diff --git a/accounts/abi/abi.go b/accounts/abi/abi.go
index 8da52c067..8adc0f014 100644
--- a/accounts/abi/abi.go
+++ b/accounts/abi/abi.go
@@ -80,39 +80,59 @@ func (abi ABI) Pack(name string, args ...interface{}) ([]byte, error) {
 	return append(method.ID, arguments...), nil
 }
 
-// Unpack output in v according to the abi specification
-func (abi ABI) Unpack(v interface{}, name string, data []byte) (err error) {
+func (abi ABI) getArguments(name string, data []byte) (Arguments, error) {
 	// since there can't be naming collisions with contracts and events,
 	// we need to decide whether we're calling a method or an event
+	var args Arguments
 	if method, ok := abi.Methods[name]; ok {
 		if len(data)%32 != 0 {
-			return fmt.Errorf("abi: improperly formatted output: %s - Bytes: [%+v]", string(data), data)
+			return nil, fmt.Errorf("abi: improperly formatted output: %s - Bytes: [%+v]", string(data), data)
 		}
-		return method.Outputs.Unpack(v, data)
+		args = method.Outputs
 	}
 	if event, ok := abi.Events[name]; ok {
-		return event.Inputs.Unpack(v, data)
+		args = event.Inputs
 	}
-	return fmt.Errorf("abi: could not locate named method or event")
+	if args == nil {
+		return nil, errors.New("abi: could not locate named method or event")
+	}
+	return args, nil
 }
 
-// UnpackIntoMap unpacks a log into the provided map[string]interface{}
-func (abi ABI) UnpackIntoMap(v map[string]interface{}, name string, data []byte) (err error) {
-	// since there can't be naming collisions with contracts and events,
-	// we need to decide whether we're calling a method or an event
-	if method, ok := abi.Methods[name]; ok {
-		if len(data)%32 != 0 {
-			return fmt.Errorf("abi: improperly formatted output")
-		}
-		return method.Outputs.UnpackIntoMap(v, data)
+// Unpack unpacks the output according to the abi specification.
+func (abi ABI) Unpack(name string, data []byte) ([]interface{}, error) {
+	args, err := abi.getArguments(name, data)
+	if err != nil {
+		return nil, err
 	}
-	if event, ok := abi.Events[name]; ok {
-		return event.Inputs.UnpackIntoMap(v, data)
+	return args.Unpack(data)
+}
+
+// UnpackIntoInterface unpacks the output in v according to the abi specification.
+// It performs an additional copy. Please only use, if you want to unpack into a
+// structure that does not strictly conform to the abi structure (e.g. has additional arguments)
+func (abi ABI) UnpackIntoInterface(v interface{}, name string, data []byte) error {
+	args, err := abi.getArguments(name, data)
+	if err != nil {
+		return err
+	}
+	unpacked, err := args.Unpack(data)
+	if err != nil {
+		return err
+	}
+	return args.Copy(v, unpacked)
+}
+
+// UnpackIntoMap unpacks a log into the provided map[string]interface{}.
+func (abi ABI) UnpackIntoMap(v map[string]interface{}, name string, data []byte) (err error) {
+	args, err := abi.getArguments(name, data)
+	if err != nil {
+		return err
 	}
-	return fmt.Errorf("abi: could not locate named method or event")
+	return args.UnpackIntoMap(v, data)
 }
 
-// UnmarshalJSON implements json.Unmarshaler interface
+// UnmarshalJSON implements json.Unmarshaler interface.
 func (abi *ABI) UnmarshalJSON(data []byte) error {
 	var fields []struct {
 		Type    string
@@ -201,8 +221,8 @@ func (abi *ABI) overloadedEventName(rawName string) string {
 	return name
 }
 
-// MethodById looks up a method by the 4-byte id
-// returns nil if none found
+// MethodById looks up a method by the 4-byte id,
+// returns nil if none found.
 func (abi *ABI) MethodById(sigdata []byte) (*Method, error) {
 	if len(sigdata) < 4 {
 		return nil, fmt.Errorf("data too short (%d bytes) for abi method lookup", len(sigdata))
@@ -250,10 +270,10 @@ func UnpackRevert(data []byte) (string, error) {
 	if !bytes.Equal(data[:4], revertSelector) {
 		return "", errors.New("invalid data for unpacking")
 	}
-	var reason string
 	typ, _ := NewType("string", "", nil)
-	if err := (Arguments{{Type: typ}}).Unpack(&reason, data[4:]); err != nil {
+	unpacked, err := (Arguments{{Type: typ}}).Unpack(data[4:])
+	if err != nil {
 		return "", err
 	}
-	return reason, nil
+	return unpacked[0].(string), nil
 }
diff --git a/accounts/abi/argument.go b/accounts/abi/argument.go
index f954b0e71..04dbdbd51 100644
--- a/accounts/abi/argument.go
+++ b/accounts/abi/argument.go
@@ -75,32 +75,24 @@ func (arguments Arguments) isTuple() bool {
 	return len(arguments) > 1
 }
 
-// Unpack performs the operation hexdata -> Go format
-func (arguments Arguments) Unpack(v interface{}, data []byte) error {
+// Unpack performs the operation hexdata -> Go format.
+func (arguments Arguments) Unpack(data []byte) ([]interface{}, error) {
 	if len(data) == 0 {
 		if len(arguments) != 0 {
-			return fmt.Errorf("abi: attempting to unmarshall an empty string while arguments are expected")
+			return nil, fmt.Errorf("abi: attempting to unmarshall an empty string while arguments are expected")
 		}
-		return nil // Nothing to unmarshal, return
-	}
-	// make sure the passed value is arguments pointer
-	if reflect.Ptr != reflect.ValueOf(v).Kind() {
-		return fmt.Errorf("abi: Unpack(non-pointer %T)", v)
-	}
-	marshalledValues, err := arguments.UnpackValues(data)
-	if err != nil {
-		return err
-	}
-	if len(marshalledValues) == 0 {
-		return fmt.Errorf("abi: Unpack(no-values unmarshalled %T)", v)
-	}
-	if arguments.isTuple() {
-		return arguments.unpackTuple(v, marshalledValues)
+		// Nothing to unmarshal, return default variables
+		nonIndexedArgs := arguments.NonIndexed()
+		defaultVars := make([]interface{}, len(nonIndexedArgs))
+		for index, arg := range nonIndexedArgs {
+			defaultVars[index] = reflect.New(arg.Type.GetType())
+		}
+		return defaultVars, nil
 	}
-	return arguments.unpackAtomic(v, marshalledValues[0])
+	return arguments.UnpackValues(data)
 }
 
-// UnpackIntoMap performs the operation hexdata -> mapping of argument name to argument value
+// UnpackIntoMap performs the operation hexdata -> mapping of argument name to argument value.
 func (arguments Arguments) UnpackIntoMap(v map[string]interface{}, data []byte) error {
 	// Make sure map is not nil
 	if v == nil {
@@ -122,8 +114,26 @@ func (arguments Arguments) UnpackIntoMap(v map[string]interface{}, data []byte)
 	return nil
 }
 
+// Copy performs the operation go format -> provided struct.
+func (arguments Arguments) Copy(v interface{}, values []interface{}) error {
+	// make sure the passed value is arguments pointer
+	if reflect.Ptr != reflect.ValueOf(v).Kind() {
+		return fmt.Errorf("abi: Unpack(non-pointer %T)", v)
+	}
+	if len(values) == 0 {
+		if len(arguments) != 0 {
+			return fmt.Errorf("abi: attempting to copy no values while %d arguments are expected", len(arguments))
+		}
+		return nil // Nothing to copy, return
+	}
+	if arguments.isTuple() {
+		return arguments.copyTuple(v, values)
+	}
+	return arguments.copyAtomic(v, values[0])
+}
+
 // unpackAtomic unpacks ( hexdata -> go ) a single value
-func (arguments Arguments) unpackAtomic(v interface{}, marshalledValues interface{}) error {
+func (arguments Arguments) copyAtomic(v interface{}, marshalledValues interface{}) error {
 	dst := reflect.ValueOf(v).Elem()
 	src := reflect.ValueOf(marshalledValues)
 
@@ -133,8 +143,8 @@ func (arguments Arguments) unpackAtomic(v interface{}, marshalledValues interfac
 	return set(dst, src)
 }
 
-// unpackTuple unpacks ( hexdata -> go ) a batch of values.
-func (arguments Arguments) unpackTuple(v interface{}, marshalledValues []interface{}) error {
+// copyTuple copies a batch of values from marshalledValues to v.
+func (arguments Arguments) copyTuple(v interface{}, marshalledValues []interface{}) error {
 	value := reflect.ValueOf(v).Elem()
 	nonIndexedArgs := arguments.NonIndexed()
 
@@ -207,13 +217,13 @@ func (arguments Arguments) UnpackValues(data []byte) ([]interface{}, error) {
 	return retval, nil
 }
 
-// PackValues performs the operation Go format -> Hexdata
-// It is the semantic opposite of UnpackValues
+// PackValues performs the operation Go format -> Hexdata.
+// It is the semantic opposite of UnpackValues.
 func (arguments Arguments) PackValues(args []interface{}) ([]byte, error) {
 	return arguments.Pack(args...)
 }
 
-// Pack performs the operation Go format -> Hexdata
+// Pack performs the operation Go format -> Hexdata.
 func (arguments Arguments) Pack(args ...interface{}) ([]byte, error) {
 	// Make sure arguments match up and pack them
 	abiArgs := arguments
diff --git a/accounts/abi/bind/auth.go b/accounts/abi/bind/auth.go
index 97733020e..9b4806b53 100644
--- a/accounts/abi/bind/auth.go
+++ b/accounts/abi/bind/auth.go
@@ -19,19 +19,31 @@ package bind
 import (
 	"crypto/ecdsa"
 	"errors"
+	"github.com/truechain/truechain-engineering-code/accounts/external"
 	"io"
 	"io/ioutil"
+	"math/big"
 
-	"github.com/truechain/truechain-engineering-code/common"
-	"github.com/truechain/truechain-engineering-code/crypto"
 	"github.com/truechain/truechain-engineering-code/accounts"
 	"github.com/truechain/truechain-engineering-code/accounts/keystore"
+	"github.com/truechain/truechain-engineering-code/common"
 	"github.com/truechain/truechain-engineering-code/core/types"
+	"github.com/truechain/truechain-engineering-code/crypto"
+	"github.com/truechain/truechain-engineering-code/log"
 )
 
+// ErrNoChainID is returned whenever the user failed to specify a chain id.
+var ErrNoChainID = errors.New("no chain id specified")
+
+// ErrNotAuthorized is returned when an account is not properly unlocked.
+var ErrNotAuthorized = errors.New("not authorized to sign this account")
+
 // NewTransactor is a utility method to easily create a transaction signer from
 // an encrypted json key stream and the associated passphrase.
+//
+// Deprecated: Use NewTransactorWithChainID instead.
 func NewTransactor(keyin io.Reader, passphrase string) (*TransactOpts, error) {
+	log.Warn("WARNING: NewTransactor has been deprecated in favour of NewTransactorWithChainID")
 	json, err := ioutil.ReadAll(keyin)
 	if err != nil {
 		return nil, err
@@ -44,13 +56,17 @@ func NewTransactor(keyin io.Reader, passphrase string) (*TransactOpts, error) {
 }
 
 // NewKeyStoreTransactor is a utility method to easily create a transaction signer from
-// an decrypted key from a keystore
+// an decrypted key from a keystore.
+//
+// Deprecated: Use NewKeyStoreTransactorWithChainID instead.
 func NewKeyStoreTransactor(keystore *keystore.KeyStore, account accounts.Account) (*TransactOpts, error) {
+	log.Warn("WARNING: NewKeyStoreTransactor has been deprecated in favour of NewTransactorWithChainID")
+	signer := types.TIP1Signer{}
 	return &TransactOpts{
 		From: account.Address,
-		Signer: func(signer types.Signer, address common.Address, tx *types.Transaction) (*types.Transaction, error) {
+		Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) {
 			if address != account.Address {
-				return nil, errors.New("not authorized to sign this account")
+				return nil, ErrNotAuthorized
 			}
 			signature, err := keystore.SignHash(account, signer.Hash(tx).Bytes())
 			if err != nil {
@@ -63,13 +79,17 @@ func NewKeyStoreTransactor(keystore *keystore.KeyStore, account accounts.Account
 
 // NewKeyedTransactor is a utility method to easily create a transaction signer
 // from a single private key.
+//
+// Deprecated: Use NewKeyedTransactorWithChainID instead.
 func NewKeyedTransactor(key *ecdsa.PrivateKey) *TransactOpts {
+	log.Warn("WARNING: NewKeyedTransactor has been deprecated in favour of NewKeyedTransactorWithChainID")
 	keyAddr := crypto.PubkeyToAddress(key.PublicKey)
+	signer := types.TIP1Signer{}
 	return &TransactOpts{
 		From: keyAddr,
-		Signer: func(signer types.Signer, address common.Address, tx *types.Transaction) (*types.Transaction, error) {
+		Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) {
 			if address != keyAddr {
-				return nil, errors.New("not authorized to sign this account")
+				return nil, ErrNotAuthorized
 			}
 			signature, err := crypto.Sign(signer.Hash(tx).Bytes(), key)
 			if err != nil {
@@ -80,16 +100,75 @@ func NewKeyedTransactor(key *ecdsa.PrivateKey) *TransactOpts {
 	}
 }
 
+// NewTransactorWithChainID is a utility method to easily create a transaction signer from
+// an encrypted json key stream and the associated passphrase.
+func NewTransactorWithChainID(keyin io.Reader, passphrase string, chainID *big.Int) (*TransactOpts, error) {
+	json, err := ioutil.ReadAll(keyin)
+	if err != nil {
+		return nil, err
+	}
+	key, err := keystore.DecryptKey(json, passphrase)
+	if err != nil {
+		return nil, err
+	}
+	return NewKeyedTransactorWithChainID(key.PrivateKey, chainID)
+}
+
+// NewKeyStoreTransactorWithChainID is a utility method to easily create a transaction signer from
+// an decrypted key from a keystore.
+func NewKeyStoreTransactorWithChainID(keystore *keystore.KeyStore, account accounts.Account, chainID *big.Int) (*TransactOpts, error) {
+	if chainID == nil {
+		return nil, ErrNoChainID
+	}
+	signer := types.LatestSignerForChainID(chainID)
+	return &TransactOpts{
+		From: account.Address,
+		Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) {
+			if address != account.Address {
+				return nil, ErrNotAuthorized
+			}
+			signature, err := keystore.SignHash(account, signer.Hash(tx).Bytes())
+			if err != nil {
+				return nil, err
+			}
+			return tx.WithSignature(signer, signature)
+		},
+	}, nil
+}
+
+// NewKeyedTransactorWithChainID is a utility method to easily create a transaction signer
+// from a single private key.
+func NewKeyedTransactorWithChainID(key *ecdsa.PrivateKey, chainID *big.Int) (*TransactOpts, error) {
+	keyAddr := crypto.PubkeyToAddress(key.PublicKey)
+	if chainID == nil {
+		return nil, ErrNoChainID
+	}
+	signer := types.LatestSignerForChainID(chainID)
+	return &TransactOpts{
+		From: keyAddr,
+		Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) {
+			if address != keyAddr {
+				return nil, ErrNotAuthorized
+			}
+			signature, err := crypto.Sign(signer.Hash(tx).Bytes(), key)
+			if err != nil {
+				return nil, err
+			}
+			return tx.WithSignature(signer, signature)
+		},
+	}, nil
+}
+
 // NewClefTransactor is a utility method to easily create a transaction signer
 // with a clef backend.
-// func NewClefTransactor(clef *external.ExternalSigner, account accounts.Account) *TransactOpts {
-// 	return &TransactOpts{
-// 		From: account.Address,
-// 		Signer: func(signer types.Signer, address common.Address, transaction *types.Transaction) (*types.Transaction, error) {
-// 			if address != account.Address {
-// 				return nil, errors.New("not authorized to sign this account")
-// 			}
-// 			return clef.SignTx(account, transaction, nil) // Clef enforces its own chain id
-// 		},
-// 	}
-// }
+func NewClefTransactor(clef *external.ExternalSigner, account accounts.Account) *TransactOpts {
+	return &TransactOpts{
+		From: account.Address,
+		Signer: func(address common.Address, transaction *types.Transaction) (*types.Transaction, error) {
+			if address != account.Address {
+				return nil, ErrNotAuthorized
+			}
+			return clef.SignTx(account, transaction, nil) // Clef enforces its own chain id
+		},
+	}
+}
diff --git a/accounts/abi/bind/backend.go b/accounts/abi/bind/backend.go
index 6134a691c..68347bf9d 100644
--- a/accounts/abi/bind/backend.go
+++ b/accounts/abi/bind/backend.go
@@ -21,8 +21,8 @@ import (
 	"errors"
 	"math/big"
 
-	"github.com/truechain/truechain-engineering-code/common"
 	truechain "github.com/truechain/truechain-engineering-code"
+	"github.com/truechain/truechain-engineering-code/common"
 	"github.com/truechain/truechain-engineering-code/core/types"
 )
 
@@ -32,22 +32,23 @@ var (
 	// have any code associated with it (i.e. suicided).
 	ErrNoCode = errors.New("no contract code at given address")
 
-	// This error is raised when attempting to perform a pending state action
+	// ErrNoPendingState is raised when attempting to perform a pending state action
 	// on a backend that doesn't implement PendingContractCaller.
 	ErrNoPendingState = errors.New("backend does not support pending state")
 
-	// This error is returned by WaitDeployed if contract creation leaves an
-	// empty contract behind.
+	// ErrNoCodeAfterDeploy is returned by WaitDeployed if contract creation leaves
+	// an empty contract behind.
 	ErrNoCodeAfterDeploy = errors.New("no contract code after deployment")
 )
 
-// ContractCaller defines the methods needed to allow operating with contract on a read
+// ContractCaller defines the methods needed to allow operating with a contract on a read
 // only basis.
 type ContractCaller interface {
 	// CodeAt returns the code of the given account. This is needed to differentiate
 	// between contract internal errors and the local chain being out of sync.
 	CodeAt(ctx context.Context, contract common.Address, blockNumber *big.Int) ([]byte, error)
-	// ContractCall executes an Ethereum contract call with the specified data as the
+
+	// CallContract executes an Ethereum contract call with the specified data as the
 	// input.
 	CallContract(ctx context.Context, call truechain.CallMsg, blockNumber *big.Int) ([]byte, error)
 }
@@ -58,22 +59,34 @@ type ContractCaller interface {
 type PendingContractCaller interface {
 	// PendingCodeAt returns the code of the given account in the pending state.
 	PendingCodeAt(ctx context.Context, contract common.Address) ([]byte, error)
+
 	// PendingCallContract executes an Ethereum contract call against the pending state.
 	PendingCallContract(ctx context.Context, call truechain.CallMsg) ([]byte, error)
 }
 
-// ContractTransactor defines the methods needed to allow operating with contract
-// on a write only basis. Beside the transacting method, the remainder are helpers
+// ContractTransactor defines the methods needed to allow operating with a contract
+// on a write only basis. Besides the transacting method, the remainder are helpers
 // used when the user does not provide some needed values, but rather leaves it up
 // to the transactor to decide.
 type ContractTransactor interface {
+	// HeaderByNumber returns a block header from the current canonical chain. If
+	// number is nil, the latest known header is returned.
+	HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error)
+
 	// PendingCodeAt returns the code of the given account in the pending state.
 	PendingCodeAt(ctx context.Context, account common.Address) ([]byte, error)
+
 	// PendingNonceAt retrieves the current pending nonce associated with an account.
 	PendingNonceAt(ctx context.Context, account common.Address) (uint64, error)
+
 	// SuggestGasPrice retrieves the currently suggested gas price to allow a timely
 	// execution of a transaction.
 	SuggestGasPrice(ctx context.Context) (*big.Int, error)
+
+	// SuggestGasTipCap retrieves the currently suggested 1559 priority fee to allow
+	// a timely execution of a transaction.
+	SuggestGasTipCap(ctx context.Context) (*big.Int, error)
+
 	// EstimateGas tries to estimate the gas needed to execute a specific
 	// transaction based on the current pending state of the backend blockchain.
 	// There is no guarantee that this is the true gas limit requirement as other
diff --git a/accounts/abi/bind/base.go b/accounts/abi/bind/base.go
index 4121fc70d..1f1f98627 100644
--- a/accounts/abi/bind/base.go
+++ b/accounts/abi/bind/base.go
@@ -20,7 +20,6 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"github.com/truechain/truechain-engineering-code/params"
 	"math/big"
 
 	truechain "github.com/truechain/truechain-engineering-code"
@@ -33,7 +32,7 @@ import (
 
 // SignerFn is a signer function callback when a contract requires a method to
 // sign the transaction before submission.
-type SignerFn func(types.Signer, common.Address, *types.Transaction) (*types.Transaction, error)
+type SignerFn func(common.Address, *types.Transaction) (*types.Transaction, error)
 
 // CallOpts is the collection of options to fine tune a contract call request.
 type CallOpts struct {
@@ -50,11 +49,15 @@ type TransactOpts struct {
 	Nonce  *big.Int       // Nonce to use for the transaction execution (nil = use pending state)
 	Signer SignerFn       // Method to use for signing the transaction (mandatory)
 
-	Value    *big.Int // Funds to transfer along the transaction (nil = 0 = no funds)
-	GasPrice *big.Int // Gas price to use for the transaction execution (nil = gas price oracle)
-	GasLimit uint64   // Gas limit to set for the transaction execution (0 = estimate)
+	Value     *big.Int // Funds to transfer along the transaction (nil = 0 = no funds)
+	GasPrice  *big.Int // Gas price to use for the transaction execution (nil = gas price oracle)
+	GasFeeCap *big.Int // Gas fee cap to use for the 1559 transaction execution (nil = gas price oracle)
+	GasTipCap *big.Int // Gas priority fee cap to use for the 1559 transaction execution (nil = gas price oracle)
+	GasLimit  uint64   // Gas limit to set for the transaction execution (0 = estimate)
 
 	Context context.Context // Network context to support cancellation and timeouts (nil = no timeout)
+
+	NoSend bool // Do all transact steps but do not send the transaction
 }
 
 // FilterOpts is the collection of options to fine tune filtering for events
@@ -118,11 +121,14 @@ func DeployContract(opts *TransactOpts, abi abi.ABI, bytecode []byte, backend Co
 // sets the output to result. The result type might be a single field for simple
 // returns, a slice of interfaces for anonymous returns and a struct for named
 // returns.
-func (c *BoundContract) Call(opts *CallOpts, result interface{}, method string, params ...interface{}) error {
+func (c *BoundContract) Call(opts *CallOpts, results *[]interface{}, method string, params ...interface{}) error {
 	// Don't crash on a lazy user
 	if opts == nil {
 		opts = new(CallOpts)
 	}
+	if results == nil {
+		results = new([]interface{})
+	}
 	// Pack the input, call and unpack the results
 	input, err := c.abi.Pack(method, params...)
 	if err != nil {
@@ -150,7 +156,10 @@ func (c *BoundContract) Call(opts *CallOpts, result interface{}, method string,
 		}
 	} else {
 		output, err = c.caller.CallContract(ctx, msg, opts.BlockNumber)
-		if err == nil && len(output) == 0 {
+		if err != nil {
+			return err
+		}
+		if len(output) == 0 {
 			// Make sure we have a contract to operate on, and bail out otherwise.
 			if code, err = c.caller.CodeAt(ctx, c.address, opts.BlockNumber); err != nil {
 				return err
@@ -159,10 +168,14 @@ func (c *BoundContract) Call(opts *CallOpts, result interface{}, method string,
 			}
 		}
 	}
-	if err != nil {
+
+	if len(*results) == 0 {
+		res, err := c.abi.Unpack(method, output)
+		*results = res
 		return err
 	}
-	return c.abi.Unpack(result, method, output)
+	res := *results
+	return c.abi.UnpackIntoInterface(res[0], method, output)
 }
 
 // Transact invokes the (paid) contract method with params as input values.
@@ -178,7 +191,7 @@ func (c *BoundContract) Transact(opts *TransactOpts, method string, params ...in
 }
 
 // RawTransact initiates a transaction with the given raw calldata as the input.
-// It's usually used to initiates transaction for invoking **Fallback** function.
+// It's usually used to initiate transactions for invoking **Fallback** function.
 func (c *BoundContract) RawTransact(opts *TransactOpts, calldata []byte) (*types.Transaction, error) {
 	// todo(rjl493456442) check the method is payable or not,
 	// reject invalid transaction at the first place
@@ -212,12 +225,42 @@ func (c *BoundContract) transact(opts *TransactOpts, contract *common.Address, i
 	} else {
 		nonce = opts.Nonce.Uint64()
 	}
-	// Figure out the gas allowance and gas price values
-	gasPrice := opts.GasPrice
-	if gasPrice == nil {
-		gasPrice, err = c.transactor.SuggestGasPrice(ensureContext(opts.Context))
-		if err != nil {
-			return nil, fmt.Errorf("failed to suggest gas price: %v", err)
+	// Figure out reasonable gas price values
+	if opts.GasPrice != nil && (opts.GasFeeCap != nil || opts.GasTipCap != nil) {
+		return nil, errors.New("both gasPrice and (maxFeePerGas or maxPriorityFeePerGas) specified")
+	}
+	head, err := c.transactor.HeaderByNumber(ensureContext(opts.Context), nil)
+	if err != nil {
+		return nil, err
+	}
+	if head.BaseFee != nil && opts.GasPrice == nil {
+		if opts.GasTipCap == nil {
+			tip, err := c.transactor.SuggestGasTipCap(ensureContext(opts.Context))
+			if err != nil {
+				return nil, err
+			}
+			opts.GasTipCap = tip
+		}
+		if opts.GasFeeCap == nil {
+			gasFeeCap := new(big.Int).Add(
+				opts.GasTipCap,
+				new(big.Int).Mul(head.BaseFee, big.NewInt(2)),
+			)
+			opts.GasFeeCap = gasFeeCap
+		}
+		if opts.GasFeeCap.Cmp(opts.GasTipCap) < 0 {
+			return nil, fmt.Errorf("maxFeePerGas (%v) < maxPriorityFeePerGas (%v)", opts.GasFeeCap, opts.GasTipCap)
+		}
+	} else {
+		if opts.GasFeeCap != nil || opts.GasTipCap != nil {
+			return nil, errors.New("maxFeePerGas or maxPriorityFeePerGas specified but london is not active yet")
+		}
+		if opts.GasPrice == nil {
+			price, err := c.transactor.SuggestGasPrice(ensureContext(opts.Context))
+			if err != nil {
+				return nil, err
+			}
+			opts.GasPrice = price
 		}
 	}
 	gasLimit := opts.GasLimit
@@ -231,7 +274,7 @@ func (c *BoundContract) transact(opts *TransactOpts, contract *common.Address, i
 			}
 		}
 		// If the contract surely has code (or code is not needed), estimate the transaction
-		msg := truechain.CallMsg{From: opts.From, To: contract, GasPrice: gasPrice, Value: value, Data: input}
+		msg := truechain.CallMsg{From: opts.From, To: contract, GasPrice: opts.GasPrice, Value: value, Data: input}
 		gasLimit, err = c.transactor.EstimateGas(ensureContext(opts.Context), msg)
 		if err != nil {
 			return nil, fmt.Errorf("failed to estimate gas needed: %v", err)
@@ -240,14 +283,14 @@ func (c *BoundContract) transact(opts *TransactOpts, contract *common.Address, i
 	// Create the transaction, sign it and schedule it for execution
 	var rawTx *types.Transaction
 	if contract == nil {
-		rawTx = types.NewContractCreation(nonce, value, gasLimit, gasPrice, input)
+		rawTx = types.NewContractCreation(nonce, value, gasLimit, opts.GasPrice, input)
 	} else {
-		rawTx = types.NewTransaction(nonce, c.address, value, gasLimit, gasPrice, input)
+		rawTx = types.NewTransaction(nonce, c.address, value, gasLimit, opts.GasPrice, input)
 	}
 	if opts.Signer == nil {
 		return nil, errors.New("no signer to authorize the transaction with")
 	}
-	signedTx, err := opts.Signer(types.NewTIP1Signer(params.AllMinervaProtocolChanges.ChainID), opts.From, rawTx)
+	signedTx, err := opts.Signer(opts.From, rawTx)
 	if err != nil {
 		return nil, err
 	}
@@ -340,7 +383,7 @@ func (c *BoundContract) WatchLogs(opts *WatchOpts, name string, query ...[]inter
 // UnpackLog unpacks a retrieved log into the provided output structure.
 func (c *BoundContract) UnpackLog(out interface{}, event string, log types.Log) error {
 	if len(log.Data) > 0 {
-		if err := c.abi.Unpack(out, event, log.Data); err != nil {
+		if err := c.abi.UnpackIntoInterface(out, event, log.Data); err != nil {
 			return err
 		}
 	}
@@ -373,7 +416,7 @@ func (c *BoundContract) UnpackLogIntoMap(out map[string]interface{}, event strin
 // user specified it as such.
 func ensureContext(ctx context.Context) context.Context {
 	if ctx == nil {
-		return context.TODO()
+		return context.Background()
 	}
 	return ctx
 }
diff --git a/accounts/abi/bind/base_test.go b/accounts/abi/bind/base_test.go
index e9e65d5ad..a61cc05cd 100644
--- a/accounts/abi/bind/base_test.go
+++ b/accounts/abi/bind/base_test.go
@@ -71,11 +71,10 @@ func TestPassingBlockNumber(t *testing.T) {
 			},
 		},
 	}, mc, nil, nil)
-	var ret string
 
 	blockNumber := big.NewInt(42)
 
-	bc.Call(&bind.CallOpts{BlockNumber: blockNumber}, &ret, "something")
+	bc.Call(&bind.CallOpts{BlockNumber: blockNumber}, nil, "something")
 
 	if mc.callContractBlockNumber != blockNumber {
 		t.Fatalf("CallContract() was not passed the block number")
@@ -85,7 +84,7 @@ func TestPassingBlockNumber(t *testing.T) {
 		t.Fatalf("CodeAt() was not passed the block number")
 	}
 
-	bc.Call(&bind.CallOpts{}, &ret, "something")
+	bc.Call(&bind.CallOpts{}, nil, "something")
 
 	if mc.callContractBlockNumber != nil {
 		t.Fatalf("CallContract() was passed a block number when it should not have been")
@@ -95,7 +94,7 @@ func TestPassingBlockNumber(t *testing.T) {
 		t.Fatalf("CodeAt() was passed a block number when it should not have been")
 	}
 
-	bc.Call(&bind.CallOpts{BlockNumber: blockNumber, Pending: true}, &ret, "something")
+	bc.Call(&bind.CallOpts{BlockNumber: blockNumber, Pending: true}, nil, "something")
 
 	if !mc.pendingCallContractCalled {
 		t.Fatalf("CallContract() was not passed the block number")
diff --git a/accounts/abi/bind/template.go b/accounts/abi/bind/template.go
index b299b5c98..087a41399 100644
--- a/accounts/abi/bind/template.go
+++ b/accounts/abi/bind/template.go
@@ -30,7 +30,7 @@ type tmplData struct {
 type tmplContract struct {
 	Type        string                 // Type name of the main contract binding
 	InputABI    string                 // JSON ABI used as the input to generate the binding from
-	InputBin    string                 // Optional EVM bytecode used to denetare deploy code from
+	InputBin    string                 // Optional EVM bytecode used to generate deploy code from
 	FuncSigs    map[string]string      // Optional map: string signature -> 4-byte signature
 	Constructor abi.Method             // Contract constructor for deploy parametrization
 	Calls       map[string]*tmplMethod // Contract calls that only read state data
@@ -50,7 +50,8 @@ type tmplMethod struct {
 	Structured bool       // Whether the returns should be accumulated into a struct
 }
 
-// tmplEvent is a wrapper around an a
+// tmplEvent is a wrapper around an abi.Event that contains a few preprocessed
+// and cached data fields.
 type tmplEvent struct {
 	Original   abi.Event // Original event as parsed by the abi package
 	Normalized abi.Event // Normalized version of the parsed fields
@@ -64,7 +65,7 @@ type tmplField struct {
 	SolKind abi.Type // Raw abi type information
 }
 
-// tmplStruct is a wrapper around an abi.tuple contains an auto-generated
+// tmplStruct is a wrapper around an abi.tuple and contains an auto-generated
 // struct name.
 type tmplStruct struct {
 	Name   string       // Auto-generated struct name(before solidity v0.5.11) or raw name.
@@ -78,8 +79,8 @@ var tmplSource = map[Lang]string{
 	LangJava: tmplSourceJava,
 }
 
-// tmplSourceGo is the Go source template use to generate the contract binding
-// based on.
+// tmplSourceGo is the Go source template that the generated Go contract binding
+// is based on.
 const tmplSourceGo = `
 // Code generated - DO NOT EDIT.
 // This file is a generated binding and any manual changes will be lost.
@@ -260,7 +261,7 @@ var (
 	// sets the output to result. The result type might be a single field for simple
 	// returns, a slice of interfaces for anonymous returns and a struct for named
 	// returns.
-	func (_{{$contract.Type}} *{{$contract.Type}}Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
+	func (_{{$contract.Type}} *{{$contract.Type}}Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
 		return _{{$contract.Type}}.Contract.{{$contract.Type}}Caller.contract.Call(opts, result, method, params...)
 	}
 
@@ -279,7 +280,7 @@ var (
 	// sets the output to result. The result type might be a single field for simple
 	// returns, a slice of interfaces for anonymous returns and a struct for named
 	// returns.
-	func (_{{$contract.Type}} *{{$contract.Type}}CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
+	func (_{{$contract.Type}} *{{$contract.Type}}CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
 		return _{{$contract.Type}}.Contract.contract.Call(opts, result, method, params...)
 	}
 
@@ -299,19 +300,26 @@ var (
 		//
 		// Solidity: {{.Original.String}}
 		func (_{{$contract.Type}} *{{$contract.Type}}Caller) {{.Normalized.Name}}(opts *bind.CallOpts {{range .Normalized.Inputs}}, {{.Name}} {{bindtype .Type $structs}} {{end}}) ({{if .Structured}}struct{ {{range .Normalized.Outputs}}{{.Name}} {{bindtype .Type $structs}};{{end}} },{{else}}{{range .Normalized.Outputs}}{{bindtype .Type $structs}},{{end}}{{end}} error) {
-			{{if .Structured}}ret := new(struct{
-				{{range .Normalized.Outputs}}{{.Name}} {{bindtype .Type $structs}}
-				{{end}}
-			}){{else}}var (
-				{{range $i, $_ := .Normalized.Outputs}}ret{{$i}} = new({{bindtype .Type $structs}})
-				{{end}}
-			){{end}}
-			out := {{if .Structured}}ret{{else}}{{if eq (len .Normalized.Outputs) 1}}ret0{{else}}&[]interface{}{
-				{{range $i, $_ := .Normalized.Outputs}}ret{{$i}},
-				{{end}}
-			}{{end}}{{end}}
-			err := _{{$contract.Type}}.contract.Call(opts, out, "{{.Original.Name}}" {{range .Normalized.Inputs}}, {{.Name}}{{end}})
-			return {{if .Structured}}*ret,{{else}}{{range $i, $_ := .Normalized.Outputs}}*ret{{$i}},{{end}}{{end}} err
+			var out []interface{}
+			err := _{{$contract.Type}}.contract.Call(opts, &out, "{{.Original.Name}}" {{range .Normalized.Inputs}}, {{.Name}}{{end}})
+			{{if .Structured}}
+			outstruct := new(struct{ {{range .Normalized.Outputs}} {{.Name}} {{bindtype .Type $structs}}; {{end}} })
+			if err != nil {
+				return *outstruct, err
+			}
+			{{range $i, $t := .Normalized.Outputs}} 
+			outstruct.{{.Name}} = *abi.ConvertType(out[{{$i}}], new({{bindtype .Type $structs}})).(*{{bindtype .Type $structs}}){{end}}
+
+			return *outstruct, err
+			{{else}}
+			if err != nil {
+				return {{range $i, $_ := .Normalized.Outputs}}*new({{bindtype .Type $structs}}), {{end}} err
+			}
+			{{range $i, $t := .Normalized.Outputs}}
+			out{{$i}} := *abi.ConvertType(out[{{$i}}], new({{bindtype .Type $structs}})).(*{{bindtype .Type $structs}}){{end}}
+			
+			return {{range $i, $t := .Normalized.Outputs}}out{{$i}}, {{end}} err
+			{{end}}
 		}
 
 		// {{.Normalized.Name}} is a free data retrieval call binding the contract method 0x{{printf "%x" .Original.ID}}.
@@ -536,6 +544,7 @@ var (
 			if err := _{{$contract.Type}}.contract.UnpackLog(event, "{{.Original.Name}}", log); err != nil {
 				return nil, err
 			}
+			event.Raw = log
 			return event, nil
 		}
 
@@ -543,8 +552,8 @@ var (
 {{end}}
 `
 
-// tmplSourceJava is the Java source template use to generate the contract binding
-// based on.
+// tmplSourceJava is the Java source template that the generated Java contract binding
+// is based on.
 const tmplSourceJava = `
 // This file is an automatically generated Java binding. Do not modify as any
 // change will likely be lost upon the next re-generation!
diff --git a/accounts/abi/bind/util_test.go b/accounts/abi/bind/util_test.go
index 5a273625b..d65279e58 100644
--- a/accounts/abi/bind/util_test.go
+++ b/accounts/abi/bind/util_test.go
@@ -53,16 +53,19 @@ var waitDeployedTests = map[string]struct {
 func TestWaitDeployed(t *testing.T) {
 	for name, test := range waitDeployedTests {
 		backend := backends.NewSimulatedBackend(
-			types.GenesisAlloc{
-				crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(10000000000)},
+			core.GenesisAlloc{
+				crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(10000000000000000)},
 			},
 			10000000,
 		)
 		defer backend.Close()
 
-		// Create the transaction.
-		tx := types.NewContractCreation(0, big.NewInt(0), test.gas, big.NewInt(1), common.FromHex(test.code))
-		tx, _ = types.SignTx(tx, types.NewTIP1Signer(params.TestChainConfig.ChainID), testKey)
+		// Create the transaction
+		head, _ := backend.HeaderByNumber(context.Background(), nil) // Should be child's, good enough
+		gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1))
+
+		tx := types.NewContractCreation(0, big.NewInt(0), test.gas, gasPrice, common.FromHex(test.code))
+		tx, _ = types.SignTx(tx, types.HomesteadSigner{}, testKey)
 
 		// Wait for it to get mined in the background.
 		var (
@@ -83,7 +86,7 @@ func TestWaitDeployed(t *testing.T) {
 		select {
 		case <-mined:
 			if err != test.wantErr {
-				t.Errorf("test %q: error mismatch: got %q, want %q", name, err, test.wantErr)
+				t.Errorf("test %q: error mismatch: want %q, got %q", name, test.wantErr, err)
 			}
 			if address != test.wantAddress {
 				t.Errorf("test %q: unexpected contract address %s", name, address.Hex())
@@ -93,3 +96,43 @@ func TestWaitDeployed(t *testing.T) {
 		}
 	}
 }
+
+func TestWaitDeployedCornerCases(t *testing.T) {
+	backend := backends.NewSimulatedBackend(
+		core.GenesisAlloc{
+			crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(10000000000000000)},
+		},
+		10000000,
+	)
+	defer backend.Close()
+
+	head, _ := backend.HeaderByNumber(context.Background(), nil) // Should be child's, good enough
+	gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1))
+
+	// Create a transaction to an account.
+	code := "6060604052600a8060106000396000f360606040526008565b00"
+	tx := types.NewTransaction(0, common.HexToAddress("0x01"), big.NewInt(0), 3000000, gasPrice, common.FromHex(code))
+	tx, _ = types.SignTx(tx, types.HomesteadSigner{}, testKey)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	backend.SendTransaction(ctx, tx)
+	backend.Commit()
+	notContentCreation := errors.New("tx is not contract creation")
+	if _, err := bind.WaitDeployed(ctx, backend, tx); err.Error() != notContentCreation.Error() {
+		t.Errorf("error missmatch: want %q, got %q, ", notContentCreation, err)
+	}
+
+	// Create a transaction that is not mined.
+	tx = types.NewContractCreation(1, big.NewInt(0), 3000000, gasPrice, common.FromHex(code))
+	tx, _ = types.SignTx(tx, types.HomesteadSigner{}, testKey)
+
+	go func() {
+		contextCanceled := errors.New("context canceled")
+		if _, err := bind.WaitDeployed(ctx, backend, tx); err.Error() != contextCanceled.Error() {
+			t.Errorf("error missmatch: want %q, got %q, ", contextCanceled, err)
+		}
+	}()
+
+	backend.SendTransaction(ctx, tx)
+	cancel()
+}
diff --git a/accounts/abi/error.go b/accounts/abi/error.go
index b63a215ad..f0f71b6c9 100644
--- a/accounts/abi/error.go
+++ b/accounts/abi/error.go
@@ -52,7 +52,7 @@ func sliceTypeCheck(t Type, val reflect.Value) error {
 		}
 	}
 
-	if elemKind := val.Type().Elem().Kind(); elemKind != t.Elem.GetType().Kind() {
+	if val.Type().Elem().Kind() != t.Elem.GetType().Kind() {
 		return typeErr(formatSliceString(t.Elem.GetType().Kind(), t.Size), val.Type())
 	}
 	return nil
diff --git a/accounts/abi/event.go b/accounts/abi/event.go
index d4c61db6f..9502223e5 100644
--- a/accounts/abi/event.go
+++ b/accounts/abi/event.go
@@ -32,7 +32,7 @@ type Event struct {
 	// the raw name and a suffix will be added in the case of a event overload.
 	//
 	// e.g.
-	// There are two events have same name:
+	// These are two events that have the same name:
 	// * foo(int,int)
 	// * foo(uint,uint)
 	// The event name of the first one wll be resolved as foo while the second one
diff --git a/accounts/abi/method.go b/accounts/abi/method.go
index 7c36312d1..4fa42607f 100644
--- a/accounts/abi/method.go
+++ b/accounts/abi/method.go
@@ -45,7 +45,7 @@ const (
 // If the method is `Const` no transaction needs to be created for this
 // particular Method call. It can easily be simulated using a local VM.
 // For example a `Balance()` method only needs to retrieve something
-// from the storage and therefore requires no Tx to be send to the
+// from the storage and therefore requires no Tx to be sent to the
 // network. A method such as `Transact` does require a Tx and thus will
 // be flagged `false`.
 // Input specifies the required input parameters for this gives method.
@@ -54,7 +54,7 @@ type Method struct {
 	// the raw name and a suffix will be added in the case of a function overload.
 	//
 	// e.g.
-	// There are two functions have same name:
+	// These are two functions that have the same name:
 	// * foo(int,int)
 	// * foo(uint,uint)
 	// The method name of the first one will be resolved as foo while the second one
diff --git a/accounts/abi/pack.go b/accounts/abi/pack.go
index 778d370f3..c57274e53 100644
--- a/accounts/abi/pack.go
+++ b/accounts/abi/pack.go
@@ -17,6 +17,8 @@
 package abi
 
 import (
+	"errors"
+	"fmt"
 	"math/big"
 	"reflect"
 
@@ -25,7 +27,7 @@ import (
 )
 
 // packBytesSlice packs the given bytes as [L, V] as the canonical representation
-// bytes slice
+// bytes slice.
 func packBytesSlice(bytes []byte, l int) []byte {
 	len := packNum(reflect.ValueOf(l))
 	return append(len, common.RightPadBytes(bytes, (l+31)/32*32)...)
@@ -33,39 +35,42 @@ func packBytesSlice(bytes []byte, l int) []byte {
 
 // packElement packs the given reflect value according to the abi specification in
 // t.
-func packElement(t Type, reflectValue reflect.Value) []byte {
+func packElement(t Type, reflectValue reflect.Value) ([]byte, error) {
 	switch t.T {
 	case IntTy, UintTy:
-		return packNum(reflectValue)
+		return packNum(reflectValue), nil
 	case StringTy:
-		return packBytesSlice([]byte(reflectValue.String()), reflectValue.Len())
+		return packBytesSlice([]byte(reflectValue.String()), reflectValue.Len()), nil
 	case AddressTy:
 		if reflectValue.Kind() == reflect.Array {
 			reflectValue = mustArrayToByteSlice(reflectValue)
 		}
 
-		return common.LeftPadBytes(reflectValue.Bytes(), 32)
+		return common.LeftPadBytes(reflectValue.Bytes(), 32), nil
 	case BoolTy:
 		if reflectValue.Bool() {
-			return math.PaddedBigBytes(common.Big1, 32)
+			return math.PaddedBigBytes(common.Big1, 32), nil
 		}
-		return math.PaddedBigBytes(common.Big0, 32)
+		return math.PaddedBigBytes(common.Big0, 32), nil
 	case BytesTy:
 		if reflectValue.Kind() == reflect.Array {
 			reflectValue = mustArrayToByteSlice(reflectValue)
 		}
-		return packBytesSlice(reflectValue.Bytes(), reflectValue.Len())
+		if reflectValue.Type() != reflect.TypeOf([]byte{}) {
+			return []byte{}, errors.New("Bytes type is neither slice nor array")
+		}
+		return packBytesSlice(reflectValue.Bytes(), reflectValue.Len()), nil
 	case FixedBytesTy, FunctionTy:
 		if reflectValue.Kind() == reflect.Array {
 			reflectValue = mustArrayToByteSlice(reflectValue)
 		}
-		return common.RightPadBytes(reflectValue.Bytes(), 32)
+		return common.RightPadBytes(reflectValue.Bytes(), 32), nil
 	default:
-		panic("abi: fatal error")
+		return []byte{}, fmt.Errorf("Could not pack element, unknown type: %v", t.T)
 	}
 }
 
-// packNum packs the given number (using the reflect value) and will cast it to appropriate number representation
+// packNum packs the given number (using the reflect value) and will cast it to appropriate number representation.
 func packNum(value reflect.Value) []byte {
 	switch kind := value.Kind(); kind {
 	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
@@ -77,5 +82,4 @@ func packNum(value reflect.Value) []byte {
 	default:
 		panic("abi: fatal error")
 	}
-
 }
diff --git a/accounts/abi/pack_test.go b/accounts/abi/pack_test.go
index 39c8b2c59..f62f591d3 100644
--- a/accounts/abi/pack_test.go
+++ b/accounts/abi/pack_test.go
@@ -44,18 +44,7 @@ func TestPack(t *testing.T) {
 				t.Fatalf("invalid ABI definition %s, %v", inDef, err)
 			}
 			var packed []byte
-			if reflect.TypeOf(test.unpacked).Kind() != reflect.Struct {
-				packed, err = inAbi.Pack("method", test.unpacked)
-			} else {
-				// if want is a struct we need to use the components.
-				elem := reflect.ValueOf(test.unpacked)
-				var values []interface{}
-				for i := 0; i < elem.NumField(); i++ {
-					field := elem.Field(i)
-					values = append(values, field.Interface())
-				}
-				packed, err = inAbi.Pack("method", values...)
-			}
+			packed, err = inAbi.Pack("method", test.unpacked)
 
 			if err != nil {
 				t.Fatalf("test %d (%v) failed: %v", i, test.def, err)
diff --git a/accounts/abi/packing_test.go b/accounts/abi/packing_test.go
index 5e823bac3..c9242f15f 100644
--- a/accounts/abi/packing_test.go
+++ b/accounts/abi/packing_test.go
@@ -620,7 +620,7 @@ var packUnpackTests = []packUnpackTest{
 
 	{
 		def:      `[{"type": "bytes32[]"}]`,
-		unpacked: []common.Hash{{1}, {2}},
+		unpacked: [][32]byte{{1}, {2}},
 		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
 			"0000000000000000000000000000000000000000000000000000000000000002" +
 			"0100000000000000000000000000000000000000000000000000000000000000" +
@@ -722,7 +722,7 @@ var packUnpackTests = []packUnpackTest{
 	},
 	// struct outputs
 	{
-		def: `[{"name":"int1","type":"int256"},{"name":"int2","type":"int256"}]`,
+		def: `[{"components": [{"name":"int1","type":"int256"},{"name":"int2","type":"int256"}], "type":"tuple"}]`,
 		packed: "0000000000000000000000000000000000000000000000000000000000000001" +
 			"0000000000000000000000000000000000000000000000000000000000000002",
 		unpacked: struct {
@@ -731,28 +731,28 @@ var packUnpackTests = []packUnpackTest{
 		}{big.NewInt(1), big.NewInt(2)},
 	},
 	{
-		def:    `[{"name":"int_one","type":"int256"}]`,
+		def:    `[{"components": [{"name":"int_one","type":"int256"}], "type":"tuple"}]`,
 		packed: "0000000000000000000000000000000000000000000000000000000000000001",
 		unpacked: struct {
 			IntOne *big.Int
 		}{big.NewInt(1)},
 	},
 	{
-		def:    `[{"name":"int__one","type":"int256"}]`,
+		def:    `[{"components": [{"name":"int__one","type":"int256"}], "type":"tuple"}]`,
 		packed: "0000000000000000000000000000000000000000000000000000000000000001",
 		unpacked: struct {
 			IntOne *big.Int
 		}{big.NewInt(1)},
 	},
 	{
-		def:    `[{"name":"int_one_","type":"int256"}]`,
+		def:    `[{"components": [{"name":"int_one_","type":"int256"}], "type":"tuple"}]`,
 		packed: "0000000000000000000000000000000000000000000000000000000000000001",
 		unpacked: struct {
 			IntOne *big.Int
 		}{big.NewInt(1)},
 	},
 	{
-		def: `[{"name":"int_one","type":"int256"}, {"name":"intone","type":"int256"}]`,
+		def: `[{"components": [{"name":"int_one","type":"int256"}, {"name":"intone","type":"int256"}], "type":"tuple"}]`,
 		packed: "0000000000000000000000000000000000000000000000000000000000000001" +
 			"0000000000000000000000000000000000000000000000000000000000000002",
 		unpacked: struct {
@@ -831,11 +831,11 @@ var packUnpackTests = []packUnpackTest{
 	},
 	{
 		// static tuple
-		def: `[{"name":"a","type":"int64"}, 
+		def: `[{"components": [{"name":"a","type":"int64"}, 
 		{"name":"b","type":"int256"}, 
 		{"name":"c","type":"int256"}, 
 		{"name":"d","type":"bool"},
-		{"name":"e","type":"bytes32[3][2]"}]`,
+		{"name":"e","type":"bytes32[3][2]"}], "type":"tuple"}]`,
 		unpacked: struct {
 			A int64
 			B *big.Int
@@ -855,21 +855,22 @@ var packUnpackTests = []packUnpackTest{
 			"0500000000000000000000000000000000000000000000000000000000000000", // struct[e] array[1][2]
 	},
 	{
-		def: `[{"name":"a","type":"string"}, 
+		def: `[{"components": [{"name":"a","type":"string"}, 
 		{"name":"b","type":"int64"}, 
 		{"name":"c","type":"bytes"}, 
 		{"name":"d","type":"string[]"},
 		{"name":"e","type":"int256[]"},
-		{"name":"f","type":"address[]"}]`,
+		{"name":"f","type":"address[]"}], "type":"tuple"}]`,
 		unpacked: struct {
-			FieldA string `abi:"a"` // Test whether abi tag works
-			FieldB int64  `abi:"b"`
-			C      []byte
-			D      []string
-			E      []*big.Int
-			F      []common.Address
+			A string
+			B int64
+			C []byte
+			D []string
+			E []*big.Int
+			F []common.Address
 		}{"foobar", 1, []byte{1}, []string{"foo", "bar"}, []*big.Int{big.NewInt(1), big.NewInt(-1)}, []common.Address{{1}, {2}}},
-		packed: "00000000000000000000000000000000000000000000000000000000000000c0" + // struct[a] offset
+		packed: "0000000000000000000000000000000000000000000000000000000000000020" + // struct a
+			"00000000000000000000000000000000000000000000000000000000000000c0" + // struct[a] offset
 			"0000000000000000000000000000000000000000000000000000000000000001" + // struct[b]
 			"0000000000000000000000000000000000000000000000000000000000000100" + // struct[c] offset
 			"0000000000000000000000000000000000000000000000000000000000000140" + // struct[d] offset
@@ -894,23 +895,24 @@ var packUnpackTests = []packUnpackTest{
 			"0000000000000000000000000200000000000000000000000000000000000000", // common.Address{2}
 	},
 	{
-		def: `[{"components": [{"name": "a","type": "uint256"},	
+		def: `[{"components": [{ "type": "tuple","components": [{"name": "a","type": "uint256"},	
 							{"name": "b","type": "uint256[]"}],	
 							"name": "a","type": "tuple"},
-							{"name": "b","type": "uint256[]"}]`,
+							{"name": "b","type": "uint256[]"}],  "type": "tuple"}]`,
 		unpacked: struct {
 			A struct {
-				FieldA *big.Int `abi:"a"`
-				B      []*big.Int
+				A *big.Int
+				B []*big.Int
 			}
 			B []*big.Int
 		}{
 			A: struct {
-				FieldA *big.Int `abi:"a"` // Test whether abi tag works for nested tuple
-				B      []*big.Int
+				A *big.Int
+				B []*big.Int
 			}{big.NewInt(1), []*big.Int{big.NewInt(1), big.NewInt(2)}},
 			B: []*big.Int{big.NewInt(1), big.NewInt(2)}},
-		packed: "0000000000000000000000000000000000000000000000000000000000000040" + // a offset
+		packed: "0000000000000000000000000000000000000000000000000000000000000020" + // struct a
+			"0000000000000000000000000000000000000000000000000000000000000040" + // a offset
 			"00000000000000000000000000000000000000000000000000000000000000e0" + // b offset
 			"0000000000000000000000000000000000000000000000000000000000000001" + // a.a value
 			"0000000000000000000000000000000000000000000000000000000000000040" + // a.b offset
diff --git a/accounts/abi/reflect.go b/accounts/abi/reflect.go
index 75f1a00a5..11248e073 100644
--- a/accounts/abi/reflect.go
+++ b/accounts/abi/reflect.go
@@ -24,6 +24,29 @@ import (
 	"strings"
 )
 
+// ConvertType converts an interface of a runtime type into a interface of the
+// given type
+// e.g. turn
+// var fields []reflect.StructField
+// fields = append(fields, reflect.StructField{
+// 		Name: "X",
+//		Type: reflect.TypeOf(new(big.Int)),
+//		Tag:  reflect.StructTag("json:\"" + "x" + "\""),
+// }
+// into
+// type TupleT struct { X *big.Int }
+func ConvertType(in interface{}, proto interface{}) interface{} {
+	protoType := reflect.TypeOf(proto)
+	if reflect.TypeOf(in).ConvertibleTo(protoType) {
+		return reflect.ValueOf(in).Convert(protoType).Interface()
+	}
+	// Use set as a last ditch effort
+	if err := set(reflect.ValueOf(proto), reflect.ValueOf(in)); err != nil {
+		panic(err)
+	}
+	return proto
+}
+
 // indirect recursively dereferences the value until it either gets the value
 // or finds a big.Int
 func indirect(v reflect.Value) reflect.Value {
@@ -61,7 +84,7 @@ func reflectIntType(unsigned bool, size int) reflect.Type {
 	return reflect.TypeOf(&big.Int{})
 }
 
-// mustArrayToBytesSlice creates a new byte slice with the exact same size as value
+// mustArrayToByteSlice creates a new byte slice with the exact same size as value
 // and copies the bytes in value to the new slice.
 func mustArrayToByteSlice(value reflect.Value) reflect.Value {
 	slice := reflect.MakeSlice(reflect.TypeOf([]byte{}), value.Len(), value.Len())
@@ -119,6 +142,9 @@ func setSlice(dst, src reflect.Value) error {
 }
 
 func setArray(dst, src reflect.Value) error {
+	if src.Kind() == reflect.Ptr {
+		return set(dst, indirect(src))
+	}
 	array := reflect.New(dst.Type()).Elem()
 	min := src.Len()
 	if src.Len() > dst.Len() {
diff --git a/accounts/abi/reflect_test.go b/accounts/abi/reflect_test.go
index c425e6e54..cf13a79da 100644
--- a/accounts/abi/reflect_test.go
+++ b/accounts/abi/reflect_test.go
@@ -17,6 +17,7 @@
 package abi
 
 import (
+	"math/big"
 	"reflect"
 	"testing"
 )
@@ -189,3 +190,72 @@ func TestReflectNameToStruct(t *testing.T) {
 		})
 	}
 }
+
+func TestConvertType(t *testing.T) {
+	// Test Basic Struct
+	type T struct {
+		X *big.Int
+		Y *big.Int
+	}
+	// Create on-the-fly structure
+	var fields []reflect.StructField
+	fields = append(fields, reflect.StructField{
+		Name: "X",
+		Type: reflect.TypeOf(new(big.Int)),
+		Tag:  "json:\"" + "x" + "\"",
+	})
+	fields = append(fields, reflect.StructField{
+		Name: "Y",
+		Type: reflect.TypeOf(new(big.Int)),
+		Tag:  "json:\"" + "y" + "\"",
+	})
+	val := reflect.New(reflect.StructOf(fields))
+	val.Elem().Field(0).Set(reflect.ValueOf(big.NewInt(1)))
+	val.Elem().Field(1).Set(reflect.ValueOf(big.NewInt(2)))
+	// ConvertType
+	out := *ConvertType(val.Interface(), new(T)).(*T)
+	if out.X.Cmp(big.NewInt(1)) != 0 {
+		t.Errorf("ConvertType failed, got %v want %v", out.X, big.NewInt(1))
+	}
+	if out.Y.Cmp(big.NewInt(2)) != 0 {
+		t.Errorf("ConvertType failed, got %v want %v", out.Y, big.NewInt(2))
+	}
+	// Slice Type
+	val2 := reflect.MakeSlice(reflect.SliceOf(reflect.StructOf(fields)), 2, 2)
+	val2.Index(0).Field(0).Set(reflect.ValueOf(big.NewInt(1)))
+	val2.Index(0).Field(1).Set(reflect.ValueOf(big.NewInt(2)))
+	val2.Index(1).Field(0).Set(reflect.ValueOf(big.NewInt(3)))
+	val2.Index(1).Field(1).Set(reflect.ValueOf(big.NewInt(4)))
+	out2 := *ConvertType(val2.Interface(), new([]T)).(*[]T)
+	if out2[0].X.Cmp(big.NewInt(1)) != 0 {
+		t.Errorf("ConvertType failed, got %v want %v", out2[0].X, big.NewInt(1))
+	}
+	if out2[0].Y.Cmp(big.NewInt(2)) != 0 {
+		t.Errorf("ConvertType failed, got %v want %v", out2[1].Y, big.NewInt(2))
+	}
+	if out2[1].X.Cmp(big.NewInt(3)) != 0 {
+		t.Errorf("ConvertType failed, got %v want %v", out2[0].X, big.NewInt(1))
+	}
+	if out2[1].Y.Cmp(big.NewInt(4)) != 0 {
+		t.Errorf("ConvertType failed, got %v want %v", out2[1].Y, big.NewInt(2))
+	}
+	// Array Type
+	val3 := reflect.New(reflect.ArrayOf(2, reflect.StructOf(fields)))
+	val3.Elem().Index(0).Field(0).Set(reflect.ValueOf(big.NewInt(1)))
+	val3.Elem().Index(0).Field(1).Set(reflect.ValueOf(big.NewInt(2)))
+	val3.Elem().Index(1).Field(0).Set(reflect.ValueOf(big.NewInt(3)))
+	val3.Elem().Index(1).Field(1).Set(reflect.ValueOf(big.NewInt(4)))
+	out3 := *ConvertType(val3.Interface(), new([2]T)).(*[2]T)
+	if out3[0].X.Cmp(big.NewInt(1)) != 0 {
+		t.Errorf("ConvertType failed, got %v want %v", out3[0].X, big.NewInt(1))
+	}
+	if out3[0].Y.Cmp(big.NewInt(2)) != 0 {
+		t.Errorf("ConvertType failed, got %v want %v", out3[1].Y, big.NewInt(2))
+	}
+	if out3[1].X.Cmp(big.NewInt(3)) != 0 {
+		t.Errorf("ConvertType failed, got %v want %v", out3[0].X, big.NewInt(1))
+	}
+	if out3[1].Y.Cmp(big.NewInt(4)) != 0 {
+		t.Errorf("ConvertType failed, got %v want %v", out3[1].Y, big.NewInt(2))
+	}
+}
diff --git a/accounts/abi/topics.go b/accounts/abi/topics.go
index 6dd0a923a..14f9b13d4 100644
--- a/accounts/abi/topics.go
+++ b/accounts/abi/topics.go
@@ -102,7 +102,7 @@ func genIntType(rule int64, size uint) []byte {
 	var topic [common.HashLength]byte
 	if rule < 0 {
 		// if a rule is negative, we need to put it into two's complement.
-		// extended to common.Hashlength bytes.
+		// extended to common.HashLength bytes.
 		topic = [common.HashLength]byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
 	}
 	for i := uint(0); i < size; i++ {
@@ -120,7 +120,7 @@ func ParseTopics(out interface{}, fields Arguments, topics []common.Hash) error
 		})
 }
 
-// ParseTopicsIntoMap converts the indexed topic field-value pairs into map key-value pairs
+// ParseTopicsIntoMap converts the indexed topic field-value pairs into map key-value pairs.
 func ParseTopicsIntoMap(out map[string]interface{}, fields Arguments, topics []common.Hash) error {
 	return parseTopicWithSetter(fields, topics,
 		func(arg Argument, reconstr interface{}) {
diff --git a/accounts/abi/type.go b/accounts/abi/type.go
index 724cbf6a2..4e5d3c1f0 100644
--- a/accounts/abi/type.go
+++ b/accounts/abi/type.go
@@ -43,7 +43,7 @@ const (
 	FunctionTy
 )
 
-// Type is the reflection of the supported argument type
+// Type is the reflection of the supported argument type.
 type Type struct {
 	Elem *Type
 	Size int
@@ -263,7 +263,7 @@ func overloadedArgName(rawName string, names map[string]string) (string, error)
 	return fieldName, nil
 }
 
-// String implements Stringer
+// String implements Stringer.
 func (t Type) String() (out string) {
 	return t.stringKind
 }
@@ -345,7 +345,7 @@ func (t Type) pack(v reflect.Value) ([]byte, error) {
 		return append(ret, tail...), nil
 
 	default:
-		return packElement(t, v), nil
+		return packElement(t, v)
 	}
 }
 
@@ -385,7 +385,7 @@ func isDynamicType(t Type) bool {
 func getTypeSize(t Type) int {
 	if t.T == ArrayTy && !isDynamicType(*t.Elem) {
 		// Recursively calculate type size if it is a nested array
-		if t.Elem.T == ArrayTy {
+		if t.Elem.T == ArrayTy || t.Elem.T == TupleTy {
 			return t.Size * getTypeSize(*t.Elem)
 		}
 		return t.Size * 32
diff --git a/accounts/abi/unpack.go b/accounts/abi/unpack.go
index 403a838be..e83288e99 100644
--- a/accounts/abi/unpack.go
+++ b/accounts/abi/unpack.go
@@ -26,13 +26,13 @@ import (
 )
 
 var (
-	// MaxUint256 is the maximum value that can be represented by a uint256
+	// MaxUint256 is the maximum value that can be represented by a uint256.
 	MaxUint256 = new(big.Int).Sub(new(big.Int).Lsh(common.Big1, 256), common.Big1)
-	// MaxInt256 is the maximum value that can be represented by a int256
+	// MaxInt256 is the maximum value that can be represented by a int256.
 	MaxInt256 = new(big.Int).Sub(new(big.Int).Lsh(common.Big1, 255), common.Big1)
 )
 
-// ReadInteger reads the integer based on its kind and returns the appropriate value
+// ReadInteger reads the integer based on its kind and returns the appropriate value.
 func ReadInteger(typ Type, b []byte) interface{} {
 	if typ.T == UintTy {
 		switch typ.Size {
@@ -73,7 +73,7 @@ func ReadInteger(typ Type, b []byte) interface{} {
 	}
 }
 
-// reads a bool
+// readBool reads a bool.
 func readBool(word []byte) (bool, error) {
 	for _, b := range word[:31] {
 		if b != 0 {
@@ -91,7 +91,8 @@ func readBool(word []byte) (bool, error) {
 }
 
 // A function type is simply the address with the function selection signature at the end.
-// This enforces that standard by always presenting it as a 24-array (address + sig = 24 bytes)
+//
+// readFunctionType enforces that standard by always presenting it as a 24-array (address + sig = 24 bytes)
 func readFunctionType(t Type, word []byte) (funcTy [24]byte, err error) {
 	if t.T != FunctionTy {
 		return [24]byte{}, fmt.Errorf("abi: invalid type in call to make function type byte array")
@@ -104,7 +105,7 @@ func readFunctionType(t Type, word []byte) (funcTy [24]byte, err error) {
 	return
 }
 
-// ReadFixedBytes uses reflection to create a fixed array to be read from
+// ReadFixedBytes uses reflection to create a fixed array to be read from.
 func ReadFixedBytes(t Type, word []byte) (interface{}, error) {
 	if t.T != FixedBytesTy {
 		return nil, fmt.Errorf("abi: invalid type in call to make fixed byte array")
@@ -117,7 +118,7 @@ func ReadFixedBytes(t Type, word []byte) (interface{}, error) {
 
 }
 
-// iteratively unpack elements
+// forEachUnpack iteratively unpack elements.
 func forEachUnpack(t Type, output []byte, start, size int) (interface{}, error) {
 	if size < 0 {
 		return nil, fmt.Errorf("cannot marshal input to array, size is negative (%d)", size)
@@ -224,7 +225,10 @@ func toGoType(index int, t Type, output []byte) (interface{}, error) {
 		return forEachUnpack(t, output[begin:], 0, length)
 	case ArrayTy:
 		if isDynamicType(*t.Elem) {
-			offset := int64(binary.BigEndian.Uint64(returnOutput[len(returnOutput)-8:]))
+			offset := binary.BigEndian.Uint64(returnOutput[len(returnOutput)-8:])
+			if offset > uint64(len(output)) {
+				return nil, fmt.Errorf("abi: toGoType offset greater than output length: offset: %d, len(output): %d", offset, len(output))
+			}
 			return forEachUnpack(t, output[offset:], 0, t.Size)
 		}
 		return forEachUnpack(t, output[index:], 0, t.Size)
@@ -249,7 +253,7 @@ func toGoType(index int, t Type, output []byte) (interface{}, error) {
 	}
 }
 
-// interprets a 32 byte slice as an offset and then determines which indice to look to decode the type.
+// lengthPrefixPointsTo interprets a 32 byte slice as an offset and then determines which indices to look to decode the type.
 func lengthPrefixPointsTo(index int, output []byte) (start int, length int, err error) {
 	bigOffsetEnd := big.NewInt(0).SetBytes(output[index : index+32])
 	bigOffsetEnd.Add(bigOffsetEnd, common.Big32)
diff --git a/accounts/abi/unpack_test.go b/accounts/abi/unpack_test.go
index c7084703e..787e10600 100644
--- a/accounts/abi/unpack_test.go
+++ b/accounts/abi/unpack_test.go
@@ -44,15 +44,13 @@ func TestUnpack(t *testing.T) {
 			if err != nil {
 				t.Fatalf("invalid hex %s: %v", test.packed, err)
 			}
-			outptr := reflect.New(reflect.TypeOf(test.unpacked))
-			err = abi.Unpack(outptr.Interface(), "method", encb)
+			out, err := abi.Unpack("method", encb)
 			if err != nil {
 				t.Errorf("test %d (%v) failed: %v", i, test.def, err)
 				return
 			}
-			out := outptr.Elem().Interface()
-			if !reflect.DeepEqual(test.unpacked, out) {
-				t.Errorf("test %d (%v) failed: expected %v, got %v", i, test.def, test.unpacked, out)
+			if !reflect.DeepEqual(test.unpacked, ConvertType(out[0], test.unpacked)) {
+				t.Errorf("test %d (%v) failed: expected %v, got %v", i, test.def, test.unpacked, out[0])
 			}
 		})
 	}
@@ -221,7 +219,7 @@ func TestLocalUnpackTests(t *testing.T) {
 				t.Fatalf("invalid hex %s: %v", test.enc, err)
 			}
 			outptr := reflect.New(reflect.TypeOf(test.want))
-			err = abi.Unpack(outptr.Interface(), "method", encb)
+			err = abi.UnpackIntoInterface(outptr.Interface(), "method", encb)
 			if err := test.checkError(err); err != nil {
 				t.Errorf("test %d (%v) failed: %v", i, test.def, err)
 				return
@@ -234,7 +232,7 @@ func TestLocalUnpackTests(t *testing.T) {
 	}
 }
 
-func TestUnpackSetDynamicArrayOutput(t *testing.T) {
+func TestUnpackIntoInterfaceSetDynamicArrayOutput(t *testing.T) {
 	abi, err := JSON(strings.NewReader(`[{"constant":true,"inputs":[],"name":"testDynamicFixedBytes15","outputs":[{"name":"","type":"bytes15[]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"testDynamicFixedBytes32","outputs":[{"name":"","type":"bytes32[]"}],"payable":false,"stateMutability":"view","type":"function"}]`))
 	if err != nil {
 		t.Fatal(err)
@@ -249,7 +247,7 @@ func TestUnpackSetDynamicArrayOutput(t *testing.T) {
 	)
 
 	// test 32
-	err = abi.Unpack(&out32, "testDynamicFixedBytes32", marshalledReturn32)
+	err = abi.UnpackIntoInterface(&out32, "testDynamicFixedBytes32", marshalledReturn32)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -266,7 +264,7 @@ func TestUnpackSetDynamicArrayOutput(t *testing.T) {
 	}
 
 	// test 15
-	err = abi.Unpack(&out15, "testDynamicFixedBytes32", marshalledReturn15)
+	err = abi.UnpackIntoInterface(&out15, "testDynamicFixedBytes32", marshalledReturn15)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -367,7 +365,7 @@ func TestMethodMultiReturn(t *testing.T) {
 		tc := tc
 		t.Run(tc.name, func(t *testing.T) {
 			require := require.New(t)
-			err := abi.Unpack(tc.dest, "multi", data)
+			err := abi.UnpackIntoInterface(tc.dest, "multi", data)
 			if tc.error == "" {
 				require.Nil(err, "Should be able to unpack method outputs.")
 				require.Equal(tc.expected, tc.dest)
@@ -390,7 +388,7 @@ func TestMultiReturnWithArray(t *testing.T) {
 
 	ret1, ret1Exp := new([3]uint64), [3]uint64{9, 9, 9}
 	ret2, ret2Exp := new(uint64), uint64(8)
-	if err := abi.Unpack(&[]interface{}{ret1, ret2}, "multi", buff.Bytes()); err != nil {
+	if err := abi.UnpackIntoInterface(&[]interface{}{ret1, ret2}, "multi", buff.Bytes()); err != nil {
 		t.Fatal(err)
 	}
 	if !reflect.DeepEqual(*ret1, ret1Exp) {
@@ -414,7 +412,7 @@ func TestMultiReturnWithStringArray(t *testing.T) {
 	ret2, ret2Exp := new(common.Address), common.HexToAddress("ab1257528b3782fb40d7ed5f72e624b744dffb2f")
 	ret3, ret3Exp := new([2]string), [2]string{"Ethereum", "Hello, Ethereum!"}
 	ret4, ret4Exp := new(bool), false
-	if err := abi.Unpack(&[]interface{}{ret1, ret2, ret3, ret4}, "multi", buff.Bytes()); err != nil {
+	if err := abi.UnpackIntoInterface(&[]interface{}{ret1, ret2, ret3, ret4}, "multi", buff.Bytes()); err != nil {
 		t.Fatal(err)
 	}
 	if !reflect.DeepEqual(*ret1, ret1Exp) {
@@ -452,7 +450,7 @@ func TestMultiReturnWithStringSlice(t *testing.T) {
 	buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000065")) // output[1][1] value
 	ret1, ret1Exp := new([]string), []string{"ethereum", "go-ethereum"}
 	ret2, ret2Exp := new([]*big.Int), []*big.Int{big.NewInt(100), big.NewInt(101)}
-	if err := abi.Unpack(&[]interface{}{ret1, ret2}, "multi", buff.Bytes()); err != nil {
+	if err := abi.UnpackIntoInterface(&[]interface{}{ret1, ret2}, "multi", buff.Bytes()); err != nil {
 		t.Fatal(err)
 	}
 	if !reflect.DeepEqual(*ret1, ret1Exp) {
@@ -492,7 +490,7 @@ func TestMultiReturnWithDeeplyNestedArray(t *testing.T) {
 		{{0x411, 0x412, 0x413}, {0x421, 0x422, 0x423}},
 	}
 	ret2, ret2Exp := new(uint64), uint64(0x9876)
-	if err := abi.Unpack(&[]interface{}{ret1, ret2}, "multi", buff.Bytes()); err != nil {
+	if err := abi.UnpackIntoInterface(&[]interface{}{ret1, ret2}, "multi", buff.Bytes()); err != nil {
 		t.Fatal(err)
 	}
 	if !reflect.DeepEqual(*ret1, ret1Exp) {
@@ -531,7 +529,7 @@ func TestUnmarshal(t *testing.T) {
 	buff.Write(common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000a"))
 	buff.Write(common.Hex2Bytes("0102000000000000000000000000000000000000000000000000000000000000"))
 
-	err = abi.Unpack(&mixedBytes, "mixedBytes", buff.Bytes())
+	err = abi.UnpackIntoInterface(&mixedBytes, "mixedBytes", buff.Bytes())
 	if err != nil {
 		t.Error(err)
 	} else {
@@ -546,7 +544,7 @@ func TestUnmarshal(t *testing.T) {
 
 	// marshal int
 	var Int *big.Int
-	err = abi.Unpack(&Int, "int", common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001"))
+	err = abi.UnpackIntoInterface(&Int, "int", common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001"))
 	if err != nil {
 		t.Error(err)
 	}
@@ -557,7 +555,7 @@ func TestUnmarshal(t *testing.T) {
 
 	// marshal bool
 	var Bool bool
-	err = abi.Unpack(&Bool, "bool", common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001"))
+	err = abi.UnpackIntoInterface(&Bool, "bool", common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001"))
 	if err != nil {
 		t.Error(err)
 	}
@@ -574,7 +572,7 @@ func TestUnmarshal(t *testing.T) {
 	buff.Write(bytesOut)
 
 	var Bytes []byte
-	err = abi.Unpack(&Bytes, "bytes", buff.Bytes())
+	err = abi.UnpackIntoInterface(&Bytes, "bytes", buff.Bytes())
 	if err != nil {
 		t.Error(err)
 	}
@@ -590,7 +588,7 @@ func TestUnmarshal(t *testing.T) {
 	bytesOut = common.RightPadBytes([]byte("hello"), 64)
 	buff.Write(bytesOut)
 
-	err = abi.Unpack(&Bytes, "bytes", buff.Bytes())
+	err = abi.UnpackIntoInterface(&Bytes, "bytes", buff.Bytes())
 	if err != nil {
 		t.Error(err)
 	}
@@ -606,7 +604,7 @@ func TestUnmarshal(t *testing.T) {
 	bytesOut = common.RightPadBytes([]byte("hello"), 64)
 	buff.Write(bytesOut)
 
-	err = abi.Unpack(&Bytes, "bytes", buff.Bytes())
+	err = abi.UnpackIntoInterface(&Bytes, "bytes", buff.Bytes())
 	if err != nil {
 		t.Error(err)
 	}
@@ -616,7 +614,7 @@ func TestUnmarshal(t *testing.T) {
 	}
 
 	// marshal dynamic bytes output empty
-	err = abi.Unpack(&Bytes, "bytes", nil)
+	err = abi.UnpackIntoInterface(&Bytes, "bytes", nil)
 	if err == nil {
 		t.Error("expected error")
 	}
@@ -627,7 +625,7 @@ func TestUnmarshal(t *testing.T) {
 	buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000005"))
 	buff.Write(common.RightPadBytes([]byte("hello"), 32))
 
-	err = abi.Unpack(&Bytes, "bytes", buff.Bytes())
+	err = abi.UnpackIntoInterface(&Bytes, "bytes", buff.Bytes())
 	if err != nil {
 		t.Error(err)
 	}
@@ -641,7 +639,7 @@ func TestUnmarshal(t *testing.T) {
 	buff.Write(common.RightPadBytes([]byte("hello"), 32))
 
 	var hash common.Hash
-	err = abi.Unpack(&hash, "fixed", buff.Bytes())
+	err = abi.UnpackIntoInterface(&hash, "fixed", buff.Bytes())
 	if err != nil {
 		t.Error(err)
 	}
@@ -654,12 +652,12 @@ func TestUnmarshal(t *testing.T) {
 	// marshal error
 	buff.Reset()
 	buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000020"))
-	err = abi.Unpack(&Bytes, "bytes", buff.Bytes())
+	err = abi.UnpackIntoInterface(&Bytes, "bytes", buff.Bytes())
 	if err == nil {
 		t.Error("expected error")
 	}
 
-	err = abi.Unpack(&Bytes, "multi", make([]byte, 64))
+	err = abi.UnpackIntoInterface(&Bytes, "multi", make([]byte, 64))
 	if err == nil {
 		t.Error("expected error")
 	}
@@ -670,7 +668,7 @@ func TestUnmarshal(t *testing.T) {
 	buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000003"))
 	// marshal int array
 	var intArray [3]*big.Int
-	err = abi.Unpack(&intArray, "intArraySingle", buff.Bytes())
+	err = abi.UnpackIntoInterface(&intArray, "intArraySingle", buff.Bytes())
 	if err != nil {
 		t.Error(err)
 	}
@@ -691,7 +689,7 @@ func TestUnmarshal(t *testing.T) {
 	buff.Write(common.Hex2Bytes("0000000000000000000000000100000000000000000000000000000000000000"))
 
 	var outAddr []common.Address
-	err = abi.Unpack(&outAddr, "addressSliceSingle", buff.Bytes())
+	err = abi.UnpackIntoInterface(&outAddr, "addressSliceSingle", buff.Bytes())
 	if err != nil {
 		t.Fatal("didn't expect error:", err)
 	}
@@ -718,7 +716,7 @@ func TestUnmarshal(t *testing.T) {
 		A []common.Address
 		B []common.Address
 	}
-	err = abi.Unpack(&outAddrStruct, "addressSliceDouble", buff.Bytes())
+	err = abi.UnpackIntoInterface(&outAddrStruct, "addressSliceDouble", buff.Bytes())
 	if err != nil {
 		t.Fatal("didn't expect error:", err)
 	}
@@ -746,7 +744,7 @@ func TestUnmarshal(t *testing.T) {
 	buff.Reset()
 	buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000100"))
 
-	err = abi.Unpack(&outAddr, "addressSliceSingle", buff.Bytes())
+	err = abi.UnpackIntoInterface(&outAddr, "addressSliceSingle", buff.Bytes())
 	if err == nil {
 		t.Fatal("expected error:", err)
 	}
@@ -769,7 +767,7 @@ func TestUnpackTuple(t *testing.T) {
 		B *big.Int
 	}{new(big.Int), new(big.Int)}
 
-	err = abi.Unpack(&v, "tuple", buff.Bytes())
+	err = abi.UnpackIntoInterface(&v, "tuple", buff.Bytes())
 	if err != nil {
 		t.Error(err)
 	} else {
@@ -841,7 +839,7 @@ func TestUnpackTuple(t *testing.T) {
 		A: big.NewInt(1),
 	}
 
-	err = abi.Unpack(&ret, "tuple", buff.Bytes())
+	err = abi.UnpackIntoInterface(&ret, "tuple", buff.Bytes())
 	if err != nil {
 		t.Error(err)
 	}
diff --git a/accounts/accounts.go b/accounts/accounts.go
index 7a3e29c5c..a305025f8 100644
--- a/accounts/accounts.go
+++ b/accounts/accounts.go
@@ -18,6 +18,8 @@
 package accounts
 
 import (
+	"fmt"
+	"golang.org/x/crypto/sha3"
 	"math/big"
 
 	"github.com/truechain/truechain-engineering-code"
@@ -33,6 +35,13 @@ type Account struct {
 	URL     URL            `json:"url"`     // Optional resource locator within a backend
 }
 
+const (
+	MimetypeDataWithValidator = "data/validator"
+	MimetypeTypedData         = "data/typed"
+	MimetypeClique            = "application/x-clique-header"
+	MimetypeTextPlain         = "text/plain"
+)
+
 // Wallet represents a software or hardware wallet that might contain one or more
 // accounts (derived from the same seed).
 type Wallet interface {
@@ -79,16 +88,38 @@ type Wallet interface {
 	// to discover non zero accounts and automatically add them to list of tracked
 	// accounts.
 	//
-	// Note, self derivaton will increment the last component of the specified path
+	// Note, self derivation will increment the last component of the specified path
 	// opposed to decending into a child path to allow discovering accounts starting
 	// from non zero components.
 	//
+	// Some hardware wallets switched derivation paths through their evolution, so
+	// this method supports providing multiple bases to discover old user accounts
+	// too. Only the last base will be used to derive the next empty account.
+	//
 	// You can disable automatic account discovery by calling SelfDerive with a nil
 	// chain state reader.
-	SelfDerive(base DerivationPath, chain truechain.ChainStateReader)
+	SelfDerive(bases []DerivationPath, chain truechain.ChainStateReader)
 
-	// SignHash requests the wallet to sign the given hash.
+	// SignData requests the wallet to sign the hash of the given data
+	// It looks up the account specified either solely via its address contained within,
+	// or optionally with the aid of any location metadata from the embedded URL field.
 	//
+	// If the wallet requires additional authentication to sign the request (e.g.
+	// a password to decrypt the account, or a PIN code o verify the transaction),
+	// an AuthNeededError instance will be returned, containing infos for the user
+	// about which fields or actions are needed. The user may retry by providing
+	// the needed details via SignDataWithPassphrase, or by other means (e.g. unlock
+	// the account in a keystore).
+	SignData(account Account, mimeType string, data []byte) ([]byte, error)
+
+	// SignDataWithPassphrase is identical to SignData, but also takes a password
+	// NOTE: there's a chance that an erroneous call might mistake the two strings, and
+	// supply password in the mimetype field, or vice versa. Thus, an implementation
+	// should never echo the mimetype or return the mimetype in the error-response
+	SignDataWithPassphrase(account Account, passphrase, mimeType string, data []byte) ([]byte, error)
+
+	// SignText requests the wallet to sign the hash of a given piece of data, prefixed
+	// by the Ethereum prefix scheme
 	// It looks up the account specified either solely via its address contained within,
 	// or optionally with the aid of any location metadata from the embedded URL field.
 	//
@@ -96,9 +127,14 @@ type Wallet interface {
 	// a password to decrypt the account, or a PIN code o verify the transaction),
 	// an AuthNeededError instance will be returned, containing infos for the user
 	// about which fields or actions are needed. The user may retry by providing
-	// the needed details via SignHashWithPassphrase, or by other means (e.g. unlock
+	// the needed details via SignTextWithPassphrase, or by other means (e.g. unlock
 	// the account in a keystore).
-	SignHash(account Account, hash []byte) ([]byte, error)
+	//
+	// This method should return the signature in 'canonical' format, with v 0 or 1
+	SignText(account Account, text []byte) ([]byte, error)
+
+	// SignTextWithPassphrase is identical to Signtext, but also takes a password
+	SignTextWithPassphrase(account Account, passphrase string, hash []byte) ([]byte, error)
 
 	// SignTx requests the wallet to sign the given transaction.
 	//
@@ -113,20 +149,7 @@ type Wallet interface {
 	// the account in a keystore).
 	SignTx(account Account, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error)
 
-	SignTx_Payment(account Account, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error)
-
-	// SignHashWithPassphrase requests the wallet to sign the given hash with the
-	// given passphrase as extra authentication information.
-	//
-	// It looks up the account specified either solely via its address contained within,
-	// or optionally with the aid of any location metadata from the embedded URL field.
-	SignHashWithPassphrase(account Account, passphrase string, hash []byte) ([]byte, error)
-
-	// SignTxWithPassphrase requests the wallet to sign the given transaction, with the
-	// given passphrase as extra authentication information.
-	//
-	// It looks up the account specified either solely via its address contained within,
-	// or optionally with the aid of any location metadata from the embedded URL field.
+	// SignTxWithPassphrase is identical to SignTx, but also takes a password
 	SignTxWithPassphrase(account Account, passphrase string, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error)
 }
 
@@ -150,6 +173,32 @@ type Backend interface {
 	Subscribe(sink chan<- WalletEvent) event.Subscription
 }
 
+// TextHash is a helper function that calculates a hash for the given message that can be
+// safely used to calculate a signature from.
+//
+// The hash is calulcated as
+//   keccak256("\x19Ethereum Signed Message:\n"${message length}${message}).
+//
+// This gives context to the signed message and prevents signing of transactions.
+func TextHash(data []byte) []byte {
+	hash, _ := TextAndHash(data)
+	return hash
+}
+
+// TextAndHash is a helper function that calculates a hash for the given message that can be
+// safely used to calculate a signature from.
+//
+// The hash is calulcated as
+//   keccak256("\x19Ethereum Signed Message:\n"${message length}${message}).
+//
+// This gives context to the signed message and prevents signing of transactions.
+func TextAndHash(data []byte) ([]byte, string) {
+	msg := fmt.Sprintf("\x19Ethereum Signed Message:\n%d%s", len(data), string(data))
+	hasher := sha3.NewLegacyKeccak256()
+	hasher.Write([]byte(msg))
+	return hasher.Sum(nil), msg
+}
+
 // WalletEventType represents the different event types that can be fired by
 // the wallet subscription subsystem.
 type WalletEventType int
diff --git a/accounts/errors.go b/accounts/errors.go
index 40b21ed17..2fed35f9d 100644
--- a/accounts/errors.go
+++ b/accounts/errors.go
@@ -35,7 +35,7 @@ var ErrNotSupported = errors.New("not supported")
 
 // ErrInvalidPassphrase is returned when a decryption operation receives a bad
 // passphrase.
-var ErrInvalidPassphrase = errors.New("invalid passphrase")
+var ErrInvalidPassphrase = errors.New("invalid password")
 
 // ErrWalletAlreadyOpen is returned if a wallet is attempted to be opened the
 // second time.
diff --git a/accounts/hd.go b/accounts/hd.go
index 6ed631807..54acea3b2 100644
--- a/accounts/hd.go
+++ b/accounts/hd.go
@@ -17,6 +17,7 @@
 package accounts
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
 	"math"
@@ -34,10 +35,10 @@ var DefaultRootDerivationPath = DerivationPath{0x80000000 + 44, 0x80000000 + 60,
 // at m/44'/60'/0'/0/1, etc.
 var DefaultBaseDerivationPath = DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0}
 
-// DefaultLedgerBaseDerivationPath is the base path from which custom derivation endpoints
-// are incremented. As such, the first account will be at m/44'/60'/0'/0, the second
-// at m/44'/60'/0'/1, etc.
-var DefaultLedgerBaseDerivationPath = DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0}
+// LegacyLedgerBaseDerivationPath is the legacy base path from which custom derivation
+// endpoints are incremented. As such, the first account will be at m/44'/60'/0'/0, the
+// second at m/44'/60'/0'/1, etc.
+var LegacyLedgerBaseDerivationPath = DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0}
 
 // DerivationPath represents the computer friendly version of a hierarchical
 // deterministic wallet account derivaion path.
@@ -133,3 +134,47 @@ func (path DerivationPath) String() string {
 	}
 	return result
 }
+
+// MarshalJSON turns a derivation path into its json-serialized string
+func (path DerivationPath) MarshalJSON() ([]byte, error) {
+	return json.Marshal(path.String())
+}
+
+// UnmarshalJSON a json-serialized string back into a derivation path
+func (path *DerivationPath) UnmarshalJSON(b []byte) error {
+	var dp string
+	var err error
+	if err = json.Unmarshal(b, &dp); err != nil {
+		return err
+	}
+	*path, err = ParseDerivationPath(dp)
+	return err
+}
+
+// DefaultIterator creates a BIP-32 path iterator, which progresses by increasing the last component:
+// i.e. m/44'/60'/0'/0/0, m/44'/60'/0'/0/1, m/44'/60'/0'/0/2, ... m/44'/60'/0'/0/N.
+func DefaultIterator(base DerivationPath) func() DerivationPath {
+	path := make(DerivationPath, len(base))
+	copy(path[:], base[:])
+	// Set it back by one, so the first call gives the first result
+	path[len(path)-1]--
+	return func() DerivationPath {
+		path[len(path)-1]++
+		return path
+	}
+}
+
+// LedgerLiveIterator creates a bip44 path iterator for Ledger Live.
+// Ledger Live increments the third component rather than the fifth component
+// i.e. m/44'/60'/0'/0/0, m/44'/60'/1'/0/0, m/44'/60'/2'/0/0, ... m/44'/60'/N'/0/0.
+func LedgerLiveIterator(base DerivationPath) func() DerivationPath {
+	path := make(DerivationPath, len(base))
+	copy(path[:], base[:])
+	// Set it back by one, so the first call gives the first result
+	path[2]--
+	return func() DerivationPath {
+		// ledgerLivePathIterator iterates on the third component
+		path[2]++
+		return path
+	}
+}
diff --git a/accounts/hd_test.go b/accounts/hd_test.go
index b6b23230d..0743bbe66 100644
--- a/accounts/hd_test.go
+++ b/accounts/hd_test.go
@@ -17,6 +17,7 @@
 package accounts
 
 import (
+	"fmt"
 	"reflect"
 	"testing"
 )
@@ -61,7 +62,7 @@ func TestHDPathParsing(t *testing.T) {
 		// Weird inputs just to ensure they work
 		{"	m  /   44			'\n/\n   60	\n\n\t'   /\n0 ' /\t\t	0", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0}},
 
-		// Invaid derivation paths
+		// Invalid derivation paths
 		{"", nil},              // Empty relative derivation path
 		{"m", nil},             // Empty absolute derivation path
 		{"m/", nil},            // Missing last derivation component
@@ -77,3 +78,41 @@ func TestHDPathParsing(t *testing.T) {
 		}
 	}
 }
+
+func testDerive(t *testing.T, next func() DerivationPath, expected []string) {
+	t.Helper()
+	for i, want := range expected {
+		if have := next(); fmt.Sprintf("%v", have) != want {
+			t.Errorf("step %d, have %v, want %v", i, have, want)
+		}
+	}
+}
+
+func TestHdPathIteration(t *testing.T) {
+	testDerive(t, DefaultIterator(DefaultBaseDerivationPath),
+		[]string{
+			"m/44'/60'/0'/0/0", "m/44'/60'/0'/0/1",
+			"m/44'/60'/0'/0/2", "m/44'/60'/0'/0/3",
+			"m/44'/60'/0'/0/4", "m/44'/60'/0'/0/5",
+			"m/44'/60'/0'/0/6", "m/44'/60'/0'/0/7",
+			"m/44'/60'/0'/0/8", "m/44'/60'/0'/0/9",
+		})
+
+	testDerive(t, DefaultIterator(LegacyLedgerBaseDerivationPath),
+		[]string{
+			"m/44'/60'/0'/0", "m/44'/60'/0'/1",
+			"m/44'/60'/0'/2", "m/44'/60'/0'/3",
+			"m/44'/60'/0'/4", "m/44'/60'/0'/5",
+			"m/44'/60'/0'/6", "m/44'/60'/0'/7",
+			"m/44'/60'/0'/8", "m/44'/60'/0'/9",
+		})
+
+	testDerive(t, LedgerLiveIterator(DefaultBaseDerivationPath),
+		[]string{
+			"m/44'/60'/0'/0/0", "m/44'/60'/1'/0/0",
+			"m/44'/60'/2'/0/0", "m/44'/60'/3'/0/0",
+			"m/44'/60'/4'/0/0", "m/44'/60'/5'/0/0",
+			"m/44'/60'/6'/0/0", "m/44'/60'/7'/0/0",
+			"m/44'/60'/8'/0/0", "m/44'/60'/9'/0/0",
+		})
+}
diff --git a/accounts/keystore/account_cache.go b/accounts/keystore/account_cache.go
index cdf1534c5..9edb29827 100644
--- a/accounts/keystore/account_cache.go
+++ b/accounts/keystore/account_cache.go
@@ -262,10 +262,13 @@ func (ac *accountCache) scanAccounts() error {
 		switch {
 		case err != nil:
 			log.Debug("Failed to decode keystore key", "path", path, "err", err)
-		case (addr == common.Address{}):
+		case addr == common.Address{}:
 			log.Debug("Failed to decode keystore key", "path", path, "err", "missing or zero address")
 		default:
-			return &accounts.Account{Address: addr, URL: accounts.URL{Scheme: KeyStoreScheme, Path: path}}
+			return &accounts.Account{
+				Address: addr,
+				URL:     accounts.URL{Scheme: KeyStoreScheme, Path: path},
+			}
 		}
 		return nil
 	}
diff --git a/accounts/keystore/file_cache.go b/accounts/keystore/file_cache.go
index 0c21eae75..9a173764e 100644
--- a/accounts/keystore/file_cache.go
+++ b/accounts/keystore/file_cache.go
@@ -32,7 +32,7 @@ import (
 type fileCache struct {
 	all     mapset.Set // Set of all files from the keystore folder
 	lastMod time.Time  // Last time instance when a file was modified
-	mu      sync.RWMutex
+	mu      sync.Mutex
 }
 
 // scan performs a new scan on the given directory, compares against the already
diff --git a/accounts/keystore/key.go b/accounts/keystore/key.go
index b7e9ff3fe..0de2d58a6 100644
--- a/accounts/keystore/key.go
+++ b/accounts/keystore/key.go
@@ -29,10 +29,10 @@ import (
 	"strings"
 	"time"
 
+	"github.com/google/uuid"
 	"github.com/truechain/truechain-engineering-code/accounts"
 	"github.com/truechain/truechain-engineering-code/common"
 	"github.com/truechain/truechain-engineering-code/crypto"
-	"github.com/pborman/uuid"
 )
 
 const (
@@ -110,7 +110,10 @@ func (k *Key) UnmarshalJSON(j []byte) (err error) {
 	}
 
 	u := new(uuid.UUID)
-	*u = uuid.Parse(keyJSON.Id)
+	*u, err = uuid.Parse(keyJSON.Id)
+	if err != nil {
+		return err
+	}
 	k.Id = *u
 	addr, err := hex.DecodeString(keyJSON.Address)
 	if err != nil {
@@ -128,7 +131,10 @@ func (k *Key) UnmarshalJSON(j []byte) (err error) {
 }
 
 func newKeyFromECDSA(privateKeyECDSA *ecdsa.PrivateKey) *Key {
-	id := uuid.NewRandom()
+	id, err := uuid.NewRandom()
+	if err != nil {
+		panic(fmt.Sprintf("Could not create random uuid: %v", err))
+	}
 	key := &Key{
 		Id:         id,
 		Address:    crypto.PubkeyToAddress(privateKeyECDSA.PublicKey),
@@ -171,7 +177,10 @@ func storeNewKey(ks keyStore, rand io.Reader, auth string) (*Key, accounts.Accou
 	if err != nil {
 		return nil, accounts.Account{}, err
 	}
-	a := accounts.Account{Address: key.Address, URL: accounts.URL{Scheme: KeyStoreScheme, Path: ks.JoinPath(keyFileName(key.Address))}}
+	a := accounts.Account{
+		Address: key.Address,
+		URL:     accounts.URL{Scheme: KeyStoreScheme, Path: ks.JoinPath(keyFileName(key.Address))},
+	}
 	if err := ks.StoreKey(a.URL.Path, key, auth); err != nil {
 		zeroKey(key.PrivateKey)
 		return nil, a, err
@@ -224,5 +233,6 @@ func toISO8601(t time.Time) string {
 	} else {
 		tz = fmt.Sprintf("%03d00", offset/3600)
 	}
-	return fmt.Sprintf("%04d-%02d-%02dT%02d-%02d-%02d.%09d%s", t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), tz)
+	return fmt.Sprintf("%04d-%02d-%02dT%02d-%02d-%02d.%09d%s",
+		t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), tz)
 }
diff --git a/accounts/keystore/keystore.go b/accounts/keystore/keystore.go
index e9d859ef2..512159b40 100644
--- a/accounts/keystore/keystore.go
+++ b/accounts/keystore/keystore.go
@@ -24,7 +24,6 @@ import (
 	"crypto/ecdsa"
 	crand "crypto/rand"
 	"errors"
-	"fmt"
 	"math/big"
 	"os"
 	"path/filepath"
@@ -33,17 +32,21 @@ import (
 	"sync"
 	"time"
 
-	"github.com/truechain/truechain-engineering-code/common"
-	"github.com/truechain/truechain-engineering-code/crypto"
 	"github.com/truechain/truechain-engineering-code/accounts"
+	"github.com/truechain/truechain-engineering-code/common"
 	"github.com/truechain/truechain-engineering-code/core/types"
+	"github.com/truechain/truechain-engineering-code/crypto"
 	"github.com/truechain/truechain-engineering-code/event"
 )
 
 var (
 	ErrLocked  = accounts.NewAuthNeededError("password or unlock")
 	ErrNoMatch = errors.New("no key for given address or file")
-	ErrDecrypt = errors.New("could not decrypt key with given passphrase")
+	ErrDecrypt = errors.New("could not decrypt key with given password")
+
+	// ErrAccountAlreadyExists is returned if an account attempted to import is
+	// already present in the keystore.
+	ErrAccountAlreadyExists = errors.New("account already exists")
 )
 
 // KeyStoreType is the reflect type of a keystore backend.
@@ -67,7 +70,8 @@ type KeyStore struct {
 	updateScope event.SubscriptionScope // Subscription scope tracking current live listeners
 	updating    bool                    // Whether the event notification loop is running
 
-	mu sync.RWMutex
+	mu       sync.RWMutex
+	importMu sync.Mutex // Import Mutex locks the import to prevent two insertions from racing
 }
 
 type unlocked struct {
@@ -137,8 +141,10 @@ func (ks *KeyStore) refreshWallets() {
 	accs := ks.cache.accounts()
 
 	// Transform the current list of wallets into the new one
-	wallets := make([]accounts.Wallet, 0, len(accs))
-	events := []accounts.WalletEvent{}
+	var (
+		wallets = make([]accounts.Wallet, 0, len(accs))
+		events  []accounts.WalletEvent
+	)
 
 	for _, account := range accs {
 		// Drop wallets while they were in front of the next account
@@ -277,21 +283,9 @@ func (ks *KeyStore) SignTx(a accounts.Account, tx *types.Transaction, chainID *b
 	if !found {
 		return nil, ErrLocked
 	}
-	// Depending on the presence of the chain ID, sign with EIP155 or homestead
-	return types.SignTx(tx, types.NewTIP1Signer(chainID), unlockedKey.PrivateKey)
-}
-
-func (ks *KeyStore) SignTx_Payment(a accounts.Account, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) {
-	// Look up the key to sign with and abort if it cannot be found
-	ks.mu.RLock()
-	defer ks.mu.RUnlock()
-
-	unlockedKey, found := ks.unlocked[a.Address]
-	if !found {
-		return nil, ErrLocked
-	}
-	// Depending on the presence of the chain ID, sign with EIP155 or homestead
-	return types.SignTx_Payment(tx, types.NewTIP1Signer(chainID), unlockedKey.PrivateKey)
+	// Depending on the presence of the chain ID, sign with 2718 or homestead
+	signer := types.LatestSignerForChainID(chainID)
+	return types.SignTx(tx, signer, unlockedKey.PrivateKey)
 }
 
 // SignHashWithPassphrase signs hash if the private key matching the given address
@@ -314,9 +308,9 @@ func (ks *KeyStore) SignTxWithPassphrase(a accounts.Account, passphrase string,
 		return nil, err
 	}
 	defer zeroKey(key.PrivateKey)
-
-	// Depending on the presence of the chain ID, sign with EIP155 or homestead
-	return types.SignTx(tx, types.NewTIP1Signer(chainID), key.PrivateKey)
+	// Depending on the presence of the chain ID, sign with or without replay protection.
+	signer := types.LatestSignerForChainID(chainID)
+	return types.SignTx(tx, signer, key.PrivateKey)
 }
 
 // Unlock unlocks the given account indefinitely.
@@ -448,14 +442,27 @@ func (ks *KeyStore) Import(keyJSON []byte, passphrase, newPassphrase string) (ac
 	if err != nil {
 		return accounts.Account{}, err
 	}
+	ks.importMu.Lock()
+	defer ks.importMu.Unlock()
+
+	if ks.cache.hasAddress(key.Address) {
+		return accounts.Account{
+			Address: key.Address,
+		}, ErrAccountAlreadyExists
+	}
 	return ks.importKey(key, newPassphrase)
 }
 
 // ImportECDSA stores the given key into the key directory, encrypting it with the passphrase.
 func (ks *KeyStore) ImportECDSA(priv *ecdsa.PrivateKey, passphrase string) (accounts.Account, error) {
+	ks.importMu.Lock()
+	defer ks.importMu.Unlock()
+
 	key := newKeyFromECDSA(priv)
 	if ks.cache.hasAddress(key.Address) {
-		return accounts.Account{}, fmt.Errorf("account already exists")
+		return accounts.Account{
+			Address: key.Address,
+		}, ErrAccountAlreadyExists
 	}
 	return ks.importKey(key, passphrase)
 }
diff --git a/accounts/keystore/keystore_passphrase.go b/accounts/keystore/keystore_passphrase.go
index f5769497c..f6d4d2157 100644
--- a/accounts/keystore/keystore_passphrase.go
+++ b/accounts/keystore/keystore_passphrase.go
@@ -38,7 +38,7 @@ import (
 	"os"
 	"path/filepath"
 
-	"github.com/pborman/uuid"
+	"github.com/google/uuid"
 	"github.com/truechain/truechain-engineering-code/common"
 	"github.com/truechain/truechain-engineering-code/common/math"
 	"github.com/truechain/truechain-engineering-code/crypto"
@@ -227,9 +227,12 @@ func DecryptKey(keyjson []byte, auth string) (*Key, error) {
 		return nil, err
 	}
 	key := crypto.ToECDSAUnsafe(keyBytes)
-
+	id, err := uuid.FromBytes(keyId)
+	if err != nil {
+		return nil, err
+	}
 	return &Key{
-		Id:         uuid.UUID(keyId),
+		Id:         id,
 		Address:    crypto.PubkeyToAddress(key.PublicKey),
 		PrivateKey: key,
 	}, nil
@@ -274,7 +277,11 @@ func decryptKeyV3(keyProtected *encryptedKeyJSONV3, auth string) (keyBytes []byt
 	if keyProtected.Version != version {
 		return nil, nil, fmt.Errorf("Version not supported: %v", keyProtected.Version)
 	}
-	keyId = uuid.Parse(keyProtected.Id)
+	keyUUID, err := uuid.Parse(keyProtected.Id)
+	if err != nil {
+		return nil, nil, err
+	}
+	keyId = keyUUID[:]
 	plainText, err := DecryptDataV3(keyProtected.Crypto, auth)
 	if err != nil {
 		return nil, nil, err
@@ -283,7 +290,11 @@ func decryptKeyV3(keyProtected *encryptedKeyJSONV3, auth string) (keyBytes []byt
 }
 
 func decryptKeyV1(keyProtected *encryptedKeyJSONV1, auth string) (keyBytes []byte, keyId []byte, err error) {
-	keyId = uuid.Parse(keyProtected.Id)
+	keyUUID, err := uuid.Parse(keyProtected.Id)
+	if err != nil {
+		return nil, nil, err
+	}
+	keyId = keyUUID[:]
 	mac, err := hex.DecodeString(keyProtected.Crypto.MAC)
 	if err != nil {
 		return nil, nil, err
diff --git a/accounts/keystore/keystore_test.go b/accounts/keystore/keystore_test.go
index e818870d1..34c409ce1 100644
--- a/accounts/keystore/keystore_test.go
+++ b/accounts/keystore/keystore_test.go
@@ -23,6 +23,8 @@ import (
 	"runtime"
 	"sort"
 	"strings"
+	"sync"
+	"sync/atomic"
 	"testing"
 	"time"
 
@@ -333,11 +335,95 @@ func TestWalletNotifications(t *testing.T) {
 
 	// Shut down the event collector and check events.
 	sub.Unsubscribe()
-	<-updates
+	for ev := range updates {
+		events = append(events, walletEvent{ev, ev.Wallet.Accounts()[0]})
+	}
 	checkAccounts(t, live, ks.Wallets())
 	checkEvents(t, wantEvents, events)
 }
 
+// TestImportExport tests the import functionality of a keystore.
+func TestImportECDSA(t *testing.T) {
+	dir, ks := tmpKeyStore(t, true)
+	defer os.RemoveAll(dir)
+	key, err := crypto.GenerateKey()
+	if err != nil {
+		t.Fatalf("failed to generate key: %v", key)
+	}
+	if _, err = ks.ImportECDSA(key, "old"); err != nil {
+		t.Errorf("importing failed: %v", err)
+	}
+	if _, err = ks.ImportECDSA(key, "old"); err == nil {
+		t.Errorf("importing same key twice succeeded")
+	}
+	if _, err = ks.ImportECDSA(key, "new"); err == nil {
+		t.Errorf("importing same key twice succeeded")
+	}
+}
+
+// TestImportECDSA tests the import and export functionality of a keystore.
+func TestImportExport(t *testing.T) {
+	dir, ks := tmpKeyStore(t, true)
+	defer os.RemoveAll(dir)
+	acc, err := ks.NewAccount("old")
+	if err != nil {
+		t.Fatalf("failed to create account: %v", acc)
+	}
+	json, err := ks.Export(acc, "old", "new")
+	if err != nil {
+		t.Fatalf("failed to export account: %v", acc)
+	}
+	dir2, ks2 := tmpKeyStore(t, true)
+	defer os.RemoveAll(dir2)
+	if _, err = ks2.Import(json, "old", "old"); err == nil {
+		t.Errorf("importing with invalid password succeeded")
+	}
+	acc2, err := ks2.Import(json, "new", "new")
+	if err != nil {
+		t.Errorf("importing failed: %v", err)
+	}
+	if acc.Address != acc2.Address {
+		t.Error("imported account does not match exported account")
+	}
+	if _, err = ks2.Import(json, "new", "new"); err == nil {
+		t.Errorf("importing a key twice succeeded")
+	}
+
+}
+
+// TestImportRace tests the keystore on races.
+// This test should fail under -race if importing races.
+func TestImportRace(t *testing.T) {
+	dir, ks := tmpKeyStore(t, true)
+	defer os.RemoveAll(dir)
+	acc, err := ks.NewAccount("old")
+	if err != nil {
+		t.Fatalf("failed to create account: %v", acc)
+	}
+	json, err := ks.Export(acc, "old", "new")
+	if err != nil {
+		t.Fatalf("failed to export account: %v", acc)
+	}
+	dir2, ks2 := tmpKeyStore(t, true)
+	defer os.RemoveAll(dir2)
+	var atom uint32
+	var wg sync.WaitGroup
+	wg.Add(2)
+	for i := 0; i < 2; i++ {
+		go func() {
+			defer wg.Done()
+			if _, err := ks2.Import(json, "new", "new"); err != nil {
+				atomic.AddUint32(&atom, 1)
+			}
+
+		}()
+	}
+	wg.Wait()
+	if atom != 1 {
+		t.Errorf("Import is racy")
+	}
+}
+
 // checkAccounts checks that all known live accounts are present in the wallet list.
 func checkAccounts(t *testing.T, live map[common.Address]accounts.Account, wallets []accounts.Wallet) {
 	if len(live) != len(wallets) {
@@ -379,9 +465,9 @@ func tmpKeyStore(t *testing.T, encrypted bool) (string, *KeyStore) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	new := NewPlaintextKeyStore
+	newKs := NewPlaintextKeyStore
 	if encrypted {
-		new = func(kd string) *KeyStore { return NewKeyStore(kd, veryLightScryptN, veryLightScryptP) }
+		newKs = func(kd string) *KeyStore { return NewKeyStore(kd, veryLightScryptN, veryLightScryptP) }
 	}
-	return d, new(d)
+	return d, newKs(d)
 }
diff --git a/accounts/keystore/keystore_wallet.go b/accounts/keystore/keystore_wallet.go
index 677599c49..e9a0c92d6 100644
--- a/accounts/keystore/keystore_wallet.go
+++ b/accounts/keystore/keystore_wallet.go
@@ -19,9 +19,10 @@ package keystore
 import (
 	"math/big"
 
-	ethereum "github.com/truechain/truechain-engineering-code"
+	"github.com/truechain/truechain-engineering-code"
 	"github.com/truechain/truechain-engineering-code/accounts"
 	"github.com/truechain/truechain-engineering-code/core/types"
+	"github.com/truechain/truechain-engineering-code/crypto"
 )
 
 // keystoreWallet implements the accounts.Wallet interface for the original
@@ -76,7 +77,8 @@ func (w *keystoreWallet) Derive(path accounts.DerivationPath, pin bool) (account
 
 // SelfDerive implements accounts.Wallet, but is a noop for plain wallets since
 // there is no notion of hierarchical account derivation for plain keystore accounts.
-func (w *keystoreWallet) SelfDerive(base accounts.DerivationPath, chain ethereum.ChainStateReader) {}
+func (w *keystoreWallet) SelfDerive(base []accounts.DerivationPath, chain truechain.ChainStateReader) {
+}
 
 // SignHash implements accounts.Wallet, attempting to sign the given hash with
 // the given account. If the wallet does not wrap this particular account, an
@@ -110,18 +112,6 @@ func (w *keystoreWallet) SignTx(account accounts.Account, tx *types.Transaction,
 	return w.keystore.SignTx(account, tx, chainID)
 }
 
-func (w *keystoreWallet) SignTx_Payment(account accounts.Account, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) {
-	// Make sure the requested account is contained within
-	if account.Address != w.account.Address {
-		return nil, accounts.ErrUnknownAccount
-	}
-	if account.URL != (accounts.URL{}) && account.URL != w.account.URL {
-		return nil, accounts.ErrUnknownAccount
-	}
-	// Account seems valid, request the keystore to sign
-	return w.keystore.SignTx_Payment(account, tx, chainID)
-}
-
 // SignHashWithPassphrase implements accounts.Wallet, attempting to sign the
 // given hash with the given account using passphrase as extra authentication.
 func (w *keystoreWallet) SignHashWithPassphrase(account accounts.Account, passphrase string, hash []byte) ([]byte, error) {
@@ -149,3 +139,48 @@ func (w *keystoreWallet) SignTxWithPassphrase(account accounts.Account, passphra
 	// Account seems valid, request the keystore to sign
 	return w.keystore.SignTxWithPassphrase(account, passphrase, tx, chainID)
 }
+
+// SignData signs keccak256(data). The mimetype parameter describes the type of data being signed.
+func (w *keystoreWallet) SignData(account accounts.Account, mimeType string, data []byte) ([]byte, error) {
+	return w.signHash(account, crypto.Keccak256(data))
+}
+
+// SignDataWithPassphrase signs keccak256(data). The mimetype parameter describes the type of data being signed.
+func (w *keystoreWallet) SignDataWithPassphrase(account accounts.Account, passphrase, mimeType string, data []byte) ([]byte, error) {
+	// Make sure the requested account is contained within
+	if !w.Contains(account) {
+		return nil, accounts.ErrUnknownAccount
+	}
+	// Account seems valid, request the keystore to sign
+	return w.keystore.SignHashWithPassphrase(account, passphrase, crypto.Keccak256(data))
+}
+
+// SignText implements accounts.Wallet, attempting to sign the hash of
+// the given text with the given account.
+func (w *keystoreWallet) SignText(account accounts.Account, text []byte) ([]byte, error) {
+	return w.signHash(account, accounts.TextHash(text))
+}
+
+// SignTextWithPassphrase implements accounts.Wallet, attempting to sign the
+// hash of the given text with the given account using passphrase as extra authentication.
+func (w *keystoreWallet) SignTextWithPassphrase(account accounts.Account, passphrase string, text []byte) ([]byte, error) {
+	// Make sure the requested account is contained within
+	if !w.Contains(account) {
+		return nil, accounts.ErrUnknownAccount
+	}
+	// Account seems valid, request the keystore to sign
+	return w.keystore.SignHashWithPassphrase(account, passphrase, accounts.TextHash(text))
+}
+
+// signHash attempts to sign the given hash with
+// the given account. If the wallet does not wrap this particular account, an
+// error is returned to avoid account leakage (even though in theory we may be
+// able to sign via our shared keystore backend).
+func (w *keystoreWallet) signHash(account accounts.Account, hash []byte) ([]byte, error) {
+	// Make sure the requested account is contained within
+	if !w.Contains(account) {
+		return nil, accounts.ErrUnknownAccount
+	}
+	// Account seems valid, request the keystore to sign
+	return w.keystore.SignHash(account, hash)
+}
diff --git a/accounts/keystore/presale.go b/accounts/keystore/presale.go
index 162a933d2..234b057bb 100644
--- a/accounts/keystore/presale.go
+++ b/accounts/keystore/presale.go
@@ -25,9 +25,9 @@ import (
 	"errors"
 	"fmt"
 
+	"github.com/google/uuid"
 	"github.com/truechain/truechain-engineering-code/accounts"
 	"github.com/truechain/truechain-engineering-code/crypto"
-	"github.com/pborman/uuid"
 	"golang.org/x/crypto/pbkdf2"
 )
 
@@ -37,8 +37,17 @@ func importPreSaleKey(keyStore keyStore, keyJSON []byte, password string) (accou
 	if err != nil {
 		return accounts.Account{}, nil, err
 	}
-	key.Id = uuid.NewRandom()
-	a := accounts.Account{Address: key.Address, URL: accounts.URL{Scheme: KeyStoreScheme, Path: keyStore.JoinPath(keyFileName(key.Address))}}
+	key.Id, err = uuid.NewRandom()
+	if err != nil {
+		return accounts.Account{}, nil, err
+	}
+	a := accounts.Account{
+		Address: key.Address,
+		URL: accounts.URL{
+			Scheme: KeyStoreScheme,
+			Path:   keyStore.JoinPath(keyFileName(key.Address)),
+		},
+	}
 	err = keyStore.StoreKey(a.URL.Path, key, password)
 	return a, key, err
 }
@@ -80,7 +89,7 @@ func decryptPreSaleKey(fileContent []byte, password string) (key *Key, err error
 	ecKey := crypto.ToECDSAUnsafe(ethPriv)
 
 	key = &Key{
-		Id:         nil,
+		Id:         uuid.UUID{},
 		Address:    crypto.PubkeyToAddress(ecKey.PublicKey),
 		PrivateKey: ecKey,
 	}
diff --git a/accounts/manager.go b/accounts/manager.go
index 5f59a64cc..84438704f 100644
--- a/accounts/manager.go
+++ b/accounts/manager.go
@@ -21,12 +21,22 @@ import (
 	"sort"
 	"sync"
 
+	"github.com/truechain/truechain-engineering-code/common"
 	"github.com/truechain/truechain-engineering-code/event"
 )
 
+// Config contains the settings of the global account manager.
+//
+// TODO(rjl493456442, karalabe, holiman): Get rid of this when account management
+// is removed in favor of Clef.
+type Config struct {
+	InsecureUnlockAllowed bool // Whether account unlocking in insecure environment is allowed
+}
+
 // Manager is an overarching account manager that can communicate with various
 // backends for signing transactions.
 type Manager struct {
+	config   *Config                    // Global account manager configurations
 	backends map[reflect.Type][]Backend // Index of backends currently registered
 	updaters []event.Subscription       // Wallet update subscriptions for all backends
 	updates  chan WalletEvent           // Subscription sink for backend wallet changes
@@ -40,7 +50,7 @@ type Manager struct {
 
 // NewManager creates a generic account manager to sign transaction via various
 // supported backends.
-func NewManager(backends ...Backend) *Manager {
+func NewManager(config *Config, backends ...Backend) *Manager {
 	// Retrieve the initial list of wallets from the backends and sort by URL
 	var wallets []Wallet
 	for _, backend := range backends {
@@ -55,6 +65,7 @@ func NewManager(backends ...Backend) *Manager {
 	}
 	// Assemble the account manager and return
 	am := &Manager{
+		config:   config,
 		backends: make(map[reflect.Type][]Backend),
 		updaters: subs,
 		updates:  updates,
@@ -77,6 +88,11 @@ func (am *Manager) Close() error {
 	return <-errc
 }
 
+// Config returns the configuration of account manager.
+func (am *Manager) Config() *Config {
+	return am.config
+}
+
 // update is the wallet event loop listening for notifications from the backends
 // and updating the cache of wallets.
 func (am *Manager) update() {
@@ -125,6 +141,11 @@ func (am *Manager) Wallets() []Wallet {
 	am.lock.RLock()
 	defer am.lock.RUnlock()
 
+	return am.walletsNoLock()
+}
+
+// walletsNoLock returns all registered wallets. Callers must hold am.lock.
+func (am *Manager) walletsNoLock() []Wallet {
 	cpy := make([]Wallet, len(am.wallets))
 	copy(cpy, am.wallets)
 	return cpy
@@ -139,7 +160,7 @@ func (am *Manager) Wallet(url string) (Wallet, error) {
 	if err != nil {
 		return nil, err
 	}
-	for _, wallet := range am.Wallets() {
+	for _, wallet := range am.walletsNoLock() {
 		if wallet.URL() == parsed {
 			return wallet, nil
 		}
@@ -147,6 +168,20 @@ func (am *Manager) Wallet(url string) (Wallet, error) {
 	return nil, ErrUnknownWallet
 }
 
+// Accounts returns all account addresses of all wallets within the account manager
+func (am *Manager) Accounts() []common.Address {
+	am.lock.RLock()
+	defer am.lock.RUnlock()
+
+	addresses := make([]common.Address, 0) // return [] instead of nil if empty
+	for _, wallet := range am.wallets {
+		for _, account := range wallet.Accounts() {
+			addresses = append(addresses, account.Address)
+		}
+	}
+	return addresses
+}
+
 // Find attempts to locate the wallet corresponding to a specific account. Since
 // accounts can be dynamically added to and removed from wallets, this method has
 // a linear runtime in the number of wallets.
diff --git a/accounts/sort.go b/accounts/sort.go
new file mode 100644
index 000000000..f46762114
--- /dev/null
+++ b/accounts/sort.go
@@ -0,0 +1,31 @@
+// Copyright 2018 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package accounts
+
+// AccountsByURL implements sort.Interface for []Account based on the URL field.
+type AccountsByURL []Account
+
+func (a AccountsByURL) Len() int           { return len(a) }
+func (a AccountsByURL) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+func (a AccountsByURL) Less(i, j int) bool { return a[i].URL.Cmp(a[j].URL) < 0 }
+
+// WalletsByURL implements sort.Interface for []Wallet based on the URL field.
+type WalletsByURL []Wallet
+
+func (w WalletsByURL) Len() int           { return len(w) }
+func (w WalletsByURL) Swap(i, j int)      { w[i], w[j] = w[j], w[i] }
+func (w WalletsByURL) Less(i, j int) bool { return w[i].URL().Cmp(w[j].URL()) < 0 }
diff --git a/accounts/url.go b/accounts/url.go
index a5add1021..12a84414a 100644
--- a/accounts/url.go
+++ b/accounts/url.go
@@ -64,7 +64,7 @@ func (u URL) String() string {
 func (u URL) TerminalString() string {
 	url := u.String()
 	if len(url) > 32 {
-		return url[:31] + "…"
+		return url[:31] + ".."
 	}
 	return url
 }
diff --git a/accounts/url_test.go b/accounts/url_test.go
index 802772871..bd6f35fa2 100644
--- a/accounts/url_test.go
+++ b/accounts/url_test.go
@@ -1,4 +1,4 @@
-// Copyright 2017 The go-ethereum Authors
+// Copyright 2018 The go-ethereum Authors
 // This file is part of the go-ethereum library.
 //
 // The go-ethereum library is free software: you can redistribute it and/or modify
diff --git a/accounts/usbwallet/hub.go b/accounts/usbwallet/hub.go
index 6b76aea04..05eed80a5 100644
--- a/accounts/usbwallet/hub.go
+++ b/accounts/usbwallet/hub.go
@@ -20,12 +20,13 @@ import (
 	"errors"
 	"runtime"
 	"sync"
+	"sync/atomic"
 	"time"
 
+	"github.com/karalabe/usb"
 	"github.com/truechain/truechain-engineering-code/accounts"
 	"github.com/truechain/truechain-engineering-code/event"
 	"github.com/truechain/truechain-engineering-code/log"
-	"github.com/karalabe/hid"
 )
 
 // LedgerScheme is the protocol scheme prefixing account and wallet URLs.
@@ -64,21 +65,41 @@ type Hub struct {
 	// TODO(karalabe): remove if hotplug lands on Windows
 	commsPend int        // Number of operations blocking enumeration
 	commsLock sync.Mutex // Lock protecting the pending counter and enumeration
+	enumFails uint32     // Number of times enumeration has failed
 }
 
 // NewLedgerHub creates a new hardware wallet manager for Ledger devices.
 func NewLedgerHub() (*Hub, error) {
-	return newHub(LedgerScheme, 0x2c97, []uint16{0x0000 /* Ledger Blue */, 0x0001 /* Ledger Nano S */}, 0xffa0, 0, newLedgerDriver)
+	return newHub(LedgerScheme, 0x2c97, []uint16{
+		// Original product IDs
+		0x0000, /* Ledger Blue */
+		0x0001, /* Ledger Nano S */
+		0x0004, /* Ledger Nano X */
+
+		// Upcoming product IDs: https://www.ledger.com/2019/05/17/windows-10-update-sunsetting-u2f-tunnel-transport-for-ledger-devices/
+		0x0015, /* HID + U2F + WebUSB Ledger Blue */
+		0x1015, /* HID + U2F + WebUSB Ledger Nano S */
+		0x4015, /* HID + U2F + WebUSB Ledger Nano X */
+		0x0011, /* HID + WebUSB Ledger Blue */
+		0x1011, /* HID + WebUSB Ledger Nano S */
+		0x4011, /* HID + WebUSB Ledger Nano X */
+	}, 0xffa0, 0, newLedgerDriver)
 }
 
-// NewTrezorHub creates a new hardware wallet manager for Trezor devices.
-func NewTrezorHub() (*Hub, error) {
-	return newHub(TrezorScheme, 0x534c, []uint16{0x0001 /* Trezor 1 */}, 0xff00, 0, newTrezorDriver)
+// NewTrezorHubWithHID creates a new hardware wallet manager for Trezor devices.
+func NewTrezorHubWithHID() (*Hub, error) {
+	return newHub(TrezorScheme, 0x534c, []uint16{0x0001 /* Trezor HID */}, 0xff00, 0, newTrezorDriver)
+}
+
+// NewTrezorHubWithWebUSB creates a new hardware wallet manager for Trezor devices with
+// firmware version > 1.8.0
+func NewTrezorHubWithWebUSB() (*Hub, error) {
+	return newHub(TrezorScheme, 0x1209, []uint16{0x53c1 /* Trezor WebUSB */}, 0xffff /* No usage id on webusb, don't match unset (0) */, 0, newTrezorDriver)
 }
 
 // newHub creates a new hardware wallet manager for generic USB devices.
 func newHub(scheme string, vendorID uint16, productIDs []uint16, usageID uint16, endpointID int, makeDriver func(log.Logger) driver) (*Hub, error) {
-	if !hid.Supported() {
+	if !usb.Supported() {
 		return nil, errors.New("unsupported platform")
 	}
 	hub := &Hub{
@@ -119,8 +140,12 @@ func (hub *Hub) refreshWallets() {
 	if elapsed < refreshThrottling {
 		return
 	}
+	// If USB enumeration is continually failing, don't keep trying indefinitely
+	if atomic.LoadUint32(&hub.enumFails) > 2 {
+		return
+	}
 	// Retrieve the current list of USB wallet devices
-	var devices []hid.DeviceInfo
+	var devices []usb.DeviceInfo
 
 	if runtime.GOOS == "linux" {
 		// hidapi on Linux opens the device during enumeration to retrieve some infos,
@@ -135,8 +160,22 @@ func (hub *Hub) refreshWallets() {
 			return
 		}
 	}
-	for _, info := range hid.Enumerate(hub.vendorID, 0) {
+	infos, err := usb.Enumerate(hub.vendorID, 0)
+	if err != nil {
+		failcount := atomic.AddUint32(&hub.enumFails, 1)
+		if runtime.GOOS == "linux" {
+			// See rationale before the enumeration why this is needed and only on Linux.
+			hub.commsLock.Unlock()
+		}
+		log.Error("Failed to enumerate USB devices", "hub", hub.scheme,
+			"vendor", hub.vendorID, "failcount", failcount, "err", err)
+		return
+	}
+	atomic.StoreUint32(&hub.enumFails, 0)
+
+	for _, info := range infos {
 		for _, id := range hub.productIDs {
+			// Windows and Macos use UsageID matching, Linux uses Interface matching
 			if info.ProductID == id && (info.UsagePage == hub.usageID || info.Interface == hub.endpointID) {
 				devices = append(devices, info)
 				break
@@ -150,8 +189,10 @@ func (hub *Hub) refreshWallets() {
 	// Transform the current list of wallets into the new one
 	hub.stateLock.Lock()
 
-	wallets := make([]accounts.Wallet, 0, len(devices))
-	events := []accounts.WalletEvent{}
+	var (
+		wallets = make([]accounts.Wallet, 0, len(devices))
+		events  []accounts.WalletEvent
+	)
 
 	for _, device := range devices {
 		url := accounts.URL{Scheme: hub.scheme, Path: device.Path}
diff --git a/accounts/usbwallet/internal/trezor/messages.pb.go b/accounts/usbwallet/internal/trezor/messages.pb.go
deleted file mode 100644
index 15bb6fb73..000000000
--- a/accounts/usbwallet/internal/trezor/messages.pb.go
+++ /dev/null
@@ -1,3081 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: messages.proto
-
-package trezor
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// *
-// Mapping between Trezor wire identifier (uint) and a protobuf message
-type MessageType int32
-
-const (
-	MessageType_MessageType_Initialize               MessageType = 0
-	MessageType_MessageType_Ping                     MessageType = 1
-	MessageType_MessageType_Success                  MessageType = 2
-	MessageType_MessageType_Failure                  MessageType = 3
-	MessageType_MessageType_ChangePin                MessageType = 4
-	MessageType_MessageType_WipeDevice               MessageType = 5
-	MessageType_MessageType_FirmwareErase            MessageType = 6
-	MessageType_MessageType_FirmwareUpload           MessageType = 7
-	MessageType_MessageType_FirmwareRequest          MessageType = 8
-	MessageType_MessageType_GetEntropy               MessageType = 9
-	MessageType_MessageType_Entropy                  MessageType = 10
-	MessageType_MessageType_GetPublicKey             MessageType = 11
-	MessageType_MessageType_PublicKey                MessageType = 12
-	MessageType_MessageType_LoadDevice               MessageType = 13
-	MessageType_MessageType_ResetDevice              MessageType = 14
-	MessageType_MessageType_SignTx                   MessageType = 15
-	MessageType_MessageType_SimpleSignTx             MessageType = 16
-	MessageType_MessageType_Features                 MessageType = 17
-	MessageType_MessageType_PinMatrixRequest         MessageType = 18
-	MessageType_MessageType_PinMatrixAck             MessageType = 19
-	MessageType_MessageType_Cancel                   MessageType = 20
-	MessageType_MessageType_TxRequest                MessageType = 21
-	MessageType_MessageType_TxAck                    MessageType = 22
-	MessageType_MessageType_CipherKeyValue           MessageType = 23
-	MessageType_MessageType_ClearSession             MessageType = 24
-	MessageType_MessageType_ApplySettings            MessageType = 25
-	MessageType_MessageType_ButtonRequest            MessageType = 26
-	MessageType_MessageType_ButtonAck                MessageType = 27
-	MessageType_MessageType_ApplyFlags               MessageType = 28
-	MessageType_MessageType_GetAddress               MessageType = 29
-	MessageType_MessageType_Address                  MessageType = 30
-	MessageType_MessageType_SelfTest                 MessageType = 32
-	MessageType_MessageType_BackupDevice             MessageType = 34
-	MessageType_MessageType_EntropyRequest           MessageType = 35
-	MessageType_MessageType_EntropyAck               MessageType = 36
-	MessageType_MessageType_SignMessage              MessageType = 38
-	MessageType_MessageType_VerifyMessage            MessageType = 39
-	MessageType_MessageType_MessageSignature         MessageType = 40
-	MessageType_MessageType_PassphraseRequest        MessageType = 41
-	MessageType_MessageType_PassphraseAck            MessageType = 42
-	MessageType_MessageType_EstimateTxSize           MessageType = 43
-	MessageType_MessageType_TxSize                   MessageType = 44
-	MessageType_MessageType_RecoveryDevice           MessageType = 45
-	MessageType_MessageType_WordRequest              MessageType = 46
-	MessageType_MessageType_WordAck                  MessageType = 47
-	MessageType_MessageType_CipheredKeyValue         MessageType = 48
-	MessageType_MessageType_EncryptMessage           MessageType = 49
-	MessageType_MessageType_EncryptedMessage         MessageType = 50
-	MessageType_MessageType_DecryptMessage           MessageType = 51
-	MessageType_MessageType_DecryptedMessage         MessageType = 52
-	MessageType_MessageType_SignIdentity             MessageType = 53
-	MessageType_MessageType_SignedIdentity           MessageType = 54
-	MessageType_MessageType_GetFeatures              MessageType = 55
-	MessageType_MessageType_EthereumGetAddress       MessageType = 56
-	MessageType_MessageType_EthereumAddress          MessageType = 57
-	MessageType_MessageType_EthereumSignTx           MessageType = 58
-	MessageType_MessageType_EthereumTxRequest        MessageType = 59
-	MessageType_MessageType_EthereumTxAck            MessageType = 60
-	MessageType_MessageType_GetECDHSessionKey        MessageType = 61
-	MessageType_MessageType_ECDHSessionKey           MessageType = 62
-	MessageType_MessageType_SetU2FCounter            MessageType = 63
-	MessageType_MessageType_EthereumSignMessage      MessageType = 64
-	MessageType_MessageType_EthereumVerifyMessage    MessageType = 65
-	MessageType_MessageType_EthereumMessageSignature MessageType = 66
-	MessageType_MessageType_DebugLinkDecision        MessageType = 100
-	MessageType_MessageType_DebugLinkGetState        MessageType = 101
-	MessageType_MessageType_DebugLinkState           MessageType = 102
-	MessageType_MessageType_DebugLinkStop            MessageType = 103
-	MessageType_MessageType_DebugLinkLog             MessageType = 104
-	MessageType_MessageType_DebugLinkMemoryRead      MessageType = 110
-	MessageType_MessageType_DebugLinkMemory          MessageType = 111
-	MessageType_MessageType_DebugLinkMemoryWrite     MessageType = 112
-	MessageType_MessageType_DebugLinkFlashErase      MessageType = 113
-)
-
-var MessageType_name = map[int32]string{
-	0:   "MessageType_Initialize",
-	1:   "MessageType_Ping",
-	2:   "MessageType_Success",
-	3:   "MessageType_Failure",
-	4:   "MessageType_ChangePin",
-	5:   "MessageType_WipeDevice",
-	6:   "MessageType_FirmwareErase",
-	7:   "MessageType_FirmwareUpload",
-	8:   "MessageType_FirmwareRequest",
-	9:   "MessageType_GetEntropy",
-	10:  "MessageType_Entropy",
-	11:  "MessageType_GetPublicKey",
-	12:  "MessageType_PublicKey",
-	13:  "MessageType_LoadDevice",
-	14:  "MessageType_ResetDevice",
-	15:  "MessageType_SignTx",
-	16:  "MessageType_SimpleSignTx",
-	17:  "MessageType_Features",
-	18:  "MessageType_PinMatrixRequest",
-	19:  "MessageType_PinMatrixAck",
-	20:  "MessageType_Cancel",
-	21:  "MessageType_TxRequest",
-	22:  "MessageType_TxAck",
-	23:  "MessageType_CipherKeyValue",
-	24:  "MessageType_ClearSession",
-	25:  "MessageType_ApplySettings",
-	26:  "MessageType_ButtonRequest",
-	27:  "MessageType_ButtonAck",
-	28:  "MessageType_ApplyFlags",
-	29:  "MessageType_GetAddress",
-	30:  "MessageType_Address",
-	32:  "MessageType_SelfTest",
-	34:  "MessageType_BackupDevice",
-	35:  "MessageType_EntropyRequest",
-	36:  "MessageType_EntropyAck",
-	38:  "MessageType_SignMessage",
-	39:  "MessageType_VerifyMessage",
-	40:  "MessageType_MessageSignature",
-	41:  "MessageType_PassphraseRequest",
-	42:  "MessageType_PassphraseAck",
-	43:  "MessageType_EstimateTxSize",
-	44:  "MessageType_TxSize",
-	45:  "MessageType_RecoveryDevice",
-	46:  "MessageType_WordRequest",
-	47:  "MessageType_WordAck",
-	48:  "MessageType_CipheredKeyValue",
-	49:  "MessageType_EncryptMessage",
-	50:  "MessageType_EncryptedMessage",
-	51:  "MessageType_DecryptMessage",
-	52:  "MessageType_DecryptedMessage",
-	53:  "MessageType_SignIdentity",
-	54:  "MessageType_SignedIdentity",
-	55:  "MessageType_GetFeatures",
-	56:  "MessageType_EthereumGetAddress",
-	57:  "MessageType_EthereumAddress",
-	58:  "MessageType_EthereumSignTx",
-	59:  "MessageType_EthereumTxRequest",
-	60:  "MessageType_EthereumTxAck",
-	61:  "MessageType_GetECDHSessionKey",
-	62:  "MessageType_ECDHSessionKey",
-	63:  "MessageType_SetU2FCounter",
-	64:  "MessageType_EthereumSignMessage",
-	65:  "MessageType_EthereumVerifyMessage",
-	66:  "MessageType_EthereumMessageSignature",
-	100: "MessageType_DebugLinkDecision",
-	101: "MessageType_DebugLinkGetState",
-	102: "MessageType_DebugLinkState",
-	103: "MessageType_DebugLinkStop",
-	104: "MessageType_DebugLinkLog",
-	110: "MessageType_DebugLinkMemoryRead",
-	111: "MessageType_DebugLinkMemory",
-	112: "MessageType_DebugLinkMemoryWrite",
-	113: "MessageType_DebugLinkFlashErase",
-}
-var MessageType_value = map[string]int32{
-	"MessageType_Initialize":               0,
-	"MessageType_Ping":                     1,
-	"MessageType_Success":                  2,
-	"MessageType_Failure":                  3,
-	"MessageType_ChangePin":                4,
-	"MessageType_WipeDevice":               5,
-	"MessageType_FirmwareErase":            6,
-	"MessageType_FirmwareUpload":           7,
-	"MessageType_FirmwareRequest":          8,
-	"MessageType_GetEntropy":               9,
-	"MessageType_Entropy":                  10,
-	"MessageType_GetPublicKey":             11,
-	"MessageType_PublicKey":                12,
-	"MessageType_LoadDevice":               13,
-	"MessageType_ResetDevice":              14,
-	"MessageType_SignTx":                   15,
-	"MessageType_SimpleSignTx":             16,
-	"MessageType_Features":                 17,
-	"MessageType_PinMatrixRequest":         18,
-	"MessageType_PinMatrixAck":             19,
-	"MessageType_Cancel":                   20,
-	"MessageType_TxRequest":                21,
-	"MessageType_TxAck":                    22,
-	"MessageType_CipherKeyValue":           23,
-	"MessageType_ClearSession":             24,
-	"MessageType_ApplySettings":            25,
-	"MessageType_ButtonRequest":            26,
-	"MessageType_ButtonAck":                27,
-	"MessageType_ApplyFlags":               28,
-	"MessageType_GetAddress":               29,
-	"MessageType_Address":                  30,
-	"MessageType_SelfTest":                 32,
-	"MessageType_BackupDevice":             34,
-	"MessageType_EntropyRequest":           35,
-	"MessageType_EntropyAck":               36,
-	"MessageType_SignMessage":              38,
-	"MessageType_VerifyMessage":            39,
-	"MessageType_MessageSignature":         40,
-	"MessageType_PassphraseRequest":        41,
-	"MessageType_PassphraseAck":            42,
-	"MessageType_EstimateTxSize":           43,
-	"MessageType_TxSize":                   44,
-	"MessageType_RecoveryDevice":           45,
-	"MessageType_WordRequest":              46,
-	"MessageType_WordAck":                  47,
-	"MessageType_CipheredKeyValue":         48,
-	"MessageType_EncryptMessage":           49,
-	"MessageType_EncryptedMessage":         50,
-	"MessageType_DecryptMessage":           51,
-	"MessageType_DecryptedMessage":         52,
-	"MessageType_SignIdentity":             53,
-	"MessageType_SignedIdentity":           54,
-	"MessageType_GetFeatures":              55,
-	"MessageType_EthereumGetAddress":       56,
-	"MessageType_EthereumAddress":          57,
-	"MessageType_EthereumSignTx":           58,
-	"MessageType_EthereumTxRequest":        59,
-	"MessageType_EthereumTxAck":            60,
-	"MessageType_GetECDHSessionKey":        61,
-	"MessageType_ECDHSessionKey":           62,
-	"MessageType_SetU2FCounter":            63,
-	"MessageType_EthereumSignMessage":      64,
-	"MessageType_EthereumVerifyMessage":    65,
-	"MessageType_EthereumMessageSignature": 66,
-	"MessageType_DebugLinkDecision":        100,
-	"MessageType_DebugLinkGetState":        101,
-	"MessageType_DebugLinkState":           102,
-	"MessageType_DebugLinkStop":            103,
-	"MessageType_DebugLinkLog":             104,
-	"MessageType_DebugLinkMemoryRead":      110,
-	"MessageType_DebugLinkMemory":          111,
-	"MessageType_DebugLinkMemoryWrite":     112,
-	"MessageType_DebugLinkFlashErase":      113,
-}
-
-func (x MessageType) Enum() *MessageType {
-	p := new(MessageType)
-	*p = x
-	return p
-}
-func (x MessageType) String() string {
-	return proto.EnumName(MessageType_name, int32(x))
-}
-func (x *MessageType) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(MessageType_value, data, "MessageType")
-	if err != nil {
-		return err
-	}
-	*x = MessageType(value)
-	return nil
-}
-func (MessageType) EnumDescriptor() ([]byte, []int) { return fileDescriptor1, []int{0} }
-
-// *
-// Request: Reset device to default state and ask for device details
-// @next Features
-type Initialize struct {
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *Initialize) Reset()                    { *m = Initialize{} }
-func (m *Initialize) String() string            { return proto.CompactTextString(m) }
-func (*Initialize) ProtoMessage()               {}
-func (*Initialize) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0} }
-
-// *
-// Request: Ask for device details (no device reset)
-// @next Features
-type GetFeatures struct {
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *GetFeatures) Reset()                    { *m = GetFeatures{} }
-func (m *GetFeatures) String() string            { return proto.CompactTextString(m) }
-func (*GetFeatures) ProtoMessage()               {}
-func (*GetFeatures) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{1} }
-
-// *
-// Response: Reports various information about the device
-// @prev Initialize
-// @prev GetFeatures
-type Features struct {
-	Vendor               *string     `protobuf:"bytes,1,opt,name=vendor" json:"vendor,omitempty"`
-	MajorVersion         *uint32     `protobuf:"varint,2,opt,name=major_version,json=majorVersion" json:"major_version,omitempty"`
-	MinorVersion         *uint32     `protobuf:"varint,3,opt,name=minor_version,json=minorVersion" json:"minor_version,omitempty"`
-	PatchVersion         *uint32     `protobuf:"varint,4,opt,name=patch_version,json=patchVersion" json:"patch_version,omitempty"`
-	BootloaderMode       *bool       `protobuf:"varint,5,opt,name=bootloader_mode,json=bootloaderMode" json:"bootloader_mode,omitempty"`
-	DeviceId             *string     `protobuf:"bytes,6,opt,name=device_id,json=deviceId" json:"device_id,omitempty"`
-	PinProtection        *bool       `protobuf:"varint,7,opt,name=pin_protection,json=pinProtection" json:"pin_protection,omitempty"`
-	PassphraseProtection *bool       `protobuf:"varint,8,opt,name=passphrase_protection,json=passphraseProtection" json:"passphrase_protection,omitempty"`
-	Language             *string     `protobuf:"bytes,9,opt,name=language" json:"language,omitempty"`
-	Label                *string     `protobuf:"bytes,10,opt,name=label" json:"label,omitempty"`
-	Coins                []*CoinType `protobuf:"bytes,11,rep,name=coins" json:"coins,omitempty"`
-	Initialized          *bool       `protobuf:"varint,12,opt,name=initialized" json:"initialized,omitempty"`
-	Revision             []byte      `protobuf:"bytes,13,opt,name=revision" json:"revision,omitempty"`
-	BootloaderHash       []byte      `protobuf:"bytes,14,opt,name=bootloader_hash,json=bootloaderHash" json:"bootloader_hash,omitempty"`
-	Imported             *bool       `protobuf:"varint,15,opt,name=imported" json:"imported,omitempty"`
-	PinCached            *bool       `protobuf:"varint,16,opt,name=pin_cached,json=pinCached" json:"pin_cached,omitempty"`
-	PassphraseCached     *bool       `protobuf:"varint,17,opt,name=passphrase_cached,json=passphraseCached" json:"passphrase_cached,omitempty"`
-	FirmwarePresent      *bool       `protobuf:"varint,18,opt,name=firmware_present,json=firmwarePresent" json:"firmware_present,omitempty"`
-	NeedsBackup          *bool       `protobuf:"varint,19,opt,name=needs_backup,json=needsBackup" json:"needs_backup,omitempty"`
-	Flags                *uint32     `protobuf:"varint,20,opt,name=flags" json:"flags,omitempty"`
-	XXX_unrecognized     []byte      `json:"-"`
-}
-
-func (m *Features) Reset()                    { *m = Features{} }
-func (m *Features) String() string            { return proto.CompactTextString(m) }
-func (*Features) ProtoMessage()               {}
-func (*Features) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{2} }
-
-func (m *Features) GetVendor() string {
-	if m != nil && m.Vendor != nil {
-		return *m.Vendor
-	}
-	return ""
-}
-
-func (m *Features) GetMajorVersion() uint32 {
-	if m != nil && m.MajorVersion != nil {
-		return *m.MajorVersion
-	}
-	return 0
-}
-
-func (m *Features) GetMinorVersion() uint32 {
-	if m != nil && m.MinorVersion != nil {
-		return *m.MinorVersion
-	}
-	return 0
-}
-
-func (m *Features) GetPatchVersion() uint32 {
-	if m != nil && m.PatchVersion != nil {
-		return *m.PatchVersion
-	}
-	return 0
-}
-
-func (m *Features) GetBootloaderMode() bool {
-	if m != nil && m.BootloaderMode != nil {
-		return *m.BootloaderMode
-	}
-	return false
-}
-
-func (m *Features) GetDeviceId() string {
-	if m != nil && m.DeviceId != nil {
-		return *m.DeviceId
-	}
-	return ""
-}
-
-func (m *Features) GetPinProtection() bool {
-	if m != nil && m.PinProtection != nil {
-		return *m.PinProtection
-	}
-	return false
-}
-
-func (m *Features) GetPassphraseProtection() bool {
-	if m != nil && m.PassphraseProtection != nil {
-		return *m.PassphraseProtection
-	}
-	return false
-}
-
-func (m *Features) GetLanguage() string {
-	if m != nil && m.Language != nil {
-		return *m.Language
-	}
-	return ""
-}
-
-func (m *Features) GetLabel() string {
-	if m != nil && m.Label != nil {
-		return *m.Label
-	}
-	return ""
-}
-
-func (m *Features) GetCoins() []*CoinType {
-	if m != nil {
-		return m.Coins
-	}
-	return nil
-}
-
-func (m *Features) GetInitialized() bool {
-	if m != nil && m.Initialized != nil {
-		return *m.Initialized
-	}
-	return false
-}
-
-func (m *Features) GetRevision() []byte {
-	if m != nil {
-		return m.Revision
-	}
-	return nil
-}
-
-func (m *Features) GetBootloaderHash() []byte {
-	if m != nil {
-		return m.BootloaderHash
-	}
-	return nil
-}
-
-func (m *Features) GetImported() bool {
-	if m != nil && m.Imported != nil {
-		return *m.Imported
-	}
-	return false
-}
-
-func (m *Features) GetPinCached() bool {
-	if m != nil && m.PinCached != nil {
-		return *m.PinCached
-	}
-	return false
-}
-
-func (m *Features) GetPassphraseCached() bool {
-	if m != nil && m.PassphraseCached != nil {
-		return *m.PassphraseCached
-	}
-	return false
-}
-
-func (m *Features) GetFirmwarePresent() bool {
-	if m != nil && m.FirmwarePresent != nil {
-		return *m.FirmwarePresent
-	}
-	return false
-}
-
-func (m *Features) GetNeedsBackup() bool {
-	if m != nil && m.NeedsBackup != nil {
-		return *m.NeedsBackup
-	}
-	return false
-}
-
-func (m *Features) GetFlags() uint32 {
-	if m != nil && m.Flags != nil {
-		return *m.Flags
-	}
-	return 0
-}
-
-// *
-// Request: clear session (removes cached PIN, passphrase, etc).
-// @next Success
-type ClearSession struct {
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *ClearSession) Reset()                    { *m = ClearSession{} }
-func (m *ClearSession) String() string            { return proto.CompactTextString(m) }
-func (*ClearSession) ProtoMessage()               {}
-func (*ClearSession) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{3} }
-
-// *
-// Request: change language and/or label of the device
-// @next Success
-// @next Failure
-// @next ButtonRequest
-// @next PinMatrixRequest
-type ApplySettings struct {
-	Language         *string `protobuf:"bytes,1,opt,name=language" json:"language,omitempty"`
-	Label            *string `protobuf:"bytes,2,opt,name=label" json:"label,omitempty"`
-	UsePassphrase    *bool   `protobuf:"varint,3,opt,name=use_passphrase,json=usePassphrase" json:"use_passphrase,omitempty"`
-	Homescreen       []byte  `protobuf:"bytes,4,opt,name=homescreen" json:"homescreen,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *ApplySettings) Reset()                    { *m = ApplySettings{} }
-func (m *ApplySettings) String() string            { return proto.CompactTextString(m) }
-func (*ApplySettings) ProtoMessage()               {}
-func (*ApplySettings) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{4} }
-
-func (m *ApplySettings) GetLanguage() string {
-	if m != nil && m.Language != nil {
-		return *m.Language
-	}
-	return ""
-}
-
-func (m *ApplySettings) GetLabel() string {
-	if m != nil && m.Label != nil {
-		return *m.Label
-	}
-	return ""
-}
-
-func (m *ApplySettings) GetUsePassphrase() bool {
-	if m != nil && m.UsePassphrase != nil {
-		return *m.UsePassphrase
-	}
-	return false
-}
-
-func (m *ApplySettings) GetHomescreen() []byte {
-	if m != nil {
-		return m.Homescreen
-	}
-	return nil
-}
-
-// *
-// Request: set flags of the device
-// @next Success
-// @next Failure
-type ApplyFlags struct {
-	Flags            *uint32 `protobuf:"varint,1,opt,name=flags" json:"flags,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *ApplyFlags) Reset()                    { *m = ApplyFlags{} }
-func (m *ApplyFlags) String() string            { return proto.CompactTextString(m) }
-func (*ApplyFlags) ProtoMessage()               {}
-func (*ApplyFlags) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{5} }
-
-func (m *ApplyFlags) GetFlags() uint32 {
-	if m != nil && m.Flags != nil {
-		return *m.Flags
-	}
-	return 0
-}
-
-// *
-// Request: Starts workflow for setting/changing/removing the PIN
-// @next ButtonRequest
-// @next PinMatrixRequest
-type ChangePin struct {
-	Remove           *bool  `protobuf:"varint,1,opt,name=remove" json:"remove,omitempty"`
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *ChangePin) Reset()                    { *m = ChangePin{} }
-func (m *ChangePin) String() string            { return proto.CompactTextString(m) }
-func (*ChangePin) ProtoMessage()               {}
-func (*ChangePin) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{6} }
-
-func (m *ChangePin) GetRemove() bool {
-	if m != nil && m.Remove != nil {
-		return *m.Remove
-	}
-	return false
-}
-
-// *
-// Request: Test if the device is alive, device sends back the message in Success response
-// @next Success
-type Ping struct {
-	Message              *string `protobuf:"bytes,1,opt,name=message" json:"message,omitempty"`
-	ButtonProtection     *bool   `protobuf:"varint,2,opt,name=button_protection,json=buttonProtection" json:"button_protection,omitempty"`
-	PinProtection        *bool   `protobuf:"varint,3,opt,name=pin_protection,json=pinProtection" json:"pin_protection,omitempty"`
-	PassphraseProtection *bool   `protobuf:"varint,4,opt,name=passphrase_protection,json=passphraseProtection" json:"passphrase_protection,omitempty"`
-	XXX_unrecognized     []byte  `json:"-"`
-}
-
-func (m *Ping) Reset()                    { *m = Ping{} }
-func (m *Ping) String() string            { return proto.CompactTextString(m) }
-func (*Ping) ProtoMessage()               {}
-func (*Ping) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{7} }
-
-func (m *Ping) GetMessage() string {
-	if m != nil && m.Message != nil {
-		return *m.Message
-	}
-	return ""
-}
-
-func (m *Ping) GetButtonProtection() bool {
-	if m != nil && m.ButtonProtection != nil {
-		return *m.ButtonProtection
-	}
-	return false
-}
-
-func (m *Ping) GetPinProtection() bool {
-	if m != nil && m.PinProtection != nil {
-		return *m.PinProtection
-	}
-	return false
-}
-
-func (m *Ping) GetPassphraseProtection() bool {
-	if m != nil && m.PassphraseProtection != nil {
-		return *m.PassphraseProtection
-	}
-	return false
-}
-
-// *
-// Response: Success of the previous request
-type Success struct {
-	Message          *string `protobuf:"bytes,1,opt,name=message" json:"message,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *Success) Reset()                    { *m = Success{} }
-func (m *Success) String() string            { return proto.CompactTextString(m) }
-func (*Success) ProtoMessage()               {}
-func (*Success) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{8} }
-
-func (m *Success) GetMessage() string {
-	if m != nil && m.Message != nil {
-		return *m.Message
-	}
-	return ""
-}
-
-// *
-// Response: Failure of the previous request
-type Failure struct {
-	Code             *FailureType `protobuf:"varint,1,opt,name=code,enum=FailureType" json:"code,omitempty"`
-	Message          *string      `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
-	XXX_unrecognized []byte       `json:"-"`
-}
-
-func (m *Failure) Reset()                    { *m = Failure{} }
-func (m *Failure) String() string            { return proto.CompactTextString(m) }
-func (*Failure) ProtoMessage()               {}
-func (*Failure) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{9} }
-
-func (m *Failure) GetCode() FailureType {
-	if m != nil && m.Code != nil {
-		return *m.Code
-	}
-	return FailureType_Failure_UnexpectedMessage
-}
-
-func (m *Failure) GetMessage() string {
-	if m != nil && m.Message != nil {
-		return *m.Message
-	}
-	return ""
-}
-
-// *
-// Response: Device is waiting for HW button press.
-// @next ButtonAck
-// @next Cancel
-type ButtonRequest struct {
-	Code             *ButtonRequestType `protobuf:"varint,1,opt,name=code,enum=ButtonRequestType" json:"code,omitempty"`
-	Data             *string            `protobuf:"bytes,2,opt,name=data" json:"data,omitempty"`
-	XXX_unrecognized []byte             `json:"-"`
-}
-
-func (m *ButtonRequest) Reset()                    { *m = ButtonRequest{} }
-func (m *ButtonRequest) String() string            { return proto.CompactTextString(m) }
-func (*ButtonRequest) ProtoMessage()               {}
-func (*ButtonRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{10} }
-
-func (m *ButtonRequest) GetCode() ButtonRequestType {
-	if m != nil && m.Code != nil {
-		return *m.Code
-	}
-	return ButtonRequestType_ButtonRequest_Other
-}
-
-func (m *ButtonRequest) GetData() string {
-	if m != nil && m.Data != nil {
-		return *m.Data
-	}
-	return ""
-}
-
-// *
-// Request: Computer agrees to wait for HW button press
-// @prev ButtonRequest
-type ButtonAck struct {
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *ButtonAck) Reset()                    { *m = ButtonAck{} }
-func (m *ButtonAck) String() string            { return proto.CompactTextString(m) }
-func (*ButtonAck) ProtoMessage()               {}
-func (*ButtonAck) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{11} }
-
-// *
-// Response: Device is asking computer to show PIN matrix and awaits PIN encoded using this matrix scheme
-// @next PinMatrixAck
-// @next Cancel
-type PinMatrixRequest struct {
-	Type             *PinMatrixRequestType `protobuf:"varint,1,opt,name=type,enum=PinMatrixRequestType" json:"type,omitempty"`
-	XXX_unrecognized []byte                `json:"-"`
-}
-
-func (m *PinMatrixRequest) Reset()                    { *m = PinMatrixRequest{} }
-func (m *PinMatrixRequest) String() string            { return proto.CompactTextString(m) }
-func (*PinMatrixRequest) ProtoMessage()               {}
-func (*PinMatrixRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{12} }
-
-func (m *PinMatrixRequest) GetType() PinMatrixRequestType {
-	if m != nil && m.Type != nil {
-		return *m.Type
-	}
-	return PinMatrixRequestType_PinMatrixRequestType_Current
-}
-
-// *
-// Request: Computer responds with encoded PIN
-// @prev PinMatrixRequest
-type PinMatrixAck struct {
-	Pin              *string `protobuf:"bytes,1,req,name=pin" json:"pin,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *PinMatrixAck) Reset()                    { *m = PinMatrixAck{} }
-func (m *PinMatrixAck) String() string            { return proto.CompactTextString(m) }
-func (*PinMatrixAck) ProtoMessage()               {}
-func (*PinMatrixAck) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{13} }
-
-func (m *PinMatrixAck) GetPin() string {
-	if m != nil && m.Pin != nil {
-		return *m.Pin
-	}
-	return ""
-}
-
-// *
-// Request: Abort last operation that required user interaction
-// @prev ButtonRequest
-// @prev PinMatrixRequest
-// @prev PassphraseRequest
-type Cancel struct {
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *Cancel) Reset()                    { *m = Cancel{} }
-func (m *Cancel) String() string            { return proto.CompactTextString(m) }
-func (*Cancel) ProtoMessage()               {}
-func (*Cancel) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{14} }
-
-// *
-// Response: Device awaits encryption passphrase
-// @next PassphraseAck
-// @next Cancel
-type PassphraseRequest struct {
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *PassphraseRequest) Reset()                    { *m = PassphraseRequest{} }
-func (m *PassphraseRequest) String() string            { return proto.CompactTextString(m) }
-func (*PassphraseRequest) ProtoMessage()               {}
-func (*PassphraseRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{15} }
-
-// *
-// Request: Send passphrase back
-// @prev PassphraseRequest
-type PassphraseAck struct {
-	Passphrase       *string `protobuf:"bytes,1,req,name=passphrase" json:"passphrase,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *PassphraseAck) Reset()                    { *m = PassphraseAck{} }
-func (m *PassphraseAck) String() string            { return proto.CompactTextString(m) }
-func (*PassphraseAck) ProtoMessage()               {}
-func (*PassphraseAck) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{16} }
-
-func (m *PassphraseAck) GetPassphrase() string {
-	if m != nil && m.Passphrase != nil {
-		return *m.Passphrase
-	}
-	return ""
-}
-
-// *
-// Request: Request a sample of random data generated by hardware RNG. May be used for testing.
-// @next ButtonRequest
-// @next Entropy
-// @next Failure
-type GetEntropy struct {
-	Size             *uint32 `protobuf:"varint,1,req,name=size" json:"size,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *GetEntropy) Reset()                    { *m = GetEntropy{} }
-func (m *GetEntropy) String() string            { return proto.CompactTextString(m) }
-func (*GetEntropy) ProtoMessage()               {}
-func (*GetEntropy) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{17} }
-
-func (m *GetEntropy) GetSize() uint32 {
-	if m != nil && m.Size != nil {
-		return *m.Size
-	}
-	return 0
-}
-
-// *
-// Response: Reply with random data generated by internal RNG
-// @prev GetEntropy
-type Entropy struct {
-	Entropy          []byte `protobuf:"bytes,1,req,name=entropy" json:"entropy,omitempty"`
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *Entropy) Reset()                    { *m = Entropy{} }
-func (m *Entropy) String() string            { return proto.CompactTextString(m) }
-func (*Entropy) ProtoMessage()               {}
-func (*Entropy) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{18} }
-
-func (m *Entropy) GetEntropy() []byte {
-	if m != nil {
-		return m.Entropy
-	}
-	return nil
-}
-
-// *
-// Request: Ask device for public key corresponding to address_n path
-// @next PassphraseRequest
-// @next PublicKey
-// @next Failure
-type GetPublicKey struct {
-	AddressN         []uint32 `protobuf:"varint,1,rep,name=address_n,json=addressN" json:"address_n,omitempty"`
-	EcdsaCurveName   *string  `protobuf:"bytes,2,opt,name=ecdsa_curve_name,json=ecdsaCurveName" json:"ecdsa_curve_name,omitempty"`
-	ShowDisplay      *bool    `protobuf:"varint,3,opt,name=show_display,json=showDisplay" json:"show_display,omitempty"`
-	CoinName         *string  `protobuf:"bytes,4,opt,name=coin_name,json=coinName,def=Bitcoin" json:"coin_name,omitempty"`
-	XXX_unrecognized []byte   `json:"-"`
-}
-
-func (m *GetPublicKey) Reset()                    { *m = GetPublicKey{} }
-func (m *GetPublicKey) String() string            { return proto.CompactTextString(m) }
-func (*GetPublicKey) ProtoMessage()               {}
-func (*GetPublicKey) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{19} }
-
-const Default_GetPublicKey_CoinName string = "Bitcoin"
-
-func (m *GetPublicKey) GetAddressN() []uint32 {
-	if m != nil {
-		return m.AddressN
-	}
-	return nil
-}
-
-func (m *GetPublicKey) GetEcdsaCurveName() string {
-	if m != nil && m.EcdsaCurveName != nil {
-		return *m.EcdsaCurveName
-	}
-	return ""
-}
-
-func (m *GetPublicKey) GetShowDisplay() bool {
-	if m != nil && m.ShowDisplay != nil {
-		return *m.ShowDisplay
-	}
-	return false
-}
-
-func (m *GetPublicKey) GetCoinName() string {
-	if m != nil && m.CoinName != nil {
-		return *m.CoinName
-	}
-	return Default_GetPublicKey_CoinName
-}
-
-// *
-// Response: Contains public key derived from device private seed
-// @prev GetPublicKey
-type PublicKey struct {
-	Node             *HDNodeType `protobuf:"bytes,1,req,name=node" json:"node,omitempty"`
-	Xpub             *string     `protobuf:"bytes,2,opt,name=xpub" json:"xpub,omitempty"`
-	XXX_unrecognized []byte      `json:"-"`
-}
-
-func (m *PublicKey) Reset()                    { *m = PublicKey{} }
-func (m *PublicKey) String() string            { return proto.CompactTextString(m) }
-func (*PublicKey) ProtoMessage()               {}
-func (*PublicKey) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{20} }
-
-func (m *PublicKey) GetNode() *HDNodeType {
-	if m != nil {
-		return m.Node
-	}
-	return nil
-}
-
-func (m *PublicKey) GetXpub() string {
-	if m != nil && m.Xpub != nil {
-		return *m.Xpub
-	}
-	return ""
-}
-
-// *
-// Request: Ask device for address corresponding to address_n path
-// @next PassphraseRequest
-// @next Address
-// @next Failure
-type GetAddress struct {
-	AddressN         []uint32                  `protobuf:"varint,1,rep,name=address_n,json=addressN" json:"address_n,omitempty"`
-	CoinName         *string                   `protobuf:"bytes,2,opt,name=coin_name,json=coinName,def=Bitcoin" json:"coin_name,omitempty"`
-	ShowDisplay      *bool                     `protobuf:"varint,3,opt,name=show_display,json=showDisplay" json:"show_display,omitempty"`
-	Multisig         *MultisigRedeemScriptType `protobuf:"bytes,4,opt,name=multisig" json:"multisig,omitempty"`
-	ScriptType       *InputScriptType          `protobuf:"varint,5,opt,name=script_type,json=scriptType,enum=InputScriptType,def=0" json:"script_type,omitempty"`
-	XXX_unrecognized []byte                    `json:"-"`
-}
-
-func (m *GetAddress) Reset()                    { *m = GetAddress{} }
-func (m *GetAddress) String() string            { return proto.CompactTextString(m) }
-func (*GetAddress) ProtoMessage()               {}
-func (*GetAddress) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{21} }
-
-const Default_GetAddress_CoinName string = "Bitcoin"
-const Default_GetAddress_ScriptType InputScriptType = InputScriptType_SPENDADDRESS
-
-func (m *GetAddress) GetAddressN() []uint32 {
-	if m != nil {
-		return m.AddressN
-	}
-	return nil
-}
-
-func (m *GetAddress) GetCoinName() string {
-	if m != nil && m.CoinName != nil {
-		return *m.CoinName
-	}
-	return Default_GetAddress_CoinName
-}
-
-func (m *GetAddress) GetShowDisplay() bool {
-	if m != nil && m.ShowDisplay != nil {
-		return *m.ShowDisplay
-	}
-	return false
-}
-
-func (m *GetAddress) GetMultisig() *MultisigRedeemScriptType {
-	if m != nil {
-		return m.Multisig
-	}
-	return nil
-}
-
-func (m *GetAddress) GetScriptType() InputScriptType {
-	if m != nil && m.ScriptType != nil {
-		return *m.ScriptType
-	}
-	return Default_GetAddress_ScriptType
-}
-
-// *
-// Request: Ask device for Ethereum address corresponding to address_n path
-// @next PassphraseRequest
-// @next EthereumAddress
-// @next Failure
-type EthereumGetAddress struct {
-	AddressN         []uint32 `protobuf:"varint,1,rep,name=address_n,json=addressN" json:"address_n,omitempty"`
-	ShowDisplay      *bool    `protobuf:"varint,2,opt,name=show_display,json=showDisplay" json:"show_display,omitempty"`
-	XXX_unrecognized []byte   `json:"-"`
-}
-
-func (m *EthereumGetAddress) Reset()                    { *m = EthereumGetAddress{} }
-func (m *EthereumGetAddress) String() string            { return proto.CompactTextString(m) }
-func (*EthereumGetAddress) ProtoMessage()               {}
-func (*EthereumGetAddress) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{22} }
-
-func (m *EthereumGetAddress) GetAddressN() []uint32 {
-	if m != nil {
-		return m.AddressN
-	}
-	return nil
-}
-
-func (m *EthereumGetAddress) GetShowDisplay() bool {
-	if m != nil && m.ShowDisplay != nil {
-		return *m.ShowDisplay
-	}
-	return false
-}
-
-// *
-// Response: Contains address derived from device private seed
-// @prev GetAddress
-type Address struct {
-	Address          *string `protobuf:"bytes,1,req,name=address" json:"address,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *Address) Reset()                    { *m = Address{} }
-func (m *Address) String() string            { return proto.CompactTextString(m) }
-func (*Address) ProtoMessage()               {}
-func (*Address) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{23} }
-
-func (m *Address) GetAddress() string {
-	if m != nil && m.Address != nil {
-		return *m.Address
-	}
-	return ""
-}
-
-// *
-// Response: Contains an Ethereum address derived from device private seed
-// @prev EthereumGetAddress
-type EthereumAddress struct {
-	Address          []byte `protobuf:"bytes,1,req,name=address" json:"address,omitempty"`
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *EthereumAddress) Reset()                    { *m = EthereumAddress{} }
-func (m *EthereumAddress) String() string            { return proto.CompactTextString(m) }
-func (*EthereumAddress) ProtoMessage()               {}
-func (*EthereumAddress) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{24} }
-
-func (m *EthereumAddress) GetAddress() []byte {
-	if m != nil {
-		return m.Address
-	}
-	return nil
-}
-
-// *
-// Request: Request device to wipe all sensitive data and settings
-// @next ButtonRequest
-type WipeDevice struct {
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *WipeDevice) Reset()                    { *m = WipeDevice{} }
-func (m *WipeDevice) String() string            { return proto.CompactTextString(m) }
-func (*WipeDevice) ProtoMessage()               {}
-func (*WipeDevice) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{25} }
-
-// *
-// Request: Load seed and related internal settings from the computer
-// @next ButtonRequest
-// @next Success
-// @next Failure
-type LoadDevice struct {
-	Mnemonic             *string     `protobuf:"bytes,1,opt,name=mnemonic" json:"mnemonic,omitempty"`
-	Node                 *HDNodeType `protobuf:"bytes,2,opt,name=node" json:"node,omitempty"`
-	Pin                  *string     `protobuf:"bytes,3,opt,name=pin" json:"pin,omitempty"`
-	PassphraseProtection *bool       `protobuf:"varint,4,opt,name=passphrase_protection,json=passphraseProtection" json:"passphrase_protection,omitempty"`
-	Language             *string     `protobuf:"bytes,5,opt,name=language,def=english" json:"language,omitempty"`
-	Label                *string     `protobuf:"bytes,6,opt,name=label" json:"label,omitempty"`
-	SkipChecksum         *bool       `protobuf:"varint,7,opt,name=skip_checksum,json=skipChecksum" json:"skip_checksum,omitempty"`
-	U2FCounter           *uint32     `protobuf:"varint,8,opt,name=u2f_counter,json=u2fCounter" json:"u2f_counter,omitempty"`
-	XXX_unrecognized     []byte      `json:"-"`
-}
-
-func (m *LoadDevice) Reset()                    { *m = LoadDevice{} }
-func (m *LoadDevice) String() string            { return proto.CompactTextString(m) }
-func (*LoadDevice) ProtoMessage()               {}
-func (*LoadDevice) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{26} }
-
-const Default_LoadDevice_Language string = "english"
-
-func (m *LoadDevice) GetMnemonic() string {
-	if m != nil && m.Mnemonic != nil {
-		return *m.Mnemonic
-	}
-	return ""
-}
-
-func (m *LoadDevice) GetNode() *HDNodeType {
-	if m != nil {
-		return m.Node
-	}
-	return nil
-}
-
-func (m *LoadDevice) GetPin() string {
-	if m != nil && m.Pin != nil {
-		return *m.Pin
-	}
-	return ""
-}
-
-func (m *LoadDevice) GetPassphraseProtection() bool {
-	if m != nil && m.PassphraseProtection != nil {
-		return *m.PassphraseProtection
-	}
-	return false
-}
-
-func (m *LoadDevice) GetLanguage() string {
-	if m != nil && m.Language != nil {
-		return *m.Language
-	}
-	return Default_LoadDevice_Language
-}
-
-func (m *LoadDevice) GetLabel() string {
-	if m != nil && m.Label != nil {
-		return *m.Label
-	}
-	return ""
-}
-
-func (m *LoadDevice) GetSkipChecksum() bool {
-	if m != nil && m.SkipChecksum != nil {
-		return *m.SkipChecksum
-	}
-	return false
-}
-
-func (m *LoadDevice) GetU2FCounter() uint32 {
-	if m != nil && m.U2FCounter != nil {
-		return *m.U2FCounter
-	}
-	return 0
-}
-
-// *
-// Request: Ask device to do initialization involving user interaction
-// @next EntropyRequest
-// @next Failure
-type ResetDevice struct {
-	DisplayRandom        *bool   `protobuf:"varint,1,opt,name=display_random,json=displayRandom" json:"display_random,omitempty"`
-	Strength             *uint32 `protobuf:"varint,2,opt,name=strength,def=256" json:"strength,omitempty"`
-	PassphraseProtection *bool   `protobuf:"varint,3,opt,name=passphrase_protection,json=passphraseProtection" json:"passphrase_protection,omitempty"`
-	PinProtection        *bool   `protobuf:"varint,4,opt,name=pin_protection,json=pinProtection" json:"pin_protection,omitempty"`
-	Language             *string `protobuf:"bytes,5,opt,name=language,def=english" json:"language,omitempty"`
-	Label                *string `protobuf:"bytes,6,opt,name=label" json:"label,omitempty"`
-	U2FCounter           *uint32 `protobuf:"varint,7,opt,name=u2f_counter,json=u2fCounter" json:"u2f_counter,omitempty"`
-	SkipBackup           *bool   `protobuf:"varint,8,opt,name=skip_backup,json=skipBackup" json:"skip_backup,omitempty"`
-	XXX_unrecognized     []byte  `json:"-"`
-}
-
-func (m *ResetDevice) Reset()                    { *m = ResetDevice{} }
-func (m *ResetDevice) String() string            { return proto.CompactTextString(m) }
-func (*ResetDevice) ProtoMessage()               {}
-func (*ResetDevice) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{27} }
-
-const Default_ResetDevice_Strength uint32 = 256
-const Default_ResetDevice_Language string = "english"
-
-func (m *ResetDevice) GetDisplayRandom() bool {
-	if m != nil && m.DisplayRandom != nil {
-		return *m.DisplayRandom
-	}
-	return false
-}
-
-func (m *ResetDevice) GetStrength() uint32 {
-	if m != nil && m.Strength != nil {
-		return *m.Strength
-	}
-	return Default_ResetDevice_Strength
-}
-
-func (m *ResetDevice) GetPassphraseProtection() bool {
-	if m != nil && m.PassphraseProtection != nil {
-		return *m.PassphraseProtection
-	}
-	return false
-}
-
-func (m *ResetDevice) GetPinProtection() bool {
-	if m != nil && m.PinProtection != nil {
-		return *m.PinProtection
-	}
-	return false
-}
-
-func (m *ResetDevice) GetLanguage() string {
-	if m != nil && m.Language != nil {
-		return *m.Language
-	}
-	return Default_ResetDevice_Language
-}
-
-func (m *ResetDevice) GetLabel() string {
-	if m != nil && m.Label != nil {
-		return *m.Label
-	}
-	return ""
-}
-
-func (m *ResetDevice) GetU2FCounter() uint32 {
-	if m != nil && m.U2FCounter != nil {
-		return *m.U2FCounter
-	}
-	return 0
-}
-
-func (m *ResetDevice) GetSkipBackup() bool {
-	if m != nil && m.SkipBackup != nil {
-		return *m.SkipBackup
-	}
-	return false
-}
-
-// *
-// Request: Perform backup of the device seed if not backed up using ResetDevice
-// @next ButtonRequest
-type BackupDevice struct {
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *BackupDevice) Reset()                    { *m = BackupDevice{} }
-func (m *BackupDevice) String() string            { return proto.CompactTextString(m) }
-func (*BackupDevice) ProtoMessage()               {}
-func (*BackupDevice) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{28} }
-
-// *
-// Response: Ask for additional entropy from host computer
-// @prev ResetDevice
-// @next EntropyAck
-type EntropyRequest struct {
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *EntropyRequest) Reset()                    { *m = EntropyRequest{} }
-func (m *EntropyRequest) String() string            { return proto.CompactTextString(m) }
-func (*EntropyRequest) ProtoMessage()               {}
-func (*EntropyRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{29} }
-
-// *
-// Request: Provide additional entropy for seed generation function
-// @prev EntropyRequest
-// @next ButtonRequest
-type EntropyAck struct {
-	Entropy          []byte `protobuf:"bytes,1,opt,name=entropy" json:"entropy,omitempty"`
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *EntropyAck) Reset()                    { *m = EntropyAck{} }
-func (m *EntropyAck) String() string            { return proto.CompactTextString(m) }
-func (*EntropyAck) ProtoMessage()               {}
-func (*EntropyAck) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{30} }
-
-func (m *EntropyAck) GetEntropy() []byte {
-	if m != nil {
-		return m.Entropy
-	}
-	return nil
-}
-
-// *
-// Request: Start recovery workflow asking user for specific words of mnemonic
-// Used to recovery device safely even on untrusted computer.
-// @next WordRequest
-type RecoveryDevice struct {
-	WordCount            *uint32 `protobuf:"varint,1,opt,name=word_count,json=wordCount" json:"word_count,omitempty"`
-	PassphraseProtection *bool   `protobuf:"varint,2,opt,name=passphrase_protection,json=passphraseProtection" json:"passphrase_protection,omitempty"`
-	PinProtection        *bool   `protobuf:"varint,3,opt,name=pin_protection,json=pinProtection" json:"pin_protection,omitempty"`
-	Language             *string `protobuf:"bytes,4,opt,name=language,def=english" json:"language,omitempty"`
-	Label                *string `protobuf:"bytes,5,opt,name=label" json:"label,omitempty"`
-	EnforceWordlist      *bool   `protobuf:"varint,6,opt,name=enforce_wordlist,json=enforceWordlist" json:"enforce_wordlist,omitempty"`
-	// 7 reserved for unused recovery method
-	Type             *uint32 `protobuf:"varint,8,opt,name=type" json:"type,omitempty"`
-	U2FCounter       *uint32 `protobuf:"varint,9,opt,name=u2f_counter,json=u2fCounter" json:"u2f_counter,omitempty"`
-	DryRun           *bool   `protobuf:"varint,10,opt,name=dry_run,json=dryRun" json:"dry_run,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *RecoveryDevice) Reset()                    { *m = RecoveryDevice{} }
-func (m *RecoveryDevice) String() string            { return proto.CompactTextString(m) }
-func (*RecoveryDevice) ProtoMessage()               {}
-func (*RecoveryDevice) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{31} }
-
-const Default_RecoveryDevice_Language string = "english"
-
-func (m *RecoveryDevice) GetWordCount() uint32 {
-	if m != nil && m.WordCount != nil {
-		return *m.WordCount
-	}
-	return 0
-}
-
-func (m *RecoveryDevice) GetPassphraseProtection() bool {
-	if m != nil && m.PassphraseProtection != nil {
-		return *m.PassphraseProtection
-	}
-	return false
-}
-
-func (m *RecoveryDevice) GetPinProtection() bool {
-	if m != nil && m.PinProtection != nil {
-		return *m.PinProtection
-	}
-	return false
-}
-
-func (m *RecoveryDevice) GetLanguage() string {
-	if m != nil && m.Language != nil {
-		return *m.Language
-	}
-	return Default_RecoveryDevice_Language
-}
-
-func (m *RecoveryDevice) GetLabel() string {
-	if m != nil && m.Label != nil {
-		return *m.Label
-	}
-	return ""
-}
-
-func (m *RecoveryDevice) GetEnforceWordlist() bool {
-	if m != nil && m.EnforceWordlist != nil {
-		return *m.EnforceWordlist
-	}
-	return false
-}
-
-func (m *RecoveryDevice) GetType() uint32 {
-	if m != nil && m.Type != nil {
-		return *m.Type
-	}
-	return 0
-}
-
-func (m *RecoveryDevice) GetU2FCounter() uint32 {
-	if m != nil && m.U2FCounter != nil {
-		return *m.U2FCounter
-	}
-	return 0
-}
-
-func (m *RecoveryDevice) GetDryRun() bool {
-	if m != nil && m.DryRun != nil {
-		return *m.DryRun
-	}
-	return false
-}
-
-// *
-// Response: Device is waiting for user to enter word of the mnemonic
-// Its position is shown only on device's internal display.
-// @prev RecoveryDevice
-// @prev WordAck
-type WordRequest struct {
-	Type             *WordRequestType `protobuf:"varint,1,opt,name=type,enum=WordRequestType" json:"type,omitempty"`
-	XXX_unrecognized []byte           `json:"-"`
-}
-
-func (m *WordRequest) Reset()                    { *m = WordRequest{} }
-func (m *WordRequest) String() string            { return proto.CompactTextString(m) }
-func (*WordRequest) ProtoMessage()               {}
-func (*WordRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{32} }
-
-func (m *WordRequest) GetType() WordRequestType {
-	if m != nil && m.Type != nil {
-		return *m.Type
-	}
-	return WordRequestType_WordRequestType_Plain
-}
-
-// *
-// Request: Computer replies with word from the mnemonic
-// @prev WordRequest
-// @next WordRequest
-// @next Success
-// @next Failure
-type WordAck struct {
-	Word             *string `protobuf:"bytes,1,req,name=word" json:"word,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *WordAck) Reset()                    { *m = WordAck{} }
-func (m *WordAck) String() string            { return proto.CompactTextString(m) }
-func (*WordAck) ProtoMessage()               {}
-func (*WordAck) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{33} }
-
-func (m *WordAck) GetWord() string {
-	if m != nil && m.Word != nil {
-		return *m.Word
-	}
-	return ""
-}
-
-// *
-// Request: Ask device to sign message
-// @next MessageSignature
-// @next Failure
-type SignMessage struct {
-	AddressN         []uint32         `protobuf:"varint,1,rep,name=address_n,json=addressN" json:"address_n,omitempty"`
-	Message          []byte           `protobuf:"bytes,2,req,name=message" json:"message,omitempty"`
-	CoinName         *string          `protobuf:"bytes,3,opt,name=coin_name,json=coinName,def=Bitcoin" json:"coin_name,omitempty"`
-	ScriptType       *InputScriptType `protobuf:"varint,4,opt,name=script_type,json=scriptType,enum=InputScriptType,def=0" json:"script_type,omitempty"`
-	XXX_unrecognized []byte           `json:"-"`
-}
-
-func (m *SignMessage) Reset()                    { *m = SignMessage{} }
-func (m *SignMessage) String() string            { return proto.CompactTextString(m) }
-func (*SignMessage) ProtoMessage()               {}
-func (*SignMessage) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{34} }
-
-const Default_SignMessage_CoinName string = "Bitcoin"
-const Default_SignMessage_ScriptType InputScriptType = InputScriptType_SPENDADDRESS
-
-func (m *SignMessage) GetAddressN() []uint32 {
-	if m != nil {
-		return m.AddressN
-	}
-	return nil
-}
-
-func (m *SignMessage) GetMessage() []byte {
-	if m != nil {
-		return m.Message
-	}
-	return nil
-}
-
-func (m *SignMessage) GetCoinName() string {
-	if m != nil && m.CoinName != nil {
-		return *m.CoinName
-	}
-	return Default_SignMessage_CoinName
-}
-
-func (m *SignMessage) GetScriptType() InputScriptType {
-	if m != nil && m.ScriptType != nil {
-		return *m.ScriptType
-	}
-	return Default_SignMessage_ScriptType
-}
-
-// *
-// Request: Ask device to verify message
-// @next Success
-// @next Failure
-type VerifyMessage struct {
-	Address          *string `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"`
-	Signature        []byte  `protobuf:"bytes,2,opt,name=signature" json:"signature,omitempty"`
-	Message          []byte  `protobuf:"bytes,3,opt,name=message" json:"message,omitempty"`
-	CoinName         *string `protobuf:"bytes,4,opt,name=coin_name,json=coinName,def=Bitcoin" json:"coin_name,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *VerifyMessage) Reset()                    { *m = VerifyMessage{} }
-func (m *VerifyMessage) String() string            { return proto.CompactTextString(m) }
-func (*VerifyMessage) ProtoMessage()               {}
-func (*VerifyMessage) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{35} }
-
-const Default_VerifyMessage_CoinName string = "Bitcoin"
-
-func (m *VerifyMessage) GetAddress() string {
-	if m != nil && m.Address != nil {
-		return *m.Address
-	}
-	return ""
-}
-
-func (m *VerifyMessage) GetSignature() []byte {
-	if m != nil {
-		return m.Signature
-	}
-	return nil
-}
-
-func (m *VerifyMessage) GetMessage() []byte {
-	if m != nil {
-		return m.Message
-	}
-	return nil
-}
-
-func (m *VerifyMessage) GetCoinName() string {
-	if m != nil && m.CoinName != nil {
-		return *m.CoinName
-	}
-	return Default_VerifyMessage_CoinName
-}
-
-// *
-// Response: Signed message
-// @prev SignMessage
-type MessageSignature struct {
-	Address          *string `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"`
-	Signature        []byte  `protobuf:"bytes,2,opt,name=signature" json:"signature,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *MessageSignature) Reset()                    { *m = MessageSignature{} }
-func (m *MessageSignature) String() string            { return proto.CompactTextString(m) }
-func (*MessageSignature) ProtoMessage()               {}
-func (*MessageSignature) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{36} }
-
-func (m *MessageSignature) GetAddress() string {
-	if m != nil && m.Address != nil {
-		return *m.Address
-	}
-	return ""
-}
-
-func (m *MessageSignature) GetSignature() []byte {
-	if m != nil {
-		return m.Signature
-	}
-	return nil
-}
-
-// *
-// Request: Ask device to encrypt message
-// @next EncryptedMessage
-// @next Failure
-type EncryptMessage struct {
-	Pubkey           []byte   `protobuf:"bytes,1,opt,name=pubkey" json:"pubkey,omitempty"`
-	Message          []byte   `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
-	DisplayOnly      *bool    `protobuf:"varint,3,opt,name=display_only,json=displayOnly" json:"display_only,omitempty"`
-	AddressN         []uint32 `protobuf:"varint,4,rep,name=address_n,json=addressN" json:"address_n,omitempty"`
-	CoinName         *string  `protobuf:"bytes,5,opt,name=coin_name,json=coinName,def=Bitcoin" json:"coin_name,omitempty"`
-	XXX_unrecognized []byte   `json:"-"`
-}
-
-func (m *EncryptMessage) Reset()                    { *m = EncryptMessage{} }
-func (m *EncryptMessage) String() string            { return proto.CompactTextString(m) }
-func (*EncryptMessage) ProtoMessage()               {}
-func (*EncryptMessage) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{37} }
-
-const Default_EncryptMessage_CoinName string = "Bitcoin"
-
-func (m *EncryptMessage) GetPubkey() []byte {
-	if m != nil {
-		return m.Pubkey
-	}
-	return nil
-}
-
-func (m *EncryptMessage) GetMessage() []byte {
-	if m != nil {
-		return m.Message
-	}
-	return nil
-}
-
-func (m *EncryptMessage) GetDisplayOnly() bool {
-	if m != nil && m.DisplayOnly != nil {
-		return *m.DisplayOnly
-	}
-	return false
-}
-
-func (m *EncryptMessage) GetAddressN() []uint32 {
-	if m != nil {
-		return m.AddressN
-	}
-	return nil
-}
-
-func (m *EncryptMessage) GetCoinName() string {
-	if m != nil && m.CoinName != nil {
-		return *m.CoinName
-	}
-	return Default_EncryptMessage_CoinName
-}
-
-// *
-// Response: Encrypted message
-// @prev EncryptMessage
-type EncryptedMessage struct {
-	Nonce            []byte `protobuf:"bytes,1,opt,name=nonce" json:"nonce,omitempty"`
-	Message          []byte `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
-	Hmac             []byte `protobuf:"bytes,3,opt,name=hmac" json:"hmac,omitempty"`
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *EncryptedMessage) Reset()                    { *m = EncryptedMessage{} }
-func (m *EncryptedMessage) String() string            { return proto.CompactTextString(m) }
-func (*EncryptedMessage) ProtoMessage()               {}
-func (*EncryptedMessage) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{38} }
-
-func (m *EncryptedMessage) GetNonce() []byte {
-	if m != nil {
-		return m.Nonce
-	}
-	return nil
-}
-
-func (m *EncryptedMessage) GetMessage() []byte {
-	if m != nil {
-		return m.Message
-	}
-	return nil
-}
-
-func (m *EncryptedMessage) GetHmac() []byte {
-	if m != nil {
-		return m.Hmac
-	}
-	return nil
-}
-
-// *
-// Request: Ask device to decrypt message
-// @next Success
-// @next Failure
-type DecryptMessage struct {
-	AddressN         []uint32 `protobuf:"varint,1,rep,name=address_n,json=addressN" json:"address_n,omitempty"`
-	Nonce            []byte   `protobuf:"bytes,2,opt,name=nonce" json:"nonce,omitempty"`
-	Message          []byte   `protobuf:"bytes,3,opt,name=message" json:"message,omitempty"`
-	Hmac             []byte   `protobuf:"bytes,4,opt,name=hmac" json:"hmac,omitempty"`
-	XXX_unrecognized []byte   `json:"-"`
-}
-
-func (m *DecryptMessage) Reset()                    { *m = DecryptMessage{} }
-func (m *DecryptMessage) String() string            { return proto.CompactTextString(m) }
-func (*DecryptMessage) ProtoMessage()               {}
-func (*DecryptMessage) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{39} }
-
-func (m *DecryptMessage) GetAddressN() []uint32 {
-	if m != nil {
-		return m.AddressN
-	}
-	return nil
-}
-
-func (m *DecryptMessage) GetNonce() []byte {
-	if m != nil {
-		return m.Nonce
-	}
-	return nil
-}
-
-func (m *DecryptMessage) GetMessage() []byte {
-	if m != nil {
-		return m.Message
-	}
-	return nil
-}
-
-func (m *DecryptMessage) GetHmac() []byte {
-	if m != nil {
-		return m.Hmac
-	}
-	return nil
-}
-
-// *
-// Response: Decrypted message
-// @prev DecryptedMessage
-type DecryptedMessage struct {
-	Message          []byte  `protobuf:"bytes,1,opt,name=message" json:"message,omitempty"`
-	Address          *string `protobuf:"bytes,2,opt,name=address" json:"address,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *DecryptedMessage) Reset()                    { *m = DecryptedMessage{} }
-func (m *DecryptedMessage) String() string            { return proto.CompactTextString(m) }
-func (*DecryptedMessage) ProtoMessage()               {}
-func (*DecryptedMessage) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{40} }
-
-func (m *DecryptedMessage) GetMessage() []byte {
-	if m != nil {
-		return m.Message
-	}
-	return nil
-}
-
-func (m *DecryptedMessage) GetAddress() string {
-	if m != nil && m.Address != nil {
-		return *m.Address
-	}
-	return ""
-}
-
-// *
-// Request: Ask device to encrypt or decrypt value of given key
-// @next CipheredKeyValue
-// @next Failure
-type CipherKeyValue struct {
-	AddressN         []uint32 `protobuf:"varint,1,rep,name=address_n,json=addressN" json:"address_n,omitempty"`
-	Key              *string  `protobuf:"bytes,2,opt,name=key" json:"key,omitempty"`
-	Value            []byte   `protobuf:"bytes,3,opt,name=value" json:"value,omitempty"`
-	Encrypt          *bool    `protobuf:"varint,4,opt,name=encrypt" json:"encrypt,omitempty"`
-	AskOnEncrypt     *bool    `protobuf:"varint,5,opt,name=ask_on_encrypt,json=askOnEncrypt" json:"ask_on_encrypt,omitempty"`
-	AskOnDecrypt     *bool    `protobuf:"varint,6,opt,name=ask_on_decrypt,json=askOnDecrypt" json:"ask_on_decrypt,omitempty"`
-	Iv               []byte   `protobuf:"bytes,7,opt,name=iv" json:"iv,omitempty"`
-	XXX_unrecognized []byte   `json:"-"`
-}
-
-func (m *CipherKeyValue) Reset()                    { *m = CipherKeyValue{} }
-func (m *CipherKeyValue) String() string            { return proto.CompactTextString(m) }
-func (*CipherKeyValue) ProtoMessage()               {}
-func (*CipherKeyValue) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{41} }
-
-func (m *CipherKeyValue) GetAddressN() []uint32 {
-	if m != nil {
-		return m.AddressN
-	}
-	return nil
-}
-
-func (m *CipherKeyValue) GetKey() string {
-	if m != nil && m.Key != nil {
-		return *m.Key
-	}
-	return ""
-}
-
-func (m *CipherKeyValue) GetValue() []byte {
-	if m != nil {
-		return m.Value
-	}
-	return nil
-}
-
-func (m *CipherKeyValue) GetEncrypt() bool {
-	if m != nil && m.Encrypt != nil {
-		return *m.Encrypt
-	}
-	return false
-}
-
-func (m *CipherKeyValue) GetAskOnEncrypt() bool {
-	if m != nil && m.AskOnEncrypt != nil {
-		return *m.AskOnEncrypt
-	}
-	return false
-}
-
-func (m *CipherKeyValue) GetAskOnDecrypt() bool {
-	if m != nil && m.AskOnDecrypt != nil {
-		return *m.AskOnDecrypt
-	}
-	return false
-}
-
-func (m *CipherKeyValue) GetIv() []byte {
-	if m != nil {
-		return m.Iv
-	}
-	return nil
-}
-
-// *
-// Response: Return ciphered/deciphered value
-// @prev CipherKeyValue
-type CipheredKeyValue struct {
-	Value            []byte `protobuf:"bytes,1,opt,name=value" json:"value,omitempty"`
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *CipheredKeyValue) Reset()                    { *m = CipheredKeyValue{} }
-func (m *CipheredKeyValue) String() string            { return proto.CompactTextString(m) }
-func (*CipheredKeyValue) ProtoMessage()               {}
-func (*CipheredKeyValue) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{42} }
-
-func (m *CipheredKeyValue) GetValue() []byte {
-	if m != nil {
-		return m.Value
-	}
-	return nil
-}
-
-// *
-// Request: Estimated size of the transaction
-// This behaves exactly like SignTx, which means that it can ask using TxRequest
-// This call is non-blocking (except possible PassphraseRequest to unlock the seed)
-// @next TxSize
-// @next Failure
-type EstimateTxSize struct {
-	OutputsCount     *uint32 `protobuf:"varint,1,req,name=outputs_count,json=outputsCount" json:"outputs_count,omitempty"`
-	InputsCount      *uint32 `protobuf:"varint,2,req,name=inputs_count,json=inputsCount" json:"inputs_count,omitempty"`
-	CoinName         *string `protobuf:"bytes,3,opt,name=coin_name,json=coinName,def=Bitcoin" json:"coin_name,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *EstimateTxSize) Reset()                    { *m = EstimateTxSize{} }
-func (m *EstimateTxSize) String() string            { return proto.CompactTextString(m) }
-func (*EstimateTxSize) ProtoMessage()               {}
-func (*EstimateTxSize) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{43} }
-
-const Default_EstimateTxSize_CoinName string = "Bitcoin"
-
-func (m *EstimateTxSize) GetOutputsCount() uint32 {
-	if m != nil && m.OutputsCount != nil {
-		return *m.OutputsCount
-	}
-	return 0
-}
-
-func (m *EstimateTxSize) GetInputsCount() uint32 {
-	if m != nil && m.InputsCount != nil {
-		return *m.InputsCount
-	}
-	return 0
-}
-
-func (m *EstimateTxSize) GetCoinName() string {
-	if m != nil && m.CoinName != nil {
-		return *m.CoinName
-	}
-	return Default_EstimateTxSize_CoinName
-}
-
-// *
-// Response: Estimated size of the transaction
-// @prev EstimateTxSize
-type TxSize struct {
-	TxSize           *uint32 `protobuf:"varint,1,opt,name=tx_size,json=txSize" json:"tx_size,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *TxSize) Reset()                    { *m = TxSize{} }
-func (m *TxSize) String() string            { return proto.CompactTextString(m) }
-func (*TxSize) ProtoMessage()               {}
-func (*TxSize) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{44} }
-
-func (m *TxSize) GetTxSize() uint32 {
-	if m != nil && m.TxSize != nil {
-		return *m.TxSize
-	}
-	return 0
-}
-
-// *
-// Request: Ask device to sign transaction
-// @next PassphraseRequest
-// @next PinMatrixRequest
-// @next TxRequest
-// @next Failure
-type SignTx struct {
-	OutputsCount     *uint32 `protobuf:"varint,1,req,name=outputs_count,json=outputsCount" json:"outputs_count,omitempty"`
-	InputsCount      *uint32 `protobuf:"varint,2,req,name=inputs_count,json=inputsCount" json:"inputs_count,omitempty"`
-	CoinName         *string `protobuf:"bytes,3,opt,name=coin_name,json=coinName,def=Bitcoin" json:"coin_name,omitempty"`
-	Version          *uint32 `protobuf:"varint,4,opt,name=version,def=1" json:"version,omitempty"`
-	LockTime         *uint32 `protobuf:"varint,5,opt,name=lock_time,json=lockTime,def=0" json:"lock_time,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *SignTx) Reset()                    { *m = SignTx{} }
-func (m *SignTx) String() string            { return proto.CompactTextString(m) }
-func (*SignTx) ProtoMessage()               {}
-func (*SignTx) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{45} }
-
-const Default_SignTx_CoinName string = "Bitcoin"
-const Default_SignTx_Version uint32 = 1
-const Default_SignTx_LockTime uint32 = 0
-
-func (m *SignTx) GetOutputsCount() uint32 {
-	if m != nil && m.OutputsCount != nil {
-		return *m.OutputsCount
-	}
-	return 0
-}
-
-func (m *SignTx) GetInputsCount() uint32 {
-	if m != nil && m.InputsCount != nil {
-		return *m.InputsCount
-	}
-	return 0
-}
-
-func (m *SignTx) GetCoinName() string {
-	if m != nil && m.CoinName != nil {
-		return *m.CoinName
-	}
-	return Default_SignTx_CoinName
-}
-
-func (m *SignTx) GetVersion() uint32 {
-	if m != nil && m.Version != nil {
-		return *m.Version
-	}
-	return Default_SignTx_Version
-}
-
-func (m *SignTx) GetLockTime() uint32 {
-	if m != nil && m.LockTime != nil {
-		return *m.LockTime
-	}
-	return Default_SignTx_LockTime
-}
-
-// *
-// Request: Simplified transaction signing
-// This method doesn't support streaming, so there are hardware limits in number of inputs and outputs.
-// In case of success, the result is returned using TxRequest message.
-// @next PassphraseRequest
-// @next PinMatrixRequest
-// @next TxRequest
-// @next Failure
-type SimpleSignTx struct {
-	Inputs           []*TxInputType     `protobuf:"bytes,1,rep,name=inputs" json:"inputs,omitempty"`
-	Outputs          []*TxOutputType    `protobuf:"bytes,2,rep,name=outputs" json:"outputs,omitempty"`
-	Transactions     []*TransactionType `protobuf:"bytes,3,rep,name=transactions" json:"transactions,omitempty"`
-	CoinName         *string            `protobuf:"bytes,4,opt,name=coin_name,json=coinName,def=Bitcoin" json:"coin_name,omitempty"`
-	Version          *uint32            `protobuf:"varint,5,opt,name=version,def=1" json:"version,omitempty"`
-	LockTime         *uint32            `protobuf:"varint,6,opt,name=lock_time,json=lockTime,def=0" json:"lock_time,omitempty"`
-	XXX_unrecognized []byte             `json:"-"`
-}
-
-func (m *SimpleSignTx) Reset()                    { *m = SimpleSignTx{} }
-func (m *SimpleSignTx) String() string            { return proto.CompactTextString(m) }
-func (*SimpleSignTx) ProtoMessage()               {}
-func (*SimpleSignTx) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{46} }
-
-const Default_SimpleSignTx_CoinName string = "Bitcoin"
-const Default_SimpleSignTx_Version uint32 = 1
-const Default_SimpleSignTx_LockTime uint32 = 0
-
-func (m *SimpleSignTx) GetInputs() []*TxInputType {
-	if m != nil {
-		return m.Inputs
-	}
-	return nil
-}
-
-func (m *SimpleSignTx) GetOutputs() []*TxOutputType {
-	if m != nil {
-		return m.Outputs
-	}
-	return nil
-}
-
-func (m *SimpleSignTx) GetTransactions() []*TransactionType {
-	if m != nil {
-		return m.Transactions
-	}
-	return nil
-}
-
-func (m *SimpleSignTx) GetCoinName() string {
-	if m != nil && m.CoinName != nil {
-		return *m.CoinName
-	}
-	return Default_SimpleSignTx_CoinName
-}
-
-func (m *SimpleSignTx) GetVersion() uint32 {
-	if m != nil && m.Version != nil {
-		return *m.Version
-	}
-	return Default_SimpleSignTx_Version
-}
-
-func (m *SimpleSignTx) GetLockTime() uint32 {
-	if m != nil && m.LockTime != nil {
-		return *m.LockTime
-	}
-	return Default_SimpleSignTx_LockTime
-}
-
-// *
-// Response: Device asks for information for signing transaction or returns the last result
-// If request_index is set, device awaits TxAck message (with fields filled in according to request_type)
-// If signature_index is set, 'signature' contains signed input of signature_index's input
-// @prev SignTx
-// @prev SimpleSignTx
-// @prev TxAck
-type TxRequest struct {
-	RequestType      *RequestType             `protobuf:"varint,1,opt,name=request_type,json=requestType,enum=RequestType" json:"request_type,omitempty"`
-	Details          *TxRequestDetailsType    `protobuf:"bytes,2,opt,name=details" json:"details,omitempty"`
-	Serialized       *TxRequestSerializedType `protobuf:"bytes,3,opt,name=serialized" json:"serialized,omitempty"`
-	XXX_unrecognized []byte                   `json:"-"`
-}
-
-func (m *TxRequest) Reset()                    { *m = TxRequest{} }
-func (m *TxRequest) String() string            { return proto.CompactTextString(m) }
-func (*TxRequest) ProtoMessage()               {}
-func (*TxRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{47} }
-
-func (m *TxRequest) GetRequestType() RequestType {
-	if m != nil && m.RequestType != nil {
-		return *m.RequestType
-	}
-	return RequestType_TXINPUT
-}
-
-func (m *TxRequest) GetDetails() *TxRequestDetailsType {
-	if m != nil {
-		return m.Details
-	}
-	return nil
-}
-
-func (m *TxRequest) GetSerialized() *TxRequestSerializedType {
-	if m != nil {
-		return m.Serialized
-	}
-	return nil
-}
-
-// *
-// Request: Reported transaction data
-// @prev TxRequest
-// @next TxRequest
-type TxAck struct {
-	Tx               *TransactionType `protobuf:"bytes,1,opt,name=tx" json:"tx,omitempty"`
-	XXX_unrecognized []byte           `json:"-"`
-}
-
-func (m *TxAck) Reset()                    { *m = TxAck{} }
-func (m *TxAck) String() string            { return proto.CompactTextString(m) }
-func (*TxAck) ProtoMessage()               {}
-func (*TxAck) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{48} }
-
-func (m *TxAck) GetTx() *TransactionType {
-	if m != nil {
-		return m.Tx
-	}
-	return nil
-}
-
-// *
-// Request: Ask device to sign transaction
-// All fields are optional from the protocol's point of view. Each field defaults to value `0` if missing.
-// Note: the first at most 1024 bytes of data MUST be transmitted as part of this message.
-// @next PassphraseRequest
-// @next PinMatrixRequest
-// @next EthereumTxRequest
-// @next Failure
-type EthereumSignTx struct {
-	AddressN         []uint32 `protobuf:"varint,1,rep,name=address_n,json=addressN" json:"address_n,omitempty"`
-	Nonce            []byte   `protobuf:"bytes,2,opt,name=nonce" json:"nonce,omitempty"`
-	GasPrice         []byte   `protobuf:"bytes,3,opt,name=gas_price,json=gasPrice" json:"gas_price,omitempty"`
-	GasLimit         []byte   `protobuf:"bytes,4,opt,name=gas_limit,json=gasLimit" json:"gas_limit,omitempty"`
-	To               []byte   `protobuf:"bytes,5,opt,name=to" json:"to,omitempty"`
-	Value            []byte   `protobuf:"bytes,6,opt,name=value" json:"value,omitempty"`
-	DataInitialChunk []byte   `protobuf:"bytes,7,opt,name=data_initial_chunk,json=dataInitialChunk" json:"data_initial_chunk,omitempty"`
-	DataLength       *uint32  `protobuf:"varint,8,opt,name=data_length,json=dataLength" json:"data_length,omitempty"`
-	ChainId          *uint32  `protobuf:"varint,9,opt,name=chain_id,json=chainId" json:"chain_id,omitempty"`
-	XXX_unrecognized []byte   `json:"-"`
-}
-
-func (m *EthereumSignTx) Reset()                    { *m = EthereumSignTx{} }
-func (m *EthereumSignTx) String() string            { return proto.CompactTextString(m) }
-func (*EthereumSignTx) ProtoMessage()               {}
-func (*EthereumSignTx) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{49} }
-
-func (m *EthereumSignTx) GetAddressN() []uint32 {
-	if m != nil {
-		return m.AddressN
-	}
-	return nil
-}
-
-func (m *EthereumSignTx) GetNonce() []byte {
-	if m != nil {
-		return m.Nonce
-	}
-	return nil
-}
-
-func (m *EthereumSignTx) GetGasPrice() []byte {
-	if m != nil {
-		return m.GasPrice
-	}
-	return nil
-}
-
-func (m *EthereumSignTx) GetGasLimit() []byte {
-	if m != nil {
-		return m.GasLimit
-	}
-	return nil
-}
-
-func (m *EthereumSignTx) GetTo() []byte {
-	if m != nil {
-		return m.To
-	}
-	return nil
-}
-
-func (m *EthereumSignTx) GetValue() []byte {
-	if m != nil {
-		return m.Value
-	}
-	return nil
-}
-
-func (m *EthereumSignTx) GetDataInitialChunk() []byte {
-	if m != nil {
-		return m.DataInitialChunk
-	}
-	return nil
-}
-
-func (m *EthereumSignTx) GetDataLength() uint32 {
-	if m != nil && m.DataLength != nil {
-		return *m.DataLength
-	}
-	return 0
-}
-
-func (m *EthereumSignTx) GetChainId() uint32 {
-	if m != nil && m.ChainId != nil {
-		return *m.ChainId
-	}
-	return 0
-}
-
-// *
-// Response: Device asks for more data from transaction payload, or returns the signature.
-// If data_length is set, device awaits that many more bytes of payload.
-// Otherwise, the signature_* fields contain the computed transaction signature. All three fields will be present.
-// @prev EthereumSignTx
-// @next EthereumTxAck
-type EthereumTxRequest struct {
-	DataLength       *uint32 `protobuf:"varint,1,opt,name=data_length,json=dataLength" json:"data_length,omitempty"`
-	SignatureV       *uint32 `protobuf:"varint,2,opt,name=signature_v,json=signatureV" json:"signature_v,omitempty"`
-	SignatureR       []byte  `protobuf:"bytes,3,opt,name=signature_r,json=signatureR" json:"signature_r,omitempty"`
-	SignatureS       []byte  `protobuf:"bytes,4,opt,name=signature_s,json=signatureS" json:"signature_s,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *EthereumTxRequest) Reset()                    { *m = EthereumTxRequest{} }
-func (m *EthereumTxRequest) String() string            { return proto.CompactTextString(m) }
-func (*EthereumTxRequest) ProtoMessage()               {}
-func (*EthereumTxRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{50} }
-
-func (m *EthereumTxRequest) GetDataLength() uint32 {
-	if m != nil && m.DataLength != nil {
-		return *m.DataLength
-	}
-	return 0
-}
-
-func (m *EthereumTxRequest) GetSignatureV() uint32 {
-	if m != nil && m.SignatureV != nil {
-		return *m.SignatureV
-	}
-	return 0
-}
-
-func (m *EthereumTxRequest) GetSignatureR() []byte {
-	if m != nil {
-		return m.SignatureR
-	}
-	return nil
-}
-
-func (m *EthereumTxRequest) GetSignatureS() []byte {
-	if m != nil {
-		return m.SignatureS
-	}
-	return nil
-}
-
-// *
-// Request: Transaction payload data.
-// @prev EthereumTxRequest
-// @next EthereumTxRequest
-type EthereumTxAck struct {
-	DataChunk        []byte `protobuf:"bytes,1,opt,name=data_chunk,json=dataChunk" json:"data_chunk,omitempty"`
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *EthereumTxAck) Reset()                    { *m = EthereumTxAck{} }
-func (m *EthereumTxAck) String() string            { return proto.CompactTextString(m) }
-func (*EthereumTxAck) ProtoMessage()               {}
-func (*EthereumTxAck) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{51} }
-
-func (m *EthereumTxAck) GetDataChunk() []byte {
-	if m != nil {
-		return m.DataChunk
-	}
-	return nil
-}
-
-// *
-// Request: Ask device to sign message
-// @next EthereumMessageSignature
-// @next Failure
-type EthereumSignMessage struct {
-	AddressN         []uint32 `protobuf:"varint,1,rep,name=address_n,json=addressN" json:"address_n,omitempty"`
-	Message          []byte   `protobuf:"bytes,2,req,name=message" json:"message,omitempty"`
-	XXX_unrecognized []byte   `json:"-"`
-}
-
-func (m *EthereumSignMessage) Reset()                    { *m = EthereumSignMessage{} }
-func (m *EthereumSignMessage) String() string            { return proto.CompactTextString(m) }
-func (*EthereumSignMessage) ProtoMessage()               {}
-func (*EthereumSignMessage) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{52} }
-
-func (m *EthereumSignMessage) GetAddressN() []uint32 {
-	if m != nil {
-		return m.AddressN
-	}
-	return nil
-}
-
-func (m *EthereumSignMessage) GetMessage() []byte {
-	if m != nil {
-		return m.Message
-	}
-	return nil
-}
-
-// *
-// Request: Ask device to verify message
-// @next Success
-// @next Failure
-type EthereumVerifyMessage struct {
-	Address          []byte `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"`
-	Signature        []byte `protobuf:"bytes,2,opt,name=signature" json:"signature,omitempty"`
-	Message          []byte `protobuf:"bytes,3,opt,name=message" json:"message,omitempty"`
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *EthereumVerifyMessage) Reset()                    { *m = EthereumVerifyMessage{} }
-func (m *EthereumVerifyMessage) String() string            { return proto.CompactTextString(m) }
-func (*EthereumVerifyMessage) ProtoMessage()               {}
-func (*EthereumVerifyMessage) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{53} }
-
-func (m *EthereumVerifyMessage) GetAddress() []byte {
-	if m != nil {
-		return m.Address
-	}
-	return nil
-}
-
-func (m *EthereumVerifyMessage) GetSignature() []byte {
-	if m != nil {
-		return m.Signature
-	}
-	return nil
-}
-
-func (m *EthereumVerifyMessage) GetMessage() []byte {
-	if m != nil {
-		return m.Message
-	}
-	return nil
-}
-
-// *
-// Response: Signed message
-// @prev EthereumSignMessage
-type EthereumMessageSignature struct {
-	Address          []byte `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"`
-	Signature        []byte `protobuf:"bytes,2,opt,name=signature" json:"signature,omitempty"`
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *EthereumMessageSignature) Reset()                    { *m = EthereumMessageSignature{} }
-func (m *EthereumMessageSignature) String() string            { return proto.CompactTextString(m) }
-func (*EthereumMessageSignature) ProtoMessage()               {}
-func (*EthereumMessageSignature) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{54} }
-
-func (m *EthereumMessageSignature) GetAddress() []byte {
-	if m != nil {
-		return m.Address
-	}
-	return nil
-}
-
-func (m *EthereumMessageSignature) GetSignature() []byte {
-	if m != nil {
-		return m.Signature
-	}
-	return nil
-}
-
-// *
-// Request: Ask device to sign identity
-// @next SignedIdentity
-// @next Failure
-type SignIdentity struct {
-	Identity         *IdentityType `protobuf:"bytes,1,opt,name=identity" json:"identity,omitempty"`
-	ChallengeHidden  []byte        `protobuf:"bytes,2,opt,name=challenge_hidden,json=challengeHidden" json:"challenge_hidden,omitempty"`
-	ChallengeVisual  *string       `protobuf:"bytes,3,opt,name=challenge_visual,json=challengeVisual" json:"challenge_visual,omitempty"`
-	EcdsaCurveName   *string       `protobuf:"bytes,4,opt,name=ecdsa_curve_name,json=ecdsaCurveName" json:"ecdsa_curve_name,omitempty"`
-	XXX_unrecognized []byte        `json:"-"`
-}
-
-func (m *SignIdentity) Reset()                    { *m = SignIdentity{} }
-func (m *SignIdentity) String() string            { return proto.CompactTextString(m) }
-func (*SignIdentity) ProtoMessage()               {}
-func (*SignIdentity) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{55} }
-
-func (m *SignIdentity) GetIdentity() *IdentityType {
-	if m != nil {
-		return m.Identity
-	}
-	return nil
-}
-
-func (m *SignIdentity) GetChallengeHidden() []byte {
-	if m != nil {
-		return m.ChallengeHidden
-	}
-	return nil
-}
-
-func (m *SignIdentity) GetChallengeVisual() string {
-	if m != nil && m.ChallengeVisual != nil {
-		return *m.ChallengeVisual
-	}
-	return ""
-}
-
-func (m *SignIdentity) GetEcdsaCurveName() string {
-	if m != nil && m.EcdsaCurveName != nil {
-		return *m.EcdsaCurveName
-	}
-	return ""
-}
-
-// *
-// Response: Device provides signed identity
-// @prev SignIdentity
-type SignedIdentity struct {
-	Address          *string `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"`
-	PublicKey        []byte  `protobuf:"bytes,2,opt,name=public_key,json=publicKey" json:"public_key,omitempty"`
-	Signature        []byte  `protobuf:"bytes,3,opt,name=signature" json:"signature,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *SignedIdentity) Reset()                    { *m = SignedIdentity{} }
-func (m *SignedIdentity) String() string            { return proto.CompactTextString(m) }
-func (*SignedIdentity) ProtoMessage()               {}
-func (*SignedIdentity) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{56} }
-
-func (m *SignedIdentity) GetAddress() string {
-	if m != nil && m.Address != nil {
-		return *m.Address
-	}
-	return ""
-}
-
-func (m *SignedIdentity) GetPublicKey() []byte {
-	if m != nil {
-		return m.PublicKey
-	}
-	return nil
-}
-
-func (m *SignedIdentity) GetSignature() []byte {
-	if m != nil {
-		return m.Signature
-	}
-	return nil
-}
-
-// *
-// Request: Ask device to generate ECDH session key
-// @next ECDHSessionKey
-// @next Failure
-type GetECDHSessionKey struct {
-	Identity         *IdentityType `protobuf:"bytes,1,opt,name=identity" json:"identity,omitempty"`
-	PeerPublicKey    []byte        `protobuf:"bytes,2,opt,name=peer_public_key,json=peerPublicKey" json:"peer_public_key,omitempty"`
-	EcdsaCurveName   *string       `protobuf:"bytes,3,opt,name=ecdsa_curve_name,json=ecdsaCurveName" json:"ecdsa_curve_name,omitempty"`
-	XXX_unrecognized []byte        `json:"-"`
-}
-
-func (m *GetECDHSessionKey) Reset()                    { *m = GetECDHSessionKey{} }
-func (m *GetECDHSessionKey) String() string            { return proto.CompactTextString(m) }
-func (*GetECDHSessionKey) ProtoMessage()               {}
-func (*GetECDHSessionKey) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{57} }
-
-func (m *GetECDHSessionKey) GetIdentity() *IdentityType {
-	if m != nil {
-		return m.Identity
-	}
-	return nil
-}
-
-func (m *GetECDHSessionKey) GetPeerPublicKey() []byte {
-	if m != nil {
-		return m.PeerPublicKey
-	}
-	return nil
-}
-
-func (m *GetECDHSessionKey) GetEcdsaCurveName() string {
-	if m != nil && m.EcdsaCurveName != nil {
-		return *m.EcdsaCurveName
-	}
-	return ""
-}
-
-// *
-// Response: Device provides ECDH session key
-// @prev GetECDHSessionKey
-type ECDHSessionKey struct {
-	SessionKey       []byte `protobuf:"bytes,1,opt,name=session_key,json=sessionKey" json:"session_key,omitempty"`
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *ECDHSessionKey) Reset()                    { *m = ECDHSessionKey{} }
-func (m *ECDHSessionKey) String() string            { return proto.CompactTextString(m) }
-func (*ECDHSessionKey) ProtoMessage()               {}
-func (*ECDHSessionKey) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{58} }
-
-func (m *ECDHSessionKey) GetSessionKey() []byte {
-	if m != nil {
-		return m.SessionKey
-	}
-	return nil
-}
-
-// *
-// Request: Set U2F counter
-// @next Success
-type SetU2FCounter struct {
-	U2FCounter       *uint32 `protobuf:"varint,1,opt,name=u2f_counter,json=u2fCounter" json:"u2f_counter,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *SetU2FCounter) Reset()                    { *m = SetU2FCounter{} }
-func (m *SetU2FCounter) String() string            { return proto.CompactTextString(m) }
-func (*SetU2FCounter) ProtoMessage()               {}
-func (*SetU2FCounter) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{59} }
-
-func (m *SetU2FCounter) GetU2FCounter() uint32 {
-	if m != nil && m.U2FCounter != nil {
-		return *m.U2FCounter
-	}
-	return 0
-}
-
-// *
-// Request: Ask device to erase its firmware (so it can be replaced via FirmwareUpload)
-// @next Success
-// @next FirmwareRequest
-// @next Failure
-type FirmwareErase struct {
-	Length           *uint32 `protobuf:"varint,1,opt,name=length" json:"length,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *FirmwareErase) Reset()                    { *m = FirmwareErase{} }
-func (m *FirmwareErase) String() string            { return proto.CompactTextString(m) }
-func (*FirmwareErase) ProtoMessage()               {}
-func (*FirmwareErase) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{60} }
-
-func (m *FirmwareErase) GetLength() uint32 {
-	if m != nil && m.Length != nil {
-		return *m.Length
-	}
-	return 0
-}
-
-// *
-// Response: Ask for firmware chunk
-// @next FirmwareUpload
-type FirmwareRequest struct {
-	Offset           *uint32 `protobuf:"varint,1,opt,name=offset" json:"offset,omitempty"`
-	Length           *uint32 `protobuf:"varint,2,opt,name=length" json:"length,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *FirmwareRequest) Reset()                    { *m = FirmwareRequest{} }
-func (m *FirmwareRequest) String() string            { return proto.CompactTextString(m) }
-func (*FirmwareRequest) ProtoMessage()               {}
-func (*FirmwareRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{61} }
-
-func (m *FirmwareRequest) GetOffset() uint32 {
-	if m != nil && m.Offset != nil {
-		return *m.Offset
-	}
-	return 0
-}
-
-func (m *FirmwareRequest) GetLength() uint32 {
-	if m != nil && m.Length != nil {
-		return *m.Length
-	}
-	return 0
-}
-
-// *
-// Request: Send firmware in binary form to the device
-// @next Success
-// @next Failure
-type FirmwareUpload struct {
-	Payload          []byte `protobuf:"bytes,1,req,name=payload" json:"payload,omitempty"`
-	Hash             []byte `protobuf:"bytes,2,opt,name=hash" json:"hash,omitempty"`
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *FirmwareUpload) Reset()                    { *m = FirmwareUpload{} }
-func (m *FirmwareUpload) String() string            { return proto.CompactTextString(m) }
-func (*FirmwareUpload) ProtoMessage()               {}
-func (*FirmwareUpload) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{62} }
-
-func (m *FirmwareUpload) GetPayload() []byte {
-	if m != nil {
-		return m.Payload
-	}
-	return nil
-}
-
-func (m *FirmwareUpload) GetHash() []byte {
-	if m != nil {
-		return m.Hash
-	}
-	return nil
-}
-
-// *
-// Request: Perform a device self-test
-// @next Success
-// @next Failure
-type SelfTest struct {
-	Payload          []byte `protobuf:"bytes,1,opt,name=payload" json:"payload,omitempty"`
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *SelfTest) Reset()                    { *m = SelfTest{} }
-func (m *SelfTest) String() string            { return proto.CompactTextString(m) }
-func (*SelfTest) ProtoMessage()               {}
-func (*SelfTest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{63} }
-
-func (m *SelfTest) GetPayload() []byte {
-	if m != nil {
-		return m.Payload
-	}
-	return nil
-}
-
-// *
-// Request: "Press" the button on the device
-// @next Success
-type DebugLinkDecision struct {
-	YesNo            *bool  `protobuf:"varint,1,req,name=yes_no,json=yesNo" json:"yes_no,omitempty"`
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *DebugLinkDecision) Reset()                    { *m = DebugLinkDecision{} }
-func (m *DebugLinkDecision) String() string            { return proto.CompactTextString(m) }
-func (*DebugLinkDecision) ProtoMessage()               {}
-func (*DebugLinkDecision) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{64} }
-
-func (m *DebugLinkDecision) GetYesNo() bool {
-	if m != nil && m.YesNo != nil {
-		return *m.YesNo
-	}
-	return false
-}
-
-// *
-// Request: Computer asks for device state
-// @next DebugLinkState
-type DebugLinkGetState struct {
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *DebugLinkGetState) Reset()                    { *m = DebugLinkGetState{} }
-func (m *DebugLinkGetState) String() string            { return proto.CompactTextString(m) }
-func (*DebugLinkGetState) ProtoMessage()               {}
-func (*DebugLinkGetState) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{65} }
-
-// *
-// Response: Device current state
-// @prev DebugLinkGetState
-type DebugLinkState struct {
-	Layout               []byte      `protobuf:"bytes,1,opt,name=layout" json:"layout,omitempty"`
-	Pin                  *string     `protobuf:"bytes,2,opt,name=pin" json:"pin,omitempty"`
-	Matrix               *string     `protobuf:"bytes,3,opt,name=matrix" json:"matrix,omitempty"`
-	Mnemonic             *string     `protobuf:"bytes,4,opt,name=mnemonic" json:"mnemonic,omitempty"`
-	Node                 *HDNodeType `protobuf:"bytes,5,opt,name=node" json:"node,omitempty"`
-	PassphraseProtection *bool       `protobuf:"varint,6,opt,name=passphrase_protection,json=passphraseProtection" json:"passphrase_protection,omitempty"`
-	ResetWord            *string     `protobuf:"bytes,7,opt,name=reset_word,json=resetWord" json:"reset_word,omitempty"`
-	ResetEntropy         []byte      `protobuf:"bytes,8,opt,name=reset_entropy,json=resetEntropy" json:"reset_entropy,omitempty"`
-	RecoveryFakeWord     *string     `protobuf:"bytes,9,opt,name=recovery_fake_word,json=recoveryFakeWord" json:"recovery_fake_word,omitempty"`
-	RecoveryWordPos      *uint32     `protobuf:"varint,10,opt,name=recovery_word_pos,json=recoveryWordPos" json:"recovery_word_pos,omitempty"`
-	XXX_unrecognized     []byte      `json:"-"`
-}
-
-func (m *DebugLinkState) Reset()                    { *m = DebugLinkState{} }
-func (m *DebugLinkState) String() string            { return proto.CompactTextString(m) }
-func (*DebugLinkState) ProtoMessage()               {}
-func (*DebugLinkState) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{66} }
-
-func (m *DebugLinkState) GetLayout() []byte {
-	if m != nil {
-		return m.Layout
-	}
-	return nil
-}
-
-func (m *DebugLinkState) GetPin() string {
-	if m != nil && m.Pin != nil {
-		return *m.Pin
-	}
-	return ""
-}
-
-func (m *DebugLinkState) GetMatrix() string {
-	if m != nil && m.Matrix != nil {
-		return *m.Matrix
-	}
-	return ""
-}
-
-func (m *DebugLinkState) GetMnemonic() string {
-	if m != nil && m.Mnemonic != nil {
-		return *m.Mnemonic
-	}
-	return ""
-}
-
-func (m *DebugLinkState) GetNode() *HDNodeType {
-	if m != nil {
-		return m.Node
-	}
-	return nil
-}
-
-func (m *DebugLinkState) GetPassphraseProtection() bool {
-	if m != nil && m.PassphraseProtection != nil {
-		return *m.PassphraseProtection
-	}
-	return false
-}
-
-func (m *DebugLinkState) GetResetWord() string {
-	if m != nil && m.ResetWord != nil {
-		return *m.ResetWord
-	}
-	return ""
-}
-
-func (m *DebugLinkState) GetResetEntropy() []byte {
-	if m != nil {
-		return m.ResetEntropy
-	}
-	return nil
-}
-
-func (m *DebugLinkState) GetRecoveryFakeWord() string {
-	if m != nil && m.RecoveryFakeWord != nil {
-		return *m.RecoveryFakeWord
-	}
-	return ""
-}
-
-func (m *DebugLinkState) GetRecoveryWordPos() uint32 {
-	if m != nil && m.RecoveryWordPos != nil {
-		return *m.RecoveryWordPos
-	}
-	return 0
-}
-
-// *
-// Request: Ask device to restart
-type DebugLinkStop struct {
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *DebugLinkStop) Reset()                    { *m = DebugLinkStop{} }
-func (m *DebugLinkStop) String() string            { return proto.CompactTextString(m) }
-func (*DebugLinkStop) ProtoMessage()               {}
-func (*DebugLinkStop) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{67} }
-
-// *
-// Response: Device wants host to log event
-type DebugLinkLog struct {
-	Level            *uint32 `protobuf:"varint,1,opt,name=level" json:"level,omitempty"`
-	Bucket           *string `protobuf:"bytes,2,opt,name=bucket" json:"bucket,omitempty"`
-	Text             *string `protobuf:"bytes,3,opt,name=text" json:"text,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *DebugLinkLog) Reset()                    { *m = DebugLinkLog{} }
-func (m *DebugLinkLog) String() string            { return proto.CompactTextString(m) }
-func (*DebugLinkLog) ProtoMessage()               {}
-func (*DebugLinkLog) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{68} }
-
-func (m *DebugLinkLog) GetLevel() uint32 {
-	if m != nil && m.Level != nil {
-		return *m.Level
-	}
-	return 0
-}
-
-func (m *DebugLinkLog) GetBucket() string {
-	if m != nil && m.Bucket != nil {
-		return *m.Bucket
-	}
-	return ""
-}
-
-func (m *DebugLinkLog) GetText() string {
-	if m != nil && m.Text != nil {
-		return *m.Text
-	}
-	return ""
-}
-
-// *
-// Request: Read memory from device
-// @next DebugLinkMemory
-type DebugLinkMemoryRead struct {
-	Address          *uint32 `protobuf:"varint,1,opt,name=address" json:"address,omitempty"`
-	Length           *uint32 `protobuf:"varint,2,opt,name=length" json:"length,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *DebugLinkMemoryRead) Reset()                    { *m = DebugLinkMemoryRead{} }
-func (m *DebugLinkMemoryRead) String() string            { return proto.CompactTextString(m) }
-func (*DebugLinkMemoryRead) ProtoMessage()               {}
-func (*DebugLinkMemoryRead) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{69} }
-
-func (m *DebugLinkMemoryRead) GetAddress() uint32 {
-	if m != nil && m.Address != nil {
-		return *m.Address
-	}
-	return 0
-}
-
-func (m *DebugLinkMemoryRead) GetLength() uint32 {
-	if m != nil && m.Length != nil {
-		return *m.Length
-	}
-	return 0
-}
-
-// *
-// Response: Device sends memory back
-// @prev DebugLinkMemoryRead
-type DebugLinkMemory struct {
-	Memory           []byte `protobuf:"bytes,1,opt,name=memory" json:"memory,omitempty"`
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *DebugLinkMemory) Reset()                    { *m = DebugLinkMemory{} }
-func (m *DebugLinkMemory) String() string            { return proto.CompactTextString(m) }
-func (*DebugLinkMemory) ProtoMessage()               {}
-func (*DebugLinkMemory) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{70} }
-
-func (m *DebugLinkMemory) GetMemory() []byte {
-	if m != nil {
-		return m.Memory
-	}
-	return nil
-}
-
-// *
-// Request: Write memory to device.
-// WARNING: Writing to the wrong location can irreparably break the device.
-type DebugLinkMemoryWrite struct {
-	Address          *uint32 `protobuf:"varint,1,opt,name=address" json:"address,omitempty"`
-	Memory           []byte  `protobuf:"bytes,2,opt,name=memory" json:"memory,omitempty"`
-	Flash            *bool   `protobuf:"varint,3,opt,name=flash" json:"flash,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *DebugLinkMemoryWrite) Reset()                    { *m = DebugLinkMemoryWrite{} }
-func (m *DebugLinkMemoryWrite) String() string            { return proto.CompactTextString(m) }
-func (*DebugLinkMemoryWrite) ProtoMessage()               {}
-func (*DebugLinkMemoryWrite) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{71} }
-
-func (m *DebugLinkMemoryWrite) GetAddress() uint32 {
-	if m != nil && m.Address != nil {
-		return *m.Address
-	}
-	return 0
-}
-
-func (m *DebugLinkMemoryWrite) GetMemory() []byte {
-	if m != nil {
-		return m.Memory
-	}
-	return nil
-}
-
-func (m *DebugLinkMemoryWrite) GetFlash() bool {
-	if m != nil && m.Flash != nil {
-		return *m.Flash
-	}
-	return false
-}
-
-// *
-// Request: Erase block of flash on device
-// WARNING: Writing to the wrong location can irreparably break the device.
-type DebugLinkFlashErase struct {
-	Sector           *uint32 `protobuf:"varint,1,opt,name=sector" json:"sector,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *DebugLinkFlashErase) Reset()                    { *m = DebugLinkFlashErase{} }
-func (m *DebugLinkFlashErase) String() string            { return proto.CompactTextString(m) }
-func (*DebugLinkFlashErase) ProtoMessage()               {}
-func (*DebugLinkFlashErase) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{72} }
-
-func (m *DebugLinkFlashErase) GetSector() uint32 {
-	if m != nil && m.Sector != nil {
-		return *m.Sector
-	}
-	return 0
-}
-
-func init() {
-	proto.RegisterType((*Initialize)(nil), "Initialize")
-	proto.RegisterType((*GetFeatures)(nil), "GetFeatures")
-	proto.RegisterType((*Features)(nil), "Features")
-	proto.RegisterType((*ClearSession)(nil), "ClearSession")
-	proto.RegisterType((*ApplySettings)(nil), "ApplySettings")
-	proto.RegisterType((*ApplyFlags)(nil), "ApplyFlags")
-	proto.RegisterType((*ChangePin)(nil), "ChangePin")
-	proto.RegisterType((*Ping)(nil), "Ping")
-	proto.RegisterType((*Success)(nil), "Success")
-	proto.RegisterType((*Failure)(nil), "Failure")
-	proto.RegisterType((*ButtonRequest)(nil), "ButtonRequest")
-	proto.RegisterType((*ButtonAck)(nil), "ButtonAck")
-	proto.RegisterType((*PinMatrixRequest)(nil), "PinMatrixRequest")
-	proto.RegisterType((*PinMatrixAck)(nil), "PinMatrixAck")
-	proto.RegisterType((*Cancel)(nil), "Cancel")
-	proto.RegisterType((*PassphraseRequest)(nil), "PassphraseRequest")
-	proto.RegisterType((*PassphraseAck)(nil), "PassphraseAck")
-	proto.RegisterType((*GetEntropy)(nil), "GetEntropy")
-	proto.RegisterType((*Entropy)(nil), "Entropy")
-	proto.RegisterType((*GetPublicKey)(nil), "GetPublicKey")
-	proto.RegisterType((*PublicKey)(nil), "PublicKey")
-	proto.RegisterType((*GetAddress)(nil), "GetAddress")
-	proto.RegisterType((*EthereumGetAddress)(nil), "EthereumGetAddress")
-	proto.RegisterType((*Address)(nil), "Address")
-	proto.RegisterType((*EthereumAddress)(nil), "EthereumAddress")
-	proto.RegisterType((*WipeDevice)(nil), "WipeDevice")
-	proto.RegisterType((*LoadDevice)(nil), "LoadDevice")
-	proto.RegisterType((*ResetDevice)(nil), "ResetDevice")
-	proto.RegisterType((*BackupDevice)(nil), "BackupDevice")
-	proto.RegisterType((*EntropyRequest)(nil), "EntropyRequest")
-	proto.RegisterType((*EntropyAck)(nil), "EntropyAck")
-	proto.RegisterType((*RecoveryDevice)(nil), "RecoveryDevice")
-	proto.RegisterType((*WordRequest)(nil), "WordRequest")
-	proto.RegisterType((*WordAck)(nil), "WordAck")
-	proto.RegisterType((*SignMessage)(nil), "SignMessage")
-	proto.RegisterType((*VerifyMessage)(nil), "VerifyMessage")
-	proto.RegisterType((*MessageSignature)(nil), "MessageSignature")
-	proto.RegisterType((*EncryptMessage)(nil), "EncryptMessage")
-	proto.RegisterType((*EncryptedMessage)(nil), "EncryptedMessage")
-	proto.RegisterType((*DecryptMessage)(nil), "DecryptMessage")
-	proto.RegisterType((*DecryptedMessage)(nil), "DecryptedMessage")
-	proto.RegisterType((*CipherKeyValue)(nil), "CipherKeyValue")
-	proto.RegisterType((*CipheredKeyValue)(nil), "CipheredKeyValue")
-	proto.RegisterType((*EstimateTxSize)(nil), "EstimateTxSize")
-	proto.RegisterType((*TxSize)(nil), "TxSize")
-	proto.RegisterType((*SignTx)(nil), "SignTx")
-	proto.RegisterType((*SimpleSignTx)(nil), "SimpleSignTx")
-	proto.RegisterType((*TxRequest)(nil), "TxRequest")
-	proto.RegisterType((*TxAck)(nil), "TxAck")
-	proto.RegisterType((*EthereumSignTx)(nil), "EthereumSignTx")
-	proto.RegisterType((*EthereumTxRequest)(nil), "EthereumTxRequest")
-	proto.RegisterType((*EthereumTxAck)(nil), "EthereumTxAck")
-	proto.RegisterType((*EthereumSignMessage)(nil), "EthereumSignMessage")
-	proto.RegisterType((*EthereumVerifyMessage)(nil), "EthereumVerifyMessage")
-	proto.RegisterType((*EthereumMessageSignature)(nil), "EthereumMessageSignature")
-	proto.RegisterType((*SignIdentity)(nil), "SignIdentity")
-	proto.RegisterType((*SignedIdentity)(nil), "SignedIdentity")
-	proto.RegisterType((*GetECDHSessionKey)(nil), "GetECDHSessionKey")
-	proto.RegisterType((*ECDHSessionKey)(nil), "ECDHSessionKey")
-	proto.RegisterType((*SetU2FCounter)(nil), "SetU2FCounter")
-	proto.RegisterType((*FirmwareErase)(nil), "FirmwareErase")
-	proto.RegisterType((*FirmwareRequest)(nil), "FirmwareRequest")
-	proto.RegisterType((*FirmwareUpload)(nil), "FirmwareUpload")
-	proto.RegisterType((*SelfTest)(nil), "SelfTest")
-	proto.RegisterType((*DebugLinkDecision)(nil), "DebugLinkDecision")
-	proto.RegisterType((*DebugLinkGetState)(nil), "DebugLinkGetState")
-	proto.RegisterType((*DebugLinkState)(nil), "DebugLinkState")
-	proto.RegisterType((*DebugLinkStop)(nil), "DebugLinkStop")
-	proto.RegisterType((*DebugLinkLog)(nil), "DebugLinkLog")
-	proto.RegisterType((*DebugLinkMemoryRead)(nil), "DebugLinkMemoryRead")
-	proto.RegisterType((*DebugLinkMemory)(nil), "DebugLinkMemory")
-	proto.RegisterType((*DebugLinkMemoryWrite)(nil), "DebugLinkMemoryWrite")
-	proto.RegisterType((*DebugLinkFlashErase)(nil), "DebugLinkFlashErase")
-	proto.RegisterEnum("MessageType", MessageType_name, MessageType_value)
-}
-
-func init() { proto.RegisterFile("messages.proto", fileDescriptor1) }
-
-var fileDescriptor1 = []byte{
-	// 3424 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x5a, 0xcb, 0x6f, 0xdc, 0x46,
-	0x9a, 0x5f, 0x76, 0xb7, 0xfa, 0xf1, 0x35, 0xbb, 0x55, 0xa2, 0x2d, 0xbb, 0x2d, 0x5b, 0xb6, 0x4c,
-	0xc9, 0xb6, 0x64, 0x27, 0xed, 0x44, 0x79, 0x6c, 0xd6, 0xbb, 0x79, 0xc8, 0x7a, 0xd8, 0xde, 0xd8,
-	0x8e, 0xc0, 0x56, 0x9c, 0xdb, 0x12, 0x14, 0x59, 0xea, 0xae, 0x55, 0x37, 0xc9, 0xf0, 0xa1, 0xa8,
-	0x7d, 0xd8, 0xeb, 0xee, 0x65, 0x81, 0xec, 0x69, 0x73, 0x1a, 0xe4, 0x36, 0x19, 0x04, 0x18, 0x0c,
-	0x30, 0x18, 0x60, 0x72, 0x9a, 0x3f, 0x60, 0xfe, 0x8b, 0x39, 0xce, 0x1f, 0x30, 0xe7, 0x41, 0x3d,
-	0x48, 0x16, 0x29, 0xb6, 0x6c, 0x27, 0xc0, 0x5c, 0x04, 0xd6, 0x57, 0xbf, 0xfe, 0xea, 0x7b, 0xd5,
-	0x57, 0x5f, 0x7d, 0x25, 0xe8, 0x4e, 0x70, 0x18, 0x5a, 0x43, 0x1c, 0xf6, 0xfd, 0xc0, 0x8b, 0xbc,
-	0xa5, 0x76, 0x34, 0xf5, 0x93, 0x81, 0xae, 0x02, 0x3c, 0x71, 0x49, 0x44, 0xac, 0x31, 0x79, 0x89,
-	0xf5, 0x0e, 0xb4, 0x1f, 0xe1, 0x68, 0x0f, 0x5b, 0x51, 0x1c, 0xe0, 0x50, 0xff, 0x69, 0x0e, 0x9a,
-	0xc9, 0x40, 0xbb, 0x04, 0xf5, 0x13, 0xec, 0x3a, 0x5e, 0xd0, 0x53, 0x56, 0x94, 0xf5, 0x96, 0x21,
-	0x46, 0xda, 0x2a, 0x74, 0x26, 0xd6, 0x7f, 0x7a, 0x81, 0x79, 0x82, 0x83, 0x90, 0x78, 0x6e, 0xaf,
-	0xb2, 0xa2, 0xac, 0x77, 0x0c, 0x95, 0x11, 0x5f, 0x70, 0x1a, 0x03, 0x11, 0x57, 0x02, 0x55, 0x05,
-	0x88, 0x12, 0x25, 0x90, 0x6f, 0x45, 0xf6, 0x28, 0x05, 0xd5, 0x38, 0x88, 0x11, 0x13, 0xd0, 0x1d,
-	0x98, 0x3f, 0xf4, 0xbc, 0x68, 0xec, 0x59, 0x0e, 0x0e, 0xcc, 0x89, 0xe7, 0xe0, 0xde, 0xdc, 0x8a,
-	0xb2, 0xde, 0x34, 0xba, 0x19, 0xf9, 0x99, 0xe7, 0x60, 0xed, 0x2a, 0xb4, 0x1c, 0x7c, 0x42, 0x6c,
-	0x6c, 0x12, 0xa7, 0x57, 0x67, 0x22, 0x37, 0x39, 0xe1, 0x89, 0xa3, 0xdd, 0x82, 0xae, 0x4f, 0x5c,
-	0x93, 0xda, 0x00, 0xdb, 0x11, 0x5d, 0xab, 0xc1, 0x98, 0x74, 0x7c, 0xe2, 0xee, 0xa7, 0x44, 0xed,
-	0x3d, 0x58, 0xf4, 0xad, 0x30, 0xf4, 0x47, 0x81, 0x15, 0x62, 0x19, 0xdd, 0x64, 0xe8, 0x8b, 0xd9,
-	0xa4, 0xf4, 0xa3, 0x25, 0x68, 0x8e, 0x2d, 0x77, 0x18, 0x5b, 0x43, 0xdc, 0x6b, 0xf1, 0x75, 0x93,
-	0xb1, 0x76, 0x11, 0xe6, 0xc6, 0xd6, 0x21, 0x1e, 0xf7, 0x80, 0x4d, 0xf0, 0x81, 0x76, 0x03, 0xe6,
-	0x6c, 0x8f, 0xb8, 0x61, 0xaf, 0xbd, 0x52, 0x5d, 0x6f, 0x6f, 0xb6, 0xfa, 0xdb, 0x1e, 0x71, 0x0f,
-	0xa6, 0x3e, 0x36, 0x38, 0x5d, 0x5b, 0x81, 0x36, 0x49, 0xbd, 0xe4, 0xf4, 0x54, 0xb6, 0xba, 0x4c,
-	0xa2, 0x8b, 0x06, 0xf8, 0x84, 0x30, 0xb3, 0x75, 0x56, 0x94, 0x75, 0xd5, 0x48, 0xc7, 0x05, 0x93,
-	0x8d, 0xac, 0x70, 0xd4, 0xeb, 0x32, 0x88, 0x64, 0xb2, 0xc7, 0x56, 0x38, 0xa2, 0x4c, 0xc8, 0xc4,
-	0xf7, 0x82, 0x08, 0x3b, 0xbd, 0x79, 0xb6, 0x46, 0x3a, 0xd6, 0x96, 0x01, 0xa8, 0xc5, 0x6c, 0xcb,
-	0x1e, 0x61, 0xa7, 0x87, 0xd8, 0x6c, 0xcb, 0x27, 0xee, 0x36, 0x23, 0x68, 0xf7, 0x60, 0x41, 0xb2,
-	0x94, 0x40, 0x2d, 0x30, 0x14, 0xca, 0x26, 0x04, 0x78, 0x03, 0xd0, 0x11, 0x09, 0x26, 0xdf, 0x58,
-	0x01, 0x35, 0x2a, 0x0e, 0xb1, 0x1b, 0xf5, 0x34, 0x86, 0x9d, 0x4f, 0xe8, 0xfb, 0x9c, 0xac, 0xdd,
-	0x04, 0xd5, 0xc5, 0xd8, 0x09, 0xcd, 0x43, 0xcb, 0x3e, 0x8e, 0xfd, 0xde, 0x05, 0xae, 0x3a, 0xa3,
-	0x3d, 0x64, 0x24, 0x6a, 0xd3, 0xa3, 0xb1, 0x35, 0x0c, 0x7b, 0x17, 0x59, 0xb8, 0xf0, 0x81, 0xde,
-	0x05, 0x75, 0x7b, 0x8c, 0xad, 0x60, 0x80, 0x43, 0x6a, 0x04, 0xfd, 0x7f, 0x14, 0xe8, 0x6c, 0xf9,
-	0xfe, 0x78, 0x3a, 0xc0, 0x51, 0x44, 0xdc, 0x61, 0x98, 0xf3, 0x93, 0x32, 0xcb, 0x4f, 0x15, 0xd9,
-	0x4f, 0xb7, 0xa0, 0x1b, 0xd3, 0x38, 0x48, 0xf5, 0x61, 0x61, 0xdc, 0x34, 0x3a, 0x71, 0x88, 0xf7,
-	0x53, 0xa2, 0x76, 0x1d, 0x60, 0xe4, 0x4d, 0x70, 0x68, 0x07, 0x18, 0xf3, 0x20, 0x56, 0x0d, 0x89,
-	0xa2, 0xeb, 0x00, 0x4c, 0x92, 0x3d, 0x2a, 0x68, 0x26, 0xbe, 0x22, 0x8b, 0xbf, 0x0a, 0xad, 0xed,
-	0x91, 0xe5, 0x0e, 0xf1, 0x3e, 0x71, 0xe9, 0xd6, 0x0b, 0xf0, 0xc4, 0x3b, 0xe1, 0x72, 0x36, 0x0d,
-	0x31, 0xd2, 0x7f, 0xa3, 0x40, 0x6d, 0x9f, 0xb8, 0x43, 0xad, 0x07, 0x0d, 0xb1, 0xc9, 0x85, 0x26,
-	0xc9, 0x90, 0xfa, 0xe5, 0x30, 0x8e, 0x22, 0x2f, 0x17, 0xeb, 0x15, 0xee, 0x17, 0x3e, 0x21, 0x45,
-	0xee, 0xd9, 0x5d, 0x51, 0x7d, 0xa3, 0x5d, 0x51, 0x9b, 0xbd, 0x2b, 0xf4, 0x55, 0x68, 0x0c, 0x62,
-	0xdb, 0xc6, 0x61, 0x38, 0x5b, 0x5a, 0x7d, 0x17, 0x1a, 0x7b, 0x16, 0x19, 0xc7, 0x01, 0xd6, 0x56,
-	0xa0, 0x66, 0xd3, 0xcd, 0x4d, 0x11, 0xdd, 0x4d, 0xb5, 0x2f, 0xe8, 0x6c, 0x57, 0xb0, 0x19, 0x99,
-	0x4d, 0x25, 0xcf, 0xe6, 0x73, 0xe8, 0x3c, 0x64, 0xba, 0x19, 0xf8, 0xeb, 0x18, 0x87, 0x91, 0x76,
-	0x3b, 0xc7, 0x4c, 0xeb, 0xe7, 0x66, 0x25, 0x96, 0x1a, 0xd4, 0x1c, 0x2b, 0xb2, 0x04, 0x3f, 0xf6,
-	0xad, 0xb7, 0xa1, 0xc5, 0xe1, 0x5b, 0xf6, 0xb1, 0xfe, 0x31, 0xa0, 0x7d, 0xe2, 0x3e, 0xb3, 0xa2,
-	0x80, 0x9c, 0x26, 0xcc, 0x37, 0xa0, 0x46, 0x33, 0xaa, 0x60, 0xbe, 0xd8, 0x2f, 0x02, 0x38, 0x7f,
-	0x0a, 0xd1, 0x57, 0x40, 0x4d, 0x67, 0xb7, 0xec, 0x63, 0x0d, 0x41, 0xd5, 0x27, 0x6e, 0x4f, 0x59,
-	0xa9, 0xac, 0xb7, 0x0c, 0xfa, 0xa9, 0x37, 0xa1, 0xbe, 0x6d, 0xb9, 0x36, 0x1e, 0xeb, 0x17, 0x60,
-	0x21, 0x8b, 0x29, 0xc1, 0x4a, 0xbf, 0x0f, 0x9d, 0x8c, 0x48, 0x39, 0x5c, 0x07, 0x90, 0xc2, 0x91,
-	0x33, 0x92, 0x28, 0xfa, 0x0a, 0xc0, 0x23, 0x1c, 0xed, 0xba, 0x51, 0xe0, 0xf9, 0x53, 0xaa, 0x5f,
-	0x48, 0x5e, 0x72, 0x5c, 0xc7, 0x60, 0xdf, 0xd4, 0x31, 0xc9, 0x74, 0x0f, 0x1a, 0x98, 0x7f, 0x32,
-	0x84, 0x6a, 0x24, 0x43, 0xfd, 0x57, 0x0a, 0xa8, 0x8f, 0x70, 0xb4, 0x1f, 0x1f, 0x8e, 0x89, 0xfd,
-	0x39, 0x9e, 0xd2, 0xec, 0x6a, 0x39, 0x4e, 0x80, 0xc3, 0xd0, 0xa4, 0xf2, 0x57, 0xd7, 0x3b, 0x46,
-	0x53, 0x10, 0x9e, 0x6b, 0xeb, 0x80, 0xb0, 0xed, 0x84, 0x96, 0x69, 0xc7, 0xc1, 0x09, 0x36, 0x5d,
-	0x6b, 0x92, 0xb8, 0xa8, 0xcb, 0xe8, 0xdb, 0x94, 0xfc, 0xdc, 0x9a, 0x60, 0xba, 0xbd, 0xc3, 0x91,
-	0xf7, 0x8d, 0xe9, 0x90, 0xd0, 0x1f, 0x5b, 0x53, 0x11, 0x6f, 0x6d, 0x4a, 0xdb, 0xe1, 0x24, 0x6d,
-	0x0d, 0x5a, 0x34, 0x09, 0x72, 0x2e, 0x34, 0xc2, 0x5a, 0x0f, 0x1a, 0x0f, 0x49, 0x44, 0x69, 0x46,
-	0x93, 0xfe, 0xa5, 0x8c, 0xf4, 0xcf, 0xa0, 0x95, 0x09, 0x77, 0x03, 0x6a, 0x2e, 0x77, 0x77, 0x65,
-	0xbd, 0xbd, 0xd9, 0xee, 0x3f, 0xde, 0x79, 0xee, 0x39, 0x22, 0x74, 0x5c, 0xe1, 0xe7, 0x53, 0x3f,
-	0x3e, 0x4c, 0xfc, 0x4c, 0xbf, 0xf5, 0xbf, 0x2a, 0xcc, 0x54, 0x5b, 0x5c, 0x89, 0xf3, 0x15, 0xcc,
-	0xc9, 0x54, 0x99, 0x21, 0xd3, 0xeb, 0x28, 0xf7, 0x01, 0x34, 0x27, 0xf1, 0x38, 0x22, 0x21, 0x19,
-	0x32, 0xdd, 0xda, 0x9b, 0x57, 0xfa, 0xcf, 0x04, 0xc1, 0xc0, 0x0e, 0xc6, 0x93, 0x81, 0x1d, 0x10,
-	0x9f, 0xc7, 0x50, 0x0a, 0xd5, 0x3e, 0x85, 0x76, 0xc8, 0xe8, 0x26, 0x8b, 0xbc, 0x39, 0x16, 0x79,
-	0xa8, 0xff, 0xc4, 0xf5, 0xe3, 0x28, 0xfb, 0xc1, 0x03, 0x75, 0xb0, 0xbf, 0xfb, 0x7c, 0x67, 0x6b,
-	0x67, 0xc7, 0xd8, 0x1d, 0x0c, 0x0c, 0x08, 0xd3, 0x19, 0xfd, 0x00, 0xb4, 0xdd, 0x68, 0x84, 0x03,
-	0x1c, 0x4f, 0x5e, 0x57, 0xe7, 0xa2, 0x36, 0x95, 0x33, 0xda, 0xd0, 0x50, 0x4a, 0x58, 0xf5, 0xa0,
-	0x21, 0x7e, 0x29, 0x82, 0x32, 0x19, 0xea, 0xf7, 0x60, 0x3e, 0x59, 0x7a, 0x06, 0x58, 0xcd, 0xc0,
-	0x2a, 0xc0, 0x57, 0xc4, 0xc7, 0x3b, 0xec, 0xdc, 0xd6, 0xff, 0xaf, 0x02, 0xf0, 0xd4, 0xb3, 0x1c,
-	0x3e, 0xa4, 0x09, 0x7c, 0xe2, 0xe2, 0x89, 0xe7, 0x12, 0x3b, 0x49, 0xe0, 0xc9, 0x38, 0x0d, 0x81,
-	0x0a, 0x33, 0x6a, 0x49, 0x08, 0x88, 0xad, 0x57, 0x65, 0xbf, 0xa3, 0x9f, 0x3f, 0x2b, 0xad, 0x69,
-	0xab, 0xd2, 0x21, 0x32, 0xc7, 0x03, 0x01, 0xbb, 0xc3, 0x31, 0x09, 0x47, 0x65, 0xa7, 0x49, 0x5d,
-	0x3e, 0x4d, 0x56, 0xa1, 0x13, 0x1e, 0x13, 0xdf, 0xb4, 0x47, 0xd8, 0x3e, 0x0e, 0xe3, 0x89, 0x28,
-	0x41, 0x54, 0x4a, 0xdc, 0x16, 0x34, 0xed, 0x06, 0xb4, 0xe3, 0xcd, 0x23, 0xd3, 0xf6, 0x62, 0x37,
-	0xc2, 0x01, 0xab, 0x3b, 0x3a, 0x06, 0xc4, 0x9b, 0x47, 0xdb, 0x9c, 0xa2, 0xff, 0xb6, 0x02, 0x6d,
-	0x03, 0x87, 0x38, 0x12, 0x46, 0xb9, 0x05, 0x5d, 0xe1, 0x21, 0x33, 0xb0, 0x5c, 0xc7, 0x9b, 0x88,
-	0x33, 0xa3, 0x23, 0xa8, 0x06, 0x23, 0x6a, 0x37, 0xa0, 0x19, 0x46, 0x01, 0x76, 0x87, 0xd1, 0x88,
-	0x17, 0x6c, 0x0f, 0xaa, 0x9b, 0x1f, 0x7c, 0x68, 0xa4, 0xc4, 0xd9, 0xd6, 0xa8, 0x9e, 0x63, 0x8d,
-	0xb3, 0x07, 0x48, 0xad, 0xec, 0x00, 0xf9, 0x05, 0x46, 0x2b, 0xd8, 0xa3, 0x51, 0xb4, 0x07, 0x05,
-	0x30, 0xab, 0x8a, 0x7a, 0x81, 0x17, 0x6a, 0x40, 0x49, 0xbc, 0x5c, 0xa0, 0x85, 0x01, 0xff, 0x12,
-	0x41, 0x85, 0xa0, 0x2b, 0xf2, 0x5f, 0x92, 0x64, 0x6f, 0x03, 0x08, 0x0a, 0xcd, 0xb0, 0xb9, 0xa4,
-	0xa8, 0xc8, 0x49, 0xf1, 0x4f, 0x15, 0xe8, 0x1a, 0xd8, 0xf6, 0x4e, 0x70, 0x30, 0x15, 0xd6, 0x5f,
-	0x06, 0xf8, 0xc6, 0x0b, 0x1c, 0x2e, 0x9f, 0x38, 0xd1, 0x5b, 0x94, 0xc2, 0xc4, 0x9b, 0x6d, 0xd4,
-	0xca, 0x1b, 0x19, 0xb5, 0xfa, 0x2a, 0xa3, 0xd6, 0x5e, 0x69, 0xd4, 0x39, 0xd9, 0xa8, 0x1b, 0x80,
-	0xb0, 0x7b, 0xe4, 0x05, 0x36, 0x36, 0xa9, 0xac, 0x63, 0x12, 0x46, 0xcc, 0xea, 0x4d, 0x63, 0x5e,
-	0xd0, 0xbf, 0x12, 0x64, 0x9a, 0x39, 0x59, 0xca, 0xe1, 0x81, 0xc8, 0xbe, 0x8b, 0x3e, 0x69, 0x9d,
-	0xf1, 0xc9, 0x65, 0x68, 0x38, 0xc1, 0xd4, 0x0c, 0x62, 0x97, 0xd5, 0xbd, 0x4d, 0xa3, 0xee, 0x04,
-	0x53, 0x23, 0x76, 0xf5, 0xf7, 0xa0, 0x4d, 0x39, 0x27, 0x27, 0xe9, 0x5a, 0xee, 0x24, 0x45, 0x7d,
-	0x69, 0x4e, 0x3a, 0x44, 0x97, 0xa1, 0x41, 0x27, 0xa8, 0x6f, 0x34, 0xa8, 0x51, 0x81, 0x45, 0x8a,
-	0x61, 0xdf, 0xfa, 0x8f, 0x0a, 0xb4, 0x07, 0x64, 0xe8, 0x3e, 0x13, 0x15, 0xd0, 0xb9, 0x49, 0x2d,
-	0x57, 0x43, 0xb0, 0xcc, 0x93, 0x14, 0x4e, 0xb9, 0x14, 0x5f, 0x9d, 0x95, 0xe2, 0x0b, 0x89, 0xb8,
-	0xf6, 0xc6, 0x89, 0xf8, 0xbf, 0x15, 0xe8, 0xbc, 0xc0, 0x01, 0x39, 0x9a, 0x26, 0xf2, 0xe6, 0x92,
-	0xa1, 0x22, 0x65, 0x4e, 0xed, 0x1a, 0xb4, 0x42, 0x32, 0x74, 0xd9, 0x7d, 0x8c, 0x45, 0x8c, 0x6a,
-	0x64, 0x04, 0x59, 0x95, 0x2a, 0x8f, 0xd3, 0x52, 0x55, 0x66, 0x9e, 0xa0, 0xff, 0x0e, 0x48, 0x88,
-	0x30, 0x90, 0x79, 0xfe, 0x1c, 0x59, 0xf4, 0x1f, 0x14, 0xba, 0xa9, 0xec, 0x60, 0xea, 0x47, 0x89,
-	0x5a, 0x97, 0xa0, 0xee, 0xc7, 0x87, 0xc7, 0x38, 0xd9, 0x45, 0x62, 0x54, 0xac, 0xe2, 0x24, 0xb1,
-	0x6f, 0x82, 0x9a, 0x64, 0x32, 0xcf, 0x1d, 0xa7, 0xc7, 0xa7, 0xa0, 0x7d, 0xe1, 0x8e, 0x0b, 0x55,
-	0x48, 0xed, 0xbc, 0x43, 0x7a, 0x6e, 0x96, 0xda, 0x2f, 0x00, 0x09, 0x49, 0xb1, 0x93, 0xc8, 0x7a,
-	0x11, 0xe6, 0x5c, 0xcf, 0xb5, 0xb1, 0x10, 0x95, 0x0f, 0xce, 0x91, 0x54, 0x83, 0xda, 0x68, 0x62,
-	0xd9, 0xc2, 0xee, 0xec, 0x5b, 0xff, 0x1a, 0xba, 0x3b, 0x38, 0x67, 0x81, 0x73, 0x03, 0x31, 0x5d,
-	0xb2, 0x32, 0x63, 0xc9, 0x6a, 0xf9, 0x92, 0x35, 0x69, 0xc9, 0x3d, 0x40, 0x62, 0xc9, 0x4c, 0x95,
-	0x42, 0xad, 0x2d, 0x71, 0x90, 0x7c, 0x5b, 0xc9, 0xf9, 0x56, 0xff, 0xb3, 0x02, 0xdd, 0x6d, 0xe2,
-	0x8f, 0x70, 0xf0, 0x39, 0x9e, 0xbe, 0xb0, 0xc6, 0xf1, 0x2b, 0x64, 0x47, 0x50, 0xa5, 0x7e, 0xe5,
-	0x5c, 0xe8, 0x27, 0xd5, 0xe6, 0x84, 0xfe, 0x4e, 0x48, 0xcd, 0x07, 0x3c, 0x93, 0x32, 0xf9, 0xc4,
-	0xb1, 0x90, 0x0c, 0xb5, 0x35, 0xe8, 0x5a, 0xe1, 0xb1, 0xe9, 0xb9, 0x66, 0x02, 0xe0, 0x77, 0x7a,
-	0xd5, 0x0a, 0x8f, 0xbf, 0x70, 0x77, 0xcf, 0xa0, 0x1c, 0xae, 0xa6, 0x48, 0x52, 0x1c, 0x25, 0x54,
-	0xd7, 0xba, 0x50, 0x21, 0x27, 0xec, 0x60, 0x50, 0x8d, 0x0a, 0x39, 0xd1, 0xd7, 0x01, 0x71, 0x65,
-	0xb0, 0x93, 0xaa, 0x93, 0xca, 0xa7, 0x48, 0xf2, 0xe9, 0xff, 0x05, 0xdd, 0xdd, 0x30, 0x22, 0x13,
-	0x2b, 0xc2, 0x07, 0xa7, 0x03, 0xf2, 0x12, 0xd3, 0x23, 0xda, 0x8b, 0x23, 0x3f, 0x8e, 0xc2, 0x34,
-	0xa3, 0xd3, 0xc2, 0x59, 0x15, 0x44, 0x9e, 0xd4, 0x6f, 0x82, 0x4a, 0x5c, 0x09, 0x53, 0x61, 0x98,
-	0x36, 0xa7, 0x71, 0xc8, 0x6b, 0x25, 0x13, 0xfd, 0x26, 0xd4, 0xc5, 0xba, 0x97, 0xa1, 0x11, 0x9d,
-	0x9a, 0xa2, 0x54, 0xa7, 0xd9, 0xb4, 0x1e, 0xb1, 0x09, 0xfd, 0xf7, 0x0a, 0xd4, 0xe9, 0xf6, 0x3c,
-	0x38, 0xfd, 0xc7, 0xca, 0xa6, 0x5d, 0x85, 0x46, 0xae, 0x2b, 0xf3, 0x40, 0x79, 0xd7, 0x48, 0x28,
-	0xda, 0x75, 0x68, 0x8d, 0x3d, 0xfb, 0xd8, 0x8c, 0x88, 0xd8, 0x69, 0x9d, 0x07, 0xca, 0x3b, 0x46,
-	0x93, 0xd2, 0x0e, 0xc8, 0x04, 0xeb, 0x7f, 0x53, 0x40, 0x1d, 0x90, 0x89, 0x3f, 0xc6, 0x42, 0xf6,
-	0x35, 0xa8, 0x73, 0x11, 0x58, 0x2c, 0xb5, 0x37, 0xd5, 0xfe, 0xc1, 0x29, 0xcb, 0x99, 0x2c, 0xcd,
-	0x8b, 0x39, 0xed, 0x0e, 0x34, 0x84, 0x32, 0xbd, 0x0a, 0x83, 0x75, 0xfa, 0x07, 0xa7, 0x5f, 0x30,
-	0x0a, 0xc3, 0x25, 0xb3, 0xda, 0xfb, 0xa0, 0x46, 0x81, 0xe5, 0x86, 0x16, 0x3b, 0x09, 0xc3, 0x5e,
-	0x95, 0xa1, 0x51, 0xff, 0x20, 0x23, 0xb2, 0x1f, 0xe4, 0x50, 0xaf, 0x97, 0x16, 0x65, 0xc5, 0xe7,
-	0xce, 0x57, 0xbc, 0x7e, 0x56, 0xf1, 0x5f, 0x2b, 0xd0, 0x3a, 0x48, 0x2f, 0x8a, 0xf7, 0x41, 0x0d,
-	0xf8, 0xa7, 0x29, 0x1d, 0x73, 0x6a, 0x5f, 0x3e, 0xe2, 0xda, 0x41, 0x36, 0xd0, 0xee, 0x43, 0xc3,
-	0xc1, 0x91, 0x45, 0xc6, 0xa1, 0xa8, 0x63, 0x17, 0xfb, 0x29, 0xb7, 0x1d, 0x3e, 0xc1, 0x0d, 0x21,
-	0x50, 0xda, 0x47, 0x00, 0x21, 0x0e, 0x92, 0x36, 0x51, 0x95, 0xfd, 0xa6, 0x97, 0xfd, 0x66, 0x90,
-	0xce, 0xb1, 0x9f, 0x49, 0x58, 0x7d, 0x03, 0xe6, 0x0e, 0xd8, 0x95, 0x74, 0x05, 0x2a, 0xd1, 0x29,
-	0x13, 0xad, 0xcc, 0x82, 0x95, 0xe8, 0x54, 0xff, 0xdf, 0x0a, 0x74, 0x93, 0x0a, 0x5e, 0xf8, 0xf3,
-	0x67, 0xa4, 0xb6, 0xab, 0xd0, 0x1a, 0x5a, 0xa1, 0xe9, 0x07, 0xc4, 0x4e, 0xd2, 0x44, 0x73, 0x68,
-	0x85, 0xfb, 0x74, 0x9c, 0x4c, 0x8e, 0xc9, 0x84, 0x44, 0x22, 0xc5, 0xd1, 0xc9, 0xa7, 0x74, 0x4c,
-	0x37, 0x78, 0xe4, 0x31, 0x67, 0xa8, 0x46, 0x25, 0xf2, 0xb2, 0xcd, 0x5c, 0x97, 0x93, 0xcd, 0x5b,
-	0xa0, 0xd1, 0xeb, 0xbb, 0x29, 0x9a, 0x64, 0xa6, 0x3d, 0x8a, 0xdd, 0x63, 0x91, 0x16, 0x10, 0x9d,
-	0x11, 0x6d, 0xcf, 0x6d, 0x4a, 0xa7, 0x25, 0x0c, 0x43, 0x8f, 0x79, 0x45, 0x2c, 0xca, 0x6c, 0x4a,
-	0x7a, 0xca, 0xcb, 0xe1, 0x2b, 0xd0, 0xb4, 0x47, 0x16, 0x71, 0x4d, 0xe2, 0x88, 0x02, 0xa7, 0xc1,
-	0xc6, 0x4f, 0x1c, 0xfd, 0xff, 0x15, 0x58, 0x48, 0xec, 0x91, 0x39, 0xbb, 0xc0, 0x51, 0x39, 0xc3,
-	0x91, 0x16, 0xaa, 0xc9, 0x81, 0x69, 0x9e, 0x88, 0xae, 0x29, 0xa4, 0xa4, 0x17, 0x79, 0x40, 0x20,
-	0x6c, 0x94, 0x01, 0x8c, 0x3c, 0x20, 0x4c, 0x1a, 0x4d, 0x29, 0x69, 0xa0, 0xf7, 0xa1, 0x93, 0x09,
-	0x46, 0x9d, 0xbb, 0x0c, 0x4c, 0x02, 0x61, 0x0c, 0x9e, 0xfc, 0x5a, 0x94, 0xc2, 0xac, 0xa0, 0x3f,
-	0x85, 0x0b, 0xb2, 0x63, 0x7f, 0x59, 0x05, 0xa5, 0x13, 0x58, 0x4c, 0xb8, 0x9d, 0x5b, 0xe1, 0xa8,
-	0xbf, 0xb8, 0xc2, 0xd1, 0x0d, 0xe8, 0x25, 0x4b, 0xbd, 0xaa, 0x86, 0x79, 0xdd, 0xd5, 0xf4, 0x9f,
-	0x58, 0xd2, 0x1a, 0xba, 0x4f, 0x1c, 0xec, 0x46, 0x24, 0x9a, 0x6a, 0x1b, 0xd0, 0x24, 0xe2, 0x5b,
-	0xec, 0x8f, 0x4e, 0x3f, 0x99, 0xe4, 0xf7, 0x73, 0x92, 0x41, 0x91, 0x3d, 0xb2, 0xc6, 0xd4, 0xf7,
-	0xd8, 0x1c, 0x11, 0xc7, 0xc1, 0xae, 0x58, 0x60, 0x3e, 0xa5, 0x3f, 0x66, 0xe4, 0x3c, 0xf4, 0x84,
-	0x84, 0xb1, 0x35, 0x16, 0x97, 0xd2, 0x0c, 0xfa, 0x82, 0x91, 0x4b, 0xdb, 0x2a, 0xb5, 0xb2, 0xb6,
-	0x8a, 0x3e, 0x84, 0x2e, 0x15, 0x1d, 0x3b, 0xa9, 0xf0, 0xb3, 0x2b, 0xb9, 0x65, 0x00, 0x9f, 0x75,
-	0x4e, 0xcc, 0xe4, 0x10, 0x57, 0x8d, 0x96, 0x9f, 0xf6, 0x52, 0x72, 0x46, 0xaa, 0x16, 0x8d, 0xf4,
-	0xad, 0x02, 0x0b, 0x8f, 0x70, 0xb4, 0xbb, 0xbd, 0xf3, 0x58, 0x34, 0x5a, 0xe9, 0x6f, 0xde, 0xc0,
-	0x52, 0xb7, 0x61, 0xde, 0xc7, 0x38, 0x30, 0xcf, 0x88, 0xd0, 0xa1, 0xe4, 0xac, 0xa5, 0x53, 0xa6,
-	0x7b, 0xb5, 0x54, 0xf7, 0x77, 0xa1, 0x5b, 0x10, 0x87, 0xee, 0x13, 0x3e, 0x32, 0xb3, 0xfa, 0x13,
-	0xc2, 0x14, 0xa0, 0xbf, 0x03, 0x9d, 0x01, 0x8e, 0xbe, 0xdc, 0xdc, 0x93, 0x2e, 0x91, 0xf2, 0x8d,
-	0x46, 0x39, 0x73, 0xeb, 0xbe, 0x03, 0x9d, 0x3d, 0xd1, 0xa9, 0xde, 0x65, 0x3d, 0xdf, 0x4b, 0x50,
-	0xcf, 0xed, 0x74, 0x31, 0xd2, 0xb7, 0x60, 0x3e, 0x01, 0x26, 0x99, 0xe1, 0x12, 0xd4, 0xbd, 0xa3,
-	0xa3, 0x10, 0x27, 0xf7, 0x43, 0x31, 0x92, 0x58, 0x54, 0x72, 0x2c, 0x3e, 0x81, 0x6e, 0xc2, 0xe2,
-	0x4b, 0x7f, 0xec, 0x59, 0x0e, 0x75, 0xa6, 0x6f, 0x4d, 0xe9, 0x67, 0xd2, 0x2f, 0x11, 0x43, 0x56,
-	0x16, 0x5a, 0xe1, 0x48, 0xd8, 0x90, 0x7d, 0xeb, 0x6b, 0xd0, 0x1c, 0xe0, 0xf1, 0xd1, 0x01, 0x5d,
-	0x3b, 0xf7, 0x4b, 0x45, 0xfa, 0xa5, 0x7e, 0x17, 0x16, 0x76, 0xf0, 0x61, 0x3c, 0x7c, 0x4a, 0xdc,
-	0xe3, 0x1d, 0x6c, 0xf3, 0x97, 0x83, 0x45, 0xa8, 0x4f, 0x71, 0x68, 0xba, 0x1e, 0x5b, 0xa7, 0x69,
-	0xcc, 0x4d, 0x71, 0xf8, 0xdc, 0xd3, 0x2f, 0x48, 0xd8, 0x47, 0x38, 0x1a, 0x44, 0x56, 0x84, 0xf5,
-	0xbf, 0x54, 0x68, 0xc5, 0x2b, 0xa8, 0x8c, 0xc4, 0x34, 0xb2, 0xa6, 0x5e, 0x1c, 0x25, 0x35, 0x3f,
-	0x1f, 0x25, 0xbd, 0x97, 0x4a, 0xd6, 0x7b, 0xb9, 0x04, 0xf5, 0x09, 0xeb, 0x8a, 0x0a, 0xa7, 0x8a,
-	0x51, 0xae, 0xc5, 0x53, 0x9b, 0xd1, 0xe2, 0x99, 0x9b, 0xd5, 0xe2, 0x99, 0x79, 0xdb, 0xae, 0x9f,
-	0x73, 0xdb, 0x5e, 0x06, 0x08, 0x70, 0x88, 0x23, 0x76, 0x13, 0x66, 0xe7, 0x45, 0xcb, 0x68, 0x31,
-	0x0a, 0xbd, 0x74, 0xd2, 0xaa, 0x8b, 0x4f, 0x27, 0x3d, 0x81, 0x26, 0xd3, 0x4c, 0x65, 0xc4, 0xa4,
-	0x8f, 0xfa, 0x16, 0x68, 0x81, 0xe8, 0x0b, 0x98, 0x47, 0xd6, 0x31, 0xbf, 0x55, 0x8b, 0xb7, 0x20,
-	0x94, 0xcc, 0xec, 0x59, 0xc7, 0xec, 0x5a, 0xad, 0xdd, 0x85, 0x85, 0x14, 0xcd, 0x9a, 0x07, 0xbe,
-	0x17, 0xb2, 0x7b, 0x72, 0xc7, 0x98, 0x4f, 0x26, 0x28, 0x70, 0xdf, 0x0b, 0xf5, 0x79, 0xe8, 0x48,
-	0x36, 0xf6, 0x7c, 0x7d, 0x1f, 0xd4, 0x94, 0xf0, 0xd4, 0x1b, 0xb2, 0x0b, 0x3e, 0x3e, 0xc1, 0xe3,
-	0xe4, 0x35, 0x81, 0x0d, 0xa8, 0x79, 0x0f, 0x63, 0xfb, 0x18, 0x47, 0xc2, 0xe6, 0x62, 0xc4, 0x6e,
-	0xf3, 0xf8, 0x34, 0x12, 0x46, 0x67, 0xdf, 0xfa, 0x23, 0xb8, 0x90, 0x72, 0x7c, 0x86, 0x27, 0x5e,
-	0x30, 0x35, 0x30, 0x8f, 0x39, 0x39, 0x81, 0x74, 0xb2, 0x04, 0x32, 0x2b, 0x6e, 0x37, 0x60, 0xbe,
-	0xc0, 0x88, 0xb9, 0x99, 0x7d, 0x25, 0x01, 0xc1, 0x47, 0xfa, 0x7f, 0xc0, 0xc5, 0x02, 0xf4, 0xab,
-	0x80, 0x44, 0xf8, 0xfc, 0x45, 0x05, 0xa7, 0x8a, 0xcc, 0x49, 0xbc, 0xa6, 0x84, 0x23, 0x71, 0x5b,
-	0xe4, 0x03, 0xfd, 0x6d, 0x49, 0xa7, 0x3d, 0x4a, 0x49, 0x37, 0x6d, 0x88, 0xed, 0xc8, 0x4b, 0x76,
-	0xb8, 0x18, 0xdd, 0xfd, 0x71, 0x11, 0xda, 0xe2, 0x1c, 0x61, 0x75, 0xd8, 0x0a, 0x5c, 0x92, 0x86,
-	0x66, 0xf6, 0x60, 0x8a, 0xfe, 0x69, 0xa9, 0xf6, 0xed, 0x1f, 0x7a, 0x8a, 0xb6, 0x94, 0x5e, 0x9e,
-	0x19, 0x62, 0x9f, 0xb8, 0x43, 0xa4, 0x88, 0xb9, 0x65, 0xb8, 0x20, 0xcf, 0x89, 0x57, 0x10, 0x54,
-	0x59, 0xaa, 0x7d, 0x57, 0x32, 0x2d, 0xde, 0x39, 0x50, 0x55, 0x4c, 0xdf, 0x80, 0x45, 0x79, 0x3a,
-	0x7d, 0x14, 0x42, 0x35, 0xc1, 0xbe, 0x20, 0x5c, 0xd6, 0x2e, 0x45, 0x73, 0x02, 0x71, 0x07, 0xae,
-	0xe4, 0x56, 0x90, 0x13, 0x17, 0xaa, 0x2f, 0x35, 0x29, 0xe8, 0x8f, 0x14, 0xb8, 0x0e, 0x4b, 0x65,
-	0x40, 0x9e, 0x75, 0x50, 0x43, 0x42, 0x6e, 0xc0, 0xd5, 0x32, 0xa4, 0x48, 0x71, 0xa8, 0xb9, 0xd4,
-	0xfc, 0x2e, 0x81, 0x16, 0xe4, 0xcb, 0x5e, 0x23, 0x50, 0xab, 0xdc, 0x40, 0xc9, 0x34, 0x08, 0x0b,
-	0xe8, 0xd0, 0x2b, 0x30, 0x48, 0x8f, 0x05, 0xd4, 0x16, 0x2c, 0x0a, 0x56, 0xca, 0x00, 0xaa, 0x60,
-	0x52, 0x90, 0x22, 0xeb, 0x22, 0xa3, 0x8e, 0x60, 0x71, 0x13, 0x2e, 0xcb, 0x08, 0xa9, 0xa7, 0x8a,
-	0xba, 0x02, 0x72, 0x0d, 0xb4, 0x9c, 0x27, 0x59, 0xf1, 0x8b, 0xe6, 0xc5, 0xec, 0x5a, 0x5e, 0x4e,
-	0xf9, 0xc2, 0x83, 0xd0, 0x52, 0x9d, 0x62, 0x9a, 0x8a, 0x76, 0x1d, 0x2e, 0xe6, 0x2c, 0x27, 0x9e,
-	0xd7, 0xd1, 0x82, 0x10, 0xf4, 0x36, 0x5c, 0x2b, 0x44, 0x52, 0xee, 0x31, 0x09, 0x69, 0x29, 0xae,
-	0x57, 0x8a, 0xdb, 0xb2, 0x8f, 0xd1, 0x05, 0xee, 0xa9, 0xdf, 0x95, 0xc8, 0xcc, 0x1f, 0x97, 0xd0,
-	0xc5, 0x72, 0xbb, 0xa5, 0xe5, 0x2b, 0x5a, 0x14, 0xcb, 0x5c, 0x85, 0x85, 0x3c, 0x80, 0xf2, 0xbf,
-	0x94, 0x6a, 0x9c, 0x8b, 0x97, 0x7c, 0xcf, 0x00, 0x5d, 0x16, 0xa8, 0x82, 0xff, 0xe4, 0x57, 0x59,
-	0xd4, 0x13, 0x98, 0xd5, 0x7c, 0x88, 0xe6, 0x1e, 0x6a, 0xd1, 0x95, 0x72, 0x50, 0xee, 0x11, 0x0f,
-	0x2d, 0x09, 0x81, 0x57, 0xf3, 0x1a, 0xa5, 0x4f, 0x77, 0xe8, 0xaa, 0x64, 0x94, 0x42, 0x34, 0x64,
-	0xaf, 0xb1, 0xe8, 0x5a, 0xf9, 0xae, 0xca, 0x1e, 0x49, 0xd0, 0x72, 0x79, 0xd4, 0x26, 0xd3, 0xd7,
-	0xd3, 0xa8, 0xcd, 0xf9, 0x39, 0x39, 0x81, 0xd1, 0x8a, 0xb4, 0x8b, 0x0a, 0x96, 0x91, 0xdb, 0xd2,
-	0x48, 0x2f, 0xb7, 0x71, 0xbe, 0x55, 0x8d, 0x56, 0xcb, 0xc3, 0x3b, 0x6b, 0x5f, 0xa3, 0xb5, 0xf2,
-	0xf0, 0x96, 0xea, 0x7b, 0x74, 0xbb, 0xdc, 0xbe, 0xb9, 0xa2, 0x1d, 0xdd, 0x11, 0xa0, 0x42, 0x7c,
-	0x16, 0xcb, 0x6d, 0xb4, 0x2e, 0x24, 0xba, 0x03, 0xcb, 0xb9, 0xf8, 0x2c, 0x3e, 0x65, 0xa2, 0x8d,
-	0x14, 0x78, 0xa5, 0x1c, 0x48, 0xa5, 0xbf, 0x2b, 0x39, 0xed, 0x76, 0xc1, 0x12, 0xb9, 0x56, 0x0d,
-	0xba, 0x27, 0xed, 0x30, 0x2d, 0x1f, 0xb2, 0x6c, 0xfe, 0xad, 0xa5, 0xfa, 0x77, 0x7c, 0xbe, 0x60,
-	0xd1, 0x7c, 0x07, 0x1f, 0xbd, 0x5d, 0x6e, 0x2f, 0xa9, 0x15, 0x8d, 0xfa, 0xe5, 0x99, 0x5b, 0x34,
-	0xa5, 0xd1, 0xfd, 0x72, 0x4b, 0x15, 0x9b, 0x50, 0xe8, 0x9d, 0x74, 0x27, 0x17, 0x3c, 0x2c, 0x77,
-	0x0d, 0xd1, 0xbb, 0xa9, 0x5e, 0xeb, 0x79, 0x7e, 0xc5, 0xae, 0x25, 0xda, 0x4c, 0x35, 0x2c, 0x70,
-	0xcc, 0xf7, 0x21, 0xd1, 0x7b, 0xb3, 0x38, 0x16, 0x9b, 0x87, 0xe8, 0xfd, 0x94, 0xa3, 0x5e, 0xcc,
-	0x6d, 0xd9, 0xbd, 0x08, 0x7d, 0x50, 0x1e, 0xa9, 0xf9, 0x0b, 0x08, 0xfa, 0x50, 0x68, 0x5b, 0xb0,
-	0xab, 0xf4, 0xef, 0x46, 0xe8, 0x9f, 0x05, 0xa3, 0x75, 0xb8, 0x9e, 0x53, 0xf4, 0xcc, 0x43, 0x25,
-	0xfa, 0x48, 0x20, 0x6f, 0xe5, 0x8f, 0xa1, 0xc2, 0xbb, 0x22, 0xfa, 0x17, 0xb1, 0x66, 0x71, 0x0f,
-	0xe5, 0x9a, 0x17, 0xe8, 0x41, 0x7a, 0x4c, 0x2e, 0x97, 0xa1, 0xb2, 0x9c, 0xf8, 0xaf, 0x69, 0x8a,
-	0xb9, 0x52, 0x0e, 0xa4, 0xde, 0xff, 0xb7, 0x72, 0x6e, 0x67, 0x2e, 0x49, 0xe8, 0xe3, 0x19, 0x1b,
-	0x3c, 0x8f, 0xfa, 0xa4, 0x7c, 0xcd, 0xdc, 0x75, 0x05, 0x7d, 0x2a, 0x58, 0x6d, 0xc0, 0x8d, 0x59,
-	0x7a, 0x26, 0x2e, 0xfd, 0x4c, 0x40, 0xef, 0xc1, 0xcd, 0x32, 0x68, 0x7e, 0xcf, 0x6f, 0x09, 0x70,
-	0x1f, 0xd6, 0xca, 0xc0, 0x67, 0xf6, 0xfe, 0x43, 0x21, 0xec, 0xbd, 0xbc, 0xee, 0x67, 0xee, 0x15,
-	0xc8, 0x59, 0x6a, 0x7e, 0x9f, 0x6c, 0xeb, 0x3b, 0x33, 0xc0, 0xc9, 0xc5, 0x02, 0xe1, 0xa5, 0xda,
-	0xf7, 0x25, 0x86, 0xca, 0xdf, 0x35, 0xd0, 0xd1, 0x52, 0xed, 0x87, 0x12, 0x43, 0xe5, 0xaa, 0x65,
-	0x34, 0x14, 0xac, 0x0a, 0xe1, 0x2c, 0x57, 0xd0, 0x68, 0x24, 0x18, 0x15, 0x8c, 0x59, 0x52, 0x13,
-	0x23, 0x57, 0xb0, 0x2b, 0x84, 0x61, 0x01, 0x8a, 0x3c, 0xc1, 0xf1, 0x2e, 0xac, 0x9c, 0x03, 0x63,
-	0x15, 0x2f, 0xf2, 0x05, 0xcb, 0x59, 0xab, 0x67, 0xd5, 0x2b, 0xfa, 0x9a, 0x43, 0x1f, 0xbe, 0x0f,
-	0xab, 0xb6, 0x37, 0xe9, 0x87, 0x56, 0xe4, 0x85, 0x23, 0x32, 0xb6, 0x0e, 0xc3, 0x7e, 0x14, 0xe0,
-	0x97, 0x5e, 0xd0, 0x1f, 0x93, 0x43, 0xfe, 0x6f, 0x7e, 0x87, 0xf1, 0xd1, 0xc3, 0xce, 0x01, 0x23,
-	0x0a, 0xae, 0x7f, 0x0f, 0x00, 0x00, 0xff, 0xff, 0x2a, 0xe4, 0xc0, 0x85, 0x16, 0x28, 0x00, 0x00,
-}
diff --git a/accounts/usbwallet/internal/trezor/messages.proto b/accounts/usbwallet/internal/trezor/messages.proto
deleted file mode 100644
index 8cb9c8cc2..000000000
--- a/accounts/usbwallet/internal/trezor/messages.proto
+++ /dev/null
@@ -1,905 +0,0 @@
-// This file originates from the SatoshiLabs Trezor `common` repository at:
-//   https://github.com/trezor/trezor-common/blob/master/protob/messages.proto
-// dated 28.07.2017, commit dd8ec3231fb5f7992360aff9bdfe30bb58130f4b.
-
-syntax = "proto2";
-
-/**
- * Messages for TREZOR communication
- */
-
-// Sugar for easier handling in Java
-option java_package = "com.satoshilabs.trezor.lib.protobuf";
-option java_outer_classname = "TrezorMessage";
-
-import "types.proto";
-
-/**
- * Mapping between Trezor wire identifier (uint) and a protobuf message
- */
-enum MessageType {
-	MessageType_Initialize = 0 [(wire_in) = true];
-	MessageType_Ping = 1 [(wire_in) = true];
-	MessageType_Success = 2 [(wire_out) = true];
-	MessageType_Failure = 3 [(wire_out) = true];
-	MessageType_ChangePin = 4 [(wire_in) = true];
-	MessageType_WipeDevice = 5 [(wire_in) = true];
-	MessageType_FirmwareErase = 6 [(wire_in) = true, (wire_bootloader) = true];
-	MessageType_FirmwareUpload = 7 [(wire_in) = true, (wire_bootloader) = true];
-	MessageType_FirmwareRequest = 8 [(wire_out) = true, (wire_bootloader) = true];
-	MessageType_GetEntropy = 9 [(wire_in) = true];
-	MessageType_Entropy = 10 [(wire_out) = true];
-	MessageType_GetPublicKey = 11 [(wire_in) = true];
-	MessageType_PublicKey = 12 [(wire_out) = true];
-	MessageType_LoadDevice = 13 [(wire_in) = true];
-	MessageType_ResetDevice = 14 [(wire_in) = true];
-	MessageType_SignTx = 15 [(wire_in) = true];
-	MessageType_SimpleSignTx = 16 [(wire_in) = true, deprecated = true];
-	MessageType_Features = 17 [(wire_out) = true];
-	MessageType_PinMatrixRequest = 18 [(wire_out) = true];
-	MessageType_PinMatrixAck = 19 [(wire_in) = true, (wire_tiny) = true];
-	MessageType_Cancel = 20 [(wire_in) = true];
-	MessageType_TxRequest = 21 [(wire_out) = true];
-	MessageType_TxAck = 22 [(wire_in) = true];
-	MessageType_CipherKeyValue = 23 [(wire_in) = true];
-	MessageType_ClearSession = 24 [(wire_in) = true];
-	MessageType_ApplySettings = 25 [(wire_in) = true];
-	MessageType_ButtonRequest = 26 [(wire_out) = true];
-	MessageType_ButtonAck = 27 [(wire_in) = true, (wire_tiny) = true];
-	MessageType_ApplyFlags = 28 [(wire_in) = true];
-	MessageType_GetAddress = 29 [(wire_in) = true];
-	MessageType_Address = 30 [(wire_out) = true];
-	MessageType_SelfTest = 32 [(wire_in) = true, (wire_bootloader) = true];
-	MessageType_BackupDevice = 34 [(wire_in) = true];
-	MessageType_EntropyRequest = 35 [(wire_out) = true];
-	MessageType_EntropyAck = 36 [(wire_in) = true];
-	MessageType_SignMessage = 38 [(wire_in) = true];
-	MessageType_VerifyMessage = 39 [(wire_in) = true];
-	MessageType_MessageSignature = 40 [(wire_out) = true];
-	MessageType_PassphraseRequest = 41 [(wire_out) = true];
-	MessageType_PassphraseAck = 42 [(wire_in) = true, (wire_tiny) = true];
-	MessageType_EstimateTxSize = 43 [(wire_in) = true, deprecated = true];
-	MessageType_TxSize = 44 [(wire_out) = true, deprecated = true];
-	MessageType_RecoveryDevice = 45 [(wire_in) = true];
-	MessageType_WordRequest = 46 [(wire_out) = true];
-	MessageType_WordAck = 47 [(wire_in) = true];
-	MessageType_CipheredKeyValue = 48 [(wire_out) = true];
-	MessageType_EncryptMessage = 49 [(wire_in) = true, deprecated = true];
-	MessageType_EncryptedMessage = 50 [(wire_out) = true, deprecated = true];
-	MessageType_DecryptMessage = 51 [(wire_in) = true, deprecated = true];
-	MessageType_DecryptedMessage = 52 [(wire_out) = true, deprecated = true];
-	MessageType_SignIdentity = 53 [(wire_in) = true];
-	MessageType_SignedIdentity = 54 [(wire_out) = true];
-	MessageType_GetFeatures = 55 [(wire_in) = true];
-	MessageType_EthereumGetAddress = 56 [(wire_in) = true];
-	MessageType_EthereumAddress = 57 [(wire_out) = true];
-	MessageType_EthereumSignTx = 58 [(wire_in) = true];
-	MessageType_EthereumTxRequest = 59 [(wire_out) = true];
-	MessageType_EthereumTxAck = 60 [(wire_in) = true];
-	MessageType_GetECDHSessionKey = 61 [(wire_in) = true];
-	MessageType_ECDHSessionKey = 62 [(wire_out) = true];
-	MessageType_SetU2FCounter = 63 [(wire_in) = true];
-	MessageType_EthereumSignMessage = 64 [(wire_in) = true];
-	MessageType_EthereumVerifyMessage = 65 [(wire_in) = true];
-	MessageType_EthereumMessageSignature = 66 [(wire_out) = true];
-	MessageType_DebugLinkDecision = 100 [(wire_debug_in) = true, (wire_tiny) = true];
-	MessageType_DebugLinkGetState = 101 [(wire_debug_in) = true];
-	MessageType_DebugLinkState = 102 [(wire_debug_out) = true];
-	MessageType_DebugLinkStop = 103 [(wire_debug_in) = true];
-	MessageType_DebugLinkLog = 104 [(wire_debug_out) = true];
-	MessageType_DebugLinkMemoryRead = 110 [(wire_debug_in) = true];
-	MessageType_DebugLinkMemory = 111 [(wire_debug_out) = true];
-	MessageType_DebugLinkMemoryWrite = 112 [(wire_debug_in) = true];
-	MessageType_DebugLinkFlashErase = 113 [(wire_debug_in) = true];
-}
-
-////////////////////
-// Basic messages //
-////////////////////
-
-/**
- * Request: Reset device to default state and ask for device details
- * @next Features
- */
-message Initialize {
-}
-
-/**
- * Request: Ask for device details (no device reset)
- * @next Features
- */
-message GetFeatures {
-}
-
-/**
- * Response: Reports various information about the device
- * @prev Initialize
- * @prev GetFeatures
- */
-message Features {
-	optional string vendor = 1;			// name of the manufacturer, e.g. "bitcointrezor.com"
-	optional uint32 major_version = 2;		// major version of the device, e.g. 1
-	optional uint32 minor_version = 3;		// minor version of the device, e.g. 0
-	optional uint32 patch_version = 4;		// patch version of the device, e.g. 0
-	optional bool bootloader_mode = 5;		// is device in bootloader mode?
-	optional string device_id = 6;			// device's unique identifier
-	optional bool pin_protection = 7;		// is device protected by PIN?
-	optional bool passphrase_protection = 8;	// is node/mnemonic encrypted using passphrase?
-	optional string language = 9;			// device language
-	optional string label = 10;			// device description label
-	repeated CoinType coins = 11;			// supported coins
-	optional bool initialized = 12;			// does device contain seed?
-	optional bytes revision = 13;			// SCM revision of firmware
-	optional bytes bootloader_hash = 14;		// hash of the bootloader
-	optional bool imported = 15;			// was storage imported from an external source?
-	optional bool pin_cached = 16;			// is PIN already cached in session?
-	optional bool passphrase_cached = 17;		// is passphrase already cached in session?
-	optional bool firmware_present = 18;		// is valid firmware loaded?
-	optional bool needs_backup = 19;		// does storage need backup? (equals to Storage.needs_backup)
-	optional uint32 flags = 20;			// device flags (equals to Storage.flags)
-}
-
-/**
- * Request: clear session (removes cached PIN, passphrase, etc).
- * @next Success
- */
-message ClearSession {
-}
-
-/**
- * Request: change language and/or label of the device
- * @next Success
- * @next Failure
- * @next ButtonRequest
- * @next PinMatrixRequest
- */
-message ApplySettings {
-	optional string language = 1;
-	optional string label = 2;
-	optional bool use_passphrase = 3;
-	optional bytes homescreen = 4;
-}
-
-/**
- * Request: set flags of the device
- * @next Success
- * @next Failure
- */
-message ApplyFlags {
-	optional uint32 flags = 1;	// bitmask, can only set bits, not unset
-}
-
-/**
- * Request: Starts workflow for setting/changing/removing the PIN
- * @next ButtonRequest
- * @next PinMatrixRequest
- */
-message ChangePin {
-	optional bool remove = 1;	// is PIN removal requested?
-}
-
-/**
- * Request: Test if the device is alive, device sends back the message in Success response
- * @next Success
- */
-message Ping {
-	optional string message = 1;			// message to send back in Success message
-	optional bool button_protection = 2;		// ask for button press
-	optional bool pin_protection = 3;		// ask for PIN if set in device
-	optional bool passphrase_protection = 4;	// ask for passphrase if set in device
-}
-
-/**
- * Response: Success of the previous request
- */
-message Success {
-	optional string message = 1;	// human readable description of action or request-specific payload
-}
-
-/**
- * Response: Failure of the previous request
- */
-message Failure {
-	optional FailureType code = 1;	// computer-readable definition of the error state
-	optional string message = 2;	// human-readable message of the error state
-}
-
-/**
- * Response: Device is waiting for HW button press.
- * @next ButtonAck
- * @next Cancel
- */
-message ButtonRequest {
-	optional ButtonRequestType code = 1;
-	optional string data = 2;
-}
-
-/**
- * Request: Computer agrees to wait for HW button press
- * @prev ButtonRequest
- */
-message ButtonAck {
-}
-
-/**
- * Response: Device is asking computer to show PIN matrix and awaits PIN encoded using this matrix scheme
- * @next PinMatrixAck
- * @next Cancel
- */
-message PinMatrixRequest {
-	optional PinMatrixRequestType type = 1;
-}
-
-/**
- * Request: Computer responds with encoded PIN
- * @prev PinMatrixRequest
- */
-message PinMatrixAck {
-	required string pin = 1;		// matrix encoded PIN entered by user
-}
-
-/**
- * Request: Abort last operation that required user interaction
- * @prev ButtonRequest
- * @prev PinMatrixRequest
- * @prev PassphraseRequest
- */
-message Cancel {
-}
-
-/**
- * Response: Device awaits encryption passphrase
- * @next PassphraseAck
- * @next Cancel
- */
-message PassphraseRequest {
-}
-
-/**
- * Request: Send passphrase back
- * @prev PassphraseRequest
- */
-message PassphraseAck {
-	required string passphrase = 1;
-}
-
-/**
- * Request: Request a sample of random data generated by hardware RNG. May be used for testing.
- * @next ButtonRequest
- * @next Entropy
- * @next Failure
- */
-message GetEntropy {
-	required uint32 size = 1;		// size of requested entropy
-}
-
-/**
- * Response: Reply with random data generated by internal RNG
- * @prev GetEntropy
- */
-message Entropy {
-	required bytes entropy = 1;		// stream of random generated bytes
-}
-
-/**
- * Request: Ask device for public key corresponding to address_n path
- * @next PassphraseRequest
- * @next PublicKey
- * @next Failure
- */
-message GetPublicKey {
-	repeated uint32 address_n = 1;		// BIP-32 path to derive the key from master node
-	optional string ecdsa_curve_name = 2;	// ECDSA curve name to use
-	optional bool show_display = 3;		// optionally show on display before sending the result
-	optional string coin_name = 4 [default='Bitcoin'];
-}
-
-/**
- * Response: Contains public key derived from device private seed
- * @prev GetPublicKey
- */
-message PublicKey {
-	required HDNodeType node = 1;		// BIP32 public node
-	optional string xpub = 2;		// serialized form of public node
-}
-
-/**
- * Request: Ask device for address corresponding to address_n path
- * @next PassphraseRequest
- * @next Address
- * @next Failure
- */
-message GetAddress {
-	repeated uint32 address_n = 1;						// BIP-32 path to derive the key from master node
-	optional string coin_name = 2 [default='Bitcoin'];
-	optional bool show_display = 3			;			// optionally show on display before sending the result
-	optional MultisigRedeemScriptType multisig = 4;				// filled if we are showing a multisig address
-	optional InputScriptType script_type = 5 [default=SPENDADDRESS];	// used to distinguish between various address formats (non-segwit, segwit, etc.)
-}
-
-/**
- * Request: Ask device for Ethereum address corresponding to address_n path
- * @next PassphraseRequest
- * @next EthereumAddress
- * @next Failure
- */
-message EthereumGetAddress {
-	repeated uint32 address_n = 1;			// BIP-32 path to derive the key from master node
-	optional bool show_display = 2;			// optionally show on display before sending the result
-}
-
-/**
- * Response: Contains address derived from device private seed
- * @prev GetAddress
- */
-message Address {
-	required string address = 1;		// Coin address in Base58 encoding
-}
-
-/**
- * Response: Contains an Ethereum address derived from device private seed
- * @prev EthereumGetAddress
- */
-message EthereumAddress {
-	required bytes address = 1;		// Coin address as an Ethereum 160 bit hash
-}
-
-/**
- * Request: Request device to wipe all sensitive data and settings
- * @next ButtonRequest
- */
-message WipeDevice {
-}
-
-/**
- * Request: Load seed and related internal settings from the computer
- * @next ButtonRequest
- * @next Success
- * @next Failure
- */
-message LoadDevice {
-	optional string mnemonic = 1;				// seed encoded as BIP-39 mnemonic (12, 18 or 24 words)
-	optional HDNodeType node = 2;				// BIP-32 node
-	optional string pin = 3;				// set PIN protection
-	optional bool passphrase_protection = 4;		// enable master node encryption using passphrase
-	optional string language = 5 [default='english'];	// device language
-	optional string label = 6;				// device label
-	optional bool skip_checksum = 7;			// do not test mnemonic for valid BIP-39 checksum
-	optional uint32 u2f_counter = 8;			// U2F counter
-}
-
-/**
- * Request: Ask device to do initialization involving user interaction
- * @next EntropyRequest
- * @next Failure
- */
-message ResetDevice {
-	optional bool display_random = 1;			// display entropy generated by the device before asking for additional entropy
-	optional uint32 strength = 2 [default=256];		// strength of seed in bits
-	optional bool passphrase_protection = 3;		// enable master node encryption using passphrase
-	optional bool pin_protection = 4;			// enable PIN protection
-	optional string language = 5 [default='english'];	// device language
-	optional string label = 6;				// device label
-	optional uint32 u2f_counter = 7;			// U2F counter
-	optional bool skip_backup = 8;				// postpone seed backup to BackupDevice workflow
-}
-
-/**
- * Request: Perform backup of the device seed if not backed up using ResetDevice
- * @next ButtonRequest
- */
-message BackupDevice {
-}
-
-/**
- * Response: Ask for additional entropy from host computer
- * @prev ResetDevice
- * @next EntropyAck
- */
-message EntropyRequest {
-}
-
-/**
- * Request: Provide additional entropy for seed generation function
- * @prev EntropyRequest
- * @next ButtonRequest
- */
-message EntropyAck {
-	optional bytes entropy = 1;				// 256 bits (32 bytes) of random data
-}
-
-/**
- * Request: Start recovery workflow asking user for specific words of mnemonic
- * Used to recovery device safely even on untrusted computer.
- * @next WordRequest
- */
-message RecoveryDevice {
-	optional uint32 word_count = 1;				// number of words in BIP-39 mnemonic
-	optional bool passphrase_protection = 2;		// enable master node encryption using passphrase
-	optional bool pin_protection = 3;			// enable PIN protection
-	optional string language = 4 [default='english'];	// device language
-	optional string label = 5;				// device label
-	optional bool enforce_wordlist = 6;			// enforce BIP-39 wordlist during the process
-	// 7 reserved for unused recovery method
-	optional uint32 type = 8;				// supported recovery type (see RecoveryType)
-	optional uint32 u2f_counter = 9;			// U2F counter
-	optional bool dry_run = 10;				// perform dry-run recovery workflow (for safe mnemonic validation)
-}
-
-/**
- * Response: Device is waiting for user to enter word of the mnemonic
- * Its position is shown only on device's internal display.
- * @prev RecoveryDevice
- * @prev WordAck
- */
-message WordRequest {
-	optional WordRequestType type = 1;
-}
-
-/**
- * Request: Computer replies with word from the mnemonic
- * @prev WordRequest
- * @next WordRequest
- * @next Success
- * @next Failure
- */
-message WordAck {
-	required string word = 1;				// one word of mnemonic on asked position
-}
-
-//////////////////////////////
-// Message signing messages //
-//////////////////////////////
-
-/**
- * Request: Ask device to sign message
- * @next MessageSignature
- * @next Failure
- */
-message SignMessage {
-	repeated uint32 address_n = 1;						// BIP-32 path to derive the key from master node
-	required bytes message = 2;						// message to be signed
-	optional string coin_name = 3 [default='Bitcoin'];			// coin to use for signing
-	optional InputScriptType script_type = 4 [default=SPENDADDRESS];	// used to distinguish between various address formats (non-segwit, segwit, etc.)
-}
-
-/**
- * Request: Ask device to verify message
- * @next Success
- * @next Failure
- */
-message VerifyMessage {
-	optional string address = 1;				// address to verify
-	optional bytes signature = 2;				// signature to verify
-	optional bytes message = 3;				// message to verify
-	optional string coin_name = 4 [default='Bitcoin'];	// coin to use for verifying
-}
-
-/**
- * Response: Signed message
- * @prev SignMessage
- */
-message MessageSignature {
-	optional string address = 1;				// address used to sign the message
-	optional bytes signature = 2;				// signature of the message
-}
-
-///////////////////////////
-// Encryption/decryption //
-///////////////////////////
-
-/**
- * Request: Ask device to encrypt message
- * @next EncryptedMessage
- * @next Failure
- */
-message EncryptMessage {
-	optional bytes pubkey = 1;				// public key
-	optional bytes message = 2;				// message to encrypt
-	optional bool display_only = 3;				// show just on display? (don't send back via wire)
-	repeated uint32 address_n = 4;				// BIP-32 path to derive the signing key from master node
-	optional string coin_name = 5 [default='Bitcoin'];	// coin to use for signing
-}
-
-/**
- * Response: Encrypted message
- * @prev EncryptMessage
- */
-message EncryptedMessage {
-	optional bytes nonce = 1;				// nonce used during encryption
-	optional bytes message = 2;				// encrypted message
-	optional bytes hmac = 3;				// message hmac
-}
-
-/**
- * Request: Ask device to decrypt message
- * @next Success
- * @next Failure
- */
-message DecryptMessage {
-	repeated uint32 address_n = 1;				// BIP-32 path to derive the decryption key from master node
-	optional bytes nonce = 2;				// nonce used during encryption
-	optional bytes message = 3;				// message to decrypt
-	optional bytes hmac = 4;				// message hmac
-}
-
-/**
- * Response: Decrypted message
- * @prev DecryptedMessage
- */
-message DecryptedMessage {
-	optional bytes message = 1;				// decrypted message
-	optional string address = 2;				// address used to sign the message (if used)
-}
-
-/**
- * Request: Ask device to encrypt or decrypt value of given key
- * @next CipheredKeyValue
- * @next Failure
- */
-message CipherKeyValue {
-	repeated uint32 address_n = 1;		// BIP-32 path to derive the key from master node
-	optional string key = 2;		// key component of key:value
-	optional bytes value = 3;		// value component of key:value
-	optional bool encrypt = 4;		// are we encrypting (True) or decrypting (False)?
-	optional bool ask_on_encrypt = 5;	// should we ask on encrypt operation?
-	optional bool ask_on_decrypt = 6;	// should we ask on decrypt operation?
-	optional bytes iv = 7;			// initialization vector (will be computed if not set)
-}
-
-/**
- * Response: Return ciphered/deciphered value
- * @prev CipherKeyValue
- */
-message CipheredKeyValue {
-	optional bytes value = 1;		// ciphered/deciphered value
-}
-
-//////////////////////////////////
-// Transaction signing messages //
-//////////////////////////////////
-
-/**
- * Request: Estimated size of the transaction
- * This behaves exactly like SignTx, which means that it can ask using TxRequest
- * This call is non-blocking (except possible PassphraseRequest to unlock the seed)
- * @next TxSize
- * @next Failure
- */
-message EstimateTxSize {
-	required uint32 outputs_count = 1;			// number of transaction outputs
-	required uint32 inputs_count = 2;			// number of transaction inputs
-	optional string coin_name = 3 [default='Bitcoin'];	// coin to use
-}
-
-/**
- * Response: Estimated size of the transaction
- * @prev EstimateTxSize
- */
-message TxSize {
-	optional uint32 tx_size = 1;				// estimated size of transaction in bytes
-}
-
-/**
- * Request: Ask device to sign transaction
- * @next PassphraseRequest
- * @next PinMatrixRequest
- * @next TxRequest
- * @next Failure
- */
-message SignTx {
-	required uint32 outputs_count = 1;			// number of transaction outputs
-	required uint32 inputs_count = 2;			// number of transaction inputs
-	optional string coin_name = 3 [default='Bitcoin'];	// coin to use
-	optional uint32 version = 4 [default=1];		// transaction version
-	optional uint32 lock_time = 5 [default=0];		// transaction lock_time
-}
-
-/**
- * Request: Simplified transaction signing
- * This method doesn't support streaming, so there are hardware limits in number of inputs and outputs.
- * In case of success, the result is returned using TxRequest message.
- * @next PassphraseRequest
- * @next PinMatrixRequest
- * @next TxRequest
- * @next Failure
- */
-message SimpleSignTx {
-	repeated TxInputType inputs = 1;			// transaction inputs
-	repeated TxOutputType outputs = 2;			// transaction outputs
-	repeated TransactionType transactions = 3;		// transactions whose outputs are used to build current inputs
-	optional string coin_name = 4 [default='Bitcoin'];	// coin to use
-	optional uint32 version = 5 [default=1];		// transaction version
-	optional uint32 lock_time = 6 [default=0];		// transaction lock_time
-}
-
-/**
- * Response: Device asks for information for signing transaction or returns the last result
- * If request_index is set, device awaits TxAck message (with fields filled in according to request_type)
- * If signature_index is set, 'signature' contains signed input of signature_index's input
- * @prev SignTx
- * @prev SimpleSignTx
- * @prev TxAck
- */
-message TxRequest {
-	optional RequestType request_type = 1;			// what should be filled in TxAck message?
-	optional TxRequestDetailsType details = 2;		// request for tx details
-	optional TxRequestSerializedType serialized = 3;	// serialized data and request for next
-}
-
-/**
- * Request: Reported transaction data
- * @prev TxRequest
- * @next TxRequest
- */
-message TxAck {
-	optional TransactionType tx = 1;
-}
-
-/**
- * Request: Ask device to sign transaction
- * All fields are optional from the protocol's point of view. Each field defaults to value `0` if missing.
- * Note: the first at most 1024 bytes of data MUST be transmitted as part of this message.
- * @next PassphraseRequest
- * @next PinMatrixRequest
- * @next EthereumTxRequest
- * @next Failure
- */
-message EthereumSignTx {
-	repeated uint32 address_n = 1;			// BIP-32 path to derive the key from master node
-	optional bytes nonce = 2;			// <=256 bit unsigned big endian
-	optional bytes gas_price = 3;			// <=256 bit unsigned big endian (in wei)
-	optional bytes gas_limit = 4;			// <=256 bit unsigned big endian
-	optional bytes to = 5;				// 160 bit address hash
-	optional bytes value = 6;			// <=256 bit unsigned big endian (in wei)
-	optional bytes data_initial_chunk = 7;		// The initial data chunk (<= 1024 bytes)
-	optional uint32 data_length = 8;		// Length of transaction payload
-	optional uint32 chain_id = 9;			// Chain Id for EIP 155
-}
-
-/**
- * Response: Device asks for more data from transaction payload, or returns the signature.
- * If data_length is set, device awaits that many more bytes of payload.
- * Otherwise, the signature_* fields contain the computed transaction signature. All three fields will be present.
- * @prev EthereumSignTx
- * @next EthereumTxAck
- */
-message EthereumTxRequest {
-	optional uint32 data_length = 1;		// Number of bytes being requested (<= 1024)
-	optional uint32 signature_v = 2;		// Computed signature (recovery parameter, limited to 27 or 28)
-	optional bytes signature_r = 3;			// Computed signature R component (256 bit)
-	optional bytes signature_s = 4;			// Computed signature S component (256 bit)
-}
-
-/**
- * Request: Transaction payload data.
- * @prev EthereumTxRequest
- * @next EthereumTxRequest
- */
-message EthereumTxAck {
-	optional bytes data_chunk = 1;			// Bytes from transaction payload (<= 1024 bytes)
-}
-
-////////////////////////////////////////
-// Ethereum: Message signing messages //
-////////////////////////////////////////
-
-/**
- * Request: Ask device to sign message
- * @next EthereumMessageSignature
- * @next Failure
- */
-message EthereumSignMessage {
-	repeated uint32 address_n = 1;				// BIP-32 path to derive the key from master node
-	required bytes message = 2;				// message to be signed
-}
-
-/**
- * Request: Ask device to verify message
- * @next Success
- * @next Failure
- */
-message EthereumVerifyMessage {
-	optional bytes address = 1;				// address to verify
-	optional bytes signature = 2;				// signature to verify
-	optional bytes message = 3;				// message to verify
-}
-
-/**
- * Response: Signed message
- * @prev EthereumSignMessage
- */
-message EthereumMessageSignature {
-	optional bytes address = 1;				// address used to sign the message
-	optional bytes signature = 2;				// signature of the message
-}
-
-///////////////////////
-// Identity messages //
-///////////////////////
-
-/**
- * Request: Ask device to sign identity
- * @next SignedIdentity
- * @next Failure
- */
-message SignIdentity {
-	optional IdentityType identity = 1;		// identity
-	optional bytes challenge_hidden = 2;		// non-visible challenge
-	optional string challenge_visual = 3;		// challenge shown on display (e.g. date+time)
-	optional string ecdsa_curve_name = 4;		// ECDSA curve name to use
-}
-
-/**
- * Response: Device provides signed identity
- * @prev SignIdentity
- */
-message SignedIdentity {
-	optional string address = 1;			// identity address
-	optional bytes public_key = 2;			// identity public key
-	optional bytes signature = 3;			// signature of the identity data
-}
-
-///////////////////
-// ECDH messages //
-///////////////////
-
-/**
- * Request: Ask device to generate ECDH session key
- * @next ECDHSessionKey
- * @next Failure
- */
-message GetECDHSessionKey {
-	optional IdentityType identity = 1;		// identity
-	optional bytes peer_public_key = 2;		// peer's public key
-	optional string ecdsa_curve_name = 3;		// ECDSA curve name to use
-}
-
-/**
- * Response: Device provides ECDH session key
- * @prev GetECDHSessionKey
- */
-message ECDHSessionKey {
-	optional bytes session_key = 1;			// ECDH session key
-}
-
-///////////////////
-// U2F messages //
-///////////////////
-
-/**
- * Request: Set U2F counter
- * @next Success
- */
-message SetU2FCounter {
-	optional uint32 u2f_counter = 1;		// counter
-}
-
-/////////////////////////
-// Bootloader messages //
-/////////////////////////
-
-/**
- * Request: Ask device to erase its firmware (so it can be replaced via FirmwareUpload)
- * @next Success
- * @next FirmwareRequest
- * @next Failure
- */
-message FirmwareErase {
-	optional uint32 length = 1;			// length of new firmware
-}
-
-/**
- * Response: Ask for firmware chunk
- * @next FirmwareUpload
- */
-message FirmwareRequest {
-	optional uint32 offset = 1;			// offset of requested firmware chunk
-	optional uint32 length = 2;			// length of requested firmware chunk
-}
-
-/**
- * Request: Send firmware in binary form to the device
- * @next Success
- * @next Failure
- */
-message FirmwareUpload {
-	required bytes payload = 1;			// firmware to be loaded into device
-	optional bytes hash = 2;			// hash of the payload
-}
-
-
-/**
- * Request: Perform a device self-test
- * @next Success
- * @next Failure
- */
-message SelfTest {
-	optional bytes payload = 1;			// payload to be used in self-test
-}
-
-/////////////////////////////////////////////////////////////
-// Debug messages (only available if DebugLink is enabled) //
-/////////////////////////////////////////////////////////////
-
-/**
- * Request: "Press" the button on the device
- * @next Success
- */
-message DebugLinkDecision {
-	required bool yes_no = 1;			// true for "Confirm", false for "Cancel"
-}
-
-/**
- * Request: Computer asks for device state
- * @next DebugLinkState
- */
-message DebugLinkGetState {
-}
-
-/**
- * Response: Device current state
- * @prev DebugLinkGetState
- */
-message DebugLinkState {
-	optional bytes layout = 1;			// raw buffer of display
-	optional string pin = 2;			// current PIN, blank if PIN is not set/enabled
-	optional string matrix = 3;			// current PIN matrix
-	optional string mnemonic = 4;			// current BIP-39 mnemonic
-	optional HDNodeType node = 5;			// current BIP-32 node
-	optional bool passphrase_protection = 6;	// is node/mnemonic encrypted using passphrase?
-	optional string reset_word = 7;			// word on device display during ResetDevice workflow
-	optional bytes reset_entropy = 8;		// current entropy during ResetDevice workflow
-	optional string recovery_fake_word = 9;		// (fake) word on display during RecoveryDevice workflow
-	optional uint32 recovery_word_pos = 10;		// index of mnemonic word the device is expecting during RecoveryDevice workflow
-}
-
-/**
- * Request: Ask device to restart
- */
-message DebugLinkStop {
-}
-
-/**
- * Response: Device wants host to log event
- */
-message DebugLinkLog {
-	optional uint32 level = 1;
-	optional string bucket = 2;
-	optional string text = 3;
-}
-
-/**
- * Request: Read memory from device
- * @next DebugLinkMemory
- */
-message DebugLinkMemoryRead {
-	optional uint32 address = 1;
-	optional uint32 length = 2;
-}
-
-/**
- * Response: Device sends memory back
- * @prev DebugLinkMemoryRead
- */
-message DebugLinkMemory {
-	optional bytes memory = 1;
-}
-
-/**
- * Request: Write memory to device.
- * WARNING: Writing to the wrong location can irreparably break the device.
- */
-message DebugLinkMemoryWrite {
-	optional uint32 address = 1;
-	optional bytes memory = 2;
-	optional bool flash = 3;
-}
-
-/**
- * Request: Erase block of flash on device
- * WARNING: Writing to the wrong location can irreparably break the device.
- */
-message DebugLinkFlashErase {
-	optional uint32 sector = 1;
-}
diff --git a/accounts/usbwallet/internal/trezor/trezor.go b/accounts/usbwallet/internal/trezor/trezor.go
deleted file mode 100644
index 80cc75efc..000000000
--- a/accounts/usbwallet/internal/trezor/trezor.go
+++ /dev/null
@@ -1,46 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-// This file contains the implementation for interacting with the Trezor hardware
-// wallets. The wire protocol spec can be found on the SatoshiLabs website:
-// https://doc.satoshilabs.com/trezor-tech/api-protobuf.html
-
-//go:generate protoc --go_out=import_path=trezor:. types.proto messages.proto
-
-// Package trezor contains the wire protocol wrapper in Go.
-package trezor
-
-import (
-	"reflect"
-
-	"github.com/golang/protobuf/proto"
-)
-
-// Type returns the protocol buffer type number of a specific message. If the
-// message is nil, this method panics!
-func Type(msg proto.Message) uint16 {
-	return uint16(MessageType_value["MessageType_"+reflect.TypeOf(msg).Elem().Name()])
-}
-
-// Name returns the friendly message type name of a specific protocol buffer
-// type number.
-func Name(kind uint16) string {
-	name := MessageType_name[int32(kind)]
-	if len(name) < 12 {
-		return name
-	}
-	return name[12:]
-}
diff --git a/accounts/usbwallet/internal/trezor/types.pb.go b/accounts/usbwallet/internal/trezor/types.pb.go
deleted file mode 100644
index 25b7672d2..000000000
--- a/accounts/usbwallet/internal/trezor/types.pb.go
+++ /dev/null
@@ -1,1333 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: types.proto
-
-/*
-Package trezor is a generated protocol buffer package.
-
-It is generated from these files:
-	types.proto
-	messages.proto
-
-It has these top-level messages:
-	HDNodeType
-	HDNodePathType
-	CoinType
-	MultisigRedeemScriptType
-	TxInputType
-	TxOutputType
-	TxOutputBinType
-	TransactionType
-	TxRequestDetailsType
-	TxRequestSerializedType
-	IdentityType
-	Initialize
-	GetFeatures
-	Features
-	ClearSession
-	ApplySettings
-	ApplyFlags
-	ChangePin
-	Ping
-	Success
-	Failure
-	ButtonRequest
-	ButtonAck
-	PinMatrixRequest
-	PinMatrixAck
-	Cancel
-	PassphraseRequest
-	PassphraseAck
-	GetEntropy
-	Entropy
-	GetPublicKey
-	PublicKey
-	GetAddress
-	EthereumGetAddress
-	Address
-	EthereumAddress
-	WipeDevice
-	LoadDevice
-	ResetDevice
-	BackupDevice
-	EntropyRequest
-	EntropyAck
-	RecoveryDevice
-	WordRequest
-	WordAck
-	SignMessage
-	VerifyMessage
-	MessageSignature
-	EncryptMessage
-	EncryptedMessage
-	DecryptMessage
-	DecryptedMessage
-	CipherKeyValue
-	CipheredKeyValue
-	EstimateTxSize
-	TxSize
-	SignTx
-	SimpleSignTx
-	TxRequest
-	TxAck
-	EthereumSignTx
-	EthereumTxRequest
-	EthereumTxAck
-	EthereumSignMessage
-	EthereumVerifyMessage
-	EthereumMessageSignature
-	SignIdentity
-	SignedIdentity
-	GetECDHSessionKey
-	ECDHSessionKey
-	SetU2FCounter
-	FirmwareErase
-	FirmwareRequest
-	FirmwareUpload
-	SelfTest
-	DebugLinkDecision
-	DebugLinkGetState
-	DebugLinkState
-	DebugLinkStop
-	DebugLinkLog
-	DebugLinkMemoryRead
-	DebugLinkMemory
-	DebugLinkMemoryWrite
-	DebugLinkFlashErase
-*/
-package trezor
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-import google_protobuf "github.com/golang/protobuf/protoc-gen-go/descriptor"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-// *
-// Type of failures returned by Failure message
-// @used_in Failure
-type FailureType int32
-
-const (
-	FailureType_Failure_UnexpectedMessage FailureType = 1
-	FailureType_Failure_ButtonExpected    FailureType = 2
-	FailureType_Failure_DataError         FailureType = 3
-	FailureType_Failure_ActionCancelled   FailureType = 4
-	FailureType_Failure_PinExpected       FailureType = 5
-	FailureType_Failure_PinCancelled      FailureType = 6
-	FailureType_Failure_PinInvalid        FailureType = 7
-	FailureType_Failure_InvalidSignature  FailureType = 8
-	FailureType_Failure_ProcessError      FailureType = 9
-	FailureType_Failure_NotEnoughFunds    FailureType = 10
-	FailureType_Failure_NotInitialized    FailureType = 11
-	FailureType_Failure_FirmwareError     FailureType = 99
-)
-
-var FailureType_name = map[int32]string{
-	1:  "Failure_UnexpectedMessage",
-	2:  "Failure_ButtonExpected",
-	3:  "Failure_DataError",
-	4:  "Failure_ActionCancelled",
-	5:  "Failure_PinExpected",
-	6:  "Failure_PinCancelled",
-	7:  "Failure_PinInvalid",
-	8:  "Failure_InvalidSignature",
-	9:  "Failure_ProcessError",
-	10: "Failure_NotEnoughFunds",
-	11: "Failure_NotInitialized",
-	99: "Failure_FirmwareError",
-}
-var FailureType_value = map[string]int32{
-	"Failure_UnexpectedMessage": 1,
-	"Failure_ButtonExpected":    2,
-	"Failure_DataError":         3,
-	"Failure_ActionCancelled":   4,
-	"Failure_PinExpected":       5,
-	"Failure_PinCancelled":      6,
-	"Failure_PinInvalid":        7,
-	"Failure_InvalidSignature":  8,
-	"Failure_ProcessError":      9,
-	"Failure_NotEnoughFunds":    10,
-	"Failure_NotInitialized":    11,
-	"Failure_FirmwareError":     99,
-}
-
-func (x FailureType) Enum() *FailureType {
-	p := new(FailureType)
-	*p = x
-	return p
-}
-func (x FailureType) String() string {
-	return proto.EnumName(FailureType_name, int32(x))
-}
-func (x *FailureType) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(FailureType_value, data, "FailureType")
-	if err != nil {
-		return err
-	}
-	*x = FailureType(value)
-	return nil
-}
-func (FailureType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
-
-// *
-// Type of script which will be used for transaction output
-// @used_in TxOutputType
-type OutputScriptType int32
-
-const (
-	OutputScriptType_PAYTOADDRESS     OutputScriptType = 0
-	OutputScriptType_PAYTOSCRIPTHASH  OutputScriptType = 1
-	OutputScriptType_PAYTOMULTISIG    OutputScriptType = 2
-	OutputScriptType_PAYTOOPRETURN    OutputScriptType = 3
-	OutputScriptType_PAYTOWITNESS     OutputScriptType = 4
-	OutputScriptType_PAYTOP2SHWITNESS OutputScriptType = 5
-)
-
-var OutputScriptType_name = map[int32]string{
-	0: "PAYTOADDRESS",
-	1: "PAYTOSCRIPTHASH",
-	2: "PAYTOMULTISIG",
-	3: "PAYTOOPRETURN",
-	4: "PAYTOWITNESS",
-	5: "PAYTOP2SHWITNESS",
-}
-var OutputScriptType_value = map[string]int32{
-	"PAYTOADDRESS":     0,
-	"PAYTOSCRIPTHASH":  1,
-	"PAYTOMULTISIG":    2,
-	"PAYTOOPRETURN":    3,
-	"PAYTOWITNESS":     4,
-	"PAYTOP2SHWITNESS": 5,
-}
-
-func (x OutputScriptType) Enum() *OutputScriptType {
-	p := new(OutputScriptType)
-	*p = x
-	return p
-}
-func (x OutputScriptType) String() string {
-	return proto.EnumName(OutputScriptType_name, int32(x))
-}
-func (x *OutputScriptType) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(OutputScriptType_value, data, "OutputScriptType")
-	if err != nil {
-		return err
-	}
-	*x = OutputScriptType(value)
-	return nil
-}
-func (OutputScriptType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
-
-// *
-// Type of script which will be used for transaction output
-// @used_in TxInputType
-type InputScriptType int32
-
-const (
-	InputScriptType_SPENDADDRESS     InputScriptType = 0
-	InputScriptType_SPENDMULTISIG    InputScriptType = 1
-	InputScriptType_EXTERNAL         InputScriptType = 2
-	InputScriptType_SPENDWITNESS     InputScriptType = 3
-	InputScriptType_SPENDP2SHWITNESS InputScriptType = 4
-)
-
-var InputScriptType_name = map[int32]string{
-	0: "SPENDADDRESS",
-	1: "SPENDMULTISIG",
-	2: "EXTERNAL",
-	3: "SPENDWITNESS",
-	4: "SPENDP2SHWITNESS",
-}
-var InputScriptType_value = map[string]int32{
-	"SPENDADDRESS":     0,
-	"SPENDMULTISIG":    1,
-	"EXTERNAL":         2,
-	"SPENDWITNESS":     3,
-	"SPENDP2SHWITNESS": 4,
-}
-
-func (x InputScriptType) Enum() *InputScriptType {
-	p := new(InputScriptType)
-	*p = x
-	return p
-}
-func (x InputScriptType) String() string {
-	return proto.EnumName(InputScriptType_name, int32(x))
-}
-func (x *InputScriptType) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(InputScriptType_value, data, "InputScriptType")
-	if err != nil {
-		return err
-	}
-	*x = InputScriptType(value)
-	return nil
-}
-func (InputScriptType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
-
-// *
-// Type of information required by transaction signing process
-// @used_in TxRequest
-type RequestType int32
-
-const (
-	RequestType_TXINPUT     RequestType = 0
-	RequestType_TXOUTPUT    RequestType = 1
-	RequestType_TXMETA      RequestType = 2
-	RequestType_TXFINISHED  RequestType = 3
-	RequestType_TXEXTRADATA RequestType = 4
-)
-
-var RequestType_name = map[int32]string{
-	0: "TXINPUT",
-	1: "TXOUTPUT",
-	2: "TXMETA",
-	3: "TXFINISHED",
-	4: "TXEXTRADATA",
-}
-var RequestType_value = map[string]int32{
-	"TXINPUT":     0,
-	"TXOUTPUT":    1,
-	"TXMETA":      2,
-	"TXFINISHED":  3,
-	"TXEXTRADATA": 4,
-}
-
-func (x RequestType) Enum() *RequestType {
-	p := new(RequestType)
-	*p = x
-	return p
-}
-func (x RequestType) String() string {
-	return proto.EnumName(RequestType_name, int32(x))
-}
-func (x *RequestType) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(RequestType_value, data, "RequestType")
-	if err != nil {
-		return err
-	}
-	*x = RequestType(value)
-	return nil
-}
-func (RequestType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
-
-// *
-// Type of button request
-// @used_in ButtonRequest
-type ButtonRequestType int32
-
-const (
-	ButtonRequestType_ButtonRequest_Other            ButtonRequestType = 1
-	ButtonRequestType_ButtonRequest_FeeOverThreshold ButtonRequestType = 2
-	ButtonRequestType_ButtonRequest_ConfirmOutput    ButtonRequestType = 3
-	ButtonRequestType_ButtonRequest_ResetDevice      ButtonRequestType = 4
-	ButtonRequestType_ButtonRequest_ConfirmWord      ButtonRequestType = 5
-	ButtonRequestType_ButtonRequest_WipeDevice       ButtonRequestType = 6
-	ButtonRequestType_ButtonRequest_ProtectCall      ButtonRequestType = 7
-	ButtonRequestType_ButtonRequest_SignTx           ButtonRequestType = 8
-	ButtonRequestType_ButtonRequest_FirmwareCheck    ButtonRequestType = 9
-	ButtonRequestType_ButtonRequest_Address          ButtonRequestType = 10
-	ButtonRequestType_ButtonRequest_PublicKey        ButtonRequestType = 11
-)
-
-var ButtonRequestType_name = map[int32]string{
-	1:  "ButtonRequest_Other",
-	2:  "ButtonRequest_FeeOverThreshold",
-	3:  "ButtonRequest_ConfirmOutput",
-	4:  "ButtonRequest_ResetDevice",
-	5:  "ButtonRequest_ConfirmWord",
-	6:  "ButtonRequest_WipeDevice",
-	7:  "ButtonRequest_ProtectCall",
-	8:  "ButtonRequest_SignTx",
-	9:  "ButtonRequest_FirmwareCheck",
-	10: "ButtonRequest_Address",
-	11: "ButtonRequest_PublicKey",
-}
-var ButtonRequestType_value = map[string]int32{
-	"ButtonRequest_Other":            1,
-	"ButtonRequest_FeeOverThreshold": 2,
-	"ButtonRequest_ConfirmOutput":    3,
-	"ButtonRequest_ResetDevice":      4,
-	"ButtonRequest_ConfirmWord":      5,
-	"ButtonRequest_WipeDevice":       6,
-	"ButtonRequest_ProtectCall":      7,
-	"ButtonRequest_SignTx":           8,
-	"ButtonRequest_FirmwareCheck":    9,
-	"ButtonRequest_Address":          10,
-	"ButtonRequest_PublicKey":        11,
-}
-
-func (x ButtonRequestType) Enum() *ButtonRequestType {
-	p := new(ButtonRequestType)
-	*p = x
-	return p
-}
-func (x ButtonRequestType) String() string {
-	return proto.EnumName(ButtonRequestType_name, int32(x))
-}
-func (x *ButtonRequestType) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(ButtonRequestType_value, data, "ButtonRequestType")
-	if err != nil {
-		return err
-	}
-	*x = ButtonRequestType(value)
-	return nil
-}
-func (ButtonRequestType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
-
-// *
-// Type of PIN request
-// @used_in PinMatrixRequest
-type PinMatrixRequestType int32
-
-const (
-	PinMatrixRequestType_PinMatrixRequestType_Current   PinMatrixRequestType = 1
-	PinMatrixRequestType_PinMatrixRequestType_NewFirst  PinMatrixRequestType = 2
-	PinMatrixRequestType_PinMatrixRequestType_NewSecond PinMatrixRequestType = 3
-)
-
-var PinMatrixRequestType_name = map[int32]string{
-	1: "PinMatrixRequestType_Current",
-	2: "PinMatrixRequestType_NewFirst",
-	3: "PinMatrixRequestType_NewSecond",
-}
-var PinMatrixRequestType_value = map[string]int32{
-	"PinMatrixRequestType_Current":   1,
-	"PinMatrixRequestType_NewFirst":  2,
-	"PinMatrixRequestType_NewSecond": 3,
-}
-
-func (x PinMatrixRequestType) Enum() *PinMatrixRequestType {
-	p := new(PinMatrixRequestType)
-	*p = x
-	return p
-}
-func (x PinMatrixRequestType) String() string {
-	return proto.EnumName(PinMatrixRequestType_name, int32(x))
-}
-func (x *PinMatrixRequestType) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(PinMatrixRequestType_value, data, "PinMatrixRequestType")
-	if err != nil {
-		return err
-	}
-	*x = PinMatrixRequestType(value)
-	return nil
-}
-func (PinMatrixRequestType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
-
-// *
-// Type of recovery procedure. These should be used as bitmask, e.g.,
-// `RecoveryDeviceType_ScrambledWords | RecoveryDeviceType_Matrix`
-// listing every method supported by the host computer.
-//
-// Note that ScrambledWords must be supported by every implementation
-// for backward compatibility; there is no way to not support it.
-//
-// @used_in RecoveryDevice
-type RecoveryDeviceType int32
-
-const (
-	// use powers of two when extending this field
-	RecoveryDeviceType_RecoveryDeviceType_ScrambledWords RecoveryDeviceType = 0
-	RecoveryDeviceType_RecoveryDeviceType_Matrix         RecoveryDeviceType = 1
-)
-
-var RecoveryDeviceType_name = map[int32]string{
-	0: "RecoveryDeviceType_ScrambledWords",
-	1: "RecoveryDeviceType_Matrix",
-}
-var RecoveryDeviceType_value = map[string]int32{
-	"RecoveryDeviceType_ScrambledWords": 0,
-	"RecoveryDeviceType_Matrix":         1,
-}
-
-func (x RecoveryDeviceType) Enum() *RecoveryDeviceType {
-	p := new(RecoveryDeviceType)
-	*p = x
-	return p
-}
-func (x RecoveryDeviceType) String() string {
-	return proto.EnumName(RecoveryDeviceType_name, int32(x))
-}
-func (x *RecoveryDeviceType) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(RecoveryDeviceType_value, data, "RecoveryDeviceType")
-	if err != nil {
-		return err
-	}
-	*x = RecoveryDeviceType(value)
-	return nil
-}
-func (RecoveryDeviceType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
-
-// *
-// Type of Recovery Word request
-// @used_in WordRequest
-type WordRequestType int32
-
-const (
-	WordRequestType_WordRequestType_Plain   WordRequestType = 0
-	WordRequestType_WordRequestType_Matrix9 WordRequestType = 1
-	WordRequestType_WordRequestType_Matrix6 WordRequestType = 2
-)
-
-var WordRequestType_name = map[int32]string{
-	0: "WordRequestType_Plain",
-	1: "WordRequestType_Matrix9",
-	2: "WordRequestType_Matrix6",
-}
-var WordRequestType_value = map[string]int32{
-	"WordRequestType_Plain":   0,
-	"WordRequestType_Matrix9": 1,
-	"WordRequestType_Matrix6": 2,
-}
-
-func (x WordRequestType) Enum() *WordRequestType {
-	p := new(WordRequestType)
-	*p = x
-	return p
-}
-func (x WordRequestType) String() string {
-	return proto.EnumName(WordRequestType_name, int32(x))
-}
-func (x *WordRequestType) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(WordRequestType_value, data, "WordRequestType")
-	if err != nil {
-		return err
-	}
-	*x = WordRequestType(value)
-	return nil
-}
-func (WordRequestType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
-
-// *
-// Structure representing BIP32 (hierarchical deterministic) node
-// Used for imports of private key into the device and exporting public key out of device
-// @used_in PublicKey
-// @used_in LoadDevice
-// @used_in DebugLinkState
-// @used_in Storage
-type HDNodeType struct {
-	Depth            *uint32 `protobuf:"varint,1,req,name=depth" json:"depth,omitempty"`
-	Fingerprint      *uint32 `protobuf:"varint,2,req,name=fingerprint" json:"fingerprint,omitempty"`
-	ChildNum         *uint32 `protobuf:"varint,3,req,name=child_num,json=childNum" json:"child_num,omitempty"`
-	ChainCode        []byte  `protobuf:"bytes,4,req,name=chain_code,json=chainCode" json:"chain_code,omitempty"`
-	PrivateKey       []byte  `protobuf:"bytes,5,opt,name=private_key,json=privateKey" json:"private_key,omitempty"`
-	PublicKey        []byte  `protobuf:"bytes,6,opt,name=public_key,json=publicKey" json:"public_key,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *HDNodeType) Reset()                    { *m = HDNodeType{} }
-func (m *HDNodeType) String() string            { return proto.CompactTextString(m) }
-func (*HDNodeType) ProtoMessage()               {}
-func (*HDNodeType) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
-
-func (m *HDNodeType) GetDepth() uint32 {
-	if m != nil && m.Depth != nil {
-		return *m.Depth
-	}
-	return 0
-}
-
-func (m *HDNodeType) GetFingerprint() uint32 {
-	if m != nil && m.Fingerprint != nil {
-		return *m.Fingerprint
-	}
-	return 0
-}
-
-func (m *HDNodeType) GetChildNum() uint32 {
-	if m != nil && m.ChildNum != nil {
-		return *m.ChildNum
-	}
-	return 0
-}
-
-func (m *HDNodeType) GetChainCode() []byte {
-	if m != nil {
-		return m.ChainCode
-	}
-	return nil
-}
-
-func (m *HDNodeType) GetPrivateKey() []byte {
-	if m != nil {
-		return m.PrivateKey
-	}
-	return nil
-}
-
-func (m *HDNodeType) GetPublicKey() []byte {
-	if m != nil {
-		return m.PublicKey
-	}
-	return nil
-}
-
-type HDNodePathType struct {
-	Node             *HDNodeType `protobuf:"bytes,1,req,name=node" json:"node,omitempty"`
-	AddressN         []uint32    `protobuf:"varint,2,rep,name=address_n,json=addressN" json:"address_n,omitempty"`
-	XXX_unrecognized []byte      `json:"-"`
-}
-
-func (m *HDNodePathType) Reset()                    { *m = HDNodePathType{} }
-func (m *HDNodePathType) String() string            { return proto.CompactTextString(m) }
-func (*HDNodePathType) ProtoMessage()               {}
-func (*HDNodePathType) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
-
-func (m *HDNodePathType) GetNode() *HDNodeType {
-	if m != nil {
-		return m.Node
-	}
-	return nil
-}
-
-func (m *HDNodePathType) GetAddressN() []uint32 {
-	if m != nil {
-		return m.AddressN
-	}
-	return nil
-}
-
-// *
-// Structure representing Coin
-// @used_in Features
-type CoinType struct {
-	CoinName            *string `protobuf:"bytes,1,opt,name=coin_name,json=coinName" json:"coin_name,omitempty"`
-	CoinShortcut        *string `protobuf:"bytes,2,opt,name=coin_shortcut,json=coinShortcut" json:"coin_shortcut,omitempty"`
-	AddressType         *uint32 `protobuf:"varint,3,opt,name=address_type,json=addressType,def=0" json:"address_type,omitempty"`
-	MaxfeeKb            *uint64 `protobuf:"varint,4,opt,name=maxfee_kb,json=maxfeeKb" json:"maxfee_kb,omitempty"`
-	AddressTypeP2Sh     *uint32 `protobuf:"varint,5,opt,name=address_type_p2sh,json=addressTypeP2sh,def=5" json:"address_type_p2sh,omitempty"`
-	SignedMessageHeader *string `protobuf:"bytes,8,opt,name=signed_message_header,json=signedMessageHeader" json:"signed_message_header,omitempty"`
-	XpubMagic           *uint32 `protobuf:"varint,9,opt,name=xpub_magic,json=xpubMagic,def=76067358" json:"xpub_magic,omitempty"`
-	XprvMagic           *uint32 `protobuf:"varint,10,opt,name=xprv_magic,json=xprvMagic,def=76066276" json:"xprv_magic,omitempty"`
-	Segwit              *bool   `protobuf:"varint,11,opt,name=segwit" json:"segwit,omitempty"`
-	Forkid              *uint32 `protobuf:"varint,12,opt,name=forkid" json:"forkid,omitempty"`
-	XXX_unrecognized    []byte  `json:"-"`
-}
-
-func (m *CoinType) Reset()                    { *m = CoinType{} }
-func (m *CoinType) String() string            { return proto.CompactTextString(m) }
-func (*CoinType) ProtoMessage()               {}
-func (*CoinType) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
-
-const Default_CoinType_AddressType uint32 = 0
-const Default_CoinType_AddressTypeP2Sh uint32 = 5
-const Default_CoinType_XpubMagic uint32 = 76067358
-const Default_CoinType_XprvMagic uint32 = 76066276
-
-func (m *CoinType) GetCoinName() string {
-	if m != nil && m.CoinName != nil {
-		return *m.CoinName
-	}
-	return ""
-}
-
-func (m *CoinType) GetCoinShortcut() string {
-	if m != nil && m.CoinShortcut != nil {
-		return *m.CoinShortcut
-	}
-	return ""
-}
-
-func (m *CoinType) GetAddressType() uint32 {
-	if m != nil && m.AddressType != nil {
-		return *m.AddressType
-	}
-	return Default_CoinType_AddressType
-}
-
-func (m *CoinType) GetMaxfeeKb() uint64 {
-	if m != nil && m.MaxfeeKb != nil {
-		return *m.MaxfeeKb
-	}
-	return 0
-}
-
-func (m *CoinType) GetAddressTypeP2Sh() uint32 {
-	if m != nil && m.AddressTypeP2Sh != nil {
-		return *m.AddressTypeP2Sh
-	}
-	return Default_CoinType_AddressTypeP2Sh
-}
-
-func (m *CoinType) GetSignedMessageHeader() string {
-	if m != nil && m.SignedMessageHeader != nil {
-		return *m.SignedMessageHeader
-	}
-	return ""
-}
-
-func (m *CoinType) GetXpubMagic() uint32 {
-	if m != nil && m.XpubMagic != nil {
-		return *m.XpubMagic
-	}
-	return Default_CoinType_XpubMagic
-}
-
-func (m *CoinType) GetXprvMagic() uint32 {
-	if m != nil && m.XprvMagic != nil {
-		return *m.XprvMagic
-	}
-	return Default_CoinType_XprvMagic
-}
-
-func (m *CoinType) GetSegwit() bool {
-	if m != nil && m.Segwit != nil {
-		return *m.Segwit
-	}
-	return false
-}
-
-func (m *CoinType) GetForkid() uint32 {
-	if m != nil && m.Forkid != nil {
-		return *m.Forkid
-	}
-	return 0
-}
-
-// *
-// Type of redeem script used in input
-// @used_in TxInputType
-type MultisigRedeemScriptType struct {
-	Pubkeys          []*HDNodePathType `protobuf:"bytes,1,rep,name=pubkeys" json:"pubkeys,omitempty"`
-	Signatures       [][]byte          `protobuf:"bytes,2,rep,name=signatures" json:"signatures,omitempty"`
-	M                *uint32           `protobuf:"varint,3,opt,name=m" json:"m,omitempty"`
-	XXX_unrecognized []byte            `json:"-"`
-}
-
-func (m *MultisigRedeemScriptType) Reset()                    { *m = MultisigRedeemScriptType{} }
-func (m *MultisigRedeemScriptType) String() string            { return proto.CompactTextString(m) }
-func (*MultisigRedeemScriptType) ProtoMessage()               {}
-func (*MultisigRedeemScriptType) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
-
-func (m *MultisigRedeemScriptType) GetPubkeys() []*HDNodePathType {
-	if m != nil {
-		return m.Pubkeys
-	}
-	return nil
-}
-
-func (m *MultisigRedeemScriptType) GetSignatures() [][]byte {
-	if m != nil {
-		return m.Signatures
-	}
-	return nil
-}
-
-func (m *MultisigRedeemScriptType) GetM() uint32 {
-	if m != nil && m.M != nil {
-		return *m.M
-	}
-	return 0
-}
-
-// *
-// Structure representing transaction input
-// @used_in SimpleSignTx
-// @used_in TransactionType
-type TxInputType struct {
-	AddressN         []uint32                  `protobuf:"varint,1,rep,name=address_n,json=addressN" json:"address_n,omitempty"`
-	PrevHash         []byte                    `protobuf:"bytes,2,req,name=prev_hash,json=prevHash" json:"prev_hash,omitempty"`
-	PrevIndex        *uint32                   `protobuf:"varint,3,req,name=prev_index,json=prevIndex" json:"prev_index,omitempty"`
-	ScriptSig        []byte                    `protobuf:"bytes,4,opt,name=script_sig,json=scriptSig" json:"script_sig,omitempty"`
-	Sequence         *uint32                   `protobuf:"varint,5,opt,name=sequence,def=4294967295" json:"sequence,omitempty"`
-	ScriptType       *InputScriptType          `protobuf:"varint,6,opt,name=script_type,json=scriptType,enum=InputScriptType,def=0" json:"script_type,omitempty"`
-	Multisig         *MultisigRedeemScriptType `protobuf:"bytes,7,opt,name=multisig" json:"multisig,omitempty"`
-	Amount           *uint64                   `protobuf:"varint,8,opt,name=amount" json:"amount,omitempty"`
-	XXX_unrecognized []byte                    `json:"-"`
-}
-
-func (m *TxInputType) Reset()                    { *m = TxInputType{} }
-func (m *TxInputType) String() string            { return proto.CompactTextString(m) }
-func (*TxInputType) ProtoMessage()               {}
-func (*TxInputType) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
-
-const Default_TxInputType_Sequence uint32 = 4294967295
-const Default_TxInputType_ScriptType InputScriptType = InputScriptType_SPENDADDRESS
-
-func (m *TxInputType) GetAddressN() []uint32 {
-	if m != nil {
-		return m.AddressN
-	}
-	return nil
-}
-
-func (m *TxInputType) GetPrevHash() []byte {
-	if m != nil {
-		return m.PrevHash
-	}
-	return nil
-}
-
-func (m *TxInputType) GetPrevIndex() uint32 {
-	if m != nil && m.PrevIndex != nil {
-		return *m.PrevIndex
-	}
-	return 0
-}
-
-func (m *TxInputType) GetScriptSig() []byte {
-	if m != nil {
-		return m.ScriptSig
-	}
-	return nil
-}
-
-func (m *TxInputType) GetSequence() uint32 {
-	if m != nil && m.Sequence != nil {
-		return *m.Sequence
-	}
-	return Default_TxInputType_Sequence
-}
-
-func (m *TxInputType) GetScriptType() InputScriptType {
-	if m != nil && m.ScriptType != nil {
-		return *m.ScriptType
-	}
-	return Default_TxInputType_ScriptType
-}
-
-func (m *TxInputType) GetMultisig() *MultisigRedeemScriptType {
-	if m != nil {
-		return m.Multisig
-	}
-	return nil
-}
-
-func (m *TxInputType) GetAmount() uint64 {
-	if m != nil && m.Amount != nil {
-		return *m.Amount
-	}
-	return 0
-}
-
-// *
-// Structure representing transaction output
-// @used_in SimpleSignTx
-// @used_in TransactionType
-type TxOutputType struct {
-	Address          *string                   `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"`
-	AddressN         []uint32                  `protobuf:"varint,2,rep,name=address_n,json=addressN" json:"address_n,omitempty"`
-	Amount           *uint64                   `protobuf:"varint,3,req,name=amount" json:"amount,omitempty"`
-	ScriptType       *OutputScriptType         `protobuf:"varint,4,req,name=script_type,json=scriptType,enum=OutputScriptType" json:"script_type,omitempty"`
-	Multisig         *MultisigRedeemScriptType `protobuf:"bytes,5,opt,name=multisig" json:"multisig,omitempty"`
-	OpReturnData     []byte                    `protobuf:"bytes,6,opt,name=op_return_data,json=opReturnData" json:"op_return_data,omitempty"`
-	XXX_unrecognized []byte                    `json:"-"`
-}
-
-func (m *TxOutputType) Reset()                    { *m = TxOutputType{} }
-func (m *TxOutputType) String() string            { return proto.CompactTextString(m) }
-func (*TxOutputType) ProtoMessage()               {}
-func (*TxOutputType) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
-
-func (m *TxOutputType) GetAddress() string {
-	if m != nil && m.Address != nil {
-		return *m.Address
-	}
-	return ""
-}
-
-func (m *TxOutputType) GetAddressN() []uint32 {
-	if m != nil {
-		return m.AddressN
-	}
-	return nil
-}
-
-func (m *TxOutputType) GetAmount() uint64 {
-	if m != nil && m.Amount != nil {
-		return *m.Amount
-	}
-	return 0
-}
-
-func (m *TxOutputType) GetScriptType() OutputScriptType {
-	if m != nil && m.ScriptType != nil {
-		return *m.ScriptType
-	}
-	return OutputScriptType_PAYTOADDRESS
-}
-
-func (m *TxOutputType) GetMultisig() *MultisigRedeemScriptType {
-	if m != nil {
-		return m.Multisig
-	}
-	return nil
-}
-
-func (m *TxOutputType) GetOpReturnData() []byte {
-	if m != nil {
-		return m.OpReturnData
-	}
-	return nil
-}
-
-// *
-// Structure representing compiled transaction output
-// @used_in TransactionType
-type TxOutputBinType struct {
-	Amount           *uint64 `protobuf:"varint,1,req,name=amount" json:"amount,omitempty"`
-	ScriptPubkey     []byte  `protobuf:"bytes,2,req,name=script_pubkey,json=scriptPubkey" json:"script_pubkey,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *TxOutputBinType) Reset()                    { *m = TxOutputBinType{} }
-func (m *TxOutputBinType) String() string            { return proto.CompactTextString(m) }
-func (*TxOutputBinType) ProtoMessage()               {}
-func (*TxOutputBinType) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
-
-func (m *TxOutputBinType) GetAmount() uint64 {
-	if m != nil && m.Amount != nil {
-		return *m.Amount
-	}
-	return 0
-}
-
-func (m *TxOutputBinType) GetScriptPubkey() []byte {
-	if m != nil {
-		return m.ScriptPubkey
-	}
-	return nil
-}
-
-// *
-// Structure representing transaction
-// @used_in SimpleSignTx
-type TransactionType struct {
-	Version          *uint32            `protobuf:"varint,1,opt,name=version" json:"version,omitempty"`
-	Inputs           []*TxInputType     `protobuf:"bytes,2,rep,name=inputs" json:"inputs,omitempty"`
-	BinOutputs       []*TxOutputBinType `protobuf:"bytes,3,rep,name=bin_outputs,json=binOutputs" json:"bin_outputs,omitempty"`
-	Outputs          []*TxOutputType    `protobuf:"bytes,5,rep,name=outputs" json:"outputs,omitempty"`
-	LockTime         *uint32            `protobuf:"varint,4,opt,name=lock_time,json=lockTime" json:"lock_time,omitempty"`
-	InputsCnt        *uint32            `protobuf:"varint,6,opt,name=inputs_cnt,json=inputsCnt" json:"inputs_cnt,omitempty"`
-	OutputsCnt       *uint32            `protobuf:"varint,7,opt,name=outputs_cnt,json=outputsCnt" json:"outputs_cnt,omitempty"`
-	ExtraData        []byte             `protobuf:"bytes,8,opt,name=extra_data,json=extraData" json:"extra_data,omitempty"`
-	ExtraDataLen     *uint32            `protobuf:"varint,9,opt,name=extra_data_len,json=extraDataLen" json:"extra_data_len,omitempty"`
-	XXX_unrecognized []byte             `json:"-"`
-}
-
-func (m *TransactionType) Reset()                    { *m = TransactionType{} }
-func (m *TransactionType) String() string            { return proto.CompactTextString(m) }
-func (*TransactionType) ProtoMessage()               {}
-func (*TransactionType) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
-
-func (m *TransactionType) GetVersion() uint32 {
-	if m != nil && m.Version != nil {
-		return *m.Version
-	}
-	return 0
-}
-
-func (m *TransactionType) GetInputs() []*TxInputType {
-	if m != nil {
-		return m.Inputs
-	}
-	return nil
-}
-
-func (m *TransactionType) GetBinOutputs() []*TxOutputBinType {
-	if m != nil {
-		return m.BinOutputs
-	}
-	return nil
-}
-
-func (m *TransactionType) GetOutputs() []*TxOutputType {
-	if m != nil {
-		return m.Outputs
-	}
-	return nil
-}
-
-func (m *TransactionType) GetLockTime() uint32 {
-	if m != nil && m.LockTime != nil {
-		return *m.LockTime
-	}
-	return 0
-}
-
-func (m *TransactionType) GetInputsCnt() uint32 {
-	if m != nil && m.InputsCnt != nil {
-		return *m.InputsCnt
-	}
-	return 0
-}
-
-func (m *TransactionType) GetOutputsCnt() uint32 {
-	if m != nil && m.OutputsCnt != nil {
-		return *m.OutputsCnt
-	}
-	return 0
-}
-
-func (m *TransactionType) GetExtraData() []byte {
-	if m != nil {
-		return m.ExtraData
-	}
-	return nil
-}
-
-func (m *TransactionType) GetExtraDataLen() uint32 {
-	if m != nil && m.ExtraDataLen != nil {
-		return *m.ExtraDataLen
-	}
-	return 0
-}
-
-// *
-// Structure representing request details
-// @used_in TxRequest
-type TxRequestDetailsType struct {
-	RequestIndex     *uint32 `protobuf:"varint,1,opt,name=request_index,json=requestIndex" json:"request_index,omitempty"`
-	TxHash           []byte  `protobuf:"bytes,2,opt,name=tx_hash,json=txHash" json:"tx_hash,omitempty"`
-	ExtraDataLen     *uint32 `protobuf:"varint,3,opt,name=extra_data_len,json=extraDataLen" json:"extra_data_len,omitempty"`
-	ExtraDataOffset  *uint32 `protobuf:"varint,4,opt,name=extra_data_offset,json=extraDataOffset" json:"extra_data_offset,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *TxRequestDetailsType) Reset()                    { *m = TxRequestDetailsType{} }
-func (m *TxRequestDetailsType) String() string            { return proto.CompactTextString(m) }
-func (*TxRequestDetailsType) ProtoMessage()               {}
-func (*TxRequestDetailsType) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
-
-func (m *TxRequestDetailsType) GetRequestIndex() uint32 {
-	if m != nil && m.RequestIndex != nil {
-		return *m.RequestIndex
-	}
-	return 0
-}
-
-func (m *TxRequestDetailsType) GetTxHash() []byte {
-	if m != nil {
-		return m.TxHash
-	}
-	return nil
-}
-
-func (m *TxRequestDetailsType) GetExtraDataLen() uint32 {
-	if m != nil && m.ExtraDataLen != nil {
-		return *m.ExtraDataLen
-	}
-	return 0
-}
-
-func (m *TxRequestDetailsType) GetExtraDataOffset() uint32 {
-	if m != nil && m.ExtraDataOffset != nil {
-		return *m.ExtraDataOffset
-	}
-	return 0
-}
-
-// *
-// Structure representing serialized data
-// @used_in TxRequest
-type TxRequestSerializedType struct {
-	SignatureIndex   *uint32 `protobuf:"varint,1,opt,name=signature_index,json=signatureIndex" json:"signature_index,omitempty"`
-	Signature        []byte  `protobuf:"bytes,2,opt,name=signature" json:"signature,omitempty"`
-	SerializedTx     []byte  `protobuf:"bytes,3,opt,name=serialized_tx,json=serializedTx" json:"serialized_tx,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *TxRequestSerializedType) Reset()                    { *m = TxRequestSerializedType{} }
-func (m *TxRequestSerializedType) String() string            { return proto.CompactTextString(m) }
-func (*TxRequestSerializedType) ProtoMessage()               {}
-func (*TxRequestSerializedType) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }
-
-func (m *TxRequestSerializedType) GetSignatureIndex() uint32 {
-	if m != nil && m.SignatureIndex != nil {
-		return *m.SignatureIndex
-	}
-	return 0
-}
-
-func (m *TxRequestSerializedType) GetSignature() []byte {
-	if m != nil {
-		return m.Signature
-	}
-	return nil
-}
-
-func (m *TxRequestSerializedType) GetSerializedTx() []byte {
-	if m != nil {
-		return m.SerializedTx
-	}
-	return nil
-}
-
-// *
-// Structure representing identity data
-// @used_in IdentityType
-type IdentityType struct {
-	Proto            *string `protobuf:"bytes,1,opt,name=proto" json:"proto,omitempty"`
-	User             *string `protobuf:"bytes,2,opt,name=user" json:"user,omitempty"`
-	Host             *string `protobuf:"bytes,3,opt,name=host" json:"host,omitempty"`
-	Port             *string `protobuf:"bytes,4,opt,name=port" json:"port,omitempty"`
-	Path             *string `protobuf:"bytes,5,opt,name=path" json:"path,omitempty"`
-	Index            *uint32 `protobuf:"varint,6,opt,name=index,def=0" json:"index,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *IdentityType) Reset()                    { *m = IdentityType{} }
-func (m *IdentityType) String() string            { return proto.CompactTextString(m) }
-func (*IdentityType) ProtoMessage()               {}
-func (*IdentityType) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} }
-
-const Default_IdentityType_Index uint32 = 0
-
-func (m *IdentityType) GetProto() string {
-	if m != nil && m.Proto != nil {
-		return *m.Proto
-	}
-	return ""
-}
-
-func (m *IdentityType) GetUser() string {
-	if m != nil && m.User != nil {
-		return *m.User
-	}
-	return ""
-}
-
-func (m *IdentityType) GetHost() string {
-	if m != nil && m.Host != nil {
-		return *m.Host
-	}
-	return ""
-}
-
-func (m *IdentityType) GetPort() string {
-	if m != nil && m.Port != nil {
-		return *m.Port
-	}
-	return ""
-}
-
-func (m *IdentityType) GetPath() string {
-	if m != nil && m.Path != nil {
-		return *m.Path
-	}
-	return ""
-}
-
-func (m *IdentityType) GetIndex() uint32 {
-	if m != nil && m.Index != nil {
-		return *m.Index
-	}
-	return Default_IdentityType_Index
-}
-
-var E_WireIn = &proto.ExtensionDesc{
-	ExtendedType:  (*google_protobuf.EnumValueOptions)(nil),
-	ExtensionType: (*bool)(nil),
-	Field:         50002,
-	Name:          "wire_in",
-	Tag:           "varint,50002,opt,name=wire_in,json=wireIn",
-	Filename:      "types.proto",
-}
-
-var E_WireOut = &proto.ExtensionDesc{
-	ExtendedType:  (*google_protobuf.EnumValueOptions)(nil),
-	ExtensionType: (*bool)(nil),
-	Field:         50003,
-	Name:          "wire_out",
-	Tag:           "varint,50003,opt,name=wire_out,json=wireOut",
-	Filename:      "types.proto",
-}
-
-var E_WireDebugIn = &proto.ExtensionDesc{
-	ExtendedType:  (*google_protobuf.EnumValueOptions)(nil),
-	ExtensionType: (*bool)(nil),
-	Field:         50004,
-	Name:          "wire_debug_in",
-	Tag:           "varint,50004,opt,name=wire_debug_in,json=wireDebugIn",
-	Filename:      "types.proto",
-}
-
-var E_WireDebugOut = &proto.ExtensionDesc{
-	ExtendedType:  (*google_protobuf.EnumValueOptions)(nil),
-	ExtensionType: (*bool)(nil),
-	Field:         50005,
-	Name:          "wire_debug_out",
-	Tag:           "varint,50005,opt,name=wire_debug_out,json=wireDebugOut",
-	Filename:      "types.proto",
-}
-
-var E_WireTiny = &proto.ExtensionDesc{
-	ExtendedType:  (*google_protobuf.EnumValueOptions)(nil),
-	ExtensionType: (*bool)(nil),
-	Field:         50006,
-	Name:          "wire_tiny",
-	Tag:           "varint,50006,opt,name=wire_tiny,json=wireTiny",
-	Filename:      "types.proto",
-}
-
-var E_WireBootloader = &proto.ExtensionDesc{
-	ExtendedType:  (*google_protobuf.EnumValueOptions)(nil),
-	ExtensionType: (*bool)(nil),
-	Field:         50007,
-	Name:          "wire_bootloader",
-	Tag:           "varint,50007,opt,name=wire_bootloader,json=wireBootloader",
-	Filename:      "types.proto",
-}
-
-func init() {
-	proto.RegisterType((*HDNodeType)(nil), "HDNodeType")
-	proto.RegisterType((*HDNodePathType)(nil), "HDNodePathType")
-	proto.RegisterType((*CoinType)(nil), "CoinType")
-	proto.RegisterType((*MultisigRedeemScriptType)(nil), "MultisigRedeemScriptType")
-	proto.RegisterType((*TxInputType)(nil), "TxInputType")
-	proto.RegisterType((*TxOutputType)(nil), "TxOutputType")
-	proto.RegisterType((*TxOutputBinType)(nil), "TxOutputBinType")
-	proto.RegisterType((*TransactionType)(nil), "TransactionType")
-	proto.RegisterType((*TxRequestDetailsType)(nil), "TxRequestDetailsType")
-	proto.RegisterType((*TxRequestSerializedType)(nil), "TxRequestSerializedType")
-	proto.RegisterType((*IdentityType)(nil), "IdentityType")
-	proto.RegisterEnum("FailureType", FailureType_name, FailureType_value)
-	proto.RegisterEnum("OutputScriptType", OutputScriptType_name, OutputScriptType_value)
-	proto.RegisterEnum("InputScriptType", InputScriptType_name, InputScriptType_value)
-	proto.RegisterEnum("RequestType", RequestType_name, RequestType_value)
-	proto.RegisterEnum("ButtonRequestType", ButtonRequestType_name, ButtonRequestType_value)
-	proto.RegisterEnum("PinMatrixRequestType", PinMatrixRequestType_name, PinMatrixRequestType_value)
-	proto.RegisterEnum("RecoveryDeviceType", RecoveryDeviceType_name, RecoveryDeviceType_value)
-	proto.RegisterEnum("WordRequestType", WordRequestType_name, WordRequestType_value)
-	proto.RegisterExtension(E_WireIn)
-	proto.RegisterExtension(E_WireOut)
-	proto.RegisterExtension(E_WireDebugIn)
-	proto.RegisterExtension(E_WireDebugOut)
-	proto.RegisterExtension(E_WireTiny)
-	proto.RegisterExtension(E_WireBootloader)
-}
-
-func init() { proto.RegisterFile("types.proto", fileDescriptor0) }
-
-var fileDescriptor0 = []byte{
-	// 1899 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x57, 0xdb, 0x72, 0x1a, 0xc9,
-	0x19, 0xf6, 0x00, 0x92, 0xe0, 0x07, 0xc4, 0xa8, 0x7d, 0xd0, 0x78, 0x6d, 0xaf, 0x31, 0x76, 0x62,
-	0x45, 0x55, 0x61, 0x77, 0xc9, 0x5a, 0x8e, 0x55, 0xa9, 0x24, 0x3a, 0xa0, 0x15, 0x65, 0x0b, 0x51,
-	0xc3, 0x28, 0x56, 0x72, 0x33, 0x35, 0xcc, 0xb4, 0xa0, 0x4b, 0x43, 0x37, 0xe9, 0xe9, 0x91, 0xd1,
-	0xde, 0xe4, 0x2a, 0xc9, 0x55, 0x5e, 0x23, 0x6f, 0x91, 0xaa, 0xbc, 0x41, 0xaa, 0x36, 0xa7, 0xcb,
-	0xbc, 0x41, 0xae, 0xf2, 0x00, 0xa9, 0x3e, 0x0c, 0x02, 0xc9, 0xde, 0xd2, 0x1d, 0xfd, 0x7d, 0xff,
-	0xf9, 0xd0, 0x3d, 0x40, 0x59, 0x5c, 0x4e, 0x70, 0xd2, 0x9c, 0x70, 0x26, 0xd8, 0x67, 0xf5, 0x21,
-	0x63, 0xc3, 0x18, 0x7f, 0xa1, 0x4e, 0x83, 0xf4, 0xec, 0x8b, 0x08, 0x27, 0x21, 0x27, 0x13, 0xc1,
-	0xb8, 0x96, 0x68, 0xfc, 0xd5, 0x02, 0x38, 0xdc, 0xef, 0xb2, 0x08, 0x7b, 0x97, 0x13, 0x8c, 0xee,
-	0xc1, 0x52, 0x84, 0x27, 0x62, 0xe4, 0x58, 0xf5, 0xdc, 0x46, 0xd5, 0xd5, 0x07, 0x54, 0x87, 0xf2,
-	0x19, 0xa1, 0x43, 0xcc, 0x27, 0x9c, 0x50, 0xe1, 0xe4, 0x14, 0x37, 0x0f, 0xa1, 0x47, 0x50, 0x0a,
-	0x47, 0x24, 0x8e, 0x7c, 0x9a, 0x8e, 0x9d, 0xbc, 0xe2, 0x8b, 0x0a, 0xe8, 0xa6, 0x63, 0xf4, 0x04,
-	0x20, 0x1c, 0x05, 0x84, 0xfa, 0x21, 0x8b, 0xb0, 0x53, 0xa8, 0xe7, 0x36, 0x2a, 0x6e, 0x49, 0x21,
-	0x7b, 0x2c, 0xc2, 0xe8, 0x29, 0x94, 0x27, 0x9c, 0x5c, 0x04, 0x02, 0xfb, 0xe7, 0xf8, 0xd2, 0x59,
-	0xaa, 0x5b, 0x1b, 0x15, 0x17, 0x0c, 0xf4, 0x16, 0x5f, 0x4a, 0xfd, 0x49, 0x3a, 0x88, 0x49, 0xa8,
-	0xf8, 0x65, 0xc5, 0x97, 0x34, 0xf2, 0x16, 0x5f, 0x36, 0xba, 0xb0, 0xaa, 0x33, 0xe8, 0x05, 0x62,
-	0xa4, 0xb2, 0x78, 0x0a, 0x05, 0x2a, 0x5d, 0xc9, 0x24, 0xca, 0xad, 0x72, 0xf3, 0x2a, 0x41, 0x57,
-	0x11, 0x32, 0xdc, 0x20, 0x8a, 0x38, 0x4e, 0x12, 0x9f, 0x3a, 0xb9, 0x7a, 0x5e, 0x86, 0x6b, 0x80,
-	0x6e, 0xe3, 0x7f, 0x39, 0x28, 0xee, 0x31, 0x42, 0x95, 0x29, 0x99, 0x18, 0x23, 0xd4, 0xa7, 0xc1,
-	0x58, 0xda, 0xb3, 0x36, 0x4a, 0x6e, 0x51, 0x02, 0xdd, 0x60, 0x8c, 0xd1, 0x73, 0xa8, 0x2a, 0x32,
-	0x19, 0x31, 0x2e, 0xc2, 0x54, 0x56, 0x46, 0x0a, 0x54, 0x24, 0xd8, 0x37, 0x18, 0x7a, 0x01, 0x95,
-	0xcc, 0x97, 0x6c, 0x8d, 0x93, 0xaf, 0x5b, 0x1b, 0xd5, 0x6d, 0xeb, 0x4b, 0xb7, 0x6c, 0xe0, 0xcc,
-	0xcf, 0x38, 0x98, 0x9e, 0x61, 0xec, 0x9f, 0x0f, 0x9c, 0x42, 0xdd, 0xda, 0x28, 0xb8, 0x45, 0x0d,
-	0xbc, 0x1d, 0xa0, 0x1f, 0xc3, 0xda, 0xbc, 0x09, 0x7f, 0xd2, 0x4a, 0x46, 0xaa, 0x4e, 0xd5, 0x6d,
-	0xeb, 0x95, 0x5b, 0x9b, 0xb3, 0xd3, 0x6b, 0x25, 0x23, 0xd4, 0x82, 0xfb, 0x09, 0x19, 0x52, 0x1c,
-	0xf9, 0x63, 0x9c, 0x24, 0xc1, 0x10, 0xfb, 0x23, 0x1c, 0x44, 0x98, 0x3b, 0x45, 0x15, 0xde, 0x5d,
-	0x4d, 0x1e, 0x69, 0xee, 0x50, 0x51, 0xe8, 0x25, 0xc0, 0x74, 0x92, 0x0e, 0xfc, 0x71, 0x30, 0x24,
-	0xa1, 0x53, 0x52, 0xb6, 0x8b, 0xaf, 0xb7, 0xbe, 0xdc, 0x7a, 0xfd, 0x93, 0x57, 0x3f, 0x75, 0x4b,
-	0x92, 0x3b, 0x92, 0x94, 0x16, 0xe4, 0x17, 0x46, 0x10, 0xae, 0x04, 0xb7, 0x5a, 0xaf, 0xb7, 0xa4,
-	0x20, 0xbf, 0xd0, 0x82, 0x0f, 0x60, 0x39, 0xc1, 0xc3, 0x0f, 0x44, 0x38, 0xe5, 0xba, 0xb5, 0x51,
-	0x74, 0xcd, 0x49, 0xe2, 0x67, 0x8c, 0x9f, 0x93, 0xc8, 0xa9, 0x48, 0x65, 0xd7, 0x9c, 0x1a, 0x09,
-	0x38, 0x47, 0x69, 0x2c, 0x48, 0x42, 0x86, 0x2e, 0x8e, 0x30, 0x1e, 0xf7, 0xd5, 0xa4, 0xaa, 0xea,
-	0xfc, 0x08, 0x56, 0x26, 0xe9, 0xe0, 0x1c, 0x5f, 0x26, 0x8e, 0x55, 0xcf, 0x6f, 0x94, 0x5b, 0xb5,
-	0xe6, 0x62, 0xcb, 0xdd, 0x8c, 0x47, 0x9f, 0x03, 0xc8, 0xfc, 0x02, 0x91, 0x72, 0x9c, 0xa8, 0xde,
-	0x56, 0xdc, 0x39, 0x04, 0x55, 0xc0, 0x1a, 0xeb, 0x1e, 0xb8, 0xd6, 0xb8, 0xf1, 0x97, 0x1c, 0x94,
-	0xbd, 0x69, 0x87, 0x4e, 0x52, 0x91, 0xb5, 0xe1, 0x6a, 0x30, 0xac, 0xc5, 0xc1, 0x90, 0xe4, 0x84,
-	0xe3, 0x0b, 0x7f, 0x14, 0x24, 0x23, 0xb5, 0x04, 0x15, 0xb7, 0x28, 0x81, 0xc3, 0x20, 0x19, 0xa9,
-	0x21, 0x95, 0x24, 0xa1, 0x11, 0x9e, 0x9a, 0x15, 0x50, 0xe2, 0x1d, 0x09, 0x48, 0x5a, 0x6f, 0x9e,
-	0x9f, 0x90, 0xa1, 0x6a, 0x70, 0xc5, 0x2d, 0x69, 0xa4, 0x4f, 0x86, 0xe8, 0x87, 0x50, 0x4c, 0xf0,
-	0x6f, 0x53, 0x4c, 0x43, 0x6c, 0x1a, 0x0b, 0x5f, 0xb7, 0xde, 0x7c, 0xfd, 0x66, 0xeb, 0x75, 0xeb,
-	0xcd, 0x2b, 0x77, 0xc6, 0xa1, 0x5f, 0x40, 0xd9, 0x98, 0x51, 0xb3, 0x24, 0x77, 0x61, 0xb5, 0x65,
-	0x37, 0x55, 0x02, 0x57, 0xf5, 0xda, 0xae, 0xf4, 0x7b, 0xed, 0xee, 0xfe, 0xce, 0xfe, 0xbe, 0xdb,
-	0xee, 0xf7, 0x5d, 0xe3, 0x59, 0x25, 0xf8, 0x0a, 0x8a, 0x63, 0x53, 0x65, 0x67, 0xa5, 0x6e, 0x6d,
-	0x94, 0x5b, 0x0f, 0x9b, 0x9f, 0x2a, 0xbb, 0x3b, 0x13, 0x95, 0x4d, 0x0b, 0xc6, 0x2c, 0xa5, 0x42,
-	0xcd, 0x50, 0xc1, 0x35, 0xa7, 0xc6, 0x7f, 0x2d, 0xa8, 0x78, 0xd3, 0xe3, 0x54, 0x64, 0x05, 0x74,
-	0x60, 0xc5, 0xd4, 0xcb, 0x6c, 0x4b, 0x76, 0xfc, 0xde, 0x9d, 0x9b, 0xb3, 0x2f, 0x2b, 0x37, 0xb3,
-	0x8f, 0x5a, 0x8b, 0xf9, 0xca, 0xbb, 0x63, 0xb5, 0xb5, 0xd6, 0xd4, 0x0e, 0xe7, 0x22, 0xfd, 0x54,
-	0x8a, 0x4b, 0xb7, 0x4f, 0xf1, 0x05, 0xac, 0xb2, 0x89, 0xcf, 0xb1, 0x48, 0x39, 0xf5, 0xa3, 0x40,
-	0x04, 0xe6, 0xa6, 0xa9, 0xb0, 0x89, 0xab, 0xc0, 0xfd, 0x40, 0x04, 0x8d, 0x2e, 0xd4, 0xb2, 0x7c,
-	0x77, 0xcd, 0x15, 0x71, 0x15, 0xbb, 0xb5, 0x10, 0xfb, 0x73, 0xa8, 0x9a, 0xd8, 0xf5, 0x6c, 0x9a,
-	0x91, 0xa9, 0x68, 0xb0, 0xa7, 0xb0, 0xc6, 0xdf, 0x72, 0x50, 0xf3, 0x78, 0x40, 0x93, 0x20, 0x14,
-	0x84, 0xd1, 0xac, 0x86, 0x17, 0x98, 0x27, 0x84, 0x51, 0x55, 0xc3, 0xaa, 0x9b, 0x1d, 0xd1, 0x0b,
-	0x58, 0x26, 0xb2, 0xd5, 0x7a, 0xb0, 0xcb, 0xad, 0x4a, 0x73, 0x6e, 0x78, 0x5d, 0xc3, 0xa1, 0xaf,
-	0xa0, 0x3c, 0x20, 0xd4, 0x67, 0x2a, 0xca, 0xc4, 0xc9, 0x2b, 0x51, 0xbb, 0x79, 0x2d, 0x6e, 0x17,
-	0x06, 0x84, 0x6a, 0x24, 0x41, 0x2f, 0x61, 0x25, 0x13, 0x5f, 0x52, 0xe2, 0xd5, 0xe6, 0x7c, 0x5b,
-	0xdd, 0x8c, 0x95, 0x5d, 0x8c, 0x59, 0x78, 0xee, 0x0b, 0x32, 0xc6, 0x6a, 0x8c, 0xab, 0x6e, 0x51,
-	0x02, 0x1e, 0x19, 0x63, 0x39, 0xe4, 0x3a, 0x04, 0x3f, 0xa4, 0x42, 0x95, 0xaf, 0xea, 0x96, 0x34,
-	0xb2, 0x47, 0x85, 0xbc, 0xe8, 0x8d, 0x19, 0xc5, 0xaf, 0x28, 0x1e, 0x0c, 0x24, 0x05, 0x9e, 0x00,
-	0xe0, 0xa9, 0xe0, 0x81, 0x2e, 0x7f, 0x51, 0x2f, 0x89, 0x42, 0x64, 0xed, 0x65, 0x87, 0xae, 0x68,
-	0x3f, 0xc6, 0x54, 0xdf, 0x53, 0x6e, 0x65, 0x26, 0xf2, 0x0e, 0xd3, 0xc6, 0x9f, 0x2d, 0xb8, 0xe7,
-	0x4d, 0x5d, 0xb9, 0x31, 0x89, 0xd8, 0xc7, 0x22, 0x20, 0xb1, 0xbe, 0x62, 0x9f, 0x43, 0x95, 0x6b,
-	0xd4, 0x2c, 0xa9, 0x2e, 0x6e, 0xc5, 0x80, 0x7a, 0x4f, 0xd7, 0x61, 0x45, 0x4c, 0xb3, 0x0d, 0x97,
-	0xfe, 0x97, 0xc5, 0x54, 0xed, 0xf7, 0x4d, 0xe7, 0xf9, 0x9b, 0xce, 0xd1, 0x26, 0xac, 0xcd, 0x49,
-	0xb1, 0xb3, 0xb3, 0x04, 0x0b, 0x53, 0xa6, 0xda, 0x4c, 0xf0, 0x58, 0xc1, 0x8d, 0xdf, 0x5b, 0xb0,
-	0x3e, 0x0b, 0xb4, 0x8f, 0x39, 0x09, 0x62, 0xf2, 0x2d, 0x8e, 0x54, 0xac, 0x2f, 0xa1, 0x36, 0xbb,
-	0xb3, 0x16, 0xa2, 0x5d, 0x9d, 0xc1, 0x3a, 0xde, 0xc7, 0x50, 0x9a, 0x21, 0x26, 0xe2, 0x2b, 0x40,
-	0x8d, 0xe0, 0xcc, 0xb0, 0x2f, 0xa6, 0x2a, 0x66, 0x39, 0x82, 0x57, 0xde, 0xa6, 0x8d, 0x3f, 0x59,
-	0x50, 0xe9, 0x44, 0x98, 0x0a, 0x22, 0x2e, 0xb3, 0x8f, 0x00, 0xf5, 0x71, 0x60, 0x36, 0x58, 0x1f,
-	0x10, 0x82, 0x42, 0x9a, 0x60, 0x6e, 0xde, 0x38, 0xf5, 0x5b, 0x62, 0x23, 0x96, 0x08, 0x65, 0xb6,
-	0xe4, 0xaa, 0xdf, 0x12, 0x9b, 0x30, 0xae, 0xb3, 0x2e, 0xb9, 0xea, 0xb7, 0xc2, 0x02, 0xa1, 0xdf,
-	0x2c, 0x89, 0x05, 0x62, 0x84, 0xd6, 0x61, 0x49, 0x27, 0xb6, 0x9c, 0x3d, 0x88, 0xfa, 0xbc, 0xf9,
-	0x5d, 0x0e, 0xca, 0x07, 0x01, 0x89, 0x53, 0xae, 0xbf, 0x49, 0x9e, 0xc0, 0x43, 0x73, 0xf4, 0x4f,
-	0x28, 0x9e, 0x4e, 0x70, 0x28, 0x66, 0xaf, 0x97, 0x6d, 0xa1, 0xcf, 0xe0, 0x41, 0x46, 0xef, 0xa6,
-	0x42, 0x30, 0xda, 0x36, 0x22, 0x76, 0x0e, 0xdd, 0x87, 0xb5, 0x8c, 0x93, 0x85, 0x6f, 0x73, 0xce,
-	0xb8, 0x9d, 0x47, 0x8f, 0x60, 0x3d, 0x83, 0x77, 0xd4, 0xda, 0xed, 0x05, 0x34, 0xc4, 0x71, 0x8c,
-	0x23, 0xbb, 0x80, 0xd6, 0xe1, 0x6e, 0x46, 0xf6, 0xc8, 0x95, 0xb1, 0x25, 0xe4, 0xc0, 0xbd, 0x39,
-	0xe2, 0x4a, 0x65, 0x19, 0x3d, 0x00, 0x34, 0xc7, 0x74, 0xe8, 0x45, 0x10, 0x93, 0xc8, 0x5e, 0x41,
-	0x8f, 0xc1, 0xc9, 0x70, 0x03, 0xf6, 0xb3, 0xd6, 0xd8, 0xc5, 0x05, 0x7b, 0x9c, 0x85, 0x38, 0x49,
-	0x74, 0x7c, 0xa5, 0xf9, 0x94, 0xba, 0x4c, 0xb4, 0x29, 0x4b, 0x87, 0xa3, 0x83, 0x94, 0x46, 0x89,
-	0x0d, 0xd7, 0xb8, 0x0e, 0x25, 0xc2, 0x74, 0xd2, 0x2e, 0xa3, 0x87, 0x70, 0x3f, 0xe3, 0x0e, 0x08,
-	0x1f, 0x7f, 0x08, 0x38, 0xd6, 0x26, 0xc3, 0xcd, 0x3f, 0x5a, 0x60, 0x5f, 0xbf, 0x35, 0x91, 0x0d,
-	0x95, 0xde, 0xce, 0xaf, 0xbd, 0x63, 0xf3, 0x50, 0xd8, 0x77, 0xd0, 0x5d, 0xa8, 0x29, 0xa4, 0xbf,
-	0xe7, 0x76, 0x7a, 0xde, 0xe1, 0x4e, 0xff, 0xd0, 0xb6, 0xd0, 0x1a, 0x54, 0x15, 0x78, 0x74, 0xf2,
-	0xce, 0xeb, 0xf4, 0x3b, 0xdf, 0xd8, 0xb9, 0x19, 0x74, 0xdc, 0x73, 0xdb, 0xde, 0x89, 0xdb, 0xb5,
-	0xf3, 0x33, 0x63, 0xef, 0x3b, 0x5e, 0x57, 0x1a, 0x2b, 0xa0, 0x7b, 0x60, 0x2b, 0xa4, 0xd7, 0xea,
-	0x1f, 0x66, 0xe8, 0xd2, 0x66, 0x0c, 0xb5, 0x6b, 0xcf, 0x95, 0x54, 0x9d, 0x7f, 0xb0, 0xec, 0x3b,
-	0xd2, 0xbe, 0x42, 0x66, 0x2e, 0x2d, 0x54, 0x81, 0x62, 0xfb, 0xd4, 0x6b, 0xbb, 0xdd, 0x9d, 0x77,
-	0x76, 0x6e, 0xa6, 0x92, 0xd9, 0xcd, 0x4b, 0x6f, 0x0a, 0x99, 0xf7, 0x56, 0xd8, 0x3c, 0x81, 0xb2,
-	0xd9, 0x30, 0xe5, 0xa9, 0x0c, 0x2b, 0xde, 0x69, 0xa7, 0xdb, 0x3b, 0xf1, 0xec, 0x3b, 0xd2, 0xa2,
-	0x77, 0x7a, 0x7c, 0xe2, 0xc9, 0x93, 0x85, 0x00, 0x96, 0xbd, 0xd3, 0xa3, 0xb6, 0xb7, 0x63, 0xe7,
-	0xd0, 0x2a, 0x80, 0x77, 0x7a, 0xd0, 0xe9, 0x76, 0xfa, 0x87, 0xed, 0x7d, 0x3b, 0x8f, 0x6a, 0x50,
-	0xf6, 0x4e, 0xdb, 0xa7, 0x9e, 0xbb, 0xb3, 0xbf, 0xe3, 0xed, 0xd8, 0x85, 0xcd, 0xff, 0xe4, 0x60,
-	0x4d, 0x4f, 0xdb, 0xbc, 0xf5, 0x75, 0xb8, 0xbb, 0x00, 0xfa, 0xc7, 0x62, 0x84, 0xb9, 0x6d, 0xa1,
-	0x06, 0x7c, 0xbe, 0x48, 0x1c, 0x60, 0x7c, 0x7c, 0x81, 0xb9, 0x37, 0xe2, 0x38, 0x19, 0xb1, 0x58,
-	0xce, 0xea, 0x53, 0x78, 0xb4, 0x28, 0xb3, 0xc7, 0xe8, 0x19, 0xe1, 0x63, 0xdd, 0x35, 0x3b, 0x2f,
-	0xf7, 0x60, 0x51, 0xc0, 0xc5, 0x09, 0x16, 0xfb, 0xf8, 0x82, 0x84, 0xd8, 0x2e, 0xdc, 0xa4, 0x8d,
-	0xfe, 0x7b, 0xc6, 0xe5, 0xf4, 0x3e, 0x06, 0x67, 0x91, 0x7e, 0x4f, 0x26, 0xd8, 0x28, 0x2f, 0xdf,
-	0x54, 0xee, 0x71, 0x26, 0x70, 0x28, 0xf6, 0x82, 0x38, 0xb6, 0x57, 0xe4, 0xa8, 0x2e, 0xd2, 0x72,
-	0x8e, 0xbd, 0xa9, 0x5d, 0xbc, 0x19, 0x75, 0x36, 0x78, 0x7b, 0x23, 0x1c, 0x9e, 0xdb, 0x25, 0x39,
-	0x93, 0x8b, 0x02, 0x3b, 0xfa, 0xcd, 0xb7, 0x41, 0xae, 0xe1, 0x35, 0xa7, 0xd9, 0x37, 0xbd, 0x5d,
-	0xde, 0xfc, 0x1d, 0xdc, 0xeb, 0x11, 0x7a, 0x14, 0x08, 0x4e, 0xa6, 0xf3, 0x35, 0xae, 0xc3, 0xe3,
-	0x8f, 0xe1, 0xfe, 0x5e, 0xca, 0x39, 0xa6, 0xc2, 0xb6, 0xd0, 0x33, 0x78, 0xf2, 0x51, 0x89, 0x2e,
-	0xfe, 0x70, 0x40, 0x78, 0x22, 0xec, 0x9c, 0xec, 0xc7, 0xa7, 0x44, 0xfa, 0x38, 0x64, 0x34, 0xb2,
-	0xf3, 0x9b, 0xbf, 0x01, 0xe4, 0xe2, 0x90, 0x5d, 0x60, 0x7e, 0xa9, 0xcb, 0xa4, 0xdc, 0xff, 0x00,
-	0x9e, 0xdd, 0x44, 0xfd, 0x7e, 0xc8, 0x83, 0xf1, 0x20, 0xc6, 0x91, 0x2c, 0x76, 0x62, 0xdf, 0x91,
-	0xf5, 0xfc, 0x88, 0x98, 0x76, 0x68, 0x5b, 0x9b, 0x67, 0x50, 0x93, 0x92, 0xf3, 0x79, 0x3d, 0x84,
-	0xfb, 0xd7, 0x20, 0xbf, 0x17, 0x07, 0x84, 0xda, 0x77, 0x64, 0x9d, 0xae, 0x53, 0xda, 0xd2, 0x1b,
-	0xdb, 0xfa, 0x34, 0xb9, 0x65, 0xe7, 0xb6, 0x7f, 0x06, 0x2b, 0x1f, 0x88, 0x7a, 0x41, 0xd0, 0xb3,
-	0xa6, 0xfe, 0x2f, 0xd8, 0xcc, 0xfe, 0x0b, 0x36, 0xdb, 0x34, 0x1d, 0xff, 0x2a, 0x88, 0x53, 0x7c,
-	0x3c, 0x91, 0x77, 0x60, 0xe2, 0x7c, 0xf7, 0x87, 0xbc, 0xfe, 0x52, 0x97, 0x3a, 0x1d, 0xba, 0xfd,
-	0x73, 0x28, 0x2a, 0x6d, 0x96, 0x8a, 0xdb, 0xa8, 0xff, 0xdd, 0xa8, 0x2b, 0x97, 0xc7, 0xa9, 0xd8,
-	0xfe, 0x06, 0xaa, 0x4a, 0x3f, 0xc2, 0x83, 0x74, 0x78, 0xcb, 0x18, 0xfe, 0x61, 0x8c, 0x94, 0xa5,
-	0xe6, 0xbe, 0x54, 0xec, 0xd0, 0xed, 0x0e, 0xac, 0xce, 0x19, 0xba, 0x65, 0x38, 0xff, 0x34, 0x96,
-	0x2a, 0x33, 0x4b, 0x32, 0xa6, 0x5f, 0x42, 0x49, 0x99, 0x12, 0x84, 0x5e, 0xde, 0xc6, 0xca, 0xbf,
-	0x8c, 0x15, 0x55, 0x09, 0x8f, 0xd0, 0xcb, 0xed, 0x77, 0x50, 0x53, 0x16, 0x06, 0x8c, 0x89, 0x98,
-	0xa9, 0x3f, 0x4f, 0xb7, 0xb0, 0xf3, 0x6f, 0x63, 0x47, 0x25, 0xb2, 0x3b, 0x53, 0xdd, 0xfd, 0x0a,
-	0x9e, 0x87, 0x6c, 0xdc, 0x4c, 0x02, 0xc1, 0x92, 0x11, 0x89, 0x83, 0x41, 0xd2, 0x14, 0x1c, 0x7f,
-	0xcb, 0x78, 0x33, 0x26, 0x83, 0x99, 0xbd, 0x5d, 0xf0, 0x14, 0x28, 0xdb, 0xfb, 0xff, 0x00, 0x00,
-	0x00, 0xff, 0xff, 0x70, 0x88, 0xcd, 0x71, 0xe2, 0x0f, 0x00, 0x00,
-}
diff --git a/accounts/usbwallet/internal/trezor/types.proto b/accounts/usbwallet/internal/trezor/types.proto
deleted file mode 100644
index acbe79e3f..000000000
--- a/accounts/usbwallet/internal/trezor/types.proto
+++ /dev/null
@@ -1,278 +0,0 @@
-// This file originates from the SatoshiLabs Trezor `common` repository at:
-//   https://github.com/trezor/trezor-common/blob/master/protob/types.proto
-// dated 28.07.2017, commit dd8ec3231fb5f7992360aff9bdfe30bb58130f4b.
-
-syntax = "proto2";
-
-/**
- * Types for TREZOR communication
- *
- * @author	Marek Palatinus <slush@satoshilabs.com>
- * @version	1.2
- */
-
-// Sugar for easier handling in Java
-option java_package = "com.satoshilabs.trezor.lib.protobuf";
-option java_outer_classname = "TrezorType";
-
-import "google/protobuf/descriptor.proto";
-
-/**
- * Options for specifying message direction and type of wire (normal/debug)
- */
-extend google.protobuf.EnumValueOptions {
-	optional bool wire_in = 50002;		// message can be transmitted via wire from PC to TREZOR
-	optional bool wire_out = 50003;		// message can be transmitted via wire from TREZOR to PC
-	optional bool wire_debug_in = 50004;	// message can be transmitted via debug wire from PC to TREZOR
-	optional bool wire_debug_out = 50005;	// message can be transmitted via debug wire from TREZOR to PC
-	optional bool wire_tiny = 50006;	// message is handled by TREZOR when the USB stack is in tiny mode
-	optional bool wire_bootloader = 50007;  // message is only handled by TREZOR Bootloader
-}
-
-/**
- * Type of failures returned by Failure message
- * @used_in Failure
- */
-enum FailureType {
-	Failure_UnexpectedMessage = 1;
-	Failure_ButtonExpected = 2;
-	Failure_DataError = 3;
-	Failure_ActionCancelled = 4;
-	Failure_PinExpected = 5;
-	Failure_PinCancelled = 6;
-	Failure_PinInvalid = 7;
-	Failure_InvalidSignature = 8;
-	Failure_ProcessError = 9;
-	Failure_NotEnoughFunds = 10;
-	Failure_NotInitialized = 11;
-	Failure_FirmwareError = 99;
-}
-
-/**
- * Type of script which will be used for transaction output
- * @used_in TxOutputType
- */
-enum OutputScriptType {
-	PAYTOADDRESS = 0;	// used for all addresses (bitcoin, p2sh, witness)
-	PAYTOSCRIPTHASH = 1;	// p2sh address (deprecated; use PAYTOADDRESS)
-	PAYTOMULTISIG = 2;	// only for change output
-	PAYTOOPRETURN = 3;	// op_return
-	PAYTOWITNESS = 4;	// only for change output
-	PAYTOP2SHWITNESS = 5;	// only for change output
-}
-
-/**
- * Type of script which will be used for transaction output
- * @used_in TxInputType
- */
-enum InputScriptType {
-	SPENDADDRESS = 0;		// standard p2pkh address
-	SPENDMULTISIG = 1;		// p2sh multisig address
-	EXTERNAL = 2;			// reserved for external inputs (coinjoin)
-	SPENDWITNESS = 3;		// native segwit
-	SPENDP2SHWITNESS = 4;		// segwit over p2sh (backward compatible)
-}
-
-/**
- * Type of information required by transaction signing process
- * @used_in TxRequest
- */
-enum RequestType {
-	TXINPUT = 0;
-	TXOUTPUT = 1;
-	TXMETA = 2;
-	TXFINISHED = 3;
-	TXEXTRADATA = 4;
-}
-
-/**
- * Type of button request
- * @used_in ButtonRequest
- */
-enum ButtonRequestType {
-	ButtonRequest_Other = 1;
-	ButtonRequest_FeeOverThreshold = 2;
-	ButtonRequest_ConfirmOutput = 3;
-	ButtonRequest_ResetDevice = 4;
-	ButtonRequest_ConfirmWord = 5;
-	ButtonRequest_WipeDevice = 6;
-	ButtonRequest_ProtectCall = 7;
-	ButtonRequest_SignTx = 8;
-	ButtonRequest_FirmwareCheck = 9;
-	ButtonRequest_Address = 10;
-	ButtonRequest_PublicKey = 11;
-}
-
-/**
- * Type of PIN request
- * @used_in PinMatrixRequest
- */
-enum PinMatrixRequestType {
-	PinMatrixRequestType_Current = 1;
-	PinMatrixRequestType_NewFirst = 2;
-	PinMatrixRequestType_NewSecond = 3;
-}
-
-/**
- * Type of recovery procedure. These should be used as bitmask, e.g.,
- * `RecoveryDeviceType_ScrambledWords | RecoveryDeviceType_Matrix`
- * listing every method supported by the host computer.
- *
- * Note that ScrambledWords must be supported by every implementation
- * for backward compatibility; there is no way to not support it.
- *
- * @used_in RecoveryDevice
- */
-enum RecoveryDeviceType {
-	// use powers of two when extending this field
-	RecoveryDeviceType_ScrambledWords = 0;		// words in scrambled order
-	RecoveryDeviceType_Matrix = 1;				// matrix recovery type
-}
-
-/**
- * Type of Recovery Word request
- * @used_in WordRequest
- */
-enum WordRequestType {
-	WordRequestType_Plain = 0;
-	WordRequestType_Matrix9 = 1;
-	WordRequestType_Matrix6 = 2;
-}
-
-/**
- * Structure representing BIP32 (hierarchical deterministic) node
- * Used for imports of private key into the device and exporting public key out of device
- * @used_in PublicKey
- * @used_in LoadDevice
- * @used_in DebugLinkState
- * @used_in Storage
- */
-message HDNodeType {
-	required uint32 depth = 1;
-	required uint32 fingerprint = 2;
-	required uint32 child_num = 3;
-	required bytes chain_code = 4;
-	optional bytes private_key = 5;
-	optional bytes public_key = 6;
-}
-
-message HDNodePathType {
-	required HDNodeType node = 1;						// BIP-32 node in deserialized form
-	repeated uint32 address_n = 2;						// BIP-32 path to derive the key from node
-}
-
-/**
- * Structure representing Coin
- * @used_in Features
- */
-message CoinType {
-	optional string coin_name = 1;
-	optional string coin_shortcut = 2;
-	optional uint32 address_type = 3 [default=0];
-	optional uint64 maxfee_kb = 4;
-	optional uint32 address_type_p2sh = 5 [default=5];
-	optional string signed_message_header = 8;
-	optional uint32 xpub_magic = 9 [default=76067358];	// default=0x0488b21e
-	optional uint32 xprv_magic = 10 [default=76066276];	// default=0x0488ade4
-	optional bool segwit = 11;
-	optional uint32 forkid = 12;
-}
-
-/**
- * Type of redeem script used in input
- * @used_in TxInputType
- */
-message MultisigRedeemScriptType {
-	repeated HDNodePathType pubkeys = 1;					// pubkeys from multisig address (sorted lexicographically)
-	repeated bytes signatures = 2;						// existing signatures for partially signed input
-	optional uint32 m = 3;							// "m" from n, how many valid signatures is necessary for spending
-}
-
-/**
- * Structure representing transaction input
- * @used_in SimpleSignTx
- * @used_in TransactionType
- */
-message TxInputType {
-	repeated uint32 address_n = 1;						// BIP-32 path to derive the key from master node
-	required bytes prev_hash = 2;						// hash of previous transaction output to spend by this input
-	required uint32 prev_index = 3;						// index of previous output to spend
-	optional bytes script_sig = 4;						// script signature, unset for tx to sign
-	optional uint32 sequence = 5 [default=4294967295];			// sequence (default=0xffffffff)
-	optional InputScriptType script_type = 6 [default=SPENDADDRESS];	// defines template of input script
-	optional MultisigRedeemScriptType multisig = 7;				// Filled if input is going to spend multisig tx
-	optional uint64 amount = 8;						// amount of previous transaction output (for segwit only)
-}
-
-/**
- * Structure representing transaction output
- * @used_in SimpleSignTx
- * @used_in TransactionType
- */
-message TxOutputType {
-	optional string address = 1;			// target coin address in Base58 encoding
-	repeated uint32 address_n = 2;			// BIP-32 path to derive the key from master node; has higher priority than "address"
-	required uint64 amount = 3;			// amount to spend in satoshis
-	required OutputScriptType script_type = 4;	// output script type
-	optional MultisigRedeemScriptType multisig = 5; // defines multisig address; script_type must be PAYTOMULTISIG
-	optional bytes op_return_data = 6;		// defines op_return data; script_type must be PAYTOOPRETURN, amount must be 0
-}
-
-/**
- * Structure representing compiled transaction output
- * @used_in TransactionType
- */
-message TxOutputBinType {
-	required uint64 amount = 1;
-	required bytes script_pubkey = 2;
-}
-
-/**
- * Structure representing transaction
- * @used_in SimpleSignTx
- */
-message TransactionType {
-	optional uint32 version = 1;
-	repeated TxInputType inputs = 2;
-	repeated TxOutputBinType bin_outputs = 3;
-	repeated TxOutputType outputs = 5;
-	optional uint32 lock_time = 4;
-	optional uint32 inputs_cnt = 6;
-	optional uint32 outputs_cnt = 7;
-	optional bytes extra_data = 8;
-	optional uint32 extra_data_len = 9;
-}
-
-/**
- * Structure representing request details
- * @used_in TxRequest
- */
-message TxRequestDetailsType {
-	optional uint32 request_index = 1;	// device expects TxAck message from the computer
-	optional bytes tx_hash = 2;		// tx_hash of requested transaction
-	optional uint32 extra_data_len = 3;	// length of requested extra data
-	optional uint32 extra_data_offset = 4;	// offset of requested extra data
-}
-
-/**
- * Structure representing serialized data
- * @used_in TxRequest
- */
-message TxRequestSerializedType {
-	optional uint32 signature_index = 1;	// 'signature' field contains signed input of this index
-	optional bytes signature = 2;		// signature of the signature_index input
-	optional bytes serialized_tx = 3;	// part of serialized and signed transaction
-}
-
-/**
- * Structure representing identity data
- * @used_in IdentityType
- */
-message IdentityType {
-	optional string proto = 1;			// proto part of URI
-	optional string user = 2;			// user part of URI
-	optional string host = 3;			// host part of URI
-	optional string port = 4;			// port part of URI
-	optional string path = 5;			// path part of URI
-	optional uint32 index = 6 [default=0];		// identity index
-}
diff --git a/accounts/usbwallet/ledger.go b/accounts/usbwallet/ledger.go
index 6b93b6e17..e896332bb 100644
--- a/accounts/usbwallet/ledger.go
+++ b/accounts/usbwallet/ledger.go
@@ -28,12 +28,13 @@ import (
 	"io"
 	"math/big"
 
+	"github.com/truechain/truechain-engineering-code/accounts"
 	"github.com/truechain/truechain-engineering-code/common"
 	"github.com/truechain/truechain-engineering-code/common/hexutil"
+	"github.com/truechain/truechain-engineering-code/core/types"
+	"github.com/truechain/truechain-engineering-code/crypto"
 	"github.com/truechain/truechain-engineering-code/log"
 	"github.com/truechain/truechain-engineering-code/rlp"
-	"github.com/truechain/truechain-engineering-code/accounts"
-	"github.com/truechain/truechain-engineering-code/core/types"
 )
 
 // ledgerOpcode is an enumeration encoding the supported Ledger opcodes.
@@ -51,8 +52,10 @@ const (
 	ledgerOpRetrieveAddress  ledgerOpcode = 0x02 // Returns the public key and Ethereum address for a given BIP 32 path
 	ledgerOpSignTransaction  ledgerOpcode = 0x04 // Signs an Ethereum transaction after having the user validate the parameters
 	ledgerOpGetConfiguration ledgerOpcode = 0x06 // Returns specific wallet application configuration
+	ledgerOpSignTypedMessage ledgerOpcode = 0x0c // Signs an Ethereum message following the EIP 712 specification
 
 	ledgerP1DirectlyFetchAddress    ledgerParam1 = 0x00 // Return address directly from the wallet
+	ledgerP1InitTypedMessageData    ledgerParam1 = 0x00 // First chunk of Typed Message data
 	ledgerP1InitTransactionData     ledgerParam1 = 0x00 // First transaction data block for signing
 	ledgerP1ContTransactionData     ledgerParam1 = 0x80 // Subsequent transaction data block for signing
 	ledgerP2DiscardAddressChainCode ledgerParam2 = 0x00 // Do not return the chain code along with the address
@@ -162,12 +165,31 @@ func (w *ledgerDriver) SignTx(path accounts.DerivationPath, tx *types.Transactio
 	}
 	// Ensure the wallet is capable of signing the given transaction
 	if chainID != nil && w.version[0] <= 1 && w.version[1] <= 0 && w.version[2] <= 2 {
+		//lint:ignore ST1005 brand name displayed on the console
 		return common.Address{}, nil, fmt.Errorf("Ledger v%d.%d.%d doesn't support signing this transaction, please update to v1.0.3 at least", w.version[0], w.version[1], w.version[2])
 	}
 	// All infos gathered and metadata checks out, request signing
 	return w.ledgerSign(path, tx, chainID)
 }
 
+// SignTypedMessage implements usbwallet.driver, sending the message to the Ledger and
+// waiting for the user to sign or deny the transaction.
+//
+// Note: this was introduced in the ledger 1.5.0 firmware
+func (w *ledgerDriver) SignTypedMessage(path accounts.DerivationPath, domainHash []byte, messageHash []byte) ([]byte, error) {
+	// If the Ethereum app doesn't run, abort
+	if w.offline() {
+		return nil, accounts.ErrWalletClosed
+	}
+	// Ensure the wallet is capable of signing the given transaction
+	if w.version[0] < 1 && w.version[1] < 5 {
+		//lint:ignore ST1005 brand name displayed on the console
+		return nil, fmt.Errorf("Ledger version >= 1.5.0 required for EIP-712 signing (found version v%d.%d.%d)", w.version[0], w.version[1], w.version[2])
+	}
+	// All infos gathered and metadata checks out, request signing
+	return w.ledgerSignTypedMessage(path, domainHash, messageHash)
+}
+
 // ledgerVersion retrieves the current version of the Ethereum wallet app running
 // on the Ledger wallet.
 //
@@ -257,7 +279,9 @@ func (w *ledgerDriver) ledgerDerive(derivationPath []uint32) (common.Address, er
 
 	// Decode the hex sting into an Ethereum address and return
 	var address common.Address
-	hex.Decode(address[:], hexstr)
+	if _, err = hex.Decode(address[:], hexstr); err != nil {
+		return common.Address{}, err
+	}
 	return address, nil
 }
 
@@ -339,15 +363,19 @@ func (w *ledgerDriver) ledgerSign(derivationPath []uint32, tx *types.Transaction
 		op = ledgerP1ContTransactionData
 	}
 	// Extract the Ethereum signature and do a sanity validation
-	if len(reply) != 65 {
+	if len(reply) != crypto.SignatureLength {
 		return common.Address{}, nil, errors.New("reply lacks signature")
 	}
 	signature := append(reply[1:], reply[0])
 
 	// Create the correct signer and signature transform based on the chain ID
-	var signer types.Signer = types.NewTIP1Signer(chainID)
-	signature[64] -= byte(chainID.Uint64()*2 + 35)
-
+	var signer types.Signer
+	if chainID == nil {
+		signer = new(types.TIP1Signer)
+	} else {
+		signer = types.NewTIP1Signer(chainID)
+		signature[64] -= byte(chainID.Uint64()*2 + 35)
+	}
 	signed, err := tx.WithSignature(signer, signature)
 	if err != nil {
 		return common.Address{}, nil, err
@@ -359,6 +387,68 @@ func (w *ledgerDriver) ledgerSign(derivationPath []uint32, tx *types.Transaction
 	return sender, signed, nil
 }
 
+// ledgerSignTypedMessage sends the transaction to the Ledger wallet, and waits for the user
+// to confirm or deny the transaction.
+//
+// The signing protocol is defined as follows:
+//
+//   CLA | INS | P1 | P2                          | Lc  | Le
+//   ----+-----+----+-----------------------------+-----+---
+//    E0 | 0C  | 00 | implementation version : 00 | variable | variable
+//
+// Where the input is:
+//
+//   Description                                      | Length
+//   -------------------------------------------------+----------
+//   Number of BIP 32 derivations to perform (max 10) | 1 byte
+//   First derivation index (big endian)              | 4 bytes
+//   ...                                              | 4 bytes
+//   Last derivation index (big endian)               | 4 bytes
+//   domain hash                                      | 32 bytes
+//   message hash                                     | 32 bytes
+//
+//
+//
+// And the output data is:
+//
+//   Description | Length
+//   ------------+---------
+//   signature V | 1 byte
+//   signature R | 32 bytes
+//   signature S | 32 bytes
+func (w *ledgerDriver) ledgerSignTypedMessage(derivationPath []uint32, domainHash []byte, messageHash []byte) ([]byte, error) {
+	// Flatten the derivation path into the Ledger request
+	path := make([]byte, 1+4*len(derivationPath))
+	path[0] = byte(len(derivationPath))
+	for i, component := range derivationPath {
+		binary.BigEndian.PutUint32(path[1+4*i:], component)
+	}
+	// Create the 712 message
+	payload := append(path, domainHash...)
+	payload = append(payload, messageHash...)
+
+	// Send the request and wait for the response
+	var (
+		op    = ledgerP1InitTypedMessageData
+		reply []byte
+		err   error
+	)
+
+	// Send the message over, ensuring it's processed correctly
+	reply, err = w.ledgerExchange(ledgerOpSignTypedMessage, op, 0, payload)
+
+	if err != nil {
+		return nil, err
+	}
+
+	// Extract the Ethereum signature and do a sanity validation
+	if len(reply) != crypto.SignatureLength {
+		return nil, errors.New("reply lacks signature")
+	}
+	signature := append(reply[1:], reply[0])
+	return signature, nil
+}
+
 // ledgerExchange performs a data exchange with the Ledger wallet, sending it a
 // message and retrieving the response.
 //
diff --git a/accounts/usbwallet/trezor.go b/accounts/usbwallet/trezor.go
index ede78b283..f961a2a27 100644
--- a/accounts/usbwallet/trezor.go
+++ b/accounts/usbwallet/trezor.go
@@ -27,13 +27,13 @@ import (
 	"io"
 	"math/big"
 
-	"github.com/truechain/truechain-engineering-code/common"
-	"github.com/truechain/truechain-engineering-code/common/hexutil"
-	"github.com/truechain/truechain-engineering-code/log"
 	"github.com/golang/protobuf/proto"
 	"github.com/truechain/truechain-engineering-code/accounts"
-	"github.com/truechain/truechain-engineering-code/accounts/usbwallet/internal/trezor"
+	"github.com/truechain/truechain-engineering-code/accounts/usbwallet/trezor"
+	"github.com/truechain/truechain-engineering-code/common"
+	"github.com/truechain/truechain-engineering-code/common/hexutil"
 	"github.com/truechain/truechain-engineering-code/core/types"
+	"github.com/truechain/truechain-engineering-code/log"
 )
 
 // ErrTrezorPINNeeded is returned if opening the trezor requires a PIN code. In
@@ -41,6 +41,9 @@ import (
 // encoded passphrase.
 var ErrTrezorPINNeeded = errors.New("trezor: pin needed")
 
+// ErrTrezorPassphraseNeeded is returned if opening the trezor requires a passphrase
+var ErrTrezorPassphraseNeeded = errors.New("trezor: passphrase needed")
+
 // errTrezorReplyInvalidHeader is the error message returned by a Trezor data exchange
 // if the device replies with a mismatching header. This usually means the device
 // is in browser mode.
@@ -48,12 +51,13 @@ var errTrezorReplyInvalidHeader = errors.New("trezor: invalid reply header")
 
 // trezorDriver implements the communication with a Trezor hardware wallet.
 type trezorDriver struct {
-	device  io.ReadWriter // USB device connection to communicate through
-	version [3]uint32     // Current version of the Trezor firmware
-	label   string        // Current textual label of the Trezor device
-	pinwait bool          // Flags whether the device is waiting for PIN entry
-	failure error         // Any failure that would make the device unusable
-	log     log.Logger    // Contextual logger to tag the trezor with its id
+	device         io.ReadWriter // USB device connection to communicate through
+	version        [3]uint32     // Current version of the Trezor firmware
+	label          string        // Current textual label of the Trezor device
+	pinwait        bool          // Flags whether the device is waiting for PIN entry
+	passphrasewait bool          // Flags whether the device is waiting for passphrase entry
+	failure        error         // Any failure that would make the device unusable
+	log            log.Logger    // Contextual logger to tag the trezor with its id
 }
 
 // newTrezorDriver creates a new instance of a Trezor USB protocol driver.
@@ -79,19 +83,21 @@ func (w *trezorDriver) Status() (string, error) {
 }
 
 // Open implements usbwallet.driver, attempting to initialize the connection to
-// the Trezor hardware wallet. Initializing the Trezor is a two phase operation:
+// the Trezor hardware wallet. Initializing the Trezor is a two or three phase operation:
 //  * The first phase is to initialize the connection and read the wallet's
-//    features. This phase is invoked is the provided passphrase is empty. The
+//    features. This phase is invoked if the provided passphrase is empty. The
 //    device will display the pinpad as a result and will return an appropriate
 //    error to notify the user that a second open phase is needed.
 //  * The second phase is to unlock access to the Trezor, which is done by the
 //    user actually providing a passphrase mapping a keyboard keypad to the pin
 //    number of the user (shuffled according to the pinpad displayed).
+//  * If needed the device will ask for passphrase which will require calling
+//    open again with the actual passphrase (3rd phase)
 func (w *trezorDriver) Open(device io.ReadWriter, passphrase string) error {
 	w.device, w.failure = device, nil
 
 	// If phase 1 is requested, init the connection and wait for user callback
-	if passphrase == "" {
+	if passphrase == "" && !w.passphrasewait {
 		// If we're already waiting for a PIN entry, insta-return
 		if w.pinwait {
 			return ErrTrezorPINNeeded
@@ -104,26 +110,46 @@ func (w *trezorDriver) Open(device io.ReadWriter, passphrase string) error {
 		w.version = [3]uint32{features.GetMajorVersion(), features.GetMinorVersion(), features.GetPatchVersion()}
 		w.label = features.GetLabel()
 
-		// Do a manual ping, forcing the device to ask for its PIN
+		// Do a manual ping, forcing the device to ask for its PIN and Passphrase
 		askPin := true
-		res, err := w.trezorExchange(&trezor.Ping{PinProtection: &askPin}, new(trezor.PinMatrixRequest), new(trezor.Success))
+		askPassphrase := true
+		res, err := w.trezorExchange(&trezor.Ping{PinProtection: &askPin, PassphraseProtection: &askPassphrase}, new(trezor.PinMatrixRequest), new(trezor.PassphraseRequest), new(trezor.Success))
 		if err != nil {
 			return err
 		}
 		// Only return the PIN request if the device wasn't unlocked until now
-		if res == 1 {
-			return nil // Device responded with trezor.Success
+		switch res {
+		case 0:
+			w.pinwait = true
+			return ErrTrezorPINNeeded
+		case 1:
+			w.pinwait = false
+			w.passphrasewait = true
+			return ErrTrezorPassphraseNeeded
+		case 2:
+			return nil // responded with trezor.Success
 		}
-		w.pinwait = true
-		return ErrTrezorPINNeeded
 	}
 	// Phase 2 requested with actual PIN entry
-	w.pinwait = false
-
-	if _, err := w.trezorExchange(&trezor.PinMatrixAck{Pin: &passphrase}, new(trezor.Success)); err != nil {
-		w.failure = err
-		return err
+	if w.pinwait {
+		w.pinwait = false
+		res, err := w.trezorExchange(&trezor.PinMatrixAck{Pin: &passphrase}, new(trezor.Success), new(trezor.PassphraseRequest))
+		if err != nil {
+			w.failure = err
+			return err
+		}
+		if res == 1 {
+			w.passphrasewait = true
+			return ErrTrezorPassphraseNeeded
+		}
+	} else if w.passphrasewait {
+		w.passphrasewait = false
+		if _, err := w.trezorExchange(&trezor.PassphraseAck{Passphrase: &passphrase}, new(trezor.Success)); err != nil {
+			w.failure = err
+			return err
+		}
 	}
+
 	return nil
 }
 
@@ -159,6 +185,10 @@ func (w *trezorDriver) SignTx(path accounts.DerivationPath, tx *types.Transactio
 	return w.trezorSign(path, tx, chainID)
 }
 
+func (w *trezorDriver) SignTypedMessage(path accounts.DerivationPath, domainHash []byte, messageHash []byte) ([]byte, error) {
+	return nil, accounts.ErrNotSupported
+}
+
 // trezorDerive sends a derivation request to the Trezor device and returns the
 // Ethereum address located on that path.
 func (w *trezorDriver) trezorDerive(derivationPath []uint32) (common.Address, error) {
@@ -166,7 +196,13 @@ func (w *trezorDriver) trezorDerive(derivationPath []uint32) (common.Address, er
 	if _, err := w.trezorExchange(&trezor.EthereumGetAddress{AddressN: derivationPath}, address); err != nil {
 		return common.Address{}, err
 	}
-	return common.BytesToAddress(address.GetAddress()), nil
+	if addr := address.GetAddressBin(); len(addr) > 0 { // Older firmwares use binary fomats
+		return common.BytesToAddress(addr), nil
+	}
+	if addr := address.GetAddressHex(); len(addr) > 0 { // Newer firmwares use hexadecimal fomats
+		return common.HexToAddress(addr), nil
+	}
+	return common.Address{}, errors.New("missing derived address")
 }
 
 // trezorSign sends the transaction to the Trezor wallet, and waits for the user
@@ -185,7 +221,10 @@ func (w *trezorDriver) trezorSign(derivationPath []uint32, tx *types.Transaction
 		DataLength: &length,
 	}
 	if to := tx.To(); to != nil {
-		request.To = (*to)[:] // Non contract deploy, set recipient explicitly
+		// Non contract deploy, set recipient explicitly
+		hex := to.Hex()
+		request.ToHex = &hex     // Newer firmwares (old will ignore)
+		request.ToBin = (*to)[:] // Older firmwares (new will ignore)
 	}
 	if length > 1024 { // Send the data chunked if that was requested
 		request.DataInitialChunk, data = data[:1024], data[1024:]
@@ -216,8 +255,14 @@ func (w *trezorDriver) trezorSign(derivationPath []uint32, tx *types.Transaction
 	signature := append(append(response.GetSignatureR(), response.GetSignatureS()...), byte(response.GetSignatureV()))
 
 	// Create the correct signer and signature transform based on the chain ID
-	var signer types.Signer = types.NewTIP1Signer(chainID)
-	signature[64] -= byte(chainID.Uint64()*2 + 35)
+	var signer types.Signer
+	if chainID == nil {
+		signer = new(types.TIP1Signer)
+	} else {
+		// Trezor backend does not support typed transactions yet.
+		signer = types.NewTIP1Signer(chainID)
+		signature[64] -= byte(chainID.Uint64()*2 + 35)
+	}
 
 	// Inject the final signature into the transaction and sanity check the sender
 	signed, err := tx.WithSignature(signer, signature)
diff --git a/accounts/usbwallet/trezor/messages-common.pb.go b/accounts/usbwallet/trezor/messages-common.pb.go
new file mode 100644
index 000000000..304bec0e3
--- /dev/null
+++ b/accounts/usbwallet/trezor/messages-common.pb.go
@@ -0,0 +1,811 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: messages-common.proto
+
+package trezor
+
+import (
+	fmt "fmt"
+	math "math"
+
+	proto "github.com/golang/protobuf/proto"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
+
+type Failure_FailureType int32
+
+const (
+	Failure_Failure_UnexpectedMessage Failure_FailureType = 1
+	Failure_Failure_ButtonExpected    Failure_FailureType = 2
+	Failure_Failure_DataError         Failure_FailureType = 3
+	Failure_Failure_ActionCancelled   Failure_FailureType = 4
+	Failure_Failure_PinExpected       Failure_FailureType = 5
+	Failure_Failure_PinCancelled      Failure_FailureType = 6
+	Failure_Failure_PinInvalid        Failure_FailureType = 7
+	Failure_Failure_InvalidSignature  Failure_FailureType = 8
+	Failure_Failure_ProcessError      Failure_FailureType = 9
+	Failure_Failure_NotEnoughFunds    Failure_FailureType = 10
+	Failure_Failure_NotInitialized    Failure_FailureType = 11
+	Failure_Failure_PinMismatch       Failure_FailureType = 12
+	Failure_Failure_FirmwareError     Failure_FailureType = 99
+)
+
+var Failure_FailureType_name = map[int32]string{
+	1:  "Failure_UnexpectedMessage",
+	2:  "Failure_ButtonExpected",
+	3:  "Failure_DataError",
+	4:  "Failure_ActionCancelled",
+	5:  "Failure_PinExpected",
+	6:  "Failure_PinCancelled",
+	7:  "Failure_PinInvalid",
+	8:  "Failure_InvalidSignature",
+	9:  "Failure_ProcessError",
+	10: "Failure_NotEnoughFunds",
+	11: "Failure_NotInitialized",
+	12: "Failure_PinMismatch",
+	99: "Failure_FirmwareError",
+}
+
+var Failure_FailureType_value = map[string]int32{
+	"Failure_UnexpectedMessage": 1,
+	"Failure_ButtonExpected":    2,
+	"Failure_DataError":         3,
+	"Failure_ActionCancelled":   4,
+	"Failure_PinExpected":       5,
+	"Failure_PinCancelled":      6,
+	"Failure_PinInvalid":        7,
+	"Failure_InvalidSignature":  8,
+	"Failure_ProcessError":      9,
+	"Failure_NotEnoughFunds":    10,
+	"Failure_NotInitialized":    11,
+	"Failure_PinMismatch":       12,
+	"Failure_FirmwareError":     99,
+}
+
+func (x Failure_FailureType) Enum() *Failure_FailureType {
+	p := new(Failure_FailureType)
+	*p = x
+	return p
+}
+
+func (x Failure_FailureType) String() string {
+	return proto.EnumName(Failure_FailureType_name, int32(x))
+}
+
+func (x *Failure_FailureType) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(Failure_FailureType_value, data, "Failure_FailureType")
+	if err != nil {
+		return err
+	}
+	*x = Failure_FailureType(value)
+	return nil
+}
+
+func (Failure_FailureType) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_aaf30d059fdbc38d, []int{1, 0}
+}
+
+//*
+// Type of button request
+type ButtonRequest_ButtonRequestType int32
+
+const (
+	ButtonRequest_ButtonRequest_Other                 ButtonRequest_ButtonRequestType = 1
+	ButtonRequest_ButtonRequest_FeeOverThreshold      ButtonRequest_ButtonRequestType = 2
+	ButtonRequest_ButtonRequest_ConfirmOutput         ButtonRequest_ButtonRequestType = 3
+	ButtonRequest_ButtonRequest_ResetDevice           ButtonRequest_ButtonRequestType = 4
+	ButtonRequest_ButtonRequest_ConfirmWord           ButtonRequest_ButtonRequestType = 5
+	ButtonRequest_ButtonRequest_WipeDevice            ButtonRequest_ButtonRequestType = 6
+	ButtonRequest_ButtonRequest_ProtectCall           ButtonRequest_ButtonRequestType = 7
+	ButtonRequest_ButtonRequest_SignTx                ButtonRequest_ButtonRequestType = 8
+	ButtonRequest_ButtonRequest_FirmwareCheck         ButtonRequest_ButtonRequestType = 9
+	ButtonRequest_ButtonRequest_Address               ButtonRequest_ButtonRequestType = 10
+	ButtonRequest_ButtonRequest_PublicKey             ButtonRequest_ButtonRequestType = 11
+	ButtonRequest_ButtonRequest_MnemonicWordCount     ButtonRequest_ButtonRequestType = 12
+	ButtonRequest_ButtonRequest_MnemonicInput         ButtonRequest_ButtonRequestType = 13
+	ButtonRequest_ButtonRequest_PassphraseType        ButtonRequest_ButtonRequestType = 14
+	ButtonRequest_ButtonRequest_UnknownDerivationPath ButtonRequest_ButtonRequestType = 15
+)
+
+var ButtonRequest_ButtonRequestType_name = map[int32]string{
+	1:  "ButtonRequest_Other",
+	2:  "ButtonRequest_FeeOverThreshold",
+	3:  "ButtonRequest_ConfirmOutput",
+	4:  "ButtonRequest_ResetDevice",
+	5:  "ButtonRequest_ConfirmWord",
+	6:  "ButtonRequest_WipeDevice",
+	7:  "ButtonRequest_ProtectCall",
+	8:  "ButtonRequest_SignTx",
+	9:  "ButtonRequest_FirmwareCheck",
+	10: "ButtonRequest_Address",
+	11: "ButtonRequest_PublicKey",
+	12: "ButtonRequest_MnemonicWordCount",
+	13: "ButtonRequest_MnemonicInput",
+	14: "ButtonRequest_PassphraseType",
+	15: "ButtonRequest_UnknownDerivationPath",
+}
+
+var ButtonRequest_ButtonRequestType_value = map[string]int32{
+	"ButtonRequest_Other":                 1,
+	"ButtonRequest_FeeOverThreshold":      2,
+	"ButtonRequest_ConfirmOutput":         3,
+	"ButtonRequest_ResetDevice":           4,
+	"ButtonRequest_ConfirmWord":           5,
+	"ButtonRequest_WipeDevice":            6,
+	"ButtonRequest_ProtectCall":           7,
+	"ButtonRequest_SignTx":                8,
+	"ButtonRequest_FirmwareCheck":         9,
+	"ButtonRequest_Address":               10,
+	"ButtonRequest_PublicKey":             11,
+	"ButtonRequest_MnemonicWordCount":     12,
+	"ButtonRequest_MnemonicInput":         13,
+	"ButtonRequest_PassphraseType":        14,
+	"ButtonRequest_UnknownDerivationPath": 15,
+}
+
+func (x ButtonRequest_ButtonRequestType) Enum() *ButtonRequest_ButtonRequestType {
+	p := new(ButtonRequest_ButtonRequestType)
+	*p = x
+	return p
+}
+
+func (x ButtonRequest_ButtonRequestType) String() string {
+	return proto.EnumName(ButtonRequest_ButtonRequestType_name, int32(x))
+}
+
+func (x *ButtonRequest_ButtonRequestType) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(ButtonRequest_ButtonRequestType_value, data, "ButtonRequest_ButtonRequestType")
+	if err != nil {
+		return err
+	}
+	*x = ButtonRequest_ButtonRequestType(value)
+	return nil
+}
+
+func (ButtonRequest_ButtonRequestType) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_aaf30d059fdbc38d, []int{2, 0}
+}
+
+//*
+// Type of PIN request
+type PinMatrixRequest_PinMatrixRequestType int32
+
+const (
+	PinMatrixRequest_PinMatrixRequestType_Current   PinMatrixRequest_PinMatrixRequestType = 1
+	PinMatrixRequest_PinMatrixRequestType_NewFirst  PinMatrixRequest_PinMatrixRequestType = 2
+	PinMatrixRequest_PinMatrixRequestType_NewSecond PinMatrixRequest_PinMatrixRequestType = 3
+)
+
+var PinMatrixRequest_PinMatrixRequestType_name = map[int32]string{
+	1: "PinMatrixRequestType_Current",
+	2: "PinMatrixRequestType_NewFirst",
+	3: "PinMatrixRequestType_NewSecond",
+}
+
+var PinMatrixRequest_PinMatrixRequestType_value = map[string]int32{
+	"PinMatrixRequestType_Current":   1,
+	"PinMatrixRequestType_NewFirst":  2,
+	"PinMatrixRequestType_NewSecond": 3,
+}
+
+func (x PinMatrixRequest_PinMatrixRequestType) Enum() *PinMatrixRequest_PinMatrixRequestType {
+	p := new(PinMatrixRequest_PinMatrixRequestType)
+	*p = x
+	return p
+}
+
+func (x PinMatrixRequest_PinMatrixRequestType) String() string {
+	return proto.EnumName(PinMatrixRequest_PinMatrixRequestType_name, int32(x))
+}
+
+func (x *PinMatrixRequest_PinMatrixRequestType) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(PinMatrixRequest_PinMatrixRequestType_value, data, "PinMatrixRequest_PinMatrixRequestType")
+	if err != nil {
+		return err
+	}
+	*x = PinMatrixRequest_PinMatrixRequestType(value)
+	return nil
+}
+
+func (PinMatrixRequest_PinMatrixRequestType) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_aaf30d059fdbc38d, []int{4, 0}
+}
+
+//*
+// Response: Success of the previous request
+// @end
+type Success struct {
+	Message              *string  `protobuf:"bytes,1,opt,name=message" json:"message,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Success) Reset()         { *m = Success{} }
+func (m *Success) String() string { return proto.CompactTextString(m) }
+func (*Success) ProtoMessage()    {}
+func (*Success) Descriptor() ([]byte, []int) {
+	return fileDescriptor_aaf30d059fdbc38d, []int{0}
+}
+
+func (m *Success) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Success.Unmarshal(m, b)
+}
+func (m *Success) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Success.Marshal(b, m, deterministic)
+}
+func (m *Success) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Success.Merge(m, src)
+}
+func (m *Success) XXX_Size() int {
+	return xxx_messageInfo_Success.Size(m)
+}
+func (m *Success) XXX_DiscardUnknown() {
+	xxx_messageInfo_Success.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Success proto.InternalMessageInfo
+
+func (m *Success) GetMessage() string {
+	if m != nil && m.Message != nil {
+		return *m.Message
+	}
+	return ""
+}
+
+//*
+// Response: Failure of the previous request
+// @end
+type Failure struct {
+	Code                 *Failure_FailureType `protobuf:"varint,1,opt,name=code,enum=hw.trezor.messages.common.Failure_FailureType" json:"code,omitempty"`
+	Message              *string              `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
+	XXX_unrecognized     []byte               `json:"-"`
+	XXX_sizecache        int32                `json:"-"`
+}
+
+func (m *Failure) Reset()         { *m = Failure{} }
+func (m *Failure) String() string { return proto.CompactTextString(m) }
+func (*Failure) ProtoMessage()    {}
+func (*Failure) Descriptor() ([]byte, []int) {
+	return fileDescriptor_aaf30d059fdbc38d, []int{1}
+}
+
+func (m *Failure) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Failure.Unmarshal(m, b)
+}
+func (m *Failure) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Failure.Marshal(b, m, deterministic)
+}
+func (m *Failure) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Failure.Merge(m, src)
+}
+func (m *Failure) XXX_Size() int {
+	return xxx_messageInfo_Failure.Size(m)
+}
+func (m *Failure) XXX_DiscardUnknown() {
+	xxx_messageInfo_Failure.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Failure proto.InternalMessageInfo
+
+func (m *Failure) GetCode() Failure_FailureType {
+	if m != nil && m.Code != nil {
+		return *m.Code
+	}
+	return Failure_Failure_UnexpectedMessage
+}
+
+func (m *Failure) GetMessage() string {
+	if m != nil && m.Message != nil {
+		return *m.Message
+	}
+	return ""
+}
+
+//*
+// Response: Device is waiting for HW button press.
+// @auxstart
+// @next ButtonAck
+type ButtonRequest struct {
+	Code                 *ButtonRequest_ButtonRequestType `protobuf:"varint,1,opt,name=code,enum=hw.trezor.messages.common.ButtonRequest_ButtonRequestType" json:"code,omitempty"`
+	Data                 *string                          `protobuf:"bytes,2,opt,name=data" json:"data,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}                         `json:"-"`
+	XXX_unrecognized     []byte                           `json:"-"`
+	XXX_sizecache        int32                            `json:"-"`
+}
+
+func (m *ButtonRequest) Reset()         { *m = ButtonRequest{} }
+func (m *ButtonRequest) String() string { return proto.CompactTextString(m) }
+func (*ButtonRequest) ProtoMessage()    {}
+func (*ButtonRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_aaf30d059fdbc38d, []int{2}
+}
+
+func (m *ButtonRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ButtonRequest.Unmarshal(m, b)
+}
+func (m *ButtonRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ButtonRequest.Marshal(b, m, deterministic)
+}
+func (m *ButtonRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ButtonRequest.Merge(m, src)
+}
+func (m *ButtonRequest) XXX_Size() int {
+	return xxx_messageInfo_ButtonRequest.Size(m)
+}
+func (m *ButtonRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_ButtonRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ButtonRequest proto.InternalMessageInfo
+
+func (m *ButtonRequest) GetCode() ButtonRequest_ButtonRequestType {
+	if m != nil && m.Code != nil {
+		return *m.Code
+	}
+	return ButtonRequest_ButtonRequest_Other
+}
+
+func (m *ButtonRequest) GetData() string {
+	if m != nil && m.Data != nil {
+		return *m.Data
+	}
+	return ""
+}
+
+//*
+// Request: Computer agrees to wait for HW button press
+// @auxend
+type ButtonAck struct {
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ButtonAck) Reset()         { *m = ButtonAck{} }
+func (m *ButtonAck) String() string { return proto.CompactTextString(m) }
+func (*ButtonAck) ProtoMessage()    {}
+func (*ButtonAck) Descriptor() ([]byte, []int) {
+	return fileDescriptor_aaf30d059fdbc38d, []int{3}
+}
+
+func (m *ButtonAck) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ButtonAck.Unmarshal(m, b)
+}
+func (m *ButtonAck) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ButtonAck.Marshal(b, m, deterministic)
+}
+func (m *ButtonAck) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ButtonAck.Merge(m, src)
+}
+func (m *ButtonAck) XXX_Size() int {
+	return xxx_messageInfo_ButtonAck.Size(m)
+}
+func (m *ButtonAck) XXX_DiscardUnknown() {
+	xxx_messageInfo_ButtonAck.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ButtonAck proto.InternalMessageInfo
+
+//*
+// Response: Device is asking computer to show PIN matrix and awaits PIN encoded using this matrix scheme
+// @auxstart
+// @next PinMatrixAck
+type PinMatrixRequest struct {
+	Type                 *PinMatrixRequest_PinMatrixRequestType `protobuf:"varint,1,opt,name=type,enum=hw.trezor.messages.common.PinMatrixRequest_PinMatrixRequestType" json:"type,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}                               `json:"-"`
+	XXX_unrecognized     []byte                                 `json:"-"`
+	XXX_sizecache        int32                                  `json:"-"`
+}
+
+func (m *PinMatrixRequest) Reset()         { *m = PinMatrixRequest{} }
+func (m *PinMatrixRequest) String() string { return proto.CompactTextString(m) }
+func (*PinMatrixRequest) ProtoMessage()    {}
+func (*PinMatrixRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_aaf30d059fdbc38d, []int{4}
+}
+
+func (m *PinMatrixRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_PinMatrixRequest.Unmarshal(m, b)
+}
+func (m *PinMatrixRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_PinMatrixRequest.Marshal(b, m, deterministic)
+}
+func (m *PinMatrixRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_PinMatrixRequest.Merge(m, src)
+}
+func (m *PinMatrixRequest) XXX_Size() int {
+	return xxx_messageInfo_PinMatrixRequest.Size(m)
+}
+func (m *PinMatrixRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_PinMatrixRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PinMatrixRequest proto.InternalMessageInfo
+
+func (m *PinMatrixRequest) GetType() PinMatrixRequest_PinMatrixRequestType {
+	if m != nil && m.Type != nil {
+		return *m.Type
+	}
+	return PinMatrixRequest_PinMatrixRequestType_Current
+}
+
+//*
+// Request: Computer responds with encoded PIN
+// @auxend
+type PinMatrixAck struct {
+	Pin                  *string  `protobuf:"bytes,1,req,name=pin" json:"pin,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *PinMatrixAck) Reset()         { *m = PinMatrixAck{} }
+func (m *PinMatrixAck) String() string { return proto.CompactTextString(m) }
+func (*PinMatrixAck) ProtoMessage()    {}
+func (*PinMatrixAck) Descriptor() ([]byte, []int) {
+	return fileDescriptor_aaf30d059fdbc38d, []int{5}
+}
+
+func (m *PinMatrixAck) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_PinMatrixAck.Unmarshal(m, b)
+}
+func (m *PinMatrixAck) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_PinMatrixAck.Marshal(b, m, deterministic)
+}
+func (m *PinMatrixAck) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_PinMatrixAck.Merge(m, src)
+}
+func (m *PinMatrixAck) XXX_Size() int {
+	return xxx_messageInfo_PinMatrixAck.Size(m)
+}
+func (m *PinMatrixAck) XXX_DiscardUnknown() {
+	xxx_messageInfo_PinMatrixAck.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PinMatrixAck proto.InternalMessageInfo
+
+func (m *PinMatrixAck) GetPin() string {
+	if m != nil && m.Pin != nil {
+		return *m.Pin
+	}
+	return ""
+}
+
+//*
+// Response: Device awaits encryption passphrase
+// @auxstart
+// @next PassphraseAck
+type PassphraseRequest struct {
+	OnDevice             *bool    `protobuf:"varint,1,opt,name=on_device,json=onDevice" json:"on_device,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *PassphraseRequest) Reset()         { *m = PassphraseRequest{} }
+func (m *PassphraseRequest) String() string { return proto.CompactTextString(m) }
+func (*PassphraseRequest) ProtoMessage()    {}
+func (*PassphraseRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_aaf30d059fdbc38d, []int{6}
+}
+
+func (m *PassphraseRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_PassphraseRequest.Unmarshal(m, b)
+}
+func (m *PassphraseRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_PassphraseRequest.Marshal(b, m, deterministic)
+}
+func (m *PassphraseRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_PassphraseRequest.Merge(m, src)
+}
+func (m *PassphraseRequest) XXX_Size() int {
+	return xxx_messageInfo_PassphraseRequest.Size(m)
+}
+func (m *PassphraseRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_PassphraseRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PassphraseRequest proto.InternalMessageInfo
+
+func (m *PassphraseRequest) GetOnDevice() bool {
+	if m != nil && m.OnDevice != nil {
+		return *m.OnDevice
+	}
+	return false
+}
+
+//*
+// Request: Send passphrase back
+// @next PassphraseStateRequest
+type PassphraseAck struct {
+	Passphrase           *string  `protobuf:"bytes,1,opt,name=passphrase" json:"passphrase,omitempty"`
+	State                []byte   `protobuf:"bytes,2,opt,name=state" json:"state,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *PassphraseAck) Reset()         { *m = PassphraseAck{} }
+func (m *PassphraseAck) String() string { return proto.CompactTextString(m) }
+func (*PassphraseAck) ProtoMessage()    {}
+func (*PassphraseAck) Descriptor() ([]byte, []int) {
+	return fileDescriptor_aaf30d059fdbc38d, []int{7}
+}
+
+func (m *PassphraseAck) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_PassphraseAck.Unmarshal(m, b)
+}
+func (m *PassphraseAck) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_PassphraseAck.Marshal(b, m, deterministic)
+}
+func (m *PassphraseAck) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_PassphraseAck.Merge(m, src)
+}
+func (m *PassphraseAck) XXX_Size() int {
+	return xxx_messageInfo_PassphraseAck.Size(m)
+}
+func (m *PassphraseAck) XXX_DiscardUnknown() {
+	xxx_messageInfo_PassphraseAck.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PassphraseAck proto.InternalMessageInfo
+
+func (m *PassphraseAck) GetPassphrase() string {
+	if m != nil && m.Passphrase != nil {
+		return *m.Passphrase
+	}
+	return ""
+}
+
+func (m *PassphraseAck) GetState() []byte {
+	if m != nil {
+		return m.State
+	}
+	return nil
+}
+
+//*
+// Response: Device awaits passphrase state
+// @next PassphraseStateAck
+type PassphraseStateRequest struct {
+	State                []byte   `protobuf:"bytes,1,opt,name=state" json:"state,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *PassphraseStateRequest) Reset()         { *m = PassphraseStateRequest{} }
+func (m *PassphraseStateRequest) String() string { return proto.CompactTextString(m) }
+func (*PassphraseStateRequest) ProtoMessage()    {}
+func (*PassphraseStateRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_aaf30d059fdbc38d, []int{8}
+}
+
+func (m *PassphraseStateRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_PassphraseStateRequest.Unmarshal(m, b)
+}
+func (m *PassphraseStateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_PassphraseStateRequest.Marshal(b, m, deterministic)
+}
+func (m *PassphraseStateRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_PassphraseStateRequest.Merge(m, src)
+}
+func (m *PassphraseStateRequest) XXX_Size() int {
+	return xxx_messageInfo_PassphraseStateRequest.Size(m)
+}
+func (m *PassphraseStateRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_PassphraseStateRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PassphraseStateRequest proto.InternalMessageInfo
+
+func (m *PassphraseStateRequest) GetState() []byte {
+	if m != nil {
+		return m.State
+	}
+	return nil
+}
+
+//*
+// Request: Send passphrase state back
+// @auxend
+type PassphraseStateAck struct {
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *PassphraseStateAck) Reset()         { *m = PassphraseStateAck{} }
+func (m *PassphraseStateAck) String() string { return proto.CompactTextString(m) }
+func (*PassphraseStateAck) ProtoMessage()    {}
+func (*PassphraseStateAck) Descriptor() ([]byte, []int) {
+	return fileDescriptor_aaf30d059fdbc38d, []int{9}
+}
+
+func (m *PassphraseStateAck) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_PassphraseStateAck.Unmarshal(m, b)
+}
+func (m *PassphraseStateAck) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_PassphraseStateAck.Marshal(b, m, deterministic)
+}
+func (m *PassphraseStateAck) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_PassphraseStateAck.Merge(m, src)
+}
+func (m *PassphraseStateAck) XXX_Size() int {
+	return xxx_messageInfo_PassphraseStateAck.Size(m)
+}
+func (m *PassphraseStateAck) XXX_DiscardUnknown() {
+	xxx_messageInfo_PassphraseStateAck.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PassphraseStateAck proto.InternalMessageInfo
+
+//*
+// Structure representing BIP32 (hierarchical deterministic) node
+// Used for imports of private key into the device and exporting public key out of device
+// @embed
+type HDNodeType struct {
+	Depth                *uint32  `protobuf:"varint,1,req,name=depth" json:"depth,omitempty"`
+	Fingerprint          *uint32  `protobuf:"varint,2,req,name=fingerprint" json:"fingerprint,omitempty"`
+	ChildNum             *uint32  `protobuf:"varint,3,req,name=child_num,json=childNum" json:"child_num,omitempty"`
+	ChainCode            []byte   `protobuf:"bytes,4,req,name=chain_code,json=chainCode" json:"chain_code,omitempty"`
+	PrivateKey           []byte   `protobuf:"bytes,5,opt,name=private_key,json=privateKey" json:"private_key,omitempty"`
+	PublicKey            []byte   `protobuf:"bytes,6,opt,name=public_key,json=publicKey" json:"public_key,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *HDNodeType) Reset()         { *m = HDNodeType{} }
+func (m *HDNodeType) String() string { return proto.CompactTextString(m) }
+func (*HDNodeType) ProtoMessage()    {}
+func (*HDNodeType) Descriptor() ([]byte, []int) {
+	return fileDescriptor_aaf30d059fdbc38d, []int{10}
+}
+
+func (m *HDNodeType) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_HDNodeType.Unmarshal(m, b)
+}
+func (m *HDNodeType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_HDNodeType.Marshal(b, m, deterministic)
+}
+func (m *HDNodeType) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_HDNodeType.Merge(m, src)
+}
+func (m *HDNodeType) XXX_Size() int {
+	return xxx_messageInfo_HDNodeType.Size(m)
+}
+func (m *HDNodeType) XXX_DiscardUnknown() {
+	xxx_messageInfo_HDNodeType.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_HDNodeType proto.InternalMessageInfo
+
+func (m *HDNodeType) GetDepth() uint32 {
+	if m != nil && m.Depth != nil {
+		return *m.Depth
+	}
+	return 0
+}
+
+func (m *HDNodeType) GetFingerprint() uint32 {
+	if m != nil && m.Fingerprint != nil {
+		return *m.Fingerprint
+	}
+	return 0
+}
+
+func (m *HDNodeType) GetChildNum() uint32 {
+	if m != nil && m.ChildNum != nil {
+		return *m.ChildNum
+	}
+	return 0
+}
+
+func (m *HDNodeType) GetChainCode() []byte {
+	if m != nil {
+		return m.ChainCode
+	}
+	return nil
+}
+
+func (m *HDNodeType) GetPrivateKey() []byte {
+	if m != nil {
+		return m.PrivateKey
+	}
+	return nil
+}
+
+func (m *HDNodeType) GetPublicKey() []byte {
+	if m != nil {
+		return m.PublicKey
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterEnum("hw.trezor.messages.common.Failure_FailureType", Failure_FailureType_name, Failure_FailureType_value)
+	proto.RegisterEnum("hw.trezor.messages.common.ButtonRequest_ButtonRequestType", ButtonRequest_ButtonRequestType_name, ButtonRequest_ButtonRequestType_value)
+	proto.RegisterEnum("hw.trezor.messages.common.PinMatrixRequest_PinMatrixRequestType", PinMatrixRequest_PinMatrixRequestType_name, PinMatrixRequest_PinMatrixRequestType_value)
+	proto.RegisterType((*Success)(nil), "hw.trezor.messages.common.Success")
+	proto.RegisterType((*Failure)(nil), "hw.trezor.messages.common.Failure")
+	proto.RegisterType((*ButtonRequest)(nil), "hw.trezor.messages.common.ButtonRequest")
+	proto.RegisterType((*ButtonAck)(nil), "hw.trezor.messages.common.ButtonAck")
+	proto.RegisterType((*PinMatrixRequest)(nil), "hw.trezor.messages.common.PinMatrixRequest")
+	proto.RegisterType((*PinMatrixAck)(nil), "hw.trezor.messages.common.PinMatrixAck")
+	proto.RegisterType((*PassphraseRequest)(nil), "hw.trezor.messages.common.PassphraseRequest")
+	proto.RegisterType((*PassphraseAck)(nil), "hw.trezor.messages.common.PassphraseAck")
+	proto.RegisterType((*PassphraseStateRequest)(nil), "hw.trezor.messages.common.PassphraseStateRequest")
+	proto.RegisterType((*PassphraseStateAck)(nil), "hw.trezor.messages.common.PassphraseStateAck")
+	proto.RegisterType((*HDNodeType)(nil), "hw.trezor.messages.common.HDNodeType")
+}
+
+func init() { proto.RegisterFile("messages-common.proto", fileDescriptor_aaf30d059fdbc38d) }
+
+var fileDescriptor_aaf30d059fdbc38d = []byte{
+	// 846 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x54, 0xcd, 0x52, 0x23, 0x37,
+	0x10, 0x2e, 0xff, 0x80, 0xed, 0xb6, 0xd9, 0x08, 0xc5, 0x80, 0x09, 0xb0, 0x38, 0xc3, 0x21, 0x5c,
+	0xe2, 0x4a, 0xe5, 0x98, 0x53, 0x58, 0x83, 0x2b, 0xd4, 0x16, 0x86, 0x1a, 0xd8, 0xda, 0xa3, 0x4b,
+	0xd1, 0xf4, 0x32, 0x2a, 0xcf, 0x48, 0x13, 0x8d, 0x06, 0xf0, 0x5e, 0xf2, 0x6a, 0x79, 0x89, 0xbc,
+	0x42, 0xaa, 0x52, 0xb9, 0xe4, 0x11, 0xb6, 0x34, 0x3f, 0x78, 0xc6, 0x66, 0x39, 0xcd, 0xe8, 0xfb,
+	0xbe, 0xee, 0x96, 0xba, 0x3f, 0x09, 0x76, 0x42, 0x8c, 0x63, 0x76, 0x8f, 0xf1, 0x8f, 0x5c, 0x85,
+	0xa1, 0x92, 0xa3, 0x48, 0x2b, 0xa3, 0xe8, 0xbe, 0xff, 0x38, 0x32, 0x1a, 0x3f, 0x2b, 0x3d, 0x2a,
+	0x04, 0xa3, 0x4c, 0xe0, 0x9c, 0x40, 0xeb, 0x36, 0xe1, 0x1c, 0xe3, 0x98, 0x0e, 0xa0, 0x95, 0xb3,
+	0x83, 0xda, 0xb0, 0x76, 0xda, 0x71, 0x8b, 0xa5, 0xf3, 0x77, 0x03, 0x5a, 0x13, 0x26, 0x82, 0x44,
+	0x23, 0x7d, 0x07, 0x4d, 0xae, 0xbc, 0x4c, 0xf2, 0xe6, 0xe7, 0xd1, 0xe8, 0xab, 0xa9, 0x47, 0x79,
+	0x44, 0xf1, 0xbd, 0x5b, 0x44, 0xe8, 0xa6, 0xb1, 0xe5, 0x4a, 0xf5, 0x6a, 0xa5, 0xff, 0xea, 0xd0,
+	0x2d, 0xe9, 0xe9, 0x11, 0xec, 0xe7, 0xcb, 0xd9, 0x07, 0x89, 0x4f, 0x11, 0x72, 0x83, 0xde, 0x55,
+	0x26, 0x26, 0x35, 0xfa, 0x1d, 0xec, 0x16, 0xf4, 0xbb, 0xc4, 0x18, 0x25, 0x2f, 0x72, 0x09, 0xa9,
+	0xd3, 0x1d, 0xd8, 0x2e, 0xb8, 0x73, 0x66, 0xd8, 0x85, 0xd6, 0x4a, 0x93, 0x06, 0x3d, 0x80, 0xbd,
+	0x02, 0x3e, 0xe3, 0x46, 0x28, 0x39, 0x66, 0x92, 0x63, 0x10, 0xa0, 0x47, 0x9a, 0x74, 0x0f, 0xbe,
+	0x2d, 0xc8, 0x1b, 0xb1, 0x4c, 0xb6, 0x41, 0x07, 0xd0, 0x2f, 0x11, 0xcb, 0x90, 0x4d, 0xba, 0x0b,
+	0xb4, 0xc4, 0x5c, 0xca, 0x07, 0x16, 0x08, 0x8f, 0xb4, 0xe8, 0x21, 0x0c, 0x0a, 0x3c, 0x07, 0x6f,
+	0xc5, 0xbd, 0x64, 0x26, 0xd1, 0x48, 0xda, 0x95, 0x7c, 0x5a, 0xd9, 0xf6, 0x67, 0xfb, 0xeb, 0x94,
+	0x8f, 0x34, 0x55, 0xe6, 0x42, 0xaa, 0xe4, 0xde, 0x9f, 0x24, 0xd2, 0x8b, 0x09, 0xac, 0x70, 0x97,
+	0x52, 0x18, 0xc1, 0x02, 0xf1, 0x19, 0x3d, 0xd2, 0x5d, 0xd9, 0xfa, 0x95, 0x88, 0x43, 0x66, 0xb8,
+	0x4f, 0x7a, 0x74, 0x1f, 0x76, 0x0a, 0x62, 0x22, 0x74, 0xf8, 0xc8, 0x34, 0x66, 0xb5, 0xb8, 0xf3,
+	0x4f, 0x13, 0xb6, 0xb2, 0xbe, 0xb9, 0xf8, 0x47, 0x82, 0xb1, 0xa1, 0xd3, 0xca, 0x74, 0x7f, 0x79,
+	0x65, 0xba, 0x95, 0xb8, 0xea, 0xaa, 0x34, 0x69, 0x0a, 0x4d, 0x8f, 0x19, 0x96, 0x8f, 0x39, 0xfd,
+	0x77, 0xfe, 0x6f, 0xc0, 0xf6, 0x9a, 0xde, 0xee, 0xbf, 0x02, 0xce, 0xae, 0x8d, 0x8f, 0x9a, 0xd4,
+	0xa8, 0x03, 0x6f, 0xab, 0xc4, 0x04, 0xf1, 0xfa, 0x01, 0xf5, 0x9d, 0xaf, 0x31, 0xf6, 0x55, 0x60,
+	0x67, 0x7d, 0x0c, 0x07, 0x55, 0xcd, 0x58, 0xc9, 0x4f, 0x42, 0x87, 0xd7, 0x89, 0x89, 0x12, 0x43,
+	0x1a, 0xd6, 0x47, 0x55, 0x81, 0x8b, 0x31, 0x9a, 0x73, 0x7c, 0x10, 0x1c, 0x49, 0x73, 0x9d, 0xce,
+	0xe3, 0x3f, 0x2a, 0x6d, 0xa7, 0x7f, 0x08, 0x83, 0x2a, 0xfd, 0x51, 0x44, 0x98, 0x07, 0x6f, 0xae,
+	0x07, 0xdf, 0x68, 0x65, 0x90, 0x9b, 0x31, 0x0b, 0x02, 0xd2, 0xb2, 0xa3, 0xae, 0xd2, 0xd6, 0x07,
+	0x77, 0x4f, 0xa4, 0xbd, 0xbe, 0xeb, 0x62, 0x3e, 0x63, 0x1f, 0xf9, 0x9c, 0x74, 0xec, 0xe8, 0xaa,
+	0x82, 0x33, 0xcf, 0xd3, 0x18, 0x5b, 0x2b, 0x1c, 0xc0, 0xde, 0x4a, 0xd1, 0xe4, 0xf7, 0x40, 0xf0,
+	0xf7, 0xb8, 0x20, 0x5d, 0x7a, 0x02, 0xc7, 0x55, 0xf2, 0x4a, 0x62, 0xa8, 0xa4, 0xe0, 0xf6, 0x3c,
+	0x63, 0x95, 0x48, 0x43, 0x7a, 0xeb, 0xd5, 0x0b, 0xd1, 0xa5, 0xb4, 0x3d, 0xdb, 0xa2, 0x43, 0x38,
+	0x5c, 0x29, 0xc1, 0xe2, 0x38, 0xf2, 0x35, 0x8b, 0xd3, 0xbb, 0x49, 0xde, 0xd0, 0x1f, 0xe0, 0xa4,
+	0xaa, 0xf8, 0x20, 0xe7, 0x52, 0x3d, 0xca, 0x73, 0xd4, 0xe2, 0x81, 0xd9, 0xcb, 0x75, 0xc3, 0x8c,
+	0x4f, 0xbe, 0x71, 0xba, 0xd0, 0xc9, 0x84, 0x67, 0x7c, 0xee, 0xfc, 0x5b, 0x03, 0x62, 0x2d, 0xca,
+	0x8c, 0x16, 0x4f, 0x85, 0xf1, 0xee, 0xa0, 0x69, 0x16, 0x51, 0x61, 0xbc, 0x5f, 0x5f, 0x31, 0xde,
+	0x6a, 0xe8, 0x1a, 0x90, 0xd9, 0xcf, 0x66, 0x73, 0xfe, 0x84, 0xfe, 0x4b, 0xac, 0x3d, 0xda, 0x4b,
+	0xf8, 0x6c, 0x9c, 0x68, 0x8d, 0xd2, 0x90, 0x1a, 0xfd, 0x1e, 0x8e, 0x5e, 0x54, 0x4c, 0xf1, 0x71,
+	0x22, 0x74, 0x6c, 0x48, 0xdd, 0x1a, 0xf3, 0x6b, 0x92, 0x5b, 0xe4, 0x4a, 0x7a, 0xa4, 0xe1, 0x0c,
+	0xa1, 0xf7, 0xac, 0x39, 0xe3, 0x73, 0x4a, 0xa0, 0x11, 0x09, 0x39, 0xa8, 0x0d, 0xeb, 0xa7, 0x1d,
+	0xd7, 0xfe, 0x3a, 0x3f, 0xc1, 0xf6, 0xb2, 0xaf, 0x45, 0x37, 0x0e, 0xa0, 0xa3, 0xe4, 0xcc, 0x4b,
+	0x1d, 0x96, 0xb6, 0xa4, 0xed, 0xb6, 0x95, 0xcc, 0x1c, 0xe7, 0x5c, 0xc0, 0xd6, 0x32, 0xc2, 0x26,
+	0x7d, 0x0b, 0x10, 0x3d, 0x03, 0xf9, 0xdb, 0x5d, 0x42, 0x68, 0x1f, 0x36, 0x62, 0xc3, 0x4c, 0xf6,
+	0xd8, 0xf6, 0xdc, 0x6c, 0xe1, 0x8c, 0x60, 0x77, 0x99, 0xe6, 0xd6, 0x42, 0x45, 0xf5, 0x67, 0x7d,
+	0xad, 0xac, 0xef, 0x03, 0x5d, 0xd1, 0xdb, 0x61, 0xfe, 0x55, 0x03, 0xf8, 0xed, 0x7c, 0xaa, 0xbc,
+	0xec, 0xbd, 0xee, 0xc3, 0x86, 0x87, 0x91, 0xf1, 0xd3, 0x13, 0x6e, 0xb9, 0xd9, 0x82, 0x0e, 0xa1,
+	0xfb, 0x49, 0xc8, 0x7b, 0xd4, 0x91, 0x16, 0xd2, 0x0c, 0xea, 0x29, 0x57, 0x86, 0xec, 0x81, 0xb9,
+	0x2f, 0x02, 0x6f, 0x26, 0x93, 0x70, 0xd0, 0x48, 0xf9, 0x76, 0x0a, 0x4c, 0x93, 0x90, 0x1e, 0x01,
+	0x70, 0x9f, 0x09, 0x39, 0x4b, 0x9f, 0xa6, 0xe6, 0xb0, 0x7e, 0xda, 0x73, 0x3b, 0x29, 0x32, 0xb6,
+	0x6f, 0xcc, 0x31, 0x74, 0xa3, 0xd4, 0x6f, 0x38, 0x9b, 0xe3, 0x62, 0xb0, 0x91, 0x6e, 0x1a, 0x72,
+	0xe8, 0x3d, 0x2e, 0x6c, 0x7c, 0x94, 0xde, 0x8e, 0x94, 0xdf, 0x4c, 0xf9, 0x4e, 0x54, 0xdc, 0x97,
+	0x2f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xb2, 0x7d, 0x20, 0xa6, 0x35, 0x07, 0x00, 0x00,
+}
diff --git a/accounts/usbwallet/trezor/messages-common.proto b/accounts/usbwallet/trezor/messages-common.proto
new file mode 100644
index 000000000..75a983b0a
--- /dev/null
+++ b/accounts/usbwallet/trezor/messages-common.proto
@@ -0,0 +1,147 @@
+// This file originates from the SatoshiLabs Trezor `common` repository at:
+//   https://github.com/trezor/trezor-common/blob/master/protob/messages-common.proto
+// dated 28.05.2019, commit 893fd219d4a01bcffa0cd9cfa631856371ec5aa9.
+
+syntax = "proto2";
+package hw.trezor.messages.common;
+
+/**
+ * Response: Success of the previous request
+ * @end
+ */
+message Success {
+    optional string message = 1;    // human readable description of action or request-specific payload
+}
+
+/**
+ * Response: Failure of the previous request
+ * @end
+ */
+message Failure {
+    optional FailureType code = 1;  // computer-readable definition of the error state
+    optional string message = 2;    // human-readable message of the error state
+    enum FailureType {
+        Failure_UnexpectedMessage = 1;
+        Failure_ButtonExpected = 2;
+        Failure_DataError = 3;
+        Failure_ActionCancelled = 4;
+        Failure_PinExpected = 5;
+        Failure_PinCancelled = 6;
+        Failure_PinInvalid = 7;
+        Failure_InvalidSignature = 8;
+        Failure_ProcessError = 9;
+        Failure_NotEnoughFunds = 10;
+        Failure_NotInitialized = 11;
+        Failure_PinMismatch = 12;
+        Failure_FirmwareError = 99;
+    }
+}
+
+/**
+ * Response: Device is waiting for HW button press.
+ * @auxstart
+ * @next ButtonAck
+ */
+message ButtonRequest {
+    optional ButtonRequestType code = 1;
+    optional string data = 2;
+    /**
+    * Type of button request
+    */
+    enum ButtonRequestType {
+        ButtonRequest_Other = 1;
+        ButtonRequest_FeeOverThreshold = 2;
+        ButtonRequest_ConfirmOutput = 3;
+        ButtonRequest_ResetDevice = 4;
+        ButtonRequest_ConfirmWord = 5;
+        ButtonRequest_WipeDevice = 6;
+        ButtonRequest_ProtectCall = 7;
+        ButtonRequest_SignTx = 8;
+        ButtonRequest_FirmwareCheck = 9;
+        ButtonRequest_Address = 10;
+        ButtonRequest_PublicKey = 11;
+        ButtonRequest_MnemonicWordCount = 12;
+        ButtonRequest_MnemonicInput = 13;
+        ButtonRequest_PassphraseType = 14;
+        ButtonRequest_UnknownDerivationPath = 15;
+    }
+}
+
+/**
+ * Request: Computer agrees to wait for HW button press
+ * @auxend
+ */
+message ButtonAck {
+}
+
+/**
+ * Response: Device is asking computer to show PIN matrix and awaits PIN encoded using this matrix scheme
+ * @auxstart
+ * @next PinMatrixAck
+ */
+message PinMatrixRequest {
+    optional PinMatrixRequestType type = 1;
+    /**
+    * Type of PIN request
+    */
+    enum PinMatrixRequestType {
+        PinMatrixRequestType_Current = 1;
+        PinMatrixRequestType_NewFirst = 2;
+        PinMatrixRequestType_NewSecond = 3;
+    }
+}
+
+/**
+ * Request: Computer responds with encoded PIN
+ * @auxend
+ */
+message PinMatrixAck {
+    required string pin = 1;    // matrix encoded PIN entered by user
+}
+
+/**
+ * Response: Device awaits encryption passphrase
+ * @auxstart
+ * @next PassphraseAck
+ */
+message PassphraseRequest {
+    optional bool on_device = 1;    // passphrase is being entered on the device
+}
+
+/**
+ * Request: Send passphrase back
+ * @next PassphraseStateRequest
+ */
+message PassphraseAck {
+    optional string passphrase = 1;
+    optional bytes state = 2;       // expected device state
+}
+
+/**
+ * Response: Device awaits passphrase state
+ * @next PassphraseStateAck
+ */
+message PassphraseStateRequest {
+    optional bytes state = 1;       // actual device state
+}
+
+/**
+ * Request: Send passphrase state back
+ * @auxend
+ */
+message PassphraseStateAck {
+}
+
+/**
+ * Structure representing BIP32 (hierarchical deterministic) node
+ * Used for imports of private key into the device and exporting public key out of device
+ * @embed
+ */
+message HDNodeType {
+    required uint32 depth = 1;
+    required uint32 fingerprint = 2;
+    required uint32 child_num = 3;
+    required bytes chain_code = 4;
+    optional bytes private_key = 5;
+    optional bytes public_key = 6;
+}
diff --git a/accounts/usbwallet/trezor/messages-ethereum.pb.go b/accounts/usbwallet/trezor/messages-ethereum.pb.go
new file mode 100644
index 000000000..5d664f5ba
--- /dev/null
+++ b/accounts/usbwallet/trezor/messages-ethereum.pb.go
@@ -0,0 +1,698 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: messages-ethereum.proto
+
+package trezor
+
+import (
+	fmt "fmt"
+	math "math"
+
+	proto "github.com/golang/protobuf/proto"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
+
+//*
+// Request: Ask device for public key corresponding to address_n path
+// @start
+// @next EthereumPublicKey
+// @next Failure
+type EthereumGetPublicKey struct {
+	AddressN             []uint32 `protobuf:"varint,1,rep,name=address_n,json=addressN" json:"address_n,omitempty"`
+	ShowDisplay          *bool    `protobuf:"varint,2,opt,name=show_display,json=showDisplay" json:"show_display,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *EthereumGetPublicKey) Reset()         { *m = EthereumGetPublicKey{} }
+func (m *EthereumGetPublicKey) String() string { return proto.CompactTextString(m) }
+func (*EthereumGetPublicKey) ProtoMessage()    {}
+func (*EthereumGetPublicKey) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cb33f46ba915f15c, []int{0}
+}
+
+func (m *EthereumGetPublicKey) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_EthereumGetPublicKey.Unmarshal(m, b)
+}
+func (m *EthereumGetPublicKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_EthereumGetPublicKey.Marshal(b, m, deterministic)
+}
+func (m *EthereumGetPublicKey) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_EthereumGetPublicKey.Merge(m, src)
+}
+func (m *EthereumGetPublicKey) XXX_Size() int {
+	return xxx_messageInfo_EthereumGetPublicKey.Size(m)
+}
+func (m *EthereumGetPublicKey) XXX_DiscardUnknown() {
+	xxx_messageInfo_EthereumGetPublicKey.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EthereumGetPublicKey proto.InternalMessageInfo
+
+func (m *EthereumGetPublicKey) GetAddressN() []uint32 {
+	if m != nil {
+		return m.AddressN
+	}
+	return nil
+}
+
+func (m *EthereumGetPublicKey) GetShowDisplay() bool {
+	if m != nil && m.ShowDisplay != nil {
+		return *m.ShowDisplay
+	}
+	return false
+}
+
+//*
+// Response: Contains public key derived from device private seed
+// @end
+type EthereumPublicKey struct {
+	Node                 *HDNodeType `protobuf:"bytes,1,opt,name=node" json:"node,omitempty"`
+	Xpub                 *string     `protobuf:"bytes,2,opt,name=xpub" json:"xpub,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
+	XXX_unrecognized     []byte      `json:"-"`
+	XXX_sizecache        int32       `json:"-"`
+}
+
+func (m *EthereumPublicKey) Reset()         { *m = EthereumPublicKey{} }
+func (m *EthereumPublicKey) String() string { return proto.CompactTextString(m) }
+func (*EthereumPublicKey) ProtoMessage()    {}
+func (*EthereumPublicKey) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cb33f46ba915f15c, []int{1}
+}
+
+func (m *EthereumPublicKey) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_EthereumPublicKey.Unmarshal(m, b)
+}
+func (m *EthereumPublicKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_EthereumPublicKey.Marshal(b, m, deterministic)
+}
+func (m *EthereumPublicKey) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_EthereumPublicKey.Merge(m, src)
+}
+func (m *EthereumPublicKey) XXX_Size() int {
+	return xxx_messageInfo_EthereumPublicKey.Size(m)
+}
+func (m *EthereumPublicKey) XXX_DiscardUnknown() {
+	xxx_messageInfo_EthereumPublicKey.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EthereumPublicKey proto.InternalMessageInfo
+
+func (m *EthereumPublicKey) GetNode() *HDNodeType {
+	if m != nil {
+		return m.Node
+	}
+	return nil
+}
+
+func (m *EthereumPublicKey) GetXpub() string {
+	if m != nil && m.Xpub != nil {
+		return *m.Xpub
+	}
+	return ""
+}
+
+//*
+// Request: Ask device for Ethereum address corresponding to address_n path
+// @start
+// @next EthereumAddress
+// @next Failure
+type EthereumGetAddress struct {
+	AddressN             []uint32 `protobuf:"varint,1,rep,name=address_n,json=addressN" json:"address_n,omitempty"`
+	ShowDisplay          *bool    `protobuf:"varint,2,opt,name=show_display,json=showDisplay" json:"show_display,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *EthereumGetAddress) Reset()         { *m = EthereumGetAddress{} }
+func (m *EthereumGetAddress) String() string { return proto.CompactTextString(m) }
+func (*EthereumGetAddress) ProtoMessage()    {}
+func (*EthereumGetAddress) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cb33f46ba915f15c, []int{2}
+}
+
+func (m *EthereumGetAddress) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_EthereumGetAddress.Unmarshal(m, b)
+}
+func (m *EthereumGetAddress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_EthereumGetAddress.Marshal(b, m, deterministic)
+}
+func (m *EthereumGetAddress) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_EthereumGetAddress.Merge(m, src)
+}
+func (m *EthereumGetAddress) XXX_Size() int {
+	return xxx_messageInfo_EthereumGetAddress.Size(m)
+}
+func (m *EthereumGetAddress) XXX_DiscardUnknown() {
+	xxx_messageInfo_EthereumGetAddress.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EthereumGetAddress proto.InternalMessageInfo
+
+func (m *EthereumGetAddress) GetAddressN() []uint32 {
+	if m != nil {
+		return m.AddressN
+	}
+	return nil
+}
+
+func (m *EthereumGetAddress) GetShowDisplay() bool {
+	if m != nil && m.ShowDisplay != nil {
+		return *m.ShowDisplay
+	}
+	return false
+}
+
+//*
+// Response: Contains an Ethereum address derived from device private seed
+// @end
+type EthereumAddress struct {
+	AddressBin           []byte   `protobuf:"bytes,1,opt,name=addressBin" json:"addressBin,omitempty"`
+	AddressHex           *string  `protobuf:"bytes,2,opt,name=addressHex" json:"addressHex,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *EthereumAddress) Reset()         { *m = EthereumAddress{} }
+func (m *EthereumAddress) String() string { return proto.CompactTextString(m) }
+func (*EthereumAddress) ProtoMessage()    {}
+func (*EthereumAddress) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cb33f46ba915f15c, []int{3}
+}
+
+func (m *EthereumAddress) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_EthereumAddress.Unmarshal(m, b)
+}
+func (m *EthereumAddress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_EthereumAddress.Marshal(b, m, deterministic)
+}
+func (m *EthereumAddress) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_EthereumAddress.Merge(m, src)
+}
+func (m *EthereumAddress) XXX_Size() int {
+	return xxx_messageInfo_EthereumAddress.Size(m)
+}
+func (m *EthereumAddress) XXX_DiscardUnknown() {
+	xxx_messageInfo_EthereumAddress.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EthereumAddress proto.InternalMessageInfo
+
+func (m *EthereumAddress) GetAddressBin() []byte {
+	if m != nil {
+		return m.AddressBin
+	}
+	return nil
+}
+
+func (m *EthereumAddress) GetAddressHex() string {
+	if m != nil && m.AddressHex != nil {
+		return *m.AddressHex
+	}
+	return ""
+}
+
+//*
+// Request: Ask device to sign transaction
+// All fields are optional from the protocol's point of view. Each field defaults to value `0` if missing.
+// Note: the first at most 1024 bytes of data MUST be transmitted as part of this message.
+// @start
+// @next EthereumTxRequest
+// @next Failure
+type EthereumSignTx struct {
+	AddressN             []uint32 `protobuf:"varint,1,rep,name=address_n,json=addressN" json:"address_n,omitempty"`
+	Nonce                []byte   `protobuf:"bytes,2,opt,name=nonce" json:"nonce,omitempty"`
+	GasPrice             []byte   `protobuf:"bytes,3,opt,name=gas_price,json=gasPrice" json:"gas_price,omitempty"`
+	GasLimit             []byte   `protobuf:"bytes,4,opt,name=gas_limit,json=gasLimit" json:"gas_limit,omitempty"`
+	ToBin                []byte   `protobuf:"bytes,5,opt,name=toBin" json:"toBin,omitempty"`
+	ToHex                *string  `protobuf:"bytes,11,opt,name=toHex" json:"toHex,omitempty"`
+	Value                []byte   `protobuf:"bytes,6,opt,name=value" json:"value,omitempty"`
+	DataInitialChunk     []byte   `protobuf:"bytes,7,opt,name=data_initial_chunk,json=dataInitialChunk" json:"data_initial_chunk,omitempty"`
+	DataLength           *uint32  `protobuf:"varint,8,opt,name=data_length,json=dataLength" json:"data_length,omitempty"`
+	ChainId              *uint32  `protobuf:"varint,9,opt,name=chain_id,json=chainId" json:"chain_id,omitempty"`
+	TxType               *uint32  `protobuf:"varint,10,opt,name=tx_type,json=txType" json:"tx_type,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *EthereumSignTx) Reset()         { *m = EthereumSignTx{} }
+func (m *EthereumSignTx) String() string { return proto.CompactTextString(m) }
+func (*EthereumSignTx) ProtoMessage()    {}
+func (*EthereumSignTx) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cb33f46ba915f15c, []int{4}
+}
+
+func (m *EthereumSignTx) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_EthereumSignTx.Unmarshal(m, b)
+}
+func (m *EthereumSignTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_EthereumSignTx.Marshal(b, m, deterministic)
+}
+func (m *EthereumSignTx) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_EthereumSignTx.Merge(m, src)
+}
+func (m *EthereumSignTx) XXX_Size() int {
+	return xxx_messageInfo_EthereumSignTx.Size(m)
+}
+func (m *EthereumSignTx) XXX_DiscardUnknown() {
+	xxx_messageInfo_EthereumSignTx.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EthereumSignTx proto.InternalMessageInfo
+
+func (m *EthereumSignTx) GetAddressN() []uint32 {
+	if m != nil {
+		return m.AddressN
+	}
+	return nil
+}
+
+func (m *EthereumSignTx) GetNonce() []byte {
+	if m != nil {
+		return m.Nonce
+	}
+	return nil
+}
+
+func (m *EthereumSignTx) GetGasPrice() []byte {
+	if m != nil {
+		return m.GasPrice
+	}
+	return nil
+}
+
+func (m *EthereumSignTx) GetGasLimit() []byte {
+	if m != nil {
+		return m.GasLimit
+	}
+	return nil
+}
+
+func (m *EthereumSignTx) GetToBin() []byte {
+	if m != nil {
+		return m.ToBin
+	}
+	return nil
+}
+
+func (m *EthereumSignTx) GetToHex() string {
+	if m != nil && m.ToHex != nil {
+		return *m.ToHex
+	}
+	return ""
+}
+
+func (m *EthereumSignTx) GetValue() []byte {
+	if m != nil {
+		return m.Value
+	}
+	return nil
+}
+
+func (m *EthereumSignTx) GetDataInitialChunk() []byte {
+	if m != nil {
+		return m.DataInitialChunk
+	}
+	return nil
+}
+
+func (m *EthereumSignTx) GetDataLength() uint32 {
+	if m != nil && m.DataLength != nil {
+		return *m.DataLength
+	}
+	return 0
+}
+
+func (m *EthereumSignTx) GetChainId() uint32 {
+	if m != nil && m.ChainId != nil {
+		return *m.ChainId
+	}
+	return 0
+}
+
+func (m *EthereumSignTx) GetTxType() uint32 {
+	if m != nil && m.TxType != nil {
+		return *m.TxType
+	}
+	return 0
+}
+
+//*
+// Response: Device asks for more data from transaction payload, or returns the signature.
+// If data_length is set, device awaits that many more bytes of payload.
+// Otherwise, the signature_* fields contain the computed transaction signature. All three fields will be present.
+// @end
+// @next EthereumTxAck
+type EthereumTxRequest struct {
+	DataLength           *uint32  `protobuf:"varint,1,opt,name=data_length,json=dataLength" json:"data_length,omitempty"`
+	SignatureV           *uint32  `protobuf:"varint,2,opt,name=signature_v,json=signatureV" json:"signature_v,omitempty"`
+	SignatureR           []byte   `protobuf:"bytes,3,opt,name=signature_r,json=signatureR" json:"signature_r,omitempty"`
+	SignatureS           []byte   `protobuf:"bytes,4,opt,name=signature_s,json=signatureS" json:"signature_s,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *EthereumTxRequest) Reset()         { *m = EthereumTxRequest{} }
+func (m *EthereumTxRequest) String() string { return proto.CompactTextString(m) }
+func (*EthereumTxRequest) ProtoMessage()    {}
+func (*EthereumTxRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cb33f46ba915f15c, []int{5}
+}
+
+func (m *EthereumTxRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_EthereumTxRequest.Unmarshal(m, b)
+}
+func (m *EthereumTxRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_EthereumTxRequest.Marshal(b, m, deterministic)
+}
+func (m *EthereumTxRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_EthereumTxRequest.Merge(m, src)
+}
+func (m *EthereumTxRequest) XXX_Size() int {
+	return xxx_messageInfo_EthereumTxRequest.Size(m)
+}
+func (m *EthereumTxRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_EthereumTxRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EthereumTxRequest proto.InternalMessageInfo
+
+func (m *EthereumTxRequest) GetDataLength() uint32 {
+	if m != nil && m.DataLength != nil {
+		return *m.DataLength
+	}
+	return 0
+}
+
+func (m *EthereumTxRequest) GetSignatureV() uint32 {
+	if m != nil && m.SignatureV != nil {
+		return *m.SignatureV
+	}
+	return 0
+}
+
+func (m *EthereumTxRequest) GetSignatureR() []byte {
+	if m != nil {
+		return m.SignatureR
+	}
+	return nil
+}
+
+func (m *EthereumTxRequest) GetSignatureS() []byte {
+	if m != nil {
+		return m.SignatureS
+	}
+	return nil
+}
+
+//*
+// Request: Transaction payload data.
+// @next EthereumTxRequest
+type EthereumTxAck struct {
+	DataChunk            []byte   `protobuf:"bytes,1,opt,name=data_chunk,json=dataChunk" json:"data_chunk,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *EthereumTxAck) Reset()         { *m = EthereumTxAck{} }
+func (m *EthereumTxAck) String() string { return proto.CompactTextString(m) }
+func (*EthereumTxAck) ProtoMessage()    {}
+func (*EthereumTxAck) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cb33f46ba915f15c, []int{6}
+}
+
+func (m *EthereumTxAck) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_EthereumTxAck.Unmarshal(m, b)
+}
+func (m *EthereumTxAck) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_EthereumTxAck.Marshal(b, m, deterministic)
+}
+func (m *EthereumTxAck) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_EthereumTxAck.Merge(m, src)
+}
+func (m *EthereumTxAck) XXX_Size() int {
+	return xxx_messageInfo_EthereumTxAck.Size(m)
+}
+func (m *EthereumTxAck) XXX_DiscardUnknown() {
+	xxx_messageInfo_EthereumTxAck.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EthereumTxAck proto.InternalMessageInfo
+
+func (m *EthereumTxAck) GetDataChunk() []byte {
+	if m != nil {
+		return m.DataChunk
+	}
+	return nil
+}
+
+//*
+// Request: Ask device to sign message
+// @start
+// @next EthereumMessageSignature
+// @next Failure
+type EthereumSignMessage struct {
+	AddressN             []uint32 `protobuf:"varint,1,rep,name=address_n,json=addressN" json:"address_n,omitempty"`
+	Message              []byte   `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *EthereumSignMessage) Reset()         { *m = EthereumSignMessage{} }
+func (m *EthereumSignMessage) String() string { return proto.CompactTextString(m) }
+func (*EthereumSignMessage) ProtoMessage()    {}
+func (*EthereumSignMessage) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cb33f46ba915f15c, []int{7}
+}
+
+func (m *EthereumSignMessage) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_EthereumSignMessage.Unmarshal(m, b)
+}
+func (m *EthereumSignMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_EthereumSignMessage.Marshal(b, m, deterministic)
+}
+func (m *EthereumSignMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_EthereumSignMessage.Merge(m, src)
+}
+func (m *EthereumSignMessage) XXX_Size() int {
+	return xxx_messageInfo_EthereumSignMessage.Size(m)
+}
+func (m *EthereumSignMessage) XXX_DiscardUnknown() {
+	xxx_messageInfo_EthereumSignMessage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EthereumSignMessage proto.InternalMessageInfo
+
+func (m *EthereumSignMessage) GetAddressN() []uint32 {
+	if m != nil {
+		return m.AddressN
+	}
+	return nil
+}
+
+func (m *EthereumSignMessage) GetMessage() []byte {
+	if m != nil {
+		return m.Message
+	}
+	return nil
+}
+
+//*
+// Response: Signed message
+// @end
+type EthereumMessageSignature struct {
+	AddressBin           []byte   `protobuf:"bytes,1,opt,name=addressBin" json:"addressBin,omitempty"`
+	Signature            []byte   `protobuf:"bytes,2,opt,name=signature" json:"signature,omitempty"`
+	AddressHex           *string  `protobuf:"bytes,3,opt,name=addressHex" json:"addressHex,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *EthereumMessageSignature) Reset()         { *m = EthereumMessageSignature{} }
+func (m *EthereumMessageSignature) String() string { return proto.CompactTextString(m) }
+func (*EthereumMessageSignature) ProtoMessage()    {}
+func (*EthereumMessageSignature) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cb33f46ba915f15c, []int{8}
+}
+
+func (m *EthereumMessageSignature) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_EthereumMessageSignature.Unmarshal(m, b)
+}
+func (m *EthereumMessageSignature) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_EthereumMessageSignature.Marshal(b, m, deterministic)
+}
+func (m *EthereumMessageSignature) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_EthereumMessageSignature.Merge(m, src)
+}
+func (m *EthereumMessageSignature) XXX_Size() int {
+	return xxx_messageInfo_EthereumMessageSignature.Size(m)
+}
+func (m *EthereumMessageSignature) XXX_DiscardUnknown() {
+	xxx_messageInfo_EthereumMessageSignature.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EthereumMessageSignature proto.InternalMessageInfo
+
+func (m *EthereumMessageSignature) GetAddressBin() []byte {
+	if m != nil {
+		return m.AddressBin
+	}
+	return nil
+}
+
+func (m *EthereumMessageSignature) GetSignature() []byte {
+	if m != nil {
+		return m.Signature
+	}
+	return nil
+}
+
+func (m *EthereumMessageSignature) GetAddressHex() string {
+	if m != nil && m.AddressHex != nil {
+		return *m.AddressHex
+	}
+	return ""
+}
+
+//*
+// Request: Ask device to verify message
+// @start
+// @next Success
+// @next Failure
+type EthereumVerifyMessage struct {
+	AddressBin           []byte   `protobuf:"bytes,1,opt,name=addressBin" json:"addressBin,omitempty"`
+	Signature            []byte   `protobuf:"bytes,2,opt,name=signature" json:"signature,omitempty"`
+	Message              []byte   `protobuf:"bytes,3,opt,name=message" json:"message,omitempty"`
+	AddressHex           *string  `protobuf:"bytes,4,opt,name=addressHex" json:"addressHex,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *EthereumVerifyMessage) Reset()         { *m = EthereumVerifyMessage{} }
+func (m *EthereumVerifyMessage) String() string { return proto.CompactTextString(m) }
+func (*EthereumVerifyMessage) ProtoMessage()    {}
+func (*EthereumVerifyMessage) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cb33f46ba915f15c, []int{9}
+}
+
+func (m *EthereumVerifyMessage) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_EthereumVerifyMessage.Unmarshal(m, b)
+}
+func (m *EthereumVerifyMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_EthereumVerifyMessage.Marshal(b, m, deterministic)
+}
+func (m *EthereumVerifyMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_EthereumVerifyMessage.Merge(m, src)
+}
+func (m *EthereumVerifyMessage) XXX_Size() int {
+	return xxx_messageInfo_EthereumVerifyMessage.Size(m)
+}
+func (m *EthereumVerifyMessage) XXX_DiscardUnknown() {
+	xxx_messageInfo_EthereumVerifyMessage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EthereumVerifyMessage proto.InternalMessageInfo
+
+func (m *EthereumVerifyMessage) GetAddressBin() []byte {
+	if m != nil {
+		return m.AddressBin
+	}
+	return nil
+}
+
+func (m *EthereumVerifyMessage) GetSignature() []byte {
+	if m != nil {
+		return m.Signature
+	}
+	return nil
+}
+
+func (m *EthereumVerifyMessage) GetMessage() []byte {
+	if m != nil {
+		return m.Message
+	}
+	return nil
+}
+
+func (m *EthereumVerifyMessage) GetAddressHex() string {
+	if m != nil && m.AddressHex != nil {
+		return *m.AddressHex
+	}
+	return ""
+}
+
+func init() {
+	proto.RegisterType((*EthereumGetPublicKey)(nil), "hw.trezor.messages.ethereum.EthereumGetPublicKey")
+	proto.RegisterType((*EthereumPublicKey)(nil), "hw.trezor.messages.ethereum.EthereumPublicKey")
+	proto.RegisterType((*EthereumGetAddress)(nil), "hw.trezor.messages.ethereum.EthereumGetAddress")
+	proto.RegisterType((*EthereumAddress)(nil), "hw.trezor.messages.ethereum.EthereumAddress")
+	proto.RegisterType((*EthereumSignTx)(nil), "hw.trezor.messages.ethereum.EthereumSignTx")
+	proto.RegisterType((*EthereumTxRequest)(nil), "hw.trezor.messages.ethereum.EthereumTxRequest")
+	proto.RegisterType((*EthereumTxAck)(nil), "hw.trezor.messages.ethereum.EthereumTxAck")
+	proto.RegisterType((*EthereumSignMessage)(nil), "hw.trezor.messages.ethereum.EthereumSignMessage")
+	proto.RegisterType((*EthereumMessageSignature)(nil), "hw.trezor.messages.ethereum.EthereumMessageSignature")
+	proto.RegisterType((*EthereumVerifyMessage)(nil), "hw.trezor.messages.ethereum.EthereumVerifyMessage")
+}
+
+func init() { proto.RegisterFile("messages-ethereum.proto", fileDescriptor_cb33f46ba915f15c) }
+
+var fileDescriptor_cb33f46ba915f15c = []byte{
+	// 593 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x54, 0x4d, 0x6f, 0xd3, 0x40,
+	0x10, 0x95, 0x9b, 0xb4, 0x49, 0x26, 0x0d, 0x1f, 0xa6, 0x55, 0x17, 0x0a, 0x34, 0x18, 0x21, 0xe5,
+	0x00, 0x3e, 0x70, 0x43, 0xe2, 0xd2, 0x52, 0x44, 0x2b, 0x4a, 0x55, 0xdc, 0xa8, 0x57, 0x6b, 0x63,
+	0x6f, 0xe3, 0x55, 0x9d, 0xdd, 0xe0, 0x5d, 0xb7, 0x0e, 0x7f, 0x82, 0x23, 0xff, 0x87, 0x5f, 0x86,
+	0xf6, 0x2b, 0x71, 0x52, 0x54, 0x0e, 0xbd, 0x65, 0xde, 0xbc, 0x7d, 0xf3, 0x66, 0xf4, 0x62, 0xd8,
+	0x99, 0x10, 0x21, 0xf0, 0x98, 0x88, 0x77, 0x44, 0x66, 0xa4, 0x20, 0xe5, 0x24, 0x9c, 0x16, 0x5c,
+	0x72, 0x7f, 0x37, 0xbb, 0x09, 0x65, 0x41, 0x7e, 0xf2, 0x22, 0x74, 0x94, 0xd0, 0x51, 0x9e, 0x6d,
+	0xcf, 0x5f, 0x25, 0x7c, 0x32, 0xe1, 0xcc, 0xbc, 0x09, 0x2e, 0x60, 0xeb, 0xb3, 0xa5, 0x7c, 0x21,
+	0xf2, 0xac, 0x1c, 0xe5, 0x34, 0xf9, 0x4a, 0x66, 0xfe, 0x2e, 0x74, 0x70, 0x9a, 0x16, 0x44, 0x88,
+	0x98, 0x21, 0xaf, 0xdf, 0x18, 0xf4, 0xa2, 0xb6, 0x05, 0x4e, 0xfd, 0x57, 0xb0, 0x29, 0x32, 0x7e,
+	0x13, 0xa7, 0x54, 0x4c, 0x73, 0x3c, 0x43, 0x6b, 0x7d, 0x6f, 0xd0, 0x8e, 0xba, 0x0a, 0x3b, 0x34,
+	0x50, 0x30, 0x82, 0xc7, 0x4e, 0x77, 0x21, 0xfa, 0x01, 0x9a, 0x8c, 0xa7, 0x04, 0x79, 0x7d, 0x6f,
+	0xd0, 0x7d, 0xff, 0x26, 0xfc, 0x87, 0x5f, 0x6b, 0xee, 0xe8, 0xf0, 0x94, 0xa7, 0x64, 0x38, 0x9b,
+	0x92, 0x48, 0x3f, 0xf1, 0x7d, 0x68, 0x56, 0xd3, 0x72, 0xa4, 0x47, 0x75, 0x22, 0xfd, 0x3b, 0x18,
+	0x82, 0x5f, 0xf3, 0xbe, 0x6f, 0xdc, 0xdd, 0xdb, 0xf9, 0x77, 0x78, 0xe8, 0x54, 0x9d, 0xe4, 0x4b,
+	0x00, 0xab, 0x70, 0x40, 0x99, 0x76, 0xbf, 0x19, 0xd5, 0x90, 0x5a, 0xff, 0x88, 0x54, 0xd6, 0x62,
+	0x0d, 0x09, 0xfe, 0xac, 0xc1, 0x03, 0xa7, 0x79, 0x4e, 0xc7, 0x6c, 0x58, 0xdd, 0xed, 0x72, 0x0b,
+	0xd6, 0x19, 0x67, 0x09, 0xd1, 0x52, 0x9b, 0x91, 0x29, 0xd4, 0x93, 0x31, 0x16, 0xf1, 0xb4, 0xa0,
+	0x09, 0x41, 0x0d, 0xdd, 0x69, 0x8f, 0xb1, 0x38, 0x53, 0xb5, 0x6b, 0xe6, 0x74, 0x42, 0x25, 0x6a,
+	0xce, 0x9b, 0x27, 0xaa, 0x56, 0x7a, 0x92, 0x2b, 0xeb, 0xeb, 0x46, 0x4f, 0x17, 0x06, 0x55, 0x86,
+	0xbb, 0xda, 0xb0, 0x29, 0x14, 0x7a, 0x8d, 0xf3, 0x92, 0xa0, 0x0d, 0xc3, 0xd5, 0x85, 0xff, 0x16,
+	0xfc, 0x14, 0x4b, 0x1c, 0x53, 0x46, 0x25, 0xc5, 0x79, 0x9c, 0x64, 0x25, 0xbb, 0x42, 0x2d, 0x4d,
+	0x79, 0xa4, 0x3a, 0xc7, 0xa6, 0xf1, 0x49, 0xe1, 0xfe, 0x1e, 0x74, 0x35, 0x3b, 0x27, 0x6c, 0x2c,
+	0x33, 0xd4, 0xee, 0x7b, 0x83, 0x5e, 0x04, 0x0a, 0x3a, 0xd1, 0x88, 0xff, 0x14, 0xda, 0x49, 0x86,
+	0x29, 0x8b, 0x69, 0x8a, 0x3a, 0xba, 0xdb, 0xd2, 0xf5, 0x71, 0xea, 0xef, 0x40, 0x4b, 0x56, 0xb1,
+	0x9c, 0x4d, 0x09, 0x02, 0xdd, 0xd9, 0x90, 0x95, 0xca, 0x41, 0xf0, 0xdb, 0x5b, 0x44, 0x6a, 0x58,
+	0x45, 0xe4, 0x47, 0x49, 0x84, 0x5c, 0x1d, 0xe5, 0xdd, 0x1a, 0xb5, 0x07, 0x5d, 0x41, 0xc7, 0x0c,
+	0xcb, 0xb2, 0x20, 0xf1, 0xb5, 0xbe, 0x68, 0x2f, 0x82, 0x39, 0x74, 0xb1, 0x4c, 0x28, 0xec, 0x61,
+	0x17, 0x84, 0x68, 0x99, 0x20, 0xec, 0x71, 0x17, 0x84, 0xf3, 0x20, 0x84, 0xde, 0xc2, 0xd8, 0x7e,
+	0x72, 0xe5, 0xbf, 0x00, 0xed, 0xc0, 0x5e, 0xc9, 0xe4, 0xa5, 0xa3, 0x10, 0x7d, 0x9e, 0xe0, 0x04,
+	0x9e, 0xd4, 0xd3, 0xf0, 0xcd, 0x64, 0xff, 0xee, 0x48, 0x20, 0x68, 0xd9, 0xff, 0x88, 0x0d, 0x85,
+	0x2b, 0x83, 0x0a, 0x90, 0x53, 0xb3, 0x4a, 0xe7, 0xce, 0xda, 0x7f, 0x83, 0xfb, 0x1c, 0x3a, 0xf3,
+	0x3d, 0xac, 0xee, 0x02, 0x58, 0x89, 0x75, 0xe3, 0x56, 0xac, 0x7f, 0x79, 0xb0, 0xed, 0x46, 0x5f,
+	0x90, 0x82, 0x5e, 0xce, 0xdc, 0x2a, 0xf7, 0x9b, 0x5b, 0xdb, 0xb5, 0xb1, 0xb4, 0xeb, 0x8a, 0xa3,
+	0xe6, 0xaa, 0xa3, 0x83, 0x8f, 0xf0, 0x3a, 0xe1, 0x93, 0x50, 0x60, 0xc9, 0x45, 0x46, 0x73, 0x3c,
+	0x12, 0xee, 0x03, 0x93, 0xd3, 0x91, 0xf9, 0xe2, 0x8d, 0xca, 0xcb, 0x83, 0xed, 0xa1, 0x06, 0xad,
+	0x5b, 0xb7, 0xc2, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x8a, 0xce, 0x81, 0xc8, 0x59, 0x05, 0x00,
+	0x00,
+}
diff --git a/accounts/usbwallet/trezor/messages-ethereum.proto b/accounts/usbwallet/trezor/messages-ethereum.proto
new file mode 100644
index 000000000..096bed2e4
--- /dev/null
+++ b/accounts/usbwallet/trezor/messages-ethereum.proto
@@ -0,0 +1,131 @@
+// This file originates from the SatoshiLabs Trezor `common` repository at:
+//   https://github.com/trezor/trezor-common/blob/master/protob/messages-ethereum.proto
+// dated 28.05.2019, commit 893fd219d4a01bcffa0cd9cfa631856371ec5aa9.
+
+syntax = "proto2";
+package hw.trezor.messages.ethereum;
+
+// Sugar for easier handling in Java
+option java_package = "com.satoshilabs.trezor.lib.protobuf";
+option java_outer_classname = "TrezorMessageEthereum";
+
+import "messages-common.proto";
+
+
+/**
+ * Request: Ask device for public key corresponding to address_n path
+ * @start
+ * @next EthereumPublicKey
+ * @next Failure
+ */
+message EthereumGetPublicKey {
+    repeated uint32 address_n = 1;                                      // BIP-32 path to derive the key from master node
+    optional bool show_display = 2;                                     // optionally show on display before sending the result
+}
+
+/**
+ * Response: Contains public key derived from device private seed
+ * @end
+ */
+message EthereumPublicKey {
+    optional hw.trezor.messages.common.HDNodeType node = 1;        // BIP32 public node
+    optional string xpub = 2;        // serialized form of public node
+}
+
+/**
+ * Request: Ask device for Ethereum address corresponding to address_n path
+ * @start
+ * @next EthereumAddress
+ * @next Failure
+ */
+message EthereumGetAddress {
+    repeated uint32 address_n = 1;  // BIP-32 path to derive the key from master node
+    optional bool show_display = 2; // optionally show on display before sending the result
+}
+
+/**
+ * Response: Contains an Ethereum address derived from device private seed
+ * @end
+ */
+message EthereumAddress {
+    optional bytes  addressBin = 1;    // Ethereum address as 20 bytes (legacy firmwares)
+    optional string addressHex = 2;    // Ethereum address as hex string (newer firmwares)
+}
+
+/**
+ * Request: Ask device to sign transaction
+ * All fields are optional from the protocol's point of view. Each field defaults to value `0` if missing.
+ * Note: the first at most 1024 bytes of data MUST be transmitted as part of this message.
+ * @start
+ * @next EthereumTxRequest
+ * @next Failure
+ */
+message EthereumSignTx {
+    repeated uint32 address_n = 1;          // BIP-32 path to derive the key from master node
+    optional bytes nonce = 2;               // <=256 bit unsigned big endian
+    optional bytes gas_price = 3;           // <=256 bit unsigned big endian (in wei)
+    optional bytes gas_limit = 4;           // <=256 bit unsigned big endian
+    optional bytes toBin = 5;               // recipient address (20 bytes, legacy firmware)
+    optional string toHex = 11;             // recipient address (hex string, newer firmware)
+    optional bytes value = 6;               // <=256 bit unsigned big endian (in wei)
+    optional bytes data_initial_chunk = 7;  // The initial data chunk (<= 1024 bytes)
+    optional uint32 data_length = 8;        // Length of transaction payload
+    optional uint32 chain_id = 9;           // Chain Id for EIP 155
+    optional uint32 tx_type = 10;           // (only for Wanchain)
+}
+
+/**
+ * Response: Device asks for more data from transaction payload, or returns the signature.
+ * If data_length is set, device awaits that many more bytes of payload.
+ * Otherwise, the signature_* fields contain the computed transaction signature. All three fields will be present.
+ * @end
+ * @next EthereumTxAck
+ */
+message EthereumTxRequest {
+    optional uint32 data_length = 1;    // Number of bytes being requested (<= 1024)
+    optional uint32 signature_v = 2;    // Computed signature (recovery parameter, limited to 27 or 28)
+    optional bytes signature_r = 3;     // Computed signature R component (256 bit)
+    optional bytes signature_s = 4;     // Computed signature S component (256 bit)
+}
+
+/**
+ * Request: Transaction payload data.
+ * @next EthereumTxRequest
+ */
+message EthereumTxAck {
+    optional bytes data_chunk = 1;  // Bytes from transaction payload (<= 1024 bytes)
+}
+
+/**
+ * Request: Ask device to sign message
+ * @start
+ * @next EthereumMessageSignature
+ * @next Failure
+ */
+message EthereumSignMessage {
+    repeated uint32 address_n = 1;  // BIP-32 path to derive the key from master node
+    optional bytes message = 2;     // message to be signed
+}
+
+/**
+ * Response: Signed message
+ * @end
+ */
+message EthereumMessageSignature {
+    optional bytes addressBin = 1;     // address used to sign the message (20 bytes, legacy firmware)
+    optional bytes signature = 2;      // signature of the message
+    optional string addressHex = 3;    // address used to sign the message (hex string, newer firmware)
+}
+
+/**
+ * Request: Ask device to verify message
+ * @start
+ * @next Success
+ * @next Failure
+ */
+message EthereumVerifyMessage {
+    optional bytes addressBin = 1;  // address to verify (20 bytes, legacy firmware)
+    optional bytes signature = 2;   // signature to verify
+    optional bytes message = 3;     // message to verify
+    optional string addressHex = 4; // address to verify (hex string, newer firmware)
+}
diff --git a/accounts/usbwallet/trezor/messages-management.pb.go b/accounts/usbwallet/trezor/messages-management.pb.go
new file mode 100644
index 000000000..f5c872f1f
--- /dev/null
+++ b/accounts/usbwallet/trezor/messages-management.pb.go
@@ -0,0 +1,1621 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: messages-management.proto
+
+package trezor
+
+import (
+	fmt "fmt"
+	math "math"
+
+	proto "github.com/golang/protobuf/proto"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
+
+//*
+// Structure representing passphrase source
+type ApplySettings_PassphraseSourceType int32
+
+const (
+	ApplySettings_ASK    ApplySettings_PassphraseSourceType = 0
+	ApplySettings_DEVICE ApplySettings_PassphraseSourceType = 1
+	ApplySettings_HOST   ApplySettings_PassphraseSourceType = 2
+)
+
+var ApplySettings_PassphraseSourceType_name = map[int32]string{
+	0: "ASK",
+	1: "DEVICE",
+	2: "HOST",
+}
+
+var ApplySettings_PassphraseSourceType_value = map[string]int32{
+	"ASK":    0,
+	"DEVICE": 1,
+	"HOST":   2,
+}
+
+func (x ApplySettings_PassphraseSourceType) Enum() *ApplySettings_PassphraseSourceType {
+	p := new(ApplySettings_PassphraseSourceType)
+	*p = x
+	return p
+}
+
+func (x ApplySettings_PassphraseSourceType) String() string {
+	return proto.EnumName(ApplySettings_PassphraseSourceType_name, int32(x))
+}
+
+func (x *ApplySettings_PassphraseSourceType) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(ApplySettings_PassphraseSourceType_value, data, "ApplySettings_PassphraseSourceType")
+	if err != nil {
+		return err
+	}
+	*x = ApplySettings_PassphraseSourceType(value)
+	return nil
+}
+
+func (ApplySettings_PassphraseSourceType) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_0c720c20d27aa029, []int{4, 0}
+}
+
+//*
+// Type of recovery procedure. These should be used as bitmask, e.g.,
+// `RecoveryDeviceType_ScrambledWords | RecoveryDeviceType_Matrix`
+// listing every method supported by the host computer.
+//
+// Note that ScrambledWords must be supported by every implementation
+// for backward compatibility; there is no way to not support it.
+type RecoveryDevice_RecoveryDeviceType int32
+
+const (
+	// use powers of two when extending this field
+	RecoveryDevice_RecoveryDeviceType_ScrambledWords RecoveryDevice_RecoveryDeviceType = 0
+	RecoveryDevice_RecoveryDeviceType_Matrix         RecoveryDevice_RecoveryDeviceType = 1
+)
+
+var RecoveryDevice_RecoveryDeviceType_name = map[int32]string{
+	0: "RecoveryDeviceType_ScrambledWords",
+	1: "RecoveryDeviceType_Matrix",
+}
+
+var RecoveryDevice_RecoveryDeviceType_value = map[string]int32{
+	"RecoveryDeviceType_ScrambledWords": 0,
+	"RecoveryDeviceType_Matrix":         1,
+}
+
+func (x RecoveryDevice_RecoveryDeviceType) Enum() *RecoveryDevice_RecoveryDeviceType {
+	p := new(RecoveryDevice_RecoveryDeviceType)
+	*p = x
+	return p
+}
+
+func (x RecoveryDevice_RecoveryDeviceType) String() string {
+	return proto.EnumName(RecoveryDevice_RecoveryDeviceType_name, int32(x))
+}
+
+func (x *RecoveryDevice_RecoveryDeviceType) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(RecoveryDevice_RecoveryDeviceType_value, data, "RecoveryDevice_RecoveryDeviceType")
+	if err != nil {
+		return err
+	}
+	*x = RecoveryDevice_RecoveryDeviceType(value)
+	return nil
+}
+
+func (RecoveryDevice_RecoveryDeviceType) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_0c720c20d27aa029, []int{17, 0}
+}
+
+//*
+// Type of Recovery Word request
+type WordRequest_WordRequestType int32
+
+const (
+	WordRequest_WordRequestType_Plain   WordRequest_WordRequestType = 0
+	WordRequest_WordRequestType_Matrix9 WordRequest_WordRequestType = 1
+	WordRequest_WordRequestType_Matrix6 WordRequest_WordRequestType = 2
+)
+
+var WordRequest_WordRequestType_name = map[int32]string{
+	0: "WordRequestType_Plain",
+	1: "WordRequestType_Matrix9",
+	2: "WordRequestType_Matrix6",
+}
+
+var WordRequest_WordRequestType_value = map[string]int32{
+	"WordRequestType_Plain":   0,
+	"WordRequestType_Matrix9": 1,
+	"WordRequestType_Matrix6": 2,
+}
+
+func (x WordRequest_WordRequestType) Enum() *WordRequest_WordRequestType {
+	p := new(WordRequest_WordRequestType)
+	*p = x
+	return p
+}
+
+func (x WordRequest_WordRequestType) String() string {
+	return proto.EnumName(WordRequest_WordRequestType_name, int32(x))
+}
+
+func (x *WordRequest_WordRequestType) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(WordRequest_WordRequestType_value, data, "WordRequest_WordRequestType")
+	if err != nil {
+		return err
+	}
+	*x = WordRequest_WordRequestType(value)
+	return nil
+}
+
+func (WordRequest_WordRequestType) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_0c720c20d27aa029, []int{18, 0}
+}
+
+//*
+// Request: Reset device to default state and ask for device details
+// @start
+// @next Features
+type Initialize struct {
+	State                []byte   `protobuf:"bytes,1,opt,name=state" json:"state,omitempty"`
+	SkipPassphrase       *bool    `protobuf:"varint,2,opt,name=skip_passphrase,json=skipPassphrase" json:"skip_passphrase,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Initialize) Reset()         { *m = Initialize{} }
+func (m *Initialize) String() string { return proto.CompactTextString(m) }
+func (*Initialize) ProtoMessage()    {}
+func (*Initialize) Descriptor() ([]byte, []int) {
+	return fileDescriptor_0c720c20d27aa029, []int{0}
+}
+
+func (m *Initialize) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Initialize.Unmarshal(m, b)
+}
+func (m *Initialize) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Initialize.Marshal(b, m, deterministic)
+}
+func (m *Initialize) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Initialize.Merge(m, src)
+}
+func (m *Initialize) XXX_Size() int {
+	return xxx_messageInfo_Initialize.Size(m)
+}
+func (m *Initialize) XXX_DiscardUnknown() {
+	xxx_messageInfo_Initialize.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Initialize proto.InternalMessageInfo
+
+func (m *Initialize) GetState() []byte {
+	if m != nil {
+		return m.State
+	}
+	return nil
+}
+
+func (m *Initialize) GetSkipPassphrase() bool {
+	if m != nil && m.SkipPassphrase != nil {
+		return *m.SkipPassphrase
+	}
+	return false
+}
+
+//*
+// Request: Ask for device details (no device reset)
+// @start
+// @next Features
+type GetFeatures struct {
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetFeatures) Reset()         { *m = GetFeatures{} }
+func (m *GetFeatures) String() string { return proto.CompactTextString(m) }
+func (*GetFeatures) ProtoMessage()    {}
+func (*GetFeatures) Descriptor() ([]byte, []int) {
+	return fileDescriptor_0c720c20d27aa029, []int{1}
+}
+
+func (m *GetFeatures) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_GetFeatures.Unmarshal(m, b)
+}
+func (m *GetFeatures) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_GetFeatures.Marshal(b, m, deterministic)
+}
+func (m *GetFeatures) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GetFeatures.Merge(m, src)
+}
+func (m *GetFeatures) XXX_Size() int {
+	return xxx_messageInfo_GetFeatures.Size(m)
+}
+func (m *GetFeatures) XXX_DiscardUnknown() {
+	xxx_messageInfo_GetFeatures.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetFeatures proto.InternalMessageInfo
+
+//*
+// Response: Reports various information about the device
+// @end
+type Features struct {
+	Vendor               *string  `protobuf:"bytes,1,opt,name=vendor" json:"vendor,omitempty"`
+	MajorVersion         *uint32  `protobuf:"varint,2,opt,name=major_version,json=majorVersion" json:"major_version,omitempty"`
+	MinorVersion         *uint32  `protobuf:"varint,3,opt,name=minor_version,json=minorVersion" json:"minor_version,omitempty"`
+	PatchVersion         *uint32  `protobuf:"varint,4,opt,name=patch_version,json=patchVersion" json:"patch_version,omitempty"`
+	BootloaderMode       *bool    `protobuf:"varint,5,opt,name=bootloader_mode,json=bootloaderMode" json:"bootloader_mode,omitempty"`
+	DeviceId             *string  `protobuf:"bytes,6,opt,name=device_id,json=deviceId" json:"device_id,omitempty"`
+	PinProtection        *bool    `protobuf:"varint,7,opt,name=pin_protection,json=pinProtection" json:"pin_protection,omitempty"`
+	PassphraseProtection *bool    `protobuf:"varint,8,opt,name=passphrase_protection,json=passphraseProtection" json:"passphrase_protection,omitempty"`
+	Language             *string  `protobuf:"bytes,9,opt,name=language" json:"language,omitempty"`
+	Label                *string  `protobuf:"bytes,10,opt,name=label" json:"label,omitempty"`
+	Initialized          *bool    `protobuf:"varint,12,opt,name=initialized" json:"initialized,omitempty"`
+	Revision             []byte   `protobuf:"bytes,13,opt,name=revision" json:"revision,omitempty"`
+	BootloaderHash       []byte   `protobuf:"bytes,14,opt,name=bootloader_hash,json=bootloaderHash" json:"bootloader_hash,omitempty"`
+	Imported             *bool    `protobuf:"varint,15,opt,name=imported" json:"imported,omitempty"`
+	PinCached            *bool    `protobuf:"varint,16,opt,name=pin_cached,json=pinCached" json:"pin_cached,omitempty"`
+	PassphraseCached     *bool    `protobuf:"varint,17,opt,name=passphrase_cached,json=passphraseCached" json:"passphrase_cached,omitempty"`
+	FirmwarePresent      *bool    `protobuf:"varint,18,opt,name=firmware_present,json=firmwarePresent" json:"firmware_present,omitempty"`
+	NeedsBackup          *bool    `protobuf:"varint,19,opt,name=needs_backup,json=needsBackup" json:"needs_backup,omitempty"`
+	Flags                *uint32  `protobuf:"varint,20,opt,name=flags" json:"flags,omitempty"`
+	Model                *string  `protobuf:"bytes,21,opt,name=model" json:"model,omitempty"`
+	FwMajor              *uint32  `protobuf:"varint,22,opt,name=fw_major,json=fwMajor" json:"fw_major,omitempty"`
+	FwMinor              *uint32  `protobuf:"varint,23,opt,name=fw_minor,json=fwMinor" json:"fw_minor,omitempty"`
+	FwPatch              *uint32  `protobuf:"varint,24,opt,name=fw_patch,json=fwPatch" json:"fw_patch,omitempty"`
+	FwVendor             *string  `protobuf:"bytes,25,opt,name=fw_vendor,json=fwVendor" json:"fw_vendor,omitempty"`
+	FwVendorKeys         []byte   `protobuf:"bytes,26,opt,name=fw_vendor_keys,json=fwVendorKeys" json:"fw_vendor_keys,omitempty"`
+	UnfinishedBackup     *bool    `protobuf:"varint,27,opt,name=unfinished_backup,json=unfinishedBackup" json:"unfinished_backup,omitempty"`
+	NoBackup             *bool    `protobuf:"varint,28,opt,name=no_backup,json=noBackup" json:"no_backup,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Features) Reset()         { *m = Features{} }
+func (m *Features) String() string { return proto.CompactTextString(m) }
+func (*Features) ProtoMessage()    {}
+func (*Features) Descriptor() ([]byte, []int) {
+	return fileDescriptor_0c720c20d27aa029, []int{2}
+}
+
+func (m *Features) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Features.Unmarshal(m, b)
+}
+func (m *Features) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Features.Marshal(b, m, deterministic)
+}
+func (m *Features) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Features.Merge(m, src)
+}
+func (m *Features) XXX_Size() int {
+	return xxx_messageInfo_Features.Size(m)
+}
+func (m *Features) XXX_DiscardUnknown() {
+	xxx_messageInfo_Features.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Features proto.InternalMessageInfo
+
+func (m *Features) GetVendor() string {
+	if m != nil && m.Vendor != nil {
+		return *m.Vendor
+	}
+	return ""
+}
+
+func (m *Features) GetMajorVersion() uint32 {
+	if m != nil && m.MajorVersion != nil {
+		return *m.MajorVersion
+	}
+	return 0
+}
+
+func (m *Features) GetMinorVersion() uint32 {
+	if m != nil && m.MinorVersion != nil {
+		return *m.MinorVersion
+	}
+	return 0
+}
+
+func (m *Features) GetPatchVersion() uint32 {
+	if m != nil && m.PatchVersion != nil {
+		return *m.PatchVersion
+	}
+	return 0
+}
+
+func (m *Features) GetBootloaderMode() bool {
+	if m != nil && m.BootloaderMode != nil {
+		return *m.BootloaderMode
+	}
+	return false
+}
+
+func (m *Features) GetDeviceId() string {
+	if m != nil && m.DeviceId != nil {
+		return *m.DeviceId
+	}
+	return ""
+}
+
+func (m *Features) GetPinProtection() bool {
+	if m != nil && m.PinProtection != nil {
+		return *m.PinProtection
+	}
+	return false
+}
+
+func (m *Features) GetPassphraseProtection() bool {
+	if m != nil && m.PassphraseProtection != nil {
+		return *m.PassphraseProtection
+	}
+	return false
+}
+
+func (m *Features) GetLanguage() string {
+	if m != nil && m.Language != nil {
+		return *m.Language
+	}
+	return ""
+}
+
+func (m *Features) GetLabel() string {
+	if m != nil && m.Label != nil {
+		return *m.Label
+	}
+	return ""
+}
+
+func (m *Features) GetInitialized() bool {
+	if m != nil && m.Initialized != nil {
+		return *m.Initialized
+	}
+	return false
+}
+
+func (m *Features) GetRevision() []byte {
+	if m != nil {
+		return m.Revision
+	}
+	return nil
+}
+
+func (m *Features) GetBootloaderHash() []byte {
+	if m != nil {
+		return m.BootloaderHash
+	}
+	return nil
+}
+
+func (m *Features) GetImported() bool {
+	if m != nil && m.Imported != nil {
+		return *m.Imported
+	}
+	return false
+}
+
+func (m *Features) GetPinCached() bool {
+	if m != nil && m.PinCached != nil {
+		return *m.PinCached
+	}
+	return false
+}
+
+func (m *Features) GetPassphraseCached() bool {
+	if m != nil && m.PassphraseCached != nil {
+		return *m.PassphraseCached
+	}
+	return false
+}
+
+func (m *Features) GetFirmwarePresent() bool {
+	if m != nil && m.FirmwarePresent != nil {
+		return *m.FirmwarePresent
+	}
+	return false
+}
+
+func (m *Features) GetNeedsBackup() bool {
+	if m != nil && m.NeedsBackup != nil {
+		return *m.NeedsBackup
+	}
+	return false
+}
+
+func (m *Features) GetFlags() uint32 {
+	if m != nil && m.Flags != nil {
+		return *m.Flags
+	}
+	return 0
+}
+
+func (m *Features) GetModel() string {
+	if m != nil && m.Model != nil {
+		return *m.Model
+	}
+	return ""
+}
+
+func (m *Features) GetFwMajor() uint32 {
+	if m != nil && m.FwMajor != nil {
+		return *m.FwMajor
+	}
+	return 0
+}
+
+func (m *Features) GetFwMinor() uint32 {
+	if m != nil && m.FwMinor != nil {
+		return *m.FwMinor
+	}
+	return 0
+}
+
+func (m *Features) GetFwPatch() uint32 {
+	if m != nil && m.FwPatch != nil {
+		return *m.FwPatch
+	}
+	return 0
+}
+
+func (m *Features) GetFwVendor() string {
+	if m != nil && m.FwVendor != nil {
+		return *m.FwVendor
+	}
+	return ""
+}
+
+func (m *Features) GetFwVendorKeys() []byte {
+	if m != nil {
+		return m.FwVendorKeys
+	}
+	return nil
+}
+
+func (m *Features) GetUnfinishedBackup() bool {
+	if m != nil && m.UnfinishedBackup != nil {
+		return *m.UnfinishedBackup
+	}
+	return false
+}
+
+func (m *Features) GetNoBackup() bool {
+	if m != nil && m.NoBackup != nil {
+		return *m.NoBackup
+	}
+	return false
+}
+
+//*
+// Request: clear session (removes cached PIN, passphrase, etc).
+// @start
+// @next Success
+type ClearSession struct {
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ClearSession) Reset()         { *m = ClearSession{} }
+func (m *ClearSession) String() string { return proto.CompactTextString(m) }
+func (*ClearSession) ProtoMessage()    {}
+func (*ClearSession) Descriptor() ([]byte, []int) {
+	return fileDescriptor_0c720c20d27aa029, []int{3}
+}
+
+func (m *ClearSession) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ClearSession.Unmarshal(m, b)
+}
+func (m *ClearSession) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ClearSession.Marshal(b, m, deterministic)
+}
+func (m *ClearSession) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ClearSession.Merge(m, src)
+}
+func (m *ClearSession) XXX_Size() int {
+	return xxx_messageInfo_ClearSession.Size(m)
+}
+func (m *ClearSession) XXX_DiscardUnknown() {
+	xxx_messageInfo_ClearSession.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ClearSession proto.InternalMessageInfo
+
+//*
+// Request: change language and/or label of the device
+// @start
+// @next Success
+// @next Failure
+type ApplySettings struct {
+	Language             *string                             `protobuf:"bytes,1,opt,name=language" json:"language,omitempty"`
+	Label                *string                             `protobuf:"bytes,2,opt,name=label" json:"label,omitempty"`
+	UsePassphrase        *bool                               `protobuf:"varint,3,opt,name=use_passphrase,json=usePassphrase" json:"use_passphrase,omitempty"`
+	Homescreen           []byte                              `protobuf:"bytes,4,opt,name=homescreen" json:"homescreen,omitempty"`
+	PassphraseSource     *ApplySettings_PassphraseSourceType `protobuf:"varint,5,opt,name=passphrase_source,json=passphraseSource,enum=hw.trezor.messages.management.ApplySettings_PassphraseSourceType" json:"passphrase_source,omitempty"`
+	AutoLockDelayMs      *uint32                             `protobuf:"varint,6,opt,name=auto_lock_delay_ms,json=autoLockDelayMs" json:"auto_lock_delay_ms,omitempty"`
+	DisplayRotation      *uint32                             `protobuf:"varint,7,opt,name=display_rotation,json=displayRotation" json:"display_rotation,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}                            `json:"-"`
+	XXX_unrecognized     []byte                              `json:"-"`
+	XXX_sizecache        int32                               `json:"-"`
+}
+
+func (m *ApplySettings) Reset()         { *m = ApplySettings{} }
+func (m *ApplySettings) String() string { return proto.CompactTextString(m) }
+func (*ApplySettings) ProtoMessage()    {}
+func (*ApplySettings) Descriptor() ([]byte, []int) {
+	return fileDescriptor_0c720c20d27aa029, []int{4}
+}
+
+func (m *ApplySettings) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ApplySettings.Unmarshal(m, b)
+}
+func (m *ApplySettings) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ApplySettings.Marshal(b, m, deterministic)
+}
+func (m *ApplySettings) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ApplySettings.Merge(m, src)
+}
+func (m *ApplySettings) XXX_Size() int {
+	return xxx_messageInfo_ApplySettings.Size(m)
+}
+func (m *ApplySettings) XXX_DiscardUnknown() {
+	xxx_messageInfo_ApplySettings.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ApplySettings proto.InternalMessageInfo
+
+func (m *ApplySettings) GetLanguage() string {
+	if m != nil && m.Language != nil {
+		return *m.Language
+	}
+	return ""
+}
+
+func (m *ApplySettings) GetLabel() string {
+	if m != nil && m.Label != nil {
+		return *m.Label
+	}
+	return ""
+}
+
+func (m *ApplySettings) GetUsePassphrase() bool {
+	if m != nil && m.UsePassphrase != nil {
+		return *m.UsePassphrase
+	}
+	return false
+}
+
+func (m *ApplySettings) GetHomescreen() []byte {
+	if m != nil {
+		return m.Homescreen
+	}
+	return nil
+}
+
+func (m *ApplySettings) GetPassphraseSource() ApplySettings_PassphraseSourceType {
+	if m != nil && m.PassphraseSource != nil {
+		return *m.PassphraseSource
+	}
+	return ApplySettings_ASK
+}
+
+func (m *ApplySettings) GetAutoLockDelayMs() uint32 {
+	if m != nil && m.AutoLockDelayMs != nil {
+		return *m.AutoLockDelayMs
+	}
+	return 0
+}
+
+func (m *ApplySettings) GetDisplayRotation() uint32 {
+	if m != nil && m.DisplayRotation != nil {
+		return *m.DisplayRotation
+	}
+	return 0
+}
+
+//*
+// Request: set flags of the device
+// @start
+// @next Success
+// @next Failure
+type ApplyFlags struct {
+	Flags                *uint32  `protobuf:"varint,1,opt,name=flags" json:"flags,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ApplyFlags) Reset()         { *m = ApplyFlags{} }
+func (m *ApplyFlags) String() string { return proto.CompactTextString(m) }
+func (*ApplyFlags) ProtoMessage()    {}
+func (*ApplyFlags) Descriptor() ([]byte, []int) {
+	return fileDescriptor_0c720c20d27aa029, []int{5}
+}
+
+func (m *ApplyFlags) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ApplyFlags.Unmarshal(m, b)
+}
+func (m *ApplyFlags) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ApplyFlags.Marshal(b, m, deterministic)
+}
+func (m *ApplyFlags) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ApplyFlags.Merge(m, src)
+}
+func (m *ApplyFlags) XXX_Size() int {
+	return xxx_messageInfo_ApplyFlags.Size(m)
+}
+func (m *ApplyFlags) XXX_DiscardUnknown() {
+	xxx_messageInfo_ApplyFlags.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ApplyFlags proto.InternalMessageInfo
+
+func (m *ApplyFlags) GetFlags() uint32 {
+	if m != nil && m.Flags != nil {
+		return *m.Flags
+	}
+	return 0
+}
+
+//*
+// Request: Starts workflow for setting/changing/removing the PIN
+// @start
+// @next Success
+// @next Failure
+type ChangePin struct {
+	Remove               *bool    `protobuf:"varint,1,opt,name=remove" json:"remove,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ChangePin) Reset()         { *m = ChangePin{} }
+func (m *ChangePin) String() string { return proto.CompactTextString(m) }
+func (*ChangePin) ProtoMessage()    {}
+func (*ChangePin) Descriptor() ([]byte, []int) {
+	return fileDescriptor_0c720c20d27aa029, []int{6}
+}
+
+func (m *ChangePin) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ChangePin.Unmarshal(m, b)
+}
+func (m *ChangePin) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ChangePin.Marshal(b, m, deterministic)
+}
+func (m *ChangePin) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ChangePin.Merge(m, src)
+}
+func (m *ChangePin) XXX_Size() int {
+	return xxx_messageInfo_ChangePin.Size(m)
+}
+func (m *ChangePin) XXX_DiscardUnknown() {
+	xxx_messageInfo_ChangePin.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ChangePin proto.InternalMessageInfo
+
+func (m *ChangePin) GetRemove() bool {
+	if m != nil && m.Remove != nil {
+		return *m.Remove
+	}
+	return false
+}
+
+//*
+// Request: Test if the device is alive, device sends back the message in Success response
+// @start
+// @next Success
+type Ping struct {
+	Message              *string  `protobuf:"bytes,1,opt,name=message" json:"message,omitempty"`
+	ButtonProtection     *bool    `protobuf:"varint,2,opt,name=button_protection,json=buttonProtection" json:"button_protection,omitempty"`
+	PinProtection        *bool    `protobuf:"varint,3,opt,name=pin_protection,json=pinProtection" json:"pin_protection,omitempty"`
+	PassphraseProtection *bool    `protobuf:"varint,4,opt,name=passphrase_protection,json=passphraseProtection" json:"passphrase_protection,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Ping) Reset()         { *m = Ping{} }
+func (m *Ping) String() string { return proto.CompactTextString(m) }
+func (*Ping) ProtoMessage()    {}
+func (*Ping) Descriptor() ([]byte, []int) {
+	return fileDescriptor_0c720c20d27aa029, []int{7}
+}
+
+func (m *Ping) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Ping.Unmarshal(m, b)
+}
+func (m *Ping) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Ping.Marshal(b, m, deterministic)
+}
+func (m *Ping) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Ping.Merge(m, src)
+}
+func (m *Ping) XXX_Size() int {
+	return xxx_messageInfo_Ping.Size(m)
+}
+func (m *Ping) XXX_DiscardUnknown() {
+	xxx_messageInfo_Ping.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Ping proto.InternalMessageInfo
+
+func (m *Ping) GetMessage() string {
+	if m != nil && m.Message != nil {
+		return *m.Message
+	}
+	return ""
+}
+
+func (m *Ping) GetButtonProtection() bool {
+	if m != nil && m.ButtonProtection != nil {
+		return *m.ButtonProtection
+	}
+	return false
+}
+
+func (m *Ping) GetPinProtection() bool {
+	if m != nil && m.PinProtection != nil {
+		return *m.PinProtection
+	}
+	return false
+}
+
+func (m *Ping) GetPassphraseProtection() bool {
+	if m != nil && m.PassphraseProtection != nil {
+		return *m.PassphraseProtection
+	}
+	return false
+}
+
+//*
+// Request: Abort last operation that required user interaction
+// @start
+// @next Failure
+type Cancel struct {
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Cancel) Reset()         { *m = Cancel{} }
+func (m *Cancel) String() string { return proto.CompactTextString(m) }
+func (*Cancel) ProtoMessage()    {}
+func (*Cancel) Descriptor() ([]byte, []int) {
+	return fileDescriptor_0c720c20d27aa029, []int{8}
+}
+
+func (m *Cancel) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Cancel.Unmarshal(m, b)
+}
+func (m *Cancel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Cancel.Marshal(b, m, deterministic)
+}
+func (m *Cancel) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Cancel.Merge(m, src)
+}
+func (m *Cancel) XXX_Size() int {
+	return xxx_messageInfo_Cancel.Size(m)
+}
+func (m *Cancel) XXX_DiscardUnknown() {
+	xxx_messageInfo_Cancel.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Cancel proto.InternalMessageInfo
+
+//*
+// Request: Request a sample of random data generated by hardware RNG. May be used for testing.
+// @start
+// @next Entropy
+// @next Failure
+type GetEntropy struct {
+	Size                 *uint32  `protobuf:"varint,1,req,name=size" json:"size,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetEntropy) Reset()         { *m = GetEntropy{} }
+func (m *GetEntropy) String() string { return proto.CompactTextString(m) }
+func (*GetEntropy) ProtoMessage()    {}
+func (*GetEntropy) Descriptor() ([]byte, []int) {
+	return fileDescriptor_0c720c20d27aa029, []int{9}
+}
+
+func (m *GetEntropy) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_GetEntropy.Unmarshal(m, b)
+}
+func (m *GetEntropy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_GetEntropy.Marshal(b, m, deterministic)
+}
+func (m *GetEntropy) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GetEntropy.Merge(m, src)
+}
+func (m *GetEntropy) XXX_Size() int {
+	return xxx_messageInfo_GetEntropy.Size(m)
+}
+func (m *GetEntropy) XXX_DiscardUnknown() {
+	xxx_messageInfo_GetEntropy.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetEntropy proto.InternalMessageInfo
+
+func (m *GetEntropy) GetSize() uint32 {
+	if m != nil && m.Size != nil {
+		return *m.Size
+	}
+	return 0
+}
+
+//*
+// Response: Reply with random data generated by internal RNG
+// @end
+type Entropy struct {
+	Entropy              []byte   `protobuf:"bytes,1,req,name=entropy" json:"entropy,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Entropy) Reset()         { *m = Entropy{} }
+func (m *Entropy) String() string { return proto.CompactTextString(m) }
+func (*Entropy) ProtoMessage()    {}
+func (*Entropy) Descriptor() ([]byte, []int) {
+	return fileDescriptor_0c720c20d27aa029, []int{10}
+}
+
+func (m *Entropy) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Entropy.Unmarshal(m, b)
+}
+func (m *Entropy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Entropy.Marshal(b, m, deterministic)
+}
+func (m *Entropy) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Entropy.Merge(m, src)
+}
+func (m *Entropy) XXX_Size() int {
+	return xxx_messageInfo_Entropy.Size(m)
+}
+func (m *Entropy) XXX_DiscardUnknown() {
+	xxx_messageInfo_Entropy.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Entropy proto.InternalMessageInfo
+
+func (m *Entropy) GetEntropy() []byte {
+	if m != nil {
+		return m.Entropy
+	}
+	return nil
+}
+
+//*
+// Request: Request device to wipe all sensitive data and settings
+// @start
+// @next Success
+// @next Failure
+type WipeDevice struct {
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *WipeDevice) Reset()         { *m = WipeDevice{} }
+func (m *WipeDevice) String() string { return proto.CompactTextString(m) }
+func (*WipeDevice) ProtoMessage()    {}
+func (*WipeDevice) Descriptor() ([]byte, []int) {
+	return fileDescriptor_0c720c20d27aa029, []int{11}
+}
+
+func (m *WipeDevice) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_WipeDevice.Unmarshal(m, b)
+}
+func (m *WipeDevice) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_WipeDevice.Marshal(b, m, deterministic)
+}
+func (m *WipeDevice) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_WipeDevice.Merge(m, src)
+}
+func (m *WipeDevice) XXX_Size() int {
+	return xxx_messageInfo_WipeDevice.Size(m)
+}
+func (m *WipeDevice) XXX_DiscardUnknown() {
+	xxx_messageInfo_WipeDevice.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_WipeDevice proto.InternalMessageInfo
+
+//*
+// Request: Load seed and related internal settings from the computer
+// @start
+// @next Success
+// @next Failure
+type LoadDevice struct {
+	Mnemonic             *string     `protobuf:"bytes,1,opt,name=mnemonic" json:"mnemonic,omitempty"`
+	Node                 *HDNodeType `protobuf:"bytes,2,opt,name=node" json:"node,omitempty"`
+	Pin                  *string     `protobuf:"bytes,3,opt,name=pin" json:"pin,omitempty"`
+	PassphraseProtection *bool       `protobuf:"varint,4,opt,name=passphrase_protection,json=passphraseProtection" json:"passphrase_protection,omitempty"`
+	Language             *string     `protobuf:"bytes,5,opt,name=language,def=english" json:"language,omitempty"`
+	Label                *string     `protobuf:"bytes,6,opt,name=label" json:"label,omitempty"`
+	SkipChecksum         *bool       `protobuf:"varint,7,opt,name=skip_checksum,json=skipChecksum" json:"skip_checksum,omitempty"`
+	U2FCounter           *uint32     `protobuf:"varint,8,opt,name=u2f_counter,json=u2fCounter" json:"u2f_counter,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
+	XXX_unrecognized     []byte      `json:"-"`
+	XXX_sizecache        int32       `json:"-"`
+}
+
+func (m *LoadDevice) Reset()         { *m = LoadDevice{} }
+func (m *LoadDevice) String() string { return proto.CompactTextString(m) }
+func (*LoadDevice) ProtoMessage()    {}
+func (*LoadDevice) Descriptor() ([]byte, []int) {
+	return fileDescriptor_0c720c20d27aa029, []int{12}
+}
+
+func (m *LoadDevice) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_LoadDevice.Unmarshal(m, b)
+}
+func (m *LoadDevice) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_LoadDevice.Marshal(b, m, deterministic)
+}
+func (m *LoadDevice) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_LoadDevice.Merge(m, src)
+}
+func (m *LoadDevice) XXX_Size() int {
+	return xxx_messageInfo_LoadDevice.Size(m)
+}
+func (m *LoadDevice) XXX_DiscardUnknown() {
+	xxx_messageInfo_LoadDevice.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_LoadDevice proto.InternalMessageInfo
+
+const Default_LoadDevice_Language string = "english"
+
+func (m *LoadDevice) GetMnemonic() string {
+	if m != nil && m.Mnemonic != nil {
+		return *m.Mnemonic
+	}
+	return ""
+}
+
+func (m *LoadDevice) GetNode() *HDNodeType {
+	if m != nil {
+		return m.Node
+	}
+	return nil
+}
+
+func (m *LoadDevice) GetPin() string {
+	if m != nil && m.Pin != nil {
+		return *m.Pin
+	}
+	return ""
+}
+
+func (m *LoadDevice) GetPassphraseProtection() bool {
+	if m != nil && m.PassphraseProtection != nil {
+		return *m.PassphraseProtection
+	}
+	return false
+}
+
+func (m *LoadDevice) GetLanguage() string {
+	if m != nil && m.Language != nil {
+		return *m.Language
+	}
+	return Default_LoadDevice_Language
+}
+
+func (m *LoadDevice) GetLabel() string {
+	if m != nil && m.Label != nil {
+		return *m.Label
+	}
+	return ""
+}
+
+func (m *LoadDevice) GetSkipChecksum() bool {
+	if m != nil && m.SkipChecksum != nil {
+		return *m.SkipChecksum
+	}
+	return false
+}
+
+func (m *LoadDevice) GetU2FCounter() uint32 {
+	if m != nil && m.U2FCounter != nil {
+		return *m.U2FCounter
+	}
+	return 0
+}
+
+//*
+// Request: Ask device to do initialization involving user interaction
+// @start
+// @next EntropyRequest
+// @next Failure
+type ResetDevice struct {
+	DisplayRandom        *bool    `protobuf:"varint,1,opt,name=display_random,json=displayRandom" json:"display_random,omitempty"`
+	Strength             *uint32  `protobuf:"varint,2,opt,name=strength,def=256" json:"strength,omitempty"`
+	PassphraseProtection *bool    `protobuf:"varint,3,opt,name=passphrase_protection,json=passphraseProtection" json:"passphrase_protection,omitempty"`
+	PinProtection        *bool    `protobuf:"varint,4,opt,name=pin_protection,json=pinProtection" json:"pin_protection,omitempty"`
+	Language             *string  `protobuf:"bytes,5,opt,name=language,def=english" json:"language,omitempty"`
+	Label                *string  `protobuf:"bytes,6,opt,name=label" json:"label,omitempty"`
+	U2FCounter           *uint32  `protobuf:"varint,7,opt,name=u2f_counter,json=u2fCounter" json:"u2f_counter,omitempty"`
+	SkipBackup           *bool    `protobuf:"varint,8,opt,name=skip_backup,json=skipBackup" json:"skip_backup,omitempty"`
+	NoBackup             *bool    `protobuf:"varint,9,opt,name=no_backup,json=noBackup" json:"no_backup,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ResetDevice) Reset()         { *m = ResetDevice{} }
+func (m *ResetDevice) String() string { return proto.CompactTextString(m) }
+func (*ResetDevice) ProtoMessage()    {}
+func (*ResetDevice) Descriptor() ([]byte, []int) {
+	return fileDescriptor_0c720c20d27aa029, []int{13}
+}
+
+func (m *ResetDevice) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ResetDevice.Unmarshal(m, b)
+}
+func (m *ResetDevice) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ResetDevice.Marshal(b, m, deterministic)
+}
+func (m *ResetDevice) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ResetDevice.Merge(m, src)
+}
+func (m *ResetDevice) XXX_Size() int {
+	return xxx_messageInfo_ResetDevice.Size(m)
+}
+func (m *ResetDevice) XXX_DiscardUnknown() {
+	xxx_messageInfo_ResetDevice.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ResetDevice proto.InternalMessageInfo
+
+const Default_ResetDevice_Strength uint32 = 256
+const Default_ResetDevice_Language string = "english"
+
+func (m *ResetDevice) GetDisplayRandom() bool {
+	if m != nil && m.DisplayRandom != nil {
+		return *m.DisplayRandom
+	}
+	return false
+}
+
+func (m *ResetDevice) GetStrength() uint32 {
+	if m != nil && m.Strength != nil {
+		return *m.Strength
+	}
+	return Default_ResetDevice_Strength
+}
+
+func (m *ResetDevice) GetPassphraseProtection() bool {
+	if m != nil && m.PassphraseProtection != nil {
+		return *m.PassphraseProtection
+	}
+	return false
+}
+
+func (m *ResetDevice) GetPinProtection() bool {
+	if m != nil && m.PinProtection != nil {
+		return *m.PinProtection
+	}
+	return false
+}
+
+func (m *ResetDevice) GetLanguage() string {
+	if m != nil && m.Language != nil {
+		return *m.Language
+	}
+	return Default_ResetDevice_Language
+}
+
+func (m *ResetDevice) GetLabel() string {
+	if m != nil && m.Label != nil {
+		return *m.Label
+	}
+	return ""
+}
+
+func (m *ResetDevice) GetU2FCounter() uint32 {
+	if m != nil && m.U2FCounter != nil {
+		return *m.U2FCounter
+	}
+	return 0
+}
+
+func (m *ResetDevice) GetSkipBackup() bool {
+	if m != nil && m.SkipBackup != nil {
+		return *m.SkipBackup
+	}
+	return false
+}
+
+func (m *ResetDevice) GetNoBackup() bool {
+	if m != nil && m.NoBackup != nil {
+		return *m.NoBackup
+	}
+	return false
+}
+
+//*
+// Request: Perform backup of the device seed if not backed up using ResetDevice
+// @start
+// @next Success
+type BackupDevice struct {
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *BackupDevice) Reset()         { *m = BackupDevice{} }
+func (m *BackupDevice) String() string { return proto.CompactTextString(m) }
+func (*BackupDevice) ProtoMessage()    {}
+func (*BackupDevice) Descriptor() ([]byte, []int) {
+	return fileDescriptor_0c720c20d27aa029, []int{14}
+}
+
+func (m *BackupDevice) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_BackupDevice.Unmarshal(m, b)
+}
+func (m *BackupDevice) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_BackupDevice.Marshal(b, m, deterministic)
+}
+func (m *BackupDevice) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_BackupDevice.Merge(m, src)
+}
+func (m *BackupDevice) XXX_Size() int {
+	return xxx_messageInfo_BackupDevice.Size(m)
+}
+func (m *BackupDevice) XXX_DiscardUnknown() {
+	xxx_messageInfo_BackupDevice.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_BackupDevice proto.InternalMessageInfo
+
+//*
+// Response: Ask for additional entropy from host computer
+// @next EntropyAck
+type EntropyRequest struct {
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *EntropyRequest) Reset()         { *m = EntropyRequest{} }
+func (m *EntropyRequest) String() string { return proto.CompactTextString(m) }
+func (*EntropyRequest) ProtoMessage()    {}
+func (*EntropyRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_0c720c20d27aa029, []int{15}
+}
+
+func (m *EntropyRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_EntropyRequest.Unmarshal(m, b)
+}
+func (m *EntropyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_EntropyRequest.Marshal(b, m, deterministic)
+}
+func (m *EntropyRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_EntropyRequest.Merge(m, src)
+}
+func (m *EntropyRequest) XXX_Size() int {
+	return xxx_messageInfo_EntropyRequest.Size(m)
+}
+func (m *EntropyRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_EntropyRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EntropyRequest proto.InternalMessageInfo
+
+//*
+// Request: Provide additional entropy for seed generation function
+// @next Success
+type EntropyAck struct {
+	Entropy              []byte   `protobuf:"bytes,1,opt,name=entropy" json:"entropy,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *EntropyAck) Reset()         { *m = EntropyAck{} }
+func (m *EntropyAck) String() string { return proto.CompactTextString(m) }
+func (*EntropyAck) ProtoMessage()    {}
+func (*EntropyAck) Descriptor() ([]byte, []int) {
+	return fileDescriptor_0c720c20d27aa029, []int{16}
+}
+
+func (m *EntropyAck) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_EntropyAck.Unmarshal(m, b)
+}
+func (m *EntropyAck) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_EntropyAck.Marshal(b, m, deterministic)
+}
+func (m *EntropyAck) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_EntropyAck.Merge(m, src)
+}
+func (m *EntropyAck) XXX_Size() int {
+	return xxx_messageInfo_EntropyAck.Size(m)
+}
+func (m *EntropyAck) XXX_DiscardUnknown() {
+	xxx_messageInfo_EntropyAck.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EntropyAck proto.InternalMessageInfo
+
+func (m *EntropyAck) GetEntropy() []byte {
+	if m != nil {
+		return m.Entropy
+	}
+	return nil
+}
+
+//*
+// Request: Start recovery workflow asking user for specific words of mnemonic
+// Used to recovery device safely even on untrusted computer.
+// @start
+// @next WordRequest
+type RecoveryDevice struct {
+	WordCount            *uint32 `protobuf:"varint,1,opt,name=word_count,json=wordCount" json:"word_count,omitempty"`
+	PassphraseProtection *bool   `protobuf:"varint,2,opt,name=passphrase_protection,json=passphraseProtection" json:"passphrase_protection,omitempty"`
+	PinProtection        *bool   `protobuf:"varint,3,opt,name=pin_protection,json=pinProtection" json:"pin_protection,omitempty"`
+	Language             *string `protobuf:"bytes,4,opt,name=language,def=english" json:"language,omitempty"`
+	Label                *string `protobuf:"bytes,5,opt,name=label" json:"label,omitempty"`
+	EnforceWordlist      *bool   `protobuf:"varint,6,opt,name=enforce_wordlist,json=enforceWordlist" json:"enforce_wordlist,omitempty"`
+	// 7 reserved for unused recovery method
+	Type                 *RecoveryDevice_RecoveryDeviceType `protobuf:"varint,8,opt,name=type,enum=hw.trezor.messages.management.RecoveryDevice_RecoveryDeviceType" json:"type,omitempty"`
+	U2FCounter           *uint32                            `protobuf:"varint,9,opt,name=u2f_counter,json=u2fCounter" json:"u2f_counter,omitempty"`
+	DryRun               *bool                              `protobuf:"varint,10,opt,name=dry_run,json=dryRun" json:"dry_run,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}                           `json:"-"`
+	XXX_unrecognized     []byte                             `json:"-"`
+	XXX_sizecache        int32                              `json:"-"`
+}
+
+func (m *RecoveryDevice) Reset()         { *m = RecoveryDevice{} }
+func (m *RecoveryDevice) String() string { return proto.CompactTextString(m) }
+func (*RecoveryDevice) ProtoMessage()    {}
+func (*RecoveryDevice) Descriptor() ([]byte, []int) {
+	return fileDescriptor_0c720c20d27aa029, []int{17}
+}
+
+func (m *RecoveryDevice) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_RecoveryDevice.Unmarshal(m, b)
+}
+func (m *RecoveryDevice) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_RecoveryDevice.Marshal(b, m, deterministic)
+}
+func (m *RecoveryDevice) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_RecoveryDevice.Merge(m, src)
+}
+func (m *RecoveryDevice) XXX_Size() int {
+	return xxx_messageInfo_RecoveryDevice.Size(m)
+}
+func (m *RecoveryDevice) XXX_DiscardUnknown() {
+	xxx_messageInfo_RecoveryDevice.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_RecoveryDevice proto.InternalMessageInfo
+
+const Default_RecoveryDevice_Language string = "english"
+
+func (m *RecoveryDevice) GetWordCount() uint32 {
+	if m != nil && m.WordCount != nil {
+		return *m.WordCount
+	}
+	return 0
+}
+
+func (m *RecoveryDevice) GetPassphraseProtection() bool {
+	if m != nil && m.PassphraseProtection != nil {
+		return *m.PassphraseProtection
+	}
+	return false
+}
+
+func (m *RecoveryDevice) GetPinProtection() bool {
+	if m != nil && m.PinProtection != nil {
+		return *m.PinProtection
+	}
+	return false
+}
+
+func (m *RecoveryDevice) GetLanguage() string {
+	if m != nil && m.Language != nil {
+		return *m.Language
+	}
+	return Default_RecoveryDevice_Language
+}
+
+func (m *RecoveryDevice) GetLabel() string {
+	if m != nil && m.Label != nil {
+		return *m.Label
+	}
+	return ""
+}
+
+func (m *RecoveryDevice) GetEnforceWordlist() bool {
+	if m != nil && m.EnforceWordlist != nil {
+		return *m.EnforceWordlist
+	}
+	return false
+}
+
+func (m *RecoveryDevice) GetType() RecoveryDevice_RecoveryDeviceType {
+	if m != nil && m.Type != nil {
+		return *m.Type
+	}
+	return RecoveryDevice_RecoveryDeviceType_ScrambledWords
+}
+
+func (m *RecoveryDevice) GetU2FCounter() uint32 {
+	if m != nil && m.U2FCounter != nil {
+		return *m.U2FCounter
+	}
+	return 0
+}
+
+func (m *RecoveryDevice) GetDryRun() bool {
+	if m != nil && m.DryRun != nil {
+		return *m.DryRun
+	}
+	return false
+}
+
+//*
+// Response: Device is waiting for user to enter word of the mnemonic
+// Its position is shown only on device's internal display.
+// @next WordAck
+type WordRequest struct {
+	Type                 *WordRequest_WordRequestType `protobuf:"varint,1,opt,name=type,enum=hw.trezor.messages.management.WordRequest_WordRequestType" json:"type,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
+	XXX_unrecognized     []byte                       `json:"-"`
+	XXX_sizecache        int32                        `json:"-"`
+}
+
+func (m *WordRequest) Reset()         { *m = WordRequest{} }
+func (m *WordRequest) String() string { return proto.CompactTextString(m) }
+func (*WordRequest) ProtoMessage()    {}
+func (*WordRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_0c720c20d27aa029, []int{18}
+}
+
+func (m *WordRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_WordRequest.Unmarshal(m, b)
+}
+func (m *WordRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_WordRequest.Marshal(b, m, deterministic)
+}
+func (m *WordRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_WordRequest.Merge(m, src)
+}
+func (m *WordRequest) XXX_Size() int {
+	return xxx_messageInfo_WordRequest.Size(m)
+}
+func (m *WordRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_WordRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_WordRequest proto.InternalMessageInfo
+
+func (m *WordRequest) GetType() WordRequest_WordRequestType {
+	if m != nil && m.Type != nil {
+		return *m.Type
+	}
+	return WordRequest_WordRequestType_Plain
+}
+
+//*
+// Request: Computer replies with word from the mnemonic
+// @next WordRequest
+// @next Success
+// @next Failure
+type WordAck struct {
+	Word                 *string  `protobuf:"bytes,1,req,name=word" json:"word,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *WordAck) Reset()         { *m = WordAck{} }
+func (m *WordAck) String() string { return proto.CompactTextString(m) }
+func (*WordAck) ProtoMessage()    {}
+func (*WordAck) Descriptor() ([]byte, []int) {
+	return fileDescriptor_0c720c20d27aa029, []int{19}
+}
+
+func (m *WordAck) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_WordAck.Unmarshal(m, b)
+}
+func (m *WordAck) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_WordAck.Marshal(b, m, deterministic)
+}
+func (m *WordAck) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_WordAck.Merge(m, src)
+}
+func (m *WordAck) XXX_Size() int {
+	return xxx_messageInfo_WordAck.Size(m)
+}
+func (m *WordAck) XXX_DiscardUnknown() {
+	xxx_messageInfo_WordAck.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_WordAck proto.InternalMessageInfo
+
+func (m *WordAck) GetWord() string {
+	if m != nil && m.Word != nil {
+		return *m.Word
+	}
+	return ""
+}
+
+//*
+// Request: Set U2F counter
+// @start
+// @next Success
+type SetU2FCounter struct {
+	U2FCounter           *uint32  `protobuf:"varint,1,opt,name=u2f_counter,json=u2fCounter" json:"u2f_counter,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *SetU2FCounter) Reset()         { *m = SetU2FCounter{} }
+func (m *SetU2FCounter) String() string { return proto.CompactTextString(m) }
+func (*SetU2FCounter) ProtoMessage()    {}
+func (*SetU2FCounter) Descriptor() ([]byte, []int) {
+	return fileDescriptor_0c720c20d27aa029, []int{20}
+}
+
+func (m *SetU2FCounter) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_SetU2FCounter.Unmarshal(m, b)
+}
+func (m *SetU2FCounter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_SetU2FCounter.Marshal(b, m, deterministic)
+}
+func (m *SetU2FCounter) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SetU2FCounter.Merge(m, src)
+}
+func (m *SetU2FCounter) XXX_Size() int {
+	return xxx_messageInfo_SetU2FCounter.Size(m)
+}
+func (m *SetU2FCounter) XXX_DiscardUnknown() {
+	xxx_messageInfo_SetU2FCounter.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SetU2FCounter proto.InternalMessageInfo
+
+func (m *SetU2FCounter) GetU2FCounter() uint32 {
+	if m != nil && m.U2FCounter != nil {
+		return *m.U2FCounter
+	}
+	return 0
+}
+
+func init() {
+	proto.RegisterEnum("hw.trezor.messages.management.ApplySettings_PassphraseSourceType", ApplySettings_PassphraseSourceType_name, ApplySettings_PassphraseSourceType_value)
+	proto.RegisterEnum("hw.trezor.messages.management.RecoveryDevice_RecoveryDeviceType", RecoveryDevice_RecoveryDeviceType_name, RecoveryDevice_RecoveryDeviceType_value)
+	proto.RegisterEnum("hw.trezor.messages.management.WordRequest_WordRequestType", WordRequest_WordRequestType_name, WordRequest_WordRequestType_value)
+	proto.RegisterType((*Initialize)(nil), "hw.trezor.messages.management.Initialize")
+	proto.RegisterType((*GetFeatures)(nil), "hw.trezor.messages.management.GetFeatures")
+	proto.RegisterType((*Features)(nil), "hw.trezor.messages.management.Features")
+	proto.RegisterType((*ClearSession)(nil), "hw.trezor.messages.management.ClearSession")
+	proto.RegisterType((*ApplySettings)(nil), "hw.trezor.messages.management.ApplySettings")
+	proto.RegisterType((*ApplyFlags)(nil), "hw.trezor.messages.management.ApplyFlags")
+	proto.RegisterType((*ChangePin)(nil), "hw.trezor.messages.management.ChangePin")
+	proto.RegisterType((*Ping)(nil), "hw.trezor.messages.management.Ping")
+	proto.RegisterType((*Cancel)(nil), "hw.trezor.messages.management.Cancel")
+	proto.RegisterType((*GetEntropy)(nil), "hw.trezor.messages.management.GetEntropy")
+	proto.RegisterType((*Entropy)(nil), "hw.trezor.messages.management.Entropy")
+	proto.RegisterType((*WipeDevice)(nil), "hw.trezor.messages.management.WipeDevice")
+	proto.RegisterType((*LoadDevice)(nil), "hw.trezor.messages.management.LoadDevice")
+	proto.RegisterType((*ResetDevice)(nil), "hw.trezor.messages.management.ResetDevice")
+	proto.RegisterType((*BackupDevice)(nil), "hw.trezor.messages.management.BackupDevice")
+	proto.RegisterType((*EntropyRequest)(nil), "hw.trezor.messages.management.EntropyRequest")
+	proto.RegisterType((*EntropyAck)(nil), "hw.trezor.messages.management.EntropyAck")
+	proto.RegisterType((*RecoveryDevice)(nil), "hw.trezor.messages.management.RecoveryDevice")
+	proto.RegisterType((*WordRequest)(nil), "hw.trezor.messages.management.WordRequest")
+	proto.RegisterType((*WordAck)(nil), "hw.trezor.messages.management.WordAck")
+	proto.RegisterType((*SetU2FCounter)(nil), "hw.trezor.messages.management.SetU2FCounter")
+}
+
+func init() { proto.RegisterFile("messages-management.proto", fileDescriptor_0c720c20d27aa029) }
+
+var fileDescriptor_0c720c20d27aa029 = []byte{
+	// 1393 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x57, 0xdd, 0x6e, 0xdb, 0xc8,
+	0x15, 0x8e, 0x7e, 0x62, 0x49, 0xc7, 0xfa, 0xcb, 0xd4, 0x8e, 0xe9, 0xb8, 0x6e, 0x1c, 0xba, 0x6e,
+	0x12, 0x04, 0x15, 0x0a, 0x17, 0x09, 0x90, 0x5c, 0x14, 0x75, 0xec, 0xfc, 0x21, 0x71, 0x6a, 0xd0,
+	0x6e, 0x02, 0xf4, 0x86, 0x18, 0x91, 0x47, 0xd2, 0xd4, 0xe4, 0x0c, 0xcb, 0x19, 0xda, 0x55, 0x5e,
+	0x60, 0x6f, 0xf6, 0x45, 0x16, 0xfb, 0x1c, 0x7b, 0xb5, 0xcf, 0xb0, 0xef, 0xb2, 0x98, 0x19, 0x52,
+	0xa2, 0x65, 0x3b, 0x46, 0x76, 0xef, 0xe6, 0x7c, 0xe7, 0xe3, 0x68, 0xce, 0x77, 0xbe, 0x39, 0x63,
+	0xc3, 0x7a, 0x8c, 0x52, 0xd2, 0x31, 0xca, 0xbf, 0xc6, 0x94, 0xd3, 0x31, 0xc6, 0xc8, 0xd5, 0x20,
+	0x49, 0x85, 0x12, 0x64, 0x73, 0x72, 0x3e, 0x50, 0x29, 0x7e, 0x11, 0xe9, 0xa0, 0x20, 0x0d, 0xe6,
+	0xa4, 0x7b, 0xab, 0xb3, 0x2f, 0x03, 0x11, 0xc7, 0x82, 0xdb, 0xaf, 0xdc, 0xf7, 0x00, 0xef, 0x38,
+	0x53, 0x8c, 0x46, 0xec, 0x0b, 0x92, 0x15, 0xb8, 0x2d, 0x15, 0x55, 0xe8, 0x54, 0xb6, 0x2a, 0x8f,
+	0xda, 0x9e, 0x0d, 0xc8, 0x43, 0xe8, 0xc9, 0x53, 0x96, 0xf8, 0x09, 0x95, 0x32, 0x99, 0xa4, 0x54,
+	0xa2, 0x53, 0xdd, 0xaa, 0x3c, 0x6a, 0x7a, 0x5d, 0x0d, 0x1f, 0xcd, 0x50, 0xb7, 0x03, 0xcb, 0x6f,
+	0x50, 0xbd, 0x46, 0xaa, 0xb2, 0x14, 0xa5, 0xfb, 0x7d, 0x03, 0x9a, 0x45, 0x40, 0xee, 0xc2, 0xd2,
+	0x19, 0xf2, 0x50, 0xa4, 0x66, 0xef, 0x96, 0x97, 0x47, 0x64, 0x1b, 0x3a, 0x31, 0xfd, 0xaf, 0x48,
+	0xfd, 0x33, 0x4c, 0x25, 0x13, 0xdc, 0x6c, 0xdd, 0xf1, 0xda, 0x06, 0xfc, 0x64, 0x31, 0x43, 0x62,
+	0xbc, 0x44, 0xaa, 0xe5, 0x24, 0x0d, 0x96, 0x48, 0x09, 0x55, 0xc1, 0x64, 0x46, 0xaa, 0x5b, 0x92,
+	0x01, 0x0b, 0xd2, 0x43, 0xe8, 0x0d, 0x85, 0x50, 0x91, 0xa0, 0x21, 0xa6, 0x7e, 0x2c, 0x42, 0x74,
+	0x6e, 0xdb, 0x5a, 0xe6, 0xf0, 0xa1, 0x08, 0x91, 0x6c, 0x40, 0x2b, 0xc4, 0x33, 0x16, 0xa0, 0xcf,
+	0x42, 0x67, 0xc9, 0x1c, 0xb9, 0x69, 0x81, 0x77, 0x21, 0xd9, 0x81, 0x6e, 0xc2, 0xb8, 0xaf, 0x25,
+	0xc4, 0x40, 0xe9, 0xdf, 0x6a, 0x98, 0x4d, 0x3a, 0x09, 0xe3, 0x47, 0x33, 0x90, 0xfc, 0x1d, 0x56,
+	0xe7, 0x9a, 0x95, 0xd9, 0x4d, 0xc3, 0x5e, 0x99, 0x27, 0x4b, 0x1f, 0xdd, 0x83, 0x66, 0x44, 0xf9,
+	0x38, 0xa3, 0x63, 0x74, 0x5a, 0xf6, 0x77, 0x8b, 0x58, 0xf7, 0x27, 0xa2, 0x43, 0x8c, 0x1c, 0x30,
+	0x09, 0x1b, 0x90, 0x2d, 0x58, 0x66, 0xb3, 0x1e, 0x86, 0x4e, 0xdb, 0x6c, 0x5e, 0x86, 0xf4, 0x9e,
+	0x29, 0x9e, 0x31, 0xa3, 0x4a, 0xc7, 0xb4, 0x76, 0x16, 0x2f, 0x28, 0x32, 0xa1, 0x72, 0xe2, 0x74,
+	0x0d, 0xa5, 0xa4, 0xc8, 0x5b, 0x2a, 0x27, 0x7a, 0x13, 0x16, 0x27, 0x22, 0x55, 0x18, 0x3a, 0x3d,
+	0xf3, 0x1b, 0xb3, 0x98, 0x6c, 0x02, 0x68, 0x41, 0x02, 0x1a, 0x4c, 0x30, 0x74, 0xfa, 0x26, 0xdb,
+	0x4a, 0x18, 0xdf, 0x37, 0x00, 0x79, 0x02, 0x77, 0x4a, 0x42, 0xe4, 0xac, 0x3b, 0x86, 0xd5, 0x9f,
+	0x27, 0x72, 0xf2, 0x63, 0xe8, 0x8f, 0x58, 0x1a, 0x9f, 0xd3, 0x54, 0x6b, 0x86, 0x12, 0xb9, 0x72,
+	0x88, 0xe1, 0xf6, 0x0a, 0xfc, 0xc8, 0xc2, 0xe4, 0x01, 0xb4, 0x39, 0x62, 0x28, 0xfd, 0x21, 0x0d,
+	0x4e, 0xb3, 0xc4, 0xf9, 0x83, 0x2d, 0xdd, 0x60, 0x2f, 0x0d, 0xa4, 0x25, 0x1b, 0x45, 0x74, 0x2c,
+	0x9d, 0x15, 0xe3, 0x06, 0x1b, 0x68, 0x54, 0xf7, 0x3e, 0x72, 0x56, 0xad, 0x90, 0x26, 0x20, 0xeb,
+	0xd0, 0x1c, 0x9d, 0xfb, 0xc6, 0x79, 0xce, 0x5d, 0x43, 0x6f, 0x8c, 0xce, 0x0f, 0x75, 0x58, 0xa4,
+	0xb4, 0xdf, 0x9c, 0xb5, 0x59, 0x4a, 0x87, 0x79, 0xca, 0xb8, 0xcc, 0x71, 0x8a, 0xd4, 0x91, 0x0e,
+	0xb5, 0x89, 0x46, 0xe7, 0x7e, 0xee, 0xfb, 0x75, 0xdb, 0xcc, 0xd1, 0xf9, 0x27, 0xeb, 0xfc, 0x3f,
+	0x43, 0x77, 0x96, 0xf4, 0x4f, 0x71, 0x2a, 0x9d, 0x7b, 0x46, 0xf7, 0x76, 0xc1, 0x78, 0x8f, 0x53,
+	0xa9, 0xa5, 0xcb, 0xf8, 0x88, 0x71, 0x26, 0x27, 0x18, 0x16, 0x75, 0x6e, 0x58, 0xe9, 0xe6, 0x89,
+	0xbc, 0xd8, 0x0d, 0x68, 0x71, 0x51, 0x90, 0xfe, 0x68, 0x7b, 0xc4, 0x85, 0x4d, 0xba, 0x5d, 0x68,
+	0xef, 0x47, 0x48, 0xd3, 0x63, 0x94, 0xba, 0xf1, 0xee, 0x77, 0x35, 0xe8, 0xec, 0x25, 0x49, 0x34,
+	0x3d, 0x46, 0xa5, 0x18, 0x1f, 0xcb, 0x0b, 0xd6, 0xab, 0x5c, 0x67, 0xbd, 0x6a, 0xd9, 0x7a, 0x3b,
+	0xd0, 0xcd, 0xb4, 0xb5, 0xe7, 0x93, 0xa1, 0x66, 0x2f, 0x42, 0x26, 0x71, 0x3e, 0x18, 0xc8, 0x9f,
+	0x00, 0x26, 0x22, 0x46, 0x19, 0xa4, 0x88, 0xf6, 0x5e, 0xb6, 0xbd, 0x12, 0x42, 0xf8, 0x05, 0x7f,
+	0x48, 0x91, 0xa5, 0x81, 0xbd, 0x97, 0xdd, 0xdd, 0xbd, 0xc1, 0x57, 0xe7, 0xda, 0xe0, 0x42, 0x05,
+	0x83, 0xf9, 0x6f, 0x1e, 0x9b, 0x4d, 0x4e, 0xa6, 0x09, 0x96, 0x2d, 0x66, 0x51, 0xf2, 0x04, 0x08,
+	0xcd, 0x94, 0xf0, 0x23, 0x11, 0x9c, 0xfa, 0x21, 0x46, 0x74, 0xea, 0xc7, 0xd2, 0xdc, 0xf2, 0x8e,
+	0xd7, 0xd3, 0x99, 0x0f, 0x22, 0x38, 0x3d, 0xd0, 0xf8, 0xa1, 0xd4, 0x7e, 0x0c, 0x99, 0x4c, 0x34,
+	0x29, 0x15, 0x8a, 0xce, 0xae, 0x7b, 0xc7, 0xeb, 0xe5, 0xb8, 0x97, 0xc3, 0xee, 0x53, 0x58, 0xb9,
+	0xea, 0x04, 0xa4, 0x01, 0xb5, 0xbd, 0xe3, 0xf7, 0xfd, 0x5b, 0x04, 0x60, 0xe9, 0xe0, 0xd5, 0xa7,
+	0x77, 0xfb, 0xaf, 0xfa, 0x15, 0xd2, 0x84, 0xfa, 0xdb, 0x7f, 0x1d, 0x9f, 0xf4, 0xab, 0xae, 0x0b,
+	0x60, 0xca, 0x78, 0x5d, 0x78, 0xd3, 0x3a, 0xb6, 0x52, 0x72, 0xac, 0xbb, 0x0d, 0xad, 0xfd, 0x09,
+	0xe5, 0x63, 0x3c, 0x62, 0x5c, 0x0f, 0xd3, 0x14, 0x63, 0x71, 0x66, 0xdb, 0xd4, 0xf4, 0xf2, 0xc8,
+	0xfd, 0xa1, 0x02, 0xf5, 0x23, 0xc6, 0xc7, 0xc4, 0x81, 0x46, 0x2e, 0x56, 0xde, 0xc8, 0x22, 0xd4,
+	0x7e, 0x1a, 0x66, 0x4a, 0x89, 0x0b, 0xd3, 0xcb, 0x8e, 0xf3, 0xbe, 0x4d, 0x94, 0x66, 0xd1, 0xe5,
+	0x39, 0x57, 0xfb, 0xa6, 0x39, 0x57, 0xbf, 0x7e, 0xce, 0xb9, 0x4d, 0x58, 0xda, 0xa7, 0x3c, 0xc0,
+	0xc8, 0xdd, 0x02, 0x78, 0x83, 0xea, 0x15, 0x57, 0xa9, 0x48, 0xa6, 0x84, 0x40, 0x5d, 0xb2, 0x2f,
+	0xfa, 0xdc, 0xd5, 0x47, 0x1d, 0xcf, 0xac, 0xdd, 0x6d, 0x68, 0x14, 0x69, 0x07, 0x1a, 0x68, 0x97,
+	0x86, 0xd1, 0xf6, 0x8a, 0xd0, 0x6d, 0x03, 0x7c, 0x66, 0x09, 0x1e, 0x98, 0x21, 0xed, 0xfe, 0x58,
+	0x05, 0xf8, 0x20, 0x68, 0x68, 0x43, 0x6d, 0xed, 0x98, 0x63, 0x2c, 0x38, 0x0b, 0x0a, 0x6b, 0x17,
+	0x31, 0x79, 0x0e, 0x75, 0xae, 0x1f, 0x02, 0xad, 0xc2, 0xf2, 0xee, 0xce, 0x55, 0x86, 0xcb, 0xdf,
+	0xcc, 0xb7, 0x07, 0x1f, 0x45, 0x68, 0x4d, 0x65, 0x3e, 0x21, 0x7d, 0xa8, 0x25, 0xcc, 0xaa, 0xd2,
+	0xf2, 0xf4, 0xf2, 0x37, 0x69, 0x41, 0xb6, 0x4b, 0x17, 0x4f, 0xdb, 0xbe, 0xf5, 0xa2, 0x81, 0x7c,
+	0x1c, 0x31, 0x39, 0xb9, 0xea, 0x06, 0x2e, 0x95, 0x6f, 0xe0, 0x36, 0x74, 0xcc, 0xe3, 0x1c, 0x4c,
+	0x30, 0x38, 0x95, 0x59, 0x9c, 0xbf, 0x44, 0x6d, 0x0d, 0xee, 0xe7, 0x18, 0xb9, 0x0f, 0xcb, 0xd9,
+	0xee, 0xc8, 0x0f, 0x44, 0xc6, 0x15, 0xa6, 0xe6, 0xf9, 0xe9, 0x78, 0x90, 0xed, 0x8e, 0xf6, 0x2d,
+	0xe2, 0xfe, 0x5c, 0x85, 0x65, 0x0f, 0x25, 0xaa, 0x5c, 0xae, 0x1d, 0xe8, 0xce, 0x3c, 0x4f, 0x79,
+	0x28, 0xe2, 0xdc, 0x68, 0x9d, 0xc2, 0xf1, 0x06, 0x24, 0xf7, 0xa1, 0x29, 0x55, 0x8a, 0x7c, 0xac,
+	0x26, 0xf6, 0xdd, 0x7e, 0x51, 0xdb, 0x7d, 0xfa, 0xcc, 0x9b, 0x81, 0xd7, 0xab, 0x51, 0xfb, 0x8a,
+	0x1a, 0x97, 0x5d, 0x57, 0xbf, 0xca, 0x75, 0xbf, 0x43, 0xb4, 0x05, 0x3d, 0x1a, 0x8b, 0x7a, 0x68,
+	0x82, 0x51, 0x35, 0x1f, 0xa5, 0xf6, 0xbd, 0x06, 0x0d, 0x5d, 0x35, 0x69, 0x5b, 0x97, 0x27, 0xad,
+	0x5d, 0xe5, 0x5e, 0xec, 0x43, 0x37, 0xb7, 0xaf, 0x87, 0xff, 0xcb, 0x50, 0x2a, 0xf7, 0x2f, 0x00,
+	0x39, 0xb2, 0x17, 0x9c, 0x5e, 0xf4, 0x74, 0xa5, 0xec, 0xe9, 0x5f, 0x6a, 0xd0, 0xf5, 0x30, 0x10,
+	0x67, 0x98, 0x4e, 0xf3, 0xd6, 0x6c, 0x02, 0x9c, 0x8b, 0x34, 0xb4, 0x87, 0xcf, 0x67, 0x44, 0x4b,
+	0x23, 0xe6, 0xec, 0xd7, 0x2b, 0x5e, 0xfd, 0x26, 0xc5, 0x6b, 0x37, 0x29, 0x5e, 0xbf, 0x51, 0xf1,
+	0xdb, 0x65, 0xc5, 0x1f, 0x43, 0x1f, 0xf9, 0x48, 0xa4, 0x01, 0xfa, 0xfa, 0xac, 0x11, 0x93, 0xca,
+	0xb4, 0xa4, 0xe9, 0xf5, 0x72, 0xfc, 0x73, 0x0e, 0x93, 0x13, 0xa8, 0xab, 0x69, 0x82, 0x46, 0xf4,
+	0xee, 0xee, 0x3f, 0x6f, 0x98, 0xff, 0x17, 0xd5, 0x59, 0x08, 0xed, 0x4d, 0xd5, 0xbb, 0x2d, 0xb6,
+	0xbc, 0x75, 0xa9, 0xe5, 0x6b, 0xd0, 0x08, 0xd3, 0xa9, 0x9f, 0x66, 0xdc, 0xfc, 0x75, 0xd5, 0xf4,
+	0x96, 0xc2, 0x74, 0xea, 0x65, 0xdc, 0xfd, 0x0f, 0x90, 0xcb, 0xbb, 0x92, 0x1d, 0x78, 0x70, 0x19,
+	0xf5, 0x8f, 0x83, 0x94, 0xc6, 0xc3, 0x08, 0x43, 0x5d, 0x8d, 0xec, 0xdf, 0x22, 0x9b, 0xb0, 0x7e,
+	0x05, 0xed, 0x90, 0xaa, 0x94, 0xfd, 0xbf, 0x5f, 0x71, 0x7f, 0xaa, 0xc0, 0xb2, 0xa6, 0xe6, 0xbe,
+	0x20, 0x1f, 0xf3, 0xda, 0x2b, 0xa6, 0xf6, 0x17, 0x37, 0xd4, 0x5e, 0xfa, 0xb2, 0xbc, 0x9e, 0x57,
+	0xed, 0x8e, 0xa0, 0xb7, 0x90, 0x20, 0xeb, 0xb0, 0xba, 0x00, 0xf9, 0x47, 0x11, 0x65, 0xbc, 0x7f,
+	0x8b, 0x6c, 0xc0, 0xda, 0x62, 0xca, 0x9e, 0xf4, 0x79, 0xbf, 0x72, 0x7d, 0xf2, 0x59, 0xbf, 0xea,
+	0x6e, 0x42, 0x43, 0x27, 0xb5, 0x99, 0x09, 0xd4, 0x75, 0x87, 0xcd, 0x74, 0x6e, 0x79, 0x66, 0xed,
+	0xfe, 0x0d, 0x3a, 0xc7, 0xa8, 0xfe, 0xbd, 0xfb, 0xba, 0x74, 0xbf, 0xca, 0xdd, 0xa8, 0x2c, 0x76,
+	0xe3, 0xe5, 0x3f, 0x60, 0x3b, 0x10, 0xf1, 0x40, 0x52, 0x25, 0xe4, 0x84, 0x45, 0x74, 0x28, 0x0b,
+	0x21, 0x22, 0x36, 0xb4, 0xff, 0xbb, 0x0c, 0xb3, 0xd1, 0xcb, 0xb5, 0x13, 0x03, 0x1e, 0x5a, 0x71,
+	0x0e, 0x67, 0xd2, 0xfc, 0x1a, 0x00, 0x00, 0xff, 0xff, 0xd7, 0x6e, 0xfc, 0x59, 0x29, 0x0d, 0x00,
+	0x00,
+}
diff --git a/accounts/usbwallet/trezor/messages-management.proto b/accounts/usbwallet/trezor/messages-management.proto
new file mode 100644
index 000000000..0ab825a1b
--- /dev/null
+++ b/accounts/usbwallet/trezor/messages-management.proto
@@ -0,0 +1,289 @@
+// This file originates from the SatoshiLabs Trezor `common` repository at:
+//   https://github.com/trezor/trezor-common/blob/master/protob/messages-management.proto
+// dated 28.05.2019, commit 893fd219d4a01bcffa0cd9cfa631856371ec5aa9.
+
+syntax = "proto2";
+package hw.trezor.messages.management;
+
+// Sugar for easier handling in Java
+option java_package = "com.satoshilabs.trezor.lib.protobuf";
+option java_outer_classname = "TrezorMessageManagement";
+
+import "messages-common.proto";
+
+/**
+ * Request: Reset device to default state and ask for device details
+ * @start
+ * @next Features
+ */
+message Initialize {
+    optional bytes state = 1;           // assumed device state, clear session if set and different
+    optional bool skip_passphrase = 2;  // this session should always assume empty passphrase
+}
+
+/**
+ * Request: Ask for device details (no device reset)
+ * @start
+ * @next Features
+ */
+message GetFeatures {
+}
+
+/**
+ * Response: Reports various information about the device
+ * @end
+ */
+message Features {
+    optional string vendor = 1;                 // name of the manufacturer, e.g. "trezor.io"
+    optional uint32 major_version = 2;          // major version of the firmware/bootloader, e.g. 1
+    optional uint32 minor_version = 3;          // minor version of the firmware/bootloader, e.g. 0
+    optional uint32 patch_version = 4;          // patch version of the firmware/bootloader, e.g. 0
+    optional bool bootloader_mode = 5;          // is device in bootloader mode?
+    optional string device_id = 6;              // device's unique identifier
+    optional bool pin_protection = 7;           // is device protected by PIN?
+    optional bool passphrase_protection = 8;    // is node/mnemonic encrypted using passphrase?
+    optional string language = 9;               // device language
+    optional string label = 10;                 // device description label
+    optional bool initialized = 12;             // does device contain seed?
+    optional bytes revision = 13;               // SCM revision of firmware
+    optional bytes bootloader_hash = 14;        // hash of the bootloader
+    optional bool imported = 15;                // was storage imported from an external source?
+    optional bool pin_cached = 16;              // is PIN already cached in session?
+    optional bool passphrase_cached = 17;       // is passphrase already cached in session?
+    optional bool firmware_present = 18;        // is valid firmware loaded?
+    optional bool needs_backup = 19;            // does storage need backup? (equals to Storage.needs_backup)
+    optional uint32 flags = 20;                 // device flags (equals to Storage.flags)
+    optional string model = 21;                 // device hardware model
+    optional uint32 fw_major = 22;              // reported firmware version if in bootloader mode
+    optional uint32 fw_minor = 23;              // reported firmware version if in bootloader mode
+    optional uint32 fw_patch = 24;              // reported firmware version if in bootloader mode
+    optional string fw_vendor = 25;             // reported firmware vendor if in bootloader mode
+    optional bytes fw_vendor_keys = 26;         // reported firmware vendor keys (their hash)
+    optional bool unfinished_backup = 27;       // report unfinished backup (equals to Storage.unfinished_backup)
+    optional bool no_backup = 28;               // report no backup (equals to Storage.no_backup)
+}
+
+/**
+ * Request: clear session (removes cached PIN, passphrase, etc).
+ * @start
+ * @next Success
+ */
+message ClearSession {
+}
+
+/**
+ * Request: change language and/or label of the device
+ * @start
+ * @next Success
+ * @next Failure
+ */
+message ApplySettings {
+    optional string language = 1;
+    optional string label = 2;
+    optional bool use_passphrase = 3;
+    optional bytes homescreen = 4;
+    optional PassphraseSourceType passphrase_source = 5;
+    optional uint32 auto_lock_delay_ms = 6;
+    optional uint32 display_rotation = 7;  // in degrees from North
+    /**
+    * Structure representing passphrase source
+    */
+    enum PassphraseSourceType {
+        ASK = 0;
+        DEVICE = 1;
+        HOST = 2;
+    }
+}
+
+/**
+ * Request: set flags of the device
+ * @start
+ * @next Success
+ * @next Failure
+ */
+message ApplyFlags {
+    optional uint32 flags = 1;  // bitmask, can only set bits, not unset
+}
+
+/**
+ * Request: Starts workflow for setting/changing/removing the PIN
+ * @start
+ * @next Success
+ * @next Failure
+ */
+message ChangePin {
+    optional bool remove = 1;   // is PIN removal requested?
+}
+
+/**
+ * Request: Test if the device is alive, device sends back the message in Success response
+ * @start
+ * @next Success
+ */
+message Ping {
+    optional string message = 1;                // message to send back in Success message
+    optional bool button_protection = 2;        // ask for button press
+    optional bool pin_protection = 3;           // ask for PIN if set in device
+    optional bool passphrase_protection = 4;    // ask for passphrase if set in device
+}
+
+/**
+ * Request: Abort last operation that required user interaction
+ * @start
+ * @next Failure
+ */
+message Cancel {
+}
+
+/**
+ * Request: Request a sample of random data generated by hardware RNG. May be used for testing.
+ * @start
+ * @next Entropy
+ * @next Failure
+ */
+message GetEntropy {
+    required uint32 size = 1;       // size of requested entropy
+}
+
+/**
+ * Response: Reply with random data generated by internal RNG
+ * @end
+ */
+message Entropy {
+    required bytes entropy = 1;     // chunk of random generated bytes
+}
+
+/**
+ * Request: Request device to wipe all sensitive data and settings
+ * @start
+ * @next Success
+ * @next Failure
+ */
+message WipeDevice {
+}
+
+/**
+ * Request: Load seed and related internal settings from the computer
+ * @start
+ * @next Success
+ * @next Failure
+ */
+message LoadDevice {
+    optional string mnemonic = 1;                           // seed encoded as BIP-39 mnemonic (12, 18 or 24 words)
+    optional hw.trezor.messages.common.HDNodeType node = 2; // BIP-32 node
+    optional string pin = 3;                                // set PIN protection
+    optional bool passphrase_protection = 4;                // enable master node encryption using passphrase
+    optional string language = 5 [default='english'];       // device language
+    optional string label = 6;                              // device label
+    optional bool skip_checksum = 7;                        // do not test mnemonic for valid BIP-39 checksum
+    optional uint32 u2f_counter = 8;                        // U2F counter
+}
+
+/**
+ * Request: Ask device to do initialization involving user interaction
+ * @start
+ * @next EntropyRequest
+ * @next Failure
+ */
+message ResetDevice {
+    optional bool display_random = 1;                   // display entropy generated by the device before asking for additional entropy
+    optional uint32 strength = 2 [default=256];         // strength of seed in bits
+    optional bool passphrase_protection = 3;            // enable master node encryption using passphrase
+    optional bool pin_protection = 4;                   // enable PIN protection
+    optional string language = 5 [default='english'];   // device language
+    optional string label = 6;                          // device label
+    optional uint32 u2f_counter = 7;                    // U2F counter
+    optional bool skip_backup = 8;                      // postpone seed backup to BackupDevice workflow
+    optional bool no_backup = 9;                        // indicate that no backup is going to be made
+}
+
+/**
+ * Request: Perform backup of the device seed if not backed up using ResetDevice
+ * @start
+ * @next Success
+ */
+message BackupDevice {
+}
+
+/**
+ * Response: Ask for additional entropy from host computer
+ * @next EntropyAck
+ */
+message EntropyRequest {
+}
+
+/**
+ * Request: Provide additional entropy for seed generation function
+ * @next Success
+ */
+message EntropyAck {
+    optional bytes entropy = 1;     // 256 bits (32 bytes) of random data
+}
+
+/**
+ * Request: Start recovery workflow asking user for specific words of mnemonic
+ * Used to recovery device safely even on untrusted computer.
+ * @start
+ * @next WordRequest
+ */
+message RecoveryDevice {
+    optional uint32 word_count = 1;                     // number of words in BIP-39 mnemonic
+    optional bool passphrase_protection = 2;            // enable master node encryption using passphrase
+    optional bool pin_protection = 3;                   // enable PIN protection
+    optional string language = 4 [default='english'];   // device language
+    optional string label = 5;                          // device label
+    optional bool enforce_wordlist = 6;                 // enforce BIP-39 wordlist during the process
+    // 7 reserved for unused recovery method
+    optional RecoveryDeviceType type = 8;               // supported recovery type
+    optional uint32 u2f_counter = 9;                    // U2F counter
+    optional bool dry_run = 10;                         // perform dry-run recovery workflow (for safe mnemonic validation)
+    /**
+     * Type of recovery procedure. These should be used as bitmask, e.g.,
+     * `RecoveryDeviceType_ScrambledWords | RecoveryDeviceType_Matrix`
+     * listing every method supported by the host computer.
+     *
+     * Note that ScrambledWords must be supported by every implementation
+     * for backward compatibility; there is no way to not support it.
+     */
+    enum RecoveryDeviceType {
+        // use powers of two when extending this field
+        RecoveryDeviceType_ScrambledWords = 0;        // words in scrambled order
+        RecoveryDeviceType_Matrix = 1;                // matrix recovery type
+    }
+}
+
+/**
+ * Response: Device is waiting for user to enter word of the mnemonic
+ * Its position is shown only on device's internal display.
+ * @next WordAck
+ */
+message WordRequest {
+    optional WordRequestType type = 1;
+    /**
+    * Type of Recovery Word request
+    */
+    enum WordRequestType {
+        WordRequestType_Plain = 0;
+        WordRequestType_Matrix9 = 1;
+        WordRequestType_Matrix6 = 2;
+    }
+}
+
+/**
+ * Request: Computer replies with word from the mnemonic
+ * @next WordRequest
+ * @next Success
+ * @next Failure
+ */
+message WordAck {
+    required string word = 1;           // one word of mnemonic on asked position
+}
+
+/**
+ * Request: Set U2F counter
+ * @start
+ * @next Success
+ */
+message SetU2FCounter {
+    optional uint32 u2f_counter = 1;    // counter
+}
diff --git a/accounts/usbwallet/trezor/messages.pb.go b/accounts/usbwallet/trezor/messages.pb.go
new file mode 100644
index 000000000..6278bd8ee
--- /dev/null
+++ b/accounts/usbwallet/trezor/messages.pb.go
@@ -0,0 +1,889 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: messages.proto
+
+package trezor
+
+import (
+	fmt "fmt"
+	math "math"
+
+	proto "github.com/golang/protobuf/proto"
+	descriptor "github.com/golang/protobuf/protoc-gen-go/descriptor"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
+
+//*
+// Mapping between TREZOR wire identifier (uint) and a protobuf message
+type MessageType int32
+
+const (
+	// Management
+	MessageType_MessageType_Initialize             MessageType = 0
+	MessageType_MessageType_Ping                   MessageType = 1
+	MessageType_MessageType_Success                MessageType = 2
+	MessageType_MessageType_Failure                MessageType = 3
+	MessageType_MessageType_ChangePin              MessageType = 4
+	MessageType_MessageType_WipeDevice             MessageType = 5
+	MessageType_MessageType_GetEntropy             MessageType = 9
+	MessageType_MessageType_Entropy                MessageType = 10
+	MessageType_MessageType_LoadDevice             MessageType = 13
+	MessageType_MessageType_ResetDevice            MessageType = 14
+	MessageType_MessageType_Features               MessageType = 17
+	MessageType_MessageType_PinMatrixRequest       MessageType = 18
+	MessageType_MessageType_PinMatrixAck           MessageType = 19
+	MessageType_MessageType_Cancel                 MessageType = 20
+	MessageType_MessageType_ClearSession           MessageType = 24
+	MessageType_MessageType_ApplySettings          MessageType = 25
+	MessageType_MessageType_ButtonRequest          MessageType = 26
+	MessageType_MessageType_ButtonAck              MessageType = 27
+	MessageType_MessageType_ApplyFlags             MessageType = 28
+	MessageType_MessageType_BackupDevice           MessageType = 34
+	MessageType_MessageType_EntropyRequest         MessageType = 35
+	MessageType_MessageType_EntropyAck             MessageType = 36
+	MessageType_MessageType_PassphraseRequest      MessageType = 41
+	MessageType_MessageType_PassphraseAck          MessageType = 42
+	MessageType_MessageType_PassphraseStateRequest MessageType = 77
+	MessageType_MessageType_PassphraseStateAck     MessageType = 78
+	MessageType_MessageType_RecoveryDevice         MessageType = 45
+	MessageType_MessageType_WordRequest            MessageType = 46
+	MessageType_MessageType_WordAck                MessageType = 47
+	MessageType_MessageType_GetFeatures            MessageType = 55
+	MessageType_MessageType_SetU2FCounter          MessageType = 63
+	// Bootloader
+	MessageType_MessageType_FirmwareErase   MessageType = 6
+	MessageType_MessageType_FirmwareUpload  MessageType = 7
+	MessageType_MessageType_FirmwareRequest MessageType = 8
+	MessageType_MessageType_SelfTest        MessageType = 32
+	// Bitcoin
+	MessageType_MessageType_GetPublicKey     MessageType = 11
+	MessageType_MessageType_PublicKey        MessageType = 12
+	MessageType_MessageType_SignTx           MessageType = 15
+	MessageType_MessageType_TxRequest        MessageType = 21
+	MessageType_MessageType_TxAck            MessageType = 22
+	MessageType_MessageType_GetAddress       MessageType = 29
+	MessageType_MessageType_Address          MessageType = 30
+	MessageType_MessageType_SignMessage      MessageType = 38
+	MessageType_MessageType_VerifyMessage    MessageType = 39
+	MessageType_MessageType_MessageSignature MessageType = 40
+	// Crypto
+	MessageType_MessageType_CipherKeyValue    MessageType = 23
+	MessageType_MessageType_CipheredKeyValue  MessageType = 48
+	MessageType_MessageType_SignIdentity      MessageType = 53
+	MessageType_MessageType_SignedIdentity    MessageType = 54
+	MessageType_MessageType_GetECDHSessionKey MessageType = 61
+	MessageType_MessageType_ECDHSessionKey    MessageType = 62
+	MessageType_MessageType_CosiCommit        MessageType = 71
+	MessageType_MessageType_CosiCommitment    MessageType = 72
+	MessageType_MessageType_CosiSign          MessageType = 73
+	MessageType_MessageType_CosiSignature     MessageType = 74
+	// Debug
+	MessageType_MessageType_DebugLinkDecision    MessageType = 100
+	MessageType_MessageType_DebugLinkGetState    MessageType = 101
+	MessageType_MessageType_DebugLinkState       MessageType = 102
+	MessageType_MessageType_DebugLinkStop        MessageType = 103
+	MessageType_MessageType_DebugLinkLog         MessageType = 104
+	MessageType_MessageType_DebugLinkMemoryRead  MessageType = 110
+	MessageType_MessageType_DebugLinkMemory      MessageType = 111
+	MessageType_MessageType_DebugLinkMemoryWrite MessageType = 112
+	MessageType_MessageType_DebugLinkFlashErase  MessageType = 113
+	// Ethereum
+	MessageType_MessageType_EthereumGetPublicKey     MessageType = 450
+	MessageType_MessageType_EthereumPublicKey        MessageType = 451
+	MessageType_MessageType_EthereumGetAddress       MessageType = 56
+	MessageType_MessageType_EthereumAddress          MessageType = 57
+	MessageType_MessageType_EthereumSignTx           MessageType = 58
+	MessageType_MessageType_EthereumTxRequest        MessageType = 59
+	MessageType_MessageType_EthereumTxAck            MessageType = 60
+	MessageType_MessageType_EthereumSignMessage      MessageType = 64
+	MessageType_MessageType_EthereumVerifyMessage    MessageType = 65
+	MessageType_MessageType_EthereumMessageSignature MessageType = 66
+	// NEM
+	MessageType_MessageType_NEMGetAddress       MessageType = 67
+	MessageType_MessageType_NEMAddress          MessageType = 68
+	MessageType_MessageType_NEMSignTx           MessageType = 69
+	MessageType_MessageType_NEMSignedTx         MessageType = 70
+	MessageType_MessageType_NEMDecryptMessage   MessageType = 75
+	MessageType_MessageType_NEMDecryptedMessage MessageType = 76
+	// Lisk
+	MessageType_MessageType_LiskGetAddress       MessageType = 114
+	MessageType_MessageType_LiskAddress          MessageType = 115
+	MessageType_MessageType_LiskSignTx           MessageType = 116
+	MessageType_MessageType_LiskSignedTx         MessageType = 117
+	MessageType_MessageType_LiskSignMessage      MessageType = 118
+	MessageType_MessageType_LiskMessageSignature MessageType = 119
+	MessageType_MessageType_LiskVerifyMessage    MessageType = 120
+	MessageType_MessageType_LiskGetPublicKey     MessageType = 121
+	MessageType_MessageType_LiskPublicKey        MessageType = 122
+	// Tezos
+	MessageType_MessageType_TezosGetAddress   MessageType = 150
+	MessageType_MessageType_TezosAddress      MessageType = 151
+	MessageType_MessageType_TezosSignTx       MessageType = 152
+	MessageType_MessageType_TezosSignedTx     MessageType = 153
+	MessageType_MessageType_TezosGetPublicKey MessageType = 154
+	MessageType_MessageType_TezosPublicKey    MessageType = 155
+	// Stellar
+	MessageType_MessageType_StellarSignTx               MessageType = 202
+	MessageType_MessageType_StellarTxOpRequest          MessageType = 203
+	MessageType_MessageType_StellarGetAddress           MessageType = 207
+	MessageType_MessageType_StellarAddress              MessageType = 208
+	MessageType_MessageType_StellarCreateAccountOp      MessageType = 210
+	MessageType_MessageType_StellarPaymentOp            MessageType = 211
+	MessageType_MessageType_StellarPathPaymentOp        MessageType = 212
+	MessageType_MessageType_StellarManageOfferOp        MessageType = 213
+	MessageType_MessageType_StellarCreatePassiveOfferOp MessageType = 214
+	MessageType_MessageType_StellarSetOptionsOp         MessageType = 215
+	MessageType_MessageType_StellarChangeTrustOp        MessageType = 216
+	MessageType_MessageType_StellarAllowTrustOp         MessageType = 217
+	MessageType_MessageType_StellarAccountMergeOp       MessageType = 218
+	// omitted: StellarInflationOp is not a supported operation, would be 219
+	MessageType_MessageType_StellarManageDataOp   MessageType = 220
+	MessageType_MessageType_StellarBumpSequenceOp MessageType = 221
+	MessageType_MessageType_StellarSignedTx       MessageType = 230
+	// TRON
+	MessageType_MessageType_TronGetAddress MessageType = 250
+	MessageType_MessageType_TronAddress    MessageType = 251
+	MessageType_MessageType_TronSignTx     MessageType = 252
+	MessageType_MessageType_TronSignedTx   MessageType = 253
+	// Cardano
+	// dropped Sign/VerifyMessage ids 300-302
+	MessageType_MessageType_CardanoSignTx       MessageType = 303
+	MessageType_MessageType_CardanoTxRequest    MessageType = 304
+	MessageType_MessageType_CardanoGetPublicKey MessageType = 305
+	MessageType_MessageType_CardanoPublicKey    MessageType = 306
+	MessageType_MessageType_CardanoGetAddress   MessageType = 307
+	MessageType_MessageType_CardanoAddress      MessageType = 308
+	MessageType_MessageType_CardanoTxAck        MessageType = 309
+	MessageType_MessageType_CardanoSignedTx     MessageType = 310
+	// Ontology
+	MessageType_MessageType_OntologyGetAddress               MessageType = 350
+	MessageType_MessageType_OntologyAddress                  MessageType = 351
+	MessageType_MessageType_OntologyGetPublicKey             MessageType = 352
+	MessageType_MessageType_OntologyPublicKey                MessageType = 353
+	MessageType_MessageType_OntologySignTransfer             MessageType = 354
+	MessageType_MessageType_OntologySignedTransfer           MessageType = 355
+	MessageType_MessageType_OntologySignWithdrawOng          MessageType = 356
+	MessageType_MessageType_OntologySignedWithdrawOng        MessageType = 357
+	MessageType_MessageType_OntologySignOntIdRegister        MessageType = 358
+	MessageType_MessageType_OntologySignedOntIdRegister      MessageType = 359
+	MessageType_MessageType_OntologySignOntIdAddAttributes   MessageType = 360
+	MessageType_MessageType_OntologySignedOntIdAddAttributes MessageType = 361
+	// Ripple
+	MessageType_MessageType_RippleGetAddress MessageType = 400
+	MessageType_MessageType_RippleAddress    MessageType = 401
+	MessageType_MessageType_RippleSignTx     MessageType = 402
+	MessageType_MessageType_RippleSignedTx   MessageType = 403
+	// Monero
+	MessageType_MessageType_MoneroTransactionInitRequest              MessageType = 501
+	MessageType_MessageType_MoneroTransactionInitAck                  MessageType = 502
+	MessageType_MessageType_MoneroTransactionSetInputRequest          MessageType = 503
+	MessageType_MessageType_MoneroTransactionSetInputAck              MessageType = 504
+	MessageType_MessageType_MoneroTransactionInputsPermutationRequest MessageType = 505
+	MessageType_MessageType_MoneroTransactionInputsPermutationAck     MessageType = 506
+	MessageType_MessageType_MoneroTransactionInputViniRequest         MessageType = 507
+	MessageType_MessageType_MoneroTransactionInputViniAck             MessageType = 508
+	MessageType_MessageType_MoneroTransactionAllInputsSetRequest      MessageType = 509
+	MessageType_MessageType_MoneroTransactionAllInputsSetAck          MessageType = 510
+	MessageType_MessageType_MoneroTransactionSetOutputRequest         MessageType = 511
+	MessageType_MessageType_MoneroTransactionSetOutputAck             MessageType = 512
+	MessageType_MessageType_MoneroTransactionAllOutSetRequest         MessageType = 513
+	MessageType_MessageType_MoneroTransactionAllOutSetAck             MessageType = 514
+	MessageType_MessageType_MoneroTransactionSignInputRequest         MessageType = 515
+	MessageType_MessageType_MoneroTransactionSignInputAck             MessageType = 516
+	MessageType_MessageType_MoneroTransactionFinalRequest             MessageType = 517
+	MessageType_MessageType_MoneroTransactionFinalAck                 MessageType = 518
+	MessageType_MessageType_MoneroKeyImageExportInitRequest           MessageType = 530
+	MessageType_MessageType_MoneroKeyImageExportInitAck               MessageType = 531
+	MessageType_MessageType_MoneroKeyImageSyncStepRequest             MessageType = 532
+	MessageType_MessageType_MoneroKeyImageSyncStepAck                 MessageType = 533
+	MessageType_MessageType_MoneroKeyImageSyncFinalRequest            MessageType = 534
+	MessageType_MessageType_MoneroKeyImageSyncFinalAck                MessageType = 535
+	MessageType_MessageType_MoneroGetAddress                          MessageType = 540
+	MessageType_MessageType_MoneroAddress                             MessageType = 541
+	MessageType_MessageType_MoneroGetWatchKey                         MessageType = 542
+	MessageType_MessageType_MoneroWatchKey                            MessageType = 543
+	MessageType_MessageType_DebugMoneroDiagRequest                    MessageType = 546
+	MessageType_MessageType_DebugMoneroDiagAck                        MessageType = 547
+	MessageType_MessageType_MoneroGetTxKeyRequest                     MessageType = 550
+	MessageType_MessageType_MoneroGetTxKeyAck                         MessageType = 551
+	MessageType_MessageType_MoneroLiveRefreshStartRequest             MessageType = 552
+	MessageType_MessageType_MoneroLiveRefreshStartAck                 MessageType = 553
+	MessageType_MessageType_MoneroLiveRefreshStepRequest              MessageType = 554
+	MessageType_MessageType_MoneroLiveRefreshStepAck                  MessageType = 555
+	MessageType_MessageType_MoneroLiveRefreshFinalRequest             MessageType = 556
+	MessageType_MessageType_MoneroLiveRefreshFinalAck                 MessageType = 557
+	// EOS
+	MessageType_MessageType_EosGetPublicKey    MessageType = 600
+	MessageType_MessageType_EosPublicKey       MessageType = 601
+	MessageType_MessageType_EosSignTx          MessageType = 602
+	MessageType_MessageType_EosTxActionRequest MessageType = 603
+	MessageType_MessageType_EosTxActionAck     MessageType = 604
+	MessageType_MessageType_EosSignedTx        MessageType = 605
+	// Binance
+	MessageType_MessageType_BinanceGetAddress   MessageType = 700
+	MessageType_MessageType_BinanceAddress      MessageType = 701
+	MessageType_MessageType_BinanceGetPublicKey MessageType = 702
+	MessageType_MessageType_BinancePublicKey    MessageType = 703
+	MessageType_MessageType_BinanceSignTx       MessageType = 704
+	MessageType_MessageType_BinanceTxRequest    MessageType = 705
+	MessageType_MessageType_BinanceTransferMsg  MessageType = 706
+	MessageType_MessageType_BinanceOrderMsg     MessageType = 707
+	MessageType_MessageType_BinanceCancelMsg    MessageType = 708
+	MessageType_MessageType_BinanceSignedTx     MessageType = 709
+)
+
+var MessageType_name = map[int32]string{
+	0:   "MessageType_Initialize",
+	1:   "MessageType_Ping",
+	2:   "MessageType_Success",
+	3:   "MessageType_Failure",
+	4:   "MessageType_ChangePin",
+	5:   "MessageType_WipeDevice",
+	9:   "MessageType_GetEntropy",
+	10:  "MessageType_Entropy",
+	13:  "MessageType_LoadDevice",
+	14:  "MessageType_ResetDevice",
+	17:  "MessageType_Features",
+	18:  "MessageType_PinMatrixRequest",
+	19:  "MessageType_PinMatrixAck",
+	20:  "MessageType_Cancel",
+	24:  "MessageType_ClearSession",
+	25:  "MessageType_ApplySettings",
+	26:  "MessageType_ButtonRequest",
+	27:  "MessageType_ButtonAck",
+	28:  "MessageType_ApplyFlags",
+	34:  "MessageType_BackupDevice",
+	35:  "MessageType_EntropyRequest",
+	36:  "MessageType_EntropyAck",
+	41:  "MessageType_PassphraseRequest",
+	42:  "MessageType_PassphraseAck",
+	77:  "MessageType_PassphraseStateRequest",
+	78:  "MessageType_PassphraseStateAck",
+	45:  "MessageType_RecoveryDevice",
+	46:  "MessageType_WordRequest",
+	47:  "MessageType_WordAck",
+	55:  "MessageType_GetFeatures",
+	63:  "MessageType_SetU2FCounter",
+	6:   "MessageType_FirmwareErase",
+	7:   "MessageType_FirmwareUpload",
+	8:   "MessageType_FirmwareRequest",
+	32:  "MessageType_SelfTest",
+	11:  "MessageType_GetPublicKey",
+	12:  "MessageType_PublicKey",
+	15:  "MessageType_SignTx",
+	21:  "MessageType_TxRequest",
+	22:  "MessageType_TxAck",
+	29:  "MessageType_GetAddress",
+	30:  "MessageType_Address",
+	38:  "MessageType_SignMessage",
+	39:  "MessageType_VerifyMessage",
+	40:  "MessageType_MessageSignature",
+	23:  "MessageType_CipherKeyValue",
+	48:  "MessageType_CipheredKeyValue",
+	53:  "MessageType_SignIdentity",
+	54:  "MessageType_SignedIdentity",
+	61:  "MessageType_GetECDHSessionKey",
+	62:  "MessageType_ECDHSessionKey",
+	71:  "MessageType_CosiCommit",
+	72:  "MessageType_CosiCommitment",
+	73:  "MessageType_CosiSign",
+	74:  "MessageType_CosiSignature",
+	100: "MessageType_DebugLinkDecision",
+	101: "MessageType_DebugLinkGetState",
+	102: "MessageType_DebugLinkState",
+	103: "MessageType_DebugLinkStop",
+	104: "MessageType_DebugLinkLog",
+	110: "MessageType_DebugLinkMemoryRead",
+	111: "MessageType_DebugLinkMemory",
+	112: "MessageType_DebugLinkMemoryWrite",
+	113: "MessageType_DebugLinkFlashErase",
+	450: "MessageType_EthereumGetPublicKey",
+	451: "MessageType_EthereumPublicKey",
+	56:  "MessageType_EthereumGetAddress",
+	57:  "MessageType_EthereumAddress",
+	58:  "MessageType_EthereumSignTx",
+	59:  "MessageType_EthereumTxRequest",
+	60:  "MessageType_EthereumTxAck",
+	64:  "MessageType_EthereumSignMessage",
+	65:  "MessageType_EthereumVerifyMessage",
+	66:  "MessageType_EthereumMessageSignature",
+	67:  "MessageType_NEMGetAddress",
+	68:  "MessageType_NEMAddress",
+	69:  "MessageType_NEMSignTx",
+	70:  "MessageType_NEMSignedTx",
+	75:  "MessageType_NEMDecryptMessage",
+	76:  "MessageType_NEMDecryptedMessage",
+	114: "MessageType_LiskGetAddress",
+	115: "MessageType_LiskAddress",
+	116: "MessageType_LiskSignTx",
+	117: "MessageType_LiskSignedTx",
+	118: "MessageType_LiskSignMessage",
+	119: "MessageType_LiskMessageSignature",
+	120: "MessageType_LiskVerifyMessage",
+	121: "MessageType_LiskGetPublicKey",
+	122: "MessageType_LiskPublicKey",
+	150: "MessageType_TezosGetAddress",
+	151: "MessageType_TezosAddress",
+	152: "MessageType_TezosSignTx",
+	153: "MessageType_TezosSignedTx",
+	154: "MessageType_TezosGetPublicKey",
+	155: "MessageType_TezosPublicKey",
+	202: "MessageType_StellarSignTx",
+	203: "MessageType_StellarTxOpRequest",
+	207: "MessageType_StellarGetAddress",
+	208: "MessageType_StellarAddress",
+	210: "MessageType_StellarCreateAccountOp",
+	211: "MessageType_StellarPaymentOp",
+	212: "MessageType_StellarPathPaymentOp",
+	213: "MessageType_StellarManageOfferOp",
+	214: "MessageType_StellarCreatePassiveOfferOp",
+	215: "MessageType_StellarSetOptionsOp",
+	216: "MessageType_StellarChangeTrustOp",
+	217: "MessageType_StellarAllowTrustOp",
+	218: "MessageType_StellarAccountMergeOp",
+	220: "MessageType_StellarManageDataOp",
+	221: "MessageType_StellarBumpSequenceOp",
+	230: "MessageType_StellarSignedTx",
+	250: "MessageType_TronGetAddress",
+	251: "MessageType_TronAddress",
+	252: "MessageType_TronSignTx",
+	253: "MessageType_TronSignedTx",
+	303: "MessageType_CardanoSignTx",
+	304: "MessageType_CardanoTxRequest",
+	305: "MessageType_CardanoGetPublicKey",
+	306: "MessageType_CardanoPublicKey",
+	307: "MessageType_CardanoGetAddress",
+	308: "MessageType_CardanoAddress",
+	309: "MessageType_CardanoTxAck",
+	310: "MessageType_CardanoSignedTx",
+	350: "MessageType_OntologyGetAddress",
+	351: "MessageType_OntologyAddress",
+	352: "MessageType_OntologyGetPublicKey",
+	353: "MessageType_OntologyPublicKey",
+	354: "MessageType_OntologySignTransfer",
+	355: "MessageType_OntologySignedTransfer",
+	356: "MessageType_OntologySignWithdrawOng",
+	357: "MessageType_OntologySignedWithdrawOng",
+	358: "MessageType_OntologySignOntIdRegister",
+	359: "MessageType_OntologySignedOntIdRegister",
+	360: "MessageType_OntologySignOntIdAddAttributes",
+	361: "MessageType_OntologySignedOntIdAddAttributes",
+	400: "MessageType_RippleGetAddress",
+	401: "MessageType_RippleAddress",
+	402: "MessageType_RippleSignTx",
+	403: "MessageType_RippleSignedTx",
+	501: "MessageType_MoneroTransactionInitRequest",
+	502: "MessageType_MoneroTransactionInitAck",
+	503: "MessageType_MoneroTransactionSetInputRequest",
+	504: "MessageType_MoneroTransactionSetInputAck",
+	505: "MessageType_MoneroTransactionInputsPermutationRequest",
+	506: "MessageType_MoneroTransactionInputsPermutationAck",
+	507: "MessageType_MoneroTransactionInputViniRequest",
+	508: "MessageType_MoneroTransactionInputViniAck",
+	509: "MessageType_MoneroTransactionAllInputsSetRequest",
+	510: "MessageType_MoneroTransactionAllInputsSetAck",
+	511: "MessageType_MoneroTransactionSetOutputRequest",
+	512: "MessageType_MoneroTransactionSetOutputAck",
+	513: "MessageType_MoneroTransactionAllOutSetRequest",
+	514: "MessageType_MoneroTransactionAllOutSetAck",
+	515: "MessageType_MoneroTransactionSignInputRequest",
+	516: "MessageType_MoneroTransactionSignInputAck",
+	517: "MessageType_MoneroTransactionFinalRequest",
+	518: "MessageType_MoneroTransactionFinalAck",
+	530: "MessageType_MoneroKeyImageExportInitRequest",
+	531: "MessageType_MoneroKeyImageExportInitAck",
+	532: "MessageType_MoneroKeyImageSyncStepRequest",
+	533: "MessageType_MoneroKeyImageSyncStepAck",
+	534: "MessageType_MoneroKeyImageSyncFinalRequest",
+	535: "MessageType_MoneroKeyImageSyncFinalAck",
+	540: "MessageType_MoneroGetAddress",
+	541: "MessageType_MoneroAddress",
+	542: "MessageType_MoneroGetWatchKey",
+	543: "MessageType_MoneroWatchKey",
+	546: "MessageType_DebugMoneroDiagRequest",
+	547: "MessageType_DebugMoneroDiagAck",
+	550: "MessageType_MoneroGetTxKeyRequest",
+	551: "MessageType_MoneroGetTxKeyAck",
+	552: "MessageType_MoneroLiveRefreshStartRequest",
+	553: "MessageType_MoneroLiveRefreshStartAck",
+	554: "MessageType_MoneroLiveRefreshStepRequest",
+	555: "MessageType_MoneroLiveRefreshStepAck",
+	556: "MessageType_MoneroLiveRefreshFinalRequest",
+	557: "MessageType_MoneroLiveRefreshFinalAck",
+	600: "MessageType_EosGetPublicKey",
+	601: "MessageType_EosPublicKey",
+	602: "MessageType_EosSignTx",
+	603: "MessageType_EosTxActionRequest",
+	604: "MessageType_EosTxActionAck",
+	605: "MessageType_EosSignedTx",
+	700: "MessageType_BinanceGetAddress",
+	701: "MessageType_BinanceAddress",
+	702: "MessageType_BinanceGetPublicKey",
+	703: "MessageType_BinancePublicKey",
+	704: "MessageType_BinanceSignTx",
+	705: "MessageType_BinanceTxRequest",
+	706: "MessageType_BinanceTransferMsg",
+	707: "MessageType_BinanceOrderMsg",
+	708: "MessageType_BinanceCancelMsg",
+	709: "MessageType_BinanceSignedTx",
+}
+
+var MessageType_value = map[string]int32{
+	"MessageType_Initialize":                                0,
+	"MessageType_Ping":                                      1,
+	"MessageType_Success":                                   2,
+	"MessageType_Failure":                                   3,
+	"MessageType_ChangePin":                                 4,
+	"MessageType_WipeDevice":                                5,
+	"MessageType_GetEntropy":                                9,
+	"MessageType_Entropy":                                   10,
+	"MessageType_LoadDevice":                                13,
+	"MessageType_ResetDevice":                               14,
+	"MessageType_Features":                                  17,
+	"MessageType_PinMatrixRequest":                          18,
+	"MessageType_PinMatrixAck":                              19,
+	"MessageType_Cancel":                                    20,
+	"MessageType_ClearSession":                              24,
+	"MessageType_ApplySettings":                             25,
+	"MessageType_ButtonRequest":                             26,
+	"MessageType_ButtonAck":                                 27,
+	"MessageType_ApplyFlags":                                28,
+	"MessageType_BackupDevice":                              34,
+	"MessageType_EntropyRequest":                            35,
+	"MessageType_EntropyAck":                                36,
+	"MessageType_PassphraseRequest":                         41,
+	"MessageType_PassphraseAck":                             42,
+	"MessageType_PassphraseStateRequest":                    77,
+	"MessageType_PassphraseStateAck":                        78,
+	"MessageType_RecoveryDevice":                            45,
+	"MessageType_WordRequest":                               46,
+	"MessageType_WordAck":                                   47,
+	"MessageType_GetFeatures":                               55,
+	"MessageType_SetU2FCounter":                             63,
+	"MessageType_FirmwareErase":                             6,
+	"MessageType_FirmwareUpload":                            7,
+	"MessageType_FirmwareRequest":                           8,
+	"MessageType_SelfTest":                                  32,
+	"MessageType_GetPublicKey":                              11,
+	"MessageType_PublicKey":                                 12,
+	"MessageType_SignTx":                                    15,
+	"MessageType_TxRequest":                                 21,
+	"MessageType_TxAck":                                     22,
+	"MessageType_GetAddress":                                29,
+	"MessageType_Address":                                   30,
+	"MessageType_SignMessage":                               38,
+	"MessageType_VerifyMessage":                             39,
+	"MessageType_MessageSignature":                          40,
+	"MessageType_CipherKeyValue":                            23,
+	"MessageType_CipheredKeyValue":                          48,
+	"MessageType_SignIdentity":                              53,
+	"MessageType_SignedIdentity":                            54,
+	"MessageType_GetECDHSessionKey":                         61,
+	"MessageType_ECDHSessionKey":                            62,
+	"MessageType_CosiCommit":                                71,
+	"MessageType_CosiCommitment":                            72,
+	"MessageType_CosiSign":                                  73,
+	"MessageType_CosiSignature":                             74,
+	"MessageType_DebugLinkDecision":                         100,
+	"MessageType_DebugLinkGetState":                         101,
+	"MessageType_DebugLinkState":                            102,
+	"MessageType_DebugLinkStop":                             103,
+	"MessageType_DebugLinkLog":                              104,
+	"MessageType_DebugLinkMemoryRead":                       110,
+	"MessageType_DebugLinkMemory":                           111,
+	"MessageType_DebugLinkMemoryWrite":                      112,
+	"MessageType_DebugLinkFlashErase":                       113,
+	"MessageType_EthereumGetPublicKey":                      450,
+	"MessageType_EthereumPublicKey":                         451,
+	"MessageType_EthereumGetAddress":                        56,
+	"MessageType_EthereumAddress":                           57,
+	"MessageType_EthereumSignTx":                            58,
+	"MessageType_EthereumTxRequest":                         59,
+	"MessageType_EthereumTxAck":                             60,
+	"MessageType_EthereumSignMessage":                       64,
+	"MessageType_EthereumVerifyMessage":                     65,
+	"MessageType_EthereumMessageSignature":                  66,
+	"MessageType_NEMGetAddress":                             67,
+	"MessageType_NEMAddress":                                68,
+	"MessageType_NEMSignTx":                                 69,
+	"MessageType_NEMSignedTx":                               70,
+	"MessageType_NEMDecryptMessage":                         75,
+	"MessageType_NEMDecryptedMessage":                       76,
+	"MessageType_LiskGetAddress":                            114,
+	"MessageType_LiskAddress":                               115,
+	"MessageType_LiskSignTx":                                116,
+	"MessageType_LiskSignedTx":                              117,
+	"MessageType_LiskSignMessage":                           118,
+	"MessageType_LiskMessageSignature":                      119,
+	"MessageType_LiskVerifyMessage":                         120,
+	"MessageType_LiskGetPublicKey":                          121,
+	"MessageType_LiskPublicKey":                             122,
+	"MessageType_TezosGetAddress":                           150,
+	"MessageType_TezosAddress":                              151,
+	"MessageType_TezosSignTx":                               152,
+	"MessageType_TezosSignedTx":                             153,
+	"MessageType_TezosGetPublicKey":                         154,
+	"MessageType_TezosPublicKey":                            155,
+	"MessageType_StellarSignTx":                             202,
+	"MessageType_StellarTxOpRequest":                        203,
+	"MessageType_StellarGetAddress":                         207,
+	"MessageType_StellarAddress":                            208,
+	"MessageType_StellarCreateAccountOp":                    210,
+	"MessageType_StellarPaymentOp":                          211,
+	"MessageType_StellarPathPaymentOp":                      212,
+	"MessageType_StellarManageOfferOp":                      213,
+	"MessageType_StellarCreatePassiveOfferOp":               214,
+	"MessageType_StellarSetOptionsOp":                       215,
+	"MessageType_StellarChangeTrustOp":                      216,
+	"MessageType_StellarAllowTrustOp":                       217,
+	"MessageType_StellarAccountMergeOp":                     218,
+	"MessageType_StellarManageDataOp":                       220,
+	"MessageType_StellarBumpSequenceOp":                     221,
+	"MessageType_StellarSignedTx":                           230,
+	"MessageType_TronGetAddress":                            250,
+	"MessageType_TronAddress":                               251,
+	"MessageType_TronSignTx":                                252,
+	"MessageType_TronSignedTx":                              253,
+	"MessageType_CardanoSignTx":                             303,
+	"MessageType_CardanoTxRequest":                          304,
+	"MessageType_CardanoGetPublicKey":                       305,
+	"MessageType_CardanoPublicKey":                          306,
+	"MessageType_CardanoGetAddress":                         307,
+	"MessageType_CardanoAddress":                            308,
+	"MessageType_CardanoTxAck":                              309,
+	"MessageType_CardanoSignedTx":                           310,
+	"MessageType_OntologyGetAddress":                        350,
+	"MessageType_OntologyAddress":                           351,
+	"MessageType_OntologyGetPublicKey":                      352,
+	"MessageType_OntologyPublicKey":                         353,
+	"MessageType_OntologySignTransfer":                      354,
+	"MessageType_OntologySignedTransfer":                    355,
+	"MessageType_OntologySignWithdrawOng":                   356,
+	"MessageType_OntologySignedWithdrawOng":                 357,
+	"MessageType_OntologySignOntIdRegister":                 358,
+	"MessageType_OntologySignedOntIdRegister":               359,
+	"MessageType_OntologySignOntIdAddAttributes":            360,
+	"MessageType_OntologySignedOntIdAddAttributes":          361,
+	"MessageType_RippleGetAddress":                          400,
+	"MessageType_RippleAddress":                             401,
+	"MessageType_RippleSignTx":                              402,
+	"MessageType_RippleSignedTx":                            403,
+	"MessageType_MoneroTransactionInitRequest":              501,
+	"MessageType_MoneroTransactionInitAck":                  502,
+	"MessageType_MoneroTransactionSetInputRequest":          503,
+	"MessageType_MoneroTransactionSetInputAck":              504,
+	"MessageType_MoneroTransactionInputsPermutationRequest": 505,
+	"MessageType_MoneroTransactionInputsPermutationAck":     506,
+	"MessageType_MoneroTransactionInputViniRequest":         507,
+	"MessageType_MoneroTransactionInputViniAck":             508,
+	"MessageType_MoneroTransactionAllInputsSetRequest":      509,
+	"MessageType_MoneroTransactionAllInputsSetAck":          510,
+	"MessageType_MoneroTransactionSetOutputRequest":         511,
+	"MessageType_MoneroTransactionSetOutputAck":             512,
+	"MessageType_MoneroTransactionAllOutSetRequest":         513,
+	"MessageType_MoneroTransactionAllOutSetAck":             514,
+	"MessageType_MoneroTransactionSignInputRequest":         515,
+	"MessageType_MoneroTransactionSignInputAck":             516,
+	"MessageType_MoneroTransactionFinalRequest":             517,
+	"MessageType_MoneroTransactionFinalAck":                 518,
+	"MessageType_MoneroKeyImageExportInitRequest":           530,
+	"MessageType_MoneroKeyImageExportInitAck":               531,
+	"MessageType_MoneroKeyImageSyncStepRequest":             532,
+	"MessageType_MoneroKeyImageSyncStepAck":                 533,
+	"MessageType_MoneroKeyImageSyncFinalRequest":            534,
+	"MessageType_MoneroKeyImageSyncFinalAck":                535,
+	"MessageType_MoneroGetAddress":                          540,
+	"MessageType_MoneroAddress":                             541,
+	"MessageType_MoneroGetWatchKey":                         542,
+	"MessageType_MoneroWatchKey":                            543,
+	"MessageType_DebugMoneroDiagRequest":                    546,
+	"MessageType_DebugMoneroDiagAck":                        547,
+	"MessageType_MoneroGetTxKeyRequest":                     550,
+	"MessageType_MoneroGetTxKeyAck":                         551,
+	"MessageType_MoneroLiveRefreshStartRequest":             552,
+	"MessageType_MoneroLiveRefreshStartAck":                 553,
+	"MessageType_MoneroLiveRefreshStepRequest":              554,
+	"MessageType_MoneroLiveRefreshStepAck":                  555,
+	"MessageType_MoneroLiveRefreshFinalRequest":             556,
+	"MessageType_MoneroLiveRefreshFinalAck":                 557,
+	"MessageType_EosGetPublicKey":                           600,
+	"MessageType_EosPublicKey":                              601,
+	"MessageType_EosSignTx":                                 602,
+	"MessageType_EosTxActionRequest":                        603,
+	"MessageType_EosTxActionAck":                            604,
+	"MessageType_EosSignedTx":                               605,
+	"MessageType_BinanceGetAddress":                         700,
+	"MessageType_BinanceAddress":                            701,
+	"MessageType_BinanceGetPublicKey":                       702,
+	"MessageType_BinancePublicKey":                          703,
+	"MessageType_BinanceSignTx":                             704,
+	"MessageType_BinanceTxRequest":                          705,
+	"MessageType_BinanceTransferMsg":                        706,
+	"MessageType_BinanceOrderMsg":                           707,
+	"MessageType_BinanceCancelMsg":                          708,
+	"MessageType_BinanceSignedTx":                           709,
+}
+
+func (x MessageType) Enum() *MessageType {
+	p := new(MessageType)
+	*p = x
+	return p
+}
+
+func (x MessageType) String() string {
+	return proto.EnumName(MessageType_name, int32(x))
+}
+
+func (x *MessageType) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(MessageType_value, data, "MessageType")
+	if err != nil {
+		return err
+	}
+	*x = MessageType(value)
+	return nil
+}
+
+func (MessageType) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_4dc296cbfe5ffcd5, []int{0}
+}
+
+var E_WireIn = &proto.ExtensionDesc{
+	ExtendedType:  (*descriptor.EnumValueOptions)(nil),
+	ExtensionType: (*bool)(nil),
+	Field:         50002,
+	Name:          "hw.trezor.messages.wire_in",
+	Tag:           "varint,50002,opt,name=wire_in",
+	Filename:      "messages.proto",
+}
+
+var E_WireOut = &proto.ExtensionDesc{
+	ExtendedType:  (*descriptor.EnumValueOptions)(nil),
+	ExtensionType: (*bool)(nil),
+	Field:         50003,
+	Name:          "hw.trezor.messages.wire_out",
+	Tag:           "varint,50003,opt,name=wire_out",
+	Filename:      "messages.proto",
+}
+
+var E_WireDebugIn = &proto.ExtensionDesc{
+	ExtendedType:  (*descriptor.EnumValueOptions)(nil),
+	ExtensionType: (*bool)(nil),
+	Field:         50004,
+	Name:          "hw.trezor.messages.wire_debug_in",
+	Tag:           "varint,50004,opt,name=wire_debug_in",
+	Filename:      "messages.proto",
+}
+
+var E_WireDebugOut = &proto.ExtensionDesc{
+	ExtendedType:  (*descriptor.EnumValueOptions)(nil),
+	ExtensionType: (*bool)(nil),
+	Field:         50005,
+	Name:          "hw.trezor.messages.wire_debug_out",
+	Tag:           "varint,50005,opt,name=wire_debug_out",
+	Filename:      "messages.proto",
+}
+
+var E_WireTiny = &proto.ExtensionDesc{
+	ExtendedType:  (*descriptor.EnumValueOptions)(nil),
+	ExtensionType: (*bool)(nil),
+	Field:         50006,
+	Name:          "hw.trezor.messages.wire_tiny",
+	Tag:           "varint,50006,opt,name=wire_tiny",
+	Filename:      "messages.proto",
+}
+
+var E_WireBootloader = &proto.ExtensionDesc{
+	ExtendedType:  (*descriptor.EnumValueOptions)(nil),
+	ExtensionType: (*bool)(nil),
+	Field:         50007,
+	Name:          "hw.trezor.messages.wire_bootloader",
+	Tag:           "varint,50007,opt,name=wire_bootloader",
+	Filename:      "messages.proto",
+}
+
+var E_WireNoFsm = &proto.ExtensionDesc{
+	ExtendedType:  (*descriptor.EnumValueOptions)(nil),
+	ExtensionType: (*bool)(nil),
+	Field:         50008,
+	Name:          "hw.trezor.messages.wire_no_fsm",
+	Tag:           "varint,50008,opt,name=wire_no_fsm",
+	Filename:      "messages.proto",
+}
+
+func init() {
+	proto.RegisterEnum("hw.trezor.messages.MessageType", MessageType_name, MessageType_value)
+	proto.RegisterExtension(E_WireIn)
+	proto.RegisterExtension(E_WireOut)
+	proto.RegisterExtension(E_WireDebugIn)
+	proto.RegisterExtension(E_WireDebugOut)
+	proto.RegisterExtension(E_WireTiny)
+	proto.RegisterExtension(E_WireBootloader)
+	proto.RegisterExtension(E_WireNoFsm)
+}
+
+func init() { proto.RegisterFile("messages.proto", fileDescriptor_4dc296cbfe5ffcd5) }
+
+var fileDescriptor_4dc296cbfe5ffcd5 = []byte{
+	// 2430 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x9a, 0xd9, 0x73, 0x1c, 0xc5,
+	0x1d, 0xc7, 0xb3, 0xab, 0x11, 0x88, 0xf6, 0x41, 0x23, 0xb0, 0x2d, 0xaf, 0x2f, 0xf9, 0xc0, 0x96,
+	0x2f, 0xd9, 0x10, 0x0c, 0x44, 0x38, 0x60, 0x69, 0xb5, 0x12, 0x8a, 0xb5, 0x5a, 0x97, 0x76, 0xb1,
+	0x1f, 0x5d, 0xa3, 0x9d, 0xd6, 0x6e, 0x97, 0x67, 0x67, 0x86, 0x9e, 0x1e, 0x49, 0xeb, 0xa7, 0x9c,
+	0x3c, 0x13, 0x48, 0xc0, 0xb9, 0xa9, 0xa4, 0x2a, 0x21, 0x57, 0x85, 0x1c, 0x4e, 0x25, 0x55, 0x39,
+	0x08, 0x24, 0x2f, 0xc9, 0x43, 0x52, 0x9c, 0x86, 0x40, 0xee, 0x90, 0xe4, 0x0f, 0xc8, 0xc5, 0x91,
+	0xa4, 0x7a, 0xa6, 0xbb, 0xe7, 0xd8, 0xdf, 0xae, 0x36, 0x6f, 0x58, 0xf3, 0xf9, 0x7d, 0x7f, 0x47,
+	0xff, 0xfa, 0x37, 0xdd, 0xb3, 0xa0, 0xcd, 0x2d, 0xe2, 0xfb, 0x66, 0x83, 0xf8, 0xe3, 0x1e, 0x73,
+	0xb9, 0x3b, 0x3c, 0xdc, 0x5c, 0x1d, 0xe7, 0x8c, 0x5c, 0x76, 0xd9, 0xb8, 0x7a, 0x52, 0x18, 0x6d,
+	0xb8, 0x6e, 0xc3, 0x26, 0x27, 0x42, 0x62, 0x29, 0x58, 0x3e, 0x61, 0x11, 0xbf, 0xce, 0xa8, 0xc7,
+	0x5d, 0x16, 0x59, 0x1d, 0xf9, 0xfe, 0x7d, 0x68, 0x43, 0x39, 0xc2, 0x6b, 0x6d, 0x8f, 0x0c, 0x1f,
+	0x40, 0x5b, 0x13, 0xff, 0xbc, 0x38, 0xe7, 0x50, 0x4e, 0x4d, 0x9b, 0x5e, 0x26, 0xf8, 0x5d, 0x85,
+	0xa1, 0x87, 0xaf, 0x8e, 0xe4, 0x9e, 0xba, 0x3a, 0x92, 0x1b, 0x2e, 0x20, 0x9c, 0xa4, 0xce, 0x51,
+	0xa7, 0x81, 0x73, 0x05, 0x43, 0x3c, 0x1f, 0xde, 0x85, 0x6e, 0x4e, 0x3e, 0xab, 0x06, 0xf5, 0x3a,
+	0xf1, 0x7d, 0x9c, 0x2f, 0x18, 0x57, 0x80, 0xc7, 0x33, 0x26, 0xb5, 0x03, 0x46, 0xf0, 0x80, 0x7c,
+	0xbc, 0x07, 0x6d, 0x49, 0x3e, 0x2e, 0x36, 0x4d, 0xa7, 0x41, 0xce, 0x51, 0x07, 0x1b, 0x52, 0x7e,
+	0x34, 0x1d, 0xe0, 0x05, 0xea, 0x91, 0x69, 0xb2, 0x42, 0xeb, 0x04, 0x0f, 0xc2, 0xc4, 0x2c, 0xe1,
+	0x25, 0x87, 0x33, 0xd7, 0x6b, 0xe3, 0x1b, 0xe0, 0x10, 0xd5, 0x63, 0x24, 0x63, 0xc8, 0x08, 0xcc,
+	0xbb, 0xa6, 0x25, 0x5d, 0x6c, 0x92, 0x02, 0x7b, 0xd1, 0xb6, 0x24, 0xb1, 0x48, 0x7c, 0xc2, 0x25,
+	0xb2, 0x59, 0x22, 0xbb, 0xd1, 0x2d, 0xa9, 0x3c, 0x89, 0xc9, 0x03, 0x46, 0x7c, 0x7c, 0x93, 0x74,
+	0x72, 0x10, 0xed, 0xcc, 0x94, 0xb0, 0x6c, 0x72, 0x46, 0xd7, 0x16, 0xc9, 0x83, 0x01, 0xf1, 0x39,
+	0x1e, 0x96, 0xdc, 0x11, 0x34, 0x02, 0x72, 0x93, 0xf5, 0x4b, 0xf8, 0xe6, 0xc2, 0x46, 0xb5, 0x24,
+	0x4f, 0x47, 0x81, 0x0f, 0xa7, 0x8a, 0x67, 0x3a, 0x75, 0x62, 0xe3, 0x5b, 0x12, 0x0b, 0xb7, 0x2f,
+	0xad, 0x56, 0xb4, 0x89, 0xc9, 0xaa, 0xc4, 0xf7, 0xa9, 0xeb, 0xe0, 0x11, 0x19, 0xf9, 0x7e, 0xb4,
+	0x3d, 0xc9, 0x4c, 0x7a, 0x9e, 0xdd, 0xae, 0x12, 0xce, 0xa9, 0xd3, 0xf0, 0xf1, 0x76, 0x18, 0x9a,
+	0x0a, 0x38, 0x77, 0x1d, 0x15, 0x7b, 0x41, 0xc6, 0x7e, 0x28, 0xbd, 0x98, 0x11, 0x24, 0x02, 0xdf,
+	0xd1, 0x11, 0xf8, 0xd6, 0x0e, 0x97, 0x33, 0xb6, 0xd9, 0xf0, 0xf1, 0x4e, 0xe9, 0x2f, 0x13, 0xf8,
+	0x94, 0x59, 0xbf, 0x14, 0x78, 0xb2, 0xe4, 0xfb, 0x24, 0x73, 0x00, 0x15, 0x80, 0x65, 0x55, 0x41,
+	0xed, 0x87, 0x57, 0x57, 0x52, 0x22, 0xaa, 0x03, 0x52, 0xe7, 0x10, 0xda, 0x95, 0x2a, 0xb9, 0xe9,
+	0xfb, 0x5e, 0x93, 0x99, 0x3e, 0x51, 0x52, 0x87, 0xa5, 0xd4, 0xd1, 0x74, 0x11, 0x62, 0x50, 0xa8,
+	0x1d, 0xc9, 0xe4, 0x78, 0x0c, 0xed, 0x83, 0xe1, 0x2a, 0x37, 0xb9, 0x96, 0x2e, 0x4b, 0xe9, 0x93,
+	0x68, 0x77, 0x0f, 0x5a, 0xe8, 0x2f, 0x64, 0xf4, 0x33, 0xd9, 0x2f, 0x92, 0xba, 0xbb, 0x42, 0x58,
+	0x5b, 0xd6, 0xe8, 0x38, 0xdc, 0xb9, 0x17, 0x5c, 0x66, 0x29, 0xd7, 0xe3, 0xf0, 0x0e, 0x15, 0x88,
+	0xf0, 0x77, 0x02, 0x56, 0x98, 0x25, 0x5c, 0xf7, 0xf6, 0x5d, 0x70, 0x73, 0x54, 0x09, 0x7f, 0xe0,
+	0xf6, 0x99, 0xa2, 0x1b, 0x38, 0x9c, 0x30, 0x7c, 0x9f, 0xae, 0x72, 0x0a, 0x9a, 0xa1, 0xac, 0xb5,
+	0x6a, 0x32, 0x52, 0x12, 0x49, 0xe2, 0xeb, 0xa2, 0x9e, 0xfd, 0x9e, 0x00, 0xc7, 0xd2, 0x89, 0x29,
+	0xf0, 0x01, 0xcf, 0x76, 0x4d, 0x0b, 0x5f, 0x9f, 0x20, 0x0f, 0xa3, 0x1d, 0x10, 0xa9, 0x12, 0x1c,
+	0x2a, 0x0c, 0x5d, 0x51, 0xe8, 0xbe, 0xf4, 0xf6, 0xac, 0x12, 0x7b, 0xb9, 0x26, 0x98, 0xd1, 0x84,
+	0x5c, 0xa6, 0xe7, 0x66, 0x09, 0x3f, 0x17, 0x2c, 0xd9, 0xb4, 0x7e, 0x96, 0xb4, 0xf1, 0x06, 0x99,
+	0x45, 0x66, 0x5e, 0xc5, 0xc0, 0x46, 0x59, 0xcd, 0x9d, 0xe9, 0x3d, 0x59, 0xa5, 0x0d, 0xa7, 0xb6,
+	0x86, 0x6f, 0x84, 0xcd, 0x6b, 0x7a, 0xfb, 0x6f, 0x91, 0xe6, 0x3b, 0xd0, 0x4d, 0x69, 0x40, 0x2c,
+	0xc5, 0xd6, 0xae, 0x93, 0x6e, 0xd2, 0xb2, 0x98, 0x98, 0xb6, 0xbb, 0xe0, 0x49, 0xa7, 0x1e, 0xef,
+	0x96, 0xea, 0x99, 0xb5, 0x14, 0xc1, 0xc9, 0x7f, 0xe3, 0x83, 0xf0, 0x5a, 0x9e, 0x27, 0x8c, 0x2e,
+	0xb7, 0x15, 0x74, 0x48, 0x42, 0x99, 0x61, 0x26, 0xff, 0x5b, 0xc8, 0x85, 0x9d, 0x81, 0xc7, 0xa4,
+	0xbf, 0x4c, 0x8f, 0x16, 0xa9, 0xd7, 0x24, 0xec, 0x2c, 0x69, 0x9f, 0x37, 0xed, 0x80, 0xe0, 0x6d,
+	0xb0, 0x5a, 0x44, 0x11, 0x4b, 0x73, 0x27, 0xa5, 0x5a, 0x66, 0x7d, 0x84, 0xbb, 0x39, 0x8b, 0x38,
+	0x9c, 0xf2, 0x36, 0x3e, 0x05, 0xcf, 0x04, 0xc1, 0x10, 0x4b, 0x53, 0x77, 0xea, 0x41, 0xb5, 0x2b,
+	0xfb, 0xca, 0x28, 0x4e, 0xdf, 0x2f, 0x07, 0xa3, 0x58, 0xcd, 0xf7, 0x76, 0x19, 0x31, 0x69, 0xea,
+	0x5e, 0x78, 0xc4, 0x14, 0x5d, 0x9f, 0x16, 0xdd, 0x56, 0x8b, 0x72, 0x3c, 0x0b, 0xeb, 0xc4, 0x44,
+	0x8b, 0x38, 0x1c, 0xdf, 0x2f, 0x75, 0x32, 0xef, 0x10, 0x41, 0x89, 0x04, 0xf0, 0x1c, 0xbc, 0x36,
+	0xea, 0x79, 0x54, 0xf3, 0xf7, 0x49, 0x91, 0x13, 0xe9, 0xdc, 0xa6, 0xc9, 0x52, 0xd0, 0x98, 0xa7,
+	0xce, 0xa5, 0x69, 0x52, 0xa7, 0xe1, 0xdc, 0xb7, 0x0a, 0x1b, 0x9f, 0x48, 0x0e, 0x92, 0xa3, 0x5d,
+	0x0c, 0x66, 0x09, 0x0f, 0x87, 0x0f, 0x26, 0x85, 0x21, 0x65, 0x90, 0x4d, 0x44, 0xc3, 0x11, 0xb9,
+	0x5c, 0x30, 0x9e, 0x04, 0x02, 0x4d, 0x50, 0xae, 0x87, 0x1b, 0x05, 0xe3, 0x09, 0x60, 0x39, 0x35,
+	0x34, 0xef, 0x36, 0x70, 0x53, 0x0a, 0x1d, 0x46, 0x7b, 0x40, 0xa6, 0x4c, 0x5a, 0x2e, 0x6b, 0x2f,
+	0x12, 0xd3, 0xc2, 0x8e, 0x94, 0xbb, 0x35, 0x3d, 0x0c, 0x32, 0x28, 0x76, 0xa5, 0xe2, 0x11, 0x34,
+	0xda, 0x03, 0xbb, 0xc0, 0x28, 0x27, 0xd8, 0x93, 0x92, 0xdd, 0xbc, 0xcf, 0xd8, 0xa6, 0xdf, 0x8c,
+	0x06, 0xd7, 0x83, 0x12, 0x3d, 0x9a, 0x96, 0x2d, 0x71, 0xd1, 0xc2, 0x41, 0x2b, 0x35, 0x43, 0x9e,
+	0x19, 0x90, 0xeb, 0x38, 0x96, 0xae, 0xb8, 0x82, 0x63, 0xf2, 0x59, 0x75, 0x3c, 0x1a, 0x4b, 0xbf,
+	0x16, 0x12, 0xb2, 0x6a, 0x6b, 0xdf, 0x2d, 0x35, 0x33, 0xe9, 0x2b, 0x52, 0x61, 0xef, 0x81, 0x77,
+	0xa4, 0xc2, 0xe4, 0x98, 0x9a, 0x80, 0xdf, 0x88, 0x8a, 0x8a, 0xc7, 0xd5, 0x3d, 0x52, 0x2e, 0xb3,
+	0xd0, 0x31, 0x28, 0xc6, 0xd6, 0x69, 0xa9, 0x96, 0x29, 0x63, 0xd2, 0xa7, 0x1a, 0x2c, 0x67, 0x24,
+	0x7a, 0x14, 0xed, 0x85, 0xd0, 0xf4, 0x14, 0x9a, 0x94, 0xf0, 0x38, 0x3a, 0x00, 0xc1, 0x1d, 0xd3,
+	0x68, 0x0a, 0x0e, 0x76, 0xa1, 0x54, 0x4e, 0xd4, 0xb1, 0x08, 0xcf, 0xd8, 0x85, 0x52, 0x59, 0x11,
+	0xd3, 0xf0, 0x91, 0x75, 0xa1, 0x54, 0x96, 0xd5, 0x2b, 0xc1, 0x6f, 0x4c, 0x09, 0x10, 0xab, 0xb6,
+	0x86, 0x67, 0xe0, 0x01, 0xb4, 0x50, 0x2a, 0x4f, 0x93, 0x3a, 0x6b, 0x7b, 0x5c, 0xe5, 0x78, 0x16,
+	0xae, 0x5d, 0x0c, 0x12, 0x4b, 0xa1, 0xf3, 0xf0, 0xd2, 0xce, 0x53, 0xff, 0x52, 0x22, 0x3f, 0x06,
+	0x07, 0x27, 0x28, 0x85, 0xf8, 0x5d, 0xce, 0xc3, 0xd4, 0xbf, 0x24, 0x33, 0xe4, 0xf0, 0xe9, 0x4c,
+	0x11, 0x61, 0x8a, 0x81, 0x54, 0xc9, 0x34, 0xa4, 0x62, 0x54, 0xd4, 0x2b, 0x52, 0x2a, 0xb3, 0x1f,
+	0x05, 0xd6, 0xb1, 0x80, 0xab, 0x70, 0xd5, 0x04, 0x9b, 0xee, 0x8c, 0x35, 0xf8, 0x8d, 0x22, 0x4b,
+	0x11, 0xef, 0xaf, 0x36, 0x3c, 0x50, 0x05, 0x17, 0x43, 0x97, 0xf5, 0xc9, 0x3d, 0x95, 0x48, 0x8d,
+	0x5c, 0x76, 0xfd, 0x44, 0x61, 0x1f, 0xcb, 0x69, 0xb1, 0x91, 0x0e, 0x4e, 0x41, 0x8f, 0xe7, 0xf4,
+	0x3b, 0x6c, 0x5b, 0x07, 0x24, 0x8b, 0x7b, 0x25, 0xa7, 0x5f, 0x16, 0xdb, 0x41, 0x26, 0x2c, 0xef,
+	0x27, 0x72, 0x7a, 0x34, 0xec, 0x82, 0xc2, 0x8a, 0xe3, 0xff, 0x64, 0x4e, 0x8f, 0x86, 0x42, 0x07,
+	0x19, 0x63, 0x9f, 0xca, 0xe9, 0xfe, 0x49, 0x9f, 0xe2, 0x38, 0xb1, 0x6d, 0x93, 0xc9, 0xe0, 0x7e,
+	0x9e, 0xd3, 0x0d, 0xb9, 0x1b, 0xa0, 0x6a, 0x6b, 0x15, 0x4f, 0xcd, 0x86, 0x5f, 0x74, 0x89, 0x50,
+	0xa2, 0x89, 0xd2, 0xfd, 0xb2, 0x4b, 0x84, 0x92, 0x54, 0xd8, 0xaf, 0x94, 0xe0, 0xf1, 0xf4, 0x91,
+	0x5a, 0x62, 0x45, 0x46, 0xc2, 0x23, 0x72, 0x5d, 0x1c, 0x38, 0x2b, 0x1e, 0x7e, 0x2e, 0xa7, 0xa7,
+	0xd8, 0x4e, 0x00, 0x3f, 0x67, 0xb6, 0xc5, 0x4b, 0xb7, 0xe2, 0xe1, 0xe7, 0x73, 0x7a, 0xea, 0x8c,
+	0x82, 0x20, 0x6f, 0xc6, 0xf0, 0x0b, 0xbd, 0xe1, 0xb2, 0xe9, 0x98, 0x0d, 0x52, 0x59, 0x5e, 0x26,
+	0xac, 0xe2, 0xe1, 0x17, 0x15, 0x7c, 0x3b, 0x3a, 0xd4, 0x35, 0x62, 0x71, 0xc6, 0xa7, 0x2b, 0xda,
+	0xe6, 0xa5, 0x9c, 0xde, 0x11, 0x7b, 0xa0, 0x75, 0x20, 0xbc, 0xe2, 0x71, 0xea, 0x3a, 0x7e, 0xc5,
+	0xc3, 0x2f, 0xf7, 0x0e, 0x26, 0xba, 0x45, 0xd7, 0x58, 0xe0, 0x8b, 0xc8, 0xaf, 0xf5, 0x16, 0x9e,
+	0xb4, 0x6d, 0x77, 0x55, 0xb1, 0xaf, 0x28, 0xf6, 0x58, 0x7a, 0x10, 0x2b, 0x36, 0x2a, 0x72, 0x99,
+	0xb0, 0x06, 0xa9, 0x78, 0xf8, 0xd5, 0xde, 0xca, 0x51, 0x4d, 0xa6, 0x4d, 0x6e, 0x56, 0x3c, 0xfc,
+	0x5a, 0x6f, 0xe5, 0xa9, 0xa0, 0xe5, 0x55, 0x45, 0x03, 0x39, 0x75, 0xa1, 0xfc, 0x7a, 0x4e, 0xef,
+	0xe4, 0x1d, 0x5d, 0x9a, 0x32, 0xdc, 0x0d, 0x6f, 0xe4, 0xf4, 0xb4, 0x49, 0xf7, 0x38, 0x73, 0x9d,
+	0x44, 0xa3, 0xbd, 0x99, 0xd3, 0x83, 0x6b, 0x5b, 0x16, 0x53, 0xcc, 0x5b, 0x39, 0x7d, 0x48, 0xde,
+	0x9a, 0x65, 0xe4, 0x26, 0x78, 0xbb, 0xdb, 0x56, 0x97, 0x48, 0x18, 0xd2, 0x3b, 0x5d, 0xf6, 0x53,
+	0xd1, 0x64, 0x96, 0xe9, 0xb8, 0x52, 0xea, 0x1b, 0x79, 0xb8, 0x49, 0x25, 0x15, 0xbf, 0x69, 0x9f,
+	0xca, 0xeb, 0x0f, 0x03, 0x7b, 0x00, 0x30, 0xb5, 0xe3, 0xbf, 0xd9, 0x5b, 0x34, 0x06, 0xbf, 0x95,
+	0x87, 0xb7, 0x68, 0x2c, 0xaa, 0xaa, 0xf2, 0xed, 0x3c, 0xbc, 0x45, 0x25, 0xa9, 0xb0, 0xef, 0xe4,
+	0xf5, 0x3b, 0x76, 0x04, 0x4c, 0x47, 0x9c, 0x07, 0xae, 0xe6, 0xe1, 0x45, 0x4d, 0x54, 0x26, 0xac,
+	0xe0, 0x77, 0x95, 0x58, 0x66, 0xd6, 0x54, 0x1c, 0xee, 0xda, 0x6e, 0xa3, 0x9d, 0x08, 0xef, 0x37,
+	0x5d, 0x24, 0x15, 0xaa, 0xb8, 0xdf, 0xe6, 0xf5, 0x15, 0x7e, 0xb4, 0x8b, 0x64, 0x5c, 0x9d, 0xdf,
+	0xe5, 0xe1, 0x73, 0x9a, 0x82, 0x63, 0xf2, 0xf7, 0xeb, 0xc8, 0x86, 0x8b, 0xcd, 0x4c, 0xc7, 0x5f,
+	0x26, 0x0c, 0xff, 0x41, 0xc9, 0x66, 0xc6, 0x58, 0x12, 0x26, 0x96, 0xc6, 0xff, 0xa8, 0xb4, 0xc7,
+	0xd1, 0xfe, 0x6e, 0xf8, 0x05, 0xca, 0x9b, 0x16, 0x33, 0x57, 0x2b, 0x4e, 0x03, 0xff, 0x49, 0xc9,
+	0x9f, 0x44, 0xb7, 0x76, 0x97, 0x4f, 0x5a, 0xfc, 0x39, 0xaf, 0x3f, 0x3e, 0x74, 0xb5, 0xa8, 0x38,
+	0x7c, 0xce, 0x5a, 0x24, 0x0d, 0xea, 0x8b, 0xbb, 0xfc, 0x1b, 0x79, 0x78, 0xae, 0xa5, 0x7d, 0xa4,
+	0x6d, 0xfe, 0xa2, 0xbc, 0x9c, 0x42, 0x47, 0x7a, 0x7a, 0x99, 0xb4, 0xac, 0x49, 0xce, 0x19, 0x5d,
+	0x0a, 0x38, 0xf1, 0xf1, 0x5f, 0x95, 0xab, 0xbb, 0xd0, 0xb1, 0x75, 0x5c, 0xa5, 0x0d, 0xff, 0x96,
+	0xd7, 0xa7, 0x85, 0xd4, 0x26, 0x58, 0xa4, 0x9e, 0x67, 0x93, 0x44, 0xef, 0x3c, 0x3c, 0x00, 0xbf,
+	0x6f, 0x23, 0x50, 0x51, 0x1f, 0x1d, 0x80, 0x3b, 0x3b, 0xa2, 0xe4, 0x6e, 0x7e, 0x64, 0x00, 0xde,
+	0x25, 0x31, 0x14, 0x36, 0xf6, 0xa3, 0x0a, 0x7b, 0x37, 0x1a, 0x4b, 0xdd, 0x9f, 0x5d, 0x87, 0x30,
+	0x37, 0x5c, 0x79, 0xb3, 0x2e, 0x66, 0xfc, 0x9c, 0x43, 0xb9, 0x1a, 0x00, 0x7f, 0x1f, 0xd0, 0x17,
+	0xbb, 0x03, 0xeb, 0x1a, 0x89, 0x6d, 0xf6, 0x0f, 0x65, 0x90, 0xa9, 0x5c, 0x87, 0x41, 0x95, 0xf0,
+	0x39, 0xc7, 0x0b, 0xb4, 0xa7, 0x7f, 0x2a, 0xc3, 0xf5, 0xc2, 0x53, 0x86, 0xc2, 0xdb, 0xbf, 0x94,
+	0xd1, 0x19, 0x74, 0x6a, 0x9d, 0xf0, 0xbc, 0x80, 0xfb, 0xe7, 0x08, 0x6b, 0x05, 0xdc, 0x14, 0x7f,
+	0x50, 0x6e, 0xff, 0xad, 0x14, 0x4e, 0xa3, 0xdb, 0xfe, 0x3f, 0x05, 0xe1, 0xff, 0x4d, 0x65, 0x7d,
+	0x37, 0x3a, 0xbe, 0xbe, 0xf5, 0x79, 0xea, 0x50, 0xe5, 0xf7, 0x2d, 0x65, 0x79, 0x07, 0x3a, 0xdc,
+	0x9f, 0xa5, 0xf0, 0xf7, 0xb6, 0xb2, 0xba, 0x07, 0x9d, 0xec, 0x69, 0x35, 0x69, 0xdb, 0x51, 0xc0,
+	0x55, 0xa2, 0x2b, 0xfc, 0x4e, 0xbf, 0x4b, 0x93, 0x34, 0x16, 0x5e, 0xff, 0xd3, 0x6f, 0x96, 0xe2,
+	0x98, 0x10, 0xf0, 0xc4, 0xa2, 0xfe, 0xb7, 0xdf, 0x2c, 0xb5, 0xa5, 0xf0, 0xf7, 0x7e, 0xa3, 0x4f,
+	0x7f, 0x93, 0xb6, 0x5d, 0x09, 0x78, 0x22, 0xc5, 0x0f, 0x18, 0x7d, 0xfa, 0xd3, 0x96, 0xc2, 0xdf,
+	0x07, 0xfb, 0xf5, 0x17, 0x7e, 0xf4, 0x49, 0x36, 0xed, 0x87, 0xfa, 0xf5, 0xa7, 0x2d, 0x85, 0xbf,
+	0x0f, 0xf7, 0x6b, 0x35, 0x43, 0x1d, 0xd3, 0x56, 0xbe, 0x3e, 0x62, 0xc0, 0x03, 0x13, 0xb6, 0x12,
+	0x7e, 0x1e, 0x52, 0x16, 0x77, 0xa2, 0xa3, 0x9d, 0x16, 0x67, 0x49, 0x7b, 0xae, 0x65, 0x36, 0x48,
+	0x69, 0xcd, 0x73, 0x19, 0x4f, 0x6e, 0xfa, 0x47, 0x94, 0x5d, 0x66, 0xd0, 0x76, 0xb3, 0x13, 0xbe,
+	0x1e, 0xed, 0x99, 0x93, 0xb2, 0xa9, 0xb6, 0x9d, 0x7a, 0x95, 0x13, 0x7d, 0x5a, 0xff, 0x58, 0xcf,
+	0x9c, 0xb2, 0x56, 0xc2, 0xcf, 0xc7, 0x0d, 0x78, 0xa0, 0x77, 0x5a, 0xa4, 0x8a, 0xf7, 0x98, 0x32,
+	0xbb, 0x0d, 0x1d, 0xec, 0xc3, 0x4c, 0x78, 0x7a, 0xdc, 0x80, 0x47, 0x79, 0x64, 0x92, 0x18, 0xe5,
+	0x9f, 0x36, 0xe0, 0x51, 0x1e, 0x81, 0x8a, 0xfa, 0x8c, 0x01, 0x9f, 0x7a, 0xb4, 0xdc, 0x05, 0x93,
+	0xd7, 0x9b, 0xe2, 0xbd, 0xfe, 0x59, 0x03, 0x9e, 0xe7, 0x11, 0xa9, 0xb1, 0xcf, 0x19, 0xf0, 0xc5,
+	0x24, 0xfc, 0x50, 0x14, 0xb1, 0xd3, 0xd4, 0x6c, 0xa8, 0x0a, 0x7c, 0xde, 0x80, 0xef, 0x50, 0x19,
+	0x5c, 0x64, 0xfe, 0x05, 0xa5, 0x9c, 0x39, 0x2d, 0xeb, 0x50, 0x6b, 0x6b, 0x67, 0x89, 0xfe, 0xa9,
+	0xe3, 0x8b, 0x06, 0x7c, 0x60, 0x49, 0xd3, 0x42, 0xf7, 0x4b, 0x3d, 0x7b, 0x64, 0x9e, 0xae, 0x90,
+	0x45, 0xb2, 0xcc, 0x88, 0xdf, 0xac, 0x72, 0x93, 0xe9, 0x6e, 0x7c, 0xd2, 0x80, 0x8f, 0x16, 0xb0,
+	0x95, 0xf0, 0xf3, 0x65, 0xa3, 0xd7, 0xab, 0x24, 0x65, 0x11, 0xb7, 0xe2, 0x57, 0x94, 0x1b, 0xf0,
+	0x4d, 0x97, 0x31, 0x12, 0x5e, 0xbe, 0xda, 0x6f, 0x36, 0xa9, 0x46, 0xfc, 0x5a, 0xbf, 0xd9, 0xe8,
+	0x3e, 0xfc, 0xba, 0x01, 0x7f, 0x0a, 0x28, 0x65, 0x6e, 0xdc, 0xd7, 0x0c, 0xf8, 0x7e, 0x50, 0x4a,
+	0xde, 0xb7, 0x5f, 0x31, 0xf4, 0x67, 0x96, 0x2d, 0x19, 0x48, 0x9e, 0x26, 0x5e, 0xed, 0xd2, 0x27,
+	0x25, 0xd7, 0x17, 0x07, 0xe9, 0xe4, 0xbb, 0xf3, 0xd7, 0x06, 0x7c, 0xff, 0x49, 0xa0, 0x22, 0x81,
+	0xd7, 0x0c, 0xf8, 0xfe, 0x53, 0x4a, 0x7c, 0x58, 0x78, 0xbd, 0xcb, 0xee, 0x98, 0xa2, 0x8e, 0xe9,
+	0xd4, 0x93, 0x07, 0xa7, 0x1f, 0x0c, 0xc2, 0xbb, 0x43, 0x92, 0x0a, 0xfb, 0xe1, 0x20, 0x7c, 0x73,
+	0x89, 0x05, 0xe3, 0xa2, 0xfc, 0x68, 0x10, 0xbe, 0xb9, 0x48, 0x36, 0x06, 0x7f, 0x3c, 0x08, 0xdf,
+	0xae, 0x24, 0x28, 0x2b, 0xf8, 0x74, 0x6f, 0xb9, 0xf8, 0x76, 0xf5, 0x93, 0x41, 0xf8, 0xaa, 0xa1,
+	0x40, 0x79, 0x18, 0x2f, 0xfb, 0x0d, 0xfc, 0xcc, 0x20, 0x7c, 0xd5, 0x90, 0x68, 0x85, 0x59, 0x11,
+	0xf7, 0x6c, 0x6f, 0xdf, 0xd1, 0x8f, 0xb4, 0x02, 0xfc, 0x69, 0x6f, 0x41, 0xbd, 0x30, 0x3f, 0x93,
+	0x31, 0x4e, 0x9c, 0x46, 0xd7, 0xaf, 0x52, 0x46, 0x2e, 0x52, 0x67, 0x78, 0xef, 0x78, 0xf4, 0x4b,
+	0xff, 0xb8, 0xfa, 0xa5, 0x7f, 0xbc, 0xe4, 0x04, 0xad, 0xf0, 0xe7, 0x12, 0xf9, 0x95, 0x60, 0xe4,
+	0xb9, 0x87, 0x06, 0x46, 0x73, 0x63, 0x43, 0x8b, 0xd7, 0x09, 0x9b, 0x39, 0x67, 0xe2, 0x5e, 0x34,
+	0x14, 0x5a, 0xbb, 0x01, 0xef, 0xc7, 0xfc, 0x79, 0x69, 0x1e, 0xba, 0xac, 0x04, 0x7c, 0x62, 0x16,
+	0x6d, 0x0a, 0xed, 0x2d, 0x31, 0xad, 0xfa, 0x8c, 0xe1, 0x05, 0x29, 0xb2, 0x41, 0x58, 0x86, 0x63,
+	0x6e, 0xce, 0x99, 0x98, 0x43, 0x9b, 0x13, 0x42, 0x7d, 0x86, 0xf3, 0xa2, 0x54, 0xda, 0xa8, 0x95,
+	0x44, 0x4c, 0x67, 0xd0, 0x0d, 0xa1, 0x14, 0xa7, 0x4e, 0xbb, 0x1f, 0x95, 0x97, 0xa4, 0x4a, 0x58,
+	0x89, 0x1a, 0x75, 0xda, 0x13, 0xf3, 0xe8, 0xc6, 0x50, 0x61, 0xc9, 0x75, 0xb9, 0xed, 0x9a, 0x16,
+	0x61, 0xfd, 0xe8, 0xbc, 0x2c, 0x75, 0xc2, 0x44, 0xa6, 0xb4, 0xe9, 0x44, 0x11, 0x85, 0x99, 0x5e,
+	0x74, 0xdc, 0x8b, 0xcb, 0x7e, 0xab, 0x1f, 0xa5, 0x6b, 0x52, 0x29, 0xcc, 0x63, 0xc1, 0x9d, 0xf1,
+	0x5b, 0x53, 0x77, 0xa0, 0xfd, 0x75, 0xb7, 0x35, 0xee, 0x9b, 0xdc, 0xf5, 0x9b, 0xd4, 0x36, 0x97,
+	0x7c, 0xf5, 0xff, 0x79, 0xd8, 0x74, 0x49, 0x4b, 0x4d, 0x6d, 0xaa, 0x85, 0x7f, 0x94, 0x9d, 0xf3,
+	0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xa3, 0x69, 0x67, 0x5d, 0x1f, 0x22, 0x00, 0x00,
+}
diff --git a/accounts/usbwallet/trezor/messages.proto b/accounts/usbwallet/trezor/messages.proto
new file mode 100644
index 000000000..3e0482e34
--- /dev/null
+++ b/accounts/usbwallet/trezor/messages.proto
@@ -0,0 +1,264 @@
+// This file originates from the SatoshiLabs Trezor `common` repository at:
+//   https://github.com/trezor/trezor-common/blob/master/protob/messages.proto
+// dated 28.05.2019, commit 893fd219d4a01bcffa0cd9cfa631856371ec5aa9.
+
+syntax = "proto2";
+package hw.trezor.messages;
+
+/**
+ * Messages for TREZOR communication
+ */
+
+// Sugar for easier handling in Java
+option java_package = "com.satoshilabs.trezor.lib.protobuf";
+option java_outer_classname = "TrezorMessage";
+
+import "google/protobuf/descriptor.proto";
+
+/**
+ * Options for specifying message direction and type of wire (normal/debug)
+ */
+extend google.protobuf.EnumValueOptions {
+    optional bool wire_in = 50002;              // message can be transmitted via wire from PC to TREZOR
+    optional bool wire_out = 50003;             // message can be transmitted via wire from TREZOR to PC
+    optional bool wire_debug_in = 50004;        // message can be transmitted via debug wire from PC to TREZOR
+    optional bool wire_debug_out = 50005;       // message can be transmitted via debug wire from TREZOR to PC
+    optional bool wire_tiny = 50006;            // message is handled by TREZOR when the USB stack is in tiny mode
+    optional bool wire_bootloader = 50007;      // message is only handled by TREZOR Bootloader
+    optional bool wire_no_fsm = 50008;          // message is not handled by TREZOR unless the USB stack is in tiny mode
+}
+
+/**
+ * Mapping between TREZOR wire identifier (uint) and a protobuf message
+ */
+enum MessageType {
+
+    // Management
+    MessageType_Initialize = 0 [(wire_in) = true, (wire_tiny) = true];
+    MessageType_Ping = 1 [(wire_in) = true];
+    MessageType_Success = 2 [(wire_out) = true];
+    MessageType_Failure = 3 [(wire_out) = true];
+    MessageType_ChangePin = 4 [(wire_in) = true];
+    MessageType_WipeDevice = 5 [(wire_in) = true];
+    MessageType_GetEntropy = 9 [(wire_in) = true];
+    MessageType_Entropy = 10 [(wire_out) = true];
+    MessageType_LoadDevice = 13 [(wire_in) = true];
+    MessageType_ResetDevice = 14 [(wire_in) = true];
+    MessageType_Features = 17 [(wire_out) = true];
+    MessageType_PinMatrixRequest = 18 [(wire_out) = true];
+    MessageType_PinMatrixAck = 19 [(wire_in) = true, (wire_tiny) = true, (wire_no_fsm) = true];
+    MessageType_Cancel = 20 [(wire_in) = true, (wire_tiny) = true];
+    MessageType_ClearSession = 24 [(wire_in) = true];
+    MessageType_ApplySettings = 25 [(wire_in) = true];
+    MessageType_ButtonRequest = 26 [(wire_out) = true];
+    MessageType_ButtonAck = 27 [(wire_in) = true, (wire_tiny) = true, (wire_no_fsm) = true];
+    MessageType_ApplyFlags = 28 [(wire_in) = true];
+    MessageType_BackupDevice = 34 [(wire_in) = true];
+    MessageType_EntropyRequest = 35 [(wire_out) = true];
+    MessageType_EntropyAck = 36 [(wire_in) = true];
+    MessageType_PassphraseRequest = 41 [(wire_out) = true];
+    MessageType_PassphraseAck = 42 [(wire_in) = true, (wire_tiny) = true, (wire_no_fsm) = true];
+    MessageType_PassphraseStateRequest = 77 [(wire_out) = true];
+    MessageType_PassphraseStateAck = 78 [(wire_in) = true, (wire_tiny) = true, (wire_no_fsm) = true];
+    MessageType_RecoveryDevice = 45 [(wire_in) = true];
+    MessageType_WordRequest = 46 [(wire_out) = true];
+    MessageType_WordAck = 47 [(wire_in) = true];
+    MessageType_GetFeatures = 55 [(wire_in) = true];
+    MessageType_SetU2FCounter = 63 [(wire_in) = true];
+
+    // Bootloader
+    MessageType_FirmwareErase = 6 [(wire_in) = true, (wire_bootloader) = true];
+    MessageType_FirmwareUpload = 7 [(wire_in) = true, (wire_bootloader) = true];
+    MessageType_FirmwareRequest = 8 [(wire_out) = true, (wire_bootloader) = true];
+    MessageType_SelfTest = 32 [(wire_in) = true, (wire_bootloader) = true];
+
+    // Bitcoin
+    MessageType_GetPublicKey = 11 [(wire_in) = true];
+    MessageType_PublicKey = 12 [(wire_out) = true];
+    MessageType_SignTx = 15 [(wire_in) = true];
+    MessageType_TxRequest = 21 [(wire_out) = true];
+    MessageType_TxAck = 22 [(wire_in) = true];
+    MessageType_GetAddress = 29 [(wire_in) = true];
+    MessageType_Address = 30 [(wire_out) = true];
+    MessageType_SignMessage = 38 [(wire_in) = true];
+    MessageType_VerifyMessage = 39 [(wire_in) = true];
+    MessageType_MessageSignature = 40 [(wire_out) = true];
+
+    // Crypto
+    MessageType_CipherKeyValue = 23 [(wire_in) = true];
+    MessageType_CipheredKeyValue = 48 [(wire_out) = true];
+    MessageType_SignIdentity = 53 [(wire_in) = true];
+    MessageType_SignedIdentity = 54 [(wire_out) = true];
+    MessageType_GetECDHSessionKey = 61 [(wire_in) = true];
+    MessageType_ECDHSessionKey = 62 [(wire_out) = true];
+    MessageType_CosiCommit = 71 [(wire_in) = true];
+    MessageType_CosiCommitment = 72 [(wire_out) = true];
+    MessageType_CosiSign = 73 [(wire_in) = true];
+    MessageType_CosiSignature = 74 [(wire_out) = true];
+
+    // Debug
+    MessageType_DebugLinkDecision = 100 [(wire_debug_in) = true, (wire_tiny) = true, (wire_no_fsm) = true];
+    MessageType_DebugLinkGetState = 101 [(wire_debug_in) = true, (wire_tiny) = true];
+    MessageType_DebugLinkState = 102 [(wire_debug_out) = true];
+    MessageType_DebugLinkStop = 103 [(wire_debug_in) = true];
+    MessageType_DebugLinkLog = 104 [(wire_debug_out) = true];
+    MessageType_DebugLinkMemoryRead = 110 [(wire_debug_in) = true];
+    MessageType_DebugLinkMemory = 111 [(wire_debug_out) = true];
+    MessageType_DebugLinkMemoryWrite = 112 [(wire_debug_in) = true];
+    MessageType_DebugLinkFlashErase = 113 [(wire_debug_in) = true];
+
+    // Ethereum
+    MessageType_EthereumGetPublicKey = 450 [(wire_in) = true];
+    MessageType_EthereumPublicKey = 451 [(wire_out) = true];
+    MessageType_EthereumGetAddress = 56 [(wire_in) = true];
+    MessageType_EthereumAddress = 57 [(wire_out) = true];
+    MessageType_EthereumSignTx = 58 [(wire_in) = true];
+    MessageType_EthereumTxRequest = 59 [(wire_out) = true];
+    MessageType_EthereumTxAck = 60 [(wire_in) = true];
+    MessageType_EthereumSignMessage = 64 [(wire_in) = true];
+    MessageType_EthereumVerifyMessage = 65 [(wire_in) = true];
+    MessageType_EthereumMessageSignature = 66 [(wire_out) = true];
+
+    // NEM
+    MessageType_NEMGetAddress = 67 [(wire_in) = true];
+    MessageType_NEMAddress = 68 [(wire_out) = true];
+    MessageType_NEMSignTx = 69 [(wire_in) = true];
+    MessageType_NEMSignedTx = 70 [(wire_out) = true];
+    MessageType_NEMDecryptMessage = 75 [(wire_in) = true];
+    MessageType_NEMDecryptedMessage = 76 [(wire_out) = true];
+
+    // Lisk
+    MessageType_LiskGetAddress = 114 [(wire_in) = true];
+    MessageType_LiskAddress = 115 [(wire_out) = true];
+    MessageType_LiskSignTx = 116 [(wire_in) = true];
+    MessageType_LiskSignedTx = 117 [(wire_out) = true];
+    MessageType_LiskSignMessage = 118 [(wire_in) = true];
+    MessageType_LiskMessageSignature = 119 [(wire_out) = true];
+    MessageType_LiskVerifyMessage = 120 [(wire_in) = true];
+    MessageType_LiskGetPublicKey = 121 [(wire_in) = true];
+    MessageType_LiskPublicKey = 122 [(wire_out) = true];
+
+    // Tezos
+    MessageType_TezosGetAddress = 150 [(wire_in) = true];
+    MessageType_TezosAddress = 151 [(wire_out) = true];
+    MessageType_TezosSignTx = 152 [(wire_in) = true];
+    MessageType_TezosSignedTx = 153 [(wire_out) = true];
+    MessageType_TezosGetPublicKey = 154 [(wire_in) = true];
+    MessageType_TezosPublicKey = 155 [(wire_out) = true];
+
+    // Stellar
+    MessageType_StellarSignTx = 202 [(wire_in) = true];
+    MessageType_StellarTxOpRequest = 203 [(wire_out) = true];
+    MessageType_StellarGetAddress = 207 [(wire_in) = true];
+    MessageType_StellarAddress = 208 [(wire_out) = true];
+    MessageType_StellarCreateAccountOp = 210 [(wire_in) = true];
+    MessageType_StellarPaymentOp = 211 [(wire_in) = true];
+    MessageType_StellarPathPaymentOp = 212 [(wire_in) = true];
+    MessageType_StellarManageOfferOp = 213 [(wire_in) = true];
+    MessageType_StellarCreatePassiveOfferOp = 214 [(wire_in) = true];
+    MessageType_StellarSetOptionsOp = 215 [(wire_in) = true];
+    MessageType_StellarChangeTrustOp = 216 [(wire_in) = true];
+    MessageType_StellarAllowTrustOp = 217 [(wire_in) = true];
+    MessageType_StellarAccountMergeOp = 218 [(wire_in) = true];
+    // omitted: StellarInflationOp is not a supported operation, would be 219
+    MessageType_StellarManageDataOp = 220 [(wire_in) = true];
+    MessageType_StellarBumpSequenceOp = 221 [(wire_in) = true];
+    MessageType_StellarSignedTx = 230 [(wire_out) = true];
+
+    // TRON
+    MessageType_TronGetAddress = 250 [(wire_in) = true];
+    MessageType_TronAddress = 251 [(wire_out) = true];
+    MessageType_TronSignTx = 252 [(wire_in) = true];
+    MessageType_TronSignedTx = 253 [(wire_out) = true];
+
+    // Cardano
+    // dropped Sign/VerifyMessage ids 300-302
+    MessageType_CardanoSignTx = 303 [(wire_in) = true];
+    MessageType_CardanoTxRequest = 304 [(wire_out) = true];
+    MessageType_CardanoGetPublicKey = 305 [(wire_in) = true];
+    MessageType_CardanoPublicKey = 306 [(wire_out) = true];
+    MessageType_CardanoGetAddress = 307 [(wire_in) = true];
+    MessageType_CardanoAddress = 308 [(wire_out) = true];
+    MessageType_CardanoTxAck = 309 [(wire_in) = true];
+    MessageType_CardanoSignedTx = 310 [(wire_out) = true];
+
+    // Ontology
+    MessageType_OntologyGetAddress = 350 [(wire_in) = true];
+    MessageType_OntologyAddress = 351 [(wire_out) = true];
+    MessageType_OntologyGetPublicKey = 352 [(wire_in) = true];
+    MessageType_OntologyPublicKey = 353 [(wire_out) = true];
+    MessageType_OntologySignTransfer = 354 [(wire_in) = true];
+    MessageType_OntologySignedTransfer = 355 [(wire_out) = true];
+    MessageType_OntologySignWithdrawOng = 356 [(wire_in) = true];
+    MessageType_OntologySignedWithdrawOng = 357 [(wire_out) = true];
+    MessageType_OntologySignOntIdRegister = 358 [(wire_in) = true];
+    MessageType_OntologySignedOntIdRegister = 359 [(wire_out) = true];
+    MessageType_OntologySignOntIdAddAttributes = 360 [(wire_in) = true];
+    MessageType_OntologySignedOntIdAddAttributes = 361 [(wire_out) = true];
+
+    // Ripple
+    MessageType_RippleGetAddress = 400 [(wire_in) = true];
+    MessageType_RippleAddress = 401 [(wire_out) = true];
+    MessageType_RippleSignTx = 402 [(wire_in) = true];
+    MessageType_RippleSignedTx = 403 [(wire_in) = true];
+
+    // Monero
+    MessageType_MoneroTransactionInitRequest = 501 [(wire_out) = true];
+    MessageType_MoneroTransactionInitAck = 502 [(wire_out) = true];
+    MessageType_MoneroTransactionSetInputRequest = 503 [(wire_out) = true];
+    MessageType_MoneroTransactionSetInputAck = 504 [(wire_out) = true];
+    MessageType_MoneroTransactionInputsPermutationRequest = 505 [(wire_out) = true];
+    MessageType_MoneroTransactionInputsPermutationAck = 506 [(wire_out) = true];
+    MessageType_MoneroTransactionInputViniRequest = 507 [(wire_out) = true];
+    MessageType_MoneroTransactionInputViniAck = 508 [(wire_out) = true];
+    MessageType_MoneroTransactionAllInputsSetRequest = 509 [(wire_out) = true];
+    MessageType_MoneroTransactionAllInputsSetAck = 510 [(wire_out) = true];
+    MessageType_MoneroTransactionSetOutputRequest = 511 [(wire_out) = true];
+    MessageType_MoneroTransactionSetOutputAck = 512 [(wire_out) = true];
+    MessageType_MoneroTransactionAllOutSetRequest = 513 [(wire_out) = true];
+    MessageType_MoneroTransactionAllOutSetAck = 514 [(wire_out) = true];
+    MessageType_MoneroTransactionSignInputRequest = 515 [(wire_out) = true];
+    MessageType_MoneroTransactionSignInputAck = 516 [(wire_out) = true];
+    MessageType_MoneroTransactionFinalRequest = 517 [(wire_out) = true];
+    MessageType_MoneroTransactionFinalAck = 518 [(wire_out) = true];
+    MessageType_MoneroKeyImageExportInitRequest = 530 [(wire_out) = true];
+    MessageType_MoneroKeyImageExportInitAck = 531 [(wire_out) = true];
+    MessageType_MoneroKeyImageSyncStepRequest = 532 [(wire_out) = true];
+    MessageType_MoneroKeyImageSyncStepAck = 533 [(wire_out) = true];
+    MessageType_MoneroKeyImageSyncFinalRequest = 534 [(wire_out) = true];
+    MessageType_MoneroKeyImageSyncFinalAck = 535 [(wire_out) = true];
+    MessageType_MoneroGetAddress = 540 [(wire_in) = true];
+    MessageType_MoneroAddress = 541 [(wire_out) = true];
+    MessageType_MoneroGetWatchKey = 542 [(wire_in) = true];
+    MessageType_MoneroWatchKey = 543 [(wire_out) = true];
+    MessageType_DebugMoneroDiagRequest = 546 [(wire_in) = true];
+    MessageType_DebugMoneroDiagAck = 547 [(wire_out) = true];
+    MessageType_MoneroGetTxKeyRequest = 550 [(wire_in) = true];
+    MessageType_MoneroGetTxKeyAck = 551 [(wire_out) = true];
+    MessageType_MoneroLiveRefreshStartRequest = 552 [(wire_in) = true];
+    MessageType_MoneroLiveRefreshStartAck = 553 [(wire_out) = true];
+    MessageType_MoneroLiveRefreshStepRequest = 554 [(wire_in) = true];
+    MessageType_MoneroLiveRefreshStepAck = 555 [(wire_out) = true];
+    MessageType_MoneroLiveRefreshFinalRequest = 556 [(wire_in) = true];
+    MessageType_MoneroLiveRefreshFinalAck = 557 [(wire_out) = true];
+
+    // EOS
+    MessageType_EosGetPublicKey = 600 [(wire_in) = true];
+    MessageType_EosPublicKey = 601 [(wire_out) = true];
+    MessageType_EosSignTx = 602 [(wire_in) = true];
+    MessageType_EosTxActionRequest = 603 [(wire_out) = true];
+    MessageType_EosTxActionAck = 604 [(wire_in) = true];
+    MessageType_EosSignedTx = 605 [(wire_out) = true];
+
+    // Binance
+    MessageType_BinanceGetAddress = 700 [(wire_in) = true];
+    MessageType_BinanceAddress = 701 [(wire_out) = true];
+    MessageType_BinanceGetPublicKey = 702 [(wire_in) = true];
+    MessageType_BinancePublicKey = 703 [(wire_out) = true];
+    MessageType_BinanceSignTx = 704 [(wire_in) = true];
+    MessageType_BinanceTxRequest = 705 [(wire_out) = true];
+    MessageType_BinanceTransferMsg = 706 [(wire_in) = true];
+    MessageType_BinanceOrderMsg = 707 [(wire_in) = true];
+    MessageType_BinanceCancelMsg = 708 [(wire_in) = true];
+    MessageType_BinanceSignedTx = 709 [(wire_out) = true];
+}
diff --git a/accounts/usbwallet/trezor/trezor.go b/accounts/usbwallet/trezor/trezor.go
new file mode 100644
index 000000000..7e756e609
--- /dev/null
+++ b/accounts/usbwallet/trezor/trezor.go
@@ -0,0 +1,70 @@
+// Copyright 2017 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+// This file contains the implementation for interacting with the Trezor hardware
+// wallets. The wire protocol spec can be found on the SatoshiLabs website:
+// https://wiki.trezor.io/Developers_guide-Message_Workflows
+
+// !!! STAHP !!!
+//
+// Before you touch the protocol files, you need to be aware of a breaking change
+// that occurred between firmware versions 1.7.3->1.8.0 (Model One) and 2.0.10->
+// 2.1.0 (Model T). The Ethereum address representation was changed from the 20
+// byte binary blob to a 42 byte hex string. The upstream protocol buffer files
+// only support the new format, so blindly pulling in a new spec will break old
+// devices!
+//
+// The Trezor devs had the foresight to add the string version as a new message
+// code instead of replacing the binary one. This means that the proto file can
+// actually define both the old and the new versions as optional. Please ensure
+// that you add back the old addresses everywhere (to avoid name clash. use the
+// addressBin and addressHex names).
+//
+// If in doubt, reach out to @karalabe.
+
+// To regenerate the protocol files in this package:
+//   - Download the latest protoc https://github.com/protocolbuffers/protobuf/releases
+//   - Build with the usual `./configure && make` and ensure it's on your $PATH
+//   - Delete all the .proto and .pb.go files, pull in fresh ones from Trezor
+//   - Grab the latest Go plugin `go get -u github.com/golang/protobuf/protoc-gen-go`
+//   - Vendor in the latest Go plugin `govendor fetch github.com/golang/protobuf/...`
+
+//go:generate protoc -I/usr/local/include:. --go_out=import_path=trezor:. messages.proto messages-common.proto messages-management.proto messages-ethereum.proto
+
+// Package trezor contains the wire protocol.
+package trezor
+
+import (
+	"reflect"
+
+	"github.com/golang/protobuf/proto"
+)
+
+// Type returns the protocol buffer type number of a specific message. If the
+// message is nil, this method panics!
+func Type(msg proto.Message) uint16 {
+	return uint16(MessageType_value["MessageType_"+reflect.TypeOf(msg).Elem().Name()])
+}
+
+// Name returns the friendly message type name of a specific protocol buffer
+// type number.
+func Name(kind uint16) string {
+	name := MessageType_name[int32(kind)]
+	if len(name) < 12 {
+		return name
+	}
+	return name[12:]
+}
diff --git a/accounts/usbwallet/wallet.go b/accounts/usbwallet/wallet.go
index 943a7b3f9..ca7e54427 100644
--- a/accounts/usbwallet/wallet.go
+++ b/accounts/usbwallet/wallet.go
@@ -20,17 +20,17 @@ package usbwallet
 import (
 	"context"
 	"fmt"
-	"io"
-	"math/big"
-	"sync"
-	"time"
-
-	"github.com/karalabe/hid"
+	"github.com/karalabe/usb"
 	ethereum "github.com/truechain/truechain-engineering-code"
 	"github.com/truechain/truechain-engineering-code/accounts"
 	"github.com/truechain/truechain-engineering-code/common"
 	"github.com/truechain/truechain-engineering-code/core/types"
+	"github.com/truechain/truechain-engineering-code/crypto"
 	"github.com/truechain/truechain-engineering-code/log"
+	"io"
+	"math/big"
+	"sync"
+	"time"
 )
 
 // Maximum time between wallet health checks to detect USB unplugs.
@@ -66,6 +66,8 @@ type driver interface {
 	// SignTx sends the transaction to the USB device and waits for the user to confirm
 	// or deny the transaction.
 	SignTx(path accounts.DerivationPath, tx *types.Transaction, chainID *big.Int) (common.Address, *types.Transaction, error)
+
+	SignTypedMessage(path accounts.DerivationPath, messageHash []byte, domainHash []byte) ([]byte, error)
 }
 
 // wallet represents the common functionality shared by all USB hardware
@@ -76,17 +78,17 @@ type wallet struct {
 	driver driver        // Hardware implementation of the low level device operations
 	url    *accounts.URL // Textual URL uniquely identifying this wallet
 
-	info   hid.DeviceInfo // Known USB device infos about the wallet
-	device *hid.Device    // USB device advertising itself as a hardware wallet
+	info   usb.DeviceInfo // Known USB device infos about the wallet
+	device usb.Device     // USB device advertising itself as a hardware wallet
 
 	accounts []accounts.Account                         // List of derive accounts pinned on the hardware wallet
 	paths    map[common.Address]accounts.DerivationPath // Known derivation paths for signing operations
 
-	deriveNextPath accounts.DerivationPath   // Next derivation path for account auto-discovery
-	deriveNextAddr common.Address            // Next derived account address for auto-discovery
-	deriveChain    ethereum.ChainStateReader // Blockchain state reader to discover used account with
-	deriveReq      chan chan struct{}        // Channel to request a self-derivation on
-	deriveQuit     chan chan error           // Channel to terminate the self-deriver with
+	deriveNextPaths []accounts.DerivationPath // Next derivation paths for account auto-discovery (multiple bases supported)
+	deriveNextAddrs []common.Address          // Next derived account addresses for auto-discovery (multiple bases supported)
+	deriveChain     ethereum.ChainStateReader // Blockchain state reader to discover used account with
+	deriveReq       chan chan struct{}        // Channel to request a self-derivation on
+	deriveQuit      chan chan error           // Channel to terminate the self-deriver with
 
 	healthQuit chan chan error
 
@@ -273,9 +275,7 @@ func (w *wallet) close() error {
 	w.device = nil
 
 	w.accounts, w.paths = nil, nil
-	w.driver.Close()
-
-	return nil
+	return w.driver.Close()
 }
 
 // Accounts implements accounts.Wallet, returning the list of accounts pinned to
@@ -340,57 +340,66 @@ func (w *wallet) selfDerive() {
 			accs  []accounts.Account
 			paths []accounts.DerivationPath
 
-			nextAddr = w.deriveNextAddr
-			nextPath = w.deriveNextPath
+			nextPaths = append([]accounts.DerivationPath{}, w.deriveNextPaths...)
+			nextAddrs = append([]common.Address{}, w.deriveNextAddrs...)
 
 			context = context.Background()
 		)
-		for empty := false; !empty; {
-			// Retrieve the next derived Ethereum account
-			if nextAddr == (common.Address{}) {
-				if nextAddr, err = w.driver.Derive(nextPath); err != nil {
-					w.log.Warn("USB wallet account derivation failed", "err", err)
+		for i := 0; i < len(nextAddrs); i++ {
+			for empty := false; !empty; {
+				// Retrieve the next derived Ethereum account
+				if nextAddrs[i] == (common.Address{}) {
+					if nextAddrs[i], err = w.driver.Derive(nextPaths[i]); err != nil {
+						w.log.Warn("USB wallet account derivation failed", "err", err)
+						break
+					}
+				}
+				// Check the account's status against the current chain state
+				var (
+					balance *big.Int
+					nonce   uint64
+				)
+				balance, err = w.deriveChain.BalanceAt(context, nextAddrs[i], nil)
+				if err != nil {
+					w.log.Warn("USB wallet balance retrieval failed", "err", err)
 					break
 				}
-			}
-			// Check the account's status against the current chain state
-			var (
-				balance *big.Int
-				nonce   uint64
-			)
-			balance, err = w.deriveChain.BalanceAt(context, nextAddr, nil)
-			if err != nil {
-				w.log.Warn("USB wallet balance retrieval failed", "err", err)
-				break
-			}
-			nonce, err = w.deriveChain.NonceAt(context, nextAddr, nil)
-			if err != nil {
-				w.log.Warn("USB wallet nonce retrieval failed", "err", err)
-				break
-			}
-			// If the next account is empty, stop self-derivation, but add it nonetheless
-			if balance.Sign() == 0 && nonce == 0 {
-				empty = true
-			}
-			// We've just self-derived a new account, start tracking it locally
-			path := make(accounts.DerivationPath, len(nextPath))
-			copy(path[:], nextPath[:])
-			paths = append(paths, path)
-
-			account := accounts.Account{
-				Address: nextAddr,
-				URL:     accounts.URL{Scheme: w.url.Scheme, Path: fmt.Sprintf("%s/%s", w.url.Path, path)},
-			}
-			accs = append(accs, account)
+				nonce, err = w.deriveChain.NonceAt(context, nextAddrs[i], nil)
+				if err != nil {
+					w.log.Warn("USB wallet nonce retrieval failed", "err", err)
+					break
+				}
+				// We've just self-derived a new account, start tracking it locally
+				// unless the account was empty.
+				path := make(accounts.DerivationPath, len(nextPaths[i]))
+				copy(path[:], nextPaths[i][:])
+				if balance.Sign() == 0 && nonce == 0 {
+					empty = true
+					// If it indeed was empty, make a log output for it anyway. In the case
+					// of legacy-ledger, the first account on the legacy-path will
+					// be shown to the user, even if we don't actively track it
+					if i < len(nextAddrs)-1 {
+						w.log.Info("Skipping trakcking first account on legacy path, use personal.deriveAccount(<url>,<path>, false) to track",
+							"path", path, "address", nextAddrs[i])
+						break
+					}
+				}
+				paths = append(paths, path)
+				account := accounts.Account{
+					Address: nextAddrs[i],
+					URL:     accounts.URL{Scheme: w.url.Scheme, Path: fmt.Sprintf("%s/%s", w.url.Path, path)},
+				}
+				accs = append(accs, account)
 
-			// Display a log message to the user for new (or previously empty accounts)
-			if _, known := w.paths[nextAddr]; !known || (!empty && nextAddr == w.deriveNextAddr) {
-				w.log.Info("USB wallet discovered new account", "address", nextAddr, "path", path, "balance", balance, "nonce", nonce)
-			}
-			// Fetch the next potential account
-			if !empty {
-				nextAddr = common.Address{}
-				nextPath[len(nextPath)-1]++
+				// Display a log message to the user for new (or previously empty accounts)
+				if _, known := w.paths[nextAddrs[i]]; !known || (!empty && nextAddrs[i] == w.deriveNextAddrs[i]) {
+					w.log.Info("USB wallet discovered new account", "address", nextAddrs[i], "path", path, "balance", balance, "nonce", nonce)
+				}
+				// Fetch the next potential account
+				if !empty {
+					nextAddrs[i] = common.Address{}
+					nextPaths[i][len(nextPaths[i])-1]++
+				}
 			}
 		}
 		// Self derivation complete, release device lock
@@ -407,8 +416,8 @@ func (w *wallet) selfDerive() {
 		}
 		// Shift the self-derivation forward
 		// TODO(karalabe): don't overwrite changes from wallet.SelfDerive
-		w.deriveNextAddr = nextAddr
-		w.deriveNextPath = nextPath
+		w.deriveNextAddrs = nextAddrs
+		w.deriveNextPaths = nextPaths
 		w.stateLock.Unlock()
 
 		// Notify the user of termination and loop after a bit of time (to avoid trashing)
@@ -475,32 +484,100 @@ func (w *wallet) Derive(path accounts.DerivationPath, pin bool) (accounts.Accoun
 
 	if _, ok := w.paths[address]; !ok {
 		w.accounts = append(w.accounts, account)
-		w.paths[address] = path
+		w.paths[address] = make(accounts.DerivationPath, len(path))
+		copy(w.paths[address], path)
 	}
 	return account, nil
 }
 
-// SelfDerive implements accounts.Wallet, trying to discover accounts that the
-// user used previously (based on the chain state), but ones that he/she did not
-// explicitly pin to the wallet manually. To avoid chain head monitoring, self
-// derivation only runs during account listing (and even then throttled).
-func (w *wallet) SelfDerive(base accounts.DerivationPath, chain ethereum.ChainStateReader) {
+// SelfDerive sets a base account derivation path from which the wallet attempts
+// to discover non zero accounts and automatically add them to list of tracked
+// accounts.
+//
+// Note, self derivation will increment the last component of the specified path
+// opposed to decending into a child path to allow discovering accounts starting
+// from non zero components.
+//
+// Some hardware wallets switched derivation paths through their evolution, so
+// this method supports providing multiple bases to discover old user accounts
+// too. Only the last base will be used to derive the next empty account.
+//
+// You can disable automatic account discovery by calling SelfDerive with a nil
+// chain state reader.
+func (w *wallet) SelfDerive(bases []accounts.DerivationPath, chain ethereum.ChainStateReader) {
 	w.stateLock.Lock()
 	defer w.stateLock.Unlock()
 
-	w.deriveNextPath = make(accounts.DerivationPath, len(base))
-	copy(w.deriveNextPath[:], base[:])
-
-	w.deriveNextAddr = common.Address{}
+	w.deriveNextPaths = make([]accounts.DerivationPath, len(bases))
+	for i, base := range bases {
+		w.deriveNextPaths[i] = make(accounts.DerivationPath, len(base))
+		copy(w.deriveNextPaths[i][:], base[:])
+	}
+	w.deriveNextAddrs = make([]common.Address, len(bases))
 	w.deriveChain = chain
 }
 
-// SignHash implements accounts.Wallet, however signing arbitrary data is not
+// signHash implements accounts.Wallet, however signing arbitrary data is not
 // supported for hardware wallets, so this method will always return an error.
-func (w *wallet) SignHash(account accounts.Account, hash []byte) ([]byte, error) {
+func (w *wallet) signHash(account accounts.Account, hash []byte) ([]byte, error) {
 	return nil, accounts.ErrNotSupported
 }
 
+// SignData signs keccak256(data). The mimetype parameter describes the type of data being signed
+func (w *wallet) SignData(account accounts.Account, mimeType string, data []byte) ([]byte, error) {
+
+	// Unless we are doing 712 signing, simply dispatch to signHash
+	if !(mimeType == accounts.MimetypeTypedData && len(data) == 66 && data[0] == 0x19 && data[1] == 0x01) {
+		return w.signHash(account, crypto.Keccak256(data))
+	}
+
+	// dispatch to 712 signing if the mimetype is TypedData and the format matches
+	w.stateLock.RLock() // Comms have own mutex, this is for the state fields
+	defer w.stateLock.RUnlock()
+
+	// If the wallet is closed, abort
+	if w.device == nil {
+		return nil, accounts.ErrWalletClosed
+	}
+	// Make sure the requested account is contained within
+	path, ok := w.paths[account.Address]
+	if !ok {
+		return nil, accounts.ErrUnknownAccount
+	}
+	// All infos gathered and metadata checks out, request signing
+	<-w.commsLock
+	defer func() { w.commsLock <- struct{}{} }()
+
+	// Ensure the device isn't screwed with while user confirmation is pending
+	// TODO(karalabe): remove if hotplug lands on Windows
+	w.hub.commsLock.Lock()
+	w.hub.commsPend++
+	w.hub.commsLock.Unlock()
+
+	defer func() {
+		w.hub.commsLock.Lock()
+		w.hub.commsPend--
+		w.hub.commsLock.Unlock()
+	}()
+	// Sign the transaction
+	signature, err := w.driver.SignTypedMessage(path, data[2:34], data[34:66])
+	if err != nil {
+		return nil, err
+	}
+	return signature, nil
+}
+
+// SignDataWithPassphrase implements accounts.Wallet, attempting to sign the given
+// data with the given account using passphrase as extra authentication.
+// Since USB wallets don't rely on passphrases, these are silently ignored.
+func (w *wallet) SignDataWithPassphrase(account accounts.Account, passphrase, mimeType string, data []byte) ([]byte, error) {
+	return w.SignData(account, mimeType, data)
+}
+
+func (w *wallet) SignText(account accounts.Account, text []byte) ([]byte, error) {
+	return w.signHash(account, accounts.TextHash(text))
+}
+
 // SignTx implements accounts.Wallet. It sends the transaction over to the Ledger
 // wallet to request a confirmation from the user. It returns either the signed
 // transaction or a failure if the user denied the transaction.
@@ -547,15 +624,11 @@ func (w *wallet) SignTx(account accounts.Account, tx *types.Transaction, chainID
 	return signed, nil
 }
 
-func (w *wallet) SignTx_Payment(account accounts.Account, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) {
-	return nil, nil
-}
-
 // SignHashWithPassphrase implements accounts.Wallet, however signing arbitrary
 // data is not supported for Ledger wallets, so this method will always return
 // an error.
-func (w *wallet) SignHashWithPassphrase(account accounts.Account, passphrase string, hash []byte) ([]byte, error) {
-	return w.SignHash(account, hash)
+func (w *wallet) SignTextWithPassphrase(account accounts.Account, passphrase string, text []byte) ([]byte, error) {
+	return w.SignText(account, accounts.TextHash(text))
 }
 
 // SignTxWithPassphrase implements accounts.Wallet, attempting to sign the given
diff --git a/cmd/getrue/main.go b/cmd/getrue/main.go
index ae5f7ff54..9a94d777c 100644
--- a/cmd/getrue/main.go
+++ b/cmd/getrue/main.go
@@ -292,9 +292,9 @@ func startNode(ctx *cli.Context, stack *node.Node) {
 				log.Info("New wallet appeared", "url", event.Wallet.URL(), "status", status)
 
 				if event.Wallet.URL().Scheme == "ledger" {
-					event.Wallet.SelfDerive(accounts.DefaultLedgerBaseDerivationPath, stateReader)
+					event.Wallet.SelfDerive([]accounts.DerivationPath{accounts.LegacyLedgerBaseDerivationPath}, stateReader)
 				} else {
-					event.Wallet.SelfDerive(accounts.DefaultBaseDerivationPath, stateReader)
+					event.Wallet.SelfDerive([]accounts.DerivationPath{accounts.DefaultBaseDerivationPath}, stateReader)
 				}
 
 			case accounts.WalletDropped:
diff --git a/core/types/block.go b/core/types/block.go
index fa2ebf210..06ae671a4 100644
--- a/core/types/block.go
+++ b/core/types/block.go
@@ -163,6 +163,9 @@ type Header struct {
 	GasUsed       uint64         `json:"gasUsed"          gencodec:"required"`
 	Time          *big.Int       `json:"timestamp"        gencodec:"required"`
 	Extra         []byte         `json:"extraData"        gencodec:"required"`
+
+	// BaseFee was added by EIP-1559 and is ignored in legacy headers.
+	BaseFee *big.Int `json:"baseFeePerGas" rlp:"optional"`
 }
 
 // field type overrides for gencodec
diff --git a/core/types/transaction_signing.go b/core/types/transaction_signing.go
index 958b4cc43..aee57f2fa 100644
--- a/core/types/transaction_signing.go
+++ b/core/types/transaction_signing.go
@@ -50,7 +50,21 @@ func MakeSigner(config *params.ChainConfig, blockNumber *big.Int) Signer {
 	return signer
 }
 
-// SignTx signs the transaction using the given signer and private key
+// LatestSignerForChainID returns the 'most permissive' Signer available. Specifically,
+// this enables support for EIP-155 replay protection and all implemented EIP-2718
+// transaction types if chainID is non-nil.
+//
+// Use this in transaction-handling code where the current block number and fork
+// configuration are unknown. If you have a ChainConfig, use LatestSigner instead.
+// If you have a ChainConfig and know the current block number, use MakeSigner instead.
+func LatestSignerForChainID(chainID *big.Int) Signer {
+	if chainID == nil {
+		return TIP1Signer{}
+	}
+	return NewTIP1Signer(chainID)
+}
+
+// SignTx signs the transaction using the given signer and private key.
 func SignTx(tx *Transaction, s Signer, prv *ecdsa.PrivateKey) (*Transaction, error) {
 	h := s.Hash(tx)
 	sig, err := crypto.Sign(h[:], prv)
diff --git a/core/vm/access_list_tracer.go b/core/vm/access_list_tracer.go
index 9fd1388ff..b6619b661 100644
--- a/core/vm/access_list_tracer.go
+++ b/core/vm/access_list_tracer.go
@@ -96,7 +96,7 @@ func (al accessList) equal(other accessList) bool {
 func (al accessList) accessList() types.AccessList {
 	acl := make(types.AccessList, 0, len(al))
 	for addr, slots := range al {
-		tuple := types.AccessTuple{Address: addr}
+		tuple := types.AccessTuple{Address: addr, StorageKeys: []common.Hash{}}
 		for slot := range slots {
 			tuple.StorageKeys = append(tuple.StorageKeys, slot)
 		}
diff --git a/core/vm/analysis.go b/core/vm/analysis.go
index 0ccf47b97..449cded2a 100644
--- a/core/vm/analysis.go
+++ b/core/vm/analysis.go
@@ -16,17 +16,49 @@
 
 package vm
 
+const (
+	set2BitsMask = uint16(0b1100_0000_0000_0000)
+	set3BitsMask = uint16(0b1110_0000_0000_0000)
+	set4BitsMask = uint16(0b1111_0000_0000_0000)
+	set5BitsMask = uint16(0b1111_1000_0000_0000)
+	set6BitsMask = uint16(0b1111_1100_0000_0000)
+	set7BitsMask = uint16(0b1111_1110_0000_0000)
+)
+
 // bitvec is a bit vector which maps bytes in a program.
 // An unset bit means the byte is an opcode, a set bit means
 // it's data (i.e. argument of PUSHxx).
 type bitvec []byte
 
-func (bits *bitvec) set(pos uint64) {
-	(*bits)[pos/8] |= 0x80 >> (pos % 8)
+var lookup = [8]byte{
+	0x80, 0x40, 0x20, 0x10, 0x8, 0x4, 0x2, 0x1,
+}
+
+func (bits bitvec) set1(pos uint64) {
+	bits[pos/8] |= lookup[pos%8]
+}
+
+func (bits bitvec) setN(flag uint16, pos uint64) {
+	a := flag >> (pos % 8)
+	bits[pos/8] |= byte(a >> 8)
+	if b := byte(a); b != 0 {
+		//	If the bit-setting affects the neighbouring byte, we can assign - no need to OR it,
+		//	since it's the first write to that byte
+		bits[pos/8+1] = b
+	}
+}
+
+func (bits bitvec) set8(pos uint64) {
+	a := byte(0xFF >> (pos % 8))
+	bits[pos/8] |= a
+	bits[pos/8+1] = ^a
 }
-func (bits *bitvec) set8(pos uint64) {
-	(*bits)[pos/8] |= 0xFF >> (pos % 8)
-	(*bits)[pos/8+1] |= ^(0xFF >> (pos % 8))
+
+func (bits bitvec) set16(pos uint64) {
+	a := byte(0xFF >> (pos % 8))
+	bits[pos/8] |= a
+	bits[pos/8+1] = 0xFF
+	bits[pos/8+2] = ^a
 }
 
 // codeSegment checks if the position is in a code segment.
@@ -40,22 +72,52 @@ func codeBitmap(code []byte) bitvec {
 	// ends with a PUSH32, the algorithm will push zeroes onto the
 	// bitvector outside the bounds of the actual code.
 	bits := make(bitvec, len(code)/8+1+4)
+	return codeBitmapInternal(code, bits)
+}
+
+// codeBitmapInternal is the internal implementation of codeBitmap.
+// It exists for the purpose of being able to run benchmark tests
+// without dynamic allocations affecting the results.
+func codeBitmapInternal(code, bits bitvec) bitvec {
 	for pc := uint64(0); pc < uint64(len(code)); {
 		op := OpCode(code[pc])
-
-		if op >= PUSH1 && op <= PUSH32 {
-			numbits := op - PUSH1 + 1
-			pc++
+		pc++
+		if op < PUSH1 || op > PUSH32 {
+			continue
+		}
+		numbits := op - PUSH1 + 1
+		if numbits >= 8 {
+			for ; numbits >= 16; numbits -= 16 {
+				bits.set16(pc)
+				pc += 16
+			}
 			for ; numbits >= 8; numbits -= 8 {
-				bits.set8(pc) // 8
+				bits.set8(pc)
 				pc += 8
 			}
-			for ; numbits > 0; numbits-- {
-				bits.set(pc)
-				pc++
-			}
-		} else {
-			pc++
+		}
+		switch numbits {
+		case 1:
+			bits.set1(pc)
+			pc += 1
+		case 2:
+			bits.setN(set2BitsMask, pc)
+			pc += 2
+		case 3:
+			bits.setN(set3BitsMask, pc)
+			pc += 3
+		case 4:
+			bits.setN(set4BitsMask, pc)
+			pc += 4
+		case 5:
+			bits.setN(set5BitsMask, pc)
+			pc += 5
+		case 6:
+			bits.setN(set6BitsMask, pc)
+			pc += 6
+		case 7:
+			bits.setN(set7BitsMask, pc)
+			pc += 7
 		}
 	}
 	return bits
diff --git a/core/vm/analysis_test.go b/core/vm/analysis_test.go
index d20b501ce..53d6c307b 100644
--- a/core/vm/analysis_test.go
+++ b/core/vm/analysis_test.go
@@ -47,17 +47,20 @@ func TestJumpDestAnalysis(t *testing.T) {
 		{[]byte{byte(PUSH32)}, 0xFF, 1},
 		{[]byte{byte(PUSH32)}, 0xFF, 2},
 	}
-	for _, test := range tests {
+	for i, test := range tests {
 		ret := codeBitmap(test.code)
 		if ret[test.which] != test.exp {
-			t.Fatalf("expected %x, got %02x", test.exp, ret[test.which])
+			t.Fatalf("test %d: expected %x, got %02x", i, test.exp, ret[test.which])
 		}
 	}
 }
 
+const analysisCodeSize = 1200 * 1024
+
 func BenchmarkJumpdestAnalysis_1200k(bench *testing.B) {
 	// 1.4 ms
-	code := make([]byte, 1200000)
+	code := make([]byte, analysisCodeSize)
+	bench.SetBytes(analysisCodeSize)
 	bench.ResetTimer()
 	for i := 0; i < bench.N; i++ {
 		codeBitmap(code)
@@ -66,10 +69,37 @@ func BenchmarkJumpdestAnalysis_1200k(bench *testing.B) {
 }
 func BenchmarkJumpdestHashing_1200k(bench *testing.B) {
 	// 4 ms
-	code := make([]byte, 1200000)
+	code := make([]byte, analysisCodeSize)
+	bench.SetBytes(analysisCodeSize)
 	bench.ResetTimer()
 	for i := 0; i < bench.N; i++ {
 		crypto.Keccak256Hash(code)
 	}
 	bench.StopTimer()
 }
+
+func BenchmarkJumpdestOpAnalysis(bench *testing.B) {
+	var op OpCode
+	bencher := func(b *testing.B) {
+		code := make([]byte, analysisCodeSize)
+		b.SetBytes(analysisCodeSize)
+		for i := range code {
+			code[i] = byte(op)
+		}
+		bits := make(bitvec, len(code)/8+1+4)
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			for j := range bits {
+				bits[j] = 0
+			}
+			codeBitmapInternal(code, bits)
+		}
+	}
+	for op = PUSH1; op <= PUSH32; op++ {
+		bench.Run(op.String(), bencher)
+	}
+	op = JUMPDEST
+	bench.Run(op.String(), bencher)
+	op = STOP
+	bench.Run(op.String(), bencher)
+}
diff --git a/core/vm/errors.go b/core/vm/errors.go
index e64e38ed4..8fb880a3e 100644
--- a/core/vm/errors.go
+++ b/core/vm/errors.go
@@ -42,6 +42,7 @@ var (
 	ErrReturnStackExceeded        = errors.New("return stack limit reached")
 	ErrStakingInvalidInput        = errors.New("invalid input for staking")
 	ErrStakingInsufficientBalance = errors.New("insufficient balance for staking transfer")
+	ErrInvalidCode                = errors.New("invalid code: must not begin with 0xef")
 )
 
 // ErrStackUnderflow wraps an evm error when the items on the stack less
diff --git a/core/vm/gas_table.go b/core/vm/gas_table.go
index dcc1a32e7..d6a5960cd 100644
--- a/core/vm/gas_table.go
+++ b/core/vm/gas_table.go
@@ -59,7 +59,7 @@ func memoryGasCost(mem *Memory, newMemSize uint64) (uint64, error) {
 // as argument:
 // CALLDATACOPY (stack position 2)
 // CODECOPY (stack position 2)
-// EXTCODECOPY (stack poition 3)
+// EXTCODECOPY (stack position 3)
 // RETURNDATACOPY (stack position 2)
 func memoryCopierGas(stackpos int) gasFunc {
 	return func(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) {
@@ -161,18 +161,18 @@ func gasSStore(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySi
 }
 
 // 0. If *gasleft* is less than or equal to 2300, fail the current call.
-// 1. If current value equals new value (this is a no-op), SSTORE_NOOP_GAS gas is deducted.
+// 1. If current value equals new value (this is a no-op), SLOAD_GAS is deducted.
 // 2. If current value does not equal new value:
 //   2.1. If original value equals current value (this storage slot has not been changed by the current execution context):
-//     2.1.1. If original value is 0, SSTORE_INIT_GAS gas is deducted.
-//     2.1.2. Otherwise, SSTORE_CLEAN_GAS gas is deducted. If new value is 0, add SSTORE_CLEAR_REFUND to refund counter.
-//   2.2. If original value does not equal current value (this storage slot is dirty), SSTORE_DIRTY_GAS gas is deducted. Apply both of the following clauses:
+//     2.1.1. If original value is 0, SSTORE_SET_GAS (20K) gas is deducted.
+//     2.1.2. Otherwise, SSTORE_RESET_GAS gas is deducted. If new value is 0, add SSTORE_CLEARS_SCHEDULE to refund counter.
+//   2.2. If original value does not equal current value (this storage slot is dirty), SLOAD_GAS gas is deducted. Apply both of the following clauses:
 //     2.2.1. If original value is not 0:
-//       2.2.1.1. If current value is 0 (also means that new value is not 0), subtract SSTORE_CLEAR_REFUND gas from refund counter. We can prove that refund counter will never go below 0.
-//       2.2.1.2. If new value is 0 (also means that current value is not 0), add SSTORE_CLEAR_REFUND gas to refund counter.
+//       2.2.1.1. If current value is 0 (also means that new value is not 0), subtract SSTORE_CLEARS_SCHEDULE gas from refund counter.
+//       2.2.1.2. If new value is 0 (also means that current value is not 0), add SSTORE_CLEARS_SCHEDULE gas to refund counter.
 //     2.2.2. If original value equals new value (this storage slot is reset):
-//       2.2.2.1. If original value is 0, add SSTORE_INIT_REFUND to refund counter.
-//       2.2.2.2. Otherwise, add SSTORE_CLEAN_REFUND gas to refund counter.
+//       2.2.2.1. If original value is 0, add SSTORE_SET_GAS - SLOAD_GAS to refund counter.
+//       2.2.2.2. Otherwise, add SSTORE_RESET_GAS - SLOAD_GAS gas to refund counter.
 func gasSStoreEIP2200(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) {
 	// If we fail the minimum gas availability invariant, fail (0)
 	if contract.Gas <= params.SstoreSentryGasEIP2200 {
@@ -186,7 +186,7 @@ func gasSStoreEIP2200(evm *EVM, contract *Contract, stack *Stack, mem *Memory, m
 	value := common.Hash(y.Bytes32())
 
 	if current == value { // noop (1)
-		return params.SstoreNoopGasEIP2200, nil
+		return params.SloadGasEIP2200, nil
 	}
 	original := evm.StateDB.GetCommittedState(contract.Address(), x.Bytes32())
 	if original == current {
@@ -195,7 +195,6 @@ func gasSStoreEIP2200(evm *EVM, contract *Contract, stack *Stack, mem *Memory, m
 		}
 		if value == (common.Hash{}) { // delete slot (2.1.2b)
 			evm.StateDB.AddRefund(params.SstoreClearsScheduleRefundEIP2200)
-
 		}
 		return params.SstoreResetGasEIP2200, nil // write existing slot (2.1.2)
 	}
@@ -208,12 +207,12 @@ func gasSStoreEIP2200(evm *EVM, contract *Contract, stack *Stack, mem *Memory, m
 	}
 	if original == value {
 		if original == (common.Hash{}) { // reset to original inexistent slot (2.2.2.1)
-			evm.StateDB.AddRefund(params.SstoreInitRefundEIP2200)
+			evm.StateDB.AddRefund(params.SstoreSetGasEIP2200 - params.SloadGasEIP2200)
 		} else { // reset to original existing slot (2.2.2.2)
-			evm.StateDB.AddRefund(params.SstoreCleanRefundEIP2200)
+			evm.StateDB.AddRefund(params.SstoreResetGasEIP2200 - params.SloadGasEIP2200)
 		}
 	}
-	return params.SstoreDirtyGasEIP2200, nil // dirty update (2.2)
+	return params.SloadGasEIP2200, nil // dirty update (2.2)
 }
 
 func makeGasLog(n uint64) gasFunc {
@@ -298,7 +297,20 @@ func gasCreate2(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memoryS
 	return gas, nil
 }
 
-func gasExp(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) {
+func gasExpFrontier(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) {
+	expByteLen := uint64((stack.data[stack.len()-2].BitLen() + 7) / 8)
+
+	var (
+		gas      = expByteLen * params.ExpByteFrontier // no overflow check required. Max is 256 * ExpByte gas
+		overflow bool
+	)
+	if gas, overflow = math.SafeAdd(gas, params.ExpGas); overflow {
+		return 0, ErrGasUintOverflow
+	}
+	return gas, nil
+}
+
+func gasExpEIP158(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) {
 	expByteLen := uint64((stack.data[stack.len()-2].BitLen() + 7) / 8)
 
 	var (
diff --git a/core/vm/gas_table_test.go b/core/vm/gas_table_test.go
index 3a86d7872..4fa305c0e 100644
--- a/core/vm/gas_table_test.go
+++ b/core/vm/gas_table_test.go
@@ -20,6 +20,7 @@ import (
 	"github.com/truechain/truechain-engineering-code/etruedb"
 	"math"
 	"math/big"
+
 	"testing"
 
 	"github.com/truechain/truechain-engineering-code/common"
@@ -87,13 +88,13 @@ func TestEIP2200(t *testing.T) {
 		statedb.SetState(address, common.Hash{}, common.BytesToHash([]byte{tt.original}))
 		statedb.Finalise(true) // Push the state into the "original" slot
 
-		vmctx := Context{
+		vmctx := BlockContext{
 			CanTransfer: func(StateDB, common.Address, *big.Int) bool { return true },
 			Transfer:    func(StateDB, common.Address, common.Address, *big.Int) {},
 		}
-		vmenv := NewEVM(vmctx, statedb, params.TestChainConfig, Config{ExtraEips: []int{2200}})
+		vmenv := NewEVM(vmctx, TxContext{}, statedb, params.TestChainConfig, Config{ExtraEips: []int{2200}})
 
-		_, gas, err := vmenv.Call(AccountRef(common.Address{}), address, nil, tt.gaspool, new(big.Int), new(big.Int))
+		_, gas, err := vmenv.Call(AccountRef(common.Address{}), address, nil, tt.gaspool, new(big.Int), nil)
 		if err != tt.failure {
 			t.Errorf("test %d: failure mismatch: have %v, want %v", i, err, tt.failure)
 		}
diff --git a/core/vm/gen_structlog.go b/core/vm/gen_structlog.go
index cd92f16ec..a873e459d 100644
--- a/core/vm/gen_structlog.go
+++ b/core/vm/gen_structlog.go
@@ -4,8 +4,8 @@ package vm
 
 import (
 	"encoding/json"
-	"math/big"
 
+	"github.com/holiman/uint256"
 	"github.com/truechain/truechain-engineering-code/common"
 	"github.com/truechain/truechain-engineering-code/common/hexutil"
 	"github.com/truechain/truechain-engineering-code/common/math"
@@ -22,7 +22,7 @@ func (s StructLog) MarshalJSON() ([]byte, error) {
 		GasCost       math.HexOrDecimal64         `json:"gasCost"`
 		Memory        hexutil.Bytes               `json:"memory"`
 		MemorySize    int                         `json:"memSize"`
-		Stack         []*math.HexOrDecimal256     `json:"stack"`
+		Stack         []uint256.Int               `json:"stack"`
 		ReturnData    hexutil.Bytes               `json:"returnData"`
 		Storage       map[common.Hash]common.Hash `json:"-"`
 		Depth         int                         `json:"depth"`
@@ -38,12 +38,7 @@ func (s StructLog) MarshalJSON() ([]byte, error) {
 	enc.GasCost = math.HexOrDecimal64(s.GasCost)
 	enc.Memory = s.Memory
 	enc.MemorySize = s.MemorySize
-	if s.Stack != nil {
-		enc.Stack = make([]*math.HexOrDecimal256, len(s.Stack))
-		for k, v := range s.Stack {
-			enc.Stack[k] = (*math.HexOrDecimal256)(v)
-		}
-	}
+	enc.Stack = s.Stack
 	enc.ReturnData = s.ReturnData
 	enc.Storage = s.Storage
 	enc.Depth = s.Depth
@@ -63,7 +58,7 @@ func (s *StructLog) UnmarshalJSON(input []byte) error {
 		GasCost       *math.HexOrDecimal64        `json:"gasCost"`
 		Memory        *hexutil.Bytes              `json:"memory"`
 		MemorySize    *int                        `json:"memSize"`
-		Stack         []*math.HexOrDecimal256     `json:"stack"`
+		Stack         []uint256.Int               `json:"stack"`
 		ReturnData    *hexutil.Bytes              `json:"returnData"`
 		Storage       map[common.Hash]common.Hash `json:"-"`
 		Depth         *int                        `json:"depth"`
@@ -93,10 +88,7 @@ func (s *StructLog) UnmarshalJSON(input []byte) error {
 		s.MemorySize = *dec.MemorySize
 	}
 	if dec.Stack != nil {
-		s.Stack = make([]*big.Int, len(dec.Stack))
-		for k, v := range dec.Stack {
-			s.Stack[k] = (*big.Int)(v)
-		}
+		s.Stack = dec.Stack
 	}
 	if dec.ReturnData != nil {
 		s.ReturnData = *dec.ReturnData
diff --git a/core/vm/instructions.go b/core/vm/instructions.go
index 13ae91bb8..f4ff9402e 100644
--- a/core/vm/instructions.go
+++ b/core/vm/instructions.go
@@ -667,6 +667,7 @@ func opCall(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byt
 	}
 	stack.push(&temp)
 	if err == nil || err == ErrExecutionReverted {
+		ret = common.CopyBytes(ret)
 		scope.Memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
 	}
 	scope.Contract.Gas += returnGas
@@ -701,6 +702,7 @@ func opCallCode(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([
 	}
 	stack.push(&temp)
 	if err == nil || err == ErrExecutionReverted {
+		ret = common.CopyBytes(ret)
 		scope.Memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
 	}
 	scope.Contract.Gas += returnGas
@@ -728,6 +730,7 @@ func opDelegateCall(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext
 	}
 	stack.push(&temp)
 	if err == nil || err == ErrExecutionReverted {
+		ret = common.CopyBytes(ret)
 		scope.Memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
 	}
 	scope.Contract.Gas += returnGas
@@ -755,6 +758,7 @@ func opStaticCall(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext)
 	}
 	stack.push(&temp)
 	if err == nil || err == ErrExecutionReverted {
+		ret = common.CopyBytes(ret)
 		scope.Memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
 	}
 	scope.Contract.Gas += returnGas
@@ -783,11 +787,8 @@ func opStop(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byt
 func opSuicide(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
 	beneficiary := scope.Stack.pop()
 	balance := interpreter.evm.StateDB.GetBalance(scope.Contract.Address())
-	addr := beneficiary.Bytes20()
-	if interpreter.evm.StateDB.GetPOSLocked(scope.Contract.Address()).Cmp(common.Big0) == 0 {
-		interpreter.evm.StateDB.AddBalance(addr, balance)
-		interpreter.evm.StateDB.Suicide(scope.Contract.Address())
-	}
+	interpreter.evm.StateDB.AddBalance(beneficiary.Bytes20(), balance)
+	interpreter.evm.StateDB.Suicide(scope.Contract.Address())
 	return nil, nil
 }
 
diff --git a/core/vm/interpreter.go b/core/vm/interpreter.go
index b683716bd..28fea23be 100644
--- a/core/vm/interpreter.go
+++ b/core/vm/interpreter.go
@@ -34,9 +34,6 @@ type Config struct {
 
 	JumpTable [256]*operation // EVM instruction table, automatically populated if unset
 
-	EWASMInterpreter string // External EWASM interpreter options
-	EVMInterpreter   string // External EVM interpreter options
-
 	ExtraEips []int // Additional EIPS that are to be enabled
 }
 
@@ -272,7 +269,7 @@ func (in *EVMInterpreter) Run(contract *Contract, input []byte, readOnly bool) (
 		// if the operation clears the return data (e.g. it has returning data)
 		// set the last return to the result of the operation.
 		if operation.returns {
-			in.returnData = common.CopyBytes(res)
+			in.returnData = res
 		}
 
 		switch {
diff --git a/core/vm/jump_table.go b/core/vm/jump_table.go
index 8d16545c2..27a4411f1 100644
--- a/core/vm/jump_table.go
+++ b/core/vm/jump_table.go
@@ -49,8 +49,14 @@ type operation struct {
 }
 
 var (
-	constantinopleInstructionSet = newConstantinopleInstructionSet()
-	berlinInstructionSet         = newBerlinInstructionSet()
+	constantinopleInstructionSet   = newConstantinopleInstructionSet()
+	berlinInstructionSet           = newBerlinInstructionSet()
+	frontierInstructionSet         = newFrontierInstructionSet()
+	homesteadInstructionSet        = newHomesteadInstructionSet()
+	tangerineWhistleInstructionSet = newTangerineWhistleInstructionSet()
+	spuriousDragonInstructionSet   = newSpuriousDragonInstructionSet()
+	byzantiumInstructionSet        = newByzantiumInstructionSet()
+	istanbulInstructionSet         = newIstanbulInstructionSet()
 )
 
 // JumpTable contains the EVM opcodes supported at a given fork.
@@ -64,8 +70,8 @@ func newBerlinInstructionSet() JumpTable {
 	return instructionSet
 }
 
-// newIstanbulInstructionSet returns the frontier, homestead
-// byzantium, contantinople and petersburg instructions.
+// newIstanbulInstructionSet returns the frontier, homestead, byzantium,
+// contantinople, istanbul and petersburg instructions.
 func newIstanbulInstructionSet() JumpTable {
 	instructionSet := newConstantinopleInstructionSet()
 
@@ -76,7 +82,7 @@ func newIstanbulInstructionSet() JumpTable {
 	return instructionSet
 }
 
-// newConstantinopleInstructionSet returns the frontier, homestead
+// newConstantinopleInstructionSet returns the frontier, homestead,
 // byzantium and contantinople instructions.
 func newConstantinopleInstructionSet() JumpTable {
 	instructionSet := newByzantiumInstructionSet()
@@ -100,7 +106,7 @@ func newConstantinopleInstructionSet() JumpTable {
 	}
 	instructionSet[EXTCODEHASH] = &operation{
 		execute:     opExtCodeHash,
-		constantGas: params.ExtcodeHashGas,
+		constantGas: params.ExtcodeHashGasConstantinople,
 		minStack:    minStack(1, 1),
 		maxStack:    maxStack(1, 1),
 	}
@@ -159,7 +165,7 @@ func newByzantiumInstructionSet() JumpTable {
 // EIP 158 a.k.a Spurious Dragon
 func newSpuriousDragonInstructionSet() JumpTable {
 	instructionSet := newTangerineWhistleInstructionSet()
-	instructionSet[EXP].dynamicGas = gasExp
+	instructionSet[EXP].dynamicGas = gasExpEIP158
 	return instructionSet
 
 }
@@ -184,7 +190,7 @@ func newHomesteadInstructionSet() JumpTable {
 	instructionSet[DELEGATECALL] = &operation{
 		execute:     opDelegateCall,
 		dynamicGas:  gasDelegateCall,
-		constantGas: params.CallGas,
+		constantGas: params.CallGasFrontier,
 		minStack:    minStack(6, 1),
 		maxStack:    maxStack(6, 1),
 		memorySize:  memoryDelegateCall,
@@ -260,7 +266,7 @@ func newFrontierInstructionSet() JumpTable {
 		},
 		EXP: {
 			execute:    opExp,
-			dynamicGas: gasExp,
+			dynamicGas: gasExpFrontier,
 			minStack:   minStack(2, 1),
 			maxStack:   maxStack(2, 1),
 		},
@@ -352,7 +358,7 @@ func newFrontierInstructionSet() JumpTable {
 		},
 		BALANCE: {
 			execute:     opBalance,
-			constantGas: params.BalanceGas,
+			constantGas: params.BalanceGasFrontier,
 			minStack:    minStack(1, 1),
 			maxStack:    maxStack(1, 1),
 		},
@@ -416,13 +422,13 @@ func newFrontierInstructionSet() JumpTable {
 		},
 		EXTCODESIZE: {
 			execute:     opExtCodeSize,
-			constantGas: params.ExtcodeSizeGas,
+			constantGas: params.ExtcodeSizeGasFrontier,
 			minStack:    minStack(1, 1),
 			maxStack:    maxStack(1, 1),
 		},
 		EXTCODECOPY: {
 			execute:     opExtCodeCopy,
-			constantGas: params.ExtcodeCopyBase,
+			constantGas: params.ExtcodeCopyBaseFrontier,
 			dynamicGas:  gasExtCodeCopy,
 			minStack:    minStack(4, 0),
 			maxStack:    maxStack(4, 0),
@@ -496,7 +502,7 @@ func newFrontierInstructionSet() JumpTable {
 		},
 		SLOAD: {
 			execute:     opSload,
-			constantGas: params.SloadGas,
+			constantGas: params.SloadGasFrontier,
 			minStack:    minStack(1, 1),
 			maxStack:    maxStack(1, 1),
 		},
@@ -981,7 +987,7 @@ func newFrontierInstructionSet() JumpTable {
 		},
 		CALL: {
 			execute:     opCall,
-			constantGas: params.CallGas,
+			constantGas: params.CallGasFrontier,
 			dynamicGas:  gasCall,
 			minStack:    minStack(7, 1),
 			maxStack:    maxStack(7, 1),
@@ -990,7 +996,7 @@ func newFrontierInstructionSet() JumpTable {
 		},
 		CALLCODE: {
 			execute:     opCallCode,
-			constantGas: params.CallGas,
+			constantGas: params.CallGasFrontier,
 			dynamicGas:  gasCallCode,
 			minStack:    minStack(7, 1),
 			maxStack:    maxStack(7, 1),
diff --git a/core/vm/logger.go b/core/vm/logger.go
index 1aac48ce2..a3261e892 100644
--- a/core/vm/logger.go
+++ b/core/vm/logger.go
@@ -19,6 +19,7 @@ package vm
 import (
 	"encoding/hex"
 	"fmt"
+	"github.com/holiman/uint256"
 	"io"
 	"math/big"
 	"strings"
@@ -65,7 +66,7 @@ type StructLog struct {
 	GasCost       uint64                      `json:"gasCost"`
 	Memory        []byte                      `json:"memory"`
 	MemorySize    int                         `json:"memSize"`
-	Stack         []*big.Int                  `json:"stack"`
+	Stack         []uint256.Int               `json:"stack"`
 	ReturnData    []byte                      `json:"returnData"`
 	Storage       map[common.Hash]common.Hash `json:"-"`
 	Depth         int                         `json:"depth"`
@@ -75,7 +76,6 @@ type StructLog struct {
 
 // overrides for gencodec
 type structLogMarshaling struct {
-	Stack       []*math.HexOrDecimal256
 	Gas         math.HexOrDecimal64
 	GasCost     math.HexOrDecimal64
 	Memory      hexutil.Bytes
@@ -134,6 +134,14 @@ func NewStructLogger(cfg *LogConfig) *StructLogger {
 	return logger
 }
 
+// Reset clears the data held by the logger.
+func (l *StructLogger) Reset() {
+	l.storage = make(map[common.Address]Storage)
+	l.output = make([]byte, 0)
+	l.logs = l.logs[:0]
+	l.err = nil
+}
+
 // CaptureStart implements the Tracer interface to initialize the tracing operation.
 func (l *StructLogger) CaptureStart(env *EVM, from common.Address, to common.Address, create bool, input []byte, gas uint64, value *big.Int) {
 }
@@ -156,16 +164,16 @@ func (l *StructLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost ui
 		copy(mem, memory.Data())
 	}
 	// Copy a snapshot of the current stack state to a new buffer
-	var stck []*big.Int
+	var stck []uint256.Int
 	if !l.cfg.DisableStack {
-		stck = make([]*big.Int, len(stack.Data()))
+		stck = make([]uint256.Int, len(stack.Data()))
 		for i, item := range stack.Data() {
-			stck[i] = new(big.Int).Set(item.ToBig())
+			stck[i] = item
 		}
 	}
 	// Copy a snapshot of the current storage to a new container
 	var storage Storage
-	if !l.cfg.DisableStorage {
+	if !l.cfg.DisableStorage && (op == SLOAD || op == SSTORE) {
 		// initialise new changed values storage container for this contract
 		// if not present.
 		if l.storage[contract.Address()] == nil {
@@ -178,16 +186,16 @@ func (l *StructLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost ui
 				value   = env.StateDB.GetState(contract.Address(), address)
 			)
 			l.storage[contract.Address()][address] = value
-		}
-		// capture SSTORE opcodes and record the written entry in the local storage.
-		if op == SSTORE && stack.len() >= 2 {
+			storage = l.storage[contract.Address()].Copy()
+		} else if op == SSTORE && stack.len() >= 2 {
+			// capture SSTORE opcodes and record the written entry in the local storage.
 			var (
 				value   = common.Hash(stack.data[stack.len()-2].Bytes32())
 				address = common.Hash(stack.data[stack.len()-1].Bytes32())
 			)
 			l.storage[contract.Address()][address] = value
+			storage = l.storage[contract.Address()].Copy()
 		}
-		storage = l.storage[contract.Address()].Copy()
 	}
 	var rdata []byte
 	if !l.cfg.DisableReturnData {
@@ -196,7 +204,6 @@ func (l *StructLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost ui
 	}
 	// create a new snapshot of the EVM.
 	log := StructLog{pc, op, gas, cost, mem, memory.Len(), stck, rdata, storage, depth, env.StateDB.GetRefund(), err}
-
 	l.logs = append(l.logs, log)
 }
 
@@ -226,6 +233,39 @@ func (l *StructLogger) Error() error { return l.err }
 // Output returns the VM return value captured by the trace.
 func (l *StructLogger) Output() []byte { return l.output }
 
+// WriteTrace writes a formatted trace to the given writer
+func WriteTrace(writer io.Writer, logs []StructLog) {
+	for _, log := range logs {
+		fmt.Fprintf(writer, "%-16spc=%08d gas=%v cost=%v", log.Op, log.Pc, log.Gas, log.GasCost)
+		if log.Err != nil {
+			fmt.Fprintf(writer, " ERROR: %v", log.Err)
+		}
+		fmt.Fprintln(writer)
+
+		if len(log.Stack) > 0 {
+			fmt.Fprintln(writer, "Stack:")
+			for i := len(log.Stack) - 1; i >= 0; i-- {
+				fmt.Fprintf(writer, "%08d  %s\n", len(log.Stack)-i-1, log.Stack[i].Hex())
+			}
+		}
+		if len(log.Memory) > 0 {
+			fmt.Fprintln(writer, "Memory:")
+			fmt.Fprint(writer, hex.Dump(log.Memory))
+		}
+		if len(log.Storage) > 0 {
+			fmt.Fprintln(writer, "Storage:")
+			for h, item := range log.Storage {
+				fmt.Fprintf(writer, "%x: %x\n", h, item)
+			}
+		}
+		if len(log.ReturnData) > 0 {
+			fmt.Fprintln(writer, "ReturnData:")
+			fmt.Fprint(writer, hex.Dump(log.ReturnData))
+		}
+		fmt.Fprintln(writer)
+	}
+}
+
 // WriteLogs writes vm logs in a readable format to the given writer
 func WriteLogs(writer io.Writer, logs []*types.Log) {
 	for _, log := range logs {
@@ -281,7 +321,7 @@ func (t *mdLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64
 		// format stack
 		var a []string
 		for _, elem := range stack.data {
-			a = append(a, fmt.Sprintf("%v", elem.String()))
+			a = append(a, elem.Hex())
 		}
 		b := fmt.Sprintf("[%v]", strings.Join(a, ","))
 		fmt.Fprintf(t.out, "%10v |", b)
diff --git a/core/vm/logger_json.go b/core/vm/logger_json.go
index aeb007f1c..60a546de3 100644
--- a/core/vm/logger_json.go
+++ b/core/vm/logger_json.go
@@ -66,12 +66,7 @@ func (l *JSONLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint
 		log.Memory = memory.Data()
 	}
 	if !l.cfg.DisableStack {
-		//TODO(@holiman) improve this
-		logstack := make([]*big.Int, len(stack.Data()))
-		for i, item := range stack.Data() {
-			logstack[i] = item.ToBig()
-		}
-		log.Stack = logstack
+		log.Stack = stack.data
 	}
 	if !l.cfg.DisableReturnData {
 		log.ReturnData = rData
@@ -87,8 +82,9 @@ func (l *JSONLogger) CaptureEnd(output []byte, gasUsed uint64, t time.Duration,
 		Time    time.Duration       `json:"time"`
 		Err     string              `json:"error,omitempty"`
 	}
+	var errMsg string
 	if err != nil {
-		l.encoder.Encode(endLog{common.Bytes2Hex(output), math.HexOrDecimal64(gasUsed), t, err.Error()})
+		errMsg = err.Error()
 	}
-	l.encoder.Encode(endLog{common.Bytes2Hex(output), math.HexOrDecimal64(gasUsed), t, ""})
+	l.encoder.Encode(endLog{common.Bytes2Hex(output), math.HexOrDecimal64(gasUsed), t, errMsg})
 }
diff --git a/core/vm/logger_test.go b/core/vm/logger_test.go
index 02766199d..ab243a4c9 100644
--- a/core/vm/logger_test.go
+++ b/core/vm/logger_test.go
@@ -51,19 +51,22 @@ func (*dummyStatedb) GetRefund() uint64 { return 1337 }
 
 func TestStoreCapture(t *testing.T) {
 	var (
-		env      = NewEVM(Context{}, &dummyStatedb{}, params.TestChainConfig, Config{})
+		env      = NewEVM(BlockContext{}, TxContext{}, &dummyStatedb{}, params.TestChainConfig, Config{})
 		logger   = NewStructLogger(nil)
-		mem      = NewMemory()
-		stack    = newstack()
-		rstack   = newReturnStack()
 		contract = NewContract(&dummyContractRef{}, &dummyContractRef{}, new(big.Int), 0)
+		scope    = &ScopeContext{
+			Memory:   NewMemory(),
+			Stack:    newstack(),
+			Contract: contract,
+		}
 	)
-	stack.push(uint256.NewInt().SetUint64(1))
-	stack.push(uint256.NewInt())
+	scope.Stack.push(uint256.NewInt(1))
+	scope.Stack.push(new(uint256.Int))
 	var index common.Hash
-	logger.CaptureState(env, 0, SSTORE, 0, 0, mem, stack, rstack, nil, contract, 0, nil)
+	logger.CaptureState(env, 0, SSTORE, 0, 0, scope, nil, 0, nil)
 	if len(logger.storage[contract.Address()]) == 0 {
-		t.Fatalf("expected exactly 1 changed value on address %x, got %d", contract.Address(), len(logger.storage[contract.Address()]))
+		t.Fatalf("expected exactly 1 changed value on address %x, got %d", contract.Address(),
+			len(logger.storage[contract.Address()]))
 	}
 	exp := common.BigToHash(big.NewInt(1))
 	if logger.storage[contract.Address()][index] != exp {
diff --git a/core/vm/opcodes.go b/core/vm/opcodes.go
index b0adf37d0..286307ae9 100644
--- a/core/vm/opcodes.go
+++ b/core/vm/opcodes.go
@@ -103,6 +103,7 @@ const (
 	GASLIMIT
 	CHAINID     OpCode = 0x46
 	SELFBALANCE OpCode = 0x47
+	BASEFEE     OpCode = 0x48
 )
 
 // 0x50 range - 'storage' and execution.
@@ -280,6 +281,7 @@ var opCodeToString = map[OpCode]string{
 	GASLIMIT:    "GASLIMIT",
 	CHAINID:     "CHAINID",
 	SELFBALANCE: "SELFBALANCE",
+	BASEFEE:     "BASEFEE",
 
 	// 0x50 range - 'storage' and execution.
 	POP: "POP",
@@ -432,6 +434,7 @@ var stringToOp = map[string]OpCode{
 	"CALLDATASIZE":   CALLDATASIZE,
 	"CALLDATACOPY":   CALLDATACOPY,
 	"CHAINID":        CHAINID,
+	"BASEFEE":        BASEFEE,
 	"DELEGATECALL":   DELEGATECALL,
 	"STATICCALL":     STATICCALL,
 	"CODESIZE":       CODESIZE,
diff --git a/core/vm/operations_acl.go b/core/vm/operations_acl.go
index 886ba81ce..9e290def7 100644
--- a/core/vm/operations_acl.go
+++ b/core/vm/operations_acl.go
@@ -24,91 +24,75 @@ import (
 	"github.com/truechain/truechain-engineering-code/params"
 )
 
-const (
-	ColdAccountAccessCostEIP2929 = uint64(2600) // COLD_ACCOUNT_ACCESS_COST
-	ColdSloadCostEIP2929         = uint64(2100) // COLD_SLOAD_COST
-	WarmStorageReadCostEIP2929   = uint64(100)  // WARM_STORAGE_READ_COST
-)
-
-// gasSStoreEIP2929 implements gas cost for SSTORE according to EIP-2929
-//
-// When calling SSTORE, check if the (address, storage_key) pair is in accessed_storage_keys.
-// If it is not, charge an additional COLD_SLOAD_COST gas, and add the pair to accessed_storage_keys.
-// Additionally, modify the parameters defined in EIP 2200 as follows:
-//
-// Parameter 	Old value 	New value
-// SLOAD_GAS 	800 	= WARM_STORAGE_READ_COST
-// SSTORE_RESET_GAS 	5000 	5000 - COLD_SLOAD_COST
-//
-//The other parameters defined in EIP 2200 are unchanged.
-// see gasSStoreEIP2200(...) in core/vm/gas_table.go for more info about how EIP 2200 is specified
-func gasSStoreEIP2929(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) {
-	// If we fail the minimum gas availability invariant, fail (0)
-	if contract.Gas <= params.SstoreSentryGasEIP2200 {
-		return 0, errors.New("not enough gas for reentrancy sentry")
-	}
-	// Gas sentry honoured, do the actual gas calculation based on the stored value
-	var (
-		y, x    = stack.Back(1), stack.peek()
-		slot    = common.Hash(x.Bytes32())
-		current = evm.StateDB.GetState(contract.Address(), slot)
-		cost    = uint64(0)
-	)
-	// Check slot presence in the access list
-	if addrPresent, slotPresent := evm.StateDB.SlotInAccessList(contract.Address(), slot); !slotPresent {
-		cost = ColdSloadCostEIP2929
-		// If the caller cannot afford the cost, this change will be rolled back
-		evm.StateDB.AddSlotToAccessList(contract.Address(), slot)
-		if !addrPresent {
-			// Once we're done with YOLOv2 and schedule this for mainnet, might
-			// be good to remove this panic here, which is just really a
-			// canary to have during testing
-			panic("impossible case: address was not present in access list during sstore op")
+func makeGasSStoreFunc(clearingRefund uint64) gasFunc {
+	return func(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) {
+		// If we fail the minimum gas availability invariant, fail (0)
+		if contract.Gas <= params.SstoreSentryGasEIP2200 {
+			return 0, errors.New("not enough gas for reentrancy sentry")
 		}
-	}
-	value := common.Hash(y.Bytes32())
+		// Gas sentry honoured, do the actual gas calculation based on the stored value
+		var (
+			y, x    = stack.Back(1), stack.peek()
+			slot    = common.Hash(x.Bytes32())
+			current = evm.StateDB.GetState(contract.Address(), slot)
+			cost    = uint64(0)
+		)
+		// Check slot presence in the access list
+		if addrPresent, slotPresent := evm.StateDB.SlotInAccessList(contract.Address(), slot); !slotPresent {
+			cost = params.ColdSloadCostEIP2929
+			// If the caller cannot afford the cost, this change will be rolled back
+			evm.StateDB.AddSlotToAccessList(contract.Address(), slot)
+			if !addrPresent {
+				// Once we're done with YOLOv2 and schedule this for mainnet, might
+				// be good to remove this panic here, which is just really a
+				// canary to have during testing
+				panic("impossible case: address was not present in access list during sstore op")
+			}
+		}
+		value := common.Hash(y.Bytes32())
 
-	if current == value { // noop (1)
-		// EIP 2200 original clause:
-		//		return params.SloadGasEIP2200, nil
-		return cost + WarmStorageReadCostEIP2929, nil // SLOAD_GAS
-	}
-	original := evm.StateDB.GetCommittedState(contract.Address(), x.Bytes32())
-	if original == current {
-		if original == (common.Hash{}) { // create slot (2.1.1)
-			return cost + params.SstoreSetGasEIP2200, nil
+		if current == value { // noop (1)
+			// EIP 2200 original clause:
+			//		return params.SloadGasEIP2200, nil
+			return cost + params.WarmStorageReadCostEIP2929, nil // SLOAD_GAS
 		}
-		if value == (common.Hash{}) { // delete slot (2.1.2b)
-			evm.StateDB.AddRefund(params.SstoreClearsScheduleRefundEIP2200)
+		original := evm.StateDB.GetCommittedState(contract.Address(), x.Bytes32())
+		if original == current {
+			if original == (common.Hash{}) { // create slot (2.1.1)
+				return cost + params.SstoreSetGasEIP2200, nil
+			}
+			if value == (common.Hash{}) { // delete slot (2.1.2b)
+				evm.StateDB.AddRefund(clearingRefund)
+			}
+			// EIP-2200 original clause:
+			//		return params.SstoreResetGasEIP2200, nil // write existing slot (2.1.2)
+			return cost + (params.SstoreResetGasEIP2200 - params.ColdSloadCostEIP2929), nil // write existing slot (2.1.2)
 		}
-		// EIP-2200 original clause:
-		//		return params.SstoreResetGasEIP2200, nil // write existing slot (2.1.2)
-		return cost + (params.SstoreResetGasEIP2200 - ColdSloadCostEIP2929), nil // write existing slot (2.1.2)
-	}
-	if original != (common.Hash{}) {
-		if current == (common.Hash{}) { // recreate slot (2.2.1.1)
-			evm.StateDB.SubRefund(params.SstoreClearsScheduleRefundEIP2200)
-		} else if value == (common.Hash{}) { // delete slot (2.2.1.2)
-			evm.StateDB.AddRefund(params.SstoreClearsScheduleRefundEIP2200)
+		if original != (common.Hash{}) {
+			if current == (common.Hash{}) { // recreate slot (2.2.1.1)
+				evm.StateDB.SubRefund(clearingRefund)
+			} else if value == (common.Hash{}) { // delete slot (2.2.1.2)
+				evm.StateDB.AddRefund(clearingRefund)
+			}
 		}
-	}
-	if original == value {
-		if original == (common.Hash{}) { // reset to original inexistent slot (2.2.2.1)
-			// EIP 2200 Original clause:
-			//evm.StateDB.AddRefund(params.SstoreSetGasEIP2200 - params.SloadGasEIP2200)
-			evm.StateDB.AddRefund(params.SstoreSetGasEIP2200 - WarmStorageReadCostEIP2929)
-		} else { // reset to original existing slot (2.2.2.2)
-			// EIP 2200 Original clause:
-			//	evm.StateDB.AddRefund(params.SstoreResetGasEIP2200 - params.SloadGasEIP2200)
-			// - SSTORE_RESET_GAS redefined as (5000 - COLD_SLOAD_COST)
-			// - SLOAD_GAS redefined as WARM_STORAGE_READ_COST
-			// Final: (5000 - COLD_SLOAD_COST) - WARM_STORAGE_READ_COST
-			evm.StateDB.AddRefund((params.SstoreResetGasEIP2200 - ColdSloadCostEIP2929) - WarmStorageReadCostEIP2929)
+		if original == value {
+			if original == (common.Hash{}) { // reset to original inexistent slot (2.2.2.1)
+				// EIP 2200 Original clause:
+				//evm.StateDB.AddRefund(params.SstoreSetGasEIP2200 - params.SloadGasEIP2200)
+				evm.StateDB.AddRefund(params.SstoreSetGasEIP2200 - params.WarmStorageReadCostEIP2929)
+			} else { // reset to original existing slot (2.2.2.2)
+				// EIP 2200 Original clause:
+				//	evm.StateDB.AddRefund(params.SstoreResetGasEIP2200 - params.SloadGasEIP2200)
+				// - SSTORE_RESET_GAS redefined as (5000 - COLD_SLOAD_COST)
+				// - SLOAD_GAS redefined as WARM_STORAGE_READ_COST
+				// Final: (5000 - COLD_SLOAD_COST) - WARM_STORAGE_READ_COST
+				evm.StateDB.AddRefund((params.SstoreResetGasEIP2200 - params.ColdSloadCostEIP2929) - params.WarmStorageReadCostEIP2929)
+			}
 		}
+		// EIP-2200 original clause:
+		//return params.SloadGasEIP2200, nil // dirty update (2.2)
+		return cost + params.WarmStorageReadCostEIP2929, nil // dirty update (2.2)
 	}
-	// EIP-2200 original clause:
-	//return params.SloadGasEIP2200, nil // dirty update (2.2)
-	return cost + WarmStorageReadCostEIP2929, nil // dirty update (2.2)
 }
 
 // gasSLoadEIP2929 calculates dynamic gas for SLOAD according to EIP-2929
@@ -124,9 +108,9 @@ func gasSLoadEIP2929(evm *EVM, contract *Contract, stack *Stack, mem *Memory, me
 		// If the caller cannot afford the cost, this change will be rolled back
 		// If he does afford it, we can skip checking the same thing later on, during execution
 		evm.StateDB.AddSlotToAccessList(contract.Address(), slot)
-		return ColdSloadCostEIP2929, nil
+		return params.ColdSloadCostEIP2929, nil
 	}
-	return WarmStorageReadCostEIP2929, nil
+	return params.WarmStorageReadCostEIP2929, nil
 }
 
 // gasExtCodeCopyEIP2929 implements extcodecopy according to EIP-2929
@@ -146,7 +130,7 @@ func gasExtCodeCopyEIP2929(evm *EVM, contract *Contract, stack *Stack, mem *Memo
 		evm.StateDB.AddAddressToAccessList(addr)
 		var overflow bool
 		// We charge (cold-warm), since 'warm' is already charged as constantGas
-		if gas, overflow = math.SafeAdd(gas, ColdAccountAccessCostEIP2929-WarmStorageReadCostEIP2929); overflow {
+		if gas, overflow = math.SafeAdd(gas, params.ColdAccountAccessCostEIP2929-params.WarmStorageReadCostEIP2929); overflow {
 			return 0, ErrGasUintOverflow
 		}
 		return gas, nil
@@ -168,7 +152,7 @@ func gasEip2929AccountCheck(evm *EVM, contract *Contract, stack *Stack, mem *Mem
 		// If the caller cannot afford the cost, this change will be rolled back
 		evm.StateDB.AddAddressToAccessList(addr)
 		// The warm storage read cost is already charged as constantGas
-		return ColdAccountAccessCostEIP2929 - WarmStorageReadCostEIP2929, nil
+		return params.ColdAccountAccessCostEIP2929 - params.WarmStorageReadCostEIP2929, nil
 	}
 	return 0, nil
 }
@@ -180,7 +164,7 @@ func makeCallVariantGasCallEIP2929(oldCalculator gasFunc) gasFunc {
 		warmAccess := evm.StateDB.AddressInAccessList(addr)
 		// The WarmStorageReadCostEIP2929 (100) is already deducted in the form of a constant cost, so
 		// the cost to charge for cold access, if any, is Cold - Warm
-		coldCost := ColdAccountAccessCostEIP2929 - WarmStorageReadCostEIP2929
+		coldCost := params.ColdAccountAccessCostEIP2929 - params.WarmStorageReadCostEIP2929
 		if !warmAccess {
 			evm.StateDB.AddAddressToAccessList(addr)
 			// Charge the remaining difference here already, to correctly calculate available
@@ -212,25 +196,49 @@ var (
 	gasDelegateCallEIP2929 = makeCallVariantGasCallEIP2929(gasDelegateCall)
 	gasStaticCallEIP2929   = makeCallVariantGasCallEIP2929(gasStaticCall)
 	gasCallCodeEIP2929     = makeCallVariantGasCallEIP2929(gasCallCode)
+	gasSelfdestructEIP2929 = makeSelfdestructGasFn(true)
+	// gasSelfdestructEIP3529 implements the changes in EIP-2539 (no refunds)
+	gasSelfdestructEIP3529 = makeSelfdestructGasFn(false)
+
+	// gasSStoreEIP2929 implements gas cost for SSTORE according to EIP-2929
+	//
+	// When calling SSTORE, check if the (address, storage_key) pair is in accessed_storage_keys.
+	// If it is not, charge an additional COLD_SLOAD_COST gas, and add the pair to accessed_storage_keys.
+	// Additionally, modify the parameters defined in EIP 2200 as follows:
+	//
+	// Parameter 	Old value 	New value
+	// SLOAD_GAS 	800 	= WARM_STORAGE_READ_COST
+	// SSTORE_RESET_GAS 	5000 	5000 - COLD_SLOAD_COST
+	//
+	//The other parameters defined in EIP 2200 are unchanged.
+	// see gasSStoreEIP2200(...) in core/vm/gas_table.go for more info about how EIP 2200 is specified
+	gasSStoreEIP2929 = makeGasSStoreFunc(params.SstoreClearsScheduleRefundEIP2200)
+
+	// gasSStoreEIP2539 implements gas cost for SSTORE according to EPI-2539
+	// Replace `SSTORE_CLEARS_SCHEDULE` with `SSTORE_RESET_GAS + ACCESS_LIST_STORAGE_KEY_COST` (4,800)
+	gasSStoreEIP3529 = makeGasSStoreFunc(params.SstoreClearsScheduleRefundEIP3529)
 )
 
-func gasSelfdestructEIP2929(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) {
-	var (
-		gas     uint64
-		address = common.Address(stack.peek().Bytes20())
-	)
-	if !evm.StateDB.AddressInAccessList(address) {
-		// If the caller cannot afford the cost, this change will be rolled back
-		evm.StateDB.AddAddressToAccessList(address)
-		gas = ColdAccountAccessCostEIP2929
-	}
-	// if empty and transfers value
-	if evm.StateDB.Empty(address) && evm.StateDB.GetBalance(contract.Address()).Sign() != 0 {
-		gas += params.CreateBySelfdestructGas
-	}
-	if !evm.StateDB.HasSuicided(contract.Address()) {
-		evm.StateDB.AddRefund(params.SelfdestructRefundGas)
+// makeSelfdestructGasFn can create the selfdestruct dynamic gas function for EIP-2929 and EIP-2539
+func makeSelfdestructGasFn(refundsEnabled bool) gasFunc {
+	gasFunc := func(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) {
+		var (
+			gas     uint64
+			address = common.Address(stack.peek().Bytes20())
+		)
+		if !evm.StateDB.AddressInAccessList(address) {
+			// If the caller cannot afford the cost, this change will be rolled back
+			evm.StateDB.AddAddressToAccessList(address)
+			gas = params.ColdAccountAccessCostEIP2929
+		}
+		// if empty and transfers value
+		if evm.StateDB.Empty(address) && evm.StateDB.GetBalance(contract.Address()).Sign() != 0 {
+			gas += params.CreateBySelfdestructGas
+		}
+		if refundsEnabled && !evm.StateDB.HasSuicided(contract.Address()) {
+			evm.StateDB.AddRefund(params.SelfdestructRefundGas)
+		}
+		return gas, nil
 	}
-	return gas, nil
-
+	return gasFunc
 }
diff --git a/core/vm/staking.go b/core/vm/staking.go
index d4ffb4b16..69847b3d8 100644
--- a/core/vm/staking.go
+++ b/core/vm/staking.go
@@ -107,7 +107,7 @@ func RunStaking(evm *EVM, contract *Contract, input []byte) (ret []byte, err err
 	}
 
 	if err != nil {
-		log.Warn("Staking error code", "code", err)
+		log.Warn("Staking error code", "code", err, "method.Name", method.Name)
 		err = ErrExecutionReverted
 	}
 
@@ -145,12 +145,15 @@ func deposit(evm *EVM, contract *Contract, input []byte) (ret []byte, err error)
 	}{}
 	method, _ := abiStaking.Methods["deposit"]
 
-	err = method.Inputs.Unpack(&args, input)
+	unpacked, err := method.Inputs.Unpack(input)
 	if err != nil {
 		log.Error("Unpack deposit pubkey error", "err", err)
 		return nil, ErrStakingInvalidInput
 	}
-
+	err = method.Inputs.Copy(&args, unpacked)
+	if err != nil {
+		return nil, err
+	}
 	from := contract.caller.Address()
 	if evm.StateDB.GetUnlockedBalance(from).Cmp(args.Value) < 0 {
 		log.Error("Staking balance insufficient", "address", contract.caller.Address(), "value", args.Value)
@@ -207,11 +210,15 @@ func depositAppend(evm *EVM, contract *Contract, input []byte) (ret []byte, err
 	amount := big.NewInt(0)
 
 	method, _ := abiStaking.Methods["append"]
-	err = method.Inputs.Unpack(&amount, input)
+	unpack, err := method.Inputs.Unpack(input)
 	if err != nil {
 		log.Error("Unpack append value error", "err", err)
 		return nil, ErrStakingInvalidInput
 	}
+	err = method.Inputs.Copy(&amount, unpack)
+	if err != nil {
+		return nil, err
+	}
 	if evm.StateDB.GetUnlockedBalance(from).Cmp(amount) < 0 {
 		log.Error("Staking balance insufficient", "address", contract.caller.Address(), "value", amount)
 		return nil, ErrStakingInsufficientBalance
@@ -256,12 +263,15 @@ func setFeeRate(evm *EVM, contract *Contract, input []byte) (ret []byte, err err
 	fee := big.NewInt(0)
 	method, _ := abiStaking.Methods["setFee"]
 
-	err = method.Inputs.Unpack(&fee, input)
+	unpack, err := method.Inputs.Unpack(input)
 	if err != nil {
 		log.Error("Unpack deposit pubkey error", "err", err)
 		return nil, ErrStakingInvalidInput
 	}
-
+	err = method.Inputs.Copy(&fee, unpack)
+	if err != nil {
+		return nil, err
+	}
 	from := contract.caller.Address()
 
 	log.Info("Staking set fee", "number", evm.Context.BlockNumber.Uint64(), "address", contract.caller.Address(), "fee", fee)
@@ -302,12 +312,16 @@ func setPubkey(evm *EVM, contract *Contract, input []byte) (ret []byte, err erro
 	var pubkey []byte
 
 	method, _ := abiStaking.Methods["setPubkey"]
-	err = method.Inputs.Unpack(&pubkey, input)
+
+	unpacked, err := method.Inputs.Unpack(input)
 	if err != nil {
 		log.Error("Unpack update pubkey error", "err", err)
 		return nil, ErrStakingInvalidInput
 	}
-
+	err = method.Inputs.Copy(&pubkey, unpacked)
+	if err != nil {
+		return nil, err
+	}
 	from := contract.caller.Address()
 
 	log.Info("Staking set pubkey", "number", evm.Context.BlockNumber.Uint64(), "address", contract.caller.Address(), "pk", pubkey)
@@ -353,11 +367,15 @@ func delegate(evm *EVM, contract *Contract, input []byte) (ret []byte, err error
 
 	t0 := time.Now()
 	method, _ := abiStaking.Methods["delegate"]
-	err = method.Inputs.Unpack(&args, input)
+	unpacked, err := method.Inputs.Unpack(input)
 	if err != nil {
 		log.Error("Unpack deposit pubkey error", "err", err)
 		return nil, ErrStakingInvalidInput
 	}
+	err = method.Inputs.Copy(&args, unpacked)
+	if err != nil {
+		return nil, err
+	}
 	from := contract.caller.Address()
 	if evm.StateDB.GetUnlockedBalance(from).Cmp(args.Value) < 0 {
 		log.Error("Staking balance insufficient", "address", contract.caller.Address(), "value", args.Value)
@@ -417,11 +435,15 @@ func undelegate(evm *EVM, contract *Contract, input []byte) (ret []byte, err err
 	}{}
 
 	method, _ := abiStaking.Methods["undelegate"]
-	err = method.Inputs.Unpack(&args, input)
+	unpacked, err := method.Inputs.Unpack(input)
 	if err != nil {
 		log.Error("Unpack undelegate error", "err", err)
 		return nil, ErrStakingInvalidInput
 	}
+	err = method.Inputs.Copy(&args, unpacked)
+	if err != nil {
+		return nil, err
+	}
 	from := contract.caller.Address()
 
 	log.Info("Staking undelegate", "number", evm.Context.BlockNumber.Uint64(), "address", contract.caller.Address(), "holder", args.Holder, "value", args.Value)
@@ -464,12 +486,15 @@ func cancel(evm *EVM, contract *Contract, input []byte) (ret []byte, err error)
 	amount := new(big.Int)
 
 	method, _ := abiStaking.Methods["cancel"]
-	err = method.Inputs.Unpack(&amount, input)
+	unpacked, err := method.Inputs.Unpack(input)
 	if err != nil {
 		log.Error("Unpack cancel input error")
 		return nil, ErrStakingInvalidInput
 	}
-
+	err = method.Inputs.Copy(&amount, unpacked)
+	if err != nil {
+		return nil, err
+	}
 	log.Info("Staking cancel", "number", evm.Context.BlockNumber.Uint64(), "address", contract.caller.Address(), "value", amount)
 	impawn := NewImpawnImpl()
 	err = impawn.Load(evm.StateDB, types.StakingAddress)
@@ -510,11 +535,15 @@ func withdraw(evm *EVM, contract *Contract, input []byte) (ret []byte, err error
 	amount := new(big.Int)
 
 	method, _ := abiStaking.Methods["withdraw"]
-	err = method.Inputs.Unpack(&amount, input)
+	unpacked, err := method.Inputs.Unpack(input)
 	if err != nil {
 		log.Error("Unpack withdraw input error")
 		return nil, ErrStakingInvalidInput
 	}
+	err = method.Inputs.Copy(&amount, unpacked)
+	if err != nil {
+		return nil, err
+	}
 	if evm.StateDB.GetPOSLocked(from).Cmp(amount) < 0 {
 		log.Error("Staking balance insufficient", "address", contract.caller.Address(), "value", amount)
 		return nil, ErrStakingInsufficientBalance
@@ -563,11 +592,15 @@ func withdrawDelegate(evm *EVM, contract *Contract, input []byte) (ret []byte, e
 	from := contract.caller.Address()
 
 	method, _ := abiStaking.Methods["withdrawDelegate"]
-	err = method.Inputs.Unpack(&args, input)
+	unpacked, err := method.Inputs.Unpack(input)
 	if err != nil {
 		log.Error("Unpack withdraw delegate input error")
 		return nil, ErrStakingInvalidInput
 	}
+	err = method.Inputs.Copy(&args, unpacked)
+	if err != nil {
+		return nil, err
+	}
 	if evm.StateDB.GetPOSLocked(from).Cmp(args.Value) < 0 {
 		log.Error("Staking balance insufficient", "address", contract.caller.Address(), "value", args.Value)
 		return nil, ErrStakingInsufficientBalance
@@ -614,12 +647,15 @@ func getLocked(evm *EVM, contract *Contract, input []byte) (ret []byte, err erro
 	var depositAddr common.Address
 
 	method, _ := abiStaking.Methods["lockedBalance"]
-	err = method.Inputs.Unpack(&depositAddr, input)
+	unpacked, err := method.Inputs.Unpack(input)
 	if err != nil {
 		log.Error("Unpack get_deposit input error")
 		return nil, ErrStakingInvalidInput
 	}
-
+	err = method.Inputs.Copy(&depositAddr, unpacked)
+	if err != nil {
+		return nil, err
+	}
 	locked := evm.StateDB.GetPOSLocked(depositAddr)
 
 	ret, err = method.Outputs.Pack(locked)
@@ -636,12 +672,15 @@ func getDeposit(evm *EVM, contract *Contract, input []byte) (ret []byte, err err
 		unlocked = big.NewInt(0)
 	)
 
-	err = method.Inputs.Unpack(&depositAddr, input)
+	unpacked, err := method.Inputs.Unpack(input)
 	if err != nil {
 		log.Error("Unpack get_deposit input error")
 		return nil, ErrStakingInvalidInput
 	}
-
+	err = method.Inputs.Copy(&depositAddr, unpacked)
+	if err != nil {
+		return nil, err
+	}
 	impawn := NewImpawnImpl()
 	err = impawn.Load(evm.StateDB, types.StakingAddress)
 	if err != nil {
@@ -683,12 +722,15 @@ func getDelegate(evm *EVM, contract *Contract, input []byte) (ret []byte, err er
 		unlocked = big.NewInt(0)
 	)
 
-	err = method.Inputs.Unpack(&args, input)
+	unpacked, err := method.Inputs.Unpack(input)
 	if err != nil {
 		log.Error("Unpack get_deposit input error")
 		return nil, ErrStakingInvalidInput
 	}
-
+	err = method.Inputs.Copy(&args, unpacked)
+	if err != nil {
+		return nil, err
+	}
 	impawn := NewImpawnImpl()
 	err = impawn.Load(evm.StateDB, types.StakingAddress)
 	if err != nil {
diff --git a/internal/trueapi/api.go b/internal/trueapi/api.go
index 987abc62c..441710f5c 100644
--- a/internal/trueapi/api.go
+++ b/internal/trueapi/api.go
@@ -534,7 +534,7 @@ func (s *PrivateAccountAPI) Sign(ctx context.Context, data hexutil.Bytes, addr c
 		return nil, err
 	}
 	// Assemble sign the data with the wallet
-	signature, err := wallet.SignHashWithPassphrase(account, passwd, signHash(data))
+	signature, err := wallet.SignTextWithPassphrase(account, passwd, signHash(data))
 	if err != nil {
 		return nil, err
 	}
@@ -607,10 +607,10 @@ func (s *PublicBlockChainAPI) BlockNumber() hexutil.Uint64 {
 }
 
 // GetBalance returns the amount of wei for the given address in the state of the
-// given block number. The rpc.LatestBlockNumber and rpc.PendingBlockNumber meta
+// given block number or hash. The rpc.LatestBlockNumber and rpc.PendingBlockNumber meta
 // block numbers are also allowed.
-func (s *PublicBlockChainAPI) GetBalance(ctx context.Context, address common.Address, blockNr rpc.BlockNumber) (*hexutil.Big, error) {
-	state, _, err := s.b.StateAndHeaderByNumber(ctx, blockNr)
+func (s *PublicBlockChainAPI) GetBalance(ctx context.Context, address common.Address, blockNrOrHash rpc.BlockNumberOrHash) (*hexutil.Big, error) {
+	state, _, err := s.b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash)
 	if state == nil || err != nil {
 		return nil, err
 	}
@@ -618,10 +618,10 @@ func (s *PublicBlockChainAPI) GetBalance(ctx context.Context, address common.Add
 }
 
 // GetLockBalance returns the amount of wei for the given address in pos state of the
-// given block number. The rpc.LatestBlockNumber and rpc.PendingBlockNumber meta
+// given block number or hash. The rpc.LatestBlockNumber and rpc.PendingBlockNumber meta
 // block numbers are also allowed.
-func (s *PublicBlockChainAPI) GetLockBalance(ctx context.Context, address common.Address, blockNr rpc.BlockNumber) (*hexutil.Big, error) {
-	state, _, err := s.b.StateAndHeaderByNumber(ctx, blockNr)
+func (s *PublicBlockChainAPI) GetLockBalance(ctx context.Context, address common.Address, blockNrOrHash rpc.BlockNumberOrHash) (*hexutil.Big, error) {
+	state, _, err := s.b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash)
 	if state == nil || err != nil {
 		return nil, err
 	}
@@ -764,9 +764,9 @@ func (s *PublicBlockChainAPI) GetUncleCountByBlockHash(ctx context.Context, bloc
 	return nil
 }
 
-// GetCode returns the code stored at the given address in the state for the given block number.
-func (s *PublicBlockChainAPI) GetCode(ctx context.Context, address common.Address, blockNr rpc.BlockNumber) (hexutil.Bytes, error) {
-	state, _, err := s.b.StateAndHeaderByNumber(ctx, blockNr)
+// GetCode returns the code stored at the given address in the state for the given block number or hash.
+func (s *PublicBlockChainAPI) GetCode(ctx context.Context, address common.Address, blockNrOrHash rpc.BlockNumberOrHash) (hexutil.Bytes, error) {
+	state, _, err := s.b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash)
 	if state == nil || err != nil {
 		return nil, err
 	}
@@ -775,10 +775,10 @@ func (s *PublicBlockChainAPI) GetCode(ctx context.Context, address common.Addres
 }
 
 // GetStorageAt returns the storage from the state at the given address, key and
-// block number. The rpc.LatestBlockNumber and rpc.PendingBlockNumber meta block
+// block number or hash. The rpc.LatestBlockNumber and rpc.PendingBlockNumber meta block
 // numbers are also allowed.
-func (s *PublicBlockChainAPI) GetStorageAt(ctx context.Context, address common.Address, key string, blockNr rpc.BlockNumber) (hexutil.Bytes, error) {
-	state, _, err := s.b.StateAndHeaderByNumber(ctx, blockNr)
+func (s *PublicBlockChainAPI) GetStorageAt(ctx context.Context, address common.Address, key string, blockNrOrHash rpc.BlockNumberOrHash) (hexutil.Bytes, error) {
+	state, _, err := s.b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash)
 	if state == nil || err != nil {
 		return nil, err
 	}
@@ -1026,7 +1026,7 @@ func FormatLogs(logs []vm.StructLog) []StructLogRes {
 		if trace.Stack != nil {
 			stack := make([]string, len(trace.Stack))
 			for i, stackValue := range trace.Stack {
-				stack[i] = fmt.Sprintf("%x", math.PaddedBigBytes(stackValue, 32))
+				stack[i] = stackValue.Hex()
 			}
 			formatted[index].Stack = &stack
 		}
@@ -1526,9 +1526,9 @@ func (s *PublicTransactionPoolAPI) GetRawTransactionByBlockHashAndIndex(ctx cont
 	return nil
 }
 
-// GetTransactionCount returns the number of transactions the given address has sent for the given block number
-func (s *PublicTransactionPoolAPI) GetTransactionCount(ctx context.Context, address common.Address, blockNr rpc.BlockNumber) (*hexutil.Uint64, error) {
-	state, _, err := s.b.StateAndHeaderByNumber(ctx, blockNr)
+// GetTransactionCount returns the number of transactions the given address has sent for the given block number or hash
+func (s *PublicTransactionPoolAPI) GetTransactionCount(ctx context.Context, address common.Address, blockNrOrHash rpc.BlockNumberOrHash) (*hexutil.Uint64, error) {
+	state, _, err := s.b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash)
 	if state == nil || err != nil {
 		return nil, err
 	}
@@ -1634,7 +1634,7 @@ func (s *PublicTransactionPoolAPI) sign_payment(addr common.Address, tx *types.T
 		return nil, err
 	}
 	// Request the wallet to sign the transaction
-	return wallet.SignTx_Payment(account, tx, s.b.ChainConfig().ChainID)
+	return wallet.SignTx(account, tx, s.b.ChainConfig().ChainID)
 }
 
 // SendTxArgs represents the arguments to sumbit a new transaction into the transaction pool.
@@ -1850,7 +1850,7 @@ func (s *PublicTransactionPoolAPI) Sign(addr common.Address, data hexutil.Bytes)
 		return nil, err
 	}
 	// Sign the requested hash with the wallet
-	signature, err := wallet.SignHash(account, signHash(data))
+	signature, err := wallet.SignText(account, signHash(data))
 	if err == nil {
 		signature[64] += 27 // Transform V from 0/1 to 27/28 according to the yellow paper
 	}
diff --git a/node/config.go b/node/config.go
index f9eecec7e..b8cd9d7f9 100644
--- a/node/config.go
+++ b/node/config.go
@@ -83,6 +83,9 @@ type Config struct {
 	// scrypt KDF at the expense of security.
 	UseLightweightKDF bool `toml:",omitempty"`
 
+	// InsecureUnlockAllowed allows user to unlock accounts in unsafe http environment.
+	InsecureUnlockAllowed bool `toml:",omitempty"`
+
 	// NoUSB disables hardware wallet monitoring and connectivity.
 	NoUSB bool `toml:",omitempty"`
 
@@ -428,13 +431,13 @@ func makeAccountManager(conf *Config) (*accounts.Manager, string, error) {
 			backends = append(backends, ledgerhub)
 		}
 		// Start a USB hub for Trezor hardware wallets
-		if trezorhub, err := usbwallet.NewTrezorHub(); err != nil {
+		if trezorhub, err := usbwallet.NewTrezorHubWithHID(); err != nil {
 			log.Warn(fmt.Sprintf("Failed to start Trezor hub, disabling: %v", err))
 		} else {
 			backends = append(backends, trezorhub)
 		}
 	}
-	return accounts.NewManager(backends...), ephemeral, nil
+	return accounts.NewManager(&accounts.Config{InsecureUnlockAllowed: conf.InsecureUnlockAllowed}, backends...), ephemeral, nil
 }
 
 func (c *Config) BftCommitteeKey() *ecdsa.PrivateKey {
diff --git a/params/config.go b/params/config.go
index ae5676646..1b8a8a1da 100644
--- a/params/config.go
+++ b/params/config.go
@@ -246,13 +246,34 @@ type ChainConfig struct {
 
 	TIP3 *BlockConfig `json:"tip3"`
 
-	TIP5  *BlockConfig `json:"tip5"`
-	TIP7  *BlockConfig `json:"tip7"`
-	TIP8  *BlockConfig `json:"tip8"`
-	TIP9  *BlockConfig `json:"tip9"`
-	TIP10 *BlockConfig `json:"tip10"`
-	TIP11 *BlockConfig `json:"tip11"`
-	TIP12 *BlockConfig `json:"tip12"`
+	TIP5           *BlockConfig `json:"tip5"`
+	TIP7           *BlockConfig `json:"tip7"`
+	TIP8           *BlockConfig `json:"tip8"`
+	TIP9           *BlockConfig `json:"tip9"`
+	TIP10          *BlockConfig `json:"tip10"`
+	TIP11          *BlockConfig `json:"tip11"`
+	TIP12          *BlockConfig `json:"tip12"`
+	HomesteadBlock *big.Int     `json:"homesteadBlock,omitempty"` // Homestead switch block (nil = no fork, 0 = already homestead)
+
+	DAOForkBlock   *big.Int `json:"daoForkBlock,omitempty"`   // TheDAO hard-fork switch block (nil = no fork)
+	DAOForkSupport bool     `json:"daoForkSupport,omitempty"` // Whether the nodes supports or opposes the DAO hard-fork
+
+	// EIP150 implements the Gas price changes (https://github.com/ethereum/EIPs/issues/150)
+	EIP150Block *big.Int    `json:"eip150Block,omitempty"` // EIP150 HF block (nil = no fork)
+	EIP150Hash  common.Hash `json:"eip150Hash,omitempty"`  // EIP150 HF hash (needed for header only clients as only gas pricing changed)
+
+	EIP155Block *big.Int `json:"eip155Block,omitempty"` // EIP155 HF block
+	EIP158Block *big.Int `json:"eip158Block,omitempty"` // EIP158 HF block
+
+	ByzantiumBlock      *big.Int `json:"byzantiumBlock,omitempty"`      // Byzantium switch block (nil = no fork, 0 = already on byzantium)
+	ConstantinopleBlock *big.Int `json:"constantinopleBlock,omitempty"` // Constantinople switch block (nil = no fork, 0 = already activated)
+	PetersburgBlock     *big.Int `json:"petersburgBlock,omitempty"`     // Petersburg switch block (nil = same as Constantinople)
+	IstanbulBlock       *big.Int `json:"istanbulBlock,omitempty"`       // Istanbul switch block (nil = no fork, 0 = already on istanbul)
+	MuirGlacierBlock    *big.Int `json:"muirGlacierBlock,omitempty"`    // Eip-2384 (bomb delay) switch block (nil = no fork, 0 = already activated)
+	BerlinBlock         *big.Int `json:"berlinBlock,omitempty"`         // Berlin switch block (nil = no fork, 0 = already on berlin)
+	LondonBlock         *big.Int `json:"londonBlock,omitempty"`         // London switch block (nil = no fork, 0 = already on london)
+
+	CatalystBlock *big.Int `json:"catalystBlock,omitempty"` // Catalyst switch block (nil = no fork, 0 = already on catalyst)
 
 	TIPStake *BlockConfig `json:"tipstake"`
 }
diff --git a/params/protocol_params.go b/params/protocol_params.go
index 210ae8fcc..20adbe867 100644
--- a/params/protocol_params.go
+++ b/params/protocol_params.go
@@ -32,7 +32,7 @@ const (
 
 	MaximumExtraDataSize  uint64 = 32    // Maximum size extra data may be after Genesis.
 	ExpByteGas            uint64 = 10    // Times ceil(log256(exponent)) for the EXP instruction.
-	SloadGas              uint64 = 50    // Multiplied by the number of 32-byte words that are copied (round up) for any *COPY operation and added.
+	SloadGasFrontier      uint64 = 50    // Multiplied by the number of 32-byte words that are copied (round up) for any *COPY operation and added.
 	CallValueTransferGas  uint64 = 9000  // Paid for CALL when the value transfer is non-zero.
 	CallNewAccountGas     uint64 = 25000 // Paid for CALL when the destination address didn't exist prior.
 	TxGas                 uint64 = 21000 // Per transaction not creating a contract. NOTE: Not payable on data of calls between transactions.
@@ -68,6 +68,16 @@ const (
 	SstoreCleanRefundEIP2200          uint64 = 4200  // Once per SSTORE operation for resetting to the original non-zero value
 	SstoreClearsScheduleRefundEIP2200 uint64 = 15000 // Once per SSTORE operation for clearing an originally existing storage slot
 
+	ColdAccountAccessCostEIP2929 = uint64(2600) // COLD_ACCOUNT_ACCESS_COST
+	ColdSloadCostEIP2929         = uint64(2100) // COLD_SLOAD_COST
+	WarmStorageReadCostEIP2929   = uint64(100)  // WARM_STORAGE_READ_COST
+
+	// In EIP-2200: SstoreResetGas was 5000.
+	// In EIP-2929: SstoreResetGas was changed to '5000 - COLD_SLOAD_COST'.
+	// In EIP-3529: SSTORE_CLEARS_SCHEDULE is defined as SSTORE_RESET_GAS + ACCESS_LIST_STORAGE_KEY_COST
+	// Which becomes: 5000 - 2100 + 1900 = 4800
+	SstoreClearsScheduleRefundEIP3529 uint64 = SstoreResetGasEIP2200 - ColdSloadCostEIP2929 + TxAccessListStorageKeyGas
+
 	JumpdestGas   uint64 = 1     // Once per JUMPDEST operation.
 	EpochDuration uint64 = 30000 // Duration between proof-of-work epochs.		EpochDuration uint64 = 30000 // Duration between proof-of-work epochs.
 
@@ -83,30 +93,36 @@ const (
 	Create2Gas            uint64 = 32000 // Once per CREATE2 operation		Create2Gas            uint64 = 32000 // Once per CREATE2 operation
 	SelfdestructRefundGas uint64 = 24000 // Refunded following a suicide operation.		SelfdestructRefundGas uint64 = 24000 // Refunded following a selfdestruct operation.
 	MemoryGas             uint64 = 3     // Times the address of the (highest referenced byte in memory + 1). NOTE: referencing happens on read, write and in instructions such as RETURN and CALL.		MemoryGas             uint64 = 3     // Times the address of the (highest referenced byte in memory + 1). NOTE: referencing happens on read, write and in instructions such as RETURN and CALL.
-	TxDataNonZeroGas      uint64 = 68    // Per byte of data attached to a transaction that is not equal to zero. NOTE: Not payable on data of calls between transactions.		TxDataNonZeroGas      uint64 = 68    // Per byte of data attached to a transaction that is not equal to zero. NOTE: Not payable on data of calls between transactions.
+
+	TxDataNonZeroGas          uint64 = 68   // Per byte of data attached to a transaction that is not equal to zero. NOTE: Not payable on data of calls between transactions.		TxDataNonZeroGas      uint64 = 68    // Per byte of data attached to a transaction that is not equal to zero. NOTE: Not payable on data of calls between transactions.
+	TxDataNonZeroGasFrontier  uint64 = 68   // Per byte of data attached to a transaction that is not equal to zero. NOTE: Not payable on data of calls between transactions.
+	TxDataNonZeroGasEIP2028   uint64 = 16   // Per byte of non zero data attached to a transaction after EIP 2028 (part in Istanbul)
+	TxAccessListAddressGas    uint64 = 2400 // Per address specified in EIP 2930 access list
+	TxAccessListStorageKeyGas uint64 = 1900 // Per storage key specified in EIP 2930 access list
 
 	// These have been changed during the course of the chain
-	CallGas               uint64 = 40  // Once per CALL operation & message call transaction.
-	CallGasEIP150         uint64 = 700 // Static portion of gas for CALL-derivates after EIP 150 (Tangerine)
-	BalanceGas            uint64 = 20  // The cost of a BALANCE operation
-	BalanceGasEIP150      uint64 = 400 // The cost of a BALANCE operation after Tangerine
-	BalanceGasEIP1884     uint64 = 700
-	ExtcodeSizeGas        uint64 = 20  // Cost of EXTCODESIZE before EIP 150 (Tangerine)
-	ExtcodeSizeGasEIP150  uint64 = 700 // Cost of EXTCODESIZE after EIP 150 (Tangerine)
-	SloadGasEIP150        uint64 = 200
-	SloadGasEIP1884       uint64 = 800  // Cost of SLOAD after EIP 1884 (part of Istanbul)
-	SloadGasEIP2200       uint64 = 800  // Cost of SLOAD after EIP 2200 (part of Istanbul)
-	ExtcodeHashGas        uint64 = 400  // Cost of EXTCODEHASH (introduced in Constantinople)
-	ExtcodeHashGasEIP1884 uint64 = 700  // Cost of EXTCODEHASH (introduced in Constantinople)
-	SelfdestructGasEIP150 uint64 = 5000 // Cost of SELFDESTRUCT post EIP 150 (Tangerine)
+	CallGasFrontier              uint64 = 40  // Once per CALL operation & message call transaction.
+	CallGasEIP150                uint64 = 700 // Static portion of gas for CALL-derivates after EIP 150 (Tangerine)
+	BalanceGasFrontier           uint64 = 20  // The cost of a BALANCE operation
+	BalanceGasEIP150             uint64 = 400 // The cost of a BALANCE operation after Tangerine
+	BalanceGasEIP1884            uint64 = 700
+	ExtcodeSizeGasFrontier       uint64 = 20  // Cost of EXTCODESIZE before EIP 150 (Tangerine)
+	ExtcodeSizeGasEIP150         uint64 = 700 // Cost of EXTCODESIZE after EIP 150 (Tangerine)
+	SloadGasEIP150               uint64 = 200
+	SloadGasEIP1884              uint64 = 800  // Cost of SLOAD after EIP 1884 (part of Istanbul)
+	SloadGasEIP2200              uint64 = 800  // Cost of SLOAD after EIP 2200 (part of Istanbul)
+	ExtcodeHashGasConstantinople uint64 = 400  // Cost of EXTCODEHASH (introduced in Constantinople)
+	ExtcodeHashGasEIP1884        uint64 = 700  // Cost of EXTCODEHASH (introduced in Constantinople)
+	SelfdestructGasEIP150        uint64 = 5000 // Cost of SELFDESTRUCT post EIP 150 (Tangerine)
 
 	// EXP has a dynamic portion depending on the size of the exponent
-	ExpByteEIP158 uint64 = 50 // was raised to 50 during Eip158 (Spurious Dragon)
+	ExpByteFrontier uint64 = 10 // was set to 10 in Frontier
+	ExpByteEIP158   uint64 = 50 // was raised to 50 during Eip158 (Spurious Dragon)
 
 	// Extcodecopy has a dynamic AND a static cost. This represents only the
 	// static portion of the gas. It was changed during EIP 150 (Tangerine)
-	ExtcodeCopyBase       uint64 = 20
-	ExtcodeCopyBaseEIP150 uint64 = 700
+	ExtcodeCopyBaseFrontier uint64 = 20
+	ExtcodeCopyBaseEIP150   uint64 = 700
 
 	// CreateBySelfdestructGas is used when the refunded account is one that does
 	// not exist. This logic is similar to call.
diff --git a/rlp/decode.go b/rlp/decode.go
index dbbe59959..ac04d5d56 100644
--- a/rlp/decode.go
+++ b/rlp/decode.go
@@ -26,14 +26,16 @@ import (
 	"math/big"
 	"reflect"
 	"strings"
+	"sync"
 )
 
-var (
-	// EOL is returned when the end of the current list
-	// has been reached during streaming.
-	EOL = errors.New("rlp: end of list")
+//lint:ignore ST1012 EOL is not an error.
+
+// EOL is returned when the end of the current list
+// has been reached during streaming.
+var EOL = errors.New("rlp: end of list")
 
-	// Actual Errors
+var (
 	ErrExpectedString   = errors.New("rlp: expected String or Byte")
 	ErrExpectedList     = errors.New("rlp: expected List")
 	ErrCanonInt         = errors.New("rlp: non-canonical integer format")
@@ -48,95 +50,49 @@ var (
 	errUintOverflow  = errors.New("rlp: uint overflow")
 	errNoPointer     = errors.New("rlp: interface given to Decode must be a pointer")
 	errDecodeIntoNil = errors.New("rlp: pointer given to Decode must not be nil")
+
+	streamPool = sync.Pool{
+		New: func() interface{} { return new(Stream) },
+	}
 )
 
-// Decoder is implemented by types that require custom RLP
-// decoding rules or need to decode into private fields.
+// Decoder is implemented by types that require custom RLP decoding rules or need to decode
+// into private fields.
 //
-// The DecodeRLP method should read one value from the given
-// Stream. It is not forbidden to read less or more, but it might
-// be confusing.
+// The DecodeRLP method should read one value from the given Stream. It is not forbidden to
+// read less or more, but it might be confusing.
 type Decoder interface {
 	DecodeRLP(*Stream) error
 }
 
-// Decode parses RLP-encoded data from r and stores the result in the
-// value pointed to by val. Val must be a non-nil pointer. If r does
-// not implement ByteReader, Decode will do its own buffering.
-//
-// Decode uses the following type-dependent decoding rules:
-//
-// If the type implements the Decoder interface, decode calls
-// DecodeRLP.
-//
-// To decode into a pointer, Decode will decode into the value pointed
-// to. If the pointer is nil, a new value of the pointer's element
-// type is allocated. If the pointer is non-nil, the existing value
-// will be reused.
-//
-// To decode into a struct, Decode expects the input to be an RLP
-// list. The decoded elements of the list are assigned to each public
-// field in the order given by the struct's definition. The input list
-// must contain an element for each decoded field. Decode returns an
-// error if there are too few or too many elements.
-//
-// The decoding of struct fields honours certain struct tags, "tail",
-// "nil" and "-".
-//
-// The "-" tag ignores fields.
-//
-// For an explanation of "tail", see the example.
-//
-// The "nil" tag applies to pointer-typed fields and changes the decoding
-// rules for the field such that input values of size zero decode as a nil
-// pointer. This tag can be useful when decoding recursive types.
+// Decode parses RLP-encoded data from r and stores the result in the value pointed to by
+// val. Please see package-level documentation for the decoding rules. Val must be a
+// non-nil pointer.
 //
-//     type StructWithEmptyOK struct {
-//         Foo *[20]byte `rlp:"nil"`
-//     }
+// If r does not implement ByteReader, Decode will do its own buffering.
 //
-// To decode into a slice, the input must be a list and the resulting
-// slice will contain the input elements in order. For byte slices,
-// the input must be an RLP string. Array types decode similarly, with
-// the additional restriction that the number of input elements (or
-// bytes) must match the array's length.
-//
-// To decode into a Go string, the input must be an RLP string. The
-// input bytes are taken as-is and will not necessarily be valid UTF-8.
-//
-// To decode into an unsigned integer type, the input must also be an RLP
-// string. The bytes are interpreted as a big endian representation of
-// the integer. If the RLP string is larger than the bit size of the
-// type, Decode will return an error. Decode also supports *big.Int.
-// There is no size limit for big integers.
-//
-// To decode into an interface value, Decode stores one of these
-// in the value:
-//
-//	  []interface{}, for RLP lists
-//	  []byte, for RLP strings
-//
-// Non-empty interface types are not supported, nor are booleans,
-// signed integers, floating point numbers, maps, channels and
-// functions.
-//
-// Note that Decode does not set an input limit for all readers
-// and may be vulnerable to panics cause by huge value sizes. If
-// you need an input limit, use
+// Note that Decode does not set an input limit for all readers and may be vulnerable to
+// panics cause by huge value sizes. If you need an input limit, use
 //
 //     NewStream(r, limit).Decode(val)
 func Decode(r io.Reader, val interface{}) error {
-	// TODO: this could use a Stream from a pool.
-	return NewStream(r, 0).Decode(val)
+	stream := streamPool.Get().(*Stream)
+	defer streamPool.Put(stream)
+
+	stream.Reset(r, 0)
+	return stream.Decode(val)
 }
 
-// DecodeBytes parses RLP data from b into val.
-// Please see the documentation of Decode for the decoding rules.
-// The input must contain exactly one value and no trailing data.
+// DecodeBytes parses RLP data from b into val. Please see package-level documentation for
+// the decoding rules. The input must contain exactly one value and no trailing data.
 func DecodeBytes(b []byte, val interface{}) error {
-	// TODO: this could use a Stream from a pool.
 	r := bytes.NewReader(b)
-	if err := NewStream(r, uint64(len(b))).Decode(val); err != nil {
+
+	stream := streamPool.Get().(*Stream)
+	defer streamPool.Put(stream)
+
+	stream.Reset(r, uint64(len(b)))
+	if err := stream.Decode(val); err != nil {
 		return err
 	}
 	if r.Len() > 0 {
@@ -197,14 +153,14 @@ func makeDecoder(typ reflect.Type, tags tags) (dec decoder, err error) {
 	switch {
 	case typ == rawValueType:
 		return decodeRawValue, nil
-	case typ.Implements(decoderInterface):
-		return decodeDecoder, nil
-	case kind != reflect.Ptr && reflect.PtrTo(typ).Implements(decoderInterface):
-		return decodeDecoderNoPtr, nil
 	case typ.AssignableTo(reflect.PtrTo(bigInt)):
 		return decodeBigInt, nil
 	case typ.AssignableTo(bigInt):
 		return decodeBigIntNoPtr, nil
+	case kind == reflect.Ptr:
+		return makePtrDecoder(typ, tags)
+	case reflect.PtrTo(typ).Implements(decoderInterface):
+		return decodeDecoder, nil
 	case isUint(kind):
 		return decodeUint, nil
 	case kind == reflect.Bool:
@@ -215,11 +171,6 @@ func makeDecoder(typ reflect.Type, tags tags) (dec decoder, err error) {
 		return makeListDecoder(typ, tags)
 	case kind == reflect.Struct:
 		return makeStructDecoder(typ)
-	case kind == reflect.Ptr:
-		if tags.nilOK {
-			return makeOptionalPtrDecoder(typ)
-		}
-		return makePtrDecoder(typ)
 	case kind == reflect.Interface:
 		return decodeInterface, nil
 	default:
@@ -269,20 +220,51 @@ func decodeBigIntNoPtr(s *Stream, val reflect.Value) error {
 }
 
 func decodeBigInt(s *Stream, val reflect.Value) error {
-	b, err := s.Bytes()
-	if err != nil {
+	var buffer []byte
+	kind, size, err := s.Kind()
+	switch {
+	case err != nil:
 		return wrapStreamError(err, val.Type())
+	case kind == List:
+		return wrapStreamError(ErrExpectedString, val.Type())
+	case kind == Byte:
+		buffer = s.uintbuf[:1]
+		buffer[0] = s.byteval
+		s.kind = -1 // re-arm Kind
+	case size == 0:
+		// Avoid zero-length read.
+		s.kind = -1
+	case size <= uint64(len(s.uintbuf)):
+		// For integers smaller than s.uintbuf, allocating a buffer
+		// can be avoided.
+		buffer = s.uintbuf[:size]
+		if err := s.readFull(buffer); err != nil {
+			return wrapStreamError(err, val.Type())
+		}
+		// Reject inputs where single byte encoding should have been used.
+		if size == 1 && buffer[0] < 128 {
+			return wrapStreamError(ErrCanonSize, val.Type())
+		}
+	default:
+		// For large integers, a temporary buffer is needed.
+		buffer = make([]byte, size)
+		if err := s.readFull(buffer); err != nil {
+			return wrapStreamError(err, val.Type())
+		}
+	}
+
+	// Reject leading zero bytes.
+	if len(buffer) > 0 && buffer[0] == 0 {
+		return wrapStreamError(ErrCanonInt, val.Type())
 	}
+
+	// Set the integer bytes.
 	i := val.Interface().(*big.Int)
 	if i == nil {
 		i = new(big.Int)
 		val.Set(reflect.ValueOf(i))
 	}
-	// Reject leading zero bytes
-	if len(b) > 0 && b[0] == 0 {
-		return wrapStreamError(ErrCanonInt, val.Type())
-	}
-	i.SetBytes(b)
+	i.SetBytes(buffer)
 	return nil
 }
 
@@ -294,9 +276,9 @@ func makeListDecoder(typ reflect.Type, tag tags) (decoder, error) {
 		}
 		return decodeByteSlice, nil
 	}
-	etypeinfo, err := cachedTypeInfo1(etype, tags{})
-	if err != nil {
-		return nil, err
+	etypeinfo := theTC.infoWhileGenerating(etype, tags{})
+	if etypeinfo.decoderErr != nil {
+		return nil, etypeinfo.decoderErr
 	}
 	var dec decoder
 	switch {
@@ -397,25 +379,23 @@ func decodeByteArray(s *Stream, val reflect.Value) error {
 	if err != nil {
 		return err
 	}
-	vlen := val.Len()
+	slice := byteArrayBytes(val)
 	switch kind {
 	case Byte:
-		if vlen == 0 {
+		if len(slice) == 0 {
 			return &decodeError{msg: "input string too long", typ: val.Type()}
-		}
-		if vlen > 1 {
+		} else if len(slice) > 1 {
 			return &decodeError{msg: "input string too short", typ: val.Type()}
 		}
-		bv, _ := s.Uint()
-		val.Index(0).SetUint(bv)
+		slice[0] = s.byteval
+		s.kind = -1
 	case String:
-		if uint64(vlen) < size {
+		if uint64(len(slice)) < size {
 			return &decodeError{msg: "input string too long", typ: val.Type()}
 		}
-		if uint64(vlen) > size {
+		if uint64(len(slice)) > size {
 			return &decodeError{msg: "input string too short", typ: val.Type()}
 		}
-		slice := val.Slice(0, vlen).Interface().([]byte)
 		if err := s.readFull(slice); err != nil {
 			return err
 		}
@@ -434,13 +414,25 @@ func makeStructDecoder(typ reflect.Type) (decoder, error) {
 	if err != nil {
 		return nil, err
 	}
+	for _, f := range fields {
+		if f.info.decoderErr != nil {
+			return nil, structFieldError{typ, f.index, f.info.decoderErr}
+		}
+	}
 	dec := func(s *Stream, val reflect.Value) (err error) {
 		if _, err := s.List(); err != nil {
 			return wrapStreamError(err, typ)
 		}
-		for _, f := range fields {
+		for i, f := range fields {
 			err := f.info.decoder(s, val.Field(f.index))
 			if err == EOL {
+				if f.optional {
+					// The field is optional, so reaching the end of the list before
+					// reaching the last field is acceptable. All remaining undecoded
+					// fields are zeroed.
+					zeroFields(val, fields[i:])
+					break
+				}
 				return &decodeError{msg: "too few elements", typ: typ}
 			} else if err != nil {
 				return addErrorContext(err, "."+typ.Field(f.index).Name)
@@ -451,15 +443,29 @@ func makeStructDecoder(typ reflect.Type) (decoder, error) {
 	return dec, nil
 }
 
-// makePtrDecoder creates a decoder that decodes into
-// the pointer's element type.
-func makePtrDecoder(typ reflect.Type) (decoder, error) {
+func zeroFields(structval reflect.Value, fields []field) {
+	for _, f := range fields {
+		fv := structval.Field(f.index)
+		fv.Set(reflect.Zero(fv.Type()))
+	}
+}
+
+// makePtrDecoder creates a decoder that decodes into the pointer's element type.
+func makePtrDecoder(typ reflect.Type, tag tags) (decoder, error) {
 	etype := typ.Elem()
-	etypeinfo, err := cachedTypeInfo1(etype, tags{})
-	if err != nil {
-		return nil, err
+	etypeinfo := theTC.infoWhileGenerating(etype, tags{})
+	switch {
+	case etypeinfo.decoderErr != nil:
+		return nil, etypeinfo.decoderErr
+	case !tag.nilOK:
+		return makeSimplePtrDecoder(etype, etypeinfo), nil
+	default:
+		return makeNilPtrDecoder(etype, etypeinfo, tag.nilKind), nil
 	}
-	dec := func(s *Stream, val reflect.Value) (err error) {
+}
+
+func makeSimplePtrDecoder(etype reflect.Type, etypeinfo *typeinfo) decoder {
+	return func(s *Stream, val reflect.Value) (err error) {
 		newval := val
 		if val.IsNil() {
 			newval = reflect.New(etype)
@@ -469,30 +475,35 @@ func makePtrDecoder(typ reflect.Type) (decoder, error) {
 		}
 		return err
 	}
-	return dec, nil
 }
 
-// makeOptionalPtrDecoder creates a decoder that decodes empty values
-// as nil. Non-empty values are decoded into a value of the element type,
-// just like makePtrDecoder does.
+// makeNilPtrDecoder creates a decoder that decodes empty values as nil. Non-empty
+// values are decoded into a value of the element type, just like makePtrDecoder does.
 //
 // This decoder is used for pointer-typed struct fields with struct tag "nil".
-func makeOptionalPtrDecoder(typ reflect.Type) (decoder, error) {
-	etype := typ.Elem()
-	etypeinfo, err := cachedTypeInfo1(etype, tags{})
-	if err != nil {
-		return nil, err
-	}
-	dec := func(s *Stream, val reflect.Value) (err error) {
+func makeNilPtrDecoder(etype reflect.Type, etypeinfo *typeinfo, nilKind Kind) decoder {
+	typ := reflect.PtrTo(etype)
+	nilPtr := reflect.Zero(typ)
+	return func(s *Stream, val reflect.Value) (err error) {
 		kind, size, err := s.Kind()
-		if err != nil || size == 0 && kind != Byte {
+		if err != nil {
+			val.Set(nilPtr)
+			return wrapStreamError(err, typ)
+		}
+		// Handle empty values as a nil pointer.
+		if kind != Byte && size == 0 {
+			if kind != nilKind {
+				return &decodeError{
+					msg: fmt.Sprintf("wrong kind of empty value (got %v, want %v)", kind, nilKind),
+					typ: typ,
+				}
+			}
 			// rearm s.Kind. This is important because the input
 			// position must advance to the next value even though
 			// we don't read anything.
 			s.kind = -1
-			// set the pointer to nil.
-			val.Set(reflect.Zero(typ))
-			return err
+			val.Set(nilPtr)
+			return nil
 		}
 		newval := val
 		if val.IsNil() {
@@ -503,7 +514,6 @@ func makeOptionalPtrDecoder(typ reflect.Type) (decoder, error) {
 		}
 		return err
 	}
-	return dec, nil
 }
 
 var ifsliceType = reflect.TypeOf([]interface{}{})
@@ -532,25 +542,12 @@ func decodeInterface(s *Stream, val reflect.Value) error {
 	return nil
 }
 
-// This decoder is used for non-pointer values of types
-// that implement the Decoder interface using a pointer receiver.
-func decodeDecoderNoPtr(s *Stream, val reflect.Value) error {
-	return val.Addr().Interface().(Decoder).DecodeRLP(s)
-}
-
 func decodeDecoder(s *Stream, val reflect.Value) error {
-	// Decoder instances are not handled using the pointer rule if the type
-	// implements Decoder with pointer receiver (i.e. always)
-	// because it might handle empty values specially.
-	// We need to allocate one here in this case, like makePtrDecoder does.
-	if val.Kind() == reflect.Ptr && val.IsNil() {
-		val.Set(reflect.New(val.Type().Elem()))
-	}
-	return val.Interface().(Decoder).DecodeRLP(s)
+	return val.Addr().Interface().(Decoder).DecodeRLP(s)
 }
 
 // Kind represents the kind of value contained in an RLP stream.
-type Kind int
+type Kind int8
 
 const (
 	Byte Kind = iota
@@ -593,22 +590,16 @@ type ByteReader interface {
 type Stream struct {
 	r ByteReader
 
-	// number of bytes remaining to be read from r.
-	remaining uint64
-	limited   bool
-
-	// auxiliary buffer for integer decoding
-	uintbuf []byte
-
-	kind    Kind   // kind of value ahead
-	size    uint64 // size of value ahead
-	byteval byte   // value of single byte in type tag
-	kinderr error  // error from last readKind
-	stack   []listpos
+	remaining uint64   // number of bytes remaining to be read from r
+	size      uint64   // size of value ahead
+	kinderr   error    // error from last readKind
+	stack     []uint64 // list sizes
+	uintbuf   [32]byte // auxiliary buffer for integer decoding
+	kind      Kind     // kind of value ahead
+	byteval   byte     // value of single byte in type tag
+	limited   bool     // true if input limit is in effect
 }
 
-type listpos struct{ pos, size uint64 }
-
 // NewStream creates a new decoding stream reading from r.
 //
 // If r implements the ByteReader interface, Stream will
@@ -678,8 +669,8 @@ func (s *Stream) Raw() ([]byte, error) {
 		s.kind = -1 // rearm Kind
 		return []byte{s.byteval}, nil
 	}
-	// the original header has already been read and is no longer
-	// available. read content and put a new header in front of it.
+	// The original header has already been read and is no longer
+	// available. Read content and put a new header in front of it.
 	start := headsize(size)
 	buf := make([]byte, uint64(start)+size)
 	if err := s.readFull(buf[start:]); err != nil {
@@ -762,7 +753,14 @@ func (s *Stream) List() (size uint64, err error) {
 	if kind != List {
 		return 0, ErrExpectedList
 	}
-	s.stack = append(s.stack, listpos{0, size})
+
+	// Remove size of inner list from outer list before pushing the new size
+	// onto the stack. This ensures that the remaining outer list size will
+	// be correct after the matching call to ListEnd.
+	if inList, limit := s.listLimit(); inList {
+		s.stack[len(s.stack)-1] = limit - size
+	}
+	s.stack = append(s.stack, size)
 	s.kind = -1
 	s.size = 0
 	return size, nil
@@ -771,17 +769,13 @@ func (s *Stream) List() (size uint64, err error) {
 // ListEnd returns to the enclosing list.
 // The input reader must be positioned at the end of a list.
 func (s *Stream) ListEnd() error {
-	if len(s.stack) == 0 {
+	// Ensure that no more data is remaining in the current list.
+	if inList, listLimit := s.listLimit(); !inList {
 		return errNotInList
-	}
-	tos := s.stack[len(s.stack)-1]
-	if tos.pos != tos.size {
+	} else if listLimit > 0 {
 		return errNotAtEOL
 	}
 	s.stack = s.stack[:len(s.stack)-1] // pop
-	if len(s.stack) > 0 {
-		s.stack[len(s.stack)-1].pos += tos.size
-	}
 	s.kind = -1
 	s.size = 0
 	return nil
@@ -802,14 +796,14 @@ func (s *Stream) Decode(val interface{}) error {
 	if rval.IsNil() {
 		return errDecodeIntoNil
 	}
-	info, err := cachedTypeInfo(rtyp.Elem(), tags{})
+	decoder, err := cachedDecoder(rtyp.Elem())
 	if err != nil {
 		return err
 	}
 
-	err = info.decoder(s, rval.Elem())
+	err = decoder(s, rval.Elem())
 	if decErr, ok := err.(*decodeError); ok && len(decErr.ctx) > 0 {
-		// add decode target type to error so context has more meaning
+		// Add decode target type to error so context has more meaning.
 		decErr.ctx = append(decErr.ctx, fmt.Sprint("(", rtyp.Elem(), ")"))
 	}
 	return err
@@ -832,6 +826,9 @@ func (s *Stream) Reset(r io.Reader, inputLimit uint64) {
 		case *bytes.Reader:
 			s.remaining = uint64(br.Len())
 			s.limited = true
+		case *bytes.Buffer:
+			s.remaining = uint64(br.Len())
+			s.limited = true
 		case *strings.Reader:
 			s.remaining = uint64(br.Len())
 			s.limited = true
@@ -850,9 +847,8 @@ func (s *Stream) Reset(r io.Reader, inputLimit uint64) {
 	s.size = 0
 	s.kind = -1
 	s.kinderr = nil
-	if s.uintbuf == nil {
-		s.uintbuf = make([]byte, 8)
-	}
+	s.byteval = 0
+	s.uintbuf = [32]byte{}
 }
 
 // Kind returns the kind and size of the next value in the
@@ -867,35 +863,29 @@ func (s *Stream) Reset(r io.Reader, inputLimit uint64) {
 // the value. Subsequent calls to Kind (until the value is decoded)
 // will not advance the input reader and return cached information.
 func (s *Stream) Kind() (kind Kind, size uint64, err error) {
-	var tos *listpos
-	if len(s.stack) > 0 {
-		tos = &s.stack[len(s.stack)-1]
-	}
-	if s.kind < 0 {
-		s.kinderr = nil
-		// Don't read further if we're at the end of the
-		// innermost list.
-		if tos != nil && tos.pos == tos.size {
-			return 0, 0, EOL
-		}
-		s.kind, s.size, s.kinderr = s.readKind()
-		if s.kinderr == nil {
-			if tos == nil {
-				// At toplevel, check that the value is smaller
-				// than the remaining input length.
-				if s.limited && s.size > s.remaining {
-					s.kinderr = ErrValueTooLarge
-				}
-			} else {
-				// Inside a list, check that the value doesn't overflow the list.
-				if s.size > tos.size-tos.pos {
-					s.kinderr = ErrElemTooLarge
-				}
-			}
+	if s.kind >= 0 {
+		return s.kind, s.size, s.kinderr
+	}
+
+	// Check for end of list. This needs to be done here because readKind
+	// checks against the list size, and would return the wrong error.
+	inList, listLimit := s.listLimit()
+	if inList && listLimit == 0 {
+		return 0, 0, EOL
+	}
+	// Read the actual size tag.
+	s.kind, s.size, s.kinderr = s.readKind()
+	if s.kinderr == nil {
+		// Check the data size of the value ahead against input limits. This
+		// is done here because many decoders require allocating an input
+		// buffer matching the value size. Checking it here protects those
+		// decoders from inputs declaring very large value size.
+		if inList && s.size > listLimit {
+			s.kinderr = ErrElemTooLarge
+		} else if s.limited && s.size > s.remaining {
+			s.kinderr = ErrValueTooLarge
 		}
 	}
-	// Note: this might return a sticky error generated
-	// by an earlier call to readKind.
 	return s.kind, s.size, s.kinderr
 }
 
@@ -922,37 +912,35 @@ func (s *Stream) readKind() (kind Kind, size uint64, err error) {
 		s.byteval = b
 		return Byte, 0, nil
 	case b < 0xB8:
-		// Otherwise, if a string is 0-55 bytes long,
-		// the RLP encoding consists of a single byte with value 0x80 plus the
-		// length of the string followed by the string. The range of the first
-		// byte is thus [0x80, 0xB7].
+		// Otherwise, if a string is 0-55 bytes long, the RLP encoding consists
+		// of a single byte with value 0x80 plus the length of the string
+		// followed by the string. The range of the first byte is thus [0x80, 0xB7].
 		return String, uint64(b - 0x80), nil
 	case b < 0xC0:
-		// If a string is more than 55 bytes long, the
-		// RLP encoding consists of a single byte with value 0xB7 plus the length
-		// of the length of the string in binary form, followed by the length of
-		// the string, followed by the string. For example, a length-1024 string
-		// would be encoded as 0xB90400 followed by the string. The range of
-		// the first byte is thus [0xB8, 0xBF].
+		// If a string is more than 55 bytes long, the RLP encoding consists of a
+		// single byte with value 0xB7 plus the length of the length of the
+		// string in binary form, followed by the length of the string, followed
+		// by the string. For example, a length-1024 string would be encoded as
+		// 0xB90400 followed by the string. The range of the first byte is thus
+		// [0xB8, 0xBF].
 		size, err = s.readUint(b - 0xB7)
 		if err == nil && size < 56 {
 			err = ErrCanonSize
 		}
 		return String, size, err
 	case b < 0xF8:
-		// If the total payload of a list
-		// (i.e. the combined length of all its items) is 0-55 bytes long, the
-		// RLP encoding consists of a single byte with value 0xC0 plus the length
-		// of the list followed by the concatenation of the RLP encodings of the
-		// items. The range of the first byte is thus [0xC0, 0xF7].
+		// If the total payload of a list (i.e. the combined length of all its
+		// items) is 0-55 bytes long, the RLP encoding consists of a single byte
+		// with value 0xC0 plus the length of the list followed by the
+		// concatenation of the RLP encodings of the items. The range of the
+		// first byte is thus [0xC0, 0xF7].
 		return List, uint64(b - 0xC0), nil
 	default:
-		// If the total payload of a list is more than 55 bytes long,
-		// the RLP encoding consists of a single byte with value 0xF7
-		// plus the length of the length of the payload in binary
-		// form, followed by the length of the payload, followed by
-		// the concatenation of the RLP encodings of the items. The
-		// range of the first byte is thus [0xF8, 0xFF].
+		// If the total payload of a list is more than 55 bytes long, the RLP
+		// encoding consists of a single byte with value 0xF7 plus the length of
+		// the length of the payload in binary form, followed by the length of
+		// the payload, followed by the concatenation of the RLP encodings of
+		// the items. The range of the first byte is thus [0xF8, 0xFF].
 		size, err = s.readUint(b - 0xF7)
 		if err == nil && size < 56 {
 			err = ErrCanonSize
@@ -970,23 +958,24 @@ func (s *Stream) readUint(size byte) (uint64, error) {
 		b, err := s.readByte()
 		return uint64(b), err
 	default:
-		start := int(8 - size)
-		for i := 0; i < start; i++ {
-			s.uintbuf[i] = 0
+		buffer := s.uintbuf[:8]
+		for i := range buffer {
+			buffer[i] = 0
 		}
-		if err := s.readFull(s.uintbuf[start:]); err != nil {
+		start := int(8 - size)
+		if err := s.readFull(buffer[start:]); err != nil {
 			return 0, err
 		}
-		if s.uintbuf[start] == 0 {
-			// Note: readUint is also used to decode integer
-			// values. The error needs to be adjusted to become
-			// ErrCanonInt in this case.
+		if buffer[start] == 0 {
+			// Note: readUint is also used to decode integer values.
+			// The error needs to be adjusted to become ErrCanonInt in this case.
 			return 0, ErrCanonSize
 		}
-		return binary.BigEndian.Uint64(s.uintbuf), nil
+		return binary.BigEndian.Uint64(buffer[:]), nil
 	}
 }
 
+// readFull reads into buf from the underlying stream.
 func (s *Stream) readFull(buf []byte) (err error) {
 	if err := s.willRead(uint64(len(buf))); err != nil {
 		return err
@@ -997,11 +986,18 @@ func (s *Stream) readFull(buf []byte) (err error) {
 		n += nn
 	}
 	if err == io.EOF {
-		err = io.ErrUnexpectedEOF
+		if n < len(buf) {
+			err = io.ErrUnexpectedEOF
+		} else {
+			// Readers are allowed to give EOF even though the read succeeded.
+			// In such cases, we discard the EOF, like io.ReadFull() does.
+			err = nil
+		}
 	}
 	return err
 }
 
+// readByte reads a single byte from the underlying stream.
 func (s *Stream) readByte() (byte, error) {
 	if err := s.willRead(1); err != nil {
 		return 0, err
@@ -1013,16 +1009,16 @@ func (s *Stream) readByte() (byte, error) {
 	return b, err
 }
 
+// willRead is called before any read from the underlying stream. It checks
+// n against size limits, and updates the limits if n doesn't overflow them.
 func (s *Stream) willRead(n uint64) error {
 	s.kind = -1 // rearm Kind
 
-	if len(s.stack) > 0 {
-		// check list overflow
-		tos := s.stack[len(s.stack)-1]
-		if n > tos.size-tos.pos {
+	if inList, limit := s.listLimit(); inList {
+		if n > limit {
 			return ErrElemTooLarge
 		}
-		s.stack[len(s.stack)-1].pos += n
+		s.stack[len(s.stack)-1] = limit - n
 	}
 	if s.limited {
 		if n > s.remaining {
@@ -1032,3 +1028,11 @@ func (s *Stream) willRead(n uint64) error {
 	}
 	return nil
 }
+
+// listLimit returns the amount of data remaining in the innermost list.
+func (s *Stream) listLimit() (inList bool, limit uint64) {
+	if len(s.stack) == 0 {
+		return false, 0
+	}
+	return true, s.stack[len(s.stack)-1]
+}
diff --git a/rlp/encode.go b/rlp/encode.go
index 445b4b5b2..334864434 100644
--- a/rlp/encode.go
+++ b/rlp/encode.go
@@ -49,34 +49,7 @@ type Encoder interface {
 // perform many small writes in some cases. Consider making w
 // buffered.
 //
-// Encode uses the following type-dependent encoding rules:
-//
-// If the type implements the Encoder interface, Encode calls
-// EncodeRLP. This is true even for nil pointers, please see the
-// documentation for Encoder.
-//
-// To encode a pointer, the value being pointed to is encoded. For nil
-// pointers, Encode will encode the zero value of the type. A nil
-// pointer to a struct type always encodes as an empty RLP list.
-// A nil pointer to an array encodes as an empty list (or empty string
-// if the array has element type byte).
-//
-// Struct values are encoded as an RLP list of all their encoded
-// public fields. Recursive struct types are supported.
-//
-// To encode slices and arrays, the elements are encoded as an RLP
-// list of the value's elements. Note that arrays and slices with
-// element type uint8 or byte are always encoded as an RLP string.
-//
-// A Go string is encoded as an RLP string.
-//
-// An unsigned integer value is encoded as an RLP string. Zero always
-// encodes as an empty RLP string. Encode also supports *big.Int.
-//
-// An interface value encodes as the value contained in the interface.
-//
-// Boolean values are not supported, nor are signed integers, floating
-// point numbers, maps, channels and functions.
+// Please see package-level documentation of encoding rules.
 func Encode(w io.Writer, val interface{}) error {
 	if outer, ok := w.(*encbuf); ok {
 		// Encode was called by some type's EncodeRLP.
@@ -93,7 +66,7 @@ func Encode(w io.Writer, val interface{}) error {
 }
 
 // EncodeToBytes returns the RLP encoding of val.
-// Please see the documentation of Encode for the encoding rules.
+// Please see package-level documentation for the encoding rules.
 func EncodeToBytes(val interface{}) ([]byte, error) {
 	eb := encbufPool.Get().(*encbuf)
 	defer encbufPool.Put(eb)
@@ -118,13 +91,6 @@ func EncodeToReader(val interface{}) (size int, r io.Reader, err error) {
 	return eb.size(), &encReader{buf: eb}, nil
 }
 
-type encbuf struct {
-	str     []byte      // string data, contains everything except list headers
-	lheads  []*listhead // all list headers
-	lhsize  int         // sum of sizes of all encoded list headers
-	sizebuf []byte      // 9-byte auxiliary buffer for uint encoding
-}
-
 type listhead struct {
 	offset int // index of this header in string data
 	size   int // total size of encoded data (including list headers)
@@ -157,19 +123,22 @@ func puthead(buf []byte, smalltag, largetag byte, size uint64) int {
 	return sizesize + 1
 }
 
+type encbuf struct {
+	str     []byte     // string data, contains everything except list headers
+	lheads  []listhead // all list headers
+	lhsize  int        // sum of sizes of all encoded list headers
+	sizebuf [9]byte    // auxiliary buffer for uint encoding
+}
+
 // encbufs are pooled.
 var encbufPool = sync.Pool{
-	New: func() interface{} { return &encbuf{sizebuf: make([]byte, 9)} },
+	New: func() interface{} { return new(encbuf) },
 }
 
 func (w *encbuf) reset() {
 	w.lhsize = 0
-	if w.str != nil {
-		w.str = w.str[:0]
-	}
-	if w.lheads != nil {
-		w.lheads = w.lheads[:0]
-	}
+	w.str = w.str[:0]
+	w.lheads = w.lheads[:0]
 }
 
 // encbuf implements io.Writer so it can be passed it into EncodeRLP.
@@ -180,18 +149,17 @@ func (w *encbuf) Write(b []byte) (int, error) {
 
 func (w *encbuf) encode(val interface{}) error {
 	rval := reflect.ValueOf(val)
-	ti, err := cachedTypeInfo(rval.Type(), tags{})
+	writer, err := cachedWriter(rval.Type())
 	if err != nil {
 		return err
 	}
-	return ti.writer(rval, w)
+	return writer(rval, w)
 }
 
 func (w *encbuf) encodeStringHeader(size int) {
 	if size < 56 {
 		w.str = append(w.str, 0x80+byte(size))
 	} else {
-		// TODO: encode to w.str directly
 		sizesize := putint(w.sizebuf[1:], uint64(size))
 		w.sizebuf[0] = 0xB7 + byte(sizesize)
 		w.str = append(w.str, w.sizebuf[:sizesize+1]...)
@@ -208,13 +176,29 @@ func (w *encbuf) encodeString(b []byte) {
 	}
 }
 
-func (w *encbuf) list() *listhead {
-	lh := &listhead{offset: len(w.str), size: w.lhsize}
-	w.lheads = append(w.lheads, lh)
-	return lh
+func (w *encbuf) encodeUint(i uint64) {
+	if i == 0 {
+		w.str = append(w.str, 0x80)
+	} else if i < 128 {
+		// fits single byte
+		w.str = append(w.str, byte(i))
+	} else {
+		s := putint(w.sizebuf[1:], i)
+		w.sizebuf[0] = 0x80 + byte(s)
+		w.str = append(w.str, w.sizebuf[:s+1]...)
+	}
 }
 
-func (w *encbuf) listEnd(lh *listhead) {
+// list adds a new list header to the header stack. It returns the index
+// of the header. The caller must call listEnd with this index after encoding
+// the content of the list.
+func (w *encbuf) list() int {
+	w.lheads = append(w.lheads, listhead{offset: len(w.str), size: w.lhsize})
+	return len(w.lheads) - 1
+}
+
+func (w *encbuf) listEnd(index int) {
+	lh := &w.lheads[index]
 	lh.size = w.size() - lh.offset - lh.size
 	if lh.size < 56 {
 		w.lhsize++ // length encoded into kind tag
@@ -257,7 +241,7 @@ func (w *encbuf) toWriter(out io.Writer) (err error) {
 			}
 		}
 		// write the header
-		enc := head.encode(w.sizebuf)
+		enc := head.encode(w.sizebuf[:])
 		if _, err = out.Write(enc); err != nil {
 			return err
 		}
@@ -323,7 +307,7 @@ func (r *encReader) next() []byte {
 			return p
 		}
 		r.lhpos++
-		return head.encode(r.buf.sizebuf)
+		return head.encode(r.buf.sizebuf[:])
 
 	case r.strpos < len(r.buf.str):
 		// String data at the end, after all list headers.
@@ -336,10 +320,7 @@ func (r *encReader) next() []byte {
 	}
 }
 
-var (
-	encoderInterface = reflect.TypeOf(new(Encoder)).Elem()
-	big0             = big.NewInt(0)
-)
+var encoderInterface = reflect.TypeOf(new(Encoder)).Elem()
 
 // makeWriter creates a writer function for the given type.
 func makeWriter(typ reflect.Type, ts tags) (writer, error) {
@@ -347,16 +328,14 @@ func makeWriter(typ reflect.Type, ts tags) (writer, error) {
 	switch {
 	case typ == rawValueType:
 		return writeRawValue, nil
-	case typ.Implements(encoderInterface):
-		return writeEncoder, nil
-	case kind != reflect.Ptr && reflect.PtrTo(typ).Implements(encoderInterface):
-		return writeEncoderNoPtr, nil
-	case kind == reflect.Interface:
-		return writeInterface, nil
 	case typ.AssignableTo(reflect.PtrTo(bigInt)):
 		return writeBigIntPtr, nil
 	case typ.AssignableTo(bigInt):
 		return writeBigIntNoPtr, nil
+	case kind == reflect.Ptr:
+		return makePtrWriter(typ, ts)
+	case reflect.PtrTo(typ).Implements(encoderInterface):
+		return makeEncoderWriter(typ), nil
 	case isUint(kind):
 		return writeUint, nil
 	case kind == reflect.Bool:
@@ -366,40 +345,25 @@ func makeWriter(typ reflect.Type, ts tags) (writer, error) {
 	case kind == reflect.Slice && isByte(typ.Elem()):
 		return writeBytes, nil
 	case kind == reflect.Array && isByte(typ.Elem()):
-		return writeByteArray, nil
+		return makeByteArrayWriter(typ), nil
 	case kind == reflect.Slice || kind == reflect.Array:
 		return makeSliceWriter(typ, ts)
 	case kind == reflect.Struct:
 		return makeStructWriter(typ)
-	case kind == reflect.Ptr:
-		return makePtrWriter(typ)
+	case kind == reflect.Interface:
+		return writeInterface, nil
 	default:
 		return nil, fmt.Errorf("rlp: type %v is not RLP-serializable", typ)
 	}
 }
 
-func isByte(typ reflect.Type) bool {
-	return typ.Kind() == reflect.Uint8 && !typ.Implements(encoderInterface)
-}
-
 func writeRawValue(val reflect.Value, w *encbuf) error {
 	w.str = append(w.str, val.Bytes()...)
 	return nil
 }
 
 func writeUint(val reflect.Value, w *encbuf) error {
-	i := val.Uint()
-	if i == 0 {
-		w.str = append(w.str, 0x80)
-	} else if i < 128 {
-		// fits single byte
-		w.str = append(w.str, byte(i))
-	} else {
-		// TODO: encode int to w.str directly
-		s := putint(w.sizebuf[1:], i)
-		w.sizebuf[0] = 0x80 + byte(s)
-		w.str = append(w.str, w.sizebuf[:s+1]...)
-	}
+	w.encodeUint(val.Uint())
 	return nil
 }
 
@@ -426,13 +390,32 @@ func writeBigIntNoPtr(val reflect.Value, w *encbuf) error {
 	return writeBigInt(&i, w)
 }
 
+// wordBytes is the number of bytes in a big.Word
+const wordBytes = (32 << (uint64(^big.Word(0)) >> 63)) / 8
+
 func writeBigInt(i *big.Int, w *encbuf) error {
-	if cmp := i.Cmp(big0); cmp == -1 {
+	if i.Sign() == -1 {
 		return fmt.Errorf("rlp: cannot encode negative *big.Int")
-	} else if cmp == 0 {
-		w.str = append(w.str, 0x80)
-	} else {
-		w.encodeString(i.Bytes())
+	}
+	bitlen := i.BitLen()
+	if bitlen <= 64 {
+		w.encodeUint(i.Uint64())
+		return nil
+	}
+	// Integer is larger than 64 bits, encode from i.Bits().
+	// The minimal byte length is bitlen rounded up to the next
+	// multiple of 8, divided by 8.
+	length := ((bitlen + 7) & -8) >> 3
+	w.encodeStringHeader(length)
+	w.str = append(w.str, make([]byte, length)...)
+	index := length
+	buf := w.str[len(w.str)-length:]
+	for _, d := range i.Bits() {
+		for j := 0; j < wordBytes && index > 0; j++ {
+			index--
+			buf[index] = byte(d)
+			d >>= 8
+		}
 	}
 	return nil
 }
@@ -442,17 +425,44 @@ func writeBytes(val reflect.Value, w *encbuf) error {
 	return nil
 }
 
+func makeByteArrayWriter(typ reflect.Type) writer {
+	switch typ.Len() {
+	case 0:
+		return writeLengthZeroByteArray
+	case 1:
+		return writeLengthOneByteArray
+	default:
+		return writeByteArray
+	}
+}
+
+func writeLengthZeroByteArray(val reflect.Value, w *encbuf) error {
+	w.str = append(w.str, 0x80)
+	return nil
+}
+
+func writeLengthOneByteArray(val reflect.Value, w *encbuf) error {
+	b := byte(val.Index(0).Uint())
+	if b <= 0x7f {
+		w.str = append(w.str, b)
+	} else {
+		w.str = append(w.str, 0x81, b)
+	}
+	return nil
+}
+
 func writeByteArray(val reflect.Value, w *encbuf) error {
 	if !val.CanAddr() {
-		// Slice requires the value to be addressable.
-		// Make it addressable by copying.
+		// Getting the byte slice of val requires it to be addressable. Make it
+		// addressable by copying.
 		copy := reflect.New(val.Type()).Elem()
 		copy.Set(val)
 		val = copy
 	}
-	size := val.Len()
-	slice := val.Slice(0, size).Bytes()
-	w.encodeString(slice)
+
+	slice := byteArrayBytes(val)
+	w.encodeStringHeader(len(slice))
+	w.str = append(w.str, slice...)
 	return nil
 }
 
@@ -468,26 +478,6 @@ func writeString(val reflect.Value, w *encbuf) error {
 	return nil
 }
 
-func writeEncoder(val reflect.Value, w *encbuf) error {
-	return val.Interface().(Encoder).EncodeRLP(w)
-}
-
-// writeEncoderNoPtr handles non-pointer values that implement Encoder
-// with a pointer receiver.
-func writeEncoderNoPtr(val reflect.Value, w *encbuf) error {
-	if !val.CanAddr() {
-		// We can't get the address. It would be possible to make the
-		// value addressable by creating a shallow copy, but this
-		// creates other problems so we're not doing it (yet).
-		//
-		// package json simply doesn't call MarshalJSON for cases like
-		// this, but encodes the value as if it didn't implement the
-		// interface. We don't want to handle it that way.
-		return fmt.Errorf("rlp: game over: unadressable value of type %v, EncodeRLP is pointer method", val.Type())
-	}
-	return val.Addr().Interface().(Encoder).EncodeRLP(w)
-}
-
 func writeInterface(val reflect.Value, w *encbuf) error {
 	if val.IsNil() {
 		// Write empty list. This is consistent with the previous RLP
@@ -497,17 +487,17 @@ func writeInterface(val reflect.Value, w *encbuf) error {
 		return nil
 	}
 	eval := val.Elem()
-	ti, err := cachedTypeInfo(eval.Type(), tags{})
+	writer, err := cachedWriter(eval.Type())
 	if err != nil {
 		return err
 	}
-	return ti.writer(eval, w)
+	return writer(eval, w)
 }
 
 func makeSliceWriter(typ reflect.Type, ts tags) (writer, error) {
-	etypeinfo, err := cachedTypeInfo1(typ.Elem(), tags{})
-	if err != nil {
-		return nil, err
+	etypeinfo := theTC.infoWhileGenerating(typ.Elem(), tags{})
+	if etypeinfo.writerErr != nil {
+		return nil, etypeinfo.writerErr
 	}
 	writer := func(val reflect.Value, w *encbuf) error {
 		if !ts.tail {
@@ -529,55 +519,92 @@ func makeStructWriter(typ reflect.Type) (writer, error) {
 	if err != nil {
 		return nil, err
 	}
-	writer := func(val reflect.Value, w *encbuf) error {
-		lh := w.list()
-		for _, f := range fields {
-			if err := f.info.writer(val.Field(f.index), w); err != nil {
-				return err
-			}
+	for _, f := range fields {
+		if f.info.writerErr != nil {
+			return nil, structFieldError{typ, f.index, f.info.writerErr}
 		}
-		w.listEnd(lh)
-		return nil
-	}
-	return writer, nil
-}
-
-func makePtrWriter(typ reflect.Type) (writer, error) {
-	etypeinfo, err := cachedTypeInfo1(typ.Elem(), tags{})
-	if err != nil {
-		return nil, err
 	}
 
-	// determine nil pointer handler
-	var nilfunc func(*encbuf) error
-	kind := typ.Elem().Kind()
-	switch {
-	case kind == reflect.Array && isByte(typ.Elem().Elem()):
-		nilfunc = func(w *encbuf) error {
-			w.str = append(w.str, 0x80)
+	var writer writer
+	firstOptionalField := firstOptionalField(fields)
+	if firstOptionalField == len(fields) {
+		// This is the writer function for structs without any optional fields.
+		writer = func(val reflect.Value, w *encbuf) error {
+			lh := w.list()
+			for _, f := range fields {
+				if err := f.info.writer(val.Field(f.index), w); err != nil {
+					return err
+				}
+			}
+			w.listEnd(lh)
 			return nil
 		}
-	case kind == reflect.Struct || kind == reflect.Array:
-		nilfunc = func(w *encbuf) error {
-			// encoding the zero value of a struct/array could trigger
-			// infinite recursion, avoid that.
-			w.listEnd(w.list())
+	} else {
+		// If there are any "optional" fields, the writer needs to perform additional
+		// checks to determine the output list length.
+		writer = func(val reflect.Value, w *encbuf) error {
+			lastField := len(fields) - 1
+			for ; lastField >= firstOptionalField; lastField-- {
+				if !val.Field(fields[lastField].index).IsZero() {
+					break
+				}
+			}
+			lh := w.list()
+			for i := 0; i <= lastField; i++ {
+				if err := fields[i].info.writer(val.Field(fields[i].index), w); err != nil {
+					return err
+				}
+			}
+			w.listEnd(lh)
 			return nil
 		}
-	default:
-		zero := reflect.Zero(typ.Elem())
-		nilfunc = func(w *encbuf) error {
-			return etypeinfo.writer(zero, w)
-		}
+	}
+	return writer, nil
+}
+
+func makePtrWriter(typ reflect.Type, ts tags) (writer, error) {
+	etypeinfo := theTC.infoWhileGenerating(typ.Elem(), tags{})
+	if etypeinfo.writerErr != nil {
+		return nil, etypeinfo.writerErr
+	}
+	// Determine how to encode nil pointers.
+	var nilKind Kind
+	if ts.nilOK {
+		nilKind = ts.nilKind // use struct tag if provided
+	} else {
+		nilKind = defaultNilKind(typ.Elem())
 	}
 
 	writer := func(val reflect.Value, w *encbuf) error {
 		if val.IsNil() {
-			return nilfunc(w)
+			if nilKind == String {
+				w.str = append(w.str, 0x80)
+			} else {
+				w.listEnd(w.list())
+			}
+			return nil
 		}
 		return etypeinfo.writer(val.Elem(), w)
 	}
-	return writer, err
+	return writer, nil
+}
+
+func makeEncoderWriter(typ reflect.Type) writer {
+	if typ.Implements(encoderInterface) {
+		return func(val reflect.Value, w *encbuf) error {
+			return val.Interface().(Encoder).EncodeRLP(w)
+		}
+	}
+	w := func(val reflect.Value, w *encbuf) error {
+		if !val.CanAddr() {
+			// package json simply doesn't call MarshalJSON for this case, but encodes the
+			// value as if it didn't implement the interface. We don't want to handle it that
+			// way.
+			return fmt.Errorf("rlp: unadressable value of type %v, EncodeRLP is pointer method", val.Type())
+		}
+		return val.Addr().Interface().(Encoder).EncodeRLP(w)
+	}
+	return w
 }
 
 // putint writes i to the beginning of b in big endian byte
diff --git a/rlp/iterator.go b/rlp/iterator.go
new file mode 100644
index 000000000..559e03a86
--- /dev/null
+++ b/rlp/iterator.go
@@ -0,0 +1,61 @@
+// Copyright 2019 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package rlp
+
+type listIterator struct {
+	data []byte
+	next []byte
+	err  error
+}
+
+// NewListIterator creates an iterator for the (list) represented by data
+// TODO: Consider removing this implementation, as it is no longer used.
+func NewListIterator(data RawValue) (*listIterator, error) {
+	k, t, c, err := readKind(data)
+	if err != nil {
+		return nil, err
+	}
+	if k != List {
+		return nil, ErrExpectedList
+	}
+	it := &listIterator{
+		data: data[t : t+c],
+	}
+	return it, nil
+
+}
+
+// Next forwards the iterator one step, returns true if it was not at end yet
+func (it *listIterator) Next() bool {
+	if len(it.data) == 0 {
+		return false
+	}
+	_, t, c, err := readKind(it.data)
+	it.next = it.data[:t+c]
+	it.data = it.data[t+c:]
+	it.err = err
+	return true
+}
+
+// Value returns the current value
+func (it *listIterator) Value() []byte {
+	return it.next
+}
+
+func (it *listIterator) Err() error {
+	return it.err
+}
diff --git a/rlp/typecache.go b/rlp/typecache.go
index 8c2dd518e..62553d3b5 100644
--- a/rlp/typecache.go
+++ b/rlp/typecache.go
@@ -21,34 +21,40 @@ import (
 	"reflect"
 	"strings"
 	"sync"
+	"sync/atomic"
 )
 
-var (
-	typeCacheMutex sync.RWMutex
-	typeCache      = make(map[typekey]*typeinfo)
-)
-
+// typeinfo is an entry in the type cache.
 type typeinfo struct {
-	decoder
-	writer
+	decoder    decoder
+	decoderErr error // error from makeDecoder
+	writer     writer
+	writerErr  error // error from makeWriter
 }
 
-// represents struct tags
+// tags represents struct tags.
 type tags struct {
 	// rlp:"nil" controls whether empty input results in a nil pointer.
-	nilOK bool
-	// rlp:"tail" controls whether this field swallows additional list
-	// elements. It can only be set for the last field, which must be
-	// of slice type.
+	// nilKind is the kind of empty value allowed for the field.
+	nilKind Kind
+	nilOK   bool
+
+	// rlp:"optional" allows for a field to be missing in the input list.
+	// If this is set, all subsequent fields must also be optional.
+	optional bool
+
+	// rlp:"tail" controls whether this field swallows additional list elements. It can
+	// only be set for the last field, which must be of slice type.
 	tail bool
+
 	// rlp:"-" ignores fields.
 	ignored bool
 }
 
+// typekey is the key of a type in typeCache. It includes the struct tags because
+// they might generate a different decoder.
 type typekey struct {
 	reflect.Type
-	// the key must include the struct tags because they
-	// might generate a different decoder.
 	tags
 }
 
@@ -56,66 +62,146 @@ type decoder func(*Stream, reflect.Value) error
 
 type writer func(reflect.Value, *encbuf) error
 
-func cachedTypeInfo(typ reflect.Type, tags tags) (*typeinfo, error) {
-	typeCacheMutex.RLock()
-	info := typeCache[typekey{typ, tags}]
-	typeCacheMutex.RUnlock()
-	if info != nil {
-		return info, nil
+var theTC = newTypeCache()
+
+type typeCache struct {
+	cur atomic.Value
+
+	// This lock synchronizes writers.
+	mu   sync.Mutex
+	next map[typekey]*typeinfo
+}
+
+func newTypeCache() *typeCache {
+	c := new(typeCache)
+	c.cur.Store(make(map[typekey]*typeinfo))
+	return c
+}
+
+func cachedDecoder(typ reflect.Type) (decoder, error) {
+	info := theTC.info(typ)
+	return info.decoder, info.decoderErr
+}
+
+func cachedWriter(typ reflect.Type) (writer, error) {
+	info := theTC.info(typ)
+	return info.writer, info.writerErr
+}
+
+func (c *typeCache) info(typ reflect.Type) *typeinfo {
+	key := typekey{Type: typ}
+	if info := c.cur.Load().(map[typekey]*typeinfo)[key]; info != nil {
+		return info
 	}
-	// not in the cache, need to generate info for this type.
-	typeCacheMutex.Lock()
-	defer typeCacheMutex.Unlock()
-	return cachedTypeInfo1(typ, tags)
+
+	// Not in the cache, need to generate info for this type.
+	return c.generate(typ, tags{})
 }
 
-func cachedTypeInfo1(typ reflect.Type, tags tags) (*typeinfo, error) {
+func (c *typeCache) generate(typ reflect.Type, tags tags) *typeinfo {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	cur := c.cur.Load().(map[typekey]*typeinfo)
+	if info := cur[typekey{typ, tags}]; info != nil {
+		return info
+	}
+
+	// Copy cur to next.
+	c.next = make(map[typekey]*typeinfo, len(cur)+1)
+	for k, v := range cur {
+		c.next[k] = v
+	}
+
+	// Generate.
+	info := c.infoWhileGenerating(typ, tags)
+
+	// next -> cur
+	c.cur.Store(c.next)
+	c.next = nil
+	return info
+}
+
+func (c *typeCache) infoWhileGenerating(typ reflect.Type, tags tags) *typeinfo {
 	key := typekey{typ, tags}
-	info := typeCache[key]
-	if info != nil {
-		// another goroutine got the write lock first
-		return info, nil
+	if info := c.next[key]; info != nil {
+		return info
 	}
-	// put a dummy value into the cache before generating.
-	// if the generator tries to lookup itself, it will get
+	// Put a dummy value into the cache before generating.
+	// If the generator tries to lookup itself, it will get
 	// the dummy value and won't call itself recursively.
-	typeCache[key] = new(typeinfo)
-	info, err := genTypeInfo(typ, tags)
-	if err != nil {
-		// remove the dummy value if the generator fails
-		delete(typeCache, key)
-		return nil, err
-	}
-	*typeCache[key] = *info
-	return typeCache[key], err
+	info := new(typeinfo)
+	c.next[key] = info
+	info.generate(typ, tags)
+	return info
 }
 
 type field struct {
-	index int
-	info  *typeinfo
+	index    int
+	info     *typeinfo
+	optional bool
 }
 
+// structFields resolves the typeinfo of all public fields in a struct type.
 func structFields(typ reflect.Type) (fields []field, err error) {
+	var (
+		lastPublic  = lastPublicField(typ)
+		anyOptional = false
+	)
 	for i := 0; i < typ.NumField(); i++ {
 		if f := typ.Field(i); f.PkgPath == "" { // exported
-			tags, err := parseStructTag(typ, i)
+			tags, err := parseStructTag(typ, i, lastPublic)
 			if err != nil {
 				return nil, err
 			}
+
+			// Skip rlp:"-" fields.
 			if tags.ignored {
 				continue
 			}
-			info, err := cachedTypeInfo1(f.Type, tags)
-			if err != nil {
-				return nil, err
+			// If any field has the "optional" tag, subsequent fields must also have it.
+			if tags.optional || tags.tail {
+				anyOptional = true
+			} else if anyOptional {
+				return nil, fmt.Errorf(`rlp: struct field %v.%s needs "optional" tag`, typ, f.Name)
 			}
-			fields = append(fields, field{i, info})
+			info := theTC.infoWhileGenerating(f.Type, tags)
+			fields = append(fields, field{i, info, tags.optional})
 		}
 	}
 	return fields, nil
 }
 
-func parseStructTag(typ reflect.Type, fi int) (tags, error) {
+// anyOptionalFields returns the index of the first field with "optional" tag.
+func firstOptionalField(fields []field) int {
+	for i, f := range fields {
+		if f.optional {
+			return i
+		}
+	}
+	return len(fields)
+}
+
+type structFieldError struct {
+	typ   reflect.Type
+	field int
+	err   error
+}
+
+func (e structFieldError) Error() string {
+	return fmt.Sprintf("%v (struct field %v.%s)", e.err, e.typ, e.typ.Field(e.field).Name)
+}
+
+type structTagError struct {
+	typ             reflect.Type
+	field, tag, err string
+}
+
+func (e structTagError) Error() string {
+	return fmt.Sprintf("rlp: invalid struct tag %q for %v.%s (%s)", e.tag, e.typ, e.field, e.err)
+}
+
+func parseStructTag(typ reflect.Type, fi, lastPublic int) (tags, error) {
 	f := typ.Field(fi)
 	var ts tags
 	for _, t := range strings.Split(f.Tag.Get("rlp"), ",") {
@@ -123,15 +209,34 @@ func parseStructTag(typ reflect.Type, fi int) (tags, error) {
 		case "":
 		case "-":
 			ts.ignored = true
-		case "nil":
+		case "nil", "nilString", "nilList":
 			ts.nilOK = true
+			if f.Type.Kind() != reflect.Ptr {
+				return ts, structTagError{typ, f.Name, t, "field is not a pointer"}
+			}
+			switch t {
+			case "nil":
+				ts.nilKind = defaultNilKind(f.Type.Elem())
+			case "nilString":
+				ts.nilKind = String
+			case "nilList":
+				ts.nilKind = List
+			}
+		case "optional":
+			ts.optional = true
+			if ts.tail {
+				return ts, structTagError{typ, f.Name, t, `also has "tail" tag`}
+			}
 		case "tail":
 			ts.tail = true
-			if fi != typ.NumField()-1 {
-				return ts, fmt.Errorf(`rlp: invalid struct tag "tail" for %v.%s (must be on last field)`, typ, f.Name)
+			if fi != lastPublic {
+				return ts, structTagError{typ, f.Name, t, "must be on last field"}
+			}
+			if ts.optional {
+				return ts, structTagError{typ, f.Name, t, `also has "optional" tag`}
 			}
 			if f.Type.Kind() != reflect.Slice {
-				return ts, fmt.Errorf(`rlp: invalid struct tag "tail" for %v.%s (field type is not slice)`, typ, f.Name)
+				return ts, structTagError{typ, f.Name, t, "field type is not slice"}
 			}
 		default:
 			return ts, fmt.Errorf("rlp: unknown struct tag %q on %v.%s", t, typ, f.Name)
@@ -140,17 +245,39 @@ func parseStructTag(typ reflect.Type, fi int) (tags, error) {
 	return ts, nil
 }
 
-func genTypeInfo(typ reflect.Type, tags tags) (info *typeinfo, err error) {
-	info = new(typeinfo)
-	if info.decoder, err = makeDecoder(typ, tags); err != nil {
-		return nil, err
+func lastPublicField(typ reflect.Type) int {
+	last := 0
+	for i := 0; i < typ.NumField(); i++ {
+		if typ.Field(i).PkgPath == "" {
+			last = i
+		}
 	}
-	if info.writer, err = makeWriter(typ, tags); err != nil {
-		return nil, err
+	return last
+}
+
+func (i *typeinfo) generate(typ reflect.Type, tags tags) {
+	i.decoder, i.decoderErr = makeDecoder(typ, tags)
+	i.writer, i.writerErr = makeWriter(typ, tags)
+}
+
+// defaultNilKind determines whether a nil pointer to typ encodes/decodes
+// as an empty string or empty list.
+func defaultNilKind(typ reflect.Type) Kind {
+	k := typ.Kind()
+	if isUint(k) || k == reflect.String || k == reflect.Bool || isByteArray(typ) {
+		return String
 	}
-	return info, nil
+	return List
 }
 
 func isUint(k reflect.Kind) bool {
 	return k >= reflect.Uint && k <= reflect.Uintptr
 }
+
+func isByte(typ reflect.Type) bool {
+	return typ.Kind() == reflect.Uint8 && !typ.Implements(encoderInterface)
+}
+
+func isByteArray(typ reflect.Type) bool {
+	return (typ.Kind() == reflect.Slice || typ.Kind() == reflect.Array) && isByte(typ.Elem())
+}
diff --git a/rlp/unsafe.go b/rlp/unsafe.go
new file mode 100644
index 000000000..94ed5405a
--- /dev/null
+++ b/rlp/unsafe.go
@@ -0,0 +1,35 @@
+// Copyright 2021 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+// +build !nacl,!js,cgo
+
+package rlp
+
+import (
+	"reflect"
+	"unsafe"
+)
+
+// byteArrayBytes returns a slice of the byte array v.
+func byteArrayBytes(v reflect.Value) []byte {
+	len := v.Len()
+	var s []byte
+	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&s))
+	hdr.Data = v.UnsafeAddr()
+	hdr.Cap = len
+	hdr.Len = len
+	return s
+}
diff --git a/signer/core/abihelper.go b/signer/core/abihelper.go
index 9bcd6d25a..b111fa872 100644
--- a/signer/core/abihelper.go
+++ b/signer/core/abihelper.go
@@ -89,11 +89,11 @@ func parseCallData(calldata []byte, abidata string) (*decodedCallData, error) {
 		return nil, err
 	}
 
-	decoded := decodedCallData{signature: method.Sig(), name: method.Name}
+	decoded := decodedCallData{signature: method.Sig, name: method.Name}
 
 	for n, argument := range method.Inputs {
 		if err != nil {
-			return nil, fmt.Errorf("Failed to decode argument %d (signature %v): %v", n, method.Sig(), err)
+			return nil, fmt.Errorf("Failed to decode argument %d (signature %v): %v", n, method.Sig, err)
 		}
 		decodedArg := decodedArgument{
 			soltype: argument,
@@ -118,7 +118,7 @@ func parseCallData(calldata []byte, abidata string) (*decodedCallData, error) {
 	if !bytes.Equal(encoded, argdata) {
 		was := common.Bytes2Hex(encoded)
 		exp := common.Bytes2Hex(argdata)
-		return nil, fmt.Errorf("WARNING: Supplied data is stuffed with extra data. \nWant %s\nHave %s\nfor method %v", exp, was, method.Sig())
+		return nil, fmt.Errorf("WARNING: Supplied data is stuffed with extra data. \nWant %s\nHave %s\nfor method %v", exp, was, method.Sig)
 	}
 	return &decoded, nil
 }
diff --git a/signer/core/api.go b/signer/core/api.go
index 030c2204c..5d8c79b28 100644
--- a/signer/core/api.go
+++ b/signer/core/api.go
@@ -215,14 +215,14 @@ func NewSignerAPI(chainID int64, ksLocation string, noUSB bool, ui SignerUI, abi
 			log.Debug("Ledger support enabled")
 		}
 		// Start a USB hub for Trezor hardware wallets
-		if trezorhub, err := usbwallet.NewTrezorHub(); err != nil {
+		if trezorhub, err := usbwallet.NewTrezorHubWithHID(); err != nil {
 			log.Warn(fmt.Sprintf("Failed to start Trezor hub, disabling: %v", err))
 		} else {
 			backends = append(backends, trezorhub)
 			log.Debug("Trezor support enabled")
 		}
 	}
-	return &SignerAPI{big.NewInt(chainID), accounts.NewManager(backends...), ui, NewValidator(abidb)}
+	return &SignerAPI{big.NewInt(chainID), accounts.NewManager(&accounts.Config{}, backends...), ui, NewValidator(abidb)}
 }
 
 // List returns the set of wallet this signer manages. Each wallet can contain
@@ -395,7 +395,7 @@ func (api *SignerAPI) Sign(ctx context.Context, addr common.MixedcaseAddress, da
 		return nil, err
 	}
 	// Assemble sign the data with the wallet
-	signature, err := wallet.SignHashWithPassphrase(account, res.Password, sighash)
+	signature, err := wallet.SignTextWithPassphrase(account, res.Password, sighash)
 	if err != nil {
 		api.UI.ShowError(err.Error())
 		return nil, err
diff --git a/vendor/bazil.org/fuse/fuse.iml b/vendor/bazil.org/fuse/fuse.iml
deleted file mode 100644
index 792ad4c30..000000000
--- a/vendor/bazil.org/fuse/fuse.iml
+++ /dev/null
@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="GO_MODULE" version="4">
-  <component name="NewModuleRootManager" inherit-compiler-output="true">
-    <exclude-output />
-    <content url="file://$MODULE_DIR$" />
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>
\ No newline at end of file
diff --git a/vendor/github.com/golang/protobuf/.github/ISSUE_TEMPLATE/bug_report.md b/vendor/github.com/golang/protobuf/.github/ISSUE_TEMPLATE/bug_report.md
new file mode 100644
index 000000000..cb9fc37c8
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/.github/ISSUE_TEMPLATE/bug_report.md
@@ -0,0 +1,20 @@
+---
+name: Bug report
+about: Create a report to help us improve
+
+---
+
+**What version of protobuf and what language are you using?**
+Version: (e.g., `v1.1.0`, `89a0c16f`, etc)
+
+**What did you do?**
+If possible, provide a recipe for reproducing the error.
+A complete runnable program is good with `.proto` and `.go` source code.
+
+**What did you expect to see?**
+
+**What did you see instead?**
+
+Make sure you include information that can help us debug (full error message, exception listing, stack trace, logs).
+
+**Anything else we should know about your project / environment?**
diff --git a/vendor/github.com/golang/protobuf/.github/ISSUE_TEMPLATE/feature_request.md b/vendor/github.com/golang/protobuf/.github/ISSUE_TEMPLATE/feature_request.md
new file mode 100644
index 000000000..b904f1f84
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/.github/ISSUE_TEMPLATE/feature_request.md
@@ -0,0 +1,17 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is.
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.
diff --git a/vendor/github.com/golang/protobuf/.github/ISSUE_TEMPLATE/question.md b/vendor/github.com/golang/protobuf/.github/ISSUE_TEMPLATE/question.md
new file mode 100644
index 000000000..bfa6ddea8
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/.github/ISSUE_TEMPLATE/question.md
@@ -0,0 +1,7 @@
+---
+name: Question
+about: Questions and troubleshooting
+
+---
+
+
diff --git a/vendor/github.com/golang/protobuf/.gitignore b/vendor/github.com/golang/protobuf/.gitignore
new file mode 100644
index 000000000..5c986d1c5
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/.gitignore
@@ -0,0 +1,3 @@
+.cache
+vendor
+cmd/protoc-gen-go/protoc-gen-go
diff --git a/vendor/github.com/golang/protobuf/.travis.yml b/vendor/github.com/golang/protobuf/.travis.yml
new file mode 100644
index 000000000..0b5166678
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/.travis.yml
@@ -0,0 +1,22 @@
+language: go
+before_install:
+  - mkdir /tmp/go1.12
+  - curl -L -s https://dl.google.com/go/go1.12.linux-amd64.tar.gz | tar -zxf - -C /tmp/go1.12 --strip-components 1
+  - unset GOROOT
+  - (GO111MODULE=on /tmp/go1.12/bin/go mod vendor)
+matrix:
+  include:
+    - go: 1.9.x
+      script: go test -tags protolegacy -v ./...
+    - go: 1.10.x
+      script: go test -tags protolegacy -v ./...
+    - go: 1.11.x
+      script: go test -tags protolegacy -v ./...
+    - go: 1.12.x
+      script: go test -tags protolegacy -v ./...
+    - go: 1.13.x
+      script: go test -tags protolegacy -v ./...
+    - go: 1.14.x
+      script: go test -tags protolegacy -v ./...
+    - go: 1.15.x
+      script: ./test.bash
diff --git a/vendor/github.com/golang/protobuf/CONTRIBUTING.md b/vendor/github.com/golang/protobuf/CONTRIBUTING.md
new file mode 100644
index 000000000..83971cbbf
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/CONTRIBUTING.md
@@ -0,0 +1,30 @@
+# Contributing to Go Protocol Buffers
+
+Go protocol buffers is an open source project and accepts contributions.
+
+This project is the first major version of Go protobufs,
+while the next major revision of this project is located at
+[protocolbuffers/protobuf-go](https://github.com/protocolbuffers/protobuf-go).
+Most new development effort is focused on the latter project,
+and changes to this project is primarily reserved for bug fixes.
+
+
+## Contributor License Agreement
+
+Contributions to this project must be accompanied by a Contributor License
+Agreement. You (or your employer) retain the copyright to your contribution,
+this simply gives us permission to use and redistribute your contributions as
+part of the project. Head over to <https://cla.developers.google.com/> to see
+your current agreements on file or to sign a new one.
+
+You generally only need to submit a CLA once, so if you've already submitted one
+(even if it was for a different project), you probably don't need to do it
+again.
+
+
+## Code reviews
+
+All submissions, including submissions by project members, require review. We
+use GitHub pull requests for this purpose. Consult
+[GitHub Help](https://help.github.com/articles/about-pull-requests/) for more
+information on using pull requests.
diff --git a/vendor/github.com/golang/protobuf/Makefile b/vendor/github.com/golang/protobuf/Makefile
deleted file mode 100644
index 2bc2621aa..000000000
--- a/vendor/github.com/golang/protobuf/Makefile
+++ /dev/null
@@ -1,48 +0,0 @@
-# Go support for Protocol Buffers - Google's data interchange format
-#
-# Copyright 2010 The Go Authors.  All rights reserved.
-# https://github.com/golang/protobuf
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-#     * Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above
-# copyright notice, this list of conditions and the following disclaimer
-# in the documentation and/or other materials provided with the
-# distribution.
-#     * Neither the name of Google Inc. nor the names of its
-# contributors may be used to endorse or promote products derived from
-# this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-all:	install
-
-install:
-	go install ./proto ./jsonpb ./ptypes ./protoc-gen-go
-
-test:
-	go test ./... ./protoc-gen-go/testdata
-	make -C conformance test
-
-clean:
-	go clean ./...
-
-nuke:
-	go clean -i ./...
-
-regenerate:
-	./regenerate.sh
diff --git a/vendor/github.com/golang/protobuf/README.md b/vendor/github.com/golang/protobuf/README.md
index 2a5670b1c..2e4233f20 100644
--- a/vendor/github.com/golang/protobuf/README.md
+++ b/vendor/github.com/golang/protobuf/README.md
@@ -1,285 +1,122 @@
-# Go support for Protocol Buffers - Google's data interchange format
+# Go support for Protocol Buffers
 
+[![GoDev](https://img.shields.io/static/v1?label=godev&message=reference&color=00add8)](https://pkg.go.dev/mod/github.com/golang/protobuf)
 [![Build Status](https://travis-ci.org/golang/protobuf.svg?branch=master)](https://travis-ci.org/golang/protobuf)
-[![GoDoc](https://godoc.org/github.com/golang/protobuf?status.svg)](https://godoc.org/github.com/golang/protobuf)
 
-Google's data interchange format.
-Copyright 2010 The Go Authors.
-https://github.com/golang/protobuf
-
-truechain use protobuf version is libprotoc 3.5.1
-
-This package and the code it generates requires at least Go 1.6.
-
-This software implements Go bindings for protocol buffers.  For
-information about protocol buffers themselves, see
-	https://developers.google.com/protocol-buffers/
-
-## Installation ##
-
-To use this software, you must:
-- Install the standard C++ implementation of protocol buffers from
-	https://developers.google.com/protocol-buffers/
-- Of course, install the Go compiler and tools from
-	https://golang.org/
-  See
-	https://golang.org/doc/install
-  for details or, if you are using gccgo, follow the instructions at
-	https://golang.org/doc/install/gccgo
-- Grab the code from the repository and install the proto package.
-  The simplest way is to run `go get -u github.com/golang/protobuf/protoc-gen-go`.
-  The compiler plugin, protoc-gen-go, will be installed in $GOBIN,
-  defaulting to $GOPATH/bin.  It must be in your $PATH for the protocol
-  compiler, protoc, to find it.
-
-This software has two parts: a 'protocol compiler plugin' that
-generates Go source files that, once compiled, can access and manage
-protocol buffers; and a library that implements run-time support for
-encoding (marshaling), decoding (unmarshaling), and accessing protocol
-buffers.
-
-There is support for gRPC in Go using protocol buffers.
-See the note at the bottom of this file for details.
-
-There are no insertion points in the plugin.
-
-
-## Using protocol buffers with Go ##
-
-Once the software is installed, there are two steps to using it.
-First you must compile the protocol buffer definitions and then import
-them, with the support library, into your program.
-
-To compile the protocol buffer definition, run protoc with the --go_out
-parameter set to the directory you want to output the Go code to.
-
-	protoc --go_out=. *.proto
-
-The generated files will be suffixed .pb.go.  See the Test code below
-for an example using such a file.
-
-## Packages and input paths ##
-
-The protocol buffer language has a concept of "packages" which does not
-correspond well to the Go notion of packages. In generated Go code,
-each source `.proto` file is associated with a single Go package. The
-name and import path for this package is specified with the `go_package`
-proto option:
-
-	option go_package = "github.com/golang/protobuf/ptypes/any";
-
-The protocol buffer compiler will attempt to derive a package name and
-import path if a `go_package` option is not present, but it is
-best to always specify one explicitly.
-
-There is a one-to-one relationship between source `.proto` files and
-generated `.pb.go` files, but any number of `.pb.go` files may be
-contained in the same Go package.
-
-The output name of a generated file is produced by replacing the
-`.proto` suffix with `.pb.go` (e.g., `foo.proto` produces `foo.pb.go`).
-However, the output directory is selected in one of two ways.  Let
-us say we have `inputs/x.proto` with a `go_package` option of
-`github.com/golang/protobuf/p`. The corresponding output file may
-be:
-
-- Relative to the import path:
-
-	protoc --go_out=. inputs/x.proto
-	# writes ./github.com/golang/protobuf/p/x.pb.go
-
-  (This can work well with `--go_out=$GOPATH`.)
-
-- Relative to the input file:
-
-	protoc --go_out=paths=source_relative:. inputs/x.proto
-	# generate ./inputs/x.pb.go
-
-## Generated code ##
-
-The package comment for the proto library contains text describing
-the interface provided in Go for protocol buffers. Here is an edited
-version.
-
-The proto package converts data structures to and from the
-wire format of protocol buffers.  It works in concert with the
-Go source code generated for .proto files by the protocol compiler.
-
-A summary of the properties of the protocol buffer interface
-for a protocol buffer variable v:
-
-  - Names are turned from camel_case to CamelCase for export.
-  - There are no methods on v to set fields; just treat
-  	them as structure fields.
-  - There are getters that return a field's value if set,
-	and return the field's default value if unset.
-	The getters work even if the receiver is a nil message.
-  - The zero value for a struct is its correct initialization state.
-	All desired fields must be set before marshaling.
-  - A Reset() method will restore a protobuf struct to its zero state.
-  - Non-repeated fields are pointers to the values; nil means unset.
-	That is, optional or required field int32 f becomes F *int32.
-  - Repeated fields are slices.
-  - Helper functions are available to aid the setting of fields.
-	Helpers for getting values are superseded by the
-	GetFoo methods and their use is deprecated.
-		msg.Foo = proto.String("hello") // set field
-  - Constants are defined to hold the default values of all fields that
-	have them.  They have the form Default_StructName_FieldName.
-	Because the getter methods handle defaulted values,
-	direct use of these constants should be rare.
-  - Enums are given type names and maps from names to values.
-	Enum values are prefixed with the enum's type name. Enum types have
-	a String method, and a Enum method to assist in message construction.
-  - Nested groups and enums have type names prefixed with the name of
-  	the surrounding message type.
-  - Extensions are given descriptor names that start with E_,
-	followed by an underscore-delimited list of the nested messages
-	that contain it (if any) followed by the CamelCased name of the
-	extension field itself.  HasExtension, ClearExtension, GetExtension
-	and SetExtension are functions for manipulating extensions.
-  - Oneof field sets are given a single field in their message,
-	with distinguished wrapper types for each possible field value.
-  - Marshal and Unmarshal are functions to encode and decode the wire format.
-
-When the .proto file specifies `syntax="proto3"`, there are some differences:
-
-  - Non-repeated fields of non-message type are values instead of pointers.
-  - Enum types do not get an Enum method.
-
-Consider file test.proto, containing
-
-```proto
-	syntax = "proto2";
-	package example;
-
-	enum FOO { X = 17; };
-
-	message Test {
-	  required string label = 1;
-	  optional int32 type = 2 [default=77];
-	  repeated int64 reps = 3;
-	  optional group OptionalGroup = 4 {
-	    required string RequiredField = 5;
-	  }
-	}
-```
-
-To create and play with a Test object from the example package,
-
-```go
-	package main
-
-	import (
-		"log"
-
-		"github.com/golang/protobuf/proto"
-		"path/to/example"
-	)
-
-	func main() {
-		test := &example.Test {
-			Label: proto.String("hello"),
-			Type:  proto.Int32(17),
-			Reps:  []int64{1, 2, 3},
-			Optionalgroup: &example.Test_OptionalGroup {
-				RequiredField: proto.String("good bye"),
-			},
-		}
-		data, err := proto.Marshal(test)
-		if err != nil {
-			log.Fatal("marshaling error: ", err)
-		}
-		newTest := &example.Test{}
-		err = proto.Unmarshal(data, newTest)
-		if err != nil {
-			log.Fatal("unmarshaling error: ", err)
-		}
-		// Now test and newTest contain the same data.
-		if test.GetLabel() != newTest.GetLabel() {
-			log.Fatalf("data mismatch %q != %q", test.GetLabel(), newTest.GetLabel())
-		}
-		// etc.
-	}
-```
-
-## Parameters ##
-
-To pass extra parameters to the plugin, use a comma-separated
-parameter list separated from the output directory by a colon:
-
-	protoc --go_out=plugins=grpc,import_path=mypackage:. *.proto
-
-- `paths=(import | source_relative)` - specifies how the paths of
-  generated files are structured. See the "Packages and imports paths"
-  section above. The default is `import`.
-- `plugins=plugin1+plugin2` - specifies the list of sub-plugins to
-  load. The only plugin in this repo is `grpc`.
-- `Mfoo/bar.proto=quux/shme` - declares that foo/bar.proto is
-  associated with Go package quux/shme.  This is subject to the
-  import_prefix parameter.
-
-The following parameters are deprecated and should not be used:
-
-- `import_prefix=xxx` - a prefix that is added onto the beginning of
-  all imports.
-- `import_path=foo/bar` - used as the package if no input files
-  declare `go_package`. If it contains slashes, everything up to the
-  rightmost slash is ignored.
-
-## gRPC Support ##
-
-If a proto file specifies RPC services, protoc-gen-go can be instructed to
-generate code compatible with gRPC (http://www.grpc.io/). To do this, pass
-the `plugins` parameter to protoc-gen-go; the usual way is to insert it into
-the --go_out argument to protoc:
-
-	protoc --go_out=plugins=grpc:. *.proto
-
-## Compatibility ##
-
-The library and the generated code are expected to be stable over time.
-However, we reserve the right to make breaking changes without notice for the
-following reasons:
-
-- Security. A security issue in the specification or implementation may come to
-  light whose resolution requires breaking compatibility. We reserve the right
-  to address such security issues.
-- Unspecified behavior.  There are some aspects of the Protocol Buffers
-  specification that are undefined.  Programs that depend on such unspecified
-  behavior may break in future releases.
-- Specification errors or changes. If it becomes necessary to address an
-  inconsistency, incompleteness, or change in the Protocol Buffers
-  specification, resolving the issue could affect the meaning or legality of
-  existing programs.  We reserve the right to address such issues, including
-  updating the implementations.
-- Bugs.  If the library has a bug that violates the specification, a program
-  that depends on the buggy behavior may break if the bug is fixed.  We reserve
-  the right to fix such bugs.
-- Adding methods or fields to generated structs.  These may conflict with field
-  names that already exist in a schema, causing applications to break.  When the
-  code generator encounters a field in the schema that would collide with a
-  generated field or method name, the code generator will append an underscore
-  to the generated field or method name.
-- Adding, removing, or changing methods or fields in generated structs that
-  start with `XXX`.  These parts of the generated code are exported out of
-  necessity, but should not be considered part of the public API.
-- Adding, removing, or changing unexported symbols in generated code.
+This module
+([`github.com/golang/protobuf`](https://pkg.go.dev/mod/github.com/golang/protobuf))
+contains Go bindings for protocol buffers.
+
+It has been superseded by the
+[`google.golang.org/protobuf`](https://pkg.go.dev/mod/google.golang.org/protobuf)
+module, which contains an updated and simplified API,
+support for protobuf reflection, and many other improvements.
+We recommend that new code use the `google.golang.org/protobuf` module.
+
+Versions v1.4 and later of `github.com/golang/protobuf` are implemented
+in terms of `google.golang.org/protobuf`.
+Programs which use both modules must use at least version v1.4 of this one.
+
+See the
+[developer guide for protocol buffers in Go](https://developers.google.com/protocol-buffers/docs/gotutorial)
+for a general guide for how to get started using protobufs in Go.
+
+See
+[release note documentation](https://github.com/golang/protobuf/releases)
+for more information about individual releases of this project.
+
+See
+[documentation for the next major revision](https://pkg.go.dev/mod/google.golang.org/protobuf)
+for more information about the purpose, usage, and history of this project.
+
+## Package index
+
+Summary of the packages provided by this module:
+
+*   [`proto`](https://pkg.go.dev/github.com/golang/protobuf/proto): Package
+    `proto` provides functions operating on protobuf messages such as cloning,
+    merging, and checking equality, as well as binary serialization and text
+    serialization.
+*   [`jsonpb`](https://pkg.go.dev/github.com/golang/protobuf/jsonpb): Package
+    `jsonpb` serializes protobuf messages as JSON.
+*   [`ptypes`](https://pkg.go.dev/github.com/golang/protobuf/ptypes): Package
+    `ptypes` provides helper functionality for protobuf well-known types.
+*   [`ptypes/any`](https://pkg.go.dev/github.com/golang/protobuf/ptypes/any):
+    Package `any` is the generated package for `google/protobuf/any.proto`.
+*   [`ptypes/empty`](https://pkg.go.dev/github.com/golang/protobuf/ptypes/empty):
+    Package `empty` is the generated package for `google/protobuf/empty.proto`.
+*   [`ptypes/timestamp`](https://pkg.go.dev/github.com/golang/protobuf/ptypes/timestamp):
+    Package `timestamp` is the generated package for
+    `google/protobuf/timestamp.proto`.
+*   [`ptypes/duration`](https://pkg.go.dev/github.com/golang/protobuf/ptypes/duration):
+    Package `duration` is the generated package for
+    `google/protobuf/duration.proto`.
+*   [`ptypes/wrappers`](https://pkg.go.dev/github.com/golang/protobuf/ptypes/wrappers):
+    Package `wrappers` is the generated package for
+    `google/protobuf/wrappers.proto`.
+*   [`ptypes/struct`](https://pkg.go.dev/github.com/golang/protobuf/ptypes/struct):
+    Package `structpb` is the generated package for
+    `google/protobuf/struct.proto`.
+*   [`protoc-gen-go/descriptor`](https://pkg.go.dev/github.com/golang/protobuf/protoc-gen-go/descriptor):
+    Package `descriptor` is the generated package for
+    `google/protobuf/descriptor.proto`.
+*   [`protoc-gen-go/plugin`](https://pkg.go.dev/github.com/golang/protobuf/protoc-gen-go/plugin):
+    Package `plugin` is the generated package for
+    `google/protobuf/compiler/plugin.proto`.
+*   [`protoc-gen-go`](https://pkg.go.dev/github.com/golang/protobuf/protoc-gen-go):
+    The `protoc-gen-go` binary is a protoc plugin to generate a Go protocol
+    buffer package.
+
+## Reporting issues
+
+The issue tracker for this project
+[is located here](https://github.com/golang/protobuf/issues).
+
+Please report any issues with a sufficient description of the bug or feature
+request. Bug reports should ideally be accompanied by a minimal reproduction of
+the issue. Irreproducible bugs are difficult to diagnose and fix (and likely to
+be closed after some period of time). Bug reports must specify the version of
+the
+[Go protocol buffer module](https://github.com/protocolbuffers/protobuf-go/releases)
+and also the version of the
+[protocol buffer toolchain](https://github.com/protocolbuffers/protobuf/releases)
+being used.
+
+## Contributing
+
+This project is open-source and accepts contributions. See the
+[contribution guide](https://github.com/golang/protobuf/blob/master/CONTRIBUTING.md)
+for more information.
+
+## Compatibility
+
+This module and the generated code are expected to be stable over time. However,
+we reserve the right to make breaking changes without notice for the following
+reasons:
+
+*   **Security:** A security issue in the specification or implementation may
+    come to light whose resolution requires breaking compatibility. We reserve
+    the right to address such issues.
+*   **Unspecified behavior:** There are some aspects of the protocol buffer
+    specification that are undefined. Programs that depend on unspecified
+    behavior may break in future releases.
+*   **Specification changes:** It may become necessary to address an
+    inconsistency, incompleteness, or change in the protocol buffer
+    specification, which may affect the behavior of existing programs. We
+    reserve the right to address such changes.
+*   **Bugs:** If a package has a bug that violates correctness, a program
+    depending on the buggy behavior may break if the bug is fixed. We reserve
+    the right to fix such bugs.
+*   **Generated additions**: We reserve the right to add new declarations to
+    generated Go packages of `.proto` files. This includes declared constants,
+    variables, functions, types, fields in structs, and methods on types. This
+    may break attempts at injecting additional code on top of what is generated
+    by `protoc-gen-go`. Such practice is not supported by this project.
+*   **Internal changes**: We reserve the right to add, modify, and remove
+    internal code, which includes all unexported declarations, the
+    [`generator`](https://pkg.go.dev/github.com/golang/protobuf/protoc-gen-go/generator)
+    package, and all packages under
+    [`internal`](https://pkg.go.dev/github.com/golang/protobuf/internal).
 
 Any breaking changes outside of these will be announced 6 months in advance to
-protobuf@googlegroups.com.
-
-You should, whenever possible, use generated code created by the `protoc-gen-go`
-tool built at the same commit as the `proto` package.  The `proto` package
-declares package-level constants in the form `ProtoPackageIsVersionX`.
-Application code and generated code may depend on one of these constants to
-ensure that compilation will fail if the available version of the proto library
-is too old.  Whenever we make a change to the generated code that requires newer
-library support, in the same commit we will increment the version number of the
-generated code and declare a new package-level constant whose name incorporates
-the latest version number.  Removing a compatibility constant is considered a
-breaking change and would be subject to the announcement policy stated above.
-
-The `protoc-gen-go/generator` package exposes a plugin interface,
-which is used by the gRPC code generation. This interface is not
-supported and is subject to incompatible changes without notice.
+[protobuf@googlegroups.com](https://groups.google.com/forum/#!forum/protobuf).
diff --git a/vendor/github.com/golang/protobuf/conformance/Makefile b/vendor/github.com/golang/protobuf/conformance/Makefile
deleted file mode 100644
index b99e4ed6d..000000000
--- a/vendor/github.com/golang/protobuf/conformance/Makefile
+++ /dev/null
@@ -1,49 +0,0 @@
-# Go support for Protocol Buffers - Google's data interchange format
-#
-# Copyright 2016 The Go Authors.  All rights reserved.
-# https://github.com/golang/protobuf
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-#     * Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above
-# copyright notice, this list of conditions and the following disclaimer
-# in the documentation and/or other materials provided with the
-# distribution.
-#     * Neither the name of Google Inc. nor the names of its
-# contributors may be used to endorse or promote products derived from
-# this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-PROTOBUF_ROOT=$(HOME)/src/protobuf
-
-all:
-	@echo To run the tests in this directory, acquire the main protobuf
-	@echo distribution from:
-	@echo
-	@echo '   https://github.com/google/protobuf'
-	@echo
-	@echo Build the test runner with:
-	@echo
-	@echo '   cd conformance && make conformance-test-runner'
-	@echo
-	@echo And run the tests in this directory with:
-	@echo
-	@echo '   make test PROTOBUF_ROOT=<protobuf distribution>'
-
-test:
-	./test.sh $(PROTOBUF_ROOT)
diff --git a/vendor/github.com/golang/protobuf/conformance/conformance.go b/vendor/github.com/golang/protobuf/conformance/conformance.go
deleted file mode 100644
index 3029312a1..000000000
--- a/vendor/github.com/golang/protobuf/conformance/conformance.go
+++ /dev/null
@@ -1,154 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2016 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// conformance implements the conformance test subprocess protocol as
-// documented in conformance.proto.
-package main
-
-import (
-	"encoding/binary"
-	"fmt"
-	"io"
-	"os"
-
-	pb "github.com/golang/protobuf/conformance/internal/conformance_proto"
-	"github.com/golang/protobuf/jsonpb"
-	"github.com/golang/protobuf/proto"
-)
-
-func main() {
-	var sizeBuf [4]byte
-	inbuf := make([]byte, 0, 4096)
-	outbuf := proto.NewBuffer(nil)
-	for {
-		if _, err := io.ReadFull(os.Stdin, sizeBuf[:]); err == io.EOF {
-			break
-		} else if err != nil {
-			fmt.Fprintln(os.Stderr, "go conformance: read request:", err)
-			os.Exit(1)
-		}
-		size := binary.LittleEndian.Uint32(sizeBuf[:])
-		if int(size) > cap(inbuf) {
-			inbuf = make([]byte, size)
-		}
-		inbuf = inbuf[:size]
-		if _, err := io.ReadFull(os.Stdin, inbuf); err != nil {
-			fmt.Fprintln(os.Stderr, "go conformance: read request:", err)
-			os.Exit(1)
-		}
-
-		req := new(pb.ConformanceRequest)
-		if err := proto.Unmarshal(inbuf, req); err != nil {
-			fmt.Fprintln(os.Stderr, "go conformance: parse request:", err)
-			os.Exit(1)
-		}
-		res := handle(req)
-
-		if err := outbuf.Marshal(res); err != nil {
-			fmt.Fprintln(os.Stderr, "go conformance: marshal response:", err)
-			os.Exit(1)
-		}
-		binary.LittleEndian.PutUint32(sizeBuf[:], uint32(len(outbuf.Bytes())))
-		if _, err := os.Stdout.Write(sizeBuf[:]); err != nil {
-			fmt.Fprintln(os.Stderr, "go conformance: write response:", err)
-			os.Exit(1)
-		}
-		if _, err := os.Stdout.Write(outbuf.Bytes()); err != nil {
-			fmt.Fprintln(os.Stderr, "go conformance: write response:", err)
-			os.Exit(1)
-		}
-		outbuf.Reset()
-	}
-}
-
-var jsonMarshaler = jsonpb.Marshaler{
-	OrigName: true,
-}
-
-func handle(req *pb.ConformanceRequest) *pb.ConformanceResponse {
-	var err error
-	var msg pb.TestAllTypes
-	switch p := req.Payload.(type) {
-	case *pb.ConformanceRequest_ProtobufPayload:
-		err = proto.Unmarshal(p.ProtobufPayload, &msg)
-	case *pb.ConformanceRequest_JsonPayload:
-		err = jsonpb.UnmarshalString(p.JsonPayload, &msg)
-	default:
-		return &pb.ConformanceResponse{
-			Result: &pb.ConformanceResponse_RuntimeError{
-				RuntimeError: "unknown request payload type",
-			},
-		}
-	}
-	if err != nil {
-		return &pb.ConformanceResponse{
-			Result: &pb.ConformanceResponse_ParseError{
-				ParseError: err.Error(),
-			},
-		}
-	}
-	switch req.RequestedOutputFormat {
-	case pb.WireFormat_PROTOBUF:
-		p, err := proto.Marshal(&msg)
-		if err != nil {
-			return &pb.ConformanceResponse{
-				Result: &pb.ConformanceResponse_SerializeError{
-					SerializeError: err.Error(),
-				},
-			}
-		}
-		return &pb.ConformanceResponse{
-			Result: &pb.ConformanceResponse_ProtobufPayload{
-				ProtobufPayload: p,
-			},
-		}
-	case pb.WireFormat_JSON:
-		p, err := jsonMarshaler.MarshalToString(&msg)
-		if err != nil {
-			return &pb.ConformanceResponse{
-				Result: &pb.ConformanceResponse_SerializeError{
-					SerializeError: err.Error(),
-				},
-			}
-		}
-		return &pb.ConformanceResponse{
-			Result: &pb.ConformanceResponse_JsonPayload{
-				JsonPayload: p,
-			},
-		}
-	default:
-		return &pb.ConformanceResponse{
-			Result: &pb.ConformanceResponse_RuntimeError{
-				RuntimeError: "unknown output format",
-			},
-		}
-	}
-}
diff --git a/vendor/github.com/golang/protobuf/conformance/conformance.sh b/vendor/github.com/golang/protobuf/conformance/conformance.sh
deleted file mode 100644
index 8532f5711..000000000
--- a/vendor/github.com/golang/protobuf/conformance/conformance.sh
+++ /dev/null
@@ -1,4 +0,0 @@
-#!/bin/sh
-
-cd $(dirname $0)
-exec go run conformance.go $*
diff --git a/vendor/github.com/golang/protobuf/conformance/failure_list_go.txt b/vendor/github.com/golang/protobuf/conformance/failure_list_go.txt
deleted file mode 100644
index d37280896..000000000
--- a/vendor/github.com/golang/protobuf/conformance/failure_list_go.txt
+++ /dev/null
@@ -1,61 +0,0 @@
-# This is the list of conformance tests that are known ot fail right now.
-# TODO: These should be fixed.
-
-DurationProtoInputTooLarge.JsonOutput
-DurationProtoInputTooSmall.JsonOutput
-FieldMaskNumbersDontRoundTrip.JsonOutput
-FieldMaskPathsDontRoundTrip.JsonOutput
-FieldMaskTooManyUnderscore.JsonOutput
-JsonInput.AnyWithFieldMask.JsonOutput
-JsonInput.AnyWithFieldMask.ProtobufOutput
-JsonInput.DoubleFieldQuotedValue.JsonOutput
-JsonInput.DoubleFieldQuotedValue.ProtobufOutput
-JsonInput.DurationHas3FractionalDigits.Validator
-JsonInput.DurationHas6FractionalDigits.Validator
-JsonInput.DurationHas9FractionalDigits.Validator
-JsonInput.DurationHasZeroFractionalDigit.Validator
-JsonInput.DurationMaxValue.JsonOutput
-JsonInput.DurationMaxValue.ProtobufOutput
-JsonInput.DurationMinValue.JsonOutput
-JsonInput.DurationMinValue.ProtobufOutput
-JsonInput.EnumFieldUnknownValue.Validator
-JsonInput.FieldMask.JsonOutput
-JsonInput.FieldMask.ProtobufOutput
-JsonInput.FieldNameInLowerCamelCase.Validator
-JsonInput.FieldNameWithMixedCases.JsonOutput
-JsonInput.FieldNameWithMixedCases.ProtobufOutput
-JsonInput.FieldNameWithMixedCases.Validator
-JsonInput.FieldNameWithNumbers.Validator
-JsonInput.FloatFieldQuotedValue.JsonOutput
-JsonInput.FloatFieldQuotedValue.ProtobufOutput
-JsonInput.Int32FieldExponentialFormat.JsonOutput
-JsonInput.Int32FieldExponentialFormat.ProtobufOutput
-JsonInput.Int32FieldFloatTrailingZero.JsonOutput
-JsonInput.Int32FieldFloatTrailingZero.ProtobufOutput
-JsonInput.Int32FieldMaxFloatValue.JsonOutput
-JsonInput.Int32FieldMaxFloatValue.ProtobufOutput
-JsonInput.Int32FieldMinFloatValue.JsonOutput
-JsonInput.Int32FieldMinFloatValue.ProtobufOutput
-JsonInput.Int32FieldStringValue.JsonOutput
-JsonInput.Int32FieldStringValue.ProtobufOutput
-JsonInput.Int32FieldStringValueEscaped.JsonOutput
-JsonInput.Int32FieldStringValueEscaped.ProtobufOutput
-JsonInput.Int64FieldBeString.Validator
-JsonInput.MapFieldValueIsNull
-JsonInput.OneofFieldDuplicate
-JsonInput.RepeatedFieldMessageElementIsNull
-JsonInput.RepeatedFieldPrimitiveElementIsNull
-JsonInput.StringFieldSurrogateInWrongOrder
-JsonInput.StringFieldUnpairedHighSurrogate
-JsonInput.StringFieldUnpairedLowSurrogate
-JsonInput.TimestampHas3FractionalDigits.Validator
-JsonInput.TimestampHas6FractionalDigits.Validator
-JsonInput.TimestampHas9FractionalDigits.Validator
-JsonInput.TimestampHasZeroFractionalDigit.Validator
-JsonInput.TimestampJsonInputTooSmall
-JsonInput.TimestampZeroNormalized.Validator
-JsonInput.Uint32FieldMaxFloatValue.JsonOutput
-JsonInput.Uint32FieldMaxFloatValue.ProtobufOutput
-JsonInput.Uint64FieldBeString.Validator
-TimestampProtoInputTooLarge.JsonOutput
-TimestampProtoInputTooSmall.JsonOutput
diff --git a/vendor/github.com/golang/protobuf/conformance/internal/conformance_proto/conformance.pb.go b/vendor/github.com/golang/protobuf/conformance/internal/conformance_proto/conformance.pb.go
deleted file mode 100644
index 82d454120..000000000
--- a/vendor/github.com/golang/protobuf/conformance/internal/conformance_proto/conformance.pb.go
+++ /dev/null
@@ -1,1816 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: conformance.proto
-
-package conformance
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-import any "github.com/golang/protobuf/ptypes/any"
-import duration "github.com/golang/protobuf/ptypes/duration"
-import _struct "github.com/golang/protobuf/ptypes/struct"
-import timestamp "github.com/golang/protobuf/ptypes/timestamp"
-import wrappers "github.com/golang/protobuf/ptypes/wrappers"
-import field_mask "google.golang.org/genproto/protobuf/field_mask"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-type WireFormat int32
-
-const (
-	WireFormat_UNSPECIFIED WireFormat = 0
-	WireFormat_PROTOBUF    WireFormat = 1
-	WireFormat_JSON        WireFormat = 2
-)
-
-var WireFormat_name = map[int32]string{
-	0: "UNSPECIFIED",
-	1: "PROTOBUF",
-	2: "JSON",
-}
-var WireFormat_value = map[string]int32{
-	"UNSPECIFIED": 0,
-	"PROTOBUF":    1,
-	"JSON":        2,
-}
-
-func (x WireFormat) String() string {
-	return proto.EnumName(WireFormat_name, int32(x))
-}
-func (WireFormat) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_conformance_48ac832451f5d6c3, []int{0}
-}
-
-type ForeignEnum int32
-
-const (
-	ForeignEnum_FOREIGN_FOO ForeignEnum = 0
-	ForeignEnum_FOREIGN_BAR ForeignEnum = 1
-	ForeignEnum_FOREIGN_BAZ ForeignEnum = 2
-)
-
-var ForeignEnum_name = map[int32]string{
-	0: "FOREIGN_FOO",
-	1: "FOREIGN_BAR",
-	2: "FOREIGN_BAZ",
-}
-var ForeignEnum_value = map[string]int32{
-	"FOREIGN_FOO": 0,
-	"FOREIGN_BAR": 1,
-	"FOREIGN_BAZ": 2,
-}
-
-func (x ForeignEnum) String() string {
-	return proto.EnumName(ForeignEnum_name, int32(x))
-}
-func (ForeignEnum) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_conformance_48ac832451f5d6c3, []int{1}
-}
-
-type TestAllTypes_NestedEnum int32
-
-const (
-	TestAllTypes_FOO TestAllTypes_NestedEnum = 0
-	TestAllTypes_BAR TestAllTypes_NestedEnum = 1
-	TestAllTypes_BAZ TestAllTypes_NestedEnum = 2
-	TestAllTypes_NEG TestAllTypes_NestedEnum = -1
-)
-
-var TestAllTypes_NestedEnum_name = map[int32]string{
-	0:  "FOO",
-	1:  "BAR",
-	2:  "BAZ",
-	-1: "NEG",
-}
-var TestAllTypes_NestedEnum_value = map[string]int32{
-	"FOO": 0,
-	"BAR": 1,
-	"BAZ": 2,
-	"NEG": -1,
-}
-
-func (x TestAllTypes_NestedEnum) String() string {
-	return proto.EnumName(TestAllTypes_NestedEnum_name, int32(x))
-}
-func (TestAllTypes_NestedEnum) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_conformance_48ac832451f5d6c3, []int{2, 0}
-}
-
-// Represents a single test case's input.  The testee should:
-//
-//   1. parse this proto (which should always succeed)
-//   2. parse the protobuf or JSON payload in "payload" (which may fail)
-//   3. if the parse succeeded, serialize the message in the requested format.
-type ConformanceRequest struct {
-	// The payload (whether protobuf of JSON) is always for a TestAllTypes proto
-	// (see below).
-	//
-	// Types that are valid to be assigned to Payload:
-	//	*ConformanceRequest_ProtobufPayload
-	//	*ConformanceRequest_JsonPayload
-	Payload isConformanceRequest_Payload `protobuf_oneof:"payload"`
-	// Which format should the testee serialize its message to?
-	RequestedOutputFormat WireFormat `protobuf:"varint,3,opt,name=requested_output_format,json=requestedOutputFormat,enum=conformance.WireFormat" json:"requested_output_format,omitempty"`
-	XXX_NoUnkeyedLiteral  struct{}   `json:"-"`
-	XXX_unrecognized      []byte     `json:"-"`
-	XXX_sizecache         int32      `json:"-"`
-}
-
-func (m *ConformanceRequest) Reset()         { *m = ConformanceRequest{} }
-func (m *ConformanceRequest) String() string { return proto.CompactTextString(m) }
-func (*ConformanceRequest) ProtoMessage()    {}
-func (*ConformanceRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_conformance_48ac832451f5d6c3, []int{0}
-}
-func (m *ConformanceRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ConformanceRequest.Unmarshal(m, b)
-}
-func (m *ConformanceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ConformanceRequest.Marshal(b, m, deterministic)
-}
-func (dst *ConformanceRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ConformanceRequest.Merge(dst, src)
-}
-func (m *ConformanceRequest) XXX_Size() int {
-	return xxx_messageInfo_ConformanceRequest.Size(m)
-}
-func (m *ConformanceRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_ConformanceRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ConformanceRequest proto.InternalMessageInfo
-
-type isConformanceRequest_Payload interface {
-	isConformanceRequest_Payload()
-}
-
-type ConformanceRequest_ProtobufPayload struct {
-	ProtobufPayload []byte `protobuf:"bytes,1,opt,name=protobuf_payload,json=protobufPayload,proto3,oneof"`
-}
-type ConformanceRequest_JsonPayload struct {
-	JsonPayload string `protobuf:"bytes,2,opt,name=json_payload,json=jsonPayload,oneof"`
-}
-
-func (*ConformanceRequest_ProtobufPayload) isConformanceRequest_Payload() {}
-func (*ConformanceRequest_JsonPayload) isConformanceRequest_Payload()     {}
-
-func (m *ConformanceRequest) GetPayload() isConformanceRequest_Payload {
-	if m != nil {
-		return m.Payload
-	}
-	return nil
-}
-
-func (m *ConformanceRequest) GetProtobufPayload() []byte {
-	if x, ok := m.GetPayload().(*ConformanceRequest_ProtobufPayload); ok {
-		return x.ProtobufPayload
-	}
-	return nil
-}
-
-func (m *ConformanceRequest) GetJsonPayload() string {
-	if x, ok := m.GetPayload().(*ConformanceRequest_JsonPayload); ok {
-		return x.JsonPayload
-	}
-	return ""
-}
-
-func (m *ConformanceRequest) GetRequestedOutputFormat() WireFormat {
-	if m != nil {
-		return m.RequestedOutputFormat
-	}
-	return WireFormat_UNSPECIFIED
-}
-
-// XXX_OneofFuncs is for the internal use of the proto package.
-func (*ConformanceRequest) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
-	return _ConformanceRequest_OneofMarshaler, _ConformanceRequest_OneofUnmarshaler, _ConformanceRequest_OneofSizer, []interface{}{
-		(*ConformanceRequest_ProtobufPayload)(nil),
-		(*ConformanceRequest_JsonPayload)(nil),
-	}
-}
-
-func _ConformanceRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
-	m := msg.(*ConformanceRequest)
-	// payload
-	switch x := m.Payload.(type) {
-	case *ConformanceRequest_ProtobufPayload:
-		b.EncodeVarint(1<<3 | proto.WireBytes)
-		b.EncodeRawBytes(x.ProtobufPayload)
-	case *ConformanceRequest_JsonPayload:
-		b.EncodeVarint(2<<3 | proto.WireBytes)
-		b.EncodeStringBytes(x.JsonPayload)
-	case nil:
-	default:
-		return fmt.Errorf("ConformanceRequest.Payload has unexpected type %T", x)
-	}
-	return nil
-}
-
-func _ConformanceRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
-	m := msg.(*ConformanceRequest)
-	switch tag {
-	case 1: // payload.protobuf_payload
-		if wire != proto.WireBytes {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeRawBytes(true)
-		m.Payload = &ConformanceRequest_ProtobufPayload{x}
-		return true, err
-	case 2: // payload.json_payload
-		if wire != proto.WireBytes {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeStringBytes()
-		m.Payload = &ConformanceRequest_JsonPayload{x}
-		return true, err
-	default:
-		return false, nil
-	}
-}
-
-func _ConformanceRequest_OneofSizer(msg proto.Message) (n int) {
-	m := msg.(*ConformanceRequest)
-	// payload
-	switch x := m.Payload.(type) {
-	case *ConformanceRequest_ProtobufPayload:
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(len(x.ProtobufPayload)))
-		n += len(x.ProtobufPayload)
-	case *ConformanceRequest_JsonPayload:
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(len(x.JsonPayload)))
-		n += len(x.JsonPayload)
-	case nil:
-	default:
-		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
-	}
-	return n
-}
-
-// Represents a single test case's output.
-type ConformanceResponse struct {
-	// Types that are valid to be assigned to Result:
-	//	*ConformanceResponse_ParseError
-	//	*ConformanceResponse_SerializeError
-	//	*ConformanceResponse_RuntimeError
-	//	*ConformanceResponse_ProtobufPayload
-	//	*ConformanceResponse_JsonPayload
-	//	*ConformanceResponse_Skipped
-	Result               isConformanceResponse_Result `protobuf_oneof:"result"`
-	XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
-	XXX_unrecognized     []byte                       `json:"-"`
-	XXX_sizecache        int32                        `json:"-"`
-}
-
-func (m *ConformanceResponse) Reset()         { *m = ConformanceResponse{} }
-func (m *ConformanceResponse) String() string { return proto.CompactTextString(m) }
-func (*ConformanceResponse) ProtoMessage()    {}
-func (*ConformanceResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_conformance_48ac832451f5d6c3, []int{1}
-}
-func (m *ConformanceResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ConformanceResponse.Unmarshal(m, b)
-}
-func (m *ConformanceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ConformanceResponse.Marshal(b, m, deterministic)
-}
-func (dst *ConformanceResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ConformanceResponse.Merge(dst, src)
-}
-func (m *ConformanceResponse) XXX_Size() int {
-	return xxx_messageInfo_ConformanceResponse.Size(m)
-}
-func (m *ConformanceResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_ConformanceResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ConformanceResponse proto.InternalMessageInfo
-
-type isConformanceResponse_Result interface {
-	isConformanceResponse_Result()
-}
-
-type ConformanceResponse_ParseError struct {
-	ParseError string `protobuf:"bytes,1,opt,name=parse_error,json=parseError,oneof"`
-}
-type ConformanceResponse_SerializeError struct {
-	SerializeError string `protobuf:"bytes,6,opt,name=serialize_error,json=serializeError,oneof"`
-}
-type ConformanceResponse_RuntimeError struct {
-	RuntimeError string `protobuf:"bytes,2,opt,name=runtime_error,json=runtimeError,oneof"`
-}
-type ConformanceResponse_ProtobufPayload struct {
-	ProtobufPayload []byte `protobuf:"bytes,3,opt,name=protobuf_payload,json=protobufPayload,proto3,oneof"`
-}
-type ConformanceResponse_JsonPayload struct {
-	JsonPayload string `protobuf:"bytes,4,opt,name=json_payload,json=jsonPayload,oneof"`
-}
-type ConformanceResponse_Skipped struct {
-	Skipped string `protobuf:"bytes,5,opt,name=skipped,oneof"`
-}
-
-func (*ConformanceResponse_ParseError) isConformanceResponse_Result()      {}
-func (*ConformanceResponse_SerializeError) isConformanceResponse_Result()  {}
-func (*ConformanceResponse_RuntimeError) isConformanceResponse_Result()    {}
-func (*ConformanceResponse_ProtobufPayload) isConformanceResponse_Result() {}
-func (*ConformanceResponse_JsonPayload) isConformanceResponse_Result()     {}
-func (*ConformanceResponse_Skipped) isConformanceResponse_Result()         {}
-
-func (m *ConformanceResponse) GetResult() isConformanceResponse_Result {
-	if m != nil {
-		return m.Result
-	}
-	return nil
-}
-
-func (m *ConformanceResponse) GetParseError() string {
-	if x, ok := m.GetResult().(*ConformanceResponse_ParseError); ok {
-		return x.ParseError
-	}
-	return ""
-}
-
-func (m *ConformanceResponse) GetSerializeError() string {
-	if x, ok := m.GetResult().(*ConformanceResponse_SerializeError); ok {
-		return x.SerializeError
-	}
-	return ""
-}
-
-func (m *ConformanceResponse) GetRuntimeError() string {
-	if x, ok := m.GetResult().(*ConformanceResponse_RuntimeError); ok {
-		return x.RuntimeError
-	}
-	return ""
-}
-
-func (m *ConformanceResponse) GetProtobufPayload() []byte {
-	if x, ok := m.GetResult().(*ConformanceResponse_ProtobufPayload); ok {
-		return x.ProtobufPayload
-	}
-	return nil
-}
-
-func (m *ConformanceResponse) GetJsonPayload() string {
-	if x, ok := m.GetResult().(*ConformanceResponse_JsonPayload); ok {
-		return x.JsonPayload
-	}
-	return ""
-}
-
-func (m *ConformanceResponse) GetSkipped() string {
-	if x, ok := m.GetResult().(*ConformanceResponse_Skipped); ok {
-		return x.Skipped
-	}
-	return ""
-}
-
-// XXX_OneofFuncs is for the internal use of the proto package.
-func (*ConformanceResponse) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
-	return _ConformanceResponse_OneofMarshaler, _ConformanceResponse_OneofUnmarshaler, _ConformanceResponse_OneofSizer, []interface{}{
-		(*ConformanceResponse_ParseError)(nil),
-		(*ConformanceResponse_SerializeError)(nil),
-		(*ConformanceResponse_RuntimeError)(nil),
-		(*ConformanceResponse_ProtobufPayload)(nil),
-		(*ConformanceResponse_JsonPayload)(nil),
-		(*ConformanceResponse_Skipped)(nil),
-	}
-}
-
-func _ConformanceResponse_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
-	m := msg.(*ConformanceResponse)
-	// result
-	switch x := m.Result.(type) {
-	case *ConformanceResponse_ParseError:
-		b.EncodeVarint(1<<3 | proto.WireBytes)
-		b.EncodeStringBytes(x.ParseError)
-	case *ConformanceResponse_SerializeError:
-		b.EncodeVarint(6<<3 | proto.WireBytes)
-		b.EncodeStringBytes(x.SerializeError)
-	case *ConformanceResponse_RuntimeError:
-		b.EncodeVarint(2<<3 | proto.WireBytes)
-		b.EncodeStringBytes(x.RuntimeError)
-	case *ConformanceResponse_ProtobufPayload:
-		b.EncodeVarint(3<<3 | proto.WireBytes)
-		b.EncodeRawBytes(x.ProtobufPayload)
-	case *ConformanceResponse_JsonPayload:
-		b.EncodeVarint(4<<3 | proto.WireBytes)
-		b.EncodeStringBytes(x.JsonPayload)
-	case *ConformanceResponse_Skipped:
-		b.EncodeVarint(5<<3 | proto.WireBytes)
-		b.EncodeStringBytes(x.Skipped)
-	case nil:
-	default:
-		return fmt.Errorf("ConformanceResponse.Result has unexpected type %T", x)
-	}
-	return nil
-}
-
-func _ConformanceResponse_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
-	m := msg.(*ConformanceResponse)
-	switch tag {
-	case 1: // result.parse_error
-		if wire != proto.WireBytes {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeStringBytes()
-		m.Result = &ConformanceResponse_ParseError{x}
-		return true, err
-	case 6: // result.serialize_error
-		if wire != proto.WireBytes {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeStringBytes()
-		m.Result = &ConformanceResponse_SerializeError{x}
-		return true, err
-	case 2: // result.runtime_error
-		if wire != proto.WireBytes {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeStringBytes()
-		m.Result = &ConformanceResponse_RuntimeError{x}
-		return true, err
-	case 3: // result.protobuf_payload
-		if wire != proto.WireBytes {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeRawBytes(true)
-		m.Result = &ConformanceResponse_ProtobufPayload{x}
-		return true, err
-	case 4: // result.json_payload
-		if wire != proto.WireBytes {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeStringBytes()
-		m.Result = &ConformanceResponse_JsonPayload{x}
-		return true, err
-	case 5: // result.skipped
-		if wire != proto.WireBytes {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeStringBytes()
-		m.Result = &ConformanceResponse_Skipped{x}
-		return true, err
-	default:
-		return false, nil
-	}
-}
-
-func _ConformanceResponse_OneofSizer(msg proto.Message) (n int) {
-	m := msg.(*ConformanceResponse)
-	// result
-	switch x := m.Result.(type) {
-	case *ConformanceResponse_ParseError:
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(len(x.ParseError)))
-		n += len(x.ParseError)
-	case *ConformanceResponse_SerializeError:
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(len(x.SerializeError)))
-		n += len(x.SerializeError)
-	case *ConformanceResponse_RuntimeError:
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(len(x.RuntimeError)))
-		n += len(x.RuntimeError)
-	case *ConformanceResponse_ProtobufPayload:
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(len(x.ProtobufPayload)))
-		n += len(x.ProtobufPayload)
-	case *ConformanceResponse_JsonPayload:
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(len(x.JsonPayload)))
-		n += len(x.JsonPayload)
-	case *ConformanceResponse_Skipped:
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(len(x.Skipped)))
-		n += len(x.Skipped)
-	case nil:
-	default:
-		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
-	}
-	return n
-}
-
-// This proto includes every type of field in both singular and repeated
-// forms.
-type TestAllTypes struct {
-	// Singular
-	OptionalInt32          int32                       `protobuf:"varint,1,opt,name=optional_int32,json=optionalInt32" json:"optional_int32,omitempty"`
-	OptionalInt64          int64                       `protobuf:"varint,2,opt,name=optional_int64,json=optionalInt64" json:"optional_int64,omitempty"`
-	OptionalUint32         uint32                      `protobuf:"varint,3,opt,name=optional_uint32,json=optionalUint32" json:"optional_uint32,omitempty"`
-	OptionalUint64         uint64                      `protobuf:"varint,4,opt,name=optional_uint64,json=optionalUint64" json:"optional_uint64,omitempty"`
-	OptionalSint32         int32                       `protobuf:"zigzag32,5,opt,name=optional_sint32,json=optionalSint32" json:"optional_sint32,omitempty"`
-	OptionalSint64         int64                       `protobuf:"zigzag64,6,opt,name=optional_sint64,json=optionalSint64" json:"optional_sint64,omitempty"`
-	OptionalFixed32        uint32                      `protobuf:"fixed32,7,opt,name=optional_fixed32,json=optionalFixed32" json:"optional_fixed32,omitempty"`
-	OptionalFixed64        uint64                      `protobuf:"fixed64,8,opt,name=optional_fixed64,json=optionalFixed64" json:"optional_fixed64,omitempty"`
-	OptionalSfixed32       int32                       `protobuf:"fixed32,9,opt,name=optional_sfixed32,json=optionalSfixed32" json:"optional_sfixed32,omitempty"`
-	OptionalSfixed64       int64                       `protobuf:"fixed64,10,opt,name=optional_sfixed64,json=optionalSfixed64" json:"optional_sfixed64,omitempty"`
-	OptionalFloat          float32                     `protobuf:"fixed32,11,opt,name=optional_float,json=optionalFloat" json:"optional_float,omitempty"`
-	OptionalDouble         float64                     `protobuf:"fixed64,12,opt,name=optional_double,json=optionalDouble" json:"optional_double,omitempty"`
-	OptionalBool           bool                        `protobuf:"varint,13,opt,name=optional_bool,json=optionalBool" json:"optional_bool,omitempty"`
-	OptionalString         string                      `protobuf:"bytes,14,opt,name=optional_string,json=optionalString" json:"optional_string,omitempty"`
-	OptionalBytes          []byte                      `protobuf:"bytes,15,opt,name=optional_bytes,json=optionalBytes,proto3" json:"optional_bytes,omitempty"`
-	OptionalNestedMessage  *TestAllTypes_NestedMessage `protobuf:"bytes,18,opt,name=optional_nested_message,json=optionalNestedMessage" json:"optional_nested_message,omitempty"`
-	OptionalForeignMessage *ForeignMessage             `protobuf:"bytes,19,opt,name=optional_foreign_message,json=optionalForeignMessage" json:"optional_foreign_message,omitempty"`
-	OptionalNestedEnum     TestAllTypes_NestedEnum     `protobuf:"varint,21,opt,name=optional_nested_enum,json=optionalNestedEnum,enum=conformance.TestAllTypes_NestedEnum" json:"optional_nested_enum,omitempty"`
-	OptionalForeignEnum    ForeignEnum                 `protobuf:"varint,22,opt,name=optional_foreign_enum,json=optionalForeignEnum,enum=conformance.ForeignEnum" json:"optional_foreign_enum,omitempty"`
-	OptionalStringPiece    string                      `protobuf:"bytes,24,opt,name=optional_string_piece,json=optionalStringPiece" json:"optional_string_piece,omitempty"`
-	OptionalCord           string                      `protobuf:"bytes,25,opt,name=optional_cord,json=optionalCord" json:"optional_cord,omitempty"`
-	RecursiveMessage       *TestAllTypes               `protobuf:"bytes,27,opt,name=recursive_message,json=recursiveMessage" json:"recursive_message,omitempty"`
-	// Repeated
-	RepeatedInt32          []int32                       `protobuf:"varint,31,rep,packed,name=repeated_int32,json=repeatedInt32" json:"repeated_int32,omitempty"`
-	RepeatedInt64          []int64                       `protobuf:"varint,32,rep,packed,name=repeated_int64,json=repeatedInt64" json:"repeated_int64,omitempty"`
-	RepeatedUint32         []uint32                      `protobuf:"varint,33,rep,packed,name=repeated_uint32,json=repeatedUint32" json:"repeated_uint32,omitempty"`
-	RepeatedUint64         []uint64                      `protobuf:"varint,34,rep,packed,name=repeated_uint64,json=repeatedUint64" json:"repeated_uint64,omitempty"`
-	RepeatedSint32         []int32                       `protobuf:"zigzag32,35,rep,packed,name=repeated_sint32,json=repeatedSint32" json:"repeated_sint32,omitempty"`
-	RepeatedSint64         []int64                       `protobuf:"zigzag64,36,rep,packed,name=repeated_sint64,json=repeatedSint64" json:"repeated_sint64,omitempty"`
-	RepeatedFixed32        []uint32                      `protobuf:"fixed32,37,rep,packed,name=repeated_fixed32,json=repeatedFixed32" json:"repeated_fixed32,omitempty"`
-	RepeatedFixed64        []uint64                      `protobuf:"fixed64,38,rep,packed,name=repeated_fixed64,json=repeatedFixed64" json:"repeated_fixed64,omitempty"`
-	RepeatedSfixed32       []int32                       `protobuf:"fixed32,39,rep,packed,name=repeated_sfixed32,json=repeatedSfixed32" json:"repeated_sfixed32,omitempty"`
-	RepeatedSfixed64       []int64                       `protobuf:"fixed64,40,rep,packed,name=repeated_sfixed64,json=repeatedSfixed64" json:"repeated_sfixed64,omitempty"`
-	RepeatedFloat          []float32                     `protobuf:"fixed32,41,rep,packed,name=repeated_float,json=repeatedFloat" json:"repeated_float,omitempty"`
-	RepeatedDouble         []float64                     `protobuf:"fixed64,42,rep,packed,name=repeated_double,json=repeatedDouble" json:"repeated_double,omitempty"`
-	RepeatedBool           []bool                        `protobuf:"varint,43,rep,packed,name=repeated_bool,json=repeatedBool" json:"repeated_bool,omitempty"`
-	RepeatedString         []string                      `protobuf:"bytes,44,rep,name=repeated_string,json=repeatedString" json:"repeated_string,omitempty"`
-	RepeatedBytes          [][]byte                      `protobuf:"bytes,45,rep,name=repeated_bytes,json=repeatedBytes,proto3" json:"repeated_bytes,omitempty"`
-	RepeatedNestedMessage  []*TestAllTypes_NestedMessage `protobuf:"bytes,48,rep,name=repeated_nested_message,json=repeatedNestedMessage" json:"repeated_nested_message,omitempty"`
-	RepeatedForeignMessage []*ForeignMessage             `protobuf:"bytes,49,rep,name=repeated_foreign_message,json=repeatedForeignMessage" json:"repeated_foreign_message,omitempty"`
-	RepeatedNestedEnum     []TestAllTypes_NestedEnum     `protobuf:"varint,51,rep,packed,name=repeated_nested_enum,json=repeatedNestedEnum,enum=conformance.TestAllTypes_NestedEnum" json:"repeated_nested_enum,omitempty"`
-	RepeatedForeignEnum    []ForeignEnum                 `protobuf:"varint,52,rep,packed,name=repeated_foreign_enum,json=repeatedForeignEnum,enum=conformance.ForeignEnum" json:"repeated_foreign_enum,omitempty"`
-	RepeatedStringPiece    []string                      `protobuf:"bytes,54,rep,name=repeated_string_piece,json=repeatedStringPiece" json:"repeated_string_piece,omitempty"`
-	RepeatedCord           []string                      `protobuf:"bytes,55,rep,name=repeated_cord,json=repeatedCord" json:"repeated_cord,omitempty"`
-	// Map
-	MapInt32Int32           map[int32]int32                        `protobuf:"bytes,56,rep,name=map_int32_int32,json=mapInt32Int32" json:"map_int32_int32,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
-	MapInt64Int64           map[int64]int64                        `protobuf:"bytes,57,rep,name=map_int64_int64,json=mapInt64Int64" json:"map_int64_int64,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
-	MapUint32Uint32         map[uint32]uint32                      `protobuf:"bytes,58,rep,name=map_uint32_uint32,json=mapUint32Uint32" json:"map_uint32_uint32,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
-	MapUint64Uint64         map[uint64]uint64                      `protobuf:"bytes,59,rep,name=map_uint64_uint64,json=mapUint64Uint64" json:"map_uint64_uint64,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
-	MapSint32Sint32         map[int32]int32                        `protobuf:"bytes,60,rep,name=map_sint32_sint32,json=mapSint32Sint32" json:"map_sint32_sint32,omitempty" protobuf_key:"zigzag32,1,opt,name=key" protobuf_val:"zigzag32,2,opt,name=value"`
-	MapSint64Sint64         map[int64]int64                        `protobuf:"bytes,61,rep,name=map_sint64_sint64,json=mapSint64Sint64" json:"map_sint64_sint64,omitempty" protobuf_key:"zigzag64,1,opt,name=key" protobuf_val:"zigzag64,2,opt,name=value"`
-	MapFixed32Fixed32       map[uint32]uint32                      `protobuf:"bytes,62,rep,name=map_fixed32_fixed32,json=mapFixed32Fixed32" json:"map_fixed32_fixed32,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
-	MapFixed64Fixed64       map[uint64]uint64                      `protobuf:"bytes,63,rep,name=map_fixed64_fixed64,json=mapFixed64Fixed64" json:"map_fixed64_fixed64,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
-	MapSfixed32Sfixed32     map[int32]int32                        `protobuf:"bytes,64,rep,name=map_sfixed32_sfixed32,json=mapSfixed32Sfixed32" json:"map_sfixed32_sfixed32,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
-	MapSfixed64Sfixed64     map[int64]int64                        `protobuf:"bytes,65,rep,name=map_sfixed64_sfixed64,json=mapSfixed64Sfixed64" json:"map_sfixed64_sfixed64,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
-	MapInt32Float           map[int32]float32                      `protobuf:"bytes,66,rep,name=map_int32_float,json=mapInt32Float" json:"map_int32_float,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
-	MapInt32Double          map[int32]float64                      `protobuf:"bytes,67,rep,name=map_int32_double,json=mapInt32Double" json:"map_int32_double,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
-	MapBoolBool             map[bool]bool                          `protobuf:"bytes,68,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"`
-	MapStringString         map[string]string                      `protobuf:"bytes,69,rep,name=map_string_string,json=mapStringString" json:"map_string_string,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
-	MapStringBytes          map[string][]byte                      `protobuf:"bytes,70,rep,name=map_string_bytes,json=mapStringBytes" json:"map_string_bytes,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value,proto3"`
-	MapStringNestedMessage  map[string]*TestAllTypes_NestedMessage `protobuf:"bytes,71,rep,name=map_string_nested_message,json=mapStringNestedMessage" json:"map_string_nested_message,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
-	MapStringForeignMessage map[string]*ForeignMessage             `protobuf:"bytes,72,rep,name=map_string_foreign_message,json=mapStringForeignMessage" json:"map_string_foreign_message,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
-	MapStringNestedEnum     map[string]TestAllTypes_NestedEnum     `protobuf:"bytes,73,rep,name=map_string_nested_enum,json=mapStringNestedEnum" json:"map_string_nested_enum,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=conformance.TestAllTypes_NestedEnum"`
-	MapStringForeignEnum    map[string]ForeignEnum                 `protobuf:"bytes,74,rep,name=map_string_foreign_enum,json=mapStringForeignEnum" json:"map_string_foreign_enum,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=conformance.ForeignEnum"`
-	// Types that are valid to be assigned to OneofField:
-	//	*TestAllTypes_OneofUint32
-	//	*TestAllTypes_OneofNestedMessage
-	//	*TestAllTypes_OneofString
-	//	*TestAllTypes_OneofBytes
-	OneofField isTestAllTypes_OneofField `protobuf_oneof:"oneof_field"`
-	// Well-known types
-	OptionalBoolWrapper   *wrappers.BoolValue     `protobuf:"bytes,201,opt,name=optional_bool_wrapper,json=optionalBoolWrapper" json:"optional_bool_wrapper,omitempty"`
-	OptionalInt32Wrapper  *wrappers.Int32Value    `protobuf:"bytes,202,opt,name=optional_int32_wrapper,json=optionalInt32Wrapper" json:"optional_int32_wrapper,omitempty"`
-	OptionalInt64Wrapper  *wrappers.Int64Value    `protobuf:"bytes,203,opt,name=optional_int64_wrapper,json=optionalInt64Wrapper" json:"optional_int64_wrapper,omitempty"`
-	OptionalUint32Wrapper *wrappers.UInt32Value   `protobuf:"bytes,204,opt,name=optional_uint32_wrapper,json=optionalUint32Wrapper" json:"optional_uint32_wrapper,omitempty"`
-	OptionalUint64Wrapper *wrappers.UInt64Value   `protobuf:"bytes,205,opt,name=optional_uint64_wrapper,json=optionalUint64Wrapper" json:"optional_uint64_wrapper,omitempty"`
-	OptionalFloatWrapper  *wrappers.FloatValue    `protobuf:"bytes,206,opt,name=optional_float_wrapper,json=optionalFloatWrapper" json:"optional_float_wrapper,omitempty"`
-	OptionalDoubleWrapper *wrappers.DoubleValue   `protobuf:"bytes,207,opt,name=optional_double_wrapper,json=optionalDoubleWrapper" json:"optional_double_wrapper,omitempty"`
-	OptionalStringWrapper *wrappers.StringValue   `protobuf:"bytes,208,opt,name=optional_string_wrapper,json=optionalStringWrapper" json:"optional_string_wrapper,omitempty"`
-	OptionalBytesWrapper  *wrappers.BytesValue    `protobuf:"bytes,209,opt,name=optional_bytes_wrapper,json=optionalBytesWrapper" json:"optional_bytes_wrapper,omitempty"`
-	RepeatedBoolWrapper   []*wrappers.BoolValue   `protobuf:"bytes,211,rep,name=repeated_bool_wrapper,json=repeatedBoolWrapper" json:"repeated_bool_wrapper,omitempty"`
-	RepeatedInt32Wrapper  []*wrappers.Int32Value  `protobuf:"bytes,212,rep,name=repeated_int32_wrapper,json=repeatedInt32Wrapper" json:"repeated_int32_wrapper,omitempty"`
-	RepeatedInt64Wrapper  []*wrappers.Int64Value  `protobuf:"bytes,213,rep,name=repeated_int64_wrapper,json=repeatedInt64Wrapper" json:"repeated_int64_wrapper,omitempty"`
-	RepeatedUint32Wrapper []*wrappers.UInt32Value `protobuf:"bytes,214,rep,name=repeated_uint32_wrapper,json=repeatedUint32Wrapper" json:"repeated_uint32_wrapper,omitempty"`
-	RepeatedUint64Wrapper []*wrappers.UInt64Value `protobuf:"bytes,215,rep,name=repeated_uint64_wrapper,json=repeatedUint64Wrapper" json:"repeated_uint64_wrapper,omitempty"`
-	RepeatedFloatWrapper  []*wrappers.FloatValue  `protobuf:"bytes,216,rep,name=repeated_float_wrapper,json=repeatedFloatWrapper" json:"repeated_float_wrapper,omitempty"`
-	RepeatedDoubleWrapper []*wrappers.DoubleValue `protobuf:"bytes,217,rep,name=repeated_double_wrapper,json=repeatedDoubleWrapper" json:"repeated_double_wrapper,omitempty"`
-	RepeatedStringWrapper []*wrappers.StringValue `protobuf:"bytes,218,rep,name=repeated_string_wrapper,json=repeatedStringWrapper" json:"repeated_string_wrapper,omitempty"`
-	RepeatedBytesWrapper  []*wrappers.BytesValue  `protobuf:"bytes,219,rep,name=repeated_bytes_wrapper,json=repeatedBytesWrapper" json:"repeated_bytes_wrapper,omitempty"`
-	OptionalDuration      *duration.Duration      `protobuf:"bytes,301,opt,name=optional_duration,json=optionalDuration" json:"optional_duration,omitempty"`
-	OptionalTimestamp     *timestamp.Timestamp    `protobuf:"bytes,302,opt,name=optional_timestamp,json=optionalTimestamp" json:"optional_timestamp,omitempty"`
-	OptionalFieldMask     *field_mask.FieldMask   `protobuf:"bytes,303,opt,name=optional_field_mask,json=optionalFieldMask" json:"optional_field_mask,omitempty"`
-	OptionalStruct        *_struct.Struct         `protobuf:"bytes,304,opt,name=optional_struct,json=optionalStruct" json:"optional_struct,omitempty"`
-	OptionalAny           *any.Any                `protobuf:"bytes,305,opt,name=optional_any,json=optionalAny" json:"optional_any,omitempty"`
-	OptionalValue         *_struct.Value          `protobuf:"bytes,306,opt,name=optional_value,json=optionalValue" json:"optional_value,omitempty"`
-	RepeatedDuration      []*duration.Duration    `protobuf:"bytes,311,rep,name=repeated_duration,json=repeatedDuration" json:"repeated_duration,omitempty"`
-	RepeatedTimestamp     []*timestamp.Timestamp  `protobuf:"bytes,312,rep,name=repeated_timestamp,json=repeatedTimestamp" json:"repeated_timestamp,omitempty"`
-	RepeatedFieldmask     []*field_mask.FieldMask `protobuf:"bytes,313,rep,name=repeated_fieldmask,json=repeatedFieldmask" json:"repeated_fieldmask,omitempty"`
-	RepeatedStruct        []*_struct.Struct       `protobuf:"bytes,324,rep,name=repeated_struct,json=repeatedStruct" json:"repeated_struct,omitempty"`
-	RepeatedAny           []*any.Any              `protobuf:"bytes,315,rep,name=repeated_any,json=repeatedAny" json:"repeated_any,omitempty"`
-	RepeatedValue         []*_struct.Value        `protobuf:"bytes,316,rep,name=repeated_value,json=repeatedValue" json:"repeated_value,omitempty"`
-	// Test field-name-to-JSON-name convention.
-	Fieldname1           int32    `protobuf:"varint,401,opt,name=fieldname1" json:"fieldname1,omitempty"`
-	FieldName2           int32    `protobuf:"varint,402,opt,name=field_name2,json=fieldName2" json:"field_name2,omitempty"`
-	XFieldName3          int32    `protobuf:"varint,403,opt,name=_field_name3,json=FieldName3" json:"_field_name3,omitempty"`
-	Field_Name4_         int32    `protobuf:"varint,404,opt,name=field__name4_,json=fieldName4" json:"field__name4_,omitempty"`
-	Field0Name5          int32    `protobuf:"varint,405,opt,name=field0name5" json:"field0name5,omitempty"`
-	Field_0Name6         int32    `protobuf:"varint,406,opt,name=field_0_name6,json=field0Name6" json:"field_0_name6,omitempty"`
-	FieldName7           int32    `protobuf:"varint,407,opt,name=fieldName7" json:"fieldName7,omitempty"`
-	FieldName8           int32    `protobuf:"varint,408,opt,name=FieldName8" json:"FieldName8,omitempty"`
-	Field_Name9          int32    `protobuf:"varint,409,opt,name=field_Name9,json=fieldName9" json:"field_Name9,omitempty"`
-	Field_Name10         int32    `protobuf:"varint,410,opt,name=Field_Name10,json=FieldName10" json:"Field_Name10,omitempty"`
-	FIELD_NAME11         int32    `protobuf:"varint,411,opt,name=FIELD_NAME11,json=FIELDNAME11" json:"FIELD_NAME11,omitempty"`
-	FIELDName12          int32    `protobuf:"varint,412,opt,name=FIELD_name12,json=FIELDName12" json:"FIELD_name12,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *TestAllTypes) Reset()         { *m = TestAllTypes{} }
-func (m *TestAllTypes) String() string { return proto.CompactTextString(m) }
-func (*TestAllTypes) ProtoMessage()    {}
-func (*TestAllTypes) Descriptor() ([]byte, []int) {
-	return fileDescriptor_conformance_48ac832451f5d6c3, []int{2}
-}
-func (m *TestAllTypes) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_TestAllTypes.Unmarshal(m, b)
-}
-func (m *TestAllTypes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_TestAllTypes.Marshal(b, m, deterministic)
-}
-func (dst *TestAllTypes) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_TestAllTypes.Merge(dst, src)
-}
-func (m *TestAllTypes) XXX_Size() int {
-	return xxx_messageInfo_TestAllTypes.Size(m)
-}
-func (m *TestAllTypes) XXX_DiscardUnknown() {
-	xxx_messageInfo_TestAllTypes.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_TestAllTypes proto.InternalMessageInfo
-
-type isTestAllTypes_OneofField interface {
-	isTestAllTypes_OneofField()
-}
-
-type TestAllTypes_OneofUint32 struct {
-	OneofUint32 uint32 `protobuf:"varint,111,opt,name=oneof_uint32,json=oneofUint32,oneof"`
-}
-type TestAllTypes_OneofNestedMessage struct {
-	OneofNestedMessage *TestAllTypes_NestedMessage `protobuf:"bytes,112,opt,name=oneof_nested_message,json=oneofNestedMessage,oneof"`
-}
-type TestAllTypes_OneofString struct {
-	OneofString string `protobuf:"bytes,113,opt,name=oneof_string,json=oneofString,oneof"`
-}
-type TestAllTypes_OneofBytes struct {
-	OneofBytes []byte `protobuf:"bytes,114,opt,name=oneof_bytes,json=oneofBytes,proto3,oneof"`
-}
-
-func (*TestAllTypes_OneofUint32) isTestAllTypes_OneofField()        {}
-func (*TestAllTypes_OneofNestedMessage) isTestAllTypes_OneofField() {}
-func (*TestAllTypes_OneofString) isTestAllTypes_OneofField()        {}
-func (*TestAllTypes_OneofBytes) isTestAllTypes_OneofField()         {}
-
-func (m *TestAllTypes) GetOneofField() isTestAllTypes_OneofField {
-	if m != nil {
-		return m.OneofField
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetOptionalInt32() int32 {
-	if m != nil {
-		return m.OptionalInt32
-	}
-	return 0
-}
-
-func (m *TestAllTypes) GetOptionalInt64() int64 {
-	if m != nil {
-		return m.OptionalInt64
-	}
-	return 0
-}
-
-func (m *TestAllTypes) GetOptionalUint32() uint32 {
-	if m != nil {
-		return m.OptionalUint32
-	}
-	return 0
-}
-
-func (m *TestAllTypes) GetOptionalUint64() uint64 {
-	if m != nil {
-		return m.OptionalUint64
-	}
-	return 0
-}
-
-func (m *TestAllTypes) GetOptionalSint32() int32 {
-	if m != nil {
-		return m.OptionalSint32
-	}
-	return 0
-}
-
-func (m *TestAllTypes) GetOptionalSint64() int64 {
-	if m != nil {
-		return m.OptionalSint64
-	}
-	return 0
-}
-
-func (m *TestAllTypes) GetOptionalFixed32() uint32 {
-	if m != nil {
-		return m.OptionalFixed32
-	}
-	return 0
-}
-
-func (m *TestAllTypes) GetOptionalFixed64() uint64 {
-	if m != nil {
-		return m.OptionalFixed64
-	}
-	return 0
-}
-
-func (m *TestAllTypes) GetOptionalSfixed32() int32 {
-	if m != nil {
-		return m.OptionalSfixed32
-	}
-	return 0
-}
-
-func (m *TestAllTypes) GetOptionalSfixed64() int64 {
-	if m != nil {
-		return m.OptionalSfixed64
-	}
-	return 0
-}
-
-func (m *TestAllTypes) GetOptionalFloat() float32 {
-	if m != nil {
-		return m.OptionalFloat
-	}
-	return 0
-}
-
-func (m *TestAllTypes) GetOptionalDouble() float64 {
-	if m != nil {
-		return m.OptionalDouble
-	}
-	return 0
-}
-
-func (m *TestAllTypes) GetOptionalBool() bool {
-	if m != nil {
-		return m.OptionalBool
-	}
-	return false
-}
-
-func (m *TestAllTypes) GetOptionalString() string {
-	if m != nil {
-		return m.OptionalString
-	}
-	return ""
-}
-
-func (m *TestAllTypes) GetOptionalBytes() []byte {
-	if m != nil {
-		return m.OptionalBytes
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetOptionalNestedMessage() *TestAllTypes_NestedMessage {
-	if m != nil {
-		return m.OptionalNestedMessage
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetOptionalForeignMessage() *ForeignMessage {
-	if m != nil {
-		return m.OptionalForeignMessage
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetOptionalNestedEnum() TestAllTypes_NestedEnum {
-	if m != nil {
-		return m.OptionalNestedEnum
-	}
-	return TestAllTypes_FOO
-}
-
-func (m *TestAllTypes) GetOptionalForeignEnum() ForeignEnum {
-	if m != nil {
-		return m.OptionalForeignEnum
-	}
-	return ForeignEnum_FOREIGN_FOO
-}
-
-func (m *TestAllTypes) GetOptionalStringPiece() string {
-	if m != nil {
-		return m.OptionalStringPiece
-	}
-	return ""
-}
-
-func (m *TestAllTypes) GetOptionalCord() string {
-	if m != nil {
-		return m.OptionalCord
-	}
-	return ""
-}
-
-func (m *TestAllTypes) GetRecursiveMessage() *TestAllTypes {
-	if m != nil {
-		return m.RecursiveMessage
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedInt32() []int32 {
-	if m != nil {
-		return m.RepeatedInt32
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedInt64() []int64 {
-	if m != nil {
-		return m.RepeatedInt64
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedUint32() []uint32 {
-	if m != nil {
-		return m.RepeatedUint32
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedUint64() []uint64 {
-	if m != nil {
-		return m.RepeatedUint64
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedSint32() []int32 {
-	if m != nil {
-		return m.RepeatedSint32
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedSint64() []int64 {
-	if m != nil {
-		return m.RepeatedSint64
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedFixed32() []uint32 {
-	if m != nil {
-		return m.RepeatedFixed32
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedFixed64() []uint64 {
-	if m != nil {
-		return m.RepeatedFixed64
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedSfixed32() []int32 {
-	if m != nil {
-		return m.RepeatedSfixed32
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedSfixed64() []int64 {
-	if m != nil {
-		return m.RepeatedSfixed64
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedFloat() []float32 {
-	if m != nil {
-		return m.RepeatedFloat
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedDouble() []float64 {
-	if m != nil {
-		return m.RepeatedDouble
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedBool() []bool {
-	if m != nil {
-		return m.RepeatedBool
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedString() []string {
-	if m != nil {
-		return m.RepeatedString
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedBytes() [][]byte {
-	if m != nil {
-		return m.RepeatedBytes
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedNestedMessage() []*TestAllTypes_NestedMessage {
-	if m != nil {
-		return m.RepeatedNestedMessage
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedForeignMessage() []*ForeignMessage {
-	if m != nil {
-		return m.RepeatedForeignMessage
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedNestedEnum() []TestAllTypes_NestedEnum {
-	if m != nil {
-		return m.RepeatedNestedEnum
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedForeignEnum() []ForeignEnum {
-	if m != nil {
-		return m.RepeatedForeignEnum
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedStringPiece() []string {
-	if m != nil {
-		return m.RepeatedStringPiece
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedCord() []string {
-	if m != nil {
-		return m.RepeatedCord
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetMapInt32Int32() map[int32]int32 {
-	if m != nil {
-		return m.MapInt32Int32
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetMapInt64Int64() map[int64]int64 {
-	if m != nil {
-		return m.MapInt64Int64
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetMapUint32Uint32() map[uint32]uint32 {
-	if m != nil {
-		return m.MapUint32Uint32
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetMapUint64Uint64() map[uint64]uint64 {
-	if m != nil {
-		return m.MapUint64Uint64
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetMapSint32Sint32() map[int32]int32 {
-	if m != nil {
-		return m.MapSint32Sint32
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetMapSint64Sint64() map[int64]int64 {
-	if m != nil {
-		return m.MapSint64Sint64
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetMapFixed32Fixed32() map[uint32]uint32 {
-	if m != nil {
-		return m.MapFixed32Fixed32
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetMapFixed64Fixed64() map[uint64]uint64 {
-	if m != nil {
-		return m.MapFixed64Fixed64
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetMapSfixed32Sfixed32() map[int32]int32 {
-	if m != nil {
-		return m.MapSfixed32Sfixed32
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetMapSfixed64Sfixed64() map[int64]int64 {
-	if m != nil {
-		return m.MapSfixed64Sfixed64
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetMapInt32Float() map[int32]float32 {
-	if m != nil {
-		return m.MapInt32Float
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetMapInt32Double() map[int32]float64 {
-	if m != nil {
-		return m.MapInt32Double
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetMapBoolBool() map[bool]bool {
-	if m != nil {
-		return m.MapBoolBool
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetMapStringString() map[string]string {
-	if m != nil {
-		return m.MapStringString
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetMapStringBytes() map[string][]byte {
-	if m != nil {
-		return m.MapStringBytes
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetMapStringNestedMessage() map[string]*TestAllTypes_NestedMessage {
-	if m != nil {
-		return m.MapStringNestedMessage
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetMapStringForeignMessage() map[string]*ForeignMessage {
-	if m != nil {
-		return m.MapStringForeignMessage
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetMapStringNestedEnum() map[string]TestAllTypes_NestedEnum {
-	if m != nil {
-		return m.MapStringNestedEnum
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetMapStringForeignEnum() map[string]ForeignEnum {
-	if m != nil {
-		return m.MapStringForeignEnum
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetOneofUint32() uint32 {
-	if x, ok := m.GetOneofField().(*TestAllTypes_OneofUint32); ok {
-		return x.OneofUint32
-	}
-	return 0
-}
-
-func (m *TestAllTypes) GetOneofNestedMessage() *TestAllTypes_NestedMessage {
-	if x, ok := m.GetOneofField().(*TestAllTypes_OneofNestedMessage); ok {
-		return x.OneofNestedMessage
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetOneofString() string {
-	if x, ok := m.GetOneofField().(*TestAllTypes_OneofString); ok {
-		return x.OneofString
-	}
-	return ""
-}
-
-func (m *TestAllTypes) GetOneofBytes() []byte {
-	if x, ok := m.GetOneofField().(*TestAllTypes_OneofBytes); ok {
-		return x.OneofBytes
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetOptionalBoolWrapper() *wrappers.BoolValue {
-	if m != nil {
-		return m.OptionalBoolWrapper
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetOptionalInt32Wrapper() *wrappers.Int32Value {
-	if m != nil {
-		return m.OptionalInt32Wrapper
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetOptionalInt64Wrapper() *wrappers.Int64Value {
-	if m != nil {
-		return m.OptionalInt64Wrapper
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetOptionalUint32Wrapper() *wrappers.UInt32Value {
-	if m != nil {
-		return m.OptionalUint32Wrapper
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetOptionalUint64Wrapper() *wrappers.UInt64Value {
-	if m != nil {
-		return m.OptionalUint64Wrapper
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetOptionalFloatWrapper() *wrappers.FloatValue {
-	if m != nil {
-		return m.OptionalFloatWrapper
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetOptionalDoubleWrapper() *wrappers.DoubleValue {
-	if m != nil {
-		return m.OptionalDoubleWrapper
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetOptionalStringWrapper() *wrappers.StringValue {
-	if m != nil {
-		return m.OptionalStringWrapper
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetOptionalBytesWrapper() *wrappers.BytesValue {
-	if m != nil {
-		return m.OptionalBytesWrapper
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedBoolWrapper() []*wrappers.BoolValue {
-	if m != nil {
-		return m.RepeatedBoolWrapper
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedInt32Wrapper() []*wrappers.Int32Value {
-	if m != nil {
-		return m.RepeatedInt32Wrapper
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedInt64Wrapper() []*wrappers.Int64Value {
-	if m != nil {
-		return m.RepeatedInt64Wrapper
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedUint32Wrapper() []*wrappers.UInt32Value {
-	if m != nil {
-		return m.RepeatedUint32Wrapper
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedUint64Wrapper() []*wrappers.UInt64Value {
-	if m != nil {
-		return m.RepeatedUint64Wrapper
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedFloatWrapper() []*wrappers.FloatValue {
-	if m != nil {
-		return m.RepeatedFloatWrapper
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedDoubleWrapper() []*wrappers.DoubleValue {
-	if m != nil {
-		return m.RepeatedDoubleWrapper
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedStringWrapper() []*wrappers.StringValue {
-	if m != nil {
-		return m.RepeatedStringWrapper
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedBytesWrapper() []*wrappers.BytesValue {
-	if m != nil {
-		return m.RepeatedBytesWrapper
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetOptionalDuration() *duration.Duration {
-	if m != nil {
-		return m.OptionalDuration
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetOptionalTimestamp() *timestamp.Timestamp {
-	if m != nil {
-		return m.OptionalTimestamp
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetOptionalFieldMask() *field_mask.FieldMask {
-	if m != nil {
-		return m.OptionalFieldMask
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetOptionalStruct() *_struct.Struct {
-	if m != nil {
-		return m.OptionalStruct
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetOptionalAny() *any.Any {
-	if m != nil {
-		return m.OptionalAny
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetOptionalValue() *_struct.Value {
-	if m != nil {
-		return m.OptionalValue
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedDuration() []*duration.Duration {
-	if m != nil {
-		return m.RepeatedDuration
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedTimestamp() []*timestamp.Timestamp {
-	if m != nil {
-		return m.RepeatedTimestamp
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedFieldmask() []*field_mask.FieldMask {
-	if m != nil {
-		return m.RepeatedFieldmask
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedStruct() []*_struct.Struct {
-	if m != nil {
-		return m.RepeatedStruct
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedAny() []*any.Any {
-	if m != nil {
-		return m.RepeatedAny
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetRepeatedValue() []*_struct.Value {
-	if m != nil {
-		return m.RepeatedValue
-	}
-	return nil
-}
-
-func (m *TestAllTypes) GetFieldname1() int32 {
-	if m != nil {
-		return m.Fieldname1
-	}
-	return 0
-}
-
-func (m *TestAllTypes) GetFieldName2() int32 {
-	if m != nil {
-		return m.FieldName2
-	}
-	return 0
-}
-
-func (m *TestAllTypes) GetXFieldName3() int32 {
-	if m != nil {
-		return m.XFieldName3
-	}
-	return 0
-}
-
-func (m *TestAllTypes) GetField_Name4_() int32 {
-	if m != nil {
-		return m.Field_Name4_
-	}
-	return 0
-}
-
-func (m *TestAllTypes) GetField0Name5() int32 {
-	if m != nil {
-		return m.Field0Name5
-	}
-	return 0
-}
-
-func (m *TestAllTypes) GetField_0Name6() int32 {
-	if m != nil {
-		return m.Field_0Name6
-	}
-	return 0
-}
-
-func (m *TestAllTypes) GetFieldName7() int32 {
-	if m != nil {
-		return m.FieldName7
-	}
-	return 0
-}
-
-func (m *TestAllTypes) GetFieldName8() int32 {
-	if m != nil {
-		return m.FieldName8
-	}
-	return 0
-}
-
-func (m *TestAllTypes) GetField_Name9() int32 {
-	if m != nil {
-		return m.Field_Name9
-	}
-	return 0
-}
-
-func (m *TestAllTypes) GetField_Name10() int32 {
-	if m != nil {
-		return m.Field_Name10
-	}
-	return 0
-}
-
-func (m *TestAllTypes) GetFIELD_NAME11() int32 {
-	if m != nil {
-		return m.FIELD_NAME11
-	}
-	return 0
-}
-
-func (m *TestAllTypes) GetFIELDName12() int32 {
-	if m != nil {
-		return m.FIELDName12
-	}
-	return 0
-}
-
-// XXX_OneofFuncs is for the internal use of the proto package.
-func (*TestAllTypes) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
-	return _TestAllTypes_OneofMarshaler, _TestAllTypes_OneofUnmarshaler, _TestAllTypes_OneofSizer, []interface{}{
-		(*TestAllTypes_OneofUint32)(nil),
-		(*TestAllTypes_OneofNestedMessage)(nil),
-		(*TestAllTypes_OneofString)(nil),
-		(*TestAllTypes_OneofBytes)(nil),
-	}
-}
-
-func _TestAllTypes_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
-	m := msg.(*TestAllTypes)
-	// oneof_field
-	switch x := m.OneofField.(type) {
-	case *TestAllTypes_OneofUint32:
-		b.EncodeVarint(111<<3 | proto.WireVarint)
-		b.EncodeVarint(uint64(x.OneofUint32))
-	case *TestAllTypes_OneofNestedMessage:
-		b.EncodeVarint(112<<3 | proto.WireBytes)
-		if err := b.EncodeMessage(x.OneofNestedMessage); err != nil {
-			return err
-		}
-	case *TestAllTypes_OneofString:
-		b.EncodeVarint(113<<3 | proto.WireBytes)
-		b.EncodeStringBytes(x.OneofString)
-	case *TestAllTypes_OneofBytes:
-		b.EncodeVarint(114<<3 | proto.WireBytes)
-		b.EncodeRawBytes(x.OneofBytes)
-	case nil:
-	default:
-		return fmt.Errorf("TestAllTypes.OneofField has unexpected type %T", x)
-	}
-	return nil
-}
-
-func _TestAllTypes_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
-	m := msg.(*TestAllTypes)
-	switch tag {
-	case 111: // oneof_field.oneof_uint32
-		if wire != proto.WireVarint {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeVarint()
-		m.OneofField = &TestAllTypes_OneofUint32{uint32(x)}
-		return true, err
-	case 112: // oneof_field.oneof_nested_message
-		if wire != proto.WireBytes {
-			return true, proto.ErrInternalBadWireType
-		}
-		msg := new(TestAllTypes_NestedMessage)
-		err := b.DecodeMessage(msg)
-		m.OneofField = &TestAllTypes_OneofNestedMessage{msg}
-		return true, err
-	case 113: // oneof_field.oneof_string
-		if wire != proto.WireBytes {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeStringBytes()
-		m.OneofField = &TestAllTypes_OneofString{x}
-		return true, err
-	case 114: // oneof_field.oneof_bytes
-		if wire != proto.WireBytes {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeRawBytes(true)
-		m.OneofField = &TestAllTypes_OneofBytes{x}
-		return true, err
-	default:
-		return false, nil
-	}
-}
-
-func _TestAllTypes_OneofSizer(msg proto.Message) (n int) {
-	m := msg.(*TestAllTypes)
-	// oneof_field
-	switch x := m.OneofField.(type) {
-	case *TestAllTypes_OneofUint32:
-		n += 2 // tag and wire
-		n += proto.SizeVarint(uint64(x.OneofUint32))
-	case *TestAllTypes_OneofNestedMessage:
-		s := proto.Size(x.OneofNestedMessage)
-		n += 2 // tag and wire
-		n += proto.SizeVarint(uint64(s))
-		n += s
-	case *TestAllTypes_OneofString:
-		n += 2 // tag and wire
-		n += proto.SizeVarint(uint64(len(x.OneofString)))
-		n += len(x.OneofString)
-	case *TestAllTypes_OneofBytes:
-		n += 2 // tag and wire
-		n += proto.SizeVarint(uint64(len(x.OneofBytes)))
-		n += len(x.OneofBytes)
-	case nil:
-	default:
-		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
-	}
-	return n
-}
-
-type TestAllTypes_NestedMessage struct {
-	A                    int32         `protobuf:"varint,1,opt,name=a" json:"a,omitempty"`
-	Corecursive          *TestAllTypes `protobuf:"bytes,2,opt,name=corecursive" json:"corecursive,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
-	XXX_unrecognized     []byte        `json:"-"`
-	XXX_sizecache        int32         `json:"-"`
-}
-
-func (m *TestAllTypes_NestedMessage) Reset()         { *m = TestAllTypes_NestedMessage{} }
-func (m *TestAllTypes_NestedMessage) String() string { return proto.CompactTextString(m) }
-func (*TestAllTypes_NestedMessage) ProtoMessage()    {}
-func (*TestAllTypes_NestedMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_conformance_48ac832451f5d6c3, []int{2, 0}
-}
-func (m *TestAllTypes_NestedMessage) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_TestAllTypes_NestedMessage.Unmarshal(m, b)
-}
-func (m *TestAllTypes_NestedMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_TestAllTypes_NestedMessage.Marshal(b, m, deterministic)
-}
-func (dst *TestAllTypes_NestedMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_TestAllTypes_NestedMessage.Merge(dst, src)
-}
-func (m *TestAllTypes_NestedMessage) XXX_Size() int {
-	return xxx_messageInfo_TestAllTypes_NestedMessage.Size(m)
-}
-func (m *TestAllTypes_NestedMessage) XXX_DiscardUnknown() {
-	xxx_messageInfo_TestAllTypes_NestedMessage.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_TestAllTypes_NestedMessage proto.InternalMessageInfo
-
-func (m *TestAllTypes_NestedMessage) GetA() int32 {
-	if m != nil {
-		return m.A
-	}
-	return 0
-}
-
-func (m *TestAllTypes_NestedMessage) GetCorecursive() *TestAllTypes {
-	if m != nil {
-		return m.Corecursive
-	}
-	return nil
-}
-
-type ForeignMessage struct {
-	C                    int32    `protobuf:"varint,1,opt,name=c" json:"c,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *ForeignMessage) Reset()         { *m = ForeignMessage{} }
-func (m *ForeignMessage) String() string { return proto.CompactTextString(m) }
-func (*ForeignMessage) ProtoMessage()    {}
-func (*ForeignMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_conformance_48ac832451f5d6c3, []int{3}
-}
-func (m *ForeignMessage) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ForeignMessage.Unmarshal(m, b)
-}
-func (m *ForeignMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ForeignMessage.Marshal(b, m, deterministic)
-}
-func (dst *ForeignMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ForeignMessage.Merge(dst, src)
-}
-func (m *ForeignMessage) XXX_Size() int {
-	return xxx_messageInfo_ForeignMessage.Size(m)
-}
-func (m *ForeignMessage) XXX_DiscardUnknown() {
-	xxx_messageInfo_ForeignMessage.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ForeignMessage proto.InternalMessageInfo
-
-func (m *ForeignMessage) GetC() int32 {
-	if m != nil {
-		return m.C
-	}
-	return 0
-}
-
-func init() {
-	proto.RegisterType((*ConformanceRequest)(nil), "conformance.ConformanceRequest")
-	proto.RegisterType((*ConformanceResponse)(nil), "conformance.ConformanceResponse")
-	proto.RegisterType((*TestAllTypes)(nil), "conformance.TestAllTypes")
-	proto.RegisterMapType((map[bool]bool)(nil), "conformance.TestAllTypes.MapBoolBoolEntry")
-	proto.RegisterMapType((map[uint32]uint32)(nil), "conformance.TestAllTypes.MapFixed32Fixed32Entry")
-	proto.RegisterMapType((map[uint64]uint64)(nil), "conformance.TestAllTypes.MapFixed64Fixed64Entry")
-	proto.RegisterMapType((map[int32]float64)(nil), "conformance.TestAllTypes.MapInt32DoubleEntry")
-	proto.RegisterMapType((map[int32]float32)(nil), "conformance.TestAllTypes.MapInt32FloatEntry")
-	proto.RegisterMapType((map[int32]int32)(nil), "conformance.TestAllTypes.MapInt32Int32Entry")
-	proto.RegisterMapType((map[int64]int64)(nil), "conformance.TestAllTypes.MapInt64Int64Entry")
-	proto.RegisterMapType((map[int32]int32)(nil), "conformance.TestAllTypes.MapSfixed32Sfixed32Entry")
-	proto.RegisterMapType((map[int64]int64)(nil), "conformance.TestAllTypes.MapSfixed64Sfixed64Entry")
-	proto.RegisterMapType((map[int32]int32)(nil), "conformance.TestAllTypes.MapSint32Sint32Entry")
-	proto.RegisterMapType((map[int64]int64)(nil), "conformance.TestAllTypes.MapSint64Sint64Entry")
-	proto.RegisterMapType((map[string][]byte)(nil), "conformance.TestAllTypes.MapStringBytesEntry")
-	proto.RegisterMapType((map[string]ForeignEnum)(nil), "conformance.TestAllTypes.MapStringForeignEnumEntry")
-	proto.RegisterMapType((map[string]*ForeignMessage)(nil), "conformance.TestAllTypes.MapStringForeignMessageEntry")
-	proto.RegisterMapType((map[string]TestAllTypes_NestedEnum)(nil), "conformance.TestAllTypes.MapStringNestedEnumEntry")
-	proto.RegisterMapType((map[string]*TestAllTypes_NestedMessage)(nil), "conformance.TestAllTypes.MapStringNestedMessageEntry")
-	proto.RegisterMapType((map[string]string)(nil), "conformance.TestAllTypes.MapStringStringEntry")
-	proto.RegisterMapType((map[uint32]uint32)(nil), "conformance.TestAllTypes.MapUint32Uint32Entry")
-	proto.RegisterMapType((map[uint64]uint64)(nil), "conformance.TestAllTypes.MapUint64Uint64Entry")
-	proto.RegisterType((*TestAllTypes_NestedMessage)(nil), "conformance.TestAllTypes.NestedMessage")
-	proto.RegisterType((*ForeignMessage)(nil), "conformance.ForeignMessage")
-	proto.RegisterEnum("conformance.WireFormat", WireFormat_name, WireFormat_value)
-	proto.RegisterEnum("conformance.ForeignEnum", ForeignEnum_name, ForeignEnum_value)
-	proto.RegisterEnum("conformance.TestAllTypes_NestedEnum", TestAllTypes_NestedEnum_name, TestAllTypes_NestedEnum_value)
-}
-
-func init() { proto.RegisterFile("conformance.proto", fileDescriptor_conformance_48ac832451f5d6c3) }
-
-var fileDescriptor_conformance_48ac832451f5d6c3 = []byte{
-	// 2600 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x5a, 0x5b, 0x73, 0x13, 0xc9,
-	0x15, 0xf6, 0x68, 0xc0, 0x36, 0x2d, 0xd9, 0x96, 0xdb, 0xb7, 0xc6, 0x50, 0xcb, 0x60, 0x96, 0x20,
-	0x60, 0xd7, 0xeb, 0xcb, 0x30, 0x5c, 0x36, 0x4b, 0xb0, 0xc0, 0x02, 0x93, 0xc5, 0xa2, 0xc6, 0x78,
-	0xa9, 0x22, 0x0f, 0xca, 0x20, 0x8f, 0x5d, 0x5a, 0x24, 0x8d, 0x76, 0x66, 0xb4, 0x89, 0xf3, 0x98,
-	0x7f, 0x90, 0xfb, 0xf5, 0x2f, 0xe4, 0x5a, 0x95, 0x4a, 0x52, 0xc9, 0x53, 0x2a, 0x2f, 0xb9, 0x27,
-	0x95, 0x7b, 0xf2, 0x63, 0x92, 0xea, 0xeb, 0x74, 0xb7, 0x7a, 0x64, 0xb1, 0x55, 0x2b, 0x5b, 0xa7,
-	0xbf, 0xfe, 0xce, 0xe9, 0xd3, 0x67, 0xbe, 0x76, 0x9f, 0x01, 0xcc, 0x36, 0xa3, 0xee, 0x61, 0x14,
-	0x77, 0x82, 0x6e, 0x33, 0x5c, 0xed, 0xc5, 0x51, 0x1a, 0xc1, 0xa2, 0x64, 0x5a, 0x3e, 0x7b, 0x14,
-	0x45, 0x47, 0xed, 0xf0, 0x1d, 0x32, 0xf4, 0xb2, 0x7f, 0xf8, 0x4e, 0xd0, 0x3d, 0xa6, 0xb8, 0xe5,
-	0x37, 0xf4, 0xa1, 0x83, 0x7e, 0x1c, 0xa4, 0xad, 0xa8, 0xcb, 0xc6, 0x1d, 0x7d, 0xfc, 0xb0, 0x15,
-	0xb6, 0x0f, 0x1a, 0x9d, 0x20, 0x79, 0xc5, 0x10, 0xe7, 0x75, 0x44, 0x92, 0xc6, 0xfd, 0x66, 0xca,
-	0x46, 0x2f, 0xe8, 0xa3, 0x69, 0xab, 0x13, 0x26, 0x69, 0xd0, 0xe9, 0xe5, 0x05, 0xf0, 0xb9, 0x38,
-	0xe8, 0xf5, 0xc2, 0x38, 0xa1, 0xe3, 0x2b, 0xbf, 0xb2, 0x00, 0xbc, 0x9f, 0xad, 0xc5, 0x0f, 0x3f,
-	0xea, 0x87, 0x49, 0x0a, 0xaf, 0x83, 0x32, 0x9f, 0xd1, 0xe8, 0x05, 0xc7, 0xed, 0x28, 0x38, 0x40,
-	0x96, 0x63, 0x55, 0x4a, 0x8f, 0xc6, 0xfc, 0x19, 0x3e, 0xf2, 0x94, 0x0e, 0xc0, 0x4b, 0xa0, 0xf4,
-	0x61, 0x12, 0x75, 0x05, 0xb0, 0xe0, 0x58, 0x95, 0x33, 0x8f, 0xc6, 0xfc, 0x22, 0xb6, 0x72, 0x50,
-	0x1d, 0x2c, 0xc5, 0x94, 0x3c, 0x3c, 0x68, 0x44, 0xfd, 0xb4, 0xd7, 0x4f, 0x1b, 0xc4, 0x6b, 0x8a,
-	0x6c, 0xc7, 0xaa, 0x4c, 0x6f, 0x2c, 0xad, 0xca, 0x69, 0x7e, 0xde, 0x8a, 0xc3, 0x1a, 0x19, 0xf6,
-	0x17, 0xc4, 0xbc, 0x3a, 0x99, 0x46, 0xcd, 0xd5, 0x33, 0x60, 0x82, 0x39, 0x5c, 0xf9, 0x62, 0x01,
-	0xcc, 0x29, 0x8b, 0x48, 0x7a, 0x51, 0x37, 0x09, 0xe1, 0x45, 0x50, 0xec, 0x05, 0x71, 0x12, 0x36,
-	0xc2, 0x38, 0x8e, 0x62, 0xb2, 0x00, 0x1c, 0x17, 0x20, 0xc6, 0x6d, 0x6c, 0x83, 0x57, 0xc1, 0x4c,
-	0x12, 0xc6, 0xad, 0xa0, 0xdd, 0xfa, 0x02, 0x87, 0x8d, 0x33, 0xd8, 0xb4, 0x18, 0xa0, 0xd0, 0xcb,
-	0x60, 0x2a, 0xee, 0x77, 0x71, 0x82, 0x19, 0x90, 0xaf, 0xb3, 0xc4, 0xcc, 0x14, 0x66, 0x4a, 0x9d,
-	0x3d, 0x6a, 0xea, 0x4e, 0x99, 0x52, 0xb7, 0x0c, 0x26, 0x92, 0x57, 0xad, 0x5e, 0x2f, 0x3c, 0x40,
-	0xa7, 0xd9, 0x38, 0x37, 0x54, 0x27, 0xc1, 0x78, 0x1c, 0x26, 0xfd, 0x76, 0xba, 0xf2, 0x93, 0xfb,
-	0xa0, 0xf4, 0x2c, 0x4c, 0xd2, 0xad, 0x76, 0xfb, 0xd9, 0x71, 0x2f, 0x4c, 0xe0, 0x65, 0x30, 0x1d,
-	0xf5, 0x70, 0xad, 0x05, 0xed, 0x46, 0xab, 0x9b, 0x6e, 0x6e, 0x90, 0x04, 0x9c, 0xf6, 0xa7, 0xb8,
-	0x75, 0x07, 0x1b, 0x75, 0x98, 0xe7, 0x92, 0x75, 0xd9, 0x0a, 0xcc, 0x73, 0xe1, 0x15, 0x30, 0x23,
-	0x60, 0x7d, 0x4a, 0x87, 0x57, 0x35, 0xe5, 0x8b, 0xd9, 0xfb, 0xc4, 0x3a, 0x00, 0xf4, 0x5c, 0xb2,
-	0xaa, 0x53, 0x2a, 0x50, 0x63, 0x4c, 0x28, 0x23, 0x5e, 0xde, 0x6c, 0x06, 0xdc, 0x1b, 0x64, 0x4c,
-	0x28, 0x23, 0xde, 0x23, 0xa8, 0x02, 0x3d, 0x17, 0x5e, 0x05, 0x65, 0x01, 0x3c, 0x6c, 0x7d, 0x3e,
-	0x3c, 0xd8, 0xdc, 0x40, 0x13, 0x8e, 0x55, 0x99, 0xf0, 0x05, 0x41, 0x8d, 0x9a, 0x07, 0xa1, 0x9e,
-	0x8b, 0x26, 0x1d, 0xab, 0x32, 0xae, 0x41, 0x3d, 0x17, 0x5e, 0x07, 0xb3, 0x99, 0x7b, 0x4e, 0x7b,
-	0xc6, 0xb1, 0x2a, 0x33, 0xbe, 0xe0, 0xd8, 0x63, 0x76, 0x03, 0xd8, 0x73, 0x11, 0x70, 0xac, 0x4a,
-	0x59, 0x07, 0x7b, 0xae, 0x92, 0xfa, 0xc3, 0x76, 0x14, 0xa4, 0xa8, 0xe8, 0x58, 0x95, 0x42, 0x96,
-	0xfa, 0x1a, 0x36, 0x2a, 0xeb, 0x3f, 0x88, 0xfa, 0x2f, 0xdb, 0x21, 0x2a, 0x39, 0x56, 0xc5, 0xca,
-	0xd6, 0xff, 0x80, 0x58, 0xe1, 0x25, 0x20, 0x66, 0x36, 0x5e, 0x46, 0x51, 0x1b, 0x4d, 0x39, 0x56,
-	0x65, 0xd2, 0x2f, 0x71, 0x63, 0x35, 0x8a, 0xda, 0x6a, 0x36, 0xd3, 0xb8, 0xd5, 0x3d, 0x42, 0xd3,
-	0xb8, 0xaa, 0xa4, 0x6c, 0x12, 0xab, 0x12, 0xdd, 0xcb, 0xe3, 0x34, 0x4c, 0xd0, 0x0c, 0x2e, 0xe3,
-	0x2c, 0xba, 0x2a, 0x36, 0xc2, 0x06, 0x58, 0x12, 0xb0, 0x2e, 0x7d, 0xbc, 0x3b, 0x61, 0x92, 0x04,
-	0x47, 0x21, 0x82, 0x8e, 0x55, 0x29, 0x6e, 0x5c, 0x51, 0x1e, 0x6c, 0xb9, 0x44, 0x57, 0x77, 0x09,
-	0xfe, 0x09, 0x85, 0xfb, 0x0b, 0x9c, 0x47, 0x31, 0xc3, 0x7d, 0x80, 0xb2, 0x2c, 0x45, 0x71, 0xd8,
-	0x3a, 0xea, 0x0a, 0x0f, 0x73, 0xc4, 0xc3, 0x39, 0xc5, 0x43, 0x8d, 0x62, 0x38, 0xeb, 0xa2, 0x48,
-	0xa6, 0x62, 0x87, 0x1f, 0x80, 0x79, 0x3d, 0xee, 0xb0, 0xdb, 0xef, 0xa0, 0x05, 0xa2, 0x46, 0x6f,
-	0x9e, 0x14, 0xf4, 0x76, 0xb7, 0xdf, 0xf1, 0xa1, 0x1a, 0x31, 0xb6, 0xc1, 0xf7, 0xc1, 0xc2, 0x40,
-	0xb8, 0x84, 0x78, 0x91, 0x10, 0x23, 0x53, 0xac, 0x84, 0x6c, 0x4e, 0x0b, 0x94, 0xb0, 0x79, 0x12,
-	0x1b, 0xdd, 0xad, 0x46, 0xaf, 0x15, 0x36, 0x43, 0x84, 0xf0, 0x9e, 0x55, 0x0b, 0x93, 0x85, 0x6c,
-	0x1e, 0xdd, 0xb7, 0xa7, 0x78, 0x18, 0x5e, 0x91, 0x4a, 0xa1, 0x19, 0xc5, 0x07, 0xe8, 0x2c, 0xc3,
-	0x5b, 0x59, 0x39, 0xdc, 0x8f, 0xe2, 0x03, 0x58, 0x03, 0xb3, 0x71, 0xd8, 0xec, 0xc7, 0x49, 0xeb,
-	0xe3, 0x50, 0xa4, 0xf5, 0x1c, 0x49, 0xeb, 0xd9, 0xdc, 0x1c, 0xf8, 0x65, 0x31, 0x87, 0xa7, 0xf3,
-	0x32, 0x98, 0x8e, 0xc3, 0x5e, 0x18, 0xe0, 0x3c, 0xd2, 0x87, 0xf9, 0x82, 0x63, 0x63, 0xb5, 0xe1,
-	0x56, 0xa1, 0x36, 0x32, 0xcc, 0x73, 0x91, 0xe3, 0xd8, 0x58, 0x6d, 0x24, 0x18, 0xd5, 0x06, 0x01,
-	0x63, 0x6a, 0x73, 0xd1, 0xb1, 0xb1, 0xda, 0x70, 0x73, 0xa6, 0x36, 0x0a, 0xd0, 0x73, 0xd1, 0x8a,
-	0x63, 0x63, 0xb5, 0x91, 0x81, 0x1a, 0x23, 0x53, 0x9b, 0x4b, 0x8e, 0x8d, 0xd5, 0x86, 0x9b, 0xf7,
-	0x06, 0x19, 0x99, 0xda, 0xbc, 0xe9, 0xd8, 0x58, 0x6d, 0x64, 0x20, 0x55, 0x1b, 0x01, 0xe4, 0xb2,
-	0x70, 0xd9, 0xb1, 0xb1, 0xda, 0x70, 0xbb, 0xa4, 0x36, 0x2a, 0xd4, 0x73, 0xd1, 0x27, 0x1c, 0x1b,
-	0xab, 0x8d, 0x02, 0xa5, 0x6a, 0x93, 0xb9, 0xe7, 0xb4, 0x57, 0x1c, 0x1b, 0xab, 0x8d, 0x08, 0x40,
-	0x52, 0x1b, 0x0d, 0xec, 0xb9, 0xa8, 0xe2, 0xd8, 0x58, 0x6d, 0x54, 0x30, 0x55, 0x9b, 0x2c, 0x08,
-	0xa2, 0x36, 0x57, 0x1d, 0x1b, 0xab, 0x8d, 0x08, 0x81, 0xab, 0x8d, 0x80, 0x31, 0xb5, 0xb9, 0xe6,
-	0xd8, 0x58, 0x6d, 0xb8, 0x39, 0x53, 0x1b, 0x01, 0x24, 0x6a, 0x73, 0xdd, 0xb1, 0xb1, 0xda, 0x70,
-	0x23, 0x57, 0x9b, 0x2c, 0x42, 0xaa, 0x36, 0x6f, 0x39, 0x36, 0x56, 0x1b, 0x11, 0x9f, 0x50, 0x9b,
-	0x8c, 0x8d, 0xa8, 0xcd, 0xdb, 0x8e, 0x8d, 0xd5, 0x46, 0xd0, 0x71, 0xb5, 0x11, 0x30, 0x4d, 0x6d,
-	0xd6, 0x1c, 0xfb, 0xb5, 0xd4, 0x86, 0xf3, 0x0c, 0xa8, 0x4d, 0x96, 0x25, 0x4d, 0x6d, 0xd6, 0x89,
-	0x87, 0xe1, 0x6a, 0x23, 0x92, 0x39, 0xa0, 0x36, 0x7a, 0xdc, 0x44, 0x14, 0x36, 0x1d, 0x7b, 0x74,
-	0xb5, 0x51, 0x23, 0xe6, 0x6a, 0x33, 0x10, 0x2e, 0x21, 0x76, 0x09, 0xf1, 0x10, 0xb5, 0xd1, 0x02,
-	0xe5, 0x6a, 0xa3, 0xed, 0x16, 0x53, 0x1b, 0x0f, 0xef, 0x19, 0x55, 0x1b, 0x75, 0xdf, 0x84, 0xda,
-	0x88, 0x79, 0x44, 0x6d, 0x6e, 0x32, 0xbc, 0x95, 0x95, 0x03, 0x51, 0x9b, 0x67, 0x60, 0xa6, 0x13,
-	0xf4, 0xa8, 0x40, 0x30, 0x99, 0xb8, 0x45, 0x92, 0xfa, 0x56, 0x7e, 0x06, 0x9e, 0x04, 0x3d, 0xa2,
-	0x1d, 0xe4, 0x63, 0xbb, 0x9b, 0xc6, 0xc7, 0xfe, 0x54, 0x47, 0xb6, 0x49, 0xac, 0x9e, 0xcb, 0x54,
-	0xe5, 0xf6, 0x68, 0xac, 0x9e, 0x4b, 0x3e, 0x14, 0x56, 0x66, 0x83, 0x2f, 0xc0, 0x2c, 0x66, 0xa5,
-	0xf2, 0xc3, 0x55, 0xe8, 0x0e, 0xe1, 0x5d, 0x1d, 0xca, 0x4b, 0xa5, 0x89, 0x7e, 0x52, 0x66, 0x1c,
-	0x9e, 0x6c, 0x95, 0xb9, 0x3d, 0x97, 0x0b, 0xd7, 0xbb, 0x23, 0x72, 0x7b, 0x2e, 0xfd, 0x54, 0xb9,
-	0xb9, 0x95, 0x73, 0x53, 0x91, 0xe3, 0x5a, 0xf7, 0xc9, 0x11, 0xb8, 0xa9, 0x00, 0xee, 0x69, 0x71,
-	0xcb, 0x56, 0x99, 0xdb, 0x73, 0xb9, 0x3c, 0xbe, 0x37, 0x22, 0xb7, 0xe7, 0xee, 0x69, 0x71, 0xcb,
-	0x56, 0xf8, 0x59, 0x30, 0x87, 0xb9, 0x99, 0xb6, 0x09, 0x49, 0xbd, 0x4b, 0xd8, 0xd7, 0x86, 0xb2,
-	0x33, 0x9d, 0x65, 0x3f, 0x28, 0x3f, 0x0e, 0x54, 0xb5, 0x2b, 0x1e, 0x3c, 0x57, 0x28, 0xf1, 0xa7,
-	0x46, 0xf5, 0xe0, 0xb9, 0xec, 0x87, 0xe6, 0x41, 0xd8, 0xe1, 0x21, 0x58, 0x20, 0xf9, 0xe1, 0x8b,
-	0x10, 0x0a, 0x7e, 0x8f, 0xf8, 0xd8, 0x18, 0x9e, 0x23, 0x06, 0xe6, 0x3f, 0xa9, 0x17, 0x1c, 0xb2,
-	0x3e, 0xa2, 0xfa, 0xc1, 0x3b, 0xc1, 0xd7, 0xb2, 0x35, 0xb2, 0x1f, 0xcf, 0xe5, 0x3f, 0x75, 0x3f,
-	0xd9, 0x88, 0xfa, 0xbc, 0xd2, 0x43, 0xa3, 0x3a, 0xea, 0xf3, 0x4a, 0x8e, 0x13, 0xed, 0x79, 0xa5,
-	0x47, 0xcc, 0x73, 0x50, 0xce, 0x58, 0xd9, 0x19, 0x73, 0x9f, 0xd0, 0xbe, 0x7d, 0x32, 0x2d, 0x3d,
-	0x7d, 0x28, 0xef, 0x74, 0x47, 0x31, 0xc2, 0x5d, 0x80, 0x3d, 0x91, 0xd3, 0x88, 0x1e, 0x49, 0x0f,
-	0x08, 0xeb, 0xb5, 0xa1, 0xac, 0xf8, 0x9c, 0xc2, 0xff, 0x53, 0xca, 0x62, 0x27, 0xb3, 0x88, 0x72,
-	0xa7, 0x52, 0xc8, 0xce, 0xaf, 0xed, 0x51, 0xca, 0x9d, 0x40, 0xe9, 0xa7, 0x54, 0xee, 0x92, 0x95,
-	0x27, 0x81, 0x71, 0xd3, 0x23, 0xaf, 0x36, 0x42, 0x12, 0xe8, 0x74, 0x72, 0x1a, 0x66, 0x49, 0x90,
-	0x8c, 0xb0, 0x07, 0xce, 0x4a, 0xc4, 0xda, 0x21, 0xf9, 0x90, 0x78, 0xb8, 0x31, 0x82, 0x07, 0xe5,
-	0x58, 0xa4, 0x9e, 0x16, 0x3b, 0xc6, 0x41, 0x98, 0x80, 0x65, 0xc9, 0xa3, 0x7e, 0x6a, 0x3e, 0x22,
-	0x2e, 0xbd, 0x11, 0x5c, 0xaa, 0x67, 0x26, 0xf5, 0xb9, 0xd4, 0x31, 0x8f, 0xc2, 0x23, 0xb0, 0x38,
-	0xb8, 0x4c, 0x72, 0xf4, 0xed, 0x8c, 0xf2, 0x0c, 0x48, 0xcb, 0xc0, 0x47, 0x9f, 0xf4, 0x0c, 0x68,
-	0x23, 0xf0, 0x43, 0xb0, 0x64, 0x58, 0x1d, 0xf1, 0xf4, 0x98, 0x78, 0xda, 0x1c, 0x7d, 0x69, 0x99,
-	0xab, 0xf9, 0x8e, 0x61, 0x08, 0x5e, 0x02, 0xa5, 0xa8, 0x1b, 0x46, 0x87, 0xfc, 0xb8, 0x89, 0xf0,
-	0x15, 0xfb, 0xd1, 0x98, 0x5f, 0x24, 0x56, 0x76, 0x78, 0x7c, 0x06, 0xcc, 0x53, 0x90, 0xb6, 0xb7,
-	0xbd, 0xd7, 0xba, 0x6e, 0x3d, 0x1a, 0xf3, 0x21, 0xa1, 0x51, 0xf7, 0x52, 0x44, 0xc0, 0xaa, 0xfd,
-	0x23, 0xde, 0x91, 0x20, 0x56, 0x56, 0xbb, 0x17, 0x01, 0xfd, 0xca, 0xca, 0x36, 0x66, 0xed, 0x0d,
-	0x40, 0x8c, 0xb4, 0x0a, 0xeb, 0xd2, 0xc5, 0x85, 0x3c, 0x8f, 0xac, 0xf1, 0x84, 0x7e, 0x63, 0x91,
-	0x30, 0x97, 0x57, 0x69, 0x67, 0x6a, 0x95, 0xb7, 0x44, 0x56, 0xf1, 0x13, 0xf7, 0x41, 0xd0, 0xee,
-	0x87, 0xd9, 0x8d, 0x06, 0x9b, 0x9e, 0xd3, 0x79, 0xd0, 0x07, 0x8b, 0x6a, 0x3b, 0x43, 0x30, 0xfe,
-	0xd6, 0x62, 0xb7, 0x40, 0x9d, 0x91, 0x48, 0x03, 0xa5, 0x9c, 0x57, 0x9a, 0x1e, 0x39, 0x9c, 0x9e,
-	0x2b, 0x38, 0x7f, 0x37, 0x84, 0xd3, 0x73, 0x07, 0x39, 0x3d, 0x97, 0x73, 0xee, 0x4b, 0xf7, 0xe1,
-	0xbe, 0x1a, 0xe8, 0xef, 0x29, 0xe9, 0xf9, 0x01, 0xd2, 0x7d, 0x29, 0xd2, 0x05, 0xb5, 0x9f, 0x92,
-	0x47, 0x2b, 0xc5, 0xfa, 0x87, 0x61, 0xb4, 0x3c, 0xd8, 0x05, 0xb5, 0xfb, 0x62, 0xca, 0x00, 0xd1,
-	0x77, 0xc1, 0xfa, 0xc7, 0xbc, 0x0c, 0x10, 0x0d, 0xd7, 0x32, 0x40, 0x6c, 0xa6, 0x50, 0xa9, 0xba,
-	0x0b, 0xd2, 0x3f, 0xe5, 0x85, 0x4a, 0x05, 0x5c, 0x0b, 0x95, 0x1a, 0x4d, 0xb4, 0xec, 0x61, 0xe4,
-	0xb4, 0x7f, 0xce, 0xa3, 0xa5, 0xf5, 0xaa, 0xd1, 0x52, 0xa3, 0x29, 0x03, 0xa4, 0x9c, 0x05, 0xeb,
-	0x5f, 0xf2, 0x32, 0x40, 0x2a, 0x5c, 0xcb, 0x00, 0xb1, 0x71, 0xce, 0xba, 0xf4, 0x77, 0xb4, 0x52,
-	0xfc, 0x7f, 0xb5, 0x88, 0x62, 0x0c, 0x2d, 0x7e, 0xf9, 0xfe, 0x24, 0x05, 0xa9, 0xde, 0xae, 0x05,
-	0xe3, 0xdf, 0x2c, 0x76, 0x29, 0x19, 0x56, 0xfc, 0xca, 0x1d, 0x3c, 0x87, 0x53, 0x2a, 0xa8, 0xbf,
-	0x0f, 0xe1, 0x14, 0xc5, 0xaf, 0x5c, 0xd8, 0xa5, 0x3d, 0xd2, 0xee, 0xed, 0x82, 0xf4, 0x1f, 0x94,
-	0xf4, 0x84, 0xe2, 0x57, 0xaf, 0xf7, 0x79, 0xb4, 0x52, 0xac, 0xff, 0x1c, 0x46, 0x2b, 0x8a, 0x5f,
-	0x6d, 0x06, 0x98, 0x32, 0xa0, 0x16, 0xff, 0xbf, 0xf2, 0x32, 0x20, 0x17, 0xbf, 0x72, 0x6f, 0x36,
-	0x85, 0xaa, 0x15, 0xff, 0xbf, 0xf3, 0x42, 0x55, 0x8a, 0x5f, 0xbd, 0x65, 0x9b, 0x68, 0xb5, 0xe2,
-	0xff, 0x4f, 0x1e, 0xad, 0x52, 0xfc, 0xea, 0xb5, 0xcd, 0x94, 0x01, 0xb5, 0xf8, 0xff, 0x9b, 0x97,
-	0x01, 0xb9, 0xf8, 0x95, 0xbb, 0x39, 0xe7, 0x7c, 0x28, 0xb5, 0x40, 0xf9, 0xeb, 0x0e, 0xf4, 0xbd,
-	0x02, 0x6b, 0x29, 0x0d, 0xac, 0x9d, 0x21, 0xb2, 0xf6, 0x28, 0xb7, 0xc0, 0xc7, 0x40, 0xf4, 0xd7,
-	0x1a, 0xe2, 0xbd, 0x06, 0xfa, 0x7e, 0x21, 0xe7, 0xfc, 0x78, 0xc6, 0x21, 0xbe, 0xf0, 0x2f, 0x4c,
-	0xf0, 0xd3, 0x60, 0x4e, 0xea, 0xf7, 0xf2, 0x77, 0x2c, 0xe8, 0x07, 0x79, 0x64, 0x35, 0x8c, 0x79,
-	0x12, 0x24, 0xaf, 0x32, 0x32, 0x61, 0x82, 0x5b, 0x6a, 0x0b, 0xb5, 0xdf, 0x4c, 0xd1, 0x0f, 0x29,
-	0xd1, 0x92, 0x69, 0x13, 0xfa, 0xcd, 0x54, 0x69, 0xae, 0xf6, 0x9b, 0x29, 0xbc, 0x05, 0x44, 0x1b,
-	0xae, 0x11, 0x74, 0x8f, 0xd1, 0x8f, 0xe8, 0xfc, 0xf9, 0x81, 0xf9, 0x5b, 0xdd, 0x63, 0xbf, 0xc8,
-	0xa1, 0x5b, 0xdd, 0x63, 0x78, 0x57, 0x6a, 0xcb, 0x7e, 0x8c, 0xb7, 0x01, 0xfd, 0x98, 0xce, 0x5d,
-	0x1c, 0x98, 0x4b, 0x77, 0x49, 0x34, 0x02, 0xc9, 0x57, 0xbc, 0x3d, 0x59, 0x81, 0xf2, 0xed, 0xf9,
-	0x69, 0x81, 0xec, 0xf6, 0xb0, 0xed, 0x11, 0x75, 0x29, 0x6d, 0x8f, 0x20, 0xca, 0xb6, 0xe7, 0x67,
-	0x85, 0x1c, 0x85, 0x93, 0xb6, 0x87, 0x4f, 0xcb, 0xb6, 0x47, 0xe6, 0x22, 0xdb, 0x43, 0x76, 0xe7,
-	0xe7, 0x79, 0x5c, 0xd2, 0xee, 0x64, 0xfd, 0x33, 0x36, 0x0b, 0xef, 0x8e, 0xfc, 0xa8, 0xe0, 0xdd,
-	0xf9, 0x35, 0x25, 0xca, 0xdf, 0x1d, 0xe9, 0xe9, 0x60, 0xbb, 0x23, 0x28, 0xf0, 0xee, 0xfc, 0x82,
-	0xce, 0xcf, 0xd9, 0x1d, 0x0e, 0x65, 0xbb, 0x23, 0x66, 0xd2, 0xdd, 0xf9, 0x25, 0x9d, 0x9b, 0xbb,
-	0x3b, 0x1c, 0x4e, 0x77, 0xe7, 0x02, 0x00, 0x64, 0xfd, 0xdd, 0xa0, 0x13, 0xae, 0xa3, 0x2f, 0xd9,
-	0xe4, 0x8d, 0x8d, 0x64, 0x82, 0x0e, 0x28, 0xd2, 0xfa, 0xc5, 0x5f, 0x37, 0xd0, 0x97, 0x65, 0xc4,
-	0x2e, 0x36, 0xc1, 0x8b, 0xa0, 0xd4, 0xc8, 0x20, 0x9b, 0xe8, 0x2b, 0x0c, 0x52, 0xe3, 0x90, 0x4d,
-	0xb8, 0x02, 0xa6, 0x28, 0x82, 0x40, 0xdc, 0x06, 0xfa, 0xaa, 0x4e, 0xe3, 0xe2, 0xbf, 0xf1, 0xc8,
-	0xb7, 0x35, 0x0c, 0xb9, 0x81, 0xbe, 0x46, 0x11, 0xb2, 0x0d, 0x5e, 0xe2, 0x34, 0x6b, 0x84, 0xc7,
-	0x43, 0x5f, 0x57, 0x40, 0x98, 0xc7, 0x13, 0x2b, 0xc2, 0xdf, 0x6e, 0xa2, 0x6f, 0xe8, 0x8e, 0x6e,
-	0x62, 0x80, 0x08, 0xed, 0x16, 0xfa, 0xa6, 0x1e, 0xed, 0xad, 0x6c, 0xc9, 0xf8, 0xeb, 0x6d, 0xf4,
-	0x2d, 0x9d, 0xe2, 0x36, 0x5c, 0x01, 0xa5, 0x9a, 0x40, 0xac, 0xaf, 0xa1, 0x6f, 0xb3, 0x38, 0x04,
-	0xc9, 0xfa, 0x1a, 0xc1, 0xec, 0x6c, 0xbf, 0xff, 0xa0, 0xb1, 0xbb, 0xf5, 0x64, 0x7b, 0x7d, 0x1d,
-	0x7d, 0x87, 0x63, 0xb0, 0x91, 0xda, 0x32, 0x0c, 0xc9, 0xf5, 0x06, 0xfa, 0xae, 0x82, 0x21, 0xb6,
-	0xe5, 0x17, 0x60, 0x4a, 0xfd, 0x8b, 0xb9, 0x04, 0xac, 0x80, 0xbd, 0x5a, 0xb3, 0x02, 0xf8, 0x2e,
-	0x28, 0x36, 0x23, 0xd1, 0x1d, 0x47, 0x85, 0x93, 0x3a, 0xe9, 0x32, 0x7a, 0xf9, 0x1e, 0x80, 0x83,
-	0xdd, 0x2e, 0x58, 0x06, 0xf6, 0xab, 0xf0, 0x98, 0xb9, 0xc0, 0xbf, 0xc2, 0x79, 0x70, 0x9a, 0x16,
-	0x57, 0x81, 0xd8, 0xe8, 0x97, 0x3b, 0x85, 0x5b, 0x56, 0xc6, 0x20, 0x77, 0xb6, 0x64, 0x06, 0xdb,
-	0xc0, 0x60, 0xcb, 0x0c, 0x55, 0x30, 0x6f, 0xea, 0x61, 0xc9, 0x1c, 0x53, 0x06, 0x8e, 0x29, 0x33,
-	0x87, 0xd2, 0xab, 0x92, 0x39, 0x4e, 0x19, 0x38, 0x4e, 0x0d, 0x72, 0x0c, 0xf4, 0xa4, 0x64, 0x8e,
-	0x59, 0x03, 0xc7, 0xac, 0x99, 0x43, 0xe9, 0x3d, 0xc9, 0x1c, 0xd0, 0xc0, 0x01, 0x65, 0x8e, 0x07,
-	0x60, 0xd1, 0xdc, 0x61, 0x92, 0x59, 0x26, 0x0c, 0x2c, 0x13, 0x39, 0x2c, 0x6a, 0x17, 0x49, 0x66,
-	0x19, 0x37, 0xb0, 0x8c, 0xcb, 0x2c, 0x35, 0x80, 0xf2, 0xfa, 0x44, 0x32, 0xcf, 0x8c, 0x81, 0x67,
-	0x26, 0x8f, 0x47, 0xeb, 0x03, 0xc9, 0x3c, 0x65, 0x03, 0x4f, 0xd9, 0x58, 0x6d, 0x72, 0xb7, 0xe7,
-	0xa4, 0x7a, 0x2d, 0xc8, 0x0c, 0x5b, 0x60, 0xce, 0xd0, 0xd8, 0x39, 0x89, 0xc2, 0x92, 0x29, 0xee,
-	0x82, 0xb2, 0xde, 0xc5, 0x91, 0xe7, 0x4f, 0x1a, 0xe6, 0x4f, 0x1a, 0x8a, 0x44, 0xef, 0xd8, 0xc8,
-	0x1c, 0x67, 0x0c, 0x1c, 0x67, 0x06, 0x97, 0xa1, 0xb7, 0x66, 0x4e, 0xa2, 0x28, 0xc9, 0x14, 0x31,
-	0x38, 0x37, 0xa4, 0xf7, 0x62, 0xa0, 0x7a, 0x4f, 0xa6, 0x7a, 0x8d, 0x17, 0x1f, 0x92, 0xcf, 0x23,
-	0x70, 0x7e, 0x58, 0xf3, 0xc5, 0xe0, 0x74, 0x5d, 0x75, 0x3a, 0xf4, 0x5d, 0x88, 0xe4, 0xa8, 0x4d,
-	0x0b, 0xce, 0xd4, 0x74, 0x31, 0x38, 0xb9, 0x23, 0x3b, 0x19, 0xf5, 0xed, 0x88, 0xe4, 0x2d, 0x00,
-	0x67, 0x73, 0x1b, 0x2f, 0x06, 0x77, 0xab, 0xaa, 0xbb, 0xfc, 0x77, 0x26, 0x99, 0x8b, 0x95, 0xdb,
-	0x00, 0x48, 0x2d, 0xa2, 0x09, 0x60, 0xd7, 0xea, 0xf5, 0xf2, 0x18, 0xfe, 0xa5, 0xba, 0xe5, 0x97,
-	0x2d, 0xfa, 0xcb, 0x8b, 0x72, 0x01, 0xbb, 0xdb, 0xdd, 0x7e, 0x58, 0xfe, 0x1f, 0xff, 0xcf, 0xaa,
-	0x4e, 0xf1, 0xe6, 0x09, 0x39, 0xc0, 0x56, 0xde, 0x00, 0xd3, 0x5a, 0x67, 0xab, 0x04, 0xac, 0x26,
-	0x3f, 0x50, 0x9a, 0xd7, 0x6e, 0x00, 0x90, 0xfd, 0x63, 0x18, 0x38, 0x03, 0x8a, 0xfb, 0xbb, 0x7b,
-	0x4f, 0xb7, 0xef, 0xef, 0xd4, 0x76, 0xb6, 0x1f, 0x94, 0xc7, 0x60, 0x09, 0x4c, 0x3e, 0xf5, 0xeb,
-	0xcf, 0xea, 0xd5, 0xfd, 0x5a, 0xd9, 0x82, 0x93, 0xe0, 0xd4, 0xe3, 0xbd, 0xfa, 0x6e, 0xb9, 0x70,
-	0xed, 0x1e, 0x28, 0xca, 0x8d, 0xa5, 0x19, 0x50, 0xac, 0xd5, 0xfd, 0xed, 0x9d, 0x87, 0xbb, 0x0d,
-	0x1a, 0xa9, 0x64, 0xa0, 0x11, 0x2b, 0x86, 0x17, 0xe5, 0x42, 0xf5, 0x22, 0xb8, 0xd0, 0x8c, 0x3a,
-	0x03, 0x7f, 0xb6, 0x48, 0xc9, 0x79, 0x39, 0x4e, 0xac, 0x9b, 0xff, 0x0f, 0x00, 0x00, 0xff, 0xff,
-	0x29, 0x30, 0x51, 0x54, 0x22, 0x25, 0x00, 0x00,
-}
diff --git a/vendor/github.com/golang/protobuf/conformance/internal/conformance_proto/conformance.proto b/vendor/github.com/golang/protobuf/conformance/internal/conformance_proto/conformance.proto
deleted file mode 100644
index fc96074ac..000000000
--- a/vendor/github.com/golang/protobuf/conformance/internal/conformance_proto/conformance.proto
+++ /dev/null
@@ -1,273 +0,0 @@
-// Protocol Buffers - Google's data interchange format
-// Copyright 2008 Google Inc.  All rights reserved.
-// https://developers.google.com/protocol-buffers/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto3";
-package conformance;
-option java_package = "com.google.protobuf.conformance";
-
-import "google/protobuf/any.proto";
-import "google/protobuf/duration.proto";
-import "google/protobuf/field_mask.proto";
-import "google/protobuf/struct.proto";
-import "google/protobuf/timestamp.proto";
-import "google/protobuf/wrappers.proto";
-
-// This defines the conformance testing protocol.  This protocol exists between
-// the conformance test suite itself and the code being tested.  For each test,
-// the suite will send a ConformanceRequest message and expect a
-// ConformanceResponse message.
-//
-// You can either run the tests in two different ways:
-//
-//   1. in-process (using the interface in conformance_test.h).
-//
-//   2. as a sub-process communicating over a pipe.  Information about how to
-//      do this is in conformance_test_runner.cc.
-//
-// Pros/cons of the two approaches:
-//
-//   - running as a sub-process is much simpler for languages other than C/C++.
-//
-//   - running as a sub-process may be more tricky in unusual environments like
-//     iOS apps, where fork/stdin/stdout are not available.
-
-enum WireFormat {
-  UNSPECIFIED = 0;
-  PROTOBUF = 1;
-  JSON = 2;
-}
-
-// Represents a single test case's input.  The testee should:
-//
-//   1. parse this proto (which should always succeed)
-//   2. parse the protobuf or JSON payload in "payload" (which may fail)
-//   3. if the parse succeeded, serialize the message in the requested format.
-message ConformanceRequest {
-  // The payload (whether protobuf of JSON) is always for a TestAllTypes proto
-  // (see below).
-  oneof payload {
-    bytes protobuf_payload = 1;
-    string json_payload = 2;
-  }
-
-  // Which format should the testee serialize its message to?
-  WireFormat requested_output_format = 3;
-}
-
-// Represents a single test case's output.
-message ConformanceResponse {
-  oneof result {
-    // This string should be set to indicate parsing failed.  The string can
-    // provide more information about the parse error if it is available.
-    //
-    // Setting this string does not necessarily mean the testee failed the
-    // test.  Some of the test cases are intentionally invalid input.
-    string parse_error = 1;
-
-    // If the input was successfully parsed but errors occurred when
-    // serializing it to the requested output format, set the error message in
-    // this field.
-    string serialize_error = 6;
-
-    // This should be set if some other error occurred.  This will always
-    // indicate that the test failed.  The string can provide more information
-    // about the failure.
-    string runtime_error = 2;
-
-    // If the input was successfully parsed and the requested output was
-    // protobuf, serialize it to protobuf and set it in this field.
-    bytes protobuf_payload = 3;
-
-    // If the input was successfully parsed and the requested output was JSON,
-    // serialize to JSON and set it in this field.
-    string json_payload = 4;
-
-    // For when the testee skipped the test, likely because a certain feature
-    // wasn't supported, like JSON input/output.
-    string skipped = 5;
-  }
-}
-
-// This proto includes every type of field in both singular and repeated
-// forms.
-message TestAllTypes {
-  message NestedMessage {
-    int32 a = 1;
-    TestAllTypes corecursive = 2;
-  }
-
-  enum NestedEnum {
-    FOO = 0;
-    BAR = 1;
-    BAZ = 2;
-    NEG = -1;  // Intentionally negative.
-  }
-
-  // Singular
-  int32 optional_int32    =  1;
-  int64 optional_int64    =  2;
-  uint32 optional_uint32   =  3;
-  uint64 optional_uint64   =  4;
-  sint32 optional_sint32   =  5;
-  sint64 optional_sint64   =  6;
-  fixed32 optional_fixed32  =  7;
-  fixed64 optional_fixed64  =  8;
-  sfixed32 optional_sfixed32 =  9;
-  sfixed64 optional_sfixed64 = 10;
-  float optional_float    = 11;
-  double optional_double   = 12;
-  bool optional_bool     = 13;
-  string optional_string   = 14;
-  bytes optional_bytes    = 15;
-
-  NestedMessage                        optional_nested_message  = 18;
-  ForeignMessage                       optional_foreign_message = 19;
-
-  NestedEnum                           optional_nested_enum     = 21;
-  ForeignEnum                          optional_foreign_enum    = 22;
-
-  string optional_string_piece = 24 [ctype=STRING_PIECE];
-  string optional_cord = 25 [ctype=CORD];
-
-  TestAllTypes recursive_message = 27;
-
-  // Repeated
-  repeated    int32 repeated_int32    = 31;
-  repeated    int64 repeated_int64    = 32;
-  repeated   uint32 repeated_uint32   = 33;
-  repeated   uint64 repeated_uint64   = 34;
-  repeated   sint32 repeated_sint32   = 35;
-  repeated   sint64 repeated_sint64   = 36;
-  repeated  fixed32 repeated_fixed32  = 37;
-  repeated  fixed64 repeated_fixed64  = 38;
-  repeated sfixed32 repeated_sfixed32 = 39;
-  repeated sfixed64 repeated_sfixed64 = 40;
-  repeated    float repeated_float    = 41;
-  repeated   double repeated_double   = 42;
-  repeated     bool repeated_bool     = 43;
-  repeated   string repeated_string   = 44;
-  repeated    bytes repeated_bytes    = 45;
-
-  repeated NestedMessage                        repeated_nested_message  = 48;
-  repeated ForeignMessage                       repeated_foreign_message = 49;
-
-  repeated NestedEnum                           repeated_nested_enum     = 51;
-  repeated ForeignEnum                          repeated_foreign_enum    = 52;
-
-  repeated string repeated_string_piece = 54 [ctype=STRING_PIECE];
-  repeated string repeated_cord = 55 [ctype=CORD];
-
-  // Map
-  map <   int32, int32>    map_int32_int32 = 56;
-  map <   int64, int64>    map_int64_int64 = 57;
-  map <  uint32, uint32>   map_uint32_uint32 = 58;
-  map <  uint64, uint64>   map_uint64_uint64 = 59;
-  map <  sint32, sint32>   map_sint32_sint32 = 60;
-  map <  sint64, sint64>   map_sint64_sint64 = 61;
-  map < fixed32, fixed32>  map_fixed32_fixed32 = 62;
-  map < fixed64, fixed64>  map_fixed64_fixed64 = 63;
-  map <sfixed32, sfixed32> map_sfixed32_sfixed32 = 64;
-  map <sfixed64, sfixed64> map_sfixed64_sfixed64 = 65;
-  map <   int32, float>    map_int32_float = 66;
-  map <   int32, double>   map_int32_double = 67;
-  map <    bool, bool>     map_bool_bool = 68;
-  map <  string, string>   map_string_string = 69;
-  map <  string, bytes>    map_string_bytes = 70;
-  map <  string, NestedMessage>  map_string_nested_message = 71;
-  map <  string, ForeignMessage> map_string_foreign_message = 72;
-  map <  string, NestedEnum>     map_string_nested_enum = 73;
-  map <  string, ForeignEnum>    map_string_foreign_enum = 74;
-
-  oneof oneof_field {
-    uint32 oneof_uint32 = 111;
-    NestedMessage oneof_nested_message = 112;
-    string oneof_string = 113;
-    bytes oneof_bytes = 114;
-  }
-
-  // Well-known types
-  google.protobuf.BoolValue optional_bool_wrapper = 201;
-  google.protobuf.Int32Value optional_int32_wrapper = 202;
-  google.protobuf.Int64Value optional_int64_wrapper = 203;
-  google.protobuf.UInt32Value optional_uint32_wrapper = 204;
-  google.protobuf.UInt64Value optional_uint64_wrapper = 205;
-  google.protobuf.FloatValue optional_float_wrapper = 206;
-  google.protobuf.DoubleValue optional_double_wrapper = 207;
-  google.protobuf.StringValue optional_string_wrapper = 208;
-  google.protobuf.BytesValue optional_bytes_wrapper = 209;
-
-  repeated google.protobuf.BoolValue repeated_bool_wrapper = 211;
-  repeated google.protobuf.Int32Value repeated_int32_wrapper = 212;
-  repeated google.protobuf.Int64Value repeated_int64_wrapper = 213;
-  repeated google.protobuf.UInt32Value repeated_uint32_wrapper = 214;
-  repeated google.protobuf.UInt64Value repeated_uint64_wrapper = 215;
-  repeated google.protobuf.FloatValue repeated_float_wrapper = 216;
-  repeated google.protobuf.DoubleValue repeated_double_wrapper = 217;
-  repeated google.protobuf.StringValue repeated_string_wrapper = 218;
-  repeated google.protobuf.BytesValue repeated_bytes_wrapper = 219;
-
-  google.protobuf.Duration optional_duration = 301;
-  google.protobuf.Timestamp optional_timestamp = 302;
-  google.protobuf.FieldMask optional_field_mask = 303;
-  google.protobuf.Struct optional_struct = 304;
-  google.protobuf.Any optional_any = 305;
-  google.protobuf.Value optional_value = 306;
-
-  repeated google.protobuf.Duration repeated_duration = 311;
-  repeated google.protobuf.Timestamp repeated_timestamp = 312;
-  repeated google.protobuf.FieldMask repeated_fieldmask = 313;
-  repeated google.protobuf.Struct repeated_struct = 324;
-  repeated google.protobuf.Any repeated_any = 315;
-  repeated google.protobuf.Value repeated_value = 316;
-
-  // Test field-name-to-JSON-name convention.
-  int32 fieldname1 = 401;
-  int32 field_name2 = 402;
-  int32 _field_name3 = 403;
-  int32 field__name4_ = 404;
-  int32 field0name5 = 405;
-  int32 field_0_name6 = 406;
-  int32 fieldName7 = 407;
-  int32 FieldName8 = 408;
-  int32 field_Name9 = 409;
-  int32 Field_Name10 = 410;
-  int32 FIELD_NAME11 = 411;
-  int32 FIELD_name12 = 412;
-}
-
-message ForeignMessage {
-  int32 c = 1;
-}
-
-enum ForeignEnum {
-  FOREIGN_FOO = 0;
-  FOREIGN_BAR = 1;
-  FOREIGN_BAZ = 2;
-}
diff --git a/vendor/github.com/golang/protobuf/conformance/test.sh b/vendor/github.com/golang/protobuf/conformance/test.sh
deleted file mode 100644
index e6de29b9a..000000000
--- a/vendor/github.com/golang/protobuf/conformance/test.sh
+++ /dev/null
@@ -1,26 +0,0 @@
-#!/bin/bash
-
-PROTOBUF_ROOT=$1
-CONFORMANCE_ROOT=$1/conformance
-CONFORMANCE_TEST_RUNNER=$CONFORMANCE_ROOT/conformance-test-runner
-
-cd $(dirname $0)
-
-if [[ $PROTOBUF_ROOT == "" ]]; then
-  echo "usage: test.sh <protobuf-root>" >/dev/stderr
-  exit 1
-fi
-
-if [[ ! -x $CONFORMANCE_TEST_RUNNER ]]; then
-  echo "SKIP: conformance test runner not installed" >/dev/stderr
-  exit 0
-fi
-
-a=$CONFORMANCE_ROOT/conformance.proto
-b=internal/conformance_proto/conformance.proto
-if [[ $(diff $a $b) != "" ]]; then
-  cp $a $b
-  echo "WARNING: conformance.proto is out of date" >/dev/stderr
-fi
-
-$CONFORMANCE_TEST_RUNNER --failure_list failure_list_go.txt ./conformance.sh
diff --git a/vendor/github.com/golang/protobuf/descriptor/descriptor.go b/vendor/github.com/golang/protobuf/descriptor/descriptor.go
index ac7e51bfb..c3c4a2b87 100644
--- a/vendor/github.com/golang/protobuf/descriptor/descriptor.go
+++ b/vendor/github.com/golang/protobuf/descriptor/descriptor.go
@@ -1,92 +1,184 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2016 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Package descriptor provides functions for obtaining protocol buffer
-// descriptors for generated Go types.
+// Copyright 2016 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 descriptor provides functions for obtaining the protocol buffer
+// descriptors of generated Go types.
 //
-// These functions cannot go in package proto because they depend on the
-// generated protobuf descriptor messages, which themselves depend on proto.
+// Deprecated: See the "google.golang.org/protobuf/reflect/protoreflect" package
+// for how to obtain an EnumDescriptor or MessageDescriptor in order to
+// programatically interact with the protobuf type system.
 package descriptor
 
 import (
 	"bytes"
 	"compress/gzip"
-	"fmt"
 	"io/ioutil"
+	"sync"
 
 	"github.com/golang/protobuf/proto"
-	protobuf "github.com/golang/protobuf/protoc-gen-go/descriptor"
+	"google.golang.org/protobuf/reflect/protodesc"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/runtime/protoimpl"
+
+	descriptorpb "github.com/golang/protobuf/protoc-gen-go/descriptor"
 )
 
-// extractFile extracts a FileDescriptorProto from a gzip'd buffer.
-func extractFile(gz []byte) (*protobuf.FileDescriptorProto, error) {
-	r, err := gzip.NewReader(bytes.NewReader(gz))
-	if err != nil {
-		return nil, fmt.Errorf("failed to open gzip reader: %v", err)
+// Message is proto.Message with a method to return its descriptor.
+//
+// Deprecated: The Descriptor method may not be generated by future
+// versions of protoc-gen-go, meaning that this interface may not
+// be implemented by many concrete message types.
+type Message interface {
+	proto.Message
+	Descriptor() ([]byte, []int)
+}
+
+// ForMessage returns the file descriptor proto containing
+// the message and the message descriptor proto for the message itself.
+// The returned proto messages must not be mutated.
+//
+// Deprecated: Not all concrete message types satisfy the Message interface.
+// Use MessageDescriptorProto instead. If possible, the calling code should
+// be rewritten to use protobuf reflection instead.
+// See package "google.golang.org/protobuf/reflect/protoreflect" for details.
+func ForMessage(m Message) (*descriptorpb.FileDescriptorProto, *descriptorpb.DescriptorProto) {
+	return MessageDescriptorProto(m)
+}
+
+type rawDesc struct {
+	fileDesc []byte
+	indexes  []int
+}
+
+var rawDescCache sync.Map // map[protoreflect.Descriptor]*rawDesc
+
+func deriveRawDescriptor(d protoreflect.Descriptor) ([]byte, []int) {
+	// Fast-path: check whether raw descriptors are already cached.
+	origDesc := d
+	if v, ok := rawDescCache.Load(origDesc); ok {
+		return v.(*rawDesc).fileDesc, v.(*rawDesc).indexes
 	}
-	defer r.Close()
 
-	b, err := ioutil.ReadAll(r)
-	if err != nil {
-		return nil, fmt.Errorf("failed to uncompress descriptor: %v", err)
+	// Slow-path: derive the raw descriptor from the v2 descriptor.
+
+	// Start with the leaf (a given enum or message declaration) and
+	// ascend upwards until we hit the parent file descriptor.
+	var idxs []int
+	for {
+		idxs = append(idxs, d.Index())
+		d = d.Parent()
+		if d == nil {
+			// TODO: We could construct a FileDescriptor stub for standalone
+			// descriptors to satisfy the API.
+			return nil, nil
+		}
+		if _, ok := d.(protoreflect.FileDescriptor); ok {
+			break
+		}
 	}
 
-	fd := new(protobuf.FileDescriptorProto)
-	if err := proto.Unmarshal(b, fd); err != nil {
-		return nil, fmt.Errorf("malformed FileDescriptorProto: %v", err)
+	// Obtain the raw file descriptor.
+	var raw []byte
+	switch fd := d.(type) {
+	case interface{ ProtoLegacyRawDesc() []byte }:
+		raw = fd.ProtoLegacyRawDesc()
+	case protoreflect.FileDescriptor:
+		raw, _ = proto.Marshal(protodesc.ToFileDescriptorProto(fd))
 	}
+	file := protoimpl.X.CompressGZIP(raw)
 
-	return fd, nil
+	// Reverse the indexes, since we populated it in reverse.
+	for i, j := 0, len(idxs)-1; i < j; i, j = i+1, j-1 {
+		idxs[i], idxs[j] = idxs[j], idxs[i]
+	}
+
+	if v, ok := rawDescCache.LoadOrStore(origDesc, &rawDesc{file, idxs}); ok {
+		return v.(*rawDesc).fileDesc, v.(*rawDesc).indexes
+	}
+	return file, idxs
 }
 
-// Message is a proto.Message with a method to return its descriptor.
-//
-// Message types generated by the protocol compiler always satisfy
-// the Message interface.
-type Message interface {
-	proto.Message
-	Descriptor() ([]byte, []int)
+// EnumRawDescriptor returns the GZIP'd raw file descriptor representing
+// the enum and the index path to reach the enum declaration.
+// The returned slices must not be mutated.
+func EnumRawDescriptor(e proto.GeneratedEnum) ([]byte, []int) {
+	if ev, ok := e.(interface{ EnumDescriptor() ([]byte, []int) }); ok {
+		return ev.EnumDescriptor()
+	}
+	ed := protoimpl.X.EnumTypeOf(e)
+	return deriveRawDescriptor(ed.Descriptor())
+}
+
+// MessageRawDescriptor returns the GZIP'd raw file descriptor representing
+// the message and the index path to reach the message declaration.
+// The returned slices must not be mutated.
+func MessageRawDescriptor(m proto.GeneratedMessage) ([]byte, []int) {
+	if mv, ok := m.(interface{ Descriptor() ([]byte, []int) }); ok {
+		return mv.Descriptor()
+	}
+	md := protoimpl.X.MessageTypeOf(m)
+	return deriveRawDescriptor(md.Descriptor())
 }
 
-// ForMessage returns a FileDescriptorProto and a DescriptorProto from within it
-// describing the given message.
-func ForMessage(msg Message) (fd *protobuf.FileDescriptorProto, md *protobuf.DescriptorProto) {
-	gz, path := msg.Descriptor()
-	fd, err := extractFile(gz)
+var fileDescCache sync.Map // map[*byte]*descriptorpb.FileDescriptorProto
+
+func deriveFileDescriptor(rawDesc []byte) *descriptorpb.FileDescriptorProto {
+	// Fast-path: check whether descriptor protos are already cached.
+	if v, ok := fileDescCache.Load(&rawDesc[0]); ok {
+		return v.(*descriptorpb.FileDescriptorProto)
+	}
+
+	// Slow-path: derive the descriptor proto from the GZIP'd message.
+	zr, err := gzip.NewReader(bytes.NewReader(rawDesc))
+	if err != nil {
+		panic(err)
+	}
+	b, err := ioutil.ReadAll(zr)
 	if err != nil {
-		panic(fmt.Sprintf("invalid FileDescriptorProto for %T: %v", msg, err))
+		panic(err)
+	}
+	fd := new(descriptorpb.FileDescriptorProto)
+	if err := proto.Unmarshal(b, fd); err != nil {
+		panic(err)
+	}
+	if v, ok := fileDescCache.LoadOrStore(&rawDesc[0], fd); ok {
+		return v.(*descriptorpb.FileDescriptorProto)
+	}
+	return fd
+}
+
+// EnumDescriptorProto returns the file descriptor proto representing
+// the enum and the enum descriptor proto for the enum itself.
+// The returned proto messages must not be mutated.
+func EnumDescriptorProto(e proto.GeneratedEnum) (*descriptorpb.FileDescriptorProto, *descriptorpb.EnumDescriptorProto) {
+	rawDesc, idxs := EnumRawDescriptor(e)
+	if rawDesc == nil || idxs == nil {
+		return nil, nil
+	}
+	fd := deriveFileDescriptor(rawDesc)
+	if len(idxs) == 1 {
+		return fd, fd.EnumType[idxs[0]]
+	}
+	md := fd.MessageType[idxs[0]]
+	for _, i := range idxs[1 : len(idxs)-1] {
+		md = md.NestedType[i]
 	}
+	ed := md.EnumType[idxs[len(idxs)-1]]
+	return fd, ed
+}
 
-	md = fd.MessageType[path[0]]
-	for _, i := range path[1:] {
+// MessageDescriptorProto returns the file descriptor proto representing
+// the message and the message descriptor proto for the message itself.
+// The returned proto messages must not be mutated.
+func MessageDescriptorProto(m proto.GeneratedMessage) (*descriptorpb.FileDescriptorProto, *descriptorpb.DescriptorProto) {
+	rawDesc, idxs := MessageRawDescriptor(m)
+	if rawDesc == nil || idxs == nil {
+		return nil, nil
+	}
+	fd := deriveFileDescriptor(rawDesc)
+	md := fd.MessageType[idxs[0]]
+	for _, i := range idxs[1:] {
 		md = md.NestedType[i]
 	}
 	return fd, md
diff --git a/vendor/github.com/golang/protobuf/descriptor/descriptor_test.go b/vendor/github.com/golang/protobuf/descriptor/descriptor_test.go
index bf5174d3b..28083979c 100644
--- a/vendor/github.com/golang/protobuf/descriptor/descriptor_test.go
+++ b/vendor/github.com/golang/protobuf/descriptor/descriptor_test.go
@@ -1,32 +1,85 @@
-package descriptor_test
+// Copyright 2020 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 descriptor
 
 import (
-	"fmt"
 	"testing"
 
-	"github.com/golang/protobuf/descriptor"
-	tpb "github.com/golang/protobuf/proto/test_proto"
-	protobuf "github.com/golang/protobuf/protoc-gen-go/descriptor"
+	"github.com/google/go-cmp/cmp"
+	"google.golang.org/protobuf/reflect/protoreflect"
+
+	descpb "github.com/golang/protobuf/protoc-gen-go/descriptor"
 )
 
-func TestMessage(t *testing.T) {
-	var msg *protobuf.DescriptorProto
-	fd, md := descriptor.ForMessage(msg)
-	if pkg, want := fd.GetPackage(), "google.protobuf"; pkg != want {
-		t.Errorf("descriptor.ForMessage(%T).GetPackage() = %q; want %q", msg, pkg, want)
-	}
-	if name, want := md.GetName(), "DescriptorProto"; name != want {
-		t.Fatalf("descriptor.ForMessage(%T).GetName() = %q; want %q", msg, name, want)
+func TestEnumDescriptor(t *testing.T) {
+	tests := []struct {
+		enum protoreflect.Enum
+		idxs []int
+		name string
+	}{{
+		enum: descpb.FieldDescriptorProto_Type(0),
+		idxs: []int{
+			new(descpb.FieldDescriptorProto).ProtoReflect().Descriptor().Index(),
+			new(descpb.FieldDescriptorProto_Type).Descriptor().Index(),
+		},
+		name: "Type",
+	}, {
+		enum: descpb.FieldOptions_CType(0),
+		idxs: []int{
+			new(descpb.FieldOptions).ProtoReflect().Descriptor().Index(),
+			new(descpb.FieldOptions_CType).Descriptor().Index(),
+		},
+		name: "CType",
+	}}
+
+	for _, tt := range tests {
+		e := struct{ protoreflect.Enum }{tt.enum} // v2-only enum
+
+		_, idxs := EnumRawDescriptor(e)
+		if diff := cmp.Diff(tt.idxs, idxs); diff != "" {
+			t.Errorf("path index mismatch (-want +got):\n%v", diff)
+		}
+
+		_, ed := EnumDescriptorProto(e)
+		if ed.GetName() != tt.name {
+			t.Errorf("mismatching enum name: got %v, want %v", ed.GetName(), tt.name)
+		}
 	}
 }
 
-func Example_options() {
-	var msg *tpb.MyMessageSet
-	_, md := descriptor.ForMessage(msg)
-	if md.GetOptions().GetMessageSetWireFormat() {
-		fmt.Printf("%v uses option message_set_wire_format.\n", md.GetName())
-	}
+func TestMessageDescriptor(t *testing.T) {
+	tests := []struct {
+		message protoreflect.ProtoMessage
+		idxs    []int
+		name    string
+	}{{
+		message: (*descpb.SourceCodeInfo_Location)(nil),
+		idxs: []int{
+			new(descpb.SourceCodeInfo).ProtoReflect().Descriptor().Index(),
+			new(descpb.SourceCodeInfo_Location).ProtoReflect().Descriptor().Index(),
+		},
+		name: "Location",
+	}, {
+		message: (*descpb.FileDescriptorProto)(nil),
+		idxs: []int{
+			new(descpb.FileDescriptorProto).ProtoReflect().Descriptor().Index(),
+		},
+		name: "FileDescriptorProto",
+	}}
+
+	for _, tt := range tests {
+		m := struct{ protoreflect.ProtoMessage }{tt.message} // v2-only message
 
-	// Output:
-	// MyMessageSet uses option message_set_wire_format.
+		_, idxs := MessageRawDescriptor(m)
+		if diff := cmp.Diff(tt.idxs, idxs); diff != "" {
+			t.Errorf("path index mismatch (-want +got):\n%v", diff)
+		}
+
+		_, md := MessageDescriptorProto(m)
+		if md.GetName() != tt.name {
+			t.Errorf("mismatching message name: got %v, want %v", md.GetName(), tt.name)
+		}
+	}
 }
diff --git a/vendor/github.com/golang/protobuf/go.mod b/vendor/github.com/golang/protobuf/go.mod
new file mode 100644
index 000000000..67adeed86
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/go.mod
@@ -0,0 +1,8 @@
+module github.com/golang/protobuf
+
+go 1.9
+
+require (
+	github.com/google/go-cmp v0.4.0
+	google.golang.org/protobuf v1.23.0
+)
diff --git a/vendor/github.com/golang/protobuf/go.sum b/vendor/github.com/golang/protobuf/go.sum
new file mode 100644
index 000000000..92baf2631
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/go.sum
@@ -0,0 +1,18 @@
+github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
+github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
+github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
+github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
+github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
+github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.4.0 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
+google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
+google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
+google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
+google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
+google.golang.org/protobuf v1.23.0 h1:4MY060fB1DLGMB/7MBTLnwQUY6+F09GEiz6SsrNqyzM=
+google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
diff --git a/vendor/github.com/golang/protobuf/internal/cmd/generate-alias/main.go b/vendor/github.com/golang/protobuf/internal/cmd/generate-alias/main.go
new file mode 100644
index 000000000..6c16e6dc6
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/internal/cmd/generate-alias/main.go
@@ -0,0 +1,132 @@
+// Copyright 2019 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.
+
+//go:generate go run . -execute
+
+package main
+
+import (
+	"flag"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path"
+	"path/filepath"
+	"strings"
+
+	"github.com/golang/protobuf/proto"
+	gengo "google.golang.org/protobuf/cmd/protoc-gen-go/internal_gengo"
+	"google.golang.org/protobuf/compiler/protogen"
+	"google.golang.org/protobuf/reflect/protodesc"
+	"google.golang.org/protobuf/reflect/protoreflect"
+
+	"google.golang.org/protobuf/types/descriptorpb"
+	"google.golang.org/protobuf/types/known/anypb"
+	"google.golang.org/protobuf/types/known/durationpb"
+	"google.golang.org/protobuf/types/known/emptypb"
+	"google.golang.org/protobuf/types/known/structpb"
+	"google.golang.org/protobuf/types/known/timestamppb"
+	"google.golang.org/protobuf/types/known/wrapperspb"
+	"google.golang.org/protobuf/types/pluginpb"
+)
+
+func main() {
+	run := flag.Bool("execute", false, "Write generated files to destination.")
+	flag.Parse()
+
+	// Set of generated proto packages to forward to v2.
+	files := []struct {
+		oldGoPkg string
+		newGoPkg string
+		pbDesc   protoreflect.FileDescriptor
+	}{{
+		oldGoPkg: "github.com/golang/protobuf/protoc-gen-go/descriptor;descriptor",
+		newGoPkg: "google.golang.org/protobuf/types/descriptorpb",
+		pbDesc:   descriptorpb.File_google_protobuf_descriptor_proto,
+	}, {
+		oldGoPkg: "github.com/golang/protobuf/protoc-gen-go/plugin;plugin_go",
+		newGoPkg: "google.golang.org/protobuf/types/pluginpb",
+		pbDesc:   pluginpb.File_google_protobuf_compiler_plugin_proto,
+	}, {
+		oldGoPkg: "github.com/golang/protobuf/ptypes/any;any",
+		newGoPkg: "google.golang.org/protobuf/types/known/anypb",
+		pbDesc:   anypb.File_google_protobuf_any_proto,
+	}, {
+		oldGoPkg: "github.com/golang/protobuf/ptypes/duration;duration",
+		newGoPkg: "google.golang.org/protobuf/types/known/durationpb",
+		pbDesc:   durationpb.File_google_protobuf_duration_proto,
+	}, {
+		oldGoPkg: "github.com/golang/protobuf/ptypes/timestamp;timestamp",
+		newGoPkg: "google.golang.org/protobuf/types/known/timestamppb",
+		pbDesc:   timestamppb.File_google_protobuf_timestamp_proto,
+	}, {
+		oldGoPkg: "github.com/golang/protobuf/ptypes/wrappers;wrappers",
+		newGoPkg: "google.golang.org/protobuf/types/known/wrapperspb",
+		pbDesc:   wrapperspb.File_google_protobuf_wrappers_proto,
+	}, {
+		oldGoPkg: "github.com/golang/protobuf/ptypes/struct;structpb",
+		newGoPkg: "google.golang.org/protobuf/types/known/structpb",
+		pbDesc:   structpb.File_google_protobuf_struct_proto,
+	}, {
+		oldGoPkg: "github.com/golang/protobuf/ptypes/empty;empty",
+		newGoPkg: "google.golang.org/protobuf/types/known/emptypb",
+		pbDesc:   emptypb.File_google_protobuf_empty_proto,
+	}}
+
+	// For each package, construct a proto file that public imports the package.
+	var req pluginpb.CodeGeneratorRequest
+	var flags []string
+	for _, file := range files {
+		pkgPath := file.oldGoPkg[:strings.IndexByte(file.oldGoPkg, ';')]
+		fd := &descriptorpb.FileDescriptorProto{
+			Name:             proto.String(pkgPath + "/" + path.Base(pkgPath) + ".proto"),
+			Syntax:           proto.String(file.pbDesc.Syntax().String()),
+			Dependency:       []string{file.pbDesc.Path()},
+			PublicDependency: []int32{0},
+			Options:          &descriptorpb.FileOptions{GoPackage: proto.String(file.oldGoPkg)},
+		}
+		req.ProtoFile = append(req.ProtoFile, protodesc.ToFileDescriptorProto(file.pbDesc), fd)
+		req.FileToGenerate = append(req.FileToGenerate, fd.GetName())
+		flags = append(flags, "M"+file.pbDesc.Path()+"="+file.newGoPkg)
+	}
+	req.Parameter = proto.String(strings.Join(flags, ","))
+
+	// Use the internal logic of protoc-gen-go to generate the files.
+	gen, err := protogen.Options{}.New(&req)
+	check(err)
+	for _, file := range gen.Files {
+		if file.Generate {
+			gengo.GenerateVersionMarkers = false
+			gengo.GenerateFile(gen, file)
+		}
+	}
+
+	// Write the generated files.
+	resp := gen.Response()
+	if resp.Error != nil {
+		panic("gengo error: " + resp.GetError())
+	}
+	for _, file := range resp.File {
+		relPath, err := filepath.Rel(filepath.FromSlash("github.com/golang/protobuf"), file.GetName())
+		check(err)
+
+		check(ioutil.WriteFile(relPath+".bak", []byte(file.GetContent()), 0664))
+		if *run {
+			fmt.Println("#", relPath)
+			check(os.Rename(relPath+".bak", relPath))
+		} else {
+			cmd := exec.Command("diff", relPath, relPath+".bak", "-N", "-u")
+			cmd.Stdout = os.Stdout
+			cmd.Run()
+			os.Remove(relPath + ".bak") // best-effort delete
+		}
+	}
+}
+
+func check(err error) {
+	if err != nil {
+		panic(err)
+	}
+}
diff --git a/vendor/github.com/golang/protobuf/internal/gengogrpc/grpc.go b/vendor/github.com/golang/protobuf/internal/gengogrpc/grpc.go
new file mode 100644
index 000000000..fd2f51d89
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/internal/gengogrpc/grpc.go
@@ -0,0 +1,398 @@
+// 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 gengogrpc contains the gRPC code generator.
+package gengogrpc
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"google.golang.org/protobuf/compiler/protogen"
+
+	"google.golang.org/protobuf/types/descriptorpb"
+)
+
+const (
+	contextPackage = protogen.GoImportPath("context")
+	grpcPackage    = protogen.GoImportPath("google.golang.org/grpc")
+	codesPackage   = protogen.GoImportPath("google.golang.org/grpc/codes")
+	statusPackage  = protogen.GoImportPath("google.golang.org/grpc/status")
+)
+
+// GenerateFile generates a _grpc.pb.go file containing gRPC service definitions.
+func GenerateFile(gen *protogen.Plugin, file *protogen.File) *protogen.GeneratedFile {
+	if len(file.Services) == 0 {
+		return nil
+	}
+	filename := file.GeneratedFilenamePrefix + "_grpc.pb.go"
+	g := gen.NewGeneratedFile(filename, file.GoImportPath)
+	g.P("// Code generated by protoc-gen-go-grpc. DO NOT EDIT.")
+	g.P()
+	g.P("package ", file.GoPackageName)
+	g.P()
+	GenerateFileContent(gen, file, g)
+	return g
+}
+
+// GenerateFileContent generates the gRPC service definitions, excluding the package statement.
+func GenerateFileContent(gen *protogen.Plugin, file *protogen.File, g *protogen.GeneratedFile) {
+	if len(file.Services) == 0 {
+		return
+	}
+
+	// TODO: Remove this. We don't need to include these references any more.
+	g.P("// Reference imports to suppress errors if they are not otherwise used.")
+	g.P("var _ ", contextPackage.Ident("Context"))
+	g.P("var _ ", grpcPackage.Ident("ClientConnInterface"))
+	g.P()
+
+	g.P("// This is a compile-time assertion to ensure that this generated file")
+	g.P("// is compatible with the grpc package it is being compiled against.")
+	g.P("const _ = ", grpcPackage.Ident("SupportPackageIsVersion6"))
+	g.P()
+	for _, service := range file.Services {
+		genService(gen, file, g, service)
+	}
+}
+
+func genService(gen *protogen.Plugin, file *protogen.File, g *protogen.GeneratedFile, service *protogen.Service) {
+	clientName := service.GoName + "Client"
+
+	g.P("// ", clientName, " is the client API for ", service.GoName, " service.")
+	g.P("//")
+	g.P("// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.")
+
+	// Client interface.
+	if service.Desc.Options().(*descriptorpb.ServiceOptions).GetDeprecated() {
+		g.P("//")
+		g.P(deprecationComment)
+	}
+	g.Annotate(clientName, service.Location)
+	g.P("type ", clientName, " interface {")
+	for _, method := range service.Methods {
+		g.Annotate(clientName+"."+method.GoName, method.Location)
+		if method.Desc.Options().(*descriptorpb.MethodOptions).GetDeprecated() {
+			g.P(deprecationComment)
+		}
+		g.P(method.Comments.Leading,
+			clientSignature(g, method))
+	}
+	g.P("}")
+	g.P()
+
+	// Client structure.
+	g.P("type ", unexport(clientName), " struct {")
+	g.P("cc ", grpcPackage.Ident("ClientConnInterface"))
+	g.P("}")
+	g.P()
+
+	// NewClient factory.
+	if service.Desc.Options().(*descriptorpb.ServiceOptions).GetDeprecated() {
+		g.P(deprecationComment)
+	}
+	g.P("func New", clientName, " (cc ", grpcPackage.Ident("ClientConnInterface"), ") ", clientName, " {")
+	g.P("return &", unexport(clientName), "{cc}")
+	g.P("}")
+	g.P()
+
+	var methodIndex, streamIndex int
+	// Client method implementations.
+	for _, method := range service.Methods {
+		if !method.Desc.IsStreamingServer() && !method.Desc.IsStreamingClient() {
+			// Unary RPC method
+			genClientMethod(gen, file, g, method, methodIndex)
+			methodIndex++
+		} else {
+			// Streaming RPC method
+			genClientMethod(gen, file, g, method, streamIndex)
+			streamIndex++
+		}
+	}
+
+	// Server interface.
+	serverType := service.GoName + "Server"
+	g.P("// ", serverType, " is the server API for ", service.GoName, " service.")
+	if service.Desc.Options().(*descriptorpb.ServiceOptions).GetDeprecated() {
+		g.P("//")
+		g.P(deprecationComment)
+	}
+	g.Annotate(serverType, service.Location)
+	g.P("type ", serverType, " interface {")
+	for _, method := range service.Methods {
+		g.Annotate(serverType+"."+method.GoName, method.Location)
+		if method.Desc.Options().(*descriptorpb.MethodOptions).GetDeprecated() {
+			g.P(deprecationComment)
+		}
+		g.P(method.Comments.Leading,
+			serverSignature(g, method))
+	}
+	g.P("}")
+	g.P()
+
+	// Server Unimplemented struct for forward compatibility.
+	g.P("// Unimplemented", serverType, " can be embedded to have forward compatible implementations.")
+	g.P("type Unimplemented", serverType, " struct {")
+	g.P("}")
+	g.P()
+	for _, method := range service.Methods {
+		nilArg := ""
+		if !method.Desc.IsStreamingClient() && !method.Desc.IsStreamingServer() {
+			nilArg = "nil,"
+		}
+		g.P("func (*Unimplemented", serverType, ") ", serverSignature(g, method), "{")
+		g.P("return ", nilArg, statusPackage.Ident("Errorf"), "(", codesPackage.Ident("Unimplemented"), `, "method `, method.GoName, ` not implemented")`)
+		g.P("}")
+	}
+	g.P()
+
+	// Server registration.
+	if service.Desc.Options().(*descriptorpb.ServiceOptions).GetDeprecated() {
+		g.P(deprecationComment)
+	}
+	serviceDescVar := "_" + service.GoName + "_serviceDesc"
+	g.P("func Register", service.GoName, "Server(s *", grpcPackage.Ident("Server"), ", srv ", serverType, ") {")
+	g.P("s.RegisterService(&", serviceDescVar, `, srv)`)
+	g.P("}")
+	g.P()
+
+	// Server handler implementations.
+	var handlerNames []string
+	for _, method := range service.Methods {
+		hname := genServerMethod(gen, file, g, method)
+		handlerNames = append(handlerNames, hname)
+	}
+
+	// Service descriptor.
+	g.P("var ", serviceDescVar, " = ", grpcPackage.Ident("ServiceDesc"), " {")
+	g.P("ServiceName: ", strconv.Quote(string(service.Desc.FullName())), ",")
+	g.P("HandlerType: (*", serverType, ")(nil),")
+	g.P("Methods: []", grpcPackage.Ident("MethodDesc"), "{")
+	for i, method := range service.Methods {
+		if method.Desc.IsStreamingClient() || method.Desc.IsStreamingServer() {
+			continue
+		}
+		g.P("{")
+		g.P("MethodName: ", strconv.Quote(string(method.Desc.Name())), ",")
+		g.P("Handler: ", handlerNames[i], ",")
+		g.P("},")
+	}
+	g.P("},")
+	g.P("Streams: []", grpcPackage.Ident("StreamDesc"), "{")
+	for i, method := range service.Methods {
+		if !method.Desc.IsStreamingClient() && !method.Desc.IsStreamingServer() {
+			continue
+		}
+		g.P("{")
+		g.P("StreamName: ", strconv.Quote(string(method.Desc.Name())), ",")
+		g.P("Handler: ", handlerNames[i], ",")
+		if method.Desc.IsStreamingServer() {
+			g.P("ServerStreams: true,")
+		}
+		if method.Desc.IsStreamingClient() {
+			g.P("ClientStreams: true,")
+		}
+		g.P("},")
+	}
+	g.P("},")
+	g.P("Metadata: \"", file.Desc.Path(), "\",")
+	g.P("}")
+	g.P()
+}
+
+func clientSignature(g *protogen.GeneratedFile, method *protogen.Method) string {
+	s := method.GoName + "(ctx " + g.QualifiedGoIdent(contextPackage.Ident("Context"))
+	if !method.Desc.IsStreamingClient() {
+		s += ", in *" + g.QualifiedGoIdent(method.Input.GoIdent)
+	}
+	s += ", opts ..." + g.QualifiedGoIdent(grpcPackage.Ident("CallOption")) + ") ("
+	if !method.Desc.IsStreamingClient() && !method.Desc.IsStreamingServer() {
+		s += "*" + g.QualifiedGoIdent(method.Output.GoIdent)
+	} else {
+		s += method.Parent.GoName + "_" + method.GoName + "Client"
+	}
+	s += ", error)"
+	return s
+}
+
+func genClientMethod(gen *protogen.Plugin, file *protogen.File, g *protogen.GeneratedFile, method *protogen.Method, index int) {
+	service := method.Parent
+	sname := fmt.Sprintf("/%s/%s", service.Desc.FullName(), method.Desc.Name())
+
+	if method.Desc.Options().(*descriptorpb.MethodOptions).GetDeprecated() {
+		g.P(deprecationComment)
+	}
+	g.P("func (c *", unexport(service.GoName), "Client) ", clientSignature(g, method), "{")
+	if !method.Desc.IsStreamingServer() && !method.Desc.IsStreamingClient() {
+		g.P("out := new(", method.Output.GoIdent, ")")
+		g.P(`err := c.cc.Invoke(ctx, "`, sname, `", in, out, opts...)`)
+		g.P("if err != nil { return nil, err }")
+		g.P("return out, nil")
+		g.P("}")
+		g.P()
+		return
+	}
+	streamType := unexport(service.GoName) + method.GoName + "Client"
+	serviceDescVar := "_" + service.GoName + "_serviceDesc"
+	g.P("stream, err := c.cc.NewStream(ctx, &", serviceDescVar, ".Streams[", index, `], "`, sname, `", opts...)`)
+	g.P("if err != nil { return nil, err }")
+	g.P("x := &", streamType, "{stream}")
+	if !method.Desc.IsStreamingClient() {
+		g.P("if err := x.ClientStream.SendMsg(in); err != nil { return nil, err }")
+		g.P("if err := x.ClientStream.CloseSend(); err != nil { return nil, err }")
+	}
+	g.P("return x, nil")
+	g.P("}")
+	g.P()
+
+	genSend := method.Desc.IsStreamingClient()
+	genRecv := method.Desc.IsStreamingServer()
+	genCloseAndRecv := !method.Desc.IsStreamingServer()
+
+	// Stream auxiliary types and methods.
+	g.P("type ", service.GoName, "_", method.GoName, "Client interface {")
+	if genSend {
+		g.P("Send(*", method.Input.GoIdent, ") error")
+	}
+	if genRecv {
+		g.P("Recv() (*", method.Output.GoIdent, ", error)")
+	}
+	if genCloseAndRecv {
+		g.P("CloseAndRecv() (*", method.Output.GoIdent, ", error)")
+	}
+	g.P(grpcPackage.Ident("ClientStream"))
+	g.P("}")
+	g.P()
+
+	g.P("type ", streamType, " struct {")
+	g.P(grpcPackage.Ident("ClientStream"))
+	g.P("}")
+	g.P()
+
+	if genSend {
+		g.P("func (x *", streamType, ") Send(m *", method.Input.GoIdent, ") error {")
+		g.P("return x.ClientStream.SendMsg(m)")
+		g.P("}")
+		g.P()
+	}
+	if genRecv {
+		g.P("func (x *", streamType, ") Recv() (*", method.Output.GoIdent, ", error) {")
+		g.P("m := new(", method.Output.GoIdent, ")")
+		g.P("if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err }")
+		g.P("return m, nil")
+		g.P("}")
+		g.P()
+	}
+	if genCloseAndRecv {
+		g.P("func (x *", streamType, ") CloseAndRecv() (*", method.Output.GoIdent, ", error) {")
+		g.P("if err := x.ClientStream.CloseSend(); err != nil { return nil, err }")
+		g.P("m := new(", method.Output.GoIdent, ")")
+		g.P("if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err }")
+		g.P("return m, nil")
+		g.P("}")
+		g.P()
+	}
+}
+
+func serverSignature(g *protogen.GeneratedFile, method *protogen.Method) string {
+	var reqArgs []string
+	ret := "error"
+	if !method.Desc.IsStreamingClient() && !method.Desc.IsStreamingServer() {
+		reqArgs = append(reqArgs, g.QualifiedGoIdent(contextPackage.Ident("Context")))
+		ret = "(*" + g.QualifiedGoIdent(method.Output.GoIdent) + ", error)"
+	}
+	if !method.Desc.IsStreamingClient() {
+		reqArgs = append(reqArgs, "*"+g.QualifiedGoIdent(method.Input.GoIdent))
+	}
+	if method.Desc.IsStreamingClient() || method.Desc.IsStreamingServer() {
+		reqArgs = append(reqArgs, method.Parent.GoName+"_"+method.GoName+"Server")
+	}
+	return method.GoName + "(" + strings.Join(reqArgs, ", ") + ") " + ret
+}
+
+func genServerMethod(gen *protogen.Plugin, file *protogen.File, g *protogen.GeneratedFile, method *protogen.Method) string {
+	service := method.Parent
+	hname := fmt.Sprintf("_%s_%s_Handler", service.GoName, method.GoName)
+
+	if !method.Desc.IsStreamingClient() && !method.Desc.IsStreamingServer() {
+		g.P("func ", hname, "(srv interface{}, ctx ", contextPackage.Ident("Context"), ", dec func(interface{}) error, interceptor ", grpcPackage.Ident("UnaryServerInterceptor"), ") (interface{}, error) {")
+		g.P("in := new(", method.Input.GoIdent, ")")
+		g.P("if err := dec(in); err != nil { return nil, err }")
+		g.P("if interceptor == nil { return srv.(", service.GoName, "Server).", method.GoName, "(ctx, in) }")
+		g.P("info := &", grpcPackage.Ident("UnaryServerInfo"), "{")
+		g.P("Server: srv,")
+		g.P("FullMethod: ", strconv.Quote(fmt.Sprintf("/%s/%s", service.Desc.FullName(), method.GoName)), ",")
+		g.P("}")
+		g.P("handler := func(ctx ", contextPackage.Ident("Context"), ", req interface{}) (interface{}, error) {")
+		g.P("return srv.(", service.GoName, "Server).", method.GoName, "(ctx, req.(*", method.Input.GoIdent, "))")
+		g.P("}")
+		g.P("return interceptor(ctx, in, info, handler)")
+		g.P("}")
+		g.P()
+		return hname
+	}
+	streamType := unexport(service.GoName) + method.GoName + "Server"
+	g.P("func ", hname, "(srv interface{}, stream ", grpcPackage.Ident("ServerStream"), ") error {")
+	if !method.Desc.IsStreamingClient() {
+		g.P("m := new(", method.Input.GoIdent, ")")
+		g.P("if err := stream.RecvMsg(m); err != nil { return err }")
+		g.P("return srv.(", service.GoName, "Server).", method.GoName, "(m, &", streamType, "{stream})")
+	} else {
+		g.P("return srv.(", service.GoName, "Server).", method.GoName, "(&", streamType, "{stream})")
+	}
+	g.P("}")
+	g.P()
+
+	genSend := method.Desc.IsStreamingServer()
+	genSendAndClose := !method.Desc.IsStreamingServer()
+	genRecv := method.Desc.IsStreamingClient()
+
+	// Stream auxiliary types and methods.
+	g.P("type ", service.GoName, "_", method.GoName, "Server interface {")
+	if genSend {
+		g.P("Send(*", method.Output.GoIdent, ") error")
+	}
+	if genSendAndClose {
+		g.P("SendAndClose(*", method.Output.GoIdent, ") error")
+	}
+	if genRecv {
+		g.P("Recv() (*", method.Input.GoIdent, ", error)")
+	}
+	g.P(grpcPackage.Ident("ServerStream"))
+	g.P("}")
+	g.P()
+
+	g.P("type ", streamType, " struct {")
+	g.P(grpcPackage.Ident("ServerStream"))
+	g.P("}")
+	g.P()
+
+	if genSend {
+		g.P("func (x *", streamType, ") Send(m *", method.Output.GoIdent, ") error {")
+		g.P("return x.ServerStream.SendMsg(m)")
+		g.P("}")
+		g.P()
+	}
+	if genSendAndClose {
+		g.P("func (x *", streamType, ") SendAndClose(m *", method.Output.GoIdent, ") error {")
+		g.P("return x.ServerStream.SendMsg(m)")
+		g.P("}")
+		g.P()
+	}
+	if genRecv {
+		g.P("func (x *", streamType, ") Recv() (*", method.Input.GoIdent, ", error) {")
+		g.P("m := new(", method.Input.GoIdent, ")")
+		g.P("if err := x.ServerStream.RecvMsg(m); err != nil { return nil, err }")
+		g.P("return m, nil")
+		g.P("}")
+		g.P()
+	}
+
+	return hname
+}
+
+const deprecationComment = "// Deprecated: Do not use."
+
+func unexport(s string) string { return strings.ToLower(s[:1]) + s[1:] }
diff --git a/vendor/github.com/golang/protobuf/jsonpb/jsonpb_test_proto/test_objects.pb.go b/vendor/github.com/golang/protobuf/internal/testprotos/jsonpb_proto/test2.pb.go
similarity index 56%
rename from vendor/github.com/golang/protobuf/jsonpb/jsonpb_test_proto/test_objects.pb.go
rename to vendor/github.com/golang/protobuf/internal/testprotos/jsonpb_proto/test2.pb.go
index d9e24db2c..a27dc0c25 100644
--- a/vendor/github.com/golang/protobuf/jsonpb/jsonpb_test_proto/test_objects.pb.go
+++ b/vendor/github.com/golang/protobuf/internal/testprotos/jsonpb_proto/test2.pb.go
@@ -1,16 +1,18 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
-// source: test_objects.proto
-
-package jsonpb
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-import any "github.com/golang/protobuf/ptypes/any"
-import duration "github.com/golang/protobuf/ptypes/duration"
-import _struct "github.com/golang/protobuf/ptypes/struct"
-import timestamp "github.com/golang/protobuf/ptypes/timestamp"
-import wrappers "github.com/golang/protobuf/ptypes/wrappers"
+// source: jsonpb_proto/test2.proto
+
+package jsonpb_proto
+
+import (
+	fmt "fmt"
+	proto "github.com/golang/protobuf/proto"
+	anypb "google.golang.org/protobuf/types/known/anypb"
+	durationpb "google.golang.org/protobuf/types/known/durationpb"
+	structpb "google.golang.org/protobuf/types/known/structpb"
+	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
+	wrapperspb "google.golang.org/protobuf/types/known/wrapperspb"
+	math "math"
+)
 
 // Reference imports to suppress errors if they are not otherwise used.
 var _ = proto.Marshal
@@ -21,7 +23,7 @@ var _ = math.Inf
 // is compatible with the proto package it is being compiled against.
 // A compilation error at this line likely means your copy of the
 // proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
 
 type Widget_Color int32
 
@@ -36,6 +38,7 @@ var Widget_Color_name = map[int32]string{
 	1: "GREEN",
 	2: "BLUE",
 }
+
 var Widget_Color_value = map[string]int32{
 	"RED":   0,
 	"GREEN": 1,
@@ -47,9 +50,11 @@ func (x Widget_Color) Enum() *Widget_Color {
 	*p = x
 	return p
 }
+
 func (x Widget_Color) String() string {
 	return proto.EnumName(Widget_Color_name, int32(x))
 }
+
 func (x *Widget_Color) UnmarshalJSON(data []byte) error {
 	value, err := proto.UnmarshalJSONEnum(Widget_Color_value, data, "Widget_Color")
 	if err != nil {
@@ -58,23 +63,32 @@ func (x *Widget_Color) UnmarshalJSON(data []byte) error {
 	*x = Widget_Color(value)
 	return nil
 }
+
 func (Widget_Color) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_test_objects_c6f6c615ab823e65, []int{3, 0}
+	return fileDescriptor_50cab1d8463dea41, []int{3, 0}
 }
 
 // Test message for holding primitive types.
 type Simple struct {
 	OBool                *bool    `protobuf:"varint,1,opt,name=o_bool,json=oBool" json:"o_bool,omitempty"`
 	OInt32               *int32   `protobuf:"varint,2,opt,name=o_int32,json=oInt32" json:"o_int32,omitempty"`
-	OInt64               *int64   `protobuf:"varint,3,opt,name=o_int64,json=oInt64" json:"o_int64,omitempty"`
-	OUint32              *uint32  `protobuf:"varint,4,opt,name=o_uint32,json=oUint32" json:"o_uint32,omitempty"`
-	OUint64              *uint64  `protobuf:"varint,5,opt,name=o_uint64,json=oUint64" json:"o_uint64,omitempty"`
-	OSint32              *int32   `protobuf:"zigzag32,6,opt,name=o_sint32,json=oSint32" json:"o_sint32,omitempty"`
-	OSint64              *int64   `protobuf:"zigzag64,7,opt,name=o_sint64,json=oSint64" json:"o_sint64,omitempty"`
-	OFloat               *float32 `protobuf:"fixed32,8,opt,name=o_float,json=oFloat" json:"o_float,omitempty"`
-	ODouble              *float64 `protobuf:"fixed64,9,opt,name=o_double,json=oDouble" json:"o_double,omitempty"`
-	OString              *string  `protobuf:"bytes,10,opt,name=o_string,json=oString" json:"o_string,omitempty"`
-	OBytes               []byte   `protobuf:"bytes,11,opt,name=o_bytes,json=oBytes" json:"o_bytes,omitempty"`
+	OInt32Str            *int32   `protobuf:"varint,3,opt,name=o_int32_str,json=oInt32Str" json:"o_int32_str,omitempty"`
+	OInt64               *int64   `protobuf:"varint,4,opt,name=o_int64,json=oInt64" json:"o_int64,omitempty"`
+	OInt64Str            *int64   `protobuf:"varint,5,opt,name=o_int64_str,json=oInt64Str" json:"o_int64_str,omitempty"`
+	OUint32              *uint32  `protobuf:"varint,6,opt,name=o_uint32,json=oUint32" json:"o_uint32,omitempty"`
+	OUint32Str           *uint32  `protobuf:"varint,7,opt,name=o_uint32_str,json=oUint32Str" json:"o_uint32_str,omitempty"`
+	OUint64              *uint64  `protobuf:"varint,8,opt,name=o_uint64,json=oUint64" json:"o_uint64,omitempty"`
+	OUint64Str           *uint64  `protobuf:"varint,9,opt,name=o_uint64_str,json=oUint64Str" json:"o_uint64_str,omitempty"`
+	OSint32              *int32   `protobuf:"zigzag32,10,opt,name=o_sint32,json=oSint32" json:"o_sint32,omitempty"`
+	OSint32Str           *int32   `protobuf:"zigzag32,11,opt,name=o_sint32_str,json=oSint32Str" json:"o_sint32_str,omitempty"`
+	OSint64              *int64   `protobuf:"zigzag64,12,opt,name=o_sint64,json=oSint64" json:"o_sint64,omitempty"`
+	OSint64Str           *int64   `protobuf:"zigzag64,13,opt,name=o_sint64_str,json=oSint64Str" json:"o_sint64_str,omitempty"`
+	OFloat               *float32 `protobuf:"fixed32,14,opt,name=o_float,json=oFloat" json:"o_float,omitempty"`
+	OFloatStr            *float32 `protobuf:"fixed32,15,opt,name=o_float_str,json=oFloatStr" json:"o_float_str,omitempty"`
+	ODouble              *float64 `protobuf:"fixed64,16,opt,name=o_double,json=oDouble" json:"o_double,omitempty"`
+	ODoubleStr           *float64 `protobuf:"fixed64,17,opt,name=o_double_str,json=oDoubleStr" json:"o_double_str,omitempty"`
+	OString              *string  `protobuf:"bytes,18,opt,name=o_string,json=oString" json:"o_string,omitempty"`
+	OBytes               []byte   `protobuf:"bytes,19,opt,name=o_bytes,json=oBytes" json:"o_bytes,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -84,16 +98,17 @@ func (m *Simple) Reset()         { *m = Simple{} }
 func (m *Simple) String() string { return proto.CompactTextString(m) }
 func (*Simple) ProtoMessage()    {}
 func (*Simple) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_objects_c6f6c615ab823e65, []int{0}
+	return fileDescriptor_50cab1d8463dea41, []int{0}
 }
+
 func (m *Simple) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Simple.Unmarshal(m, b)
 }
 func (m *Simple) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_Simple.Marshal(b, m, deterministic)
 }
-func (dst *Simple) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Simple.Merge(dst, src)
+func (m *Simple) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Simple.Merge(m, src)
 }
 func (m *Simple) XXX_Size() int {
 	return xxx_messageInfo_Simple.Size(m)
@@ -118,6 +133,13 @@ func (m *Simple) GetOInt32() int32 {
 	return 0
 }
 
+func (m *Simple) GetOInt32Str() int32 {
+	if m != nil && m.OInt32Str != nil {
+		return *m.OInt32Str
+	}
+	return 0
+}
+
 func (m *Simple) GetOInt64() int64 {
 	if m != nil && m.OInt64 != nil {
 		return *m.OInt64
@@ -125,6 +147,13 @@ func (m *Simple) GetOInt64() int64 {
 	return 0
 }
 
+func (m *Simple) GetOInt64Str() int64 {
+	if m != nil && m.OInt64Str != nil {
+		return *m.OInt64Str
+	}
+	return 0
+}
+
 func (m *Simple) GetOUint32() uint32 {
 	if m != nil && m.OUint32 != nil {
 		return *m.OUint32
@@ -132,6 +161,13 @@ func (m *Simple) GetOUint32() uint32 {
 	return 0
 }
 
+func (m *Simple) GetOUint32Str() uint32 {
+	if m != nil && m.OUint32Str != nil {
+		return *m.OUint32Str
+	}
+	return 0
+}
+
 func (m *Simple) GetOUint64() uint64 {
 	if m != nil && m.OUint64 != nil {
 		return *m.OUint64
@@ -139,6 +175,13 @@ func (m *Simple) GetOUint64() uint64 {
 	return 0
 }
 
+func (m *Simple) GetOUint64Str() uint64 {
+	if m != nil && m.OUint64Str != nil {
+		return *m.OUint64Str
+	}
+	return 0
+}
+
 func (m *Simple) GetOSint32() int32 {
 	if m != nil && m.OSint32 != nil {
 		return *m.OSint32
@@ -146,6 +189,13 @@ func (m *Simple) GetOSint32() int32 {
 	return 0
 }
 
+func (m *Simple) GetOSint32Str() int32 {
+	if m != nil && m.OSint32Str != nil {
+		return *m.OSint32Str
+	}
+	return 0
+}
+
 func (m *Simple) GetOSint64() int64 {
 	if m != nil && m.OSint64 != nil {
 		return *m.OSint64
@@ -153,6 +203,13 @@ func (m *Simple) GetOSint64() int64 {
 	return 0
 }
 
+func (m *Simple) GetOSint64Str() int64 {
+	if m != nil && m.OSint64Str != nil {
+		return *m.OSint64Str
+	}
+	return 0
+}
+
 func (m *Simple) GetOFloat() float32 {
 	if m != nil && m.OFloat != nil {
 		return *m.OFloat
@@ -160,6 +217,13 @@ func (m *Simple) GetOFloat() float32 {
 	return 0
 }
 
+func (m *Simple) GetOFloatStr() float32 {
+	if m != nil && m.OFloatStr != nil {
+		return *m.OFloatStr
+	}
+	return 0
+}
+
 func (m *Simple) GetODouble() float64 {
 	if m != nil && m.ODouble != nil {
 		return *m.ODouble
@@ -167,6 +231,13 @@ func (m *Simple) GetODouble() float64 {
 	return 0
 }
 
+func (m *Simple) GetODoubleStr() float64 {
+	if m != nil && m.ODoubleStr != nil {
+		return *m.ODoubleStr
+	}
+	return 0
+}
+
 func (m *Simple) GetOString() string {
 	if m != nil && m.OString != nil {
 		return *m.OString
@@ -198,16 +269,17 @@ func (m *NonFinites) Reset()         { *m = NonFinites{} }
 func (m *NonFinites) String() string { return proto.CompactTextString(m) }
 func (*NonFinites) ProtoMessage()    {}
 func (*NonFinites) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_objects_c6f6c615ab823e65, []int{1}
+	return fileDescriptor_50cab1d8463dea41, []int{1}
 }
+
 func (m *NonFinites) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_NonFinites.Unmarshal(m, b)
 }
 func (m *NonFinites) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_NonFinites.Marshal(b, m, deterministic)
 }
-func (dst *NonFinites) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_NonFinites.Merge(dst, src)
+func (m *NonFinites) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_NonFinites.Merge(m, src)
 }
 func (m *NonFinites) XXX_Size() int {
 	return xxx_messageInfo_NonFinites.Size(m)
@@ -282,16 +354,17 @@ func (m *Repeats) Reset()         { *m = Repeats{} }
 func (m *Repeats) String() string { return proto.CompactTextString(m) }
 func (*Repeats) ProtoMessage()    {}
 func (*Repeats) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_objects_c6f6c615ab823e65, []int{2}
+	return fileDescriptor_50cab1d8463dea41, []int{2}
 }
+
 func (m *Repeats) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Repeats.Unmarshal(m, b)
 }
 func (m *Repeats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_Repeats.Marshal(b, m, deterministic)
 }
-func (dst *Repeats) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Repeats.Merge(dst, src)
+func (m *Repeats) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Repeats.Merge(m, src)
 }
 func (m *Repeats) XXX_Size() int {
 	return xxx_messageInfo_Repeats.Size(m)
@@ -381,8 +454,8 @@ func (m *Repeats) GetRBytes() [][]byte {
 
 // Test message for holding enums and nested messages.
 type Widget struct {
-	Color                *Widget_Color  `protobuf:"varint,1,opt,name=color,enum=jsonpb.Widget_Color" json:"color,omitempty"`
-	RColor               []Widget_Color `protobuf:"varint,2,rep,name=r_color,json=rColor,enum=jsonpb.Widget_Color" json:"r_color,omitempty"`
+	Color                *Widget_Color  `protobuf:"varint,1,opt,name=color,enum=jsonpb_test.Widget_Color" json:"color,omitempty"`
+	RColor               []Widget_Color `protobuf:"varint,2,rep,name=r_color,json=rColor,enum=jsonpb_test.Widget_Color" json:"r_color,omitempty"`
 	Simple               *Simple        `protobuf:"bytes,10,opt,name=simple" json:"simple,omitempty"`
 	RSimple              []*Simple      `protobuf:"bytes,11,rep,name=r_simple,json=rSimple" json:"r_simple,omitempty"`
 	Repeats              *Repeats       `protobuf:"bytes,20,opt,name=repeats" json:"repeats,omitempty"`
@@ -396,16 +469,17 @@ func (m *Widget) Reset()         { *m = Widget{} }
 func (m *Widget) String() string { return proto.CompactTextString(m) }
 func (*Widget) ProtoMessage()    {}
 func (*Widget) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_objects_c6f6c615ab823e65, []int{3}
+	return fileDescriptor_50cab1d8463dea41, []int{3}
 }
+
 func (m *Widget) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Widget.Unmarshal(m, b)
 }
 func (m *Widget) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_Widget.Marshal(b, m, deterministic)
 }
-func (dst *Widget) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Widget.Merge(dst, src)
+func (m *Widget) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Widget.Merge(m, src)
 }
 func (m *Widget) XXX_Size() int {
 	return xxx_messageInfo_Widget.Size(m)
@@ -470,16 +544,17 @@ func (m *Maps) Reset()         { *m = Maps{} }
 func (m *Maps) String() string { return proto.CompactTextString(m) }
 func (*Maps) ProtoMessage()    {}
 func (*Maps) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_objects_c6f6c615ab823e65, []int{4}
+	return fileDescriptor_50cab1d8463dea41, []int{4}
 }
+
 func (m *Maps) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Maps.Unmarshal(m, b)
 }
 func (m *Maps) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_Maps.Marshal(b, m, deterministic)
 }
-func (dst *Maps) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Maps.Merge(dst, src)
+func (m *Maps) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Maps.Merge(m, src)
 }
 func (m *Maps) XXX_Size() int {
 	return xxx_messageInfo_Maps.Size(m)
@@ -521,16 +596,17 @@ func (m *MsgWithOneof) Reset()         { *m = MsgWithOneof{} }
 func (m *MsgWithOneof) String() string { return proto.CompactTextString(m) }
 func (*MsgWithOneof) ProtoMessage()    {}
 func (*MsgWithOneof) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_objects_c6f6c615ab823e65, []int{5}
+	return fileDescriptor_50cab1d8463dea41, []int{5}
 }
+
 func (m *MsgWithOneof) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_MsgWithOneof.Unmarshal(m, b)
 }
 func (m *MsgWithOneof) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_MsgWithOneof.Marshal(b, m, deterministic)
 }
-func (dst *MsgWithOneof) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MsgWithOneof.Merge(dst, src)
+func (m *MsgWithOneof) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgWithOneof.Merge(m, src)
 }
 func (m *MsgWithOneof) XXX_Size() int {
 	return xxx_messageInfo_MsgWithOneof.Size(m)
@@ -548,23 +624,31 @@ type isMsgWithOneof_Union interface {
 type MsgWithOneof_Title struct {
 	Title string `protobuf:"bytes,1,opt,name=title,oneof"`
 }
+
 type MsgWithOneof_Salary struct {
 	Salary int64 `protobuf:"varint,2,opt,name=salary,oneof"`
 }
+
 type MsgWithOneof_Country struct {
 	Country string `protobuf:"bytes,3,opt,name=Country,oneof"`
 }
+
 type MsgWithOneof_HomeAddress struct {
 	HomeAddress string `protobuf:"bytes,4,opt,name=home_address,json=homeAddress,oneof"`
 }
+
 type MsgWithOneof_MsgWithRequired struct {
 	MsgWithRequired *MsgWithRequired `protobuf:"bytes,5,opt,name=msg_with_required,json=msgWithRequired,oneof"`
 }
 
-func (*MsgWithOneof_Title) isMsgWithOneof_Union()           {}
-func (*MsgWithOneof_Salary) isMsgWithOneof_Union()          {}
-func (*MsgWithOneof_Country) isMsgWithOneof_Union()         {}
-func (*MsgWithOneof_HomeAddress) isMsgWithOneof_Union()     {}
+func (*MsgWithOneof_Title) isMsgWithOneof_Union() {}
+
+func (*MsgWithOneof_Salary) isMsgWithOneof_Union() {}
+
+func (*MsgWithOneof_Country) isMsgWithOneof_Union() {}
+
+func (*MsgWithOneof_HomeAddress) isMsgWithOneof_Union() {}
+
 func (*MsgWithOneof_MsgWithRequired) isMsgWithOneof_Union() {}
 
 func (m *MsgWithOneof) GetUnion() isMsgWithOneof_Union {
@@ -609,9 +693,9 @@ func (m *MsgWithOneof) GetMsgWithRequired() *MsgWithRequired {
 	return nil
 }
 
-// XXX_OneofFuncs is for the internal use of the proto package.
-func (*MsgWithOneof) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
-	return _MsgWithOneof_OneofMarshaler, _MsgWithOneof_OneofUnmarshaler, _MsgWithOneof_OneofSizer, []interface{}{
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*MsgWithOneof) XXX_OneofWrappers() []interface{} {
+	return []interface{}{
 		(*MsgWithOneof_Title)(nil),
 		(*MsgWithOneof_Salary)(nil),
 		(*MsgWithOneof_Country)(nil),
@@ -620,109 +704,6 @@ func (*MsgWithOneof) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer)
 	}
 }
 
-func _MsgWithOneof_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
-	m := msg.(*MsgWithOneof)
-	// union
-	switch x := m.Union.(type) {
-	case *MsgWithOneof_Title:
-		b.EncodeVarint(1<<3 | proto.WireBytes)
-		b.EncodeStringBytes(x.Title)
-	case *MsgWithOneof_Salary:
-		b.EncodeVarint(2<<3 | proto.WireVarint)
-		b.EncodeVarint(uint64(x.Salary))
-	case *MsgWithOneof_Country:
-		b.EncodeVarint(3<<3 | proto.WireBytes)
-		b.EncodeStringBytes(x.Country)
-	case *MsgWithOneof_HomeAddress:
-		b.EncodeVarint(4<<3 | proto.WireBytes)
-		b.EncodeStringBytes(x.HomeAddress)
-	case *MsgWithOneof_MsgWithRequired:
-		b.EncodeVarint(5<<3 | proto.WireBytes)
-		if err := b.EncodeMessage(x.MsgWithRequired); err != nil {
-			return err
-		}
-	case nil:
-	default:
-		return fmt.Errorf("MsgWithOneof.Union has unexpected type %T", x)
-	}
-	return nil
-}
-
-func _MsgWithOneof_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
-	m := msg.(*MsgWithOneof)
-	switch tag {
-	case 1: // union.title
-		if wire != proto.WireBytes {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeStringBytes()
-		m.Union = &MsgWithOneof_Title{x}
-		return true, err
-	case 2: // union.salary
-		if wire != proto.WireVarint {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeVarint()
-		m.Union = &MsgWithOneof_Salary{int64(x)}
-		return true, err
-	case 3: // union.Country
-		if wire != proto.WireBytes {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeStringBytes()
-		m.Union = &MsgWithOneof_Country{x}
-		return true, err
-	case 4: // union.home_address
-		if wire != proto.WireBytes {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeStringBytes()
-		m.Union = &MsgWithOneof_HomeAddress{x}
-		return true, err
-	case 5: // union.msg_with_required
-		if wire != proto.WireBytes {
-			return true, proto.ErrInternalBadWireType
-		}
-		msg := new(MsgWithRequired)
-		err := b.DecodeMessage(msg)
-		m.Union = &MsgWithOneof_MsgWithRequired{msg}
-		return true, err
-	default:
-		return false, nil
-	}
-}
-
-func _MsgWithOneof_OneofSizer(msg proto.Message) (n int) {
-	m := msg.(*MsgWithOneof)
-	// union
-	switch x := m.Union.(type) {
-	case *MsgWithOneof_Title:
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(len(x.Title)))
-		n += len(x.Title)
-	case *MsgWithOneof_Salary:
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(x.Salary))
-	case *MsgWithOneof_Country:
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(len(x.Country)))
-		n += len(x.Country)
-	case *MsgWithOneof_HomeAddress:
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(len(x.HomeAddress)))
-		n += len(x.HomeAddress)
-	case *MsgWithOneof_MsgWithRequired:
-		s := proto.Size(x.MsgWithRequired)
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(s))
-		n += s
-	case nil:
-	default:
-		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
-	}
-	return n
-}
-
 type Real struct {
 	Value                        *float64 `protobuf:"fixed64,1,opt,name=value" json:"value,omitempty"`
 	XXX_NoUnkeyedLiteral         struct{} `json:"-"`
@@ -735,7 +716,7 @@ func (m *Real) Reset()         { *m = Real{} }
 func (m *Real) String() string { return proto.CompactTextString(m) }
 func (*Real) ProtoMessage()    {}
 func (*Real) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_objects_c6f6c615ab823e65, []int{6}
+	return fileDescriptor_50cab1d8463dea41, []int{6}
 }
 
 var extRange_Real = []proto.ExtensionRange{
@@ -745,14 +726,15 @@ var extRange_Real = []proto.ExtensionRange{
 func (*Real) ExtensionRangeArray() []proto.ExtensionRange {
 	return extRange_Real
 }
+
 func (m *Real) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Real.Unmarshal(m, b)
 }
 func (m *Real) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_Real.Marshal(b, m, deterministic)
 }
-func (dst *Real) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Real.Merge(dst, src)
+func (m *Real) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Real.Merge(m, src)
 }
 func (m *Real) XXX_Size() int {
 	return xxx_messageInfo_Real.Size(m)
@@ -782,7 +764,7 @@ func (m *Complex) Reset()         { *m = Complex{} }
 func (m *Complex) String() string { return proto.CompactTextString(m) }
 func (*Complex) ProtoMessage()    {}
 func (*Complex) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_objects_c6f6c615ab823e65, []int{7}
+	return fileDescriptor_50cab1d8463dea41, []int{7}
 }
 
 var extRange_Complex = []proto.ExtensionRange{
@@ -792,14 +774,15 @@ var extRange_Complex = []proto.ExtensionRange{
 func (*Complex) ExtensionRangeArray() []proto.ExtensionRange {
 	return extRange_Complex
 }
+
 func (m *Complex) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Complex.Unmarshal(m, b)
 }
 func (m *Complex) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_Complex.Marshal(b, m, deterministic)
 }
-func (dst *Complex) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Complex.Merge(dst, src)
+func (m *Complex) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Complex.Merge(m, src)
 }
 func (m *Complex) XXX_Size() int {
 	return xxx_messageInfo_Complex.Size(m)
@@ -821,46 +804,47 @@ var E_Complex_RealExtension = &proto.ExtensionDesc{
 	ExtendedType:  (*Real)(nil),
 	ExtensionType: (*Complex)(nil),
 	Field:         123,
-	Name:          "jsonpb.Complex.real_extension",
-	Tag:           "bytes,123,opt,name=real_extension,json=realExtension",
-	Filename:      "test_objects.proto",
+	Name:          "jsonpb_test.Complex.real_extension",
+	Tag:           "bytes,123,opt,name=real_extension",
+	Filename:      "jsonpb_proto/test2.proto",
 }
 
 type KnownTypes struct {
-	An                   *any.Any              `protobuf:"bytes,14,opt,name=an" json:"an,omitempty"`
-	Dur                  *duration.Duration    `protobuf:"bytes,1,opt,name=dur" json:"dur,omitempty"`
-	St                   *_struct.Struct       `protobuf:"bytes,12,opt,name=st" json:"st,omitempty"`
-	Ts                   *timestamp.Timestamp  `protobuf:"bytes,2,opt,name=ts" json:"ts,omitempty"`
-	Lv                   *_struct.ListValue    `protobuf:"bytes,15,opt,name=lv" json:"lv,omitempty"`
-	Val                  *_struct.Value        `protobuf:"bytes,16,opt,name=val" json:"val,omitempty"`
-	Dbl                  *wrappers.DoubleValue `protobuf:"bytes,3,opt,name=dbl" json:"dbl,omitempty"`
-	Flt                  *wrappers.FloatValue  `protobuf:"bytes,4,opt,name=flt" json:"flt,omitempty"`
-	I64                  *wrappers.Int64Value  `protobuf:"bytes,5,opt,name=i64" json:"i64,omitempty"`
-	U64                  *wrappers.UInt64Value `protobuf:"bytes,6,opt,name=u64" json:"u64,omitempty"`
-	I32                  *wrappers.Int32Value  `protobuf:"bytes,7,opt,name=i32" json:"i32,omitempty"`
-	U32                  *wrappers.UInt32Value `protobuf:"bytes,8,opt,name=u32" json:"u32,omitempty"`
-	Bool                 *wrappers.BoolValue   `protobuf:"bytes,9,opt,name=bool" json:"bool,omitempty"`
-	Str                  *wrappers.StringValue `protobuf:"bytes,10,opt,name=str" json:"str,omitempty"`
-	Bytes                *wrappers.BytesValue  `protobuf:"bytes,11,opt,name=bytes" json:"bytes,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
-	XXX_unrecognized     []byte                `json:"-"`
-	XXX_sizecache        int32                 `json:"-"`
+	An                   *anypb.Any              `protobuf:"bytes,14,opt,name=an" json:"an,omitempty"`
+	Dur                  *durationpb.Duration    `protobuf:"bytes,1,opt,name=dur" json:"dur,omitempty"`
+	St                   *structpb.Struct        `protobuf:"bytes,12,opt,name=st" json:"st,omitempty"`
+	Ts                   *timestamppb.Timestamp  `protobuf:"bytes,2,opt,name=ts" json:"ts,omitempty"`
+	Lv                   *structpb.ListValue     `protobuf:"bytes,15,opt,name=lv" json:"lv,omitempty"`
+	Val                  *structpb.Value         `protobuf:"bytes,16,opt,name=val" json:"val,omitempty"`
+	Dbl                  *wrapperspb.DoubleValue `protobuf:"bytes,3,opt,name=dbl" json:"dbl,omitempty"`
+	Flt                  *wrapperspb.FloatValue  `protobuf:"bytes,4,opt,name=flt" json:"flt,omitempty"`
+	I64                  *wrapperspb.Int64Value  `protobuf:"bytes,5,opt,name=i64" json:"i64,omitempty"`
+	U64                  *wrapperspb.UInt64Value `protobuf:"bytes,6,opt,name=u64" json:"u64,omitempty"`
+	I32                  *wrapperspb.Int32Value  `protobuf:"bytes,7,opt,name=i32" json:"i32,omitempty"`
+	U32                  *wrapperspb.UInt32Value `protobuf:"bytes,8,opt,name=u32" json:"u32,omitempty"`
+	Bool                 *wrapperspb.BoolValue   `protobuf:"bytes,9,opt,name=bool" json:"bool,omitempty"`
+	Str                  *wrapperspb.StringValue `protobuf:"bytes,10,opt,name=str" json:"str,omitempty"`
+	Bytes                *wrapperspb.BytesValue  `protobuf:"bytes,11,opt,name=bytes" json:"bytes,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
+	XXX_unrecognized     []byte                  `json:"-"`
+	XXX_sizecache        int32                   `json:"-"`
 }
 
 func (m *KnownTypes) Reset()         { *m = KnownTypes{} }
 func (m *KnownTypes) String() string { return proto.CompactTextString(m) }
 func (*KnownTypes) ProtoMessage()    {}
 func (*KnownTypes) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_objects_c6f6c615ab823e65, []int{8}
+	return fileDescriptor_50cab1d8463dea41, []int{8}
 }
+
 func (m *KnownTypes) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_KnownTypes.Unmarshal(m, b)
 }
 func (m *KnownTypes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_KnownTypes.Marshal(b, m, deterministic)
 }
-func (dst *KnownTypes) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_KnownTypes.Merge(dst, src)
+func (m *KnownTypes) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_KnownTypes.Merge(m, src)
 }
 func (m *KnownTypes) XXX_Size() int {
 	return xxx_messageInfo_KnownTypes.Size(m)
@@ -871,105 +855,105 @@ func (m *KnownTypes) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_KnownTypes proto.InternalMessageInfo
 
-func (m *KnownTypes) GetAn() *any.Any {
+func (m *KnownTypes) GetAn() *anypb.Any {
 	if m != nil {
 		return m.An
 	}
 	return nil
 }
 
-func (m *KnownTypes) GetDur() *duration.Duration {
+func (m *KnownTypes) GetDur() *durationpb.Duration {
 	if m != nil {
 		return m.Dur
 	}
 	return nil
 }
 
-func (m *KnownTypes) GetSt() *_struct.Struct {
+func (m *KnownTypes) GetSt() *structpb.Struct {
 	if m != nil {
 		return m.St
 	}
 	return nil
 }
 
-func (m *KnownTypes) GetTs() *timestamp.Timestamp {
+func (m *KnownTypes) GetTs() *timestamppb.Timestamp {
 	if m != nil {
 		return m.Ts
 	}
 	return nil
 }
 
-func (m *KnownTypes) GetLv() *_struct.ListValue {
+func (m *KnownTypes) GetLv() *structpb.ListValue {
 	if m != nil {
 		return m.Lv
 	}
 	return nil
 }
 
-func (m *KnownTypes) GetVal() *_struct.Value {
+func (m *KnownTypes) GetVal() *structpb.Value {
 	if m != nil {
 		return m.Val
 	}
 	return nil
 }
 
-func (m *KnownTypes) GetDbl() *wrappers.DoubleValue {
+func (m *KnownTypes) GetDbl() *wrapperspb.DoubleValue {
 	if m != nil {
 		return m.Dbl
 	}
 	return nil
 }
 
-func (m *KnownTypes) GetFlt() *wrappers.FloatValue {
+func (m *KnownTypes) GetFlt() *wrapperspb.FloatValue {
 	if m != nil {
 		return m.Flt
 	}
 	return nil
 }
 
-func (m *KnownTypes) GetI64() *wrappers.Int64Value {
+func (m *KnownTypes) GetI64() *wrapperspb.Int64Value {
 	if m != nil {
 		return m.I64
 	}
 	return nil
 }
 
-func (m *KnownTypes) GetU64() *wrappers.UInt64Value {
+func (m *KnownTypes) GetU64() *wrapperspb.UInt64Value {
 	if m != nil {
 		return m.U64
 	}
 	return nil
 }
 
-func (m *KnownTypes) GetI32() *wrappers.Int32Value {
+func (m *KnownTypes) GetI32() *wrapperspb.Int32Value {
 	if m != nil {
 		return m.I32
 	}
 	return nil
 }
 
-func (m *KnownTypes) GetU32() *wrappers.UInt32Value {
+func (m *KnownTypes) GetU32() *wrapperspb.UInt32Value {
 	if m != nil {
 		return m.U32
 	}
 	return nil
 }
 
-func (m *KnownTypes) GetBool() *wrappers.BoolValue {
+func (m *KnownTypes) GetBool() *wrapperspb.BoolValue {
 	if m != nil {
 		return m.Bool
 	}
 	return nil
 }
 
-func (m *KnownTypes) GetStr() *wrappers.StringValue {
+func (m *KnownTypes) GetStr() *wrapperspb.StringValue {
 	if m != nil {
 		return m.Str
 	}
 	return nil
 }
 
-func (m *KnownTypes) GetBytes() *wrappers.BytesValue {
+func (m *KnownTypes) GetBytes() *wrapperspb.BytesValue {
 	if m != nil {
 		return m.Bytes
 	}
@@ -988,16 +972,17 @@ func (m *MsgWithRequired) Reset()         { *m = MsgWithRequired{} }
 func (m *MsgWithRequired) String() string { return proto.CompactTextString(m) }
 func (*MsgWithRequired) ProtoMessage()    {}
 func (*MsgWithRequired) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_objects_c6f6c615ab823e65, []int{9}
+	return fileDescriptor_50cab1d8463dea41, []int{9}
 }
+
 func (m *MsgWithRequired) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_MsgWithRequired.Unmarshal(m, b)
 }
 func (m *MsgWithRequired) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_MsgWithRequired.Marshal(b, m, deterministic)
 }
-func (dst *MsgWithRequired) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MsgWithRequired.Merge(dst, src)
+func (m *MsgWithRequired) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgWithRequired.Merge(m, src)
 }
 func (m *MsgWithRequired) XXX_Size() int {
 	return xxx_messageInfo_MsgWithRequired.Size(m)
@@ -1028,16 +1013,17 @@ func (m *MsgWithIndirectRequired) Reset()         { *m = MsgWithIndirectRequired
 func (m *MsgWithIndirectRequired) String() string { return proto.CompactTextString(m) }
 func (*MsgWithIndirectRequired) ProtoMessage()    {}
 func (*MsgWithIndirectRequired) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_objects_c6f6c615ab823e65, []int{10}
+	return fileDescriptor_50cab1d8463dea41, []int{10}
 }
+
 func (m *MsgWithIndirectRequired) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_MsgWithIndirectRequired.Unmarshal(m, b)
 }
 func (m *MsgWithIndirectRequired) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_MsgWithIndirectRequired.Marshal(b, m, deterministic)
 }
-func (dst *MsgWithIndirectRequired) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MsgWithIndirectRequired.Merge(dst, src)
+func (m *MsgWithIndirectRequired) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgWithIndirectRequired.Merge(m, src)
 }
 func (m *MsgWithIndirectRequired) XXX_Size() int {
 	return xxx_messageInfo_MsgWithIndirectRequired.Size(m)
@@ -1080,16 +1066,17 @@ func (m *MsgWithRequiredBytes) Reset()         { *m = MsgWithRequiredBytes{} }
 func (m *MsgWithRequiredBytes) String() string { return proto.CompactTextString(m) }
 func (*MsgWithRequiredBytes) ProtoMessage()    {}
 func (*MsgWithRequiredBytes) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_objects_c6f6c615ab823e65, []int{11}
+	return fileDescriptor_50cab1d8463dea41, []int{11}
 }
+
 func (m *MsgWithRequiredBytes) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_MsgWithRequiredBytes.Unmarshal(m, b)
 }
 func (m *MsgWithRequiredBytes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_MsgWithRequiredBytes.Marshal(b, m, deterministic)
 }
-func (dst *MsgWithRequiredBytes) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MsgWithRequiredBytes.Merge(dst, src)
+func (m *MsgWithRequiredBytes) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgWithRequiredBytes.Merge(m, src)
 }
 func (m *MsgWithRequiredBytes) XXX_Size() int {
 	return xxx_messageInfo_MsgWithRequiredBytes.Size(m)
@@ -1108,26 +1095,27 @@ func (m *MsgWithRequiredBytes) GetByts() []byte {
 }
 
 type MsgWithRequiredWKT struct {
-	Str                  *wrappers.StringValue `protobuf:"bytes,1,req,name=str" json:"str,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
-	XXX_unrecognized     []byte                `json:"-"`
-	XXX_sizecache        int32                 `json:"-"`
+	Str                  *wrapperspb.StringValue `protobuf:"bytes,1,req,name=str" json:"str,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
+	XXX_unrecognized     []byte                  `json:"-"`
+	XXX_sizecache        int32                   `json:"-"`
 }
 
 func (m *MsgWithRequiredWKT) Reset()         { *m = MsgWithRequiredWKT{} }
 func (m *MsgWithRequiredWKT) String() string { return proto.CompactTextString(m) }
 func (*MsgWithRequiredWKT) ProtoMessage()    {}
 func (*MsgWithRequiredWKT) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_objects_c6f6c615ab823e65, []int{12}
+	return fileDescriptor_50cab1d8463dea41, []int{12}
 }
+
 func (m *MsgWithRequiredWKT) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_MsgWithRequiredWKT.Unmarshal(m, b)
 }
 func (m *MsgWithRequiredWKT) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_MsgWithRequiredWKT.Marshal(b, m, deterministic)
 }
-func (dst *MsgWithRequiredWKT) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MsgWithRequiredWKT.Merge(dst, src)
+func (m *MsgWithRequiredWKT) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgWithRequiredWKT.Merge(m, src)
 }
 func (m *MsgWithRequiredWKT) XXX_Size() int {
 	return xxx_messageInfo_MsgWithRequiredWKT.Size(m)
@@ -1138,7 +1126,7 @@ func (m *MsgWithRequiredWKT) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_MsgWithRequiredWKT proto.InternalMessageInfo
 
-func (m *MsgWithRequiredWKT) GetStr() *wrappers.StringValue {
+func (m *MsgWithRequiredWKT) GetStr() *wrapperspb.StringValue {
 	if m != nil {
 		return m.Str
 	}
@@ -1149,130 +1137,140 @@ var E_Name = &proto.ExtensionDesc{
 	ExtendedType:  (*Real)(nil),
 	ExtensionType: (*string)(nil),
 	Field:         124,
-	Name:          "jsonpb.name",
+	Name:          "jsonpb_test.name",
 	Tag:           "bytes,124,opt,name=name",
-	Filename:      "test_objects.proto",
+	Filename:      "jsonpb_proto/test2.proto",
 }
 
 var E_Extm = &proto.ExtensionDesc{
 	ExtendedType:  (*Real)(nil),
 	ExtensionType: (*MsgWithRequired)(nil),
 	Field:         125,
-	Name:          "jsonpb.extm",
+	Name:          "jsonpb_test.extm",
 	Tag:           "bytes,125,opt,name=extm",
-	Filename:      "test_objects.proto",
+	Filename:      "jsonpb_proto/test2.proto",
 }
 
 func init() {
-	proto.RegisterType((*Simple)(nil), "jsonpb.Simple")
-	proto.RegisterType((*NonFinites)(nil), "jsonpb.NonFinites")
-	proto.RegisterType((*Repeats)(nil), "jsonpb.Repeats")
-	proto.RegisterType((*Widget)(nil), "jsonpb.Widget")
-	proto.RegisterType((*Maps)(nil), "jsonpb.Maps")
-	proto.RegisterMapType((map[bool]*Simple)(nil), "jsonpb.Maps.MBoolSimpleEntry")
-	proto.RegisterMapType((map[int64]string)(nil), "jsonpb.Maps.MInt64StrEntry")
-	proto.RegisterType((*MsgWithOneof)(nil), "jsonpb.MsgWithOneof")
-	proto.RegisterType((*Real)(nil), "jsonpb.Real")
-	proto.RegisterType((*Complex)(nil), "jsonpb.Complex")
-	proto.RegisterType((*KnownTypes)(nil), "jsonpb.KnownTypes")
-	proto.RegisterType((*MsgWithRequired)(nil), "jsonpb.MsgWithRequired")
-	proto.RegisterType((*MsgWithIndirectRequired)(nil), "jsonpb.MsgWithIndirectRequired")
-	proto.RegisterMapType((map[string]*MsgWithRequired)(nil), "jsonpb.MsgWithIndirectRequired.MapFieldEntry")
-	proto.RegisterType((*MsgWithRequiredBytes)(nil), "jsonpb.MsgWithRequiredBytes")
-	proto.RegisterType((*MsgWithRequiredWKT)(nil), "jsonpb.MsgWithRequiredWKT")
-	proto.RegisterEnum("jsonpb.Widget_Color", Widget_Color_name, Widget_Color_value)
+	proto.RegisterEnum("jsonpb_test.Widget_Color", Widget_Color_name, Widget_Color_value)
+	proto.RegisterType((*Simple)(nil), "jsonpb_test.Simple")
+	proto.RegisterType((*NonFinites)(nil), "jsonpb_test.NonFinites")
+	proto.RegisterType((*Repeats)(nil), "jsonpb_test.Repeats")
+	proto.RegisterType((*Widget)(nil), "jsonpb_test.Widget")
+	proto.RegisterType((*Maps)(nil), "jsonpb_test.Maps")
+	proto.RegisterMapType((map[bool]*Simple)(nil), "jsonpb_test.Maps.MBoolSimpleEntry")
+	proto.RegisterMapType((map[int64]string)(nil), "jsonpb_test.Maps.MInt64StrEntry")
+	proto.RegisterType((*MsgWithOneof)(nil), "jsonpb_test.MsgWithOneof")
+	proto.RegisterType((*Real)(nil), "jsonpb_test.Real")
 	proto.RegisterExtension(E_Complex_RealExtension)
+	proto.RegisterType((*Complex)(nil), "jsonpb_test.Complex")
+	proto.RegisterType((*KnownTypes)(nil), "jsonpb_test.KnownTypes")
+	proto.RegisterType((*MsgWithRequired)(nil), "jsonpb_test.MsgWithRequired")
+	proto.RegisterType((*MsgWithIndirectRequired)(nil), "jsonpb_test.MsgWithIndirectRequired")
+	proto.RegisterMapType((map[string]*MsgWithRequired)(nil), "jsonpb_test.MsgWithIndirectRequired.MapFieldEntry")
+	proto.RegisterType((*MsgWithRequiredBytes)(nil), "jsonpb_test.MsgWithRequiredBytes")
+	proto.RegisterType((*MsgWithRequiredWKT)(nil), "jsonpb_test.MsgWithRequiredWKT")
 	proto.RegisterExtension(E_Name)
 	proto.RegisterExtension(E_Extm)
 }
 
-func init() { proto.RegisterFile("test_objects.proto", fileDescriptor_test_objects_c6f6c615ab823e65) }
-
-var fileDescriptor_test_objects_c6f6c615ab823e65 = []byte{
-	// 1357 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x56, 0xdd, 0x72, 0x13, 0xc7,
-	0x12, 0xf6, 0xee, 0x6a, 0xf5, 0xd3, 0xf2, 0x1f, 0x83, 0x81, 0xc5, 0x87, 0x73, 0x8e, 0x4a, 0x70,
-	0x38, 0x0a, 0xc4, 0xa2, 0x22, 0xbb, 0x5c, 0x84, 0xe4, 0x06, 0x63, 0x13, 0x08, 0xe0, 0xa4, 0xc6,
-	0x26, 0x5c, 0xaa, 0x56, 0xde, 0x91, 0x59, 0xb2, 0xbb, 0xa3, 0xcc, 0xcc, 0xda, 0xa8, 0x92, 0x54,
-	0xf9, 0x19, 0x52, 0x79, 0x82, 0x54, 0x25, 0x8f, 0x90, 0x8b, 0xbc, 0x45, 0xde, 0x28, 0x35, 0x3d,
-	0xb3, 0x5a, 0x59, 0x42, 0x95, 0x5c, 0x79, 0xbb, 0xfb, 0xeb, 0x4f, 0x33, 0xfd, 0xf5, 0x74, 0x1b,
-	0x88, 0x62, 0x52, 0xf5, 0xf9, 0xe0, 0x1d, 0x3b, 0x51, 0xb2, 0x3b, 0x12, 0x5c, 0x71, 0x52, 0x7d,
-	0x27, 0x79, 0x36, 0x1a, 0x6c, 0xde, 0x3c, 0xe5, 0xfc, 0x34, 0x61, 0x0f, 0xd0, 0x3b, 0xc8, 0x87,
-	0x0f, 0xc2, 0x6c, 0x6c, 0x20, 0x9b, 0xff, 0x99, 0x0d, 0x45, 0xb9, 0x08, 0x55, 0xcc, 0x33, 0x1b,
-	0xbf, 0x35, 0x1b, 0x97, 0x4a, 0xe4, 0x27, 0xca, 0x46, 0xff, 0x3b, 0x1b, 0x55, 0x71, 0xca, 0xa4,
-	0x0a, 0xd3, 0xd1, 0x22, 0xfa, 0x73, 0x11, 0x8e, 0x46, 0x4c, 0xd8, 0x13, 0xb6, 0x7f, 0x75, 0xa1,
-	0x7a, 0x14, 0xa7, 0xa3, 0x84, 0x91, 0x6b, 0x50, 0xe5, 0xfd, 0x01, 0xe7, 0x49, 0xe0, 0xb4, 0x9c,
-	0x4e, 0x9d, 0xfa, 0x7c, 0x8f, 0xf3, 0x84, 0xdc, 0x80, 0x1a, 0xef, 0xc7, 0x99, 0xda, 0xee, 0x05,
-	0x6e, 0xcb, 0xe9, 0xf8, 0xb4, 0xca, 0x9f, 0x6b, 0x6b, 0x12, 0xd8, 0xdd, 0x09, 0xbc, 0x96, 0xd3,
-	0xf1, 0x4c, 0x60, 0x77, 0x87, 0xdc, 0x84, 0x3a, 0xef, 0xe7, 0x26, 0xa5, 0xd2, 0x72, 0x3a, 0x2b,
-	0xb4, 0xc6, 0x5f, 0xa3, 0x59, 0x86, 0x76, 0x77, 0x02, 0xbf, 0xe5, 0x74, 0x2a, 0x36, 0x54, 0x64,
-	0x49, 0x93, 0x55, 0x6d, 0x39, 0x9d, 0x2b, 0xb4, 0xc6, 0x8f, 0xa6, 0xb2, 0xa4, 0xc9, 0xaa, 0xb5,
-	0x9c, 0x0e, 0xb1, 0xa1, 0xdd, 0x1d, 0x73, 0x88, 0x61, 0xc2, 0x43, 0x15, 0xd4, 0x5b, 0x4e, 0xc7,
-	0xa5, 0x55, 0xfe, 0x54, 0x5b, 0x26, 0x27, 0xe2, 0xf9, 0x20, 0x61, 0x41, 0xa3, 0xe5, 0x74, 0x1c,
-	0x5a, 0xe3, 0xfb, 0x68, 0x5a, 0x3a, 0x25, 0xe2, 0xec, 0x34, 0x80, 0x96, 0xd3, 0x69, 0x68, 0x3a,
-	0x34, 0x0d, 0xdd, 0x60, 0xac, 0x98, 0x0c, 0x9a, 0x2d, 0xa7, 0xb3, 0x4c, 0xab, 0x7c, 0x4f, 0x5b,
-	0xed, 0x9f, 0x1c, 0x80, 0x43, 0x9e, 0x3d, 0x8d, 0xb3, 0x58, 0x31, 0x49, 0xae, 0x82, 0x3f, 0xec,
-	0x67, 0x61, 0x86, 0xa5, 0x72, 0x69, 0x65, 0x78, 0x18, 0x66, 0xba, 0x80, 0xc3, 0xfe, 0x28, 0xce,
-	0x86, 0x58, 0x28, 0x97, 0xfa, 0xc3, 0xaf, 0xe3, 0x6c, 0x68, 0xdc, 0x99, 0x76, 0x7b, 0xd6, 0x7d,
-	0xa8, 0xdd, 0x57, 0xc1, 0x8f, 0x90, 0xa2, 0x82, 0xa7, 0xab, 0x44, 0x96, 0x22, 0x32, 0x14, 0x3e,
-	0x7a, 0xfd, 0xa8, 0xa0, 0x88, 0x0c, 0x45, 0xd5, 0xba, 0x35, 0x45, 0xfb, 0x37, 0x17, 0x6a, 0x94,
-	0x8d, 0x58, 0xa8, 0xa4, 0x86, 0x88, 0x42, 0x3d, 0x4f, 0xab, 0x27, 0x0a, 0xf5, 0xc4, 0x44, 0x3d,
-	0x4f, 0xab, 0x27, 0x26, 0xea, 0x89, 0x89, 0x7a, 0x9e, 0x56, 0x4f, 0x4c, 0xd4, 0x13, 0xa5, 0x7a,
-	0x9e, 0x56, 0x4f, 0x94, 0xea, 0x89, 0x52, 0x3d, 0x4f, 0xab, 0x27, 0x4a, 0xf5, 0x44, 0xa9, 0x9e,
-	0xa7, 0xd5, 0x13, 0x47, 0x53, 0x59, 0x13, 0xf5, 0x3c, 0xad, 0x9e, 0x28, 0xd5, 0x13, 0x13, 0xf5,
-	0x3c, 0xad, 0x9e, 0x98, 0xa8, 0x27, 0x4a, 0xf5, 0x3c, 0xad, 0x9e, 0x28, 0xd5, 0x13, 0xa5, 0x7a,
-	0x9e, 0x56, 0x4f, 0x94, 0xea, 0x89, 0x89, 0x7a, 0x9e, 0x56, 0x4f, 0x18, 0xf5, 0x7e, 0x77, 0xa1,
-	0xfa, 0x26, 0x8e, 0x4e, 0x99, 0x22, 0xf7, 0xc0, 0x3f, 0xe1, 0x09, 0x17, 0xa8, 0xdc, 0x6a, 0x6f,
-	0xa3, 0x6b, 0x9e, 0x68, 0xd7, 0x84, 0xbb, 0x4f, 0x74, 0x8c, 0x1a, 0x08, 0xd9, 0xd2, 0x7c, 0x06,
-	0xad, 0x8b, 0xb7, 0x08, 0x5d, 0x15, 0xf8, 0x97, 0xdc, 0x85, 0xaa, 0xc4, 0xa7, 0x84, 0x5d, 0xd5,
-	0xec, 0xad, 0x16, 0x68, 0xf3, 0xc0, 0xa8, 0x8d, 0x92, 0x8f, 0x4c, 0x41, 0x10, 0xa9, 0xcf, 0x39,
-	0x8f, 0xd4, 0x05, 0xb2, 0xd0, 0x9a, 0x30, 0x02, 0x07, 0x1b, 0xc8, 0xb9, 0x56, 0x20, 0xad, 0xee,
-	0xb4, 0x88, 0x93, 0x8f, 0xa1, 0x21, 0xfa, 0x05, 0xf8, 0x1a, 0xd2, 0xce, 0x81, 0xeb, 0xc2, 0x7e,
-	0xb5, 0xff, 0x07, 0xbe, 0x39, 0x74, 0x0d, 0x3c, 0x7a, 0xb0, 0xbf, 0xbe, 0x44, 0x1a, 0xe0, 0x7f,
-	0x41, 0x0f, 0x0e, 0x0e, 0xd7, 0x1d, 0x52, 0x87, 0xca, 0xde, 0xcb, 0xd7, 0x07, 0xeb, 0x6e, 0xfb,
-	0x67, 0x17, 0x2a, 0xaf, 0xc2, 0x91, 0x24, 0x9f, 0x41, 0x33, 0x35, 0xed, 0xa2, 0x6b, 0x8f, 0x3d,
-	0xd6, 0xec, 0xfd, 0xab, 0xe0, 0xd7, 0x90, 0xee, 0x2b, 0xec, 0x9f, 0x23, 0x25, 0x0e, 0x32, 0x25,
-	0xc6, 0xb4, 0x91, 0x16, 0x36, 0x79, 0x0c, 0x2b, 0x29, 0xf6, 0x66, 0x71, 0x6b, 0x17, 0xd3, 0xff,
-	0x7d, 0x39, 0x5d, 0xf7, 0xab, 0xb9, 0xb6, 0x21, 0x68, 0xa6, 0xa5, 0x67, 0xf3, 0x73, 0x58, 0xbd,
-	0xcc, 0x4f, 0xd6, 0xc1, 0xfb, 0x96, 0x8d, 0x51, 0x46, 0x8f, 0xea, 0x4f, 0xb2, 0x01, 0xfe, 0x59,
-	0x98, 0xe4, 0x0c, 0x9f, 0x5f, 0x83, 0x1a, 0xe3, 0x91, 0xfb, 0xd0, 0xd9, 0x3c, 0x84, 0xf5, 0x59,
-	0xfa, 0xe9, 0xfc, 0xba, 0xc9, 0xbf, 0x33, 0x9d, 0x3f, 0x2f, 0x4a, 0xc9, 0xd7, 0xfe, 0xd3, 0x81,
-	0xe5, 0x57, 0xf2, 0xf4, 0x4d, 0xac, 0xde, 0x7e, 0x95, 0x31, 0x3e, 0x24, 0xd7, 0xc1, 0x57, 0xb1,
-	0x4a, 0x18, 0xd2, 0x35, 0x9e, 0x2d, 0x51, 0x63, 0x92, 0x00, 0xaa, 0x32, 0x4c, 0x42, 0x31, 0x46,
-	0x4e, 0xef, 0xd9, 0x12, 0xb5, 0x36, 0xd9, 0x84, 0xda, 0x13, 0x9e, 0xeb, 0x93, 0xe0, 0x58, 0xd0,
-	0x39, 0x85, 0x83, 0xdc, 0x86, 0xe5, 0xb7, 0x3c, 0x65, 0xfd, 0x30, 0x8a, 0x04, 0x93, 0x12, 0x27,
-	0x84, 0x06, 0x34, 0xb5, 0xf7, 0xb1, 0x71, 0x92, 0x03, 0xb8, 0x92, 0xca, 0xd3, 0xfe, 0x79, 0xac,
-	0xde, 0xf6, 0x05, 0xfb, 0x2e, 0x8f, 0x05, 0x8b, 0x70, 0x6a, 0x34, 0x7b, 0x37, 0x26, 0x85, 0x35,
-	0x67, 0xa4, 0x36, 0xfc, 0x6c, 0x89, 0xae, 0xa5, 0x97, 0x5d, 0x7b, 0x35, 0xf0, 0xf3, 0x2c, 0xe6,
-	0x59, 0xfb, 0x2e, 0x54, 0x28, 0x0b, 0x93, 0xb2, 0x8a, 0x8e, 0x19, 0x35, 0x68, 0xdc, 0xab, 0xd7,
-	0xa3, 0xf5, 0x8b, 0x8b, 0x8b, 0x0b, 0xb7, 0x7d, 0xae, 0x0f, 0xae, 0x0b, 0xf2, 0x9e, 0xdc, 0x82,
-	0x46, 0x9c, 0x86, 0xa7, 0x71, 0xa6, 0x2f, 0x68, 0xe0, 0xa5, 0xa3, 0x4c, 0xe9, 0xed, 0xc3, 0xaa,
-	0x60, 0x61, 0xd2, 0x67, 0xef, 0x15, 0xcb, 0x64, 0xcc, 0x33, 0xb2, 0x5c, 0x76, 0x66, 0x98, 0x04,
-	0xdf, 0x5f, 0x6e, 0x6d, 0x4b, 0x4f, 0x57, 0x74, 0xd2, 0x41, 0x91, 0xd3, 0xfe, 0xc3, 0x07, 0x78,
-	0x91, 0xf1, 0xf3, 0xec, 0x78, 0x3c, 0x62, 0x92, 0xdc, 0x01, 0x37, 0xcc, 0x82, 0x55, 0x4c, 0xdd,
-	0xe8, 0x9a, 0x35, 0xd7, 0x2d, 0xd6, 0x5c, 0xf7, 0x71, 0x36, 0xa6, 0x6e, 0x98, 0x91, 0xfb, 0xe0,
-	0x45, 0xb9, 0x79, 0xec, 0xcd, 0xde, 0xcd, 0x39, 0xd8, 0xbe, 0x5d, 0xb6, 0x54, 0xa3, 0xc8, 0xff,
-	0xc1, 0x95, 0x2a, 0x58, 0xb6, 0x35, 0x9c, 0xc5, 0x1e, 0xe1, 0xe2, 0xa5, 0xae, 0xd4, 0x43, 0xc4,
-	0x55, 0xd2, 0xb6, 0xc9, 0xe6, 0x1c, 0xf0, 0xb8, 0xd8, 0xc1, 0xd4, 0x55, 0x52, 0x63, 0x93, 0xb3,
-	0x60, 0x6d, 0x01, 0xf6, 0x65, 0x2c, 0xd5, 0x37, 0xba, 0xc2, 0xd4, 0x4d, 0xce, 0x48, 0x07, 0xbc,
-	0xb3, 0x30, 0x09, 0xd6, 0x11, 0x7c, 0x7d, 0x0e, 0x6c, 0x80, 0x1a, 0x42, 0xba, 0xe0, 0x45, 0x83,
-	0x04, 0x5b, 0xa7, 0xd9, 0xbb, 0x35, 0x7f, 0x2f, 0x9c, 0x95, 0x16, 0x1f, 0x0d, 0x12, 0xb2, 0x05,
-	0xde, 0x30, 0x51, 0xd8, 0x49, 0xfa, 0xdd, 0xce, 0xe2, 0x71, 0xea, 0x5a, 0xf8, 0x30, 0x51, 0x1a,
-	0x1e, 0xdb, 0x15, 0xfd, 0x21, 0x38, 0xbe, 0x44, 0x0b, 0x8f, 0x77, 0x77, 0xf4, 0x69, 0xf2, 0xdd,
-	0x1d, 0x5c, 0x4e, 0x1f, 0x3a, 0xcd, 0xeb, 0x69, 0x7c, 0xbe, 0xbb, 0x83, 0xf4, 0xdb, 0x3d, 0xdc,
-	0xe5, 0x0b, 0xe8, 0xb7, 0x7b, 0x05, 0xfd, 0x76, 0x0f, 0xe9, 0xb7, 0x7b, 0xb8, 0xe0, 0x17, 0xd1,
-	0x4f, 0xf0, 0x39, 0xe2, 0x2b, 0xb8, 0x09, 0x1b, 0x0b, 0x8a, 0xae, 0x47, 0x81, 0x81, 0x23, 0x4e,
-	0xf3, 0xeb, 0xa1, 0x06, 0x0b, 0xf8, 0xcd, 0x76, 0xb1, 0xfc, 0x52, 0x09, 0xf2, 0x09, 0xf8, 0xe5,
-	0xff, 0x08, 0x1f, 0xba, 0x00, 0x6e, 0x1d, 0x93, 0x60, 0x90, 0xed, 0xdb, 0xb0, 0x36, 0xf3, 0x18,
-	0xf5, 0x00, 0x32, 0xa3, 0xd4, 0xed, 0x34, 0x90, 0xb7, 0xfd, 0x8b, 0x0b, 0x37, 0x2c, 0xea, 0x79,
-	0x16, 0xc5, 0x82, 0x9d, 0xa8, 0x09, 0xfa, 0x3e, 0x54, 0x64, 0x3e, 0x48, 0x6d, 0x27, 0x2f, 0x7a,
-	0xe1, 0x14, 0x41, 0xe4, 0x4b, 0x68, 0xa4, 0xe1, 0xa8, 0x3f, 0x8c, 0x59, 0x12, 0xd9, 0x61, 0xbb,
-	0x35, 0x93, 0x31, 0xfb, 0x03, 0x7a, 0x08, 0x3f, 0xd5, 0x78, 0x33, 0x7c, 0xeb, 0xa9, 0x35, 0xc9,
-	0x43, 0x68, 0xca, 0x24, 0x3e, 0x61, 0x96, 0xcd, 0x43, 0xb6, 0x85, 0xbf, 0x0f, 0x88, 0xc5, 0xcc,
-	0xcd, 0x63, 0x58, 0xb9, 0x44, 0x3a, 0x3d, 0x72, 0x1b, 0x66, 0xe4, 0x6e, 0x5d, 0x1e, 0xb9, 0x0b,
-	0x69, 0xa7, 0x66, 0xef, 0x3d, 0xd8, 0x98, 0x89, 0x62, 0xb5, 0x09, 0x81, 0xca, 0x60, 0xac, 0x24,
-	0xd6, 0x73, 0x99, 0xe2, 0x77, 0x7b, 0x1f, 0xc8, 0x0c, 0xf6, 0xcd, 0x8b, 0xe3, 0x42, 0x6e, 0x0d,
-	0xfc, 0x27, 0x72, 0x3f, 0x6a, 0x41, 0x25, 0x0b, 0x53, 0x36, 0x33, 0xb4, 0x7e, 0xc0, 0x5b, 0x60,
-	0xe4, 0xd1, 0xa7, 0x50, 0x61, 0xef, 0x55, 0x3a, 0x83, 0xf8, 0xf1, 0x6f, 0xa4, 0xd2, 0x29, 0x7f,
-	0x05, 0x00, 0x00, 0xff, 0xff, 0xea, 0x06, 0x1a, 0xa9, 0x37, 0x0c, 0x00, 0x00,
+func init() { proto.RegisterFile("jsonpb_proto/test2.proto", fileDescriptor_50cab1d8463dea41) }
+
+var fileDescriptor_50cab1d8463dea41 = []byte{
+	// 1510 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x57, 0xdd, 0x6e, 0xdb, 0x46,
+	0x16, 0x36, 0x49, 0x51, 0x12, 0x8f, 0x6c, 0xc7, 0x1e, 0x3b, 0x09, 0xed, 0x0d, 0xb2, 0x84, 0xb2,
+	0xd9, 0xd5, 0x26, 0x58, 0x79, 0x43, 0x0b, 0x42, 0x91, 0x36, 0x40, 0xe3, 0xd8, 0x6e, 0xd2, 0x24,
+	0x4e, 0x41, 0x27, 0x0d, 0xda, 0x1b, 0x81, 0x32, 0x29, 0x99, 0x2d, 0xc9, 0x51, 0x67, 0x46, 0x4e,
+	0x84, 0xb6, 0x80, 0xfb, 0x0a, 0x7d, 0x85, 0x02, 0xbd, 0xed, 0x5d, 0x2f, 0xfa, 0x1c, 0x45, 0x9f,
+	0xa7, 0x98, 0x33, 0x43, 0xfd, 0x59, 0x36, 0x72, 0x65, 0xcd, 0x7c, 0x3f, 0x33, 0x9c, 0xf3, 0xf1,
+	0x0c, 0x0d, 0xee, 0x37, 0x9c, 0xe6, 0x83, 0x6e, 0x67, 0xc0, 0xa8, 0xa0, 0x3b, 0x22, 0xe6, 0xc2,
+	0x6f, 0xe2, 0x6f, 0x52, 0xd3, 0x88, 0x9c, 0xdb, 0xde, 0xea, 0x53, 0xda, 0x4f, 0xe3, 0x1d, 0x84,
+	0xba, 0xc3, 0xde, 0x4e, 0x98, 0x8f, 0x14, 0x6f, 0xfb, 0xf6, 0x3c, 0x14, 0x0d, 0x59, 0x28, 0x12,
+	0x9a, 0x6b, 0xfc, 0xd6, 0x3c, 0xce, 0x05, 0x1b, 0x9e, 0x08, 0x8d, 0xfe, 0x73, 0x1e, 0x15, 0x49,
+	0x16, 0x73, 0x11, 0x66, 0x83, 0xcb, 0xec, 0xdf, 0xb1, 0x70, 0x30, 0x88, 0x19, 0x57, 0x78, 0xfd,
+	0xb7, 0x12, 0x94, 0x8f, 0x93, 0x6c, 0x90, 0xc6, 0xe4, 0x3a, 0x94, 0x69, 0xa7, 0x4b, 0x69, 0xea,
+	0x1a, 0x9e, 0xd1, 0xa8, 0x06, 0x36, 0xdd, 0xa3, 0x34, 0x25, 0x37, 0xa1, 0x42, 0x3b, 0x49, 0x2e,
+	0x76, 0x7d, 0xd7, 0xf4, 0x8c, 0x86, 0x1d, 0x94, 0xe9, 0x33, 0x39, 0x22, 0xb7, 0xa1, 0xa6, 0x81,
+	0x0e, 0x17, 0xcc, 0xb5, 0x10, 0x74, 0x14, 0x78, 0x2c, 0xd8, 0x58, 0xd8, 0x6e, 0xb9, 0x25, 0xcf,
+	0x68, 0x58, 0x4a, 0xd8, 0x6e, 0x8d, 0x85, 0xed, 0x16, 0x0a, 0x6d, 0x04, 0x1d, 0x05, 0x4a, 0xe1,
+	0x16, 0x54, 0x69, 0x67, 0xa8, 0x96, 0x2c, 0x7b, 0x46, 0x63, 0x25, 0xa8, 0xd0, 0x37, 0x38, 0x24,
+	0x1e, 0x2c, 0x17, 0x10, 0x6a, 0x2b, 0x08, 0x83, 0x86, 0x67, 0xc4, 0xed, 0x96, 0x5b, 0xf5, 0x8c,
+	0x46, 0x49, 0x8b, 0xdb, 0xad, 0x89, 0x58, 0x2f, 0xec, 0x20, 0x0c, 0x1a, 0x1e, 0x8b, 0xb9, 0x5a,
+	0x19, 0x3c, 0xa3, 0xb1, 0x1e, 0x54, 0xe8, 0xf1, 0xd4, 0xca, 0x7c, 0xb2, 0x72, 0x0d, 0x61, 0xd0,
+	0xf0, 0x8c, 0xb8, 0xdd, 0x72, 0x97, 0x3d, 0xa3, 0x41, 0xb4, 0xb8, 0x58, 0x99, 0x4f, 0x56, 0x5e,
+	0x41, 0x18, 0x34, 0x3c, 0x3e, 0xac, 0x5e, 0x4a, 0x43, 0xe1, 0xae, 0x7a, 0x46, 0xc3, 0x0c, 0xca,
+	0xf4, 0x50, 0x8e, 0xd4, 0x61, 0x21, 0x80, 0xca, 0x6b, 0x08, 0x3a, 0x0a, 0x1c, 0xaf, 0x1a, 0xd1,
+	0x61, 0x37, 0x8d, 0xdd, 0x35, 0xcf, 0x68, 0x18, 0x41, 0x85, 0xee, 0xe3, 0x50, 0xad, 0xaa, 0x20,
+	0xd4, 0xae, 0x23, 0x0c, 0x1a, 0x9e, 0x6c, 0x59, 0xb0, 0x24, 0xef, 0xbb, 0xc4, 0x33, 0x1a, 0x8e,
+	0xdc, 0x32, 0x0e, 0xd5, 0x86, 0xba, 0x23, 0x11, 0x73, 0x77, 0xc3, 0x33, 0x1a, 0xcb, 0x41, 0x99,
+	0xee, 0xc9, 0x51, 0xfd, 0x67, 0x03, 0xe0, 0x88, 0xe6, 0x87, 0x49, 0x9e, 0x88, 0x98, 0x93, 0x0d,
+	0xb0, 0x7b, 0x9d, 0x3c, 0xcc, 0x31, 0x34, 0x66, 0x50, 0xea, 0x1d, 0x85, 0xb9, 0x8c, 0x52, 0xaf,
+	0x33, 0x48, 0xf2, 0x1e, 0x46, 0xc6, 0x0c, 0xec, 0xde, 0x17, 0x49, 0xde, 0x53, 0xd3, 0xb9, 0x9c,
+	0xb6, 0xf4, 0xf4, 0x91, 0x9c, 0xde, 0x00, 0x3b, 0x42, 0x8b, 0x12, 0x6e, 0xb0, 0x14, 0x69, 0x8b,
+	0x48, 0x59, 0xd8, 0x38, 0x6b, 0x47, 0x85, 0x45, 0xa4, 0x2c, 0xca, 0x7a, 0x5a, 0x5a, 0xd4, 0x7f,
+	0x35, 0xa1, 0x12, 0xc4, 0x83, 0x38, 0x14, 0x5c, 0x52, 0x58, 0x91, 0x63, 0x4b, 0xe6, 0x98, 0x15,
+	0x39, 0x66, 0xe3, 0x1c, 0x5b, 0x32, 0xc7, 0x4c, 0xe5, 0xb8, 0x00, 0xda, 0x2d, 0xd7, 0xf2, 0x2c,
+	0x99, 0x53, 0xa6, 0x72, 0xba, 0x05, 0x55, 0x56, 0xe4, 0xb0, 0xe4, 0x59, 0x32, 0x87, 0x4c, 0xe7,
+	0x70, 0x0c, 0xb5, 0x5b, 0xae, 0xed, 0x59, 0x32, 0x65, 0x4c, 0xa7, 0x0c, 0x21, 0x5e, 0xa4, 0xd7,
+	0x92, 0x19, 0x62, 0xc7, 0x53, 0x2a, 0x9d, 0x90, 0x8a, 0x67, 0xc9, 0x84, 0x30, 0x9d, 0x10, 0xdc,
+	0x84, 0xaa, 0x7f, 0xd5, 0xb3, 0x64, 0xfd, 0x99, 0xaa, 0x3f, 0x6a, 0x74, 0x7d, 0x1d, 0xcf, 0x92,
+	0xf5, 0x65, 0xba, 0xbe, 0xca, 0x4e, 0x55, 0x0f, 0x3c, 0x4b, 0x56, 0x8f, 0x4d, 0xaa, 0xc7, 0x74,
+	0xf5, 0x6a, 0x9e, 0x25, 0xab, 0xc7, 0x54, 0xf5, 0xfe, 0x34, 0xa1, 0xfc, 0x36, 0x89, 0xfa, 0xb1,
+	0x20, 0x3b, 0x60, 0x9f, 0xd0, 0x94, 0x32, 0xac, 0xdc, 0xaa, 0xbf, 0xd5, 0x9c, 0xea, 0x58, 0x4d,
+	0xc5, 0x69, 0x3e, 0x91, 0x84, 0x40, 0xf1, 0x88, 0x2f, 0x4d, 0x95, 0x44, 0x9e, 0xe0, 0x95, 0x92,
+	0x32, 0xc3, 0xbf, 0xe4, 0x3e, 0x94, 0x39, 0xb6, 0x17, 0x7c, 0x9f, 0x6a, 0xfe, 0xc6, 0x8c, 0x44,
+	0x75, 0x9e, 0x40, 0x53, 0x48, 0x53, 0x9d, 0x0f, 0xd2, 0xe5, 0xb6, 0x2f, 0xa1, 0xcb, 0x43, 0xd3,
+	0xfc, 0x0a, 0x53, 0x45, 0x77, 0x37, 0xd1, 0x7d, 0x73, 0x86, 0xae, 0x03, 0x11, 0x14, 0x24, 0xf2,
+	0x00, 0x1c, 0xd6, 0x29, 0x14, 0xd7, 0x71, 0x81, 0xc5, 0x8a, 0x2a, 0xd3, 0xbf, 0xea, 0x77, 0xc1,
+	0x56, 0x0f, 0x52, 0x01, 0x2b, 0x38, 0xd8, 0x5f, 0x5b, 0x22, 0x0e, 0xd8, 0x9f, 0x05, 0x07, 0x07,
+	0x47, 0x6b, 0x06, 0xa9, 0x42, 0x69, 0xef, 0xc5, 0x9b, 0x83, 0x35, 0xb3, 0xfe, 0x8b, 0x09, 0xa5,
+	0x97, 0xe1, 0x80, 0x93, 0x4f, 0xa1, 0x96, 0x4d, 0xf5, 0x36, 0x03, 0x17, 0xf1, 0x66, 0x16, 0x91,
+	0xbc, 0xe6, 0xcb, 0xa2, 0xdb, 0x1d, 0xe4, 0x82, 0x8d, 0x02, 0x27, 0x1b, 0x77, 0xbf, 0x43, 0x58,
+	0xc9, 0x30, 0xbe, 0xc5, 0x49, 0x98, 0xe8, 0x51, 0x5f, 0xe0, 0x21, 0x73, 0xad, 0x8e, 0x42, 0xb9,
+	0xd4, 0xb2, 0xc9, 0xcc, 0xf6, 0x27, 0xb0, 0x3a, 0xbb, 0x08, 0x59, 0x03, 0xeb, 0xdb, 0x78, 0x84,
+	0xe5, 0xb6, 0x02, 0xf9, 0x93, 0x6c, 0x82, 0x7d, 0x16, 0xa6, 0xc3, 0x18, 0x5f, 0x53, 0x27, 0x50,
+	0x83, 0x87, 0xe6, 0x47, 0xc6, 0xf6, 0x31, 0xac, 0xcd, 0xdb, 0x4f, 0xeb, 0xab, 0x4a, 0xff, 0xdf,
+	0x69, 0xfd, 0x25, 0xd5, 0x9a, 0x98, 0xd6, 0xff, 0x32, 0x60, 0xf9, 0x25, 0xef, 0xbf, 0x4d, 0xc4,
+	0xe9, 0xab, 0x3c, 0xa6, 0x3d, 0x72, 0x03, 0x6c, 0x91, 0x88, 0x34, 0x46, 0x4f, 0xe7, 0xe9, 0x52,
+	0xa0, 0x86, 0xc4, 0x85, 0x32, 0x0f, 0xd3, 0x90, 0x8d, 0xd0, 0xd8, 0x7a, 0xba, 0x14, 0xe8, 0x31,
+	0xd9, 0x86, 0xca, 0x13, 0x3a, 0x94, 0xdb, 0xc1, 0x1e, 0x22, 0x35, 0xc5, 0x04, 0xb9, 0x03, 0xcb,
+	0xa7, 0x34, 0x8b, 0x3b, 0x61, 0x14, 0xb1, 0x98, 0x73, 0x6c, 0x27, 0x92, 0x50, 0x93, 0xb3, 0x8f,
+	0xd5, 0x24, 0xf9, 0x1c, 0xd6, 0x33, 0xde, 0xef, 0xbc, 0x4b, 0xc4, 0x69, 0x87, 0xc5, 0xdf, 0x0d,
+	0x13, 0x16, 0x47, 0xd8, 0x62, 0x6a, 0xfe, 0xad, 0xd9, 0x23, 0x56, 0x1b, 0x0d, 0x34, 0xe7, 0xe9,
+	0x52, 0x70, 0x2d, 0x9b, 0x9d, 0xda, 0xab, 0x80, 0x3d, 0xcc, 0x13, 0x9a, 0xd7, 0xff, 0x0d, 0xa5,
+	0x20, 0x0e, 0xd3, 0xc9, 0x79, 0x1a, 0xaa, 0x39, 0xe1, 0xe0, 0x5e, 0xb5, 0x1a, 0xad, 0x9d, 0x9f,
+	0x9f, 0x9f, 0x9b, 0xf5, 0x9f, 0x0c, 0xb9, 0x7d, 0x79, 0x2c, 0xef, 0xc9, 0x2d, 0x70, 0x92, 0x2c,
+	0xec, 0x27, 0xb9, 0x7c, 0x4c, 0xc5, 0x9f, 0x4c, 0x4c, 0x34, 0xfe, 0x11, 0xac, 0xb2, 0x38, 0x4c,
+	0x3b, 0xf1, 0x7b, 0x11, 0xe7, 0x3c, 0xa1, 0x39, 0x59, 0x9f, 0xcb, 0x6c, 0x98, 0xba, 0xdf, 0x2f,
+	0x88, 0xbf, 0x5e, 0x28, 0x58, 0x91, 0xf2, 0x83, 0x42, 0x5d, 0xff, 0xc3, 0x06, 0x78, 0x9e, 0xd3,
+	0x77, 0xf9, 0xeb, 0xd1, 0x20, 0xe6, 0xe4, 0x5f, 0x60, 0x86, 0x39, 0xde, 0x39, 0x52, 0xaf, 0xbe,
+	0x16, 0x9a, 0xc5, 0xd7, 0x42, 0xf3, 0x71, 0x3e, 0x0a, 0xcc, 0x30, 0x27, 0xf7, 0xc1, 0x8a, 0x86,
+	0xaa, 0x53, 0xd4, 0xfc, 0xad, 0x0b, 0xb4, 0x7d, 0xfd, 0xcd, 0x12, 0x48, 0x16, 0xf9, 0x0f, 0x98,
+	0x5c, 0xe0, 0x15, 0x58, 0xf3, 0x6f, 0x5e, 0xe0, 0x1e, 0xe3, 0xf7, 0x4b, 0x60, 0x72, 0x41, 0xee,
+	0x81, 0x29, 0xb8, 0xce, 0xce, 0xf6, 0x05, 0xe2, 0xeb, 0xe2, 0x53, 0x26, 0x30, 0x05, 0x97, 0xdc,
+	0xf4, 0x0c, 0xaf, 0xbf, 0x45, 0xdc, 0x17, 0x09, 0x17, 0x5f, 0xca, 0xc3, 0x0e, 0xcc, 0xf4, 0x8c,
+	0x34, 0xc0, 0x3a, 0x0b, 0x53, 0xbc, 0x0e, 0x6b, 0xfe, 0x8d, 0x0b, 0x64, 0x45, 0x94, 0x14, 0xd2,
+	0x04, 0x2b, 0xea, 0xa6, 0x18, 0x25, 0x59, 0xff, 0x0b, 0xcf, 0x85, 0x8d, 0x56, 0xf3, 0xa3, 0x6e,
+	0x4a, 0xfe, 0x07, 0x56, 0x2f, 0x15, 0x98, 0xac, 0x9a, 0xff, 0x8f, 0x0b, 0x7c, 0x6c, 0xd9, 0x9a,
+	0xde, 0x4b, 0x85, 0xa4, 0x27, 0x78, 0x43, 0x2c, 0xa6, 0xe3, 0xeb, 0xa9, 0xe9, 0x49, 0xbb, 0x25,
+	0x77, 0x33, 0x6c, 0xb7, 0xf0, 0x66, 0x5b, 0xb4, 0x9b, 0x37, 0xd3, 0xfc, 0x61, 0xbb, 0x85, 0xf6,
+	0xbb, 0x3e, 0x7e, 0x04, 0x5d, 0x62, 0xbf, 0xeb, 0x17, 0xf6, 0xbb, 0x3e, 0xda, 0xef, 0xfa, 0xf8,
+	0x55, 0x74, 0x99, 0xfd, 0x98, 0x3f, 0x44, 0x7e, 0x09, 0xaf, 0x51, 0xe7, 0x92, 0x43, 0x97, 0xfd,
+	0x41, 0xd1, 0x91, 0x27, 0xfd, 0x65, 0xcf, 0x83, 0x4b, 0xfc, 0xd5, 0xd5, 0xa4, 0xfd, 0xb9, 0x60,
+	0xe4, 0x01, 0xd8, 0xc5, 0x15, 0xb5, 0xf8, 0x01, 0xf0, 0xca, 0x52, 0x02, 0xc5, 0xac, 0xdf, 0x81,
+	0x6b, 0x73, 0xef, 0xa5, 0xec, 0x4a, 0xaa, 0xd3, 0x9a, 0x0d, 0x07, 0x7d, 0xeb, 0xbf, 0x9b, 0x70,
+	0x53, 0xb3, 0x9e, 0xe5, 0x51, 0xc2, 0xe2, 0x13, 0x31, 0x66, 0xff, 0x1f, 0x4a, 0x7c, 0xd8, 0xcd,
+	0x74, 0x92, 0xaf, 0x7c, 0xe3, 0x03, 0x64, 0x92, 0x57, 0xe0, 0x64, 0xe1, 0xa0, 0xd3, 0x4b, 0xe2,
+	0x34, 0xd2, 0xbd, 0xd8, 0x5f, 0x24, 0x9b, 0x5f, 0x4a, 0xf6, 0xe8, 0x43, 0x29, 0x52, 0xbd, 0xb9,
+	0x9a, 0xe9, 0x21, 0x79, 0x04, 0x35, 0x9e, 0x26, 0x27, 0xb1, 0xb6, 0xb4, 0xd0, 0xf2, 0xea, 0x9d,
+	0x00, 0x0a, 0x50, 0xbe, 0xfd, 0x15, 0xac, 0xcc, 0x38, 0x4f, 0xb7, 0x65, 0x47, 0xb5, 0x65, 0x7f,
+	0xb6, 0x2d, 0x5f, 0xed, 0x3d, 0xd5, 0x9f, 0xef, 0xc1, 0xe6, 0x1c, 0x8a, 0x15, 0x20, 0x04, 0x4a,
+	0xdd, 0x91, 0xe0, 0x78, 0xc6, 0xcb, 0x01, 0xfe, 0xae, 0xef, 0x03, 0x99, 0xe3, 0xbe, 0x7d, 0xfe,
+	0xba, 0x88, 0x80, 0x24, 0x7e, 0x48, 0x04, 0x1e, 0xde, 0x85, 0x52, 0x1e, 0x66, 0xf1, 0xa2, 0x96,
+	0xf6, 0x03, 0x3e, 0x0f, 0xc2, 0x0f, 0x9f, 0x40, 0x29, 0x7e, 0x2f, 0xb2, 0x45, 0xb4, 0x1f, 0x3f,
+	0xa4, 0x90, 0x52, 0xbc, 0xf7, 0xe8, 0xeb, 0x8f, 0xfb, 0x89, 0x38, 0x1d, 0x76, 0x9b, 0x27, 0x34,
+	0xdb, 0xe9, 0xd3, 0x34, 0xcc, 0xfb, 0x93, 0xff, 0x8b, 0x92, 0x5c, 0xc4, 0x2c, 0x0f, 0x53, 0xfc,
+	0x27, 0x0e, 0x67, 0xf9, 0xce, 0xf4, 0x3f, 0x77, 0x7f, 0x07, 0x00, 0x00, 0xff, 0xff, 0xba, 0x6b,
+	0x0b, 0xa0, 0xeb, 0x0d, 0x00, 0x00,
 }
diff --git a/vendor/github.com/golang/protobuf/jsonpb/jsonpb_test_proto/test_objects.proto b/vendor/github.com/golang/protobuf/internal/testprotos/jsonpb_proto/test2.proto
similarity index 61%
rename from vendor/github.com/golang/protobuf/jsonpb/jsonpb_test_proto/test_objects.proto
rename to vendor/github.com/golang/protobuf/internal/testprotos/jsonpb_proto/test2.proto
index 36eb6e8c6..d34dc33d6 100644
--- a/vendor/github.com/golang/protobuf/jsonpb/jsonpb_test_proto/test_objects.proto
+++ b/vendor/github.com/golang/protobuf/internal/testprotos/jsonpb_proto/test2.proto
@@ -1,57 +1,40 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2015 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// Copyright 2015 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.
 
 syntax = "proto2";
 
+option go_package = "github.com/golang/protobuf/internal/testprotos/jsonpb_proto";
+
 import "google/protobuf/any.proto";
 import "google/protobuf/duration.proto";
 import "google/protobuf/struct.proto";
 import "google/protobuf/timestamp.proto";
 import "google/protobuf/wrappers.proto";
 
-package jsonpb;
+package jsonpb_test;
 
 // Test message for holding primitive types.
 message Simple {
   optional bool o_bool = 1;
   optional int32 o_int32 = 2;
-  optional int64 o_int64 = 3;
-  optional uint32 o_uint32 = 4;
-  optional uint64 o_uint64 = 5;
-  optional sint32 o_sint32 = 6;
-  optional sint64 o_sint64 = 7;
-  optional float o_float = 8;
-  optional double o_double = 9;
-  optional string o_string = 10;
-  optional bytes o_bytes = 11;
+  optional int32 o_int32_str = 3;
+  optional int64 o_int64 = 4;
+  optional int64 o_int64_str = 5;
+  optional uint32 o_uint32 = 6;
+  optional uint32 o_uint32_str = 7;
+  optional uint64 o_uint64 = 8;
+  optional uint64 o_uint64_str = 9;
+  optional sint32 o_sint32 = 10;
+  optional sint32 o_sint32_str = 11;
+  optional sint64 o_sint64 = 12;
+  optional sint64 o_sint64_str = 13;
+  optional float o_float = 14;
+  optional float o_float_str = 15;
+  optional double o_double = 16;
+  optional double o_double_str = 17;
+  optional string o_string = 18;
+  optional bytes o_bytes = 19;
 }
 
 // Test message for holding special non-finites primitives.
diff --git a/vendor/github.com/golang/protobuf/jsonpb/jsonpb_test_proto/more_test_objects.pb.go b/vendor/github.com/golang/protobuf/internal/testprotos/jsonpb_proto/test3.pb.go
similarity index 50%
rename from vendor/github.com/golang/protobuf/jsonpb/jsonpb_test_proto/more_test_objects.pb.go
rename to vendor/github.com/golang/protobuf/internal/testprotos/jsonpb_proto/test3.pb.go
index 1bcce029c..cb9a81411 100644
--- a/vendor/github.com/golang/protobuf/jsonpb/jsonpb_test_proto/more_test_objects.pb.go
+++ b/vendor/github.com/golang/protobuf/internal/testprotos/jsonpb_proto/test3.pb.go
@@ -1,11 +1,13 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
-// source: more_test_objects.proto
+// source: jsonpb_proto/test3.proto
 
-package jsonpb
+package jsonpb_proto
 
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
+import (
+	fmt "fmt"
+	proto "github.com/golang/protobuf/proto"
+	math "math"
+)
 
 // Reference imports to suppress errors if they are not otherwise used.
 var _ = proto.Marshal
@@ -16,7 +18,7 @@ var _ = math.Inf
 // is compatible with the proto package it is being compiled against.
 // A compilation error at this line likely means your copy of the
 // proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
 
 type Numeral int32
 
@@ -31,6 +33,7 @@ var Numeral_name = map[int32]string{
 	1: "ARABIC",
 	2: "ROMAN",
 }
+
 var Numeral_value = map[string]int32{
 	"UNKNOWN": 0,
 	"ARABIC":  1,
@@ -40,12 +43,13 @@ var Numeral_value = map[string]int32{
 func (x Numeral) String() string {
 	return proto.EnumName(Numeral_name, int32(x))
 }
+
 func (Numeral) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_more_test_objects_bef0d79b901f4c4a, []int{0}
+	return fileDescriptor_813baf511b225405, []int{0}
 }
 
 type Simple3 struct {
-	Dub                  float64  `protobuf:"fixed64,1,opt,name=dub" json:"dub,omitempty"`
+	Dub                  float64  `protobuf:"fixed64,1,opt,name=dub,proto3" json:"dub,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -55,16 +59,17 @@ func (m *Simple3) Reset()         { *m = Simple3{} }
 func (m *Simple3) String() string { return proto.CompactTextString(m) }
 func (*Simple3) ProtoMessage()    {}
 func (*Simple3) Descriptor() ([]byte, []int) {
-	return fileDescriptor_more_test_objects_bef0d79b901f4c4a, []int{0}
+	return fileDescriptor_813baf511b225405, []int{0}
 }
+
 func (m *Simple3) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Simple3.Unmarshal(m, b)
 }
 func (m *Simple3) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_Simple3.Marshal(b, m, deterministic)
 }
-func (dst *Simple3) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Simple3.Merge(dst, src)
+func (m *Simple3) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Simple3.Merge(m, src)
 }
 func (m *Simple3) XXX_Size() int {
 	return xxx_messageInfo_Simple3.Size(m)
@@ -83,7 +88,7 @@ func (m *Simple3) GetDub() float64 {
 }
 
 type SimpleSlice3 struct {
-	Slices               []string `protobuf:"bytes,1,rep,name=slices" json:"slices,omitempty"`
+	Slices               []string `protobuf:"bytes,1,rep,name=slices,proto3" json:"slices,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -93,16 +98,17 @@ func (m *SimpleSlice3) Reset()         { *m = SimpleSlice3{} }
 func (m *SimpleSlice3) String() string { return proto.CompactTextString(m) }
 func (*SimpleSlice3) ProtoMessage()    {}
 func (*SimpleSlice3) Descriptor() ([]byte, []int) {
-	return fileDescriptor_more_test_objects_bef0d79b901f4c4a, []int{1}
+	return fileDescriptor_813baf511b225405, []int{1}
 }
+
 func (m *SimpleSlice3) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SimpleSlice3.Unmarshal(m, b)
 }
 func (m *SimpleSlice3) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_SimpleSlice3.Marshal(b, m, deterministic)
 }
-func (dst *SimpleSlice3) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_SimpleSlice3.Merge(dst, src)
+func (m *SimpleSlice3) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SimpleSlice3.Merge(m, src)
 }
 func (m *SimpleSlice3) XXX_Size() int {
 	return xxx_messageInfo_SimpleSlice3.Size(m)
@@ -121,7 +127,7 @@ func (m *SimpleSlice3) GetSlices() []string {
 }
 
 type SimpleMap3 struct {
-	Stringy              map[string]string `protobuf:"bytes,1,rep,name=stringy" json:"stringy,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+	Stringy              map[string]string `protobuf:"bytes,1,rep,name=stringy,proto3" json:"stringy,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
 	XXX_unrecognized     []byte            `json:"-"`
 	XXX_sizecache        int32             `json:"-"`
@@ -131,16 +137,17 @@ func (m *SimpleMap3) Reset()         { *m = SimpleMap3{} }
 func (m *SimpleMap3) String() string { return proto.CompactTextString(m) }
 func (*SimpleMap3) ProtoMessage()    {}
 func (*SimpleMap3) Descriptor() ([]byte, []int) {
-	return fileDescriptor_more_test_objects_bef0d79b901f4c4a, []int{2}
+	return fileDescriptor_813baf511b225405, []int{2}
 }
+
 func (m *SimpleMap3) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SimpleMap3.Unmarshal(m, b)
 }
 func (m *SimpleMap3) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_SimpleMap3.Marshal(b, m, deterministic)
 }
-func (dst *SimpleMap3) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_SimpleMap3.Merge(dst, src)
+func (m *SimpleMap3) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SimpleMap3.Merge(m, src)
 }
 func (m *SimpleMap3) XXX_Size() int {
 	return xxx_messageInfo_SimpleMap3.Size(m)
@@ -159,7 +166,7 @@ func (m *SimpleMap3) GetStringy() map[string]string {
 }
 
 type SimpleNull3 struct {
-	Simple               *Simple3 `protobuf:"bytes,1,opt,name=simple" json:"simple,omitempty"`
+	Simple               *Simple3 `protobuf:"bytes,1,opt,name=simple,proto3" json:"simple,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -169,16 +176,17 @@ func (m *SimpleNull3) Reset()         { *m = SimpleNull3{} }
 func (m *SimpleNull3) String() string { return proto.CompactTextString(m) }
 func (*SimpleNull3) ProtoMessage()    {}
 func (*SimpleNull3) Descriptor() ([]byte, []int) {
-	return fileDescriptor_more_test_objects_bef0d79b901f4c4a, []int{3}
+	return fileDescriptor_813baf511b225405, []int{3}
 }
+
 func (m *SimpleNull3) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SimpleNull3.Unmarshal(m, b)
 }
 func (m *SimpleNull3) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_SimpleNull3.Marshal(b, m, deterministic)
 }
-func (dst *SimpleNull3) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_SimpleNull3.Merge(dst, src)
+func (m *SimpleNull3) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SimpleNull3.Merge(m, src)
 }
 func (m *SimpleNull3) XXX_Size() int {
 	return xxx_messageInfo_SimpleNull3.Size(m)
@@ -197,16 +205,16 @@ func (m *SimpleNull3) GetSimple() *Simple3 {
 }
 
 type Mappy struct {
-	Nummy                map[int64]int32    `protobuf:"bytes,1,rep,name=nummy" json:"nummy,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
-	Strry                map[string]string  `protobuf:"bytes,2,rep,name=strry" json:"strry,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
-	Objjy                map[int32]*Simple3 `protobuf:"bytes,3,rep,name=objjy" json:"objjy,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
-	Buggy                map[int64]string   `protobuf:"bytes,4,rep,name=buggy" json:"buggy,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
-	Booly                map[bool]bool      `protobuf:"bytes,5,rep,name=booly" json:"booly,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
-	Enumy                map[string]Numeral `protobuf:"bytes,6,rep,name=enumy" json:"enumy,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=jsonpb.Numeral"`
-	S32Booly             map[int32]bool     `protobuf:"bytes,7,rep,name=s32booly" json:"s32booly,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
-	S64Booly             map[int64]bool     `protobuf:"bytes,8,rep,name=s64booly" json:"s64booly,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
-	U32Booly             map[uint32]bool    `protobuf:"bytes,9,rep,name=u32booly" json:"u32booly,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
-	U64Booly             map[uint64]bool    `protobuf:"bytes,10,rep,name=u64booly" json:"u64booly,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
+	Nummy                map[int64]int32    `protobuf:"bytes,1,rep,name=nummy,proto3" json:"nummy,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+	Strry                map[string]string  `protobuf:"bytes,2,rep,name=strry,proto3" json:"strry,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	Objjy                map[int32]*Simple3 `protobuf:"bytes,3,rep,name=objjy,proto3" json:"objjy,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	Buggy                map[int64]string   `protobuf:"bytes,4,rep,name=buggy,proto3" json:"buggy,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	Booly                map[bool]bool      `protobuf:"bytes,5,rep,name=booly,proto3" json:"booly,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+	Enumy                map[string]Numeral `protobuf:"bytes,6,rep,name=enumy,proto3" json:"enumy,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3,enum=jsonpb_test.Numeral"`
+	S32Booly             map[int32]bool     `protobuf:"bytes,7,rep,name=s32booly,proto3" json:"s32booly,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+	S64Booly             map[int64]bool     `protobuf:"bytes,8,rep,name=s64booly,proto3" json:"s64booly,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+	U32Booly             map[uint32]bool    `protobuf:"bytes,9,rep,name=u32booly,proto3" json:"u32booly,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+	U64Booly             map[uint64]bool    `protobuf:"bytes,10,rep,name=u64booly,proto3" json:"u64booly,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
 	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
 	XXX_unrecognized     []byte             `json:"-"`
 	XXX_sizecache        int32              `json:"-"`
@@ -216,16 +224,17 @@ func (m *Mappy) Reset()         { *m = Mappy{} }
 func (m *Mappy) String() string { return proto.CompactTextString(m) }
 func (*Mappy) ProtoMessage()    {}
 func (*Mappy) Descriptor() ([]byte, []int) {
-	return fileDescriptor_more_test_objects_bef0d79b901f4c4a, []int{4}
+	return fileDescriptor_813baf511b225405, []int{4}
 }
+
 func (m *Mappy) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Mappy.Unmarshal(m, b)
 }
 func (m *Mappy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_Mappy.Marshal(b, m, deterministic)
 }
-func (dst *Mappy) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Mappy.Merge(dst, src)
+func (m *Mappy) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Mappy.Merge(m, src)
 }
 func (m *Mappy) XXX_Size() int {
 	return xxx_messageInfo_Mappy.Size(m)
@@ -307,62 +316,63 @@ func (m *Mappy) GetU64Booly() map[uint64]bool {
 }
 
 func init() {
-	proto.RegisterType((*Simple3)(nil), "jsonpb.Simple3")
-	proto.RegisterType((*SimpleSlice3)(nil), "jsonpb.SimpleSlice3")
-	proto.RegisterType((*SimpleMap3)(nil), "jsonpb.SimpleMap3")
-	proto.RegisterMapType((map[string]string)(nil), "jsonpb.SimpleMap3.StringyEntry")
-	proto.RegisterType((*SimpleNull3)(nil), "jsonpb.SimpleNull3")
-	proto.RegisterType((*Mappy)(nil), "jsonpb.Mappy")
-	proto.RegisterMapType((map[bool]bool)(nil), "jsonpb.Mappy.BoolyEntry")
-	proto.RegisterMapType((map[int64]string)(nil), "jsonpb.Mappy.BuggyEntry")
-	proto.RegisterMapType((map[string]Numeral)(nil), "jsonpb.Mappy.EnumyEntry")
-	proto.RegisterMapType((map[int64]int32)(nil), "jsonpb.Mappy.NummyEntry")
-	proto.RegisterMapType((map[int32]*Simple3)(nil), "jsonpb.Mappy.ObjjyEntry")
-	proto.RegisterMapType((map[int32]bool)(nil), "jsonpb.Mappy.S32boolyEntry")
-	proto.RegisterMapType((map[int64]bool)(nil), "jsonpb.Mappy.S64boolyEntry")
-	proto.RegisterMapType((map[string]string)(nil), "jsonpb.Mappy.StrryEntry")
-	proto.RegisterMapType((map[uint32]bool)(nil), "jsonpb.Mappy.U32boolyEntry")
-	proto.RegisterMapType((map[uint64]bool)(nil), "jsonpb.Mappy.U64boolyEntry")
-	proto.RegisterEnum("jsonpb.Numeral", Numeral_name, Numeral_value)
-}
-
-func init() {
-	proto.RegisterFile("more_test_objects.proto", fileDescriptor_more_test_objects_bef0d79b901f4c4a)
-}
-
-var fileDescriptor_more_test_objects_bef0d79b901f4c4a = []byte{
-	// 526 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x94, 0xdd, 0x6b, 0xdb, 0x3c,
-	0x14, 0x87, 0x5f, 0x27, 0xf5, 0xd7, 0x49, 0xfb, 0x2e, 0x88, 0xb1, 0x99, 0xf4, 0x62, 0xc5, 0xb0,
-	0xad, 0x0c, 0xe6, 0x8b, 0x78, 0x74, 0x5d, 0x77, 0x95, 0x8e, 0x5e, 0x94, 0x11, 0x07, 0x1c, 0xc2,
-	0x2e, 0x4b, 0xdc, 0x99, 0x90, 0xcc, 0x5f, 0xd8, 0xd6, 0xc0, 0xd7, 0xfb, 0xbb, 0x07, 0xe3, 0x48,
-	0x72, 0x2d, 0x07, 0x85, 0x6c, 0x77, 0x52, 0x7e, 0xcf, 0xe3, 0x73, 0x24, 0x1d, 0x02, 0x2f, 0xd3,
-	0xbc, 0x8c, 0x1f, 0xea, 0xb8, 0xaa, 0x1f, 0xf2, 0x68, 0x17, 0x3f, 0xd6, 0x95, 0x57, 0x94, 0x79,
-	0x9d, 0x13, 0x63, 0x57, 0xe5, 0x59, 0x11, 0xb9, 0xe7, 0x60, 0x2e, 0xb7, 0x69, 0x91, 0xc4, 0x3e,
-	0x19, 0xc3, 0xf0, 0x3b, 0x8d, 0x1c, 0xed, 0x42, 0xbb, 0xd4, 0x42, 0x5c, 0xba, 0x6f, 0xe0, 0x94,
-	0x87, 0xcb, 0x64, 0xfb, 0x18, 0xfb, 0xe4, 0x05, 0x18, 0x15, 0xae, 0x2a, 0x47, 0xbb, 0x18, 0x5e,
-	0xda, 0xa1, 0xd8, 0xb9, 0xbf, 0x34, 0x00, 0x0e, 0xce, 0xd7, 0x85, 0x4f, 0x3e, 0x81, 0x59, 0xd5,
-	0xe5, 0x36, 0xdb, 0x34, 0x8c, 0x1b, 0x4d, 0x5f, 0x79, 0xbc, 0x9a, 0xd7, 0x41, 0xde, 0x92, 0x13,
-	0x77, 0x59, 0x5d, 0x36, 0x61, 0xcb, 0x4f, 0x6e, 0xe0, 0x54, 0x0e, 0xb0, 0xa7, 0x1f, 0x71, 0xc3,
-	0x7a, 0xb2, 0x43, 0x5c, 0x92, 0xe7, 0xa0, 0xff, 0x5c, 0x27, 0x34, 0x76, 0x06, 0xec, 0x37, 0xbe,
-	0xb9, 0x19, 0x5c, 0x6b, 0xee, 0x15, 0x8c, 0xf8, 0xf7, 0x03, 0x9a, 0x24, 0x3e, 0x79, 0x0b, 0x46,
-	0xc5, 0xb6, 0xcc, 0x1e, 0x4d, 0x9f, 0xf5, 0x9b, 0xf0, 0x43, 0x11, 0xbb, 0xbf, 0x2d, 0xd0, 0xe7,
-	0xeb, 0xa2, 0x68, 0x88, 0x07, 0x7a, 0x46, 0xd3, 0xb4, 0x6d, 0xdb, 0x69, 0x0d, 0x96, 0x7a, 0x01,
-	0x46, 0xbc, 0x5f, 0x8e, 0x21, 0x5f, 0xd5, 0x65, 0xd9, 0x38, 0x03, 0x15, 0xbf, 0xc4, 0x48, 0xf0,
-	0x0c, 0x43, 0x3e, 0x8f, 0x76, 0xbb, 0xc6, 0x19, 0xaa, 0xf8, 0x05, 0x46, 0x82, 0x67, 0x18, 0xf2,
-	0x11, 0xdd, 0x6c, 0x1a, 0xe7, 0x44, 0xc5, 0xdf, 0x62, 0x24, 0x78, 0x86, 0x31, 0x3e, 0xcf, 0x93,
-	0xc6, 0xd1, 0x95, 0x3c, 0x46, 0x2d, 0x8f, 0x6b, 0xe4, 0xe3, 0x8c, 0xa6, 0x8d, 0x63, 0xa8, 0xf8,
-	0x3b, 0x8c, 0x04, 0xcf, 0x30, 0xf2, 0x11, 0xac, 0xca, 0x9f, 0xf2, 0x12, 0x26, 0x53, 0xce, 0xf7,
-	0x8e, 0x2c, 0x52, 0x6e, 0x3d, 0xc1, 0x4c, 0xbc, 0xfa, 0xc0, 0x45, 0x4b, 0x29, 0x8a, 0xb4, 0x15,
-	0xc5, 0x16, 0x45, 0xda, 0x56, 0xb4, 0x55, 0xe2, 0xaa, 0x5f, 0x91, 0x4a, 0x15, 0x69, 0x5b, 0x11,
-	0x94, 0x62, 0xbf, 0x62, 0x0b, 0x4f, 0xae, 0x01, 0xba, 0x87, 0x96, 0xe7, 0x6f, 0xa8, 0x98, 0x3f,
-	0x5d, 0x9a, 0x3f, 0x34, 0xbb, 0x27, 0xff, 0x97, 0xc9, 0x9d, 0xdc, 0x03, 0x74, 0x8f, 0x2f, 0x9b,
-	0x3a, 0x37, 0x5f, 0xcb, 0xa6, 0x62, 0x92, 0xfb, 0x4d, 0x74, 0x73, 0x71, 0xac, 0x7d, 0x7b, 0xdf,
-	0x7c, 0xba, 0x10, 0xd9, 0xb4, 0x14, 0xa6, 0xb5, 0xd7, 0x7e, 0x37, 0x2b, 0x8a, 0x83, 0xf7, 0xda,
-	0xff, 0xbf, 0x6b, 0x3f, 0xa0, 0x69, 0x5c, 0xae, 0x13, 0xf9, 0x53, 0x9f, 0xe1, 0xac, 0x37, 0x43,
-	0x8a, 0xcb, 0x38, 0xdc, 0x07, 0xca, 0xf2, 0xab, 0x1e, 0x3b, 0xfe, 0xbe, 0xbc, 0x3a, 0x54, 0xf9,
-	0xec, 0x6f, 0xe4, 0x43, 0x95, 0x4f, 0x8e, 0xc8, 0xef, 0xde, 0x83, 0x29, 0x6e, 0x82, 0x8c, 0xc0,
-	0x5c, 0x05, 0x5f, 0x83, 0xc5, 0xb7, 0x60, 0xfc, 0x1f, 0x01, 0x30, 0x66, 0xe1, 0xec, 0xf6, 0xfe,
-	0xcb, 0x58, 0x23, 0x36, 0xe8, 0xe1, 0x62, 0x3e, 0x0b, 0xc6, 0x83, 0xc8, 0x60, 0x7f, 0xe0, 0xfe,
-	0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xdc, 0x84, 0x34, 0xaf, 0xdb, 0x05, 0x00, 0x00,
+	proto.RegisterEnum("jsonpb_test.Numeral", Numeral_name, Numeral_value)
+	proto.RegisterType((*Simple3)(nil), "jsonpb_test.Simple3")
+	proto.RegisterType((*SimpleSlice3)(nil), "jsonpb_test.SimpleSlice3")
+	proto.RegisterType((*SimpleMap3)(nil), "jsonpb_test.SimpleMap3")
+	proto.RegisterMapType((map[string]string)(nil), "jsonpb_test.SimpleMap3.StringyEntry")
+	proto.RegisterType((*SimpleNull3)(nil), "jsonpb_test.SimpleNull3")
+	proto.RegisterType((*Mappy)(nil), "jsonpb_test.Mappy")
+	proto.RegisterMapType((map[bool]bool)(nil), "jsonpb_test.Mappy.BoolyEntry")
+	proto.RegisterMapType((map[int64]string)(nil), "jsonpb_test.Mappy.BuggyEntry")
+	proto.RegisterMapType((map[string]Numeral)(nil), "jsonpb_test.Mappy.EnumyEntry")
+	proto.RegisterMapType((map[int64]int32)(nil), "jsonpb_test.Mappy.NummyEntry")
+	proto.RegisterMapType((map[int32]*Simple3)(nil), "jsonpb_test.Mappy.ObjjyEntry")
+	proto.RegisterMapType((map[int32]bool)(nil), "jsonpb_test.Mappy.S32boolyEntry")
+	proto.RegisterMapType((map[int64]bool)(nil), "jsonpb_test.Mappy.S64boolyEntry")
+	proto.RegisterMapType((map[string]string)(nil), "jsonpb_test.Mappy.StrryEntry")
+	proto.RegisterMapType((map[uint32]bool)(nil), "jsonpb_test.Mappy.U32boolyEntry")
+	proto.RegisterMapType((map[uint64]bool)(nil), "jsonpb_test.Mappy.U64boolyEntry")
+}
+
+func init() { proto.RegisterFile("jsonpb_proto/test3.proto", fileDescriptor_813baf511b225405) }
+
+var fileDescriptor_813baf511b225405 = []byte{
+	// 563 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x95, 0xdd, 0x8a, 0xd3, 0x40,
+	0x14, 0xc7, 0x4d, 0xbb, 0x69, 0x9b, 0xd3, 0x5d, 0x29, 0xc3, 0x22, 0xa1, 0x22, 0x94, 0x22, 0xb2,
+	0x2c, 0x9a, 0x40, 0x23, 0xb2, 0x6c, 0x55, 0x68, 0x65, 0x2f, 0x44, 0x9a, 0x42, 0x4a, 0x11, 0xbc,
+	0x91, 0x64, 0x8d, 0x31, 0x35, 0x5f, 0x24, 0x19, 0x21, 0x6f, 0xe0, 0x2b, 0xf9, 0x76, 0x32, 0x1f,
+	0xd9, 0x4c, 0x4a, 0x86, 0xea, 0xd5, 0x9e, 0x99, 0xf3, 0xff, 0xe5, 0x7c, 0xec, 0xbf, 0x0c, 0xe8,
+	0x87, 0x22, 0x4d, 0x32, 0xef, 0x6b, 0x96, 0xa7, 0x65, 0x6a, 0x96, 0x7e, 0x51, 0x5a, 0x06, 0x8d,
+	0xd1, 0x98, 0x67, 0xc8, 0xdd, 0xfc, 0x29, 0x0c, 0x77, 0x61, 0x9c, 0x45, 0xbe, 0x85, 0x26, 0xd0,
+	0xff, 0x86, 0x3d, 0x5d, 0x99, 0x29, 0x57, 0x8a, 0x43, 0xc2, 0xf9, 0x0b, 0x38, 0x67, 0xc9, 0x5d,
+	0x14, 0xde, 0xfb, 0x16, 0x7a, 0x02, 0x83, 0x82, 0x44, 0x85, 0xae, 0xcc, 0xfa, 0x57, 0x9a, 0xc3,
+	0x4f, 0xf3, 0xdf, 0x0a, 0x00, 0x13, 0x6e, 0xdc, 0xcc, 0x42, 0xef, 0x61, 0x58, 0x94, 0x79, 0x98,
+	0x04, 0x15, 0xd5, 0x8d, 0x17, 0xcf, 0x0d, 0xa1, 0xa4, 0xd1, 0x28, 0x8d, 0x1d, 0x93, 0xdd, 0x25,
+	0x65, 0x5e, 0x39, 0x35, 0x34, 0xbd, 0x85, 0x73, 0x31, 0x41, 0x1a, 0xfb, 0xe9, 0x57, 0xb4, 0x31,
+	0xcd, 0x21, 0x21, 0xba, 0x04, 0xf5, 0x97, 0x1b, 0x61, 0x5f, 0xef, 0xd1, 0x3b, 0x76, 0xb8, 0xed,
+	0xdd, 0x28, 0xf3, 0x25, 0x8c, 0xd9, 0xf7, 0x6d, 0x1c, 0x45, 0x16, 0x7a, 0x09, 0x83, 0x82, 0x1e,
+	0x29, 0x3d, 0x5e, 0x5c, 0x76, 0x74, 0x62, 0x39, 0x5c, 0x33, 0xff, 0xa3, 0x81, 0xba, 0x71, 0xb3,
+	0xac, 0x42, 0x16, 0xa8, 0x09, 0x8e, 0xe3, 0x7a, 0x80, 0x67, 0x2d, 0x8c, 0x4a, 0x0c, 0x9b, 0xe4,
+	0x59, 0xe7, 0x4c, 0x4b, 0xa0, 0xa2, 0xcc, 0xf3, 0x4a, 0xef, 0x49, 0xa1, 0x1d, 0xc9, 0x73, 0x88,
+	0x6a, 0x09, 0x94, 0x7a, 0x87, 0x43, 0xa5, 0xf7, 0xa5, 0xd0, 0x96, 0xe4, 0x39, 0x44, 0xb5, 0x04,
+	0xf2, 0x70, 0x10, 0x54, 0xfa, 0x99, 0x14, 0x5a, 0x93, 0x3c, 0x87, 0xa8, 0x96, 0x42, 0x69, 0x1a,
+	0x55, 0xba, 0x2a, 0x87, 0x48, 0xbe, 0x86, 0x48, 0x4c, 0x20, 0x3f, 0xc1, 0x71, 0xa5, 0x0f, 0xa4,
+	0xd0, 0x1d, 0xc9, 0x73, 0x88, 0x6a, 0xd1, 0x5b, 0x18, 0x15, 0xd6, 0x82, 0x15, 0x1b, 0x52, 0x6e,
+	0xd6, 0xb5, 0x0b, 0x2e, 0x61, 0xe8, 0x03, 0x41, 0xe9, 0x37, 0xaf, 0x19, 0x3d, 0x92, 0xd3, 0x5c,
+	0x52, 0xd3, 0xfc, 0x48, 0x68, 0x5c, 0xd7, 0xd6, 0xa4, 0xf4, 0xbe, 0x5d, 0x1b, 0x0b, 0xb5, 0x71,
+	0x5d, 0x1b, 0xe4, 0x74, 0xbb, 0x76, 0x4d, 0x4c, 0x6f, 0x00, 0x1a, 0x57, 0x88, 0xb6, 0xed, 0x77,
+	0xd8, 0x56, 0x15, 0x6c, 0x4b, 0xc8, 0xc6, 0x1a, 0xff, 0x63, 0xf8, 0xa9, 0x0d, 0xd0, 0xf8, 0x43,
+	0x24, 0x55, 0x46, 0x5e, 0x8b, 0xa4, 0xec, 0x07, 0xd0, 0xee, 0xa4, 0xb1, 0xce, 0xa9, 0x19, 0xb4,
+	0x63, 0xf2, 0x61, 0x2b, 0x22, 0x39, 0xea, 0x20, 0x47, 0x47, 0x33, 0x34, 0x26, 0xea, 0x98, 0xbe,
+	0x35, 0xc3, 0xe3, 0xa3, 0x19, 0x6c, 0x1c, 0xfb, 0xb9, 0x1b, 0x89, 0xdf, 0x5b, 0xc2, 0x45, 0xcb,
+	0x5c, 0x1d, 0x6b, 0x91, 0x37, 0x43, 0x60, 0xf1, 0xff, 0x7b, 0x6a, 0x07, 0xc7, 0xf0, 0x5e, 0x56,
+	0xf9, 0xe2, 0x5f, 0x60, 0x59, 0xe5, 0xb3, 0x13, 0xf0, 0xf5, 0x2b, 0x18, 0xf2, 0x4d, 0xa0, 0x31,
+	0x0c, 0xf7, 0xf6, 0x27, 0x7b, 0xfb, 0xd9, 0x9e, 0x3c, 0x42, 0x00, 0x83, 0x95, 0xb3, 0x5a, 0x7f,
+	0xfc, 0x30, 0x51, 0x90, 0x06, 0xaa, 0xb3, 0xdd, 0xac, 0xec, 0x49, 0x6f, 0xfd, 0xee, 0xcb, 0x32,
+	0x08, 0xcb, 0x1f, 0xd8, 0x33, 0xee, 0xd3, 0xd8, 0x0c, 0xd2, 0xc8, 0x4d, 0x02, 0x93, 0xbe, 0x0f,
+	0x1e, 0xfe, 0x6e, 0x86, 0x49, 0xe9, 0xe7, 0x89, 0x1b, 0xd1, 0x77, 0x83, 0xde, 0x16, 0xa6, 0xf8,
+	0x9e, 0x78, 0x03, 0xfa, 0xc7, 0xfa, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x7c, 0xda, 0x44, 0x24, 0x66,
+	0x06, 0x00, 0x00,
 }
diff --git a/vendor/github.com/golang/protobuf/internal/testprotos/jsonpb_proto/test3.proto b/vendor/github.com/golang/protobuf/internal/testprotos/jsonpb_proto/test3.proto
new file mode 100644
index 000000000..dbeb2b589
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/internal/testprotos/jsonpb_proto/test3.proto
@@ -0,0 +1,44 @@
+// Copyright 2015 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.
+
+syntax = "proto3";
+
+option go_package = "github.com/golang/protobuf/internal/testprotos/jsonpb_proto";
+
+package jsonpb_test;
+
+message Simple3 {
+  double dub = 1;
+}
+
+message SimpleSlice3 {
+  repeated string slices = 1;
+}
+
+message SimpleMap3 {
+  map<string,string> stringy = 1;
+}
+
+message SimpleNull3 {
+  Simple3 simple = 1;
+}
+
+enum Numeral {
+  UNKNOWN = 0;
+  ARABIC = 1;
+  ROMAN = 2;
+}
+
+message Mappy {
+  map<int64, int32> nummy = 1;
+  map<string, string> strry = 2;
+  map<int32, Simple3> objjy = 3;
+  map<int64, string> buggy = 4;
+  map<bool, bool> booly = 5;
+  map<string, Numeral> enumy = 6;
+  map<int32, bool> s32booly = 7;
+  map<int64, bool> s64booly = 8;
+  map<uint32, bool> u32booly = 9;
+  map<uint64, bool> u64booly = 10;
+}
diff --git a/vendor/github.com/golang/protobuf/proto/test_proto/test.pb.go b/vendor/github.com/golang/protobuf/internal/testprotos/proto2_proto/test.pb.go
similarity index 59%
rename from vendor/github.com/golang/protobuf/proto/test_proto/test.pb.go
rename to vendor/github.com/golang/protobuf/internal/testprotos/proto2_proto/test.pb.go
index 049b5dd2c..cd202f971 100644
--- a/vendor/github.com/golang/protobuf/proto/test_proto/test.pb.go
+++ b/vendor/github.com/golang/protobuf/internal/testprotos/proto2_proto/test.pb.go
@@ -1,11 +1,13 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
-// source: test_proto/test.proto
+// source: proto2_proto/test.proto
 
-package test_proto // import "github.com/golang/protobuf/proto/test_proto"
+package proto2_proto
 
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
+import (
+	fmt "fmt"
+	proto "github.com/golang/protobuf/proto"
+	math "math"
+)
 
 // Reference imports to suppress errors if they are not otherwise used.
 var _ = proto.Marshal
@@ -16,7 +18,7 @@ var _ = math.Inf
 // is compatible with the proto package it is being compiled against.
 // A compilation error at this line likely means your copy of the
 // proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
 
 type FOO int32
 
@@ -27,6 +29,7 @@ const (
 var FOO_name = map[int32]string{
 	1: "FOO1",
 }
+
 var FOO_value = map[string]int32{
 	"FOO1": 1,
 }
@@ -36,9 +39,11 @@ func (x FOO) Enum() *FOO {
 	*p = x
 	return p
 }
+
 func (x FOO) String() string {
 	return proto.EnumName(FOO_name, int32(x))
 }
+
 func (x *FOO) UnmarshalJSON(data []byte) error {
 	value, err := proto.UnmarshalJSONEnum(FOO_value, data, "FOO")
 	if err != nil {
@@ -47,8 +52,9 @@ func (x *FOO) UnmarshalJSON(data []byte) error {
 	*x = FOO(value)
 	return nil
 }
+
 func (FOO) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{0}
+	return fileDescriptor_e5b3e7ca68f98362, []int{0}
 }
 
 // An enum, for completeness.
@@ -89,6 +95,7 @@ var GoTest_KIND_name = map[int32]string{
 	11: "TABLE",
 	12: "FUNCTION",
 }
+
 var GoTest_KIND_value = map[string]int32{
 	"VOID":        0,
 	"BOOL":        1,
@@ -110,9 +117,11 @@ func (x GoTest_KIND) Enum() *GoTest_KIND {
 	*p = x
 	return p
 }
+
 func (x GoTest_KIND) String() string {
 	return proto.EnumName(GoTest_KIND_name, int32(x))
 }
+
 func (x *GoTest_KIND) UnmarshalJSON(data []byte) error {
 	value, err := proto.UnmarshalJSONEnum(GoTest_KIND_value, data, "GoTest_KIND")
 	if err != nil {
@@ -121,8 +130,9 @@ func (x *GoTest_KIND) UnmarshalJSON(data []byte) error {
 	*x = GoTest_KIND(value)
 	return nil
 }
+
 func (GoTest_KIND) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{2, 0}
+	return fileDescriptor_e5b3e7ca68f98362, []int{2, 0}
 }
 
 type MyMessage_Color int32
@@ -138,6 +148,7 @@ var MyMessage_Color_name = map[int32]string{
 	1: "GREEN",
 	2: "BLUE",
 }
+
 var MyMessage_Color_value = map[string]int32{
 	"RED":   0,
 	"GREEN": 1,
@@ -149,9 +160,11 @@ func (x MyMessage_Color) Enum() *MyMessage_Color {
 	*p = x
 	return p
 }
+
 func (x MyMessage_Color) String() string {
 	return proto.EnumName(MyMessage_Color_name, int32(x))
 }
+
 func (x *MyMessage_Color) UnmarshalJSON(data []byte) error {
 	value, err := proto.UnmarshalJSONEnum(MyMessage_Color_value, data, "MyMessage_Color")
 	if err != nil {
@@ -160,8 +173,9 @@ func (x *MyMessage_Color) UnmarshalJSON(data []byte) error {
 	*x = MyMessage_Color(value)
 	return nil
 }
+
 func (MyMessage_Color) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{13, 0}
+	return fileDescriptor_e5b3e7ca68f98362, []int{13, 0}
 }
 
 type DefaultsMessage_DefaultsEnum int32
@@ -177,6 +191,7 @@ var DefaultsMessage_DefaultsEnum_name = map[int32]string{
 	1: "ONE",
 	2: "TWO",
 }
+
 var DefaultsMessage_DefaultsEnum_value = map[string]int32{
 	"ZERO": 0,
 	"ONE":  1,
@@ -188,9 +203,11 @@ func (x DefaultsMessage_DefaultsEnum) Enum() *DefaultsMessage_DefaultsEnum {
 	*p = x
 	return p
 }
+
 func (x DefaultsMessage_DefaultsEnum) String() string {
 	return proto.EnumName(DefaultsMessage_DefaultsEnum_name, int32(x))
 }
+
 func (x *DefaultsMessage_DefaultsEnum) UnmarshalJSON(data []byte) error {
 	value, err := proto.UnmarshalJSONEnum(DefaultsMessage_DefaultsEnum_value, data, "DefaultsMessage_DefaultsEnum")
 	if err != nil {
@@ -199,8 +216,9 @@ func (x *DefaultsMessage_DefaultsEnum) UnmarshalJSON(data []byte) error {
 	*x = DefaultsMessage_DefaultsEnum(value)
 	return nil
 }
+
 func (DefaultsMessage_DefaultsEnum) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{16, 0}
+	return fileDescriptor_e5b3e7ca68f98362, []int{16, 0}
 }
 
 type Defaults_Color int32
@@ -216,6 +234,7 @@ var Defaults_Color_name = map[int32]string{
 	1: "GREEN",
 	2: "BLUE",
 }
+
 var Defaults_Color_value = map[string]int32{
 	"RED":   0,
 	"GREEN": 1,
@@ -227,9 +246,11 @@ func (x Defaults_Color) Enum() *Defaults_Color {
 	*p = x
 	return p
 }
+
 func (x Defaults_Color) String() string {
 	return proto.EnumName(Defaults_Color_name, int32(x))
 }
+
 func (x *Defaults_Color) UnmarshalJSON(data []byte) error {
 	value, err := proto.UnmarshalJSONEnum(Defaults_Color_value, data, "Defaults_Color")
 	if err != nil {
@@ -238,8 +259,9 @@ func (x *Defaults_Color) UnmarshalJSON(data []byte) error {
 	*x = Defaults_Color(value)
 	return nil
 }
+
 func (Defaults_Color) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{21, 0}
+	return fileDescriptor_e5b3e7ca68f98362, []int{20, 0}
 }
 
 type RepeatedEnum_Color int32
@@ -251,6 +273,7 @@ const (
 var RepeatedEnum_Color_name = map[int32]string{
 	1: "RED",
 }
+
 var RepeatedEnum_Color_value = map[string]int32{
 	"RED": 1,
 }
@@ -260,9 +283,11 @@ func (x RepeatedEnum_Color) Enum() *RepeatedEnum_Color {
 	*p = x
 	return p
 }
+
 func (x RepeatedEnum_Color) String() string {
 	return proto.EnumName(RepeatedEnum_Color_name, int32(x))
 }
+
 func (x *RepeatedEnum_Color) UnmarshalJSON(data []byte) error {
 	value, err := proto.UnmarshalJSONEnum(RepeatedEnum_Color_value, data, "RepeatedEnum_Color")
 	if err != nil {
@@ -271,12 +296,13 @@ func (x *RepeatedEnum_Color) UnmarshalJSON(data []byte) error {
 	*x = RepeatedEnum_Color(value)
 	return nil
 }
+
 func (RepeatedEnum_Color) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{23, 0}
+	return fileDescriptor_e5b3e7ca68f98362, []int{22, 0}
 }
 
 type GoEnum struct {
-	Foo                  *FOO     `protobuf:"varint,1,req,name=foo,enum=test_proto.FOO" json:"foo,omitempty"`
+	Foo                  *FOO     `protobuf:"varint,1,req,name=foo,enum=proto2_test.FOO" json:"foo,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -286,16 +312,17 @@ func (m *GoEnum) Reset()         { *m = GoEnum{} }
 func (m *GoEnum) String() string { return proto.CompactTextString(m) }
 func (*GoEnum) ProtoMessage()    {}
 func (*GoEnum) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{0}
+	return fileDescriptor_e5b3e7ca68f98362, []int{0}
 }
+
 func (m *GoEnum) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GoEnum.Unmarshal(m, b)
 }
 func (m *GoEnum) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_GoEnum.Marshal(b, m, deterministic)
 }
-func (dst *GoEnum) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GoEnum.Merge(dst, src)
+func (m *GoEnum) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GoEnum.Merge(m, src)
 }
 func (m *GoEnum) XXX_Size() int {
 	return xxx_messageInfo_GoEnum.Size(m)
@@ -325,16 +352,17 @@ func (m *GoTestField) Reset()         { *m = GoTestField{} }
 func (m *GoTestField) String() string { return proto.CompactTextString(m) }
 func (*GoTestField) ProtoMessage()    {}
 func (*GoTestField) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{1}
+	return fileDescriptor_e5b3e7ca68f98362, []int{1}
 }
+
 func (m *GoTestField) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GoTestField.Unmarshal(m, b)
 }
 func (m *GoTestField) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_GoTestField.Marshal(b, m, deterministic)
 }
-func (dst *GoTestField) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GoTestField.Merge(dst, src)
+func (m *GoTestField) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GoTestField.Merge(m, src)
 }
 func (m *GoTestField) XXX_Size() int {
 	return xxx_messageInfo_GoTestField.Size(m)
@@ -361,7 +389,7 @@ func (m *GoTestField) GetType() string {
 
 type GoTest struct {
 	// Some typical parameters
-	Kind  *GoTest_KIND `protobuf:"varint,1,req,name=Kind,enum=test_proto.GoTest_KIND" json:"Kind,omitempty"`
+	Kind  *GoTest_KIND `protobuf:"varint,1,req,name=Kind,enum=proto2_test.GoTest_KIND" json:"Kind,omitempty"`
 	Table *string      `protobuf:"bytes,2,opt,name=Table" json:"Table,omitempty"`
 	Param *int32       `protobuf:"varint,3,opt,name=Param" json:"Param,omitempty"`
 	// Required, repeated and optional foreign fields.
@@ -458,16 +486,17 @@ func (m *GoTest) Reset()         { *m = GoTest{} }
 func (m *GoTest) String() string { return proto.CompactTextString(m) }
 func (*GoTest) ProtoMessage()    {}
 func (*GoTest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{2}
+	return fileDescriptor_e5b3e7ca68f98362, []int{2}
 }
+
 func (m *GoTest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GoTest.Unmarshal(m, b)
 }
 func (m *GoTest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_GoTest.Marshal(b, m, deterministic)
 }
-func (dst *GoTest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GoTest.Merge(dst, src)
+func (m *GoTest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GoTest.Merge(m, src)
 }
 func (m *GoTest) XXX_Size() int {
 	return xxx_messageInfo_GoTest.Size(m)
@@ -1082,16 +1111,17 @@ func (m *GoTest_RequiredGroup) Reset()         { *m = GoTest_RequiredGroup{} }
 func (m *GoTest_RequiredGroup) String() string { return proto.CompactTextString(m) }
 func (*GoTest_RequiredGroup) ProtoMessage()    {}
 func (*GoTest_RequiredGroup) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{2, 0}
+	return fileDescriptor_e5b3e7ca68f98362, []int{2, 0}
 }
+
 func (m *GoTest_RequiredGroup) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GoTest_RequiredGroup.Unmarshal(m, b)
 }
 func (m *GoTest_RequiredGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_GoTest_RequiredGroup.Marshal(b, m, deterministic)
 }
-func (dst *GoTest_RequiredGroup) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GoTest_RequiredGroup.Merge(dst, src)
+func (m *GoTest_RequiredGroup) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GoTest_RequiredGroup.Merge(m, src)
 }
 func (m *GoTest_RequiredGroup) XXX_Size() int {
 	return xxx_messageInfo_GoTest_RequiredGroup.Size(m)
@@ -1120,16 +1150,17 @@ func (m *GoTest_RepeatedGroup) Reset()         { *m = GoTest_RepeatedGroup{} }
 func (m *GoTest_RepeatedGroup) String() string { return proto.CompactTextString(m) }
 func (*GoTest_RepeatedGroup) ProtoMessage()    {}
 func (*GoTest_RepeatedGroup) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{2, 1}
+	return fileDescriptor_e5b3e7ca68f98362, []int{2, 1}
 }
+
 func (m *GoTest_RepeatedGroup) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GoTest_RepeatedGroup.Unmarshal(m, b)
 }
 func (m *GoTest_RepeatedGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_GoTest_RepeatedGroup.Marshal(b, m, deterministic)
 }
-func (dst *GoTest_RepeatedGroup) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GoTest_RepeatedGroup.Merge(dst, src)
+func (m *GoTest_RepeatedGroup) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GoTest_RepeatedGroup.Merge(m, src)
 }
 func (m *GoTest_RepeatedGroup) XXX_Size() int {
 	return xxx_messageInfo_GoTest_RepeatedGroup.Size(m)
@@ -1158,16 +1189,17 @@ func (m *GoTest_OptionalGroup) Reset()         { *m = GoTest_OptionalGroup{} }
 func (m *GoTest_OptionalGroup) String() string { return proto.CompactTextString(m) }
 func (*GoTest_OptionalGroup) ProtoMessage()    {}
 func (*GoTest_OptionalGroup) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{2, 2}
+	return fileDescriptor_e5b3e7ca68f98362, []int{2, 2}
 }
+
 func (m *GoTest_OptionalGroup) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GoTest_OptionalGroup.Unmarshal(m, b)
 }
 func (m *GoTest_OptionalGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_GoTest_OptionalGroup.Marshal(b, m, deterministic)
 }
-func (dst *GoTest_OptionalGroup) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GoTest_OptionalGroup.Merge(dst, src)
+func (m *GoTest_OptionalGroup) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GoTest_OptionalGroup.Merge(m, src)
 }
 func (m *GoTest_OptionalGroup) XXX_Size() int {
 	return xxx_messageInfo_GoTest_OptionalGroup.Size(m)
@@ -1197,16 +1229,17 @@ func (m *GoTestRequiredGroupField) Reset()         { *m = GoTestRequiredGroupFie
 func (m *GoTestRequiredGroupField) String() string { return proto.CompactTextString(m) }
 func (*GoTestRequiredGroupField) ProtoMessage()    {}
 func (*GoTestRequiredGroupField) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{3}
+	return fileDescriptor_e5b3e7ca68f98362, []int{3}
 }
+
 func (m *GoTestRequiredGroupField) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GoTestRequiredGroupField.Unmarshal(m, b)
 }
 func (m *GoTestRequiredGroupField) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_GoTestRequiredGroupField.Marshal(b, m, deterministic)
 }
-func (dst *GoTestRequiredGroupField) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GoTestRequiredGroupField.Merge(dst, src)
+func (m *GoTestRequiredGroupField) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GoTestRequiredGroupField.Merge(m, src)
 }
 func (m *GoTestRequiredGroupField) XXX_Size() int {
 	return xxx_messageInfo_GoTestRequiredGroupField.Size(m)
@@ -1235,16 +1268,17 @@ func (m *GoTestRequiredGroupField_Group) Reset()         { *m = GoTestRequiredGr
 func (m *GoTestRequiredGroupField_Group) String() string { return proto.CompactTextString(m) }
 func (*GoTestRequiredGroupField_Group) ProtoMessage()    {}
 func (*GoTestRequiredGroupField_Group) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{3, 0}
+	return fileDescriptor_e5b3e7ca68f98362, []int{3, 0}
 }
+
 func (m *GoTestRequiredGroupField_Group) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GoTestRequiredGroupField_Group.Unmarshal(m, b)
 }
 func (m *GoTestRequiredGroupField_Group) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_GoTestRequiredGroupField_Group.Marshal(b, m, deterministic)
 }
-func (dst *GoTestRequiredGroupField_Group) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GoTestRequiredGroupField_Group.Merge(dst, src)
+func (m *GoTestRequiredGroupField_Group) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GoTestRequiredGroupField_Group.Merge(m, src)
 }
 func (m *GoTestRequiredGroupField_Group) XXX_Size() int {
 	return xxx_messageInfo_GoTestRequiredGroupField_Group.Size(m)
@@ -1280,16 +1314,17 @@ func (m *GoSkipTest) Reset()         { *m = GoSkipTest{} }
 func (m *GoSkipTest) String() string { return proto.CompactTextString(m) }
 func (*GoSkipTest) ProtoMessage()    {}
 func (*GoSkipTest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{4}
+	return fileDescriptor_e5b3e7ca68f98362, []int{4}
 }
+
 func (m *GoSkipTest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GoSkipTest.Unmarshal(m, b)
 }
 func (m *GoSkipTest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_GoSkipTest.Marshal(b, m, deterministic)
 }
-func (dst *GoSkipTest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GoSkipTest.Merge(dst, src)
+func (m *GoSkipTest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GoSkipTest.Merge(m, src)
 }
 func (m *GoSkipTest) XXX_Size() int {
 	return xxx_messageInfo_GoSkipTest.Size(m)
@@ -1347,16 +1382,17 @@ func (m *GoSkipTest_SkipGroup) Reset()         { *m = GoSkipTest_SkipGroup{} }
 func (m *GoSkipTest_SkipGroup) String() string { return proto.CompactTextString(m) }
 func (*GoSkipTest_SkipGroup) ProtoMessage()    {}
 func (*GoSkipTest_SkipGroup) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{4, 0}
+	return fileDescriptor_e5b3e7ca68f98362, []int{4, 0}
 }
+
 func (m *GoSkipTest_SkipGroup) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GoSkipTest_SkipGroup.Unmarshal(m, b)
 }
 func (m *GoSkipTest_SkipGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_GoSkipTest_SkipGroup.Marshal(b, m, deterministic)
 }
-func (dst *GoSkipTest_SkipGroup) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GoSkipTest_SkipGroup.Merge(dst, src)
+func (m *GoSkipTest_SkipGroup) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GoSkipTest_SkipGroup.Merge(m, src)
 }
 func (m *GoSkipTest_SkipGroup) XXX_Size() int {
 	return xxx_messageInfo_GoSkipTest_SkipGroup.Size(m)
@@ -1394,16 +1430,17 @@ func (m *NonPackedTest) Reset()         { *m = NonPackedTest{} }
 func (m *NonPackedTest) String() string { return proto.CompactTextString(m) }
 func (*NonPackedTest) ProtoMessage()    {}
 func (*NonPackedTest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{5}
+	return fileDescriptor_e5b3e7ca68f98362, []int{5}
 }
+
 func (m *NonPackedTest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_NonPackedTest.Unmarshal(m, b)
 }
 func (m *NonPackedTest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_NonPackedTest.Marshal(b, m, deterministic)
 }
-func (dst *NonPackedTest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_NonPackedTest.Merge(dst, src)
+func (m *NonPackedTest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_NonPackedTest.Merge(m, src)
 }
 func (m *NonPackedTest) XXX_Size() int {
 	return xxx_messageInfo_NonPackedTest.Size(m)
@@ -1432,16 +1469,17 @@ func (m *PackedTest) Reset()         { *m = PackedTest{} }
 func (m *PackedTest) String() string { return proto.CompactTextString(m) }
 func (*PackedTest) ProtoMessage()    {}
 func (*PackedTest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{6}
+	return fileDescriptor_e5b3e7ca68f98362, []int{6}
 }
+
 func (m *PackedTest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PackedTest.Unmarshal(m, b)
 }
 func (m *PackedTest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_PackedTest.Marshal(b, m, deterministic)
 }
-func (dst *PackedTest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_PackedTest.Merge(dst, src)
+func (m *PackedTest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_PackedTest.Merge(m, src)
 }
 func (m *PackedTest) XXX_Size() int {
 	return xxx_messageInfo_PackedTest.Size(m)
@@ -1471,16 +1509,17 @@ func (m *MaxTag) Reset()         { *m = MaxTag{} }
 func (m *MaxTag) String() string { return proto.CompactTextString(m) }
 func (*MaxTag) ProtoMessage()    {}
 func (*MaxTag) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{7}
+	return fileDescriptor_e5b3e7ca68f98362, []int{7}
 }
+
 func (m *MaxTag) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_MaxTag.Unmarshal(m, b)
 }
 func (m *MaxTag) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_MaxTag.Marshal(b, m, deterministic)
 }
-func (dst *MaxTag) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MaxTag.Merge(dst, src)
+func (m *MaxTag) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MaxTag.Merge(m, src)
 }
 func (m *MaxTag) XXX_Size() int {
 	return xxx_messageInfo_MaxTag.Size(m)
@@ -1510,16 +1549,17 @@ func (m *OldMessage) Reset()         { *m = OldMessage{} }
 func (m *OldMessage) String() string { return proto.CompactTextString(m) }
 func (*OldMessage) ProtoMessage()    {}
 func (*OldMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{8}
+	return fileDescriptor_e5b3e7ca68f98362, []int{8}
 }
+
 func (m *OldMessage) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_OldMessage.Unmarshal(m, b)
 }
 func (m *OldMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_OldMessage.Marshal(b, m, deterministic)
 }
-func (dst *OldMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_OldMessage.Merge(dst, src)
+func (m *OldMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_OldMessage.Merge(m, src)
 }
 func (m *OldMessage) XXX_Size() int {
 	return xxx_messageInfo_OldMessage.Size(m)
@@ -1555,16 +1595,17 @@ func (m *OldMessage_Nested) Reset()         { *m = OldMessage_Nested{} }
 func (m *OldMessage_Nested) String() string { return proto.CompactTextString(m) }
 func (*OldMessage_Nested) ProtoMessage()    {}
 func (*OldMessage_Nested) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{8, 0}
+	return fileDescriptor_e5b3e7ca68f98362, []int{8, 0}
 }
+
 func (m *OldMessage_Nested) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_OldMessage_Nested.Unmarshal(m, b)
 }
 func (m *OldMessage_Nested) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_OldMessage_Nested.Marshal(b, m, deterministic)
 }
-func (dst *OldMessage_Nested) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_OldMessage_Nested.Merge(dst, src)
+func (m *OldMessage_Nested) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_OldMessage_Nested.Merge(m, src)
 }
 func (m *OldMessage_Nested) XXX_Size() int {
 	return xxx_messageInfo_OldMessage_Nested.Size(m)
@@ -1597,16 +1638,17 @@ func (m *NewMessage) Reset()         { *m = NewMessage{} }
 func (m *NewMessage) String() string { return proto.CompactTextString(m) }
 func (*NewMessage) ProtoMessage()    {}
 func (*NewMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{9}
+	return fileDescriptor_e5b3e7ca68f98362, []int{9}
 }
+
 func (m *NewMessage) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_NewMessage.Unmarshal(m, b)
 }
 func (m *NewMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_NewMessage.Marshal(b, m, deterministic)
 }
-func (dst *NewMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_NewMessage.Merge(dst, src)
+func (m *NewMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_NewMessage.Merge(m, src)
 }
 func (m *NewMessage) XXX_Size() int {
 	return xxx_messageInfo_NewMessage.Size(m)
@@ -1643,16 +1685,17 @@ func (m *NewMessage_Nested) Reset()         { *m = NewMessage_Nested{} }
 func (m *NewMessage_Nested) String() string { return proto.CompactTextString(m) }
 func (*NewMessage_Nested) ProtoMessage()    {}
 func (*NewMessage_Nested) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{9, 0}
+	return fileDescriptor_e5b3e7ca68f98362, []int{9, 0}
 }
+
 func (m *NewMessage_Nested) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_NewMessage_Nested.Unmarshal(m, b)
 }
 func (m *NewMessage_Nested) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_NewMessage_Nested.Marshal(b, m, deterministic)
 }
-func (dst *NewMessage_Nested) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_NewMessage_Nested.Merge(dst, src)
+func (m *NewMessage_Nested) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_NewMessage_Nested.Merge(m, src)
 }
 func (m *NewMessage_Nested) XXX_Size() int {
 	return xxx_messageInfo_NewMessage_Nested.Size(m)
@@ -1690,16 +1733,17 @@ func (m *InnerMessage) Reset()         { *m = InnerMessage{} }
 func (m *InnerMessage) String() string { return proto.CompactTextString(m) }
 func (*InnerMessage) ProtoMessage()    {}
 func (*InnerMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{10}
+	return fileDescriptor_e5b3e7ca68f98362, []int{10}
 }
+
 func (m *InnerMessage) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_InnerMessage.Unmarshal(m, b)
 }
 func (m *InnerMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_InnerMessage.Marshal(b, m, deterministic)
 }
-func (dst *InnerMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_InnerMessage.Merge(dst, src)
+func (m *InnerMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_InnerMessage.Merge(m, src)
 }
 func (m *InnerMessage) XXX_Size() int {
 	return xxx_messageInfo_InnerMessage.Size(m)
@@ -1748,7 +1792,7 @@ func (m *OtherMessage) Reset()         { *m = OtherMessage{} }
 func (m *OtherMessage) String() string { return proto.CompactTextString(m) }
 func (*OtherMessage) ProtoMessage()    {}
 func (*OtherMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{11}
+	return fileDescriptor_e5b3e7ca68f98362, []int{11}
 }
 
 var extRange_OtherMessage = []proto.ExtensionRange{
@@ -1758,14 +1802,15 @@ var extRange_OtherMessage = []proto.ExtensionRange{
 func (*OtherMessage) ExtensionRangeArray() []proto.ExtensionRange {
 	return extRange_OtherMessage
 }
+
 func (m *OtherMessage) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_OtherMessage.Unmarshal(m, b)
 }
 func (m *OtherMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_OtherMessage.Marshal(b, m, deterministic)
 }
-func (dst *OtherMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_OtherMessage.Merge(dst, src)
+func (m *OtherMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_OtherMessage.Merge(m, src)
 }
 func (m *OtherMessage) XXX_Size() int {
 	return xxx_messageInfo_OtherMessage.Size(m)
@@ -1815,16 +1860,17 @@ func (m *RequiredInnerMessage) Reset()         { *m = RequiredInnerMessage{} }
 func (m *RequiredInnerMessage) String() string { return proto.CompactTextString(m) }
 func (*RequiredInnerMessage) ProtoMessage()    {}
 func (*RequiredInnerMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{12}
+	return fileDescriptor_e5b3e7ca68f98362, []int{12}
 }
+
 func (m *RequiredInnerMessage) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RequiredInnerMessage.Unmarshal(m, b)
 }
 func (m *RequiredInnerMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_RequiredInnerMessage.Marshal(b, m, deterministic)
 }
-func (dst *RequiredInnerMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_RequiredInnerMessage.Merge(dst, src)
+func (m *RequiredInnerMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_RequiredInnerMessage.Merge(m, src)
 }
 func (m *RequiredInnerMessage) XXX_Size() int {
 	return xxx_messageInfo_RequiredInnerMessage.Size(m)
@@ -1851,7 +1897,7 @@ type MyMessage struct {
 	Others         []*OtherMessage       `protobuf:"bytes,6,rep,name=others" json:"others,omitempty"`
 	WeMustGoDeeper *RequiredInnerMessage `protobuf:"bytes,13,opt,name=we_must_go_deeper,json=weMustGoDeeper" json:"we_must_go_deeper,omitempty"`
 	RepInner       []*InnerMessage       `protobuf:"bytes,12,rep,name=rep_inner,json=repInner" json:"rep_inner,omitempty"`
-	Bikeshed       *MyMessage_Color      `protobuf:"varint,7,opt,name=bikeshed,enum=test_proto.MyMessage_Color" json:"bikeshed,omitempty"`
+	Bikeshed       *MyMessage_Color      `protobuf:"varint,7,opt,name=bikeshed,enum=proto2_test.MyMessage_Color" json:"bikeshed,omitempty"`
 	Somegroup      *MyMessage_SomeGroup  `protobuf:"group,8,opt,name=SomeGroup,json=somegroup" json:"somegroup,omitempty"`
 	// This field becomes [][]byte in the generated code.
 	RepBytes                     [][]byte `protobuf:"bytes,10,rep,name=rep_bytes,json=repBytes" json:"rep_bytes,omitempty"`
@@ -1866,7 +1912,7 @@ func (m *MyMessage) Reset()         { *m = MyMessage{} }
 func (m *MyMessage) String() string { return proto.CompactTextString(m) }
 func (*MyMessage) ProtoMessage()    {}
 func (*MyMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{13}
+	return fileDescriptor_e5b3e7ca68f98362, []int{13}
 }
 
 var extRange_MyMessage = []proto.ExtensionRange{
@@ -1876,14 +1922,15 @@ var extRange_MyMessage = []proto.ExtensionRange{
 func (*MyMessage) ExtensionRangeArray() []proto.ExtensionRange {
 	return extRange_MyMessage
 }
+
 func (m *MyMessage) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_MyMessage.Unmarshal(m, b)
 }
 func (m *MyMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_MyMessage.Marshal(b, m, deterministic)
 }
-func (dst *MyMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MyMessage.Merge(dst, src)
+func (m *MyMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MyMessage.Merge(m, src)
 }
 func (m *MyMessage) XXX_Size() int {
 	return xxx_messageInfo_MyMessage.Size(m)
@@ -1989,16 +2036,17 @@ func (m *MyMessage_SomeGroup) Reset()         { *m = MyMessage_SomeGroup{} }
 func (m *MyMessage_SomeGroup) String() string { return proto.CompactTextString(m) }
 func (*MyMessage_SomeGroup) ProtoMessage()    {}
 func (*MyMessage_SomeGroup) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{13, 0}
+	return fileDescriptor_e5b3e7ca68f98362, []int{13, 0}
 }
+
 func (m *MyMessage_SomeGroup) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_MyMessage_SomeGroup.Unmarshal(m, b)
 }
 func (m *MyMessage_SomeGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_MyMessage_SomeGroup.Marshal(b, m, deterministic)
 }
-func (dst *MyMessage_SomeGroup) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MyMessage_SomeGroup.Merge(dst, src)
+func (m *MyMessage_SomeGroup) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MyMessage_SomeGroup.Merge(m, src)
 }
 func (m *MyMessage_SomeGroup) XXX_Size() int {
 	return xxx_messageInfo_MyMessage_SomeGroup.Size(m)
@@ -2028,16 +2076,17 @@ func (m *Ext) Reset()         { *m = Ext{} }
 func (m *Ext) String() string { return proto.CompactTextString(m) }
 func (*Ext) ProtoMessage()    {}
 func (*Ext) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{14}
+	return fileDescriptor_e5b3e7ca68f98362, []int{14}
 }
+
 func (m *Ext) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Ext.Unmarshal(m, b)
 }
 func (m *Ext) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_Ext.Marshal(b, m, deterministic)
 }
-func (dst *Ext) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Ext.Merge(dst, src)
+func (m *Ext) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Ext.Merge(m, src)
 }
 func (m *Ext) XXX_Size() int {
 	return xxx_messageInfo_Ext.Size(m)
@@ -2066,27 +2115,27 @@ var E_Ext_More = &proto.ExtensionDesc{
 	ExtendedType:  (*MyMessage)(nil),
 	ExtensionType: (*Ext)(nil),
 	Field:         103,
-	Name:          "test_proto.Ext.more",
+	Name:          "proto2_test.Ext.more",
 	Tag:           "bytes,103,opt,name=more",
-	Filename:      "test_proto/test.proto",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_Ext_Text = &proto.ExtensionDesc{
 	ExtendedType:  (*MyMessage)(nil),
 	ExtensionType: (*string)(nil),
 	Field:         104,
-	Name:          "test_proto.Ext.text",
+	Name:          "proto2_test.Ext.text",
 	Tag:           "bytes,104,opt,name=text",
-	Filename:      "test_proto/test.proto",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_Ext_Number = &proto.ExtensionDesc{
 	ExtendedType:  (*MyMessage)(nil),
 	ExtensionType: (*int32)(nil),
 	Field:         105,
-	Name:          "test_proto.Ext.number",
+	Name:          "proto2_test.Ext.number",
 	Tag:           "varint,105,opt,name=number",
-	Filename:      "test_proto/test.proto",
+	Filename:      "proto2_proto/test.proto",
 }
 
 type ComplexExtension struct {
@@ -2102,16 +2151,17 @@ func (m *ComplexExtension) Reset()         { *m = ComplexExtension{} }
 func (m *ComplexExtension) String() string { return proto.CompactTextString(m) }
 func (*ComplexExtension) ProtoMessage()    {}
 func (*ComplexExtension) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{15}
+	return fileDescriptor_e5b3e7ca68f98362, []int{15}
 }
+
 func (m *ComplexExtension) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ComplexExtension.Unmarshal(m, b)
 }
 func (m *ComplexExtension) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_ComplexExtension.Marshal(b, m, deterministic)
 }
-func (dst *ComplexExtension) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ComplexExtension.Merge(dst, src)
+func (m *ComplexExtension) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ComplexExtension.Merge(m, src)
 }
 func (m *ComplexExtension) XXX_Size() int {
 	return xxx_messageInfo_ComplexExtension.Size(m)
@@ -2154,7 +2204,7 @@ func (m *DefaultsMessage) Reset()         { *m = DefaultsMessage{} }
 func (m *DefaultsMessage) String() string { return proto.CompactTextString(m) }
 func (*DefaultsMessage) ProtoMessage()    {}
 func (*DefaultsMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{16}
+	return fileDescriptor_e5b3e7ca68f98362, []int{16}
 }
 
 var extRange_DefaultsMessage = []proto.ExtensionRange{
@@ -2164,14 +2214,15 @@ var extRange_DefaultsMessage = []proto.ExtensionRange{
 func (*DefaultsMessage) ExtensionRangeArray() []proto.ExtensionRange {
 	return extRange_DefaultsMessage
 }
+
 func (m *DefaultsMessage) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DefaultsMessage.Unmarshal(m, b)
 }
 func (m *DefaultsMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_DefaultsMessage.Marshal(b, m, deterministic)
 }
-func (dst *DefaultsMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_DefaultsMessage.Merge(dst, src)
+func (m *DefaultsMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DefaultsMessage.Merge(m, src)
 }
 func (m *DefaultsMessage) XXX_Size() int {
 	return xxx_messageInfo_DefaultsMessage.Size(m)
@@ -2182,52 +2233,6 @@ func (m *DefaultsMessage) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_DefaultsMessage proto.InternalMessageInfo
 
-type MyMessageSet struct {
-	XXX_NoUnkeyedLiteral         struct{} `json:"-"`
-	proto.XXX_InternalExtensions `protobuf_messageset:"1" json:"-"`
-	XXX_unrecognized             []byte `json:"-"`
-	XXX_sizecache                int32  `json:"-"`
-}
-
-func (m *MyMessageSet) Reset()         { *m = MyMessageSet{} }
-func (m *MyMessageSet) String() string { return proto.CompactTextString(m) }
-func (*MyMessageSet) ProtoMessage()    {}
-func (*MyMessageSet) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{17}
-}
-
-func (m *MyMessageSet) MarshalJSON() ([]byte, error) {
-	return proto.MarshalMessageSetJSON(&m.XXX_InternalExtensions)
-}
-func (m *MyMessageSet) UnmarshalJSON(buf []byte) error {
-	return proto.UnmarshalMessageSetJSON(buf, &m.XXX_InternalExtensions)
-}
-
-var extRange_MyMessageSet = []proto.ExtensionRange{
-	{Start: 100, End: 2147483646},
-}
-
-func (*MyMessageSet) ExtensionRangeArray() []proto.ExtensionRange {
-	return extRange_MyMessageSet
-}
-func (m *MyMessageSet) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_MyMessageSet.Unmarshal(m, b)
-}
-func (m *MyMessageSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_MyMessageSet.Marshal(b, m, deterministic)
-}
-func (dst *MyMessageSet) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MyMessageSet.Merge(dst, src)
-}
-func (m *MyMessageSet) XXX_Size() int {
-	return xxx_messageInfo_MyMessageSet.Size(m)
-}
-func (m *MyMessageSet) XXX_DiscardUnknown() {
-	xxx_messageInfo_MyMessageSet.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_MyMessageSet proto.InternalMessageInfo
-
 type Empty struct {
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
@@ -2238,16 +2243,17 @@ func (m *Empty) Reset()         { *m = Empty{} }
 func (m *Empty) String() string { return proto.CompactTextString(m) }
 func (*Empty) ProtoMessage()    {}
 func (*Empty) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{18}
+	return fileDescriptor_e5b3e7ca68f98362, []int{17}
 }
+
 func (m *Empty) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Empty.Unmarshal(m, b)
 }
 func (m *Empty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_Empty.Marshal(b, m, deterministic)
 }
-func (dst *Empty) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Empty.Merge(dst, src)
+func (m *Empty) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Empty.Merge(m, src)
 }
 func (m *Empty) XXX_Size() int {
 	return xxx_messageInfo_Empty.Size(m)
@@ -2269,16 +2275,17 @@ func (m *MessageList) Reset()         { *m = MessageList{} }
 func (m *MessageList) String() string { return proto.CompactTextString(m) }
 func (*MessageList) ProtoMessage()    {}
 func (*MessageList) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{19}
+	return fileDescriptor_e5b3e7ca68f98362, []int{18}
 }
+
 func (m *MessageList) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_MessageList.Unmarshal(m, b)
 }
 func (m *MessageList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_MessageList.Marshal(b, m, deterministic)
 }
-func (dst *MessageList) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MessageList.Merge(dst, src)
+func (m *MessageList) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MessageList.Merge(m, src)
 }
 func (m *MessageList) XXX_Size() int {
 	return xxx_messageInfo_MessageList.Size(m)
@@ -2308,16 +2315,17 @@ func (m *MessageList_Message) Reset()         { *m = MessageList_Message{} }
 func (m *MessageList_Message) String() string { return proto.CompactTextString(m) }
 func (*MessageList_Message) ProtoMessage()    {}
 func (*MessageList_Message) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{19, 0}
+	return fileDescriptor_e5b3e7ca68f98362, []int{18, 0}
 }
+
 func (m *MessageList_Message) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_MessageList_Message.Unmarshal(m, b)
 }
 func (m *MessageList_Message) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_MessageList_Message.Marshal(b, m, deterministic)
 }
-func (dst *MessageList_Message) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MessageList_Message.Merge(dst, src)
+func (m *MessageList_Message) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MessageList_Message.Merge(m, src)
 }
 func (m *MessageList_Message) XXX_Size() int {
 	return xxx_messageInfo_MessageList_Message.Size(m)
@@ -2354,16 +2362,17 @@ func (m *Strings) Reset()         { *m = Strings{} }
 func (m *Strings) String() string { return proto.CompactTextString(m) }
 func (*Strings) ProtoMessage()    {}
 func (*Strings) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{20}
+	return fileDescriptor_e5b3e7ca68f98362, []int{19}
 }
+
 func (m *Strings) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Strings.Unmarshal(m, b)
 }
 func (m *Strings) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_Strings.Marshal(b, m, deterministic)
 }
-func (dst *Strings) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Strings.Merge(dst, src)
+func (m *Strings) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Strings.Merge(m, src)
 }
 func (m *Strings) XXX_Size() int {
 	return xxx_messageInfo_Strings.Size(m)
@@ -2404,7 +2413,7 @@ type Defaults struct {
 	F_Bytes   []byte          `protobuf:"bytes,11,opt,name=F_Bytes,json=FBytes,def=Bignose" json:"F_Bytes,omitempty"`
 	F_Sint32  *int32          `protobuf:"zigzag32,12,opt,name=F_Sint32,json=FSint32,def=-32" json:"F_Sint32,omitempty"`
 	F_Sint64  *int64          `protobuf:"zigzag64,13,opt,name=F_Sint64,json=FSint64,def=-64" json:"F_Sint64,omitempty"`
-	F_Enum    *Defaults_Color `protobuf:"varint,14,opt,name=F_Enum,json=FEnum,enum=test_proto.Defaults_Color,def=1" json:"F_Enum,omitempty"`
+	F_Enum    *Defaults_Color `protobuf:"varint,14,opt,name=F_Enum,json=FEnum,enum=proto2_test.Defaults_Color,def=1" json:"F_Enum,omitempty"`
 	// More fields with crazy defaults.
 	F_Pinf *float32 `protobuf:"fixed32,15,opt,name=F_Pinf,json=FPinf,def=inf" json:"F_Pinf,omitempty"`
 	F_Ninf *float32 `protobuf:"fixed32,16,opt,name=F_Ninf,json=FNinf,def=-inf" json:"F_Ninf,omitempty"`
@@ -2422,16 +2431,17 @@ func (m *Defaults) Reset()         { *m = Defaults{} }
 func (m *Defaults) String() string { return proto.CompactTextString(m) }
 func (*Defaults) ProtoMessage()    {}
 func (*Defaults) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{21}
+	return fileDescriptor_e5b3e7ca68f98362, []int{20}
 }
+
 func (m *Defaults) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Defaults.Unmarshal(m, b)
 }
 func (m *Defaults) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_Defaults.Marshal(b, m, deterministic)
 }
-func (dst *Defaults) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Defaults.Merge(dst, src)
+func (m *Defaults) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Defaults.Merge(m, src)
 }
 func (m *Defaults) XXX_Size() int {
 	return xxx_messageInfo_Defaults.Size(m)
@@ -2607,16 +2617,17 @@ func (m *SubDefaults) Reset()         { *m = SubDefaults{} }
 func (m *SubDefaults) String() string { return proto.CompactTextString(m) }
 func (*SubDefaults) ProtoMessage()    {}
 func (*SubDefaults) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{22}
+	return fileDescriptor_e5b3e7ca68f98362, []int{21}
 }
+
 func (m *SubDefaults) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SubDefaults.Unmarshal(m, b)
 }
 func (m *SubDefaults) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_SubDefaults.Marshal(b, m, deterministic)
 }
-func (dst *SubDefaults) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_SubDefaults.Merge(dst, src)
+func (m *SubDefaults) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SubDefaults.Merge(m, src)
 }
 func (m *SubDefaults) XXX_Size() int {
 	return xxx_messageInfo_SubDefaults.Size(m)
@@ -2637,7 +2648,7 @@ func (m *SubDefaults) GetN() int64 {
 }
 
 type RepeatedEnum struct {
-	Color                []RepeatedEnum_Color `protobuf:"varint,1,rep,name=color,enum=test_proto.RepeatedEnum_Color" json:"color,omitempty"`
+	Color                []RepeatedEnum_Color `protobuf:"varint,1,rep,name=color,enum=proto2_test.RepeatedEnum_Color" json:"color,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
 	XXX_unrecognized     []byte               `json:"-"`
 	XXX_sizecache        int32                `json:"-"`
@@ -2647,16 +2658,17 @@ func (m *RepeatedEnum) Reset()         { *m = RepeatedEnum{} }
 func (m *RepeatedEnum) String() string { return proto.CompactTextString(m) }
 func (*RepeatedEnum) ProtoMessage()    {}
 func (*RepeatedEnum) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{23}
+	return fileDescriptor_e5b3e7ca68f98362, []int{22}
 }
+
 func (m *RepeatedEnum) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RepeatedEnum.Unmarshal(m, b)
 }
 func (m *RepeatedEnum) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_RepeatedEnum.Marshal(b, m, deterministic)
 }
-func (dst *RepeatedEnum) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_RepeatedEnum.Merge(dst, src)
+func (m *RepeatedEnum) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_RepeatedEnum.Merge(m, src)
 }
 func (m *RepeatedEnum) XXX_Size() int {
 	return xxx_messageInfo_RepeatedEnum.Size(m)
@@ -2691,16 +2703,17 @@ func (m *MoreRepeated) Reset()         { *m = MoreRepeated{} }
 func (m *MoreRepeated) String() string { return proto.CompactTextString(m) }
 func (*MoreRepeated) ProtoMessage()    {}
 func (*MoreRepeated) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{24}
+	return fileDescriptor_e5b3e7ca68f98362, []int{23}
 }
+
 func (m *MoreRepeated) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_MoreRepeated.Unmarshal(m, b)
 }
 func (m *MoreRepeated) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_MoreRepeated.Marshal(b, m, deterministic)
 }
-func (dst *MoreRepeated) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MoreRepeated.Merge(dst, src)
+func (m *MoreRepeated) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MoreRepeated.Merge(m, src)
 }
 func (m *MoreRepeated) XXX_Size() int {
 	return xxx_messageInfo_MoreRepeated.Size(m)
@@ -2771,16 +2784,17 @@ func (m *GroupOld) Reset()         { *m = GroupOld{} }
 func (m *GroupOld) String() string { return proto.CompactTextString(m) }
 func (*GroupOld) ProtoMessage()    {}
 func (*GroupOld) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{25}
+	return fileDescriptor_e5b3e7ca68f98362, []int{24}
 }
+
 func (m *GroupOld) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GroupOld.Unmarshal(m, b)
 }
 func (m *GroupOld) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_GroupOld.Marshal(b, m, deterministic)
 }
-func (dst *GroupOld) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GroupOld.Merge(dst, src)
+func (m *GroupOld) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GroupOld.Merge(m, src)
 }
 func (m *GroupOld) XXX_Size() int {
 	return xxx_messageInfo_GroupOld.Size(m)
@@ -2809,16 +2823,17 @@ func (m *GroupOld_G) Reset()         { *m = GroupOld_G{} }
 func (m *GroupOld_G) String() string { return proto.CompactTextString(m) }
 func (*GroupOld_G) ProtoMessage()    {}
 func (*GroupOld_G) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{25, 0}
+	return fileDescriptor_e5b3e7ca68f98362, []int{24, 0}
 }
+
 func (m *GroupOld_G) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GroupOld_G.Unmarshal(m, b)
 }
 func (m *GroupOld_G) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_GroupOld_G.Marshal(b, m, deterministic)
 }
-func (dst *GroupOld_G) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GroupOld_G.Merge(dst, src)
+func (m *GroupOld_G) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GroupOld_G.Merge(m, src)
 }
 func (m *GroupOld_G) XXX_Size() int {
 	return xxx_messageInfo_GroupOld_G.Size(m)
@@ -2847,16 +2862,17 @@ func (m *GroupNew) Reset()         { *m = GroupNew{} }
 func (m *GroupNew) String() string { return proto.CompactTextString(m) }
 func (*GroupNew) ProtoMessage()    {}
 func (*GroupNew) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{26}
+	return fileDescriptor_e5b3e7ca68f98362, []int{25}
 }
+
 func (m *GroupNew) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GroupNew.Unmarshal(m, b)
 }
 func (m *GroupNew) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_GroupNew.Marshal(b, m, deterministic)
 }
-func (dst *GroupNew) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GroupNew.Merge(dst, src)
+func (m *GroupNew) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GroupNew.Merge(m, src)
 }
 func (m *GroupNew) XXX_Size() int {
 	return xxx_messageInfo_GroupNew.Size(m)
@@ -2886,16 +2902,17 @@ func (m *GroupNew_G) Reset()         { *m = GroupNew_G{} }
 func (m *GroupNew_G) String() string { return proto.CompactTextString(m) }
 func (*GroupNew_G) ProtoMessage()    {}
 func (*GroupNew_G) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{26, 0}
+	return fileDescriptor_e5b3e7ca68f98362, []int{25, 0}
 }
+
 func (m *GroupNew_G) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GroupNew_G.Unmarshal(m, b)
 }
 func (m *GroupNew_G) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_GroupNew_G.Marshal(b, m, deterministic)
 }
-func (dst *GroupNew_G) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GroupNew_G.Merge(dst, src)
+func (m *GroupNew_G) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GroupNew_G.Merge(m, src)
 }
 func (m *GroupNew_G) XXX_Size() int {
 	return xxx_messageInfo_GroupNew_G.Size(m)
@@ -2932,16 +2949,17 @@ func (m *FloatingPoint) Reset()         { *m = FloatingPoint{} }
 func (m *FloatingPoint) String() string { return proto.CompactTextString(m) }
 func (*FloatingPoint) ProtoMessage()    {}
 func (*FloatingPoint) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{27}
+	return fileDescriptor_e5b3e7ca68f98362, []int{26}
 }
+
 func (m *FloatingPoint) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FloatingPoint.Unmarshal(m, b)
 }
 func (m *FloatingPoint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_FloatingPoint.Marshal(b, m, deterministic)
 }
-func (dst *FloatingPoint) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_FloatingPoint.Merge(dst, src)
+func (m *FloatingPoint) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_FloatingPoint.Merge(m, src)
 }
 func (m *FloatingPoint) XXX_Size() int {
 	return xxx_messageInfo_FloatingPoint.Size(m)
@@ -2980,16 +2998,17 @@ func (m *MessageWithMap) Reset()         { *m = MessageWithMap{} }
 func (m *MessageWithMap) String() string { return proto.CompactTextString(m) }
 func (*MessageWithMap) ProtoMessage()    {}
 func (*MessageWithMap) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{28}
+	return fileDescriptor_e5b3e7ca68f98362, []int{27}
 }
+
 func (m *MessageWithMap) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_MessageWithMap.Unmarshal(m, b)
 }
 func (m *MessageWithMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_MessageWithMap.Marshal(b, m, deterministic)
 }
-func (dst *MessageWithMap) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MessageWithMap.Merge(dst, src)
+func (m *MessageWithMap) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MessageWithMap.Merge(m, src)
 }
 func (m *MessageWithMap) XXX_Size() int {
 	return xxx_messageInfo_MessageWithMap.Size(m)
@@ -3060,16 +3079,17 @@ func (m *Oneof) Reset()         { *m = Oneof{} }
 func (m *Oneof) String() string { return proto.CompactTextString(m) }
 func (*Oneof) ProtoMessage()    {}
 func (*Oneof) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{29}
+	return fileDescriptor_e5b3e7ca68f98362, []int{28}
 }
+
 func (m *Oneof) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Oneof.Unmarshal(m, b)
 }
 func (m *Oneof) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_Oneof.Marshal(b, m, deterministic)
 }
-func (dst *Oneof) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Oneof.Merge(dst, src)
+func (m *Oneof) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Oneof.Merge(m, src)
 }
 func (m *Oneof) XXX_Size() int {
 	return xxx_messageInfo_Oneof.Size(m)
@@ -3083,83 +3103,108 @@ var xxx_messageInfo_Oneof proto.InternalMessageInfo
 type isOneof_Union interface {
 	isOneof_Union()
 }
-type isOneof_Tormato interface {
-	isOneof_Tormato()
-}
 
 type Oneof_F_Bool struct {
 	F_Bool bool `protobuf:"varint,1,opt,name=F_Bool,json=FBool,oneof"`
 }
+
 type Oneof_F_Int32 struct {
 	F_Int32 int32 `protobuf:"varint,2,opt,name=F_Int32,json=FInt32,oneof"`
 }
+
 type Oneof_F_Int64 struct {
 	F_Int64 int64 `protobuf:"varint,3,opt,name=F_Int64,json=FInt64,oneof"`
 }
+
 type Oneof_F_Fixed32 struct {
 	F_Fixed32 uint32 `protobuf:"fixed32,4,opt,name=F_Fixed32,json=FFixed32,oneof"`
 }
+
 type Oneof_F_Fixed64 struct {
 	F_Fixed64 uint64 `protobuf:"fixed64,5,opt,name=F_Fixed64,json=FFixed64,oneof"`
 }
+
 type Oneof_F_Uint32 struct {
 	F_Uint32 uint32 `protobuf:"varint,6,opt,name=F_Uint32,json=FUint32,oneof"`
 }
+
 type Oneof_F_Uint64 struct {
 	F_Uint64 uint64 `protobuf:"varint,7,opt,name=F_Uint64,json=FUint64,oneof"`
 }
+
 type Oneof_F_Float struct {
 	F_Float float32 `protobuf:"fixed32,8,opt,name=F_Float,json=FFloat,oneof"`
 }
+
 type Oneof_F_Double struct {
 	F_Double float64 `protobuf:"fixed64,9,opt,name=F_Double,json=FDouble,oneof"`
 }
+
 type Oneof_F_String struct {
 	F_String string `protobuf:"bytes,10,opt,name=F_String,json=FString,oneof"`
 }
+
 type Oneof_F_Bytes struct {
 	F_Bytes []byte `protobuf:"bytes,11,opt,name=F_Bytes,json=FBytes,oneof"`
 }
+
 type Oneof_F_Sint32 struct {
 	F_Sint32 int32 `protobuf:"zigzag32,12,opt,name=F_Sint32,json=FSint32,oneof"`
 }
+
 type Oneof_F_Sint64 struct {
 	F_Sint64 int64 `protobuf:"zigzag64,13,opt,name=F_Sint64,json=FSint64,oneof"`
 }
+
 type Oneof_F_Enum struct {
-	F_Enum MyMessage_Color `protobuf:"varint,14,opt,name=F_Enum,json=FEnum,enum=test_proto.MyMessage_Color,oneof"`
+	F_Enum MyMessage_Color `protobuf:"varint,14,opt,name=F_Enum,json=FEnum,enum=proto2_test.MyMessage_Color,oneof"`
 }
+
 type Oneof_F_Message struct {
 	F_Message *GoTestField `protobuf:"bytes,15,opt,name=F_Message,json=FMessage,oneof"`
 }
+
 type Oneof_FGroup struct {
 	FGroup *Oneof_F_Group `protobuf:"group,16,opt,name=F_Group,json=fGroup,oneof"`
 }
+
 type Oneof_F_Largest_Tag struct {
 	F_Largest_Tag int32 `protobuf:"varint,536870911,opt,name=F_Largest_Tag,json=FLargestTag,oneof"`
 }
-type Oneof_Value struct {
-	Value int32 `protobuf:"varint,100,opt,name=value,oneof"`
-}
 
-func (*Oneof_F_Bool) isOneof_Union()        {}
-func (*Oneof_F_Int32) isOneof_Union()       {}
-func (*Oneof_F_Int64) isOneof_Union()       {}
-func (*Oneof_F_Fixed32) isOneof_Union()     {}
-func (*Oneof_F_Fixed64) isOneof_Union()     {}
-func (*Oneof_F_Uint32) isOneof_Union()      {}
-func (*Oneof_F_Uint64) isOneof_Union()      {}
-func (*Oneof_F_Float) isOneof_Union()       {}
-func (*Oneof_F_Double) isOneof_Union()      {}
-func (*Oneof_F_String) isOneof_Union()      {}
-func (*Oneof_F_Bytes) isOneof_Union()       {}
-func (*Oneof_F_Sint32) isOneof_Union()      {}
-func (*Oneof_F_Sint64) isOneof_Union()      {}
-func (*Oneof_F_Enum) isOneof_Union()        {}
-func (*Oneof_F_Message) isOneof_Union()     {}
-func (*Oneof_FGroup) isOneof_Union()        {}
+func (*Oneof_F_Bool) isOneof_Union() {}
+
+func (*Oneof_F_Int32) isOneof_Union() {}
+
+func (*Oneof_F_Int64) isOneof_Union() {}
+
+func (*Oneof_F_Fixed32) isOneof_Union() {}
+
+func (*Oneof_F_Fixed64) isOneof_Union() {}
+
+func (*Oneof_F_Uint32) isOneof_Union() {}
+
+func (*Oneof_F_Uint64) isOneof_Union() {}
+
+func (*Oneof_F_Float) isOneof_Union() {}
+
+func (*Oneof_F_Double) isOneof_Union() {}
+
+func (*Oneof_F_String) isOneof_Union() {}
+
+func (*Oneof_F_Bytes) isOneof_Union() {}
+
+func (*Oneof_F_Sint32) isOneof_Union() {}
+
+func (*Oneof_F_Sint64) isOneof_Union() {}
+
+func (*Oneof_F_Enum) isOneof_Union() {}
+
+func (*Oneof_F_Message) isOneof_Union() {}
+
+func (*Oneof_FGroup) isOneof_Union() {}
+
 func (*Oneof_F_Largest_Tag) isOneof_Union() {}
-func (*Oneof_Value) isOneof_Tormato()       {}
 
 func (m *Oneof) GetUnion() isOneof_Union {
 	if m != nil {
@@ -3167,12 +3212,6 @@ func (m *Oneof) GetUnion() isOneof_Union {
 	}
 	return nil
 }
-func (m *Oneof) GetTormato() isOneof_Tormato {
-	if m != nil {
-		return m.Tormato
-	}
-	return nil
-}
 
 func (m *Oneof) GetF_Bool() bool {
 	if x, ok := m.GetUnion().(*Oneof_F_Bool); ok {
@@ -3293,6 +3332,23 @@ func (m *Oneof) GetF_Largest_Tag() int32 {
 	return 0
 }
 
+type isOneof_Tormato interface {
+	isOneof_Tormato()
+}
+
+type Oneof_Value struct {
+	Value int32 `protobuf:"varint,100,opt,name=value,oneof"`
+}
+
+func (*Oneof_Value) isOneof_Tormato() {}
+
+func (m *Oneof) GetTormato() isOneof_Tormato {
+	if m != nil {
+		return m.Tormato
+	}
+	return nil
+}
+
 func (m *Oneof) GetValue() int32 {
 	if x, ok := m.GetTormato().(*Oneof_Value); ok {
 		return x.Value
@@ -3300,9 +3356,9 @@ func (m *Oneof) GetValue() int32 {
 	return 0
 }
 
-// XXX_OneofFuncs is for the internal use of the proto package.
-func (*Oneof) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
-	return _Oneof_OneofMarshaler, _Oneof_OneofUnmarshaler, _Oneof_OneofSizer, []interface{}{
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*Oneof) XXX_OneofWrappers() []interface{} {
+	return []interface{}{
 		(*Oneof_F_Bool)(nil),
 		(*Oneof_F_Int32)(nil),
 		(*Oneof_F_Int64)(nil),
@@ -3324,298 +3380,6 @@ func (*Oneof) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error,
 	}
 }
 
-func _Oneof_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
-	m := msg.(*Oneof)
-	// union
-	switch x := m.Union.(type) {
-	case *Oneof_F_Bool:
-		t := uint64(0)
-		if x.F_Bool {
-			t = 1
-		}
-		b.EncodeVarint(1<<3 | proto.WireVarint)
-		b.EncodeVarint(t)
-	case *Oneof_F_Int32:
-		b.EncodeVarint(2<<3 | proto.WireVarint)
-		b.EncodeVarint(uint64(x.F_Int32))
-	case *Oneof_F_Int64:
-		b.EncodeVarint(3<<3 | proto.WireVarint)
-		b.EncodeVarint(uint64(x.F_Int64))
-	case *Oneof_F_Fixed32:
-		b.EncodeVarint(4<<3 | proto.WireFixed32)
-		b.EncodeFixed32(uint64(x.F_Fixed32))
-	case *Oneof_F_Fixed64:
-		b.EncodeVarint(5<<3 | proto.WireFixed64)
-		b.EncodeFixed64(uint64(x.F_Fixed64))
-	case *Oneof_F_Uint32:
-		b.EncodeVarint(6<<3 | proto.WireVarint)
-		b.EncodeVarint(uint64(x.F_Uint32))
-	case *Oneof_F_Uint64:
-		b.EncodeVarint(7<<3 | proto.WireVarint)
-		b.EncodeVarint(uint64(x.F_Uint64))
-	case *Oneof_F_Float:
-		b.EncodeVarint(8<<3 | proto.WireFixed32)
-		b.EncodeFixed32(uint64(math.Float32bits(x.F_Float)))
-	case *Oneof_F_Double:
-		b.EncodeVarint(9<<3 | proto.WireFixed64)
-		b.EncodeFixed64(math.Float64bits(x.F_Double))
-	case *Oneof_F_String:
-		b.EncodeVarint(10<<3 | proto.WireBytes)
-		b.EncodeStringBytes(x.F_String)
-	case *Oneof_F_Bytes:
-		b.EncodeVarint(11<<3 | proto.WireBytes)
-		b.EncodeRawBytes(x.F_Bytes)
-	case *Oneof_F_Sint32:
-		b.EncodeVarint(12<<3 | proto.WireVarint)
-		b.EncodeZigzag32(uint64(x.F_Sint32))
-	case *Oneof_F_Sint64:
-		b.EncodeVarint(13<<3 | proto.WireVarint)
-		b.EncodeZigzag64(uint64(x.F_Sint64))
-	case *Oneof_F_Enum:
-		b.EncodeVarint(14<<3 | proto.WireVarint)
-		b.EncodeVarint(uint64(x.F_Enum))
-	case *Oneof_F_Message:
-		b.EncodeVarint(15<<3 | proto.WireBytes)
-		if err := b.EncodeMessage(x.F_Message); err != nil {
-			return err
-		}
-	case *Oneof_FGroup:
-		b.EncodeVarint(16<<3 | proto.WireStartGroup)
-		if err := b.Marshal(x.FGroup); err != nil {
-			return err
-		}
-		b.EncodeVarint(16<<3 | proto.WireEndGroup)
-	case *Oneof_F_Largest_Tag:
-		b.EncodeVarint(536870911<<3 | proto.WireVarint)
-		b.EncodeVarint(uint64(x.F_Largest_Tag))
-	case nil:
-	default:
-		return fmt.Errorf("Oneof.Union has unexpected type %T", x)
-	}
-	// tormato
-	switch x := m.Tormato.(type) {
-	case *Oneof_Value:
-		b.EncodeVarint(100<<3 | proto.WireVarint)
-		b.EncodeVarint(uint64(x.Value))
-	case nil:
-	default:
-		return fmt.Errorf("Oneof.Tormato has unexpected type %T", x)
-	}
-	return nil
-}
-
-func _Oneof_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
-	m := msg.(*Oneof)
-	switch tag {
-	case 1: // union.F_Bool
-		if wire != proto.WireVarint {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeVarint()
-		m.Union = &Oneof_F_Bool{x != 0}
-		return true, err
-	case 2: // union.F_Int32
-		if wire != proto.WireVarint {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeVarint()
-		m.Union = &Oneof_F_Int32{int32(x)}
-		return true, err
-	case 3: // union.F_Int64
-		if wire != proto.WireVarint {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeVarint()
-		m.Union = &Oneof_F_Int64{int64(x)}
-		return true, err
-	case 4: // union.F_Fixed32
-		if wire != proto.WireFixed32 {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeFixed32()
-		m.Union = &Oneof_F_Fixed32{uint32(x)}
-		return true, err
-	case 5: // union.F_Fixed64
-		if wire != proto.WireFixed64 {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeFixed64()
-		m.Union = &Oneof_F_Fixed64{x}
-		return true, err
-	case 6: // union.F_Uint32
-		if wire != proto.WireVarint {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeVarint()
-		m.Union = &Oneof_F_Uint32{uint32(x)}
-		return true, err
-	case 7: // union.F_Uint64
-		if wire != proto.WireVarint {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeVarint()
-		m.Union = &Oneof_F_Uint64{x}
-		return true, err
-	case 8: // union.F_Float
-		if wire != proto.WireFixed32 {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeFixed32()
-		m.Union = &Oneof_F_Float{math.Float32frombits(uint32(x))}
-		return true, err
-	case 9: // union.F_Double
-		if wire != proto.WireFixed64 {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeFixed64()
-		m.Union = &Oneof_F_Double{math.Float64frombits(x)}
-		return true, err
-	case 10: // union.F_String
-		if wire != proto.WireBytes {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeStringBytes()
-		m.Union = &Oneof_F_String{x}
-		return true, err
-	case 11: // union.F_Bytes
-		if wire != proto.WireBytes {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeRawBytes(true)
-		m.Union = &Oneof_F_Bytes{x}
-		return true, err
-	case 12: // union.F_Sint32
-		if wire != proto.WireVarint {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeZigzag32()
-		m.Union = &Oneof_F_Sint32{int32(x)}
-		return true, err
-	case 13: // union.F_Sint64
-		if wire != proto.WireVarint {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeZigzag64()
-		m.Union = &Oneof_F_Sint64{int64(x)}
-		return true, err
-	case 14: // union.F_Enum
-		if wire != proto.WireVarint {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeVarint()
-		m.Union = &Oneof_F_Enum{MyMessage_Color(x)}
-		return true, err
-	case 15: // union.F_Message
-		if wire != proto.WireBytes {
-			return true, proto.ErrInternalBadWireType
-		}
-		msg := new(GoTestField)
-		err := b.DecodeMessage(msg)
-		m.Union = &Oneof_F_Message{msg}
-		return true, err
-	case 16: // union.f_group
-		if wire != proto.WireStartGroup {
-			return true, proto.ErrInternalBadWireType
-		}
-		msg := new(Oneof_F_Group)
-		err := b.DecodeGroup(msg)
-		m.Union = &Oneof_FGroup{msg}
-		return true, err
-	case 536870911: // union.F_Largest_Tag
-		if wire != proto.WireVarint {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeVarint()
-		m.Union = &Oneof_F_Largest_Tag{int32(x)}
-		return true, err
-	case 100: // tormato.value
-		if wire != proto.WireVarint {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeVarint()
-		m.Tormato = &Oneof_Value{int32(x)}
-		return true, err
-	default:
-		return false, nil
-	}
-}
-
-func _Oneof_OneofSizer(msg proto.Message) (n int) {
-	m := msg.(*Oneof)
-	// union
-	switch x := m.Union.(type) {
-	case *Oneof_F_Bool:
-		n += 1 // tag and wire
-		n += 1
-	case *Oneof_F_Int32:
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(x.F_Int32))
-	case *Oneof_F_Int64:
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(x.F_Int64))
-	case *Oneof_F_Fixed32:
-		n += 1 // tag and wire
-		n += 4
-	case *Oneof_F_Fixed64:
-		n += 1 // tag and wire
-		n += 8
-	case *Oneof_F_Uint32:
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(x.F_Uint32))
-	case *Oneof_F_Uint64:
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(x.F_Uint64))
-	case *Oneof_F_Float:
-		n += 1 // tag and wire
-		n += 4
-	case *Oneof_F_Double:
-		n += 1 // tag and wire
-		n += 8
-	case *Oneof_F_String:
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(len(x.F_String)))
-		n += len(x.F_String)
-	case *Oneof_F_Bytes:
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(len(x.F_Bytes)))
-		n += len(x.F_Bytes)
-	case *Oneof_F_Sint32:
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64((uint32(x.F_Sint32) << 1) ^ uint32((int32(x.F_Sint32) >> 31))))
-	case *Oneof_F_Sint64:
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(uint64(x.F_Sint64<<1) ^ uint64((int64(x.F_Sint64) >> 63))))
-	case *Oneof_F_Enum:
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(x.F_Enum))
-	case *Oneof_F_Message:
-		s := proto.Size(x.F_Message)
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(s))
-		n += s
-	case *Oneof_FGroup:
-		n += 2 // tag and wire
-		n += proto.Size(x.FGroup)
-		n += 2 // tag and wire
-	case *Oneof_F_Largest_Tag:
-		n += 10 // tag and wire
-		n += proto.SizeVarint(uint64(x.F_Largest_Tag))
-	case nil:
-	default:
-		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
-	}
-	// tormato
-	switch x := m.Tormato.(type) {
-	case *Oneof_Value:
-		n += 2 // tag and wire
-		n += proto.SizeVarint(uint64(x.Value))
-	case nil:
-	default:
-		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
-	}
-	return n
-}
-
 type Oneof_F_Group struct {
 	X                    *int32   `protobuf:"varint,17,opt,name=x" json:"x,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
@@ -3627,16 +3391,17 @@ func (m *Oneof_F_Group) Reset()         { *m = Oneof_F_Group{} }
 func (m *Oneof_F_Group) String() string { return proto.CompactTextString(m) }
 func (*Oneof_F_Group) ProtoMessage()    {}
 func (*Oneof_F_Group) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{29, 0}
+	return fileDescriptor_e5b3e7ca68f98362, []int{28, 0}
 }
+
 func (m *Oneof_F_Group) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Oneof_F_Group.Unmarshal(m, b)
 }
 func (m *Oneof_F_Group) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_Oneof_F_Group.Marshal(b, m, deterministic)
 }
-func (dst *Oneof_F_Group) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Oneof_F_Group.Merge(dst, src)
+func (m *Oneof_F_Group) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Oneof_F_Group.Merge(m, src)
 }
 func (m *Oneof_F_Group) XXX_Size() int {
 	return xxx_messageInfo_Oneof_F_Group.Size(m)
@@ -3675,16 +3440,17 @@ func (m *Communique) Reset()         { *m = Communique{} }
 func (m *Communique) String() string { return proto.CompactTextString(m) }
 func (*Communique) ProtoMessage()    {}
 func (*Communique) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_74787bfc6550f8a7, []int{30}
+	return fileDescriptor_e5b3e7ca68f98362, []int{29}
 }
+
 func (m *Communique) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Communique.Unmarshal(m, b)
 }
 func (m *Communique) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_Communique.Marshal(b, m, deterministic)
 }
-func (dst *Communique) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Communique.Merge(dst, src)
+func (m *Communique) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Communique.Merge(m, src)
 }
 func (m *Communique) XXX_Size() int {
 	return xxx_messageInfo_Communique.Size(m)
@@ -3695,6 +3461,13 @@ func (m *Communique) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_Communique proto.InternalMessageInfo
 
+func (m *Communique) GetMakeMeCry() bool {
+	if m != nil && m.MakeMeCry != nil {
+		return *m.MakeMeCry
+	}
+	return false
+}
+
 type isCommunique_Union interface {
 	isCommunique_Union()
 }
@@ -3702,28 +3475,38 @@ type isCommunique_Union interface {
 type Communique_Number struct {
 	Number int32 `protobuf:"varint,5,opt,name=number,oneof"`
 }
+
 type Communique_Name struct {
 	Name string `protobuf:"bytes,6,opt,name=name,oneof"`
 }
+
 type Communique_Data struct {
 	Data []byte `protobuf:"bytes,7,opt,name=data,oneof"`
 }
+
 type Communique_TempC struct {
 	TempC float64 `protobuf:"fixed64,8,opt,name=temp_c,json=tempC,oneof"`
 }
+
 type Communique_Col struct {
-	Col MyMessage_Color `protobuf:"varint,9,opt,name=col,enum=test_proto.MyMessage_Color,oneof"`
+	Col MyMessage_Color `protobuf:"varint,9,opt,name=col,enum=proto2_test.MyMessage_Color,oneof"`
 }
+
 type Communique_Msg struct {
 	Msg *Strings `protobuf:"bytes,10,opt,name=msg,oneof"`
 }
 
 func (*Communique_Number) isCommunique_Union() {}
-func (*Communique_Name) isCommunique_Union()   {}
-func (*Communique_Data) isCommunique_Union()   {}
-func (*Communique_TempC) isCommunique_Union()  {}
-func (*Communique_Col) isCommunique_Union()    {}
-func (*Communique_Msg) isCommunique_Union()    {}
+
+func (*Communique_Name) isCommunique_Union() {}
+
+func (*Communique_Data) isCommunique_Union() {}
+
+func (*Communique_TempC) isCommunique_Union() {}
+
+func (*Communique_Col) isCommunique_Union() {}
+
+func (*Communique_Msg) isCommunique_Union() {}
 
 func (m *Communique) GetUnion() isCommunique_Union {
 	if m != nil {
@@ -3732,13 +3515,6 @@ func (m *Communique) GetUnion() isCommunique_Union {
 	return nil
 }
 
-func (m *Communique) GetMakeMeCry() bool {
-	if m != nil && m.MakeMeCry != nil {
-		return *m.MakeMeCry
-	}
-	return false
-}
-
 func (m *Communique) GetNumber() int32 {
 	if x, ok := m.GetUnion().(*Communique_Number); ok {
 		return x.Number
@@ -3781,9 +3557,9 @@ func (m *Communique) GetMsg() *Strings {
 	return nil
 }
 
-// XXX_OneofFuncs is for the internal use of the proto package.
-func (*Communique) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
-	return _Communique_OneofMarshaler, _Communique_OneofUnmarshaler, _Communique_OneofSizer, []interface{}{
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*Communique) XXX_OneofWrappers() []interface{} {
+	return []interface{}{
 		(*Communique_Number)(nil),
 		(*Communique_Name)(nil),
 		(*Communique_Data)(nil),
@@ -3793,944 +3569,478 @@ func (*Communique) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) er
 	}
 }
 
-func _Communique_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
-	m := msg.(*Communique)
-	// union
-	switch x := m.Union.(type) {
-	case *Communique_Number:
-		b.EncodeVarint(5<<3 | proto.WireVarint)
-		b.EncodeVarint(uint64(x.Number))
-	case *Communique_Name:
-		b.EncodeVarint(6<<3 | proto.WireBytes)
-		b.EncodeStringBytes(x.Name)
-	case *Communique_Data:
-		b.EncodeVarint(7<<3 | proto.WireBytes)
-		b.EncodeRawBytes(x.Data)
-	case *Communique_TempC:
-		b.EncodeVarint(8<<3 | proto.WireFixed64)
-		b.EncodeFixed64(math.Float64bits(x.TempC))
-	case *Communique_Col:
-		b.EncodeVarint(9<<3 | proto.WireVarint)
-		b.EncodeVarint(uint64(x.Col))
-	case *Communique_Msg:
-		b.EncodeVarint(10<<3 | proto.WireBytes)
-		if err := b.EncodeMessage(x.Msg); err != nil {
-			return err
-		}
-	case nil:
-	default:
-		return fmt.Errorf("Communique.Union has unexpected type %T", x)
+type TestUTF8 struct {
+	Scalar *string  `protobuf:"bytes,1,opt,name=scalar" json:"scalar,omitempty"`
+	Vector []string `protobuf:"bytes,2,rep,name=vector" json:"vector,omitempty"`
+	// Types that are valid to be assigned to Oneof:
+	//	*TestUTF8_Field
+	Oneof                isTestUTF8_Oneof `protobuf_oneof:"oneof"`
+	MapKey               map[string]int64 `protobuf:"bytes,4,rep,name=map_key,json=mapKey" json:"map_key,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
+	MapValue             map[int64]string `protobuf:"bytes,5,rep,name=map_value,json=mapValue" json:"map_value,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
+	XXX_unrecognized     []byte           `json:"-"`
+	XXX_sizecache        int32            `json:"-"`
+}
+
+func (m *TestUTF8) Reset()         { *m = TestUTF8{} }
+func (m *TestUTF8) String() string { return proto.CompactTextString(m) }
+func (*TestUTF8) ProtoMessage()    {}
+func (*TestUTF8) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e5b3e7ca68f98362, []int{30}
+}
+
+func (m *TestUTF8) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_TestUTF8.Unmarshal(m, b)
+}
+func (m *TestUTF8) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_TestUTF8.Marshal(b, m, deterministic)
+}
+func (m *TestUTF8) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_TestUTF8.Merge(m, src)
+}
+func (m *TestUTF8) XXX_Size() int {
+	return xxx_messageInfo_TestUTF8.Size(m)
+}
+func (m *TestUTF8) XXX_DiscardUnknown() {
+	xxx_messageInfo_TestUTF8.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_TestUTF8 proto.InternalMessageInfo
+
+func (m *TestUTF8) GetScalar() string {
+	if m != nil && m.Scalar != nil {
+		return *m.Scalar
+	}
+	return ""
+}
+
+func (m *TestUTF8) GetVector() []string {
+	if m != nil {
+		return m.Vector
+	}
+	return nil
+}
+
+type isTestUTF8_Oneof interface {
+	isTestUTF8_Oneof()
+}
+
+type TestUTF8_Field struct {
+	Field string `protobuf:"bytes,3,opt,name=field,oneof"`
+}
+
+func (*TestUTF8_Field) isTestUTF8_Oneof() {}
+
+func (m *TestUTF8) GetOneof() isTestUTF8_Oneof {
+	if m != nil {
+		return m.Oneof
+	}
+	return nil
+}
+
+func (m *TestUTF8) GetField() string {
+	if x, ok := m.GetOneof().(*TestUTF8_Field); ok {
+		return x.Field
+	}
+	return ""
+}
+
+func (m *TestUTF8) GetMapKey() map[string]int64 {
+	if m != nil {
+		return m.MapKey
+	}
+	return nil
+}
+
+func (m *TestUTF8) GetMapValue() map[int64]string {
+	if m != nil {
+		return m.MapValue
 	}
 	return nil
 }
 
-func _Communique_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
-	m := msg.(*Communique)
-	switch tag {
-	case 5: // union.number
-		if wire != proto.WireVarint {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeVarint()
-		m.Union = &Communique_Number{int32(x)}
-		return true, err
-	case 6: // union.name
-		if wire != proto.WireBytes {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeStringBytes()
-		m.Union = &Communique_Name{x}
-		return true, err
-	case 7: // union.data
-		if wire != proto.WireBytes {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeRawBytes(true)
-		m.Union = &Communique_Data{x}
-		return true, err
-	case 8: // union.temp_c
-		if wire != proto.WireFixed64 {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeFixed64()
-		m.Union = &Communique_TempC{math.Float64frombits(x)}
-		return true, err
-	case 9: // union.col
-		if wire != proto.WireVarint {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeVarint()
-		m.Union = &Communique_Col{MyMessage_Color(x)}
-		return true, err
-	case 10: // union.msg
-		if wire != proto.WireBytes {
-			return true, proto.ErrInternalBadWireType
-		}
-		msg := new(Strings)
-		err := b.DecodeMessage(msg)
-		m.Union = &Communique_Msg{msg}
-		return true, err
-	default:
-		return false, nil
-	}
-}
-
-func _Communique_OneofSizer(msg proto.Message) (n int) {
-	m := msg.(*Communique)
-	// union
-	switch x := m.Union.(type) {
-	case *Communique_Number:
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(x.Number))
-	case *Communique_Name:
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(len(x.Name)))
-		n += len(x.Name)
-	case *Communique_Data:
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(len(x.Data)))
-		n += len(x.Data)
-	case *Communique_TempC:
-		n += 1 // tag and wire
-		n += 8
-	case *Communique_Col:
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(x.Col))
-	case *Communique_Msg:
-		s := proto.Size(x.Msg)
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(s))
-		n += s
-	case nil:
-	default:
-		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
-	}
-	return n
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*TestUTF8) XXX_OneofWrappers() []interface{} {
+	return []interface{}{
+		(*TestUTF8_Field)(nil),
+	}
 }
 
 var E_Greeting = &proto.ExtensionDesc{
 	ExtendedType:  (*MyMessage)(nil),
 	ExtensionType: ([]string)(nil),
 	Field:         106,
-	Name:          "test_proto.greeting",
+	Name:          "proto2_test.greeting",
 	Tag:           "bytes,106,rep,name=greeting",
-	Filename:      "test_proto/test.proto",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_Complex = &proto.ExtensionDesc{
 	ExtendedType:  (*OtherMessage)(nil),
 	ExtensionType: (*ComplexExtension)(nil),
 	Field:         200,
-	Name:          "test_proto.complex",
+	Name:          "proto2_test.complex",
 	Tag:           "bytes,200,opt,name=complex",
-	Filename:      "test_proto/test.proto",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_RComplex = &proto.ExtensionDesc{
 	ExtendedType:  (*OtherMessage)(nil),
 	ExtensionType: ([]*ComplexExtension)(nil),
 	Field:         201,
-	Name:          "test_proto.r_complex",
-	Tag:           "bytes,201,rep,name=r_complex,json=rComplex",
-	Filename:      "test_proto/test.proto",
+	Name:          "proto2_test.r_complex",
+	Tag:           "bytes,201,rep,name=r_complex",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_NoDefaultDouble = &proto.ExtensionDesc{
 	ExtendedType:  (*DefaultsMessage)(nil),
 	ExtensionType: (*float64)(nil),
 	Field:         101,
-	Name:          "test_proto.no_default_double",
-	Tag:           "fixed64,101,opt,name=no_default_double,json=noDefaultDouble",
-	Filename:      "test_proto/test.proto",
+	Name:          "proto2_test.no_default_double",
+	Tag:           "fixed64,101,opt,name=no_default_double",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_NoDefaultFloat = &proto.ExtensionDesc{
 	ExtendedType:  (*DefaultsMessage)(nil),
 	ExtensionType: (*float32)(nil),
 	Field:         102,
-	Name:          "test_proto.no_default_float",
-	Tag:           "fixed32,102,opt,name=no_default_float,json=noDefaultFloat",
-	Filename:      "test_proto/test.proto",
+	Name:          "proto2_test.no_default_float",
+	Tag:           "fixed32,102,opt,name=no_default_float",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_NoDefaultInt32 = &proto.ExtensionDesc{
 	ExtendedType:  (*DefaultsMessage)(nil),
 	ExtensionType: (*int32)(nil),
 	Field:         103,
-	Name:          "test_proto.no_default_int32",
-	Tag:           "varint,103,opt,name=no_default_int32,json=noDefaultInt32",
-	Filename:      "test_proto/test.proto",
+	Name:          "proto2_test.no_default_int32",
+	Tag:           "varint,103,opt,name=no_default_int32",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_NoDefaultInt64 = &proto.ExtensionDesc{
 	ExtendedType:  (*DefaultsMessage)(nil),
 	ExtensionType: (*int64)(nil),
 	Field:         104,
-	Name:          "test_proto.no_default_int64",
-	Tag:           "varint,104,opt,name=no_default_int64,json=noDefaultInt64",
-	Filename:      "test_proto/test.proto",
+	Name:          "proto2_test.no_default_int64",
+	Tag:           "varint,104,opt,name=no_default_int64",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_NoDefaultUint32 = &proto.ExtensionDesc{
 	ExtendedType:  (*DefaultsMessage)(nil),
 	ExtensionType: (*uint32)(nil),
 	Field:         105,
-	Name:          "test_proto.no_default_uint32",
-	Tag:           "varint,105,opt,name=no_default_uint32,json=noDefaultUint32",
-	Filename:      "test_proto/test.proto",
+	Name:          "proto2_test.no_default_uint32",
+	Tag:           "varint,105,opt,name=no_default_uint32",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_NoDefaultUint64 = &proto.ExtensionDesc{
 	ExtendedType:  (*DefaultsMessage)(nil),
 	ExtensionType: (*uint64)(nil),
 	Field:         106,
-	Name:          "test_proto.no_default_uint64",
-	Tag:           "varint,106,opt,name=no_default_uint64,json=noDefaultUint64",
-	Filename:      "test_proto/test.proto",
+	Name:          "proto2_test.no_default_uint64",
+	Tag:           "varint,106,opt,name=no_default_uint64",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_NoDefaultSint32 = &proto.ExtensionDesc{
 	ExtendedType:  (*DefaultsMessage)(nil),
 	ExtensionType: (*int32)(nil),
 	Field:         107,
-	Name:          "test_proto.no_default_sint32",
-	Tag:           "zigzag32,107,opt,name=no_default_sint32,json=noDefaultSint32",
-	Filename:      "test_proto/test.proto",
+	Name:          "proto2_test.no_default_sint32",
+	Tag:           "zigzag32,107,opt,name=no_default_sint32",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_NoDefaultSint64 = &proto.ExtensionDesc{
 	ExtendedType:  (*DefaultsMessage)(nil),
 	ExtensionType: (*int64)(nil),
 	Field:         108,
-	Name:          "test_proto.no_default_sint64",
-	Tag:           "zigzag64,108,opt,name=no_default_sint64,json=noDefaultSint64",
-	Filename:      "test_proto/test.proto",
+	Name:          "proto2_test.no_default_sint64",
+	Tag:           "zigzag64,108,opt,name=no_default_sint64",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_NoDefaultFixed32 = &proto.ExtensionDesc{
 	ExtendedType:  (*DefaultsMessage)(nil),
 	ExtensionType: (*uint32)(nil),
 	Field:         109,
-	Name:          "test_proto.no_default_fixed32",
-	Tag:           "fixed32,109,opt,name=no_default_fixed32,json=noDefaultFixed32",
-	Filename:      "test_proto/test.proto",
+	Name:          "proto2_test.no_default_fixed32",
+	Tag:           "fixed32,109,opt,name=no_default_fixed32",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_NoDefaultFixed64 = &proto.ExtensionDesc{
 	ExtendedType:  (*DefaultsMessage)(nil),
 	ExtensionType: (*uint64)(nil),
 	Field:         110,
-	Name:          "test_proto.no_default_fixed64",
-	Tag:           "fixed64,110,opt,name=no_default_fixed64,json=noDefaultFixed64",
-	Filename:      "test_proto/test.proto",
+	Name:          "proto2_test.no_default_fixed64",
+	Tag:           "fixed64,110,opt,name=no_default_fixed64",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_NoDefaultSfixed32 = &proto.ExtensionDesc{
 	ExtendedType:  (*DefaultsMessage)(nil),
 	ExtensionType: (*int32)(nil),
 	Field:         111,
-	Name:          "test_proto.no_default_sfixed32",
-	Tag:           "fixed32,111,opt,name=no_default_sfixed32,json=noDefaultSfixed32",
-	Filename:      "test_proto/test.proto",
+	Name:          "proto2_test.no_default_sfixed32",
+	Tag:           "fixed32,111,opt,name=no_default_sfixed32",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_NoDefaultSfixed64 = &proto.ExtensionDesc{
 	ExtendedType:  (*DefaultsMessage)(nil),
 	ExtensionType: (*int64)(nil),
 	Field:         112,
-	Name:          "test_proto.no_default_sfixed64",
-	Tag:           "fixed64,112,opt,name=no_default_sfixed64,json=noDefaultSfixed64",
-	Filename:      "test_proto/test.proto",
+	Name:          "proto2_test.no_default_sfixed64",
+	Tag:           "fixed64,112,opt,name=no_default_sfixed64",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_NoDefaultBool = &proto.ExtensionDesc{
 	ExtendedType:  (*DefaultsMessage)(nil),
 	ExtensionType: (*bool)(nil),
 	Field:         113,
-	Name:          "test_proto.no_default_bool",
-	Tag:           "varint,113,opt,name=no_default_bool,json=noDefaultBool",
-	Filename:      "test_proto/test.proto",
+	Name:          "proto2_test.no_default_bool",
+	Tag:           "varint,113,opt,name=no_default_bool",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_NoDefaultString = &proto.ExtensionDesc{
 	ExtendedType:  (*DefaultsMessage)(nil),
 	ExtensionType: (*string)(nil),
 	Field:         114,
-	Name:          "test_proto.no_default_string",
-	Tag:           "bytes,114,opt,name=no_default_string,json=noDefaultString",
-	Filename:      "test_proto/test.proto",
+	Name:          "proto2_test.no_default_string",
+	Tag:           "bytes,114,opt,name=no_default_string",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_NoDefaultBytes = &proto.ExtensionDesc{
 	ExtendedType:  (*DefaultsMessage)(nil),
 	ExtensionType: ([]byte)(nil),
 	Field:         115,
-	Name:          "test_proto.no_default_bytes",
-	Tag:           "bytes,115,opt,name=no_default_bytes,json=noDefaultBytes",
-	Filename:      "test_proto/test.proto",
+	Name:          "proto2_test.no_default_bytes",
+	Tag:           "bytes,115,opt,name=no_default_bytes",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_NoDefaultEnum = &proto.ExtensionDesc{
 	ExtendedType:  (*DefaultsMessage)(nil),
 	ExtensionType: (*DefaultsMessage_DefaultsEnum)(nil),
 	Field:         116,
-	Name:          "test_proto.no_default_enum",
-	Tag:           "varint,116,opt,name=no_default_enum,json=noDefaultEnum,enum=test_proto.DefaultsMessage_DefaultsEnum",
-	Filename:      "test_proto/test.proto",
+	Name:          "proto2_test.no_default_enum",
+	Tag:           "varint,116,opt,name=no_default_enum,enum=proto2_test.DefaultsMessage_DefaultsEnum",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_DefaultDouble = &proto.ExtensionDesc{
 	ExtendedType:  (*DefaultsMessage)(nil),
 	ExtensionType: (*float64)(nil),
 	Field:         201,
-	Name:          "test_proto.default_double",
-	Tag:           "fixed64,201,opt,name=default_double,json=defaultDouble,def=3.1415",
-	Filename:      "test_proto/test.proto",
+	Name:          "proto2_test.default_double",
+	Tag:           "fixed64,201,opt,name=default_double,def=3.1415",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_DefaultFloat = &proto.ExtensionDesc{
 	ExtendedType:  (*DefaultsMessage)(nil),
 	ExtensionType: (*float32)(nil),
 	Field:         202,
-	Name:          "test_proto.default_float",
-	Tag:           "fixed32,202,opt,name=default_float,json=defaultFloat,def=3.14",
-	Filename:      "test_proto/test.proto",
+	Name:          "proto2_test.default_float",
+	Tag:           "fixed32,202,opt,name=default_float,def=3.14",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_DefaultInt32 = &proto.ExtensionDesc{
 	ExtendedType:  (*DefaultsMessage)(nil),
 	ExtensionType: (*int32)(nil),
 	Field:         203,
-	Name:          "test_proto.default_int32",
-	Tag:           "varint,203,opt,name=default_int32,json=defaultInt32,def=42",
-	Filename:      "test_proto/test.proto",
+	Name:          "proto2_test.default_int32",
+	Tag:           "varint,203,opt,name=default_int32,def=42",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_DefaultInt64 = &proto.ExtensionDesc{
 	ExtendedType:  (*DefaultsMessage)(nil),
 	ExtensionType: (*int64)(nil),
 	Field:         204,
-	Name:          "test_proto.default_int64",
-	Tag:           "varint,204,opt,name=default_int64,json=defaultInt64,def=43",
-	Filename:      "test_proto/test.proto",
+	Name:          "proto2_test.default_int64",
+	Tag:           "varint,204,opt,name=default_int64,def=43",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_DefaultUint32 = &proto.ExtensionDesc{
 	ExtendedType:  (*DefaultsMessage)(nil),
 	ExtensionType: (*uint32)(nil),
 	Field:         205,
-	Name:          "test_proto.default_uint32",
-	Tag:           "varint,205,opt,name=default_uint32,json=defaultUint32,def=44",
-	Filename:      "test_proto/test.proto",
+	Name:          "proto2_test.default_uint32",
+	Tag:           "varint,205,opt,name=default_uint32,def=44",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_DefaultUint64 = &proto.ExtensionDesc{
 	ExtendedType:  (*DefaultsMessage)(nil),
 	ExtensionType: (*uint64)(nil),
 	Field:         206,
-	Name:          "test_proto.default_uint64",
-	Tag:           "varint,206,opt,name=default_uint64,json=defaultUint64,def=45",
-	Filename:      "test_proto/test.proto",
+	Name:          "proto2_test.default_uint64",
+	Tag:           "varint,206,opt,name=default_uint64,def=45",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_DefaultSint32 = &proto.ExtensionDesc{
 	ExtendedType:  (*DefaultsMessage)(nil),
 	ExtensionType: (*int32)(nil),
 	Field:         207,
-	Name:          "test_proto.default_sint32",
-	Tag:           "zigzag32,207,opt,name=default_sint32,json=defaultSint32,def=46",
-	Filename:      "test_proto/test.proto",
+	Name:          "proto2_test.default_sint32",
+	Tag:           "zigzag32,207,opt,name=default_sint32,def=46",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_DefaultSint64 = &proto.ExtensionDesc{
 	ExtendedType:  (*DefaultsMessage)(nil),
 	ExtensionType: (*int64)(nil),
 	Field:         208,
-	Name:          "test_proto.default_sint64",
-	Tag:           "zigzag64,208,opt,name=default_sint64,json=defaultSint64,def=47",
-	Filename:      "test_proto/test.proto",
+	Name:          "proto2_test.default_sint64",
+	Tag:           "zigzag64,208,opt,name=default_sint64,def=47",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_DefaultFixed32 = &proto.ExtensionDesc{
 	ExtendedType:  (*DefaultsMessage)(nil),
 	ExtensionType: (*uint32)(nil),
 	Field:         209,
-	Name:          "test_proto.default_fixed32",
-	Tag:           "fixed32,209,opt,name=default_fixed32,json=defaultFixed32,def=48",
-	Filename:      "test_proto/test.proto",
+	Name:          "proto2_test.default_fixed32",
+	Tag:           "fixed32,209,opt,name=default_fixed32,def=48",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_DefaultFixed64 = &proto.ExtensionDesc{
 	ExtendedType:  (*DefaultsMessage)(nil),
 	ExtensionType: (*uint64)(nil),
 	Field:         210,
-	Name:          "test_proto.default_fixed64",
-	Tag:           "fixed64,210,opt,name=default_fixed64,json=defaultFixed64,def=49",
-	Filename:      "test_proto/test.proto",
+	Name:          "proto2_test.default_fixed64",
+	Tag:           "fixed64,210,opt,name=default_fixed64,def=49",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_DefaultSfixed32 = &proto.ExtensionDesc{
 	ExtendedType:  (*DefaultsMessage)(nil),
 	ExtensionType: (*int32)(nil),
 	Field:         211,
-	Name:          "test_proto.default_sfixed32",
-	Tag:           "fixed32,211,opt,name=default_sfixed32,json=defaultSfixed32,def=50",
-	Filename:      "test_proto/test.proto",
+	Name:          "proto2_test.default_sfixed32",
+	Tag:           "fixed32,211,opt,name=default_sfixed32,def=50",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_DefaultSfixed64 = &proto.ExtensionDesc{
 	ExtendedType:  (*DefaultsMessage)(nil),
 	ExtensionType: (*int64)(nil),
 	Field:         212,
-	Name:          "test_proto.default_sfixed64",
-	Tag:           "fixed64,212,opt,name=default_sfixed64,json=defaultSfixed64,def=51",
-	Filename:      "test_proto/test.proto",
+	Name:          "proto2_test.default_sfixed64",
+	Tag:           "fixed64,212,opt,name=default_sfixed64,def=51",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_DefaultBool = &proto.ExtensionDesc{
 	ExtendedType:  (*DefaultsMessage)(nil),
 	ExtensionType: (*bool)(nil),
 	Field:         213,
-	Name:          "test_proto.default_bool",
-	Tag:           "varint,213,opt,name=default_bool,json=defaultBool,def=1",
-	Filename:      "test_proto/test.proto",
+	Name:          "proto2_test.default_bool",
+	Tag:           "varint,213,opt,name=default_bool,def=1",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_DefaultString = &proto.ExtensionDesc{
 	ExtendedType:  (*DefaultsMessage)(nil),
 	ExtensionType: (*string)(nil),
 	Field:         214,
-	Name:          "test_proto.default_string",
-	Tag:           "bytes,214,opt,name=default_string,json=defaultString,def=Hello, string,def=foo",
-	Filename:      "test_proto/test.proto",
+	Name:          "proto2_test.default_string",
+	Tag:           "bytes,214,opt,name=default_string,def=Hello, string,def=foo",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_DefaultBytes = &proto.ExtensionDesc{
 	ExtendedType:  (*DefaultsMessage)(nil),
 	ExtensionType: ([]byte)(nil),
 	Field:         215,
-	Name:          "test_proto.default_bytes",
-	Tag:           "bytes,215,opt,name=default_bytes,json=defaultBytes,def=Hello, bytes",
-	Filename:      "test_proto/test.proto",
+	Name:          "proto2_test.default_bytes",
+	Tag:           "bytes,215,opt,name=default_bytes,def=Hello, bytes",
+	Filename:      "proto2_proto/test.proto",
 }
 
 var E_DefaultEnum = &proto.ExtensionDesc{
 	ExtendedType:  (*DefaultsMessage)(nil),
 	ExtensionType: (*DefaultsMessage_DefaultsEnum)(nil),
 	Field:         216,
-	Name:          "test_proto.default_enum",
-	Tag:           "varint,216,opt,name=default_enum,json=defaultEnum,enum=test_proto.DefaultsMessage_DefaultsEnum,def=1",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X201 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         201,
-	Name:          "test_proto.x201",
-	Tag:           "bytes,201,opt,name=x201",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X202 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         202,
-	Name:          "test_proto.x202",
-	Tag:           "bytes,202,opt,name=x202",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X203 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         203,
-	Name:          "test_proto.x203",
-	Tag:           "bytes,203,opt,name=x203",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X204 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         204,
-	Name:          "test_proto.x204",
-	Tag:           "bytes,204,opt,name=x204",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X205 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         205,
-	Name:          "test_proto.x205",
-	Tag:           "bytes,205,opt,name=x205",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X206 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         206,
-	Name:          "test_proto.x206",
-	Tag:           "bytes,206,opt,name=x206",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X207 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         207,
-	Name:          "test_proto.x207",
-	Tag:           "bytes,207,opt,name=x207",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X208 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         208,
-	Name:          "test_proto.x208",
-	Tag:           "bytes,208,opt,name=x208",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X209 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         209,
-	Name:          "test_proto.x209",
-	Tag:           "bytes,209,opt,name=x209",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X210 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         210,
-	Name:          "test_proto.x210",
-	Tag:           "bytes,210,opt,name=x210",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X211 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         211,
-	Name:          "test_proto.x211",
-	Tag:           "bytes,211,opt,name=x211",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X212 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         212,
-	Name:          "test_proto.x212",
-	Tag:           "bytes,212,opt,name=x212",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X213 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         213,
-	Name:          "test_proto.x213",
-	Tag:           "bytes,213,opt,name=x213",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X214 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         214,
-	Name:          "test_proto.x214",
-	Tag:           "bytes,214,opt,name=x214",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X215 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         215,
-	Name:          "test_proto.x215",
-	Tag:           "bytes,215,opt,name=x215",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X216 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         216,
-	Name:          "test_proto.x216",
-	Tag:           "bytes,216,opt,name=x216",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X217 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         217,
-	Name:          "test_proto.x217",
-	Tag:           "bytes,217,opt,name=x217",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X218 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         218,
-	Name:          "test_proto.x218",
-	Tag:           "bytes,218,opt,name=x218",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X219 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         219,
-	Name:          "test_proto.x219",
-	Tag:           "bytes,219,opt,name=x219",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X220 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         220,
-	Name:          "test_proto.x220",
-	Tag:           "bytes,220,opt,name=x220",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X221 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         221,
-	Name:          "test_proto.x221",
-	Tag:           "bytes,221,opt,name=x221",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X222 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         222,
-	Name:          "test_proto.x222",
-	Tag:           "bytes,222,opt,name=x222",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X223 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         223,
-	Name:          "test_proto.x223",
-	Tag:           "bytes,223,opt,name=x223",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X224 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         224,
-	Name:          "test_proto.x224",
-	Tag:           "bytes,224,opt,name=x224",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X225 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         225,
-	Name:          "test_proto.x225",
-	Tag:           "bytes,225,opt,name=x225",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X226 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         226,
-	Name:          "test_proto.x226",
-	Tag:           "bytes,226,opt,name=x226",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X227 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         227,
-	Name:          "test_proto.x227",
-	Tag:           "bytes,227,opt,name=x227",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X228 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         228,
-	Name:          "test_proto.x228",
-	Tag:           "bytes,228,opt,name=x228",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X229 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         229,
-	Name:          "test_proto.x229",
-	Tag:           "bytes,229,opt,name=x229",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X230 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         230,
-	Name:          "test_proto.x230",
-	Tag:           "bytes,230,opt,name=x230",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X231 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         231,
-	Name:          "test_proto.x231",
-	Tag:           "bytes,231,opt,name=x231",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X232 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         232,
-	Name:          "test_proto.x232",
-	Tag:           "bytes,232,opt,name=x232",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X233 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         233,
-	Name:          "test_proto.x233",
-	Tag:           "bytes,233,opt,name=x233",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X234 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         234,
-	Name:          "test_proto.x234",
-	Tag:           "bytes,234,opt,name=x234",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X235 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         235,
-	Name:          "test_proto.x235",
-	Tag:           "bytes,235,opt,name=x235",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X236 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         236,
-	Name:          "test_proto.x236",
-	Tag:           "bytes,236,opt,name=x236",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X237 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         237,
-	Name:          "test_proto.x237",
-	Tag:           "bytes,237,opt,name=x237",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X238 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         238,
-	Name:          "test_proto.x238",
-	Tag:           "bytes,238,opt,name=x238",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X239 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         239,
-	Name:          "test_proto.x239",
-	Tag:           "bytes,239,opt,name=x239",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X240 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         240,
-	Name:          "test_proto.x240",
-	Tag:           "bytes,240,opt,name=x240",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X241 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         241,
-	Name:          "test_proto.x241",
-	Tag:           "bytes,241,opt,name=x241",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X242 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         242,
-	Name:          "test_proto.x242",
-	Tag:           "bytes,242,opt,name=x242",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X243 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         243,
-	Name:          "test_proto.x243",
-	Tag:           "bytes,243,opt,name=x243",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X244 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         244,
-	Name:          "test_proto.x244",
-	Tag:           "bytes,244,opt,name=x244",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X245 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         245,
-	Name:          "test_proto.x245",
-	Tag:           "bytes,245,opt,name=x245",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X246 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         246,
-	Name:          "test_proto.x246",
-	Tag:           "bytes,246,opt,name=x246",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X247 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         247,
-	Name:          "test_proto.x247",
-	Tag:           "bytes,247,opt,name=x247",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X248 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         248,
-	Name:          "test_proto.x248",
-	Tag:           "bytes,248,opt,name=x248",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X249 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         249,
-	Name:          "test_proto.x249",
-	Tag:           "bytes,249,opt,name=x249",
-	Filename:      "test_proto/test.proto",
-}
-
-var E_X250 = &proto.ExtensionDesc{
-	ExtendedType:  (*MyMessageSet)(nil),
-	ExtensionType: (*Empty)(nil),
-	Field:         250,
-	Name:          "test_proto.x250",
-	Tag:           "bytes,250,opt,name=x250",
-	Filename:      "test_proto/test.proto",
+	Name:          "proto2_test.default_enum",
+	Tag:           "varint,216,opt,name=default_enum,enum=proto2_test.DefaultsMessage_DefaultsEnum,def=1",
+	Filename:      "proto2_proto/test.proto",
 }
 
 func init() {
-	proto.RegisterType((*GoEnum)(nil), "test_proto.GoEnum")
-	proto.RegisterType((*GoTestField)(nil), "test_proto.GoTestField")
-	proto.RegisterType((*GoTest)(nil), "test_proto.GoTest")
-	proto.RegisterType((*GoTest_RequiredGroup)(nil), "test_proto.GoTest.RequiredGroup")
-	proto.RegisterType((*GoTest_RepeatedGroup)(nil), "test_proto.GoTest.RepeatedGroup")
-	proto.RegisterType((*GoTest_OptionalGroup)(nil), "test_proto.GoTest.OptionalGroup")
-	proto.RegisterType((*GoTestRequiredGroupField)(nil), "test_proto.GoTestRequiredGroupField")
-	proto.RegisterType((*GoTestRequiredGroupField_Group)(nil), "test_proto.GoTestRequiredGroupField.Group")
-	proto.RegisterType((*GoSkipTest)(nil), "test_proto.GoSkipTest")
-	proto.RegisterType((*GoSkipTest_SkipGroup)(nil), "test_proto.GoSkipTest.SkipGroup")
-	proto.RegisterType((*NonPackedTest)(nil), "test_proto.NonPackedTest")
-	proto.RegisterType((*PackedTest)(nil), "test_proto.PackedTest")
-	proto.RegisterType((*MaxTag)(nil), "test_proto.MaxTag")
-	proto.RegisterType((*OldMessage)(nil), "test_proto.OldMessage")
-	proto.RegisterType((*OldMessage_Nested)(nil), "test_proto.OldMessage.Nested")
-	proto.RegisterType((*NewMessage)(nil), "test_proto.NewMessage")
-	proto.RegisterType((*NewMessage_Nested)(nil), "test_proto.NewMessage.Nested")
-	proto.RegisterType((*InnerMessage)(nil), "test_proto.InnerMessage")
-	proto.RegisterType((*OtherMessage)(nil), "test_proto.OtherMessage")
-	proto.RegisterType((*RequiredInnerMessage)(nil), "test_proto.RequiredInnerMessage")
-	proto.RegisterType((*MyMessage)(nil), "test_proto.MyMessage")
-	proto.RegisterType((*MyMessage_SomeGroup)(nil), "test_proto.MyMessage.SomeGroup")
-	proto.RegisterType((*Ext)(nil), "test_proto.Ext")
-	proto.RegisterMapType((map[int32]int32)(nil), "test_proto.Ext.MapFieldEntry")
-	proto.RegisterType((*ComplexExtension)(nil), "test_proto.ComplexExtension")
-	proto.RegisterType((*DefaultsMessage)(nil), "test_proto.DefaultsMessage")
-	proto.RegisterType((*MyMessageSet)(nil), "test_proto.MyMessageSet")
-	proto.RegisterType((*Empty)(nil), "test_proto.Empty")
-	proto.RegisterType((*MessageList)(nil), "test_proto.MessageList")
-	proto.RegisterType((*MessageList_Message)(nil), "test_proto.MessageList.Message")
-	proto.RegisterType((*Strings)(nil), "test_proto.Strings")
-	proto.RegisterType((*Defaults)(nil), "test_proto.Defaults")
-	proto.RegisterType((*SubDefaults)(nil), "test_proto.SubDefaults")
-	proto.RegisterType((*RepeatedEnum)(nil), "test_proto.RepeatedEnum")
-	proto.RegisterType((*MoreRepeated)(nil), "test_proto.MoreRepeated")
-	proto.RegisterType((*GroupOld)(nil), "test_proto.GroupOld")
-	proto.RegisterType((*GroupOld_G)(nil), "test_proto.GroupOld.G")
-	proto.RegisterType((*GroupNew)(nil), "test_proto.GroupNew")
-	proto.RegisterType((*GroupNew_G)(nil), "test_proto.GroupNew.G")
-	proto.RegisterType((*FloatingPoint)(nil), "test_proto.FloatingPoint")
-	proto.RegisterType((*MessageWithMap)(nil), "test_proto.MessageWithMap")
-	proto.RegisterMapType((map[bool][]byte)(nil), "test_proto.MessageWithMap.ByteMappingEntry")
-	proto.RegisterMapType((map[int64]*FloatingPoint)(nil), "test_proto.MessageWithMap.MsgMappingEntry")
-	proto.RegisterMapType((map[int32]string)(nil), "test_proto.MessageWithMap.NameMappingEntry")
-	proto.RegisterMapType((map[string]string)(nil), "test_proto.MessageWithMap.StrToStrEntry")
-	proto.RegisterType((*Oneof)(nil), "test_proto.Oneof")
-	proto.RegisterType((*Oneof_F_Group)(nil), "test_proto.Oneof.F_Group")
-	proto.RegisterType((*Communique)(nil), "test_proto.Communique")
-	proto.RegisterEnum("test_proto.FOO", FOO_name, FOO_value)
-	proto.RegisterEnum("test_proto.GoTest_KIND", GoTest_KIND_name, GoTest_KIND_value)
-	proto.RegisterEnum("test_proto.MyMessage_Color", MyMessage_Color_name, MyMessage_Color_value)
-	proto.RegisterEnum("test_proto.DefaultsMessage_DefaultsEnum", DefaultsMessage_DefaultsEnum_name, DefaultsMessage_DefaultsEnum_value)
-	proto.RegisterEnum("test_proto.Defaults_Color", Defaults_Color_name, Defaults_Color_value)
-	proto.RegisterEnum("test_proto.RepeatedEnum_Color", RepeatedEnum_Color_name, RepeatedEnum_Color_value)
+	proto.RegisterEnum("proto2_test.FOO", FOO_name, FOO_value)
+	proto.RegisterEnum("proto2_test.GoTest_KIND", GoTest_KIND_name, GoTest_KIND_value)
+	proto.RegisterEnum("proto2_test.MyMessage_Color", MyMessage_Color_name, MyMessage_Color_value)
+	proto.RegisterEnum("proto2_test.DefaultsMessage_DefaultsEnum", DefaultsMessage_DefaultsEnum_name, DefaultsMessage_DefaultsEnum_value)
+	proto.RegisterEnum("proto2_test.Defaults_Color", Defaults_Color_name, Defaults_Color_value)
+	proto.RegisterEnum("proto2_test.RepeatedEnum_Color", RepeatedEnum_Color_name, RepeatedEnum_Color_value)
+	proto.RegisterType((*GoEnum)(nil), "proto2_test.GoEnum")
+	proto.RegisterType((*GoTestField)(nil), "proto2_test.GoTestField")
+	proto.RegisterType((*GoTest)(nil), "proto2_test.GoTest")
+	proto.RegisterType((*GoTest_RequiredGroup)(nil), "proto2_test.GoTest.RequiredGroup")
+	proto.RegisterType((*GoTest_RepeatedGroup)(nil), "proto2_test.GoTest.RepeatedGroup")
+	proto.RegisterType((*GoTest_OptionalGroup)(nil), "proto2_test.GoTest.OptionalGroup")
+	proto.RegisterType((*GoTestRequiredGroupField)(nil), "proto2_test.GoTestRequiredGroupField")
+	proto.RegisterType((*GoTestRequiredGroupField_Group)(nil), "proto2_test.GoTestRequiredGroupField.Group")
+	proto.RegisterType((*GoSkipTest)(nil), "proto2_test.GoSkipTest")
+	proto.RegisterType((*GoSkipTest_SkipGroup)(nil), "proto2_test.GoSkipTest.SkipGroup")
+	proto.RegisterType((*NonPackedTest)(nil), "proto2_test.NonPackedTest")
+	proto.RegisterType((*PackedTest)(nil), "proto2_test.PackedTest")
+	proto.RegisterType((*MaxTag)(nil), "proto2_test.MaxTag")
+	proto.RegisterType((*OldMessage)(nil), "proto2_test.OldMessage")
+	proto.RegisterType((*OldMessage_Nested)(nil), "proto2_test.OldMessage.Nested")
+	proto.RegisterType((*NewMessage)(nil), "proto2_test.NewMessage")
+	proto.RegisterType((*NewMessage_Nested)(nil), "proto2_test.NewMessage.Nested")
+	proto.RegisterType((*InnerMessage)(nil), "proto2_test.InnerMessage")
+	proto.RegisterType((*OtherMessage)(nil), "proto2_test.OtherMessage")
+	proto.RegisterType((*RequiredInnerMessage)(nil), "proto2_test.RequiredInnerMessage")
+	proto.RegisterType((*MyMessage)(nil), "proto2_test.MyMessage")
+	proto.RegisterType((*MyMessage_SomeGroup)(nil), "proto2_test.MyMessage.SomeGroup")
 	proto.RegisterExtension(E_Ext_More)
 	proto.RegisterExtension(E_Ext_Text)
 	proto.RegisterExtension(E_Ext_Number)
+	proto.RegisterType((*Ext)(nil), "proto2_test.Ext")
+	proto.RegisterMapType((map[int32]int32)(nil), "proto2_test.Ext.MapFieldEntry")
+	proto.RegisterType((*ComplexExtension)(nil), "proto2_test.ComplexExtension")
+	proto.RegisterType((*DefaultsMessage)(nil), "proto2_test.DefaultsMessage")
+	proto.RegisterType((*Empty)(nil), "proto2_test.Empty")
+	proto.RegisterType((*MessageList)(nil), "proto2_test.MessageList")
+	proto.RegisterType((*MessageList_Message)(nil), "proto2_test.MessageList.Message")
+	proto.RegisterType((*Strings)(nil), "proto2_test.Strings")
+	proto.RegisterType((*Defaults)(nil), "proto2_test.Defaults")
+	proto.RegisterType((*SubDefaults)(nil), "proto2_test.SubDefaults")
+	proto.RegisterType((*RepeatedEnum)(nil), "proto2_test.RepeatedEnum")
+	proto.RegisterType((*MoreRepeated)(nil), "proto2_test.MoreRepeated")
+	proto.RegisterType((*GroupOld)(nil), "proto2_test.GroupOld")
+	proto.RegisterType((*GroupOld_G)(nil), "proto2_test.GroupOld.G")
+	proto.RegisterType((*GroupNew)(nil), "proto2_test.GroupNew")
+	proto.RegisterType((*GroupNew_G)(nil), "proto2_test.GroupNew.G")
+	proto.RegisterType((*FloatingPoint)(nil), "proto2_test.FloatingPoint")
+	proto.RegisterType((*MessageWithMap)(nil), "proto2_test.MessageWithMap")
+	proto.RegisterMapType((map[bool][]byte)(nil), "proto2_test.MessageWithMap.ByteMappingEntry")
+	proto.RegisterMapType((map[int64]*FloatingPoint)(nil), "proto2_test.MessageWithMap.MsgMappingEntry")
+	proto.RegisterMapType((map[int32]string)(nil), "proto2_test.MessageWithMap.NameMappingEntry")
+	proto.RegisterMapType((map[string]string)(nil), "proto2_test.MessageWithMap.StrToStrEntry")
+	proto.RegisterType((*Oneof)(nil), "proto2_test.Oneof")
+	proto.RegisterType((*Oneof_F_Group)(nil), "proto2_test.Oneof.F_Group")
+	proto.RegisterType((*Communique)(nil), "proto2_test.Communique")
+	proto.RegisterType((*TestUTF8)(nil), "proto2_test.TestUTF8")
+	proto.RegisterMapType((map[string]int64)(nil), "proto2_test.TestUTF8.MapKeyEntry")
+	proto.RegisterMapType((map[int64]string)(nil), "proto2_test.TestUTF8.MapValueEntry")
 	proto.RegisterExtension(E_Greeting)
 	proto.RegisterExtension(E_Complex)
 	proto.RegisterExtension(E_RComplex)
@@ -4766,353 +4076,281 @@ func init() {
 	proto.RegisterExtension(E_DefaultString)
 	proto.RegisterExtension(E_DefaultBytes)
 	proto.RegisterExtension(E_DefaultEnum)
-	proto.RegisterExtension(E_X201)
-	proto.RegisterExtension(E_X202)
-	proto.RegisterExtension(E_X203)
-	proto.RegisterExtension(E_X204)
-	proto.RegisterExtension(E_X205)
-	proto.RegisterExtension(E_X206)
-	proto.RegisterExtension(E_X207)
-	proto.RegisterExtension(E_X208)
-	proto.RegisterExtension(E_X209)
-	proto.RegisterExtension(E_X210)
-	proto.RegisterExtension(E_X211)
-	proto.RegisterExtension(E_X212)
-	proto.RegisterExtension(E_X213)
-	proto.RegisterExtension(E_X214)
-	proto.RegisterExtension(E_X215)
-	proto.RegisterExtension(E_X216)
-	proto.RegisterExtension(E_X217)
-	proto.RegisterExtension(E_X218)
-	proto.RegisterExtension(E_X219)
-	proto.RegisterExtension(E_X220)
-	proto.RegisterExtension(E_X221)
-	proto.RegisterExtension(E_X222)
-	proto.RegisterExtension(E_X223)
-	proto.RegisterExtension(E_X224)
-	proto.RegisterExtension(E_X225)
-	proto.RegisterExtension(E_X226)
-	proto.RegisterExtension(E_X227)
-	proto.RegisterExtension(E_X228)
-	proto.RegisterExtension(E_X229)
-	proto.RegisterExtension(E_X230)
-	proto.RegisterExtension(E_X231)
-	proto.RegisterExtension(E_X232)
-	proto.RegisterExtension(E_X233)
-	proto.RegisterExtension(E_X234)
-	proto.RegisterExtension(E_X235)
-	proto.RegisterExtension(E_X236)
-	proto.RegisterExtension(E_X237)
-	proto.RegisterExtension(E_X238)
-	proto.RegisterExtension(E_X239)
-	proto.RegisterExtension(E_X240)
-	proto.RegisterExtension(E_X241)
-	proto.RegisterExtension(E_X242)
-	proto.RegisterExtension(E_X243)
-	proto.RegisterExtension(E_X244)
-	proto.RegisterExtension(E_X245)
-	proto.RegisterExtension(E_X246)
-	proto.RegisterExtension(E_X247)
-	proto.RegisterExtension(E_X248)
-	proto.RegisterExtension(E_X249)
-	proto.RegisterExtension(E_X250)
-}
-
-func init() { proto.RegisterFile("test_proto/test.proto", fileDescriptor_test_74787bfc6550f8a7) }
-
-var fileDescriptor_test_74787bfc6550f8a7 = []byte{
-	// 4680 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x5b, 0xd9, 0x73, 0x1b, 0x47,
-	0x7a, 0xd7, 0x0c, 0xee, 0x0f, 0x20, 0x31, 0x6c, 0xd1, 0x12, 0x44, 0x59, 0xd2, 0x08, 0x6b, 0xaf,
-	0x61, 0xc9, 0xa2, 0x48, 0x60, 0x08, 0x49, 0x70, 0xec, 0xb2, 0x0e, 0x82, 0x62, 0x49, 0x24, 0xe4,
-	0x21, 0x6d, 0x67, 0x95, 0x07, 0x14, 0x48, 0x0c, 0x40, 0xac, 0x80, 0x19, 0x18, 0x18, 0x44, 0x64,
-	0x52, 0xa9, 0xf2, 0x63, 0xaa, 0xf2, 0x94, 0x4d, 0x52, 0x95, 0xf7, 0xbc, 0xe4, 0x25, 0xd7, 0x43,
-	0xf2, 0x37, 0xc4, 0xd7, 0x5e, 0xde, 0x2b, 0xc9, 0x26, 0x9b, 0xfb, 0xce, 0xe6, 0xde, 0x23, 0x2f,
-	0x4e, 0xf5, 0xd7, 0x3d, 0x33, 0x3d, 0x03, 0xa8, 0x45, 0x3e, 0x71, 0xa6, 0xfb, 0xf7, 0xfd, 0xfa,
-	0xfa, 0xf5, 0xf7, 0xf5, 0xd7, 0x18, 0xc2, 0x0b, 0xae, 0x35, 0x76, 0x9b, 0xc3, 0x91, 0xe3, 0x3a,
-	0xd7, 0xe9, 0xe3, 0x32, 0x3e, 0x12, 0x08, 0x8a, 0x8b, 0x57, 0x21, 0xb9, 0xe1, 0xac, 0xdb, 0x93,
-	0x01, 0xb9, 0x0c, 0xb1, 0x8e, 0xe3, 0x14, 0x14, 0x5d, 0x2d, 0xcd, 0x97, 0xf3, 0xcb, 0x01, 0x66,
-	0xb9, 0xde, 0x68, 0x98, 0xb4, 0xae, 0x78, 0x03, 0xb2, 0x1b, 0xce, 0xae, 0x35, 0x76, 0xeb, 0x3d,
-	0xab, 0xdf, 0x26, 0x8b, 0x90, 0x78, 0xd8, 0xda, 0xb3, 0xfa, 0x68, 0x93, 0x31, 0xd9, 0x0b, 0x21,
-	0x10, 0xdf, 0x3d, 0x1a, 0x5a, 0x05, 0x15, 0x0b, 0xf1, 0xb9, 0xf8, 0x87, 0x45, 0xda, 0x0c, 0xb5,
-	0x24, 0x57, 0x21, 0xfe, 0xa0, 0x67, 0xb7, 0x79, 0x3b, 0x67, 0xc5, 0x76, 0x18, 0x62, 0xf9, 0xc1,
-	0xe6, 0xf6, 0x3d, 0x13, 0x41, 0xb4, 0x85, 0xdd, 0xd6, 0x5e, 0x9f, 0x92, 0x29, 0xb4, 0x05, 0x7c,
-	0xa1, 0xa5, 0x8f, 0x5a, 0xa3, 0xd6, 0xa0, 0x10, 0xd3, 0x95, 0x52, 0xc2, 0x64, 0x2f, 0xe4, 0x0d,
-	0x98, 0x33, 0xad, 0xf7, 0x27, 0xbd, 0x91, 0xd5, 0xc6, 0xee, 0x15, 0xe2, 0xba, 0x5a, 0xca, 0xce,
-	0x6a, 0x01, 0xab, 0xcd, 0x30, 0x9a, 0x99, 0x0f, 0xad, 0x96, 0xeb, 0x99, 0x27, 0xf4, 0xd8, 0x73,
-	0xcc, 0x05, 0x34, 0x35, 0x6f, 0x0c, 0xdd, 0x9e, 0x63, 0xb7, 0xfa, 0xcc, 0x3c, 0xa9, 0x2b, 0x52,
-	0xf3, 0x10, 0x9a, 0x7c, 0x11, 0xf2, 0xf5, 0xe6, 0x1d, 0xc7, 0xe9, 0x37, 0x47, 0xbc, 0x57, 0x05,
-	0xd0, 0xd5, 0x52, 0xda, 0x9c, 0xab, 0xd3, 0x52, 0xaf, 0xab, 0xa4, 0x04, 0x5a, 0xbd, 0xb9, 0x69,
-	0xbb, 0x95, 0x72, 0x00, 0xcc, 0xea, 0x6a, 0x29, 0x61, 0xce, 0xd7, 0xb1, 0x78, 0x0a, 0x59, 0x35,
-	0x02, 0x64, 0x4e, 0x57, 0x4b, 0x31, 0x86, 0xac, 0x1a, 0x3e, 0xf2, 0x35, 0x20, 0xf5, 0x66, 0xbd,
-	0x77, 0x68, 0xb5, 0x45, 0xd6, 0x39, 0x5d, 0x2d, 0xa5, 0x4c, 0xad, 0xce, 0x2b, 0x66, 0xa0, 0x45,
-	0xe6, 0x79, 0x5d, 0x2d, 0x25, 0x3d, 0xb4, 0xc0, 0x7d, 0x05, 0x16, 0xea, 0xcd, 0x77, 0x7a, 0xe1,
-	0x0e, 0xe7, 0x75, 0xb5, 0x34, 0x67, 0xe6, 0xeb, 0xac, 0x7c, 0x1a, 0x2b, 0x12, 0x6b, 0xba, 0x5a,
-	0x8a, 0x73, 0xac, 0xc0, 0x8b, 0xa3, 0xab, 0xf7, 0x9d, 0x96, 0x1b, 0x40, 0x17, 0x74, 0xb5, 0xa4,
-	0x9a, 0xf3, 0x75, 0x2c, 0x0e, 0xb3, 0xde, 0x73, 0x26, 0x7b, 0x7d, 0x2b, 0x80, 0x12, 0x5d, 0x2d,
-	0x29, 0x66, 0xbe, 0xce, 0xca, 0xc3, 0xd8, 0x1d, 0x77, 0xd4, 0xb3, 0xbb, 0x01, 0xf6, 0x34, 0xea,
-	0x38, 0x5f, 0x67, 0xe5, 0xe1, 0x1e, 0xdc, 0x39, 0x72, 0xad, 0x71, 0x00, 0xb5, 0x74, 0xb5, 0x94,
-	0x33, 0xe7, 0xeb, 0x58, 0x1c, 0x61, 0x8d, 0xcc, 0x41, 0x47, 0x57, 0x4b, 0x0b, 0x94, 0x75, 0xc6,
-	0x1c, 0xec, 0x44, 0xe6, 0xa0, 0xab, 0xab, 0x25, 0xc2, 0xb1, 0xc2, 0x1c, 0x2c, 0xc3, 0xe9, 0x7a,
-	0x73, 0xa7, 0x13, 0x5d, 0xb8, 0x03, 0x5d, 0x2d, 0xe5, 0xcd, 0x85, 0xba, 0x57, 0x33, 0x0b, 0x2f,
-	0xb2, 0xf7, 0x74, 0xb5, 0xa4, 0xf9, 0x78, 0x81, 0x5f, 0xd4, 0x24, 0x93, 0x7a, 0x61, 0x51, 0x8f,
-	0x09, 0x9a, 0x64, 0x85, 0x61, 0x4d, 0x72, 0xe0, 0x0b, 0x7a, 0x4c, 0xd4, 0x64, 0x04, 0x89, 0xcd,
-	0x73, 0xe4, 0x19, 0x3d, 0x26, 0x6a, 0x92, 0x23, 0x23, 0x9a, 0xe4, 0xd8, 0xb3, 0x7a, 0x2c, 0xac,
-	0xc9, 0x29, 0xb4, 0xc8, 0x5c, 0xd0, 0x63, 0x61, 0x4d, 0x72, 0x74, 0x58, 0x93, 0x1c, 0x7c, 0x4e,
-	0x8f, 0x85, 0x34, 0x19, 0xc5, 0x8a, 0xc4, 0x4b, 0x7a, 0x2c, 0xa4, 0x49, 0x71, 0x74, 0x9e, 0x26,
-	0x39, 0xf4, 0xbc, 0x1e, 0x13, 0x35, 0x29, 0xb2, 0xfa, 0x9a, 0xe4, 0xd0, 0x17, 0xf5, 0x58, 0x48,
-	0x93, 0x22, 0xd6, 0xd7, 0x24, 0xc7, 0x5e, 0xd0, 0x63, 0x21, 0x4d, 0x72, 0xec, 0xab, 0xa2, 0x26,
-	0x39, 0xf4, 0x43, 0x45, 0x8f, 0x89, 0xa2, 0xe4, 0xd0, 0xab, 0x21, 0x51, 0x72, 0xec, 0x47, 0x14,
-	0x2b, 0xaa, 0x32, 0x0a, 0x16, 0x67, 0xe1, 0x63, 0x0a, 0x16, 0x65, 0xc9, 0xc1, 0xd7, 0x23, 0xb2,
-	0xe4, 0xf0, 0x4f, 0x28, 0x3c, 0xac, 0xcb, 0x69, 0x03, 0x91, 0xff, 0x53, 0x6a, 0x10, 0x16, 0x26,
-	0x37, 0x08, 0x84, 0xe9, 0x70, 0x27, 0x5a, 0xb8, 0xa8, 0x2b, 0xbe, 0x30, 0x3d, 0xcf, 0x2a, 0x0a,
-	0xd3, 0x07, 0x5e, 0xc2, 0x90, 0xc1, 0x85, 0x39, 0x85, 0xac, 0x1a, 0x01, 0x52, 0xd7, 0x95, 0x40,
-	0x98, 0x3e, 0x32, 0x24, 0x4c, 0x1f, 0x7b, 0x59, 0x57, 0x44, 0x61, 0xce, 0x40, 0x8b, 0xcc, 0x45,
-	0x5d, 0x11, 0x85, 0xe9, 0xa3, 0x45, 0x61, 0xfa, 0xe0, 0x2f, 0xe8, 0x8a, 0x20, 0xcc, 0x69, 0xac,
-	0x48, 0xfc, 0x92, 0xae, 0x08, 0xc2, 0x0c, 0x8f, 0x8e, 0x09, 0xd3, 0x87, 0xbe, 0xac, 0x2b, 0x81,
-	0x30, 0xc3, 0xac, 0x5c, 0x98, 0x3e, 0xf4, 0x8b, 0xba, 0x22, 0x08, 0x33, 0x8c, 0xe5, 0xc2, 0xf4,
-	0xb1, 0xaf, 0x60, 0x9c, 0xf6, 0x84, 0xe9, 0x63, 0x05, 0x61, 0xfa, 0xd0, 0xdf, 0xa1, 0x31, 0xdd,
-	0x17, 0xa6, 0x0f, 0x15, 0x85, 0xe9, 0x63, 0x7f, 0x97, 0x62, 0x03, 0x61, 0x4e, 0x83, 0xc5, 0x59,
-	0xf8, 0x3d, 0x0a, 0x0e, 0x84, 0xe9, 0x83, 0xc3, 0xc2, 0xf4, 0xe1, 0xbf, 0x4f, 0xe1, 0xa2, 0x30,
-	0x67, 0x19, 0x88, 0xfc, 0x7f, 0x40, 0x0d, 0x44, 0x61, 0xfa, 0x06, 0xcb, 0x38, 0x4c, 0x2a, 0xcc,
-	0xb6, 0xd5, 0x69, 0x4d, 0xfa, 0x54, 0xc6, 0x25, 0xaa, 0xcc, 0x5a, 0xdc, 0x1d, 0x4d, 0x2c, 0x3a,
-	0x56, 0xc7, 0xe9, 0xdf, 0xf3, 0xea, 0xc8, 0x32, 0xed, 0x3e, 0x13, 0x68, 0x60, 0xf0, 0x2a, 0x55,
-	0x68, 0x4d, 0xad, 0x94, 0xcd, 0x3c, 0x53, 0xe9, 0x34, 0xbe, 0x6a, 0x08, 0xf8, 0x2b, 0x54, 0xa7,
-	0x35, 0xb5, 0x6a, 0x30, 0x7c, 0xd5, 0x08, 0xf0, 0x15, 0x3a, 0x00, 0x4f, 0xac, 0x81, 0xc5, 0x55,
-	0xaa, 0xd6, 0x5a, 0xac, 0x52, 0x5e, 0x31, 0x17, 0x3c, 0xc9, 0xce, 0x32, 0x0a, 0x35, 0xf3, 0x1a,
-	0x15, 0x6d, 0x2d, 0x56, 0x35, 0x7c, 0x23, 0xb1, 0xa5, 0x32, 0x15, 0x3a, 0x97, 0x6e, 0x60, 0x73,
-	0x8d, 0x6a, 0xb7, 0x16, 0xaf, 0x94, 0x57, 0x56, 0x4c, 0x8d, 0x2b, 0x78, 0x86, 0x4d, 0xa8, 0x9d,
-	0x65, 0xaa, 0xe1, 0x5a, 0xbc, 0x6a, 0xf8, 0x36, 0xe1, 0x76, 0x16, 0x3c, 0x29, 0x07, 0x26, 0xd7,
-	0xa9, 0x96, 0x6b, 0xc9, 0xca, 0xaa, 0xb1, 0xba, 0x76, 0xcb, 0xcc, 0x33, 0x4d, 0x07, 0x36, 0x06,
-	0x6d, 0x87, 0x8b, 0x3a, 0x30, 0x5a, 0xa1, 0xaa, 0xae, 0x25, 0xcb, 0x37, 0x56, 0x6f, 0x96, 0x6f,
-	0x9a, 0x1a, 0x57, 0x77, 0x60, 0xf5, 0x26, 0xb5, 0xe2, 0xf2, 0x0e, 0xac, 0x56, 0xa9, 0xbe, 0x6b,
-	0xda, 0x81, 0xd5, 0xef, 0x3b, 0xaf, 0xe9, 0xc5, 0xa7, 0xce, 0xa8, 0xdf, 0xbe, 0x5c, 0x04, 0x53,
-	0xe3, 0x8a, 0x17, 0x5b, 0x5d, 0xf0, 0x24, 0x1f, 0x98, 0xff, 0x2a, 0x3d, 0xb1, 0xe6, 0x6a, 0xa9,
-	0x3b, 0xbd, 0xae, 0xed, 0x8c, 0x2d, 0x33, 0xcf, 0xc4, 0x1f, 0x99, 0x93, 0x9d, 0xe8, 0x3c, 0x7e,
-	0x85, 0x9a, 0x2d, 0xd4, 0x62, 0xd7, 0x2a, 0x65, 0xda, 0xd2, 0xac, 0x79, 0xdc, 0x89, 0xce, 0xe3,
-	0xaf, 0x51, 0x1b, 0x52, 0x8b, 0x5d, 0xab, 0x1a, 0xdc, 0x46, 0x9c, 0xc7, 0x2a, 0x2c, 0x0a, 0x7b,
-	0x21, 0xb0, 0xfa, 0x75, 0x6a, 0x95, 0x67, 0x2d, 0x11, 0x7f, 0x47, 0xcc, 0xb4, 0x0b, 0xb5, 0xf6,
-	0x1b, 0xd4, 0x4e, 0x63, 0xad, 0x11, 0x7f, 0x63, 0x04, 0x76, 0x37, 0xe0, 0x4c, 0xe4, 0x2c, 0xd1,
-	0x1c, 0xb6, 0xf6, 0x9f, 0x58, 0xed, 0x42, 0x99, 0x1e, 0x29, 0xee, 0xa8, 0x9a, 0x62, 0x9e, 0x0e,
-	0x1d, 0x2b, 0x1e, 0x61, 0x35, 0xb9, 0x05, 0x67, 0xa3, 0x87, 0x0b, 0xcf, 0xb2, 0x42, 0xcf, 0x18,
-	0x68, 0xb9, 0x18, 0x3e, 0x67, 0x44, 0x4c, 0x85, 0xa0, 0xe2, 0x99, 0x1a, 0xf4, 0xd0, 0x11, 0x98,
-	0x06, 0xb1, 0x85, 0x9b, 0xbe, 0x01, 0xe7, 0xa6, 0x8f, 0x1f, 0x9e, 0xf1, 0x1a, 0x3d, 0x85, 0xa0,
-	0xf1, 0x99, 0xe8, 0x49, 0x64, 0xca, 0x7c, 0x46, 0xdb, 0x55, 0x7a, 0x2c, 0x11, 0xcd, 0xa7, 0x5a,
-	0x7f, 0x1d, 0x0a, 0x53, 0x07, 0x14, 0xcf, 0xfa, 0x06, 0x3d, 0xa7, 0xa0, 0xf5, 0x0b, 0x91, 0xb3,
-	0x4a, 0xd4, 0x78, 0x46, 0xd3, 0x37, 0xe9, 0xc1, 0x45, 0x30, 0x9e, 0x6a, 0x19, 0xa7, 0x2c, 0x7c,
-	0x84, 0xf1, 0x6c, 0x6f, 0xd1, 0x93, 0x0c, 0x9f, 0xb2, 0xd0, 0x69, 0x46, 0x6c, 0x37, 0x72, 0xa6,
-	0xf1, 0x6c, 0x6b, 0xf4, 0x68, 0xc3, 0xdb, 0x0d, 0x1f, 0x6f, 0xb8, 0xf1, 0xcf, 0x50, 0xe3, 0x9d,
-	0xd9, 0x23, 0xfe, 0x51, 0x8c, 0x1e, 0x4a, 0xb8, 0xf5, 0xce, 0xac, 0x21, 0xfb, 0xd6, 0x33, 0x86,
-	0xfc, 0x63, 0x6a, 0x4d, 0x04, 0xeb, 0xa9, 0x31, 0xbf, 0x05, 0x4b, 0x33, 0xce, 0x2b, 0x9e, 0xfd,
-	0x4f, 0xa8, 0x7d, 0x1e, 0xed, 0xcf, 0x4e, 0x1d, 0x5d, 0xa6, 0x19, 0x66, 0xf4, 0xe0, 0xa7, 0x94,
-	0x41, 0x0b, 0x31, 0x4c, 0xf5, 0xa1, 0x0e, 0x73, 0xde, 0x79, 0xbc, 0x3b, 0x72, 0x26, 0xc3, 0x42,
-	0x5d, 0x57, 0x4b, 0x50, 0xd6, 0x67, 0x64, 0xc7, 0xde, 0xf1, 0x7c, 0x83, 0xe2, 0xcc, 0xb0, 0x19,
-	0xe3, 0x61, 0xcc, 0x8c, 0xe7, 0x91, 0x1e, 0x7b, 0x26, 0x0f, 0xc3, 0xf9, 0x3c, 0x82, 0x19, 0xe5,
-	0xf1, 0xc2, 0x1d, 0xe3, 0x79, 0xac, 0x2b, 0xcf, 0xe0, 0xf1, 0x82, 0x1f, 0xe7, 0x09, 0x99, 0x2d,
-	0xad, 0x05, 0x39, 0x39, 0xd6, 0x93, 0x97, 0xa2, 0x49, 0xfa, 0x06, 0x66, 0x57, 0xe1, 0x42, 0x66,
-	0x26, 0x74, 0x6f, 0xda, 0xec, 0xed, 0x67, 0x98, 0x85, 0x7a, 0x33, 0x6d, 0xf6, 0x73, 0x33, 0xcc,
-	0x8a, 0xbf, 0xa9, 0x40, 0xfc, 0xc1, 0xe6, 0xf6, 0x3d, 0x92, 0x86, 0xf8, 0xbb, 0x8d, 0xcd, 0x7b,
-	0xda, 0x29, 0xfa, 0x74, 0xa7, 0xd1, 0x78, 0xa8, 0x29, 0x24, 0x03, 0x89, 0x3b, 0x5f, 0xda, 0x5d,
-	0xdf, 0xd1, 0x54, 0x92, 0x87, 0x6c, 0x7d, 0x73, 0x7b, 0x63, 0xdd, 0x7c, 0x64, 0x6e, 0x6e, 0xef,
-	0x6a, 0x31, 0x5a, 0x57, 0x7f, 0xd8, 0xb8, 0xbd, 0xab, 0xc5, 0x49, 0x0a, 0x62, 0xb4, 0x2c, 0x41,
-	0x00, 0x92, 0x3b, 0xbb, 0xe6, 0xe6, 0xf6, 0x86, 0x96, 0xa4, 0x2c, 0xbb, 0x9b, 0x5b, 0xeb, 0x5a,
-	0x8a, 0x22, 0x77, 0xdf, 0x79, 0xf4, 0x70, 0x5d, 0x4b, 0xd3, 0xc7, 0xdb, 0xa6, 0x79, 0xfb, 0x4b,
-	0x5a, 0x86, 0x1a, 0x6d, 0xdd, 0x7e, 0xa4, 0x01, 0x56, 0xdf, 0xbe, 0xf3, 0x70, 0x5d, 0xcb, 0x92,
-	0x1c, 0xa4, 0xeb, 0xef, 0x6c, 0xdf, 0xdd, 0xdd, 0x6c, 0x6c, 0x6b, 0xb9, 0xe2, 0x2f, 0x42, 0x81,
-	0x4d, 0x73, 0x68, 0x16, 0xd9, 0x95, 0xc1, 0x5b, 0x90, 0x60, 0x6b, 0xa3, 0xa0, 0x56, 0xae, 0x4c,
-	0xaf, 0xcd, 0xb4, 0xd1, 0x32, 0x5b, 0x25, 0x66, 0xb8, 0x74, 0x01, 0x12, 0x6c, 0x9e, 0x16, 0x21,
-	0xc1, 0xe6, 0x47, 0xc5, 0xab, 0x04, 0xf6, 0x52, 0xfc, 0x2d, 0x15, 0x60, 0xc3, 0xd9, 0x79, 0xd2,
-	0x1b, 0xe2, 0xc5, 0xcd, 0x05, 0x80, 0xf1, 0x93, 0xde, 0xb0, 0x89, 0x3b, 0x90, 0x5f, 0x3a, 0x64,
-	0x68, 0x09, 0xfa, 0x5e, 0x72, 0x19, 0x72, 0x58, 0xcd, 0xb7, 0x08, 0xde, 0x35, 0xa4, 0xcc, 0x2c,
-	0x2d, 0xe3, 0x4e, 0x32, 0x0c, 0xa9, 0x1a, 0x78, 0xc5, 0x90, 0x14, 0x20, 0x55, 0x83, 0x5c, 0x02,
-	0x7c, 0x6d, 0x8e, 0x31, 0x9a, 0xe2, 0xb5, 0x42, 0xc6, 0xc4, 0x76, 0x59, 0x7c, 0x25, 0x6f, 0x02,
-	0xb6, 0xc9, 0x46, 0x9e, 0x9f, 0xb5, 0x4b, 0xbc, 0x0e, 0x2f, 0xd3, 0x07, 0x36, 0xde, 0xc0, 0x64,
-	0xa9, 0x01, 0x19, 0xbf, 0x9c, 0xb6, 0x86, 0xa5, 0x7c, 0x4c, 0x1a, 0x8e, 0x09, 0xb0, 0xc8, 0x1f,
-	0x14, 0x03, 0xf0, 0xfe, 0x2c, 0x60, 0x7f, 0x98, 0x11, 0xeb, 0x50, 0xf1, 0x02, 0xcc, 0x6d, 0x3b,
-	0x36, 0xdb, 0xc7, 0x38, 0x4f, 0x39, 0x50, 0x5a, 0x05, 0x05, 0xf3, 0x5f, 0xa5, 0x55, 0xbc, 0x08,
-	0x20, 0xd4, 0x69, 0xa0, 0xec, 0xb1, 0x3a, 0xf4, 0x07, 0xca, 0x5e, 0xf1, 0x2a, 0x24, 0xb7, 0x5a,
-	0x87, 0xbb, 0xad, 0x2e, 0xb9, 0x0c, 0xd0, 0x6f, 0x8d, 0xdd, 0x66, 0x07, 0x57, 0xe2, 0xf3, 0xcf,
-	0x3f, 0xff, 0x5c, 0xc1, 0xc3, 0x74, 0x86, 0x96, 0xb2, 0x15, 0x19, 0x03, 0x34, 0xfa, 0xed, 0x2d,
-	0x6b, 0x3c, 0x6e, 0x75, 0x2d, 0xb2, 0x06, 0x49, 0xdb, 0x1a, 0xd3, 0xe8, 0xab, 0xe0, 0x5d, 0xd3,
-	0x05, 0x71, 0x1e, 0x02, 0xdc, 0xf2, 0x36, 0x82, 0x4c, 0x0e, 0x26, 0x1a, 0xc4, 0xec, 0xc9, 0x00,
-	0x6f, 0xd4, 0x12, 0x26, 0x7d, 0x5c, 0x7a, 0x11, 0x92, 0x0c, 0x43, 0x08, 0xc4, 0xed, 0xd6, 0xc0,
-	0x2a, 0xb0, 0x96, 0xf1, 0xb9, 0xf8, 0x15, 0x05, 0x60, 0xdb, 0x7a, 0x7a, 0xac, 0x56, 0x03, 0x9c,
-	0xa4, 0xd5, 0x18, 0x6b, 0xf5, 0x75, 0x59, 0xab, 0x54, 0x6d, 0x1d, 0xc7, 0x69, 0x37, 0xd9, 0x42,
-	0xb3, 0xeb, 0xbf, 0x0c, 0x2d, 0xc1, 0x95, 0x2b, 0x3e, 0x86, 0xdc, 0xa6, 0x6d, 0x5b, 0x23, 0xaf,
-	0x57, 0x04, 0xe2, 0x07, 0xce, 0xd8, 0xe5, 0x37, 0x91, 0xf8, 0x4c, 0x0a, 0x10, 0x1f, 0x3a, 0x23,
-	0x97, 0x8d, 0xb4, 0x16, 0x37, 0x56, 0x56, 0x56, 0x4c, 0x2c, 0x21, 0x2f, 0x42, 0x66, 0xdf, 0xb1,
-	0x6d, 0x6b, 0x9f, 0x0e, 0x23, 0x86, 0xa9, 0x63, 0x50, 0x50, 0xfc, 0x65, 0x05, 0x72, 0x0d, 0xf7,
-	0x20, 0x20, 0xd7, 0x20, 0xf6, 0xc4, 0x3a, 0xc2, 0xee, 0xc5, 0x4c, 0xfa, 0x48, 0x37, 0xcc, 0xcf,
-	0xb7, 0xfa, 0x13, 0x76, 0x2f, 0x99, 0x33, 0xd9, 0x0b, 0x39, 0x03, 0xc9, 0xa7, 0x56, 0xaf, 0x7b,
-	0xe0, 0x22, 0xa7, 0x6a, 0xf2, 0x37, 0xb2, 0x0c, 0x89, 0x1e, 0xed, 0x6c, 0x21, 0x8e, 0x33, 0x56,
-	0x10, 0x67, 0x4c, 0x1c, 0x85, 0xc9, 0x60, 0x57, 0xd2, 0xe9, 0xb6, 0xf6, 0xc1, 0x07, 0x1f, 0x7c,
-	0xa0, 0x16, 0x0f, 0x60, 0xd1, 0xdb, 0xc4, 0xa1, 0xe1, 0x3e, 0x82, 0x42, 0xdf, 0x72, 0x9a, 0x9d,
-	0x9e, 0xdd, 0xea, 0xf7, 0x8f, 0x9a, 0x4f, 0x1d, 0xbb, 0xd9, 0xb2, 0x9b, 0xce, 0x78, 0xbf, 0x35,
-	0xc2, 0x29, 0x90, 0x35, 0xb2, 0xd8, 0xb7, 0x9c, 0x3a, 0x33, 0x7c, 0xcf, 0xb1, 0x6f, 0xdb, 0x0d,
-	0x6a, 0x55, 0xfc, 0x2c, 0x0e, 0x99, 0xad, 0x23, 0x8f, 0x7f, 0x11, 0x12, 0xfb, 0xce, 0xc4, 0x66,
-	0xf3, 0x99, 0x30, 0xd9, 0x8b, 0xbf, 0x4e, 0xaa, 0xb0, 0x4e, 0x8b, 0x90, 0x78, 0x7f, 0xe2, 0xb8,
-	0x16, 0x0e, 0x39, 0x63, 0xb2, 0x17, 0x3a, 0x63, 0x43, 0xcb, 0x2d, 0xc4, 0xf1, 0x9a, 0x82, 0x3e,
-	0x06, 0x73, 0x90, 0x38, 0xd6, 0x1c, 0x90, 0x15, 0x48, 0x3a, 0x74, 0x0d, 0xc6, 0x85, 0x24, 0xde,
-	0xc3, 0x86, 0x0c, 0xc4, 0xd5, 0x31, 0x39, 0x8e, 0x3c, 0x80, 0x85, 0xa7, 0x56, 0x73, 0x30, 0x19,
-	0xbb, 0xcd, 0xae, 0xd3, 0x6c, 0x5b, 0xd6, 0xd0, 0x1a, 0x15, 0xe6, 0xb0, 0xb5, 0x90, 0x87, 0x98,
-	0x35, 0xa1, 0xe6, 0xfc, 0x53, 0x6b, 0x6b, 0x32, 0x76, 0x37, 0x9c, 0x7b, 0x68, 0x47, 0xd6, 0x20,
-	0x33, 0xb2, 0xa8, 0x5f, 0xa0, 0x5d, 0xce, 0x4d, 0xf7, 0x20, 0x64, 0x9c, 0x1e, 0x59, 0x43, 0x2c,
-	0x20, 0x37, 0x20, 0xbd, 0xd7, 0x7b, 0x62, 0x8d, 0x0f, 0xac, 0x76, 0x21, 0xa5, 0x2b, 0xa5, 0xf9,
-	0xf2, 0x79, 0xd1, 0xca, 0x9f, 0xe0, 0xe5, 0xbb, 0x4e, 0xdf, 0x19, 0x99, 0x3e, 0x98, 0xbc, 0x01,
-	0x99, 0xb1, 0x33, 0xb0, 0x98, 0xda, 0xd3, 0x18, 0x6c, 0x2f, 0xcd, 0xb6, 0xdc, 0x71, 0x06, 0x96,
-	0xe7, 0xd5, 0x3c, 0x0b, 0x72, 0x9e, 0x75, 0x77, 0x8f, 0x26, 0x13, 0x05, 0xc0, 0x0b, 0x1f, 0xda,
-	0x29, 0x4c, 0x2e, 0xc8, 0x12, 0xed, 0x54, 0xb7, 0x43, 0xcf, 0x6c, 0x85, 0x2c, 0xe6, 0xf2, 0xfe,
-	0xfb, 0xd2, 0x6b, 0x90, 0xf1, 0x09, 0x03, 0x77, 0xc8, 0x5c, 0x50, 0x06, 0x3d, 0x04, 0x73, 0x87,
-	0xcc, 0xff, 0xbc, 0x0c, 0x09, 0xec, 0x38, 0x8d, 0x5c, 0xe6, 0x3a, 0x0d, 0x94, 0x19, 0x48, 0x6c,
-	0x98, 0xeb, 0xeb, 0xdb, 0x9a, 0x82, 0x31, 0xf3, 0xe1, 0x3b, 0xeb, 0x9a, 0x2a, 0xe8, 0xf7, 0xb7,
-	0x55, 0x88, 0xad, 0x1f, 0xa2, 0x72, 0xda, 0x2d, 0xb7, 0xe5, 0xed, 0x70, 0xfa, 0x4c, 0x6a, 0x90,
-	0x19, 0xb4, 0xbc, 0xb6, 0x54, 0x9c, 0xe2, 0x90, 0x2f, 0x59, 0x3f, 0x74, 0x97, 0xb7, 0x5a, 0xac,
-	0xe5, 0x75, 0xdb, 0x1d, 0x1d, 0x99, 0xe9, 0x01, 0x7f, 0x5d, 0x7a, 0x1d, 0xe6, 0x42, 0x55, 0xe2,
-	0x16, 0x4d, 0xcc, 0xd8, 0xa2, 0x09, 0xbe, 0x45, 0x6b, 0xea, 0x4d, 0xa5, 0x5c, 0x83, 0xf8, 0xc0,
-	0x19, 0x59, 0xe4, 0x85, 0x99, 0x13, 0x5c, 0xe8, 0xa2, 0x64, 0xf2, 0x91, 0xae, 0x98, 0x68, 0x53,
-	0x7e, 0x15, 0xe2, 0xae, 0x75, 0xe8, 0x3e, 0xcb, 0xf6, 0x80, 0x8d, 0x8f, 0x42, 0xca, 0xd7, 0x20,
-	0x69, 0x4f, 0x06, 0x7b, 0xd6, 0xe8, 0x59, 0xe0, 0x1e, 0x76, 0x8c, 0x83, 0x8a, 0xef, 0x82, 0x76,
-	0xd7, 0x19, 0x0c, 0xfb, 0xd6, 0xe1, 0xfa, 0xa1, 0x6b, 0xd9, 0xe3, 0x9e, 0x63, 0xd3, 0x31, 0x74,
-	0x7a, 0x23, 0x74, 0x6b, 0x38, 0x06, 0x7c, 0xa1, 0x6e, 0x66, 0x6c, 0xed, 0x3b, 0x76, 0x9b, 0x0f,
-	0x8d, 0xbf, 0x51, 0xb4, 0x7b, 0xd0, 0x1b, 0x51, 0x8f, 0x46, 0x83, 0x0f, 0x7b, 0x29, 0x6e, 0x40,
-	0x9e, 0xa7, 0x61, 0x63, 0xde, 0x70, 0xf1, 0x0a, 0xe4, 0xbc, 0x22, 0xfc, 0xe5, 0x27, 0x0d, 0xf1,
-	0xc7, 0xeb, 0x66, 0x43, 0x3b, 0x45, 0xd7, 0xb5, 0xb1, 0xbd, 0xae, 0x29, 0xf4, 0x61, 0xf7, 0xbd,
-	0x46, 0x68, 0x2d, 0x5f, 0x84, 0x9c, 0xdf, 0xf7, 0x1d, 0xcb, 0xc5, 0x1a, 0x1a, 0xa5, 0x52, 0x35,
-	0x35, 0xad, 0x14, 0x53, 0x90, 0x58, 0x1f, 0x0c, 0xdd, 0xa3, 0xe2, 0x2f, 0x41, 0x96, 0x83, 0x1e,
-	0xf6, 0xc6, 0x2e, 0xb9, 0x05, 0xa9, 0x01, 0x1f, 0xaf, 0x82, 0x67, 0xd1, 0xb0, 0xac, 0x03, 0xa4,
-	0xf7, 0x6c, 0x7a, 0xf8, 0xa5, 0x0a, 0xa4, 0x04, 0xf7, 0xce, 0x3d, 0x8f, 0x2a, 0x7a, 0x1e, 0xe6,
-	0xa3, 0x62, 0x82, 0x8f, 0x2a, 0x6e, 0x41, 0x8a, 0x05, 0xe6, 0x31, 0x1e, 0x37, 0x58, 0xfe, 0xce,
-	0x34, 0xc6, 0xc4, 0x97, 0x65, 0x65, 0xec, 0x0c, 0x75, 0x09, 0xb2, 0xb8, 0x67, 0x7c, 0x15, 0x52,
-	0x6f, 0x0e, 0x58, 0xc4, 0x14, 0xff, 0x47, 0x09, 0x48, 0x7b, 0x73, 0x45, 0xce, 0x43, 0x92, 0x25,
-	0xb1, 0x48, 0xe5, 0x5d, 0xea, 0x24, 0x30, 0x6d, 0x25, 0xe7, 0x21, 0xc5, 0x13, 0x55, 0x1e, 0x70,
-	0xd4, 0x4a, 0xd9, 0x4c, 0xb2, 0xc4, 0xd4, 0xaf, 0xac, 0x1a, 0xe8, 0x27, 0xd9, 0x75, 0x4d, 0x92,
-	0xa5, 0x9e, 0x44, 0x87, 0x8c, 0x9f, 0x6c, 0x62, 0x88, 0xe0, 0x77, 0x33, 0x69, 0x2f, 0xbb, 0x14,
-	0x10, 0x55, 0x03, 0x1d, 0x28, 0xbf, 0x88, 0x49, 0xd7, 0x83, 0x73, 0x53, 0xda, 0x4b, 0x19, 0xf1,
-	0x97, 0x27, 0xef, 0xd6, 0x25, 0xc5, 0x93, 0xc4, 0x00, 0x50, 0x35, 0xd0, 0x33, 0x79, 0x57, 0x2c,
-	0x29, 0x9e, 0x08, 0x92, 0x4b, 0xb4, 0x8b, 0x98, 0xd8, 0xa1, 0xff, 0x09, 0xee, 0x53, 0x92, 0x2c,
-	0xdd, 0x23, 0x97, 0x29, 0x03, 0xcb, 0xde, 0xd0, 0x35, 0x04, 0x97, 0x27, 0x29, 0x9e, 0xd4, 0x91,
-	0xab, 0x14, 0xc2, 0xa6, 0xbf, 0x00, 0xcf, 0xb8, 0x29, 0x49, 0xf1, 0x9b, 0x12, 0xa2, 0xd3, 0x06,
-	0xd1, 0x43, 0xa1, 0x57, 0x12, 0x6e, 0x45, 0x92, 0xec, 0x56, 0x84, 0x5c, 0x44, 0x3a, 0x36, 0xa8,
-	0x5c, 0x70, 0x03, 0x92, 0xe2, 0x59, 0x60, 0x50, 0x8f, 0x67, 0x49, 0xff, 0xb6, 0x23, 0xc5, 0xf3,
-	0x3c, 0x72, 0x93, 0xae, 0x17, 0x55, 0x78, 0x61, 0x1e, 0x7d, 0xf1, 0x92, 0x28, 0x3d, 0x6f, 0x55,
-	0x99, 0x2b, 0xae, 0x31, 0x37, 0x66, 0x26, 0xea, 0xb8, 0x23, 0x96, 0xa8, 0xe5, 0xa3, 0x9e, 0xdd,
-	0x29, 0xe4, 0x71, 0x2e, 0x62, 0x3d, 0xbb, 0x63, 0x26, 0xea, 0xb4, 0x84, 0xa9, 0x60, 0x9b, 0xd6,
-	0x69, 0x58, 0x17, 0xbf, 0xc6, 0x2a, 0x69, 0x11, 0x29, 0x40, 0xa2, 0xde, 0xdc, 0x6e, 0xd9, 0x85,
-	0x05, 0x66, 0x67, 0xb7, 0x6c, 0x33, 0x5e, 0xdf, 0x6e, 0xd9, 0xe4, 0x55, 0x88, 0x8d, 0x27, 0x7b,
-	0x05, 0x32, 0xfd, 0xb3, 0xe0, 0xce, 0x64, 0xcf, 0xeb, 0x8c, 0x49, 0x31, 0xe4, 0x3c, 0xa4, 0xc7,
-	0xee, 0xa8, 0xf9, 0x0b, 0xd6, 0xc8, 0x29, 0x9c, 0xc6, 0x69, 0x3c, 0x65, 0xa6, 0xc6, 0xee, 0xe8,
-	0xb1, 0x35, 0x72, 0x8e, 0xe9, 0x83, 0x8b, 0x17, 0x21, 0x2b, 0xf0, 0x92, 0x3c, 0x28, 0x36, 0x3b,
-	0xc0, 0xd4, 0x94, 0x1b, 0xa6, 0x62, 0x17, 0xdf, 0x85, 0x9c, 0x97, 0x62, 0xe1, 0x88, 0x0d, 0xba,
-	0x9b, 0xfa, 0xce, 0x08, 0x77, 0xe9, 0x7c, 0xf9, 0x62, 0x38, 0x62, 0x06, 0x40, 0x1e, 0xb9, 0x18,
-	0xb8, 0xa8, 0x45, 0x3a, 0xa3, 0x14, 0x7f, 0xa0, 0x40, 0x6e, 0xcb, 0x19, 0x05, 0xbf, 0x5f, 0x2c,
-	0x42, 0x62, 0xcf, 0x71, 0xfa, 0x63, 0x24, 0x4e, 0x9b, 0xec, 0x85, 0xbc, 0x0c, 0x39, 0x7c, 0xf0,
-	0x92, 0x64, 0xd5, 0xbf, 0x05, 0xca, 0x62, 0x39, 0xcf, 0x8b, 0x09, 0xc4, 0x7b, 0xb6, 0x3b, 0xe6,
-	0x1e, 0x0d, 0x9f, 0xc9, 0x17, 0x20, 0x4b, 0xff, 0x7a, 0x96, 0x71, 0xff, 0x34, 0x0d, 0xb4, 0x98,
-	0x1b, 0xbe, 0x02, 0x73, 0xa8, 0x01, 0x1f, 0x96, 0xf2, 0x6f, 0x7c, 0x72, 0xac, 0x82, 0x03, 0x0b,
-	0x90, 0x62, 0x0e, 0x61, 0x8c, 0x3f, 0xf8, 0x66, 0x4c, 0xef, 0x95, 0xba, 0x59, 0x4c, 0x54, 0xd8,
-	0x09, 0x24, 0x65, 0xf2, 0xb7, 0xe2, 0x5d, 0x48, 0x63, 0xb8, 0x6c, 0xf4, 0xdb, 0xe4, 0x25, 0x50,
-	0xba, 0x05, 0x0b, 0xc3, 0xf5, 0x99, 0x50, 0x16, 0xc2, 0x01, 0xcb, 0x1b, 0xa6, 0xd2, 0x5d, 0x5a,
-	0x00, 0x65, 0x83, 0xa6, 0x05, 0x87, 0xdc, 0x61, 0x2b, 0x87, 0xc5, 0xb7, 0x39, 0xc9, 0xb6, 0xf5,
-	0x54, 0x4e, 0xb2, 0x6d, 0x3d, 0x65, 0x24, 0x97, 0xa6, 0x48, 0xe8, 0xdb, 0x11, 0xff, 0x0d, 0x5c,
-	0x39, 0x2a, 0x56, 0x60, 0x0e, 0x37, 0x6a, 0xcf, 0xee, 0x3e, 0x72, 0x7a, 0x36, 0x26, 0x22, 0x1d,
-	0x3c, 0xc0, 0x29, 0xa6, 0xd2, 0xa1, 0xeb, 0x60, 0x1d, 0xb6, 0xf6, 0xd9, 0x71, 0x38, 0x6d, 0xb2,
-	0x97, 0xe2, 0xf7, 0xe3, 0x30, 0xcf, 0x9d, 0xec, 0x7b, 0x3d, 0xf7, 0x60, 0xab, 0x35, 0x24, 0xdb,
-	0x90, 0xa3, 0xfe, 0xb5, 0x39, 0x68, 0x0d, 0x87, 0x74, 0x23, 0x2b, 0x18, 0x9a, 0xaf, 0xce, 0x70,
-	0xdb, 0xdc, 0x62, 0x79, 0xbb, 0x35, 0xb0, 0xb6, 0x18, 0x9a, 0x05, 0xea, 0xac, 0x1d, 0x94, 0x90,
-	0x07, 0x90, 0x1d, 0x8c, 0xbb, 0x3e, 0x1d, 0x8b, 0xf4, 0x57, 0x24, 0x74, 0x5b, 0xe3, 0x6e, 0x88,
-	0x0d, 0x06, 0x7e, 0x01, 0xed, 0x1c, 0xf5, 0xce, 0x3e, 0x5b, 0xec, 0xb9, 0x9d, 0xa3, 0xae, 0x24,
-	0xdc, 0xb9, 0xbd, 0xa0, 0x84, 0xd4, 0x01, 0xe8, 0x56, 0x73, 0x1d, 0x9a, 0xe1, 0xa1, 0x96, 0xb2,
-	0xe5, 0x92, 0x84, 0x6d, 0xc7, 0x1d, 0xed, 0x3a, 0x3b, 0xee, 0x88, 0x1f, 0x48, 0xc6, 0xfc, 0x75,
-	0xe9, 0x4d, 0xd0, 0xa2, 0xb3, 0xf0, 0xbc, 0x33, 0x49, 0x46, 0x38, 0x93, 0x2c, 0xfd, 0x2c, 0xe4,
-	0x23, 0xc3, 0x16, 0xcd, 0x09, 0x33, 0xbf, 0x2e, 0x9a, 0x67, 0xcb, 0xe7, 0x42, 0xdf, 0x68, 0x88,
-	0x4b, 0x2f, 0x32, 0xbf, 0x09, 0x5a, 0x74, 0x0a, 0x44, 0xea, 0xb4, 0x24, 0xa1, 0x41, 0xfb, 0xd7,
-	0x61, 0x2e, 0x34, 0x68, 0xd1, 0x38, 0xf3, 0x9c, 0x61, 0x15, 0x7f, 0x25, 0x01, 0x89, 0x86, 0x6d,
-	0x39, 0x1d, 0x72, 0x36, 0x1c, 0x3b, 0xef, 0x9f, 0xf2, 0xe2, 0xe6, 0xb9, 0x48, 0xdc, 0xbc, 0x7f,
-	0xca, 0x8f, 0x9a, 0xe7, 0x22, 0x51, 0xd3, 0xab, 0xaa, 0x1a, 0xe4, 0xc2, 0x54, 0xcc, 0xbc, 0x7f,
-	0x4a, 0x08, 0x98, 0x17, 0xa6, 0x02, 0x66, 0x50, 0x5d, 0x35, 0xa8, 0x83, 0x0d, 0x47, 0xcb, 0xfb,
-	0xa7, 0x82, 0x48, 0x79, 0x3e, 0x1a, 0x29, 0xfd, 0xca, 0xaa, 0xc1, 0xba, 0x24, 0x44, 0x49, 0xec,
-	0x12, 0x8b, 0x8f, 0xe7, 0xa3, 0xf1, 0x11, 0xed, 0x78, 0x64, 0x3c, 0x1f, 0x8d, 0x8c, 0x58, 0xc9,
-	0x23, 0xe1, 0xb9, 0x48, 0x24, 0x44, 0x52, 0x16, 0x02, 0xcf, 0x47, 0x43, 0x20, 0xb3, 0x13, 0x7a,
-	0x2a, 0xc6, 0x3f, 0xbf, 0xb2, 0x6a, 0x10, 0x23, 0x12, 0xfc, 0x64, 0x89, 0x08, 0xae, 0x06, 0x86,
-	0x81, 0x2a, 0x9d, 0x38, 0xef, 0x80, 0x9a, 0x97, 0x7e, 0xc2, 0x82, 0x33, 0xea, 0x1d, 0xd0, 0x0c,
-	0x48, 0x75, 0x78, 0xae, 0xae, 0xa1, 0x27, 0x0b, 0x89, 0x13, 0x25, 0xb0, 0x5c, 0x6f, 0xa2, 0x47,
-	0xa3, 0xa3, 0xeb, 0xb0, 0x84, 0xa3, 0x04, 0x73, 0xf5, 0xe6, 0xc3, 0xd6, 0xa8, 0x4b, 0xa1, 0xbb,
-	0xad, 0xae, 0x7f, 0xeb, 0x41, 0x55, 0x90, 0xad, 0xf3, 0x9a, 0xdd, 0x56, 0x97, 0x9c, 0xf1, 0x24,
-	0xd6, 0xc6, 0x5a, 0x85, 0x8b, 0x6c, 0xe9, 0x2c, 0x9d, 0x3a, 0x46, 0x86, 0xbe, 0x71, 0x81, 0xfb,
-	0xc6, 0x3b, 0x29, 0x48, 0x4c, 0xec, 0x9e, 0x63, 0xdf, 0xc9, 0x40, 0xca, 0x75, 0x46, 0x83, 0x96,
-	0xeb, 0x14, 0x7f, 0xa8, 0x00, 0xdc, 0x75, 0x06, 0x83, 0x89, 0xdd, 0x7b, 0x7f, 0x62, 0x91, 0x8b,
-	0x90, 0x1d, 0xb4, 0x9e, 0x58, 0xcd, 0x81, 0xd5, 0xdc, 0x1f, 0x79, 0xbb, 0x21, 0x43, 0x8b, 0xb6,
-	0xac, 0xbb, 0xa3, 0x23, 0x52, 0xf0, 0x0e, 0xf0, 0xa8, 0x20, 0x14, 0x26, 0x3f, 0xd0, 0x2f, 0xf2,
-	0xe3, 0x68, 0x92, 0xaf, 0xa4, 0x77, 0x20, 0x65, 0x49, 0x4e, 0x8a, 0xaf, 0x21, 0x4b, 0x73, 0xce,
-	0x42, 0xd2, 0xb5, 0x06, 0xc3, 0xe6, 0x3e, 0x0a, 0x86, 0x8a, 0x22, 0x41, 0xdf, 0xef, 0x92, 0xeb,
-	0x10, 0xdb, 0x77, 0xfa, 0x28, 0x95, 0xe7, 0xae, 0x0e, 0x45, 0x92, 0x57, 0x20, 0x36, 0x18, 0x33,
-	0xf9, 0x64, 0xcb, 0xa7, 0x43, 0x27, 0x08, 0x16, 0xb2, 0x28, 0x70, 0x30, 0xee, 0xfa, 0x63, 0xbf,
-	0x92, 0x87, 0x58, 0xbd, 0xd1, 0xa0, 0xa7, 0x82, 0x7a, 0xa3, 0xb1, 0xaa, 0x29, 0xb5, 0x55, 0x48,
-	0x77, 0x47, 0x96, 0x45, 0x1d, 0xc5, 0xb3, 0xb2, 0x92, 0x2f, 0x63, 0x14, 0xf4, 0x61, 0xb5, 0xb7,
-	0x21, 0xb5, 0xcf, 0xf2, 0x12, 0xf2, 0xcc, 0x1c, 0xbc, 0xf0, 0xc7, 0xec, 0x2e, 0xe8, 0x45, 0x11,
-	0x10, 0xcd, 0x66, 0x4c, 0x8f, 0xa7, 0xb6, 0x0b, 0x99, 0x51, 0xf3, 0xf9, 0xa4, 0x1f, 0xb2, 0xc8,
-	0x23, 0x27, 0x4d, 0x8f, 0x78, 0x51, 0x6d, 0x03, 0x16, 0x6c, 0xc7, 0xfb, 0x49, 0xaa, 0xd9, 0xe6,
-	0xfb, 0x6e, 0xd6, 0x91, 0xcf, 0x6b, 0xc0, 0x62, 0x3f, 0x6c, 0xdb, 0x0e, 0xaf, 0x60, 0x7b, 0xb5,
-	0xb6, 0x0e, 0x9a, 0x40, 0xd4, 0x61, 0x9b, 0x5b, 0xc6, 0xd3, 0x61, 0xbf, 0xa5, 0xfb, 0x3c, 0xe8,
-	0x0f, 0x22, 0x34, 0x7c, 0xc7, 0xca, 0x68, 0xba, 0xec, 0xd3, 0x04, 0x9f, 0x06, 0x9d, 0xe0, 0x34,
-	0x0d, 0xf5, 0x5f, 0x32, 0x9a, 0x03, 0xf6, 0xdd, 0x82, 0x48, 0x53, 0x35, 0x22, 0xb3, 0x33, 0x39,
-	0x46, 0x77, 0x7a, 0xec, 0xc3, 0x03, 0x9f, 0x87, 0xb9, 0xc7, 0x19, 0x44, 0xcf, 0xeb, 0xd0, 0x97,
-	0xd9, 0x57, 0x09, 0x21, 0xa2, 0xa9, 0x1e, 0x8d, 0x8f, 0xd1, 0xa3, 0x27, 0xec, 0x23, 0x00, 0x9f,
-	0x68, 0x67, 0x56, 0x8f, 0xc6, 0xc7, 0xe8, 0x51, 0x9f, 0x7d, 0x20, 0x10, 0x22, 0xaa, 0x1a, 0xb5,
-	0x4d, 0x20, 0xe2, 0xc2, 0xf3, 0x58, 0x22, 0x65, 0x1a, 0xb0, 0x0f, 0x3f, 0x82, 0xa5, 0x67, 0x46,
-	0xb3, 0xa8, 0x9e, 0xd7, 0x29, 0x9b, 0x7d, 0x15, 0x12, 0xa6, 0xaa, 0x1a, 0xb5, 0x07, 0x70, 0x5a,
-	0x1c, 0xde, 0xb1, 0xba, 0xe5, 0xb0, 0x4f, 0x1a, 0x82, 0x01, 0x72, 0xab, 0x99, 0x64, 0xcf, 0xeb,
-	0xd8, 0x90, 0x7d, 0xee, 0x10, 0x21, 0xab, 0x1a, 0xb5, 0xbb, 0x90, 0x17, 0xc8, 0xf6, 0x30, 0x0b,
-	0x96, 0x11, 0xbd, 0xcf, 0x3e, 0xd2, 0xf1, 0x89, 0x68, 0xfc, 0x8f, 0xae, 0x1e, 0x8b, 0x88, 0x52,
-	0x9a, 0x11, 0xfb, 0xc6, 0x24, 0xe8, 0x0f, 0xda, 0x44, 0x36, 0xca, 0x1e, 0x0b, 0x9f, 0x32, 0x9e,
-	0x31, 0xfb, 0xfe, 0x24, 0xe8, 0x0e, 0x35, 0xa9, 0x0d, 0x42, 0x83, 0xb2, 0x68, 0x50, 0x94, 0xb2,
-	0xb8, 0xe8, 0xbf, 0x4b, 0x12, 0xc8, 0xb2, 0x78, 0xd9, 0x22, 0x0c, 0x9f, 0xbe, 0xd6, 0x1e, 0xc0,
-	0xfc, 0x49, 0x5c, 0xd6, 0x87, 0x0a, 0xcb, 0xbc, 0x2b, 0xcb, 0x34, 0x39, 0x37, 0xe7, 0xda, 0x21,
-	0xcf, 0xb5, 0x01, 0x73, 0x27, 0x70, 0x5b, 0x1f, 0x29, 0x2c, 0x7f, 0xa5, 0x5c, 0x66, 0xae, 0x1d,
-	0xf6, 0x5d, 0x73, 0x27, 0x70, 0x5c, 0x1f, 0x2b, 0xec, 0xc2, 0xc3, 0x28, 0xfb, 0x34, 0x9e, 0xef,
-	0x9a, 0x3b, 0x81, 0xe3, 0xfa, 0x84, 0xe5, 0xa7, 0xaa, 0x51, 0x11, 0x69, 0xd0, 0x53, 0xcc, 0x9f,
-	0xc4, 0x71, 0x7d, 0xaa, 0xe0, 0x05, 0x88, 0x6a, 0x18, 0xfe, 0xfc, 0xf8, 0xbe, 0x6b, 0xfe, 0x24,
-	0x8e, 0xeb, 0xab, 0x0a, 0x5e, 0x94, 0xa8, 0xc6, 0x5a, 0x88, 0x28, 0xdc, 0xa3, 0xe3, 0x38, 0xae,
-	0xaf, 0x29, 0x78, 0x7b, 0xa1, 0x1a, 0x55, 0x9f, 0x68, 0x67, 0xaa, 0x47, 0xc7, 0x71, 0x5c, 0x5f,
-	0xc7, 0x6c, 0xa0, 0xa6, 0x1a, 0x37, 0x42, 0x44, 0xe8, 0xbb, 0xf2, 0x27, 0x72, 0x5c, 0xdf, 0x50,
-	0xf0, 0xa2, 0x49, 0x35, 0x6e, 0x9a, 0x5e, 0x0f, 0x02, 0xdf, 0x95, 0x3f, 0x91, 0xe3, 0xfa, 0xa6,
-	0x82, 0x37, 0x52, 0xaa, 0x71, 0x2b, 0x4c, 0x85, 0xbe, 0x4b, 0x3b, 0x99, 0xe3, 0xfa, 0x4c, 0xc1,
-	0xef, 0x4f, 0xd4, 0xb5, 0x15, 0xd3, 0xeb, 0x84, 0xe0, 0xbb, 0xb4, 0x93, 0x39, 0xae, 0x6f, 0x29,
-	0xf8, 0x51, 0x8a, 0xba, 0xb6, 0x1a, 0x21, 0xab, 0x1a, 0xb5, 0x75, 0xc8, 0x1d, 0xdf, 0x71, 0x7d,
-	0x5b, 0xbc, 0xef, 0xcb, 0xb6, 0x05, 0xef, 0xf5, 0x58, 0x58, 0xbf, 0x63, 0xb8, 0xae, 0xef, 0x60,
-	0xd6, 0x54, 0x7b, 0xe1, 0x3e, 0xbb, 0x15, 0x63, 0x26, 0xaf, 0xb5, 0xad, 0xce, 0x1b, 0x1d, 0xc7,
-	0x09, 0x96, 0x94, 0x39, 0xb4, 0x46, 0xb0, 0x7b, 0x8e, 0xe1, 0xcd, 0xbe, 0xab, 0xe0, 0x25, 0x5a,
-	0x8e, 0x53, 0xa3, 0x85, 0xbf, 0x8f, 0x98, 0x6b, 0xb3, 0x83, 0x31, 0x3f, 0xdf, 0xaf, 0x7d, 0x4f,
-	0x39, 0x99, 0x63, 0xab, 0xc5, 0x1a, 0xdb, 0xeb, 0xfe, 0xe4, 0x60, 0xc9, 0x5b, 0x10, 0x3f, 0x2c,
-	0xaf, 0xac, 0x86, 0x8f, 0x78, 0xe2, 0x1d, 0x32, 0x73, 0x67, 0xd9, 0xf2, 0x42, 0xe8, 0xb2, 0x7d,
-	0x30, 0x74, 0x8f, 0x4c, 0xb4, 0xe4, 0x0c, 0x65, 0x09, 0xc3, 0x47, 0x52, 0x86, 0x32, 0x67, 0xa8,
-	0x48, 0x18, 0x3e, 0x96, 0x32, 0x54, 0x38, 0x83, 0x21, 0x61, 0xf8, 0x44, 0xca, 0x60, 0x70, 0x86,
-	0x35, 0x09, 0xc3, 0xa7, 0x52, 0x86, 0x35, 0xce, 0x50, 0x95, 0x30, 0x7c, 0x55, 0xca, 0x50, 0xe5,
-	0x0c, 0x37, 0x24, 0x0c, 0x5f, 0x93, 0x32, 0xdc, 0xe0, 0x0c, 0x37, 0x25, 0x0c, 0x5f, 0x97, 0x32,
-	0xdc, 0xe4, 0x0c, 0xb7, 0x24, 0x0c, 0xdf, 0x90, 0x32, 0xdc, 0x62, 0x0c, 0xab, 0x2b, 0x12, 0x86,
-	0x6f, 0xca, 0x18, 0x56, 0x57, 0x38, 0x83, 0x4c, 0x93, 0x9f, 0x49, 0x19, 0xb8, 0x26, 0x57, 0x65,
-	0x9a, 0xfc, 0x96, 0x94, 0x81, 0x6b, 0x72, 0x55, 0xa6, 0xc9, 0x6f, 0x4b, 0x19, 0xb8, 0x26, 0x57,
-	0x65, 0x9a, 0xfc, 0x8e, 0x94, 0x81, 0x6b, 0x72, 0x55, 0xa6, 0xc9, 0xef, 0x4a, 0x19, 0xb8, 0x26,
-	0x57, 0x65, 0x9a, 0xfc, 0x9e, 0x94, 0x81, 0x6b, 0x72, 0x55, 0xa6, 0xc9, 0x3f, 0x91, 0x32, 0x70,
-	0x4d, 0xae, 0xca, 0x34, 0xf9, 0xa7, 0x52, 0x06, 0xae, 0xc9, 0x55, 0x99, 0x26, 0xff, 0x4c, 0xca,
-	0xc0, 0x35, 0x59, 0x96, 0x69, 0xf2, 0xfb, 0x32, 0x86, 0x32, 0xd7, 0x64, 0x59, 0xa6, 0xc9, 0x3f,
-	0x97, 0x32, 0x70, 0x4d, 0x96, 0x65, 0x9a, 0xfc, 0x0b, 0x29, 0x03, 0xd7, 0x64, 0x59, 0xa6, 0xc9,
-	0x1f, 0x48, 0x19, 0xb8, 0x26, 0xcb, 0x32, 0x4d, 0xfe, 0xa5, 0x94, 0x81, 0x6b, 0xb2, 0x2c, 0xd3,
-	0xe4, 0x5f, 0x49, 0x19, 0xb8, 0x26, 0xcb, 0x32, 0x4d, 0xfe, 0xb5, 0x94, 0x81, 0x6b, 0xb2, 0x2c,
-	0xd3, 0xe4, 0xdf, 0x48, 0x19, 0xb8, 0x26, 0xcb, 0x32, 0x4d, 0xfe, 0xad, 0x94, 0x81, 0x6b, 0xb2,
-	0x2c, 0xd3, 0xe4, 0xdf, 0x49, 0x19, 0xb8, 0x26, 0x2b, 0x32, 0x4d, 0xfe, 0xbd, 0x8c, 0xa1, 0xc2,
-	0x35, 0x59, 0x91, 0x69, 0xf2, 0x1f, 0xa4, 0x0c, 0x5c, 0x93, 0x15, 0x99, 0x26, 0xff, 0x51, 0xca,
-	0xc0, 0x35, 0x59, 0x91, 0x69, 0xf2, 0x9f, 0xa4, 0x0c, 0x5c, 0x93, 0x15, 0x99, 0x26, 0xff, 0x59,
-	0xca, 0xc0, 0x35, 0x59, 0x91, 0x69, 0xf2, 0x5f, 0xa4, 0x0c, 0x5c, 0x93, 0x15, 0x99, 0x26, 0xff,
-	0x55, 0xca, 0xc0, 0x35, 0x59, 0x91, 0x69, 0xf2, 0xdf, 0xa4, 0x0c, 0x5c, 0x93, 0x15, 0x99, 0x26,
-	0x7f, 0x28, 0x65, 0xe0, 0x9a, 0xac, 0xc8, 0x34, 0xf9, 0xef, 0x52, 0x06, 0xae, 0x49, 0x43, 0xa6,
-	0xc9, 0xff, 0x90, 0x31, 0x18, 0x5c, 0x93, 0x86, 0x4c, 0x93, 0xff, 0x29, 0x65, 0xe0, 0x9a, 0x34,
-	0x64, 0x9a, 0xfc, 0x2f, 0x29, 0x03, 0xd7, 0xa4, 0x21, 0xd3, 0xe4, 0x7f, 0x4b, 0x19, 0xb8, 0x26,
-	0x0d, 0x99, 0x26, 0xff, 0x47, 0xca, 0xc0, 0x35, 0x69, 0xc8, 0x34, 0xf9, 0xbf, 0x52, 0x06, 0xae,
-	0x49, 0x43, 0xa6, 0xc9, 0x1f, 0x49, 0x19, 0xb8, 0x26, 0x0d, 0x99, 0x26, 0x7f, 0x2c, 0x65, 0xe0,
-	0x9a, 0x34, 0x64, 0x9a, 0xfc, 0x89, 0x94, 0x81, 0x6b, 0xd2, 0x90, 0x69, 0xf2, 0xa7, 0x52, 0x06,
-	0xae, 0xc9, 0x35, 0x99, 0x26, 0xff, 0x4f, 0xc6, 0xb0, 0xb6, 0x72, 0xe7, 0xda, 0xe3, 0xab, 0xdd,
-	0x9e, 0x7b, 0x30, 0xd9, 0x5b, 0xde, 0x77, 0x06, 0xd7, 0xbb, 0x4e, 0xbf, 0x65, 0x77, 0xaf, 0x23,
-	0x6c, 0x6f, 0xd2, 0xb9, 0x1e, 0xfc, 0xeb, 0x35, 0x33, 0xfd, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff,
-	0x46, 0xc7, 0xb3, 0x38, 0x92, 0x3d, 0x00, 0x00,
+}
+
+func init() { proto.RegisterFile("proto2_proto/test.proto", fileDescriptor_e5b3e7ca68f98362) }
+
+var fileDescriptor_e5b3e7ca68f98362 = []byte{
+	// 4330 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x5b, 0x4b, 0x73, 0xdb, 0x58,
+	0x76, 0x36, 0xc0, 0xf7, 0x21, 0x25, 0x42, 0xb7, 0xd5, 0x36, 0x2d, 0xb5, 0x6d, 0x98, 0x3d, 0x3d,
+	0xc3, 0xb6, 0xdd, 0xb4, 0x4c, 0x51, 0xb4, 0x4d, 0x4f, 0x3b, 0x63, 0xd9, 0xa2, 0xac, 0xb4, 0x24,
+	0x7a, 0x20, 0xb9, 0xbb, 0xda, 0xb3, 0x60, 0x41, 0x22, 0x48, 0x71, 0x4c, 0x02, 0x6c, 0x12, 0x1c,
+	0x4b, 0xa9, 0x54, 0xaa, 0xb7, 0xd9, 0xa4, 0x2a, 0x99, 0xa4, 0x2a, 0x3f, 0x20, 0xdb, 0xc9, 0x63,
+	0x97, 0x45, 0x7e, 0x40, 0x7a, 0x1e, 0x49, 0x26, 0xef, 0xac, 0x52, 0xf9, 0x07, 0x59, 0xe5, 0xb1,
+	0xea, 0xa9, 0x73, 0xee, 0x05, 0x70, 0x01, 0x52, 0xaf, 0x95, 0x70, 0xef, 0xfd, 0xbe, 0x73, 0x5f,
+	0x1f, 0xce, 0x39, 0xf7, 0x12, 0x82, 0x6b, 0xc3, 0x91, 0xe3, 0x3a, 0x95, 0x16, 0xfd, 0xb9, 0xef,
+	0x5a, 0x63, 0xb7, 0x4c, 0x8f, 0x2c, 0x2b, 0x1a, 0xb0, 0xaa, 0x78, 0x0f, 0x92, 0x9b, 0xce, 0x86,
+	0x3d, 0x19, 0xb0, 0x22, 0xc4, 0x3a, 0x8e, 0x53, 0x50, 0x74, 0xb5, 0x34, 0x5f, 0xd1, 0xca, 0x12,
+	0xa8, 0xdc, 0x68, 0x36, 0x0d, 0x6c, 0x2c, 0x3e, 0x84, 0xec, 0xa6, 0xb3, 0x6f, 0x8d, 0xdd, 0x46,
+	0xcf, 0xea, 0xb7, 0xd9, 0x22, 0x24, 0xb6, 0xcd, 0x03, 0xab, 0x4f, 0xa4, 0x8c, 0xc1, 0x0b, 0x8c,
+	0x41, 0x7c, 0xff, 0x64, 0x68, 0x15, 0x54, 0xaa, 0xa4, 0xe7, 0xe2, 0xdf, 0x14, 0xb1, 0x1f, 0x64,
+	0xb2, 0x7b, 0x10, 0xff, 0xac, 0x67, 0xb7, 0x45, 0x47, 0x85, 0x50, 0x47, 0x1c, 0x52, 0xfe, 0x6c,
+	0x6b, 0xf7, 0x85, 0x41, 0x28, 0xec, 0x62, 0xdf, 0x3c, 0xe8, 0xa3, 0x35, 0x05, 0xbb, 0xa0, 0x02,
+	0xd6, 0xbe, 0x32, 0x47, 0xe6, 0xa0, 0x10, 0xd3, 0x95, 0x52, 0xc2, 0xe0, 0x05, 0xf6, 0x14, 0xe6,
+	0x0c, 0xeb, 0xab, 0x49, 0x6f, 0x64, 0xb5, 0x69, 0x7c, 0x85, 0xb8, 0xae, 0x96, 0xb2, 0x33, 0xbb,
+	0xa0, 0x76, 0x23, 0x0c, 0xe7, 0xfc, 0xa1, 0x65, 0xba, 0x1e, 0x3f, 0xa1, 0xc7, 0xce, 0xe3, 0x4b,
+	0x70, 0xe4, 0x37, 0x87, 0x6e, 0xcf, 0xb1, 0xcd, 0x3e, 0xe7, 0x27, 0x75, 0xe5, 0x6c, 0x7e, 0x08,
+	0xce, 0xbe, 0x0b, 0xf9, 0x46, 0x6b, 0xdd, 0x71, 0xfa, 0xad, 0x91, 0x18, 0x57, 0x01, 0x74, 0xb5,
+	0x94, 0x36, 0xe6, 0x1a, 0x58, 0xeb, 0x0d, 0x96, 0x95, 0x40, 0x6b, 0xb4, 0xb6, 0x6c, 0x77, 0xb5,
+	0x12, 0x00, 0xb3, 0xba, 0x5a, 0x4a, 0x18, 0xf3, 0x0d, 0xaa, 0x9e, 0x42, 0xd6, 0xaa, 0x01, 0x32,
+	0xa7, 0xab, 0xa5, 0x18, 0x47, 0xd6, 0xaa, 0x3e, 0xf2, 0x1e, 0xb0, 0x46, 0xab, 0xd1, 0x3b, 0xb6,
+	0xda, 0xb2, 0xd5, 0x39, 0x5d, 0x2d, 0xa5, 0x0c, 0xad, 0x21, 0x1a, 0x66, 0xa0, 0x65, 0xcb, 0xf3,
+	0xba, 0x5a, 0x4a, 0x7a, 0x68, 0xc9, 0xf6, 0x1d, 0x58, 0x68, 0xb4, 0x5e, 0xf7, 0xc2, 0x03, 0xce,
+	0xeb, 0x6a, 0x69, 0xce, 0xc8, 0x37, 0x78, 0xfd, 0x34, 0x56, 0x36, 0xac, 0xe9, 0x6a, 0x29, 0x2e,
+	0xb0, 0x92, 0x5d, 0x9a, 0x5d, 0xa3, 0xef, 0x98, 0x6e, 0x00, 0x5d, 0xd0, 0xd5, 0x92, 0x6a, 0xcc,
+	0x37, 0xa8, 0x3a, 0x6c, 0xf5, 0x85, 0x33, 0x39, 0xe8, 0x5b, 0x01, 0x94, 0xe9, 0x6a, 0x49, 0x31,
+	0xf2, 0x0d, 0x5e, 0x1f, 0xc6, 0xee, 0xb9, 0xa3, 0x9e, 0xdd, 0x0d, 0xb0, 0xef, 0x91, 0x96, 0xf3,
+	0x0d, 0x5e, 0x1f, 0x1e, 0xc1, 0xfa, 0x89, 0x6b, 0x8d, 0x03, 0xa8, 0xa5, 0xab, 0xa5, 0x9c, 0x31,
+	0xdf, 0xa0, 0xea, 0x88, 0xd5, 0xc8, 0x1a, 0x74, 0x74, 0xb5, 0xb4, 0x80, 0x56, 0x67, 0xac, 0xc1,
+	0x5e, 0x64, 0x0d, 0xba, 0xba, 0x5a, 0x62, 0x02, 0x2b, 0xad, 0x41, 0x19, 0xde, 0x6b, 0xb4, 0xf6,
+	0x3a, 0xd1, 0x8d, 0x3b, 0xd2, 0xd5, 0x52, 0xde, 0x58, 0x68, 0x78, 0x2d, 0xb3, 0xf0, 0xb2, 0xf5,
+	0x9e, 0xae, 0x96, 0x34, 0x1f, 0x2f, 0xd9, 0x97, 0x35, 0xc9, 0xb5, 0x5e, 0x58, 0xd4, 0x63, 0x92,
+	0x26, 0x79, 0x65, 0x58, 0x93, 0x02, 0xf8, 0xbe, 0x1e, 0x93, 0x35, 0x19, 0x41, 0x52, 0xf7, 0x02,
+	0x79, 0x55, 0x8f, 0xc9, 0x9a, 0x14, 0xc8, 0x88, 0x26, 0x05, 0xf6, 0x9a, 0x1e, 0x0b, 0x6b, 0x72,
+	0x0a, 0x2d, 0x5b, 0x2e, 0xe8, 0xb1, 0xb0, 0x26, 0x05, 0x3a, 0xac, 0x49, 0x01, 0xbe, 0xae, 0xc7,
+	0x42, 0x9a, 0x8c, 0x62, 0x65, 0xc3, 0x4b, 0x7a, 0x2c, 0xa4, 0x49, 0x79, 0x76, 0x9e, 0x26, 0x05,
+	0x74, 0x59, 0x8f, 0xc9, 0x9a, 0x94, 0xad, 0xfa, 0x9a, 0x14, 0xd0, 0x0f, 0xf4, 0x58, 0x48, 0x93,
+	0x32, 0xd6, 0xd7, 0xa4, 0xc0, 0xde, 0xd0, 0x63, 0x21, 0x4d, 0x0a, 0xec, 0xc7, 0xb2, 0x26, 0x05,
+	0xf4, 0x1b, 0x45, 0x8f, 0xc9, 0xa2, 0x14, 0xd0, 0xbb, 0x21, 0x51, 0x0a, 0xec, 0xcf, 0x11, 0x2b,
+	0xab, 0x32, 0x0a, 0x96, 0x57, 0xe1, 0x17, 0x08, 0x96, 0x65, 0x29, 0xc0, 0xf7, 0x23, 0xb2, 0x14,
+	0xf0, 0x5f, 0x22, 0x3c, 0xac, 0xcb, 0x69, 0x82, 0x6c, 0xff, 0x57, 0x48, 0x08, 0x0b, 0x53, 0x10,
+	0x02, 0x61, 0x3a, 0xc2, 0x89, 0x16, 0x6e, 0xea, 0x8a, 0x2f, 0x4c, 0xcf, 0xb3, 0xca, 0xc2, 0xf4,
+	0x81, 0xb7, 0x28, 0x6a, 0x08, 0x61, 0x4e, 0x21, 0x6b, 0xd5, 0x00, 0xa9, 0xeb, 0x4a, 0x20, 0x4c,
+	0x1f, 0x19, 0x12, 0xa6, 0x8f, 0xbd, 0xad, 0x2b, 0xb2, 0x30, 0x67, 0xa0, 0x65, 0xcb, 0x45, 0x5d,
+	0x91, 0x85, 0xe9, 0xa3, 0x65, 0x61, 0xfa, 0xe0, 0x0f, 0x75, 0x45, 0x12, 0xe6, 0x34, 0x56, 0x36,
+	0xfc, 0x1d, 0x5d, 0x91, 0x84, 0x19, 0x9e, 0x1d, 0x17, 0xa6, 0x0f, 0xfd, 0x48, 0x57, 0x02, 0x61,
+	0x86, 0xad, 0x0a, 0x61, 0xfa, 0xd0, 0xef, 0xea, 0x8a, 0x24, 0xcc, 0x30, 0x56, 0x08, 0xd3, 0xc7,
+	0x7e, 0x8f, 0x42, 0xb5, 0x27, 0x4c, 0x1f, 0x2b, 0x09, 0xd3, 0x87, 0xfe, 0x0c, 0xc3, 0xba, 0x2f,
+	0x4c, 0x1f, 0x2a, 0x0b, 0xd3, 0xc7, 0xfe, 0x39, 0x62, 0x03, 0x61, 0x4e, 0x83, 0xe5, 0x55, 0xf8,
+	0x0b, 0x04, 0x07, 0xc2, 0xf4, 0xc1, 0x61, 0x61, 0xfa, 0xf0, 0xbf, 0x44, 0xb8, 0x2c, 0xcc, 0x59,
+	0x04, 0xd9, 0xfe, 0x5f, 0x21, 0x41, 0x16, 0xa6, 0x4f, 0x28, 0xd3, 0x34, 0x51, 0x98, 0x6d, 0xab,
+	0x63, 0x4e, 0xfa, 0x28, 0xe3, 0x12, 0x2a, 0xb3, 0x1e, 0x77, 0x47, 0x13, 0x0b, 0xe7, 0xea, 0x38,
+	0xfd, 0x17, 0x5e, 0x1b, 0x2b, 0xe3, 0xf0, 0xb9, 0x40, 0x03, 0xc2, 0xc7, 0xa8, 0xd0, 0xba, 0xba,
+	0x5a, 0x31, 0xf2, 0x5c, 0xa5, 0xd3, 0xf8, 0x5a, 0x55, 0xc2, 0xdf, 0x41, 0x9d, 0xd6, 0xd5, 0x5a,
+	0x95, 0xe3, 0x6b, 0xd5, 0x00, 0xbf, 0x8a, 0x13, 0xf0, 0xc4, 0x1a, 0x30, 0xee, 0xa2, 0x5a, 0xeb,
+	0xb1, 0xd5, 0xca, 0x8a, 0xb1, 0xe0, 0x49, 0x76, 0x16, 0x29, 0xd4, 0xcd, 0x3d, 0x14, 0x6d, 0x3d,
+	0x56, 0xab, 0xfa, 0x24, 0xb9, 0xa7, 0x0a, 0x0a, 0x5d, 0x48, 0x37, 0xe0, 0x7c, 0x82, 0xda, 0xad,
+	0xc7, 0x57, 0x2b, 0x2b, 0x2b, 0x86, 0x26, 0x14, 0x3c, 0x83, 0x13, 0xea, 0xa7, 0x8c, 0x1a, 0xae,
+	0xc7, 0x6b, 0x55, 0x9f, 0x13, 0xee, 0x67, 0xc1, 0x93, 0x72, 0x40, 0xb9, 0x8f, 0x5a, 0xae, 0x27,
+	0x57, 0x1f, 0x54, 0x1f, 0xac, 0x3d, 0x36, 0xf2, 0x5c, 0xd3, 0x01, 0xa7, 0x8a, 0xfd, 0x08, 0x51,
+	0x07, 0xa4, 0x15, 0x54, 0x75, 0x3d, 0x59, 0x79, 0xf8, 0xe0, 0x51, 0xe5, 0x91, 0xa1, 0x09, 0x75,
+	0x07, 0xac, 0xa7, 0xc8, 0x12, 0xf2, 0x0e, 0x58, 0x0f, 0x50, 0xdf, 0x75, 0xed, 0xc8, 0xea, 0xf7,
+	0x9d, 0x7b, 0x7a, 0xf1, 0x9d, 0x33, 0xea, 0xb7, 0x6f, 0x17, 0xc1, 0xd0, 0x84, 0xe2, 0xe5, 0x5e,
+	0x17, 0x3c, 0xc9, 0x07, 0xf4, 0x3f, 0xc4, 0xa4, 0x35, 0x57, 0x4f, 0xad, 0xf7, 0xba, 0xb6, 0x33,
+	0xb6, 0x8c, 0x3c, 0x17, 0x7f, 0x64, 0x4d, 0xf6, 0xa2, 0xeb, 0xf8, 0x47, 0x48, 0x5b, 0xa8, 0xc7,
+	0x3e, 0x59, 0xad, 0x60, 0x4f, 0xb3, 0xd6, 0x71, 0x2f, 0xba, 0x8e, 0x3f, 0x45, 0x0e, 0xab, 0xc7,
+	0x3e, 0xa9, 0x55, 0x05, 0x47, 0x5e, 0xc7, 0x1a, 0x2c, 0x4a, 0xef, 0x42, 0xc0, 0xfa, 0x63, 0x64,
+	0xe5, 0x79, 0x4f, 0xcc, 0x7f, 0x23, 0x66, 0xf2, 0x42, 0xbd, 0xfd, 0x09, 0xf2, 0x34, 0xde, 0x1b,
+	0xf3, 0x5f, 0x8c, 0x80, 0xf7, 0x10, 0xae, 0x46, 0x72, 0x89, 0xd6, 0xd0, 0x3c, 0x7c, 0x6b, 0xb5,
+	0x0b, 0x15, 0x4c, 0x29, 0xd6, 0x55, 0x4d, 0x31, 0xde, 0x0b, 0xa5, 0x15, 0xaf, 0xa8, 0x99, 0x3d,
+	0x86, 0x6b, 0xd1, 0xe4, 0xc2, 0x63, 0xae, 0x62, 0x8e, 0x41, 0xcc, 0xc5, 0x70, 0x9e, 0x11, 0xa1,
+	0x4a, 0x41, 0xc5, 0xa3, 0x56, 0x31, 0xe9, 0x08, 0xa8, 0x41, 0x6c, 0x11, 0xd4, 0x4f, 0xe1, 0xfa,
+	0x74, 0xfa, 0xe1, 0x91, 0xd7, 0x30, 0x0b, 0x21, 0xf2, 0xd5, 0x68, 0x26, 0x32, 0x45, 0x9f, 0xd1,
+	0x77, 0x0d, 0xd3, 0x12, 0x99, 0x3e, 0xd5, 0xfb, 0x13, 0x28, 0x4c, 0x25, 0x28, 0x1e, 0xfb, 0x21,
+	0xe6, 0x29, 0xc4, 0x7e, 0x3f, 0x92, 0xab, 0x44, 0xc9, 0x33, 0xba, 0x7e, 0x84, 0x89, 0x8b, 0x44,
+	0x9e, 0xea, 0x99, 0x96, 0x2c, 0x9c, 0xc2, 0x78, 0xdc, 0xc7, 0x98, 0xc9, 0x88, 0x25, 0x0b, 0x65,
+	0x33, 0x72, 0xbf, 0x91, 0x9c, 0xc6, 0xe3, 0xd6, 0x31, 0xb5, 0x11, 0xfd, 0x86, 0xd3, 0x1b, 0x41,
+	0xfe, 0x3e, 0x92, 0xf7, 0x66, 0xcf, 0xf8, 0x7f, 0x62, 0x98, 0x94, 0x08, 0xf6, 0xde, 0xac, 0x29,
+	0xfb, 0xec, 0x19, 0x53, 0xfe, 0x5f, 0x64, 0x33, 0x89, 0x3d, 0x35, 0xe7, 0x1f, 0xc0, 0xd2, 0x8c,
+	0x7c, 0xc5, 0xe3, 0xff, 0x1f, 0xf2, 0xf3, 0xc4, 0xbf, 0x36, 0x95, 0xba, 0x4c, 0x5b, 0x98, 0x31,
+	0x82, 0xff, 0x47, 0x0b, 0x5a, 0xc8, 0xc2, 0xd4, 0x18, 0x36, 0x61, 0xce, 0xcb, 0xc7, 0xbb, 0x23,
+	0x67, 0x32, 0x2c, 0x34, 0x74, 0xb5, 0x04, 0x95, 0xdb, 0xb3, 0x4e, 0xc8, 0x5e, 0x7e, 0xbe, 0x89,
+	0x40, 0x23, 0xcc, 0xe3, 0x86, 0xb8, 0x69, 0x6e, 0xe8, 0x95, 0x1e, 0x3b, 0xdd, 0x10, 0x07, 0xfa,
+	0x86, 0x24, 0x1e, 0x1a, 0xf2, 0x02, 0x1e, 0x37, 0xf4, 0x46, 0x57, 0x4e, 0x33, 0xe4, 0xc5, 0x3f,
+	0x61, 0x28, 0xc4, 0x5b, 0x5a, 0x0b, 0x4e, 0xe6, 0xd4, 0xce, 0xbe, 0x13, 0x3d, 0xaa, 0x6f, 0xd2,
+	0x01, 0x2b, 0x5c, 0xc9, 0x69, 0xd2, 0xf8, 0xa6, 0x69, 0x3f, 0x3c, 0x85, 0x16, 0x1a, 0xcd, 0x34,
+	0xed, 0x47, 0x33, 0x68, 0xc5, 0x3f, 0x55, 0x20, 0xfe, 0xd9, 0xd6, 0xee, 0x0b, 0x96, 0x86, 0xf8,
+	0xe7, 0xcd, 0xad, 0x17, 0xda, 0x15, 0x7c, 0x5a, 0x6f, 0x36, 0xb7, 0x35, 0x85, 0x65, 0x20, 0xb1,
+	0xfe, 0xe5, 0xfe, 0xc6, 0x9e, 0xa6, 0xb2, 0x3c, 0x64, 0x1b, 0x5b, 0xbb, 0x9b, 0x1b, 0xc6, 0x2b,
+	0x63, 0x6b, 0x77, 0x5f, 0x8b, 0x61, 0x5b, 0x63, 0xbb, 0xf9, 0x6c, 0x5f, 0x8b, 0xb3, 0x14, 0xc4,
+	0xb0, 0x2e, 0xc1, 0x00, 0x92, 0x7b, 0xfb, 0xc6, 0xd6, 0xee, 0xa6, 0x96, 0x44, 0x2b, 0xfb, 0x5b,
+	0x3b, 0x1b, 0x5a, 0x0a, 0x91, 0xfb, 0xaf, 0x5f, 0x6d, 0x6f, 0x68, 0x69, 0x7c, 0x7c, 0x66, 0x18,
+	0xcf, 0xbe, 0xd4, 0x32, 0x48, 0xda, 0x79, 0xf6, 0x4a, 0x03, 0x6a, 0x7e, 0xb6, 0xbe, 0xbd, 0xa1,
+	0x65, 0x59, 0x0e, 0xd2, 0x8d, 0xd7, 0xbb, 0xcf, 0xf7, 0xb7, 0x9a, 0xbb, 0x5a, 0xae, 0xf8, 0xbb,
+	0x50, 0xe0, 0xcb, 0x1c, 0x5a, 0x45, 0x7e, 0x6b, 0xf0, 0x0c, 0x12, 0x7c, 0x73, 0x14, 0x92, 0xcb,
+	0xdd, 0x19, 0x9b, 0x33, 0xcd, 0x2a, 0xf3, 0x6d, 0xe2, 0xcc, 0xa5, 0x1b, 0x90, 0xe0, 0x0b, 0xb5,
+	0x08, 0x09, 0xbe, 0x40, 0x2a, 0x5d, 0x27, 0xf0, 0x42, 0xf1, 0xcf, 0x54, 0x80, 0x4d, 0x67, 0xef,
+	0x6d, 0x6f, 0x48, 0x17, 0x38, 0x37, 0x00, 0xc6, 0x6f, 0x7b, 0xc3, 0x16, 0xbd, 0x85, 0xe2, 0xe2,
+	0x21, 0x83, 0x35, 0xe4, 0x7f, 0xd9, 0x6d, 0xc8, 0x51, 0xb3, 0x78, 0x4d, 0xe8, 0xbe, 0x21, 0x65,
+	0x64, 0xb1, 0x4e, 0x38, 0xca, 0x30, 0xa4, 0x56, 0xa5, 0x6b, 0x86, 0xa4, 0x04, 0xa9, 0x55, 0xd9,
+	0x2d, 0xa0, 0x62, 0x6b, 0x4c, 0x11, 0x95, 0xae, 0x16, 0x32, 0x06, 0xf5, 0xcb, 0x63, 0x2c, 0xfb,
+	0x2d, 0xa0, 0x3e, 0xf9, 0xd4, 0xf3, 0x33, 0xdf, 0x14, 0x6f, 0xc4, 0x65, 0x7c, 0xe0, 0x13, 0x0e,
+	0x38, 0x4b, 0x4d, 0xc8, 0xf8, 0xf5, 0xd8, 0x1d, 0xd5, 0x8a, 0x49, 0x69, 0x34, 0x29, 0xa0, 0x2a,
+	0x7f, 0x56, 0x1c, 0x20, 0x06, 0xb4, 0x40, 0x03, 0xe2, 0x24, 0x3e, 0xa2, 0xe2, 0x0d, 0x98, 0xdb,
+	0x75, 0x6c, 0xfe, 0x32, 0xd3, 0x42, 0xe5, 0x40, 0x31, 0x0b, 0x0a, 0x1d, 0x82, 0x15, 0xb3, 0x78,
+	0x13, 0x40, 0x6a, 0xd3, 0x40, 0x39, 0xe0, 0x6d, 0xe4, 0x14, 0x94, 0x83, 0xe2, 0x5d, 0x48, 0xee,
+	0x98, 0xc7, 0xfb, 0x66, 0x97, 0xdd, 0x06, 0xe8, 0x9b, 0x63, 0xb7, 0xd5, 0xa1, 0xad, 0xf8, 0xf6,
+	0xdb, 0x6f, 0xbf, 0x55, 0x28, 0xa3, 0xce, 0x60, 0x2d, 0xdf, 0x12, 0x17, 0xa0, 0xd9, 0x6f, 0xef,
+	0x58, 0xe3, 0xb1, 0xd9, 0xb5, 0x58, 0x0d, 0x92, 0xb6, 0x35, 0xc6, 0x10, 0xac, 0xd0, 0x8d, 0xd3,
+	0xcd, 0xd0, 0x42, 0x04, 0xc0, 0xf2, 0x2e, 0xa1, 0x0c, 0x81, 0x66, 0x1a, 0xc4, 0xec, 0xc9, 0x80,
+	0xae, 0xd6, 0x12, 0x06, 0x3e, 0x2e, 0x7d, 0x00, 0x49, 0x8e, 0x61, 0x0c, 0xe2, 0xb6, 0x39, 0xb0,
+	0x0a, 0xbc, 0x6b, 0x7a, 0x2e, 0xfe, 0x54, 0x01, 0xd8, 0xb5, 0xde, 0x5d, 0xac, 0xdb, 0x00, 0x78,
+	0x46, 0xb7, 0x31, 0xde, 0xed, 0x93, 0xb3, 0xba, 0x45, 0xc1, 0x75, 0x1c, 0xa7, 0xdd, 0xe2, 0x7b,
+	0xcd, 0x2f, 0x02, 0x33, 0x58, 0x43, 0x7b, 0x57, 0x7c, 0x03, 0xb9, 0x2d, 0xdb, 0xb6, 0x46, 0xde,
+	0xb0, 0x18, 0xc4, 0x8f, 0x9c, 0xb1, 0x2b, 0x2e, 0x25, 0xe9, 0x99, 0x15, 0x20, 0x3e, 0x74, 0x46,
+	0x2e, 0x9f, 0x6a, 0x3d, 0x5e, 0x5d, 0x59, 0x59, 0x31, 0xa8, 0x86, 0x7d, 0x00, 0x99, 0x43, 0xc7,
+	0xb6, 0xad, 0x43, 0x9c, 0x47, 0x8c, 0x4e, 0x90, 0x41, 0x45, 0xf1, 0xf7, 0x15, 0xc8, 0x35, 0xdd,
+	0xa3, 0xc0, 0xb8, 0x06, 0xb1, 0xb7, 0xd6, 0x09, 0x0d, 0x2f, 0x66, 0xe0, 0x23, 0xbe, 0x33, 0x3f,
+	0x31, 0xfb, 0x13, 0x7e, 0x43, 0x99, 0x33, 0x78, 0x81, 0x5d, 0x85, 0xe4, 0x3b, 0xab, 0xd7, 0x3d,
+	0x72, 0xc9, 0xa6, 0x6a, 0x88, 0x12, 0xbb, 0x0f, 0x89, 0x1e, 0x0e, 0xb6, 0x10, 0xa7, 0x25, 0xbb,
+	0x1e, 0x5a, 0x32, 0x79, 0x1a, 0x06, 0xc7, 0xdd, 0x49, 0xa7, 0xdb, 0xda, 0xd7, 0x5f, 0x7f, 0xfd,
+	0xb5, 0x5a, 0xec, 0xc1, 0xa2, 0xf7, 0x22, 0x87, 0xe6, 0xfb, 0x43, 0x28, 0xf4, 0x2d, 0xa7, 0xd5,
+	0xe9, 0xd9, 0x66, 0xbf, 0x7f, 0xd2, 0x7a, 0xe7, 0xd8, 0x2d, 0xd3, 0x6e, 0x39, 0xe3, 0x43, 0x73,
+	0x44, 0x6b, 0x70, 0x66, 0x2f, 0x8b, 0x7d, 0xcb, 0x69, 0x70, 0xe6, 0x17, 0x8e, 0xfd, 0xcc, 0x6e,
+	0x22, 0xad, 0xf8, 0x1f, 0x71, 0xc8, 0xec, 0x9c, 0x78, 0x1d, 0x2c, 0x42, 0xe2, 0xd0, 0x99, 0xd8,
+	0x7c, 0x45, 0x13, 0x06, 0x2f, 0xf8, 0x3b, 0xa5, 0x4a, 0x3b, 0xb5, 0x08, 0x89, 0xaf, 0x26, 0x8e,
+	0x6b, 0xd1, 0xa4, 0x33, 0x06, 0x2f, 0xe0, 0x9a, 0x0d, 0x2d, 0xb7, 0x10, 0xa7, 0xfb, 0x0a, 0x7c,
+	0x0c, 0x56, 0x21, 0x71, 0xb1, 0x55, 0x60, 0x0f, 0x20, 0xe9, 0xe0, 0x36, 0x8c, 0x0b, 0x49, 0xba,
+	0x93, 0x0d, 0x33, 0xe4, 0x1d, 0x32, 0x04, 0x90, 0x6d, 0xc3, 0xc2, 0x3b, 0xab, 0x35, 0x98, 0x8c,
+	0xdd, 0x56, 0xd7, 0x69, 0xb5, 0x2d, 0x6b, 0x68, 0x8d, 0x0a, 0x73, 0xd4, 0x5f, 0xd8, 0x51, 0xcc,
+	0x5a, 0x54, 0x63, 0xfe, 0x9d, 0xb5, 0x33, 0x19, 0xbb, 0x9b, 0xce, 0x0b, 0x22, 0xb2, 0x1a, 0x64,
+	0x46, 0x16, 0xba, 0x07, 0x1c, 0x75, 0x6e, 0xc6, 0x18, 0x42, 0xec, 0xf4, 0xc8, 0x1a, 0x52, 0x05,
+	0x7b, 0x04, 0xe9, 0x83, 0xde, 0x5b, 0x6b, 0x7c, 0x64, 0xb5, 0x0b, 0x29, 0x5d, 0x29, 0xcd, 0x57,
+	0x3e, 0x08, 0xd1, 0xfc, 0x55, 0x2e, 0x3f, 0x77, 0xfa, 0xce, 0xc8, 0xf0, 0xd1, 0xec, 0x29, 0x64,
+	0xc6, 0xce, 0xc0, 0xe2, 0xa2, 0x4f, 0x53, 0xe0, 0xd5, 0x4f, 0xa1, 0xee, 0x39, 0x03, 0xcb, 0xf3,
+	0x6f, 0x1e, 0x85, 0x2d, 0xf3, 0x11, 0x1f, 0xe0, 0xd9, 0xa2, 0x00, 0x74, 0xff, 0x83, 0xc3, 0xa2,
+	0xb3, 0x06, 0x5b, 0xc2, 0x61, 0x75, 0x3b, 0x98, 0xc2, 0x15, 0xb2, 0x74, 0xb4, 0xf7, 0xcb, 0x4b,
+	0xf7, 0x20, 0xe3, 0x1b, 0x0c, 0x1c, 0x23, 0x77, 0x46, 0x19, 0x72, 0x15, 0xdc, 0x31, 0x72, 0x4f,
+	0xf4, 0x11, 0x24, 0x68, 0xe4, 0x18, 0xc5, 0x8c, 0x0d, 0x0c, 0x9a, 0x19, 0x48, 0x6c, 0x1a, 0x1b,
+	0x1b, 0xbb, 0x9a, 0x42, 0xf1, 0x73, 0xfb, 0xf5, 0x86, 0xa6, 0x4a, 0x32, 0xfe, 0x99, 0x0a, 0xb1,
+	0x8d, 0x63, 0xd2, 0x4f, 0xdb, 0x74, 0x4d, 0xef, 0x4d, 0xc7, 0x67, 0xf6, 0x04, 0x32, 0x03, 0xd3,
+	0xeb, 0x4b, 0xa5, 0x55, 0x0e, 0x3b, 0x95, 0x8d, 0x63, 0xb7, 0xbc, 0x63, 0xf2, 0xae, 0x37, 0x6c,
+	0x77, 0x74, 0x62, 0xa4, 0x07, 0xa2, 0xb8, 0xf4, 0x04, 0xe6, 0x42, 0x4d, 0xf2, 0xbb, 0x9a, 0x98,
+	0xf1, 0xae, 0x26, 0xc4, 0xbb, 0x5a, 0x57, 0x1f, 0x29, 0x95, 0xef, 0x43, 0x7c, 0xe0, 0x8c, 0x2c,
+	0x76, 0x75, 0xf6, 0x12, 0x17, 0xba, 0x24, 0x1c, 0x2d, 0x3a, 0x18, 0x83, 0x58, 0x95, 0x3b, 0x10,
+	0x77, 0xad, 0x63, 0xf7, 0x54, 0xf6, 0x11, 0x9f, 0x23, 0x62, 0x2a, 0x65, 0x48, 0xda, 0x93, 0xc1,
+	0x81, 0x35, 0x3a, 0x15, 0xdd, 0xa3, 0xc1, 0x09, 0x54, 0xf1, 0x73, 0xd0, 0x9e, 0x3b, 0x83, 0x61,
+	0xdf, 0x3a, 0xde, 0x38, 0x76, 0x2d, 0x7b, 0xdc, 0x73, 0x6c, 0x9c, 0x47, 0xa7, 0x37, 0x22, 0x1f,
+	0x47, 0xf3, 0xa0, 0x02, 0xfa, 0x9c, 0xb1, 0x75, 0xe8, 0xd8, 0x6d, 0x31, 0x3d, 0x51, 0x42, 0xb4,
+	0x7b, 0xd4, 0x1b, 0xa1, 0x7b, 0xc3, 0x58, 0xc4, 0x0b, 0xc5, 0x4d, 0xc8, 0x8b, 0xa3, 0xd9, 0x58,
+	0x74, 0x5c, 0xbc, 0x03, 0x39, 0xaf, 0x8a, 0x7e, 0x12, 0x4a, 0x43, 0xfc, 0xcd, 0x86, 0xd1, 0xd4,
+	0xae, 0xe0, 0xe6, 0x36, 0x77, 0x37, 0x34, 0x05, 0x1f, 0xf6, 0xbf, 0x68, 0x86, 0x36, 0x34, 0x05,
+	0x89, 0x8d, 0xc1, 0xd0, 0x3d, 0x29, 0xfe, 0x1e, 0x64, 0x85, 0xa5, 0xed, 0xde, 0xd8, 0x65, 0x75,
+	0x48, 0x0d, 0xc4, 0x8c, 0x14, 0x4a, 0x40, 0x23, 0xf2, 0x0d, 0xa0, 0xde, 0xb3, 0xe1, 0x11, 0x96,
+	0x56, 0x21, 0x25, 0xb9, 0x73, 0xe1, 0x67, 0x54, 0xd9, 0xcf, 0x70, 0x8f, 0x14, 0x93, 0x3c, 0x52,
+	0x71, 0x07, 0x52, 0x3c, 0x14, 0x8f, 0x29, 0xc3, 0xe0, 0xc7, 0x76, 0xae, 0x25, 0x2e, 0xb2, 0x2c,
+	0xaf, 0xe3, 0x79, 0xd3, 0x2d, 0xc8, 0xd2, 0xbb, 0xe1, 0xab, 0x0d, 0xbd, 0x37, 0x50, 0x15, 0x57,
+	0xf6, 0x5f, 0x27, 0x20, 0xed, 0x2d, 0x07, 0x5b, 0x86, 0x24, 0x3f, 0xbb, 0x92, 0x29, 0xef, 0x2e,
+	0x27, 0x41, 0xa7, 0x55, 0xb6, 0x0c, 0x29, 0x71, 0x3e, 0x15, 0x01, 0x46, 0x5d, 0xad, 0x18, 0x49,
+	0x7e, 0x1e, 0xf5, 0x1b, 0x6b, 0x55, 0xf2, 0x8a, 0xfc, 0x96, 0x26, 0xc9, 0x4f, 0x9c, 0x4c, 0x87,
+	0x8c, 0x7f, 0xc6, 0xa4, 0x90, 0x20, 0xae, 0x64, 0xd2, 0xde, 0xa1, 0x52, 0x42, 0xd4, 0xaa, 0xe4,
+	0x2e, 0xc5, 0xfd, 0x4b, 0xba, 0x11, 0xa4, 0x4a, 0x69, 0xef, 0xa4, 0x48, 0xbf, 0x38, 0x79, 0x97,
+	0x2d, 0x29, 0x71, 0x36, 0x0c, 0x00, 0xb5, 0x2a, 0xf9, 0x20, 0xef, 0x66, 0x25, 0x25, 0xce, 0x7f,
+	0xec, 0x16, 0x0e, 0x91, 0xce, 0x73, 0xe4, 0x68, 0x82, 0x6b, 0x94, 0x24, 0x3f, 0xe5, 0xb1, 0xdb,
+	0x68, 0x81, 0x1f, 0xda, 0xc8, 0x05, 0x04, 0x77, 0x26, 0x29, 0x71, 0x96, 0x63, 0x77, 0x11, 0xc2,
+	0x97, 0xbf, 0x00, 0xa7, 0x5c, 0x90, 0xa4, 0xc4, 0x05, 0x09, 0xd3, 0xb1, 0x43, 0xf2, 0x44, 0xe4,
+	0x7d, 0xa4, 0xcb, 0x90, 0x24, 0xbf, 0x0c, 0x61, 0x37, 0xc9, 0x1c, 0x9f, 0x54, 0x2e, 0xb8, 0xf8,
+	0x48, 0x89, 0xc3, 0x5f, 0xd0, 0x4e, 0xe9, 0xa3, 0x7f, 0xc9, 0x91, 0x12, 0xc7, 0x3b, 0xf6, 0x18,
+	0xf7, 0x0b, 0x45, 0x5c, 0x98, 0x27, 0xaf, 0xbb, 0x1c, 0xd2, 0x9e, 0xb7, 0xad, 0xdc, 0xe9, 0xd6,
+	0xb9, 0xbf, 0x32, 0x12, 0x0d, 0x52, 0xfd, 0x12, 0x52, 0x5f, 0xf5, 0xec, 0x4e, 0x21, 0x4f, 0x8b,
+	0x11, 0xeb, 0xd9, 0x1d, 0x23, 0xd1, 0xc0, 0x1a, 0x2e, 0x83, 0x5d, 0x6c, 0xd3, 0xa8, 0x2d, 0xfe,
+	0x09, 0x6f, 0xc4, 0x2a, 0x56, 0x80, 0x44, 0xa3, 0xb5, 0x6b, 0xda, 0x85, 0x05, 0xce, 0xb3, 0x4d,
+	0xdb, 0x88, 0x37, 0x76, 0x4d, 0x9b, 0xdd, 0x81, 0xd8, 0x78, 0x72, 0x50, 0x60, 0x33, 0x7e, 0x0f,
+	0xdc, 0x9b, 0x1c, 0x78, 0xa3, 0x31, 0x10, 0xc4, 0x96, 0x21, 0x3d, 0x76, 0x47, 0xad, 0xdf, 0xb1,
+	0x46, 0x4e, 0xe1, 0x3d, 0x5a, 0xc8, 0x2b, 0x46, 0x6a, 0xec, 0x8e, 0xde, 0x58, 0x23, 0xe7, 0x82,
+	0xde, 0xb6, 0x78, 0x13, 0xb2, 0x92, 0x5d, 0x96, 0x07, 0xc5, 0xe6, 0x29, 0x4b, 0x5d, 0x79, 0x68,
+	0x28, 0x76, 0xf1, 0x0b, 0xc8, 0x79, 0x07, 0x2b, 0x9a, 0xf2, 0x1a, 0xbe, 0x4f, 0x7d, 0x67, 0x44,
+	0x2f, 0xea, 0x7c, 0xe5, 0x56, 0x24, 0x3e, 0x06, 0x48, 0x11, 0xa5, 0x38, 0xba, 0xa8, 0x45, 0x46,
+	0xa3, 0x14, 0xff, 0x53, 0x81, 0xdc, 0x8e, 0x33, 0x0a, 0x7e, 0xb9, 0x58, 0x84, 0xc4, 0x81, 0xe3,
+	0xf4, 0xc7, 0x64, 0x39, 0x6d, 0xf0, 0x02, 0xfb, 0x08, 0x72, 0xf4, 0xe0, 0x1d, 0x8f, 0x55, 0xff,
+	0xfe, 0x27, 0x4b, 0xf5, 0xe2, 0x44, 0xcc, 0x20, 0xde, 0xb3, 0xdd, 0xb1, 0xf0, 0x5b, 0xf4, 0xcc,
+	0x3e, 0x84, 0x2c, 0xfe, 0xf5, 0x98, 0x71, 0x3f, 0x85, 0x06, 0xac, 0x16, 0xc4, 0xef, 0xc1, 0x1c,
+	0xc9, 0xc0, 0x87, 0xa5, 0xfc, 0xbb, 0x9e, 0x1c, 0x6f, 0x10, 0xc0, 0x02, 0xa4, 0xb8, 0x4f, 0x18,
+	0xd3, 0x8f, 0xbd, 0x19, 0xc3, 0x2b, 0xa2, 0x33, 0xa5, 0xe3, 0x09, 0xcf, 0x38, 0x52, 0x86, 0x28,
+	0x15, 0x5f, 0x40, 0x9a, 0x22, 0x63, 0xb3, 0xdf, 0x66, 0x1f, 0x81, 0xd2, 0x2d, 0x58, 0x14, 0x9a,
+	0xaf, 0x85, 0xcf, 0x1e, 0x02, 0x51, 0xde, 0x34, 0x94, 0xee, 0xd2, 0x02, 0x28, 0x9b, 0x78, 0x18,
+	0x38, 0x16, 0x7e, 0x59, 0x39, 0x2e, 0x1a, 0xc2, 0xca, 0xae, 0xf5, 0xee, 0x1c, 0x2b, 0xbb, 0xd6,
+	0x3b, 0x6e, 0xe5, 0xd6, 0x94, 0x15, 0x2c, 0x9d, 0x88, 0x9f, 0xc0, 0x95, 0x93, 0xe2, 0x2a, 0xcc,
+	0xd1, 0xdb, 0xda, 0xb3, 0xbb, 0xaf, 0x9c, 0x9e, 0x4d, 0xe7, 0x8f, 0x0e, 0xe5, 0x6c, 0x8a, 0xa1,
+	0x74, 0x70, 0x27, 0xac, 0x63, 0xf3, 0x90, 0xe7, 0xc0, 0x69, 0x83, 0x17, 0x8a, 0xff, 0x15, 0x87,
+	0x79, 0xe1, 0x69, 0xbf, 0xe8, 0xb9, 0x47, 0x3b, 0xe6, 0x90, 0x35, 0x21, 0x87, 0x4e, 0xb6, 0x35,
+	0x30, 0x87, 0x43, 0x7c, 0x9b, 0x15, 0x8a, 0xc3, 0xf7, 0x66, 0x39, 0x6f, 0x41, 0x29, 0xef, 0x9a,
+	0x03, 0x6b, 0x87, 0xc3, 0x79, 0x54, 0xce, 0xda, 0x41, 0x0d, 0xdb, 0x86, 0xec, 0x60, 0xdc, 0xf5,
+	0xed, 0xf1, 0xb8, 0x7e, 0xf7, 0x2c, 0x7b, 0x3b, 0xe3, 0x6e, 0xc8, 0x1c, 0x0c, 0xfc, 0x0a, 0x1c,
+	0x1e, 0x3a, 0x69, 0xdf, 0x5c, 0xec, 0xfc, 0xe1, 0xa1, 0x4b, 0x09, 0x0f, 0xef, 0x20, 0xa8, 0x61,
+	0x9b, 0x00, 0xf8, 0xc2, 0xb9, 0x0e, 0x9e, 0xed, 0x48, 0x50, 0xd9, 0xca, 0xc7, 0x67, 0x99, 0xdb,
+	0x73, 0x47, 0xfb, 0xce, 0x9e, 0x3b, 0x12, 0x09, 0xc8, 0x58, 0x14, 0x97, 0x9e, 0x82, 0x16, 0x5d,
+	0x88, 0xf3, 0x72, 0x90, 0x8c, 0x94, 0x83, 0x2c, 0x7d, 0x09, 0xf9, 0xc8, 0xc4, 0x65, 0x3a, 0xe3,
+	0xf4, 0x15, 0x99, 0x9e, 0xad, 0x2c, 0x85, 0x3f, 0xd4, 0x90, 0xf7, 0x5f, 0x36, 0xfd, 0x14, 0xb4,
+	0xe8, 0x22, 0xc8, 0xb6, 0xd3, 0x67, 0x1c, 0x65, 0x88, 0xff, 0x04, 0xe6, 0x42, 0xb3, 0x96, 0xc9,
+	0x99, 0x73, 0xe6, 0x55, 0xfc, 0x83, 0x04, 0x24, 0x9a, 0xb6, 0xe5, 0x74, 0xd8, 0xb5, 0x70, 0x14,
+	0x7d, 0x79, 0xc5, 0x8b, 0xa0, 0xd7, 0x23, 0x11, 0xf4, 0xe5, 0x15, 0x3f, 0x7e, 0x5e, 0x8f, 0xc4,
+	0x4f, 0xaf, 0xa9, 0x56, 0x65, 0x37, 0xa6, 0xa2, 0xe7, 0xcb, 0x2b, 0x52, 0xe8, 0xbc, 0x31, 0x15,
+	0x3a, 0x83, 0xe6, 0x5a, 0x15, 0x1d, 0x6d, 0x38, 0x6e, 0xbe, 0xbc, 0x12, 0xc4, 0xcc, 0xe5, 0x68,
+	0xcc, 0xf4, 0x1b, 0x6b, 0x55, 0x3e, 0x24, 0x29, 0x5e, 0xd2, 0x90, 0x78, 0xa4, 0x5c, 0x8e, 0x46,
+	0x4a, 0xe2, 0x89, 0x18, 0xb9, 0x1c, 0x8d, 0x91, 0xd4, 0x28, 0x62, 0xe2, 0xf5, 0x48, 0x4c, 0x24,
+	0xa3, 0x3c, 0x18, 0x2e, 0x47, 0x83, 0x21, 0xe7, 0x49, 0x23, 0x95, 0x23, 0xa1, 0xdf, 0x58, 0xab,
+	0xb2, 0xb5, 0x48, 0x18, 0x3c, 0xf3, 0xf0, 0x41, 0xdb, 0x41, 0xf1, 0xe0, 0x21, 0xae, 0x9c, 0x97,
+	0x8e, 0xe6, 0xcf, 0xfe, 0x8a, 0x85, 0xd6, 0xd4, 0x4b, 0xd6, 0xd6, 0x20, 0xd5, 0x11, 0xe7, 0x74,
+	0x8d, 0x3c, 0x5a, 0x58, 0x9f, 0xa4, 0x82, 0x72, 0xa3, 0x45, 0x9e, 0x0d, 0x27, 0xd8, 0xe1, 0xa7,
+	0x8c, 0x12, 0xcc, 0x35, 0x5a, 0xdb, 0xe6, 0xa8, 0x6b, 0x8d, 0xdd, 0xd6, 0xbe, 0xd9, 0xf5, 0x2f,
+	0x3d, 0x50, 0x08, 0xd9, 0x86, 0x68, 0xd9, 0x37, 0xbb, 0xec, 0xaa, 0xa7, 0xb2, 0x36, 0xb5, 0x2a,
+	0x42, 0x67, 0x4b, 0xd7, 0x70, 0xf5, 0xb8, 0x31, 0xf2, 0x91, 0x0b, 0xc2, 0x47, 0xae, 0xa7, 0x20,
+	0x31, 0xb1, 0x7b, 0x8e, 0xbd, 0x9e, 0x81, 0x94, 0xeb, 0x8c, 0x06, 0xa6, 0xeb, 0x14, 0xff, 0x5b,
+	0x01, 0x78, 0xee, 0x0c, 0x06, 0x13, 0xbb, 0xf7, 0xd5, 0xc4, 0x62, 0x37, 0x21, 0x3b, 0x30, 0xdf,
+	0x5a, 0xad, 0x81, 0xd5, 0x3a, 0x1c, 0x79, 0x2f, 0x44, 0x06, 0xab, 0x76, 0xac, 0xe7, 0xa3, 0x13,
+	0x56, 0xf0, 0x32, 0x76, 0x12, 0x11, 0x69, 0x53, 0x64, 0xf0, 0x8b, 0x22, 0x37, 0x4d, 0x8a, 0xcd,
+	0xf4, 0xb2, 0x53, 0x7e, 0xb2, 0x49, 0x89, 0x6d, 0xe4, 0x67, 0x9b, 0x6b, 0x90, 0x74, 0xad, 0xc1,
+	0xb0, 0x75, 0x48, 0x9a, 0x41, 0x5d, 0x24, 0xb0, 0xfc, 0x9c, 0xad, 0x40, 0xec, 0xd0, 0xe9, 0x93,
+	0x5a, 0xce, 0xdf, 0x20, 0x84, 0xb2, 0x12, 0xc4, 0x06, 0x63, 0x2e, 0xa1, 0x6c, 0x65, 0x31, 0x9c,
+	0x4e, 0xf0, 0xf0, 0x85, 0xc8, 0xc1, 0xb8, 0xeb, 0xcf, 0xbe, 0xf8, 0x6b, 0x15, 0xd2, 0xb8, 0x65,
+	0xaf, 0xf7, 0x1b, 0x8f, 0xe8, 0xa0, 0x70, 0x68, 0xf6, 0xe9, 0x7e, 0x00, 0xdf, 0x55, 0x51, 0xc2,
+	0xfa, 0x9f, 0x58, 0x87, 0xae, 0x33, 0x22, 0x1f, 0x9d, 0x31, 0x44, 0x09, 0x17, 0x9d, 0x27, 0xc9,
+	0x31, 0x31, 0x4f, 0x5e, 0xa4, 0x0c, 0xdf, 0x1c, 0xb6, 0xd0, 0x11, 0x70, 0xb7, 0x19, 0x3e, 0x58,
+	0x7b, 0xfd, 0xe1, 0x89, 0xed, 0x33, 0xeb, 0x84, 0xbb, 0xcb, 0xe4, 0x80, 0x0a, 0xec, 0x07, 0xfc,
+	0xa8, 0xc7, 0x37, 0x93, 0x7f, 0x68, 0xf5, 0xe1, 0xa9, 0xec, 0xcf, 0x11, 0x15, 0x9c, 0xf7, 0xa8,
+	0xb8, 0xf4, 0x18, 0xb2, 0x92, 0xe1, 0xf3, 0x3c, 0x52, 0x2c, 0xe2, 0xce, 0x42, 0x56, 0xcf, 0xbb,
+	0xd6, 0x91, 0xdd, 0x19, 0xae, 0xa9, 0x83, 0x3a, 0xbe, 0x93, 0x87, 0x58, 0xa3, 0xd9, 0xc4, 0xb4,
+	0xab, 0xd1, 0x6c, 0x3e, 0xd0, 0x94, 0x7a, 0x05, 0xd2, 0xdd, 0x91, 0x65, 0xa1, 0x07, 0x3e, 0xf5,
+	0x70, 0xf7, 0x63, 0x5a, 0x59, 0x1f, 0x57, 0xdf, 0x83, 0xd4, 0x21, 0x3f, 0xde, 0xb1, 0xd3, 0x2f,
+	0x35, 0x0a, 0x7f, 0xcb, 0x6f, 0xd8, 0x6e, 0x84, 0x10, 0xd1, 0x63, 0xa1, 0xe1, 0x59, 0xaa, 0x7f,
+	0x0e, 0x99, 0x51, 0xeb, 0x02, 0x66, 0xbf, 0xe1, 0xb1, 0xfd, 0x1c, 0xb3, 0xe9, 0x91, 0xa8, 0xaa,
+	0xbf, 0x84, 0x05, 0xdb, 0xf1, 0x7e, 0xf1, 0x6b, 0xb5, 0xb9, 0x57, 0xfb, 0x60, 0x66, 0x6a, 0xed,
+	0x75, 0x61, 0xf1, 0x0f, 0x07, 0x6c, 0x47, 0x34, 0x70, 0x57, 0x58, 0x6f, 0x80, 0x26, 0x59, 0xa2,
+	0x8b, 0x87, 0x73, 0x0c, 0x75, 0xf8, 0xc7, 0x0a, 0xbe, 0x21, 0xf2, 0xb7, 0x11, 0x3b, 0xdc, 0x23,
+	0x9e, 0x6d, 0xa7, 0xcb, 0x3f, 0xfe, 0xf0, 0xed, 0x50, 0x94, 0x99, 0xb6, 0x53, 0xab, 0x9e, 0x63,
+	0xe7, 0x88, 0x7f, 0x1a, 0x22, 0xdb, 0xa9, 0x55, 0x23, 0x2b, 0x34, 0xb9, 0xc8, 0x80, 0x7a, 0xfc,
+	0xe3, 0x0e, 0xdf, 0x10, 0x8f, 0x40, 0x33, 0x2c, 0x9d, 0x3b, 0xa4, 0x1f, 0xf3, 0x4f, 0x3f, 0x42,
+	0x96, 0xa6, 0xc6, 0x34, 0xbe, 0xc8, 0x98, 0xde, 0xf2, 0x4f, 0x2d, 0x7c, 0x4b, 0x7b, 0xb3, 0xc6,
+	0x34, 0xbe, 0xc8, 0x98, 0xfa, 0xfc, 0x3b, 0x8c, 0x90, 0xa5, 0x5a, 0xb5, 0xfe, 0xdb, 0xc0, 0xe4,
+	0xfd, 0x17, 0x11, 0xfb, 0x6c, 0x53, 0x03, 0xfe, 0x81, 0x4d, 0xa0, 0x00, 0xce, 0x9a, 0x65, 0xeb,
+	0xdc, 0x61, 0xd9, 0xfc, 0xf3, 0x9b, 0xb0, 0xad, 0x5a, 0xb5, 0xbe, 0x0d, 0xef, 0xc9, 0x33, 0xbc,
+	0xd8, 0xc0, 0x1c, 0xfe, 0xf1, 0x48, 0x30, 0x47, 0x41, 0x9b, 0x69, 0xed, 0xdc, 0xa1, 0x0d, 0xf9,
+	0x97, 0x25, 0x11, 0x6b, 0xb5, 0x6a, 0xfd, 0x05, 0xe4, 0x25, 0x6b, 0x78, 0x50, 0x3a, 0xc7, 0xd2,
+	0x57, 0xfc, 0x83, 0x28, 0xdf, 0x12, 0xa6, 0x5a, 0xd1, 0x3d, 0xe4, 0xc9, 0xc7, 0xd9, 0x76, 0x46,
+	0xfc, 0x83, 0x9e, 0x60, 0x44, 0x44, 0x8a, 0xbc, 0x33, 0x74, 0x73, 0x72, 0x8e, 0xa1, 0x31, 0xff,
+	0xda, 0x27, 0x18, 0x10, 0x72, 0xea, 0x4e, 0x68, 0x5e, 0x16, 0x26, 0x20, 0x67, 0x9b, 0x71, 0x29,
+	0x54, 0x7e, 0x7c, 0x16, 0xa6, 0x2c, 0x5f, 0x64, 0x49, 0x4b, 0x80, 0xc5, 0xfa, 0x36, 0xcc, 0x5f,
+	0xca, 0x87, 0x7d, 0xa3, 0xf0, 0x3b, 0x8f, 0xd5, 0xf2, 0x83, 0xea, 0x83, 0x35, 0x63, 0xae, 0x1d,
+	0x72, 0x65, 0x2f, 0x61, 0xee, 0x32, 0x7e, 0xec, 0xe7, 0x0a, 0xbf, 0x39, 0x40, 0x63, 0x46, 0xae,
+	0x1d, 0x76, 0x66, 0x73, 0x97, 0xf1, 0x64, 0xbf, 0x50, 0xf8, 0x65, 0x53, 0xb5, 0xe2, 0xdb, 0xf1,
+	0x9c, 0xd9, 0xdc, 0x65, 0x3c, 0xd9, 0x2f, 0xf9, 0xd5, 0x80, 0x5a, 0x5d, 0x95, 0xed, 0x90, 0xe3,
+	0x98, 0xbf, 0x94, 0x27, 0xfb, 0x95, 0x42, 0xd7, 0x4f, 0x6a, 0xb5, 0xea, 0xaf, 0x91, 0xef, 0xcc,
+	0xe6, 0x2f, 0xe5, 0xc9, 0xfe, 0x4e, 0xa1, 0x7b, 0x2a, 0xb5, 0xba, 0x16, 0xb2, 0x14, 0x1e, 0xd3,
+	0x85, 0x3c, 0xd9, 0xdf, 0x2b, 0x74, 0x7b, 0xa4, 0x56, 0x6b, 0xbe, 0xa5, 0xbd, 0xa9, 0x31, 0x5d,
+	0xc8, 0x93, 0xfd, 0x03, 0x9d, 0xc2, 0xea, 0x6a, 0xf5, 0x61, 0xc8, 0x12, 0x39, 0xb3, 0xfc, 0xe5,
+	0x3c, 0xd9, 0xaf, 0x15, 0xba, 0xea, 0x53, 0xab, 0x8f, 0x0c, 0x6f, 0x0c, 0x81, 0x33, 0xcb, 0x5f,
+	0xce, 0x93, 0xfd, 0xa3, 0x42, 0x97, 0x82, 0x6a, 0xf5, 0x71, 0xd8, 0x16, 0x39, 0x33, 0xed, 0x92,
+	0x9e, 0xec, 0x9f, 0x14, 0xfa, 0xf4, 0x47, 0x5d, 0x5b, 0x31, 0xbc, 0x61, 0x48, 0xce, 0x4c, 0xbb,
+	0xa4, 0x27, 0xfb, 0x67, 0x85, 0x3e, 0x08, 0x52, 0xd7, 0x1e, 0x44, 0xac, 0xd5, 0xaa, 0xf5, 0x06,
+	0xe4, 0x2e, 0xe1, 0xc9, 0xfe, 0x45, 0xbe, 0x75, 0xcd, 0xb6, 0x25, 0x77, 0xf6, 0x23, 0x69, 0x17,
+	0x2f, 0xe2, 0xcb, 0xfe, 0x95, 0x12, 0xc4, 0xfa, 0xfb, 0x2f, 0xf9, 0xe5, 0x24, 0xe7, 0xdc, 0x6b,
+	0x5b, 0x9d, 0x4f, 0x3b, 0x8e, 0x13, 0x6c, 0x2c, 0xf7, 0x70, 0xaf, 0x82, 0x17, 0xe9, 0x22, 0xee,
+	0xed, 0xdf, 0x14, 0xba, 0xcc, 0xcc, 0x09, 0xdb, 0x44, 0xf1, 0x5f, 0x29, 0xee, 0xeb, 0x86, 0xc1,
+	0xb4, 0x2f, 0xe0, 0xe8, 0xfe, 0x5d, 0xb9, 0xa4, 0xa7, 0xab, 0xc7, 0x9a, 0xbb, 0x1b, 0xfe, 0x02,
+	0x61, 0xcd, 0xfa, 0xa7, 0x6f, 0x9e, 0x74, 0x7b, 0xee, 0xd1, 0xe4, 0xa0, 0x7c, 0xe8, 0x0c, 0xee,
+	0x77, 0x9d, 0xbe, 0x69, 0x77, 0xef, 0x93, 0xbd, 0x83, 0x49, 0xe7, 0x7e, 0xcf, 0x76, 0xad, 0x91,
+	0x6d, 0xf6, 0xe9, 0x1f, 0x44, 0xa8, 0x76, 0x7c, 0x5f, 0xfe, 0xc7, 0x91, 0xdf, 0x04, 0x00, 0x00,
+	0xff, 0xff, 0x4a, 0x65, 0x66, 0xff, 0x47, 0x32, 0x00, 0x00,
 }
diff --git a/vendor/github.com/golang/protobuf/proto/test_proto/test.proto b/vendor/github.com/golang/protobuf/internal/testprotos/proto2_proto/test.proto
similarity index 79%
rename from vendor/github.com/golang/protobuf/proto/test_proto/test.proto
rename to vendor/github.com/golang/protobuf/internal/testprotos/proto2_proto/test.proto
index 22068a959..3b9fe04e2 100644
--- a/vendor/github.com/golang/protobuf/proto/test_proto/test.proto
+++ b/vendor/github.com/golang/protobuf/internal/testprotos/proto2_proto/test.proto
@@ -1,41 +1,14 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// Copyright 2010 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.
 
 // A feature-rich test file for the protocol compiler and libraries.
 
 syntax = "proto2";
 
-option go_package = "github.com/golang/protobuf/proto/test_proto";
+option go_package = "github.com/golang/protobuf/internal/testprotos/proto2_proto";
 
-package test_proto;
+package proto2_test;
 
 enum FOO { FOO1 = 1; };
 
@@ -361,67 +334,9 @@ extend DefaultsMessage {
   optional DefaultsMessage.DefaultsEnum default_enum = 216 [default = ONE];
 }
 
-message MyMessageSet {
-  option message_set_wire_format = true;
-  extensions 100 to max;
-}
-
 message Empty {
 }
 
-extend MyMessageSet {
-    optional Empty x201 = 201;
-    optional Empty x202 = 202;
-    optional Empty x203 = 203;
-    optional Empty x204 = 204;
-    optional Empty x205 = 205;
-    optional Empty x206 = 206;
-    optional Empty x207 = 207;
-    optional Empty x208 = 208;
-    optional Empty x209 = 209;
-    optional Empty x210 = 210;
-    optional Empty x211 = 211;
-    optional Empty x212 = 212;
-    optional Empty x213 = 213;
-    optional Empty x214 = 214;
-    optional Empty x215 = 215;
-    optional Empty x216 = 216;
-    optional Empty x217 = 217;
-    optional Empty x218 = 218;
-    optional Empty x219 = 219;
-    optional Empty x220 = 220;
-    optional Empty x221 = 221;
-    optional Empty x222 = 222;
-    optional Empty x223 = 223;
-    optional Empty x224 = 224;
-    optional Empty x225 = 225;
-    optional Empty x226 = 226;
-    optional Empty x227 = 227;
-    optional Empty x228 = 228;
-    optional Empty x229 = 229;
-    optional Empty x230 = 230;
-    optional Empty x231 = 231;
-    optional Empty x232 = 232;
-    optional Empty x233 = 233;
-    optional Empty x234 = 234;
-    optional Empty x235 = 235;
-    optional Empty x236 = 236;
-    optional Empty x237 = 237;
-    optional Empty x238 = 238;
-    optional Empty x239 = 239;
-    optional Empty x240 = 240;
-    optional Empty x241 = 241;
-    optional Empty x242 = 242;
-    optional Empty x243 = 243;
-    optional Empty x244 = 244;
-    optional Empty x245 = 245;
-    optional Empty x246 = 246;
-    optional Empty x247 = 247;
-    optional Empty x248 = 248;
-    optional Empty x249 = 249;
-    optional Empty x250 = 250;
-}
-
 message MessageList {
   repeated group Message = 1 {
     required string name = 2;
@@ -560,3 +475,11 @@ message Communique {
     Strings msg = 10;
   }
 }
+
+message TestUTF8 {
+  optional string scalar = 1;
+  repeated string vector = 2;
+  oneof oneof { string field = 3; }
+  map<string, int64> map_key = 4;
+  map<int64, string> map_value = 5;
+}
diff --git a/vendor/github.com/golang/protobuf/internal/testprotos/proto3_proto/test.pb.go b/vendor/github.com/golang/protobuf/internal/testprotos/proto3_proto/test.pb.go
new file mode 100644
index 000000000..0aa2d9d07
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/internal/testprotos/proto3_proto/test.pb.go
@@ -0,0 +1,579 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: proto3_proto/test.proto
+
+package proto3_proto
+
+import (
+	fmt "fmt"
+	proto2_proto "github.com/golang/protobuf/internal/testprotos/proto2_proto"
+	proto "github.com/golang/protobuf/proto"
+	anypb "google.golang.org/protobuf/types/known/anypb"
+	math "math"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
+
+type Message_Humour int32
+
+const (
+	Message_UNKNOWN     Message_Humour = 0
+	Message_PUNS        Message_Humour = 1
+	Message_SLAPSTICK   Message_Humour = 2
+	Message_BILL_BAILEY Message_Humour = 3
+)
+
+var Message_Humour_name = map[int32]string{
+	0: "UNKNOWN",
+	1: "PUNS",
+	2: "SLAPSTICK",
+	3: "BILL_BAILEY",
+}
+
+var Message_Humour_value = map[string]int32{
+	"UNKNOWN":     0,
+	"PUNS":        1,
+	"SLAPSTICK":   2,
+	"BILL_BAILEY": 3,
+}
+
+func (x Message_Humour) String() string {
+	return proto.EnumName(Message_Humour_name, int32(x))
+}
+
+func (Message_Humour) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_ff83f0b8d2b92afa, []int{0, 0}
+}
+
+type Message struct {
+	Name                 string                               `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
+	Hilarity             Message_Humour                       `protobuf:"varint,2,opt,name=hilarity,proto3,enum=proto3_test.Message_Humour" json:"hilarity,omitempty"`
+	HeightInCm           uint32                               `protobuf:"varint,3,opt,name=height_in_cm,json=heightInCm,proto3" json:"height_in_cm,omitempty"`
+	Data                 []byte                               `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"`
+	ResultCount          int64                                `protobuf:"varint,7,opt,name=result_count,json=resultCount,proto3" json:"result_count,omitempty"`
+	TrueScotsman         bool                                 `protobuf:"varint,8,opt,name=true_scotsman,json=trueScotsman,proto3" json:"true_scotsman,omitempty"`
+	Score                float32                              `protobuf:"fixed32,9,opt,name=score,proto3" json:"score,omitempty"`
+	Key                  []uint64                             `protobuf:"varint,5,rep,packed,name=key,proto3" json:"key,omitempty"`
+	ShortKey             []int32                              `protobuf:"varint,19,rep,packed,name=short_key,json=shortKey,proto3" json:"short_key,omitempty"`
+	Nested               *Nested                              `protobuf:"bytes,6,opt,name=nested,proto3" json:"nested,omitempty"`
+	RFunny               []Message_Humour                     `protobuf:"varint,16,rep,packed,name=r_funny,json=rFunny,proto3,enum=proto3_test.Message_Humour" json:"r_funny,omitempty"`
+	Terrain              map[string]*Nested                   `protobuf:"bytes,10,rep,name=terrain,proto3" json:"terrain,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	Proto2Field          *proto2_proto.SubDefaults            `protobuf:"bytes,11,opt,name=proto2_field,json=proto2Field,proto3" json:"proto2_field,omitempty"`
+	Proto2Value          map[string]*proto2_proto.SubDefaults `protobuf:"bytes,13,rep,name=proto2_value,json=proto2Value,proto3" json:"proto2_value,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	Anything             *anypb.Any                           `protobuf:"bytes,14,opt,name=anything,proto3" json:"anything,omitempty"`
+	ManyThings           []*anypb.Any                         `protobuf:"bytes,15,rep,name=many_things,json=manyThings,proto3" json:"many_things,omitempty"`
+	Submessage           *Message                             `protobuf:"bytes,17,opt,name=submessage,proto3" json:"submessage,omitempty"`
+	Children             []*Message                           `protobuf:"bytes,18,rep,name=children,proto3" json:"children,omitempty"`
+	StringMap            map[string]string                    `protobuf:"bytes,20,rep,name=string_map,json=stringMap,proto3" json:"string_map,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	XXX_NoUnkeyedLiteral struct{}                             `json:"-"`
+	XXX_unrecognized     []byte                               `json:"-"`
+	XXX_sizecache        int32                                `json:"-"`
+}
+
+func (m *Message) Reset()         { *m = Message{} }
+func (m *Message) String() string { return proto.CompactTextString(m) }
+func (*Message) ProtoMessage()    {}
+func (*Message) Descriptor() ([]byte, []int) {
+	return fileDescriptor_ff83f0b8d2b92afa, []int{0}
+}
+
+func (m *Message) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Message.Unmarshal(m, b)
+}
+func (m *Message) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Message.Marshal(b, m, deterministic)
+}
+func (m *Message) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Message.Merge(m, src)
+}
+func (m *Message) XXX_Size() int {
+	return xxx_messageInfo_Message.Size(m)
+}
+func (m *Message) XXX_DiscardUnknown() {
+	xxx_messageInfo_Message.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message proto.InternalMessageInfo
+
+func (m *Message) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+func (m *Message) GetHilarity() Message_Humour {
+	if m != nil {
+		return m.Hilarity
+	}
+	return Message_UNKNOWN
+}
+
+func (m *Message) GetHeightInCm() uint32 {
+	if m != nil {
+		return m.HeightInCm
+	}
+	return 0
+}
+
+func (m *Message) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+func (m *Message) GetResultCount() int64 {
+	if m != nil {
+		return m.ResultCount
+	}
+	return 0
+}
+
+func (m *Message) GetTrueScotsman() bool {
+	if m != nil {
+		return m.TrueScotsman
+	}
+	return false
+}
+
+func (m *Message) GetScore() float32 {
+	if m != nil {
+		return m.Score
+	}
+	return 0
+}
+
+func (m *Message) GetKey() []uint64 {
+	if m != nil {
+		return m.Key
+	}
+	return nil
+}
+
+func (m *Message) GetShortKey() []int32 {
+	if m != nil {
+		return m.ShortKey
+	}
+	return nil
+}
+
+func (m *Message) GetNested() *Nested {
+	if m != nil {
+		return m.Nested
+	}
+	return nil
+}
+
+func (m *Message) GetRFunny() []Message_Humour {
+	if m != nil {
+		return m.RFunny
+	}
+	return nil
+}
+
+func (m *Message) GetTerrain() map[string]*Nested {
+	if m != nil {
+		return m.Terrain
+	}
+	return nil
+}
+
+func (m *Message) GetProto2Field() *proto2_proto.SubDefaults {
+	if m != nil {
+		return m.Proto2Field
+	}
+	return nil
+}
+
+func (m *Message) GetProto2Value() map[string]*proto2_proto.SubDefaults {
+	if m != nil {
+		return m.Proto2Value
+	}
+	return nil
+}
+
+func (m *Message) GetAnything() *anypb.Any {
+	if m != nil {
+		return m.Anything
+	}
+	return nil
+}
+
+func (m *Message) GetManyThings() []*anypb.Any {
+	if m != nil {
+		return m.ManyThings
+	}
+	return nil
+}
+
+func (m *Message) GetSubmessage() *Message {
+	if m != nil {
+		return m.Submessage
+	}
+	return nil
+}
+
+func (m *Message) GetChildren() []*Message {
+	if m != nil {
+		return m.Children
+	}
+	return nil
+}
+
+func (m *Message) GetStringMap() map[string]string {
+	if m != nil {
+		return m.StringMap
+	}
+	return nil
+}
+
+type Nested struct {
+	Bunny                string   `protobuf:"bytes,1,opt,name=bunny,proto3" json:"bunny,omitempty"`
+	Cute                 bool     `protobuf:"varint,2,opt,name=cute,proto3" json:"cute,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Nested) Reset()         { *m = Nested{} }
+func (m *Nested) String() string { return proto.CompactTextString(m) }
+func (*Nested) ProtoMessage()    {}
+func (*Nested) Descriptor() ([]byte, []int) {
+	return fileDescriptor_ff83f0b8d2b92afa, []int{1}
+}
+
+func (m *Nested) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Nested.Unmarshal(m, b)
+}
+func (m *Nested) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Nested.Marshal(b, m, deterministic)
+}
+func (m *Nested) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Nested.Merge(m, src)
+}
+func (m *Nested) XXX_Size() int {
+	return xxx_messageInfo_Nested.Size(m)
+}
+func (m *Nested) XXX_DiscardUnknown() {
+	xxx_messageInfo_Nested.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Nested proto.InternalMessageInfo
+
+func (m *Nested) GetBunny() string {
+	if m != nil {
+		return m.Bunny
+	}
+	return ""
+}
+
+func (m *Nested) GetCute() bool {
+	if m != nil {
+		return m.Cute
+	}
+	return false
+}
+
+type MessageWithMap struct {
+	ByteMapping          map[bool][]byte `protobuf:"bytes,1,rep,name=byte_mapping,json=byteMapping,proto3" json:"byte_mapping,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
+	XXX_unrecognized     []byte          `json:"-"`
+	XXX_sizecache        int32           `json:"-"`
+}
+
+func (m *MessageWithMap) Reset()         { *m = MessageWithMap{} }
+func (m *MessageWithMap) String() string { return proto.CompactTextString(m) }
+func (*MessageWithMap) ProtoMessage()    {}
+func (*MessageWithMap) Descriptor() ([]byte, []int) {
+	return fileDescriptor_ff83f0b8d2b92afa, []int{2}
+}
+
+func (m *MessageWithMap) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_MessageWithMap.Unmarshal(m, b)
+}
+func (m *MessageWithMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_MessageWithMap.Marshal(b, m, deterministic)
+}
+func (m *MessageWithMap) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MessageWithMap.Merge(m, src)
+}
+func (m *MessageWithMap) XXX_Size() int {
+	return xxx_messageInfo_MessageWithMap.Size(m)
+}
+func (m *MessageWithMap) XXX_DiscardUnknown() {
+	xxx_messageInfo_MessageWithMap.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MessageWithMap proto.InternalMessageInfo
+
+func (m *MessageWithMap) GetByteMapping() map[bool][]byte {
+	if m != nil {
+		return m.ByteMapping
+	}
+	return nil
+}
+
+type IntMap struct {
+	Rtt                  map[int32]int32 `protobuf:"bytes,1,rep,name=rtt,proto3" json:"rtt,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
+	XXX_unrecognized     []byte          `json:"-"`
+	XXX_sizecache        int32           `json:"-"`
+}
+
+func (m *IntMap) Reset()         { *m = IntMap{} }
+func (m *IntMap) String() string { return proto.CompactTextString(m) }
+func (*IntMap) ProtoMessage()    {}
+func (*IntMap) Descriptor() ([]byte, []int) {
+	return fileDescriptor_ff83f0b8d2b92afa, []int{3}
+}
+
+func (m *IntMap) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_IntMap.Unmarshal(m, b)
+}
+func (m *IntMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_IntMap.Marshal(b, m, deterministic)
+}
+func (m *IntMap) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_IntMap.Merge(m, src)
+}
+func (m *IntMap) XXX_Size() int {
+	return xxx_messageInfo_IntMap.Size(m)
+}
+func (m *IntMap) XXX_DiscardUnknown() {
+	xxx_messageInfo_IntMap.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_IntMap proto.InternalMessageInfo
+
+func (m *IntMap) GetRtt() map[int32]int32 {
+	if m != nil {
+		return m.Rtt
+	}
+	return nil
+}
+
+type IntMaps struct {
+	Maps                 []*IntMap `protobuf:"bytes,1,rep,name=maps,proto3" json:"maps,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
+	XXX_unrecognized     []byte    `json:"-"`
+	XXX_sizecache        int32     `json:"-"`
+}
+
+func (m *IntMaps) Reset()         { *m = IntMaps{} }
+func (m *IntMaps) String() string { return proto.CompactTextString(m) }
+func (*IntMaps) ProtoMessage()    {}
+func (*IntMaps) Descriptor() ([]byte, []int) {
+	return fileDescriptor_ff83f0b8d2b92afa, []int{4}
+}
+
+func (m *IntMaps) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_IntMaps.Unmarshal(m, b)
+}
+func (m *IntMaps) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_IntMaps.Marshal(b, m, deterministic)
+}
+func (m *IntMaps) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_IntMaps.Merge(m, src)
+}
+func (m *IntMaps) XXX_Size() int {
+	return xxx_messageInfo_IntMaps.Size(m)
+}
+func (m *IntMaps) XXX_DiscardUnknown() {
+	xxx_messageInfo_IntMaps.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_IntMaps proto.InternalMessageInfo
+
+func (m *IntMaps) GetMaps() []*IntMap {
+	if m != nil {
+		return m.Maps
+	}
+	return nil
+}
+
+type TestUTF8 struct {
+	Scalar string   `protobuf:"bytes,1,opt,name=scalar,proto3" json:"scalar,omitempty"`
+	Vector []string `protobuf:"bytes,2,rep,name=vector,proto3" json:"vector,omitempty"`
+	// Types that are valid to be assigned to Oneof:
+	//	*TestUTF8_Field
+	Oneof                isTestUTF8_Oneof `protobuf_oneof:"oneof"`
+	MapKey               map[string]int64 `protobuf:"bytes,4,rep,name=map_key,json=mapKey,proto3" json:"map_key,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+	MapValue             map[int64]string `protobuf:"bytes,5,rep,name=map_value,json=mapValue,proto3" json:"map_value,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
+	XXX_unrecognized     []byte           `json:"-"`
+	XXX_sizecache        int32            `json:"-"`
+}
+
+func (m *TestUTF8) Reset()         { *m = TestUTF8{} }
+func (m *TestUTF8) String() string { return proto.CompactTextString(m) }
+func (*TestUTF8) ProtoMessage()    {}
+func (*TestUTF8) Descriptor() ([]byte, []int) {
+	return fileDescriptor_ff83f0b8d2b92afa, []int{5}
+}
+
+func (m *TestUTF8) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_TestUTF8.Unmarshal(m, b)
+}
+func (m *TestUTF8) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_TestUTF8.Marshal(b, m, deterministic)
+}
+func (m *TestUTF8) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_TestUTF8.Merge(m, src)
+}
+func (m *TestUTF8) XXX_Size() int {
+	return xxx_messageInfo_TestUTF8.Size(m)
+}
+func (m *TestUTF8) XXX_DiscardUnknown() {
+	xxx_messageInfo_TestUTF8.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_TestUTF8 proto.InternalMessageInfo
+
+func (m *TestUTF8) GetScalar() string {
+	if m != nil {
+		return m.Scalar
+	}
+	return ""
+}
+
+func (m *TestUTF8) GetVector() []string {
+	if m != nil {
+		return m.Vector
+	}
+	return nil
+}
+
+type isTestUTF8_Oneof interface {
+	isTestUTF8_Oneof()
+}
+
+type TestUTF8_Field struct {
+	Field string `protobuf:"bytes,3,opt,name=field,proto3,oneof"`
+}
+
+func (*TestUTF8_Field) isTestUTF8_Oneof() {}
+
+func (m *TestUTF8) GetOneof() isTestUTF8_Oneof {
+	if m != nil {
+		return m.Oneof
+	}
+	return nil
+}
+
+func (m *TestUTF8) GetField() string {
+	if x, ok := m.GetOneof().(*TestUTF8_Field); ok {
+		return x.Field
+	}
+	return ""
+}
+
+func (m *TestUTF8) GetMapKey() map[string]int64 {
+	if m != nil {
+		return m.MapKey
+	}
+	return nil
+}
+
+func (m *TestUTF8) GetMapValue() map[int64]string {
+	if m != nil {
+		return m.MapValue
+	}
+	return nil
+}
+
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*TestUTF8) XXX_OneofWrappers() []interface{} {
+	return []interface{}{
+		(*TestUTF8_Field)(nil),
+	}
+}
+
+func init() {
+	proto.RegisterEnum("proto3_test.Message_Humour", Message_Humour_name, Message_Humour_value)
+	proto.RegisterType((*Message)(nil), "proto3_test.Message")
+	proto.RegisterMapType((map[string]*proto2_proto.SubDefaults)(nil), "proto3_test.Message.Proto2ValueEntry")
+	proto.RegisterMapType((map[string]string)(nil), "proto3_test.Message.StringMapEntry")
+	proto.RegisterMapType((map[string]*Nested)(nil), "proto3_test.Message.TerrainEntry")
+	proto.RegisterType((*Nested)(nil), "proto3_test.Nested")
+	proto.RegisterType((*MessageWithMap)(nil), "proto3_test.MessageWithMap")
+	proto.RegisterMapType((map[bool][]byte)(nil), "proto3_test.MessageWithMap.ByteMappingEntry")
+	proto.RegisterType((*IntMap)(nil), "proto3_test.IntMap")
+	proto.RegisterMapType((map[int32]int32)(nil), "proto3_test.IntMap.RttEntry")
+	proto.RegisterType((*IntMaps)(nil), "proto3_test.IntMaps")
+	proto.RegisterType((*TestUTF8)(nil), "proto3_test.TestUTF8")
+	proto.RegisterMapType((map[string]int64)(nil), "proto3_test.TestUTF8.MapKeyEntry")
+	proto.RegisterMapType((map[int64]string)(nil), "proto3_test.TestUTF8.MapValueEntry")
+}
+
+func init() { proto.RegisterFile("proto3_proto/test.proto", fileDescriptor_ff83f0b8d2b92afa) }
+
+var fileDescriptor_ff83f0b8d2b92afa = []byte{
+	// 926 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x55, 0x6d, 0x6f, 0xdb, 0x36,
+	0x10, 0xae, 0x2c, 0xbf, 0xc8, 0x67, 0x3b, 0xf5, 0x98, 0xa0, 0xe3, 0xdc, 0x7d, 0x50, 0x5d, 0x0c,
+	0xd3, 0xb0, 0x41, 0x1e, 0xbc, 0x6e, 0xeb, 0x9a, 0xbd, 0xc5, 0x59, 0x83, 0x18, 0x89, 0x9d, 0x40,
+	0x76, 0xd6, 0x6d, 0x5f, 0x04, 0xda, 0xa1, 0x6d, 0x61, 0x12, 0x65, 0x88, 0x54, 0x01, 0xfd, 0x9c,
+	0xfd, 0xa4, 0xfd, 0xa2, 0x0d, 0x24, 0xe5, 0x54, 0x6e, 0x15, 0xe4, 0x93, 0x79, 0x8f, 0x9f, 0xbb,
+	0xe7, 0x78, 0x77, 0x3c, 0xc1, 0xc7, 0xdb, 0x24, 0x16, 0xf1, 0x37, 0xbe, 0xfa, 0x19, 0x08, 0xca,
+	0x85, 0xab, 0x8e, 0xa8, 0x95, 0xff, 0x21, 0xa1, 0xde, 0x27, 0xeb, 0x38, 0x5e, 0x87, 0x74, 0xa0,
+	0xb0, 0x45, 0xba, 0x1a, 0x10, 0x96, 0x69, 0x5e, 0x4f, 0x07, 0x18, 0x7e, 0x10, 0xa0, 0xff, 0x9f,
+	0x05, 0x8d, 0x09, 0xe5, 0x9c, 0xac, 0x29, 0x42, 0x50, 0x65, 0x24, 0xa2, 0xd8, 0xb0, 0x0d, 0xa7,
+	0xe9, 0xa9, 0x33, 0xfa, 0x1e, 0xac, 0x4d, 0x10, 0x92, 0x24, 0x10, 0x19, 0xae, 0xd8, 0x86, 0x73,
+	0x30, 0x7c, 0xea, 0x16, 0x34, 0xdd, 0xdc, 0xd7, 0x3d, 0x4f, 0xa3, 0x38, 0x4d, 0xbc, 0x3b, 0x32,
+	0xb2, 0xa1, 0xbd, 0xa1, 0xc1, 0x7a, 0x23, 0xfc, 0x80, 0xf9, 0xcb, 0x08, 0x9b, 0xb6, 0xe1, 0x74,
+	0x3c, 0xd0, 0xd8, 0x98, 0x9d, 0x46, 0x52, 0xee, 0x96, 0x08, 0x82, 0xab, 0xb6, 0xe1, 0xb4, 0x3d,
+	0x75, 0x46, 0xcf, 0xa0, 0x9d, 0x50, 0x9e, 0x86, 0xc2, 0x5f, 0xc6, 0x29, 0x13, 0xb8, 0x61, 0x1b,
+	0x8e, 0xe9, 0xb5, 0x34, 0x76, 0x2a, 0x21, 0xf4, 0x1c, 0x3a, 0x22, 0x49, 0xa9, 0xcf, 0x97, 0xb1,
+	0xe0, 0x11, 0x61, 0xd8, 0xb2, 0x0d, 0xc7, 0xf2, 0xda, 0x12, 0x9c, 0xe5, 0x18, 0x3a, 0x82, 0x1a,
+	0x5f, 0xc6, 0x09, 0xc5, 0x4d, 0xdb, 0x70, 0x2a, 0x9e, 0x36, 0x50, 0x17, 0xcc, 0xbf, 0x69, 0x86,
+	0x6b, 0xb6, 0xe9, 0x54, 0x3d, 0x79, 0x44, 0x4f, 0xa1, 0xc9, 0x37, 0x71, 0x22, 0x7c, 0x89, 0x1f,
+	0xda, 0xa6, 0x53, 0xf3, 0x2c, 0x05, 0x5c, 0xd0, 0x0c, 0x7d, 0x09, 0x75, 0x46, 0xb9, 0xa0, 0xb7,
+	0xb8, 0x6e, 0x1b, 0x4e, 0x6b, 0x78, 0xb8, 0x77, 0xf3, 0xa9, 0xfa, 0xcb, 0xcb, 0x29, 0xe8, 0x05,
+	0x34, 0x12, 0x7f, 0x95, 0x32, 0x96, 0xe1, 0xae, 0x6d, 0x3e, 0x54, 0xa7, 0x7a, 0x72, 0x26, 0xa9,
+	0xe8, 0x18, 0x1a, 0x82, 0x26, 0x09, 0x09, 0x18, 0x06, 0xdb, 0x74, 0x5a, 0xc3, 0x67, 0xa5, 0x5e,
+	0x73, 0xcd, 0x79, 0xcd, 0x44, 0x92, 0x79, 0x3b, 0x0f, 0x74, 0x0c, 0xed, 0xbc, 0xad, 0xab, 0x80,
+	0x86, 0xb7, 0xb8, 0xa5, 0xb2, 0xc4, 0x6e, 0x0e, 0xaa, 0x08, 0xb3, 0x74, 0xf1, 0x1b, 0x5d, 0x91,
+	0x34, 0x14, 0xdc, 0xd3, 0xc3, 0x32, 0x3c, 0x93, 0x64, 0x74, 0x7e, 0xe7, 0xfc, 0x96, 0x84, 0x29,
+	0xc5, 0x1d, 0x25, 0xff, 0x59, 0xa9, 0xfc, 0xb5, 0x22, 0xfe, 0x2e, 0x79, 0x3a, 0x85, 0x3c, 0x92,
+	0x42, 0xd0, 0xd7, 0x60, 0x11, 0x96, 0x89, 0x4d, 0xc0, 0xd6, 0xf8, 0x40, 0xa5, 0x70, 0xe4, 0xea,
+	0x49, 0x74, 0x77, 0x93, 0xe8, 0x9e, 0xb0, 0xcc, 0xbb, 0x63, 0xa1, 0x6f, 0xa1, 0x15, 0x11, 0x96,
+	0xf9, 0xca, 0xe2, 0xf8, 0xb1, 0x92, 0x2e, 0x77, 0x02, 0x49, 0x9c, 0x2b, 0x1e, 0x7a, 0x01, 0xc0,
+	0xd3, 0x45, 0xa4, 0x93, 0xc2, 0x1f, 0xe5, 0x52, 0x25, 0x09, 0x7b, 0x05, 0x9e, 0x4c, 0x6f, 0xb9,
+	0x09, 0xc2, 0xdb, 0x84, 0x32, 0x8c, 0x72, 0xa5, 0x32, 0x9f, 0x3b, 0x16, 0x1a, 0x01, 0x70, 0x91,
+	0x04, 0x6c, 0xed, 0x47, 0x64, 0x8b, 0x8f, 0x94, 0xcf, 0xf3, 0xd2, 0xc2, 0xcc, 0x14, 0x6d, 0x42,
+	0xb6, 0xba, 0x2c, 0x4d, 0xbe, 0xb3, 0x7b, 0x57, 0xd0, 0x2e, 0x36, 0x6d, 0x37, 0x7a, 0xfa, 0x69,
+	0xa9, 0xd1, 0xfb, 0x02, 0x6a, 0xba, 0xf2, 0x95, 0xfb, 0x87, 0x4b, 0x33, 0x5e, 0x55, 0x5e, 0x1a,
+	0xbd, 0x3f, 0xa0, 0xfb, 0x7e, 0x1b, 0x4a, 0x82, 0xba, 0xfb, 0x41, 0xef, 0x9f, 0x85, 0x42, 0xe4,
+	0x1f, 0xe1, 0x60, 0xff, 0x1e, 0x25, 0x71, 0x8f, 0x8a, 0x71, 0x9b, 0x05, 0xef, 0xfe, 0x2f, 0x50,
+	0xd7, 0x33, 0x8d, 0x5a, 0xd0, 0xb8, 0x99, 0x5e, 0x4c, 0xaf, 0xde, 0x4c, 0xbb, 0x8f, 0x90, 0x05,
+	0xd5, 0xeb, 0x9b, 0xe9, 0xac, 0x6b, 0xa0, 0x0e, 0x34, 0x67, 0x97, 0x27, 0xd7, 0xb3, 0xf9, 0xf8,
+	0xf4, 0xa2, 0x5b, 0x41, 0x8f, 0xa1, 0x35, 0x1a, 0x5f, 0x5e, 0xfa, 0xa3, 0x93, 0xf1, 0xe5, 0xeb,
+	0x3f, 0xbb, 0x66, 0x7f, 0x08, 0x75, 0x7d, 0x5b, 0x29, 0xb2, 0x50, 0x0f, 0x48, 0x0b, 0x6b, 0x43,
+	0xae, 0x89, 0x65, 0x2a, 0xb4, 0xb2, 0xe5, 0xa9, 0x73, 0xff, 0x1f, 0x03, 0x0e, 0xf2, 0x1e, 0xbc,
+	0x09, 0xc4, 0x66, 0x42, 0xb6, 0xe8, 0x0a, 0xda, 0x8b, 0x4c, 0x50, 0xd9, 0xb2, 0xad, 0x9c, 0x44,
+	0x43, 0xb5, 0xed, 0xab, 0xb2, 0xb6, 0xe5, 0x2e, 0xee, 0x28, 0x13, 0x74, 0xa2, 0xe9, 0xf9, 0x58,
+	0x2f, 0xde, 0x21, 0xbd, 0x9f, 0xa1, 0xfb, 0x3e, 0xa1, 0x58, 0x18, 0xab, 0xa4, 0x30, 0xed, 0x62,
+	0x61, 0xb6, 0x50, 0x1f, 0x33, 0x21, 0x53, 0x73, 0xc1, 0x4c, 0x84, 0xc8, 0x33, 0xfa, 0x74, 0x2f,
+	0x23, 0xcd, 0x70, 0x3d, 0x21, 0x74, 0x06, 0x92, 0xd8, 0xfb, 0x0e, 0xac, 0x1d, 0x50, 0x54, 0xac,
+	0x95, 0x28, 0xd6, 0x8a, 0x8a, 0x43, 0x68, 0xe8, 0x78, 0x1c, 0x7d, 0x0e, 0xd5, 0x88, 0x6c, 0x79,
+	0xae, 0x79, 0x58, 0xa2, 0xe9, 0x29, 0x42, 0xff, 0xdf, 0x0a, 0x58, 0x73, 0xca, 0xc5, 0xcd, 0xfc,
+	0xec, 0x25, 0x7a, 0x02, 0x75, 0xbe, 0x24, 0x21, 0x49, 0xf2, 0x0e, 0xe4, 0x96, 0xc4, 0xdf, 0xd2,
+	0xa5, 0x88, 0x13, 0x5c, 0xb1, 0x4d, 0x89, 0x6b, 0x0b, 0x3d, 0x81, 0x9a, 0xde, 0x3c, 0x72, 0xb9,
+	0x37, 0xcf, 0x1f, 0x79, 0xda, 0x44, 0xaf, 0xa0, 0x11, 0x91, 0xad, 0xda, 0xa9, 0xd5, 0x92, 0xad,
+	0xb6, 0xd3, 0x73, 0x27, 0x64, 0x7b, 0x41, 0x33, 0x7d, 0xf3, 0x7a, 0xa4, 0x0c, 0xf4, 0x2b, 0x34,
+	0xa5, 0xaf, 0xbe, 0x62, 0xad, 0xe4, 0xed, 0x15, 0xbd, 0x0b, 0x2b, 0xc9, 0x8a, 0x72, 0xb3, 0xf7,
+	0x03, 0xb4, 0x0a, 0x81, 0x1f, 0x1a, 0x66, 0xb3, 0xf8, 0x14, 0x8e, 0xa1, 0xb3, 0x17, 0xb5, 0xe8,
+	0x6c, 0x3e, 0xf0, 0x12, 0x46, 0x0d, 0xa8, 0xc5, 0x8c, 0xc6, 0xab, 0xd1, 0x4f, 0x7f, 0x1d, 0xaf,
+	0x03, 0xb1, 0x49, 0x17, 0xee, 0x32, 0x8e, 0x06, 0xeb, 0x38, 0x24, 0x6c, 0xfd, 0xee, 0xa3, 0x1c,
+	0x30, 0x41, 0x13, 0x46, 0x42, 0xf5, 0x15, 0x56, 0x28, 0x1f, 0x14, 0x3f, 0xef, 0x8b, 0xba, 0xb6,
+	0xfe, 0x0f, 0x00, 0x00, 0xff, 0xff, 0x10, 0x03, 0x1b, 0x06, 0xf5, 0x07, 0x00, 0x00,
+}
diff --git a/vendor/github.com/golang/protobuf/internal/testprotos/proto3_proto/test.proto b/vendor/github.com/golang/protobuf/internal/testprotos/proto3_proto/test.proto
new file mode 100644
index 000000000..b1c6749d1
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/internal/testprotos/proto3_proto/test.proto
@@ -0,0 +1,72 @@
+// Copyright 2014 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.
+
+syntax = "proto3";
+
+option go_package = "github.com/golang/protobuf/internal/testprotos/proto3_proto";
+
+import "google/protobuf/any.proto";
+import "proto2_proto/test.proto";
+
+package proto3_test;
+
+message Message {
+  enum Humour {
+    UNKNOWN = 0;
+    PUNS = 1;
+    SLAPSTICK = 2;
+    BILL_BAILEY = 3;
+  }
+
+  string name = 1;
+  Humour hilarity = 2;
+  uint32 height_in_cm = 3;
+  bytes data = 4;
+  int64 result_count = 7;
+  bool true_scotsman = 8;
+  float score = 9;
+
+  repeated uint64 key = 5;
+  repeated int32 short_key = 19;
+  Nested nested = 6;
+  repeated Humour r_funny = 16;
+
+  map<string, Nested> terrain = 10;
+  proto2_test.SubDefaults proto2_field = 11;
+  map<string, proto2_test.SubDefaults> proto2_value = 13;
+
+  google.protobuf.Any anything = 14;
+  repeated google.protobuf.Any many_things = 15;
+
+  Message submessage = 17;
+  repeated Message children = 18;
+
+  map<string, string> string_map = 20;
+}
+
+message Nested {
+  string bunny = 1;
+  bool cute = 2;
+}
+
+message MessageWithMap {
+  map<bool, bytes> byte_mapping = 1;
+}
+
+
+message IntMap {
+  map<int32, int32> rtt = 1;
+}
+
+message IntMaps {
+  repeated IntMap maps = 1;
+}
+
+message TestUTF8 {
+  string scalar = 1;
+  repeated string vector = 2;
+  oneof oneof { string field = 3; }
+  map<string, int64> map_key = 4;
+  map<int64, string> map_value = 5;
+}
diff --git a/vendor/github.com/golang/protobuf/internal/testprotos/regenerate.bash b/vendor/github.com/golang/protobuf/internal/testprotos/regenerate.bash
new file mode 100644
index 000000000..c2eb29703
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/internal/testprotos/regenerate.bash
@@ -0,0 +1,17 @@
+#!/bin/bash
+# Copyright 2020 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.
+
+# NOTE: The integration scripts deliberately do not check to
+# make sure that the test protos have been regenerated.
+# It is intentional that older versions of the .pb.go files
+# are checked in to ensure that they continue to function.
+#
+# Versions used:
+#	protoc:        v3.9.1
+#	protoc-gen-go: v1.3.2
+
+for X in $(find . -name "*.proto" | sed "s|^\./||"); do
+	protoc -I$(pwd) --go_out=paths=source_relative:. $X
+done
diff --git a/vendor/github.com/golang/protobuf/jsonpb/decode.go b/vendor/github.com/golang/protobuf/jsonpb/decode.go
new file mode 100644
index 000000000..7c6c5a524
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/jsonpb/decode.go
@@ -0,0 +1,514 @@
+// Copyright 2015 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 jsonpb
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"math"
+	"reflect"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/golang/protobuf/proto"
+	"google.golang.org/protobuf/encoding/protojson"
+	protoV2 "google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/reflect/protoregistry"
+)
+
+const wrapJSONUnmarshalV2 = false
+
+// UnmarshalNext unmarshals the next JSON object from d into m.
+func UnmarshalNext(d *json.Decoder, m proto.Message) error {
+	return new(Unmarshaler).UnmarshalNext(d, m)
+}
+
+// Unmarshal unmarshals a JSON object from r into m.
+func Unmarshal(r io.Reader, m proto.Message) error {
+	return new(Unmarshaler).Unmarshal(r, m)
+}
+
+// UnmarshalString unmarshals a JSON object from s into m.
+func UnmarshalString(s string, m proto.Message) error {
+	return new(Unmarshaler).Unmarshal(strings.NewReader(s), m)
+}
+
+// Unmarshaler is a configurable object for converting from a JSON
+// representation to a protocol buffer object.
+type Unmarshaler struct {
+	// AllowUnknownFields specifies whether to allow messages to contain
+	// unknown JSON fields, as opposed to failing to unmarshal.
+	AllowUnknownFields bool
+
+	// AnyResolver is used to resolve the google.protobuf.Any well-known type.
+	// If unset, the global registry is used by default.
+	AnyResolver AnyResolver
+}
+
+// JSONPBUnmarshaler is implemented by protobuf messages that customize the way
+// they are unmarshaled from JSON. Messages that implement this should also
+// implement JSONPBMarshaler so that the custom format can be produced.
+//
+// The JSON unmarshaling must follow the JSON to proto specification:
+//	https://developers.google.com/protocol-buffers/docs/proto3#json
+//
+// Deprecated: Custom types should implement protobuf reflection instead.
+type JSONPBUnmarshaler interface {
+	UnmarshalJSONPB(*Unmarshaler, []byte) error
+}
+
+// Unmarshal unmarshals a JSON object from r into m.
+func (u *Unmarshaler) Unmarshal(r io.Reader, m proto.Message) error {
+	return u.UnmarshalNext(json.NewDecoder(r), m)
+}
+
+// UnmarshalNext unmarshals the next JSON object from d into m.
+func (u *Unmarshaler) UnmarshalNext(d *json.Decoder, m proto.Message) error {
+	if m == nil {
+		return errors.New("invalid nil message")
+	}
+
+	// Parse the next JSON object from the stream.
+	raw := json.RawMessage{}
+	if err := d.Decode(&raw); err != nil {
+		return err
+	}
+
+	// Check for custom unmarshalers first since they may not properly
+	// implement protobuf reflection that the logic below relies on.
+	if jsu, ok := m.(JSONPBUnmarshaler); ok {
+		return jsu.UnmarshalJSONPB(u, raw)
+	}
+
+	mr := proto.MessageReflect(m)
+
+	// NOTE: For historical reasons, a top-level null is treated as a noop.
+	// This is incorrect, but kept for compatibility.
+	if string(raw) == "null" && mr.Descriptor().FullName() != "google.protobuf.Value" {
+		return nil
+	}
+
+	if wrapJSONUnmarshalV2 {
+		// NOTE: If input message is non-empty, we need to preserve merge semantics
+		// of the old jsonpb implementation. These semantics are not supported by
+		// the protobuf JSON specification.
+		isEmpty := true
+		mr.Range(func(protoreflect.FieldDescriptor, protoreflect.Value) bool {
+			isEmpty = false // at least one iteration implies non-empty
+			return false
+		})
+		if !isEmpty {
+			// Perform unmarshaling into a newly allocated, empty message.
+			mr = mr.New()
+
+			// Use a defer to copy all unmarshaled fields into the original message.
+			dst := proto.MessageReflect(m)
+			defer mr.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
+				dst.Set(fd, v)
+				return true
+			})
+		}
+
+		// Unmarshal using the v2 JSON unmarshaler.
+		opts := protojson.UnmarshalOptions{
+			DiscardUnknown: u.AllowUnknownFields,
+		}
+		if u.AnyResolver != nil {
+			opts.Resolver = anyResolver{u.AnyResolver}
+		}
+		return opts.Unmarshal(raw, mr.Interface())
+	} else {
+		if err := u.unmarshalMessage(mr, raw); err != nil {
+			return err
+		}
+		return protoV2.CheckInitialized(mr.Interface())
+	}
+}
+
+func (u *Unmarshaler) unmarshalMessage(m protoreflect.Message, in []byte) error {
+	md := m.Descriptor()
+	fds := md.Fields()
+
+	if string(in) == "null" && md.FullName() != "google.protobuf.Value" {
+		return nil
+	}
+
+	if jsu, ok := proto.MessageV1(m.Interface()).(JSONPBUnmarshaler); ok {
+		return jsu.UnmarshalJSONPB(u, in)
+	}
+
+	switch wellKnownType(md.FullName()) {
+	case "Any":
+		var jsonObject map[string]json.RawMessage
+		if err := json.Unmarshal(in, &jsonObject); err != nil {
+			return err
+		}
+
+		rawTypeURL, ok := jsonObject["@type"]
+		if !ok {
+			return errors.New("Any JSON doesn't have '@type'")
+		}
+		typeURL, err := unquoteString(string(rawTypeURL))
+		if err != nil {
+			return fmt.Errorf("can't unmarshal Any's '@type': %q", rawTypeURL)
+		}
+		m.Set(fds.ByNumber(1), protoreflect.ValueOfString(typeURL))
+
+		var m2 protoreflect.Message
+		if u.AnyResolver != nil {
+			mi, err := u.AnyResolver.Resolve(typeURL)
+			if err != nil {
+				return err
+			}
+			m2 = proto.MessageReflect(mi)
+		} else {
+			mt, err := protoregistry.GlobalTypes.FindMessageByURL(typeURL)
+			if err != nil {
+				if err == protoregistry.NotFound {
+					return fmt.Errorf("could not resolve Any message type: %v", typeURL)
+				}
+				return err
+			}
+			m2 = mt.New()
+		}
+
+		if wellKnownType(m2.Descriptor().FullName()) != "" {
+			rawValue, ok := jsonObject["value"]
+			if !ok {
+				return errors.New("Any JSON doesn't have 'value'")
+			}
+			if err := u.unmarshalMessage(m2, rawValue); err != nil {
+				return fmt.Errorf("can't unmarshal Any nested proto %v: %v", typeURL, err)
+			}
+		} else {
+			delete(jsonObject, "@type")
+			rawJSON, err := json.Marshal(jsonObject)
+			if err != nil {
+				return fmt.Errorf("can't generate JSON for Any's nested proto to be unmarshaled: %v", err)
+			}
+			if err = u.unmarshalMessage(m2, rawJSON); err != nil {
+				return fmt.Errorf("can't unmarshal Any nested proto %v: %v", typeURL, err)
+			}
+		}
+
+		rawWire, err := protoV2.Marshal(m2.Interface())
+		if err != nil {
+			return fmt.Errorf("can't marshal proto %v into Any.Value: %v", typeURL, err)
+		}
+		m.Set(fds.ByNumber(2), protoreflect.ValueOfBytes(rawWire))
+		return nil
+	case "BoolValue", "BytesValue", "StringValue",
+		"Int32Value", "UInt32Value", "FloatValue",
+		"Int64Value", "UInt64Value", "DoubleValue":
+		fd := fds.ByNumber(1)
+		v, err := u.unmarshalValue(m.NewField(fd), in, fd)
+		if err != nil {
+			return err
+		}
+		m.Set(fd, v)
+		return nil
+	case "Duration":
+		v, err := unquoteString(string(in))
+		if err != nil {
+			return err
+		}
+		d, err := time.ParseDuration(v)
+		if err != nil {
+			return fmt.Errorf("bad Duration: %v", err)
+		}
+
+		sec := d.Nanoseconds() / 1e9
+		nsec := d.Nanoseconds() % 1e9
+		m.Set(fds.ByNumber(1), protoreflect.ValueOfInt64(int64(sec)))
+		m.Set(fds.ByNumber(2), protoreflect.ValueOfInt32(int32(nsec)))
+		return nil
+	case "Timestamp":
+		v, err := unquoteString(string(in))
+		if err != nil {
+			return err
+		}
+		t, err := time.Parse(time.RFC3339Nano, v)
+		if err != nil {
+			return fmt.Errorf("bad Timestamp: %v", err)
+		}
+
+		sec := t.Unix()
+		nsec := t.Nanosecond()
+		m.Set(fds.ByNumber(1), protoreflect.ValueOfInt64(int64(sec)))
+		m.Set(fds.ByNumber(2), protoreflect.ValueOfInt32(int32(nsec)))
+		return nil
+	case "Value":
+		switch {
+		case string(in) == "null":
+			m.Set(fds.ByNumber(1), protoreflect.ValueOfEnum(0))
+		case string(in) == "true":
+			m.Set(fds.ByNumber(4), protoreflect.ValueOfBool(true))
+		case string(in) == "false":
+			m.Set(fds.ByNumber(4), protoreflect.ValueOfBool(false))
+		case hasPrefixAndSuffix('"', in, '"'):
+			s, err := unquoteString(string(in))
+			if err != nil {
+				return fmt.Errorf("unrecognized type for Value %q", in)
+			}
+			m.Set(fds.ByNumber(3), protoreflect.ValueOfString(s))
+		case hasPrefixAndSuffix('[', in, ']'):
+			v := m.Mutable(fds.ByNumber(6))
+			return u.unmarshalMessage(v.Message(), in)
+		case hasPrefixAndSuffix('{', in, '}'):
+			v := m.Mutable(fds.ByNumber(5))
+			return u.unmarshalMessage(v.Message(), in)
+		default:
+			f, err := strconv.ParseFloat(string(in), 0)
+			if err != nil {
+				return fmt.Errorf("unrecognized type for Value %q", in)
+			}
+			m.Set(fds.ByNumber(2), protoreflect.ValueOfFloat64(f))
+		}
+		return nil
+	case "ListValue":
+		var jsonArray []json.RawMessage
+		if err := json.Unmarshal(in, &jsonArray); err != nil {
+			return fmt.Errorf("bad ListValue: %v", err)
+		}
+
+		lv := m.Mutable(fds.ByNumber(1)).List()
+		for _, raw := range jsonArray {
+			ve := lv.NewElement()
+			if err := u.unmarshalMessage(ve.Message(), raw); err != nil {
+				return err
+			}
+			lv.Append(ve)
+		}
+		return nil
+	case "Struct":
+		var jsonObject map[string]json.RawMessage
+		if err := json.Unmarshal(in, &jsonObject); err != nil {
+			return fmt.Errorf("bad StructValue: %v", err)
+		}
+
+		mv := m.Mutable(fds.ByNumber(1)).Map()
+		for key, raw := range jsonObject {
+			kv := protoreflect.ValueOf(key).MapKey()
+			vv := mv.NewValue()
+			if err := u.unmarshalMessage(vv.Message(), raw); err != nil {
+				return fmt.Errorf("bad value in StructValue for key %q: %v", key, err)
+			}
+			mv.Set(kv, vv)
+		}
+		return nil
+	}
+
+	var jsonObject map[string]json.RawMessage
+	if err := json.Unmarshal(in, &jsonObject); err != nil {
+		return err
+	}
+
+	// Handle known fields.
+	for i := 0; i < fds.Len(); i++ {
+		fd := fds.Get(i)
+		if fd.IsWeak() && fd.Message().IsPlaceholder() {
+			continue //  weak reference is not linked in
+		}
+
+		// Search for any raw JSON value associated with this field.
+		var raw json.RawMessage
+		name := string(fd.Name())
+		if fd.Kind() == protoreflect.GroupKind {
+			name = string(fd.Message().Name())
+		}
+		if v, ok := jsonObject[name]; ok {
+			delete(jsonObject, name)
+			raw = v
+		}
+		name = string(fd.JSONName())
+		if v, ok := jsonObject[name]; ok {
+			delete(jsonObject, name)
+			raw = v
+		}
+
+		// Unmarshal the field value.
+		if raw == nil || (string(raw) == "null" && !isSingularWellKnownValue(fd)) {
+			continue
+		}
+		v, err := u.unmarshalValue(m.NewField(fd), raw, fd)
+		if err != nil {
+			return err
+		}
+		m.Set(fd, v)
+	}
+
+	// Handle extension fields.
+	for name, raw := range jsonObject {
+		if !strings.HasPrefix(name, "[") || !strings.HasSuffix(name, "]") {
+			continue
+		}
+
+		// Resolve the extension field by name.
+		xname := protoreflect.FullName(name[len("[") : len(name)-len("]")])
+		xt, _ := protoregistry.GlobalTypes.FindExtensionByName(xname)
+		if xt == nil && isMessageSet(md) {
+			xt, _ = protoregistry.GlobalTypes.FindExtensionByName(xname.Append("message_set_extension"))
+		}
+		if xt == nil {
+			continue
+		}
+		delete(jsonObject, name)
+		fd := xt.TypeDescriptor()
+		if fd.ContainingMessage().FullName() != m.Descriptor().FullName() {
+			return fmt.Errorf("extension field %q does not extend message %q", xname, m.Descriptor().FullName())
+		}
+
+		// Unmarshal the field value.
+		if raw == nil || (string(raw) == "null" && !isSingularWellKnownValue(fd)) {
+			continue
+		}
+		v, err := u.unmarshalValue(m.NewField(fd), raw, fd)
+		if err != nil {
+			return err
+		}
+		m.Set(fd, v)
+	}
+
+	if !u.AllowUnknownFields && len(jsonObject) > 0 {
+		for name := range jsonObject {
+			return fmt.Errorf("unknown field %q in %v", name, md.FullName())
+		}
+	}
+	return nil
+}
+
+func isSingularWellKnownValue(fd protoreflect.FieldDescriptor) bool {
+	if md := fd.Message(); md != nil {
+		return md.FullName() == "google.protobuf.Value" && fd.Cardinality() != protoreflect.Repeated
+	}
+	return false
+}
+
+func (u *Unmarshaler) unmarshalValue(v protoreflect.Value, in []byte, fd protoreflect.FieldDescriptor) (protoreflect.Value, error) {
+	switch {
+	case fd.IsList():
+		var jsonArray []json.RawMessage
+		if err := json.Unmarshal(in, &jsonArray); err != nil {
+			return v, err
+		}
+		lv := v.List()
+		for _, raw := range jsonArray {
+			ve, err := u.unmarshalSingularValue(lv.NewElement(), raw, fd)
+			if err != nil {
+				return v, err
+			}
+			lv.Append(ve)
+		}
+		return v, nil
+	case fd.IsMap():
+		var jsonObject map[string]json.RawMessage
+		if err := json.Unmarshal(in, &jsonObject); err != nil {
+			return v, err
+		}
+		kfd := fd.MapKey()
+		vfd := fd.MapValue()
+		mv := v.Map()
+		for key, raw := range jsonObject {
+			var kv protoreflect.MapKey
+			if kfd.Kind() == protoreflect.StringKind {
+				kv = protoreflect.ValueOf(key).MapKey()
+			} else {
+				v, err := u.unmarshalSingularValue(kfd.Default(), []byte(key), kfd)
+				if err != nil {
+					return v, err
+				}
+				kv = v.MapKey()
+			}
+
+			vv, err := u.unmarshalSingularValue(mv.NewValue(), raw, vfd)
+			if err != nil {
+				return v, err
+			}
+			mv.Set(kv, vv)
+		}
+		return v, nil
+	default:
+		return u.unmarshalSingularValue(v, in, fd)
+	}
+}
+
+var nonFinite = map[string]float64{
+	`"NaN"`:       math.NaN(),
+	`"Infinity"`:  math.Inf(+1),
+	`"-Infinity"`: math.Inf(-1),
+}
+
+func (u *Unmarshaler) unmarshalSingularValue(v protoreflect.Value, in []byte, fd protoreflect.FieldDescriptor) (protoreflect.Value, error) {
+	switch fd.Kind() {
+	case protoreflect.BoolKind:
+		return unmarshalValue(in, new(bool))
+	case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
+		return unmarshalValue(trimQuote(in), new(int32))
+	case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
+		return unmarshalValue(trimQuote(in), new(int64))
+	case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
+		return unmarshalValue(trimQuote(in), new(uint32))
+	case protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
+		return unmarshalValue(trimQuote(in), new(uint64))
+	case protoreflect.FloatKind:
+		if f, ok := nonFinite[string(in)]; ok {
+			return protoreflect.ValueOfFloat32(float32(f)), nil
+		}
+		return unmarshalValue(trimQuote(in), new(float32))
+	case protoreflect.DoubleKind:
+		if f, ok := nonFinite[string(in)]; ok {
+			return protoreflect.ValueOfFloat64(float64(f)), nil
+		}
+		return unmarshalValue(trimQuote(in), new(float64))
+	case protoreflect.StringKind:
+		return unmarshalValue(in, new(string))
+	case protoreflect.BytesKind:
+		return unmarshalValue(in, new([]byte))
+	case protoreflect.EnumKind:
+		if hasPrefixAndSuffix('"', in, '"') {
+			vd := fd.Enum().Values().ByName(protoreflect.Name(trimQuote(in)))
+			if vd == nil {
+				return v, fmt.Errorf("unknown value %q for enum %s", in, fd.Enum().FullName())
+			}
+			return protoreflect.ValueOfEnum(vd.Number()), nil
+		}
+		return unmarshalValue(in, new(protoreflect.EnumNumber))
+	case protoreflect.MessageKind, protoreflect.GroupKind:
+		err := u.unmarshalMessage(v.Message(), in)
+		return v, err
+	default:
+		panic(fmt.Sprintf("invalid kind %v", fd.Kind()))
+	}
+}
+
+func unmarshalValue(in []byte, v interface{}) (protoreflect.Value, error) {
+	err := json.Unmarshal(in, v)
+	return protoreflect.ValueOf(reflect.ValueOf(v).Elem().Interface()), err
+}
+
+func unquoteString(in string) (out string, err error) {
+	err = json.Unmarshal([]byte(in), &out)
+	return out, err
+}
+
+func hasPrefixAndSuffix(prefix byte, in []byte, suffix byte) bool {
+	if len(in) >= 2 && in[0] == prefix && in[len(in)-1] == suffix {
+		return true
+	}
+	return false
+}
+
+// trimQuote is like unquoteString but simply strips surrounding quotes.
+// This is incorrect, but is behavior done by the legacy implementation.
+func trimQuote(in []byte) []byte {
+	if len(in) >= 2 && in[0] == '"' && in[len(in)-1] == '"' {
+		in = in[1 : len(in)-1]
+	}
+	return in
+}
diff --git a/vendor/github.com/golang/protobuf/jsonpb/encode.go b/vendor/github.com/golang/protobuf/jsonpb/encode.go
new file mode 100644
index 000000000..685c80a62
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/jsonpb/encode.go
@@ -0,0 +1,559 @@
+// Copyright 2015 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 jsonpb
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"math"
+	"reflect"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/golang/protobuf/proto"
+	"google.golang.org/protobuf/encoding/protojson"
+	protoV2 "google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/reflect/protoregistry"
+)
+
+const wrapJSONMarshalV2 = false
+
+// Marshaler is a configurable object for marshaling protocol buffer messages
+// to the specified JSON representation.
+type Marshaler struct {
+	// OrigName specifies whether to use the original protobuf name for fields.
+	OrigName bool
+
+	// EnumsAsInts specifies whether to render enum values as integers,
+	// as opposed to string values.
+	EnumsAsInts bool
+
+	// EmitDefaults specifies whether to render fields with zero values.
+	EmitDefaults bool
+
+	// Indent controls whether the output is compact or not.
+	// If empty, the output is compact JSON. Otherwise, every JSON object
+	// entry and JSON array value will be on its own line.
+	// Each line will be preceded by repeated copies of Indent, where the
+	// number of copies is the current indentation depth.
+	Indent string
+
+	// AnyResolver is used to resolve the google.protobuf.Any well-known type.
+	// If unset, the global registry is used by default.
+	AnyResolver AnyResolver
+}
+
+// JSONPBMarshaler is implemented by protobuf messages that customize the
+// way they are marshaled to JSON. Messages that implement this should also
+// implement JSONPBUnmarshaler so that the custom format can be parsed.
+//
+// The JSON marshaling must follow the proto to JSON specification:
+//	https://developers.google.com/protocol-buffers/docs/proto3#json
+//
+// Deprecated: Custom types should implement protobuf reflection instead.
+type JSONPBMarshaler interface {
+	MarshalJSONPB(*Marshaler) ([]byte, error)
+}
+
+// Marshal serializes a protobuf message as JSON into w.
+func (jm *Marshaler) Marshal(w io.Writer, m proto.Message) error {
+	b, err := jm.marshal(m)
+	if len(b) > 0 {
+		if _, err := w.Write(b); err != nil {
+			return err
+		}
+	}
+	return err
+}
+
+// MarshalToString serializes a protobuf message as JSON in string form.
+func (jm *Marshaler) MarshalToString(m proto.Message) (string, error) {
+	b, err := jm.marshal(m)
+	if err != nil {
+		return "", err
+	}
+	return string(b), nil
+}
+
+func (jm *Marshaler) marshal(m proto.Message) ([]byte, error) {
+	v := reflect.ValueOf(m)
+	if m == nil || (v.Kind() == reflect.Ptr && v.IsNil()) {
+		return nil, errors.New("Marshal called with nil")
+	}
+
+	// Check for custom marshalers first since they may not properly
+	// implement protobuf reflection that the logic below relies on.
+	if jsm, ok := m.(JSONPBMarshaler); ok {
+		return jsm.MarshalJSONPB(jm)
+	}
+
+	if wrapJSONMarshalV2 {
+		opts := protojson.MarshalOptions{
+			UseProtoNames:   jm.OrigName,
+			UseEnumNumbers:  jm.EnumsAsInts,
+			EmitUnpopulated: jm.EmitDefaults,
+			Indent:          jm.Indent,
+		}
+		if jm.AnyResolver != nil {
+			opts.Resolver = anyResolver{jm.AnyResolver}
+		}
+		return opts.Marshal(proto.MessageReflect(m).Interface())
+	} else {
+		// Check for unpopulated required fields first.
+		m2 := proto.MessageReflect(m)
+		if err := protoV2.CheckInitialized(m2.Interface()); err != nil {
+			return nil, err
+		}
+
+		w := jsonWriter{Marshaler: jm}
+		err := w.marshalMessage(m2, "", "")
+		return w.buf, err
+	}
+}
+
+type jsonWriter struct {
+	*Marshaler
+	buf []byte
+}
+
+func (w *jsonWriter) write(s string) {
+	w.buf = append(w.buf, s...)
+}
+
+func (w *jsonWriter) marshalMessage(m protoreflect.Message, indent, typeURL string) error {
+	if jsm, ok := proto.MessageV1(m.Interface()).(JSONPBMarshaler); ok {
+		b, err := jsm.MarshalJSONPB(w.Marshaler)
+		if err != nil {
+			return err
+		}
+		if typeURL != "" {
+			// we are marshaling this object to an Any type
+			var js map[string]*json.RawMessage
+			if err = json.Unmarshal(b, &js); err != nil {
+				return fmt.Errorf("type %T produced invalid JSON: %v", m.Interface(), err)
+			}
+			turl, err := json.Marshal(typeURL)
+			if err != nil {
+				return fmt.Errorf("failed to marshal type URL %q to JSON: %v", typeURL, err)
+			}
+			js["@type"] = (*json.RawMessage)(&turl)
+			if b, err = json.Marshal(js); err != nil {
+				return err
+			}
+		}
+		w.write(string(b))
+		return nil
+	}
+
+	md := m.Descriptor()
+	fds := md.Fields()
+
+	// Handle well-known types.
+	const secondInNanos = int64(time.Second / time.Nanosecond)
+	switch wellKnownType(md.FullName()) {
+	case "Any":
+		return w.marshalAny(m, indent)
+	case "BoolValue", "BytesValue", "StringValue",
+		"Int32Value", "UInt32Value", "FloatValue",
+		"Int64Value", "UInt64Value", "DoubleValue":
+		fd := fds.ByNumber(1)
+		return w.marshalValue(fd, m.Get(fd), indent)
+	case "Duration":
+		const maxSecondsInDuration = 315576000000
+		// "Generated output always contains 0, 3, 6, or 9 fractional digits,
+		//  depending on required precision."
+		s := m.Get(fds.ByNumber(1)).Int()
+		ns := m.Get(fds.ByNumber(2)).Int()
+		if s < -maxSecondsInDuration || s > maxSecondsInDuration {
+			return fmt.Errorf("seconds out of range %v", s)
+		}
+		if ns <= -secondInNanos || ns >= secondInNanos {
+			return fmt.Errorf("ns out of range (%v, %v)", -secondInNanos, secondInNanos)
+		}
+		if (s > 0 && ns < 0) || (s < 0 && ns > 0) {
+			return errors.New("signs of seconds and nanos do not match")
+		}
+		var sign string
+		if s < 0 || ns < 0 {
+			sign, s, ns = "-", -1*s, -1*ns
+		}
+		x := fmt.Sprintf("%s%d.%09d", sign, s, ns)
+		x = strings.TrimSuffix(x, "000")
+		x = strings.TrimSuffix(x, "000")
+		x = strings.TrimSuffix(x, ".000")
+		w.write(fmt.Sprintf(`"%vs"`, x))
+		return nil
+	case "Timestamp":
+		// "RFC 3339, where generated output will always be Z-normalized
+		//  and uses 0, 3, 6 or 9 fractional digits."
+		s := m.Get(fds.ByNumber(1)).Int()
+		ns := m.Get(fds.ByNumber(2)).Int()
+		if ns < 0 || ns >= secondInNanos {
+			return fmt.Errorf("ns out of range [0, %v)", secondInNanos)
+		}
+		t := time.Unix(s, ns).UTC()
+		// time.RFC3339Nano isn't exactly right (we need to get 3/6/9 fractional digits).
+		x := t.Format("2006-01-02T15:04:05.000000000")
+		x = strings.TrimSuffix(x, "000")
+		x = strings.TrimSuffix(x, "000")
+		x = strings.TrimSuffix(x, ".000")
+		w.write(fmt.Sprintf(`"%vZ"`, x))
+		return nil
+	case "Value":
+		// JSON value; which is a null, number, string, bool, object, or array.
+		od := md.Oneofs().Get(0)
+		fd := m.WhichOneof(od)
+		if fd == nil {
+			return errors.New("nil Value")
+		}
+		return w.marshalValue(fd, m.Get(fd), indent)
+	case "Struct", "ListValue":
+		// JSON object or array.
+		fd := fds.ByNumber(1)
+		return w.marshalValue(fd, m.Get(fd), indent)
+	}
+
+	w.write("{")
+	if w.Indent != "" {
+		w.write("\n")
+	}
+
+	firstField := true
+	if typeURL != "" {
+		if err := w.marshalTypeURL(indent, typeURL); err != nil {
+			return err
+		}
+		firstField = false
+	}
+
+	for i := 0; i < fds.Len(); {
+		fd := fds.Get(i)
+		if od := fd.ContainingOneof(); od != nil {
+			fd = m.WhichOneof(od)
+			i += od.Fields().Len()
+			if fd == nil {
+				continue
+			}
+		} else {
+			i++
+		}
+
+		v := m.Get(fd)
+
+		if !m.Has(fd) {
+			if !w.EmitDefaults || fd.ContainingOneof() != nil {
+				continue
+			}
+			if fd.Cardinality() != protoreflect.Repeated && (fd.Message() != nil || fd.Syntax() == protoreflect.Proto2) {
+				v = protoreflect.Value{} // use "null" for singular messages or proto2 scalars
+			}
+		}
+
+		if !firstField {
+			w.writeComma()
+		}
+		if err := w.marshalField(fd, v, indent); err != nil {
+			return err
+		}
+		firstField = false
+	}
+
+	// Handle proto2 extensions.
+	if md.ExtensionRanges().Len() > 0 {
+		// Collect a sorted list of all extension descriptor and values.
+		type ext struct {
+			desc protoreflect.FieldDescriptor
+			val  protoreflect.Value
+		}
+		var exts []ext
+		m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
+			if fd.IsExtension() {
+				exts = append(exts, ext{fd, v})
+			}
+			return true
+		})
+		sort.Slice(exts, func(i, j int) bool {
+			return exts[i].desc.Number() < exts[j].desc.Number()
+		})
+
+		for _, ext := range exts {
+			if !firstField {
+				w.writeComma()
+			}
+			if err := w.marshalField(ext.desc, ext.val, indent); err != nil {
+				return err
+			}
+			firstField = false
+		}
+	}
+
+	if w.Indent != "" {
+		w.write("\n")
+		w.write(indent)
+	}
+	w.write("}")
+	return nil
+}
+
+func (w *jsonWriter) writeComma() {
+	if w.Indent != "" {
+		w.write(",\n")
+	} else {
+		w.write(",")
+	}
+}
+
+func (w *jsonWriter) marshalAny(m protoreflect.Message, indent string) error {
+	// "If the Any contains a value that has a special JSON mapping,
+	//  it will be converted as follows: {"@type": xxx, "value": yyy}.
+	//  Otherwise, the value will be converted into a JSON object,
+	//  and the "@type" field will be inserted to indicate the actual data type."
+	md := m.Descriptor()
+	typeURL := m.Get(md.Fields().ByNumber(1)).String()
+	rawVal := m.Get(md.Fields().ByNumber(2)).Bytes()
+
+	var m2 protoreflect.Message
+	if w.AnyResolver != nil {
+		mi, err := w.AnyResolver.Resolve(typeURL)
+		if err != nil {
+			return err
+		}
+		m2 = proto.MessageReflect(mi)
+	} else {
+		mt, err := protoregistry.GlobalTypes.FindMessageByURL(typeURL)
+		if err != nil {
+			return err
+		}
+		m2 = mt.New()
+	}
+
+	if err := protoV2.Unmarshal(rawVal, m2.Interface()); err != nil {
+		return err
+	}
+
+	if wellKnownType(m2.Descriptor().FullName()) == "" {
+		return w.marshalMessage(m2, indent, typeURL)
+	}
+
+	w.write("{")
+	if w.Indent != "" {
+		w.write("\n")
+	}
+	if err := w.marshalTypeURL(indent, typeURL); err != nil {
+		return err
+	}
+	w.writeComma()
+	if w.Indent != "" {
+		w.write(indent)
+		w.write(w.Indent)
+		w.write(`"value": `)
+	} else {
+		w.write(`"value":`)
+	}
+	if err := w.marshalMessage(m2, indent+w.Indent, ""); err != nil {
+		return err
+	}
+	if w.Indent != "" {
+		w.write("\n")
+		w.write(indent)
+	}
+	w.write("}")
+	return nil
+}
+
+func (w *jsonWriter) marshalTypeURL(indent, typeURL string) error {
+	if w.Indent != "" {
+		w.write(indent)
+		w.write(w.Indent)
+	}
+	w.write(`"@type":`)
+	if w.Indent != "" {
+		w.write(" ")
+	}
+	b, err := json.Marshal(typeURL)
+	if err != nil {
+		return err
+	}
+	w.write(string(b))
+	return nil
+}
+
+// marshalField writes field description and value to the Writer.
+func (w *jsonWriter) marshalField(fd protoreflect.FieldDescriptor, v protoreflect.Value, indent string) error {
+	if w.Indent != "" {
+		w.write(indent)
+		w.write(w.Indent)
+	}
+	w.write(`"`)
+	switch {
+	case fd.IsExtension():
+		// For message set, use the fname of the message as the extension name.
+		name := string(fd.FullName())
+		if isMessageSet(fd.ContainingMessage()) {
+			name = strings.TrimSuffix(name, ".message_set_extension")
+		}
+
+		w.write("[" + name + "]")
+	case w.OrigName:
+		name := string(fd.Name())
+		if fd.Kind() == protoreflect.GroupKind {
+			name = string(fd.Message().Name())
+		}
+		w.write(name)
+	default:
+		w.write(string(fd.JSONName()))
+	}
+	w.write(`":`)
+	if w.Indent != "" {
+		w.write(" ")
+	}
+	return w.marshalValue(fd, v, indent)
+}
+
+func (w *jsonWriter) marshalValue(fd protoreflect.FieldDescriptor, v protoreflect.Value, indent string) error {
+	switch {
+	case fd.IsList():
+		w.write("[")
+		comma := ""
+		lv := v.List()
+		for i := 0; i < lv.Len(); i++ {
+			w.write(comma)
+			if w.Indent != "" {
+				w.write("\n")
+				w.write(indent)
+				w.write(w.Indent)
+				w.write(w.Indent)
+			}
+			if err := w.marshalSingularValue(fd, lv.Get(i), indent+w.Indent); err != nil {
+				return err
+			}
+			comma = ","
+		}
+		if w.Indent != "" {
+			w.write("\n")
+			w.write(indent)
+			w.write(w.Indent)
+		}
+		w.write("]")
+		return nil
+	case fd.IsMap():
+		kfd := fd.MapKey()
+		vfd := fd.MapValue()
+		mv := v.Map()
+
+		// Collect a sorted list of all map keys and values.
+		type entry struct{ key, val protoreflect.Value }
+		var entries []entry
+		mv.Range(func(k protoreflect.MapKey, v protoreflect.Value) bool {
+			entries = append(entries, entry{k.Value(), v})
+			return true
+		})
+		sort.Slice(entries, func(i, j int) bool {
+			switch kfd.Kind() {
+			case protoreflect.BoolKind:
+				return !entries[i].key.Bool() && entries[j].key.Bool()
+			case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind, protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
+				return entries[i].key.Int() < entries[j].key.Int()
+			case protoreflect.Uint32Kind, protoreflect.Fixed32Kind, protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
+				return entries[i].key.Uint() < entries[j].key.Uint()
+			case protoreflect.StringKind:
+				return entries[i].key.String() < entries[j].key.String()
+			default:
+				panic("invalid kind")
+			}
+		})
+
+		w.write(`{`)
+		comma := ""
+		for _, entry := range entries {
+			w.write(comma)
+			if w.Indent != "" {
+				w.write("\n")
+				w.write(indent)
+				w.write(w.Indent)
+				w.write(w.Indent)
+			}
+
+			s := fmt.Sprint(entry.key.Interface())
+			b, err := json.Marshal(s)
+			if err != nil {
+				return err
+			}
+			w.write(string(b))
+
+			w.write(`:`)
+			if w.Indent != "" {
+				w.write(` `)
+			}
+
+			if err := w.marshalSingularValue(vfd, entry.val, indent+w.Indent); err != nil {
+				return err
+			}
+			comma = ","
+		}
+		if w.Indent != "" {
+			w.write("\n")
+			w.write(indent)
+			w.write(w.Indent)
+		}
+		w.write(`}`)
+		return nil
+	default:
+		return w.marshalSingularValue(fd, v, indent)
+	}
+}
+
+func (w *jsonWriter) marshalSingularValue(fd protoreflect.FieldDescriptor, v protoreflect.Value, indent string) error {
+	switch {
+	case !v.IsValid():
+		w.write("null")
+		return nil
+	case fd.Message() != nil:
+		return w.marshalMessage(v.Message(), indent+w.Indent, "")
+	case fd.Enum() != nil:
+		if fd.Enum().FullName() == "google.protobuf.NullValue" {
+			w.write("null")
+			return nil
+		}
+
+		vd := fd.Enum().Values().ByNumber(v.Enum())
+		if vd == nil || w.EnumsAsInts {
+			w.write(strconv.Itoa(int(v.Enum())))
+		} else {
+			w.write(`"` + string(vd.Name()) + `"`)
+		}
+		return nil
+	default:
+		switch v.Interface().(type) {
+		case float32, float64:
+			switch {
+			case math.IsInf(v.Float(), +1):
+				w.write(`"Infinity"`)
+				return nil
+			case math.IsInf(v.Float(), -1):
+				w.write(`"-Infinity"`)
+				return nil
+			case math.IsNaN(v.Float()):
+				w.write(`"NaN"`)
+				return nil
+			}
+		case int64, uint64:
+			w.write(fmt.Sprintf(`"%d"`, v.Interface()))
+			return nil
+		}
+
+		b, err := json.Marshal(v.Interface())
+		if err != nil {
+			return err
+		}
+		w.write(string(b))
+		return nil
+	}
+}
diff --git a/vendor/github.com/golang/protobuf/jsonpb/json.go b/vendor/github.com/golang/protobuf/jsonpb/json.go
new file mode 100644
index 000000000..480e2448d
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/jsonpb/json.go
@@ -0,0 +1,69 @@
+// Copyright 2015 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 jsonpb provides functionality to marshal and unmarshal between a
+// protocol buffer message and JSON. It follows the specification at
+// https://developers.google.com/protocol-buffers/docs/proto3#json.
+//
+// Do not rely on the default behavior of the standard encoding/json package
+// when called on generated message types as it does not operate correctly.
+//
+// Deprecated: Use the "google.golang.org/protobuf/encoding/protojson"
+// package instead.
+package jsonpb
+
+import (
+	"github.com/golang/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/reflect/protoregistry"
+	"google.golang.org/protobuf/runtime/protoimpl"
+)
+
+// AnyResolver takes a type URL, present in an Any message,
+// and resolves it into an instance of the associated message.
+type AnyResolver interface {
+	Resolve(typeURL string) (proto.Message, error)
+}
+
+type anyResolver struct{ AnyResolver }
+
+func (r anyResolver) FindMessageByName(message protoreflect.FullName) (protoreflect.MessageType, error) {
+	return r.FindMessageByURL(string(message))
+}
+
+func (r anyResolver) FindMessageByURL(url string) (protoreflect.MessageType, error) {
+	m, err := r.Resolve(url)
+	if err != nil {
+		return nil, err
+	}
+	return protoimpl.X.MessageTypeOf(m), nil
+}
+
+func (r anyResolver) FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error) {
+	return protoregistry.GlobalTypes.FindExtensionByName(field)
+}
+
+func (r anyResolver) FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error) {
+	return protoregistry.GlobalTypes.FindExtensionByNumber(message, field)
+}
+
+func wellKnownType(s protoreflect.FullName) string {
+	if s.Parent() == "google.protobuf" {
+		switch s.Name() {
+		case "Empty", "Any",
+			"BoolValue", "BytesValue", "StringValue",
+			"Int32Value", "UInt32Value", "FloatValue",
+			"Int64Value", "UInt64Value", "DoubleValue",
+			"Duration", "Timestamp",
+			"NullValue", "Struct", "Value", "ListValue":
+			return string(s.Name())
+		}
+	}
+	return ""
+}
+
+func isMessageSet(md protoreflect.MessageDescriptor) bool {
+	ms, ok := md.(interface{ IsMessageSet() bool })
+	return ok && ms.IsMessageSet()
+}
diff --git a/vendor/github.com/golang/protobuf/jsonpb/jsonpb_test.go b/vendor/github.com/golang/protobuf/jsonpb/json_test.go
similarity index 51%
rename from vendor/github.com/golang/protobuf/jsonpb/jsonpb_test.go
rename to vendor/github.com/golang/protobuf/jsonpb/json_test.go
index 54ed681a0..0ef23f2d3 100644
--- a/vendor/github.com/golang/protobuf/jsonpb/jsonpb_test.go
+++ b/vendor/github.com/golang/protobuf/jsonpb/json_test.go
@@ -1,38 +1,12 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2015 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// Copyright 2015 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 jsonpb
 
 import (
 	"bytes"
+	"compress/gzip"
 	"encoding/json"
 	"io"
 	"math"
@@ -41,10 +15,11 @@ import (
 	"testing"
 
 	"github.com/golang/protobuf/proto"
-
-	pb "github.com/golang/protobuf/jsonpb/jsonpb_test_proto"
-	proto3pb "github.com/golang/protobuf/proto/proto3_proto"
 	"github.com/golang/protobuf/ptypes"
+
+	pb2 "github.com/golang/protobuf/internal/testprotos/jsonpb_proto"
+	pb3 "github.com/golang/protobuf/internal/testprotos/proto3_proto"
+	descpb "github.com/golang/protobuf/protoc-gen-go/descriptor"
 	anypb "github.com/golang/protobuf/ptypes/any"
 	durpb "github.com/golang/protobuf/ptypes/duration"
 	stpb "github.com/golang/protobuf/ptypes/struct"
@@ -59,49 +34,117 @@ var (
 		Indent: "  ",
 	}
 
-	simpleObject = &pb.Simple{
-		OInt32:  proto.Int32(-32),
-		OInt64:  proto.Int64(-6400000000),
-		OUint32: proto.Uint32(32),
-		OUint64: proto.Uint64(6400000000),
-		OSint32: proto.Int32(-13),
-		OSint64: proto.Int64(-2600000000),
-		OFloat:  proto.Float32(3.14),
-		ODouble: proto.Float64(6.02214179e23),
-		OBool:   proto.Bool(true),
-		OString: proto.String("hello \"there\""),
-		OBytes:  []byte("beep boop"),
+	simpleObject = &pb2.Simple{
+		OInt32:     proto.Int32(-32),
+		OInt32Str:  proto.Int32(-32),
+		OInt64:     proto.Int64(-6400000000),
+		OInt64Str:  proto.Int64(-6400000000),
+		OUint32:    proto.Uint32(32),
+		OUint32Str: proto.Uint32(32),
+		OUint64:    proto.Uint64(6400000000),
+		OUint64Str: proto.Uint64(6400000000),
+		OSint32:    proto.Int32(-13),
+		OSint32Str: proto.Int32(-13),
+		OSint64:    proto.Int64(-2600000000),
+		OSint64Str: proto.Int64(-2600000000),
+		OFloat:     proto.Float32(3.14),
+		OFloatStr:  proto.Float32(3.14),
+		ODouble:    proto.Float64(6.02214179e23),
+		ODoubleStr: proto.Float64(6.02214179e23),
+		OBool:      proto.Bool(true),
+		OString:    proto.String("hello \"there\""),
+		OBytes:     []byte("beep boop"),
 	}
 
-	simpleObjectJSON = `{` +
+	simpleObjectInputJSON = `{` +
+		`"oBool":true,` +
+		`"oInt32":-32,` +
+		`"oInt32Str":"-32",` +
+		`"oInt64":-6400000000,` +
+		`"oInt64Str":"-6400000000",` +
+		`"oUint32":32,` +
+		`"oUint32Str":"32",` +
+		`"oUint64":6400000000,` +
+		`"oUint64Str":"6400000000",` +
+		`"oSint32":-13,` +
+		`"oSint32Str":"-13",` +
+		`"oSint64":-2600000000,` +
+		`"oSint64Str":"-2600000000",` +
+		`"oFloat":3.14,` +
+		`"oFloatStr":"3.14",` +
+		`"oDouble":6.02214179e+23,` +
+		`"oDoubleStr":"6.02214179e+23",` +
+		`"oString":"hello \"there\"",` +
+		`"oBytes":"YmVlcCBib29w"` +
+		`}`
+
+	simpleObjectOutputJSON = `{` +
 		`"oBool":true,` +
 		`"oInt32":-32,` +
+		`"oInt32Str":-32,` +
 		`"oInt64":"-6400000000",` +
+		`"oInt64Str":"-6400000000",` +
 		`"oUint32":32,` +
+		`"oUint32Str":32,` +
 		`"oUint64":"6400000000",` +
+		`"oUint64Str":"6400000000",` +
 		`"oSint32":-13,` +
+		`"oSint32Str":-13,` +
 		`"oSint64":"-2600000000",` +
+		`"oSint64Str":"-2600000000",` +
 		`"oFloat":3.14,` +
+		`"oFloatStr":3.14,` +
 		`"oDouble":6.02214179e+23,` +
+		`"oDoubleStr":6.02214179e+23,` +
 		`"oString":"hello \"there\"",` +
 		`"oBytes":"YmVlcCBib29w"` +
 		`}`
 
-	simpleObjectPrettyJSON = `{
+	simpleObjectInputPrettyJSON = `{
   "oBool": true,
   "oInt32": -32,
+  "oInt32Str": "-32",
+  "oInt64": -6400000000,
+  "oInt64Str": "-6400000000",
+  "oUint32": 32,
+  "oUint32Str": "32",
+  "oUint64": 6400000000,
+  "oUint64Str": "6400000000",
+  "oSint32": -13,
+  "oSint32Str": "-13",
+  "oSint64": -2600000000,
+  "oSint64Str": "-2600000000",
+  "oFloat": 3.14,
+  "oFloatStr": "3.14",
+  "oDouble": 6.02214179e+23,
+  "oDoubleStr": "6.02214179e+23",
+  "oString": "hello \"there\"",
+  "oBytes": "YmVlcCBib29w"
+}`
+
+	simpleObjectOutputPrettyJSON = `{
+  "oBool": true,
+  "oInt32": -32,
+  "oInt32Str": -32,
   "oInt64": "-6400000000",
+  "oInt64Str": "-6400000000",
   "oUint32": 32,
+  "oUint32Str": 32,
   "oUint64": "6400000000",
+  "oUint64Str": "6400000000",
   "oSint32": -13,
+  "oSint32Str": -13,
   "oSint64": "-2600000000",
+  "oSint64Str": "-2600000000",
   "oFloat": 3.14,
+  "oFloatStr": 3.14,
   "oDouble": 6.02214179e+23,
+  "oDoubleStr": 6.02214179e+23,
   "oString": "hello \"there\"",
   "oBytes": "YmVlcCBib29w"
 }`
 
-	repeatsObject = &pb.Repeats{
+	repeatsObject = &pb2.Repeats{
 		RBool:   []bool{true, false, true},
 		RInt32:  []int32{-3, -4, -5},
 		RInt64:  []int64{-123456789, -987654321},
@@ -180,17 +223,17 @@ var (
   ]
 }`
 
-	innerSimple   = &pb.Simple{OInt32: proto.Int32(-32)}
-	innerSimple2  = &pb.Simple{OInt64: proto.Int64(25)}
-	innerRepeats  = &pb.Repeats{RString: []string{"roses", "red"}}
-	innerRepeats2 = &pb.Repeats{RString: []string{"violets", "blue"}}
-	complexObject = &pb.Widget{
-		Color:    pb.Widget_GREEN.Enum(),
-		RColor:   []pb.Widget_Color{pb.Widget_RED, pb.Widget_GREEN, pb.Widget_BLUE},
+	innerSimple   = &pb2.Simple{OInt32: proto.Int32(-32)}
+	innerSimple2  = &pb2.Simple{OInt64: proto.Int64(25)}
+	innerRepeats  = &pb2.Repeats{RString: []string{"roses", "red"}}
+	innerRepeats2 = &pb2.Repeats{RString: []string{"violets", "blue"}}
+	complexObject = &pb2.Widget{
+		Color:    pb2.Widget_GREEN.Enum(),
+		RColor:   []pb2.Widget_Color{pb2.Widget_RED, pb2.Widget_GREEN, pb2.Widget_BLUE},
 		Simple:   innerSimple,
-		RSimple:  []*pb.Simple{innerSimple, innerSimple2},
+		RSimple:  []*pb2.Simple{innerSimple, innerSimple2},
 		Repeats:  innerRepeats,
-		RRepeats: []*pb.Repeats{innerRepeats, innerRepeats2},
+		RRepeats: []*pb2.Repeats{innerRepeats, innerRepeats2},
 	}
 
 	complexObjectJSON = `{"color":"GREEN",` +
@@ -266,33 +309,33 @@ var (
     }
   }
 }`
-	realNumber     = &pb.Real{Value: proto.Float64(3.14159265359)}
+	realNumber     = &pb2.Real{Value: proto.Float64(3.14159265359)}
 	realNumberName = "Pi"
-	complexNumber  = &pb.Complex{Imaginary: proto.Float64(0.5772156649)}
+	complexNumber  = &pb2.Complex{Imaginary: proto.Float64(0.5772156649)}
 	realNumberJSON = `{` +
 		`"value":3.14159265359,` +
-		`"[jsonpb.Complex.real_extension]":{"imaginary":0.5772156649},` +
-		`"[jsonpb.name]":"Pi"` +
+		`"[jsonpb_test.Complex.real_extension]":{"imaginary":0.5772156649},` +
+		`"[jsonpb_test.name]":"Pi"` +
 		`}`
 
-	anySimple = &pb.KnownTypes{
+	anySimple = &pb2.KnownTypes{
 		An: &anypb.Any{
-			TypeUrl: "something.example.com/jsonpb.Simple",
+			TypeUrl: "something.example.com/jsonpb_test.Simple",
 			Value: []byte{
-				// &pb.Simple{OBool:true}
+				// &pb2.Simple{OBool:true}
 				1 << 3, 1,
 			},
 		},
 	}
-	anySimpleJSON       = `{"an":{"@type":"something.example.com/jsonpb.Simple","oBool":true}}`
+	anySimpleJSON       = `{"an":{"@type":"something.example.com/jsonpb_test.Simple","oBool":true}}`
 	anySimplePrettyJSON = `{
   "an": {
-    "@type": "something.example.com/jsonpb.Simple",
+    "@type": "something.example.com/jsonpb_test.Simple",
     "oBool": true
   }
 }`
 
-	anyWellKnown = &pb.KnownTypes{
+	anyWellKnown = &pb2.KnownTypes{
 		An: &anypb.Any{
 			TypeUrl: "type.googleapis.com/google.protobuf.Duration",
 			Value: []byte{
@@ -310,7 +353,7 @@ var (
   }
 }`
 
-	nonFinites = &pb.NonFinites{
+	nonFinites = &pb2.NonFinites{
 		FNan:  proto.Float32(float32(math.NaN())),
 		FPinf: proto.Float32(float32(math.Inf(1))),
 		FNinf: proto.Float32(float32(math.Inf(-1))),
@@ -329,10 +372,10 @@ var (
 )
 
 func init() {
-	if err := proto.SetExtension(realNumber, pb.E_Name, &realNumberName); err != nil {
+	if err := proto.SetExtension(realNumber, pb2.E_Name, &realNumberName); err != nil {
 		panic(err)
 	}
-	if err := proto.SetExtension(realNumber, pb.E_Complex_RealExtension, complexNumber); err != nil {
+	if err := proto.SetExtension(realNumber, pb2.E_Complex_RealExtension, complexNumber); err != nil {
 		panic(err)
 	}
 }
@@ -343,92 +386,98 @@ var marshalingTests = []struct {
 	pb        proto.Message
 	json      string
 }{
-	{"simple flat object", marshaler, simpleObject, simpleObjectJSON},
-	{"simple pretty object", marshalerAllOptions, simpleObject, simpleObjectPrettyJSON},
+	{"simple flat object", marshaler, simpleObject, simpleObjectOutputJSON},
+	{"simple pretty object", marshalerAllOptions, simpleObject, simpleObjectOutputPrettyJSON},
 	{"non-finite floats fields object", marshaler, nonFinites, nonFinitesJSON},
 	{"repeated fields flat object", marshaler, repeatsObject, repeatsObjectJSON},
 	{"repeated fields pretty object", marshalerAllOptions, repeatsObject, repeatsObjectPrettyJSON},
 	{"nested message/enum flat object", marshaler, complexObject, complexObjectJSON},
 	{"nested message/enum pretty object", marshalerAllOptions, complexObject, complexObjectPrettyJSON},
 	{"enum-string flat object", Marshaler{},
-		&pb.Widget{Color: pb.Widget_BLUE.Enum()}, `{"color":"BLUE"}`},
+		&pb2.Widget{Color: pb2.Widget_BLUE.Enum()}, `{"color":"BLUE"}`},
 	{"enum-value pretty object", Marshaler{EnumsAsInts: true, Indent: " "},
-		&pb.Widget{Color: pb.Widget_BLUE.Enum()}, colorPrettyJSON},
+		&pb2.Widget{Color: pb2.Widget_BLUE.Enum()}, colorPrettyJSON},
 	{"unknown enum value object", marshalerAllOptions,
-		&pb.Widget{Color: pb.Widget_Color(1000).Enum(), RColor: []pb.Widget_Color{pb.Widget_RED}}, colorListPrettyJSON},
+		&pb2.Widget{Color: pb2.Widget_Color(1000).Enum(), RColor: []pb2.Widget_Color{pb2.Widget_RED}}, colorListPrettyJSON},
 	{"repeated proto3 enum", Marshaler{},
-		&proto3pb.Message{RFunny: []proto3pb.Message_Humour{
-			proto3pb.Message_PUNS,
-			proto3pb.Message_SLAPSTICK,
+		&pb3.Message{RFunny: []pb3.Message_Humour{
+			pb3.Message_PUNS,
+			pb3.Message_SLAPSTICK,
 		}},
 		`{"rFunny":["PUNS","SLAPSTICK"]}`},
 	{"repeated proto3 enum as int", Marshaler{EnumsAsInts: true},
-		&proto3pb.Message{RFunny: []proto3pb.Message_Humour{
-			proto3pb.Message_PUNS,
-			proto3pb.Message_SLAPSTICK,
+		&pb3.Message{RFunny: []pb3.Message_Humour{
+			pb3.Message_PUNS,
+			pb3.Message_SLAPSTICK,
 		}},
 		`{"rFunny":[1,2]}`},
-	{"empty value", marshaler, &pb.Simple3{}, `{}`},
-	{"empty value emitted", Marshaler{EmitDefaults: true}, &pb.Simple3{}, `{"dub":0}`},
-	{"empty repeated emitted", Marshaler{EmitDefaults: true}, &pb.SimpleSlice3{}, `{"slices":[]}`},
-	{"empty map emitted", Marshaler{EmitDefaults: true}, &pb.SimpleMap3{}, `{"stringy":{}}`},
-	{"nested struct null", Marshaler{EmitDefaults: true}, &pb.SimpleNull3{}, `{"simple":null}`},
-	{"map<int64, int32>", marshaler, &pb.Mappy{Nummy: map[int64]int32{1: 2, 3: 4}}, `{"nummy":{"1":2,"3":4}}`},
-	{"map<int64, int32>", marshalerAllOptions, &pb.Mappy{Nummy: map[int64]int32{1: 2, 3: 4}}, nummyPrettyJSON},
+	{"empty value", marshaler, &pb2.Simple3{}, `{}`},
+	{"empty value emitted", Marshaler{EmitDefaults: true}, &pb2.Simple3{}, `{"dub":0}`},
+	{"empty repeated emitted", Marshaler{EmitDefaults: true}, &pb2.SimpleSlice3{}, `{"slices":[]}`},
+	{"empty map emitted", Marshaler{EmitDefaults: true}, &pb2.SimpleMap3{}, `{"stringy":{}}`},
+	{"nested struct null", Marshaler{EmitDefaults: true}, &pb2.SimpleNull3{}, `{"simple":null}`},
+	{"map<int64, int32>", marshaler, &pb2.Mappy{Nummy: map[int64]int32{1: 2, 3: 4}}, `{"nummy":{"1":2,"3":4}}`},
+	{"map<int64, int32>", marshalerAllOptions, &pb2.Mappy{Nummy: map[int64]int32{1: 2, 3: 4}}, nummyPrettyJSON},
 	{"map<string, string>", marshaler,
-		&pb.Mappy{Strry: map[string]string{`"one"`: "two", "three": "four"}},
+		&pb2.Mappy{Strry: map[string]string{`"one"`: "two", "three": "four"}},
 		`{"strry":{"\"one\"":"two","three":"four"}}`},
 	{"map<int32, Object>", marshaler,
-		&pb.Mappy{Objjy: map[int32]*pb.Simple3{1: {Dub: 1}}}, `{"objjy":{"1":{"dub":1}}}`},
+		&pb2.Mappy{Objjy: map[int32]*pb2.Simple3{1: {Dub: 1}}}, `{"objjy":{"1":{"dub":1}}}`},
 	{"map<int32, Object>", marshalerAllOptions,
-		&pb.Mappy{Objjy: map[int32]*pb.Simple3{1: {Dub: 1}}}, objjyPrettyJSON},
-	{"map<int64, string>", marshaler, &pb.Mappy{Buggy: map[int64]string{1234: "yup"}},
+		&pb2.Mappy{Objjy: map[int32]*pb2.Simple3{1: {Dub: 1}}}, objjyPrettyJSON},
+	{"map<int64, string>", marshaler, &pb2.Mappy{Buggy: map[int64]string{1234: "yup"}},
 		`{"buggy":{"1234":"yup"}}`},
-	{"map<bool, bool>", marshaler, &pb.Mappy{Booly: map[bool]bool{false: true}}, `{"booly":{"false":true}}`},
-	// TODO: This is broken.
-	//{"map<string, enum>", marshaler, &pb.Mappy{Enumy: map[string]pb.Numeral{"XIV": pb.Numeral_ROMAN}}, `{"enumy":{"XIV":"ROMAN"}`},
-	{"map<string, enum as int>", Marshaler{EnumsAsInts: true}, &pb.Mappy{Enumy: map[string]pb.Numeral{"XIV": pb.Numeral_ROMAN}}, `{"enumy":{"XIV":2}}`},
-	{"map<int32, bool>", marshaler, &pb.Mappy{S32Booly: map[int32]bool{1: true, 3: false, 10: true, 12: false}}, `{"s32booly":{"1":true,"3":false,"10":true,"12":false}}`},
-	{"map<int64, bool>", marshaler, &pb.Mappy{S64Booly: map[int64]bool{1: true, 3: false, 10: true, 12: false}}, `{"s64booly":{"1":true,"3":false,"10":true,"12":false}}`},
-	{"map<uint32, bool>", marshaler, &pb.Mappy{U32Booly: map[uint32]bool{1: true, 3: false, 10: true, 12: false}}, `{"u32booly":{"1":true,"3":false,"10":true,"12":false}}`},
-	{"map<uint64, bool>", marshaler, &pb.Mappy{U64Booly: map[uint64]bool{1: true, 3: false, 10: true, 12: false}}, `{"u64booly":{"1":true,"3":false,"10":true,"12":false}}`},
-	{"proto2 map<int64, string>", marshaler, &pb.Maps{MInt64Str: map[int64]string{213: "cat"}},
+	{"map<bool, bool>", marshaler, &pb2.Mappy{Booly: map[bool]bool{false: true}}, `{"booly":{"false":true}}`},
+	{"map<string, enum>", marshaler, &pb2.Mappy{Enumy: map[string]pb2.Numeral{"XIV": pb2.Numeral_ROMAN}}, `{"enumy":{"XIV":"ROMAN"}}`},
+	{"map<string, enum as int>", Marshaler{EnumsAsInts: true}, &pb2.Mappy{Enumy: map[string]pb2.Numeral{"XIV": pb2.Numeral_ROMAN}}, `{"enumy":{"XIV":2}}`},
+	{"map<int32, bool>", marshaler, &pb2.Mappy{S32Booly: map[int32]bool{1: true, 3: false, 10: true, 12: false}}, `{"s32booly":{"1":true,"3":false,"10":true,"12":false}}`},
+	{"map<int64, bool>", marshaler, &pb2.Mappy{S64Booly: map[int64]bool{1: true, 3: false, 10: true, 12: false}}, `{"s64booly":{"1":true,"3":false,"10":true,"12":false}}`},
+	{"map<uint32, bool>", marshaler, &pb2.Mappy{U32Booly: map[uint32]bool{1: true, 3: false, 10: true, 12: false}}, `{"u32booly":{"1":true,"3":false,"10":true,"12":false}}`},
+	{"map<uint64, bool>", marshaler, &pb2.Mappy{U64Booly: map[uint64]bool{1: true, 3: false, 10: true, 12: false}}, `{"u64booly":{"1":true,"3":false,"10":true,"12":false}}`},
+	{"proto2 map<int64, string>", marshaler, &pb2.Maps{MInt64Str: map[int64]string{213: "cat"}},
 		`{"mInt64Str":{"213":"cat"}}`},
 	{"proto2 map<bool, Object>", marshaler,
-		&pb.Maps{MBoolSimple: map[bool]*pb.Simple{true: {OInt32: proto.Int32(1)}}},
+		&pb2.Maps{MBoolSimple: map[bool]*pb2.Simple{true: {OInt32: proto.Int32(1)}}},
 		`{"mBoolSimple":{"true":{"oInt32":1}}}`},
-	{"oneof, not set", marshaler, &pb.MsgWithOneof{}, `{}`},
-	{"oneof, set", marshaler, &pb.MsgWithOneof{Union: &pb.MsgWithOneof_Title{"Grand Poobah"}}, `{"title":"Grand Poobah"}`},
-	{"force orig_name", Marshaler{OrigName: true}, &pb.Simple{OInt32: proto.Int32(4)},
+	{"oneof, not set", marshaler, &pb2.MsgWithOneof{}, `{}`},
+	{"oneof, set", marshaler, &pb2.MsgWithOneof{Union: &pb2.MsgWithOneof_Title{"Grand Poobah"}}, `{"title":"Grand Poobah"}`},
+	{"force orig_name", Marshaler{OrigName: true}, &pb2.Simple{OInt32: proto.Int32(4)},
 		`{"o_int32":4}`},
 	{"proto2 extension", marshaler, realNumber, realNumberJSON},
 	{"Any with message", marshaler, anySimple, anySimpleJSON},
 	{"Any with message and indent", marshalerAllOptions, anySimple, anySimplePrettyJSON},
 	{"Any with WKT", marshaler, anyWellKnown, anyWellKnownJSON},
 	{"Any with WKT and indent", marshalerAllOptions, anyWellKnown, anyWellKnownPrettyJSON},
-	{"Duration", marshaler, &pb.KnownTypes{Dur: &durpb.Duration{Seconds: 3}}, `{"dur":"3s"}`},
-	{"Duration", marshaler, &pb.KnownTypes{Dur: &durpb.Duration{Seconds: 3, Nanos: 1e6}}, `{"dur":"3.001s"}`},
-	{"Duration beyond float64 precision", marshaler, &pb.KnownTypes{Dur: &durpb.Duration{Seconds: 100000000, Nanos: 1}}, `{"dur":"100000000.000000001s"}`},
-	{"negative Duration", marshaler, &pb.KnownTypes{Dur: &durpb.Duration{Seconds: -123, Nanos: -456}}, `{"dur":"-123.000000456s"}`},
-	{"Struct", marshaler, &pb.KnownTypes{St: &stpb.Struct{
+	{"Duration empty", marshaler, &durpb.Duration{}, `"0s"`},
+	{"Duration with secs", marshaler, &durpb.Duration{Seconds: 3}, `"3s"`},
+	{"Duration with -secs", marshaler, &durpb.Duration{Seconds: -3}, `"-3s"`},
+	{"Duration with nanos", marshaler, &durpb.Duration{Nanos: 1e6}, `"0.001s"`},
+	{"Duration with -nanos", marshaler, &durpb.Duration{Nanos: -1e6}, `"-0.001s"`},
+	{"Duration with large secs", marshaler, &durpb.Duration{Seconds: 1e10, Nanos: 1}, `"10000000000.000000001s"`},
+	{"Duration with 6-digit nanos", marshaler, &durpb.Duration{Nanos: 1e4}, `"0.000010s"`},
+	{"Duration with 3-digit nanos", marshaler, &durpb.Duration{Nanos: 1e6}, `"0.001s"`},
+	{"Duration with -secs -nanos", marshaler, &durpb.Duration{Seconds: -123, Nanos: -450}, `"-123.000000450s"`},
+	{"Duration max value", marshaler, &durpb.Duration{Seconds: 315576000000, Nanos: 999999999}, `"315576000000.999999999s"`},
+	{"Duration min value", marshaler, &durpb.Duration{Seconds: -315576000000, Nanos: -999999999}, `"-315576000000.999999999s"`},
+	{"Struct", marshaler, &pb2.KnownTypes{St: &stpb.Struct{
 		Fields: map[string]*stpb.Value{
 			"one": {Kind: &stpb.Value_StringValue{"loneliest number"}},
 			"two": {Kind: &stpb.Value_NullValue{stpb.NullValue_NULL_VALUE}},
 		},
 	}}, `{"st":{"one":"loneliest number","two":null}}`},
-	{"empty ListValue", marshaler, &pb.KnownTypes{Lv: &stpb.ListValue{}}, `{"lv":[]}`},
-	{"basic ListValue", marshaler, &pb.KnownTypes{Lv: &stpb.ListValue{Values: []*stpb.Value{
+	{"empty ListValue", marshaler, &pb2.KnownTypes{Lv: &stpb.ListValue{}}, `{"lv":[]}`},
+	{"basic ListValue", marshaler, &pb2.KnownTypes{Lv: &stpb.ListValue{Values: []*stpb.Value{
 		{Kind: &stpb.Value_StringValue{"x"}},
 		{Kind: &stpb.Value_NullValue{}},
 		{Kind: &stpb.Value_NumberValue{3}},
 		{Kind: &stpb.Value_BoolValue{true}},
 	}}}, `{"lv":["x",null,3,true]}`},
-	{"Timestamp", marshaler, &pb.KnownTypes{Ts: &tspb.Timestamp{Seconds: 14e8, Nanos: 21e6}}, `{"ts":"2014-05-13T16:53:20.021Z"}`},
-	{"Timestamp", marshaler, &pb.KnownTypes{Ts: &tspb.Timestamp{Seconds: 14e8, Nanos: 0}}, `{"ts":"2014-05-13T16:53:20Z"}`},
-	{"number Value", marshaler, &pb.KnownTypes{Val: &stpb.Value{Kind: &stpb.Value_NumberValue{1}}}, `{"val":1}`},
-	{"null Value", marshaler, &pb.KnownTypes{Val: &stpb.Value{Kind: &stpb.Value_NullValue{stpb.NullValue_NULL_VALUE}}}, `{"val":null}`},
-	{"string number value", marshaler, &pb.KnownTypes{Val: &stpb.Value{Kind: &stpb.Value_StringValue{"9223372036854775807"}}}, `{"val":"9223372036854775807"}`},
-	{"list of lists Value", marshaler, &pb.KnownTypes{Val: &stpb.Value{
+	{"Timestamp", marshaler, &pb2.KnownTypes{Ts: &tspb.Timestamp{Seconds: 14e8, Nanos: 21e6}}, `{"ts":"2014-05-13T16:53:20.021Z"}`},
+	{"Timestamp", marshaler, &pb2.KnownTypes{Ts: &tspb.Timestamp{Seconds: 14e8, Nanos: 0}}, `{"ts":"2014-05-13T16:53:20Z"}`},
+	{"number Value", marshaler, &pb2.KnownTypes{Val: &stpb.Value{Kind: &stpb.Value_NumberValue{1}}}, `{"val":1}`},
+	{"null Value", marshaler, &pb2.KnownTypes{Val: &stpb.Value{Kind: &stpb.Value_NullValue{stpb.NullValue_NULL_VALUE}}}, `{"val":null}`},
+	{"string number value", marshaler, &pb2.KnownTypes{Val: &stpb.Value{Kind: &stpb.Value_StringValue{"9223372036854775807"}}}, `{"val":"9223372036854775807"}`},
+	{"list of lists Value", marshaler, &pb2.KnownTypes{Val: &stpb.Value{
 		Kind: &stpb.Value_ListValue{&stpb.ListValue{
 			Values: []*stpb.Value{
 				{Kind: &stpb.Value_StringValue{"x"}},
@@ -444,18 +493,18 @@ var marshalingTests = []struct {
 		}},
 	}}, `{"val":["x",[["y"],"z"]]}`},
 
-	{"DoubleValue", marshaler, &pb.KnownTypes{Dbl: &wpb.DoubleValue{Value: 1.2}}, `{"dbl":1.2}`},
-	{"FloatValue", marshaler, &pb.KnownTypes{Flt: &wpb.FloatValue{Value: 1.2}}, `{"flt":1.2}`},
-	{"Int64Value", marshaler, &pb.KnownTypes{I64: &wpb.Int64Value{Value: -3}}, `{"i64":"-3"}`},
-	{"UInt64Value", marshaler, &pb.KnownTypes{U64: &wpb.UInt64Value{Value: 3}}, `{"u64":"3"}`},
-	{"Int32Value", marshaler, &pb.KnownTypes{I32: &wpb.Int32Value{Value: -4}}, `{"i32":-4}`},
-	{"UInt32Value", marshaler, &pb.KnownTypes{U32: &wpb.UInt32Value{Value: 4}}, `{"u32":4}`},
-	{"BoolValue", marshaler, &pb.KnownTypes{Bool: &wpb.BoolValue{Value: true}}, `{"bool":true}`},
-	{"StringValue", marshaler, &pb.KnownTypes{Str: &wpb.StringValue{Value: "plush"}}, `{"str":"plush"}`},
-	{"BytesValue", marshaler, &pb.KnownTypes{Bytes: &wpb.BytesValue{Value: []byte("wow")}}, `{"bytes":"d293"}`},
-
-	{"required", marshaler, &pb.MsgWithRequired{Str: proto.String("hello")}, `{"str":"hello"}`},
-	{"required bytes", marshaler, &pb.MsgWithRequiredBytes{Byts: []byte{}}, `{"byts":""}`},
+	{"DoubleValue", marshaler, &pb2.KnownTypes{Dbl: &wpb.DoubleValue{Value: 1.2}}, `{"dbl":1.2}`},
+	{"FloatValue", marshaler, &pb2.KnownTypes{Flt: &wpb.FloatValue{Value: 1.2}}, `{"flt":1.2}`},
+	{"Int64Value", marshaler, &pb2.KnownTypes{I64: &wpb.Int64Value{Value: -3}}, `{"i64":"-3"}`},
+	{"UInt64Value", marshaler, &pb2.KnownTypes{U64: &wpb.UInt64Value{Value: 3}}, `{"u64":"3"}`},
+	{"Int32Value", marshaler, &pb2.KnownTypes{I32: &wpb.Int32Value{Value: -4}}, `{"i32":-4}`},
+	{"UInt32Value", marshaler, &pb2.KnownTypes{U32: &wpb.UInt32Value{Value: 4}}, `{"u32":4}`},
+	{"BoolValue", marshaler, &pb2.KnownTypes{Bool: &wpb.BoolValue{Value: true}}, `{"bool":true}`},
+	{"StringValue", marshaler, &pb2.KnownTypes{Str: &wpb.StringValue{Value: "plush"}}, `{"str":"plush"}`},
+	{"BytesValue", marshaler, &pb2.KnownTypes{Bytes: &wpb.BytesValue{Value: []byte("wow")}}, `{"bytes":"d293"}`},
+
+	{"required", marshaler, &pb2.MsgWithRequired{Str: proto.String("hello")}, `{"str":"hello"}`},
+	{"required bytes", marshaler, &pb2.MsgWithRequiredBytes{Byts: []byte{}}, `{"byts":""}`},
 }
 
 func TestMarshaling(t *testing.T) {
@@ -464,13 +513,13 @@ func TestMarshaling(t *testing.T) {
 		if err != nil {
 			t.Errorf("%s: marshaling error: %v", tt.desc, err)
 		} else if tt.json != json {
-			t.Errorf("%s: got [%v] want [%v]", tt.desc, json, tt.json)
+			t.Errorf("%s:\ngot:  %v\nwant: %v", tt.desc, json, tt.json)
 		}
 	}
 }
 
 func TestMarshalingNil(t *testing.T) {
-	var msg *pb.Simple
+	var msg *pb2.Simple
 	m := &Marshaler{}
 	if _, err := m.MarshalToString(msg); err == nil {
 		t.Errorf("mashaling nil returned no error")
@@ -482,15 +531,17 @@ func TestMarshalIllegalTime(t *testing.T) {
 		pb   proto.Message
 		fail bool
 	}{
-		{&pb.KnownTypes{Dur: &durpb.Duration{Seconds: 1, Nanos: 0}}, false},
-		{&pb.KnownTypes{Dur: &durpb.Duration{Seconds: -1, Nanos: 0}}, false},
-		{&pb.KnownTypes{Dur: &durpb.Duration{Seconds: 1, Nanos: -1}}, true},
-		{&pb.KnownTypes{Dur: &durpb.Duration{Seconds: -1, Nanos: 1}}, true},
-		{&pb.KnownTypes{Dur: &durpb.Duration{Seconds: 1, Nanos: 1000000000}}, true},
-		{&pb.KnownTypes{Dur: &durpb.Duration{Seconds: -1, Nanos: -1000000000}}, true},
-		{&pb.KnownTypes{Ts: &tspb.Timestamp{Seconds: 1, Nanos: 1}}, false},
-		{&pb.KnownTypes{Ts: &tspb.Timestamp{Seconds: 1, Nanos: -1}}, true},
-		{&pb.KnownTypes{Ts: &tspb.Timestamp{Seconds: 1, Nanos: 1000000000}}, true},
+		{&durpb.Duration{Seconds: 1, Nanos: 0}, false},
+		{&durpb.Duration{Seconds: -1, Nanos: 0}, false},
+		{&durpb.Duration{Seconds: 1, Nanos: -1}, true},
+		{&durpb.Duration{Seconds: -1, Nanos: 1}, true},
+		{&durpb.Duration{Seconds: 315576000001}, true},
+		{&durpb.Duration{Seconds: -315576000001}, true},
+		{&durpb.Duration{Seconds: 1, Nanos: 1000000000}, true},
+		{&durpb.Duration{Seconds: -1, Nanos: -1000000000}, true},
+		{&tspb.Timestamp{Seconds: 1, Nanos: 1}, false},
+		{&tspb.Timestamp{Seconds: 1, Nanos: -1}, true},
+		{&tspb.Timestamp{Seconds: 1, Nanos: 1000000000}, true},
 	}
 	for _, tt := range tests {
 		_, err := marshaler.MarshalToString(tt.pb)
@@ -505,51 +556,51 @@ func TestMarshalIllegalTime(t *testing.T) {
 
 func TestMarshalJSONPBMarshaler(t *testing.T) {
 	rawJson := `{ "foo": "bar", "baz": [0, 1, 2, 3] }`
-	msg := dynamicMessage{rawJson: rawJson}
+	msg := dynamicMessage{RawJson: rawJson}
 	str, err := new(Marshaler).MarshalToString(&msg)
 	if err != nil {
-		t.Errorf("an unexpected error occurred when marshalling JSONPBMarshaler: %v", err)
+		t.Errorf("an unexpected error while marshaling JSONPBMarshaler: %v", err)
 	}
 	if str != rawJson {
-		t.Errorf("marshalling JSON produced incorrect output: got %s, wanted %s", str, rawJson)
+		t.Errorf("marshaling JSON produced incorrect output: got %s, wanted %s", str, rawJson)
 	}
 }
 
 func TestMarshalAnyJSONPBMarshaler(t *testing.T) {
-	msg := dynamicMessage{rawJson: `{ "foo": "bar", "baz": [0, 1, 2, 3] }`}
+	msg := dynamicMessage{RawJson: `{ "foo": "bar", "baz": [0, 1, 2, 3] }`}
 	a, err := ptypes.MarshalAny(&msg)
 	if err != nil {
-		t.Errorf("an unexpected error occurred when marshalling to Any: %v", err)
+		t.Errorf("an unexpected error while marshaling to Any: %v", err)
 	}
 	str, err := new(Marshaler).MarshalToString(a)
 	if err != nil {
-		t.Errorf("an unexpected error occurred when marshalling Any to JSON: %v", err)
+		t.Errorf("an unexpected error while marshaling Any to JSON: %v", err)
 	}
 	// after custom marshaling, it's round-tripped through JSON decoding/encoding already,
 	// so the keys are sorted, whitespace is compacted, and "@type" key has been added
-	expected := `{"@type":"type.googleapis.com/` + dynamicMessageName + `","baz":[0,1,2,3],"foo":"bar"}`
-	if str != expected {
-		t.Errorf("marshalling JSON produced incorrect output: got %s, wanted %s", str, expected)
+	want := `{"@type":"type.googleapis.com/` + dynamicMessageName + `","baz":[0,1,2,3],"foo":"bar"}`
+	if str != want {
+		t.Errorf("marshaling JSON produced incorrect output: got %s, wanted %s", str, want)
 	}
 }
 
 func TestMarshalWithCustomValidation(t *testing.T) {
-	msg := dynamicMessage{rawJson: `{ "foo": "bar", "baz": [0, 1, 2, 3] }`, dummy: &dynamicMessage{}}
+	msg := dynamicMessage{RawJson: `{ "foo": "bar", "baz": [0, 1, 2, 3] }`, Dummy: &dynamicMessage{}}
 
 	js, err := new(Marshaler).MarshalToString(&msg)
 	if err != nil {
-		t.Errorf("an unexpected error occurred when marshalling to json: %v", err)
+		t.Errorf("an unexpected error while marshaling to json: %v", err)
 	}
 	err = Unmarshal(strings.NewReader(js), &msg)
 	if err != nil {
-		t.Errorf("an unexpected error occurred when unmarshalling from json: %v", err)
+		t.Errorf("an unexpected error while unmarshaling from json: %v", err)
 	}
 }
 
 // Test marshaling message containing unset required fields should produce error.
 func TestMarshalUnsetRequiredFields(t *testing.T) {
-	msgExt := &pb.Real{}
-	proto.SetExtension(msgExt, pb.E_Extm, &pb.MsgWithRequired{})
+	msgExt := &pb2.Real{}
+	proto.SetExtension(msgExt, pb2.E_Extm, &pb2.MsgWithRequired{})
 
 	tests := []struct {
 		desc      string
@@ -559,43 +610,43 @@ func TestMarshalUnsetRequiredFields(t *testing.T) {
 		{
 			desc:      "direct required field",
 			marshaler: &Marshaler{},
-			pb:        &pb.MsgWithRequired{},
+			pb:        &pb2.MsgWithRequired{},
 		},
 		{
 			desc:      "direct required field + emit defaults",
 			marshaler: &Marshaler{EmitDefaults: true},
-			pb:        &pb.MsgWithRequired{},
+			pb:        &pb2.MsgWithRequired{},
 		},
 		{
 			desc:      "indirect required field",
 			marshaler: &Marshaler{},
-			pb:        &pb.MsgWithIndirectRequired{Subm: &pb.MsgWithRequired{}},
+			pb:        &pb2.MsgWithIndirectRequired{Subm: &pb2.MsgWithRequired{}},
 		},
 		{
 			desc:      "indirect required field + emit defaults",
 			marshaler: &Marshaler{EmitDefaults: true},
-			pb:        &pb.MsgWithIndirectRequired{Subm: &pb.MsgWithRequired{}},
+			pb:        &pb2.MsgWithIndirectRequired{Subm: &pb2.MsgWithRequired{}},
 		},
 		{
 			desc:      "direct required wkt field",
 			marshaler: &Marshaler{},
-			pb:        &pb.MsgWithRequiredWKT{},
+			pb:        &pb2.MsgWithRequiredWKT{},
 		},
 		{
 			desc:      "direct required wkt field + emit defaults",
 			marshaler: &Marshaler{EmitDefaults: true},
-			pb:        &pb.MsgWithRequiredWKT{},
+			pb:        &pb2.MsgWithRequiredWKT{},
 		},
 		{
 			desc:      "direct required bytes field",
 			marshaler: &Marshaler{},
-			pb:        &pb.MsgWithRequiredBytes{},
+			pb:        &pb2.MsgWithRequiredBytes{},
 		},
 		{
 			desc:      "required in map value",
 			marshaler: &Marshaler{},
-			pb: &pb.MsgWithIndirectRequired{
-				MapField: map[string]*pb.MsgWithRequired{
+			pb: &pb2.MsgWithIndirectRequired{
+				MapField: map[string]*pb2.MsgWithRequired{
 					"key": {},
 				},
 			},
@@ -603,8 +654,8 @@ func TestMarshalUnsetRequiredFields(t *testing.T) {
 		{
 			desc:      "required in repeated item",
 			marshaler: &Marshaler{},
-			pb: &pb.MsgWithIndirectRequired{
-				SliceField: []*pb.MsgWithRequired{
+			pb: &pb2.MsgWithIndirectRequired{
+				SliceField: []*pb2.MsgWithRequired{
 					{Str: proto.String("hello")},
 					{},
 				},
@@ -613,8 +664,8 @@ func TestMarshalUnsetRequiredFields(t *testing.T) {
 		{
 			desc:      "required inside oneof",
 			marshaler: &Marshaler{},
-			pb: &pb.MsgWithOneof{
-				Union: &pb.MsgWithOneof_MsgWithRequired{&pb.MsgWithRequired{}},
+			pb: &pb2.MsgWithOneof{
+				Union: &pb2.MsgWithOneof_MsgWithRequired{&pb2.MsgWithRequired{}},
 			},
 		},
 		{
@@ -626,7 +677,7 @@ func TestMarshalUnsetRequiredFields(t *testing.T) {
 
 	for _, tc := range tests {
 		if _, err := tc.marshaler.MarshalToString(tc.pb); err == nil {
-			t.Errorf("%s: expecting error in marshaling with unset required fields %+v", tc.desc, tc.pb)
+			t.Errorf("%s: expected error while marshaling with unset required fields %+v", tc.desc, tc.pb)
 		}
 	}
 }
@@ -637,79 +688,78 @@ var unmarshalingTests = []struct {
 	json        string
 	pb          proto.Message
 }{
-	{"simple flat object", Unmarshaler{}, simpleObjectJSON, simpleObject},
-	{"simple pretty object", Unmarshaler{}, simpleObjectPrettyJSON, simpleObject},
+	{"simple flat object", Unmarshaler{}, simpleObjectInputJSON, simpleObject},
+	{"simple pretty object", Unmarshaler{}, simpleObjectInputPrettyJSON, simpleObject},
 	{"repeated fields flat object", Unmarshaler{}, repeatsObjectJSON, repeatsObject},
 	{"repeated fields pretty object", Unmarshaler{}, repeatsObjectPrettyJSON, repeatsObject},
 	{"nested message/enum flat object", Unmarshaler{}, complexObjectJSON, complexObject},
 	{"nested message/enum pretty object", Unmarshaler{}, complexObjectPrettyJSON, complexObject},
-	{"enum-string object", Unmarshaler{}, `{"color":"BLUE"}`, &pb.Widget{Color: pb.Widget_BLUE.Enum()}},
-	{"enum-value object", Unmarshaler{}, "{\n \"color\": 2\n}", &pb.Widget{Color: pb.Widget_BLUE.Enum()}},
-	{"unknown field with allowed option", Unmarshaler{AllowUnknownFields: true}, `{"unknown": "foo"}`, new(pb.Simple)},
-	{"proto3 enum string", Unmarshaler{}, `{"hilarity":"PUNS"}`, &proto3pb.Message{Hilarity: proto3pb.Message_PUNS}},
-	{"proto3 enum value", Unmarshaler{}, `{"hilarity":1}`, &proto3pb.Message{Hilarity: proto3pb.Message_PUNS}},
+	{"enum-string object", Unmarshaler{}, `{"color":"BLUE"}`, &pb2.Widget{Color: pb2.Widget_BLUE.Enum()}},
+	{"enum-value object", Unmarshaler{}, "{\n \"color\": 2\n}", &pb2.Widget{Color: pb2.Widget_BLUE.Enum()}},
+	{"unknown field with allowed option", Unmarshaler{AllowUnknownFields: true}, `{"unknown": "foo"}`, new(pb2.Simple)},
+	{"proto3 enum string", Unmarshaler{}, `{"hilarity":"PUNS"}`, &pb3.Message{Hilarity: pb3.Message_PUNS}},
+	{"proto3 enum value", Unmarshaler{}, `{"hilarity":1}`, &pb3.Message{Hilarity: pb3.Message_PUNS}},
 	{"unknown enum value object",
 		Unmarshaler{},
 		"{\n  \"color\": 1000,\n  \"r_color\": [\n    \"RED\"\n  ]\n}",
-		&pb.Widget{Color: pb.Widget_Color(1000).Enum(), RColor: []pb.Widget_Color{pb.Widget_RED}}},
+		&pb2.Widget{Color: pb2.Widget_Color(1000).Enum(), RColor: []pb2.Widget_Color{pb2.Widget_RED}}},
 	{"repeated proto3 enum", Unmarshaler{}, `{"rFunny":["PUNS","SLAPSTICK"]}`,
-		&proto3pb.Message{RFunny: []proto3pb.Message_Humour{
-			proto3pb.Message_PUNS,
-			proto3pb.Message_SLAPSTICK,
+		&pb3.Message{RFunny: []pb3.Message_Humour{
+			pb3.Message_PUNS,
+			pb3.Message_SLAPSTICK,
 		}}},
 	{"repeated proto3 enum as int", Unmarshaler{}, `{"rFunny":[1,2]}`,
-		&proto3pb.Message{RFunny: []proto3pb.Message_Humour{
-			proto3pb.Message_PUNS,
-			proto3pb.Message_SLAPSTICK,
+		&pb3.Message{RFunny: []pb3.Message_Humour{
+			pb3.Message_PUNS,
+			pb3.Message_SLAPSTICK,
 		}}},
 	{"repeated proto3 enum as mix of strings and ints", Unmarshaler{}, `{"rFunny":["PUNS",2]}`,
-		&proto3pb.Message{RFunny: []proto3pb.Message_Humour{
-			proto3pb.Message_PUNS,
-			proto3pb.Message_SLAPSTICK,
+		&pb3.Message{RFunny: []pb3.Message_Humour{
+			pb3.Message_PUNS,
+			pb3.Message_SLAPSTICK,
 		}}},
-	{"unquoted int64 object", Unmarshaler{}, `{"oInt64":-314}`, &pb.Simple{OInt64: proto.Int64(-314)}},
-	{"unquoted uint64 object", Unmarshaler{}, `{"oUint64":123}`, &pb.Simple{OUint64: proto.Uint64(123)}},
-	{"NaN", Unmarshaler{}, `{"oDouble":"NaN"}`, &pb.Simple{ODouble: proto.Float64(math.NaN())}},
-	{"Inf", Unmarshaler{}, `{"oFloat":"Infinity"}`, &pb.Simple{OFloat: proto.Float32(float32(math.Inf(1)))}},
-	{"-Inf", Unmarshaler{}, `{"oDouble":"-Infinity"}`, &pb.Simple{ODouble: proto.Float64(math.Inf(-1))}},
-	{"map<int64, int32>", Unmarshaler{}, `{"nummy":{"1":2,"3":4}}`, &pb.Mappy{Nummy: map[int64]int32{1: 2, 3: 4}}},
-	{"map<string, string>", Unmarshaler{}, `{"strry":{"\"one\"":"two","three":"four"}}`, &pb.Mappy{Strry: map[string]string{`"one"`: "two", "three": "four"}}},
-	{"map<int32, Object>", Unmarshaler{}, `{"objjy":{"1":{"dub":1}}}`, &pb.Mappy{Objjy: map[int32]*pb.Simple3{1: {Dub: 1}}}},
+	{"unquoted int64 object", Unmarshaler{}, `{"oInt64":-314}`, &pb2.Simple{OInt64: proto.Int64(-314)}},
+	{"unquoted uint64 object", Unmarshaler{}, `{"oUint64":123}`, &pb2.Simple{OUint64: proto.Uint64(123)}},
+	{"NaN", Unmarshaler{}, `{"oDouble":"NaN"}`, &pb2.Simple{ODouble: proto.Float64(math.NaN())}},
+	{"Inf", Unmarshaler{}, `{"oFloat":"Infinity"}`, &pb2.Simple{OFloat: proto.Float32(float32(math.Inf(1)))}},
+	{"-Inf", Unmarshaler{}, `{"oDouble":"-Infinity"}`, &pb2.Simple{ODouble: proto.Float64(math.Inf(-1))}},
+	{"map<int64, int32>", Unmarshaler{}, `{"nummy":{"1":2,"3":4}}`, &pb2.Mappy{Nummy: map[int64]int32{1: 2, 3: 4}}},
+	{"map<string, string>", Unmarshaler{}, `{"strry":{"\"one\"":"two","three":"four"}}`, &pb2.Mappy{Strry: map[string]string{`"one"`: "two", "three": "four"}}},
+	{"map<int32, Object>", Unmarshaler{}, `{"objjy":{"1":{"dub":1}}}`, &pb2.Mappy{Objjy: map[int32]*pb2.Simple3{1: {Dub: 1}}}},
 	{"proto2 extension", Unmarshaler{}, realNumberJSON, realNumber},
 	{"Any with message", Unmarshaler{}, anySimpleJSON, anySimple},
 	{"Any with message and indent", Unmarshaler{}, anySimplePrettyJSON, anySimple},
 	{"Any with WKT", Unmarshaler{}, anyWellKnownJSON, anyWellKnown},
 	{"Any with WKT and indent", Unmarshaler{}, anyWellKnownPrettyJSON, anyWellKnown},
-	// TODO: This is broken.
-	//{"map<string, enum>", Unmarshaler{}, `{"enumy":{"XIV":"ROMAN"}`, &pb.Mappy{Enumy: map[string]pb.Numeral{"XIV": pb.Numeral_ROMAN}}},
-	{"map<string, enum as int>", Unmarshaler{}, `{"enumy":{"XIV":2}}`, &pb.Mappy{Enumy: map[string]pb.Numeral{"XIV": pb.Numeral_ROMAN}}},
-	{"oneof", Unmarshaler{}, `{"salary":31000}`, &pb.MsgWithOneof{Union: &pb.MsgWithOneof_Salary{31000}}},
-	{"oneof spec name", Unmarshaler{}, `{"Country":"Australia"}`, &pb.MsgWithOneof{Union: &pb.MsgWithOneof_Country{"Australia"}}},
-	{"oneof orig_name", Unmarshaler{}, `{"Country":"Australia"}`, &pb.MsgWithOneof{Union: &pb.MsgWithOneof_Country{"Australia"}}},
-	{"oneof spec name2", Unmarshaler{}, `{"homeAddress":"Australia"}`, &pb.MsgWithOneof{Union: &pb.MsgWithOneof_HomeAddress{"Australia"}}},
-	{"oneof orig_name2", Unmarshaler{}, `{"home_address":"Australia"}`, &pb.MsgWithOneof{Union: &pb.MsgWithOneof_HomeAddress{"Australia"}}},
-	{"orig_name input", Unmarshaler{}, `{"o_bool":true}`, &pb.Simple{OBool: proto.Bool(true)}},
-	{"camelName input", Unmarshaler{}, `{"oBool":true}`, &pb.Simple{OBool: proto.Bool(true)}},
-
-	{"Duration", Unmarshaler{}, `{"dur":"3.000s"}`, &pb.KnownTypes{Dur: &durpb.Duration{Seconds: 3}}},
-	{"Duration", Unmarshaler{}, `{"dur":"4s"}`, &pb.KnownTypes{Dur: &durpb.Duration{Seconds: 4}}},
-	{"Duration with unicode", Unmarshaler{}, `{"dur": "3\u0073"}`, &pb.KnownTypes{Dur: &durpb.Duration{Seconds: 3}}},
-	{"null Duration", Unmarshaler{}, `{"dur":null}`, &pb.KnownTypes{Dur: nil}},
-	{"Timestamp", Unmarshaler{}, `{"ts":"2014-05-13T16:53:20.021Z"}`, &pb.KnownTypes{Ts: &tspb.Timestamp{Seconds: 14e8, Nanos: 21e6}}},
-	{"Timestamp", Unmarshaler{}, `{"ts":"2014-05-13T16:53:20Z"}`, &pb.KnownTypes{Ts: &tspb.Timestamp{Seconds: 14e8, Nanos: 0}}},
-	{"Timestamp with unicode", Unmarshaler{}, `{"ts": "2014-05-13T16:53:20\u005a"}`, &pb.KnownTypes{Ts: &tspb.Timestamp{Seconds: 14e8, Nanos: 0}}},
-	{"PreEpochTimestamp", Unmarshaler{}, `{"ts":"1969-12-31T23:59:58.999999995Z"}`, &pb.KnownTypes{Ts: &tspb.Timestamp{Seconds: -2, Nanos: 999999995}}},
-	{"ZeroTimeTimestamp", Unmarshaler{}, `{"ts":"0001-01-01T00:00:00Z"}`, &pb.KnownTypes{Ts: &tspb.Timestamp{Seconds: -62135596800, Nanos: 0}}},
-	{"null Timestamp", Unmarshaler{}, `{"ts":null}`, &pb.KnownTypes{Ts: nil}},
-	{"null Struct", Unmarshaler{}, `{"st": null}`, &pb.KnownTypes{St: nil}},
-	{"empty Struct", Unmarshaler{}, `{"st": {}}`, &pb.KnownTypes{St: &stpb.Struct{}}},
-	{"basic Struct", Unmarshaler{}, `{"st": {"a": "x", "b": null, "c": 3, "d": true}}`, &pb.KnownTypes{St: &stpb.Struct{Fields: map[string]*stpb.Value{
+	{"map<string, enum>", Unmarshaler{}, `{"enumy":{"XIV":"ROMAN"}}`, &pb2.Mappy{Enumy: map[string]pb2.Numeral{"XIV": pb2.Numeral_ROMAN}}},
+	{"map<string, enum as int>", Unmarshaler{}, `{"enumy":{"XIV":2}}`, &pb2.Mappy{Enumy: map[string]pb2.Numeral{"XIV": pb2.Numeral_ROMAN}}},
+	{"oneof", Unmarshaler{}, `{"salary":31000}`, &pb2.MsgWithOneof{Union: &pb2.MsgWithOneof_Salary{31000}}},
+	{"oneof spec name", Unmarshaler{}, `{"Country":"Australia"}`, &pb2.MsgWithOneof{Union: &pb2.MsgWithOneof_Country{"Australia"}}},
+	{"oneof orig_name", Unmarshaler{}, `{"Country":"Australia"}`, &pb2.MsgWithOneof{Union: &pb2.MsgWithOneof_Country{"Australia"}}},
+	{"oneof spec name2", Unmarshaler{}, `{"homeAddress":"Australia"}`, &pb2.MsgWithOneof{Union: &pb2.MsgWithOneof_HomeAddress{"Australia"}}},
+	{"oneof orig_name2", Unmarshaler{}, `{"home_address":"Australia"}`, &pb2.MsgWithOneof{Union: &pb2.MsgWithOneof_HomeAddress{"Australia"}}},
+	{"orig_name input", Unmarshaler{}, `{"o_bool":true}`, &pb2.Simple{OBool: proto.Bool(true)}},
+	{"camelName input", Unmarshaler{}, `{"oBool":true}`, &pb2.Simple{OBool: proto.Bool(true)}},
+
+	{"Duration", Unmarshaler{}, `{"dur":"3.000s"}`, &pb2.KnownTypes{Dur: &durpb.Duration{Seconds: 3}}},
+	{"Duration", Unmarshaler{}, `{"dur":"4s"}`, &pb2.KnownTypes{Dur: &durpb.Duration{Seconds: 4}}},
+	{"Duration with unicode", Unmarshaler{}, `{"dur": "3\u0073"}`, &pb2.KnownTypes{Dur: &durpb.Duration{Seconds: 3}}},
+	{"null Duration", Unmarshaler{}, `{"dur":null}`, &pb2.KnownTypes{Dur: nil}},
+	{"Timestamp", Unmarshaler{}, `{"ts":"2014-05-13T16:53:20.021Z"}`, &pb2.KnownTypes{Ts: &tspb.Timestamp{Seconds: 14e8, Nanos: 21e6}}},
+	{"Timestamp", Unmarshaler{}, `{"ts":"2014-05-13T16:53:20Z"}`, &pb2.KnownTypes{Ts: &tspb.Timestamp{Seconds: 14e8, Nanos: 0}}},
+	{"Timestamp with unicode", Unmarshaler{}, `{"ts": "2014-05-13T16:53:20\u005a"}`, &pb2.KnownTypes{Ts: &tspb.Timestamp{Seconds: 14e8, Nanos: 0}}},
+	{"PreEpochTimestamp", Unmarshaler{}, `{"ts":"1969-12-31T23:59:58.999999995Z"}`, &pb2.KnownTypes{Ts: &tspb.Timestamp{Seconds: -2, Nanos: 999999995}}},
+	{"ZeroTimeTimestamp", Unmarshaler{}, `{"ts":"0001-01-01T00:00:00Z"}`, &pb2.KnownTypes{Ts: &tspb.Timestamp{Seconds: -62135596800, Nanos: 0}}},
+	{"null Timestamp", Unmarshaler{}, `{"ts":null}`, &pb2.KnownTypes{Ts: nil}},
+	{"null Struct", Unmarshaler{}, `{"st": null}`, &pb2.KnownTypes{St: nil}},
+	{"empty Struct", Unmarshaler{}, `{"st": {}}`, &pb2.KnownTypes{St: &stpb.Struct{}}},
+	{"basic Struct", Unmarshaler{}, `{"st": {"a": "x", "b": null, "c": 3, "d": true}}`, &pb2.KnownTypes{St: &stpb.Struct{Fields: map[string]*stpb.Value{
 		"a": {Kind: &stpb.Value_StringValue{"x"}},
 		"b": {Kind: &stpb.Value_NullValue{}},
 		"c": {Kind: &stpb.Value_NumberValue{3}},
 		"d": {Kind: &stpb.Value_BoolValue{true}},
 	}}}},
-	{"nested Struct", Unmarshaler{}, `{"st": {"a": {"b": 1, "c": [{"d": true}, "f"]}}}`, &pb.KnownTypes{St: &stpb.Struct{Fields: map[string]*stpb.Value{
+	{"nested Struct", Unmarshaler{}, `{"st": {"a": {"b": 1, "c": [{"d": true}, "f"]}}}`, &pb2.KnownTypes{St: &stpb.Struct{Fields: map[string]*stpb.Value{
 		"a": {Kind: &stpb.Value_StructValue{&stpb.Struct{Fields: map[string]*stpb.Value{
 			"b": {Kind: &stpb.Value_NumberValue{1}},
 			"c": {Kind: &stpb.Value_ListValue{&stpb.ListValue{Values: []*stpb.Value{
@@ -718,20 +768,20 @@ var unmarshalingTests = []struct {
 			}}}},
 		}}}},
 	}}}},
-	{"null ListValue", Unmarshaler{}, `{"lv": null}`, &pb.KnownTypes{Lv: nil}},
-	{"empty ListValue", Unmarshaler{}, `{"lv": []}`, &pb.KnownTypes{Lv: &stpb.ListValue{}}},
-	{"basic ListValue", Unmarshaler{}, `{"lv": ["x", null, 3, true]}`, &pb.KnownTypes{Lv: &stpb.ListValue{Values: []*stpb.Value{
+	{"null ListValue", Unmarshaler{}, `{"lv": null}`, &pb2.KnownTypes{Lv: nil}},
+	{"empty ListValue", Unmarshaler{}, `{"lv": []}`, &pb2.KnownTypes{Lv: &stpb.ListValue{}}},
+	{"basic ListValue", Unmarshaler{}, `{"lv": ["x", null, 3, true]}`, &pb2.KnownTypes{Lv: &stpb.ListValue{Values: []*stpb.Value{
 		{Kind: &stpb.Value_StringValue{"x"}},
 		{Kind: &stpb.Value_NullValue{}},
 		{Kind: &stpb.Value_NumberValue{3}},
 		{Kind: &stpb.Value_BoolValue{true}},
 	}}}},
-	{"number Value", Unmarshaler{}, `{"val":1}`, &pb.KnownTypes{Val: &stpb.Value{Kind: &stpb.Value_NumberValue{1}}}},
-	{"null Value", Unmarshaler{}, `{"val":null}`, &pb.KnownTypes{Val: &stpb.Value{Kind: &stpb.Value_NullValue{stpb.NullValue_NULL_VALUE}}}},
-	{"bool Value", Unmarshaler{}, `{"val":true}`, &pb.KnownTypes{Val: &stpb.Value{Kind: &stpb.Value_BoolValue{true}}}},
-	{"string Value", Unmarshaler{}, `{"val":"x"}`, &pb.KnownTypes{Val: &stpb.Value{Kind: &stpb.Value_StringValue{"x"}}}},
-	{"string number value", Unmarshaler{}, `{"val":"9223372036854775807"}`, &pb.KnownTypes{Val: &stpb.Value{Kind: &stpb.Value_StringValue{"9223372036854775807"}}}},
-	{"list of lists Value", Unmarshaler{}, `{"val":["x", [["y"], "z"]]}`, &pb.KnownTypes{Val: &stpb.Value{
+	{"number Value", Unmarshaler{}, `{"val":1}`, &pb2.KnownTypes{Val: &stpb.Value{Kind: &stpb.Value_NumberValue{1}}}},
+	{"null Value", Unmarshaler{}, `{"val":null}`, &pb2.KnownTypes{Val: &stpb.Value{Kind: &stpb.Value_NullValue{stpb.NullValue_NULL_VALUE}}}},
+	{"bool Value", Unmarshaler{}, `{"val":true}`, &pb2.KnownTypes{Val: &stpb.Value{Kind: &stpb.Value_BoolValue{true}}}},
+	{"string Value", Unmarshaler{}, `{"val":"x"}`, &pb2.KnownTypes{Val: &stpb.Value{Kind: &stpb.Value_StringValue{"x"}}}},
+	{"string number value", Unmarshaler{}, `{"val":"9223372036854775807"}`, &pb2.KnownTypes{Val: &stpb.Value{Kind: &stpb.Value_StringValue{"9223372036854775807"}}}},
+	{"list of lists Value", Unmarshaler{}, `{"val":["x", [["y"], "z"]]}`, &pb2.KnownTypes{Val: &stpb.Value{
 		Kind: &stpb.Value_ListValue{&stpb.ListValue{
 			Values: []*stpb.Value{
 				{Kind: &stpb.Value_StringValue{"x"}},
@@ -746,15 +796,15 @@ var unmarshalingTests = []struct {
 			},
 		}}}}},
 
-	{"DoubleValue", Unmarshaler{}, `{"dbl":1.2}`, &pb.KnownTypes{Dbl: &wpb.DoubleValue{Value: 1.2}}},
-	{"FloatValue", Unmarshaler{}, `{"flt":1.2}`, &pb.KnownTypes{Flt: &wpb.FloatValue{Value: 1.2}}},
-	{"Int64Value", Unmarshaler{}, `{"i64":"-3"}`, &pb.KnownTypes{I64: &wpb.Int64Value{Value: -3}}},
-	{"UInt64Value", Unmarshaler{}, `{"u64":"3"}`, &pb.KnownTypes{U64: &wpb.UInt64Value{Value: 3}}},
-	{"Int32Value", Unmarshaler{}, `{"i32":-4}`, &pb.KnownTypes{I32: &wpb.Int32Value{Value: -4}}},
-	{"UInt32Value", Unmarshaler{}, `{"u32":4}`, &pb.KnownTypes{U32: &wpb.UInt32Value{Value: 4}}},
-	{"BoolValue", Unmarshaler{}, `{"bool":true}`, &pb.KnownTypes{Bool: &wpb.BoolValue{Value: true}}},
-	{"StringValue", Unmarshaler{}, `{"str":"plush"}`, &pb.KnownTypes{Str: &wpb.StringValue{Value: "plush"}}},
-	{"StringValue containing escaped character", Unmarshaler{}, `{"str":"a\/b"}`, &pb.KnownTypes{Str: &wpb.StringValue{Value: "a/b"}}},
+	{"DoubleValue", Unmarshaler{}, `{"dbl":1.2}`, &pb2.KnownTypes{Dbl: &wpb.DoubleValue{Value: 1.2}}},
+	{"FloatValue", Unmarshaler{}, `{"flt":1.2}`, &pb2.KnownTypes{Flt: &wpb.FloatValue{Value: 1.2}}},
+	{"Int64Value", Unmarshaler{}, `{"i64":"-3"}`, &pb2.KnownTypes{I64: &wpb.Int64Value{Value: -3}}},
+	{"UInt64Value", Unmarshaler{}, `{"u64":"3"}`, &pb2.KnownTypes{U64: &wpb.UInt64Value{Value: 3}}},
+	{"Int32Value", Unmarshaler{}, `{"i32":-4}`, &pb2.KnownTypes{I32: &wpb.Int32Value{Value: -4}}},
+	{"UInt32Value", Unmarshaler{}, `{"u32":4}`, &pb2.KnownTypes{U32: &wpb.UInt32Value{Value: 4}}},
+	{"BoolValue", Unmarshaler{}, `{"bool":true}`, &pb2.KnownTypes{Bool: &wpb.BoolValue{Value: true}}},
+	{"StringValue", Unmarshaler{}, `{"str":"plush"}`, &pb2.KnownTypes{Str: &wpb.StringValue{Value: "plush"}}},
+	{"StringValue containing escaped character", Unmarshaler{}, `{"str":"a\/b"}`, &pb2.KnownTypes{Str: &wpb.StringValue{Value: "a/b"}}},
 	{"StructValue containing StringValue's", Unmarshaler{}, `{"escaped": "a\/b", "unicode": "\u00004E16\u0000754C"}`,
 		&stpb.Struct{
 			Fields: map[string]*stpb.Value{
@@ -762,31 +812,31 @@ var unmarshalingTests = []struct {
 				"unicode": {Kind: &stpb.Value_StringValue{"\u00004E16\u0000754C"}},
 			},
 		}},
-	{"BytesValue", Unmarshaler{}, `{"bytes":"d293"}`, &pb.KnownTypes{Bytes: &wpb.BytesValue{Value: []byte("wow")}}},
+	{"BytesValue", Unmarshaler{}, `{"bytes":"d293"}`, &pb2.KnownTypes{Bytes: &wpb.BytesValue{Value: []byte("wow")}}},
 
 	// Ensure that `null` as a value ends up with a nil pointer instead of a [type]Value struct.
-	{"null DoubleValue", Unmarshaler{}, `{"dbl":null}`, &pb.KnownTypes{Dbl: nil}},
-	{"null FloatValue", Unmarshaler{}, `{"flt":null}`, &pb.KnownTypes{Flt: nil}},
-	{"null Int64Value", Unmarshaler{}, `{"i64":null}`, &pb.KnownTypes{I64: nil}},
-	{"null UInt64Value", Unmarshaler{}, `{"u64":null}`, &pb.KnownTypes{U64: nil}},
-	{"null Int32Value", Unmarshaler{}, `{"i32":null}`, &pb.KnownTypes{I32: nil}},
-	{"null UInt32Value", Unmarshaler{}, `{"u32":null}`, &pb.KnownTypes{U32: nil}},
-	{"null BoolValue", Unmarshaler{}, `{"bool":null}`, &pb.KnownTypes{Bool: nil}},
-	{"null StringValue", Unmarshaler{}, `{"str":null}`, &pb.KnownTypes{Str: nil}},
-	{"null BytesValue", Unmarshaler{}, `{"bytes":null}`, &pb.KnownTypes{Bytes: nil}},
-
-	{"required", Unmarshaler{}, `{"str":"hello"}`, &pb.MsgWithRequired{Str: proto.String("hello")}},
-	{"required bytes", Unmarshaler{}, `{"byts": []}`, &pb.MsgWithRequiredBytes{Byts: []byte{}}},
+	{"null DoubleValue", Unmarshaler{}, `{"dbl":null}`, &pb2.KnownTypes{Dbl: nil}},
+	{"null FloatValue", Unmarshaler{}, `{"flt":null}`, &pb2.KnownTypes{Flt: nil}},
+	{"null Int64Value", Unmarshaler{}, `{"i64":null}`, &pb2.KnownTypes{I64: nil}},
+	{"null UInt64Value", Unmarshaler{}, `{"u64":null}`, &pb2.KnownTypes{U64: nil}},
+	{"null Int32Value", Unmarshaler{}, `{"i32":null}`, &pb2.KnownTypes{I32: nil}},
+	{"null UInt32Value", Unmarshaler{}, `{"u32":null}`, &pb2.KnownTypes{U32: nil}},
+	{"null BoolValue", Unmarshaler{}, `{"bool":null}`, &pb2.KnownTypes{Bool: nil}},
+	{"null StringValue", Unmarshaler{}, `{"str":null}`, &pb2.KnownTypes{Str: nil}},
+	{"null BytesValue", Unmarshaler{}, `{"bytes":null}`, &pb2.KnownTypes{Bytes: nil}},
+
+	{"required", Unmarshaler{}, `{"str":"hello"}`, &pb2.MsgWithRequired{Str: proto.String("hello")}},
+	{"required bytes", Unmarshaler{}, `{"byts": []}`, &pb2.MsgWithRequiredBytes{Byts: []byte{}}},
 }
 
 func TestUnmarshaling(t *testing.T) {
 	for _, tt := range unmarshalingTests {
-		// Make a new instance of the type of our expected object.
+		// Make a new instance of the type of our wanted object.
 		p := reflect.New(reflect.TypeOf(tt.pb).Elem()).Interface().(proto.Message)
 
 		err := tt.unmarshaler.Unmarshal(strings.NewReader(tt.json), p)
 		if err != nil {
-			t.Errorf("%s: %v", tt.desc, err)
+			t.Errorf("unmarshaling %s: %v", tt.desc, err)
 			continue
 		}
 
@@ -800,21 +850,21 @@ func TestUnmarshaling(t *testing.T) {
 }
 
 func TestUnmarshalNullArray(t *testing.T) {
-	var repeats pb.Repeats
+	var repeats pb2.Repeats
 	if err := UnmarshalString(`{"rBool":null}`, &repeats); err != nil {
 		t.Fatal(err)
 	}
-	if !reflect.DeepEqual(repeats, pb.Repeats{}) {
+	if !proto.Equal(&repeats, &pb2.Repeats{}) {
 		t.Errorf("got non-nil fields in [%#v]", repeats)
 	}
 }
 
 func TestUnmarshalNullObject(t *testing.T) {
-	var maps pb.Maps
+	var maps pb2.Maps
 	if err := UnmarshalString(`{"mInt64Str":null}`, &maps); err != nil {
 		t.Fatal(err)
 	}
-	if !reflect.DeepEqual(maps, pb.Maps{}) {
+	if !proto.Equal(&maps, &pb2.Maps{}) {
 		t.Errorf("got non-nil fields in [%#v]", maps)
 	}
 }
@@ -831,7 +881,7 @@ func TestUnmarshalNext(t *testing.T) {
 
 	dec := json.NewDecoder(&b)
 	for _, tt := range tests {
-		// Make a new instance of the type of our expected object.
+		// Make a new instance of the type of our wanted object.
 		p := reflect.New(reflect.TypeOf(tt.pb).Elem()).Interface().(proto.Message)
 
 		err := tt.unmarshaler.UnmarshalNext(dec, p)
@@ -848,10 +898,10 @@ func TestUnmarshalNext(t *testing.T) {
 		}
 	}
 
-	p := &pb.Simple{}
+	p := &pb2.Simple{}
 	err := new(Unmarshaler).UnmarshalNext(dec, p)
 	if err != io.EOF {
-		t.Errorf("eof: got %v, expected io.EOF", err)
+		t.Errorf("eof: got %v, want io.EOF", err)
 	}
 }
 
@@ -860,22 +910,24 @@ var unmarshalingShouldError = []struct {
 	in   string
 	pb   proto.Message
 }{
-	{"a value", "666", new(pb.Simple)},
-	{"gibberish", "{adskja123;l23=-=", new(pb.Simple)},
-	{"unknown field", `{"unknown": "foo"}`, new(pb.Simple)},
-	{"unknown enum name", `{"hilarity":"DAVE"}`, new(proto3pb.Message)},
-	{"Duration containing invalid character", `{"dur": "3\U0073"}`, &pb.KnownTypes{}},
-	{"Timestamp containing invalid character", `{"ts": "2014-05-13T16:53:20\U005a"}`, &pb.KnownTypes{}},
-	{"StringValue containing invalid character", `{"str": "\U00004E16\U0000754C"}`, &pb.KnownTypes{}},
+	{"a value", "666", new(pb2.Simple)},
+	{"gibberish", "{adskja123;l23=-=", new(pb2.Simple)},
+	{"unknown field", `{"unknown": "foo"}`, new(pb2.Simple)},
+	{"unknown enum name", `{"hilarity":"DAVE"}`, new(pb3.Message)},
+	{"Duration containing invalid character", `{"dur": "3\U0073"}`, &pb2.KnownTypes{}},
+	{"Timestamp containing invalid character", `{"ts": "2014-05-13T16:53:20\U005a"}`, &pb2.KnownTypes{}},
+	{"StringValue containing invalid character", `{"str": "\U00004E16\U0000754C"}`, &pb2.KnownTypes{}},
 	{"StructValue containing invalid character", `{"str": "\U00004E16\U0000754C"}`, &stpb.Struct{}},
-	{"repeated proto3 enum with non array input", `{"rFunny":"PUNS"}`, &proto3pb.Message{RFunny: []proto3pb.Message_Humour{}}},
+	{"repeated proto3 enum with non array input", `{"rFunny":"PUNS"}`, &pb3.Message{RFunny: []pb3.Message_Humour{}}},
+	{"unknown extension field", `{"[ext_unknown]": "value"}`, &pb2.Real{}},
+	{"extension field for wrong message", `{"[jsonpb_test.name]": "value"}`, &pb2.Complex{}},
 }
 
 func TestUnmarshalingBadInput(t *testing.T) {
 	for _, tt := range unmarshalingShouldError {
 		err := UnmarshalString(tt.in, tt.pb)
 		if err == nil {
-			t.Errorf("an error was expected when parsing %q instead of an object", tt.desc)
+			t.Errorf("expected error while parsing %q", tt.desc)
 		}
 	}
 }
@@ -890,9 +942,9 @@ func TestAnyWithCustomResolver(t *testing.T) {
 	var resolvedTypeUrls []string
 	resolver := funcResolver(func(turl string) (proto.Message, error) {
 		resolvedTypeUrls = append(resolvedTypeUrls, turl)
-		return new(pb.Simple), nil
+		return new(pb2.Simple), nil
 	})
-	msg := &pb.Simple{
+	msg := &pb2.Simple{
 		OBytes:  []byte{1, 2, 3, 4},
 		OBool:   proto.Bool(true),
 		OString: proto.String("foobar"),
@@ -900,7 +952,7 @@ func TestAnyWithCustomResolver(t *testing.T) {
 	}
 	msgBytes, err := proto.Marshal(msg)
 	if err != nil {
-		t.Errorf("an unexpected error occurred when marshaling message: %v", err)
+		t.Errorf("an unexpected error while marshaling message: %v", err)
 	}
 	// make an Any with a type URL that won't resolve w/out custom resolver
 	any := &anypb.Any{
@@ -911,7 +963,7 @@ func TestAnyWithCustomResolver(t *testing.T) {
 	m := Marshaler{AnyResolver: resolver}
 	js, err := m.MarshalToString(any)
 	if err != nil {
-		t.Errorf("an unexpected error occurred when marshaling any to JSON: %v", err)
+		t.Errorf("an unexpected error while marshaling any to JSON: %v", err)
 	}
 	if len(resolvedTypeUrls) != 1 {
 		t.Errorf("custom resolver was not invoked during marshaling")
@@ -920,14 +972,14 @@ func TestAnyWithCustomResolver(t *testing.T) {
 	}
 	wanted := `{"@type":"https://foobar.com/some.random.MessageKind","oBool":true,"oInt64":"1020304","oString":"foobar","oBytes":"AQIDBA=="}`
 	if js != wanted {
-		t.Errorf("marshalling JSON produced incorrect output: got %s, wanted %s", js, wanted)
+		t.Errorf("marshaling JSON produced incorrect output: got %s, wanted %s", js, wanted)
 	}
 
 	u := Unmarshaler{AnyResolver: resolver}
 	roundTrip := &anypb.Any{}
 	err = u.Unmarshal(bytes.NewReader([]byte(js)), roundTrip)
 	if err != nil {
-		t.Errorf("an unexpected error occurred when unmarshaling any from JSON: %v", err)
+		t.Errorf("an unexpected error while unmarshaling any from JSON: %v", err)
 	}
 	if len(resolvedTypeUrls) != 2 {
 		t.Errorf("custom resolver was not invoked during marshaling")
@@ -935,7 +987,7 @@ func TestAnyWithCustomResolver(t *testing.T) {
 		t.Errorf("custom resolver was invoked with wrong URL: got %q, wanted %q", resolvedTypeUrls[1], "https://foobar.com/some.random.MessageKind")
 	}
 	if !proto.Equal(any, roundTrip) {
-		t.Errorf("message contents not set correctly after unmarshalling JSON: got %s, wanted %s", roundTrip, any)
+		t.Errorf("message contents not set correctly after unmarshaling JSON: got %s, wanted %s", roundTrip, any)
 	}
 }
 
@@ -943,10 +995,10 @@ func TestUnmarshalJSONPBUnmarshaler(t *testing.T) {
 	rawJson := `{ "foo": "bar", "baz": [0, 1, 2, 3] }`
 	var msg dynamicMessage
 	if err := Unmarshal(strings.NewReader(rawJson), &msg); err != nil {
-		t.Errorf("an unexpected error occurred when parsing into JSONPBUnmarshaler: %v", err)
+		t.Errorf("an unexpected error while parsing into JSONPBUnmarshaler: %v", err)
 	}
-	if msg.rawJson != rawJson {
-		t.Errorf("message contents not set correctly after unmarshalling JSON: got %s, wanted %s", msg.rawJson, rawJson)
+	if msg.RawJson != rawJson {
+		t.Errorf("message contents not set correctly after unmarshaling JSON: got %s, wanted %s", msg.RawJson, rawJson)
 	}
 }
 
@@ -957,7 +1009,7 @@ func TestUnmarshalNullWithJSONPBUnmarshaler(t *testing.T) {
 		t.Errorf("unmarshal error: %v", err)
 	}
 
-	want := ptrFieldMessage{StringField: &stringField{IsSet: true, StringValue: "null"}}
+	want := ptrFieldMessage{}
 	if !proto.Equal(&ptrFieldMsg, &want) {
 		t.Errorf("unmarshal result StringField: got %v, want %v", ptrFieldMsg, want)
 	}
@@ -967,25 +1019,25 @@ func TestUnmarshalAnyJSONPBUnmarshaler(t *testing.T) {
 	rawJson := `{ "@type": "blah.com/` + dynamicMessageName + `", "foo": "bar", "baz": [0, 1, 2, 3] }`
 	var got anypb.Any
 	if err := Unmarshal(strings.NewReader(rawJson), &got); err != nil {
-		t.Errorf("an unexpected error occurred when parsing into JSONPBUnmarshaler: %v", err)
+		t.Errorf("an unexpected error while parsing into JSONPBUnmarshaler: %v", err)
 	}
 
-	dm := &dynamicMessage{rawJson: `{"baz":[0,1,2,3],"foo":"bar"}`}
+	dm := &dynamicMessage{RawJson: `{"baz":[0,1,2,3],"foo":"bar"}`}
 	var want anypb.Any
 	if b, err := proto.Marshal(dm); err != nil {
-		t.Errorf("an unexpected error occurred when marshaling message: %v", err)
+		t.Errorf("an unexpected error while marshaling message: %v", err)
 	} else {
 		want.TypeUrl = "blah.com/" + dynamicMessageName
 		want.Value = b
 	}
 
 	if !proto.Equal(&got, &want) {
-		t.Errorf("message contents not set correctly after unmarshalling JSON: got %v, wanted %v", got, want)
+		t.Errorf("message contents not set correctly after unmarshaling JSON: got %v, wanted %v", &got, &want)
 	}
 }
 
 const (
-	dynamicMessageName = "google.protobuf.jsonpb.testing.dynamicMessage"
+	dynamicMessageName = "github_com.golang.protobuf.jsonpb.dynamicMessage"
 )
 
 func init() {
@@ -1007,6 +1059,10 @@ func (m *ptrFieldMessage) String() string {
 func (m *ptrFieldMessage) ProtoMessage() {
 }
 
+func (m *ptrFieldMessage) Descriptor() ([]byte, []int) {
+	return testMessageFD, []int{0}
+}
+
 type stringField struct {
 	IsSet       bool   `protobuf:"varint,1,opt,name=isSet"`
 	StringValue string `protobuf:"bytes,2,opt,name=stringValue"`
@@ -1022,6 +1078,10 @@ func (s *stringField) String() string {
 func (s *stringField) ProtoMessage() {
 }
 
+func (s *stringField) Descriptor() ([]byte, []int) {
+	return testMessageFD, []int{1}
+}
+
 func (s *stringField) UnmarshalJSONPB(jum *Unmarshaler, js []byte) error {
 	s.IsSet = true
 	s.StringValue = string(js)
@@ -1031,33 +1091,70 @@ func (s *stringField) UnmarshalJSONPB(jum *Unmarshaler, js []byte) error {
 // dynamicMessage implements protobuf.Message but is not a normal generated message type.
 // It provides implementations of JSONPBMarshaler and JSONPBUnmarshaler for JSON support.
 type dynamicMessage struct {
-	rawJson string `protobuf:"bytes,1,opt,name=rawJson"`
+	RawJson string `protobuf:"bytes,1,opt,name=rawJson"`
 
 	// an unexported nested message is present just to ensure that it
 	// won't result in a panic (see issue #509)
-	dummy *dynamicMessage `protobuf:"bytes,2,opt,name=dummy"`
+	Dummy *dynamicMessage `protobuf:"bytes,2,opt,name=dummy"`
 }
 
 func (m *dynamicMessage) Reset() {
-	m.rawJson = "{}"
+	m.RawJson = "{}"
 }
 
 func (m *dynamicMessage) String() string {
-	return m.rawJson
+	return m.RawJson
 }
 
 func (m *dynamicMessage) ProtoMessage() {
 }
 
+func (m *dynamicMessage) Descriptor() ([]byte, []int) {
+	return testMessageFD, []int{2}
+}
+
 func (m *dynamicMessage) MarshalJSONPB(jm *Marshaler) ([]byte, error) {
-	return []byte(m.rawJson), nil
+	return []byte(m.RawJson), nil
 }
 
 func (m *dynamicMessage) UnmarshalJSONPB(jum *Unmarshaler, js []byte) error {
-	m.rawJson = string(js)
+	m.RawJson = string(js)
 	return nil
 }
 
+var testMessageFD = func() []byte {
+	fd := new(descpb.FileDescriptorProto)
+	proto.UnmarshalText(`
+		name:    "jsonpb.proto"
+		package: "github_com.golang.protobuf.jsonpb"
+		syntax:  "proto3"
+		message_type: [{
+			name: "ptrFieldMessage"
+			field: [
+				{name:"stringField" number:1 label:LABEL_OPTIONAL type:TYPE_MESSAGE type_name:".github_com.golang.protobuf.jsonpb.stringField"}
+			]
+		}, {
+			name: "stringField"
+			field: [
+				{name:"isSet"       number:1 label:LABEL_OPTIONAL type:TYPE_BOOL},
+				{name:"stringValue" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}
+			]
+		}, {
+			name: "dynamicMessage"
+			field: [
+				{name:"rawJson" number:1 label:LABEL_OPTIONAL type:TYPE_BYTES},
+				{name:"dummy"   number:2 label:LABEL_OPTIONAL type:TYPE_MESSAGE type_name:".github_com.golang.protobuf.jsonpb.dynamicMessage"}
+			]
+		}]
+	`, fd)
+	b, _ := proto.Marshal(fd)
+	var buf bytes.Buffer
+	zw := gzip.NewWriter(&buf)
+	zw.Write(b)
+	zw.Close()
+	return buf.Bytes()
+}()
+
 // Test unmarshaling message containing unset required fields should produce error.
 func TestUnmarshalUnsetRequiredFields(t *testing.T) {
 	tests := []struct {
@@ -1067,99 +1164,99 @@ func TestUnmarshalUnsetRequiredFields(t *testing.T) {
 	}{
 		{
 			desc: "direct required field missing",
-			pb:   &pb.MsgWithRequired{},
+			pb:   &pb2.MsgWithRequired{},
 			json: `{}`,
 		},
 		{
 			desc: "direct required field set to null",
-			pb:   &pb.MsgWithRequired{},
+			pb:   &pb2.MsgWithRequired{},
 			json: `{"str": null}`,
 		},
 		{
 			desc: "indirect required field missing",
-			pb:   &pb.MsgWithIndirectRequired{},
+			pb:   &pb2.MsgWithIndirectRequired{},
 			json: `{"subm": {}}`,
 		},
 		{
 			desc: "indirect required field set to null",
-			pb:   &pb.MsgWithIndirectRequired{},
+			pb:   &pb2.MsgWithIndirectRequired{},
 			json: `{"subm": {"str": null}}`,
 		},
 		{
 			desc: "direct required bytes field missing",
-			pb:   &pb.MsgWithRequiredBytes{},
+			pb:   &pb2.MsgWithRequiredBytes{},
 			json: `{}`,
 		},
 		{
 			desc: "direct required bytes field set to null",
-			pb:   &pb.MsgWithRequiredBytes{},
+			pb:   &pb2.MsgWithRequiredBytes{},
 			json: `{"byts": null}`,
 		},
 		{
 			desc: "direct required wkt field missing",
-			pb:   &pb.MsgWithRequiredWKT{},
+			pb:   &pb2.MsgWithRequiredWKT{},
 			json: `{}`,
 		},
 		{
 			desc: "direct required wkt field set to null",
-			pb:   &pb.MsgWithRequiredWKT{},
+			pb:   &pb2.MsgWithRequiredWKT{},
 			json: `{"str": null}`,
 		},
 		{
 			desc: "any containing message with required field set to null",
-			pb:   &pb.KnownTypes{},
+			pb:   &pb2.KnownTypes{},
 			json: `{"an": {"@type": "example.com/jsonpb.MsgWithRequired", "str": null}}`,
 		},
 		{
 			desc: "any containing message with missing required field",
-			pb:   &pb.KnownTypes{},
+			pb:   &pb2.KnownTypes{},
 			json: `{"an": {"@type": "example.com/jsonpb.MsgWithRequired"}}`,
 		},
 		{
 			desc: "missing required in map value",
-			pb:   &pb.MsgWithIndirectRequired{},
+			pb:   &pb2.MsgWithIndirectRequired{},
 			json: `{"map_field": {"a": {}, "b": {"str": "hi"}}}`,
 		},
 		{
 			desc: "required in map value set to null",
-			pb:   &pb.MsgWithIndirectRequired{},
+			pb:   &pb2.MsgWithIndirectRequired{},
 			json: `{"map_field": {"a": {"str": "hello"}, "b": {"str": null}}}`,
 		},
 		{
 			desc: "missing required in slice item",
-			pb:   &pb.MsgWithIndirectRequired{},
+			pb:   &pb2.MsgWithIndirectRequired{},
 			json: `{"slice_field": [{}, {"str": "hi"}]}`,
 		},
 		{
 			desc: "required in slice item set to null",
-			pb:   &pb.MsgWithIndirectRequired{},
+			pb:   &pb2.MsgWithIndirectRequired{},
 			json: `{"slice_field": [{"str": "hello"}, {"str": null}]}`,
 		},
 		{
 			desc: "required inside oneof missing",
-			pb:   &pb.MsgWithOneof{},
+			pb:   &pb2.MsgWithOneof{},
 			json: `{"msgWithRequired": {}}`,
 		},
 		{
 			desc: "required inside oneof set to null",
-			pb:   &pb.MsgWithOneof{},
+			pb:   &pb2.MsgWithOneof{},
 			json: `{"msgWithRequired": {"str": null}}`,
 		},
 		{
 			desc: "required field in extension missing",
-			pb:   &pb.Real{},
+			pb:   &pb2.Real{},
 			json: `{"[jsonpb.extm]":{}}`,
 		},
 		{
 			desc: "required field in extension set to null",
-			pb:   &pb.Real{},
+			pb:   &pb2.Real{},
 			json: `{"[jsonpb.extm]":{"str": null}}`,
 		},
 	}
 
 	for _, tc := range tests {
 		if err := UnmarshalString(tc.json, tc.pb); err == nil {
-			t.Errorf("%s: expecting error in unmarshaling with unset required fields %s", tc.desc, tc.json)
+			t.Errorf("%s: expected error while unmarshaling with unset required fields %s", tc.desc, tc.json)
 		}
 	}
 }
diff --git a/vendor/github.com/golang/protobuf/jsonpb/jsonpb.go b/vendor/github.com/golang/protobuf/jsonpb/jsonpb.go
deleted file mode 100644
index 242e3155b..000000000
--- a/vendor/github.com/golang/protobuf/jsonpb/jsonpb.go
+++ /dev/null
@@ -1,1250 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2015 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-/*
-Package jsonpb provides marshaling and unmarshaling between protocol buffers and JSON.
-It follows the specification at https://developers.google.com/protocol-buffers/docs/proto3#json.
-
-This package produces a different output than the standard "encoding/json" package,
-which does not operate correctly on protocol buffers.
-*/
-package jsonpb
-
-import (
-	"bytes"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"math"
-	"reflect"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/golang/protobuf/proto"
-
-	stpb "github.com/golang/protobuf/ptypes/struct"
-)
-
-const secondInNanos = int64(time.Second / time.Nanosecond)
-
-// Marshaler is a configurable object for converting between
-// protocol buffer objects and a JSON representation for them.
-type Marshaler struct {
-	// Whether to render enum values as integers, as opposed to string values.
-	EnumsAsInts bool
-
-	// Whether to render fields with zero values.
-	EmitDefaults bool
-
-	// A string to indent each level by. The presence of this field will
-	// also cause a space to appear between the field separator and
-	// value, and for newlines to be appear between fields and array
-	// elements.
-	Indent string
-
-	// Whether to use the original (.proto) name for fields.
-	OrigName bool
-
-	// A custom URL resolver to use when marshaling Any messages to JSON.
-	// If unset, the default resolution strategy is to extract the
-	// fully-qualified type name from the type URL and pass that to
-	// proto.MessageType(string).
-	AnyResolver AnyResolver
-}
-
-// AnyResolver takes a type URL, present in an Any message, and resolves it into
-// an instance of the associated message.
-type AnyResolver interface {
-	Resolve(typeUrl string) (proto.Message, error)
-}
-
-func defaultResolveAny(typeUrl string) (proto.Message, error) {
-	// Only the part of typeUrl after the last slash is relevant.
-	mname := typeUrl
-	if slash := strings.LastIndex(mname, "/"); slash >= 0 {
-		mname = mname[slash+1:]
-	}
-	mt := proto.MessageType(mname)
-	if mt == nil {
-		return nil, fmt.Errorf("unknown message type %q", mname)
-	}
-	return reflect.New(mt.Elem()).Interface().(proto.Message), nil
-}
-
-// JSONPBMarshaler is implemented by protobuf messages that customize the
-// way they are marshaled to JSON. Messages that implement this should
-// also implement JSONPBUnmarshaler so that the custom format can be
-// parsed.
-type JSONPBMarshaler interface {
-	MarshalJSONPB(*Marshaler) ([]byte, error)
-}
-
-// JSONPBUnmarshaler is implemented by protobuf messages that customize
-// the way they are unmarshaled from JSON. Messages that implement this
-// should also implement JSONPBMarshaler so that the custom format can be
-// produced.
-type JSONPBUnmarshaler interface {
-	UnmarshalJSONPB(*Unmarshaler, []byte) error
-}
-
-// Marshal marshals a protocol buffer into JSON.
-func (m *Marshaler) Marshal(out io.Writer, pb proto.Message) error {
-	v := reflect.ValueOf(pb)
-	if pb == nil || (v.Kind() == reflect.Ptr && v.IsNil()) {
-		return errors.New("Marshal called with nil")
-	}
-	// Check for unset required fields first.
-	if err := checkRequiredFields(pb); err != nil {
-		return err
-	}
-	writer := &errWriter{writer: out}
-	return m.marshalObject(writer, pb, "", "")
-}
-
-// MarshalToString converts a protocol buffer object to JSON string.
-func (m *Marshaler) MarshalToString(pb proto.Message) (string, error) {
-	var buf bytes.Buffer
-	if err := m.Marshal(&buf, pb); err != nil {
-		return "", err
-	}
-	return buf.String(), nil
-}
-
-type int32Slice []int32
-
-var nonFinite = map[string]float64{
-	`"NaN"`:       math.NaN(),
-	`"Infinity"`:  math.Inf(1),
-	`"-Infinity"`: math.Inf(-1),
-}
-
-// For sorting extensions ids to ensure stable output.
-func (s int32Slice) Len() int           { return len(s) }
-func (s int32Slice) Less(i, j int) bool { return s[i] < s[j] }
-func (s int32Slice) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
-
-type wkt interface {
-	XXX_WellKnownType() string
-}
-
-// marshalObject writes a struct to the Writer.
-func (m *Marshaler) marshalObject(out *errWriter, v proto.Message, indent, typeURL string) error {
-	if jsm, ok := v.(JSONPBMarshaler); ok {
-		b, err := jsm.MarshalJSONPB(m)
-		if err != nil {
-			return err
-		}
-		if typeURL != "" {
-			// we are marshaling this object to an Any type
-			var js map[string]*json.RawMessage
-			if err = json.Unmarshal(b, &js); err != nil {
-				return fmt.Errorf("type %T produced invalid JSON: %v", v, err)
-			}
-			turl, err := json.Marshal(typeURL)
-			if err != nil {
-				return fmt.Errorf("failed to marshal type URL %q to JSON: %v", typeURL, err)
-			}
-			js["@type"] = (*json.RawMessage)(&turl)
-			if b, err = json.Marshal(js); err != nil {
-				return err
-			}
-		}
-
-		out.write(string(b))
-		return out.err
-	}
-
-	s := reflect.ValueOf(v).Elem()
-
-	// Handle well-known types.
-	if wkt, ok := v.(wkt); ok {
-		switch wkt.XXX_WellKnownType() {
-		case "DoubleValue", "FloatValue", "Int64Value", "UInt64Value",
-			"Int32Value", "UInt32Value", "BoolValue", "StringValue", "BytesValue":
-			// "Wrappers use the same representation in JSON
-			//  as the wrapped primitive type, ..."
-			sprop := proto.GetProperties(s.Type())
-			return m.marshalValue(out, sprop.Prop[0], s.Field(0), indent)
-		case "Any":
-			// Any is a bit more involved.
-			return m.marshalAny(out, v, indent)
-		case "Duration":
-			// "Generated output always contains 0, 3, 6, or 9 fractional digits,
-			//  depending on required precision."
-			s, ns := s.Field(0).Int(), s.Field(1).Int()
-			if ns <= -secondInNanos || ns >= secondInNanos {
-				return fmt.Errorf("ns out of range (%v, %v)", -secondInNanos, secondInNanos)
-			}
-			if (s > 0 && ns < 0) || (s < 0 && ns > 0) {
-				return errors.New("signs of seconds and nanos do not match")
-			}
-			if s < 0 {
-				ns = -ns
-			}
-			x := fmt.Sprintf("%d.%09d", s, ns)
-			x = strings.TrimSuffix(x, "000")
-			x = strings.TrimSuffix(x, "000")
-			x = strings.TrimSuffix(x, ".000")
-			out.write(`"`)
-			out.write(x)
-			out.write(`s"`)
-			return out.err
-		case "Struct", "ListValue":
-			// Let marshalValue handle the `Struct.fields` map or the `ListValue.values` slice.
-			// TODO: pass the correct Properties if needed.
-			return m.marshalValue(out, &proto.Properties{}, s.Field(0), indent)
-		case "Timestamp":
-			// "RFC 3339, where generated output will always be Z-normalized
-			//  and uses 0, 3, 6 or 9 fractional digits."
-			s, ns := s.Field(0).Int(), s.Field(1).Int()
-			if ns < 0 || ns >= secondInNanos {
-				return fmt.Errorf("ns out of range [0, %v)", secondInNanos)
-			}
-			t := time.Unix(s, ns).UTC()
-			// time.RFC3339Nano isn't exactly right (we need to get 3/6/9 fractional digits).
-			x := t.Format("2006-01-02T15:04:05.000000000")
-			x = strings.TrimSuffix(x, "000")
-			x = strings.TrimSuffix(x, "000")
-			x = strings.TrimSuffix(x, ".000")
-			out.write(`"`)
-			out.write(x)
-			out.write(`Z"`)
-			return out.err
-		case "Value":
-			// Value has a single oneof.
-			kind := s.Field(0)
-			if kind.IsNil() {
-				// "absence of any variant indicates an error"
-				return errors.New("nil Value")
-			}
-			// oneof -> *T -> T -> T.F
-			x := kind.Elem().Elem().Field(0)
-			// TODO: pass the correct Properties if needed.
-			return m.marshalValue(out, &proto.Properties{}, x, indent)
-		}
-	}
-
-	out.write("{")
-	if m.Indent != "" {
-		out.write("\n")
-	}
-
-	firstField := true
-
-	if typeURL != "" {
-		if err := m.marshalTypeURL(out, indent, typeURL); err != nil {
-			return err
-		}
-		firstField = false
-	}
-
-	for i := 0; i < s.NumField(); i++ {
-		value := s.Field(i)
-		valueField := s.Type().Field(i)
-		if strings.HasPrefix(valueField.Name, "XXX_") {
-			continue
-		}
-
-		// IsNil will panic on most value kinds.
-		switch value.Kind() {
-		case reflect.Chan, reflect.Func, reflect.Interface:
-			if value.IsNil() {
-				continue
-			}
-		}
-
-		if !m.EmitDefaults {
-			switch value.Kind() {
-			case reflect.Bool:
-				if !value.Bool() {
-					continue
-				}
-			case reflect.Int32, reflect.Int64:
-				if value.Int() == 0 {
-					continue
-				}
-			case reflect.Uint32, reflect.Uint64:
-				if value.Uint() == 0 {
-					continue
-				}
-			case reflect.Float32, reflect.Float64:
-				if value.Float() == 0 {
-					continue
-				}
-			case reflect.String:
-				if value.Len() == 0 {
-					continue
-				}
-			case reflect.Map, reflect.Ptr, reflect.Slice:
-				if value.IsNil() {
-					continue
-				}
-			}
-		}
-
-		// Oneof fields need special handling.
-		if valueField.Tag.Get("protobuf_oneof") != "" {
-			// value is an interface containing &T{real_value}.
-			sv := value.Elem().Elem() // interface -> *T -> T
-			value = sv.Field(0)
-			valueField = sv.Type().Field(0)
-		}
-		prop := jsonProperties(valueField, m.OrigName)
-		if !firstField {
-			m.writeSep(out)
-		}
-		if err := m.marshalField(out, prop, value, indent); err != nil {
-			return err
-		}
-		firstField = false
-	}
-
-	// Handle proto2 extensions.
-	if ep, ok := v.(proto.Message); ok {
-		extensions := proto.RegisteredExtensions(v)
-		// Sort extensions for stable output.
-		ids := make([]int32, 0, len(extensions))
-		for id, desc := range extensions {
-			if !proto.HasExtension(ep, desc) {
-				continue
-			}
-			ids = append(ids, id)
-		}
-		sort.Sort(int32Slice(ids))
-		for _, id := range ids {
-			desc := extensions[id]
-			if desc == nil {
-				// unknown extension
-				continue
-			}
-			ext, extErr := proto.GetExtension(ep, desc)
-			if extErr != nil {
-				return extErr
-			}
-			value := reflect.ValueOf(ext)
-			var prop proto.Properties
-			prop.Parse(desc.Tag)
-			prop.JSONName = fmt.Sprintf("[%s]", desc.Name)
-			if !firstField {
-				m.writeSep(out)
-			}
-			if err := m.marshalField(out, &prop, value, indent); err != nil {
-				return err
-			}
-			firstField = false
-		}
-
-	}
-
-	if m.Indent != "" {
-		out.write("\n")
-		out.write(indent)
-	}
-	out.write("}")
-	return out.err
-}
-
-func (m *Marshaler) writeSep(out *errWriter) {
-	if m.Indent != "" {
-		out.write(",\n")
-	} else {
-		out.write(",")
-	}
-}
-
-func (m *Marshaler) marshalAny(out *errWriter, any proto.Message, indent string) error {
-	// "If the Any contains a value that has a special JSON mapping,
-	//  it will be converted as follows: {"@type": xxx, "value": yyy}.
-	//  Otherwise, the value will be converted into a JSON object,
-	//  and the "@type" field will be inserted to indicate the actual data type."
-	v := reflect.ValueOf(any).Elem()
-	turl := v.Field(0).String()
-	val := v.Field(1).Bytes()
-
-	var msg proto.Message
-	var err error
-	if m.AnyResolver != nil {
-		msg, err = m.AnyResolver.Resolve(turl)
-	} else {
-		msg, err = defaultResolveAny(turl)
-	}
-	if err != nil {
-		return err
-	}
-
-	if err := proto.Unmarshal(val, msg); err != nil {
-		return err
-	}
-
-	if _, ok := msg.(wkt); ok {
-		out.write("{")
-		if m.Indent != "" {
-			out.write("\n")
-		}
-		if err := m.marshalTypeURL(out, indent, turl); err != nil {
-			return err
-		}
-		m.writeSep(out)
-		if m.Indent != "" {
-			out.write(indent)
-			out.write(m.Indent)
-			out.write(`"value": `)
-		} else {
-			out.write(`"value":`)
-		}
-		if err := m.marshalObject(out, msg, indent+m.Indent, ""); err != nil {
-			return err
-		}
-		if m.Indent != "" {
-			out.write("\n")
-			out.write(indent)
-		}
-		out.write("}")
-		return out.err
-	}
-
-	return m.marshalObject(out, msg, indent, turl)
-}
-
-func (m *Marshaler) marshalTypeURL(out *errWriter, indent, typeURL string) error {
-	if m.Indent != "" {
-		out.write(indent)
-		out.write(m.Indent)
-	}
-	out.write(`"@type":`)
-	if m.Indent != "" {
-		out.write(" ")
-	}
-	b, err := json.Marshal(typeURL)
-	if err != nil {
-		return err
-	}
-	out.write(string(b))
-	return out.err
-}
-
-// marshalField writes field description and value to the Writer.
-func (m *Marshaler) marshalField(out *errWriter, prop *proto.Properties, v reflect.Value, indent string) error {
-	if m.Indent != "" {
-		out.write(indent)
-		out.write(m.Indent)
-	}
-	out.write(`"`)
-	out.write(prop.JSONName)
-	out.write(`":`)
-	if m.Indent != "" {
-		out.write(" ")
-	}
-	if err := m.marshalValue(out, prop, v, indent); err != nil {
-		return err
-	}
-	return nil
-}
-
-// marshalValue writes the value to the Writer.
-func (m *Marshaler) marshalValue(out *errWriter, prop *proto.Properties, v reflect.Value, indent string) error {
-	var err error
-	v = reflect.Indirect(v)
-
-	// Handle nil pointer
-	if v.Kind() == reflect.Invalid {
-		out.write("null")
-		return out.err
-	}
-
-	// Handle repeated elements.
-	if v.Kind() == reflect.Slice && v.Type().Elem().Kind() != reflect.Uint8 {
-		out.write("[")
-		comma := ""
-		for i := 0; i < v.Len(); i++ {
-			sliceVal := v.Index(i)
-			out.write(comma)
-			if m.Indent != "" {
-				out.write("\n")
-				out.write(indent)
-				out.write(m.Indent)
-				out.write(m.Indent)
-			}
-			if err := m.marshalValue(out, prop, sliceVal, indent+m.Indent); err != nil {
-				return err
-			}
-			comma = ","
-		}
-		if m.Indent != "" {
-			out.write("\n")
-			out.write(indent)
-			out.write(m.Indent)
-		}
-		out.write("]")
-		return out.err
-	}
-
-	// Handle well-known types.
-	// Most are handled up in marshalObject (because 99% are messages).
-	if wkt, ok := v.Interface().(wkt); ok {
-		switch wkt.XXX_WellKnownType() {
-		case "NullValue":
-			out.write("null")
-			return out.err
-		}
-	}
-
-	// Handle enumerations.
-	if !m.EnumsAsInts && prop.Enum != "" {
-		// Unknown enum values will are stringified by the proto library as their
-		// value. Such values should _not_ be quoted or they will be interpreted
-		// as an enum string instead of their value.
-		enumStr := v.Interface().(fmt.Stringer).String()
-		var valStr string
-		if v.Kind() == reflect.Ptr {
-			valStr = strconv.Itoa(int(v.Elem().Int()))
-		} else {
-			valStr = strconv.Itoa(int(v.Int()))
-		}
-		isKnownEnum := enumStr != valStr
-		if isKnownEnum {
-			out.write(`"`)
-		}
-		out.write(enumStr)
-		if isKnownEnum {
-			out.write(`"`)
-		}
-		return out.err
-	}
-
-	// Handle nested messages.
-	if v.Kind() == reflect.Struct {
-		return m.marshalObject(out, v.Addr().Interface().(proto.Message), indent+m.Indent, "")
-	}
-
-	// Handle maps.
-	// Since Go randomizes map iteration, we sort keys for stable output.
-	if v.Kind() == reflect.Map {
-		out.write(`{`)
-		keys := v.MapKeys()
-		sort.Sort(mapKeys(keys))
-		for i, k := range keys {
-			if i > 0 {
-				out.write(`,`)
-			}
-			if m.Indent != "" {
-				out.write("\n")
-				out.write(indent)
-				out.write(m.Indent)
-				out.write(m.Indent)
-			}
-
-			b, err := json.Marshal(k.Interface())
-			if err != nil {
-				return err
-			}
-			s := string(b)
-
-			// If the JSON is not a string value, encode it again to make it one.
-			if !strings.HasPrefix(s, `"`) {
-				b, err := json.Marshal(s)
-				if err != nil {
-					return err
-				}
-				s = string(b)
-			}
-
-			out.write(s)
-			out.write(`:`)
-			if m.Indent != "" {
-				out.write(` `)
-			}
-
-			if err := m.marshalValue(out, prop, v.MapIndex(k), indent+m.Indent); err != nil {
-				return err
-			}
-		}
-		if m.Indent != "" {
-			out.write("\n")
-			out.write(indent)
-			out.write(m.Indent)
-		}
-		out.write(`}`)
-		return out.err
-	}
-
-	// Handle non-finite floats, e.g. NaN, Infinity and -Infinity.
-	if v.Kind() == reflect.Float32 || v.Kind() == reflect.Float64 {
-		f := v.Float()
-		var sval string
-		switch {
-		case math.IsInf(f, 1):
-			sval = `"Infinity"`
-		case math.IsInf(f, -1):
-			sval = `"-Infinity"`
-		case math.IsNaN(f):
-			sval = `"NaN"`
-		}
-		if sval != "" {
-			out.write(sval)
-			return out.err
-		}
-	}
-
-	// Default handling defers to the encoding/json library.
-	b, err := json.Marshal(v.Interface())
-	if err != nil {
-		return err
-	}
-	needToQuote := string(b[0]) != `"` && (v.Kind() == reflect.Int64 || v.Kind() == reflect.Uint64)
-	if needToQuote {
-		out.write(`"`)
-	}
-	out.write(string(b))
-	if needToQuote {
-		out.write(`"`)
-	}
-	return out.err
-}
-
-// Unmarshaler is a configurable object for converting from a JSON
-// representation to a protocol buffer object.
-type Unmarshaler struct {
-	// Whether to allow messages to contain unknown fields, as opposed to
-	// failing to unmarshal.
-	AllowUnknownFields bool
-
-	// A custom URL resolver to use when unmarshaling Any messages from JSON.
-	// If unset, the default resolution strategy is to extract the
-	// fully-qualified type name from the type URL and pass that to
-	// proto.MessageType(string).
-	AnyResolver AnyResolver
-}
-
-// UnmarshalNext unmarshals the next protocol buffer from a JSON object stream.
-// This function is lenient and will decode any options permutations of the
-// related Marshaler.
-func (u *Unmarshaler) UnmarshalNext(dec *json.Decoder, pb proto.Message) error {
-	inputValue := json.RawMessage{}
-	if err := dec.Decode(&inputValue); err != nil {
-		return err
-	}
-	if err := u.unmarshalValue(reflect.ValueOf(pb).Elem(), inputValue, nil); err != nil {
-		return err
-	}
-	return checkRequiredFields(pb)
-}
-
-// Unmarshal unmarshals a JSON object stream into a protocol
-// buffer. This function is lenient and will decode any options
-// permutations of the related Marshaler.
-func (u *Unmarshaler) Unmarshal(r io.Reader, pb proto.Message) error {
-	dec := json.NewDecoder(r)
-	return u.UnmarshalNext(dec, pb)
-}
-
-// UnmarshalNext unmarshals the next protocol buffer from a JSON object stream.
-// This function is lenient and will decode any options permutations of the
-// related Marshaler.
-func UnmarshalNext(dec *json.Decoder, pb proto.Message) error {
-	return new(Unmarshaler).UnmarshalNext(dec, pb)
-}
-
-// Unmarshal unmarshals a JSON object stream into a protocol
-// buffer. This function is lenient and will decode any options
-// permutations of the related Marshaler.
-func Unmarshal(r io.Reader, pb proto.Message) error {
-	return new(Unmarshaler).Unmarshal(r, pb)
-}
-
-// UnmarshalString will populate the fields of a protocol buffer based
-// on a JSON string. This function is lenient and will decode any options
-// permutations of the related Marshaler.
-func UnmarshalString(str string, pb proto.Message) error {
-	return new(Unmarshaler).Unmarshal(strings.NewReader(str), pb)
-}
-
-// unmarshalValue converts/copies a value into the target.
-// prop may be nil.
-func (u *Unmarshaler) unmarshalValue(target reflect.Value, inputValue json.RawMessage, prop *proto.Properties) error {
-	targetType := target.Type()
-
-	// Allocate memory for pointer fields.
-	if targetType.Kind() == reflect.Ptr {
-		// If input value is "null" and target is a pointer type, then the field should be treated as not set
-		// UNLESS the target is structpb.Value, in which case it should be set to structpb.NullValue.
-		_, isJSONPBUnmarshaler := target.Interface().(JSONPBUnmarshaler)
-		if string(inputValue) == "null" && targetType != reflect.TypeOf(&stpb.Value{}) && !isJSONPBUnmarshaler {
-			return nil
-		}
-		target.Set(reflect.New(targetType.Elem()))
-
-		return u.unmarshalValue(target.Elem(), inputValue, prop)
-	}
-
-	if jsu, ok := target.Addr().Interface().(JSONPBUnmarshaler); ok {
-		return jsu.UnmarshalJSONPB(u, []byte(inputValue))
-	}
-
-	// Handle well-known types that are not pointers.
-	if w, ok := target.Addr().Interface().(wkt); ok {
-		switch w.XXX_WellKnownType() {
-		case "DoubleValue", "FloatValue", "Int64Value", "UInt64Value",
-			"Int32Value", "UInt32Value", "BoolValue", "StringValue", "BytesValue":
-			return u.unmarshalValue(target.Field(0), inputValue, prop)
-		case "Any":
-			// Use json.RawMessage pointer type instead of value to support pre-1.8 version.
-			// 1.8 changed RawMessage.MarshalJSON from pointer type to value type, see
-			// https://github.com/golang/go/issues/14493
-			var jsonFields map[string]*json.RawMessage
-			if err := json.Unmarshal(inputValue, &jsonFields); err != nil {
-				return err
-			}
-
-			val, ok := jsonFields["@type"]
-			if !ok || val == nil {
-				return errors.New("Any JSON doesn't have '@type'")
-			}
-
-			var turl string
-			if err := json.Unmarshal([]byte(*val), &turl); err != nil {
-				return fmt.Errorf("can't unmarshal Any's '@type': %q", *val)
-			}
-			target.Field(0).SetString(turl)
-
-			var m proto.Message
-			var err error
-			if u.AnyResolver != nil {
-				m, err = u.AnyResolver.Resolve(turl)
-			} else {
-				m, err = defaultResolveAny(turl)
-			}
-			if err != nil {
-				return err
-			}
-
-			if _, ok := m.(wkt); ok {
-				val, ok := jsonFields["value"]
-				if !ok {
-					return errors.New("Any JSON doesn't have 'value'")
-				}
-
-				if err := u.unmarshalValue(reflect.ValueOf(m).Elem(), *val, nil); err != nil {
-					return fmt.Errorf("can't unmarshal Any nested proto %T: %v", m, err)
-				}
-			} else {
-				delete(jsonFields, "@type")
-				nestedProto, err := json.Marshal(jsonFields)
-				if err != nil {
-					return fmt.Errorf("can't generate JSON for Any's nested proto to be unmarshaled: %v", err)
-				}
-
-				if err = u.unmarshalValue(reflect.ValueOf(m).Elem(), nestedProto, nil); err != nil {
-					return fmt.Errorf("can't unmarshal Any nested proto %T: %v", m, err)
-				}
-			}
-
-			b, err := proto.Marshal(m)
-			if err != nil {
-				return fmt.Errorf("can't marshal proto %T into Any.Value: %v", m, err)
-			}
-			target.Field(1).SetBytes(b)
-
-			return nil
-		case "Duration":
-			unq, err := unquote(string(inputValue))
-			if err != nil {
-				return err
-			}
-
-			d, err := time.ParseDuration(unq)
-			if err != nil {
-				return fmt.Errorf("bad Duration: %v", err)
-			}
-
-			ns := d.Nanoseconds()
-			s := ns / 1e9
-			ns %= 1e9
-			target.Field(0).SetInt(s)
-			target.Field(1).SetInt(ns)
-			return nil
-		case "Timestamp":
-			unq, err := unquote(string(inputValue))
-			if err != nil {
-				return err
-			}
-
-			t, err := time.Parse(time.RFC3339Nano, unq)
-			if err != nil {
-				return fmt.Errorf("bad Timestamp: %v", err)
-			}
-
-			target.Field(0).SetInt(t.Unix())
-			target.Field(1).SetInt(int64(t.Nanosecond()))
-			return nil
-		case "Struct":
-			var m map[string]json.RawMessage
-			if err := json.Unmarshal(inputValue, &m); err != nil {
-				return fmt.Errorf("bad StructValue: %v", err)
-			}
-
-			target.Field(0).Set(reflect.ValueOf(map[string]*stpb.Value{}))
-			for k, jv := range m {
-				pv := &stpb.Value{}
-				if err := u.unmarshalValue(reflect.ValueOf(pv).Elem(), jv, prop); err != nil {
-					return fmt.Errorf("bad value in StructValue for key %q: %v", k, err)
-				}
-				target.Field(0).SetMapIndex(reflect.ValueOf(k), reflect.ValueOf(pv))
-			}
-			return nil
-		case "ListValue":
-			var s []json.RawMessage
-			if err := json.Unmarshal(inputValue, &s); err != nil {
-				return fmt.Errorf("bad ListValue: %v", err)
-			}
-
-			target.Field(0).Set(reflect.ValueOf(make([]*stpb.Value, len(s))))
-			for i, sv := range s {
-				if err := u.unmarshalValue(target.Field(0).Index(i), sv, prop); err != nil {
-					return err
-				}
-			}
-			return nil
-		case "Value":
-			ivStr := string(inputValue)
-			if ivStr == "null" {
-				target.Field(0).Set(reflect.ValueOf(&stpb.Value_NullValue{}))
-			} else if v, err := strconv.ParseFloat(ivStr, 0); err == nil {
-				target.Field(0).Set(reflect.ValueOf(&stpb.Value_NumberValue{v}))
-			} else if v, err := unquote(ivStr); err == nil {
-				target.Field(0).Set(reflect.ValueOf(&stpb.Value_StringValue{v}))
-			} else if v, err := strconv.ParseBool(ivStr); err == nil {
-				target.Field(0).Set(reflect.ValueOf(&stpb.Value_BoolValue{v}))
-			} else if err := json.Unmarshal(inputValue, &[]json.RawMessage{}); err == nil {
-				lv := &stpb.ListValue{}
-				target.Field(0).Set(reflect.ValueOf(&stpb.Value_ListValue{lv}))
-				return u.unmarshalValue(reflect.ValueOf(lv).Elem(), inputValue, prop)
-			} else if err := json.Unmarshal(inputValue, &map[string]json.RawMessage{}); err == nil {
-				sv := &stpb.Struct{}
-				target.Field(0).Set(reflect.ValueOf(&stpb.Value_StructValue{sv}))
-				return u.unmarshalValue(reflect.ValueOf(sv).Elem(), inputValue, prop)
-			} else {
-				return fmt.Errorf("unrecognized type for Value %q", ivStr)
-			}
-			return nil
-		}
-	}
-
-	// Handle enums, which have an underlying type of int32,
-	// and may appear as strings.
-	// The case of an enum appearing as a number is handled
-	// at the bottom of this function.
-	if inputValue[0] == '"' && prop != nil && prop.Enum != "" {
-		vmap := proto.EnumValueMap(prop.Enum)
-		// Don't need to do unquoting; valid enum names
-		// are from a limited character set.
-		s := inputValue[1 : len(inputValue)-1]
-		n, ok := vmap[string(s)]
-		if !ok {
-			return fmt.Errorf("unknown value %q for enum %s", s, prop.Enum)
-		}
-		if target.Kind() == reflect.Ptr { // proto2
-			target.Set(reflect.New(targetType.Elem()))
-			target = target.Elem()
-		}
-		if targetType.Kind() != reflect.Int32 {
-			return fmt.Errorf("invalid target %q for enum %s", targetType.Kind(), prop.Enum)
-		}
-		target.SetInt(int64(n))
-		return nil
-	}
-
-	// Handle nested messages.
-	if targetType.Kind() == reflect.Struct {
-		var jsonFields map[string]json.RawMessage
-		if err := json.Unmarshal(inputValue, &jsonFields); err != nil {
-			return err
-		}
-
-		consumeField := func(prop *proto.Properties) (json.RawMessage, bool) {
-			// Be liberal in what names we accept; both orig_name and camelName are okay.
-			fieldNames := acceptedJSONFieldNames(prop)
-
-			vOrig, okOrig := jsonFields[fieldNames.orig]
-			vCamel, okCamel := jsonFields[fieldNames.camel]
-			if !okOrig && !okCamel {
-				return nil, false
-			}
-			// If, for some reason, both are present in the data, favour the camelName.
-			var raw json.RawMessage
-			if okOrig {
-				raw = vOrig
-				delete(jsonFields, fieldNames.orig)
-			}
-			if okCamel {
-				raw = vCamel
-				delete(jsonFields, fieldNames.camel)
-			}
-			return raw, true
-		}
-
-		sprops := proto.GetProperties(targetType)
-		for i := 0; i < target.NumField(); i++ {
-			ft := target.Type().Field(i)
-			if strings.HasPrefix(ft.Name, "XXX_") {
-				continue
-			}
-
-			valueForField, ok := consumeField(sprops.Prop[i])
-			if !ok {
-				continue
-			}
-
-			if err := u.unmarshalValue(target.Field(i), valueForField, sprops.Prop[i]); err != nil {
-				return err
-			}
-		}
-		// Check for any oneof fields.
-		if len(jsonFields) > 0 {
-			for _, oop := range sprops.OneofTypes {
-				raw, ok := consumeField(oop.Prop)
-				if !ok {
-					continue
-				}
-				nv := reflect.New(oop.Type.Elem())
-				target.Field(oop.Field).Set(nv)
-				if err := u.unmarshalValue(nv.Elem().Field(0), raw, oop.Prop); err != nil {
-					return err
-				}
-			}
-		}
-		// Handle proto2 extensions.
-		if len(jsonFields) > 0 {
-			if ep, ok := target.Addr().Interface().(proto.Message); ok {
-				for _, ext := range proto.RegisteredExtensions(ep) {
-					name := fmt.Sprintf("[%s]", ext.Name)
-					raw, ok := jsonFields[name]
-					if !ok {
-						continue
-					}
-					delete(jsonFields, name)
-					nv := reflect.New(reflect.TypeOf(ext.ExtensionType).Elem())
-					if err := u.unmarshalValue(nv.Elem(), raw, nil); err != nil {
-						return err
-					}
-					if err := proto.SetExtension(ep, ext, nv.Interface()); err != nil {
-						return err
-					}
-				}
-			}
-		}
-		if !u.AllowUnknownFields && len(jsonFields) > 0 {
-			// Pick any field to be the scapegoat.
-			var f string
-			for fname := range jsonFields {
-				f = fname
-				break
-			}
-			return fmt.Errorf("unknown field %q in %v", f, targetType)
-		}
-		return nil
-	}
-
-	// Handle arrays (which aren't encoded bytes)
-	if targetType.Kind() == reflect.Slice && targetType.Elem().Kind() != reflect.Uint8 {
-		var slc []json.RawMessage
-		if err := json.Unmarshal(inputValue, &slc); err != nil {
-			return err
-		}
-		if slc != nil {
-			l := len(slc)
-			target.Set(reflect.MakeSlice(targetType, l, l))
-			for i := 0; i < l; i++ {
-				if err := u.unmarshalValue(target.Index(i), slc[i], prop); err != nil {
-					return err
-				}
-			}
-		}
-		return nil
-	}
-
-	// Handle maps (whose keys are always strings)
-	if targetType.Kind() == reflect.Map {
-		var mp map[string]json.RawMessage
-		if err := json.Unmarshal(inputValue, &mp); err != nil {
-			return err
-		}
-		if mp != nil {
-			target.Set(reflect.MakeMap(targetType))
-			for ks, raw := range mp {
-				// Unmarshal map key. The core json library already decoded the key into a
-				// string, so we handle that specially. Other types were quoted post-serialization.
-				var k reflect.Value
-				if targetType.Key().Kind() == reflect.String {
-					k = reflect.ValueOf(ks)
-				} else {
-					k = reflect.New(targetType.Key()).Elem()
-					// TODO: pass the correct Properties if needed.
-					if err := u.unmarshalValue(k, json.RawMessage(ks), nil); err != nil {
-						return err
-					}
-				}
-
-				// Unmarshal map value.
-				v := reflect.New(targetType.Elem()).Elem()
-				// TODO: pass the correct Properties if needed.
-				if err := u.unmarshalValue(v, raw, nil); err != nil {
-					return err
-				}
-				target.SetMapIndex(k, v)
-			}
-		}
-		return nil
-	}
-
-	// 64-bit integers can be encoded as strings. In this case we drop
-	// the quotes and proceed as normal.
-	isNum := targetType.Kind() == reflect.Int64 || targetType.Kind() == reflect.Uint64
-	if isNum && strings.HasPrefix(string(inputValue), `"`) {
-		inputValue = inputValue[1 : len(inputValue)-1]
-	}
-
-	// Non-finite numbers can be encoded as strings.
-	isFloat := targetType.Kind() == reflect.Float32 || targetType.Kind() == reflect.Float64
-	if isFloat {
-		if num, ok := nonFinite[string(inputValue)]; ok {
-			target.SetFloat(num)
-			return nil
-		}
-	}
-
-	// Use the encoding/json for parsing other value types.
-	return json.Unmarshal(inputValue, target.Addr().Interface())
-}
-
-func unquote(s string) (string, error) {
-	var ret string
-	err := json.Unmarshal([]byte(s), &ret)
-	return ret, err
-}
-
-// jsonProperties returns parsed proto.Properties for the field and corrects JSONName attribute.
-func jsonProperties(f reflect.StructField, origName bool) *proto.Properties {
-	var prop proto.Properties
-	prop.Init(f.Type, f.Name, f.Tag.Get("protobuf"), &f)
-	if origName || prop.JSONName == "" {
-		prop.JSONName = prop.OrigName
-	}
-	return &prop
-}
-
-type fieldNames struct {
-	orig, camel string
-}
-
-func acceptedJSONFieldNames(prop *proto.Properties) fieldNames {
-	opts := fieldNames{orig: prop.OrigName, camel: prop.OrigName}
-	if prop.JSONName != "" {
-		opts.camel = prop.JSONName
-	}
-	return opts
-}
-
-// Writer wrapper inspired by https://blog.golang.org/errors-are-values
-type errWriter struct {
-	writer io.Writer
-	err    error
-}
-
-func (w *errWriter) write(str string) {
-	if w.err != nil {
-		return
-	}
-	_, w.err = w.writer.Write([]byte(str))
-}
-
-// Map fields may have key types of non-float scalars, strings and enums.
-// The easiest way to sort them in some deterministic order is to use fmt.
-// If this turns out to be inefficient we can always consider other options,
-// such as doing a Schwartzian transform.
-//
-// Numeric keys are sorted in numeric order per
-// https://developers.google.com/protocol-buffers/docs/proto#maps.
-type mapKeys []reflect.Value
-
-func (s mapKeys) Len() int      { return len(s) }
-func (s mapKeys) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
-func (s mapKeys) Less(i, j int) bool {
-	if k := s[i].Kind(); k == s[j].Kind() {
-		switch k {
-		case reflect.Int32, reflect.Int64:
-			return s[i].Int() < s[j].Int()
-		case reflect.Uint32, reflect.Uint64:
-			return s[i].Uint() < s[j].Uint()
-		}
-	}
-	return fmt.Sprint(s[i].Interface()) < fmt.Sprint(s[j].Interface())
-}
-
-// checkRequiredFields returns an error if any required field in the given proto message is not set.
-// This function is used by both Marshal and Unmarshal.  While required fields only exist in a
-// proto2 message, a proto3 message can contain proto2 message(s).
-func checkRequiredFields(pb proto.Message) error {
-	// Most well-known type messages do not contain required fields.  The "Any" type may contain
-	// a message that has required fields.
-	//
-	// When an Any message is being marshaled, the code will invoked proto.Unmarshal on Any.Value
-	// field in order to transform that into JSON, and that should have returned an error if a
-	// required field is not set in the embedded message.
-	//
-	// When an Any message is being unmarshaled, the code will have invoked proto.Marshal on the
-	// embedded message to store the serialized message in Any.Value field, and that should have
-	// returned an error if a required field is not set.
-	if _, ok := pb.(wkt); ok {
-		return nil
-	}
-
-	v := reflect.ValueOf(pb)
-	// Skip message if it is not a struct pointer.
-	if v.Kind() != reflect.Ptr {
-		return nil
-	}
-	v = v.Elem()
-	if v.Kind() != reflect.Struct {
-		return nil
-	}
-
-	for i := 0; i < v.NumField(); i++ {
-		field := v.Field(i)
-		sfield := v.Type().Field(i)
-
-		if sfield.PkgPath != "" {
-			// blank PkgPath means the field is exported; skip if not exported
-			continue
-		}
-
-		if strings.HasPrefix(sfield.Name, "XXX_") {
-			continue
-		}
-
-		// Oneof field is an interface implemented by wrapper structs containing the actual oneof
-		// field, i.e. an interface containing &T{real_value}.
-		if sfield.Tag.Get("protobuf_oneof") != "" {
-			if field.Kind() != reflect.Interface {
-				continue
-			}
-			v := field.Elem()
-			if v.Kind() != reflect.Ptr || v.IsNil() {
-				continue
-			}
-			v = v.Elem()
-			if v.Kind() != reflect.Struct || v.NumField() < 1 {
-				continue
-			}
-			field = v.Field(0)
-			sfield = v.Type().Field(0)
-		}
-
-		protoTag := sfield.Tag.Get("protobuf")
-		if protoTag == "" {
-			continue
-		}
-		var prop proto.Properties
-		prop.Init(sfield.Type, sfield.Name, protoTag, &sfield)
-
-		switch field.Kind() {
-		case reflect.Map:
-			if field.IsNil() {
-				continue
-			}
-			// Check each map value.
-			keys := field.MapKeys()
-			for _, k := range keys {
-				v := field.MapIndex(k)
-				if err := checkRequiredFieldsInValue(v); err != nil {
-					return err
-				}
-			}
-		case reflect.Slice:
-			// Handle non-repeated type, e.g. bytes.
-			if !prop.Repeated {
-				if prop.Required && field.IsNil() {
-					return fmt.Errorf("required field %q is not set", prop.Name)
-				}
-				continue
-			}
-
-			// Handle repeated type.
-			if field.IsNil() {
-				continue
-			}
-			// Check each slice item.
-			for i := 0; i < field.Len(); i++ {
-				v := field.Index(i)
-				if err := checkRequiredFieldsInValue(v); err != nil {
-					return err
-				}
-			}
-		case reflect.Ptr:
-			if field.IsNil() {
-				if prop.Required {
-					return fmt.Errorf("required field %q is not set", prop.Name)
-				}
-				continue
-			}
-			if err := checkRequiredFieldsInValue(field); err != nil {
-				return err
-			}
-		}
-	}
-
-	// Handle proto2 extensions.
-	for _, ext := range proto.RegisteredExtensions(pb) {
-		if !proto.HasExtension(pb, ext) {
-			continue
-		}
-		ep, err := proto.GetExtension(pb, ext)
-		if err != nil {
-			return err
-		}
-		err = checkRequiredFieldsInValue(reflect.ValueOf(ep))
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func checkRequiredFieldsInValue(v reflect.Value) error {
-	if pm, ok := v.Interface().(proto.Message); ok {
-		return checkRequiredFields(pm)
-	}
-	return nil
-}
diff --git a/vendor/github.com/golang/protobuf/jsonpb/jsonpb_test_proto/more_test_objects.proto b/vendor/github.com/golang/protobuf/jsonpb/jsonpb_test_proto/more_test_objects.proto
deleted file mode 100644
index d254fa5fa..000000000
--- a/vendor/github.com/golang/protobuf/jsonpb/jsonpb_test_proto/more_test_objects.proto
+++ /dev/null
@@ -1,69 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2015 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto3";
-
-package jsonpb;
-
-message Simple3 {
-  double dub = 1;
-}
-
-message SimpleSlice3 {
-  repeated string slices = 1;
-}
-
-message SimpleMap3 {
-  map<string,string> stringy = 1;
-}
-
-message SimpleNull3 {
-  Simple3 simple = 1;
-}
-
-enum Numeral {
-  UNKNOWN = 0;
-  ARABIC = 1;
-  ROMAN = 2;
-}
-
-message Mappy {
-  map<int64, int32> nummy = 1;
-  map<string, string> strry = 2;
-  map<int32, Simple3> objjy = 3;
-  map<int64, string> buggy = 4;
-  map<bool, bool> booly = 5;
-  map<string, Numeral> enumy = 6;
-  map<int32, bool> s32booly = 7;
-  map<int64, bool> s64booly = 8;
-  map<uint32, bool> u32booly = 9;
-  map<uint64, bool> u64booly = 10;
-}
diff --git a/vendor/github.com/golang/protobuf/proto/Makefile b/vendor/github.com/golang/protobuf/proto/Makefile
deleted file mode 100644
index e2e0651a9..000000000
--- a/vendor/github.com/golang/protobuf/proto/Makefile
+++ /dev/null
@@ -1,43 +0,0 @@
-# Go support for Protocol Buffers - Google's data interchange format
-#
-# Copyright 2010 The Go Authors.  All rights reserved.
-# https://github.com/golang/protobuf
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-#     * Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above
-# copyright notice, this list of conditions and the following disclaimer
-# in the documentation and/or other materials provided with the
-# distribution.
-#     * Neither the name of Google Inc. nor the names of its
-# contributors may be used to endorse or promote products derived from
-# this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-install:
-	go install
-
-test: install generate-test-pbs
-	go test
-
-
-generate-test-pbs:
-	make install
-	make -C testdata
-	protoc --go_out=Mtestdata/test.proto=github.com/golang/protobuf/proto/testdata,Mgoogle/protobuf/any.proto=github.com/golang/protobuf/ptypes/any:. proto3_proto/proto3.proto
-	make
diff --git a/vendor/github.com/golang/protobuf/proto/all_test.go b/vendor/github.com/golang/protobuf/proto/all_test.go
deleted file mode 100644
index 361f72fbd..000000000
--- a/vendor/github.com/golang/protobuf/proto/all_test.go
+++ /dev/null
@@ -1,2410 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package proto_test
-
-import (
-	"bytes"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"math"
-	"math/rand"
-	"reflect"
-	"runtime/debug"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-
-	. "github.com/golang/protobuf/proto"
-	. "github.com/golang/protobuf/proto/test_proto"
-)
-
-var globalO *Buffer
-
-func old() *Buffer {
-	if globalO == nil {
-		globalO = NewBuffer(nil)
-	}
-	globalO.Reset()
-	return globalO
-}
-
-func equalbytes(b1, b2 []byte, t *testing.T) {
-	if len(b1) != len(b2) {
-		t.Errorf("wrong lengths: 2*%d != %d", len(b1), len(b2))
-		return
-	}
-	for i := 0; i < len(b1); i++ {
-		if b1[i] != b2[i] {
-			t.Errorf("bad byte[%d]:%x %x: %s %s", i, b1[i], b2[i], b1, b2)
-		}
-	}
-}
-
-func initGoTestField() *GoTestField {
-	f := new(GoTestField)
-	f.Label = String("label")
-	f.Type = String("type")
-	return f
-}
-
-// These are all structurally equivalent but the tag numbers differ.
-// (It's remarkable that required, optional, and repeated all have
-// 8 letters.)
-func initGoTest_RequiredGroup() *GoTest_RequiredGroup {
-	return &GoTest_RequiredGroup{
-		RequiredField: String("required"),
-	}
-}
-
-func initGoTest_OptionalGroup() *GoTest_OptionalGroup {
-	return &GoTest_OptionalGroup{
-		RequiredField: String("optional"),
-	}
-}
-
-func initGoTest_RepeatedGroup() *GoTest_RepeatedGroup {
-	return &GoTest_RepeatedGroup{
-		RequiredField: String("repeated"),
-	}
-}
-
-func initGoTest(setdefaults bool) *GoTest {
-	pb := new(GoTest)
-	if setdefaults {
-		pb.F_BoolDefaulted = Bool(Default_GoTest_F_BoolDefaulted)
-		pb.F_Int32Defaulted = Int32(Default_GoTest_F_Int32Defaulted)
-		pb.F_Int64Defaulted = Int64(Default_GoTest_F_Int64Defaulted)
-		pb.F_Fixed32Defaulted = Uint32(Default_GoTest_F_Fixed32Defaulted)
-		pb.F_Fixed64Defaulted = Uint64(Default_GoTest_F_Fixed64Defaulted)
-		pb.F_Uint32Defaulted = Uint32(Default_GoTest_F_Uint32Defaulted)
-		pb.F_Uint64Defaulted = Uint64(Default_GoTest_F_Uint64Defaulted)
-		pb.F_FloatDefaulted = Float32(Default_GoTest_F_FloatDefaulted)
-		pb.F_DoubleDefaulted = Float64(Default_GoTest_F_DoubleDefaulted)
-		pb.F_StringDefaulted = String(Default_GoTest_F_StringDefaulted)
-		pb.F_BytesDefaulted = Default_GoTest_F_BytesDefaulted
-		pb.F_Sint32Defaulted = Int32(Default_GoTest_F_Sint32Defaulted)
-		pb.F_Sint64Defaulted = Int64(Default_GoTest_F_Sint64Defaulted)
-		pb.F_Sfixed32Defaulted = Int32(Default_GoTest_F_Sfixed32Defaulted)
-		pb.F_Sfixed64Defaulted = Int64(Default_GoTest_F_Sfixed64Defaulted)
-	}
-
-	pb.Kind = GoTest_TIME.Enum()
-	pb.RequiredField = initGoTestField()
-	pb.F_BoolRequired = Bool(true)
-	pb.F_Int32Required = Int32(3)
-	pb.F_Int64Required = Int64(6)
-	pb.F_Fixed32Required = Uint32(32)
-	pb.F_Fixed64Required = Uint64(64)
-	pb.F_Uint32Required = Uint32(3232)
-	pb.F_Uint64Required = Uint64(6464)
-	pb.F_FloatRequired = Float32(3232)
-	pb.F_DoubleRequired = Float64(6464)
-	pb.F_StringRequired = String("string")
-	pb.F_BytesRequired = []byte("bytes")
-	pb.F_Sint32Required = Int32(-32)
-	pb.F_Sint64Required = Int64(-64)
-	pb.F_Sfixed32Required = Int32(-32)
-	pb.F_Sfixed64Required = Int64(-64)
-	pb.Requiredgroup = initGoTest_RequiredGroup()
-
-	return pb
-}
-
-func hex(c uint8) uint8 {
-	if '0' <= c && c <= '9' {
-		return c - '0'
-	}
-	if 'a' <= c && c <= 'f' {
-		return 10 + c - 'a'
-	}
-	if 'A' <= c && c <= 'F' {
-		return 10 + c - 'A'
-	}
-	return 0
-}
-
-func equal(b []byte, s string, t *testing.T) bool {
-	if 2*len(b) != len(s) {
-		//		fail(fmt.Sprintf("wrong lengths: 2*%d != %d", len(b), len(s)), b, s, t)
-		fmt.Printf("wrong lengths: 2*%d != %d\n", len(b), len(s))
-		return false
-	}
-	for i, j := 0, 0; i < len(b); i, j = i+1, j+2 {
-		x := hex(s[j])*16 + hex(s[j+1])
-		if b[i] != x {
-			//			fail(fmt.Sprintf("bad byte[%d]:%x %x", i, b[i], x), b, s, t)
-			fmt.Printf("bad byte[%d]:%x %x", i, b[i], x)
-			return false
-		}
-	}
-	return true
-}
-
-func overify(t *testing.T, pb *GoTest, expected string) {
-	o := old()
-	err := o.Marshal(pb)
-	if err != nil {
-		fmt.Printf("overify marshal-1 err = %v", err)
-		o.DebugPrint("", o.Bytes())
-		t.Fatalf("expected = %s", expected)
-	}
-	if !equal(o.Bytes(), expected, t) {
-		o.DebugPrint("overify neq 1", o.Bytes())
-		t.Fatalf("expected = %s", expected)
-	}
-
-	// Now test Unmarshal by recreating the original buffer.
-	pbd := new(GoTest)
-	err = o.Unmarshal(pbd)
-	if err != nil {
-		t.Fatalf("overify unmarshal err = %v", err)
-		o.DebugPrint("", o.Bytes())
-		t.Fatalf("string = %s", expected)
-	}
-	o.Reset()
-	err = o.Marshal(pbd)
-	if err != nil {
-		t.Errorf("overify marshal-2 err = %v", err)
-		o.DebugPrint("", o.Bytes())
-		t.Fatalf("string = %s", expected)
-	}
-	if !equal(o.Bytes(), expected, t) {
-		o.DebugPrint("overify neq 2", o.Bytes())
-		t.Fatalf("string = %s", expected)
-	}
-}
-
-// Simple tests for numeric encode/decode primitives (varint, etc.)
-func TestNumericPrimitives(t *testing.T) {
-	for i := uint64(0); i < 1e6; i += 111 {
-		o := old()
-		if o.EncodeVarint(i) != nil {
-			t.Error("EncodeVarint")
-			break
-		}
-		x, e := o.DecodeVarint()
-		if e != nil {
-			t.Fatal("DecodeVarint")
-		}
-		if x != i {
-			t.Fatal("varint decode fail:", i, x)
-		}
-
-		o = old()
-		if o.EncodeFixed32(i) != nil {
-			t.Fatal("encFixed32")
-		}
-		x, e = o.DecodeFixed32()
-		if e != nil {
-			t.Fatal("decFixed32")
-		}
-		if x != i {
-			t.Fatal("fixed32 decode fail:", i, x)
-		}
-
-		o = old()
-		if o.EncodeFixed64(i*1234567) != nil {
-			t.Error("encFixed64")
-			break
-		}
-		x, e = o.DecodeFixed64()
-		if e != nil {
-			t.Error("decFixed64")
-			break
-		}
-		if x != i*1234567 {
-			t.Error("fixed64 decode fail:", i*1234567, x)
-			break
-		}
-
-		o = old()
-		i32 := int32(i - 12345)
-		if o.EncodeZigzag32(uint64(i32)) != nil {
-			t.Fatal("EncodeZigzag32")
-		}
-		x, e = o.DecodeZigzag32()
-		if e != nil {
-			t.Fatal("DecodeZigzag32")
-		}
-		if x != uint64(uint32(i32)) {
-			t.Fatal("zigzag32 decode fail:", i32, x)
-		}
-
-		o = old()
-		i64 := int64(i - 12345)
-		if o.EncodeZigzag64(uint64(i64)) != nil {
-			t.Fatal("EncodeZigzag64")
-		}
-		x, e = o.DecodeZigzag64()
-		if e != nil {
-			t.Fatal("DecodeZigzag64")
-		}
-		if x != uint64(i64) {
-			t.Fatal("zigzag64 decode fail:", i64, x)
-		}
-	}
-}
-
-// fakeMarshaler is a simple struct implementing Marshaler and Message interfaces.
-type fakeMarshaler struct {
-	b   []byte
-	err error
-}
-
-func (f *fakeMarshaler) Marshal() ([]byte, error) { return f.b, f.err }
-func (f *fakeMarshaler) String() string           { return fmt.Sprintf("Bytes: %v Error: %v", f.b, f.err) }
-func (f *fakeMarshaler) ProtoMessage()            {}
-func (f *fakeMarshaler) Reset()                   {}
-
-type msgWithFakeMarshaler struct {
-	M *fakeMarshaler `protobuf:"bytes,1,opt,name=fake"`
-}
-
-func (m *msgWithFakeMarshaler) String() string { return CompactTextString(m) }
-func (m *msgWithFakeMarshaler) ProtoMessage()  {}
-func (m *msgWithFakeMarshaler) Reset()         {}
-
-// Simple tests for proto messages that implement the Marshaler interface.
-func TestMarshalerEncoding(t *testing.T) {
-	tests := []struct {
-		name    string
-		m       Message
-		want    []byte
-		errType reflect.Type
-	}{
-		{
-			name: "Marshaler that fails",
-			m: &fakeMarshaler{
-				err: errors.New("some marshal err"),
-				b:   []byte{5, 6, 7},
-			},
-			// Since the Marshal method returned bytes, they should be written to the
-			// buffer.  (For efficiency, we assume that Marshal implementations are
-			// always correct w.r.t. RequiredNotSetError and output.)
-			want:    []byte{5, 6, 7},
-			errType: reflect.TypeOf(errors.New("some marshal err")),
-		},
-		{
-			name: "Marshaler that fails with RequiredNotSetError",
-			m: &msgWithFakeMarshaler{
-				M: &fakeMarshaler{
-					err: &RequiredNotSetError{},
-					b:   []byte{5, 6, 7},
-				},
-			},
-			// Since there's an error that can be continued after,
-			// the buffer should be written.
-			want: []byte{
-				10, 3, // for &msgWithFakeMarshaler
-				5, 6, 7, // for &fakeMarshaler
-			},
-			errType: reflect.TypeOf(&RequiredNotSetError{}),
-		},
-		{
-			name: "Marshaler that succeeds",
-			m: &fakeMarshaler{
-				b: []byte{0, 1, 2, 3, 4, 127, 255},
-			},
-			want: []byte{0, 1, 2, 3, 4, 127, 255},
-		},
-	}
-	for _, test := range tests {
-		b := NewBuffer(nil)
-		err := b.Marshal(test.m)
-		if reflect.TypeOf(err) != test.errType {
-			t.Errorf("%s: got err %T(%v) wanted %T", test.name, err, err, test.errType)
-		}
-		if !reflect.DeepEqual(test.want, b.Bytes()) {
-			t.Errorf("%s: got bytes %v wanted %v", test.name, b.Bytes(), test.want)
-		}
-		if size := Size(test.m); size != len(b.Bytes()) {
-			t.Errorf("%s: Size(_) = %v, but marshaled to %v bytes", test.name, size, len(b.Bytes()))
-		}
-
-		m, mErr := Marshal(test.m)
-		if !bytes.Equal(b.Bytes(), m) {
-			t.Errorf("%s: Marshal returned %v, but (*Buffer).Marshal wrote %v", test.name, m, b.Bytes())
-		}
-		if !reflect.DeepEqual(err, mErr) {
-			t.Errorf("%s: Marshal err = %q, but (*Buffer).Marshal returned %q",
-				test.name, fmt.Sprint(mErr), fmt.Sprint(err))
-		}
-	}
-}
-
-// Ensure that Buffer.Marshal uses O(N) memory for N messages
-func TestBufferMarshalAllocs(t *testing.T) {
-	value := &OtherMessage{Key: Int64(1)}
-	msg := &MyMessage{Count: Int32(1), Others: []*OtherMessage{value}}
-
-	reallocSize := func(t *testing.T, items int, prealloc int) (int64, int64) {
-		var b Buffer
-		b.SetBuf(make([]byte, 0, prealloc))
-
-		var allocSpace int64
-		prevCap := cap(b.Bytes())
-		for i := 0; i < items; i++ {
-			err := b.Marshal(msg)
-			if err != nil {
-				t.Errorf("Marshal err = %q", err)
-				break
-			}
-			if c := cap(b.Bytes()); prevCap != c {
-				allocSpace += int64(c)
-				prevCap = c
-			}
-		}
-		needSpace := int64(len(b.Bytes()))
-		return allocSpace, needSpace
-	}
-
-	for _, prealloc := range []int{0, 100, 10000} {
-		for _, items := range []int{1, 2, 5, 10, 20, 50, 100, 200, 500, 1000} {
-			runtimeSpace, need := reallocSize(t, items, prealloc)
-			totalSpace := int64(prealloc) + runtimeSpace
-
-			runtimeRatio := float64(runtimeSpace) / float64(need)
-			totalRatio := float64(totalSpace) / float64(need)
-
-			if totalRatio < 1 || runtimeRatio > 4 {
-				t.Errorf("needed %dB, allocated %dB total (ratio %.1f), allocated %dB at runtime (ratio %.1f)",
-					need, totalSpace, totalRatio, runtimeSpace, runtimeRatio)
-			}
-		}
-	}
-}
-
-// Simple tests for bytes
-func TestBytesPrimitives(t *testing.T) {
-	o := old()
-	bytes := []byte{'n', 'o', 'w', ' ', 'i', 's', ' ', 't', 'h', 'e', ' ', 't', 'i', 'm', 'e'}
-	if o.EncodeRawBytes(bytes) != nil {
-		t.Error("EncodeRawBytes")
-	}
-	decb, e := o.DecodeRawBytes(false)
-	if e != nil {
-		t.Error("DecodeRawBytes")
-	}
-	equalbytes(bytes, decb, t)
-}
-
-// Simple tests for strings
-func TestStringPrimitives(t *testing.T) {
-	o := old()
-	s := "now is the time"
-	if o.EncodeStringBytes(s) != nil {
-		t.Error("enc_string")
-	}
-	decs, e := o.DecodeStringBytes()
-	if e != nil {
-		t.Error("dec_string")
-	}
-	if s != decs {
-		t.Error("string encode/decode fail:", s, decs)
-	}
-}
-
-// Do we catch the "required bit not set" case?
-func TestRequiredBit(t *testing.T) {
-	o := old()
-	pb := new(GoTest)
-	err := o.Marshal(pb)
-	if err == nil {
-		t.Error("did not catch missing required fields")
-	} else if !strings.Contains(err.Error(), "Kind") {
-		t.Error("wrong error type:", err)
-	}
-}
-
-// Check that all fields are nil.
-// Clearly silly, and a residue from a more interesting test with an earlier,
-// different initialization property, but it once caught a compiler bug so
-// it lives.
-func checkInitialized(pb *GoTest, t *testing.T) {
-	if pb.F_BoolDefaulted != nil {
-		t.Error("New or Reset did not set boolean:", *pb.F_BoolDefaulted)
-	}
-	if pb.F_Int32Defaulted != nil {
-		t.Error("New or Reset did not set int32:", *pb.F_Int32Defaulted)
-	}
-	if pb.F_Int64Defaulted != nil {
-		t.Error("New or Reset did not set int64:", *pb.F_Int64Defaulted)
-	}
-	if pb.F_Fixed32Defaulted != nil {
-		t.Error("New or Reset did not set fixed32:", *pb.F_Fixed32Defaulted)
-	}
-	if pb.F_Fixed64Defaulted != nil {
-		t.Error("New or Reset did not set fixed64:", *pb.F_Fixed64Defaulted)
-	}
-	if pb.F_Uint32Defaulted != nil {
-		t.Error("New or Reset did not set uint32:", *pb.F_Uint32Defaulted)
-	}
-	if pb.F_Uint64Defaulted != nil {
-		t.Error("New or Reset did not set uint64:", *pb.F_Uint64Defaulted)
-	}
-	if pb.F_FloatDefaulted != nil {
-		t.Error("New or Reset did not set float:", *pb.F_FloatDefaulted)
-	}
-	if pb.F_DoubleDefaulted != nil {
-		t.Error("New or Reset did not set double:", *pb.F_DoubleDefaulted)
-	}
-	if pb.F_StringDefaulted != nil {
-		t.Error("New or Reset did not set string:", *pb.F_StringDefaulted)
-	}
-	if pb.F_BytesDefaulted != nil {
-		t.Error("New or Reset did not set bytes:", string(pb.F_BytesDefaulted))
-	}
-	if pb.F_Sint32Defaulted != nil {
-		t.Error("New or Reset did not set int32:", *pb.F_Sint32Defaulted)
-	}
-	if pb.F_Sint64Defaulted != nil {
-		t.Error("New or Reset did not set int64:", *pb.F_Sint64Defaulted)
-	}
-}
-
-// Does Reset() reset?
-func TestReset(t *testing.T) {
-	pb := initGoTest(true)
-	// muck with some values
-	pb.F_BoolDefaulted = Bool(false)
-	pb.F_Int32Defaulted = Int32(237)
-	pb.F_Int64Defaulted = Int64(12346)
-	pb.F_Fixed32Defaulted = Uint32(32000)
-	pb.F_Fixed64Defaulted = Uint64(666)
-	pb.F_Uint32Defaulted = Uint32(323232)
-	pb.F_Uint64Defaulted = nil
-	pb.F_FloatDefaulted = nil
-	pb.F_DoubleDefaulted = Float64(0)
-	pb.F_StringDefaulted = String("gotcha")
-	pb.F_BytesDefaulted = []byte("asdfasdf")
-	pb.F_Sint32Defaulted = Int32(123)
-	pb.F_Sint64Defaulted = Int64(789)
-	pb.Reset()
-	checkInitialized(pb, t)
-}
-
-// All required fields set, no defaults provided.
-func TestEncodeDecode1(t *testing.T) {
-	pb := initGoTest(false)
-	overify(t, pb,
-		"0807"+ // field 1, encoding 0, value 7
-			"220d"+"0a056c6162656c120474797065"+ // field 4, encoding 2 (GoTestField)
-			"5001"+ // field 10, encoding 0, value 1
-			"5803"+ // field 11, encoding 0, value 3
-			"6006"+ // field 12, encoding 0, value 6
-			"6d20000000"+ // field 13, encoding 5, value 0x20
-			"714000000000000000"+ // field 14, encoding 1, value 0x40
-			"78a019"+ // field 15, encoding 0, value 0xca0 = 3232
-			"8001c032"+ // field 16, encoding 0, value 0x1940 = 6464
-			"8d0100004a45"+ // field 17, encoding 5, value 3232.0
-			"9101000000000040b940"+ // field 18, encoding 1, value 6464.0
-			"9a0106"+"737472696e67"+ // field 19, encoding 2, string "string"
-			"b304"+ // field 70, encoding 3, start group
-			"ba0408"+"7265717569726564"+ // field 71, encoding 2, string "required"
-			"b404"+ // field 70, encoding 4, end group
-			"aa0605"+"6279746573"+ // field 101, encoding 2, string "bytes"
-			"b0063f"+ // field 102, encoding 0, 0x3f zigzag32
-			"b8067f"+ // field 103, encoding 0, 0x7f zigzag64
-			"c506e0ffffff"+ // field 104, encoding 5, -32 fixed32
-			"c906c0ffffffffffffff") // field 105, encoding 1, -64 fixed64
-}
-
-// All required fields set, defaults provided.
-func TestEncodeDecode2(t *testing.T) {
-	pb := initGoTest(true)
-	overify(t, pb,
-		"0807"+ // field 1, encoding 0, value 7
-			"220d"+"0a056c6162656c120474797065"+ // field 4, encoding 2 (GoTestField)
-			"5001"+ // field 10, encoding 0, value 1
-			"5803"+ // field 11, encoding 0, value 3
-			"6006"+ // field 12, encoding 0, value 6
-			"6d20000000"+ // field 13, encoding 5, value 32
-			"714000000000000000"+ // field 14, encoding 1, value 64
-			"78a019"+ // field 15, encoding 0, value 3232
-			"8001c032"+ // field 16, encoding 0, value 6464
-			"8d0100004a45"+ // field 17, encoding 5, value 3232.0
-			"9101000000000040b940"+ // field 18, encoding 1, value 6464.0
-			"9a0106"+"737472696e67"+ // field 19, encoding 2 string "string"
-			"c00201"+ // field 40, encoding 0, value 1
-			"c80220"+ // field 41, encoding 0, value 32
-			"d00240"+ // field 42, encoding 0, value 64
-			"dd0240010000"+ // field 43, encoding 5, value 320
-			"e1028002000000000000"+ // field 44, encoding 1, value 640
-			"e8028019"+ // field 45, encoding 0, value 3200
-			"f0028032"+ // field 46, encoding 0, value 6400
-			"fd02e0659948"+ // field 47, encoding 5, value 314159.0
-			"81030000000050971041"+ // field 48, encoding 1, value 271828.0
-			"8a0310"+"68656c6c6f2c2022776f726c6421220a"+ // field 49, encoding 2 string "hello, \"world!\"\n"
-			"b304"+ // start group field 70 level 1
-			"ba0408"+"7265717569726564"+ // field 71, encoding 2, string "required"
-			"b404"+ // end group field 70 level 1
-			"aa0605"+"6279746573"+ // field 101, encoding 2 string "bytes"
-			"b0063f"+ // field 102, encoding 0, 0x3f zigzag32
-			"b8067f"+ // field 103, encoding 0, 0x7f zigzag64
-			"c506e0ffffff"+ // field 104, encoding 5, -32 fixed32
-			"c906c0ffffffffffffff"+ // field 105, encoding 1, -64 fixed64
-			"8a1907"+"4269676e6f7365"+ // field 401, encoding 2, string "Bignose"
-			"90193f"+ // field 402, encoding 0, value 63
-			"98197f"+ // field 403, encoding 0, value 127
-			"a519e0ffffff"+ // field 404, encoding 5, -32 fixed32
-			"a919c0ffffffffffffff") // field 405, encoding 1, -64 fixed64
-
-}
-
-// All default fields set to their default value by hand
-func TestEncodeDecode3(t *testing.T) {
-	pb := initGoTest(false)
-	pb.F_BoolDefaulted = Bool(true)
-	pb.F_Int32Defaulted = Int32(32)
-	pb.F_Int64Defaulted = Int64(64)
-	pb.F_Fixed32Defaulted = Uint32(320)
-	pb.F_Fixed64Defaulted = Uint64(640)
-	pb.F_Uint32Defaulted = Uint32(3200)
-	pb.F_Uint64Defaulted = Uint64(6400)
-	pb.F_FloatDefaulted = Float32(314159)
-	pb.F_DoubleDefaulted = Float64(271828)
-	pb.F_StringDefaulted = String("hello, \"world!\"\n")
-	pb.F_BytesDefaulted = []byte("Bignose")
-	pb.F_Sint32Defaulted = Int32(-32)
-	pb.F_Sint64Defaulted = Int64(-64)
-	pb.F_Sfixed32Defaulted = Int32(-32)
-	pb.F_Sfixed64Defaulted = Int64(-64)
-
-	overify(t, pb,
-		"0807"+ // field 1, encoding 0, value 7
-			"220d"+"0a056c6162656c120474797065"+ // field 4, encoding 2 (GoTestField)
-			"5001"+ // field 10, encoding 0, value 1
-			"5803"+ // field 11, encoding 0, value 3
-			"6006"+ // field 12, encoding 0, value 6
-			"6d20000000"+ // field 13, encoding 5, value 32
-			"714000000000000000"+ // field 14, encoding 1, value 64
-			"78a019"+ // field 15, encoding 0, value 3232
-			"8001c032"+ // field 16, encoding 0, value 6464
-			"8d0100004a45"+ // field 17, encoding 5, value 3232.0
-			"9101000000000040b940"+ // field 18, encoding 1, value 6464.0
-			"9a0106"+"737472696e67"+ // field 19, encoding 2 string "string"
-			"c00201"+ // field 40, encoding 0, value 1
-			"c80220"+ // field 41, encoding 0, value 32
-			"d00240"+ // field 42, encoding 0, value 64
-			"dd0240010000"+ // field 43, encoding 5, value 320
-			"e1028002000000000000"+ // field 44, encoding 1, value 640
-			"e8028019"+ // field 45, encoding 0, value 3200
-			"f0028032"+ // field 46, encoding 0, value 6400
-			"fd02e0659948"+ // field 47, encoding 5, value 314159.0
-			"81030000000050971041"+ // field 48, encoding 1, value 271828.0
-			"8a0310"+"68656c6c6f2c2022776f726c6421220a"+ // field 49, encoding 2 string "hello, \"world!\"\n"
-			"b304"+ // start group field 70 level 1
-			"ba0408"+"7265717569726564"+ // field 71, encoding 2, string "required"
-			"b404"+ // end group field 70 level 1
-			"aa0605"+"6279746573"+ // field 101, encoding 2 string "bytes"
-			"b0063f"+ // field 102, encoding 0, 0x3f zigzag32
-			"b8067f"+ // field 103, encoding 0, 0x7f zigzag64
-			"c506e0ffffff"+ // field 104, encoding 5, -32 fixed32
-			"c906c0ffffffffffffff"+ // field 105, encoding 1, -64 fixed64
-			"8a1907"+"4269676e6f7365"+ // field 401, encoding 2, string "Bignose"
-			"90193f"+ // field 402, encoding 0, value 63
-			"98197f"+ // field 403, encoding 0, value 127
-			"a519e0ffffff"+ // field 404, encoding 5, -32 fixed32
-			"a919c0ffffffffffffff") // field 405, encoding 1, -64 fixed64
-
-}
-
-// All required fields set, defaults provided, all non-defaulted optional fields have values.
-func TestEncodeDecode4(t *testing.T) {
-	pb := initGoTest(true)
-	pb.Table = String("hello")
-	pb.Param = Int32(7)
-	pb.OptionalField = initGoTestField()
-	pb.F_BoolOptional = Bool(true)
-	pb.F_Int32Optional = Int32(32)
-	pb.F_Int64Optional = Int64(64)
-	pb.F_Fixed32Optional = Uint32(3232)
-	pb.F_Fixed64Optional = Uint64(6464)
-	pb.F_Uint32Optional = Uint32(323232)
-	pb.F_Uint64Optional = Uint64(646464)
-	pb.F_FloatOptional = Float32(32.)
-	pb.F_DoubleOptional = Float64(64.)
-	pb.F_StringOptional = String("hello")
-	pb.F_BytesOptional = []byte("Bignose")
-	pb.F_Sint32Optional = Int32(-32)
-	pb.F_Sint64Optional = Int64(-64)
-	pb.F_Sfixed32Optional = Int32(-32)
-	pb.F_Sfixed64Optional = Int64(-64)
-	pb.Optionalgroup = initGoTest_OptionalGroup()
-
-	overify(t, pb,
-		"0807"+ // field 1, encoding 0, value 7
-			"1205"+"68656c6c6f"+ // field 2, encoding 2, string "hello"
-			"1807"+ // field 3, encoding 0, value 7
-			"220d"+"0a056c6162656c120474797065"+ // field 4, encoding 2 (GoTestField)
-			"320d"+"0a056c6162656c120474797065"+ // field 6, encoding 2 (GoTestField)
-			"5001"+ // field 10, encoding 0, value 1
-			"5803"+ // field 11, encoding 0, value 3
-			"6006"+ // field 12, encoding 0, value 6
-			"6d20000000"+ // field 13, encoding 5, value 32
-			"714000000000000000"+ // field 14, encoding 1, value 64
-			"78a019"+ // field 15, encoding 0, value 3232
-			"8001c032"+ // field 16, encoding 0, value 6464
-			"8d0100004a45"+ // field 17, encoding 5, value 3232.0
-			"9101000000000040b940"+ // field 18, encoding 1, value 6464.0
-			"9a0106"+"737472696e67"+ // field 19, encoding 2 string "string"
-			"f00101"+ // field 30, encoding 0, value 1
-			"f80120"+ // field 31, encoding 0, value 32
-			"800240"+ // field 32, encoding 0, value 64
-			"8d02a00c0000"+ // field 33, encoding 5, value 3232
-			"91024019000000000000"+ // field 34, encoding 1, value 6464
-			"9802a0dd13"+ // field 35, encoding 0, value 323232
-			"a002c0ba27"+ // field 36, encoding 0, value 646464
-			"ad0200000042"+ // field 37, encoding 5, value 32.0
-			"b1020000000000005040"+ // field 38, encoding 1, value 64.0
-			"ba0205"+"68656c6c6f"+ // field 39, encoding 2, string "hello"
-			"c00201"+ // field 40, encoding 0, value 1
-			"c80220"+ // field 41, encoding 0, value 32
-			"d00240"+ // field 42, encoding 0, value 64
-			"dd0240010000"+ // field 43, encoding 5, value 320
-			"e1028002000000000000"+ // field 44, encoding 1, value 640
-			"e8028019"+ // field 45, encoding 0, value 3200
-			"f0028032"+ // field 46, encoding 0, value 6400
-			"fd02e0659948"+ // field 47, encoding 5, value 314159.0
-			"81030000000050971041"+ // field 48, encoding 1, value 271828.0
-			"8a0310"+"68656c6c6f2c2022776f726c6421220a"+ // field 49, encoding 2 string "hello, \"world!\"\n"
-			"b304"+ // start group field 70 level 1
-			"ba0408"+"7265717569726564"+ // field 71, encoding 2, string "required"
-			"b404"+ // end group field 70 level 1
-			"d305"+ // start group field 90 level 1
-			"da0508"+"6f7074696f6e616c"+ // field 91, encoding 2, string "optional"
-			"d405"+ // end group field 90 level 1
-			"aa0605"+"6279746573"+ // field 101, encoding 2 string "bytes"
-			"b0063f"+ // field 102, encoding 0, 0x3f zigzag32
-			"b8067f"+ // field 103, encoding 0, 0x7f zigzag64
-			"c506e0ffffff"+ // field 104, encoding 5, -32 fixed32
-			"c906c0ffffffffffffff"+ // field 105, encoding 1, -64 fixed64
-			"ea1207"+"4269676e6f7365"+ // field 301, encoding 2, string "Bignose"
-			"f0123f"+ // field 302, encoding 0, value 63
-			"f8127f"+ // field 303, encoding 0, value 127
-			"8513e0ffffff"+ // field 304, encoding 5, -32 fixed32
-			"8913c0ffffffffffffff"+ // field 305, encoding 1, -64 fixed64
-			"8a1907"+"4269676e6f7365"+ // field 401, encoding 2, string "Bignose"
-			"90193f"+ // field 402, encoding 0, value 63
-			"98197f"+ // field 403, encoding 0, value 127
-			"a519e0ffffff"+ // field 404, encoding 5, -32 fixed32
-			"a919c0ffffffffffffff") // field 405, encoding 1, -64 fixed64
-
-}
-
-// All required fields set, defaults provided, all repeated fields given two values.
-func TestEncodeDecode5(t *testing.T) {
-	pb := initGoTest(true)
-	pb.RepeatedField = []*GoTestField{initGoTestField(), initGoTestField()}
-	pb.F_BoolRepeated = []bool{false, true}
-	pb.F_Int32Repeated = []int32{32, 33}
-	pb.F_Int64Repeated = []int64{64, 65}
-	pb.F_Fixed32Repeated = []uint32{3232, 3333}
-	pb.F_Fixed64Repeated = []uint64{6464, 6565}
-	pb.F_Uint32Repeated = []uint32{323232, 333333}
-	pb.F_Uint64Repeated = []uint64{646464, 656565}
-	pb.F_FloatRepeated = []float32{32., 33.}
-	pb.F_DoubleRepeated = []float64{64., 65.}
-	pb.F_StringRepeated = []string{"hello", "sailor"}
-	pb.F_BytesRepeated = [][]byte{[]byte("big"), []byte("nose")}
-	pb.F_Sint32Repeated = []int32{32, -32}
-	pb.F_Sint64Repeated = []int64{64, -64}
-	pb.F_Sfixed32Repeated = []int32{32, -32}
-	pb.F_Sfixed64Repeated = []int64{64, -64}
-	pb.Repeatedgroup = []*GoTest_RepeatedGroup{initGoTest_RepeatedGroup(), initGoTest_RepeatedGroup()}
-
-	overify(t, pb,
-		"0807"+ // field 1, encoding 0, value 7
-			"220d"+"0a056c6162656c120474797065"+ // field 4, encoding 2 (GoTestField)
-			"2a0d"+"0a056c6162656c120474797065"+ // field 5, encoding 2 (GoTestField)
-			"2a0d"+"0a056c6162656c120474797065"+ // field 5, encoding 2 (GoTestField)
-			"5001"+ // field 10, encoding 0, value 1
-			"5803"+ // field 11, encoding 0, value 3
-			"6006"+ // field 12, encoding 0, value 6
-			"6d20000000"+ // field 13, encoding 5, value 32
-			"714000000000000000"+ // field 14, encoding 1, value 64
-			"78a019"+ // field 15, encoding 0, value 3232
-			"8001c032"+ // field 16, encoding 0, value 6464
-			"8d0100004a45"+ // field 17, encoding 5, value 3232.0
-			"9101000000000040b940"+ // field 18, encoding 1, value 6464.0
-			"9a0106"+"737472696e67"+ // field 19, encoding 2 string "string"
-			"a00100"+ // field 20, encoding 0, value 0
-			"a00101"+ // field 20, encoding 0, value 1
-			"a80120"+ // field 21, encoding 0, value 32
-			"a80121"+ // field 21, encoding 0, value 33
-			"b00140"+ // field 22, encoding 0, value 64
-			"b00141"+ // field 22, encoding 0, value 65
-			"bd01a00c0000"+ // field 23, encoding 5, value 3232
-			"bd01050d0000"+ // field 23, encoding 5, value 3333
-			"c1014019000000000000"+ // field 24, encoding 1, value 6464
-			"c101a519000000000000"+ // field 24, encoding 1, value 6565
-			"c801a0dd13"+ // field 25, encoding 0, value 323232
-			"c80195ac14"+ // field 25, encoding 0, value 333333
-			"d001c0ba27"+ // field 26, encoding 0, value 646464
-			"d001b58928"+ // field 26, encoding 0, value 656565
-			"dd0100000042"+ // field 27, encoding 5, value 32.0
-			"dd0100000442"+ // field 27, encoding 5, value 33.0
-			"e1010000000000005040"+ // field 28, encoding 1, value 64.0
-			"e1010000000000405040"+ // field 28, encoding 1, value 65.0
-			"ea0105"+"68656c6c6f"+ // field 29, encoding 2, string "hello"
-			"ea0106"+"7361696c6f72"+ // field 29, encoding 2, string "sailor"
-			"c00201"+ // field 40, encoding 0, value 1
-			"c80220"+ // field 41, encoding 0, value 32
-			"d00240"+ // field 42, encoding 0, value 64
-			"dd0240010000"+ // field 43, encoding 5, value 320
-			"e1028002000000000000"+ // field 44, encoding 1, value 640
-			"e8028019"+ // field 45, encoding 0, value 3200
-			"f0028032"+ // field 46, encoding 0, value 6400
-			"fd02e0659948"+ // field 47, encoding 5, value 314159.0
-			"81030000000050971041"+ // field 48, encoding 1, value 271828.0
-			"8a0310"+"68656c6c6f2c2022776f726c6421220a"+ // field 49, encoding 2 string "hello, \"world!\"\n"
-			"b304"+ // start group field 70 level 1
-			"ba0408"+"7265717569726564"+ // field 71, encoding 2, string "required"
-			"b404"+ // end group field 70 level 1
-			"8305"+ // start group field 80 level 1
-			"8a0508"+"7265706561746564"+ // field 81, encoding 2, string "repeated"
-			"8405"+ // end group field 80 level 1
-			"8305"+ // start group field 80 level 1
-			"8a0508"+"7265706561746564"+ // field 81, encoding 2, string "repeated"
-			"8405"+ // end group field 80 level 1
-			"aa0605"+"6279746573"+ // field 101, encoding 2 string "bytes"
-			"b0063f"+ // field 102, encoding 0, 0x3f zigzag32
-			"b8067f"+ // field 103, encoding 0, 0x7f zigzag64
-			"c506e0ffffff"+ // field 104, encoding 5, -32 fixed32
-			"c906c0ffffffffffffff"+ // field 105, encoding 1, -64 fixed64
-			"ca0c03"+"626967"+ // field 201, encoding 2, string "big"
-			"ca0c04"+"6e6f7365"+ // field 201, encoding 2, string "nose"
-			"d00c40"+ // field 202, encoding 0, value 32
-			"d00c3f"+ // field 202, encoding 0, value -32
-			"d80c8001"+ // field 203, encoding 0, value 64
-			"d80c7f"+ // field 203, encoding 0, value -64
-			"e50c20000000"+ // field 204, encoding 5, 32 fixed32
-			"e50ce0ffffff"+ // field 204, encoding 5, -32 fixed32
-			"e90c4000000000000000"+ // field 205, encoding 1, 64 fixed64
-			"e90cc0ffffffffffffff"+ // field 205, encoding 1, -64 fixed64
-			"8a1907"+"4269676e6f7365"+ // field 401, encoding 2, string "Bignose"
-			"90193f"+ // field 402, encoding 0, value 63
-			"98197f"+ // field 403, encoding 0, value 127
-			"a519e0ffffff"+ // field 404, encoding 5, -32 fixed32
-			"a919c0ffffffffffffff") // field 405, encoding 1, -64 fixed64
-
-}
-
-// All required fields set, all packed repeated fields given two values.
-func TestEncodeDecode6(t *testing.T) {
-	pb := initGoTest(false)
-	pb.F_BoolRepeatedPacked = []bool{false, true}
-	pb.F_Int32RepeatedPacked = []int32{32, 33}
-	pb.F_Int64RepeatedPacked = []int64{64, 65}
-	pb.F_Fixed32RepeatedPacked = []uint32{3232, 3333}
-	pb.F_Fixed64RepeatedPacked = []uint64{6464, 6565}
-	pb.F_Uint32RepeatedPacked = []uint32{323232, 333333}
-	pb.F_Uint64RepeatedPacked = []uint64{646464, 656565}
-	pb.F_FloatRepeatedPacked = []float32{32., 33.}
-	pb.F_DoubleRepeatedPacked = []float64{64., 65.}
-	pb.F_Sint32RepeatedPacked = []int32{32, -32}
-	pb.F_Sint64RepeatedPacked = []int64{64, -64}
-	pb.F_Sfixed32RepeatedPacked = []int32{32, -32}
-	pb.F_Sfixed64RepeatedPacked = []int64{64, -64}
-
-	overify(t, pb,
-		"0807"+ // field 1, encoding 0, value 7
-			"220d"+"0a056c6162656c120474797065"+ // field 4, encoding 2 (GoTestField)
-			"5001"+ // field 10, encoding 0, value 1
-			"5803"+ // field 11, encoding 0, value 3
-			"6006"+ // field 12, encoding 0, value 6
-			"6d20000000"+ // field 13, encoding 5, value 32
-			"714000000000000000"+ // field 14, encoding 1, value 64
-			"78a019"+ // field 15, encoding 0, value 3232
-			"8001c032"+ // field 16, encoding 0, value 6464
-			"8d0100004a45"+ // field 17, encoding 5, value 3232.0
-			"9101000000000040b940"+ // field 18, encoding 1, value 6464.0
-			"9a0106"+"737472696e67"+ // field 19, encoding 2 string "string"
-			"9203020001"+ // field 50, encoding 2, 2 bytes, value 0, value 1
-			"9a03022021"+ // field 51, encoding 2, 2 bytes, value 32, value 33
-			"a203024041"+ // field 52, encoding 2, 2 bytes, value 64, value 65
-			"aa0308"+ // field 53, encoding 2, 8 bytes
-			"a00c0000050d0000"+ // value 3232, value 3333
-			"b20310"+ // field 54, encoding 2, 16 bytes
-			"4019000000000000a519000000000000"+ // value 6464, value 6565
-			"ba0306"+ // field 55, encoding 2, 6 bytes
-			"a0dd1395ac14"+ // value 323232, value 333333
-			"c20306"+ // field 56, encoding 2, 6 bytes
-			"c0ba27b58928"+ // value 646464, value 656565
-			"ca0308"+ // field 57, encoding 2, 8 bytes
-			"0000004200000442"+ // value 32.0, value 33.0
-			"d20310"+ // field 58, encoding 2, 16 bytes
-			"00000000000050400000000000405040"+ // value 64.0, value 65.0
-			"b304"+ // start group field 70 level 1
-			"ba0408"+"7265717569726564"+ // field 71, encoding 2, string "required"
-			"b404"+ // end group field 70 level 1
-			"aa0605"+"6279746573"+ // field 101, encoding 2 string "bytes"
-			"b0063f"+ // field 102, encoding 0, 0x3f zigzag32
-			"b8067f"+ // field 103, encoding 0, 0x7f zigzag64
-			"c506e0ffffff"+ // field 104, encoding 5, -32 fixed32
-			"c906c0ffffffffffffff"+ // field 105, encoding 1, -64 fixed64
-			"b21f02"+ // field 502, encoding 2, 2 bytes
-			"403f"+ // value 32, value -32
-			"ba1f03"+ // field 503, encoding 2, 3 bytes
-			"80017f"+ // value 64, value -64
-			"c21f08"+ // field 504, encoding 2, 8 bytes
-			"20000000e0ffffff"+ // value 32, value -32
-			"ca1f10"+ // field 505, encoding 2, 16 bytes
-			"4000000000000000c0ffffffffffffff") // value 64, value -64
-
-}
-
-// Test that we can encode empty bytes fields.
-func TestEncodeDecodeBytes1(t *testing.T) {
-	pb := initGoTest(false)
-
-	// Create our bytes
-	pb.F_BytesRequired = []byte{}
-	pb.F_BytesRepeated = [][]byte{{}}
-	pb.F_BytesOptional = []byte{}
-
-	d, err := Marshal(pb)
-	if err != nil {
-		t.Error(err)
-	}
-
-	pbd := new(GoTest)
-	if err := Unmarshal(d, pbd); err != nil {
-		t.Error(err)
-	}
-
-	if pbd.F_BytesRequired == nil || len(pbd.F_BytesRequired) != 0 {
-		t.Error("required empty bytes field is incorrect")
-	}
-	if pbd.F_BytesRepeated == nil || len(pbd.F_BytesRepeated) == 1 && pbd.F_BytesRepeated[0] == nil {
-		t.Error("repeated empty bytes field is incorrect")
-	}
-	if pbd.F_BytesOptional == nil || len(pbd.F_BytesOptional) != 0 {
-		t.Error("optional empty bytes field is incorrect")
-	}
-}
-
-// Test that we encode nil-valued fields of a repeated bytes field correctly.
-// Since entries in a repeated field cannot be nil, nil must mean empty value.
-func TestEncodeDecodeBytes2(t *testing.T) {
-	pb := initGoTest(false)
-
-	// Create our bytes
-	pb.F_BytesRepeated = [][]byte{nil}
-
-	d, err := Marshal(pb)
-	if err != nil {
-		t.Error(err)
-	}
-
-	pbd := new(GoTest)
-	if err := Unmarshal(d, pbd); err != nil {
-		t.Error(err)
-	}
-
-	if len(pbd.F_BytesRepeated) != 1 || pbd.F_BytesRepeated[0] == nil {
-		t.Error("Unexpected value for repeated bytes field")
-	}
-}
-
-// All required fields set, defaults provided, all repeated fields given two values.
-func TestSkippingUnrecognizedFields(t *testing.T) {
-	o := old()
-	pb := initGoTestField()
-
-	// Marshal it normally.
-	o.Marshal(pb)
-
-	// Now new a GoSkipTest record.
-	skip := &GoSkipTest{
-		SkipInt32:   Int32(32),
-		SkipFixed32: Uint32(3232),
-		SkipFixed64: Uint64(6464),
-		SkipString:  String("skipper"),
-		Skipgroup: &GoSkipTest_SkipGroup{
-			GroupInt32:  Int32(75),
-			GroupString: String("wxyz"),
-		},
-	}
-
-	// Marshal it into same buffer.
-	o.Marshal(skip)
-
-	pbd := new(GoTestField)
-	o.Unmarshal(pbd)
-
-	// The __unrecognized field should be a marshaling of GoSkipTest
-	skipd := new(GoSkipTest)
-
-	o.SetBuf(pbd.XXX_unrecognized)
-	o.Unmarshal(skipd)
-
-	if *skipd.SkipInt32 != *skip.SkipInt32 {
-		t.Error("skip int32", skipd.SkipInt32)
-	}
-	if *skipd.SkipFixed32 != *skip.SkipFixed32 {
-		t.Error("skip fixed32", skipd.SkipFixed32)
-	}
-	if *skipd.SkipFixed64 != *skip.SkipFixed64 {
-		t.Error("skip fixed64", skipd.SkipFixed64)
-	}
-	if *skipd.SkipString != *skip.SkipString {
-		t.Error("skip string", *skipd.SkipString)
-	}
-	if *skipd.Skipgroup.GroupInt32 != *skip.Skipgroup.GroupInt32 {
-		t.Error("skip group int32", skipd.Skipgroup.GroupInt32)
-	}
-	if *skipd.Skipgroup.GroupString != *skip.Skipgroup.GroupString {
-		t.Error("skip group string", *skipd.Skipgroup.GroupString)
-	}
-}
-
-// Check that unrecognized fields of a submessage are preserved.
-func TestSubmessageUnrecognizedFields(t *testing.T) {
-	nm := &NewMessage{
-		Nested: &NewMessage_Nested{
-			Name:      String("Nigel"),
-			FoodGroup: String("carbs"),
-		},
-	}
-	b, err := Marshal(nm)
-	if err != nil {
-		t.Fatalf("Marshal of NewMessage: %v", err)
-	}
-
-	// Unmarshal into an OldMessage.
-	om := new(OldMessage)
-	if err := Unmarshal(b, om); err != nil {
-		t.Fatalf("Unmarshal to OldMessage: %v", err)
-	}
-	exp := &OldMessage{
-		Nested: &OldMessage_Nested{
-			Name: String("Nigel"),
-			// normal protocol buffer users should not do this
-			XXX_unrecognized: []byte("\x12\x05carbs"),
-		},
-	}
-	if !Equal(om, exp) {
-		t.Errorf("om = %v, want %v", om, exp)
-	}
-
-	// Clone the OldMessage.
-	om = Clone(om).(*OldMessage)
-	if !Equal(om, exp) {
-		t.Errorf("Clone(om) = %v, want %v", om, exp)
-	}
-
-	// Marshal the OldMessage, then unmarshal it into an empty NewMessage.
-	if b, err = Marshal(om); err != nil {
-		t.Fatalf("Marshal of OldMessage: %v", err)
-	}
-	t.Logf("Marshal(%v) -> %q", om, b)
-	nm2 := new(NewMessage)
-	if err := Unmarshal(b, nm2); err != nil {
-		t.Fatalf("Unmarshal to NewMessage: %v", err)
-	}
-	if !Equal(nm, nm2) {
-		t.Errorf("NewMessage round-trip: %v => %v", nm, nm2)
-	}
-}
-
-// Check that an int32 field can be upgraded to an int64 field.
-func TestNegativeInt32(t *testing.T) {
-	om := &OldMessage{
-		Num: Int32(-1),
-	}
-	b, err := Marshal(om)
-	if err != nil {
-		t.Fatalf("Marshal of OldMessage: %v", err)
-	}
-
-	// Check the size. It should be 11 bytes;
-	// 1 for the field/wire type, and 10 for the negative number.
-	if len(b) != 11 {
-		t.Errorf("%v marshaled as %q, wanted 11 bytes", om, b)
-	}
-
-	// Unmarshal into a NewMessage.
-	nm := new(NewMessage)
-	if err := Unmarshal(b, nm); err != nil {
-		t.Fatalf("Unmarshal to NewMessage: %v", err)
-	}
-	want := &NewMessage{
-		Num: Int64(-1),
-	}
-	if !Equal(nm, want) {
-		t.Errorf("nm = %v, want %v", nm, want)
-	}
-}
-
-// Check that we can grow an array (repeated field) to have many elements.
-// This test doesn't depend only on our encoding; for variety, it makes sure
-// we create, encode, and decode the correct contents explicitly.  It's therefore
-// a bit messier.
-// This test also uses (and hence tests) the Marshal/Unmarshal functions
-// instead of the methods.
-func TestBigRepeated(t *testing.T) {
-	pb := initGoTest(true)
-
-	// Create the arrays
-	const N = 50 // Internally the library starts much smaller.
-	pb.Repeatedgroup = make([]*GoTest_RepeatedGroup, N)
-	pb.F_Sint64Repeated = make([]int64, N)
-	pb.F_Sint32Repeated = make([]int32, N)
-	pb.F_BytesRepeated = make([][]byte, N)
-	pb.F_StringRepeated = make([]string, N)
-	pb.F_DoubleRepeated = make([]float64, N)
-	pb.F_FloatRepeated = make([]float32, N)
-	pb.F_Uint64Repeated = make([]uint64, N)
-	pb.F_Uint32Repeated = make([]uint32, N)
-	pb.F_Fixed64Repeated = make([]uint64, N)
-	pb.F_Fixed32Repeated = make([]uint32, N)
-	pb.F_Int64Repeated = make([]int64, N)
-	pb.F_Int32Repeated = make([]int32, N)
-	pb.F_BoolRepeated = make([]bool, N)
-	pb.RepeatedField = make([]*GoTestField, N)
-
-	// Fill in the arrays with checkable values.
-	igtf := initGoTestField()
-	igtrg := initGoTest_RepeatedGroup()
-	for i := 0; i < N; i++ {
-		pb.Repeatedgroup[i] = igtrg
-		pb.F_Sint64Repeated[i] = int64(i)
-		pb.F_Sint32Repeated[i] = int32(i)
-		s := fmt.Sprint(i)
-		pb.F_BytesRepeated[i] = []byte(s)
-		pb.F_StringRepeated[i] = s
-		pb.F_DoubleRepeated[i] = float64(i)
-		pb.F_FloatRepeated[i] = float32(i)
-		pb.F_Uint64Repeated[i] = uint64(i)
-		pb.F_Uint32Repeated[i] = uint32(i)
-		pb.F_Fixed64Repeated[i] = uint64(i)
-		pb.F_Fixed32Repeated[i] = uint32(i)
-		pb.F_Int64Repeated[i] = int64(i)
-		pb.F_Int32Repeated[i] = int32(i)
-		pb.F_BoolRepeated[i] = i%2 == 0
-		pb.RepeatedField[i] = igtf
-	}
-
-	// Marshal.
-	buf, _ := Marshal(pb)
-
-	// Now test Unmarshal by recreating the original buffer.
-	pbd := new(GoTest)
-	Unmarshal(buf, pbd)
-
-	// Check the checkable values
-	for i := uint64(0); i < N; i++ {
-		if pbd.Repeatedgroup[i] == nil { // TODO: more checking?
-			t.Error("pbd.Repeatedgroup bad")
-		}
-		if x := uint64(pbd.F_Sint64Repeated[i]); x != i {
-			t.Error("pbd.F_Sint64Repeated bad", x, i)
-		}
-		if x := uint64(pbd.F_Sint32Repeated[i]); x != i {
-			t.Error("pbd.F_Sint32Repeated bad", x, i)
-		}
-		s := fmt.Sprint(i)
-		equalbytes(pbd.F_BytesRepeated[i], []byte(s), t)
-		if pbd.F_StringRepeated[i] != s {
-			t.Error("pbd.F_Sint32Repeated bad", pbd.F_StringRepeated[i], i)
-		}
-		if x := uint64(pbd.F_DoubleRepeated[i]); x != i {
-			t.Error("pbd.F_DoubleRepeated bad", x, i)
-		}
-		if x := uint64(pbd.F_FloatRepeated[i]); x != i {
-			t.Error("pbd.F_FloatRepeated bad", x, i)
-		}
-		if x := pbd.F_Uint64Repeated[i]; x != i {
-			t.Error("pbd.F_Uint64Repeated bad", x, i)
-		}
-		if x := uint64(pbd.F_Uint32Repeated[i]); x != i {
-			t.Error("pbd.F_Uint32Repeated bad", x, i)
-		}
-		if x := pbd.F_Fixed64Repeated[i]; x != i {
-			t.Error("pbd.F_Fixed64Repeated bad", x, i)
-		}
-		if x := uint64(pbd.F_Fixed32Repeated[i]); x != i {
-			t.Error("pbd.F_Fixed32Repeated bad", x, i)
-		}
-		if x := uint64(pbd.F_Int64Repeated[i]); x != i {
-			t.Error("pbd.F_Int64Repeated bad", x, i)
-		}
-		if x := uint64(pbd.F_Int32Repeated[i]); x != i {
-			t.Error("pbd.F_Int32Repeated bad", x, i)
-		}
-		if x := pbd.F_BoolRepeated[i]; x != (i%2 == 0) {
-			t.Error("pbd.F_BoolRepeated bad", x, i)
-		}
-		if pbd.RepeatedField[i] == nil { // TODO: more checking?
-			t.Error("pbd.RepeatedField bad")
-		}
-	}
-}
-
-func TestBadWireTypeUnknown(t *testing.T) {
-	var b []byte
-	fmt.Sscanf("0a01780d00000000080b101612036161611521000000202c220362626225370000002203636363214200000000000000584d5a036464645900000000000056405d63000000", "%x", &b)
-
-	m := new(MyMessage)
-	if err := Unmarshal(b, m); err != nil {
-		t.Errorf("unexpected Unmarshal error: %v", err)
-	}
-
-	var unknown []byte
-	fmt.Sscanf("0a01780d0000000010161521000000202c2537000000214200000000000000584d5a036464645d63000000", "%x", &unknown)
-	if !bytes.Equal(m.XXX_unrecognized, unknown) {
-		t.Errorf("unknown bytes mismatch:\ngot  %x\nwant %x", m.XXX_unrecognized, unknown)
-	}
-	DiscardUnknown(m)
-
-	want := &MyMessage{Count: Int32(11), Name: String("aaa"), Pet: []string{"bbb", "ccc"}, Bigfloat: Float64(88)}
-	if !Equal(m, want) {
-		t.Errorf("message mismatch:\ngot  %v\nwant %v", m, want)
-	}
-}
-
-func encodeDecode(t *testing.T, in, out Message, msg string) {
-	buf, err := Marshal(in)
-	if err != nil {
-		t.Fatalf("failed marshaling %v: %v", msg, err)
-	}
-	if err := Unmarshal(buf, out); err != nil {
-		t.Fatalf("failed unmarshaling %v: %v", msg, err)
-	}
-}
-
-func TestPackedNonPackedDecoderSwitching(t *testing.T) {
-	np, p := new(NonPackedTest), new(PackedTest)
-
-	// non-packed -> packed
-	np.A = []int32{0, 1, 1, 2, 3, 5}
-	encodeDecode(t, np, p, "non-packed -> packed")
-	if !reflect.DeepEqual(np.A, p.B) {
-		t.Errorf("failed non-packed -> packed; np.A=%+v, p.B=%+v", np.A, p.B)
-	}
-
-	// packed -> non-packed
-	np.Reset()
-	p.B = []int32{3, 1, 4, 1, 5, 9}
-	encodeDecode(t, p, np, "packed -> non-packed")
-	if !reflect.DeepEqual(p.B, np.A) {
-		t.Errorf("failed packed -> non-packed; p.B=%+v, np.A=%+v", p.B, np.A)
-	}
-}
-
-func TestProto1RepeatedGroup(t *testing.T) {
-	pb := &MessageList{
-		Message: []*MessageList_Message{
-			{
-				Name:  String("blah"),
-				Count: Int32(7),
-			},
-			// NOTE: pb.Message[1] is a nil
-			nil,
-		},
-	}
-
-	o := old()
-	err := o.Marshal(pb)
-	if err == nil || !strings.Contains(err.Error(), "repeated field Message has nil") {
-		t.Fatalf("unexpected or no error when marshaling: %v", err)
-	}
-}
-
-// Test that enums work.  Checks for a bug introduced by making enums
-// named types instead of int32: newInt32FromUint64 would crash with
-// a type mismatch in reflect.PointTo.
-func TestEnum(t *testing.T) {
-	pb := new(GoEnum)
-	pb.Foo = FOO_FOO1.Enum()
-	o := old()
-	if err := o.Marshal(pb); err != nil {
-		t.Fatal("error encoding enum:", err)
-	}
-	pb1 := new(GoEnum)
-	if err := o.Unmarshal(pb1); err != nil {
-		t.Fatal("error decoding enum:", err)
-	}
-	if *pb1.Foo != FOO_FOO1 {
-		t.Error("expected 7 but got ", *pb1.Foo)
-	}
-}
-
-// Enum types have String methods. Check that enum fields can be printed.
-// We don't care what the value actually is, just as long as it doesn't crash.
-func TestPrintingNilEnumFields(t *testing.T) {
-	pb := new(GoEnum)
-	_ = fmt.Sprintf("%+v", pb)
-}
-
-// Verify that absent required fields cause Marshal/Unmarshal to return errors.
-func TestRequiredFieldEnforcement(t *testing.T) {
-	pb := new(GoTestField)
-	_, err := Marshal(pb)
-	if err == nil {
-		t.Error("marshal: expected error, got nil")
-	} else if _, ok := err.(*RequiredNotSetError); !ok || !strings.Contains(err.Error(), "Label") {
-		t.Errorf("marshal: bad error type: %v", err)
-	}
-
-	// A slightly sneaky, yet valid, proto. It encodes the same required field twice,
-	// so simply counting the required fields is insufficient.
-	// field 1, encoding 2, value "hi"
-	buf := []byte("\x0A\x02hi\x0A\x02hi")
-	err = Unmarshal(buf, pb)
-	if err == nil {
-		t.Error("unmarshal: expected error, got nil")
-	} else if _, ok := err.(*RequiredNotSetError); !ok || !strings.Contains(err.Error(), "Type") && !strings.Contains(err.Error(), "{Unknown}") {
-		// TODO: remove unknown cases once we commit to the new unmarshaler.
-		t.Errorf("unmarshal: bad error type: %v", err)
-	}
-}
-
-// Verify that absent required fields in groups cause Marshal/Unmarshal to return errors.
-func TestRequiredFieldEnforcementGroups(t *testing.T) {
-	pb := &GoTestRequiredGroupField{Group: &GoTestRequiredGroupField_Group{}}
-	if _, err := Marshal(pb); err == nil {
-		t.Error("marshal: expected error, got nil")
-	} else if _, ok := err.(*RequiredNotSetError); !ok || !strings.Contains(err.Error(), "Group.Field") {
-		t.Errorf("marshal: bad error type: %v", err)
-	}
-
-	buf := []byte{11, 12}
-	if err := Unmarshal(buf, pb); err == nil {
-		t.Error("unmarshal: expected error, got nil")
-	} else if _, ok := err.(*RequiredNotSetError); !ok || !strings.Contains(err.Error(), "Group.Field") && !strings.Contains(err.Error(), "Group.{Unknown}") {
-		t.Errorf("unmarshal: bad error type: %v", err)
-	}
-}
-
-func TestTypedNilMarshal(t *testing.T) {
-	// A typed nil should return ErrNil and not crash.
-	{
-		var m *GoEnum
-		if _, err := Marshal(m); err != ErrNil {
-			t.Errorf("Marshal(%#v): got %v, want ErrNil", m, err)
-		}
-	}
-
-	{
-		m := &Communique{Union: &Communique_Msg{nil}}
-		if _, err := Marshal(m); err == nil || err == ErrNil {
-			t.Errorf("Marshal(%#v): got %v, want errOneofHasNil", m, err)
-		}
-	}
-}
-
-// A type that implements the Marshaler interface, but is not nillable.
-type nonNillableInt uint64
-
-func (nni nonNillableInt) Marshal() ([]byte, error) {
-	return EncodeVarint(uint64(nni)), nil
-}
-
-type NNIMessage struct {
-	nni nonNillableInt
-}
-
-func (*NNIMessage) Reset()         {}
-func (*NNIMessage) String() string { return "" }
-func (*NNIMessage) ProtoMessage()  {}
-
-type NMMessage struct{}
-
-func (*NMMessage) Reset()         {}
-func (*NMMessage) String() string { return "" }
-func (*NMMessage) ProtoMessage()  {}
-
-// Verify a type that uses the Marshaler interface, but has a nil pointer.
-func TestNilMarshaler(t *testing.T) {
-	// Try a struct with a Marshaler field that is nil.
-	// It should be directly marshable.
-	nmm := new(NMMessage)
-	if _, err := Marshal(nmm); err != nil {
-		t.Error("unexpected error marshaling nmm: ", err)
-	}
-
-	// Try a struct with a Marshaler field that is not nillable.
-	nnim := new(NNIMessage)
-	nnim.nni = 7
-	var _ Marshaler = nnim.nni // verify it is truly a Marshaler
-	if _, err := Marshal(nnim); err != nil {
-		t.Error("unexpected error marshaling nnim: ", err)
-	}
-}
-
-func TestAllSetDefaults(t *testing.T) {
-	// Exercise SetDefaults with all scalar field types.
-	m := &Defaults{
-		// NaN != NaN, so override that here.
-		F_Nan: Float32(1.7),
-	}
-	expected := &Defaults{
-		F_Bool:    Bool(true),
-		F_Int32:   Int32(32),
-		F_Int64:   Int64(64),
-		F_Fixed32: Uint32(320),
-		F_Fixed64: Uint64(640),
-		F_Uint32:  Uint32(3200),
-		F_Uint64:  Uint64(6400),
-		F_Float:   Float32(314159),
-		F_Double:  Float64(271828),
-		F_String:  String(`hello, "world!"` + "\n"),
-		F_Bytes:   []byte("Bignose"),
-		F_Sint32:  Int32(-32),
-		F_Sint64:  Int64(-64),
-		F_Enum:    Defaults_GREEN.Enum(),
-		F_Pinf:    Float32(float32(math.Inf(1))),
-		F_Ninf:    Float32(float32(math.Inf(-1))),
-		F_Nan:     Float32(1.7),
-		StrZero:   String(""),
-	}
-	SetDefaults(m)
-	if !Equal(m, expected) {
-		t.Errorf("SetDefaults failed\n got %v\nwant %v", m, expected)
-	}
-}
-
-func TestSetDefaultsWithSetField(t *testing.T) {
-	// Check that a set value is not overridden.
-	m := &Defaults{
-		F_Int32: Int32(12),
-	}
-	SetDefaults(m)
-	if v := m.GetF_Int32(); v != 12 {
-		t.Errorf("m.FInt32 = %v, want 12", v)
-	}
-}
-
-func TestSetDefaultsWithSubMessage(t *testing.T) {
-	m := &OtherMessage{
-		Key: Int64(123),
-		Inner: &InnerMessage{
-			Host: String("gopher"),
-		},
-	}
-	expected := &OtherMessage{
-		Key: Int64(123),
-		Inner: &InnerMessage{
-			Host: String("gopher"),
-			Port: Int32(4000),
-		},
-	}
-	SetDefaults(m)
-	if !Equal(m, expected) {
-		t.Errorf("\n got %v\nwant %v", m, expected)
-	}
-}
-
-func TestSetDefaultsWithRepeatedSubMessage(t *testing.T) {
-	m := &MyMessage{
-		RepInner: []*InnerMessage{{}},
-	}
-	expected := &MyMessage{
-		RepInner: []*InnerMessage{{
-			Port: Int32(4000),
-		}},
-	}
-	SetDefaults(m)
-	if !Equal(m, expected) {
-		t.Errorf("\n got %v\nwant %v", m, expected)
-	}
-}
-
-func TestSetDefaultWithRepeatedNonMessage(t *testing.T) {
-	m := &MyMessage{
-		Pet: []string{"turtle", "wombat"},
-	}
-	expected := Clone(m)
-	SetDefaults(m)
-	if !Equal(m, expected) {
-		t.Errorf("\n got %v\nwant %v", m, expected)
-	}
-}
-
-func TestMaximumTagNumber(t *testing.T) {
-	m := &MaxTag{
-		LastField: String("natural goat essence"),
-	}
-	buf, err := Marshal(m)
-	if err != nil {
-		t.Fatalf("proto.Marshal failed: %v", err)
-	}
-	m2 := new(MaxTag)
-	if err := Unmarshal(buf, m2); err != nil {
-		t.Fatalf("proto.Unmarshal failed: %v", err)
-	}
-	if got, want := m2.GetLastField(), *m.LastField; got != want {
-		t.Errorf("got %q, want %q", got, want)
-	}
-}
-
-func TestJSON(t *testing.T) {
-	m := &MyMessage{
-		Count: Int32(4),
-		Pet:   []string{"bunny", "kitty"},
-		Inner: &InnerMessage{
-			Host: String("cauchy"),
-		},
-		Bikeshed: MyMessage_GREEN.Enum(),
-	}
-	const expected = `{"count":4,"pet":["bunny","kitty"],"inner":{"host":"cauchy"},"bikeshed":1}`
-
-	b, err := json.Marshal(m)
-	if err != nil {
-		t.Fatalf("json.Marshal failed: %v", err)
-	}
-	s := string(b)
-	if s != expected {
-		t.Errorf("got  %s\nwant %s", s, expected)
-	}
-
-	received := new(MyMessage)
-	if err := json.Unmarshal(b, received); err != nil {
-		t.Fatalf("json.Unmarshal failed: %v", err)
-	}
-	if !Equal(received, m) {
-		t.Fatalf("got %s, want %s", received, m)
-	}
-
-	// Test unmarshalling of JSON with symbolic enum name.
-	const old = `{"count":4,"pet":["bunny","kitty"],"inner":{"host":"cauchy"},"bikeshed":"GREEN"}`
-	received.Reset()
-	if err := json.Unmarshal([]byte(old), received); err != nil {
-		t.Fatalf("json.Unmarshal failed: %v", err)
-	}
-	if !Equal(received, m) {
-		t.Fatalf("got %s, want %s", received, m)
-	}
-}
-
-func TestBadWireType(t *testing.T) {
-	b := []byte{7<<3 | 6} // field 7, wire type 6
-	pb := new(OtherMessage)
-	if err := Unmarshal(b, pb); err == nil {
-		t.Errorf("Unmarshal did not fail")
-	} else if !strings.Contains(err.Error(), "unknown wire type") {
-		t.Errorf("wrong error: %v", err)
-	}
-}
-
-func TestBytesWithInvalidLength(t *testing.T) {
-	// If a byte sequence has an invalid (negative) length, Unmarshal should not panic.
-	b := []byte{2<<3 | WireBytes, 0xff, 0xff, 0xff, 0xff, 0xff, 0}
-	Unmarshal(b, new(MyMessage))
-}
-
-func TestLengthOverflow(t *testing.T) {
-	// Overflowing a length should not panic.
-	b := []byte{2<<3 | WireBytes, 1, 1, 3<<3 | WireBytes, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x01}
-	Unmarshal(b, new(MyMessage))
-}
-
-func TestVarintOverflow(t *testing.T) {
-	// Overflowing a 64-bit length should not be allowed.
-	b := []byte{1<<3 | WireVarint, 0x01, 3<<3 | WireBytes, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x01}
-	if err := Unmarshal(b, new(MyMessage)); err == nil {
-		t.Fatalf("Overflowed uint64 length without error")
-	}
-}
-
-func TestBytesWithInvalidLengthInGroup(t *testing.T) {
-	// Overflowing a 64-bit length should not be allowed.
-	b := []byte{0xbb, 0x30, 0xb2, 0x30, 0xb0, 0xb2, 0x83, 0xf1, 0xb0, 0xb2, 0xef, 0xbf, 0xbd, 0x01}
-	if err := Unmarshal(b, new(MyMessage)); err == nil {
-		t.Fatalf("Overflowed uint64 length without error")
-	}
-}
-
-func TestUnmarshalFuzz(t *testing.T) {
-	const N = 1000
-	seed := time.Now().UnixNano()
-	t.Logf("RNG seed is %d", seed)
-	rng := rand.New(rand.NewSource(seed))
-	buf := make([]byte, 20)
-	for i := 0; i < N; i++ {
-		for j := range buf {
-			buf[j] = byte(rng.Intn(256))
-		}
-		fuzzUnmarshal(t, buf)
-	}
-}
-
-func TestMergeMessages(t *testing.T) {
-	pb := &MessageList{Message: []*MessageList_Message{{Name: String("x"), Count: Int32(1)}}}
-	data, err := Marshal(pb)
-	if err != nil {
-		t.Fatalf("Marshal: %v", err)
-	}
-
-	pb1 := new(MessageList)
-	if err := Unmarshal(data, pb1); err != nil {
-		t.Fatalf("first Unmarshal: %v", err)
-	}
-	if err := Unmarshal(data, pb1); err != nil {
-		t.Fatalf("second Unmarshal: %v", err)
-	}
-	if len(pb1.Message) != 1 {
-		t.Errorf("two Unmarshals produced %d Messages, want 1", len(pb1.Message))
-	}
-
-	pb2 := new(MessageList)
-	if err := UnmarshalMerge(data, pb2); err != nil {
-		t.Fatalf("first UnmarshalMerge: %v", err)
-	}
-	if err := UnmarshalMerge(data, pb2); err != nil {
-		t.Fatalf("second UnmarshalMerge: %v", err)
-	}
-	if len(pb2.Message) != 2 {
-		t.Errorf("two UnmarshalMerges produced %d Messages, want 2", len(pb2.Message))
-	}
-}
-
-func TestExtensionMarshalOrder(t *testing.T) {
-	m := &MyMessage{Count: Int(123)}
-	if err := SetExtension(m, E_Ext_More, &Ext{Data: String("alpha")}); err != nil {
-		t.Fatalf("SetExtension: %v", err)
-	}
-	if err := SetExtension(m, E_Ext_Text, String("aleph")); err != nil {
-		t.Fatalf("SetExtension: %v", err)
-	}
-	if err := SetExtension(m, E_Ext_Number, Int32(1)); err != nil {
-		t.Fatalf("SetExtension: %v", err)
-	}
-
-	// Serialize m several times, and check we get the same bytes each time.
-	var orig []byte
-	for i := 0; i < 100; i++ {
-		b, err := Marshal(m)
-		if err != nil {
-			t.Fatalf("Marshal: %v", err)
-		}
-		if i == 0 {
-			orig = b
-			continue
-		}
-		if !bytes.Equal(b, orig) {
-			t.Errorf("Bytes differ on attempt #%d", i)
-		}
-	}
-}
-
-func TestExtensionMapFieldMarshalDeterministic(t *testing.T) {
-	m := &MyMessage{Count: Int(123)}
-	if err := SetExtension(m, E_Ext_More, &Ext{MapField: map[int32]int32{1: 1, 2: 2, 3: 3, 4: 4}}); err != nil {
-		t.Fatalf("SetExtension: %v", err)
-	}
-	marshal := func(m Message) []byte {
-		var b Buffer
-		b.SetDeterministic(true)
-		if err := b.Marshal(m); err != nil {
-			t.Fatalf("Marshal failed: %v", err)
-		}
-		return b.Bytes()
-	}
-
-	want := marshal(m)
-	for i := 0; i < 100; i++ {
-		if got := marshal(m); !bytes.Equal(got, want) {
-			t.Errorf("Marshal produced inconsistent output with determinism enabled (pass %d).\n got %v\nwant %v", i, got, want)
-		}
-	}
-}
-
-// Many extensions, because small maps might not iterate differently on each iteration.
-var exts = []*ExtensionDesc{
-	E_X201,
-	E_X202,
-	E_X203,
-	E_X204,
-	E_X205,
-	E_X206,
-	E_X207,
-	E_X208,
-	E_X209,
-	E_X210,
-	E_X211,
-	E_X212,
-	E_X213,
-	E_X214,
-	E_X215,
-	E_X216,
-	E_X217,
-	E_X218,
-	E_X219,
-	E_X220,
-	E_X221,
-	E_X222,
-	E_X223,
-	E_X224,
-	E_X225,
-	E_X226,
-	E_X227,
-	E_X228,
-	E_X229,
-	E_X230,
-	E_X231,
-	E_X232,
-	E_X233,
-	E_X234,
-	E_X235,
-	E_X236,
-	E_X237,
-	E_X238,
-	E_X239,
-	E_X240,
-	E_X241,
-	E_X242,
-	E_X243,
-	E_X244,
-	E_X245,
-	E_X246,
-	E_X247,
-	E_X248,
-	E_X249,
-	E_X250,
-}
-
-func TestMessageSetMarshalOrder(t *testing.T) {
-	m := &MyMessageSet{}
-	for _, x := range exts {
-		if err := SetExtension(m, x, &Empty{}); err != nil {
-			t.Fatalf("SetExtension: %v", err)
-		}
-	}
-
-	buf, err := Marshal(m)
-	if err != nil {
-		t.Fatalf("Marshal: %v", err)
-	}
-
-	// Serialize m several times, and check we get the same bytes each time.
-	for i := 0; i < 10; i++ {
-		b1, err := Marshal(m)
-		if err != nil {
-			t.Fatalf("Marshal: %v", err)
-		}
-		if !bytes.Equal(b1, buf) {
-			t.Errorf("Bytes differ on re-Marshal #%d", i)
-		}
-
-		m2 := &MyMessageSet{}
-		if err := Unmarshal(buf, m2); err != nil {
-			t.Errorf("Unmarshal: %v", err)
-		}
-		b2, err := Marshal(m2)
-		if err != nil {
-			t.Errorf("re-Marshal: %v", err)
-		}
-		if !bytes.Equal(b2, buf) {
-			t.Errorf("Bytes differ on round-trip #%d", i)
-		}
-	}
-}
-
-func TestUnmarshalMergesMessages(t *testing.T) {
-	// If a nested message occurs twice in the input,
-	// the fields should be merged when decoding.
-	a := &OtherMessage{
-		Key: Int64(123),
-		Inner: &InnerMessage{
-			Host: String("polhode"),
-			Port: Int32(1234),
-		},
-	}
-	aData, err := Marshal(a)
-	if err != nil {
-		t.Fatalf("Marshal(a): %v", err)
-	}
-	b := &OtherMessage{
-		Weight: Float32(1.2),
-		Inner: &InnerMessage{
-			Host:      String("herpolhode"),
-			Connected: Bool(true),
-		},
-	}
-	bData, err := Marshal(b)
-	if err != nil {
-		t.Fatalf("Marshal(b): %v", err)
-	}
-	want := &OtherMessage{
-		Key:    Int64(123),
-		Weight: Float32(1.2),
-		Inner: &InnerMessage{
-			Host:      String("herpolhode"),
-			Port:      Int32(1234),
-			Connected: Bool(true),
-		},
-	}
-	got := new(OtherMessage)
-	if err := Unmarshal(append(aData, bData...), got); err != nil {
-		t.Fatalf("Unmarshal: %v", err)
-	}
-	if !Equal(got, want) {
-		t.Errorf("\n got %v\nwant %v", got, want)
-	}
-}
-
-func TestUnmarshalMergesGroups(t *testing.T) {
-	// If a nested group occurs twice in the input,
-	// the fields should be merged when decoding.
-	a := &GroupNew{
-		G: &GroupNew_G{
-			X: Int32(7),
-			Y: Int32(8),
-		},
-	}
-	aData, err := Marshal(a)
-	if err != nil {
-		t.Fatalf("Marshal(a): %v", err)
-	}
-	b := &GroupNew{
-		G: &GroupNew_G{
-			X: Int32(9),
-		},
-	}
-	bData, err := Marshal(b)
-	if err != nil {
-		t.Fatalf("Marshal(b): %v", err)
-	}
-	want := &GroupNew{
-		G: &GroupNew_G{
-			X: Int32(9),
-			Y: Int32(8),
-		},
-	}
-	got := new(GroupNew)
-	if err := Unmarshal(append(aData, bData...), got); err != nil {
-		t.Fatalf("Unmarshal: %v", err)
-	}
-	if !Equal(got, want) {
-		t.Errorf("\n got %v\nwant %v", got, want)
-	}
-}
-
-func TestEncodingSizes(t *testing.T) {
-	tests := []struct {
-		m Message
-		n int
-	}{
-		{&Defaults{F_Int32: Int32(math.MaxInt32)}, 6},
-		{&Defaults{F_Int32: Int32(math.MinInt32)}, 11},
-		{&Defaults{F_Uint32: Uint32(uint32(math.MaxInt32) + 1)}, 6},
-		{&Defaults{F_Uint32: Uint32(math.MaxUint32)}, 6},
-	}
-	for _, test := range tests {
-		b, err := Marshal(test.m)
-		if err != nil {
-			t.Errorf("Marshal(%v): %v", test.m, err)
-			continue
-		}
-		if len(b) != test.n {
-			t.Errorf("Marshal(%v) yielded %d bytes, want %d bytes", test.m, len(b), test.n)
-		}
-	}
-}
-
-func TestRequiredNotSetError(t *testing.T) {
-	pb := initGoTest(false)
-	pb.RequiredField.Label = nil
-	pb.F_Int32Required = nil
-	pb.F_Int64Required = nil
-
-	expected := "0807" + // field 1, encoding 0, value 7
-		"2206" + "120474797065" + // field 4, encoding 2 (GoTestField)
-		"5001" + // field 10, encoding 0, value 1
-		"6d20000000" + // field 13, encoding 5, value 0x20
-		"714000000000000000" + // field 14, encoding 1, value 0x40
-		"78a019" + // field 15, encoding 0, value 0xca0 = 3232
-		"8001c032" + // field 16, encoding 0, value 0x1940 = 6464
-		"8d0100004a45" + // field 17, encoding 5, value 3232.0
-		"9101000000000040b940" + // field 18, encoding 1, value 6464.0
-		"9a0106" + "737472696e67" + // field 19, encoding 2, string "string"
-		"b304" + // field 70, encoding 3, start group
-		"ba0408" + "7265717569726564" + // field 71, encoding 2, string "required"
-		"b404" + // field 70, encoding 4, end group
-		"aa0605" + "6279746573" + // field 101, encoding 2, string "bytes"
-		"b0063f" + // field 102, encoding 0, 0x3f zigzag32
-		"b8067f" + // field 103, encoding 0, 0x7f zigzag64
-		"c506e0ffffff" + // field 104, encoding 5, -32 fixed32
-		"c906c0ffffffffffffff" // field 105, encoding 1, -64 fixed64
-
-	o := old()
-	bytes, err := Marshal(pb)
-	if _, ok := err.(*RequiredNotSetError); !ok {
-		fmt.Printf("marshal-1 err = %v, want *RequiredNotSetError", err)
-		o.DebugPrint("", bytes)
-		t.Fatalf("expected = %s", expected)
-	}
-	if !strings.Contains(err.Error(), "RequiredField.Label") {
-		t.Errorf("marshal-1 wrong err msg: %v", err)
-	}
-	if !equal(bytes, expected, t) {
-		o.DebugPrint("neq 1", bytes)
-		t.Fatalf("expected = %s", expected)
-	}
-
-	// Now test Unmarshal by recreating the original buffer.
-	pbd := new(GoTest)
-	err = Unmarshal(bytes, pbd)
-	if _, ok := err.(*RequiredNotSetError); !ok {
-		t.Fatalf("unmarshal err = %v, want *RequiredNotSetError", err)
-		o.DebugPrint("", bytes)
-		t.Fatalf("string = %s", expected)
-	}
-	if !strings.Contains(err.Error(), "RequiredField.Label") && !strings.Contains(err.Error(), "RequiredField.{Unknown}") {
-		t.Errorf("unmarshal wrong err msg: %v", err)
-	}
-	bytes, err = Marshal(pbd)
-	if _, ok := err.(*RequiredNotSetError); !ok {
-		t.Errorf("marshal-2 err = %v, want *RequiredNotSetError", err)
-		o.DebugPrint("", bytes)
-		t.Fatalf("string = %s", expected)
-	}
-	if !strings.Contains(err.Error(), "RequiredField.Label") {
-		t.Errorf("marshal-2 wrong err msg: %v", err)
-	}
-	if !equal(bytes, expected, t) {
-		o.DebugPrint("neq 2", bytes)
-		t.Fatalf("string = %s", expected)
-	}
-}
-
-func TestRequiredNotSetErrorWithBadWireTypes(t *testing.T) {
-	// Required field expects a varint, and properly found a varint.
-	if err := Unmarshal([]byte{0x08, 0x00}, new(GoEnum)); err != nil {
-		t.Errorf("Unmarshal = %v, want nil", err)
-	}
-	// Required field expects a varint, but found a fixed32 instead.
-	if err := Unmarshal([]byte{0x0d, 0x00, 0x00, 0x00, 0x00}, new(GoEnum)); err == nil {
-		t.Errorf("Unmarshal = nil, want RequiredNotSetError")
-	}
-	// Required field expects a varint, and found both a varint and fixed32 (ignored).
-	m := new(GoEnum)
-	if err := Unmarshal([]byte{0x08, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00}, m); err != nil {
-		t.Errorf("Unmarshal = %v, want nil", err)
-	}
-	if !bytes.Equal(m.XXX_unrecognized, []byte{0x0d, 0x00, 0x00, 0x00, 0x00}) {
-		t.Errorf("expected fixed32 to appear as unknown bytes: %x", m.XXX_unrecognized)
-	}
-}
-
-func fuzzUnmarshal(t *testing.T, data []byte) {
-	defer func() {
-		if e := recover(); e != nil {
-			t.Errorf("These bytes caused a panic: %+v", data)
-			t.Logf("Stack:\n%s", debug.Stack())
-			t.FailNow()
-		}
-	}()
-
-	pb := new(MyMessage)
-	Unmarshal(data, pb)
-}
-
-func TestMapFieldMarshal(t *testing.T) {
-	m := &MessageWithMap{
-		NameMapping: map[int32]string{
-			1: "Rob",
-			4: "Ian",
-			8: "Dave",
-		},
-	}
-	b, err := Marshal(m)
-	if err != nil {
-		t.Fatalf("Marshal: %v", err)
-	}
-
-	// b should be the concatenation of these three byte sequences in some order.
-	parts := []string{
-		"\n\a\b\x01\x12\x03Rob",
-		"\n\a\b\x04\x12\x03Ian",
-		"\n\b\b\x08\x12\x04Dave",
-	}
-	ok := false
-	for i := range parts {
-		for j := range parts {
-			if j == i {
-				continue
-			}
-			for k := range parts {
-				if k == i || k == j {
-					continue
-				}
-				try := parts[i] + parts[j] + parts[k]
-				if bytes.Equal(b, []byte(try)) {
-					ok = true
-					break
-				}
-			}
-		}
-	}
-	if !ok {
-		t.Fatalf("Incorrect Marshal output.\n got %q\nwant %q (or a permutation of that)", b, parts[0]+parts[1]+parts[2])
-	}
-	t.Logf("FYI b: %q", b)
-
-	(new(Buffer)).DebugPrint("Dump of b", b)
-}
-
-func TestMapFieldDeterministicMarshal(t *testing.T) {
-	m := &MessageWithMap{
-		NameMapping: map[int32]string{
-			1: "Rob",
-			4: "Ian",
-			8: "Dave",
-		},
-	}
-
-	marshal := func(m Message) []byte {
-		var b Buffer
-		b.SetDeterministic(true)
-		if err := b.Marshal(m); err != nil {
-			t.Fatalf("Marshal failed: %v", err)
-		}
-		return b.Bytes()
-	}
-
-	want := marshal(m)
-	for i := 0; i < 10; i++ {
-		if got := marshal(m); !bytes.Equal(got, want) {
-			t.Errorf("Marshal produced inconsistent output with determinism enabled (pass %d).\n got %v\nwant %v", i, got, want)
-		}
-	}
-}
-
-func TestMapFieldRoundTrips(t *testing.T) {
-	m := &MessageWithMap{
-		NameMapping: map[int32]string{
-			1: "Rob",
-			4: "Ian",
-			8: "Dave",
-		},
-		MsgMapping: map[int64]*FloatingPoint{
-			0x7001: {F: Float64(2.0)},
-		},
-		ByteMapping: map[bool][]byte{
-			false: []byte("that's not right!"),
-			true:  []byte("aye, 'tis true!"),
-		},
-	}
-	b, err := Marshal(m)
-	if err != nil {
-		t.Fatalf("Marshal: %v", err)
-	}
-	t.Logf("FYI b: %q", b)
-	m2 := new(MessageWithMap)
-	if err := Unmarshal(b, m2); err != nil {
-		t.Fatalf("Unmarshal: %v", err)
-	}
-	if !Equal(m, m2) {
-		t.Errorf("Map did not survive a round trip.\ninitial: %v\n  final: %v", m, m2)
-	}
-}
-
-func TestMapFieldWithNil(t *testing.T) {
-	m1 := &MessageWithMap{
-		MsgMapping: map[int64]*FloatingPoint{
-			1: nil,
-		},
-	}
-	b, err := Marshal(m1)
-	if err != nil {
-		t.Fatalf("Marshal: %v", err)
-	}
-	m2 := new(MessageWithMap)
-	if err := Unmarshal(b, m2); err != nil {
-		t.Fatalf("Unmarshal: %v, got these bytes: %v", err, b)
-	}
-	if v, ok := m2.MsgMapping[1]; !ok {
-		t.Error("msg_mapping[1] not present")
-	} else if v != nil {
-		t.Errorf("msg_mapping[1] not nil: %v", v)
-	}
-}
-
-func TestMapFieldWithNilBytes(t *testing.T) {
-	m1 := &MessageWithMap{
-		ByteMapping: map[bool][]byte{
-			false: {},
-			true:  nil,
-		},
-	}
-	n := Size(m1)
-	b, err := Marshal(m1)
-	if err != nil {
-		t.Fatalf("Marshal: %v", err)
-	}
-	if n != len(b) {
-		t.Errorf("Size(m1) = %d; want len(Marshal(m1)) = %d", n, len(b))
-	}
-	m2 := new(MessageWithMap)
-	if err := Unmarshal(b, m2); err != nil {
-		t.Fatalf("Unmarshal: %v, got these bytes: %v", err, b)
-	}
-	if v, ok := m2.ByteMapping[false]; !ok {
-		t.Error("byte_mapping[false] not present")
-	} else if len(v) != 0 {
-		t.Errorf("byte_mapping[false] not empty: %#v", v)
-	}
-	if v, ok := m2.ByteMapping[true]; !ok {
-		t.Error("byte_mapping[true] not present")
-	} else if len(v) != 0 {
-		t.Errorf("byte_mapping[true] not empty: %#v", v)
-	}
-}
-
-func TestDecodeMapFieldMissingKey(t *testing.T) {
-	b := []byte{
-		0x0A, 0x03, // message, tag 1 (name_mapping), of length 3 bytes
-		// no key
-		0x12, 0x01, 0x6D, // string value of length 1 byte, value "m"
-	}
-	got := &MessageWithMap{}
-	err := Unmarshal(b, got)
-	if err != nil {
-		t.Fatalf("failed to marshal map with missing key: %v", err)
-	}
-	want := &MessageWithMap{NameMapping: map[int32]string{0: "m"}}
-	if !Equal(got, want) {
-		t.Errorf("Unmarshaled map with no key was not as expected. got: %v, want %v", got, want)
-	}
-}
-
-func TestDecodeMapFieldMissingValue(t *testing.T) {
-	b := []byte{
-		0x0A, 0x02, // message, tag 1 (name_mapping), of length 2 bytes
-		0x08, 0x01, // varint key, value 1
-		// no value
-	}
-	got := &MessageWithMap{}
-	err := Unmarshal(b, got)
-	if err != nil {
-		t.Fatalf("failed to marshal map with missing value: %v", err)
-	}
-	want := &MessageWithMap{NameMapping: map[int32]string{1: ""}}
-	if !Equal(got, want) {
-		t.Errorf("Unmarshaled map with no value was not as expected. got: %v, want %v", got, want)
-	}
-}
-
-func TestOneof(t *testing.T) {
-	m := &Communique{}
-	b, err := Marshal(m)
-	if err != nil {
-		t.Fatalf("Marshal of empty message with oneof: %v", err)
-	}
-	if len(b) != 0 {
-		t.Errorf("Marshal of empty message yielded too many bytes: %v", b)
-	}
-
-	m = &Communique{
-		Union: &Communique_Name{"Barry"},
-	}
-
-	// Round-trip.
-	b, err = Marshal(m)
-	if err != nil {
-		t.Fatalf("Marshal of message with oneof: %v", err)
-	}
-	if len(b) != 7 { // name tag/wire (1) + name len (1) + name (5)
-		t.Errorf("Incorrect marshal of message with oneof: %v", b)
-	}
-	m.Reset()
-	if err := Unmarshal(b, m); err != nil {
-		t.Fatalf("Unmarshal of message with oneof: %v", err)
-	}
-	if x, ok := m.Union.(*Communique_Name); !ok || x.Name != "Barry" {
-		t.Errorf("After round trip, Union = %+v", m.Union)
-	}
-	if name := m.GetName(); name != "Barry" {
-		t.Errorf("After round trip, GetName = %q, want %q", name, "Barry")
-	}
-
-	// Let's try with a message in the oneof.
-	m.Union = &Communique_Msg{&Strings{StringField: String("deep deep string")}}
-	b, err = Marshal(m)
-	if err != nil {
-		t.Fatalf("Marshal of message with oneof set to message: %v", err)
-	}
-	if len(b) != 20 { // msg tag/wire (1) + msg len (1) + msg (1 + 1 + 16)
-		t.Errorf("Incorrect marshal of message with oneof set to message: %v", b)
-	}
-	m.Reset()
-	if err := Unmarshal(b, m); err != nil {
-		t.Fatalf("Unmarshal of message with oneof set to message: %v", err)
-	}
-	ss, ok := m.Union.(*Communique_Msg)
-	if !ok || ss.Msg.GetStringField() != "deep deep string" {
-		t.Errorf("After round trip with oneof set to message, Union = %+v", m.Union)
-	}
-}
-
-func TestOneofNilBytes(t *testing.T) {
-	// A oneof with nil byte slice should marshal to tag + 0 (size), with no error.
-	m := &Communique{Union: &Communique_Data{Data: nil}}
-	b, err := Marshal(m)
-	if err != nil {
-		t.Fatalf("Marshal failed: %v", err)
-	}
-	want := []byte{
-		7<<3 | 2, // tag 7, wire type 2
-		0,        // size
-	}
-	if !bytes.Equal(b, want) {
-		t.Errorf("Wrong result of Marshal: got %x, want %x", b, want)
-	}
-}
-
-func TestInefficientPackedBool(t *testing.T) {
-	// https://github.com/golang/protobuf/issues/76
-	inp := []byte{
-		0x12, 0x02, // 0x12 = 2<<3|2; 2 bytes
-		// Usually a bool should take a single byte,
-		// but it is permitted to be any varint.
-		0xb9, 0x30,
-	}
-	if err := Unmarshal(inp, new(MoreRepeated)); err != nil {
-		t.Error(err)
-	}
-}
-
-// Make sure pure-reflect-based implementation handles
-// []int32-[]enum conversion correctly.
-func TestRepeatedEnum2(t *testing.T) {
-	pb := &RepeatedEnum{
-		Color: []RepeatedEnum_Color{RepeatedEnum_RED},
-	}
-	b, err := Marshal(pb)
-	if err != nil {
-		t.Fatalf("Marshal failed: %v", err)
-	}
-	x := new(RepeatedEnum)
-	err = Unmarshal(b, x)
-	if err != nil {
-		t.Fatalf("Unmarshal failed: %v", err)
-	}
-	if !Equal(pb, x) {
-		t.Errorf("Incorrect result: want: %v got: %v", pb, x)
-	}
-}
-
-// TestConcurrentMarshal makes sure that it is safe to marshal
-// same message in multiple goroutines concurrently.
-func TestConcurrentMarshal(t *testing.T) {
-	pb := initGoTest(true)
-	const N = 100
-	b := make([][]byte, N)
-
-	var wg sync.WaitGroup
-	for i := 0; i < N; i++ {
-		wg.Add(1)
-		go func(i int) {
-			defer wg.Done()
-			var err error
-			b[i], err = Marshal(pb)
-			if err != nil {
-				t.Errorf("marshal error: %v", err)
-			}
-		}(i)
-	}
-
-	wg.Wait()
-	for i := 1; i < N; i++ {
-		if !bytes.Equal(b[0], b[i]) {
-			t.Errorf("concurrent marshal result not same: b[0] = %v, b[%d] = %v", b[0], i, b[i])
-		}
-	}
-}
-
-func TestInvalidUTF8(t *testing.T) {
-	const wire = "\x12\x04\xde\xea\xca\xfe"
-
-	var m GoTest
-	if err := Unmarshal([]byte(wire), &m); err == nil {
-		t.Errorf("Unmarshal error: got nil, want non-nil")
-	}
-
-	m.Reset()
-	m.Table = String(wire[2:])
-	if _, err := Marshal(&m); err == nil {
-		t.Errorf("Marshal error: got nil, want non-nil")
-	}
-}
-
-// Benchmarks
-
-func testMsg() *GoTest {
-	pb := initGoTest(true)
-	const N = 1000 // Internally the library starts much smaller.
-	pb.F_Int32Repeated = make([]int32, N)
-	pb.F_DoubleRepeated = make([]float64, N)
-	for i := 0; i < N; i++ {
-		pb.F_Int32Repeated[i] = int32(i)
-		pb.F_DoubleRepeated[i] = float64(i)
-	}
-	return pb
-}
-
-func bytesMsg() *GoTest {
-	pb := initGoTest(true)
-	buf := make([]byte, 4000)
-	for i := range buf {
-		buf[i] = byte(i)
-	}
-	pb.F_BytesDefaulted = buf
-	return pb
-}
-
-func benchmarkMarshal(b *testing.B, pb Message, marshal func(Message) ([]byte, error)) {
-	d, _ := marshal(pb)
-	b.SetBytes(int64(len(d)))
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		marshal(pb)
-	}
-}
-
-func benchmarkBufferMarshal(b *testing.B, pb Message) {
-	p := NewBuffer(nil)
-	benchmarkMarshal(b, pb, func(pb0 Message) ([]byte, error) {
-		p.Reset()
-		err := p.Marshal(pb0)
-		return p.Bytes(), err
-	})
-}
-
-func benchmarkSize(b *testing.B, pb Message) {
-	benchmarkMarshal(b, pb, func(pb0 Message) ([]byte, error) {
-		Size(pb)
-		return nil, nil
-	})
-}
-
-func newOf(pb Message) Message {
-	in := reflect.ValueOf(pb)
-	if in.IsNil() {
-		return pb
-	}
-	return reflect.New(in.Type().Elem()).Interface().(Message)
-}
-
-func benchmarkUnmarshal(b *testing.B, pb Message, unmarshal func([]byte, Message) error) {
-	d, _ := Marshal(pb)
-	b.SetBytes(int64(len(d)))
-	pbd := newOf(pb)
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		unmarshal(d, pbd)
-	}
-}
-
-func benchmarkBufferUnmarshal(b *testing.B, pb Message) {
-	p := NewBuffer(nil)
-	benchmarkUnmarshal(b, pb, func(d []byte, pb0 Message) error {
-		p.SetBuf(d)
-		return p.Unmarshal(pb0)
-	})
-}
-
-// Benchmark{Marshal,BufferMarshal,Size,Unmarshal,BufferUnmarshal}{,Bytes}
-
-func BenchmarkMarshal(b *testing.B) {
-	benchmarkMarshal(b, testMsg(), Marshal)
-}
-
-func BenchmarkBufferMarshal(b *testing.B) {
-	benchmarkBufferMarshal(b, testMsg())
-}
-
-func BenchmarkSize(b *testing.B) {
-	benchmarkSize(b, testMsg())
-}
-
-func BenchmarkUnmarshal(b *testing.B) {
-	benchmarkUnmarshal(b, testMsg(), Unmarshal)
-}
-
-func BenchmarkBufferUnmarshal(b *testing.B) {
-	benchmarkBufferUnmarshal(b, testMsg())
-}
-
-func BenchmarkMarshalBytes(b *testing.B) {
-	benchmarkMarshal(b, bytesMsg(), Marshal)
-}
-
-func BenchmarkBufferMarshalBytes(b *testing.B) {
-	benchmarkBufferMarshal(b, bytesMsg())
-}
-
-func BenchmarkSizeBytes(b *testing.B) {
-	benchmarkSize(b, bytesMsg())
-}
-
-func BenchmarkUnmarshalBytes(b *testing.B) {
-	benchmarkUnmarshal(b, bytesMsg(), Unmarshal)
-}
-
-func BenchmarkBufferUnmarshalBytes(b *testing.B) {
-	benchmarkBufferUnmarshal(b, bytesMsg())
-}
-
-func BenchmarkUnmarshalUnrecognizedFields(b *testing.B) {
-	b.StopTimer()
-	pb := initGoTestField()
-	skip := &GoSkipTest{
-		SkipInt32:   Int32(32),
-		SkipFixed32: Uint32(3232),
-		SkipFixed64: Uint64(6464),
-		SkipString:  String("skipper"),
-		Skipgroup: &GoSkipTest_SkipGroup{
-			GroupInt32:  Int32(75),
-			GroupString: String("wxyz"),
-		},
-	}
-
-	pbd := new(GoTestField)
-	p := NewBuffer(nil)
-	p.Marshal(pb)
-	p.Marshal(skip)
-	p2 := NewBuffer(nil)
-
-	b.StartTimer()
-	for i := 0; i < b.N; i++ {
-		p2.SetBuf(p.Bytes())
-		p2.Unmarshal(pbd)
-	}
-}
diff --git a/vendor/github.com/golang/protobuf/proto/any_test.go b/vendor/github.com/golang/protobuf/proto/any_test.go
deleted file mode 100644
index 56fc97c11..000000000
--- a/vendor/github.com/golang/protobuf/proto/any_test.go
+++ /dev/null
@@ -1,300 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2016 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package proto_test
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/golang/protobuf/proto"
-
-	pb "github.com/golang/protobuf/proto/proto3_proto"
-	testpb "github.com/golang/protobuf/proto/test_proto"
-	anypb "github.com/golang/protobuf/ptypes/any"
-)
-
-var (
-	expandedMarshaler        = proto.TextMarshaler{ExpandAny: true}
-	expandedCompactMarshaler = proto.TextMarshaler{Compact: true, ExpandAny: true}
-)
-
-// anyEqual reports whether two messages which may be google.protobuf.Any or may
-// contain google.protobuf.Any fields are equal. We can't use proto.Equal for
-// comparison, because semantically equivalent messages may be marshaled to
-// binary in different tag order. Instead, trust that TextMarshaler with
-// ExpandAny option works and compare the text marshaling results.
-func anyEqual(got, want proto.Message) bool {
-	// if messages are proto.Equal, no need to marshal.
-	if proto.Equal(got, want) {
-		return true
-	}
-	g := expandedMarshaler.Text(got)
-	w := expandedMarshaler.Text(want)
-	return g == w
-}
-
-type golden struct {
-	m    proto.Message
-	t, c string
-}
-
-var goldenMessages = makeGolden()
-
-func makeGolden() []golden {
-	nested := &pb.Nested{Bunny: "Monty"}
-	nb, err := proto.Marshal(nested)
-	if err != nil {
-		panic(err)
-	}
-	m1 := &pb.Message{
-		Name:        "David",
-		ResultCount: 47,
-		Anything:    &anypb.Any{TypeUrl: "type.googleapis.com/" + proto.MessageName(nested), Value: nb},
-	}
-	m2 := &pb.Message{
-		Name:        "David",
-		ResultCount: 47,
-		Anything:    &anypb.Any{TypeUrl: "http://[::1]/type.googleapis.com/" + proto.MessageName(nested), Value: nb},
-	}
-	m3 := &pb.Message{
-		Name:        "David",
-		ResultCount: 47,
-		Anything:    &anypb.Any{TypeUrl: `type.googleapis.com/"/` + proto.MessageName(nested), Value: nb},
-	}
-	m4 := &pb.Message{
-		Name:        "David",
-		ResultCount: 47,
-		Anything:    &anypb.Any{TypeUrl: "type.googleapis.com/a/path/" + proto.MessageName(nested), Value: nb},
-	}
-	m5 := &anypb.Any{TypeUrl: "type.googleapis.com/" + proto.MessageName(nested), Value: nb}
-
-	any1 := &testpb.MyMessage{Count: proto.Int32(47), Name: proto.String("David")}
-	proto.SetExtension(any1, testpb.E_Ext_More, &testpb.Ext{Data: proto.String("foo")})
-	proto.SetExtension(any1, testpb.E_Ext_Text, proto.String("bar"))
-	any1b, err := proto.Marshal(any1)
-	if err != nil {
-		panic(err)
-	}
-	any2 := &testpb.MyMessage{Count: proto.Int32(42), Bikeshed: testpb.MyMessage_GREEN.Enum(), RepBytes: [][]byte{[]byte("roboto")}}
-	proto.SetExtension(any2, testpb.E_Ext_More, &testpb.Ext{Data: proto.String("baz")})
-	any2b, err := proto.Marshal(any2)
-	if err != nil {
-		panic(err)
-	}
-	m6 := &pb.Message{
-		Name:        "David",
-		ResultCount: 47,
-		Anything:    &anypb.Any{TypeUrl: "type.googleapis.com/" + proto.MessageName(any1), Value: any1b},
-		ManyThings: []*anypb.Any{
-			&anypb.Any{TypeUrl: "type.googleapis.com/" + proto.MessageName(any2), Value: any2b},
-			&anypb.Any{TypeUrl: "type.googleapis.com/" + proto.MessageName(any1), Value: any1b},
-		},
-	}
-
-	const (
-		m1Golden = `
-name: "David"
-result_count: 47
-anything: <
-  [type.googleapis.com/proto3_proto.Nested]: <
-    bunny: "Monty"
-  >
->
-`
-		m2Golden = `
-name: "David"
-result_count: 47
-anything: <
-  ["http://[::1]/type.googleapis.com/proto3_proto.Nested"]: <
-    bunny: "Monty"
-  >
->
-`
-		m3Golden = `
-name: "David"
-result_count: 47
-anything: <
-  ["type.googleapis.com/\"/proto3_proto.Nested"]: <
-    bunny: "Monty"
-  >
->
-`
-		m4Golden = `
-name: "David"
-result_count: 47
-anything: <
-  [type.googleapis.com/a/path/proto3_proto.Nested]: <
-    bunny: "Monty"
-  >
->
-`
-		m5Golden = `
-[type.googleapis.com/proto3_proto.Nested]: <
-  bunny: "Monty"
->
-`
-		m6Golden = `
-name: "David"
-result_count: 47
-anything: <
-  [type.googleapis.com/test_proto.MyMessage]: <
-    count: 47
-    name: "David"
-    [test_proto.Ext.more]: <
-      data: "foo"
-    >
-    [test_proto.Ext.text]: "bar"
-  >
->
-many_things: <
-  [type.googleapis.com/test_proto.MyMessage]: <
-    count: 42
-    bikeshed: GREEN
-    rep_bytes: "roboto"
-    [test_proto.Ext.more]: <
-      data: "baz"
-    >
-  >
->
-many_things: <
-  [type.googleapis.com/test_proto.MyMessage]: <
-    count: 47
-    name: "David"
-    [test_proto.Ext.more]: <
-      data: "foo"
-    >
-    [test_proto.Ext.text]: "bar"
-  >
->
-`
-	)
-	return []golden{
-		{m1, strings.TrimSpace(m1Golden) + "\n", strings.TrimSpace(compact(m1Golden)) + " "},
-		{m2, strings.TrimSpace(m2Golden) + "\n", strings.TrimSpace(compact(m2Golden)) + " "},
-		{m3, strings.TrimSpace(m3Golden) + "\n", strings.TrimSpace(compact(m3Golden)) + " "},
-		{m4, strings.TrimSpace(m4Golden) + "\n", strings.TrimSpace(compact(m4Golden)) + " "},
-		{m5, strings.TrimSpace(m5Golden) + "\n", strings.TrimSpace(compact(m5Golden)) + " "},
-		{m6, strings.TrimSpace(m6Golden) + "\n", strings.TrimSpace(compact(m6Golden)) + " "},
-	}
-}
-
-func TestMarshalGolden(t *testing.T) {
-	for _, tt := range goldenMessages {
-		if got, want := expandedMarshaler.Text(tt.m), tt.t; got != want {
-			t.Errorf("message %v: got:\n%s\nwant:\n%s", tt.m, got, want)
-		}
-		if got, want := expandedCompactMarshaler.Text(tt.m), tt.c; got != want {
-			t.Errorf("message %v: got:\n`%s`\nwant:\n`%s`", tt.m, got, want)
-		}
-	}
-}
-
-func TestUnmarshalGolden(t *testing.T) {
-	for _, tt := range goldenMessages {
-		want := tt.m
-		got := proto.Clone(tt.m)
-		got.Reset()
-		if err := proto.UnmarshalText(tt.t, got); err != nil {
-			t.Errorf("failed to unmarshal\n%s\nerror: %v", tt.t, err)
-		}
-		if !anyEqual(got, want) {
-			t.Errorf("message:\n%s\ngot:\n%s\nwant:\n%s", tt.t, got, want)
-		}
-		got.Reset()
-		if err := proto.UnmarshalText(tt.c, got); err != nil {
-			t.Errorf("failed to unmarshal\n%s\nerror: %v", tt.c, err)
-		}
-		if !anyEqual(got, want) {
-			t.Errorf("message:\n%s\ngot:\n%s\nwant:\n%s", tt.c, got, want)
-		}
-	}
-}
-
-func TestMarshalUnknownAny(t *testing.T) {
-	m := &pb.Message{
-		Anything: &anypb.Any{
-			TypeUrl: "foo",
-			Value:   []byte("bar"),
-		},
-	}
-	want := `anything: <
-  type_url: "foo"
-  value: "bar"
->
-`
-	got := expandedMarshaler.Text(m)
-	if got != want {
-		t.Errorf("got\n`%s`\nwant\n`%s`", got, want)
-	}
-}
-
-func TestAmbiguousAny(t *testing.T) {
-	pb := &anypb.Any{}
-	err := proto.UnmarshalText(`
-	type_url: "ttt/proto3_proto.Nested"
-	value: "\n\x05Monty"
-	`, pb)
-	t.Logf("result: %v (error: %v)", expandedMarshaler.Text(pb), err)
-	if err != nil {
-		t.Errorf("failed to parse ambiguous Any message: %v", err)
-	}
-}
-
-func TestUnmarshalOverwriteAny(t *testing.T) {
-	pb := &anypb.Any{}
-	err := proto.UnmarshalText(`
-  [type.googleapis.com/a/path/proto3_proto.Nested]: <
-    bunny: "Monty"
-  >
-  [type.googleapis.com/a/path/proto3_proto.Nested]: <
-    bunny: "Rabbit of Caerbannog"
-  >
-	`, pb)
-	want := `line 7: Any message unpacked multiple times, or "type_url" already set`
-	if err.Error() != want {
-		t.Errorf("incorrect error.\nHave: %v\nWant: %v", err.Error(), want)
-	}
-}
-
-func TestUnmarshalAnyMixAndMatch(t *testing.T) {
-	pb := &anypb.Any{}
-	err := proto.UnmarshalText(`
-	value: "\n\x05Monty"
-  [type.googleapis.com/a/path/proto3_proto.Nested]: <
-    bunny: "Rabbit of Caerbannog"
-  >
-	`, pb)
-	want := `line 5: Any message unpacked multiple times, or "value" already set`
-	if err.Error() != want {
-		t.Errorf("incorrect error.\nHave: %v\nWant: %v", err.Error(), want)
-	}
-}
diff --git a/vendor/github.com/golang/protobuf/proto/buffer.go b/vendor/github.com/golang/protobuf/proto/buffer.go
new file mode 100644
index 000000000..e810e6fea
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/buffer.go
@@ -0,0 +1,324 @@
+// Copyright 2019 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 proto
+
+import (
+	"errors"
+	"fmt"
+
+	"google.golang.org/protobuf/encoding/prototext"
+	"google.golang.org/protobuf/encoding/protowire"
+	"google.golang.org/protobuf/runtime/protoimpl"
+)
+
+const (
+	WireVarint     = 0
+	WireFixed32    = 5
+	WireFixed64    = 1
+	WireBytes      = 2
+	WireStartGroup = 3
+	WireEndGroup   = 4
+)
+
+// EncodeVarint returns the varint encoded bytes of v.
+func EncodeVarint(v uint64) []byte {
+	return protowire.AppendVarint(nil, v)
+}
+
+// SizeVarint returns the length of the varint encoded bytes of v.
+// This is equal to len(EncodeVarint(v)).
+func SizeVarint(v uint64) int {
+	return protowire.SizeVarint(v)
+}
+
+// DecodeVarint parses a varint encoded integer from b,
+// returning the integer value and the length of the varint.
+// It returns (0, 0) if there is a parse error.
+func DecodeVarint(b []byte) (uint64, int) {
+	v, n := protowire.ConsumeVarint(b)
+	if n < 0 {
+		return 0, 0
+	}
+	return v, n
+}
+
+// Buffer is a buffer for encoding and decoding the protobuf wire format.
+// It may be reused between invocations to reduce memory usage.
+type Buffer struct {
+	buf           []byte
+	idx           int
+	deterministic bool
+}
+
+// NewBuffer allocates a new Buffer initialized with buf,
+// where the contents of buf are considered the unread portion of the buffer.
+func NewBuffer(buf []byte) *Buffer {
+	return &Buffer{buf: buf}
+}
+
+// SetDeterministic specifies whether to use deterministic serialization.
+//
+// Deterministic serialization guarantees that for a given binary, equal
+// messages will always be serialized to the same bytes. This implies:
+//
+//   - Repeated serialization of a message will return the same bytes.
+//   - Different processes of the same binary (which may be executing on
+//     different machines) will serialize equal messages to the same bytes.
+//
+// Note that the deterministic serialization is NOT canonical across
+// languages. It is not guaranteed to remain stable over time. It is unstable
+// across different builds with schema changes due to unknown fields.
+// Users who need canonical serialization (e.g., persistent storage in a
+// canonical form, fingerprinting, etc.) should define their own
+// canonicalization specification and implement their own serializer rather
+// than relying on this API.
+//
+// If deterministic serialization is requested, map entries will be sorted
+// by keys in lexographical order. This is an implementation detail and
+// subject to change.
+func (b *Buffer) SetDeterministic(deterministic bool) {
+	b.deterministic = deterministic
+}
+
+// SetBuf sets buf as the internal buffer,
+// where the contents of buf are considered the unread portion of the buffer.
+func (b *Buffer) SetBuf(buf []byte) {
+	b.buf = buf
+	b.idx = 0
+}
+
+// Reset clears the internal buffer of all written and unread data.
+func (b *Buffer) Reset() {
+	b.buf = b.buf[:0]
+	b.idx = 0
+}
+
+// Bytes returns the internal buffer.
+func (b *Buffer) Bytes() []byte {
+	return b.buf
+}
+
+// Unread returns the unread portion of the buffer.
+func (b *Buffer) Unread() []byte {
+	return b.buf[b.idx:]
+}
+
+// Marshal appends the wire-format encoding of m to the buffer.
+func (b *Buffer) Marshal(m Message) error {
+	var err error
+	b.buf, err = marshalAppend(b.buf, m, b.deterministic)
+	return err
+}
+
+// Unmarshal parses the wire-format message in the buffer and
+// places the decoded results in m.
+// It does not reset m before unmarshaling.
+func (b *Buffer) Unmarshal(m Message) error {
+	err := UnmarshalMerge(b.Unread(), m)
+	b.idx = len(b.buf)
+	return err
+}
+
+type unknownFields struct{ XXX_unrecognized protoimpl.UnknownFields }
+
+func (m *unknownFields) String() string { panic("not implemented") }
+func (m *unknownFields) Reset()         { panic("not implemented") }
+func (m *unknownFields) ProtoMessage()  { panic("not implemented") }
+
+// DebugPrint dumps the encoded bytes of b with a header and footer including s
+// to stdout. This is only intended for debugging.
+func (*Buffer) DebugPrint(s string, b []byte) {
+	m := MessageReflect(new(unknownFields))
+	m.SetUnknown(b)
+	b, _ = prototext.MarshalOptions{AllowPartial: true, Indent: "\t"}.Marshal(m.Interface())
+	fmt.Printf("==== %s ====\n%s==== %s ====\n", s, b, s)
+}
+
+// EncodeVarint appends an unsigned varint encoding to the buffer.
+func (b *Buffer) EncodeVarint(v uint64) error {
+	b.buf = protowire.AppendVarint(b.buf, v)
+	return nil
+}
+
+// EncodeZigzag32 appends a 32-bit zig-zag varint encoding to the buffer.
+func (b *Buffer) EncodeZigzag32(v uint64) error {
+	return b.EncodeVarint(uint64((uint32(v) << 1) ^ uint32((int32(v) >> 31))))
+}
+
+// EncodeZigzag64 appends a 64-bit zig-zag varint encoding to the buffer.
+func (b *Buffer) EncodeZigzag64(v uint64) error {
+	return b.EncodeVarint(uint64((uint64(v) << 1) ^ uint64((int64(v) >> 63))))
+}
+
+// EncodeFixed32 appends a 32-bit little-endian integer to the buffer.
+func (b *Buffer) EncodeFixed32(v uint64) error {
+	b.buf = protowire.AppendFixed32(b.buf, uint32(v))
+	return nil
+}
+
+// EncodeFixed64 appends a 64-bit little-endian integer to the buffer.
+func (b *Buffer) EncodeFixed64(v uint64) error {
+	b.buf = protowire.AppendFixed64(b.buf, uint64(v))
+	return nil
+}
+
+// EncodeRawBytes appends a length-prefixed raw bytes to the buffer.
+func (b *Buffer) EncodeRawBytes(v []byte) error {
+	b.buf = protowire.AppendBytes(b.buf, v)
+	return nil
+}
+
+// EncodeStringBytes appends a length-prefixed raw bytes to the buffer.
+// It does not validate whether v contains valid UTF-8.
+func (b *Buffer) EncodeStringBytes(v string) error {
+	b.buf = protowire.AppendString(b.buf, v)
+	return nil
+}
+
+// EncodeMessage appends a length-prefixed encoded message to the buffer.
+func (b *Buffer) EncodeMessage(m Message) error {
+	var err error
+	b.buf = protowire.AppendVarint(b.buf, uint64(Size(m)))
+	b.buf, err = marshalAppend(b.buf, m, b.deterministic)
+	return err
+}
+
+// DecodeVarint consumes an encoded unsigned varint from the buffer.
+func (b *Buffer) DecodeVarint() (uint64, error) {
+	v, n := protowire.ConsumeVarint(b.buf[b.idx:])
+	if n < 0 {
+		return 0, protowire.ParseError(n)
+	}
+	b.idx += n
+	return uint64(v), nil
+}
+
+// DecodeZigzag32 consumes an encoded 32-bit zig-zag varint from the buffer.
+func (b *Buffer) DecodeZigzag32() (uint64, error) {
+	v, err := b.DecodeVarint()
+	if err != nil {
+		return 0, err
+	}
+	return uint64((uint32(v) >> 1) ^ uint32((int32(v&1)<<31)>>31)), nil
+}
+
+// DecodeZigzag64 consumes an encoded 64-bit zig-zag varint from the buffer.
+func (b *Buffer) DecodeZigzag64() (uint64, error) {
+	v, err := b.DecodeVarint()
+	if err != nil {
+		return 0, err
+	}
+	return uint64((uint64(v) >> 1) ^ uint64((int64(v&1)<<63)>>63)), nil
+}
+
+// DecodeFixed32 consumes a 32-bit little-endian integer from the buffer.
+func (b *Buffer) DecodeFixed32() (uint64, error) {
+	v, n := protowire.ConsumeFixed32(b.buf[b.idx:])
+	if n < 0 {
+		return 0, protowire.ParseError(n)
+	}
+	b.idx += n
+	return uint64(v), nil
+}
+
+// DecodeFixed64 consumes a 64-bit little-endian integer from the buffer.
+func (b *Buffer) DecodeFixed64() (uint64, error) {
+	v, n := protowire.ConsumeFixed64(b.buf[b.idx:])
+	if n < 0 {
+		return 0, protowire.ParseError(n)
+	}
+	b.idx += n
+	return uint64(v), nil
+}
+
+// DecodeRawBytes consumes a length-prefixed raw bytes from the buffer.
+// If alloc is specified, it returns a copy the raw bytes
+// rather than a sub-slice of the buffer.
+func (b *Buffer) DecodeRawBytes(alloc bool) ([]byte, error) {
+	v, n := protowire.ConsumeBytes(b.buf[b.idx:])
+	if n < 0 {
+		return nil, protowire.ParseError(n)
+	}
+	b.idx += n
+	if alloc {
+		v = append([]byte(nil), v...)
+	}
+	return v, nil
+}
+
+// DecodeStringBytes consumes a length-prefixed raw bytes from the buffer.
+// It does not validate whether the raw bytes contain valid UTF-8.
+func (b *Buffer) DecodeStringBytes() (string, error) {
+	v, n := protowire.ConsumeString(b.buf[b.idx:])
+	if n < 0 {
+		return "", protowire.ParseError(n)
+	}
+	b.idx += n
+	return v, nil
+}
+
+// DecodeMessage consumes a length-prefixed message from the buffer.
+// It does not reset m before unmarshaling.
+func (b *Buffer) DecodeMessage(m Message) error {
+	v, err := b.DecodeRawBytes(false)
+	if err != nil {
+		return err
+	}
+	return UnmarshalMerge(v, m)
+}
+
+// DecodeGroup consumes a message group from the buffer.
+// It assumes that the start group marker has already been consumed and
+// consumes all bytes until (and including the end group marker).
+// It does not reset m before unmarshaling.
+func (b *Buffer) DecodeGroup(m Message) error {
+	v, n, err := consumeGroup(b.buf[b.idx:])
+	if err != nil {
+		return err
+	}
+	b.idx += n
+	return UnmarshalMerge(v, m)
+}
+
+// consumeGroup parses b until it finds an end group marker, returning
+// the raw bytes of the message (excluding the end group marker) and the
+// the total length of the message (including the end group marker).
+func consumeGroup(b []byte) ([]byte, int, error) {
+	b0 := b
+	depth := 1 // assume this follows a start group marker
+	for {
+		_, wtyp, tagLen := protowire.ConsumeTag(b)
+		if tagLen < 0 {
+			return nil, 0, protowire.ParseError(tagLen)
+		}
+		b = b[tagLen:]
+
+		var valLen int
+		switch wtyp {
+		case protowire.VarintType:
+			_, valLen = protowire.ConsumeVarint(b)
+		case protowire.Fixed32Type:
+			_, valLen = protowire.ConsumeFixed32(b)
+		case protowire.Fixed64Type:
+			_, valLen = protowire.ConsumeFixed64(b)
+		case protowire.BytesType:
+			_, valLen = protowire.ConsumeBytes(b)
+		case protowire.StartGroupType:
+			depth++
+		case protowire.EndGroupType:
+			depth--
+		default:
+			return nil, 0, errors.New("proto: cannot parse reserved wire type")
+		}
+		if valLen < 0 {
+			return nil, 0, protowire.ParseError(valLen)
+		}
+		b = b[valLen:]
+
+		if depth == 0 {
+			return b0[:len(b0)-len(b)-tagLen], len(b0) - len(b), nil
+		}
+	}
+}
diff --git a/vendor/github.com/golang/protobuf/proto/clone.go b/vendor/github.com/golang/protobuf/proto/clone.go
deleted file mode 100644
index 3cd3249f7..000000000
--- a/vendor/github.com/golang/protobuf/proto/clone.go
+++ /dev/null
@@ -1,253 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2011 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Protocol buffer deep copy and merge.
-// TODO: RawMessage.
-
-package proto
-
-import (
-	"fmt"
-	"log"
-	"reflect"
-	"strings"
-)
-
-// Clone returns a deep copy of a protocol buffer.
-func Clone(src Message) Message {
-	in := reflect.ValueOf(src)
-	if in.IsNil() {
-		return src
-	}
-	out := reflect.New(in.Type().Elem())
-	dst := out.Interface().(Message)
-	Merge(dst, src)
-	return dst
-}
-
-// Merger is the interface representing objects that can merge messages of the same type.
-type Merger interface {
-	// Merge merges src into this message.
-	// Required and optional fields that are set in src will be set to that value in dst.
-	// Elements of repeated fields will be appended.
-	//
-	// Merge may panic if called with a different argument type than the receiver.
-	Merge(src Message)
-}
-
-// generatedMerger is the custom merge method that generated protos will have.
-// We must add this method since a generate Merge method will conflict with
-// many existing protos that have a Merge data field already defined.
-type generatedMerger interface {
-	XXX_Merge(src Message)
-}
-
-// Merge merges src into dst.
-// Required and optional fields that are set in src will be set to that value in dst.
-// Elements of repeated fields will be appended.
-// Merge panics if src and dst are not the same type, or if dst is nil.
-func Merge(dst, src Message) {
-	if m, ok := dst.(Merger); ok {
-		m.Merge(src)
-		return
-	}
-
-	in := reflect.ValueOf(src)
-	out := reflect.ValueOf(dst)
-	if out.IsNil() {
-		panic("proto: nil destination")
-	}
-	if in.Type() != out.Type() {
-		panic(fmt.Sprintf("proto.Merge(%T, %T) type mismatch", dst, src))
-	}
-	if in.IsNil() {
-		return // Merge from nil src is a noop
-	}
-	if m, ok := dst.(generatedMerger); ok {
-		m.XXX_Merge(src)
-		return
-	}
-	mergeStruct(out.Elem(), in.Elem())
-}
-
-func mergeStruct(out, in reflect.Value) {
-	sprop := GetProperties(in.Type())
-	for i := 0; i < in.NumField(); i++ {
-		f := in.Type().Field(i)
-		if strings.HasPrefix(f.Name, "XXX_") {
-			continue
-		}
-		mergeAny(out.Field(i), in.Field(i), false, sprop.Prop[i])
-	}
-
-	if emIn, err := extendable(in.Addr().Interface()); err == nil {
-		emOut, _ := extendable(out.Addr().Interface())
-		mIn, muIn := emIn.extensionsRead()
-		if mIn != nil {
-			mOut := emOut.extensionsWrite()
-			muIn.Lock()
-			mergeExtension(mOut, mIn)
-			muIn.Unlock()
-		}
-	}
-
-	uf := in.FieldByName("XXX_unrecognized")
-	if !uf.IsValid() {
-		return
-	}
-	uin := uf.Bytes()
-	if len(uin) > 0 {
-		out.FieldByName("XXX_unrecognized").SetBytes(append([]byte(nil), uin...))
-	}
-}
-
-// mergeAny performs a merge between two values of the same type.
-// viaPtr indicates whether the values were indirected through a pointer (implying proto2).
-// prop is set if this is a struct field (it may be nil).
-func mergeAny(out, in reflect.Value, viaPtr bool, prop *Properties) {
-	if in.Type() == protoMessageType {
-		if !in.IsNil() {
-			if out.IsNil() {
-				out.Set(reflect.ValueOf(Clone(in.Interface().(Message))))
-			} else {
-				Merge(out.Interface().(Message), in.Interface().(Message))
-			}
-		}
-		return
-	}
-	switch in.Kind() {
-	case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64,
-		reflect.String, reflect.Uint32, reflect.Uint64:
-		if !viaPtr && isProto3Zero(in) {
-			return
-		}
-		out.Set(in)
-	case reflect.Interface:
-		// Probably a oneof field; copy non-nil values.
-		if in.IsNil() {
-			return
-		}
-		// Allocate destination if it is not set, or set to a different type.
-		// Otherwise we will merge as normal.
-		if out.IsNil() || out.Elem().Type() != in.Elem().Type() {
-			out.Set(reflect.New(in.Elem().Elem().Type())) // interface -> *T -> T -> new(T)
-		}
-		mergeAny(out.Elem(), in.Elem(), false, nil)
-	case reflect.Map:
-		if in.Len() == 0 {
-			return
-		}
-		if out.IsNil() {
-			out.Set(reflect.MakeMap(in.Type()))
-		}
-		// For maps with value types of *T or []byte we need to deep copy each value.
-		elemKind := in.Type().Elem().Kind()
-		for _, key := range in.MapKeys() {
-			var val reflect.Value
-			switch elemKind {
-			case reflect.Ptr:
-				val = reflect.New(in.Type().Elem().Elem())
-				mergeAny(val, in.MapIndex(key), false, nil)
-			case reflect.Slice:
-				val = in.MapIndex(key)
-				val = reflect.ValueOf(append([]byte{}, val.Bytes()...))
-			default:
-				val = in.MapIndex(key)
-			}
-			out.SetMapIndex(key, val)
-		}
-	case reflect.Ptr:
-		if in.IsNil() {
-			return
-		}
-		if out.IsNil() {
-			out.Set(reflect.New(in.Elem().Type()))
-		}
-		mergeAny(out.Elem(), in.Elem(), true, nil)
-	case reflect.Slice:
-		if in.IsNil() {
-			return
-		}
-		if in.Type().Elem().Kind() == reflect.Uint8 {
-			// []byte is a scalar bytes field, not a repeated field.
-
-			// Edge case: if this is in a proto3 message, a zero length
-			// bytes field is considered the zero value, and should not
-			// be merged.
-			if prop != nil && prop.proto3 && in.Len() == 0 {
-				return
-			}
-
-			// Make a deep copy.
-			// Append to []byte{} instead of []byte(nil) so that we never end up
-			// with a nil result.
-			out.SetBytes(append([]byte{}, in.Bytes()...))
-			return
-		}
-		n := in.Len()
-		if out.IsNil() {
-			out.Set(reflect.MakeSlice(in.Type(), 0, n))
-		}
-		switch in.Type().Elem().Kind() {
-		case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64,
-			reflect.String, reflect.Uint32, reflect.Uint64:
-			out.Set(reflect.AppendSlice(out, in))
-		default:
-			for i := 0; i < n; i++ {
-				x := reflect.Indirect(reflect.New(in.Type().Elem()))
-				mergeAny(x, in.Index(i), false, nil)
-				out.Set(reflect.Append(out, x))
-			}
-		}
-	case reflect.Struct:
-		mergeStruct(out, in)
-	default:
-		// unknown type, so not a protocol buffer
-		log.Printf("proto: don't know how to copy %v", in)
-	}
-}
-
-func mergeExtension(out, in map[int32]Extension) {
-	for extNum, eIn := range in {
-		eOut := Extension{desc: eIn.desc}
-		if eIn.value != nil {
-			v := reflect.New(reflect.TypeOf(eIn.value)).Elem()
-			mergeAny(v, reflect.ValueOf(eIn.value), false, nil)
-			eOut.value = v.Interface()
-		}
-		if eIn.enc != nil {
-			eOut.enc = make([]byte, len(eIn.enc))
-			copy(eOut.enc, eIn.enc)
-		}
-
-		out[extNum] = eOut
-	}
-}
diff --git a/vendor/github.com/golang/protobuf/proto/clone_test.go b/vendor/github.com/golang/protobuf/proto/clone_test.go
deleted file mode 100644
index 0d3b12737..000000000
--- a/vendor/github.com/golang/protobuf/proto/clone_test.go
+++ /dev/null
@@ -1,390 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2011 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package proto_test
-
-import (
-	"testing"
-
-	"github.com/golang/protobuf/proto"
-
-	proto3pb "github.com/golang/protobuf/proto/proto3_proto"
-	pb "github.com/golang/protobuf/proto/test_proto"
-)
-
-var cloneTestMessage = &pb.MyMessage{
-	Count: proto.Int32(42),
-	Name:  proto.String("Dave"),
-	Pet:   []string{"bunny", "kitty", "horsey"},
-	Inner: &pb.InnerMessage{
-		Host:      proto.String("niles"),
-		Port:      proto.Int32(9099),
-		Connected: proto.Bool(true),
-	},
-	Others: []*pb.OtherMessage{
-		{
-			Value: []byte("some bytes"),
-		},
-	},
-	Somegroup: &pb.MyMessage_SomeGroup{
-		GroupField: proto.Int32(6),
-	},
-	RepBytes: [][]byte{[]byte("sham"), []byte("wow")},
-}
-
-func init() {
-	ext := &pb.Ext{
-		Data: proto.String("extension"),
-	}
-	if err := proto.SetExtension(cloneTestMessage, pb.E_Ext_More, ext); err != nil {
-		panic("SetExtension: " + err.Error())
-	}
-}
-
-func TestClone(t *testing.T) {
-	m := proto.Clone(cloneTestMessage).(*pb.MyMessage)
-	if !proto.Equal(m, cloneTestMessage) {
-		t.Fatalf("Clone(%v) = %v", cloneTestMessage, m)
-	}
-
-	// Verify it was a deep copy.
-	*m.Inner.Port++
-	if proto.Equal(m, cloneTestMessage) {
-		t.Error("Mutating clone changed the original")
-	}
-	// Byte fields and repeated fields should be copied.
-	if &m.Pet[0] == &cloneTestMessage.Pet[0] {
-		t.Error("Pet: repeated field not copied")
-	}
-	if &m.Others[0] == &cloneTestMessage.Others[0] {
-		t.Error("Others: repeated field not copied")
-	}
-	if &m.Others[0].Value[0] == &cloneTestMessage.Others[0].Value[0] {
-		t.Error("Others[0].Value: bytes field not copied")
-	}
-	if &m.RepBytes[0] == &cloneTestMessage.RepBytes[0] {
-		t.Error("RepBytes: repeated field not copied")
-	}
-	if &m.RepBytes[0][0] == &cloneTestMessage.RepBytes[0][0] {
-		t.Error("RepBytes[0]: bytes field not copied")
-	}
-}
-
-func TestCloneNil(t *testing.T) {
-	var m *pb.MyMessage
-	if c := proto.Clone(m); !proto.Equal(m, c) {
-		t.Errorf("Clone(%v) = %v", m, c)
-	}
-}
-
-var mergeTests = []struct {
-	src, dst, want proto.Message
-}{
-	{
-		src: &pb.MyMessage{
-			Count: proto.Int32(42),
-		},
-		dst: &pb.MyMessage{
-			Name: proto.String("Dave"),
-		},
-		want: &pb.MyMessage{
-			Count: proto.Int32(42),
-			Name:  proto.String("Dave"),
-		},
-	},
-	{
-		src: &pb.MyMessage{
-			Inner: &pb.InnerMessage{
-				Host:      proto.String("hey"),
-				Connected: proto.Bool(true),
-			},
-			Pet: []string{"horsey"},
-			Others: []*pb.OtherMessage{
-				{
-					Value: []byte("some bytes"),
-				},
-			},
-		},
-		dst: &pb.MyMessage{
-			Inner: &pb.InnerMessage{
-				Host: proto.String("niles"),
-				Port: proto.Int32(9099),
-			},
-			Pet: []string{"bunny", "kitty"},
-			Others: []*pb.OtherMessage{
-				{
-					Key: proto.Int64(31415926535),
-				},
-				{
-					// Explicitly test a src=nil field
-					Inner: nil,
-				},
-			},
-		},
-		want: &pb.MyMessage{
-			Inner: &pb.InnerMessage{
-				Host:      proto.String("hey"),
-				Connected: proto.Bool(true),
-				Port:      proto.Int32(9099),
-			},
-			Pet: []string{"bunny", "kitty", "horsey"},
-			Others: []*pb.OtherMessage{
-				{
-					Key: proto.Int64(31415926535),
-				},
-				{},
-				{
-					Value: []byte("some bytes"),
-				},
-			},
-		},
-	},
-	{
-		src: &pb.MyMessage{
-			RepBytes: [][]byte{[]byte("wow")},
-		},
-		dst: &pb.MyMessage{
-			Somegroup: &pb.MyMessage_SomeGroup{
-				GroupField: proto.Int32(6),
-			},
-			RepBytes: [][]byte{[]byte("sham")},
-		},
-		want: &pb.MyMessage{
-			Somegroup: &pb.MyMessage_SomeGroup{
-				GroupField: proto.Int32(6),
-			},
-			RepBytes: [][]byte{[]byte("sham"), []byte("wow")},
-		},
-	},
-	// Check that a scalar bytes field replaces rather than appends.
-	{
-		src:  &pb.OtherMessage{Value: []byte("foo")},
-		dst:  &pb.OtherMessage{Value: []byte("bar")},
-		want: &pb.OtherMessage{Value: []byte("foo")},
-	},
-	{
-		src: &pb.MessageWithMap{
-			NameMapping: map[int32]string{6: "Nigel"},
-			MsgMapping: map[int64]*pb.FloatingPoint{
-				0x4001: &pb.FloatingPoint{F: proto.Float64(2.0)},
-				0x4002: &pb.FloatingPoint{
-					F: proto.Float64(2.0),
-				},
-			},
-			ByteMapping: map[bool][]byte{true: []byte("wowsa")},
-		},
-		dst: &pb.MessageWithMap{
-			NameMapping: map[int32]string{
-				6: "Bruce", // should be overwritten
-				7: "Andrew",
-			},
-			MsgMapping: map[int64]*pb.FloatingPoint{
-				0x4002: &pb.FloatingPoint{
-					F:     proto.Float64(3.0),
-					Exact: proto.Bool(true),
-				}, // the entire message should be overwritten
-			},
-		},
-		want: &pb.MessageWithMap{
-			NameMapping: map[int32]string{
-				6: "Nigel",
-				7: "Andrew",
-			},
-			MsgMapping: map[int64]*pb.FloatingPoint{
-				0x4001: &pb.FloatingPoint{F: proto.Float64(2.0)},
-				0x4002: &pb.FloatingPoint{
-					F: proto.Float64(2.0),
-				},
-			},
-			ByteMapping: map[bool][]byte{true: []byte("wowsa")},
-		},
-	},
-	// proto3 shouldn't merge zero values,
-	// in the same way that proto2 shouldn't merge nils.
-	{
-		src: &proto3pb.Message{
-			Name: "Aaron",
-			Data: []byte(""), // zero value, but not nil
-		},
-		dst: &proto3pb.Message{
-			HeightInCm: 176,
-			Data:       []byte("texas!"),
-		},
-		want: &proto3pb.Message{
-			Name:       "Aaron",
-			HeightInCm: 176,
-			Data:       []byte("texas!"),
-		},
-	},
-	{ // Oneof fields should merge by assignment.
-		src:  &pb.Communique{Union: &pb.Communique_Number{41}},
-		dst:  &pb.Communique{Union: &pb.Communique_Name{"Bobby Tables"}},
-		want: &pb.Communique{Union: &pb.Communique_Number{41}},
-	},
-	{ // Oneof nil is the same as not set.
-		src:  &pb.Communique{},
-		dst:  &pb.Communique{Union: &pb.Communique_Name{"Bobby Tables"}},
-		want: &pb.Communique{Union: &pb.Communique_Name{"Bobby Tables"}},
-	},
-	{
-		src:  &pb.Communique{Union: &pb.Communique_Number{1337}},
-		dst:  &pb.Communique{},
-		want: &pb.Communique{Union: &pb.Communique_Number{1337}},
-	},
-	{
-		src:  &pb.Communique{Union: &pb.Communique_Col{pb.MyMessage_RED}},
-		dst:  &pb.Communique{},
-		want: &pb.Communique{Union: &pb.Communique_Col{pb.MyMessage_RED}},
-	},
-	{
-		src:  &pb.Communique{Union: &pb.Communique_Data{[]byte("hello")}},
-		dst:  &pb.Communique{},
-		want: &pb.Communique{Union: &pb.Communique_Data{[]byte("hello")}},
-	},
-	{
-		src:  &pb.Communique{Union: &pb.Communique_Msg{&pb.Strings{BytesField: []byte{1, 2, 3}}}},
-		dst:  &pb.Communique{},
-		want: &pb.Communique{Union: &pb.Communique_Msg{&pb.Strings{BytesField: []byte{1, 2, 3}}}},
-	},
-	{
-		src:  &pb.Communique{Union: &pb.Communique_Msg{}},
-		dst:  &pb.Communique{},
-		want: &pb.Communique{Union: &pb.Communique_Msg{}},
-	},
-	{
-		src:  &pb.Communique{Union: &pb.Communique_Msg{&pb.Strings{StringField: proto.String("123")}}},
-		dst:  &pb.Communique{Union: &pb.Communique_Msg{&pb.Strings{BytesField: []byte{1, 2, 3}}}},
-		want: &pb.Communique{Union: &pb.Communique_Msg{&pb.Strings{StringField: proto.String("123"), BytesField: []byte{1, 2, 3}}}},
-	},
-	{
-		src: &proto3pb.Message{
-			Terrain: map[string]*proto3pb.Nested{
-				"kay_a": &proto3pb.Nested{Cute: true},      // replace
-				"kay_b": &proto3pb.Nested{Bunny: "rabbit"}, // insert
-			},
-		},
-		dst: &proto3pb.Message{
-			Terrain: map[string]*proto3pb.Nested{
-				"kay_a": &proto3pb.Nested{Bunny: "lost"},  // replaced
-				"kay_c": &proto3pb.Nested{Bunny: "bunny"}, // keep
-			},
-		},
-		want: &proto3pb.Message{
-			Terrain: map[string]*proto3pb.Nested{
-				"kay_a": &proto3pb.Nested{Cute: true},
-				"kay_b": &proto3pb.Nested{Bunny: "rabbit"},
-				"kay_c": &proto3pb.Nested{Bunny: "bunny"},
-			},
-		},
-	},
-	{
-		src: &pb.GoTest{
-			F_BoolRepeated:   []bool{},
-			F_Int32Repeated:  []int32{},
-			F_Int64Repeated:  []int64{},
-			F_Uint32Repeated: []uint32{},
-			F_Uint64Repeated: []uint64{},
-			F_FloatRepeated:  []float32{},
-			F_DoubleRepeated: []float64{},
-			F_StringRepeated: []string{},
-			F_BytesRepeated:  [][]byte{},
-		},
-		dst: &pb.GoTest{},
-		want: &pb.GoTest{
-			F_BoolRepeated:   []bool{},
-			F_Int32Repeated:  []int32{},
-			F_Int64Repeated:  []int64{},
-			F_Uint32Repeated: []uint32{},
-			F_Uint64Repeated: []uint64{},
-			F_FloatRepeated:  []float32{},
-			F_DoubleRepeated: []float64{},
-			F_StringRepeated: []string{},
-			F_BytesRepeated:  [][]byte{},
-		},
-	},
-	{
-		src: &pb.GoTest{},
-		dst: &pb.GoTest{
-			F_BoolRepeated:   []bool{},
-			F_Int32Repeated:  []int32{},
-			F_Int64Repeated:  []int64{},
-			F_Uint32Repeated: []uint32{},
-			F_Uint64Repeated: []uint64{},
-			F_FloatRepeated:  []float32{},
-			F_DoubleRepeated: []float64{},
-			F_StringRepeated: []string{},
-			F_BytesRepeated:  [][]byte{},
-		},
-		want: &pb.GoTest{
-			F_BoolRepeated:   []bool{},
-			F_Int32Repeated:  []int32{},
-			F_Int64Repeated:  []int64{},
-			F_Uint32Repeated: []uint32{},
-			F_Uint64Repeated: []uint64{},
-			F_FloatRepeated:  []float32{},
-			F_DoubleRepeated: []float64{},
-			F_StringRepeated: []string{},
-			F_BytesRepeated:  [][]byte{},
-		},
-	},
-	{
-		src: &pb.GoTest{
-			F_BytesRepeated: [][]byte{nil, []byte{}, []byte{0}},
-		},
-		dst: &pb.GoTest{},
-		want: &pb.GoTest{
-			F_BytesRepeated: [][]byte{nil, []byte{}, []byte{0}},
-		},
-	},
-	{
-		src: &pb.MyMessage{
-			Others: []*pb.OtherMessage{},
-		},
-		dst: &pb.MyMessage{},
-		want: &pb.MyMessage{
-			Others: []*pb.OtherMessage{},
-		},
-	},
-}
-
-func TestMerge(t *testing.T) {
-	for _, m := range mergeTests {
-		got := proto.Clone(m.dst)
-		if !proto.Equal(got, m.dst) {
-			t.Errorf("Clone()\ngot  %v\nwant %v", got, m.dst)
-			continue
-		}
-		proto.Merge(got, m.src)
-		if !proto.Equal(got, m.want) {
-			t.Errorf("Merge(%v, %v)\ngot  %v\nwant %v", m.dst, m.src, got, m.want)
-		}
-	}
-}
diff --git a/vendor/github.com/golang/protobuf/proto/decode.go b/vendor/github.com/golang/protobuf/proto/decode.go
deleted file mode 100644
index d9aa3c42d..000000000
--- a/vendor/github.com/golang/protobuf/proto/decode.go
+++ /dev/null
@@ -1,428 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package proto
-
-/*
- * Routines for decoding protocol buffer data to construct in-memory representations.
- */
-
-import (
-	"errors"
-	"fmt"
-	"io"
-)
-
-// errOverflow is returned when an integer is too large to be represented.
-var errOverflow = errors.New("proto: integer overflow")
-
-// ErrInternalBadWireType is returned by generated code when an incorrect
-// wire type is encountered. It does not get returned to user code.
-var ErrInternalBadWireType = errors.New("proto: internal error: bad wiretype for oneof")
-
-// DecodeVarint reads a varint-encoded integer from the slice.
-// It returns the integer and the number of bytes consumed, or
-// zero if there is not enough.
-// This is the format for the
-// int32, int64, uint32, uint64, bool, and enum
-// protocol buffer types.
-func DecodeVarint(buf []byte) (x uint64, n int) {
-	for shift := uint(0); shift < 64; shift += 7 {
-		if n >= len(buf) {
-			return 0, 0
-		}
-		b := uint64(buf[n])
-		n++
-		x |= (b & 0x7F) << shift
-		if (b & 0x80) == 0 {
-			return x, n
-		}
-	}
-
-	// The number is too large to represent in a 64-bit value.
-	return 0, 0
-}
-
-func (p *Buffer) decodeVarintSlow() (x uint64, err error) {
-	i := p.index
-	l := len(p.buf)
-
-	for shift := uint(0); shift < 64; shift += 7 {
-		if i >= l {
-			err = io.ErrUnexpectedEOF
-			return
-		}
-		b := p.buf[i]
-		i++
-		x |= (uint64(b) & 0x7F) << shift
-		if b < 0x80 {
-			p.index = i
-			return
-		}
-	}
-
-	// The number is too large to represent in a 64-bit value.
-	err = errOverflow
-	return
-}
-
-// DecodeVarint reads a varint-encoded integer from the Buffer.
-// This is the format for the
-// int32, int64, uint32, uint64, bool, and enum
-// protocol buffer types.
-func (p *Buffer) DecodeVarint() (x uint64, err error) {
-	i := p.index
-	buf := p.buf
-
-	if i >= len(buf) {
-		return 0, io.ErrUnexpectedEOF
-	} else if buf[i] < 0x80 {
-		p.index++
-		return uint64(buf[i]), nil
-	} else if len(buf)-i < 10 {
-		return p.decodeVarintSlow()
-	}
-
-	var b uint64
-	// we already checked the first byte
-	x = uint64(buf[i]) - 0x80
-	i++
-
-	b = uint64(buf[i])
-	i++
-	x += b << 7
-	if b&0x80 == 0 {
-		goto done
-	}
-	x -= 0x80 << 7
-
-	b = uint64(buf[i])
-	i++
-	x += b << 14
-	if b&0x80 == 0 {
-		goto done
-	}
-	x -= 0x80 << 14
-
-	b = uint64(buf[i])
-	i++
-	x += b << 21
-	if b&0x80 == 0 {
-		goto done
-	}
-	x -= 0x80 << 21
-
-	b = uint64(buf[i])
-	i++
-	x += b << 28
-	if b&0x80 == 0 {
-		goto done
-	}
-	x -= 0x80 << 28
-
-	b = uint64(buf[i])
-	i++
-	x += b << 35
-	if b&0x80 == 0 {
-		goto done
-	}
-	x -= 0x80 << 35
-
-	b = uint64(buf[i])
-	i++
-	x += b << 42
-	if b&0x80 == 0 {
-		goto done
-	}
-	x -= 0x80 << 42
-
-	b = uint64(buf[i])
-	i++
-	x += b << 49
-	if b&0x80 == 0 {
-		goto done
-	}
-	x -= 0x80 << 49
-
-	b = uint64(buf[i])
-	i++
-	x += b << 56
-	if b&0x80 == 0 {
-		goto done
-	}
-	x -= 0x80 << 56
-
-	b = uint64(buf[i])
-	i++
-	x += b << 63
-	if b&0x80 == 0 {
-		goto done
-	}
-	// x -= 0x80 << 63 // Always zero.
-
-	return 0, errOverflow
-
-done:
-	p.index = i
-	return x, nil
-}
-
-// DecodeFixed64 reads a 64-bit integer from the Buffer.
-// This is the format for the
-// fixed64, sfixed64, and double protocol buffer types.
-func (p *Buffer) DecodeFixed64() (x uint64, err error) {
-	// x, err already 0
-	i := p.index + 8
-	if i < 0 || i > len(p.buf) {
-		err = io.ErrUnexpectedEOF
-		return
-	}
-	p.index = i
-
-	x = uint64(p.buf[i-8])
-	x |= uint64(p.buf[i-7]) << 8
-	x |= uint64(p.buf[i-6]) << 16
-	x |= uint64(p.buf[i-5]) << 24
-	x |= uint64(p.buf[i-4]) << 32
-	x |= uint64(p.buf[i-3]) << 40
-	x |= uint64(p.buf[i-2]) << 48
-	x |= uint64(p.buf[i-1]) << 56
-	return
-}
-
-// DecodeFixed32 reads a 32-bit integer from the Buffer.
-// This is the format for the
-// fixed32, sfixed32, and float protocol buffer types.
-func (p *Buffer) DecodeFixed32() (x uint64, err error) {
-	// x, err already 0
-	i := p.index + 4
-	if i < 0 || i > len(p.buf) {
-		err = io.ErrUnexpectedEOF
-		return
-	}
-	p.index = i
-
-	x = uint64(p.buf[i-4])
-	x |= uint64(p.buf[i-3]) << 8
-	x |= uint64(p.buf[i-2]) << 16
-	x |= uint64(p.buf[i-1]) << 24
-	return
-}
-
-// DecodeZigzag64 reads a zigzag-encoded 64-bit integer
-// from the Buffer.
-// This is the format used for the sint64 protocol buffer type.
-func (p *Buffer) DecodeZigzag64() (x uint64, err error) {
-	x, err = p.DecodeVarint()
-	if err != nil {
-		return
-	}
-	x = (x >> 1) ^ uint64((int64(x&1)<<63)>>63)
-	return
-}
-
-// DecodeZigzag32 reads a zigzag-encoded 32-bit integer
-// from  the Buffer.
-// This is the format used for the sint32 protocol buffer type.
-func (p *Buffer) DecodeZigzag32() (x uint64, err error) {
-	x, err = p.DecodeVarint()
-	if err != nil {
-		return
-	}
-	x = uint64((uint32(x) >> 1) ^ uint32((int32(x&1)<<31)>>31))
-	return
-}
-
-// DecodeRawBytes reads a count-delimited byte buffer from the Buffer.
-// This is the format used for the bytes protocol buffer
-// type and for embedded messages.
-func (p *Buffer) DecodeRawBytes(alloc bool) (buf []byte, err error) {
-	n, err := p.DecodeVarint()
-	if err != nil {
-		return nil, err
-	}
-
-	nb := int(n)
-	if nb < 0 {
-		return nil, fmt.Errorf("proto: bad byte length %d", nb)
-	}
-	end := p.index + nb
-	if end < p.index || end > len(p.buf) {
-		return nil, io.ErrUnexpectedEOF
-	}
-
-	if !alloc {
-		// todo: check if can get more uses of alloc=false
-		buf = p.buf[p.index:end]
-		p.index += nb
-		return
-	}
-
-	buf = make([]byte, nb)
-	copy(buf, p.buf[p.index:])
-	p.index += nb
-	return
-}
-
-// DecodeStringBytes reads an encoded string from the Buffer.
-// This is the format used for the proto2 string type.
-func (p *Buffer) DecodeStringBytes() (s string, err error) {
-	buf, err := p.DecodeRawBytes(false)
-	if err != nil {
-		return
-	}
-	return string(buf), nil
-}
-
-// Unmarshaler is the interface representing objects that can
-// unmarshal themselves.  The argument points to data that may be
-// overwritten, so implementations should not keep references to the
-// buffer.
-// Unmarshal implementations should not clear the receiver.
-// Any unmarshaled data should be merged into the receiver.
-// Callers of Unmarshal that do not want to retain existing data
-// should Reset the receiver before calling Unmarshal.
-type Unmarshaler interface {
-	Unmarshal([]byte) error
-}
-
-// newUnmarshaler is the interface representing objects that can
-// unmarshal themselves. The semantics are identical to Unmarshaler.
-//
-// This exists to support protoc-gen-go generated messages.
-// The proto package will stop type-asserting to this interface in the future.
-//
-// DO NOT DEPEND ON THIS.
-type newUnmarshaler interface {
-	XXX_Unmarshal([]byte) error
-}
-
-// Unmarshal parses the protocol buffer representation in buf and places the
-// decoded result in pb.  If the struct underlying pb does not match
-// the data in buf, the results can be unpredictable.
-//
-// Unmarshal resets pb before starting to unmarshal, so any
-// existing data in pb is always removed. Use UnmarshalMerge
-// to preserve and append to existing data.
-func Unmarshal(buf []byte, pb Message) error {
-	pb.Reset()
-	if u, ok := pb.(newUnmarshaler); ok {
-		return u.XXX_Unmarshal(buf)
-	}
-	if u, ok := pb.(Unmarshaler); ok {
-		return u.Unmarshal(buf)
-	}
-	return NewBuffer(buf).Unmarshal(pb)
-}
-
-// UnmarshalMerge parses the protocol buffer representation in buf and
-// writes the decoded result to pb.  If the struct underlying pb does not match
-// the data in buf, the results can be unpredictable.
-//
-// UnmarshalMerge merges into existing data in pb.
-// Most code should use Unmarshal instead.
-func UnmarshalMerge(buf []byte, pb Message) error {
-	if u, ok := pb.(newUnmarshaler); ok {
-		return u.XXX_Unmarshal(buf)
-	}
-	if u, ok := pb.(Unmarshaler); ok {
-		// NOTE: The history of proto have unfortunately been inconsistent
-		// whether Unmarshaler should or should not implicitly clear itself.
-		// Some implementations do, most do not.
-		// Thus, calling this here may or may not do what people want.
-		//
-		// See https://github.com/golang/protobuf/issues/424
-		return u.Unmarshal(buf)
-	}
-	return NewBuffer(buf).Unmarshal(pb)
-}
-
-// DecodeMessage reads a count-delimited message from the Buffer.
-func (p *Buffer) DecodeMessage(pb Message) error {
-	enc, err := p.DecodeRawBytes(false)
-	if err != nil {
-		return err
-	}
-	return NewBuffer(enc).Unmarshal(pb)
-}
-
-// DecodeGroup reads a tag-delimited group from the Buffer.
-// StartGroup tag is already consumed. This function consumes
-// EndGroup tag.
-func (p *Buffer) DecodeGroup(pb Message) error {
-	b := p.buf[p.index:]
-	x, y := findEndGroup(b)
-	if x < 0 {
-		return io.ErrUnexpectedEOF
-	}
-	err := Unmarshal(b[:x], pb)
-	p.index += y
-	return err
-}
-
-// Unmarshal parses the protocol buffer representation in the
-// Buffer and places the decoded result in pb.  If the struct
-// underlying pb does not match the data in the buffer, the results can be
-// unpredictable.
-//
-// Unlike proto.Unmarshal, this does not reset pb before starting to unmarshal.
-func (p *Buffer) Unmarshal(pb Message) error {
-	// If the object can unmarshal itself, let it.
-	if u, ok := pb.(newUnmarshaler); ok {
-		err := u.XXX_Unmarshal(p.buf[p.index:])
-		p.index = len(p.buf)
-		return err
-	}
-	if u, ok := pb.(Unmarshaler); ok {
-		// NOTE: The history of proto have unfortunately been inconsistent
-		// whether Unmarshaler should or should not implicitly clear itself.
-		// Some implementations do, most do not.
-		// Thus, calling this here may or may not do what people want.
-		//
-		// See https://github.com/golang/protobuf/issues/424
-		err := u.Unmarshal(p.buf[p.index:])
-		p.index = len(p.buf)
-		return err
-	}
-
-	// Slow workaround for messages that aren't Unmarshalers.
-	// This includes some hand-coded .pb.go files and
-	// bootstrap protos.
-	// TODO: fix all of those and then add Unmarshal to
-	// the Message interface. Then:
-	// The cast above and code below can be deleted.
-	// The old unmarshaler can be deleted.
-	// Clients can call Unmarshal directly (can already do that, actually).
-	var info InternalMessageInfo
-	err := info.Unmarshal(pb, p.buf[p.index:])
-	p.index = len(p.buf)
-	return err
-}
diff --git a/vendor/github.com/golang/protobuf/proto/decode_test.go b/vendor/github.com/golang/protobuf/proto/decode_test.go
deleted file mode 100644
index 949be3abd..000000000
--- a/vendor/github.com/golang/protobuf/proto/decode_test.go
+++ /dev/null
@@ -1,255 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// +build go1.7
-
-package proto_test
-
-import (
-	"fmt"
-	"testing"
-
-	"github.com/golang/protobuf/proto"
-	tpb "github.com/golang/protobuf/proto/proto3_proto"
-)
-
-var msgBlackhole = new(tpb.Message)
-
-// BenchmarkVarint32ArraySmall shows the performance on an array of small int32 fields (1 and
-// 2 bytes long).
-func BenchmarkVarint32ArraySmall(b *testing.B) {
-	for i := uint(1); i <= 10; i++ {
-		dist := genInt32Dist([7]int{0, 3, 1}, 1<<i)
-		raw, err := proto.Marshal(&tpb.Message{
-			ShortKey: dist,
-		})
-		if err != nil {
-			b.Error("wrong encode", err)
-		}
-		b.Run(fmt.Sprintf("Len%v", len(dist)), func(b *testing.B) {
-			scratchBuf := proto.NewBuffer(nil)
-			b.ResetTimer()
-			for k := 0; k < b.N; k++ {
-				scratchBuf.SetBuf(raw)
-				msgBlackhole.Reset()
-				if err := scratchBuf.Unmarshal(msgBlackhole); err != nil {
-					b.Error("wrong decode", err)
-				}
-			}
-		})
-	}
-}
-
-// BenchmarkVarint32ArrayLarge shows the performance on an array of large int32 fields (3 and
-// 4 bytes long, with a small number of 1, 2, 5 and 10 byte long versions).
-func BenchmarkVarint32ArrayLarge(b *testing.B) {
-	for i := uint(1); i <= 10; i++ {
-		dist := genInt32Dist([7]int{0, 1, 2, 4, 8, 1, 1}, 1<<i)
-		raw, err := proto.Marshal(&tpb.Message{
-			ShortKey: dist,
-		})
-		if err != nil {
-			b.Error("wrong encode", err)
-		}
-		b.Run(fmt.Sprintf("Len%v", len(dist)), func(b *testing.B) {
-			scratchBuf := proto.NewBuffer(nil)
-			b.ResetTimer()
-			for k := 0; k < b.N; k++ {
-				scratchBuf.SetBuf(raw)
-				msgBlackhole.Reset()
-				if err := scratchBuf.Unmarshal(msgBlackhole); err != nil {
-					b.Error("wrong decode", err)
-				}
-			}
-		})
-	}
-}
-
-// BenchmarkVarint64ArraySmall shows the performance on an array of small int64 fields (1 and
-// 2 bytes long).
-func BenchmarkVarint64ArraySmall(b *testing.B) {
-	for i := uint(1); i <= 10; i++ {
-		dist := genUint64Dist([11]int{0, 3, 1}, 1<<i)
-		raw, err := proto.Marshal(&tpb.Message{
-			Key: dist,
-		})
-		if err != nil {
-			b.Error("wrong encode", err)
-		}
-		b.Run(fmt.Sprintf("Len%v", len(dist)), func(b *testing.B) {
-			scratchBuf := proto.NewBuffer(nil)
-			b.ResetTimer()
-			for k := 0; k < b.N; k++ {
-				scratchBuf.SetBuf(raw)
-				msgBlackhole.Reset()
-				if err := scratchBuf.Unmarshal(msgBlackhole); err != nil {
-					b.Error("wrong decode", err)
-				}
-			}
-		})
-	}
-}
-
-// BenchmarkVarint64ArrayLarge shows the performance on an array of large int64 fields (6, 7,
-// and 8 bytes long with a small number of the other sizes).
-func BenchmarkVarint64ArrayLarge(b *testing.B) {
-	for i := uint(1); i <= 10; i++ {
-		dist := genUint64Dist([11]int{0, 1, 1, 2, 4, 8, 16, 32, 16, 1, 1}, 1<<i)
-		raw, err := proto.Marshal(&tpb.Message{
-			Key: dist,
-		})
-		if err != nil {
-			b.Error("wrong encode", err)
-		}
-		b.Run(fmt.Sprintf("Len%v", len(dist)), func(b *testing.B) {
-			scratchBuf := proto.NewBuffer(nil)
-			b.ResetTimer()
-			for k := 0; k < b.N; k++ {
-				scratchBuf.SetBuf(raw)
-				msgBlackhole.Reset()
-				if err := scratchBuf.Unmarshal(msgBlackhole); err != nil {
-					b.Error("wrong decode", err)
-				}
-			}
-		})
-	}
-}
-
-// BenchmarkVarint64ArrayMixed shows the performance of lots of small messages, each
-// containing a small number of large (3, 4, and 5 byte) repeated int64s.
-func BenchmarkVarint64ArrayMixed(b *testing.B) {
-	for i := uint(1); i <= 1<<5; i <<= 1 {
-		dist := genUint64Dist([11]int{0, 0, 0, 4, 6, 4, 0, 0, 0, 0, 0}, int(i))
-		// number of sub fields
-		for k := uint(1); k <= 1<<10; k <<= 2 {
-			msg := &tpb.Message{}
-			for m := uint(0); m < k; m++ {
-				msg.Children = append(msg.Children, &tpb.Message{
-					Key: dist,
-				})
-			}
-			raw, err := proto.Marshal(msg)
-			if err != nil {
-				b.Error("wrong encode", err)
-			}
-			b.Run(fmt.Sprintf("Fields%vLen%v", k, i), func(b *testing.B) {
-				scratchBuf := proto.NewBuffer(nil)
-				b.ResetTimer()
-				for k := 0; k < b.N; k++ {
-					scratchBuf.SetBuf(raw)
-					msgBlackhole.Reset()
-					if err := scratchBuf.Unmarshal(msgBlackhole); err != nil {
-						b.Error("wrong decode", err)
-					}
-				}
-			})
-		}
-	}
-}
-
-// genInt32Dist generates a slice of ints that will match the size distribution of dist.
-// A size of 6 corresponds to a max length varint32, which is 10 bytes.  The distribution
-// is 1-indexed. (i.e. the value at index 1 is how many 1 byte ints to create).
-func genInt32Dist(dist [7]int, count int) (dest []int32) {
-	for i := 0; i < count; i++ {
-		for k := 0; k < len(dist); k++ {
-			var num int32
-			switch k {
-			case 1:
-				num = 1<<7 - 1
-			case 2:
-				num = 1<<14 - 1
-			case 3:
-				num = 1<<21 - 1
-			case 4:
-				num = 1<<28 - 1
-			case 5:
-				num = 1<<29 - 1
-			case 6:
-				num = -1
-			}
-			for m := 0; m < dist[k]; m++ {
-				dest = append(dest, num)
-			}
-		}
-	}
-	return
-}
-
-// genUint64Dist generates a slice of ints that will match the size distribution of dist.
-// The distribution is 1-indexed. (i.e. the value at index 1 is how many 1 byte ints to create).
-func genUint64Dist(dist [11]int, count int) (dest []uint64) {
-	for i := 0; i < count; i++ {
-		for k := 0; k < len(dist); k++ {
-			var num uint64
-			switch k {
-			case 1:
-				num = 1<<7 - 1
-			case 2:
-				num = 1<<14 - 1
-			case 3:
-				num = 1<<21 - 1
-			case 4:
-				num = 1<<28 - 1
-			case 5:
-				num = 1<<35 - 1
-			case 6:
-				num = 1<<42 - 1
-			case 7:
-				num = 1<<49 - 1
-			case 8:
-				num = 1<<56 - 1
-			case 9:
-				num = 1<<63 - 1
-			case 10:
-				num = 1<<64 - 1
-			}
-			for m := 0; m < dist[k]; m++ {
-				dest = append(dest, num)
-			}
-		}
-	}
-	return
-}
-
-// BenchmarkDecodeEmpty measures the overhead of doing the minimal possible decode.
-func BenchmarkDecodeEmpty(b *testing.B) {
-	raw, err := proto.Marshal(&tpb.Message{})
-	if err != nil {
-		b.Error("wrong encode", err)
-	}
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		if err := proto.Unmarshal(raw, msgBlackhole); err != nil {
-			b.Error("wrong decode", err)
-		}
-	}
-}
diff --git a/vendor/github.com/golang/protobuf/proto/defaults.go b/vendor/github.com/golang/protobuf/proto/defaults.go
new file mode 100644
index 000000000..d399bf069
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/defaults.go
@@ -0,0 +1,63 @@
+// Copyright 2019 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 proto
+
+import (
+	"google.golang.org/protobuf/reflect/protoreflect"
+)
+
+// SetDefaults sets unpopulated scalar fields to their default values.
+// Fields within a oneof are not set even if they have a default value.
+// SetDefaults is recursively called upon any populated message fields.
+func SetDefaults(m Message) {
+	if m != nil {
+		setDefaults(MessageReflect(m))
+	}
+}
+
+func setDefaults(m protoreflect.Message) {
+	fds := m.Descriptor().Fields()
+	for i := 0; i < fds.Len(); i++ {
+		fd := fds.Get(i)
+		if !m.Has(fd) {
+			if fd.HasDefault() && fd.ContainingOneof() == nil {
+				v := fd.Default()
+				if fd.Kind() == protoreflect.BytesKind {
+					v = protoreflect.ValueOf(append([]byte(nil), v.Bytes()...)) // copy the default bytes
+				}
+				m.Set(fd, v)
+			}
+			continue
+		}
+	}
+
+	m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
+		switch {
+		// Handle singular message.
+		case fd.Cardinality() != protoreflect.Repeated:
+			if fd.Message() != nil {
+				setDefaults(m.Get(fd).Message())
+			}
+		// Handle list of messages.
+		case fd.IsList():
+			if fd.Message() != nil {
+				ls := m.Get(fd).List()
+				for i := 0; i < ls.Len(); i++ {
+					setDefaults(ls.Get(i).Message())
+				}
+			}
+		// Handle map of messages.
+		case fd.IsMap():
+			if fd.MapValue().Message() != nil {
+				ms := m.Get(fd).Map()
+				ms.Range(func(_ protoreflect.MapKey, v protoreflect.Value) bool {
+					setDefaults(v.Message())
+					return true
+				})
+			}
+		}
+		return true
+	})
+}
diff --git a/vendor/github.com/golang/protobuf/proto/deprecated.go b/vendor/github.com/golang/protobuf/proto/deprecated.go
new file mode 100644
index 000000000..e8db57e09
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/deprecated.go
@@ -0,0 +1,113 @@
+// 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 proto
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"strconv"
+
+	protoV2 "google.golang.org/protobuf/proto"
+)
+
+var (
+	// Deprecated: No longer returned.
+	ErrNil = errors.New("proto: Marshal called with nil")
+
+	// Deprecated: No longer returned.
+	ErrTooLarge = errors.New("proto: message encodes to over 2 GB")
+
+	// Deprecated: No longer returned.
+	ErrInternalBadWireType = errors.New("proto: internal error: bad wiretype for oneof")
+)
+
+// Deprecated: Do not use.
+type Stats struct{ Emalloc, Dmalloc, Encode, Decode, Chit, Cmiss, Size uint64 }
+
+// Deprecated: Do not use.
+func GetStats() Stats { return Stats{} }
+
+// Deprecated: Do not use.
+func MarshalMessageSet(interface{}) ([]byte, error) {
+	return nil, errors.New("proto: not implemented")
+}
+
+// Deprecated: Do not use.
+func UnmarshalMessageSet([]byte, interface{}) error {
+	return errors.New("proto: not implemented")
+}
+
+// Deprecated: Do not use.
+func MarshalMessageSetJSON(interface{}) ([]byte, error) {
+	return nil, errors.New("proto: not implemented")
+}
+
+// Deprecated: Do not use.
+func UnmarshalMessageSetJSON([]byte, interface{}) error {
+	return errors.New("proto: not implemented")
+}
+
+// Deprecated: Do not use.
+func RegisterMessageSetType(Message, int32, string) {}
+
+// Deprecated: Do not use.
+func EnumName(m map[int32]string, v int32) string {
+	s, ok := m[v]
+	if ok {
+		return s
+	}
+	return strconv.Itoa(int(v))
+}
+
+// Deprecated: Do not use.
+func UnmarshalJSONEnum(m map[string]int32, data []byte, enumName string) (int32, error) {
+	if data[0] == '"' {
+		// New style: enums are strings.
+		var repr string
+		if err := json.Unmarshal(data, &repr); err != nil {
+			return -1, err
+		}
+		val, ok := m[repr]
+		if !ok {
+			return 0, fmt.Errorf("unrecognized enum %s value %q", enumName, repr)
+		}
+		return val, nil
+	}
+	// Old style: enums are ints.
+	var val int32
+	if err := json.Unmarshal(data, &val); err != nil {
+		return 0, fmt.Errorf("cannot unmarshal %#q into enum %s", data, enumName)
+	}
+	return val, nil
+}
+
+// Deprecated: Do not use; this type existed for intenal-use only.
+type InternalMessageInfo struct{}
+
+// Deprecated: Do not use; this method existed for intenal-use only.
+func (*InternalMessageInfo) DiscardUnknown(m Message) {
+	DiscardUnknown(m)
+}
+
+// Deprecated: Do not use; this method existed for intenal-use only.
+func (*InternalMessageInfo) Marshal(b []byte, m Message, deterministic bool) ([]byte, error) {
+	return protoV2.MarshalOptions{Deterministic: deterministic}.MarshalAppend(b, MessageV2(m))
+}
+
+// Deprecated: Do not use; this method existed for intenal-use only.
+func (*InternalMessageInfo) Merge(dst, src Message) {
+	protoV2.Merge(MessageV2(dst), MessageV2(src))
+}
+
+// Deprecated: Do not use; this method existed for intenal-use only.
+func (*InternalMessageInfo) Size(m Message) int {
+	return protoV2.Size(MessageV2(m))
+}
+
+// Deprecated: Do not use; this method existed for intenal-use only.
+func (*InternalMessageInfo) Unmarshal(m Message, b []byte) error {
+	return protoV2.UnmarshalOptions{Merge: true}.Unmarshal(b, MessageV2(m))
+}
diff --git a/vendor/github.com/golang/protobuf/proto/discard.go b/vendor/github.com/golang/protobuf/proto/discard.go
index dea2617ce..2187e877f 100644
--- a/vendor/github.com/golang/protobuf/proto/discard.go
+++ b/vendor/github.com/golang/protobuf/proto/discard.go
@@ -1,48 +1,13 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2017 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// Copyright 2019 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 proto
 
 import (
-	"fmt"
-	"reflect"
-	"strings"
-	"sync"
-	"sync/atomic"
+	"google.golang.org/protobuf/reflect/protoreflect"
 )
 
-type generatedDiscarder interface {
-	XXX_DiscardUnknown()
-}
-
 // DiscardUnknown recursively discards all unknown fields from this message
 // and all embedded messages.
 //
@@ -51,300 +16,43 @@ type generatedDiscarder interface {
 // marshal to be able to produce a message that continues to have those
 // unrecognized fields. To avoid this, DiscardUnknown is used to
 // explicitly clear the unknown fields after unmarshaling.
-//
-// For proto2 messages, the unknown fields of message extensions are only
-// discarded from messages that have been accessed via GetExtension.
 func DiscardUnknown(m Message) {
-	if m, ok := m.(generatedDiscarder); ok {
-		m.XXX_DiscardUnknown()
-		return
-	}
-	// TODO: Dynamically populate a InternalMessageInfo for legacy messages,
-	// but the master branch has no implementation for InternalMessageInfo,
-	// so it would be more work to replicate that approach.
-	discardLegacy(m)
-}
-
-// DiscardUnknown recursively discards all unknown fields.
-func (a *InternalMessageInfo) DiscardUnknown(m Message) {
-	di := atomicLoadDiscardInfo(&a.discard)
-	if di == nil {
-		di = getDiscardInfo(reflect.TypeOf(m).Elem())
-		atomicStoreDiscardInfo(&a.discard, di)
-	}
-	di.discard(toPointer(&m))
-}
-
-type discardInfo struct {
-	typ reflect.Type
-
-	initialized int32 // 0: only typ is valid, 1: everything is valid
-	lock        sync.Mutex
-
-	fields       []discardFieldInfo
-	unrecognized field
-}
-
-type discardFieldInfo struct {
-	field   field // Offset of field, guaranteed to be valid
-	discard func(src pointer)
-}
-
-var (
-	discardInfoMap  = map[reflect.Type]*discardInfo{}
-	discardInfoLock sync.Mutex
-)
-
-func getDiscardInfo(t reflect.Type) *discardInfo {
-	discardInfoLock.Lock()
-	defer discardInfoLock.Unlock()
-	di := discardInfoMap[t]
-	if di == nil {
-		di = &discardInfo{typ: t}
-		discardInfoMap[t] = di
+	if m != nil {
+		discardUnknown(MessageReflect(m))
 	}
-	return di
 }
 
-func (di *discardInfo) discard(src pointer) {
-	if src.isNil() {
-		return // Nothing to do.
-	}
-
-	if atomic.LoadInt32(&di.initialized) == 0 {
-		di.computeDiscardInfo()
-	}
-
-	for _, fi := range di.fields {
-		sfp := src.offset(fi.field)
-		fi.discard(sfp)
-	}
-
-	// For proto2 messages, only discard unknown fields in message extensions
-	// that have been accessed via GetExtension.
-	if em, err := extendable(src.asPointerTo(di.typ).Interface()); err == nil {
-		// Ignore lock since DiscardUnknown is not concurrency safe.
-		emm, _ := em.extensionsRead()
-		for _, mx := range emm {
-			if m, ok := mx.value.(Message); ok {
-				DiscardUnknown(m)
+func discardUnknown(m protoreflect.Message) {
+	m.Range(func(fd protoreflect.FieldDescriptor, val protoreflect.Value) bool {
+		switch {
+		// Handle singular message.
+		case fd.Cardinality() != protoreflect.Repeated:
+			if fd.Message() != nil {
+				discardUnknown(m.Get(fd).Message())
 			}
-		}
-	}
-
-	if di.unrecognized.IsValid() {
-		*src.offset(di.unrecognized).toBytes() = nil
-	}
-}
-
-func (di *discardInfo) computeDiscardInfo() {
-	di.lock.Lock()
-	defer di.lock.Unlock()
-	if di.initialized != 0 {
-		return
-	}
-	t := di.typ
-	n := t.NumField()
-
-	for i := 0; i < n; i++ {
-		f := t.Field(i)
-		if strings.HasPrefix(f.Name, "XXX_") {
-			continue
-		}
-
-		dfi := discardFieldInfo{field: toField(&f)}
-		tf := f.Type
-
-		// Unwrap tf to get its most basic type.
-		var isPointer, isSlice bool
-		if tf.Kind() == reflect.Slice && tf.Elem().Kind() != reflect.Uint8 {
-			isSlice = true
-			tf = tf.Elem()
-		}
-		if tf.Kind() == reflect.Ptr {
-			isPointer = true
-			tf = tf.Elem()
-		}
-		if isPointer && isSlice && tf.Kind() != reflect.Struct {
-			panic(fmt.Sprintf("%v.%s cannot be a slice of pointers to primitive types", t, f.Name))
-		}
-
-		switch tf.Kind() {
-		case reflect.Struct:
-			switch {
-			case !isPointer:
-				panic(fmt.Sprintf("%v.%s cannot be a direct struct value", t, f.Name))
-			case isSlice: // E.g., []*pb.T
-				di := getDiscardInfo(tf)
-				dfi.discard = func(src pointer) {
-					sps := src.getPointerSlice()
-					for _, sp := range sps {
-						if !sp.isNil() {
-							di.discard(sp)
-						}
-					}
-				}
-			default: // E.g., *pb.T
-				di := getDiscardInfo(tf)
-				dfi.discard = func(src pointer) {
-					sp := src.getPointer()
-					if !sp.isNil() {
-						di.discard(sp)
-					}
+		// Handle list of messages.
+		case fd.IsList():
+			if fd.Message() != nil {
+				ls := m.Get(fd).List()
+				for i := 0; i < ls.Len(); i++ {
+					discardUnknown(ls.Get(i).Message())
 				}
 			}
-		case reflect.Map:
-			switch {
-			case isPointer || isSlice:
-				panic(fmt.Sprintf("%v.%s cannot be a pointer to a map or a slice of map values", t, f.Name))
-			default: // E.g., map[K]V
-				if tf.Elem().Kind() == reflect.Ptr { // Proto struct (e.g., *T)
-					dfi.discard = func(src pointer) {
-						sm := src.asPointerTo(tf).Elem()
-						if sm.Len() == 0 {
-							return
-						}
-						for _, key := range sm.MapKeys() {
-							val := sm.MapIndex(key)
-							DiscardUnknown(val.Interface().(Message))
-						}
-					}
-				} else {
-					dfi.discard = func(pointer) {} // Noop
-				}
-			}
-		case reflect.Interface:
-			// Must be oneof field.
-			switch {
-			case isPointer || isSlice:
-				panic(fmt.Sprintf("%v.%s cannot be a pointer to a interface or a slice of interface values", t, f.Name))
-			default: // E.g., interface{}
-				// TODO: Make this faster?
-				dfi.discard = func(src pointer) {
-					su := src.asPointerTo(tf).Elem()
-					if !su.IsNil() {
-						sv := su.Elem().Elem().Field(0)
-						if sv.Kind() == reflect.Ptr && sv.IsNil() {
-							return
-						}
-						switch sv.Type().Kind() {
-						case reflect.Ptr: // Proto struct (e.g., *T)
-							DiscardUnknown(sv.Interface().(Message))
-						}
-					}
-				}
+		// Handle map of messages.
+		case fd.IsMap():
+			if fd.MapValue().Message() != nil {
+				ms := m.Get(fd).Map()
+				ms.Range(func(_ protoreflect.MapKey, v protoreflect.Value) bool {
+					discardUnknown(v.Message())
+					return true
+				})
 			}
-		default:
-			continue
-		}
-		di.fields = append(di.fields, dfi)
-	}
-
-	di.unrecognized = invalidField
-	if f, ok := t.FieldByName("XXX_unrecognized"); ok {
-		if f.Type != reflect.TypeOf([]byte{}) {
-			panic("expected XXX_unrecognized to be of type []byte")
-		}
-		di.unrecognized = toField(&f)
-	}
-
-	atomic.StoreInt32(&di.initialized, 1)
-}
-
-func discardLegacy(m Message) {
-	v := reflect.ValueOf(m)
-	if v.Kind() != reflect.Ptr || v.IsNil() {
-		return
-	}
-	v = v.Elem()
-	if v.Kind() != reflect.Struct {
-		return
-	}
-	t := v.Type()
-
-	for i := 0; i < v.NumField(); i++ {
-		f := t.Field(i)
-		if strings.HasPrefix(f.Name, "XXX_") {
-			continue
 		}
-		vf := v.Field(i)
-		tf := f.Type
+		return true
+	})
 
-		// Unwrap tf to get its most basic type.
-		var isPointer, isSlice bool
-		if tf.Kind() == reflect.Slice && tf.Elem().Kind() != reflect.Uint8 {
-			isSlice = true
-			tf = tf.Elem()
-		}
-		if tf.Kind() == reflect.Ptr {
-			isPointer = true
-			tf = tf.Elem()
-		}
-		if isPointer && isSlice && tf.Kind() != reflect.Struct {
-			panic(fmt.Sprintf("%T.%s cannot be a slice of pointers to primitive types", m, f.Name))
-		}
-
-		switch tf.Kind() {
-		case reflect.Struct:
-			switch {
-			case !isPointer:
-				panic(fmt.Sprintf("%T.%s cannot be a direct struct value", m, f.Name))
-			case isSlice: // E.g., []*pb.T
-				for j := 0; j < vf.Len(); j++ {
-					discardLegacy(vf.Index(j).Interface().(Message))
-				}
-			default: // E.g., *pb.T
-				discardLegacy(vf.Interface().(Message))
-			}
-		case reflect.Map:
-			switch {
-			case isPointer || isSlice:
-				panic(fmt.Sprintf("%T.%s cannot be a pointer to a map or a slice of map values", m, f.Name))
-			default: // E.g., map[K]V
-				tv := vf.Type().Elem()
-				if tv.Kind() == reflect.Ptr && tv.Implements(protoMessageType) { // Proto struct (e.g., *T)
-					for _, key := range vf.MapKeys() {
-						val := vf.MapIndex(key)
-						discardLegacy(val.Interface().(Message))
-					}
-				}
-			}
-		case reflect.Interface:
-			// Must be oneof field.
-			switch {
-			case isPointer || isSlice:
-				panic(fmt.Sprintf("%T.%s cannot be a pointer to a interface or a slice of interface values", m, f.Name))
-			default: // E.g., test_proto.isCommunique_Union interface
-				if !vf.IsNil() && f.Tag.Get("protobuf_oneof") != "" {
-					vf = vf.Elem() // E.g., *test_proto.Communique_Msg
-					if !vf.IsNil() {
-						vf = vf.Elem()   // E.g., test_proto.Communique_Msg
-						vf = vf.Field(0) // E.g., Proto struct (e.g., *T) or primitive value
-						if vf.Kind() == reflect.Ptr {
-							discardLegacy(vf.Interface().(Message))
-						}
-					}
-				}
-			}
-		}
-	}
-
-	if vf := v.FieldByName("XXX_unrecognized"); vf.IsValid() {
-		if vf.Type() != reflect.TypeOf([]byte{}) {
-			panic("expected XXX_unrecognized to be of type []byte")
-		}
-		vf.Set(reflect.ValueOf([]byte(nil)))
-	}
-
-	// For proto2 messages, only discard unknown fields in message extensions
-	// that have been accessed via GetExtension.
-	if em, err := extendable(m); err == nil {
-		// Ignore lock since discardLegacy is not concurrency safe.
-		emm, _ := em.extensionsRead()
-		for _, mx := range emm {
-			if m, ok := mx.value.(Message); ok {
-				discardLegacy(m)
-			}
-		}
+	// Discard unknown fields.
+	if len(m.GetUnknown()) > 0 {
+		m.SetUnknown(nil)
 	}
 }
diff --git a/vendor/github.com/golang/protobuf/proto/discard_test.go b/vendor/github.com/golang/protobuf/proto/discard_test.go
index a2ff5509d..f850d9dec 100644
--- a/vendor/github.com/golang/protobuf/proto/discard_test.go
+++ b/vendor/github.com/golang/protobuf/proto/discard_test.go
@@ -1,33 +1,6 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2017 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// Copyright 2017 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 proto_test
 
@@ -35,11 +8,16 @@ import (
 	"testing"
 
 	"github.com/golang/protobuf/proto"
+	"google.golang.org/protobuf/testing/protopack"
 
-	proto3pb "github.com/golang/protobuf/proto/proto3_proto"
-	pb "github.com/golang/protobuf/proto/test_proto"
+	pb2 "github.com/golang/protobuf/internal/testprotos/proto2_proto"
+	pb3 "github.com/golang/protobuf/internal/testprotos/proto3_proto"
 )
 
+var rawFields = protopack.Message{
+	protopack.Tag{5, protopack.Fixed32Type}, protopack.Uint32(4041331395),
+}.Marshal()
+
 func TestDiscardUnknown(t *testing.T) {
 	tests := []struct {
 		desc     string
@@ -49,104 +27,85 @@ func TestDiscardUnknown(t *testing.T) {
 		in:   nil, want: nil, // Should not panic
 	}, {
 		desc: "NilPtr",
-		in:   (*proto3pb.Message)(nil), want: (*proto3pb.Message)(nil), // Should not panic
+		in:   (*pb3.Message)(nil), want: (*pb3.Message)(nil), // Should not panic
 	}, {
 		desc: "Nested",
-		in: &proto3pb.Message{
+		in: &pb3.Message{
 			Name:             "Aaron",
-			Nested:           &proto3pb.Nested{Cute: true, XXX_unrecognized: []byte("blah")},
-			XXX_unrecognized: []byte("blah"),
+			Nested:           &pb3.Nested{Cute: true, XXX_unrecognized: []byte(rawFields)},
+			XXX_unrecognized: []byte(rawFields),
 		},
-		want: &proto3pb.Message{
+		want: &pb3.Message{
 			Name:   "Aaron",
-			Nested: &proto3pb.Nested{Cute: true},
+			Nested: &pb3.Nested{Cute: true},
 		},
 	}, {
 		desc: "Slice",
-		in: &proto3pb.Message{
+		in: &pb3.Message{
 			Name: "Aaron",
-			Children: []*proto3pb.Message{
-				{Name: "Sarah", XXX_unrecognized: []byte("blah")},
-				{Name: "Abraham", XXX_unrecognized: []byte("blah")},
+			Children: []*pb3.Message{
+				{Name: "Sarah", XXX_unrecognized: []byte(rawFields)},
+				{Name: "Abraham", XXX_unrecognized: []byte(rawFields)},
 			},
-			XXX_unrecognized: []byte("blah"),
+			XXX_unrecognized: []byte(rawFields),
 		},
-		want: &proto3pb.Message{
+		want: &pb3.Message{
 			Name: "Aaron",
-			Children: []*proto3pb.Message{
+			Children: []*pb3.Message{
 				{Name: "Sarah"},
 				{Name: "Abraham"},
 			},
 		},
 	}, {
 		desc: "OneOf",
-		in: &pb.Communique{
-			Union: &pb.Communique_Msg{&pb.Strings{
+		in: &pb2.Communique{
+			Union: &pb2.Communique_Msg{&pb2.Strings{
 				StringField:      proto.String("123"),
-				XXX_unrecognized: []byte("blah"),
+				XXX_unrecognized: []byte(rawFields),
 			}},
-			XXX_unrecognized: []byte("blah"),
+			XXX_unrecognized: []byte(rawFields),
 		},
-		want: &pb.Communique{
-			Union: &pb.Communique_Msg{&pb.Strings{StringField: proto.String("123")}},
+		want: &pb2.Communique{
+			Union: &pb2.Communique_Msg{&pb2.Strings{StringField: proto.String("123")}},
 		},
 	}, {
 		desc: "Map",
-		in: &pb.MessageWithMap{MsgMapping: map[int64]*pb.FloatingPoint{
-			0x4002: &pb.FloatingPoint{
+		in: &pb2.MessageWithMap{MsgMapping: map[int64]*pb2.FloatingPoint{
+			0x4002: &pb2.FloatingPoint{
 				Exact:            proto.Bool(true),
-				XXX_unrecognized: []byte("blah"),
+				XXX_unrecognized: []byte(rawFields),
 			},
 		}},
-		want: &pb.MessageWithMap{MsgMapping: map[int64]*pb.FloatingPoint{
-			0x4002: &pb.FloatingPoint{Exact: proto.Bool(true)},
+		want: &pb2.MessageWithMap{MsgMapping: map[int64]*pb2.FloatingPoint{
+			0x4002: &pb2.FloatingPoint{Exact: proto.Bool(true)},
 		}},
 	}, {
 		desc: "Extension",
 		in: func() proto.Message {
-			m := &pb.MyMessage{
+			m := &pb2.MyMessage{
 				Count: proto.Int32(42),
-				Somegroup: &pb.MyMessage_SomeGroup{
+				Somegroup: &pb2.MyMessage_SomeGroup{
 					GroupField:       proto.Int32(6),
-					XXX_unrecognized: []byte("blah"),
+					XXX_unrecognized: []byte(rawFields),
 				},
-				XXX_unrecognized: []byte("blah"),
+				XXX_unrecognized: []byte(rawFields),
 			}
-			proto.SetExtension(m, pb.E_Ext_More, &pb.Ext{
+			proto.SetExtension(m, pb2.E_Ext_More, &pb2.Ext{
 				Data:             proto.String("extension"),
-				XXX_unrecognized: []byte("blah"),
+				XXX_unrecognized: []byte(rawFields),
 			})
 			return m
 		}(),
 		want: func() proto.Message {
-			m := &pb.MyMessage{
+			m := &pb2.MyMessage{
 				Count:     proto.Int32(42),
-				Somegroup: &pb.MyMessage_SomeGroup{GroupField: proto.Int32(6)},
+				Somegroup: &pb2.MyMessage_SomeGroup{GroupField: proto.Int32(6)},
 			}
-			proto.SetExtension(m, pb.E_Ext_More, &pb.Ext{Data: proto.String("extension")})
+			proto.SetExtension(m, pb2.E_Ext_More, &pb2.Ext{Data: proto.String("extension")})
 			return m
 		}(),
 	}}
 
-	// Test the legacy code path.
-	for _, tt := range tests {
-		// Clone the input so that we don't alter the original.
-		in := tt.in
-		if in != nil {
-			in = proto.Clone(tt.in)
-		}
-
-		var m LegacyMessage
-		m.Message, _ = in.(*proto3pb.Message)
-		m.Communique, _ = in.(*pb.Communique)
-		m.MessageWithMap, _ = in.(*pb.MessageWithMap)
-		m.MyMessage, _ = in.(*pb.MyMessage)
-		proto.DiscardUnknown(&m)
-		if !proto.Equal(in, tt.want) {
-			t.Errorf("test %s/Legacy, expected unknown fields to be discarded\ngot  %v\nwant %v", tt.desc, in, tt.want)
-		}
-	}
-
 	for _, tt := range tests {
 		proto.DiscardUnknown(tt.in)
 		if !proto.Equal(tt.in, tt.want) {
@@ -154,17 +113,3 @@ func TestDiscardUnknown(t *testing.T) {
 		}
 	}
 }
-
-// LegacyMessage is a proto.Message that has several nested messages.
-// This does not have the XXX_DiscardUnknown method and so forces DiscardUnknown
-// to use the legacy fallback logic.
-type LegacyMessage struct {
-	Message        *proto3pb.Message
-	Communique     *pb.Communique
-	MessageWithMap *pb.MessageWithMap
-	MyMessage      *pb.MyMessage
-}
-
-func (m *LegacyMessage) Reset()         { *m = LegacyMessage{} }
-func (m *LegacyMessage) String() string { return proto.CompactTextString(m) }
-func (*LegacyMessage) ProtoMessage()    {}
diff --git a/vendor/github.com/golang/protobuf/proto/encode.go b/vendor/github.com/golang/protobuf/proto/encode.go
deleted file mode 100644
index 4c35d3373..000000000
--- a/vendor/github.com/golang/protobuf/proto/encode.go
+++ /dev/null
@@ -1,218 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package proto
-
-/*
- * Routines for encoding data into the wire format for protocol buffers.
- */
-
-import (
-	"errors"
-	"fmt"
-	"reflect"
-)
-
-// RequiredNotSetError is an error type returned by either Marshal or Unmarshal.
-// Marshal reports this when a required field is not initialized.
-// Unmarshal reports this when a required field is missing from the wire data.
-type RequiredNotSetError struct {
-	field string
-}
-
-func (e *RequiredNotSetError) Error() string {
-	if e.field == "" {
-		return fmt.Sprintf("proto: required field not set")
-	}
-	return fmt.Sprintf("proto: required field %q not set", e.field)
-}
-
-var (
-	// errRepeatedHasNil is the error returned if Marshal is called with
-	// a struct with a repeated field containing a nil element.
-	errRepeatedHasNil = errors.New("proto: repeated field has nil element")
-
-	// errOneofHasNil is the error returned if Marshal is called with
-	// a struct with a oneof field containing a nil element.
-	errOneofHasNil = errors.New("proto: oneof field has nil value")
-
-	// ErrNil is the error returned if Marshal is called with nil.
-	ErrNil = errors.New("proto: Marshal called with nil")
-
-	// ErrTooLarge is the error returned if Marshal is called with a
-	// message that encodes to >2GB.
-	ErrTooLarge = errors.New("proto: message encodes to over 2 GB")
-)
-
-// The fundamental encoders that put bytes on the wire.
-// Those that take integer types all accept uint64 and are
-// therefore of type valueEncoder.
-
-const maxVarintBytes = 10 // maximum length of a varint
-
-// EncodeVarint returns the varint encoding of x.
-// This is the format for the
-// int32, int64, uint32, uint64, bool, and enum
-// protocol buffer types.
-// Not used by the package itself, but helpful to clients
-// wishing to use the same encoding.
-func EncodeVarint(x uint64) []byte {
-	var buf [maxVarintBytes]byte
-	var n int
-	for n = 0; x > 127; n++ {
-		buf[n] = 0x80 | uint8(x&0x7F)
-		x >>= 7
-	}
-	buf[n] = uint8(x)
-	n++
-	return buf[0:n]
-}
-
-// EncodeVarint writes a varint-encoded integer to the Buffer.
-// This is the format for the
-// int32, int64, uint32, uint64, bool, and enum
-// protocol buffer types.
-func (p *Buffer) EncodeVarint(x uint64) error {
-	for x >= 1<<7 {
-		p.buf = append(p.buf, uint8(x&0x7f|0x80))
-		x >>= 7
-	}
-	p.buf = append(p.buf, uint8(x))
-	return nil
-}
-
-// SizeVarint returns the varint encoding size of an integer.
-func SizeVarint(x uint64) int {
-	switch {
-	case x < 1<<7:
-		return 1
-	case x < 1<<14:
-		return 2
-	case x < 1<<21:
-		return 3
-	case x < 1<<28:
-		return 4
-	case x < 1<<35:
-		return 5
-	case x < 1<<42:
-		return 6
-	case x < 1<<49:
-		return 7
-	case x < 1<<56:
-		return 8
-	case x < 1<<63:
-		return 9
-	}
-	return 10
-}
-
-// EncodeFixed64 writes a 64-bit integer to the Buffer.
-// This is the format for the
-// fixed64, sfixed64, and double protocol buffer types.
-func (p *Buffer) EncodeFixed64(x uint64) error {
-	p.buf = append(p.buf,
-		uint8(x),
-		uint8(x>>8),
-		uint8(x>>16),
-		uint8(x>>24),
-		uint8(x>>32),
-		uint8(x>>40),
-		uint8(x>>48),
-		uint8(x>>56))
-	return nil
-}
-
-// EncodeFixed32 writes a 32-bit integer to the Buffer.
-// This is the format for the
-// fixed32, sfixed32, and float protocol buffer types.
-func (p *Buffer) EncodeFixed32(x uint64) error {
-	p.buf = append(p.buf,
-		uint8(x),
-		uint8(x>>8),
-		uint8(x>>16),
-		uint8(x>>24))
-	return nil
-}
-
-// EncodeZigzag64 writes a zigzag-encoded 64-bit integer
-// to the Buffer.
-// This is the format used for the sint64 protocol buffer type.
-func (p *Buffer) EncodeZigzag64(x uint64) error {
-	// use signed number to get arithmetic right shift.
-	return p.EncodeVarint(uint64((x << 1) ^ uint64((int64(x) >> 63))))
-}
-
-// EncodeZigzag32 writes a zigzag-encoded 32-bit integer
-// to the Buffer.
-// This is the format used for the sint32 protocol buffer type.
-func (p *Buffer) EncodeZigzag32(x uint64) error {
-	// use signed number to get arithmetic right shift.
-	return p.EncodeVarint(uint64((uint32(x) << 1) ^ uint32((int32(x) >> 31))))
-}
-
-// EncodeRawBytes writes a count-delimited byte buffer to the Buffer.
-// This is the format used for the bytes protocol buffer
-// type and for embedded messages.
-func (p *Buffer) EncodeRawBytes(b []byte) error {
-	p.EncodeVarint(uint64(len(b)))
-	p.buf = append(p.buf, b...)
-	return nil
-}
-
-// EncodeStringBytes writes an encoded string to the Buffer.
-// This is the format used for the proto2 string type.
-func (p *Buffer) EncodeStringBytes(s string) error {
-	p.EncodeVarint(uint64(len(s)))
-	p.buf = append(p.buf, s...)
-	return nil
-}
-
-// Marshaler is the interface representing objects that can marshal themselves.
-type Marshaler interface {
-	Marshal() ([]byte, error)
-}
-
-// EncodeMessage writes the protocol buffer to the Buffer,
-// prefixed by a varint-encoded length.
-func (p *Buffer) EncodeMessage(pb Message) error {
-	siz := Size(pb)
-	p.EncodeVarint(uint64(siz))
-	return p.Marshal(pb)
-}
-
-// All protocol buffer fields are nillable, but be careful.
-func isNil(v reflect.Value) bool {
-	switch v.Kind() {
-	case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
-		return v.IsNil()
-	}
-	return false
-}
diff --git a/vendor/github.com/golang/protobuf/proto/encode_test.go b/vendor/github.com/golang/protobuf/proto/encode_test.go
deleted file mode 100644
index a7209475f..000000000
--- a/vendor/github.com/golang/protobuf/proto/encode_test.go
+++ /dev/null
@@ -1,85 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// +build go1.7
-
-package proto_test
-
-import (
-	"strconv"
-	"testing"
-
-	"github.com/golang/protobuf/proto"
-	tpb "github.com/golang/protobuf/proto/proto3_proto"
-	"github.com/golang/protobuf/ptypes"
-)
-
-var (
-	blackhole []byte
-)
-
-// BenchmarkAny creates increasingly large arbitrary Any messages.  The type is always the
-// same.
-func BenchmarkAny(b *testing.B) {
-	data := make([]byte, 1<<20)
-	quantum := 1 << 10
-	for i := uint(0); i <= 10; i++ {
-		b.Run(strconv.Itoa(quantum<<i), func(b *testing.B) {
-			for k := 0; k < b.N; k++ {
-				inner := &tpb.Message{
-					Data: data[:quantum<<i],
-				}
-				outer, err := ptypes.MarshalAny(inner)
-				if err != nil {
-					b.Error("wrong encode", err)
-				}
-				raw, err := proto.Marshal(&tpb.Message{
-					Anything: outer,
-				})
-				if err != nil {
-					b.Error("wrong encode", err)
-				}
-				blackhole = raw
-			}
-		})
-	}
-}
-
-// BenchmarkEmpy measures the overhead of doing the minimal possible encode.
-func BenchmarkEmpy(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		raw, err := proto.Marshal(&tpb.Message{})
-		if err != nil {
-			b.Error("wrong encode", err)
-		}
-		blackhole = raw
-	}
-}
diff --git a/vendor/github.com/golang/protobuf/proto/equal.go b/vendor/github.com/golang/protobuf/proto/equal.go
deleted file mode 100644
index d4db5a1c1..000000000
--- a/vendor/github.com/golang/protobuf/proto/equal.go
+++ /dev/null
@@ -1,300 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2011 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Protocol buffer comparison.
-
-package proto
-
-import (
-	"bytes"
-	"log"
-	"reflect"
-	"strings"
-)
-
-/*
-Equal returns true iff protocol buffers a and b are equal.
-The arguments must both be pointers to protocol buffer structs.
-
-Equality is defined in this way:
-  - Two messages are equal iff they are the same type,
-    corresponding fields are equal, unknown field sets
-    are equal, and extensions sets are equal.
-  - Two set scalar fields are equal iff their values are equal.
-    If the fields are of a floating-point type, remember that
-    NaN != x for all x, including NaN. If the message is defined
-    in a proto3 .proto file, fields are not "set"; specifically,
-    zero length proto3 "bytes" fields are equal (nil == {}).
-  - Two repeated fields are equal iff their lengths are the same,
-    and their corresponding elements are equal. Note a "bytes" field,
-    although represented by []byte, is not a repeated field and the
-    rule for the scalar fields described above applies.
-  - Two unset fields are equal.
-  - Two unknown field sets are equal if their current
-    encoded state is equal.
-  - Two extension sets are equal iff they have corresponding
-    elements that are pairwise equal.
-  - Two map fields are equal iff their lengths are the same,
-    and they contain the same set of elements. Zero-length map
-    fields are equal.
-  - Every other combination of things are not equal.
-
-The return value is undefined if a and b are not protocol buffers.
-*/
-func Equal(a, b Message) bool {
-	if a == nil || b == nil {
-		return a == b
-	}
-	v1, v2 := reflect.ValueOf(a), reflect.ValueOf(b)
-	if v1.Type() != v2.Type() {
-		return false
-	}
-	if v1.Kind() == reflect.Ptr {
-		if v1.IsNil() {
-			return v2.IsNil()
-		}
-		if v2.IsNil() {
-			return false
-		}
-		v1, v2 = v1.Elem(), v2.Elem()
-	}
-	if v1.Kind() != reflect.Struct {
-		return false
-	}
-	return equalStruct(v1, v2)
-}
-
-// v1 and v2 are known to have the same type.
-func equalStruct(v1, v2 reflect.Value) bool {
-	sprop := GetProperties(v1.Type())
-	for i := 0; i < v1.NumField(); i++ {
-		f := v1.Type().Field(i)
-		if strings.HasPrefix(f.Name, "XXX_") {
-			continue
-		}
-		f1, f2 := v1.Field(i), v2.Field(i)
-		if f.Type.Kind() == reflect.Ptr {
-			if n1, n2 := f1.IsNil(), f2.IsNil(); n1 && n2 {
-				// both unset
-				continue
-			} else if n1 != n2 {
-				// set/unset mismatch
-				return false
-			}
-			f1, f2 = f1.Elem(), f2.Elem()
-		}
-		if !equalAny(f1, f2, sprop.Prop[i]) {
-			return false
-		}
-	}
-
-	if em1 := v1.FieldByName("XXX_InternalExtensions"); em1.IsValid() {
-		em2 := v2.FieldByName("XXX_InternalExtensions")
-		if !equalExtensions(v1.Type(), em1.Interface().(XXX_InternalExtensions), em2.Interface().(XXX_InternalExtensions)) {
-			return false
-		}
-	}
-
-	if em1 := v1.FieldByName("XXX_extensions"); em1.IsValid() {
-		em2 := v2.FieldByName("XXX_extensions")
-		if !equalExtMap(v1.Type(), em1.Interface().(map[int32]Extension), em2.Interface().(map[int32]Extension)) {
-			return false
-		}
-	}
-
-	uf := v1.FieldByName("XXX_unrecognized")
-	if !uf.IsValid() {
-		return true
-	}
-
-	u1 := uf.Bytes()
-	u2 := v2.FieldByName("XXX_unrecognized").Bytes()
-	return bytes.Equal(u1, u2)
-}
-
-// v1 and v2 are known to have the same type.
-// prop may be nil.
-func equalAny(v1, v2 reflect.Value, prop *Properties) bool {
-	if v1.Type() == protoMessageType {
-		m1, _ := v1.Interface().(Message)
-		m2, _ := v2.Interface().(Message)
-		return Equal(m1, m2)
-	}
-	switch v1.Kind() {
-	case reflect.Bool:
-		return v1.Bool() == v2.Bool()
-	case reflect.Float32, reflect.Float64:
-		return v1.Float() == v2.Float()
-	case reflect.Int32, reflect.Int64:
-		return v1.Int() == v2.Int()
-	case reflect.Interface:
-		// Probably a oneof field; compare the inner values.
-		n1, n2 := v1.IsNil(), v2.IsNil()
-		if n1 || n2 {
-			return n1 == n2
-		}
-		e1, e2 := v1.Elem(), v2.Elem()
-		if e1.Type() != e2.Type() {
-			return false
-		}
-		return equalAny(e1, e2, nil)
-	case reflect.Map:
-		if v1.Len() != v2.Len() {
-			return false
-		}
-		for _, key := range v1.MapKeys() {
-			val2 := v2.MapIndex(key)
-			if !val2.IsValid() {
-				// This key was not found in the second map.
-				return false
-			}
-			if !equalAny(v1.MapIndex(key), val2, nil) {
-				return false
-			}
-		}
-		return true
-	case reflect.Ptr:
-		// Maps may have nil values in them, so check for nil.
-		if v1.IsNil() && v2.IsNil() {
-			return true
-		}
-		if v1.IsNil() != v2.IsNil() {
-			return false
-		}
-		return equalAny(v1.Elem(), v2.Elem(), prop)
-	case reflect.Slice:
-		if v1.Type().Elem().Kind() == reflect.Uint8 {
-			// short circuit: []byte
-
-			// Edge case: if this is in a proto3 message, a zero length
-			// bytes field is considered the zero value.
-			if prop != nil && prop.proto3 && v1.Len() == 0 && v2.Len() == 0 {
-				return true
-			}
-			if v1.IsNil() != v2.IsNil() {
-				return false
-			}
-			return bytes.Equal(v1.Interface().([]byte), v2.Interface().([]byte))
-		}
-
-		if v1.Len() != v2.Len() {
-			return false
-		}
-		for i := 0; i < v1.Len(); i++ {
-			if !equalAny(v1.Index(i), v2.Index(i), prop) {
-				return false
-			}
-		}
-		return true
-	case reflect.String:
-		return v1.Interface().(string) == v2.Interface().(string)
-	case reflect.Struct:
-		return equalStruct(v1, v2)
-	case reflect.Uint32, reflect.Uint64:
-		return v1.Uint() == v2.Uint()
-	}
-
-	// unknown type, so not a protocol buffer
-	log.Printf("proto: don't know how to compare %v", v1)
-	return false
-}
-
-// base is the struct type that the extensions are based on.
-// x1 and x2 are InternalExtensions.
-func equalExtensions(base reflect.Type, x1, x2 XXX_InternalExtensions) bool {
-	em1, _ := x1.extensionsRead()
-	em2, _ := x2.extensionsRead()
-	return equalExtMap(base, em1, em2)
-}
-
-func equalExtMap(base reflect.Type, em1, em2 map[int32]Extension) bool {
-	if len(em1) != len(em2) {
-		return false
-	}
-
-	for extNum, e1 := range em1 {
-		e2, ok := em2[extNum]
-		if !ok {
-			return false
-		}
-
-		m1, m2 := e1.value, e2.value
-
-		if m1 == nil && m2 == nil {
-			// Both have only encoded form.
-			if bytes.Equal(e1.enc, e2.enc) {
-				continue
-			}
-			// The bytes are different, but the extensions might still be
-			// equal. We need to decode them to compare.
-		}
-
-		if m1 != nil && m2 != nil {
-			// Both are unencoded.
-			if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) {
-				return false
-			}
-			continue
-		}
-
-		// At least one is encoded. To do a semantically correct comparison
-		// we need to unmarshal them first.
-		var desc *ExtensionDesc
-		if m := extensionMaps[base]; m != nil {
-			desc = m[extNum]
-		}
-		if desc == nil {
-			// If both have only encoded form and the bytes are the same,
-			// it is handled above. We get here when the bytes are different.
-			// We don't know how to decode it, so just compare them as byte
-			// slices.
-			log.Printf("proto: don't know how to compare extension %d of %v", extNum, base)
-			return false
-		}
-		var err error
-		if m1 == nil {
-			m1, err = decodeExtension(e1.enc, desc)
-		}
-		if m2 == nil && err == nil {
-			m2, err = decodeExtension(e2.enc, desc)
-		}
-		if err != nil {
-			// The encoded form is invalid.
-			log.Printf("proto: badly encoded extension %d of %v: %v", extNum, base, err)
-			return false
-		}
-		if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) {
-			return false
-		}
-	}
-
-	return true
-}
diff --git a/vendor/github.com/golang/protobuf/proto/equal_test.go b/vendor/github.com/golang/protobuf/proto/equal_test.go
deleted file mode 100644
index 93ff88f3a..000000000
--- a/vendor/github.com/golang/protobuf/proto/equal_test.go
+++ /dev/null
@@ -1,244 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2011 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package proto_test
-
-import (
-	"testing"
-
-	. "github.com/golang/protobuf/proto"
-	proto3pb "github.com/golang/protobuf/proto/proto3_proto"
-	pb "github.com/golang/protobuf/proto/test_proto"
-)
-
-// Four identical base messages.
-// The init function adds extensions to some of them.
-var messageWithoutExtension = &pb.MyMessage{Count: Int32(7)}
-var messageWithExtension1a = &pb.MyMessage{Count: Int32(7)}
-var messageWithExtension1b = &pb.MyMessage{Count: Int32(7)}
-var messageWithExtension2 = &pb.MyMessage{Count: Int32(7)}
-var messageWithExtension3a = &pb.MyMessage{Count: Int32(7)}
-var messageWithExtension3b = &pb.MyMessage{Count: Int32(7)}
-var messageWithExtension3c = &pb.MyMessage{Count: Int32(7)}
-
-// Two messages with non-message extensions.
-var messageWithInt32Extension1 = &pb.MyMessage{Count: Int32(8)}
-var messageWithInt32Extension2 = &pb.MyMessage{Count: Int32(8)}
-
-func init() {
-	ext1 := &pb.Ext{Data: String("Kirk")}
-	ext2 := &pb.Ext{Data: String("Picard")}
-
-	// messageWithExtension1a has ext1, but never marshals it.
-	if err := SetExtension(messageWithExtension1a, pb.E_Ext_More, ext1); err != nil {
-		panic("SetExtension on 1a failed: " + err.Error())
-	}
-
-	// messageWithExtension1b is the unmarshaled form of messageWithExtension1a.
-	if err := SetExtension(messageWithExtension1b, pb.E_Ext_More, ext1); err != nil {
-		panic("SetExtension on 1b failed: " + err.Error())
-	}
-	buf, err := Marshal(messageWithExtension1b)
-	if err != nil {
-		panic("Marshal of 1b failed: " + err.Error())
-	}
-	messageWithExtension1b.Reset()
-	if err := Unmarshal(buf, messageWithExtension1b); err != nil {
-		panic("Unmarshal of 1b failed: " + err.Error())
-	}
-
-	// messageWithExtension2 has ext2.
-	if err := SetExtension(messageWithExtension2, pb.E_Ext_More, ext2); err != nil {
-		panic("SetExtension on 2 failed: " + err.Error())
-	}
-
-	if err := SetExtension(messageWithInt32Extension1, pb.E_Ext_Number, Int32(23)); err != nil {
-		panic("SetExtension on Int32-1 failed: " + err.Error())
-	}
-	if err := SetExtension(messageWithInt32Extension1, pb.E_Ext_Number, Int32(24)); err != nil {
-		panic("SetExtension on Int32-2 failed: " + err.Error())
-	}
-
-	// messageWithExtension3{a,b,c} has unregistered extension.
-	if RegisteredExtensions(messageWithExtension3a)[200] != nil {
-		panic("expect extension 200 unregistered")
-	}
-	bytes := []byte{
-		0xc0, 0x0c, 0x01, // id=200, wiretype=0 (varint), data=1
-	}
-	bytes2 := []byte{
-		0xc0, 0x0c, 0x02, // id=200, wiretype=0 (varint), data=2
-	}
-	SetRawExtension(messageWithExtension3a, 200, bytes)
-	SetRawExtension(messageWithExtension3b, 200, bytes)
-	SetRawExtension(messageWithExtension3c, 200, bytes2)
-}
-
-var EqualTests = []struct {
-	desc string
-	a, b Message
-	exp  bool
-}{
-	{"different types", &pb.GoEnum{}, &pb.GoTestField{}, false},
-	{"equal empty", &pb.GoEnum{}, &pb.GoEnum{}, true},
-	{"nil vs nil", nil, nil, true},
-	{"typed nil vs typed nil", (*pb.GoEnum)(nil), (*pb.GoEnum)(nil), true},
-	{"typed nil vs empty", (*pb.GoEnum)(nil), &pb.GoEnum{}, false},
-	{"different typed nil", (*pb.GoEnum)(nil), (*pb.GoTestField)(nil), false},
-
-	{"one set field, one unset field", &pb.GoTestField{Label: String("foo")}, &pb.GoTestField{}, false},
-	{"one set field zero, one unset field", &pb.GoTest{Param: Int32(0)}, &pb.GoTest{}, false},
-	{"different set fields", &pb.GoTestField{Label: String("foo")}, &pb.GoTestField{Label: String("bar")}, false},
-	{"equal set", &pb.GoTestField{Label: String("foo")}, &pb.GoTestField{Label: String("foo")}, true},
-
-	{"repeated, one set", &pb.GoTest{F_Int32Repeated: []int32{2, 3}}, &pb.GoTest{}, false},
-	{"repeated, different length", &pb.GoTest{F_Int32Repeated: []int32{2, 3}}, &pb.GoTest{F_Int32Repeated: []int32{2}}, false},
-	{"repeated, different value", &pb.GoTest{F_Int32Repeated: []int32{2}}, &pb.GoTest{F_Int32Repeated: []int32{3}}, false},
-	{"repeated, equal", &pb.GoTest{F_Int32Repeated: []int32{2, 4}}, &pb.GoTest{F_Int32Repeated: []int32{2, 4}}, true},
-	{"repeated, nil equal nil", &pb.GoTest{F_Int32Repeated: nil}, &pb.GoTest{F_Int32Repeated: nil}, true},
-	{"repeated, nil equal empty", &pb.GoTest{F_Int32Repeated: nil}, &pb.GoTest{F_Int32Repeated: []int32{}}, true},
-	{"repeated, empty equal nil", &pb.GoTest{F_Int32Repeated: []int32{}}, &pb.GoTest{F_Int32Repeated: nil}, true},
-
-	{
-		"nested, different",
-		&pb.GoTest{RequiredField: &pb.GoTestField{Label: String("foo")}},
-		&pb.GoTest{RequiredField: &pb.GoTestField{Label: String("bar")}},
-		false,
-	},
-	{
-		"nested, equal",
-		&pb.GoTest{RequiredField: &pb.GoTestField{Label: String("wow")}},
-		&pb.GoTest{RequiredField: &pb.GoTestField{Label: String("wow")}},
-		true,
-	},
-
-	{"bytes", &pb.OtherMessage{Value: []byte("foo")}, &pb.OtherMessage{Value: []byte("foo")}, true},
-	{"bytes, empty", &pb.OtherMessage{Value: []byte{}}, &pb.OtherMessage{Value: []byte{}}, true},
-	{"bytes, empty vs nil", &pb.OtherMessage{Value: []byte{}}, &pb.OtherMessage{Value: nil}, false},
-	{
-		"repeated bytes",
-		&pb.MyMessage{RepBytes: [][]byte{[]byte("sham"), []byte("wow")}},
-		&pb.MyMessage{RepBytes: [][]byte{[]byte("sham"), []byte("wow")}},
-		true,
-	},
-	// In proto3, []byte{} and []byte(nil) are equal.
-	{"proto3 bytes, empty vs nil", &proto3pb.Message{Data: []byte{}}, &proto3pb.Message{Data: nil}, true},
-
-	{"extension vs. no extension", messageWithoutExtension, messageWithExtension1a, false},
-	{"extension vs. same extension", messageWithExtension1a, messageWithExtension1b, true},
-	{"extension vs. different extension", messageWithExtension1a, messageWithExtension2, false},
-
-	{"int32 extension vs. itself", messageWithInt32Extension1, messageWithInt32Extension1, true},
-	{"int32 extension vs. a different int32", messageWithInt32Extension1, messageWithInt32Extension2, false},
-
-	{"unregistered extension same", messageWithExtension3a, messageWithExtension3b, true},
-	{"unregistered extension different", messageWithExtension3a, messageWithExtension3c, false},
-
-	{
-		"message with group",
-		&pb.MyMessage{
-			Count: Int32(1),
-			Somegroup: &pb.MyMessage_SomeGroup{
-				GroupField: Int32(5),
-			},
-		},
-		&pb.MyMessage{
-			Count: Int32(1),
-			Somegroup: &pb.MyMessage_SomeGroup{
-				GroupField: Int32(5),
-			},
-		},
-		true,
-	},
-
-	{
-		"map same",
-		&pb.MessageWithMap{NameMapping: map[int32]string{1: "Ken"}},
-		&pb.MessageWithMap{NameMapping: map[int32]string{1: "Ken"}},
-		true,
-	},
-	{
-		"map different entry",
-		&pb.MessageWithMap{NameMapping: map[int32]string{1: "Ken"}},
-		&pb.MessageWithMap{NameMapping: map[int32]string{2: "Rob"}},
-		false,
-	},
-	{
-		"map different key only",
-		&pb.MessageWithMap{NameMapping: map[int32]string{1: "Ken"}},
-		&pb.MessageWithMap{NameMapping: map[int32]string{2: "Ken"}},
-		false,
-	},
-	{
-		"map different value only",
-		&pb.MessageWithMap{NameMapping: map[int32]string{1: "Ken"}},
-		&pb.MessageWithMap{NameMapping: map[int32]string{1: "Rob"}},
-		false,
-	},
-	{
-		"zero-length maps same",
-		&pb.MessageWithMap{NameMapping: map[int32]string{}},
-		&pb.MessageWithMap{NameMapping: nil},
-		true,
-	},
-	{
-		"orders in map don't matter",
-		&pb.MessageWithMap{NameMapping: map[int32]string{1: "Ken", 2: "Rob"}},
-		&pb.MessageWithMap{NameMapping: map[int32]string{2: "Rob", 1: "Ken"}},
-		true,
-	},
-	{
-		"oneof same",
-		&pb.Communique{Union: &pb.Communique_Number{41}},
-		&pb.Communique{Union: &pb.Communique_Number{41}},
-		true,
-	},
-	{
-		"oneof one nil",
-		&pb.Communique{Union: &pb.Communique_Number{41}},
-		&pb.Communique{},
-		false,
-	},
-	{
-		"oneof different",
-		&pb.Communique{Union: &pb.Communique_Number{41}},
-		&pb.Communique{Union: &pb.Communique_Name{"Bobby Tables"}},
-		false,
-	},
-}
-
-func TestEqual(t *testing.T) {
-	for _, tc := range EqualTests {
-		if res := Equal(tc.a, tc.b); res != tc.exp {
-			t.Errorf("%v: Equal(%v, %v) = %v, want %v", tc.desc, tc.a, tc.b, res, tc.exp)
-		}
-	}
-}
diff --git a/vendor/github.com/golang/protobuf/proto/extensions.go b/vendor/github.com/golang/protobuf/proto/extensions.go
index 816a3b9d6..42fc120c9 100644
--- a/vendor/github.com/golang/protobuf/proto/extensions.go
+++ b/vendor/github.com/golang/protobuf/proto/extensions.go
@@ -1,543 +1,356 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// Copyright 2010 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 proto
 
-/*
- * Types and routines for supporting protocol buffer extensions.
- */
-
 import (
 	"errors"
 	"fmt"
-	"io"
 	"reflect"
-	"strconv"
-	"sync"
-)
-
-// ErrMissingExtension is the error returned by GetExtension if the named extension is not in the message.
-var ErrMissingExtension = errors.New("proto: missing extension")
 
-// ExtensionRange represents a range of message extensions for a protocol buffer.
-// Used in code generated by the protocol compiler.
-type ExtensionRange struct {
-	Start, End int32 // both inclusive
-}
-
-// extendableProto is an interface implemented by any protocol buffer generated by the current
-// proto compiler that may be extended.
-type extendableProto interface {
-	Message
-	ExtensionRangeArray() []ExtensionRange
-	extensionsWrite() map[int32]Extension
-	extensionsRead() (map[int32]Extension, sync.Locker)
-}
-
-// extendableProtoV1 is an interface implemented by a protocol buffer generated by the previous
-// version of the proto compiler that may be extended.
-type extendableProtoV1 interface {
-	Message
-	ExtensionRangeArray() []ExtensionRange
-	ExtensionMap() map[int32]Extension
-}
-
-// extensionAdapter is a wrapper around extendableProtoV1 that implements extendableProto.
-type extensionAdapter struct {
-	extendableProtoV1
-}
+	"google.golang.org/protobuf/encoding/protowire"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/reflect/protoregistry"
+	"google.golang.org/protobuf/runtime/protoiface"
+	"google.golang.org/protobuf/runtime/protoimpl"
+)
 
-func (e extensionAdapter) extensionsWrite() map[int32]Extension {
-	return e.ExtensionMap()
-}
+type (
+	// ExtensionDesc represents an extension descriptor and
+	// is used to interact with an extension field in a message.
+	//
+	// Variables of this type are generated in code by protoc-gen-go.
+	ExtensionDesc = protoimpl.ExtensionInfo
 
-func (e extensionAdapter) extensionsRead() (map[int32]Extension, sync.Locker) {
-	return e.ExtensionMap(), notLocker{}
-}
+	// ExtensionRange represents a range of message extensions.
+	// Used in code generated by protoc-gen-go.
+	ExtensionRange = protoiface.ExtensionRangeV1
 
-// notLocker is a sync.Locker whose Lock and Unlock methods are nops.
-type notLocker struct{}
+	// Deprecated: Do not use; this is an internal type.
+	Extension = protoimpl.ExtensionFieldV1
 
-func (n notLocker) Lock()   {}
-func (n notLocker) Unlock() {}
+	// Deprecated: Do not use; this is an internal type.
+	XXX_InternalExtensions = protoimpl.ExtensionFields
+)
 
-// extendable returns the extendableProto interface for the given generated proto message.
-// If the proto message has the old extension format, it returns a wrapper that implements
-// the extendableProto interface.
-func extendable(p interface{}) (extendableProto, error) {
-	switch p := p.(type) {
-	case extendableProto:
-		if isNilPtr(p) {
-			return nil, fmt.Errorf("proto: nil %T is not extendable", p)
-		}
-		return p, nil
-	case extendableProtoV1:
-		if isNilPtr(p) {
-			return nil, fmt.Errorf("proto: nil %T is not extendable", p)
-		}
-		return extensionAdapter{p}, nil
-	}
-	// Don't allocate a specific error containing %T:
-	// this is the hot path for Clone and MarshalText.
-	return nil, errNotExtendable
-}
+// ErrMissingExtension reports whether the extension was not present.
+var ErrMissingExtension = errors.New("proto: missing extension")
 
 var errNotExtendable = errors.New("proto: not an extendable proto.Message")
 
-func isNilPtr(x interface{}) bool {
-	v := reflect.ValueOf(x)
-	return v.Kind() == reflect.Ptr && v.IsNil()
-}
-
-// XXX_InternalExtensions is an internal representation of proto extensions.
-//
-// Each generated message struct type embeds an anonymous XXX_InternalExtensions field,
-// thus gaining the unexported 'extensions' method, which can be called only from the proto package.
-//
-// The methods of XXX_InternalExtensions are not concurrency safe in general,
-// but calls to logically read-only methods such as has and get may be executed concurrently.
-type XXX_InternalExtensions struct {
-	// The struct must be indirect so that if a user inadvertently copies a
-	// generated message and its embedded XXX_InternalExtensions, they
-	// avoid the mayhem of a copied mutex.
-	//
-	// The mutex serializes all logically read-only operations to p.extensionMap.
-	// It is up to the client to ensure that write operations to p.extensionMap are
-	// mutually exclusive with other accesses.
-	p *struct {
-		mu           sync.Mutex
-		extensionMap map[int32]Extension
+// HasExtension reports whether the extension field is present in m
+// either as an explicitly populated field or as an unknown field.
+func HasExtension(m Message, xt *ExtensionDesc) (has bool) {
+	mr := MessageReflect(m)
+	if mr == nil || !mr.IsValid() {
+		return false
 	}
-}
 
-// extensionsWrite returns the extension map, creating it on first use.
-func (e *XXX_InternalExtensions) extensionsWrite() map[int32]Extension {
-	if e.p == nil {
-		e.p = new(struct {
-			mu           sync.Mutex
-			extensionMap map[int32]Extension
+	// Check whether any populated known field matches the field number.
+	xtd := xt.TypeDescriptor()
+	if isValidExtension(mr.Descriptor(), xtd) {
+		has = mr.Has(xtd)
+	} else {
+		mr.Range(func(fd protoreflect.FieldDescriptor, _ protoreflect.Value) bool {
+			has = int32(fd.Number()) == xt.Field
+			return !has
 		})
-		e.p.extensionMap = make(map[int32]Extension)
 	}
-	return e.p.extensionMap
-}
 
-// extensionsRead returns the extensions map for read-only use.  It may be nil.
-// The caller must hold the returned mutex's lock when accessing Elements within the map.
-func (e *XXX_InternalExtensions) extensionsRead() (map[int32]Extension, sync.Locker) {
-	if e.p == nil {
-		return nil, nil
+	// Check whether any unknown field matches the field number.
+	for b := mr.GetUnknown(); !has && len(b) > 0; {
+		num, _, n := protowire.ConsumeField(b)
+		has = int32(num) == xt.Field
+		b = b[n:]
 	}
-	return e.p.extensionMap, &e.p.mu
-}
-
-// ExtensionDesc represents an extension specification.
-// Used in generated code from the protocol compiler.
-type ExtensionDesc struct {
-	ExtendedType  Message     // nil pointer to the type that is being extended
-	ExtensionType interface{} // nil pointer to the extension type
-	Field         int32       // field number
-	Name          string      // fully-qualified name of extension, for text formatting
-	Tag           string      // protobuf tag style
-	Filename      string      // name of the file in which the extension is defined
-}
-
-func (ed *ExtensionDesc) repeated() bool {
-	t := reflect.TypeOf(ed.ExtensionType)
-	return t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8
-}
-
-// Extension represents an extension in a message.
-type Extension struct {
-	// When an extension is stored in a message using SetExtension
-	// only desc and value are set. When the message is marshaled
-	// enc will be set to the encoded form of the message.
-	//
-	// When a message is unmarshaled and contains extensions, each
-	// extension will have only enc set. When such an extension is
-	// accessed using GetExtension (or GetExtensions) desc and value
-	// will be set.
-	desc  *ExtensionDesc
-	value interface{}
-	enc   []byte
+	return has
 }
 
-// SetRawExtension is for testing only.
-func SetRawExtension(base Message, id int32, b []byte) {
-	epb, err := extendable(base)
-	if err != nil {
+// ClearExtension removes the extension field from m
+// either as an explicitly populated field or as an unknown field.
+func ClearExtension(m Message, xt *ExtensionDesc) {
+	mr := MessageReflect(m)
+	if mr == nil || !mr.IsValid() {
 		return
 	}
-	extmap := epb.extensionsWrite()
-	extmap[id] = Extension{enc: b}
-}
 
-// isExtensionField returns true iff the given field number is in an extension range.
-func isExtensionField(pb extendableProto, field int32) bool {
-	for _, er := range pb.ExtensionRangeArray() {
-		if er.Start <= field && field <= er.End {
+	xtd := xt.TypeDescriptor()
+	if isValidExtension(mr.Descriptor(), xtd) {
+		mr.Clear(xtd)
+	} else {
+		mr.Range(func(fd protoreflect.FieldDescriptor, _ protoreflect.Value) bool {
+			if int32(fd.Number()) == xt.Field {
+				mr.Clear(fd)
+				return false
+			}
 			return true
-		}
-	}
-	return false
-}
-
-// checkExtensionTypes checks that the given extension is valid for pb.
-func checkExtensionTypes(pb extendableProto, extension *ExtensionDesc) error {
-	var pbi interface{} = pb
-	// Check the extended type.
-	if ea, ok := pbi.(extensionAdapter); ok {
-		pbi = ea.extendableProtoV1
-	}
-	if a, b := reflect.TypeOf(pbi), reflect.TypeOf(extension.ExtendedType); a != b {
-		return fmt.Errorf("proto: bad extended type; %v does not extend %v", b, a)
-	}
-	// Check the range.
-	if !isExtensionField(pb, extension.Field) {
-		return errors.New("proto: bad extension number; not in declared ranges")
-	}
-	return nil
-}
-
-// extPropKey is sufficient to uniquely identify an extension.
-type extPropKey struct {
-	base  reflect.Type
-	field int32
-}
-
-var extProp = struct {
-	sync.RWMutex
-	m map[extPropKey]*Properties
-}{
-	m: make(map[extPropKey]*Properties),
-}
-
-func extensionProperties(ed *ExtensionDesc) *Properties {
-	key := extPropKey{base: reflect.TypeOf(ed.ExtendedType), field: ed.Field}
-
-	extProp.RLock()
-	if prop, ok := extProp.m[key]; ok {
-		extProp.RUnlock()
-		return prop
-	}
-	extProp.RUnlock()
-
-	extProp.Lock()
-	defer extProp.Unlock()
-	// Check again.
-	if prop, ok := extProp.m[key]; ok {
-		return prop
-	}
-
-	prop := new(Properties)
-	prop.Init(reflect.TypeOf(ed.ExtensionType), "unknown_name", ed.Tag, nil)
-	extProp.m[key] = prop
-	return prop
-}
-
-// HasExtension returns whether the given extension is present in pb.
-func HasExtension(pb Message, extension *ExtensionDesc) bool {
-	// TODO: Check types, field numbers, etc.?
-	epb, err := extendable(pb)
-	if err != nil {
-		return false
-	}
-	extmap, mu := epb.extensionsRead()
-	if extmap == nil {
-		return false
+		})
 	}
-	mu.Lock()
-	_, ok := extmap[extension.Field]
-	mu.Unlock()
-	return ok
+	clearUnknown(mr, fieldNum(xt.Field))
 }
 
-// ClearExtension removes the given extension from pb.
-func ClearExtension(pb Message, extension *ExtensionDesc) {
-	epb, err := extendable(pb)
-	if err != nil {
+// ClearAllExtensions clears all extensions from m.
+// This includes populated fields and unknown fields in the extension range.
+func ClearAllExtensions(m Message) {
+	mr := MessageReflect(m)
+	if mr == nil || !mr.IsValid() {
 		return
 	}
-	// TODO: Check types, field numbers, etc.?
-	extmap := epb.extensionsWrite()
-	delete(extmap, extension.Field)
+
+	mr.Range(func(fd protoreflect.FieldDescriptor, _ protoreflect.Value) bool {
+		if fd.IsExtension() {
+			mr.Clear(fd)
+		}
+		return true
+	})
+	clearUnknown(mr, mr.Descriptor().ExtensionRanges())
 }
 
-// GetExtension retrieves a proto2 extended field from pb.
+// GetExtension retrieves a proto2 extended field from m.
 //
 // If the descriptor is type complete (i.e., ExtensionDesc.ExtensionType is non-nil),
 // then GetExtension parses the encoded field and returns a Go value of the specified type.
 // If the field is not present, then the default value is returned (if one is specified),
 // otherwise ErrMissingExtension is reported.
 //
-// If the descriptor is not type complete (i.e., ExtensionDesc.ExtensionType is nil),
-// then GetExtension returns the raw encoded bytes of the field extension.
-func GetExtension(pb Message, extension *ExtensionDesc) (interface{}, error) {
-	epb, err := extendable(pb)
-	if err != nil {
-		return nil, err
-	}
-
-	if extension.ExtendedType != nil {
-		// can only check type if this is a complete descriptor
-		if err := checkExtensionTypes(epb, extension); err != nil {
-			return nil, err
+// If the descriptor is type incomplete (i.e., ExtensionDesc.ExtensionType is nil),
+// then GetExtension returns the raw encoded bytes for the extension field.
+func GetExtension(m Message, xt *ExtensionDesc) (interface{}, error) {
+	mr := MessageReflect(m)
+	if mr == nil || !mr.IsValid() || mr.Descriptor().ExtensionRanges().Len() == 0 {
+		return nil, errNotExtendable
+	}
+
+	// Retrieve the unknown fields for this extension field.
+	var bo protoreflect.RawFields
+	for bi := mr.GetUnknown(); len(bi) > 0; {
+		num, _, n := protowire.ConsumeField(bi)
+		if int32(num) == xt.Field {
+			bo = append(bo, bi[:n]...)
 		}
+		bi = bi[n:]
 	}
 
-	emap, mu := epb.extensionsRead()
-	if emap == nil {
-		return defaultExtensionValue(extension)
-	}
-	mu.Lock()
-	defer mu.Unlock()
-	e, ok := emap[extension.Field]
-	if !ok {
-		// defaultExtensionValue returns the default value or
-		// ErrMissingExtension if there is no default.
-		return defaultExtensionValue(extension)
+	// For type incomplete descriptors, only retrieve the unknown fields.
+	if xt.ExtensionType == nil {
+		return []byte(bo), nil
 	}
 
-	if e.value != nil {
-		// Already decoded. Check the descriptor, though.
-		if e.desc != extension {
-			// This shouldn't happen. If it does, it means that
-			// GetExtension was called twice with two different
-			// descriptors with the same field number.
-			return nil, errors.New("proto: descriptor conflict")
+	// If the extension field only exists as unknown fields, unmarshal it.
+	// This is rarely done since proto.Unmarshal eagerly unmarshals extensions.
+	xtd := xt.TypeDescriptor()
+	if !isValidExtension(mr.Descriptor(), xtd) {
+		return nil, fmt.Errorf("proto: bad extended type; %T does not extend %T", xt.ExtendedType, m)
+	}
+	if !mr.Has(xtd) && len(bo) > 0 {
+		m2 := mr.New()
+		if err := (proto.UnmarshalOptions{
+			Resolver: extensionResolver{xt},
+		}.Unmarshal(bo, m2.Interface())); err != nil {
+			return nil, err
+		}
+		if m2.Has(xtd) {
+			mr.Set(xtd, m2.Get(xtd))
+			clearUnknown(mr, fieldNum(xt.Field))
 		}
-		return e.value, nil
 	}
 
-	if extension.ExtensionType == nil {
-		// incomplete descriptor
-		return e.enc, nil
+	// Check whether the message has the extension field set or a default.
+	var pv protoreflect.Value
+	switch {
+	case mr.Has(xtd):
+		pv = mr.Get(xtd)
+	case xtd.HasDefault():
+		pv = xtd.Default()
+	default:
+		return nil, ErrMissingExtension
 	}
 
-	v, err := decodeExtension(e.enc, extension)
-	if err != nil {
-		return nil, err
+	v := xt.InterfaceOf(pv)
+	rv := reflect.ValueOf(v)
+	if isScalarKind(rv.Kind()) {
+		rv2 := reflect.New(rv.Type())
+		rv2.Elem().Set(rv)
+		v = rv2.Interface()
 	}
-
-	// Remember the decoded version and drop the encoded version.
-	// That way it is safe to mutate what we return.
-	e.value = v
-	e.desc = extension
-	e.enc = nil
-	emap[extension.Field] = e
-	return e.value, nil
+	return v, nil
 }
 
-// defaultExtensionValue returns the default value for extension.
-// If no default for an extension is defined ErrMissingExtension is returned.
-func defaultExtensionValue(extension *ExtensionDesc) (interface{}, error) {
-	if extension.ExtensionType == nil {
-		// incomplete descriptor, so no default
-		return nil, ErrMissingExtension
-	}
-
-	t := reflect.TypeOf(extension.ExtensionType)
-	props := extensionProperties(extension)
+// extensionResolver is a custom extension resolver that stores a single
+// extension type that takes precedence over the global registry.
+type extensionResolver struct{ xt protoreflect.ExtensionType }
 
-	sf, _, err := fieldDefault(t, props)
-	if err != nil {
-		return nil, err
+func (r extensionResolver) FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error) {
+	if xtd := r.xt.TypeDescriptor(); xtd.FullName() == field {
+		return r.xt, nil
 	}
+	return protoregistry.GlobalTypes.FindExtensionByName(field)
+}
 
-	if sf == nil || sf.value == nil {
-		// There is no default value.
-		return nil, ErrMissingExtension
+func (r extensionResolver) FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error) {
+	if xtd := r.xt.TypeDescriptor(); xtd.ContainingMessage().FullName() == message && xtd.Number() == field {
+		return r.xt, nil
 	}
+	return protoregistry.GlobalTypes.FindExtensionByNumber(message, field)
+}
 
-	if t.Kind() != reflect.Ptr {
-		// We do not need to return a Ptr, we can directly return sf.value.
-		return sf.value, nil
+// GetExtensions returns a list of the extensions values present in m,
+// corresponding with the provided list of extension descriptors, xts.
+// If an extension is missing in m, the corresponding value is nil.
+func GetExtensions(m Message, xts []*ExtensionDesc) ([]interface{}, error) {
+	mr := MessageReflect(m)
+	if mr == nil || !mr.IsValid() {
+		return nil, errNotExtendable
 	}
 
-	// We need to return an interface{} that is a pointer to sf.value.
-	value := reflect.New(t).Elem()
-	value.Set(reflect.New(value.Type().Elem()))
-	if sf.kind == reflect.Int32 {
-		// We may have an int32 or an enum, but the underlying data is int32.
-		// Since we can't set an int32 into a non int32 reflect.value directly
-		// set it as a int32.
-		value.Elem().SetInt(int64(sf.value.(int32)))
-	} else {
-		value.Elem().Set(reflect.ValueOf(sf.value))
+	vs := make([]interface{}, len(xts))
+	for i, xt := range xts {
+		v, err := GetExtension(m, xt)
+		if err != nil {
+			if err == ErrMissingExtension {
+				continue
+			}
+			return vs, err
+		}
+		vs[i] = v
 	}
-	return value.Interface(), nil
+	return vs, nil
 }
 
-// decodeExtension decodes an extension encoded in b.
-func decodeExtension(b []byte, extension *ExtensionDesc) (interface{}, error) {
-	t := reflect.TypeOf(extension.ExtensionType)
-	unmarshal := typeUnmarshaler(t, extension.Tag)
-
-	// t is a pointer to a struct, pointer to basic type or a slice.
-	// Allocate space to store the pointer/slice.
-	value := reflect.New(t).Elem()
+// SetExtension sets an extension field in m to the provided value.
+func SetExtension(m Message, xt *ExtensionDesc, v interface{}) error {
+	mr := MessageReflect(m)
+	if mr == nil || !mr.IsValid() || mr.Descriptor().ExtensionRanges().Len() == 0 {
+		return errNotExtendable
+	}
 
-	var err error
-	for {
-		x, n := decodeVarint(b)
-		if n == 0 {
-			return nil, io.ErrUnexpectedEOF
+	rv := reflect.ValueOf(v)
+	if reflect.TypeOf(v) != reflect.TypeOf(xt.ExtensionType) {
+		return fmt.Errorf("proto: bad extension value type. got: %T, want: %T", v, xt.ExtensionType)
+	}
+	if rv.Kind() == reflect.Ptr {
+		if rv.IsNil() {
+			return fmt.Errorf("proto: SetExtension called with nil value of type %T", v)
 		}
-		b = b[n:]
-		wire := int(x) & 7
-
-		b, err = unmarshal(b, valToPointer(value.Addr()), wire)
-		if err != nil {
-			return nil, err
+		if isScalarKind(rv.Elem().Kind()) {
+			v = rv.Elem().Interface()
 		}
+	}
 
-		if len(b) == 0 {
-			break
-		}
+	xtd := xt.TypeDescriptor()
+	if !isValidExtension(mr.Descriptor(), xtd) {
+		return fmt.Errorf("proto: bad extended type; %T does not extend %T", xt.ExtendedType, m)
 	}
-	return value.Interface(), nil
+	mr.Set(xtd, xt.ValueOf(v))
+	clearUnknown(mr, fieldNum(xt.Field))
+	return nil
 }
 
-// GetExtensions returns a slice of the extensions present in pb that are also listed in es.
-// The returned slice has the same length as es; missing extensions will appear as nil elements.
-func GetExtensions(pb Message, es []*ExtensionDesc) (extensions []interface{}, err error) {
-	epb, err := extendable(pb)
-	if err != nil {
-		return nil, err
+// SetRawExtension inserts b into the unknown fields of m.
+//
+// Deprecated: Use Message.ProtoReflect.SetUnknown instead.
+func SetRawExtension(m Message, fnum int32, b []byte) {
+	mr := MessageReflect(m)
+	if mr == nil || !mr.IsValid() {
+		return
 	}
-	extensions = make([]interface{}, len(es))
-	for i, e := range es {
-		extensions[i], err = GetExtension(epb, e)
-		if err == ErrMissingExtension {
-			err = nil
-		}
-		if err != nil {
-			return
+
+	// Verify that the raw field is valid.
+	for b0 := b; len(b0) > 0; {
+		num, _, n := protowire.ConsumeField(b0)
+		if int32(num) != fnum {
+			panic(fmt.Sprintf("mismatching field number: got %d, want %d", num, fnum))
 		}
+		b0 = b0[n:]
 	}
-	return
-}
 
-// ExtensionDescs returns a new slice containing pb's extension descriptors, in undefined order.
-// For non-registered extensions, ExtensionDescs returns an incomplete descriptor containing
-// just the Field field, which defines the extension's field number.
-func ExtensionDescs(pb Message) ([]*ExtensionDesc, error) {
-	epb, err := extendable(pb)
-	if err != nil {
-		return nil, err
-	}
-	registeredExtensions := RegisteredExtensions(pb)
+	ClearExtension(m, &ExtensionDesc{Field: fnum})
+	mr.SetUnknown(append(mr.GetUnknown(), b...))
+}
 
-	emap, mu := epb.extensionsRead()
-	if emap == nil {
-		return nil, nil
-	}
-	mu.Lock()
-	defer mu.Unlock()
-	extensions := make([]*ExtensionDesc, 0, len(emap))
-	for extid, e := range emap {
-		desc := e.desc
-		if desc == nil {
-			desc = registeredExtensions[extid]
-			if desc == nil {
-				desc = &ExtensionDesc{Field: extid}
+// ExtensionDescs returns a list of extension descriptors found in m,
+// containing descriptors for both populated extension fields in m and
+// also unknown fields of m that are in the extension range.
+// For the later case, an type incomplete descriptor is provided where only
+// the ExtensionDesc.Field field is populated.
+// The order of the extension descriptors is undefined.
+func ExtensionDescs(m Message) ([]*ExtensionDesc, error) {
+	mr := MessageReflect(m)
+	if mr == nil || !mr.IsValid() || mr.Descriptor().ExtensionRanges().Len() == 0 {
+		return nil, errNotExtendable
+	}
+
+	// Collect a set of known extension descriptors.
+	extDescs := make(map[protoreflect.FieldNumber]*ExtensionDesc)
+	mr.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
+		if fd.IsExtension() {
+			xt := fd.(protoreflect.ExtensionTypeDescriptor)
+			if xd, ok := xt.Type().(*ExtensionDesc); ok {
+				extDescs[fd.Number()] = xd
 			}
 		}
-
-		extensions = append(extensions, desc)
+		return true
+	})
+
+	// Collect a set of unknown extension descriptors.
+	extRanges := mr.Descriptor().ExtensionRanges()
+	for b := mr.GetUnknown(); len(b) > 0; {
+		num, _, n := protowire.ConsumeField(b)
+		if extRanges.Has(num) && extDescs[num] == nil {
+			extDescs[num] = nil
+		}
+		b = b[n:]
 	}
-	return extensions, nil
-}
 
-// SetExtension sets the specified extension of pb to the specified value.
-func SetExtension(pb Message, extension *ExtensionDesc, value interface{}) error {
-	epb, err := extendable(pb)
-	if err != nil {
-		return err
-	}
-	if err := checkExtensionTypes(epb, extension); err != nil {
-		return err
-	}
-	typ := reflect.TypeOf(extension.ExtensionType)
-	if typ != reflect.TypeOf(value) {
-		return errors.New("proto: bad extension value type")
-	}
-	// nil extension values need to be caught early, because the
-	// encoder can't distinguish an ErrNil due to a nil extension
-	// from an ErrNil due to a missing field. Extensions are
-	// always optional, so the encoder would just swallow the error
-	// and drop all the extensions from the encoded message.
-	if reflect.ValueOf(value).IsNil() {
-		return fmt.Errorf("proto: SetExtension called with nil value of type %T", value)
+	// Transpose the set of descriptors into a list.
+	var xts []*ExtensionDesc
+	for num, xt := range extDescs {
+		if xt == nil {
+			xt = &ExtensionDesc{Field: int32(num)}
+		}
+		xts = append(xts, xt)
 	}
+	return xts, nil
+}
 
-	extmap := epb.extensionsWrite()
-	extmap[extension.Field] = Extension{desc: extension, value: value}
-	return nil
+// isValidExtension reports whether xtd is a valid extension descriptor for md.
+func isValidExtension(md protoreflect.MessageDescriptor, xtd protoreflect.ExtensionTypeDescriptor) bool {
+	return xtd.ContainingMessage() == md && md.ExtensionRanges().Has(xtd.Number())
 }
 
-// ClearAllExtensions clears all extensions from pb.
-func ClearAllExtensions(pb Message) {
-	epb, err := extendable(pb)
-	if err != nil {
-		return
-	}
-	m := epb.extensionsWrite()
-	for k := range m {
-		delete(m, k)
+// isScalarKind reports whether k is a protobuf scalar kind (except bytes).
+// This function exists for historical reasons since the representation of
+// scalars differs between v1 and v2, where v1 uses *T and v2 uses T.
+func isScalarKind(k reflect.Kind) bool {
+	switch k {
+	case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.String:
+		return true
+	default:
+		return false
 	}
 }
 
-// A global registry of extensions.
-// The generated code will register the generated descriptors by calling RegisterExtension.
-
-var extensionMaps = make(map[reflect.Type]map[int32]*ExtensionDesc)
-
-// RegisterExtension is called from the generated code.
-func RegisterExtension(desc *ExtensionDesc) {
-	st := reflect.TypeOf(desc.ExtendedType).Elem()
-	m := extensionMaps[st]
-	if m == nil {
-		m = make(map[int32]*ExtensionDesc)
-		extensionMaps[st] = m
+// clearUnknown removes unknown fields from m where remover.Has reports true.
+func clearUnknown(m protoreflect.Message, remover interface {
+	Has(protoreflect.FieldNumber) bool
+}) {
+	var bo protoreflect.RawFields
+	for bi := m.GetUnknown(); len(bi) > 0; {
+		num, _, n := protowire.ConsumeField(bi)
+		if !remover.Has(num) {
+			bo = append(bo, bi[:n]...)
+		}
+		bi = bi[n:]
 	}
-	if _, ok := m[desc.Field]; ok {
-		panic("proto: duplicate extension registered: " + st.String() + " " + strconv.Itoa(int(desc.Field)))
+	if bi := m.GetUnknown(); len(bi) != len(bo) {
+		m.SetUnknown(bo)
 	}
-	m[desc.Field] = desc
 }
 
-// RegisteredExtensions returns a map of the registered extensions of a
-// protocol buffer struct, indexed by the extension number.
-// The argument pb should be a nil pointer to the struct type.
-func RegisteredExtensions(pb Message) map[int32]*ExtensionDesc {
-	return extensionMaps[reflect.TypeOf(pb).Elem()]
+type fieldNum protoreflect.FieldNumber
+
+func (n1 fieldNum) Has(n2 protoreflect.FieldNumber) bool {
+	return protoreflect.FieldNumber(n1) == n2
 }
diff --git a/vendor/github.com/golang/protobuf/proto/extensions_test.go b/vendor/github.com/golang/protobuf/proto/extensions_test.go
index dc69fe971..597815942 100644
--- a/vendor/github.com/golang/protobuf/proto/extensions_test.go
+++ b/vendor/github.com/golang/protobuf/proto/extensions_test.go
@@ -1,59 +1,32 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2014 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// Copyright 2014 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 proto_test
 
 import (
 	"bytes"
 	"fmt"
-	"io"
 	"reflect"
 	"sort"
 	"strings"
+	"sync"
 	"testing"
 
 	"github.com/golang/protobuf/proto"
-	pb "github.com/golang/protobuf/proto/test_proto"
-	"golang.org/x/sync/errgroup"
+
+	pb2 "github.com/golang/protobuf/internal/testprotos/proto2_proto"
 )
 
 func TestGetExtensionsWithMissingExtensions(t *testing.T) {
-	msg := &pb.MyMessage{}
-	ext1 := &pb.Ext{}
-	if err := proto.SetExtension(msg, pb.E_Ext_More, ext1); err != nil {
+	msg := &pb2.MyMessage{}
+	ext1 := &pb2.Ext{}
+	if err := proto.SetExtension(msg, pb2.E_Ext_More, ext1); err != nil {
 		t.Fatalf("Could not set ext1: %s", err)
 	}
 	exts, err := proto.GetExtensions(msg, []*proto.ExtensionDesc{
-		pb.E_Ext_More,
-		pb.E_Ext_Text,
+		pb2.E_Ext_More,
+		pb2.E_Ext_Text,
 	})
 	if err != nil {
 		t.Fatalf("GetExtensions() failed: %s", err)
@@ -66,21 +39,10 @@ func TestGetExtensionsWithMissingExtensions(t *testing.T) {
 	}
 }
 
-func TestGetExtensionWithEmptyBuffer(t *testing.T) {
-	// Make sure that GetExtension returns an error if its
-	// undecoded buffer is empty.
-	msg := &pb.MyMessage{}
-	proto.SetRawExtension(msg, pb.E_Ext_More.Field, []byte{})
-	_, err := proto.GetExtension(msg, pb.E_Ext_More)
-	if want := io.ErrUnexpectedEOF; err != want {
-		t.Errorf("unexpected error in GetExtension from empty buffer: got %v, want %v", err, want)
-	}
-}
-
 func TestGetExtensionForIncompleteDesc(t *testing.T) {
-	msg := &pb.MyMessage{Count: proto.Int32(0)}
+	msg := &pb2.MyMessage{Count: proto.Int32(0)}
 	extdesc1 := &proto.ExtensionDesc{
-		ExtendedType:  (*pb.MyMessage)(nil),
+		ExtendedType:  (*pb2.MyMessage)(nil),
 		ExtensionType: (*bool)(nil),
 		Field:         123456789,
 		Name:          "a.b",
@@ -91,7 +53,7 @@ func TestGetExtensionForIncompleteDesc(t *testing.T) {
 		t.Fatalf("Could not set ext1: %s", err)
 	}
 	extdesc2 := &proto.ExtensionDesc{
-		ExtendedType:  (*pb.MyMessage)(nil),
+		ExtendedType:  (*pb2.MyMessage)(nil),
 		ExtensionType: ([]byte)(nil),
 		Field:         123456790,
 		Name:          "a.c",
@@ -102,13 +64,13 @@ func TestGetExtensionForIncompleteDesc(t *testing.T) {
 		t.Fatalf("Could not set ext2: %s", err)
 	}
 	extdesc3 := &proto.ExtensionDesc{
-		ExtendedType:  (*pb.MyMessage)(nil),
-		ExtensionType: (*pb.Ext)(nil),
+		ExtendedType:  (*pb2.MyMessage)(nil),
+		ExtensionType: (*pb2.Ext)(nil),
 		Field:         123456791,
 		Name:          "a.d",
 		Tag:           "bytes,123456791,opt",
 	}
-	ext3 := &pb.Ext{Data: proto.String("foo")}
+	ext3 := &pb2.Ext{Data: proto.String("foo")}
 	if err := proto.SetExtension(msg, extdesc3, ext3); err != nil {
 		t.Fatalf("Could not set ext3: %s", err)
 	}
@@ -167,18 +129,18 @@ func TestGetExtensionForIncompleteDesc(t *testing.T) {
 }
 
 func TestExtensionDescsWithUnregisteredExtensions(t *testing.T) {
-	msg := &pb.MyMessage{Count: proto.Int32(0)}
-	extdesc1 := pb.E_Ext_More
+	msg := &pb2.MyMessage{Count: proto.Int32(0)}
+	extdesc1 := pb2.E_Ext_More
 	if descs, err := proto.ExtensionDescs(msg); len(descs) != 0 || err != nil {
 		t.Errorf("proto.ExtensionDescs: got %d descs, error %v; want 0, nil", len(descs), err)
 	}
 
-	ext1 := &pb.Ext{}
+	ext1 := &pb2.Ext{}
 	if err := proto.SetExtension(msg, extdesc1, ext1); err != nil {
 		t.Fatalf("Could not set ext1: %s", err)
 	}
 	extdesc2 := &proto.ExtensionDesc{
-		ExtendedType:  (*pb.MyMessage)(nil),
+		ExtendedType:  (*pb2.MyMessage)(nil),
 		ExtensionType: (*bool)(nil),
 		Field:         123456789,
 		Name:          "a.b",
@@ -219,20 +181,20 @@ func sortExtDescs(s []*proto.ExtensionDesc) {
 }
 
 func TestGetExtensionStability(t *testing.T) {
-	check := func(m *pb.MyMessage) bool {
-		ext1, err := proto.GetExtension(m, pb.E_Ext_More)
+	check := func(m *pb2.MyMessage) bool {
+		ext1, err := proto.GetExtension(m, pb2.E_Ext_More)
 		if err != nil {
 			t.Fatalf("GetExtension() failed: %s", err)
 		}
-		ext2, err := proto.GetExtension(m, pb.E_Ext_More)
+		ext2, err := proto.GetExtension(m, pb2.E_Ext_More)
 		if err != nil {
 			t.Fatalf("GetExtension() failed: %s", err)
 		}
 		return ext1 == ext2
 	}
-	msg := &pb.MyMessage{Count: proto.Int32(4)}
-	ext0 := &pb.Ext{}
-	if err := proto.SetExtension(msg, pb.E_Ext_More, ext0); err != nil {
+	msg := &pb2.MyMessage{Count: proto.Int32(4)}
+	ext0 := &pb2.Ext{}
+	if err := proto.SetExtension(msg, pb2.E_Ext_More, ext0); err != nil {
 		t.Fatalf("Could not set ext1: %s", ext0)
 	}
 	if !check(msg) {
@@ -242,7 +204,7 @@ func TestGetExtensionStability(t *testing.T) {
 	if err != nil {
 		t.Fatalf("Marshal() failed: %s", err)
 	}
-	msg1 := &pb.MyMessage{}
+	msg1 := &pb2.MyMessage{}
 	err = proto.Unmarshal(bb, msg1)
 	if err != nil {
 		t.Fatalf("Unmarshal() failed: %s", err)
@@ -263,7 +225,7 @@ func TestGetExtensionDefaults(t *testing.T) {
 	var setBool2 = false
 	var setString = "Goodnight string"
 	var setBytes = []byte("Goodnight bytes")
-	var setEnum = pb.DefaultsMessage_TWO
+	var setEnum = pb2.DefaultsMessage_TWO
 
 	type testcase struct {
 		ext  *proto.ExtensionDesc // Extension we are testing.
@@ -271,83 +233,89 @@ func TestGetExtensionDefaults(t *testing.T) {
 		def  interface{}          // Expected value of extension after ClearExtension().
 	}
 	tests := []testcase{
-		{pb.E_NoDefaultDouble, setFloat64, nil},
-		{pb.E_NoDefaultFloat, setFloat32, nil},
-		{pb.E_NoDefaultInt32, setInt32, nil},
-		{pb.E_NoDefaultInt64, setInt64, nil},
-		{pb.E_NoDefaultUint32, setUint32, nil},
-		{pb.E_NoDefaultUint64, setUint64, nil},
-		{pb.E_NoDefaultSint32, setInt32, nil},
-		{pb.E_NoDefaultSint64, setInt64, nil},
-		{pb.E_NoDefaultFixed32, setUint32, nil},
-		{pb.E_NoDefaultFixed64, setUint64, nil},
-		{pb.E_NoDefaultSfixed32, setInt32, nil},
-		{pb.E_NoDefaultSfixed64, setInt64, nil},
-		{pb.E_NoDefaultBool, setBool, nil},
-		{pb.E_NoDefaultBool, setBool2, nil},
-		{pb.E_NoDefaultString, setString, nil},
-		{pb.E_NoDefaultBytes, setBytes, nil},
-		{pb.E_NoDefaultEnum, setEnum, nil},
-		{pb.E_DefaultDouble, setFloat64, float64(3.1415)},
-		{pb.E_DefaultFloat, setFloat32, float32(3.14)},
-		{pb.E_DefaultInt32, setInt32, int32(42)},
-		{pb.E_DefaultInt64, setInt64, int64(43)},
-		{pb.E_DefaultUint32, setUint32, uint32(44)},
-		{pb.E_DefaultUint64, setUint64, uint64(45)},
-		{pb.E_DefaultSint32, setInt32, int32(46)},
-		{pb.E_DefaultSint64, setInt64, int64(47)},
-		{pb.E_DefaultFixed32, setUint32, uint32(48)},
-		{pb.E_DefaultFixed64, setUint64, uint64(49)},
-		{pb.E_DefaultSfixed32, setInt32, int32(50)},
-		{pb.E_DefaultSfixed64, setInt64, int64(51)},
-		{pb.E_DefaultBool, setBool, true},
-		{pb.E_DefaultBool, setBool2, true},
-		{pb.E_DefaultString, setString, "Hello, string,def=foo"},
-		{pb.E_DefaultBytes, setBytes, []byte("Hello, bytes")},
-		{pb.E_DefaultEnum, setEnum, pb.DefaultsMessage_ONE},
-	}
-
-	checkVal := func(test testcase, msg *pb.DefaultsMessage, valWant interface{}) error {
-		val, err := proto.GetExtension(msg, test.ext)
-		if err != nil {
-			if valWant != nil {
-				return fmt.Errorf("GetExtension(): %s", err)
-			}
-			if want := proto.ErrMissingExtension; err != want {
-				return fmt.Errorf("Unexpected error: got %v, want %v", err, want)
+		{pb2.E_NoDefaultDouble, setFloat64, nil},
+		{pb2.E_NoDefaultFloat, setFloat32, nil},
+		{pb2.E_NoDefaultInt32, setInt32, nil},
+		{pb2.E_NoDefaultInt64, setInt64, nil},
+		{pb2.E_NoDefaultUint32, setUint32, nil},
+		{pb2.E_NoDefaultUint64, setUint64, nil},
+		{pb2.E_NoDefaultSint32, setInt32, nil},
+		{pb2.E_NoDefaultSint64, setInt64, nil},
+		{pb2.E_NoDefaultFixed32, setUint32, nil},
+		{pb2.E_NoDefaultFixed64, setUint64, nil},
+		{pb2.E_NoDefaultSfixed32, setInt32, nil},
+		{pb2.E_NoDefaultSfixed64, setInt64, nil},
+		{pb2.E_NoDefaultBool, setBool, nil},
+		{pb2.E_NoDefaultBool, setBool2, nil},
+		{pb2.E_NoDefaultString, setString, nil},
+		{pb2.E_NoDefaultBytes, setBytes, nil},
+		{pb2.E_NoDefaultEnum, setEnum, nil},
+		{pb2.E_DefaultDouble, setFloat64, float64(3.1415)},
+		{pb2.E_DefaultFloat, setFloat32, float32(3.14)},
+		{pb2.E_DefaultInt32, setInt32, int32(42)},
+		{pb2.E_DefaultInt64, setInt64, int64(43)},
+		{pb2.E_DefaultUint32, setUint32, uint32(44)},
+		{pb2.E_DefaultUint64, setUint64, uint64(45)},
+		{pb2.E_DefaultSint32, setInt32, int32(46)},
+		{pb2.E_DefaultSint64, setInt64, int64(47)},
+		{pb2.E_DefaultFixed32, setUint32, uint32(48)},
+		{pb2.E_DefaultFixed64, setUint64, uint64(49)},
+		{pb2.E_DefaultSfixed32, setInt32, int32(50)},
+		{pb2.E_DefaultSfixed64, setInt64, int64(51)},
+		{pb2.E_DefaultBool, setBool, true},
+		{pb2.E_DefaultBool, setBool2, true},
+		{pb2.E_DefaultString, setString, "Hello, string,def=foo"},
+		{pb2.E_DefaultBytes, setBytes, []byte("Hello, bytes")},
+		{pb2.E_DefaultEnum, setEnum, pb2.DefaultsMessage_ONE},
+	}
+
+	checkVal := func(t *testing.T, name string, test testcase, msg *pb2.DefaultsMessage, valWant interface{}) {
+		t.Run(name, func(t *testing.T) {
+			val, err := proto.GetExtension(msg, test.ext)
+			if err != nil {
+				if valWant != nil {
+					t.Errorf("GetExtension(): %s", err)
+					return
+				}
+				if want := proto.ErrMissingExtension; err != want {
+					t.Errorf("Unexpected error: got %v, want %v", err, want)
+					return
+				}
+				return
 			}
-			return nil
-		}
 
-		// All proto2 extension values are either a pointer to a value or a slice of values.
-		ty := reflect.TypeOf(val)
-		tyWant := reflect.TypeOf(test.ext.ExtensionType)
-		if got, want := ty, tyWant; got != want {
-			return fmt.Errorf("unexpected reflect.TypeOf(): got %v want %v", got, want)
-		}
-		tye := ty.Elem()
-		tyeWant := tyWant.Elem()
-		if got, want := tye, tyeWant; got != want {
-			return fmt.Errorf("unexpected reflect.TypeOf().Elem(): got %v want %v", got, want)
-		}
-
-		// Check the name of the type of the value.
-		// If it is an enum it will be type int32 with the name of the enum.
-		if got, want := tye.Name(), tye.Name(); got != want {
-			return fmt.Errorf("unexpected reflect.TypeOf().Elem().Name(): got %v want %v", got, want)
-		}
+			// All proto2 extension values are either a pointer to a value or a slice of values.
+			ty := reflect.TypeOf(val)
+			tyWant := reflect.TypeOf(test.ext.ExtensionType)
+			if got, want := ty, tyWant; got != want {
+				t.Errorf("unexpected reflect.TypeOf(): got %v want %v", got, want)
+				return
+			}
+			tye := ty.Elem()
+			tyeWant := tyWant.Elem()
+			if got, want := tye, tyeWant; got != want {
+				t.Errorf("unexpected reflect.TypeOf().Elem(): got %v want %v", got, want)
+				return
+			}
 
-		// Check that value is what we expect.
-		// If we have a pointer in val, get the value it points to.
-		valExp := val
-		if ty.Kind() == reflect.Ptr {
-			valExp = reflect.ValueOf(val).Elem().Interface()
-		}
-		if got, want := valExp, valWant; !reflect.DeepEqual(got, want) {
-			return fmt.Errorf("unexpected reflect.DeepEqual(): got %v want %v", got, want)
-		}
+			// Check the name of the type of the value.
+			// If it is an enum it will be type int32 with the name of the enum.
+			if got, want := tye.Name(), tye.Name(); got != want {
+				t.Errorf("unexpected reflect.TypeOf().Elem().Name(): got %v want %v", got, want)
+				return
+			}
 
-		return nil
+			// Check that value is what we expect.
+			// If we have a pointer in val, get the value it points to.
+			valExp := val
+			if ty.Kind() == reflect.Ptr {
+				valExp = reflect.ValueOf(val).Elem().Interface()
+			}
+			if got, want := valExp, valWant; !reflect.DeepEqual(got, want) {
+				t.Errorf("unexpected reflect.DeepEqual(): got %v want %v", got, want)
+				return
+			}
+		})
 	}
 
 	setTo := func(test testcase) interface{} {
@@ -361,37 +329,28 @@ func TestGetExtensionDefaults(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		msg := &pb.DefaultsMessage{}
+		msg := &pb2.DefaultsMessage{}
 		name := test.ext.Name
 
 		// Check the initial value.
-		if err := checkVal(test, msg, test.def); err != nil {
-			t.Errorf("%s: %v", name, err)
-		}
+		checkVal(t, name+"/initial", test, msg, test.def)
 
 		// Set the per-type value and check value.
-		name = fmt.Sprintf("%s (set to %T %v)", name, test.want, test.want)
 		if err := proto.SetExtension(msg, test.ext, setTo(test)); err != nil {
 			t.Errorf("%s: SetExtension(): %v", name, err)
 			continue
 		}
-		if err := checkVal(test, msg, test.want); err != nil {
-			t.Errorf("%s: %v", name, err)
-			continue
-		}
+		checkVal(t, name+"/set", test, msg, test.want)
 
 		// Set and check the value.
-		name += " (cleared)"
 		proto.ClearExtension(msg, test.ext)
-		if err := checkVal(test, msg, test.def); err != nil {
-			t.Errorf("%s: %v", name, err)
-		}
+		checkVal(t, name+"/cleared", test, msg, test.def)
 	}
 }
 
 func TestNilMessage(t *testing.T) {
 	name := "nil interface"
-	if got, err := proto.GetExtension(nil, pb.E_Ext_More); err == nil {
+	if got, err := proto.GetExtension(nil, pb2.E_Ext_More); err == nil {
 		t.Errorf("%s: got %T %v, expected to fail", name, got, got)
 	} else if !strings.Contains(err.Error(), "extendable") {
 		t.Errorf("%s: got error %v, expected not-extendable error", name, err)
@@ -400,11 +359,11 @@ func TestNilMessage(t *testing.T) {
 	// Regression tests: all functions of the Extension API
 	// used to panic when passed (*M)(nil), where M is a concrete message
 	// type.  Now they handle this gracefully as a no-op or reported error.
-	var nilMsg *pb.MyMessage
-	desc := pb.E_Ext_More
+	var nilMsg *pb2.MyMessage
+	desc := pb2.E_Ext_More
 
 	isNotExtendable := func(err error) bool {
-		return strings.Contains(fmt.Sprint(err), "not extendable")
+		return strings.Contains(fmt.Sprint(err), "not an extendable")
 	}
 
 	if proto.HasExtension(nilMsg, desc) {
@@ -428,58 +387,52 @@ func TestNilMessage(t *testing.T) {
 }
 
 func TestExtensionsRoundTrip(t *testing.T) {
-	msg := &pb.MyMessage{}
-	ext1 := &pb.Ext{
+	msg := &pb2.MyMessage{}
+	ext1 := &pb2.Ext{
 		Data: proto.String("hi"),
 	}
-	ext2 := &pb.Ext{
+	ext2 := &pb2.Ext{
 		Data: proto.String("there"),
 	}
-	exists := proto.HasExtension(msg, pb.E_Ext_More)
+	exists := proto.HasExtension(msg, pb2.E_Ext_More)
 	if exists {
 		t.Error("Extension More present unexpectedly")
 	}
-	if err := proto.SetExtension(msg, pb.E_Ext_More, ext1); err != nil {
+	if err := proto.SetExtension(msg, pb2.E_Ext_More, ext1); err != nil {
 		t.Error(err)
 	}
-	if err := proto.SetExtension(msg, pb.E_Ext_More, ext2); err != nil {
+	if err := proto.SetExtension(msg, pb2.E_Ext_More, ext2); err != nil {
 		t.Error(err)
 	}
-	e, err := proto.GetExtension(msg, pb.E_Ext_More)
+	e, err := proto.GetExtension(msg, pb2.E_Ext_More)
 	if err != nil {
 		t.Error(err)
 	}
-	x, ok := e.(*pb.Ext)
+	x, ok := e.(*pb2.Ext)
 	if !ok {
 		t.Errorf("e has type %T, expected test_proto.Ext", e)
 	} else if *x.Data != "there" {
 		t.Errorf("SetExtension failed to overwrite, got %+v, not 'there'", x)
 	}
-	proto.ClearExtension(msg, pb.E_Ext_More)
-	if _, err = proto.GetExtension(msg, pb.E_Ext_More); err != proto.ErrMissingExtension {
+	proto.ClearExtension(msg, pb2.E_Ext_More)
+	if _, err = proto.GetExtension(msg, pb2.E_Ext_More); err != proto.ErrMissingExtension {
 		t.Errorf("got %v, expected ErrMissingExtension", e)
 	}
-	if _, err := proto.GetExtension(msg, pb.E_X215); err == nil {
-		t.Error("expected bad extension error, got nil")
-	}
-	if err := proto.SetExtension(msg, pb.E_X215, 12); err == nil {
-		t.Error("expected extension err")
-	}
-	if err := proto.SetExtension(msg, pb.E_Ext_More, 12); err == nil {
+	if err := proto.SetExtension(msg, pb2.E_Ext_More, 12); err == nil {
 		t.Error("expected some sort of type mismatch error, got nil")
 	}
 }
 
 func TestNilExtension(t *testing.T) {
-	msg := &pb.MyMessage{
+	msg := &pb2.MyMessage{
 		Count: proto.Int32(1),
 	}
-	if err := proto.SetExtension(msg, pb.E_Ext_Text, proto.String("hello")); err != nil {
+	if err := proto.SetExtension(msg, pb2.E_Ext_Text, proto.String("hello")); err != nil {
 		t.Fatal(err)
 	}
-	if err := proto.SetExtension(msg, pb.E_Ext_More, (*pb.Ext)(nil)); err == nil {
+	if err := proto.SetExtension(msg, pb2.E_Ext_More, (*pb2.Ext)(nil)); err == nil {
 		t.Error("expected SetExtension to fail due to a nil extension")
-	} else if want := fmt.Sprintf("proto: SetExtension called with nil value of type %T", new(pb.Ext)); err.Error() != want {
+	} else if want := fmt.Sprintf("proto: SetExtension called with nil value of type %T", new(pb2.Ext)); err.Error() != want {
 		t.Errorf("expected error %v, got %v", want, err)
 	}
 	// Note: if the behavior of Marshal is ever changed to ignore nil extensions, update
@@ -490,25 +443,25 @@ func TestMarshalUnmarshalRepeatedExtension(t *testing.T) {
 	// Add a repeated extension to the result.
 	tests := []struct {
 		name string
-		ext  []*pb.ComplexExtension
+		ext  []*pb2.ComplexExtension
 	}{
 		{
 			"two fields",
-			[]*pb.ComplexExtension{
+			[]*pb2.ComplexExtension{
 				{First: proto.Int32(7)},
 				{Second: proto.Int32(11)},
 			},
 		},
 		{
 			"repeated field",
-			[]*pb.ComplexExtension{
+			[]*pb2.ComplexExtension{
 				{Third: []int32{1000}},
 				{Third: []int32{2000}},
 			},
 		},
 		{
 			"two fields and repeated field",
-			[]*pb.ComplexExtension{
+			[]*pb2.ComplexExtension{
 				{Third: []int32{1000}},
 				{First: proto.Int32(9)},
 				{Second: proto.Int32(21)},
@@ -518,8 +471,8 @@ func TestMarshalUnmarshalRepeatedExtension(t *testing.T) {
 	}
 	for _, test := range tests {
 		// Marshal message with a repeated extension.
-		msg1 := new(pb.OtherMessage)
-		err := proto.SetExtension(msg1, pb.E_RComplex, test.ext)
+		msg1 := new(pb2.OtherMessage)
+		err := proto.SetExtension(msg1, pb2.E_RComplex, test.ext)
 		if err != nil {
 			t.Fatalf("[%s] Error setting extension: %v", test.name, err)
 		}
@@ -529,16 +482,16 @@ func TestMarshalUnmarshalRepeatedExtension(t *testing.T) {
 		}
 
 		// Unmarshal and read the merged proto.
-		msg2 := new(pb.OtherMessage)
+		msg2 := new(pb2.OtherMessage)
 		err = proto.Unmarshal(b, msg2)
 		if err != nil {
 			t.Fatalf("[%s] Error unmarshaling message: %v", test.name, err)
 		}
-		e, err := proto.GetExtension(msg2, pb.E_RComplex)
+		e, err := proto.GetExtension(msg2, pb2.E_RComplex)
 		if err != nil {
 			t.Fatalf("[%s] Error getting extension: %v", test.name, err)
 		}
-		ext := e.([]*pb.ComplexExtension)
+		ext := e.([]*pb2.ComplexExtension)
 		if ext == nil {
 			t.Fatalf("[%s] Invalid extension", test.name)
 		}
@@ -559,25 +512,25 @@ func TestUnmarshalRepeatingNonRepeatedExtension(t *testing.T) {
 	// this way. Here, we verify that we merge the extensions together.
 	tests := []struct {
 		name string
-		ext  []*pb.ComplexExtension
+		ext  []*pb2.ComplexExtension
 	}{
 		{
 			"two fields",
-			[]*pb.ComplexExtension{
+			[]*pb2.ComplexExtension{
 				{First: proto.Int32(7)},
 				{Second: proto.Int32(11)},
 			},
 		},
 		{
 			"repeated field",
-			[]*pb.ComplexExtension{
+			[]*pb2.ComplexExtension{
 				{Third: []int32{1000}},
 				{Third: []int32{2000}},
 			},
 		},
 		{
 			"two fields and repeated field",
-			[]*pb.ComplexExtension{
+			[]*pb2.ComplexExtension{
 				{Third: []int32{1000}},
 				{First: proto.Int32(9)},
 				{Second: proto.Int32(21)},
@@ -587,7 +540,7 @@ func TestUnmarshalRepeatingNonRepeatedExtension(t *testing.T) {
 	}
 	for _, test := range tests {
 		var buf bytes.Buffer
-		var want pb.ComplexExtension
+		var want pb2.ComplexExtension
 
 		// Generate a serialized representation of a repeated extension
 		// by catenating bytes together.
@@ -596,8 +549,8 @@ func TestUnmarshalRepeatingNonRepeatedExtension(t *testing.T) {
 			proto.Merge(&want, e)
 
 			// serialize the message
-			msg := new(pb.OtherMessage)
-			err := proto.SetExtension(msg, pb.E_Complex, e)
+			msg := new(pb2.OtherMessage)
+			err := proto.SetExtension(msg, pb2.E_Complex, e)
 			if err != nil {
 				t.Fatalf("[%s] Error setting extension %d: %v", test.name, i, err)
 			}
@@ -609,16 +562,16 @@ func TestUnmarshalRepeatingNonRepeatedExtension(t *testing.T) {
 		}
 
 		// Unmarshal and read the merged proto.
-		msg2 := new(pb.OtherMessage)
+		msg2 := new(pb2.OtherMessage)
 		err := proto.Unmarshal(buf.Bytes(), msg2)
 		if err != nil {
 			t.Fatalf("[%s] Error unmarshaling message: %v", test.name, err)
 		}
-		e, err := proto.GetExtension(msg2, pb.E_Complex)
+		e, err := proto.GetExtension(msg2, pb2.E_Complex)
 		if err != nil {
 			t.Fatalf("[%s] Error getting extension: %v", test.name, err)
 		}
-		ext := e.(*pb.ComplexExtension)
+		ext := e.(*pb2.ComplexExtension)
 		if ext == nil {
 			t.Fatalf("[%s] Invalid extension", test.name)
 		}
@@ -631,13 +584,13 @@ func TestUnmarshalRepeatingNonRepeatedExtension(t *testing.T) {
 func TestClearAllExtensions(t *testing.T) {
 	// unregistered extension
 	desc := &proto.ExtensionDesc{
-		ExtendedType:  (*pb.MyMessage)(nil),
+		ExtendedType:  (*pb2.MyMessage)(nil),
 		ExtensionType: (*bool)(nil),
 		Field:         101010100,
 		Name:          "emptyextension",
 		Tag:           "varint,0,opt",
 	}
-	m := &pb.MyMessage{}
+	m := &pb2.MyMessage{}
 	if proto.HasExtension(m, desc) {
 		t.Errorf("proto.HasExtension(%s): got true, want false", proto.MarshalTextString(m))
 	}
@@ -654,9 +607,9 @@ func TestClearAllExtensions(t *testing.T) {
 }
 
 func TestMarshalRace(t *testing.T) {
-	ext := &pb.Ext{}
-	m := &pb.MyMessage{Count: proto.Int32(4)}
-	if err := proto.SetExtension(m, pb.E_Ext_More, ext); err != nil {
+	ext := &pb2.Ext{}
+	m := &pb2.MyMessage{Count: proto.Int32(4)}
+	if err := proto.SetExtension(m, pb2.E_Ext_More, ext); err != nil {
 		t.Fatalf("proto.SetExtension(m, desc, true): got error %q, want nil", err)
 	}
 
@@ -671,18 +624,22 @@ func TestMarshalRace(t *testing.T) {
 	// GetExtension will decode it lazily. Make sure this does
 	// not race against Marshal.
 
-	var g errgroup.Group
+	wg := sync.WaitGroup{}
+	errs := make(chan error, 3)
 	for n := 3; n > 0; n-- {
-		g.Go(func() error {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
 			_, err := proto.Marshal(m)
-			return err
-		})
-		g.Go(func() error {
-			_, err := proto.GetExtension(m, pb.E_Ext_More)
-			return err
-		})
+			errs <- err
+		}()
 	}
-	if err := g.Wait(); err != nil {
-		t.Fatal(err)
+	wg.Wait()
+	close(errs)
+
+	for err = range errs {
+		if err != nil {
+			t.Fatal(err)
+		}
 	}
 }
diff --git a/vendor/github.com/golang/protobuf/proto/lib.go b/vendor/github.com/golang/protobuf/proto/lib.go
deleted file mode 100644
index 0e2191b8a..000000000
--- a/vendor/github.com/golang/protobuf/proto/lib.go
+++ /dev/null
@@ -1,921 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-/*
-Package proto converts data structures to and from the wire format of
-protocol buffers.  It works in concert with the Go source code generated
-for .proto files by the protocol compiler.
-
-A summary of the properties of the protocol buffer interface
-for a protocol buffer variable v:
-
-  - Names are turned from camel_case to CamelCase for export.
-  - There are no methods on v to set fields; just treat
-	them as structure fields.
-  - There are getters that return a field's value if set,
-	and return the field's default value if unset.
-	The getters work even if the receiver is a nil message.
-  - The zero value for a struct is its correct initialization state.
-	All desired fields must be set before marshaling.
-  - A Reset() method will restore a protobuf struct to its zero state.
-  - Non-repeated fields are pointers to the values; nil means unset.
-	That is, optional or required field int32 f becomes F *int32.
-  - Repeated fields are slices.
-  - Helper functions are available to aid the setting of fields.
-	msg.Foo = proto.String("hello") // set field
-  - Constants are defined to hold the default values of all fields that
-	have them.  They have the form Default_StructName_FieldName.
-	Because the getter methods handle defaulted values,
-	direct use of these constants should be rare.
-  - Enums are given type names and maps from names to values.
-	Enum values are prefixed by the enclosing message's name, or by the
-	enum's type name if it is a top-level enum. Enum types have a String
-	method, and a Enum method to assist in message construction.
-  - Nested messages, groups and enums have type names prefixed with the name of
-	the surrounding message type.
-  - Extensions are given descriptor names that start with E_,
-	followed by an underscore-delimited list of the nested messages
-	that contain it (if any) followed by the CamelCased name of the
-	extension field itself.  HasExtension, ClearExtension, GetExtension
-	and SetExtension are functions for manipulating extensions.
-  - Oneof field sets are given a single field in their message,
-	with distinguished wrapper types for each possible field value.
-  - Marshal and Unmarshal are functions to encode and decode the wire format.
-
-When the .proto file specifies `syntax="proto3"`, there are some differences:
-
-  - Non-repeated fields of non-message type are values instead of pointers.
-  - Enum types do not get an Enum method.
-
-The simplest way to describe this is to see an example.
-Given file test.proto, containing
-
-	package example;
-
-	enum FOO { X = 17; }
-
-	message Test {
-	  required string label = 1;
-	  optional int32 type = 2 [default=77];
-	  repeated int64 reps = 3;
-	  optional group OptionalGroup = 4 {
-	    required string RequiredField = 5;
-	  }
-	  oneof union {
-	    int32 number = 6;
-	    string name = 7;
-	  }
-	}
-
-The resulting file, test.pb.go, is:
-
-	package example
-
-	import proto "github.com/golang/protobuf/proto"
-	import math "math"
-
-	type FOO int32
-	const (
-		FOO_X FOO = 17
-	)
-	var FOO_name = map[int32]string{
-		17: "X",
-	}
-	var FOO_value = map[string]int32{
-		"X": 17,
-	}
-
-	func (x FOO) Enum() *FOO {
-		p := new(FOO)
-		*p = x
-		return p
-	}
-	func (x FOO) String() string {
-		return proto.EnumName(FOO_name, int32(x))
-	}
-	func (x *FOO) UnmarshalJSON(data []byte) error {
-		value, err := proto.UnmarshalJSONEnum(FOO_value, data)
-		if err != nil {
-			return err
-		}
-		*x = FOO(value)
-		return nil
-	}
-
-	type Test struct {
-		Label         *string             `protobuf:"bytes,1,req,name=label" json:"label,omitempty"`
-		Type          *int32              `protobuf:"varint,2,opt,name=type,def=77" json:"type,omitempty"`
-		Reps          []int64             `protobuf:"varint,3,rep,name=reps" json:"reps,omitempty"`
-		Optionalgroup *Test_OptionalGroup `protobuf:"group,4,opt,name=OptionalGroup" json:"optionalgroup,omitempty"`
-		// Types that are valid to be assigned to Union:
-		//	*Test_Number
-		//	*Test_Name
-		Union            isTest_Union `protobuf_oneof:"union"`
-		XXX_unrecognized []byte       `json:"-"`
-	}
-	func (m *Test) Reset()         { *m = Test{} }
-	func (m *Test) String() string { return proto.CompactTextString(m) }
-	func (*Test) ProtoMessage() {}
-
-	type isTest_Union interface {
-		isTest_Union()
-	}
-
-	type Test_Number struct {
-		Number int32 `protobuf:"varint,6,opt,name=number"`
-	}
-	type Test_Name struct {
-		Name string `protobuf:"bytes,7,opt,name=name"`
-	}
-
-	func (*Test_Number) isTest_Union() {}
-	func (*Test_Name) isTest_Union()   {}
-
-	func (m *Test) GetUnion() isTest_Union {
-		if m != nil {
-			return m.Union
-		}
-		return nil
-	}
-	const Default_Test_Type int32 = 77
-
-	func (m *Test) GetLabel() string {
-		if m != nil && m.Label != nil {
-			return *m.Label
-		}
-		return ""
-	}
-
-	func (m *Test) GetType() int32 {
-		if m != nil && m.Type != nil {
-			return *m.Type
-		}
-		return Default_Test_Type
-	}
-
-	func (m *Test) GetOptionalgroup() *Test_OptionalGroup {
-		if m != nil {
-			return m.Optionalgroup
-		}
-		return nil
-	}
-
-	type Test_OptionalGroup struct {
-		RequiredField *string `protobuf:"bytes,5,req" json:"RequiredField,omitempty"`
-	}
-	func (m *Test_OptionalGroup) Reset()         { *m = Test_OptionalGroup{} }
-	func (m *Test_OptionalGroup) String() string { return proto.CompactTextString(m) }
-
-	func (m *Test_OptionalGroup) GetRequiredField() string {
-		if m != nil && m.RequiredField != nil {
-			return *m.RequiredField
-		}
-		return ""
-	}
-
-	func (m *Test) GetNumber() int32 {
-		if x, ok := m.GetUnion().(*Test_Number); ok {
-			return x.Number
-		}
-		return 0
-	}
-
-	func (m *Test) GetName() string {
-		if x, ok := m.GetUnion().(*Test_Name); ok {
-			return x.Name
-		}
-		return ""
-	}
-
-	func init() {
-		proto.RegisterEnum("example.FOO", FOO_name, FOO_value)
-	}
-
-To create and play with a Test object:
-
-	package main
-
-	import (
-		"log"
-
-		"github.com/golang/protobuf/proto"
-		pb "./example.pb"
-	)
-
-	func main() {
-		test := &pb.Test{
-			Label: proto.String("hello"),
-			Type:  proto.Int32(17),
-			Reps:  []int64{1, 2, 3},
-			Optionalgroup: &pb.Test_OptionalGroup{
-				RequiredField: proto.String("good bye"),
-			},
-			Union: &pb.Test_Name{"fred"},
-		}
-		data, err := proto.Marshal(test)
-		if err != nil {
-			log.Fatal("marshaling error: ", err)
-		}
-		newTest := &pb.Test{}
-		err = proto.Unmarshal(data, newTest)
-		if err != nil {
-			log.Fatal("unmarshaling error: ", err)
-		}
-		// Now test and newTest contain the same data.
-		if test.GetLabel() != newTest.GetLabel() {
-			log.Fatalf("data mismatch %q != %q", test.GetLabel(), newTest.GetLabel())
-		}
-		// Use a type switch to determine which oneof was set.
-		switch u := test.Union.(type) {
-		case *pb.Test_Number: // u.Number contains the number.
-		case *pb.Test_Name: // u.Name contains the string.
-		}
-		// etc.
-	}
-*/
-package proto
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"log"
-	"reflect"
-	"sort"
-	"strconv"
-	"sync"
-)
-
-var errInvalidUTF8 = errors.New("proto: invalid UTF-8 string")
-
-// Message is implemented by generated protocol buffer messages.
-type Message interface {
-	Reset()
-	String() string
-	ProtoMessage()
-}
-
-// Stats records allocation details about the protocol buffer encoders
-// and decoders.  Useful for tuning the library itself.
-type Stats struct {
-	Emalloc uint64 // mallocs in encode
-	Dmalloc uint64 // mallocs in decode
-	Encode  uint64 // number of encodes
-	Decode  uint64 // number of decodes
-	Chit    uint64 // number of cache hits
-	Cmiss   uint64 // number of cache misses
-	Size    uint64 // number of sizes
-}
-
-// Set to true to enable stats collection.
-const collectStats = false
-
-var stats Stats
-
-// GetStats returns a copy of the global Stats structure.
-func GetStats() Stats { return stats }
-
-// A Buffer is a buffer manager for marshaling and unmarshaling
-// protocol buffers.  It may be reused between invocations to
-// reduce memory usage.  It is not necessary to use a Buffer;
-// the global functions Marshal and Unmarshal create a
-// temporary Buffer and are fine for most applications.
-type Buffer struct {
-	buf   []byte // encode/decode byte stream
-	index int    // read point
-
-	deterministic bool
-}
-
-// NewBuffer allocates a new Buffer and initializes its internal data to
-// the contents of the argument slice.
-func NewBuffer(e []byte) *Buffer {
-	return &Buffer{buf: e}
-}
-
-// Reset resets the Buffer, ready for marshaling a new protocol buffer.
-func (p *Buffer) Reset() {
-	p.buf = p.buf[0:0] // for reading/writing
-	p.index = 0        // for reading
-}
-
-// SetBuf replaces the internal buffer with the slice,
-// ready for unmarshaling the contents of the slice.
-func (p *Buffer) SetBuf(s []byte) {
-	p.buf = s
-	p.index = 0
-}
-
-// Bytes returns the contents of the Buffer.
-func (p *Buffer) Bytes() []byte { return p.buf }
-
-// SetDeterministic sets whether to use deterministic serialization.
-//
-// Deterministic serialization guarantees that for a given binary, equal
-// messages will always be serialized to the same bytes. This implies:
-//
-//   - Repeated serialization of a message will return the same bytes.
-//   - Different processes of the same binary (which may be executing on
-//     different machines) will serialize equal messages to the same bytes.
-//
-// Note that the deterministic serialization is NOT canonical across
-// languages. It is not guaranteed to remain stable over time. It is unstable
-// across different builds with schema changes due to unknown fields.
-// Users who need canonical serialization (e.g., persistent storage in a
-// canonical form, fingerprinting, etc.) should define their own
-// canonicalization specification and implement their own serializer rather
-// than relying on this API.
-//
-// If deterministic serialization is requested, map entries will be sorted
-// by keys in lexographical order. This is an implementation detail and
-// subject to change.
-func (p *Buffer) SetDeterministic(deterministic bool) {
-	p.deterministic = deterministic
-}
-
-/*
- * Helper routines for simplifying the creation of optional fields of basic type.
- */
-
-// Bool is a helper routine that allocates a new bool value
-// to store v and returns a pointer to it.
-func Bool(v bool) *bool {
-	return &v
-}
-
-// Int32 is a helper routine that allocates a new int32 value
-// to store v and returns a pointer to it.
-func Int32(v int32) *int32 {
-	return &v
-}
-
-// Int is a helper routine that allocates a new int32 value
-// to store v and returns a pointer to it, but unlike Int32
-// its argument value is an int.
-func Int(v int) *int32 {
-	p := new(int32)
-	*p = int32(v)
-	return p
-}
-
-// Int64 is a helper routine that allocates a new int64 value
-// to store v and returns a pointer to it.
-func Int64(v int64) *int64 {
-	return &v
-}
-
-// Float32 is a helper routine that allocates a new float32 value
-// to store v and returns a pointer to it.
-func Float32(v float32) *float32 {
-	return &v
-}
-
-// Float64 is a helper routine that allocates a new float64 value
-// to store v and returns a pointer to it.
-func Float64(v float64) *float64 {
-	return &v
-}
-
-// Uint32 is a helper routine that allocates a new uint32 value
-// to store v and returns a pointer to it.
-func Uint32(v uint32) *uint32 {
-	return &v
-}
-
-// Uint64 is a helper routine that allocates a new uint64 value
-// to store v and returns a pointer to it.
-func Uint64(v uint64) *uint64 {
-	return &v
-}
-
-// String is a helper routine that allocates a new string value
-// to store v and returns a pointer to it.
-func String(v string) *string {
-	return &v
-}
-
-// EnumName is a helper function to simplify printing protocol buffer enums
-// by name.  Given an enum map and a value, it returns a useful string.
-func EnumName(m map[int32]string, v int32) string {
-	s, ok := m[v]
-	if ok {
-		return s
-	}
-	return strconv.Itoa(int(v))
-}
-
-// UnmarshalJSONEnum is a helper function to simplify recovering enum int values
-// from their JSON-encoded representation. Given a map from the enum's symbolic
-// names to its int values, and a byte buffer containing the JSON-encoded
-// value, it returns an int32 that can be cast to the enum type by the caller.
-//
-// The function can deal with both JSON representations, numeric and symbolic.
-func UnmarshalJSONEnum(m map[string]int32, data []byte, enumName string) (int32, error) {
-	if data[0] == '"' {
-		// New style: enums are strings.
-		var repr string
-		if err := json.Unmarshal(data, &repr); err != nil {
-			return -1, err
-		}
-		val, ok := m[repr]
-		if !ok {
-			return 0, fmt.Errorf("unrecognized enum %s value %q", enumName, repr)
-		}
-		return val, nil
-	}
-	// Old style: enums are ints.
-	var val int32
-	if err := json.Unmarshal(data, &val); err != nil {
-		return 0, fmt.Errorf("cannot unmarshal %#q into enum %s", data, enumName)
-	}
-	return val, nil
-}
-
-// DebugPrint dumps the encoded data in b in a debugging format with a header
-// including the string s. Used in testing but made available for general debugging.
-func (p *Buffer) DebugPrint(s string, b []byte) {
-	var u uint64
-
-	obuf := p.buf
-	index := p.index
-	p.buf = b
-	p.index = 0
-	depth := 0
-
-	fmt.Printf("\n--- %s ---\n", s)
-
-out:
-	for {
-		for i := 0; i < depth; i++ {
-			fmt.Print("  ")
-		}
-
-		index := p.index
-		if index == len(p.buf) {
-			break
-		}
-
-		op, err := p.DecodeVarint()
-		if err != nil {
-			fmt.Printf("%3d: fetching op err %v\n", index, err)
-			break out
-		}
-		tag := op >> 3
-		wire := op & 7
-
-		switch wire {
-		default:
-			fmt.Printf("%3d: t=%3d unknown wire=%d\n",
-				index, tag, wire)
-			break out
-
-		case WireBytes:
-			var r []byte
-
-			r, err = p.DecodeRawBytes(false)
-			if err != nil {
-				break out
-			}
-			fmt.Printf("%3d: t=%3d bytes [%d]", index, tag, len(r))
-			if len(r) <= 6 {
-				for i := 0; i < len(r); i++ {
-					fmt.Printf(" %.2x", r[i])
-				}
-			} else {
-				for i := 0; i < 3; i++ {
-					fmt.Printf(" %.2x", r[i])
-				}
-				fmt.Printf(" ..")
-				for i := len(r) - 3; i < len(r); i++ {
-					fmt.Printf(" %.2x", r[i])
-				}
-			}
-			fmt.Printf("\n")
-
-		case WireFixed32:
-			u, err = p.DecodeFixed32()
-			if err != nil {
-				fmt.Printf("%3d: t=%3d fix32 err %v\n", index, tag, err)
-				break out
-			}
-			fmt.Printf("%3d: t=%3d fix32 %d\n", index, tag, u)
-
-		case WireFixed64:
-			u, err = p.DecodeFixed64()
-			if err != nil {
-				fmt.Printf("%3d: t=%3d fix64 err %v\n", index, tag, err)
-				break out
-			}
-			fmt.Printf("%3d: t=%3d fix64 %d\n", index, tag, u)
-
-		case WireVarint:
-			u, err = p.DecodeVarint()
-			if err != nil {
-				fmt.Printf("%3d: t=%3d varint err %v\n", index, tag, err)
-				break out
-			}
-			fmt.Printf("%3d: t=%3d varint %d\n", index, tag, u)
-
-		case WireStartGroup:
-			fmt.Printf("%3d: t=%3d start\n", index, tag)
-			depth++
-
-		case WireEndGroup:
-			depth--
-			fmt.Printf("%3d: t=%3d end\n", index, tag)
-		}
-	}
-
-	if depth != 0 {
-		fmt.Printf("%3d: start-end not balanced %d\n", p.index, depth)
-	}
-	fmt.Printf("\n")
-
-	p.buf = obuf
-	p.index = index
-}
-
-// SetDefaults sets unset protocol buffer fields to their default values.
-// It only modifies fields that are both unset and have defined defaults.
-// It recursively sets default values in any non-nil sub-messages.
-func SetDefaults(pb Message) {
-	setDefaults(reflect.ValueOf(pb), true, false)
-}
-
-// v is a pointer to a struct.
-func setDefaults(v reflect.Value, recur, zeros bool) {
-	v = v.Elem()
-
-	defaultMu.RLock()
-	dm, ok := defaults[v.Type()]
-	defaultMu.RUnlock()
-	if !ok {
-		dm = buildDefaultMessage(v.Type())
-		defaultMu.Lock()
-		defaults[v.Type()] = dm
-		defaultMu.Unlock()
-	}
-
-	for _, sf := range dm.scalars {
-		f := v.Field(sf.index)
-		if !f.IsNil() {
-			// field already set
-			continue
-		}
-		dv := sf.value
-		if dv == nil && !zeros {
-			// no explicit default, and don't want to set zeros
-			continue
-		}
-		fptr := f.Addr().Interface() // **T
-		// TODO: Consider batching the allocations we do here.
-		switch sf.kind {
-		case reflect.Bool:
-			b := new(bool)
-			if dv != nil {
-				*b = dv.(bool)
-			}
-			*(fptr.(**bool)) = b
-		case reflect.Float32:
-			f := new(float32)
-			if dv != nil {
-				*f = dv.(float32)
-			}
-			*(fptr.(**float32)) = f
-		case reflect.Float64:
-			f := new(float64)
-			if dv != nil {
-				*f = dv.(float64)
-			}
-			*(fptr.(**float64)) = f
-		case reflect.Int32:
-			// might be an enum
-			if ft := f.Type(); ft != int32PtrType {
-				// enum
-				f.Set(reflect.New(ft.Elem()))
-				if dv != nil {
-					f.Elem().SetInt(int64(dv.(int32)))
-				}
-			} else {
-				// int32 field
-				i := new(int32)
-				if dv != nil {
-					*i = dv.(int32)
-				}
-				*(fptr.(**int32)) = i
-			}
-		case reflect.Int64:
-			i := new(int64)
-			if dv != nil {
-				*i = dv.(int64)
-			}
-			*(fptr.(**int64)) = i
-		case reflect.String:
-			s := new(string)
-			if dv != nil {
-				*s = dv.(string)
-			}
-			*(fptr.(**string)) = s
-		case reflect.Uint8:
-			// exceptional case: []byte
-			var b []byte
-			if dv != nil {
-				db := dv.([]byte)
-				b = make([]byte, len(db))
-				copy(b, db)
-			} else {
-				b = []byte{}
-			}
-			*(fptr.(*[]byte)) = b
-		case reflect.Uint32:
-			u := new(uint32)
-			if dv != nil {
-				*u = dv.(uint32)
-			}
-			*(fptr.(**uint32)) = u
-		case reflect.Uint64:
-			u := new(uint64)
-			if dv != nil {
-				*u = dv.(uint64)
-			}
-			*(fptr.(**uint64)) = u
-		default:
-			log.Printf("proto: can't set default for field %v (sf.kind=%v)", f, sf.kind)
-		}
-	}
-
-	for _, ni := range dm.nested {
-		f := v.Field(ni)
-		// f is *T or []*T or map[T]*T
-		switch f.Kind() {
-		case reflect.Ptr:
-			if f.IsNil() {
-				continue
-			}
-			setDefaults(f, recur, zeros)
-
-		case reflect.Slice:
-			for i := 0; i < f.Len(); i++ {
-				e := f.Index(i)
-				if e.IsNil() {
-					continue
-				}
-				setDefaults(e, recur, zeros)
-			}
-
-		case reflect.Map:
-			for _, k := range f.MapKeys() {
-				e := f.MapIndex(k)
-				if e.IsNil() {
-					continue
-				}
-				setDefaults(e, recur, zeros)
-			}
-		}
-	}
-}
-
-var (
-	// defaults maps a protocol buffer struct type to a slice of the fields,
-	// with its scalar fields set to their proto-declared non-zero default values.
-	defaultMu sync.RWMutex
-	defaults  = make(map[reflect.Type]defaultMessage)
-
-	int32PtrType = reflect.TypeOf((*int32)(nil))
-)
-
-// defaultMessage represents information about the default values of a message.
-type defaultMessage struct {
-	scalars []scalarField
-	nested  []int // struct field index of nested messages
-}
-
-type scalarField struct {
-	index int          // struct field index
-	kind  reflect.Kind // element type (the T in *T or []T)
-	value interface{}  // the proto-declared default value, or nil
-}
-
-// t is a struct type.
-func buildDefaultMessage(t reflect.Type) (dm defaultMessage) {
-	sprop := GetProperties(t)
-	for _, prop := range sprop.Prop {
-		fi, ok := sprop.decoderTags.get(prop.Tag)
-		if !ok {
-			// XXX_unrecognized
-			continue
-		}
-		ft := t.Field(fi).Type
-
-		sf, nested, err := fieldDefault(ft, prop)
-		switch {
-		case err != nil:
-			log.Print(err)
-		case nested:
-			dm.nested = append(dm.nested, fi)
-		case sf != nil:
-			sf.index = fi
-			dm.scalars = append(dm.scalars, *sf)
-		}
-	}
-
-	return dm
-}
-
-// fieldDefault returns the scalarField for field type ft.
-// sf will be nil if the field can not have a default.
-// nestedMessage will be true if this is a nested message.
-// Note that sf.index is not set on return.
-func fieldDefault(ft reflect.Type, prop *Properties) (sf *scalarField, nestedMessage bool, err error) {
-	var canHaveDefault bool
-	switch ft.Kind() {
-	case reflect.Ptr:
-		if ft.Elem().Kind() == reflect.Struct {
-			nestedMessage = true
-		} else {
-			canHaveDefault = true // proto2 scalar field
-		}
-
-	case reflect.Slice:
-		switch ft.Elem().Kind() {
-		case reflect.Ptr:
-			nestedMessage = true // repeated message
-		case reflect.Uint8:
-			canHaveDefault = true // bytes field
-		}
-
-	case reflect.Map:
-		if ft.Elem().Kind() == reflect.Ptr {
-			nestedMessage = true // map with message values
-		}
-	}
-
-	if !canHaveDefault {
-		if nestedMessage {
-			return nil, true, nil
-		}
-		return nil, false, nil
-	}
-
-	// We now know that ft is a pointer or slice.
-	sf = &scalarField{kind: ft.Elem().Kind()}
-
-	// scalar fields without defaults
-	if !prop.HasDefault {
-		return sf, false, nil
-	}
-
-	// a scalar field: either *T or []byte
-	switch ft.Elem().Kind() {
-	case reflect.Bool:
-		x, err := strconv.ParseBool(prop.Default)
-		if err != nil {
-			return nil, false, fmt.Errorf("proto: bad default bool %q: %v", prop.Default, err)
-		}
-		sf.value = x
-	case reflect.Float32:
-		x, err := strconv.ParseFloat(prop.Default, 32)
-		if err != nil {
-			return nil, false, fmt.Errorf("proto: bad default float32 %q: %v", prop.Default, err)
-		}
-		sf.value = float32(x)
-	case reflect.Float64:
-		x, err := strconv.ParseFloat(prop.Default, 64)
-		if err != nil {
-			return nil, false, fmt.Errorf("proto: bad default float64 %q: %v", prop.Default, err)
-		}
-		sf.value = x
-	case reflect.Int32:
-		x, err := strconv.ParseInt(prop.Default, 10, 32)
-		if err != nil {
-			return nil, false, fmt.Errorf("proto: bad default int32 %q: %v", prop.Default, err)
-		}
-		sf.value = int32(x)
-	case reflect.Int64:
-		x, err := strconv.ParseInt(prop.Default, 10, 64)
-		if err != nil {
-			return nil, false, fmt.Errorf("proto: bad default int64 %q: %v", prop.Default, err)
-		}
-		sf.value = x
-	case reflect.String:
-		sf.value = prop.Default
-	case reflect.Uint8:
-		// []byte (not *uint8)
-		sf.value = []byte(prop.Default)
-	case reflect.Uint32:
-		x, err := strconv.ParseUint(prop.Default, 10, 32)
-		if err != nil {
-			return nil, false, fmt.Errorf("proto: bad default uint32 %q: %v", prop.Default, err)
-		}
-		sf.value = uint32(x)
-	case reflect.Uint64:
-		x, err := strconv.ParseUint(prop.Default, 10, 64)
-		if err != nil {
-			return nil, false, fmt.Errorf("proto: bad default uint64 %q: %v", prop.Default, err)
-		}
-		sf.value = x
-	default:
-		return nil, false, fmt.Errorf("proto: unhandled def kind %v", ft.Elem().Kind())
-	}
-
-	return sf, false, nil
-}
-
-// mapKeys returns a sort.Interface to be used for sorting the map keys.
-// Map fields may have key types of non-float scalars, strings and enums.
-func mapKeys(vs []reflect.Value) sort.Interface {
-	s := mapKeySorter{vs: vs}
-
-	// Type specialization per https://developers.google.com/protocol-buffers/docs/proto#maps.
-	if len(vs) == 0 {
-		return s
-	}
-	switch vs[0].Kind() {
-	case reflect.Int32, reflect.Int64:
-		s.less = func(a, b reflect.Value) bool { return a.Int() < b.Int() }
-	case reflect.Uint32, reflect.Uint64:
-		s.less = func(a, b reflect.Value) bool { return a.Uint() < b.Uint() }
-	case reflect.Bool:
-		s.less = func(a, b reflect.Value) bool { return !a.Bool() && b.Bool() } // false < true
-	case reflect.String:
-		s.less = func(a, b reflect.Value) bool { return a.String() < b.String() }
-	default:
-		panic(fmt.Sprintf("unsupported map key type: %v", vs[0].Kind()))
-	}
-
-	return s
-}
-
-type mapKeySorter struct {
-	vs   []reflect.Value
-	less func(a, b reflect.Value) bool
-}
-
-func (s mapKeySorter) Len() int      { return len(s.vs) }
-func (s mapKeySorter) Swap(i, j int) { s.vs[i], s.vs[j] = s.vs[j], s.vs[i] }
-func (s mapKeySorter) Less(i, j int) bool {
-	return s.less(s.vs[i], s.vs[j])
-}
-
-// isProto3Zero reports whether v is a zero proto3 value.
-func isProto3Zero(v reflect.Value) bool {
-	switch v.Kind() {
-	case reflect.Bool:
-		return !v.Bool()
-	case reflect.Int32, reflect.Int64:
-		return v.Int() == 0
-	case reflect.Uint32, reflect.Uint64:
-		return v.Uint() == 0
-	case reflect.Float32, reflect.Float64:
-		return v.Float() == 0
-	case reflect.String:
-		return v.String() == ""
-	}
-	return false
-}
-
-// ProtoPackageIsVersion2 is referenced from generated protocol buffer files
-// to assert that that code is compatible with this version of the proto package.
-const ProtoPackageIsVersion2 = true
-
-// ProtoPackageIsVersion1 is referenced from generated protocol buffer files
-// to assert that that code is compatible with this version of the proto package.
-const ProtoPackageIsVersion1 = true
-
-// InternalMessageInfo is a type used internally by generated .pb.go files.
-// This type is not intended to be used by non-generated code.
-// This type is not subject to any compatibility guarantee.
-type InternalMessageInfo struct {
-	marshal   *marshalInfo
-	unmarshal *unmarshalInfo
-	merge     *mergeInfo
-	discard   *discardInfo
-}
diff --git a/vendor/github.com/golang/protobuf/proto/map_test.go b/vendor/github.com/golang/protobuf/proto/map_test.go
deleted file mode 100644
index b1e1529ee..000000000
--- a/vendor/github.com/golang/protobuf/proto/map_test.go
+++ /dev/null
@@ -1,70 +0,0 @@
-package proto_test
-
-import (
-	"fmt"
-	"reflect"
-	"testing"
-
-	"github.com/golang/protobuf/proto"
-	ppb "github.com/golang/protobuf/proto/proto3_proto"
-)
-
-func TestMap(t *testing.T) {
-	var b []byte
-	fmt.Sscanf("a2010c0a044b657931120456616c31a201130a044b657932120556616c3261120456616c32a201240a044b6579330d05000000120556616c33621a0556616c3361120456616c331505000000a20100a201260a044b657934130a07536f6d6555524c1209536f6d655469746c651a08536e69707065743114", "%x", &b)
-
-	var m ppb.Message
-	if err := proto.Unmarshal(b, &m); err != nil {
-		t.Fatalf("proto.Unmarshal error: %v", err)
-	}
-
-	got := m.StringMap
-	want := map[string]string{
-		"":     "",
-		"Key1": "Val1",
-		"Key2": "Val2",
-		"Key3": "Val3",
-		"Key4": "",
-	}
-
-	if !reflect.DeepEqual(got, want) {
-		t.Errorf("maps differ:\ngot  %#v\nwant %#v", got, want)
-	}
-}
-
-func marshalled() []byte {
-	m := &ppb.IntMaps{}
-	for i := 0; i < 1000; i++ {
-		m.Maps = append(m.Maps, &ppb.IntMap{
-			Rtt: map[int32]int32{1: 2},
-		})
-	}
-	b, err := proto.Marshal(m)
-	if err != nil {
-		panic(fmt.Sprintf("Can't marshal %+v: %v", m, err))
-	}
-	return b
-}
-
-func BenchmarkConcurrentMapUnmarshal(b *testing.B) {
-	in := marshalled()
-	b.RunParallel(func(pb *testing.PB) {
-		for pb.Next() {
-			var out ppb.IntMaps
-			if err := proto.Unmarshal(in, &out); err != nil {
-				b.Errorf("Can't unmarshal ppb.IntMaps: %v", err)
-			}
-		}
-	})
-}
-
-func BenchmarkSequentialMapUnmarshal(b *testing.B) {
-	in := marshalled()
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		var out ppb.IntMaps
-		if err := proto.Unmarshal(in, &out); err != nil {
-			b.Errorf("Can't unmarshal ppb.IntMaps: %v", err)
-		}
-	}
-}
diff --git a/vendor/github.com/golang/protobuf/proto/message_set.go b/vendor/github.com/golang/protobuf/proto/message_set.go
deleted file mode 100644
index 3b6ca41d5..000000000
--- a/vendor/github.com/golang/protobuf/proto/message_set.go
+++ /dev/null
@@ -1,314 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package proto
-
-/*
- * Support for message sets.
- */
-
-import (
-	"bytes"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"reflect"
-	"sort"
-	"sync"
-)
-
-// errNoMessageTypeID occurs when a protocol buffer does not have a message type ID.
-// A message type ID is required for storing a protocol buffer in a message set.
-var errNoMessageTypeID = errors.New("proto does not have a message type ID")
-
-// The first two types (_MessageSet_Item and messageSet)
-// model what the protocol compiler produces for the following protocol message:
-//   message MessageSet {
-//     repeated group Item = 1 {
-//       required int32 type_id = 2;
-//       required string message = 3;
-//     };
-//   }
-// That is the MessageSet wire format. We can't use a proto to generate these
-// because that would introduce a circular dependency between it and this package.
-
-type _MessageSet_Item struct {
-	TypeId  *int32 `protobuf:"varint,2,req,name=type_id"`
-	Message []byte `protobuf:"bytes,3,req,name=message"`
-}
-
-type messageSet struct {
-	Item             []*_MessageSet_Item `protobuf:"group,1,rep"`
-	XXX_unrecognized []byte
-	// TODO: caching?
-}
-
-// Make sure messageSet is a Message.
-var _ Message = (*messageSet)(nil)
-
-// messageTypeIder is an interface satisfied by a protocol buffer type
-// that may be stored in a MessageSet.
-type messageTypeIder interface {
-	MessageTypeId() int32
-}
-
-func (ms *messageSet) find(pb Message) *_MessageSet_Item {
-	mti, ok := pb.(messageTypeIder)
-	if !ok {
-		return nil
-	}
-	id := mti.MessageTypeId()
-	for _, item := range ms.Item {
-		if *item.TypeId == id {
-			return item
-		}
-	}
-	return nil
-}
-
-func (ms *messageSet) Has(pb Message) bool {
-	return ms.find(pb) != nil
-}
-
-func (ms *messageSet) Unmarshal(pb Message) error {
-	if item := ms.find(pb); item != nil {
-		return Unmarshal(item.Message, pb)
-	}
-	if _, ok := pb.(messageTypeIder); !ok {
-		return errNoMessageTypeID
-	}
-	return nil // TODO: return error instead?
-}
-
-func (ms *messageSet) Marshal(pb Message) error {
-	msg, err := Marshal(pb)
-	if err != nil {
-		return err
-	}
-	if item := ms.find(pb); item != nil {
-		// reuse existing item
-		item.Message = msg
-		return nil
-	}
-
-	mti, ok := pb.(messageTypeIder)
-	if !ok {
-		return errNoMessageTypeID
-	}
-
-	mtid := mti.MessageTypeId()
-	ms.Item = append(ms.Item, &_MessageSet_Item{
-		TypeId:  &mtid,
-		Message: msg,
-	})
-	return nil
-}
-
-func (ms *messageSet) Reset()         { *ms = messageSet{} }
-func (ms *messageSet) String() string { return CompactTextString(ms) }
-func (*messageSet) ProtoMessage()     {}
-
-// Support for the message_set_wire_format message option.
-
-func skipVarint(buf []byte) []byte {
-	i := 0
-	for ; buf[i]&0x80 != 0; i++ {
-	}
-	return buf[i+1:]
-}
-
-// MarshalMessageSet encodes the extension map represented by m in the message set wire format.
-// It is called by generated Marshal methods on protocol buffer messages with the message_set_wire_format option.
-func MarshalMessageSet(exts interface{}) ([]byte, error) {
-	return marshalMessageSet(exts, false)
-}
-
-// marshaMessageSet implements above function, with the opt to turn on / off deterministic during Marshal.
-func marshalMessageSet(exts interface{}, deterministic bool) ([]byte, error) {
-	switch exts := exts.(type) {
-	case *XXX_InternalExtensions:
-		var u marshalInfo
-		siz := u.sizeMessageSet(exts)
-		b := make([]byte, 0, siz)
-		return u.appendMessageSet(b, exts, deterministic)
-
-	case map[int32]Extension:
-		// This is an old-style extension map.
-		// Wrap it in a new-style XXX_InternalExtensions.
-		ie := XXX_InternalExtensions{
-			p: &struct {
-				mu           sync.Mutex
-				extensionMap map[int32]Extension
-			}{
-				extensionMap: exts,
-			},
-		}
-
-		var u marshalInfo
-		siz := u.sizeMessageSet(&ie)
-		b := make([]byte, 0, siz)
-		return u.appendMessageSet(b, &ie, deterministic)
-
-	default:
-		return nil, errors.New("proto: not an extension map")
-	}
-}
-
-// UnmarshalMessageSet decodes the extension map encoded in buf in the message set wire format.
-// It is called by Unmarshal methods on protocol buffer messages with the message_set_wire_format option.
-func UnmarshalMessageSet(buf []byte, exts interface{}) error {
-	var m map[int32]Extension
-	switch exts := exts.(type) {
-	case *XXX_InternalExtensions:
-		m = exts.extensionsWrite()
-	case map[int32]Extension:
-		m = exts
-	default:
-		return errors.New("proto: not an extension map")
-	}
-
-	ms := new(messageSet)
-	if err := Unmarshal(buf, ms); err != nil {
-		return err
-	}
-	for _, item := range ms.Item {
-		id := *item.TypeId
-		msg := item.Message
-
-		// Restore wire type and field number varint, plus length varint.
-		// Be careful to preserve duplicate items.
-		b := EncodeVarint(uint64(id)<<3 | WireBytes)
-		if ext, ok := m[id]; ok {
-			// Existing data; rip off the tag and length varint
-			// so we join the new data correctly.
-			// We can assume that ext.enc is set because we are unmarshaling.
-			o := ext.enc[len(b):]   // skip wire type and field number
-			_, n := DecodeVarint(o) // calculate length of length varint
-			o = o[n:]               // skip length varint
-			msg = append(o, msg...) // join old data and new data
-		}
-		b = append(b, EncodeVarint(uint64(len(msg)))...)
-		b = append(b, msg...)
-
-		m[id] = Extension{enc: b}
-	}
-	return nil
-}
-
-// MarshalMessageSetJSON encodes the extension map represented by m in JSON format.
-// It is called by generated MarshalJSON methods on protocol buffer messages with the message_set_wire_format option.
-func MarshalMessageSetJSON(exts interface{}) ([]byte, error) {
-	var m map[int32]Extension
-	switch exts := exts.(type) {
-	case *XXX_InternalExtensions:
-		var mu sync.Locker
-		m, mu = exts.extensionsRead()
-		if m != nil {
-			// Keep the extensions map locked until we're done marshaling to prevent
-			// races between marshaling and unmarshaling the lazily-{en,de}coded
-			// values.
-			mu.Lock()
-			defer mu.Unlock()
-		}
-	case map[int32]Extension:
-		m = exts
-	default:
-		return nil, errors.New("proto: not an extension map")
-	}
-	var b bytes.Buffer
-	b.WriteByte('{')
-
-	// Process the map in key order for deterministic output.
-	ids := make([]int32, 0, len(m))
-	for id := range m {
-		ids = append(ids, id)
-	}
-	sort.Sort(int32Slice(ids)) // int32Slice defined in text.go
-
-	for i, id := range ids {
-		ext := m[id]
-		msd, ok := messageSetMap[id]
-		if !ok {
-			// Unknown type; we can't render it, so skip it.
-			continue
-		}
-
-		if i > 0 && b.Len() > 1 {
-			b.WriteByte(',')
-		}
-
-		fmt.Fprintf(&b, `"[%s]":`, msd.name)
-
-		x := ext.value
-		if x == nil {
-			x = reflect.New(msd.t.Elem()).Interface()
-			if err := Unmarshal(ext.enc, x.(Message)); err != nil {
-				return nil, err
-			}
-		}
-		d, err := json.Marshal(x)
-		if err != nil {
-			return nil, err
-		}
-		b.Write(d)
-	}
-	b.WriteByte('}')
-	return b.Bytes(), nil
-}
-
-// UnmarshalMessageSetJSON decodes the extension map encoded in buf in JSON format.
-// It is called by generated UnmarshalJSON methods on protocol buffer messages with the message_set_wire_format option.
-func UnmarshalMessageSetJSON(buf []byte, exts interface{}) error {
-	// Common-case fast path.
-	if len(buf) == 0 || bytes.Equal(buf, []byte("{}")) {
-		return nil
-	}
-
-	// This is fairly tricky, and it's not clear that it is needed.
-	return errors.New("TODO: UnmarshalMessageSetJSON not yet implemented")
-}
-
-// A global registry of types that can be used in a MessageSet.
-
-var messageSetMap = make(map[int32]messageSetDesc)
-
-type messageSetDesc struct {
-	t    reflect.Type // pointer to struct
-	name string
-}
-
-// RegisterMessageSetType is called from the generated code.
-func RegisterMessageSetType(m Message, fieldNum int32, name string) {
-	messageSetMap[fieldNum] = messageSetDesc{
-		t:    reflect.TypeOf(m),
-		name: name,
-	}
-}
diff --git a/vendor/github.com/golang/protobuf/proto/message_set_test.go b/vendor/github.com/golang/protobuf/proto/message_set_test.go
deleted file mode 100644
index 2c170c5f2..000000000
--- a/vendor/github.com/golang/protobuf/proto/message_set_test.go
+++ /dev/null
@@ -1,77 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2014 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package proto
-
-import (
-	"bytes"
-	"testing"
-)
-
-func TestUnmarshalMessageSetWithDuplicate(t *testing.T) {
-	// Check that a repeated message set entry will be concatenated.
-	in := &messageSet{
-		Item: []*_MessageSet_Item{
-			{TypeId: Int32(12345), Message: []byte("hoo")},
-			{TypeId: Int32(12345), Message: []byte("hah")},
-		},
-	}
-	b, err := Marshal(in)
-	if err != nil {
-		t.Fatalf("Marshal: %v", err)
-	}
-	t.Logf("Marshaled bytes: %q", b)
-
-	var extensions XXX_InternalExtensions
-	if err := UnmarshalMessageSet(b, &extensions); err != nil {
-		t.Fatalf("UnmarshalMessageSet: %v", err)
-	}
-	ext, ok := extensions.p.extensionMap[12345]
-	if !ok {
-		t.Fatalf("Didn't retrieve extension 12345; map is %v", extensions.p.extensionMap)
-	}
-	// Skip wire type/field number and length varints.
-	got := skipVarint(skipVarint(ext.enc))
-	if want := []byte("hoohah"); !bytes.Equal(got, want) {
-		t.Errorf("Combined extension is %q, want %q", got, want)
-	}
-}
-
-func TestMarshalMessageSetJSON_UnknownType(t *testing.T) {
-	extMap := map[int32]Extension{12345: Extension{}}
-	got, err := MarshalMessageSetJSON(extMap)
-	if err != nil {
-		t.Fatalf("MarshalMessageSetJSON: %v", err)
-	}
-	if want := []byte("{}"); !bytes.Equal(got, want) {
-		t.Errorf("MarshalMessageSetJSON(%v) = %q, want %q", extMap, got, want)
-	}
-}
diff --git a/vendor/github.com/golang/protobuf/proto/pointer_reflect.go b/vendor/github.com/golang/protobuf/proto/pointer_reflect.go
deleted file mode 100644
index b6cad9083..000000000
--- a/vendor/github.com/golang/protobuf/proto/pointer_reflect.go
+++ /dev/null
@@ -1,357 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2012 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// +build purego appengine js
-
-// This file contains an implementation of proto field accesses using package reflect.
-// It is slower than the code in pointer_unsafe.go but it avoids package unsafe and can
-// be used on App Engine.
-
-package proto
-
-import (
-	"reflect"
-	"sync"
-)
-
-const unsafeAllowed = false
-
-// A field identifies a field in a struct, accessible from a pointer.
-// In this implementation, a field is identified by the sequence of field indices
-// passed to reflect's FieldByIndex.
-type field []int
-
-// toField returns a field equivalent to the given reflect field.
-func toField(f *reflect.StructField) field {
-	return f.Index
-}
-
-// invalidField is an invalid field identifier.
-var invalidField = field(nil)
-
-// zeroField is a noop when calling pointer.offset.
-var zeroField = field([]int{})
-
-// IsValid reports whether the field identifier is valid.
-func (f field) IsValid() bool { return f != nil }
-
-// The pointer type is for the table-driven decoder.
-// The implementation here uses a reflect.Value of pointer type to
-// create a generic pointer. In pointer_unsafe.go we use unsafe
-// instead of reflect to implement the same (but faster) interface.
-type pointer struct {
-	v reflect.Value
-}
-
-// toPointer converts an interface of pointer type to a pointer
-// that points to the same target.
-func toPointer(i *Message) pointer {
-	return pointer{v: reflect.ValueOf(*i)}
-}
-
-// toAddrPointer converts an interface to a pointer that points to
-// the interface data.
-func toAddrPointer(i *interface{}, isptr bool) pointer {
-	v := reflect.ValueOf(*i)
-	u := reflect.New(v.Type())
-	u.Elem().Set(v)
-	return pointer{v: u}
-}
-
-// valToPointer converts v to a pointer.  v must be of pointer type.
-func valToPointer(v reflect.Value) pointer {
-	return pointer{v: v}
-}
-
-// offset converts from a pointer to a structure to a pointer to
-// one of its fields.
-func (p pointer) offset(f field) pointer {
-	return pointer{v: p.v.Elem().FieldByIndex(f).Addr()}
-}
-
-func (p pointer) isNil() bool {
-	return p.v.IsNil()
-}
-
-// grow updates the slice s in place to make it one element longer.
-// s must be addressable.
-// Returns the (addressable) new element.
-func grow(s reflect.Value) reflect.Value {
-	n, m := s.Len(), s.Cap()
-	if n < m {
-		s.SetLen(n + 1)
-	} else {
-		s.Set(reflect.Append(s, reflect.Zero(s.Type().Elem())))
-	}
-	return s.Index(n)
-}
-
-func (p pointer) toInt64() *int64 {
-	return p.v.Interface().(*int64)
-}
-func (p pointer) toInt64Ptr() **int64 {
-	return p.v.Interface().(**int64)
-}
-func (p pointer) toInt64Slice() *[]int64 {
-	return p.v.Interface().(*[]int64)
-}
-
-var int32ptr = reflect.TypeOf((*int32)(nil))
-
-func (p pointer) toInt32() *int32 {
-	return p.v.Convert(int32ptr).Interface().(*int32)
-}
-
-// The toInt32Ptr/Slice methods don't work because of enums.
-// Instead, we must use set/get methods for the int32ptr/slice case.
-/*
-	func (p pointer) toInt32Ptr() **int32 {
-		return p.v.Interface().(**int32)
-}
-	func (p pointer) toInt32Slice() *[]int32 {
-		return p.v.Interface().(*[]int32)
-}
-*/
-func (p pointer) getInt32Ptr() *int32 {
-	if p.v.Type().Elem().Elem() == reflect.TypeOf(int32(0)) {
-		// raw int32 type
-		return p.v.Elem().Interface().(*int32)
-	}
-	// an enum
-	return p.v.Elem().Convert(int32PtrType).Interface().(*int32)
-}
-func (p pointer) setInt32Ptr(v int32) {
-	// Allocate value in a *int32. Possibly convert that to a *enum.
-	// Then assign it to a **int32 or **enum.
-	// Note: we can convert *int32 to *enum, but we can't convert
-	// **int32 to **enum!
-	p.v.Elem().Set(reflect.ValueOf(&v).Convert(p.v.Type().Elem()))
-}
-
-// getInt32Slice copies []int32 from p as a new slice.
-// This behavior differs from the implementation in pointer_unsafe.go.
-func (p pointer) getInt32Slice() []int32 {
-	if p.v.Type().Elem().Elem() == reflect.TypeOf(int32(0)) {
-		// raw int32 type
-		return p.v.Elem().Interface().([]int32)
-	}
-	// an enum
-	// Allocate a []int32, then assign []enum's values into it.
-	// Note: we can't convert []enum to []int32.
-	slice := p.v.Elem()
-	s := make([]int32, slice.Len())
-	for i := 0; i < slice.Len(); i++ {
-		s[i] = int32(slice.Index(i).Int())
-	}
-	return s
-}
-
-// setInt32Slice copies []int32 into p as a new slice.
-// This behavior differs from the implementation in pointer_unsafe.go.
-func (p pointer) setInt32Slice(v []int32) {
-	if p.v.Type().Elem().Elem() == reflect.TypeOf(int32(0)) {
-		// raw int32 type
-		p.v.Elem().Set(reflect.ValueOf(v))
-		return
-	}
-	// an enum
-	// Allocate a []enum, then assign []int32's values into it.
-	// Note: we can't convert []enum to []int32.
-	slice := reflect.MakeSlice(p.v.Type().Elem(), len(v), cap(v))
-	for i, x := range v {
-		slice.Index(i).SetInt(int64(x))
-	}
-	p.v.Elem().Set(slice)
-}
-func (p pointer) appendInt32Slice(v int32) {
-	grow(p.v.Elem()).SetInt(int64(v))
-}
-
-func (p pointer) toUint64() *uint64 {
-	return p.v.Interface().(*uint64)
-}
-func (p pointer) toUint64Ptr() **uint64 {
-	return p.v.Interface().(**uint64)
-}
-func (p pointer) toUint64Slice() *[]uint64 {
-	return p.v.Interface().(*[]uint64)
-}
-func (p pointer) toUint32() *uint32 {
-	return p.v.Interface().(*uint32)
-}
-func (p pointer) toUint32Ptr() **uint32 {
-	return p.v.Interface().(**uint32)
-}
-func (p pointer) toUint32Slice() *[]uint32 {
-	return p.v.Interface().(*[]uint32)
-}
-func (p pointer) toBool() *bool {
-	return p.v.Interface().(*bool)
-}
-func (p pointer) toBoolPtr() **bool {
-	return p.v.Interface().(**bool)
-}
-func (p pointer) toBoolSlice() *[]bool {
-	return p.v.Interface().(*[]bool)
-}
-func (p pointer) toFloat64() *float64 {
-	return p.v.Interface().(*float64)
-}
-func (p pointer) toFloat64Ptr() **float64 {
-	return p.v.Interface().(**float64)
-}
-func (p pointer) toFloat64Slice() *[]float64 {
-	return p.v.Interface().(*[]float64)
-}
-func (p pointer) toFloat32() *float32 {
-	return p.v.Interface().(*float32)
-}
-func (p pointer) toFloat32Ptr() **float32 {
-	return p.v.Interface().(**float32)
-}
-func (p pointer) toFloat32Slice() *[]float32 {
-	return p.v.Interface().(*[]float32)
-}
-func (p pointer) toString() *string {
-	return p.v.Interface().(*string)
-}
-func (p pointer) toStringPtr() **string {
-	return p.v.Interface().(**string)
-}
-func (p pointer) toStringSlice() *[]string {
-	return p.v.Interface().(*[]string)
-}
-func (p pointer) toBytes() *[]byte {
-	return p.v.Interface().(*[]byte)
-}
-func (p pointer) toBytesSlice() *[][]byte {
-	return p.v.Interface().(*[][]byte)
-}
-func (p pointer) toExtensions() *XXX_InternalExtensions {
-	return p.v.Interface().(*XXX_InternalExtensions)
-}
-func (p pointer) toOldExtensions() *map[int32]Extension {
-	return p.v.Interface().(*map[int32]Extension)
-}
-func (p pointer) getPointer() pointer {
-	return pointer{v: p.v.Elem()}
-}
-func (p pointer) setPointer(q pointer) {
-	p.v.Elem().Set(q.v)
-}
-func (p pointer) appendPointer(q pointer) {
-	grow(p.v.Elem()).Set(q.v)
-}
-
-// getPointerSlice copies []*T from p as a new []pointer.
-// This behavior differs from the implementation in pointer_unsafe.go.
-func (p pointer) getPointerSlice() []pointer {
-	if p.v.IsNil() {
-		return nil
-	}
-	n := p.v.Elem().Len()
-	s := make([]pointer, n)
-	for i := 0; i < n; i++ {
-		s[i] = pointer{v: p.v.Elem().Index(i)}
-	}
-	return s
-}
-
-// setPointerSlice copies []pointer into p as a new []*T.
-// This behavior differs from the implementation in pointer_unsafe.go.
-func (p pointer) setPointerSlice(v []pointer) {
-	if v == nil {
-		p.v.Elem().Set(reflect.New(p.v.Elem().Type()).Elem())
-		return
-	}
-	s := reflect.MakeSlice(p.v.Elem().Type(), 0, len(v))
-	for _, p := range v {
-		s = reflect.Append(s, p.v)
-	}
-	p.v.Elem().Set(s)
-}
-
-// getInterfacePointer returns a pointer that points to the
-// interface data of the interface pointed by p.
-func (p pointer) getInterfacePointer() pointer {
-	if p.v.Elem().IsNil() {
-		return pointer{v: p.v.Elem()}
-	}
-	return pointer{v: p.v.Elem().Elem().Elem().Field(0).Addr()} // *interface -> interface -> *struct -> struct
-}
-
-func (p pointer) asPointerTo(t reflect.Type) reflect.Value {
-	// TODO: check that p.v.Type().Elem() == t?
-	return p.v
-}
-
-func atomicLoadUnmarshalInfo(p **unmarshalInfo) *unmarshalInfo {
-	atomicLock.Lock()
-	defer atomicLock.Unlock()
-	return *p
-}
-func atomicStoreUnmarshalInfo(p **unmarshalInfo, v *unmarshalInfo) {
-	atomicLock.Lock()
-	defer atomicLock.Unlock()
-	*p = v
-}
-func atomicLoadMarshalInfo(p **marshalInfo) *marshalInfo {
-	atomicLock.Lock()
-	defer atomicLock.Unlock()
-	return *p
-}
-func atomicStoreMarshalInfo(p **marshalInfo, v *marshalInfo) {
-	atomicLock.Lock()
-	defer atomicLock.Unlock()
-	*p = v
-}
-func atomicLoadMergeInfo(p **mergeInfo) *mergeInfo {
-	atomicLock.Lock()
-	defer atomicLock.Unlock()
-	return *p
-}
-func atomicStoreMergeInfo(p **mergeInfo, v *mergeInfo) {
-	atomicLock.Lock()
-	defer atomicLock.Unlock()
-	*p = v
-}
-func atomicLoadDiscardInfo(p **discardInfo) *discardInfo {
-	atomicLock.Lock()
-	defer atomicLock.Unlock()
-	return *p
-}
-func atomicStoreDiscardInfo(p **discardInfo, v *discardInfo) {
-	atomicLock.Lock()
-	defer atomicLock.Unlock()
-	*p = v
-}
-
-var atomicLock sync.Mutex
diff --git a/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go b/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go
deleted file mode 100644
index d55a335d9..000000000
--- a/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go
+++ /dev/null
@@ -1,308 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2012 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// +build !purego,!appengine,!js
-
-// This file contains the implementation of the proto field accesses using package unsafe.
-
-package proto
-
-import (
-	"reflect"
-	"sync/atomic"
-	"unsafe"
-)
-
-const unsafeAllowed = true
-
-// A field identifies a field in a struct, accessible from a pointer.
-// In this implementation, a field is identified by its byte offset from the start of the struct.
-type field uintptr
-
-// toField returns a field equivalent to the given reflect field.
-func toField(f *reflect.StructField) field {
-	return field(f.Offset)
-}
-
-// invalidField is an invalid field identifier.
-const invalidField = ^field(0)
-
-// zeroField is a noop when calling pointer.offset.
-const zeroField = field(0)
-
-// IsValid reports whether the field identifier is valid.
-func (f field) IsValid() bool {
-	return f != invalidField
-}
-
-// The pointer type below is for the new table-driven encoder/decoder.
-// The implementation here uses unsafe.Pointer to create a generic pointer.
-// In pointer_reflect.go we use reflect instead of unsafe to implement
-// the same (but slower) interface.
-type pointer struct {
-	p unsafe.Pointer
-}
-
-// size of pointer
-var ptrSize = unsafe.Sizeof(uintptr(0))
-
-// toPointer converts an interface of pointer type to a pointer
-// that points to the same target.
-func toPointer(i *Message) pointer {
-	// Super-tricky - read pointer out of data word of interface value.
-	// Saves ~25ns over the equivalent:
-	// return valToPointer(reflect.ValueOf(*i))
-	return pointer{p: (*[2]unsafe.Pointer)(unsafe.Pointer(i))[1]}
-}
-
-// toAddrPointer converts an interface to a pointer that points to
-// the interface data.
-func toAddrPointer(i *interface{}, isptr bool) pointer {
-	// Super-tricky - read or get the address of data word of interface value.
-	if isptr {
-		// The interface is of pointer type, thus it is a direct interface.
-		// The data word is the pointer data itself. We take its address.
-		return pointer{p: unsafe.Pointer(uintptr(unsafe.Pointer(i)) + ptrSize)}
-	}
-	// The interface is not of pointer type. The data word is the pointer
-	// to the data.
-	return pointer{p: (*[2]unsafe.Pointer)(unsafe.Pointer(i))[1]}
-}
-
-// valToPointer converts v to a pointer. v must be of pointer type.
-func valToPointer(v reflect.Value) pointer {
-	return pointer{p: unsafe.Pointer(v.Pointer())}
-}
-
-// offset converts from a pointer to a structure to a pointer to
-// one of its fields.
-func (p pointer) offset(f field) pointer {
-	// For safety, we should panic if !f.IsValid, however calling panic causes
-	// this to no longer be inlineable, which is a serious performance cost.
-	/*
-		if !f.IsValid() {
-			panic("invalid field")
-		}
-	*/
-	return pointer{p: unsafe.Pointer(uintptr(p.p) + uintptr(f))}
-}
-
-func (p pointer) isNil() bool {
-	return p.p == nil
-}
-
-func (p pointer) toInt64() *int64 {
-	return (*int64)(p.p)
-}
-func (p pointer) toInt64Ptr() **int64 {
-	return (**int64)(p.p)
-}
-func (p pointer) toInt64Slice() *[]int64 {
-	return (*[]int64)(p.p)
-}
-func (p pointer) toInt32() *int32 {
-	return (*int32)(p.p)
-}
-
-// See pointer_reflect.go for why toInt32Ptr/Slice doesn't exist.
-/*
-	func (p pointer) toInt32Ptr() **int32 {
-		return (**int32)(p.p)
-	}
-	func (p pointer) toInt32Slice() *[]int32 {
-		return (*[]int32)(p.p)
-	}
-*/
-func (p pointer) getInt32Ptr() *int32 {
-	return *(**int32)(p.p)
-}
-func (p pointer) setInt32Ptr(v int32) {
-	*(**int32)(p.p) = &v
-}
-
-// getInt32Slice loads a []int32 from p.
-// The value returned is aliased with the original slice.
-// This behavior differs from the implementation in pointer_reflect.go.
-func (p pointer) getInt32Slice() []int32 {
-	return *(*[]int32)(p.p)
-}
-
-// setInt32Slice stores a []int32 to p.
-// The value set is aliased with the input slice.
-// This behavior differs from the implementation in pointer_reflect.go.
-func (p pointer) setInt32Slice(v []int32) {
-	*(*[]int32)(p.p) = v
-}
-
-// TODO: Can we get rid of appendInt32Slice and use setInt32Slice instead?
-func (p pointer) appendInt32Slice(v int32) {
-	s := (*[]int32)(p.p)
-	*s = append(*s, v)
-}
-
-func (p pointer) toUint64() *uint64 {
-	return (*uint64)(p.p)
-}
-func (p pointer) toUint64Ptr() **uint64 {
-	return (**uint64)(p.p)
-}
-func (p pointer) toUint64Slice() *[]uint64 {
-	return (*[]uint64)(p.p)
-}
-func (p pointer) toUint32() *uint32 {
-	return (*uint32)(p.p)
-}
-func (p pointer) toUint32Ptr() **uint32 {
-	return (**uint32)(p.p)
-}
-func (p pointer) toUint32Slice() *[]uint32 {
-	return (*[]uint32)(p.p)
-}
-func (p pointer) toBool() *bool {
-	return (*bool)(p.p)
-}
-func (p pointer) toBoolPtr() **bool {
-	return (**bool)(p.p)
-}
-func (p pointer) toBoolSlice() *[]bool {
-	return (*[]bool)(p.p)
-}
-func (p pointer) toFloat64() *float64 {
-	return (*float64)(p.p)
-}
-func (p pointer) toFloat64Ptr() **float64 {
-	return (**float64)(p.p)
-}
-func (p pointer) toFloat64Slice() *[]float64 {
-	return (*[]float64)(p.p)
-}
-func (p pointer) toFloat32() *float32 {
-	return (*float32)(p.p)
-}
-func (p pointer) toFloat32Ptr() **float32 {
-	return (**float32)(p.p)
-}
-func (p pointer) toFloat32Slice() *[]float32 {
-	return (*[]float32)(p.p)
-}
-func (p pointer) toString() *string {
-	return (*string)(p.p)
-}
-func (p pointer) toStringPtr() **string {
-	return (**string)(p.p)
-}
-func (p pointer) toStringSlice() *[]string {
-	return (*[]string)(p.p)
-}
-func (p pointer) toBytes() *[]byte {
-	return (*[]byte)(p.p)
-}
-func (p pointer) toBytesSlice() *[][]byte {
-	return (*[][]byte)(p.p)
-}
-func (p pointer) toExtensions() *XXX_InternalExtensions {
-	return (*XXX_InternalExtensions)(p.p)
-}
-func (p pointer) toOldExtensions() *map[int32]Extension {
-	return (*map[int32]Extension)(p.p)
-}
-
-// getPointerSlice loads []*T from p as a []pointer.
-// The value returned is aliased with the original slice.
-// This behavior differs from the implementation in pointer_reflect.go.
-func (p pointer) getPointerSlice() []pointer {
-	// Super-tricky - p should point to a []*T where T is a
-	// message type. We load it as []pointer.
-	return *(*[]pointer)(p.p)
-}
-
-// setPointerSlice stores []pointer into p as a []*T.
-// The value set is aliased with the input slice.
-// This behavior differs from the implementation in pointer_reflect.go.
-func (p pointer) setPointerSlice(v []pointer) {
-	// Super-tricky - p should point to a []*T where T is a
-	// message type. We store it as []pointer.
-	*(*[]pointer)(p.p) = v
-}
-
-// getPointer loads the pointer at p and returns it.
-func (p pointer) getPointer() pointer {
-	return pointer{p: *(*unsafe.Pointer)(p.p)}
-}
-
-// setPointer stores the pointer q at p.
-func (p pointer) setPointer(q pointer) {
-	*(*unsafe.Pointer)(p.p) = q.p
-}
-
-// append q to the slice pointed to by p.
-func (p pointer) appendPointer(q pointer) {
-	s := (*[]unsafe.Pointer)(p.p)
-	*s = append(*s, q.p)
-}
-
-// getInterfacePointer returns a pointer that points to the
-// interface data of the interface pointed by p.
-func (p pointer) getInterfacePointer() pointer {
-	// Super-tricky - read pointer out of data word of interface value.
-	return pointer{p: (*(*[2]unsafe.Pointer)(p.p))[1]}
-}
-
-// asPointerTo returns a reflect.Value that is a pointer to an
-// object of type t stored at p.
-func (p pointer) asPointerTo(t reflect.Type) reflect.Value {
-	return reflect.NewAt(t, p.p)
-}
-
-func atomicLoadUnmarshalInfo(p **unmarshalInfo) *unmarshalInfo {
-	return (*unmarshalInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))
-}
-func atomicStoreUnmarshalInfo(p **unmarshalInfo, v *unmarshalInfo) {
-	atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v))
-}
-func atomicLoadMarshalInfo(p **marshalInfo) *marshalInfo {
-	return (*marshalInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))
-}
-func atomicStoreMarshalInfo(p **marshalInfo, v *marshalInfo) {
-	atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v))
-}
-func atomicLoadMergeInfo(p **mergeInfo) *mergeInfo {
-	return (*mergeInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))
-}
-func atomicStoreMergeInfo(p **mergeInfo, v *mergeInfo) {
-	atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v))
-}
-func atomicLoadDiscardInfo(p **discardInfo) *discardInfo {
-	return (*discardInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))
-}
-func atomicStoreDiscardInfo(p **discardInfo, v *discardInfo) {
-	atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v))
-}
diff --git a/vendor/github.com/golang/protobuf/proto/properties.go b/vendor/github.com/golang/protobuf/proto/properties.go
index f710adab0..dcdc2202f 100644
--- a/vendor/github.com/golang/protobuf/proto/properties.go
+++ b/vendor/github.com/golang/protobuf/proto/properties.go
@@ -1,163 +1,104 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// Copyright 2010 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 proto
 
-/*
- * Routines for encoding data into the wire format for protocol buffers.
- */
-
 import (
 	"fmt"
-	"log"
-	"os"
 	"reflect"
-	"sort"
 	"strconv"
 	"strings"
 	"sync"
-)
-
-const debug bool = false
 
-// Constants that identify the encoding of a value on the wire.
-const (
-	WireVarint     = 0
-	WireFixed64    = 1
-	WireBytes      = 2
-	WireStartGroup = 3
-	WireEndGroup   = 4
-	WireFixed32    = 5
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/runtime/protoimpl"
 )
 
-// tagMap is an optimization over map[int]int for typical protocol buffer
-// use-cases. Encoded protocol buffers are often in tag order with small tag
-// numbers.
-type tagMap struct {
-	fastTags []int
-	slowTags map[int]int
-}
-
-// tagMapFastLimit is the upper bound on the tag number that will be stored in
-// the tagMap slice rather than its map.
-const tagMapFastLimit = 1024
-
-func (p *tagMap) get(t int) (int, bool) {
-	if t > 0 && t < tagMapFastLimit {
-		if t >= len(p.fastTags) {
-			return 0, false
-		}
-		fi := p.fastTags[t]
-		return fi, fi >= 0
-	}
-	fi, ok := p.slowTags[t]
-	return fi, ok
-}
-
-func (p *tagMap) put(t int, fi int) {
-	if t > 0 && t < tagMapFastLimit {
-		for len(p.fastTags) < t+1 {
-			p.fastTags = append(p.fastTags, -1)
-		}
-		p.fastTags[t] = fi
-		return
-	}
-	if p.slowTags == nil {
-		p.slowTags = make(map[int]int)
-	}
-	p.slowTags[t] = fi
-}
-
-// StructProperties represents properties for all the fields of a struct.
-// decoderTags and decoderOrigNames should only be used by the decoder.
+// StructProperties represents protocol buffer type information for a
+// generated protobuf message in the open-struct API.
+//
+// Deprecated: Do not use.
 type StructProperties struct {
-	Prop             []*Properties  // properties for each field
-	reqCount         int            // required count
-	decoderTags      tagMap         // map from proto tag to struct field number
-	decoderOrigNames map[string]int // map from original name to struct field number
-	order            []int          // list of struct field numbers in tag order
+	// Prop are the properties for each field.
+	//
+	// Fields belonging to a oneof are stored in OneofTypes instead, with a
+	// single Properties representing the parent oneof held here.
+	//
+	// The order of Prop matches the order of fields in the Go struct.
+	// Struct fields that are not related to protobufs have a "XXX_" prefix
+	// in the Properties.Name and must be ignored by the user.
+	Prop []*Properties
 
 	// OneofTypes contains information about the oneof fields in this message.
-	// It is keyed by the original name of a field.
+	// It is keyed by the protobuf field name.
 	OneofTypes map[string]*OneofProperties
 }
 
-// OneofProperties represents information about a specific field in a oneof.
-type OneofProperties struct {
-	Type  reflect.Type // pointer to generated struct type for this oneof field
-	Field int          // struct field number of the containing oneof in the message
-	Prop  *Properties
-}
-
-// Implement the sorting interface so we can sort the fields in tag order, as recommended by the spec.
-// See encode.go, (*Buffer).enc_struct.
-
-func (sp *StructProperties) Len() int { return len(sp.order) }
-func (sp *StructProperties) Less(i, j int) bool {
-	return sp.Prop[sp.order[i]].Tag < sp.Prop[sp.order[j]].Tag
-}
-func (sp *StructProperties) Swap(i, j int) { sp.order[i], sp.order[j] = sp.order[j], sp.order[i] }
-
-// Properties represents the protocol-specific behavior of a single struct field.
+// Properties represents the type information for a protobuf message field.
+//
+// Deprecated: Do not use.
 type Properties struct {
-	Name     string // name of the field, for error messages
-	OrigName string // original name before protocol compiler (always set)
-	JSONName string // name to use for JSON; determined by protoc
-	Wire     string
+	// Name is a placeholder name with little meaningful semantic value.
+	// If the name has an "XXX_" prefix, the entire Properties must be ignored.
+	Name string
+	// OrigName is the protobuf field name or oneof name.
+	OrigName string
+	// JSONName is the JSON name for the protobuf field.
+	JSONName string
+	// Enum is a placeholder name for enums.
+	// For historical reasons, this is neither the Go name for the enum,
+	// nor the protobuf name for the enum.
+	Enum string // Deprecated: Do not use.
+	// Weak contains the full name of the weakly referenced message.
+	Weak string
+	// Wire is a string representation of the wire type.
+	Wire string
+	// WireType is the protobuf wire type for the field.
 	WireType int
-	Tag      int
+	// Tag is the protobuf field number.
+	Tag int
+	// Required reports whether this is a required field.
 	Required bool
+	// Optional reports whether this is a optional field.
 	Optional bool
+	// Repeated reports whether this is a repeated field.
 	Repeated bool
-	Packed   bool   // relevant for repeated primitives only
-	Enum     string // set for enum types only
-	proto3   bool   // whether this is known to be a proto3 field; set for []byte only
-	oneof    bool   // whether this is a oneof field
-
-	Default    string // default value
-	HasDefault bool   // whether an explicit default was provided
-
-	stype reflect.Type      // set for struct types only
-	sprop *StructProperties // set for struct types only
+	// Packed reports whether this is a packed repeated field of scalars.
+	Packed bool
+	// Proto3 reports whether this field operates under the proto3 syntax.
+	Proto3 bool
+	// Oneof reports whether this field belongs within a oneof.
+	Oneof bool
+
+	// Default is the default value in string form.
+	Default string
+	// HasDefault reports whether the field has a default value.
+	HasDefault bool
+
+	// MapKeyProp is the properties for the key field for a map field.
+	MapKeyProp *Properties
+	// MapValProp is the properties for the value field for a map field.
+	MapValProp *Properties
+}
 
-	mtype    reflect.Type // set for map types only
-	mkeyprop *Properties  // set for map types only
-	mvalprop *Properties  // set for map types only
+// OneofProperties represents the type information for a protobuf oneof.
+//
+// Deprecated: Do not use.
+type OneofProperties struct {
+	// Type is a pointer to the generated wrapper type for the field value.
+	// This is nil for messages that are not in the open-struct API.
+	Type reflect.Type
+	// Field is the index into StructProperties.Prop for the containing oneof.
+	Field int
+	// Prop is the properties for the field.
+	Prop *Properties
 }
 
 // String formats the properties in the protobuf struct field tag style.
 func (p *Properties) String() string {
 	s := p.Wire
-	s += ","
-	s += strconv.Itoa(p.Tag)
+	s += "," + strconv.Itoa(p.Tag)
 	if p.Required {
 		s += ",req"
 	}
@@ -171,18 +112,21 @@ func (p *Properties) String() string {
 		s += ",packed"
 	}
 	s += ",name=" + p.OrigName
-	if p.JSONName != p.OrigName {
+	if p.JSONName != "" {
 		s += ",json=" + p.JSONName
 	}
-	if p.proto3 {
+	if len(p.Enum) > 0 {
+		s += ",enum=" + p.Enum
+	}
+	if len(p.Weak) > 0 {
+		s += ",weak=" + p.Weak
+	}
+	if p.Proto3 {
 		s += ",proto3"
 	}
-	if p.oneof {
+	if p.Oneof {
 		s += ",oneof"
 	}
-	if len(p.Enum) > 0 {
-		s += ",enum=" + p.Enum
-	}
 	if p.HasDefault {
 		s += ",def=" + p.Default
 	}
@@ -190,355 +134,173 @@ func (p *Properties) String() string {
 }
 
 // Parse populates p by parsing a string in the protobuf struct field tag style.
-func (p *Properties) Parse(s string) {
-	// "bytes,49,opt,name=foo,def=hello!"
-	fields := strings.Split(s, ",") // breaks def=, but handled below.
-	if len(fields) < 2 {
-		fmt.Fprintf(os.Stderr, "proto: tag has too few fields: %q\n", s)
-		return
-	}
-
-	p.Wire = fields[0]
-	switch p.Wire {
-	case "varint":
-		p.WireType = WireVarint
-	case "fixed32":
-		p.WireType = WireFixed32
-	case "fixed64":
-		p.WireType = WireFixed64
-	case "zigzag32":
-		p.WireType = WireVarint
-	case "zigzag64":
-		p.WireType = WireVarint
-	case "bytes", "group":
-		p.WireType = WireBytes
-		// no numeric converter for non-numeric types
-	default:
-		fmt.Fprintf(os.Stderr, "proto: tag has unknown wire type: %q\n", s)
-		return
-	}
-
-	var err error
-	p.Tag, err = strconv.Atoi(fields[1])
-	if err != nil {
-		return
-	}
-
-outer:
-	for i := 2; i < len(fields); i++ {
-		f := fields[i]
-		switch {
-		case f == "req":
-			p.Required = true
-		case f == "opt":
+func (p *Properties) Parse(tag string) {
+	// For example: "bytes,49,opt,name=foo,def=hello!"
+	for len(tag) > 0 {
+		i := strings.IndexByte(tag, ',')
+		if i < 0 {
+			i = len(tag)
+		}
+		switch s := tag[:i]; {
+		case strings.HasPrefix(s, "name="):
+			p.OrigName = s[len("name="):]
+		case strings.HasPrefix(s, "json="):
+			p.JSONName = s[len("json="):]
+		case strings.HasPrefix(s, "enum="):
+			p.Enum = s[len("enum="):]
+		case strings.HasPrefix(s, "weak="):
+			p.Weak = s[len("weak="):]
+		case strings.Trim(s, "0123456789") == "":
+			n, _ := strconv.ParseUint(s, 10, 32)
+			p.Tag = int(n)
+		case s == "opt":
 			p.Optional = true
-		case f == "rep":
+		case s == "req":
+			p.Required = true
+		case s == "rep":
 			p.Repeated = true
-		case f == "packed":
+		case s == "varint" || s == "zigzag32" || s == "zigzag64":
+			p.Wire = s
+			p.WireType = WireVarint
+		case s == "fixed32":
+			p.Wire = s
+			p.WireType = WireFixed32
+		case s == "fixed64":
+			p.Wire = s
+			p.WireType = WireFixed64
+		case s == "bytes":
+			p.Wire = s
+			p.WireType = WireBytes
+		case s == "group":
+			p.Wire = s
+			p.WireType = WireStartGroup
+		case s == "packed":
 			p.Packed = true
-		case strings.HasPrefix(f, "name="):
-			p.OrigName = f[5:]
-		case strings.HasPrefix(f, "json="):
-			p.JSONName = f[5:]
-		case strings.HasPrefix(f, "enum="):
-			p.Enum = f[5:]
-		case f == "proto3":
-			p.proto3 = true
-		case f == "oneof":
-			p.oneof = true
-		case strings.HasPrefix(f, "def="):
+		case s == "proto3":
+			p.Proto3 = true
+		case s == "oneof":
+			p.Oneof = true
+		case strings.HasPrefix(s, "def="):
+			// The default tag is special in that everything afterwards is the
+			// default regardless of the presence of commas.
 			p.HasDefault = true
-			p.Default = f[4:] // rest of string
-			if i+1 < len(fields) {
-				// Commas aren't escaped, and def is always last.
-				p.Default += "," + strings.Join(fields[i+1:], ",")
-				break outer
-			}
-		}
-	}
-}
-
-var protoMessageType = reflect.TypeOf((*Message)(nil)).Elem()
-
-// setFieldProps initializes the field properties for submessages and maps.
-func (p *Properties) setFieldProps(typ reflect.Type, f *reflect.StructField, lockGetProp bool) {
-	switch t1 := typ; t1.Kind() {
-	case reflect.Ptr:
-		if t1.Elem().Kind() == reflect.Struct {
-			p.stype = t1.Elem()
-		}
-
-	case reflect.Slice:
-		if t2 := t1.Elem(); t2.Kind() == reflect.Ptr && t2.Elem().Kind() == reflect.Struct {
-			p.stype = t2.Elem()
-		}
-
-	case reflect.Map:
-		p.mtype = t1
-		p.mkeyprop = &Properties{}
-		p.mkeyprop.init(reflect.PtrTo(p.mtype.Key()), "Key", f.Tag.Get("protobuf_key"), nil, lockGetProp)
-		p.mvalprop = &Properties{}
-		vtype := p.mtype.Elem()
-		if vtype.Kind() != reflect.Ptr && vtype.Kind() != reflect.Slice {
-			// The value type is not a message (*T) or bytes ([]byte),
-			// so we need encoders for the pointer to this type.
-			vtype = reflect.PtrTo(vtype)
-		}
-		p.mvalprop.init(vtype, "Value", f.Tag.Get("protobuf_val"), nil, lockGetProp)
-	}
-
-	if p.stype != nil {
-		if lockGetProp {
-			p.sprop = GetProperties(p.stype)
-		} else {
-			p.sprop = getPropertiesLocked(p.stype)
+			p.Default, i = tag[len("def="):], len(tag)
 		}
+		tag = strings.TrimPrefix(tag[i:], ",")
 	}
 }
 
-var (
-	marshalerType = reflect.TypeOf((*Marshaler)(nil)).Elem()
-)
-
 // Init populates the properties from a protocol buffer struct tag.
+//
+// Deprecated: Do not use.
 func (p *Properties) Init(typ reflect.Type, name, tag string, f *reflect.StructField) {
-	p.init(typ, name, tag, f, true)
-}
-
-func (p *Properties) init(typ reflect.Type, name, tag string, f *reflect.StructField, lockGetProp bool) {
-	// "bytes,49,opt,def=hello!"
 	p.Name = name
 	p.OrigName = name
 	if tag == "" {
 		return
 	}
 	p.Parse(tag)
-	p.setFieldProps(typ, f, lockGetProp)
+
+	if typ != nil && typ.Kind() == reflect.Map {
+		p.MapKeyProp = new(Properties)
+		p.MapKeyProp.Init(nil, "Key", f.Tag.Get("protobuf_key"), nil)
+		p.MapValProp = new(Properties)
+		p.MapValProp.Init(nil, "Value", f.Tag.Get("protobuf_val"), nil)
+	}
 }
 
-var (
-	propertiesMu  sync.RWMutex
-	propertiesMap = make(map[reflect.Type]*StructProperties)
-)
+var propertiesCache sync.Map // map[reflect.Type]*StructProperties
 
-// GetProperties returns the list of properties for the type represented by t.
-// t must represent a generated struct type of a protocol message.
+// GetProperties returns the list of properties for the type represented by t,
+// which must be a generated protocol buffer message in the open-struct API,
+// where protobuf message fields are represented by exported Go struct fields.
+//
+// Deprecated: Use protobuf reflection instead.
 func GetProperties(t reflect.Type) *StructProperties {
-	if t.Kind() != reflect.Struct {
-		panic("proto: type must have kind struct")
-	}
-
-	// Most calls to GetProperties in a long-running program will be
-	// retrieving details for types we have seen before.
-	propertiesMu.RLock()
-	sprop, ok := propertiesMap[t]
-	propertiesMu.RUnlock()
-	if ok {
-		if collectStats {
-			stats.Chit++
-		}
-		return sprop
+	if p, ok := propertiesCache.Load(t); ok {
+		return p.(*StructProperties)
 	}
-
-	propertiesMu.Lock()
-	sprop = getPropertiesLocked(t)
-	propertiesMu.Unlock()
-	return sprop
+	p, _ := propertiesCache.LoadOrStore(t, newProperties(t))
+	return p.(*StructProperties)
 }
 
-// getPropertiesLocked requires that propertiesMu is held.
-func getPropertiesLocked(t reflect.Type) *StructProperties {
-	if prop, ok := propertiesMap[t]; ok {
-		if collectStats {
-			stats.Chit++
-		}
-		return prop
-	}
-	if collectStats {
-		stats.Cmiss++
+func newProperties(t reflect.Type) *StructProperties {
+	if t.Kind() != reflect.Struct {
+		panic(fmt.Sprintf("%v is not a generated message in the open-struct API", t))
 	}
 
+	var hasOneof bool
 	prop := new(StructProperties)
-	// in case of recursive protos, fill this in now.
-	propertiesMap[t] = prop
-
-	// build properties
-	prop.Prop = make([]*Properties, t.NumField())
-	prop.order = make([]int, t.NumField())
 
+	// Construct a list of properties for each field in the struct.
 	for i := 0; i < t.NumField(); i++ {
-		f := t.Field(i)
 		p := new(Properties)
-		name := f.Name
-		p.init(f.Type, name, f.Tag.Get("protobuf"), &f, false)
+		f := t.Field(i)
+		tagField := f.Tag.Get("protobuf")
+		p.Init(f.Type, f.Name, tagField, &f)
 
-		oneof := f.Tag.Get("protobuf_oneof") // special case
-		if oneof != "" {
-			// Oneof fields don't use the traditional protobuf tag.
-			p.OrigName = oneof
-		}
-		prop.Prop[i] = p
-		prop.order[i] = i
-		if debug {
-			print(i, " ", f.Name, " ", t.String(), " ")
-			if p.Tag > 0 {
-				print(p.String())
-			}
-			print("\n")
+		tagOneof := f.Tag.Get("protobuf_oneof")
+		if tagOneof != "" {
+			hasOneof = true
+			p.OrigName = tagOneof
 		}
-	}
 
-	// Re-order prop.order.
-	sort.Sort(prop)
+		// Rename unrelated struct fields with the "XXX_" prefix since so much
+		// user code simply checks for this to exclude special fields.
+		if tagField == "" && tagOneof == "" && !strings.HasPrefix(p.Name, "XXX_") {
+			p.Name = "XXX_" + p.Name
+			p.OrigName = "XXX_" + p.OrigName
+		} else if p.Weak != "" {
+			p.Name = p.OrigName // avoid possible "XXX_" prefix on weak field
+		}
 
-	type oneofMessage interface {
-		XXX_OneofFuncs() (func(Message, *Buffer) error, func(Message, int, int, *Buffer) (bool, error), func(Message) int, []interface{})
+		prop.Prop = append(prop.Prop, p)
 	}
-	if om, ok := reflect.Zero(reflect.PtrTo(t)).Interface().(oneofMessage); ok {
-		var oots []interface{}
-		_, _, _, oots = om.XXX_OneofFuncs()
 
-		// Interpret oneof metadata.
+	// Construct a mapping of oneof field names to properties.
+	if hasOneof {
+		var oneofWrappers []interface{}
+		if fn, ok := reflect.PtrTo(t).MethodByName("XXX_OneofFuncs"); ok {
+			oneofWrappers = fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[3].Interface().([]interface{})
+		}
+		if fn, ok := reflect.PtrTo(t).MethodByName("XXX_OneofWrappers"); ok {
+			oneofWrappers = fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[0].Interface().([]interface{})
+		}
+		if m, ok := reflect.Zero(reflect.PtrTo(t)).Interface().(protoreflect.ProtoMessage); ok {
+			if m, ok := m.ProtoReflect().(interface{ ProtoMessageInfo() *protoimpl.MessageInfo }); ok {
+				oneofWrappers = m.ProtoMessageInfo().OneofWrappers
+			}
+		}
+
 		prop.OneofTypes = make(map[string]*OneofProperties)
-		for _, oot := range oots {
-			oop := &OneofProperties{
-				Type: reflect.ValueOf(oot).Type(), // *T
+		for _, wrapper := range oneofWrappers {
+			p := &OneofProperties{
+				Type: reflect.ValueOf(wrapper).Type(), // *T
 				Prop: new(Properties),
 			}
-			sft := oop.Type.Elem().Field(0)
-			oop.Prop.Name = sft.Name
-			oop.Prop.Parse(sft.Tag.Get("protobuf"))
-			// There will be exactly one interface field that
-			// this new value is assignable to.
-			for i := 0; i < t.NumField(); i++ {
-				f := t.Field(i)
-				if f.Type.Kind() != reflect.Interface {
-					continue
+			f := p.Type.Elem().Field(0)
+			p.Prop.Name = f.Name
+			p.Prop.Parse(f.Tag.Get("protobuf"))
+
+			// Determine the struct field that contains this oneof.
+			// Each wrapper is assignable to exactly one parent field.
+			var foundOneof bool
+			for i := 0; i < t.NumField() && !foundOneof; i++ {
+				if p.Type.AssignableTo(t.Field(i).Type) {
+					p.Field = i
+					foundOneof = true
 				}
-				if !oop.Type.AssignableTo(f.Type) {
-					continue
-				}
-				oop.Field = i
-				break
 			}
-			prop.OneofTypes[oop.Prop.OrigName] = oop
-		}
-	}
-
-	// build required counts
-	// build tags
-	reqCount := 0
-	prop.decoderOrigNames = make(map[string]int)
-	for i, p := range prop.Prop {
-		if strings.HasPrefix(p.Name, "XXX_") {
-			// Internal fields should not appear in tags/origNames maps.
-			// They are handled specially when encoding and decoding.
-			continue
-		}
-		if p.Required {
-			reqCount++
+			if !foundOneof {
+				panic(fmt.Sprintf("%v is not a generated message in the open-struct API", t))
+			}
+			prop.OneofTypes[p.Prop.OrigName] = p
 		}
-		prop.decoderTags.put(p.Tag, i)
-		prop.decoderOrigNames[p.OrigName] = i
 	}
-	prop.reqCount = reqCount
 
 	return prop
 }
 
-// A global registry of enum types.
-// The generated code will register the generated maps by calling RegisterEnum.
-
-var enumValueMaps = make(map[string]map[string]int32)
-
-// RegisterEnum is called from the generated code to install the enum descriptor
-// maps into the global table to aid parsing text format protocol buffers.
-func RegisterEnum(typeName string, unusedNameMap map[int32]string, valueMap map[string]int32) {
-	if _, ok := enumValueMaps[typeName]; ok {
-		panic("proto: duplicate enum registered: " + typeName)
-	}
-	enumValueMaps[typeName] = valueMap
-}
-
-// EnumValueMap returns the mapping from names to integers of the
-// enum type enumType, or a nil if not found.
-func EnumValueMap(enumType string) map[string]int32 {
-	return enumValueMaps[enumType]
-}
-
-// A registry of all linked message types.
-// The string is a fully-qualified proto name ("pkg.Message").
-var (
-	protoTypedNils = make(map[string]Message)      // a map from proto names to typed nil pointers
-	protoMapTypes  = make(map[string]reflect.Type) // a map from proto names to map types
-	revProtoTypes  = make(map[reflect.Type]string)
-)
-
-// RegisterType is called from generated code and maps from the fully qualified
-// proto name to the type (pointer to struct) of the protocol buffer.
-func RegisterType(x Message, name string) {
-	if _, ok := protoTypedNils[name]; ok {
-		// TODO: Some day, make this a panic.
-		log.Printf("proto: duplicate proto type registered: %s", name)
-		return
-	}
-	t := reflect.TypeOf(x)
-	if v := reflect.ValueOf(x); v.Kind() == reflect.Ptr && v.Pointer() == 0 {
-		// Generated code always calls RegisterType with nil x.
-		// This check is just for extra safety.
-		protoTypedNils[name] = x
-	} else {
-		protoTypedNils[name] = reflect.Zero(t).Interface().(Message)
-	}
-	revProtoTypes[t] = name
-}
-
-// RegisterMapType is called from generated code and maps from the fully qualified
-// proto name to the native map type of the proto map definition.
-func RegisterMapType(x interface{}, name string) {
-	if reflect.TypeOf(x).Kind() != reflect.Map {
-		panic(fmt.Sprintf("RegisterMapType(%T, %q); want map", x, name))
-	}
-	if _, ok := protoMapTypes[name]; ok {
-		log.Printf("proto: duplicate proto type registered: %s", name)
-		return
-	}
-	t := reflect.TypeOf(x)
-	protoMapTypes[name] = t
-	revProtoTypes[t] = name
-}
-
-// MessageName returns the fully-qualified proto name for the given message type.
-func MessageName(x Message) string {
-	type xname interface {
-		XXX_MessageName() string
-	}
-	if m, ok := x.(xname); ok {
-		return m.XXX_MessageName()
-	}
-	return revProtoTypes[reflect.TypeOf(x)]
-}
-
-// MessageType returns the message type (pointer to struct) for a named message.
-// The type is not guaranteed to implement proto.Message if the name refers to a
-// map entry.
-func MessageType(name string) reflect.Type {
-	if t, ok := protoTypedNils[name]; ok {
-		return reflect.TypeOf(t)
-	}
-	return protoMapTypes[name]
-}
-
-// A registry of all linked proto files.
-var (
-	protoFiles = make(map[string][]byte) // file name => fileDescriptor
-)
-
-// RegisterFile is called from generated code and maps from the
-// full file name of a .proto file to its compressed FileDescriptorProto.
-func RegisterFile(filename string, fileDescriptor []byte) {
-	protoFiles[filename] = fileDescriptor
-}
-
-// FileDescriptor returns the compressed FileDescriptorProto for a .proto file.
-func FileDescriptor(filename string) []byte { return protoFiles[filename] }
+func (sp *StructProperties) Len() int           { return len(sp.Prop) }
+func (sp *StructProperties) Less(i, j int) bool { return false }
+func (sp *StructProperties) Swap(i, j int)      { return }
diff --git a/vendor/github.com/golang/protobuf/proto/proto.go b/vendor/github.com/golang/protobuf/proto/proto.go
new file mode 100644
index 000000000..5aee89c32
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/proto.go
@@ -0,0 +1,167 @@
+// Copyright 2019 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 proto provides functionality for handling protocol buffer messages.
+// In particular, it provides marshaling and unmarshaling between a protobuf
+// message and the binary wire format.
+//
+// See https://developers.google.com/protocol-buffers/docs/gotutorial for
+// more information.
+//
+// Deprecated: Use the "google.golang.org/protobuf/proto" package instead.
+package proto
+
+import (
+	protoV2 "google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/runtime/protoiface"
+	"google.golang.org/protobuf/runtime/protoimpl"
+)
+
+const (
+	ProtoPackageIsVersion1 = true
+	ProtoPackageIsVersion2 = true
+	ProtoPackageIsVersion3 = true
+	ProtoPackageIsVersion4 = true
+)
+
+// GeneratedEnum is any enum type generated by protoc-gen-go
+// which is a named int32 kind.
+// This type exists for documentation purposes.
+type GeneratedEnum interface{}
+
+// GeneratedMessage is any message type generated by protoc-gen-go
+// which is a pointer to a named struct kind.
+// This type exists for documentation purposes.
+type GeneratedMessage interface{}
+
+// Message is a protocol buffer message.
+//
+// This is the v1 version of the message interface and is marginally better
+// than an empty interface as it lacks any method to programatically interact
+// with the contents of the message.
+//
+// A v2 message is declared in "google.golang.org/protobuf/proto".Message and
+// exposes protobuf reflection as a first-class feature of the interface.
+//
+// To convert a v1 message to a v2 message, use the MessageV2 function.
+// To convert a v2 message to a v1 message, use the MessageV1 function.
+type Message = protoiface.MessageV1
+
+// MessageV1 converts either a v1 or v2 message to a v1 message.
+// It returns nil if m is nil.
+func MessageV1(m GeneratedMessage) protoiface.MessageV1 {
+	return protoimpl.X.ProtoMessageV1Of(m)
+}
+
+// MessageV2 converts either a v1 or v2 message to a v2 message.
+// It returns nil if m is nil.
+func MessageV2(m GeneratedMessage) protoV2.Message {
+	return protoimpl.X.ProtoMessageV2Of(m)
+}
+
+// MessageReflect returns a reflective view for a message.
+// It returns nil if m is nil.
+func MessageReflect(m Message) protoreflect.Message {
+	return protoimpl.X.MessageOf(m)
+}
+
+// Marshaler is implemented by messages that can marshal themselves.
+// This interface is used by the following functions: Size, Marshal,
+// Buffer.Marshal, and Buffer.EncodeMessage.
+//
+// Deprecated: Do not implement.
+type Marshaler interface {
+	// Marshal formats the encoded bytes of the message.
+	// It should be deterministic and emit valid protobuf wire data.
+	// The caller takes ownership of the returned buffer.
+	Marshal() ([]byte, error)
+}
+
+// Unmarshaler is implemented by messages that can unmarshal themselves.
+// This interface is used by the following functions: Unmarshal, UnmarshalMerge,
+// Buffer.Unmarshal, Buffer.DecodeMessage, and Buffer.DecodeGroup.
+//
+// Deprecated: Do not implement.
+type Unmarshaler interface {
+	// Unmarshal parses the encoded bytes of the protobuf wire input.
+	// The provided buffer is only valid for during method call.
+	// It should not reset the receiver message.
+	Unmarshal([]byte) error
+}
+
+// Merger is implemented by messages that can merge themselves.
+// This interface is used by the following functions: Clone and Merge.
+//
+// Deprecated: Do not implement.
+type Merger interface {
+	// Merge merges the contents of src into the receiver message.
+	// It clones all data structures in src such that it aliases no mutable
+	// memory referenced by src.
+	Merge(src Message)
+}
+
+// RequiredNotSetError is an error type returned when
+// marshaling or unmarshaling a message with missing required fields.
+type RequiredNotSetError struct {
+	err error
+}
+
+func (e *RequiredNotSetError) Error() string {
+	if e.err != nil {
+		return e.err.Error()
+	}
+	return "proto: required field not set"
+}
+func (e *RequiredNotSetError) RequiredNotSet() bool {
+	return true
+}
+
+func checkRequiredNotSet(m protoV2.Message) error {
+	if err := protoV2.CheckInitialized(m); err != nil {
+		return &RequiredNotSetError{err: err}
+	}
+	return nil
+}
+
+// Clone returns a deep copy of src.
+func Clone(src Message) Message {
+	return MessageV1(protoV2.Clone(MessageV2(src)))
+}
+
+// Merge merges src into dst, which must be messages of the same type.
+//
+// Populated scalar fields in src are copied to dst, while populated
+// singular messages in src are merged into dst by recursively calling Merge.
+// The elements of every list field in src is appended to the corresponded
+// list fields in dst. The entries of every map field in src is copied into
+// the corresponding map field in dst, possibly replacing existing entries.
+// The unknown fields of src are appended to the unknown fields of dst.
+func Merge(dst, src Message) {
+	protoV2.Merge(MessageV2(dst), MessageV2(src))
+}
+
+// Equal reports whether two messages are equal.
+// If two messages marshal to the same bytes under deterministic serialization,
+// then Equal is guaranteed to report true.
+//
+// Two messages are equal if they are the same protobuf message type,
+// have the same set of populated known and extension field values,
+// and the same set of unknown fields values.
+//
+// Scalar values are compared with the equivalent of the == operator in Go,
+// except bytes values which are compared using bytes.Equal and
+// floating point values which specially treat NaNs as equal.
+// Message values are compared by recursively calling Equal.
+// Lists are equal if each element value is also equal.
+// Maps are equal if they have the same set of keys, where the pair of values
+// for each key is also equal.
+func Equal(x, y Message) bool {
+	return protoV2.Equal(MessageV2(x), MessageV2(y))
+}
+
+func isMessageSet(md protoreflect.MessageDescriptor) bool {
+	ms, ok := md.(interface{ IsMessageSet() bool })
+	return ok && ms.IsMessageSet()
+}
diff --git a/vendor/github.com/golang/protobuf/proto/proto3_proto/proto3.pb.go b/vendor/github.com/golang/protobuf/proto/proto3_proto/proto3.pb.go
deleted file mode 100644
index a80f08930..000000000
--- a/vendor/github.com/golang/protobuf/proto/proto3_proto/proto3.pb.go
+++ /dev/null
@@ -1,461 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: proto3_proto/proto3.proto
-
-package proto3_proto
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-import test_proto "github.com/golang/protobuf/proto/test_proto"
-import any "github.com/golang/protobuf/ptypes/any"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-type Message_Humour int32
-
-const (
-	Message_UNKNOWN     Message_Humour = 0
-	Message_PUNS        Message_Humour = 1
-	Message_SLAPSTICK   Message_Humour = 2
-	Message_BILL_BAILEY Message_Humour = 3
-)
-
-var Message_Humour_name = map[int32]string{
-	0: "UNKNOWN",
-	1: "PUNS",
-	2: "SLAPSTICK",
-	3: "BILL_BAILEY",
-}
-var Message_Humour_value = map[string]int32{
-	"UNKNOWN":     0,
-	"PUNS":        1,
-	"SLAPSTICK":   2,
-	"BILL_BAILEY": 3,
-}
-
-func (x Message_Humour) String() string {
-	return proto.EnumName(Message_Humour_name, int32(x))
-}
-func (Message_Humour) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_proto3_e706e4ff19a5dbea, []int{0, 0}
-}
-
-type Message struct {
-	Name                 string                             `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
-	Hilarity             Message_Humour                     `protobuf:"varint,2,opt,name=hilarity,enum=proto3_proto.Message_Humour" json:"hilarity,omitempty"`
-	HeightInCm           uint32                             `protobuf:"varint,3,opt,name=height_in_cm,json=heightInCm" json:"height_in_cm,omitempty"`
-	Data                 []byte                             `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"`
-	ResultCount          int64                              `protobuf:"varint,7,opt,name=result_count,json=resultCount" json:"result_count,omitempty"`
-	TrueScotsman         bool                               `protobuf:"varint,8,opt,name=true_scotsman,json=trueScotsman" json:"true_scotsman,omitempty"`
-	Score                float32                            `protobuf:"fixed32,9,opt,name=score" json:"score,omitempty"`
-	Key                  []uint64                           `protobuf:"varint,5,rep,packed,name=key" json:"key,omitempty"`
-	ShortKey             []int32                            `protobuf:"varint,19,rep,packed,name=short_key,json=shortKey" json:"short_key,omitempty"`
-	Nested               *Nested                            `protobuf:"bytes,6,opt,name=nested" json:"nested,omitempty"`
-	RFunny               []Message_Humour                   `protobuf:"varint,16,rep,packed,name=r_funny,json=rFunny,enum=proto3_proto.Message_Humour" json:"r_funny,omitempty"`
-	Terrain              map[string]*Nested                 `protobuf:"bytes,10,rep,name=terrain" json:"terrain,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
-	Proto2Field          *test_proto.SubDefaults            `protobuf:"bytes,11,opt,name=proto2_field,json=proto2Field" json:"proto2_field,omitempty"`
-	Proto2Value          map[string]*test_proto.SubDefaults `protobuf:"bytes,13,rep,name=proto2_value,json=proto2Value" json:"proto2_value,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
-	Anything             *any.Any                           `protobuf:"bytes,14,opt,name=anything" json:"anything,omitempty"`
-	ManyThings           []*any.Any                         `protobuf:"bytes,15,rep,name=many_things,json=manyThings" json:"many_things,omitempty"`
-	Submessage           *Message                           `protobuf:"bytes,17,opt,name=submessage" json:"submessage,omitempty"`
-	Children             []*Message                         `protobuf:"bytes,18,rep,name=children" json:"children,omitempty"`
-	StringMap            map[string]string                  `protobuf:"bytes,20,rep,name=string_map,json=stringMap" json:"string_map,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
-	XXX_NoUnkeyedLiteral struct{}                           `json:"-"`
-	XXX_unrecognized     []byte                             `json:"-"`
-	XXX_sizecache        int32                              `json:"-"`
-}
-
-func (m *Message) Reset()         { *m = Message{} }
-func (m *Message) String() string { return proto.CompactTextString(m) }
-func (*Message) ProtoMessage()    {}
-func (*Message) Descriptor() ([]byte, []int) {
-	return fileDescriptor_proto3_e706e4ff19a5dbea, []int{0}
-}
-func (m *Message) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Message.Unmarshal(m, b)
-}
-func (m *Message) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Message.Marshal(b, m, deterministic)
-}
-func (dst *Message) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Message.Merge(dst, src)
-}
-func (m *Message) XXX_Size() int {
-	return xxx_messageInfo_Message.Size(m)
-}
-func (m *Message) XXX_DiscardUnknown() {
-	xxx_messageInfo_Message.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Message proto.InternalMessageInfo
-
-func (m *Message) GetName() string {
-	if m != nil {
-		return m.Name
-	}
-	return ""
-}
-
-func (m *Message) GetHilarity() Message_Humour {
-	if m != nil {
-		return m.Hilarity
-	}
-	return Message_UNKNOWN
-}
-
-func (m *Message) GetHeightInCm() uint32 {
-	if m != nil {
-		return m.HeightInCm
-	}
-	return 0
-}
-
-func (m *Message) GetData() []byte {
-	if m != nil {
-		return m.Data
-	}
-	return nil
-}
-
-func (m *Message) GetResultCount() int64 {
-	if m != nil {
-		return m.ResultCount
-	}
-	return 0
-}
-
-func (m *Message) GetTrueScotsman() bool {
-	if m != nil {
-		return m.TrueScotsman
-	}
-	return false
-}
-
-func (m *Message) GetScore() float32 {
-	if m != nil {
-		return m.Score
-	}
-	return 0
-}
-
-func (m *Message) GetKey() []uint64 {
-	if m != nil {
-		return m.Key
-	}
-	return nil
-}
-
-func (m *Message) GetShortKey() []int32 {
-	if m != nil {
-		return m.ShortKey
-	}
-	return nil
-}
-
-func (m *Message) GetNested() *Nested {
-	if m != nil {
-		return m.Nested
-	}
-	return nil
-}
-
-func (m *Message) GetRFunny() []Message_Humour {
-	if m != nil {
-		return m.RFunny
-	}
-	return nil
-}
-
-func (m *Message) GetTerrain() map[string]*Nested {
-	if m != nil {
-		return m.Terrain
-	}
-	return nil
-}
-
-func (m *Message) GetProto2Field() *test_proto.SubDefaults {
-	if m != nil {
-		return m.Proto2Field
-	}
-	return nil
-}
-
-func (m *Message) GetProto2Value() map[string]*test_proto.SubDefaults {
-	if m != nil {
-		return m.Proto2Value
-	}
-	return nil
-}
-
-func (m *Message) GetAnything() *any.Any {
-	if m != nil {
-		return m.Anything
-	}
-	return nil
-}
-
-func (m *Message) GetManyThings() []*any.Any {
-	if m != nil {
-		return m.ManyThings
-	}
-	return nil
-}
-
-func (m *Message) GetSubmessage() *Message {
-	if m != nil {
-		return m.Submessage
-	}
-	return nil
-}
-
-func (m *Message) GetChildren() []*Message {
-	if m != nil {
-		return m.Children
-	}
-	return nil
-}
-
-func (m *Message) GetStringMap() map[string]string {
-	if m != nil {
-		return m.StringMap
-	}
-	return nil
-}
-
-type Nested struct {
-	Bunny                string   `protobuf:"bytes,1,opt,name=bunny" json:"bunny,omitempty"`
-	Cute                 bool     `protobuf:"varint,2,opt,name=cute" json:"cute,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *Nested) Reset()         { *m = Nested{} }
-func (m *Nested) String() string { return proto.CompactTextString(m) }
-func (*Nested) ProtoMessage()    {}
-func (*Nested) Descriptor() ([]byte, []int) {
-	return fileDescriptor_proto3_e706e4ff19a5dbea, []int{1}
-}
-func (m *Nested) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Nested.Unmarshal(m, b)
-}
-func (m *Nested) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Nested.Marshal(b, m, deterministic)
-}
-func (dst *Nested) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Nested.Merge(dst, src)
-}
-func (m *Nested) XXX_Size() int {
-	return xxx_messageInfo_Nested.Size(m)
-}
-func (m *Nested) XXX_DiscardUnknown() {
-	xxx_messageInfo_Nested.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Nested proto.InternalMessageInfo
-
-func (m *Nested) GetBunny() string {
-	if m != nil {
-		return m.Bunny
-	}
-	return ""
-}
-
-func (m *Nested) GetCute() bool {
-	if m != nil {
-		return m.Cute
-	}
-	return false
-}
-
-type MessageWithMap struct {
-	ByteMapping          map[bool][]byte `protobuf:"bytes,1,rep,name=byte_mapping,json=byteMapping" json:"byte_mapping,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value,proto3"`
-	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
-	XXX_unrecognized     []byte          `json:"-"`
-	XXX_sizecache        int32           `json:"-"`
-}
-
-func (m *MessageWithMap) Reset()         { *m = MessageWithMap{} }
-func (m *MessageWithMap) String() string { return proto.CompactTextString(m) }
-func (*MessageWithMap) ProtoMessage()    {}
-func (*MessageWithMap) Descriptor() ([]byte, []int) {
-	return fileDescriptor_proto3_e706e4ff19a5dbea, []int{2}
-}
-func (m *MessageWithMap) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_MessageWithMap.Unmarshal(m, b)
-}
-func (m *MessageWithMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_MessageWithMap.Marshal(b, m, deterministic)
-}
-func (dst *MessageWithMap) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MessageWithMap.Merge(dst, src)
-}
-func (m *MessageWithMap) XXX_Size() int {
-	return xxx_messageInfo_MessageWithMap.Size(m)
-}
-func (m *MessageWithMap) XXX_DiscardUnknown() {
-	xxx_messageInfo_MessageWithMap.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_MessageWithMap proto.InternalMessageInfo
-
-func (m *MessageWithMap) GetByteMapping() map[bool][]byte {
-	if m != nil {
-		return m.ByteMapping
-	}
-	return nil
-}
-
-type IntMap struct {
-	Rtt                  map[int32]int32 `protobuf:"bytes,1,rep,name=rtt" json:"rtt,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
-	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
-	XXX_unrecognized     []byte          `json:"-"`
-	XXX_sizecache        int32           `json:"-"`
-}
-
-func (m *IntMap) Reset()         { *m = IntMap{} }
-func (m *IntMap) String() string { return proto.CompactTextString(m) }
-func (*IntMap) ProtoMessage()    {}
-func (*IntMap) Descriptor() ([]byte, []int) {
-	return fileDescriptor_proto3_e706e4ff19a5dbea, []int{3}
-}
-func (m *IntMap) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_IntMap.Unmarshal(m, b)
-}
-func (m *IntMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_IntMap.Marshal(b, m, deterministic)
-}
-func (dst *IntMap) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_IntMap.Merge(dst, src)
-}
-func (m *IntMap) XXX_Size() int {
-	return xxx_messageInfo_IntMap.Size(m)
-}
-func (m *IntMap) XXX_DiscardUnknown() {
-	xxx_messageInfo_IntMap.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_IntMap proto.InternalMessageInfo
-
-func (m *IntMap) GetRtt() map[int32]int32 {
-	if m != nil {
-		return m.Rtt
-	}
-	return nil
-}
-
-type IntMaps struct {
-	Maps                 []*IntMap `protobuf:"bytes,1,rep,name=maps" json:"maps,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
-	XXX_unrecognized     []byte    `json:"-"`
-	XXX_sizecache        int32     `json:"-"`
-}
-
-func (m *IntMaps) Reset()         { *m = IntMaps{} }
-func (m *IntMaps) String() string { return proto.CompactTextString(m) }
-func (*IntMaps) ProtoMessage()    {}
-func (*IntMaps) Descriptor() ([]byte, []int) {
-	return fileDescriptor_proto3_e706e4ff19a5dbea, []int{4}
-}
-func (m *IntMaps) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_IntMaps.Unmarshal(m, b)
-}
-func (m *IntMaps) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_IntMaps.Marshal(b, m, deterministic)
-}
-func (dst *IntMaps) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_IntMaps.Merge(dst, src)
-}
-func (m *IntMaps) XXX_Size() int {
-	return xxx_messageInfo_IntMaps.Size(m)
-}
-func (m *IntMaps) XXX_DiscardUnknown() {
-	xxx_messageInfo_IntMaps.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_IntMaps proto.InternalMessageInfo
-
-func (m *IntMaps) GetMaps() []*IntMap {
-	if m != nil {
-		return m.Maps
-	}
-	return nil
-}
-
-func init() {
-	proto.RegisterType((*Message)(nil), "proto3_proto.Message")
-	proto.RegisterMapType((map[string]*test_proto.SubDefaults)(nil), "proto3_proto.Message.Proto2ValueEntry")
-	proto.RegisterMapType((map[string]string)(nil), "proto3_proto.Message.StringMapEntry")
-	proto.RegisterMapType((map[string]*Nested)(nil), "proto3_proto.Message.TerrainEntry")
-	proto.RegisterType((*Nested)(nil), "proto3_proto.Nested")
-	proto.RegisterType((*MessageWithMap)(nil), "proto3_proto.MessageWithMap")
-	proto.RegisterMapType((map[bool][]byte)(nil), "proto3_proto.MessageWithMap.ByteMappingEntry")
-	proto.RegisterType((*IntMap)(nil), "proto3_proto.IntMap")
-	proto.RegisterMapType((map[int32]int32)(nil), "proto3_proto.IntMap.RttEntry")
-	proto.RegisterType((*IntMaps)(nil), "proto3_proto.IntMaps")
-	proto.RegisterEnum("proto3_proto.Message_Humour", Message_Humour_name, Message_Humour_value)
-}
-
-func init() { proto.RegisterFile("proto3_proto/proto3.proto", fileDescriptor_proto3_e706e4ff19a5dbea) }
-
-var fileDescriptor_proto3_e706e4ff19a5dbea = []byte{
-	// 774 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x94, 0x6f, 0x8f, 0xdb, 0x44,
-	0x10, 0xc6, 0x71, 0x9c, 0x3f, 0xce, 0xd8, 0x77, 0x35, 0x4b, 0x2a, 0xb6, 0x01, 0x24, 0x13, 0x10,
-	0xb2, 0x10, 0xf5, 0x41, 0xaa, 0x43, 0x55, 0x55, 0x81, 0xee, 0x8e, 0x56, 0x44, 0x77, 0x17, 0xa2,
-	0xcd, 0x95, 0x13, 0xaf, 0xac, 0x4d, 0x6e, 0x93, 0x58, 0xc4, 0xeb, 0xe0, 0x5d, 0x23, 0xf9, 0x0b,
-	0xf0, 0x41, 0xf8, 0xa4, 0x68, 0x77, 0x9d, 0xd4, 0xa9, 0x5c, 0xfa, 0x2a, 0xbb, 0x8f, 0x7f, 0x33,
-	0xcf, 0x78, 0x66, 0x1c, 0x78, 0xb2, 0xcb, 0x33, 0x99, 0x3d, 0x8b, 0xf5, 0xcf, 0x99, 0xb9, 0x44,
-	0xfa, 0x07, 0x79, 0xf5, 0x47, 0xc3, 0x27, 0xeb, 0x2c, 0x5b, 0x6f, 0x99, 0x41, 0x16, 0xc5, 0xea,
-	0x8c, 0xf2, 0xd2, 0x80, 0xc3, 0xc7, 0x92, 0x09, 0x59, 0x65, 0x50, 0x47, 0x23, 0x8f, 0xfe, 0xe9,
-	0x43, 0xef, 0x96, 0x09, 0x41, 0xd7, 0x0c, 0x21, 0x68, 0x73, 0x9a, 0x32, 0x6c, 0x05, 0x56, 0xd8,
-	0x27, 0xfa, 0x8c, 0x9e, 0x83, 0xb3, 0x49, 0xb6, 0x34, 0x4f, 0x64, 0x89, 0x5b, 0x81, 0x15, 0x9e,
-	0x8e, 0x3f, 0x8f, 0xea, 0x96, 0x51, 0x15, 0x1c, 0xfd, 0x5a, 0xa4, 0x59, 0x91, 0x93, 0x03, 0x8d,
-	0x02, 0xf0, 0x36, 0x2c, 0x59, 0x6f, 0x64, 0x9c, 0xf0, 0x78, 0x99, 0x62, 0x3b, 0xb0, 0xc2, 0x13,
-	0x02, 0x46, 0x9b, 0xf0, 0xab, 0x54, 0xf9, 0x3d, 0x50, 0x49, 0x71, 0x3b, 0xb0, 0x42, 0x8f, 0xe8,
-	0x33, 0xfa, 0x12, 0xbc, 0x9c, 0x89, 0x62, 0x2b, 0xe3, 0x65, 0x56, 0x70, 0x89, 0x7b, 0x81, 0x15,
-	0xda, 0xc4, 0x35, 0xda, 0x95, 0x92, 0xd0, 0x57, 0x70, 0x22, 0xf3, 0x82, 0xc5, 0x62, 0x99, 0x49,
-	0x91, 0x52, 0x8e, 0x9d, 0xc0, 0x0a, 0x1d, 0xe2, 0x29, 0x71, 0x5e, 0x69, 0x68, 0x00, 0x1d, 0xb1,
-	0xcc, 0x72, 0x86, 0xfb, 0x81, 0x15, 0xb6, 0x88, 0xb9, 0x20, 0x1f, 0xec, 0x3f, 0x59, 0x89, 0x3b,
-	0x81, 0x1d, 0xb6, 0x89, 0x3a, 0xa2, 0xcf, 0xa0, 0x2f, 0x36, 0x59, 0x2e, 0x63, 0xa5, 0x7f, 0x12,
-	0xd8, 0x61, 0x87, 0x38, 0x5a, 0xb8, 0x66, 0x25, 0xfa, 0x0e, 0xba, 0x9c, 0x09, 0xc9, 0x1e, 0x70,
-	0x37, 0xb0, 0x42, 0x77, 0x3c, 0x38, 0x7e, 0xf5, 0xa9, 0x7e, 0x46, 0x2a, 0x06, 0x9d, 0x43, 0x2f,
-	0x8f, 0x57, 0x05, 0xe7, 0x25, 0xf6, 0x03, 0xfb, 0x83, 0x9d, 0xea, 0xe6, 0xaf, 0x15, 0x8b, 0x5e,
-	0x42, 0x4f, 0xb2, 0x3c, 0xa7, 0x09, 0xc7, 0x10, 0xd8, 0xa1, 0x3b, 0x1e, 0x35, 0x87, 0xdd, 0x19,
-	0xe8, 0x15, 0x97, 0x79, 0x49, 0xf6, 0x21, 0xe8, 0x05, 0x98, 0x0d, 0x18, 0xc7, 0xab, 0x84, 0x6d,
-	0x1f, 0xb0, 0xab, 0x0b, 0xfd, 0x34, 0x7a, 0x3b, 0xed, 0x68, 0x5e, 0x2c, 0x7e, 0x61, 0x2b, 0x5a,
-	0x6c, 0xa5, 0x20, 0xae, 0x81, 0x5f, 0x2b, 0x16, 0x4d, 0x0e, 0xb1, 0x7f, 0xd3, 0x6d, 0xc1, 0xf0,
-	0x89, 0xb6, 0xff, 0xa6, 0xd9, 0x7e, 0xa6, 0xc9, 0xdf, 0x15, 0x68, 0x4a, 0xa8, 0x52, 0x69, 0x05,
-	0x7d, 0x0f, 0x0e, 0xe5, 0xa5, 0xdc, 0x24, 0x7c, 0x8d, 0x4f, 0xab, 0x5e, 0x99, 0x5d, 0x8c, 0xf6,
-	0xbb, 0x18, 0x5d, 0xf0, 0x92, 0x1c, 0x28, 0x74, 0x0e, 0x6e, 0x4a, 0x79, 0x19, 0xeb, 0x9b, 0xc0,
-	0x8f, 0xb4, 0x77, 0x73, 0x10, 0x28, 0xf0, 0x4e, 0x73, 0xe8, 0x1c, 0x40, 0x14, 0x8b, 0xd4, 0x14,
-	0x85, 0x3f, 0xd6, 0x56, 0x8f, 0x1b, 0x2b, 0x26, 0x35, 0x10, 0xfd, 0x00, 0xce, 0x72, 0x93, 0x6c,
-	0x1f, 0x72, 0xc6, 0x31, 0xd2, 0x56, 0xef, 0x09, 0x3a, 0x60, 0xe8, 0x0a, 0x40, 0xc8, 0x3c, 0xe1,
-	0xeb, 0x38, 0xa5, 0x3b, 0x3c, 0xd0, 0x41, 0x5f, 0x37, 0xf7, 0x66, 0xae, 0xb9, 0x5b, 0xba, 0x33,
-	0x9d, 0xe9, 0x8b, 0xfd, 0x7d, 0x38, 0x03, 0xaf, 0x3e, 0xb7, 0xfd, 0x02, 0x9a, 0x2f, 0x4c, 0x2f,
-	0xe0, 0xb7, 0xd0, 0x31, 0xdd, 0x6f, 0xfd, 0xcf, 0x8a, 0x19, 0xe4, 0x45, 0xeb, 0xb9, 0x35, 0xbc,
-	0x07, 0xff, 0xdd, 0x51, 0x34, 0x64, 0x7d, 0x7a, 0x9c, 0xf5, 0xbd, 0xfb, 0x50, 0x4b, 0xfc, 0x12,
-	0x4e, 0x8f, 0xdf, 0xa3, 0x21, 0xed, 0xa0, 0x9e, 0xb6, 0x5f, 0x8b, 0x1e, 0xfd, 0x0c, 0x5d, 0xb3,
-	0xd7, 0xc8, 0x85, 0xde, 0x9b, 0xe9, 0xf5, 0xf4, 0xb7, 0xfb, 0xa9, 0xff, 0x11, 0x72, 0xa0, 0x3d,
-	0x7b, 0x33, 0x9d, 0xfb, 0x16, 0x3a, 0x81, 0xfe, 0xfc, 0xe6, 0x62, 0x36, 0xbf, 0x9b, 0x5c, 0x5d,
-	0xfb, 0x2d, 0xf4, 0x08, 0xdc, 0xcb, 0xc9, 0xcd, 0x4d, 0x7c, 0x79, 0x31, 0xb9, 0x79, 0xf5, 0x87,
-	0x6f, 0x8f, 0xc6, 0xd0, 0x35, 0x2f, 0xab, 0x4c, 0x16, 0xfa, 0x2b, 0x32, 0xc6, 0xe6, 0xa2, 0xfe,
-	0x2c, 0x96, 0x85, 0x34, 0xce, 0x0e, 0xd1, 0xe7, 0xd1, 0xbf, 0x16, 0x9c, 0x56, 0x33, 0xb8, 0x4f,
-	0xe4, 0xe6, 0x96, 0xee, 0xd0, 0x0c, 0xbc, 0x45, 0x29, 0x99, 0x9a, 0xd9, 0x4e, 0x2d, 0xa3, 0xa5,
-	0xe7, 0xf6, 0xb4, 0x71, 0x6e, 0x55, 0x4c, 0x74, 0x59, 0x4a, 0x76, 0x6b, 0xf8, 0x6a, 0xb5, 0x17,
-	0x6f, 0x95, 0xe1, 0x4f, 0xe0, 0xbf, 0x0b, 0xd4, 0x3b, 0xe3, 0x34, 0x74, 0xc6, 0xab, 0x77, 0xe6,
-	0x2f, 0xe8, 0x4e, 0xb8, 0x54, 0xb5, 0x9d, 0x81, 0x9d, 0x4b, 0x59, 0x95, 0xf4, 0xc5, 0x71, 0x49,
-	0x06, 0x89, 0x88, 0x94, 0xa6, 0x04, 0x45, 0x0e, 0x7f, 0x04, 0x67, 0x2f, 0xd4, 0x2d, 0x3b, 0x0d,
-	0x96, 0x9d, 0xba, 0xe5, 0x33, 0xe8, 0x99, 0x7c, 0x02, 0x85, 0xd0, 0x4e, 0xe9, 0x4e, 0x54, 0xa6,
-	0x83, 0x26, 0x53, 0xa2, 0x89, 0x45, 0xd7, 0x3c, 0xfa, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x99, 0x24,
-	0x6b, 0x12, 0x6d, 0x06, 0x00, 0x00,
-}
diff --git a/vendor/github.com/golang/protobuf/proto/proto3_proto/proto3.proto b/vendor/github.com/golang/protobuf/proto/proto3_proto/proto3.proto
deleted file mode 100644
index c81fe1e5e..000000000
--- a/vendor/github.com/golang/protobuf/proto/proto3_proto/proto3.proto
+++ /dev/null
@@ -1,89 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2014 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto3";
-
-import "google/protobuf/any.proto";
-import "test_proto/test.proto";
-
-package proto3_proto;
-
-message Message {
-  enum Humour {
-    UNKNOWN = 0;
-    PUNS = 1;
-    SLAPSTICK = 2;
-    BILL_BAILEY = 3;
-  }
-
-  string name = 1;
-  Humour hilarity = 2;
-  uint32 height_in_cm = 3;
-  bytes data = 4;
-  int64 result_count = 7;
-  bool true_scotsman = 8;
-  float score = 9;
-
-  repeated uint64 key = 5;
-  repeated int32 short_key = 19;
-  Nested nested = 6;
-  repeated Humour r_funny = 16;
-
-  map<string, Nested> terrain = 10;
-  test_proto.SubDefaults proto2_field = 11;
-  map<string, test_proto.SubDefaults> proto2_value = 13;
-
-  google.protobuf.Any anything = 14;
-  repeated google.protobuf.Any many_things = 15;
-
-  Message submessage = 17;
-  repeated Message children = 18;
-
-  map<string, string> string_map = 20;
-}
-
-message Nested {
-  string bunny = 1;
-  bool cute = 2;
-}
-
-message MessageWithMap {
-  map<bool, bytes> byte_mapping = 1;
-}
-
-
-message IntMap {
-  map<int32, int32> rtt = 1;
-}
-
-message IntMaps {
-  repeated IntMap maps = 1;
-}
diff --git a/vendor/github.com/golang/protobuf/proto/proto3_test.go b/vendor/github.com/golang/protobuf/proto/proto3_test.go
deleted file mode 100644
index 73eed6c0b..000000000
--- a/vendor/github.com/golang/protobuf/proto/proto3_test.go
+++ /dev/null
@@ -1,151 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2014 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package proto_test
-
-import (
-	"bytes"
-	"testing"
-
-	"github.com/golang/protobuf/proto"
-	pb "github.com/golang/protobuf/proto/proto3_proto"
-	tpb "github.com/golang/protobuf/proto/test_proto"
-)
-
-func TestProto3ZeroValues(t *testing.T) {
-	tests := []struct {
-		desc string
-		m    proto.Message
-	}{
-		{"zero message", &pb.Message{}},
-		{"empty bytes field", &pb.Message{Data: []byte{}}},
-	}
-	for _, test := range tests {
-		b, err := proto.Marshal(test.m)
-		if err != nil {
-			t.Errorf("%s: proto.Marshal: %v", test.desc, err)
-			continue
-		}
-		if len(b) > 0 {
-			t.Errorf("%s: Encoding is non-empty: %q", test.desc, b)
-		}
-	}
-}
-
-func TestRoundTripProto3(t *testing.T) {
-	m := &pb.Message{
-		Name:         "David",          // (2 | 1<<3): 0x0a 0x05 "David"
-		Hilarity:     pb.Message_PUNS,  // (0 | 2<<3): 0x10 0x01
-		HeightInCm:   178,              // (0 | 3<<3): 0x18 0xb2 0x01
-		Data:         []byte("roboto"), // (2 | 4<<3): 0x20 0x06 "roboto"
-		ResultCount:  47,               // (0 | 7<<3): 0x38 0x2f
-		TrueScotsman: true,             // (0 | 8<<3): 0x40 0x01
-		Score:        8.1,              // (5 | 9<<3): 0x4d <8.1>
-
-		Key: []uint64{1, 0xdeadbeef},
-		Nested: &pb.Nested{
-			Bunny: "Monty",
-		},
-	}
-	t.Logf(" m: %v", m)
-
-	b, err := proto.Marshal(m)
-	if err != nil {
-		t.Fatalf("proto.Marshal: %v", err)
-	}
-	t.Logf(" b: %q", b)
-
-	m2 := new(pb.Message)
-	if err := proto.Unmarshal(b, m2); err != nil {
-		t.Fatalf("proto.Unmarshal: %v", err)
-	}
-	t.Logf("m2: %v", m2)
-
-	if !proto.Equal(m, m2) {
-		t.Errorf("proto.Equal returned false:\n m: %v\nm2: %v", m, m2)
-	}
-}
-
-func TestGettersForBasicTypesExist(t *testing.T) {
-	var m pb.Message
-	if got := m.GetNested().GetBunny(); got != "" {
-		t.Errorf("m.GetNested().GetBunny() = %q, want empty string", got)
-	}
-	if got := m.GetNested().GetCute(); got {
-		t.Errorf("m.GetNested().GetCute() = %t, want false", got)
-	}
-}
-
-func TestProto3SetDefaults(t *testing.T) {
-	in := &pb.Message{
-		Terrain: map[string]*pb.Nested{
-			"meadow": new(pb.Nested),
-		},
-		Proto2Field: new(tpb.SubDefaults),
-		Proto2Value: map[string]*tpb.SubDefaults{
-			"badlands": new(tpb.SubDefaults),
-		},
-	}
-
-	got := proto.Clone(in).(*pb.Message)
-	proto.SetDefaults(got)
-
-	// There are no defaults in proto3.  Everything should be the zero value, but
-	// we need to remember to set defaults for nested proto2 messages.
-	want := &pb.Message{
-		Terrain: map[string]*pb.Nested{
-			"meadow": new(pb.Nested),
-		},
-		Proto2Field: &tpb.SubDefaults{N: proto.Int64(7)},
-		Proto2Value: map[string]*tpb.SubDefaults{
-			"badlands": &tpb.SubDefaults{N: proto.Int64(7)},
-		},
-	}
-
-	if !proto.Equal(got, want) {
-		t.Errorf("with in = %v\nproto.SetDefaults(in) =>\ngot %v\nwant %v", in, got, want)
-	}
-}
-
-func TestUnknownFieldPreservation(t *testing.T) {
-	b1 := "\x0a\x05David"      // Known tag 1
-	b2 := "\xc2\x0c\x06Google" // Unknown tag 200
-	b := []byte(b1 + b2)
-
-	m := new(pb.Message)
-	if err := proto.Unmarshal(b, m); err != nil {
-		t.Fatalf("proto.Unmarshal: %v", err)
-	}
-
-	if !bytes.Equal(m.XXX_unrecognized, []byte(b2)) {
-		t.Fatalf("mismatching unknown fields:\ngot  %q\nwant %q", m.XXX_unrecognized, b2)
-	}
-}
diff --git a/vendor/github.com/golang/protobuf/proto/proto_clone_test.go b/vendor/github.com/golang/protobuf/proto/proto_clone_test.go
new file mode 100644
index 000000000..d9ae24f1b
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/proto_clone_test.go
@@ -0,0 +1,379 @@
+// Copyright 2011 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 proto_test
+
+import (
+	"testing"
+
+	"github.com/golang/protobuf/proto"
+
+	pb2 "github.com/golang/protobuf/internal/testprotos/proto2_proto"
+	pb3 "github.com/golang/protobuf/internal/testprotos/proto3_proto"
+)
+
+var cloneTestMessage = &pb2.MyMessage{
+	Count: proto.Int32(42),
+	Name:  proto.String("Dave"),
+	Pet:   []string{"bunny", "kitty", "horsey"},
+	Inner: &pb2.InnerMessage{
+		Host:      proto.String("niles"),
+		Port:      proto.Int32(9099),
+		Connected: proto.Bool(true),
+	},
+	Others: []*pb2.OtherMessage{
+		{
+			Value: []byte("some bytes"),
+		},
+	},
+	Somegroup: &pb2.MyMessage_SomeGroup{
+		GroupField: proto.Int32(6),
+	},
+	RepBytes: [][]byte{[]byte("sham"), []byte("wow")},
+}
+
+func init() {
+	ext := &pb2.Ext{
+		Data: proto.String("extension"),
+	}
+	if err := proto.SetExtension(cloneTestMessage, pb2.E_Ext_More, ext); err != nil {
+		panic("SetExtension: " + err.Error())
+	}
+	if err := proto.SetExtension(cloneTestMessage, pb2.E_Ext_Text, proto.String("hello")); err != nil {
+		panic("SetExtension: " + err.Error())
+	}
+	if err := proto.SetExtension(cloneTestMessage, pb2.E_Greeting, []string{"one", "two"}); err != nil {
+		panic("SetExtension: " + err.Error())
+	}
+}
+
+func TestClone(t *testing.T) {
+	// Create a clone using a marshal/unmarshal roundtrip.
+	vanilla := new(pb2.MyMessage)
+	b, err := proto.Marshal(cloneTestMessage)
+	if err != nil {
+		t.Errorf("unexpected Marshal error: %v", err)
+	}
+	if err := proto.Unmarshal(b, vanilla); err != nil {
+		t.Errorf("unexpected Unarshal error: %v", err)
+	}
+
+	// Create a clone using Clone and verify that it is equal to the original.
+	m := proto.Clone(cloneTestMessage).(*pb2.MyMessage)
+	if !proto.Equal(m, cloneTestMessage) {
+		t.Fatalf("Clone(%v) = %v", cloneTestMessage, m)
+	}
+
+	// Mutate the clone, which should not affect the original.
+	x1, err := proto.GetExtension(m, pb2.E_Ext_More)
+	if err != nil {
+		t.Errorf("unexpected GetExtension(%v) error: %v", pb2.E_Ext_More.Name, err)
+	}
+	x2, err := proto.GetExtension(m, pb2.E_Ext_Text)
+	if err != nil {
+		t.Errorf("unexpected GetExtension(%v) error: %v", pb2.E_Ext_Text.Name, err)
+	}
+	x3, err := proto.GetExtension(m, pb2.E_Greeting)
+	if err != nil {
+		t.Errorf("unexpected GetExtension(%v) error: %v", pb2.E_Greeting.Name, err)
+	}
+	*m.Inner.Port++
+	*(x1.(*pb2.Ext)).Data = "blah blah"
+	*(x2.(*string)) = "goodbye"
+	x3.([]string)[0] = "zero"
+	if !proto.Equal(cloneTestMessage, vanilla) {
+		t.Fatalf("mutation on original detected:\ngot  %v\nwant %v", cloneTestMessage, vanilla)
+	}
+}
+
+func TestCloneNil(t *testing.T) {
+	var m *pb2.MyMessage
+	if c := proto.Clone(m); !proto.Equal(m, c) {
+		t.Errorf("Clone(%v) = %v", m, c)
+	}
+}
+
+var mergeTests = []struct {
+	src, dst, want proto.Message
+}{
+	{
+		src: &pb2.MyMessage{
+			Count: proto.Int32(42),
+		},
+		dst: &pb2.MyMessage{
+			Name: proto.String("Dave"),
+		},
+		want: &pb2.MyMessage{
+			Count: proto.Int32(42),
+			Name:  proto.String("Dave"),
+		},
+	},
+	{
+		src: &pb2.MyMessage{
+			Inner: &pb2.InnerMessage{
+				Host:      proto.String("hey"),
+				Connected: proto.Bool(true),
+			},
+			Pet: []string{"horsey"},
+			Others: []*pb2.OtherMessage{
+				{
+					Value: []byte("some bytes"),
+				},
+			},
+		},
+		dst: &pb2.MyMessage{
+			Inner: &pb2.InnerMessage{
+				Host: proto.String("niles"),
+				Port: proto.Int32(9099),
+			},
+			Pet: []string{"bunny", "kitty"},
+			Others: []*pb2.OtherMessage{
+				{
+					Key: proto.Int64(31415926535),
+				},
+				{
+					// Explicitly test a src=nil field
+					Inner: nil,
+				},
+			},
+		},
+		want: &pb2.MyMessage{
+			Inner: &pb2.InnerMessage{
+				Host:      proto.String("hey"),
+				Connected: proto.Bool(true),
+				Port:      proto.Int32(9099),
+			},
+			Pet: []string{"bunny", "kitty", "horsey"},
+			Others: []*pb2.OtherMessage{
+				{
+					Key: proto.Int64(31415926535),
+				},
+				{},
+				{
+					Value: []byte("some bytes"),
+				},
+			},
+		},
+	},
+	{
+		src: &pb2.MyMessage{
+			RepBytes: [][]byte{[]byte("wow")},
+		},
+		dst: &pb2.MyMessage{
+			Somegroup: &pb2.MyMessage_SomeGroup{
+				GroupField: proto.Int32(6),
+			},
+			RepBytes: [][]byte{[]byte("sham")},
+		},
+		want: &pb2.MyMessage{
+			Somegroup: &pb2.MyMessage_SomeGroup{
+				GroupField: proto.Int32(6),
+			},
+			RepBytes: [][]byte{[]byte("sham"), []byte("wow")},
+		},
+	},
+	// Check that a scalar bytes field replaces rather than appends.
+	{
+		src:  &pb2.OtherMessage{Value: []byte("foo")},
+		dst:  &pb2.OtherMessage{Value: []byte("bar")},
+		want: &pb2.OtherMessage{Value: []byte("foo")},
+	},
+	{
+		src: &pb2.MessageWithMap{
+			NameMapping: map[int32]string{6: "Nigel"},
+			MsgMapping: map[int64]*pb2.FloatingPoint{
+				0x4001: &pb2.FloatingPoint{F: proto.Float64(2.0)},
+				0x4002: &pb2.FloatingPoint{
+					F: proto.Float64(2.0),
+				},
+			},
+			ByteMapping: map[bool][]byte{true: []byte("wowsa")},
+		},
+		dst: &pb2.MessageWithMap{
+			NameMapping: map[int32]string{
+				6: "Bruce", // should be overwritten
+				7: "Andrew",
+			},
+			MsgMapping: map[int64]*pb2.FloatingPoint{
+				0x4002: &pb2.FloatingPoint{
+					F:     proto.Float64(3.0),
+					Exact: proto.Bool(true),
+				}, // the entire message should be overwritten
+			},
+		},
+		want: &pb2.MessageWithMap{
+			NameMapping: map[int32]string{
+				6: "Nigel",
+				7: "Andrew",
+			},
+			MsgMapping: map[int64]*pb2.FloatingPoint{
+				0x4001: &pb2.FloatingPoint{F: proto.Float64(2.0)},
+				0x4002: &pb2.FloatingPoint{
+					F: proto.Float64(2.0),
+				},
+			},
+			ByteMapping: map[bool][]byte{true: []byte("wowsa")},
+		},
+	},
+	// proto3 shouldn't merge zero values,
+	// in the same way that proto2 shouldn't merge nils.
+	{
+		src: &pb3.Message{
+			Name: "Aaron",
+			Data: []byte(""), // zero value, but not nil
+		},
+		dst: &pb3.Message{
+			HeightInCm: 176,
+			Data:       []byte("texas!"),
+		},
+		want: &pb3.Message{
+			Name:       "Aaron",
+			HeightInCm: 176,
+			Data:       []byte("texas!"),
+		},
+	},
+	{ // Oneof fields should merge by assignment.
+		src:  &pb2.Communique{Union: &pb2.Communique_Number{41}},
+		dst:  &pb2.Communique{Union: &pb2.Communique_Name{"Bobby Tables"}},
+		want: &pb2.Communique{Union: &pb2.Communique_Number{41}},
+	},
+	{ // Oneof nil is the same as not set.
+		src:  &pb2.Communique{},
+		dst:  &pb2.Communique{Union: &pb2.Communique_Name{"Bobby Tables"}},
+		want: &pb2.Communique{Union: &pb2.Communique_Name{"Bobby Tables"}},
+	},
+	{
+		src:  &pb2.Communique{Union: &pb2.Communique_Number{1337}},
+		dst:  &pb2.Communique{},
+		want: &pb2.Communique{Union: &pb2.Communique_Number{1337}},
+	},
+	{
+		src:  &pb2.Communique{Union: &pb2.Communique_Col{pb2.MyMessage_RED}},
+		dst:  &pb2.Communique{},
+		want: &pb2.Communique{Union: &pb2.Communique_Col{pb2.MyMessage_RED}},
+	},
+	{
+		src:  &pb2.Communique{Union: &pb2.Communique_Data{[]byte("hello")}},
+		dst:  &pb2.Communique{},
+		want: &pb2.Communique{Union: &pb2.Communique_Data{[]byte("hello")}},
+	},
+	{
+		src:  &pb2.Communique{Union: &pb2.Communique_Msg{&pb2.Strings{BytesField: []byte{1, 2, 3}}}},
+		dst:  &pb2.Communique{},
+		want: &pb2.Communique{Union: &pb2.Communique_Msg{&pb2.Strings{BytesField: []byte{1, 2, 3}}}},
+	},
+	{
+		src:  &pb2.Communique{Union: &pb2.Communique_Msg{}},
+		dst:  &pb2.Communique{},
+		want: &pb2.Communique{Union: &pb2.Communique_Msg{}},
+	},
+	{
+		src:  &pb2.Communique{Union: &pb2.Communique_Msg{&pb2.Strings{StringField: proto.String("123")}}},
+		dst:  &pb2.Communique{Union: &pb2.Communique_Msg{&pb2.Strings{BytesField: []byte{1, 2, 3}}}},
+		want: &pb2.Communique{Union: &pb2.Communique_Msg{&pb2.Strings{StringField: proto.String("123"), BytesField: []byte{1, 2, 3}}}},
+	},
+	{
+		src: &pb3.Message{
+			Terrain: map[string]*pb3.Nested{
+				"kay_a": &pb3.Nested{Cute: true},      // replace
+				"kay_b": &pb3.Nested{Bunny: "rabbit"}, // insert
+			},
+		},
+		dst: &pb3.Message{
+			Terrain: map[string]*pb3.Nested{
+				"kay_a": &pb3.Nested{Bunny: "lost"},  // replaced
+				"kay_c": &pb3.Nested{Bunny: "bunny"}, // keep
+			},
+		},
+		want: &pb3.Message{
+			Terrain: map[string]*pb3.Nested{
+				"kay_a": &pb3.Nested{Cute: true},
+				"kay_b": &pb3.Nested{Bunny: "rabbit"},
+				"kay_c": &pb3.Nested{Bunny: "bunny"},
+			},
+		},
+	},
+	{
+		src: &pb2.GoTest{
+			F_BoolRepeated:   []bool{},
+			F_Int32Repeated:  []int32{},
+			F_Int64Repeated:  []int64{},
+			F_Uint32Repeated: []uint32{},
+			F_Uint64Repeated: []uint64{},
+			F_FloatRepeated:  []float32{},
+			F_DoubleRepeated: []float64{},
+			F_StringRepeated: []string{},
+			F_BytesRepeated:  [][]byte{},
+		},
+		dst: &pb2.GoTest{},
+		want: &pb2.GoTest{
+			F_BoolRepeated:   []bool{},
+			F_Int32Repeated:  []int32{},
+			F_Int64Repeated:  []int64{},
+			F_Uint32Repeated: []uint32{},
+			F_Uint64Repeated: []uint64{},
+			F_FloatRepeated:  []float32{},
+			F_DoubleRepeated: []float64{},
+			F_StringRepeated: []string{},
+			F_BytesRepeated:  [][]byte{},
+		},
+	},
+	{
+		src: &pb2.GoTest{},
+		dst: &pb2.GoTest{
+			F_BoolRepeated:   []bool{},
+			F_Int32Repeated:  []int32{},
+			F_Int64Repeated:  []int64{},
+			F_Uint32Repeated: []uint32{},
+			F_Uint64Repeated: []uint64{},
+			F_FloatRepeated:  []float32{},
+			F_DoubleRepeated: []float64{},
+			F_StringRepeated: []string{},
+			F_BytesRepeated:  [][]byte{},
+		},
+		want: &pb2.GoTest{
+			F_BoolRepeated:   []bool{},
+			F_Int32Repeated:  []int32{},
+			F_Int64Repeated:  []int64{},
+			F_Uint32Repeated: []uint32{},
+			F_Uint64Repeated: []uint64{},
+			F_FloatRepeated:  []float32{},
+			F_DoubleRepeated: []float64{},
+			F_StringRepeated: []string{},
+			F_BytesRepeated:  [][]byte{},
+		},
+	},
+	{
+		src: &pb2.GoTest{
+			F_BytesRepeated: [][]byte{nil, []byte{}, []byte{0}},
+		},
+		dst: &pb2.GoTest{},
+		want: &pb2.GoTest{
+			F_BytesRepeated: [][]byte{nil, []byte{}, []byte{0}},
+		},
+	},
+	{
+		src: &pb2.MyMessage{
+			Others: []*pb2.OtherMessage{},
+		},
+		dst: &pb2.MyMessage{},
+		want: &pb2.MyMessage{
+			Others: []*pb2.OtherMessage{},
+		},
+	},
+}
+
+func TestMerge(t *testing.T) {
+	for _, m := range mergeTests {
+		got := proto.Clone(m.dst)
+		if !proto.Equal(got, m.dst) {
+			t.Errorf("Clone()\ngot  %v\nwant %v", got, m.dst)
+			continue
+		}
+		proto.Merge(got, m.src)
+		if !proto.Equal(got, m.want) {
+			t.Errorf("Merge(%v, %v)\ngot  %v\nwant %v", m.dst, m.src, got, m.want)
+		}
+	}
+}
diff --git a/vendor/github.com/golang/protobuf/proto/proto_equal_test.go b/vendor/github.com/golang/protobuf/proto/proto_equal_test.go
new file mode 100644
index 000000000..d5b2541a0
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/proto_equal_test.go
@@ -0,0 +1,218 @@
+// Copyright 2011 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 proto_test
+
+import (
+	"testing"
+
+	"github.com/golang/protobuf/proto"
+
+	pb2 "github.com/golang/protobuf/internal/testprotos/proto2_proto"
+	pb3 "github.com/golang/protobuf/internal/testprotos/proto3_proto"
+)
+
+// Four identical base messages.
+// The init function adds extensions to some of them.
+var messageWithoutExtension = &pb2.MyMessage{Count: proto.Int32(7)}
+var messageWithExtension1a = &pb2.MyMessage{Count: proto.Int32(7)}
+var messageWithExtension1b = &pb2.MyMessage{Count: proto.Int32(7)}
+var messageWithExtension2 = &pb2.MyMessage{Count: proto.Int32(7)}
+var messageWithExtension3a = &pb2.MyMessage{Count: proto.Int32(7)}
+var messageWithExtension3b = &pb2.MyMessage{Count: proto.Int32(7)}
+var messageWithExtension3c = &pb2.MyMessage{Count: proto.Int32(7)}
+
+// Two messages with non-message extensions.
+var messageWithInt32Extension1 = &pb2.MyMessage{Count: proto.Int32(8)}
+var messageWithInt32Extension2 = &pb2.MyMessage{Count: proto.Int32(8)}
+
+func init() {
+	ext1 := &pb2.Ext{Data: proto.String("Kirk")}
+	ext2 := &pb2.Ext{Data: proto.String("Picard")}
+
+	// messageWithExtension1a has ext1, but never marshals it.
+	if err := proto.SetExtension(messageWithExtension1a, pb2.E_Ext_More, ext1); err != nil {
+		panic("proto.SetExtension on 1a failed: " + err.Error())
+	}
+
+	// messageWithExtension1b is the unmarshaled form of messageWithExtension1a.
+	if err := proto.SetExtension(messageWithExtension1b, pb2.E_Ext_More, ext1); err != nil {
+		panic("proto.SetExtension on 1b failed: " + err.Error())
+	}
+	buf, err := proto.Marshal(messageWithExtension1b)
+	if err != nil {
+		panic("proto.Marshal of 1b failed: " + err.Error())
+	}
+	messageWithExtension1b.Reset()
+	if err := proto.Unmarshal(buf, messageWithExtension1b); err != nil {
+		panic("proto.Unmarshal of 1b failed: " + err.Error())
+	}
+
+	// messageWithExtension2 has ext2.
+	if err := proto.SetExtension(messageWithExtension2, pb2.E_Ext_More, ext2); err != nil {
+		panic("proto.SetExtension on 2 failed: " + err.Error())
+	}
+
+	if err := proto.SetExtension(messageWithInt32Extension1, pb2.E_Ext_Number, proto.Int32(23)); err != nil {
+		panic("proto.SetExtension on Int32-1 failed: " + err.Error())
+	}
+	if err := proto.SetExtension(messageWithInt32Extension1, pb2.E_Ext_Number, proto.Int32(24)); err != nil {
+		panic("proto.SetExtension on Int32-2 failed: " + err.Error())
+	}
+
+	// messageWithExtension3{a,b,c} has unregistered extension.
+	if proto.RegisteredExtensions(messageWithExtension3a)[200] != nil {
+		panic("expect extension 200 unregistered")
+	}
+	bytes := []byte{
+		0xc0, 0x0c, 0x01, // id=200, wiretype=0 (varint), data=1
+	}
+	bytes2 := []byte{
+		0xc0, 0x0c, 0x02, // id=200, wiretype=0 (varint), data=2
+	}
+	proto.SetRawExtension(messageWithExtension3a, 200, bytes)
+	proto.SetRawExtension(messageWithExtension3b, 200, bytes)
+	proto.SetRawExtension(messageWithExtension3c, 200, bytes2)
+}
+
+var EqualTests = []struct {
+	desc string
+	a, b proto.Message
+	exp  bool
+}{
+	{"different types", &pb2.GoEnum{}, &pb2.GoTestField{}, false},
+	{"equal empty", &pb2.GoEnum{}, &pb2.GoEnum{}, true},
+	{"nil vs nil", nil, nil, true},
+	{"typed nil vs typed nil", (*pb2.GoEnum)(nil), (*pb2.GoEnum)(nil), true},
+	{"typed nil vs empty", (*pb2.GoEnum)(nil), &pb2.GoEnum{}, false},
+	{"different typed nil", (*pb2.GoEnum)(nil), (*pb2.GoTestField)(nil), false},
+
+	{"one set field, one unset field", &pb2.GoTestField{Label: proto.String("foo")}, &pb2.GoTestField{}, false},
+	{"one set field zero, one unset field", &pb2.GoTest{Param: proto.Int32(0)}, &pb2.GoTest{}, false},
+	{"different set fields", &pb2.GoTestField{Label: proto.String("foo")}, &pb2.GoTestField{Label: proto.String("bar")}, false},
+	{"equal set", &pb2.GoTestField{Label: proto.String("foo")}, &pb2.GoTestField{Label: proto.String("foo")}, true},
+
+	{"repeated, one set", &pb2.GoTest{F_Int32Repeated: []int32{2, 3}}, &pb2.GoTest{}, false},
+	{"repeated, different length", &pb2.GoTest{F_Int32Repeated: []int32{2, 3}}, &pb2.GoTest{F_Int32Repeated: []int32{2}}, false},
+	{"repeated, different value", &pb2.GoTest{F_Int32Repeated: []int32{2}}, &pb2.GoTest{F_Int32Repeated: []int32{3}}, false},
+	{"repeated, equal", &pb2.GoTest{F_Int32Repeated: []int32{2, 4}}, &pb2.GoTest{F_Int32Repeated: []int32{2, 4}}, true},
+	{"repeated, nil equal nil", &pb2.GoTest{F_Int32Repeated: nil}, &pb2.GoTest{F_Int32Repeated: nil}, true},
+	{"repeated, nil equal empty", &pb2.GoTest{F_Int32Repeated: nil}, &pb2.GoTest{F_Int32Repeated: []int32{}}, true},
+	{"repeated, empty equal nil", &pb2.GoTest{F_Int32Repeated: []int32{}}, &pb2.GoTest{F_Int32Repeated: nil}, true},
+
+	{
+		"nested, different",
+		&pb2.GoTest{RequiredField: &pb2.GoTestField{Label: proto.String("foo")}},
+		&pb2.GoTest{RequiredField: &pb2.GoTestField{Label: proto.String("bar")}},
+		false,
+	},
+	{
+		"nested, equal",
+		&pb2.GoTest{RequiredField: &pb2.GoTestField{Label: proto.String("wow")}},
+		&pb2.GoTest{RequiredField: &pb2.GoTestField{Label: proto.String("wow")}},
+		true,
+	},
+
+	{"bytes", &pb2.OtherMessage{Value: []byte("foo")}, &pb2.OtherMessage{Value: []byte("foo")}, true},
+	{"bytes, empty", &pb2.OtherMessage{Value: []byte{}}, &pb2.OtherMessage{Value: []byte{}}, true},
+	{"bytes, empty vs nil", &pb2.OtherMessage{Value: []byte{}}, &pb2.OtherMessage{Value: nil}, false},
+	{
+		"repeated bytes",
+		&pb2.MyMessage{RepBytes: [][]byte{[]byte("sham"), []byte("wow")}},
+		&pb2.MyMessage{RepBytes: [][]byte{[]byte("sham"), []byte("wow")}},
+		true,
+	},
+	// In proto3, []byte{} and []byte(nil) are equal.
+	{"proto3 bytes, empty vs nil", &pb3.Message{Data: []byte{}}, &pb3.Message{Data: nil}, true},
+
+	{"extension vs. no extension", messageWithoutExtension, messageWithExtension1a, false},
+	{"extension vs. same extension", messageWithExtension1a, messageWithExtension1b, true},
+	{"extension vs. different extension", messageWithExtension1a, messageWithExtension2, false},
+
+	{"int32 extension vs. itself", messageWithInt32Extension1, messageWithInt32Extension1, true},
+	{"int32 extension vs. a different int32", messageWithInt32Extension1, messageWithInt32Extension2, false},
+
+	{"unregistered extension same", messageWithExtension3a, messageWithExtension3b, true},
+	{"unregistered extension different", messageWithExtension3a, messageWithExtension3c, false},
+
+	{
+		"message with group",
+		&pb2.MyMessage{
+			Count: proto.Int32(1),
+			Somegroup: &pb2.MyMessage_SomeGroup{
+				GroupField: proto.Int32(5),
+			},
+		},
+		&pb2.MyMessage{
+			Count: proto.Int32(1),
+			Somegroup: &pb2.MyMessage_SomeGroup{
+				GroupField: proto.Int32(5),
+			},
+		},
+		true,
+	},
+
+	{
+		"map same",
+		&pb2.MessageWithMap{NameMapping: map[int32]string{1: "Ken"}},
+		&pb2.MessageWithMap{NameMapping: map[int32]string{1: "Ken"}},
+		true,
+	},
+	{
+		"map different entry",
+		&pb2.MessageWithMap{NameMapping: map[int32]string{1: "Ken"}},
+		&pb2.MessageWithMap{NameMapping: map[int32]string{2: "Rob"}},
+		false,
+	},
+	{
+		"map different key only",
+		&pb2.MessageWithMap{NameMapping: map[int32]string{1: "Ken"}},
+		&pb2.MessageWithMap{NameMapping: map[int32]string{2: "Ken"}},
+		false,
+	},
+	{
+		"map different value only",
+		&pb2.MessageWithMap{NameMapping: map[int32]string{1: "Ken"}},
+		&pb2.MessageWithMap{NameMapping: map[int32]string{1: "Rob"}},
+		false,
+	},
+	{
+		"zero-length maps same",
+		&pb2.MessageWithMap{NameMapping: map[int32]string{}},
+		&pb2.MessageWithMap{NameMapping: nil},
+		true,
+	},
+	{
+		"orders in map don't matter",
+		&pb2.MessageWithMap{NameMapping: map[int32]string{1: "Ken", 2: "Rob"}},
+		&pb2.MessageWithMap{NameMapping: map[int32]string{2: "Rob", 1: "Ken"}},
+		true,
+	},
+	{
+		"oneof same",
+		&pb2.Communique{Union: &pb2.Communique_Number{41}},
+		&pb2.Communique{Union: &pb2.Communique_Number{41}},
+		true,
+	},
+	{
+		"oneof one nil",
+		&pb2.Communique{Union: &pb2.Communique_Number{41}},
+		&pb2.Communique{},
+		false,
+	},
+	{
+		"oneof different",
+		&pb2.Communique{Union: &pb2.Communique_Number{41}},
+		&pb2.Communique{Union: &pb2.Communique_Name{"Bobby Tables"}},
+		false,
+	},
+}
+
+func TestEqual(t *testing.T) {
+	for _, tc := range EqualTests {
+		if res := proto.Equal(tc.a, tc.b); res != tc.exp {
+			t.Errorf("%v: Equal(%v, %v) = %v, want %v", tc.desc, tc.a, tc.b, res, tc.exp)
+		}
+	}
+}
diff --git a/vendor/github.com/golang/protobuf/proto/proto_test.go b/vendor/github.com/golang/protobuf/proto/proto_test.go
new file mode 100644
index 000000000..61c8f8a02
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/proto_test.go
@@ -0,0 +1,2593 @@
+// Copyright 2010 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 proto_test
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"log"
+	"math"
+	"math/rand"
+	"reflect"
+	"runtime/debug"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/golang/protobuf/proto"
+	"google.golang.org/protobuf/testing/protopack"
+
+	pb2 "github.com/golang/protobuf/internal/testprotos/proto2_proto"
+	pb3 "github.com/golang/protobuf/internal/testprotos/proto3_proto"
+	tspb "github.com/golang/protobuf/ptypes/timestamp"
+)
+
+func initGoTestField() *pb2.GoTestField {
+	f := new(pb2.GoTestField)
+	f.Label = proto.String("label")
+	f.Type = proto.String("type")
+	return f
+}
+
+// These are all structurally equivalent but the tag numbers differ.
+// (It's remarkable that required, optional, and repeated all have
+// 8 letters.)
+func initGoTest_RequiredGroup() *pb2.GoTest_RequiredGroup {
+	return &pb2.GoTest_RequiredGroup{
+		RequiredField: proto.String("required"),
+	}
+}
+
+func initGoTest_OptionalGroup() *pb2.GoTest_OptionalGroup {
+	return &pb2.GoTest_OptionalGroup{
+		RequiredField: proto.String("optional"),
+	}
+}
+
+func initGoTest_RepeatedGroup() *pb2.GoTest_RepeatedGroup {
+	return &pb2.GoTest_RepeatedGroup{
+		RequiredField: proto.String("repeated"),
+	}
+}
+
+func initGoTest(setdefaults bool) *pb2.GoTest {
+	pb := new(pb2.GoTest)
+	if setdefaults {
+		pb.F_BoolDefaulted = proto.Bool(pb2.Default_GoTest_F_BoolDefaulted)
+		pb.F_Int32Defaulted = proto.Int32(pb2.Default_GoTest_F_Int32Defaulted)
+		pb.F_Int64Defaulted = proto.Int64(pb2.Default_GoTest_F_Int64Defaulted)
+		pb.F_Fixed32Defaulted = proto.Uint32(pb2.Default_GoTest_F_Fixed32Defaulted)
+		pb.F_Fixed64Defaulted = proto.Uint64(pb2.Default_GoTest_F_Fixed64Defaulted)
+		pb.F_Uint32Defaulted = proto.Uint32(pb2.Default_GoTest_F_Uint32Defaulted)
+		pb.F_Uint64Defaulted = proto.Uint64(pb2.Default_GoTest_F_Uint64Defaulted)
+		pb.F_FloatDefaulted = proto.Float32(pb2.Default_GoTest_F_FloatDefaulted)
+		pb.F_DoubleDefaulted = proto.Float64(pb2.Default_GoTest_F_DoubleDefaulted)
+		pb.F_StringDefaulted = proto.String(pb2.Default_GoTest_F_StringDefaulted)
+		pb.F_BytesDefaulted = pb2.Default_GoTest_F_BytesDefaulted
+		pb.F_Sint32Defaulted = proto.Int32(pb2.Default_GoTest_F_Sint32Defaulted)
+		pb.F_Sint64Defaulted = proto.Int64(pb2.Default_GoTest_F_Sint64Defaulted)
+		pb.F_Sfixed32Defaulted = proto.Int32(pb2.Default_GoTest_F_Sfixed32Defaulted)
+		pb.F_Sfixed64Defaulted = proto.Int64(pb2.Default_GoTest_F_Sfixed64Defaulted)
+	}
+
+	pb.Kind = pb2.GoTest_TIME.Enum()
+	pb.RequiredField = initGoTestField()
+	pb.F_BoolRequired = proto.Bool(true)
+	pb.F_Int32Required = proto.Int32(3)
+	pb.F_Int64Required = proto.Int64(6)
+	pb.F_Fixed32Required = proto.Uint32(32)
+	pb.F_Fixed64Required = proto.Uint64(64)
+	pb.F_Uint32Required = proto.Uint32(3232)
+	pb.F_Uint64Required = proto.Uint64(6464)
+	pb.F_FloatRequired = proto.Float32(3232)
+	pb.F_DoubleRequired = proto.Float64(6464)
+	pb.F_StringRequired = proto.String("string")
+	pb.F_BytesRequired = []byte("bytes")
+	pb.F_Sint32Required = proto.Int32(-32)
+	pb.F_Sint64Required = proto.Int64(-64)
+	pb.F_Sfixed32Required = proto.Int32(-32)
+	pb.F_Sfixed64Required = proto.Int64(-64)
+	pb.Requiredgroup = initGoTest_RequiredGroup()
+
+	return pb
+}
+
+func overify(t *testing.T, pb *pb2.GoTest, want []byte) {
+	bb := new(proto.Buffer)
+	err := bb.Marshal(pb)
+	got := bb.Bytes()
+	if err != nil {
+		t.Logf("overify marshal-1 err = %v", err)
+	}
+	if !bytes.Equal(got, want) {
+		t.Fatalf("got %q\nwant  %q", got, want)
+	}
+
+	// Now test Unmarshal by recreating the original buffer.
+	pbd := new(pb2.GoTest)
+	err = bb.Unmarshal(pbd)
+	if err != nil {
+		t.Fatalf("overify unmarshal err = %v", err)
+	}
+	bb.Reset()
+	err = bb.Marshal(pbd)
+	got = bb.Bytes()
+	if err != nil {
+		t.Fatalf("overify marshal-2 err = %v", err)
+	}
+	if !bytes.Equal(got, want) {
+		t.Fatalf("got %q\nwant  %q", got, want)
+	}
+}
+
+// When hooks are enabled, RequiredNotSetError is typed alias to internal/proto
+// package. Binary serialization has not been wrapped yet and hence produces
+// requiredNotSetError instead. This function is a work-around to identify both
+// aliased and non-aliased types.
+func isRequiredNotSetError(err error) bool {
+	e, ok := err.(interface{ RequiredNotSet() bool })
+	return ok && e.RequiredNotSet()
+}
+
+// Simple tests for numeric encode/decode primitives (varint, etc.)
+func TestNumericPrimitives(t *testing.T) {
+	for i := uint64(0); i < 1e6; i += 111 {
+		o := new(proto.Buffer)
+		if o.EncodeVarint(i) != nil {
+			t.Error("EncodeVarint")
+			break
+		}
+		x, e := o.DecodeVarint()
+		if e != nil {
+			t.Fatal("DecodeVarint")
+		}
+		if x != i {
+			t.Fatal("varint decode fail:", i, x)
+		}
+
+		o.Reset()
+		if o.EncodeFixed32(i) != nil {
+			t.Fatal("encFixed32")
+		}
+		x, e = o.DecodeFixed32()
+		if e != nil {
+			t.Fatal("decFixed32")
+		}
+		if x != i {
+			t.Fatal("fixed32 decode fail:", i, x)
+		}
+
+		o.Reset()
+		if o.EncodeFixed64(i*1234567) != nil {
+			t.Error("encFixed64")
+			break
+		}
+		x, e = o.DecodeFixed64()
+		if e != nil {
+			t.Error("decFixed64")
+			break
+		}
+		if x != i*1234567 {
+			t.Error("fixed64 decode fail:", i*1234567, x)
+			break
+		}
+
+		o.Reset()
+		i32 := int32(i - 12345)
+		if o.EncodeZigzag32(uint64(i32)) != nil {
+			t.Fatal("EncodeZigzag32")
+		}
+		x, e = o.DecodeZigzag32()
+		if e != nil {
+			t.Fatal("DecodeZigzag32")
+		}
+		if x != uint64(uint32(i32)) {
+			t.Fatal("zigzag32 decode fail:", i32, x)
+		}
+
+		o.Reset()
+		i64 := int64(i - 12345)
+		if o.EncodeZigzag64(uint64(i64)) != nil {
+			t.Fatal("EncodeZigzag64")
+		}
+		x, e = o.DecodeZigzag64()
+		if e != nil {
+			t.Fatal("DecodeZigzag64")
+		}
+		if x != uint64(i64) {
+			t.Fatal("zigzag64 decode fail:", i64, x)
+		}
+	}
+}
+
+// fakeMarshaler is a simple struct implementing Marshaler and Message interfaces.
+type fakeMarshaler struct {
+	b   []byte
+	err error
+}
+
+func (f *fakeMarshaler) Marshal() ([]byte, error) { return f.b, f.err }
+func (f *fakeMarshaler) String() string           { return fmt.Sprintf("Bytes: %v Error: %v", f.b, f.err) }
+func (f *fakeMarshaler) ProtoMessage()            {}
+func (f *fakeMarshaler) Reset()                   {}
+
+type msgWithFakeMarshaler struct {
+	M *fakeMarshaler `protobuf:"bytes,1,opt,name=fake"`
+}
+
+func (m *msgWithFakeMarshaler) String() string { return proto.CompactTextString(m) }
+func (m *msgWithFakeMarshaler) ProtoMessage()  {}
+func (m *msgWithFakeMarshaler) Reset()         {}
+
+// Simple tests for proto messages that implement the Marshaler interface.
+func TestMarshalerEncoding(t *testing.T) {
+	tests := []struct {
+		name    string
+		m       proto.Message
+		want    []byte
+		errType reflect.Type
+	}{
+		{
+			name: "Marshaler that fails",
+			m: &fakeMarshaler{
+				err: errors.New("some marshal err"),
+				b:   []byte{5, 6, 7},
+			},
+			errType: reflect.TypeOf(errors.New("some marshal err")),
+		},
+		{
+			name: "Marshaler that fails with RequiredNotSetError",
+			m: &msgWithFakeMarshaler{
+				M: &fakeMarshaler{
+					err: &proto.RequiredNotSetError{},
+					b:   []byte{5, 6, 7},
+				},
+			},
+			errType: reflect.TypeOf(&proto.RequiredNotSetError{}),
+		},
+		{
+			name: "Marshaler that succeeds",
+			m: &fakeMarshaler{
+				b: []byte{0, 1, 2, 3, 4, 127, 255},
+			},
+			want: []byte{0, 1, 2, 3, 4, 127, 255},
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			b := proto.NewBuffer(nil)
+			err := b.Marshal(test.m)
+			if reflect.TypeOf(err) != test.errType {
+				t.Errorf("got err %T(%v) wanted %T", err, err, test.errType)
+			}
+			if err != nil {
+				return // skip comparing output when marshal fails.
+			}
+			if !reflect.DeepEqual(test.want, b.Bytes()) {
+				t.Errorf("got bytes %v wanted %v", b.Bytes(), test.want)
+			}
+			if size := proto.Size(test.m); size != len(b.Bytes()) {
+				t.Errorf("Size(_) = %v, but marshaled to %v bytes", size, len(b.Bytes()))
+			}
+
+			m, mErr := proto.Marshal(test.m)
+			if !bytes.Equal(b.Bytes(), m) {
+				t.Errorf("Marshal returned %v, but (*Buffer).Marshal wrote %v", m, b.Bytes())
+			}
+			if !reflect.DeepEqual(err, mErr) {
+				t.Errorf("Marshal err = %v, but (*Buffer).Marshal returned %v", mErr, err)
+			}
+		})
+	}
+}
+
+// Ensure that Buffer.Marshal uses O(N) memory for N messages
+func TestBufferMarshalAllocs(t *testing.T) {
+	value := &pb2.OtherMessage{Key: proto.Int64(1)}
+	msg := &pb2.MyMessage{Count: proto.Int32(1), Others: []*pb2.OtherMessage{value}}
+
+	for _, prealloc := range []int{0, 100, 10000} {
+		const count = 1000
+		var b proto.Buffer
+		s := make([]byte, 0, proto.Size(msg))
+		marshalAllocs := testing.AllocsPerRun(count, func() {
+			b.SetBuf(s)
+			err := b.Marshal(msg)
+			if err != nil {
+				t.Errorf("Marshal err = %q", err)
+			}
+		})
+
+		b.SetBuf(make([]byte, 0, prealloc))
+		bufferAllocs := testing.AllocsPerRun(count, func() {
+			err := b.Marshal(msg)
+			if err != nil {
+				t.Errorf("Marshal err = %q", err)
+			}
+		})
+
+		if marshalAllocs != bufferAllocs {
+			t.Errorf("%v allocs/op when writing to a preallocated buffer", marshalAllocs)
+			t.Errorf("%v allocs/op when repeatedly appending to a buffer", bufferAllocs)
+			t.Errorf("expect amortized allocs/op to be identical")
+		}
+	}
+}
+
+// Simple tests for bytes
+func TestBytesPrimitives(t *testing.T) {
+	bb := new(proto.Buffer)
+	want := []byte("now is the time")
+	if err := bb.EncodeRawBytes(want); err != nil {
+		t.Errorf("EncodeRawBytes error: %v", err)
+	}
+	got, err := bb.DecodeRawBytes(false)
+	if err != nil {
+		t.Errorf("DecodeRawBytes error: %v", err)
+	}
+	if !bytes.Equal(got, want) {
+		t.Errorf("got %q\nwant  %q", got, want)
+	}
+}
+
+// Simple tests for strings
+func TestStringPrimitives(t *testing.T) {
+	bb := new(proto.Buffer)
+	want := "now is the time"
+	if err := bb.EncodeStringBytes(want); err != nil {
+		t.Errorf("EncodeStringBytes error: %v", err)
+	}
+	got, err := bb.DecodeStringBytes()
+	if err != nil {
+		t.Errorf("DecodeStringBytes error: %v", err)
+	}
+	if got != want {
+		t.Errorf("got %q\nwant  %q", got, want)
+	}
+}
+
+// Do we catch the "required bit not set" case?
+func TestRequiredBit(t *testing.T) {
+	o := new(proto.Buffer)
+	pb := new(pb2.GoTest)
+	err := o.Marshal(pb)
+	if err == nil {
+		t.Error("did not catch missing required fields")
+	} else if !strings.Contains(err.Error(), "Kind") {
+		t.Error("wrong error type:", err)
+	}
+}
+
+// Check that all fields are nil.
+// Clearly silly, and a residue from a more interesting test with an earlier,
+// different initialization property, but it once caught a compiler bug so
+// it lives.
+func checkInitialized(pb *pb2.GoTest, t *testing.T) {
+	switch {
+	case pb.F_BoolDefaulted != nil:
+		t.Error("New or Reset did not set boolean:", *pb.F_BoolDefaulted)
+	case pb.F_Int32Defaulted != nil:
+		t.Error("New or Reset did not set int32:", *pb.F_Int32Defaulted)
+	case pb.F_Int64Defaulted != nil:
+		t.Error("New or Reset did not set int64:", *pb.F_Int64Defaulted)
+	case pb.F_Fixed32Defaulted != nil:
+		t.Error("New or Reset did not set fixed32:", *pb.F_Fixed32Defaulted)
+	case pb.F_Fixed64Defaulted != nil:
+		t.Error("New or Reset did not set fixed64:", *pb.F_Fixed64Defaulted)
+	case pb.F_Uint32Defaulted != nil:
+		t.Error("New or Reset did not set uint32:", *pb.F_Uint32Defaulted)
+	case pb.F_Uint64Defaulted != nil:
+		t.Error("New or Reset did not set uint64:", *pb.F_Uint64Defaulted)
+	case pb.F_FloatDefaulted != nil:
+		t.Error("New or Reset did not set float:", *pb.F_FloatDefaulted)
+	case pb.F_DoubleDefaulted != nil:
+		t.Error("New or Reset did not set double:", *pb.F_DoubleDefaulted)
+	case pb.F_StringDefaulted != nil:
+		t.Error("New or Reset did not set string:", *pb.F_StringDefaulted)
+	case pb.F_BytesDefaulted != nil:
+		t.Error("New or Reset did not set bytes:", string(pb.F_BytesDefaulted))
+	case pb.F_Sint32Defaulted != nil:
+		t.Error("New or Reset did not set int32:", *pb.F_Sint32Defaulted)
+	case pb.F_Sint64Defaulted != nil:
+		t.Error("New or Reset did not set int64:", *pb.F_Sint64Defaulted)
+	}
+}
+
+// Does Reset() reset?
+func TestReset(t *testing.T) {
+	pb := initGoTest(true)
+	// muck with some values
+	pb.F_BoolDefaulted = proto.Bool(false)
+	pb.F_Int32Defaulted = proto.Int32(237)
+	pb.F_Int64Defaulted = proto.Int64(12346)
+	pb.F_Fixed32Defaulted = proto.Uint32(32000)
+	pb.F_Fixed64Defaulted = proto.Uint64(666)
+	pb.F_Uint32Defaulted = proto.Uint32(323232)
+	pb.F_Uint64Defaulted = nil
+	pb.F_FloatDefaulted = nil
+	pb.F_DoubleDefaulted = proto.Float64(0)
+	pb.F_StringDefaulted = proto.String("gotcha")
+	pb.F_BytesDefaulted = []byte("asdfasdf")
+	pb.F_Sint32Defaulted = proto.Int32(123)
+	pb.F_Sint64Defaulted = proto.Int64(789)
+	pb.Reset()
+	checkInitialized(pb, t)
+}
+
+// All required fields set, no defaults provided.
+func TestEncodeDecode1(t *testing.T) {
+	pb := initGoTest(false)
+	overify(t, pb,
+		protopack.Message{
+			protopack.Tag{1, protopack.VarintType}, protopack.Uvarint(7),
+			protopack.Tag{4, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.BytesType}, protopack.String("label"),
+				protopack.Tag{2, protopack.BytesType}, protopack.String("type"),
+			}),
+			protopack.Tag{10, protopack.VarintType}, protopack.Bool(true),
+			protopack.Tag{11, protopack.VarintType}, protopack.Varint(3),
+			protopack.Tag{12, protopack.VarintType}, protopack.Varint(6),
+			protopack.Tag{13, protopack.Fixed32Type}, protopack.Uint32(32),
+			protopack.Tag{14, protopack.Fixed64Type}, protopack.Uint64(64),
+			protopack.Tag{15, protopack.VarintType}, protopack.Uvarint(3232),
+			protopack.Tag{16, protopack.VarintType}, protopack.Uvarint(6464),
+			protopack.Tag{17, protopack.Fixed32Type}, protopack.Float32(3232),
+			protopack.Tag{18, protopack.Fixed64Type}, protopack.Float64(6464),
+			protopack.Tag{19, protopack.BytesType}, protopack.String("string"),
+			protopack.Tag{70, protopack.StartGroupType},
+			protopack.Message{
+				protopack.Tag{71, protopack.BytesType}, protopack.String("required"),
+			},
+			protopack.Tag{70, protopack.EndGroupType},
+			protopack.Tag{101, protopack.BytesType}, protopack.Bytes("bytes"),
+			protopack.Tag{102, protopack.VarintType}, protopack.Svarint(-32),
+			protopack.Tag{103, protopack.VarintType}, protopack.Svarint(-64),
+			protopack.Tag{104, protopack.Fixed32Type}, protopack.Int32(-32),
+			protopack.Tag{105, protopack.Fixed64Type}, protopack.Int64(-64),
+		}.Marshal())
+}
+
+// All required fields set, defaults provided.
+func TestEncodeDecode2(t *testing.T) {
+	pb := initGoTest(true)
+	overify(t, pb,
+		protopack.Message{
+			protopack.Tag{1, protopack.VarintType}, protopack.Uvarint(7),
+			protopack.Tag{4, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.BytesType}, protopack.String("label"),
+				protopack.Tag{2, protopack.BytesType}, protopack.String("type"),
+			}),
+			protopack.Tag{10, protopack.VarintType}, protopack.Bool(true),
+			protopack.Tag{11, protopack.VarintType}, protopack.Varint(3),
+			protopack.Tag{12, protopack.VarintType}, protopack.Varint(6),
+			protopack.Tag{13, protopack.Fixed32Type}, protopack.Uint32(32),
+			protopack.Tag{14, protopack.Fixed64Type}, protopack.Uint64(64),
+			protopack.Tag{15, protopack.VarintType}, protopack.Uvarint(3232),
+			protopack.Tag{16, protopack.VarintType}, protopack.Uvarint(6464),
+			protopack.Tag{17, protopack.Fixed32Type}, protopack.Float32(3232),
+			protopack.Tag{18, protopack.Fixed64Type}, protopack.Float64(6464),
+			protopack.Tag{19, protopack.BytesType}, protopack.String("string"),
+			protopack.Tag{40, protopack.VarintType}, protopack.Bool(true),
+			protopack.Tag{41, protopack.VarintType}, protopack.Varint(32),
+			protopack.Tag{42, protopack.VarintType}, protopack.Varint(64),
+			protopack.Tag{43, protopack.Fixed32Type}, protopack.Uint32(320),
+			protopack.Tag{44, protopack.Fixed64Type}, protopack.Uint64(640),
+			protopack.Tag{45, protopack.VarintType}, protopack.Uvarint(3200),
+			protopack.Tag{46, protopack.VarintType}, protopack.Uvarint(6400),
+			protopack.Tag{47, protopack.Fixed32Type}, protopack.Float32(314159),
+			protopack.Tag{48, protopack.Fixed64Type}, protopack.Float64(271828),
+			protopack.Tag{49, protopack.BytesType}, protopack.String("hello, \"world!\"\n"),
+			protopack.Tag{70, protopack.StartGroupType},
+			protopack.Message{
+				protopack.Tag{71, protopack.BytesType}, protopack.String("required"),
+			},
+			protopack.Tag{70, protopack.EndGroupType},
+			protopack.Tag{101, protopack.BytesType}, protopack.Bytes("bytes"),
+			protopack.Tag{102, protopack.VarintType}, protopack.Svarint(-32),
+			protopack.Tag{103, protopack.VarintType}, protopack.Svarint(-64),
+			protopack.Tag{104, protopack.Fixed32Type}, protopack.Int32(-32),
+			protopack.Tag{105, protopack.Fixed64Type}, protopack.Int64(-64),
+			protopack.Tag{401, protopack.BytesType}, protopack.Bytes("Bignose"),
+			protopack.Tag{402, protopack.VarintType}, protopack.Svarint(-32),
+			protopack.Tag{403, protopack.VarintType}, protopack.Svarint(-64),
+			protopack.Tag{404, protopack.Fixed32Type}, protopack.Int32(-32),
+			protopack.Tag{405, protopack.Fixed64Type}, protopack.Int64(-64),
+		}.Marshal())
+}
+
+// All default fields set to their default value by hand
+func TestEncodeDecode3(t *testing.T) {
+	pb := initGoTest(false)
+	pb.F_BoolDefaulted = proto.Bool(true)
+	pb.F_Int32Defaulted = proto.Int32(32)
+	pb.F_Int64Defaulted = proto.Int64(64)
+	pb.F_Fixed32Defaulted = proto.Uint32(320)
+	pb.F_Fixed64Defaulted = proto.Uint64(640)
+	pb.F_Uint32Defaulted = proto.Uint32(3200)
+	pb.F_Uint64Defaulted = proto.Uint64(6400)
+	pb.F_FloatDefaulted = proto.Float32(314159)
+	pb.F_DoubleDefaulted = proto.Float64(271828)
+	pb.F_StringDefaulted = proto.String("hello, \"world!\"\n")
+	pb.F_BytesDefaulted = []byte("Bignose")
+	pb.F_Sint32Defaulted = proto.Int32(-32)
+	pb.F_Sint64Defaulted = proto.Int64(-64)
+	pb.F_Sfixed32Defaulted = proto.Int32(-32)
+	pb.F_Sfixed64Defaulted = proto.Int64(-64)
+
+	overify(t, pb,
+		protopack.Message{
+			protopack.Tag{1, protopack.VarintType}, protopack.Uvarint(7),
+			protopack.Tag{4, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.BytesType}, protopack.String("label"),
+				protopack.Tag{2, protopack.BytesType}, protopack.String("type"),
+			}),
+			protopack.Tag{10, protopack.VarintType}, protopack.Bool(true),
+			protopack.Tag{11, protopack.VarintType}, protopack.Varint(3),
+			protopack.Tag{12, protopack.VarintType}, protopack.Varint(6),
+			protopack.Tag{13, protopack.Fixed32Type}, protopack.Uint32(32),
+			protopack.Tag{14, protopack.Fixed64Type}, protopack.Uint64(64),
+			protopack.Tag{15, protopack.VarintType}, protopack.Uvarint(3232),
+			protopack.Tag{16, protopack.VarintType}, protopack.Uvarint(6464),
+			protopack.Tag{17, protopack.Fixed32Type}, protopack.Float32(3232),
+			protopack.Tag{18, protopack.Fixed64Type}, protopack.Float64(6464),
+			protopack.Tag{19, protopack.BytesType}, protopack.String("string"),
+			protopack.Tag{40, protopack.VarintType}, protopack.Bool(true),
+			protopack.Tag{41, protopack.VarintType}, protopack.Varint(32),
+			protopack.Tag{42, protopack.VarintType}, protopack.Varint(64),
+			protopack.Tag{43, protopack.Fixed32Type}, protopack.Uint32(320),
+			protopack.Tag{44, protopack.Fixed64Type}, protopack.Uint64(640),
+			protopack.Tag{45, protopack.VarintType}, protopack.Uvarint(3200),
+			protopack.Tag{46, protopack.VarintType}, protopack.Uvarint(6400),
+			protopack.Tag{47, protopack.Fixed32Type}, protopack.Float32(314159),
+			protopack.Tag{48, protopack.Fixed64Type}, protopack.Float64(271828),
+			protopack.Tag{49, protopack.BytesType}, protopack.String("hello, \"world!\"\n"),
+			protopack.Tag{70, protopack.StartGroupType},
+			protopack.Message{
+				protopack.Tag{71, protopack.BytesType}, protopack.String("required"),
+			},
+			protopack.Tag{70, protopack.EndGroupType},
+			protopack.Tag{101, protopack.BytesType}, protopack.Bytes("bytes"),
+			protopack.Tag{102, protopack.VarintType}, protopack.Svarint(-32),
+			protopack.Tag{103, protopack.VarintType}, protopack.Svarint(-64),
+			protopack.Tag{104, protopack.Fixed32Type}, protopack.Int32(-32),
+			protopack.Tag{105, protopack.Fixed64Type}, protopack.Int64(-64),
+			protopack.Tag{401, protopack.BytesType}, protopack.Bytes("Bignose"),
+			protopack.Tag{402, protopack.VarintType}, protopack.Svarint(-32),
+			protopack.Tag{403, protopack.VarintType}, protopack.Svarint(-64),
+			protopack.Tag{404, protopack.Fixed32Type}, protopack.Int32(-32),
+			protopack.Tag{405, protopack.Fixed64Type}, protopack.Int64(-64),
+		}.Marshal())
+}
+
+// All required fields set, defaults provided, all non-defaulted optional fields have values.
+func TestEncodeDecode4(t *testing.T) {
+	pb := initGoTest(true)
+	pb.Table = proto.String("hello")
+	pb.Param = proto.Int32(7)
+	pb.OptionalField = initGoTestField()
+	pb.F_BoolOptional = proto.Bool(true)
+	pb.F_Int32Optional = proto.Int32(32)
+	pb.F_Int64Optional = proto.Int64(64)
+	pb.F_Fixed32Optional = proto.Uint32(3232)
+	pb.F_Fixed64Optional = proto.Uint64(6464)
+	pb.F_Uint32Optional = proto.Uint32(323232)
+	pb.F_Uint64Optional = proto.Uint64(646464)
+	pb.F_FloatOptional = proto.Float32(32.)
+	pb.F_DoubleOptional = proto.Float64(64.)
+	pb.F_StringOptional = proto.String("hello")
+	pb.F_BytesOptional = []byte("Bignose")
+	pb.F_Sint32Optional = proto.Int32(-32)
+	pb.F_Sint64Optional = proto.Int64(-64)
+	pb.F_Sfixed32Optional = proto.Int32(-32)
+	pb.F_Sfixed64Optional = proto.Int64(-64)
+	pb.Optionalgroup = initGoTest_OptionalGroup()
+
+	overify(t, pb,
+		protopack.Message{
+			protopack.Tag{1, protopack.VarintType}, protopack.Uvarint(7),
+			protopack.Tag{2, protopack.BytesType}, protopack.String("hello"),
+			protopack.Tag{3, protopack.VarintType}, protopack.Varint(7),
+			protopack.Tag{4, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.BytesType}, protopack.String("label"),
+				protopack.Tag{2, protopack.BytesType}, protopack.String("type"),
+			}),
+			protopack.Tag{6, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.BytesType}, protopack.String("label"),
+				protopack.Tag{2, protopack.BytesType}, protopack.String("type"),
+			}),
+			protopack.Tag{10, protopack.VarintType}, protopack.Bool(true),
+			protopack.Tag{11, protopack.VarintType}, protopack.Varint(3),
+			protopack.Tag{12, protopack.VarintType}, protopack.Varint(6),
+			protopack.Tag{13, protopack.Fixed32Type}, protopack.Uint32(32),
+			protopack.Tag{14, protopack.Fixed64Type}, protopack.Uint64(64),
+			protopack.Tag{15, protopack.VarintType}, protopack.Uvarint(3232),
+			protopack.Tag{16, protopack.VarintType}, protopack.Uvarint(6464),
+			protopack.Tag{17, protopack.Fixed32Type}, protopack.Float32(3232),
+			protopack.Tag{18, protopack.Fixed64Type}, protopack.Float64(6464),
+			protopack.Tag{19, protopack.BytesType}, protopack.String("string"),
+			protopack.Tag{30, protopack.VarintType}, protopack.Bool(true),
+			protopack.Tag{31, protopack.VarintType}, protopack.Varint(32),
+			protopack.Tag{32, protopack.VarintType}, protopack.Varint(64),
+			protopack.Tag{33, protopack.Fixed32Type}, protopack.Uint32(3232),
+			protopack.Tag{34, protopack.Fixed64Type}, protopack.Uint64(6464),
+			protopack.Tag{35, protopack.VarintType}, protopack.Uvarint(323232),
+			protopack.Tag{36, protopack.VarintType}, protopack.Uvarint(646464),
+			protopack.Tag{37, protopack.Fixed32Type}, protopack.Float32(32),
+			protopack.Tag{38, protopack.Fixed64Type}, protopack.Float64(64),
+			protopack.Tag{39, protopack.BytesType}, protopack.String("hello"),
+			protopack.Tag{40, protopack.VarintType}, protopack.Bool(true),
+			protopack.Tag{41, protopack.VarintType}, protopack.Varint(32),
+			protopack.Tag{42, protopack.VarintType}, protopack.Varint(64),
+			protopack.Tag{43, protopack.Fixed32Type}, protopack.Uint32(320),
+			protopack.Tag{44, protopack.Fixed64Type}, protopack.Uint64(640),
+			protopack.Tag{45, protopack.VarintType}, protopack.Uvarint(3200),
+			protopack.Tag{46, protopack.VarintType}, protopack.Uvarint(6400),
+			protopack.Tag{47, protopack.Fixed32Type}, protopack.Float32(314159),
+			protopack.Tag{48, protopack.Fixed64Type}, protopack.Float64(271828),
+			protopack.Tag{49, protopack.BytesType}, protopack.String("hello, \"world!\"\n"),
+			protopack.Tag{70, protopack.StartGroupType},
+			protopack.Message{
+				protopack.Tag{71, protopack.BytesType}, protopack.String("required"),
+			},
+			protopack.Tag{70, protopack.EndGroupType},
+			protopack.Tag{90, protopack.StartGroupType},
+			protopack.Message{
+				protopack.Tag{91, protopack.BytesType}, protopack.String("optional"),
+			},
+			protopack.Tag{90, protopack.EndGroupType},
+			protopack.Tag{101, protopack.BytesType}, protopack.Bytes("bytes"),
+			protopack.Tag{102, protopack.VarintType}, protopack.Svarint(-32),
+			protopack.Tag{103, protopack.VarintType}, protopack.Svarint(-64),
+			protopack.Tag{104, protopack.Fixed32Type}, protopack.Int32(-32),
+			protopack.Tag{105, protopack.Fixed64Type}, protopack.Int64(-64),
+			protopack.Tag{301, protopack.BytesType}, protopack.Bytes("Bignose"),
+			protopack.Tag{302, protopack.VarintType}, protopack.Svarint(-32),
+			protopack.Tag{303, protopack.VarintType}, protopack.Svarint(-64),
+			protopack.Tag{304, protopack.Fixed32Type}, protopack.Int32(-32),
+			protopack.Tag{305, protopack.Fixed64Type}, protopack.Int64(-64),
+			protopack.Tag{401, protopack.BytesType}, protopack.Bytes("Bignose"),
+			protopack.Tag{402, protopack.VarintType}, protopack.Svarint(-32),
+			protopack.Tag{403, protopack.VarintType}, protopack.Svarint(-64),
+			protopack.Tag{404, protopack.Fixed32Type}, protopack.Int32(-32),
+			protopack.Tag{405, protopack.Fixed64Type}, protopack.Int64(-64),
+		}.Marshal())
+}
+
+// All required fields set, defaults provided, all repeated fields given two values.
+func TestEncodeDecode5(t *testing.T) {
+	pb := initGoTest(true)
+	pb.RepeatedField = []*pb2.GoTestField{initGoTestField(), initGoTestField()}
+	pb.F_BoolRepeated = []bool{false, true}
+	pb.F_Int32Repeated = []int32{32, 33}
+	pb.F_Int64Repeated = []int64{64, 65}
+	pb.F_Fixed32Repeated = []uint32{3232, 3333}
+	pb.F_Fixed64Repeated = []uint64{6464, 6565}
+	pb.F_Uint32Repeated = []uint32{323232, 333333}
+	pb.F_Uint64Repeated = []uint64{646464, 656565}
+	pb.F_FloatRepeated = []float32{32., 33.}
+	pb.F_DoubleRepeated = []float64{64., 65.}
+	pb.F_StringRepeated = []string{"hello", "sailor"}
+	pb.F_BytesRepeated = [][]byte{[]byte("big"), []byte("nose")}
+	pb.F_Sint32Repeated = []int32{32, -32}
+	pb.F_Sint64Repeated = []int64{64, -64}
+	pb.F_Sfixed32Repeated = []int32{32, -32}
+	pb.F_Sfixed64Repeated = []int64{64, -64}
+	pb.Repeatedgroup = []*pb2.GoTest_RepeatedGroup{initGoTest_RepeatedGroup(), initGoTest_RepeatedGroup()}
+
+	overify(t, pb,
+		protopack.Message{
+			protopack.Tag{1, protopack.VarintType}, protopack.Uvarint(7),
+			protopack.Tag{4, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.BytesType}, protopack.String("label"),
+				protopack.Tag{2, protopack.BytesType}, protopack.String("type"),
+			}),
+			protopack.Tag{5, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.BytesType}, protopack.String("label"),
+				protopack.Tag{2, protopack.BytesType}, protopack.String("type"),
+			}),
+			protopack.Tag{5, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.BytesType}, protopack.String("label"),
+				protopack.Tag{2, protopack.BytesType}, protopack.String("type"),
+			}),
+			protopack.Tag{10, protopack.VarintType}, protopack.Bool(true),
+			protopack.Tag{11, protopack.VarintType}, protopack.Varint(3),
+			protopack.Tag{12, protopack.VarintType}, protopack.Varint(6),
+			protopack.Tag{13, protopack.Fixed32Type}, protopack.Uint32(32),
+			protopack.Tag{14, protopack.Fixed64Type}, protopack.Uint64(64),
+			protopack.Tag{15, protopack.VarintType}, protopack.Uvarint(3232),
+			protopack.Tag{16, protopack.VarintType}, protopack.Uvarint(6464),
+			protopack.Tag{17, protopack.Fixed32Type}, protopack.Float32(3232),
+			protopack.Tag{18, protopack.Fixed64Type}, protopack.Float64(6464),
+			protopack.Tag{19, protopack.BytesType}, protopack.String("string"),
+			protopack.Tag{20, protopack.VarintType}, protopack.Bool(false),
+			protopack.Tag{20, protopack.VarintType}, protopack.Bool(true),
+			protopack.Tag{21, protopack.VarintType}, protopack.Varint(32),
+			protopack.Tag{21, protopack.VarintType}, protopack.Varint(33),
+			protopack.Tag{22, protopack.VarintType}, protopack.Varint(64),
+			protopack.Tag{22, protopack.VarintType}, protopack.Varint(65),
+			protopack.Tag{23, protopack.Fixed32Type}, protopack.Uint32(3232),
+			protopack.Tag{23, protopack.Fixed32Type}, protopack.Uint32(3333),
+			protopack.Tag{24, protopack.Fixed64Type}, protopack.Uint64(6464),
+			protopack.Tag{24, protopack.Fixed64Type}, protopack.Uint64(6565),
+			protopack.Tag{25, protopack.VarintType}, protopack.Uvarint(323232),
+			protopack.Tag{25, protopack.VarintType}, protopack.Uvarint(333333),
+			protopack.Tag{26, protopack.VarintType}, protopack.Uvarint(646464),
+			protopack.Tag{26, protopack.VarintType}, protopack.Uvarint(656565),
+			protopack.Tag{27, protopack.Fixed32Type}, protopack.Float32(32),
+			protopack.Tag{27, protopack.Fixed32Type}, protopack.Float32(33),
+			protopack.Tag{28, protopack.Fixed64Type}, protopack.Float64(64),
+			protopack.Tag{28, protopack.Fixed64Type}, protopack.Float64(65),
+			protopack.Tag{29, protopack.BytesType}, protopack.String("hello"),
+			protopack.Tag{29, protopack.BytesType}, protopack.String("sailor"),
+			protopack.Tag{40, protopack.VarintType}, protopack.Bool(true),
+			protopack.Tag{41, protopack.VarintType}, protopack.Varint(32),
+			protopack.Tag{42, protopack.VarintType}, protopack.Varint(64),
+			protopack.Tag{43, protopack.Fixed32Type}, protopack.Uint32(320),
+			protopack.Tag{44, protopack.Fixed64Type}, protopack.Uint64(640),
+			protopack.Tag{45, protopack.VarintType}, protopack.Uvarint(3200),
+			protopack.Tag{46, protopack.VarintType}, protopack.Uvarint(6400),
+			protopack.Tag{47, protopack.Fixed32Type}, protopack.Float32(314159),
+			protopack.Tag{48, protopack.Fixed64Type}, protopack.Float64(271828),
+			protopack.Tag{49, protopack.BytesType}, protopack.String("hello, \"world!\"\n"),
+			protopack.Tag{70, protopack.StartGroupType},
+			protopack.Message{
+				protopack.Tag{71, protopack.BytesType}, protopack.String("required"),
+			},
+			protopack.Tag{70, protopack.EndGroupType},
+			protopack.Tag{80, protopack.StartGroupType},
+			protopack.Message{
+				protopack.Tag{81, protopack.BytesType}, protopack.String("repeated"),
+			},
+			protopack.Tag{80, protopack.EndGroupType},
+			protopack.Tag{80, protopack.StartGroupType},
+			protopack.Message{
+				protopack.Tag{81, protopack.BytesType}, protopack.String("repeated"),
+			},
+			protopack.Tag{80, protopack.EndGroupType},
+			protopack.Tag{101, protopack.BytesType}, protopack.Bytes("bytes"),
+			protopack.Tag{102, protopack.VarintType}, protopack.Svarint(-32),
+			protopack.Tag{103, protopack.VarintType}, protopack.Svarint(-64),
+			protopack.Tag{104, protopack.Fixed32Type}, protopack.Int32(-32),
+			protopack.Tag{105, protopack.Fixed64Type}, protopack.Int64(-64),
+			protopack.Tag{201, protopack.BytesType}, protopack.Bytes("big"),
+			protopack.Tag{201, protopack.BytesType}, protopack.Bytes("nose"),
+			protopack.Tag{202, protopack.VarintType}, protopack.Svarint(32),
+			protopack.Tag{202, protopack.VarintType}, protopack.Svarint(-32),
+			protopack.Tag{203, protopack.VarintType}, protopack.Svarint(64),
+			protopack.Tag{203, protopack.VarintType}, protopack.Svarint(-64),
+			protopack.Tag{204, protopack.Fixed32Type}, protopack.Int32(32),
+			protopack.Tag{204, protopack.Fixed32Type}, protopack.Int32(-32),
+			protopack.Tag{205, protopack.Fixed64Type}, protopack.Int64(64),
+			protopack.Tag{205, protopack.Fixed64Type}, protopack.Int64(-64),
+			protopack.Tag{401, protopack.BytesType}, protopack.Bytes("Bignose"),
+			protopack.Tag{402, protopack.VarintType}, protopack.Svarint(-32),
+			protopack.Tag{403, protopack.VarintType}, protopack.Svarint(-64),
+			protopack.Tag{404, protopack.Fixed32Type}, protopack.Int32(-32),
+			protopack.Tag{405, protopack.Fixed64Type}, protopack.Int64(-64),
+		}.Marshal())
+}
+
+// All required fields set, all packed repeated fields given two values.
+func TestEncodeDecode6(t *testing.T) {
+	pb := initGoTest(false)
+	pb.F_BoolRepeatedPacked = []bool{false, true}
+	pb.F_Int32RepeatedPacked = []int32{32, 33}
+	pb.F_Int64RepeatedPacked = []int64{64, 65}
+	pb.F_Fixed32RepeatedPacked = []uint32{3232, 3333}
+	pb.F_Fixed64RepeatedPacked = []uint64{6464, 6565}
+	pb.F_Uint32RepeatedPacked = []uint32{323232, 333333}
+	pb.F_Uint64RepeatedPacked = []uint64{646464, 656565}
+	pb.F_FloatRepeatedPacked = []float32{32., 33.}
+	pb.F_DoubleRepeatedPacked = []float64{64., 65.}
+	pb.F_Sint32RepeatedPacked = []int32{32, -32}
+	pb.F_Sint64RepeatedPacked = []int64{64, -64}
+	pb.F_Sfixed32RepeatedPacked = []int32{32, -32}
+	pb.F_Sfixed64RepeatedPacked = []int64{64, -64}
+
+	overify(t, pb,
+		protopack.Message{
+			protopack.Tag{1, protopack.VarintType}, protopack.Uvarint(7),
+			protopack.Tag{4, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.BytesType}, protopack.String("label"),
+				protopack.Tag{2, protopack.BytesType}, protopack.String("type"),
+			}),
+			protopack.Tag{10, protopack.VarintType}, protopack.Bool(true),
+			protopack.Tag{11, protopack.VarintType}, protopack.Varint(3),
+			protopack.Tag{12, protopack.VarintType}, protopack.Varint(6),
+			protopack.Tag{13, protopack.Fixed32Type}, protopack.Uint32(32),
+			protopack.Tag{14, protopack.Fixed64Type}, protopack.Uint64(64),
+			protopack.Tag{15, protopack.VarintType}, protopack.Uvarint(3232),
+			protopack.Tag{16, protopack.VarintType}, protopack.Uvarint(6464),
+			protopack.Tag{17, protopack.Fixed32Type}, protopack.Float32(3232),
+			protopack.Tag{18, protopack.Fixed64Type}, protopack.Float64(6464),
+			protopack.Tag{19, protopack.BytesType}, protopack.String("string"),
+			protopack.Tag{50, protopack.BytesType}, protopack.LengthPrefix{protopack.Bool(false), protopack.Bool(true)},
+			protopack.Tag{51, protopack.BytesType}, protopack.LengthPrefix{protopack.Varint(32), protopack.Varint(33)},
+			protopack.Tag{52, protopack.BytesType}, protopack.LengthPrefix{protopack.Varint(64), protopack.Varint(65)},
+			protopack.Tag{53, protopack.BytesType}, protopack.LengthPrefix{protopack.Uint32(3232), protopack.Uint32(3333)},
+			protopack.Tag{54, protopack.BytesType}, protopack.LengthPrefix{protopack.Uint64(6464), protopack.Uint64(6565)},
+			protopack.Tag{55, protopack.BytesType}, protopack.LengthPrefix{protopack.Uvarint(323232), protopack.Uvarint(333333)},
+			protopack.Tag{56, protopack.BytesType}, protopack.LengthPrefix{protopack.Uvarint(646464), protopack.Uvarint(656565)},
+			protopack.Tag{57, protopack.BytesType}, protopack.LengthPrefix{protopack.Float32(32), protopack.Float32(33)},
+			protopack.Tag{58, protopack.BytesType}, protopack.LengthPrefix{protopack.Float64(64), protopack.Float64(65)},
+			protopack.Tag{70, protopack.StartGroupType},
+			protopack.Message{
+				protopack.Tag{71, protopack.BytesType}, protopack.String("required"),
+			},
+			protopack.Tag{70, protopack.EndGroupType},
+			protopack.Tag{101, protopack.BytesType}, protopack.Bytes("bytes"),
+			protopack.Tag{102, protopack.VarintType}, protopack.Svarint(-32),
+			protopack.Tag{103, protopack.VarintType}, protopack.Svarint(-64),
+			protopack.Tag{104, protopack.Fixed32Type}, protopack.Int32(-32),
+			protopack.Tag{105, protopack.Fixed64Type}, protopack.Int64(-64),
+			protopack.Tag{502, protopack.BytesType}, protopack.LengthPrefix{protopack.Svarint(32), protopack.Svarint(-32)},
+			protopack.Tag{503, protopack.BytesType}, protopack.LengthPrefix{protopack.Svarint(64), protopack.Svarint(-64)},
+			protopack.Tag{504, protopack.BytesType}, protopack.LengthPrefix{protopack.Int32(32), protopack.Int32(-32)},
+			protopack.Tag{505, protopack.BytesType}, protopack.LengthPrefix{protopack.Int64(64), protopack.Int64(-64)},
+		}.Marshal())
+}
+
+// Test that we can encode empty bytes fields.
+func TestEncodeDecodeBytes1(t *testing.T) {
+	pb := initGoTest(false)
+
+	// Create our bytes
+	pb.F_BytesRequired = []byte{}
+	pb.F_BytesRepeated = [][]byte{{}}
+	pb.F_BytesOptional = []byte{}
+
+	d, err := proto.Marshal(pb)
+	if err != nil {
+		t.Error(err)
+	}
+
+	pbd := new(pb2.GoTest)
+	if err := proto.Unmarshal(d, pbd); err != nil {
+		t.Error(err)
+	}
+
+	if pbd.F_BytesRequired == nil || len(pbd.F_BytesRequired) != 0 {
+		t.Error("required empty bytes field is incorrect")
+	}
+	if pbd.F_BytesRepeated == nil || len(pbd.F_BytesRepeated) == 1 && pbd.F_BytesRepeated[0] == nil {
+		t.Error("repeated empty bytes field is incorrect")
+	}
+	if pbd.F_BytesOptional == nil || len(pbd.F_BytesOptional) != 0 {
+		t.Error("optional empty bytes field is incorrect")
+	}
+}
+
+// Test that we encode nil-valued fields of a repeated bytes field correctly.
+// Since entries in a repeated field cannot be nil, nil must mean empty value.
+func TestEncodeDecodeBytes2(t *testing.T) {
+	pb := initGoTest(false)
+
+	// Create our bytes
+	pb.F_BytesRepeated = [][]byte{nil}
+
+	d, err := proto.Marshal(pb)
+	if err != nil {
+		t.Error(err)
+	}
+
+	pbd := new(pb2.GoTest)
+	if err := proto.Unmarshal(d, pbd); err != nil {
+		t.Error(err)
+	}
+
+	if len(pbd.F_BytesRepeated) != 1 || pbd.F_BytesRepeated[0] == nil {
+		t.Error("Unexpected value for repeated bytes field")
+	}
+}
+
+// All required fields set, defaults provided, all repeated fields given two values.
+func TestSkippingUnrecognizedFields(t *testing.T) {
+	o := new(proto.Buffer)
+	pb := initGoTestField()
+
+	// Marshal it normally.
+	o.Marshal(pb)
+
+	// Now new a GoSkipTest record.
+	skip := &pb2.GoSkipTest{
+		SkipInt32:   proto.Int32(32),
+		SkipFixed32: proto.Uint32(3232),
+		SkipFixed64: proto.Uint64(6464),
+		SkipString:  proto.String("skipper"),
+		Skipgroup: &pb2.GoSkipTest_SkipGroup{
+			GroupInt32:  proto.Int32(75),
+			GroupString: proto.String("wxyz"),
+		},
+	}
+
+	// Marshal it into same buffer.
+	o.Marshal(skip)
+
+	pbd := new(pb2.GoTestField)
+	o.Unmarshal(pbd)
+
+	// The __unrecognized field should be a marshaling of GoSkipTest
+	skipd := new(pb2.GoSkipTest)
+
+	o.SetBuf(pbd.XXX_unrecognized)
+	o.Unmarshal(skipd)
+
+	switch {
+	case *skipd.SkipInt32 != *skip.SkipInt32:
+		t.Error("skip int32", skipd.SkipInt32)
+	case *skipd.SkipFixed32 != *skip.SkipFixed32:
+		t.Error("skip fixed32", skipd.SkipFixed32)
+	case *skipd.SkipFixed64 != *skip.SkipFixed64:
+		t.Error("skip fixed64", skipd.SkipFixed64)
+	case *skipd.SkipString != *skip.SkipString:
+		t.Error("skip string", *skipd.SkipString)
+	case *skipd.Skipgroup.GroupInt32 != *skip.Skipgroup.GroupInt32:
+		t.Error("skip group int32", skipd.Skipgroup.GroupInt32)
+	case *skipd.Skipgroup.GroupString != *skip.Skipgroup.GroupString:
+		t.Error("skip group string", *skipd.Skipgroup.GroupString)
+	}
+}
+
+// Check that unrecognized fields of a submessage are preserved.
+func TestSubmessageUnrecognizedFields(t *testing.T) {
+	nm := &pb2.NewMessage{
+		Nested: &pb2.NewMessage_Nested{
+			Name:      proto.String("Nigel"),
+			FoodGroup: proto.String("carbs"),
+		},
+	}
+	b, err := proto.Marshal(nm)
+	if err != nil {
+		t.Fatalf("Marshal of NewMessage: %v", err)
+	}
+
+	// Unmarshal into an OldMessage.
+	om := new(pb2.OldMessage)
+	if err := proto.Unmarshal(b, om); err != nil {
+		t.Fatalf("Unmarshal to OldMessage: %v", err)
+	}
+	exp := &pb2.OldMessage{
+		Nested: &pb2.OldMessage_Nested{
+			Name: proto.String("Nigel"),
+			// normal protocol buffer users should not do this
+			XXX_unrecognized: []byte("\x12\x05carbs"),
+		},
+	}
+	if !proto.Equal(om, exp) {
+		t.Errorf("om = %v, want %v", om, exp)
+	}
+
+	// Clone the OldMessage.
+	om = proto.Clone(om).(*pb2.OldMessage)
+	if !proto.Equal(om, exp) {
+		t.Errorf("Clone(om) = %v, want %v", om, exp)
+	}
+
+	// Marshal the OldMessage, then unmarshal it into an empty NewMessage.
+	if b, err = proto.Marshal(om); err != nil {
+		t.Fatalf("Marshal of OldMessage: %v", err)
+	}
+	t.Logf("Marshal(%v) -> %q", om, b)
+	nm2 := new(pb2.NewMessage)
+	if err := proto.Unmarshal(b, nm2); err != nil {
+		t.Fatalf("Unmarshal to NewMessage: %v", err)
+	}
+	if !proto.Equal(nm, nm2) {
+		t.Errorf("NewMessage round-trip: %v => %v", nm, nm2)
+	}
+}
+
+// Check that an int32 field can be upgraded to an int64 field.
+func TestNegativeInt32(t *testing.T) {
+	om := &pb2.OldMessage{
+		Num: proto.Int32(-1),
+	}
+	b, err := proto.Marshal(om)
+	if err != nil {
+		t.Fatalf("Marshal of OldMessage: %v", err)
+	}
+
+	// Check the size. It should be 11 bytes;
+	// 1 for the field/wire type, and 10 for the negative number.
+	if len(b) != 11 {
+		t.Errorf("%v marshaled as %q, wanted 11 bytes", om, b)
+	}
+
+	// Unmarshal into a NewMessage.
+	nm := new(pb2.NewMessage)
+	if err := proto.Unmarshal(b, nm); err != nil {
+		t.Fatalf("Unmarshal to NewMessage: %v", err)
+	}
+	want := &pb2.NewMessage{
+		Num: proto.Int64(-1),
+	}
+	if !proto.Equal(nm, want) {
+		t.Errorf("nm = %v, want %v", nm, want)
+	}
+}
+
+// Check that we can grow an array (repeated field) to have many elements.
+// This test doesn't depend only on our encoding; for variety, it makes sure
+// we create, encode, and decode the correct contents explicitly.  It's therefore
+// a bit messier.
+// This test also uses (and hence tests) the Marshal/Unmarshal functions
+// instead of the methods.
+func TestBigRepeated(t *testing.T) {
+	pb := initGoTest(true)
+
+	// Create the arrays
+	const N = 50 // Internally the library starts much smaller.
+	pb.Repeatedgroup = make([]*pb2.GoTest_RepeatedGroup, N)
+	pb.F_Sint64Repeated = make([]int64, N)
+	pb.F_Sint32Repeated = make([]int32, N)
+	pb.F_BytesRepeated = make([][]byte, N)
+	pb.F_StringRepeated = make([]string, N)
+	pb.F_DoubleRepeated = make([]float64, N)
+	pb.F_FloatRepeated = make([]float32, N)
+	pb.F_Uint64Repeated = make([]uint64, N)
+	pb.F_Uint32Repeated = make([]uint32, N)
+	pb.F_Fixed64Repeated = make([]uint64, N)
+	pb.F_Fixed32Repeated = make([]uint32, N)
+	pb.F_Int64Repeated = make([]int64, N)
+	pb.F_Int32Repeated = make([]int32, N)
+	pb.F_BoolRepeated = make([]bool, N)
+	pb.RepeatedField = make([]*pb2.GoTestField, N)
+
+	// Fill in the arrays with checkable values.
+	igtf := initGoTestField()
+	igtrg := initGoTest_RepeatedGroup()
+	for i := 0; i < N; i++ {
+		pb.Repeatedgroup[i] = igtrg
+		pb.F_Sint64Repeated[i] = int64(i)
+		pb.F_Sint32Repeated[i] = int32(i)
+		s := fmt.Sprint(i)
+		pb.F_BytesRepeated[i] = []byte(s)
+		pb.F_StringRepeated[i] = s
+		pb.F_DoubleRepeated[i] = float64(i)
+		pb.F_FloatRepeated[i] = float32(i)
+		pb.F_Uint64Repeated[i] = uint64(i)
+		pb.F_Uint32Repeated[i] = uint32(i)
+		pb.F_Fixed64Repeated[i] = uint64(i)
+		pb.F_Fixed32Repeated[i] = uint32(i)
+		pb.F_Int64Repeated[i] = int64(i)
+		pb.F_Int32Repeated[i] = int32(i)
+		pb.F_BoolRepeated[i] = i%2 == 0
+		pb.RepeatedField[i] = igtf
+	}
+
+	// Marshal.
+	buf, _ := proto.Marshal(pb)
+
+	// Now test Unmarshal by recreating the original buffer.
+	pbd := new(pb2.GoTest)
+	proto.Unmarshal(buf, pbd)
+
+	// Check the checkable values
+	for i := uint64(0); i < N; i++ {
+		switch {
+		case pbd.Repeatedgroup[i] == nil:
+			t.Error("pbd.Repeatedgroup bad")
+		case uint64(pbd.F_Sint64Repeated[i]) != i:
+			t.Error("pbd.F_Sint64Repeated bad", uint64(pbd.F_Sint64Repeated[i]), i)
+		case uint64(pbd.F_Sint32Repeated[i]) != i:
+			t.Error("pbd.F_Sint32Repeated bad", uint64(pbd.F_Sint32Repeated[i]), i)
+		case !bytes.Equal(pbd.F_BytesRepeated[i], []byte(fmt.Sprint(i))):
+			t.Error("pbd.F_BytesRepeated bad", pbd.F_BytesRepeated[i], i)
+		case pbd.F_StringRepeated[i] != string(fmt.Sprint(i)):
+			t.Error("pbd.F_Sint32Repeated bad", pbd.F_StringRepeated[i], i)
+		case uint64(pbd.F_DoubleRepeated[i]) != i:
+			t.Error("pbd.F_DoubleRepeated bad", uint64(pbd.F_DoubleRepeated[i]), i)
+		case uint64(pbd.F_FloatRepeated[i]) != i:
+			t.Error("pbd.F_FloatRepeated bad", uint64(pbd.F_FloatRepeated[i]), i)
+		case pbd.F_Uint64Repeated[i] != i:
+			t.Error("pbd.F_Uint64Repeated bad", pbd.F_Uint64Repeated[i], i)
+		case uint64(pbd.F_Uint32Repeated[i]) != i:
+			t.Error("pbd.F_Uint32Repeated bad", uint64(pbd.F_Uint32Repeated[i]), i)
+		case pbd.F_Fixed64Repeated[i] != i:
+			t.Error("pbd.F_Fixed64Repeated bad", pbd.F_Fixed64Repeated[i], i)
+		case uint64(pbd.F_Fixed32Repeated[i]) != i:
+			t.Error("pbd.F_Fixed32Repeated bad", uint64(pbd.F_Fixed32Repeated[i]), i)
+		case uint64(pbd.F_Int64Repeated[i]) != i:
+			t.Error("pbd.F_Int64Repeated bad", uint64(pbd.F_Int64Repeated[i]), i)
+		case uint64(pbd.F_Int32Repeated[i]) != i:
+			t.Error("pbd.F_Int32Repeated bad", uint64(pbd.F_Int32Repeated[i]), i)
+		case pbd.F_BoolRepeated[i] != (i%2 == 0):
+			t.Error("pbd.F_BoolRepeated bad", pbd.F_BoolRepeated[i], i)
+		case pbd.RepeatedField[i] == nil:
+			t.Error("pbd.RepeatedField bad")
+		}
+	}
+}
+
+func TestBadWireTypeUnknown(t *testing.T) {
+	b := protopack.Message{
+		protopack.Tag{1, protopack.BytesType}, protopack.Bytes("x"),
+		protopack.Tag{1, protopack.Fixed32Type}, protopack.Uint32(0),
+		protopack.Tag{1, protopack.VarintType}, protopack.Varint(11),
+		protopack.Tag{2, protopack.VarintType}, protopack.Uvarint(22),
+		protopack.Tag{2, protopack.BytesType}, protopack.String("aaa"),
+		protopack.Tag{2, protopack.Fixed32Type}, protopack.Uint32(33),
+		protopack.Tag{4, protopack.VarintType}, protopack.Uvarint(44),
+		protopack.Tag{4, protopack.BytesType}, protopack.String("bbb"),
+		protopack.Tag{4, protopack.Fixed32Type}, protopack.Uint32(55),
+		protopack.Tag{4, protopack.BytesType}, protopack.String("ccc"),
+		protopack.Tag{4, protopack.Fixed64Type}, protopack.Uint64(66),
+		protopack.Tag{11, protopack.VarintType}, protopack.Uvarint(77),
+		protopack.Tag{11, protopack.BytesType}, protopack.Bytes("ddd"),
+		protopack.Tag{11, protopack.Fixed64Type}, protopack.Float64(88),
+		protopack.Tag{11, protopack.Fixed32Type}, protopack.Uint32(99),
+	}.Marshal()
+
+	m := new(pb2.MyMessage)
+	if err := proto.Unmarshal(b, m); err != nil {
+		t.Errorf("unexpected Unmarshal error: %v", err)
+	}
+
+	unknown := protopack.Message{
+		protopack.Tag{1, protopack.BytesType}, protopack.Bytes("x"),
+		protopack.Tag{1, protopack.Fixed32Type}, protopack.Uint32(0),
+		protopack.Tag{2, protopack.VarintType}, protopack.Uvarint(22),
+		protopack.Tag{2, protopack.Fixed32Type}, protopack.Uint32(33),
+		protopack.Tag{4, protopack.VarintType}, protopack.Uvarint(44),
+		protopack.Tag{4, protopack.Fixed32Type}, protopack.Uint32(55),
+		protopack.Tag{4, protopack.Fixed64Type}, protopack.Uint64(66),
+		protopack.Tag{11, protopack.VarintType}, protopack.Uvarint(77),
+		protopack.Tag{11, protopack.BytesType}, protopack.Bytes("ddd"),
+		protopack.Tag{11, protopack.Fixed32Type}, protopack.Uint32(99),
+	}.Marshal()
+	if !bytes.Equal(m.XXX_unrecognized, unknown) {
+		t.Errorf("unknown bytes mismatch:\ngot  %x\nwant %x", m.XXX_unrecognized, unknown)
+	}
+	proto.DiscardUnknown(m)
+
+	want := &pb2.MyMessage{Count: proto.Int32(11), Name: proto.String("aaa"), Pet: []string{"bbb", "ccc"}, Bigfloat: proto.Float64(88)}
+	if !proto.Equal(m, want) {
+		t.Errorf("message mismatch:\ngot  %v\nwant %v", m, want)
+	}
+}
+
+func encodeDecode(t *testing.T, in, out proto.Message, msg string) {
+	buf, err := proto.Marshal(in)
+	if err != nil {
+		t.Fatalf("failed marshaling %v: %v", msg, err)
+	}
+	if err := proto.Unmarshal(buf, out); err != nil {
+		t.Fatalf("failed unmarshaling %v: %v", msg, err)
+	}
+}
+
+func TestPackedNonPackedDecoderSwitching(t *testing.T) {
+	np, p := new(pb2.NonPackedTest), new(pb2.PackedTest)
+
+	// non-packed -> packed
+	np.A = []int32{0, 1, 1, 2, 3, 5}
+	encodeDecode(t, np, p, "non-packed -> packed")
+	if !reflect.DeepEqual(np.A, p.B) {
+		t.Errorf("failed non-packed -> packed; np.A=%+v, p.B=%+v", np.A, p.B)
+	}
+
+	// packed -> non-packed
+	np.Reset()
+	p.B = []int32{3, 1, 4, 1, 5, 9}
+	encodeDecode(t, p, np, "packed -> non-packed")
+	if !reflect.DeepEqual(p.B, np.A) {
+		t.Errorf("failed packed -> non-packed; p.B=%+v, np.A=%+v", p.B, np.A)
+	}
+}
+
+func TestProto1RepeatedGroup(t *testing.T) {
+	pb := &pb2.MessageList{
+		Message: []*pb2.MessageList_Message{
+			{
+				Name:  proto.String("blah"),
+				Count: proto.Int32(7),
+			},
+			// NOTE: pb.Message[1] is a nil
+			nil,
+		},
+	}
+
+	o := new(proto.Buffer)
+	err := o.Marshal(pb)
+	if err == nil {
+		t.Fatalf("expected error when marshaling repeted nil MessageList.Message")
+	}
+	if _, ok := err.(*proto.RequiredNotSetError); !ok {
+		t.Fatalf("unexpected error when marshaling: %v", err)
+	}
+}
+
+// Test that enums work.  Checks for a bug introduced by making enums
+// named types instead of int32: newInt32FromUint64 would crash with
+// a type mismatch in reflect.PointTo.
+func TestEnum(t *testing.T) {
+	pb := new(pb2.GoEnum)
+	pb.Foo = pb2.FOO_FOO1.Enum()
+	o := new(proto.Buffer)
+	if err := o.Marshal(pb); err != nil {
+		t.Fatal("error encoding enum:", err)
+	}
+	pb1 := new(pb2.GoEnum)
+	if err := o.Unmarshal(pb1); err != nil {
+		t.Fatal("error decoding enum:", err)
+	}
+	if *pb1.Foo != pb2.FOO_FOO1 {
+		t.Error("expected 7 but got ", *pb1.Foo)
+	}
+}
+
+// Enum types have String methods. Check that enum fields can be printed.
+// We don't care what the value actually is, just as long as it doesn't crash.
+func TestPrintingNilEnumFields(t *testing.T) {
+	pb := new(pb2.GoEnum)
+	_ = fmt.Sprintf("%+v", pb)
+}
+
+// Verify that absent required fields cause Marshal/Unmarshal to return errors.
+func TestRequiredFieldEnforcement(t *testing.T) {
+	pb := new(pb2.GoTestField)
+	_, err := proto.Marshal(pb)
+	if err == nil {
+		t.Error("marshal: expected error, got nil")
+	} else if !isRequiredNotSetError(err) {
+		t.Errorf("marshal: bad error type: %v", err)
+	}
+
+	// A slightly sneaky, yet valid, proto. It encodes the same required field twice,
+	// so simply counting the required fields is insufficient.
+	// field 1, encoding 2, value "hi"
+	buf := []byte("\x0A\x02hi\x0A\x02hi")
+	err = proto.Unmarshal(buf, pb)
+	if err == nil {
+		t.Error("unmarshal: expected error, got nil")
+	} else if !isRequiredNotSetError(err) {
+		t.Errorf("unmarshal: bad error type: %v", err)
+	}
+}
+
+// Verify that absent required fields in groups cause Marshal/Unmarshal to return errors.
+func TestRequiredFieldEnforcementGroups(t *testing.T) {
+	pb := &pb2.GoTestRequiredGroupField{Group: &pb2.GoTestRequiredGroupField_Group{}}
+	if _, err := proto.Marshal(pb); err == nil {
+		t.Error("marshal: expected error, got nil")
+	} else if !isRequiredNotSetError(err) {
+		t.Errorf("marshal: bad error type: %v", err)
+	}
+
+	buf := []byte{11, 12}
+	if err := proto.Unmarshal(buf, pb); err == nil {
+		t.Error("unmarshal: expected error, got nil")
+	} else if !isRequiredNotSetError(err) {
+		t.Errorf("unmarshal: bad error type: %v", err)
+	}
+}
+
+func TestTypedNilMarshal(t *testing.T) {
+	// A typed nil should return ErrNil and not crash.
+	var m *pb2.GoEnum
+	if _, err := proto.Marshal(m); err != proto.ErrNil {
+		t.Errorf("Marshal(%#v): got %v, want ErrNil", m, err)
+	}
+}
+
+func TestTypedNilMarshalInOneof(t *testing.T) {
+	// It should not panic.
+	m := &pb2.Communique{Union: &pb2.Communique_Msg{nil}}
+	if _, err := proto.Marshal(m); err == proto.ErrNil {
+		t.Errorf("Marshal(%#v): got %v, want nil or errOneofHasNil", m, err)
+	}
+}
+
+// A type that implements the Marshaler interface, but is not nillable.
+type nonNillableInt uint64
+
+func (nni nonNillableInt) Marshal() ([]byte, error) {
+	return proto.EncodeVarint(uint64(nni)), nil
+}
+
+type NNIMessage struct {
+	nni nonNillableInt
+}
+
+func (*NNIMessage) Reset()         {}
+func (*NNIMessage) String() string { return "" }
+func (*NNIMessage) ProtoMessage()  {}
+
+type NMMessage struct{}
+
+func (*NMMessage) Reset()         {}
+func (*NMMessage) String() string { return "" }
+func (*NMMessage) ProtoMessage()  {}
+
+// Verify a type that uses the Marshaler interface, but has a nil pointer.
+func TestNilMarshaler(t *testing.T) {
+	// Try a struct with a Marshaler field that is nil.
+	// It should be directly marshable.
+	nmm := new(NMMessage)
+	if _, err := proto.Marshal(nmm); err != nil {
+		t.Error("unexpected error marshaling nmm: ", err)
+	}
+
+	// Try a struct with a Marshaler field that is not nillable.
+	nnim := new(NNIMessage)
+	nnim.nni = 7
+	var _ proto.Marshaler = nnim.nni // verify it is truly a Marshaler
+	if _, err := proto.Marshal(nnim); err != nil {
+		t.Error("unexpected error marshaling nnim: ", err)
+	}
+}
+
+func TestAllSetDefaults(t *testing.T) {
+	// Exercise SetDefaults with all scalar field types.
+	got := &pb2.Defaults{
+		// NaN != NaN, so override that here.
+		F_Nan: proto.Float32(1.7),
+	}
+	want := &pb2.Defaults{
+		F_Bool:    proto.Bool(true),
+		F_Int32:   proto.Int32(32),
+		F_Int64:   proto.Int64(64),
+		F_Fixed32: proto.Uint32(320),
+		F_Fixed64: proto.Uint64(640),
+		F_Uint32:  proto.Uint32(3200),
+		F_Uint64:  proto.Uint64(6400),
+		F_Float:   proto.Float32(314159),
+		F_Double:  proto.Float64(271828),
+		F_String:  proto.String(`hello, "world!"` + "\n"),
+		F_Bytes:   []byte("Bignose"),
+		F_Sint32:  proto.Int32(-32),
+		F_Sint64:  proto.Int64(-64),
+		F_Enum:    pb2.Defaults_GREEN.Enum(),
+		F_Pinf:    proto.Float32(float32(math.Inf(1))),
+		F_Ninf:    proto.Float32(float32(math.Inf(-1))),
+		F_Nan:     proto.Float32(1.7),
+		StrZero:   proto.String(""),
+	}
+	proto.SetDefaults(got)
+	if !proto.Equal(got, want) {
+		t.Errorf("SetDefaults failed\n got %v\nwant %v", got, want)
+	}
+}
+
+func TestSetDefaultsWithSetField(t *testing.T) {
+	// Check that a set value is not overridden.
+	m := &pb2.Defaults{
+		F_Int32: proto.Int32(12),
+	}
+	proto.SetDefaults(m)
+	if v := m.GetF_Int32(); v != 12 {
+		t.Errorf("m.FInt32 = %v, want 12", v)
+	}
+}
+
+func TestSetDefaultsWithSubMessage(t *testing.T) {
+	got := &pb2.OtherMessage{
+		Key: proto.Int64(123),
+		Inner: &pb2.InnerMessage{
+			Host: proto.String("gopher"),
+		},
+	}
+	want := &pb2.OtherMessage{
+		Key: proto.Int64(123),
+		Inner: &pb2.InnerMessage{
+			Host: proto.String("gopher"),
+			Port: proto.Int32(4000),
+		},
+	}
+	proto.SetDefaults(got)
+	if !proto.Equal(got, want) {
+		t.Errorf("\n got %v\nwant %v", got, want)
+	}
+}
+
+func TestSetDefaultsWithRepeatedSubMessage(t *testing.T) {
+	got := &pb2.MyMessage{
+		RepInner: []*pb2.InnerMessage{{}},
+	}
+	want := &pb2.MyMessage{
+		RepInner: []*pb2.InnerMessage{{
+			Port: proto.Int32(4000),
+		}},
+	}
+	proto.SetDefaults(got)
+	if !proto.Equal(got, want) {
+		t.Errorf("\n got %v\nwant %v", got, want)
+	}
+}
+
+func TestSetDefaultWithRepeatedNonMessage(t *testing.T) {
+	got := &pb2.MyMessage{
+		Pet: []string{"turtle", "wombat"},
+	}
+	want := proto.Clone(got)
+	proto.SetDefaults(got)
+	if !proto.Equal(got, want) {
+		t.Errorf("\n got %v\nwant %v", got, want)
+	}
+}
+
+func TestMaximumTagNumber(t *testing.T) {
+	m := &pb2.MaxTag{
+		LastField: proto.String("natural goat essence"),
+	}
+	buf, err := proto.Marshal(m)
+	if err != nil {
+		t.Fatalf("proto.Marshal failed: %v", err)
+	}
+	m2 := new(pb2.MaxTag)
+	if err := proto.Unmarshal(buf, m2); err != nil {
+		t.Fatalf("proto.Unmarshal failed: %v", err)
+	}
+	if got, want := m2.GetLastField(), *m.LastField; got != want {
+		t.Errorf("got %q, want %q", got, want)
+	}
+}
+
+func TestJSON(t *testing.T) {
+	m := &pb2.MyMessage{
+		Count: proto.Int32(4),
+		Pet:   []string{"bunny", "kitty"},
+		Inner: &pb2.InnerMessage{
+			Host: proto.String("cauchy"),
+		},
+		Bikeshed: pb2.MyMessage_GREEN.Enum(),
+	}
+	const want = `{"count":4,"pet":["bunny","kitty"],"inner":{"host":"cauchy"},"bikeshed":1}`
+
+	b, err := json.Marshal(m)
+	if err != nil {
+		t.Fatalf("json.Marshal failed: %v", err)
+	}
+	s := string(b)
+	if s != want {
+		t.Errorf("got  %s\nwant %s", s, want)
+	}
+
+	received := new(pb2.MyMessage)
+	if err := json.Unmarshal(b, received); err != nil {
+		t.Fatalf("json.Unmarshal failed: %v", err)
+	}
+	if !proto.Equal(received, m) {
+		t.Fatalf("got %s, want %s", received, m)
+	}
+
+	// Test unmarshaling of JSON with symbolic enum name.
+	const old = `{"count":4,"pet":["bunny","kitty"],"inner":{"host":"cauchy"},"bikeshed":"GREEN"}`
+	received.Reset()
+	if err := json.Unmarshal([]byte(old), received); err != nil {
+		t.Fatalf("json.Unmarshal failed: %v", err)
+	}
+	if !proto.Equal(received, m) {
+		t.Fatalf("got %s, want %s", received, m)
+	}
+}
+
+func TestBadWireType(t *testing.T) {
+	b := []byte{7<<3 | 6} // field 7, wire type 6
+	pb := new(pb2.OtherMessage)
+	if err := proto.Unmarshal(b, pb); err == nil {
+		t.Errorf("Unmarshal did not fail")
+	}
+}
+
+func TestBytesWithInvalidLength(t *testing.T) {
+	// If a byte sequence has an invalid (negative) length, Unmarshal should not panic.
+	b := protopack.Message{
+		protopack.Tag{2, protopack.BytesType}, protopack.Denormalized{+1, protopack.Uvarint(34359738367)},
+	}.Marshal()
+	proto.Unmarshal(b, new(pb2.MyMessage))
+}
+
+func TestLengthOverflow(t *testing.T) {
+	// Overflowing a length should not panic.
+	b := protopack.Message{
+		protopack.Tag{2, protopack.BytesType}, protopack.String("\x01"),
+		protopack.Tag{3, protopack.BytesType}, protopack.Uvarint(9223372036854775807),
+		protopack.Raw("\x01"),
+	}.Marshal()
+	proto.Unmarshal(b, new(pb2.MyMessage))
+}
+
+func TestVarintOverflow(t *testing.T) {
+	// Overflowing a 64-bit length should not be allowed.
+	b := protopack.Message{
+		protopack.Tag{1, protopack.VarintType}, protopack.Varint(1),
+		protopack.Tag{3, protopack.BytesType},
+		protopack.Raw("\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x01"),
+	}.Marshal()
+	if err := proto.Unmarshal(b, new(pb2.MyMessage)); err == nil {
+		t.Fatalf("Overflowed uint64 length without error")
+	}
+}
+
+func TestBytesWithInvalidLengthInGroup(t *testing.T) {
+	// Overflowing a 64-bit length should not be allowed.
+	b := protopack.Message{
+		protopack.Tag{775, protopack.StartGroupType},
+		protopack.Message{
+			protopack.Tag{774, protopack.BytesType}, protopack.Uvarint(13654841034505509168),
+			protopack.Raw(""),
+		},
+	}.Marshal()
+	if err := proto.Unmarshal(b, new(pb2.MyMessage)); err == nil {
+		t.Fatalf("Overflowed uint64 length without error")
+	}
+}
+
+func TestUnmarshalFuzz(t *testing.T) {
+	const N = 1000
+	seed := time.Now().UnixNano()
+	t.Logf("RNG seed is %d", seed)
+	rng := rand.New(rand.NewSource(seed))
+	buf := make([]byte, 20)
+	for i := 0; i < N; i++ {
+		for j := range buf {
+			buf[j] = byte(rng.Intn(256))
+		}
+		fuzzUnmarshal(t, buf)
+	}
+}
+
+func TestMergeMessages(t *testing.T) {
+	pb := &pb2.MessageList{Message: []*pb2.MessageList_Message{{Name: proto.String("x"), Count: proto.Int32(1)}}}
+	data, err := proto.Marshal(pb)
+	if err != nil {
+		t.Fatalf("Marshal: %v", err)
+	}
+
+	pb1 := new(pb2.MessageList)
+	if err := proto.Unmarshal(data, pb1); err != nil {
+		t.Fatalf("first Unmarshal: %v", err)
+	}
+	if err := proto.Unmarshal(data, pb1); err != nil {
+		t.Fatalf("second Unmarshal: %v", err)
+	}
+	if len(pb1.Message) != 1 {
+		t.Errorf("two Unmarshals produced %d Messages, want 1", len(pb1.Message))
+	}
+
+	pb2 := new(pb2.MessageList)
+	if err := proto.UnmarshalMerge(data, pb2); err != nil {
+		t.Fatalf("first UnmarshalMerge: %v", err)
+	}
+	if err := proto.UnmarshalMerge(data, pb2); err != nil {
+		t.Fatalf("second UnmarshalMerge: %v", err)
+	}
+	if len(pb2.Message) != 2 {
+		t.Errorf("two UnmarshalMerges produced %d Messages, want 2", len(pb2.Message))
+	}
+}
+
+func TestExtensionMarshalOrder(t *testing.T) {
+	m := &pb2.MyMessage{Count: proto.Int(123)}
+	if err := proto.SetExtension(m, pb2.E_Ext_More, &pb2.Ext{Data: proto.String("alpha")}); err != nil {
+		t.Fatalf("SetExtension: %v", err)
+	}
+	if err := proto.SetExtension(m, pb2.E_Ext_Text, proto.String("aleph")); err != nil {
+		t.Fatalf("SetExtension: %v", err)
+	}
+	if err := proto.SetExtension(m, pb2.E_Ext_Number, proto.Int32(1)); err != nil {
+		t.Fatalf("SetExtension: %v", err)
+	}
+
+	// Serialize m several times, and check we get the same bytes each time.
+	var orig []byte
+	for i := 0; i < 100; i++ {
+		b, err := proto.Marshal(m)
+		if err != nil {
+			t.Fatalf("Marshal: %v", err)
+		}
+		if i == 0 {
+			orig = b
+			continue
+		}
+		if !bytes.Equal(b, orig) {
+			t.Errorf("Bytes differ on attempt #%d", i)
+		}
+	}
+}
+
+func TestExtensionMapFieldMarshalDeterministic(t *testing.T) {
+	m := &pb2.MyMessage{Count: proto.Int(123)}
+	if err := proto.SetExtension(m, pb2.E_Ext_More, &pb2.Ext{MapField: map[int32]int32{1: 1, 2: 2, 3: 3, 4: 4}}); err != nil {
+		t.Fatalf("SetExtension: %v", err)
+	}
+	marshal := func(m proto.Message) []byte {
+		var b proto.Buffer
+		b.SetDeterministic(true)
+		if err := b.Marshal(m); err != nil {
+			t.Fatalf("Marshal failed: %v", err)
+		}
+		return b.Bytes()
+	}
+
+	want := marshal(m)
+	for i := 0; i < 100; i++ {
+		if got := marshal(m); !bytes.Equal(got, want) {
+			t.Errorf("Marshal produced inconsistent output with determinism enabled (pass %d).\n got %v\nwant %v", i, got, want)
+		}
+	}
+}
+
+func TestUnmarshalMergesMessages(t *testing.T) {
+	// If a nested message occurs twice in the input,
+	// the fields should be merged when decoding.
+	a := &pb2.OtherMessage{
+		Key: proto.Int64(123),
+		Inner: &pb2.InnerMessage{
+			Host: proto.String("polhode"),
+			Port: proto.Int32(1234),
+		},
+	}
+	aData, err := proto.Marshal(a)
+	if err != nil {
+		t.Fatalf("Marshal(a): %v", err)
+	}
+	b := &pb2.OtherMessage{
+		Weight: proto.Float32(1.2),
+		Inner: &pb2.InnerMessage{
+			Host:      proto.String("herpolhode"),
+			Connected: proto.Bool(true),
+		},
+	}
+	bData, err := proto.Marshal(b)
+	if err != nil {
+		t.Fatalf("Marshal(b): %v", err)
+	}
+	want := &pb2.OtherMessage{
+		Key:    proto.Int64(123),
+		Weight: proto.Float32(1.2),
+		Inner: &pb2.InnerMessage{
+			Host:      proto.String("herpolhode"),
+			Port:      proto.Int32(1234),
+			Connected: proto.Bool(true),
+		},
+	}
+	got := new(pb2.OtherMessage)
+	if err := proto.Unmarshal(append(aData, bData...), got); err != nil {
+		t.Fatalf("Unmarshal: %v", err)
+	}
+	if !proto.Equal(got, want) {
+		t.Errorf("\n got %v\nwant %v", got, want)
+	}
+}
+
+func TestUnmarshalMergesGroups(t *testing.T) {
+	// If a nested group occurs twice in the input,
+	// the fields should be merged when decoding.
+	a := &pb2.GroupNew{
+		G: &pb2.GroupNew_G{
+			X: proto.Int32(7),
+			Y: proto.Int32(8),
+		},
+	}
+	aData, err := proto.Marshal(a)
+	if err != nil {
+		t.Fatalf("Marshal(a): %v", err)
+	}
+	b := &pb2.GroupNew{
+		G: &pb2.GroupNew_G{
+			X: proto.Int32(9),
+		},
+	}
+	bData, err := proto.Marshal(b)
+	if err != nil {
+		t.Fatalf("Marshal(b): %v", err)
+	}
+	want := &pb2.GroupNew{
+		G: &pb2.GroupNew_G{
+			X: proto.Int32(9),
+			Y: proto.Int32(8),
+		},
+	}
+	got := new(pb2.GroupNew)
+	if err := proto.Unmarshal(append(aData, bData...), got); err != nil {
+		t.Fatalf("Unmarshal: %v", err)
+	}
+	if !proto.Equal(got, want) {
+		t.Errorf("\n got %v\nwant %v", got, want)
+	}
+}
+
+func TestEncodingSizes(t *testing.T) {
+	tests := []struct {
+		m proto.Message
+		n int
+	}{
+		{&pb2.Defaults{F_Int32: proto.Int32(math.MaxInt32)}, 6},
+		{&pb2.Defaults{F_Int32: proto.Int32(math.MinInt32)}, 11},
+		{&pb2.Defaults{F_Uint32: proto.Uint32(uint32(math.MaxInt32) + 1)}, 6},
+		{&pb2.Defaults{F_Uint32: proto.Uint32(math.MaxUint32)}, 6},
+	}
+	for _, test := range tests {
+		b, err := proto.Marshal(test.m)
+		if err != nil {
+			t.Errorf("Marshal(%v): %v", test.m, err)
+			continue
+		}
+		if len(b) != test.n {
+			t.Errorf("Marshal(%v) yielded %d bytes, want %d bytes", test.m, len(b), test.n)
+		}
+	}
+}
+
+func TestRequiredNotSetError(t *testing.T) {
+	pb := initGoTest(false)
+	pb.RequiredField.Label = nil
+	pb.F_Int32Required = nil
+	pb.F_Int64Required = nil
+
+	want := protopack.Message{
+		protopack.Tag{1, protopack.VarintType}, protopack.Uvarint(7),
+		protopack.Tag{4, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+			protopack.Tag{2, protopack.BytesType}, protopack.String("type"),
+		}),
+		protopack.Tag{10, protopack.VarintType}, protopack.Bool(true),
+		protopack.Tag{13, protopack.Fixed32Type}, protopack.Uint32(32),
+		protopack.Tag{14, protopack.Fixed64Type}, protopack.Uint64(64),
+		protopack.Tag{15, protopack.VarintType}, protopack.Uvarint(3232),
+		protopack.Tag{16, protopack.VarintType}, protopack.Uvarint(6464),
+		protopack.Tag{17, protopack.Fixed32Type}, protopack.Float32(3232),
+		protopack.Tag{18, protopack.Fixed64Type}, protopack.Float64(6464),
+		protopack.Tag{19, protopack.BytesType}, protopack.String("string"),
+		protopack.Tag{70, protopack.StartGroupType},
+		protopack.Message{
+			protopack.Tag{71, protopack.BytesType}, protopack.String("required"),
+		},
+		protopack.Tag{70, protopack.EndGroupType},
+		protopack.Tag{101, protopack.BytesType}, protopack.Bytes("bytes"),
+		protopack.Tag{102, protopack.VarintType}, protopack.Svarint(-32),
+		protopack.Tag{103, protopack.VarintType}, protopack.Svarint(-64),
+		protopack.Tag{104, protopack.Fixed32Type}, protopack.Int32(-32),
+		protopack.Tag{105, protopack.Fixed64Type}, protopack.Int64(-64),
+	}.Marshal()
+
+	got, err := proto.Marshal(pb)
+	if !isRequiredNotSetError(err) {
+		t.Logf("marshal-1 err = %v, want *RequiredNotSetError", err)
+		t.Fatalf("got %q\nwant  %q", got, want)
+	}
+	if !bytes.Equal(got, want) {
+		t.Fatalf("got %q\nwant  %q", got, want)
+	}
+
+	// Now test Unmarshal by recreating the original buffer.
+	pbd := new(pb2.GoTest)
+	err = proto.Unmarshal(got, pbd)
+	if !isRequiredNotSetError(err) {
+		t.Errorf("unmarshal err = %v, want *RequiredNotSetError", err)
+		t.Fatalf("got %q\nwant  %q", got, want)
+	}
+	got, err = proto.Marshal(pbd)
+	if !isRequiredNotSetError(err) {
+		t.Errorf("marshal-2 err = %v, want *RequiredNotSetError", err)
+		t.Fatalf("got %q\nwant  %q", got, want)
+	}
+	if !bytes.Equal(got, want) {
+		t.Fatalf("got %q\nwant  %q", got, want)
+	}
+}
+
+func TestRequiredNotSetErrorWithBadWireTypes(t *testing.T) {
+	// Required field expects a varint, and properly found a varint.
+	if err := proto.Unmarshal([]byte{0x08, 0x00}, new(pb2.GoEnum)); err != nil {
+		t.Errorf("Unmarshal = %v, want nil", err)
+	}
+	// Required field expects a varint, but found a fixed32 instead.
+	if err := proto.Unmarshal([]byte{0x0d, 0x00, 0x00, 0x00, 0x00}, new(pb2.GoEnum)); err == nil {
+		t.Errorf("Unmarshal = nil, want RequiredNotSetError")
+	}
+	// Required field expects a varint, and found both a varint and fixed32 (ignored).
+	m := new(pb2.GoEnum)
+	if err := proto.Unmarshal([]byte{0x08, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00}, m); err != nil {
+		t.Errorf("Unmarshal = %v, want nil", err)
+	}
+	if !bytes.Equal(m.XXX_unrecognized, []byte{0x0d, 0x00, 0x00, 0x00, 0x00}) {
+		t.Errorf("expected fixed32 to appear as unknown bytes: %x", m.XXX_unrecognized)
+	}
+}
+
+func fuzzUnmarshal(t *testing.T, data []byte) {
+	defer func() {
+		if e := recover(); e != nil {
+			t.Errorf("These bytes caused a panic: %+v", data)
+			t.Logf("Stack:\n%s", debug.Stack())
+			t.FailNow()
+		}
+	}()
+
+	pb := new(pb2.MyMessage)
+	proto.Unmarshal(data, pb)
+}
+
+func TestMapFieldMarshal(t *testing.T) {
+	m := &pb2.MessageWithMap{
+		NameMapping: map[int32]string{
+			1: "Rob",
+			4: "Ian",
+			8: "Dave",
+		},
+	}
+	b, err := proto.Marshal(m)
+	if err != nil {
+		t.Fatalf("Marshal: %v", err)
+	}
+
+	// b should be the concatenation of these three byte sequences in some order.
+	parts := []string{
+		"\n\a\b\x01\x12\x03Rob",
+		"\n\a\b\x04\x12\x03Ian",
+		"\n\b\b\x08\x12\x04Dave",
+	}
+	ok := false
+	for i := range parts {
+		for j := range parts {
+			if j == i {
+				continue
+			}
+			for k := range parts {
+				if k == i || k == j {
+					continue
+				}
+				try := parts[i] + parts[j] + parts[k]
+				if bytes.Equal(b, []byte(try)) {
+					ok = true
+					break
+				}
+			}
+		}
+	}
+	if !ok {
+		t.Fatalf("Incorrect Marshal output.\n got %q\nwant %q (or a permutation of that)", b, parts[0]+parts[1]+parts[2])
+	}
+	t.Logf("FYI b: %q", b)
+}
+
+func TestMapFieldDeterministicMarshal(t *testing.T) {
+	m := &pb2.MessageWithMap{
+		NameMapping: map[int32]string{
+			1: "Rob",
+			4: "Ian",
+			8: "Dave",
+		},
+	}
+
+	marshal := func(m proto.Message) []byte {
+		var b proto.Buffer
+		b.SetDeterministic(true)
+		if err := b.Marshal(m); err != nil {
+			t.Fatalf("Marshal failed: %v", err)
+		}
+		return b.Bytes()
+	}
+
+	want := marshal(m)
+	for i := 0; i < 10; i++ {
+		if got := marshal(m); !bytes.Equal(got, want) {
+			t.Errorf("Marshal produced inconsistent output with determinism enabled (pass %d).\n got %v\nwant %v", i, got, want)
+		}
+	}
+}
+
+func TestMapFieldRoundTrips(t *testing.T) {
+	m := &pb2.MessageWithMap{
+		NameMapping: map[int32]string{
+			1: "Rob",
+			4: "Ian",
+			8: "Dave",
+		},
+		MsgMapping: map[int64]*pb2.FloatingPoint{
+			0x7001: {F: proto.Float64(2.0)},
+		},
+		ByteMapping: map[bool][]byte{
+			false: []byte("that's not right!"),
+			true:  []byte("aye, 'tis true!"),
+		},
+	}
+	b, err := proto.Marshal(m)
+	if err != nil {
+		t.Fatalf("Marshal: %v", err)
+	}
+	t.Logf("FYI b: %q", b)
+	m2 := new(pb2.MessageWithMap)
+	if err := proto.Unmarshal(b, m2); err != nil {
+		t.Fatalf("Unmarshal: %v", err)
+	}
+	if !proto.Equal(m, m2) {
+		t.Errorf("Map did not survive a round trip.\ninitial: %v\n  final: %v", m, m2)
+	}
+}
+
+func TestMapFieldWithNil(t *testing.T) {
+	m1 := &pb2.MessageWithMap{
+		MsgMapping: map[int64]*pb2.FloatingPoint{
+			1: nil,
+		},
+	}
+	b, err := proto.Marshal(m1)
+	if _, ok := err.(*proto.RequiredNotSetError); !ok {
+		t.Fatalf("Marshal(%v): err=%v, want RequiredNotSet", m1, err)
+	}
+	m2 := new(pb2.MessageWithMap)
+	err = proto.Unmarshal(b, m2)
+	if _, ok := err.(*proto.RequiredNotSetError); !ok {
+		t.Fatalf("Unmarshal(%v): err=%v, want RequiredNotSet", m1, err)
+	}
+	if !proto.Equal(m1, m2) {
+		t.Fatalf("roundtrip marshal/unmarshal changed message; got:\n%v\nwant:\n%v", m2, m1)
+	}
+}
+
+func TestMapFieldWithNilBytes(t *testing.T) {
+	m1 := &pb2.MessageWithMap{
+		ByteMapping: map[bool][]byte{
+			false: {},
+			true:  nil,
+		},
+	}
+	n := proto.Size(m1)
+	b, err := proto.Marshal(m1)
+	if err != nil {
+		t.Fatalf("Marshal: %v", err)
+	}
+	if n != len(b) {
+		t.Errorf("Size(m1) = %d; want len(Marshal(m1)) = %d", n, len(b))
+	}
+	m2 := new(pb2.MessageWithMap)
+	if err := proto.Unmarshal(b, m2); err != nil {
+		t.Fatalf("Unmarshal: %v, got these bytes: %v", err, b)
+	}
+	if v, ok := m2.ByteMapping[false]; !ok {
+		t.Error("byte_mapping[false] not present")
+	} else if len(v) != 0 {
+		t.Errorf("byte_mapping[false] not empty: %#v", v)
+	}
+	if v, ok := m2.ByteMapping[true]; !ok {
+		t.Error("byte_mapping[true] not present")
+	} else if len(v) != 0 {
+		t.Errorf("byte_mapping[true] not empty: %#v", v)
+	}
+}
+
+func TestDecodeMapFieldMissingKey(t *testing.T) {
+	b := []byte{
+		0x0A, 0x03, // message, tag 1 (name_mapping), of length 3 bytes
+		// no key
+		0x12, 0x01, 0x6D, // string value of length 1 byte, value "m"
+	}
+	got := &pb2.MessageWithMap{}
+	err := proto.Unmarshal(b, got)
+	if err != nil {
+		t.Fatalf("failed to marshal map with missing key: %v", err)
+	}
+	want := &pb2.MessageWithMap{NameMapping: map[int32]string{0: "m"}}
+	if !proto.Equal(got, want) {
+		t.Errorf("Unmarshaled map with no key was not as expected. got: %v, want %v", got, want)
+	}
+}
+
+func TestDecodeMapFieldMissingValue(t *testing.T) {
+	b := protopack.Message{
+		protopack.Tag{1, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+			protopack.Tag{1, protopack.VarintType}, protopack.Uvarint(1),
+		}),
+	}.Marshal()
+	got := &pb2.MessageWithMap{}
+	err := proto.Unmarshal(b, got)
+	if err != nil {
+		t.Fatalf("failed to marshal map with missing value: %v", err)
+	}
+	want := &pb2.MessageWithMap{NameMapping: map[int32]string{1: ""}}
+	if !proto.Equal(got, want) {
+		t.Errorf("Unmarshaled map with no value was not as expected. got: %v, want %v", got, want)
+	}
+}
+
+func TestOneof(t *testing.T) {
+	m := &pb2.Communique{}
+	b, err := proto.Marshal(m)
+	if err != nil {
+		t.Fatalf("Marshal of empty message with oneof: %v", err)
+	}
+	if len(b) != 0 {
+		t.Errorf("Marshal of empty message yielded too many bytes: %v", b)
+	}
+
+	m = &pb2.Communique{
+		Union: &pb2.Communique_Name{"Barry"},
+	}
+
+	// Round-trip.
+	b, err = proto.Marshal(m)
+	if err != nil {
+		t.Fatalf("Marshal of message with oneof: %v", err)
+	}
+	if len(b) != 7 { // name tag/wire (1) + name len (1) + name (5)
+		t.Errorf("Incorrect marshal of message with oneof: %v", b)
+	}
+	m.Reset()
+	if err := proto.Unmarshal(b, m); err != nil {
+		t.Fatalf("Unmarshal of message with oneof: %v", err)
+	}
+	if x, ok := m.Union.(*pb2.Communique_Name); !ok || x.Name != "Barry" {
+		t.Errorf("After round trip, Union = %+v", m.Union)
+	}
+	if name := m.GetName(); name != "Barry" {
+		t.Errorf("After round trip, GetName = %q, want %q", name, "Barry")
+	}
+
+	// Let's try with a message in the oneof.
+	m.Union = &pb2.Communique_Msg{&pb2.Strings{StringField: proto.String("deep deep string")}}
+	b, err = proto.Marshal(m)
+	if err != nil {
+		t.Fatalf("Marshal of message with oneof set to message: %v", err)
+	}
+	if len(b) != 20 { // msg tag/wire (1) + msg len (1) + msg (1 + 1 + 16)
+		t.Errorf("Incorrect marshal of message with oneof set to message: %v", b)
+	}
+	m.Reset()
+	if err := proto.Unmarshal(b, m); err != nil {
+		t.Fatalf("Unmarshal of message with oneof set to message: %v", err)
+	}
+	ss, ok := m.Union.(*pb2.Communique_Msg)
+	if !ok || ss.Msg.GetStringField() != "deep deep string" {
+		t.Errorf("After round trip with oneof set to message, Union = %+v", m.Union)
+	}
+}
+
+func TestOneofNilBytes(t *testing.T) {
+	// A oneof with nil byte slice should marshal to tag + 0 (size), with no error.
+	m := &pb2.Communique{Union: &pb2.Communique_Data{Data: nil}}
+	b, err := proto.Marshal(m)
+	if err != nil {
+		t.Fatalf("Marshal failed: %v", err)
+	}
+	want := protopack.Message{
+		protopack.Tag{7, protopack.BytesType}, protopack.Bytes(""),
+	}.Marshal()
+	if !bytes.Equal(b, want) {
+		t.Errorf("Wrong result of Marshal: got %x, want %x", b, want)
+	}
+}
+
+func TestInefficientPackedBool(t *testing.T) {
+	// https://github.com/golang/protobuf/issues/76
+	inp := protopack.Message{
+		protopack.Tag{2, protopack.BytesType}, protopack.Bytes("\xb90"),
+	}.Marshal()
+	if err := proto.Unmarshal(inp, new(pb2.MoreRepeated)); err != nil {
+		t.Error(err)
+	}
+}
+
+// Make sure pure-reflect-based implementation handles
+// []int32-[]enum conversion correctly.
+func TestRepeatedEnum2(t *testing.T) {
+	pb := &pb2.RepeatedEnum{
+		Color: []pb2.RepeatedEnum_Color{pb2.RepeatedEnum_RED},
+	}
+	b, err := proto.Marshal(pb)
+	if err != nil {
+		t.Fatalf("Marshal failed: %v", err)
+	}
+	x := new(pb2.RepeatedEnum)
+	err = proto.Unmarshal(b, x)
+	if err != nil {
+		t.Fatalf("Unmarshal failed: %v", err)
+	}
+	if !proto.Equal(pb, x) {
+		t.Errorf("Incorrect result: want: %v got: %v", pb, x)
+	}
+}
+
+// TestConcurrentMarshal makes sure that it is safe to marshal
+// same message in multiple goroutines concurrently.
+func TestConcurrentMarshal(t *testing.T) {
+	pb := initGoTest(true)
+	const N = 100
+	b := make([][]byte, N)
+
+	var wg sync.WaitGroup
+	for i := 0; i < N; i++ {
+		wg.Add(1)
+		go func(i int) {
+			defer wg.Done()
+			var err error
+			b[i], err = proto.Marshal(pb)
+			if err != nil {
+				t.Errorf("marshal error: %v", err)
+			}
+		}(i)
+	}
+
+	wg.Wait()
+	for i := 1; i < N; i++ {
+		if !bytes.Equal(b[0], b[i]) {
+			t.Errorf("concurrent marshal result not same: b[0] = %v, b[%d] = %v", b[0], i, b[i])
+		}
+	}
+}
+
+func TestInvalidUTF8(t *testing.T) {
+	const invalidUTF8 = "\xde\xad\xbe\xef\x80\x00\xff"
+	tests := []struct {
+		label  string
+		proto2 proto.Message
+		proto3 proto.Message
+		want   []byte
+	}{{
+		label:  "Scalar",
+		proto2: &pb2.TestUTF8{Scalar: proto.String(invalidUTF8)},
+		proto3: &pb3.TestUTF8{Scalar: invalidUTF8},
+		want:   []byte{0x0a, 0x07, 0xde, 0xad, 0xbe, 0xef, 0x80, 0x00, 0xff},
+	}, {
+		label:  "Vector",
+		proto2: &pb2.TestUTF8{Vector: []string{invalidUTF8}},
+		proto3: &pb3.TestUTF8{Vector: []string{invalidUTF8}},
+		want:   []byte{0x12, 0x07, 0xde, 0xad, 0xbe, 0xef, 0x80, 0x00, 0xff},
+	}, {
+		label:  "Oneof",
+		proto2: &pb2.TestUTF8{Oneof: &pb2.TestUTF8_Field{invalidUTF8}},
+		proto3: &pb3.TestUTF8{Oneof: &pb3.TestUTF8_Field{invalidUTF8}},
+		want:   []byte{0x1a, 0x07, 0xde, 0xad, 0xbe, 0xef, 0x80, 0x00, 0xff},
+	}, {
+		label:  "MapKey",
+		proto2: &pb2.TestUTF8{MapKey: map[string]int64{invalidUTF8: 0}},
+		proto3: &pb3.TestUTF8{MapKey: map[string]int64{invalidUTF8: 0}},
+		want:   []byte{0x22, 0x0b, 0x0a, 0x07, 0xde, 0xad, 0xbe, 0xef, 0x80, 0x00, 0xff, 0x10, 0x00},
+	}, {
+		label:  "MapValue",
+		proto2: &pb2.TestUTF8{MapValue: map[int64]string{0: invalidUTF8}},
+		proto3: &pb3.TestUTF8{MapValue: map[int64]string{0: invalidUTF8}},
+		want:   []byte{0x2a, 0x0b, 0x08, 0x00, 0x12, 0x07, 0xde, 0xad, 0xbe, 0xef, 0x80, 0x00, 0xff},
+	}}
+
+	for _, tt := range tests {
+		// Proto2 should not validate UTF-8.
+		b, err := proto.Marshal(tt.proto2)
+		if err != nil {
+			t.Errorf("Marshal(proto2.%s) = %v, want nil", tt.label, err)
+		}
+		if !bytes.Equal(b, tt.want) {
+			t.Errorf("Marshal(proto2.%s) = %x, want %x", tt.label, b, tt.want)
+		}
+
+		m := proto.Clone(tt.proto2)
+		m.Reset()
+		if err = proto.Unmarshal(tt.want, m); err != nil {
+			t.Errorf("Unmarshal(proto2.%s) = %v, want nil", tt.label, err)
+		}
+		if !proto.Equal(m, tt.proto2) {
+			t.Errorf("proto2.%s: output mismatch:\ngot  %v\nwant %v", tt.label, m, tt.proto2)
+		}
+
+		// Proto3 should validate UTF-8.
+		if _, err := proto.Marshal(tt.proto3); err == nil {
+			t.Errorf("Marshal(proto3.%s) = %v, want non-nil", tt.label, err)
+		}
+
+		m = proto.Clone(tt.proto3)
+		m.Reset()
+		if err := proto.Unmarshal(tt.want, m); err == nil {
+			t.Errorf("Unmarshal(proto3.%s) = %v, want non-nil", tt.label, err)
+		}
+	}
+}
+
+func TestRequired(t *testing.T) {
+	// The F_BoolRequired field appears after all of the required fields.
+	// It should still be handled even after multiple required field violations.
+	m := &pb2.GoTest{F_BoolRequired: proto.Bool(true)}
+	got, err := proto.Marshal(m)
+	if !isRequiredNotSetError(err) {
+		t.Errorf("Marshal() = %v, want RequiredNotSetError error", err)
+	}
+	if want := []byte{0x50, 0x01}; !bytes.Equal(got, want) {
+		t.Errorf("Marshal() = %x, want %x", got, want)
+	}
+
+	m = new(pb2.GoTest)
+	err = proto.Unmarshal(got, m)
+	if !isRequiredNotSetError(err) {
+		t.Errorf("Marshal() = %v, want RequiredNotSetError error", err)
+	}
+	if !m.GetF_BoolRequired() {
+		t.Error("m.F_BoolRequired = false, want true")
+	}
+}
+
+func TestUnknownV2(t *testing.T) {
+	m := new(tspb.Timestamp)
+	m.ProtoReflect().SetUnknown([]byte("\x92\x4d\x12unknown field 1234"))
+	got := proto.CompactTextString(m)
+	if !strings.Contains(got, "unknown field 1234") {
+		t.Errorf("got %q, want contains %q", got, "unknown field 1234")
+	}
+}
+
+func testMsg() *pb2.GoTest {
+	pb := initGoTest(true)
+	const N = 1000 // Internally the library starts much smaller.
+	pb.F_Int32Repeated = make([]int32, N)
+	pb.F_DoubleRepeated = make([]float64, N)
+	for i := 0; i < N; i++ {
+		pb.F_Int32Repeated[i] = int32(i)
+		pb.F_DoubleRepeated[i] = float64(i)
+	}
+	return pb
+}
+
+func bytesMsg() *pb2.GoTest {
+	pb := initGoTest(true)
+	buf := make([]byte, 4000)
+	for i := range buf {
+		buf[i] = byte(i)
+	}
+	pb.F_BytesDefaulted = buf
+	return pb
+}
+
+func benchmarkMarshal(b *testing.B, pb proto.Message, marshal func(proto.Message) ([]byte, error)) {
+	d, _ := marshal(pb)
+	b.SetBytes(int64(len(d)))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		marshal(pb)
+	}
+}
+
+func benchmarkBufferMarshal(b *testing.B, pb proto.Message) {
+	p := proto.NewBuffer(nil)
+	benchmarkMarshal(b, pb, func(pb0 proto.Message) ([]byte, error) {
+		p.Reset()
+		err := p.Marshal(pb0)
+		return p.Bytes(), err
+	})
+}
+
+func benchmarkSize(b *testing.B, pb proto.Message) {
+	benchmarkMarshal(b, pb, func(pb0 proto.Message) ([]byte, error) {
+		proto.Size(pb)
+		return nil, nil
+	})
+}
+
+func TestProto3ZeroValues(t *testing.T) {
+	tests := []struct {
+		desc string
+		m    proto.Message
+	}{
+		{"zero message", &pb3.Message{}},
+		{"empty bytes field", &pb3.Message{Data: []byte{}}},
+	}
+	for _, test := range tests {
+		b, err := proto.Marshal(test.m)
+		if err != nil {
+			t.Errorf("%s: proto.Marshal: %v", test.desc, err)
+			continue
+		}
+		if len(b) > 0 {
+			t.Errorf("%s: Encoding is non-empty: %q", test.desc, b)
+		}
+	}
+}
+
+func TestRoundTripProto3(t *testing.T) {
+	m := &pb3.Message{
+		Name:         "David",          // (2 | 1<<3): 0x0a 0x05 "David"
+		Hilarity:     pb3.Message_PUNS, // (0 | 2<<3): 0x10 0x01
+		HeightInCm:   178,              // (0 | 3<<3): 0x18 0xb2 0x01
+		Data:         []byte("roboto"), // (2 | 4<<3): 0x20 0x06 "roboto"
+		ResultCount:  47,               // (0 | 7<<3): 0x38 0x2f
+		TrueScotsman: true,             // (0 | 8<<3): 0x40 0x01
+		Score:        8.1,              // (5 | 9<<3): 0x4d <8.1>
+
+		Key: []uint64{1, 0xdeadbeef},
+		Nested: &pb3.Nested{
+			Bunny: "Monty",
+		},
+	}
+	t.Logf(" m: %v", m)
+
+	b, err := proto.Marshal(m)
+	if err != nil {
+		t.Fatalf("proto.Marshal: %v", err)
+	}
+	t.Logf(" b: %q", b)
+
+	m2 := new(pb3.Message)
+	if err := proto.Unmarshal(b, m2); err != nil {
+		t.Fatalf("proto.Unmarshal: %v", err)
+	}
+	t.Logf("m2: %v", m2)
+
+	if !proto.Equal(m, m2) {
+		t.Errorf("proto.Equal returned false:\n m: %v\nm2: %v", m, m2)
+	}
+}
+
+func TestGettersForBasicTypesExist(t *testing.T) {
+	var m pb3.Message
+	if got := m.GetNested().GetBunny(); got != "" {
+		t.Errorf("m.GetNested().GetBunny() = %q, want empty string", got)
+	}
+	if got := m.GetNested().GetCute(); got {
+		t.Errorf("m.GetNested().GetCute() = %t, want false", got)
+	}
+}
+
+func TestProto3SetDefaults(t *testing.T) {
+	in := &pb3.Message{
+		Terrain: map[string]*pb3.Nested{
+			"meadow": new(pb3.Nested),
+		},
+		Proto2Field: new(pb2.SubDefaults),
+		Proto2Value: map[string]*pb2.SubDefaults{
+			"badlands": new(pb2.SubDefaults),
+		},
+	}
+
+	got := proto.Clone(in).(*pb3.Message)
+	proto.SetDefaults(got)
+
+	// There are no defaults in proto3.  Everything should be the zero value, but
+	// we need to remember to set defaults for nested proto2 messages.
+	want := &pb3.Message{
+		Terrain: map[string]*pb3.Nested{
+			"meadow": new(pb3.Nested),
+		},
+		Proto2Field: &pb2.SubDefaults{N: proto.Int64(7)},
+		Proto2Value: map[string]*pb2.SubDefaults{
+			"badlands": &pb2.SubDefaults{N: proto.Int64(7)},
+		},
+	}
+
+	if !proto.Equal(got, want) {
+		t.Errorf("with in = %v\nproto.SetDefaults(in) =>\ngot %v\nwant %v", in, got, want)
+	}
+}
+
+func TestUnknownFieldPreservation(t *testing.T) {
+	b1 := "\x0a\x05David"      // Known tag 1
+	b2 := "\xc2\x0c\x06Google" // Unknown tag 200
+	b := []byte(b1 + b2)
+
+	m := new(pb3.Message)
+	if err := proto.Unmarshal(b, m); err != nil {
+		t.Fatalf("proto.Unmarshal: %v", err)
+	}
+
+	if !bytes.Equal(m.XXX_unrecognized, []byte(b2)) {
+		t.Fatalf("mismatching unknown fields:\ngot  %q\nwant %q", m.XXX_unrecognized, b2)
+	}
+}
+
+func TestMap(t *testing.T) {
+	b := protopack.Message{
+		protopack.Tag{20, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+			protopack.Tag{1, protopack.BytesType}, protopack.String("Key1"),
+			protopack.Tag{2, protopack.BytesType}, protopack.String("Val1"),
+		}),
+		protopack.Tag{20, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+			protopack.Tag{1, protopack.BytesType}, protopack.String("Key2"),
+			protopack.Tag{2, protopack.BytesType}, protopack.String("Val2a"),
+			protopack.Tag{2, protopack.BytesType}, protopack.String("Val2"),
+		}),
+		protopack.Tag{20, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+			protopack.Tag{1, protopack.BytesType}, protopack.String("Key3"),
+			protopack.Tag{1, protopack.Fixed32Type}, protopack.Uint32(5),
+			protopack.Tag{2, protopack.BytesType}, protopack.String("Val3b"),
+			protopack.Tag{3, protopack.BytesType}, protopack.Bytes("Val3a"),
+			protopack.Tag{2, protopack.BytesType}, protopack.String("Val3"),
+			protopack.Tag{2, protopack.Fixed32Type}, protopack.Uint32(5),
+		}),
+		protopack.Tag{20, protopack.BytesType}, protopack.LengthPrefix{},
+		protopack.Tag{20, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+			protopack.Tag{1, protopack.BytesType}, protopack.String("Key4"),
+			protopack.Tag{2, protopack.StartGroupType},
+			protopack.Message{
+				protopack.Tag{1, protopack.BytesType}, protopack.Bytes("SomeURL"),
+				protopack.Tag{2, protopack.BytesType}, protopack.Bytes("SomeTitle"),
+				protopack.Tag{3, protopack.BytesType}, protopack.Bytes("Snippet1"),
+			},
+			protopack.Tag{2, protopack.EndGroupType},
+		}),
+	}.Marshal()
+
+	var m pb3.Message
+	if err := proto.Unmarshal(b, &m); err != nil {
+		t.Fatalf("proto.Unmarshal error: %v", err)
+	}
+
+	got := m.StringMap
+	want := map[string]string{
+		"":     "",
+		"Key1": "Val1",
+		"Key2": "Val2",
+		"Key3": "Val3",
+		"Key4": "",
+	}
+
+	if !reflect.DeepEqual(got, want) {
+		t.Errorf("maps differ:\ngot  %#v\nwant %#v", got, want)
+	}
+}
+
+func marshalled() []byte {
+	m := &pb3.IntMaps{}
+	for i := 0; i < 1000; i++ {
+		m.Maps = append(m.Maps, &pb3.IntMap{
+			Rtt: map[int32]int32{1: 2},
+		})
+	}
+	b, err := proto.Marshal(m)
+	if err != nil {
+		panic(fmt.Sprintf("Can't marshal %+v: %v", m, err))
+	}
+	return b
+}
+
+var messageWithExtension1 = &pb2.MyMessage{Count: proto.Int32(7)}
+
+// messageWithExtension2 is in equal_test.go.
+var messageWithExtension3 = &pb2.MyMessage{Count: proto.Int32(8)}
+
+func init() {
+	if err := proto.SetExtension(messageWithExtension1, pb2.E_Ext_More, &pb2.Ext{Data: proto.String("Abbott")}); err != nil {
+		log.Panicf("proto.SetExtension: %v", err)
+	}
+	if err := proto.SetExtension(messageWithExtension3, pb2.E_Ext_More, &pb2.Ext{Data: proto.String("Costello")}); err != nil {
+		log.Panicf("proto.SetExtension: %v", err)
+	}
+
+	// Force messageWithExtension3 to have the extension encoded.
+	proto.Marshal(messageWithExtension3)
+
+}
+
+// non-pointer custom message
+type nonptrMessage struct{}
+
+func (m nonptrMessage) ProtoMessage()  {}
+func (m nonptrMessage) Reset()         {}
+func (m nonptrMessage) String() string { return "" }
+
+func (m nonptrMessage) Marshal() ([]byte, error) {
+	return []byte{42}, nil
+}
+
+var SizeTests = []struct {
+	desc string
+	pb   proto.Message
+}{
+	{"empty", &pb2.OtherMessage{}},
+	// Basic types.
+	{"bool", &pb2.Defaults{F_Bool: proto.Bool(true)}},
+	{"int32", &pb2.Defaults{F_Int32: proto.Int32(12)}},
+	{"negative int32", &pb2.Defaults{F_Int32: proto.Int32(-1)}},
+	{"small int64", &pb2.Defaults{F_Int64: proto.Int64(1)}},
+	{"big int64", &pb2.Defaults{F_Int64: proto.Int64(1 << 20)}},
+	{"negative int64", &pb2.Defaults{F_Int64: proto.Int64(-1)}},
+	{"fixed32", &pb2.Defaults{F_Fixed32: proto.Uint32(71)}},
+	{"fixed64", &pb2.Defaults{F_Fixed64: proto.Uint64(72)}},
+	{"uint32", &pb2.Defaults{F_Uint32: proto.Uint32(123)}},
+	{"uint64", &pb2.Defaults{F_Uint64: proto.Uint64(124)}},
+	{"float", &pb2.Defaults{F_Float: proto.Float32(12.6)}},
+	{"double", &pb2.Defaults{F_Double: proto.Float64(13.9)}},
+	{"string", &pb2.Defaults{F_String: proto.String("niles")}},
+	{"bytes", &pb2.Defaults{F_Bytes: []byte("wowsa")}},
+	{"bytes, empty", &pb2.Defaults{F_Bytes: []byte{}}},
+	{"sint32", &pb2.Defaults{F_Sint32: proto.Int32(65)}},
+	{"sint64", &pb2.Defaults{F_Sint64: proto.Int64(67)}},
+	{"enum", &pb2.Defaults{F_Enum: pb2.Defaults_BLUE.Enum()}},
+	// Repeated.
+	{"empty repeated bool", &pb2.MoreRepeated{Bools: []bool{}}},
+	{"repeated bool", &pb2.MoreRepeated{Bools: []bool{false, true, true, false}}},
+	{"packed repeated bool", &pb2.MoreRepeated{BoolsPacked: []bool{false, true, true, false, true, true, true}}},
+	{"repeated int32", &pb2.MoreRepeated{Ints: []int32{1, 12203, 1729, -1}}},
+	{"repeated int32 packed", &pb2.MoreRepeated{IntsPacked: []int32{1, 12203, 1729}}},
+	{"repeated int64 packed", &pb2.MoreRepeated{Int64SPacked: []int64{
+		// Need enough large numbers to verify that the header is counting the number of bytes
+		// for the field, not the number of elements.
+		1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62,
+		1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62,
+	}}},
+	{"repeated string", &pb2.MoreRepeated{Strings: []string{"r", "ken", "gri"}}},
+	{"repeated fixed", &pb2.MoreRepeated{Fixeds: []uint32{1, 2, 3, 4}}},
+	// Nested.
+	{"nested", &pb2.OldMessage{Nested: &pb2.OldMessage_Nested{Name: proto.String("whatever")}}},
+	{"group", &pb2.GroupOld{G: &pb2.GroupOld_G{X: proto.Int32(12345)}}},
+	// Other things.
+	{"unrecognized", &pb2.MoreRepeated{XXX_unrecognized: []byte{13<<3 | 0, 4}}},
+	{"extension (unencoded)", messageWithExtension1},
+	{"extension (encoded)", messageWithExtension3},
+	// proto3 message
+	{"proto3 empty", &pb3.Message{}},
+	{"proto3 bool", &pb3.Message{TrueScotsman: true}},
+	{"proto3 int64", &pb3.Message{ResultCount: 1}},
+	{"proto3 uint32", &pb3.Message{HeightInCm: 123}},
+	{"proto3 float", &pb3.Message{Score: 12.6}},
+	{"proto3 string", &pb3.Message{Name: "Snezana"}},
+	{"proto3 bytes", &pb3.Message{Data: []byte("wowsa")}},
+	{"proto3 bytes, empty", &pb3.Message{Data: []byte{}}},
+	{"proto3 enum", &pb3.Message{Hilarity: pb3.Message_PUNS}},
+	{"proto3 map field with empty bytes", &pb3.MessageWithMap{ByteMapping: map[bool][]byte{false: []byte{}}}},
+
+	{"map field", &pb2.MessageWithMap{NameMapping: map[int32]string{1: "Rob", 7: "Andrew"}}},
+	{"map field with message", &pb2.MessageWithMap{MsgMapping: map[int64]*pb2.FloatingPoint{0x7001: &pb2.FloatingPoint{F: proto.Float64(2.0)}}}},
+	{"map field with bytes", &pb2.MessageWithMap{ByteMapping: map[bool][]byte{true: []byte("this time for sure")}}},
+	{"map field with empty bytes", &pb2.MessageWithMap{ByteMapping: map[bool][]byte{true: []byte{}}}},
+
+	{"map field with big entry", &pb2.MessageWithMap{NameMapping: map[int32]string{8: strings.Repeat("x", 125)}}},
+	{"map field with big key and val", &pb2.MessageWithMap{StrToStr: map[string]string{strings.Repeat("x", 70): strings.Repeat("y", 70)}}},
+	{"map field with big numeric key", &pb2.MessageWithMap{NameMapping: map[int32]string{0xf00d: "om nom nom"}}},
+
+	{"oneof not set", &pb2.Oneof{}},
+	{"oneof bool", &pb2.Oneof{Union: &pb2.Oneof_F_Bool{true}}},
+	{"oneof zero int32", &pb2.Oneof{Union: &pb2.Oneof_F_Int32{0}}},
+	{"oneof big int32", &pb2.Oneof{Union: &pb2.Oneof_F_Int32{1 << 20}}},
+	{"oneof int64", &pb2.Oneof{Union: &pb2.Oneof_F_Int64{42}}},
+	{"oneof fixed32", &pb2.Oneof{Union: &pb2.Oneof_F_Fixed32{43}}},
+	{"oneof fixed64", &pb2.Oneof{Union: &pb2.Oneof_F_Fixed64{44}}},
+	{"oneof uint32", &pb2.Oneof{Union: &pb2.Oneof_F_Uint32{45}}},
+	{"oneof uint64", &pb2.Oneof{Union: &pb2.Oneof_F_Uint64{46}}},
+	{"oneof float", &pb2.Oneof{Union: &pb2.Oneof_F_Float{47.1}}},
+	{"oneof double", &pb2.Oneof{Union: &pb2.Oneof_F_Double{48.9}}},
+	{"oneof string", &pb2.Oneof{Union: &pb2.Oneof_F_String{"Rhythmic Fman"}}},
+	{"oneof bytes", &pb2.Oneof{Union: &pb2.Oneof_F_Bytes{[]byte("let go")}}},
+	{"oneof sint32", &pb2.Oneof{Union: &pb2.Oneof_F_Sint32{50}}},
+	{"oneof sint64", &pb2.Oneof{Union: &pb2.Oneof_F_Sint64{51}}},
+	{"oneof enum", &pb2.Oneof{Union: &pb2.Oneof_F_Enum{pb2.MyMessage_BLUE}}},
+	{"message for oneof", &pb2.GoTestField{Label: proto.String("k"), Type: proto.String("v")}},
+	{"oneof message", &pb2.Oneof{Union: &pb2.Oneof_F_Message{&pb2.GoTestField{Label: proto.String("k"), Type: proto.String("v")}}}},
+	{"oneof group", &pb2.Oneof{Union: &pb2.Oneof_FGroup{&pb2.Oneof_F_Group{X: proto.Int32(52)}}}},
+	{"oneof largest tag", &pb2.Oneof{Union: &pb2.Oneof_F_Largest_Tag{1}}},
+	{"multiple oneofs", &pb2.Oneof{Union: &pb2.Oneof_F_Int32{1}, Tormato: &pb2.Oneof_Value{2}}},
+
+	{"non-pointer message", nonptrMessage{}},
+}
+
+func TestSize(t *testing.T) {
+	for _, tc := range SizeTests {
+		t.Run(tc.desc, func(t *testing.T) {
+			size := proto.Size(tc.pb)
+			b, err := proto.Marshal(tc.pb)
+			if err != nil {
+				t.Errorf("%v: Marshal failed: %v", tc.desc, err)
+				return
+			}
+			if size != len(b) {
+				t.Errorf("%v: Size(%v) = %d, want %d", tc.desc, tc.pb, size, len(b))
+				t.Logf("%v: bytes: %#v", tc.desc, b)
+			}
+		})
+	}
+}
+
+func TestVarintSize(t *testing.T) {
+	// Check the edge cases carefully.
+	testCases := []struct {
+		n    uint64
+		size int
+	}{
+		{0, 1},
+		{1, 1},
+		{127, 1},
+		{128, 2},
+		{16383, 2},
+		{16384, 3},
+		{math.MaxInt64, 9},
+		{math.MaxInt64 + 1, 10},
+	}
+	for _, tc := range testCases {
+		size := proto.SizeVarint(tc.n)
+		if size != tc.size {
+			t.Errorf("sizeVarint(%d) = %d, want %d", tc.n, size, tc.size)
+		}
+	}
+}
diff --git a/vendor/github.com/golang/protobuf/proto/registry.go b/vendor/github.com/golang/protobuf/proto/registry.go
new file mode 100644
index 000000000..1e7ff6420
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/registry.go
@@ -0,0 +1,323 @@
+// Copyright 2019 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 proto
+
+import (
+	"bytes"
+	"compress/gzip"
+	"fmt"
+	"io/ioutil"
+	"reflect"
+	"strings"
+	"sync"
+
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/reflect/protoregistry"
+	"google.golang.org/protobuf/runtime/protoimpl"
+)
+
+// filePath is the path to the proto source file.
+type filePath = string // e.g., "google/protobuf/descriptor.proto"
+
+// fileDescGZIP is the compressed contents of the encoded FileDescriptorProto.
+type fileDescGZIP = []byte
+
+var fileCache sync.Map // map[filePath]fileDescGZIP
+
+// RegisterFile is called from generated code to register the compressed
+// FileDescriptorProto with the file path for a proto source file.
+//
+// Deprecated: Use protoregistry.GlobalFiles.RegisterFile instead.
+func RegisterFile(s filePath, d fileDescGZIP) {
+	// Decompress the descriptor.
+	zr, err := gzip.NewReader(bytes.NewReader(d))
+	if err != nil {
+		panic(fmt.Sprintf("proto: invalid compressed file descriptor: %v", err))
+	}
+	b, err := ioutil.ReadAll(zr)
+	if err != nil {
+		panic(fmt.Sprintf("proto: invalid compressed file descriptor: %v", err))
+	}
+
+	// Construct a protoreflect.FileDescriptor from the raw descriptor.
+	// Note that DescBuilder.Build automatically registers the constructed
+	// file descriptor with the v2 registry.
+	protoimpl.DescBuilder{RawDescriptor: b}.Build()
+
+	// Locally cache the raw descriptor form for the file.
+	fileCache.Store(s, d)
+}
+
+// FileDescriptor returns the compressed FileDescriptorProto given the file path
+// for a proto source file. It returns nil if not found.
+//
+// Deprecated: Use protoregistry.GlobalFiles.FindFileByPath instead.
+func FileDescriptor(s filePath) fileDescGZIP {
+	if v, ok := fileCache.Load(s); ok {
+		return v.(fileDescGZIP)
+	}
+
+	// Find the descriptor in the v2 registry.
+	var b []byte
+	if fd, _ := protoregistry.GlobalFiles.FindFileByPath(s); fd != nil {
+		if fd, ok := fd.(interface{ ProtoLegacyRawDesc() []byte }); ok {
+			b = fd.ProtoLegacyRawDesc()
+		} else {
+			// TODO: Use protodesc.ToFileDescriptorProto to construct
+			// a descriptorpb.FileDescriptorProto and marshal it.
+			// However, doing so causes the proto package to have a dependency
+			// on descriptorpb, leading to cyclic dependency issues.
+		}
+	}
+
+	// Locally cache the raw descriptor form for the file.
+	if len(b) > 0 {
+		v, _ := fileCache.LoadOrStore(s, protoimpl.X.CompressGZIP(b))
+		return v.(fileDescGZIP)
+	}
+	return nil
+}
+
+// enumName is the name of an enum. For historical reasons, the enum name is
+// neither the full Go name nor the full protobuf name of the enum.
+// The name is the dot-separated combination of just the proto package that the
+// enum is declared within followed by the Go type name of the generated enum.
+type enumName = string // e.g., "my.proto.package.GoMessage_GoEnum"
+
+// enumsByName maps enum values by name to their numeric counterpart.
+type enumsByName = map[string]int32
+
+// enumsByNumber maps enum values by number to their name counterpart.
+type enumsByNumber = map[int32]string
+
+var enumCache sync.Map     // map[enumName]enumsByName
+var numFilesCache sync.Map // map[protoreflect.FullName]int
+
+// RegisterEnum is called from the generated code to register the mapping of
+// enum value names to enum numbers for the enum identified by s.
+//
+// Deprecated: Use protoregistry.GlobalTypes.RegisterEnum instead.
+func RegisterEnum(s enumName, _ enumsByNumber, m enumsByName) {
+	if _, ok := enumCache.Load(s); ok {
+		panic("proto: duplicate enum registered: " + s)
+	}
+	enumCache.Store(s, m)
+
+	// This does not forward registration to the v2 registry since this API
+	// lacks sufficient information to construct a complete v2 enum descriptor.
+}
+
+// EnumValueMap returns the mapping from enum value names to enum numbers for
+// the enum of the given name. It returns nil if not found.
+//
+// Deprecated: Use protoregistry.GlobalTypes.FindEnumByName instead.
+func EnumValueMap(s enumName) enumsByName {
+	if v, ok := enumCache.Load(s); ok {
+		return v.(enumsByName)
+	}
+
+	// Check whether the cache is stale. If the number of files in the current
+	// package differs, then it means that some enums may have been recently
+	// registered upstream that we do not know about.
+	var protoPkg protoreflect.FullName
+	if i := strings.LastIndexByte(s, '.'); i >= 0 {
+		protoPkg = protoreflect.FullName(s[:i])
+	}
+	v, _ := numFilesCache.Load(protoPkg)
+	numFiles, _ := v.(int)
+	if protoregistry.GlobalFiles.NumFilesByPackage(protoPkg) == numFiles {
+		return nil // cache is up-to-date; was not found earlier
+	}
+
+	// Update the enum cache for all enums declared in the given proto package.
+	numFiles = 0
+	protoregistry.GlobalFiles.RangeFilesByPackage(protoPkg, func(fd protoreflect.FileDescriptor) bool {
+		walkEnums(fd, func(ed protoreflect.EnumDescriptor) {
+			name := protoimpl.X.LegacyEnumName(ed)
+			if _, ok := enumCache.Load(name); !ok {
+				m := make(enumsByName)
+				evs := ed.Values()
+				for i := evs.Len() - 1; i >= 0; i-- {
+					ev := evs.Get(i)
+					m[string(ev.Name())] = int32(ev.Number())
+				}
+				enumCache.LoadOrStore(name, m)
+			}
+		})
+		numFiles++
+		return true
+	})
+	numFilesCache.Store(protoPkg, numFiles)
+
+	// Check cache again for enum map.
+	if v, ok := enumCache.Load(s); ok {
+		return v.(enumsByName)
+	}
+	return nil
+}
+
+// walkEnums recursively walks all enums declared in d.
+func walkEnums(d interface {
+	Enums() protoreflect.EnumDescriptors
+	Messages() protoreflect.MessageDescriptors
+}, f func(protoreflect.EnumDescriptor)) {
+	eds := d.Enums()
+	for i := eds.Len() - 1; i >= 0; i-- {
+		f(eds.Get(i))
+	}
+	mds := d.Messages()
+	for i := mds.Len() - 1; i >= 0; i-- {
+		walkEnums(mds.Get(i), f)
+	}
+}
+
+// messageName is the full name of protobuf message.
+type messageName = string
+
+var messageTypeCache sync.Map // map[messageName]reflect.Type
+
+// RegisterType is called from generated code to register the message Go type
+// for a message of the given name.
+//
+// Deprecated: Use protoregistry.GlobalTypes.RegisterMessage instead.
+func RegisterType(m Message, s messageName) {
+	mt := protoimpl.X.LegacyMessageTypeOf(m, protoreflect.FullName(s))
+	if err := protoregistry.GlobalTypes.RegisterMessage(mt); err != nil {
+		panic(err)
+	}
+	messageTypeCache.Store(s, reflect.TypeOf(m))
+}
+
+// RegisterMapType is called from generated code to register the Go map type
+// for a protobuf message representing a map entry.
+//
+// Deprecated: Do not use.
+func RegisterMapType(m interface{}, s messageName) {
+	t := reflect.TypeOf(m)
+	if t.Kind() != reflect.Map {
+		panic(fmt.Sprintf("invalid map kind: %v", t))
+	}
+	if _, ok := messageTypeCache.Load(s); ok {
+		panic(fmt.Errorf("proto: duplicate proto message registered: %s", s))
+	}
+	messageTypeCache.Store(s, t)
+}
+
+// MessageType returns the message type for a named message.
+// It returns nil if not found.
+//
+// Deprecated: Use protoregistry.GlobalTypes.FindMessageByName instead.
+func MessageType(s messageName) reflect.Type {
+	if v, ok := messageTypeCache.Load(s); ok {
+		return v.(reflect.Type)
+	}
+
+	// Derive the message type from the v2 registry.
+	var t reflect.Type
+	if mt, _ := protoregistry.GlobalTypes.FindMessageByName(protoreflect.FullName(s)); mt != nil {
+		t = messageGoType(mt)
+	}
+
+	// If we could not get a concrete type, it is possible that it is a
+	// pseudo-message for a map entry.
+	if t == nil {
+		d, _ := protoregistry.GlobalFiles.FindDescriptorByName(protoreflect.FullName(s))
+		if md, _ := d.(protoreflect.MessageDescriptor); md != nil && md.IsMapEntry() {
+			kt := goTypeForField(md.Fields().ByNumber(1))
+			vt := goTypeForField(md.Fields().ByNumber(2))
+			t = reflect.MapOf(kt, vt)
+		}
+	}
+
+	// Locally cache the message type for the given name.
+	if t != nil {
+		v, _ := messageTypeCache.LoadOrStore(s, t)
+		return v.(reflect.Type)
+	}
+	return nil
+}
+
+func goTypeForField(fd protoreflect.FieldDescriptor) reflect.Type {
+	switch k := fd.Kind(); k {
+	case protoreflect.EnumKind:
+		if et, _ := protoregistry.GlobalTypes.FindEnumByName(fd.Enum().FullName()); et != nil {
+			return enumGoType(et)
+		}
+		return reflect.TypeOf(protoreflect.EnumNumber(0))
+	case protoreflect.MessageKind, protoreflect.GroupKind:
+		if mt, _ := protoregistry.GlobalTypes.FindMessageByName(fd.Message().FullName()); mt != nil {
+			return messageGoType(mt)
+		}
+		return reflect.TypeOf((*protoreflect.Message)(nil)).Elem()
+	default:
+		return reflect.TypeOf(fd.Default().Interface())
+	}
+}
+
+func enumGoType(et protoreflect.EnumType) reflect.Type {
+	return reflect.TypeOf(et.New(0))
+}
+
+func messageGoType(mt protoreflect.MessageType) reflect.Type {
+	return reflect.TypeOf(MessageV1(mt.Zero().Interface()))
+}
+
+// MessageName returns the full protobuf name for the given message type.
+//
+// Deprecated: Use protoreflect.MessageDescriptor.FullName instead.
+func MessageName(m Message) messageName {
+	if m == nil {
+		return ""
+	}
+	if m, ok := m.(interface{ XXX_MessageName() messageName }); ok {
+		return m.XXX_MessageName()
+	}
+	return messageName(protoimpl.X.MessageDescriptorOf(m).FullName())
+}
+
+// RegisterExtension is called from the generated code to register
+// the extension descriptor.
+//
+// Deprecated: Use protoregistry.GlobalTypes.RegisterExtension instead.
+func RegisterExtension(d *ExtensionDesc) {
+	if err := protoregistry.GlobalTypes.RegisterExtension(d); err != nil {
+		panic(err)
+	}
+}
+
+type extensionsByNumber = map[int32]*ExtensionDesc
+
+var extensionCache sync.Map // map[messageName]extensionsByNumber
+
+// RegisteredExtensions returns a map of the registered extensions for the
+// provided protobuf message, indexed by the extension field number.
+//
+// Deprecated: Use protoregistry.GlobalTypes.RangeExtensionsByMessage instead.
+func RegisteredExtensions(m Message) extensionsByNumber {
+	// Check whether the cache is stale. If the number of extensions for
+	// the given message differs, then it means that some extensions were
+	// recently registered upstream that we do not know about.
+	s := MessageName(m)
+	v, _ := extensionCache.Load(s)
+	xs, _ := v.(extensionsByNumber)
+	if protoregistry.GlobalTypes.NumExtensionsByMessage(protoreflect.FullName(s)) == len(xs) {
+		return xs // cache is up-to-date
+	}
+
+	// Cache is stale, re-compute the extensions map.
+	xs = make(extensionsByNumber)
+	protoregistry.GlobalTypes.RangeExtensionsByMessage(protoreflect.FullName(s), func(xt protoreflect.ExtensionType) bool {
+		if xd, ok := xt.(*ExtensionDesc); ok {
+			xs[int32(xt.TypeDescriptor().Number())] = xd
+		} else {
+			// TODO: This implies that the protoreflect.ExtensionType is a
+			// custom type not generated by protoc-gen-go. We could try and
+			// convert the type to an ExtensionDesc.
+		}
+		return true
+	})
+	extensionCache.Store(s, xs)
+	return xs
+}
diff --git a/vendor/github.com/golang/protobuf/proto/registry_test.go b/vendor/github.com/golang/protobuf/proto/registry_test.go
new file mode 100644
index 000000000..89c4f783c
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/registry_test.go
@@ -0,0 +1,37 @@
+// Copyright 2019 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 proto_test
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/golang/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protoreflect"
+
+	descpb "github.com/golang/protobuf/protoc-gen-go/descriptor"
+)
+
+func TestRegistry(t *testing.T) {
+	file := new(descpb.DescriptorProto).ProtoReflect().Descriptor().ParentFile()
+	path := file.Path()
+	pkg := file.Package()
+	if got := proto.FileDescriptor(path); len(got) == 0 {
+		t.Errorf("FileDescriptor(%q) = empty, want non-empty", path)
+	}
+
+	name := protoreflect.FullName(pkg + ".FieldDescriptorProto_Label")
+	if got := proto.EnumValueMap(string(name)); len(got) == 0 {
+		t.Errorf("EnumValueMap(%q) = empty, want non-empty", name)
+	}
+
+	msg := new(descpb.EnumDescriptorProto_EnumReservedRange)
+	name = msg.ProtoReflect().Descriptor().FullName()
+	wantType := reflect.TypeOf(msg)
+	gotType := proto.MessageType(string(name))
+	if gotType != wantType {
+		t.Errorf("MessageType(%q) = %v, want %v", name, gotType, wantType)
+	}
+}
diff --git a/vendor/github.com/golang/protobuf/proto/size2_test.go b/vendor/github.com/golang/protobuf/proto/size2_test.go
deleted file mode 100644
index 7846b0617..000000000
--- a/vendor/github.com/golang/protobuf/proto/size2_test.go
+++ /dev/null
@@ -1,63 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2012 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package proto
-
-import (
-	"testing"
-)
-
-// This is a separate file and package from size_test.go because that one uses
-// generated messages and thus may not be in package proto without having a circular
-// dependency, whereas this file tests unexported details of size.go.
-
-func TestVarintSize(t *testing.T) {
-	// Check the edge cases carefully.
-	testCases := []struct {
-		n    uint64
-		size int
-	}{
-		{0, 1},
-		{1, 1},
-		{127, 1},
-		{128, 2},
-		{16383, 2},
-		{16384, 3},
-		{1<<63 - 1, 9},
-		{1 << 63, 10},
-	}
-	for _, tc := range testCases {
-		size := SizeVarint(tc.n)
-		if size != tc.size {
-			t.Errorf("sizeVarint(%d) = %d, want %d", tc.n, size, tc.size)
-		}
-	}
-}
diff --git a/vendor/github.com/golang/protobuf/proto/size_test.go b/vendor/github.com/golang/protobuf/proto/size_test.go
deleted file mode 100644
index 3abac418a..000000000
--- a/vendor/github.com/golang/protobuf/proto/size_test.go
+++ /dev/null
@@ -1,191 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2012 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package proto_test
-
-import (
-	"log"
-	"strings"
-	"testing"
-
-	. "github.com/golang/protobuf/proto"
-	proto3pb "github.com/golang/protobuf/proto/proto3_proto"
-	pb "github.com/golang/protobuf/proto/test_proto"
-)
-
-var messageWithExtension1 = &pb.MyMessage{Count: Int32(7)}
-
-// messageWithExtension2 is in equal_test.go.
-var messageWithExtension3 = &pb.MyMessage{Count: Int32(8)}
-
-func init() {
-	if err := SetExtension(messageWithExtension1, pb.E_Ext_More, &pb.Ext{Data: String("Abbott")}); err != nil {
-		log.Panicf("SetExtension: %v", err)
-	}
-	if err := SetExtension(messageWithExtension3, pb.E_Ext_More, &pb.Ext{Data: String("Costello")}); err != nil {
-		log.Panicf("SetExtension: %v", err)
-	}
-
-	// Force messageWithExtension3 to have the extension encoded.
-	Marshal(messageWithExtension3)
-
-}
-
-// non-pointer custom message
-type nonptrMessage struct{}
-
-func (m nonptrMessage) ProtoMessage()  {}
-func (m nonptrMessage) Reset()         {}
-func (m nonptrMessage) String() string { return "" }
-
-func (m nonptrMessage) Marshal() ([]byte, error) {
-	return []byte{42}, nil
-}
-
-// custom message embedding a proto.Message
-type messageWithEmbedding struct {
-	*pb.OtherMessage
-}
-
-func (m *messageWithEmbedding) ProtoMessage()  {}
-func (m *messageWithEmbedding) Reset()         {}
-func (m *messageWithEmbedding) String() string { return "" }
-
-func (m *messageWithEmbedding) Marshal() ([]byte, error) {
-	return []byte{42}, nil
-}
-
-var SizeTests = []struct {
-	desc string
-	pb   Message
-}{
-	{"empty", &pb.OtherMessage{}},
-	// Basic types.
-	{"bool", &pb.Defaults{F_Bool: Bool(true)}},
-	{"int32", &pb.Defaults{F_Int32: Int32(12)}},
-	{"negative int32", &pb.Defaults{F_Int32: Int32(-1)}},
-	{"small int64", &pb.Defaults{F_Int64: Int64(1)}},
-	{"big int64", &pb.Defaults{F_Int64: Int64(1 << 20)}},
-	{"negative int64", &pb.Defaults{F_Int64: Int64(-1)}},
-	{"fixed32", &pb.Defaults{F_Fixed32: Uint32(71)}},
-	{"fixed64", &pb.Defaults{F_Fixed64: Uint64(72)}},
-	{"uint32", &pb.Defaults{F_Uint32: Uint32(123)}},
-	{"uint64", &pb.Defaults{F_Uint64: Uint64(124)}},
-	{"float", &pb.Defaults{F_Float: Float32(12.6)}},
-	{"double", &pb.Defaults{F_Double: Float64(13.9)}},
-	{"string", &pb.Defaults{F_String: String("niles")}},
-	{"bytes", &pb.Defaults{F_Bytes: []byte("wowsa")}},
-	{"bytes, empty", &pb.Defaults{F_Bytes: []byte{}}},
-	{"sint32", &pb.Defaults{F_Sint32: Int32(65)}},
-	{"sint64", &pb.Defaults{F_Sint64: Int64(67)}},
-	{"enum", &pb.Defaults{F_Enum: pb.Defaults_BLUE.Enum()}},
-	// Repeated.
-	{"empty repeated bool", &pb.MoreRepeated{Bools: []bool{}}},
-	{"repeated bool", &pb.MoreRepeated{Bools: []bool{false, true, true, false}}},
-	{"packed repeated bool", &pb.MoreRepeated{BoolsPacked: []bool{false, true, true, false, true, true, true}}},
-	{"repeated int32", &pb.MoreRepeated{Ints: []int32{1, 12203, 1729, -1}}},
-	{"repeated int32 packed", &pb.MoreRepeated{IntsPacked: []int32{1, 12203, 1729}}},
-	{"repeated int64 packed", &pb.MoreRepeated{Int64SPacked: []int64{
-		// Need enough large numbers to verify that the header is counting the number of bytes
-		// for the field, not the number of elements.
-		1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62,
-		1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62,
-	}}},
-	{"repeated string", &pb.MoreRepeated{Strings: []string{"r", "ken", "gri"}}},
-	{"repeated fixed", &pb.MoreRepeated{Fixeds: []uint32{1, 2, 3, 4}}},
-	// Nested.
-	{"nested", &pb.OldMessage{Nested: &pb.OldMessage_Nested{Name: String("whatever")}}},
-	{"group", &pb.GroupOld{G: &pb.GroupOld_G{X: Int32(12345)}}},
-	// Other things.
-	{"unrecognized", &pb.MoreRepeated{XXX_unrecognized: []byte{13<<3 | 0, 4}}},
-	{"extension (unencoded)", messageWithExtension1},
-	{"extension (encoded)", messageWithExtension3},
-	// proto3 message
-	{"proto3 empty", &proto3pb.Message{}},
-	{"proto3 bool", &proto3pb.Message{TrueScotsman: true}},
-	{"proto3 int64", &proto3pb.Message{ResultCount: 1}},
-	{"proto3 uint32", &proto3pb.Message{HeightInCm: 123}},
-	{"proto3 float", &proto3pb.Message{Score: 12.6}},
-	{"proto3 string", &proto3pb.Message{Name: "Snezana"}},
-	{"proto3 bytes", &proto3pb.Message{Data: []byte("wowsa")}},
-	{"proto3 bytes, empty", &proto3pb.Message{Data: []byte{}}},
-	{"proto3 enum", &proto3pb.Message{Hilarity: proto3pb.Message_PUNS}},
-	{"proto3 map field with empty bytes", &proto3pb.MessageWithMap{ByteMapping: map[bool][]byte{false: []byte{}}}},
-
-	{"map field", &pb.MessageWithMap{NameMapping: map[int32]string{1: "Rob", 7: "Andrew"}}},
-	{"map field with message", &pb.MessageWithMap{MsgMapping: map[int64]*pb.FloatingPoint{0x7001: &pb.FloatingPoint{F: Float64(2.0)}}}},
-	{"map field with bytes", &pb.MessageWithMap{ByteMapping: map[bool][]byte{true: []byte("this time for sure")}}},
-	{"map field with empty bytes", &pb.MessageWithMap{ByteMapping: map[bool][]byte{true: []byte{}}}},
-
-	{"map field with big entry", &pb.MessageWithMap{NameMapping: map[int32]string{8: strings.Repeat("x", 125)}}},
-	{"map field with big key and val", &pb.MessageWithMap{StrToStr: map[string]string{strings.Repeat("x", 70): strings.Repeat("y", 70)}}},
-	{"map field with big numeric key", &pb.MessageWithMap{NameMapping: map[int32]string{0xf00d: "om nom nom"}}},
-
-	{"oneof not set", &pb.Oneof{}},
-	{"oneof bool", &pb.Oneof{Union: &pb.Oneof_F_Bool{true}}},
-	{"oneof zero int32", &pb.Oneof{Union: &pb.Oneof_F_Int32{0}}},
-	{"oneof big int32", &pb.Oneof{Union: &pb.Oneof_F_Int32{1 << 20}}},
-	{"oneof int64", &pb.Oneof{Union: &pb.Oneof_F_Int64{42}}},
-	{"oneof fixed32", &pb.Oneof{Union: &pb.Oneof_F_Fixed32{43}}},
-	{"oneof fixed64", &pb.Oneof{Union: &pb.Oneof_F_Fixed64{44}}},
-	{"oneof uint32", &pb.Oneof{Union: &pb.Oneof_F_Uint32{45}}},
-	{"oneof uint64", &pb.Oneof{Union: &pb.Oneof_F_Uint64{46}}},
-	{"oneof float", &pb.Oneof{Union: &pb.Oneof_F_Float{47.1}}},
-	{"oneof double", &pb.Oneof{Union: &pb.Oneof_F_Double{48.9}}},
-	{"oneof string", &pb.Oneof{Union: &pb.Oneof_F_String{"Rhythmic Fman"}}},
-	{"oneof bytes", &pb.Oneof{Union: &pb.Oneof_F_Bytes{[]byte("let go")}}},
-	{"oneof sint32", &pb.Oneof{Union: &pb.Oneof_F_Sint32{50}}},
-	{"oneof sint64", &pb.Oneof{Union: &pb.Oneof_F_Sint64{51}}},
-	{"oneof enum", &pb.Oneof{Union: &pb.Oneof_F_Enum{pb.MyMessage_BLUE}}},
-	{"message for oneof", &pb.GoTestField{Label: String("k"), Type: String("v")}},
-	{"oneof message", &pb.Oneof{Union: &pb.Oneof_F_Message{&pb.GoTestField{Label: String("k"), Type: String("v")}}}},
-	{"oneof group", &pb.Oneof{Union: &pb.Oneof_FGroup{&pb.Oneof_F_Group{X: Int32(52)}}}},
-	{"oneof largest tag", &pb.Oneof{Union: &pb.Oneof_F_Largest_Tag{1}}},
-	{"multiple oneofs", &pb.Oneof{Union: &pb.Oneof_F_Int32{1}, Tormato: &pb.Oneof_Value{2}}},
-
-	{"non-pointer message", nonptrMessage{}},
-	{"custom message with embedding", &messageWithEmbedding{&pb.OtherMessage{}}},
-}
-
-func TestSize(t *testing.T) {
-	for _, tc := range SizeTests {
-		size := Size(tc.pb)
-		b, err := Marshal(tc.pb)
-		if err != nil {
-			t.Errorf("%v: Marshal failed: %v", tc.desc, err)
-			continue
-		}
-		if size != len(b) {
-			t.Errorf("%v: Size(%v) = %d, want %d", tc.desc, tc.pb, size, len(b))
-			t.Logf("%v: bytes: %#v", tc.desc, b)
-		}
-	}
-}
diff --git a/vendor/github.com/golang/protobuf/proto/table_marshal.go b/vendor/github.com/golang/protobuf/proto/table_marshal.go
deleted file mode 100644
index be7b2428c..000000000
--- a/vendor/github.com/golang/protobuf/proto/table_marshal.go
+++ /dev/null
@@ -1,2685 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2016 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package proto
-
-import (
-	"errors"
-	"fmt"
-	"math"
-	"reflect"
-	"sort"
-	"strconv"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"unicode/utf8"
-)
-
-// a sizer takes a pointer to a field and the size of its tag, computes the size of
-// the encoded data.
-type sizer func(pointer, int) int
-
-// a marshaler takes a byte slice, a pointer to a field, and its tag (in wire format),
-// marshals the field to the end of the slice, returns the slice and error (if any).
-type marshaler func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error)
-
-// marshalInfo is the information used for marshaling a message.
-type marshalInfo struct {
-	typ          reflect.Type
-	fields       []*marshalFieldInfo
-	unrecognized field                      // offset of XXX_unrecognized
-	extensions   field                      // offset of XXX_InternalExtensions
-	v1extensions field                      // offset of XXX_extensions
-	sizecache    field                      // offset of XXX_sizecache
-	initialized  int32                      // 0 -- only typ is set, 1 -- fully initialized
-	messageset   bool                       // uses message set wire format
-	hasmarshaler bool                       // has custom marshaler
-	sync.RWMutex                            // protect extElems map, also for initialization
-	extElems     map[int32]*marshalElemInfo // info of extension elements
-}
-
-// marshalFieldInfo is the information used for marshaling a field of a message.
-type marshalFieldInfo struct {
-	field      field
-	wiretag    uint64 // tag in wire format
-	tagsize    int    // size of tag in wire format
-	sizer      sizer
-	marshaler  marshaler
-	isPointer  bool
-	required   bool                              // field is required
-	name       string                            // name of the field, for error reporting
-	oneofElems map[reflect.Type]*marshalElemInfo // info of oneof elements
-}
-
-// marshalElemInfo is the information used for marshaling an extension or oneof element.
-type marshalElemInfo struct {
-	wiretag   uint64 // tag in wire format
-	tagsize   int    // size of tag in wire format
-	sizer     sizer
-	marshaler marshaler
-	isptr     bool // elem is pointer typed, thus interface of this type is a direct interface (extension only)
-}
-
-var (
-	marshalInfoMap  = map[reflect.Type]*marshalInfo{}
-	marshalInfoLock sync.Mutex
-)
-
-// getMarshalInfo returns the information to marshal a given type of message.
-// The info it returns may not necessarily initialized.
-// t is the type of the message (NOT the pointer to it).
-func getMarshalInfo(t reflect.Type) *marshalInfo {
-	marshalInfoLock.Lock()
-	u, ok := marshalInfoMap[t]
-	if !ok {
-		u = &marshalInfo{typ: t}
-		marshalInfoMap[t] = u
-	}
-	marshalInfoLock.Unlock()
-	return u
-}
-
-// Size is the entry point from generated code,
-// and should be ONLY called by generated code.
-// It computes the size of encoded data of msg.
-// a is a pointer to a place to store cached marshal info.
-func (a *InternalMessageInfo) Size(msg Message) int {
-	u := getMessageMarshalInfo(msg, a)
-	ptr := toPointer(&msg)
-	if ptr.isNil() {
-		// We get here if msg is a typed nil ((*SomeMessage)(nil)),
-		// so it satisfies the interface, and msg == nil wouldn't
-		// catch it. We don't want crash in this case.
-		return 0
-	}
-	return u.size(ptr)
-}
-
-// Marshal is the entry point from generated code,
-// and should be ONLY called by generated code.
-// It marshals msg to the end of b.
-// a is a pointer to a place to store cached marshal info.
-func (a *InternalMessageInfo) Marshal(b []byte, msg Message, deterministic bool) ([]byte, error) {
-	u := getMessageMarshalInfo(msg, a)
-	ptr := toPointer(&msg)
-	if ptr.isNil() {
-		// We get here if msg is a typed nil ((*SomeMessage)(nil)),
-		// so it satisfies the interface, and msg == nil wouldn't
-		// catch it. We don't want crash in this case.
-		return b, ErrNil
-	}
-	return u.marshal(b, ptr, deterministic)
-}
-
-func getMessageMarshalInfo(msg interface{}, a *InternalMessageInfo) *marshalInfo {
-	// u := a.marshal, but atomically.
-	// We use an atomic here to ensure memory consistency.
-	u := atomicLoadMarshalInfo(&a.marshal)
-	if u == nil {
-		// Get marshal information from type of message.
-		t := reflect.ValueOf(msg).Type()
-		if t.Kind() != reflect.Ptr {
-			panic(fmt.Sprintf("cannot handle non-pointer message type %v", t))
-		}
-		u = getMarshalInfo(t.Elem())
-		// Store it in the cache for later users.
-		// a.marshal = u, but atomically.
-		atomicStoreMarshalInfo(&a.marshal, u)
-	}
-	return u
-}
-
-// size is the main function to compute the size of the encoded data of a message.
-// ptr is the pointer to the message.
-func (u *marshalInfo) size(ptr pointer) int {
-	if atomic.LoadInt32(&u.initialized) == 0 {
-		u.computeMarshalInfo()
-	}
-
-	// If the message can marshal itself, let it do it, for compatibility.
-	// NOTE: This is not efficient.
-	if u.hasmarshaler {
-		m := ptr.asPointerTo(u.typ).Interface().(Marshaler)
-		b, _ := m.Marshal()
-		return len(b)
-	}
-
-	n := 0
-	for _, f := range u.fields {
-		if f.isPointer && ptr.offset(f.field).getPointer().isNil() {
-			// nil pointer always marshals to nothing
-			continue
-		}
-		n += f.sizer(ptr.offset(f.field), f.tagsize)
-	}
-	if u.extensions.IsValid() {
-		e := ptr.offset(u.extensions).toExtensions()
-		if u.messageset {
-			n += u.sizeMessageSet(e)
-		} else {
-			n += u.sizeExtensions(e)
-		}
-	}
-	if u.v1extensions.IsValid() {
-		m := *ptr.offset(u.v1extensions).toOldExtensions()
-		n += u.sizeV1Extensions(m)
-	}
-	if u.unrecognized.IsValid() {
-		s := *ptr.offset(u.unrecognized).toBytes()
-		n += len(s)
-	}
-	// cache the result for use in marshal
-	if u.sizecache.IsValid() {
-		atomic.StoreInt32(ptr.offset(u.sizecache).toInt32(), int32(n))
-	}
-	return n
-}
-
-// cachedsize gets the size from cache. If there is no cache (i.e. message is not generated),
-// fall back to compute the size.
-func (u *marshalInfo) cachedsize(ptr pointer) int {
-	if u.sizecache.IsValid() {
-		return int(atomic.LoadInt32(ptr.offset(u.sizecache).toInt32()))
-	}
-	return u.size(ptr)
-}
-
-// marshal is the main function to marshal a message. It takes a byte slice and appends
-// the encoded data to the end of the slice, returns the slice and error (if any).
-// ptr is the pointer to the message.
-// If deterministic is true, map is marshaled in deterministic order.
-func (u *marshalInfo) marshal(b []byte, ptr pointer, deterministic bool) ([]byte, error) {
-	if atomic.LoadInt32(&u.initialized) == 0 {
-		u.computeMarshalInfo()
-	}
-
-	// If the message can marshal itself, let it do it, for compatibility.
-	// NOTE: This is not efficient.
-	if u.hasmarshaler {
-		m := ptr.asPointerTo(u.typ).Interface().(Marshaler)
-		b1, err := m.Marshal()
-		b = append(b, b1...)
-		return b, err
-	}
-
-	var err, errreq error
-	// The old marshaler encodes extensions at beginning.
-	if u.extensions.IsValid() {
-		e := ptr.offset(u.extensions).toExtensions()
-		if u.messageset {
-			b, err = u.appendMessageSet(b, e, deterministic)
-		} else {
-			b, err = u.appendExtensions(b, e, deterministic)
-		}
-		if err != nil {
-			return b, err
-		}
-	}
-	if u.v1extensions.IsValid() {
-		m := *ptr.offset(u.v1extensions).toOldExtensions()
-		b, err = u.appendV1Extensions(b, m, deterministic)
-		if err != nil {
-			return b, err
-		}
-	}
-	for _, f := range u.fields {
-		if f.required && errreq == nil {
-			if ptr.offset(f.field).getPointer().isNil() {
-				// Required field is not set.
-				// We record the error but keep going, to give a complete marshaling.
-				errreq = &RequiredNotSetError{f.name}
-				continue
-			}
-		}
-		if f.isPointer && ptr.offset(f.field).getPointer().isNil() {
-			// nil pointer always marshals to nothing
-			continue
-		}
-		b, err = f.marshaler(b, ptr.offset(f.field), f.wiretag, deterministic)
-		if err != nil {
-			if err1, ok := err.(*RequiredNotSetError); ok {
-				// Required field in submessage is not set.
-				// We record the error but keep going, to give a complete marshaling.
-				if errreq == nil {
-					errreq = &RequiredNotSetError{f.name + "." + err1.field}
-				}
-				continue
-			}
-			if err == errRepeatedHasNil {
-				err = errors.New("proto: repeated field " + f.name + " has nil element")
-			}
-			if err == errInvalidUTF8 {
-				fullName := revProtoTypes[reflect.PtrTo(u.typ)] + "." + f.name
-				err = fmt.Errorf("proto: string field %q contains invalid UTF-8", fullName)
-			}
-			return b, err
-		}
-	}
-	if u.unrecognized.IsValid() {
-		s := *ptr.offset(u.unrecognized).toBytes()
-		b = append(b, s...)
-	}
-	return b, errreq
-}
-
-// computeMarshalInfo initializes the marshal info.
-func (u *marshalInfo) computeMarshalInfo() {
-	u.Lock()
-	defer u.Unlock()
-	if u.initialized != 0 { // non-atomic read is ok as it is protected by the lock
-		return
-	}
-
-	t := u.typ
-	u.unrecognized = invalidField
-	u.extensions = invalidField
-	u.v1extensions = invalidField
-	u.sizecache = invalidField
-
-	// If the message can marshal itself, let it do it, for compatibility.
-	// NOTE: This is not efficient.
-	if reflect.PtrTo(t).Implements(marshalerType) {
-		u.hasmarshaler = true
-		atomic.StoreInt32(&u.initialized, 1)
-		return
-	}
-
-	// get oneof implementers
-	var oneofImplementers []interface{}
-	if m, ok := reflect.Zero(reflect.PtrTo(t)).Interface().(oneofMessage); ok {
-		_, _, _, oneofImplementers = m.XXX_OneofFuncs()
-	}
-
-	n := t.NumField()
-
-	// deal with XXX fields first
-	for i := 0; i < t.NumField(); i++ {
-		f := t.Field(i)
-		if !strings.HasPrefix(f.Name, "XXX_") {
-			continue
-		}
-		switch f.Name {
-		case "XXX_sizecache":
-			u.sizecache = toField(&f)
-		case "XXX_unrecognized":
-			u.unrecognized = toField(&f)
-		case "XXX_InternalExtensions":
-			u.extensions = toField(&f)
-			u.messageset = f.Tag.Get("protobuf_messageset") == "1"
-		case "XXX_extensions":
-			u.v1extensions = toField(&f)
-		case "XXX_NoUnkeyedLiteral":
-			// nothing to do
-		default:
-			panic("unknown XXX field: " + f.Name)
-		}
-		n--
-	}
-
-	// normal fields
-	fields := make([]marshalFieldInfo, n) // batch allocation
-	u.fields = make([]*marshalFieldInfo, 0, n)
-	for i, j := 0, 0; i < t.NumField(); i++ {
-		f := t.Field(i)
-
-		if strings.HasPrefix(f.Name, "XXX_") {
-			continue
-		}
-		field := &fields[j]
-		j++
-		field.name = f.Name
-		u.fields = append(u.fields, field)
-		if f.Tag.Get("protobuf_oneof") != "" {
-			field.computeOneofFieldInfo(&f, oneofImplementers)
-			continue
-		}
-		if f.Tag.Get("protobuf") == "" {
-			// field has no tag (not in generated message), ignore it
-			u.fields = u.fields[:len(u.fields)-1]
-			j--
-			continue
-		}
-		field.computeMarshalFieldInfo(&f)
-	}
-
-	// fields are marshaled in tag order on the wire.
-	sort.Sort(byTag(u.fields))
-
-	atomic.StoreInt32(&u.initialized, 1)
-}
-
-// helper for sorting fields by tag
-type byTag []*marshalFieldInfo
-
-func (a byTag) Len() int           { return len(a) }
-func (a byTag) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
-func (a byTag) Less(i, j int) bool { return a[i].wiretag < a[j].wiretag }
-
-// getExtElemInfo returns the information to marshal an extension element.
-// The info it returns is initialized.
-func (u *marshalInfo) getExtElemInfo(desc *ExtensionDesc) *marshalElemInfo {
-	// get from cache first
-	u.RLock()
-	e, ok := u.extElems[desc.Field]
-	u.RUnlock()
-	if ok {
-		return e
-	}
-
-	t := reflect.TypeOf(desc.ExtensionType) // pointer or slice to basic type or struct
-	tags := strings.Split(desc.Tag, ",")
-	tag, err := strconv.Atoi(tags[1])
-	if err != nil {
-		panic("tag is not an integer")
-	}
-	wt := wiretype(tags[0])
-	sizer, marshaler := typeMarshaler(t, tags, false, false)
-	e = &marshalElemInfo{
-		wiretag:   uint64(tag)<<3 | wt,
-		tagsize:   SizeVarint(uint64(tag) << 3),
-		sizer:     sizer,
-		marshaler: marshaler,
-		isptr:     t.Kind() == reflect.Ptr,
-	}
-
-	// update cache
-	u.Lock()
-	if u.extElems == nil {
-		u.extElems = make(map[int32]*marshalElemInfo)
-	}
-	u.extElems[desc.Field] = e
-	u.Unlock()
-	return e
-}
-
-// computeMarshalFieldInfo fills up the information to marshal a field.
-func (fi *marshalFieldInfo) computeMarshalFieldInfo(f *reflect.StructField) {
-	// parse protobuf tag of the field.
-	// tag has format of "bytes,49,opt,name=foo,def=hello!"
-	tags := strings.Split(f.Tag.Get("protobuf"), ",")
-	if tags[0] == "" {
-		return
-	}
-	tag, err := strconv.Atoi(tags[1])
-	if err != nil {
-		panic("tag is not an integer")
-	}
-	wt := wiretype(tags[0])
-	if tags[2] == "req" {
-		fi.required = true
-	}
-	fi.setTag(f, tag, wt)
-	fi.setMarshaler(f, tags)
-}
-
-func (fi *marshalFieldInfo) computeOneofFieldInfo(f *reflect.StructField, oneofImplementers []interface{}) {
-	fi.field = toField(f)
-	fi.wiretag = 1<<31 - 1 // Use a large tag number, make oneofs sorted at the end. This tag will not appear on the wire.
-	fi.isPointer = true
-	fi.sizer, fi.marshaler = makeOneOfMarshaler(fi, f)
-	fi.oneofElems = make(map[reflect.Type]*marshalElemInfo)
-
-	ityp := f.Type // interface type
-	for _, o := range oneofImplementers {
-		t := reflect.TypeOf(o)
-		if !t.Implements(ityp) {
-			continue
-		}
-		sf := t.Elem().Field(0) // oneof implementer is a struct with a single field
-		tags := strings.Split(sf.Tag.Get("protobuf"), ",")
-		tag, err := strconv.Atoi(tags[1])
-		if err != nil {
-			panic("tag is not an integer")
-		}
-		wt := wiretype(tags[0])
-		sizer, marshaler := typeMarshaler(sf.Type, tags, false, true) // oneof should not omit any zero value
-		fi.oneofElems[t.Elem()] = &marshalElemInfo{
-			wiretag:   uint64(tag)<<3 | wt,
-			tagsize:   SizeVarint(uint64(tag) << 3),
-			sizer:     sizer,
-			marshaler: marshaler,
-		}
-	}
-}
-
-type oneofMessage interface {
-	XXX_OneofFuncs() (func(Message, *Buffer) error, func(Message, int, int, *Buffer) (bool, error), func(Message) int, []interface{})
-}
-
-// wiretype returns the wire encoding of the type.
-func wiretype(encoding string) uint64 {
-	switch encoding {
-	case "fixed32":
-		return WireFixed32
-	case "fixed64":
-		return WireFixed64
-	case "varint", "zigzag32", "zigzag64":
-		return WireVarint
-	case "bytes":
-		return WireBytes
-	case "group":
-		return WireStartGroup
-	}
-	panic("unknown wire type " + encoding)
-}
-
-// setTag fills up the tag (in wire format) and its size in the info of a field.
-func (fi *marshalFieldInfo) setTag(f *reflect.StructField, tag int, wt uint64) {
-	fi.field = toField(f)
-	fi.wiretag = uint64(tag)<<3 | wt
-	fi.tagsize = SizeVarint(uint64(tag) << 3)
-}
-
-// setMarshaler fills up the sizer and marshaler in the info of a field.
-func (fi *marshalFieldInfo) setMarshaler(f *reflect.StructField, tags []string) {
-	switch f.Type.Kind() {
-	case reflect.Map:
-		// map field
-		fi.isPointer = true
-		fi.sizer, fi.marshaler = makeMapMarshaler(f)
-		return
-	case reflect.Ptr, reflect.Slice:
-		fi.isPointer = true
-	}
-	fi.sizer, fi.marshaler = typeMarshaler(f.Type, tags, true, false)
-}
-
-// typeMarshaler returns the sizer and marshaler of a given field.
-// t is the type of the field.
-// tags is the generated "protobuf" tag of the field.
-// If nozero is true, zero value is not marshaled to the wire.
-// If oneof is true, it is a oneof field.
-func typeMarshaler(t reflect.Type, tags []string, nozero, oneof bool) (sizer, marshaler) {
-	encoding := tags[0]
-
-	pointer := false
-	slice := false
-	if t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8 {
-		slice = true
-		t = t.Elem()
-	}
-	if t.Kind() == reflect.Ptr {
-		pointer = true
-		t = t.Elem()
-	}
-
-	packed := false
-	proto3 := false
-	for i := 2; i < len(tags); i++ {
-		if tags[i] == "packed" {
-			packed = true
-		}
-		if tags[i] == "proto3" {
-			proto3 = true
-		}
-	}
-
-	switch t.Kind() {
-	case reflect.Bool:
-		if pointer {
-			return sizeBoolPtr, appendBoolPtr
-		}
-		if slice {
-			if packed {
-				return sizeBoolPackedSlice, appendBoolPackedSlice
-			}
-			return sizeBoolSlice, appendBoolSlice
-		}
-		if nozero {
-			return sizeBoolValueNoZero, appendBoolValueNoZero
-		}
-		return sizeBoolValue, appendBoolValue
-	case reflect.Uint32:
-		switch encoding {
-		case "fixed32":
-			if pointer {
-				return sizeFixed32Ptr, appendFixed32Ptr
-			}
-			if slice {
-				if packed {
-					return sizeFixed32PackedSlice, appendFixed32PackedSlice
-				}
-				return sizeFixed32Slice, appendFixed32Slice
-			}
-			if nozero {
-				return sizeFixed32ValueNoZero, appendFixed32ValueNoZero
-			}
-			return sizeFixed32Value, appendFixed32Value
-		case "varint":
-			if pointer {
-				return sizeVarint32Ptr, appendVarint32Ptr
-			}
-			if slice {
-				if packed {
-					return sizeVarint32PackedSlice, appendVarint32PackedSlice
-				}
-				return sizeVarint32Slice, appendVarint32Slice
-			}
-			if nozero {
-				return sizeVarint32ValueNoZero, appendVarint32ValueNoZero
-			}
-			return sizeVarint32Value, appendVarint32Value
-		}
-	case reflect.Int32:
-		switch encoding {
-		case "fixed32":
-			if pointer {
-				return sizeFixedS32Ptr, appendFixedS32Ptr
-			}
-			if slice {
-				if packed {
-					return sizeFixedS32PackedSlice, appendFixedS32PackedSlice
-				}
-				return sizeFixedS32Slice, appendFixedS32Slice
-			}
-			if nozero {
-				return sizeFixedS32ValueNoZero, appendFixedS32ValueNoZero
-			}
-			return sizeFixedS32Value, appendFixedS32Value
-		case "varint":
-			if pointer {
-				return sizeVarintS32Ptr, appendVarintS32Ptr
-			}
-			if slice {
-				if packed {
-					return sizeVarintS32PackedSlice, appendVarintS32PackedSlice
-				}
-				return sizeVarintS32Slice, appendVarintS32Slice
-			}
-			if nozero {
-				return sizeVarintS32ValueNoZero, appendVarintS32ValueNoZero
-			}
-			return sizeVarintS32Value, appendVarintS32Value
-		case "zigzag32":
-			if pointer {
-				return sizeZigzag32Ptr, appendZigzag32Ptr
-			}
-			if slice {
-				if packed {
-					return sizeZigzag32PackedSlice, appendZigzag32PackedSlice
-				}
-				return sizeZigzag32Slice, appendZigzag32Slice
-			}
-			if nozero {
-				return sizeZigzag32ValueNoZero, appendZigzag32ValueNoZero
-			}
-			return sizeZigzag32Value, appendZigzag32Value
-		}
-	case reflect.Uint64:
-		switch encoding {
-		case "fixed64":
-			if pointer {
-				return sizeFixed64Ptr, appendFixed64Ptr
-			}
-			if slice {
-				if packed {
-					return sizeFixed64PackedSlice, appendFixed64PackedSlice
-				}
-				return sizeFixed64Slice, appendFixed64Slice
-			}
-			if nozero {
-				return sizeFixed64ValueNoZero, appendFixed64ValueNoZero
-			}
-			return sizeFixed64Value, appendFixed64Value
-		case "varint":
-			if pointer {
-				return sizeVarint64Ptr, appendVarint64Ptr
-			}
-			if slice {
-				if packed {
-					return sizeVarint64PackedSlice, appendVarint64PackedSlice
-				}
-				return sizeVarint64Slice, appendVarint64Slice
-			}
-			if nozero {
-				return sizeVarint64ValueNoZero, appendVarint64ValueNoZero
-			}
-			return sizeVarint64Value, appendVarint64Value
-		}
-	case reflect.Int64:
-		switch encoding {
-		case "fixed64":
-			if pointer {
-				return sizeFixedS64Ptr, appendFixedS64Ptr
-			}
-			if slice {
-				if packed {
-					return sizeFixedS64PackedSlice, appendFixedS64PackedSlice
-				}
-				return sizeFixedS64Slice, appendFixedS64Slice
-			}
-			if nozero {
-				return sizeFixedS64ValueNoZero, appendFixedS64ValueNoZero
-			}
-			return sizeFixedS64Value, appendFixedS64Value
-		case "varint":
-			if pointer {
-				return sizeVarintS64Ptr, appendVarintS64Ptr
-			}
-			if slice {
-				if packed {
-					return sizeVarintS64PackedSlice, appendVarintS64PackedSlice
-				}
-				return sizeVarintS64Slice, appendVarintS64Slice
-			}
-			if nozero {
-				return sizeVarintS64ValueNoZero, appendVarintS64ValueNoZero
-			}
-			return sizeVarintS64Value, appendVarintS64Value
-		case "zigzag64":
-			if pointer {
-				return sizeZigzag64Ptr, appendZigzag64Ptr
-			}
-			if slice {
-				if packed {
-					return sizeZigzag64PackedSlice, appendZigzag64PackedSlice
-				}
-				return sizeZigzag64Slice, appendZigzag64Slice
-			}
-			if nozero {
-				return sizeZigzag64ValueNoZero, appendZigzag64ValueNoZero
-			}
-			return sizeZigzag64Value, appendZigzag64Value
-		}
-	case reflect.Float32:
-		if pointer {
-			return sizeFloat32Ptr, appendFloat32Ptr
-		}
-		if slice {
-			if packed {
-				return sizeFloat32PackedSlice, appendFloat32PackedSlice
-			}
-			return sizeFloat32Slice, appendFloat32Slice
-		}
-		if nozero {
-			return sizeFloat32ValueNoZero, appendFloat32ValueNoZero
-		}
-		return sizeFloat32Value, appendFloat32Value
-	case reflect.Float64:
-		if pointer {
-			return sizeFloat64Ptr, appendFloat64Ptr
-		}
-		if slice {
-			if packed {
-				return sizeFloat64PackedSlice, appendFloat64PackedSlice
-			}
-			return sizeFloat64Slice, appendFloat64Slice
-		}
-		if nozero {
-			return sizeFloat64ValueNoZero, appendFloat64ValueNoZero
-		}
-		return sizeFloat64Value, appendFloat64Value
-	case reflect.String:
-		if pointer {
-			return sizeStringPtr, appendStringPtr
-		}
-		if slice {
-			return sizeStringSlice, appendStringSlice
-		}
-		if nozero {
-			return sizeStringValueNoZero, appendStringValueNoZero
-		}
-		return sizeStringValue, appendStringValue
-	case reflect.Slice:
-		if slice {
-			return sizeBytesSlice, appendBytesSlice
-		}
-		if oneof {
-			// Oneof bytes field may also have "proto3" tag.
-			// We want to marshal it as a oneof field. Do this
-			// check before the proto3 check.
-			return sizeBytesOneof, appendBytesOneof
-		}
-		if proto3 {
-			return sizeBytes3, appendBytes3
-		}
-		return sizeBytes, appendBytes
-	case reflect.Struct:
-		switch encoding {
-		case "group":
-			if slice {
-				return makeGroupSliceMarshaler(getMarshalInfo(t))
-			}
-			return makeGroupMarshaler(getMarshalInfo(t))
-		case "bytes":
-			if slice {
-				return makeMessageSliceMarshaler(getMarshalInfo(t))
-			}
-			return makeMessageMarshaler(getMarshalInfo(t))
-		}
-	}
-	panic(fmt.Sprintf("unknown or mismatched type: type: %v, wire type: %v", t, encoding))
-}
-
-// Below are functions to size/marshal a specific type of a field.
-// They are stored in the field's info, and called by function pointers.
-// They have type sizer or marshaler.
-
-func sizeFixed32Value(_ pointer, tagsize int) int {
-	return 4 + tagsize
-}
-func sizeFixed32ValueNoZero(ptr pointer, tagsize int) int {
-	v := *ptr.toUint32()
-	if v == 0 {
-		return 0
-	}
-	return 4 + tagsize
-}
-func sizeFixed32Ptr(ptr pointer, tagsize int) int {
-	p := *ptr.toUint32Ptr()
-	if p == nil {
-		return 0
-	}
-	return 4 + tagsize
-}
-func sizeFixed32Slice(ptr pointer, tagsize int) int {
-	s := *ptr.toUint32Slice()
-	return (4 + tagsize) * len(s)
-}
-func sizeFixed32PackedSlice(ptr pointer, tagsize int) int {
-	s := *ptr.toUint32Slice()
-	if len(s) == 0 {
-		return 0
-	}
-	return 4*len(s) + SizeVarint(uint64(4*len(s))) + tagsize
-}
-func sizeFixedS32Value(_ pointer, tagsize int) int {
-	return 4 + tagsize
-}
-func sizeFixedS32ValueNoZero(ptr pointer, tagsize int) int {
-	v := *ptr.toInt32()
-	if v == 0 {
-		return 0
-	}
-	return 4 + tagsize
-}
-func sizeFixedS32Ptr(ptr pointer, tagsize int) int {
-	p := ptr.getInt32Ptr()
-	if p == nil {
-		return 0
-	}
-	return 4 + tagsize
-}
-func sizeFixedS32Slice(ptr pointer, tagsize int) int {
-	s := ptr.getInt32Slice()
-	return (4 + tagsize) * len(s)
-}
-func sizeFixedS32PackedSlice(ptr pointer, tagsize int) int {
-	s := ptr.getInt32Slice()
-	if len(s) == 0 {
-		return 0
-	}
-	return 4*len(s) + SizeVarint(uint64(4*len(s))) + tagsize
-}
-func sizeFloat32Value(_ pointer, tagsize int) int {
-	return 4 + tagsize
-}
-func sizeFloat32ValueNoZero(ptr pointer, tagsize int) int {
-	v := math.Float32bits(*ptr.toFloat32())
-	if v == 0 {
-		return 0
-	}
-	return 4 + tagsize
-}
-func sizeFloat32Ptr(ptr pointer, tagsize int) int {
-	p := *ptr.toFloat32Ptr()
-	if p == nil {
-		return 0
-	}
-	return 4 + tagsize
-}
-func sizeFloat32Slice(ptr pointer, tagsize int) int {
-	s := *ptr.toFloat32Slice()
-	return (4 + tagsize) * len(s)
-}
-func sizeFloat32PackedSlice(ptr pointer, tagsize int) int {
-	s := *ptr.toFloat32Slice()
-	if len(s) == 0 {
-		return 0
-	}
-	return 4*len(s) + SizeVarint(uint64(4*len(s))) + tagsize
-}
-func sizeFixed64Value(_ pointer, tagsize int) int {
-	return 8 + tagsize
-}
-func sizeFixed64ValueNoZero(ptr pointer, tagsize int) int {
-	v := *ptr.toUint64()
-	if v == 0 {
-		return 0
-	}
-	return 8 + tagsize
-}
-func sizeFixed64Ptr(ptr pointer, tagsize int) int {
-	p := *ptr.toUint64Ptr()
-	if p == nil {
-		return 0
-	}
-	return 8 + tagsize
-}
-func sizeFixed64Slice(ptr pointer, tagsize int) int {
-	s := *ptr.toUint64Slice()
-	return (8 + tagsize) * len(s)
-}
-func sizeFixed64PackedSlice(ptr pointer, tagsize int) int {
-	s := *ptr.toUint64Slice()
-	if len(s) == 0 {
-		return 0
-	}
-	return 8*len(s) + SizeVarint(uint64(8*len(s))) + tagsize
-}
-func sizeFixedS64Value(_ pointer, tagsize int) int {
-	return 8 + tagsize
-}
-func sizeFixedS64ValueNoZero(ptr pointer, tagsize int) int {
-	v := *ptr.toInt64()
-	if v == 0 {
-		return 0
-	}
-	return 8 + tagsize
-}
-func sizeFixedS64Ptr(ptr pointer, tagsize int) int {
-	p := *ptr.toInt64Ptr()
-	if p == nil {
-		return 0
-	}
-	return 8 + tagsize
-}
-func sizeFixedS64Slice(ptr pointer, tagsize int) int {
-	s := *ptr.toInt64Slice()
-	return (8 + tagsize) * len(s)
-}
-func sizeFixedS64PackedSlice(ptr pointer, tagsize int) int {
-	s := *ptr.toInt64Slice()
-	if len(s) == 0 {
-		return 0
-	}
-	return 8*len(s) + SizeVarint(uint64(8*len(s))) + tagsize
-}
-func sizeFloat64Value(_ pointer, tagsize int) int {
-	return 8 + tagsize
-}
-func sizeFloat64ValueNoZero(ptr pointer, tagsize int) int {
-	v := math.Float64bits(*ptr.toFloat64())
-	if v == 0 {
-		return 0
-	}
-	return 8 + tagsize
-}
-func sizeFloat64Ptr(ptr pointer, tagsize int) int {
-	p := *ptr.toFloat64Ptr()
-	if p == nil {
-		return 0
-	}
-	return 8 + tagsize
-}
-func sizeFloat64Slice(ptr pointer, tagsize int) int {
-	s := *ptr.toFloat64Slice()
-	return (8 + tagsize) * len(s)
-}
-func sizeFloat64PackedSlice(ptr pointer, tagsize int) int {
-	s := *ptr.toFloat64Slice()
-	if len(s) == 0 {
-		return 0
-	}
-	return 8*len(s) + SizeVarint(uint64(8*len(s))) + tagsize
-}
-func sizeVarint32Value(ptr pointer, tagsize int) int {
-	v := *ptr.toUint32()
-	return SizeVarint(uint64(v)) + tagsize
-}
-func sizeVarint32ValueNoZero(ptr pointer, tagsize int) int {
-	v := *ptr.toUint32()
-	if v == 0 {
-		return 0
-	}
-	return SizeVarint(uint64(v)) + tagsize
-}
-func sizeVarint32Ptr(ptr pointer, tagsize int) int {
-	p := *ptr.toUint32Ptr()
-	if p == nil {
-		return 0
-	}
-	return SizeVarint(uint64(*p)) + tagsize
-}
-func sizeVarint32Slice(ptr pointer, tagsize int) int {
-	s := *ptr.toUint32Slice()
-	n := 0
-	for _, v := range s {
-		n += SizeVarint(uint64(v)) + tagsize
-	}
-	return n
-}
-func sizeVarint32PackedSlice(ptr pointer, tagsize int) int {
-	s := *ptr.toUint32Slice()
-	if len(s) == 0 {
-		return 0
-	}
-	n := 0
-	for _, v := range s {
-		n += SizeVarint(uint64(v))
-	}
-	return n + SizeVarint(uint64(n)) + tagsize
-}
-func sizeVarintS32Value(ptr pointer, tagsize int) int {
-	v := *ptr.toInt32()
-	return SizeVarint(uint64(v)) + tagsize
-}
-func sizeVarintS32ValueNoZero(ptr pointer, tagsize int) int {
-	v := *ptr.toInt32()
-	if v == 0 {
-		return 0
-	}
-	return SizeVarint(uint64(v)) + tagsize
-}
-func sizeVarintS32Ptr(ptr pointer, tagsize int) int {
-	p := ptr.getInt32Ptr()
-	if p == nil {
-		return 0
-	}
-	return SizeVarint(uint64(*p)) + tagsize
-}
-func sizeVarintS32Slice(ptr pointer, tagsize int) int {
-	s := ptr.getInt32Slice()
-	n := 0
-	for _, v := range s {
-		n += SizeVarint(uint64(v)) + tagsize
-	}
-	return n
-}
-func sizeVarintS32PackedSlice(ptr pointer, tagsize int) int {
-	s := ptr.getInt32Slice()
-	if len(s) == 0 {
-		return 0
-	}
-	n := 0
-	for _, v := range s {
-		n += SizeVarint(uint64(v))
-	}
-	return n + SizeVarint(uint64(n)) + tagsize
-}
-func sizeVarint64Value(ptr pointer, tagsize int) int {
-	v := *ptr.toUint64()
-	return SizeVarint(v) + tagsize
-}
-func sizeVarint64ValueNoZero(ptr pointer, tagsize int) int {
-	v := *ptr.toUint64()
-	if v == 0 {
-		return 0
-	}
-	return SizeVarint(v) + tagsize
-}
-func sizeVarint64Ptr(ptr pointer, tagsize int) int {
-	p := *ptr.toUint64Ptr()
-	if p == nil {
-		return 0
-	}
-	return SizeVarint(*p) + tagsize
-}
-func sizeVarint64Slice(ptr pointer, tagsize int) int {
-	s := *ptr.toUint64Slice()
-	n := 0
-	for _, v := range s {
-		n += SizeVarint(v) + tagsize
-	}
-	return n
-}
-func sizeVarint64PackedSlice(ptr pointer, tagsize int) int {
-	s := *ptr.toUint64Slice()
-	if len(s) == 0 {
-		return 0
-	}
-	n := 0
-	for _, v := range s {
-		n += SizeVarint(v)
-	}
-	return n + SizeVarint(uint64(n)) + tagsize
-}
-func sizeVarintS64Value(ptr pointer, tagsize int) int {
-	v := *ptr.toInt64()
-	return SizeVarint(uint64(v)) + tagsize
-}
-func sizeVarintS64ValueNoZero(ptr pointer, tagsize int) int {
-	v := *ptr.toInt64()
-	if v == 0 {
-		return 0
-	}
-	return SizeVarint(uint64(v)) + tagsize
-}
-func sizeVarintS64Ptr(ptr pointer, tagsize int) int {
-	p := *ptr.toInt64Ptr()
-	if p == nil {
-		return 0
-	}
-	return SizeVarint(uint64(*p)) + tagsize
-}
-func sizeVarintS64Slice(ptr pointer, tagsize int) int {
-	s := *ptr.toInt64Slice()
-	n := 0
-	for _, v := range s {
-		n += SizeVarint(uint64(v)) + tagsize
-	}
-	return n
-}
-func sizeVarintS64PackedSlice(ptr pointer, tagsize int) int {
-	s := *ptr.toInt64Slice()
-	if len(s) == 0 {
-		return 0
-	}
-	n := 0
-	for _, v := range s {
-		n += SizeVarint(uint64(v))
-	}
-	return n + SizeVarint(uint64(n)) + tagsize
-}
-func sizeZigzag32Value(ptr pointer, tagsize int) int {
-	v := *ptr.toInt32()
-	return SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
-}
-func sizeZigzag32ValueNoZero(ptr pointer, tagsize int) int {
-	v := *ptr.toInt32()
-	if v == 0 {
-		return 0
-	}
-	return SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
-}
-func sizeZigzag32Ptr(ptr pointer, tagsize int) int {
-	p := ptr.getInt32Ptr()
-	if p == nil {
-		return 0
-	}
-	v := *p
-	return SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
-}
-func sizeZigzag32Slice(ptr pointer, tagsize int) int {
-	s := ptr.getInt32Slice()
-	n := 0
-	for _, v := range s {
-		n += SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
-	}
-	return n
-}
-func sizeZigzag32PackedSlice(ptr pointer, tagsize int) int {
-	s := ptr.getInt32Slice()
-	if len(s) == 0 {
-		return 0
-	}
-	n := 0
-	for _, v := range s {
-		n += SizeVarint(uint64((uint32(v) << 1) ^ uint32((int32(v) >> 31))))
-	}
-	return n + SizeVarint(uint64(n)) + tagsize
-}
-func sizeZigzag64Value(ptr pointer, tagsize int) int {
-	v := *ptr.toInt64()
-	return SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
-}
-func sizeZigzag64ValueNoZero(ptr pointer, tagsize int) int {
-	v := *ptr.toInt64()
-	if v == 0 {
-		return 0
-	}
-	return SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
-}
-func sizeZigzag64Ptr(ptr pointer, tagsize int) int {
-	p := *ptr.toInt64Ptr()
-	if p == nil {
-		return 0
-	}
-	v := *p
-	return SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
-}
-func sizeZigzag64Slice(ptr pointer, tagsize int) int {
-	s := *ptr.toInt64Slice()
-	n := 0
-	for _, v := range s {
-		n += SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
-	}
-	return n
-}
-func sizeZigzag64PackedSlice(ptr pointer, tagsize int) int {
-	s := *ptr.toInt64Slice()
-	if len(s) == 0 {
-		return 0
-	}
-	n := 0
-	for _, v := range s {
-		n += SizeVarint(uint64(v<<1) ^ uint64((int64(v) >> 63)))
-	}
-	return n + SizeVarint(uint64(n)) + tagsize
-}
-func sizeBoolValue(_ pointer, tagsize int) int {
-	return 1 + tagsize
-}
-func sizeBoolValueNoZero(ptr pointer, tagsize int) int {
-	v := *ptr.toBool()
-	if !v {
-		return 0
-	}
-	return 1 + tagsize
-}
-func sizeBoolPtr(ptr pointer, tagsize int) int {
-	p := *ptr.toBoolPtr()
-	if p == nil {
-		return 0
-	}
-	return 1 + tagsize
-}
-func sizeBoolSlice(ptr pointer, tagsize int) int {
-	s := *ptr.toBoolSlice()
-	return (1 + tagsize) * len(s)
-}
-func sizeBoolPackedSlice(ptr pointer, tagsize int) int {
-	s := *ptr.toBoolSlice()
-	if len(s) == 0 {
-		return 0
-	}
-	return len(s) + SizeVarint(uint64(len(s))) + tagsize
-}
-func sizeStringValue(ptr pointer, tagsize int) int {
-	v := *ptr.toString()
-	return len(v) + SizeVarint(uint64(len(v))) + tagsize
-}
-func sizeStringValueNoZero(ptr pointer, tagsize int) int {
-	v := *ptr.toString()
-	if v == "" {
-		return 0
-	}
-	return len(v) + SizeVarint(uint64(len(v))) + tagsize
-}
-func sizeStringPtr(ptr pointer, tagsize int) int {
-	p := *ptr.toStringPtr()
-	if p == nil {
-		return 0
-	}
-	v := *p
-	return len(v) + SizeVarint(uint64(len(v))) + tagsize
-}
-func sizeStringSlice(ptr pointer, tagsize int) int {
-	s := *ptr.toStringSlice()
-	n := 0
-	for _, v := range s {
-		n += len(v) + SizeVarint(uint64(len(v))) + tagsize
-	}
-	return n
-}
-func sizeBytes(ptr pointer, tagsize int) int {
-	v := *ptr.toBytes()
-	if v == nil {
-		return 0
-	}
-	return len(v) + SizeVarint(uint64(len(v))) + tagsize
-}
-func sizeBytes3(ptr pointer, tagsize int) int {
-	v := *ptr.toBytes()
-	if len(v) == 0 {
-		return 0
-	}
-	return len(v) + SizeVarint(uint64(len(v))) + tagsize
-}
-func sizeBytesOneof(ptr pointer, tagsize int) int {
-	v := *ptr.toBytes()
-	return len(v) + SizeVarint(uint64(len(v))) + tagsize
-}
-func sizeBytesSlice(ptr pointer, tagsize int) int {
-	s := *ptr.toBytesSlice()
-	n := 0
-	for _, v := range s {
-		n += len(v) + SizeVarint(uint64(len(v))) + tagsize
-	}
-	return n
-}
-
-// appendFixed32 appends an encoded fixed32 to b.
-func appendFixed32(b []byte, v uint32) []byte {
-	b = append(b,
-		byte(v),
-		byte(v>>8),
-		byte(v>>16),
-		byte(v>>24))
-	return b
-}
-
-// appendFixed64 appends an encoded fixed64 to b.
-func appendFixed64(b []byte, v uint64) []byte {
-	b = append(b,
-		byte(v),
-		byte(v>>8),
-		byte(v>>16),
-		byte(v>>24),
-		byte(v>>32),
-		byte(v>>40),
-		byte(v>>48),
-		byte(v>>56))
-	return b
-}
-
-// appendVarint appends an encoded varint to b.
-func appendVarint(b []byte, v uint64) []byte {
-	// TODO: make 1-byte (maybe 2-byte) case inline-able, once we
-	// have non-leaf inliner.
-	switch {
-	case v < 1<<7:
-		b = append(b, byte(v))
-	case v < 1<<14:
-		b = append(b,
-			byte(v&0x7f|0x80),
-			byte(v>>7))
-	case v < 1<<21:
-		b = append(b,
-			byte(v&0x7f|0x80),
-			byte((v>>7)&0x7f|0x80),
-			byte(v>>14))
-	case v < 1<<28:
-		b = append(b,
-			byte(v&0x7f|0x80),
-			byte((v>>7)&0x7f|0x80),
-			byte((v>>14)&0x7f|0x80),
-			byte(v>>21))
-	case v < 1<<35:
-		b = append(b,
-			byte(v&0x7f|0x80),
-			byte((v>>7)&0x7f|0x80),
-			byte((v>>14)&0x7f|0x80),
-			byte((v>>21)&0x7f|0x80),
-			byte(v>>28))
-	case v < 1<<42:
-		b = append(b,
-			byte(v&0x7f|0x80),
-			byte((v>>7)&0x7f|0x80),
-			byte((v>>14)&0x7f|0x80),
-			byte((v>>21)&0x7f|0x80),
-			byte((v>>28)&0x7f|0x80),
-			byte(v>>35))
-	case v < 1<<49:
-		b = append(b,
-			byte(v&0x7f|0x80),
-			byte((v>>7)&0x7f|0x80),
-			byte((v>>14)&0x7f|0x80),
-			byte((v>>21)&0x7f|0x80),
-			byte((v>>28)&0x7f|0x80),
-			byte((v>>35)&0x7f|0x80),
-			byte(v>>42))
-	case v < 1<<56:
-		b = append(b,
-			byte(v&0x7f|0x80),
-			byte((v>>7)&0x7f|0x80),
-			byte((v>>14)&0x7f|0x80),
-			byte((v>>21)&0x7f|0x80),
-			byte((v>>28)&0x7f|0x80),
-			byte((v>>35)&0x7f|0x80),
-			byte((v>>42)&0x7f|0x80),
-			byte(v>>49))
-	case v < 1<<63:
-		b = append(b,
-			byte(v&0x7f|0x80),
-			byte((v>>7)&0x7f|0x80),
-			byte((v>>14)&0x7f|0x80),
-			byte((v>>21)&0x7f|0x80),
-			byte((v>>28)&0x7f|0x80),
-			byte((v>>35)&0x7f|0x80),
-			byte((v>>42)&0x7f|0x80),
-			byte((v>>49)&0x7f|0x80),
-			byte(v>>56))
-	default:
-		b = append(b,
-			byte(v&0x7f|0x80),
-			byte((v>>7)&0x7f|0x80),
-			byte((v>>14)&0x7f|0x80),
-			byte((v>>21)&0x7f|0x80),
-			byte((v>>28)&0x7f|0x80),
-			byte((v>>35)&0x7f|0x80),
-			byte((v>>42)&0x7f|0x80),
-			byte((v>>49)&0x7f|0x80),
-			byte((v>>56)&0x7f|0x80),
-			1)
-	}
-	return b
-}
-
-func appendFixed32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	v := *ptr.toUint32()
-	b = appendVarint(b, wiretag)
-	b = appendFixed32(b, v)
-	return b, nil
-}
-func appendFixed32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	v := *ptr.toUint32()
-	if v == 0 {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag)
-	b = appendFixed32(b, v)
-	return b, nil
-}
-func appendFixed32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	p := *ptr.toUint32Ptr()
-	if p == nil {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag)
-	b = appendFixed32(b, *p)
-	return b, nil
-}
-func appendFixed32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	s := *ptr.toUint32Slice()
-	for _, v := range s {
-		b = appendVarint(b, wiretag)
-		b = appendFixed32(b, v)
-	}
-	return b, nil
-}
-func appendFixed32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	s := *ptr.toUint32Slice()
-	if len(s) == 0 {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag&^7|WireBytes)
-	b = appendVarint(b, uint64(4*len(s)))
-	for _, v := range s {
-		b = appendFixed32(b, v)
-	}
-	return b, nil
-}
-func appendFixedS32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	v := *ptr.toInt32()
-	b = appendVarint(b, wiretag)
-	b = appendFixed32(b, uint32(v))
-	return b, nil
-}
-func appendFixedS32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	v := *ptr.toInt32()
-	if v == 0 {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag)
-	b = appendFixed32(b, uint32(v))
-	return b, nil
-}
-func appendFixedS32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	p := ptr.getInt32Ptr()
-	if p == nil {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag)
-	b = appendFixed32(b, uint32(*p))
-	return b, nil
-}
-func appendFixedS32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	s := ptr.getInt32Slice()
-	for _, v := range s {
-		b = appendVarint(b, wiretag)
-		b = appendFixed32(b, uint32(v))
-	}
-	return b, nil
-}
-func appendFixedS32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	s := ptr.getInt32Slice()
-	if len(s) == 0 {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag&^7|WireBytes)
-	b = appendVarint(b, uint64(4*len(s)))
-	for _, v := range s {
-		b = appendFixed32(b, uint32(v))
-	}
-	return b, nil
-}
-func appendFloat32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	v := math.Float32bits(*ptr.toFloat32())
-	b = appendVarint(b, wiretag)
-	b = appendFixed32(b, v)
-	return b, nil
-}
-func appendFloat32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	v := math.Float32bits(*ptr.toFloat32())
-	if v == 0 {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag)
-	b = appendFixed32(b, v)
-	return b, nil
-}
-func appendFloat32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	p := *ptr.toFloat32Ptr()
-	if p == nil {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag)
-	b = appendFixed32(b, math.Float32bits(*p))
-	return b, nil
-}
-func appendFloat32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	s := *ptr.toFloat32Slice()
-	for _, v := range s {
-		b = appendVarint(b, wiretag)
-		b = appendFixed32(b, math.Float32bits(v))
-	}
-	return b, nil
-}
-func appendFloat32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	s := *ptr.toFloat32Slice()
-	if len(s) == 0 {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag&^7|WireBytes)
-	b = appendVarint(b, uint64(4*len(s)))
-	for _, v := range s {
-		b = appendFixed32(b, math.Float32bits(v))
-	}
-	return b, nil
-}
-func appendFixed64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	v := *ptr.toUint64()
-	b = appendVarint(b, wiretag)
-	b = appendFixed64(b, v)
-	return b, nil
-}
-func appendFixed64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	v := *ptr.toUint64()
-	if v == 0 {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag)
-	b = appendFixed64(b, v)
-	return b, nil
-}
-func appendFixed64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	p := *ptr.toUint64Ptr()
-	if p == nil {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag)
-	b = appendFixed64(b, *p)
-	return b, nil
-}
-func appendFixed64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	s := *ptr.toUint64Slice()
-	for _, v := range s {
-		b = appendVarint(b, wiretag)
-		b = appendFixed64(b, v)
-	}
-	return b, nil
-}
-func appendFixed64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	s := *ptr.toUint64Slice()
-	if len(s) == 0 {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag&^7|WireBytes)
-	b = appendVarint(b, uint64(8*len(s)))
-	for _, v := range s {
-		b = appendFixed64(b, v)
-	}
-	return b, nil
-}
-func appendFixedS64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	v := *ptr.toInt64()
-	b = appendVarint(b, wiretag)
-	b = appendFixed64(b, uint64(v))
-	return b, nil
-}
-func appendFixedS64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	v := *ptr.toInt64()
-	if v == 0 {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag)
-	b = appendFixed64(b, uint64(v))
-	return b, nil
-}
-func appendFixedS64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	p := *ptr.toInt64Ptr()
-	if p == nil {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag)
-	b = appendFixed64(b, uint64(*p))
-	return b, nil
-}
-func appendFixedS64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	s := *ptr.toInt64Slice()
-	for _, v := range s {
-		b = appendVarint(b, wiretag)
-		b = appendFixed64(b, uint64(v))
-	}
-	return b, nil
-}
-func appendFixedS64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	s := *ptr.toInt64Slice()
-	if len(s) == 0 {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag&^7|WireBytes)
-	b = appendVarint(b, uint64(8*len(s)))
-	for _, v := range s {
-		b = appendFixed64(b, uint64(v))
-	}
-	return b, nil
-}
-func appendFloat64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	v := math.Float64bits(*ptr.toFloat64())
-	b = appendVarint(b, wiretag)
-	b = appendFixed64(b, v)
-	return b, nil
-}
-func appendFloat64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	v := math.Float64bits(*ptr.toFloat64())
-	if v == 0 {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag)
-	b = appendFixed64(b, v)
-	return b, nil
-}
-func appendFloat64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	p := *ptr.toFloat64Ptr()
-	if p == nil {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag)
-	b = appendFixed64(b, math.Float64bits(*p))
-	return b, nil
-}
-func appendFloat64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	s := *ptr.toFloat64Slice()
-	for _, v := range s {
-		b = appendVarint(b, wiretag)
-		b = appendFixed64(b, math.Float64bits(v))
-	}
-	return b, nil
-}
-func appendFloat64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	s := *ptr.toFloat64Slice()
-	if len(s) == 0 {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag&^7|WireBytes)
-	b = appendVarint(b, uint64(8*len(s)))
-	for _, v := range s {
-		b = appendFixed64(b, math.Float64bits(v))
-	}
-	return b, nil
-}
-func appendVarint32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	v := *ptr.toUint32()
-	b = appendVarint(b, wiretag)
-	b = appendVarint(b, uint64(v))
-	return b, nil
-}
-func appendVarint32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	v := *ptr.toUint32()
-	if v == 0 {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag)
-	b = appendVarint(b, uint64(v))
-	return b, nil
-}
-func appendVarint32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	p := *ptr.toUint32Ptr()
-	if p == nil {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag)
-	b = appendVarint(b, uint64(*p))
-	return b, nil
-}
-func appendVarint32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	s := *ptr.toUint32Slice()
-	for _, v := range s {
-		b = appendVarint(b, wiretag)
-		b = appendVarint(b, uint64(v))
-	}
-	return b, nil
-}
-func appendVarint32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	s := *ptr.toUint32Slice()
-	if len(s) == 0 {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag&^7|WireBytes)
-	// compute size
-	n := 0
-	for _, v := range s {
-		n += SizeVarint(uint64(v))
-	}
-	b = appendVarint(b, uint64(n))
-	for _, v := range s {
-		b = appendVarint(b, uint64(v))
-	}
-	return b, nil
-}
-func appendVarintS32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	v := *ptr.toInt32()
-	b = appendVarint(b, wiretag)
-	b = appendVarint(b, uint64(v))
-	return b, nil
-}
-func appendVarintS32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	v := *ptr.toInt32()
-	if v == 0 {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag)
-	b = appendVarint(b, uint64(v))
-	return b, nil
-}
-func appendVarintS32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	p := ptr.getInt32Ptr()
-	if p == nil {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag)
-	b = appendVarint(b, uint64(*p))
-	return b, nil
-}
-func appendVarintS32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	s := ptr.getInt32Slice()
-	for _, v := range s {
-		b = appendVarint(b, wiretag)
-		b = appendVarint(b, uint64(v))
-	}
-	return b, nil
-}
-func appendVarintS32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	s := ptr.getInt32Slice()
-	if len(s) == 0 {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag&^7|WireBytes)
-	// compute size
-	n := 0
-	for _, v := range s {
-		n += SizeVarint(uint64(v))
-	}
-	b = appendVarint(b, uint64(n))
-	for _, v := range s {
-		b = appendVarint(b, uint64(v))
-	}
-	return b, nil
-}
-func appendVarint64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	v := *ptr.toUint64()
-	b = appendVarint(b, wiretag)
-	b = appendVarint(b, v)
-	return b, nil
-}
-func appendVarint64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	v := *ptr.toUint64()
-	if v == 0 {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag)
-	b = appendVarint(b, v)
-	return b, nil
-}
-func appendVarint64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	p := *ptr.toUint64Ptr()
-	if p == nil {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag)
-	b = appendVarint(b, *p)
-	return b, nil
-}
-func appendVarint64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	s := *ptr.toUint64Slice()
-	for _, v := range s {
-		b = appendVarint(b, wiretag)
-		b = appendVarint(b, v)
-	}
-	return b, nil
-}
-func appendVarint64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	s := *ptr.toUint64Slice()
-	if len(s) == 0 {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag&^7|WireBytes)
-	// compute size
-	n := 0
-	for _, v := range s {
-		n += SizeVarint(v)
-	}
-	b = appendVarint(b, uint64(n))
-	for _, v := range s {
-		b = appendVarint(b, v)
-	}
-	return b, nil
-}
-func appendVarintS64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	v := *ptr.toInt64()
-	b = appendVarint(b, wiretag)
-	b = appendVarint(b, uint64(v))
-	return b, nil
-}
-func appendVarintS64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	v := *ptr.toInt64()
-	if v == 0 {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag)
-	b = appendVarint(b, uint64(v))
-	return b, nil
-}
-func appendVarintS64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	p := *ptr.toInt64Ptr()
-	if p == nil {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag)
-	b = appendVarint(b, uint64(*p))
-	return b, nil
-}
-func appendVarintS64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	s := *ptr.toInt64Slice()
-	for _, v := range s {
-		b = appendVarint(b, wiretag)
-		b = appendVarint(b, uint64(v))
-	}
-	return b, nil
-}
-func appendVarintS64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	s := *ptr.toInt64Slice()
-	if len(s) == 0 {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag&^7|WireBytes)
-	// compute size
-	n := 0
-	for _, v := range s {
-		n += SizeVarint(uint64(v))
-	}
-	b = appendVarint(b, uint64(n))
-	for _, v := range s {
-		b = appendVarint(b, uint64(v))
-	}
-	return b, nil
-}
-func appendZigzag32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	v := *ptr.toInt32()
-	b = appendVarint(b, wiretag)
-	b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
-	return b, nil
-}
-func appendZigzag32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	v := *ptr.toInt32()
-	if v == 0 {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag)
-	b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
-	return b, nil
-}
-func appendZigzag32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	p := ptr.getInt32Ptr()
-	if p == nil {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag)
-	v := *p
-	b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
-	return b, nil
-}
-func appendZigzag32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	s := ptr.getInt32Slice()
-	for _, v := range s {
-		b = appendVarint(b, wiretag)
-		b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
-	}
-	return b, nil
-}
-func appendZigzag32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	s := ptr.getInt32Slice()
-	if len(s) == 0 {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag&^7|WireBytes)
-	// compute size
-	n := 0
-	for _, v := range s {
-		n += SizeVarint(uint64((uint32(v) << 1) ^ uint32((int32(v) >> 31))))
-	}
-	b = appendVarint(b, uint64(n))
-	for _, v := range s {
-		b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
-	}
-	return b, nil
-}
-func appendZigzag64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	v := *ptr.toInt64()
-	b = appendVarint(b, wiretag)
-	b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
-	return b, nil
-}
-func appendZigzag64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	v := *ptr.toInt64()
-	if v == 0 {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag)
-	b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
-	return b, nil
-}
-func appendZigzag64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	p := *ptr.toInt64Ptr()
-	if p == nil {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag)
-	v := *p
-	b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
-	return b, nil
-}
-func appendZigzag64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	s := *ptr.toInt64Slice()
-	for _, v := range s {
-		b = appendVarint(b, wiretag)
-		b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
-	}
-	return b, nil
-}
-func appendZigzag64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	s := *ptr.toInt64Slice()
-	if len(s) == 0 {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag&^7|WireBytes)
-	// compute size
-	n := 0
-	for _, v := range s {
-		n += SizeVarint(uint64(v<<1) ^ uint64((int64(v) >> 63)))
-	}
-	b = appendVarint(b, uint64(n))
-	for _, v := range s {
-		b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
-	}
-	return b, nil
-}
-func appendBoolValue(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	v := *ptr.toBool()
-	b = appendVarint(b, wiretag)
-	if v {
-		b = append(b, 1)
-	} else {
-		b = append(b, 0)
-	}
-	return b, nil
-}
-func appendBoolValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	v := *ptr.toBool()
-	if !v {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag)
-	b = append(b, 1)
-	return b, nil
-}
-
-func appendBoolPtr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	p := *ptr.toBoolPtr()
-	if p == nil {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag)
-	if *p {
-		b = append(b, 1)
-	} else {
-		b = append(b, 0)
-	}
-	return b, nil
-}
-func appendBoolSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	s := *ptr.toBoolSlice()
-	for _, v := range s {
-		b = appendVarint(b, wiretag)
-		if v {
-			b = append(b, 1)
-		} else {
-			b = append(b, 0)
-		}
-	}
-	return b, nil
-}
-func appendBoolPackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	s := *ptr.toBoolSlice()
-	if len(s) == 0 {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag&^7|WireBytes)
-	b = appendVarint(b, uint64(len(s)))
-	for _, v := range s {
-		if v {
-			b = append(b, 1)
-		} else {
-			b = append(b, 0)
-		}
-	}
-	return b, nil
-}
-func appendStringValue(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	v := *ptr.toString()
-	if !utf8.ValidString(v) {
-		return nil, errInvalidUTF8
-	}
-	b = appendVarint(b, wiretag)
-	b = appendVarint(b, uint64(len(v)))
-	b = append(b, v...)
-	return b, nil
-}
-func appendStringValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	v := *ptr.toString()
-	if v == "" {
-		return b, nil
-	}
-	if !utf8.ValidString(v) {
-		return nil, errInvalidUTF8
-	}
-	b = appendVarint(b, wiretag)
-	b = appendVarint(b, uint64(len(v)))
-	b = append(b, v...)
-	return b, nil
-}
-func appendStringPtr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	p := *ptr.toStringPtr()
-	if p == nil {
-		return b, nil
-	}
-	v := *p
-	if !utf8.ValidString(v) {
-		return nil, errInvalidUTF8
-	}
-	b = appendVarint(b, wiretag)
-	b = appendVarint(b, uint64(len(v)))
-	b = append(b, v...)
-	return b, nil
-}
-func appendStringSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	s := *ptr.toStringSlice()
-	for _, v := range s {
-		if !utf8.ValidString(v) {
-			return nil, errInvalidUTF8
-		}
-		b = appendVarint(b, wiretag)
-		b = appendVarint(b, uint64(len(v)))
-		b = append(b, v...)
-	}
-	return b, nil
-}
-func appendBytes(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	v := *ptr.toBytes()
-	if v == nil {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag)
-	b = appendVarint(b, uint64(len(v)))
-	b = append(b, v...)
-	return b, nil
-}
-func appendBytes3(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	v := *ptr.toBytes()
-	if len(v) == 0 {
-		return b, nil
-	}
-	b = appendVarint(b, wiretag)
-	b = appendVarint(b, uint64(len(v)))
-	b = append(b, v...)
-	return b, nil
-}
-func appendBytesOneof(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	v := *ptr.toBytes()
-	b = appendVarint(b, wiretag)
-	b = appendVarint(b, uint64(len(v)))
-	b = append(b, v...)
-	return b, nil
-}
-func appendBytesSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
-	s := *ptr.toBytesSlice()
-	for _, v := range s {
-		b = appendVarint(b, wiretag)
-		b = appendVarint(b, uint64(len(v)))
-		b = append(b, v...)
-	}
-	return b, nil
-}
-
-// makeGroupMarshaler returns the sizer and marshaler for a group.
-// u is the marshal info of the underlying message.
-func makeGroupMarshaler(u *marshalInfo) (sizer, marshaler) {
-	return func(ptr pointer, tagsize int) int {
-			p := ptr.getPointer()
-			if p.isNil() {
-				return 0
-			}
-			return u.size(p) + 2*tagsize
-		},
-		func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
-			p := ptr.getPointer()
-			if p.isNil() {
-				return b, nil
-			}
-			var err error
-			b = appendVarint(b, wiretag) // start group
-			b, err = u.marshal(b, p, deterministic)
-			b = appendVarint(b, wiretag+(WireEndGroup-WireStartGroup)) // end group
-			return b, err
-		}
-}
-
-// makeGroupSliceMarshaler returns the sizer and marshaler for a group slice.
-// u is the marshal info of the underlying message.
-func makeGroupSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
-	return func(ptr pointer, tagsize int) int {
-			s := ptr.getPointerSlice()
-			n := 0
-			for _, v := range s {
-				if v.isNil() {
-					continue
-				}
-				n += u.size(v) + 2*tagsize
-			}
-			return n
-		},
-		func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
-			s := ptr.getPointerSlice()
-			var err, errreq error
-			for _, v := range s {
-				if v.isNil() {
-					return b, errRepeatedHasNil
-				}
-				b = appendVarint(b, wiretag) // start group
-				b, err = u.marshal(b, v, deterministic)
-				b = appendVarint(b, wiretag+(WireEndGroup-WireStartGroup)) // end group
-				if err != nil {
-					if _, ok := err.(*RequiredNotSetError); ok {
-						// Required field in submessage is not set.
-						// We record the error but keep going, to give a complete marshaling.
-						if errreq == nil {
-							errreq = err
-						}
-						continue
-					}
-					if err == ErrNil {
-						err = errRepeatedHasNil
-					}
-					return b, err
-				}
-			}
-			return b, errreq
-		}
-}
-
-// makeMessageMarshaler returns the sizer and marshaler for a message field.
-// u is the marshal info of the message.
-func makeMessageMarshaler(u *marshalInfo) (sizer, marshaler) {
-	return func(ptr pointer, tagsize int) int {
-			p := ptr.getPointer()
-			if p.isNil() {
-				return 0
-			}
-			siz := u.size(p)
-			return siz + SizeVarint(uint64(siz)) + tagsize
-		},
-		func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
-			p := ptr.getPointer()
-			if p.isNil() {
-				return b, nil
-			}
-			b = appendVarint(b, wiretag)
-			siz := u.cachedsize(p)
-			b = appendVarint(b, uint64(siz))
-			return u.marshal(b, p, deterministic)
-		}
-}
-
-// makeMessageSliceMarshaler returns the sizer and marshaler for a message slice.
-// u is the marshal info of the message.
-func makeMessageSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
-	return func(ptr pointer, tagsize int) int {
-			s := ptr.getPointerSlice()
-			n := 0
-			for _, v := range s {
-				if v.isNil() {
-					continue
-				}
-				siz := u.size(v)
-				n += siz + SizeVarint(uint64(siz)) + tagsize
-			}
-			return n
-		},
-		func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
-			s := ptr.getPointerSlice()
-			var err, errreq error
-			for _, v := range s {
-				if v.isNil() {
-					return b, errRepeatedHasNil
-				}
-				b = appendVarint(b, wiretag)
-				siz := u.cachedsize(v)
-				b = appendVarint(b, uint64(siz))
-				b, err = u.marshal(b, v, deterministic)
-
-				if err != nil {
-					if _, ok := err.(*RequiredNotSetError); ok {
-						// Required field in submessage is not set.
-						// We record the error but keep going, to give a complete marshaling.
-						if errreq == nil {
-							errreq = err
-						}
-						continue
-					}
-					if err == ErrNil {
-						err = errRepeatedHasNil
-					}
-					return b, err
-				}
-			}
-			return b, errreq
-		}
-}
-
-// makeMapMarshaler returns the sizer and marshaler for a map field.
-// f is the pointer to the reflect data structure of the field.
-func makeMapMarshaler(f *reflect.StructField) (sizer, marshaler) {
-	// figure out key and value type
-	t := f.Type
-	keyType := t.Key()
-	valType := t.Elem()
-	keyTags := strings.Split(f.Tag.Get("protobuf_key"), ",")
-	valTags := strings.Split(f.Tag.Get("protobuf_val"), ",")
-	keySizer, keyMarshaler := typeMarshaler(keyType, keyTags, false, false) // don't omit zero value in map
-	valSizer, valMarshaler := typeMarshaler(valType, valTags, false, false) // don't omit zero value in map
-	keyWireTag := 1<<3 | wiretype(keyTags[0])
-	valWireTag := 2<<3 | wiretype(valTags[0])
-
-	// We create an interface to get the addresses of the map key and value.
-	// If value is pointer-typed, the interface is a direct interface, the
-	// idata itself is the value. Otherwise, the idata is the pointer to the
-	// value.
-	// Key cannot be pointer-typed.
-	valIsPtr := valType.Kind() == reflect.Ptr
-	return func(ptr pointer, tagsize int) int {
-			m := ptr.asPointerTo(t).Elem() // the map
-			n := 0
-			for _, k := range m.MapKeys() {
-				ki := k.Interface()
-				vi := m.MapIndex(k).Interface()
-				kaddr := toAddrPointer(&ki, false)             // pointer to key
-				vaddr := toAddrPointer(&vi, valIsPtr)          // pointer to value
-				siz := keySizer(kaddr, 1) + valSizer(vaddr, 1) // tag of key = 1 (size=1), tag of val = 2 (size=1)
-				n += siz + SizeVarint(uint64(siz)) + tagsize
-			}
-			return n
-		},
-		func(b []byte, ptr pointer, tag uint64, deterministic bool) ([]byte, error) {
-			m := ptr.asPointerTo(t).Elem() // the map
-			var err error
-			keys := m.MapKeys()
-			if len(keys) > 1 && deterministic {
-				sort.Sort(mapKeys(keys))
-			}
-			for _, k := range keys {
-				ki := k.Interface()
-				vi := m.MapIndex(k).Interface()
-				kaddr := toAddrPointer(&ki, false)    // pointer to key
-				vaddr := toAddrPointer(&vi, valIsPtr) // pointer to value
-				b = appendVarint(b, tag)
-				siz := keySizer(kaddr, 1) + valSizer(vaddr, 1) // tag of key = 1 (size=1), tag of val = 2 (size=1)
-				b = appendVarint(b, uint64(siz))
-				b, err = keyMarshaler(b, kaddr, keyWireTag, deterministic)
-				if err != nil {
-					return b, err
-				}
-				b, err = valMarshaler(b, vaddr, valWireTag, deterministic)
-				if err != nil && err != ErrNil { // allow nil value in map
-					return b, err
-				}
-			}
-			return b, nil
-		}
-}
-
-// makeOneOfMarshaler returns the sizer and marshaler for a oneof field.
-// fi is the marshal info of the field.
-// f is the pointer to the reflect data structure of the field.
-func makeOneOfMarshaler(fi *marshalFieldInfo, f *reflect.StructField) (sizer, marshaler) {
-	// Oneof field is an interface. We need to get the actual data type on the fly.
-	t := f.Type
-	return func(ptr pointer, _ int) int {
-			p := ptr.getInterfacePointer()
-			if p.isNil() {
-				return 0
-			}
-			v := ptr.asPointerTo(t).Elem().Elem().Elem() // *interface -> interface -> *struct -> struct
-			telem := v.Type()
-			e := fi.oneofElems[telem]
-			return e.sizer(p, e.tagsize)
-		},
-		func(b []byte, ptr pointer, _ uint64, deterministic bool) ([]byte, error) {
-			p := ptr.getInterfacePointer()
-			if p.isNil() {
-				return b, nil
-			}
-			v := ptr.asPointerTo(t).Elem().Elem().Elem() // *interface -> interface -> *struct -> struct
-			telem := v.Type()
-			if telem.Field(0).Type.Kind() == reflect.Ptr && p.getPointer().isNil() {
-				return b, errOneofHasNil
-			}
-			e := fi.oneofElems[telem]
-			return e.marshaler(b, p, e.wiretag, deterministic)
-		}
-}
-
-// sizeExtensions computes the size of encoded data for a XXX_InternalExtensions field.
-func (u *marshalInfo) sizeExtensions(ext *XXX_InternalExtensions) int {
-	m, mu := ext.extensionsRead()
-	if m == nil {
-		return 0
-	}
-	mu.Lock()
-
-	n := 0
-	for _, e := range m {
-		if e.value == nil || e.desc == nil {
-			// Extension is only in its encoded form.
-			n += len(e.enc)
-			continue
-		}
-
-		// We don't skip extensions that have an encoded form set,
-		// because the extension value may have been mutated after
-		// the last time this function was called.
-		ei := u.getExtElemInfo(e.desc)
-		v := e.value
-		p := toAddrPointer(&v, ei.isptr)
-		n += ei.sizer(p, ei.tagsize)
-	}
-	mu.Unlock()
-	return n
-}
-
-// appendExtensions marshals a XXX_InternalExtensions field to the end of byte slice b.
-func (u *marshalInfo) appendExtensions(b []byte, ext *XXX_InternalExtensions, deterministic bool) ([]byte, error) {
-	m, mu := ext.extensionsRead()
-	if m == nil {
-		return b, nil
-	}
-	mu.Lock()
-	defer mu.Unlock()
-
-	var err error
-
-	// Fast-path for common cases: zero or one extensions.
-	// Don't bother sorting the keys.
-	if len(m) <= 1 {
-		for _, e := range m {
-			if e.value == nil || e.desc == nil {
-				// Extension is only in its encoded form.
-				b = append(b, e.enc...)
-				continue
-			}
-
-			// We don't skip extensions that have an encoded form set,
-			// because the extension value may have been mutated after
-			// the last time this function was called.
-
-			ei := u.getExtElemInfo(e.desc)
-			v := e.value
-			p := toAddrPointer(&v, ei.isptr)
-			b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
-			if err != nil {
-				return b, err
-			}
-		}
-		return b, nil
-	}
-
-	// Sort the keys to provide a deterministic encoding.
-	// Not sure this is required, but the old code does it.
-	keys := make([]int, 0, len(m))
-	for k := range m {
-		keys = append(keys, int(k))
-	}
-	sort.Ints(keys)
-
-	for _, k := range keys {
-		e := m[int32(k)]
-		if e.value == nil || e.desc == nil {
-			// Extension is only in its encoded form.
-			b = append(b, e.enc...)
-			continue
-		}
-
-		// We don't skip extensions that have an encoded form set,
-		// because the extension value may have been mutated after
-		// the last time this function was called.
-
-		ei := u.getExtElemInfo(e.desc)
-		v := e.value
-		p := toAddrPointer(&v, ei.isptr)
-		b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
-		if err != nil {
-			return b, err
-		}
-	}
-	return b, nil
-}
-
-// message set format is:
-//   message MessageSet {
-//     repeated group Item = 1 {
-//       required int32 type_id = 2;
-//       required string message = 3;
-//     };
-//   }
-
-// sizeMessageSet computes the size of encoded data for a XXX_InternalExtensions field
-// in message set format (above).
-func (u *marshalInfo) sizeMessageSet(ext *XXX_InternalExtensions) int {
-	m, mu := ext.extensionsRead()
-	if m == nil {
-		return 0
-	}
-	mu.Lock()
-
-	n := 0
-	for id, e := range m {
-		n += 2                          // start group, end group. tag = 1 (size=1)
-		n += SizeVarint(uint64(id)) + 1 // type_id, tag = 2 (size=1)
-
-		if e.value == nil || e.desc == nil {
-			// Extension is only in its encoded form.
-			msgWithLen := skipVarint(e.enc) // skip old tag, but leave the length varint
-			siz := len(msgWithLen)
-			n += siz + 1 // message, tag = 3 (size=1)
-			continue
-		}
-
-		// We don't skip extensions that have an encoded form set,
-		// because the extension value may have been mutated after
-		// the last time this function was called.
-
-		ei := u.getExtElemInfo(e.desc)
-		v := e.value
-		p := toAddrPointer(&v, ei.isptr)
-		n += ei.sizer(p, 1) // message, tag = 3 (size=1)
-	}
-	mu.Unlock()
-	return n
-}
-
-// appendMessageSet marshals a XXX_InternalExtensions field in message set format (above)
-// to the end of byte slice b.
-func (u *marshalInfo) appendMessageSet(b []byte, ext *XXX_InternalExtensions, deterministic bool) ([]byte, error) {
-	m, mu := ext.extensionsRead()
-	if m == nil {
-		return b, nil
-	}
-	mu.Lock()
-	defer mu.Unlock()
-
-	var err error
-
-	// Fast-path for common cases: zero or one extensions.
-	// Don't bother sorting the keys.
-	if len(m) <= 1 {
-		for id, e := range m {
-			b = append(b, 1<<3|WireStartGroup)
-			b = append(b, 2<<3|WireVarint)
-			b = appendVarint(b, uint64(id))
-
-			if e.value == nil || e.desc == nil {
-				// Extension is only in its encoded form.
-				msgWithLen := skipVarint(e.enc) // skip old tag, but leave the length varint
-				b = append(b, 3<<3|WireBytes)
-				b = append(b, msgWithLen...)
-				b = append(b, 1<<3|WireEndGroup)
-				continue
-			}
-
-			// We don't skip extensions that have an encoded form set,
-			// because the extension value may have been mutated after
-			// the last time this function was called.
-
-			ei := u.getExtElemInfo(e.desc)
-			v := e.value
-			p := toAddrPointer(&v, ei.isptr)
-			b, err = ei.marshaler(b, p, 3<<3|WireBytes, deterministic)
-			if err != nil {
-				return b, err
-			}
-			b = append(b, 1<<3|WireEndGroup)
-		}
-		return b, nil
-	}
-
-	// Sort the keys to provide a deterministic encoding.
-	keys := make([]int, 0, len(m))
-	for k := range m {
-		keys = append(keys, int(k))
-	}
-	sort.Ints(keys)
-
-	for _, id := range keys {
-		e := m[int32(id)]
-		b = append(b, 1<<3|WireStartGroup)
-		b = append(b, 2<<3|WireVarint)
-		b = appendVarint(b, uint64(id))
-
-		if e.value == nil || e.desc == nil {
-			// Extension is only in its encoded form.
-			msgWithLen := skipVarint(e.enc) // skip old tag, but leave the length varint
-			b = append(b, 3<<3|WireBytes)
-			b = append(b, msgWithLen...)
-			b = append(b, 1<<3|WireEndGroup)
-			continue
-		}
-
-		// We don't skip extensions that have an encoded form set,
-		// because the extension value may have been mutated after
-		// the last time this function was called.
-
-		ei := u.getExtElemInfo(e.desc)
-		v := e.value
-		p := toAddrPointer(&v, ei.isptr)
-		b, err = ei.marshaler(b, p, 3<<3|WireBytes, deterministic)
-		b = append(b, 1<<3|WireEndGroup)
-		if err != nil {
-			return b, err
-		}
-	}
-	return b, nil
-}
-
-// sizeV1Extensions computes the size of encoded data for a V1-API extension field.
-func (u *marshalInfo) sizeV1Extensions(m map[int32]Extension) int {
-	if m == nil {
-		return 0
-	}
-
-	n := 0
-	for _, e := range m {
-		if e.value == nil || e.desc == nil {
-			// Extension is only in its encoded form.
-			n += len(e.enc)
-			continue
-		}
-
-		// We don't skip extensions that have an encoded form set,
-		// because the extension value may have been mutated after
-		// the last time this function was called.
-
-		ei := u.getExtElemInfo(e.desc)
-		v := e.value
-		p := toAddrPointer(&v, ei.isptr)
-		n += ei.sizer(p, ei.tagsize)
-	}
-	return n
-}
-
-// appendV1Extensions marshals a V1-API extension field to the end of byte slice b.
-func (u *marshalInfo) appendV1Extensions(b []byte, m map[int32]Extension, deterministic bool) ([]byte, error) {
-	if m == nil {
-		return b, nil
-	}
-
-	// Sort the keys to provide a deterministic encoding.
-	keys := make([]int, 0, len(m))
-	for k := range m {
-		keys = append(keys, int(k))
-	}
-	sort.Ints(keys)
-
-	var err error
-	for _, k := range keys {
-		e := m[int32(k)]
-		if e.value == nil || e.desc == nil {
-			// Extension is only in its encoded form.
-			b = append(b, e.enc...)
-			continue
-		}
-
-		// We don't skip extensions that have an encoded form set,
-		// because the extension value may have been mutated after
-		// the last time this function was called.
-
-		ei := u.getExtElemInfo(e.desc)
-		v := e.value
-		p := toAddrPointer(&v, ei.isptr)
-		b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
-		if err != nil {
-			return b, err
-		}
-	}
-	return b, nil
-}
-
-// newMarshaler is the interface representing objects that can marshal themselves.
-//
-// This exists to support protoc-gen-go generated messages.
-// The proto package will stop type-asserting to this interface in the future.
-//
-// DO NOT DEPEND ON THIS.
-type newMarshaler interface {
-	XXX_Size() int
-	XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
-}
-
-// Size returns the encoded size of a protocol buffer message.
-// This is the main entry point.
-func Size(pb Message) int {
-	if m, ok := pb.(newMarshaler); ok {
-		return m.XXX_Size()
-	}
-	if m, ok := pb.(Marshaler); ok {
-		// If the message can marshal itself, let it do it, for compatibility.
-		// NOTE: This is not efficient.
-		b, _ := m.Marshal()
-		return len(b)
-	}
-	// in case somehow we didn't generate the wrapper
-	if pb == nil {
-		return 0
-	}
-	var info InternalMessageInfo
-	return info.Size(pb)
-}
-
-// Marshal takes a protocol buffer message
-// and encodes it into the wire format, returning the data.
-// This is the main entry point.
-func Marshal(pb Message) ([]byte, error) {
-	if m, ok := pb.(newMarshaler); ok {
-		siz := m.XXX_Size()
-		b := make([]byte, 0, siz)
-		return m.XXX_Marshal(b, false)
-	}
-	if m, ok := pb.(Marshaler); ok {
-		// If the message can marshal itself, let it do it, for compatibility.
-		// NOTE: This is not efficient.
-		return m.Marshal()
-	}
-	// in case somehow we didn't generate the wrapper
-	if pb == nil {
-		return nil, ErrNil
-	}
-	var info InternalMessageInfo
-	siz := info.Size(pb)
-	b := make([]byte, 0, siz)
-	return info.Marshal(b, pb, false)
-}
-
-// Marshal takes a protocol buffer message
-// and encodes it into the wire format, writing the result to the
-// Buffer.
-// This is an alternative entry point. It is not necessary to use
-// a Buffer for most applications.
-func (p *Buffer) Marshal(pb Message) error {
-	var err error
-	if m, ok := pb.(newMarshaler); ok {
-		siz := m.XXX_Size()
-		p.grow(siz) // make sure buf has enough capacity
-		p.buf, err = m.XXX_Marshal(p.buf, p.deterministic)
-		return err
-	}
-	if m, ok := pb.(Marshaler); ok {
-		// If the message can marshal itself, let it do it, for compatibility.
-		// NOTE: This is not efficient.
-		b, err := m.Marshal()
-		p.buf = append(p.buf, b...)
-		return err
-	}
-	// in case somehow we didn't generate the wrapper
-	if pb == nil {
-		return ErrNil
-	}
-	var info InternalMessageInfo
-	siz := info.Size(pb)
-	p.grow(siz) // make sure buf has enough capacity
-	p.buf, err = info.Marshal(p.buf, pb, p.deterministic)
-	return err
-}
-
-// grow grows the buffer's capacity, if necessary, to guarantee space for
-// another n bytes. After grow(n), at least n bytes can be written to the
-// buffer without another allocation.
-func (p *Buffer) grow(n int) {
-	need := len(p.buf) + n
-	if need <= cap(p.buf) {
-		return
-	}
-	newCap := len(p.buf) * 2
-	if newCap < need {
-		newCap = need
-	}
-	p.buf = append(make([]byte, 0, newCap), p.buf...)
-}
diff --git a/vendor/github.com/golang/protobuf/proto/table_merge.go b/vendor/github.com/golang/protobuf/proto/table_merge.go
deleted file mode 100644
index 5525def6a..000000000
--- a/vendor/github.com/golang/protobuf/proto/table_merge.go
+++ /dev/null
@@ -1,654 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2016 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package proto
-
-import (
-	"fmt"
-	"reflect"
-	"strings"
-	"sync"
-	"sync/atomic"
-)
-
-// Merge merges the src message into dst.
-// This assumes that dst and src of the same type and are non-nil.
-func (a *InternalMessageInfo) Merge(dst, src Message) {
-	mi := atomicLoadMergeInfo(&a.merge)
-	if mi == nil {
-		mi = getMergeInfo(reflect.TypeOf(dst).Elem())
-		atomicStoreMergeInfo(&a.merge, mi)
-	}
-	mi.merge(toPointer(&dst), toPointer(&src))
-}
-
-type mergeInfo struct {
-	typ reflect.Type
-
-	initialized int32 // 0: only typ is valid, 1: everything is valid
-	lock        sync.Mutex
-
-	fields       []mergeFieldInfo
-	unrecognized field // Offset of XXX_unrecognized
-}
-
-type mergeFieldInfo struct {
-	field field // Offset of field, guaranteed to be valid
-
-	// isPointer reports whether the value in the field is a pointer.
-	// This is true for the following situations:
-	//	* Pointer to struct
-	//	* Pointer to basic type (proto2 only)
-	//	* Slice (first value in slice header is a pointer)
-	//	* String (first value in string header is a pointer)
-	isPointer bool
-
-	// basicWidth reports the width of the field assuming that it is directly
-	// embedded in the struct (as is the case for basic types in proto3).
-	// The possible values are:
-	// 	0: invalid
-	//	1: bool
-	//	4: int32, uint32, float32
-	//	8: int64, uint64, float64
-	basicWidth int
-
-	// Where dst and src are pointers to the types being merged.
-	merge func(dst, src pointer)
-}
-
-var (
-	mergeInfoMap  = map[reflect.Type]*mergeInfo{}
-	mergeInfoLock sync.Mutex
-)
-
-func getMergeInfo(t reflect.Type) *mergeInfo {
-	mergeInfoLock.Lock()
-	defer mergeInfoLock.Unlock()
-	mi := mergeInfoMap[t]
-	if mi == nil {
-		mi = &mergeInfo{typ: t}
-		mergeInfoMap[t] = mi
-	}
-	return mi
-}
-
-// merge merges src into dst assuming they are both of type *mi.typ.
-func (mi *mergeInfo) merge(dst, src pointer) {
-	if dst.isNil() {
-		panic("proto: nil destination")
-	}
-	if src.isNil() {
-		return // Nothing to do.
-	}
-
-	if atomic.LoadInt32(&mi.initialized) == 0 {
-		mi.computeMergeInfo()
-	}
-
-	for _, fi := range mi.fields {
-		sfp := src.offset(fi.field)
-
-		// As an optimization, we can avoid the merge function call cost
-		// if we know for sure that the source will have no effect
-		// by checking if it is the zero value.
-		if unsafeAllowed {
-			if fi.isPointer && sfp.getPointer().isNil() { // Could be slice or string
-				continue
-			}
-			if fi.basicWidth > 0 {
-				switch {
-				case fi.basicWidth == 1 && !*sfp.toBool():
-					continue
-				case fi.basicWidth == 4 && *sfp.toUint32() == 0:
-					continue
-				case fi.basicWidth == 8 && *sfp.toUint64() == 0:
-					continue
-				}
-			}
-		}
-
-		dfp := dst.offset(fi.field)
-		fi.merge(dfp, sfp)
-	}
-
-	// TODO: Make this faster?
-	out := dst.asPointerTo(mi.typ).Elem()
-	in := src.asPointerTo(mi.typ).Elem()
-	if emIn, err := extendable(in.Addr().Interface()); err == nil {
-		emOut, _ := extendable(out.Addr().Interface())
-		mIn, muIn := emIn.extensionsRead()
-		if mIn != nil {
-			mOut := emOut.extensionsWrite()
-			muIn.Lock()
-			mergeExtension(mOut, mIn)
-			muIn.Unlock()
-		}
-	}
-
-	if mi.unrecognized.IsValid() {
-		if b := *src.offset(mi.unrecognized).toBytes(); len(b) > 0 {
-			*dst.offset(mi.unrecognized).toBytes() = append([]byte(nil), b...)
-		}
-	}
-}
-
-func (mi *mergeInfo) computeMergeInfo() {
-	mi.lock.Lock()
-	defer mi.lock.Unlock()
-	if mi.initialized != 0 {
-		return
-	}
-	t := mi.typ
-	n := t.NumField()
-
-	props := GetProperties(t)
-	for i := 0; i < n; i++ {
-		f := t.Field(i)
-		if strings.HasPrefix(f.Name, "XXX_") {
-			continue
-		}
-
-		mfi := mergeFieldInfo{field: toField(&f)}
-		tf := f.Type
-
-		// As an optimization, we can avoid the merge function call cost
-		// if we know for sure that the source will have no effect
-		// by checking if it is the zero value.
-		if unsafeAllowed {
-			switch tf.Kind() {
-			case reflect.Ptr, reflect.Slice, reflect.String:
-				// As a special case, we assume slices and strings are pointers
-				// since we know that the first field in the SliceSlice or
-				// StringHeader is a data pointer.
-				mfi.isPointer = true
-			case reflect.Bool:
-				mfi.basicWidth = 1
-			case reflect.Int32, reflect.Uint32, reflect.Float32:
-				mfi.basicWidth = 4
-			case reflect.Int64, reflect.Uint64, reflect.Float64:
-				mfi.basicWidth = 8
-			}
-		}
-
-		// Unwrap tf to get at its most basic type.
-		var isPointer, isSlice bool
-		if tf.Kind() == reflect.Slice && tf.Elem().Kind() != reflect.Uint8 {
-			isSlice = true
-			tf = tf.Elem()
-		}
-		if tf.Kind() == reflect.Ptr {
-			isPointer = true
-			tf = tf.Elem()
-		}
-		if isPointer && isSlice && tf.Kind() != reflect.Struct {
-			panic("both pointer and slice for basic type in " + tf.Name())
-		}
-
-		switch tf.Kind() {
-		case reflect.Int32:
-			switch {
-			case isSlice: // E.g., []int32
-				mfi.merge = func(dst, src pointer) {
-					// NOTE: toInt32Slice is not defined (see pointer_reflect.go).
-					/*
-						sfsp := src.toInt32Slice()
-						if *sfsp != nil {
-							dfsp := dst.toInt32Slice()
-							*dfsp = append(*dfsp, *sfsp...)
-							if *dfsp == nil {
-								*dfsp = []int64{}
-							}
-						}
-					*/
-					sfs := src.getInt32Slice()
-					if sfs != nil {
-						dfs := dst.getInt32Slice()
-						dfs = append(dfs, sfs...)
-						if dfs == nil {
-							dfs = []int32{}
-						}
-						dst.setInt32Slice(dfs)
-					}
-				}
-			case isPointer: // E.g., *int32
-				mfi.merge = func(dst, src pointer) {
-					// NOTE: toInt32Ptr is not defined (see pointer_reflect.go).
-					/*
-						sfpp := src.toInt32Ptr()
-						if *sfpp != nil {
-							dfpp := dst.toInt32Ptr()
-							if *dfpp == nil {
-								*dfpp = Int32(**sfpp)
-							} else {
-								**dfpp = **sfpp
-							}
-						}
-					*/
-					sfp := src.getInt32Ptr()
-					if sfp != nil {
-						dfp := dst.getInt32Ptr()
-						if dfp == nil {
-							dst.setInt32Ptr(*sfp)
-						} else {
-							*dfp = *sfp
-						}
-					}
-				}
-			default: // E.g., int32
-				mfi.merge = func(dst, src pointer) {
-					if v := *src.toInt32(); v != 0 {
-						*dst.toInt32() = v
-					}
-				}
-			}
-		case reflect.Int64:
-			switch {
-			case isSlice: // E.g., []int64
-				mfi.merge = func(dst, src pointer) {
-					sfsp := src.toInt64Slice()
-					if *sfsp != nil {
-						dfsp := dst.toInt64Slice()
-						*dfsp = append(*dfsp, *sfsp...)
-						if *dfsp == nil {
-							*dfsp = []int64{}
-						}
-					}
-				}
-			case isPointer: // E.g., *int64
-				mfi.merge = func(dst, src pointer) {
-					sfpp := src.toInt64Ptr()
-					if *sfpp != nil {
-						dfpp := dst.toInt64Ptr()
-						if *dfpp == nil {
-							*dfpp = Int64(**sfpp)
-						} else {
-							**dfpp = **sfpp
-						}
-					}
-				}
-			default: // E.g., int64
-				mfi.merge = func(dst, src pointer) {
-					if v := *src.toInt64(); v != 0 {
-						*dst.toInt64() = v
-					}
-				}
-			}
-		case reflect.Uint32:
-			switch {
-			case isSlice: // E.g., []uint32
-				mfi.merge = func(dst, src pointer) {
-					sfsp := src.toUint32Slice()
-					if *sfsp != nil {
-						dfsp := dst.toUint32Slice()
-						*dfsp = append(*dfsp, *sfsp...)
-						if *dfsp == nil {
-							*dfsp = []uint32{}
-						}
-					}
-				}
-			case isPointer: // E.g., *uint32
-				mfi.merge = func(dst, src pointer) {
-					sfpp := src.toUint32Ptr()
-					if *sfpp != nil {
-						dfpp := dst.toUint32Ptr()
-						if *dfpp == nil {
-							*dfpp = Uint32(**sfpp)
-						} else {
-							**dfpp = **sfpp
-						}
-					}
-				}
-			default: // E.g., uint32
-				mfi.merge = func(dst, src pointer) {
-					if v := *src.toUint32(); v != 0 {
-						*dst.toUint32() = v
-					}
-				}
-			}
-		case reflect.Uint64:
-			switch {
-			case isSlice: // E.g., []uint64
-				mfi.merge = func(dst, src pointer) {
-					sfsp := src.toUint64Slice()
-					if *sfsp != nil {
-						dfsp := dst.toUint64Slice()
-						*dfsp = append(*dfsp, *sfsp...)
-						if *dfsp == nil {
-							*dfsp = []uint64{}
-						}
-					}
-				}
-			case isPointer: // E.g., *uint64
-				mfi.merge = func(dst, src pointer) {
-					sfpp := src.toUint64Ptr()
-					if *sfpp != nil {
-						dfpp := dst.toUint64Ptr()
-						if *dfpp == nil {
-							*dfpp = Uint64(**sfpp)
-						} else {
-							**dfpp = **sfpp
-						}
-					}
-				}
-			default: // E.g., uint64
-				mfi.merge = func(dst, src pointer) {
-					if v := *src.toUint64(); v != 0 {
-						*dst.toUint64() = v
-					}
-				}
-			}
-		case reflect.Float32:
-			switch {
-			case isSlice: // E.g., []float32
-				mfi.merge = func(dst, src pointer) {
-					sfsp := src.toFloat32Slice()
-					if *sfsp != nil {
-						dfsp := dst.toFloat32Slice()
-						*dfsp = append(*dfsp, *sfsp...)
-						if *dfsp == nil {
-							*dfsp = []float32{}
-						}
-					}
-				}
-			case isPointer: // E.g., *float32
-				mfi.merge = func(dst, src pointer) {
-					sfpp := src.toFloat32Ptr()
-					if *sfpp != nil {
-						dfpp := dst.toFloat32Ptr()
-						if *dfpp == nil {
-							*dfpp = Float32(**sfpp)
-						} else {
-							**dfpp = **sfpp
-						}
-					}
-				}
-			default: // E.g., float32
-				mfi.merge = func(dst, src pointer) {
-					if v := *src.toFloat32(); v != 0 {
-						*dst.toFloat32() = v
-					}
-				}
-			}
-		case reflect.Float64:
-			switch {
-			case isSlice: // E.g., []float64
-				mfi.merge = func(dst, src pointer) {
-					sfsp := src.toFloat64Slice()
-					if *sfsp != nil {
-						dfsp := dst.toFloat64Slice()
-						*dfsp = append(*dfsp, *sfsp...)
-						if *dfsp == nil {
-							*dfsp = []float64{}
-						}
-					}
-				}
-			case isPointer: // E.g., *float64
-				mfi.merge = func(dst, src pointer) {
-					sfpp := src.toFloat64Ptr()
-					if *sfpp != nil {
-						dfpp := dst.toFloat64Ptr()
-						if *dfpp == nil {
-							*dfpp = Float64(**sfpp)
-						} else {
-							**dfpp = **sfpp
-						}
-					}
-				}
-			default: // E.g., float64
-				mfi.merge = func(dst, src pointer) {
-					if v := *src.toFloat64(); v != 0 {
-						*dst.toFloat64() = v
-					}
-				}
-			}
-		case reflect.Bool:
-			switch {
-			case isSlice: // E.g., []bool
-				mfi.merge = func(dst, src pointer) {
-					sfsp := src.toBoolSlice()
-					if *sfsp != nil {
-						dfsp := dst.toBoolSlice()
-						*dfsp = append(*dfsp, *sfsp...)
-						if *dfsp == nil {
-							*dfsp = []bool{}
-						}
-					}
-				}
-			case isPointer: // E.g., *bool
-				mfi.merge = func(dst, src pointer) {
-					sfpp := src.toBoolPtr()
-					if *sfpp != nil {
-						dfpp := dst.toBoolPtr()
-						if *dfpp == nil {
-							*dfpp = Bool(**sfpp)
-						} else {
-							**dfpp = **sfpp
-						}
-					}
-				}
-			default: // E.g., bool
-				mfi.merge = func(dst, src pointer) {
-					if v := *src.toBool(); v {
-						*dst.toBool() = v
-					}
-				}
-			}
-		case reflect.String:
-			switch {
-			case isSlice: // E.g., []string
-				mfi.merge = func(dst, src pointer) {
-					sfsp := src.toStringSlice()
-					if *sfsp != nil {
-						dfsp := dst.toStringSlice()
-						*dfsp = append(*dfsp, *sfsp...)
-						if *dfsp == nil {
-							*dfsp = []string{}
-						}
-					}
-				}
-			case isPointer: // E.g., *string
-				mfi.merge = func(dst, src pointer) {
-					sfpp := src.toStringPtr()
-					if *sfpp != nil {
-						dfpp := dst.toStringPtr()
-						if *dfpp == nil {
-							*dfpp = String(**sfpp)
-						} else {
-							**dfpp = **sfpp
-						}
-					}
-				}
-			default: // E.g., string
-				mfi.merge = func(dst, src pointer) {
-					if v := *src.toString(); v != "" {
-						*dst.toString() = v
-					}
-				}
-			}
-		case reflect.Slice:
-			isProto3 := props.Prop[i].proto3
-			switch {
-			case isPointer:
-				panic("bad pointer in byte slice case in " + tf.Name())
-			case tf.Elem().Kind() != reflect.Uint8:
-				panic("bad element kind in byte slice case in " + tf.Name())
-			case isSlice: // E.g., [][]byte
-				mfi.merge = func(dst, src pointer) {
-					sbsp := src.toBytesSlice()
-					if *sbsp != nil {
-						dbsp := dst.toBytesSlice()
-						for _, sb := range *sbsp {
-							if sb == nil {
-								*dbsp = append(*dbsp, nil)
-							} else {
-								*dbsp = append(*dbsp, append([]byte{}, sb...))
-							}
-						}
-						if *dbsp == nil {
-							*dbsp = [][]byte{}
-						}
-					}
-				}
-			default: // E.g., []byte
-				mfi.merge = func(dst, src pointer) {
-					sbp := src.toBytes()
-					if *sbp != nil {
-						dbp := dst.toBytes()
-						if !isProto3 || len(*sbp) > 0 {
-							*dbp = append([]byte{}, *sbp...)
-						}
-					}
-				}
-			}
-		case reflect.Struct:
-			switch {
-			case !isPointer:
-				panic(fmt.Sprintf("message field %s without pointer", tf))
-			case isSlice: // E.g., []*pb.T
-				mi := getMergeInfo(tf)
-				mfi.merge = func(dst, src pointer) {
-					sps := src.getPointerSlice()
-					if sps != nil {
-						dps := dst.getPointerSlice()
-						for _, sp := range sps {
-							var dp pointer
-							if !sp.isNil() {
-								dp = valToPointer(reflect.New(tf))
-								mi.merge(dp, sp)
-							}
-							dps = append(dps, dp)
-						}
-						if dps == nil {
-							dps = []pointer{}
-						}
-						dst.setPointerSlice(dps)
-					}
-				}
-			default: // E.g., *pb.T
-				mi := getMergeInfo(tf)
-				mfi.merge = func(dst, src pointer) {
-					sp := src.getPointer()
-					if !sp.isNil() {
-						dp := dst.getPointer()
-						if dp.isNil() {
-							dp = valToPointer(reflect.New(tf))
-							dst.setPointer(dp)
-						}
-						mi.merge(dp, sp)
-					}
-				}
-			}
-		case reflect.Map:
-			switch {
-			case isPointer || isSlice:
-				panic("bad pointer or slice in map case in " + tf.Name())
-			default: // E.g., map[K]V
-				mfi.merge = func(dst, src pointer) {
-					sm := src.asPointerTo(tf).Elem()
-					if sm.Len() == 0 {
-						return
-					}
-					dm := dst.asPointerTo(tf).Elem()
-					if dm.IsNil() {
-						dm.Set(reflect.MakeMap(tf))
-					}
-
-					switch tf.Elem().Kind() {
-					case reflect.Ptr: // Proto struct (e.g., *T)
-						for _, key := range sm.MapKeys() {
-							val := sm.MapIndex(key)
-							val = reflect.ValueOf(Clone(val.Interface().(Message)))
-							dm.SetMapIndex(key, val)
-						}
-					case reflect.Slice: // E.g. Bytes type (e.g., []byte)
-						for _, key := range sm.MapKeys() {
-							val := sm.MapIndex(key)
-							val = reflect.ValueOf(append([]byte{}, val.Bytes()...))
-							dm.SetMapIndex(key, val)
-						}
-					default: // Basic type (e.g., string)
-						for _, key := range sm.MapKeys() {
-							val := sm.MapIndex(key)
-							dm.SetMapIndex(key, val)
-						}
-					}
-				}
-			}
-		case reflect.Interface:
-			// Must be oneof field.
-			switch {
-			case isPointer || isSlice:
-				panic("bad pointer or slice in interface case in " + tf.Name())
-			default: // E.g., interface{}
-				// TODO: Make this faster?
-				mfi.merge = func(dst, src pointer) {
-					su := src.asPointerTo(tf).Elem()
-					if !su.IsNil() {
-						du := dst.asPointerTo(tf).Elem()
-						typ := su.Elem().Type()
-						if du.IsNil() || du.Elem().Type() != typ {
-							du.Set(reflect.New(typ.Elem())) // Initialize interface if empty
-						}
-						sv := su.Elem().Elem().Field(0)
-						if sv.Kind() == reflect.Ptr && sv.IsNil() {
-							return
-						}
-						dv := du.Elem().Elem().Field(0)
-						if dv.Kind() == reflect.Ptr && dv.IsNil() {
-							dv.Set(reflect.New(sv.Type().Elem())) // Initialize proto message if empty
-						}
-						switch sv.Type().Kind() {
-						case reflect.Ptr: // Proto struct (e.g., *T)
-							Merge(dv.Interface().(Message), sv.Interface().(Message))
-						case reflect.Slice: // E.g. Bytes type (e.g., []byte)
-							dv.Set(reflect.ValueOf(append([]byte{}, sv.Bytes()...)))
-						default: // Basic type (e.g., string)
-							dv.Set(sv)
-						}
-					}
-				}
-			}
-		default:
-			panic(fmt.Sprintf("merger not found for type:%s", tf))
-		}
-		mi.fields = append(mi.fields, mfi)
-	}
-
-	mi.unrecognized = invalidField
-	if f, ok := t.FieldByName("XXX_unrecognized"); ok {
-		if f.Type != reflect.TypeOf([]byte{}) {
-			panic("expected XXX_unrecognized to be of type []byte")
-		}
-		mi.unrecognized = toField(&f)
-	}
-
-	atomic.StoreInt32(&mi.initialized, 1)
-}
diff --git a/vendor/github.com/golang/protobuf/proto/table_unmarshal.go b/vendor/github.com/golang/protobuf/proto/table_unmarshal.go
deleted file mode 100644
index 96764347a..000000000
--- a/vendor/github.com/golang/protobuf/proto/table_unmarshal.go
+++ /dev/null
@@ -1,1981 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2016 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package proto
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"math"
-	"reflect"
-	"strconv"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"unicode/utf8"
-)
-
-// Unmarshal is the entry point from the generated .pb.go files.
-// This function is not intended to be used by non-generated code.
-// This function is not subject to any compatibility guarantee.
-// msg contains a pointer to a protocol buffer struct.
-// b is the data to be unmarshaled into the protocol buffer.
-// a is a pointer to a place to store cached unmarshal information.
-func (a *InternalMessageInfo) Unmarshal(msg Message, b []byte) error {
-	// Load the unmarshal information for this message type.
-	// The atomic load ensures memory consistency.
-	u := atomicLoadUnmarshalInfo(&a.unmarshal)
-	if u == nil {
-		// Slow path: find unmarshal info for msg, update a with it.
-		u = getUnmarshalInfo(reflect.TypeOf(msg).Elem())
-		atomicStoreUnmarshalInfo(&a.unmarshal, u)
-	}
-	// Then do the unmarshaling.
-	err := u.unmarshal(toPointer(&msg), b)
-	return err
-}
-
-type unmarshalInfo struct {
-	typ reflect.Type // type of the protobuf struct
-
-	// 0 = only typ field is initialized
-	// 1 = completely initialized
-	initialized     int32
-	lock            sync.Mutex                    // prevents double initialization
-	dense           []unmarshalFieldInfo          // fields indexed by tag #
-	sparse          map[uint64]unmarshalFieldInfo // fields indexed by tag #
-	reqFields       []string                      // names of required fields
-	reqMask         uint64                        // 1<<len(reqFields)-1
-	unrecognized    field                         // offset of []byte to put unrecognized data (or invalidField if we should throw it away)
-	extensions      field                         // offset of extensions field (of type proto.XXX_InternalExtensions), or invalidField if it does not exist
-	oldExtensions   field                         // offset of old-form extensions field (of type map[int]Extension)
-	extensionRanges []ExtensionRange              // if non-nil, implies extensions field is valid
-	isMessageSet    bool                          // if true, implies extensions field is valid
-}
-
-// An unmarshaler takes a stream of bytes and a pointer to a field of a message.
-// It decodes the field, stores it at f, and returns the unused bytes.
-// w is the wire encoding.
-// b is the data after the tag and wire encoding have been read.
-type unmarshaler func(b []byte, f pointer, w int) ([]byte, error)
-
-type unmarshalFieldInfo struct {
-	// location of the field in the proto message structure.
-	field field
-
-	// function to unmarshal the data for the field.
-	unmarshal unmarshaler
-
-	// if a required field, contains a single set bit at this field's index in the required field list.
-	reqMask uint64
-
-	name string // name of the field, for error reporting
-}
-
-var (
-	unmarshalInfoMap  = map[reflect.Type]*unmarshalInfo{}
-	unmarshalInfoLock sync.Mutex
-)
-
-// getUnmarshalInfo returns the data structure which can be
-// subsequently used to unmarshal a message of the given type.
-// t is the type of the message (note: not pointer to message).
-func getUnmarshalInfo(t reflect.Type) *unmarshalInfo {
-	// It would be correct to return a new unmarshalInfo
-	// unconditionally. We would end up allocating one
-	// per occurrence of that type as a message or submessage.
-	// We use a cache here just to reduce memory usage.
-	unmarshalInfoLock.Lock()
-	defer unmarshalInfoLock.Unlock()
-	u := unmarshalInfoMap[t]
-	if u == nil {
-		u = &unmarshalInfo{typ: t}
-		// Note: we just set the type here. The rest of the fields
-		// will be initialized on first use.
-		unmarshalInfoMap[t] = u
-	}
-	return u
-}
-
-// unmarshal does the main work of unmarshaling a message.
-// u provides type information used to unmarshal the message.
-// m is a pointer to a protocol buffer message.
-// b is a byte stream to unmarshal into m.
-// This is top routine used when recursively unmarshaling submessages.
-func (u *unmarshalInfo) unmarshal(m pointer, b []byte) error {
-	if atomic.LoadInt32(&u.initialized) == 0 {
-		u.computeUnmarshalInfo()
-	}
-	if u.isMessageSet {
-		return UnmarshalMessageSet(b, m.offset(u.extensions).toExtensions())
-	}
-	var reqMask uint64            // bitmask of required fields we've seen.
-	var rnse *RequiredNotSetError // an instance of a RequiredNotSetError returned by a submessage.
-	for len(b) > 0 {
-		// Read tag and wire type.
-		// Special case 1 and 2 byte varints.
-		var x uint64
-		if b[0] < 128 {
-			x = uint64(b[0])
-			b = b[1:]
-		} else if len(b) >= 2 && b[1] < 128 {
-			x = uint64(b[0]&0x7f) + uint64(b[1])<<7
-			b = b[2:]
-		} else {
-			var n int
-			x, n = decodeVarint(b)
-			if n == 0 {
-				return io.ErrUnexpectedEOF
-			}
-			b = b[n:]
-		}
-		tag := x >> 3
-		wire := int(x) & 7
-
-		// Dispatch on the tag to one of the unmarshal* functions below.
-		var f unmarshalFieldInfo
-		if tag < uint64(len(u.dense)) {
-			f = u.dense[tag]
-		} else {
-			f = u.sparse[tag]
-		}
-		if fn := f.unmarshal; fn != nil {
-			var err error
-			b, err = fn(b, m.offset(f.field), wire)
-			if err == nil {
-				reqMask |= f.reqMask
-				continue
-			}
-			if r, ok := err.(*RequiredNotSetError); ok {
-				// Remember this error, but keep parsing. We need to produce
-				// a full parse even if a required field is missing.
-				rnse = r
-				reqMask |= f.reqMask
-				continue
-			}
-			if err != errInternalBadWireType {
-				if err == errInvalidUTF8 {
-					fullName := revProtoTypes[reflect.PtrTo(u.typ)] + "." + f.name
-					err = fmt.Errorf("proto: string field %q contains invalid UTF-8", fullName)
-				}
-				return err
-			}
-			// Fragments with bad wire type are treated as unknown fields.
-		}
-
-		// Unknown tag.
-		if !u.unrecognized.IsValid() {
-			// Don't keep unrecognized data; just skip it.
-			var err error
-			b, err = skipField(b, wire)
-			if err != nil {
-				return err
-			}
-			continue
-		}
-		// Keep unrecognized data around.
-		// maybe in extensions, maybe in the unrecognized field.
-		z := m.offset(u.unrecognized).toBytes()
-		var emap map[int32]Extension
-		var e Extension
-		for _, r := range u.extensionRanges {
-			if uint64(r.Start) <= tag && tag <= uint64(r.End) {
-				if u.extensions.IsValid() {
-					mp := m.offset(u.extensions).toExtensions()
-					emap = mp.extensionsWrite()
-					e = emap[int32(tag)]
-					z = &e.enc
-					break
-				}
-				if u.oldExtensions.IsValid() {
-					p := m.offset(u.oldExtensions).toOldExtensions()
-					emap = *p
-					if emap == nil {
-						emap = map[int32]Extension{}
-						*p = emap
-					}
-					e = emap[int32(tag)]
-					z = &e.enc
-					break
-				}
-				panic("no extensions field available")
-			}
-		}
-
-		// Use wire type to skip data.
-		var err error
-		b0 := b
-		b, err = skipField(b, wire)
-		if err != nil {
-			return err
-		}
-		*z = encodeVarint(*z, tag<<3|uint64(wire))
-		*z = append(*z, b0[:len(b0)-len(b)]...)
-
-		if emap != nil {
-			emap[int32(tag)] = e
-		}
-	}
-	if rnse != nil {
-		// A required field of a submessage/group is missing. Return that error.
-		return rnse
-	}
-	if reqMask != u.reqMask {
-		// A required field of this message is missing.
-		for _, n := range u.reqFields {
-			if reqMask&1 == 0 {
-				return &RequiredNotSetError{n}
-			}
-			reqMask >>= 1
-		}
-	}
-	return nil
-}
-
-// computeUnmarshalInfo fills in u with information for use
-// in unmarshaling protocol buffers of type u.typ.
-func (u *unmarshalInfo) computeUnmarshalInfo() {
-	u.lock.Lock()
-	defer u.lock.Unlock()
-	if u.initialized != 0 {
-		return
-	}
-	t := u.typ
-	n := t.NumField()
-
-	// Set up the "not found" value for the unrecognized byte buffer.
-	// This is the default for proto3.
-	u.unrecognized = invalidField
-	u.extensions = invalidField
-	u.oldExtensions = invalidField
-
-	// List of the generated type and offset for each oneof field.
-	type oneofField struct {
-		ityp  reflect.Type // interface type of oneof field
-		field field        // offset in containing message
-	}
-	var oneofFields []oneofField
-
-	for i := 0; i < n; i++ {
-		f := t.Field(i)
-		if f.Name == "XXX_unrecognized" {
-			// The byte slice used to hold unrecognized input is special.
-			if f.Type != reflect.TypeOf(([]byte)(nil)) {
-				panic("bad type for XXX_unrecognized field: " + f.Type.Name())
-			}
-			u.unrecognized = toField(&f)
-			continue
-		}
-		if f.Name == "XXX_InternalExtensions" {
-			// Ditto here.
-			if f.Type != reflect.TypeOf(XXX_InternalExtensions{}) {
-				panic("bad type for XXX_InternalExtensions field: " + f.Type.Name())
-			}
-			u.extensions = toField(&f)
-			if f.Tag.Get("protobuf_messageset") == "1" {
-				u.isMessageSet = true
-			}
-			continue
-		}
-		if f.Name == "XXX_extensions" {
-			// An older form of the extensions field.
-			if f.Type != reflect.TypeOf((map[int32]Extension)(nil)) {
-				panic("bad type for XXX_extensions field: " + f.Type.Name())
-			}
-			u.oldExtensions = toField(&f)
-			continue
-		}
-		if f.Name == "XXX_NoUnkeyedLiteral" || f.Name == "XXX_sizecache" {
-			continue
-		}
-
-		oneof := f.Tag.Get("protobuf_oneof")
-		if oneof != "" {
-			oneofFields = append(oneofFields, oneofField{f.Type, toField(&f)})
-			// The rest of oneof processing happens below.
-			continue
-		}
-
-		tags := f.Tag.Get("protobuf")
-		tagArray := strings.Split(tags, ",")
-		if len(tagArray) < 2 {
-			panic("protobuf tag not enough fields in " + t.Name() + "." + f.Name + ": " + tags)
-		}
-		tag, err := strconv.Atoi(tagArray[1])
-		if err != nil {
-			panic("protobuf tag field not an integer: " + tagArray[1])
-		}
-
-		name := ""
-		for _, tag := range tagArray[3:] {
-			if strings.HasPrefix(tag, "name=") {
-				name = tag[5:]
-			}
-		}
-
-		// Extract unmarshaling function from the field (its type and tags).
-		unmarshal := fieldUnmarshaler(&f)
-
-		// Required field?
-		var reqMask uint64
-		if tagArray[2] == "req" {
-			bit := len(u.reqFields)
-			u.reqFields = append(u.reqFields, name)
-			reqMask = uint64(1) << uint(bit)
-			// TODO: if we have more than 64 required fields, we end up
-			// not verifying that all required fields are present.
-			// Fix this, perhaps using a count of required fields?
-		}
-
-		// Store the info in the correct slot in the message.
-		u.setTag(tag, toField(&f), unmarshal, reqMask, name)
-	}
-
-	// Find any types associated with oneof fields.
-	// TODO: XXX_OneofFuncs returns more info than we need.  Get rid of some of it?
-	fn := reflect.Zero(reflect.PtrTo(t)).MethodByName("XXX_OneofFuncs")
-	if fn.IsValid() {
-		res := fn.Call(nil)[3] // last return value from XXX_OneofFuncs: []interface{}
-		for i := res.Len() - 1; i >= 0; i-- {
-			v := res.Index(i)                             // interface{}
-			tptr := reflect.ValueOf(v.Interface()).Type() // *Msg_X
-			typ := tptr.Elem()                            // Msg_X
-
-			f := typ.Field(0) // oneof implementers have one field
-			baseUnmarshal := fieldUnmarshaler(&f)
-			tags := strings.Split(f.Tag.Get("protobuf"), ",")
-			fieldNum, err := strconv.Atoi(tags[1])
-			if err != nil {
-				panic("protobuf tag field not an integer: " + tags[1])
-			}
-			var name string
-			for _, tag := range tags {
-				if strings.HasPrefix(tag, "name=") {
-					name = strings.TrimPrefix(tag, "name=")
-					break
-				}
-			}
-
-			// Find the oneof field that this struct implements.
-			// Might take O(n^2) to process all of the oneofs, but who cares.
-			for _, of := range oneofFields {
-				if tptr.Implements(of.ityp) {
-					// We have found the corresponding interface for this struct.
-					// That lets us know where this struct should be stored
-					// when we encounter it during unmarshaling.
-					unmarshal := makeUnmarshalOneof(typ, of.ityp, baseUnmarshal)
-					u.setTag(fieldNum, of.field, unmarshal, 0, name)
-				}
-			}
-		}
-	}
-
-	// Get extension ranges, if any.
-	fn = reflect.Zero(reflect.PtrTo(t)).MethodByName("ExtensionRangeArray")
-	if fn.IsValid() {
-		if !u.extensions.IsValid() && !u.oldExtensions.IsValid() {
-			panic("a message with extensions, but no extensions field in " + t.Name())
-		}
-		u.extensionRanges = fn.Call(nil)[0].Interface().([]ExtensionRange)
-	}
-
-	// Explicitly disallow tag 0. This will ensure we flag an error
-	// when decoding a buffer of all zeros. Without this code, we
-	// would decode and skip an all-zero buffer of even length.
-	// [0 0] is [tag=0/wiretype=varint varint-encoded-0].
-	u.setTag(0, zeroField, func(b []byte, f pointer, w int) ([]byte, error) {
-		return nil, fmt.Errorf("proto: %s: illegal tag 0 (wire type %d)", t, w)
-	}, 0, "")
-
-	// Set mask for required field check.
-	u.reqMask = uint64(1)<<uint(len(u.reqFields)) - 1
-
-	atomic.StoreInt32(&u.initialized, 1)
-}
-
-// setTag stores the unmarshal information for the given tag.
-// tag = tag # for field
-// field/unmarshal = unmarshal info for that field.
-// reqMask = if required, bitmask for field position in required field list. 0 otherwise.
-// name = short name of the field.
-func (u *unmarshalInfo) setTag(tag int, field field, unmarshal unmarshaler, reqMask uint64, name string) {
-	i := unmarshalFieldInfo{field: field, unmarshal: unmarshal, reqMask: reqMask, name: name}
-	n := u.typ.NumField()
-	if tag >= 0 && (tag < 16 || tag < 2*n) { // TODO: what are the right numbers here?
-		for len(u.dense) <= tag {
-			u.dense = append(u.dense, unmarshalFieldInfo{})
-		}
-		u.dense[tag] = i
-		return
-	}
-	if u.sparse == nil {
-		u.sparse = map[uint64]unmarshalFieldInfo{}
-	}
-	u.sparse[uint64(tag)] = i
-}
-
-// fieldUnmarshaler returns an unmarshaler for the given field.
-func fieldUnmarshaler(f *reflect.StructField) unmarshaler {
-	if f.Type.Kind() == reflect.Map {
-		return makeUnmarshalMap(f)
-	}
-	return typeUnmarshaler(f.Type, f.Tag.Get("protobuf"))
-}
-
-// typeUnmarshaler returns an unmarshaler for the given field type / field tag pair.
-func typeUnmarshaler(t reflect.Type, tags string) unmarshaler {
-	tagArray := strings.Split(tags, ",")
-	encoding := tagArray[0]
-	name := "unknown"
-	for _, tag := range tagArray[3:] {
-		if strings.HasPrefix(tag, "name=") {
-			name = tag[5:]
-		}
-	}
-
-	// Figure out packaging (pointer, slice, or both)
-	slice := false
-	pointer := false
-	if t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8 {
-		slice = true
-		t = t.Elem()
-	}
-	if t.Kind() == reflect.Ptr {
-		pointer = true
-		t = t.Elem()
-	}
-
-	// We'll never have both pointer and slice for basic types.
-	if pointer && slice && t.Kind() != reflect.Struct {
-		panic("both pointer and slice for basic type in " + t.Name())
-	}
-
-	switch t.Kind() {
-	case reflect.Bool:
-		if pointer {
-			return unmarshalBoolPtr
-		}
-		if slice {
-			return unmarshalBoolSlice
-		}
-		return unmarshalBoolValue
-	case reflect.Int32:
-		switch encoding {
-		case "fixed32":
-			if pointer {
-				return unmarshalFixedS32Ptr
-			}
-			if slice {
-				return unmarshalFixedS32Slice
-			}
-			return unmarshalFixedS32Value
-		case "varint":
-			// this could be int32 or enum
-			if pointer {
-				return unmarshalInt32Ptr
-			}
-			if slice {
-				return unmarshalInt32Slice
-			}
-			return unmarshalInt32Value
-		case "zigzag32":
-			if pointer {
-				return unmarshalSint32Ptr
-			}
-			if slice {
-				return unmarshalSint32Slice
-			}
-			return unmarshalSint32Value
-		}
-	case reflect.Int64:
-		switch encoding {
-		case "fixed64":
-			if pointer {
-				return unmarshalFixedS64Ptr
-			}
-			if slice {
-				return unmarshalFixedS64Slice
-			}
-			return unmarshalFixedS64Value
-		case "varint":
-			if pointer {
-				return unmarshalInt64Ptr
-			}
-			if slice {
-				return unmarshalInt64Slice
-			}
-			return unmarshalInt64Value
-		case "zigzag64":
-			if pointer {
-				return unmarshalSint64Ptr
-			}
-			if slice {
-				return unmarshalSint64Slice
-			}
-			return unmarshalSint64Value
-		}
-	case reflect.Uint32:
-		switch encoding {
-		case "fixed32":
-			if pointer {
-				return unmarshalFixed32Ptr
-			}
-			if slice {
-				return unmarshalFixed32Slice
-			}
-			return unmarshalFixed32Value
-		case "varint":
-			if pointer {
-				return unmarshalUint32Ptr
-			}
-			if slice {
-				return unmarshalUint32Slice
-			}
-			return unmarshalUint32Value
-		}
-	case reflect.Uint64:
-		switch encoding {
-		case "fixed64":
-			if pointer {
-				return unmarshalFixed64Ptr
-			}
-			if slice {
-				return unmarshalFixed64Slice
-			}
-			return unmarshalFixed64Value
-		case "varint":
-			if pointer {
-				return unmarshalUint64Ptr
-			}
-			if slice {
-				return unmarshalUint64Slice
-			}
-			return unmarshalUint64Value
-		}
-	case reflect.Float32:
-		if pointer {
-			return unmarshalFloat32Ptr
-		}
-		if slice {
-			return unmarshalFloat32Slice
-		}
-		return unmarshalFloat32Value
-	case reflect.Float64:
-		if pointer {
-			return unmarshalFloat64Ptr
-		}
-		if slice {
-			return unmarshalFloat64Slice
-		}
-		return unmarshalFloat64Value
-	case reflect.Map:
-		panic("map type in typeUnmarshaler in " + t.Name())
-	case reflect.Slice:
-		if pointer {
-			panic("bad pointer in slice case in " + t.Name())
-		}
-		if slice {
-			return unmarshalBytesSlice
-		}
-		return unmarshalBytesValue
-	case reflect.String:
-		if pointer {
-			return unmarshalStringPtr
-		}
-		if slice {
-			return unmarshalStringSlice
-		}
-		return unmarshalStringValue
-	case reflect.Struct:
-		// message or group field
-		if !pointer {
-			panic(fmt.Sprintf("message/group field %s:%s without pointer", t, encoding))
-		}
-		switch encoding {
-		case "bytes":
-			if slice {
-				return makeUnmarshalMessageSlicePtr(getUnmarshalInfo(t), name)
-			}
-			return makeUnmarshalMessagePtr(getUnmarshalInfo(t), name)
-		case "group":
-			if slice {
-				return makeUnmarshalGroupSlicePtr(getUnmarshalInfo(t), name)
-			}
-			return makeUnmarshalGroupPtr(getUnmarshalInfo(t), name)
-		}
-	}
-	panic(fmt.Sprintf("unmarshaler not found type:%s encoding:%s", t, encoding))
-}
-
-// Below are all the unmarshalers for individual fields of various types.
-
-func unmarshalInt64Value(b []byte, f pointer, w int) ([]byte, error) {
-	if w != WireVarint {
-		return b, errInternalBadWireType
-	}
-	x, n := decodeVarint(b)
-	if n == 0 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	b = b[n:]
-	v := int64(x)
-	*f.toInt64() = v
-	return b, nil
-}
-
-func unmarshalInt64Ptr(b []byte, f pointer, w int) ([]byte, error) {
-	if w != WireVarint {
-		return b, errInternalBadWireType
-	}
-	x, n := decodeVarint(b)
-	if n == 0 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	b = b[n:]
-	v := int64(x)
-	*f.toInt64Ptr() = &v
-	return b, nil
-}
-
-func unmarshalInt64Slice(b []byte, f pointer, w int) ([]byte, error) {
-	if w == WireBytes { // packed
-		x, n := decodeVarint(b)
-		if n == 0 {
-			return nil, io.ErrUnexpectedEOF
-		}
-		b = b[n:]
-		if x > uint64(len(b)) {
-			return nil, io.ErrUnexpectedEOF
-		}
-		res := b[x:]
-		b = b[:x]
-		for len(b) > 0 {
-			x, n = decodeVarint(b)
-			if n == 0 {
-				return nil, io.ErrUnexpectedEOF
-			}
-			b = b[n:]
-			v := int64(x)
-			s := f.toInt64Slice()
-			*s = append(*s, v)
-		}
-		return res, nil
-	}
-	if w != WireVarint {
-		return b, errInternalBadWireType
-	}
-	x, n := decodeVarint(b)
-	if n == 0 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	b = b[n:]
-	v := int64(x)
-	s := f.toInt64Slice()
-	*s = append(*s, v)
-	return b, nil
-}
-
-func unmarshalSint64Value(b []byte, f pointer, w int) ([]byte, error) {
-	if w != WireVarint {
-		return b, errInternalBadWireType
-	}
-	x, n := decodeVarint(b)
-	if n == 0 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	b = b[n:]
-	v := int64(x>>1) ^ int64(x)<<63>>63
-	*f.toInt64() = v
-	return b, nil
-}
-
-func unmarshalSint64Ptr(b []byte, f pointer, w int) ([]byte, error) {
-	if w != WireVarint {
-		return b, errInternalBadWireType
-	}
-	x, n := decodeVarint(b)
-	if n == 0 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	b = b[n:]
-	v := int64(x>>1) ^ int64(x)<<63>>63
-	*f.toInt64Ptr() = &v
-	return b, nil
-}
-
-func unmarshalSint64Slice(b []byte, f pointer, w int) ([]byte, error) {
-	if w == WireBytes { // packed
-		x, n := decodeVarint(b)
-		if n == 0 {
-			return nil, io.ErrUnexpectedEOF
-		}
-		b = b[n:]
-		if x > uint64(len(b)) {
-			return nil, io.ErrUnexpectedEOF
-		}
-		res := b[x:]
-		b = b[:x]
-		for len(b) > 0 {
-			x, n = decodeVarint(b)
-			if n == 0 {
-				return nil, io.ErrUnexpectedEOF
-			}
-			b = b[n:]
-			v := int64(x>>1) ^ int64(x)<<63>>63
-			s := f.toInt64Slice()
-			*s = append(*s, v)
-		}
-		return res, nil
-	}
-	if w != WireVarint {
-		return b, errInternalBadWireType
-	}
-	x, n := decodeVarint(b)
-	if n == 0 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	b = b[n:]
-	v := int64(x>>1) ^ int64(x)<<63>>63
-	s := f.toInt64Slice()
-	*s = append(*s, v)
-	return b, nil
-}
-
-func unmarshalUint64Value(b []byte, f pointer, w int) ([]byte, error) {
-	if w != WireVarint {
-		return b, errInternalBadWireType
-	}
-	x, n := decodeVarint(b)
-	if n == 0 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	b = b[n:]
-	v := uint64(x)
-	*f.toUint64() = v
-	return b, nil
-}
-
-func unmarshalUint64Ptr(b []byte, f pointer, w int) ([]byte, error) {
-	if w != WireVarint {
-		return b, errInternalBadWireType
-	}
-	x, n := decodeVarint(b)
-	if n == 0 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	b = b[n:]
-	v := uint64(x)
-	*f.toUint64Ptr() = &v
-	return b, nil
-}
-
-func unmarshalUint64Slice(b []byte, f pointer, w int) ([]byte, error) {
-	if w == WireBytes { // packed
-		x, n := decodeVarint(b)
-		if n == 0 {
-			return nil, io.ErrUnexpectedEOF
-		}
-		b = b[n:]
-		if x > uint64(len(b)) {
-			return nil, io.ErrUnexpectedEOF
-		}
-		res := b[x:]
-		b = b[:x]
-		for len(b) > 0 {
-			x, n = decodeVarint(b)
-			if n == 0 {
-				return nil, io.ErrUnexpectedEOF
-			}
-			b = b[n:]
-			v := uint64(x)
-			s := f.toUint64Slice()
-			*s = append(*s, v)
-		}
-		return res, nil
-	}
-	if w != WireVarint {
-		return b, errInternalBadWireType
-	}
-	x, n := decodeVarint(b)
-	if n == 0 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	b = b[n:]
-	v := uint64(x)
-	s := f.toUint64Slice()
-	*s = append(*s, v)
-	return b, nil
-}
-
-func unmarshalInt32Value(b []byte, f pointer, w int) ([]byte, error) {
-	if w != WireVarint {
-		return b, errInternalBadWireType
-	}
-	x, n := decodeVarint(b)
-	if n == 0 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	b = b[n:]
-	v := int32(x)
-	*f.toInt32() = v
-	return b, nil
-}
-
-func unmarshalInt32Ptr(b []byte, f pointer, w int) ([]byte, error) {
-	if w != WireVarint {
-		return b, errInternalBadWireType
-	}
-	x, n := decodeVarint(b)
-	if n == 0 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	b = b[n:]
-	v := int32(x)
-	f.setInt32Ptr(v)
-	return b, nil
-}
-
-func unmarshalInt32Slice(b []byte, f pointer, w int) ([]byte, error) {
-	if w == WireBytes { // packed
-		x, n := decodeVarint(b)
-		if n == 0 {
-			return nil, io.ErrUnexpectedEOF
-		}
-		b = b[n:]
-		if x > uint64(len(b)) {
-			return nil, io.ErrUnexpectedEOF
-		}
-		res := b[x:]
-		b = b[:x]
-		for len(b) > 0 {
-			x, n = decodeVarint(b)
-			if n == 0 {
-				return nil, io.ErrUnexpectedEOF
-			}
-			b = b[n:]
-			v := int32(x)
-			f.appendInt32Slice(v)
-		}
-		return res, nil
-	}
-	if w != WireVarint {
-		return b, errInternalBadWireType
-	}
-	x, n := decodeVarint(b)
-	if n == 0 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	b = b[n:]
-	v := int32(x)
-	f.appendInt32Slice(v)
-	return b, nil
-}
-
-func unmarshalSint32Value(b []byte, f pointer, w int) ([]byte, error) {
-	if w != WireVarint {
-		return b, errInternalBadWireType
-	}
-	x, n := decodeVarint(b)
-	if n == 0 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	b = b[n:]
-	v := int32(x>>1) ^ int32(x)<<31>>31
-	*f.toInt32() = v
-	return b, nil
-}
-
-func unmarshalSint32Ptr(b []byte, f pointer, w int) ([]byte, error) {
-	if w != WireVarint {
-		return b, errInternalBadWireType
-	}
-	x, n := decodeVarint(b)
-	if n == 0 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	b = b[n:]
-	v := int32(x>>1) ^ int32(x)<<31>>31
-	f.setInt32Ptr(v)
-	return b, nil
-}
-
-func unmarshalSint32Slice(b []byte, f pointer, w int) ([]byte, error) {
-	if w == WireBytes { // packed
-		x, n := decodeVarint(b)
-		if n == 0 {
-			return nil, io.ErrUnexpectedEOF
-		}
-		b = b[n:]
-		if x > uint64(len(b)) {
-			return nil, io.ErrUnexpectedEOF
-		}
-		res := b[x:]
-		b = b[:x]
-		for len(b) > 0 {
-			x, n = decodeVarint(b)
-			if n == 0 {
-				return nil, io.ErrUnexpectedEOF
-			}
-			b = b[n:]
-			v := int32(x>>1) ^ int32(x)<<31>>31
-			f.appendInt32Slice(v)
-		}
-		return res, nil
-	}
-	if w != WireVarint {
-		return b, errInternalBadWireType
-	}
-	x, n := decodeVarint(b)
-	if n == 0 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	b = b[n:]
-	v := int32(x>>1) ^ int32(x)<<31>>31
-	f.appendInt32Slice(v)
-	return b, nil
-}
-
-func unmarshalUint32Value(b []byte, f pointer, w int) ([]byte, error) {
-	if w != WireVarint {
-		return b, errInternalBadWireType
-	}
-	x, n := decodeVarint(b)
-	if n == 0 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	b = b[n:]
-	v := uint32(x)
-	*f.toUint32() = v
-	return b, nil
-}
-
-func unmarshalUint32Ptr(b []byte, f pointer, w int) ([]byte, error) {
-	if w != WireVarint {
-		return b, errInternalBadWireType
-	}
-	x, n := decodeVarint(b)
-	if n == 0 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	b = b[n:]
-	v := uint32(x)
-	*f.toUint32Ptr() = &v
-	return b, nil
-}
-
-func unmarshalUint32Slice(b []byte, f pointer, w int) ([]byte, error) {
-	if w == WireBytes { // packed
-		x, n := decodeVarint(b)
-		if n == 0 {
-			return nil, io.ErrUnexpectedEOF
-		}
-		b = b[n:]
-		if x > uint64(len(b)) {
-			return nil, io.ErrUnexpectedEOF
-		}
-		res := b[x:]
-		b = b[:x]
-		for len(b) > 0 {
-			x, n = decodeVarint(b)
-			if n == 0 {
-				return nil, io.ErrUnexpectedEOF
-			}
-			b = b[n:]
-			v := uint32(x)
-			s := f.toUint32Slice()
-			*s = append(*s, v)
-		}
-		return res, nil
-	}
-	if w != WireVarint {
-		return b, errInternalBadWireType
-	}
-	x, n := decodeVarint(b)
-	if n == 0 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	b = b[n:]
-	v := uint32(x)
-	s := f.toUint32Slice()
-	*s = append(*s, v)
-	return b, nil
-}
-
-func unmarshalFixed64Value(b []byte, f pointer, w int) ([]byte, error) {
-	if w != WireFixed64 {
-		return b, errInternalBadWireType
-	}
-	if len(b) < 8 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	v := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
-	*f.toUint64() = v
-	return b[8:], nil
-}
-
-func unmarshalFixed64Ptr(b []byte, f pointer, w int) ([]byte, error) {
-	if w != WireFixed64 {
-		return b, errInternalBadWireType
-	}
-	if len(b) < 8 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	v := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
-	*f.toUint64Ptr() = &v
-	return b[8:], nil
-}
-
-func unmarshalFixed64Slice(b []byte, f pointer, w int) ([]byte, error) {
-	if w == WireBytes { // packed
-		x, n := decodeVarint(b)
-		if n == 0 {
-			return nil, io.ErrUnexpectedEOF
-		}
-		b = b[n:]
-		if x > uint64(len(b)) {
-			return nil, io.ErrUnexpectedEOF
-		}
-		res := b[x:]
-		b = b[:x]
-		for len(b) > 0 {
-			if len(b) < 8 {
-				return nil, io.ErrUnexpectedEOF
-			}
-			v := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
-			s := f.toUint64Slice()
-			*s = append(*s, v)
-			b = b[8:]
-		}
-		return res, nil
-	}
-	if w != WireFixed64 {
-		return b, errInternalBadWireType
-	}
-	if len(b) < 8 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	v := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
-	s := f.toUint64Slice()
-	*s = append(*s, v)
-	return b[8:], nil
-}
-
-func unmarshalFixedS64Value(b []byte, f pointer, w int) ([]byte, error) {
-	if w != WireFixed64 {
-		return b, errInternalBadWireType
-	}
-	if len(b) < 8 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	v := int64(b[0]) | int64(b[1])<<8 | int64(b[2])<<16 | int64(b[3])<<24 | int64(b[4])<<32 | int64(b[5])<<40 | int64(b[6])<<48 | int64(b[7])<<56
-	*f.toInt64() = v
-	return b[8:], nil
-}
-
-func unmarshalFixedS64Ptr(b []byte, f pointer, w int) ([]byte, error) {
-	if w != WireFixed64 {
-		return b, errInternalBadWireType
-	}
-	if len(b) < 8 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	v := int64(b[0]) | int64(b[1])<<8 | int64(b[2])<<16 | int64(b[3])<<24 | int64(b[4])<<32 | int64(b[5])<<40 | int64(b[6])<<48 | int64(b[7])<<56
-	*f.toInt64Ptr() = &v
-	return b[8:], nil
-}
-
-func unmarshalFixedS64Slice(b []byte, f pointer, w int) ([]byte, error) {
-	if w == WireBytes { // packed
-		x, n := decodeVarint(b)
-		if n == 0 {
-			return nil, io.ErrUnexpectedEOF
-		}
-		b = b[n:]
-		if x > uint64(len(b)) {
-			return nil, io.ErrUnexpectedEOF
-		}
-		res := b[x:]
-		b = b[:x]
-		for len(b) > 0 {
-			if len(b) < 8 {
-				return nil, io.ErrUnexpectedEOF
-			}
-			v := int64(b[0]) | int64(b[1])<<8 | int64(b[2])<<16 | int64(b[3])<<24 | int64(b[4])<<32 | int64(b[5])<<40 | int64(b[6])<<48 | int64(b[7])<<56
-			s := f.toInt64Slice()
-			*s = append(*s, v)
-			b = b[8:]
-		}
-		return res, nil
-	}
-	if w != WireFixed64 {
-		return b, errInternalBadWireType
-	}
-	if len(b) < 8 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	v := int64(b[0]) | int64(b[1])<<8 | int64(b[2])<<16 | int64(b[3])<<24 | int64(b[4])<<32 | int64(b[5])<<40 | int64(b[6])<<48 | int64(b[7])<<56
-	s := f.toInt64Slice()
-	*s = append(*s, v)
-	return b[8:], nil
-}
-
-func unmarshalFixed32Value(b []byte, f pointer, w int) ([]byte, error) {
-	if w != WireFixed32 {
-		return b, errInternalBadWireType
-	}
-	if len(b) < 4 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
-	*f.toUint32() = v
-	return b[4:], nil
-}
-
-func unmarshalFixed32Ptr(b []byte, f pointer, w int) ([]byte, error) {
-	if w != WireFixed32 {
-		return b, errInternalBadWireType
-	}
-	if len(b) < 4 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
-	*f.toUint32Ptr() = &v
-	return b[4:], nil
-}
-
-func unmarshalFixed32Slice(b []byte, f pointer, w int) ([]byte, error) {
-	if w == WireBytes { // packed
-		x, n := decodeVarint(b)
-		if n == 0 {
-			return nil, io.ErrUnexpectedEOF
-		}
-		b = b[n:]
-		if x > uint64(len(b)) {
-			return nil, io.ErrUnexpectedEOF
-		}
-		res := b[x:]
-		b = b[:x]
-		for len(b) > 0 {
-			if len(b) < 4 {
-				return nil, io.ErrUnexpectedEOF
-			}
-			v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
-			s := f.toUint32Slice()
-			*s = append(*s, v)
-			b = b[4:]
-		}
-		return res, nil
-	}
-	if w != WireFixed32 {
-		return b, errInternalBadWireType
-	}
-	if len(b) < 4 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
-	s := f.toUint32Slice()
-	*s = append(*s, v)
-	return b[4:], nil
-}
-
-func unmarshalFixedS32Value(b []byte, f pointer, w int) ([]byte, error) {
-	if w != WireFixed32 {
-		return b, errInternalBadWireType
-	}
-	if len(b) < 4 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	v := int32(b[0]) | int32(b[1])<<8 | int32(b[2])<<16 | int32(b[3])<<24
-	*f.toInt32() = v
-	return b[4:], nil
-}
-
-func unmarshalFixedS32Ptr(b []byte, f pointer, w int) ([]byte, error) {
-	if w != WireFixed32 {
-		return b, errInternalBadWireType
-	}
-	if len(b) < 4 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	v := int32(b[0]) | int32(b[1])<<8 | int32(b[2])<<16 | int32(b[3])<<24
-	f.setInt32Ptr(v)
-	return b[4:], nil
-}
-
-func unmarshalFixedS32Slice(b []byte, f pointer, w int) ([]byte, error) {
-	if w == WireBytes { // packed
-		x, n := decodeVarint(b)
-		if n == 0 {
-			return nil, io.ErrUnexpectedEOF
-		}
-		b = b[n:]
-		if x > uint64(len(b)) {
-			return nil, io.ErrUnexpectedEOF
-		}
-		res := b[x:]
-		b = b[:x]
-		for len(b) > 0 {
-			if len(b) < 4 {
-				return nil, io.ErrUnexpectedEOF
-			}
-			v := int32(b[0]) | int32(b[1])<<8 | int32(b[2])<<16 | int32(b[3])<<24
-			f.appendInt32Slice(v)
-			b = b[4:]
-		}
-		return res, nil
-	}
-	if w != WireFixed32 {
-		return b, errInternalBadWireType
-	}
-	if len(b) < 4 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	v := int32(b[0]) | int32(b[1])<<8 | int32(b[2])<<16 | int32(b[3])<<24
-	f.appendInt32Slice(v)
-	return b[4:], nil
-}
-
-func unmarshalBoolValue(b []byte, f pointer, w int) ([]byte, error) {
-	if w != WireVarint {
-		return b, errInternalBadWireType
-	}
-	// Note: any length varint is allowed, even though any sane
-	// encoder will use one byte.
-	// See https://github.com/golang/protobuf/issues/76
-	x, n := decodeVarint(b)
-	if n == 0 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	// TODO: check if x>1? Tests seem to indicate no.
-	v := x != 0
-	*f.toBool() = v
-	return b[n:], nil
-}
-
-func unmarshalBoolPtr(b []byte, f pointer, w int) ([]byte, error) {
-	if w != WireVarint {
-		return b, errInternalBadWireType
-	}
-	x, n := decodeVarint(b)
-	if n == 0 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	v := x != 0
-	*f.toBoolPtr() = &v
-	return b[n:], nil
-}
-
-func unmarshalBoolSlice(b []byte, f pointer, w int) ([]byte, error) {
-	if w == WireBytes { // packed
-		x, n := decodeVarint(b)
-		if n == 0 {
-			return nil, io.ErrUnexpectedEOF
-		}
-		b = b[n:]
-		if x > uint64(len(b)) {
-			return nil, io.ErrUnexpectedEOF
-		}
-		res := b[x:]
-		b = b[:x]
-		for len(b) > 0 {
-			x, n = decodeVarint(b)
-			if n == 0 {
-				return nil, io.ErrUnexpectedEOF
-			}
-			v := x != 0
-			s := f.toBoolSlice()
-			*s = append(*s, v)
-			b = b[n:]
-		}
-		return res, nil
-	}
-	if w != WireVarint {
-		return b, errInternalBadWireType
-	}
-	x, n := decodeVarint(b)
-	if n == 0 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	v := x != 0
-	s := f.toBoolSlice()
-	*s = append(*s, v)
-	return b[n:], nil
-}
-
-func unmarshalFloat64Value(b []byte, f pointer, w int) ([]byte, error) {
-	if w != WireFixed64 {
-		return b, errInternalBadWireType
-	}
-	if len(b) < 8 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	v := math.Float64frombits(uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56)
-	*f.toFloat64() = v
-	return b[8:], nil
-}
-
-func unmarshalFloat64Ptr(b []byte, f pointer, w int) ([]byte, error) {
-	if w != WireFixed64 {
-		return b, errInternalBadWireType
-	}
-	if len(b) < 8 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	v := math.Float64frombits(uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56)
-	*f.toFloat64Ptr() = &v
-	return b[8:], nil
-}
-
-func unmarshalFloat64Slice(b []byte, f pointer, w int) ([]byte, error) {
-	if w == WireBytes { // packed
-		x, n := decodeVarint(b)
-		if n == 0 {
-			return nil, io.ErrUnexpectedEOF
-		}
-		b = b[n:]
-		if x > uint64(len(b)) {
-			return nil, io.ErrUnexpectedEOF
-		}
-		res := b[x:]
-		b = b[:x]
-		for len(b) > 0 {
-			if len(b) < 8 {
-				return nil, io.ErrUnexpectedEOF
-			}
-			v := math.Float64frombits(uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56)
-			s := f.toFloat64Slice()
-			*s = append(*s, v)
-			b = b[8:]
-		}
-		return res, nil
-	}
-	if w != WireFixed64 {
-		return b, errInternalBadWireType
-	}
-	if len(b) < 8 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	v := math.Float64frombits(uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56)
-	s := f.toFloat64Slice()
-	*s = append(*s, v)
-	return b[8:], nil
-}
-
-func unmarshalFloat32Value(b []byte, f pointer, w int) ([]byte, error) {
-	if w != WireFixed32 {
-		return b, errInternalBadWireType
-	}
-	if len(b) < 4 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	v := math.Float32frombits(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24)
-	*f.toFloat32() = v
-	return b[4:], nil
-}
-
-func unmarshalFloat32Ptr(b []byte, f pointer, w int) ([]byte, error) {
-	if w != WireFixed32 {
-		return b, errInternalBadWireType
-	}
-	if len(b) < 4 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	v := math.Float32frombits(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24)
-	*f.toFloat32Ptr() = &v
-	return b[4:], nil
-}
-
-func unmarshalFloat32Slice(b []byte, f pointer, w int) ([]byte, error) {
-	if w == WireBytes { // packed
-		x, n := decodeVarint(b)
-		if n == 0 {
-			return nil, io.ErrUnexpectedEOF
-		}
-		b = b[n:]
-		if x > uint64(len(b)) {
-			return nil, io.ErrUnexpectedEOF
-		}
-		res := b[x:]
-		b = b[:x]
-		for len(b) > 0 {
-			if len(b) < 4 {
-				return nil, io.ErrUnexpectedEOF
-			}
-			v := math.Float32frombits(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24)
-			s := f.toFloat32Slice()
-			*s = append(*s, v)
-			b = b[4:]
-		}
-		return res, nil
-	}
-	if w != WireFixed32 {
-		return b, errInternalBadWireType
-	}
-	if len(b) < 4 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	v := math.Float32frombits(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24)
-	s := f.toFloat32Slice()
-	*s = append(*s, v)
-	return b[4:], nil
-}
-
-func unmarshalStringValue(b []byte, f pointer, w int) ([]byte, error) {
-	if w != WireBytes {
-		return b, errInternalBadWireType
-	}
-	x, n := decodeVarint(b)
-	if n == 0 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	b = b[n:]
-	if x > uint64(len(b)) {
-		return nil, io.ErrUnexpectedEOF
-	}
-	v := string(b[:x])
-	if !utf8.ValidString(v) {
-		return nil, errInvalidUTF8
-	}
-	*f.toString() = v
-	return b[x:], nil
-}
-
-func unmarshalStringPtr(b []byte, f pointer, w int) ([]byte, error) {
-	if w != WireBytes {
-		return b, errInternalBadWireType
-	}
-	x, n := decodeVarint(b)
-	if n == 0 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	b = b[n:]
-	if x > uint64(len(b)) {
-		return nil, io.ErrUnexpectedEOF
-	}
-	v := string(b[:x])
-	if !utf8.ValidString(v) {
-		return nil, errInvalidUTF8
-	}
-	*f.toStringPtr() = &v
-	return b[x:], nil
-}
-
-func unmarshalStringSlice(b []byte, f pointer, w int) ([]byte, error) {
-	if w != WireBytes {
-		return b, errInternalBadWireType
-	}
-	x, n := decodeVarint(b)
-	if n == 0 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	b = b[n:]
-	if x > uint64(len(b)) {
-		return nil, io.ErrUnexpectedEOF
-	}
-	v := string(b[:x])
-	if !utf8.ValidString(v) {
-		return nil, errInvalidUTF8
-	}
-	s := f.toStringSlice()
-	*s = append(*s, v)
-	return b[x:], nil
-}
-
-var emptyBuf [0]byte
-
-func unmarshalBytesValue(b []byte, f pointer, w int) ([]byte, error) {
-	if w != WireBytes {
-		return b, errInternalBadWireType
-	}
-	x, n := decodeVarint(b)
-	if n == 0 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	b = b[n:]
-	if x > uint64(len(b)) {
-		return nil, io.ErrUnexpectedEOF
-	}
-	// The use of append here is a trick which avoids the zeroing
-	// that would be required if we used a make/copy pair.
-	// We append to emptyBuf instead of nil because we want
-	// a non-nil result even when the length is 0.
-	v := append(emptyBuf[:], b[:x]...)
-	*f.toBytes() = v
-	return b[x:], nil
-}
-
-func unmarshalBytesSlice(b []byte, f pointer, w int) ([]byte, error) {
-	if w != WireBytes {
-		return b, errInternalBadWireType
-	}
-	x, n := decodeVarint(b)
-	if n == 0 {
-		return nil, io.ErrUnexpectedEOF
-	}
-	b = b[n:]
-	if x > uint64(len(b)) {
-		return nil, io.ErrUnexpectedEOF
-	}
-	v := append(emptyBuf[:], b[:x]...)
-	s := f.toBytesSlice()
-	*s = append(*s, v)
-	return b[x:], nil
-}
-
-func makeUnmarshalMessagePtr(sub *unmarshalInfo, name string) unmarshaler {
-	return func(b []byte, f pointer, w int) ([]byte, error) {
-		if w != WireBytes {
-			return b, errInternalBadWireType
-		}
-		x, n := decodeVarint(b)
-		if n == 0 {
-			return nil, io.ErrUnexpectedEOF
-		}
-		b = b[n:]
-		if x > uint64(len(b)) {
-			return nil, io.ErrUnexpectedEOF
-		}
-		// First read the message field to see if something is there.
-		// The semantics of multiple submessages are weird.  Instead of
-		// the last one winning (as it is for all other fields), multiple
-		// submessages are merged.
-		v := f.getPointer()
-		if v.isNil() {
-			v = valToPointer(reflect.New(sub.typ))
-			f.setPointer(v)
-		}
-		err := sub.unmarshal(v, b[:x])
-		if err != nil {
-			if r, ok := err.(*RequiredNotSetError); ok {
-				r.field = name + "." + r.field
-			} else {
-				return nil, err
-			}
-		}
-		return b[x:], err
-	}
-}
-
-func makeUnmarshalMessageSlicePtr(sub *unmarshalInfo, name string) unmarshaler {
-	return func(b []byte, f pointer, w int) ([]byte, error) {
-		if w != WireBytes {
-			return b, errInternalBadWireType
-		}
-		x, n := decodeVarint(b)
-		if n == 0 {
-			return nil, io.ErrUnexpectedEOF
-		}
-		b = b[n:]
-		if x > uint64(len(b)) {
-			return nil, io.ErrUnexpectedEOF
-		}
-		v := valToPointer(reflect.New(sub.typ))
-		err := sub.unmarshal(v, b[:x])
-		if err != nil {
-			if r, ok := err.(*RequiredNotSetError); ok {
-				r.field = name + "." + r.field
-			} else {
-				return nil, err
-			}
-		}
-		f.appendPointer(v)
-		return b[x:], err
-	}
-}
-
-func makeUnmarshalGroupPtr(sub *unmarshalInfo, name string) unmarshaler {
-	return func(b []byte, f pointer, w int) ([]byte, error) {
-		if w != WireStartGroup {
-			return b, errInternalBadWireType
-		}
-		x, y := findEndGroup(b)
-		if x < 0 {
-			return nil, io.ErrUnexpectedEOF
-		}
-		v := f.getPointer()
-		if v.isNil() {
-			v = valToPointer(reflect.New(sub.typ))
-			f.setPointer(v)
-		}
-		err := sub.unmarshal(v, b[:x])
-		if err != nil {
-			if r, ok := err.(*RequiredNotSetError); ok {
-				r.field = name + "." + r.field
-			} else {
-				return nil, err
-			}
-		}
-		return b[y:], err
-	}
-}
-
-func makeUnmarshalGroupSlicePtr(sub *unmarshalInfo, name string) unmarshaler {
-	return func(b []byte, f pointer, w int) ([]byte, error) {
-		if w != WireStartGroup {
-			return b, errInternalBadWireType
-		}
-		x, y := findEndGroup(b)
-		if x < 0 {
-			return nil, io.ErrUnexpectedEOF
-		}
-		v := valToPointer(reflect.New(sub.typ))
-		err := sub.unmarshal(v, b[:x])
-		if err != nil {
-			if r, ok := err.(*RequiredNotSetError); ok {
-				r.field = name + "." + r.field
-			} else {
-				return nil, err
-			}
-		}
-		f.appendPointer(v)
-		return b[y:], err
-	}
-}
-
-func makeUnmarshalMap(f *reflect.StructField) unmarshaler {
-	t := f.Type
-	kt := t.Key()
-	vt := t.Elem()
-	unmarshalKey := typeUnmarshaler(kt, f.Tag.Get("protobuf_key"))
-	unmarshalVal := typeUnmarshaler(vt, f.Tag.Get("protobuf_val"))
-	return func(b []byte, f pointer, w int) ([]byte, error) {
-		// The map entry is a submessage. Figure out how big it is.
-		if w != WireBytes {
-			return nil, fmt.Errorf("proto: bad wiretype for map field: got %d want %d", w, WireBytes)
-		}
-		x, n := decodeVarint(b)
-		if n == 0 {
-			return nil, io.ErrUnexpectedEOF
-		}
-		b = b[n:]
-		if x > uint64(len(b)) {
-			return nil, io.ErrUnexpectedEOF
-		}
-		r := b[x:] // unused data to return
-		b = b[:x]  // data for map entry
-
-		// Note: we could use #keys * #values ~= 200 functions
-		// to do map decoding without reflection. Probably not worth it.
-		// Maps will be somewhat slow. Oh well.
-
-		// Read key and value from data.
-		k := reflect.New(kt)
-		v := reflect.New(vt)
-		for len(b) > 0 {
-			x, n := decodeVarint(b)
-			if n == 0 {
-				return nil, io.ErrUnexpectedEOF
-			}
-			wire := int(x) & 7
-			b = b[n:]
-
-			var err error
-			switch x >> 3 {
-			case 1:
-				b, err = unmarshalKey(b, valToPointer(k), wire)
-			case 2:
-				b, err = unmarshalVal(b, valToPointer(v), wire)
-			default:
-				err = errInternalBadWireType // skip unknown tag
-			}
-
-			if err == nil {
-				continue
-			}
-			if err != errInternalBadWireType {
-				return nil, err
-			}
-
-			// Skip past unknown fields.
-			b, err = skipField(b, wire)
-			if err != nil {
-				return nil, err
-			}
-		}
-
-		// Get map, allocate if needed.
-		m := f.asPointerTo(t).Elem() // an addressable map[K]T
-		if m.IsNil() {
-			m.Set(reflect.MakeMap(t))
-		}
-
-		// Insert into map.
-		m.SetMapIndex(k.Elem(), v.Elem())
-
-		return r, nil
-	}
-}
-
-// makeUnmarshalOneof makes an unmarshaler for oneof fields.
-// for:
-// message Msg {
-//   oneof F {
-//     int64 X = 1;
-//     float64 Y = 2;
-//   }
-// }
-// typ is the type of the concrete entry for a oneof case (e.g. Msg_X).
-// ityp is the interface type of the oneof field (e.g. isMsg_F).
-// unmarshal is the unmarshaler for the base type of the oneof case (e.g. int64).
-// Note that this function will be called once for each case in the oneof.
-func makeUnmarshalOneof(typ, ityp reflect.Type, unmarshal unmarshaler) unmarshaler {
-	sf := typ.Field(0)
-	field0 := toField(&sf)
-	return func(b []byte, f pointer, w int) ([]byte, error) {
-		// Allocate holder for value.
-		v := reflect.New(typ)
-
-		// Unmarshal data into holder.
-		// We unmarshal into the first field of the holder object.
-		var err error
-		b, err = unmarshal(b, valToPointer(v).offset(field0), w)
-		if err != nil {
-			return nil, err
-		}
-
-		// Write pointer to holder into target field.
-		f.asPointerTo(ityp).Elem().Set(v)
-
-		return b, nil
-	}
-}
-
-// Error used by decode internally.
-var errInternalBadWireType = errors.New("proto: internal error: bad wiretype")
-
-// skipField skips past a field of type wire and returns the remaining bytes.
-func skipField(b []byte, wire int) ([]byte, error) {
-	switch wire {
-	case WireVarint:
-		_, k := decodeVarint(b)
-		if k == 0 {
-			return b, io.ErrUnexpectedEOF
-		}
-		b = b[k:]
-	case WireFixed32:
-		if len(b) < 4 {
-			return b, io.ErrUnexpectedEOF
-		}
-		b = b[4:]
-	case WireFixed64:
-		if len(b) < 8 {
-			return b, io.ErrUnexpectedEOF
-		}
-		b = b[8:]
-	case WireBytes:
-		m, k := decodeVarint(b)
-		if k == 0 || uint64(len(b)-k) < m {
-			return b, io.ErrUnexpectedEOF
-		}
-		b = b[uint64(k)+m:]
-	case WireStartGroup:
-		_, i := findEndGroup(b)
-		if i == -1 {
-			return b, io.ErrUnexpectedEOF
-		}
-		b = b[i:]
-	default:
-		return b, fmt.Errorf("proto: can't skip unknown wire type %d", wire)
-	}
-	return b, nil
-}
-
-// findEndGroup finds the index of the next EndGroup tag.
-// Groups may be nested, so the "next" EndGroup tag is the first
-// unpaired EndGroup.
-// findEndGroup returns the indexes of the start and end of the EndGroup tag.
-// Returns (-1,-1) if it can't find one.
-func findEndGroup(b []byte) (int, int) {
-	depth := 1
-	i := 0
-	for {
-		x, n := decodeVarint(b[i:])
-		if n == 0 {
-			return -1, -1
-		}
-		j := i
-		i += n
-		switch x & 7 {
-		case WireVarint:
-			_, k := decodeVarint(b[i:])
-			if k == 0 {
-				return -1, -1
-			}
-			i += k
-		case WireFixed32:
-			if len(b)-4 < i {
-				return -1, -1
-			}
-			i += 4
-		case WireFixed64:
-			if len(b)-8 < i {
-				return -1, -1
-			}
-			i += 8
-		case WireBytes:
-			m, k := decodeVarint(b[i:])
-			if k == 0 {
-				return -1, -1
-			}
-			i += k
-			if uint64(len(b)-i) < m {
-				return -1, -1
-			}
-			i += int(m)
-		case WireStartGroup:
-			depth++
-		case WireEndGroup:
-			depth--
-			if depth == 0 {
-				return j, i
-			}
-		default:
-			return -1, -1
-		}
-	}
-}
-
-// encodeVarint appends a varint-encoded integer to b and returns the result.
-func encodeVarint(b []byte, x uint64) []byte {
-	for x >= 1<<7 {
-		b = append(b, byte(x&0x7f|0x80))
-		x >>= 7
-	}
-	return append(b, byte(x))
-}
-
-// decodeVarint reads a varint-encoded integer from b.
-// Returns the decoded integer and the number of bytes read.
-// If there is an error, it returns 0,0.
-func decodeVarint(b []byte) (uint64, int) {
-	var x, y uint64
-	if len(b) <= 0 {
-		goto bad
-	}
-	x = uint64(b[0])
-	if x < 0x80 {
-		return x, 1
-	}
-	x -= 0x80
-
-	if len(b) <= 1 {
-		goto bad
-	}
-	y = uint64(b[1])
-	x += y << 7
-	if y < 0x80 {
-		return x, 2
-	}
-	x -= 0x80 << 7
-
-	if len(b) <= 2 {
-		goto bad
-	}
-	y = uint64(b[2])
-	x += y << 14
-	if y < 0x80 {
-		return x, 3
-	}
-	x -= 0x80 << 14
-
-	if len(b) <= 3 {
-		goto bad
-	}
-	y = uint64(b[3])
-	x += y << 21
-	if y < 0x80 {
-		return x, 4
-	}
-	x -= 0x80 << 21
-
-	if len(b) <= 4 {
-		goto bad
-	}
-	y = uint64(b[4])
-	x += y << 28
-	if y < 0x80 {
-		return x, 5
-	}
-	x -= 0x80 << 28
-
-	if len(b) <= 5 {
-		goto bad
-	}
-	y = uint64(b[5])
-	x += y << 35
-	if y < 0x80 {
-		return x, 6
-	}
-	x -= 0x80 << 35
-
-	if len(b) <= 6 {
-		goto bad
-	}
-	y = uint64(b[6])
-	x += y << 42
-	if y < 0x80 {
-		return x, 7
-	}
-	x -= 0x80 << 42
-
-	if len(b) <= 7 {
-		goto bad
-	}
-	y = uint64(b[7])
-	x += y << 49
-	if y < 0x80 {
-		return x, 8
-	}
-	x -= 0x80 << 49
-
-	if len(b) <= 8 {
-		goto bad
-	}
-	y = uint64(b[8])
-	x += y << 56
-	if y < 0x80 {
-		return x, 9
-	}
-	x -= 0x80 << 56
-
-	if len(b) <= 9 {
-		goto bad
-	}
-	y = uint64(b[9])
-	x += y << 63
-	if y < 2 {
-		return x, 10
-	}
-
-bad:
-	return 0, 0
-}
diff --git a/vendor/github.com/golang/protobuf/proto/text.go b/vendor/github.com/golang/protobuf/proto/text.go
deleted file mode 100644
index 2205fdaad..000000000
--- a/vendor/github.com/golang/protobuf/proto/text.go
+++ /dev/null
@@ -1,843 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package proto
-
-// Functions for writing the text protocol buffer format.
-
-import (
-	"bufio"
-	"bytes"
-	"encoding"
-	"errors"
-	"fmt"
-	"io"
-	"log"
-	"math"
-	"reflect"
-	"sort"
-	"strings"
-)
-
-var (
-	newline         = []byte("\n")
-	spaces          = []byte("                                        ")
-	endBraceNewline = []byte("}\n")
-	backslashN      = []byte{'\\', 'n'}
-	backslashR      = []byte{'\\', 'r'}
-	backslashT      = []byte{'\\', 't'}
-	backslashDQ     = []byte{'\\', '"'}
-	backslashBS     = []byte{'\\', '\\'}
-	posInf          = []byte("inf")
-	negInf          = []byte("-inf")
-	nan             = []byte("nan")
-)
-
-type writer interface {
-	io.Writer
-	WriteByte(byte) error
-}
-
-// textWriter is an io.Writer that tracks its indentation level.
-type textWriter struct {
-	ind      int
-	complete bool // if the current position is a complete line
-	compact  bool // whether to write out as a one-liner
-	w        writer
-}
-
-func (w *textWriter) WriteString(s string) (n int, err error) {
-	if !strings.Contains(s, "\n") {
-		if !w.compact && w.complete {
-			w.writeIndent()
-		}
-		w.complete = false
-		return io.WriteString(w.w, s)
-	}
-	// WriteString is typically called without newlines, so this
-	// codepath and its copy are rare.  We copy to avoid
-	// duplicating all of Write's logic here.
-	return w.Write([]byte(s))
-}
-
-func (w *textWriter) Write(p []byte) (n int, err error) {
-	newlines := bytes.Count(p, newline)
-	if newlines == 0 {
-		if !w.compact && w.complete {
-			w.writeIndent()
-		}
-		n, err = w.w.Write(p)
-		w.complete = false
-		return n, err
-	}
-
-	frags := bytes.SplitN(p, newline, newlines+1)
-	if w.compact {
-		for i, frag := range frags {
-			if i > 0 {
-				if err := w.w.WriteByte(' '); err != nil {
-					return n, err
-				}
-				n++
-			}
-			nn, err := w.w.Write(frag)
-			n += nn
-			if err != nil {
-				return n, err
-			}
-		}
-		return n, nil
-	}
-
-	for i, frag := range frags {
-		if w.complete {
-			w.writeIndent()
-		}
-		nn, err := w.w.Write(frag)
-		n += nn
-		if err != nil {
-			return n, err
-		}
-		if i+1 < len(frags) {
-			if err := w.w.WriteByte('\n'); err != nil {
-				return n, err
-			}
-			n++
-		}
-	}
-	w.complete = len(frags[len(frags)-1]) == 0
-	return n, nil
-}
-
-func (w *textWriter) WriteByte(c byte) error {
-	if w.compact && c == '\n' {
-		c = ' '
-	}
-	if !w.compact && w.complete {
-		w.writeIndent()
-	}
-	err := w.w.WriteByte(c)
-	w.complete = c == '\n'
-	return err
-}
-
-func (w *textWriter) indent() { w.ind++ }
-
-func (w *textWriter) unindent() {
-	if w.ind == 0 {
-		log.Print("proto: textWriter unindented too far")
-		return
-	}
-	w.ind--
-}
-
-func writeName(w *textWriter, props *Properties) error {
-	if _, err := w.WriteString(props.OrigName); err != nil {
-		return err
-	}
-	if props.Wire != "group" {
-		return w.WriteByte(':')
-	}
-	return nil
-}
-
-func requiresQuotes(u string) bool {
-	// When type URL contains any characters except [0-9A-Za-z./\-]*, it must be quoted.
-	for _, ch := range u {
-		switch {
-		case ch == '.' || ch == '/' || ch == '_':
-			continue
-		case '0' <= ch && ch <= '9':
-			continue
-		case 'A' <= ch && ch <= 'Z':
-			continue
-		case 'a' <= ch && ch <= 'z':
-			continue
-		default:
-			return true
-		}
-	}
-	return false
-}
-
-// isAny reports whether sv is a google.protobuf.Any message
-func isAny(sv reflect.Value) bool {
-	type wkt interface {
-		XXX_WellKnownType() string
-	}
-	t, ok := sv.Addr().Interface().(wkt)
-	return ok && t.XXX_WellKnownType() == "Any"
-}
-
-// writeProto3Any writes an expanded google.protobuf.Any message.
-//
-// It returns (false, nil) if sv value can't be unmarshaled (e.g. because
-// required messages are not linked in).
-//
-// It returns (true, error) when sv was written in expanded format or an error
-// was encountered.
-func (tm *TextMarshaler) writeProto3Any(w *textWriter, sv reflect.Value) (bool, error) {
-	turl := sv.FieldByName("TypeUrl")
-	val := sv.FieldByName("Value")
-	if !turl.IsValid() || !val.IsValid() {
-		return true, errors.New("proto: invalid google.protobuf.Any message")
-	}
-
-	b, ok := val.Interface().([]byte)
-	if !ok {
-		return true, errors.New("proto: invalid google.protobuf.Any message")
-	}
-
-	parts := strings.Split(turl.String(), "/")
-	mt := MessageType(parts[len(parts)-1])
-	if mt == nil {
-		return false, nil
-	}
-	m := reflect.New(mt.Elem())
-	if err := Unmarshal(b, m.Interface().(Message)); err != nil {
-		return false, nil
-	}
-	w.Write([]byte("["))
-	u := turl.String()
-	if requiresQuotes(u) {
-		writeString(w, u)
-	} else {
-		w.Write([]byte(u))
-	}
-	if w.compact {
-		w.Write([]byte("]:<"))
-	} else {
-		w.Write([]byte("]: <\n"))
-		w.ind++
-	}
-	if err := tm.writeStruct(w, m.Elem()); err != nil {
-		return true, err
-	}
-	if w.compact {
-		w.Write([]byte("> "))
-	} else {
-		w.ind--
-		w.Write([]byte(">\n"))
-	}
-	return true, nil
-}
-
-func (tm *TextMarshaler) writeStruct(w *textWriter, sv reflect.Value) error {
-	if tm.ExpandAny && isAny(sv) {
-		if canExpand, err := tm.writeProto3Any(w, sv); canExpand {
-			return err
-		}
-	}
-	st := sv.Type()
-	sprops := GetProperties(st)
-	for i := 0; i < sv.NumField(); i++ {
-		fv := sv.Field(i)
-		props := sprops.Prop[i]
-		name := st.Field(i).Name
-
-		if name == "XXX_NoUnkeyedLiteral" {
-			continue
-		}
-
-		if strings.HasPrefix(name, "XXX_") {
-			// There are two XXX_ fields:
-			//   XXX_unrecognized []byte
-			//   XXX_extensions   map[int32]proto.Extension
-			// The first is handled here;
-			// the second is handled at the bottom of this function.
-			if name == "XXX_unrecognized" && !fv.IsNil() {
-				if err := writeUnknownStruct(w, fv.Interface().([]byte)); err != nil {
-					return err
-				}
-			}
-			continue
-		}
-		if fv.Kind() == reflect.Ptr && fv.IsNil() {
-			// Field not filled in. This could be an optional field or
-			// a required field that wasn't filled in. Either way, there
-			// isn't anything we can show for it.
-			continue
-		}
-		if fv.Kind() == reflect.Slice && fv.IsNil() {
-			// Repeated field that is empty, or a bytes field that is unused.
-			continue
-		}
-
-		if props.Repeated && fv.Kind() == reflect.Slice {
-			// Repeated field.
-			for j := 0; j < fv.Len(); j++ {
-				if err := writeName(w, props); err != nil {
-					return err
-				}
-				if !w.compact {
-					if err := w.WriteByte(' '); err != nil {
-						return err
-					}
-				}
-				v := fv.Index(j)
-				if v.Kind() == reflect.Ptr && v.IsNil() {
-					// A nil message in a repeated field is not valid,
-					// but we can handle that more gracefully than panicking.
-					if _, err := w.Write([]byte("<nil>\n")); err != nil {
-						return err
-					}
-					continue
-				}
-				if err := tm.writeAny(w, v, props); err != nil {
-					return err
-				}
-				if err := w.WriteByte('\n'); err != nil {
-					return err
-				}
-			}
-			continue
-		}
-		if fv.Kind() == reflect.Map {
-			// Map fields are rendered as a repeated struct with key/value fields.
-			keys := fv.MapKeys()
-			sort.Sort(mapKeys(keys))
-			for _, key := range keys {
-				val := fv.MapIndex(key)
-				if err := writeName(w, props); err != nil {
-					return err
-				}
-				if !w.compact {
-					if err := w.WriteByte(' '); err != nil {
-						return err
-					}
-				}
-				// open struct
-				if err := w.WriteByte('<'); err != nil {
-					return err
-				}
-				if !w.compact {
-					if err := w.WriteByte('\n'); err != nil {
-						return err
-					}
-				}
-				w.indent()
-				// key
-				if _, err := w.WriteString("key:"); err != nil {
-					return err
-				}
-				if !w.compact {
-					if err := w.WriteByte(' '); err != nil {
-						return err
-					}
-				}
-				if err := tm.writeAny(w, key, props.mkeyprop); err != nil {
-					return err
-				}
-				if err := w.WriteByte('\n'); err != nil {
-					return err
-				}
-				// nil values aren't legal, but we can avoid panicking because of them.
-				if val.Kind() != reflect.Ptr || !val.IsNil() {
-					// value
-					if _, err := w.WriteString("value:"); err != nil {
-						return err
-					}
-					if !w.compact {
-						if err := w.WriteByte(' '); err != nil {
-							return err
-						}
-					}
-					if err := tm.writeAny(w, val, props.mvalprop); err != nil {
-						return err
-					}
-					if err := w.WriteByte('\n'); err != nil {
-						return err
-					}
-				}
-				// close struct
-				w.unindent()
-				if err := w.WriteByte('>'); err != nil {
-					return err
-				}
-				if err := w.WriteByte('\n'); err != nil {
-					return err
-				}
-			}
-			continue
-		}
-		if props.proto3 && fv.Kind() == reflect.Slice && fv.Len() == 0 {
-			// empty bytes field
-			continue
-		}
-		if fv.Kind() != reflect.Ptr && fv.Kind() != reflect.Slice {
-			// proto3 non-repeated scalar field; skip if zero value
-			if isProto3Zero(fv) {
-				continue
-			}
-		}
-
-		if fv.Kind() == reflect.Interface {
-			// Check if it is a oneof.
-			if st.Field(i).Tag.Get("protobuf_oneof") != "" {
-				// fv is nil, or holds a pointer to generated struct.
-				// That generated struct has exactly one field,
-				// which has a protobuf struct tag.
-				if fv.IsNil() {
-					continue
-				}
-				inner := fv.Elem().Elem() // interface -> *T -> T
-				tag := inner.Type().Field(0).Tag.Get("protobuf")
-				props = new(Properties) // Overwrite the outer props var, but not its pointee.
-				props.Parse(tag)
-				// Write the value in the oneof, not the oneof itself.
-				fv = inner.Field(0)
-
-				// Special case to cope with malformed messages gracefully:
-				// If the value in the oneof is a nil pointer, don't panic
-				// in writeAny.
-				if fv.Kind() == reflect.Ptr && fv.IsNil() {
-					// Use errors.New so writeAny won't render quotes.
-					msg := errors.New("/* nil */")
-					fv = reflect.ValueOf(&msg).Elem()
-				}
-			}
-		}
-
-		if err := writeName(w, props); err != nil {
-			return err
-		}
-		if !w.compact {
-			if err := w.WriteByte(' '); err != nil {
-				return err
-			}
-		}
-
-		// Enums have a String method, so writeAny will work fine.
-		if err := tm.writeAny(w, fv, props); err != nil {
-			return err
-		}
-
-		if err := w.WriteByte('\n'); err != nil {
-			return err
-		}
-	}
-
-	// Extensions (the XXX_extensions field).
-	pv := sv.Addr()
-	if _, err := extendable(pv.Interface()); err == nil {
-		if err := tm.writeExtensions(w, pv); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// writeAny writes an arbitrary field.
-func (tm *TextMarshaler) writeAny(w *textWriter, v reflect.Value, props *Properties) error {
-	v = reflect.Indirect(v)
-
-	// Floats have special cases.
-	if v.Kind() == reflect.Float32 || v.Kind() == reflect.Float64 {
-		x := v.Float()
-		var b []byte
-		switch {
-		case math.IsInf(x, 1):
-			b = posInf
-		case math.IsInf(x, -1):
-			b = negInf
-		case math.IsNaN(x):
-			b = nan
-		}
-		if b != nil {
-			_, err := w.Write(b)
-			return err
-		}
-		// Other values are handled below.
-	}
-
-	// We don't attempt to serialise every possible value type; only those
-	// that can occur in protocol buffers.
-	switch v.Kind() {
-	case reflect.Slice:
-		// Should only be a []byte; repeated fields are handled in writeStruct.
-		if err := writeString(w, string(v.Bytes())); err != nil {
-			return err
-		}
-	case reflect.String:
-		if err := writeString(w, v.String()); err != nil {
-			return err
-		}
-	case reflect.Struct:
-		// Required/optional group/message.
-		var bra, ket byte = '<', '>'
-		if props != nil && props.Wire == "group" {
-			bra, ket = '{', '}'
-		}
-		if err := w.WriteByte(bra); err != nil {
-			return err
-		}
-		if !w.compact {
-			if err := w.WriteByte('\n'); err != nil {
-				return err
-			}
-		}
-		w.indent()
-		if v.CanAddr() {
-			// Calling v.Interface on a struct causes the reflect package to
-			// copy the entire struct. This is racy with the new Marshaler
-			// since we atomically update the XXX_sizecache.
-			//
-			// Thus, we retrieve a pointer to the struct if possible to avoid
-			// a race since v.Interface on the pointer doesn't copy the struct.
-			//
-			// If v is not addressable, then we are not worried about a race
-			// since it implies that the binary Marshaler cannot possibly be
-			// mutating this value.
-			v = v.Addr()
-		}
-		if etm, ok := v.Interface().(encoding.TextMarshaler); ok {
-			text, err := etm.MarshalText()
-			if err != nil {
-				return err
-			}
-			if _, err = w.Write(text); err != nil {
-				return err
-			}
-		} else {
-			if v.Kind() == reflect.Ptr {
-				v = v.Elem()
-			}
-			if err := tm.writeStruct(w, v); err != nil {
-				return err
-			}
-		}
-		w.unindent()
-		if err := w.WriteByte(ket); err != nil {
-			return err
-		}
-	default:
-		_, err := fmt.Fprint(w, v.Interface())
-		return err
-	}
-	return nil
-}
-
-// equivalent to C's isprint.
-func isprint(c byte) bool {
-	return c >= 0x20 && c < 0x7f
-}
-
-// writeString writes a string in the protocol buffer text format.
-// It is similar to strconv.Quote except we don't use Go escape sequences,
-// we treat the string as a byte sequence, and we use octal escapes.
-// These differences are to maintain interoperability with the other
-// languages' implementations of the text format.
-func writeString(w *textWriter, s string) error {
-	// use WriteByte here to get any needed indent
-	if err := w.WriteByte('"'); err != nil {
-		return err
-	}
-	// Loop over the bytes, not the runes.
-	for i := 0; i < len(s); i++ {
-		var err error
-		// Divergence from C++: we don't escape apostrophes.
-		// There's no need to escape them, and the C++ parser
-		// copes with a naked apostrophe.
-		switch c := s[i]; c {
-		case '\n':
-			_, err = w.w.Write(backslashN)
-		case '\r':
-			_, err = w.w.Write(backslashR)
-		case '\t':
-			_, err = w.w.Write(backslashT)
-		case '"':
-			_, err = w.w.Write(backslashDQ)
-		case '\\':
-			_, err = w.w.Write(backslashBS)
-		default:
-			if isprint(c) {
-				err = w.w.WriteByte(c)
-			} else {
-				_, err = fmt.Fprintf(w.w, "\\%03o", c)
-			}
-		}
-		if err != nil {
-			return err
-		}
-	}
-	return w.WriteByte('"')
-}
-
-func writeUnknownStruct(w *textWriter, data []byte) (err error) {
-	if !w.compact {
-		if _, err := fmt.Fprintf(w, "/* %d unknown bytes */\n", len(data)); err != nil {
-			return err
-		}
-	}
-	b := NewBuffer(data)
-	for b.index < len(b.buf) {
-		x, err := b.DecodeVarint()
-		if err != nil {
-			_, err := fmt.Fprintf(w, "/* %v */\n", err)
-			return err
-		}
-		wire, tag := x&7, x>>3
-		if wire == WireEndGroup {
-			w.unindent()
-			if _, err := w.Write(endBraceNewline); err != nil {
-				return err
-			}
-			continue
-		}
-		if _, err := fmt.Fprint(w, tag); err != nil {
-			return err
-		}
-		if wire != WireStartGroup {
-			if err := w.WriteByte(':'); err != nil {
-				return err
-			}
-		}
-		if !w.compact || wire == WireStartGroup {
-			if err := w.WriteByte(' '); err != nil {
-				return err
-			}
-		}
-		switch wire {
-		case WireBytes:
-			buf, e := b.DecodeRawBytes(false)
-			if e == nil {
-				_, err = fmt.Fprintf(w, "%q", buf)
-			} else {
-				_, err = fmt.Fprintf(w, "/* %v */", e)
-			}
-		case WireFixed32:
-			x, err = b.DecodeFixed32()
-			err = writeUnknownInt(w, x, err)
-		case WireFixed64:
-			x, err = b.DecodeFixed64()
-			err = writeUnknownInt(w, x, err)
-		case WireStartGroup:
-			err = w.WriteByte('{')
-			w.indent()
-		case WireVarint:
-			x, err = b.DecodeVarint()
-			err = writeUnknownInt(w, x, err)
-		default:
-			_, err = fmt.Fprintf(w, "/* unknown wire type %d */", wire)
-		}
-		if err != nil {
-			return err
-		}
-		if err = w.WriteByte('\n'); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func writeUnknownInt(w *textWriter, x uint64, err error) error {
-	if err == nil {
-		_, err = fmt.Fprint(w, x)
-	} else {
-		_, err = fmt.Fprintf(w, "/* %v */", err)
-	}
-	return err
-}
-
-type int32Slice []int32
-
-func (s int32Slice) Len() int           { return len(s) }
-func (s int32Slice) Less(i, j int) bool { return s[i] < s[j] }
-func (s int32Slice) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
-
-// writeExtensions writes all the extensions in pv.
-// pv is assumed to be a pointer to a protocol message struct that is extendable.
-func (tm *TextMarshaler) writeExtensions(w *textWriter, pv reflect.Value) error {
-	emap := extensionMaps[pv.Type().Elem()]
-	ep, _ := extendable(pv.Interface())
-
-	// Order the extensions by ID.
-	// This isn't strictly necessary, but it will give us
-	// canonical output, which will also make testing easier.
-	m, mu := ep.extensionsRead()
-	if m == nil {
-		return nil
-	}
-	mu.Lock()
-	ids := make([]int32, 0, len(m))
-	for id := range m {
-		ids = append(ids, id)
-	}
-	sort.Sort(int32Slice(ids))
-	mu.Unlock()
-
-	for _, extNum := range ids {
-		ext := m[extNum]
-		var desc *ExtensionDesc
-		if emap != nil {
-			desc = emap[extNum]
-		}
-		if desc == nil {
-			// Unknown extension.
-			if err := writeUnknownStruct(w, ext.enc); err != nil {
-				return err
-			}
-			continue
-		}
-
-		pb, err := GetExtension(ep, desc)
-		if err != nil {
-			return fmt.Errorf("failed getting extension: %v", err)
-		}
-
-		// Repeated extensions will appear as a slice.
-		if !desc.repeated() {
-			if err := tm.writeExtension(w, desc.Name, pb); err != nil {
-				return err
-			}
-		} else {
-			v := reflect.ValueOf(pb)
-			for i := 0; i < v.Len(); i++ {
-				if err := tm.writeExtension(w, desc.Name, v.Index(i).Interface()); err != nil {
-					return err
-				}
-			}
-		}
-	}
-	return nil
-}
-
-func (tm *TextMarshaler) writeExtension(w *textWriter, name string, pb interface{}) error {
-	if _, err := fmt.Fprintf(w, "[%s]:", name); err != nil {
-		return err
-	}
-	if !w.compact {
-		if err := w.WriteByte(' '); err != nil {
-			return err
-		}
-	}
-	if err := tm.writeAny(w, reflect.ValueOf(pb), nil); err != nil {
-		return err
-	}
-	if err := w.WriteByte('\n'); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (w *textWriter) writeIndent() {
-	if !w.complete {
-		return
-	}
-	remain := w.ind * 2
-	for remain > 0 {
-		n := remain
-		if n > len(spaces) {
-			n = len(spaces)
-		}
-		w.w.Write(spaces[:n])
-		remain -= n
-	}
-	w.complete = false
-}
-
-// TextMarshaler is a configurable text format marshaler.
-type TextMarshaler struct {
-	Compact   bool // use compact text format (one line).
-	ExpandAny bool // expand google.protobuf.Any messages of known types
-}
-
-// Marshal writes a given protocol buffer in text format.
-// The only errors returned are from w.
-func (tm *TextMarshaler) Marshal(w io.Writer, pb Message) error {
-	val := reflect.ValueOf(pb)
-	if pb == nil || val.IsNil() {
-		w.Write([]byte("<nil>"))
-		return nil
-	}
-	var bw *bufio.Writer
-	ww, ok := w.(writer)
-	if !ok {
-		bw = bufio.NewWriter(w)
-		ww = bw
-	}
-	aw := &textWriter{
-		w:        ww,
-		complete: true,
-		compact:  tm.Compact,
-	}
-
-	if etm, ok := pb.(encoding.TextMarshaler); ok {
-		text, err := etm.MarshalText()
-		if err != nil {
-			return err
-		}
-		if _, err = aw.Write(text); err != nil {
-			return err
-		}
-		if bw != nil {
-			return bw.Flush()
-		}
-		return nil
-	}
-	// Dereference the received pointer so we don't have outer < and >.
-	v := reflect.Indirect(val)
-	if err := tm.writeStruct(aw, v); err != nil {
-		return err
-	}
-	if bw != nil {
-		return bw.Flush()
-	}
-	return nil
-}
-
-// Text is the same as Marshal, but returns the string directly.
-func (tm *TextMarshaler) Text(pb Message) string {
-	var buf bytes.Buffer
-	tm.Marshal(&buf, pb)
-	return buf.String()
-}
-
-var (
-	defaultTextMarshaler = TextMarshaler{}
-	compactTextMarshaler = TextMarshaler{Compact: true}
-)
-
-// TODO: consider removing some of the Marshal functions below.
-
-// MarshalText writes a given protocol buffer in text format.
-// The only errors returned are from w.
-func MarshalText(w io.Writer, pb Message) error { return defaultTextMarshaler.Marshal(w, pb) }
-
-// MarshalTextString is the same as MarshalText, but returns the string directly.
-func MarshalTextString(pb Message) string { return defaultTextMarshaler.Text(pb) }
-
-// CompactText writes a given protocol buffer in compact text format (one line).
-func CompactText(w io.Writer, pb Message) error { return compactTextMarshaler.Marshal(w, pb) }
-
-// CompactTextString is the same as CompactText, but returns the string directly.
-func CompactTextString(pb Message) string { return compactTextMarshaler.Text(pb) }
diff --git a/vendor/github.com/golang/protobuf/proto/text_decode.go b/vendor/github.com/golang/protobuf/proto/text_decode.go
new file mode 100644
index 000000000..47eb3e445
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/text_decode.go
@@ -0,0 +1,801 @@
+// Copyright 2010 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 proto
+
+import (
+	"encoding"
+	"errors"
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+	"unicode/utf8"
+
+	"google.golang.org/protobuf/encoding/prototext"
+	protoV2 "google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/reflect/protoregistry"
+)
+
+const wrapTextUnmarshalV2 = false
+
+// ParseError is returned by UnmarshalText.
+type ParseError struct {
+	Message string
+
+	// Deprecated: Do not use.
+	Line, Offset int
+}
+
+func (e *ParseError) Error() string {
+	if wrapTextUnmarshalV2 {
+		return e.Message
+	}
+	if e.Line == 1 {
+		return fmt.Sprintf("line 1.%d: %v", e.Offset, e.Message)
+	}
+	return fmt.Sprintf("line %d: %v", e.Line, e.Message)
+}
+
+// UnmarshalText parses a proto text formatted string into m.
+func UnmarshalText(s string, m Message) error {
+	if u, ok := m.(encoding.TextUnmarshaler); ok {
+		return u.UnmarshalText([]byte(s))
+	}
+
+	m.Reset()
+	mi := MessageV2(m)
+
+	if wrapTextUnmarshalV2 {
+		err := prototext.UnmarshalOptions{
+			AllowPartial: true,
+		}.Unmarshal([]byte(s), mi)
+		if err != nil {
+			return &ParseError{Message: err.Error()}
+		}
+		return checkRequiredNotSet(mi)
+	} else {
+		if err := newTextParser(s).unmarshalMessage(mi.ProtoReflect(), ""); err != nil {
+			return err
+		}
+		return checkRequiredNotSet(mi)
+	}
+}
+
+type textParser struct {
+	s            string // remaining input
+	done         bool   // whether the parsing is finished (success or error)
+	backed       bool   // whether back() was called
+	offset, line int
+	cur          token
+}
+
+type token struct {
+	value    string
+	err      *ParseError
+	line     int    // line number
+	offset   int    // byte number from start of input, not start of line
+	unquoted string // the unquoted version of value, if it was a quoted string
+}
+
+func newTextParser(s string) *textParser {
+	p := new(textParser)
+	p.s = s
+	p.line = 1
+	p.cur.line = 1
+	return p
+}
+
+func (p *textParser) unmarshalMessage(m protoreflect.Message, terminator string) (err error) {
+	md := m.Descriptor()
+	fds := md.Fields()
+
+	// A struct is a sequence of "name: value", terminated by one of
+	// '>' or '}', or the end of the input.  A name may also be
+	// "[extension]" or "[type/url]".
+	//
+	// The whole struct can also be an expanded Any message, like:
+	// [type/url] < ... struct contents ... >
+	seen := make(map[protoreflect.FieldNumber]bool)
+	for {
+		tok := p.next()
+		if tok.err != nil {
+			return tok.err
+		}
+		if tok.value == terminator {
+			break
+		}
+		if tok.value == "[" {
+			if err := p.unmarshalExtensionOrAny(m, seen); err != nil {
+				return err
+			}
+			continue
+		}
+
+		// This is a normal, non-extension field.
+		name := protoreflect.Name(tok.value)
+		fd := fds.ByName(name)
+		switch {
+		case fd == nil:
+			gd := fds.ByName(protoreflect.Name(strings.ToLower(string(name))))
+			if gd != nil && gd.Kind() == protoreflect.GroupKind && gd.Message().Name() == name {
+				fd = gd
+			}
+		case fd.Kind() == protoreflect.GroupKind && fd.Message().Name() != name:
+			fd = nil
+		case fd.IsWeak() && fd.Message().IsPlaceholder():
+			fd = nil
+		}
+		if fd == nil {
+			typeName := string(md.FullName())
+			if m, ok := m.Interface().(Message); ok {
+				t := reflect.TypeOf(m)
+				if t.Kind() == reflect.Ptr {
+					typeName = t.Elem().String()
+				}
+			}
+			return p.errorf("unknown field name %q in %v", name, typeName)
+		}
+		if od := fd.ContainingOneof(); od != nil && m.WhichOneof(od) != nil {
+			return p.errorf("field '%s' would overwrite already parsed oneof '%s'", name, od.Name())
+		}
+		if fd.Cardinality() != protoreflect.Repeated && seen[fd.Number()] {
+			return p.errorf("non-repeated field %q was repeated", fd.Name())
+		}
+		seen[fd.Number()] = true
+
+		// Consume any colon.
+		if err := p.checkForColon(fd); err != nil {
+			return err
+		}
+
+		// Parse into the field.
+		v := m.Get(fd)
+		if !m.Has(fd) && (fd.IsList() || fd.IsMap() || fd.Message() != nil) {
+			v = m.Mutable(fd)
+		}
+		if v, err = p.unmarshalValue(v, fd); err != nil {
+			return err
+		}
+		m.Set(fd, v)
+
+		if err := p.consumeOptionalSeparator(); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (p *textParser) unmarshalExtensionOrAny(m protoreflect.Message, seen map[protoreflect.FieldNumber]bool) error {
+	name, err := p.consumeExtensionOrAnyName()
+	if err != nil {
+		return err
+	}
+
+	// If it contains a slash, it's an Any type URL.
+	if slashIdx := strings.LastIndex(name, "/"); slashIdx >= 0 {
+		tok := p.next()
+		if tok.err != nil {
+			return tok.err
+		}
+		// consume an optional colon
+		if tok.value == ":" {
+			tok = p.next()
+			if tok.err != nil {
+				return tok.err
+			}
+		}
+
+		var terminator string
+		switch tok.value {
+		case "<":
+			terminator = ">"
+		case "{":
+			terminator = "}"
+		default:
+			return p.errorf("expected '{' or '<', found %q", tok.value)
+		}
+
+		mt, err := protoregistry.GlobalTypes.FindMessageByURL(name)
+		if err != nil {
+			return p.errorf("unrecognized message %q in google.protobuf.Any", name[slashIdx+len("/"):])
+		}
+		m2 := mt.New()
+		if err := p.unmarshalMessage(m2, terminator); err != nil {
+			return err
+		}
+		b, err := protoV2.Marshal(m2.Interface())
+		if err != nil {
+			return p.errorf("failed to marshal message of type %q: %v", name[slashIdx+len("/"):], err)
+		}
+
+		urlFD := m.Descriptor().Fields().ByName("type_url")
+		valFD := m.Descriptor().Fields().ByName("value")
+		if seen[urlFD.Number()] {
+			return p.errorf("Any message unpacked multiple times, or %q already set", urlFD.Name())
+		}
+		if seen[valFD.Number()] {
+			return p.errorf("Any message unpacked multiple times, or %q already set", valFD.Name())
+		}
+		m.Set(urlFD, protoreflect.ValueOfString(name))
+		m.Set(valFD, protoreflect.ValueOfBytes(b))
+		seen[urlFD.Number()] = true
+		seen[valFD.Number()] = true
+		return nil
+	}
+
+	xname := protoreflect.FullName(name)
+	xt, _ := protoregistry.GlobalTypes.FindExtensionByName(xname)
+	if xt == nil && isMessageSet(m.Descriptor()) {
+		xt, _ = protoregistry.GlobalTypes.FindExtensionByName(xname.Append("message_set_extension"))
+	}
+	if xt == nil {
+		return p.errorf("unrecognized extension %q", name)
+	}
+	fd := xt.TypeDescriptor()
+	if fd.ContainingMessage().FullName() != m.Descriptor().FullName() {
+		return p.errorf("extension field %q does not extend message %q", name, m.Descriptor().FullName())
+	}
+
+	if err := p.checkForColon(fd); err != nil {
+		return err
+	}
+
+	v := m.Get(fd)
+	if !m.Has(fd) && (fd.IsList() || fd.IsMap() || fd.Message() != nil) {
+		v = m.Mutable(fd)
+	}
+	v, err = p.unmarshalValue(v, fd)
+	if err != nil {
+		return err
+	}
+	m.Set(fd, v)
+	return p.consumeOptionalSeparator()
+}
+
+func (p *textParser) unmarshalValue(v protoreflect.Value, fd protoreflect.FieldDescriptor) (protoreflect.Value, error) {
+	tok := p.next()
+	if tok.err != nil {
+		return v, tok.err
+	}
+	if tok.value == "" {
+		return v, p.errorf("unexpected EOF")
+	}
+
+	switch {
+	case fd.IsList():
+		lv := v.List()
+		var err error
+		if tok.value == "[" {
+			// Repeated field with list notation, like [1,2,3].
+			for {
+				vv := lv.NewElement()
+				vv, err = p.unmarshalSingularValue(vv, fd)
+				if err != nil {
+					return v, err
+				}
+				lv.Append(vv)
+
+				tok := p.next()
+				if tok.err != nil {
+					return v, tok.err
+				}
+				if tok.value == "]" {
+					break
+				}
+				if tok.value != "," {
+					return v, p.errorf("Expected ']' or ',' found %q", tok.value)
+				}
+			}
+			return v, nil
+		}
+
+		// One value of the repeated field.
+		p.back()
+		vv := lv.NewElement()
+		vv, err = p.unmarshalSingularValue(vv, fd)
+		if err != nil {
+			return v, err
+		}
+		lv.Append(vv)
+		return v, nil
+	case fd.IsMap():
+		// The map entry should be this sequence of tokens:
+		//	< key : KEY value : VALUE >
+		// However, implementations may omit key or value, and technically
+		// we should support them in any order.
+		var terminator string
+		switch tok.value {
+		case "<":
+			terminator = ">"
+		case "{":
+			terminator = "}"
+		default:
+			return v, p.errorf("expected '{' or '<', found %q", tok.value)
+		}
+
+		keyFD := fd.MapKey()
+		valFD := fd.MapValue()
+
+		mv := v.Map()
+		kv := keyFD.Default()
+		vv := mv.NewValue()
+		for {
+			tok := p.next()
+			if tok.err != nil {
+				return v, tok.err
+			}
+			if tok.value == terminator {
+				break
+			}
+			var err error
+			switch tok.value {
+			case "key":
+				if err := p.consumeToken(":"); err != nil {
+					return v, err
+				}
+				if kv, err = p.unmarshalSingularValue(kv, keyFD); err != nil {
+					return v, err
+				}
+				if err := p.consumeOptionalSeparator(); err != nil {
+					return v, err
+				}
+			case "value":
+				if err := p.checkForColon(valFD); err != nil {
+					return v, err
+				}
+				if vv, err = p.unmarshalSingularValue(vv, valFD); err != nil {
+					return v, err
+				}
+				if err := p.consumeOptionalSeparator(); err != nil {
+					return v, err
+				}
+			default:
+				p.back()
+				return v, p.errorf(`expected "key", "value", or %q, found %q`, terminator, tok.value)
+			}
+		}
+		mv.Set(kv.MapKey(), vv)
+		return v, nil
+	default:
+		p.back()
+		return p.unmarshalSingularValue(v, fd)
+	}
+}
+
+func (p *textParser) unmarshalSingularValue(v protoreflect.Value, fd protoreflect.FieldDescriptor) (protoreflect.Value, error) {
+	tok := p.next()
+	if tok.err != nil {
+		return v, tok.err
+	}
+	if tok.value == "" {
+		return v, p.errorf("unexpected EOF")
+	}
+
+	switch fd.Kind() {
+	case protoreflect.BoolKind:
+		switch tok.value {
+		case "true", "1", "t", "True":
+			return protoreflect.ValueOfBool(true), nil
+		case "false", "0", "f", "False":
+			return protoreflect.ValueOfBool(false), nil
+		}
+	case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
+		if x, err := strconv.ParseInt(tok.value, 0, 32); err == nil {
+			return protoreflect.ValueOfInt32(int32(x)), nil
+		}
+
+		// The C++ parser accepts large positive hex numbers that uses
+		// two's complement arithmetic to represent negative numbers.
+		// This feature is here for backwards compatibility with C++.
+		if strings.HasPrefix(tok.value, "0x") {
+			if x, err := strconv.ParseUint(tok.value, 0, 32); err == nil {
+				return protoreflect.ValueOfInt32(int32(-(int64(^x) + 1))), nil
+			}
+		}
+	case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
+		if x, err := strconv.ParseInt(tok.value, 0, 64); err == nil {
+			return protoreflect.ValueOfInt64(int64(x)), nil
+		}
+
+		// The C++ parser accepts large positive hex numbers that uses
+		// two's complement arithmetic to represent negative numbers.
+		// This feature is here for backwards compatibility with C++.
+		if strings.HasPrefix(tok.value, "0x") {
+			if x, err := strconv.ParseUint(tok.value, 0, 64); err == nil {
+				return protoreflect.ValueOfInt64(int64(-(int64(^x) + 1))), nil
+			}
+		}
+	case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
+		if x, err := strconv.ParseUint(tok.value, 0, 32); err == nil {
+			return protoreflect.ValueOfUint32(uint32(x)), nil
+		}
+	case protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
+		if x, err := strconv.ParseUint(tok.value, 0, 64); err == nil {
+			return protoreflect.ValueOfUint64(uint64(x)), nil
+		}
+	case protoreflect.FloatKind:
+		// Ignore 'f' for compatibility with output generated by C++,
+		// but don't remove 'f' when the value is "-inf" or "inf".
+		v := tok.value
+		if strings.HasSuffix(v, "f") && v != "-inf" && v != "inf" {
+			v = v[:len(v)-len("f")]
+		}
+		if x, err := strconv.ParseFloat(v, 32); err == nil {
+			return protoreflect.ValueOfFloat32(float32(x)), nil
+		}
+	case protoreflect.DoubleKind:
+		// Ignore 'f' for compatibility with output generated by C++,
+		// but don't remove 'f' when the value is "-inf" or "inf".
+		v := tok.value
+		if strings.HasSuffix(v, "f") && v != "-inf" && v != "inf" {
+			v = v[:len(v)-len("f")]
+		}
+		if x, err := strconv.ParseFloat(v, 64); err == nil {
+			return protoreflect.ValueOfFloat64(float64(x)), nil
+		}
+	case protoreflect.StringKind:
+		if isQuote(tok.value[0]) {
+			return protoreflect.ValueOfString(tok.unquoted), nil
+		}
+	case protoreflect.BytesKind:
+		if isQuote(tok.value[0]) {
+			return protoreflect.ValueOfBytes([]byte(tok.unquoted)), nil
+		}
+	case protoreflect.EnumKind:
+		if x, err := strconv.ParseInt(tok.value, 0, 32); err == nil {
+			return protoreflect.ValueOfEnum(protoreflect.EnumNumber(x)), nil
+		}
+		vd := fd.Enum().Values().ByName(protoreflect.Name(tok.value))
+		if vd != nil {
+			return protoreflect.ValueOfEnum(vd.Number()), nil
+		}
+	case protoreflect.MessageKind, protoreflect.GroupKind:
+		var terminator string
+		switch tok.value {
+		case "{":
+			terminator = "}"
+		case "<":
+			terminator = ">"
+		default:
+			return v, p.errorf("expected '{' or '<', found %q", tok.value)
+		}
+		err := p.unmarshalMessage(v.Message(), terminator)
+		return v, err
+	default:
+		panic(fmt.Sprintf("invalid kind %v", fd.Kind()))
+	}
+	return v, p.errorf("invalid %v: %v", fd.Kind(), tok.value)
+}
+
+// Consume a ':' from the input stream (if the next token is a colon),
+// returning an error if a colon is needed but not present.
+func (p *textParser) checkForColon(fd protoreflect.FieldDescriptor) *ParseError {
+	tok := p.next()
+	if tok.err != nil {
+		return tok.err
+	}
+	if tok.value != ":" {
+		if fd.Message() == nil {
+			return p.errorf("expected ':', found %q", tok.value)
+		}
+		p.back()
+	}
+	return nil
+}
+
+// consumeExtensionOrAnyName consumes an extension name or an Any type URL and
+// the following ']'. It returns the name or URL consumed.
+func (p *textParser) consumeExtensionOrAnyName() (string, error) {
+	tok := p.next()
+	if tok.err != nil {
+		return "", tok.err
+	}
+
+	// If extension name or type url is quoted, it's a single token.
+	if len(tok.value) > 2 && isQuote(tok.value[0]) && tok.value[len(tok.value)-1] == tok.value[0] {
+		name, err := unquoteC(tok.value[1:len(tok.value)-1], rune(tok.value[0]))
+		if err != nil {
+			return "", err
+		}
+		return name, p.consumeToken("]")
+	}
+
+	// Consume everything up to "]"
+	var parts []string
+	for tok.value != "]" {
+		parts = append(parts, tok.value)
+		tok = p.next()
+		if tok.err != nil {
+			return "", p.errorf("unrecognized type_url or extension name: %s", tok.err)
+		}
+		if p.done && tok.value != "]" {
+			return "", p.errorf("unclosed type_url or extension name")
+		}
+	}
+	return strings.Join(parts, ""), nil
+}
+
+// consumeOptionalSeparator consumes an optional semicolon or comma.
+// It is used in unmarshalMessage to provide backward compatibility.
+func (p *textParser) consumeOptionalSeparator() error {
+	tok := p.next()
+	if tok.err != nil {
+		return tok.err
+	}
+	if tok.value != ";" && tok.value != "," {
+		p.back()
+	}
+	return nil
+}
+
+func (p *textParser) errorf(format string, a ...interface{}) *ParseError {
+	pe := &ParseError{fmt.Sprintf(format, a...), p.cur.line, p.cur.offset}
+	p.cur.err = pe
+	p.done = true
+	return pe
+}
+
+func (p *textParser) skipWhitespace() {
+	i := 0
+	for i < len(p.s) && (isWhitespace(p.s[i]) || p.s[i] == '#') {
+		if p.s[i] == '#' {
+			// comment; skip to end of line or input
+			for i < len(p.s) && p.s[i] != '\n' {
+				i++
+			}
+			if i == len(p.s) {
+				break
+			}
+		}
+		if p.s[i] == '\n' {
+			p.line++
+		}
+		i++
+	}
+	p.offset += i
+	p.s = p.s[i:len(p.s)]
+	if len(p.s) == 0 {
+		p.done = true
+	}
+}
+
+func (p *textParser) advance() {
+	// Skip whitespace
+	p.skipWhitespace()
+	if p.done {
+		return
+	}
+
+	// Start of non-whitespace
+	p.cur.err = nil
+	p.cur.offset, p.cur.line = p.offset, p.line
+	p.cur.unquoted = ""
+	switch p.s[0] {
+	case '<', '>', '{', '}', ':', '[', ']', ';', ',', '/':
+		// Single symbol
+		p.cur.value, p.s = p.s[0:1], p.s[1:len(p.s)]
+	case '"', '\'':
+		// Quoted string
+		i := 1
+		for i < len(p.s) && p.s[i] != p.s[0] && p.s[i] != '\n' {
+			if p.s[i] == '\\' && i+1 < len(p.s) {
+				// skip escaped char
+				i++
+			}
+			i++
+		}
+		if i >= len(p.s) || p.s[i] != p.s[0] {
+			p.errorf("unmatched quote")
+			return
+		}
+		unq, err := unquoteC(p.s[1:i], rune(p.s[0]))
+		if err != nil {
+			p.errorf("invalid quoted string %s: %v", p.s[0:i+1], err)
+			return
+		}
+		p.cur.value, p.s = p.s[0:i+1], p.s[i+1:len(p.s)]
+		p.cur.unquoted = unq
+	default:
+		i := 0
+		for i < len(p.s) && isIdentOrNumberChar(p.s[i]) {
+			i++
+		}
+		if i == 0 {
+			p.errorf("unexpected byte %#x", p.s[0])
+			return
+		}
+		p.cur.value, p.s = p.s[0:i], p.s[i:len(p.s)]
+	}
+	p.offset += len(p.cur.value)
+}
+
+// Back off the parser by one token. Can only be done between calls to next().
+// It makes the next advance() a no-op.
+func (p *textParser) back() { p.backed = true }
+
+// Advances the parser and returns the new current token.
+func (p *textParser) next() *token {
+	if p.backed || p.done {
+		p.backed = false
+		return &p.cur
+	}
+	p.advance()
+	if p.done {
+		p.cur.value = ""
+	} else if len(p.cur.value) > 0 && isQuote(p.cur.value[0]) {
+		// Look for multiple quoted strings separated by whitespace,
+		// and concatenate them.
+		cat := p.cur
+		for {
+			p.skipWhitespace()
+			if p.done || !isQuote(p.s[0]) {
+				break
+			}
+			p.advance()
+			if p.cur.err != nil {
+				return &p.cur
+			}
+			cat.value += " " + p.cur.value
+			cat.unquoted += p.cur.unquoted
+		}
+		p.done = false // parser may have seen EOF, but we want to return cat
+		p.cur = cat
+	}
+	return &p.cur
+}
+
+func (p *textParser) consumeToken(s string) error {
+	tok := p.next()
+	if tok.err != nil {
+		return tok.err
+	}
+	if tok.value != s {
+		p.back()
+		return p.errorf("expected %q, found %q", s, tok.value)
+	}
+	return nil
+}
+
+var errBadUTF8 = errors.New("proto: bad UTF-8")
+
+func unquoteC(s string, quote rune) (string, error) {
+	// This is based on C++'s tokenizer.cc.
+	// Despite its name, this is *not* parsing C syntax.
+	// For instance, "\0" is an invalid quoted string.
+
+	// Avoid allocation in trivial cases.
+	simple := true
+	for _, r := range s {
+		if r == '\\' || r == quote {
+			simple = false
+			break
+		}
+	}
+	if simple {
+		return s, nil
+	}
+
+	buf := make([]byte, 0, 3*len(s)/2)
+	for len(s) > 0 {
+		r, n := utf8.DecodeRuneInString(s)
+		if r == utf8.RuneError && n == 1 {
+			return "", errBadUTF8
+		}
+		s = s[n:]
+		if r != '\\' {
+			if r < utf8.RuneSelf {
+				buf = append(buf, byte(r))
+			} else {
+				buf = append(buf, string(r)...)
+			}
+			continue
+		}
+
+		ch, tail, err := unescape(s)
+		if err != nil {
+			return "", err
+		}
+		buf = append(buf, ch...)
+		s = tail
+	}
+	return string(buf), nil
+}
+
+func unescape(s string) (ch string, tail string, err error) {
+	r, n := utf8.DecodeRuneInString(s)
+	if r == utf8.RuneError && n == 1 {
+		return "", "", errBadUTF8
+	}
+	s = s[n:]
+	switch r {
+	case 'a':
+		return "\a", s, nil
+	case 'b':
+		return "\b", s, nil
+	case 'f':
+		return "\f", s, nil
+	case 'n':
+		return "\n", s, nil
+	case 'r':
+		return "\r", s, nil
+	case 't':
+		return "\t", s, nil
+	case 'v':
+		return "\v", s, nil
+	case '?':
+		return "?", s, nil // trigraph workaround
+	case '\'', '"', '\\':
+		return string(r), s, nil
+	case '0', '1', '2', '3', '4', '5', '6', '7':
+		if len(s) < 2 {
+			return "", "", fmt.Errorf(`\%c requires 2 following digits`, r)
+		}
+		ss := string(r) + s[:2]
+		s = s[2:]
+		i, err := strconv.ParseUint(ss, 8, 8)
+		if err != nil {
+			return "", "", fmt.Errorf(`\%s contains non-octal digits`, ss)
+		}
+		return string([]byte{byte(i)}), s, nil
+	case 'x', 'X', 'u', 'U':
+		var n int
+		switch r {
+		case 'x', 'X':
+			n = 2
+		case 'u':
+			n = 4
+		case 'U':
+			n = 8
+		}
+		if len(s) < n {
+			return "", "", fmt.Errorf(`\%c requires %d following digits`, r, n)
+		}
+		ss := s[:n]
+		s = s[n:]
+		i, err := strconv.ParseUint(ss, 16, 64)
+		if err != nil {
+			return "", "", fmt.Errorf(`\%c%s contains non-hexadecimal digits`, r, ss)
+		}
+		if r == 'x' || r == 'X' {
+			return string([]byte{byte(i)}), s, nil
+		}
+		if i > utf8.MaxRune {
+			return "", "", fmt.Errorf(`\%c%s is not a valid Unicode code point`, r, ss)
+		}
+		return string(rune(i)), s, nil
+	}
+	return "", "", fmt.Errorf(`unknown escape \%c`, r)
+}
+
+func isIdentOrNumberChar(c byte) bool {
+	switch {
+	case 'A' <= c && c <= 'Z', 'a' <= c && c <= 'z':
+		return true
+	case '0' <= c && c <= '9':
+		return true
+	}
+	switch c {
+	case '-', '+', '.', '_':
+		return true
+	}
+	return false
+}
+
+func isWhitespace(c byte) bool {
+	switch c {
+	case ' ', '\t', '\n', '\r':
+		return true
+	}
+	return false
+}
+
+func isQuote(c byte) bool {
+	switch c {
+	case '"', '\'':
+		return true
+	}
+	return false
+}
diff --git a/vendor/github.com/golang/protobuf/proto/text_encode.go b/vendor/github.com/golang/protobuf/proto/text_encode.go
new file mode 100644
index 000000000..a31134eeb
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/text_encode.go
@@ -0,0 +1,560 @@
+// Copyright 2010 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 proto
+
+import (
+	"bytes"
+	"encoding"
+	"fmt"
+	"io"
+	"math"
+	"sort"
+	"strings"
+
+	"google.golang.org/protobuf/encoding/prototext"
+	"google.golang.org/protobuf/encoding/protowire"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/reflect/protoregistry"
+)
+
+const wrapTextMarshalV2 = false
+
+// TextMarshaler is a configurable text format marshaler.
+type TextMarshaler struct {
+	Compact   bool // use compact text format (one line)
+	ExpandAny bool // expand google.protobuf.Any messages of known types
+}
+
+// Marshal writes the proto text format of m to w.
+func (tm *TextMarshaler) Marshal(w io.Writer, m Message) error {
+	b, err := tm.marshal(m)
+	if len(b) > 0 {
+		if _, err := w.Write(b); err != nil {
+			return err
+		}
+	}
+	return err
+}
+
+// Text returns a proto text formatted string of m.
+func (tm *TextMarshaler) Text(m Message) string {
+	b, _ := tm.marshal(m)
+	return string(b)
+}
+
+func (tm *TextMarshaler) marshal(m Message) ([]byte, error) {
+	mr := MessageReflect(m)
+	if mr == nil || !mr.IsValid() {
+		return []byte("<nil>"), nil
+	}
+
+	if wrapTextMarshalV2 {
+		if m, ok := m.(encoding.TextMarshaler); ok {
+			return m.MarshalText()
+		}
+
+		opts := prototext.MarshalOptions{
+			AllowPartial: true,
+			EmitUnknown:  true,
+		}
+		if !tm.Compact {
+			opts.Indent = "  "
+		}
+		if !tm.ExpandAny {
+			opts.Resolver = (*protoregistry.Types)(nil)
+		}
+		return opts.Marshal(mr.Interface())
+	} else {
+		w := &textWriter{
+			compact:   tm.Compact,
+			expandAny: tm.ExpandAny,
+			complete:  true,
+		}
+
+		if m, ok := m.(encoding.TextMarshaler); ok {
+			b, err := m.MarshalText()
+			if err != nil {
+				return nil, err
+			}
+			w.Write(b)
+			return w.buf, nil
+		}
+
+		err := w.writeMessage(mr)
+		return w.buf, err
+	}
+}
+
+var (
+	defaultTextMarshaler = TextMarshaler{}
+	compactTextMarshaler = TextMarshaler{Compact: true}
+)
+
+// MarshalText writes the proto text format of m to w.
+func MarshalText(w io.Writer, m Message) error { return defaultTextMarshaler.Marshal(w, m) }
+
+// MarshalTextString returns a proto text formatted string of m.
+func MarshalTextString(m Message) string { return defaultTextMarshaler.Text(m) }
+
+// CompactText writes the compact proto text format of m to w.
+func CompactText(w io.Writer, m Message) error { return compactTextMarshaler.Marshal(w, m) }
+
+// CompactTextString returns a compact proto text formatted string of m.
+func CompactTextString(m Message) string { return compactTextMarshaler.Text(m) }
+
+var (
+	newline         = []byte("\n")
+	endBraceNewline = []byte("}\n")
+	posInf          = []byte("inf")
+	negInf          = []byte("-inf")
+	nan             = []byte("nan")
+)
+
+// textWriter is an io.Writer that tracks its indentation level.
+type textWriter struct {
+	compact   bool // same as TextMarshaler.Compact
+	expandAny bool // same as TextMarshaler.ExpandAny
+	complete  bool // whether the current position is a complete line
+	indent    int  // indentation level; never negative
+	buf       []byte
+}
+
+func (w *textWriter) Write(p []byte) (n int, _ error) {
+	newlines := bytes.Count(p, newline)
+	if newlines == 0 {
+		if !w.compact && w.complete {
+			w.writeIndent()
+		}
+		w.buf = append(w.buf, p...)
+		w.complete = false
+		return len(p), nil
+	}
+
+	frags := bytes.SplitN(p, newline, newlines+1)
+	if w.compact {
+		for i, frag := range frags {
+			if i > 0 {
+				w.buf = append(w.buf, ' ')
+				n++
+			}
+			w.buf = append(w.buf, frag...)
+			n += len(frag)
+		}
+		return n, nil
+	}
+
+	for i, frag := range frags {
+		if w.complete {
+			w.writeIndent()
+		}
+		w.buf = append(w.buf, frag...)
+		n += len(frag)
+		if i+1 < len(frags) {
+			w.buf = append(w.buf, '\n')
+			n++
+		}
+	}
+	w.complete = len(frags[len(frags)-1]) == 0
+	return n, nil
+}
+
+func (w *textWriter) WriteByte(c byte) error {
+	if w.compact && c == '\n' {
+		c = ' '
+	}
+	if !w.compact && w.complete {
+		w.writeIndent()
+	}
+	w.buf = append(w.buf, c)
+	w.complete = c == '\n'
+	return nil
+}
+
+func (w *textWriter) writeName(fd protoreflect.FieldDescriptor) {
+	if !w.compact && w.complete {
+		w.writeIndent()
+	}
+	w.complete = false
+
+	if fd.Kind() != protoreflect.GroupKind {
+		w.buf = append(w.buf, fd.Name()...)
+		w.WriteByte(':')
+	} else {
+		// Use message type name for group field name.
+		w.buf = append(w.buf, fd.Message().Name()...)
+	}
+
+	if !w.compact {
+		w.WriteByte(' ')
+	}
+}
+
+func requiresQuotes(u string) bool {
+	// When type URL contains any characters except [0-9A-Za-z./\-]*, it must be quoted.
+	for _, ch := range u {
+		switch {
+		case ch == '.' || ch == '/' || ch == '_':
+			continue
+		case '0' <= ch && ch <= '9':
+			continue
+		case 'A' <= ch && ch <= 'Z':
+			continue
+		case 'a' <= ch && ch <= 'z':
+			continue
+		default:
+			return true
+		}
+	}
+	return false
+}
+
+// writeProto3Any writes an expanded google.protobuf.Any message.
+//
+// It returns (false, nil) if sv value can't be unmarshaled (e.g. because
+// required messages are not linked in).
+//
+// It returns (true, error) when sv was written in expanded format or an error
+// was encountered.
+func (w *textWriter) writeProto3Any(m protoreflect.Message) (bool, error) {
+	md := m.Descriptor()
+	fdURL := md.Fields().ByName("type_url")
+	fdVal := md.Fields().ByName("value")
+
+	url := m.Get(fdURL).String()
+	mt, err := protoregistry.GlobalTypes.FindMessageByURL(url)
+	if err != nil {
+		return false, nil
+	}
+
+	b := m.Get(fdVal).Bytes()
+	m2 := mt.New()
+	if err := proto.Unmarshal(b, m2.Interface()); err != nil {
+		return false, nil
+	}
+	w.Write([]byte("["))
+	if requiresQuotes(url) {
+		w.writeQuotedString(url)
+	} else {
+		w.Write([]byte(url))
+	}
+	if w.compact {
+		w.Write([]byte("]:<"))
+	} else {
+		w.Write([]byte("]: <\n"))
+		w.indent++
+	}
+	if err := w.writeMessage(m2); err != nil {
+		return true, err
+	}
+	if w.compact {
+		w.Write([]byte("> "))
+	} else {
+		w.indent--
+		w.Write([]byte(">\n"))
+	}
+	return true, nil
+}
+
+func (w *textWriter) writeMessage(m protoreflect.Message) error {
+	md := m.Descriptor()
+	if w.expandAny && md.FullName() == "google.protobuf.Any" {
+		if canExpand, err := w.writeProto3Any(m); canExpand {
+			return err
+		}
+	}
+
+	fds := md.Fields()
+	for i := 0; i < fds.Len(); {
+		fd := fds.Get(i)
+		if od := fd.ContainingOneof(); od != nil {
+			fd = m.WhichOneof(od)
+			i += od.Fields().Len()
+		} else {
+			i++
+		}
+		if fd == nil || !m.Has(fd) {
+			continue
+		}
+
+		switch {
+		case fd.IsList():
+			lv := m.Get(fd).List()
+			for j := 0; j < lv.Len(); j++ {
+				w.writeName(fd)
+				v := lv.Get(j)
+				if err := w.writeSingularValue(v, fd); err != nil {
+					return err
+				}
+				w.WriteByte('\n')
+			}
+		case fd.IsMap():
+			kfd := fd.MapKey()
+			vfd := fd.MapValue()
+			mv := m.Get(fd).Map()
+
+			type entry struct{ key, val protoreflect.Value }
+			var entries []entry
+			mv.Range(func(k protoreflect.MapKey, v protoreflect.Value) bool {
+				entries = append(entries, entry{k.Value(), v})
+				return true
+			})
+			sort.Slice(entries, func(i, j int) bool {
+				switch kfd.Kind() {
+				case protoreflect.BoolKind:
+					return !entries[i].key.Bool() && entries[j].key.Bool()
+				case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind, protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
+					return entries[i].key.Int() < entries[j].key.Int()
+				case protoreflect.Uint32Kind, protoreflect.Fixed32Kind, protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
+					return entries[i].key.Uint() < entries[j].key.Uint()
+				case protoreflect.StringKind:
+					return entries[i].key.String() < entries[j].key.String()
+				default:
+					panic("invalid kind")
+				}
+			})
+			for _, entry := range entries {
+				w.writeName(fd)
+				w.WriteByte('<')
+				if !w.compact {
+					w.WriteByte('\n')
+				}
+				w.indent++
+				w.writeName(kfd)
+				if err := w.writeSingularValue(entry.key, kfd); err != nil {
+					return err
+				}
+				w.WriteByte('\n')
+				w.writeName(vfd)
+				if err := w.writeSingularValue(entry.val, vfd); err != nil {
+					return err
+				}
+				w.WriteByte('\n')
+				w.indent--
+				w.WriteByte('>')
+				w.WriteByte('\n')
+			}
+		default:
+			w.writeName(fd)
+			if err := w.writeSingularValue(m.Get(fd), fd); err != nil {
+				return err
+			}
+			w.WriteByte('\n')
+		}
+	}
+
+	if b := m.GetUnknown(); len(b) > 0 {
+		w.writeUnknownFields(b)
+	}
+	return w.writeExtensions(m)
+}
+
+func (w *textWriter) writeSingularValue(v protoreflect.Value, fd protoreflect.FieldDescriptor) error {
+	switch fd.Kind() {
+	case protoreflect.FloatKind, protoreflect.DoubleKind:
+		switch vf := v.Float(); {
+		case math.IsInf(vf, +1):
+			w.Write(posInf)
+		case math.IsInf(vf, -1):
+			w.Write(negInf)
+		case math.IsNaN(vf):
+			w.Write(nan)
+		default:
+			fmt.Fprint(w, v.Interface())
+		}
+	case protoreflect.StringKind:
+		// NOTE: This does not validate UTF-8 for historical reasons.
+		w.writeQuotedString(string(v.String()))
+	case protoreflect.BytesKind:
+		w.writeQuotedString(string(v.Bytes()))
+	case protoreflect.MessageKind, protoreflect.GroupKind:
+		var bra, ket byte = '<', '>'
+		if fd.Kind() == protoreflect.GroupKind {
+			bra, ket = '{', '}'
+		}
+		w.WriteByte(bra)
+		if !w.compact {
+			w.WriteByte('\n')
+		}
+		w.indent++
+		m := v.Message()
+		if m2, ok := m.Interface().(encoding.TextMarshaler); ok {
+			b, err := m2.MarshalText()
+			if err != nil {
+				return err
+			}
+			w.Write(b)
+		} else {
+			w.writeMessage(m)
+		}
+		w.indent--
+		w.WriteByte(ket)
+	case protoreflect.EnumKind:
+		if ev := fd.Enum().Values().ByNumber(v.Enum()); ev != nil {
+			fmt.Fprint(w, ev.Name())
+		} else {
+			fmt.Fprint(w, v.Enum())
+		}
+	default:
+		fmt.Fprint(w, v.Interface())
+	}
+	return nil
+}
+
+// writeQuotedString writes a quoted string in the protocol buffer text format.
+func (w *textWriter) writeQuotedString(s string) {
+	w.WriteByte('"')
+	for i := 0; i < len(s); i++ {
+		switch c := s[i]; c {
+		case '\n':
+			w.buf = append(w.buf, `\n`...)
+		case '\r':
+			w.buf = append(w.buf, `\r`...)
+		case '\t':
+			w.buf = append(w.buf, `\t`...)
+		case '"':
+			w.buf = append(w.buf, `\"`...)
+		case '\\':
+			w.buf = append(w.buf, `\\`...)
+		default:
+			if isPrint := c >= 0x20 && c < 0x7f; isPrint {
+				w.buf = append(w.buf, c)
+			} else {
+				w.buf = append(w.buf, fmt.Sprintf(`\%03o`, c)...)
+			}
+		}
+	}
+	w.WriteByte('"')
+}
+
+func (w *textWriter) writeUnknownFields(b []byte) {
+	if !w.compact {
+		fmt.Fprintf(w, "/* %d unknown bytes */\n", len(b))
+	}
+
+	for len(b) > 0 {
+		num, wtyp, n := protowire.ConsumeTag(b)
+		if n < 0 {
+			return
+		}
+		b = b[n:]
+
+		if wtyp == protowire.EndGroupType {
+			w.indent--
+			w.Write(endBraceNewline)
+			continue
+		}
+		fmt.Fprint(w, num)
+		if wtyp != protowire.StartGroupType {
+			w.WriteByte(':')
+		}
+		if !w.compact || wtyp == protowire.StartGroupType {
+			w.WriteByte(' ')
+		}
+		switch wtyp {
+		case protowire.VarintType:
+			v, n := protowire.ConsumeVarint(b)
+			if n < 0 {
+				return
+			}
+			b = b[n:]
+			fmt.Fprint(w, v)
+		case protowire.Fixed32Type:
+			v, n := protowire.ConsumeFixed32(b)
+			if n < 0 {
+				return
+			}
+			b = b[n:]
+			fmt.Fprint(w, v)
+		case protowire.Fixed64Type:
+			v, n := protowire.ConsumeFixed64(b)
+			if n < 0 {
+				return
+			}
+			b = b[n:]
+			fmt.Fprint(w, v)
+		case protowire.BytesType:
+			v, n := protowire.ConsumeBytes(b)
+			if n < 0 {
+				return
+			}
+			b = b[n:]
+			fmt.Fprintf(w, "%q", v)
+		case protowire.StartGroupType:
+			w.WriteByte('{')
+			w.indent++
+		default:
+			fmt.Fprintf(w, "/* unknown wire type %d */", wtyp)
+		}
+		w.WriteByte('\n')
+	}
+}
+
+// writeExtensions writes all the extensions in m.
+func (w *textWriter) writeExtensions(m protoreflect.Message) error {
+	md := m.Descriptor()
+	if md.ExtensionRanges().Len() == 0 {
+		return nil
+	}
+
+	type ext struct {
+		desc protoreflect.FieldDescriptor
+		val  protoreflect.Value
+	}
+	var exts []ext
+	m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
+		if fd.IsExtension() {
+			exts = append(exts, ext{fd, v})
+		}
+		return true
+	})
+	sort.Slice(exts, func(i, j int) bool {
+		return exts[i].desc.Number() < exts[j].desc.Number()
+	})
+
+	for _, ext := range exts {
+		// For message set, use the name of the message as the extension name.
+		name := string(ext.desc.FullName())
+		if isMessageSet(ext.desc.ContainingMessage()) {
+			name = strings.TrimSuffix(name, ".message_set_extension")
+		}
+
+		if !ext.desc.IsList() {
+			if err := w.writeSingularExtension(name, ext.val, ext.desc); err != nil {
+				return err
+			}
+		} else {
+			lv := ext.val.List()
+			for i := 0; i < lv.Len(); i++ {
+				if err := w.writeSingularExtension(name, lv.Get(i), ext.desc); err != nil {
+					return err
+				}
+			}
+		}
+	}
+	return nil
+}
+
+func (w *textWriter) writeSingularExtension(name string, v protoreflect.Value, fd protoreflect.FieldDescriptor) error {
+	fmt.Fprintf(w, "[%s]:", name)
+	if !w.compact {
+		w.WriteByte(' ')
+	}
+	if err := w.writeSingularValue(v, fd); err != nil {
+		return err
+	}
+	w.WriteByte('\n')
+	return nil
+}
+
+func (w *textWriter) writeIndent() {
+	if !w.complete {
+		return
+	}
+	for i := 0; i < w.indent*2; i++ {
+		w.buf = append(w.buf, ' ')
+	}
+	w.complete = false
+}
diff --git a/vendor/github.com/golang/protobuf/proto/text_parser.go b/vendor/github.com/golang/protobuf/proto/text_parser.go
deleted file mode 100644
index 0685bae36..000000000
--- a/vendor/github.com/golang/protobuf/proto/text_parser.go
+++ /dev/null
@@ -1,880 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package proto
-
-// Functions for parsing the Text protocol buffer format.
-// TODO: message sets.
-
-import (
-	"encoding"
-	"errors"
-	"fmt"
-	"reflect"
-	"strconv"
-	"strings"
-	"unicode/utf8"
-)
-
-// Error string emitted when deserializing Any and fields are already set
-const anyRepeatedlyUnpacked = "Any message unpacked multiple times, or %q already set"
-
-type ParseError struct {
-	Message string
-	Line    int // 1-based line number
-	Offset  int // 0-based byte offset from start of input
-}
-
-func (p *ParseError) Error() string {
-	if p.Line == 1 {
-		// show offset only for first line
-		return fmt.Sprintf("line 1.%d: %v", p.Offset, p.Message)
-	}
-	return fmt.Sprintf("line %d: %v", p.Line, p.Message)
-}
-
-type token struct {
-	value    string
-	err      *ParseError
-	line     int    // line number
-	offset   int    // byte number from start of input, not start of line
-	unquoted string // the unquoted version of value, if it was a quoted string
-}
-
-func (t *token) String() string {
-	if t.err == nil {
-		return fmt.Sprintf("%q (line=%d, offset=%d)", t.value, t.line, t.offset)
-	}
-	return fmt.Sprintf("parse error: %v", t.err)
-}
-
-type textParser struct {
-	s            string // remaining input
-	done         bool   // whether the parsing is finished (success or error)
-	backed       bool   // whether back() was called
-	offset, line int
-	cur          token
-}
-
-func newTextParser(s string) *textParser {
-	p := new(textParser)
-	p.s = s
-	p.line = 1
-	p.cur.line = 1
-	return p
-}
-
-func (p *textParser) errorf(format string, a ...interface{}) *ParseError {
-	pe := &ParseError{fmt.Sprintf(format, a...), p.cur.line, p.cur.offset}
-	p.cur.err = pe
-	p.done = true
-	return pe
-}
-
-// Numbers and identifiers are matched by [-+._A-Za-z0-9]
-func isIdentOrNumberChar(c byte) bool {
-	switch {
-	case 'A' <= c && c <= 'Z', 'a' <= c && c <= 'z':
-		return true
-	case '0' <= c && c <= '9':
-		return true
-	}
-	switch c {
-	case '-', '+', '.', '_':
-		return true
-	}
-	return false
-}
-
-func isWhitespace(c byte) bool {
-	switch c {
-	case ' ', '\t', '\n', '\r':
-		return true
-	}
-	return false
-}
-
-func isQuote(c byte) bool {
-	switch c {
-	case '"', '\'':
-		return true
-	}
-	return false
-}
-
-func (p *textParser) skipWhitespace() {
-	i := 0
-	for i < len(p.s) && (isWhitespace(p.s[i]) || p.s[i] == '#') {
-		if p.s[i] == '#' {
-			// comment; skip to end of line or input
-			for i < len(p.s) && p.s[i] != '\n' {
-				i++
-			}
-			if i == len(p.s) {
-				break
-			}
-		}
-		if p.s[i] == '\n' {
-			p.line++
-		}
-		i++
-	}
-	p.offset += i
-	p.s = p.s[i:len(p.s)]
-	if len(p.s) == 0 {
-		p.done = true
-	}
-}
-
-func (p *textParser) advance() {
-	// Skip whitespace
-	p.skipWhitespace()
-	if p.done {
-		return
-	}
-
-	// Start of non-whitespace
-	p.cur.err = nil
-	p.cur.offset, p.cur.line = p.offset, p.line
-	p.cur.unquoted = ""
-	switch p.s[0] {
-	case '<', '>', '{', '}', ':', '[', ']', ';', ',', '/':
-		// Single symbol
-		p.cur.value, p.s = p.s[0:1], p.s[1:len(p.s)]
-	case '"', '\'':
-		// Quoted string
-		i := 1
-		for i < len(p.s) && p.s[i] != p.s[0] && p.s[i] != '\n' {
-			if p.s[i] == '\\' && i+1 < len(p.s) {
-				// skip escaped char
-				i++
-			}
-			i++
-		}
-		if i >= len(p.s) || p.s[i] != p.s[0] {
-			p.errorf("unmatched quote")
-			return
-		}
-		unq, err := unquoteC(p.s[1:i], rune(p.s[0]))
-		if err != nil {
-			p.errorf("invalid quoted string %s: %v", p.s[0:i+1], err)
-			return
-		}
-		p.cur.value, p.s = p.s[0:i+1], p.s[i+1:len(p.s)]
-		p.cur.unquoted = unq
-	default:
-		i := 0
-		for i < len(p.s) && isIdentOrNumberChar(p.s[i]) {
-			i++
-		}
-		if i == 0 {
-			p.errorf("unexpected byte %#x", p.s[0])
-			return
-		}
-		p.cur.value, p.s = p.s[0:i], p.s[i:len(p.s)]
-	}
-	p.offset += len(p.cur.value)
-}
-
-var (
-	errBadUTF8 = errors.New("proto: bad UTF-8")
-)
-
-func unquoteC(s string, quote rune) (string, error) {
-	// This is based on C++'s tokenizer.cc.
-	// Despite its name, this is *not* parsing C syntax.
-	// For instance, "\0" is an invalid quoted string.
-
-	// Avoid allocation in trivial cases.
-	simple := true
-	for _, r := range s {
-		if r == '\\' || r == quote {
-			simple = false
-			break
-		}
-	}
-	if simple {
-		return s, nil
-	}
-
-	buf := make([]byte, 0, 3*len(s)/2)
-	for len(s) > 0 {
-		r, n := utf8.DecodeRuneInString(s)
-		if r == utf8.RuneError && n == 1 {
-			return "", errBadUTF8
-		}
-		s = s[n:]
-		if r != '\\' {
-			if r < utf8.RuneSelf {
-				buf = append(buf, byte(r))
-			} else {
-				buf = append(buf, string(r)...)
-			}
-			continue
-		}
-
-		ch, tail, err := unescape(s)
-		if err != nil {
-			return "", err
-		}
-		buf = append(buf, ch...)
-		s = tail
-	}
-	return string(buf), nil
-}
-
-func unescape(s string) (ch string, tail string, err error) {
-	r, n := utf8.DecodeRuneInString(s)
-	if r == utf8.RuneError && n == 1 {
-		return "", "", errBadUTF8
-	}
-	s = s[n:]
-	switch r {
-	case 'a':
-		return "\a", s, nil
-	case 'b':
-		return "\b", s, nil
-	case 'f':
-		return "\f", s, nil
-	case 'n':
-		return "\n", s, nil
-	case 'r':
-		return "\r", s, nil
-	case 't':
-		return "\t", s, nil
-	case 'v':
-		return "\v", s, nil
-	case '?':
-		return "?", s, nil // trigraph workaround
-	case '\'', '"', '\\':
-		return string(r), s, nil
-	case '0', '1', '2', '3', '4', '5', '6', '7':
-		if len(s) < 2 {
-			return "", "", fmt.Errorf(`\%c requires 2 following digits`, r)
-		}
-		ss := string(r) + s[:2]
-		s = s[2:]
-		i, err := strconv.ParseUint(ss, 8, 8)
-		if err != nil {
-			return "", "", fmt.Errorf(`\%s contains non-octal digits`, ss)
-		}
-		return string([]byte{byte(i)}), s, nil
-	case 'x', 'X', 'u', 'U':
-		var n int
-		switch r {
-		case 'x', 'X':
-			n = 2
-		case 'u':
-			n = 4
-		case 'U':
-			n = 8
-		}
-		if len(s) < n {
-			return "", "", fmt.Errorf(`\%c requires %d following digits`, r, n)
-		}
-		ss := s[:n]
-		s = s[n:]
-		i, err := strconv.ParseUint(ss, 16, 64)
-		if err != nil {
-			return "", "", fmt.Errorf(`\%c%s contains non-hexadecimal digits`, r, ss)
-		}
-		if r == 'x' || r == 'X' {
-			return string([]byte{byte(i)}), s, nil
-		}
-		if i > utf8.MaxRune {
-			return "", "", fmt.Errorf(`\%c%s is not a valid Unicode code point`, r, ss)
-		}
-		return string(i), s, nil
-	}
-	return "", "", fmt.Errorf(`unknown escape \%c`, r)
-}
-
-// Back off the parser by one token. Can only be done between calls to next().
-// It makes the next advance() a no-op.
-func (p *textParser) back() { p.backed = true }
-
-// Advances the parser and returns the new current token.
-func (p *textParser) next() *token {
-	if p.backed || p.done {
-		p.backed = false
-		return &p.cur
-	}
-	p.advance()
-	if p.done {
-		p.cur.value = ""
-	} else if len(p.cur.value) > 0 && isQuote(p.cur.value[0]) {
-		// Look for multiple quoted strings separated by whitespace,
-		// and concatenate them.
-		cat := p.cur
-		for {
-			p.skipWhitespace()
-			if p.done || !isQuote(p.s[0]) {
-				break
-			}
-			p.advance()
-			if p.cur.err != nil {
-				return &p.cur
-			}
-			cat.value += " " + p.cur.value
-			cat.unquoted += p.cur.unquoted
-		}
-		p.done = false // parser may have seen EOF, but we want to return cat
-		p.cur = cat
-	}
-	return &p.cur
-}
-
-func (p *textParser) consumeToken(s string) error {
-	tok := p.next()
-	if tok.err != nil {
-		return tok.err
-	}
-	if tok.value != s {
-		p.back()
-		return p.errorf("expected %q, found %q", s, tok.value)
-	}
-	return nil
-}
-
-// Return a RequiredNotSetError indicating which required field was not set.
-func (p *textParser) missingRequiredFieldError(sv reflect.Value) *RequiredNotSetError {
-	st := sv.Type()
-	sprops := GetProperties(st)
-	for i := 0; i < st.NumField(); i++ {
-		if !isNil(sv.Field(i)) {
-			continue
-		}
-
-		props := sprops.Prop[i]
-		if props.Required {
-			return &RequiredNotSetError{fmt.Sprintf("%v.%v", st, props.OrigName)}
-		}
-	}
-	return &RequiredNotSetError{fmt.Sprintf("%v.<unknown field name>", st)} // should not happen
-}
-
-// Returns the index in the struct for the named field, as well as the parsed tag properties.
-func structFieldByName(sprops *StructProperties, name string) (int, *Properties, bool) {
-	i, ok := sprops.decoderOrigNames[name]
-	if ok {
-		return i, sprops.Prop[i], true
-	}
-	return -1, nil, false
-}
-
-// Consume a ':' from the input stream (if the next token is a colon),
-// returning an error if a colon is needed but not present.
-func (p *textParser) checkForColon(props *Properties, typ reflect.Type) *ParseError {
-	tok := p.next()
-	if tok.err != nil {
-		return tok.err
-	}
-	if tok.value != ":" {
-		// Colon is optional when the field is a group or message.
-		needColon := true
-		switch props.Wire {
-		case "group":
-			needColon = false
-		case "bytes":
-			// A "bytes" field is either a message, a string, or a repeated field;
-			// those three become *T, *string and []T respectively, so we can check for
-			// this field being a pointer to a non-string.
-			if typ.Kind() == reflect.Ptr {
-				// *T or *string
-				if typ.Elem().Kind() == reflect.String {
-					break
-				}
-			} else if typ.Kind() == reflect.Slice {
-				// []T or []*T
-				if typ.Elem().Kind() != reflect.Ptr {
-					break
-				}
-			} else if typ.Kind() == reflect.String {
-				// The proto3 exception is for a string field,
-				// which requires a colon.
-				break
-			}
-			needColon = false
-		}
-		if needColon {
-			return p.errorf("expected ':', found %q", tok.value)
-		}
-		p.back()
-	}
-	return nil
-}
-
-func (p *textParser) readStruct(sv reflect.Value, terminator string) error {
-	st := sv.Type()
-	sprops := GetProperties(st)
-	reqCount := sprops.reqCount
-	var reqFieldErr error
-	fieldSet := make(map[string]bool)
-	// A struct is a sequence of "name: value", terminated by one of
-	// '>' or '}', or the end of the input.  A name may also be
-	// "[extension]" or "[type/url]".
-	//
-	// The whole struct can also be an expanded Any message, like:
-	// [type/url] < ... struct contents ... >
-	for {
-		tok := p.next()
-		if tok.err != nil {
-			return tok.err
-		}
-		if tok.value == terminator {
-			break
-		}
-		if tok.value == "[" {
-			// Looks like an extension or an Any.
-			//
-			// TODO: Check whether we need to handle
-			// namespace rooted names (e.g. ".something.Foo").
-			extName, err := p.consumeExtName()
-			if err != nil {
-				return err
-			}
-
-			if s := strings.LastIndex(extName, "/"); s >= 0 {
-				// If it contains a slash, it's an Any type URL.
-				messageName := extName[s+1:]
-				mt := MessageType(messageName)
-				if mt == nil {
-					return p.errorf("unrecognized message %q in google.protobuf.Any", messageName)
-				}
-				tok = p.next()
-				if tok.err != nil {
-					return tok.err
-				}
-				// consume an optional colon
-				if tok.value == ":" {
-					tok = p.next()
-					if tok.err != nil {
-						return tok.err
-					}
-				}
-				var terminator string
-				switch tok.value {
-				case "<":
-					terminator = ">"
-				case "{":
-					terminator = "}"
-				default:
-					return p.errorf("expected '{' or '<', found %q", tok.value)
-				}
-				v := reflect.New(mt.Elem())
-				if pe := p.readStruct(v.Elem(), terminator); pe != nil {
-					return pe
-				}
-				b, err := Marshal(v.Interface().(Message))
-				if err != nil {
-					return p.errorf("failed to marshal message of type %q: %v", messageName, err)
-				}
-				if fieldSet["type_url"] {
-					return p.errorf(anyRepeatedlyUnpacked, "type_url")
-				}
-				if fieldSet["value"] {
-					return p.errorf(anyRepeatedlyUnpacked, "value")
-				}
-				sv.FieldByName("TypeUrl").SetString(extName)
-				sv.FieldByName("Value").SetBytes(b)
-				fieldSet["type_url"] = true
-				fieldSet["value"] = true
-				continue
-			}
-
-			var desc *ExtensionDesc
-			// This could be faster, but it's functional.
-			// TODO: Do something smarter than a linear scan.
-			for _, d := range RegisteredExtensions(reflect.New(st).Interface().(Message)) {
-				if d.Name == extName {
-					desc = d
-					break
-				}
-			}
-			if desc == nil {
-				return p.errorf("unrecognized extension %q", extName)
-			}
-
-			props := &Properties{}
-			props.Parse(desc.Tag)
-
-			typ := reflect.TypeOf(desc.ExtensionType)
-			if err := p.checkForColon(props, typ); err != nil {
-				return err
-			}
-
-			rep := desc.repeated()
-
-			// Read the extension structure, and set it in
-			// the value we're constructing.
-			var ext reflect.Value
-			if !rep {
-				ext = reflect.New(typ).Elem()
-			} else {
-				ext = reflect.New(typ.Elem()).Elem()
-			}
-			if err := p.readAny(ext, props); err != nil {
-				if _, ok := err.(*RequiredNotSetError); !ok {
-					return err
-				}
-				reqFieldErr = err
-			}
-			ep := sv.Addr().Interface().(Message)
-			if !rep {
-				SetExtension(ep, desc, ext.Interface())
-			} else {
-				old, err := GetExtension(ep, desc)
-				var sl reflect.Value
-				if err == nil {
-					sl = reflect.ValueOf(old) // existing slice
-				} else {
-					sl = reflect.MakeSlice(typ, 0, 1)
-				}
-				sl = reflect.Append(sl, ext)
-				SetExtension(ep, desc, sl.Interface())
-			}
-			if err := p.consumeOptionalSeparator(); err != nil {
-				return err
-			}
-			continue
-		}
-
-		// This is a normal, non-extension field.
-		name := tok.value
-		var dst reflect.Value
-		fi, props, ok := structFieldByName(sprops, name)
-		if ok {
-			dst = sv.Field(fi)
-		} else if oop, ok := sprops.OneofTypes[name]; ok {
-			// It is a oneof.
-			props = oop.Prop
-			nv := reflect.New(oop.Type.Elem())
-			dst = nv.Elem().Field(0)
-			field := sv.Field(oop.Field)
-			if !field.IsNil() {
-				return p.errorf("field '%s' would overwrite already parsed oneof '%s'", name, sv.Type().Field(oop.Field).Name)
-			}
-			field.Set(nv)
-		}
-		if !dst.IsValid() {
-			return p.errorf("unknown field name %q in %v", name, st)
-		}
-
-		if dst.Kind() == reflect.Map {
-			// Consume any colon.
-			if err := p.checkForColon(props, dst.Type()); err != nil {
-				return err
-			}
-
-			// Construct the map if it doesn't already exist.
-			if dst.IsNil() {
-				dst.Set(reflect.MakeMap(dst.Type()))
-			}
-			key := reflect.New(dst.Type().Key()).Elem()
-			val := reflect.New(dst.Type().Elem()).Elem()
-
-			// The map entry should be this sequence of tokens:
-			//	< key : KEY value : VALUE >
-			// However, implementations may omit key or value, and technically
-			// we should support them in any order.  See b/28924776 for a time
-			// this went wrong.
-
-			tok := p.next()
-			var terminator string
-			switch tok.value {
-			case "<":
-				terminator = ">"
-			case "{":
-				terminator = "}"
-			default:
-				return p.errorf("expected '{' or '<', found %q", tok.value)
-			}
-			for {
-				tok := p.next()
-				if tok.err != nil {
-					return tok.err
-				}
-				if tok.value == terminator {
-					break
-				}
-				switch tok.value {
-				case "key":
-					if err := p.consumeToken(":"); err != nil {
-						return err
-					}
-					if err := p.readAny(key, props.mkeyprop); err != nil {
-						return err
-					}
-					if err := p.consumeOptionalSeparator(); err != nil {
-						return err
-					}
-				case "value":
-					if err := p.checkForColon(props.mvalprop, dst.Type().Elem()); err != nil {
-						return err
-					}
-					if err := p.readAny(val, props.mvalprop); err != nil {
-						return err
-					}
-					if err := p.consumeOptionalSeparator(); err != nil {
-						return err
-					}
-				default:
-					p.back()
-					return p.errorf(`expected "key", "value", or %q, found %q`, terminator, tok.value)
-				}
-			}
-
-			dst.SetMapIndex(key, val)
-			continue
-		}
-
-		// Check that it's not already set if it's not a repeated field.
-		if !props.Repeated && fieldSet[name] {
-			return p.errorf("non-repeated field %q was repeated", name)
-		}
-
-		if err := p.checkForColon(props, dst.Type()); err != nil {
-			return err
-		}
-
-		// Parse into the field.
-		fieldSet[name] = true
-		if err := p.readAny(dst, props); err != nil {
-			if _, ok := err.(*RequiredNotSetError); !ok {
-				return err
-			}
-			reqFieldErr = err
-		}
-		if props.Required {
-			reqCount--
-		}
-
-		if err := p.consumeOptionalSeparator(); err != nil {
-			return err
-		}
-
-	}
-
-	if reqCount > 0 {
-		return p.missingRequiredFieldError(sv)
-	}
-	return reqFieldErr
-}
-
-// consumeExtName consumes extension name or expanded Any type URL and the
-// following ']'. It returns the name or URL consumed.
-func (p *textParser) consumeExtName() (string, error) {
-	tok := p.next()
-	if tok.err != nil {
-		return "", tok.err
-	}
-
-	// If extension name or type url is quoted, it's a single token.
-	if len(tok.value) > 2 && isQuote(tok.value[0]) && tok.value[len(tok.value)-1] == tok.value[0] {
-		name, err := unquoteC(tok.value[1:len(tok.value)-1], rune(tok.value[0]))
-		if err != nil {
-			return "", err
-		}
-		return name, p.consumeToken("]")
-	}
-
-	// Consume everything up to "]"
-	var parts []string
-	for tok.value != "]" {
-		parts = append(parts, tok.value)
-		tok = p.next()
-		if tok.err != nil {
-			return "", p.errorf("unrecognized type_url or extension name: %s", tok.err)
-		}
-		if p.done && tok.value != "]" {
-			return "", p.errorf("unclosed type_url or extension name")
-		}
-	}
-	return strings.Join(parts, ""), nil
-}
-
-// consumeOptionalSeparator consumes an optional semicolon or comma.
-// It is used in readStruct to provide backward compatibility.
-func (p *textParser) consumeOptionalSeparator() error {
-	tok := p.next()
-	if tok.err != nil {
-		return tok.err
-	}
-	if tok.value != ";" && tok.value != "," {
-		p.back()
-	}
-	return nil
-}
-
-func (p *textParser) readAny(v reflect.Value, props *Properties) error {
-	tok := p.next()
-	if tok.err != nil {
-		return tok.err
-	}
-	if tok.value == "" {
-		return p.errorf("unexpected EOF")
-	}
-
-	switch fv := v; fv.Kind() {
-	case reflect.Slice:
-		at := v.Type()
-		if at.Elem().Kind() == reflect.Uint8 {
-			// Special case for []byte
-			if tok.value[0] != '"' && tok.value[0] != '\'' {
-				// Deliberately written out here, as the error after
-				// this switch statement would write "invalid []byte: ...",
-				// which is not as user-friendly.
-				return p.errorf("invalid string: %v", tok.value)
-			}
-			bytes := []byte(tok.unquoted)
-			fv.Set(reflect.ValueOf(bytes))
-			return nil
-		}
-		// Repeated field.
-		if tok.value == "[" {
-			// Repeated field with list notation, like [1,2,3].
-			for {
-				fv.Set(reflect.Append(fv, reflect.New(at.Elem()).Elem()))
-				err := p.readAny(fv.Index(fv.Len()-1), props)
-				if err != nil {
-					return err
-				}
-				tok := p.next()
-				if tok.err != nil {
-					return tok.err
-				}
-				if tok.value == "]" {
-					break
-				}
-				if tok.value != "," {
-					return p.errorf("Expected ']' or ',' found %q", tok.value)
-				}
-			}
-			return nil
-		}
-		// One value of the repeated field.
-		p.back()
-		fv.Set(reflect.Append(fv, reflect.New(at.Elem()).Elem()))
-		return p.readAny(fv.Index(fv.Len()-1), props)
-	case reflect.Bool:
-		// true/1/t/True or false/f/0/False.
-		switch tok.value {
-		case "true", "1", "t", "True":
-			fv.SetBool(true)
-			return nil
-		case "false", "0", "f", "False":
-			fv.SetBool(false)
-			return nil
-		}
-	case reflect.Float32, reflect.Float64:
-		v := tok.value
-		// Ignore 'f' for compatibility with output generated by C++, but don't
-		// remove 'f' when the value is "-inf" or "inf".
-		if strings.HasSuffix(v, "f") && tok.value != "-inf" && tok.value != "inf" {
-			v = v[:len(v)-1]
-		}
-		if f, err := strconv.ParseFloat(v, fv.Type().Bits()); err == nil {
-			fv.SetFloat(f)
-			return nil
-		}
-	case reflect.Int32:
-		if x, err := strconv.ParseInt(tok.value, 0, 32); err == nil {
-			fv.SetInt(x)
-			return nil
-		}
-
-		if len(props.Enum) == 0 {
-			break
-		}
-		m, ok := enumValueMaps[props.Enum]
-		if !ok {
-			break
-		}
-		x, ok := m[tok.value]
-		if !ok {
-			break
-		}
-		fv.SetInt(int64(x))
-		return nil
-	case reflect.Int64:
-		if x, err := strconv.ParseInt(tok.value, 0, 64); err == nil {
-			fv.SetInt(x)
-			return nil
-		}
-
-	case reflect.Ptr:
-		// A basic field (indirected through pointer), or a repeated message/group
-		p.back()
-		fv.Set(reflect.New(fv.Type().Elem()))
-		return p.readAny(fv.Elem(), props)
-	case reflect.String:
-		if tok.value[0] == '"' || tok.value[0] == '\'' {
-			fv.SetString(tok.unquoted)
-			return nil
-		}
-	case reflect.Struct:
-		var terminator string
-		switch tok.value {
-		case "{":
-			terminator = "}"
-		case "<":
-			terminator = ">"
-		default:
-			return p.errorf("expected '{' or '<', found %q", tok.value)
-		}
-		// TODO: Handle nested messages which implement encoding.TextUnmarshaler.
-		return p.readStruct(fv, terminator)
-	case reflect.Uint32:
-		if x, err := strconv.ParseUint(tok.value, 0, 32); err == nil {
-			fv.SetUint(uint64(x))
-			return nil
-		}
-	case reflect.Uint64:
-		if x, err := strconv.ParseUint(tok.value, 0, 64); err == nil {
-			fv.SetUint(x)
-			return nil
-		}
-	}
-	return p.errorf("invalid %v: %v", v.Type(), tok.value)
-}
-
-// UnmarshalText reads a protocol buffer in Text format. UnmarshalText resets pb
-// before starting to unmarshal, so any existing data in pb is always removed.
-// If a required field is not set and no other error occurs,
-// UnmarshalText returns *RequiredNotSetError.
-func UnmarshalText(s string, pb Message) error {
-	if um, ok := pb.(encoding.TextUnmarshaler); ok {
-		return um.UnmarshalText([]byte(s))
-	}
-	pb.Reset()
-	v := reflect.ValueOf(pb)
-	return newTextParser(s).readStruct(v.Elem(), "")
-}
diff --git a/vendor/github.com/golang/protobuf/proto/text_parser_test.go b/vendor/github.com/golang/protobuf/proto/text_parser_test.go
deleted file mode 100644
index a81980879..000000000
--- a/vendor/github.com/golang/protobuf/proto/text_parser_test.go
+++ /dev/null
@@ -1,706 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package proto_test
-
-import (
-	"fmt"
-	"math"
-	"testing"
-
-	. "github.com/golang/protobuf/proto"
-	proto3pb "github.com/golang/protobuf/proto/proto3_proto"
-	. "github.com/golang/protobuf/proto/test_proto"
-)
-
-type UnmarshalTextTest struct {
-	in  string
-	err string // if "", no error expected
-	out *MyMessage
-}
-
-func buildExtStructTest(text string) UnmarshalTextTest {
-	msg := &MyMessage{
-		Count: Int32(42),
-	}
-	SetExtension(msg, E_Ext_More, &Ext{
-		Data: String("Hello, world!"),
-	})
-	return UnmarshalTextTest{in: text, out: msg}
-}
-
-func buildExtDataTest(text string) UnmarshalTextTest {
-	msg := &MyMessage{
-		Count: Int32(42),
-	}
-	SetExtension(msg, E_Ext_Text, String("Hello, world!"))
-	SetExtension(msg, E_Ext_Number, Int32(1729))
-	return UnmarshalTextTest{in: text, out: msg}
-}
-
-func buildExtRepStringTest(text string) UnmarshalTextTest {
-	msg := &MyMessage{
-		Count: Int32(42),
-	}
-	if err := SetExtension(msg, E_Greeting, []string{"bula", "hola"}); err != nil {
-		panic(err)
-	}
-	return UnmarshalTextTest{in: text, out: msg}
-}
-
-var unMarshalTextTests = []UnmarshalTextTest{
-	// Basic
-	{
-		in: " count:42\n  name:\"Dave\" ",
-		out: &MyMessage{
-			Count: Int32(42),
-			Name:  String("Dave"),
-		},
-	},
-
-	// Empty quoted string
-	{
-		in: `count:42 name:""`,
-		out: &MyMessage{
-			Count: Int32(42),
-			Name:  String(""),
-		},
-	},
-
-	// Quoted string concatenation with double quotes
-	{
-		in: `count:42 name: "My name is "` + "\n" + `"elsewhere"`,
-		out: &MyMessage{
-			Count: Int32(42),
-			Name:  String("My name is elsewhere"),
-		},
-	},
-
-	// Quoted string concatenation with single quotes
-	{
-		in: "count:42 name: 'My name is '\n'elsewhere'",
-		out: &MyMessage{
-			Count: Int32(42),
-			Name:  String("My name is elsewhere"),
-		},
-	},
-
-	// Quoted string concatenations with mixed quotes
-	{
-		in: "count:42 name: 'My name is '\n\"elsewhere\"",
-		out: &MyMessage{
-			Count: Int32(42),
-			Name:  String("My name is elsewhere"),
-		},
-	},
-	{
-		in: "count:42 name: \"My name is \"\n'elsewhere'",
-		out: &MyMessage{
-			Count: Int32(42),
-			Name:  String("My name is elsewhere"),
-		},
-	},
-
-	// Quoted string with escaped apostrophe
-	{
-		in: `count:42 name: "HOLIDAY - New Year\'s Day"`,
-		out: &MyMessage{
-			Count: Int32(42),
-			Name:  String("HOLIDAY - New Year's Day"),
-		},
-	},
-
-	// Quoted string with single quote
-	{
-		in: `count:42 name: 'Roger "The Ramster" Ramjet'`,
-		out: &MyMessage{
-			Count: Int32(42),
-			Name:  String(`Roger "The Ramster" Ramjet`),
-		},
-	},
-
-	// Quoted string with all the accepted special characters from the C++ test
-	{
-		in: `count:42 name: ` + "\"\\\"A string with \\' characters \\n and \\r newlines and \\t tabs and \\001 slashes \\\\ and  multiple   spaces\"",
-		out: &MyMessage{
-			Count: Int32(42),
-			Name:  String("\"A string with ' characters \n and \r newlines and \t tabs and \001 slashes \\ and  multiple   spaces"),
-		},
-	},
-
-	// Quoted string with quoted backslash
-	{
-		in: `count:42 name: "\\'xyz"`,
-		out: &MyMessage{
-			Count: Int32(42),
-			Name:  String(`\'xyz`),
-		},
-	},
-
-	// Quoted string with UTF-8 bytes.
-	{
-		in: "count:42 name: '\303\277\302\201\x00\xAB\xCD\xEF'",
-		out: &MyMessage{
-			Count: Int32(42),
-			Name:  String("\303\277\302\201\x00\xAB\xCD\xEF"),
-		},
-	},
-
-	// Quoted string with unicode escapes.
-	{
-		in: `count: 42 name: "\u0047\U00000047\uffff\U0010ffff"`,
-		out: &MyMessage{
-			Count: Int32(42),
-			Name:  String("GG\uffff\U0010ffff"),
-		},
-	},
-
-	// Bad quoted string
-	{
-		in:  `inner: < host: "\0" >` + "\n",
-		err: `line 1.15: invalid quoted string "\0": \0 requires 2 following digits`,
-	},
-
-	// Bad \u escape
-	{
-		in:  `count: 42 name: "\u000"`,
-		err: `line 1.16: invalid quoted string "\u000": \u requires 4 following digits`,
-	},
-
-	// Bad \U escape
-	{
-		in:  `count: 42 name: "\U0000000"`,
-		err: `line 1.16: invalid quoted string "\U0000000": \U requires 8 following digits`,
-	},
-
-	// Bad \U escape
-	{
-		in:  `count: 42 name: "\xxx"`,
-		err: `line 1.16: invalid quoted string "\xxx": \xxx contains non-hexadecimal digits`,
-	},
-
-	// Number too large for int64
-	{
-		in:  "count: 1 others { key: 123456789012345678901 }",
-		err: "line 1.23: invalid int64: 123456789012345678901",
-	},
-
-	// Number too large for int32
-	{
-		in:  "count: 1234567890123",
-		err: "line 1.7: invalid int32: 1234567890123",
-	},
-
-	// Number in hexadecimal
-	{
-		in: "count: 0x2beef",
-		out: &MyMessage{
-			Count: Int32(0x2beef),
-		},
-	},
-
-	// Number in octal
-	{
-		in: "count: 024601",
-		out: &MyMessage{
-			Count: Int32(024601),
-		},
-	},
-
-	// Floating point number with "f" suffix
-	{
-		in: "count: 4 others:< weight: 17.0f >",
-		out: &MyMessage{
-			Count: Int32(4),
-			Others: []*OtherMessage{
-				{
-					Weight: Float32(17),
-				},
-			},
-		},
-	},
-
-	// Floating point positive infinity
-	{
-		in: "count: 4 bigfloat: inf",
-		out: &MyMessage{
-			Count:    Int32(4),
-			Bigfloat: Float64(math.Inf(1)),
-		},
-	},
-
-	// Floating point negative infinity
-	{
-		in: "count: 4 bigfloat: -inf",
-		out: &MyMessage{
-			Count:    Int32(4),
-			Bigfloat: Float64(math.Inf(-1)),
-		},
-	},
-
-	// Number too large for float32
-	{
-		in:  "others:< weight: 12345678901234567890123456789012345678901234567890 >",
-		err: "line 1.17: invalid float32: 12345678901234567890123456789012345678901234567890",
-	},
-
-	// Number posing as a quoted string
-	{
-		in:  `inner: < host: 12 >` + "\n",
-		err: `line 1.15: invalid string: 12`,
-	},
-
-	// Quoted string posing as int32
-	{
-		in:  `count: "12"`,
-		err: `line 1.7: invalid int32: "12"`,
-	},
-
-	// Quoted string posing a float32
-	{
-		in:  `others:< weight: "17.4" >`,
-		err: `line 1.17: invalid float32: "17.4"`,
-	},
-
-	// unclosed bracket doesn't cause infinite loop
-	{
-		in:  `[`,
-		err: `line 1.0: unclosed type_url or extension name`,
-	},
-
-	// Enum
-	{
-		in: `count:42 bikeshed: BLUE`,
-		out: &MyMessage{
-			Count:    Int32(42),
-			Bikeshed: MyMessage_BLUE.Enum(),
-		},
-	},
-
-	// Repeated field
-	{
-		in: `count:42 pet: "horsey" pet:"bunny"`,
-		out: &MyMessage{
-			Count: Int32(42),
-			Pet:   []string{"horsey", "bunny"},
-		},
-	},
-
-	// Repeated field with list notation
-	{
-		in: `count:42 pet: ["horsey", "bunny"]`,
-		out: &MyMessage{
-			Count: Int32(42),
-			Pet:   []string{"horsey", "bunny"},
-		},
-	},
-
-	// Repeated message with/without colon and <>/{}
-	{
-		in: `count:42 others:{} others{} others:<> others:{}`,
-		out: &MyMessage{
-			Count: Int32(42),
-			Others: []*OtherMessage{
-				{},
-				{},
-				{},
-				{},
-			},
-		},
-	},
-
-	// Missing colon for inner message
-	{
-		in: `count:42 inner < host: "cauchy.syd" >`,
-		out: &MyMessage{
-			Count: Int32(42),
-			Inner: &InnerMessage{
-				Host: String("cauchy.syd"),
-			},
-		},
-	},
-
-	// Missing colon for string field
-	{
-		in:  `name "Dave"`,
-		err: `line 1.5: expected ':', found "\"Dave\""`,
-	},
-
-	// Missing colon for int32 field
-	{
-		in:  `count 42`,
-		err: `line 1.6: expected ':', found "42"`,
-	},
-
-	// Missing required field
-	{
-		in:  `name: "Pawel"`,
-		err: fmt.Sprintf(`proto: required field "%T.count" not set`, MyMessage{}),
-		out: &MyMessage{
-			Name: String("Pawel"),
-		},
-	},
-
-	// Missing required field in a required submessage
-	{
-		in:  `count: 42 we_must_go_deeper < leo_finally_won_an_oscar <> >`,
-		err: fmt.Sprintf(`proto: required field "%T.host" not set`, InnerMessage{}),
-		out: &MyMessage{
-			Count:          Int32(42),
-			WeMustGoDeeper: &RequiredInnerMessage{LeoFinallyWonAnOscar: &InnerMessage{}},
-		},
-	},
-
-	// Repeated non-repeated field
-	{
-		in:  `name: "Rob" name: "Russ"`,
-		err: `line 1.12: non-repeated field "name" was repeated`,
-	},
-
-	// Group
-	{
-		in: `count: 17 SomeGroup { group_field: 12 }`,
-		out: &MyMessage{
-			Count: Int32(17),
-			Somegroup: &MyMessage_SomeGroup{
-				GroupField: Int32(12),
-			},
-		},
-	},
-
-	// Semicolon between fields
-	{
-		in: `count:3;name:"Calvin"`,
-		out: &MyMessage{
-			Count: Int32(3),
-			Name:  String("Calvin"),
-		},
-	},
-	// Comma between fields
-	{
-		in: `count:4,name:"Ezekiel"`,
-		out: &MyMessage{
-			Count: Int32(4),
-			Name:  String("Ezekiel"),
-		},
-	},
-
-	// Boolean false
-	{
-		in: `count:42 inner { host: "example.com" connected: false }`,
-		out: &MyMessage{
-			Count: Int32(42),
-			Inner: &InnerMessage{
-				Host:      String("example.com"),
-				Connected: Bool(false),
-			},
-		},
-	},
-	// Boolean true
-	{
-		in: `count:42 inner { host: "example.com" connected: true }`,
-		out: &MyMessage{
-			Count: Int32(42),
-			Inner: &InnerMessage{
-				Host:      String("example.com"),
-				Connected: Bool(true),
-			},
-		},
-	},
-	// Boolean 0
-	{
-		in: `count:42 inner { host: "example.com" connected: 0 }`,
-		out: &MyMessage{
-			Count: Int32(42),
-			Inner: &InnerMessage{
-				Host:      String("example.com"),
-				Connected: Bool(false),
-			},
-		},
-	},
-	// Boolean 1
-	{
-		in: `count:42 inner { host: "example.com" connected: 1 }`,
-		out: &MyMessage{
-			Count: Int32(42),
-			Inner: &InnerMessage{
-				Host:      String("example.com"),
-				Connected: Bool(true),
-			},
-		},
-	},
-	// Boolean f
-	{
-		in: `count:42 inner { host: "example.com" connected: f }`,
-		out: &MyMessage{
-			Count: Int32(42),
-			Inner: &InnerMessage{
-				Host:      String("example.com"),
-				Connected: Bool(false),
-			},
-		},
-	},
-	// Boolean t
-	{
-		in: `count:42 inner { host: "example.com" connected: t }`,
-		out: &MyMessage{
-			Count: Int32(42),
-			Inner: &InnerMessage{
-				Host:      String("example.com"),
-				Connected: Bool(true),
-			},
-		},
-	},
-	// Boolean False
-	{
-		in: `count:42 inner { host: "example.com" connected: False }`,
-		out: &MyMessage{
-			Count: Int32(42),
-			Inner: &InnerMessage{
-				Host:      String("example.com"),
-				Connected: Bool(false),
-			},
-		},
-	},
-	// Boolean True
-	{
-		in: `count:42 inner { host: "example.com" connected: True }`,
-		out: &MyMessage{
-			Count: Int32(42),
-			Inner: &InnerMessage{
-				Host:      String("example.com"),
-				Connected: Bool(true),
-			},
-		},
-	},
-
-	// Extension
-	buildExtStructTest(`count: 42 [test_proto.Ext.more]:<data:"Hello, world!" >`),
-	buildExtStructTest(`count: 42 [test_proto.Ext.more] {data:"Hello, world!"}`),
-	buildExtDataTest(`count: 42 [test_proto.Ext.text]:"Hello, world!" [test_proto.Ext.number]:1729`),
-	buildExtRepStringTest(`count: 42 [test_proto.greeting]:"bula" [test_proto.greeting]:"hola"`),
-
-	// Big all-in-one
-	{
-		in: "count:42  # Meaning\n" +
-			`name:"Dave" ` +
-			`quote:"\"I didn't want to go.\"" ` +
-			`pet:"bunny" ` +
-			`pet:"kitty" ` +
-			`pet:"horsey" ` +
-			`inner:<` +
-			`  host:"footrest.syd" ` +
-			`  port:7001 ` +
-			`  connected:true ` +
-			`> ` +
-			`others:<` +
-			`  key:3735928559 ` +
-			`  value:"\x01A\a\f" ` +
-			`> ` +
-			`others:<` +
-			"  weight:58.9  # Atomic weight of Co\n" +
-			`  inner:<` +
-			`    host:"lesha.mtv" ` +
-			`    port:8002 ` +
-			`  >` +
-			`>`,
-		out: &MyMessage{
-			Count: Int32(42),
-			Name:  String("Dave"),
-			Quote: String(`"I didn't want to go."`),
-			Pet:   []string{"bunny", "kitty", "horsey"},
-			Inner: &InnerMessage{
-				Host:      String("footrest.syd"),
-				Port:      Int32(7001),
-				Connected: Bool(true),
-			},
-			Others: []*OtherMessage{
-				{
-					Key:   Int64(3735928559),
-					Value: []byte{0x1, 'A', '\a', '\f'},
-				},
-				{
-					Weight: Float32(58.9),
-					Inner: &InnerMessage{
-						Host: String("lesha.mtv"),
-						Port: Int32(8002),
-					},
-				},
-			},
-		},
-	},
-}
-
-func TestUnmarshalText(t *testing.T) {
-	for i, test := range unMarshalTextTests {
-		pb := new(MyMessage)
-		err := UnmarshalText(test.in, pb)
-		if test.err == "" {
-			// We don't expect failure.
-			if err != nil {
-				t.Errorf("Test %d: Unexpected error: %v", i, err)
-			} else if !Equal(pb, test.out) {
-				t.Errorf("Test %d: Incorrect populated \nHave: %v\nWant: %v",
-					i, pb, test.out)
-			}
-		} else {
-			// We do expect failure.
-			if err == nil {
-				t.Errorf("Test %d: Didn't get expected error: %v", i, test.err)
-			} else if err.Error() != test.err {
-				t.Errorf("Test %d: Incorrect error.\nHave: %v\nWant: %v",
-					i, err.Error(), test.err)
-			} else if _, ok := err.(*RequiredNotSetError); ok && test.out != nil && !Equal(pb, test.out) {
-				t.Errorf("Test %d: Incorrect populated \nHave: %v\nWant: %v",
-					i, pb, test.out)
-			}
-		}
-	}
-}
-
-func TestUnmarshalTextCustomMessage(t *testing.T) {
-	msg := &textMessage{}
-	if err := UnmarshalText("custom", msg); err != nil {
-		t.Errorf("Unexpected error from custom unmarshal: %v", err)
-	}
-	if UnmarshalText("not custom", msg) == nil {
-		t.Errorf("Didn't get expected error from custom unmarshal")
-	}
-}
-
-// Regression test; this caused a panic.
-func TestRepeatedEnum(t *testing.T) {
-	pb := new(RepeatedEnum)
-	if err := UnmarshalText("color: RED", pb); err != nil {
-		t.Fatal(err)
-	}
-	exp := &RepeatedEnum{
-		Color: []RepeatedEnum_Color{RepeatedEnum_RED},
-	}
-	if !Equal(pb, exp) {
-		t.Errorf("Incorrect populated \nHave: %v\nWant: %v", pb, exp)
-	}
-}
-
-func TestProto3TextParsing(t *testing.T) {
-	m := new(proto3pb.Message)
-	const in = `name: "Wallace" true_scotsman: true`
-	want := &proto3pb.Message{
-		Name:         "Wallace",
-		TrueScotsman: true,
-	}
-	if err := UnmarshalText(in, m); err != nil {
-		t.Fatal(err)
-	}
-	if !Equal(m, want) {
-		t.Errorf("\n got %v\nwant %v", m, want)
-	}
-}
-
-func TestMapParsing(t *testing.T) {
-	m := new(MessageWithMap)
-	const in = `name_mapping:<key:1234 value:"Feist"> name_mapping:<key:1 value:"Beatles">` +
-		`msg_mapping:<key:-4, value:<f: 2.0>,>` + // separating commas are okay
-		`msg_mapping<key:-2 value<f: 4.0>>` + // no colon after "value"
-		`msg_mapping:<value:<f: 5.0>>` + // omitted key
-		`msg_mapping:<key:1>` + // omitted value
-		`byte_mapping:<key:true value:"so be it">` +
-		`byte_mapping:<>` // omitted key and value
-	want := &MessageWithMap{
-		NameMapping: map[int32]string{
-			1:    "Beatles",
-			1234: "Feist",
-		},
-		MsgMapping: map[int64]*FloatingPoint{
-			-4: {F: Float64(2.0)},
-			-2: {F: Float64(4.0)},
-			0:  {F: Float64(5.0)},
-			1:  nil,
-		},
-		ByteMapping: map[bool][]byte{
-			false: nil,
-			true:  []byte("so be it"),
-		},
-	}
-	if err := UnmarshalText(in, m); err != nil {
-		t.Fatal(err)
-	}
-	if !Equal(m, want) {
-		t.Errorf("\n got %v\nwant %v", m, want)
-	}
-}
-
-func TestOneofParsing(t *testing.T) {
-	const in = `name:"Shrek"`
-	m := new(Communique)
-	want := &Communique{Union: &Communique_Name{"Shrek"}}
-	if err := UnmarshalText(in, m); err != nil {
-		t.Fatal(err)
-	}
-	if !Equal(m, want) {
-		t.Errorf("\n got %v\nwant %v", m, want)
-	}
-
-	const inOverwrite = `name:"Shrek" number:42`
-	m = new(Communique)
-	testErr := "line 1.13: field 'number' would overwrite already parsed oneof 'Union'"
-	if err := UnmarshalText(inOverwrite, m); err == nil {
-		t.Errorf("TestOneofParsing: Didn't get expected error: %v", testErr)
-	} else if err.Error() != testErr {
-		t.Errorf("TestOneofParsing: Incorrect error.\nHave: %v\nWant: %v",
-			err.Error(), testErr)
-	}
-
-}
-
-var benchInput string
-
-func init() {
-	benchInput = "count: 4\n"
-	for i := 0; i < 1000; i++ {
-		benchInput += "pet: \"fido\"\n"
-	}
-
-	// Check it is valid input.
-	pb := new(MyMessage)
-	err := UnmarshalText(benchInput, pb)
-	if err != nil {
-		panic("Bad benchmark input: " + err.Error())
-	}
-}
-
-func BenchmarkUnmarshalText(b *testing.B) {
-	pb := new(MyMessage)
-	for i := 0; i < b.N; i++ {
-		UnmarshalText(benchInput, pb)
-	}
-	b.SetBytes(int64(len(benchInput)))
-}
diff --git a/vendor/github.com/golang/protobuf/proto/text_test.go b/vendor/github.com/golang/protobuf/proto/text_test.go
index 3c8b033c0..3f6edc5a6 100644
--- a/vendor/github.com/golang/protobuf/proto/text_test.go
+++ b/vendor/github.com/golang/protobuf/proto/text_test.go
@@ -1,52 +1,285 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// Copyright 2016 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 proto_test
 
 import (
 	"bytes"
 	"errors"
-	"io/ioutil"
 	"math"
 	"strings"
 	"sync"
 	"testing"
 
 	"github.com/golang/protobuf/proto"
+	"github.com/google/go-cmp/cmp"
 
-	proto3pb "github.com/golang/protobuf/proto/proto3_proto"
-	pb "github.com/golang/protobuf/proto/test_proto"
+	pb2 "github.com/golang/protobuf/internal/testprotos/proto2_proto"
+	pb3 "github.com/golang/protobuf/internal/testprotos/proto3_proto"
 	anypb "github.com/golang/protobuf/ptypes/any"
 )
 
+var (
+	expandedMarshaler        = proto.TextMarshaler{ExpandAny: true}
+	expandedCompactMarshaler = proto.TextMarshaler{Compact: true, ExpandAny: true}
+)
+
+// anyEqual reports whether two messages which may be google.protobuf.Any or may
+// contain google.protobuf.Any fields are equal. We can't use proto.Equal for
+// comparison, because semantically equivalent messages may be marshaled to
+// binary in different tag order. Instead, trust that TextMarshaler with
+// ExpandAny option works and compare the text marshaling results.
+func anyEqual(got, want proto.Message) bool {
+	// if messages are proto.Equal, no need to marshal.
+	if proto.Equal(got, want) {
+		return true
+	}
+	g := expandedMarshaler.Text(got)
+	w := expandedMarshaler.Text(want)
+	return g == w
+}
+
+type golden struct {
+	m    proto.Message
+	t, c string
+}
+
+var goldenMessages = makeGolden()
+
+func makeGolden() []golden {
+	nested := &pb3.Nested{Bunny: "Monty"}
+	nb, err := proto.Marshal(nested)
+	if err != nil {
+		panic(err)
+	}
+	m1 := &pb3.Message{
+		Name:        "David",
+		ResultCount: 47,
+		Anything:    &anypb.Any{TypeUrl: "type.googleapis.com/" + proto.MessageName(nested), Value: nb},
+	}
+	m2 := &pb3.Message{
+		Name:        "David",
+		ResultCount: 47,
+		Anything:    &anypb.Any{TypeUrl: "http://[::1]/type.googleapis.com/" + proto.MessageName(nested), Value: nb},
+	}
+	m3 := &pb3.Message{
+		Name:        "David",
+		ResultCount: 47,
+		Anything:    &anypb.Any{TypeUrl: `type.googleapis.com/"/` + proto.MessageName(nested), Value: nb},
+	}
+	m4 := &pb3.Message{
+		Name:        "David",
+		ResultCount: 47,
+		Anything:    &anypb.Any{TypeUrl: "type.googleapis.com/a/path/" + proto.MessageName(nested), Value: nb},
+	}
+	m5 := &anypb.Any{TypeUrl: "type.googleapis.com/" + proto.MessageName(nested), Value: nb}
+
+	any1 := &pb2.MyMessage{Count: proto.Int32(47), Name: proto.String("David")}
+	proto.SetExtension(any1, pb2.E_Ext_More, &pb2.Ext{Data: proto.String("foo")})
+	proto.SetExtension(any1, pb2.E_Ext_Text, proto.String("bar"))
+	any1b, err := proto.Marshal(any1)
+	if err != nil {
+		panic(err)
+	}
+	any2 := &pb2.MyMessage{Count: proto.Int32(42), Bikeshed: pb2.MyMessage_GREEN.Enum(), RepBytes: [][]byte{[]byte("roboto")}}
+	proto.SetExtension(any2, pb2.E_Ext_More, &pb2.Ext{Data: proto.String("baz")})
+	any2b, err := proto.Marshal(any2)
+	if err != nil {
+		panic(err)
+	}
+	m6 := &pb3.Message{
+		Name:        "David",
+		ResultCount: 47,
+		Anything:    &anypb.Any{TypeUrl: "type.googleapis.com/" + proto.MessageName(any1), Value: any1b},
+		ManyThings: []*anypb.Any{
+			&anypb.Any{TypeUrl: "type.googleapis.com/" + proto.MessageName(any2), Value: any2b},
+			&anypb.Any{TypeUrl: "type.googleapis.com/" + proto.MessageName(any1), Value: any1b},
+		},
+	}
+
+	const (
+		m1Golden = `
+name: "David"
+result_count: 47
+anything: <
+  [type.googleapis.com/proto3_test.Nested]: <
+    bunny: "Monty"
+  >
+>
+`
+		m2Golden = `
+name: "David"
+result_count: 47
+anything: <
+  ["http://[::1]/type.googleapis.com/proto3_test.Nested"]: <
+    bunny: "Monty"
+  >
+>
+`
+		m3Golden = `
+name: "David"
+result_count: 47
+anything: <
+  ["type.googleapis.com/\"/proto3_test.Nested"]: <
+    bunny: "Monty"
+  >
+>
+`
+		m4Golden = `
+name: "David"
+result_count: 47
+anything: <
+  [type.googleapis.com/a/path/proto3_test.Nested]: <
+    bunny: "Monty"
+  >
+>
+`
+		m5Golden = `
+[type.googleapis.com/proto3_test.Nested]: <
+  bunny: "Monty"
+>
+`
+		m6Golden = `
+name: "David"
+result_count: 47
+anything: <
+  [type.googleapis.com/proto2_test.MyMessage]: <
+    count: 47
+    name: "David"
+    [proto2_test.Ext.more]: <
+      data: "foo"
+    >
+    [proto2_test.Ext.text]: "bar"
+  >
+>
+many_things: <
+  [type.googleapis.com/proto2_test.MyMessage]: <
+    count: 42
+    bikeshed: GREEN
+    rep_bytes: "roboto"
+    [proto2_test.Ext.more]: <
+      data: "baz"
+    >
+  >
+>
+many_things: <
+  [type.googleapis.com/proto2_test.MyMessage]: <
+    count: 47
+    name: "David"
+    [proto2_test.Ext.more]: <
+      data: "foo"
+    >
+    [proto2_test.Ext.text]: "bar"
+  >
+>
+`
+	)
+	return []golden{
+		{m1, strings.TrimSpace(m1Golden) + "\n", strings.TrimSpace(compact(m1Golden)) + " "},
+		{m2, strings.TrimSpace(m2Golden) + "\n", strings.TrimSpace(compact(m2Golden)) + " "},
+		{m3, strings.TrimSpace(m3Golden) + "\n", strings.TrimSpace(compact(m3Golden)) + " "},
+		{m4, strings.TrimSpace(m4Golden) + "\n", strings.TrimSpace(compact(m4Golden)) + " "},
+		{m5, strings.TrimSpace(m5Golden) + "\n", strings.TrimSpace(compact(m5Golden)) + " "},
+		{m6, strings.TrimSpace(m6Golden) + "\n", strings.TrimSpace(compact(m6Golden)) + " "},
+	}
+}
+
+func TestMarshalGolden(t *testing.T) {
+	for _, tt := range goldenMessages {
+		t.Run("", func(t *testing.T) {
+			if got, want := expandedMarshaler.Text(tt.m), tt.t; got != want {
+				t.Errorf("message %v: got:\n%s\nwant:\n%s", tt.m, got, want)
+			}
+			if got, want := expandedCompactMarshaler.Text(tt.m), tt.c; got != want {
+				t.Errorf("message %v: got:\n`%s`\nwant:\n`%s`", tt.m, got, want)
+			}
+		})
+	}
+}
+
+func TestUnmarshalGolden(t *testing.T) {
+	for _, tt := range goldenMessages {
+		t.Run("", func(t *testing.T) {
+			want := tt.m
+			got := proto.Clone(tt.m)
+			got.Reset()
+			if err := proto.UnmarshalText(tt.t, got); err != nil {
+				t.Errorf("failed to unmarshal\n%s\nerror: %v", tt.t, err)
+			}
+			if !anyEqual(got, want) {
+				t.Errorf("message:\n%s\ngot:\n%s\nwant:\n%s", tt.t, got, want)
+			}
+			got.Reset()
+			if err := proto.UnmarshalText(tt.c, got); err != nil {
+				t.Errorf("failed to unmarshal\n%s\nerror: %v", tt.c, err)
+			}
+			if !anyEqual(got, want) {
+				t.Errorf("message:\n%s\ngot:\n%s\nwant:\n%s", tt.c, got, want)
+			}
+		})
+	}
+}
+
+func TestMarshalUnknownAny(t *testing.T) {
+	m := &pb3.Message{
+		Anything: &anypb.Any{
+			TypeUrl: "foo",
+			Value:   []byte("bar"),
+		},
+	}
+	want := `anything: <
+  type_url: "foo"
+  value: "bar"
+>
+`
+	got := expandedMarshaler.Text(m)
+	if got != want {
+		t.Errorf("got:\n%s\nwant:\n%s", got, want)
+	}
+}
+
+func TestAmbiguousAny(t *testing.T) {
+	pb := &anypb.Any{}
+	err := proto.UnmarshalText(`
+	type_url: "ttt/proto3_test.Nested"
+	value: "\n\x05Monty"
+	`, pb)
+	if err != nil {
+		t.Errorf("unexpected proto.UnmarshalText error: %v", err)
+	}
+}
+
+func TestUnmarshalOverwriteAny(t *testing.T) {
+	pb := &anypb.Any{}
+	err := proto.UnmarshalText(`
+  [type.googleapis.com/a/path/proto3_test.Nested]: <
+    bunny: "Monty"
+  >
+  [type.googleapis.com/a/path/proto3_test.Nested]: <
+    bunny: "Rabbit of Caerbannog"
+  >
+	`, pb)
+	want := `line 7: Any message unpacked multiple times, or "type_url" already set`
+	if err.Error() != want {
+		t.Errorf("incorrect error:\ngot:  %v\nwant: %v", err.Error(), want)
+	}
+}
+
+func TestUnmarshalAnyMixAndMatch(t *testing.T) {
+	pb := &anypb.Any{}
+	err := proto.UnmarshalText(`
+	value: "\n\x05Monty"
+  [type.googleapis.com/a/path/proto3_test.Nested]: <
+    bunny: "Rabbit of Caerbannog"
+  >
+	`, pb)
+	want := `line 5: Any message unpacked multiple times, or "value" already set`
+	if err.Error() != want {
+		t.Errorf("incorrect error:\ngot:  %v\nwant: %v", err.Error(), want)
+	}
+}
+
 // textMessage implements the methods that allow it to marshal and unmarshal
 // itself as text.
 type textMessage struct {
@@ -67,51 +300,51 @@ func (*textMessage) Reset()         {}
 func (*textMessage) String() string { return "" }
 func (*textMessage) ProtoMessage()  {}
 
-func newTestMessage() *pb.MyMessage {
-	msg := &pb.MyMessage{
+func newTestMessage() *pb2.MyMessage {
+	msg := &pb2.MyMessage{
 		Count: proto.Int32(42),
 		Name:  proto.String("Dave"),
 		Quote: proto.String(`"I didn't want to go."`),
 		Pet:   []string{"bunny", "kitty", "horsey"},
-		Inner: &pb.InnerMessage{
+		Inner: &pb2.InnerMessage{
 			Host:      proto.String("footrest.syd"),
 			Port:      proto.Int32(7001),
 			Connected: proto.Bool(true),
 		},
-		Others: []*pb.OtherMessage{
+		Others: []*pb2.OtherMessage{
 			{
 				Key:   proto.Int64(0xdeadbeef),
 				Value: []byte{1, 65, 7, 12},
 			},
 			{
 				Weight: proto.Float32(6.022),
-				Inner: &pb.InnerMessage{
+				Inner: &pb2.InnerMessage{
 					Host: proto.String("lesha.mtv"),
 					Port: proto.Int32(8002),
 				},
 			},
 		},
-		Bikeshed: pb.MyMessage_BLUE.Enum(),
-		Somegroup: &pb.MyMessage_SomeGroup{
+		Bikeshed: pb2.MyMessage_BLUE.Enum(),
+		Somegroup: &pb2.MyMessage_SomeGroup{
 			GroupField: proto.Int32(8),
 		},
 		// One normally wouldn't do this.
 		// This is an undeclared tag 13, as a varint (wire type 0) with value 4.
 		XXX_unrecognized: []byte{13<<3 | 0, 4},
 	}
-	ext := &pb.Ext{
+	ext := &pb2.Ext{
 		Data: proto.String("Big gobs for big rats"),
 	}
-	if err := proto.SetExtension(msg, pb.E_Ext_More, ext); err != nil {
+	if err := proto.SetExtension(msg, pb2.E_Ext_More, ext); err != nil {
 		panic(err)
 	}
 	greetings := []string{"adg", "easy", "cow"}
-	if err := proto.SetExtension(msg, pb.E_Greeting, greetings); err != nil {
+	if err := proto.SetExtension(msg, pb2.E_Greeting, greetings); err != nil {
 		panic(err)
 	}
 
-	// Add an unknown extension. We marshal a pb.Ext, and fake the ID.
-	b, err := proto.Marshal(&pb.Ext{Data: proto.String("3G skiing")})
+	// Add an unknown extension. We marshal a pb2.Ext, and fake the ID.
+	b, err := proto.Marshal(&pb2.Ext{Data: proto.String("3G skiing")})
 	if err != nil {
 		panic(err)
 	}
@@ -151,18 +384,16 @@ bikeshed: BLUE
 SomeGroup {
   group_field: 8
 }
-/* 2 unknown bytes */
+/* 18 unknown bytes */
 13: 4
-[test_proto.Ext.more]: <
-  data: "Big gobs for big rats"
->
-[test_proto.greeting]: "adg"
-[test_proto.greeting]: "easy"
-[test_proto.greeting]: "cow"
-/* 13 unknown bytes */
 201: "\t3G skiing"
-/* 3 unknown bytes */
 202: 19
+[proto2_test.Ext.more]: <
+  data: "Big gobs for big rats"
+>
+[proto2_test.greeting]: "adg"
+[proto2_test.greeting]: "easy"
+[proto2_test.greeting]: "cow"
 `
 
 func TestMarshalText(t *testing.T) {
@@ -170,9 +401,9 @@ func TestMarshalText(t *testing.T) {
 	if err := proto.MarshalText(buf, newTestMessage()); err != nil {
 		t.Fatalf("proto.MarshalText: %v", err)
 	}
-	s := buf.String()
-	if s != text {
-		t.Errorf("Got:\n===\n%v===\nExpected:\n===\n%v===\n", s, text)
+	got := buf.String()
+	if diff := cmp.Diff(text, got); got != text {
+		t.Errorf("diff (-want +got):\n%v\n\ngot:\n%v\n\nwant:\n%v", diff, got, text)
 	}
 }
 
@@ -181,14 +412,14 @@ func TestMarshalTextCustomMessage(t *testing.T) {
 	if err := proto.MarshalText(buf, &textMessage{}); err != nil {
 		t.Fatalf("proto.MarshalText: %v", err)
 	}
-	s := buf.String()
-	if s != "custom" {
-		t.Errorf("Got %q, expected %q", s, "custom")
+	got := buf.String()
+	if got != "custom" {
+		t.Errorf("got:\n%v\n\nwant:\n%v", got, "custom")
 	}
 }
 func TestMarshalTextNil(t *testing.T) {
 	want := "<nil>"
-	tests := []proto.Message{nil, (*pb.MyMessage)(nil)}
+	tests := []proto.Message{nil, (*pb2.MyMessage)(nil)}
 	for i, test := range tests {
 		buf := new(bytes.Buffer)
 		if err := proto.MarshalText(buf, test); err != nil {
@@ -202,7 +433,7 @@ func TestMarshalTextNil(t *testing.T) {
 
 func TestMarshalTextUnknownEnum(t *testing.T) {
 	// The Color enum only specifies values 0-2.
-	m := &pb.MyMessage{Bikeshed: pb.MyMessage_Color(3).Enum()}
+	m := &pb2.MyMessage{Bikeshed: pb2.MyMessage_Color(3).Enum()}
 	got := m.String()
 	const want = `bikeshed:3 `
 	if got != want {
@@ -216,41 +447,24 @@ func TestTextOneof(t *testing.T) {
 		want string
 	}{
 		// zero message
-		{&pb.Communique{}, ``},
+		{&pb2.Communique{}, ``},
 		// scalar field
-		{&pb.Communique{Union: &pb.Communique_Number{4}}, `number:4`},
+		{&pb2.Communique{Union: &pb2.Communique_Number{4}}, `number:4`},
 		// message field
-		{&pb.Communique{Union: &pb.Communique_Msg{
-			&pb.Strings{StringField: proto.String("why hello!")},
+		{&pb2.Communique{Union: &pb2.Communique_Msg{
+			&pb2.Strings{StringField: proto.String("why hello!")},
 		}}, `msg:<string_field:"why hello!" >`},
 		// bad oneof (should not panic)
-		{&pb.Communique{Union: &pb.Communique_Msg{nil}}, `msg:/* nil */`},
+		{&pb2.Communique{Union: &pb2.Communique_Msg{nil}}, `msg:<>`},
 	}
 	for _, test := range tests {
 		got := strings.TrimSpace(test.m.String())
 		if got != test.want {
-			t.Errorf("\n got %s\nwant %s", got, test.want)
+			t.Errorf("got:\n%s\n\nwant:\n%s", got, test.want)
 		}
 	}
 }
 
-func BenchmarkMarshalTextBuffered(b *testing.B) {
-	buf := new(bytes.Buffer)
-	m := newTestMessage()
-	for i := 0; i < b.N; i++ {
-		buf.Reset()
-		proto.MarshalText(buf, m)
-	}
-}
-
-func BenchmarkMarshalTextUnbuffered(b *testing.B) {
-	w := ioutil.Discard
-	m := newTestMessage()
-	for i := 0; i < b.N; i++ {
-		proto.MarshalText(w, m)
-	}
-}
-
 func compact(src string) string {
 	// s/[ \n]+/ /g; s/ $//;
 	dst := make([]byte, len(src))
@@ -296,59 +510,56 @@ func compact(src string) string {
 	return string(dst[0:j])
 }
 
-var compactText = compact(text)
-
 func TestCompactText(t *testing.T) {
-	s := proto.CompactTextString(newTestMessage())
-	if s != compactText {
-		t.Errorf("Got:\n===\n%v===\nExpected:\n===\n%v\n===\n", s, compactText)
+	got := proto.CompactTextString(newTestMessage())
+	if got != compact(text) {
+		t.Errorf("got:\n%v\n\nwant:\n%v", got, compact(text))
 	}
 }
 
 func TestStringEscaping(t *testing.T) {
 	testCases := []struct {
-		in  *pb.Strings
+		in  *pb2.Strings
 		out string
 	}{
 		{
 			// Test data from C++ test (TextFormatTest.StringEscape).
 			// Single divergence: we don't escape apostrophes.
-			&pb.Strings{StringField: proto.String("\"A string with ' characters \n and \r newlines and \t tabs and \001 slashes \\ and  multiple   spaces")},
+			&pb2.Strings{StringField: proto.String("\"A string with ' characters \n and \r newlines and \t tabs and \001 slashes \\ and  multiple   spaces")},
 			"string_field: \"\\\"A string with ' characters \\n and \\r newlines and \\t tabs and \\001 slashes \\\\ and  multiple   spaces\"\n",
 		},
 		{
 			// Test data from the same C++ test.
-			&pb.Strings{StringField: proto.String("\350\260\267\346\255\214")},
+			&pb2.Strings{StringField: proto.String("\350\260\267\346\255\214")},
 			"string_field: \"\\350\\260\\267\\346\\255\\214\"\n",
 		},
 		{
 			// Some UTF-8.
-			&pb.Strings{StringField: proto.String("\x00\x01\xff\x81")},
+			&pb2.Strings{StringField: proto.String("\x00\x01\xff\x81")},
 			`string_field: "\000\001\377\201"` + "\n",
 		},
 	}
 
-	for i, tc := range testCases {
-		var buf bytes.Buffer
-		if err := proto.MarshalText(&buf, tc.in); err != nil {
-			t.Errorf("proto.MarsalText: %v", err)
-			continue
-		}
-		s := buf.String()
-		if s != tc.out {
-			t.Errorf("#%d: Got:\n%s\nExpected:\n%s\n", i, s, tc.out)
-			continue
-		}
+	for _, tc := range testCases {
+		t.Run("", func(t *testing.T) {
+			var buf bytes.Buffer
+			if err := proto.MarshalText(&buf, tc.in); err != nil {
+				t.Fatalf("proto.MarsalText error: %v", err)
+			}
+			got := buf.String()
+			if got != tc.out {
+				t.Fatalf("want:\n%s\n\nwant:\n%s", got, tc.out)
+			}
 
-		// Check round-trip.
-		pb := new(pb.Strings)
-		if err := proto.UnmarshalText(s, pb); err != nil {
-			t.Errorf("#%d: UnmarshalText: %v", i, err)
-			continue
-		}
-		if !proto.Equal(pb, tc.in) {
-			t.Errorf("#%d: Round-trip failed:\nstart: %v\n  end: %v", i, tc.in, pb)
-		}
+			// Check round-trip.
+			pb := new(pb2.Strings)
+			if err := proto.UnmarshalText(got, pb); err != nil {
+				t.Fatalf("proto.UnmarshalText error: %v", err)
+			}
+			if !proto.Equal(pb, tc.in) {
+				t.Fatalf("proto.Equal mismatch:\ngot:\n%v\n\nwant:\n%v", pb, tc.in)
+			}
+		})
 	}
 }
 
@@ -382,12 +593,12 @@ func TestMarshalTextFailing(t *testing.T) {
 		err := proto.MarshalText(buf, newTestMessage())
 		// We expect a certain error, but also some partial results in the buffer.
 		if err != outOfSpace {
-			t.Errorf("Got:\n===\n%v===\nExpected:\n===\n%v===\n", err, outOfSpace)
+			t.Errorf("error mismatch: got %v, want %v", err, outOfSpace)
 		}
-		s := buf.b.String()
-		x := text[:buf.limit]
-		if s != x {
-			t.Errorf("Got:\n===\n%v===\nExpected:\n===\n%v===\n", s, x)
+		got := buf.b.String()
+		want := text[:buf.limit]
+		if got != want {
+			t.Errorf("text mismatch:\n\ngot:\n%v\n\nwant:\n%v", got, want)
 		}
 	}
 }
@@ -404,7 +615,7 @@ func TestFloats(t *testing.T) {
 		{math.NaN(), "nan"},
 	}
 	for _, test := range tests {
-		msg := &pb.FloatingPoint{F: &test.f}
+		msg := &pb2.FloatingPoint{F: &test.f}
 		got := strings.TrimSpace(msg.String())
 		want := `f:` + test.want
 		if got != want {
@@ -414,23 +625,25 @@ func TestFloats(t *testing.T) {
 }
 
 func TestRepeatedNilText(t *testing.T) {
-	m := &pb.MessageList{
-		Message: []*pb.MessageList_Message{
+	m := &pb2.MessageList{
+		Message: []*pb2.MessageList_Message{
 			nil,
-			&pb.MessageList_Message{
+			&pb2.MessageList_Message{
 				Name: proto.String("Horse"),
 			},
 			nil,
 		},
 	}
-	want := `Message <nil>
+	want := `Message {
+}
 Message {
   name: "Horse"
 }
-Message <nil>
+Message {
+}
 `
-	if s := proto.MarshalTextString(m); s != want {
-		t.Errorf(" got: %s\nwant: %s", s, want)
+	if got := proto.MarshalTextString(m); got != want {
+		t.Errorf("got:\n%s\n\nwant:\n%s", got, want)
 	}
 }
 
@@ -440,17 +653,17 @@ func TestProto3Text(t *testing.T) {
 		want string
 	}{
 		// zero message
-		{&proto3pb.Message{}, ``},
+		{&pb3.Message{}, ``},
 		// zero message except for an empty byte slice
-		{&proto3pb.Message{Data: []byte{}}, ``},
+		{&pb3.Message{Data: []byte{}}, ``},
 		// trivial case
-		{&proto3pb.Message{Name: "Rob", HeightInCm: 175}, `name:"Rob" height_in_cm:175`},
+		{&pb3.Message{Name: "Rob", HeightInCm: 175}, `name:"Rob" height_in_cm:175`},
 		// empty map
-		{&pb.MessageWithMap{}, ``},
+		{&pb2.MessageWithMap{}, ``},
 		// non-empty map; map format is the same as a repeated struct,
 		// and they are sorted by key (numerically for numeric keys).
 		{
-			&pb.MessageWithMap{NameMapping: map[int32]string{
+			&pb2.MessageWithMap{NameMapping: map[int32]string{
 				-1:      "Negatory",
 				7:       "Lucky",
 				1234:    "Feist",
@@ -463,14 +676,14 @@ func TestProto3Text(t *testing.T) {
 		},
 		// map with nil value; not well-defined, but we shouldn't crash
 		{
-			&pb.MessageWithMap{MsgMapping: map[int64]*pb.FloatingPoint{7: nil}},
-			`msg_mapping:<key:7 >`,
+			&pb2.MessageWithMap{MsgMapping: map[int64]*pb2.FloatingPoint{7: nil}},
+			`msg_mapping:<key:7 value:<> >`,
 		},
 	}
 	for _, test := range tests {
 		got := strings.TrimSpace(test.m.String())
 		if got != test.want {
-			t.Errorf("\n got %s\nwant %s", got, test.want)
+			t.Errorf("got:\n%s\n\nwant:\n%s", got, test.want)
 		}
 	}
 }
@@ -478,13 +691,13 @@ func TestProto3Text(t *testing.T) {
 func TestRacyMarshal(t *testing.T) {
 	// This test should be run with the race detector.
 
-	any := &pb.MyMessage{Count: proto.Int32(47), Name: proto.String("David")}
-	proto.SetExtension(any, pb.E_Ext_Text, proto.String("bar"))
+	any := &pb2.MyMessage{Count: proto.Int32(47), Name: proto.String("David")}
+	proto.SetExtension(any, pb2.E_Ext_Text, proto.String("bar"))
 	b, err := proto.Marshal(any)
 	if err != nil {
 		panic(err)
 	}
-	m := &proto3pb.Message{
+	m := &pb3.Message{
 		Name:        "David",
 		ResultCount: 47,
 		Anything:    &anypb.Any{TypeUrl: "type.googleapis.com/" + proto.MessageName(any), Value: b},
@@ -516,3 +729,642 @@ func TestRacyMarshal(t *testing.T) {
 		}()
 	}
 }
+
+type UnmarshalTextTest struct {
+	in  string
+	err string // if "", no error expected
+	out *pb2.MyMessage
+}
+
+func buildExtStructTest(text string) UnmarshalTextTest {
+	msg := &pb2.MyMessage{
+		Count: proto.Int32(42),
+	}
+	proto.SetExtension(msg, pb2.E_Ext_More, &pb2.Ext{
+		Data: proto.String("Hello, world!"),
+	})
+	return UnmarshalTextTest{in: text, out: msg}
+}
+
+func buildExtDataTest(text string) UnmarshalTextTest {
+	msg := &pb2.MyMessage{
+		Count: proto.Int32(42),
+	}
+	proto.SetExtension(msg, pb2.E_Ext_Text, proto.String("Hello, world!"))
+	proto.SetExtension(msg, pb2.E_Ext_Number, proto.Int32(1729))
+	return UnmarshalTextTest{in: text, out: msg}
+}
+
+func buildExtRepStringTest(text string) UnmarshalTextTest {
+	msg := &pb2.MyMessage{
+		Count: proto.Int32(42),
+	}
+	if err := proto.SetExtension(msg, pb2.E_Greeting, []string{"bula", "hola"}); err != nil {
+		panic(err)
+	}
+	return UnmarshalTextTest{in: text, out: msg}
+}
+
+var unmarshalTextTests = []UnmarshalTextTest{
+	// Basic
+	{
+		in: " count:42\n  name:\"Dave\" ",
+		out: &pb2.MyMessage{
+			Count: proto.Int32(42),
+			Name:  proto.String("Dave"),
+		},
+	},
+
+	// Empty quoted string
+	{
+		in: `count:42 name:""`,
+		out: &pb2.MyMessage{
+			Count: proto.Int32(42),
+			Name:  proto.String(""),
+		},
+	},
+
+	// Quoted string concatenation with double quotes
+	{
+		in: `count:42 name: "My name is "` + "\n" + `"elsewhere"`,
+		out: &pb2.MyMessage{
+			Count: proto.Int32(42),
+			Name:  proto.String("My name is elsewhere"),
+		},
+	},
+
+	// Quoted string concatenation with single quotes
+	{
+		in: "count:42 name: 'My name is '\n'elsewhere'",
+		out: &pb2.MyMessage{
+			Count: proto.Int32(42),
+			Name:  proto.String("My name is elsewhere"),
+		},
+	},
+
+	// Quoted string concatenations with mixed quotes
+	{
+		in: "count:42 name: 'My name is '\n\"elsewhere\"",
+		out: &pb2.MyMessage{
+			Count: proto.Int32(42),
+			Name:  proto.String("My name is elsewhere"),
+		},
+	},
+	{
+		in: "count:42 name: \"My name is \"\n'elsewhere'",
+		out: &pb2.MyMessage{
+			Count: proto.Int32(42),
+			Name:  proto.String("My name is elsewhere"),
+		},
+	},
+
+	// Quoted string with escaped apostrophe
+	{
+		in: `count:42 name: "HOLIDAY - New Year\'s Day"`,
+		out: &pb2.MyMessage{
+			Count: proto.Int32(42),
+			Name:  proto.String("HOLIDAY - New Year's Day"),
+		},
+	},
+
+	// Quoted string with single quote
+	{
+		in: `count:42 name: 'Roger "The Ramster" Ramjet'`,
+		out: &pb2.MyMessage{
+			Count: proto.Int32(42),
+			Name:  proto.String(`Roger "The Ramster" Ramjet`),
+		},
+	},
+
+	// Quoted string with all the accepted special characters from the C++ test
+	{
+		in: `count:42 name: ` + "\"\\\"A string with \\' characters \\n and \\r newlines and \\t tabs and \\001 slashes \\\\ and  multiple   spaces\"",
+		out: &pb2.MyMessage{
+			Count: proto.Int32(42),
+			Name:  proto.String("\"A string with ' characters \n and \r newlines and \t tabs and \001 slashes \\ and  multiple   spaces"),
+		},
+	},
+
+	// Quoted string with quoted backslash
+	{
+		in: `count:42 name: "\\'xyz"`,
+		out: &pb2.MyMessage{
+			Count: proto.Int32(42),
+			Name:  proto.String(`\'xyz`),
+		},
+	},
+
+	// Quoted string with UTF-8 bytes.
+	{
+		in: "count:42 name: '\303\277\302\201\x00\xAB\xCD\xEF'",
+		out: &pb2.MyMessage{
+			Count: proto.Int32(42),
+			Name:  proto.String("\303\277\302\201\x00\xAB\xCD\xEF"),
+		},
+	},
+
+	// Quoted string with unicode escapes.
+	{
+		in: `count: 42 name: "\u0047\U00000047\uffff\U0010ffff"`,
+		out: &pb2.MyMessage{
+			Count: proto.Int32(42),
+			Name:  proto.String("GG\uffff\U0010ffff"),
+		},
+	},
+
+	// Bad quoted string
+	{
+		in:  `inner: < host: "\0" >` + "\n",
+		err: `line 1.15: invalid quoted string "\0": \0 requires 2 following digits`,
+	},
+
+	// Bad \u escape
+	{
+		in:  `count: 42 name: "\u000"`,
+		err: `line 1.16: invalid quoted string "\u000": \u requires 4 following digits`,
+	},
+
+	// Bad \U escape
+	{
+		in:  `count: 42 name: "\U0000000"`,
+		err: `line 1.16: invalid quoted string "\U0000000": \U requires 8 following digits`,
+	},
+
+	// Bad \U escape
+	{
+		in:  `count: 42 name: "\xxx"`,
+		err: `line 1.16: invalid quoted string "\xxx": \xxx contains non-hexadecimal digits`,
+	},
+
+	// Number too large for int64
+	{
+		in:  "count: 1 others { key: 123456789012345678901 }",
+		err: "line 1.23: invalid int64: 123456789012345678901",
+	},
+
+	// Number too large for int32
+	{
+		in:  "count: 1234567890123",
+		err: "line 1.7: invalid int32: 1234567890123",
+	},
+
+	// Number in hexadecimal
+	{
+		in: "count: 0x2beef",
+		out: &pb2.MyMessage{
+			Count: proto.Int32(0x2beef),
+		},
+	},
+
+	// Number in octal
+	{
+		in: "count: 024601",
+		out: &pb2.MyMessage{
+			Count: proto.Int32(024601),
+		},
+	},
+
+	// Floating point number with "f" suffix
+	{
+		in: "count: 4 others:< weight: 17.0f >",
+		out: &pb2.MyMessage{
+			Count: proto.Int32(4),
+			Others: []*pb2.OtherMessage{
+				{
+					Weight: proto.Float32(17),
+				},
+			},
+		},
+	},
+
+	// Floating point positive infinity
+	{
+		in: "count: 4 bigfloat: inf",
+		out: &pb2.MyMessage{
+			Count:    proto.Int32(4),
+			Bigfloat: proto.Float64(math.Inf(1)),
+		},
+	},
+
+	// Floating point negative infinity
+	{
+		in: "count: 4 bigfloat: -inf",
+		out: &pb2.MyMessage{
+			Count:    proto.Int32(4),
+			Bigfloat: proto.Float64(math.Inf(-1)),
+		},
+	},
+
+	// Number too large for float32
+	{
+		in:  "others:< weight: 12345678901234567890123456789012345678901234567890 >",
+		err: "line 1.17: invalid float: 12345678901234567890123456789012345678901234567890",
+	},
+
+	// Number posing as a quoted string
+	{
+		in:  `inner: < host: 12 >` + "\n",
+		err: `line 1.15: invalid string: 12`,
+	},
+
+	// Quoted string posing as int32
+	{
+		in:  `count: "12"`,
+		err: `line 1.7: invalid int32: "12"`,
+	},
+
+	// Quoted string posing a float32
+	{
+		in:  `others:< weight: "17.4" >`,
+		err: `line 1.17: invalid float: "17.4"`,
+	},
+
+	// unclosed bracket doesn't cause infinite loop
+	{
+		in:  `[`,
+		err: `line 1.0: unclosed type_url or extension name`,
+	},
+
+	// Enum
+	{
+		in: `count:42 bikeshed: BLUE`,
+		out: &pb2.MyMessage{
+			Count:    proto.Int32(42),
+			Bikeshed: pb2.MyMessage_BLUE.Enum(),
+		},
+	},
+
+	// Repeated field
+	{
+		in: `count:42 pet: "horsey" pet:"bunny"`,
+		out: &pb2.MyMessage{
+			Count: proto.Int32(42),
+			Pet:   []string{"horsey", "bunny"},
+		},
+	},
+
+	// Repeated field with list notation
+	{
+		in: `count:42 pet: ["horsey", "bunny"]`,
+		out: &pb2.MyMessage{
+			Count: proto.Int32(42),
+			Pet:   []string{"horsey", "bunny"},
+		},
+	},
+
+	// Repeated message with/without colon and <>/{}
+	{
+		in: `count:42 others:{} others{} others:<> others:{}`,
+		out: &pb2.MyMessage{
+			Count: proto.Int32(42),
+			Others: []*pb2.OtherMessage{
+				{},
+				{},
+				{},
+				{},
+			},
+		},
+	},
+
+	// Missing colon for inner message
+	{
+		in: `count:42 inner < host: "cauchy.syd" >`,
+		out: &pb2.MyMessage{
+			Count: proto.Int32(42),
+			Inner: &pb2.InnerMessage{
+				Host: proto.String("cauchy.syd"),
+			},
+		},
+	},
+
+	// Missing colon for string field
+	{
+		in:  `name "Dave"`,
+		err: `line 1.5: expected ':', found "\"Dave\""`,
+	},
+
+	// Missing colon for int32 field
+	{
+		in:  `count 42`,
+		err: `line 1.6: expected ':', found "42"`,
+	},
+
+	// Missing required field
+	{
+		in:  `name: "Pawel"`,
+		err: `required field proto2_test.MyMessage.count not set`,
+		out: &pb2.MyMessage{
+			Name: proto.String("Pawel"),
+		},
+	},
+
+	// Missing required field in a required submessage
+	{
+		in:  `count: 42 we_must_go_deeper < leo_finally_won_an_oscar <> >`,
+		err: `required field proto2_test.InnerMessage.host not set`,
+		out: &pb2.MyMessage{
+			Count:          proto.Int32(42),
+			WeMustGoDeeper: &pb2.RequiredInnerMessage{LeoFinallyWonAnOscar: &pb2.InnerMessage{}},
+		},
+	},
+
+	// Repeated non-repeated field
+	{
+		in:  `name: "Rob" name: "Russ"`,
+		err: `line 1.12: non-repeated field "name" was repeated`,
+	},
+
+	// Group
+	{
+		in: `count: 17 SomeGroup { group_field: 12 }`,
+		out: &pb2.MyMessage{
+			Count: proto.Int32(17),
+			Somegroup: &pb2.MyMessage_SomeGroup{
+				GroupField: proto.Int32(12),
+			},
+		},
+	},
+
+	// Semicolon between fields
+	{
+		in: `count:3;name:"Calvin"`,
+		out: &pb2.MyMessage{
+			Count: proto.Int32(3),
+			Name:  proto.String("Calvin"),
+		},
+	},
+	// Comma between fields
+	{
+		in: `count:4,name:"Ezekiel"`,
+		out: &pb2.MyMessage{
+			Count: proto.Int32(4),
+			Name:  proto.String("Ezekiel"),
+		},
+	},
+
+	// Boolean false
+	{
+		in: `count:42 inner { host: "example.com" connected: false }`,
+		out: &pb2.MyMessage{
+			Count: proto.Int32(42),
+			Inner: &pb2.InnerMessage{
+				Host:      proto.String("example.com"),
+				Connected: proto.Bool(false),
+			},
+		},
+	},
+	// Boolean true
+	{
+		in: `count:42 inner { host: "example.com" connected: true }`,
+		out: &pb2.MyMessage{
+			Count: proto.Int32(42),
+			Inner: &pb2.InnerMessage{
+				Host:      proto.String("example.com"),
+				Connected: proto.Bool(true),
+			},
+		},
+	},
+	// Boolean 0
+	{
+		in: `count:42 inner { host: "example.com" connected: 0 }`,
+		out: &pb2.MyMessage{
+			Count: proto.Int32(42),
+			Inner: &pb2.InnerMessage{
+				Host:      proto.String("example.com"),
+				Connected: proto.Bool(false),
+			},
+		},
+	},
+	// Boolean 1
+	{
+		in: `count:42 inner { host: "example.com" connected: 1 }`,
+		out: &pb2.MyMessage{
+			Count: proto.Int32(42),
+			Inner: &pb2.InnerMessage{
+				Host:      proto.String("example.com"),
+				Connected: proto.Bool(true),
+			},
+		},
+	},
+	// Boolean f
+	{
+		in: `count:42 inner { host: "example.com" connected: f }`,
+		out: &pb2.MyMessage{
+			Count: proto.Int32(42),
+			Inner: &pb2.InnerMessage{
+				Host:      proto.String("example.com"),
+				Connected: proto.Bool(false),
+			},
+		},
+	},
+	// Boolean t
+	{
+		in: `count:42 inner { host: "example.com" connected: t }`,
+		out: &pb2.MyMessage{
+			Count: proto.Int32(42),
+			Inner: &pb2.InnerMessage{
+				Host:      proto.String("example.com"),
+				Connected: proto.Bool(true),
+			},
+		},
+	},
+	// Boolean False
+	{
+		in: `count:42 inner { host: "example.com" connected: False }`,
+		out: &pb2.MyMessage{
+			Count: proto.Int32(42),
+			Inner: &pb2.InnerMessage{
+				Host:      proto.String("example.com"),
+				Connected: proto.Bool(false),
+			},
+		},
+	},
+	// Boolean True
+	{
+		in: `count:42 inner { host: "example.com" connected: True }`,
+		out: &pb2.MyMessage{
+			Count: proto.Int32(42),
+			Inner: &pb2.InnerMessage{
+				Host:      proto.String("example.com"),
+				Connected: proto.Bool(true),
+			},
+		},
+	},
+
+	// Extension
+	buildExtStructTest(`count: 42 [proto2_test.Ext.more]:<data:"Hello, world!" >`),
+	buildExtStructTest(`count: 42 [proto2_test.Ext.more] {data:"Hello, world!"}`),
+	buildExtDataTest(`count: 42 [proto2_test.Ext.text]:"Hello, world!" [proto2_test.Ext.number]:1729`),
+	buildExtRepStringTest(`count: 42 [proto2_test.greeting]:"bula" [proto2_test.greeting]:"hola"`),
+	{
+		in:  `[proto2_test.complex]:<>`,
+		err: `line 1.20: extension field "proto2_test.complex" does not extend message "proto2_test.MyMessage"`,
+	},
+
+	// Big all-in-one
+	{
+		in: "count:42  # Meaning\n" +
+			`name:"Dave" ` +
+			`quote:"\"I didn't want to go.\"" ` +
+			`pet:"bunny" ` +
+			`pet:"kitty" ` +
+			`pet:"horsey" ` +
+			`inner:<` +
+			`  host:"footrest.syd" ` +
+			`  port:7001 ` +
+			`  connected:true ` +
+			`> ` +
+			`others:<` +
+			`  key:3735928559 ` +
+			`  value:"\x01A\a\f" ` +
+			`> ` +
+			`others:<` +
+			"  weight:58.9  # Atomic weight of Co\n" +
+			`  inner:<` +
+			`    host:"lesha.mtv" ` +
+			`    port:8002 ` +
+			`  >` +
+			`>`,
+		out: &pb2.MyMessage{
+			Count: proto.Int32(42),
+			Name:  proto.String("Dave"),
+			Quote: proto.String(`"I didn't want to go."`),
+			Pet:   []string{"bunny", "kitty", "horsey"},
+			Inner: &pb2.InnerMessage{
+				Host:      proto.String("footrest.syd"),
+				Port:      proto.Int32(7001),
+				Connected: proto.Bool(true),
+			},
+			Others: []*pb2.OtherMessage{
+				{
+					Key:   proto.Int64(3735928559),
+					Value: []byte{0x1, 'A', '\a', '\f'},
+				},
+				{
+					Weight: proto.Float32(58.9),
+					Inner: &pb2.InnerMessage{
+						Host: proto.String("lesha.mtv"),
+						Port: proto.Int32(8002),
+					},
+				},
+			},
+		},
+	},
+}
+
+func TestUnmarshalText(t *testing.T) {
+	for _, test := range unmarshalTextTests {
+		t.Run("", func(t *testing.T) {
+			pb := new(pb2.MyMessage)
+			err := proto.UnmarshalText(test.in, pb)
+			if test.err == "" {
+				// We don't expect failure.
+				if err != nil {
+					t.Errorf("proto.UnmarshalText error: %v", err)
+				} else if !proto.Equal(pb, test.out) {
+					t.Errorf("proto.Equal mismatch:\ngot:  %v\nwant: %v", pb, test.out)
+				}
+			} else {
+				// We do expect failure.
+				if err == nil {
+					t.Errorf("proto.UnmarshalText: got nil error, want %v", test.err)
+				} else if !strings.Contains(err.Error(), test.err) {
+					t.Errorf("proto.UnmarshalText error mismatch:\ngot:  %v\nwant: %v", err.Error(), test.err)
+				} else if _, ok := err.(*proto.RequiredNotSetError); ok && test.out != nil && !proto.Equal(pb, test.out) {
+					t.Errorf("proto.Equal mismatch:\ngot  %v\nwant: %v", pb, test.out)
+				}
+			}
+		})
+	}
+}
+
+func TestUnmarshalTextCustomMessage(t *testing.T) {
+	msg := &textMessage{}
+	if err := proto.UnmarshalText("custom", msg); err != nil {
+		t.Errorf("proto.UnmarshalText error: %v", err)
+	}
+	if err := proto.UnmarshalText("not custom", msg); err == nil {
+		t.Errorf("proto.UnmarshalText: got nil error, want non-nil")
+	}
+}
+
+// Regression test; this caused a panic.
+func TestRepeatedEnum(t *testing.T) {
+	pb := new(pb2.RepeatedEnum)
+	if err := proto.UnmarshalText("color: RED", pb); err != nil {
+		t.Fatal(err)
+	}
+	exp := &pb2.RepeatedEnum{
+		Color: []pb2.RepeatedEnum_Color{pb2.RepeatedEnum_RED},
+	}
+	if !proto.Equal(pb, exp) {
+		t.Errorf("proto.Equal mismatch:\ngot:  %v\nwant %v", pb, exp)
+	}
+}
+
+func TestProto3TextParsing(t *testing.T) {
+	m := new(pb3.Message)
+	const in = `name: "Wallace" true_scotsman: true`
+	want := &pb3.Message{
+		Name:         "Wallace",
+		TrueScotsman: true,
+	}
+	if err := proto.UnmarshalText(in, m); err != nil {
+		t.Fatal(err)
+	}
+	if !proto.Equal(m, want) {
+		t.Errorf("proto.Equal mismatch:\ngot:  %v\nwant %v", m, want)
+	}
+}
+
+func TestMapParsing(t *testing.T) {
+	m := new(pb2.MessageWithMap)
+	const in = `name_mapping:<key:1234 value:"Feist"> name_mapping:<key:1 value:"Beatles">` +
+		`msg_mapping:<key:-4, value:<f: 2.0>,>` + // separating commas are okay
+		`msg_mapping<key:-2 value<f: 4.0>>` + // no colon after "value"
+		`msg_mapping:<value:<f: 5.0>>` + // omitted key
+		`byte_mapping:<key:true value:"so be it">` +
+		`byte_mapping:<>` // omitted key and value
+	want := &pb2.MessageWithMap{
+		NameMapping: map[int32]string{
+			1:    "Beatles",
+			1234: "Feist",
+		},
+		MsgMapping: map[int64]*pb2.FloatingPoint{
+			-4: {F: proto.Float64(2.0)},
+			-2: {F: proto.Float64(4.0)},
+			0:  {F: proto.Float64(5.0)},
+		},
+		ByteMapping: map[bool][]byte{
+			false: nil,
+			true:  []byte("so be it"),
+		},
+	}
+	if err := proto.UnmarshalText(in, m); err != nil {
+		t.Fatal(err)
+	}
+	if !proto.Equal(m, want) {
+		t.Errorf("proto.Equal mismatch:\ngot:  %v\nwant %v", m, want)
+	}
+}
+
+func TestOneofParsing(t *testing.T) {
+	const in = `name:"Shrek"`
+	m := new(pb2.Communique)
+	want := &pb2.Communique{Union: &pb2.Communique_Name{"Shrek"}}
+	if err := proto.UnmarshalText(in, m); err != nil {
+		t.Fatal(err)
+	}
+	if !proto.Equal(m, want) {
+		t.Errorf("\n got %v\nwant %v", m, want)
+	}
+
+	const inOverwrite = `name:"Shrek" number:42`
+	m = new(pb2.Communique)
+	testErr := "line 1.13: field 'number' would overwrite already parsed oneof 'union'"
+	if err := proto.UnmarshalText(inOverwrite, m); err == nil {
+		t.Errorf("proto.UnmarshalText: got nil error, want %v", testErr)
+	} else if err.Error() != testErr {
+		t.Errorf("error mismatch:\ngot:  %v\nwant: %v", err.Error(), testErr)
+	}
+}
diff --git a/vendor/github.com/golang/protobuf/proto/wire.go b/vendor/github.com/golang/protobuf/proto/wire.go
new file mode 100644
index 000000000..d7c28da5a
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/wire.go
@@ -0,0 +1,78 @@
+// Copyright 2019 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 proto
+
+import (
+	protoV2 "google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/runtime/protoiface"
+)
+
+// Size returns the size in bytes of the wire-format encoding of m.
+func Size(m Message) int {
+	if m == nil {
+		return 0
+	}
+	mi := MessageV2(m)
+	return protoV2.Size(mi)
+}
+
+// Marshal returns the wire-format encoding of m.
+func Marshal(m Message) ([]byte, error) {
+	b, err := marshalAppend(nil, m, false)
+	if b == nil {
+		b = zeroBytes
+	}
+	return b, err
+}
+
+var zeroBytes = make([]byte, 0, 0)
+
+func marshalAppend(buf []byte, m Message, deterministic bool) ([]byte, error) {
+	if m == nil {
+		return nil, ErrNil
+	}
+	mi := MessageV2(m)
+	nbuf, err := protoV2.MarshalOptions{
+		Deterministic: deterministic,
+		AllowPartial:  true,
+	}.MarshalAppend(buf, mi)
+	if err != nil {
+		return buf, err
+	}
+	if len(buf) == len(nbuf) {
+		if !mi.ProtoReflect().IsValid() {
+			return buf, ErrNil
+		}
+	}
+	return nbuf, checkRequiredNotSet(mi)
+}
+
+// Unmarshal parses a wire-format message in b and places the decoded results in m.
+//
+// Unmarshal resets m before starting to unmarshal, so any existing data in m is always
+// removed. Use UnmarshalMerge to preserve and append to existing data.
+func Unmarshal(b []byte, m Message) error {
+	m.Reset()
+	return UnmarshalMerge(b, m)
+}
+
+// UnmarshalMerge parses a wire-format message in b and places the decoded results in m.
+func UnmarshalMerge(b []byte, m Message) error {
+	mi := MessageV2(m)
+	out, err := protoV2.UnmarshalOptions{
+		AllowPartial: true,
+		Merge:        true,
+	}.UnmarshalState(protoiface.UnmarshalInput{
+		Buf:     b,
+		Message: mi.ProtoReflect(),
+	})
+	if err != nil {
+		return err
+	}
+	if out.Flags&protoiface.UnmarshalInitialized > 0 {
+		return nil
+	}
+	return checkRequiredNotSet(mi)
+}
diff --git a/vendor/github.com/golang/protobuf/proto/wrappers.go b/vendor/github.com/golang/protobuf/proto/wrappers.go
new file mode 100644
index 000000000..398e34859
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/wrappers.go
@@ -0,0 +1,34 @@
+// Copyright 2019 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 proto
+
+// Bool stores v in a new bool value and returns a pointer to it.
+func Bool(v bool) *bool { return &v }
+
+// Int stores v in a new int32 value and returns a pointer to it.
+//
+// Deprecated: Use Int32 instead.
+func Int(v int) *int32 { return Int32(int32(v)) }
+
+// Int32 stores v in a new int32 value and returns a pointer to it.
+func Int32(v int32) *int32 { return &v }
+
+// Int64 stores v in a new int64 value and returns a pointer to it.
+func Int64(v int64) *int64 { return &v }
+
+// Uint32 stores v in a new uint32 value and returns a pointer to it.
+func Uint32(v uint32) *uint32 { return &v }
+
+// Uint64 stores v in a new uint64 value and returns a pointer to it.
+func Uint64(v uint64) *uint64 { return &v }
+
+// Float32 stores v in a new float32 value and returns a pointer to it.
+func Float32(v float32) *float32 { return &v }
+
+// Float64 stores v in a new float64 value and returns a pointer to it.
+func Float64(v float64) *float64 { return &v }
+
+// String stores v in a new string value and returns a pointer to it.
+func String(v string) *string { return &v }
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/Makefile b/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/Makefile
deleted file mode 100644
index 41a2d04d0..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/Makefile
+++ /dev/null
@@ -1,36 +0,0 @@
-# Go support for Protocol Buffers - Google's data interchange format
-#
-# Copyright 2010 The Go Authors.  All rights reserved.
-# https://github.com/golang/protobuf
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-#     * Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above
-# copyright notice, this list of conditions and the following disclaimer
-# in the documentation and/or other materials provided with the
-# distribution.
-#     * Neither the name of Google Inc. nor the names of its
-# contributors may be used to endorse or promote products derived from
-# this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-# Not stored here, but descriptor.proto is in https://github.com/google/protobuf/
-# at src/google/protobuf/descriptor.proto
-regenerate:
-	@echo WARNING! THIS RULE IS PROBABLY NOT RIGHT FOR YOUR INSTALLATION
-	protoc --go_out=../../../../.. -I$(HOME)/src/protobuf/include $(HOME)/src/protobuf/include/google/protobuf/descriptor.proto
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.pb.go b/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.pb.go
index e855b1f5c..63dc05785 100644
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.pb.go
+++ b/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.pb.go
@@ -1,2812 +1,200 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
-// source: google/protobuf/descriptor.proto
+// source: github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.proto
 
-package descriptor // import "github.com/golang/protobuf/protoc-gen-go/descriptor"
+package descriptor
 
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-type FieldDescriptorProto_Type int32
-
-const (
-	// 0 is reserved for errors.
-	// Order is weird for historical reasons.
-	FieldDescriptorProto_TYPE_DOUBLE FieldDescriptorProto_Type = 1
-	FieldDescriptorProto_TYPE_FLOAT  FieldDescriptorProto_Type = 2
-	// Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT64 if
-	// negative values are likely.
-	FieldDescriptorProto_TYPE_INT64  FieldDescriptorProto_Type = 3
-	FieldDescriptorProto_TYPE_UINT64 FieldDescriptorProto_Type = 4
-	// Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT32 if
-	// negative values are likely.
-	FieldDescriptorProto_TYPE_INT32   FieldDescriptorProto_Type = 5
-	FieldDescriptorProto_TYPE_FIXED64 FieldDescriptorProto_Type = 6
-	FieldDescriptorProto_TYPE_FIXED32 FieldDescriptorProto_Type = 7
-	FieldDescriptorProto_TYPE_BOOL    FieldDescriptorProto_Type = 8
-	FieldDescriptorProto_TYPE_STRING  FieldDescriptorProto_Type = 9
-	// Tag-delimited aggregate.
-	// Group type is deprecated and not supported in proto3. However, Proto3
-	// implementations should still be able to parse the group wire format and
-	// treat group fields as unknown fields.
-	FieldDescriptorProto_TYPE_GROUP   FieldDescriptorProto_Type = 10
-	FieldDescriptorProto_TYPE_MESSAGE FieldDescriptorProto_Type = 11
-	// New in version 2.
-	FieldDescriptorProto_TYPE_BYTES    FieldDescriptorProto_Type = 12
-	FieldDescriptorProto_TYPE_UINT32   FieldDescriptorProto_Type = 13
-	FieldDescriptorProto_TYPE_ENUM     FieldDescriptorProto_Type = 14
-	FieldDescriptorProto_TYPE_SFIXED32 FieldDescriptorProto_Type = 15
-	FieldDescriptorProto_TYPE_SFIXED64 FieldDescriptorProto_Type = 16
-	FieldDescriptorProto_TYPE_SINT32   FieldDescriptorProto_Type = 17
-	FieldDescriptorProto_TYPE_SINT64   FieldDescriptorProto_Type = 18
-)
-
-var FieldDescriptorProto_Type_name = map[int32]string{
-	1:  "TYPE_DOUBLE",
-	2:  "TYPE_FLOAT",
-	3:  "TYPE_INT64",
-	4:  "TYPE_UINT64",
-	5:  "TYPE_INT32",
-	6:  "TYPE_FIXED64",
-	7:  "TYPE_FIXED32",
-	8:  "TYPE_BOOL",
-	9:  "TYPE_STRING",
-	10: "TYPE_GROUP",
-	11: "TYPE_MESSAGE",
-	12: "TYPE_BYTES",
-	13: "TYPE_UINT32",
-	14: "TYPE_ENUM",
-	15: "TYPE_SFIXED32",
-	16: "TYPE_SFIXED64",
-	17: "TYPE_SINT32",
-	18: "TYPE_SINT64",
-}
-var FieldDescriptorProto_Type_value = map[string]int32{
-	"TYPE_DOUBLE":   1,
-	"TYPE_FLOAT":    2,
-	"TYPE_INT64":    3,
-	"TYPE_UINT64":   4,
-	"TYPE_INT32":    5,
-	"TYPE_FIXED64":  6,
-	"TYPE_FIXED32":  7,
-	"TYPE_BOOL":     8,
-	"TYPE_STRING":   9,
-	"TYPE_GROUP":    10,
-	"TYPE_MESSAGE":  11,
-	"TYPE_BYTES":    12,
-	"TYPE_UINT32":   13,
-	"TYPE_ENUM":     14,
-	"TYPE_SFIXED32": 15,
-	"TYPE_SFIXED64": 16,
-	"TYPE_SINT32":   17,
-	"TYPE_SINT64":   18,
-}
-
-func (x FieldDescriptorProto_Type) Enum() *FieldDescriptorProto_Type {
-	p := new(FieldDescriptorProto_Type)
-	*p = x
-	return p
-}
-func (x FieldDescriptorProto_Type) String() string {
-	return proto.EnumName(FieldDescriptorProto_Type_name, int32(x))
-}
-func (x *FieldDescriptorProto_Type) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(FieldDescriptorProto_Type_value, data, "FieldDescriptorProto_Type")
-	if err != nil {
-		return err
-	}
-	*x = FieldDescriptorProto_Type(value)
-	return nil
-}
-func (FieldDescriptorProto_Type) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{4, 0}
-}
-
-type FieldDescriptorProto_Label int32
-
-const (
-	// 0 is reserved for errors
-	FieldDescriptorProto_LABEL_OPTIONAL FieldDescriptorProto_Label = 1
-	FieldDescriptorProto_LABEL_REQUIRED FieldDescriptorProto_Label = 2
-	FieldDescriptorProto_LABEL_REPEATED FieldDescriptorProto_Label = 3
-)
-
-var FieldDescriptorProto_Label_name = map[int32]string{
-	1: "LABEL_OPTIONAL",
-	2: "LABEL_REQUIRED",
-	3: "LABEL_REPEATED",
-}
-var FieldDescriptorProto_Label_value = map[string]int32{
-	"LABEL_OPTIONAL": 1,
-	"LABEL_REQUIRED": 2,
-	"LABEL_REPEATED": 3,
-}
-
-func (x FieldDescriptorProto_Label) Enum() *FieldDescriptorProto_Label {
-	p := new(FieldDescriptorProto_Label)
-	*p = x
-	return p
-}
-func (x FieldDescriptorProto_Label) String() string {
-	return proto.EnumName(FieldDescriptorProto_Label_name, int32(x))
-}
-func (x *FieldDescriptorProto_Label) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(FieldDescriptorProto_Label_value, data, "FieldDescriptorProto_Label")
-	if err != nil {
-		return err
-	}
-	*x = FieldDescriptorProto_Label(value)
-	return nil
-}
-func (FieldDescriptorProto_Label) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{4, 1}
-}
-
-// Generated classes can be optimized for speed or code size.
-type FileOptions_OptimizeMode int32
-
-const (
-	FileOptions_SPEED FileOptions_OptimizeMode = 1
-	// etc.
-	FileOptions_CODE_SIZE    FileOptions_OptimizeMode = 2
-	FileOptions_LITE_RUNTIME FileOptions_OptimizeMode = 3
-)
-
-var FileOptions_OptimizeMode_name = map[int32]string{
-	1: "SPEED",
-	2: "CODE_SIZE",
-	3: "LITE_RUNTIME",
-}
-var FileOptions_OptimizeMode_value = map[string]int32{
-	"SPEED":        1,
-	"CODE_SIZE":    2,
-	"LITE_RUNTIME": 3,
-}
-
-func (x FileOptions_OptimizeMode) Enum() *FileOptions_OptimizeMode {
-	p := new(FileOptions_OptimizeMode)
-	*p = x
-	return p
-}
-func (x FileOptions_OptimizeMode) String() string {
-	return proto.EnumName(FileOptions_OptimizeMode_name, int32(x))
-}
-func (x *FileOptions_OptimizeMode) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(FileOptions_OptimizeMode_value, data, "FileOptions_OptimizeMode")
-	if err != nil {
-		return err
-	}
-	*x = FileOptions_OptimizeMode(value)
-	return nil
-}
-func (FileOptions_OptimizeMode) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{10, 0}
-}
-
-type FieldOptions_CType int32
-
-const (
-	// Default mode.
-	FieldOptions_STRING       FieldOptions_CType = 0
-	FieldOptions_CORD         FieldOptions_CType = 1
-	FieldOptions_STRING_PIECE FieldOptions_CType = 2
-)
-
-var FieldOptions_CType_name = map[int32]string{
-	0: "STRING",
-	1: "CORD",
-	2: "STRING_PIECE",
-}
-var FieldOptions_CType_value = map[string]int32{
-	"STRING":       0,
-	"CORD":         1,
-	"STRING_PIECE": 2,
-}
-
-func (x FieldOptions_CType) Enum() *FieldOptions_CType {
-	p := new(FieldOptions_CType)
-	*p = x
-	return p
-}
-func (x FieldOptions_CType) String() string {
-	return proto.EnumName(FieldOptions_CType_name, int32(x))
-}
-func (x *FieldOptions_CType) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(FieldOptions_CType_value, data, "FieldOptions_CType")
-	if err != nil {
-		return err
-	}
-	*x = FieldOptions_CType(value)
-	return nil
-}
-func (FieldOptions_CType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{12, 0}
-}
-
-type FieldOptions_JSType int32
-
-const (
-	// Use the default type.
-	FieldOptions_JS_NORMAL FieldOptions_JSType = 0
-	// Use JavaScript strings.
-	FieldOptions_JS_STRING FieldOptions_JSType = 1
-	// Use JavaScript numbers.
-	FieldOptions_JS_NUMBER FieldOptions_JSType = 2
-)
-
-var FieldOptions_JSType_name = map[int32]string{
-	0: "JS_NORMAL",
-	1: "JS_STRING",
-	2: "JS_NUMBER",
-}
-var FieldOptions_JSType_value = map[string]int32{
-	"JS_NORMAL": 0,
-	"JS_STRING": 1,
-	"JS_NUMBER": 2,
-}
-
-func (x FieldOptions_JSType) Enum() *FieldOptions_JSType {
-	p := new(FieldOptions_JSType)
-	*p = x
-	return p
-}
-func (x FieldOptions_JSType) String() string {
-	return proto.EnumName(FieldOptions_JSType_name, int32(x))
-}
-func (x *FieldOptions_JSType) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(FieldOptions_JSType_value, data, "FieldOptions_JSType")
-	if err != nil {
-		return err
-	}
-	*x = FieldOptions_JSType(value)
-	return nil
-}
-func (FieldOptions_JSType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{12, 1}
-}
-
-// Is this method side-effect-free (or safe in HTTP parlance), or idempotent,
-// or neither? HTTP based RPC implementation may choose GET verb for safe
-// methods, and PUT verb for idempotent methods instead of the default POST.
-type MethodOptions_IdempotencyLevel int32
-
-const (
-	MethodOptions_IDEMPOTENCY_UNKNOWN MethodOptions_IdempotencyLevel = 0
-	MethodOptions_NO_SIDE_EFFECTS     MethodOptions_IdempotencyLevel = 1
-	MethodOptions_IDEMPOTENT          MethodOptions_IdempotencyLevel = 2
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	descriptorpb "google.golang.org/protobuf/types/descriptorpb"
+	reflect "reflect"
 )
 
-var MethodOptions_IdempotencyLevel_name = map[int32]string{
-	0: "IDEMPOTENCY_UNKNOWN",
-	1: "NO_SIDE_EFFECTS",
-	2: "IDEMPOTENT",
-}
-var MethodOptions_IdempotencyLevel_value = map[string]int32{
-	"IDEMPOTENCY_UNKNOWN": 0,
-	"NO_SIDE_EFFECTS":     1,
-	"IDEMPOTENT":          2,
-}
-
-func (x MethodOptions_IdempotencyLevel) Enum() *MethodOptions_IdempotencyLevel {
-	p := new(MethodOptions_IdempotencyLevel)
-	*p = x
-	return p
-}
-func (x MethodOptions_IdempotencyLevel) String() string {
-	return proto.EnumName(MethodOptions_IdempotencyLevel_name, int32(x))
-}
-func (x *MethodOptions_IdempotencyLevel) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(MethodOptions_IdempotencyLevel_value, data, "MethodOptions_IdempotencyLevel")
-	if err != nil {
-		return err
-	}
-	*x = MethodOptions_IdempotencyLevel(value)
-	return nil
-}
-func (MethodOptions_IdempotencyLevel) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{17, 0}
-}
-
-// The protocol compiler can output a FileDescriptorSet containing the .proto
-// files it parses.
-type FileDescriptorSet struct {
-	File                 []*FileDescriptorProto `protobuf:"bytes,1,rep,name=file" json:"file,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
-	XXX_unrecognized     []byte                 `json:"-"`
-	XXX_sizecache        int32                  `json:"-"`
-}
-
-func (m *FileDescriptorSet) Reset()         { *m = FileDescriptorSet{} }
-func (m *FileDescriptorSet) String() string { return proto.CompactTextString(m) }
-func (*FileDescriptorSet) ProtoMessage()    {}
-func (*FileDescriptorSet) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{0}
-}
-func (m *FileDescriptorSet) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_FileDescriptorSet.Unmarshal(m, b)
-}
-func (m *FileDescriptorSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_FileDescriptorSet.Marshal(b, m, deterministic)
-}
-func (dst *FileDescriptorSet) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_FileDescriptorSet.Merge(dst, src)
-}
-func (m *FileDescriptorSet) XXX_Size() int {
-	return xxx_messageInfo_FileDescriptorSet.Size(m)
-}
-func (m *FileDescriptorSet) XXX_DiscardUnknown() {
-	xxx_messageInfo_FileDescriptorSet.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_FileDescriptorSet proto.InternalMessageInfo
-
-func (m *FileDescriptorSet) GetFile() []*FileDescriptorProto {
-	if m != nil {
-		return m.File
-	}
-	return nil
-}
-
-// Describes a complete .proto file.
-type FileDescriptorProto struct {
-	Name    *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
-	Package *string `protobuf:"bytes,2,opt,name=package" json:"package,omitempty"`
-	// Names of files imported by this file.
-	Dependency []string `protobuf:"bytes,3,rep,name=dependency" json:"dependency,omitempty"`
-	// Indexes of the public imported files in the dependency list above.
-	PublicDependency []int32 `protobuf:"varint,10,rep,name=public_dependency,json=publicDependency" json:"public_dependency,omitempty"`
-	// Indexes of the weak imported files in the dependency list.
-	// For Google-internal migration only. Do not use.
-	WeakDependency []int32 `protobuf:"varint,11,rep,name=weak_dependency,json=weakDependency" json:"weak_dependency,omitempty"`
-	// All top-level definitions in this file.
-	MessageType []*DescriptorProto        `protobuf:"bytes,4,rep,name=message_type,json=messageType" json:"message_type,omitempty"`
-	EnumType    []*EnumDescriptorProto    `protobuf:"bytes,5,rep,name=enum_type,json=enumType" json:"enum_type,omitempty"`
-	Service     []*ServiceDescriptorProto `protobuf:"bytes,6,rep,name=service" json:"service,omitempty"`
-	Extension   []*FieldDescriptorProto   `protobuf:"bytes,7,rep,name=extension" json:"extension,omitempty"`
-	Options     *FileOptions              `protobuf:"bytes,8,opt,name=options" json:"options,omitempty"`
-	// This field contains optional information about the original source code.
-	// You may safely remove this entire field without harming runtime
-	// functionality of the descriptors -- the information is needed only by
-	// development tools.
-	SourceCodeInfo *SourceCodeInfo `protobuf:"bytes,9,opt,name=source_code_info,json=sourceCodeInfo" json:"source_code_info,omitempty"`
-	// The syntax of the proto file.
-	// The supported values are "proto2" and "proto3".
-	Syntax               *string  `protobuf:"bytes,12,opt,name=syntax" json:"syntax,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *FileDescriptorProto) Reset()         { *m = FileDescriptorProto{} }
-func (m *FileDescriptorProto) String() string { return proto.CompactTextString(m) }
-func (*FileDescriptorProto) ProtoMessage()    {}
-func (*FileDescriptorProto) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{1}
-}
-func (m *FileDescriptorProto) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_FileDescriptorProto.Unmarshal(m, b)
-}
-func (m *FileDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_FileDescriptorProto.Marshal(b, m, deterministic)
-}
-func (dst *FileDescriptorProto) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_FileDescriptorProto.Merge(dst, src)
-}
-func (m *FileDescriptorProto) XXX_Size() int {
-	return xxx_messageInfo_FileDescriptorProto.Size(m)
-}
-func (m *FileDescriptorProto) XXX_DiscardUnknown() {
-	xxx_messageInfo_FileDescriptorProto.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_FileDescriptorProto proto.InternalMessageInfo
-
-func (m *FileDescriptorProto) GetName() string {
-	if m != nil && m.Name != nil {
-		return *m.Name
-	}
-	return ""
-}
-
-func (m *FileDescriptorProto) GetPackage() string {
-	if m != nil && m.Package != nil {
-		return *m.Package
-	}
-	return ""
-}
-
-func (m *FileDescriptorProto) GetDependency() []string {
-	if m != nil {
-		return m.Dependency
-	}
-	return nil
-}
-
-func (m *FileDescriptorProto) GetPublicDependency() []int32 {
-	if m != nil {
-		return m.PublicDependency
-	}
-	return nil
-}
-
-func (m *FileDescriptorProto) GetWeakDependency() []int32 {
-	if m != nil {
-		return m.WeakDependency
-	}
-	return nil
-}
-
-func (m *FileDescriptorProto) GetMessageType() []*DescriptorProto {
-	if m != nil {
-		return m.MessageType
-	}
-	return nil
-}
-
-func (m *FileDescriptorProto) GetEnumType() []*EnumDescriptorProto {
-	if m != nil {
-		return m.EnumType
-	}
-	return nil
-}
-
-func (m *FileDescriptorProto) GetService() []*ServiceDescriptorProto {
-	if m != nil {
-		return m.Service
-	}
-	return nil
-}
-
-func (m *FileDescriptorProto) GetExtension() []*FieldDescriptorProto {
-	if m != nil {
-		return m.Extension
-	}
-	return nil
-}
-
-func (m *FileDescriptorProto) GetOptions() *FileOptions {
-	if m != nil {
-		return m.Options
-	}
-	return nil
-}
-
-func (m *FileDescriptorProto) GetSourceCodeInfo() *SourceCodeInfo {
-	if m != nil {
-		return m.SourceCodeInfo
-	}
-	return nil
-}
-
-func (m *FileDescriptorProto) GetSyntax() string {
-	if m != nil && m.Syntax != nil {
-		return *m.Syntax
-	}
-	return ""
-}
-
-// Describes a message type.
-type DescriptorProto struct {
-	Name           *string                           `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
-	Field          []*FieldDescriptorProto           `protobuf:"bytes,2,rep,name=field" json:"field,omitempty"`
-	Extension      []*FieldDescriptorProto           `protobuf:"bytes,6,rep,name=extension" json:"extension,omitempty"`
-	NestedType     []*DescriptorProto                `protobuf:"bytes,3,rep,name=nested_type,json=nestedType" json:"nested_type,omitempty"`
-	EnumType       []*EnumDescriptorProto            `protobuf:"bytes,4,rep,name=enum_type,json=enumType" json:"enum_type,omitempty"`
-	ExtensionRange []*DescriptorProto_ExtensionRange `protobuf:"bytes,5,rep,name=extension_range,json=extensionRange" json:"extension_range,omitempty"`
-	OneofDecl      []*OneofDescriptorProto           `protobuf:"bytes,8,rep,name=oneof_decl,json=oneofDecl" json:"oneof_decl,omitempty"`
-	Options        *MessageOptions                   `protobuf:"bytes,7,opt,name=options" json:"options,omitempty"`
-	ReservedRange  []*DescriptorProto_ReservedRange  `protobuf:"bytes,9,rep,name=reserved_range,json=reservedRange" json:"reserved_range,omitempty"`
-	// Reserved field names, which may not be used by fields in the same message.
-	// A given name may only be reserved once.
-	ReservedName         []string `protobuf:"bytes,10,rep,name=reserved_name,json=reservedName" json:"reserved_name,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *DescriptorProto) Reset()         { *m = DescriptorProto{} }
-func (m *DescriptorProto) String() string { return proto.CompactTextString(m) }
-func (*DescriptorProto) ProtoMessage()    {}
-func (*DescriptorProto) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{2}
-}
-func (m *DescriptorProto) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_DescriptorProto.Unmarshal(m, b)
-}
-func (m *DescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_DescriptorProto.Marshal(b, m, deterministic)
-}
-func (dst *DescriptorProto) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_DescriptorProto.Merge(dst, src)
-}
-func (m *DescriptorProto) XXX_Size() int {
-	return xxx_messageInfo_DescriptorProto.Size(m)
-}
-func (m *DescriptorProto) XXX_DiscardUnknown() {
-	xxx_messageInfo_DescriptorProto.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_DescriptorProto proto.InternalMessageInfo
-
-func (m *DescriptorProto) GetName() string {
-	if m != nil && m.Name != nil {
-		return *m.Name
-	}
-	return ""
-}
-
-func (m *DescriptorProto) GetField() []*FieldDescriptorProto {
-	if m != nil {
-		return m.Field
-	}
-	return nil
-}
-
-func (m *DescriptorProto) GetExtension() []*FieldDescriptorProto {
-	if m != nil {
-		return m.Extension
-	}
-	return nil
-}
-
-func (m *DescriptorProto) GetNestedType() []*DescriptorProto {
-	if m != nil {
-		return m.NestedType
-	}
-	return nil
-}
-
-func (m *DescriptorProto) GetEnumType() []*EnumDescriptorProto {
-	if m != nil {
-		return m.EnumType
-	}
-	return nil
-}
-
-func (m *DescriptorProto) GetExtensionRange() []*DescriptorProto_ExtensionRange {
-	if m != nil {
-		return m.ExtensionRange
-	}
-	return nil
-}
-
-func (m *DescriptorProto) GetOneofDecl() []*OneofDescriptorProto {
-	if m != nil {
-		return m.OneofDecl
-	}
-	return nil
-}
-
-func (m *DescriptorProto) GetOptions() *MessageOptions {
-	if m != nil {
-		return m.Options
-	}
-	return nil
-}
-
-func (m *DescriptorProto) GetReservedRange() []*DescriptorProto_ReservedRange {
-	if m != nil {
-		return m.ReservedRange
-	}
-	return nil
-}
-
-func (m *DescriptorProto) GetReservedName() []string {
-	if m != nil {
-		return m.ReservedName
-	}
-	return nil
-}
-
-type DescriptorProto_ExtensionRange struct {
-	Start                *int32                 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"`
-	End                  *int32                 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"`
-	Options              *ExtensionRangeOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
-	XXX_unrecognized     []byte                 `json:"-"`
-	XXX_sizecache        int32                  `json:"-"`
-}
-
-func (m *DescriptorProto_ExtensionRange) Reset()         { *m = DescriptorProto_ExtensionRange{} }
-func (m *DescriptorProto_ExtensionRange) String() string { return proto.CompactTextString(m) }
-func (*DescriptorProto_ExtensionRange) ProtoMessage()    {}
-func (*DescriptorProto_ExtensionRange) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{2, 0}
-}
-func (m *DescriptorProto_ExtensionRange) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_DescriptorProto_ExtensionRange.Unmarshal(m, b)
-}
-func (m *DescriptorProto_ExtensionRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_DescriptorProto_ExtensionRange.Marshal(b, m, deterministic)
-}
-func (dst *DescriptorProto_ExtensionRange) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_DescriptorProto_ExtensionRange.Merge(dst, src)
-}
-func (m *DescriptorProto_ExtensionRange) XXX_Size() int {
-	return xxx_messageInfo_DescriptorProto_ExtensionRange.Size(m)
-}
-func (m *DescriptorProto_ExtensionRange) XXX_DiscardUnknown() {
-	xxx_messageInfo_DescriptorProto_ExtensionRange.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_DescriptorProto_ExtensionRange proto.InternalMessageInfo
-
-func (m *DescriptorProto_ExtensionRange) GetStart() int32 {
-	if m != nil && m.Start != nil {
-		return *m.Start
-	}
-	return 0
-}
-
-func (m *DescriptorProto_ExtensionRange) GetEnd() int32 {
-	if m != nil && m.End != nil {
-		return *m.End
-	}
-	return 0
-}
-
-func (m *DescriptorProto_ExtensionRange) GetOptions() *ExtensionRangeOptions {
-	if m != nil {
-		return m.Options
-	}
-	return nil
-}
-
-// Range of reserved tag numbers. Reserved tag numbers may not be used by
-// fields or extension ranges in the same message. Reserved ranges may
-// not overlap.
-type DescriptorProto_ReservedRange struct {
-	Start                *int32   `protobuf:"varint,1,opt,name=start" json:"start,omitempty"`
-	End                  *int32   `protobuf:"varint,2,opt,name=end" json:"end,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *DescriptorProto_ReservedRange) Reset()         { *m = DescriptorProto_ReservedRange{} }
-func (m *DescriptorProto_ReservedRange) String() string { return proto.CompactTextString(m) }
-func (*DescriptorProto_ReservedRange) ProtoMessage()    {}
-func (*DescriptorProto_ReservedRange) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{2, 1}
-}
-func (m *DescriptorProto_ReservedRange) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_DescriptorProto_ReservedRange.Unmarshal(m, b)
-}
-func (m *DescriptorProto_ReservedRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_DescriptorProto_ReservedRange.Marshal(b, m, deterministic)
-}
-func (dst *DescriptorProto_ReservedRange) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_DescriptorProto_ReservedRange.Merge(dst, src)
-}
-func (m *DescriptorProto_ReservedRange) XXX_Size() int {
-	return xxx_messageInfo_DescriptorProto_ReservedRange.Size(m)
-}
-func (m *DescriptorProto_ReservedRange) XXX_DiscardUnknown() {
-	xxx_messageInfo_DescriptorProto_ReservedRange.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_DescriptorProto_ReservedRange proto.InternalMessageInfo
-
-func (m *DescriptorProto_ReservedRange) GetStart() int32 {
-	if m != nil && m.Start != nil {
-		return *m.Start
-	}
-	return 0
-}
-
-func (m *DescriptorProto_ReservedRange) GetEnd() int32 {
-	if m != nil && m.End != nil {
-		return *m.End
-	}
-	return 0
-}
-
-type ExtensionRangeOptions struct {
-	// The parser stores options it doesn't recognize here. See above.
-	UninterpretedOption          []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-	XXX_NoUnkeyedLiteral         struct{}               `json:"-"`
-	proto.XXX_InternalExtensions `json:"-"`
-	XXX_unrecognized             []byte `json:"-"`
-	XXX_sizecache                int32  `json:"-"`
-}
-
-func (m *ExtensionRangeOptions) Reset()         { *m = ExtensionRangeOptions{} }
-func (m *ExtensionRangeOptions) String() string { return proto.CompactTextString(m) }
-func (*ExtensionRangeOptions) ProtoMessage()    {}
-func (*ExtensionRangeOptions) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{3}
-}
-
-var extRange_ExtensionRangeOptions = []proto.ExtensionRange{
-	{Start: 1000, End: 536870911},
-}
-
-func (*ExtensionRangeOptions) ExtensionRangeArray() []proto.ExtensionRange {
-	return extRange_ExtensionRangeOptions
-}
-func (m *ExtensionRangeOptions) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ExtensionRangeOptions.Unmarshal(m, b)
-}
-func (m *ExtensionRangeOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ExtensionRangeOptions.Marshal(b, m, deterministic)
-}
-func (dst *ExtensionRangeOptions) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ExtensionRangeOptions.Merge(dst, src)
-}
-func (m *ExtensionRangeOptions) XXX_Size() int {
-	return xxx_messageInfo_ExtensionRangeOptions.Size(m)
-}
-func (m *ExtensionRangeOptions) XXX_DiscardUnknown() {
-	xxx_messageInfo_ExtensionRangeOptions.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ExtensionRangeOptions proto.InternalMessageInfo
+// Symbols defined in public import of google/protobuf/descriptor.proto.
 
-func (m *ExtensionRangeOptions) GetUninterpretedOption() []*UninterpretedOption {
-	if m != nil {
-		return m.UninterpretedOption
-	}
-	return nil
-}
+type FieldDescriptorProto_Type = descriptorpb.FieldDescriptorProto_Type
 
-// Describes a field within a message.
-type FieldDescriptorProto struct {
-	Name   *string                     `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
-	Number *int32                      `protobuf:"varint,3,opt,name=number" json:"number,omitempty"`
-	Label  *FieldDescriptorProto_Label `protobuf:"varint,4,opt,name=label,enum=google.protobuf.FieldDescriptorProto_Label" json:"label,omitempty"`
-	// If type_name is set, this need not be set.  If both this and type_name
-	// are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.
-	Type *FieldDescriptorProto_Type `protobuf:"varint,5,opt,name=type,enum=google.protobuf.FieldDescriptorProto_Type" json:"type,omitempty"`
-	// For message and enum types, this is the name of the type.  If the name
-	// starts with a '.', it is fully-qualified.  Otherwise, C++-like scoping
-	// rules are used to find the type (i.e. first the nested types within this
-	// message are searched, then within the parent, on up to the root
-	// namespace).
-	TypeName *string `protobuf:"bytes,6,opt,name=type_name,json=typeName" json:"type_name,omitempty"`
-	// For extensions, this is the name of the type being extended.  It is
-	// resolved in the same manner as type_name.
-	Extendee *string `protobuf:"bytes,2,opt,name=extendee" json:"extendee,omitempty"`
-	// For numeric types, contains the original text representation of the value.
-	// For booleans, "true" or "false".
-	// For strings, contains the default text contents (not escaped in any way).
-	// For bytes, contains the C escaped value.  All bytes >= 128 are escaped.
-	// TODO(kenton):  Base-64 encode?
-	DefaultValue *string `protobuf:"bytes,7,opt,name=default_value,json=defaultValue" json:"default_value,omitempty"`
-	// If set, gives the index of a oneof in the containing type's oneof_decl
-	// list.  This field is a member of that oneof.
-	OneofIndex *int32 `protobuf:"varint,9,opt,name=oneof_index,json=oneofIndex" json:"oneof_index,omitempty"`
-	// JSON name of this field. The value is set by protocol compiler. If the
-	// user has set a "json_name" option on this field, that option's value
-	// will be used. Otherwise, it's deduced from the field's name by converting
-	// it to camelCase.
-	JsonName             *string       `protobuf:"bytes,10,opt,name=json_name,json=jsonName" json:"json_name,omitempty"`
-	Options              *FieldOptions `protobuf:"bytes,8,opt,name=options" json:"options,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
-	XXX_unrecognized     []byte        `json:"-"`
-	XXX_sizecache        int32         `json:"-"`
-}
+const FieldDescriptorProto_TYPE_DOUBLE = descriptorpb.FieldDescriptorProto_TYPE_DOUBLE
+const FieldDescriptorProto_TYPE_FLOAT = descriptorpb.FieldDescriptorProto_TYPE_FLOAT
+const FieldDescriptorProto_TYPE_INT64 = descriptorpb.FieldDescriptorProto_TYPE_INT64
+const FieldDescriptorProto_TYPE_UINT64 = descriptorpb.FieldDescriptorProto_TYPE_UINT64
+const FieldDescriptorProto_TYPE_INT32 = descriptorpb.FieldDescriptorProto_TYPE_INT32
+const FieldDescriptorProto_TYPE_FIXED64 = descriptorpb.FieldDescriptorProto_TYPE_FIXED64
+const FieldDescriptorProto_TYPE_FIXED32 = descriptorpb.FieldDescriptorProto_TYPE_FIXED32
+const FieldDescriptorProto_TYPE_BOOL = descriptorpb.FieldDescriptorProto_TYPE_BOOL
+const FieldDescriptorProto_TYPE_STRING = descriptorpb.FieldDescriptorProto_TYPE_STRING
+const FieldDescriptorProto_TYPE_GROUP = descriptorpb.FieldDescriptorProto_TYPE_GROUP
+const FieldDescriptorProto_TYPE_MESSAGE = descriptorpb.FieldDescriptorProto_TYPE_MESSAGE
+const FieldDescriptorProto_TYPE_BYTES = descriptorpb.FieldDescriptorProto_TYPE_BYTES
+const FieldDescriptorProto_TYPE_UINT32 = descriptorpb.FieldDescriptorProto_TYPE_UINT32
+const FieldDescriptorProto_TYPE_ENUM = descriptorpb.FieldDescriptorProto_TYPE_ENUM
+const FieldDescriptorProto_TYPE_SFIXED32 = descriptorpb.FieldDescriptorProto_TYPE_SFIXED32
+const FieldDescriptorProto_TYPE_SFIXED64 = descriptorpb.FieldDescriptorProto_TYPE_SFIXED64
+const FieldDescriptorProto_TYPE_SINT32 = descriptorpb.FieldDescriptorProto_TYPE_SINT32
+const FieldDescriptorProto_TYPE_SINT64 = descriptorpb.FieldDescriptorProto_TYPE_SINT64
 
-func (m *FieldDescriptorProto) Reset()         { *m = FieldDescriptorProto{} }
-func (m *FieldDescriptorProto) String() string { return proto.CompactTextString(m) }
-func (*FieldDescriptorProto) ProtoMessage()    {}
-func (*FieldDescriptorProto) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{4}
-}
-func (m *FieldDescriptorProto) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_FieldDescriptorProto.Unmarshal(m, b)
-}
-func (m *FieldDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_FieldDescriptorProto.Marshal(b, m, deterministic)
-}
-func (dst *FieldDescriptorProto) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_FieldDescriptorProto.Merge(dst, src)
-}
-func (m *FieldDescriptorProto) XXX_Size() int {
-	return xxx_messageInfo_FieldDescriptorProto.Size(m)
-}
-func (m *FieldDescriptorProto) XXX_DiscardUnknown() {
-	xxx_messageInfo_FieldDescriptorProto.DiscardUnknown(m)
-}
+var FieldDescriptorProto_Type_name = descriptorpb.FieldDescriptorProto_Type_name
+var FieldDescriptorProto_Type_value = descriptorpb.FieldDescriptorProto_Type_value
 
-var xxx_messageInfo_FieldDescriptorProto proto.InternalMessageInfo
+type FieldDescriptorProto_Label = descriptorpb.FieldDescriptorProto_Label
 
-func (m *FieldDescriptorProto) GetName() string {
-	if m != nil && m.Name != nil {
-		return *m.Name
-	}
-	return ""
-}
+const FieldDescriptorProto_LABEL_OPTIONAL = descriptorpb.FieldDescriptorProto_LABEL_OPTIONAL
+const FieldDescriptorProto_LABEL_REQUIRED = descriptorpb.FieldDescriptorProto_LABEL_REQUIRED
+const FieldDescriptorProto_LABEL_REPEATED = descriptorpb.FieldDescriptorProto_LABEL_REPEATED
 
-func (m *FieldDescriptorProto) GetNumber() int32 {
-	if m != nil && m.Number != nil {
-		return *m.Number
-	}
-	return 0
-}
+var FieldDescriptorProto_Label_name = descriptorpb.FieldDescriptorProto_Label_name
+var FieldDescriptorProto_Label_value = descriptorpb.FieldDescriptorProto_Label_value
 
-func (m *FieldDescriptorProto) GetLabel() FieldDescriptorProto_Label {
-	if m != nil && m.Label != nil {
-		return *m.Label
-	}
-	return FieldDescriptorProto_LABEL_OPTIONAL
-}
+type FileOptions_OptimizeMode = descriptorpb.FileOptions_OptimizeMode
 
-func (m *FieldDescriptorProto) GetType() FieldDescriptorProto_Type {
-	if m != nil && m.Type != nil {
-		return *m.Type
-	}
-	return FieldDescriptorProto_TYPE_DOUBLE
-}
+const FileOptions_SPEED = descriptorpb.FileOptions_SPEED
+const FileOptions_CODE_SIZE = descriptorpb.FileOptions_CODE_SIZE
+const FileOptions_LITE_RUNTIME = descriptorpb.FileOptions_LITE_RUNTIME
 
-func (m *FieldDescriptorProto) GetTypeName() string {
-	if m != nil && m.TypeName != nil {
-		return *m.TypeName
-	}
-	return ""
-}
+var FileOptions_OptimizeMode_name = descriptorpb.FileOptions_OptimizeMode_name
+var FileOptions_OptimizeMode_value = descriptorpb.FileOptions_OptimizeMode_value
 
-func (m *FieldDescriptorProto) GetExtendee() string {
-	if m != nil && m.Extendee != nil {
-		return *m.Extendee
-	}
-	return ""
-}
+type FieldOptions_CType = descriptorpb.FieldOptions_CType
 
-func (m *FieldDescriptorProto) GetDefaultValue() string {
-	if m != nil && m.DefaultValue != nil {
-		return *m.DefaultValue
-	}
-	return ""
-}
+const FieldOptions_STRING = descriptorpb.FieldOptions_STRING
+const FieldOptions_CORD = descriptorpb.FieldOptions_CORD
+const FieldOptions_STRING_PIECE = descriptorpb.FieldOptions_STRING_PIECE
 
-func (m *FieldDescriptorProto) GetOneofIndex() int32 {
-	if m != nil && m.OneofIndex != nil {
-		return *m.OneofIndex
-	}
-	return 0
-}
+var FieldOptions_CType_name = descriptorpb.FieldOptions_CType_name
+var FieldOptions_CType_value = descriptorpb.FieldOptions_CType_value
 
-func (m *FieldDescriptorProto) GetJsonName() string {
-	if m != nil && m.JsonName != nil {
-		return *m.JsonName
-	}
-	return ""
-}
+type FieldOptions_JSType = descriptorpb.FieldOptions_JSType
 
-func (m *FieldDescriptorProto) GetOptions() *FieldOptions {
-	if m != nil {
-		return m.Options
-	}
-	return nil
-}
+const FieldOptions_JS_NORMAL = descriptorpb.FieldOptions_JS_NORMAL
+const FieldOptions_JS_STRING = descriptorpb.FieldOptions_JS_STRING
+const FieldOptions_JS_NUMBER = descriptorpb.FieldOptions_JS_NUMBER
 
-// Describes a oneof.
-type OneofDescriptorProto struct {
-	Name                 *string       `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
-	Options              *OneofOptions `protobuf:"bytes,2,opt,name=options" json:"options,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
-	XXX_unrecognized     []byte        `json:"-"`
-	XXX_sizecache        int32         `json:"-"`
-}
+var FieldOptions_JSType_name = descriptorpb.FieldOptions_JSType_name
+var FieldOptions_JSType_value = descriptorpb.FieldOptions_JSType_value
 
-func (m *OneofDescriptorProto) Reset()         { *m = OneofDescriptorProto{} }
-func (m *OneofDescriptorProto) String() string { return proto.CompactTextString(m) }
-func (*OneofDescriptorProto) ProtoMessage()    {}
-func (*OneofDescriptorProto) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{5}
-}
-func (m *OneofDescriptorProto) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_OneofDescriptorProto.Unmarshal(m, b)
-}
-func (m *OneofDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_OneofDescriptorProto.Marshal(b, m, deterministic)
-}
-func (dst *OneofDescriptorProto) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_OneofDescriptorProto.Merge(dst, src)
-}
-func (m *OneofDescriptorProto) XXX_Size() int {
-	return xxx_messageInfo_OneofDescriptorProto.Size(m)
-}
-func (m *OneofDescriptorProto) XXX_DiscardUnknown() {
-	xxx_messageInfo_OneofDescriptorProto.DiscardUnknown(m)
-}
+type MethodOptions_IdempotencyLevel = descriptorpb.MethodOptions_IdempotencyLevel
 
-var xxx_messageInfo_OneofDescriptorProto proto.InternalMessageInfo
+const MethodOptions_IDEMPOTENCY_UNKNOWN = descriptorpb.MethodOptions_IDEMPOTENCY_UNKNOWN
+const MethodOptions_NO_SIDE_EFFECTS = descriptorpb.MethodOptions_NO_SIDE_EFFECTS
+const MethodOptions_IDEMPOTENT = descriptorpb.MethodOptions_IDEMPOTENT
 
-func (m *OneofDescriptorProto) GetName() string {
-	if m != nil && m.Name != nil {
-		return *m.Name
-	}
-	return ""
-}
-
-func (m *OneofDescriptorProto) GetOptions() *OneofOptions {
-	if m != nil {
-		return m.Options
-	}
-	return nil
-}
-
-// Describes an enum type.
-type EnumDescriptorProto struct {
-	Name    *string                     `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
-	Value   []*EnumValueDescriptorProto `protobuf:"bytes,2,rep,name=value" json:"value,omitempty"`
-	Options *EnumOptions                `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
-	// Range of reserved numeric values. Reserved numeric values may not be used
-	// by enum values in the same enum declaration. Reserved ranges may not
-	// overlap.
-	ReservedRange []*EnumDescriptorProto_EnumReservedRange `protobuf:"bytes,4,rep,name=reserved_range,json=reservedRange" json:"reserved_range,omitempty"`
-	// Reserved enum value names, which may not be reused. A given name may only
-	// be reserved once.
-	ReservedName         []string `protobuf:"bytes,5,rep,name=reserved_name,json=reservedName" json:"reserved_name,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *EnumDescriptorProto) Reset()         { *m = EnumDescriptorProto{} }
-func (m *EnumDescriptorProto) String() string { return proto.CompactTextString(m) }
-func (*EnumDescriptorProto) ProtoMessage()    {}
-func (*EnumDescriptorProto) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{6}
-}
-func (m *EnumDescriptorProto) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_EnumDescriptorProto.Unmarshal(m, b)
-}
-func (m *EnumDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_EnumDescriptorProto.Marshal(b, m, deterministic)
-}
-func (dst *EnumDescriptorProto) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_EnumDescriptorProto.Merge(dst, src)
-}
-func (m *EnumDescriptorProto) XXX_Size() int {
-	return xxx_messageInfo_EnumDescriptorProto.Size(m)
-}
-func (m *EnumDescriptorProto) XXX_DiscardUnknown() {
-	xxx_messageInfo_EnumDescriptorProto.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EnumDescriptorProto proto.InternalMessageInfo
-
-func (m *EnumDescriptorProto) GetName() string {
-	if m != nil && m.Name != nil {
-		return *m.Name
-	}
-	return ""
-}
-
-func (m *EnumDescriptorProto) GetValue() []*EnumValueDescriptorProto {
-	if m != nil {
-		return m.Value
-	}
-	return nil
-}
-
-func (m *EnumDescriptorProto) GetOptions() *EnumOptions {
-	if m != nil {
-		return m.Options
-	}
-	return nil
-}
-
-func (m *EnumDescriptorProto) GetReservedRange() []*EnumDescriptorProto_EnumReservedRange {
-	if m != nil {
-		return m.ReservedRange
-	}
-	return nil
-}
-
-func (m *EnumDescriptorProto) GetReservedName() []string {
-	if m != nil {
-		return m.ReservedName
-	}
-	return nil
-}
-
-// Range of reserved numeric values. Reserved values may not be used by
-// entries in the same enum. Reserved ranges may not overlap.
-//
-// Note that this is distinct from DescriptorProto.ReservedRange in that it
-// is inclusive such that it can appropriately represent the entire int32
-// domain.
-type EnumDescriptorProto_EnumReservedRange struct {
-	Start                *int32   `protobuf:"varint,1,opt,name=start" json:"start,omitempty"`
-	End                  *int32   `protobuf:"varint,2,opt,name=end" json:"end,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *EnumDescriptorProto_EnumReservedRange) Reset()         { *m = EnumDescriptorProto_EnumReservedRange{} }
-func (m *EnumDescriptorProto_EnumReservedRange) String() string { return proto.CompactTextString(m) }
-func (*EnumDescriptorProto_EnumReservedRange) ProtoMessage()    {}
-func (*EnumDescriptorProto_EnumReservedRange) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{6, 0}
-}
-func (m *EnumDescriptorProto_EnumReservedRange) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.Unmarshal(m, b)
-}
-func (m *EnumDescriptorProto_EnumReservedRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.Marshal(b, m, deterministic)
-}
-func (dst *EnumDescriptorProto_EnumReservedRange) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.Merge(dst, src)
-}
-func (m *EnumDescriptorProto_EnumReservedRange) XXX_Size() int {
-	return xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.Size(m)
-}
-func (m *EnumDescriptorProto_EnumReservedRange) XXX_DiscardUnknown() {
-	xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EnumDescriptorProto_EnumReservedRange proto.InternalMessageInfo
-
-func (m *EnumDescriptorProto_EnumReservedRange) GetStart() int32 {
-	if m != nil && m.Start != nil {
-		return *m.Start
-	}
-	return 0
-}
-
-func (m *EnumDescriptorProto_EnumReservedRange) GetEnd() int32 {
-	if m != nil && m.End != nil {
-		return *m.End
-	}
-	return 0
-}
-
-// Describes a value within an enum.
-type EnumValueDescriptorProto struct {
-	Name                 *string           `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
-	Number               *int32            `protobuf:"varint,2,opt,name=number" json:"number,omitempty"`
-	Options              *EnumValueOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
-	XXX_unrecognized     []byte            `json:"-"`
-	XXX_sizecache        int32             `json:"-"`
-}
-
-func (m *EnumValueDescriptorProto) Reset()         { *m = EnumValueDescriptorProto{} }
-func (m *EnumValueDescriptorProto) String() string { return proto.CompactTextString(m) }
-func (*EnumValueDescriptorProto) ProtoMessage()    {}
-func (*EnumValueDescriptorProto) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{7}
-}
-func (m *EnumValueDescriptorProto) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_EnumValueDescriptorProto.Unmarshal(m, b)
-}
-func (m *EnumValueDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_EnumValueDescriptorProto.Marshal(b, m, deterministic)
-}
-func (dst *EnumValueDescriptorProto) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_EnumValueDescriptorProto.Merge(dst, src)
-}
-func (m *EnumValueDescriptorProto) XXX_Size() int {
-	return xxx_messageInfo_EnumValueDescriptorProto.Size(m)
-}
-func (m *EnumValueDescriptorProto) XXX_DiscardUnknown() {
-	xxx_messageInfo_EnumValueDescriptorProto.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EnumValueDescriptorProto proto.InternalMessageInfo
-
-func (m *EnumValueDescriptorProto) GetName() string {
-	if m != nil && m.Name != nil {
-		return *m.Name
-	}
-	return ""
-}
-
-func (m *EnumValueDescriptorProto) GetNumber() int32 {
-	if m != nil && m.Number != nil {
-		return *m.Number
-	}
-	return 0
-}
-
-func (m *EnumValueDescriptorProto) GetOptions() *EnumValueOptions {
-	if m != nil {
-		return m.Options
-	}
-	return nil
-}
-
-// Describes a service.
-type ServiceDescriptorProto struct {
-	Name                 *string                  `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
-	Method               []*MethodDescriptorProto `protobuf:"bytes,2,rep,name=method" json:"method,omitempty"`
-	Options              *ServiceOptions          `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
-	XXX_unrecognized     []byte                   `json:"-"`
-	XXX_sizecache        int32                    `json:"-"`
-}
-
-func (m *ServiceDescriptorProto) Reset()         { *m = ServiceDescriptorProto{} }
-func (m *ServiceDescriptorProto) String() string { return proto.CompactTextString(m) }
-func (*ServiceDescriptorProto) ProtoMessage()    {}
-func (*ServiceDescriptorProto) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{8}
-}
-func (m *ServiceDescriptorProto) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ServiceDescriptorProto.Unmarshal(m, b)
-}
-func (m *ServiceDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ServiceDescriptorProto.Marshal(b, m, deterministic)
-}
-func (dst *ServiceDescriptorProto) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ServiceDescriptorProto.Merge(dst, src)
-}
-func (m *ServiceDescriptorProto) XXX_Size() int {
-	return xxx_messageInfo_ServiceDescriptorProto.Size(m)
-}
-func (m *ServiceDescriptorProto) XXX_DiscardUnknown() {
-	xxx_messageInfo_ServiceDescriptorProto.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ServiceDescriptorProto proto.InternalMessageInfo
-
-func (m *ServiceDescriptorProto) GetName() string {
-	if m != nil && m.Name != nil {
-		return *m.Name
-	}
-	return ""
-}
-
-func (m *ServiceDescriptorProto) GetMethod() []*MethodDescriptorProto {
-	if m != nil {
-		return m.Method
-	}
-	return nil
-}
-
-func (m *ServiceDescriptorProto) GetOptions() *ServiceOptions {
-	if m != nil {
-		return m.Options
-	}
-	return nil
-}
-
-// Describes a method of a service.
-type MethodDescriptorProto struct {
-	Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
-	// Input and output type names.  These are resolved in the same way as
-	// FieldDescriptorProto.type_name, but must refer to a message type.
-	InputType  *string        `protobuf:"bytes,2,opt,name=input_type,json=inputType" json:"input_type,omitempty"`
-	OutputType *string        `protobuf:"bytes,3,opt,name=output_type,json=outputType" json:"output_type,omitempty"`
-	Options    *MethodOptions `protobuf:"bytes,4,opt,name=options" json:"options,omitempty"`
-	// Identifies if client streams multiple client messages
-	ClientStreaming *bool `protobuf:"varint,5,opt,name=client_streaming,json=clientStreaming,def=0" json:"client_streaming,omitempty"`
-	// Identifies if server streams multiple server messages
-	ServerStreaming      *bool    `protobuf:"varint,6,opt,name=server_streaming,json=serverStreaming,def=0" json:"server_streaming,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *MethodDescriptorProto) Reset()         { *m = MethodDescriptorProto{} }
-func (m *MethodDescriptorProto) String() string { return proto.CompactTextString(m) }
-func (*MethodDescriptorProto) ProtoMessage()    {}
-func (*MethodDescriptorProto) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{9}
-}
-func (m *MethodDescriptorProto) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_MethodDescriptorProto.Unmarshal(m, b)
-}
-func (m *MethodDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_MethodDescriptorProto.Marshal(b, m, deterministic)
-}
-func (dst *MethodDescriptorProto) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MethodDescriptorProto.Merge(dst, src)
-}
-func (m *MethodDescriptorProto) XXX_Size() int {
-	return xxx_messageInfo_MethodDescriptorProto.Size(m)
-}
-func (m *MethodDescriptorProto) XXX_DiscardUnknown() {
-	xxx_messageInfo_MethodDescriptorProto.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_MethodDescriptorProto proto.InternalMessageInfo
-
-const Default_MethodDescriptorProto_ClientStreaming bool = false
-const Default_MethodDescriptorProto_ServerStreaming bool = false
-
-func (m *MethodDescriptorProto) GetName() string {
-	if m != nil && m.Name != nil {
-		return *m.Name
-	}
-	return ""
-}
-
-func (m *MethodDescriptorProto) GetInputType() string {
-	if m != nil && m.InputType != nil {
-		return *m.InputType
-	}
-	return ""
-}
-
-func (m *MethodDescriptorProto) GetOutputType() string {
-	if m != nil && m.OutputType != nil {
-		return *m.OutputType
-	}
-	return ""
-}
-
-func (m *MethodDescriptorProto) GetOptions() *MethodOptions {
-	if m != nil {
-		return m.Options
-	}
-	return nil
-}
-
-func (m *MethodDescriptorProto) GetClientStreaming() bool {
-	if m != nil && m.ClientStreaming != nil {
-		return *m.ClientStreaming
-	}
-	return Default_MethodDescriptorProto_ClientStreaming
-}
-
-func (m *MethodDescriptorProto) GetServerStreaming() bool {
-	if m != nil && m.ServerStreaming != nil {
-		return *m.ServerStreaming
-	}
-	return Default_MethodDescriptorProto_ServerStreaming
-}
-
-type FileOptions struct {
-	// Sets the Java package where classes generated from this .proto will be
-	// placed.  By default, the proto package is used, but this is often
-	// inappropriate because proto packages do not normally start with backwards
-	// domain names.
-	JavaPackage *string `protobuf:"bytes,1,opt,name=java_package,json=javaPackage" json:"java_package,omitempty"`
-	// If set, all the classes from the .proto file are wrapped in a single
-	// outer class with the given name.  This applies to both Proto1
-	// (equivalent to the old "--one_java_file" option) and Proto2 (where
-	// a .proto always translates to a single class, but you may want to
-	// explicitly choose the class name).
-	JavaOuterClassname *string `protobuf:"bytes,8,opt,name=java_outer_classname,json=javaOuterClassname" json:"java_outer_classname,omitempty"`
-	// If set true, then the Java code generator will generate a separate .java
-	// file for each top-level message, enum, and service defined in the .proto
-	// file.  Thus, these types will *not* be nested inside the outer class
-	// named by java_outer_classname.  However, the outer class will still be
-	// generated to contain the file's getDescriptor() method as well as any
-	// top-level extensions defined in the file.
-	JavaMultipleFiles *bool `protobuf:"varint,10,opt,name=java_multiple_files,json=javaMultipleFiles,def=0" json:"java_multiple_files,omitempty"`
-	// This option does nothing.
-	JavaGenerateEqualsAndHash *bool `protobuf:"varint,20,opt,name=java_generate_equals_and_hash,json=javaGenerateEqualsAndHash" json:"java_generate_equals_and_hash,omitempty"` // Deprecated: Do not use.
-	// If set true, then the Java2 code generator will generate code that
-	// throws an exception whenever an attempt is made to assign a non-UTF-8
-	// byte sequence to a string field.
-	// Message reflection will do the same.
-	// However, an extension field still accepts non-UTF-8 byte sequences.
-	// This option has no effect on when used with the lite runtime.
-	JavaStringCheckUtf8 *bool                     `protobuf:"varint,27,opt,name=java_string_check_utf8,json=javaStringCheckUtf8,def=0" json:"java_string_check_utf8,omitempty"`
-	OptimizeFor         *FileOptions_OptimizeMode `protobuf:"varint,9,opt,name=optimize_for,json=optimizeFor,enum=google.protobuf.FileOptions_OptimizeMode,def=1" json:"optimize_for,omitempty"`
-	// Sets the Go package where structs generated from this .proto will be
-	// placed. If omitted, the Go package will be derived from the following:
-	//   - The basename of the package import path, if provided.
-	//   - Otherwise, the package statement in the .proto file, if present.
-	//   - Otherwise, the basename of the .proto file, without extension.
-	GoPackage *string `protobuf:"bytes,11,opt,name=go_package,json=goPackage" json:"go_package,omitempty"`
-	// Should generic services be generated in each language?  "Generic" services
-	// are not specific to any particular RPC system.  They are generated by the
-	// main code generators in each language (without additional plugins).
-	// Generic services were the only kind of service generation supported by
-	// early versions of google.protobuf.
-	//
-	// Generic services are now considered deprecated in favor of using plugins
-	// that generate code specific to your particular RPC system.  Therefore,
-	// these default to false.  Old code which depends on generic services should
-	// explicitly set them to true.
-	CcGenericServices   *bool `protobuf:"varint,16,opt,name=cc_generic_services,json=ccGenericServices,def=0" json:"cc_generic_services,omitempty"`
-	JavaGenericServices *bool `protobuf:"varint,17,opt,name=java_generic_services,json=javaGenericServices,def=0" json:"java_generic_services,omitempty"`
-	PyGenericServices   *bool `protobuf:"varint,18,opt,name=py_generic_services,json=pyGenericServices,def=0" json:"py_generic_services,omitempty"`
-	PhpGenericServices  *bool `protobuf:"varint,42,opt,name=php_generic_services,json=phpGenericServices,def=0" json:"php_generic_services,omitempty"`
-	// Is this file deprecated?
-	// Depending on the target platform, this can emit Deprecated annotations
-	// for everything in the file, or it will be completely ignored; in the very
-	// least, this is a formalization for deprecating files.
-	Deprecated *bool `protobuf:"varint,23,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
-	// Enables the use of arenas for the proto messages in this file. This applies
-	// only to generated classes for C++.
-	CcEnableArenas *bool `protobuf:"varint,31,opt,name=cc_enable_arenas,json=ccEnableArenas,def=0" json:"cc_enable_arenas,omitempty"`
-	// Sets the objective c class prefix which is prepended to all objective c
-	// generated classes from this .proto. There is no default.
-	ObjcClassPrefix *string `protobuf:"bytes,36,opt,name=objc_class_prefix,json=objcClassPrefix" json:"objc_class_prefix,omitempty"`
-	// Namespace for generated classes; defaults to the package.
-	CsharpNamespace *string `protobuf:"bytes,37,opt,name=csharp_namespace,json=csharpNamespace" json:"csharp_namespace,omitempty"`
-	// By default Swift generators will take the proto package and CamelCase it
-	// replacing '.' with underscore and use that to prefix the types/symbols
-	// defined. When this options is provided, they will use this value instead
-	// to prefix the types/symbols defined.
-	SwiftPrefix *string `protobuf:"bytes,39,opt,name=swift_prefix,json=swiftPrefix" json:"swift_prefix,omitempty"`
-	// Sets the php class prefix which is prepended to all php generated classes
-	// from this .proto. Default is empty.
-	PhpClassPrefix *string `protobuf:"bytes,40,opt,name=php_class_prefix,json=phpClassPrefix" json:"php_class_prefix,omitempty"`
-	// Use this option to change the namespace of php generated classes. Default
-	// is empty. When this option is empty, the package name will be used for
-	// determining the namespace.
-	PhpNamespace *string `protobuf:"bytes,41,opt,name=php_namespace,json=phpNamespace" json:"php_namespace,omitempty"`
-	// The parser stores options it doesn't recognize here.
-	// See the documentation for the "Options" section above.
-	UninterpretedOption          []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-	XXX_NoUnkeyedLiteral         struct{}               `json:"-"`
-	proto.XXX_InternalExtensions `json:"-"`
-	XXX_unrecognized             []byte `json:"-"`
-	XXX_sizecache                int32  `json:"-"`
-}
-
-func (m *FileOptions) Reset()         { *m = FileOptions{} }
-func (m *FileOptions) String() string { return proto.CompactTextString(m) }
-func (*FileOptions) ProtoMessage()    {}
-func (*FileOptions) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{10}
-}
-
-var extRange_FileOptions = []proto.ExtensionRange{
-	{Start: 1000, End: 536870911},
-}
-
-func (*FileOptions) ExtensionRangeArray() []proto.ExtensionRange {
-	return extRange_FileOptions
-}
-func (m *FileOptions) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_FileOptions.Unmarshal(m, b)
-}
-func (m *FileOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_FileOptions.Marshal(b, m, deterministic)
-}
-func (dst *FileOptions) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_FileOptions.Merge(dst, src)
-}
-func (m *FileOptions) XXX_Size() int {
-	return xxx_messageInfo_FileOptions.Size(m)
-}
-func (m *FileOptions) XXX_DiscardUnknown() {
-	xxx_messageInfo_FileOptions.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_FileOptions proto.InternalMessageInfo
-
-const Default_FileOptions_JavaMultipleFiles bool = false
-const Default_FileOptions_JavaStringCheckUtf8 bool = false
-const Default_FileOptions_OptimizeFor FileOptions_OptimizeMode = FileOptions_SPEED
-const Default_FileOptions_CcGenericServices bool = false
-const Default_FileOptions_JavaGenericServices bool = false
-const Default_FileOptions_PyGenericServices bool = false
-const Default_FileOptions_PhpGenericServices bool = false
-const Default_FileOptions_Deprecated bool = false
-const Default_FileOptions_CcEnableArenas bool = false
-
-func (m *FileOptions) GetJavaPackage() string {
-	if m != nil && m.JavaPackage != nil {
-		return *m.JavaPackage
-	}
-	return ""
-}
-
-func (m *FileOptions) GetJavaOuterClassname() string {
-	if m != nil && m.JavaOuterClassname != nil {
-		return *m.JavaOuterClassname
-	}
-	return ""
-}
-
-func (m *FileOptions) GetJavaMultipleFiles() bool {
-	if m != nil && m.JavaMultipleFiles != nil {
-		return *m.JavaMultipleFiles
-	}
-	return Default_FileOptions_JavaMultipleFiles
-}
-
-// Deprecated: Do not use.
-func (m *FileOptions) GetJavaGenerateEqualsAndHash() bool {
-	if m != nil && m.JavaGenerateEqualsAndHash != nil {
-		return *m.JavaGenerateEqualsAndHash
-	}
-	return false
-}
-
-func (m *FileOptions) GetJavaStringCheckUtf8() bool {
-	if m != nil && m.JavaStringCheckUtf8 != nil {
-		return *m.JavaStringCheckUtf8
-	}
-	return Default_FileOptions_JavaStringCheckUtf8
-}
-
-func (m *FileOptions) GetOptimizeFor() FileOptions_OptimizeMode {
-	if m != nil && m.OptimizeFor != nil {
-		return *m.OptimizeFor
-	}
-	return Default_FileOptions_OptimizeFor
-}
-
-func (m *FileOptions) GetGoPackage() string {
-	if m != nil && m.GoPackage != nil {
-		return *m.GoPackage
-	}
-	return ""
-}
-
-func (m *FileOptions) GetCcGenericServices() bool {
-	if m != nil && m.CcGenericServices != nil {
-		return *m.CcGenericServices
-	}
-	return Default_FileOptions_CcGenericServices
-}
-
-func (m *FileOptions) GetJavaGenericServices() bool {
-	if m != nil && m.JavaGenericServices != nil {
-		return *m.JavaGenericServices
-	}
-	return Default_FileOptions_JavaGenericServices
-}
-
-func (m *FileOptions) GetPyGenericServices() bool {
-	if m != nil && m.PyGenericServices != nil {
-		return *m.PyGenericServices
-	}
-	return Default_FileOptions_PyGenericServices
-}
-
-func (m *FileOptions) GetPhpGenericServices() bool {
-	if m != nil && m.PhpGenericServices != nil {
-		return *m.PhpGenericServices
-	}
-	return Default_FileOptions_PhpGenericServices
-}
-
-func (m *FileOptions) GetDeprecated() bool {
-	if m != nil && m.Deprecated != nil {
-		return *m.Deprecated
-	}
-	return Default_FileOptions_Deprecated
-}
-
-func (m *FileOptions) GetCcEnableArenas() bool {
-	if m != nil && m.CcEnableArenas != nil {
-		return *m.CcEnableArenas
-	}
-	return Default_FileOptions_CcEnableArenas
-}
-
-func (m *FileOptions) GetObjcClassPrefix() string {
-	if m != nil && m.ObjcClassPrefix != nil {
-		return *m.ObjcClassPrefix
-	}
-	return ""
-}
-
-func (m *FileOptions) GetCsharpNamespace() string {
-	if m != nil && m.CsharpNamespace != nil {
-		return *m.CsharpNamespace
-	}
-	return ""
-}
-
-func (m *FileOptions) GetSwiftPrefix() string {
-	if m != nil && m.SwiftPrefix != nil {
-		return *m.SwiftPrefix
-	}
-	return ""
-}
-
-func (m *FileOptions) GetPhpClassPrefix() string {
-	if m != nil && m.PhpClassPrefix != nil {
-		return *m.PhpClassPrefix
-	}
-	return ""
-}
-
-func (m *FileOptions) GetPhpNamespace() string {
-	if m != nil && m.PhpNamespace != nil {
-		return *m.PhpNamespace
-	}
-	return ""
-}
-
-func (m *FileOptions) GetUninterpretedOption() []*UninterpretedOption {
-	if m != nil {
-		return m.UninterpretedOption
-	}
-	return nil
-}
-
-type MessageOptions struct {
-	// Set true to use the old proto1 MessageSet wire format for extensions.
-	// This is provided for backwards-compatibility with the MessageSet wire
-	// format.  You should not use this for any other reason:  It's less
-	// efficient, has fewer features, and is more complicated.
-	//
-	// The message must be defined exactly as follows:
-	//   message Foo {
-	//     option message_set_wire_format = true;
-	//     extensions 4 to max;
-	//   }
-	// Note that the message cannot have any defined fields; MessageSets only
-	// have extensions.
-	//
-	// All extensions of your type must be singular messages; e.g. they cannot
-	// be int32s, enums, or repeated messages.
-	//
-	// Because this is an option, the above two restrictions are not enforced by
-	// the protocol compiler.
-	MessageSetWireFormat *bool `protobuf:"varint,1,opt,name=message_set_wire_format,json=messageSetWireFormat,def=0" json:"message_set_wire_format,omitempty"`
-	// Disables the generation of the standard "descriptor()" accessor, which can
-	// conflict with a field of the same name.  This is meant to make migration
-	// from proto1 easier; new code should avoid fields named "descriptor".
-	NoStandardDescriptorAccessor *bool `protobuf:"varint,2,opt,name=no_standard_descriptor_accessor,json=noStandardDescriptorAccessor,def=0" json:"no_standard_descriptor_accessor,omitempty"`
-	// Is this message deprecated?
-	// Depending on the target platform, this can emit Deprecated annotations
-	// for the message, or it will be completely ignored; in the very least,
-	// this is a formalization for deprecating messages.
-	Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
-	// Whether the message is an automatically generated map entry type for the
-	// maps field.
-	//
-	// For maps fields:
-	//     map<KeyType, ValueType> map_field = 1;
-	// The parsed descriptor looks like:
-	//     message MapFieldEntry {
-	//         option map_entry = true;
-	//         optional KeyType key = 1;
-	//         optional ValueType value = 2;
-	//     }
-	//     repeated MapFieldEntry map_field = 1;
-	//
-	// Implementations may choose not to generate the map_entry=true message, but
-	// use a native map in the target language to hold the keys and values.
-	// The reflection APIs in such implementions still need to work as
-	// if the field is a repeated message field.
-	//
-	// NOTE: Do not set the option in .proto files. Always use the maps syntax
-	// instead. The option should only be implicitly set by the proto compiler
-	// parser.
-	MapEntry *bool `protobuf:"varint,7,opt,name=map_entry,json=mapEntry" json:"map_entry,omitempty"`
-	// The parser stores options it doesn't recognize here. See above.
-	UninterpretedOption          []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-	XXX_NoUnkeyedLiteral         struct{}               `json:"-"`
-	proto.XXX_InternalExtensions `json:"-"`
-	XXX_unrecognized             []byte `json:"-"`
-	XXX_sizecache                int32  `json:"-"`
-}
-
-func (m *MessageOptions) Reset()         { *m = MessageOptions{} }
-func (m *MessageOptions) String() string { return proto.CompactTextString(m) }
-func (*MessageOptions) ProtoMessage()    {}
-func (*MessageOptions) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{11}
-}
-
-var extRange_MessageOptions = []proto.ExtensionRange{
-	{Start: 1000, End: 536870911},
-}
-
-func (*MessageOptions) ExtensionRangeArray() []proto.ExtensionRange {
-	return extRange_MessageOptions
-}
-func (m *MessageOptions) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_MessageOptions.Unmarshal(m, b)
-}
-func (m *MessageOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_MessageOptions.Marshal(b, m, deterministic)
-}
-func (dst *MessageOptions) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MessageOptions.Merge(dst, src)
-}
-func (m *MessageOptions) XXX_Size() int {
-	return xxx_messageInfo_MessageOptions.Size(m)
-}
-func (m *MessageOptions) XXX_DiscardUnknown() {
-	xxx_messageInfo_MessageOptions.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_MessageOptions proto.InternalMessageInfo
-
-const Default_MessageOptions_MessageSetWireFormat bool = false
-const Default_MessageOptions_NoStandardDescriptorAccessor bool = false
-const Default_MessageOptions_Deprecated bool = false
-
-func (m *MessageOptions) GetMessageSetWireFormat() bool {
-	if m != nil && m.MessageSetWireFormat != nil {
-		return *m.MessageSetWireFormat
-	}
-	return Default_MessageOptions_MessageSetWireFormat
-}
-
-func (m *MessageOptions) GetNoStandardDescriptorAccessor() bool {
-	if m != nil && m.NoStandardDescriptorAccessor != nil {
-		return *m.NoStandardDescriptorAccessor
-	}
-	return Default_MessageOptions_NoStandardDescriptorAccessor
-}
-
-func (m *MessageOptions) GetDeprecated() bool {
-	if m != nil && m.Deprecated != nil {
-		return *m.Deprecated
-	}
-	return Default_MessageOptions_Deprecated
-}
-
-func (m *MessageOptions) GetMapEntry() bool {
-	if m != nil && m.MapEntry != nil {
-		return *m.MapEntry
-	}
-	return false
-}
-
-func (m *MessageOptions) GetUninterpretedOption() []*UninterpretedOption {
-	if m != nil {
-		return m.UninterpretedOption
-	}
-	return nil
-}
-
-type FieldOptions struct {
-	// The ctype option instructs the C++ code generator to use a different
-	// representation of the field than it normally would.  See the specific
-	// options below.  This option is not yet implemented in the open source
-	// release -- sorry, we'll try to include it in a future version!
-	Ctype *FieldOptions_CType `protobuf:"varint,1,opt,name=ctype,enum=google.protobuf.FieldOptions_CType,def=0" json:"ctype,omitempty"`
-	// The packed option can be enabled for repeated primitive fields to enable
-	// a more efficient representation on the wire. Rather than repeatedly
-	// writing the tag and type for each element, the entire array is encoded as
-	// a single length-delimited blob. In proto3, only explicit setting it to
-	// false will avoid using packed encoding.
-	Packed *bool `protobuf:"varint,2,opt,name=packed" json:"packed,omitempty"`
-	// The jstype option determines the JavaScript type used for values of the
-	// field.  The option is permitted only for 64 bit integral and fixed types
-	// (int64, uint64, sint64, fixed64, sfixed64).  A field with jstype JS_STRING
-	// is represented as JavaScript string, which avoids loss of precision that
-	// can happen when a large value is converted to a floating point JavaScript.
-	// Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
-	// use the JavaScript "number" type.  The behavior of the default option
-	// JS_NORMAL is implementation dependent.
-	//
-	// This option is an enum to permit additional types to be added, e.g.
-	// goog.math.Integer.
-	Jstype *FieldOptions_JSType `protobuf:"varint,6,opt,name=jstype,enum=google.protobuf.FieldOptions_JSType,def=0" json:"jstype,omitempty"`
-	// Should this field be parsed lazily?  Lazy applies only to message-type
-	// fields.  It means that when the outer message is initially parsed, the
-	// inner message's contents will not be parsed but instead stored in encoded
-	// form.  The inner message will actually be parsed when it is first accessed.
-	//
-	// This is only a hint.  Implementations are free to choose whether to use
-	// eager or lazy parsing regardless of the value of this option.  However,
-	// setting this option true suggests that the protocol author believes that
-	// using lazy parsing on this field is worth the additional bookkeeping
-	// overhead typically needed to implement it.
-	//
-	// This option does not affect the public interface of any generated code;
-	// all method signatures remain the same.  Furthermore, thread-safety of the
-	// interface is not affected by this option; const methods remain safe to
-	// call from multiple threads concurrently, while non-const methods continue
-	// to require exclusive access.
-	//
-	//
-	// Note that implementations may choose not to check required fields within
-	// a lazy sub-message.  That is, calling IsInitialized() on the outer message
-	// may return true even if the inner message has missing required fields.
-	// This is necessary because otherwise the inner message would have to be
-	// parsed in order to perform the check, defeating the purpose of lazy
-	// parsing.  An implementation which chooses not to check required fields
-	// must be consistent about it.  That is, for any particular sub-message, the
-	// implementation must either *always* check its required fields, or *never*
-	// check its required fields, regardless of whether or not the message has
-	// been parsed.
-	Lazy *bool `protobuf:"varint,5,opt,name=lazy,def=0" json:"lazy,omitempty"`
-	// Is this field deprecated?
-	// Depending on the target platform, this can emit Deprecated annotations
-	// for accessors, or it will be completely ignored; in the very least, this
-	// is a formalization for deprecating fields.
-	Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
-	// For Google-internal migration only. Do not use.
-	Weak *bool `protobuf:"varint,10,opt,name=weak,def=0" json:"weak,omitempty"`
-	// The parser stores options it doesn't recognize here. See above.
-	UninterpretedOption          []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-	XXX_NoUnkeyedLiteral         struct{}               `json:"-"`
-	proto.XXX_InternalExtensions `json:"-"`
-	XXX_unrecognized             []byte `json:"-"`
-	XXX_sizecache                int32  `json:"-"`
-}
-
-func (m *FieldOptions) Reset()         { *m = FieldOptions{} }
-func (m *FieldOptions) String() string { return proto.CompactTextString(m) }
-func (*FieldOptions) ProtoMessage()    {}
-func (*FieldOptions) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{12}
-}
-
-var extRange_FieldOptions = []proto.ExtensionRange{
-	{Start: 1000, End: 536870911},
-}
-
-func (*FieldOptions) ExtensionRangeArray() []proto.ExtensionRange {
-	return extRange_FieldOptions
-}
-func (m *FieldOptions) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_FieldOptions.Unmarshal(m, b)
-}
-func (m *FieldOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_FieldOptions.Marshal(b, m, deterministic)
-}
-func (dst *FieldOptions) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_FieldOptions.Merge(dst, src)
-}
-func (m *FieldOptions) XXX_Size() int {
-	return xxx_messageInfo_FieldOptions.Size(m)
-}
-func (m *FieldOptions) XXX_DiscardUnknown() {
-	xxx_messageInfo_FieldOptions.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_FieldOptions proto.InternalMessageInfo
-
-const Default_FieldOptions_Ctype FieldOptions_CType = FieldOptions_STRING
-const Default_FieldOptions_Jstype FieldOptions_JSType = FieldOptions_JS_NORMAL
-const Default_FieldOptions_Lazy bool = false
-const Default_FieldOptions_Deprecated bool = false
-const Default_FieldOptions_Weak bool = false
-
-func (m *FieldOptions) GetCtype() FieldOptions_CType {
-	if m != nil && m.Ctype != nil {
-		return *m.Ctype
-	}
-	return Default_FieldOptions_Ctype
-}
-
-func (m *FieldOptions) GetPacked() bool {
-	if m != nil && m.Packed != nil {
-		return *m.Packed
-	}
-	return false
-}
-
-func (m *FieldOptions) GetJstype() FieldOptions_JSType {
-	if m != nil && m.Jstype != nil {
-		return *m.Jstype
-	}
-	return Default_FieldOptions_Jstype
-}
-
-func (m *FieldOptions) GetLazy() bool {
-	if m != nil && m.Lazy != nil {
-		return *m.Lazy
-	}
-	return Default_FieldOptions_Lazy
-}
-
-func (m *FieldOptions) GetDeprecated() bool {
-	if m != nil && m.Deprecated != nil {
-		return *m.Deprecated
-	}
-	return Default_FieldOptions_Deprecated
-}
-
-func (m *FieldOptions) GetWeak() bool {
-	if m != nil && m.Weak != nil {
-		return *m.Weak
-	}
-	return Default_FieldOptions_Weak
-}
-
-func (m *FieldOptions) GetUninterpretedOption() []*UninterpretedOption {
-	if m != nil {
-		return m.UninterpretedOption
-	}
-	return nil
-}
-
-type OneofOptions struct {
-	// The parser stores options it doesn't recognize here. See above.
-	UninterpretedOption          []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-	XXX_NoUnkeyedLiteral         struct{}               `json:"-"`
-	proto.XXX_InternalExtensions `json:"-"`
-	XXX_unrecognized             []byte `json:"-"`
-	XXX_sizecache                int32  `json:"-"`
-}
-
-func (m *OneofOptions) Reset()         { *m = OneofOptions{} }
-func (m *OneofOptions) String() string { return proto.CompactTextString(m) }
-func (*OneofOptions) ProtoMessage()    {}
-func (*OneofOptions) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{13}
-}
-
-var extRange_OneofOptions = []proto.ExtensionRange{
-	{Start: 1000, End: 536870911},
-}
-
-func (*OneofOptions) ExtensionRangeArray() []proto.ExtensionRange {
-	return extRange_OneofOptions
-}
-func (m *OneofOptions) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_OneofOptions.Unmarshal(m, b)
-}
-func (m *OneofOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_OneofOptions.Marshal(b, m, deterministic)
-}
-func (dst *OneofOptions) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_OneofOptions.Merge(dst, src)
-}
-func (m *OneofOptions) XXX_Size() int {
-	return xxx_messageInfo_OneofOptions.Size(m)
-}
-func (m *OneofOptions) XXX_DiscardUnknown() {
-	xxx_messageInfo_OneofOptions.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_OneofOptions proto.InternalMessageInfo
-
-func (m *OneofOptions) GetUninterpretedOption() []*UninterpretedOption {
-	if m != nil {
-		return m.UninterpretedOption
-	}
-	return nil
-}
-
-type EnumOptions struct {
-	// Set this option to true to allow mapping different tag names to the same
-	// value.
-	AllowAlias *bool `protobuf:"varint,2,opt,name=allow_alias,json=allowAlias" json:"allow_alias,omitempty"`
-	// Is this enum deprecated?
-	// Depending on the target platform, this can emit Deprecated annotations
-	// for the enum, or it will be completely ignored; in the very least, this
-	// is a formalization for deprecating enums.
-	Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
-	// The parser stores options it doesn't recognize here. See above.
-	UninterpretedOption          []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-	XXX_NoUnkeyedLiteral         struct{}               `json:"-"`
-	proto.XXX_InternalExtensions `json:"-"`
-	XXX_unrecognized             []byte `json:"-"`
-	XXX_sizecache                int32  `json:"-"`
-}
-
-func (m *EnumOptions) Reset()         { *m = EnumOptions{} }
-func (m *EnumOptions) String() string { return proto.CompactTextString(m) }
-func (*EnumOptions) ProtoMessage()    {}
-func (*EnumOptions) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{14}
-}
-
-var extRange_EnumOptions = []proto.ExtensionRange{
-	{Start: 1000, End: 536870911},
-}
-
-func (*EnumOptions) ExtensionRangeArray() []proto.ExtensionRange {
-	return extRange_EnumOptions
-}
-func (m *EnumOptions) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_EnumOptions.Unmarshal(m, b)
-}
-func (m *EnumOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_EnumOptions.Marshal(b, m, deterministic)
-}
-func (dst *EnumOptions) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_EnumOptions.Merge(dst, src)
-}
-func (m *EnumOptions) XXX_Size() int {
-	return xxx_messageInfo_EnumOptions.Size(m)
-}
-func (m *EnumOptions) XXX_DiscardUnknown() {
-	xxx_messageInfo_EnumOptions.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EnumOptions proto.InternalMessageInfo
-
-const Default_EnumOptions_Deprecated bool = false
-
-func (m *EnumOptions) GetAllowAlias() bool {
-	if m != nil && m.AllowAlias != nil {
-		return *m.AllowAlias
-	}
-	return false
-}
-
-func (m *EnumOptions) GetDeprecated() bool {
-	if m != nil && m.Deprecated != nil {
-		return *m.Deprecated
-	}
-	return Default_EnumOptions_Deprecated
-}
-
-func (m *EnumOptions) GetUninterpretedOption() []*UninterpretedOption {
-	if m != nil {
-		return m.UninterpretedOption
-	}
-	return nil
-}
-
-type EnumValueOptions struct {
-	// Is this enum value deprecated?
-	// Depending on the target platform, this can emit Deprecated annotations
-	// for the enum value, or it will be completely ignored; in the very least,
-	// this is a formalization for deprecating enum values.
-	Deprecated *bool `protobuf:"varint,1,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
-	// The parser stores options it doesn't recognize here. See above.
-	UninterpretedOption          []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-	XXX_NoUnkeyedLiteral         struct{}               `json:"-"`
-	proto.XXX_InternalExtensions `json:"-"`
-	XXX_unrecognized             []byte `json:"-"`
-	XXX_sizecache                int32  `json:"-"`
-}
-
-func (m *EnumValueOptions) Reset()         { *m = EnumValueOptions{} }
-func (m *EnumValueOptions) String() string { return proto.CompactTextString(m) }
-func (*EnumValueOptions) ProtoMessage()    {}
-func (*EnumValueOptions) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{15}
-}
-
-var extRange_EnumValueOptions = []proto.ExtensionRange{
-	{Start: 1000, End: 536870911},
-}
-
-func (*EnumValueOptions) ExtensionRangeArray() []proto.ExtensionRange {
-	return extRange_EnumValueOptions
-}
-func (m *EnumValueOptions) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_EnumValueOptions.Unmarshal(m, b)
-}
-func (m *EnumValueOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_EnumValueOptions.Marshal(b, m, deterministic)
-}
-func (dst *EnumValueOptions) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_EnumValueOptions.Merge(dst, src)
-}
-func (m *EnumValueOptions) XXX_Size() int {
-	return xxx_messageInfo_EnumValueOptions.Size(m)
-}
-func (m *EnumValueOptions) XXX_DiscardUnknown() {
-	xxx_messageInfo_EnumValueOptions.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EnumValueOptions proto.InternalMessageInfo
-
-const Default_EnumValueOptions_Deprecated bool = false
-
-func (m *EnumValueOptions) GetDeprecated() bool {
-	if m != nil && m.Deprecated != nil {
-		return *m.Deprecated
-	}
-	return Default_EnumValueOptions_Deprecated
-}
-
-func (m *EnumValueOptions) GetUninterpretedOption() []*UninterpretedOption {
-	if m != nil {
-		return m.UninterpretedOption
-	}
-	return nil
-}
-
-type ServiceOptions struct {
-	// Is this service deprecated?
-	// Depending on the target platform, this can emit Deprecated annotations
-	// for the service, or it will be completely ignored; in the very least,
-	// this is a formalization for deprecating services.
-	Deprecated *bool `protobuf:"varint,33,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
-	// The parser stores options it doesn't recognize here. See above.
-	UninterpretedOption          []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-	XXX_NoUnkeyedLiteral         struct{}               `json:"-"`
-	proto.XXX_InternalExtensions `json:"-"`
-	XXX_unrecognized             []byte `json:"-"`
-	XXX_sizecache                int32  `json:"-"`
-}
-
-func (m *ServiceOptions) Reset()         { *m = ServiceOptions{} }
-func (m *ServiceOptions) String() string { return proto.CompactTextString(m) }
-func (*ServiceOptions) ProtoMessage()    {}
-func (*ServiceOptions) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{16}
-}
-
-var extRange_ServiceOptions = []proto.ExtensionRange{
-	{Start: 1000, End: 536870911},
-}
-
-func (*ServiceOptions) ExtensionRangeArray() []proto.ExtensionRange {
-	return extRange_ServiceOptions
-}
-func (m *ServiceOptions) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ServiceOptions.Unmarshal(m, b)
-}
-func (m *ServiceOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ServiceOptions.Marshal(b, m, deterministic)
-}
-func (dst *ServiceOptions) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ServiceOptions.Merge(dst, src)
-}
-func (m *ServiceOptions) XXX_Size() int {
-	return xxx_messageInfo_ServiceOptions.Size(m)
-}
-func (m *ServiceOptions) XXX_DiscardUnknown() {
-	xxx_messageInfo_ServiceOptions.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ServiceOptions proto.InternalMessageInfo
-
-const Default_ServiceOptions_Deprecated bool = false
-
-func (m *ServiceOptions) GetDeprecated() bool {
-	if m != nil && m.Deprecated != nil {
-		return *m.Deprecated
-	}
-	return Default_ServiceOptions_Deprecated
-}
-
-func (m *ServiceOptions) GetUninterpretedOption() []*UninterpretedOption {
-	if m != nil {
-		return m.UninterpretedOption
-	}
-	return nil
-}
-
-type MethodOptions struct {
-	// Is this method deprecated?
-	// Depending on the target platform, this can emit Deprecated annotations
-	// for the method, or it will be completely ignored; in the very least,
-	// this is a formalization for deprecating methods.
-	Deprecated       *bool                           `protobuf:"varint,33,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
-	IdempotencyLevel *MethodOptions_IdempotencyLevel `protobuf:"varint,34,opt,name=idempotency_level,json=idempotencyLevel,enum=google.protobuf.MethodOptions_IdempotencyLevel,def=0" json:"idempotency_level,omitempty"`
-	// The parser stores options it doesn't recognize here. See above.
-	UninterpretedOption          []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-	XXX_NoUnkeyedLiteral         struct{}               `json:"-"`
-	proto.XXX_InternalExtensions `json:"-"`
-	XXX_unrecognized             []byte `json:"-"`
-	XXX_sizecache                int32  `json:"-"`
-}
-
-func (m *MethodOptions) Reset()         { *m = MethodOptions{} }
-func (m *MethodOptions) String() string { return proto.CompactTextString(m) }
-func (*MethodOptions) ProtoMessage()    {}
-func (*MethodOptions) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{17}
-}
-
-var extRange_MethodOptions = []proto.ExtensionRange{
-	{Start: 1000, End: 536870911},
-}
-
-func (*MethodOptions) ExtensionRangeArray() []proto.ExtensionRange {
-	return extRange_MethodOptions
-}
-func (m *MethodOptions) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_MethodOptions.Unmarshal(m, b)
-}
-func (m *MethodOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_MethodOptions.Marshal(b, m, deterministic)
-}
-func (dst *MethodOptions) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MethodOptions.Merge(dst, src)
-}
-func (m *MethodOptions) XXX_Size() int {
-	return xxx_messageInfo_MethodOptions.Size(m)
-}
-func (m *MethodOptions) XXX_DiscardUnknown() {
-	xxx_messageInfo_MethodOptions.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_MethodOptions proto.InternalMessageInfo
-
-const Default_MethodOptions_Deprecated bool = false
-const Default_MethodOptions_IdempotencyLevel MethodOptions_IdempotencyLevel = MethodOptions_IDEMPOTENCY_UNKNOWN
-
-func (m *MethodOptions) GetDeprecated() bool {
-	if m != nil && m.Deprecated != nil {
-		return *m.Deprecated
-	}
-	return Default_MethodOptions_Deprecated
-}
-
-func (m *MethodOptions) GetIdempotencyLevel() MethodOptions_IdempotencyLevel {
-	if m != nil && m.IdempotencyLevel != nil {
-		return *m.IdempotencyLevel
-	}
-	return Default_MethodOptions_IdempotencyLevel
-}
-
-func (m *MethodOptions) GetUninterpretedOption() []*UninterpretedOption {
-	if m != nil {
-		return m.UninterpretedOption
-	}
-	return nil
-}
-
-// A message representing a option the parser does not recognize. This only
-// appears in options protos created by the compiler::Parser class.
-// DescriptorPool resolves these when building Descriptor objects. Therefore,
-// options protos in descriptor objects (e.g. returned by Descriptor::options(),
-// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
-// in them.
-type UninterpretedOption struct {
-	Name []*UninterpretedOption_NamePart `protobuf:"bytes,2,rep,name=name" json:"name,omitempty"`
-	// The value of the uninterpreted option, in whatever type the tokenizer
-	// identified it as during parsing. Exactly one of these should be set.
-	IdentifierValue      *string  `protobuf:"bytes,3,opt,name=identifier_value,json=identifierValue" json:"identifier_value,omitempty"`
-	PositiveIntValue     *uint64  `protobuf:"varint,4,opt,name=positive_int_value,json=positiveIntValue" json:"positive_int_value,omitempty"`
-	NegativeIntValue     *int64   `protobuf:"varint,5,opt,name=negative_int_value,json=negativeIntValue" json:"negative_int_value,omitempty"`
-	DoubleValue          *float64 `protobuf:"fixed64,6,opt,name=double_value,json=doubleValue" json:"double_value,omitempty"`
-	StringValue          []byte   `protobuf:"bytes,7,opt,name=string_value,json=stringValue" json:"string_value,omitempty"`
-	AggregateValue       *string  `protobuf:"bytes,8,opt,name=aggregate_value,json=aggregateValue" json:"aggregate_value,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *UninterpretedOption) Reset()         { *m = UninterpretedOption{} }
-func (m *UninterpretedOption) String() string { return proto.CompactTextString(m) }
-func (*UninterpretedOption) ProtoMessage()    {}
-func (*UninterpretedOption) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{18}
-}
-func (m *UninterpretedOption) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_UninterpretedOption.Unmarshal(m, b)
-}
-func (m *UninterpretedOption) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_UninterpretedOption.Marshal(b, m, deterministic)
-}
-func (dst *UninterpretedOption) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_UninterpretedOption.Merge(dst, src)
-}
-func (m *UninterpretedOption) XXX_Size() int {
-	return xxx_messageInfo_UninterpretedOption.Size(m)
-}
-func (m *UninterpretedOption) XXX_DiscardUnknown() {
-	xxx_messageInfo_UninterpretedOption.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_UninterpretedOption proto.InternalMessageInfo
-
-func (m *UninterpretedOption) GetName() []*UninterpretedOption_NamePart {
-	if m != nil {
-		return m.Name
-	}
-	return nil
-}
-
-func (m *UninterpretedOption) GetIdentifierValue() string {
-	if m != nil && m.IdentifierValue != nil {
-		return *m.IdentifierValue
-	}
-	return ""
-}
-
-func (m *UninterpretedOption) GetPositiveIntValue() uint64 {
-	if m != nil && m.PositiveIntValue != nil {
-		return *m.PositiveIntValue
-	}
-	return 0
-}
-
-func (m *UninterpretedOption) GetNegativeIntValue() int64 {
-	if m != nil && m.NegativeIntValue != nil {
-		return *m.NegativeIntValue
-	}
-	return 0
-}
-
-func (m *UninterpretedOption) GetDoubleValue() float64 {
-	if m != nil && m.DoubleValue != nil {
-		return *m.DoubleValue
-	}
-	return 0
-}
-
-func (m *UninterpretedOption) GetStringValue() []byte {
-	if m != nil {
-		return m.StringValue
-	}
-	return nil
-}
-
-func (m *UninterpretedOption) GetAggregateValue() string {
-	if m != nil && m.AggregateValue != nil {
-		return *m.AggregateValue
-	}
-	return ""
-}
-
-// The name of the uninterpreted option.  Each string represents a segment in
-// a dot-separated name.  is_extension is true iff a segment represents an
-// extension (denoted with parentheses in options specs in .proto files).
-// E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents
-// "foo.(bar.baz).qux".
-type UninterpretedOption_NamePart struct {
-	NamePart             *string  `protobuf:"bytes,1,req,name=name_part,json=namePart" json:"name_part,omitempty"`
-	IsExtension          *bool    `protobuf:"varint,2,req,name=is_extension,json=isExtension" json:"is_extension,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *UninterpretedOption_NamePart) Reset()         { *m = UninterpretedOption_NamePart{} }
-func (m *UninterpretedOption_NamePart) String() string { return proto.CompactTextString(m) }
-func (*UninterpretedOption_NamePart) ProtoMessage()    {}
-func (*UninterpretedOption_NamePart) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{18, 0}
-}
-func (m *UninterpretedOption_NamePart) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_UninterpretedOption_NamePart.Unmarshal(m, b)
-}
-func (m *UninterpretedOption_NamePart) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_UninterpretedOption_NamePart.Marshal(b, m, deterministic)
-}
-func (dst *UninterpretedOption_NamePart) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_UninterpretedOption_NamePart.Merge(dst, src)
-}
-func (m *UninterpretedOption_NamePart) XXX_Size() int {
-	return xxx_messageInfo_UninterpretedOption_NamePart.Size(m)
-}
-func (m *UninterpretedOption_NamePart) XXX_DiscardUnknown() {
-	xxx_messageInfo_UninterpretedOption_NamePart.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_UninterpretedOption_NamePart proto.InternalMessageInfo
-
-func (m *UninterpretedOption_NamePart) GetNamePart() string {
-	if m != nil && m.NamePart != nil {
-		return *m.NamePart
-	}
-	return ""
-}
-
-func (m *UninterpretedOption_NamePart) GetIsExtension() bool {
-	if m != nil && m.IsExtension != nil {
-		return *m.IsExtension
-	}
-	return false
-}
-
-// Encapsulates information about the original source file from which a
-// FileDescriptorProto was generated.
-type SourceCodeInfo struct {
-	// A Location identifies a piece of source code in a .proto file which
-	// corresponds to a particular definition.  This information is intended
-	// to be useful to IDEs, code indexers, documentation generators, and similar
-	// tools.
-	//
-	// For example, say we have a file like:
-	//   message Foo {
-	//     optional string foo = 1;
-	//   }
-	// Let's look at just the field definition:
-	//   optional string foo = 1;
-	//   ^       ^^     ^^  ^  ^^^
-	//   a       bc     de  f  ghi
-	// We have the following locations:
-	//   span   path               represents
-	//   [a,i)  [ 4, 0, 2, 0 ]     The whole field definition.
-	//   [a,b)  [ 4, 0, 2, 0, 4 ]  The label (optional).
-	//   [c,d)  [ 4, 0, 2, 0, 5 ]  The type (string).
-	//   [e,f)  [ 4, 0, 2, 0, 1 ]  The name (foo).
-	//   [g,h)  [ 4, 0, 2, 0, 3 ]  The number (1).
-	//
-	// Notes:
-	// - A location may refer to a repeated field itself (i.e. not to any
-	//   particular index within it).  This is used whenever a set of elements are
-	//   logically enclosed in a single code segment.  For example, an entire
-	//   extend block (possibly containing multiple extension definitions) will
-	//   have an outer location whose path refers to the "extensions" repeated
-	//   field without an index.
-	// - Multiple locations may have the same path.  This happens when a single
-	//   logical declaration is spread out across multiple places.  The most
-	//   obvious example is the "extend" block again -- there may be multiple
-	//   extend blocks in the same scope, each of which will have the same path.
-	// - A location's span is not always a subset of its parent's span.  For
-	//   example, the "extendee" of an extension declaration appears at the
-	//   beginning of the "extend" block and is shared by all extensions within
-	//   the block.
-	// - Just because a location's span is a subset of some other location's span
-	//   does not mean that it is a descendent.  For example, a "group" defines
-	//   both a type and a field in a single declaration.  Thus, the locations
-	//   corresponding to the type and field and their components will overlap.
-	// - Code which tries to interpret locations should probably be designed to
-	//   ignore those that it doesn't understand, as more types of locations could
-	//   be recorded in the future.
-	Location             []*SourceCodeInfo_Location `protobuf:"bytes,1,rep,name=location" json:"location,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
-	XXX_unrecognized     []byte                     `json:"-"`
-	XXX_sizecache        int32                      `json:"-"`
-}
-
-func (m *SourceCodeInfo) Reset()         { *m = SourceCodeInfo{} }
-func (m *SourceCodeInfo) String() string { return proto.CompactTextString(m) }
-func (*SourceCodeInfo) ProtoMessage()    {}
-func (*SourceCodeInfo) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{19}
-}
-func (m *SourceCodeInfo) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_SourceCodeInfo.Unmarshal(m, b)
-}
-func (m *SourceCodeInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_SourceCodeInfo.Marshal(b, m, deterministic)
-}
-func (dst *SourceCodeInfo) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_SourceCodeInfo.Merge(dst, src)
-}
-func (m *SourceCodeInfo) XXX_Size() int {
-	return xxx_messageInfo_SourceCodeInfo.Size(m)
-}
-func (m *SourceCodeInfo) XXX_DiscardUnknown() {
-	xxx_messageInfo_SourceCodeInfo.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_SourceCodeInfo proto.InternalMessageInfo
-
-func (m *SourceCodeInfo) GetLocation() []*SourceCodeInfo_Location {
-	if m != nil {
-		return m.Location
-	}
-	return nil
-}
-
-type SourceCodeInfo_Location struct {
-	// Identifies which part of the FileDescriptorProto was defined at this
-	// location.
-	//
-	// Each element is a field number or an index.  They form a path from
-	// the root FileDescriptorProto to the place where the definition.  For
-	// example, this path:
-	//   [ 4, 3, 2, 7, 1 ]
-	// refers to:
-	//   file.message_type(3)  // 4, 3
-	//       .field(7)         // 2, 7
-	//       .name()           // 1
-	// This is because FileDescriptorProto.message_type has field number 4:
-	//   repeated DescriptorProto message_type = 4;
-	// and DescriptorProto.field has field number 2:
-	//   repeated FieldDescriptorProto field = 2;
-	// and FieldDescriptorProto.name has field number 1:
-	//   optional string name = 1;
-	//
-	// Thus, the above path gives the location of a field name.  If we removed
-	// the last element:
-	//   [ 4, 3, 2, 7 ]
-	// this path refers to the whole field declaration (from the beginning
-	// of the label to the terminating semicolon).
-	Path []int32 `protobuf:"varint,1,rep,packed,name=path" json:"path,omitempty"`
-	// Always has exactly three or four elements: start line, start column,
-	// end line (optional, otherwise assumed same as start line), end column.
-	// These are packed into a single field for efficiency.  Note that line
-	// and column numbers are zero-based -- typically you will want to add
-	// 1 to each before displaying to a user.
-	Span []int32 `protobuf:"varint,2,rep,packed,name=span" json:"span,omitempty"`
-	// If this SourceCodeInfo represents a complete declaration, these are any
-	// comments appearing before and after the declaration which appear to be
-	// attached to the declaration.
-	//
-	// A series of line comments appearing on consecutive lines, with no other
-	// tokens appearing on those lines, will be treated as a single comment.
-	//
-	// leading_detached_comments will keep paragraphs of comments that appear
-	// before (but not connected to) the current element. Each paragraph,
-	// separated by empty lines, will be one comment element in the repeated
-	// field.
-	//
-	// Only the comment content is provided; comment markers (e.g. //) are
-	// stripped out.  For block comments, leading whitespace and an asterisk
-	// will be stripped from the beginning of each line other than the first.
-	// Newlines are included in the output.
-	//
-	// Examples:
-	//
-	//   optional int32 foo = 1;  // Comment attached to foo.
-	//   // Comment attached to bar.
-	//   optional int32 bar = 2;
-	//
-	//   optional string baz = 3;
-	//   // Comment attached to baz.
-	//   // Another line attached to baz.
-	//
-	//   // Comment attached to qux.
-	//   //
-	//   // Another line attached to qux.
-	//   optional double qux = 4;
-	//
-	//   // Detached comment for corge. This is not leading or trailing comments
-	//   // to qux or corge because there are blank lines separating it from
-	//   // both.
-	//
-	//   // Detached comment for corge paragraph 2.
-	//
-	//   optional string corge = 5;
-	//   /* Block comment attached
-	//    * to corge.  Leading asterisks
-	//    * will be removed. */
-	//   /* Block comment attached to
-	//    * grault. */
-	//   optional int32 grault = 6;
-	//
-	//   // ignored detached comments.
-	LeadingComments         *string  `protobuf:"bytes,3,opt,name=leading_comments,json=leadingComments" json:"leading_comments,omitempty"`
-	TrailingComments        *string  `protobuf:"bytes,4,opt,name=trailing_comments,json=trailingComments" json:"trailing_comments,omitempty"`
-	LeadingDetachedComments []string `protobuf:"bytes,6,rep,name=leading_detached_comments,json=leadingDetachedComments" json:"leading_detached_comments,omitempty"`
-	XXX_NoUnkeyedLiteral    struct{} `json:"-"`
-	XXX_unrecognized        []byte   `json:"-"`
-	XXX_sizecache           int32    `json:"-"`
-}
-
-func (m *SourceCodeInfo_Location) Reset()         { *m = SourceCodeInfo_Location{} }
-func (m *SourceCodeInfo_Location) String() string { return proto.CompactTextString(m) }
-func (*SourceCodeInfo_Location) ProtoMessage()    {}
-func (*SourceCodeInfo_Location) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{19, 0}
-}
-func (m *SourceCodeInfo_Location) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_SourceCodeInfo_Location.Unmarshal(m, b)
-}
-func (m *SourceCodeInfo_Location) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_SourceCodeInfo_Location.Marshal(b, m, deterministic)
-}
-func (dst *SourceCodeInfo_Location) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_SourceCodeInfo_Location.Merge(dst, src)
-}
-func (m *SourceCodeInfo_Location) XXX_Size() int {
-	return xxx_messageInfo_SourceCodeInfo_Location.Size(m)
-}
-func (m *SourceCodeInfo_Location) XXX_DiscardUnknown() {
-	xxx_messageInfo_SourceCodeInfo_Location.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_SourceCodeInfo_Location proto.InternalMessageInfo
-
-func (m *SourceCodeInfo_Location) GetPath() []int32 {
-	if m != nil {
-		return m.Path
-	}
-	return nil
-}
-
-func (m *SourceCodeInfo_Location) GetSpan() []int32 {
-	if m != nil {
-		return m.Span
-	}
-	return nil
-}
-
-func (m *SourceCodeInfo_Location) GetLeadingComments() string {
-	if m != nil && m.LeadingComments != nil {
-		return *m.LeadingComments
-	}
-	return ""
-}
-
-func (m *SourceCodeInfo_Location) GetTrailingComments() string {
-	if m != nil && m.TrailingComments != nil {
-		return *m.TrailingComments
-	}
-	return ""
-}
-
-func (m *SourceCodeInfo_Location) GetLeadingDetachedComments() []string {
-	if m != nil {
-		return m.LeadingDetachedComments
-	}
-	return nil
-}
-
-// Describes the relationship between generated code and its original source
-// file. A GeneratedCodeInfo message is associated with only one generated
-// source file, but may contain references to different source .proto files.
-type GeneratedCodeInfo struct {
-	// An Annotation connects some span of text in generated code to an element
-	// of its generating .proto file.
-	Annotation           []*GeneratedCodeInfo_Annotation `protobuf:"bytes,1,rep,name=annotation" json:"annotation,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                        `json:"-"`
-	XXX_unrecognized     []byte                          `json:"-"`
-	XXX_sizecache        int32                           `json:"-"`
-}
-
-func (m *GeneratedCodeInfo) Reset()         { *m = GeneratedCodeInfo{} }
-func (m *GeneratedCodeInfo) String() string { return proto.CompactTextString(m) }
-func (*GeneratedCodeInfo) ProtoMessage()    {}
-func (*GeneratedCodeInfo) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{20}
-}
-func (m *GeneratedCodeInfo) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_GeneratedCodeInfo.Unmarshal(m, b)
-}
-func (m *GeneratedCodeInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_GeneratedCodeInfo.Marshal(b, m, deterministic)
-}
-func (dst *GeneratedCodeInfo) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GeneratedCodeInfo.Merge(dst, src)
-}
-func (m *GeneratedCodeInfo) XXX_Size() int {
-	return xxx_messageInfo_GeneratedCodeInfo.Size(m)
-}
-func (m *GeneratedCodeInfo) XXX_DiscardUnknown() {
-	xxx_messageInfo_GeneratedCodeInfo.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_GeneratedCodeInfo proto.InternalMessageInfo
-
-func (m *GeneratedCodeInfo) GetAnnotation() []*GeneratedCodeInfo_Annotation {
-	if m != nil {
-		return m.Annotation
-	}
-	return nil
-}
-
-type GeneratedCodeInfo_Annotation struct {
-	// Identifies the element in the original source .proto file. This field
-	// is formatted the same as SourceCodeInfo.Location.path.
-	Path []int32 `protobuf:"varint,1,rep,packed,name=path" json:"path,omitempty"`
-	// Identifies the filesystem path to the original source .proto.
-	SourceFile *string `protobuf:"bytes,2,opt,name=source_file,json=sourceFile" json:"source_file,omitempty"`
-	// Identifies the starting offset in bytes in the generated code
-	// that relates to the identified object.
-	Begin *int32 `protobuf:"varint,3,opt,name=begin" json:"begin,omitempty"`
-	// Identifies the ending offset in bytes in the generated code that
-	// relates to the identified offset. The end offset should be one past
-	// the last relevant byte (so the length of the text = end - begin).
-	End                  *int32   `protobuf:"varint,4,opt,name=end" json:"end,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *GeneratedCodeInfo_Annotation) Reset()         { *m = GeneratedCodeInfo_Annotation{} }
-func (m *GeneratedCodeInfo_Annotation) String() string { return proto.CompactTextString(m) }
-func (*GeneratedCodeInfo_Annotation) ProtoMessage()    {}
-func (*GeneratedCodeInfo_Annotation) Descriptor() ([]byte, []int) {
-	return fileDescriptor_descriptor_4df4cb5f42392df6, []int{20, 0}
-}
-func (m *GeneratedCodeInfo_Annotation) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_GeneratedCodeInfo_Annotation.Unmarshal(m, b)
-}
-func (m *GeneratedCodeInfo_Annotation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_GeneratedCodeInfo_Annotation.Marshal(b, m, deterministic)
-}
-func (dst *GeneratedCodeInfo_Annotation) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GeneratedCodeInfo_Annotation.Merge(dst, src)
-}
-func (m *GeneratedCodeInfo_Annotation) XXX_Size() int {
-	return xxx_messageInfo_GeneratedCodeInfo_Annotation.Size(m)
-}
-func (m *GeneratedCodeInfo_Annotation) XXX_DiscardUnknown() {
-	xxx_messageInfo_GeneratedCodeInfo_Annotation.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_GeneratedCodeInfo_Annotation proto.InternalMessageInfo
-
-func (m *GeneratedCodeInfo_Annotation) GetPath() []int32 {
-	if m != nil {
-		return m.Path
-	}
-	return nil
-}
-
-func (m *GeneratedCodeInfo_Annotation) GetSourceFile() string {
-	if m != nil && m.SourceFile != nil {
-		return *m.SourceFile
-	}
-	return ""
-}
-
-func (m *GeneratedCodeInfo_Annotation) GetBegin() int32 {
-	if m != nil && m.Begin != nil {
-		return *m.Begin
-	}
-	return 0
-}
-
-func (m *GeneratedCodeInfo_Annotation) GetEnd() int32 {
-	if m != nil && m.End != nil {
-		return *m.End
-	}
-	return 0
-}
-
-func init() {
-	proto.RegisterType((*FileDescriptorSet)(nil), "google.protobuf.FileDescriptorSet")
-	proto.RegisterType((*FileDescriptorProto)(nil), "google.protobuf.FileDescriptorProto")
-	proto.RegisterType((*DescriptorProto)(nil), "google.protobuf.DescriptorProto")
-	proto.RegisterType((*DescriptorProto_ExtensionRange)(nil), "google.protobuf.DescriptorProto.ExtensionRange")
-	proto.RegisterType((*DescriptorProto_ReservedRange)(nil), "google.protobuf.DescriptorProto.ReservedRange")
-	proto.RegisterType((*ExtensionRangeOptions)(nil), "google.protobuf.ExtensionRangeOptions")
-	proto.RegisterType((*FieldDescriptorProto)(nil), "google.protobuf.FieldDescriptorProto")
-	proto.RegisterType((*OneofDescriptorProto)(nil), "google.protobuf.OneofDescriptorProto")
-	proto.RegisterType((*EnumDescriptorProto)(nil), "google.protobuf.EnumDescriptorProto")
-	proto.RegisterType((*EnumDescriptorProto_EnumReservedRange)(nil), "google.protobuf.EnumDescriptorProto.EnumReservedRange")
-	proto.RegisterType((*EnumValueDescriptorProto)(nil), "google.protobuf.EnumValueDescriptorProto")
-	proto.RegisterType((*ServiceDescriptorProto)(nil), "google.protobuf.ServiceDescriptorProto")
-	proto.RegisterType((*MethodDescriptorProto)(nil), "google.protobuf.MethodDescriptorProto")
-	proto.RegisterType((*FileOptions)(nil), "google.protobuf.FileOptions")
-	proto.RegisterType((*MessageOptions)(nil), "google.protobuf.MessageOptions")
-	proto.RegisterType((*FieldOptions)(nil), "google.protobuf.FieldOptions")
-	proto.RegisterType((*OneofOptions)(nil), "google.protobuf.OneofOptions")
-	proto.RegisterType((*EnumOptions)(nil), "google.protobuf.EnumOptions")
-	proto.RegisterType((*EnumValueOptions)(nil), "google.protobuf.EnumValueOptions")
-	proto.RegisterType((*ServiceOptions)(nil), "google.protobuf.ServiceOptions")
-	proto.RegisterType((*MethodOptions)(nil), "google.protobuf.MethodOptions")
-	proto.RegisterType((*UninterpretedOption)(nil), "google.protobuf.UninterpretedOption")
-	proto.RegisterType((*UninterpretedOption_NamePart)(nil), "google.protobuf.UninterpretedOption.NamePart")
-	proto.RegisterType((*SourceCodeInfo)(nil), "google.protobuf.SourceCodeInfo")
-	proto.RegisterType((*SourceCodeInfo_Location)(nil), "google.protobuf.SourceCodeInfo.Location")
-	proto.RegisterType((*GeneratedCodeInfo)(nil), "google.protobuf.GeneratedCodeInfo")
-	proto.RegisterType((*GeneratedCodeInfo_Annotation)(nil), "google.protobuf.GeneratedCodeInfo.Annotation")
-	proto.RegisterEnum("google.protobuf.FieldDescriptorProto_Type", FieldDescriptorProto_Type_name, FieldDescriptorProto_Type_value)
-	proto.RegisterEnum("google.protobuf.FieldDescriptorProto_Label", FieldDescriptorProto_Label_name, FieldDescriptorProto_Label_value)
-	proto.RegisterEnum("google.protobuf.FileOptions_OptimizeMode", FileOptions_OptimizeMode_name, FileOptions_OptimizeMode_value)
-	proto.RegisterEnum("google.protobuf.FieldOptions_CType", FieldOptions_CType_name, FieldOptions_CType_value)
-	proto.RegisterEnum("google.protobuf.FieldOptions_JSType", FieldOptions_JSType_name, FieldOptions_JSType_value)
-	proto.RegisterEnum("google.protobuf.MethodOptions_IdempotencyLevel", MethodOptions_IdempotencyLevel_name, MethodOptions_IdempotencyLevel_value)
-}
-
-func init() {
-	proto.RegisterFile("google/protobuf/descriptor.proto", fileDescriptor_descriptor_4df4cb5f42392df6)
-}
+var MethodOptions_IdempotencyLevel_name = descriptorpb.MethodOptions_IdempotencyLevel_name
+var MethodOptions_IdempotencyLevel_value = descriptorpb.MethodOptions_IdempotencyLevel_value
 
-var fileDescriptor_descriptor_4df4cb5f42392df6 = []byte{
-	// 2555 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x59, 0xdd, 0x6e, 0x1b, 0xc7,
-	0xf5, 0xcf, 0xf2, 0x4b, 0xe4, 0x21, 0x45, 0x8d, 0x46, 0x8a, 0xbd, 0x56, 0x3e, 0x2c, 0x33, 0x1f,
-	0x96, 0x9d, 0x7f, 0xa8, 0xc0, 0xb1, 0x1d, 0x47, 0xfe, 0x23, 0x2d, 0x45, 0xae, 0x15, 0xaa, 0x12,
-	0xc9, 0x2e, 0xa9, 0xe6, 0x03, 0x28, 0x16, 0xa3, 0xdd, 0x21, 0xb9, 0xf6, 0x72, 0x77, 0xb3, 0xbb,
-	0xb4, 0xad, 0xa0, 0x17, 0x06, 0x7a, 0xd5, 0xab, 0xde, 0x16, 0x45, 0xd1, 0x8b, 0xde, 0x04, 0xe8,
-	0x03, 0x14, 0xc8, 0x5d, 0x9f, 0xa0, 0x40, 0xde, 0xa0, 0x68, 0x0b, 0xb4, 0x8f, 0xd0, 0xcb, 0x62,
-	0x66, 0x76, 0x97, 0xbb, 0x24, 0x15, 0x2b, 0x01, 0xe2, 0x5c, 0x91, 0xf3, 0x9b, 0xdf, 0x39, 0x73,
-	0xe6, 0xcc, 0x99, 0x33, 0x67, 0x66, 0x61, 0x7b, 0xe4, 0x38, 0x23, 0x8b, 0xee, 0xba, 0x9e, 0x13,
-	0x38, 0xa7, 0xd3, 0xe1, 0xae, 0x41, 0x7d, 0xdd, 0x33, 0xdd, 0xc0, 0xf1, 0xea, 0x1c, 0xc3, 0x6b,
-	0x82, 0x51, 0x8f, 0x18, 0xb5, 0x63, 0x58, 0x7f, 0x60, 0x5a, 0xb4, 0x15, 0x13, 0xfb, 0x34, 0xc0,
-	0xf7, 0x20, 0x37, 0x34, 0x2d, 0x2a, 0x4b, 0xdb, 0xd9, 0x9d, 0xf2, 0xad, 0x37, 0xeb, 0x73, 0x42,
-	0xf5, 0xb4, 0x44, 0x8f, 0xc1, 0x2a, 0x97, 0xa8, 0xfd, 0x2b, 0x07, 0x1b, 0x4b, 0x7a, 0x31, 0x86,
-	0x9c, 0x4d, 0x26, 0x4c, 0xa3, 0xb4, 0x53, 0x52, 0xf9, 0x7f, 0x2c, 0xc3, 0x8a, 0x4b, 0xf4, 0x47,
-	0x64, 0x44, 0xe5, 0x0c, 0x87, 0xa3, 0x26, 0x7e, 0x1d, 0xc0, 0xa0, 0x2e, 0xb5, 0x0d, 0x6a, 0xeb,
-	0x67, 0x72, 0x76, 0x3b, 0xbb, 0x53, 0x52, 0x13, 0x08, 0x7e, 0x07, 0xd6, 0xdd, 0xe9, 0xa9, 0x65,
-	0xea, 0x5a, 0x82, 0x06, 0xdb, 0xd9, 0x9d, 0xbc, 0x8a, 0x44, 0x47, 0x6b, 0x46, 0xbe, 0x0e, 0x6b,
-	0x4f, 0x28, 0x79, 0x94, 0xa4, 0x96, 0x39, 0xb5, 0xca, 0xe0, 0x04, 0xb1, 0x09, 0x95, 0x09, 0xf5,
-	0x7d, 0x32, 0xa2, 0x5a, 0x70, 0xe6, 0x52, 0x39, 0xc7, 0x67, 0xbf, 0xbd, 0x30, 0xfb, 0xf9, 0x99,
-	0x97, 0x43, 0xa9, 0xc1, 0x99, 0x4b, 0x71, 0x03, 0x4a, 0xd4, 0x9e, 0x4e, 0x84, 0x86, 0xfc, 0x39,
-	0xfe, 0x53, 0xec, 0xe9, 0x64, 0x5e, 0x4b, 0x91, 0x89, 0x85, 0x2a, 0x56, 0x7c, 0xea, 0x3d, 0x36,
-	0x75, 0x2a, 0x17, 0xb8, 0x82, 0xeb, 0x0b, 0x0a, 0xfa, 0xa2, 0x7f, 0x5e, 0x47, 0x24, 0x87, 0x9b,
-	0x50, 0xa2, 0x4f, 0x03, 0x6a, 0xfb, 0xa6, 0x63, 0xcb, 0x2b, 0x5c, 0xc9, 0x5b, 0x4b, 0x56, 0x91,
-	0x5a, 0xc6, 0xbc, 0x8a, 0x99, 0x1c, 0xbe, 0x0b, 0x2b, 0x8e, 0x1b, 0x98, 0x8e, 0xed, 0xcb, 0xc5,
-	0x6d, 0x69, 0xa7, 0x7c, 0xeb, 0xd5, 0xa5, 0x81, 0xd0, 0x15, 0x1c, 0x35, 0x22, 0xe3, 0x36, 0x20,
-	0xdf, 0x99, 0x7a, 0x3a, 0xd5, 0x74, 0xc7, 0xa0, 0x9a, 0x69, 0x0f, 0x1d, 0xb9, 0xc4, 0x15, 0x5c,
-	0x5d, 0x9c, 0x08, 0x27, 0x36, 0x1d, 0x83, 0xb6, 0xed, 0xa1, 0xa3, 0x56, 0xfd, 0x54, 0x1b, 0x5f,
-	0x82, 0x82, 0x7f, 0x66, 0x07, 0xe4, 0xa9, 0x5c, 0xe1, 0x11, 0x12, 0xb6, 0x6a, 0x5f, 0x17, 0x60,
-	0xed, 0x22, 0x21, 0x76, 0x1f, 0xf2, 0x43, 0x36, 0x4b, 0x39, 0xf3, 0x5d, 0x7c, 0x20, 0x64, 0xd2,
-	0x4e, 0x2c, 0x7c, 0x4f, 0x27, 0x36, 0xa0, 0x6c, 0x53, 0x3f, 0xa0, 0x86, 0x88, 0x88, 0xec, 0x05,
-	0x63, 0x0a, 0x84, 0xd0, 0x62, 0x48, 0xe5, 0xbe, 0x57, 0x48, 0x7d, 0x0a, 0x6b, 0xb1, 0x49, 0x9a,
-	0x47, 0xec, 0x51, 0x14, 0x9b, 0xbb, 0xcf, 0xb3, 0xa4, 0xae, 0x44, 0x72, 0x2a, 0x13, 0x53, 0xab,
-	0x34, 0xd5, 0xc6, 0x2d, 0x00, 0xc7, 0xa6, 0xce, 0x50, 0x33, 0xa8, 0x6e, 0xc9, 0xc5, 0x73, 0xbc,
-	0xd4, 0x65, 0x94, 0x05, 0x2f, 0x39, 0x02, 0xd5, 0x2d, 0xfc, 0xe1, 0x2c, 0xd4, 0x56, 0xce, 0x89,
-	0x94, 0x63, 0xb1, 0xc9, 0x16, 0xa2, 0xed, 0x04, 0xaa, 0x1e, 0x65, 0x71, 0x4f, 0x8d, 0x70, 0x66,
-	0x25, 0x6e, 0x44, 0xfd, 0xb9, 0x33, 0x53, 0x43, 0x31, 0x31, 0xb1, 0x55, 0x2f, 0xd9, 0xc4, 0x6f,
-	0x40, 0x0c, 0x68, 0x3c, 0xac, 0x80, 0x67, 0xa1, 0x4a, 0x04, 0x76, 0xc8, 0x84, 0x6e, 0x7d, 0x09,
-	0xd5, 0xb4, 0x7b, 0xf0, 0x26, 0xe4, 0xfd, 0x80, 0x78, 0x01, 0x8f, 0xc2, 0xbc, 0x2a, 0x1a, 0x18,
-	0x41, 0x96, 0xda, 0x06, 0xcf, 0x72, 0x79, 0x95, 0xfd, 0xc5, 0x3f, 0x9d, 0x4d, 0x38, 0xcb, 0x27,
-	0xfc, 0xf6, 0xe2, 0x8a, 0xa6, 0x34, 0xcf, 0xcf, 0x7b, 0xeb, 0x03, 0x58, 0x4d, 0x4d, 0xe0, 0xa2,
-	0x43, 0xd7, 0x7e, 0x05, 0x2f, 0x2f, 0x55, 0x8d, 0x3f, 0x85, 0xcd, 0xa9, 0x6d, 0xda, 0x01, 0xf5,
-	0x5c, 0x8f, 0xb2, 0x88, 0x15, 0x43, 0xc9, 0xff, 0x5e, 0x39, 0x27, 0xe6, 0x4e, 0x92, 0x6c, 0xa1,
-	0x45, 0xdd, 0x98, 0x2e, 0x82, 0x37, 0x4b, 0xc5, 0xff, 0xac, 0xa0, 0x67, 0xcf, 0x9e, 0x3d, 0xcb,
-	0xd4, 0x7e, 0x57, 0x80, 0xcd, 0x65, 0x7b, 0x66, 0xe9, 0xf6, 0xbd, 0x04, 0x05, 0x7b, 0x3a, 0x39,
-	0xa5, 0x1e, 0x77, 0x52, 0x5e, 0x0d, 0x5b, 0xb8, 0x01, 0x79, 0x8b, 0x9c, 0x52, 0x4b, 0xce, 0x6d,
-	0x4b, 0x3b, 0xd5, 0x5b, 0xef, 0x5c, 0x68, 0x57, 0xd6, 0x8f, 0x98, 0x88, 0x2a, 0x24, 0xf1, 0x47,
-	0x90, 0x0b, 0x53, 0x34, 0xd3, 0x70, 0xf3, 0x62, 0x1a, 0xd8, 0x5e, 0x52, 0xb9, 0x1c, 0x7e, 0x05,
-	0x4a, 0xec, 0x57, 0xc4, 0x46, 0x81, 0xdb, 0x5c, 0x64, 0x00, 0x8b, 0x0b, 0xbc, 0x05, 0x45, 0xbe,
-	0x4d, 0x0c, 0x1a, 0x1d, 0x6d, 0x71, 0x9b, 0x05, 0x96, 0x41, 0x87, 0x64, 0x6a, 0x05, 0xda, 0x63,
-	0x62, 0x4d, 0x29, 0x0f, 0xf8, 0x92, 0x5a, 0x09, 0xc1, 0x5f, 0x30, 0x0c, 0x5f, 0x85, 0xb2, 0xd8,
-	0x55, 0xa6, 0x6d, 0xd0, 0xa7, 0x3c, 0x7b, 0xe6, 0x55, 0xb1, 0xd1, 0xda, 0x0c, 0x61, 0xc3, 0x3f,
-	0xf4, 0x1d, 0x3b, 0x0a, 0x4d, 0x3e, 0x04, 0x03, 0xf8, 0xf0, 0x1f, 0xcc, 0x27, 0xee, 0xd7, 0x96,
-	0x4f, 0x6f, 0x3e, 0xa6, 0x6a, 0x7f, 0xc9, 0x40, 0x8e, 0xe7, 0x8b, 0x35, 0x28, 0x0f, 0x3e, 0xeb,
-	0x29, 0x5a, 0xab, 0x7b, 0xb2, 0x7f, 0xa4, 0x20, 0x09, 0x57, 0x01, 0x38, 0xf0, 0xe0, 0xa8, 0xdb,
-	0x18, 0xa0, 0x4c, 0xdc, 0x6e, 0x77, 0x06, 0x77, 0x6f, 0xa3, 0x6c, 0x2c, 0x70, 0x22, 0x80, 0x5c,
-	0x92, 0xf0, 0xfe, 0x2d, 0x94, 0xc7, 0x08, 0x2a, 0x42, 0x41, 0xfb, 0x53, 0xa5, 0x75, 0xf7, 0x36,
-	0x2a, 0xa4, 0x91, 0xf7, 0x6f, 0xa1, 0x15, 0xbc, 0x0a, 0x25, 0x8e, 0xec, 0x77, 0xbb, 0x47, 0xa8,
-	0x18, 0xeb, 0xec, 0x0f, 0xd4, 0x76, 0xe7, 0x00, 0x95, 0x62, 0x9d, 0x07, 0x6a, 0xf7, 0xa4, 0x87,
-	0x20, 0xd6, 0x70, 0xac, 0xf4, 0xfb, 0x8d, 0x03, 0x05, 0x95, 0x63, 0xc6, 0xfe, 0x67, 0x03, 0xa5,
-	0x8f, 0x2a, 0x29, 0xb3, 0xde, 0xbf, 0x85, 0x56, 0xe3, 0x21, 0x94, 0xce, 0xc9, 0x31, 0xaa, 0xe2,
-	0x75, 0x58, 0x15, 0x43, 0x44, 0x46, 0xac, 0xcd, 0x41, 0x77, 0x6f, 0x23, 0x34, 0x33, 0x44, 0x68,
-	0x59, 0x4f, 0x01, 0x77, 0x6f, 0x23, 0x5c, 0x6b, 0x42, 0x9e, 0x47, 0x17, 0xc6, 0x50, 0x3d, 0x6a,
-	0xec, 0x2b, 0x47, 0x5a, 0xb7, 0x37, 0x68, 0x77, 0x3b, 0x8d, 0x23, 0x24, 0xcd, 0x30, 0x55, 0xf9,
-	0xf9, 0x49, 0x5b, 0x55, 0x5a, 0x28, 0x93, 0xc4, 0x7a, 0x4a, 0x63, 0xa0, 0xb4, 0x50, 0xb6, 0xa6,
-	0xc3, 0xe6, 0xb2, 0x3c, 0xb9, 0x74, 0x67, 0x24, 0x96, 0x38, 0x73, 0xce, 0x12, 0x73, 0x5d, 0x0b,
-	0x4b, 0xfc, 0xcf, 0x0c, 0x6c, 0x2c, 0x39, 0x2b, 0x96, 0x0e, 0xf2, 0x13, 0xc8, 0x8b, 0x10, 0x15,
-	0xa7, 0xe7, 0x8d, 0xa5, 0x87, 0x0e, 0x0f, 0xd8, 0x85, 0x13, 0x94, 0xcb, 0x25, 0x2b, 0x88, 0xec,
-	0x39, 0x15, 0x04, 0x53, 0xb1, 0x90, 0xd3, 0x7f, 0xb9, 0x90, 0xd3, 0xc5, 0xb1, 0x77, 0xf7, 0x22,
-	0xc7, 0x1e, 0xc7, 0xbe, 0x5b, 0x6e, 0xcf, 0x2f, 0xc9, 0xed, 0xf7, 0x61, 0x7d, 0x41, 0xd1, 0x85,
-	0x73, 0xec, 0xaf, 0x25, 0x90, 0xcf, 0x73, 0xce, 0x73, 0x32, 0x5d, 0x26, 0x95, 0xe9, 0xee, 0xcf,
-	0x7b, 0xf0, 0xda, 0xf9, 0x8b, 0xb0, 0xb0, 0xd6, 0x5f, 0x49, 0x70, 0x69, 0x79, 0xa5, 0xb8, 0xd4,
-	0x86, 0x8f, 0xa0, 0x30, 0xa1, 0xc1, 0xd8, 0x89, 0xaa, 0xa5, 0xb7, 0x97, 0x9c, 0xc1, 0xac, 0x7b,
-	0x7e, 0xb1, 0x43, 0xa9, 0xe4, 0x21, 0x9e, 0x3d, 0xaf, 0xdc, 0x13, 0xd6, 0x2c, 0x58, 0xfa, 0x9b,
-	0x0c, 0xbc, 0xbc, 0x54, 0xf9, 0x52, 0x43, 0x5f, 0x03, 0x30, 0x6d, 0x77, 0x1a, 0x88, 0x8a, 0x48,
-	0x24, 0xd8, 0x12, 0x47, 0x78, 0xf2, 0x62, 0xc9, 0x73, 0x1a, 0xc4, 0xfd, 0x59, 0xde, 0x0f, 0x02,
-	0xe2, 0x84, 0x7b, 0x33, 0x43, 0x73, 0xdc, 0xd0, 0xd7, 0xcf, 0x99, 0xe9, 0x42, 0x60, 0xbe, 0x07,
-	0x48, 0xb7, 0x4c, 0x6a, 0x07, 0x9a, 0x1f, 0x78, 0x94, 0x4c, 0x4c, 0x7b, 0xc4, 0x4f, 0x90, 0xe2,
-	0x5e, 0x7e, 0x48, 0x2c, 0x9f, 0xaa, 0x6b, 0xa2, 0xbb, 0x1f, 0xf5, 0x32, 0x09, 0x1e, 0x40, 0x5e,
-	0x42, 0xa2, 0x90, 0x92, 0x10, 0xdd, 0xb1, 0x44, 0xed, 0xeb, 0x22, 0x94, 0x13, 0x75, 0x35, 0xbe,
-	0x06, 0x95, 0x87, 0xe4, 0x31, 0xd1, 0xa2, 0xbb, 0x92, 0xf0, 0x44, 0x99, 0x61, 0xbd, 0xf0, 0xbe,
-	0xf4, 0x1e, 0x6c, 0x72, 0x8a, 0x33, 0x0d, 0xa8, 0xa7, 0xe9, 0x16, 0xf1, 0x7d, 0xee, 0xb4, 0x22,
-	0xa7, 0x62, 0xd6, 0xd7, 0x65, 0x5d, 0xcd, 0xa8, 0x07, 0xdf, 0x81, 0x0d, 0x2e, 0x31, 0x99, 0x5a,
-	0x81, 0xe9, 0x5a, 0x54, 0x63, 0xb7, 0x37, 0x9f, 0x9f, 0x24, 0xb1, 0x65, 0xeb, 0x8c, 0x71, 0x1c,
-	0x12, 0x98, 0x45, 0x3e, 0x6e, 0xc1, 0x6b, 0x5c, 0x6c, 0x44, 0x6d, 0xea, 0x91, 0x80, 0x6a, 0xf4,
-	0x8b, 0x29, 0xb1, 0x7c, 0x8d, 0xd8, 0x86, 0x36, 0x26, 0xfe, 0x58, 0xde, 0x64, 0x0a, 0xf6, 0x33,
-	0xb2, 0xa4, 0x5e, 0x61, 0xc4, 0x83, 0x90, 0xa7, 0x70, 0x5a, 0xc3, 0x36, 0x3e, 0x26, 0xfe, 0x18,
-	0xef, 0xc1, 0x25, 0xae, 0xc5, 0x0f, 0x3c, 0xd3, 0x1e, 0x69, 0xfa, 0x98, 0xea, 0x8f, 0xb4, 0x69,
-	0x30, 0xbc, 0x27, 0xbf, 0x92, 0x1c, 0x9f, 0x5b, 0xd8, 0xe7, 0x9c, 0x26, 0xa3, 0x9c, 0x04, 0xc3,
-	0x7b, 0xb8, 0x0f, 0x15, 0xb6, 0x18, 0x13, 0xf3, 0x4b, 0xaa, 0x0d, 0x1d, 0x8f, 0x1f, 0x8d, 0xd5,
-	0x25, 0xa9, 0x29, 0xe1, 0xc1, 0x7a, 0x37, 0x14, 0x38, 0x76, 0x0c, 0xba, 0x97, 0xef, 0xf7, 0x14,
-	0xa5, 0xa5, 0x96, 0x23, 0x2d, 0x0f, 0x1c, 0x8f, 0x05, 0xd4, 0xc8, 0x89, 0x1d, 0x5c, 0x16, 0x01,
-	0x35, 0x72, 0x22, 0xf7, 0xde, 0x81, 0x0d, 0x5d, 0x17, 0x73, 0x36, 0x75, 0x2d, 0xbc, 0x63, 0xf9,
-	0x32, 0x4a, 0x39, 0x4b, 0xd7, 0x0f, 0x04, 0x21, 0x8c, 0x71, 0x1f, 0x7f, 0x08, 0x2f, 0xcf, 0x9c,
-	0x95, 0x14, 0x5c, 0x5f, 0x98, 0xe5, 0xbc, 0xe8, 0x1d, 0xd8, 0x70, 0xcf, 0x16, 0x05, 0x71, 0x6a,
-	0x44, 0xf7, 0x6c, 0x5e, 0xec, 0x03, 0xd8, 0x74, 0xc7, 0xee, 0xa2, 0xdc, 0xcd, 0xa4, 0x1c, 0x76,
-	0xc7, 0xee, 0xbc, 0xe0, 0x5b, 0xfc, 0xc2, 0xed, 0x51, 0x9d, 0x04, 0xd4, 0x90, 0x2f, 0x27, 0xe9,
-	0x89, 0x0e, 0xbc, 0x0b, 0x48, 0xd7, 0x35, 0x6a, 0x93, 0x53, 0x8b, 0x6a, 0xc4, 0xa3, 0x36, 0xf1,
-	0xe5, 0xab, 0x49, 0x72, 0x55, 0xd7, 0x15, 0xde, 0xdb, 0xe0, 0x9d, 0xf8, 0x26, 0xac, 0x3b, 0xa7,
-	0x0f, 0x75, 0x11, 0x92, 0x9a, 0xeb, 0xd1, 0xa1, 0xf9, 0x54, 0x7e, 0x93, 0xfb, 0x77, 0x8d, 0x75,
-	0xf0, 0x80, 0xec, 0x71, 0x18, 0xdf, 0x00, 0xa4, 0xfb, 0x63, 0xe2, 0xb9, 0x3c, 0x27, 0xfb, 0x2e,
-	0xd1, 0xa9, 0xfc, 0x96, 0xa0, 0x0a, 0xbc, 0x13, 0xc1, 0x6c, 0x4b, 0xf8, 0x4f, 0xcc, 0x61, 0x10,
-	0x69, 0xbc, 0x2e, 0xb6, 0x04, 0xc7, 0x42, 0x6d, 0x3b, 0x80, 0x98, 0x2b, 0x52, 0x03, 0xef, 0x70,
-	0x5a, 0xd5, 0x1d, 0xbb, 0xc9, 0x71, 0xdf, 0x80, 0x55, 0xc6, 0x9c, 0x0d, 0x7a, 0x43, 0x14, 0x64,
-	0xee, 0x38, 0x31, 0xe2, 0x0f, 0x56, 0x1b, 0xd7, 0xf6, 0xa0, 0x92, 0x8c, 0x4f, 0x5c, 0x02, 0x11,
-	0xa1, 0x48, 0x62, 0xc5, 0x4a, 0xb3, 0xdb, 0x62, 0x65, 0xc6, 0xe7, 0x0a, 0xca, 0xb0, 0x72, 0xe7,
-	0xa8, 0x3d, 0x50, 0x34, 0xf5, 0xa4, 0x33, 0x68, 0x1f, 0x2b, 0x28, 0x9b, 0xa8, 0xab, 0x0f, 0x73,
-	0xc5, 0xb7, 0xd1, 0xf5, 0xda, 0x37, 0x19, 0xa8, 0xa6, 0x2f, 0x4a, 0xf8, 0xff, 0xe1, 0x72, 0xf4,
-	0xaa, 0xe1, 0xd3, 0x40, 0x7b, 0x62, 0x7a, 0x7c, 0xe3, 0x4c, 0x88, 0x38, 0xc4, 0xe2, 0xa5, 0xdb,
-	0x0c, 0x59, 0x7d, 0x1a, 0x7c, 0x62, 0x7a, 0x6c, 0x5b, 0x4c, 0x48, 0x80, 0x8f, 0xe0, 0xaa, 0xed,
-	0x68, 0x7e, 0x40, 0x6c, 0x83, 0x78, 0x86, 0x36, 0x7b, 0x4f, 0xd2, 0x88, 0xae, 0x53, 0xdf, 0x77,
-	0xc4, 0x81, 0x15, 0x6b, 0x79, 0xd5, 0x76, 0xfa, 0x21, 0x79, 0x96, 0xc9, 0x1b, 0x21, 0x75, 0x2e,
-	0xcc, 0xb2, 0xe7, 0x85, 0xd9, 0x2b, 0x50, 0x9a, 0x10, 0x57, 0xa3, 0x76, 0xe0, 0x9d, 0xf1, 0xf2,
-	0xb8, 0xa8, 0x16, 0x27, 0xc4, 0x55, 0x58, 0xfb, 0x85, 0xdc, 0x52, 0x0e, 0x73, 0xc5, 0x22, 0x2a,
-	0x1d, 0xe6, 0x8a, 0x25, 0x04, 0xb5, 0x7f, 0x64, 0xa1, 0x92, 0x2c, 0x97, 0xd9, 0xed, 0x43, 0xe7,
-	0x27, 0x8b, 0xc4, 0x73, 0xcf, 0x1b, 0xdf, 0x5a, 0x5c, 0xd7, 0x9b, 0xec, 0xc8, 0xd9, 0x2b, 0x88,
-	0x22, 0x56, 0x15, 0x92, 0xec, 0xb8, 0x67, 0xd9, 0x86, 0x8a, 0xa2, 0xa1, 0xa8, 0x86, 0x2d, 0x7c,
-	0x00, 0x85, 0x87, 0x3e, 0xd7, 0x5d, 0xe0, 0xba, 0xdf, 0xfc, 0x76, 0xdd, 0x87, 0x7d, 0xae, 0xbc,
-	0x74, 0xd8, 0xd7, 0x3a, 0x5d, 0xf5, 0xb8, 0x71, 0xa4, 0x86, 0xe2, 0xf8, 0x0a, 0xe4, 0x2c, 0xf2,
-	0xe5, 0x59, 0xfa, 0x70, 0xe2, 0xd0, 0x45, 0x17, 0xe1, 0x0a, 0xe4, 0x9e, 0x50, 0xf2, 0x28, 0x7d,
-	0x24, 0x70, 0xe8, 0x07, 0xdc, 0x0c, 0xbb, 0x90, 0xe7, 0xfe, 0xc2, 0x00, 0xa1, 0xc7, 0xd0, 0x4b,
-	0xb8, 0x08, 0xb9, 0x66, 0x57, 0x65, 0x1b, 0x02, 0x41, 0x45, 0xa0, 0x5a, 0xaf, 0xad, 0x34, 0x15,
-	0x94, 0xa9, 0xdd, 0x81, 0x82, 0x70, 0x02, 0xdb, 0x2c, 0xb1, 0x1b, 0xd0, 0x4b, 0x61, 0x33, 0xd4,
-	0x21, 0x45, 0xbd, 0x27, 0xc7, 0xfb, 0x8a, 0x8a, 0x32, 0xe9, 0xa5, 0xce, 0xa1, 0x7c, 0xcd, 0x87,
-	0x4a, 0xb2, 0x5e, 0x7e, 0x31, 0x77, 0xe1, 0xbf, 0x4a, 0x50, 0x4e, 0xd4, 0xbf, 0xac, 0x70, 0x21,
-	0x96, 0xe5, 0x3c, 0xd1, 0x88, 0x65, 0x12, 0x3f, 0x0c, 0x0d, 0xe0, 0x50, 0x83, 0x21, 0x17, 0x5d,
-	0xba, 0x17, 0xb4, 0x45, 0xf2, 0xa8, 0x50, 0xfb, 0xa3, 0x04, 0x68, 0xbe, 0x00, 0x9d, 0x33, 0x53,
-	0xfa, 0x31, 0xcd, 0xac, 0xfd, 0x41, 0x82, 0x6a, 0xba, 0xea, 0x9c, 0x33, 0xef, 0xda, 0x8f, 0x6a,
-	0xde, 0xdf, 0x33, 0xb0, 0x9a, 0xaa, 0x35, 0x2f, 0x6a, 0xdd, 0x17, 0xb0, 0x6e, 0x1a, 0x74, 0xe2,
-	0x3a, 0x01, 0xb5, 0xf5, 0x33, 0xcd, 0xa2, 0x8f, 0xa9, 0x25, 0xd7, 0x78, 0xd2, 0xd8, 0xfd, 0xf6,
-	0x6a, 0xb6, 0xde, 0x9e, 0xc9, 0x1d, 0x31, 0xb1, 0xbd, 0x8d, 0x76, 0x4b, 0x39, 0xee, 0x75, 0x07,
-	0x4a, 0xa7, 0xf9, 0x99, 0x76, 0xd2, 0xf9, 0x59, 0xa7, 0xfb, 0x49, 0x47, 0x45, 0xe6, 0x1c, 0xed,
-	0x07, 0xdc, 0xf6, 0x3d, 0x40, 0xf3, 0x46, 0xe1, 0xcb, 0xb0, 0xcc, 0x2c, 0xf4, 0x12, 0xde, 0x80,
-	0xb5, 0x4e, 0x57, 0xeb, 0xb7, 0x5b, 0x8a, 0xa6, 0x3c, 0x78, 0xa0, 0x34, 0x07, 0x7d, 0xf1, 0x3e,
-	0x11, 0xb3, 0x07, 0xa9, 0x0d, 0x5e, 0xfb, 0x7d, 0x16, 0x36, 0x96, 0x58, 0x82, 0x1b, 0xe1, 0xcd,
-	0x42, 0x5c, 0x76, 0xde, 0xbd, 0x88, 0xf5, 0x75, 0x56, 0x10, 0xf4, 0x88, 0x17, 0x84, 0x17, 0x91,
-	0x1b, 0xc0, 0xbc, 0x64, 0x07, 0xe6, 0xd0, 0xa4, 0x5e, 0xf8, 0x9c, 0x23, 0xae, 0x1b, 0x6b, 0x33,
-	0x5c, 0xbc, 0xe8, 0xfc, 0x1f, 0x60, 0xd7, 0xf1, 0xcd, 0xc0, 0x7c, 0x4c, 0x35, 0xd3, 0x8e, 0xde,
-	0x7e, 0xd8, 0xf5, 0x23, 0xa7, 0xa2, 0xa8, 0xa7, 0x6d, 0x07, 0x31, 0xdb, 0xa6, 0x23, 0x32, 0xc7,
-	0x66, 0xc9, 0x3c, 0xab, 0xa2, 0xa8, 0x27, 0x66, 0x5f, 0x83, 0x8a, 0xe1, 0x4c, 0x59, 0x4d, 0x26,
-	0x78, 0xec, 0xec, 0x90, 0xd4, 0xb2, 0xc0, 0x62, 0x4a, 0x58, 0x6d, 0xcf, 0x1e, 0x9d, 0x2a, 0x6a,
-	0x59, 0x60, 0x82, 0x72, 0x1d, 0xd6, 0xc8, 0x68, 0xe4, 0x31, 0xe5, 0x91, 0x22, 0x71, 0x7f, 0xa8,
-	0xc6, 0x30, 0x27, 0x6e, 0x1d, 0x42, 0x31, 0xf2, 0x03, 0x3b, 0xaa, 0x99, 0x27, 0x34, 0x57, 0x5c,
-	0x8a, 0x33, 0x3b, 0x25, 0xb5, 0x68, 0x47, 0x9d, 0xd7, 0xa0, 0x62, 0xfa, 0xda, 0xec, 0x0d, 0x3d,
-	0xb3, 0x9d, 0xd9, 0x29, 0xaa, 0x65, 0xd3, 0x8f, 0xdf, 0x1f, 0x6b, 0x5f, 0x65, 0xa0, 0x9a, 0xfe,
-	0x06, 0x80, 0x5b, 0x50, 0xb4, 0x1c, 0x9d, 0xf0, 0xd0, 0x12, 0x1f, 0xa0, 0x76, 0x9e, 0xf3, 0xd9,
-	0xa0, 0x7e, 0x14, 0xf2, 0xd5, 0x58, 0x72, 0xeb, 0x6f, 0x12, 0x14, 0x23, 0x18, 0x5f, 0x82, 0x9c,
-	0x4b, 0x82, 0x31, 0x57, 0x97, 0xdf, 0xcf, 0x20, 0x49, 0xe5, 0x6d, 0x86, 0xfb, 0x2e, 0xb1, 0x79,
-	0x08, 0x84, 0x38, 0x6b, 0xb3, 0x75, 0xb5, 0x28, 0x31, 0xf8, 0xe5, 0xc4, 0x99, 0x4c, 0xa8, 0x1d,
-	0xf8, 0xd1, 0xba, 0x86, 0x78, 0x33, 0x84, 0xf1, 0x3b, 0xb0, 0x1e, 0x78, 0xc4, 0xb4, 0x52, 0xdc,
-	0x1c, 0xe7, 0xa2, 0xa8, 0x23, 0x26, 0xef, 0xc1, 0x95, 0x48, 0xaf, 0x41, 0x03, 0xa2, 0x8f, 0xa9,
-	0x31, 0x13, 0x2a, 0xf0, 0x47, 0x88, 0xcb, 0x21, 0xa1, 0x15, 0xf6, 0x47, 0xb2, 0xb5, 0x6f, 0x24,
-	0x58, 0x8f, 0xae, 0x53, 0x46, 0xec, 0xac, 0x63, 0x00, 0x62, 0xdb, 0x4e, 0x90, 0x74, 0xd7, 0x62,
-	0x28, 0x2f, 0xc8, 0xd5, 0x1b, 0xb1, 0x90, 0x9a, 0x50, 0xb0, 0x35, 0x01, 0x98, 0xf5, 0x9c, 0xeb,
-	0xb6, 0xab, 0x50, 0x0e, 0x3f, 0xf0, 0xf0, 0xaf, 0x84, 0xe2, 0x02, 0x0e, 0x02, 0x62, 0xf7, 0x2e,
-	0xbc, 0x09, 0xf9, 0x53, 0x3a, 0x32, 0xed, 0xf0, 0xd9, 0x56, 0x34, 0xa2, 0x67, 0x92, 0x5c, 0xfc,
-	0x4c, 0xb2, 0xff, 0x5b, 0x09, 0x36, 0x74, 0x67, 0x32, 0x6f, 0xef, 0x3e, 0x9a, 0x7b, 0x05, 0xf0,
-	0x3f, 0x96, 0x3e, 0xff, 0x68, 0x64, 0x06, 0xe3, 0xe9, 0x69, 0x5d, 0x77, 0x26, 0xbb, 0x23, 0xc7,
-	0x22, 0xf6, 0x68, 0xf6, 0x99, 0x93, 0xff, 0xd1, 0xdf, 0x1d, 0x51, 0xfb, 0xdd, 0x91, 0x93, 0xf8,
-	0xe8, 0x79, 0x7f, 0xf6, 0xf7, 0xbf, 0x92, 0xf4, 0xa7, 0x4c, 0xf6, 0xa0, 0xb7, 0xff, 0xe7, 0xcc,
-	0xd6, 0x81, 0x18, 0xae, 0x17, 0xb9, 0x47, 0xa5, 0x43, 0x8b, 0xea, 0x6c, 0xca, 0xff, 0x0b, 0x00,
-	0x00, 0xff, 0xff, 0x1a, 0x28, 0x25, 0x79, 0x42, 0x1d, 0x00, 0x00,
+type FileDescriptorSet = descriptorpb.FileDescriptorSet
+type FileDescriptorProto = descriptorpb.FileDescriptorProto
+type DescriptorProto = descriptorpb.DescriptorProto
+type ExtensionRangeOptions = descriptorpb.ExtensionRangeOptions
+type FieldDescriptorProto = descriptorpb.FieldDescriptorProto
+type OneofDescriptorProto = descriptorpb.OneofDescriptorProto
+type EnumDescriptorProto = descriptorpb.EnumDescriptorProto
+type EnumValueDescriptorProto = descriptorpb.EnumValueDescriptorProto
+type ServiceDescriptorProto = descriptorpb.ServiceDescriptorProto
+type MethodDescriptorProto = descriptorpb.MethodDescriptorProto
+
+const Default_MethodDescriptorProto_ClientStreaming = descriptorpb.Default_MethodDescriptorProto_ClientStreaming
+const Default_MethodDescriptorProto_ServerStreaming = descriptorpb.Default_MethodDescriptorProto_ServerStreaming
+
+type FileOptions = descriptorpb.FileOptions
+
+const Default_FileOptions_JavaMultipleFiles = descriptorpb.Default_FileOptions_JavaMultipleFiles
+const Default_FileOptions_JavaStringCheckUtf8 = descriptorpb.Default_FileOptions_JavaStringCheckUtf8
+const Default_FileOptions_OptimizeFor = descriptorpb.Default_FileOptions_OptimizeFor
+const Default_FileOptions_CcGenericServices = descriptorpb.Default_FileOptions_CcGenericServices
+const Default_FileOptions_JavaGenericServices = descriptorpb.Default_FileOptions_JavaGenericServices
+const Default_FileOptions_PyGenericServices = descriptorpb.Default_FileOptions_PyGenericServices
+const Default_FileOptions_PhpGenericServices = descriptorpb.Default_FileOptions_PhpGenericServices
+const Default_FileOptions_Deprecated = descriptorpb.Default_FileOptions_Deprecated
+const Default_FileOptions_CcEnableArenas = descriptorpb.Default_FileOptions_CcEnableArenas
+
+type MessageOptions = descriptorpb.MessageOptions
+
+const Default_MessageOptions_MessageSetWireFormat = descriptorpb.Default_MessageOptions_MessageSetWireFormat
+const Default_MessageOptions_NoStandardDescriptorAccessor = descriptorpb.Default_MessageOptions_NoStandardDescriptorAccessor
+const Default_MessageOptions_Deprecated = descriptorpb.Default_MessageOptions_Deprecated
+
+type FieldOptions = descriptorpb.FieldOptions
+
+const Default_FieldOptions_Ctype = descriptorpb.Default_FieldOptions_Ctype
+const Default_FieldOptions_Jstype = descriptorpb.Default_FieldOptions_Jstype
+const Default_FieldOptions_Lazy = descriptorpb.Default_FieldOptions_Lazy
+const Default_FieldOptions_Deprecated = descriptorpb.Default_FieldOptions_Deprecated
+const Default_FieldOptions_Weak = descriptorpb.Default_FieldOptions_Weak
+
+type OneofOptions = descriptorpb.OneofOptions
+type EnumOptions = descriptorpb.EnumOptions
+
+const Default_EnumOptions_Deprecated = descriptorpb.Default_EnumOptions_Deprecated
+
+type EnumValueOptions = descriptorpb.EnumValueOptions
+
+const Default_EnumValueOptions_Deprecated = descriptorpb.Default_EnumValueOptions_Deprecated
+
+type ServiceOptions = descriptorpb.ServiceOptions
+
+const Default_ServiceOptions_Deprecated = descriptorpb.Default_ServiceOptions_Deprecated
+
+type MethodOptions = descriptorpb.MethodOptions
+
+const Default_MethodOptions_Deprecated = descriptorpb.Default_MethodOptions_Deprecated
+const Default_MethodOptions_IdempotencyLevel = descriptorpb.Default_MethodOptions_IdempotencyLevel
+
+type UninterpretedOption = descriptorpb.UninterpretedOption
+type SourceCodeInfo = descriptorpb.SourceCodeInfo
+type GeneratedCodeInfo = descriptorpb.GeneratedCodeInfo
+type DescriptorProto_ExtensionRange = descriptorpb.DescriptorProto_ExtensionRange
+type DescriptorProto_ReservedRange = descriptorpb.DescriptorProto_ReservedRange
+type EnumDescriptorProto_EnumReservedRange = descriptorpb.EnumDescriptorProto_EnumReservedRange
+type UninterpretedOption_NamePart = descriptorpb.UninterpretedOption_NamePart
+type SourceCodeInfo_Location = descriptorpb.SourceCodeInfo_Location
+type GeneratedCodeInfo_Annotation = descriptorpb.GeneratedCodeInfo_Annotation
+
+var File_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto protoreflect.FileDescriptor
+
+var file_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_rawDesc = []byte{
+	0x0a, 0x44, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
+	0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x64, 0x65, 0x73, 0x63, 0x72,
+	0x69, 0x70, 0x74, 0x6f, 0x72, 0x2f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x20, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74,
+	0x6f, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x42, 0x40, 0x5a, 0x3e, 0x67, 0x69, 0x74, 0x68,
+	0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65,
+	0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x3b,
+	0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x00, 0x62, 0x06, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x32,
+}
+
+var file_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_goTypes = []interface{}{}
+var file_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_init() }
+func file_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_init() {
+	if File_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto != nil {
+		return
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   0,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_goTypes,
+		DependencyIndexes: file_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_depIdxs,
+	}.Build()
+	File_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto = out.File
+	file_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_rawDesc = nil
+	file_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_goTypes = nil
+	file_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_depIdxs = nil
 }
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.proto b/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.proto
deleted file mode 100644
index 8697a50de..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.proto
+++ /dev/null
@@ -1,872 +0,0 @@
-// Protocol Buffers - Google's data interchange format
-// Copyright 2008 Google Inc.  All rights reserved.
-// https://developers.google.com/protocol-buffers/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Author: kenton@google.com (Kenton Varda)
-//  Based on original Protocol Buffers design by
-//  Sanjay Ghemawat, Jeff Dean, and others.
-//
-// The messages in this file describe the definitions found in .proto files.
-// A valid .proto file can be translated directly to a FileDescriptorProto
-// without any other information (e.g. without reading its imports).
-
-
-syntax = "proto2";
-
-package google.protobuf;
-option go_package = "github.com/golang/protobuf/protoc-gen-go/descriptor;descriptor";
-option java_package = "com.google.protobuf";
-option java_outer_classname = "DescriptorProtos";
-option csharp_namespace = "Google.Protobuf.Reflection";
-option objc_class_prefix = "GPB";
-option cc_enable_arenas = true;
-
-// descriptor.proto must be optimized for speed because reflection-based
-// algorithms don't work during bootstrapping.
-option optimize_for = SPEED;
-
-// The protocol compiler can output a FileDescriptorSet containing the .proto
-// files it parses.
-message FileDescriptorSet {
-  repeated FileDescriptorProto file = 1;
-}
-
-// Describes a complete .proto file.
-message FileDescriptorProto {
-  optional string name = 1;       // file name, relative to root of source tree
-  optional string package = 2;    // e.g. "foo", "foo.bar", etc.
-
-  // Names of files imported by this file.
-  repeated string dependency = 3;
-  // Indexes of the public imported files in the dependency list above.
-  repeated int32 public_dependency = 10;
-  // Indexes of the weak imported files in the dependency list.
-  // For Google-internal migration only. Do not use.
-  repeated int32 weak_dependency = 11;
-
-  // All top-level definitions in this file.
-  repeated DescriptorProto message_type = 4;
-  repeated EnumDescriptorProto enum_type = 5;
-  repeated ServiceDescriptorProto service = 6;
-  repeated FieldDescriptorProto extension = 7;
-
-  optional FileOptions options = 8;
-
-  // This field contains optional information about the original source code.
-  // You may safely remove this entire field without harming runtime
-  // functionality of the descriptors -- the information is needed only by
-  // development tools.
-  optional SourceCodeInfo source_code_info = 9;
-
-  // The syntax of the proto file.
-  // The supported values are "proto2" and "proto3".
-  optional string syntax = 12;
-}
-
-// Describes a message type.
-message DescriptorProto {
-  optional string name = 1;
-
-  repeated FieldDescriptorProto field = 2;
-  repeated FieldDescriptorProto extension = 6;
-
-  repeated DescriptorProto nested_type = 3;
-  repeated EnumDescriptorProto enum_type = 4;
-
-  message ExtensionRange {
-    optional int32 start = 1;
-    optional int32 end = 2;
-
-    optional ExtensionRangeOptions options = 3;
-  }
-  repeated ExtensionRange extension_range = 5;
-
-  repeated OneofDescriptorProto oneof_decl = 8;
-
-  optional MessageOptions options = 7;
-
-  // Range of reserved tag numbers. Reserved tag numbers may not be used by
-  // fields or extension ranges in the same message. Reserved ranges may
-  // not overlap.
-  message ReservedRange {
-    optional int32 start = 1; // Inclusive.
-    optional int32 end = 2;   // Exclusive.
-  }
-  repeated ReservedRange reserved_range = 9;
-  // Reserved field names, which may not be used by fields in the same message.
-  // A given name may only be reserved once.
-  repeated string reserved_name = 10;
-}
-
-message ExtensionRangeOptions {
-  // The parser stores options it doesn't recognize here. See above.
-  repeated UninterpretedOption uninterpreted_option = 999;
-
-  // Clients can define custom options in extensions of this message. See above.
-  extensions 1000 to max;
-}
-
-// Describes a field within a message.
-message FieldDescriptorProto {
-  enum Type {
-    // 0 is reserved for errors.
-    // Order is weird for historical reasons.
-    TYPE_DOUBLE         = 1;
-    TYPE_FLOAT          = 2;
-    // Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT64 if
-    // negative values are likely.
-    TYPE_INT64          = 3;
-    TYPE_UINT64         = 4;
-    // Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT32 if
-    // negative values are likely.
-    TYPE_INT32          = 5;
-    TYPE_FIXED64        = 6;
-    TYPE_FIXED32        = 7;
-    TYPE_BOOL           = 8;
-    TYPE_STRING         = 9;
-    // Tag-delimited aggregate.
-    // Group type is deprecated and not supported in proto3. However, Proto3
-    // implementations should still be able to parse the group wire format and
-    // treat group fields as unknown fields.
-    TYPE_GROUP          = 10;
-    TYPE_MESSAGE        = 11;  // Length-delimited aggregate.
-
-    // New in version 2.
-    TYPE_BYTES          = 12;
-    TYPE_UINT32         = 13;
-    TYPE_ENUM           = 14;
-    TYPE_SFIXED32       = 15;
-    TYPE_SFIXED64       = 16;
-    TYPE_SINT32         = 17;  // Uses ZigZag encoding.
-    TYPE_SINT64         = 18;  // Uses ZigZag encoding.
-  };
-
-  enum Label {
-    // 0 is reserved for errors
-    LABEL_OPTIONAL      = 1;
-    LABEL_REQUIRED      = 2;
-    LABEL_REPEATED      = 3;
-  };
-
-  optional string name = 1;
-  optional int32 number = 3;
-  optional Label label = 4;
-
-  // If type_name is set, this need not be set.  If both this and type_name
-  // are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.
-  optional Type type = 5;
-
-  // For message and enum types, this is the name of the type.  If the name
-  // starts with a '.', it is fully-qualified.  Otherwise, C++-like scoping
-  // rules are used to find the type (i.e. first the nested types within this
-  // message are searched, then within the parent, on up to the root
-  // namespace).
-  optional string type_name = 6;
-
-  // For extensions, this is the name of the type being extended.  It is
-  // resolved in the same manner as type_name.
-  optional string extendee = 2;
-
-  // For numeric types, contains the original text representation of the value.
-  // For booleans, "true" or "false".
-  // For strings, contains the default text contents (not escaped in any way).
-  // For bytes, contains the C escaped value.  All bytes >= 128 are escaped.
-  // TODO(kenton):  Base-64 encode?
-  optional string default_value = 7;
-
-  // If set, gives the index of a oneof in the containing type's oneof_decl
-  // list.  This field is a member of that oneof.
-  optional int32 oneof_index = 9;
-
-  // JSON name of this field. The value is set by protocol compiler. If the
-  // user has set a "json_name" option on this field, that option's value
-  // will be used. Otherwise, it's deduced from the field's name by converting
-  // it to camelCase.
-  optional string json_name = 10;
-
-  optional FieldOptions options = 8;
-}
-
-// Describes a oneof.
-message OneofDescriptorProto {
-  optional string name = 1;
-  optional OneofOptions options = 2;
-}
-
-// Describes an enum type.
-message EnumDescriptorProto {
-  optional string name = 1;
-
-  repeated EnumValueDescriptorProto value = 2;
-
-  optional EnumOptions options = 3;
-
-  // Range of reserved numeric values. Reserved values may not be used by
-  // entries in the same enum. Reserved ranges may not overlap.
-  //
-  // Note that this is distinct from DescriptorProto.ReservedRange in that it
-  // is inclusive such that it can appropriately represent the entire int32
-  // domain.
-  message EnumReservedRange {
-    optional int32 start = 1; // Inclusive.
-    optional int32 end = 2;   // Inclusive.
-  }
-
-  // Range of reserved numeric values. Reserved numeric values may not be used
-  // by enum values in the same enum declaration. Reserved ranges may not
-  // overlap.
-  repeated EnumReservedRange reserved_range = 4;
-
-  // Reserved enum value names, which may not be reused. A given name may only
-  // be reserved once.
-  repeated string reserved_name = 5;
-}
-
-// Describes a value within an enum.
-message EnumValueDescriptorProto {
-  optional string name = 1;
-  optional int32 number = 2;
-
-  optional EnumValueOptions options = 3;
-}
-
-// Describes a service.
-message ServiceDescriptorProto {
-  optional string name = 1;
-  repeated MethodDescriptorProto method = 2;
-
-  optional ServiceOptions options = 3;
-}
-
-// Describes a method of a service.
-message MethodDescriptorProto {
-  optional string name = 1;
-
-  // Input and output type names.  These are resolved in the same way as
-  // FieldDescriptorProto.type_name, but must refer to a message type.
-  optional string input_type = 2;
-  optional string output_type = 3;
-
-  optional MethodOptions options = 4;
-
-  // Identifies if client streams multiple client messages
-  optional bool client_streaming = 5 [default=false];
-  // Identifies if server streams multiple server messages
-  optional bool server_streaming = 6 [default=false];
-}
-
-
-// ===================================================================
-// Options
-
-// Each of the definitions above may have "options" attached.  These are
-// just annotations which may cause code to be generated slightly differently
-// or may contain hints for code that manipulates protocol messages.
-//
-// Clients may define custom options as extensions of the *Options messages.
-// These extensions may not yet be known at parsing time, so the parser cannot
-// store the values in them.  Instead it stores them in a field in the *Options
-// message called uninterpreted_option. This field must have the same name
-// across all *Options messages. We then use this field to populate the
-// extensions when we build a descriptor, at which point all protos have been
-// parsed and so all extensions are known.
-//
-// Extension numbers for custom options may be chosen as follows:
-// * For options which will only be used within a single application or
-//   organization, or for experimental options, use field numbers 50000
-//   through 99999.  It is up to you to ensure that you do not use the
-//   same number for multiple options.
-// * For options which will be published and used publicly by multiple
-//   independent entities, e-mail protobuf-global-extension-registry@google.com
-//   to reserve extension numbers. Simply provide your project name (e.g.
-//   Objective-C plugin) and your project website (if available) -- there's no
-//   need to explain how you intend to use them. Usually you only need one
-//   extension number. You can declare multiple options with only one extension
-//   number by putting them in a sub-message. See the Custom Options section of
-//   the docs for examples:
-//   https://developers.google.com/protocol-buffers/docs/proto#options
-//   If this turns out to be popular, a web service will be set up
-//   to automatically assign option numbers.
-
-
-message FileOptions {
-
-  // Sets the Java package where classes generated from this .proto will be
-  // placed.  By default, the proto package is used, but this is often
-  // inappropriate because proto packages do not normally start with backwards
-  // domain names.
-  optional string java_package = 1;
-
-
-  // If set, all the classes from the .proto file are wrapped in a single
-  // outer class with the given name.  This applies to both Proto1
-  // (equivalent to the old "--one_java_file" option) and Proto2 (where
-  // a .proto always translates to a single class, but you may want to
-  // explicitly choose the class name).
-  optional string java_outer_classname = 8;
-
-  // If set true, then the Java code generator will generate a separate .java
-  // file for each top-level message, enum, and service defined in the .proto
-  // file.  Thus, these types will *not* be nested inside the outer class
-  // named by java_outer_classname.  However, the outer class will still be
-  // generated to contain the file's getDescriptor() method as well as any
-  // top-level extensions defined in the file.
-  optional bool java_multiple_files = 10 [default=false];
-
-  // This option does nothing.
-  optional bool java_generate_equals_and_hash = 20 [deprecated=true];
-
-  // If set true, then the Java2 code generator will generate code that
-  // throws an exception whenever an attempt is made to assign a non-UTF-8
-  // byte sequence to a string field.
-  // Message reflection will do the same.
-  // However, an extension field still accepts non-UTF-8 byte sequences.
-  // This option has no effect on when used with the lite runtime.
-  optional bool java_string_check_utf8 = 27 [default=false];
-
-
-  // Generated classes can be optimized for speed or code size.
-  enum OptimizeMode {
-    SPEED = 1;        // Generate complete code for parsing, serialization,
-                      // etc.
-    CODE_SIZE = 2;    // Use ReflectionOps to implement these methods.
-    LITE_RUNTIME = 3; // Generate code using MessageLite and the lite runtime.
-  }
-  optional OptimizeMode optimize_for = 9 [default=SPEED];
-
-  // Sets the Go package where structs generated from this .proto will be
-  // placed. If omitted, the Go package will be derived from the following:
-  //   - The basename of the package import path, if provided.
-  //   - Otherwise, the package statement in the .proto file, if present.
-  //   - Otherwise, the basename of the .proto file, without extension.
-  optional string go_package = 11;
-
-
-
-  // Should generic services be generated in each language?  "Generic" services
-  // are not specific to any particular RPC system.  They are generated by the
-  // main code generators in each language (without additional plugins).
-  // Generic services were the only kind of service generation supported by
-  // early versions of google.protobuf.
-  //
-  // Generic services are now considered deprecated in favor of using plugins
-  // that generate code specific to your particular RPC system.  Therefore,
-  // these default to false.  Old code which depends on generic services should
-  // explicitly set them to true.
-  optional bool cc_generic_services = 16 [default=false];
-  optional bool java_generic_services = 17 [default=false];
-  optional bool py_generic_services = 18 [default=false];
-  optional bool php_generic_services = 42 [default=false];
-
-  // Is this file deprecated?
-  // Depending on the target platform, this can emit Deprecated annotations
-  // for everything in the file, or it will be completely ignored; in the very
-  // least, this is a formalization for deprecating files.
-  optional bool deprecated = 23 [default=false];
-
-  // Enables the use of arenas for the proto messages in this file. This applies
-  // only to generated classes for C++.
-  optional bool cc_enable_arenas = 31 [default=false];
-
-
-  // Sets the objective c class prefix which is prepended to all objective c
-  // generated classes from this .proto. There is no default.
-  optional string objc_class_prefix = 36;
-
-  // Namespace for generated classes; defaults to the package.
-  optional string csharp_namespace = 37;
-
-  // By default Swift generators will take the proto package and CamelCase it
-  // replacing '.' with underscore and use that to prefix the types/symbols
-  // defined. When this options is provided, they will use this value instead
-  // to prefix the types/symbols defined.
-  optional string swift_prefix = 39;
-
-  // Sets the php class prefix which is prepended to all php generated classes
-  // from this .proto. Default is empty.
-  optional string php_class_prefix = 40;
-
-  // Use this option to change the namespace of php generated classes. Default
-  // is empty. When this option is empty, the package name will be used for
-  // determining the namespace.
-  optional string php_namespace = 41;
-
-  // The parser stores options it doesn't recognize here.
-  // See the documentation for the "Options" section above.
-  repeated UninterpretedOption uninterpreted_option = 999;
-
-  // Clients can define custom options in extensions of this message.
-  // See the documentation for the "Options" section above.
-  extensions 1000 to max;
-
-  reserved 38;
-}
-
-message MessageOptions {
-  // Set true to use the old proto1 MessageSet wire format for extensions.
-  // This is provided for backwards-compatibility with the MessageSet wire
-  // format.  You should not use this for any other reason:  It's less
-  // efficient, has fewer features, and is more complicated.
-  //
-  // The message must be defined exactly as follows:
-  //   message Foo {
-  //     option message_set_wire_format = true;
-  //     extensions 4 to max;
-  //   }
-  // Note that the message cannot have any defined fields; MessageSets only
-  // have extensions.
-  //
-  // All extensions of your type must be singular messages; e.g. they cannot
-  // be int32s, enums, or repeated messages.
-  //
-  // Because this is an option, the above two restrictions are not enforced by
-  // the protocol compiler.
-  optional bool message_set_wire_format = 1 [default=false];
-
-  // Disables the generation of the standard "descriptor()" accessor, which can
-  // conflict with a field of the same name.  This is meant to make migration
-  // from proto1 easier; new code should avoid fields named "descriptor".
-  optional bool no_standard_descriptor_accessor = 2 [default=false];
-
-  // Is this message deprecated?
-  // Depending on the target platform, this can emit Deprecated annotations
-  // for the message, or it will be completely ignored; in the very least,
-  // this is a formalization for deprecating messages.
-  optional bool deprecated = 3 [default=false];
-
-  // Whether the message is an automatically generated map entry type for the
-  // maps field.
-  //
-  // For maps fields:
-  //     map<KeyType, ValueType> map_field = 1;
-  // The parsed descriptor looks like:
-  //     message MapFieldEntry {
-  //         option map_entry = true;
-  //         optional KeyType key = 1;
-  //         optional ValueType value = 2;
-  //     }
-  //     repeated MapFieldEntry map_field = 1;
-  //
-  // Implementations may choose not to generate the map_entry=true message, but
-  // use a native map in the target language to hold the keys and values.
-  // The reflection APIs in such implementions still need to work as
-  // if the field is a repeated message field.
-  //
-  // NOTE: Do not set the option in .proto files. Always use the maps syntax
-  // instead. The option should only be implicitly set by the proto compiler
-  // parser.
-  optional bool map_entry = 7;
-
-  reserved 8;  // javalite_serializable
-  reserved 9;  // javanano_as_lite
-
-  // The parser stores options it doesn't recognize here. See above.
-  repeated UninterpretedOption uninterpreted_option = 999;
-
-  // Clients can define custom options in extensions of this message. See above.
-  extensions 1000 to max;
-}
-
-message FieldOptions {
-  // The ctype option instructs the C++ code generator to use a different
-  // representation of the field than it normally would.  See the specific
-  // options below.  This option is not yet implemented in the open source
-  // release -- sorry, we'll try to include it in a future version!
-  optional CType ctype = 1 [default = STRING];
-  enum CType {
-    // Default mode.
-    STRING = 0;
-
-    CORD = 1;
-
-    STRING_PIECE = 2;
-  }
-  // The packed option can be enabled for repeated primitive fields to enable
-  // a more efficient representation on the wire. Rather than repeatedly
-  // writing the tag and type for each element, the entire array is encoded as
-  // a single length-delimited blob. In proto3, only explicit setting it to
-  // false will avoid using packed encoding.
-  optional bool packed = 2;
-
-  // The jstype option determines the JavaScript type used for values of the
-  // field.  The option is permitted only for 64 bit integral and fixed types
-  // (int64, uint64, sint64, fixed64, sfixed64).  A field with jstype JS_STRING
-  // is represented as JavaScript string, which avoids loss of precision that
-  // can happen when a large value is converted to a floating point JavaScript.
-  // Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
-  // use the JavaScript "number" type.  The behavior of the default option
-  // JS_NORMAL is implementation dependent.
-  //
-  // This option is an enum to permit additional types to be added, e.g.
-  // goog.math.Integer.
-  optional JSType jstype = 6 [default = JS_NORMAL];
-  enum JSType {
-    // Use the default type.
-    JS_NORMAL = 0;
-
-    // Use JavaScript strings.
-    JS_STRING = 1;
-
-    // Use JavaScript numbers.
-    JS_NUMBER = 2;
-  }
-
-  // Should this field be parsed lazily?  Lazy applies only to message-type
-  // fields.  It means that when the outer message is initially parsed, the
-  // inner message's contents will not be parsed but instead stored in encoded
-  // form.  The inner message will actually be parsed when it is first accessed.
-  //
-  // This is only a hint.  Implementations are free to choose whether to use
-  // eager or lazy parsing regardless of the value of this option.  However,
-  // setting this option true suggests that the protocol author believes that
-  // using lazy parsing on this field is worth the additional bookkeeping
-  // overhead typically needed to implement it.
-  //
-  // This option does not affect the public interface of any generated code;
-  // all method signatures remain the same.  Furthermore, thread-safety of the
-  // interface is not affected by this option; const methods remain safe to
-  // call from multiple threads concurrently, while non-const methods continue
-  // to require exclusive access.
-  //
-  //
-  // Note that implementations may choose not to check required fields within
-  // a lazy sub-message.  That is, calling IsInitialized() on the outer message
-  // may return true even if the inner message has missing required fields.
-  // This is necessary because otherwise the inner message would have to be
-  // parsed in order to perform the check, defeating the purpose of lazy
-  // parsing.  An implementation which chooses not to check required fields
-  // must be consistent about it.  That is, for any particular sub-message, the
-  // implementation must either *always* check its required fields, or *never*
-  // check its required fields, regardless of whether or not the message has
-  // been parsed.
-  optional bool lazy = 5 [default=false];
-
-  // Is this field deprecated?
-  // Depending on the target platform, this can emit Deprecated annotations
-  // for accessors, or it will be completely ignored; in the very least, this
-  // is a formalization for deprecating fields.
-  optional bool deprecated = 3 [default=false];
-
-  // For Google-internal migration only. Do not use.
-  optional bool weak = 10 [default=false];
-
-
-  // The parser stores options it doesn't recognize here. See above.
-  repeated UninterpretedOption uninterpreted_option = 999;
-
-  // Clients can define custom options in extensions of this message. See above.
-  extensions 1000 to max;
-
-  reserved 4;  // removed jtype
-}
-
-message OneofOptions {
-  // The parser stores options it doesn't recognize here. See above.
-  repeated UninterpretedOption uninterpreted_option = 999;
-
-  // Clients can define custom options in extensions of this message. See above.
-  extensions 1000 to max;
-}
-
-message EnumOptions {
-
-  // Set this option to true to allow mapping different tag names to the same
-  // value.
-  optional bool allow_alias = 2;
-
-  // Is this enum deprecated?
-  // Depending on the target platform, this can emit Deprecated annotations
-  // for the enum, or it will be completely ignored; in the very least, this
-  // is a formalization for deprecating enums.
-  optional bool deprecated = 3 [default=false];
-
-  reserved 5;  // javanano_as_lite
-
-  // The parser stores options it doesn't recognize here. See above.
-  repeated UninterpretedOption uninterpreted_option = 999;
-
-  // Clients can define custom options in extensions of this message. See above.
-  extensions 1000 to max;
-}
-
-message EnumValueOptions {
-  // Is this enum value deprecated?
-  // Depending on the target platform, this can emit Deprecated annotations
-  // for the enum value, or it will be completely ignored; in the very least,
-  // this is a formalization for deprecating enum values.
-  optional bool deprecated = 1 [default=false];
-
-  // The parser stores options it doesn't recognize here. See above.
-  repeated UninterpretedOption uninterpreted_option = 999;
-
-  // Clients can define custom options in extensions of this message. See above.
-  extensions 1000 to max;
-}
-
-message ServiceOptions {
-
-  // Note:  Field numbers 1 through 32 are reserved for Google's internal RPC
-  //   framework.  We apologize for hoarding these numbers to ourselves, but
-  //   we were already using them long before we decided to release Protocol
-  //   Buffers.
-
-  // Is this service deprecated?
-  // Depending on the target platform, this can emit Deprecated annotations
-  // for the service, or it will be completely ignored; in the very least,
-  // this is a formalization for deprecating services.
-  optional bool deprecated = 33 [default=false];
-
-  // The parser stores options it doesn't recognize here. See above.
-  repeated UninterpretedOption uninterpreted_option = 999;
-
-  // Clients can define custom options in extensions of this message. See above.
-  extensions 1000 to max;
-}
-
-message MethodOptions {
-
-  // Note:  Field numbers 1 through 32 are reserved for Google's internal RPC
-  //   framework.  We apologize for hoarding these numbers to ourselves, but
-  //   we were already using them long before we decided to release Protocol
-  //   Buffers.
-
-  // Is this method deprecated?
-  // Depending on the target platform, this can emit Deprecated annotations
-  // for the method, or it will be completely ignored; in the very least,
-  // this is a formalization for deprecating methods.
-  optional bool deprecated = 33 [default=false];
-
-  // Is this method side-effect-free (or safe in HTTP parlance), or idempotent,
-  // or neither? HTTP based RPC implementation may choose GET verb for safe
-  // methods, and PUT verb for idempotent methods instead of the default POST.
-  enum IdempotencyLevel {
-    IDEMPOTENCY_UNKNOWN = 0;
-    NO_SIDE_EFFECTS     = 1; // implies idempotent
-    IDEMPOTENT          = 2; // idempotent, but may have side effects
-  }
-  optional IdempotencyLevel idempotency_level =
-      34 [default=IDEMPOTENCY_UNKNOWN];
-
-  // The parser stores options it doesn't recognize here. See above.
-  repeated UninterpretedOption uninterpreted_option = 999;
-
-  // Clients can define custom options in extensions of this message. See above.
-  extensions 1000 to max;
-}
-
-
-// A message representing a option the parser does not recognize. This only
-// appears in options protos created by the compiler::Parser class.
-// DescriptorPool resolves these when building Descriptor objects. Therefore,
-// options protos in descriptor objects (e.g. returned by Descriptor::options(),
-// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
-// in them.
-message UninterpretedOption {
-  // The name of the uninterpreted option.  Each string represents a segment in
-  // a dot-separated name.  is_extension is true iff a segment represents an
-  // extension (denoted with parentheses in options specs in .proto files).
-  // E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents
-  // "foo.(bar.baz).qux".
-  message NamePart {
-    required string name_part = 1;
-    required bool is_extension = 2;
-  }
-  repeated NamePart name = 2;
-
-  // The value of the uninterpreted option, in whatever type the tokenizer
-  // identified it as during parsing. Exactly one of these should be set.
-  optional string identifier_value = 3;
-  optional uint64 positive_int_value = 4;
-  optional int64 negative_int_value = 5;
-  optional double double_value = 6;
-  optional bytes string_value = 7;
-  optional string aggregate_value = 8;
-}
-
-// ===================================================================
-// Optional source code info
-
-// Encapsulates information about the original source file from which a
-// FileDescriptorProto was generated.
-message SourceCodeInfo {
-  // A Location identifies a piece of source code in a .proto file which
-  // corresponds to a particular definition.  This information is intended
-  // to be useful to IDEs, code indexers, documentation generators, and similar
-  // tools.
-  //
-  // For example, say we have a file like:
-  //   message Foo {
-  //     optional string foo = 1;
-  //   }
-  // Let's look at just the field definition:
-  //   optional string foo = 1;
-  //   ^       ^^     ^^  ^  ^^^
-  //   a       bc     de  f  ghi
-  // We have the following locations:
-  //   span   path               represents
-  //   [a,i)  [ 4, 0, 2, 0 ]     The whole field definition.
-  //   [a,b)  [ 4, 0, 2, 0, 4 ]  The label (optional).
-  //   [c,d)  [ 4, 0, 2, 0, 5 ]  The type (string).
-  //   [e,f)  [ 4, 0, 2, 0, 1 ]  The name (foo).
-  //   [g,h)  [ 4, 0, 2, 0, 3 ]  The number (1).
-  //
-  // Notes:
-  // - A location may refer to a repeated field itself (i.e. not to any
-  //   particular index within it).  This is used whenever a set of elements are
-  //   logically enclosed in a single code segment.  For example, an entire
-  //   extend block (possibly containing multiple extension definitions) will
-  //   have an outer location whose path refers to the "extensions" repeated
-  //   field without an index.
-  // - Multiple locations may have the same path.  This happens when a single
-  //   logical declaration is spread out across multiple places.  The most
-  //   obvious example is the "extend" block again -- there may be multiple
-  //   extend blocks in the same scope, each of which will have the same path.
-  // - A location's span is not always a subset of its parent's span.  For
-  //   example, the "extendee" of an extension declaration appears at the
-  //   beginning of the "extend" block and is shared by all extensions within
-  //   the block.
-  // - Just because a location's span is a subset of some other location's span
-  //   does not mean that it is a descendent.  For example, a "group" defines
-  //   both a type and a field in a single declaration.  Thus, the locations
-  //   corresponding to the type and field and their components will overlap.
-  // - Code which tries to interpret locations should probably be designed to
-  //   ignore those that it doesn't understand, as more types of locations could
-  //   be recorded in the future.
-  repeated Location location = 1;
-  message Location {
-    // Identifies which part of the FileDescriptorProto was defined at this
-    // location.
-    //
-    // Each element is a field number or an index.  They form a path from
-    // the root FileDescriptorProto to the place where the definition.  For
-    // example, this path:
-    //   [ 4, 3, 2, 7, 1 ]
-    // refers to:
-    //   file.message_type(3)  // 4, 3
-    //       .field(7)         // 2, 7
-    //       .name()           // 1
-    // This is because FileDescriptorProto.message_type has field number 4:
-    //   repeated DescriptorProto message_type = 4;
-    // and DescriptorProto.field has field number 2:
-    //   repeated FieldDescriptorProto field = 2;
-    // and FieldDescriptorProto.name has field number 1:
-    //   optional string name = 1;
-    //
-    // Thus, the above path gives the location of a field name.  If we removed
-    // the last element:
-    //   [ 4, 3, 2, 7 ]
-    // this path refers to the whole field declaration (from the beginning
-    // of the label to the terminating semicolon).
-    repeated int32 path = 1 [packed=true];
-
-    // Always has exactly three or four elements: start line, start column,
-    // end line (optional, otherwise assumed same as start line), end column.
-    // These are packed into a single field for efficiency.  Note that line
-    // and column numbers are zero-based -- typically you will want to add
-    // 1 to each before displaying to a user.
-    repeated int32 span = 2 [packed=true];
-
-    // If this SourceCodeInfo represents a complete declaration, these are any
-    // comments appearing before and after the declaration which appear to be
-    // attached to the declaration.
-    //
-    // A series of line comments appearing on consecutive lines, with no other
-    // tokens appearing on those lines, will be treated as a single comment.
-    //
-    // leading_detached_comments will keep paragraphs of comments that appear
-    // before (but not connected to) the current element. Each paragraph,
-    // separated by empty lines, will be one comment element in the repeated
-    // field.
-    //
-    // Only the comment content is provided; comment markers (e.g. //) are
-    // stripped out.  For block comments, leading whitespace and an asterisk
-    // will be stripped from the beginning of each line other than the first.
-    // Newlines are included in the output.
-    //
-    // Examples:
-    //
-    //   optional int32 foo = 1;  // Comment attached to foo.
-    //   // Comment attached to bar.
-    //   optional int32 bar = 2;
-    //
-    //   optional string baz = 3;
-    //   // Comment attached to baz.
-    //   // Another line attached to baz.
-    //
-    //   // Comment attached to qux.
-    //   //
-    //   // Another line attached to qux.
-    //   optional double qux = 4;
-    //
-    //   // Detached comment for corge. This is not leading or trailing comments
-    //   // to qux or corge because there are blank lines separating it from
-    //   // both.
-    //
-    //   // Detached comment for corge paragraph 2.
-    //
-    //   optional string corge = 5;
-    //   /* Block comment attached
-    //    * to corge.  Leading asterisks
-    //    * will be removed. */
-    //   /* Block comment attached to
-    //    * grault. */
-    //   optional int32 grault = 6;
-    //
-    //   // ignored detached comments.
-    optional string leading_comments = 3;
-    optional string trailing_comments = 4;
-    repeated string leading_detached_comments = 6;
-  }
-}
-
-// Describes the relationship between generated code and its original source
-// file. A GeneratedCodeInfo message is associated with only one generated
-// source file, but may contain references to different source .proto files.
-message GeneratedCodeInfo {
-  // An Annotation connects some span of text in generated code to an element
-  // of its generating .proto file.
-  repeated Annotation annotation = 1;
-  message Annotation {
-    // Identifies the element in the original source .proto file. This field
-    // is formatted the same as SourceCodeInfo.Location.path.
-    repeated int32 path = 1 [packed=true];
-
-    // Identifies the filesystem path to the original source .proto.
-    optional string source_file = 2;
-
-    // Identifies the starting offset in bytes in the generated code
-    // that relates to the identified object.
-    optional int32 begin = 3;
-
-    // Identifies the ending offset in bytes in the generated code that
-    // relates to the identified offset. The end offset should be one past
-    // the last relevant byte (so the length of the text = end - begin).
-    optional int32 end = 4;
-  }
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/doc.go b/vendor/github.com/golang/protobuf/protoc-gen-go/doc.go
deleted file mode 100644
index 0d6055d61..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/doc.go
+++ /dev/null
@@ -1,51 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-/*
-	A plugin for the Google protocol buffer compiler to generate Go code.
-	Run it by building this program and putting it in your path with the name
-		protoc-gen-go
-	That word 'go' at the end becomes part of the option string set for the
-	protocol compiler, so once the protocol compiler (protoc) is installed
-	you can run
-		protoc --go_out=output_directory input_directory/file.proto
-	to generate Go bindings for the protocol defined by file.proto.
-	With that input, the output will be written to
-		output_directory/file.pb.go
-
-	The generated code is documented in the package comment for
-	the library.
-
-	See the README and documentation for protocol buffers to learn more:
-		https://developers.google.com/protocol-buffers/
-
-*/
-package documentation
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/generator/generator.go b/vendor/github.com/golang/protobuf/protoc-gen-go/generator/generator.go
index e0aba85f3..12ff35b94 100644
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/generator/generator.go
+++ b/vendor/github.com/golang/protobuf/protoc-gen-go/generator/generator.go
@@ -1,39 +1,14 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
+// Copyright 2010 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 generator is deprecated.
 //
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
+// This package is excluded from the Go protocol buffer compatibility guarantee
+// and may be deleted at some point in the future.
 //
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-/*
-	The code generator for the plugin for the Google protocol buffer compiler.
-	It generates Go code from the protocol buffer description files read by the
-	main routine.
-*/
+// Deprecated: Use the "google.golang.org/protobuf/compiler/protogen" package
+// instead to write protoc plugins in Go.
 package generator
 
 import (
@@ -43,6 +18,7 @@ import (
 	"crypto/sha256"
 	"encoding/hex"
 	"fmt"
+	"go/ast"
 	"go/build"
 	"go/parser"
 	"go/printer"
@@ -63,11 +39,18 @@ import (
 	plugin "github.com/golang/protobuf/protoc-gen-go/plugin"
 )
 
+func init() {
+	fmt.Fprint(os.Stderr,
+		"WARNING: Package \"github.com/golang/protobuf/protoc-gen-go/generator\" is deprecated.\n"+
+			"\tA future release of golang/protobuf will delete this package,\n"+
+			"\twhich has long been excluded from the compatibility promise.\n\n")
+}
+
 // generatedCodeVersion indicates a version of the generated code.
 // It is incremented whenever an incompatibility between the generated code and
 // proto package is introduced; the generated code references
 // a constant, proto.ProtoPackageIsVersionN (where N is generatedCodeVersion).
-const generatedCodeVersion = 2
+const generatedCodeVersion = 3
 
 // A Plugin provides functionality to add to the output during Go code generation,
 // such as to produce RPC stubs.
@@ -271,7 +254,6 @@ type FileDescriptor struct {
 	// This is used for supporting public imports.
 	exported map[Object][]symbol
 
-	fingerprint string        // Fingerprint of this file's contents.
 	importPath  GoImportPath  // Import path of this file's package.
 	packageName GoPackageName // Name of this file's Go package.
 
@@ -282,8 +264,8 @@ type FileDescriptor struct {
 // to the compressed bytes of this descriptor. It is not exported, so
 // it is only valid inside the generated package.
 func (d *FileDescriptor) VarName() string {
-	name := strings.Map(badToUnderscore, baseName(d.GetName()))
-	return fmt.Sprintf("fileDescriptor_%s_%s", name, d.fingerprint)
+	h := sha256.Sum256([]byte(d.GetName()))
+	return fmt.Sprintf("fileDescriptor_%s", hex.EncodeToString(h[:8]))
 }
 
 // goPackageOption interprets the file's go_package option.
@@ -340,7 +322,7 @@ func (d *FileDescriptor) addExport(obj Object, sym symbol) {
 type symbol interface {
 	// GenerateAlias should generate an appropriate alias
 	// for the symbol from the named package.
-	GenerateAlias(g *Generator, pkg GoPackageName)
+	GenerateAlias(g *Generator, filename string, pkg GoPackageName)
 }
 
 type messageSymbol struct {
@@ -356,7 +338,8 @@ type getterSymbol struct {
 	genType  bool   // whether typ contains a generated type (message/group/enum)
 }
 
-func (ms *messageSymbol) GenerateAlias(g *Generator, pkg GoPackageName) {
+func (ms *messageSymbol) GenerateAlias(g *Generator, filename string, pkg GoPackageName) {
+	g.P("// ", ms.sym, " from public import ", filename)
 	g.P("type ", ms.sym, " = ", pkg, ".", ms.sym)
 	for _, name := range ms.oneofTypes {
 		g.P("type ", name, " = ", pkg, ".", name)
@@ -368,8 +351,9 @@ type enumSymbol struct {
 	proto3 bool // Whether this came from a proto3 file.
 }
 
-func (es enumSymbol) GenerateAlias(g *Generator, pkg GoPackageName) {
+func (es enumSymbol) GenerateAlias(g *Generator, filename string, pkg GoPackageName) {
 	s := es.name
+	g.P("// ", s, " from public import ", filename)
 	g.P("type ", s, " = ", pkg, ".", s)
 	g.P("var ", s, "_name = ", pkg, ".", s, "_name")
 	g.P("var ", s, "_value = ", pkg, ".", s, "_value")
@@ -381,7 +365,7 @@ type constOrVarSymbol struct {
 	cast string // if non-empty, a type cast is required (used for enums)
 }
 
-func (cs constOrVarSymbol) GenerateAlias(g *Generator, pkg GoPackageName) {
+func (cs constOrVarSymbol) GenerateAlias(g *Generator, filename string, pkg GoPackageName) {
 	v := string(pkg) + "." + cs.sym
 	if cs.cast != "" {
 		v = cs.cast + "(" + v + ")"
@@ -418,6 +402,7 @@ type Generator struct {
 	packageNames     map[GoImportPath]GoPackageName // Imported package names in the current file.
 	usedPackages     map[GoImportPath]bool          // Packages used in current file.
 	usedPackageNames map[GoPackageName]bool         // Package names used in the current file.
+	addedImports     map[GoImportPath]bool          // Additional imports to emit.
 	typeNameToObject map[string]Object              // Key is a fully-qualified name in input syntax.
 	init             []string                       // Lines to emit in the init function.
 	indent           string
@@ -532,7 +517,7 @@ func (g *Generator) GoPackageName(importPath GoImportPath) GoPackageName {
 		return name
 	}
 	name := cleanPackageName(baseName(string(importPath)))
-	for i, orig := 1, name; g.usedPackageNames[name]; i++ {
+	for i, orig := 1, name; g.usedPackageNames[name] || isGoPredeclaredIdentifier[string(name)]; i++ {
 		name = orig + GoPackageName(strconv.Itoa(i))
 	}
 	g.packageNames[importPath] = name
@@ -540,6 +525,13 @@ func (g *Generator) GoPackageName(importPath GoImportPath) GoPackageName {
 	return name
 }
 
+// AddImport adds a package to the generated file's import section.
+// It returns the name used for the package.
+func (g *Generator) AddImport(importPath GoImportPath) GoPackageName {
+	g.addedImports[importPath] = true
+	return g.GoPackageName(importPath)
+}
+
 var globalPackageNames = map[GoPackageName]bool{
 	"fmt":   true,
 	"math":  true,
@@ -585,9 +577,51 @@ var isGoKeyword = map[string]bool{
 	"var":         true,
 }
 
+var isGoPredeclaredIdentifier = map[string]bool{
+	"append":     true,
+	"bool":       true,
+	"byte":       true,
+	"cap":        true,
+	"close":      true,
+	"complex":    true,
+	"complex128": true,
+	"complex64":  true,
+	"copy":       true,
+	"delete":     true,
+	"error":      true,
+	"false":      true,
+	"float32":    true,
+	"float64":    true,
+	"imag":       true,
+	"int":        true,
+	"int16":      true,
+	"int32":      true,
+	"int64":      true,
+	"int8":       true,
+	"iota":       true,
+	"len":        true,
+	"make":       true,
+	"new":        true,
+	"nil":        true,
+	"panic":      true,
+	"print":      true,
+	"println":    true,
+	"real":       true,
+	"recover":    true,
+	"rune":       true,
+	"string":     true,
+	"true":       true,
+	"uint":       true,
+	"uint16":     true,
+	"uint32":     true,
+	"uint64":     true,
+	"uint8":      true,
+	"uintptr":    true,
+}
+
 func cleanPackageName(name string) GoPackageName {
 	name = strings.Map(badToUnderscore, name)
-	// Identifier must not be keyword: insert _.
+	// Identifier must not be keyword or predeclared identifier: insert _.
 	if isGoKeyword[name] {
 		name = "_" + name
 	}
@@ -724,27 +758,10 @@ func (g *Generator) WrapTypes() {
 		if fd == nil {
 			g.Fail("could not find file named", fileName)
 		}
-		fingerprint, err := fingerprintProto(fd.FileDescriptorProto)
-		if err != nil {
-			g.Error(err)
-		}
-		fd.fingerprint = fingerprint
 		g.genFiles = append(g.genFiles, fd)
 	}
 }
 
-// fingerprintProto returns a fingerprint for a message.
-// The fingerprint is intended to prevent conflicts between generated fileds,
-// not to provide cryptographic security.
-func fingerprintProto(m proto.Message) (string, error) {
-	b, err := proto.Marshal(m)
-	if err != nil {
-		return "", err
-	}
-	h := sha256.Sum256(b)
-	return hex.EncodeToString(h[:8]), nil
-}
-
 // Scan the descriptors in this file.  For each one, build the slice of nested descriptors
 func (g *Generator) buildNestedDescriptors(descs []*Descriptor) {
 	for _, desc := range descs {
@@ -938,39 +955,6 @@ func (g *Generator) ObjectNamed(typeName string) Object {
 	if !ok {
 		g.Fail("can't find object with type", typeName)
 	}
-
-	// If the file of this object isn't a direct dependency of the current file,
-	// or in the current file, then this object has been publicly imported into
-	// a dependency of the current file.
-	// We should return the ImportedDescriptor object for it instead.
-	direct := *o.File().Name == *g.file.Name
-	if !direct {
-		for _, dep := range g.file.Dependency {
-			if *g.fileByName(dep).Name == *o.File().Name {
-				direct = true
-				break
-			}
-		}
-	}
-	if !direct {
-		found := false
-	Loop:
-		for _, dep := range g.file.Dependency {
-			df := g.fileByName(*g.fileByName(dep).Name)
-			for _, td := range df.imp {
-				if td.o == o {
-					// Found it!
-					o = td
-					found = true
-					break Loop
-				}
-			}
-		}
-		if !found {
-			log.Printf("protoc-gen-go: WARNING: failed finding publicly imported dependency for %v, used in %v", typeName, *g.file.Name)
-		}
-	}
-
 	return o
 }
 
@@ -1124,6 +1108,7 @@ func (g *Generator) generate(file *FileDescriptor) {
 	g.usedPackages = make(map[GoImportPath]bool)
 	g.packageNames = make(map[GoImportPath]GoPackageName)
 	g.usedPackageNames = make(map[GoPackageName]bool)
+	g.addedImports = make(map[GoImportPath]bool)
 	for name := range globalPackageNames {
 		g.usedPackageNames[name] = true
 	}
@@ -1152,12 +1137,11 @@ func (g *Generator) generate(file *FileDescriptor) {
 		g.generateExtension(ext)
 	}
 	g.generateInitFunction()
+	g.generateFileDescriptor(file)
 
 	// Run the plugins before the imports so we know which imports are necessary.
 	g.runPlugins(file)
 
-	g.generateFileDescriptor(file)
-
 	// Generate header and imports last, though they appear first in the output.
 	rem := g.Buffer
 	remAnno := g.annotations
@@ -1183,7 +1167,7 @@ func (g *Generator) generate(file *FileDescriptor) {
 		// make a copy independent of g; we'll need it after Reset.
 		original = append([]byte(nil), original...)
 	}
-	ast, err := parser.ParseFile(fset, "", original, parser.ParseComments)
+	fileAST, err := parser.ParseFile(fset, "", original, parser.ParseComments)
 	if err != nil {
 		// Print out the bad code with line numbers.
 		// This should never happen in practice, but it can while changing generated code,
@@ -1195,8 +1179,9 @@ func (g *Generator) generate(file *FileDescriptor) {
 		}
 		g.Fail("bad Go source code was generated:", err.Error(), "\n"+src.String())
 	}
+	ast.SortImports(fset, fileAST)
 	g.Reset()
-	err = (&printer.Config{Mode: printer.TabIndent | printer.UseSpaces, Tabwidth: 8}).Fprint(g, fset, ast)
+	err = (&printer.Config{Mode: printer.TabIndent | printer.UseSpaces, Tabwidth: 8}).Fprint(g, fset, fileAST)
 	if err != nil {
 		g.Fail("generated Go source code could not be reformatted:", err.Error())
 	}
@@ -1225,28 +1210,10 @@ func (g *Generator) generateHeader() {
 		g.P("// source: ", g.file.Name)
 	}
 	g.P()
-
-	importPath, _, _ := g.file.goPackageOption()
-	if importPath == "" {
-		g.P("package ", g.file.packageName)
-	} else {
-		g.P("package ", g.file.packageName, " // import ", GoImportPath(g.ImportPrefix)+importPath)
-	}
+	g.PrintComments(strconv.Itoa(packagePath))
+	g.P()
+	g.P("package ", g.file.packageName)
 	g.P()
-
-	if loc, ok := g.file.comments[strconv.Itoa(packagePath)]; ok {
-		g.P("/*")
-		// not using g.PrintComments because this is a /* */ comment block.
-		text := strings.TrimSuffix(loc.GetLeadingComments(), "\n")
-		for _, line := range strings.Split(text, "\n") {
-			line = strings.TrimPrefix(line, " ")
-			// ensure we don't escape from the block comment
-			line = strings.Replace(line, "*/", "* /", -1)
-			g.P(line)
-		}
-		g.P("*/")
-		g.P()
-	}
 }
 
 // deprecationComment is the standard comment added to deprecated
@@ -1261,16 +1228,28 @@ func (g *Generator) PrintComments(path string) bool {
 	if !g.writeOutput {
 		return false
 	}
-	if loc, ok := g.file.comments[path]; ok {
-		text := strings.TrimSuffix(loc.GetLeadingComments(), "\n")
-		for _, line := range strings.Split(text, "\n") {
-			g.P("// ", strings.TrimPrefix(line, " "))
-		}
+	if c, ok := g.makeComments(path); ok {
+		g.P(c)
 		return true
 	}
 	return false
 }
 
+// makeComments generates the comment string for the field, no "\n" at the end
+func (g *Generator) makeComments(path string) (string, bool) {
+	loc, ok := g.file.comments[path]
+	if !ok {
+		return "", false
+	}
+	w := new(bytes.Buffer)
+	nl := ""
+	for _, line := range strings.Split(strings.TrimSuffix(loc.GetLeadingComments(), "\n"), "\n") {
+		fmt.Fprintf(w, "%s//%s", nl, line)
+		nl = "\n"
+	}
+	return w.String(), true
+}
+
 func (g *Generator) fileByName(filename string) *FileDescriptor {
 	return g.allFilesByName[filename]
 }
@@ -1287,17 +1266,7 @@ func (g *Generator) weak(i int32) bool {
 
 // Generate the imports
 func (g *Generator) generateImports() {
-	// We almost always need a proto import.  Rather than computing when we
-	// do, which is tricky when there's a plugin, just import it and
-	// reference it later. The same argument applies to the fmt and math packages.
-	g.P("import "+g.Pkg["proto"]+" ", GoImportPath(g.ImportPrefix)+"github.com/golang/protobuf/proto")
-	g.P("import " + g.Pkg["fmt"] + ` "fmt"`)
-	g.P("import " + g.Pkg["math"] + ` "math"`)
-	var (
-		imports       = make(map[GoImportPath]bool)
-		strongImports = make(map[GoImportPath]bool)
-		importPaths   []string
-	)
+	imports := make(map[GoImportPath]GoPackageName)
 	for i, s := range g.file.Dependency {
 		fd := g.fileByName(s)
 		importPath := fd.importPath
@@ -1305,32 +1274,37 @@ func (g *Generator) generateImports() {
 		if importPath == g.file.importPath {
 			continue
 		}
-		if !imports[importPath] {
-			importPaths = append(importPaths, string(importPath))
-		}
-		imports[importPath] = true
-		if !g.weak(int32(i)) {
-			strongImports[importPath] = true
+		// Do not import weak imports.
+		if g.weak(int32(i)) {
+			continue
 		}
-	}
-	sort.Strings(importPaths)
-	for i := range importPaths {
-		importPath := GoImportPath(importPaths[i])
-		packageName := g.GoPackageName(importPath)
-		fullPath := GoImportPath(g.ImportPrefix) + importPath
-		// Skip weak imports.
-		if !strongImports[importPath] {
-			g.P("// skipping weak import ", packageName, " ", fullPath)
+		// Do not import a package twice.
+		if _, ok := imports[importPath]; ok {
 			continue
 		}
 		// We need to import all the dependencies, even if we don't reference them,
 		// because other code and tools depend on having the full transitive closure
 		// of protocol buffer types in the binary.
+		packageName := g.GoPackageName(importPath)
 		if _, ok := g.usedPackages[importPath]; !ok {
 			packageName = "_"
 		}
-		g.P("import ", packageName, " ", fullPath)
+		imports[importPath] = packageName
+	}
+	for importPath := range g.addedImports {
+		imports[importPath] = g.GoPackageName(importPath)
+	}
+	// We almost always need a proto import.  Rather than computing when we
+	// do, which is tricky when there's a plugin, just import it and
+	// reference it later. The same argument applies to the fmt and math packages.
+	g.P("import (")
+	g.P(g.Pkg["fmt"] + ` "fmt"`)
+	g.P(g.Pkg["math"] + ` "math"`)
+	g.P(g.Pkg["proto"]+" ", GoImportPath(g.ImportPrefix)+"github.com/golang/protobuf/proto")
+	for importPath, packageName := range imports {
+		g.P(packageName, " ", GoImportPath(g.ImportPrefix)+importPath)
 	}
+	g.P(")")
 	g.P()
 	// TODO: may need to worry about uniqueness across plugins
 	for _, p := range plugins {
@@ -1345,24 +1319,19 @@ func (g *Generator) generateImports() {
 }
 
 func (g *Generator) generateImported(id *ImportedDescriptor) {
-	tn := id.TypeName()
-	sn := tn[len(tn)-1]
 	df := id.o.File()
 	filename := *df.Name
 	if df.importPath == g.file.importPath {
 		// Don't generate type aliases for files in the same Go package as this one.
-		g.P("// Ignoring public import of ", sn, " from ", filename)
-		g.P()
 		return
 	}
 	if !supportTypeAliases {
 		g.Fail(fmt.Sprintf("%s: public imports require at least go1.9", filename))
 	}
-	g.P("// ", sn, " from public import ", filename)
 	g.usedPackages[df.importPath] = true
 
 	for _, sym := range df.exported[id.o] {
-		sym.GenerateAlias(g, g.GoPackageName(df.importPath))
+		sym.GenerateAlias(g, filename, g.GoPackageName(df.importPath))
 	}
 
 	g.P()
@@ -1384,7 +1353,6 @@ func (g *Generator) generateEnum(enum *EnumDescriptor) {
 	g.P("type ", Annotate(enum.file, enum.path, ccTypeName), " int32", deprecatedEnum)
 	g.file.addExport(enum, enumSymbol{ccTypeName, enum.proto3()})
 	g.P("const (")
-	g.In()
 	for i, e := range enum.Value {
 		etorPath := fmt.Sprintf("%s,%d,%d", enum.path, enumValuePath, i)
 		g.PrintComments(etorPath)
@@ -1398,10 +1366,9 @@ func (g *Generator) generateEnum(enum *EnumDescriptor) {
 		g.P(Annotate(enum.file, etorPath, name), " ", ccTypeName, " = ", e.Number, " ", deprecatedValue)
 		g.file.addExport(enum, constOrVarSymbol{name, "const", ccTypeName})
 	}
-	g.Out()
 	g.P(")")
+	g.P()
 	g.P("var ", ccTypeName, "_name = map[int32]string{")
-	g.In()
 	generated := make(map[int32]bool) // avoid duplicate values
 	for _, e := range enum.Value {
 		duplicate := ""
@@ -1411,45 +1378,39 @@ func (g *Generator) generateEnum(enum *EnumDescriptor) {
 		g.P(duplicate, e.Number, ": ", strconv.Quote(*e.Name), ",")
 		generated[*e.Number] = true
 	}
-	g.Out()
 	g.P("}")
+	g.P()
 	g.P("var ", ccTypeName, "_value = map[string]int32{")
-	g.In()
 	for _, e := range enum.Value {
 		g.P(strconv.Quote(*e.Name), ": ", e.Number, ",")
 	}
-	g.Out()
 	g.P("}")
+	g.P()
 
 	if !enum.proto3() {
 		g.P("func (x ", ccTypeName, ") Enum() *", ccTypeName, " {")
-		g.In()
 		g.P("p := new(", ccTypeName, ")")
 		g.P("*p = x")
 		g.P("return p")
-		g.Out()
 		g.P("}")
+		g.P()
 	}
 
 	g.P("func (x ", ccTypeName, ") String() string {")
-	g.In()
 	g.P("return ", g.Pkg["proto"], ".EnumName(", ccTypeName, "_name, int32(x))")
-	g.Out()
 	g.P("}")
+	g.P()
 
 	if !enum.proto3() {
 		g.P("func (x *", ccTypeName, ") UnmarshalJSON(data []byte) error {")
-		g.In()
 		g.P("value, err := ", g.Pkg["proto"], ".UnmarshalJSONEnum(", ccTypeName, `_value, data, "`, ccTypeName, `")`)
 		g.P("if err != nil {")
-		g.In()
 		g.P("return err")
-		g.Out()
 		g.P("}")
 		g.P("*x = ", ccTypeName, "(value)")
 		g.P("return nil")
-		g.Out()
 		g.P("}")
+		g.P()
 	}
 
 	var indexes []string
@@ -1459,15 +1420,15 @@ func (g *Generator) generateEnum(enum *EnumDescriptor) {
 	}
 	indexes = append(indexes, strconv.Itoa(enum.index))
 	g.P("func (", ccTypeName, ") EnumDescriptor() ([]byte, []int) {")
-	g.In()
 	g.P("return ", g.file.VarName(), ", []int{", strings.Join(indexes, ", "), "}")
-	g.Out()
 	g.P("}")
+	g.P()
 	if enum.file.GetPackage() == "google.protobuf" && enum.GetName() == "NullValue" {
 		g.P("func (", ccTypeName, `) XXX_WellKnownType() string { return "`, enum.GetName(), `" }`)
+		g.P()
 	}
 
-	g.P()
+	g.generateEnumRegistration(enum)
 }
 
 // The tag is a string like "varint,2,opt,name=fieldname,def=7" that
@@ -1524,6 +1485,18 @@ func (g *Generator) goTag(message *Descriptor, field *descriptor.FieldDescriptor
 				g.Fail("unknown enum type", CamelCaseSlice(obj.TypeName()))
 			}
 			defaultValue = enum.integerValueAsString(defaultValue)
+		case descriptor.FieldDescriptorProto_TYPE_FLOAT:
+			if def := defaultValue; def != "inf" && def != "-inf" && def != "nan" {
+				if f, err := strconv.ParseFloat(defaultValue, 32); err == nil {
+					defaultValue = fmt.Sprint(float32(f))
+				}
+			}
+		case descriptor.FieldDescriptorProto_TYPE_DOUBLE:
+			if def := defaultValue; def != "inf" && def != "-inf" && def != "nan" {
+				if f, err := strconv.ParseFloat(defaultValue, 64); err == nil {
+					defaultValue = fmt.Sprint(f)
+				}
+			}
 		}
 		defaultValue = ",def=" + defaultValue
 	}
@@ -1561,19 +1534,14 @@ func (g *Generator) goTag(message *Descriptor, field *descriptor.FieldDescriptor
 			name = name[i+1:]
 		}
 	}
-	if json := field.GetJsonName(); json != "" && json != name {
+	if json := field.GetJsonName(); field.Extendee == nil && json != "" && json != name {
 		// TODO: escaping might be needed, in which case
 		// perhaps this should be in its own "json" tag.
 		name += ",json=" + json
 	}
 	name = ",name=" + name
 	if message.proto3() {
-		// We only need the extra tag for []byte fields;
-		// no need to add noise for the others.
-		if *field.Type == descriptor.FieldDescriptorProto_TYPE_BYTES {
-			name += ",proto3"
-		}
-
+		name += ",proto3"
 	}
 	oneof := ""
 	if field.OneofIndex != nil {
@@ -1670,11 +1638,16 @@ func (g *Generator) GoType(message *Descriptor, field *descriptor.FieldDescripto
 }
 
 func (g *Generator) RecordTypeUse(t string) {
-	if _, ok := g.typeNameToObject[t]; ok {
-		// Call ObjectNamed to get the true object to record the use.
-		obj := g.ObjectNamed(t)
-		g.usedPackages[obj.GoImportPath()] = true
+	if _, ok := g.typeNameToObject[t]; !ok {
+		return
+	}
+	importPath := g.ObjectNamed(t).GoImportPath()
+	if importPath == g.outputImportPath {
+		// Don't record use of objects in our package.
+		return
 	}
+	g.AddImport(importPath)
+	g.usedPackages[importPath] = true
 }
 
 // Method names that may be generated.  Fields with these names get an
@@ -1713,321 +1686,294 @@ var wellKnownTypes = map[string]bool{
 	"BytesValue":  true,
 }
 
-// Generate the type and default constant definitions for this Descriptor.
-func (g *Generator) generateMessage(message *Descriptor) {
-	// The full type name
-	typeName := message.TypeName()
-	// The full type name, CamelCased.
-	ccTypeName := CamelCaseSlice(typeName)
-
-	usedNames := make(map[string]bool)
-	for _, n := range methodNames {
-		usedNames[n] = true
+// getterDefault finds the default value for the field to return from a getter,
+// regardless of if it's a built in default or explicit from the source. Returns e.g. "nil", `""`, "Default_MessageType_FieldName"
+func (g *Generator) getterDefault(field *descriptor.FieldDescriptorProto, goMessageType string) string {
+	if isRepeated(field) {
+		return "nil"
+	}
+	if def := field.GetDefaultValue(); def != "" {
+		defaultConstant := g.defaultConstantName(goMessageType, field.GetName())
+		if *field.Type != descriptor.FieldDescriptorProto_TYPE_BYTES {
+			return defaultConstant
+		}
+		return "append([]byte(nil), " + defaultConstant + "...)"
+	}
+	switch *field.Type {
+	case descriptor.FieldDescriptorProto_TYPE_BOOL:
+		return "false"
+	case descriptor.FieldDescriptorProto_TYPE_STRING:
+		return `""`
+	case descriptor.FieldDescriptorProto_TYPE_GROUP, descriptor.FieldDescriptorProto_TYPE_MESSAGE, descriptor.FieldDescriptorProto_TYPE_BYTES:
+		return "nil"
+	case descriptor.FieldDescriptorProto_TYPE_ENUM:
+		obj := g.ObjectNamed(field.GetTypeName())
+		var enum *EnumDescriptor
+		if id, ok := obj.(*ImportedDescriptor); ok {
+			// The enum type has been publicly imported.
+			enum, _ = id.o.(*EnumDescriptor)
+		} else {
+			enum, _ = obj.(*EnumDescriptor)
+		}
+		if enum == nil {
+			log.Printf("don't know how to generate getter for %s", field.GetName())
+			return "nil"
+		}
+		if len(enum.Value) == 0 {
+			return "0 // empty enum"
+		}
+		first := enum.Value[0].GetName()
+		return g.DefaultPackageName(obj) + enum.prefix() + first
+	default:
+		return "0"
 	}
-	fieldNames := make(map[*descriptor.FieldDescriptorProto]string)
-	fieldGetterNames := make(map[*descriptor.FieldDescriptorProto]string)
-	fieldTypes := make(map[*descriptor.FieldDescriptorProto]string)
-	mapFieldTypes := make(map[*descriptor.FieldDescriptorProto]string)
+}
 
-	oneofFieldName := make(map[int32]string)                           // indexed by oneof_index field of FieldDescriptorProto
-	oneofDisc := make(map[int32]string)                                // name of discriminator method
-	oneofTypeName := make(map[*descriptor.FieldDescriptorProto]string) // without star
-	oneofInsertPoints := make(map[int32]int)                           // oneof_index => offset of g.Buffer
+// defaultConstantName builds the name of the default constant from the message
+// type name and the untouched field name, e.g. "Default_MessageType_FieldName"
+func (g *Generator) defaultConstantName(goMessageType, protoFieldName string) string {
+	return "Default_" + goMessageType + "_" + CamelCase(protoFieldName)
+}
 
-	comments := g.PrintComments(message.path)
+// The different types of fields in a message and how to actually print them
+// Most of the logic for generateMessage is in the methods of these types.
+//
+// Note that the content of the field is irrelevant, a simpleField can contain
+// anything from a scalar to a group (which is just a message).
+//
+// Extension fields (and message sets) are however handled separately.
+//
+// simpleField - a field that is neiter weak nor oneof, possibly repeated
+// oneofField - field containing list of subfields:
+// - oneofSubField - a field within the oneof
 
-	// Guarantee deprecation comments appear after user-provided comments.
-	if message.GetOptions().GetDeprecated() {
-		if comments {
-			// Convention: Separate deprecation comments from original
-			// comments with an empty line.
-			g.P("//")
-		}
-		g.P(deprecationComment)
-	}
+// msgCtx contains the context for the generator functions.
+type msgCtx struct {
+	goName  string      // Go struct name of the message, e.g. MessageName
+	message *Descriptor // The descriptor for the message
+}
 
-	g.P("type ", Annotate(message.file, message.path, ccTypeName), " struct {")
-	g.In()
+// fieldCommon contains data common to all types of fields.
+type fieldCommon struct {
+	goName     string // Go name of field, e.g. "FieldName" or "Descriptor_"
+	protoName  string // Name of field in proto language, e.g. "field_name" or "descriptor"
+	getterName string // Name of the getter, e.g. "GetFieldName" or "GetDescriptor_"
+	goType     string // The Go type as a string, e.g. "*int32" or "*OtherMessage"
+	tags       string // The tag string/annotation for the type, e.g. `protobuf:"varint,8,opt,name=region_id,json=regionId"`
+	fullPath   string // The full path of the field as used by Annotate etc, e.g. "4,0,2,0"
+}
 
-	// allocNames finds a conflict-free variation of the given strings,
-	// consistently mutating their suffixes.
-	// It returns the same number of strings.
-	allocNames := func(ns ...string) []string {
-	Loop:
-		for {
-			for _, n := range ns {
-				if usedNames[n] {
-					for i := range ns {
-						ns[i] += "_"
-					}
-					continue Loop
-				}
-			}
-			for _, n := range ns {
-				usedNames[n] = true
-			}
-			return ns
-		}
-	}
+// getProtoName gets the proto name of a field, e.g. "field_name" or "descriptor".
+func (f *fieldCommon) getProtoName() string {
+	return f.protoName
+}
 
-	for i, field := range message.Field {
-		// Allocate the getter and the field at the same time so name
-		// collisions create field/method consistent names.
-		// TODO: This allocation occurs based on the order of the fields
-		// in the proto file, meaning that a change in the field
-		// ordering can change generated Method/Field names.
-		base := CamelCase(*field.Name)
-		ns := allocNames(base, "Get"+base)
-		fieldName, fieldGetterName := ns[0], ns[1]
-		typename, wiretype := g.GoType(message, field)
-		jsonName := *field.Name
-		tag := fmt.Sprintf("protobuf:%s json:%q", g.goTag(message, field, wiretype), jsonName+",omitempty")
+// getGoType returns the go type of the field  as a string, e.g. "*int32".
+func (f *fieldCommon) getGoType() string {
+	return f.goType
+}
 
-		fieldNames[field] = fieldName
-		fieldGetterNames[field] = fieldGetterName
+// simpleField is not weak, not a oneof, not an extension. Can be required, optional or repeated.
+type simpleField struct {
+	fieldCommon
+	protoTypeName string                               // Proto type name, empty if primitive, e.g. ".google.protobuf.Duration"
+	protoType     descriptor.FieldDescriptorProto_Type // Actual type enum value, e.g. descriptor.FieldDescriptorProto_TYPE_FIXED64
+	deprecated    string                               // Deprecation comment, if any, e.g. "// Deprecated: Do not use."
+	getterDef     string                               // Default for getters, e.g. "nil", `""` or "Default_MessageType_FieldName"
+	protoDef      string                               // Default value as defined in the proto file, e.g "yoshi" or "5"
+	comment       string                               // The full comment for the field, e.g. "// Useful information"
+}
 
-		oneof := field.OneofIndex != nil
-		if oneof && oneofFieldName[*field.OneofIndex] == "" {
-			odp := message.OneofDecl[int(*field.OneofIndex)]
-			fname := allocNames(CamelCase(odp.GetName()))[0]
+// decl prints the declaration of the field in the struct (if any).
+func (f *simpleField) decl(g *Generator, mc *msgCtx) {
+	g.P(f.comment, Annotate(mc.message.file, f.fullPath, f.goName), "\t", f.goType, "\t`", f.tags, "`", f.deprecated)
+}
 
-			// This is the first field of a oneof we haven't seen before.
-			// Generate the union field.
-			oneofFullPath := fmt.Sprintf("%s,%d,%d", message.path, messageOneofPath, *field.OneofIndex)
-			com := g.PrintComments(oneofFullPath)
-			if com {
-				g.P("//")
-			}
-			g.P("// Types that are valid to be assigned to ", fname, ":")
-			// Generate the rest of this comment later,
-			// when we've computed any disambiguation.
-			oneofInsertPoints[*field.OneofIndex] = g.Buffer.Len()
+// getter prints the getter for the field.
+func (f *simpleField) getter(g *Generator, mc *msgCtx) {
+	star := ""
+	tname := f.goType
+	if needsStar(f.protoType) && tname[0] == '*' {
+		tname = tname[1:]
+		star = "*"
+	}
+	if f.deprecated != "" {
+		g.P(f.deprecated)
+	}
+	g.P("func (m *", mc.goName, ") ", Annotate(mc.message.file, f.fullPath, f.getterName), "() "+tname+" {")
+	if f.getterDef == "nil" { // Simpler getter
+		g.P("if m != nil {")
+		g.P("return m." + f.goName)
+		g.P("}")
+		g.P("return nil")
+		g.P("}")
+		g.P()
+		return
+	}
+	if mc.message.proto3() {
+		g.P("if m != nil {")
+	} else {
+		g.P("if m != nil && m." + f.goName + " != nil {")
+	}
+	g.P("return " + star + "m." + f.goName)
+	g.P("}")
+	g.P("return ", f.getterDef)
+	g.P("}")
+	g.P()
+}
 
-			dname := "is" + ccTypeName + "_" + fname
-			oneofFieldName[*field.OneofIndex] = fname
-			oneofDisc[*field.OneofIndex] = dname
-			tag := `protobuf_oneof:"` + odp.GetName() + `"`
-			g.P(Annotate(message.file, oneofFullPath, fname), " ", dname, " `", tag, "`")
-		}
+// setter prints the setter method of the field.
+func (f *simpleField) setter(g *Generator, mc *msgCtx) {
+	// No setter for regular fields yet
+}
 
-		if *field.Type == descriptor.FieldDescriptorProto_TYPE_MESSAGE {
-			desc := g.ObjectNamed(field.GetTypeName())
-			if d, ok := desc.(*Descriptor); ok && d.GetOptions().GetMapEntry() {
-				// Figure out the Go types and tags for the key and value types.
-				keyField, valField := d.Field[0], d.Field[1]
-				keyType, keyWire := g.GoType(d, keyField)
-				valType, valWire := g.GoType(d, valField)
-				keyTag, valTag := g.goTag(d, keyField, keyWire), g.goTag(d, valField, valWire)
+// getProtoDef returns the default value explicitly stated in the proto file, e.g "yoshi" or "5".
+func (f *simpleField) getProtoDef() string {
+	return f.protoDef
+}
 
-				// We don't use stars, except for message-typed values.
-				// Message and enum types are the only two possibly foreign types used in maps,
-				// so record their use. They are not permitted as map keys.
-				keyType = strings.TrimPrefix(keyType, "*")
-				switch *valField.Type {
-				case descriptor.FieldDescriptorProto_TYPE_ENUM:
-					valType = strings.TrimPrefix(valType, "*")
-					g.RecordTypeUse(valField.GetTypeName())
-				case descriptor.FieldDescriptorProto_TYPE_MESSAGE:
-					g.RecordTypeUse(valField.GetTypeName())
-				default:
-					valType = strings.TrimPrefix(valType, "*")
-				}
+// getProtoTypeName returns the protobuf type name for the field as returned by field.GetTypeName(), e.g. ".google.protobuf.Duration".
+func (f *simpleField) getProtoTypeName() string {
+	return f.protoTypeName
+}
 
-				typename = fmt.Sprintf("map[%s]%s", keyType, valType)
-				mapFieldTypes[field] = typename // record for the getter generation
+// getProtoType returns the *field.Type value, e.g. descriptor.FieldDescriptorProto_TYPE_FIXED64.
+func (f *simpleField) getProtoType() descriptor.FieldDescriptorProto_Type {
+	return f.protoType
+}
 
-				tag += fmt.Sprintf(" protobuf_key:%s protobuf_val:%s", keyTag, valTag)
-			}
-		}
+// oneofSubFields are kept slize held by each oneofField. They do not appear in the top level slize of fields for the message.
+type oneofSubField struct {
+	fieldCommon
+	protoTypeName string                               // Proto type name, empty if primitive, e.g. ".google.protobuf.Duration"
+	protoType     descriptor.FieldDescriptorProto_Type // Actual type enum value, e.g. descriptor.FieldDescriptorProto_TYPE_FIXED64
+	oneofTypeName string                               // Type name of the enclosing struct, e.g. "MessageName_FieldName"
+	fieldNumber   int                                  // Actual field number, as defined in proto, e.g. 12
+	getterDef     string                               // Default for getters, e.g. "nil", `""` or "Default_MessageType_FieldName"
+	protoDef      string                               // Default value as defined in the proto file, e.g "yoshi" or "5"
+	deprecated    string                               // Deprecation comment, if any.
+}
 
-		fieldTypes[field] = typename
+// typedNil prints a nil casted to the pointer to this field.
+// - for XXX_OneofWrappers
+func (f *oneofSubField) typedNil(g *Generator) {
+	g.P("(*", f.oneofTypeName, ")(nil),")
+}
 
-		if oneof {
-			tname := ccTypeName + "_" + fieldName
-			// It is possible for this to collide with a message or enum
-			// nested in this message. Check for collisions.
-			for {
-				ok := true
-				for _, desc := range message.nested {
-					if CamelCaseSlice(desc.TypeName()) == tname {
-						ok = false
-						break
-					}
-				}
-				for _, enum := range message.enums {
-					if CamelCaseSlice(enum.TypeName()) == tname {
-						ok = false
-						break
-					}
-				}
-				if !ok {
-					tname += "_"
-					continue
-				}
-				break
-			}
+// getProtoDef returns the default value explicitly stated in the proto file, e.g "yoshi" or "5".
+func (f *oneofSubField) getProtoDef() string {
+	return f.protoDef
+}
 
-			oneofTypeName[field] = tname
-			continue
-		}
+// getProtoTypeName returns the protobuf type name for the field as returned by field.GetTypeName(), e.g. ".google.protobuf.Duration".
+func (f *oneofSubField) getProtoTypeName() string {
+	return f.protoTypeName
+}
 
-		fieldDeprecated := ""
-		if field.GetOptions().GetDeprecated() {
-			fieldDeprecated = deprecationComment
-		}
+// getProtoType returns the *field.Type value, e.g. descriptor.FieldDescriptorProto_TYPE_FIXED64.
+func (f *oneofSubField) getProtoType() descriptor.FieldDescriptorProto_Type {
+	return f.protoType
+}
 
-		fieldFullPath := fmt.Sprintf("%s,%d,%d", message.path, messageFieldPath, i)
-		g.PrintComments(fieldFullPath)
-		g.P(Annotate(message.file, fieldFullPath, fieldName), "\t", typename, "\t`", tag, "`", fieldDeprecated)
-		g.RecordTypeUse(field.GetTypeName())
-	}
-	g.P("XXX_NoUnkeyedLiteral\tstruct{} `json:\"-\"`") // prevent unkeyed struct literals
-	if len(message.ExtensionRange) > 0 {
-		messageset := ""
-		if opts := message.Options; opts != nil && opts.GetMessageSetWireFormat() {
-			messageset = "protobuf_messageset:\"1\" "
-		}
-		g.P(g.Pkg["proto"], ".XXX_InternalExtensions `", messageset, "json:\"-\"`")
+// oneofField represents the oneof on top level.
+// The alternative fields within the oneof are represented by oneofSubField.
+type oneofField struct {
+	fieldCommon
+	subFields []*oneofSubField // All the possible oneof fields
+	comment   string           // The full comment for the field, e.g. "// Types that are valid to be assigned to MyOneof:\n\\"
+}
+
+// decl prints the declaration of the field in the struct (if any).
+func (f *oneofField) decl(g *Generator, mc *msgCtx) {
+	comment := f.comment
+	for _, sf := range f.subFields {
+		comment += "//\t*" + sf.oneofTypeName + "\n"
 	}
-	g.P("XXX_unrecognized\t[]byte `json:\"-\"`")
-	g.P("XXX_sizecache\tint32 `json:\"-\"`")
-	g.Out()
-	g.P("}")
+	g.P(comment, Annotate(mc.message.file, f.fullPath, f.goName), " ", f.goType, " `", f.tags, "`")
+}
 
-	// Update g.Buffer to list valid oneof types.
-	// We do this down here, after we've disambiguated the oneof type names.
-	// We go in reverse order of insertion point to avoid invalidating offsets.
-	for oi := int32(len(message.OneofDecl)); oi >= 0; oi-- {
-		ip := oneofInsertPoints[oi]
-		all := g.Buffer.Bytes()
-		rem := all[ip:]
-		g.Buffer = bytes.NewBuffer(all[:ip:ip]) // set cap so we don't scribble on rem
-		oldLen := g.Buffer.Len()
-		for _, field := range message.Field {
-			if field.OneofIndex == nil || *field.OneofIndex != oi {
-				continue
-			}
-			g.P("//\t*", oneofTypeName[field])
-		}
-		// If we've inserted text, we also need to fix up affected annotations (as
-		// they contain offsets that may need to be changed).
-		offset := int32(g.Buffer.Len() - oldLen)
-		ip32 := int32(ip)
-		for _, anno := range g.annotations {
-			if *anno.Begin >= ip32 {
-				*anno.Begin += offset
-			}
-			if *anno.End >= ip32 {
-				*anno.End += offset
-			}
-		}
-		g.Buffer.Write(rem)
-	}
-
-	// Reset, String and ProtoMessage methods.
-	g.P("func (m *", ccTypeName, ") Reset() { *m = ", ccTypeName, "{} }")
-	g.P("func (m *", ccTypeName, ") String() string { return ", g.Pkg["proto"], ".CompactTextString(m) }")
-	g.P("func (*", ccTypeName, ") ProtoMessage() {}")
-	var indexes []string
-	for m := message; m != nil; m = m.parent {
-		indexes = append([]string{strconv.Itoa(m.index)}, indexes...)
-	}
-	g.P("func (*", ccTypeName, ") Descriptor() ([]byte, []int) {")
-	g.In()
-	g.P("return ", g.file.VarName(), ", []int{", strings.Join(indexes, ", "), "}")
-	g.Out()
+// getter for a oneof field will print additional discriminators and interfaces for the oneof,
+// also it prints all the getters for the sub fields.
+func (f *oneofField) getter(g *Generator, mc *msgCtx) {
+	// The discriminator type
+	g.P("type ", f.goType, " interface {")
+	g.P(f.goType, "()")
 	g.P("}")
-	// TODO: Revisit the decision to use a XXX_WellKnownType method
-	// if we change proto.MessageName to work with multiple equivalents.
-	if message.file.GetPackage() == "google.protobuf" && wellKnownTypes[message.GetName()] {
-		g.P("func (*", ccTypeName, `) XXX_WellKnownType() string { return "`, message.GetName(), `" }`)
+	g.P()
+	// The subField types, fulfilling the discriminator type contract
+	for _, sf := range f.subFields {
+		g.P("type ", Annotate(mc.message.file, sf.fullPath, sf.oneofTypeName), " struct {")
+		g.P(Annotate(mc.message.file, sf.fullPath, sf.goName), " ", sf.goType, " `", sf.tags, "`")
+		g.P("}")
+		g.P()
 	}
-
-	// Extension support methods
-	var hasExtensions, isMessageSet bool
-	if len(message.ExtensionRange) > 0 {
-		hasExtensions = true
-		// message_set_wire_format only makes sense when extensions are defined.
-		if opts := message.Options; opts != nil && opts.GetMessageSetWireFormat() {
-			isMessageSet = true
-			g.P()
-			g.P("func (m *", ccTypeName, ") MarshalJSON() ([]byte, error) {")
-			g.In()
-			g.P("return ", g.Pkg["proto"], ".MarshalMessageSetJSON(&m.XXX_InternalExtensions)")
-			g.Out()
-			g.P("}")
-			g.P("func (m *", ccTypeName, ") UnmarshalJSON(buf []byte) error {")
-			g.In()
-			g.P("return ", g.Pkg["proto"], ".UnmarshalMessageSetJSON(buf, &m.XXX_InternalExtensions)")
-			g.Out()
-			g.P("}")
-		}
-
+	for _, sf := range f.subFields {
+		g.P("func (*", sf.oneofTypeName, ") ", f.goType, "() {}")
 		g.P()
-		g.P("var extRange_", ccTypeName, " = []", g.Pkg["proto"], ".ExtensionRange{")
-		g.In()
-		for _, r := range message.ExtensionRange {
-			end := fmt.Sprint(*r.End - 1) // make range inclusive on both ends
-			g.P("{Start: ", r.Start, ", End: ", end, "},")
-		}
-		g.Out()
+	}
+	// Getter for the oneof field
+	g.P("func (m *", mc.goName, ") ", Annotate(mc.message.file, f.fullPath, f.getterName), "() ", f.goType, " {")
+	g.P("if m != nil { return m.", f.goName, " }")
+	g.P("return nil")
+	g.P("}")
+	g.P()
+	// Getters for each oneof
+	for _, sf := range f.subFields {
+		if sf.deprecated != "" {
+			g.P(sf.deprecated)
+		}
+		g.P("func (m *", mc.goName, ") ", Annotate(mc.message.file, sf.fullPath, sf.getterName), "() "+sf.goType+" {")
+		g.P("if x, ok := m.", f.getterName, "().(*", sf.oneofTypeName, "); ok {")
+		g.P("return x.", sf.goName)
 		g.P("}")
-		g.P("func (*", ccTypeName, ") ExtensionRangeArray() []", g.Pkg["proto"], ".ExtensionRange {")
-		g.In()
-		g.P("return extRange_", ccTypeName)
-		g.Out()
+		g.P("return ", sf.getterDef)
 		g.P("}")
+		g.P()
 	}
+}
 
-	// TODO: It does not scale to keep adding another method for every
-	// operation on protos that we want to switch over to using the
-	// table-driven approach. Instead, we should only add a single method
-	// that allows getting access to the *InternalMessageInfo struct and then
-	// calling Unmarshal, Marshal, Merge, Size, and Discard directly on that.
-
-	// Wrapper for table-driven marshaling and unmarshaling.
-	g.P("func (m *", ccTypeName, ") XXX_Unmarshal(b []byte) error {")
-	g.In()
-	g.P("return xxx_messageInfo_", ccTypeName, ".Unmarshal(m, b)")
-	g.Out()
-	g.P("}")
-
-	g.P("func (m *", ccTypeName, ") XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {")
-	g.In()
-	g.P("return xxx_messageInfo_", ccTypeName, ".Marshal(b, m, deterministic)")
-	g.Out()
-	g.P("}")
-
-	g.P("func (dst *", ccTypeName, ") XXX_Merge(src ", g.Pkg["proto"], ".Message) {")
-	g.In()
-	g.P("xxx_messageInfo_", ccTypeName, ".Merge(dst, src)")
-	g.Out()
-	g.P("}")
-
-	g.P("func (m *", ccTypeName, ") XXX_Size() int {") // avoid name clash with "Size" field in some message
-	g.In()
-	g.P("return xxx_messageInfo_", ccTypeName, ".Size(m)")
-	g.Out()
-	g.P("}")
+// setter prints the setter method of the field.
+func (f *oneofField) setter(g *Generator, mc *msgCtx) {
+	// No setters for oneof yet
+}
 
-	g.P("func (m *", ccTypeName, ") XXX_DiscardUnknown() {")
-	g.In()
-	g.P("xxx_messageInfo_", ccTypeName, ".DiscardUnknown(m)")
-	g.Out()
-	g.P("}")
+// topLevelField interface implemented by all types of fields on the top level (not oneofSubField).
+type topLevelField interface {
+	decl(g *Generator, mc *msgCtx)   // print declaration within the struct
+	getter(g *Generator, mc *msgCtx) // print getter
+	setter(g *Generator, mc *msgCtx) // print setter if applicable
+}
 
-	g.P("var xxx_messageInfo_", ccTypeName, " ", g.Pkg["proto"], ".InternalMessageInfo")
+// defField interface implemented by all types of fields that can have defaults (not oneofField, but instead oneofSubField).
+type defField interface {
+	getProtoDef() string                                // default value explicitly stated in the proto file, e.g "yoshi" or "5"
+	getProtoName() string                               // proto name of a field, e.g. "field_name" or "descriptor"
+	getGoType() string                                  // go type of the field  as a string, e.g. "*int32"
+	getProtoTypeName() string                           // protobuf type name for the field, e.g. ".google.protobuf.Duration"
+	getProtoType() descriptor.FieldDescriptorProto_Type // *field.Type value, e.g. descriptor.FieldDescriptorProto_TYPE_FIXED64
+}
 
-	// Default constants
-	defNames := make(map[*descriptor.FieldDescriptorProto]string)
-	for _, field := range message.Field {
-		def := field.GetDefaultValue()
+// generateDefaultConstants adds constants for default values if needed, which is only if the default value is.
+// explicit in the proto.
+func (g *Generator) generateDefaultConstants(mc *msgCtx, topLevelFields []topLevelField) {
+	// Collect fields that can have defaults
+	dFields := []defField{}
+	for _, pf := range topLevelFields {
+		if f, ok := pf.(*oneofField); ok {
+			for _, osf := range f.subFields {
+				dFields = append(dFields, osf)
+			}
+			continue
+		}
+		dFields = append(dFields, pf.(defField))
+	}
+	for _, df := range dFields {
+		def := df.getProtoDef()
 		if def == "" {
 			continue
 		}
-		fieldname := "Default_" + ccTypeName + "_" + CamelCase(*field.Name)
-		defNames[field] = fieldname
-		typename, _ := g.GoType(message, field)
+		fieldname := g.defaultConstantName(mc.goName, df.getProtoName())
+		typename := df.getGoType()
 		if typename[0] == '*' {
 			typename = typename[1:]
 		}
@@ -2049,13 +1995,21 @@ func (g *Generator) generateMessage(message *Descriptor) {
 			case "nan":
 				def = "math.NaN()"
 			}
-			if *field.Type == descriptor.FieldDescriptorProto_TYPE_FLOAT {
+			if df.getProtoType() == descriptor.FieldDescriptorProto_TYPE_FLOAT {
 				def = "float32(" + def + ")"
 			}
 			kind = "var "
-		case *field.Type == descriptor.FieldDescriptorProto_TYPE_ENUM:
+		case df.getProtoType() == descriptor.FieldDescriptorProto_TYPE_FLOAT:
+			if f, err := strconv.ParseFloat(def, 32); err == nil {
+				def = fmt.Sprint(float32(f))
+			}
+		case df.getProtoType() == descriptor.FieldDescriptorProto_TYPE_DOUBLE:
+			if f, err := strconv.ParseFloat(def, 64); err == nil {
+				def = fmt.Sprint(f)
+			}
+		case df.getProtoType() == descriptor.FieldDescriptorProto_TYPE_ENUM:
 			// Must be an enum.  Need to construct the prefixed name.
-			obj := g.ObjectNamed(field.GetTypeName())
+			obj := g.ObjectNamed(df.getProtoTypeName())
 			var enum *EnumDescriptor
 			if id, ok := obj.(*ImportedDescriptor); ok {
 				// The enum type has been publicly imported.
@@ -2070,456 +2024,388 @@ func (g *Generator) generateMessage(message *Descriptor) {
 			def = g.DefaultPackageName(obj) + enum.prefix() + def
 		}
 		g.P(kind, fieldname, " ", typename, " = ", def)
-		g.file.addExport(message, constOrVarSymbol{fieldname, kind, ""})
+		g.file.addExport(mc.message, constOrVarSymbol{fieldname, kind, ""})
 	}
 	g.P()
+}
 
-	// Oneof per-field types, discriminants and getters.
-	//
-	// Generate unexported named types for the discriminant interfaces.
-	// We shouldn't have to do this, but there was (~19 Aug 2015) a compiler/linker bug
-	// that was triggered by using anonymous interfaces here.
-	// TODO: Revisit this and consider reverting back to anonymous interfaces.
-	for oi := range message.OneofDecl {
-		dname := oneofDisc[int32(oi)]
-		g.P("type ", dname, " interface {")
-		g.In()
-		g.P(dname, "()")
-		g.Out()
-		g.P("}")
-	}
-	g.P()
-	var oneofTypes []string
-	for i, field := range message.Field {
-		if field.OneofIndex == nil {
-			continue
+// generateInternalStructFields just adds the XXX_<something> fields to the message struct.
+func (g *Generator) generateInternalStructFields(mc *msgCtx, topLevelFields []topLevelField) {
+	g.P("XXX_NoUnkeyedLiteral\tstruct{} `json:\"-\"`") // prevent unkeyed struct literals
+	if len(mc.message.ExtensionRange) > 0 {
+		messageset := ""
+		if opts := mc.message.Options; opts != nil && opts.GetMessageSetWireFormat() {
+			messageset = "protobuf_messageset:\"1\" "
 		}
-		_, wiretype := g.GoType(message, field)
-		tag := "protobuf:" + g.goTag(message, field, wiretype)
-		fieldFullPath := fmt.Sprintf("%s,%d,%d", message.path, messageFieldPath, i)
-		g.P("type ", Annotate(message.file, fieldFullPath, oneofTypeName[field]), " struct{ ", Annotate(message.file, fieldFullPath, fieldNames[field]), " ", fieldTypes[field], " `", tag, "` }")
-		g.RecordTypeUse(field.GetTypeName())
-		oneofTypes = append(oneofTypes, oneofTypeName[field])
+		g.P(g.Pkg["proto"], ".XXX_InternalExtensions `", messageset, "json:\"-\"`")
 	}
-	g.P()
-	for _, field := range message.Field {
-		if field.OneofIndex == nil {
-			continue
+	g.P("XXX_unrecognized\t[]byte `json:\"-\"`")
+	g.P("XXX_sizecache\tint32 `json:\"-\"`")
+
+}
+
+// generateOneofFuncs adds all the utility functions for oneof, including marshalling, unmarshalling and sizer.
+func (g *Generator) generateOneofFuncs(mc *msgCtx, topLevelFields []topLevelField) {
+	ofields := []*oneofField{}
+	for _, f := range topLevelFields {
+		if o, ok := f.(*oneofField); ok {
+			ofields = append(ofields, o)
 		}
-		g.P("func (*", oneofTypeName[field], ") ", oneofDisc[*field.OneofIndex], "() {}")
 	}
-	g.P()
-	for oi := range message.OneofDecl {
-		fname := oneofFieldName[int32(oi)]
-		oneofFullPath := fmt.Sprintf("%s,%d,%d", message.path, messageOneofPath, oi)
-		g.P("func (m *", ccTypeName, ") ", Annotate(message.file, oneofFullPath, "Get"+fname), "() ", oneofDisc[int32(oi)], " {")
-		g.P("if m != nil { return m.", fname, " }")
-		g.P("return nil")
-		g.P("}")
+	if len(ofields) == 0 {
+		return
 	}
-	g.P()
 
-	// Field getters
-	for i, field := range message.Field {
-		oneof := field.OneofIndex != nil
-
-		fname := fieldNames[field]
-		typename, _ := g.GoType(message, field)
-		if t, ok := mapFieldTypes[field]; ok {
-			typename = t
-		}
-		mname := fieldGetterNames[field]
-		star := ""
-		if needsStar(*field.Type) && typename[0] == '*' {
-			typename = typename[1:]
-			star = "*"
+	// OneofFuncs
+	g.P("// XXX_OneofWrappers is for the internal use of the proto package.")
+	g.P("func (*", mc.goName, ") XXX_OneofWrappers() []interface{} {")
+	g.P("return []interface{}{")
+	for _, of := range ofields {
+		for _, sf := range of.subFields {
+			sf.typedNil(g)
 		}
-		fieldFullPath := fmt.Sprintf("%s,%d,%d", message.path, messageFieldPath, i)
+	}
+	g.P("}")
+	g.P("}")
+	g.P()
+}
 
-		if field.GetOptions().GetDeprecated() {
-			g.P(deprecationComment)
-		}
+// generateMessageStruct adds the actual struct with it's members (but not methods) to the output.
+func (g *Generator) generateMessageStruct(mc *msgCtx, topLevelFields []topLevelField) {
+	comments := g.PrintComments(mc.message.path)
 
-		g.P("func (m *", ccTypeName, ") ", Annotate(message.file, fieldFullPath, mname), "() "+typename+" {")
-		g.In()
-		def, hasDef := defNames[field]
-		typeDefaultIsNil := false // whether this field type's default value is a literal nil unless specified
-		switch *field.Type {
-		case descriptor.FieldDescriptorProto_TYPE_BYTES:
-			typeDefaultIsNil = !hasDef
-		case descriptor.FieldDescriptorProto_TYPE_GROUP, descriptor.FieldDescriptorProto_TYPE_MESSAGE:
-			typeDefaultIsNil = true
-		}
-		if isRepeated(field) {
-			typeDefaultIsNil = true
-		}
-		if typeDefaultIsNil && !oneof {
-			// A bytes field with no explicit default needs less generated code,
-			// as does a message or group field, or a repeated field.
-			g.P("if m != nil {")
-			g.In()
-			g.P("return m." + fname)
-			g.Out()
-			g.P("}")
-			g.P("return nil")
-			g.Out()
-			g.P("}")
-			g.P()
-			continue
-		}
-		if !oneof {
-			if message.proto3() {
-				g.P("if m != nil {")
-			} else {
-				g.P("if m != nil && m." + fname + " != nil {")
-			}
-			g.In()
-			g.P("return " + star + "m." + fname)
-			g.Out()
-			g.P("}")
-		} else {
-			uname := oneofFieldName[*field.OneofIndex]
-			tname := oneofTypeName[field]
-			g.P("if x, ok := m.Get", uname, "().(*", tname, "); ok {")
-			g.P("return x.", fname)
-			g.P("}")
-		}
-		if hasDef {
-			if *field.Type != descriptor.FieldDescriptorProto_TYPE_BYTES {
-				g.P("return " + def)
-			} else {
-				// The default is a []byte var.
-				// Make a copy when returning it to be safe.
-				g.P("return append([]byte(nil), ", def, "...)")
-			}
-		} else {
-			switch *field.Type {
-			case descriptor.FieldDescriptorProto_TYPE_BOOL:
-				g.P("return false")
-			case descriptor.FieldDescriptorProto_TYPE_STRING:
-				g.P(`return ""`)
-			case descriptor.FieldDescriptorProto_TYPE_GROUP,
-				descriptor.FieldDescriptorProto_TYPE_MESSAGE,
-				descriptor.FieldDescriptorProto_TYPE_BYTES:
-				// This is only possible for oneof fields.
-				g.P("return nil")
-			case descriptor.FieldDescriptorProto_TYPE_ENUM:
-				// The default default for an enum is the first value in the enum,
-				// not zero.
-				obj := g.ObjectNamed(field.GetTypeName())
-				var enum *EnumDescriptor
-				if id, ok := obj.(*ImportedDescriptor); ok {
-					// The enum type has been publicly imported.
-					enum, _ = id.o.(*EnumDescriptor)
-				} else {
-					enum, _ = obj.(*EnumDescriptor)
-				}
-				if enum == nil {
-					log.Printf("don't know how to generate getter for %s", field.GetName())
-					continue
-				}
-				if len(enum.Value) == 0 {
-					g.P("return 0 // empty enum")
-				} else {
-					first := enum.Value[0].GetName()
-					g.P("return ", g.DefaultPackageName(obj)+enum.prefix()+first)
-				}
-			default:
-				g.P("return 0")
-			}
+	// Guarantee deprecation comments appear after user-provided comments.
+	if mc.message.GetOptions().GetDeprecated() {
+		if comments {
+			// Convention: Separate deprecation comments from original
+			// comments with an empty line.
+			g.P("//")
 		}
-		g.Out()
-		g.P("}")
-		g.P()
+		g.P(deprecationComment)
 	}
 
-	if !message.group {
-		ms := &messageSymbol{
-			sym:           ccTypeName,
-			hasExtensions: hasExtensions,
-			isMessageSet:  isMessageSet,
-			oneofTypes:    oneofTypes,
-		}
-		g.file.addExport(message, ms)
+	g.P("type ", Annotate(mc.message.file, mc.message.path, mc.goName), " struct {")
+	for _, pf := range topLevelFields {
+		pf.decl(g, mc)
+	}
+	g.generateInternalStructFields(mc, topLevelFields)
+	g.P("}")
+}
+
+// generateGetters adds getters for all fields, including oneofs and weak fields when applicable.
+func (g *Generator) generateGetters(mc *msgCtx, topLevelFields []topLevelField) {
+	for _, pf := range topLevelFields {
+		pf.getter(g, mc)
 	}
+}
 
-	// Oneof functions
-	if len(message.OneofDecl) > 0 {
-		fieldWire := make(map[*descriptor.FieldDescriptorProto]string)
+// generateSetters add setters for all fields, including oneofs and weak fields when applicable.
+func (g *Generator) generateSetters(mc *msgCtx, topLevelFields []topLevelField) {
+	for _, pf := range topLevelFields {
+		pf.setter(g, mc)
+	}
+}
 
-		// method
-		enc := "_" + ccTypeName + "_OneofMarshaler"
-		dec := "_" + ccTypeName + "_OneofUnmarshaler"
-		size := "_" + ccTypeName + "_OneofSizer"
-		encSig := "(msg " + g.Pkg["proto"] + ".Message, b *" + g.Pkg["proto"] + ".Buffer) error"
-		decSig := "(msg " + g.Pkg["proto"] + ".Message, tag, wire int, b *" + g.Pkg["proto"] + ".Buffer) (bool, error)"
-		sizeSig := "(msg " + g.Pkg["proto"] + ".Message) (n int)"
+// generateCommonMethods adds methods to the message that are not on a per field basis.
+func (g *Generator) generateCommonMethods(mc *msgCtx) {
+	// Reset, String and ProtoMessage methods.
+	g.P("func (m *", mc.goName, ") Reset() { *m = ", mc.goName, "{} }")
+	g.P("func (m *", mc.goName, ") String() string { return ", g.Pkg["proto"], ".CompactTextString(m) }")
+	g.P("func (*", mc.goName, ") ProtoMessage() {}")
+	var indexes []string
+	for m := mc.message; m != nil; m = m.parent {
+		indexes = append([]string{strconv.Itoa(m.index)}, indexes...)
+	}
+	g.P("func (*", mc.goName, ") Descriptor() ([]byte, []int) {")
+	g.P("return ", g.file.VarName(), ", []int{", strings.Join(indexes, ", "), "}")
+	g.P("}")
+	g.P()
+	// TODO: Revisit the decision to use a XXX_WellKnownType method
+	// if we change proto.MessageName to work with multiple equivalents.
+	if mc.message.file.GetPackage() == "google.protobuf" && wellKnownTypes[mc.message.GetName()] {
+		g.P("func (*", mc.goName, `) XXX_WellKnownType() string { return "`, mc.message.GetName(), `" }`)
+		g.P()
+	}
 
-		g.P("// XXX_OneofFuncs is for the internal use of the proto package.")
-		g.P("func (*", ccTypeName, ") XXX_OneofFuncs() (func", encSig, ", func", decSig, ", func", sizeSig, ", []interface{}) {")
-		g.P("return ", enc, ", ", dec, ", ", size, ", []interface{}{")
-		for _, field := range message.Field {
-			if field.OneofIndex == nil {
-				continue
-			}
-			g.P("(*", oneofTypeName[field], ")(nil),")
+	// Extension support methods
+	if len(mc.message.ExtensionRange) > 0 {
+		g.P()
+		g.P("var extRange_", mc.goName, " = []", g.Pkg["proto"], ".ExtensionRange{")
+		for _, r := range mc.message.ExtensionRange {
+			end := fmt.Sprint(*r.End - 1) // make range inclusive on both ends
+			g.P("{Start: ", r.Start, ", End: ", end, "},")
 		}
 		g.P("}")
+		g.P("func (*", mc.goName, ") ExtensionRangeArray() []", g.Pkg["proto"], ".ExtensionRange {")
+		g.P("return extRange_", mc.goName)
 		g.P("}")
 		g.P()
+	}
 
-		// marshaler
-		g.P("func ", enc, encSig, " {")
-		g.P("m := msg.(*", ccTypeName, ")")
-		for oi, odp := range message.OneofDecl {
-			g.P("// ", odp.GetName())
-			fname := oneofFieldName[int32(oi)]
-			g.P("switch x := m.", fname, ".(type) {")
-			for _, field := range message.Field {
-				if field.OneofIndex == nil || int(*field.OneofIndex) != oi {
-					continue
-				}
-				g.P("case *", oneofTypeName[field], ":")
-				var wire, pre, post string
-				val := "x." + fieldNames[field] // overridden for TYPE_BOOL
-				canFail := false                // only TYPE_MESSAGE and TYPE_GROUP can fail
-				switch *field.Type {
-				case descriptor.FieldDescriptorProto_TYPE_DOUBLE:
-					wire = "WireFixed64"
-					pre = "b.EncodeFixed64(" + g.Pkg["math"] + ".Float64bits("
-					post = "))"
-				case descriptor.FieldDescriptorProto_TYPE_FLOAT:
-					wire = "WireFixed32"
-					pre = "b.EncodeFixed32(uint64(" + g.Pkg["math"] + ".Float32bits("
-					post = ")))"
-				case descriptor.FieldDescriptorProto_TYPE_INT64,
-					descriptor.FieldDescriptorProto_TYPE_UINT64:
-					wire = "WireVarint"
-					pre, post = "b.EncodeVarint(uint64(", "))"
-				case descriptor.FieldDescriptorProto_TYPE_INT32,
-					descriptor.FieldDescriptorProto_TYPE_UINT32,
-					descriptor.FieldDescriptorProto_TYPE_ENUM:
-					wire = "WireVarint"
-					pre, post = "b.EncodeVarint(uint64(", "))"
-				case descriptor.FieldDescriptorProto_TYPE_FIXED64,
-					descriptor.FieldDescriptorProto_TYPE_SFIXED64:
-					wire = "WireFixed64"
-					pre, post = "b.EncodeFixed64(uint64(", "))"
-				case descriptor.FieldDescriptorProto_TYPE_FIXED32,
-					descriptor.FieldDescriptorProto_TYPE_SFIXED32:
-					wire = "WireFixed32"
-					pre, post = "b.EncodeFixed32(uint64(", "))"
-				case descriptor.FieldDescriptorProto_TYPE_BOOL:
-					// bool needs special handling.
-					g.P("t := uint64(0)")
-					g.P("if ", val, " { t = 1 }")
-					val = "t"
-					wire = "WireVarint"
-					pre, post = "b.EncodeVarint(", ")"
-				case descriptor.FieldDescriptorProto_TYPE_STRING:
-					wire = "WireBytes"
-					pre, post = "b.EncodeStringBytes(", ")"
-				case descriptor.FieldDescriptorProto_TYPE_GROUP:
-					wire = "WireStartGroup"
-					pre, post = "b.Marshal(", ")"
-					canFail = true
-				case descriptor.FieldDescriptorProto_TYPE_MESSAGE:
-					wire = "WireBytes"
-					pre, post = "b.EncodeMessage(", ")"
-					canFail = true
-				case descriptor.FieldDescriptorProto_TYPE_BYTES:
-					wire = "WireBytes"
-					pre, post = "b.EncodeRawBytes(", ")"
-				case descriptor.FieldDescriptorProto_TYPE_SINT32:
-					wire = "WireVarint"
-					pre, post = "b.EncodeZigzag32(uint64(", "))"
-				case descriptor.FieldDescriptorProto_TYPE_SINT64:
-					wire = "WireVarint"
-					pre, post = "b.EncodeZigzag64(uint64(", "))"
-				default:
-					g.Fail("unhandled oneof field type ", field.Type.String())
-				}
-				fieldWire[field] = wire
-				g.P("b.EncodeVarint(", field.Number, "<<3|", g.Pkg["proto"], ".", wire, ")")
-				if !canFail {
-					g.P(pre, val, post)
-				} else {
-					g.P("if err := ", pre, val, post, "; err != nil {")
-					g.P("return err")
-					g.P("}")
-				}
-				if *field.Type == descriptor.FieldDescriptorProto_TYPE_GROUP {
-					g.P("b.EncodeVarint(", field.Number, "<<3|", g.Pkg["proto"], ".WireEndGroup)")
+	// TODO: It does not scale to keep adding another method for every
+	// operation on protos that we want to switch over to using the
+	// table-driven approach. Instead, we should only add a single method
+	// that allows getting access to the *InternalMessageInfo struct and then
+	// calling Unmarshal, Marshal, Merge, Size, and Discard directly on that.
+
+	// Wrapper for table-driven marshaling and unmarshaling.
+	g.P("func (m *", mc.goName, ") XXX_Unmarshal(b []byte) error {")
+	g.P("return xxx_messageInfo_", mc.goName, ".Unmarshal(m, b)")
+	g.P("}")
+
+	g.P("func (m *", mc.goName, ") XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {")
+	g.P("return xxx_messageInfo_", mc.goName, ".Marshal(b, m, deterministic)")
+	g.P("}")
+
+	g.P("func (m *", mc.goName, ") XXX_Merge(src ", g.Pkg["proto"], ".Message) {")
+	g.P("xxx_messageInfo_", mc.goName, ".Merge(m, src)")
+	g.P("}")
+
+	g.P("func (m *", mc.goName, ") XXX_Size() int {") // avoid name clash with "Size" field in some message
+	g.P("return xxx_messageInfo_", mc.goName, ".Size(m)")
+	g.P("}")
+
+	g.P("func (m *", mc.goName, ") XXX_DiscardUnknown() {")
+	g.P("xxx_messageInfo_", mc.goName, ".DiscardUnknown(m)")
+	g.P("}")
+
+	g.P("var xxx_messageInfo_", mc.goName, " ", g.Pkg["proto"], ".InternalMessageInfo")
+	g.P()
+}
+
+// Generate the type, methods and default constant definitions for this Descriptor.
+func (g *Generator) generateMessage(message *Descriptor) {
+	topLevelFields := []topLevelField{}
+	oFields := make(map[int32]*oneofField)
+	// The full type name
+	typeName := message.TypeName()
+	// The full type name, CamelCased.
+	goTypeName := CamelCaseSlice(typeName)
+
+	usedNames := make(map[string]bool)
+	for _, n := range methodNames {
+		usedNames[n] = true
+	}
+
+	// allocNames finds a conflict-free variation of the given strings,
+	// consistently mutating their suffixes.
+	// It returns the same number of strings.
+	allocNames := func(ns ...string) []string {
+	Loop:
+		for {
+			for _, n := range ns {
+				if usedNames[n] {
+					for i := range ns {
+						ns[i] += "_"
+					}
+					continue Loop
 				}
 			}
-			g.P("case nil:")
-			g.P("default: return ", g.Pkg["fmt"], `.Errorf("`, ccTypeName, ".", fname, ` has unexpected type %T", x)`)
-			g.P("}")
+			for _, n := range ns {
+				usedNames[n] = true
+			}
+			return ns
 		}
-		g.P("return nil")
-		g.P("}")
-		g.P()
+	}
 
-		// unmarshaler
-		g.P("func ", dec, decSig, " {")
-		g.P("m := msg.(*", ccTypeName, ")")
-		g.P("switch tag {")
-		for _, field := range message.Field {
-			if field.OneofIndex == nil {
-				continue
-			}
+	mapFieldTypes := make(map[*descriptor.FieldDescriptorProto]string) // keep track of the map fields to be added later
+
+	// Build a structure more suitable for generating the text in one pass
+	for i, field := range message.Field {
+		// Allocate the getter and the field at the same time so name
+		// collisions create field/method consistent names.
+		// TODO: This allocation occurs based on the order of the fields
+		// in the proto file, meaning that a change in the field
+		// ordering can change generated Method/Field names.
+		base := CamelCase(*field.Name)
+		ns := allocNames(base, "Get"+base)
+		fieldName, fieldGetterName := ns[0], ns[1]
+		typename, wiretype := g.GoType(message, field)
+		jsonName := *field.Name
+		tag := fmt.Sprintf("protobuf:%s json:%q", g.goTag(message, field, wiretype), jsonName+",omitempty")
+
+		oneof := field.OneofIndex != nil
+		if oneof && oFields[*field.OneofIndex] == nil {
 			odp := message.OneofDecl[int(*field.OneofIndex)]
-			g.P("case ", field.Number, ": // ", odp.GetName(), ".", *field.Name)
-			g.P("if wire != ", g.Pkg["proto"], ".", fieldWire[field], " {")
-			g.P("return true, ", g.Pkg["proto"], ".ErrInternalBadWireType")
-			g.P("}")
-			lhs := "x, err" // overridden for TYPE_MESSAGE and TYPE_GROUP
-			var dec, cast, cast2 string
-			switch *field.Type {
-			case descriptor.FieldDescriptorProto_TYPE_DOUBLE:
-				dec, cast = "b.DecodeFixed64()", g.Pkg["math"]+".Float64frombits"
-			case descriptor.FieldDescriptorProto_TYPE_FLOAT:
-				dec, cast, cast2 = "b.DecodeFixed32()", "uint32", g.Pkg["math"]+".Float32frombits"
-			case descriptor.FieldDescriptorProto_TYPE_INT64:
-				dec, cast = "b.DecodeVarint()", "int64"
-			case descriptor.FieldDescriptorProto_TYPE_UINT64:
-				dec = "b.DecodeVarint()"
-			case descriptor.FieldDescriptorProto_TYPE_INT32:
-				dec, cast = "b.DecodeVarint()", "int32"
-			case descriptor.FieldDescriptorProto_TYPE_FIXED64:
-				dec = "b.DecodeFixed64()"
-			case descriptor.FieldDescriptorProto_TYPE_FIXED32:
-				dec, cast = "b.DecodeFixed32()", "uint32"
-			case descriptor.FieldDescriptorProto_TYPE_BOOL:
-				dec = "b.DecodeVarint()"
-				// handled specially below
-			case descriptor.FieldDescriptorProto_TYPE_STRING:
-				dec = "b.DecodeStringBytes()"
-			case descriptor.FieldDescriptorProto_TYPE_GROUP:
-				g.P("msg := new(", fieldTypes[field][1:], ")") // drop star
-				lhs = "err"
-				dec = "b.DecodeGroup(msg)"
-				// handled specially below
-			case descriptor.FieldDescriptorProto_TYPE_MESSAGE:
-				g.P("msg := new(", fieldTypes[field][1:], ")") // drop star
-				lhs = "err"
-				dec = "b.DecodeMessage(msg)"
-				// handled specially below
-			case descriptor.FieldDescriptorProto_TYPE_BYTES:
-				dec = "b.DecodeRawBytes(true)"
-			case descriptor.FieldDescriptorProto_TYPE_UINT32:
-				dec, cast = "b.DecodeVarint()", "uint32"
-			case descriptor.FieldDescriptorProto_TYPE_ENUM:
-				dec, cast = "b.DecodeVarint()", fieldTypes[field]
-			case descriptor.FieldDescriptorProto_TYPE_SFIXED32:
-				dec, cast = "b.DecodeFixed32()", "int32"
-			case descriptor.FieldDescriptorProto_TYPE_SFIXED64:
-				dec, cast = "b.DecodeFixed64()", "int64"
-			case descriptor.FieldDescriptorProto_TYPE_SINT32:
-				dec, cast = "b.DecodeZigzag32()", "int32"
-			case descriptor.FieldDescriptorProto_TYPE_SINT64:
-				dec, cast = "b.DecodeZigzag64()", "int64"
-			default:
-				g.Fail("unhandled oneof field type ", field.Type.String())
-			}
-			g.P(lhs, " := ", dec)
-			val := "x"
-			if cast != "" {
-				val = cast + "(" + val + ")"
-			}
-			if cast2 != "" {
-				val = cast2 + "(" + val + ")"
+			base := CamelCase(odp.GetName())
+			names := allocNames(base, "Get"+base)
+			fname, gname := names[0], names[1]
+
+			// This is the first field of a oneof we haven't seen before.
+			// Generate the union field.
+			oneofFullPath := fmt.Sprintf("%s,%d,%d", message.path, messageOneofPath, *field.OneofIndex)
+			c, ok := g.makeComments(oneofFullPath)
+			if ok {
+				c += "\n//\n"
 			}
-			switch *field.Type {
-			case descriptor.FieldDescriptorProto_TYPE_BOOL:
-				val += " != 0"
-			case descriptor.FieldDescriptorProto_TYPE_GROUP,
-				descriptor.FieldDescriptorProto_TYPE_MESSAGE:
-				val = "msg"
+			c += "// Types that are valid to be assigned to " + fname + ":\n"
+			// Generate the rest of this comment later,
+			// when we've computed any disambiguation.
+
+			dname := "is" + goTypeName + "_" + fname
+			tag := `protobuf_oneof:"` + odp.GetName() + `"`
+			of := oneofField{
+				fieldCommon: fieldCommon{
+					goName:     fname,
+					getterName: gname,
+					goType:     dname,
+					tags:       tag,
+					protoName:  odp.GetName(),
+					fullPath:   oneofFullPath,
+				},
+				comment: c,
 			}
-			g.P("m.", oneofFieldName[*field.OneofIndex], " = &", oneofTypeName[field], "{", val, "}")
-			g.P("return true, err")
+			topLevelFields = append(topLevelFields, &of)
+			oFields[*field.OneofIndex] = &of
 		}
-		g.P("default: return false, nil")
-		g.P("}")
-		g.P("}")
-		g.P()
 
-		// sizer
-		g.P("func ", size, sizeSig, " {")
-		g.P("m := msg.(*", ccTypeName, ")")
-		for oi, odp := range message.OneofDecl {
-			g.P("// ", odp.GetName())
-			fname := oneofFieldName[int32(oi)]
-			g.P("switch x := m.", fname, ".(type) {")
-			for _, field := range message.Field {
-				if field.OneofIndex == nil || int(*field.OneofIndex) != oi {
-					continue
-				}
-				g.P("case *", oneofTypeName[field], ":")
-				val := "x." + fieldNames[field]
-				var varint, fixed string
-				switch *field.Type {
-				case descriptor.FieldDescriptorProto_TYPE_DOUBLE:
-					fixed = "8"
-				case descriptor.FieldDescriptorProto_TYPE_FLOAT:
-					fixed = "4"
-				case descriptor.FieldDescriptorProto_TYPE_INT64,
-					descriptor.FieldDescriptorProto_TYPE_UINT64,
-					descriptor.FieldDescriptorProto_TYPE_INT32,
-					descriptor.FieldDescriptorProto_TYPE_UINT32,
-					descriptor.FieldDescriptorProto_TYPE_ENUM:
-					varint = val
-				case descriptor.FieldDescriptorProto_TYPE_FIXED64,
-					descriptor.FieldDescriptorProto_TYPE_SFIXED64:
-					fixed = "8"
-				case descriptor.FieldDescriptorProto_TYPE_FIXED32,
-					descriptor.FieldDescriptorProto_TYPE_SFIXED32:
-					fixed = "4"
-				case descriptor.FieldDescriptorProto_TYPE_BOOL:
-					fixed = "1"
-				case descriptor.FieldDescriptorProto_TYPE_STRING:
-					fixed = "len(" + val + ")"
-					varint = fixed
-				case descriptor.FieldDescriptorProto_TYPE_GROUP:
-					fixed = g.Pkg["proto"] + ".Size(" + val + ")"
+		if *field.Type == descriptor.FieldDescriptorProto_TYPE_MESSAGE {
+			desc := g.ObjectNamed(field.GetTypeName())
+			if d, ok := desc.(*Descriptor); ok && d.GetOptions().GetMapEntry() {
+				// Figure out the Go types and tags for the key and value types.
+				keyField, valField := d.Field[0], d.Field[1]
+				keyType, keyWire := g.GoType(d, keyField)
+				valType, valWire := g.GoType(d, valField)
+				keyTag, valTag := g.goTag(d, keyField, keyWire), g.goTag(d, valField, valWire)
+
+				// We don't use stars, except for message-typed values.
+				// Message and enum types are the only two possibly foreign types used in maps,
+				// so record their use. They are not permitted as map keys.
+				keyType = strings.TrimPrefix(keyType, "*")
+				switch *valField.Type {
+				case descriptor.FieldDescriptorProto_TYPE_ENUM:
+					valType = strings.TrimPrefix(valType, "*")
+					g.RecordTypeUse(valField.GetTypeName())
 				case descriptor.FieldDescriptorProto_TYPE_MESSAGE:
-					g.P("s := ", g.Pkg["proto"], ".Size(", val, ")")
-					fixed = "s"
-					varint = fixed
-				case descriptor.FieldDescriptorProto_TYPE_BYTES:
-					fixed = "len(" + val + ")"
-					varint = fixed
-				case descriptor.FieldDescriptorProto_TYPE_SINT32:
-					varint = "(uint32(" + val + ") << 1) ^ uint32((int32(" + val + ") >> 31))"
-				case descriptor.FieldDescriptorProto_TYPE_SINT64:
-					varint = "uint64(" + val + " << 1) ^ uint64((int64(" + val + ") >> 63))"
+					g.RecordTypeUse(valField.GetTypeName())
 				default:
-					g.Fail("unhandled oneof field type ", field.Type.String())
+					valType = strings.TrimPrefix(valType, "*")
 				}
-				// Tag and wire varint is known statically,
-				// so don't generate code for that part of the size computation.
-				tagAndWireSize := proto.SizeVarint(uint64(*field.Number << 3)) // wire doesn't affect varint size
-				g.P("n += ", tagAndWireSize, " // tag and wire")
-				if varint != "" {
-					g.P("n += ", g.Pkg["proto"], ".SizeVarint(uint64(", varint, "))")
+
+				typename = fmt.Sprintf("map[%s]%s", keyType, valType)
+				mapFieldTypes[field] = typename // record for the getter generation
+
+				tag += fmt.Sprintf(" protobuf_key:%s protobuf_val:%s", keyTag, valTag)
+			}
+		}
+
+		fieldDeprecated := ""
+		if field.GetOptions().GetDeprecated() {
+			fieldDeprecated = deprecationComment
+		}
+
+		dvalue := g.getterDefault(field, goTypeName)
+		if oneof {
+			tname := goTypeName + "_" + fieldName
+			// It is possible for this to collide with a message or enum
+			// nested in this message. Check for collisions.
+			for {
+				ok := true
+				for _, desc := range message.nested {
+					if CamelCaseSlice(desc.TypeName()) == tname {
+						ok = false
+						break
+					}
 				}
-				if fixed != "" {
-					g.P("n += ", fixed)
+				for _, enum := range message.enums {
+					if CamelCaseSlice(enum.TypeName()) == tname {
+						ok = false
+						break
+					}
 				}
-				if *field.Type == descriptor.FieldDescriptorProto_TYPE_GROUP {
-					g.P("n += ", tagAndWireSize, " // tag and wire")
+				if !ok {
+					tname += "_"
+					continue
 				}
+				break
+			}
+
+			oneofField := oFields[*field.OneofIndex]
+			tag := "protobuf:" + g.goTag(message, field, wiretype)
+			sf := oneofSubField{
+				fieldCommon: fieldCommon{
+					goName:     fieldName,
+					getterName: fieldGetterName,
+					goType:     typename,
+					tags:       tag,
+					protoName:  field.GetName(),
+					fullPath:   fmt.Sprintf("%s,%d,%d", message.path, messageFieldPath, i),
+				},
+				protoTypeName: field.GetTypeName(),
+				fieldNumber:   int(*field.Number),
+				protoType:     *field.Type,
+				getterDef:     dvalue,
+				protoDef:      field.GetDefaultValue(),
+				oneofTypeName: tname,
+				deprecated:    fieldDeprecated,
 			}
-			g.P("case nil:")
-			g.P("default:")
-			g.P("panic(", g.Pkg["fmt"], ".Sprintf(\"proto: unexpected type %T in oneof\", x))")
-			g.P("}")
+			oneofField.subFields = append(oneofField.subFields, &sf)
+			g.RecordTypeUse(field.GetTypeName())
+			continue
 		}
-		g.P("return n")
-		g.P("}")
-		g.P()
+
+		fieldFullPath := fmt.Sprintf("%s,%d,%d", message.path, messageFieldPath, i)
+		c, ok := g.makeComments(fieldFullPath)
+		if ok {
+			c += "\n"
+		}
+		rf := simpleField{
+			fieldCommon: fieldCommon{
+				goName:     fieldName,
+				getterName: fieldGetterName,
+				goType:     typename,
+				tags:       tag,
+				protoName:  field.GetName(),
+				fullPath:   fieldFullPath,
+			},
+			protoTypeName: field.GetTypeName(),
+			protoType:     *field.Type,
+			deprecated:    fieldDeprecated,
+			getterDef:     dvalue,
+			protoDef:      field.GetDefaultValue(),
+			comment:       c,
+		}
+		var pf topLevelField = &rf
+
+		topLevelFields = append(topLevelFields, pf)
+		g.RecordTypeUse(field.GetTypeName())
+	}
+
+	mc := &msgCtx{
+		goName:  goTypeName,
+		message: message,
+	}
+
+	g.generateMessageStruct(mc, topLevelFields)
+	g.P()
+	g.generateCommonMethods(mc)
+	g.P()
+	g.generateDefaultConstants(mc, topLevelFields)
+	g.P()
+	g.generateGetters(mc, topLevelFields)
+	g.P()
+	g.generateSetters(mc, topLevelFields)
+	g.P()
+	g.generateOneofFuncs(mc, topLevelFields)
+	g.P()
+
+	var oneofTypes []string
+	for _, f := range topLevelFields {
+		if of, ok := f.(*oneofField); ok {
+			for _, osf := range of.subFields {
+				oneofTypes = append(oneofTypes, osf.oneofTypeName)
+			}
+		}
+	}
+
+	opts := message.Options
+	ms := &messageSymbol{
+		sym:           goTypeName,
+		hasExtensions: len(message.ExtensionRange) > 0,
+		isMessageSet:  opts != nil && opts.GetMessageSetWireFormat(),
+		oneofTypes:    oneofTypes,
 	}
+	g.file.addExport(message, ms)
 
 	for _, ext := range message.ext {
 		g.generateExtension(ext)
@@ -2530,12 +2416,13 @@ func (g *Generator) generateMessage(message *Descriptor) {
 		fullName = *g.file.Package + "." + fullName
 	}
 
-	g.addInitf("%s.RegisterType((*%s)(nil), %q)", g.Pkg["proto"], ccTypeName, fullName)
+	g.addInitf("%s.RegisterType((*%s)(nil), %q)", g.Pkg["proto"], goTypeName, fullName)
 	// Register types for native map types.
 	for _, k := range mapFieldKeys(mapFieldTypes) {
 		fullName := strings.TrimPrefix(*k.TypeName, ".")
 		g.addInitf("%s.RegisterMapType((%s)(nil), %q)", g.Pkg["proto"], mapFieldTypes[k], fullName)
 	}
+
 }
 
 type byTypeName []*descriptor.FieldDescriptorProto
@@ -2647,10 +2534,8 @@ func (g *Generator) generateExtension(ext *ExtensionDescriptor) {
 	// In addition, the situation for when to apply this special case is implemented
 	// differently in other languages:
 	// https://github.com/google/protobuf/blob/aff10976/src/google/protobuf/text_format.cc#L1560
-	mset := false
 	if extDesc.GetOptions().GetMessageSetWireFormat() && typeName[len(typeName)-1] == "message_set_extension" {
 		typeName = typeName[:len(typeName)-1]
-		mset = true
 	}
 
 	// For text formatting, the package must be exactly what the .proto file declares,
@@ -2661,7 +2546,6 @@ func (g *Generator) generateExtension(ext *ExtensionDescriptor) {
 	}
 
 	g.P("var ", ccTypeName, " = &", g.Pkg["proto"], ".ExtensionDesc{")
-	g.In()
 	g.P("ExtendedType: (", extendedType, ")(nil),")
 	g.P("ExtensionType: (", fieldType, ")(nil),")
 	g.P("Field: ", field.Number, ",")
@@ -2669,39 +2553,22 @@ func (g *Generator) generateExtension(ext *ExtensionDescriptor) {
 	g.P("Tag: ", tag, ",")
 	g.P(`Filename: "`, g.file.GetName(), `",`)
 
-	g.Out()
 	g.P("}")
 	g.P()
 
-	if mset {
-		// Generate a bit more code to register with message_set.go.
-		g.addInitf("%s.RegisterMessageSetType((%s)(nil), %d, %q)", g.Pkg["proto"], fieldType, *field.Number, extName)
-	}
+	g.addInitf("%s.RegisterExtension(%s)", g.Pkg["proto"], ext.DescName())
 
 	g.file.addExport(ext, constOrVarSymbol{ccTypeName, "var", ""})
 }
 
 func (g *Generator) generateInitFunction() {
-	for _, enum := range g.file.enum {
-		g.generateEnumRegistration(enum)
-	}
-	for _, d := range g.file.desc {
-		for _, ext := range d.ext {
-			g.generateExtensionRegistration(ext)
-		}
-	}
-	for _, ext := range g.file.ext {
-		g.generateExtensionRegistration(ext)
-	}
 	if len(g.init) == 0 {
 		return
 	}
 	g.P("func init() {")
-	g.In()
 	for _, l := range g.init {
 		g.P(l)
 	}
-	g.Out()
 	g.P("}")
 	g.init = nil
 }
@@ -2727,7 +2594,6 @@ func (g *Generator) generateFileDescriptor(file *FileDescriptor) {
 	g.P()
 	g.P("func init() { ", g.Pkg["proto"], ".RegisterFile(", strconv.Quote(*file.Name), ", ", v, ") }")
 	g.P("var ", v, " = []byte{")
-	g.In()
 	g.P("// ", len(b), " bytes of a gzipped FileDescriptorProto")
 	for len(b) > 0 {
 		n := 16
@@ -2743,7 +2609,6 @@ func (g *Generator) generateFileDescriptor(file *FileDescriptor) {
 
 		b = b[n:]
 	}
-	g.Out()
 	g.P("}")
 }
 
@@ -2760,10 +2625,6 @@ func (g *Generator) generateEnumRegistration(enum *EnumDescriptor) {
 	g.addInitf("%s.RegisterEnum(%q, %[3]s_name, %[3]s_value)", g.Pkg["proto"], pkg+ccTypeName, ccTypeName)
 }
 
-func (g *Generator) generateExtensionRegistration(ext *ExtensionDescriptor) {
-	g.addInitf("%s.RegisterExtension(%s)", g.Pkg["proto"], ext.DescName())
-}
-
 // And now lots of helper functions.
 
 // Is c an ASCII lower-case letter?
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/generator/internal/remap/remap.go b/vendor/github.com/golang/protobuf/protoc-gen-go/generator/internal/remap/remap.go
index a9b61036c..e688c8941 100644
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/generator/internal/remap/remap.go
+++ b/vendor/github.com/golang/protobuf/protoc-gen-go/generator/internal/remap/remap.go
@@ -1,38 +1,9 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2017 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// Copyright 2017 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 remap handles tracking the locations of Go tokens in a source text
-across a rewrite by the Go formatter.
-*/
+// Package remap handles tracking the locations of Go tokens in a source text
+// across a rewrite by the Go formatter.
 package remap
 
 import (
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/generator/internal/remap/remap_test.go b/vendor/github.com/golang/protobuf/protoc-gen-go/generator/internal/remap/remap_test.go
index ccc7fca03..441ef57cb 100644
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/generator/internal/remap/remap_test.go
+++ b/vendor/github.com/golang/protobuf/protoc-gen-go/generator/internal/remap/remap_test.go
@@ -1,33 +1,6 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2017 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// Copyright 2017 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 remap
 
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/generator/name_test.go b/vendor/github.com/golang/protobuf/protoc-gen-go/generator/name_test.go
deleted file mode 100644
index 571147cfc..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/generator/name_test.go
+++ /dev/null
@@ -1,115 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2013 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package generator
-
-import (
-	"testing"
-
-	"github.com/golang/protobuf/protoc-gen-go/descriptor"
-)
-
-func TestCamelCase(t *testing.T) {
-	tests := []struct {
-		in, want string
-	}{
-		{"one", "One"},
-		{"one_two", "OneTwo"},
-		{"_my_field_name_2", "XMyFieldName_2"},
-		{"Something_Capped", "Something_Capped"},
-		{"my_Name", "My_Name"},
-		{"OneTwo", "OneTwo"},
-		{"_", "X"},
-		{"_a_", "XA_"},
-	}
-	for _, tc := range tests {
-		if got := CamelCase(tc.in); got != tc.want {
-			t.Errorf("CamelCase(%q) = %q, want %q", tc.in, got, tc.want)
-		}
-	}
-}
-
-func TestGoPackageOption(t *testing.T) {
-	tests := []struct {
-		in      string
-		impPath GoImportPath
-		pkg     GoPackageName
-		ok      bool
-	}{
-		{"", "", "", false},
-		{"foo", "", "foo", true},
-		{"github.com/golang/bar", "github.com/golang/bar", "bar", true},
-		{"github.com/golang/bar;baz", "github.com/golang/bar", "baz", true},
-	}
-	for _, tc := range tests {
-		d := &FileDescriptor{
-			FileDescriptorProto: &descriptor.FileDescriptorProto{
-				Options: &descriptor.FileOptions{
-					GoPackage: &tc.in,
-				},
-			},
-		}
-		impPath, pkg, ok := d.goPackageOption()
-		if impPath != tc.impPath || pkg != tc.pkg || ok != tc.ok {
-			t.Errorf("go_package = %q => (%q, %q, %t), want (%q, %q, %t)", tc.in,
-				impPath, pkg, ok, tc.impPath, tc.pkg, tc.ok)
-		}
-	}
-}
-
-func TestUnescape(t *testing.T) {
-	tests := []struct {
-		in  string
-		out string
-	}{
-		// successful cases, including all kinds of escapes
-		{"", ""},
-		{"foo bar baz frob nitz", "foo bar baz frob nitz"},
-		{`\000\001\002\003\004\005\006\007`, string([]byte{0, 1, 2, 3, 4, 5, 6, 7})},
-		{`\a\b\f\n\r\t\v\\\?\'\"`, string([]byte{'\a', '\b', '\f', '\n', '\r', '\t', '\v', '\\', '?', '\'', '"'})},
-		{`\x10\x20\x30\x40\x50\x60\x70\x80`, string([]byte{16, 32, 48, 64, 80, 96, 112, 128})},
-		// variable length octal escapes
-		{`\0\018\222\377\3\04\005\6\07`, string([]byte{0, 1, '8', 0222, 255, 3, 4, 5, 6, 7})},
-		// malformed escape sequences left as is
-		{"foo \\g bar", "foo \\g bar"},
-		{"foo \\xg0 bar", "foo \\xg0 bar"},
-		{"\\", "\\"},
-		{"\\x", "\\x"},
-		{"\\xf", "\\xf"},
-		{"\\777", "\\777"}, // overflows byte
-	}
-	for _, tc := range tests {
-		s := unescape(tc.in)
-		if s != tc.out {
-			t.Errorf("doUnescape(%q) = %q; should have been %q", tc.in, s, tc.out)
-		}
-	}
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/golden_test.go b/vendor/github.com/golang/protobuf/protoc-gen-go/golden_test.go
deleted file mode 100644
index 2630de68a..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/golden_test.go
+++ /dev/null
@@ -1,422 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"flag"
-	"fmt"
-	"go/build"
-	"go/parser"
-	"go/token"
-	"io/ioutil"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"regexp"
-	"runtime"
-	"strings"
-	"testing"
-)
-
-// Set --regenerate to regenerate the golden files.
-var regenerate = flag.Bool("regenerate", false, "regenerate golden files")
-
-// When the environment variable RUN_AS_PROTOC_GEN_GO is set, we skip running
-// tests and instead act as protoc-gen-go. This allows the test binary to
-// pass itself to protoc.
-func init() {
-	if os.Getenv("RUN_AS_PROTOC_GEN_GO") != "" {
-		main()
-		os.Exit(0)
-	}
-}
-
-func TestGolden(t *testing.T) {
-	workdir, err := ioutil.TempDir("", "proto-test")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(workdir)
-
-	// Find all the proto files we need to compile. We assume that each directory
-	// contains the files for a single package.
-	supportTypeAliases := hasReleaseTag("go1.9")
-	packages := map[string][]string{}
-	err = filepath.Walk("testdata", func(path string, info os.FileInfo, err error) error {
-		if filepath.Base(path) == "import_public" && !supportTypeAliases {
-			// Public imports require type alias support.
-			return filepath.SkipDir
-		}
-		if !strings.HasSuffix(path, ".proto") {
-			return nil
-		}
-		dir := filepath.Dir(path)
-		packages[dir] = append(packages[dir], path)
-		return nil
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// Compile each package, using this binary as protoc-gen-go.
-	for _, sources := range packages {
-		args := []string{"-Itestdata", "--go_out=plugins=grpc,paths=source_relative:" + workdir}
-		args = append(args, sources...)
-		protoc(t, args)
-	}
-
-	// Compare each generated file to the golden version.
-	filepath.Walk(workdir, func(genPath string, info os.FileInfo, _ error) error {
-		if info.IsDir() {
-			return nil
-		}
-
-		// For each generated file, figure out the path to the corresponding
-		// golden file in the testdata directory.
-		relPath, err := filepath.Rel(workdir, genPath)
-		if err != nil {
-			t.Errorf("filepath.Rel(%q, %q): %v", workdir, genPath, err)
-			return nil
-		}
-		if filepath.SplitList(relPath)[0] == ".." {
-			t.Errorf("generated file %q is not relative to %q", genPath, workdir)
-		}
-		goldenPath := filepath.Join("testdata", relPath)
-
-		got, err := ioutil.ReadFile(genPath)
-		if err != nil {
-			t.Error(err)
-			return nil
-		}
-		if *regenerate {
-			// If --regenerate set, just rewrite the golden files.
-			err := ioutil.WriteFile(goldenPath, got, 0666)
-			if err != nil {
-				t.Error(err)
-			}
-			return nil
-		}
-
-		want, err := ioutil.ReadFile(goldenPath)
-		if err != nil {
-			t.Error(err)
-			return nil
-		}
-
-		want = fdescRE.ReplaceAll(want, nil)
-		got = fdescRE.ReplaceAll(got, nil)
-		if bytes.Equal(got, want) {
-			return nil
-		}
-
-		cmd := exec.Command("diff", "-u", goldenPath, genPath)
-		out, _ := cmd.CombinedOutput()
-		t.Errorf("golden file differs: %v\n%v", relPath, string(out))
-		return nil
-	})
-}
-
-var fdescRE = regexp.MustCompile(`(?ms)^var fileDescriptor.*}`)
-
-// Source files used by TestParameters.
-const (
-	aProto = `
-syntax = "proto3";
-package test.alpha;
-option go_package = "package/alpha";
-import "beta/b.proto";
-message M { test.beta.M field = 1; }`
-
-	bProto = `
-syntax = "proto3";
-package test.beta;
-// no go_package option
-message M {}`
-)
-
-func TestParameters(t *testing.T) {
-	for _, test := range []struct {
-		parameters   string
-		wantFiles    map[string]bool
-		wantImportsA map[string]bool
-		wantPackageA string
-		wantPackageB string
-	}{{
-		parameters: "",
-		wantFiles: map[string]bool{
-			"package/alpha/a.pb.go": true,
-			"beta/b.pb.go":          true,
-		},
-		wantPackageA: "alpha",
-		wantPackageB: "test_beta",
-		wantImportsA: map[string]bool{
-			"github.com/golang/protobuf/proto": true,
-			"beta": true,
-		},
-	}, {
-		parameters: "import_prefix=prefix",
-		wantFiles: map[string]bool{
-			"package/alpha/a.pb.go": true,
-			"beta/b.pb.go":          true,
-		},
-		wantPackageA: "alpha",
-		wantPackageB: "test_beta",
-		wantImportsA: map[string]bool{
-			// This really doesn't seem like useful behavior.
-			"prefixgithub.com/golang/protobuf/proto": true,
-			"prefixbeta":                             true,
-		},
-	}, {
-		// import_path only affects the 'package' line.
-		parameters:   "import_path=import/path/of/pkg",
-		wantPackageA: "alpha",
-		wantPackageB: "pkg",
-		wantFiles: map[string]bool{
-			"package/alpha/a.pb.go": true,
-			"beta/b.pb.go":          true,
-		},
-	}, {
-		parameters: "Mbeta/b.proto=package/gamma",
-		wantFiles: map[string]bool{
-			"package/alpha/a.pb.go": true,
-			"beta/b.pb.go":          true,
-		},
-		wantPackageA: "alpha",
-		wantPackageB: "test_beta",
-		wantImportsA: map[string]bool{
-			"github.com/golang/protobuf/proto": true,
-			// Rewritten by the M parameter.
-			"package/gamma": true,
-		},
-	}, {
-		parameters: "import_prefix=prefix,Mbeta/b.proto=package/gamma",
-		wantFiles: map[string]bool{
-			"package/alpha/a.pb.go": true,
-			"beta/b.pb.go":          true,
-		},
-		wantPackageA: "alpha",
-		wantPackageB: "test_beta",
-		wantImportsA: map[string]bool{
-			// import_prefix applies after M.
-			"prefixpackage/gamma": true,
-		},
-	}, {
-		parameters: "paths=source_relative",
-		wantFiles: map[string]bool{
-			"alpha/a.pb.go": true,
-			"beta/b.pb.go":  true,
-		},
-		wantPackageA: "alpha",
-		wantPackageB: "test_beta",
-	}, {
-		parameters: "paths=source_relative,import_prefix=prefix",
-		wantFiles: map[string]bool{
-			// import_prefix doesn't affect filenames.
-			"alpha/a.pb.go": true,
-			"beta/b.pb.go":  true,
-		},
-		wantPackageA: "alpha",
-		wantPackageB: "test_beta",
-	}} {
-		name := test.parameters
-		if name == "" {
-			name = "defaults"
-		}
-		// TODO: Switch to t.Run when we no longer support Go 1.6.
-		t.Logf("TEST: %v", name)
-		workdir, err := ioutil.TempDir("", "proto-test")
-		if err != nil {
-			t.Fatal(err)
-		}
-		defer os.RemoveAll(workdir)
-
-		for _, dir := range []string{"alpha", "beta", "out"} {
-			if err := os.MkdirAll(filepath.Join(workdir, dir), 0777); err != nil {
-				t.Fatal(err)
-			}
-		}
-
-		if err := ioutil.WriteFile(filepath.Join(workdir, "alpha", "a.proto"), []byte(aProto), 0666); err != nil {
-			t.Fatal(err)
-		}
-
-		if err := ioutil.WriteFile(filepath.Join(workdir, "beta", "b.proto"), []byte(bProto), 0666); err != nil {
-			t.Fatal(err)
-		}
-
-		protoc(t, []string{
-			"-I" + workdir,
-			"--go_out=" + test.parameters + ":" + filepath.Join(workdir, "out"),
-			filepath.Join(workdir, "alpha", "a.proto"),
-		})
-		protoc(t, []string{
-			"-I" + workdir,
-			"--go_out=" + test.parameters + ":" + filepath.Join(workdir, "out"),
-			filepath.Join(workdir, "beta", "b.proto"),
-		})
-
-		contents := make(map[string]string)
-		gotFiles := make(map[string]bool)
-		outdir := filepath.Join(workdir, "out")
-		filepath.Walk(outdir, func(p string, info os.FileInfo, _ error) error {
-			if info.IsDir() {
-				return nil
-			}
-			base := filepath.Base(p)
-			if base == "a.pb.go" || base == "b.pb.go" {
-				b, err := ioutil.ReadFile(p)
-				if err != nil {
-					t.Fatal(err)
-				}
-				contents[base] = string(b)
-			}
-			relPath, _ := filepath.Rel(outdir, p)
-			gotFiles[relPath] = true
-			return nil
-		})
-		for got := range gotFiles {
-			if runtime.GOOS == "windows" {
-				got = filepath.ToSlash(got)
-			}
-			if !test.wantFiles[got] {
-				t.Errorf("unexpected output file: %v", got)
-			}
-		}
-		for want := range test.wantFiles {
-			if runtime.GOOS == "windows" {
-				want = filepath.FromSlash(want)
-			}
-			if !gotFiles[want] {
-				t.Errorf("missing output file:    %v", want)
-			}
-		}
-		gotPackageA, gotImports, err := parseFile(contents["a.pb.go"])
-		if err != nil {
-			t.Fatal(err)
-		}
-		gotPackageB, _, err := parseFile(contents["b.pb.go"])
-		if err != nil {
-			t.Fatal(err)
-		}
-		if got, want := gotPackageA, test.wantPackageA; want != got {
-			t.Errorf("output file a.pb.go is package %q, want %q", got, want)
-		}
-		if got, want := gotPackageB, test.wantPackageB; want != got {
-			t.Errorf("output file b.pb.go is package %q, want %q", got, want)
-		}
-		missingImport := false
-	WantImport:
-		for want := range test.wantImportsA {
-			for _, imp := range gotImports {
-				if `"`+want+`"` == imp {
-					continue WantImport
-				}
-			}
-			t.Errorf("output file a.pb.go does not contain expected import %q", want)
-			missingImport = true
-		}
-		if missingImport {
-			t.Error("got imports:")
-			for _, imp := range gotImports {
-				t.Errorf("  %v", imp)
-			}
-		}
-	}
-}
-
-func TestPackageComment(t *testing.T) {
-	workdir, err := ioutil.TempDir("", "proto-test")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(workdir)
-
-	var packageRE = regexp.MustCompile(`(?m)^package .*`)
-
-	for i, test := range []struct {
-		goPackageOption string
-		wantPackage     string
-	}{{
-		goPackageOption: ``,
-		wantPackage:     `package proto_package`,
-	}, {
-		goPackageOption: `option go_package = "go_package";`,
-		wantPackage:     `package go_package`,
-	}, {
-		goPackageOption: `option go_package = "import/path/of/go_package";`,
-		wantPackage:     `package go_package // import "import/path/of/go_package"`,
-	}, {
-		goPackageOption: `option go_package = "import/path/of/something;go_package";`,
-		wantPackage:     `package go_package // import "import/path/of/something"`,
-	}, {
-		goPackageOption: `option go_package = "import_path;go_package";`,
-		wantPackage:     `package go_package // import "import_path"`,
-	}} {
-		srcName := filepath.Join(workdir, fmt.Sprintf("%d.proto", i))
-		tgtName := filepath.Join(workdir, fmt.Sprintf("%d.pb.go", i))
-
-		buf := &bytes.Buffer{}
-		fmt.Fprintln(buf, `syntax = "proto3";`)
-		fmt.Fprintln(buf, `package proto_package;`)
-		fmt.Fprintln(buf, test.goPackageOption)
-		if err := ioutil.WriteFile(srcName, buf.Bytes(), 0666); err != nil {
-			t.Fatal(err)
-		}
-
-		protoc(t, []string{"-I" + workdir, "--go_out=paths=source_relative:" + workdir, srcName})
-
-		out, err := ioutil.ReadFile(tgtName)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		pkg := packageRE.Find(out)
-		if pkg == nil {
-			t.Errorf("generated .pb.go contains no package line\n\nsource:\n%v\n\noutput:\n%v", buf.String(), string(out))
-			continue
-		}
-
-		if got, want := string(pkg), test.wantPackage; got != want {
-			t.Errorf("unexpected package statement with go_package = %q\n got: %v\nwant: %v", test.goPackageOption, got, want)
-		}
-	}
-}
-
-// parseFile returns a file's package name and a list of all packages it imports.
-func parseFile(source string) (packageName string, imports []string, err error) {
-	fset := token.NewFileSet()
-	f, err := parser.ParseFile(fset, "<source>", source, parser.ImportsOnly)
-	if err != nil {
-		return "", nil, err
-	}
-	for _, imp := range f.Imports {
-		imports = append(imports, imp.Path.Value)
-	}
-	return f.Name.Name, imports, nil
-}
-
-func protoc(t *testing.T, args []string) {
-	cmd := exec.Command("protoc", "--plugin=protoc-gen-go="+os.Args[0])
-	cmd.Args = append(cmd.Args, args...)
-	// We set the RUN_AS_PROTOC_GEN_GO environment variable to indicate that
-	// the subprocess should act as a proto compiler rather than a test.
-	cmd.Env = append(os.Environ(), "RUN_AS_PROTOC_GEN_GO=1")
-	out, err := cmd.CombinedOutput()
-	if len(out) > 0 || err != nil {
-		t.Log("RUNNING: ", strings.Join(cmd.Args, " "))
-	}
-	if len(out) > 0 {
-		t.Log(string(out))
-	}
-	if err != nil {
-		t.Fatalf("protoc: %v", err)
-	}
-}
-
-func hasReleaseTag(want string) bool {
-	for _, tag := range build.Default.ReleaseTags {
-		if tag == want {
-			return true
-		}
-	}
-	return false
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/grpc/grpc.go b/vendor/github.com/golang/protobuf/protoc-gen-go/grpc/grpc.go
index faef1abb7..40cba163b 100644
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/grpc/grpc.go
+++ b/vendor/github.com/golang/protobuf/protoc-gen-go/grpc/grpc.go
@@ -1,42 +1,17 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
 // Copyright 2015 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package grpc is deprecated.
 //
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
+// This package is excluded from the Go protocol buffer compatibility guarantee
+// and may be deleted at some point in the future.
 //
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Package grpc outputs gRPC service descriptions in Go code.
-// It runs as a plugin for the Go protocol buffer compiler plugin.
-// It is linked in to protoc-gen-go.
+// Deprecated: Do not use.
 package grpc
 
 import (
 	"fmt"
-	"path"
 	"strconv"
 	"strings"
 
@@ -48,13 +23,15 @@ import (
 // It is incremented whenever an incompatibility between the generated code and
 // the grpc package is introduced; the generated code references
 // a constant, grpc.SupportPackageIsVersionN (where N is generatedCodeVersion).
-const generatedCodeVersion = 4
+const generatedCodeVersion = 6
 
 // Paths for packages used by code generated in this file,
 // relative to the import_prefix of the generator.Generator.
 const (
-	contextPkgPath = "golang.org/x/net/context"
+	contextPkgPath = "context"
 	grpcPkgPath    = "google.golang.org/grpc"
+	codePkgPath    = "google.golang.org/grpc/codes"
+	statusPkgPath  = "google.golang.org/grpc/status"
 )
 
 func init() {
@@ -83,8 +60,6 @@ var (
 // Init initializes the plugin.
 func (g *grpc) Init(gen *generator.Generator) {
 	g.gen = gen
-	contextPkg = generator.RegisterUniquePackageName("context", nil)
-	grpcPkg = generator.RegisterUniquePackageName("grpc", nil)
 }
 
 // Given a type name defined in a .proto, return its object.
@@ -108,9 +83,12 @@ func (g *grpc) Generate(file *generator.FileDescriptor) {
 		return
 	}
 
+	contextPkg = string(g.gen.AddImport(contextPkgPath))
+	grpcPkg = string(g.gen.AddImport(grpcPkgPath))
+
 	g.P("// Reference imports to suppress errors if they are not otherwise used.")
 	g.P("var _ ", contextPkg, ".Context")
-	g.P("var _ ", grpcPkg, ".ClientConn")
+	g.P("var _ ", grpcPkg, ".ClientConnInterface")
 	g.P()
 
 	// Assert version compatibility.
@@ -126,14 +104,6 @@ func (g *grpc) Generate(file *generator.FileDescriptor) {
 
 // GenerateImports generates the import declaration for this file.
 func (g *grpc) GenerateImports(file *generator.FileDescriptor) {
-	if len(file.FileDescriptorProto.Service) == 0 {
-		return
-	}
-	g.P("import (")
-	g.P(contextPkg, " ", generator.GoImportPath(path.Join(string(g.gen.ImportPrefix), contextPkgPath)))
-	g.P(grpcPkg, " ", generator.GoImportPath(path.Join(string(g.gen.ImportPrefix), grpcPkgPath)))
-	g.P(")")
-	g.P()
 }
 
 // reservedClientName records whether a client name is reserved on the client side.
@@ -172,6 +142,10 @@ func (g *grpc) generateService(file *generator.FileDescriptor, service *pb.Servi
 	g.P("type ", servName, "Client interface {")
 	for i, method := range service.Method {
 		g.gen.PrintComments(fmt.Sprintf("%s,2,%d", path, i)) // 2 means method in a service.
+		if method.GetOptions().GetDeprecated() {
+			g.P("//")
+			g.P(deprecationComment)
+		}
 		g.P(g.generateClientSignature(servName, method))
 	}
 	g.P("}")
@@ -179,7 +153,7 @@ func (g *grpc) generateService(file *generator.FileDescriptor, service *pb.Servi
 
 	// Client structure.
 	g.P("type ", unexport(servName), "Client struct {")
-	g.P("cc *", grpcPkg, ".ClientConn")
+	g.P("cc ", grpcPkg, ".ClientConnInterface")
 	g.P("}")
 	g.P()
 
@@ -187,7 +161,7 @@ func (g *grpc) generateService(file *generator.FileDescriptor, service *pb.Servi
 	if deprecated {
 		g.P(deprecationComment)
 	}
-	g.P("func New", servName, "Client (cc *", grpcPkg, ".ClientConn) ", servName, "Client {")
+	g.P("func New", servName, "Client (cc ", grpcPkg, ".ClientConnInterface) ", servName, "Client {")
 	g.P("return &", unexport(servName), "Client{cc}")
 	g.P("}")
 	g.P()
@@ -219,11 +193,21 @@ func (g *grpc) generateService(file *generator.FileDescriptor, service *pb.Servi
 	g.P("type ", serverType, " interface {")
 	for i, method := range service.Method {
 		g.gen.PrintComments(fmt.Sprintf("%s,2,%d", path, i)) // 2 means method in a service.
+		if method.GetOptions().GetDeprecated() {
+			g.P("//")
+			g.P(deprecationComment)
+		}
 		g.P(g.generateServerSignature(servName, method))
 	}
 	g.P("}")
 	g.P()
 
+	// Server Unimplemented struct for forward compatibility.
+	if deprecated {
+		g.P(deprecationComment)
+	}
+	g.generateUnimplementedServer(servName, service)
+
 	// Server registration.
 	if deprecated {
 		g.P(deprecationComment)
@@ -277,6 +261,35 @@ func (g *grpc) generateService(file *generator.FileDescriptor, service *pb.Servi
 	g.P()
 }
 
+// generateUnimplementedServer creates the unimplemented server struct
+func (g *grpc) generateUnimplementedServer(servName string, service *pb.ServiceDescriptorProto) {
+	serverType := servName + "Server"
+	g.P("// Unimplemented", serverType, " can be embedded to have forward compatible implementations.")
+	g.P("type Unimplemented", serverType, " struct {")
+	g.P("}")
+	g.P()
+	// Unimplemented<service_name>Server's concrete methods
+	for _, method := range service.Method {
+		g.generateServerMethodConcrete(servName, method)
+	}
+	g.P()
+}
+
+// generateServerMethodConcrete returns unimplemented methods which ensure forward compatibility
+func (g *grpc) generateServerMethodConcrete(servName string, method *pb.MethodDescriptorProto) {
+	header := g.generateServerSignatureWithParamNames(servName, method)
+	g.P("func (*Unimplemented", servName, "Server) ", header, " {")
+	var nilArg string
+	if !method.GetServerStreaming() && !method.GetClientStreaming() {
+		nilArg = "nil, "
+	}
+	methName := generator.CamelCase(method.GetName())
+	statusPkg := string(g.gen.AddImport(statusPkgPath))
+	codePkg := string(g.gen.AddImport(codePkgPath))
+	g.P("return ", nilArg, statusPkg, `.Errorf(`, codePkg, `.Unimplemented, "method `, methName, ` not implemented")`)
+	g.P("}")
+}
+
 // generateClientSignature returns the client-side signature for a method.
 func (g *grpc) generateClientSignature(servName string, method *pb.MethodDescriptorProto) string {
 	origMethName := method.GetName()
@@ -376,6 +389,30 @@ func (g *grpc) generateClientMethod(servName, fullServName, serviceDescVar strin
 	}
 }
 
+// generateServerSignatureWithParamNames returns the server-side signature for a method with parameter names.
+func (g *grpc) generateServerSignatureWithParamNames(servName string, method *pb.MethodDescriptorProto) string {
+	origMethName := method.GetName()
+	methName := generator.CamelCase(origMethName)
+	if reservedClientName[methName] {
+		methName += "_"
+	}
+
+	var reqArgs []string
+	ret := "error"
+	if !method.GetServerStreaming() && !method.GetClientStreaming() {
+		reqArgs = append(reqArgs, "ctx "+contextPkg+".Context")
+		ret = "(*" + g.typeName(method.GetOutputType()) + ", error)"
+	}
+	if !method.GetClientStreaming() {
+		reqArgs = append(reqArgs, "req *"+g.typeName(method.GetInputType()))
+	}
+	if method.GetServerStreaming() || method.GetClientStreaming() {
+		reqArgs = append(reqArgs, "srv "+servName+"_"+generator.CamelCase(origMethName)+"Server")
+	}
+
+	return methName + "(" + strings.Join(reqArgs, ", ") + ") " + ret
+}
+
 // generateServerSignature returns the server-side signature for a method.
 func (g *grpc) generateServerSignature(servName string, method *pb.MethodDescriptorProto) string {
 	origMethName := method.GetName()
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/link_grpc.go b/vendor/github.com/golang/protobuf/protoc-gen-go/link_grpc.go
deleted file mode 100644
index 532a55005..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/link_grpc.go
+++ /dev/null
@@ -1,34 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2015 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package main
-
-import _ "github.com/golang/protobuf/protoc-gen-go/grpc"
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/main.go b/vendor/github.com/golang/protobuf/protoc-gen-go/main.go
index 8e2486de0..d45b719d1 100644
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/main.go
+++ b/vendor/github.com/golang/protobuf/protoc-gen-go/main.go
@@ -1,98 +1,74 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// Copyright 2010 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.
 
 // protoc-gen-go is a plugin for the Google protocol buffer compiler to generate
-// Go code.  Run it by building this program and putting it in your path with
-// the name
-// 	protoc-gen-go
-// That word 'go' at the end becomes part of the option string set for the
-// protocol compiler, so once the protocol compiler (protoc) is installed
-// you can run
-// 	protoc --go_out=output_directory input_directory/file.proto
-// to generate Go bindings for the protocol defined by file.proto.
-// With that input, the output will be written to
-// 	output_directory/file.pb.go
+// Go code. Install it by building this program and making it accessible within
+// your PATH with the name:
+//	protoc-gen-go
+//
+// The 'go' suffix becomes part of the argument for the protocol compiler,
+// such that it can be invoked as:
+//	protoc --go_out=paths=source_relative:. path/to/file.proto
 //
-// The generated code is documented in the package comment for
-// the library.
+// This generates Go bindings for the protocol buffer defined by file.proto.
+// With that input, the output will be written to:
+//	path/to/file.pb.go
 //
 // See the README and documentation for protocol buffers to learn more:
-// 	https://developers.google.com/protocol-buffers/
+//	https://developers.google.com/protocol-buffers/
 package main
 
 import (
-	"io/ioutil"
-	"os"
+	"flag"
+	"fmt"
+	"strings"
 
-	"github.com/golang/protobuf/proto"
-	"github.com/golang/protobuf/protoc-gen-go/generator"
+	"github.com/golang/protobuf/internal/gengogrpc"
+	gengo "google.golang.org/protobuf/cmd/protoc-gen-go/internal_gengo"
+	"google.golang.org/protobuf/compiler/protogen"
 )
 
 func main() {
-	// Begin by allocating a generator. The request and response structures are stored there
-	// so we can do error handling easily - the response structure contains the field to
-	// report failure.
-	g := generator.New()
-
-	data, err := ioutil.ReadAll(os.Stdin)
-	if err != nil {
-		g.Error(err, "reading input")
-	}
-
-	if err := proto.Unmarshal(data, g.Request); err != nil {
-		g.Error(err, "parsing input proto")
-	}
-
-	if len(g.Request.FileToGenerate) == 0 {
-		g.Fail("no files to generate")
-	}
-
-	g.CommandLineParameters(g.Request.GetParameter())
-
-	// Create a wrapped version of the Descriptors and EnumDescriptors that
-	// point to the file that defines them.
-	g.WrapTypes()
-
-	g.SetPackageNames()
-	g.BuildTypeNameMap()
-
-	g.GenerateAllFiles()
-
-	// Send back the results.
-	data, err = proto.Marshal(g.Response)
-	if err != nil {
-		g.Error(err, "failed to marshal output proto")
-	}
-	_, err = os.Stdout.Write(data)
-	if err != nil {
-		g.Error(err, "failed to write output proto")
+	var (
+		flags        flag.FlagSet
+		plugins      = flags.String("plugins", "", "list of plugins to enable (supported values: grpc)")
+		importPrefix = flags.String("import_prefix", "", "prefix to prepend to import paths")
+	)
+	importRewriteFunc := func(importPath protogen.GoImportPath) protogen.GoImportPath {
+		switch importPath {
+		case "context", "fmt", "math":
+			return importPath
+		}
+		if *importPrefix != "" {
+			return protogen.GoImportPath(*importPrefix) + importPath
+		}
+		return importPath
 	}
+	protogen.Options{
+		ParamFunc:         flags.Set,
+		ImportRewriteFunc: importRewriteFunc,
+	}.Run(func(gen *protogen.Plugin) error {
+		grpc := false
+		for _, plugin := range strings.Split(*plugins, ",") {
+			switch plugin {
+			case "grpc":
+				grpc = true
+			case "":
+			default:
+				return fmt.Errorf("protoc-gen-go: unknown plugin %q", plugin)
+			}
+		}
+		for _, f := range gen.Files {
+			if !f.Generate {
+				continue
+			}
+			g := gengo.GenerateFile(gen, f)
+			if grpc {
+				gengogrpc.GenerateFileContent(gen, f, g)
+			}
+		}
+		gen.SupportedFeatures = gengo.SupportedFeatures
+		return nil
+	})
 }
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/plugin/plugin.pb.go b/vendor/github.com/golang/protobuf/protoc-gen-go/plugin/plugin.pb.go
index 61bfc10e0..b7b4a2f94 100644
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/plugin/plugin.pb.go
+++ b/vendor/github.com/golang/protobuf/protoc-gen-go/plugin/plugin.pb.go
@@ -1,369 +1,75 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
-// source: google/protobuf/compiler/plugin.proto
+// source: github.com/golang/protobuf/protoc-gen-go/plugin/plugin.proto
 
-/*
-Package plugin_go is a generated protocol buffer package.
-
-It is generated from these files:
-	google/protobuf/compiler/plugin.proto
-
-It has these top-level messages:
-	Version
-	CodeGeneratorRequest
-	CodeGeneratorResponse
-*/
 package plugin_go
 
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-import google_protobuf "github.com/golang/protobuf/protoc-gen-go/descriptor"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-// The version number of protocol compiler.
-type Version struct {
-	Major *int32 `protobuf:"varint,1,opt,name=major" json:"major,omitempty"`
-	Minor *int32 `protobuf:"varint,2,opt,name=minor" json:"minor,omitempty"`
-	Patch *int32 `protobuf:"varint,3,opt,name=patch" json:"patch,omitempty"`
-	// A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
-	// be empty for mainline stable releases.
-	Suffix               *string  `protobuf:"bytes,4,opt,name=suffix" json:"suffix,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *Version) Reset()                    { *m = Version{} }
-func (m *Version) String() string            { return proto.CompactTextString(m) }
-func (*Version) ProtoMessage()               {}
-func (*Version) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
-func (m *Version) Unmarshal(b []byte) error {
-	return xxx_messageInfo_Version.Unmarshal(m, b)
-}
-func (m *Version) Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Version.Marshal(b, m, deterministic)
-}
-func (dst *Version) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Version.Merge(dst, src)
-}
-func (m *Version) XXX_Size() int {
-	return xxx_messageInfo_Version.Size(m)
-}
-func (m *Version) XXX_DiscardUnknown() {
-	xxx_messageInfo_Version.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Version proto.InternalMessageInfo
-
-func (m *Version) GetMajor() int32 {
-	if m != nil && m.Major != nil {
-		return *m.Major
-	}
-	return 0
-}
-
-func (m *Version) GetMinor() int32 {
-	if m != nil && m.Minor != nil {
-		return *m.Minor
-	}
-	return 0
-}
-
-func (m *Version) GetPatch() int32 {
-	if m != nil && m.Patch != nil {
-		return *m.Patch
-	}
-	return 0
-}
-
-func (m *Version) GetSuffix() string {
-	if m != nil && m.Suffix != nil {
-		return *m.Suffix
-	}
-	return ""
-}
-
-// An encoded CodeGeneratorRequest is written to the plugin's stdin.
-type CodeGeneratorRequest struct {
-	// The .proto files that were explicitly listed on the command-line.  The
-	// code generator should generate code only for these files.  Each file's
-	// descriptor will be included in proto_file, below.
-	FileToGenerate []string `protobuf:"bytes,1,rep,name=file_to_generate,json=fileToGenerate" json:"file_to_generate,omitempty"`
-	// The generator parameter passed on the command-line.
-	Parameter *string `protobuf:"bytes,2,opt,name=parameter" json:"parameter,omitempty"`
-	// FileDescriptorProtos for all files in files_to_generate and everything
-	// they import.  The files will appear in topological order, so each file
-	// appears before any file that imports it.
-	//
-	// protoc guarantees that all proto_files will be written after
-	// the fields above, even though this is not technically guaranteed by the
-	// protobuf wire format.  This theoretically could allow a plugin to stream
-	// in the FileDescriptorProtos and handle them one by one rather than read
-	// the entire set into memory at once.  However, as of this writing, this
-	// is not similarly optimized on protoc's end -- it will store all fields in
-	// memory at once before sending them to the plugin.
-	//
-	// Type names of fields and extensions in the FileDescriptorProto are always
-	// fully qualified.
-	ProtoFile []*google_protobuf.FileDescriptorProto `protobuf:"bytes,15,rep,name=proto_file,json=protoFile" json:"proto_file,omitempty"`
-	// The version number of protocol compiler.
-	CompilerVersion      *Version `protobuf:"bytes,3,opt,name=compiler_version,json=compilerVersion" json:"compiler_version,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *CodeGeneratorRequest) Reset()                    { *m = CodeGeneratorRequest{} }
-func (m *CodeGeneratorRequest) String() string            { return proto.CompactTextString(m) }
-func (*CodeGeneratorRequest) ProtoMessage()               {}
-func (*CodeGeneratorRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
-func (m *CodeGeneratorRequest) Unmarshal(b []byte) error {
-	return xxx_messageInfo_CodeGeneratorRequest.Unmarshal(m, b)
-}
-func (m *CodeGeneratorRequest) Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_CodeGeneratorRequest.Marshal(b, m, deterministic)
-}
-func (dst *CodeGeneratorRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CodeGeneratorRequest.Merge(dst, src)
-}
-func (m *CodeGeneratorRequest) XXX_Size() int {
-	return xxx_messageInfo_CodeGeneratorRequest.Size(m)
-}
-func (m *CodeGeneratorRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_CodeGeneratorRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_CodeGeneratorRequest proto.InternalMessageInfo
-
-func (m *CodeGeneratorRequest) GetFileToGenerate() []string {
-	if m != nil {
-		return m.FileToGenerate
-	}
-	return nil
-}
-
-func (m *CodeGeneratorRequest) GetParameter() string {
-	if m != nil && m.Parameter != nil {
-		return *m.Parameter
-	}
-	return ""
-}
-
-func (m *CodeGeneratorRequest) GetProtoFile() []*google_protobuf.FileDescriptorProto {
-	if m != nil {
-		return m.ProtoFile
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	pluginpb "google.golang.org/protobuf/types/pluginpb"
+	reflect "reflect"
+)
+
+// Symbols defined in public import of google/protobuf/compiler/plugin.proto.
+
+type CodeGeneratorResponse_Feature = pluginpb.CodeGeneratorResponse_Feature
+
+const CodeGeneratorResponse_FEATURE_NONE = pluginpb.CodeGeneratorResponse_FEATURE_NONE
+const CodeGeneratorResponse_FEATURE_PROTO3_OPTIONAL = pluginpb.CodeGeneratorResponse_FEATURE_PROTO3_OPTIONAL
+
+var CodeGeneratorResponse_Feature_name = pluginpb.CodeGeneratorResponse_Feature_name
+var CodeGeneratorResponse_Feature_value = pluginpb.CodeGeneratorResponse_Feature_value
+
+type Version = pluginpb.Version
+type CodeGeneratorRequest = pluginpb.CodeGeneratorRequest
+type CodeGeneratorResponse = pluginpb.CodeGeneratorResponse
+type CodeGeneratorResponse_File = pluginpb.CodeGeneratorResponse_File
+
+var File_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto protoreflect.FileDescriptor
+
+var file_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto_rawDesc = []byte{
+	0x0a, 0x3c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
+	0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69,
+	0x6e, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x25,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f,
+	0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x72, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x42, 0x3b, 0x5a, 0x39, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e,
+	0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x62, 0x75, 0x66, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67,
+	0x6f, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x3b, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x5f,
+	0x67, 0x6f, 0x50, 0x00, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32,
+}
+
+var file_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto_goTypes = []interface{}{}
+var file_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto_init() }
+func file_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto_init() {
+	if File_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto != nil {
+		return
 	}
-	return nil
-}
-
-func (m *CodeGeneratorRequest) GetCompilerVersion() *Version {
-	if m != nil {
-		return m.CompilerVersion
-	}
-	return nil
-}
-
-// The plugin writes an encoded CodeGeneratorResponse to stdout.
-type CodeGeneratorResponse struct {
-	// Error message.  If non-empty, code generation failed.  The plugin process
-	// should exit with status code zero even if it reports an error in this way.
-	//
-	// This should be used to indicate errors in .proto files which prevent the
-	// code generator from generating correct code.  Errors which indicate a
-	// problem in protoc itself -- such as the input CodeGeneratorRequest being
-	// unparseable -- should be reported by writing a message to stderr and
-	// exiting with a non-zero status code.
-	Error                *string                       `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"`
-	File                 []*CodeGeneratorResponse_File `protobuf:"bytes,15,rep,name=file" json:"file,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
-	XXX_unrecognized     []byte                        `json:"-"`
-	XXX_sizecache        int32                         `json:"-"`
-}
-
-func (m *CodeGeneratorResponse) Reset()                    { *m = CodeGeneratorResponse{} }
-func (m *CodeGeneratorResponse) String() string            { return proto.CompactTextString(m) }
-func (*CodeGeneratorResponse) ProtoMessage()               {}
-func (*CodeGeneratorResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
-func (m *CodeGeneratorResponse) Unmarshal(b []byte) error {
-	return xxx_messageInfo_CodeGeneratorResponse.Unmarshal(m, b)
-}
-func (m *CodeGeneratorResponse) Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_CodeGeneratorResponse.Marshal(b, m, deterministic)
-}
-func (dst *CodeGeneratorResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CodeGeneratorResponse.Merge(dst, src)
-}
-func (m *CodeGeneratorResponse) XXX_Size() int {
-	return xxx_messageInfo_CodeGeneratorResponse.Size(m)
-}
-func (m *CodeGeneratorResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_CodeGeneratorResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_CodeGeneratorResponse proto.InternalMessageInfo
-
-func (m *CodeGeneratorResponse) GetError() string {
-	if m != nil && m.Error != nil {
-		return *m.Error
-	}
-	return ""
-}
-
-func (m *CodeGeneratorResponse) GetFile() []*CodeGeneratorResponse_File {
-	if m != nil {
-		return m.File
-	}
-	return nil
-}
-
-// Represents a single generated file.
-type CodeGeneratorResponse_File struct {
-	// The file name, relative to the output directory.  The name must not
-	// contain "." or ".." components and must be relative, not be absolute (so,
-	// the file cannot lie outside the output directory).  "/" must be used as
-	// the path separator, not "\".
-	//
-	// If the name is omitted, the content will be appended to the previous
-	// file.  This allows the generator to break large files into small chunks,
-	// and allows the generated text to be streamed back to protoc so that large
-	// files need not reside completely in memory at one time.  Note that as of
-	// this writing protoc does not optimize for this -- it will read the entire
-	// CodeGeneratorResponse before writing files to disk.
-	Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
-	// If non-empty, indicates that the named file should already exist, and the
-	// content here is to be inserted into that file at a defined insertion
-	// point.  This feature allows a code generator to extend the output
-	// produced by another code generator.  The original generator may provide
-	// insertion points by placing special annotations in the file that look
-	// like:
-	//   @@protoc_insertion_point(NAME)
-	// The annotation can have arbitrary text before and after it on the line,
-	// which allows it to be placed in a comment.  NAME should be replaced with
-	// an identifier naming the point -- this is what other generators will use
-	// as the insertion_point.  Code inserted at this point will be placed
-	// immediately above the line containing the insertion point (thus multiple
-	// insertions to the same point will come out in the order they were added).
-	// The double-@ is intended to make it unlikely that the generated code
-	// could contain things that look like insertion points by accident.
-	//
-	// For example, the C++ code generator places the following line in the
-	// .pb.h files that it generates:
-	//   // @@protoc_insertion_point(namespace_scope)
-	// This line appears within the scope of the file's package namespace, but
-	// outside of any particular class.  Another plugin can then specify the
-	// insertion_point "namespace_scope" to generate additional classes or
-	// other declarations that should be placed in this scope.
-	//
-	// Note that if the line containing the insertion point begins with
-	// whitespace, the same whitespace will be added to every line of the
-	// inserted text.  This is useful for languages like Python, where
-	// indentation matters.  In these languages, the insertion point comment
-	// should be indented the same amount as any inserted code will need to be
-	// in order to work correctly in that context.
-	//
-	// The code generator that generates the initial file and the one which
-	// inserts into it must both run as part of a single invocation of protoc.
-	// Code generators are executed in the order in which they appear on the
-	// command line.
-	//
-	// If |insertion_point| is present, |name| must also be present.
-	InsertionPoint *string `protobuf:"bytes,2,opt,name=insertion_point,json=insertionPoint" json:"insertion_point,omitempty"`
-	// The file contents.
-	Content              *string  `protobuf:"bytes,15,opt,name=content" json:"content,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *CodeGeneratorResponse_File) Reset()                    { *m = CodeGeneratorResponse_File{} }
-func (m *CodeGeneratorResponse_File) String() string            { return proto.CompactTextString(m) }
-func (*CodeGeneratorResponse_File) ProtoMessage()               {}
-func (*CodeGeneratorResponse_File) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2, 0} }
-func (m *CodeGeneratorResponse_File) Unmarshal(b []byte) error {
-	return xxx_messageInfo_CodeGeneratorResponse_File.Unmarshal(m, b)
-}
-func (m *CodeGeneratorResponse_File) Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_CodeGeneratorResponse_File.Marshal(b, m, deterministic)
-}
-func (dst *CodeGeneratorResponse_File) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CodeGeneratorResponse_File.Merge(dst, src)
-}
-func (m *CodeGeneratorResponse_File) XXX_Size() int {
-	return xxx_messageInfo_CodeGeneratorResponse_File.Size(m)
-}
-func (m *CodeGeneratorResponse_File) XXX_DiscardUnknown() {
-	xxx_messageInfo_CodeGeneratorResponse_File.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_CodeGeneratorResponse_File proto.InternalMessageInfo
-
-func (m *CodeGeneratorResponse_File) GetName() string {
-	if m != nil && m.Name != nil {
-		return *m.Name
-	}
-	return ""
-}
-
-func (m *CodeGeneratorResponse_File) GetInsertionPoint() string {
-	if m != nil && m.InsertionPoint != nil {
-		return *m.InsertionPoint
-	}
-	return ""
-}
-
-func (m *CodeGeneratorResponse_File) GetContent() string {
-	if m != nil && m.Content != nil {
-		return *m.Content
-	}
-	return ""
-}
-
-func init() {
-	proto.RegisterType((*Version)(nil), "google.protobuf.compiler.Version")
-	proto.RegisterType((*CodeGeneratorRequest)(nil), "google.protobuf.compiler.CodeGeneratorRequest")
-	proto.RegisterType((*CodeGeneratorResponse)(nil), "google.protobuf.compiler.CodeGeneratorResponse")
-	proto.RegisterType((*CodeGeneratorResponse_File)(nil), "google.protobuf.compiler.CodeGeneratorResponse.File")
-}
-
-func init() { proto.RegisterFile("google/protobuf/compiler/plugin.proto", fileDescriptor0) }
-
-var fileDescriptor0 = []byte{
-	// 417 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x92, 0xcf, 0x6a, 0x14, 0x41,
-	0x10, 0xc6, 0x19, 0x77, 0x63, 0x98, 0x8a, 0x64, 0x43, 0x13, 0xa5, 0x09, 0x39, 0x8c, 0x8b, 0xe2,
-	0x5c, 0x32, 0x0b, 0xc1, 0x8b, 0x78, 0x4b, 0x44, 0x3d, 0x78, 0x58, 0x1a, 0xf1, 0x20, 0xc8, 0x30,
-	0x99, 0xd4, 0x74, 0x5a, 0x66, 0xba, 0xc6, 0xee, 0x1e, 0xf1, 0x49, 0x7d, 0x0f, 0xdf, 0x40, 0xfa,
-	0xcf, 0x24, 0xb2, 0xb8, 0xa7, 0xee, 0xef, 0x57, 0xd5, 0xd5, 0x55, 0x1f, 0x05, 0x2f, 0x25, 0x91,
-	0xec, 0x71, 0x33, 0x1a, 0x72, 0x74, 0x33, 0x75, 0x9b, 0x96, 0x86, 0x51, 0xf5, 0x68, 0x36, 0x63,
-	0x3f, 0x49, 0xa5, 0xab, 0x10, 0x60, 0x3c, 0xa6, 0x55, 0x73, 0x5a, 0x35, 0xa7, 0x9d, 0x15, 0xbb,
-	0x05, 0x6e, 0xd1, 0xb6, 0x46, 0x8d, 0x8e, 0x4c, 0xcc, 0x5e, 0xb7, 0x70, 0xf8, 0x05, 0x8d, 0x55,
-	0xa4, 0xd9, 0x29, 0x1c, 0x0c, 0xcd, 0x77, 0x32, 0x3c, 0x2b, 0xb2, 0xf2, 0x40, 0x44, 0x11, 0xa8,
-	0xd2, 0x64, 0xf8, 0xa3, 0x44, 0xbd, 0xf0, 0x74, 0x6c, 0x5c, 0x7b, 0xc7, 0x17, 0x91, 0x06, 0xc1,
-	0x9e, 0xc1, 0x63, 0x3b, 0x75, 0x9d, 0xfa, 0xc5, 0x97, 0x45, 0x56, 0xe6, 0x22, 0xa9, 0xf5, 0x9f,
-	0x0c, 0x4e, 0xaf, 0xe9, 0x16, 0x3f, 0xa0, 0x46, 0xd3, 0x38, 0x32, 0x02, 0x7f, 0x4c, 0x68, 0x1d,
-	0x2b, 0xe1, 0xa4, 0x53, 0x3d, 0xd6, 0x8e, 0x6a, 0x19, 0x63, 0xc8, 0xb3, 0x62, 0x51, 0xe6, 0xe2,
-	0xd8, 0xf3, 0xcf, 0x94, 0x5e, 0x20, 0x3b, 0x87, 0x7c, 0x6c, 0x4c, 0x33, 0xa0, 0xc3, 0xd8, 0x4a,
-	0x2e, 0x1e, 0x00, 0xbb, 0x06, 0x08, 0xe3, 0xd4, 0xfe, 0x15, 0x5f, 0x15, 0x8b, 0xf2, 0xe8, 0xf2,
-	0x45, 0xb5, 0x6b, 0xcb, 0x7b, 0xd5, 0xe3, 0xbb, 0x7b, 0x03, 0xb6, 0x1e, 0x8b, 0x3c, 0x44, 0x7d,
-	0x84, 0x7d, 0x82, 0x93, 0xd9, 0xb8, 0xfa, 0x67, 0xf4, 0x24, 0x8c, 0x77, 0x74, 0xf9, 0xbc, 0xda,
-	0xe7, 0x70, 0x95, 0xcc, 0x13, 0xab, 0x99, 0x24, 0xb0, 0xfe, 0x9d, 0xc1, 0xd3, 0x9d, 0x99, 0xed,
-	0x48, 0xda, 0xa2, 0xf7, 0x0e, 0x8d, 0x49, 0x3e, 0xe7, 0x22, 0x0a, 0xf6, 0x11, 0x96, 0xff, 0x34,
-	0xff, 0x7a, 0xff, 0x8f, 0xff, 0x2d, 0x1a, 0x66, 0x13, 0xa1, 0xc2, 0xd9, 0x37, 0x58, 0x86, 0x79,
-	0x18, 0x2c, 0x75, 0x33, 0x60, 0xfa, 0x26, 0xdc, 0xd9, 0x2b, 0x58, 0x29, 0x6d, 0xd1, 0x38, 0x45,
-	0xba, 0x1e, 0x49, 0x69, 0x97, 0xcc, 0x3c, 0xbe, 0xc7, 0x5b, 0x4f, 0x19, 0x87, 0xc3, 0x96, 0xb4,
-	0x43, 0xed, 0xf8, 0x2a, 0x24, 0xcc, 0xf2, 0x4a, 0xc2, 0x79, 0x4b, 0xc3, 0xde, 0xfe, 0xae, 0x9e,
-	0x6c, 0xc3, 0x6e, 0x06, 0x7b, 0xed, 0xd7, 0x37, 0x52, 0xb9, 0xbb, 0xe9, 0xc6, 0x87, 0x37, 0x92,
-	0xfa, 0x46, 0xcb, 0x87, 0x65, 0x0c, 0x97, 0xf6, 0x42, 0xa2, 0xbe, 0x90, 0x94, 0x56, 0xfa, 0x6d,
-	0x3c, 0x6a, 0x49, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xf7, 0x15, 0x40, 0xc5, 0xfe, 0x02, 0x00,
-	0x00,
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   0,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto_goTypes,
+		DependencyIndexes: file_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto_depIdxs,
+	}.Build()
+	File_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto = out.File
+	file_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto_rawDesc = nil
+	file_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto_goTypes = nil
+	file_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto_depIdxs = nil
 }
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/plugin/plugin.pb.golden b/vendor/github.com/golang/protobuf/protoc-gen-go/plugin/plugin.pb.golden
deleted file mode 100644
index 8953d0ff8..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/plugin/plugin.pb.golden
+++ /dev/null
@@ -1,83 +0,0 @@
-// Code generated by protoc-gen-go.
-// source: google/protobuf/compiler/plugin.proto
-// DO NOT EDIT!
-
-package google_protobuf_compiler
-
-import proto "github.com/golang/protobuf/proto"
-import "math"
-import google_protobuf "github.com/golang/protobuf/protoc-gen-go/descriptor"
-
-// Reference proto and math imports to suppress error if they are not otherwise used.
-var _ = proto.GetString
-var _ = math.Inf
-
-type CodeGeneratorRequest struct {
-	FileToGenerate   []string                               `protobuf:"bytes,1,rep,name=file_to_generate" json:"file_to_generate,omitempty"`
-	Parameter        *string                                `protobuf:"bytes,2,opt,name=parameter" json:"parameter,omitempty"`
-	ProtoFile        []*google_protobuf.FileDescriptorProto `protobuf:"bytes,15,rep,name=proto_file" json:"proto_file,omitempty"`
-	XXX_unrecognized []byte                                 `json:"-"`
-}
-
-func (this *CodeGeneratorRequest) Reset()         { *this = CodeGeneratorRequest{} }
-func (this *CodeGeneratorRequest) String() string { return proto.CompactTextString(this) }
-func (*CodeGeneratorRequest) ProtoMessage()       {}
-
-func (this *CodeGeneratorRequest) GetParameter() string {
-	if this != nil && this.Parameter != nil {
-		return *this.Parameter
-	}
-	return ""
-}
-
-type CodeGeneratorResponse struct {
-	Error            *string                       `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"`
-	File             []*CodeGeneratorResponse_File `protobuf:"bytes,15,rep,name=file" json:"file,omitempty"`
-	XXX_unrecognized []byte                        `json:"-"`
-}
-
-func (this *CodeGeneratorResponse) Reset()         { *this = CodeGeneratorResponse{} }
-func (this *CodeGeneratorResponse) String() string { return proto.CompactTextString(this) }
-func (*CodeGeneratorResponse) ProtoMessage()       {}
-
-func (this *CodeGeneratorResponse) GetError() string {
-	if this != nil && this.Error != nil {
-		return *this.Error
-	}
-	return ""
-}
-
-type CodeGeneratorResponse_File struct {
-	Name             *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
-	InsertionPoint   *string `protobuf:"bytes,2,opt,name=insertion_point" json:"insertion_point,omitempty"`
-	Content          *string `protobuf:"bytes,15,opt,name=content" json:"content,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (this *CodeGeneratorResponse_File) Reset()         { *this = CodeGeneratorResponse_File{} }
-func (this *CodeGeneratorResponse_File) String() string { return proto.CompactTextString(this) }
-func (*CodeGeneratorResponse_File) ProtoMessage()       {}
-
-func (this *CodeGeneratorResponse_File) GetName() string {
-	if this != nil && this.Name != nil {
-		return *this.Name
-	}
-	return ""
-}
-
-func (this *CodeGeneratorResponse_File) GetInsertionPoint() string {
-	if this != nil && this.InsertionPoint != nil {
-		return *this.InsertionPoint
-	}
-	return ""
-}
-
-func (this *CodeGeneratorResponse_File) GetContent() string {
-	if this != nil && this.Content != nil {
-		return *this.Content
-	}
-	return ""
-}
-
-func init() {
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/plugin/plugin.proto b/vendor/github.com/golang/protobuf/protoc-gen-go/plugin/plugin.proto
deleted file mode 100644
index 5b5574529..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/plugin/plugin.proto
+++ /dev/null
@@ -1,167 +0,0 @@
-// Protocol Buffers - Google's data interchange format
-// Copyright 2008 Google Inc.  All rights reserved.
-// https://developers.google.com/protocol-buffers/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Author: kenton@google.com (Kenton Varda)
-//
-// WARNING:  The plugin interface is currently EXPERIMENTAL and is subject to
-//   change.
-//
-// protoc (aka the Protocol Compiler) can be extended via plugins.  A plugin is
-// just a program that reads a CodeGeneratorRequest from stdin and writes a
-// CodeGeneratorResponse to stdout.
-//
-// Plugins written using C++ can use google/protobuf/compiler/plugin.h instead
-// of dealing with the raw protocol defined here.
-//
-// A plugin executable needs only to be placed somewhere in the path.  The
-// plugin should be named "protoc-gen-$NAME", and will then be used when the
-// flag "--${NAME}_out" is passed to protoc.
-
-syntax = "proto2";
-package google.protobuf.compiler;
-option java_package = "com.google.protobuf.compiler";
-option java_outer_classname = "PluginProtos";
-
-option go_package = "github.com/golang/protobuf/protoc-gen-go/plugin;plugin_go";
-
-import "google/protobuf/descriptor.proto";
-
-// The version number of protocol compiler.
-message Version {
-  optional int32 major = 1;
-  optional int32 minor = 2;
-  optional int32 patch = 3;
-  // A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
-  // be empty for mainline stable releases.
-  optional string suffix = 4;
-}
-
-// An encoded CodeGeneratorRequest is written to the plugin's stdin.
-message CodeGeneratorRequest {
-  // The .proto files that were explicitly listed on the command-line.  The
-  // code generator should generate code only for these files.  Each file's
-  // descriptor will be included in proto_file, below.
-  repeated string file_to_generate = 1;
-
-  // The generator parameter passed on the command-line.
-  optional string parameter = 2;
-
-  // FileDescriptorProtos for all files in files_to_generate and everything
-  // they import.  The files will appear in topological order, so each file
-  // appears before any file that imports it.
-  //
-  // protoc guarantees that all proto_files will be written after
-  // the fields above, even though this is not technically guaranteed by the
-  // protobuf wire format.  This theoretically could allow a plugin to stream
-  // in the FileDescriptorProtos and handle them one by one rather than read
-  // the entire set into memory at once.  However, as of this writing, this
-  // is not similarly optimized on protoc's end -- it will store all fields in
-  // memory at once before sending them to the plugin.
-  //
-  // Type names of fields and extensions in the FileDescriptorProto are always
-  // fully qualified.
-  repeated FileDescriptorProto proto_file = 15;
-
-  // The version number of protocol compiler.
-  optional Version compiler_version = 3;
-
-}
-
-// The plugin writes an encoded CodeGeneratorResponse to stdout.
-message CodeGeneratorResponse {
-  // Error message.  If non-empty, code generation failed.  The plugin process
-  // should exit with status code zero even if it reports an error in this way.
-  //
-  // This should be used to indicate errors in .proto files which prevent the
-  // code generator from generating correct code.  Errors which indicate a
-  // problem in protoc itself -- such as the input CodeGeneratorRequest being
-  // unparseable -- should be reported by writing a message to stderr and
-  // exiting with a non-zero status code.
-  optional string error = 1;
-
-  // Represents a single generated file.
-  message File {
-    // The file name, relative to the output directory.  The name must not
-    // contain "." or ".." components and must be relative, not be absolute (so,
-    // the file cannot lie outside the output directory).  "/" must be used as
-    // the path separator, not "\".
-    //
-    // If the name is omitted, the content will be appended to the previous
-    // file.  This allows the generator to break large files into small chunks,
-    // and allows the generated text to be streamed back to protoc so that large
-    // files need not reside completely in memory at one time.  Note that as of
-    // this writing protoc does not optimize for this -- it will read the entire
-    // CodeGeneratorResponse before writing files to disk.
-    optional string name = 1;
-
-    // If non-empty, indicates that the named file should already exist, and the
-    // content here is to be inserted into that file at a defined insertion
-    // point.  This feature allows a code generator to extend the output
-    // produced by another code generator.  The original generator may provide
-    // insertion points by placing special annotations in the file that look
-    // like:
-    //   @@protoc_insertion_point(NAME)
-    // The annotation can have arbitrary text before and after it on the line,
-    // which allows it to be placed in a comment.  NAME should be replaced with
-    // an identifier naming the point -- this is what other generators will use
-    // as the insertion_point.  Code inserted at this point will be placed
-    // immediately above the line containing the insertion point (thus multiple
-    // insertions to the same point will come out in the order they were added).
-    // The double-@ is intended to make it unlikely that the generated code
-    // could contain things that look like insertion points by accident.
-    //
-    // For example, the C++ code generator places the following line in the
-    // .pb.h files that it generates:
-    //   // @@protoc_insertion_point(namespace_scope)
-    // This line appears within the scope of the file's package namespace, but
-    // outside of any particular class.  Another plugin can then specify the
-    // insertion_point "namespace_scope" to generate additional classes or
-    // other declarations that should be placed in this scope.
-    //
-    // Note that if the line containing the insertion point begins with
-    // whitespace, the same whitespace will be added to every line of the
-    // inserted text.  This is useful for languages like Python, where
-    // indentation matters.  In these languages, the insertion point comment
-    // should be indented the same amount as any inserted code will need to be
-    // in order to work correctly in that context.
-    //
-    // The code generator that generates the initial file and the one which
-    // inserts into it must both run as part of a single invocation of protoc.
-    // Code generators are executed in the order in which they appear on the
-    // command line.
-    //
-    // If |insertion_point| is present, |name| must also be present.
-    optional string insertion_point = 2;
-
-    // The file contents.
-    optional string content = 15;
-  }
-  repeated File file = 15;
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/deprecated/deprecated.pb.go b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/deprecated/deprecated.pb.go
deleted file mode 100644
index ea699eabe..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/deprecated/deprecated.pb.go
+++ /dev/null
@@ -1,234 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// deprecated/deprecated.proto is a deprecated file.
-
-package deprecated // import "github.com/golang/protobuf/protoc-gen-go/testdata/deprecated"
-
-/*
-package deprecated contains only deprecated messages and services.
-*/
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-import (
-	context "golang.org/x/net/context"
-	grpc "google.golang.org/grpc"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-// DeprecatedEnum contains deprecated values.
-type DeprecatedEnum int32 // Deprecated: Do not use.
-const (
-	// DEPRECATED is the iota value of this enum.
-	DeprecatedEnum_DEPRECATED DeprecatedEnum = 0 // Deprecated: Do not use.
-)
-
-var DeprecatedEnum_name = map[int32]string{
-	0: "DEPRECATED",
-}
-var DeprecatedEnum_value = map[string]int32{
-	"DEPRECATED": 0,
-}
-
-func (x DeprecatedEnum) String() string {
-	return proto.EnumName(DeprecatedEnum_name, int32(x))
-}
-func (DeprecatedEnum) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_deprecated_9e1889ba21817fad, []int{0}
-}
-
-// DeprecatedRequest is a request to DeprecatedCall.
-//
-// Deprecated: Do not use.
-type DeprecatedRequest struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *DeprecatedRequest) Reset()         { *m = DeprecatedRequest{} }
-func (m *DeprecatedRequest) String() string { return proto.CompactTextString(m) }
-func (*DeprecatedRequest) ProtoMessage()    {}
-func (*DeprecatedRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_deprecated_9e1889ba21817fad, []int{0}
-}
-func (m *DeprecatedRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_DeprecatedRequest.Unmarshal(m, b)
-}
-func (m *DeprecatedRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_DeprecatedRequest.Marshal(b, m, deterministic)
-}
-func (dst *DeprecatedRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_DeprecatedRequest.Merge(dst, src)
-}
-func (m *DeprecatedRequest) XXX_Size() int {
-	return xxx_messageInfo_DeprecatedRequest.Size(m)
-}
-func (m *DeprecatedRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_DeprecatedRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_DeprecatedRequest proto.InternalMessageInfo
-
-// Deprecated: Do not use.
-type DeprecatedResponse struct {
-	// DeprecatedField contains a DeprecatedEnum.
-	DeprecatedField      DeprecatedEnum `protobuf:"varint,1,opt,name=deprecated_field,json=deprecatedField,enum=deprecated.DeprecatedEnum" json:"deprecated_field,omitempty"` // Deprecated: Do not use.
-	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
-	XXX_unrecognized     []byte         `json:"-"`
-	XXX_sizecache        int32          `json:"-"`
-}
-
-func (m *DeprecatedResponse) Reset()         { *m = DeprecatedResponse{} }
-func (m *DeprecatedResponse) String() string { return proto.CompactTextString(m) }
-func (*DeprecatedResponse) ProtoMessage()    {}
-func (*DeprecatedResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_deprecated_9e1889ba21817fad, []int{1}
-}
-func (m *DeprecatedResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_DeprecatedResponse.Unmarshal(m, b)
-}
-func (m *DeprecatedResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_DeprecatedResponse.Marshal(b, m, deterministic)
-}
-func (dst *DeprecatedResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_DeprecatedResponse.Merge(dst, src)
-}
-func (m *DeprecatedResponse) XXX_Size() int {
-	return xxx_messageInfo_DeprecatedResponse.Size(m)
-}
-func (m *DeprecatedResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_DeprecatedResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_DeprecatedResponse proto.InternalMessageInfo
-
-// Deprecated: Do not use.
-func (m *DeprecatedResponse) GetDeprecatedField() DeprecatedEnum {
-	if m != nil {
-		return m.DeprecatedField
-	}
-	return DeprecatedEnum_DEPRECATED
-}
-
-func init() {
-	proto.RegisterType((*DeprecatedRequest)(nil), "deprecated.DeprecatedRequest")
-	proto.RegisterType((*DeprecatedResponse)(nil), "deprecated.DeprecatedResponse")
-	proto.RegisterEnum("deprecated.DeprecatedEnum", DeprecatedEnum_name, DeprecatedEnum_value)
-}
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ context.Context
-var _ grpc.ClientConn
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the grpc package it is being compiled against.
-const _ = grpc.SupportPackageIsVersion4
-
-// DeprecatedServiceClient is the client API for DeprecatedService service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
-//
-// Deprecated: Do not use.
-type DeprecatedServiceClient interface {
-	// DeprecatedCall takes a DeprecatedRequest and returns a DeprecatedResponse.
-	DeprecatedCall(ctx context.Context, in *DeprecatedRequest, opts ...grpc.CallOption) (*DeprecatedResponse, error)
-}
-
-type deprecatedServiceClient struct {
-	cc *grpc.ClientConn
-}
-
-// Deprecated: Do not use.
-func NewDeprecatedServiceClient(cc *grpc.ClientConn) DeprecatedServiceClient {
-	return &deprecatedServiceClient{cc}
-}
-
-// Deprecated: Do not use.
-func (c *deprecatedServiceClient) DeprecatedCall(ctx context.Context, in *DeprecatedRequest, opts ...grpc.CallOption) (*DeprecatedResponse, error) {
-	out := new(DeprecatedResponse)
-	err := c.cc.Invoke(ctx, "/deprecated.DeprecatedService/DeprecatedCall", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-// DeprecatedServiceServer is the server API for DeprecatedService service.
-//
-// Deprecated: Do not use.
-type DeprecatedServiceServer interface {
-	// DeprecatedCall takes a DeprecatedRequest and returns a DeprecatedResponse.
-	DeprecatedCall(context.Context, *DeprecatedRequest) (*DeprecatedResponse, error)
-}
-
-// Deprecated: Do not use.
-func RegisterDeprecatedServiceServer(s *grpc.Server, srv DeprecatedServiceServer) {
-	s.RegisterService(&_DeprecatedService_serviceDesc, srv)
-}
-
-func _DeprecatedService_DeprecatedCall_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(DeprecatedRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(DeprecatedServiceServer).DeprecatedCall(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/deprecated.DeprecatedService/DeprecatedCall",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(DeprecatedServiceServer).DeprecatedCall(ctx, req.(*DeprecatedRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-var _DeprecatedService_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "deprecated.DeprecatedService",
-	HandlerType: (*DeprecatedServiceServer)(nil),
-	Methods: []grpc.MethodDesc{
-		{
-			MethodName: "DeprecatedCall",
-			Handler:    _DeprecatedService_DeprecatedCall_Handler,
-		},
-	},
-	Streams:  []grpc.StreamDesc{},
-	Metadata: "deprecated/deprecated.proto",
-}
-
-func init() {
-	proto.RegisterFile("deprecated/deprecated.proto", fileDescriptor_deprecated_9e1889ba21817fad)
-}
-
-var fileDescriptor_deprecated_9e1889ba21817fad = []byte{
-	// 248 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4e, 0x49, 0x2d, 0x28,
-	0x4a, 0x4d, 0x4e, 0x2c, 0x49, 0x4d, 0xd1, 0x47, 0x30, 0xf5, 0x0a, 0x8a, 0xf2, 0x4b, 0xf2, 0x85,
-	0xb8, 0x10, 0x22, 0x4a, 0xe2, 0x5c, 0x82, 0x2e, 0x70, 0x5e, 0x50, 0x6a, 0x61, 0x69, 0x6a, 0x71,
-	0x89, 0x15, 0x93, 0x04, 0xa3, 0x52, 0x32, 0x97, 0x10, 0xb2, 0x44, 0x71, 0x41, 0x7e, 0x5e, 0x71,
-	0xaa, 0x90, 0x27, 0x97, 0x00, 0x42, 0x73, 0x7c, 0x5a, 0x66, 0x6a, 0x4e, 0x8a, 0x04, 0xa3, 0x02,
-	0xa3, 0x06, 0x9f, 0x91, 0x94, 0x1e, 0x92, 0x3d, 0x08, 0x9d, 0xae, 0x79, 0xa5, 0xb9, 0x4e, 0x4c,
-	0x12, 0x8c, 0x41, 0xfc, 0x08, 0x69, 0x37, 0x90, 0x36, 0x90, 0x25, 0x5a, 0x1a, 0x5c, 0x7c, 0xa8,
-	0x4a, 0x85, 0x84, 0xb8, 0xb8, 0x5c, 0x5c, 0x03, 0x82, 0x5c, 0x9d, 0x1d, 0x43, 0x5c, 0x5d, 0x04,
-	0x18, 0xa4, 0x98, 0x38, 0x18, 0xa5, 0x98, 0x24, 0x18, 0x8d, 0xf2, 0x90, 0xdd, 0x19, 0x9c, 0x5a,
-	0x54, 0x96, 0x99, 0x9c, 0x2a, 0x14, 0x82, 0xac, 0xdd, 0x39, 0x31, 0x27, 0x47, 0x48, 0x16, 0xbb,
-	0x2b, 0xa0, 0x1e, 0x93, 0x92, 0xc3, 0x25, 0x0d, 0xf1, 0x9e, 0x12, 0x73, 0x07, 0x13, 0xa3, 0x14,
-	0x88, 0x70, 0x72, 0x8c, 0xb2, 0x49, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5,
-	0x4f, 0xcf, 0xcf, 0x49, 0xcc, 0x4b, 0xd7, 0x07, 0x07, 0x5f, 0x52, 0x69, 0x1a, 0x84, 0x91, 0xac,
-	0x9b, 0x9e, 0x9a, 0xa7, 0x9b, 0x9e, 0xaf, 0x5f, 0x92, 0x5a, 0x5c, 0x92, 0x92, 0x58, 0x92, 0x88,
-	0x14, 0xd2, 0x3b, 0x18, 0x19, 0x93, 0xd8, 0xc0, 0xaa, 0x8c, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff,
-	0x0e, 0xf5, 0x6c, 0x87, 0x8c, 0x01, 0x00, 0x00,
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/deprecated/deprecated.proto b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/deprecated/deprecated.proto
deleted file mode 100644
index b314166d2..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/deprecated/deprecated.proto
+++ /dev/null
@@ -1,69 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2018 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto3";
-
-// package deprecated contains only deprecated messages and services.
-package deprecated;
-
-option go_package = "github.com/golang/protobuf/protoc-gen-go/testdata/deprecated";
-
-option deprecated = true; // file-level deprecation
-
-// DeprecatedRequest is a request to DeprecatedCall.
-message DeprecatedRequest {
-  option deprecated = true;
-}
-
-message DeprecatedResponse {
-  // comment for DeprecatedResponse is omitted to guarantee deprecation
-  // message doesn't append unnecessary comments.
-  option deprecated = true;
-  // DeprecatedField contains a DeprecatedEnum.
-  DeprecatedEnum deprecated_field = 1 [deprecated=true];
-}
-
-// DeprecatedEnum contains deprecated values.
-enum DeprecatedEnum {
-  option deprecated = true;
-  // DEPRECATED is the iota value of this enum.
-  DEPRECATED = 0 [deprecated=true];
-}
-
-// DeprecatedService is for making DeprecatedCalls
-service DeprecatedService {
-  option deprecated = true;
-
-  // DeprecatedCall takes a DeprecatedRequest and returns a DeprecatedResponse.
-  rpc DeprecatedCall(DeprecatedRequest) returns (DeprecatedResponse) {
-    option deprecated = true;
-  }
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/extension_base/extension_base.pb.go b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/extension_base/extension_base.pb.go
deleted file mode 100644
index a08e8eda5..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/extension_base/extension_base.pb.go
+++ /dev/null
@@ -1,139 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: extension_base/extension_base.proto
-
-package extension_base // import "github.com/golang/protobuf/protoc-gen-go/testdata/extension_base"
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-type BaseMessage struct {
-	Height                       *int32   `protobuf:"varint,1,opt,name=height" json:"height,omitempty"`
-	XXX_NoUnkeyedLiteral         struct{} `json:"-"`
-	proto.XXX_InternalExtensions `json:"-"`
-	XXX_unrecognized             []byte `json:"-"`
-	XXX_sizecache                int32  `json:"-"`
-}
-
-func (m *BaseMessage) Reset()         { *m = BaseMessage{} }
-func (m *BaseMessage) String() string { return proto.CompactTextString(m) }
-func (*BaseMessage) ProtoMessage()    {}
-func (*BaseMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_extension_base_41d3c712c9fc37fc, []int{0}
-}
-
-var extRange_BaseMessage = []proto.ExtensionRange{
-	{Start: 4, End: 9},
-	{Start: 16, End: 536870911},
-}
-
-func (*BaseMessage) ExtensionRangeArray() []proto.ExtensionRange {
-	return extRange_BaseMessage
-}
-func (m *BaseMessage) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_BaseMessage.Unmarshal(m, b)
-}
-func (m *BaseMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_BaseMessage.Marshal(b, m, deterministic)
-}
-func (dst *BaseMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_BaseMessage.Merge(dst, src)
-}
-func (m *BaseMessage) XXX_Size() int {
-	return xxx_messageInfo_BaseMessage.Size(m)
-}
-func (m *BaseMessage) XXX_DiscardUnknown() {
-	xxx_messageInfo_BaseMessage.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_BaseMessage proto.InternalMessageInfo
-
-func (m *BaseMessage) GetHeight() int32 {
-	if m != nil && m.Height != nil {
-		return *m.Height
-	}
-	return 0
-}
-
-// Another message that may be extended, using message_set_wire_format.
-type OldStyleMessage struct {
-	XXX_NoUnkeyedLiteral         struct{} `json:"-"`
-	proto.XXX_InternalExtensions `protobuf_messageset:"1" json:"-"`
-	XXX_unrecognized             []byte `json:"-"`
-	XXX_sizecache                int32  `json:"-"`
-}
-
-func (m *OldStyleMessage) Reset()         { *m = OldStyleMessage{} }
-func (m *OldStyleMessage) String() string { return proto.CompactTextString(m) }
-func (*OldStyleMessage) ProtoMessage()    {}
-func (*OldStyleMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_extension_base_41d3c712c9fc37fc, []int{1}
-}
-
-func (m *OldStyleMessage) MarshalJSON() ([]byte, error) {
-	return proto.MarshalMessageSetJSON(&m.XXX_InternalExtensions)
-}
-func (m *OldStyleMessage) UnmarshalJSON(buf []byte) error {
-	return proto.UnmarshalMessageSetJSON(buf, &m.XXX_InternalExtensions)
-}
-
-var extRange_OldStyleMessage = []proto.ExtensionRange{
-	{Start: 100, End: 2147483646},
-}
-
-func (*OldStyleMessage) ExtensionRangeArray() []proto.ExtensionRange {
-	return extRange_OldStyleMessage
-}
-func (m *OldStyleMessage) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_OldStyleMessage.Unmarshal(m, b)
-}
-func (m *OldStyleMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_OldStyleMessage.Marshal(b, m, deterministic)
-}
-func (dst *OldStyleMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_OldStyleMessage.Merge(dst, src)
-}
-func (m *OldStyleMessage) XXX_Size() int {
-	return xxx_messageInfo_OldStyleMessage.Size(m)
-}
-func (m *OldStyleMessage) XXX_DiscardUnknown() {
-	xxx_messageInfo_OldStyleMessage.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_OldStyleMessage proto.InternalMessageInfo
-
-func init() {
-	proto.RegisterType((*BaseMessage)(nil), "extension_base.BaseMessage")
-	proto.RegisterType((*OldStyleMessage)(nil), "extension_base.OldStyleMessage")
-}
-
-func init() {
-	proto.RegisterFile("extension_base/extension_base.proto", fileDescriptor_extension_base_41d3c712c9fc37fc)
-}
-
-var fileDescriptor_extension_base_41d3c712c9fc37fc = []byte{
-	// 179 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x4e, 0xad, 0x28, 0x49,
-	0xcd, 0x2b, 0xce, 0xcc, 0xcf, 0x8b, 0x4f, 0x4a, 0x2c, 0x4e, 0xd5, 0x47, 0xe5, 0xea, 0x15, 0x14,
-	0xe5, 0x97, 0xe4, 0x0b, 0xf1, 0xa1, 0x8a, 0x2a, 0x99, 0x72, 0x71, 0x3b, 0x25, 0x16, 0xa7, 0xfa,
-	0xa6, 0x16, 0x17, 0x27, 0xa6, 0xa7, 0x0a, 0x89, 0x71, 0xb1, 0x65, 0xa4, 0x66, 0xa6, 0x67, 0x94,
-	0x48, 0x30, 0x2a, 0x30, 0x6a, 0xb0, 0x06, 0x41, 0x79, 0x5a, 0x2c, 0x1c, 0x2c, 0x02, 0x5c, 0x5a,
-	0x1c, 0x1c, 0x02, 0x02, 0x0d, 0x0d, 0x0d, 0x0d, 0x4c, 0x4a, 0xf2, 0x5c, 0xfc, 0xfe, 0x39, 0x29,
-	0xc1, 0x25, 0x95, 0x39, 0x30, 0xad, 0x5a, 0x1c, 0x1c, 0x29, 0x02, 0xff, 0xff, 0xff, 0xff, 0xcf,
-	0x6e, 0xc5, 0xc4, 0xc1, 0xe8, 0xe4, 0x14, 0xe5, 0x90, 0x9e, 0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97,
-	0x9c, 0x9f, 0xab, 0x9f, 0x9e, 0x9f, 0x93, 0x98, 0x97, 0xae, 0x0f, 0x76, 0x42, 0x52, 0x69, 0x1a,
-	0x84, 0x91, 0xac, 0x9b, 0x9e, 0x9a, 0xa7, 0x9b, 0x9e, 0xaf, 0x5f, 0x92, 0x5a, 0x5c, 0x92, 0x92,
-	0x58, 0x92, 0x88, 0xe6, 0x62, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7a, 0x7f, 0xb7, 0x2a, 0xd1,
-	0x00, 0x00, 0x00,
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/extension_base/extension_base.proto b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/extension_base/extension_base.proto
deleted file mode 100644
index 0ba74def8..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/extension_base/extension_base.proto
+++ /dev/null
@@ -1,48 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto2";
-
-package extension_base;
-
-option go_package = "github.com/golang/protobuf/protoc-gen-go/testdata/extension_base";
-
-message BaseMessage {
-  optional int32 height = 1;
-  extensions 4 to 9;
-  extensions 16 to max;
-}
-
-// Another message that may be extended, using message_set_wire_format.
-message OldStyleMessage {
-  option message_set_wire_format = true;
-  extensions 100 to max;
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/extension_extra/extension_extra.pb.go b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/extension_extra/extension_extra.pb.go
deleted file mode 100644
index b37321690..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/extension_extra/extension_extra.pb.go
+++ /dev/null
@@ -1,78 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: extension_extra/extension_extra.proto
-
-package extension_extra // import "github.com/golang/protobuf/protoc-gen-go/testdata/extension_extra"
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-type ExtraMessage struct {
-	Width                *int32   `protobuf:"varint,1,opt,name=width" json:"width,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *ExtraMessage) Reset()         { *m = ExtraMessage{} }
-func (m *ExtraMessage) String() string { return proto.CompactTextString(m) }
-func (*ExtraMessage) ProtoMessage()    {}
-func (*ExtraMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_extension_extra_83adf2410f49f816, []int{0}
-}
-func (m *ExtraMessage) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ExtraMessage.Unmarshal(m, b)
-}
-func (m *ExtraMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ExtraMessage.Marshal(b, m, deterministic)
-}
-func (dst *ExtraMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ExtraMessage.Merge(dst, src)
-}
-func (m *ExtraMessage) XXX_Size() int {
-	return xxx_messageInfo_ExtraMessage.Size(m)
-}
-func (m *ExtraMessage) XXX_DiscardUnknown() {
-	xxx_messageInfo_ExtraMessage.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ExtraMessage proto.InternalMessageInfo
-
-func (m *ExtraMessage) GetWidth() int32 {
-	if m != nil && m.Width != nil {
-		return *m.Width
-	}
-	return 0
-}
-
-func init() {
-	proto.RegisterType((*ExtraMessage)(nil), "extension_extra.ExtraMessage")
-}
-
-func init() {
-	proto.RegisterFile("extension_extra/extension_extra.proto", fileDescriptor_extension_extra_83adf2410f49f816)
-}
-
-var fileDescriptor_extension_extra_83adf2410f49f816 = []byte{
-	// 133 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x4d, 0xad, 0x28, 0x49,
-	0xcd, 0x2b, 0xce, 0xcc, 0xcf, 0x8b, 0x4f, 0xad, 0x28, 0x29, 0x4a, 0xd4, 0x47, 0xe3, 0xeb, 0x15,
-	0x14, 0xe5, 0x97, 0xe4, 0x0b, 0xf1, 0xa3, 0x09, 0x2b, 0xa9, 0x70, 0xf1, 0xb8, 0x82, 0x18, 0xbe,
-	0xa9, 0xc5, 0xc5, 0x89, 0xe9, 0xa9, 0x42, 0x22, 0x5c, 0xac, 0xe5, 0x99, 0x29, 0x25, 0x19, 0x12,
-	0x8c, 0x0a, 0x8c, 0x1a, 0xac, 0x41, 0x10, 0x8e, 0x93, 0x73, 0x94, 0x63, 0x7a, 0x66, 0x49, 0x46,
-	0x69, 0x92, 0x5e, 0x72, 0x7e, 0xae, 0x7e, 0x7a, 0x7e, 0x4e, 0x62, 0x5e, 0xba, 0x3e, 0xd8, 0xc4,
-	0xa4, 0xd2, 0x34, 0x08, 0x23, 0x59, 0x37, 0x3d, 0x35, 0x4f, 0x37, 0x3d, 0x5f, 0xbf, 0x24, 0xb5,
-	0xb8, 0x24, 0x25, 0xb1, 0x04, 0xc3, 0x05, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf1, 0xec, 0xe3,
-	0xb7, 0xa3, 0x00, 0x00, 0x00,
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/extension_extra/extension_extra.proto b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/extension_extra/extension_extra.proto
deleted file mode 100644
index 1dd03e70b..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/extension_extra/extension_extra.proto
+++ /dev/null
@@ -1,40 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2011 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto2";
-
-package extension_extra;
-
-option go_package = "github.com/golang/protobuf/protoc-gen-go/testdata/extension_extra";
-
-message ExtraMessage {
-  optional int32 width = 1;
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/extension_test.go b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/extension_test.go
deleted file mode 100644
index 052472992..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/extension_test.go
+++ /dev/null
@@ -1,206 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Test that we can use protocol buffers that use extensions.
-
-package testdata
-
-import (
-	"bytes"
-	"regexp"
-	"testing"
-
-	"github.com/golang/protobuf/proto"
-	base "github.com/golang/protobuf/protoc-gen-go/testdata/extension_base"
-	user "github.com/golang/protobuf/protoc-gen-go/testdata/extension_user"
-)
-
-func TestSingleFieldExtension(t *testing.T) {
-	bm := &base.BaseMessage{
-		Height: proto.Int32(178),
-	}
-
-	// Use extension within scope of another type.
-	vol := proto.Uint32(11)
-	err := proto.SetExtension(bm, user.E_LoudMessage_Volume, vol)
-	if err != nil {
-		t.Fatal("Failed setting extension:", err)
-	}
-	buf, err := proto.Marshal(bm)
-	if err != nil {
-		t.Fatal("Failed encoding message with extension:", err)
-	}
-	bm_new := new(base.BaseMessage)
-	if err := proto.Unmarshal(buf, bm_new); err != nil {
-		t.Fatal("Failed decoding message with extension:", err)
-	}
-	if !proto.HasExtension(bm_new, user.E_LoudMessage_Volume) {
-		t.Fatal("Decoded message didn't contain extension.")
-	}
-	vol_out, err := proto.GetExtension(bm_new, user.E_LoudMessage_Volume)
-	if err != nil {
-		t.Fatal("Failed getting extension:", err)
-	}
-	if v := vol_out.(*uint32); *v != *vol {
-		t.Errorf("vol_out = %v, expected %v", *v, *vol)
-	}
-	proto.ClearExtension(bm_new, user.E_LoudMessage_Volume)
-	if proto.HasExtension(bm_new, user.E_LoudMessage_Volume) {
-		t.Fatal("Failed clearing extension.")
-	}
-}
-
-func TestMessageExtension(t *testing.T) {
-	bm := &base.BaseMessage{
-		Height: proto.Int32(179),
-	}
-
-	// Use extension that is itself a message.
-	um := &user.UserMessage{
-		Name: proto.String("Dave"),
-		Rank: proto.String("Major"),
-	}
-	err := proto.SetExtension(bm, user.E_LoginMessage_UserMessage, um)
-	if err != nil {
-		t.Fatal("Failed setting extension:", err)
-	}
-	buf, err := proto.Marshal(bm)
-	if err != nil {
-		t.Fatal("Failed encoding message with extension:", err)
-	}
-	bm_new := new(base.BaseMessage)
-	if err := proto.Unmarshal(buf, bm_new); err != nil {
-		t.Fatal("Failed decoding message with extension:", err)
-	}
-	if !proto.HasExtension(bm_new, user.E_LoginMessage_UserMessage) {
-		t.Fatal("Decoded message didn't contain extension.")
-	}
-	um_out, err := proto.GetExtension(bm_new, user.E_LoginMessage_UserMessage)
-	if err != nil {
-		t.Fatal("Failed getting extension:", err)
-	}
-	if n := um_out.(*user.UserMessage).Name; *n != *um.Name {
-		t.Errorf("um_out.Name = %q, expected %q", *n, *um.Name)
-	}
-	if r := um_out.(*user.UserMessage).Rank; *r != *um.Rank {
-		t.Errorf("um_out.Rank = %q, expected %q", *r, *um.Rank)
-	}
-	proto.ClearExtension(bm_new, user.E_LoginMessage_UserMessage)
-	if proto.HasExtension(bm_new, user.E_LoginMessage_UserMessage) {
-		t.Fatal("Failed clearing extension.")
-	}
-}
-
-func TestTopLevelExtension(t *testing.T) {
-	bm := &base.BaseMessage{
-		Height: proto.Int32(179),
-	}
-
-	width := proto.Int32(17)
-	err := proto.SetExtension(bm, user.E_Width, width)
-	if err != nil {
-		t.Fatal("Failed setting extension:", err)
-	}
-	buf, err := proto.Marshal(bm)
-	if err != nil {
-		t.Fatal("Failed encoding message with extension:", err)
-	}
-	bm_new := new(base.BaseMessage)
-	if err := proto.Unmarshal(buf, bm_new); err != nil {
-		t.Fatal("Failed decoding message with extension:", err)
-	}
-	if !proto.HasExtension(bm_new, user.E_Width) {
-		t.Fatal("Decoded message didn't contain extension.")
-	}
-	width_out, err := proto.GetExtension(bm_new, user.E_Width)
-	if err != nil {
-		t.Fatal("Failed getting extension:", err)
-	}
-	if w := width_out.(*int32); *w != *width {
-		t.Errorf("width_out = %v, expected %v", *w, *width)
-	}
-	proto.ClearExtension(bm_new, user.E_Width)
-	if proto.HasExtension(bm_new, user.E_Width) {
-		t.Fatal("Failed clearing extension.")
-	}
-}
-
-func TestMessageSetWireFormat(t *testing.T) {
-	osm := new(base.OldStyleMessage)
-	osp := &user.OldStyleParcel{
-		Name:   proto.String("Dave"),
-		Height: proto.Int32(178),
-	}
-
-	err := proto.SetExtension(osm, user.E_OldStyleParcel_MessageSetExtension, osp)
-	if err != nil {
-		t.Fatal("Failed setting extension:", err)
-	}
-
-	buf, err := proto.Marshal(osm)
-	if err != nil {
-		t.Fatal("Failed encoding message:", err)
-	}
-
-	// Data generated from Python implementation.
-	expected := []byte{
-		11, 16, 209, 15, 26, 9, 10, 4, 68, 97, 118, 101, 16, 178, 1, 12,
-	}
-
-	if !bytes.Equal(expected, buf) {
-		t.Errorf("Encoding mismatch.\nwant %+v\n got %+v", expected, buf)
-	}
-
-	// Check that it is restored correctly.
-	osm = new(base.OldStyleMessage)
-	if err := proto.Unmarshal(buf, osm); err != nil {
-		t.Fatal("Failed decoding message:", err)
-	}
-	osp_out, err := proto.GetExtension(osm, user.E_OldStyleParcel_MessageSetExtension)
-	if err != nil {
-		t.Fatal("Failed getting extension:", err)
-	}
-	osp = osp_out.(*user.OldStyleParcel)
-	if *osp.Name != "Dave" || *osp.Height != 178 {
-		t.Errorf("Retrieved extension from decoded message is not correct: %+v", osp)
-	}
-}
-
-func main() {
-	// simpler than rigging up gotest
-	testing.Main(regexp.MatchString, []testing.InternalTest{
-		{"TestSingleFieldExtension", TestSingleFieldExtension},
-		{"TestMessageExtension", TestMessageExtension},
-		{"TestTopLevelExtension", TestTopLevelExtension},
-	},
-		[]testing.InternalBenchmark{},
-		[]testing.InternalExample{})
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/extension_user/extension_user.pb.go b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/extension_user/extension_user.pb.go
deleted file mode 100644
index c71879215..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/extension_user/extension_user.pb.go
+++ /dev/null
@@ -1,401 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: extension_user/extension_user.proto
-
-package extension_user // import "github.com/golang/protobuf/protoc-gen-go/testdata/extension_user"
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-import extension_base "github.com/golang/protobuf/protoc-gen-go/testdata/extension_base"
-import extension_extra "github.com/golang/protobuf/protoc-gen-go/testdata/extension_extra"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-type UserMessage struct {
-	Name                 *string  `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
-	Rank                 *string  `protobuf:"bytes,2,opt,name=rank" json:"rank,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *UserMessage) Reset()         { *m = UserMessage{} }
-func (m *UserMessage) String() string { return proto.CompactTextString(m) }
-func (*UserMessage) ProtoMessage()    {}
-func (*UserMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_extension_user_af41b5e0bdfb7846, []int{0}
-}
-func (m *UserMessage) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_UserMessage.Unmarshal(m, b)
-}
-func (m *UserMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_UserMessage.Marshal(b, m, deterministic)
-}
-func (dst *UserMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_UserMessage.Merge(dst, src)
-}
-func (m *UserMessage) XXX_Size() int {
-	return xxx_messageInfo_UserMessage.Size(m)
-}
-func (m *UserMessage) XXX_DiscardUnknown() {
-	xxx_messageInfo_UserMessage.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_UserMessage proto.InternalMessageInfo
-
-func (m *UserMessage) GetName() string {
-	if m != nil && m.Name != nil {
-		return *m.Name
-	}
-	return ""
-}
-
-func (m *UserMessage) GetRank() string {
-	if m != nil && m.Rank != nil {
-		return *m.Rank
-	}
-	return ""
-}
-
-// Extend inside the scope of another type
-type LoudMessage struct {
-	XXX_NoUnkeyedLiteral         struct{} `json:"-"`
-	proto.XXX_InternalExtensions `json:"-"`
-	XXX_unrecognized             []byte `json:"-"`
-	XXX_sizecache                int32  `json:"-"`
-}
-
-func (m *LoudMessage) Reset()         { *m = LoudMessage{} }
-func (m *LoudMessage) String() string { return proto.CompactTextString(m) }
-func (*LoudMessage) ProtoMessage()    {}
-func (*LoudMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_extension_user_af41b5e0bdfb7846, []int{1}
-}
-
-var extRange_LoudMessage = []proto.ExtensionRange{
-	{Start: 100, End: 536870911},
-}
-
-func (*LoudMessage) ExtensionRangeArray() []proto.ExtensionRange {
-	return extRange_LoudMessage
-}
-func (m *LoudMessage) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_LoudMessage.Unmarshal(m, b)
-}
-func (m *LoudMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_LoudMessage.Marshal(b, m, deterministic)
-}
-func (dst *LoudMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_LoudMessage.Merge(dst, src)
-}
-func (m *LoudMessage) XXX_Size() int {
-	return xxx_messageInfo_LoudMessage.Size(m)
-}
-func (m *LoudMessage) XXX_DiscardUnknown() {
-	xxx_messageInfo_LoudMessage.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_LoudMessage proto.InternalMessageInfo
-
-var E_LoudMessage_Volume = &proto.ExtensionDesc{
-	ExtendedType:  (*extension_base.BaseMessage)(nil),
-	ExtensionType: (*uint32)(nil),
-	Field:         8,
-	Name:          "extension_user.LoudMessage.volume",
-	Tag:           "varint,8,opt,name=volume",
-	Filename:      "extension_user/extension_user.proto",
-}
-
-// Extend inside the scope of another type, using a message.
-type LoginMessage struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *LoginMessage) Reset()         { *m = LoginMessage{} }
-func (m *LoginMessage) String() string { return proto.CompactTextString(m) }
-func (*LoginMessage) ProtoMessage()    {}
-func (*LoginMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_extension_user_af41b5e0bdfb7846, []int{2}
-}
-func (m *LoginMessage) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_LoginMessage.Unmarshal(m, b)
-}
-func (m *LoginMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_LoginMessage.Marshal(b, m, deterministic)
-}
-func (dst *LoginMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_LoginMessage.Merge(dst, src)
-}
-func (m *LoginMessage) XXX_Size() int {
-	return xxx_messageInfo_LoginMessage.Size(m)
-}
-func (m *LoginMessage) XXX_DiscardUnknown() {
-	xxx_messageInfo_LoginMessage.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_LoginMessage proto.InternalMessageInfo
-
-var E_LoginMessage_UserMessage = &proto.ExtensionDesc{
-	ExtendedType:  (*extension_base.BaseMessage)(nil),
-	ExtensionType: (*UserMessage)(nil),
-	Field:         16,
-	Name:          "extension_user.LoginMessage.user_message",
-	Tag:           "bytes,16,opt,name=user_message,json=userMessage",
-	Filename:      "extension_user/extension_user.proto",
-}
-
-type Detail struct {
-	Color                *string  `protobuf:"bytes,1,opt,name=color" json:"color,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *Detail) Reset()         { *m = Detail{} }
-func (m *Detail) String() string { return proto.CompactTextString(m) }
-func (*Detail) ProtoMessage()    {}
-func (*Detail) Descriptor() ([]byte, []int) {
-	return fileDescriptor_extension_user_af41b5e0bdfb7846, []int{3}
-}
-func (m *Detail) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Detail.Unmarshal(m, b)
-}
-func (m *Detail) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Detail.Marshal(b, m, deterministic)
-}
-func (dst *Detail) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Detail.Merge(dst, src)
-}
-func (m *Detail) XXX_Size() int {
-	return xxx_messageInfo_Detail.Size(m)
-}
-func (m *Detail) XXX_DiscardUnknown() {
-	xxx_messageInfo_Detail.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Detail proto.InternalMessageInfo
-
-func (m *Detail) GetColor() string {
-	if m != nil && m.Color != nil {
-		return *m.Color
-	}
-	return ""
-}
-
-// An extension of an extension
-type Announcement struct {
-	Words                *string  `protobuf:"bytes,1,opt,name=words" json:"words,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *Announcement) Reset()         { *m = Announcement{} }
-func (m *Announcement) String() string { return proto.CompactTextString(m) }
-func (*Announcement) ProtoMessage()    {}
-func (*Announcement) Descriptor() ([]byte, []int) {
-	return fileDescriptor_extension_user_af41b5e0bdfb7846, []int{4}
-}
-func (m *Announcement) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Announcement.Unmarshal(m, b)
-}
-func (m *Announcement) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Announcement.Marshal(b, m, deterministic)
-}
-func (dst *Announcement) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Announcement.Merge(dst, src)
-}
-func (m *Announcement) XXX_Size() int {
-	return xxx_messageInfo_Announcement.Size(m)
-}
-func (m *Announcement) XXX_DiscardUnknown() {
-	xxx_messageInfo_Announcement.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Announcement proto.InternalMessageInfo
-
-func (m *Announcement) GetWords() string {
-	if m != nil && m.Words != nil {
-		return *m.Words
-	}
-	return ""
-}
-
-var E_Announcement_LoudExt = &proto.ExtensionDesc{
-	ExtendedType:  (*LoudMessage)(nil),
-	ExtensionType: (*Announcement)(nil),
-	Field:         100,
-	Name:          "extension_user.Announcement.loud_ext",
-	Tag:           "bytes,100,opt,name=loud_ext,json=loudExt",
-	Filename:      "extension_user/extension_user.proto",
-}
-
-// Something that can be put in a message set.
-type OldStyleParcel struct {
-	Name                 *string  `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
-	Height               *int32   `protobuf:"varint,2,opt,name=height" json:"height,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *OldStyleParcel) Reset()         { *m = OldStyleParcel{} }
-func (m *OldStyleParcel) String() string { return proto.CompactTextString(m) }
-func (*OldStyleParcel) ProtoMessage()    {}
-func (*OldStyleParcel) Descriptor() ([]byte, []int) {
-	return fileDescriptor_extension_user_af41b5e0bdfb7846, []int{5}
-}
-func (m *OldStyleParcel) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_OldStyleParcel.Unmarshal(m, b)
-}
-func (m *OldStyleParcel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_OldStyleParcel.Marshal(b, m, deterministic)
-}
-func (dst *OldStyleParcel) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_OldStyleParcel.Merge(dst, src)
-}
-func (m *OldStyleParcel) XXX_Size() int {
-	return xxx_messageInfo_OldStyleParcel.Size(m)
-}
-func (m *OldStyleParcel) XXX_DiscardUnknown() {
-	xxx_messageInfo_OldStyleParcel.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_OldStyleParcel proto.InternalMessageInfo
-
-func (m *OldStyleParcel) GetName() string {
-	if m != nil && m.Name != nil {
-		return *m.Name
-	}
-	return ""
-}
-
-func (m *OldStyleParcel) GetHeight() int32 {
-	if m != nil && m.Height != nil {
-		return *m.Height
-	}
-	return 0
-}
-
-var E_OldStyleParcel_MessageSetExtension = &proto.ExtensionDesc{
-	ExtendedType:  (*extension_base.OldStyleMessage)(nil),
-	ExtensionType: (*OldStyleParcel)(nil),
-	Field:         2001,
-	Name:          "extension_user.OldStyleParcel",
-	Tag:           "bytes,2001,opt,name=message_set_extension,json=messageSetExtension",
-	Filename:      "extension_user/extension_user.proto",
-}
-
-var E_UserMessage = &proto.ExtensionDesc{
-	ExtendedType:  (*extension_base.BaseMessage)(nil),
-	ExtensionType: (*UserMessage)(nil),
-	Field:         5,
-	Name:          "extension_user.user_message",
-	Tag:           "bytes,5,opt,name=user_message,json=userMessage",
-	Filename:      "extension_user/extension_user.proto",
-}
-
-var E_ExtraMessage = &proto.ExtensionDesc{
-	ExtendedType:  (*extension_base.BaseMessage)(nil),
-	ExtensionType: (*extension_extra.ExtraMessage)(nil),
-	Field:         9,
-	Name:          "extension_user.extra_message",
-	Tag:           "bytes,9,opt,name=extra_message,json=extraMessage",
-	Filename:      "extension_user/extension_user.proto",
-}
-
-var E_Width = &proto.ExtensionDesc{
-	ExtendedType:  (*extension_base.BaseMessage)(nil),
-	ExtensionType: (*int32)(nil),
-	Field:         6,
-	Name:          "extension_user.width",
-	Tag:           "varint,6,opt,name=width",
-	Filename:      "extension_user/extension_user.proto",
-}
-
-var E_Area = &proto.ExtensionDesc{
-	ExtendedType:  (*extension_base.BaseMessage)(nil),
-	ExtensionType: (*int64)(nil),
-	Field:         7,
-	Name:          "extension_user.area",
-	Tag:           "varint,7,opt,name=area",
-	Filename:      "extension_user/extension_user.proto",
-}
-
-var E_Detail = &proto.ExtensionDesc{
-	ExtendedType:  (*extension_base.BaseMessage)(nil),
-	ExtensionType: ([]*Detail)(nil),
-	Field:         17,
-	Name:          "extension_user.detail",
-	Tag:           "bytes,17,rep,name=detail",
-	Filename:      "extension_user/extension_user.proto",
-}
-
-func init() {
-	proto.RegisterType((*UserMessage)(nil), "extension_user.UserMessage")
-	proto.RegisterType((*LoudMessage)(nil), "extension_user.LoudMessage")
-	proto.RegisterType((*LoginMessage)(nil), "extension_user.LoginMessage")
-	proto.RegisterType((*Detail)(nil), "extension_user.Detail")
-	proto.RegisterType((*Announcement)(nil), "extension_user.Announcement")
-	proto.RegisterMessageSetType((*OldStyleParcel)(nil), 2001, "extension_user.OldStyleParcel")
-	proto.RegisterType((*OldStyleParcel)(nil), "extension_user.OldStyleParcel")
-	proto.RegisterExtension(E_LoudMessage_Volume)
-	proto.RegisterExtension(E_LoginMessage_UserMessage)
-	proto.RegisterExtension(E_Announcement_LoudExt)
-	proto.RegisterExtension(E_OldStyleParcel_MessageSetExtension)
-	proto.RegisterExtension(E_UserMessage)
-	proto.RegisterExtension(E_ExtraMessage)
-	proto.RegisterExtension(E_Width)
-	proto.RegisterExtension(E_Area)
-	proto.RegisterExtension(E_Detail)
-}
-
-func init() {
-	proto.RegisterFile("extension_user/extension_user.proto", fileDescriptor_extension_user_af41b5e0bdfb7846)
-}
-
-var fileDescriptor_extension_user_af41b5e0bdfb7846 = []byte{
-	// 492 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0x51, 0x6f, 0x94, 0x40,
-	0x10, 0x0e, 0x6d, 0x8f, 0x5e, 0x87, 0x6b, 0xad, 0xa8, 0xcd, 0xa5, 0x6a, 0x25, 0x18, 0x13, 0x62,
-	0xd2, 0x23, 0x62, 0x7c, 0xe1, 0x49, 0x2f, 0xde, 0x93, 0x67, 0x34, 0x54, 0x5f, 0xf4, 0x81, 0xec,
-	0xc1, 0xc8, 0x91, 0xc2, 0xae, 0xd9, 0x5d, 0xec, 0xe9, 0xd3, 0xfd, 0x26, 0xff, 0x89, 0xff, 0xc8,
-	0xb0, 0x2c, 0x2d, 0x87, 0xc9, 0xc5, 0xbe, 0x90, 0xfd, 0x86, 0x6f, 0xbe, 0x99, 0xfd, 0x66, 0x00,
-	0x9e, 0xe2, 0x4a, 0x22, 0x15, 0x39, 0xa3, 0x71, 0x25, 0x90, 0xfb, 0x9b, 0x70, 0xf2, 0x9d, 0x33,
-	0xc9, 0xec, 0xa3, 0xcd, 0xe8, 0x69, 0x27, 0x69, 0x41, 0x04, 0xfa, 0x9b, 0xb0, 0x49, 0x3a, 0x7d,
-	0x76, 0x13, 0xc5, 0x95, 0xe4, 0xc4, 0xef, 0xe1, 0x86, 0xe6, 0xbe, 0x02, 0xeb, 0xb3, 0x40, 0xfe,
-	0x1e, 0x85, 0x20, 0x19, 0xda, 0x36, 0xec, 0x51, 0x52, 0xe2, 0xd8, 0x70, 0x0c, 0xef, 0x20, 0x52,
-	0xe7, 0x3a, 0xc6, 0x09, 0xbd, 0x1c, 0xef, 0x34, 0xb1, 0xfa, 0xec, 0xce, 0xc1, 0x9a, 0xb3, 0x2a,
-	0xd5, 0x69, 0xcf, 0x87, 0xc3, 0xf4, 0x78, 0xbd, 0x5e, 0xaf, 0x77, 0x82, 0x97, 0x60, 0xfe, 0x60,
-	0x45, 0x55, 0xa2, 0xfd, 0x70, 0xd2, 0xeb, 0x6b, 0x4a, 0x04, 0xea, 0x84, 0xf1, 0xd0, 0x31, 0xbc,
-	0xc3, 0x48, 0x53, 0xdd, 0x4b, 0x18, 0xcd, 0x59, 0x96, 0x53, 0xfd, 0x36, 0xf8, 0x0a, 0xa3, 0xfa,
-	0xa2, 0x71, 0xa9, 0xbb, 0xda, 0x2a, 0x75, 0xec, 0x18, 0x9e, 0x15, 0x74, 0x29, 0xca, 0xba, 0xce,
-	0xad, 0x22, 0xab, 0xba, 0x01, 0xee, 0x19, 0x98, 0x6f, 0x51, 0x92, 0xbc, 0xb0, 0xef, 0xc3, 0x20,
-	0x61, 0x05, 0xe3, 0xfa, 0xb6, 0x0d, 0x70, 0x7f, 0xc1, 0xe8, 0x0d, 0xa5, 0xac, 0xa2, 0x09, 0x96,
-	0x48, 0x65, 0xcd, 0xba, 0x62, 0x3c, 0x15, 0x2d, 0x4b, 0x81, 0xe0, 0x13, 0x0c, 0x0b, 0x56, 0xa5,
-	0xb5, 0x97, 0xf6, 0x3f, 0xb5, 0x3b, 0xd6, 0x8c, 0x53, 0xd5, 0xde, 0xa3, 0x3e, 0xa5, 0x5b, 0x22,
-	0xda, 0xaf, 0xa5, 0x66, 0x2b, 0xe9, 0xfe, 0x36, 0xe0, 0xe8, 0x43, 0x91, 0x5e, 0xc8, 0x9f, 0x05,
-	0x7e, 0x24, 0x3c, 0xc1, 0xa2, 0x33, 0x91, 0x9d, 0xeb, 0x89, 0x9c, 0x80, 0xb9, 0xc4, 0x3c, 0x5b,
-	0x4a, 0x35, 0x93, 0x41, 0xa4, 0x51, 0x20, 0xe1, 0x81, 0xb6, 0x2c, 0x16, 0x28, 0xe3, 0xeb, 0x92,
-	0xf6, 0x93, 0xbe, 0x81, 0x6d, 0x91, 0xb6, 0xcb, 0x3f, 0x77, 0x54, 0x9b, 0x67, 0xfd, 0x36, 0x37,
-	0x9b, 0x89, 0xee, 0x69, 0xf9, 0x0b, 0x94, 0xb3, 0x96, 0x18, 0xde, 0x6a, 0x5a, 0x83, 0xdb, 0x4d,
-	0x2b, 0x8c, 0xe1, 0x50, 0xad, 0xeb, 0xff, 0xa9, 0x1f, 0x28, 0xf5, 0xc7, 0x93, 0xfe, 0xae, 0xcf,
-	0xea, 0x67, 0xab, 0x3f, 0xc2, 0x0e, 0x0a, 0x5f, 0xc0, 0xe0, 0x2a, 0x4f, 0xe5, 0x72, 0xbb, 0xb0,
-	0xa9, 0x7c, 0x6e, 0x98, 0xa1, 0x0f, 0x7b, 0x84, 0x23, 0xd9, 0x9e, 0xb1, 0xef, 0x18, 0xde, 0x6e,
-	0xa4, 0x88, 0xe1, 0x3b, 0x30, 0xd3, 0x66, 0xe5, 0xb6, 0xa6, 0xdc, 0x75, 0x76, 0x3d, 0x2b, 0x38,
-	0xe9, 0x7b, 0xd3, 0x6c, 0x6b, 0xa4, 0x25, 0xa6, 0xd3, 0x2f, 0xaf, 0xb3, 0x5c, 0x2e, 0xab, 0xc5,
-	0x24, 0x61, 0xa5, 0x9f, 0xb1, 0x82, 0xd0, 0xcc, 0x57, 0x1f, 0xf3, 0xa2, 0xfa, 0xd6, 0x1c, 0x92,
-	0xf3, 0x0c, 0xe9, 0x79, 0xc6, 0x7c, 0x89, 0x42, 0xa6, 0x44, 0x92, 0xde, 0x7f, 0xe5, 0x6f, 0x00,
-	0x00, 0x00, 0xff, 0xff, 0xdf, 0x18, 0x64, 0x15, 0x77, 0x04, 0x00, 0x00,
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/extension_user/extension_user.proto b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/extension_user/extension_user.proto
deleted file mode 100644
index 033c186c0..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/extension_user/extension_user.proto
+++ /dev/null
@@ -1,102 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto2";
-
-import "extension_base/extension_base.proto";
-import "extension_extra/extension_extra.proto";
-
-package extension_user;
-
-option go_package = "github.com/golang/protobuf/protoc-gen-go/testdata/extension_user";
-
-message UserMessage {
-  optional string name = 1;
-  optional string rank = 2;
-}
-
-// Extend with a message
-extend extension_base.BaseMessage {
-  optional UserMessage user_message = 5;
-}
-
-// Extend with a foreign message
-extend extension_base.BaseMessage {
-  optional extension_extra.ExtraMessage extra_message = 9;
-}
-
-// Extend with some primitive types
-extend extension_base.BaseMessage {
-  optional int32 width = 6;
-  optional int64 area = 7;
-}
-
-// Extend inside the scope of another type
-message LoudMessage {
-  extend extension_base.BaseMessage {
-    optional uint32 volume = 8;
-  }
-  extensions 100 to max;
-}
-
-// Extend inside the scope of another type, using a message.
-message LoginMessage {
-  extend extension_base.BaseMessage {
-    optional UserMessage user_message = 16;
-  }
-}
-
-// Extend with a repeated field
-extend extension_base.BaseMessage {
-  repeated Detail detail = 17;
-}
-
-message Detail {
-  optional string color = 1;
-}
-
-// An extension of an extension
-message Announcement {
-  optional string words = 1;
-  extend LoudMessage {
-    optional Announcement loud_ext = 100;
-  }
-}
-
-// Something that can be put in a message set.
-message OldStyleParcel {
-  extend extension_base.OldStyleMessage {
-    optional OldStyleParcel message_set_extension = 2001;
-  }
-
-  required string name = 1;
-  optional int32 height = 2;
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/grpc/grpc.pb.go b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/grpc/grpc.pb.go
deleted file mode 100644
index 1bc0283f3..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/grpc/grpc.pb.go
+++ /dev/null
@@ -1,444 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: grpc/grpc.proto
-
-package testing // import "github.com/golang/protobuf/protoc-gen-go/testdata/grpc"
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-import (
-	context "golang.org/x/net/context"
-	grpc "google.golang.org/grpc"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-type SimpleRequest struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *SimpleRequest) Reset()         { *m = SimpleRequest{} }
-func (m *SimpleRequest) String() string { return proto.CompactTextString(m) }
-func (*SimpleRequest) ProtoMessage()    {}
-func (*SimpleRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_grpc_65bf3902e49ee873, []int{0}
-}
-func (m *SimpleRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_SimpleRequest.Unmarshal(m, b)
-}
-func (m *SimpleRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_SimpleRequest.Marshal(b, m, deterministic)
-}
-func (dst *SimpleRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_SimpleRequest.Merge(dst, src)
-}
-func (m *SimpleRequest) XXX_Size() int {
-	return xxx_messageInfo_SimpleRequest.Size(m)
-}
-func (m *SimpleRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_SimpleRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_SimpleRequest proto.InternalMessageInfo
-
-type SimpleResponse struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *SimpleResponse) Reset()         { *m = SimpleResponse{} }
-func (m *SimpleResponse) String() string { return proto.CompactTextString(m) }
-func (*SimpleResponse) ProtoMessage()    {}
-func (*SimpleResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_grpc_65bf3902e49ee873, []int{1}
-}
-func (m *SimpleResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_SimpleResponse.Unmarshal(m, b)
-}
-func (m *SimpleResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_SimpleResponse.Marshal(b, m, deterministic)
-}
-func (dst *SimpleResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_SimpleResponse.Merge(dst, src)
-}
-func (m *SimpleResponse) XXX_Size() int {
-	return xxx_messageInfo_SimpleResponse.Size(m)
-}
-func (m *SimpleResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_SimpleResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_SimpleResponse proto.InternalMessageInfo
-
-type StreamMsg struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *StreamMsg) Reset()         { *m = StreamMsg{} }
-func (m *StreamMsg) String() string { return proto.CompactTextString(m) }
-func (*StreamMsg) ProtoMessage()    {}
-func (*StreamMsg) Descriptor() ([]byte, []int) {
-	return fileDescriptor_grpc_65bf3902e49ee873, []int{2}
-}
-func (m *StreamMsg) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_StreamMsg.Unmarshal(m, b)
-}
-func (m *StreamMsg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_StreamMsg.Marshal(b, m, deterministic)
-}
-func (dst *StreamMsg) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_StreamMsg.Merge(dst, src)
-}
-func (m *StreamMsg) XXX_Size() int {
-	return xxx_messageInfo_StreamMsg.Size(m)
-}
-func (m *StreamMsg) XXX_DiscardUnknown() {
-	xxx_messageInfo_StreamMsg.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_StreamMsg proto.InternalMessageInfo
-
-type StreamMsg2 struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *StreamMsg2) Reset()         { *m = StreamMsg2{} }
-func (m *StreamMsg2) String() string { return proto.CompactTextString(m) }
-func (*StreamMsg2) ProtoMessage()    {}
-func (*StreamMsg2) Descriptor() ([]byte, []int) {
-	return fileDescriptor_grpc_65bf3902e49ee873, []int{3}
-}
-func (m *StreamMsg2) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_StreamMsg2.Unmarshal(m, b)
-}
-func (m *StreamMsg2) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_StreamMsg2.Marshal(b, m, deterministic)
-}
-func (dst *StreamMsg2) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_StreamMsg2.Merge(dst, src)
-}
-func (m *StreamMsg2) XXX_Size() int {
-	return xxx_messageInfo_StreamMsg2.Size(m)
-}
-func (m *StreamMsg2) XXX_DiscardUnknown() {
-	xxx_messageInfo_StreamMsg2.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_StreamMsg2 proto.InternalMessageInfo
-
-func init() {
-	proto.RegisterType((*SimpleRequest)(nil), "grpc.testing.SimpleRequest")
-	proto.RegisterType((*SimpleResponse)(nil), "grpc.testing.SimpleResponse")
-	proto.RegisterType((*StreamMsg)(nil), "grpc.testing.StreamMsg")
-	proto.RegisterType((*StreamMsg2)(nil), "grpc.testing.StreamMsg2")
-}
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ context.Context
-var _ grpc.ClientConn
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the grpc package it is being compiled against.
-const _ = grpc.SupportPackageIsVersion4
-
-// TestClient is the client API for Test service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
-type TestClient interface {
-	UnaryCall(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (*SimpleResponse, error)
-	// This RPC streams from the server only.
-	Downstream(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (Test_DownstreamClient, error)
-	// This RPC streams from the client.
-	Upstream(ctx context.Context, opts ...grpc.CallOption) (Test_UpstreamClient, error)
-	// This one streams in both directions.
-	Bidi(ctx context.Context, opts ...grpc.CallOption) (Test_BidiClient, error)
-}
-
-type testClient struct {
-	cc *grpc.ClientConn
-}
-
-func NewTestClient(cc *grpc.ClientConn) TestClient {
-	return &testClient{cc}
-}
-
-func (c *testClient) UnaryCall(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (*SimpleResponse, error) {
-	out := new(SimpleResponse)
-	err := c.cc.Invoke(ctx, "/grpc.testing.Test/UnaryCall", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *testClient) Downstream(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (Test_DownstreamClient, error) {
-	stream, err := c.cc.NewStream(ctx, &_Test_serviceDesc.Streams[0], "/grpc.testing.Test/Downstream", opts...)
-	if err != nil {
-		return nil, err
-	}
-	x := &testDownstreamClient{stream}
-	if err := x.ClientStream.SendMsg(in); err != nil {
-		return nil, err
-	}
-	if err := x.ClientStream.CloseSend(); err != nil {
-		return nil, err
-	}
-	return x, nil
-}
-
-type Test_DownstreamClient interface {
-	Recv() (*StreamMsg, error)
-	grpc.ClientStream
-}
-
-type testDownstreamClient struct {
-	grpc.ClientStream
-}
-
-func (x *testDownstreamClient) Recv() (*StreamMsg, error) {
-	m := new(StreamMsg)
-	if err := x.ClientStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-func (c *testClient) Upstream(ctx context.Context, opts ...grpc.CallOption) (Test_UpstreamClient, error) {
-	stream, err := c.cc.NewStream(ctx, &_Test_serviceDesc.Streams[1], "/grpc.testing.Test/Upstream", opts...)
-	if err != nil {
-		return nil, err
-	}
-	x := &testUpstreamClient{stream}
-	return x, nil
-}
-
-type Test_UpstreamClient interface {
-	Send(*StreamMsg) error
-	CloseAndRecv() (*SimpleResponse, error)
-	grpc.ClientStream
-}
-
-type testUpstreamClient struct {
-	grpc.ClientStream
-}
-
-func (x *testUpstreamClient) Send(m *StreamMsg) error {
-	return x.ClientStream.SendMsg(m)
-}
-
-func (x *testUpstreamClient) CloseAndRecv() (*SimpleResponse, error) {
-	if err := x.ClientStream.CloseSend(); err != nil {
-		return nil, err
-	}
-	m := new(SimpleResponse)
-	if err := x.ClientStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-func (c *testClient) Bidi(ctx context.Context, opts ...grpc.CallOption) (Test_BidiClient, error) {
-	stream, err := c.cc.NewStream(ctx, &_Test_serviceDesc.Streams[2], "/grpc.testing.Test/Bidi", opts...)
-	if err != nil {
-		return nil, err
-	}
-	x := &testBidiClient{stream}
-	return x, nil
-}
-
-type Test_BidiClient interface {
-	Send(*StreamMsg) error
-	Recv() (*StreamMsg2, error)
-	grpc.ClientStream
-}
-
-type testBidiClient struct {
-	grpc.ClientStream
-}
-
-func (x *testBidiClient) Send(m *StreamMsg) error {
-	return x.ClientStream.SendMsg(m)
-}
-
-func (x *testBidiClient) Recv() (*StreamMsg2, error) {
-	m := new(StreamMsg2)
-	if err := x.ClientStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-// TestServer is the server API for Test service.
-type TestServer interface {
-	UnaryCall(context.Context, *SimpleRequest) (*SimpleResponse, error)
-	// This RPC streams from the server only.
-	Downstream(*SimpleRequest, Test_DownstreamServer) error
-	// This RPC streams from the client.
-	Upstream(Test_UpstreamServer) error
-	// This one streams in both directions.
-	Bidi(Test_BidiServer) error
-}
-
-func RegisterTestServer(s *grpc.Server, srv TestServer) {
-	s.RegisterService(&_Test_serviceDesc, srv)
-}
-
-func _Test_UnaryCall_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(SimpleRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(TestServer).UnaryCall(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/grpc.testing.Test/UnaryCall",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(TestServer).UnaryCall(ctx, req.(*SimpleRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Test_Downstream_Handler(srv interface{}, stream grpc.ServerStream) error {
-	m := new(SimpleRequest)
-	if err := stream.RecvMsg(m); err != nil {
-		return err
-	}
-	return srv.(TestServer).Downstream(m, &testDownstreamServer{stream})
-}
-
-type Test_DownstreamServer interface {
-	Send(*StreamMsg) error
-	grpc.ServerStream
-}
-
-type testDownstreamServer struct {
-	grpc.ServerStream
-}
-
-func (x *testDownstreamServer) Send(m *StreamMsg) error {
-	return x.ServerStream.SendMsg(m)
-}
-
-func _Test_Upstream_Handler(srv interface{}, stream grpc.ServerStream) error {
-	return srv.(TestServer).Upstream(&testUpstreamServer{stream})
-}
-
-type Test_UpstreamServer interface {
-	SendAndClose(*SimpleResponse) error
-	Recv() (*StreamMsg, error)
-	grpc.ServerStream
-}
-
-type testUpstreamServer struct {
-	grpc.ServerStream
-}
-
-func (x *testUpstreamServer) SendAndClose(m *SimpleResponse) error {
-	return x.ServerStream.SendMsg(m)
-}
-
-func (x *testUpstreamServer) Recv() (*StreamMsg, error) {
-	m := new(StreamMsg)
-	if err := x.ServerStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-func _Test_Bidi_Handler(srv interface{}, stream grpc.ServerStream) error {
-	return srv.(TestServer).Bidi(&testBidiServer{stream})
-}
-
-type Test_BidiServer interface {
-	Send(*StreamMsg2) error
-	Recv() (*StreamMsg, error)
-	grpc.ServerStream
-}
-
-type testBidiServer struct {
-	grpc.ServerStream
-}
-
-func (x *testBidiServer) Send(m *StreamMsg2) error {
-	return x.ServerStream.SendMsg(m)
-}
-
-func (x *testBidiServer) Recv() (*StreamMsg, error) {
-	m := new(StreamMsg)
-	if err := x.ServerStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-var _Test_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "grpc.testing.Test",
-	HandlerType: (*TestServer)(nil),
-	Methods: []grpc.MethodDesc{
-		{
-			MethodName: "UnaryCall",
-			Handler:    _Test_UnaryCall_Handler,
-		},
-	},
-	Streams: []grpc.StreamDesc{
-		{
-			StreamName:    "Downstream",
-			Handler:       _Test_Downstream_Handler,
-			ServerStreams: true,
-		},
-		{
-			StreamName:    "Upstream",
-			Handler:       _Test_Upstream_Handler,
-			ClientStreams: true,
-		},
-		{
-			StreamName:    "Bidi",
-			Handler:       _Test_Bidi_Handler,
-			ServerStreams: true,
-			ClientStreams: true,
-		},
-	},
-	Metadata: "grpc/grpc.proto",
-}
-
-func init() { proto.RegisterFile("grpc/grpc.proto", fileDescriptor_grpc_65bf3902e49ee873) }
-
-var fileDescriptor_grpc_65bf3902e49ee873 = []byte{
-	// 244 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x4f, 0x2f, 0x2a, 0x48,
-	0xd6, 0x07, 0x11, 0x7a, 0x05, 0x45, 0xf9, 0x25, 0xf9, 0x42, 0x3c, 0x60, 0x76, 0x49, 0x6a, 0x71,
-	0x49, 0x66, 0x5e, 0xba, 0x12, 0x3f, 0x17, 0x6f, 0x70, 0x66, 0x6e, 0x41, 0x4e, 0x6a, 0x50, 0x6a,
-	0x61, 0x69, 0x6a, 0x71, 0x89, 0x92, 0x00, 0x17, 0x1f, 0x4c, 0xa0, 0xb8, 0x20, 0x3f, 0xaf, 0x38,
-	0x55, 0x89, 0x9b, 0x8b, 0x33, 0xb8, 0xa4, 0x28, 0x35, 0x31, 0xd7, 0xb7, 0x38, 0x5d, 0x89, 0x87,
-	0x8b, 0x0b, 0xce, 0x31, 0x32, 0x9a, 0xc1, 0xc4, 0xc5, 0x12, 0x92, 0x5a, 0x5c, 0x22, 0xe4, 0xc6,
-	0xc5, 0x19, 0x9a, 0x97, 0x58, 0x54, 0xe9, 0x9c, 0x98, 0x93, 0x23, 0x24, 0xad, 0x87, 0x6c, 0x85,
-	0x1e, 0x8a, 0xf9, 0x52, 0x32, 0xd8, 0x25, 0x21, 0x76, 0x09, 0xb9, 0x70, 0x71, 0xb9, 0xe4, 0x97,
-	0xe7, 0x15, 0x83, 0xad, 0xc0, 0x6f, 0x90, 0x38, 0x9a, 0x24, 0xcc, 0x55, 0x06, 0x8c, 0x42, 0xce,
-	0x5c, 0x1c, 0xa1, 0x05, 0x50, 0x33, 0x70, 0x29, 0xc3, 0xef, 0x10, 0x0d, 0x46, 0x21, 0x5b, 0x2e,
-	0x16, 0xa7, 0xcc, 0x94, 0x4c, 0xdc, 0x06, 0x48, 0xe0, 0x90, 0x30, 0xd2, 0x60, 0x34, 0x60, 0x74,
-	0x72, 0x88, 0xb2, 0x4b, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xcf,
-	0xcf, 0x49, 0xcc, 0x4b, 0xd7, 0x07, 0xc7, 0x40, 0x52, 0x69, 0x1a, 0x84, 0x91, 0xac, 0x9b, 0x9e,
-	0x9a, 0xa7, 0x9b, 0x9e, 0xaf, 0x0f, 0x32, 0x22, 0x25, 0xb1, 0x24, 0x11, 0x1c, 0x4d, 0xd6, 0x50,
-	0x03, 0x93, 0xd8, 0xc0, 0x8a, 0x8c, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0x90, 0xb9, 0x95, 0x42,
-	0xc2, 0x01, 0x00, 0x00,
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/grpc/grpc.proto b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/grpc/grpc.proto
deleted file mode 100644
index 0e5c64a91..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/grpc/grpc.proto
+++ /dev/null
@@ -1,61 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2015 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto3";
-
-package grpc.testing;
-
-option go_package = "github.com/golang/protobuf/protoc-gen-go/testdata/grpc;testing";
-
-message SimpleRequest {
-}
-
-message SimpleResponse {
-}
-
-message StreamMsg {
-}
-
-message StreamMsg2 {
-}
-
-service Test {
-  rpc UnaryCall(SimpleRequest) returns (SimpleResponse);
-
-  // This RPC streams from the server only.
-  rpc Downstream(SimpleRequest) returns (stream StreamMsg);
-
-  // This RPC streams from the client.
-  rpc Upstream(stream StreamMsg) returns (SimpleResponse);
-
-  // This one streams in both directions.
-  rpc Bidi(stream StreamMsg) returns (stream StreamMsg2);
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/import_public/a.pb.go b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/import_public/a.pb.go
deleted file mode 100644
index 5b780fd5c..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/import_public/a.pb.go
+++ /dev/null
@@ -1,110 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: import_public/a.proto
-
-package import_public // import "github.com/golang/protobuf/protoc-gen-go/testdata/import_public"
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-import sub "github.com/golang/protobuf/protoc-gen-go/testdata/import_public/sub"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-// M from public import import_public/sub/a.proto
-type M = sub.M
-
-// E from public import import_public/sub/a.proto
-type E = sub.E
-
-var E_name = sub.E_name
-var E_value = sub.E_value
-
-const E_ZERO = E(sub.E_ZERO)
-
-// Ignoring public import of Local from import_public/b.proto
-
-type Public struct {
-	M                    *sub.M   `protobuf:"bytes,1,opt,name=m" json:"m,omitempty"`
-	E                    sub.E    `protobuf:"varint,2,opt,name=e,enum=goproto.test.import_public.sub.E" json:"e,omitempty"`
-	Local                *Local   `protobuf:"bytes,3,opt,name=local" json:"local,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *Public) Reset()         { *m = Public{} }
-func (m *Public) String() string { return proto.CompactTextString(m) }
-func (*Public) ProtoMessage()    {}
-func (*Public) Descriptor() ([]byte, []int) {
-	return fileDescriptor_a_c0314c022b7c17d8, []int{0}
-}
-func (m *Public) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Public.Unmarshal(m, b)
-}
-func (m *Public) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Public.Marshal(b, m, deterministic)
-}
-func (dst *Public) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Public.Merge(dst, src)
-}
-func (m *Public) XXX_Size() int {
-	return xxx_messageInfo_Public.Size(m)
-}
-func (m *Public) XXX_DiscardUnknown() {
-	xxx_messageInfo_Public.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Public proto.InternalMessageInfo
-
-func (m *Public) GetM() *sub.M {
-	if m != nil {
-		return m.M
-	}
-	return nil
-}
-
-func (m *Public) GetE() sub.E {
-	if m != nil {
-		return m.E
-	}
-	return sub.E_ZERO
-}
-
-func (m *Public) GetLocal() *Local {
-	if m != nil {
-		return m.Local
-	}
-	return nil
-}
-
-func init() {
-	proto.RegisterType((*Public)(nil), "goproto.test.import_public.Public")
-}
-
-func init() { proto.RegisterFile("import_public/a.proto", fileDescriptor_a_c0314c022b7c17d8) }
-
-var fileDescriptor_a_c0314c022b7c17d8 = []byte{
-	// 200 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0xcd, 0xcc, 0x2d, 0xc8,
-	0x2f, 0x2a, 0x89, 0x2f, 0x28, 0x4d, 0xca, 0xc9, 0x4c, 0xd6, 0x4f, 0xd4, 0x2b, 0x28, 0xca, 0x2f,
-	0xc9, 0x17, 0x92, 0x4a, 0xcf, 0x07, 0x33, 0xf4, 0x4a, 0x52, 0x8b, 0x4b, 0xf4, 0x50, 0xd4, 0x48,
-	0x49, 0xa2, 0x6a, 0x29, 0x2e, 0x4d, 0x82, 0x69, 0x93, 0x42, 0x33, 0x2d, 0x09, 0x22, 0xac, 0xb4,
-	0x98, 0x91, 0x8b, 0x2d, 0x00, 0x2c, 0x24, 0xa4, 0xcf, 0xc5, 0x98, 0x2b, 0xc1, 0xa8, 0xc0, 0xa8,
-	0xc1, 0x6d, 0xa4, 0xa8, 0x87, 0xdb, 0x12, 0xbd, 0xe2, 0xd2, 0x24, 0x3d, 0xdf, 0x20, 0xc6, 0x5c,
-	0x90, 0x86, 0x54, 0x09, 0x26, 0x05, 0x46, 0x0d, 0x3e, 0xc2, 0x1a, 0x5c, 0x83, 0x18, 0x53, 0x85,
-	0xcc, 0xb9, 0x58, 0x73, 0xf2, 0x93, 0x13, 0x73, 0x24, 0x98, 0x09, 0xdb, 0xe2, 0x03, 0x52, 0x18,
-	0x04, 0x51, 0xef, 0xe4, 0x18, 0x65, 0x9f, 0x9e, 0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97, 0x9c, 0x9f,
-	0xab, 0x9f, 0x9e, 0x9f, 0x93, 0x98, 0x97, 0xae, 0x0f, 0xd6, 0x9a, 0x54, 0x9a, 0x06, 0x61, 0x24,
-	0xeb, 0xa6, 0xa7, 0xe6, 0xe9, 0xa6, 0xe7, 0xeb, 0x83, 0xcc, 0x4a, 0x49, 0x2c, 0x49, 0xd4, 0x47,
-	0x31, 0x2f, 0x80, 0x21, 0x80, 0x31, 0x89, 0x0d, 0xac, 0xd2, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff,
-	0x70, 0xc5, 0xc3, 0x79, 0x5a, 0x01, 0x00, 0x00,
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/import_public/a.proto b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/import_public/a.proto
deleted file mode 100644
index 957ad8971..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/import_public/a.proto
+++ /dev/null
@@ -1,45 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2018 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto3";
-
-package goproto.test.import_public;
-
-option go_package = "github.com/golang/protobuf/protoc-gen-go/testdata/import_public";
-
-import public "import_public/sub/a.proto"; // Different Go package.
-import public "import_public/b.proto";     // Same Go package.
-
-message Public {
-  goproto.test.import_public.sub.M m = 1;
-  goproto.test.import_public.sub.E e = 2;
-  Local local = 3;
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/import_public/b.pb.go b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/import_public/b.pb.go
deleted file mode 100644
index 427aa4f32..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/import_public/b.pb.go
+++ /dev/null
@@ -1,87 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: import_public/b.proto
-
-package import_public // import "github.com/golang/protobuf/protoc-gen-go/testdata/import_public"
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-import sub "github.com/golang/protobuf/protoc-gen-go/testdata/import_public/sub"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-type Local struct {
-	M                    *sub.M   `protobuf:"bytes,1,opt,name=m" json:"m,omitempty"`
-	E                    sub.E    `protobuf:"varint,2,opt,name=e,enum=goproto.test.import_public.sub.E" json:"e,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *Local) Reset()         { *m = Local{} }
-func (m *Local) String() string { return proto.CompactTextString(m) }
-func (*Local) ProtoMessage()    {}
-func (*Local) Descriptor() ([]byte, []int) {
-	return fileDescriptor_b_7f20a805fad67bd0, []int{0}
-}
-func (m *Local) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Local.Unmarshal(m, b)
-}
-func (m *Local) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Local.Marshal(b, m, deterministic)
-}
-func (dst *Local) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Local.Merge(dst, src)
-}
-func (m *Local) XXX_Size() int {
-	return xxx_messageInfo_Local.Size(m)
-}
-func (m *Local) XXX_DiscardUnknown() {
-	xxx_messageInfo_Local.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Local proto.InternalMessageInfo
-
-func (m *Local) GetM() *sub.M {
-	if m != nil {
-		return m.M
-	}
-	return nil
-}
-
-func (m *Local) GetE() sub.E {
-	if m != nil {
-		return m.E
-	}
-	return sub.E_ZERO
-}
-
-func init() {
-	proto.RegisterType((*Local)(nil), "goproto.test.import_public.Local")
-}
-
-func init() { proto.RegisterFile("import_public/b.proto", fileDescriptor_b_7f20a805fad67bd0) }
-
-var fileDescriptor_b_7f20a805fad67bd0 = []byte{
-	// 174 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0xcd, 0xcc, 0x2d, 0xc8,
-	0x2f, 0x2a, 0x89, 0x2f, 0x28, 0x4d, 0xca, 0xc9, 0x4c, 0xd6, 0x4f, 0xd2, 0x2b, 0x28, 0xca, 0x2f,
-	0xc9, 0x17, 0x92, 0x4a, 0xcf, 0x07, 0x33, 0xf4, 0x4a, 0x52, 0x8b, 0x4b, 0xf4, 0x50, 0xd4, 0x48,
-	0x49, 0xa2, 0x6a, 0x29, 0x2e, 0x4d, 0xd2, 0x4f, 0x84, 0x68, 0x53, 0xca, 0xe4, 0x62, 0xf5, 0xc9,
-	0x4f, 0x4e, 0xcc, 0x11, 0xd2, 0xe7, 0x62, 0xcc, 0x95, 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x36, 0x52,
-	0xd4, 0xc3, 0x6d, 0x96, 0x5e, 0x71, 0x69, 0x92, 0x9e, 0x6f, 0x10, 0x63, 0x2e, 0x48, 0x43, 0xaa,
-	0x04, 0x93, 0x02, 0xa3, 0x06, 0x1f, 0x61, 0x0d, 0xae, 0x41, 0x8c, 0xa9, 0x4e, 0x8e, 0x51, 0xf6,
-	0xe9, 0x99, 0x25, 0x19, 0xa5, 0x49, 0x7a, 0xc9, 0xf9, 0xb9, 0xfa, 0xe9, 0xf9, 0x39, 0x89, 0x79,
-	0xe9, 0xfa, 0x60, 0x6d, 0x49, 0xa5, 0x69, 0x10, 0x46, 0xb2, 0x6e, 0x7a, 0x6a, 0x9e, 0x6e, 0x7a,
-	0xbe, 0x3e, 0xc8, 0x9c, 0x94, 0xc4, 0x92, 0x44, 0x7d, 0x14, 0xb3, 0x92, 0xd8, 0xc0, 0xaa, 0x8c,
-	0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0xd6, 0x2b, 0x5f, 0x8e, 0x04, 0x01, 0x00, 0x00,
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/import_public/b.proto b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/import_public/b.proto
deleted file mode 100644
index 1dbca3e49..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/import_public/b.proto
+++ /dev/null
@@ -1,43 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2018 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto3";
-
-package goproto.test.import_public;
-
-option go_package = "github.com/golang/protobuf/protoc-gen-go/testdata/import_public";
-
-import "import_public/sub/a.proto";
-
-message Local {
-  goproto.test.import_public.sub.M m = 1;
-  goproto.test.import_public.sub.E e = 2;
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/import_public/sub/a.pb.go b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/import_public/sub/a.pb.go
deleted file mode 100644
index 4f8f6d243..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/import_public/sub/a.pb.go
+++ /dev/null
@@ -1,100 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: import_public/sub/a.proto
-
-package sub // import "github.com/golang/protobuf/protoc-gen-go/testdata/import_public/sub"
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-type E int32
-
-const (
-	E_ZERO E = 0
-)
-
-var E_name = map[int32]string{
-	0: "ZERO",
-}
-var E_value = map[string]int32{
-	"ZERO": 0,
-}
-
-func (x E) String() string {
-	return proto.EnumName(E_name, int32(x))
-}
-func (E) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_a_91ca0264a534463a, []int{0}
-}
-
-type M struct {
-	// Field using a type in the same Go package, but a different source file.
-	M2                   *M2      `protobuf:"bytes,1,opt,name=m2" json:"m2,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *M) Reset()         { *m = M{} }
-func (m *M) String() string { return proto.CompactTextString(m) }
-func (*M) ProtoMessage()    {}
-func (*M) Descriptor() ([]byte, []int) {
-	return fileDescriptor_a_91ca0264a534463a, []int{0}
-}
-func (m *M) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_M.Unmarshal(m, b)
-}
-func (m *M) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_M.Marshal(b, m, deterministic)
-}
-func (dst *M) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_M.Merge(dst, src)
-}
-func (m *M) XXX_Size() int {
-	return xxx_messageInfo_M.Size(m)
-}
-func (m *M) XXX_DiscardUnknown() {
-	xxx_messageInfo_M.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_M proto.InternalMessageInfo
-
-func (m *M) GetM2() *M2 {
-	if m != nil {
-		return m.M2
-	}
-	return nil
-}
-
-func init() {
-	proto.RegisterType((*M)(nil), "goproto.test.import_public.sub.M")
-	proto.RegisterEnum("goproto.test.import_public.sub.E", E_name, E_value)
-}
-
-func init() { proto.RegisterFile("import_public/sub/a.proto", fileDescriptor_a_91ca0264a534463a) }
-
-var fileDescriptor_a_91ca0264a534463a = []byte{
-	// 172 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0xcc, 0xcc, 0x2d, 0xc8,
-	0x2f, 0x2a, 0x89, 0x2f, 0x28, 0x4d, 0xca, 0xc9, 0x4c, 0xd6, 0x2f, 0x2e, 0x4d, 0xd2, 0x4f, 0xd4,
-	0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x92, 0x4b, 0xcf, 0x07, 0x33, 0xf4, 0x4a, 0x52, 0x8b, 0x4b,
-	0xf4, 0x50, 0xd4, 0xe9, 0x15, 0x97, 0x26, 0x49, 0x61, 0xd1, 0x9a, 0x04, 0xd1, 0xaa, 0x64, 0xce,
-	0xc5, 0xe8, 0x2b, 0x64, 0xc4, 0xc5, 0x94, 0x6b, 0x24, 0xc1, 0xa8, 0xc0, 0xa8, 0xc1, 0x6d, 0xa4,
-	0xa4, 0x87, 0xdf, 0x30, 0x3d, 0x5f, 0xa3, 0x20, 0xa6, 0x5c, 0x23, 0x2d, 0x5e, 0x2e, 0x46, 0x57,
-	0x21, 0x0e, 0x2e, 0x96, 0x28, 0xd7, 0x20, 0x7f, 0x01, 0x06, 0x27, 0xd7, 0x28, 0xe7, 0xf4, 0xcc,
-	0x92, 0x8c, 0xd2, 0x24, 0xbd, 0xe4, 0xfc, 0x5c, 0xfd, 0xf4, 0xfc, 0x9c, 0xc4, 0xbc, 0x74, 0x7d,
-	0xb0, 0x39, 0x49, 0xa5, 0x69, 0x10, 0x46, 0xb2, 0x6e, 0x7a, 0x6a, 0x9e, 0x6e, 0x7a, 0xbe, 0x3e,
-	0xc8, 0xe0, 0x94, 0xc4, 0x92, 0x44, 0x7d, 0x0c, 0x67, 0x25, 0xb1, 0x81, 0x55, 0x1a, 0x03, 0x02,
-	0x00, 0x00, 0xff, 0xff, 0x81, 0xcc, 0x07, 0x7d, 0xed, 0x00, 0x00, 0x00,
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/import_public/sub/a.proto b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/import_public/sub/a.proto
deleted file mode 100644
index 4494c818a..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/import_public/sub/a.proto
+++ /dev/null
@@ -1,47 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2018 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto3";
-
-package goproto.test.import_public.sub;
-
-option go_package = "github.com/golang/protobuf/protoc-gen-go/testdata/import_public/sub";
-
-import "import_public/sub/b.proto";
-
-message M {
-  // Field using a type in the same Go package, but a different source file.
-  M2 m2 = 1;
-}
-
-enum E {
-  ZERO = 0;
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/import_public/sub/b.pb.go b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/import_public/sub/b.pb.go
deleted file mode 100644
index d57a3bb9a..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/import_public/sub/b.pb.go
+++ /dev/null
@@ -1,67 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: import_public/sub/b.proto
-
-package sub // import "github.com/golang/protobuf/protoc-gen-go/testdata/import_public/sub"
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-type M2 struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *M2) Reset()         { *m = M2{} }
-func (m *M2) String() string { return proto.CompactTextString(m) }
-func (*M2) ProtoMessage()    {}
-func (*M2) Descriptor() ([]byte, []int) {
-	return fileDescriptor_b_eba25180453d86b4, []int{0}
-}
-func (m *M2) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_M2.Unmarshal(m, b)
-}
-func (m *M2) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_M2.Marshal(b, m, deterministic)
-}
-func (dst *M2) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_M2.Merge(dst, src)
-}
-func (m *M2) XXX_Size() int {
-	return xxx_messageInfo_M2.Size(m)
-}
-func (m *M2) XXX_DiscardUnknown() {
-	xxx_messageInfo_M2.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_M2 proto.InternalMessageInfo
-
-func init() {
-	proto.RegisterType((*M2)(nil), "goproto.test.import_public.sub.M2")
-}
-
-func init() { proto.RegisterFile("import_public/sub/b.proto", fileDescriptor_b_eba25180453d86b4) }
-
-var fileDescriptor_b_eba25180453d86b4 = []byte{
-	// 127 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0xcc, 0xcc, 0x2d, 0xc8,
-	0x2f, 0x2a, 0x89, 0x2f, 0x28, 0x4d, 0xca, 0xc9, 0x4c, 0xd6, 0x2f, 0x2e, 0x4d, 0xd2, 0x4f, 0xd2,
-	0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x92, 0x4b, 0xcf, 0x07, 0x33, 0xf4, 0x4a, 0x52, 0x8b, 0x4b,
-	0xf4, 0x50, 0xd4, 0xe9, 0x15, 0x97, 0x26, 0x29, 0xb1, 0x70, 0x31, 0xf9, 0x1a, 0x39, 0xb9, 0x46,
-	0x39, 0xa7, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0xa7, 0xe7, 0xe7, 0x24,
-	0xe6, 0xa5, 0xeb, 0x83, 0xf5, 0x25, 0x95, 0xa6, 0x41, 0x18, 0xc9, 0xba, 0xe9, 0xa9, 0x79, 0xba,
-	0xe9, 0xf9, 0xfa, 0x20, 0x83, 0x52, 0x12, 0x4b, 0x12, 0xf5, 0x31, 0x2c, 0x4d, 0x62, 0x03, 0xab,
-	0x34, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x64, 0x42, 0xe4, 0xa8, 0x90, 0x00, 0x00, 0x00,
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/import_public/sub/b.proto b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/import_public/sub/b.proto
deleted file mode 100644
index c7299e0f2..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/import_public/sub/b.proto
+++ /dev/null
@@ -1,39 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2018 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto3";
-
-package goproto.test.import_public.sub;
-
-option go_package = "github.com/golang/protobuf/protoc-gen-go/testdata/import_public/sub";
-
-message M2 {
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/import_public_test.go b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/import_public_test.go
deleted file mode 100644
index 7ef776bf7..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/import_public_test.go
+++ /dev/null
@@ -1,66 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// +build go1.9
-
-package testdata
-
-import (
-	"testing"
-
-	mainpb "github.com/golang/protobuf/protoc-gen-go/testdata/import_public"
-	subpb "github.com/golang/protobuf/protoc-gen-go/testdata/import_public/sub"
-)
-
-func TestImportPublicLink(t *testing.T) {
-	// mainpb.[ME] should be interchangable with subpb.[ME].
-	var _ mainpb.M = subpb.M{}
-	var _ mainpb.E = subpb.E(0)
-	_ = &mainpb.Public{
-		M: &mainpb.M{},
-		E: mainpb.E_ZERO,
-		Local: &mainpb.Local{
-			M: &mainpb.M{},
-			E: mainpb.E_ZERO,
-		},
-	}
-	_ = &mainpb.Public{
-		M: &subpb.M{},
-		E: subpb.E_ZERO,
-		Local: &mainpb.Local{
-			M: &subpb.M{},
-			E: subpb.E_ZERO,
-		},
-	}
-	_ = &mainpb.M{
-		M2: &subpb.M2{},
-	}
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/fmt/m.pb.go b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/fmt/m.pb.go
deleted file mode 100644
index ca312d6cc..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/fmt/m.pb.go
+++ /dev/null
@@ -1,66 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: imports/fmt/m.proto
-
-package fmt // import "github.com/golang/protobuf/protoc-gen-go/testdata/imports/fmt"
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-type M struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *M) Reset()         { *m = M{} }
-func (m *M) String() string { return proto.CompactTextString(m) }
-func (*M) ProtoMessage()    {}
-func (*M) Descriptor() ([]byte, []int) {
-	return fileDescriptor_m_867dd34c461422b8, []int{0}
-}
-func (m *M) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_M.Unmarshal(m, b)
-}
-func (m *M) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_M.Marshal(b, m, deterministic)
-}
-func (dst *M) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_M.Merge(dst, src)
-}
-func (m *M) XXX_Size() int {
-	return xxx_messageInfo_M.Size(m)
-}
-func (m *M) XXX_DiscardUnknown() {
-	xxx_messageInfo_M.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_M proto.InternalMessageInfo
-
-func init() {
-	proto.RegisterType((*M)(nil), "fmt.M")
-}
-
-func init() { proto.RegisterFile("imports/fmt/m.proto", fileDescriptor_m_867dd34c461422b8) }
-
-var fileDescriptor_m_867dd34c461422b8 = []byte{
-	// 109 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0xce, 0xcc, 0x2d, 0xc8,
-	0x2f, 0x2a, 0x29, 0xd6, 0x4f, 0xcb, 0x2d, 0xd1, 0xcf, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17,
-	0x62, 0x4e, 0xcb, 0x2d, 0x51, 0x62, 0xe6, 0x62, 0xf4, 0x75, 0xb2, 0x8f, 0xb2, 0x4d, 0xcf, 0x2c,
-	0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xcf, 0xcf, 0x49, 0xcc, 0x4b, 0xd7, 0x07,
-	0x2b, 0x4a, 0x2a, 0x4d, 0x83, 0x30, 0x92, 0x75, 0xd3, 0x53, 0xf3, 0x74, 0xd3, 0xf3, 0xf5, 0x4b,
-	0x52, 0x8b, 0x4b, 0x52, 0x12, 0x4b, 0x12, 0xf5, 0x91, 0x8c, 0x4c, 0x62, 0x03, 0xab, 0x31, 0x06,
-	0x04, 0x00, 0x00, 0xff, 0xff, 0xc4, 0xc9, 0xee, 0xbe, 0x68, 0x00, 0x00, 0x00,
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/fmt/m.proto b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/fmt/m.proto
deleted file mode 100644
index 142d8cfac..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/fmt/m.proto
+++ /dev/null
@@ -1,35 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2018 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto3";
-package fmt;
-option go_package = "github.com/golang/protobuf/protoc-gen-go/testdata/imports/fmt";
-message M {}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_1/m1.pb.go b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_1/m1.pb.go
deleted file mode 100644
index 82ec35e10..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_1/m1.pb.go
+++ /dev/null
@@ -1,130 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: imports/test_a_1/m1.proto
-
-package test_a_1 // import "github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_1"
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-type E1 int32
-
-const (
-	E1_E1_ZERO E1 = 0
-)
-
-var E1_name = map[int32]string{
-	0: "E1_ZERO",
-}
-var E1_value = map[string]int32{
-	"E1_ZERO": 0,
-}
-
-func (x E1) String() string {
-	return proto.EnumName(E1_name, int32(x))
-}
-func (E1) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_m1_56a2598431d21e61, []int{0}
-}
-
-type M1 struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *M1) Reset()         { *m = M1{} }
-func (m *M1) String() string { return proto.CompactTextString(m) }
-func (*M1) ProtoMessage()    {}
-func (*M1) Descriptor() ([]byte, []int) {
-	return fileDescriptor_m1_56a2598431d21e61, []int{0}
-}
-func (m *M1) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_M1.Unmarshal(m, b)
-}
-func (m *M1) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_M1.Marshal(b, m, deterministic)
-}
-func (dst *M1) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_M1.Merge(dst, src)
-}
-func (m *M1) XXX_Size() int {
-	return xxx_messageInfo_M1.Size(m)
-}
-func (m *M1) XXX_DiscardUnknown() {
-	xxx_messageInfo_M1.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_M1 proto.InternalMessageInfo
-
-type M1_1 struct {
-	M1                   *M1      `protobuf:"bytes,1,opt,name=m1" json:"m1,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *M1_1) Reset()         { *m = M1_1{} }
-func (m *M1_1) String() string { return proto.CompactTextString(m) }
-func (*M1_1) ProtoMessage()    {}
-func (*M1_1) Descriptor() ([]byte, []int) {
-	return fileDescriptor_m1_56a2598431d21e61, []int{1}
-}
-func (m *M1_1) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_M1_1.Unmarshal(m, b)
-}
-func (m *M1_1) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_M1_1.Marshal(b, m, deterministic)
-}
-func (dst *M1_1) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_M1_1.Merge(dst, src)
-}
-func (m *M1_1) XXX_Size() int {
-	return xxx_messageInfo_M1_1.Size(m)
-}
-func (m *M1_1) XXX_DiscardUnknown() {
-	xxx_messageInfo_M1_1.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_M1_1 proto.InternalMessageInfo
-
-func (m *M1_1) GetM1() *M1 {
-	if m != nil {
-		return m.M1
-	}
-	return nil
-}
-
-func init() {
-	proto.RegisterType((*M1)(nil), "test.a.M1")
-	proto.RegisterType((*M1_1)(nil), "test.a.M1_1")
-	proto.RegisterEnum("test.a.E1", E1_name, E1_value)
-}
-
-func init() { proto.RegisterFile("imports/test_a_1/m1.proto", fileDescriptor_m1_56a2598431d21e61) }
-
-var fileDescriptor_m1_56a2598431d21e61 = []byte{
-	// 165 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0xcc, 0xcc, 0x2d, 0xc8,
-	0x2f, 0x2a, 0x29, 0xd6, 0x2f, 0x49, 0x2d, 0x2e, 0x89, 0x4f, 0x8c, 0x37, 0xd4, 0xcf, 0x35, 0xd4,
-	0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x03, 0x09, 0xe9, 0x25, 0x2a, 0xb1, 0x70, 0x31, 0xf9,
-	0x1a, 0x2a, 0x29, 0x71, 0xb1, 0xf8, 0x1a, 0xc6, 0x1b, 0x0a, 0x49, 0x71, 0x31, 0xe5, 0x1a, 0x4a,
-	0x30, 0x2a, 0x30, 0x6a, 0x70, 0x1b, 0x71, 0xe9, 0x41, 0x94, 0xe8, 0xf9, 0x1a, 0x06, 0x31, 0xe5,
-	0x1a, 0x6a, 0x09, 0x72, 0x31, 0xb9, 0x1a, 0x0a, 0x71, 0x73, 0xb1, 0xbb, 0x1a, 0xc6, 0x47, 0xb9,
-	0x06, 0xf9, 0x0b, 0x30, 0x38, 0xb9, 0x44, 0x39, 0xa5, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25,
-	0xe7, 0xe7, 0xea, 0xa7, 0xe7, 0xe7, 0x24, 0xe6, 0xa5, 0xeb, 0x83, 0xcd, 0x4f, 0x2a, 0x4d, 0x83,
-	0x30, 0x92, 0x75, 0xd3, 0x53, 0xf3, 0x74, 0xd3, 0xf3, 0xc1, 0x4e, 0x48, 0x49, 0x2c, 0x49, 0xd4,
-	0x47, 0x77, 0x53, 0x12, 0x1b, 0x58, 0xa1, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0xcc, 0xae, 0xc9,
-	0xcd, 0xae, 0x00, 0x00, 0x00,
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_1/m1.proto b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_1/m1.proto
deleted file mode 100644
index da54c1ee4..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_1/m1.proto
+++ /dev/null
@@ -1,44 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2018 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto3";
-package test.a;
-option go_package = "github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_1";
-
-message M1 {}
-
-message M1_1 {
-  M1 m1 = 1;
-}
-
-enum E1 {
-  E1_ZERO = 0;
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_1/m2.pb.go b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_1/m2.pb.go
deleted file mode 100644
index 1b629bf32..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_1/m2.pb.go
+++ /dev/null
@@ -1,67 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: imports/test_a_1/m2.proto
-
-package test_a_1 // import "github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_1"
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-type M2 struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *M2) Reset()         { *m = M2{} }
-func (m *M2) String() string { return proto.CompactTextString(m) }
-func (*M2) ProtoMessage()    {}
-func (*M2) Descriptor() ([]byte, []int) {
-	return fileDescriptor_m2_ccd6356c045a9ac3, []int{0}
-}
-func (m *M2) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_M2.Unmarshal(m, b)
-}
-func (m *M2) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_M2.Marshal(b, m, deterministic)
-}
-func (dst *M2) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_M2.Merge(dst, src)
-}
-func (m *M2) XXX_Size() int {
-	return xxx_messageInfo_M2.Size(m)
-}
-func (m *M2) XXX_DiscardUnknown() {
-	xxx_messageInfo_M2.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_M2 proto.InternalMessageInfo
-
-func init() {
-	proto.RegisterType((*M2)(nil), "test.a.M2")
-}
-
-func init() { proto.RegisterFile("imports/test_a_1/m2.proto", fileDescriptor_m2_ccd6356c045a9ac3) }
-
-var fileDescriptor_m2_ccd6356c045a9ac3 = []byte{
-	// 114 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0xcc, 0xcc, 0x2d, 0xc8,
-	0x2f, 0x2a, 0x29, 0xd6, 0x2f, 0x49, 0x2d, 0x2e, 0x89, 0x4f, 0x8c, 0x37, 0xd4, 0xcf, 0x35, 0xd2,
-	0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x03, 0x09, 0xe9, 0x25, 0x2a, 0xb1, 0x70, 0x31, 0xf9,
-	0x1a, 0x39, 0xb9, 0x44, 0x39, 0xa5, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea,
-	0xa7, 0xe7, 0xe7, 0x24, 0xe6, 0xa5, 0xeb, 0x83, 0x15, 0x26, 0x95, 0xa6, 0x41, 0x18, 0xc9, 0xba,
-	0xe9, 0xa9, 0x79, 0xba, 0xe9, 0xf9, 0x60, 0xb3, 0x52, 0x12, 0x4b, 0x12, 0xf5, 0xd1, 0x0d, 0x4f,
-	0x62, 0x03, 0x2b, 0x34, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0xe3, 0xe0, 0x7e, 0xc0, 0x77, 0x00,
-	0x00, 0x00,
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_1/m2.proto b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_1/m2.proto
deleted file mode 100644
index 49499dc9c..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_1/m2.proto
+++ /dev/null
@@ -1,35 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2018 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto3";
-package test.a;
-option go_package = "github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_1";
-message M2 {}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_2/m3.pb.go b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_2/m3.pb.go
deleted file mode 100644
index e3895d2be..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_2/m3.pb.go
+++ /dev/null
@@ -1,67 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: imports/test_a_2/m3.proto
-
-package test_a_2 // import "github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_2"
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-type M3 struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *M3) Reset()         { *m = M3{} }
-func (m *M3) String() string { return proto.CompactTextString(m) }
-func (*M3) ProtoMessage()    {}
-func (*M3) Descriptor() ([]byte, []int) {
-	return fileDescriptor_m3_de310e87d08d4216, []int{0}
-}
-func (m *M3) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_M3.Unmarshal(m, b)
-}
-func (m *M3) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_M3.Marshal(b, m, deterministic)
-}
-func (dst *M3) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_M3.Merge(dst, src)
-}
-func (m *M3) XXX_Size() int {
-	return xxx_messageInfo_M3.Size(m)
-}
-func (m *M3) XXX_DiscardUnknown() {
-	xxx_messageInfo_M3.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_M3 proto.InternalMessageInfo
-
-func init() {
-	proto.RegisterType((*M3)(nil), "test.a.M3")
-}
-
-func init() { proto.RegisterFile("imports/test_a_2/m3.proto", fileDescriptor_m3_de310e87d08d4216) }
-
-var fileDescriptor_m3_de310e87d08d4216 = []byte{
-	// 114 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0xcc, 0xcc, 0x2d, 0xc8,
-	0x2f, 0x2a, 0x29, 0xd6, 0x2f, 0x49, 0x2d, 0x2e, 0x89, 0x4f, 0x8c, 0x37, 0xd2, 0xcf, 0x35, 0xd6,
-	0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x03, 0x09, 0xe9, 0x25, 0x2a, 0xb1, 0x70, 0x31, 0xf9,
-	0x1a, 0x3b, 0xb9, 0x44, 0x39, 0xa5, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea,
-	0xa7, 0xe7, 0xe7, 0x24, 0xe6, 0xa5, 0xeb, 0x83, 0x15, 0x26, 0x95, 0xa6, 0x41, 0x18, 0xc9, 0xba,
-	0xe9, 0xa9, 0x79, 0xba, 0xe9, 0xf9, 0x60, 0xb3, 0x52, 0x12, 0x4b, 0x12, 0xf5, 0xd1, 0x0d, 0x4f,
-	0x62, 0x03, 0x2b, 0x34, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x23, 0x86, 0x27, 0x47, 0x77, 0x00,
-	0x00, 0x00,
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_2/m3.proto b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_2/m3.proto
deleted file mode 100644
index 5e811ef84..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_2/m3.proto
+++ /dev/null
@@ -1,35 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2018 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto3";
-package test.a;
-option go_package = "github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_2";
-message M3 {}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_2/m4.pb.go b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_2/m4.pb.go
deleted file mode 100644
index 65a3bad29..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_2/m4.pb.go
+++ /dev/null
@@ -1,67 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: imports/test_a_2/m4.proto
-
-package test_a_2 // import "github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_2"
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-type M4 struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *M4) Reset()         { *m = M4{} }
-func (m *M4) String() string { return proto.CompactTextString(m) }
-func (*M4) ProtoMessage()    {}
-func (*M4) Descriptor() ([]byte, []int) {
-	return fileDescriptor_m4_da12b386229f3791, []int{0}
-}
-func (m *M4) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_M4.Unmarshal(m, b)
-}
-func (m *M4) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_M4.Marshal(b, m, deterministic)
-}
-func (dst *M4) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_M4.Merge(dst, src)
-}
-func (m *M4) XXX_Size() int {
-	return xxx_messageInfo_M4.Size(m)
-}
-func (m *M4) XXX_DiscardUnknown() {
-	xxx_messageInfo_M4.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_M4 proto.InternalMessageInfo
-
-func init() {
-	proto.RegisterType((*M4)(nil), "test.a.M4")
-}
-
-func init() { proto.RegisterFile("imports/test_a_2/m4.proto", fileDescriptor_m4_da12b386229f3791) }
-
-var fileDescriptor_m4_da12b386229f3791 = []byte{
-	// 114 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0xcc, 0xcc, 0x2d, 0xc8,
-	0x2f, 0x2a, 0x29, 0xd6, 0x2f, 0x49, 0x2d, 0x2e, 0x89, 0x4f, 0x8c, 0x37, 0xd2, 0xcf, 0x35, 0xd1,
-	0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x03, 0x09, 0xe9, 0x25, 0x2a, 0xb1, 0x70, 0x31, 0xf9,
-	0x9a, 0x38, 0xb9, 0x44, 0x39, 0xa5, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea,
-	0xa7, 0xe7, 0xe7, 0x24, 0xe6, 0xa5, 0xeb, 0x83, 0x15, 0x26, 0x95, 0xa6, 0x41, 0x18, 0xc9, 0xba,
-	0xe9, 0xa9, 0x79, 0xba, 0xe9, 0xf9, 0x60, 0xb3, 0x52, 0x12, 0x4b, 0x12, 0xf5, 0xd1, 0x0d, 0x4f,
-	0x62, 0x03, 0x2b, 0x34, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x58, 0xcb, 0x10, 0xc8, 0x77, 0x00,
-	0x00, 0x00,
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_2/m4.proto b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_2/m4.proto
deleted file mode 100644
index 8f8fe3e12..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_2/m4.proto
+++ /dev/null
@@ -1,35 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2018 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto3";
-package test.a;
-option go_package = "github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_2";
-message M4 {}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_b_1/m1.pb.go b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_b_1/m1.pb.go
deleted file mode 100644
index 831f41498..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_b_1/m1.pb.go
+++ /dev/null
@@ -1,67 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: imports/test_b_1/m1.proto
-
-package beta // import "github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_b_1"
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-type M1 struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *M1) Reset()         { *m = M1{} }
-func (m *M1) String() string { return proto.CompactTextString(m) }
-func (*M1) ProtoMessage()    {}
-func (*M1) Descriptor() ([]byte, []int) {
-	return fileDescriptor_m1_aff127b054aec649, []int{0}
-}
-func (m *M1) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_M1.Unmarshal(m, b)
-}
-func (m *M1) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_M1.Marshal(b, m, deterministic)
-}
-func (dst *M1) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_M1.Merge(dst, src)
-}
-func (m *M1) XXX_Size() int {
-	return xxx_messageInfo_M1.Size(m)
-}
-func (m *M1) XXX_DiscardUnknown() {
-	xxx_messageInfo_M1.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_M1 proto.InternalMessageInfo
-
-func init() {
-	proto.RegisterType((*M1)(nil), "test.b.part1.M1")
-}
-
-func init() { proto.RegisterFile("imports/test_b_1/m1.proto", fileDescriptor_m1_aff127b054aec649) }
-
-var fileDescriptor_m1_aff127b054aec649 = []byte{
-	// 125 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0xcc, 0xcc, 0x2d, 0xc8,
-	0x2f, 0x2a, 0x29, 0xd6, 0x2f, 0x49, 0x2d, 0x2e, 0x89, 0x4f, 0x8a, 0x37, 0xd4, 0xcf, 0x35, 0xd4,
-	0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x01, 0x09, 0xe9, 0x25, 0xe9, 0x15, 0x24, 0x16, 0x95,
-	0x18, 0x2a, 0xb1, 0x70, 0x31, 0xf9, 0x1a, 0x3a, 0x79, 0x46, 0xb9, 0xa7, 0x67, 0x96, 0x64, 0x94,
-	0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0xa7, 0xe7, 0xe7, 0x24, 0xe6, 0xa5, 0xeb, 0x83, 0x95, 0x27,
-	0x95, 0xa6, 0x41, 0x18, 0xc9, 0xba, 0xe9, 0xa9, 0x79, 0xba, 0xe9, 0xf9, 0x60, 0x13, 0x53, 0x12,
-	0x4b, 0x12, 0xf5, 0xd1, 0xad, 0xb0, 0x4e, 0x4a, 0x2d, 0x49, 0x4c, 0x62, 0x03, 0xab, 0x36, 0x06,
-	0x04, 0x00, 0x00, 0xff, 0xff, 0x4a, 0xf1, 0x3b, 0x7f, 0x82, 0x00, 0x00, 0x00,
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_b_1/m1.proto b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_b_1/m1.proto
deleted file mode 100644
index 2c35ec4ae..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_b_1/m1.proto
+++ /dev/null
@@ -1,35 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2018 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto3";
-package test.b.part1;
-option go_package = "github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_b_1;beta";
-message M1 {}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_b_1/m2.pb.go b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_b_1/m2.pb.go
deleted file mode 100644
index bc741056a..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_b_1/m2.pb.go
+++ /dev/null
@@ -1,67 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: imports/test_b_1/m2.proto
-
-package beta // import "github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_b_1"
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-type M2 struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *M2) Reset()         { *m = M2{} }
-func (m *M2) String() string { return proto.CompactTextString(m) }
-func (*M2) ProtoMessage()    {}
-func (*M2) Descriptor() ([]byte, []int) {
-	return fileDescriptor_m2_0c59cab35ba1b0d8, []int{0}
-}
-func (m *M2) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_M2.Unmarshal(m, b)
-}
-func (m *M2) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_M2.Marshal(b, m, deterministic)
-}
-func (dst *M2) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_M2.Merge(dst, src)
-}
-func (m *M2) XXX_Size() int {
-	return xxx_messageInfo_M2.Size(m)
-}
-func (m *M2) XXX_DiscardUnknown() {
-	xxx_messageInfo_M2.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_M2 proto.InternalMessageInfo
-
-func init() {
-	proto.RegisterType((*M2)(nil), "test.b.part2.M2")
-}
-
-func init() { proto.RegisterFile("imports/test_b_1/m2.proto", fileDescriptor_m2_0c59cab35ba1b0d8) }
-
-var fileDescriptor_m2_0c59cab35ba1b0d8 = []byte{
-	// 125 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0xcc, 0xcc, 0x2d, 0xc8,
-	0x2f, 0x2a, 0x29, 0xd6, 0x2f, 0x49, 0x2d, 0x2e, 0x89, 0x4f, 0x8a, 0x37, 0xd4, 0xcf, 0x35, 0xd2,
-	0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x01, 0x09, 0xe9, 0x25, 0xe9, 0x15, 0x24, 0x16, 0x95,
-	0x18, 0x29, 0xb1, 0x70, 0x31, 0xf9, 0x1a, 0x39, 0x79, 0x46, 0xb9, 0xa7, 0x67, 0x96, 0x64, 0x94,
-	0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0xa7, 0xe7, 0xe7, 0x24, 0xe6, 0xa5, 0xeb, 0x83, 0x95, 0x27,
-	0x95, 0xa6, 0x41, 0x18, 0xc9, 0xba, 0xe9, 0xa9, 0x79, 0xba, 0xe9, 0xf9, 0x60, 0x13, 0x53, 0x12,
-	0x4b, 0x12, 0xf5, 0xd1, 0xad, 0xb0, 0x4e, 0x4a, 0x2d, 0x49, 0x4c, 0x62, 0x03, 0xab, 0x36, 0x06,
-	0x04, 0x00, 0x00, 0xff, 0xff, 0x44, 0x29, 0xbe, 0x6d, 0x82, 0x00, 0x00, 0x00,
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_b_1/m2.proto b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_b_1/m2.proto
deleted file mode 100644
index 13723be41..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_b_1/m2.proto
+++ /dev/null
@@ -1,35 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2018 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto3";
-package test.b.part2;
-option go_package = "github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_b_1;beta";
-message M2 {}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_import_a1m1.pb.go b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_import_a1m1.pb.go
deleted file mode 100644
index 72daffdbf..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_import_a1m1.pb.go
+++ /dev/null
@@ -1,80 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: imports/test_import_a1m1.proto
-
-package imports // import "github.com/golang/protobuf/protoc-gen-go/testdata/imports"
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-import test_a_1 "github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_1"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-type A1M1 struct {
-	F                    *test_a_1.M1 `protobuf:"bytes,1,opt,name=f" json:"f,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
-	XXX_unrecognized     []byte       `json:"-"`
-	XXX_sizecache        int32        `json:"-"`
-}
-
-func (m *A1M1) Reset()         { *m = A1M1{} }
-func (m *A1M1) String() string { return proto.CompactTextString(m) }
-func (*A1M1) ProtoMessage()    {}
-func (*A1M1) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_import_a1m1_d7f2b5c638a69f6e, []int{0}
-}
-func (m *A1M1) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_A1M1.Unmarshal(m, b)
-}
-func (m *A1M1) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_A1M1.Marshal(b, m, deterministic)
-}
-func (dst *A1M1) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_A1M1.Merge(dst, src)
-}
-func (m *A1M1) XXX_Size() int {
-	return xxx_messageInfo_A1M1.Size(m)
-}
-func (m *A1M1) XXX_DiscardUnknown() {
-	xxx_messageInfo_A1M1.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_A1M1 proto.InternalMessageInfo
-
-func (m *A1M1) GetF() *test_a_1.M1 {
-	if m != nil {
-		return m.F
-	}
-	return nil
-}
-
-func init() {
-	proto.RegisterType((*A1M1)(nil), "test.A1M1")
-}
-
-func init() {
-	proto.RegisterFile("imports/test_import_a1m1.proto", fileDescriptor_test_import_a1m1_d7f2b5c638a69f6e)
-}
-
-var fileDescriptor_test_import_a1m1_d7f2b5c638a69f6e = []byte{
-	// 149 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0xcb, 0xcc, 0x2d, 0xc8,
-	0x2f, 0x2a, 0x29, 0xd6, 0x2f, 0x49, 0x2d, 0x2e, 0x89, 0x87, 0x70, 0xe2, 0x13, 0x0d, 0x73, 0x0d,
-	0xf5, 0x0a, 0x8a, 0xf2, 0x4b, 0xf2, 0x85, 0x58, 0x40, 0xe2, 0x52, 0x92, 0x28, 0xaa, 0x12, 0xe3,
-	0x0d, 0xf5, 0x61, 0x0a, 0x94, 0x14, 0xb8, 0x58, 0x1c, 0x0d, 0x7d, 0x0d, 0x85, 0x24, 0xb8, 0x18,
-	0xd3, 0x24, 0x18, 0x15, 0x18, 0x35, 0xb8, 0x8d, 0xb8, 0xf4, 0x40, 0xca, 0xf4, 0x12, 0xf5, 0x7c,
-	0x0d, 0x83, 0x18, 0xd3, 0x9c, 0xac, 0xa3, 0x2c, 0xd3, 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92,
-	0xf3, 0x73, 0xf5, 0xd3, 0xf3, 0x73, 0x12, 0xf3, 0xd2, 0xf5, 0xc1, 0x9a, 0x93, 0x4a, 0xd3, 0x20,
-	0x8c, 0x64, 0xdd, 0xf4, 0xd4, 0x3c, 0xdd, 0xf4, 0x7c, 0xb0, 0xf9, 0x29, 0x89, 0x25, 0x89, 0xfa,
-	0x50, 0x0b, 0x93, 0xd8, 0xc0, 0xf2, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x84, 0x2f, 0x18,
-	0x23, 0xa8, 0x00, 0x00, 0x00,
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_import_a1m1.proto b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_import_a1m1.proto
deleted file mode 100644
index abf07f2a4..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_import_a1m1.proto
+++ /dev/null
@@ -1,42 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2018 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto3";
-
-package test;
-
-option go_package = "github.com/golang/protobuf/protoc-gen-go/testdata/imports";
-
-import "imports/test_a_1/m1.proto";
-
-message A1M1 {
-  test.a.M1 f = 1;
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_import_a1m2.pb.go b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_import_a1m2.pb.go
deleted file mode 100644
index 9e36ebdeb..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_import_a1m2.pb.go
+++ /dev/null
@@ -1,80 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: imports/test_import_a1m2.proto
-
-package imports // import "github.com/golang/protobuf/protoc-gen-go/testdata/imports"
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-import test_a_1 "github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_1"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-type A1M2 struct {
-	F                    *test_a_1.M2 `protobuf:"bytes,1,opt,name=f" json:"f,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
-	XXX_unrecognized     []byte       `json:"-"`
-	XXX_sizecache        int32        `json:"-"`
-}
-
-func (m *A1M2) Reset()         { *m = A1M2{} }
-func (m *A1M2) String() string { return proto.CompactTextString(m) }
-func (*A1M2) ProtoMessage()    {}
-func (*A1M2) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_import_a1m2_9a3281ce9464e116, []int{0}
-}
-func (m *A1M2) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_A1M2.Unmarshal(m, b)
-}
-func (m *A1M2) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_A1M2.Marshal(b, m, deterministic)
-}
-func (dst *A1M2) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_A1M2.Merge(dst, src)
-}
-func (m *A1M2) XXX_Size() int {
-	return xxx_messageInfo_A1M2.Size(m)
-}
-func (m *A1M2) XXX_DiscardUnknown() {
-	xxx_messageInfo_A1M2.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_A1M2 proto.InternalMessageInfo
-
-func (m *A1M2) GetF() *test_a_1.M2 {
-	if m != nil {
-		return m.F
-	}
-	return nil
-}
-
-func init() {
-	proto.RegisterType((*A1M2)(nil), "test.A1M2")
-}
-
-func init() {
-	proto.RegisterFile("imports/test_import_a1m2.proto", fileDescriptor_test_import_a1m2_9a3281ce9464e116)
-}
-
-var fileDescriptor_test_import_a1m2_9a3281ce9464e116 = []byte{
-	// 149 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0xcb, 0xcc, 0x2d, 0xc8,
-	0x2f, 0x2a, 0x29, 0xd6, 0x2f, 0x49, 0x2d, 0x2e, 0x89, 0x87, 0x70, 0xe2, 0x13, 0x0d, 0x73, 0x8d,
-	0xf4, 0x0a, 0x8a, 0xf2, 0x4b, 0xf2, 0x85, 0x58, 0x40, 0xe2, 0x52, 0x92, 0x28, 0xaa, 0x12, 0xe3,
-	0x0d, 0xf5, 0x61, 0x0a, 0x94, 0x14, 0xb8, 0x58, 0x1c, 0x0d, 0x7d, 0x8d, 0x84, 0x24, 0xb8, 0x18,
-	0xd3, 0x24, 0x18, 0x15, 0x18, 0x35, 0xb8, 0x8d, 0xb8, 0xf4, 0x40, 0xca, 0xf4, 0x12, 0xf5, 0x7c,
-	0x8d, 0x82, 0x18, 0xd3, 0x9c, 0xac, 0xa3, 0x2c, 0xd3, 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92,
-	0xf3, 0x73, 0xf5, 0xd3, 0xf3, 0x73, 0x12, 0xf3, 0xd2, 0xf5, 0xc1, 0x9a, 0x93, 0x4a, 0xd3, 0x20,
-	0x8c, 0x64, 0xdd, 0xf4, 0xd4, 0x3c, 0xdd, 0xf4, 0x7c, 0xb0, 0xf9, 0x29, 0x89, 0x25, 0x89, 0xfa,
-	0x50, 0x0b, 0x93, 0xd8, 0xc0, 0xf2, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x1f, 0x88, 0xfb,
-	0xea, 0xa8, 0x00, 0x00, 0x00,
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_import_a1m2.proto b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_import_a1m2.proto
deleted file mode 100644
index 5c53950da..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_import_a1m2.proto
+++ /dev/null
@@ -1,42 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2018 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto3";
-
-package test;
-
-option go_package = "github.com/golang/protobuf/protoc-gen-go/testdata/imports";
-
-import "imports/test_a_1/m2.proto";
-
-message A1M2 {
-  test.a.M2 f = 1;
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_import_all.pb.go b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_import_all.pb.go
deleted file mode 100644
index f40e0b738..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_import_all.pb.go
+++ /dev/null
@@ -1,138 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: imports/test_import_all.proto
-
-package imports // import "github.com/golang/protobuf/protoc-gen-go/testdata/imports"
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-import fmt1 "github.com/golang/protobuf/protoc-gen-go/testdata/imports/fmt"
-import test_a_1 "github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_1"
-import test_a_2 "github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_2"
-import test_b_1 "github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_b_1"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-type All struct {
-	Am1                  *test_a_1.M1 `protobuf:"bytes,1,opt,name=am1" json:"am1,omitempty"`
-	Am2                  *test_a_1.M2 `protobuf:"bytes,2,opt,name=am2" json:"am2,omitempty"`
-	Am3                  *test_a_2.M3 `protobuf:"bytes,3,opt,name=am3" json:"am3,omitempty"`
-	Am4                  *test_a_2.M4 `protobuf:"bytes,4,opt,name=am4" json:"am4,omitempty"`
-	Bm1                  *test_b_1.M1 `protobuf:"bytes,5,opt,name=bm1" json:"bm1,omitempty"`
-	Bm2                  *test_b_1.M2 `protobuf:"bytes,6,opt,name=bm2" json:"bm2,omitempty"`
-	Fmt                  *fmt1.M      `protobuf:"bytes,7,opt,name=fmt" json:"fmt,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
-	XXX_unrecognized     []byte       `json:"-"`
-	XXX_sizecache        int32        `json:"-"`
-}
-
-func (m *All) Reset()         { *m = All{} }
-func (m *All) String() string { return proto.CompactTextString(m) }
-func (*All) ProtoMessage()    {}
-func (*All) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_import_all_b41dc4592e4a4f3b, []int{0}
-}
-func (m *All) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_All.Unmarshal(m, b)
-}
-func (m *All) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_All.Marshal(b, m, deterministic)
-}
-func (dst *All) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_All.Merge(dst, src)
-}
-func (m *All) XXX_Size() int {
-	return xxx_messageInfo_All.Size(m)
-}
-func (m *All) XXX_DiscardUnknown() {
-	xxx_messageInfo_All.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_All proto.InternalMessageInfo
-
-func (m *All) GetAm1() *test_a_1.M1 {
-	if m != nil {
-		return m.Am1
-	}
-	return nil
-}
-
-func (m *All) GetAm2() *test_a_1.M2 {
-	if m != nil {
-		return m.Am2
-	}
-	return nil
-}
-
-func (m *All) GetAm3() *test_a_2.M3 {
-	if m != nil {
-		return m.Am3
-	}
-	return nil
-}
-
-func (m *All) GetAm4() *test_a_2.M4 {
-	if m != nil {
-		return m.Am4
-	}
-	return nil
-}
-
-func (m *All) GetBm1() *test_b_1.M1 {
-	if m != nil {
-		return m.Bm1
-	}
-	return nil
-}
-
-func (m *All) GetBm2() *test_b_1.M2 {
-	if m != nil {
-		return m.Bm2
-	}
-	return nil
-}
-
-func (m *All) GetFmt() *fmt1.M {
-	if m != nil {
-		return m.Fmt
-	}
-	return nil
-}
-
-func init() {
-	proto.RegisterType((*All)(nil), "test.All")
-}
-
-func init() {
-	proto.RegisterFile("imports/test_import_all.proto", fileDescriptor_test_import_all_b41dc4592e4a4f3b)
-}
-
-var fileDescriptor_test_import_all_b41dc4592e4a4f3b = []byte{
-	// 258 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0xd0, 0xb1, 0x4e, 0xc3, 0x30,
-	0x10, 0x06, 0x60, 0x15, 0x97, 0x20, 0x99, 0x05, 0x85, 0xc5, 0x20, 0x90, 0x50, 0x27, 0x96, 0xda,
-	0xb2, 0x9d, 0x05, 0x31, 0xc1, 0xde, 0xa5, 0x23, 0x4b, 0x64, 0x97, 0xc6, 0x54, 0xf2, 0xd5, 0x51,
-	0x7a, 0x7d, 0x5e, 0x5e, 0x05, 0xd9, 0x07, 0x12, 0x84, 0x66, 0x4b, 0xfe, 0xef, 0xb7, 0xce, 0x3e,
-	0x7e, 0xbf, 0x83, 0x3e, 0x0d, 0x78, 0x50, 0xb8, 0x3d, 0x60, 0x4b, 0x3f, 0xad, 0x8b, 0x51, 0xf6,
-	0x43, 0xc2, 0x54, 0xcf, 0x73, 0x7c, 0x7b, 0xf3, 0xa7, 0xe4, 0x5a, 0xad, 0x40, 0x53, 0xe1, 0x14,
-	0x99, 0x09, 0x32, 0x0a, 0xec, 0x34, 0x35, 0x27, 0xc9, 0x4f, 0xcf, 0xf2, 0xbf, 0x67, 0x5d, 0xff,
-	0x50, 0x07, 0xa8, 0x80, 0xc2, 0xc5, 0xe7, 0x8c, 0xb3, 0x97, 0x18, 0xeb, 0x3b, 0xce, 0x1c, 0x68,
-	0x31, 0x7b, 0x98, 0x3d, 0x5e, 0x1a, 0x2e, 0xf3, 0x69, 0xe9, 0xe4, 0x4a, 0xaf, 0x73, 0x4c, 0x6a,
-	0xc4, 0xd9, 0x48, 0x4d, 0x56, 0x43, 0x6a, 0x05, 0x1b, 0xa9, 0xcd, 0x6a, 0x49, 0x1b, 0x31, 0x1f,
-	0x69, 0x93, 0xb5, 0xa9, 0x17, 0x9c, 0x79, 0xd0, 0xe2, 0xbc, 0xe8, 0x15, 0xa9, 0x97, 0xbd, 0x1b,
-	0x50, 0x97, 0xe9, 0x1e, 0x34, 0x75, 0x8c, 0xa8, 0xfe, 0x77, 0x4c, 0xb9, 0x83, 0x07, 0x53, 0x0b,
-	0xce, 0x3a, 0x40, 0x71, 0x51, 0x3a, 0x95, 0xec, 0x00, 0xe5, 0x6a, 0x9d, 0xa3, 0xd7, 0xe7, 0xb7,
-	0xa7, 0xb0, 0xc3, 0x8f, 0xa3, 0x97, 0x9b, 0x04, 0x2a, 0xa4, 0xe8, 0xf6, 0x41, 0x95, 0xc7, 0xfb,
-	0x63, 0x47, 0x1f, 0x9b, 0x65, 0xd8, 0xee, 0x97, 0x21, 0x95, 0xa5, 0xbd, 0x3b, 0x74, 0xea, 0x7b,
-	0x55, 0xbe, 0x2a, 0x6e, 0xbf, 0x02, 0x00, 0x00, 0xff, 0xff, 0x95, 0x39, 0xa3, 0x82, 0x03, 0x02,
-	0x00, 0x00,
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_import_all.proto b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_import_all.proto
deleted file mode 100644
index 582d722e3..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_import_all.proto
+++ /dev/null
@@ -1,58 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2018 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto3";
-
-package test;
-
-option go_package = "github.com/golang/protobuf/protoc-gen-go/testdata/imports";
-
-// test_a_1/m*.proto are in the same Go package and proto package.
-// test_a_*/*.proto are in different Go packages, but the same proto package.
-// test_b_1/*.proto are in the same Go package, but different proto packages.
-// fmt/m.proto has a package name which conflicts with "fmt".
-import "imports/test_a_1/m1.proto";
-import "imports/test_a_1/m2.proto";
-import "imports/test_a_2/m3.proto";
-import "imports/test_a_2/m4.proto";
-import "imports/test_b_1/m1.proto";
-import "imports/test_b_1/m2.proto";
-import "imports/fmt/m.proto";
-
-message All {
-  test.a.M1 am1 = 1;
-  test.a.M2 am2 = 2;
-  test.a.M3 am3 = 3;
-  test.a.M4 am4 = 4;
-  test.b.part1.M1 bm1 = 5;
-  test.b.part2.M2 bm2 = 6;
-  fmt.M fmt = 7;
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/main_test.go b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/main_test.go
deleted file mode 100644
index 7ec1f2dba..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/main_test.go
+++ /dev/null
@@ -1,48 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// A simple binary to link together the protocol buffers in this test.
-
-package testdata
-
-import (
-	"testing"
-
-	importspb "github.com/golang/protobuf/protoc-gen-go/testdata/imports"
-	multipb "github.com/golang/protobuf/protoc-gen-go/testdata/multi"
-	mytestpb "github.com/golang/protobuf/protoc-gen-go/testdata/my_test"
-)
-
-func TestLink(t *testing.T) {
-	_ = &multipb.Multi1{}
-	_ = &mytestpb.Request{}
-	_ = &importspb.All{}
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/multi/multi1.pb.go b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/multi/multi1.pb.go
deleted file mode 100644
index da0fdf8fd..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/multi/multi1.pb.go
+++ /dev/null
@@ -1,96 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: multi/multi1.proto
-
-package multitest // import "github.com/golang/protobuf/protoc-gen-go/testdata/multi"
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-type Multi1 struct {
-	Multi2               *Multi2         `protobuf:"bytes,1,req,name=multi2" json:"multi2,omitempty"`
-	Color                *Multi2_Color   `protobuf:"varint,2,opt,name=color,enum=multitest.Multi2_Color" json:"color,omitempty"`
-	HatType              *Multi3_HatType `protobuf:"varint,3,opt,name=hat_type,json=hatType,enum=multitest.Multi3_HatType" json:"hat_type,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
-	XXX_unrecognized     []byte          `json:"-"`
-	XXX_sizecache        int32           `json:"-"`
-}
-
-func (m *Multi1) Reset()         { *m = Multi1{} }
-func (m *Multi1) String() string { return proto.CompactTextString(m) }
-func (*Multi1) ProtoMessage()    {}
-func (*Multi1) Descriptor() ([]byte, []int) {
-	return fileDescriptor_multi1_08e50c6822e808b8, []int{0}
-}
-func (m *Multi1) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Multi1.Unmarshal(m, b)
-}
-func (m *Multi1) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Multi1.Marshal(b, m, deterministic)
-}
-func (dst *Multi1) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Multi1.Merge(dst, src)
-}
-func (m *Multi1) XXX_Size() int {
-	return xxx_messageInfo_Multi1.Size(m)
-}
-func (m *Multi1) XXX_DiscardUnknown() {
-	xxx_messageInfo_Multi1.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Multi1 proto.InternalMessageInfo
-
-func (m *Multi1) GetMulti2() *Multi2 {
-	if m != nil {
-		return m.Multi2
-	}
-	return nil
-}
-
-func (m *Multi1) GetColor() Multi2_Color {
-	if m != nil && m.Color != nil {
-		return *m.Color
-	}
-	return Multi2_BLUE
-}
-
-func (m *Multi1) GetHatType() Multi3_HatType {
-	if m != nil && m.HatType != nil {
-		return *m.HatType
-	}
-	return Multi3_FEDORA
-}
-
-func init() {
-	proto.RegisterType((*Multi1)(nil), "multitest.Multi1")
-}
-
-func init() { proto.RegisterFile("multi/multi1.proto", fileDescriptor_multi1_08e50c6822e808b8) }
-
-var fileDescriptor_multi1_08e50c6822e808b8 = []byte{
-	// 200 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0xca, 0x2d, 0xcd, 0x29,
-	0xc9, 0xd4, 0x07, 0x93, 0x86, 0x7a, 0x05, 0x45, 0xf9, 0x25, 0xf9, 0x42, 0x9c, 0x60, 0x5e, 0x49,
-	0x6a, 0x71, 0x89, 0x14, 0xb2, 0xb4, 0x11, 0x44, 0x1a, 0x45, 0xcc, 0x18, 0x22, 0xa6, 0x34, 0x83,
-	0x91, 0x8b, 0xcd, 0x17, 0x6c, 0x86, 0x90, 0x26, 0x17, 0x1b, 0x44, 0xb9, 0x04, 0xa3, 0x02, 0x93,
-	0x06, 0xb7, 0x91, 0xa0, 0x1e, 0xdc, 0x38, 0x3d, 0xb0, 0x12, 0xa3, 0x20, 0xa8, 0x02, 0x21, 0x5d,
-	0x2e, 0xd6, 0xe4, 0xfc, 0x9c, 0xfc, 0x22, 0x09, 0x26, 0x05, 0x46, 0x0d, 0x3e, 0x23, 0x71, 0x0c,
-	0x95, 0x7a, 0xce, 0x20, 0xe9, 0x20, 0x88, 0x2a, 0x21, 0x13, 0x2e, 0x8e, 0x8c, 0xc4, 0x92, 0xf8,
-	0x92, 0xca, 0x82, 0x54, 0x09, 0x66, 0xb0, 0x0e, 0x49, 0x74, 0x1d, 0xc6, 0x7a, 0x1e, 0x89, 0x25,
-	0x21, 0x95, 0x05, 0xa9, 0x41, 0xec, 0x19, 0x10, 0x86, 0x93, 0x73, 0x94, 0x63, 0x7a, 0x66, 0x49,
-	0x46, 0x69, 0x92, 0x5e, 0x72, 0x7e, 0xae, 0x7e, 0x7a, 0x7e, 0x4e, 0x62, 0x5e, 0xba, 0x3e, 0xd8,
-	0xd5, 0x49, 0xa5, 0x69, 0x10, 0x46, 0xb2, 0x6e, 0x7a, 0x6a, 0x9e, 0x6e, 0x7a, 0xbe, 0x3e, 0xc8,
-	0xa0, 0x94, 0xc4, 0x92, 0x44, 0x88, 0xe7, 0xac, 0xe1, 0x86, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff,
-	0x60, 0x7d, 0xfc, 0x9f, 0x27, 0x01, 0x00, 0x00,
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/multi/multi1.proto b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/multi/multi1.proto
deleted file mode 100644
index d3a32041e..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/multi/multi1.proto
+++ /dev/null
@@ -1,46 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto2";
-
-import "multi/multi2.proto";
-import "multi/multi3.proto";
-
-package multitest;
-
-option go_package = "github.com/golang/protobuf/protoc-gen-go/testdata/multi;multitest";
-
-message Multi1 {
-  required Multi2 multi2 = 1;
-  optional Multi2.Color color = 2;
-  optional Multi3.HatType hat_type = 3;
-}
-
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/multi/multi2.pb.go b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/multi/multi2.pb.go
deleted file mode 100644
index b66ce7930..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/multi/multi2.pb.go
+++ /dev/null
@@ -1,128 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: multi/multi2.proto
-
-package multitest // import "github.com/golang/protobuf/protoc-gen-go/testdata/multi"
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-type Multi2_Color int32
-
-const (
-	Multi2_BLUE  Multi2_Color = 1
-	Multi2_GREEN Multi2_Color = 2
-	Multi2_RED   Multi2_Color = 3
-)
-
-var Multi2_Color_name = map[int32]string{
-	1: "BLUE",
-	2: "GREEN",
-	3: "RED",
-}
-var Multi2_Color_value = map[string]int32{
-	"BLUE":  1,
-	"GREEN": 2,
-	"RED":   3,
-}
-
-func (x Multi2_Color) Enum() *Multi2_Color {
-	p := new(Multi2_Color)
-	*p = x
-	return p
-}
-func (x Multi2_Color) String() string {
-	return proto.EnumName(Multi2_Color_name, int32(x))
-}
-func (x *Multi2_Color) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(Multi2_Color_value, data, "Multi2_Color")
-	if err != nil {
-		return err
-	}
-	*x = Multi2_Color(value)
-	return nil
-}
-func (Multi2_Color) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_multi2_c47490ad66d93e67, []int{0, 0}
-}
-
-type Multi2 struct {
-	RequiredValue        *int32        `protobuf:"varint,1,req,name=required_value,json=requiredValue" json:"required_value,omitempty"`
-	Color                *Multi2_Color `protobuf:"varint,2,opt,name=color,enum=multitest.Multi2_Color" json:"color,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
-	XXX_unrecognized     []byte        `json:"-"`
-	XXX_sizecache        int32         `json:"-"`
-}
-
-func (m *Multi2) Reset()         { *m = Multi2{} }
-func (m *Multi2) String() string { return proto.CompactTextString(m) }
-func (*Multi2) ProtoMessage()    {}
-func (*Multi2) Descriptor() ([]byte, []int) {
-	return fileDescriptor_multi2_c47490ad66d93e67, []int{0}
-}
-func (m *Multi2) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Multi2.Unmarshal(m, b)
-}
-func (m *Multi2) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Multi2.Marshal(b, m, deterministic)
-}
-func (dst *Multi2) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Multi2.Merge(dst, src)
-}
-func (m *Multi2) XXX_Size() int {
-	return xxx_messageInfo_Multi2.Size(m)
-}
-func (m *Multi2) XXX_DiscardUnknown() {
-	xxx_messageInfo_Multi2.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Multi2 proto.InternalMessageInfo
-
-func (m *Multi2) GetRequiredValue() int32 {
-	if m != nil && m.RequiredValue != nil {
-		return *m.RequiredValue
-	}
-	return 0
-}
-
-func (m *Multi2) GetColor() Multi2_Color {
-	if m != nil && m.Color != nil {
-		return *m.Color
-	}
-	return Multi2_BLUE
-}
-
-func init() {
-	proto.RegisterType((*Multi2)(nil), "multitest.Multi2")
-	proto.RegisterEnum("multitest.Multi2_Color", Multi2_Color_name, Multi2_Color_value)
-}
-
-func init() { proto.RegisterFile("multi/multi2.proto", fileDescriptor_multi2_c47490ad66d93e67) }
-
-var fileDescriptor_multi2_c47490ad66d93e67 = []byte{
-	// 202 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0xca, 0x2d, 0xcd, 0x29,
-	0xc9, 0xd4, 0x07, 0x93, 0x46, 0x7a, 0x05, 0x45, 0xf9, 0x25, 0xf9, 0x42, 0x9c, 0x60, 0x5e, 0x49,
-	0x6a, 0x71, 0x89, 0x52, 0x2b, 0x23, 0x17, 0x9b, 0x2f, 0x58, 0x4e, 0x48, 0x95, 0x8b, 0xaf, 0x28,
-	0xb5, 0xb0, 0x34, 0xb3, 0x28, 0x35, 0x25, 0xbe, 0x2c, 0x31, 0xa7, 0x34, 0x55, 0x82, 0x51, 0x81,
-	0x49, 0x83, 0x35, 0x88, 0x17, 0x26, 0x1a, 0x06, 0x12, 0x14, 0xd2, 0xe5, 0x62, 0x4d, 0xce, 0xcf,
-	0xc9, 0x2f, 0x92, 0x60, 0x52, 0x60, 0xd4, 0xe0, 0x33, 0x12, 0xd7, 0x83, 0x1b, 0xa6, 0x07, 0x31,
-	0x48, 0xcf, 0x19, 0x24, 0x1d, 0x04, 0x51, 0xa5, 0xa4, 0xca, 0xc5, 0x0a, 0xe6, 0x0b, 0x71, 0x70,
-	0xb1, 0x38, 0xf9, 0x84, 0xba, 0x0a, 0x30, 0x0a, 0x71, 0x72, 0xb1, 0xba, 0x07, 0xb9, 0xba, 0xfa,
-	0x09, 0x30, 0x09, 0xb1, 0x73, 0x31, 0x07, 0xb9, 0xba, 0x08, 0x30, 0x3b, 0x39, 0x47, 0x39, 0xa6,
-	0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0xa7, 0xe7, 0xe7, 0x24, 0xe6, 0xa5,
-	0xeb, 0x83, 0x5d, 0x9b, 0x54, 0x9a, 0x06, 0x61, 0x24, 0xeb, 0xa6, 0xa7, 0xe6, 0xe9, 0xa6, 0xe7,
-	0xeb, 0x83, 0xec, 0x4a, 0x49, 0x2c, 0x49, 0x84, 0x78, 0xca, 0x1a, 0x6e, 0x3f, 0x20, 0x00, 0x00,
-	0xff, 0xff, 0x49, 0x3b, 0x52, 0x44, 0xec, 0x00, 0x00, 0x00,
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/multi/multi2.proto b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/multi/multi2.proto
deleted file mode 100644
index ec5b431e3..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/multi/multi2.proto
+++ /dev/null
@@ -1,48 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto2";
-
-package multitest;
-
-option go_package = "github.com/golang/protobuf/protoc-gen-go/testdata/multi;multitest";
-
-message Multi2 {
-  required int32 required_value = 1;
-
-  enum Color {
-    BLUE = 1;
-    GREEN = 2;
-    RED = 3;
-  };
-  optional Color color = 2;
-}
-
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/multi/multi3.pb.go b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/multi/multi3.pb.go
deleted file mode 100644
index f03c350a0..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/multi/multi3.pb.go
+++ /dev/null
@@ -1,115 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: multi/multi3.proto
-
-package multitest // import "github.com/golang/protobuf/protoc-gen-go/testdata/multi"
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-type Multi3_HatType int32
-
-const (
-	Multi3_FEDORA Multi3_HatType = 1
-	Multi3_FEZ    Multi3_HatType = 2
-)
-
-var Multi3_HatType_name = map[int32]string{
-	1: "FEDORA",
-	2: "FEZ",
-}
-var Multi3_HatType_value = map[string]int32{
-	"FEDORA": 1,
-	"FEZ":    2,
-}
-
-func (x Multi3_HatType) Enum() *Multi3_HatType {
-	p := new(Multi3_HatType)
-	*p = x
-	return p
-}
-func (x Multi3_HatType) String() string {
-	return proto.EnumName(Multi3_HatType_name, int32(x))
-}
-func (x *Multi3_HatType) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(Multi3_HatType_value, data, "Multi3_HatType")
-	if err != nil {
-		return err
-	}
-	*x = Multi3_HatType(value)
-	return nil
-}
-func (Multi3_HatType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_multi3_d55a72b4628b7875, []int{0, 0}
-}
-
-type Multi3 struct {
-	HatType              *Multi3_HatType `protobuf:"varint,1,opt,name=hat_type,json=hatType,enum=multitest.Multi3_HatType" json:"hat_type,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
-	XXX_unrecognized     []byte          `json:"-"`
-	XXX_sizecache        int32           `json:"-"`
-}
-
-func (m *Multi3) Reset()         { *m = Multi3{} }
-func (m *Multi3) String() string { return proto.CompactTextString(m) }
-func (*Multi3) ProtoMessage()    {}
-func (*Multi3) Descriptor() ([]byte, []int) {
-	return fileDescriptor_multi3_d55a72b4628b7875, []int{0}
-}
-func (m *Multi3) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Multi3.Unmarshal(m, b)
-}
-func (m *Multi3) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Multi3.Marshal(b, m, deterministic)
-}
-func (dst *Multi3) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Multi3.Merge(dst, src)
-}
-func (m *Multi3) XXX_Size() int {
-	return xxx_messageInfo_Multi3.Size(m)
-}
-func (m *Multi3) XXX_DiscardUnknown() {
-	xxx_messageInfo_Multi3.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Multi3 proto.InternalMessageInfo
-
-func (m *Multi3) GetHatType() Multi3_HatType {
-	if m != nil && m.HatType != nil {
-		return *m.HatType
-	}
-	return Multi3_FEDORA
-}
-
-func init() {
-	proto.RegisterType((*Multi3)(nil), "multitest.Multi3")
-	proto.RegisterEnum("multitest.Multi3_HatType", Multi3_HatType_name, Multi3_HatType_value)
-}
-
-func init() { proto.RegisterFile("multi/multi3.proto", fileDescriptor_multi3_d55a72b4628b7875) }
-
-var fileDescriptor_multi3_d55a72b4628b7875 = []byte{
-	// 170 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0xca, 0x2d, 0xcd, 0x29,
-	0xc9, 0xd4, 0x07, 0x93, 0xc6, 0x7a, 0x05, 0x45, 0xf9, 0x25, 0xf9, 0x42, 0x9c, 0x60, 0x5e, 0x49,
-	0x6a, 0x71, 0x89, 0x52, 0x1c, 0x17, 0x9b, 0x2f, 0x58, 0x4a, 0xc8, 0x84, 0x8b, 0x23, 0x23, 0xb1,
-	0x24, 0xbe, 0xa4, 0xb2, 0x20, 0x55, 0x82, 0x51, 0x81, 0x51, 0x83, 0xcf, 0x48, 0x52, 0x0f, 0xae,
-	0x4e, 0x0f, 0xa2, 0x48, 0xcf, 0x23, 0xb1, 0x24, 0xa4, 0xb2, 0x20, 0x35, 0x88, 0x3d, 0x03, 0xc2,
-	0x50, 0x92, 0xe3, 0x62, 0x87, 0x8a, 0x09, 0x71, 0x71, 0xb1, 0xb9, 0xb9, 0xba, 0xf8, 0x07, 0x39,
-	0x0a, 0x30, 0x0a, 0xb1, 0x73, 0x31, 0xbb, 0xb9, 0x46, 0x09, 0x30, 0x39, 0x39, 0x47, 0x39, 0xa6,
-	0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0xa7, 0xe7, 0xe7, 0x24, 0xe6, 0xa5,
-	0xeb, 0x83, 0x5d, 0x91, 0x54, 0x9a, 0x06, 0x61, 0x24, 0xeb, 0xa6, 0xa7, 0xe6, 0xe9, 0xa6, 0xe7,
-	0xeb, 0x83, 0x2c, 0x4a, 0x49, 0x2c, 0x49, 0x84, 0x38, 0xd6, 0x1a, 0x6e, 0x39, 0x20, 0x00, 0x00,
-	0xff, 0xff, 0xd5, 0xa4, 0x1a, 0x0e, 0xc4, 0x00, 0x00, 0x00,
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/multi/multi3.proto b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/multi/multi3.proto
deleted file mode 100644
index 8690b8815..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/multi/multi3.proto
+++ /dev/null
@@ -1,45 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto2";
-
-package multitest;
-
-option go_package = "github.com/golang/protobuf/protoc-gen-go/testdata/multi;multitest";
-
-message Multi3 {
-  enum HatType {
-    FEDORA = 1;
-    FEZ = 2;
-  };
-  optional HatType hat_type = 1;
-}
-
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/my_test/test.pb.go b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/my_test/test.pb.go
deleted file mode 100644
index 8cf6a698f..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/my_test/test.pb.go
+++ /dev/null
@@ -1,1174 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: my_test/test.proto
-
-package test // import "github.com/golang/protobuf/protoc-gen-go/testdata/my_test"
-
-/*
-This package holds interesting messages.
-*/
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-import _ "github.com/golang/protobuf/protoc-gen-go/testdata/multi"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-type HatType int32
-
-const (
-	// deliberately skipping 0
-	HatType_FEDORA HatType = 1
-	HatType_FEZ    HatType = 2
-)
-
-var HatType_name = map[int32]string{
-	1: "FEDORA",
-	2: "FEZ",
-}
-var HatType_value = map[string]int32{
-	"FEDORA": 1,
-	"FEZ":    2,
-}
-
-func (x HatType) Enum() *HatType {
-	p := new(HatType)
-	*p = x
-	return p
-}
-func (x HatType) String() string {
-	return proto.EnumName(HatType_name, int32(x))
-}
-func (x *HatType) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(HatType_value, data, "HatType")
-	if err != nil {
-		return err
-	}
-	*x = HatType(value)
-	return nil
-}
-func (HatType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_test_2309d445eee26af7, []int{0}
-}
-
-// This enum represents days of the week.
-type Days int32
-
-const (
-	Days_MONDAY  Days = 1
-	Days_TUESDAY Days = 2
-	Days_LUNDI   Days = 1
-)
-
-var Days_name = map[int32]string{
-	1: "MONDAY",
-	2: "TUESDAY",
-	// Duplicate value: 1: "LUNDI",
-}
-var Days_value = map[string]int32{
-	"MONDAY":  1,
-	"TUESDAY": 2,
-	"LUNDI":   1,
-}
-
-func (x Days) Enum() *Days {
-	p := new(Days)
-	*p = x
-	return p
-}
-func (x Days) String() string {
-	return proto.EnumName(Days_name, int32(x))
-}
-func (x *Days) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(Days_value, data, "Days")
-	if err != nil {
-		return err
-	}
-	*x = Days(value)
-	return nil
-}
-func (Days) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_test_2309d445eee26af7, []int{1}
-}
-
-type Request_Color int32
-
-const (
-	Request_RED   Request_Color = 0
-	Request_GREEN Request_Color = 1
-	Request_BLUE  Request_Color = 2
-)
-
-var Request_Color_name = map[int32]string{
-	0: "RED",
-	1: "GREEN",
-	2: "BLUE",
-}
-var Request_Color_value = map[string]int32{
-	"RED":   0,
-	"GREEN": 1,
-	"BLUE":  2,
-}
-
-func (x Request_Color) Enum() *Request_Color {
-	p := new(Request_Color)
-	*p = x
-	return p
-}
-func (x Request_Color) String() string {
-	return proto.EnumName(Request_Color_name, int32(x))
-}
-func (x *Request_Color) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(Request_Color_value, data, "Request_Color")
-	if err != nil {
-		return err
-	}
-	*x = Request_Color(value)
-	return nil
-}
-func (Request_Color) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_test_2309d445eee26af7, []int{0, 0}
-}
-
-type Reply_Entry_Game int32
-
-const (
-	Reply_Entry_FOOTBALL Reply_Entry_Game = 1
-	Reply_Entry_TENNIS   Reply_Entry_Game = 2
-)
-
-var Reply_Entry_Game_name = map[int32]string{
-	1: "FOOTBALL",
-	2: "TENNIS",
-}
-var Reply_Entry_Game_value = map[string]int32{
-	"FOOTBALL": 1,
-	"TENNIS":   2,
-}
-
-func (x Reply_Entry_Game) Enum() *Reply_Entry_Game {
-	p := new(Reply_Entry_Game)
-	*p = x
-	return p
-}
-func (x Reply_Entry_Game) String() string {
-	return proto.EnumName(Reply_Entry_Game_name, int32(x))
-}
-func (x *Reply_Entry_Game) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(Reply_Entry_Game_value, data, "Reply_Entry_Game")
-	if err != nil {
-		return err
-	}
-	*x = Reply_Entry_Game(value)
-	return nil
-}
-func (Reply_Entry_Game) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_test_2309d445eee26af7, []int{1, 0, 0}
-}
-
-// This is a message that might be sent somewhere.
-type Request struct {
-	Key []int64 `protobuf:"varint,1,rep,name=key" json:"key,omitempty"`
-	//  optional imp.ImportedMessage imported_message = 2;
-	Hue *Request_Color `protobuf:"varint,3,opt,name=hue,enum=my.test.Request_Color" json:"hue,omitempty"`
-	Hat *HatType       `protobuf:"varint,4,opt,name=hat,enum=my.test.HatType,def=1" json:"hat,omitempty"`
-	//  optional imp.ImportedMessage.Owner owner = 6;
-	Deadline  *float32           `protobuf:"fixed32,7,opt,name=deadline,def=inf" json:"deadline,omitempty"`
-	Somegroup *Request_SomeGroup `protobuf:"group,8,opt,name=SomeGroup,json=somegroup" json:"somegroup,omitempty"`
-	// This is a map field. It will generate map[int32]string.
-	NameMapping map[int32]string `protobuf:"bytes,14,rep,name=name_mapping,json=nameMapping" json:"name_mapping,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
-	// This is a map field whose value type is a message.
-	MsgMapping map[int64]*Reply `protobuf:"bytes,15,rep,name=msg_mapping,json=msgMapping" json:"msg_mapping,omitempty" protobuf_key:"zigzag64,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
-	Reset_     *int32           `protobuf:"varint,12,opt,name=reset" json:"reset,omitempty"`
-	// This field should not conflict with any getters.
-	GetKey_              *string  `protobuf:"bytes,16,opt,name=get_key,json=getKey" json:"get_key,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *Request) Reset()         { *m = Request{} }
-func (m *Request) String() string { return proto.CompactTextString(m) }
-func (*Request) ProtoMessage()    {}
-func (*Request) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_2309d445eee26af7, []int{0}
-}
-func (m *Request) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Request.Unmarshal(m, b)
-}
-func (m *Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Request.Marshal(b, m, deterministic)
-}
-func (dst *Request) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Request.Merge(dst, src)
-}
-func (m *Request) XXX_Size() int {
-	return xxx_messageInfo_Request.Size(m)
-}
-func (m *Request) XXX_DiscardUnknown() {
-	xxx_messageInfo_Request.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Request proto.InternalMessageInfo
-
-const Default_Request_Hat HatType = HatType_FEDORA
-
-var Default_Request_Deadline float32 = float32(math.Inf(1))
-
-func (m *Request) GetKey() []int64 {
-	if m != nil {
-		return m.Key
-	}
-	return nil
-}
-
-func (m *Request) GetHue() Request_Color {
-	if m != nil && m.Hue != nil {
-		return *m.Hue
-	}
-	return Request_RED
-}
-
-func (m *Request) GetHat() HatType {
-	if m != nil && m.Hat != nil {
-		return *m.Hat
-	}
-	return Default_Request_Hat
-}
-
-func (m *Request) GetDeadline() float32 {
-	if m != nil && m.Deadline != nil {
-		return *m.Deadline
-	}
-	return Default_Request_Deadline
-}
-
-func (m *Request) GetSomegroup() *Request_SomeGroup {
-	if m != nil {
-		return m.Somegroup
-	}
-	return nil
-}
-
-func (m *Request) GetNameMapping() map[int32]string {
-	if m != nil {
-		return m.NameMapping
-	}
-	return nil
-}
-
-func (m *Request) GetMsgMapping() map[int64]*Reply {
-	if m != nil {
-		return m.MsgMapping
-	}
-	return nil
-}
-
-func (m *Request) GetReset_() int32 {
-	if m != nil && m.Reset_ != nil {
-		return *m.Reset_
-	}
-	return 0
-}
-
-func (m *Request) GetGetKey_() string {
-	if m != nil && m.GetKey_ != nil {
-		return *m.GetKey_
-	}
-	return ""
-}
-
-type Request_SomeGroup struct {
-	GroupField           *int32   `protobuf:"varint,9,opt,name=group_field,json=groupField" json:"group_field,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *Request_SomeGroup) Reset()         { *m = Request_SomeGroup{} }
-func (m *Request_SomeGroup) String() string { return proto.CompactTextString(m) }
-func (*Request_SomeGroup) ProtoMessage()    {}
-func (*Request_SomeGroup) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_2309d445eee26af7, []int{0, 0}
-}
-func (m *Request_SomeGroup) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Request_SomeGroup.Unmarshal(m, b)
-}
-func (m *Request_SomeGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Request_SomeGroup.Marshal(b, m, deterministic)
-}
-func (dst *Request_SomeGroup) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Request_SomeGroup.Merge(dst, src)
-}
-func (m *Request_SomeGroup) XXX_Size() int {
-	return xxx_messageInfo_Request_SomeGroup.Size(m)
-}
-func (m *Request_SomeGroup) XXX_DiscardUnknown() {
-	xxx_messageInfo_Request_SomeGroup.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Request_SomeGroup proto.InternalMessageInfo
-
-func (m *Request_SomeGroup) GetGroupField() int32 {
-	if m != nil && m.GroupField != nil {
-		return *m.GroupField
-	}
-	return 0
-}
-
-type Reply struct {
-	Found                        []*Reply_Entry `protobuf:"bytes,1,rep,name=found" json:"found,omitempty"`
-	CompactKeys                  []int32        `protobuf:"varint,2,rep,packed,name=compact_keys,json=compactKeys" json:"compact_keys,omitempty"`
-	XXX_NoUnkeyedLiteral         struct{}       `json:"-"`
-	proto.XXX_InternalExtensions `json:"-"`
-	XXX_unrecognized             []byte `json:"-"`
-	XXX_sizecache                int32  `json:"-"`
-}
-
-func (m *Reply) Reset()         { *m = Reply{} }
-func (m *Reply) String() string { return proto.CompactTextString(m) }
-func (*Reply) ProtoMessage()    {}
-func (*Reply) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_2309d445eee26af7, []int{1}
-}
-
-var extRange_Reply = []proto.ExtensionRange{
-	{Start: 100, End: 536870911},
-}
-
-func (*Reply) ExtensionRangeArray() []proto.ExtensionRange {
-	return extRange_Reply
-}
-func (m *Reply) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Reply.Unmarshal(m, b)
-}
-func (m *Reply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Reply.Marshal(b, m, deterministic)
-}
-func (dst *Reply) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Reply.Merge(dst, src)
-}
-func (m *Reply) XXX_Size() int {
-	return xxx_messageInfo_Reply.Size(m)
-}
-func (m *Reply) XXX_DiscardUnknown() {
-	xxx_messageInfo_Reply.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Reply proto.InternalMessageInfo
-
-func (m *Reply) GetFound() []*Reply_Entry {
-	if m != nil {
-		return m.Found
-	}
-	return nil
-}
-
-func (m *Reply) GetCompactKeys() []int32 {
-	if m != nil {
-		return m.CompactKeys
-	}
-	return nil
-}
-
-type Reply_Entry struct {
-	KeyThatNeeds_1234Camel_CasIng *int64   `protobuf:"varint,1,req,name=key_that_needs_1234camel_CasIng,json=keyThatNeeds1234camelCasIng" json:"key_that_needs_1234camel_CasIng,omitempty"`
-	Value                         *int64   `protobuf:"varint,2,opt,name=value,def=7" json:"value,omitempty"`
-	XMyFieldName_2                *int64   `protobuf:"varint,3,opt,name=_my_field_name_2,json=MyFieldName2" json:"_my_field_name_2,omitempty"`
-	XXX_NoUnkeyedLiteral          struct{} `json:"-"`
-	XXX_unrecognized              []byte   `json:"-"`
-	XXX_sizecache                 int32    `json:"-"`
-}
-
-func (m *Reply_Entry) Reset()         { *m = Reply_Entry{} }
-func (m *Reply_Entry) String() string { return proto.CompactTextString(m) }
-func (*Reply_Entry) ProtoMessage()    {}
-func (*Reply_Entry) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_2309d445eee26af7, []int{1, 0}
-}
-func (m *Reply_Entry) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Reply_Entry.Unmarshal(m, b)
-}
-func (m *Reply_Entry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Reply_Entry.Marshal(b, m, deterministic)
-}
-func (dst *Reply_Entry) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Reply_Entry.Merge(dst, src)
-}
-func (m *Reply_Entry) XXX_Size() int {
-	return xxx_messageInfo_Reply_Entry.Size(m)
-}
-func (m *Reply_Entry) XXX_DiscardUnknown() {
-	xxx_messageInfo_Reply_Entry.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Reply_Entry proto.InternalMessageInfo
-
-const Default_Reply_Entry_Value int64 = 7
-
-func (m *Reply_Entry) GetKeyThatNeeds_1234Camel_CasIng() int64 {
-	if m != nil && m.KeyThatNeeds_1234Camel_CasIng != nil {
-		return *m.KeyThatNeeds_1234Camel_CasIng
-	}
-	return 0
-}
-
-func (m *Reply_Entry) GetValue() int64 {
-	if m != nil && m.Value != nil {
-		return *m.Value
-	}
-	return Default_Reply_Entry_Value
-}
-
-func (m *Reply_Entry) GetXMyFieldName_2() int64 {
-	if m != nil && m.XMyFieldName_2 != nil {
-		return *m.XMyFieldName_2
-	}
-	return 0
-}
-
-type OtherBase struct {
-	Name                         *string  `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
-	XXX_NoUnkeyedLiteral         struct{} `json:"-"`
-	proto.XXX_InternalExtensions `json:"-"`
-	XXX_unrecognized             []byte `json:"-"`
-	XXX_sizecache                int32  `json:"-"`
-}
-
-func (m *OtherBase) Reset()         { *m = OtherBase{} }
-func (m *OtherBase) String() string { return proto.CompactTextString(m) }
-func (*OtherBase) ProtoMessage()    {}
-func (*OtherBase) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_2309d445eee26af7, []int{2}
-}
-
-var extRange_OtherBase = []proto.ExtensionRange{
-	{Start: 100, End: 536870911},
-}
-
-func (*OtherBase) ExtensionRangeArray() []proto.ExtensionRange {
-	return extRange_OtherBase
-}
-func (m *OtherBase) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_OtherBase.Unmarshal(m, b)
-}
-func (m *OtherBase) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_OtherBase.Marshal(b, m, deterministic)
-}
-func (dst *OtherBase) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_OtherBase.Merge(dst, src)
-}
-func (m *OtherBase) XXX_Size() int {
-	return xxx_messageInfo_OtherBase.Size(m)
-}
-func (m *OtherBase) XXX_DiscardUnknown() {
-	xxx_messageInfo_OtherBase.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_OtherBase proto.InternalMessageInfo
-
-func (m *OtherBase) GetName() string {
-	if m != nil && m.Name != nil {
-		return *m.Name
-	}
-	return ""
-}
-
-type ReplyExtensions struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *ReplyExtensions) Reset()         { *m = ReplyExtensions{} }
-func (m *ReplyExtensions) String() string { return proto.CompactTextString(m) }
-func (*ReplyExtensions) ProtoMessage()    {}
-func (*ReplyExtensions) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_2309d445eee26af7, []int{3}
-}
-func (m *ReplyExtensions) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ReplyExtensions.Unmarshal(m, b)
-}
-func (m *ReplyExtensions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ReplyExtensions.Marshal(b, m, deterministic)
-}
-func (dst *ReplyExtensions) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ReplyExtensions.Merge(dst, src)
-}
-func (m *ReplyExtensions) XXX_Size() int {
-	return xxx_messageInfo_ReplyExtensions.Size(m)
-}
-func (m *ReplyExtensions) XXX_DiscardUnknown() {
-	xxx_messageInfo_ReplyExtensions.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ReplyExtensions proto.InternalMessageInfo
-
-var E_ReplyExtensions_Time = &proto.ExtensionDesc{
-	ExtendedType:  (*Reply)(nil),
-	ExtensionType: (*float64)(nil),
-	Field:         101,
-	Name:          "my.test.ReplyExtensions.time",
-	Tag:           "fixed64,101,opt,name=time",
-	Filename:      "my_test/test.proto",
-}
-
-var E_ReplyExtensions_Carrot = &proto.ExtensionDesc{
-	ExtendedType:  (*Reply)(nil),
-	ExtensionType: (*ReplyExtensions)(nil),
-	Field:         105,
-	Name:          "my.test.ReplyExtensions.carrot",
-	Tag:           "bytes,105,opt,name=carrot",
-	Filename:      "my_test/test.proto",
-}
-
-var E_ReplyExtensions_Donut = &proto.ExtensionDesc{
-	ExtendedType:  (*OtherBase)(nil),
-	ExtensionType: (*ReplyExtensions)(nil),
-	Field:         101,
-	Name:          "my.test.ReplyExtensions.donut",
-	Tag:           "bytes,101,opt,name=donut",
-	Filename:      "my_test/test.proto",
-}
-
-type OtherReplyExtensions struct {
-	Key                  *int32   `protobuf:"varint,1,opt,name=key" json:"key,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *OtherReplyExtensions) Reset()         { *m = OtherReplyExtensions{} }
-func (m *OtherReplyExtensions) String() string { return proto.CompactTextString(m) }
-func (*OtherReplyExtensions) ProtoMessage()    {}
-func (*OtherReplyExtensions) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_2309d445eee26af7, []int{4}
-}
-func (m *OtherReplyExtensions) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_OtherReplyExtensions.Unmarshal(m, b)
-}
-func (m *OtherReplyExtensions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_OtherReplyExtensions.Marshal(b, m, deterministic)
-}
-func (dst *OtherReplyExtensions) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_OtherReplyExtensions.Merge(dst, src)
-}
-func (m *OtherReplyExtensions) XXX_Size() int {
-	return xxx_messageInfo_OtherReplyExtensions.Size(m)
-}
-func (m *OtherReplyExtensions) XXX_DiscardUnknown() {
-	xxx_messageInfo_OtherReplyExtensions.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_OtherReplyExtensions proto.InternalMessageInfo
-
-func (m *OtherReplyExtensions) GetKey() int32 {
-	if m != nil && m.Key != nil {
-		return *m.Key
-	}
-	return 0
-}
-
-type OldReply struct {
-	XXX_NoUnkeyedLiteral         struct{} `json:"-"`
-	proto.XXX_InternalExtensions `protobuf_messageset:"1" json:"-"`
-	XXX_unrecognized             []byte `json:"-"`
-	XXX_sizecache                int32  `json:"-"`
-}
-
-func (m *OldReply) Reset()         { *m = OldReply{} }
-func (m *OldReply) String() string { return proto.CompactTextString(m) }
-func (*OldReply) ProtoMessage()    {}
-func (*OldReply) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_2309d445eee26af7, []int{5}
-}
-
-func (m *OldReply) MarshalJSON() ([]byte, error) {
-	return proto.MarshalMessageSetJSON(&m.XXX_InternalExtensions)
-}
-func (m *OldReply) UnmarshalJSON(buf []byte) error {
-	return proto.UnmarshalMessageSetJSON(buf, &m.XXX_InternalExtensions)
-}
-
-var extRange_OldReply = []proto.ExtensionRange{
-	{Start: 100, End: 2147483646},
-}
-
-func (*OldReply) ExtensionRangeArray() []proto.ExtensionRange {
-	return extRange_OldReply
-}
-func (m *OldReply) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_OldReply.Unmarshal(m, b)
-}
-func (m *OldReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_OldReply.Marshal(b, m, deterministic)
-}
-func (dst *OldReply) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_OldReply.Merge(dst, src)
-}
-func (m *OldReply) XXX_Size() int {
-	return xxx_messageInfo_OldReply.Size(m)
-}
-func (m *OldReply) XXX_DiscardUnknown() {
-	xxx_messageInfo_OldReply.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_OldReply proto.InternalMessageInfo
-
-type Communique struct {
-	MakeMeCry *bool `protobuf:"varint,1,opt,name=make_me_cry,json=makeMeCry" json:"make_me_cry,omitempty"`
-	// This is a oneof, called "union".
-	//
-	// Types that are valid to be assigned to Union:
-	//	*Communique_Number
-	//	*Communique_Name
-	//	*Communique_Data
-	//	*Communique_TempC
-	//	*Communique_Height
-	//	*Communique_Today
-	//	*Communique_Maybe
-	//	*Communique_Delta_
-	//	*Communique_Msg
-	//	*Communique_Somegroup
-	Union                isCommunique_Union `protobuf_oneof:"union"`
-	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
-	XXX_unrecognized     []byte             `json:"-"`
-	XXX_sizecache        int32              `json:"-"`
-}
-
-func (m *Communique) Reset()         { *m = Communique{} }
-func (m *Communique) String() string { return proto.CompactTextString(m) }
-func (*Communique) ProtoMessage()    {}
-func (*Communique) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_2309d445eee26af7, []int{6}
-}
-func (m *Communique) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Communique.Unmarshal(m, b)
-}
-func (m *Communique) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Communique.Marshal(b, m, deterministic)
-}
-func (dst *Communique) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Communique.Merge(dst, src)
-}
-func (m *Communique) XXX_Size() int {
-	return xxx_messageInfo_Communique.Size(m)
-}
-func (m *Communique) XXX_DiscardUnknown() {
-	xxx_messageInfo_Communique.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Communique proto.InternalMessageInfo
-
-type isCommunique_Union interface {
-	isCommunique_Union()
-}
-
-type Communique_Number struct {
-	Number int32 `protobuf:"varint,5,opt,name=number,oneof"`
-}
-type Communique_Name struct {
-	Name string `protobuf:"bytes,6,opt,name=name,oneof"`
-}
-type Communique_Data struct {
-	Data []byte `protobuf:"bytes,7,opt,name=data,oneof"`
-}
-type Communique_TempC struct {
-	TempC float64 `protobuf:"fixed64,8,opt,name=temp_c,json=tempC,oneof"`
-}
-type Communique_Height struct {
-	Height float32 `protobuf:"fixed32,9,opt,name=height,oneof"`
-}
-type Communique_Today struct {
-	Today Days `protobuf:"varint,10,opt,name=today,enum=my.test.Days,oneof"`
-}
-type Communique_Maybe struct {
-	Maybe bool `protobuf:"varint,11,opt,name=maybe,oneof"`
-}
-type Communique_Delta_ struct {
-	Delta int32 `protobuf:"zigzag32,12,opt,name=delta,oneof"`
-}
-type Communique_Msg struct {
-	Msg *Reply `protobuf:"bytes,16,opt,name=msg,oneof"`
-}
-type Communique_Somegroup struct {
-	Somegroup *Communique_SomeGroup `protobuf:"group,14,opt,name=SomeGroup,json=somegroup,oneof"`
-}
-
-func (*Communique_Number) isCommunique_Union()    {}
-func (*Communique_Name) isCommunique_Union()      {}
-func (*Communique_Data) isCommunique_Union()      {}
-func (*Communique_TempC) isCommunique_Union()     {}
-func (*Communique_Height) isCommunique_Union()    {}
-func (*Communique_Today) isCommunique_Union()     {}
-func (*Communique_Maybe) isCommunique_Union()     {}
-func (*Communique_Delta_) isCommunique_Union()    {}
-func (*Communique_Msg) isCommunique_Union()       {}
-func (*Communique_Somegroup) isCommunique_Union() {}
-
-func (m *Communique) GetUnion() isCommunique_Union {
-	if m != nil {
-		return m.Union
-	}
-	return nil
-}
-
-func (m *Communique) GetMakeMeCry() bool {
-	if m != nil && m.MakeMeCry != nil {
-		return *m.MakeMeCry
-	}
-	return false
-}
-
-func (m *Communique) GetNumber() int32 {
-	if x, ok := m.GetUnion().(*Communique_Number); ok {
-		return x.Number
-	}
-	return 0
-}
-
-func (m *Communique) GetName() string {
-	if x, ok := m.GetUnion().(*Communique_Name); ok {
-		return x.Name
-	}
-	return ""
-}
-
-func (m *Communique) GetData() []byte {
-	if x, ok := m.GetUnion().(*Communique_Data); ok {
-		return x.Data
-	}
-	return nil
-}
-
-func (m *Communique) GetTempC() float64 {
-	if x, ok := m.GetUnion().(*Communique_TempC); ok {
-		return x.TempC
-	}
-	return 0
-}
-
-func (m *Communique) GetHeight() float32 {
-	if x, ok := m.GetUnion().(*Communique_Height); ok {
-		return x.Height
-	}
-	return 0
-}
-
-func (m *Communique) GetToday() Days {
-	if x, ok := m.GetUnion().(*Communique_Today); ok {
-		return x.Today
-	}
-	return Days_MONDAY
-}
-
-func (m *Communique) GetMaybe() bool {
-	if x, ok := m.GetUnion().(*Communique_Maybe); ok {
-		return x.Maybe
-	}
-	return false
-}
-
-func (m *Communique) GetDelta() int32 {
-	if x, ok := m.GetUnion().(*Communique_Delta_); ok {
-		return x.Delta
-	}
-	return 0
-}
-
-func (m *Communique) GetMsg() *Reply {
-	if x, ok := m.GetUnion().(*Communique_Msg); ok {
-		return x.Msg
-	}
-	return nil
-}
-
-func (m *Communique) GetSomegroup() *Communique_SomeGroup {
-	if x, ok := m.GetUnion().(*Communique_Somegroup); ok {
-		return x.Somegroup
-	}
-	return nil
-}
-
-// XXX_OneofFuncs is for the internal use of the proto package.
-func (*Communique) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
-	return _Communique_OneofMarshaler, _Communique_OneofUnmarshaler, _Communique_OneofSizer, []interface{}{
-		(*Communique_Number)(nil),
-		(*Communique_Name)(nil),
-		(*Communique_Data)(nil),
-		(*Communique_TempC)(nil),
-		(*Communique_Height)(nil),
-		(*Communique_Today)(nil),
-		(*Communique_Maybe)(nil),
-		(*Communique_Delta_)(nil),
-		(*Communique_Msg)(nil),
-		(*Communique_Somegroup)(nil),
-	}
-}
-
-func _Communique_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
-	m := msg.(*Communique)
-	// union
-	switch x := m.Union.(type) {
-	case *Communique_Number:
-		b.EncodeVarint(5<<3 | proto.WireVarint)
-		b.EncodeVarint(uint64(x.Number))
-	case *Communique_Name:
-		b.EncodeVarint(6<<3 | proto.WireBytes)
-		b.EncodeStringBytes(x.Name)
-	case *Communique_Data:
-		b.EncodeVarint(7<<3 | proto.WireBytes)
-		b.EncodeRawBytes(x.Data)
-	case *Communique_TempC:
-		b.EncodeVarint(8<<3 | proto.WireFixed64)
-		b.EncodeFixed64(math.Float64bits(x.TempC))
-	case *Communique_Height:
-		b.EncodeVarint(9<<3 | proto.WireFixed32)
-		b.EncodeFixed32(uint64(math.Float32bits(x.Height)))
-	case *Communique_Today:
-		b.EncodeVarint(10<<3 | proto.WireVarint)
-		b.EncodeVarint(uint64(x.Today))
-	case *Communique_Maybe:
-		t := uint64(0)
-		if x.Maybe {
-			t = 1
-		}
-		b.EncodeVarint(11<<3 | proto.WireVarint)
-		b.EncodeVarint(t)
-	case *Communique_Delta_:
-		b.EncodeVarint(12<<3 | proto.WireVarint)
-		b.EncodeZigzag32(uint64(x.Delta))
-	case *Communique_Msg:
-		b.EncodeVarint(16<<3 | proto.WireBytes)
-		if err := b.EncodeMessage(x.Msg); err != nil {
-			return err
-		}
-	case *Communique_Somegroup:
-		b.EncodeVarint(14<<3 | proto.WireStartGroup)
-		if err := b.Marshal(x.Somegroup); err != nil {
-			return err
-		}
-		b.EncodeVarint(14<<3 | proto.WireEndGroup)
-	case nil:
-	default:
-		return fmt.Errorf("Communique.Union has unexpected type %T", x)
-	}
-	return nil
-}
-
-func _Communique_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
-	m := msg.(*Communique)
-	switch tag {
-	case 5: // union.number
-		if wire != proto.WireVarint {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeVarint()
-		m.Union = &Communique_Number{int32(x)}
-		return true, err
-	case 6: // union.name
-		if wire != proto.WireBytes {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeStringBytes()
-		m.Union = &Communique_Name{x}
-		return true, err
-	case 7: // union.data
-		if wire != proto.WireBytes {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeRawBytes(true)
-		m.Union = &Communique_Data{x}
-		return true, err
-	case 8: // union.temp_c
-		if wire != proto.WireFixed64 {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeFixed64()
-		m.Union = &Communique_TempC{math.Float64frombits(x)}
-		return true, err
-	case 9: // union.height
-		if wire != proto.WireFixed32 {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeFixed32()
-		m.Union = &Communique_Height{math.Float32frombits(uint32(x))}
-		return true, err
-	case 10: // union.today
-		if wire != proto.WireVarint {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeVarint()
-		m.Union = &Communique_Today{Days(x)}
-		return true, err
-	case 11: // union.maybe
-		if wire != proto.WireVarint {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeVarint()
-		m.Union = &Communique_Maybe{x != 0}
-		return true, err
-	case 12: // union.delta
-		if wire != proto.WireVarint {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeZigzag32()
-		m.Union = &Communique_Delta_{int32(x)}
-		return true, err
-	case 16: // union.msg
-		if wire != proto.WireBytes {
-			return true, proto.ErrInternalBadWireType
-		}
-		msg := new(Reply)
-		err := b.DecodeMessage(msg)
-		m.Union = &Communique_Msg{msg}
-		return true, err
-	case 14: // union.somegroup
-		if wire != proto.WireStartGroup {
-			return true, proto.ErrInternalBadWireType
-		}
-		msg := new(Communique_SomeGroup)
-		err := b.DecodeGroup(msg)
-		m.Union = &Communique_Somegroup{msg}
-		return true, err
-	default:
-		return false, nil
-	}
-}
-
-func _Communique_OneofSizer(msg proto.Message) (n int) {
-	m := msg.(*Communique)
-	// union
-	switch x := m.Union.(type) {
-	case *Communique_Number:
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(x.Number))
-	case *Communique_Name:
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(len(x.Name)))
-		n += len(x.Name)
-	case *Communique_Data:
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(len(x.Data)))
-		n += len(x.Data)
-	case *Communique_TempC:
-		n += 1 // tag and wire
-		n += 8
-	case *Communique_Height:
-		n += 1 // tag and wire
-		n += 4
-	case *Communique_Today:
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(x.Today))
-	case *Communique_Maybe:
-		n += 1 // tag and wire
-		n += 1
-	case *Communique_Delta_:
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64((uint32(x.Delta) << 1) ^ uint32((int32(x.Delta) >> 31))))
-	case *Communique_Msg:
-		s := proto.Size(x.Msg)
-		n += 2 // tag and wire
-		n += proto.SizeVarint(uint64(s))
-		n += s
-	case *Communique_Somegroup:
-		n += 1 // tag and wire
-		n += proto.Size(x.Somegroup)
-		n += 1 // tag and wire
-	case nil:
-	default:
-		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
-	}
-	return n
-}
-
-type Communique_SomeGroup struct {
-	Member               *string  `protobuf:"bytes,15,opt,name=member" json:"member,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *Communique_SomeGroup) Reset()         { *m = Communique_SomeGroup{} }
-func (m *Communique_SomeGroup) String() string { return proto.CompactTextString(m) }
-func (*Communique_SomeGroup) ProtoMessage()    {}
-func (*Communique_SomeGroup) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_2309d445eee26af7, []int{6, 0}
-}
-func (m *Communique_SomeGroup) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Communique_SomeGroup.Unmarshal(m, b)
-}
-func (m *Communique_SomeGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Communique_SomeGroup.Marshal(b, m, deterministic)
-}
-func (dst *Communique_SomeGroup) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Communique_SomeGroup.Merge(dst, src)
-}
-func (m *Communique_SomeGroup) XXX_Size() int {
-	return xxx_messageInfo_Communique_SomeGroup.Size(m)
-}
-func (m *Communique_SomeGroup) XXX_DiscardUnknown() {
-	xxx_messageInfo_Communique_SomeGroup.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Communique_SomeGroup proto.InternalMessageInfo
-
-func (m *Communique_SomeGroup) GetMember() string {
-	if m != nil && m.Member != nil {
-		return *m.Member
-	}
-	return ""
-}
-
-type Communique_Delta struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *Communique_Delta) Reset()         { *m = Communique_Delta{} }
-func (m *Communique_Delta) String() string { return proto.CompactTextString(m) }
-func (*Communique_Delta) ProtoMessage()    {}
-func (*Communique_Delta) Descriptor() ([]byte, []int) {
-	return fileDescriptor_test_2309d445eee26af7, []int{6, 1}
-}
-func (m *Communique_Delta) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Communique_Delta.Unmarshal(m, b)
-}
-func (m *Communique_Delta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Communique_Delta.Marshal(b, m, deterministic)
-}
-func (dst *Communique_Delta) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Communique_Delta.Merge(dst, src)
-}
-func (m *Communique_Delta) XXX_Size() int {
-	return xxx_messageInfo_Communique_Delta.Size(m)
-}
-func (m *Communique_Delta) XXX_DiscardUnknown() {
-	xxx_messageInfo_Communique_Delta.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Communique_Delta proto.InternalMessageInfo
-
-var E_Tag = &proto.ExtensionDesc{
-	ExtendedType:  (*Reply)(nil),
-	ExtensionType: (*string)(nil),
-	Field:         103,
-	Name:          "my.test.tag",
-	Tag:           "bytes,103,opt,name=tag",
-	Filename:      "my_test/test.proto",
-}
-
-var E_Donut = &proto.ExtensionDesc{
-	ExtendedType:  (*Reply)(nil),
-	ExtensionType: (*OtherReplyExtensions)(nil),
-	Field:         106,
-	Name:          "my.test.donut",
-	Tag:           "bytes,106,opt,name=donut",
-	Filename:      "my_test/test.proto",
-}
-
-func init() {
-	proto.RegisterType((*Request)(nil), "my.test.Request")
-	proto.RegisterMapType((map[int64]*Reply)(nil), "my.test.Request.MsgMappingEntry")
-	proto.RegisterMapType((map[int32]string)(nil), "my.test.Request.NameMappingEntry")
-	proto.RegisterType((*Request_SomeGroup)(nil), "my.test.Request.SomeGroup")
-	proto.RegisterType((*Reply)(nil), "my.test.Reply")
-	proto.RegisterType((*Reply_Entry)(nil), "my.test.Reply.Entry")
-	proto.RegisterType((*OtherBase)(nil), "my.test.OtherBase")
-	proto.RegisterType((*ReplyExtensions)(nil), "my.test.ReplyExtensions")
-	proto.RegisterType((*OtherReplyExtensions)(nil), "my.test.OtherReplyExtensions")
-	proto.RegisterType((*OldReply)(nil), "my.test.OldReply")
-	proto.RegisterType((*Communique)(nil), "my.test.Communique")
-	proto.RegisterType((*Communique_SomeGroup)(nil), "my.test.Communique.SomeGroup")
-	proto.RegisterType((*Communique_Delta)(nil), "my.test.Communique.Delta")
-	proto.RegisterEnum("my.test.HatType", HatType_name, HatType_value)
-	proto.RegisterEnum("my.test.Days", Days_name, Days_value)
-	proto.RegisterEnum("my.test.Request_Color", Request_Color_name, Request_Color_value)
-	proto.RegisterEnum("my.test.Reply_Entry_Game", Reply_Entry_Game_name, Reply_Entry_Game_value)
-	proto.RegisterExtension(E_ReplyExtensions_Time)
-	proto.RegisterExtension(E_ReplyExtensions_Carrot)
-	proto.RegisterExtension(E_ReplyExtensions_Donut)
-	proto.RegisterExtension(E_Tag)
-	proto.RegisterExtension(E_Donut)
-}
-
-func init() { proto.RegisterFile("my_test/test.proto", fileDescriptor_test_2309d445eee26af7) }
-
-var fileDescriptor_test_2309d445eee26af7 = []byte{
-	// 1033 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x55, 0xdd, 0x6e, 0xe3, 0x44,
-	0x14, 0xce, 0xd8, 0x71, 0x7e, 0x4e, 0x42, 0x6b, 0x46, 0x55, 0x6b, 0x05, 0xed, 0xd6, 0x04, 0x8a,
-	0x4c, 0xc5, 0xa6, 0xda, 0x80, 0xc4, 0x2a, 0x88, 0xd5, 0x36, 0x3f, 0x6d, 0xaa, 0x6d, 0x12, 0x69,
-	0xda, 0x5e, 0xb0, 0x37, 0xd6, 0x34, 0x9e, 0x3a, 0xa6, 0x19, 0x3b, 0x6b, 0x8f, 0x11, 0xbe, 0xeb,
-	0x53, 0xc0, 0x6b, 0x70, 0xcf, 0x0b, 0xf1, 0x16, 0x45, 0x33, 0x0e, 0x49, 0xda, 0xa0, 0xbd, 0xb1,
-	0x7c, 0xce, 0xf9, 0xce, 0xe7, 0x39, 0x3f, 0xfe, 0x06, 0x30, 0xcf, 0x5c, 0xc1, 0x12, 0x71, 0x22,
-	0x1f, 0xad, 0x45, 0x1c, 0x89, 0x08, 0x97, 0x79, 0xd6, 0x92, 0x66, 0x03, 0xf3, 0x74, 0x2e, 0x82,
-	0x13, 0xf5, 0x7c, 0x9d, 0x07, 0x9b, 0xff, 0x14, 0xa1, 0x4c, 0xd8, 0xc7, 0x94, 0x25, 0x02, 0x9b,
-	0xa0, 0xdf, 0xb3, 0xcc, 0x42, 0xb6, 0xee, 0xe8, 0x44, 0xbe, 0x62, 0x07, 0xf4, 0x59, 0xca, 0x2c,
-	0xdd, 0x46, 0xce, 0x4e, 0x7b, 0xbf, 0xb5, 0x24, 0x6a, 0x2d, 0x13, 0x5a, 0xbd, 0x68, 0x1e, 0xc5,
-	0x44, 0x42, 0xf0, 0x31, 0xe8, 0x33, 0x2a, 0xac, 0xa2, 0x42, 0x9a, 0x2b, 0xe4, 0x90, 0x8a, 0xeb,
-	0x6c, 0xc1, 0x3a, 0xa5, 0xb3, 0x41, 0x7f, 0x42, 0x4e, 0x89, 0x04, 0xe1, 0x43, 0xa8, 0x78, 0x8c,
-	0x7a, 0xf3, 0x20, 0x64, 0x56, 0xd9, 0x46, 0x8e, 0xd6, 0xd1, 0x83, 0xf0, 0x8e, 0xac, 0x9c, 0xf8,
-	0x0d, 0x54, 0x93, 0x88, 0x33, 0x3f, 0x8e, 0xd2, 0x85, 0x55, 0xb1, 0x91, 0x03, 0xed, 0xc6, 0xd6,
-	0xc7, 0xaf, 0x22, 0xce, 0xce, 0x25, 0x82, 0xac, 0xc1, 0xb8, 0x0f, 0xf5, 0x90, 0x72, 0xe6, 0x72,
-	0xba, 0x58, 0x04, 0xa1, 0x6f, 0xed, 0xd8, 0xba, 0x53, 0x6b, 0x7f, 0xb9, 0x95, 0x3c, 0xa6, 0x9c,
-	0x8d, 0x72, 0xcc, 0x20, 0x14, 0x71, 0x46, 0x6a, 0xe1, 0xda, 0x83, 0x4f, 0xa1, 0xc6, 0x13, 0x7f,
-	0x45, 0xb2, 0xab, 0x48, 0xec, 0x2d, 0x92, 0x51, 0xe2, 0x3f, 0xe1, 0x00, 0xbe, 0x72, 0xe0, 0x3d,
-	0x30, 0x62, 0x96, 0x30, 0x61, 0xd5, 0x6d, 0xe4, 0x18, 0x24, 0x37, 0xf0, 0x01, 0x94, 0x7d, 0x26,
-	0x5c, 0xd9, 0x65, 0xd3, 0x46, 0x4e, 0x95, 0x94, 0x7c, 0x26, 0xde, 0xb3, 0xac, 0xf1, 0x1d, 0x54,
-	0x57, 0xf5, 0xe0, 0x43, 0xa8, 0xa9, 0x6a, 0xdc, 0xbb, 0x80, 0xcd, 0x3d, 0xab, 0xaa, 0x18, 0x40,
-	0xb9, 0xce, 0xa4, 0xa7, 0xf1, 0x16, 0xcc, 0xe7, 0x05, 0xac, 0x87, 0x27, 0xc1, 0x6a, 0x78, 0x7b,
-	0x60, 0xfc, 0x46, 0xe7, 0x29, 0xb3, 0x34, 0xf5, 0xa9, 0xdc, 0xe8, 0x68, 0x6f, 0x50, 0x63, 0x04,
-	0xbb, 0xcf, 0xce, 0xbe, 0x99, 0x8e, 0xf3, 0xf4, 0xaf, 0x37, 0xd3, 0x6b, 0xed, 0x9d, 0x8d, 0xf2,
-	0x17, 0xf3, 0x6c, 0x83, 0xae, 0x79, 0x04, 0x86, 0xda, 0x04, 0x5c, 0x06, 0x9d, 0x0c, 0xfa, 0x66,
-	0x01, 0x57, 0xc1, 0x38, 0x27, 0x83, 0xc1, 0xd8, 0x44, 0xb8, 0x02, 0xc5, 0xee, 0xe5, 0xcd, 0xc0,
-	0xd4, 0x9a, 0x7f, 0x6a, 0x60, 0xa8, 0x5c, 0x7c, 0x0c, 0xc6, 0x5d, 0x94, 0x86, 0x9e, 0x5a, 0xb5,
-	0x5a, 0x7b, 0xef, 0x29, 0x75, 0x2b, 0xef, 0x66, 0x0e, 0xc1, 0x47, 0x50, 0x9f, 0x46, 0x7c, 0x41,
-	0xa7, 0xaa, 0x6d, 0x89, 0xa5, 0xd9, 0xba, 0x63, 0x74, 0x35, 0x13, 0x91, 0xda, 0xd2, 0xff, 0x9e,
-	0x65, 0x49, 0xe3, 0x2f, 0x04, 0x46, 0x5e, 0x49, 0x1f, 0x0e, 0xef, 0x59, 0xe6, 0x8a, 0x19, 0x15,
-	0x6e, 0xc8, 0x98, 0x97, 0xb8, 0xaf, 0xdb, 0xdf, 0xff, 0x30, 0xa5, 0x9c, 0xcd, 0xdd, 0x1e, 0x4d,
-	0x2e, 0x42, 0xdf, 0x42, 0xb6, 0xe6, 0xe8, 0xe4, 0x8b, 0x7b, 0x96, 0x5d, 0xcf, 0xa8, 0x18, 0x4b,
-	0xd0, 0x0a, 0x93, 0x43, 0xf0, 0xc1, 0x66, 0xf5, 0x7a, 0x07, 0xfd, 0xb8, 0x2c, 0x18, 0x7f, 0x03,
-	0xa6, 0xcb, 0xb3, 0x7c, 0x34, 0xae, 0xda, 0xb5, 0xb6, 0xfa, 0x3f, 0x74, 0x52, 0x1f, 0x65, 0x6a,
-	0x3c, 0x72, 0x34, 0xed, 0xa6, 0x0d, 0xc5, 0x73, 0xca, 0x19, 0xae, 0x43, 0xe5, 0x6c, 0x32, 0xb9,
-	0xee, 0x9e, 0x5e, 0x5e, 0x9a, 0x08, 0x03, 0x94, 0xae, 0x07, 0xe3, 0xf1, 0xc5, 0x95, 0xa9, 0x1d,
-	0x57, 0x2a, 0x9e, 0xf9, 0xf0, 0xf0, 0xf0, 0xa0, 0x35, 0xbf, 0x85, 0xea, 0x44, 0xcc, 0x58, 0xdc,
-	0xa5, 0x09, 0xc3, 0x18, 0x8a, 0x92, 0x56, 0x8d, 0xa2, 0x4a, 0xd4, 0xfb, 0x06, 0xf4, 0x6f, 0x04,
-	0xbb, 0xaa, 0x4b, 0x83, 0xdf, 0x05, 0x0b, 0x93, 0x20, 0x0a, 0x93, 0x76, 0x13, 0x8a, 0x22, 0xe0,
-	0x0c, 0x3f, 0x1b, 0x91, 0xc5, 0x6c, 0xe4, 0x20, 0xa2, 0x62, 0xed, 0x77, 0x50, 0x9a, 0xd2, 0x38,
-	0x8e, 0xc4, 0x16, 0x2a, 0x50, 0xe3, 0xb5, 0x9e, 0x7a, 0xd7, 0xec, 0x64, 0x99, 0xd7, 0xee, 0x82,
-	0xe1, 0x45, 0x61, 0x2a, 0x30, 0x5e, 0x41, 0x57, 0x87, 0x56, 0x9f, 0xfa, 0x14, 0x49, 0x9e, 0xda,
-	0x74, 0x60, 0x4f, 0xe5, 0x3c, 0x0b, 0x6f, 0x2f, 0x6f, 0xd3, 0x82, 0xca, 0x64, 0xee, 0x29, 0x9c,
-	0xaa, 0xfe, 0xf1, 0xf1, 0xf1, 0xb1, 0xdc, 0xd1, 0x2a, 0xa8, 0xf9, 0x87, 0x0e, 0xd0, 0x8b, 0x38,
-	0x4f, 0xc3, 0xe0, 0x63, 0xca, 0xf0, 0x4b, 0xa8, 0x71, 0x7a, 0xcf, 0x5c, 0xce, 0xdc, 0x69, 0x9c,
-	0x53, 0x54, 0x48, 0x55, 0xba, 0x46, 0xac, 0x17, 0x67, 0xd8, 0x82, 0x52, 0x98, 0xf2, 0x5b, 0x16,
-	0x5b, 0x86, 0x64, 0x1f, 0x16, 0xc8, 0xd2, 0xc6, 0x7b, 0xcb, 0x46, 0x97, 0x64, 0xa3, 0x87, 0x85,
-	0xbc, 0xd5, 0xd2, 0xeb, 0x51, 0x41, 0x95, 0x30, 0xd5, 0xa5, 0x57, 0x5a, 0xf8, 0x00, 0x4a, 0x82,
-	0xf1, 0x85, 0x3b, 0x55, 0x72, 0x84, 0x86, 0x05, 0x62, 0x48, 0xbb, 0x27, 0xe9, 0x67, 0x2c, 0xf0,
-	0x67, 0x42, 0xfd, 0xa6, 0x9a, 0xa4, 0xcf, 0x6d, 0x7c, 0x04, 0x86, 0x88, 0x3c, 0x9a, 0x59, 0xa0,
-	0x34, 0xf1, 0xb3, 0x55, 0x6f, 0xfa, 0x34, 0x4b, 0x14, 0x81, 0x8c, 0xe2, 0x7d, 0x30, 0x38, 0xcd,
-	0x6e, 0x99, 0x55, 0x93, 0x27, 0x97, 0x7e, 0x65, 0x4a, 0xbf, 0xc7, 0xe6, 0x82, 0x2a, 0x01, 0xf9,
-	0x5c, 0xfa, 0x95, 0x89, 0x9b, 0xa0, 0xf3, 0xc4, 0x57, 0xf2, 0xb1, 0xf5, 0x53, 0x0e, 0x0b, 0x44,
-	0x06, 0xf1, 0xcf, 0x9b, 0xfa, 0xb9, 0xa3, 0xf4, 0xf3, 0xc5, 0x0a, 0xb9, 0xee, 0xdd, 0x5a, 0x42,
-	0x87, 0x85, 0x0d, 0x11, 0x6d, 0x7c, 0xb5, 0x29, 0x46, 0xfb, 0x50, 0xe2, 0x4c, 0xf5, 0x6f, 0x37,
-	0x57, 0xac, 0xdc, 0x6a, 0x94, 0xc1, 0xe8, 0xcb, 0x03, 0x75, 0xcb, 0x60, 0xa4, 0x61, 0x10, 0x85,
-	0xc7, 0x2f, 0xa1, 0xbc, 0x94, 0x7b, 0xb9, 0xe6, 0xb9, 0xe0, 0x9b, 0x48, 0x8a, 0xc2, 0xd9, 0xe0,
-	0x83, 0xa9, 0x1d, 0xb7, 0xa0, 0x28, 0x4b, 0x97, 0xc1, 0xd1, 0x64, 0xdc, 0x3f, 0xfd, 0xc5, 0x44,
-	0xb8, 0x06, 0xe5, 0xeb, 0x9b, 0xc1, 0x95, 0x34, 0x34, 0xa9, 0x1a, 0x97, 0x37, 0xe3, 0xfe, 0x85,
-	0x89, 0x1a, 0x9a, 0x89, 0x3a, 0x36, 0xe8, 0x82, 0xfa, 0x5b, 0xfb, 0xea, 0xab, 0x63, 0xc8, 0x50,
-	0xa7, 0xf7, 0xdf, 0x4a, 0x3e, 0xc7, 0xfc, 0xaa, 0xba, 0xf3, 0xe2, 0xe9, 0xa2, 0xfe, 0xff, 0x4e,
-	0x76, 0xdf, 0x7d, 0x78, 0xeb, 0x07, 0x62, 0x96, 0xde, 0xb6, 0xa6, 0x11, 0x3f, 0xf1, 0xa3, 0x39,
-	0x0d, 0xfd, 0x13, 0x75, 0x39, 0xde, 0xa6, 0x77, 0xf9, 0xcb, 0xf4, 0x95, 0xcf, 0xc2, 0x57, 0x7e,
-	0xa4, 0x6e, 0x55, 0xb9, 0x0f, 0x27, 0xcb, 0x6b, 0xf6, 0x27, 0xf9, 0xf8, 0x37, 0x00, 0x00, 0xff,
-	0xff, 0x12, 0xd5, 0x46, 0x00, 0x75, 0x07, 0x00, 0x00,
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/my_test/test.proto b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/my_test/test.proto
deleted file mode 100644
index 1ef3fd029..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/my_test/test.proto
+++ /dev/null
@@ -1,158 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto2";
-
-// This package holds interesting messages.
-package my.test;  // dotted package name
-
-option go_package = "github.com/golang/protobuf/protoc-gen-go/testdata/my_test;test";
-
-//import "imp.proto";
-import "multi/multi1.proto";  // unused import
-
-enum HatType {
-  // deliberately skipping 0
-  FEDORA = 1;
-  FEZ = 2;
-}
-
-// This enum represents days of the week.
-enum Days {
-  option allow_alias = true;
-
-  MONDAY = 1;
-  TUESDAY = 2;
-  LUNDI = 1;  // same value as MONDAY
-}
-
-// This is a message that might be sent somewhere.
-message Request {
-  enum Color {
-    RED = 0;
-    GREEN = 1;
-    BLUE = 2;
-  }
-  repeated int64 key = 1;
-//  optional imp.ImportedMessage imported_message = 2;
-  optional Color hue = 3; // no default
-  optional HatType hat = 4 [default=FEDORA];
-//  optional imp.ImportedMessage.Owner owner = 6;
-  optional float deadline = 7 [default=inf];
-  optional group SomeGroup = 8 {
-    optional int32 group_field = 9;
-  }
-
-  // These foreign types are in imp2.proto,
-  // which is publicly imported by imp.proto.
-//  optional imp.PubliclyImportedMessage pub = 10;
-//  optional imp.PubliclyImportedEnum pub_enum = 13 [default=HAIR];
-
-
-  // This is a map field. It will generate map[int32]string.
-  map<int32, string> name_mapping = 14;
-  // This is a map field whose value type is a message.
-  map<sint64, Reply> msg_mapping = 15;
-
-  optional int32 reset = 12;
-  // This field should not conflict with any getters.
-  optional string get_key = 16;
-}
-
-message Reply {
-  message Entry {
-    required int64 key_that_needs_1234camel_CasIng = 1;
-    optional int64 value = 2 [default=7];
-    optional int64 _my_field_name_2 = 3;
-    enum Game {
-      FOOTBALL = 1;
-      TENNIS = 2;
-    }
-  }
-  repeated Entry found = 1;
-  repeated int32 compact_keys = 2 [packed=true];
-  extensions 100 to max;
-}
-
-message OtherBase {
-  optional string name = 1;
-  extensions 100 to max;
-}
-
-message ReplyExtensions {
-  extend Reply {
-    optional double time = 101;
-    optional ReplyExtensions carrot = 105;
-  }
-  extend OtherBase {
-    optional ReplyExtensions donut = 101;
-  }
-}
-
-message OtherReplyExtensions {
-  optional int32 key = 1;
-}
-
-// top-level extension
-extend Reply {
-  optional string tag = 103;
-  optional OtherReplyExtensions donut = 106;
-//  optional imp.ImportedMessage elephant = 107;  // extend with message from another file.
-}
-
-message OldReply {
-  // Extensions will be encoded in MessageSet wire format.
-  option message_set_wire_format = true;
-  extensions 100 to max;
-}
-
-message Communique {
-  optional bool make_me_cry = 1;
-
-  // This is a oneof, called "union".
-  oneof union {
-    int32 number = 5;
-    string name = 6;
-    bytes data = 7;
-    double temp_c = 8;
-    float height = 9;
-    Days today = 10;
-    bool maybe = 11;
-    sint32 delta = 12;  // name will conflict with Delta below
-    Reply msg = 16;  // requires two bytes to encode field tag
-    group SomeGroup = 14 {
-      optional string member = 15;
-    }
-  }
-
-  message Delta {}
-}
-
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/proto3/proto3.pb.go b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/proto3/proto3.pb.go
deleted file mode 100644
index 3b0ad8491..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/proto3/proto3.pb.go
+++ /dev/null
@@ -1,196 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: proto3/proto3.proto
-
-package proto3 // import "github.com/golang/protobuf/protoc-gen-go/testdata/proto3"
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-type Request_Flavour int32
-
-const (
-	Request_SWEET         Request_Flavour = 0
-	Request_SOUR          Request_Flavour = 1
-	Request_UMAMI         Request_Flavour = 2
-	Request_GOPHERLICIOUS Request_Flavour = 3
-)
-
-var Request_Flavour_name = map[int32]string{
-	0: "SWEET",
-	1: "SOUR",
-	2: "UMAMI",
-	3: "GOPHERLICIOUS",
-}
-var Request_Flavour_value = map[string]int32{
-	"SWEET":         0,
-	"SOUR":          1,
-	"UMAMI":         2,
-	"GOPHERLICIOUS": 3,
-}
-
-func (x Request_Flavour) String() string {
-	return proto.EnumName(Request_Flavour_name, int32(x))
-}
-func (Request_Flavour) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_proto3_a752e09251f17e01, []int{0, 0}
-}
-
-type Request struct {
-	Name                 string          `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
-	Key                  []int64         `protobuf:"varint,2,rep,packed,name=key" json:"key,omitempty"`
-	Taste                Request_Flavour `protobuf:"varint,3,opt,name=taste,enum=proto3.Request_Flavour" json:"taste,omitempty"`
-	Book                 *Book           `protobuf:"bytes,4,opt,name=book" json:"book,omitempty"`
-	Unpacked             []int64         `protobuf:"varint,5,rep,name=unpacked" json:"unpacked,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
-	XXX_unrecognized     []byte          `json:"-"`
-	XXX_sizecache        int32           `json:"-"`
-}
-
-func (m *Request) Reset()         { *m = Request{} }
-func (m *Request) String() string { return proto.CompactTextString(m) }
-func (*Request) ProtoMessage()    {}
-func (*Request) Descriptor() ([]byte, []int) {
-	return fileDescriptor_proto3_a752e09251f17e01, []int{0}
-}
-func (m *Request) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Request.Unmarshal(m, b)
-}
-func (m *Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Request.Marshal(b, m, deterministic)
-}
-func (dst *Request) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Request.Merge(dst, src)
-}
-func (m *Request) XXX_Size() int {
-	return xxx_messageInfo_Request.Size(m)
-}
-func (m *Request) XXX_DiscardUnknown() {
-	xxx_messageInfo_Request.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Request proto.InternalMessageInfo
-
-func (m *Request) GetName() string {
-	if m != nil {
-		return m.Name
-	}
-	return ""
-}
-
-func (m *Request) GetKey() []int64 {
-	if m != nil {
-		return m.Key
-	}
-	return nil
-}
-
-func (m *Request) GetTaste() Request_Flavour {
-	if m != nil {
-		return m.Taste
-	}
-	return Request_SWEET
-}
-
-func (m *Request) GetBook() *Book {
-	if m != nil {
-		return m.Book
-	}
-	return nil
-}
-
-func (m *Request) GetUnpacked() []int64 {
-	if m != nil {
-		return m.Unpacked
-	}
-	return nil
-}
-
-type Book struct {
-	Title                string   `protobuf:"bytes,1,opt,name=title" json:"title,omitempty"`
-	RawData              []byte   `protobuf:"bytes,2,opt,name=raw_data,json=rawData,proto3" json:"raw_data,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *Book) Reset()         { *m = Book{} }
-func (m *Book) String() string { return proto.CompactTextString(m) }
-func (*Book) ProtoMessage()    {}
-func (*Book) Descriptor() ([]byte, []int) {
-	return fileDescriptor_proto3_a752e09251f17e01, []int{1}
-}
-func (m *Book) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Book.Unmarshal(m, b)
-}
-func (m *Book) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Book.Marshal(b, m, deterministic)
-}
-func (dst *Book) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Book.Merge(dst, src)
-}
-func (m *Book) XXX_Size() int {
-	return xxx_messageInfo_Book.Size(m)
-}
-func (m *Book) XXX_DiscardUnknown() {
-	xxx_messageInfo_Book.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Book proto.InternalMessageInfo
-
-func (m *Book) GetTitle() string {
-	if m != nil {
-		return m.Title
-	}
-	return ""
-}
-
-func (m *Book) GetRawData() []byte {
-	if m != nil {
-		return m.RawData
-	}
-	return nil
-}
-
-func init() {
-	proto.RegisterType((*Request)(nil), "proto3.Request")
-	proto.RegisterType((*Book)(nil), "proto3.Book")
-	proto.RegisterEnum("proto3.Request_Flavour", Request_Flavour_name, Request_Flavour_value)
-}
-
-func init() { proto.RegisterFile("proto3/proto3.proto", fileDescriptor_proto3_a752e09251f17e01) }
-
-var fileDescriptor_proto3_a752e09251f17e01 = []byte{
-	// 306 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x3c, 0x90, 0xcf, 0x4e, 0xf2, 0x40,
-	0x14, 0xc5, 0x99, 0xfe, 0xf9, 0x80, 0xfb, 0xa1, 0x19, 0xaf, 0x26, 0x8e, 0x1b, 0x33, 0x61, 0xd5,
-	0x0d, 0x25, 0xc1, 0x85, 0xc6, 0xb8, 0x11, 0x45, 0x25, 0x91, 0x60, 0x06, 0x89, 0x89, 0x1b, 0x33,
-	0x85, 0xb1, 0x92, 0x42, 0x07, 0xcb, 0x54, 0xe2, 0xcb, 0xfa, 0x2c, 0xa6, 0x9d, 0xe2, 0xea, 0x9e,
-	0x7b, 0xe7, 0xe4, 0x77, 0x32, 0x07, 0x0e, 0xd7, 0x99, 0x36, 0xfa, 0xac, 0x6b, 0x47, 0x58, 0x0e,
-	0xfc, 0x67, 0xb7, 0xf6, 0x0f, 0x81, 0xba, 0x50, 0x9f, 0xb9, 0xda, 0x18, 0x44, 0xf0, 0x52, 0xb9,
-	0x52, 0x8c, 0x70, 0x12, 0x34, 0x45, 0xa9, 0x91, 0x82, 0x9b, 0xa8, 0x6f, 0xe6, 0x70, 0x37, 0x70,
-	0x45, 0x21, 0xb1, 0x03, 0xbe, 0x91, 0x1b, 0xa3, 0x98, 0xcb, 0x49, 0xb0, 0xdf, 0x3b, 0x0e, 0x2b,
-	0x6e, 0x45, 0x09, 0xef, 0x96, 0xf2, 0x4b, 0xe7, 0x99, 0xb0, 0x2e, 0xe4, 0xe0, 0x45, 0x5a, 0x27,
-	0xcc, 0xe3, 0x24, 0xf8, 0xdf, 0x6b, 0xed, 0xdc, 0x7d, 0xad, 0x13, 0x51, 0xbe, 0xe0, 0x29, 0x34,
-	0xf2, 0x74, 0x2d, 0x67, 0x89, 0x9a, 0x33, 0xbf, 0xc8, 0xe9, 0x3b, 0xb4, 0x26, 0xfe, 0x6e, 0xed,
-	0x2b, 0xa8, 0x57, 0x4c, 0x6c, 0x82, 0x3f, 0x79, 0x19, 0x0c, 0x9e, 0x69, 0x0d, 0x1b, 0xe0, 0x4d,
-	0xc6, 0x53, 0x41, 0x49, 0x71, 0x9c, 0x8e, 0xae, 0x47, 0x43, 0xea, 0xe0, 0x01, 0xec, 0xdd, 0x8f,
-	0x9f, 0x1e, 0x06, 0xe2, 0x71, 0x78, 0x33, 0x1c, 0x4f, 0x27, 0xd4, 0x6d, 0x9f, 0x83, 0x57, 0x64,
-	0xe1, 0x11, 0xf8, 0x66, 0x61, 0x96, 0xbb, 0xdf, 0xd9, 0x05, 0x4f, 0xa0, 0x91, 0xc9, 0xed, 0xdb,
-	0x5c, 0x1a, 0xc9, 0x1c, 0x4e, 0x82, 0x96, 0xa8, 0x67, 0x72, 0x7b, 0x2b, 0x8d, 0xec, 0x5f, 0xbe,
-	0x5e, 0xc4, 0x0b, 0xf3, 0x91, 0x47, 0xe1, 0x4c, 0xaf, 0xba, 0xb1, 0x5e, 0xca, 0x34, 0xb6, 0x1d,
-	0x46, 0xf9, 0xbb, 0x15, 0xb3, 0x4e, 0xac, 0xd2, 0x4e, 0xac, 0xbb, 0x46, 0x6d, 0x4c, 0xc1, 0xa8,
-	0x3a, 0x8e, 0xaa, 0x76, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xec, 0x71, 0xee, 0xdb, 0x7b, 0x01,
-	0x00, 0x00,
-}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/proto3/proto3.proto b/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/proto3/proto3.proto
deleted file mode 100644
index 79954e4e2..000000000
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/testdata/proto3/proto3.proto
+++ /dev/null
@@ -1,55 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2014 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto3";
-
-package proto3;
-
-option go_package = "github.com/golang/protobuf/protoc-gen-go/testdata/proto3";
-
-message Request {
-  enum Flavour {
-    SWEET = 0;
-    SOUR = 1;
-    UMAMI = 2;
-    GOPHERLICIOUS = 3;
-  }
-  string name = 1;
-  repeated int64 key = 2;
-  Flavour taste = 3;
-  Book book = 4;
-  repeated int64 unpacked = 5 [packed=false];
-}
-
-message Book {
-  string title = 1;
-  bytes raw_data = 2;
-}
diff --git a/vendor/github.com/golang/protobuf/ptypes/any.go b/vendor/github.com/golang/protobuf/ptypes/any.go
index 70276e8f5..e729dcff1 100644
--- a/vendor/github.com/golang/protobuf/ptypes/any.go
+++ b/vendor/github.com/golang/protobuf/ptypes/any.go
@@ -1,141 +1,165 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2016 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// Copyright 2016 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 ptypes
 
-// This file implements functions to marshal proto.Message to/from
-// google.protobuf.Any message.
-
 import (
 	"fmt"
-	"reflect"
 	"strings"
 
 	"github.com/golang/protobuf/proto"
-	"github.com/golang/protobuf/ptypes/any"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/reflect/protoregistry"
+
+	anypb "github.com/golang/protobuf/ptypes/any"
 )
 
-const googleApis = "type.googleapis.com/"
+const urlPrefix = "type.googleapis.com/"
 
-// AnyMessageName returns the name of the message contained in a google.protobuf.Any message.
-//
-// Note that regular type assertions should be done using the Is
-// function. AnyMessageName is provided for less common use cases like filtering a
-// sequence of Any messages based on a set of allowed message type names.
-func AnyMessageName(any *any.Any) (string, error) {
+// AnyMessageName returns the message name contained in an anypb.Any message.
+// Most type assertions should use the Is function instead.
+func AnyMessageName(any *anypb.Any) (string, error) {
+	name, err := anyMessageName(any)
+	return string(name), err
+}
+func anyMessageName(any *anypb.Any) (protoreflect.FullName, error) {
 	if any == nil {
 		return "", fmt.Errorf("message is nil")
 	}
-	slash := strings.LastIndex(any.TypeUrl, "/")
-	if slash < 0 {
+	name := protoreflect.FullName(any.TypeUrl)
+	if i := strings.LastIndex(any.TypeUrl, "/"); i >= 0 {
+		name = name[i+len("/"):]
+	}
+	if !name.IsValid() {
 		return "", fmt.Errorf("message type url %q is invalid", any.TypeUrl)
 	}
-	return any.TypeUrl[slash+1:], nil
+	return name, nil
 }
 
-// MarshalAny takes the protocol buffer and encodes it into google.protobuf.Any.
-func MarshalAny(pb proto.Message) (*any.Any, error) {
-	value, err := proto.Marshal(pb)
+// MarshalAny marshals the given message m into an anypb.Any message.
+func MarshalAny(m proto.Message) (*anypb.Any, error) {
+	switch dm := m.(type) {
+	case DynamicAny:
+		m = dm.Message
+	case *DynamicAny:
+		if dm == nil {
+			return nil, proto.ErrNil
+		}
+		m = dm.Message
+	}
+	b, err := proto.Marshal(m)
 	if err != nil {
 		return nil, err
 	}
-	return &any.Any{TypeUrl: googleApis + proto.MessageName(pb), Value: value}, nil
-}
-
-// DynamicAny is a value that can be passed to UnmarshalAny to automatically
-// allocate a proto.Message for the type specified in a google.protobuf.Any
-// message. The allocated message is stored in the embedded proto.Message.
-//
-// Example:
-//
-//   var x ptypes.DynamicAny
-//   if err := ptypes.UnmarshalAny(a, &x); err != nil { ... }
-//   fmt.Printf("unmarshaled message: %v", x.Message)
-type DynamicAny struct {
-	proto.Message
+	return &anypb.Any{TypeUrl: urlPrefix + proto.MessageName(m), Value: b}, nil
 }
 
-// Empty returns a new proto.Message of the type specified in a
-// google.protobuf.Any message. It returns an error if corresponding message
-// type isn't linked in.
-func Empty(any *any.Any) (proto.Message, error) {
-	aname, err := AnyMessageName(any)
+// Empty returns a new message of the type specified in an anypb.Any message.
+// It returns protoregistry.NotFound if the corresponding message type could not
+// be resolved in the global registry.
+func Empty(any *anypb.Any) (proto.Message, error) {
+	name, err := anyMessageName(any)
 	if err != nil {
 		return nil, err
 	}
-
-	t := proto.MessageType(aname)
-	if t == nil {
-		return nil, fmt.Errorf("any: message type %q isn't linked in", aname)
+	mt, err := protoregistry.GlobalTypes.FindMessageByName(name)
+	if err != nil {
+		return nil, err
 	}
-	return reflect.New(t.Elem()).Interface().(proto.Message), nil
+	return proto.MessageV1(mt.New().Interface()), nil
 }
 
-// UnmarshalAny parses the protocol buffer representation in a google.protobuf.Any
-// message and places the decoded result in pb. It returns an error if type of
-// contents of Any message does not match type of pb message.
+// UnmarshalAny unmarshals the encoded value contained in the anypb.Any message
+// into the provided message m. It returns an error if the target message
+// does not match the type in the Any message or if an unmarshal error occurs.
 //
-// pb can be a proto.Message, or a *DynamicAny.
-func UnmarshalAny(any *any.Any, pb proto.Message) error {
-	if d, ok := pb.(*DynamicAny); ok {
-		if d.Message == nil {
+// The target message m may be a *DynamicAny message. If the underlying message
+// type could not be resolved, then this returns protoregistry.NotFound.
+func UnmarshalAny(any *anypb.Any, m proto.Message) error {
+	if dm, ok := m.(*DynamicAny); ok {
+		if dm.Message == nil {
 			var err error
-			d.Message, err = Empty(any)
+			dm.Message, err = Empty(any)
 			if err != nil {
 				return err
 			}
 		}
-		return UnmarshalAny(any, d.Message)
+		m = dm.Message
 	}
 
-	aname, err := AnyMessageName(any)
+	anyName, err := AnyMessageName(any)
 	if err != nil {
 		return err
 	}
-
-	mname := proto.MessageName(pb)
-	if aname != mname {
-		return fmt.Errorf("mismatched message type: got %q want %q", aname, mname)
+	msgName := proto.MessageName(m)
+	if anyName != msgName {
+		return fmt.Errorf("mismatched message type: got %q want %q", anyName, msgName)
 	}
-	return proto.Unmarshal(any.Value, pb)
+	return proto.Unmarshal(any.Value, m)
 }
 
-// Is returns true if any value contains a given message type.
-func Is(any *any.Any, pb proto.Message) bool {
-	// The following is equivalent to AnyMessageName(any) == proto.MessageName(pb),
-	// but it avoids scanning TypeUrl for the slash.
-	if any == nil {
+// Is reports whether the Any message contains a message of the specified type.
+func Is(any *anypb.Any, m proto.Message) bool {
+	if any == nil || m == nil {
 		return false
 	}
-	name := proto.MessageName(pb)
-	prefix := len(any.TypeUrl) - len(name)
-	return prefix >= 1 && any.TypeUrl[prefix-1] == '/' && any.TypeUrl[prefix:] == name
+	name := proto.MessageName(m)
+	if !strings.HasSuffix(any.TypeUrl, name) {
+		return false
+	}
+	return len(any.TypeUrl) == len(name) || any.TypeUrl[len(any.TypeUrl)-len(name)-1] == '/'
+}
+
+// DynamicAny is a value that can be passed to UnmarshalAny to automatically
+// allocate a proto.Message for the type specified in an anypb.Any message.
+// The allocated message is stored in the embedded proto.Message.
+//
+// Example:
+//   var x ptypes.DynamicAny
+//   if err := ptypes.UnmarshalAny(a, &x); err != nil { ... }
+//   fmt.Printf("unmarshaled message: %v", x.Message)
+type DynamicAny struct{ proto.Message }
+
+func (m DynamicAny) String() string {
+	if m.Message == nil {
+		return "<nil>"
+	}
+	return m.Message.String()
+}
+func (m DynamicAny) Reset() {
+	if m.Message == nil {
+		return
+	}
+	m.Message.Reset()
+}
+func (m DynamicAny) ProtoMessage() {
+	return
+}
+func (m DynamicAny) ProtoReflect() protoreflect.Message {
+	if m.Message == nil {
+		return nil
+	}
+	return dynamicAny{proto.MessageReflect(m.Message)}
+}
+
+type dynamicAny struct{ protoreflect.Message }
+
+func (m dynamicAny) Type() protoreflect.MessageType {
+	return dynamicAnyType{m.Message.Type()}
+}
+func (m dynamicAny) New() protoreflect.Message {
+	return dynamicAnyType{m.Message.Type()}.New()
+}
+func (m dynamicAny) Interface() protoreflect.ProtoMessage {
+	return DynamicAny{proto.MessageV1(m.Message.Interface())}
+}
+
+type dynamicAnyType struct{ protoreflect.MessageType }
+
+func (t dynamicAnyType) New() protoreflect.Message {
+	return dynamicAny{t.MessageType.New()}
+}
+func (t dynamicAnyType) Zero() protoreflect.Message {
+	return dynamicAny{t.MessageType.Zero()}
 }
diff --git a/vendor/github.com/golang/protobuf/ptypes/any/any.pb.go b/vendor/github.com/golang/protobuf/ptypes/any/any.pb.go
index f67edc7dc..0ef27d33d 100644
--- a/vendor/github.com/golang/protobuf/ptypes/any/any.pb.go
+++ b/vendor/github.com/golang/protobuf/ptypes/any/any.pb.go
@@ -1,191 +1,62 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
-// source: google/protobuf/any.proto
+// source: github.com/golang/protobuf/ptypes/any/any.proto
 
-package any // import "github.com/golang/protobuf/ptypes/any"
+package any
 
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	anypb "google.golang.org/protobuf/types/known/anypb"
+	reflect "reflect"
+)
 
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
+// Symbols defined in public import of google/protobuf/any.proto.
 
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+type Any = anypb.Any
 
-// `Any` contains an arbitrary serialized protocol buffer message along with a
-// URL that describes the type of the serialized message.
-//
-// Protobuf library provides support to pack/unpack Any values in the form
-// of utility functions or additional generated methods of the Any type.
-//
-// Example 1: Pack and unpack a message in C++.
-//
-//     Foo foo = ...;
-//     Any any;
-//     any.PackFrom(foo);
-//     ...
-//     if (any.UnpackTo(&foo)) {
-//       ...
-//     }
-//
-// Example 2: Pack and unpack a message in Java.
-//
-//     Foo foo = ...;
-//     Any any = Any.pack(foo);
-//     ...
-//     if (any.is(Foo.class)) {
-//       foo = any.unpack(Foo.class);
-//     }
-//
-//  Example 3: Pack and unpack a message in Python.
-//
-//     foo = Foo(...)
-//     any = Any()
-//     any.Pack(foo)
-//     ...
-//     if any.Is(Foo.DESCRIPTOR):
-//       any.Unpack(foo)
-//       ...
-//
-//  Example 4: Pack and unpack a message in Go
-//
-//      foo := &pb.Foo{...}
-//      any, err := ptypes.MarshalAny(foo)
-//      ...
-//      foo := &pb.Foo{}
-//      if err := ptypes.UnmarshalAny(any, foo); err != nil {
-//        ...
-//      }
-//
-// The pack methods provided by protobuf library will by default use
-// 'type.googleapis.com/full.type.name' as the type URL and the unpack
-// methods only use the fully qualified type name after the last '/'
-// in the type URL, for example "foo.bar.com/x/y.z" will yield type
-// name "y.z".
-//
-//
-// JSON
-// ====
-// The JSON representation of an `Any` value uses the regular
-// representation of the deserialized, embedded message, with an
-// additional field `@type` which contains the type URL. Example:
-//
-//     package google.profile;
-//     message Person {
-//       string first_name = 1;
-//       string last_name = 2;
-//     }
-//
-//     {
-//       "@type": "type.googleapis.com/google.profile.Person",
-//       "firstName": <string>,
-//       "lastName": <string>
-//     }
-//
-// If the embedded message type is well-known and has a custom JSON
-// representation, that representation will be embedded adding a field
-// `value` which holds the custom JSON in addition to the `@type`
-// field. Example (for message [google.protobuf.Duration][]):
-//
-//     {
-//       "@type": "type.googleapis.com/google.protobuf.Duration",
-//       "value": "1.212s"
-//     }
-//
-type Any struct {
-	// A URL/resource name whose content describes the type of the
-	// serialized protocol buffer message.
-	//
-	// For URLs which use the scheme `http`, `https`, or no scheme, the
-	// following restrictions and interpretations apply:
-	//
-	// * If no scheme is provided, `https` is assumed.
-	// * The last segment of the URL's path must represent the fully
-	//   qualified name of the type (as in `path/google.protobuf.Duration`).
-	//   The name should be in a canonical form (e.g., leading "." is
-	//   not accepted).
-	// * An HTTP GET on the URL must yield a [google.protobuf.Type][]
-	//   value in binary format, or produce an error.
-	// * Applications are allowed to cache lookup results based on the
-	//   URL, or have them precompiled into a binary to avoid any
-	//   lookup. Therefore, binary compatibility needs to be preserved
-	//   on changes to types. (Use versioned type names to manage
-	//   breaking changes.)
-	//
-	// Schemes other than `http`, `https` (or the empty scheme) might be
-	// used with implementation specific semantics.
-	//
-	TypeUrl string `protobuf:"bytes,1,opt,name=type_url,json=typeUrl" json:"type_url,omitempty"`
-	// Must be a valid serialized protocol buffer of the above specified type.
-	Value                []byte   `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
+var File_github_com_golang_protobuf_ptypes_any_any_proto protoreflect.FileDescriptor
 
-func (m *Any) Reset()         { *m = Any{} }
-func (m *Any) String() string { return proto.CompactTextString(m) }
-func (*Any) ProtoMessage()    {}
-func (*Any) Descriptor() ([]byte, []int) {
-	return fileDescriptor_any_744b9ca530f228db, []int{0}
-}
-func (*Any) XXX_WellKnownType() string { return "Any" }
-func (m *Any) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Any.Unmarshal(m, b)
-}
-func (m *Any) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Any.Marshal(b, m, deterministic)
-}
-func (dst *Any) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Any.Merge(dst, src)
+var file_github_com_golang_protobuf_ptypes_any_any_proto_rawDesc = []byte{
+	0x0a, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
+	0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79,
+	0x70, 0x65, 0x73, 0x2f, 0x61, 0x6e, 0x79, 0x2f, 0x61, 0x6e, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x1a, 0x19, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
+	0x75, 0x66, 0x2f, 0x61, 0x6e, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x42, 0x2b, 0x5a, 0x29,
+	0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e,
+	0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79, 0x70, 0x65,
+	0x73, 0x2f, 0x61, 0x6e, 0x79, 0x3b, 0x61, 0x6e, 0x79, 0x50, 0x00, 0x62, 0x06, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x33,
 }
-func (m *Any) XXX_Size() int {
-	return xxx_messageInfo_Any.Size(m)
-}
-func (m *Any) XXX_DiscardUnknown() {
-	xxx_messageInfo_Any.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Any proto.InternalMessageInfo
 
-func (m *Any) GetTypeUrl() string {
-	if m != nil {
-		return m.TypeUrl
-	}
-	return ""
+var file_github_com_golang_protobuf_ptypes_any_any_proto_goTypes = []interface{}{}
+var file_github_com_golang_protobuf_ptypes_any_any_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
 }
 
-func (m *Any) GetValue() []byte {
-	if m != nil {
-		return m.Value
+func init() { file_github_com_golang_protobuf_ptypes_any_any_proto_init() }
+func file_github_com_golang_protobuf_ptypes_any_any_proto_init() {
+	if File_github_com_golang_protobuf_ptypes_any_any_proto != nil {
+		return
 	}
-	return nil
-}
-
-func init() {
-	proto.RegisterType((*Any)(nil), "google.protobuf.Any")
-}
-
-func init() { proto.RegisterFile("google/protobuf/any.proto", fileDescriptor_any_744b9ca530f228db) }
-
-var fileDescriptor_any_744b9ca530f228db = []byte{
-	// 185 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4c, 0xcf, 0xcf, 0x4f,
-	0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x4f, 0xcc, 0xab, 0xd4,
-	0x03, 0x73, 0x84, 0xf8, 0x21, 0x52, 0x7a, 0x30, 0x29, 0x25, 0x33, 0x2e, 0x66, 0xc7, 0xbc, 0x4a,
-	0x21, 0x49, 0x2e, 0x8e, 0x92, 0xca, 0x82, 0xd4, 0xf8, 0xd2, 0xa2, 0x1c, 0x09, 0x46, 0x05, 0x46,
-	0x0d, 0xce, 0x20, 0x76, 0x10, 0x3f, 0xb4, 0x28, 0x47, 0x48, 0x84, 0x8b, 0xb5, 0x2c, 0x31, 0xa7,
-	0x34, 0x55, 0x82, 0x49, 0x81, 0x51, 0x83, 0x27, 0x08, 0xc2, 0x71, 0xca, 0xe7, 0x12, 0x4e, 0xce,
-	0xcf, 0xd5, 0x43, 0x33, 0xce, 0x89, 0xc3, 0x31, 0xaf, 0x32, 0x00, 0xc4, 0x09, 0x60, 0x8c, 0x52,
-	0x4d, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xcf, 0xcf, 0x49, 0xcc,
-	0x4b, 0x47, 0xb8, 0xa8, 0x00, 0x64, 0x7a, 0x31, 0xc8, 0x61, 0x8b, 0x98, 0x98, 0xdd, 0x03, 0x9c,
-	0x56, 0x31, 0xc9, 0xb9, 0x43, 0x8c, 0x0a, 0x80, 0x2a, 0xd1, 0x0b, 0x4f, 0xcd, 0xc9, 0xf1, 0xce,
-	0xcb, 0x2f, 0xcf, 0x0b, 0x01, 0x29, 0x4d, 0x62, 0x03, 0xeb, 0x35, 0x06, 0x04, 0x00, 0x00, 0xff,
-	0xff, 0x13, 0xf8, 0xe8, 0x42, 0xdd, 0x00, 0x00, 0x00,
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_github_com_golang_protobuf_ptypes_any_any_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   0,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_github_com_golang_protobuf_ptypes_any_any_proto_goTypes,
+		DependencyIndexes: file_github_com_golang_protobuf_ptypes_any_any_proto_depIdxs,
+	}.Build()
+	File_github_com_golang_protobuf_ptypes_any_any_proto = out.File
+	file_github_com_golang_protobuf_ptypes_any_any_proto_rawDesc = nil
+	file_github_com_golang_protobuf_ptypes_any_any_proto_goTypes = nil
+	file_github_com_golang_protobuf_ptypes_any_any_proto_depIdxs = nil
 }
diff --git a/vendor/github.com/golang/protobuf/ptypes/any/any.proto b/vendor/github.com/golang/protobuf/ptypes/any/any.proto
deleted file mode 100644
index c74866762..000000000
--- a/vendor/github.com/golang/protobuf/ptypes/any/any.proto
+++ /dev/null
@@ -1,149 +0,0 @@
-// Protocol Buffers - Google's data interchange format
-// Copyright 2008 Google Inc.  All rights reserved.
-// https://developers.google.com/protocol-buffers/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto3";
-
-package google.protobuf;
-
-option csharp_namespace = "Google.Protobuf.WellKnownTypes";
-option go_package = "github.com/golang/protobuf/ptypes/any";
-option java_package = "com.google.protobuf";
-option java_outer_classname = "AnyProto";
-option java_multiple_files = true;
-option objc_class_prefix = "GPB";
-
-// `Any` contains an arbitrary serialized protocol buffer message along with a
-// URL that describes the type of the serialized message.
-//
-// Protobuf library provides support to pack/unpack Any values in the form
-// of utility functions or additional generated methods of the Any type.
-//
-// Example 1: Pack and unpack a message in C++.
-//
-//     Foo foo = ...;
-//     Any any;
-//     any.PackFrom(foo);
-//     ...
-//     if (any.UnpackTo(&foo)) {
-//       ...
-//     }
-//
-// Example 2: Pack and unpack a message in Java.
-//
-//     Foo foo = ...;
-//     Any any = Any.pack(foo);
-//     ...
-//     if (any.is(Foo.class)) {
-//       foo = any.unpack(Foo.class);
-//     }
-//
-//  Example 3: Pack and unpack a message in Python.
-//
-//     foo = Foo(...)
-//     any = Any()
-//     any.Pack(foo)
-//     ...
-//     if any.Is(Foo.DESCRIPTOR):
-//       any.Unpack(foo)
-//       ...
-//
-//  Example 4: Pack and unpack a message in Go
-//
-//      foo := &pb.Foo{...}
-//      any, err := ptypes.MarshalAny(foo)
-//      ...
-//      foo := &pb.Foo{}
-//      if err := ptypes.UnmarshalAny(any, foo); err != nil {
-//        ...
-//      }
-//
-// The pack methods provided by protobuf library will by default use
-// 'type.googleapis.com/full.type.name' as the type URL and the unpack
-// methods only use the fully qualified type name after the last '/'
-// in the type URL, for example "foo.bar.com/x/y.z" will yield type
-// name "y.z".
-//
-//
-// JSON
-// ====
-// The JSON representation of an `Any` value uses the regular
-// representation of the deserialized, embedded message, with an
-// additional field `@type` which contains the type URL. Example:
-//
-//     package google.profile;
-//     message Person {
-//       string first_name = 1;
-//       string last_name = 2;
-//     }
-//
-//     {
-//       "@type": "type.googleapis.com/google.profile.Person",
-//       "firstName": <string>,
-//       "lastName": <string>
-//     }
-//
-// If the embedded message type is well-known and has a custom JSON
-// representation, that representation will be embedded adding a field
-// `value` which holds the custom JSON in addition to the `@type`
-// field. Example (for message [google.protobuf.Duration][]):
-//
-//     {
-//       "@type": "type.googleapis.com/google.protobuf.Duration",
-//       "value": "1.212s"
-//     }
-//
-message Any {
-  // A URL/resource name whose content describes the type of the
-  // serialized protocol buffer message.
-  //
-  // For URLs which use the scheme `http`, `https`, or no scheme, the
-  // following restrictions and interpretations apply:
-  //
-  // * If no scheme is provided, `https` is assumed.
-  // * The last segment of the URL's path must represent the fully
-  //   qualified name of the type (as in `path/google.protobuf.Duration`).
-  //   The name should be in a canonical form (e.g., leading "." is
-  //   not accepted).
-  // * An HTTP GET on the URL must yield a [google.protobuf.Type][]
-  //   value in binary format, or produce an error.
-  // * Applications are allowed to cache lookup results based on the
-  //   URL, or have them precompiled into a binary to avoid any
-  //   lookup. Therefore, binary compatibility needs to be preserved
-  //   on changes to types. (Use versioned type names to manage
-  //   breaking changes.)
-  //
-  // Schemes other than `http`, `https` (or the empty scheme) might be
-  // used with implementation specific semantics.
-  //
-  string type_url = 1;
-
-  // Must be a valid serialized protocol buffer of the above specified type.
-  bytes value = 2;
-}
diff --git a/vendor/github.com/golang/protobuf/ptypes/any_test.go b/vendor/github.com/golang/protobuf/ptypes/any_test.go
index 163ca312b..c865e1ca5 100644
--- a/vendor/github.com/golang/protobuf/ptypes/any_test.go
+++ b/vendor/github.com/golang/protobuf/ptypes/any_test.go
@@ -1,53 +1,28 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2016 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// Copyright 2016 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 ptypes
 
 import (
+	"reflect"
 	"testing"
 
 	"github.com/golang/protobuf/proto"
-	pb "github.com/golang/protobuf/protoc-gen-go/descriptor"
-	"github.com/golang/protobuf/ptypes/any"
+
+	descriptorpb "github.com/golang/protobuf/protoc-gen-go/descriptor"
+	anypb "github.com/golang/protobuf/ptypes/any"
 )
 
 func TestMarshalUnmarshal(t *testing.T) {
-	orig := &any.Any{Value: []byte("test")}
+	orig := &anypb.Any{Value: []byte("test")}
 
 	packed, err := MarshalAny(orig)
 	if err != nil {
 		t.Errorf("MarshalAny(%+v): got: _, %v exp: _, nil", orig, err)
 	}
 
-	unpacked := &any.Any{}
+	unpacked := &anypb.Any{}
 	err = UnmarshalAny(packed, unpacked)
 	if err != nil || !proto.Equal(unpacked, orig) {
 		t.Errorf("got: %v, %+v; want nil, %+v", err, unpacked, orig)
@@ -55,49 +30,48 @@ func TestMarshalUnmarshal(t *testing.T) {
 }
 
 func TestIs(t *testing.T) {
-	a, err := MarshalAny(&pb.FileDescriptorProto{})
+	a, err := MarshalAny(&descriptorpb.FileDescriptorProto{})
 	if err != nil {
 		t.Fatal(err)
 	}
-	if Is(a, &pb.DescriptorProto{}) {
+	if Is(a, &descriptorpb.DescriptorProto{}) {
 		// No spurious match for message names of different length.
 		t.Error("FileDescriptorProto is not a DescriptorProto, but Is says it is")
 	}
-	if Is(a, &pb.EnumDescriptorProto{}) {
+	if Is(a, &descriptorpb.EnumDescriptorProto{}) {
 		// No spurious match for message names of equal length.
 		t.Error("FileDescriptorProto is not an EnumDescriptorProto, but Is says it is")
 	}
-	if !Is(a, &pb.FileDescriptorProto{}) {
+	if !Is(a, &descriptorpb.FileDescriptorProto{}) {
 		t.Error("FileDescriptorProto is indeed a FileDescriptorProto, but Is says it is not")
 	}
 }
 
 func TestIsDifferentUrlPrefixes(t *testing.T) {
-	m := &pb.FileDescriptorProto{}
-	a := &any.Any{TypeUrl: "foo/bar/" + proto.MessageName(m)}
+	m := &descriptorpb.FileDescriptorProto{}
+	a := &anypb.Any{TypeUrl: "foo/bar/" + proto.MessageName(m)}
 	if !Is(a, m) {
 		t.Errorf("message with type url %q didn't satisfy Is for type %q", a.TypeUrl, proto.MessageName(m))
 	}
 }
 
-
 func TestIsCornerCases(t *testing.T) {
-	m := &pb.FileDescriptorProto{}
+	m := &descriptorpb.FileDescriptorProto{}
 	if Is(nil, m) {
 		t.Errorf("message with nil type url incorrectly claimed to be %q", proto.MessageName(m))
 	}
-	noPrefix := &any.Any{TypeUrl: proto.MessageName(m)}
-	if Is(noPrefix, m) {
-		t.Errorf("message with type url %q incorrectly claimed to be %q", noPrefix.TypeUrl, proto.MessageName(m))
+	noPrefix := &anypb.Any{TypeUrl: proto.MessageName(m)}
+	if !Is(noPrefix, m) {
+		t.Errorf("message with type url %q didn't satisfy Is for type %q", noPrefix.TypeUrl, proto.MessageName(m))
 	}
-	shortPrefix := &any.Any{TypeUrl: "/" + proto.MessageName(m)}
+	shortPrefix := &anypb.Any{TypeUrl: "/" + proto.MessageName(m)}
 	if !Is(shortPrefix, m) {
 		t.Errorf("message with type url %q didn't satisfy Is for type %q", shortPrefix.TypeUrl, proto.MessageName(m))
 	}
 }
 
 func TestUnmarshalDynamic(t *testing.T) {
-	want := &pb.FileDescriptorProto{Name: proto.String("foo")}
+	want := &descriptorpb.FileDescriptorProto{Name: proto.String("foo")}
 	a, err := MarshalAny(want)
 	if err != nil {
 		t.Fatal(err)
@@ -112,7 +86,7 @@ func TestUnmarshalDynamic(t *testing.T) {
 }
 
 func TestEmpty(t *testing.T) {
-	want := &pb.FileDescriptorProto{}
+	want := &descriptorpb.FileDescriptorProto{}
 	a, err := MarshalAny(want)
 	if err != nil {
 		t.Fatal(err)
@@ -138,14 +112,17 @@ func TestEmptyCornerCases(t *testing.T) {
 	if err == nil {
 		t.Error("expected Empty for nil to fail")
 	}
-	want := &pb.FileDescriptorProto{}
-	noPrefix := &any.Any{TypeUrl: proto.MessageName(want)}
-	_, err = Empty(noPrefix)
-	if err == nil {
-		t.Errorf("expected Empty for any type %q to fail", noPrefix.TypeUrl)
+	want := &descriptorpb.FileDescriptorProto{}
+	noPrefix := &anypb.Any{TypeUrl: proto.MessageName(want)}
+	got, err := Empty(noPrefix)
+	if err != nil {
+		t.Errorf("Empty for any type %q failed: %s", noPrefix.TypeUrl, err)
+	}
+	if !proto.Equal(got, want) {
+		t.Errorf("Empty for any type %q differs, got %q, want %q", noPrefix.TypeUrl, got, want)
 	}
-	shortPrefix := &any.Any{TypeUrl: "/" + proto.MessageName(want)}
-	got, err := Empty(shortPrefix)
+	shortPrefix := &anypb.Any{TypeUrl: "/" + proto.MessageName(want)}
+	got, err = Empty(shortPrefix)
 	if err != nil {
 		t.Errorf("Empty for any type %q failed: %s", shortPrefix.TypeUrl, err)
 	}
@@ -153,3 +130,37 @@ func TestEmptyCornerCases(t *testing.T) {
 		t.Errorf("Empty for any type %q differs, got %q, want %q", shortPrefix.TypeUrl, got, want)
 	}
 }
+
+func TestAnyReflect(t *testing.T) {
+	want := &descriptorpb.FileDescriptorProto{Name: proto.String("foo")}
+	a, err := MarshalAny(want)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var got DynamicAny
+	if err := UnmarshalAny(a, &got); err != nil {
+		t.Fatal(err)
+	}
+	wantName := want.ProtoReflect().Descriptor().FullName()
+	gotName := got.ProtoReflect().Descriptor().FullName()
+	if gotName != wantName {
+		t.Errorf("name mismatch: got %v, want %v", gotName, wantName)
+	}
+	wantType := reflect.TypeOf(got)
+	gotType := reflect.TypeOf(got.ProtoReflect().Interface())
+	if gotType != wantType {
+		t.Errorf("ProtoReflect().Interface() round-trip type mismatch: got %v, want %v", gotType, wantType)
+	}
+	gotType = reflect.TypeOf(got.ProtoReflect().New().Interface())
+	if gotType != wantType {
+		t.Errorf("ProtoReflect().New().Interface() type mismatch: got %v, want %v", gotType, wantType)
+	}
+	gotType = reflect.TypeOf(got.ProtoReflect().Type().New().Interface())
+	if gotType != wantType {
+		t.Errorf("ProtoReflect().Type().New().Interface() type mismatch: got %v, want %v", gotType, wantType)
+	}
+	gotType = reflect.TypeOf(got.ProtoReflect().Type().Zero().Interface())
+	if gotType != wantType {
+		t.Errorf("ProtoReflect().Type().Zero().Interface() type mismatch: got %v, want %v", gotType, wantType)
+	}
+}
diff --git a/vendor/github.com/golang/protobuf/ptypes/doc.go b/vendor/github.com/golang/protobuf/ptypes/doc.go
index c0d595da7..fb9edd5c6 100644
--- a/vendor/github.com/golang/protobuf/ptypes/doc.go
+++ b/vendor/github.com/golang/protobuf/ptypes/doc.go
@@ -1,35 +1,6 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2016 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// Copyright 2016 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 ptypes contains code for interacting with well-known types.
-*/
+// Package ptypes provides functionality for interacting with well-known types.
 package ptypes
diff --git a/vendor/github.com/golang/protobuf/ptypes/duration.go b/vendor/github.com/golang/protobuf/ptypes/duration.go
index 65cb0f8eb..6110ae8a4 100644
--- a/vendor/github.com/golang/protobuf/ptypes/duration.go
+++ b/vendor/github.com/golang/protobuf/ptypes/duration.go
@@ -1,102 +1,72 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2016 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// Copyright 2016 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 ptypes
 
-// This file implements conversions between google.protobuf.Duration
-// and time.Duration.
-
 import (
 	"errors"
 	"fmt"
 	"time"
 
-	durpb "github.com/golang/protobuf/ptypes/duration"
+	durationpb "github.com/golang/protobuf/ptypes/duration"
 )
 
+// Range of google.protobuf.Duration as specified in duration.proto.
+// This is about 10,000 years in seconds.
 const (
-	// Range of a durpb.Duration in seconds, as specified in
-	// google/protobuf/duration.proto. This is about 10,000 years in seconds.
 	maxSeconds = int64(10000 * 365.25 * 24 * 60 * 60)
 	minSeconds = -maxSeconds
 )
 
-// validateDuration determines whether the durpb.Duration is valid according to the
-// definition in google/protobuf/duration.proto. A valid durpb.Duration
-// may still be too large to fit into a time.Duration (the range of durpb.Duration
-// is about 10,000 years, and the range of time.Duration is about 290).
-func validateDuration(d *durpb.Duration) error {
-	if d == nil {
-		return errors.New("duration: nil Duration")
-	}
-	if d.Seconds < minSeconds || d.Seconds > maxSeconds {
-		return fmt.Errorf("duration: %v: seconds out of range", d)
-	}
-	if d.Nanos <= -1e9 || d.Nanos >= 1e9 {
-		return fmt.Errorf("duration: %v: nanos out of range", d)
-	}
-	// Seconds and Nanos must have the same sign, unless d.Nanos is zero.
-	if (d.Seconds < 0 && d.Nanos > 0) || (d.Seconds > 0 && d.Nanos < 0) {
-		return fmt.Errorf("duration: %v: seconds and nanos have different signs", d)
-	}
-	return nil
-}
-
-// Duration converts a durpb.Duration to a time.Duration. Duration
-// returns an error if the durpb.Duration is invalid or is too large to be
-// represented in a time.Duration.
-func Duration(p *durpb.Duration) (time.Duration, error) {
-	if err := validateDuration(p); err != nil {
+// Duration converts a durationpb.Duration to a time.Duration.
+// Duration returns an error if dur is invalid or overflows a time.Duration.
+func Duration(dur *durationpb.Duration) (time.Duration, error) {
+	if err := validateDuration(dur); err != nil {
 		return 0, err
 	}
-	d := time.Duration(p.Seconds) * time.Second
-	if int64(d/time.Second) != p.Seconds {
-		return 0, fmt.Errorf("duration: %v is out of range for time.Duration", p)
+	d := time.Duration(dur.Seconds) * time.Second
+	if int64(d/time.Second) != dur.Seconds {
+		return 0, fmt.Errorf("duration: %v is out of range for time.Duration", dur)
 	}
-	if p.Nanos != 0 {
-		d += time.Duration(p.Nanos)
-		if (d < 0) != (p.Nanos < 0) {
-			return 0, fmt.Errorf("duration: %v is out of range for time.Duration", p)
+	if dur.Nanos != 0 {
+		d += time.Duration(dur.Nanos) * time.Nanosecond
+		if (d < 0) != (dur.Nanos < 0) {
+			return 0, fmt.Errorf("duration: %v is out of range for time.Duration", dur)
 		}
 	}
 	return d, nil
 }
 
-// DurationProto converts a time.Duration to a durpb.Duration.
-func DurationProto(d time.Duration) *durpb.Duration {
+// DurationProto converts a time.Duration to a durationpb.Duration.
+func DurationProto(d time.Duration) *durationpb.Duration {
 	nanos := d.Nanoseconds()
 	secs := nanos / 1e9
 	nanos -= secs * 1e9
-	return &durpb.Duration{
-		Seconds: secs,
+	return &durationpb.Duration{
+		Seconds: int64(secs),
 		Nanos:   int32(nanos),
 	}
 }
+
+// validateDuration determines whether the durationpb.Duration is valid
+// according to the definition in google/protobuf/duration.proto.
+// A valid durpb.Duration may still be too large to fit into a time.Duration
+// Note that the range of durationpb.Duration is about 10,000 years,
+// while the range of time.Duration is about 290 years.
+func validateDuration(dur *durationpb.Duration) error {
+	if dur == nil {
+		return errors.New("duration: nil Duration")
+	}
+	if dur.Seconds < minSeconds || dur.Seconds > maxSeconds {
+		return fmt.Errorf("duration: %v: seconds out of range", dur)
+	}
+	if dur.Nanos <= -1e9 || dur.Nanos >= 1e9 {
+		return fmt.Errorf("duration: %v: nanos out of range", dur)
+	}
+	// Seconds and Nanos must have the same sign, unless d.Nanos is zero.
+	if (dur.Seconds < 0 && dur.Nanos > 0) || (dur.Seconds > 0 && dur.Nanos < 0) {
+		return fmt.Errorf("duration: %v: seconds and nanos have different signs", dur)
+	}
+	return nil
+}
diff --git a/vendor/github.com/golang/protobuf/ptypes/duration/duration.pb.go b/vendor/github.com/golang/protobuf/ptypes/duration/duration.pb.go
index 4d75473b8..d0079ee3e 100644
--- a/vendor/github.com/golang/protobuf/ptypes/duration/duration.pb.go
+++ b/vendor/github.com/golang/protobuf/ptypes/duration/duration.pb.go
@@ -1,159 +1,63 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
-// source: google/protobuf/duration.proto
+// source: github.com/golang/protobuf/ptypes/duration/duration.proto
 
-package duration // import "github.com/golang/protobuf/ptypes/duration"
+package duration
 
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	durationpb "google.golang.org/protobuf/types/known/durationpb"
+	reflect "reflect"
+)
 
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
+// Symbols defined in public import of google/protobuf/duration.proto.
 
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+type Duration = durationpb.Duration
 
-// A Duration represents a signed, fixed-length span of time represented
-// as a count of seconds and fractions of seconds at nanosecond
-// resolution. It is independent of any calendar and concepts like "day"
-// or "month". It is related to Timestamp in that the difference between
-// two Timestamp values is a Duration and it can be added or subtracted
-// from a Timestamp. Range is approximately +-10,000 years.
-//
-// # Examples
-//
-// Example 1: Compute Duration from two Timestamps in pseudo code.
-//
-//     Timestamp start = ...;
-//     Timestamp end = ...;
-//     Duration duration = ...;
-//
-//     duration.seconds = end.seconds - start.seconds;
-//     duration.nanos = end.nanos - start.nanos;
-//
-//     if (duration.seconds < 0 && duration.nanos > 0) {
-//       duration.seconds += 1;
-//       duration.nanos -= 1000000000;
-//     } else if (durations.seconds > 0 && duration.nanos < 0) {
-//       duration.seconds -= 1;
-//       duration.nanos += 1000000000;
-//     }
-//
-// Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
-//
-//     Timestamp start = ...;
-//     Duration duration = ...;
-//     Timestamp end = ...;
-//
-//     end.seconds = start.seconds + duration.seconds;
-//     end.nanos = start.nanos + duration.nanos;
-//
-//     if (end.nanos < 0) {
-//       end.seconds -= 1;
-//       end.nanos += 1000000000;
-//     } else if (end.nanos >= 1000000000) {
-//       end.seconds += 1;
-//       end.nanos -= 1000000000;
-//     }
-//
-// Example 3: Compute Duration from datetime.timedelta in Python.
-//
-//     td = datetime.timedelta(days=3, minutes=10)
-//     duration = Duration()
-//     duration.FromTimedelta(td)
-//
-// # JSON Mapping
-//
-// In JSON format, the Duration type is encoded as a string rather than an
-// object, where the string ends in the suffix "s" (indicating seconds) and
-// is preceded by the number of seconds, with nanoseconds expressed as
-// fractional seconds. For example, 3 seconds with 0 nanoseconds should be
-// encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should
-// be expressed in JSON format as "3.000000001s", and 3 seconds and 1
-// microsecond should be expressed in JSON format as "3.000001s".
-//
-//
-type Duration struct {
-	// Signed seconds of the span of time. Must be from -315,576,000,000
-	// to +315,576,000,000 inclusive. Note: these bounds are computed from:
-	// 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
-	Seconds int64 `protobuf:"varint,1,opt,name=seconds" json:"seconds,omitempty"`
-	// Signed fractions of a second at nanosecond resolution of the span
-	// of time. Durations less than one second are represented with a 0
-	// `seconds` field and a positive or negative `nanos` field. For durations
-	// of one second or more, a non-zero value for the `nanos` field must be
-	// of the same sign as the `seconds` field. Must be from -999,999,999
-	// to +999,999,999 inclusive.
-	Nanos                int32    `protobuf:"varint,2,opt,name=nanos" json:"nanos,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
+var File_github_com_golang_protobuf_ptypes_duration_duration_proto protoreflect.FileDescriptor
 
-func (m *Duration) Reset()         { *m = Duration{} }
-func (m *Duration) String() string { return proto.CompactTextString(m) }
-func (*Duration) ProtoMessage()    {}
-func (*Duration) Descriptor() ([]byte, []int) {
-	return fileDescriptor_duration_e7d612259e3f0613, []int{0}
-}
-func (*Duration) XXX_WellKnownType() string { return "Duration" }
-func (m *Duration) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Duration.Unmarshal(m, b)
-}
-func (m *Duration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Duration.Marshal(b, m, deterministic)
-}
-func (dst *Duration) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Duration.Merge(dst, src)
+var file_github_com_golang_protobuf_ptypes_duration_duration_proto_rawDesc = []byte{
+	0x0a, 0x39, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
+	0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79,
+	0x70, 0x65, 0x73, 0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x64, 0x75, 0x72,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x75, 0x72,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x42, 0x35, 0x5a, 0x33, 0x67,
+	0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67,
+	0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79, 0x70, 0x65, 0x73,
+	0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x50, 0x00, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
-func (m *Duration) XXX_Size() int {
-	return xxx_messageInfo_Duration.Size(m)
-}
-func (m *Duration) XXX_DiscardUnknown() {
-	xxx_messageInfo_Duration.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Duration proto.InternalMessageInfo
 
-func (m *Duration) GetSeconds() int64 {
-	if m != nil {
-		return m.Seconds
-	}
-	return 0
+var file_github_com_golang_protobuf_ptypes_duration_duration_proto_goTypes = []interface{}{}
+var file_github_com_golang_protobuf_ptypes_duration_duration_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
 }
 
-func (m *Duration) GetNanos() int32 {
-	if m != nil {
-		return m.Nanos
+func init() { file_github_com_golang_protobuf_ptypes_duration_duration_proto_init() }
+func file_github_com_golang_protobuf_ptypes_duration_duration_proto_init() {
+	if File_github_com_golang_protobuf_ptypes_duration_duration_proto != nil {
+		return
 	}
-	return 0
-}
-
-func init() {
-	proto.RegisterType((*Duration)(nil), "google.protobuf.Duration")
-}
-
-func init() {
-	proto.RegisterFile("google/protobuf/duration.proto", fileDescriptor_duration_e7d612259e3f0613)
-}
-
-var fileDescriptor_duration_e7d612259e3f0613 = []byte{
-	// 190 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4b, 0xcf, 0xcf, 0x4f,
-	0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x4f, 0x29, 0x2d, 0x4a,
-	0x2c, 0xc9, 0xcc, 0xcf, 0xd3, 0x03, 0x8b, 0x08, 0xf1, 0x43, 0xe4, 0xf5, 0x60, 0xf2, 0x4a, 0x56,
-	0x5c, 0x1c, 0x2e, 0x50, 0x25, 0x42, 0x12, 0x5c, 0xec, 0xc5, 0xa9, 0xc9, 0xf9, 0x79, 0x29, 0xc5,
-	0x12, 0x8c, 0x0a, 0x8c, 0x1a, 0xcc, 0x41, 0x30, 0xae, 0x90, 0x08, 0x17, 0x6b, 0x5e, 0x62, 0x5e,
-	0x7e, 0xb1, 0x04, 0x93, 0x02, 0xa3, 0x06, 0x6b, 0x10, 0x84, 0xe3, 0x54, 0xc3, 0x25, 0x9c, 0x9c,
-	0x9f, 0xab, 0x87, 0x66, 0xa4, 0x13, 0x2f, 0xcc, 0xc0, 0x00, 0x90, 0x48, 0x00, 0x63, 0x94, 0x56,
-	0x7a, 0x66, 0x49, 0x46, 0x69, 0x92, 0x5e, 0x72, 0x7e, 0xae, 0x7e, 0x7a, 0x7e, 0x4e, 0x62, 0x5e,
-	0x3a, 0xc2, 0x7d, 0x05, 0x25, 0x95, 0x05, 0xa9, 0xc5, 0x70, 0x67, 0xfe, 0x60, 0x64, 0x5c, 0xc4,
-	0xc4, 0xec, 0x1e, 0xe0, 0xb4, 0x8a, 0x49, 0xce, 0x1d, 0x62, 0x6e, 0x00, 0x54, 0xa9, 0x5e, 0x78,
-	0x6a, 0x4e, 0x8e, 0x77, 0x5e, 0x7e, 0x79, 0x5e, 0x08, 0x48, 0x4b, 0x12, 0x1b, 0xd8, 0x0c, 0x63,
-	0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0xdc, 0x84, 0x30, 0xff, 0xf3, 0x00, 0x00, 0x00,
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_github_com_golang_protobuf_ptypes_duration_duration_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   0,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_github_com_golang_protobuf_ptypes_duration_duration_proto_goTypes,
+		DependencyIndexes: file_github_com_golang_protobuf_ptypes_duration_duration_proto_depIdxs,
+	}.Build()
+	File_github_com_golang_protobuf_ptypes_duration_duration_proto = out.File
+	file_github_com_golang_protobuf_ptypes_duration_duration_proto_rawDesc = nil
+	file_github_com_golang_protobuf_ptypes_duration_duration_proto_goTypes = nil
+	file_github_com_golang_protobuf_ptypes_duration_duration_proto_depIdxs = nil
 }
diff --git a/vendor/github.com/golang/protobuf/ptypes/duration/duration.proto b/vendor/github.com/golang/protobuf/ptypes/duration/duration.proto
deleted file mode 100644
index 975fce41a..000000000
--- a/vendor/github.com/golang/protobuf/ptypes/duration/duration.proto
+++ /dev/null
@@ -1,117 +0,0 @@
-// Protocol Buffers - Google's data interchange format
-// Copyright 2008 Google Inc.  All rights reserved.
-// https://developers.google.com/protocol-buffers/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto3";
-
-package google.protobuf;
-
-option csharp_namespace = "Google.Protobuf.WellKnownTypes";
-option cc_enable_arenas = true;
-option go_package = "github.com/golang/protobuf/ptypes/duration";
-option java_package = "com.google.protobuf";
-option java_outer_classname = "DurationProto";
-option java_multiple_files = true;
-option objc_class_prefix = "GPB";
-
-// A Duration represents a signed, fixed-length span of time represented
-// as a count of seconds and fractions of seconds at nanosecond
-// resolution. It is independent of any calendar and concepts like "day"
-// or "month". It is related to Timestamp in that the difference between
-// two Timestamp values is a Duration and it can be added or subtracted
-// from a Timestamp. Range is approximately +-10,000 years.
-//
-// # Examples
-//
-// Example 1: Compute Duration from two Timestamps in pseudo code.
-//
-//     Timestamp start = ...;
-//     Timestamp end = ...;
-//     Duration duration = ...;
-//
-//     duration.seconds = end.seconds - start.seconds;
-//     duration.nanos = end.nanos - start.nanos;
-//
-//     if (duration.seconds < 0 && duration.nanos > 0) {
-//       duration.seconds += 1;
-//       duration.nanos -= 1000000000;
-//     } else if (durations.seconds > 0 && duration.nanos < 0) {
-//       duration.seconds -= 1;
-//       duration.nanos += 1000000000;
-//     }
-//
-// Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
-//
-//     Timestamp start = ...;
-//     Duration duration = ...;
-//     Timestamp end = ...;
-//
-//     end.seconds = start.seconds + duration.seconds;
-//     end.nanos = start.nanos + duration.nanos;
-//
-//     if (end.nanos < 0) {
-//       end.seconds -= 1;
-//       end.nanos += 1000000000;
-//     } else if (end.nanos >= 1000000000) {
-//       end.seconds += 1;
-//       end.nanos -= 1000000000;
-//     }
-//
-// Example 3: Compute Duration from datetime.timedelta in Python.
-//
-//     td = datetime.timedelta(days=3, minutes=10)
-//     duration = Duration()
-//     duration.FromTimedelta(td)
-//
-// # JSON Mapping
-//
-// In JSON format, the Duration type is encoded as a string rather than an
-// object, where the string ends in the suffix "s" (indicating seconds) and
-// is preceded by the number of seconds, with nanoseconds expressed as
-// fractional seconds. For example, 3 seconds with 0 nanoseconds should be
-// encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should
-// be expressed in JSON format as "3.000000001s", and 3 seconds and 1
-// microsecond should be expressed in JSON format as "3.000001s".
-//
-//
-message Duration {
-
-  // Signed seconds of the span of time. Must be from -315,576,000,000
-  // to +315,576,000,000 inclusive. Note: these bounds are computed from:
-  // 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
-  int64 seconds = 1;
-
-  // Signed fractions of a second at nanosecond resolution of the span
-  // of time. Durations less than one second are represented with a 0
-  // `seconds` field and a positive or negative `nanos` field. For durations
-  // of one second or more, a non-zero value for the `nanos` field must be
-  // of the same sign as the `seconds` field. Must be from -999,999,999
-  // to +999,999,999 inclusive.
-  int32 nanos = 2;
-}
diff --git a/vendor/github.com/golang/protobuf/ptypes/duration_test.go b/vendor/github.com/golang/protobuf/ptypes/duration_test.go
index e00491a34..b11827c2c 100644
--- a/vendor/github.com/golang/protobuf/ptypes/duration_test.go
+++ b/vendor/github.com/golang/protobuf/ptypes/duration_test.go
@@ -1,33 +1,6 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2016 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// Copyright 2016 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 ptypes
 
@@ -37,6 +10,7 @@ import (
 	"time"
 
 	"github.com/golang/protobuf/proto"
+
 	durpb "github.com/golang/protobuf/ptypes/duration"
 )
 
diff --git a/vendor/github.com/golang/protobuf/ptypes/empty/empty.pb.go b/vendor/github.com/golang/protobuf/ptypes/empty/empty.pb.go
index a69b403ce..16686a655 100644
--- a/vendor/github.com/golang/protobuf/ptypes/empty/empty.pb.go
+++ b/vendor/github.com/golang/protobuf/ptypes/empty/empty.pb.go
@@ -1,79 +1,62 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
-// source: google/protobuf/empty.proto
-
-package empty // import "github.com/golang/protobuf/ptypes/empty"
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-// A generic empty message that you can re-use to avoid defining duplicated
-// empty messages in your APIs. A typical example is to use it as the request
-// or the response type of an API method. For instance:
-//
-//     service Foo {
-//       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
-//     }
-//
-// The JSON representation for `Empty` is empty JSON object `{}`.
-type Empty struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *Empty) Reset()         { *m = Empty{} }
-func (m *Empty) String() string { return proto.CompactTextString(m) }
-func (*Empty) ProtoMessage()    {}
-func (*Empty) Descriptor() ([]byte, []int) {
-	return fileDescriptor_empty_39e6d6db0632e5b2, []int{0}
-}
-func (*Empty) XXX_WellKnownType() string { return "Empty" }
-func (m *Empty) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Empty.Unmarshal(m, b)
-}
-func (m *Empty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Empty.Marshal(b, m, deterministic)
-}
-func (dst *Empty) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Empty.Merge(dst, src)
-}
-func (m *Empty) XXX_Size() int {
-	return xxx_messageInfo_Empty.Size(m)
-}
-func (m *Empty) XXX_DiscardUnknown() {
-	xxx_messageInfo_Empty.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Empty proto.InternalMessageInfo
-
-func init() {
-	proto.RegisterType((*Empty)(nil), "google.protobuf.Empty")
-}
-
-func init() { proto.RegisterFile("google/protobuf/empty.proto", fileDescriptor_empty_39e6d6db0632e5b2) }
-
-var fileDescriptor_empty_39e6d6db0632e5b2 = []byte{
-	// 148 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4e, 0xcf, 0xcf, 0x4f,
-	0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x4f, 0xcd, 0x2d, 0x28,
-	0xa9, 0xd4, 0x03, 0x73, 0x85, 0xf8, 0x21, 0x92, 0x7a, 0x30, 0x49, 0x25, 0x76, 0x2e, 0x56, 0x57,
-	0x90, 0xbc, 0x53, 0x19, 0x97, 0x70, 0x72, 0x7e, 0xae, 0x1e, 0x9a, 0xbc, 0x13, 0x17, 0x58, 0x36,
-	0x00, 0xc4, 0x0d, 0x60, 0x8c, 0x52, 0x4f, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf,
-	0xd5, 0x4f, 0xcf, 0xcf, 0x49, 0xcc, 0x4b, 0x47, 0x58, 0x53, 0x50, 0x52, 0x59, 0x90, 0x5a, 0x0c,
-	0xb1, 0xed, 0x07, 0x23, 0xe3, 0x22, 0x26, 0x66, 0xf7, 0x00, 0xa7, 0x55, 0x4c, 0x72, 0xee, 0x10,
-	0x13, 0x03, 0xa0, 0xea, 0xf4, 0xc2, 0x53, 0x73, 0x72, 0xbc, 0xf3, 0xf2, 0xcb, 0xf3, 0x42, 0x40,
-	0xea, 0x93, 0xd8, 0xc0, 0x06, 0x18, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0x64, 0xd4, 0xb3, 0xa6,
-	0xb7, 0x00, 0x00, 0x00,
+// source: github.com/golang/protobuf/ptypes/empty/empty.proto
+
+package empty
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	emptypb "google.golang.org/protobuf/types/known/emptypb"
+	reflect "reflect"
+)
+
+// Symbols defined in public import of google/protobuf/empty.proto.
+
+type Empty = emptypb.Empty
+
+var File_github_com_golang_protobuf_ptypes_empty_empty_proto protoreflect.FileDescriptor
+
+var file_github_com_golang_protobuf_ptypes_empty_empty_proto_rawDesc = []byte{
+	0x0a, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
+	0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79,
+	0x70, 0x65, 0x73, 0x2f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1b, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x42, 0x2f, 0x5a, 0x2d, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d,
+	0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
+	0x2f, 0x70, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x3b, 0x65, 0x6d,
+	0x70, 0x74, 0x79, 0x50, 0x00, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var file_github_com_golang_protobuf_ptypes_empty_empty_proto_goTypes = []interface{}{}
+var file_github_com_golang_protobuf_ptypes_empty_empty_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_github_com_golang_protobuf_ptypes_empty_empty_proto_init() }
+func file_github_com_golang_protobuf_ptypes_empty_empty_proto_init() {
+	if File_github_com_golang_protobuf_ptypes_empty_empty_proto != nil {
+		return
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_github_com_golang_protobuf_ptypes_empty_empty_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   0,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_github_com_golang_protobuf_ptypes_empty_empty_proto_goTypes,
+		DependencyIndexes: file_github_com_golang_protobuf_ptypes_empty_empty_proto_depIdxs,
+	}.Build()
+	File_github_com_golang_protobuf_ptypes_empty_empty_proto = out.File
+	file_github_com_golang_protobuf_ptypes_empty_empty_proto_rawDesc = nil
+	file_github_com_golang_protobuf_ptypes_empty_empty_proto_goTypes = nil
+	file_github_com_golang_protobuf_ptypes_empty_empty_proto_depIdxs = nil
 }
diff --git a/vendor/github.com/golang/protobuf/ptypes/empty/empty.proto b/vendor/github.com/golang/protobuf/ptypes/empty/empty.proto
deleted file mode 100644
index 03cacd233..000000000
--- a/vendor/github.com/golang/protobuf/ptypes/empty/empty.proto
+++ /dev/null
@@ -1,52 +0,0 @@
-// Protocol Buffers - Google's data interchange format
-// Copyright 2008 Google Inc.  All rights reserved.
-// https://developers.google.com/protocol-buffers/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto3";
-
-package google.protobuf;
-
-option csharp_namespace = "Google.Protobuf.WellKnownTypes";
-option go_package = "github.com/golang/protobuf/ptypes/empty";
-option java_package = "com.google.protobuf";
-option java_outer_classname = "EmptyProto";
-option java_multiple_files = true;
-option objc_class_prefix = "GPB";
-option cc_enable_arenas = true;
-
-// A generic empty message that you can re-use to avoid defining duplicated
-// empty messages in your APIs. A typical example is to use it as the request
-// or the response type of an API method. For instance:
-//
-//     service Foo {
-//       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
-//     }
-//
-// The JSON representation for `Empty` is empty JSON object `{}`.
-message Empty {}
diff --git a/vendor/github.com/golang/protobuf/ptypes/struct/struct.pb.go b/vendor/github.com/golang/protobuf/ptypes/struct/struct.pb.go
index 442c0e099..8d82abe21 100644
--- a/vendor/github.com/golang/protobuf/ptypes/struct/struct.pb.go
+++ b/vendor/github.com/golang/protobuf/ptypes/struct/struct.pb.go
@@ -1,440 +1,78 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
-// source: google/protobuf/struct.proto
+// source: github.com/golang/protobuf/ptypes/struct/struct.proto
 
-package structpb // import "github.com/golang/protobuf/ptypes/struct"
+package structpb
 
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-// `NullValue` is a singleton enumeration to represent the null value for the
-// `Value` type union.
-//
-//  The JSON representation for `NullValue` is JSON `null`.
-type NullValue int32
-
-const (
-	// Null value.
-	NullValue_NULL_VALUE NullValue = 0
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	structpb "google.golang.org/protobuf/types/known/structpb"
+	reflect "reflect"
 )
 
-var NullValue_name = map[int32]string{
-	0: "NULL_VALUE",
-}
-var NullValue_value = map[string]int32{
-	"NULL_VALUE": 0,
-}
-
-func (x NullValue) String() string {
-	return proto.EnumName(NullValue_name, int32(x))
-}
-func (NullValue) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_struct_3a5a94e0c7801b27, []int{0}
-}
-func (NullValue) XXX_WellKnownType() string { return "NullValue" }
-
-// `Struct` represents a structured data value, consisting of fields
-// which map to dynamically typed values. In some languages, `Struct`
-// might be supported by a native representation. For example, in
-// scripting languages like JS a struct is represented as an
-// object. The details of that representation are described together
-// with the proto support for the language.
-//
-// The JSON representation for `Struct` is JSON object.
-type Struct struct {
-	// Unordered map of dynamically typed values.
-	Fields               map[string]*Value `protobuf:"bytes,1,rep,name=fields" json:"fields,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
-	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
-	XXX_unrecognized     []byte            `json:"-"`
-	XXX_sizecache        int32             `json:"-"`
-}
-
-func (m *Struct) Reset()         { *m = Struct{} }
-func (m *Struct) String() string { return proto.CompactTextString(m) }
-func (*Struct) ProtoMessage()    {}
-func (*Struct) Descriptor() ([]byte, []int) {
-	return fileDescriptor_struct_3a5a94e0c7801b27, []int{0}
-}
-func (*Struct) XXX_WellKnownType() string { return "Struct" }
-func (m *Struct) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Struct.Unmarshal(m, b)
-}
-func (m *Struct) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Struct.Marshal(b, m, deterministic)
-}
-func (dst *Struct) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Struct.Merge(dst, src)
-}
-func (m *Struct) XXX_Size() int {
-	return xxx_messageInfo_Struct.Size(m)
-}
-func (m *Struct) XXX_DiscardUnknown() {
-	xxx_messageInfo_Struct.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Struct proto.InternalMessageInfo
-
-func (m *Struct) GetFields() map[string]*Value {
-	if m != nil {
-		return m.Fields
-	}
-	return nil
-}
-
-// `Value` represents a dynamically typed value which can be either
-// null, a number, a string, a boolean, a recursive struct value, or a
-// list of values. A producer of value is expected to set one of that
-// variants, absence of any variant indicates an error.
-//
-// The JSON representation for `Value` is JSON value.
-type Value struct {
-	// The kind of value.
-	//
-	// Types that are valid to be assigned to Kind:
-	//	*Value_NullValue
-	//	*Value_NumberValue
-	//	*Value_StringValue
-	//	*Value_BoolValue
-	//	*Value_StructValue
-	//	*Value_ListValue
-	Kind                 isValue_Kind `protobuf_oneof:"kind"`
-	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
-	XXX_unrecognized     []byte       `json:"-"`
-	XXX_sizecache        int32        `json:"-"`
-}
-
-func (m *Value) Reset()         { *m = Value{} }
-func (m *Value) String() string { return proto.CompactTextString(m) }
-func (*Value) ProtoMessage()    {}
-func (*Value) Descriptor() ([]byte, []int) {
-	return fileDescriptor_struct_3a5a94e0c7801b27, []int{1}
-}
-func (*Value) XXX_WellKnownType() string { return "Value" }
-func (m *Value) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Value.Unmarshal(m, b)
-}
-func (m *Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Value.Marshal(b, m, deterministic)
-}
-func (dst *Value) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Value.Merge(dst, src)
-}
-func (m *Value) XXX_Size() int {
-	return xxx_messageInfo_Value.Size(m)
-}
-func (m *Value) XXX_DiscardUnknown() {
-	xxx_messageInfo_Value.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Value proto.InternalMessageInfo
-
-type isValue_Kind interface {
-	isValue_Kind()
-}
-
-type Value_NullValue struct {
-	NullValue NullValue `protobuf:"varint,1,opt,name=null_value,json=nullValue,enum=google.protobuf.NullValue,oneof"`
-}
-type Value_NumberValue struct {
-	NumberValue float64 `protobuf:"fixed64,2,opt,name=number_value,json=numberValue,oneof"`
-}
-type Value_StringValue struct {
-	StringValue string `protobuf:"bytes,3,opt,name=string_value,json=stringValue,oneof"`
-}
-type Value_BoolValue struct {
-	BoolValue bool `protobuf:"varint,4,opt,name=bool_value,json=boolValue,oneof"`
-}
-type Value_StructValue struct {
-	StructValue *Struct `protobuf:"bytes,5,opt,name=struct_value,json=structValue,oneof"`
-}
-type Value_ListValue struct {
-	ListValue *ListValue `protobuf:"bytes,6,opt,name=list_value,json=listValue,oneof"`
-}
-
-func (*Value_NullValue) isValue_Kind()   {}
-func (*Value_NumberValue) isValue_Kind() {}
-func (*Value_StringValue) isValue_Kind() {}
-func (*Value_BoolValue) isValue_Kind()   {}
-func (*Value_StructValue) isValue_Kind() {}
-func (*Value_ListValue) isValue_Kind()   {}
-
-func (m *Value) GetKind() isValue_Kind {
-	if m != nil {
-		return m.Kind
-	}
-	return nil
-}
-
-func (m *Value) GetNullValue() NullValue {
-	if x, ok := m.GetKind().(*Value_NullValue); ok {
-		return x.NullValue
+// Symbols defined in public import of google/protobuf/struct.proto.
+
+type NullValue = structpb.NullValue
+
+const NullValue_NULL_VALUE = structpb.NullValue_NULL_VALUE
+
+var NullValue_name = structpb.NullValue_name
+var NullValue_value = structpb.NullValue_value
+
+type Struct = structpb.Struct
+type Value = structpb.Value
+type Value_NullValue = structpb.Value_NullValue
+type Value_NumberValue = structpb.Value_NumberValue
+type Value_StringValue = structpb.Value_StringValue
+type Value_BoolValue = structpb.Value_BoolValue
+type Value_StructValue = structpb.Value_StructValue
+type Value_ListValue = structpb.Value_ListValue
+type ListValue = structpb.ListValue
+
+var File_github_com_golang_protobuf_ptypes_struct_struct_proto protoreflect.FileDescriptor
+
+var file_github_com_golang_protobuf_ptypes_struct_struct_proto_rawDesc = []byte{
+	0x0a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
+	0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79,
+	0x70, 0x65, 0x73, 0x2f, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x2f, 0x73, 0x74, 0x72, 0x75, 0x63,
+	0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x42, 0x33, 0x5a, 0x31, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e,
+	0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x73, 0x74, 0x72, 0x75, 0x63,
+	0x74, 0x3b, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x70, 0x62, 0x50, 0x00, 0x62, 0x06, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x33,
+}
+
+var file_github_com_golang_protobuf_ptypes_struct_struct_proto_goTypes = []interface{}{}
+var file_github_com_golang_protobuf_ptypes_struct_struct_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_github_com_golang_protobuf_ptypes_struct_struct_proto_init() }
+func file_github_com_golang_protobuf_ptypes_struct_struct_proto_init() {
+	if File_github_com_golang_protobuf_ptypes_struct_struct_proto != nil {
+		return
 	}
-	return NullValue_NULL_VALUE
-}
-
-func (m *Value) GetNumberValue() float64 {
-	if x, ok := m.GetKind().(*Value_NumberValue); ok {
-		return x.NumberValue
-	}
-	return 0
-}
-
-func (m *Value) GetStringValue() string {
-	if x, ok := m.GetKind().(*Value_StringValue); ok {
-		return x.StringValue
-	}
-	return ""
-}
-
-func (m *Value) GetBoolValue() bool {
-	if x, ok := m.GetKind().(*Value_BoolValue); ok {
-		return x.BoolValue
-	}
-	return false
-}
-
-func (m *Value) GetStructValue() *Struct {
-	if x, ok := m.GetKind().(*Value_StructValue); ok {
-		return x.StructValue
-	}
-	return nil
-}
-
-func (m *Value) GetListValue() *ListValue {
-	if x, ok := m.GetKind().(*Value_ListValue); ok {
-		return x.ListValue
-	}
-	return nil
-}
-
-// XXX_OneofFuncs is for the internal use of the proto package.
-func (*Value) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
-	return _Value_OneofMarshaler, _Value_OneofUnmarshaler, _Value_OneofSizer, []interface{}{
-		(*Value_NullValue)(nil),
-		(*Value_NumberValue)(nil),
-		(*Value_StringValue)(nil),
-		(*Value_BoolValue)(nil),
-		(*Value_StructValue)(nil),
-		(*Value_ListValue)(nil),
-	}
-}
-
-func _Value_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
-	m := msg.(*Value)
-	// kind
-	switch x := m.Kind.(type) {
-	case *Value_NullValue:
-		b.EncodeVarint(1<<3 | proto.WireVarint)
-		b.EncodeVarint(uint64(x.NullValue))
-	case *Value_NumberValue:
-		b.EncodeVarint(2<<3 | proto.WireFixed64)
-		b.EncodeFixed64(math.Float64bits(x.NumberValue))
-	case *Value_StringValue:
-		b.EncodeVarint(3<<3 | proto.WireBytes)
-		b.EncodeStringBytes(x.StringValue)
-	case *Value_BoolValue:
-		t := uint64(0)
-		if x.BoolValue {
-			t = 1
-		}
-		b.EncodeVarint(4<<3 | proto.WireVarint)
-		b.EncodeVarint(t)
-	case *Value_StructValue:
-		b.EncodeVarint(5<<3 | proto.WireBytes)
-		if err := b.EncodeMessage(x.StructValue); err != nil {
-			return err
-		}
-	case *Value_ListValue:
-		b.EncodeVarint(6<<3 | proto.WireBytes)
-		if err := b.EncodeMessage(x.ListValue); err != nil {
-			return err
-		}
-	case nil:
-	default:
-		return fmt.Errorf("Value.Kind has unexpected type %T", x)
-	}
-	return nil
-}
-
-func _Value_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
-	m := msg.(*Value)
-	switch tag {
-	case 1: // kind.null_value
-		if wire != proto.WireVarint {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeVarint()
-		m.Kind = &Value_NullValue{NullValue(x)}
-		return true, err
-	case 2: // kind.number_value
-		if wire != proto.WireFixed64 {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeFixed64()
-		m.Kind = &Value_NumberValue{math.Float64frombits(x)}
-		return true, err
-	case 3: // kind.string_value
-		if wire != proto.WireBytes {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeStringBytes()
-		m.Kind = &Value_StringValue{x}
-		return true, err
-	case 4: // kind.bool_value
-		if wire != proto.WireVarint {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeVarint()
-		m.Kind = &Value_BoolValue{x != 0}
-		return true, err
-	case 5: // kind.struct_value
-		if wire != proto.WireBytes {
-			return true, proto.ErrInternalBadWireType
-		}
-		msg := new(Struct)
-		err := b.DecodeMessage(msg)
-		m.Kind = &Value_StructValue{msg}
-		return true, err
-	case 6: // kind.list_value
-		if wire != proto.WireBytes {
-			return true, proto.ErrInternalBadWireType
-		}
-		msg := new(ListValue)
-		err := b.DecodeMessage(msg)
-		m.Kind = &Value_ListValue{msg}
-		return true, err
-	default:
-		return false, nil
-	}
-}
-
-func _Value_OneofSizer(msg proto.Message) (n int) {
-	m := msg.(*Value)
-	// kind
-	switch x := m.Kind.(type) {
-	case *Value_NullValue:
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(x.NullValue))
-	case *Value_NumberValue:
-		n += 1 // tag and wire
-		n += 8
-	case *Value_StringValue:
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(len(x.StringValue)))
-		n += len(x.StringValue)
-	case *Value_BoolValue:
-		n += 1 // tag and wire
-		n += 1
-	case *Value_StructValue:
-		s := proto.Size(x.StructValue)
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(s))
-		n += s
-	case *Value_ListValue:
-		s := proto.Size(x.ListValue)
-		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(s))
-		n += s
-	case nil:
-	default:
-		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
-	}
-	return n
-}
-
-// `ListValue` is a wrapper around a repeated field of values.
-//
-// The JSON representation for `ListValue` is JSON array.
-type ListValue struct {
-	// Repeated field of dynamically typed values.
-	Values               []*Value `protobuf:"bytes,1,rep,name=values" json:"values,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *ListValue) Reset()         { *m = ListValue{} }
-func (m *ListValue) String() string { return proto.CompactTextString(m) }
-func (*ListValue) ProtoMessage()    {}
-func (*ListValue) Descriptor() ([]byte, []int) {
-	return fileDescriptor_struct_3a5a94e0c7801b27, []int{2}
-}
-func (*ListValue) XXX_WellKnownType() string { return "ListValue" }
-func (m *ListValue) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ListValue.Unmarshal(m, b)
-}
-func (m *ListValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ListValue.Marshal(b, m, deterministic)
-}
-func (dst *ListValue) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ListValue.Merge(dst, src)
-}
-func (m *ListValue) XXX_Size() int {
-	return xxx_messageInfo_ListValue.Size(m)
-}
-func (m *ListValue) XXX_DiscardUnknown() {
-	xxx_messageInfo_ListValue.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ListValue proto.InternalMessageInfo
-
-func (m *ListValue) GetValues() []*Value {
-	if m != nil {
-		return m.Values
-	}
-	return nil
-}
-
-func init() {
-	proto.RegisterType((*Struct)(nil), "google.protobuf.Struct")
-	proto.RegisterMapType((map[string]*Value)(nil), "google.protobuf.Struct.FieldsEntry")
-	proto.RegisterType((*Value)(nil), "google.protobuf.Value")
-	proto.RegisterType((*ListValue)(nil), "google.protobuf.ListValue")
-	proto.RegisterEnum("google.protobuf.NullValue", NullValue_name, NullValue_value)
-}
-
-func init() {
-	proto.RegisterFile("google/protobuf/struct.proto", fileDescriptor_struct_3a5a94e0c7801b27)
-}
-
-var fileDescriptor_struct_3a5a94e0c7801b27 = []byte{
-	// 417 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x92, 0x41, 0x8b, 0xd3, 0x40,
-	0x14, 0xc7, 0x3b, 0xc9, 0x36, 0x98, 0x17, 0x59, 0x97, 0x11, 0xb4, 0xac, 0xa2, 0xa1, 0x7b, 0x09,
-	0x22, 0x29, 0xd6, 0x8b, 0x18, 0x2f, 0x06, 0xd6, 0x5d, 0x30, 0x2c, 0x31, 0xba, 0x15, 0xbc, 0x94,
-	0x26, 0x4d, 0x63, 0xe8, 0x74, 0x26, 0x24, 0x33, 0x4a, 0x8f, 0x7e, 0x0b, 0xcf, 0x1e, 0x3d, 0xfa,
-	0xe9, 0x3c, 0xca, 0xcc, 0x24, 0xa9, 0xb4, 0xf4, 0x94, 0xbc, 0xf7, 0x7e, 0xef, 0x3f, 0xef, 0xff,
-	0x66, 0xe0, 0x71, 0xc1, 0x58, 0x41, 0xf2, 0x49, 0x55, 0x33, 0xce, 0x52, 0xb1, 0x9a, 0x34, 0xbc,
-	0x16, 0x19, 0xf7, 0x55, 0x8c, 0xef, 0xe9, 0xaa, 0xdf, 0x55, 0xc7, 0x3f, 0x11, 0x58, 0x1f, 0x15,
-	0x81, 0x03, 0xb0, 0x56, 0x65, 0x4e, 0x96, 0xcd, 0x08, 0xb9, 0xa6, 0xe7, 0x4c, 0x2f, 0xfc, 0x3d,
-	0xd8, 0xd7, 0xa0, 0xff, 0x4e, 0x51, 0x97, 0x94, 0xd7, 0xdb, 0xa4, 0x6d, 0x39, 0xff, 0x00, 0xce,
-	0x7f, 0x69, 0x7c, 0x06, 0xe6, 0x3a, 0xdf, 0x8e, 0x90, 0x8b, 0x3c, 0x3b, 0x91, 0xbf, 0xf8, 0x39,
-	0x0c, 0xbf, 0x2d, 0x88, 0xc8, 0x47, 0x86, 0x8b, 0x3c, 0x67, 0xfa, 0xe0, 0x40, 0x7c, 0x26, 0xab,
-	0x89, 0x86, 0x5e, 0x1b, 0xaf, 0xd0, 0xf8, 0x8f, 0x01, 0x43, 0x95, 0xc4, 0x01, 0x00, 0x15, 0x84,
-	0xcc, 0xb5, 0x80, 0x14, 0x3d, 0x9d, 0x9e, 0x1f, 0x08, 0xdc, 0x08, 0x42, 0x14, 0x7f, 0x3d, 0x48,
-	0x6c, 0xda, 0x05, 0xf8, 0x02, 0xee, 0x52, 0xb1, 0x49, 0xf3, 0x7a, 0xbe, 0x3b, 0x1f, 0x5d, 0x0f,
-	0x12, 0x47, 0x67, 0x7b, 0xa8, 0xe1, 0x75, 0x49, 0x8b, 0x16, 0x32, 0xe5, 0xe0, 0x12, 0xd2, 0x59,
-	0x0d, 0x3d, 0x05, 0x48, 0x19, 0xeb, 0xc6, 0x38, 0x71, 0x91, 0x77, 0x47, 0x1e, 0x25, 0x73, 0x1a,
-	0x78, 0xa3, 0x54, 0x44, 0xc6, 0x5b, 0x64, 0xa8, 0xac, 0x3e, 0x3c, 0xb2, 0xc7, 0x56, 0x5e, 0x64,
-	0xbc, 0x77, 0x49, 0xca, 0xa6, 0xeb, 0xb5, 0x54, 0xef, 0xa1, 0xcb, 0xa8, 0x6c, 0x78, 0xef, 0x92,
-	0x74, 0x41, 0x68, 0xc1, 0xc9, 0xba, 0xa4, 0xcb, 0x71, 0x00, 0x76, 0x4f, 0x60, 0x1f, 0x2c, 0x25,
-	0xd6, 0xdd, 0xe8, 0xb1, 0xa5, 0xb7, 0xd4, 0xb3, 0x47, 0x60, 0xf7, 0x4b, 0xc4, 0xa7, 0x00, 0x37,
-	0xb7, 0x51, 0x34, 0x9f, 0xbd, 0x8d, 0x6e, 0x2f, 0xcf, 0x06, 0xe1, 0x0f, 0x04, 0xf7, 0x33, 0xb6,
-	0xd9, 0x97, 0x08, 0x1d, 0xed, 0x26, 0x96, 0x71, 0x8c, 0xbe, 0xbc, 0x28, 0x4a, 0xfe, 0x55, 0xa4,
-	0x7e, 0xc6, 0x36, 0x93, 0x82, 0x91, 0x05, 0x2d, 0x76, 0x4f, 0xb1, 0xe2, 0xdb, 0x2a, 0x6f, 0xda,
-	0x17, 0x19, 0xe8, 0x4f, 0x95, 0xfe, 0x45, 0xe8, 0x97, 0x61, 0x5e, 0xc5, 0xe1, 0x6f, 0xe3, 0xc9,
-	0x95, 0x16, 0x8f, 0xbb, 0xf9, 0x3e, 0xe7, 0x84, 0xbc, 0xa7, 0xec, 0x3b, 0xfd, 0x24, 0x3b, 0x53,
-	0x4b, 0x49, 0xbd, 0xfc, 0x17, 0x00, 0x00, 0xff, 0xff, 0xe8, 0x1b, 0x59, 0xf8, 0xe5, 0x02, 0x00,
-	0x00,
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_github_com_golang_protobuf_ptypes_struct_struct_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   0,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_github_com_golang_protobuf_ptypes_struct_struct_proto_goTypes,
+		DependencyIndexes: file_github_com_golang_protobuf_ptypes_struct_struct_proto_depIdxs,
+	}.Build()
+	File_github_com_golang_protobuf_ptypes_struct_struct_proto = out.File
+	file_github_com_golang_protobuf_ptypes_struct_struct_proto_rawDesc = nil
+	file_github_com_golang_protobuf_ptypes_struct_struct_proto_goTypes = nil
+	file_github_com_golang_protobuf_ptypes_struct_struct_proto_depIdxs = nil
 }
diff --git a/vendor/github.com/golang/protobuf/ptypes/struct/struct.proto b/vendor/github.com/golang/protobuf/ptypes/struct/struct.proto
deleted file mode 100644
index 7d7808e7f..000000000
--- a/vendor/github.com/golang/protobuf/ptypes/struct/struct.proto
+++ /dev/null
@@ -1,96 +0,0 @@
-// Protocol Buffers - Google's data interchange format
-// Copyright 2008 Google Inc.  All rights reserved.
-// https://developers.google.com/protocol-buffers/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto3";
-
-package google.protobuf;
-
-option csharp_namespace = "Google.Protobuf.WellKnownTypes";
-option cc_enable_arenas = true;
-option go_package = "github.com/golang/protobuf/ptypes/struct;structpb";
-option java_package = "com.google.protobuf";
-option java_outer_classname = "StructProto";
-option java_multiple_files = true;
-option objc_class_prefix = "GPB";
-
-
-// `Struct` represents a structured data value, consisting of fields
-// which map to dynamically typed values. In some languages, `Struct`
-// might be supported by a native representation. For example, in
-// scripting languages like JS a struct is represented as an
-// object. The details of that representation are described together
-// with the proto support for the language.
-//
-// The JSON representation for `Struct` is JSON object.
-message Struct {
-  // Unordered map of dynamically typed values.
-  map<string, Value> fields = 1;
-}
-
-// `Value` represents a dynamically typed value which can be either
-// null, a number, a string, a boolean, a recursive struct value, or a
-// list of values. A producer of value is expected to set one of that
-// variants, absence of any variant indicates an error.
-//
-// The JSON representation for `Value` is JSON value.
-message Value {
-  // The kind of value.
-  oneof kind {
-    // Represents a null value.
-    NullValue null_value = 1;
-    // Represents a double value.
-    double number_value = 2;
-    // Represents a string value.
-    string string_value = 3;
-    // Represents a boolean value.
-    bool bool_value = 4;
-    // Represents a structured value.
-    Struct struct_value = 5;
-    // Represents a repeated `Value`.
-    ListValue list_value = 6;
-  }
-}
-
-// `NullValue` is a singleton enumeration to represent the null value for the
-// `Value` type union.
-//
-//  The JSON representation for `NullValue` is JSON `null`.
-enum NullValue {
-  // Null value.
-  NULL_VALUE = 0;
-}
-
-// `ListValue` is a wrapper around a repeated field of values.
-//
-// The JSON representation for `ListValue` is JSON array.
-message ListValue {
-  // Repeated field of dynamically typed values.
-  repeated Value values = 1;
-}
diff --git a/vendor/github.com/golang/protobuf/ptypes/timestamp.go b/vendor/github.com/golang/protobuf/ptypes/timestamp.go
index 47f10dbc2..026d0d491 100644
--- a/vendor/github.com/golang/protobuf/ptypes/timestamp.go
+++ b/vendor/github.com/golang/protobuf/ptypes/timestamp.go
@@ -1,46 +1,18 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2016 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// Copyright 2016 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 ptypes
 
-// This file implements operations on google.protobuf.Timestamp.
-
 import (
 	"errors"
 	"fmt"
 	"time"
 
-	tspb "github.com/golang/protobuf/ptypes/timestamp"
+	timestamppb "github.com/golang/protobuf/ptypes/timestamp"
 )
 
+// Range of google.protobuf.Duration as specified in timestamp.proto.
 const (
 	// Seconds field of the earliest valid Timestamp.
 	// This is time.Date(1, 1, 1, 0, 0, 0, 0, time.UTC).Unix().
@@ -50,44 +22,18 @@ const (
 	maxValidSeconds = 253402300800
 )
 
-// validateTimestamp determines whether a Timestamp is valid.
-// A valid timestamp represents a time in the range
-// [0001-01-01, 10000-01-01) and has a Nanos field
-// in the range [0, 1e9).
-//
-// If the Timestamp is valid, validateTimestamp returns nil.
-// Otherwise, it returns an error that describes
-// the problem.
-//
-// Every valid Timestamp can be represented by a time.Time, but the converse is not true.
-func validateTimestamp(ts *tspb.Timestamp) error {
-	if ts == nil {
-		return errors.New("timestamp: nil Timestamp")
-	}
-	if ts.Seconds < minValidSeconds {
-		return fmt.Errorf("timestamp: %v before 0001-01-01", ts)
-	}
-	if ts.Seconds >= maxValidSeconds {
-		return fmt.Errorf("timestamp: %v after 10000-01-01", ts)
-	}
-	if ts.Nanos < 0 || ts.Nanos >= 1e9 {
-		return fmt.Errorf("timestamp: %v: nanos not in range [0, 1e9)", ts)
-	}
-	return nil
-}
-
-// Timestamp converts a google.protobuf.Timestamp proto to a time.Time.
+// Timestamp converts a timestamppb.Timestamp to a time.Time.
 // It returns an error if the argument is invalid.
 //
-// Unlike most Go functions, if Timestamp returns an error, the first return value
-// is not the zero time.Time. Instead, it is the value obtained from the
+// Unlike most Go functions, if Timestamp returns an error, the first return
+// value is not the zero time.Time. Instead, it is the value obtained from the
 // time.Unix function when passed the contents of the Timestamp, in the UTC
 // locale. This may or may not be a meaningful time; many invalid Timestamps
 // do map to valid time.Times.
 //
 // A nil Timestamp returns an error. The first return value in that case is
 // undefined.
-func Timestamp(ts *tspb.Timestamp) (time.Time, error) {
+func Timestamp(ts *timestamppb.Timestamp) (time.Time, error) {
 	// Don't return the zero value on error, because corresponds to a valid
 	// timestamp. Instead return whatever time.Unix gives us.
 	var t time.Time
@@ -100,7 +46,7 @@ func Timestamp(ts *tspb.Timestamp) (time.Time, error) {
 }
 
 // TimestampNow returns a google.protobuf.Timestamp for the current time.
-func TimestampNow() *tspb.Timestamp {
+func TimestampNow() *timestamppb.Timestamp {
 	ts, err := TimestampProto(time.Now())
 	if err != nil {
 		panic("ptypes: time.Now() out of Timestamp range")
@@ -110,12 +56,10 @@ func TimestampNow() *tspb.Timestamp {
 
 // TimestampProto converts the time.Time to a google.protobuf.Timestamp proto.
 // It returns an error if the resulting Timestamp is invalid.
-func TimestampProto(t time.Time) (*tspb.Timestamp, error) {
-	seconds := t.Unix()
-	nanos := int32(t.Sub(time.Unix(seconds, 0)))
-	ts := &tspb.Timestamp{
-		Seconds: seconds,
-		Nanos:   nanos,
+func TimestampProto(t time.Time) (*timestamppb.Timestamp, error) {
+	ts := &timestamppb.Timestamp{
+		Seconds: t.Unix(),
+		Nanos:   int32(t.Nanosecond()),
 	}
 	if err := validateTimestamp(ts); err != nil {
 		return nil, err
@@ -123,12 +67,37 @@ func TimestampProto(t time.Time) (*tspb.Timestamp, error) {
 	return ts, nil
 }
 
-// TimestampString returns the RFC 3339 string for valid Timestamps. For invalid
-// Timestamps, it returns an error message in parentheses.
-func TimestampString(ts *tspb.Timestamp) string {
+// TimestampString returns the RFC 3339 string for valid Timestamps.
+// For invalid Timestamps, it returns an error message in parentheses.
+func TimestampString(ts *timestamppb.Timestamp) string {
 	t, err := Timestamp(ts)
 	if err != nil {
 		return fmt.Sprintf("(%v)", err)
 	}
 	return t.Format(time.RFC3339Nano)
 }
+
+// validateTimestamp determines whether a Timestamp is valid.
+// A valid timestamp represents a time in the range [0001-01-01, 10000-01-01)
+// and has a Nanos field in the range [0, 1e9).
+//
+// If the Timestamp is valid, validateTimestamp returns nil.
+// Otherwise, it returns an error that describes the problem.
+//
+// Every valid Timestamp can be represented by a time.Time,
+// but the converse is not true.
+func validateTimestamp(ts *timestamppb.Timestamp) error {
+	if ts == nil {
+		return errors.New("timestamp: nil Timestamp")
+	}
+	if ts.Seconds < minValidSeconds {
+		return fmt.Errorf("timestamp: %v before 0001-01-01", ts)
+	}
+	if ts.Seconds >= maxValidSeconds {
+		return fmt.Errorf("timestamp: %v after 10000-01-01", ts)
+	}
+	if ts.Nanos < 0 || ts.Nanos >= 1e9 {
+		return fmt.Errorf("timestamp: %v: nanos not in range [0, 1e9)", ts)
+	}
+	return nil
+}
diff --git a/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go b/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go
index e9c222282..a76f80760 100644
--- a/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go
+++ b/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go
@@ -1,175 +1,64 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
-// source: google/protobuf/timestamp.proto
+// source: github.com/golang/protobuf/ptypes/timestamp/timestamp.proto
 
-package timestamp // import "github.com/golang/protobuf/ptypes/timestamp"
+package timestamp
 
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
+	reflect "reflect"
+)
 
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
+// Symbols defined in public import of google/protobuf/timestamp.proto.
 
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+type Timestamp = timestamppb.Timestamp
 
-// A Timestamp represents a point in time independent of any time zone
-// or calendar, represented as seconds and fractions of seconds at
-// nanosecond resolution in UTC Epoch time. It is encoded using the
-// Proleptic Gregorian Calendar which extends the Gregorian calendar
-// backwards to year one. It is encoded assuming all minutes are 60
-// seconds long, i.e. leap seconds are "smeared" so that no leap second
-// table is needed for interpretation. Range is from
-// 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z.
-// By restricting to that range, we ensure that we can convert to
-// and from  RFC 3339 date strings.
-// See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt).
-//
-// # Examples
-//
-// Example 1: Compute Timestamp from POSIX `time()`.
-//
-//     Timestamp timestamp;
-//     timestamp.set_seconds(time(NULL));
-//     timestamp.set_nanos(0);
-//
-// Example 2: Compute Timestamp from POSIX `gettimeofday()`.
-//
-//     struct timeval tv;
-//     gettimeofday(&tv, NULL);
-//
-//     Timestamp timestamp;
-//     timestamp.set_seconds(tv.tv_sec);
-//     timestamp.set_nanos(tv.tv_usec * 1000);
-//
-// Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
-//
-//     FILETIME ft;
-//     GetSystemTimeAsFileTime(&ft);
-//     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
-//
-//     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
-//     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
-//     Timestamp timestamp;
-//     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
-//     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
-//
-// Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
-//
-//     long millis = System.currentTimeMillis();
-//
-//     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
-//         .setNanos((int) ((millis % 1000) * 1000000)).build();
-//
-//
-// Example 5: Compute Timestamp from current time in Python.
-//
-//     timestamp = Timestamp()
-//     timestamp.GetCurrentTime()
-//
-// # JSON Mapping
-//
-// In JSON format, the Timestamp type is encoded as a string in the
-// [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
-// format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
-// where {year} is always expressed using four digits while {month}, {day},
-// {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
-// seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
-// are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
-// is required, though only UTC (as indicated by "Z") is presently supported.
-//
-// For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
-// 01:30 UTC on January 15, 2017.
-//
-// In JavaScript, one can convert a Date object to this format using the
-// standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString]
-// method. In Python, a standard `datetime.datetime` object can be converted
-// to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime)
-// with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one
-// can use the Joda Time's [`ISODateTimeFormat.dateTime()`](
-// http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime--)
-// to obtain a formatter capable of generating timestamps in this format.
-//
-//
-type Timestamp struct {
-	// Represents seconds of UTC time since Unix epoch
-	// 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
-	// 9999-12-31T23:59:59Z inclusive.
-	Seconds int64 `protobuf:"varint,1,opt,name=seconds" json:"seconds,omitempty"`
-	// Non-negative fractions of a second at nanosecond resolution. Negative
-	// second values with fractions must still have non-negative nanos values
-	// that count forward in time. Must be from 0 to 999,999,999
-	// inclusive.
-	Nanos                int32    `protobuf:"varint,2,opt,name=nanos" json:"nanos,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
+var File_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto protoreflect.FileDescriptor
 
-func (m *Timestamp) Reset()         { *m = Timestamp{} }
-func (m *Timestamp) String() string { return proto.CompactTextString(m) }
-func (*Timestamp) ProtoMessage()    {}
-func (*Timestamp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_timestamp_b826e8e5fba671a8, []int{0}
-}
-func (*Timestamp) XXX_WellKnownType() string { return "Timestamp" }
-func (m *Timestamp) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Timestamp.Unmarshal(m, b)
-}
-func (m *Timestamp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Timestamp.Marshal(b, m, deterministic)
-}
-func (dst *Timestamp) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Timestamp.Merge(dst, src)
+var file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_rawDesc = []byte{
+	0x0a, 0x3b, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
+	0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79,
+	0x70, 0x65, 0x73, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2f, 0x74, 0x69,
+	0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74,
+	0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x42, 0x37,
+	0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
+	0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79,
+	0x70, 0x65, 0x73, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x3b, 0x74, 0x69,
+	0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x50, 0x00, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x33,
 }
-func (m *Timestamp) XXX_Size() int {
-	return xxx_messageInfo_Timestamp.Size(m)
-}
-func (m *Timestamp) XXX_DiscardUnknown() {
-	xxx_messageInfo_Timestamp.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Timestamp proto.InternalMessageInfo
 
-func (m *Timestamp) GetSeconds() int64 {
-	if m != nil {
-		return m.Seconds
-	}
-	return 0
+var file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_goTypes = []interface{}{}
+var file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
 }
 
-func (m *Timestamp) GetNanos() int32 {
-	if m != nil {
-		return m.Nanos
+func init() { file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_init() }
+func file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_init() {
+	if File_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto != nil {
+		return
 	}
-	return 0
-}
-
-func init() {
-	proto.RegisterType((*Timestamp)(nil), "google.protobuf.Timestamp")
-}
-
-func init() {
-	proto.RegisterFile("google/protobuf/timestamp.proto", fileDescriptor_timestamp_b826e8e5fba671a8)
-}
-
-var fileDescriptor_timestamp_b826e8e5fba671a8 = []byte{
-	// 191 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4f, 0xcf, 0xcf, 0x4f,
-	0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x2f, 0xc9, 0xcc, 0x4d,
-	0x2d, 0x2e, 0x49, 0xcc, 0x2d, 0xd0, 0x03, 0x0b, 0x09, 0xf1, 0x43, 0x14, 0xe8, 0xc1, 0x14, 0x28,
-	0x59, 0x73, 0x71, 0x86, 0xc0, 0xd4, 0x08, 0x49, 0x70, 0xb1, 0x17, 0xa7, 0x26, 0xe7, 0xe7, 0xa5,
-	0x14, 0x4b, 0x30, 0x2a, 0x30, 0x6a, 0x30, 0x07, 0xc1, 0xb8, 0x42, 0x22, 0x5c, 0xac, 0x79, 0x89,
-	0x79, 0xf9, 0xc5, 0x12, 0x4c, 0x0a, 0x8c, 0x1a, 0xac, 0x41, 0x10, 0x8e, 0x53, 0x1d, 0x97, 0x70,
-	0x72, 0x7e, 0xae, 0x1e, 0x9a, 0x99, 0x4e, 0x7c, 0x70, 0x13, 0x03, 0x40, 0x42, 0x01, 0x8c, 0x51,
-	0xda, 0xe9, 0x99, 0x25, 0x19, 0xa5, 0x49, 0x7a, 0xc9, 0xf9, 0xb9, 0xfa, 0xe9, 0xf9, 0x39, 0x89,
-	0x79, 0xe9, 0x08, 0x27, 0x16, 0x94, 0x54, 0x16, 0xa4, 0x16, 0x23, 0x5c, 0xfa, 0x83, 0x91, 0x71,
-	0x11, 0x13, 0xb3, 0x7b, 0x80, 0xd3, 0x2a, 0x26, 0x39, 0x77, 0x88, 0xc9, 0x01, 0x50, 0xb5, 0x7a,
-	0xe1, 0xa9, 0x39, 0x39, 0xde, 0x79, 0xf9, 0xe5, 0x79, 0x21, 0x20, 0x3d, 0x49, 0x6c, 0x60, 0x43,
-	0x8c, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0xbc, 0x77, 0x4a, 0x07, 0xf7, 0x00, 0x00, 0x00,
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   0,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_goTypes,
+		DependencyIndexes: file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_depIdxs,
+	}.Build()
+	File_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto = out.File
+	file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_rawDesc = nil
+	file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_goTypes = nil
+	file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_depIdxs = nil
 }
diff --git a/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.proto b/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.proto
deleted file mode 100644
index 06750ab1f..000000000
--- a/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.proto
+++ /dev/null
@@ -1,133 +0,0 @@
-// Protocol Buffers - Google's data interchange format
-// Copyright 2008 Google Inc.  All rights reserved.
-// https://developers.google.com/protocol-buffers/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto3";
-
-package google.protobuf;
-
-option csharp_namespace = "Google.Protobuf.WellKnownTypes";
-option cc_enable_arenas = true;
-option go_package = "github.com/golang/protobuf/ptypes/timestamp";
-option java_package = "com.google.protobuf";
-option java_outer_classname = "TimestampProto";
-option java_multiple_files = true;
-option objc_class_prefix = "GPB";
-
-// A Timestamp represents a point in time independent of any time zone
-// or calendar, represented as seconds and fractions of seconds at
-// nanosecond resolution in UTC Epoch time. It is encoded using the
-// Proleptic Gregorian Calendar which extends the Gregorian calendar
-// backwards to year one. It is encoded assuming all minutes are 60
-// seconds long, i.e. leap seconds are "smeared" so that no leap second
-// table is needed for interpretation. Range is from
-// 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z.
-// By restricting to that range, we ensure that we can convert to
-// and from  RFC 3339 date strings.
-// See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt).
-//
-// # Examples
-//
-// Example 1: Compute Timestamp from POSIX `time()`.
-//
-//     Timestamp timestamp;
-//     timestamp.set_seconds(time(NULL));
-//     timestamp.set_nanos(0);
-//
-// Example 2: Compute Timestamp from POSIX `gettimeofday()`.
-//
-//     struct timeval tv;
-//     gettimeofday(&tv, NULL);
-//
-//     Timestamp timestamp;
-//     timestamp.set_seconds(tv.tv_sec);
-//     timestamp.set_nanos(tv.tv_usec * 1000);
-//
-// Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
-//
-//     FILETIME ft;
-//     GetSystemTimeAsFileTime(&ft);
-//     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
-//
-//     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
-//     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
-//     Timestamp timestamp;
-//     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
-//     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
-//
-// Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
-//
-//     long millis = System.currentTimeMillis();
-//
-//     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
-//         .setNanos((int) ((millis % 1000) * 1000000)).build();
-//
-//
-// Example 5: Compute Timestamp from current time in Python.
-//
-//     timestamp = Timestamp()
-//     timestamp.GetCurrentTime()
-//
-// # JSON Mapping
-//
-// In JSON format, the Timestamp type is encoded as a string in the
-// [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
-// format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
-// where {year} is always expressed using four digits while {month}, {day},
-// {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
-// seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
-// are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
-// is required, though only UTC (as indicated by "Z") is presently supported.
-//
-// For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
-// 01:30 UTC on January 15, 2017.
-//
-// In JavaScript, one can convert a Date object to this format using the
-// standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString]
-// method. In Python, a standard `datetime.datetime` object can be converted
-// to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime)
-// with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one
-// can use the Joda Time's [`ISODateTimeFormat.dateTime()`](
-// http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime--)
-// to obtain a formatter capable of generating timestamps in this format.
-//
-//
-message Timestamp {
-
-  // Represents seconds of UTC time since Unix epoch
-  // 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
-  // 9999-12-31T23:59:59Z inclusive.
-  int64 seconds = 1;
-
-  // Non-negative fractions of a second at nanosecond resolution. Negative
-  // second values with fractions must still have non-negative nanos values
-  // that count forward in time. Must be from 0 to 999,999,999
-  // inclusive.
-  int32 nanos = 2;
-}
diff --git a/vendor/github.com/golang/protobuf/ptypes/timestamp_test.go b/vendor/github.com/golang/protobuf/ptypes/timestamp_test.go
index 6e3c969b9..07efdfd82 100644
--- a/vendor/github.com/golang/protobuf/ptypes/timestamp_test.go
+++ b/vendor/github.com/golang/protobuf/ptypes/timestamp_test.go
@@ -1,33 +1,6 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2016 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// Copyright 2016 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 ptypes
 
@@ -37,6 +10,7 @@ import (
 	"time"
 
 	"github.com/golang/protobuf/proto"
+
 	tspb "github.com/golang/protobuf/ptypes/timestamp"
 )
 
@@ -124,7 +98,6 @@ func TestTimestampString(t *testing.T) {
 		// Not much testing needed because presumably time.Format is
 		// well-tested.
 		{&tspb.Timestamp{Seconds: 0, Nanos: 0}, "1970-01-01T00:00:00Z"},
-		{&tspb.Timestamp{Seconds: minValidSeconds - 1, Nanos: 0}, "(timestamp: seconds:-62135596801  before 0001-01-01)"},
 	} {
 		got := TimestampString(test.ts)
 		if got != test.want {
diff --git a/vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.pb.go b/vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.pb.go
index d1fc4d0b8..cc40f27ad 100644
--- a/vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.pb.go
+++ b/vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.pb.go
@@ -1,443 +1,71 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
-// source: google/protobuf/wrappers.proto
-
-package wrappers // import "github.com/golang/protobuf/ptypes/wrappers"
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-// Wrapper message for `double`.
-//
-// The JSON representation for `DoubleValue` is JSON number.
-type DoubleValue struct {
-	// The double value.
-	Value                float64  `protobuf:"fixed64,1,opt,name=value" json:"value,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *DoubleValue) Reset()         { *m = DoubleValue{} }
-func (m *DoubleValue) String() string { return proto.CompactTextString(m) }
-func (*DoubleValue) ProtoMessage()    {}
-func (*DoubleValue) Descriptor() ([]byte, []int) {
-	return fileDescriptor_wrappers_16c7c35c009f3253, []int{0}
-}
-func (*DoubleValue) XXX_WellKnownType() string { return "DoubleValue" }
-func (m *DoubleValue) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_DoubleValue.Unmarshal(m, b)
-}
-func (m *DoubleValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_DoubleValue.Marshal(b, m, deterministic)
-}
-func (dst *DoubleValue) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_DoubleValue.Merge(dst, src)
-}
-func (m *DoubleValue) XXX_Size() int {
-	return xxx_messageInfo_DoubleValue.Size(m)
-}
-func (m *DoubleValue) XXX_DiscardUnknown() {
-	xxx_messageInfo_DoubleValue.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_DoubleValue proto.InternalMessageInfo
-
-func (m *DoubleValue) GetValue() float64 {
-	if m != nil {
-		return m.Value
-	}
-	return 0
-}
-
-// Wrapper message for `float`.
-//
-// The JSON representation for `FloatValue` is JSON number.
-type FloatValue struct {
-	// The float value.
-	Value                float32  `protobuf:"fixed32,1,opt,name=value" json:"value,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *FloatValue) Reset()         { *m = FloatValue{} }
-func (m *FloatValue) String() string { return proto.CompactTextString(m) }
-func (*FloatValue) ProtoMessage()    {}
-func (*FloatValue) Descriptor() ([]byte, []int) {
-	return fileDescriptor_wrappers_16c7c35c009f3253, []int{1}
-}
-func (*FloatValue) XXX_WellKnownType() string { return "FloatValue" }
-func (m *FloatValue) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_FloatValue.Unmarshal(m, b)
-}
-func (m *FloatValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_FloatValue.Marshal(b, m, deterministic)
-}
-func (dst *FloatValue) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_FloatValue.Merge(dst, src)
-}
-func (m *FloatValue) XXX_Size() int {
-	return xxx_messageInfo_FloatValue.Size(m)
-}
-func (m *FloatValue) XXX_DiscardUnknown() {
-	xxx_messageInfo_FloatValue.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_FloatValue proto.InternalMessageInfo
-
-func (m *FloatValue) GetValue() float32 {
-	if m != nil {
-		return m.Value
+// source: github.com/golang/protobuf/ptypes/wrappers/wrappers.proto
+
+package wrappers
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	wrapperspb "google.golang.org/protobuf/types/known/wrapperspb"
+	reflect "reflect"
+)
+
+// Symbols defined in public import of google/protobuf/wrappers.proto.
+
+type DoubleValue = wrapperspb.DoubleValue
+type FloatValue = wrapperspb.FloatValue
+type Int64Value = wrapperspb.Int64Value
+type UInt64Value = wrapperspb.UInt64Value
+type Int32Value = wrapperspb.Int32Value
+type UInt32Value = wrapperspb.UInt32Value
+type BoolValue = wrapperspb.BoolValue
+type StringValue = wrapperspb.StringValue
+type BytesValue = wrapperspb.BytesValue
+
+var File_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto protoreflect.FileDescriptor
+
+var file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_rawDesc = []byte{
+	0x0a, 0x39, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
+	0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79,
+	0x70, 0x65, 0x73, 0x2f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x73, 0x2f, 0x77, 0x72, 0x61,
+	0x70, 0x70, 0x65, 0x72, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x77, 0x72, 0x61,
+	0x70, 0x70, 0x65, 0x72, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x42, 0x35, 0x5a, 0x33, 0x67,
+	0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67,
+	0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79, 0x70, 0x65, 0x73,
+	0x2f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x73, 0x3b, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65,
+	0x72, 0x73, 0x50, 0x00, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_goTypes = []interface{}{}
+var file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_init() }
+func file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_init() {
+	if File_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto != nil {
+		return
 	}
-	return 0
-}
-
-// Wrapper message for `int64`.
-//
-// The JSON representation for `Int64Value` is JSON string.
-type Int64Value struct {
-	// The int64 value.
-	Value                int64    `protobuf:"varint,1,opt,name=value" json:"value,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *Int64Value) Reset()         { *m = Int64Value{} }
-func (m *Int64Value) String() string { return proto.CompactTextString(m) }
-func (*Int64Value) ProtoMessage()    {}
-func (*Int64Value) Descriptor() ([]byte, []int) {
-	return fileDescriptor_wrappers_16c7c35c009f3253, []int{2}
-}
-func (*Int64Value) XXX_WellKnownType() string { return "Int64Value" }
-func (m *Int64Value) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Int64Value.Unmarshal(m, b)
-}
-func (m *Int64Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Int64Value.Marshal(b, m, deterministic)
-}
-func (dst *Int64Value) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Int64Value.Merge(dst, src)
-}
-func (m *Int64Value) XXX_Size() int {
-	return xxx_messageInfo_Int64Value.Size(m)
-}
-func (m *Int64Value) XXX_DiscardUnknown() {
-	xxx_messageInfo_Int64Value.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Int64Value proto.InternalMessageInfo
-
-func (m *Int64Value) GetValue() int64 {
-	if m != nil {
-		return m.Value
-	}
-	return 0
-}
-
-// Wrapper message for `uint64`.
-//
-// The JSON representation for `UInt64Value` is JSON string.
-type UInt64Value struct {
-	// The uint64 value.
-	Value                uint64   `protobuf:"varint,1,opt,name=value" json:"value,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *UInt64Value) Reset()         { *m = UInt64Value{} }
-func (m *UInt64Value) String() string { return proto.CompactTextString(m) }
-func (*UInt64Value) ProtoMessage()    {}
-func (*UInt64Value) Descriptor() ([]byte, []int) {
-	return fileDescriptor_wrappers_16c7c35c009f3253, []int{3}
-}
-func (*UInt64Value) XXX_WellKnownType() string { return "UInt64Value" }
-func (m *UInt64Value) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_UInt64Value.Unmarshal(m, b)
-}
-func (m *UInt64Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_UInt64Value.Marshal(b, m, deterministic)
-}
-func (dst *UInt64Value) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_UInt64Value.Merge(dst, src)
-}
-func (m *UInt64Value) XXX_Size() int {
-	return xxx_messageInfo_UInt64Value.Size(m)
-}
-func (m *UInt64Value) XXX_DiscardUnknown() {
-	xxx_messageInfo_UInt64Value.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_UInt64Value proto.InternalMessageInfo
-
-func (m *UInt64Value) GetValue() uint64 {
-	if m != nil {
-		return m.Value
-	}
-	return 0
-}
-
-// Wrapper message for `int32`.
-//
-// The JSON representation for `Int32Value` is JSON number.
-type Int32Value struct {
-	// The int32 value.
-	Value                int32    `protobuf:"varint,1,opt,name=value" json:"value,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *Int32Value) Reset()         { *m = Int32Value{} }
-func (m *Int32Value) String() string { return proto.CompactTextString(m) }
-func (*Int32Value) ProtoMessage()    {}
-func (*Int32Value) Descriptor() ([]byte, []int) {
-	return fileDescriptor_wrappers_16c7c35c009f3253, []int{4}
-}
-func (*Int32Value) XXX_WellKnownType() string { return "Int32Value" }
-func (m *Int32Value) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Int32Value.Unmarshal(m, b)
-}
-func (m *Int32Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Int32Value.Marshal(b, m, deterministic)
-}
-func (dst *Int32Value) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Int32Value.Merge(dst, src)
-}
-func (m *Int32Value) XXX_Size() int {
-	return xxx_messageInfo_Int32Value.Size(m)
-}
-func (m *Int32Value) XXX_DiscardUnknown() {
-	xxx_messageInfo_Int32Value.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Int32Value proto.InternalMessageInfo
-
-func (m *Int32Value) GetValue() int32 {
-	if m != nil {
-		return m.Value
-	}
-	return 0
-}
-
-// Wrapper message for `uint32`.
-//
-// The JSON representation for `UInt32Value` is JSON number.
-type UInt32Value struct {
-	// The uint32 value.
-	Value                uint32   `protobuf:"varint,1,opt,name=value" json:"value,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *UInt32Value) Reset()         { *m = UInt32Value{} }
-func (m *UInt32Value) String() string { return proto.CompactTextString(m) }
-func (*UInt32Value) ProtoMessage()    {}
-func (*UInt32Value) Descriptor() ([]byte, []int) {
-	return fileDescriptor_wrappers_16c7c35c009f3253, []int{5}
-}
-func (*UInt32Value) XXX_WellKnownType() string { return "UInt32Value" }
-func (m *UInt32Value) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_UInt32Value.Unmarshal(m, b)
-}
-func (m *UInt32Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_UInt32Value.Marshal(b, m, deterministic)
-}
-func (dst *UInt32Value) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_UInt32Value.Merge(dst, src)
-}
-func (m *UInt32Value) XXX_Size() int {
-	return xxx_messageInfo_UInt32Value.Size(m)
-}
-func (m *UInt32Value) XXX_DiscardUnknown() {
-	xxx_messageInfo_UInt32Value.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_UInt32Value proto.InternalMessageInfo
-
-func (m *UInt32Value) GetValue() uint32 {
-	if m != nil {
-		return m.Value
-	}
-	return 0
-}
-
-// Wrapper message for `bool`.
-//
-// The JSON representation for `BoolValue` is JSON `true` and `false`.
-type BoolValue struct {
-	// The bool value.
-	Value                bool     `protobuf:"varint,1,opt,name=value" json:"value,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *BoolValue) Reset()         { *m = BoolValue{} }
-func (m *BoolValue) String() string { return proto.CompactTextString(m) }
-func (*BoolValue) ProtoMessage()    {}
-func (*BoolValue) Descriptor() ([]byte, []int) {
-	return fileDescriptor_wrappers_16c7c35c009f3253, []int{6}
-}
-func (*BoolValue) XXX_WellKnownType() string { return "BoolValue" }
-func (m *BoolValue) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_BoolValue.Unmarshal(m, b)
-}
-func (m *BoolValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_BoolValue.Marshal(b, m, deterministic)
-}
-func (dst *BoolValue) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_BoolValue.Merge(dst, src)
-}
-func (m *BoolValue) XXX_Size() int {
-	return xxx_messageInfo_BoolValue.Size(m)
-}
-func (m *BoolValue) XXX_DiscardUnknown() {
-	xxx_messageInfo_BoolValue.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_BoolValue proto.InternalMessageInfo
-
-func (m *BoolValue) GetValue() bool {
-	if m != nil {
-		return m.Value
-	}
-	return false
-}
-
-// Wrapper message for `string`.
-//
-// The JSON representation for `StringValue` is JSON string.
-type StringValue struct {
-	// The string value.
-	Value                string   `protobuf:"bytes,1,opt,name=value" json:"value,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *StringValue) Reset()         { *m = StringValue{} }
-func (m *StringValue) String() string { return proto.CompactTextString(m) }
-func (*StringValue) ProtoMessage()    {}
-func (*StringValue) Descriptor() ([]byte, []int) {
-	return fileDescriptor_wrappers_16c7c35c009f3253, []int{7}
-}
-func (*StringValue) XXX_WellKnownType() string { return "StringValue" }
-func (m *StringValue) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_StringValue.Unmarshal(m, b)
-}
-func (m *StringValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_StringValue.Marshal(b, m, deterministic)
-}
-func (dst *StringValue) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_StringValue.Merge(dst, src)
-}
-func (m *StringValue) XXX_Size() int {
-	return xxx_messageInfo_StringValue.Size(m)
-}
-func (m *StringValue) XXX_DiscardUnknown() {
-	xxx_messageInfo_StringValue.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_StringValue proto.InternalMessageInfo
-
-func (m *StringValue) GetValue() string {
-	if m != nil {
-		return m.Value
-	}
-	return ""
-}
-
-// Wrapper message for `bytes`.
-//
-// The JSON representation for `BytesValue` is JSON string.
-type BytesValue struct {
-	// The bytes value.
-	Value                []byte   `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *BytesValue) Reset()         { *m = BytesValue{} }
-func (m *BytesValue) String() string { return proto.CompactTextString(m) }
-func (*BytesValue) ProtoMessage()    {}
-func (*BytesValue) Descriptor() ([]byte, []int) {
-	return fileDescriptor_wrappers_16c7c35c009f3253, []int{8}
-}
-func (*BytesValue) XXX_WellKnownType() string { return "BytesValue" }
-func (m *BytesValue) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_BytesValue.Unmarshal(m, b)
-}
-func (m *BytesValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_BytesValue.Marshal(b, m, deterministic)
-}
-func (dst *BytesValue) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_BytesValue.Merge(dst, src)
-}
-func (m *BytesValue) XXX_Size() int {
-	return xxx_messageInfo_BytesValue.Size(m)
-}
-func (m *BytesValue) XXX_DiscardUnknown() {
-	xxx_messageInfo_BytesValue.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_BytesValue proto.InternalMessageInfo
-
-func (m *BytesValue) GetValue() []byte {
-	if m != nil {
-		return m.Value
-	}
-	return nil
-}
-
-func init() {
-	proto.RegisterType((*DoubleValue)(nil), "google.protobuf.DoubleValue")
-	proto.RegisterType((*FloatValue)(nil), "google.protobuf.FloatValue")
-	proto.RegisterType((*Int64Value)(nil), "google.protobuf.Int64Value")
-	proto.RegisterType((*UInt64Value)(nil), "google.protobuf.UInt64Value")
-	proto.RegisterType((*Int32Value)(nil), "google.protobuf.Int32Value")
-	proto.RegisterType((*UInt32Value)(nil), "google.protobuf.UInt32Value")
-	proto.RegisterType((*BoolValue)(nil), "google.protobuf.BoolValue")
-	proto.RegisterType((*StringValue)(nil), "google.protobuf.StringValue")
-	proto.RegisterType((*BytesValue)(nil), "google.protobuf.BytesValue")
-}
-
-func init() {
-	proto.RegisterFile("google/protobuf/wrappers.proto", fileDescriptor_wrappers_16c7c35c009f3253)
-}
-
-var fileDescriptor_wrappers_16c7c35c009f3253 = []byte{
-	// 259 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4b, 0xcf, 0xcf, 0x4f,
-	0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x2f, 0x2f, 0x4a, 0x2c,
-	0x28, 0x48, 0x2d, 0x2a, 0xd6, 0x03, 0x8b, 0x08, 0xf1, 0x43, 0xe4, 0xf5, 0x60, 0xf2, 0x4a, 0xca,
-	0x5c, 0xdc, 0x2e, 0xf9, 0xa5, 0x49, 0x39, 0xa9, 0x61, 0x89, 0x39, 0xa5, 0xa9, 0x42, 0x22, 0x5c,
-	0xac, 0x65, 0x20, 0x86, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0x63, 0x10, 0x84, 0xa3, 0xa4, 0xc4, 0xc5,
-	0xe5, 0x96, 0x93, 0x9f, 0x58, 0x82, 0x45, 0x0d, 0x13, 0x92, 0x1a, 0xcf, 0xbc, 0x12, 0x33, 0x13,
-	0x2c, 0x6a, 0x98, 0x61, 0x6a, 0x94, 0xb9, 0xb8, 0x43, 0x71, 0x29, 0x62, 0x41, 0x35, 0xc8, 0xd8,
-	0x08, 0x8b, 0x1a, 0x56, 0x34, 0x83, 0xb0, 0x2a, 0xe2, 0x85, 0x29, 0x52, 0xe4, 0xe2, 0x74, 0xca,
-	0xcf, 0xcf, 0xc1, 0xa2, 0x84, 0x03, 0xc9, 0x9c, 0xe0, 0x92, 0xa2, 0xcc, 0xbc, 0x74, 0x2c, 0x8a,
-	0x38, 0x91, 0x1c, 0xe4, 0x54, 0x59, 0x92, 0x5a, 0x8c, 0x45, 0x0d, 0x0f, 0x54, 0x8d, 0x53, 0x0d,
-	0x97, 0x70, 0x72, 0x7e, 0xae, 0x1e, 0x5a, 0xe8, 0x3a, 0xf1, 0x86, 0x43, 0x83, 0x3f, 0x00, 0x24,
-	0x12, 0xc0, 0x18, 0xa5, 0x95, 0x9e, 0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97, 0x9c, 0x9f, 0xab, 0x9f,
-	0x9e, 0x9f, 0x93, 0x98, 0x97, 0x8e, 0x88, 0xaa, 0x82, 0x92, 0xca, 0x82, 0xd4, 0x62, 0x78, 0x8c,
-	0xfd, 0x60, 0x64, 0x5c, 0xc4, 0xc4, 0xec, 0x1e, 0xe0, 0xb4, 0x8a, 0x49, 0xce, 0x1d, 0x62, 0x6e,
-	0x00, 0x54, 0xa9, 0x5e, 0x78, 0x6a, 0x4e, 0x8e, 0x77, 0x5e, 0x7e, 0x79, 0x5e, 0x08, 0x48, 0x4b,
-	0x12, 0x1b, 0xd8, 0x0c, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0x19, 0x6c, 0xb9, 0xb8, 0xfe,
-	0x01, 0x00, 0x00,
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   0,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_goTypes,
+		DependencyIndexes: file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_depIdxs,
+	}.Build()
+	File_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto = out.File
+	file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_rawDesc = nil
+	file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_goTypes = nil
+	file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_depIdxs = nil
 }
diff --git a/vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.proto b/vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.proto
deleted file mode 100644
index 01947639a..000000000
--- a/vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.proto
+++ /dev/null
@@ -1,118 +0,0 @@
-// Protocol Buffers - Google's data interchange format
-// Copyright 2008 Google Inc.  All rights reserved.
-// https://developers.google.com/protocol-buffers/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Wrappers for primitive (non-message) types. These types are useful
-// for embedding primitives in the `google.protobuf.Any` type and for places
-// where we need to distinguish between the absence of a primitive
-// typed field and its default value.
-
-syntax = "proto3";
-
-package google.protobuf;
-
-option csharp_namespace = "Google.Protobuf.WellKnownTypes";
-option cc_enable_arenas = true;
-option go_package = "github.com/golang/protobuf/ptypes/wrappers";
-option java_package = "com.google.protobuf";
-option java_outer_classname = "WrappersProto";
-option java_multiple_files = true;
-option objc_class_prefix = "GPB";
-
-// Wrapper message for `double`.
-//
-// The JSON representation for `DoubleValue` is JSON number.
-message DoubleValue {
-  // The double value.
-  double value = 1;
-}
-
-// Wrapper message for `float`.
-//
-// The JSON representation for `FloatValue` is JSON number.
-message FloatValue {
-  // The float value.
-  float value = 1;
-}
-
-// Wrapper message for `int64`.
-//
-// The JSON representation for `Int64Value` is JSON string.
-message Int64Value {
-  // The int64 value.
-  int64 value = 1;
-}
-
-// Wrapper message for `uint64`.
-//
-// The JSON representation for `UInt64Value` is JSON string.
-message UInt64Value {
-  // The uint64 value.
-  uint64 value = 1;
-}
-
-// Wrapper message for `int32`.
-//
-// The JSON representation for `Int32Value` is JSON number.
-message Int32Value {
-  // The int32 value.
-  int32 value = 1;
-}
-
-// Wrapper message for `uint32`.
-//
-// The JSON representation for `UInt32Value` is JSON number.
-message UInt32Value {
-  // The uint32 value.
-  uint32 value = 1;
-}
-
-// Wrapper message for `bool`.
-//
-// The JSON representation for `BoolValue` is JSON `true` and `false`.
-message BoolValue {
-  // The bool value.
-  bool value = 1;
-}
-
-// Wrapper message for `string`.
-//
-// The JSON representation for `StringValue` is JSON string.
-message StringValue {
-  // The string value.
-  string value = 1;
-}
-
-// Wrapper message for `bytes`.
-//
-// The JSON representation for `BytesValue` is JSON string.
-message BytesValue {
-  // The bytes value.
-  bytes value = 1;
-}
diff --git a/vendor/github.com/golang/protobuf/regenerate.bash b/vendor/github.com/golang/protobuf/regenerate.bash
new file mode 100644
index 000000000..f6c35c5af
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/regenerate.bash
@@ -0,0 +1,9 @@
+#!/bin/bash
+# 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.
+
+cd "$(git rev-parse --show-toplevel)"
+set -e
+go run ./internal/cmd/generate-alias -execute
+go test ./protoc-gen-go -regenerate
diff --git a/vendor/github.com/golang/protobuf/regenerate.sh b/vendor/github.com/golang/protobuf/regenerate.sh
deleted file mode 100644
index dc7e2d1f6..000000000
--- a/vendor/github.com/golang/protobuf/regenerate.sh
+++ /dev/null
@@ -1,53 +0,0 @@
-#!/bin/bash
-
-set -e
-
-# Install the working tree's protoc-gen-gen in a tempdir.
-tmpdir=$(mktemp -d -t regen-wkt.XXXXXX)
-trap 'rm -rf $tmpdir' EXIT
-mkdir -p $tmpdir/bin
-PATH=$tmpdir/bin:$PATH
-GOBIN=$tmpdir/bin go install ./protoc-gen-go
-
-# Public imports require at least Go 1.9.
-supportTypeAliases=""
-if go list -f '{{context.ReleaseTags}}' runtime | grep -q go1.9; then
-  supportTypeAliases=1
-fi
-
-# Generate various test protos.
-PROTO_DIRS=(
-  conformance/internal/conformance_proto
-  jsonpb/jsonpb_test_proto
-  proto
-  protoc-gen-go/testdata
-)
-for dir in ${PROTO_DIRS[@]}; do
-  for p in `find $dir -name "*.proto"`; do
-    if [[ $p == */import_public/* && ! $supportTypeAliases ]]; then
-      echo "# $p (skipped)"
-      continue;
-    fi
-    echo "# $p"
-    protoc -I$dir --go_out=plugins=grpc,paths=source_relative:$dir $p
-  done
-done
-
-# Deriving the location of the source protos from the path to the
-# protoc binary may be a bit odd, but this is what protoc itself does.
-PROTO_INCLUDE=$(dirname $(dirname $(which protoc)))/include
-
-# Well-known types.
-WKT_PROTOS=(any duration empty struct timestamp wrappers)
-for p in ${WKT_PROTOS[@]}; do
-  echo "# google/protobuf/$p.proto"
-  protoc --go_out=paths=source_relative:$tmpdir google/protobuf/$p.proto
-  cp $tmpdir/google/protobuf/$p.pb.go ptypes/$p
-  cp $PROTO_INCLUDE/google/protobuf/$p.proto ptypes/$p
-done
-
-# descriptor.proto.
-echo "# google/protobuf/descriptor.proto"
-protoc --go_out=paths=source_relative:$tmpdir google/protobuf/descriptor.proto
-cp $tmpdir/google/protobuf/descriptor.pb.go protoc-gen-go/descriptor
-cp $PROTO_INCLUDE/google/protobuf/descriptor.proto protoc-gen-go/descriptor
diff --git a/vendor/github.com/golang/protobuf/test.bash b/vendor/github.com/golang/protobuf/test.bash
new file mode 100644
index 000000000..c213adebd
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/test.bash
@@ -0,0 +1,41 @@
+#!/bin/bash
+# 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.
+
+cd "$(git rev-parse --show-toplevel)"
+
+BOLD="\x1b[1mRunning: "
+PASS="\x1b[32mPASS"
+FAIL="\x1b[31mFAIL"
+RESET="\x1b[0m"
+
+echo -e "${BOLD}go test ./...${RESET}"
+RET_TEST0=$(go test ./... | egrep -v "^(ok|[?])\s+")
+if [[ ! -z "$RET_TEST0" ]]; then echo "$RET_TEST0"; echo; fi
+
+echo -e "${BOLD}go test -tags purego ./...${RESET}"
+RET_TEST1=$(go test -tags purego ./... | egrep -v "^(ok|[?])\s+")
+if [[ ! -z "$RET_TEST1" ]]; then echo "$RET_TEST1"; echo; fi
+
+echo -e "${BOLD}go generate${RESET}"
+RET_GEN=$(go run ./internal/cmd/generate-alias 2>&1)
+if [[ ! -z "$RET_GEN" ]]; then echo "$RET_GEN"; echo; fi
+
+echo -e "${BOLD}go fmt${RESET}"
+RET_FMT=$(gofmt -d $(git ls-files *.go) 2>&1)
+if [[ ! -z "$RET_FMT" ]]; then echo "$RET_FMT"; echo; fi
+
+echo -e "${BOLD}git diff${RESET}"
+RET_DIFF=$(git diff --no-prefix HEAD 2>&1)
+if [[ ! -z "$RET_DIFF" ]]; then echo "$RET_DIFF"; echo; fi
+
+echo -e "${BOLD}git ls-files${RESET}"
+RET_FILES=$(git ls-files --others --exclude-standard 2>&1)
+if [[ ! -z "$RET_FILES" ]]; then echo "$RET_FILES"; echo; fi
+
+if [[ ! -z "$RET_TEST0" ]] || [[ ! -z "$RET_TEST1" ]] || [[ ! -z "$RET_GEN" ]] || [ ! -z "$RET_FMT" ] || [[ ! -z "$RET_DIFF" ]] || [[ ! -z "$RET_FILES" ]]; then
+	echo -e "${FAIL}${RESET}"; exit 1
+else
+	echo -e "${PASS}${RESET}"; exit 0
+fi
diff --git a/vendor/github.com/google/uuid/.travis.yml b/vendor/github.com/google/uuid/.travis.yml
new file mode 100644
index 000000000..d8156a60b
--- /dev/null
+++ b/vendor/github.com/google/uuid/.travis.yml
@@ -0,0 +1,9 @@
+language: go
+
+go:
+  - 1.4.3
+  - 1.5.3
+  - tip
+
+script:
+  - go test -v ./...
diff --git a/vendor/github.com/google/uuid/CONTRIBUTING.md b/vendor/github.com/google/uuid/CONTRIBUTING.md
new file mode 100644
index 000000000..04fdf09f1
--- /dev/null
+++ b/vendor/github.com/google/uuid/CONTRIBUTING.md
@@ -0,0 +1,10 @@
+# How to contribute
+
+We definitely welcome patches and contribution to this project!
+
+### Legal requirements
+
+In order to protect both you and ourselves, you will need to sign the
+[Contributor License Agreement](https://cla.developers.google.com/clas).
+
+You may have already signed it for other Google projects.
diff --git a/vendor/github.com/google/uuid/CONTRIBUTORS b/vendor/github.com/google/uuid/CONTRIBUTORS
new file mode 100644
index 000000000..b4bb97f6b
--- /dev/null
+++ b/vendor/github.com/google/uuid/CONTRIBUTORS
@@ -0,0 +1,9 @@
+Paul Borman <borman@google.com>
+bmatsuo
+shawnps
+theory
+jboverfelt
+dsymonds
+cd1
+wallclockbuilder
+dansouza
diff --git a/vendor/github.com/google/uuid/LICENSE b/vendor/github.com/google/uuid/LICENSE
new file mode 100644
index 000000000..5dc68268d
--- /dev/null
+++ b/vendor/github.com/google/uuid/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2009,2014 Google Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/github.com/google/uuid/README.md b/vendor/github.com/google/uuid/README.md
new file mode 100644
index 000000000..f765a46f9
--- /dev/null
+++ b/vendor/github.com/google/uuid/README.md
@@ -0,0 +1,19 @@
+# uuid ![build status](https://travis-ci.org/google/uuid.svg?branch=master)
+The uuid package generates and inspects UUIDs based on
+[RFC 4122](http://tools.ietf.org/html/rfc4122)
+and DCE 1.1: Authentication and Security Services. 
+
+This package is based on the github.com/pborman/uuid package (previously named
+code.google.com/p/go-uuid).  It differs from these earlier packages in that
+a UUID is a 16 byte array rather than a byte slice.  One loss due to this
+change is the ability to represent an invalid UUID (vs a NIL UUID).
+
+###### Install
+`go get github.com/google/uuid`
+
+###### Documentation 
+[![GoDoc](https://godoc.org/github.com/google/uuid?status.svg)](http://godoc.org/github.com/google/uuid)
+
+Full `go doc` style documentation for the package can be viewed online without
+installing this package by using the GoDoc site here: 
+http://pkg.go.dev/github.com/google/uuid
diff --git a/vendor/github.com/google/uuid/dce.go b/vendor/github.com/google/uuid/dce.go
new file mode 100644
index 000000000..fa820b9d3
--- /dev/null
+++ b/vendor/github.com/google/uuid/dce.go
@@ -0,0 +1,80 @@
+// Copyright 2016 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import (
+	"encoding/binary"
+	"fmt"
+	"os"
+)
+
+// A Domain represents a Version 2 domain
+type Domain byte
+
+// Domain constants for DCE Security (Version 2) UUIDs.
+const (
+	Person = Domain(0)
+	Group  = Domain(1)
+	Org    = Domain(2)
+)
+
+// NewDCESecurity returns a DCE Security (Version 2) UUID.
+//
+// The domain should be one of Person, Group or Org.
+// On a POSIX system the id should be the users UID for the Person
+// domain and the users GID for the Group.  The meaning of id for
+// the domain Org or on non-POSIX systems is site defined.
+//
+// For a given domain/id pair the same token may be returned for up to
+// 7 minutes and 10 seconds.
+func NewDCESecurity(domain Domain, id uint32) (UUID, error) {
+	uuid, err := NewUUID()
+	if err == nil {
+		uuid[6] = (uuid[6] & 0x0f) | 0x20 // Version 2
+		uuid[9] = byte(domain)
+		binary.BigEndian.PutUint32(uuid[0:], id)
+	}
+	return uuid, err
+}
+
+// NewDCEPerson returns a DCE Security (Version 2) UUID in the person
+// domain with the id returned by os.Getuid.
+//
+//  NewDCESecurity(Person, uint32(os.Getuid()))
+func NewDCEPerson() (UUID, error) {
+	return NewDCESecurity(Person, uint32(os.Getuid()))
+}
+
+// NewDCEGroup returns a DCE Security (Version 2) UUID in the group
+// domain with the id returned by os.Getgid.
+//
+//  NewDCESecurity(Group, uint32(os.Getgid()))
+func NewDCEGroup() (UUID, error) {
+	return NewDCESecurity(Group, uint32(os.Getgid()))
+}
+
+// Domain returns the domain for a Version 2 UUID.  Domains are only defined
+// for Version 2 UUIDs.
+func (uuid UUID) Domain() Domain {
+	return Domain(uuid[9])
+}
+
+// ID returns the id for a Version 2 UUID. IDs are only defined for Version 2
+// UUIDs.
+func (uuid UUID) ID() uint32 {
+	return binary.BigEndian.Uint32(uuid[0:4])
+}
+
+func (d Domain) String() string {
+	switch d {
+	case Person:
+		return "Person"
+	case Group:
+		return "Group"
+	case Org:
+		return "Org"
+	}
+	return fmt.Sprintf("Domain%d", int(d))
+}
diff --git a/vendor/github.com/google/uuid/doc.go b/vendor/github.com/google/uuid/doc.go
new file mode 100644
index 000000000..5b8a4b9af
--- /dev/null
+++ b/vendor/github.com/google/uuid/doc.go
@@ -0,0 +1,12 @@
+// Copyright 2016 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package uuid generates and inspects UUIDs.
+//
+// UUIDs are based on RFC 4122 and DCE 1.1: Authentication and Security
+// Services.
+//
+// A UUID is a 16 byte (128 bit) array.  UUIDs may be used as keys to
+// maps or compared directly.
+package uuid
diff --git a/vendor/github.com/google/uuid/go.mod b/vendor/github.com/google/uuid/go.mod
new file mode 100644
index 000000000..fc84cd79d
--- /dev/null
+++ b/vendor/github.com/google/uuid/go.mod
@@ -0,0 +1 @@
+module github.com/google/uuid
diff --git a/vendor/github.com/google/uuid/hash.go b/vendor/github.com/google/uuid/hash.go
new file mode 100644
index 000000000..b404f4bec
--- /dev/null
+++ b/vendor/github.com/google/uuid/hash.go
@@ -0,0 +1,53 @@
+// Copyright 2016 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import (
+	"crypto/md5"
+	"crypto/sha1"
+	"hash"
+)
+
+// Well known namespace IDs and UUIDs
+var (
+	NameSpaceDNS  = Must(Parse("6ba7b810-9dad-11d1-80b4-00c04fd430c8"))
+	NameSpaceURL  = Must(Parse("6ba7b811-9dad-11d1-80b4-00c04fd430c8"))
+	NameSpaceOID  = Must(Parse("6ba7b812-9dad-11d1-80b4-00c04fd430c8"))
+	NameSpaceX500 = Must(Parse("6ba7b814-9dad-11d1-80b4-00c04fd430c8"))
+	Nil           UUID // empty UUID, all zeros
+)
+
+// NewHash returns a new UUID derived from the hash of space concatenated with
+// data generated by h.  The hash should be at least 16 byte in length.  The
+// first 16 bytes of the hash are used to form the UUID.  The version of the
+// UUID will be the lower 4 bits of version.  NewHash is used to implement
+// NewMD5 and NewSHA1.
+func NewHash(h hash.Hash, space UUID, data []byte, version int) UUID {
+	h.Reset()
+	h.Write(space[:]) //nolint:errcheck
+	h.Write(data)     //nolint:errcheck
+	s := h.Sum(nil)
+	var uuid UUID
+	copy(uuid[:], s)
+	uuid[6] = (uuid[6] & 0x0f) | uint8((version&0xf)<<4)
+	uuid[8] = (uuid[8] & 0x3f) | 0x80 // RFC 4122 variant
+	return uuid
+}
+
+// NewMD5 returns a new MD5 (Version 3) UUID based on the
+// supplied name space and data.  It is the same as calling:
+//
+//  NewHash(md5.New(), space, data, 3)
+func NewMD5(space UUID, data []byte) UUID {
+	return NewHash(md5.New(), space, data, 3)
+}
+
+// NewSHA1 returns a new SHA1 (Version 5) UUID based on the
+// supplied name space and data.  It is the same as calling:
+//
+//  NewHash(sha1.New(), space, data, 5)
+func NewSHA1(space UUID, data []byte) UUID {
+	return NewHash(sha1.New(), space, data, 5)
+}
diff --git a/vendor/github.com/google/uuid/json_test.go b/vendor/github.com/google/uuid/json_test.go
new file mode 100644
index 000000000..245f91edf
--- /dev/null
+++ b/vendor/github.com/google/uuid/json_test.go
@@ -0,0 +1,62 @@
+// Copyright 2016 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import (
+	"encoding/json"
+	"reflect"
+	"testing"
+)
+
+var testUUID = Must(Parse("f47ac10b-58cc-0372-8567-0e02b2c3d479"))
+
+func TestJSON(t *testing.T) {
+	type S struct {
+		ID1 UUID
+		ID2 UUID
+	}
+	s1 := S{ID1: testUUID}
+	data, err := json.Marshal(&s1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var s2 S
+	if err := json.Unmarshal(data, &s2); err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(&s1, &s2) {
+		t.Errorf("got %#v, want %#v", s2, s1)
+	}
+}
+
+func BenchmarkUUID_MarshalJSON(b *testing.B) {
+	x := &struct {
+		UUID UUID `json:"uuid"`
+	}{}
+	var err error
+	x.UUID, err = Parse("f47ac10b-58cc-0372-8567-0e02b2c3d479")
+	if err != nil {
+		b.Fatal(err)
+	}
+	for i := 0; i < b.N; i++ {
+		js, err := json.Marshal(x)
+		if err != nil {
+			b.Fatalf("marshal json: %#v (%v)", js, err)
+		}
+	}
+}
+
+func BenchmarkUUID_UnmarshalJSON(b *testing.B) {
+	js := []byte(`{"uuid":"f47ac10b-58cc-0372-8567-0e02b2c3d479"}`)
+	var x *struct {
+		UUID UUID `json:"uuid"`
+	}
+	for i := 0; i < b.N; i++ {
+		err := json.Unmarshal(js, &x)
+		if err != nil {
+			b.Fatalf("marshal json: %#v (%v)", js, err)
+		}
+	}
+}
diff --git a/vendor/github.com/google/uuid/marshal.go b/vendor/github.com/google/uuid/marshal.go
new file mode 100644
index 000000000..14bd34072
--- /dev/null
+++ b/vendor/github.com/google/uuid/marshal.go
@@ -0,0 +1,38 @@
+// Copyright 2016 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import "fmt"
+
+// MarshalText implements encoding.TextMarshaler.
+func (uuid UUID) MarshalText() ([]byte, error) {
+	var js [36]byte
+	encodeHex(js[:], uuid)
+	return js[:], nil
+}
+
+// UnmarshalText implements encoding.TextUnmarshaler.
+func (uuid *UUID) UnmarshalText(data []byte) error {
+	id, err := ParseBytes(data)
+	if err != nil {
+		return err
+	}
+	*uuid = id
+	return nil
+}
+
+// MarshalBinary implements encoding.BinaryMarshaler.
+func (uuid UUID) MarshalBinary() ([]byte, error) {
+	return uuid[:], nil
+}
+
+// UnmarshalBinary implements encoding.BinaryUnmarshaler.
+func (uuid *UUID) UnmarshalBinary(data []byte) error {
+	if len(data) != 16 {
+		return fmt.Errorf("invalid UUID (got %d bytes)", len(data))
+	}
+	copy(uuid[:], data)
+	return nil
+}
diff --git a/vendor/github.com/google/uuid/node.go b/vendor/github.com/google/uuid/node.go
new file mode 100644
index 000000000..d651a2b06
--- /dev/null
+++ b/vendor/github.com/google/uuid/node.go
@@ -0,0 +1,90 @@
+// Copyright 2016 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import (
+	"sync"
+)
+
+var (
+	nodeMu sync.Mutex
+	ifname string  // name of interface being used
+	nodeID [6]byte // hardware for version 1 UUIDs
+	zeroID [6]byte // nodeID with only 0's
+)
+
+// NodeInterface returns the name of the interface from which the NodeID was
+// derived.  The interface "user" is returned if the NodeID was set by
+// SetNodeID.
+func NodeInterface() string {
+	defer nodeMu.Unlock()
+	nodeMu.Lock()
+	return ifname
+}
+
+// SetNodeInterface selects the hardware address to be used for Version 1 UUIDs.
+// If name is "" then the first usable interface found will be used or a random
+// Node ID will be generated.  If a named interface cannot be found then false
+// is returned.
+//
+// SetNodeInterface never fails when name is "".
+func SetNodeInterface(name string) bool {
+	defer nodeMu.Unlock()
+	nodeMu.Lock()
+	return setNodeInterface(name)
+}
+
+func setNodeInterface(name string) bool {
+	iname, addr := getHardwareInterface(name) // null implementation for js
+	if iname != "" && addr != nil {
+		ifname = iname
+		copy(nodeID[:], addr)
+		return true
+	}
+
+	// We found no interfaces with a valid hardware address.  If name
+	// does not specify a specific interface generate a random Node ID
+	// (section 4.1.6)
+	if name == "" {
+		ifname = "random"
+		randomBits(nodeID[:])
+		return true
+	}
+	return false
+}
+
+// NodeID returns a slice of a copy of the current Node ID, setting the Node ID
+// if not already set.
+func NodeID() []byte {
+	defer nodeMu.Unlock()
+	nodeMu.Lock()
+	if nodeID == zeroID {
+		setNodeInterface("")
+	}
+	nid := nodeID
+	return nid[:]
+}
+
+// SetNodeID sets the Node ID to be used for Version 1 UUIDs.  The first 6 bytes
+// of id are used.  If id is less than 6 bytes then false is returned and the
+// Node ID is not set.
+func SetNodeID(id []byte) bool {
+	if len(id) < 6 {
+		return false
+	}
+	defer nodeMu.Unlock()
+	nodeMu.Lock()
+	copy(nodeID[:], id)
+	ifname = "user"
+	return true
+}
+
+// NodeID returns the 6 byte node id encoded in uuid.  It returns nil if uuid is
+// not valid.  The NodeID is only well defined for version 1 and 2 UUIDs.
+func (uuid UUID) NodeID() []byte {
+	var node [6]byte
+	copy(node[:], uuid[10:])
+	return node[:]
+}
diff --git a/vendor/github.com/google/uuid/node_js.go b/vendor/github.com/google/uuid/node_js.go
new file mode 100644
index 000000000..24b78edc9
--- /dev/null
+++ b/vendor/github.com/google/uuid/node_js.go
@@ -0,0 +1,12 @@
+// Copyright 2017 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build js
+
+package uuid
+
+// getHardwareInterface returns nil values for the JS version of the code.
+// This remvoves the "net" dependency, because it is not used in the browser.
+// Using the "net" library inflates the size of the transpiled JS code by 673k bytes.
+func getHardwareInterface(name string) (string, []byte) { return "", nil }
diff --git a/vendor/github.com/google/uuid/node_net.go b/vendor/github.com/google/uuid/node_net.go
new file mode 100644
index 000000000..0cbbcddbd
--- /dev/null
+++ b/vendor/github.com/google/uuid/node_net.go
@@ -0,0 +1,33 @@
+// Copyright 2017 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build !js
+
+package uuid
+
+import "net"
+
+var interfaces []net.Interface // cached list of interfaces
+
+// getHardwareInterface returns the name and hardware address of interface name.
+// If name is "" then the name and hardware address of one of the system's
+// interfaces is returned.  If no interfaces are found (name does not exist or
+// there are no interfaces) then "", nil is returned.
+//
+// Only addresses of at least 6 bytes are returned.
+func getHardwareInterface(name string) (string, []byte) {
+	if interfaces == nil {
+		var err error
+		interfaces, err = net.Interfaces()
+		if err != nil {
+			return "", nil
+		}
+	}
+	for _, ifs := range interfaces {
+		if len(ifs.HardwareAddr) >= 6 && (name == "" || name == ifs.Name) {
+			return ifs.Name, ifs.HardwareAddr
+		}
+	}
+	return "", nil
+}
diff --git a/vendor/github.com/google/uuid/seq_test.go b/vendor/github.com/google/uuid/seq_test.go
new file mode 100644
index 000000000..4f6c54912
--- /dev/null
+++ b/vendor/github.com/google/uuid/seq_test.go
@@ -0,0 +1,66 @@
+// Copyright 2016 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import (
+	"flag"
+	"runtime"
+	"testing"
+	"time"
+)
+
+// This test is only run when --regressions is passed on the go test line.
+var regressions = flag.Bool("regressions", false, "run uuid regression tests")
+
+// TestClockSeqRace tests for a particular race condition of returning two
+// identical Version1 UUIDs.  The duration of 1 minute was chosen as the race
+// condition, before being fixed, nearly always occurred in under 30 seconds.
+func TestClockSeqRace(t *testing.T) {
+	if !*regressions {
+		t.Skip("skipping regression tests")
+	}
+	duration := time.Minute
+
+	done := make(chan struct{})
+	defer close(done)
+
+	ch := make(chan UUID, 10000)
+	ncpu := runtime.NumCPU()
+	switch ncpu {
+	case 0, 1:
+		// We can't run the test effectively.
+		t.Skip("skipping race test, only one CPU detected")
+		return
+	default:
+		runtime.GOMAXPROCS(ncpu)
+	}
+	for i := 0; i < ncpu; i++ {
+		go func() {
+			for {
+				select {
+				case <-done:
+					return
+				case ch <- Must(NewUUID()):
+				}
+			}
+		}()
+	}
+
+	uuids := make(map[string]bool)
+	cnt := 0
+	start := time.Now()
+	for u := range ch {
+		s := u.String()
+		if uuids[s] {
+			t.Errorf("duplicate uuid after %d in %v: %s", cnt, time.Since(start), s)
+			return
+		}
+		uuids[s] = true
+		if time.Since(start) > duration {
+			return
+		}
+		cnt++
+	}
+}
diff --git a/vendor/github.com/google/uuid/sql.go b/vendor/github.com/google/uuid/sql.go
new file mode 100644
index 000000000..2e02ec06c
--- /dev/null
+++ b/vendor/github.com/google/uuid/sql.go
@@ -0,0 +1,59 @@
+// Copyright 2016 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import (
+	"database/sql/driver"
+	"fmt"
+)
+
+// Scan implements sql.Scanner so UUIDs can be read from databases transparently.
+// Currently, database types that map to string and []byte are supported. Please
+// consult database-specific driver documentation for matching types.
+func (uuid *UUID) Scan(src interface{}) error {
+	switch src := src.(type) {
+	case nil:
+		return nil
+
+	case string:
+		// if an empty UUID comes from a table, we return a null UUID
+		if src == "" {
+			return nil
+		}
+
+		// see Parse for required string format
+		u, err := Parse(src)
+		if err != nil {
+			return fmt.Errorf("Scan: %v", err)
+		}
+
+		*uuid = u
+
+	case []byte:
+		// if an empty UUID comes from a table, we return a null UUID
+		if len(src) == 0 {
+			return nil
+		}
+
+		// assumes a simple slice of bytes if 16 bytes
+		// otherwise attempts to parse
+		if len(src) != 16 {
+			return uuid.Scan(string(src))
+		}
+		copy((*uuid)[:], src)
+
+	default:
+		return fmt.Errorf("Scan: unable to scan type %T into UUID", src)
+	}
+
+	return nil
+}
+
+// Value implements sql.Valuer so that UUIDs can be written to databases
+// transparently. Currently, UUIDs map to strings. Please consult
+// database-specific driver documentation for matching types.
+func (uuid UUID) Value() (driver.Value, error) {
+	return uuid.String(), nil
+}
diff --git a/vendor/github.com/google/uuid/sql_test.go b/vendor/github.com/google/uuid/sql_test.go
new file mode 100644
index 000000000..1803dfd87
--- /dev/null
+++ b/vendor/github.com/google/uuid/sql_test.go
@@ -0,0 +1,113 @@
+// Copyright 2016 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestScan(t *testing.T) {
+	stringTest := "f47ac10b-58cc-0372-8567-0e02b2c3d479"
+	badTypeTest := 6
+	invalidTest := "f47ac10b-58cc-0372-8567-0e02b2c3d4"
+
+	byteTest := make([]byte, 16)
+	byteTestUUID := Must(Parse(stringTest))
+	copy(byteTest, byteTestUUID[:])
+
+	// sunny day tests
+
+	var uuid UUID
+	err := (&uuid).Scan(stringTest)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = (&uuid).Scan([]byte(stringTest))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = (&uuid).Scan(byteTest)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// bad type tests
+
+	err = (&uuid).Scan(badTypeTest)
+	if err == nil {
+		t.Error("int correctly parsed and shouldn't have")
+	}
+	if !strings.Contains(err.Error(), "unable to scan type") {
+		t.Error("attempting to parse an int returned an incorrect error message")
+	}
+
+	// invalid/incomplete uuids
+
+	err = (&uuid).Scan(invalidTest)
+	if err == nil {
+		t.Error("invalid uuid was parsed without error")
+	}
+	if !strings.Contains(err.Error(), "invalid UUID") {
+		t.Error("attempting to parse an invalid UUID returned an incorrect error message")
+	}
+
+	err = (&uuid).Scan(byteTest[:len(byteTest)-2])
+	if err == nil {
+		t.Error("invalid byte uuid was parsed without error")
+	}
+	if !strings.Contains(err.Error(), "invalid UUID") {
+		t.Error("attempting to parse an invalid byte UUID returned an incorrect error message")
+	}
+
+	// empty tests
+
+	uuid = UUID{}
+	var emptySlice []byte
+	err = (&uuid).Scan(emptySlice)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	for _, v := range uuid {
+		if v != 0 {
+			t.Error("UUID was not nil after scanning empty byte slice")
+		}
+	}
+
+	uuid = UUID{}
+	var emptyString string
+	err = (&uuid).Scan(emptyString)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, v := range uuid {
+		if v != 0 {
+			t.Error("UUID was not nil after scanning empty byte slice")
+		}
+	}
+
+	uuid = UUID{}
+	err = (&uuid).Scan(nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, v := range uuid {
+		if v != 0 {
+			t.Error("UUID was not nil after scanning nil")
+		}
+	}
+}
+
+func TestValue(t *testing.T) {
+	stringTest := "f47ac10b-58cc-0372-8567-0e02b2c3d479"
+	uuid := Must(Parse(stringTest))
+	val, _ := uuid.Value()
+	if val != stringTest {
+		t.Error("Value() did not return expected string")
+	}
+}
diff --git a/vendor/github.com/google/uuid/time.go b/vendor/github.com/google/uuid/time.go
new file mode 100644
index 000000000..e6ef06cdc
--- /dev/null
+++ b/vendor/github.com/google/uuid/time.go
@@ -0,0 +1,123 @@
+// Copyright 2016 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import (
+	"encoding/binary"
+	"sync"
+	"time"
+)
+
+// A Time represents a time as the number of 100's of nanoseconds since 15 Oct
+// 1582.
+type Time int64
+
+const (
+	lillian    = 2299160          // Julian day of 15 Oct 1582
+	unix       = 2440587          // Julian day of 1 Jan 1970
+	epoch      = unix - lillian   // Days between epochs
+	g1582      = epoch * 86400    // seconds between epochs
+	g1582ns100 = g1582 * 10000000 // 100s of a nanoseconds between epochs
+)
+
+var (
+	timeMu   sync.Mutex
+	lasttime uint64 // last time we returned
+	clockSeq uint16 // clock sequence for this run
+
+	timeNow = time.Now // for testing
+)
+
+// UnixTime converts t the number of seconds and nanoseconds using the Unix
+// epoch of 1 Jan 1970.
+func (t Time) UnixTime() (sec, nsec int64) {
+	sec = int64(t - g1582ns100)
+	nsec = (sec % 10000000) * 100
+	sec /= 10000000
+	return sec, nsec
+}
+
+// GetTime returns the current Time (100s of nanoseconds since 15 Oct 1582) and
+// clock sequence as well as adjusting the clock sequence as needed.  An error
+// is returned if the current time cannot be determined.
+func GetTime() (Time, uint16, error) {
+	defer timeMu.Unlock()
+	timeMu.Lock()
+	return getTime()
+}
+
+func getTime() (Time, uint16, error) {
+	t := timeNow()
+
+	// If we don't have a clock sequence already, set one.
+	if clockSeq == 0 {
+		setClockSequence(-1)
+	}
+	now := uint64(t.UnixNano()/100) + g1582ns100
+
+	// If time has gone backwards with this clock sequence then we
+	// increment the clock sequence
+	if now <= lasttime {
+		clockSeq = ((clockSeq + 1) & 0x3fff) | 0x8000
+	}
+	lasttime = now
+	return Time(now), clockSeq, nil
+}
+
+// ClockSequence returns the current clock sequence, generating one if not
+// already set.  The clock sequence is only used for Version 1 UUIDs.
+//
+// The uuid package does not use global static storage for the clock sequence or
+// the last time a UUID was generated.  Unless SetClockSequence is used, a new
+// random clock sequence is generated the first time a clock sequence is
+// requested by ClockSequence, GetTime, or NewUUID.  (section 4.2.1.1)
+func ClockSequence() int {
+	defer timeMu.Unlock()
+	timeMu.Lock()
+	return clockSequence()
+}
+
+func clockSequence() int {
+	if clockSeq == 0 {
+		setClockSequence(-1)
+	}
+	return int(clockSeq & 0x3fff)
+}
+
+// SetClockSequence sets the clock sequence to the lower 14 bits of seq.  Setting to
+// -1 causes a new sequence to be generated.
+func SetClockSequence(seq int) {
+	defer timeMu.Unlock()
+	timeMu.Lock()
+	setClockSequence(seq)
+}
+
+func setClockSequence(seq int) {
+	if seq == -1 {
+		var b [2]byte
+		randomBits(b[:]) // clock sequence
+		seq = int(b[0])<<8 | int(b[1])
+	}
+	oldSeq := clockSeq
+	clockSeq = uint16(seq&0x3fff) | 0x8000 // Set our variant
+	if oldSeq != clockSeq {
+		lasttime = 0
+	}
+}
+
+// Time returns the time in 100s of nanoseconds since 15 Oct 1582 encoded in
+// uuid.  The time is only defined for version 1 and 2 UUIDs.
+func (uuid UUID) Time() Time {
+	time := int64(binary.BigEndian.Uint32(uuid[0:4]))
+	time |= int64(binary.BigEndian.Uint16(uuid[4:6])) << 32
+	time |= int64(binary.BigEndian.Uint16(uuid[6:8])&0xfff) << 48
+	return Time(time)
+}
+
+// ClockSequence returns the clock sequence encoded in uuid.
+// The clock sequence is only well defined for version 1 and 2 UUIDs.
+func (uuid UUID) ClockSequence() int {
+	return int(binary.BigEndian.Uint16(uuid[8:10])) & 0x3fff
+}
diff --git a/vendor/github.com/google/uuid/util.go b/vendor/github.com/google/uuid/util.go
new file mode 100644
index 000000000..5ea6c7378
--- /dev/null
+++ b/vendor/github.com/google/uuid/util.go
@@ -0,0 +1,43 @@
+// Copyright 2016 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import (
+	"io"
+)
+
+// randomBits completely fills slice b with random data.
+func randomBits(b []byte) {
+	if _, err := io.ReadFull(rander, b); err != nil {
+		panic(err.Error()) // rand should never fail
+	}
+}
+
+// xvalues returns the value of a byte as a hexadecimal digit or 255.
+var xvalues = [256]byte{
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 255, 255, 255, 255, 255, 255,
+	255, 10, 11, 12, 13, 14, 15, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	255, 10, 11, 12, 13, 14, 15, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+}
+
+// xtob converts hex characters x1 and x2 into a byte.
+func xtob(x1, x2 byte) (byte, bool) {
+	b1 := xvalues[x1]
+	b2 := xvalues[x2]
+	return (b1 << 4) | b2, b1 != 255 && b2 != 255
+}
diff --git a/vendor/github.com/google/uuid/uuid.go b/vendor/github.com/google/uuid/uuid.go
new file mode 100644
index 000000000..60d26bb50
--- /dev/null
+++ b/vendor/github.com/google/uuid/uuid.go
@@ -0,0 +1,251 @@
+// Copyright 2018 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import (
+	"bytes"
+	"crypto/rand"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"io"
+	"strings"
+)
+
+// A UUID is a 128 bit (16 byte) Universal Unique IDentifier as defined in RFC
+// 4122.
+type UUID [16]byte
+
+// A Version represents a UUID's version.
+type Version byte
+
+// A Variant represents a UUID's variant.
+type Variant byte
+
+// Constants returned by Variant.
+const (
+	Invalid   = Variant(iota) // Invalid UUID
+	RFC4122                   // The variant specified in RFC4122
+	Reserved                  // Reserved, NCS backward compatibility.
+	Microsoft                 // Reserved, Microsoft Corporation backward compatibility.
+	Future                    // Reserved for future definition.
+)
+
+var rander = rand.Reader // random function
+
+type invalidLengthError struct{ len int }
+
+func (err invalidLengthError) Error() string {
+	return fmt.Sprintf("invalid UUID length: %d", err.len)
+}
+
+// Parse decodes s into a UUID or returns an error.  Both the standard UUID
+// forms of xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx and
+// urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx are decoded as well as the
+// Microsoft encoding {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx} and the raw hex
+// encoding: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.
+func Parse(s string) (UUID, error) {
+	var uuid UUID
+	switch len(s) {
+	// xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+	case 36:
+
+	// urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+	case 36 + 9:
+		if strings.ToLower(s[:9]) != "urn:uuid:" {
+			return uuid, fmt.Errorf("invalid urn prefix: %q", s[:9])
+		}
+		s = s[9:]
+
+	// {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}
+	case 36 + 2:
+		s = s[1:]
+
+	// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+	case 32:
+		var ok bool
+		for i := range uuid {
+			uuid[i], ok = xtob(s[i*2], s[i*2+1])
+			if !ok {
+				return uuid, errors.New("invalid UUID format")
+			}
+		}
+		return uuid, nil
+	default:
+		return uuid, invalidLengthError{len(s)}
+	}
+	// s is now at least 36 bytes long
+	// it must be of the form  xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+	if s[8] != '-' || s[13] != '-' || s[18] != '-' || s[23] != '-' {
+		return uuid, errors.New("invalid UUID format")
+	}
+	for i, x := range [16]int{
+		0, 2, 4, 6,
+		9, 11,
+		14, 16,
+		19, 21,
+		24, 26, 28, 30, 32, 34} {
+		v, ok := xtob(s[x], s[x+1])
+		if !ok {
+			return uuid, errors.New("invalid UUID format")
+		}
+		uuid[i] = v
+	}
+	return uuid, nil
+}
+
+// ParseBytes is like Parse, except it parses a byte slice instead of a string.
+func ParseBytes(b []byte) (UUID, error) {
+	var uuid UUID
+	switch len(b) {
+	case 36: // xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+	case 36 + 9: // urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+		if !bytes.Equal(bytes.ToLower(b[:9]), []byte("urn:uuid:")) {
+			return uuid, fmt.Errorf("invalid urn prefix: %q", b[:9])
+		}
+		b = b[9:]
+	case 36 + 2: // {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}
+		b = b[1:]
+	case 32: // xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+		var ok bool
+		for i := 0; i < 32; i += 2 {
+			uuid[i/2], ok = xtob(b[i], b[i+1])
+			if !ok {
+				return uuid, errors.New("invalid UUID format")
+			}
+		}
+		return uuid, nil
+	default:
+		return uuid, invalidLengthError{len(b)}
+	}
+	// s is now at least 36 bytes long
+	// it must be of the form  xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+	if b[8] != '-' || b[13] != '-' || b[18] != '-' || b[23] != '-' {
+		return uuid, errors.New("invalid UUID format")
+	}
+	for i, x := range [16]int{
+		0, 2, 4, 6,
+		9, 11,
+		14, 16,
+		19, 21,
+		24, 26, 28, 30, 32, 34} {
+		v, ok := xtob(b[x], b[x+1])
+		if !ok {
+			return uuid, errors.New("invalid UUID format")
+		}
+		uuid[i] = v
+	}
+	return uuid, nil
+}
+
+// MustParse is like Parse but panics if the string cannot be parsed.
+// It simplifies safe initialization of global variables holding compiled UUIDs.
+func MustParse(s string) UUID {
+	uuid, err := Parse(s)
+	if err != nil {
+		panic(`uuid: Parse(` + s + `): ` + err.Error())
+	}
+	return uuid
+}
+
+// FromBytes creates a new UUID from a byte slice. Returns an error if the slice
+// does not have a length of 16. The bytes are copied from the slice.
+func FromBytes(b []byte) (uuid UUID, err error) {
+	err = uuid.UnmarshalBinary(b)
+	return uuid, err
+}
+
+// Must returns uuid if err is nil and panics otherwise.
+func Must(uuid UUID, err error) UUID {
+	if err != nil {
+		panic(err)
+	}
+	return uuid
+}
+
+// String returns the string form of uuid, xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+// , or "" if uuid is invalid.
+func (uuid UUID) String() string {
+	var buf [36]byte
+	encodeHex(buf[:], uuid)
+	return string(buf[:])
+}
+
+// URN returns the RFC 2141 URN form of uuid,
+// urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx,  or "" if uuid is invalid.
+func (uuid UUID) URN() string {
+	var buf [36 + 9]byte
+	copy(buf[:], "urn:uuid:")
+	encodeHex(buf[9:], uuid)
+	return string(buf[:])
+}
+
+func encodeHex(dst []byte, uuid UUID) {
+	hex.Encode(dst, uuid[:4])
+	dst[8] = '-'
+	hex.Encode(dst[9:13], uuid[4:6])
+	dst[13] = '-'
+	hex.Encode(dst[14:18], uuid[6:8])
+	dst[18] = '-'
+	hex.Encode(dst[19:23], uuid[8:10])
+	dst[23] = '-'
+	hex.Encode(dst[24:], uuid[10:])
+}
+
+// Variant returns the variant encoded in uuid.
+func (uuid UUID) Variant() Variant {
+	switch {
+	case (uuid[8] & 0xc0) == 0x80:
+		return RFC4122
+	case (uuid[8] & 0xe0) == 0xc0:
+		return Microsoft
+	case (uuid[8] & 0xe0) == 0xe0:
+		return Future
+	default:
+		return Reserved
+	}
+}
+
+// Version returns the version of uuid.
+func (uuid UUID) Version() Version {
+	return Version(uuid[6] >> 4)
+}
+
+func (v Version) String() string {
+	if v > 15 {
+		return fmt.Sprintf("BAD_VERSION_%d", v)
+	}
+	return fmt.Sprintf("VERSION_%d", v)
+}
+
+func (v Variant) String() string {
+	switch v {
+	case RFC4122:
+		return "RFC4122"
+	case Reserved:
+		return "Reserved"
+	case Microsoft:
+		return "Microsoft"
+	case Future:
+		return "Future"
+	case Invalid:
+		return "Invalid"
+	}
+	return fmt.Sprintf("BadVariant%d", int(v))
+}
+
+// SetRand sets the random number generator to r, which implements io.Reader.
+// If r.Read returns an error when the package requests random data then
+// a panic will be issued.
+//
+// Calling SetRand with nil sets the random number generator to the default
+// generator.
+func SetRand(r io.Reader) {
+	if r == nil {
+		rander = rand.Reader
+		return
+	}
+	rander = r
+}
diff --git a/vendor/github.com/google/uuid/uuid_test.go b/vendor/github.com/google/uuid/uuid_test.go
new file mode 100644
index 000000000..709e34c66
--- /dev/null
+++ b/vendor/github.com/google/uuid/uuid_test.go
@@ -0,0 +1,636 @@
+// Copyright 2016 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+	"unsafe"
+)
+
+type test struct {
+	in      string
+	version Version
+	variant Variant
+	isuuid  bool
+}
+
+var tests = []test{
+	{"f47ac10b-58cc-0372-8567-0e02b2c3d479", 0, RFC4122, true},
+	{"f47ac10b-58cc-1372-8567-0e02b2c3d479", 1, RFC4122, true},
+	{"f47ac10b-58cc-2372-8567-0e02b2c3d479", 2, RFC4122, true},
+	{"f47ac10b-58cc-3372-8567-0e02b2c3d479", 3, RFC4122, true},
+	{"f47ac10b-58cc-4372-8567-0e02b2c3d479", 4, RFC4122, true},
+	{"f47ac10b-58cc-5372-8567-0e02b2c3d479", 5, RFC4122, true},
+	{"f47ac10b-58cc-6372-8567-0e02b2c3d479", 6, RFC4122, true},
+	{"f47ac10b-58cc-7372-8567-0e02b2c3d479", 7, RFC4122, true},
+	{"f47ac10b-58cc-8372-8567-0e02b2c3d479", 8, RFC4122, true},
+	{"f47ac10b-58cc-9372-8567-0e02b2c3d479", 9, RFC4122, true},
+	{"f47ac10b-58cc-a372-8567-0e02b2c3d479", 10, RFC4122, true},
+	{"f47ac10b-58cc-b372-8567-0e02b2c3d479", 11, RFC4122, true},
+	{"f47ac10b-58cc-c372-8567-0e02b2c3d479", 12, RFC4122, true},
+	{"f47ac10b-58cc-d372-8567-0e02b2c3d479", 13, RFC4122, true},
+	{"f47ac10b-58cc-e372-8567-0e02b2c3d479", 14, RFC4122, true},
+	{"f47ac10b-58cc-f372-8567-0e02b2c3d479", 15, RFC4122, true},
+
+	{"urn:uuid:f47ac10b-58cc-4372-0567-0e02b2c3d479", 4, Reserved, true},
+	{"URN:UUID:f47ac10b-58cc-4372-0567-0e02b2c3d479", 4, Reserved, true},
+	{"f47ac10b-58cc-4372-0567-0e02b2c3d479", 4, Reserved, true},
+	{"f47ac10b-58cc-4372-1567-0e02b2c3d479", 4, Reserved, true},
+	{"f47ac10b-58cc-4372-2567-0e02b2c3d479", 4, Reserved, true},
+	{"f47ac10b-58cc-4372-3567-0e02b2c3d479", 4, Reserved, true},
+	{"f47ac10b-58cc-4372-4567-0e02b2c3d479", 4, Reserved, true},
+	{"f47ac10b-58cc-4372-5567-0e02b2c3d479", 4, Reserved, true},
+	{"f47ac10b-58cc-4372-6567-0e02b2c3d479", 4, Reserved, true},
+	{"f47ac10b-58cc-4372-7567-0e02b2c3d479", 4, Reserved, true},
+	{"f47ac10b-58cc-4372-8567-0e02b2c3d479", 4, RFC4122, true},
+	{"f47ac10b-58cc-4372-9567-0e02b2c3d479", 4, RFC4122, true},
+	{"f47ac10b-58cc-4372-a567-0e02b2c3d479", 4, RFC4122, true},
+	{"f47ac10b-58cc-4372-b567-0e02b2c3d479", 4, RFC4122, true},
+	{"f47ac10b-58cc-4372-c567-0e02b2c3d479", 4, Microsoft, true},
+	{"f47ac10b-58cc-4372-d567-0e02b2c3d479", 4, Microsoft, true},
+	{"f47ac10b-58cc-4372-e567-0e02b2c3d479", 4, Future, true},
+	{"f47ac10b-58cc-4372-f567-0e02b2c3d479", 4, Future, true},
+
+	{"f47ac10b158cc-5372-a567-0e02b2c3d479", 0, Invalid, false},
+	{"f47ac10b-58cc25372-a567-0e02b2c3d479", 0, Invalid, false},
+	{"f47ac10b-58cc-53723a567-0e02b2c3d479", 0, Invalid, false},
+	{"f47ac10b-58cc-5372-a56740e02b2c3d479", 0, Invalid, false},
+	{"f47ac10b-58cc-5372-a567-0e02-2c3d479", 0, Invalid, false},
+	{"g47ac10b-58cc-4372-a567-0e02b2c3d479", 0, Invalid, false},
+
+	{"{f47ac10b-58cc-0372-8567-0e02b2c3d479}", 0, RFC4122, true},
+	{"{f47ac10b-58cc-0372-8567-0e02b2c3d479", 0, Invalid, false},
+	{"f47ac10b-58cc-0372-8567-0e02b2c3d479}", 0, Invalid, false},
+
+	{"f47ac10b58cc037285670e02b2c3d479", 0, RFC4122, true},
+	{"f47ac10b58cc037285670e02b2c3d4790", 0, Invalid, false},
+	{"f47ac10b58cc037285670e02b2c3d47", 0, Invalid, false},
+}
+
+var constants = []struct {
+	c    interface{}
+	name string
+}{
+	{Person, "Person"},
+	{Group, "Group"},
+	{Org, "Org"},
+	{Invalid, "Invalid"},
+	{RFC4122, "RFC4122"},
+	{Reserved, "Reserved"},
+	{Microsoft, "Microsoft"},
+	{Future, "Future"},
+	{Domain(17), "Domain17"},
+	{Variant(42), "BadVariant42"},
+}
+
+func testTest(t *testing.T, in string, tt test) {
+	uuid, err := Parse(in)
+	if ok := (err == nil); ok != tt.isuuid {
+		t.Errorf("Parse(%s) got %v expected %v\b", in, ok, tt.isuuid)
+	}
+	if err != nil {
+		return
+	}
+
+	if v := uuid.Variant(); v != tt.variant {
+		t.Errorf("Variant(%s) got %d expected %d\b", in, v, tt.variant)
+	}
+	if v := uuid.Version(); v != tt.version {
+		t.Errorf("Version(%s) got %d expected %d\b", in, v, tt.version)
+	}
+}
+
+func testBytes(t *testing.T, in []byte, tt test) {
+	uuid, err := ParseBytes(in)
+	if ok := (err == nil); ok != tt.isuuid {
+		t.Errorf("ParseBytes(%s) got %v expected %v\b", in, ok, tt.isuuid)
+	}
+	if err != nil {
+		return
+	}
+	suuid, _ := Parse(string(in))
+	if uuid != suuid {
+		t.Errorf("ParseBytes(%s) got %v expected %v\b", in, uuid, suuid)
+	}
+}
+
+func TestUUID(t *testing.T) {
+	for _, tt := range tests {
+		testTest(t, tt.in, tt)
+		testTest(t, strings.ToUpper(tt.in), tt)
+		testBytes(t, []byte(tt.in), tt)
+	}
+}
+
+func TestFromBytes(t *testing.T) {
+	b := []byte{
+		0x7d, 0x44, 0x48, 0x40,
+		0x9d, 0xc0,
+		0x11, 0xd1,
+		0xb2, 0x45,
+		0x5f, 0xfd, 0xce, 0x74, 0xfa, 0xd2,
+	}
+	uuid, err := FromBytes(b)
+	if err != nil {
+		t.Fatalf("%s", err)
+	}
+	for i := 0; i < len(uuid); i++ {
+		if b[i] != uuid[i] {
+			t.Fatalf("FromBytes() got %v expected %v\b", uuid[:], b)
+		}
+	}
+}
+
+func TestConstants(t *testing.T) {
+	for x, tt := range constants {
+		v, ok := tt.c.(fmt.Stringer)
+		if !ok {
+			t.Errorf("%x: %v: not a stringer", x, v)
+		} else if s := v.String(); s != tt.name {
+			v, _ := tt.c.(int)
+			t.Errorf("%x: Constant %T:%d gives %q, expected %q", x, tt.c, v, s, tt.name)
+		}
+	}
+}
+
+func TestRandomUUID(t *testing.T) {
+	m := make(map[string]bool)
+	for x := 1; x < 32; x++ {
+		uuid := New()
+		s := uuid.String()
+		if m[s] {
+			t.Errorf("NewRandom returned duplicated UUID %s", s)
+		}
+		m[s] = true
+		if v := uuid.Version(); v != 4 {
+			t.Errorf("Random UUID of version %s", v)
+		}
+		if uuid.Variant() != RFC4122 {
+			t.Errorf("Random UUID is variant %d", uuid.Variant())
+		}
+	}
+}
+
+func TestNew(t *testing.T) {
+	m := make(map[UUID]bool)
+	for x := 1; x < 32; x++ {
+		s := New()
+		if m[s] {
+			t.Errorf("New returned duplicated UUID %s", s)
+		}
+		m[s] = true
+		uuid, err := Parse(s.String())
+		if err != nil {
+			t.Errorf("New.String() returned %q which does not decode", s)
+			continue
+		}
+		if v := uuid.Version(); v != 4 {
+			t.Errorf("Random UUID of version %s", v)
+		}
+		if uuid.Variant() != RFC4122 {
+			t.Errorf("Random UUID is variant %d", uuid.Variant())
+		}
+	}
+}
+
+func TestClockSeq(t *testing.T) {
+	// Fake time.Now for this test to return a monotonically advancing time; restore it at end.
+	defer func(orig func() time.Time) { timeNow = orig }(timeNow)
+	monTime := time.Now()
+	timeNow = func() time.Time {
+		monTime = monTime.Add(1 * time.Second)
+		return monTime
+	}
+
+	SetClockSequence(-1)
+	uuid1, err := NewUUID()
+	if err != nil {
+		t.Fatalf("could not create UUID: %v", err)
+	}
+	uuid2, err := NewUUID()
+	if err != nil {
+		t.Fatalf("could not create UUID: %v", err)
+	}
+
+	if s1, s2 := uuid1.ClockSequence(), uuid2.ClockSequence(); s1 != s2 {
+		t.Errorf("clock sequence %d != %d", s1, s2)
+	}
+
+	SetClockSequence(-1)
+	uuid2, err = NewUUID()
+	if err != nil {
+		t.Fatalf("could not create UUID: %v", err)
+	}
+
+	// Just on the very off chance we generated the same sequence
+	// two times we try again.
+	if uuid1.ClockSequence() == uuid2.ClockSequence() {
+		SetClockSequence(-1)
+		uuid2, err = NewUUID()
+		if err != nil {
+			t.Fatalf("could not create UUID: %v", err)
+		}
+	}
+	if s1, s2 := uuid1.ClockSequence(), uuid2.ClockSequence(); s1 == s2 {
+		t.Errorf("Duplicate clock sequence %d", s1)
+	}
+
+	SetClockSequence(0x1234)
+	uuid1, err = NewUUID()
+	if err != nil {
+		t.Fatalf("could not create UUID: %v", err)
+	}
+	if seq := uuid1.ClockSequence(); seq != 0x1234 {
+		t.Errorf("%s: expected seq 0x1234 got 0x%04x", uuid1, seq)
+	}
+}
+
+func TestCoding(t *testing.T) {
+	text := "7d444840-9dc0-11d1-b245-5ffdce74fad2"
+	urn := "urn:uuid:7d444840-9dc0-11d1-b245-5ffdce74fad2"
+	data := UUID{
+		0x7d, 0x44, 0x48, 0x40,
+		0x9d, 0xc0,
+		0x11, 0xd1,
+		0xb2, 0x45,
+		0x5f, 0xfd, 0xce, 0x74, 0xfa, 0xd2,
+	}
+	if v := data.String(); v != text {
+		t.Errorf("%x: encoded to %s, expected %s", data, v, text)
+	}
+	if v := data.URN(); v != urn {
+		t.Errorf("%x: urn is %s, expected %s", data, v, urn)
+	}
+
+	uuid, err := Parse(text)
+	if err != nil {
+		t.Errorf("Parse returned unexpected error %v", err)
+	}
+	if data != uuid {
+		t.Errorf("%s: decoded to %s, expected %s", text, uuid, data)
+	}
+}
+
+func TestVersion1(t *testing.T) {
+	uuid1, err := NewUUID()
+	if err != nil {
+		t.Fatalf("could not create UUID: %v", err)
+	}
+	uuid2, err := NewUUID()
+	if err != nil {
+		t.Fatalf("could not create UUID: %v", err)
+	}
+
+	if uuid1 == uuid2 {
+		t.Errorf("%s:duplicate uuid", uuid1)
+	}
+	if v := uuid1.Version(); v != 1 {
+		t.Errorf("%s: version %s expected 1", uuid1, v)
+	}
+	if v := uuid2.Version(); v != 1 {
+		t.Errorf("%s: version %s expected 1", uuid2, v)
+	}
+	n1 := uuid1.NodeID()
+	n2 := uuid2.NodeID()
+	if !bytes.Equal(n1, n2) {
+		t.Errorf("Different nodes %x != %x", n1, n2)
+	}
+	t1 := uuid1.Time()
+	t2 := uuid2.Time()
+	q1 := uuid1.ClockSequence()
+	q2 := uuid2.ClockSequence()
+
+	switch {
+	case t1 == t2 && q1 == q2:
+		t.Error("time stopped")
+	case t1 > t2 && q1 == q2:
+		t.Error("time reversed")
+	case t1 < t2 && q1 != q2:
+		t.Error("clock sequence changed unexpectedly")
+	}
+}
+
+func TestNode(t *testing.T) {
+	// This test is mostly to make sure we don't leave nodeMu locked.
+	ifname = ""
+	if ni := NodeInterface(); ni != "" {
+		t.Errorf("NodeInterface got %q, want %q", ni, "")
+	}
+	if SetNodeInterface("xyzzy") {
+		t.Error("SetNodeInterface succeeded on a bad interface name")
+	}
+	if !SetNodeInterface("") {
+		t.Error("SetNodeInterface failed")
+	}
+	if runtime.GOARCH != "js" {
+		if ni := NodeInterface(); ni == "" {
+			t.Error("NodeInterface returned an empty string")
+		}
+	}
+
+	ni := NodeID()
+	if len(ni) != 6 {
+		t.Errorf("ni got %d bytes, want 6", len(ni))
+	}
+	hasData := false
+	for _, b := range ni {
+		if b != 0 {
+			hasData = true
+		}
+	}
+	if !hasData {
+		t.Error("nodeid is all zeros")
+	}
+
+	id := []byte{1, 2, 3, 4, 5, 6, 7, 8}
+	SetNodeID(id)
+	ni = NodeID()
+	if !bytes.Equal(ni, id[:6]) {
+		t.Errorf("got nodeid %v, want %v", ni, id[:6])
+	}
+
+	if ni := NodeInterface(); ni != "user" {
+		t.Errorf("got interface %q, want %q", ni, "user")
+	}
+}
+
+func TestNodeAndTime(t *testing.T) {
+	// Time is February 5, 1998 12:30:23.136364800 AM GMT
+
+	uuid, err := Parse("7d444840-9dc0-11d1-b245-5ffdce74fad2")
+	if err != nil {
+		t.Fatalf("Parser returned unexpected error %v", err)
+	}
+	node := []byte{0x5f, 0xfd, 0xce, 0x74, 0xfa, 0xd2}
+
+	ts := uuid.Time()
+	c := time.Unix(ts.UnixTime())
+	want := time.Date(1998, 2, 5, 0, 30, 23, 136364800, time.UTC)
+	if !c.Equal(want) {
+		t.Errorf("Got time %v, want %v", c, want)
+	}
+	if !bytes.Equal(node, uuid.NodeID()) {
+		t.Errorf("Expected node %v got %v", node, uuid.NodeID())
+	}
+}
+
+func TestMD5(t *testing.T) {
+	uuid := NewMD5(NameSpaceDNS, []byte("python.org")).String()
+	want := "6fa459ea-ee8a-3ca4-894e-db77e160355e"
+	if uuid != want {
+		t.Errorf("MD5: got %q expected %q", uuid, want)
+	}
+}
+
+func TestSHA1(t *testing.T) {
+	uuid := NewSHA1(NameSpaceDNS, []byte("python.org")).String()
+	want := "886313e1-3b8a-5372-9b90-0c9aee199e5d"
+	if uuid != want {
+		t.Errorf("SHA1: got %q expected %q", uuid, want)
+	}
+}
+
+func TestNodeID(t *testing.T) {
+	nid := []byte{1, 2, 3, 4, 5, 6}
+	SetNodeInterface("")
+	s := NodeInterface()
+	if runtime.GOARCH != "js" {
+		if s == "" || s == "user" {
+			t.Errorf("NodeInterface %q after SetInterface", s)
+		}
+	}
+	node1 := NodeID()
+	if node1 == nil {
+		t.Error("NodeID nil after SetNodeInterface", s)
+	}
+	SetNodeID(nid)
+	s = NodeInterface()
+	if s != "user" {
+		t.Errorf("Expected NodeInterface %q got %q", "user", s)
+	}
+	node2 := NodeID()
+	if node2 == nil {
+		t.Error("NodeID nil after SetNodeID", s)
+	}
+	if bytes.Equal(node1, node2) {
+		t.Error("NodeID not changed after SetNodeID", s)
+	} else if !bytes.Equal(nid, node2) {
+		t.Errorf("NodeID is %x, expected %x", node2, nid)
+	}
+}
+
+func testDCE(t *testing.T, name string, uuid UUID, err error, domain Domain, id uint32) {
+	if err != nil {
+		t.Errorf("%s failed: %v", name, err)
+		return
+	}
+	if v := uuid.Version(); v != 2 {
+		t.Errorf("%s: %s: expected version 2, got %s", name, uuid, v)
+		return
+	}
+	if v := uuid.Domain(); v != domain {
+		t.Errorf("%s: %s: expected domain %d, got %d", name, uuid, domain, v)
+	}
+	if v := uuid.ID(); v != id {
+		t.Errorf("%s: %s: expected id %d, got %d", name, uuid, id, v)
+	}
+}
+
+func TestDCE(t *testing.T) {
+	uuid, err := NewDCESecurity(42, 12345678)
+	testDCE(t, "NewDCESecurity", uuid, err, 42, 12345678)
+	uuid, err = NewDCEPerson()
+	testDCE(t, "NewDCEPerson", uuid, err, Person, uint32(os.Getuid()))
+	uuid, err = NewDCEGroup()
+	testDCE(t, "NewDCEGroup", uuid, err, Group, uint32(os.Getgid()))
+}
+
+type badRand struct{}
+
+func (r badRand) Read(buf []byte) (int, error) {
+	for i := range buf {
+		buf[i] = byte(i)
+	}
+	return len(buf), nil
+}
+
+func TestBadRand(t *testing.T) {
+	SetRand(badRand{})
+	uuid1 := New()
+	uuid2 := New()
+	if uuid1 != uuid2 {
+		t.Errorf("expected duplicates, got %q and %q", uuid1, uuid2)
+	}
+	SetRand(nil)
+	uuid1 = New()
+	uuid2 = New()
+	if uuid1 == uuid2 {
+		t.Errorf("unexpected duplicates, got %q", uuid1)
+	}
+}
+
+func TestSetRand(t *testing.T) {
+	myString := "805-9dd6-1a877cb526c678e71d38-7122-44c0-9b7c-04e7001cc78783ac3e82-47a3-4cc3-9951-13f3339d88088f5d685a-11f7-4078-ada9-de44ad2daeb7"
+
+	SetRand(strings.NewReader(myString))
+	uuid1 := New()
+	uuid2 := New()
+
+	SetRand(strings.NewReader(myString))
+	uuid3 := New()
+	uuid4 := New()
+
+	if uuid1 != uuid3 {
+		t.Errorf("expected duplicates, got %q and %q", uuid1, uuid3)
+	}
+	if uuid2 != uuid4 {
+		t.Errorf("expected duplicates, got %q and %q", uuid2, uuid4)
+	}
+}
+
+func TestRandomFromReader(t *testing.T) {
+	myString := "8059ddhdle77cb52"
+	r := bytes.NewReader([]byte(myString))
+	r2 := bytes.NewReader([]byte(myString))
+	uuid1, err := NewRandomFromReader(r)
+	if err != nil {
+		t.Errorf("failed generating UUID from a reader")
+	}
+	_, err = NewRandomFromReader(r)
+	if err == nil {
+		t.Errorf("expecting an error as reader has no more bytes. Got uuid. NewRandomFromReader may not be using the provided reader")
+	}
+	uuid3, err := NewRandomFromReader(r2)
+	if err != nil {
+		t.Errorf("failed generating UUID from a reader")
+	}
+	if uuid1 != uuid3 {
+		t.Errorf("expected duplicates, got %q and %q", uuid1, uuid3)
+	}
+}
+
+func TestWrongLength(t *testing.T) {
+	_, err := Parse("12345")
+	if err == nil {
+		t.Errorf("expected ‘12345’ was invalid")
+	} else if err.Error() != "invalid UUID length: 5" {
+		t.Errorf("expected a different error message for an invalid length")
+	}
+}
+
+var asString = "f47ac10b-58cc-0372-8567-0e02b2c3d479"
+var asBytes = []byte(asString)
+
+func BenchmarkParse(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		_, err := Parse(asString)
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func BenchmarkParseBytes(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		_, err := ParseBytes(asBytes)
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+// parseBytesUnsafe is to benchmark using unsafe.
+func parseBytesUnsafe(b []byte) (UUID, error) {
+	return Parse(*(*string)(unsafe.Pointer(&b)))
+}
+
+func BenchmarkParseBytesUnsafe(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		_, err := parseBytesUnsafe(asBytes)
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+// parseBytesCopy is to benchmark not using unsafe.
+func parseBytesCopy(b []byte) (UUID, error) {
+	return Parse(string(b))
+}
+
+func BenchmarkParseBytesCopy(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		_, err := parseBytesCopy(asBytes)
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func BenchmarkNew(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		New()
+	}
+}
+
+func BenchmarkUUID_String(b *testing.B) {
+	uuid, err := Parse("f47ac10b-58cc-0372-8567-0e02b2c3d479")
+	if err != nil {
+		b.Fatal(err)
+	}
+	for i := 0; i < b.N; i++ {
+		if uuid.String() == "" {
+			b.Fatal("invalid uuid")
+		}
+	}
+}
+
+func BenchmarkUUID_URN(b *testing.B) {
+	uuid, err := Parse("f47ac10b-58cc-0372-8567-0e02b2c3d479")
+	if err != nil {
+		b.Fatal(err)
+	}
+	for i := 0; i < b.N; i++ {
+		if uuid.URN() == "" {
+			b.Fatal("invalid uuid")
+		}
+	}
+}
+
+func BenchmarkParseBadLength(b *testing.B) {
+	short := asString[:10]
+	for i := 0; i < b.N; i++ {
+		_, err := Parse(short)
+		if err == nil {
+			b.Fatalf("expected ‘%s’ was invalid", short)
+		}
+	}
+}
+
+func BenchmarkParseLen32Truncated(b *testing.B) {
+	partial := asString[:len(asString)-4]
+	for i := 0; i < b.N; i++ {
+		_, err := Parse(partial)
+		if err == nil {
+			b.Fatalf("expected ‘%s’ was invalid", partial)
+		}
+	}
+}
+
+func BenchmarkParseLen36Corrupted(b *testing.B) {
+	wrong := asString[:len(asString)-1] + "x"
+	for i := 0; i < b.N; i++ {
+		_, err := Parse(wrong)
+		if err == nil {
+			b.Fatalf("expected ‘%s’ was invalid", wrong)
+		}
+	}
+}
diff --git a/vendor/github.com/google/uuid/version1.go b/vendor/github.com/google/uuid/version1.go
new file mode 100644
index 000000000..463109629
--- /dev/null
+++ b/vendor/github.com/google/uuid/version1.go
@@ -0,0 +1,44 @@
+// Copyright 2016 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import (
+	"encoding/binary"
+)
+
+// NewUUID returns a Version 1 UUID based on the current NodeID and clock
+// sequence, and the current time.  If the NodeID has not been set by SetNodeID
+// or SetNodeInterface then it will be set automatically.  If the NodeID cannot
+// be set NewUUID returns nil.  If clock sequence has not been set by
+// SetClockSequence then it will be set automatically.  If GetTime fails to
+// return the current NewUUID returns nil and an error.
+//
+// In most cases, New should be used.
+func NewUUID() (UUID, error) {
+	var uuid UUID
+	now, seq, err := GetTime()
+	if err != nil {
+		return uuid, err
+	}
+
+	timeLow := uint32(now & 0xffffffff)
+	timeMid := uint16((now >> 32) & 0xffff)
+	timeHi := uint16((now >> 48) & 0x0fff)
+	timeHi |= 0x1000 // Version 1
+
+	binary.BigEndian.PutUint32(uuid[0:], timeLow)
+	binary.BigEndian.PutUint16(uuid[4:], timeMid)
+	binary.BigEndian.PutUint16(uuid[6:], timeHi)
+	binary.BigEndian.PutUint16(uuid[8:], seq)
+
+	nodeMu.Lock()
+	if nodeID == zeroID {
+		setNodeInterface("")
+	}
+	copy(uuid[10:], nodeID[:])
+	nodeMu.Unlock()
+
+	return uuid, nil
+}
diff --git a/vendor/github.com/google/uuid/version4.go b/vendor/github.com/google/uuid/version4.go
new file mode 100644
index 000000000..c110465db
--- /dev/null
+++ b/vendor/github.com/google/uuid/version4.go
@@ -0,0 +1,43 @@
+// Copyright 2016 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import "io"
+
+// New creates a new random UUID or panics.  New is equivalent to
+// the expression
+//
+//    uuid.Must(uuid.NewRandom())
+func New() UUID {
+	return Must(NewRandom())
+}
+
+// NewRandom returns a Random (Version 4) UUID.
+//
+// The strength of the UUIDs is based on the strength of the crypto/rand
+// package.
+//
+// A note about uniqueness derived from the UUID Wikipedia entry:
+//
+//  Randomly generated UUIDs have 122 random bits.  One's annual risk of being
+//  hit by a meteorite is estimated to be one chance in 17 billion, that
+//  means the probability is about 0.00000000006 (6 × 10−11),
+//  equivalent to the odds of creating a few tens of trillions of UUIDs in a
+//  year and having one duplicate.
+func NewRandom() (UUID, error) {
+	return NewRandomFromReader(rander)
+}
+
+// NewRandomFromReader returns a UUID based on bytes read from a given io.Reader.
+func NewRandomFromReader(r io.Reader) (UUID, error) {
+	var uuid UUID
+	_, err := io.ReadFull(r, uuid[:])
+	if err != nil {
+		return Nil, err
+	}
+	uuid[6] = (uuid[6] & 0x0f) | 0x40 // Version 4
+	uuid[8] = (uuid[8] & 0x3f) | 0x80 // Variant is 10
+	return uuid, nil
+}
diff --git a/vendor/github.com/karalabe/usb/.travis.yml b/vendor/github.com/karalabe/usb/.travis.yml
new file mode 100644
index 000000000..7f925fbc0
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/.travis.yml
@@ -0,0 +1,49 @@
+language: go
+
+matrix:
+  include:
+    - os: linux
+      dist: trusty
+      go: 1.5.x
+    - os: linux
+      dist: trusty
+      go: 1.6.x
+    - os: linux
+      dist: trusty
+      go: 1.7.x
+    - os: linux
+      dist: trusty
+      go: 1.8.x
+    - os: linux
+      dist: trusty
+      go: 1.9.x
+    - os: linux
+      dist: xenial
+      go: 1.9.x
+    - os: linux
+      dist: xenial
+      go: 1.10.x
+    - os: linux
+      dist: xenial
+      go: 1.11.x
+    - os: linux
+      dist: xenial
+      go: 1.12.x
+    - os: osx
+      go: 1.12.x
+    - os: linux
+      dist: bionic
+      go: 1.13.x
+      services:
+        - docker
+      env:
+        - docker
+      script:
+        - docker build -f Dockerfile.ubuntu .
+        - docker build -f Dockerfile.alpine .
+
+script:
+  - go install ./...
+  - go test -v ./...
+  - CGO_ENABLED=0 go install ./...
+  - CGO_ENABLED=0 go test -v ./...
diff --git a/vendor/github.com/karalabe/usb/AUTHORS b/vendor/github.com/karalabe/usb/AUTHORS
new file mode 100644
index 000000000..bae45b3ec
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/AUTHORS
@@ -0,0 +1,7 @@
+Felix Lange <fjl@twurst.com>
+Guillaume Ballet <gballet@gmail.com>
+Jakob Weisblat <jakobw@yubico.com>
+Martin Holst Swende <martin@swende.se>
+Mateusz Mikołajczyk <mikolajczyk.mateusz@gmail.com>
+Péter Szilágyi <peterke@gmail.com>
+Rosen Penev <rosenp@gmail.com>
diff --git a/vendor/github.com/karalabe/usb/Dockerfile.alpine b/vendor/github.com/karalabe/usb/Dockerfile.alpine
new file mode 100644
index 000000000..342bdf79a
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/Dockerfile.alpine
@@ -0,0 +1,6 @@
+FROM golang:alpine
+
+RUN apk add --no-cache git gcc musl-dev linux-headers
+
+ADD . $GOPATH/src/github.com/karalabe/usb
+RUN cd $GOPATH/src/github.com/karalabe/usb && go install
diff --git a/vendor/github.com/karalabe/usb/Dockerfile.ubuntu b/vendor/github.com/karalabe/usb/Dockerfile.ubuntu
new file mode 100644
index 000000000..b861e497b
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/Dockerfile.ubuntu
@@ -0,0 +1,4 @@
+FROM golang:latest
+
+ADD . $GOPATH/src/github.com/karalabe/usb
+RUN cd $GOPATH/src/github.com/karalabe/usb && go install
diff --git a/vendor/github.com/karalabe/usb/LICENSE b/vendor/github.com/karalabe/usb/LICENSE
new file mode 100644
index 000000000..65c5ca88a
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/LICENSE
@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.
diff --git a/vendor/github.com/karalabe/usb/README.md b/vendor/github.com/karalabe/usb/README.md
new file mode 100644
index 000000000..b6920f51a
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/README.md
@@ -0,0 +1,47 @@
+[![Travis][travisimg]][travisurl]
+[![AppVeyor][appveyorimg]][appveyorurl]
+[![GoDoc][docimg]][docurl]
+
+[travisimg]:   https://travis-ci.org/karalabe/usb.svg?branch=master
+[travisurl]:   https://travis-ci.org/karalabe/usb
+[appveyorimg]: https://ci.appveyor.com/api/projects/status/u96eq262bj2itprh/branch/master?svg=true
+[appveyorurl]: https://ci.appveyor.com/project/karalabe/usb
+[docimg]:      https://godoc.org/github.com/karalabe/usb?status.svg
+[docurl]:      https://godoc.org/github.com/karalabe/usb
+
+# Yet another USB library for Go
+
+The `usb` package is a cross platform, fully self-contained library for accessing and communicating with USB devices **either via HID or low level interrupts**. The goal of the library was to create a simple way to find-, attach to- and read/write form USB devices.
+
+There are multiple already existing USB libraries:
+
+ * The original `gousb` package [created by @kylelemons](https://github.com/kylelemons/gousb) and nowadays [maintained by @google](https://github.com/google/gousb) is a CGO wrapper around `libusb`. It is the most advanced USB library for Go out there.
+   * Unfortunately, `gousb` requires the `libusb` C library to be installed both during build as well as during runtime on the host operating system. This breaks binary portability and also adds unnecessary hurdles on Windows.
+   * Furthermore, whilst HID devices are supported by `libusb`, the OS on Macos and Windows explicitly takes over these devices, so only native system calls can be used on recent versions (i.e. you **cannot** use `libusb` for HID).
+ * There is a fork of `gousb` [created by @karalabe](https://github.com/karalabe/gousb) that statically linked `libusb` during build, but with the lack of HID access, that work was abandoned.
+ * For HID-only devices, a previous self-contained package was created at [`github.com/karalabe/hid`](https://github.com/karalabe/hid), which worked well for hardware wallet uses cases in [`go-ethereum`](https://github.com/ethereum/go-ethereum). It's a simple package that does it's thing well.
+   * Unfortunately, `hid` is not capable of talking to generic USB devices. When multiple different devices are needed, eventually some will not support the HID spec (e.g. WebUSB). Pulling in both `hid` and `gousb` will break down due to both depending internally on different versions of `libusb` on Linux.
+
+This `usb` package is a proper integration of `hidapi` and `libusb` so that communication with HID devices is done via system calls, whereas communication with lower level USB devices is done via interrupts. All this detail is hidden away behind a tiny interface.
+
+The package supports Linux, macOS, Windows and FreeBSD. Exclude constraints are also specified for Android and iOS to allow smoother vendoring into cross platform projects.
+
+## Cross-compiling
+
+Using `go get`, the embedded C library is compiled into the binary format of your host OS. Cross compiling to a different platform or architecture entails disabling CGO by default in Go, causing device enumeration `hid.Enumerate()` to yield no results.
+
+To cross compile a functional version of this library, you'll need to enable CGO during cross compilation via `CGO_ENABLED=1` and you'll need to install and set a cross compilation enabled C toolkit via `CC=your-cross-gcc`.
+
+## Acknowledgements
+
+Although the `usb` package is an implementation from scratch, HID support was heavily inspired by the existing [`go.hid`](https://github.com/GeertJohan/go.hid) library, which seems abandoned since 2015; is incompatible with Go 1.6+; and has various external dependencies.
+
+Wide character support in the HID support is done via the [`gowchar`](https://github.com/orofarne/gowchar) library, unmaintained since 2013; non buildable with a modern Go release and failing `go vet` checks. As such, `gowchar` was also vendored in inline.
+
+Error handling for the `libusb` integration originates from the [`gousb`](https://github.com/google/gousb) library.
+
+## License
+
+This USB library is licensed under the [GNU Lesser General Public License v3.0](https://www.gnu.org/licenses/lgpl-3.0.en.html) (dictated by libusb).
+
+If you are only interested in Human Interface devices, a less restrictive package can be found at [`github.com/karalabe/hid`](https://github.com/karalabe/hid).
diff --git a/vendor/github.com/karalabe/usb/appveyor.yml b/vendor/github.com/karalabe/usb/appveyor.yml
new file mode 100644
index 000000000..595fd34ad
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/appveyor.yml
@@ -0,0 +1,35 @@
+os: Visual Studio 2015
+
+# Clone directly into GOPATH.
+clone_folder: C:\gopath\src\github.com\karalabe\usb
+clone_depth: 1
+version: "{branch}.{build}"
+environment:
+  global:
+    GOPATH: C:\gopath
+    CC: gcc.exe
+  matrix:
+    - GOARCH: amd64
+      MSYS2_ARCH: x86_64
+      MSYS2_BITS: 64
+      MSYSTEM: MINGW64
+      PATH: C:\msys64\mingw64\bin\;%PATH%
+    - GOARCH: 386
+      MSYS2_ARCH: i686
+      MSYS2_BITS: 32
+      MSYSTEM: MINGW32
+      PATH: C:\msys64\mingw32\bin\;%PATH%
+
+install:
+  - rmdir C:\go /s /q
+  - appveyor DownloadFile https://storage.googleapis.com/golang/go1.13.4.windows-%GOARCH%.zip
+  - 7z x go1.13.4.windows-%GOARCH%.zip -y -oC:\ > NUL
+  - go version
+  - gcc --version
+
+build_script:
+  - go install ./...
+  - go test -v ./...
+  - set CGO_ENABLED=0
+  - go install ./...
+  - go test -v ./...
diff --git a/vendor/github.com/karalabe/usb/demo.go b/vendor/github.com/karalabe/usb/demo.go
new file mode 100644
index 000000000..229faaf5f
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/demo.go
@@ -0,0 +1,76 @@
+// usb - Self contained USB and HID library for Go
+// Copyright 2019 The library Authors
+//
+// This library is free software: you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License as published by the Free
+// Software Foundation, either version 3 of the License, or (at your option) any
+// later version.
+//
+// The library is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+// A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License along
+// with the library. If not, see <http://www.gnu.org/licenses/>.
+
+// +build none
+
+package main
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/karalabe/usb"
+)
+
+func main() {
+	// Enumerate all the HID devices in alphabetical path order
+	hids, err := usb.EnumerateHid(0, 0)
+	if err != nil {
+		panic(err)
+	}
+	for i := 0; i < len(hids); i++ {
+		for j := i + 1; j < len(hids); j++ {
+			if hids[i].Path > hids[j].Path {
+				hids[i], hids[j] = hids[j], hids[i]
+			}
+		}
+	}
+	for i, hid := range hids {
+		fmt.Println(strings.Repeat("-", 128))
+		fmt.Printf("HID #%d\n", i)
+		fmt.Printf("  OS Path:      %s\n", hid.Path)
+		fmt.Printf("  Vendor ID:    %#04x\n", hid.VendorID)
+		fmt.Printf("  Product ID:   %#04x\n", hid.ProductID)
+		fmt.Printf("  Release:      %d\n", hid.Release)
+		fmt.Printf("  Serial:       %s\n", hid.Serial)
+		fmt.Printf("  Manufacturer: %s\n", hid.Manufacturer)
+		fmt.Printf("  Product:      %s\n", hid.Product)
+		fmt.Printf("  Usage Page:   %d\n", hid.UsagePage)
+		fmt.Printf("  Usage:        %d\n", hid.Usage)
+		fmt.Printf("  Interface:    %d\n", hid.Interface)
+	}
+	fmt.Println(strings.Repeat("=", 128))
+
+	// Enumerate all the non-HID devices in alphabetical path order
+	raws, err := usb.EnumerateRaw(0, 0)
+	if err != nil {
+		panic(err)
+	}
+	for i := 0; i < len(raws); i++ {
+		for j := i + 1; j < len(raws); j++ {
+			if raws[i].Path > raws[j].Path {
+				raws[i], raws[j] = raws[j], raws[i]
+			}
+		}
+	}
+	for i, raw := range raws {
+		fmt.Printf("RAW #%d\n", i)
+		fmt.Printf("  OS Path:    %s\n", raw.Path)
+		fmt.Printf("  Vendor ID:  %#04x\n", raw.VendorID)
+		fmt.Printf("  Product ID: %#04x\n", raw.ProductID)
+		fmt.Printf("  Interface:  %d\n", raw.Interface)
+		fmt.Println(strings.Repeat("-", 128))
+	}
+}
diff --git a/vendor/github.com/karalabe/usb/go.mod b/vendor/github.com/karalabe/usb/go.mod
new file mode 100644
index 000000000..ef549d28f
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/go.mod
@@ -0,0 +1,3 @@
+module github.com/karalabe/usb
+
+go 1.12
diff --git a/vendor/github.com/karalabe/usb/hid_disabled.go b/vendor/github.com/karalabe/usb/hid_disabled.go
new file mode 100644
index 000000000..a85964bf3
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/hid_disabled.go
@@ -0,0 +1,42 @@
+// usb - Self contained USB and HID library for Go
+// Copyright 2017 The library Authors
+//
+// This library is free software: you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License as published by the Free
+// Software Foundation, either version 3 of the License, or (at your option) any
+// later version.
+//
+// The library is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+// A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License along
+// with the library. If not, see <http://www.gnu.org/licenses/>.
+
+// +build !freebsd,!linux,!darwin,!windows ios !cgo
+
+package usb
+
+// HidDevice is a live HID USB connected device handle. On platforms that this file
+// implements, the type lacks the actual HID device and all methods are noop.
+type HidDevice struct {
+	DeviceInfo // Embed the infos for easier access
+}
+
+// Close releases the HID USB device handle. On platforms that this file implements,
+// the method is just a noop.
+func (dev *HidDevice) Close() error {
+	return ErrUnsupportedPlatform
+}
+
+// Write sends an output report to a HID device. On platforms that this file
+// implements, the method just returns an error.
+func (dev *HidDevice) Write(b []byte) (int, error) {
+	return 0, ErrUnsupportedPlatform
+}
+
+// Read retrieves an input report from a HID device. On platforms that this file
+// implements, the method just returns an error.
+func (dev *HidDevice) Read(b []byte) (int, error) {
+	return 0, ErrUnsupportedPlatform
+}
diff --git a/vendor/github.com/karalabe/usb/hid_enabled.go b/vendor/github.com/karalabe/usb/hid_enabled.go
new file mode 100644
index 000000000..c2b372098
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/hid_enabled.go
@@ -0,0 +1,187 @@
+// usb - Self contained USB and HID library for Go
+// Copyright 2017 The library Authors
+//
+// This library is free software: you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License as published by the Free
+// Software Foundation, either version 3 of the License, or (at your option) any
+// later version.
+//
+// The library is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+// A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License along
+// with the library. If not, see <http://www.gnu.org/licenses/>.
+
+// +build freebsd,cgo linux,cgo darwin,!ios,cgo windows,cgo
+
+package usb
+
+/*
+#include <stdlib.h>
+#include "./hidapi/hidapi/hidapi.h"
+*/
+import "C"
+
+import (
+	"errors"
+	"runtime"
+	"sync"
+	"unsafe"
+)
+
+// enumerateHid returns a list of all the HID devices attached to the system which
+// match the vendor and product id:
+//  - If the vendor id is set to 0 then any vendor matches.
+//  - If the product id is set to 0 then any product matches.
+//  - If the vendor and product id are both 0, all HID devices are returned.
+func enumerateHid(vendorID uint16, productID uint16) ([]DeviceInfo, error) {
+	// Gather all device infos and ensure they are freed before returning
+	head := C.hid_enumerate(C.ushort(vendorID), C.ushort(productID))
+	if head == nil {
+		return nil, nil
+	}
+	defer C.hid_free_enumeration(head)
+
+	// Iterate the list and retrieve the device details
+	var infos []DeviceInfo
+	for ; head != nil; head = head.next {
+		info := DeviceInfo{
+			Path:      C.GoString(head.path),
+			VendorID:  uint16(head.vendor_id),
+			ProductID: uint16(head.product_id),
+			Release:   uint16(head.release_number),
+			UsagePage: uint16(head.usage_page),
+			Usage:     uint16(head.usage),
+			Interface: int(head.interface_number),
+		}
+		if head.serial_number != nil {
+			info.Serial, _ = wcharTToString(head.serial_number)
+		}
+		if head.product_string != nil {
+			info.Product, _ = wcharTToString(head.product_string)
+		}
+		if head.manufacturer_string != nil {
+			info.Manufacturer, _ = wcharTToString(head.manufacturer_string)
+		}
+		infos = append(infos, info)
+	}
+	return infos, nil
+}
+
+// openHid connects to an HID device by its path name.
+func openHid(info DeviceInfo) (*hidDevice, error) {
+	path := C.CString(info.Path)
+	defer C.free(unsafe.Pointer(path))
+
+	device := C.hid_open_path(path)
+	if device == nil {
+		return nil, errors.New("hidapi: failed to open device")
+	}
+	return &hidDevice{
+		DeviceInfo: info,
+		device:     device,
+	}, nil
+}
+
+// hidDevice is a live HID USB connected device handle.
+type hidDevice struct {
+	DeviceInfo // Embed the infos for easier access
+
+	device *C.hid_device // Low level HID device to communicate through
+	lock   sync.Mutex
+}
+
+// Close releases the HID USB device handle.
+func (dev *hidDevice) Close() error {
+	dev.lock.Lock()
+	defer dev.lock.Unlock()
+
+	if dev.device != nil {
+		C.hid_close(dev.device)
+		dev.device = nil
+	}
+	return nil
+}
+
+// Write sends an output report to a HID device.
+//
+// Write will send the data on the first OUT endpoint, if one exists. If it does
+// not, it will send the data through the Control Endpoint (Endpoint 0).
+func (dev *hidDevice) Write(b []byte) (int, error) {
+	// Abort if nothing to write
+	if len(b) == 0 {
+		return 0, nil
+	}
+	// Abort if device closed in between
+	dev.lock.Lock()
+	device := dev.device
+	dev.lock.Unlock()
+
+	if device == nil {
+		return 0, ErrDeviceClosed
+	}
+	// Prepend a HID report ID on Windows, other OSes don't need it
+	var report []byte
+	if runtime.GOOS == "windows" {
+		report = append([]byte{0x00}, b...)
+	} else {
+		report = b
+	}
+	// Execute the write operation
+	written := int(C.hid_write(device, (*C.uchar)(&report[0]), C.size_t(len(report))))
+	if written == -1 {
+		// If the write failed, verify if closed or other error
+		dev.lock.Lock()
+		device = dev.device
+		dev.lock.Unlock()
+
+		if device == nil {
+			return 0, ErrDeviceClosed
+		}
+		// Device not closed, some other error occurred
+		message := C.hid_error(device)
+		if message == nil {
+			return 0, errors.New("hidapi: unknown failure")
+		}
+		failure, _ := wcharTToString(message)
+		return 0, errors.New("hidapi: " + failure)
+	}
+	return written, nil
+}
+
+// Read retrieves an input report from a HID device.
+func (dev *hidDevice) Read(b []byte) (int, error) {
+	// Aborth if nothing to read
+	if len(b) == 0 {
+		return 0, nil
+	}
+	// Abort if device closed in between
+	dev.lock.Lock()
+	device := dev.device
+	dev.lock.Unlock()
+
+	if device == nil {
+		return 0, ErrDeviceClosed
+	}
+	// Execute the read operation
+	read := int(C.hid_read(device, (*C.uchar)(&b[0]), C.size_t(len(b))))
+	if read == -1 {
+		// If the read failed, verify if closed or other error
+		dev.lock.Lock()
+		device = dev.device
+		dev.lock.Unlock()
+
+		if device == nil {
+			return 0, ErrDeviceClosed
+		}
+		// Device not closed, some other error occurred
+		message := C.hid_error(device)
+		if message == nil {
+			return 0, errors.New("hidapi: unknown failure")
+		}
+		failure, _ := wcharTToString(message)
+		return 0, errors.New("hidapi: " + failure)
+	}
+	return read, nil
+}
diff --git a/vendor/github.com/karalabe/usb/hidapi/AUTHORS.txt b/vendor/github.com/karalabe/usb/hidapi/AUTHORS.txt
new file mode 100644
index 000000000..7acafd78c
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/hidapi/AUTHORS.txt
@@ -0,0 +1,16 @@
+
+HIDAPI Authors:
+
+Alan Ott <alan@signal11.us>:
+	Original Author and Maintainer
+	Linux, Windows, and Mac implementations
+
+Ludovic Rousseau <rousseau@debian.org>:
+	Formatting for Doxygen documentation
+	Bug fixes
+	Correctness fixes
+
+
+For a comprehensive list of contributions, see the commit list at github:
+	http://github.com/signal11/hidapi/commits/master
+
diff --git a/vendor/github.com/karalabe/usb/hidapi/LICENSE-bsd.txt b/vendor/github.com/karalabe/usb/hidapi/LICENSE-bsd.txt
new file mode 100644
index 000000000..538cdf95c
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/hidapi/LICENSE-bsd.txt
@@ -0,0 +1,26 @@
+Copyright (c) 2010, Alan Ott, Signal 11 Software
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Signal 11 Software nor the names of its
+      contributors may be used to endorse or promote products derived from
+      this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/github.com/karalabe/usb/hidapi/LICENSE-gpl3.txt b/vendor/github.com/karalabe/usb/hidapi/LICENSE-gpl3.txt
new file mode 100644
index 000000000..94a9ed024
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/hidapi/LICENSE-gpl3.txt
@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
diff --git a/vendor/github.com/karalabe/usb/hidapi/LICENSE-orig.txt b/vendor/github.com/karalabe/usb/hidapi/LICENSE-orig.txt
new file mode 100644
index 000000000..e3f338082
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/hidapi/LICENSE-orig.txt
@@ -0,0 +1,9 @@
+ HIDAPI - Multi-Platform library for
+ communication with HID devices.
+
+ Copyright 2009, Alan Ott, Signal 11 Software.
+ All Rights Reserved.
+ 
+ This software may be used by anyone for any reason so
+ long as the copyright notice in the source files
+ remains intact.
diff --git a/vendor/github.com/karalabe/usb/hidapi/LICENSE.txt b/vendor/github.com/karalabe/usb/hidapi/LICENSE.txt
new file mode 100644
index 000000000..e1676d4c4
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/hidapi/LICENSE.txt
@@ -0,0 +1,13 @@
+HIDAPI can be used under one of three licenses.
+
+1. The GNU General Public License, version 3.0, in LICENSE-gpl3.txt
+2. A BSD-Style License, in LICENSE-bsd.txt.
+3. The more liberal original HIDAPI license. LICENSE-orig.txt
+
+The license chosen is at the discretion of the user of HIDAPI. For example:
+1. An author of GPL software would likely use HIDAPI under the terms of the
+GPL.
+
+2. An author of commercial closed-source software would likely use HIDAPI
+under the terms of the BSD-style license or the original HIDAPI license.
+
diff --git a/vendor/github.com/karalabe/usb/hidapi/README.txt b/vendor/github.com/karalabe/usb/hidapi/README.txt
new file mode 100644
index 000000000..f19dae4ab
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/hidapi/README.txt
@@ -0,0 +1,339 @@
+         HIDAPI library for Windows, Linux, FreeBSD and Mac OS X
+        =========================================================
+
+About
+======
+
+HIDAPI is a multi-platform library which allows an application to interface
+with USB and Bluetooth HID-Class devices on Windows, Linux, FreeBSD, and Mac
+OS X.  HIDAPI can be either built as a shared library (.so or .dll) or
+can be embedded directly into a target application by adding a single source
+file (per platform) and a single header.
+
+HIDAPI has four back-ends:
+	* Windows (using hid.dll)
+	* Linux/hidraw (using the Kernel's hidraw driver)
+	* Linux/libusb (using libusb-1.0)
+	* FreeBSD (using libusb-1.0)
+	* Mac (using IOHidManager)
+
+On Linux, either the hidraw or the libusb back-end can be used. There are
+tradeoffs, and the functionality supported is slightly different.
+
+Linux/hidraw (linux/hid.c):
+This back-end uses the hidraw interface in the Linux kernel.  While this
+back-end will support both USB and Bluetooth, it has some limitations on
+kernels prior to 2.6.39, including the inability to send or receive feature
+reports.  In addition, it will only communicate with devices which have
+hidraw nodes associated with them.  Keyboards, mice, and some other devices
+which are blacklisted from having hidraw nodes will not work. Fortunately,
+for nearly all the uses of hidraw, this is not a problem.
+
+Linux/FreeBSD/libusb (libusb/hid.c):
+This back-end uses libusb-1.0 to communicate directly to a USB device. This
+back-end will of course not work with Bluetooth devices.
+
+HIDAPI also comes with a Test GUI. The Test GUI is cross-platform and uses
+Fox Toolkit (http://www.fox-toolkit.org).  It will build on every platform
+which HIDAPI supports.  Since it relies on a 3rd party library, building it
+is optional but recommended because it is so useful when debugging hardware.
+
+What Does the API Look Like?
+=============================
+The API provides the the most commonly used HID functions including sending
+and receiving of input, output, and feature reports.  The sample program,
+which communicates with a heavily hacked up version of the Microchip USB
+Generic HID sample looks like this (with error checking removed for
+simplicity):
+
+#ifdef WIN32
+#include <windows.h>
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+#include "hidapi.h"
+
+#define MAX_STR 255
+
+int main(int argc, char* argv[])
+{
+	int res;
+	unsigned char buf[65];
+	wchar_t wstr[MAX_STR];
+	hid_device *handle;
+	int i;
+
+	// Initialize the hidapi library
+	res = hid_init();
+
+	// Open the device using the VID, PID,
+	// and optionally the Serial number.
+	handle = hid_open(0x4d8, 0x3f, NULL);
+
+	// Read the Manufacturer String
+	res = hid_get_manufacturer_string(handle, wstr, MAX_STR);
+	wprintf(L"Manufacturer String: %s\n", wstr);
+
+	// Read the Product String
+	res = hid_get_product_string(handle, wstr, MAX_STR);
+	wprintf(L"Product String: %s\n", wstr);
+
+	// Read the Serial Number String
+	res = hid_get_serial_number_string(handle, wstr, MAX_STR);
+	wprintf(L"Serial Number String: (%d) %s\n", wstr[0], wstr);
+
+	// Read Indexed String 1
+	res = hid_get_indexed_string(handle, 1, wstr, MAX_STR);
+	wprintf(L"Indexed String 1: %s\n", wstr);
+
+	// Toggle LED (cmd 0x80). The first byte is the report number (0x0).
+	buf[0] = 0x0;
+	buf[1] = 0x80;
+	res = hid_write(handle, buf, 65);
+
+	// Request state (cmd 0x81). The first byte is the report number (0x0).
+	buf[0] = 0x0;
+	buf[1] = 0x81;
+	res = hid_write(handle, buf, 65);
+
+	// Read requested state
+	res = hid_read(handle, buf, 65);
+
+	// Print out the returned buffer.
+	for (i = 0; i < 4; i++)
+		printf("buf[%d]: %d\n", i, buf[i]);
+
+	// Finalize the hidapi library
+	res = hid_exit();
+
+	return 0;
+}
+
+If you have your own simple test programs which communicate with standard
+hardware development boards (such as those from Microchip, TI, Atmel,
+FreeScale and others), please consider sending me something like the above
+for inclusion into the HIDAPI source.  This will help others who have the
+same hardware as you do.
+
+License
+========
+HIDAPI may be used by one of three licenses as outlined in LICENSE.txt.
+
+Download
+=========
+HIDAPI can be downloaded from github
+	git clone git://github.com/signal11/hidapi.git
+
+Build Instructions
+===================
+
+This section is long. Don't be put off by this. It's not long because it's
+complicated to build HIDAPI; it's quite the opposite.  This section is long
+because of the flexibility of HIDAPI and the large number of ways in which
+it can be built and used.  You will likely pick a single build method.
+
+HIDAPI can be built in several different ways. If you elect to build a
+shared library, you will need to build it from the HIDAPI source
+distribution.  If you choose instead to embed HIDAPI directly into your
+application, you can skip the building and look at the provided platform
+Makefiles for guidance.  These platform Makefiles are located in linux/
+libusb/ mac/ and windows/ and are called Makefile-manual.  In addition,
+Visual Studio projects are provided.  Even if you're going to embed HIDAPI
+into your project, it is still beneficial to build the example programs.
+
+
+Prerequisites:
+---------------
+
+	Linux:
+	-------
+	On Linux, you will need to install development packages for libudev,
+	libusb and optionally Fox-toolkit (for the test GUI). On
+	Debian/Ubuntu systems these can be installed by running:
+	    sudo apt-get install libudev-dev libusb-1.0-0-dev libfox-1.6-dev
+
+	If you downloaded the source directly from the git repository (using
+	git clone), you'll need Autotools:
+	    sudo apt-get install autotools-dev autoconf automake libtool
+
+	FreeBSD:
+	---------
+	On FreeBSD you will need to install GNU make, libiconv, and
+	optionally Fox-Toolkit (for the test GUI). This is done by running
+	the following:
+	    pkg_add -r gmake libiconv fox16
+
+	If you downloaded the source directly from the git repository (using
+	git clone), you'll need Autotools:
+	    pkg_add -r autotools
+
+	Mac:
+	-----
+	On Mac, you will need to install Fox-Toolkit if you wish to build
+	the Test GUI. There are two ways to do this, and each has a slight
+	complication. Which method you use depends on your use case.
+
+	If you wish to build the Test GUI just for your own testing on your
+	own computer, then the easiest method is to install Fox-Toolkit
+	using ports:
+		sudo port install fox
+
+	If you wish to build the TestGUI app bundle to redistribute to
+	others, you will need to install Fox-toolkit from source.  This is
+	because the version of fox that gets installed using ports uses the
+	ports X11 libraries which are not compatible with the Apple X11
+	libraries.  If you install Fox with ports and then try to distribute
+	your built app bundle, it will simply fail to run on other systems.
+	To install Fox-Toolkit manually, download the source package from
+	http://www.fox-toolkit.org, extract it, and run the following from
+	within the extracted source:
+		./configure && make && make install
+
+	Windows:
+	---------
+	On Windows, if you want to build the test GUI, you will need to get
+	the hidapi-externals.zip package from the download site.  This
+	contains pre-built binaries for Fox-toolkit.  Extract
+	hidapi-externals.zip just outside of hidapi, so that
+	hidapi-externals and hidapi are on the same level, as shown:
+
+	     Parent_Folder
+	       |
+	       +hidapi
+	       +hidapi-externals
+
+	Again, this step is not required if you do not wish to build the
+	test GUI.
+
+
+Building HIDAPI into a shared library on Unix Platforms:
+---------------------------------------------------------
+
+On Unix-like systems such as Linux, FreeBSD, Mac, and even Windows, using
+Mingw or Cygwin, the easiest way to build a standard system-installed shared
+library is to use the GNU Autotools build system.  If you checked out the
+source from the git repository, run the following:
+
+	./bootstrap
+	./configure
+	make
+	make install     <----- as root, or using sudo
+
+If you downloaded a source package (ie: if you did not run git clone), you
+can skip the ./bootstrap step.
+
+./configure can take several arguments which control the build. The two most
+likely to be used are:
+	--enable-testgui
+		Enable build of the Test GUI. This requires Fox toolkit to
+		be installed.  Instructions for installing Fox-Toolkit on
+		each platform are in the Prerequisites section above.
+
+	--prefix=/usr
+		Specify where you want the output headers and libraries to
+		be installed. The example above will put the headers in
+		/usr/include and the binaries in /usr/lib. The default is to
+		install into /usr/local which is fine on most systems.
+
+Building the manual way on Unix platforms:
+-------------------------------------------
+
+Manual Makefiles are provided mostly to give the user and idea what it takes
+to build a program which embeds HIDAPI directly inside of it. These should
+really be used as examples only. If you want to build a system-wide shared
+library, use the Autotools method described above.
+
+	To build HIDAPI using the manual makefiles, change to the directory
+	of your platform and run make. For example, on Linux run:
+		cd linux/
+		make -f Makefile-manual
+
+	To build the Test GUI using the manual makefiles:
+		cd testgui/
+		make -f Makefile-manual
+
+Building on Windows:
+---------------------
+
+To build the HIDAPI DLL on Windows using Visual Studio, build the .sln file
+in the windows/ directory.
+
+To build the Test GUI on windows using Visual Studio, build the .sln file in
+the testgui/ directory.
+
+To build HIDAPI using MinGW or Cygwin using Autotools, use the instructions
+in the section titled "Building HIDAPI into a shared library on Unix
+Platforms" above.  Note that building the Test GUI with MinGW or Cygwin will
+require the Windows procedure in the Prerequisites section above (ie:
+hidapi-externals.zip).
+
+To build HIDAPI using MinGW using the Manual Makefiles, see the section
+"Building the manual way on Unix platforms" above.
+
+HIDAPI can also be built using the Windows DDK (now also called the Windows
+Driver Kit or WDK). This method was originally required for the HIDAPI build
+but not anymore. However, some users still prefer this method. It is not as
+well supported anymore but should still work. Patches are welcome if it does
+not. To build using the DDK:
+
+   1. Install the Windows Driver Kit (WDK) from Microsoft.
+   2. From the Start menu, in the Windows Driver Kits folder, select Build
+      Environments, then your operating system, then the x86 Free Build
+      Environment (or one that is appropriate for your system).
+   3. From the console, change directory to the windows/ddk_build/ directory,
+      which is part of the HIDAPI distribution.
+   4. Type build.
+   5. You can find the output files (DLL and LIB) in a subdirectory created
+      by the build system which is appropriate for your environment. On
+      Windows XP, this directory is objfre_wxp_x86/i386.
+
+Cross Compiling
+================
+
+This section talks about cross compiling HIDAPI for Linux using autotools.
+This is useful for using HIDAPI on embedded Linux targets.  These
+instructions assume the most raw kind of embedded Linux build, where all
+prerequisites will need to be built first.  This process will of course vary
+based on your embedded Linux build system if you are using one, such as
+OpenEmbedded or Buildroot.
+
+For the purpose of this section, it will be assumed that the following
+environment variables are exported.
+
+	$ export STAGING=$HOME/out
+	$ export HOST=arm-linux
+
+STAGING and HOST can be modified to suit your setup.
+
+Prerequisites
+--------------
+
+Note that the build of libudev is the very basic configuration.
+
+Build Libusb. From the libusb source directory, run:
+	./configure --host=$HOST --prefix=$STAGING
+	make
+	make install
+
+Build libudev. From the libudev source directory, run:
+	./configure --disable-gudev --disable-introspection --disable-hwdb \
+		 --host=$HOST --prefix=$STAGING
+	make
+	make install
+
+Building HIDAPI
+----------------
+
+Build HIDAPI:
+
+	PKG_CONFIG_DIR= \
+	PKG_CONFIG_LIBDIR=$STAGING/lib/pkgconfig:$STAGING/share/pkgconfig \
+	PKG_CONFIG_SYSROOT_DIR=$STAGING \
+	./configure --host=$HOST --prefix=$STAGING
+
+
+Signal 11 Software - 2010-04-11
+                     2010-07-28
+                     2011-09-10
+                     2012-05-01
+                     2012-07-03
diff --git a/vendor/github.com/karalabe/usb/hidapi/hidapi/hidapi.h b/vendor/github.com/karalabe/usb/hidapi/hidapi/hidapi.h
new file mode 100644
index 000000000..166f3509a
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/hidapi/hidapi/hidapi.h
@@ -0,0 +1,390 @@
+/*******************************************************
+ HIDAPI - Multi-Platform library for
+ communication with HID devices.
+
+ Alan Ott
+ Signal 11 Software
+
+ 8/22/2009
+
+ Copyright 2009, All Rights Reserved.
+
+ At the discretion of the user of this library,
+ this software may be licensed under the terms of the
+ GNU General Public License v3, a BSD-Style license, or the
+ original HIDAPI license as outlined in the LICENSE.txt,
+ LICENSE-gpl3.txt, LICENSE-bsd.txt, and LICENSE-orig.txt
+ files located at the root of the source distribution.
+ These files may also be found in the public source
+ code repository located at:
+        http://github.com/signal11/hidapi .
+********************************************************/
+
+/** @file
+ * @defgroup API hidapi API
+ */
+
+#ifndef HIDAPI_H__
+#define HIDAPI_H__
+
+#include <wchar.h>
+
+#ifdef _WIN32
+      #define HID_API_EXPORT __declspec(dllexport)
+      #define HID_API_CALL
+#else
+      #define HID_API_EXPORT /**< API export macro */
+      #define HID_API_CALL /**< API call macro */
+#endif
+
+#define HID_API_EXPORT_CALL HID_API_EXPORT HID_API_CALL /**< API export and call macro*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+		struct hid_device_;
+		typedef struct hid_device_ hid_device; /**< opaque hidapi structure */
+
+		/** hidapi info structure */
+		struct hid_device_info {
+			/** Platform-specific device path */
+			char *path;
+			/** Device Vendor ID */
+			unsigned short vendor_id;
+			/** Device Product ID */
+			unsigned short product_id;
+			/** Serial Number */
+			wchar_t *serial_number;
+			/** Device Release Number in binary-coded decimal,
+			    also known as Device Version Number */
+			unsigned short release_number;
+			/** Manufacturer String */
+			wchar_t *manufacturer_string;
+			/** Product string */
+			wchar_t *product_string;
+			/** Usage Page for this Device/Interface
+			    (Windows/Mac only). */
+			unsigned short usage_page;
+			/** Usage for this Device/Interface
+			    (Windows/Mac only).*/
+			unsigned short usage;
+			/** The USB interface which this logical device
+			    represents. Valid on both Linux implementations
+			    in all cases, and valid on the Windows implementation
+			    only if the device contains more than one interface. */
+			int interface_number;
+
+			/** Pointer to the next device */
+			struct hid_device_info *next;
+		};
+
+
+		/** @brief Initialize the HIDAPI library.
+
+			This function initializes the HIDAPI library. Calling it is not
+			strictly necessary, as it will be called automatically by
+			hid_enumerate() and any of the hid_open_*() functions if it is
+			needed.  This function should be called at the beginning of
+			execution however, if there is a chance of HIDAPI handles
+			being opened by different threads simultaneously.
+
+			@ingroup API
+
+			@returns
+				This function returns 0 on success and -1 on error.
+		*/
+		int HID_API_EXPORT HID_API_CALL hid_init(void);
+
+		/** @brief Finalize the HIDAPI library.
+
+			This function frees all of the static data associated with
+			HIDAPI. It should be called at the end of execution to avoid
+			memory leaks.
+
+			@ingroup API
+
+		    @returns
+				This function returns 0 on success and -1 on error.
+		*/
+		int HID_API_EXPORT HID_API_CALL hid_exit(void);
+
+		/** @brief Enumerate the HID Devices.
+
+			This function returns a linked list of all the HID devices
+			attached to the system which match vendor_id and product_id.
+			If @p vendor_id is set to 0 then any vendor matches.
+			If @p product_id is set to 0 then any product matches.
+			If @p vendor_id and @p product_id are both set to 0, then
+			all HID devices will be returned.
+
+			@ingroup API
+			@param vendor_id The Vendor ID (VID) of the types of device
+				to open.
+			@param product_id The Product ID (PID) of the types of
+				device to open.
+
+		    @returns
+		    	This function returns a pointer to a linked list of type
+		    	struct #hid_device, containing information about the HID devices
+		    	attached to the system, or NULL in the case of failure. Free
+		    	this linked list by calling hid_free_enumeration().
+		*/
+		struct hid_device_info HID_API_EXPORT * HID_API_CALL hid_enumerate(unsigned short vendor_id, unsigned short product_id);
+
+		/** @brief Free an enumeration Linked List
+
+		    This function frees a linked list created by hid_enumerate().
+
+			@ingroup API
+		    @param devs Pointer to a list of struct_device returned from
+		    	      hid_enumerate().
+		*/
+		void  HID_API_EXPORT HID_API_CALL hid_free_enumeration(struct hid_device_info *devs);
+
+		/** @brief Open a HID device using a Vendor ID (VID), Product ID
+			(PID) and optionally a serial number.
+
+			If @p serial_number is NULL, the first device with the
+			specified VID and PID is opened.
+
+			@ingroup API
+			@param vendor_id The Vendor ID (VID) of the device to open.
+			@param product_id The Product ID (PID) of the device to open.
+			@param serial_number The Serial Number of the device to open
+				               (Optionally NULL).
+
+			@returns
+				This function returns a pointer to a #hid_device object on
+				success or NULL on failure.
+		*/
+		HID_API_EXPORT hid_device * HID_API_CALL hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number);
+
+		/** @brief Open a HID device by its path name.
+
+			The path name be determined by calling hid_enumerate(), or a
+			platform-specific path name can be used (eg: /dev/hidraw0 on
+			Linux).
+
+			@ingroup API
+		    @param path The path name of the device to open
+
+			@returns
+				This function returns a pointer to a #hid_device object on
+				success or NULL on failure.
+		*/
+		HID_API_EXPORT hid_device * HID_API_CALL hid_open_path(const char *path);
+
+		/** @brief Write an Output report to a HID device.
+
+			The first byte of @p data[] must contain the Report ID. For
+			devices which only support a single report, this must be set
+			to 0x0. The remaining bytes contain the report data. Since
+			the Report ID is mandatory, calls to hid_write() will always
+			contain one more byte than the report contains. For example,
+			if a hid report is 16 bytes long, 17 bytes must be passed to
+			hid_write(), the Report ID (or 0x0, for devices with a
+			single report), followed by the report data (16 bytes). In
+			this example, the length passed in would be 17.
+
+			hid_write() will send the data on the first OUT endpoint, if
+			one exists. If it does not, it will send the data through
+			the Control Endpoint (Endpoint 0).
+
+			@ingroup API
+			@param device A device handle returned from hid_open().
+			@param data The data to send, including the report number as
+				the first byte.
+			@param length The length in bytes of the data to send.
+
+			@returns
+				This function returns the actual number of bytes written and
+				-1 on error.
+		*/
+		int  HID_API_EXPORT HID_API_CALL hid_write(hid_device *device, const unsigned char *data, size_t length);
+
+		/** @brief Read an Input report from a HID device with timeout.
+
+			Input reports are returned
+			to the host through the INTERRUPT IN endpoint. The first byte will
+			contain the Report number if the device uses numbered reports.
+
+			@ingroup API
+			@param device A device handle returned from hid_open().
+			@param data A buffer to put the read data into.
+			@param length The number of bytes to read. For devices with
+				multiple reports, make sure to read an extra byte for
+				the report number.
+			@param milliseconds timeout in milliseconds or -1 for blocking wait.
+
+			@returns
+				This function returns the actual number of bytes read and
+				-1 on error. If no packet was available to be read within
+				the timeout period, this function returns 0.
+		*/
+		int HID_API_EXPORT HID_API_CALL hid_read_timeout(hid_device *dev, unsigned char *data, size_t length, int milliseconds);
+
+		/** @brief Read an Input report from a HID device.
+
+			Input reports are returned
+		    to the host through the INTERRUPT IN endpoint. The first byte will
+			contain the Report number if the device uses numbered reports.
+
+			@ingroup API
+			@param device A device handle returned from hid_open().
+			@param data A buffer to put the read data into.
+			@param length The number of bytes to read. For devices with
+				multiple reports, make sure to read an extra byte for
+				the report number.
+
+			@returns
+				This function returns the actual number of bytes read and
+				-1 on error. If no packet was available to be read and
+				the handle is in non-blocking mode, this function returns 0.
+		*/
+		int  HID_API_EXPORT HID_API_CALL hid_read(hid_device *device, unsigned char *data, size_t length);
+
+		/** @brief Set the device handle to be non-blocking.
+
+			In non-blocking mode calls to hid_read() will return
+			immediately with a value of 0 if there is no data to be
+			read. In blocking mode, hid_read() will wait (block) until
+			there is data to read before returning.
+
+			Nonblocking can be turned on and off at any time.
+
+			@ingroup API
+			@param device A device handle returned from hid_open().
+			@param nonblock enable or not the nonblocking reads
+			 - 1 to enable nonblocking
+			 - 0 to disable nonblocking.
+
+			@returns
+				This function returns 0 on success and -1 on error.
+		*/
+		int  HID_API_EXPORT HID_API_CALL hid_set_nonblocking(hid_device *device, int nonblock);
+
+		/** @brief Send a Feature report to the device.
+
+			Feature reports are sent over the Control endpoint as a
+			Set_Report transfer.  The first byte of @p data[] must
+			contain the Report ID. For devices which only support a
+			single report, this must be set to 0x0. The remaining bytes
+			contain the report data. Since the Report ID is mandatory,
+			calls to hid_send_feature_report() will always contain one
+			more byte than the report contains. For example, if a hid
+			report is 16 bytes long, 17 bytes must be passed to
+			hid_send_feature_report(): the Report ID (or 0x0, for
+			devices which do not use numbered reports), followed by the
+			report data (16 bytes). In this example, the length passed
+			in would be 17.
+
+			@ingroup API
+			@param device A device handle returned from hid_open().
+			@param data The data to send, including the report number as
+				the first byte.
+			@param length The length in bytes of the data to send, including
+				the report number.
+
+			@returns
+				This function returns the actual number of bytes written and
+				-1 on error.
+		*/
+		int HID_API_EXPORT HID_API_CALL hid_send_feature_report(hid_device *device, const unsigned char *data, size_t length);
+
+		/** @brief Get a feature report from a HID device.
+
+			Set the first byte of @p data[] to the Report ID of the
+			report to be read.  Make sure to allow space for this
+			extra byte in @p data[]. Upon return, the first byte will
+			still contain the Report ID, and the report data will
+			start in data[1].
+
+			@ingroup API
+			@param device A device handle returned from hid_open().
+			@param data A buffer to put the read data into, including
+				the Report ID. Set the first byte of @p data[] to the
+				Report ID of the report to be read, or set it to zero
+				if your device does not use numbered reports.
+			@param length The number of bytes to read, including an
+				extra byte for the report ID. The buffer can be longer
+				than the actual report.
+
+			@returns
+				This function returns the number of bytes read plus
+				one for the report ID (which is still in the first
+				byte), or -1 on error.
+		*/
+		int HID_API_EXPORT HID_API_CALL hid_get_feature_report(hid_device *device, unsigned char *data, size_t length);
+
+		/** @brief Close a HID device.
+
+			@ingroup API
+			@param device A device handle returned from hid_open().
+		*/
+		void HID_API_EXPORT HID_API_CALL hid_close(hid_device *device);
+
+		/** @brief Get The Manufacturer String from a HID device.
+
+			@ingroup API
+			@param device A device handle returned from hid_open().
+			@param string A wide string buffer to put the data into.
+			@param maxlen The length of the buffer in multiples of wchar_t.
+
+			@returns
+				This function returns 0 on success and -1 on error.
+		*/
+		int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device *device, wchar_t *string, size_t maxlen);
+
+		/** @brief Get The Product String from a HID device.
+
+			@ingroup API
+			@param device A device handle returned from hid_open().
+			@param string A wide string buffer to put the data into.
+			@param maxlen The length of the buffer in multiples of wchar_t.
+
+			@returns
+				This function returns 0 on success and -1 on error.
+		*/
+		int HID_API_EXPORT_CALL hid_get_product_string(hid_device *device, wchar_t *string, size_t maxlen);
+
+		/** @brief Get The Serial Number String from a HID device.
+
+			@ingroup API
+			@param device A device handle returned from hid_open().
+			@param string A wide string buffer to put the data into.
+			@param maxlen The length of the buffer in multiples of wchar_t.
+
+			@returns
+				This function returns 0 on success and -1 on error.
+		*/
+		int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *device, wchar_t *string, size_t maxlen);
+
+		/** @brief Get a string from a HID device, based on its string index.
+
+			@ingroup API
+			@param device A device handle returned from hid_open().
+			@param string_index The index of the string to get.
+			@param string A wide string buffer to put the data into.
+			@param maxlen The length of the buffer in multiples of wchar_t.
+
+			@returns
+				This function returns 0 on success and -1 on error.
+		*/
+		int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *device, int string_index, wchar_t *string, size_t maxlen);
+
+		/** @brief Get a string describing the last error which occurred.
+
+			@ingroup API
+			@param device A device handle returned from hid_open().
+
+			@returns
+				This function returns a string containing the last error
+				which occurred or NULL if none has occurred.
+		*/
+		HID_API_EXPORT const wchar_t* HID_API_CALL hid_error(hid_device *device);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/vendor/github.com/karalabe/usb/hidapi/libusb/hid.c b/vendor/github.com/karalabe/usb/hidapi/libusb/hid.c
new file mode 100644
index 000000000..e91474065
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/hidapi/libusb/hid.c
@@ -0,0 +1,1508 @@
+/*******************************************************
+ HIDAPI - Multi-Platform library for
+ communication with HID devices.
+
+ Alan Ott
+ Signal 11 Software
+
+ 8/22/2009
+ Linux Version - 6/2/2010
+ Libusb Version - 8/13/2010
+ FreeBSD Version - 11/1/2011
+
+ Copyright 2009, All Rights Reserved.
+
+ At the discretion of the user of this library,
+ this software may be licensed under the terms of the
+ GNU General Public License v3, a BSD-Style license, or the
+ original HIDAPI license as outlined in the LICENSE.txt,
+ LICENSE-gpl3.txt, LICENSE-bsd.txt, and LICENSE-orig.txt
+ files located at the root of the source distribution.
+ These files may also be found in the public source
+ code repository located at:
+        http://github.com/signal11/hidapi .
+********************************************************/
+
+/* C */
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <locale.h>
+#include <errno.h>
+
+/* Unix */
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <sys/utsname.h>
+#include <fcntl.h>
+#include <pthread.h>
+#include <wchar.h>
+
+/* GNU / LibUSB */
+#include <libusb.h>
+#ifndef __ANDROID__
+#include <iconv.h>
+#endif
+
+#include "hidapi.h"
+
+#ifdef __ANDROID__
+
+/* Barrier implementation because Android/Bionic don't have pthread_barrier.
+   This implementation came from Brent Priddy and was posted on
+   StackOverflow. It is used with his permission. */
+typedef int pthread_barrierattr_t;
+typedef struct pthread_barrier {
+    pthread_mutex_t mutex;
+    pthread_cond_t cond;
+    int count;
+    int trip_count;
+} pthread_barrier_t;
+
+static int pthread_barrier_init(pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count)
+{
+	if(count == 0) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	if(pthread_mutex_init(&barrier->mutex, 0) < 0) {
+		return -1;
+	}
+	if(pthread_cond_init(&barrier->cond, 0) < 0) {
+		pthread_mutex_destroy(&barrier->mutex);
+		return -1;
+	}
+	barrier->trip_count = count;
+	barrier->count = 0;
+
+	return 0;
+}
+
+static int pthread_barrier_destroy(pthread_barrier_t *barrier)
+{
+	pthread_cond_destroy(&barrier->cond);
+	pthread_mutex_destroy(&barrier->mutex);
+	return 0;
+}
+
+static int pthread_barrier_wait(pthread_barrier_t *barrier)
+{
+	pthread_mutex_lock(&barrier->mutex);
+	++(barrier->count);
+	if(barrier->count >= barrier->trip_count)
+	{
+		barrier->count = 0;
+		pthread_cond_broadcast(&barrier->cond);
+		pthread_mutex_unlock(&barrier->mutex);
+		return 1;
+	}
+	else
+	{
+		pthread_cond_wait(&barrier->cond, &(barrier->mutex));
+		pthread_mutex_unlock(&barrier->mutex);
+		return 0;
+	}
+}
+
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef DEBUG_PRINTF
+#define LOG(...) fprintf(stderr, __VA_ARGS__)
+#else
+#define LOG(...) do {} while (0)
+#endif
+
+#ifndef __FreeBSD__
+#define DETACH_KERNEL_DRIVER
+#endif
+
+/* Uncomment to enable the retrieval of Usage and Usage Page in
+hid_enumerate(). Warning, on platforms different from FreeBSD
+this is very invasive as it requires the detach
+and re-attach of the kernel driver. See comments inside hid_enumerate().
+libusb HIDAPI programs are encouraged to use the interface number
+instead to differentiate between interfaces on a composite HID device. */
+/*#define INVASIVE_GET_USAGE*/
+
+/* Linked List of input reports received from the device. */
+struct input_report {
+	uint8_t *data;
+	size_t len;
+	struct input_report *next;
+};
+
+
+struct hid_device_ {
+	/* Handle to the actual device. */
+	libusb_device_handle *device_handle;
+
+	/* Endpoint information */
+	int input_endpoint;
+	int output_endpoint;
+	int input_ep_max_packet_size;
+
+	/* The interface number of the HID */
+	int interface;
+
+	/* Indexes of Strings */
+	int manufacturer_index;
+	int product_index;
+	int serial_index;
+
+	/* Whether blocking reads are used */
+	int blocking; /* boolean */
+
+	/* Read thread objects */
+	pthread_t thread;
+	pthread_mutex_t mutex; /* Protects input_reports */
+	pthread_cond_t condition;
+	pthread_barrier_t barrier; /* Ensures correct startup sequence */
+	int shutdown_thread;
+	int cancelled;
+	struct libusb_transfer *transfer;
+
+	/* List of received input reports. */
+	struct input_report *input_reports;
+};
+
+static libusb_context *usb_context = NULL;
+
+uint16_t get_usb_code_for_current_locale(void);
+static int return_data(hid_device *dev, unsigned char *data, size_t length);
+
+static hid_device *new_hid_device(void)
+{
+	hid_device *dev = calloc(1, sizeof(hid_device));
+	dev->blocking = 1;
+
+	pthread_mutex_init(&dev->mutex, NULL);
+	pthread_cond_init(&dev->condition, NULL);
+	pthread_barrier_init(&dev->barrier, NULL, 2);
+
+	return dev;
+}
+
+static void free_hid_device(hid_device *dev)
+{
+	/* Clean up the thread objects */
+	pthread_barrier_destroy(&dev->barrier);
+	pthread_cond_destroy(&dev->condition);
+	pthread_mutex_destroy(&dev->mutex);
+
+	/* Free the device itself */
+	free(dev);
+}
+
+#if 0
+/*TODO: Implement this funciton on hidapi/libusb.. */
+static void register_error(hid_device *device, const char *op)
+{
+
+}
+#endif
+
+#ifdef INVASIVE_GET_USAGE
+/* Get bytes from a HID Report Descriptor.
+   Only call with a num_bytes of 0, 1, 2, or 4. */
+static uint32_t get_bytes(uint8_t *rpt, size_t len, size_t num_bytes, size_t cur)
+{
+	/* Return if there aren't enough bytes. */
+	if (cur + num_bytes >= len)
+		return 0;
+
+	if (num_bytes == 0)
+		return 0;
+	else if (num_bytes == 1) {
+		return rpt[cur+1];
+	}
+	else if (num_bytes == 2) {
+		return (rpt[cur+2] * 256 + rpt[cur+1]);
+	}
+	else if (num_bytes == 4) {
+		return (rpt[cur+4] * 0x01000000 +
+		        rpt[cur+3] * 0x00010000 +
+		        rpt[cur+2] * 0x00000100 +
+		        rpt[cur+1] * 0x00000001);
+	}
+	else
+		return 0;
+}
+
+/* Retrieves the device's Usage Page and Usage from the report
+   descriptor. The algorithm is simple, as it just returns the first
+   Usage and Usage Page that it finds in the descriptor.
+   The return value is 0 on success and -1 on failure. */
+static int get_usage(uint8_t *report_descriptor, size_t size,
+                     unsigned short *usage_page, unsigned short *usage)
+{
+	unsigned int i = 0;
+	int size_code;
+	int data_len, key_size;
+	int usage_found = 0, usage_page_found = 0;
+
+	while (i < size) {
+		int key = report_descriptor[i];
+		int key_cmd = key & 0xfc;
+
+		//printf("key: %02hhx\n", key);
+
+		if ((key & 0xf0) == 0xf0) {
+			/* This is a Long Item. The next byte contains the
+			   length of the data section (value) for this key.
+			   See the HID specification, version 1.11, section
+			   6.2.2.3, titled "Long Items." */
+			if (i+1 < size)
+				data_len = report_descriptor[i+1];
+			else
+				data_len = 0; /* malformed report */
+			key_size = 3;
+		}
+		else {
+			/* This is a Short Item. The bottom two bits of the
+			   key contain the size code for the data section
+			   (value) for this key.  Refer to the HID
+			   specification, version 1.11, section 6.2.2.2,
+			   titled "Short Items." */
+			size_code = key & 0x3;
+			switch (size_code) {
+			case 0:
+			case 1:
+			case 2:
+				data_len = size_code;
+				break;
+			case 3:
+				data_len = 4;
+				break;
+			default:
+				/* Can't ever happen since size_code is & 0x3 */
+				data_len = 0;
+				break;
+			};
+			key_size = 1;
+		}
+
+		if (key_cmd == 0x4) {
+			*usage_page  = get_bytes(report_descriptor, size, data_len, i);
+			usage_page_found = 1;
+			//printf("Usage Page: %x\n", (uint32_t)*usage_page);
+		}
+		if (key_cmd == 0x8) {
+			*usage = get_bytes(report_descriptor, size, data_len, i);
+			usage_found = 1;
+			//printf("Usage: %x\n", (uint32_t)*usage);
+		}
+
+		if (usage_page_found && usage_found)
+			return 0; /* success */
+
+		/* Skip over this key and it's associated data */
+		i += data_len + key_size;
+	}
+
+	return -1; /* failure */
+}
+#endif /* INVASIVE_GET_USAGE */
+
+#if defined(__FreeBSD__) && __FreeBSD__ < 10
+/* The libusb version included in FreeBSD < 10 doesn't have this function. In
+   mainline libusb, it's inlined in libusb.h. This function will bear a striking
+   resemblance to that one, because there's about one way to code it.
+
+   Note that the data parameter is Unicode in UTF-16LE encoding.
+   Return value is the number of bytes in data, or LIBUSB_ERROR_*.
+ */
+static inline int libusb_get_string_descriptor(libusb_device_handle *dev,
+	uint8_t descriptor_index, uint16_t lang_id,
+	unsigned char *data, int length)
+{
+	return libusb_control_transfer(dev,
+		LIBUSB_ENDPOINT_IN | 0x0, /* Endpoint 0 IN */
+		LIBUSB_REQUEST_GET_DESCRIPTOR,
+		(LIBUSB_DT_STRING << 8) | descriptor_index,
+		lang_id, data, (uint16_t) length, 1000);
+}
+
+#endif
+
+
+/* Get the first language the device says it reports. This comes from
+   USB string #0. */
+static uint16_t get_first_language(libusb_device_handle *dev)
+{
+	uint16_t buf[32];
+	int len;
+
+	/* Get the string from libusb. */
+	len = libusb_get_string_descriptor(dev,
+			0x0, /* String ID */
+			0x0, /* Language */
+			(unsigned char*)buf,
+			sizeof(buf));
+	if (len < 4)
+		return 0x0;
+
+	return buf[1]; /* First two bytes are len and descriptor type. */
+}
+
+static int is_language_supported(libusb_device_handle *dev, uint16_t lang)
+{
+	uint16_t buf[32];
+	int len;
+	int i;
+
+	/* Get the string from libusb. */
+	len = libusb_get_string_descriptor(dev,
+			0x0, /* String ID */
+			0x0, /* Language */
+			(unsigned char*)buf,
+			sizeof(buf));
+	if (len < 4)
+		return 0x0;
+
+
+	len /= 2; /* language IDs are two-bytes each. */
+	/* Start at index 1 because there are two bytes of protocol data. */
+	for (i = 1; i < len; i++) {
+		if (buf[i] == lang)
+			return 1;
+	}
+
+	return 0;
+}
+
+
+/* This function returns a newly allocated wide string containing the USB
+   device string numbered by the index. The returned string must be freed
+   by using free(). */
+static wchar_t *get_usb_string(libusb_device_handle *dev, uint8_t idx)
+{
+	char buf[512];
+	int len;
+	wchar_t *str = NULL;
+
+#ifndef __ANDROID__ /* we don't use iconv on Android */
+	wchar_t wbuf[256];
+	/* iconv variables */
+	iconv_t ic;
+	size_t inbytes;
+	size_t outbytes;
+	size_t res;
+	char *inptr;
+	char *outptr;
+#endif
+
+	/* Determine which language to use. */
+	uint16_t lang;
+	lang = get_usb_code_for_current_locale();
+	if (!is_language_supported(dev, lang))
+		lang = get_first_language(dev);
+
+	/* Get the string from libusb. */
+	len = libusb_get_string_descriptor(dev,
+			idx,
+			lang,
+			(unsigned char*)buf,
+			sizeof(buf));
+	if (len < 0)
+		return NULL;
+
+#ifdef __ANDROID__
+
+	/* Bionic does not have iconv support nor wcsdup() function, so it
+	   has to be done manually.  The following code will only work for
+	   code points that can be represented as a single UTF-16 character,
+	   and will incorrectly convert any code points which require more
+	   than one UTF-16 character.
+
+	   Skip over the first character (2-bytes).  */
+	len -= 2;
+	str = malloc((len / 2 + 1) * sizeof(wchar_t));
+	int i;
+	for (i = 0; i < len / 2; i++) {
+		str[i] = buf[i * 2 + 2] | (buf[i * 2 + 3] << 8);
+	}
+	str[len / 2] = 0x00000000;
+
+#else
+
+	/* buf does not need to be explicitly NULL-terminated because
+	   it is only passed into iconv() which does not need it. */
+
+	/* Initialize iconv. */
+	ic = iconv_open("WCHAR_T", "UTF-16LE");
+	if (ic == (iconv_t)-1) {
+		LOG("iconv_open() failed\n");
+		return NULL;
+	}
+
+	/* Convert to native wchar_t (UTF-32 on glibc/BSD systems).
+	   Skip the first character (2-bytes). */
+	inptr = buf+2;
+	inbytes = len-2;
+	outptr = (char*) wbuf;
+	outbytes = sizeof(wbuf);
+	res = iconv(ic, &inptr, &inbytes, &outptr, &outbytes);
+	if (res == (size_t)-1) {
+		LOG("iconv() failed\n");
+		goto err;
+	}
+
+	/* Write the terminating NULL. */
+	wbuf[sizeof(wbuf)/sizeof(wbuf[0])-1] = 0x00000000;
+	if (outbytes >= sizeof(wbuf[0]))
+		*((wchar_t*)outptr) = 0x00000000;
+
+	/* Allocate and copy the string. */
+	str = wcsdup(wbuf);
+
+err:
+	iconv_close(ic);
+
+#endif
+
+	return str;
+}
+
+static char *make_path(libusb_device *dev, int interface_number)
+{
+	char str[64];
+	snprintf(str, sizeof(str), "%04x:%04x:%02x",
+		libusb_get_bus_number(dev),
+		libusb_get_device_address(dev),
+		interface_number);
+	str[sizeof(str)-1] = '\0';
+
+	return strdup(str);
+}
+
+
+int HID_API_EXPORT hid_init(void)
+{
+	if (!usb_context) {
+		const char *locale;
+
+		/* Init Libusb */
+		if (libusb_init(&usb_context))
+			return -1;
+
+		/* Set the locale if it's not set. */
+		locale = setlocale(LC_CTYPE, NULL);
+		if (!locale)
+			setlocale(LC_CTYPE, "");
+	}
+
+	return 0;
+}
+
+int HID_API_EXPORT hid_exit(void)
+{
+	if (usb_context) {
+		libusb_exit(usb_context);
+		usb_context = NULL;
+	}
+
+	return 0;
+}
+
+struct hid_device_info  HID_API_EXPORT *hid_enumerate(unsigned short vendor_id, unsigned short product_id)
+{
+	libusb_device **devs;
+	libusb_device *dev;
+	libusb_device_handle *handle;
+	ssize_t num_devs;
+	int i = 0;
+
+	struct hid_device_info *root = NULL; /* return object */
+	struct hid_device_info *cur_dev = NULL;
+
+	if(hid_init() < 0)
+		return NULL;
+
+	num_devs = libusb_get_device_list(usb_context, &devs);
+	if (num_devs < 0)
+		return NULL;
+	while ((dev = devs[i++]) != NULL) {
+		struct libusb_device_descriptor desc;
+		struct libusb_config_descriptor *conf_desc = NULL;
+		int j, k;
+		int interface_num = 0;
+
+		int res = libusb_get_device_descriptor(dev, &desc);
+		unsigned short dev_vid = desc.idVendor;
+		unsigned short dev_pid = desc.idProduct;
+
+		res = libusb_get_active_config_descriptor(dev, &conf_desc);
+		if (res < 0)
+			libusb_get_config_descriptor(dev, 0, &conf_desc);
+		if (conf_desc) {
+			for (j = 0; j < conf_desc->bNumInterfaces; j++) {
+				const struct libusb_interface *intf = &conf_desc->interface[j];
+				for (k = 0; k < intf->num_altsetting; k++) {
+					const struct libusb_interface_descriptor *intf_desc;
+					intf_desc = &intf->altsetting[k];
+					if (intf_desc->bInterfaceClass == LIBUSB_CLASS_HID) {
+						interface_num = intf_desc->bInterfaceNumber;
+
+						/* Check the VID/PID against the arguments */
+						if ((vendor_id == 0x0 || vendor_id == dev_vid) &&
+						    (product_id == 0x0 || product_id == dev_pid)) {
+							struct hid_device_info *tmp;
+
+							/* VID/PID match. Create the record. */
+							tmp = calloc(1, sizeof(struct hid_device_info));
+							if (cur_dev) {
+								cur_dev->next = tmp;
+							}
+							else {
+								root = tmp;
+							}
+							cur_dev = tmp;
+
+							/* Fill out the record */
+							cur_dev->next = NULL;
+							cur_dev->path = make_path(dev, interface_num);
+
+							res = libusb_open(dev, &handle);
+
+							if (res >= 0) {
+								/* Serial Number */
+								if (desc.iSerialNumber > 0)
+									cur_dev->serial_number =
+										get_usb_string(handle, desc.iSerialNumber);
+
+								/* Manufacturer and Product strings */
+								if (desc.iManufacturer > 0)
+									cur_dev->manufacturer_string =
+										get_usb_string(handle, desc.iManufacturer);
+								if (desc.iProduct > 0)
+									cur_dev->product_string =
+										get_usb_string(handle, desc.iProduct);
+
+#ifdef INVASIVE_GET_USAGE
+{
+							/*
+							This section is removed because it is too
+							invasive on the system. Getting a Usage Page
+							and Usage requires parsing the HID Report
+							descriptor. Getting a HID Report descriptor
+							involves claiming the interface. Claiming the
+							interface involves detaching the kernel driver.
+							Detaching the kernel driver is hard on the system
+							because it will unclaim interfaces (if another
+							app has them claimed) and the re-attachment of
+							the driver will sometimes change /dev entry names.
+							It is for these reasons that this section is
+							#if 0. For composite devices, use the interface
+							field in the hid_device_info struct to distinguish
+							between interfaces. */
+								unsigned char data[256];
+#ifdef DETACH_KERNEL_DRIVER
+								int detached = 0;
+								/* Usage Page and Usage */
+								res = libusb_kernel_driver_active(handle, interface_num);
+								if (res == 1) {
+									res = libusb_detach_kernel_driver(handle, interface_num);
+									if (res < 0)
+										LOG("Couldn't detach kernel driver, even though a kernel driver was attached.");
+									else
+										detached = 1;
+								}
+#endif
+								res = libusb_claim_interface(handle, interface_num);
+								if (res >= 0) {
+									/* Get the HID Report Descriptor. */
+									res = libusb_control_transfer(handle, LIBUSB_ENDPOINT_IN|LIBUSB_RECIPIENT_INTERFACE, LIBUSB_REQUEST_GET_DESCRIPTOR, (LIBUSB_DT_REPORT << 8)|interface_num, 0, data, sizeof(data), 5000);
+									if (res >= 0) {
+										unsigned short page=0, usage=0;
+										/* Parse the usage and usage page
+										   out of the report descriptor. */
+										get_usage(data, res,  &page, &usage);
+										cur_dev->usage_page = page;
+										cur_dev->usage = usage;
+									}
+									else
+										LOG("libusb_control_transfer() for getting the HID report failed with %d\n", res);
+
+									/* Release the interface */
+									res = libusb_release_interface(handle, interface_num);
+									if (res < 0)
+										LOG("Can't release the interface.\n");
+								}
+								else
+									LOG("Can't claim interface %d\n", res);
+#ifdef DETACH_KERNEL_DRIVER
+								/* Re-attach kernel driver if necessary. */
+								if (detached) {
+									res = libusb_attach_kernel_driver(handle, interface_num);
+									if (res < 0)
+										LOG("Couldn't re-attach kernel driver.\n");
+								}
+#endif
+}
+#endif /* INVASIVE_GET_USAGE */
+
+								libusb_close(handle);
+							}
+							/* VID/PID */
+							cur_dev->vendor_id = dev_vid;
+							cur_dev->product_id = dev_pid;
+
+							/* Release Number */
+							cur_dev->release_number = desc.bcdDevice;
+
+							/* Interface Number */
+							cur_dev->interface_number = interface_num;
+						}
+					}
+				} /* altsettings */
+			} /* interfaces */
+			libusb_free_config_descriptor(conf_desc);
+		}
+	}
+
+	libusb_free_device_list(devs, 1);
+
+	return root;
+}
+
+void  HID_API_EXPORT hid_free_enumeration(struct hid_device_info *devs)
+{
+	struct hid_device_info *d = devs;
+	while (d) {
+		struct hid_device_info *next = d->next;
+		free(d->path);
+		free(d->serial_number);
+		free(d->manufacturer_string);
+		free(d->product_string);
+		free(d);
+		d = next;
+	}
+}
+
+hid_device * hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number)
+{
+	struct hid_device_info *devs, *cur_dev;
+	const char *path_to_open = NULL;
+	hid_device *handle = NULL;
+
+	devs = hid_enumerate(vendor_id, product_id);
+	cur_dev = devs;
+	while (cur_dev) {
+		if (cur_dev->vendor_id == vendor_id &&
+		    cur_dev->product_id == product_id) {
+			if (serial_number) {
+				if (cur_dev->serial_number &&
+				    wcscmp(serial_number, cur_dev->serial_number) == 0) {
+					path_to_open = cur_dev->path;
+					break;
+				}
+			}
+			else {
+				path_to_open = cur_dev->path;
+				break;
+			}
+		}
+		cur_dev = cur_dev->next;
+	}
+
+	if (path_to_open) {
+		/* Open the device */
+		handle = hid_open_path(path_to_open);
+	}
+
+	hid_free_enumeration(devs);
+
+	return handle;
+}
+
+static void read_callback(struct libusb_transfer *transfer)
+{
+	hid_device *dev = transfer->user_data;
+	int res;
+
+	if (transfer->status == LIBUSB_TRANSFER_COMPLETED) {
+
+		struct input_report *rpt = malloc(sizeof(*rpt));
+		rpt->data = malloc(transfer->actual_length);
+		memcpy(rpt->data, transfer->buffer, transfer->actual_length);
+		rpt->len = transfer->actual_length;
+		rpt->next = NULL;
+
+		pthread_mutex_lock(&dev->mutex);
+
+		/* Attach the new report object to the end of the list. */
+		if (dev->input_reports == NULL) {
+			/* The list is empty. Put it at the root. */
+			dev->input_reports = rpt;
+			pthread_cond_signal(&dev->condition);
+		}
+		else {
+			/* Find the end of the list and attach. */
+			struct input_report *cur = dev->input_reports;
+			int num_queued = 0;
+			while (cur->next != NULL) {
+				cur = cur->next;
+				num_queued++;
+			}
+			cur->next = rpt;
+
+			/* Pop one off if we've reached 30 in the queue. This
+			   way we don't grow forever if the user never reads
+			   anything from the device. */
+			if (num_queued > 30) {
+				return_data(dev, NULL, 0);
+			}
+		}
+		pthread_mutex_unlock(&dev->mutex);
+	}
+	else if (transfer->status == LIBUSB_TRANSFER_CANCELLED) {
+		dev->shutdown_thread = 1;
+		dev->cancelled = 1;
+		return;
+	}
+	else if (transfer->status == LIBUSB_TRANSFER_NO_DEVICE) {
+		dev->shutdown_thread = 1;
+		dev->cancelled = 1;
+		return;
+	}
+	else if (transfer->status == LIBUSB_TRANSFER_TIMED_OUT) {
+		//LOG("Timeout (normal)\n");
+	}
+	else {
+		LOG("Unknown transfer code: %d\n", transfer->status);
+	}
+
+	/* Re-submit the transfer object. */
+	res = libusb_submit_transfer(transfer);
+	if (res != 0) {
+		LOG("Unable to submit URB. libusb error code: %d\n", res);
+		dev->shutdown_thread = 1;
+		dev->cancelled = 1;
+	}
+}
+
+
+static void *read_thread(void *param)
+{
+	hid_device *dev = param;
+	unsigned char *buf;
+	const size_t length = dev->input_ep_max_packet_size;
+
+	/* Set up the transfer object. */
+	buf = malloc(length);
+	dev->transfer = libusb_alloc_transfer(0);
+	libusb_fill_interrupt_transfer(dev->transfer,
+		dev->device_handle,
+		dev->input_endpoint,
+		buf,
+		length,
+		read_callback,
+		dev,
+		5000/*timeout*/);
+
+	/* Make the first submission. Further submissions are made
+	   from inside read_callback() */
+	libusb_submit_transfer(dev->transfer);
+
+	/* Notify the main thread that the read thread is up and running. */
+	pthread_barrier_wait(&dev->barrier);
+
+	/* Handle all the events. */
+	while (!dev->shutdown_thread) {
+		int res;
+		res = libusb_handle_events(usb_context);
+		if (res < 0) {
+			/* There was an error. */
+			LOG("read_thread(): libusb reports error # %d\n", res);
+
+			/* Break out of this loop only on fatal error.*/
+			if (res != LIBUSB_ERROR_BUSY &&
+			    res != LIBUSB_ERROR_TIMEOUT &&
+			    res != LIBUSB_ERROR_OVERFLOW &&
+			    res != LIBUSB_ERROR_INTERRUPTED) {
+				break;
+			}
+		}
+	}
+
+	/* Cancel any transfer that may be pending. This call will fail
+	   if no transfers are pending, but that's OK. */
+	libusb_cancel_transfer(dev->transfer);
+
+	while (!dev->cancelled)
+		libusb_handle_events_completed(usb_context, &dev->cancelled);
+
+	/* Now that the read thread is stopping, Wake any threads which are
+	   waiting on data (in hid_read_timeout()). Do this under a mutex to
+	   make sure that a thread which is about to go to sleep waiting on
+	   the condition actually will go to sleep before the condition is
+	   signaled. */
+	pthread_mutex_lock(&dev->mutex);
+	pthread_cond_broadcast(&dev->condition);
+	pthread_mutex_unlock(&dev->mutex);
+
+	/* The dev->transfer->buffer and dev->transfer objects are cleaned up
+	   in hid_close(). They are not cleaned up here because this thread
+	   could end either due to a disconnect or due to a user
+	   call to hid_close(). In both cases the objects can be safely
+	   cleaned up after the call to pthread_join() (in hid_close()), but
+	   since hid_close() calls libusb_cancel_transfer(), on these objects,
+	   they can not be cleaned up here. */
+
+	return NULL;
+}
+
+
+hid_device * HID_API_EXPORT hid_open_path(const char *path)
+{
+	hid_device *dev = NULL;
+
+	libusb_device **devs;
+	libusb_device *usb_dev;
+	int res;
+	int d = 0;
+	int good_open = 0;
+
+	if(hid_init() < 0)
+		return NULL;
+
+	dev = new_hid_device();
+
+	libusb_get_device_list(usb_context, &devs);
+	while ((usb_dev = devs[d++]) != NULL) {
+		struct libusb_device_descriptor desc;
+		struct libusb_config_descriptor *conf_desc = NULL;
+		int i,j,k;
+		libusb_get_device_descriptor(usb_dev, &desc);
+
+		if (libusb_get_active_config_descriptor(usb_dev, &conf_desc) < 0)
+			continue;
+		for (j = 0; j < conf_desc->bNumInterfaces; j++) {
+			const struct libusb_interface *intf = &conf_desc->interface[j];
+			for (k = 0; k < intf->num_altsetting; k++) {
+				const struct libusb_interface_descriptor *intf_desc;
+				intf_desc = &intf->altsetting[k];
+				if (intf_desc->bInterfaceClass == LIBUSB_CLASS_HID) {
+					char *dev_path = make_path(usb_dev, intf_desc->bInterfaceNumber);
+					if (!strcmp(dev_path, path)) {
+						/* Matched Paths. Open this device */
+
+						/* OPEN HERE */
+						res = libusb_open(usb_dev, &dev->device_handle);
+						if (res < 0) {
+							LOG("can't open device\n");
+							free(dev_path);
+							break;
+						}
+						good_open = 1;
+#ifdef DETACH_KERNEL_DRIVER
+						/* Detach the kernel driver, but only if the
+						   device is managed by the kernel */
+						if (libusb_kernel_driver_active(dev->device_handle, intf_desc->bInterfaceNumber) == 1) {
+							res = libusb_detach_kernel_driver(dev->device_handle, intf_desc->bInterfaceNumber);
+							if (res < 0) {
+								libusb_close(dev->device_handle);
+								LOG("Unable to detach Kernel Driver\n");
+								free(dev_path);
+								good_open = 0;
+								break;
+							}
+						}
+#endif
+						res = libusb_claim_interface(dev->device_handle, intf_desc->bInterfaceNumber);
+						if (res < 0) {
+							LOG("can't claim interface %d: %d\n", intf_desc->bInterfaceNumber, res);
+							free(dev_path);
+							libusb_close(dev->device_handle);
+							good_open = 0;
+							break;
+						}
+
+						/* Store off the string descriptor indexes */
+						dev->manufacturer_index = desc.iManufacturer;
+						dev->product_index      = desc.iProduct;
+						dev->serial_index       = desc.iSerialNumber;
+
+						/* Store off the interface number */
+						dev->interface = intf_desc->bInterfaceNumber;
+
+						/* Find the INPUT and OUTPUT endpoints. An
+						   OUTPUT endpoint is not required. */
+						for (i = 0; i < intf_desc->bNumEndpoints; i++) {
+							const struct libusb_endpoint_descriptor *ep
+								= &intf_desc->endpoint[i];
+
+							/* Determine the type and direction of this
+							   endpoint. */
+							int is_interrupt =
+								(ep->bmAttributes & LIBUSB_TRANSFER_TYPE_MASK)
+							      == LIBUSB_TRANSFER_TYPE_INTERRUPT;
+							int is_output =
+								(ep->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK)
+							      == LIBUSB_ENDPOINT_OUT;
+							int is_input =
+								(ep->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK)
+							      == LIBUSB_ENDPOINT_IN;
+
+							/* Decide whether to use it for input or output. */
+							if (dev->input_endpoint == 0 &&
+							    is_interrupt && is_input) {
+								/* Use this endpoint for INPUT */
+								dev->input_endpoint = ep->bEndpointAddress;
+								dev->input_ep_max_packet_size = ep->wMaxPacketSize;
+							}
+							if (dev->output_endpoint == 0 &&
+							    is_interrupt && is_output) {
+								/* Use this endpoint for OUTPUT */
+								dev->output_endpoint = ep->bEndpointAddress;
+							}
+						}
+
+						pthread_create(&dev->thread, NULL, read_thread, dev);
+
+						/* Wait here for the read thread to be initialized. */
+						pthread_barrier_wait(&dev->barrier);
+
+					}
+					free(dev_path);
+				}
+			}
+		}
+		libusb_free_config_descriptor(conf_desc);
+
+	}
+
+	libusb_free_device_list(devs, 1);
+
+	/* If we have a good handle, return it. */
+	if (good_open) {
+		return dev;
+	}
+	else {
+		/* Unable to open any devices. */
+		free_hid_device(dev);
+		return NULL;
+	}
+}
+
+
+int HID_API_EXPORT hid_write(hid_device *dev, const unsigned char *data, size_t length)
+{
+	int res;
+	int report_number = data[0];
+	int skipped_report_id = 0;
+
+	if (report_number == 0x0) {
+		data++;
+		length--;
+		skipped_report_id = 1;
+	}
+
+
+	if (dev->output_endpoint <= 0) {
+		/* No interrupt out endpoint. Use the Control Endpoint */
+		res = libusb_control_transfer(dev->device_handle,
+			LIBUSB_REQUEST_TYPE_CLASS|LIBUSB_RECIPIENT_INTERFACE|LIBUSB_ENDPOINT_OUT,
+			0x09/*HID Set_Report*/,
+			(2/*HID output*/ << 8) | report_number,
+			dev->interface,
+			(unsigned char *)data, length,
+			1000/*timeout millis*/);
+
+		if (res < 0)
+			return -1;
+
+		if (skipped_report_id)
+			length++;
+
+		return length;
+	}
+	else {
+		/* Use the interrupt out endpoint */
+		int actual_length;
+		res = libusb_interrupt_transfer(dev->device_handle,
+			dev->output_endpoint,
+			(unsigned char*)data,
+			length,
+			&actual_length, 1000);
+
+		if (res < 0)
+			return -1;
+
+		if (skipped_report_id)
+			actual_length++;
+
+		return actual_length;
+	}
+}
+
+/* Helper function, to simplify hid_read().
+   This should be called with dev->mutex locked. */
+static int return_data(hid_device *dev, unsigned char *data, size_t length)
+{
+	/* Copy the data out of the linked list item (rpt) into the
+	   return buffer (data), and delete the liked list item. */
+	struct input_report *rpt = dev->input_reports;
+	size_t len = (length < rpt->len)? length: rpt->len;
+	if (len > 0)
+		memcpy(data, rpt->data, len);
+	dev->input_reports = rpt->next;
+	free(rpt->data);
+	free(rpt);
+	return len;
+}
+
+static void cleanup_mutex(void *param)
+{
+	hid_device *dev = param;
+	pthread_mutex_unlock(&dev->mutex);
+}
+
+
+int HID_API_EXPORT hid_read_timeout(hid_device *dev, unsigned char *data, size_t length, int milliseconds)
+{
+	int bytes_read = -1;
+
+#if 0
+	int transferred;
+	int res = libusb_interrupt_transfer(dev->device_handle, dev->input_endpoint, data, length, &transferred, 5000);
+	LOG("transferred: %d\n", transferred);
+	return transferred;
+#endif
+
+	pthread_mutex_lock(&dev->mutex);
+	pthread_cleanup_push(&cleanup_mutex, dev);
+
+	/* There's an input report queued up. Return it. */
+	if (dev->input_reports) {
+		/* Return the first one */
+		bytes_read = return_data(dev, data, length);
+		goto ret;
+	}
+
+	if (dev->shutdown_thread) {
+		/* This means the device has been disconnected.
+		   An error code of -1 should be returned. */
+		bytes_read = -1;
+		goto ret;
+	}
+
+	if (milliseconds == -1) {
+		/* Blocking */
+		while (!dev->input_reports && !dev->shutdown_thread) {
+			pthread_cond_wait(&dev->condition, &dev->mutex);
+		}
+		if (dev->input_reports) {
+			bytes_read = return_data(dev, data, length);
+		}
+	}
+	else if (milliseconds > 0) {
+		/* Non-blocking, but called with timeout. */
+		int res;
+		struct timespec ts;
+		clock_gettime(CLOCK_REALTIME, &ts);
+		ts.tv_sec += milliseconds / 1000;
+		ts.tv_nsec += (milliseconds % 1000) * 1000000;
+		if (ts.tv_nsec >= 1000000000L) {
+			ts.tv_sec++;
+			ts.tv_nsec -= 1000000000L;
+		}
+
+		while (!dev->input_reports && !dev->shutdown_thread) {
+			res = pthread_cond_timedwait(&dev->condition, &dev->mutex, &ts);
+			if (res == 0) {
+				if (dev->input_reports) {
+					bytes_read = return_data(dev, data, length);
+					break;
+				}
+
+				/* If we're here, there was a spurious wake up
+				   or the read thread was shutdown. Run the
+				   loop again (ie: don't break). */
+			}
+			else if (res == ETIMEDOUT) {
+				/* Timed out. */
+				bytes_read = 0;
+				break;
+			}
+			else {
+				/* Error. */
+				bytes_read = -1;
+				break;
+			}
+		}
+	}
+	else {
+		/* Purely non-blocking */
+		bytes_read = 0;
+	}
+
+ret:
+	pthread_mutex_unlock(&dev->mutex);
+	pthread_cleanup_pop(0);
+
+	return bytes_read;
+}
+
+int HID_API_EXPORT hid_read(hid_device *dev, unsigned char *data, size_t length)
+{
+	return hid_read_timeout(dev, data, length, dev->blocking ? -1 : 0);
+}
+
+int HID_API_EXPORT hid_set_nonblocking(hid_device *dev, int nonblock)
+{
+	dev->blocking = !nonblock;
+
+	return 0;
+}
+
+
+int HID_API_EXPORT hid_send_feature_report(hid_device *dev, const unsigned char *data, size_t length)
+{
+	int res = -1;
+	int skipped_report_id = 0;
+	int report_number = data[0];
+
+	if (report_number == 0x0) {
+		data++;
+		length--;
+		skipped_report_id = 1;
+	}
+
+	res = libusb_control_transfer(dev->device_handle,
+		LIBUSB_REQUEST_TYPE_CLASS|LIBUSB_RECIPIENT_INTERFACE|LIBUSB_ENDPOINT_OUT,
+		0x09/*HID set_report*/,
+		(3/*HID feature*/ << 8) | report_number,
+		dev->interface,
+		(unsigned char *)data, length,
+		1000/*timeout millis*/);
+
+	if (res < 0)
+		return -1;
+
+	/* Account for the report ID */
+	if (skipped_report_id)
+		length++;
+
+	return length;
+}
+
+int HID_API_EXPORT hid_get_feature_report(hid_device *dev, unsigned char *data, size_t length)
+{
+	int res = -1;
+	int skipped_report_id = 0;
+	int report_number = data[0];
+
+	if (report_number == 0x0) {
+		/* Offset the return buffer by 1, so that the report ID
+		   will remain in byte 0. */
+		data++;
+		length--;
+		skipped_report_id = 1;
+	}
+	res = libusb_control_transfer(dev->device_handle,
+		LIBUSB_REQUEST_TYPE_CLASS|LIBUSB_RECIPIENT_INTERFACE|LIBUSB_ENDPOINT_IN,
+		0x01/*HID get_report*/,
+		(3/*HID feature*/ << 8) | report_number,
+		dev->interface,
+		(unsigned char *)data, length,
+		1000/*timeout millis*/);
+
+	if (res < 0)
+		return -1;
+
+	if (skipped_report_id)
+		res++;
+
+	return res;
+}
+
+
+void HID_API_EXPORT hid_close(hid_device *dev)
+{
+	if (!dev)
+		return;
+
+	/* Cause read_thread() to stop. */
+	dev->shutdown_thread = 1;
+	libusb_cancel_transfer(dev->transfer);
+
+	/* Wait for read_thread() to end. */
+	pthread_join(dev->thread, NULL);
+
+	/* Clean up the Transfer objects allocated in read_thread(). */
+	free(dev->transfer->buffer);
+	libusb_free_transfer(dev->transfer);
+
+	/* release the interface */
+	libusb_release_interface(dev->device_handle, dev->interface);
+
+	/* Close the handle */
+	libusb_close(dev->device_handle);
+
+	/* Clear out the queue of received reports. */
+	pthread_mutex_lock(&dev->mutex);
+	while (dev->input_reports) {
+		return_data(dev, NULL, 0);
+	}
+	pthread_mutex_unlock(&dev->mutex);
+
+	free_hid_device(dev);
+}
+
+
+int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device *dev, wchar_t *string, size_t maxlen)
+{
+	return hid_get_indexed_string(dev, dev->manufacturer_index, string, maxlen);
+}
+
+int HID_API_EXPORT_CALL hid_get_product_string(hid_device *dev, wchar_t *string, size_t maxlen)
+{
+	return hid_get_indexed_string(dev, dev->product_index, string, maxlen);
+}
+
+int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *string, size_t maxlen)
+{
+	return hid_get_indexed_string(dev, dev->serial_index, string, maxlen);
+}
+
+int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen)
+{
+	wchar_t *str;
+
+	str = get_usb_string(dev->device_handle, string_index);
+	if (str) {
+		wcsncpy(string, str, maxlen);
+		string[maxlen-1] = L'\0';
+		free(str);
+		return 0;
+	}
+	else
+		return -1;
+}
+
+
+HID_API_EXPORT const wchar_t * HID_API_CALL  hid_error(hid_device *dev)
+{
+	return NULL;
+}
+
+
+struct lang_map_entry {
+	const char *name;
+	const char *string_code;
+	uint16_t usb_code;
+};
+
+#define LANG(name,code,usb_code) { name, code, usb_code }
+static struct lang_map_entry lang_map[] = {
+	LANG("Afrikaans", "af", 0x0436),
+	LANG("Albanian", "sq", 0x041C),
+	LANG("Arabic - United Arab Emirates", "ar_ae", 0x3801),
+	LANG("Arabic - Bahrain", "ar_bh", 0x3C01),
+	LANG("Arabic - Algeria", "ar_dz", 0x1401),
+	LANG("Arabic - Egypt", "ar_eg", 0x0C01),
+	LANG("Arabic - Iraq", "ar_iq", 0x0801),
+	LANG("Arabic - Jordan", "ar_jo", 0x2C01),
+	LANG("Arabic - Kuwait", "ar_kw", 0x3401),
+	LANG("Arabic - Lebanon", "ar_lb", 0x3001),
+	LANG("Arabic - Libya", "ar_ly", 0x1001),
+	LANG("Arabic - Morocco", "ar_ma", 0x1801),
+	LANG("Arabic - Oman", "ar_om", 0x2001),
+	LANG("Arabic - Qatar", "ar_qa", 0x4001),
+	LANG("Arabic - Saudi Arabia", "ar_sa", 0x0401),
+	LANG("Arabic - Syria", "ar_sy", 0x2801),
+	LANG("Arabic - Tunisia", "ar_tn", 0x1C01),
+	LANG("Arabic - Yemen", "ar_ye", 0x2401),
+	LANG("Armenian", "hy", 0x042B),
+	LANG("Azeri - Latin", "az_az", 0x042C),
+	LANG("Azeri - Cyrillic", "az_az", 0x082C),
+	LANG("Basque", "eu", 0x042D),
+	LANG("Belarusian", "be", 0x0423),
+	LANG("Bulgarian", "bg", 0x0402),
+	LANG("Catalan", "ca", 0x0403),
+	LANG("Chinese - China", "zh_cn", 0x0804),
+	LANG("Chinese - Hong Kong SAR", "zh_hk", 0x0C04),
+	LANG("Chinese - Macau SAR", "zh_mo", 0x1404),
+	LANG("Chinese - Singapore", "zh_sg", 0x1004),
+	LANG("Chinese - Taiwan", "zh_tw", 0x0404),
+	LANG("Croatian", "hr", 0x041A),
+	LANG("Czech", "cs", 0x0405),
+	LANG("Danish", "da", 0x0406),
+	LANG("Dutch - Netherlands", "nl_nl", 0x0413),
+	LANG("Dutch - Belgium", "nl_be", 0x0813),
+	LANG("English - Australia", "en_au", 0x0C09),
+	LANG("English - Belize", "en_bz", 0x2809),
+	LANG("English - Canada", "en_ca", 0x1009),
+	LANG("English - Caribbean", "en_cb", 0x2409),
+	LANG("English - Ireland", "en_ie", 0x1809),
+	LANG("English - Jamaica", "en_jm", 0x2009),
+	LANG("English - New Zealand", "en_nz", 0x1409),
+	LANG("English - Phillippines", "en_ph", 0x3409),
+	LANG("English - Southern Africa", "en_za", 0x1C09),
+	LANG("English - Trinidad", "en_tt", 0x2C09),
+	LANG("English - Great Britain", "en_gb", 0x0809),
+	LANG("English - United States", "en_us", 0x0409),
+	LANG("Estonian", "et", 0x0425),
+	LANG("Farsi", "fa", 0x0429),
+	LANG("Finnish", "fi", 0x040B),
+	LANG("Faroese", "fo", 0x0438),
+	LANG("French - France", "fr_fr", 0x040C),
+	LANG("French - Belgium", "fr_be", 0x080C),
+	LANG("French - Canada", "fr_ca", 0x0C0C),
+	LANG("French - Luxembourg", "fr_lu", 0x140C),
+	LANG("French - Switzerland", "fr_ch", 0x100C),
+	LANG("Gaelic - Ireland", "gd_ie", 0x083C),
+	LANG("Gaelic - Scotland", "gd", 0x043C),
+	LANG("German - Germany", "de_de", 0x0407),
+	LANG("German - Austria", "de_at", 0x0C07),
+	LANG("German - Liechtenstein", "de_li", 0x1407),
+	LANG("German - Luxembourg", "de_lu", 0x1007),
+	LANG("German - Switzerland", "de_ch", 0x0807),
+	LANG("Greek", "el", 0x0408),
+	LANG("Hebrew", "he", 0x040D),
+	LANG("Hindi", "hi", 0x0439),
+	LANG("Hungarian", "hu", 0x040E),
+	LANG("Icelandic", "is", 0x040F),
+	LANG("Indonesian", "id", 0x0421),
+	LANG("Italian - Italy", "it_it", 0x0410),
+	LANG("Italian - Switzerland", "it_ch", 0x0810),
+	LANG("Japanese", "ja", 0x0411),
+	LANG("Korean", "ko", 0x0412),
+	LANG("Latvian", "lv", 0x0426),
+	LANG("Lithuanian", "lt", 0x0427),
+	LANG("F.Y.R.O. Macedonia", "mk", 0x042F),
+	LANG("Malay - Malaysia", "ms_my", 0x043E),
+	LANG("Malay – Brunei", "ms_bn", 0x083E),
+	LANG("Maltese", "mt", 0x043A),
+	LANG("Marathi", "mr", 0x044E),
+	LANG("Norwegian - Bokml", "no_no", 0x0414),
+	LANG("Norwegian - Nynorsk", "no_no", 0x0814),
+	LANG("Polish", "pl", 0x0415),
+	LANG("Portuguese - Portugal", "pt_pt", 0x0816),
+	LANG("Portuguese - Brazil", "pt_br", 0x0416),
+	LANG("Raeto-Romance", "rm", 0x0417),
+	LANG("Romanian - Romania", "ro", 0x0418),
+	LANG("Romanian - Republic of Moldova", "ro_mo", 0x0818),
+	LANG("Russian", "ru", 0x0419),
+	LANG("Russian - Republic of Moldova", "ru_mo", 0x0819),
+	LANG("Sanskrit", "sa", 0x044F),
+	LANG("Serbian - Cyrillic", "sr_sp", 0x0C1A),
+	LANG("Serbian - Latin", "sr_sp", 0x081A),
+	LANG("Setsuana", "tn", 0x0432),
+	LANG("Slovenian", "sl", 0x0424),
+	LANG("Slovak", "sk", 0x041B),
+	LANG("Sorbian", "sb", 0x042E),
+	LANG("Spanish - Spain (Traditional)", "es_es", 0x040A),
+	LANG("Spanish - Argentina", "es_ar", 0x2C0A),
+	LANG("Spanish - Bolivia", "es_bo", 0x400A),
+	LANG("Spanish - Chile", "es_cl", 0x340A),
+	LANG("Spanish - Colombia", "es_co", 0x240A),
+	LANG("Spanish - Costa Rica", "es_cr", 0x140A),
+	LANG("Spanish - Dominican Republic", "es_do", 0x1C0A),
+	LANG("Spanish - Ecuador", "es_ec", 0x300A),
+	LANG("Spanish - Guatemala", "es_gt", 0x100A),
+	LANG("Spanish - Honduras", "es_hn", 0x480A),
+	LANG("Spanish - Mexico", "es_mx", 0x080A),
+	LANG("Spanish - Nicaragua", "es_ni", 0x4C0A),
+	LANG("Spanish - Panama", "es_pa", 0x180A),
+	LANG("Spanish - Peru", "es_pe", 0x280A),
+	LANG("Spanish - Puerto Rico", "es_pr", 0x500A),
+	LANG("Spanish - Paraguay", "es_py", 0x3C0A),
+	LANG("Spanish - El Salvador", "es_sv", 0x440A),
+	LANG("Spanish - Uruguay", "es_uy", 0x380A),
+	LANG("Spanish - Venezuela", "es_ve", 0x200A),
+	LANG("Southern Sotho", "st", 0x0430),
+	LANG("Swahili", "sw", 0x0441),
+	LANG("Swedish - Sweden", "sv_se", 0x041D),
+	LANG("Swedish - Finland", "sv_fi", 0x081D),
+	LANG("Tamil", "ta", 0x0449),
+	LANG("Tatar", "tt", 0X0444),
+	LANG("Thai", "th", 0x041E),
+	LANG("Turkish", "tr", 0x041F),
+	LANG("Tsonga", "ts", 0x0431),
+	LANG("Ukrainian", "uk", 0x0422),
+	LANG("Urdu", "ur", 0x0420),
+	LANG("Uzbek - Cyrillic", "uz_uz", 0x0843),
+	LANG("Uzbek – Latin", "uz_uz", 0x0443),
+	LANG("Vietnamese", "vi", 0x042A),
+	LANG("Xhosa", "xh", 0x0434),
+	LANG("Yiddish", "yi", 0x043D),
+	LANG("Zulu", "zu", 0x0435),
+	LANG(NULL, NULL, 0x0),
+};
+
+uint16_t get_usb_code_for_current_locale(void)
+{
+	char *locale;
+	char search_string[64];
+	char *ptr;
+	struct lang_map_entry *lang;
+
+	/* Get the current locale. */
+	locale = setlocale(0, NULL);
+	if (!locale)
+		return 0x0;
+
+	/* Make a copy of the current locale string. */
+	strncpy(search_string, locale, sizeof(search_string));
+	search_string[sizeof(search_string)-1] = '\0';
+
+	/* Chop off the encoding part, and make it lower case. */
+	ptr = search_string;
+	while (*ptr) {
+		*ptr = tolower(*ptr);
+		if (*ptr == '.') {
+			*ptr = '\0';
+			break;
+		}
+		ptr++;
+	}
+
+	/* Find the entry which matches the string code of our locale. */
+	lang = lang_map;
+	while (lang->string_code) {
+		if (!strcmp(lang->string_code, search_string)) {
+			return lang->usb_code;
+		}
+		lang++;
+	}
+
+	/* There was no match. Find with just the language only. */
+	/* Chop off the variant. Chop it off at the '_'. */
+	ptr = search_string;
+	while (*ptr) {
+		*ptr = tolower(*ptr);
+		if (*ptr == '_') {
+			*ptr = '\0';
+			break;
+		}
+		ptr++;
+	}
+
+#if 0 /* TODO: Do we need this? */
+	/* Find the entry which matches the string code of our language. */
+	lang = lang_map;
+	while (lang->string_code) {
+		if (!strcmp(lang->string_code, search_string)) {
+			return lang->usb_code;
+		}
+		lang++;
+	}
+#endif
+
+	/* Found nothing. */
+	return 0x0;
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/vendor/github.com/karalabe/usb/hidapi/mac/hid.c b/vendor/github.com/karalabe/usb/hidapi/mac/hid.c
new file mode 100644
index 000000000..e0756a158
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/hidapi/mac/hid.c
@@ -0,0 +1,1110 @@
+/*******************************************************
+ HIDAPI - Multi-Platform library for
+ communication with HID devices.
+
+ Alan Ott
+ Signal 11 Software
+
+ 2010-07-03
+
+ Copyright 2010, All Rights Reserved.
+
+ At the discretion of the user of this library,
+ this software may be licensed under the terms of the
+ GNU General Public License v3, a BSD-Style license, or the
+ original HIDAPI license as outlined in the LICENSE.txt,
+ LICENSE-gpl3.txt, LICENSE-bsd.txt, and LICENSE-orig.txt
+ files located at the root of the source distribution.
+ These files may also be found in the public source
+ code repository located at:
+        http://github.com/signal11/hidapi .
+********************************************************/
+
+/* See Apple Technical Note TN2187 for details on IOHidManager. */
+
+#include <IOKit/hid/IOHIDManager.h>
+#include <IOKit/hid/IOHIDKeys.h>
+#include <IOKit/IOKitLib.h>
+#include <CoreFoundation/CoreFoundation.h>
+#include <wchar.h>
+#include <locale.h>
+#include <pthread.h>
+#include <sys/time.h>
+#include <unistd.h>
+#include <dlfcn.h>
+
+#include "hidapi.h"
+
+/* Barrier implementation because Mac OSX doesn't have pthread_barrier.
+   It also doesn't have clock_gettime(). So much for POSIX and SUSv2.
+   This implementation came from Brent Priddy and was posted on
+   StackOverflow. It is used with his permission. */
+typedef int pthread_barrierattr_t;
+typedef struct pthread_barrier {
+    pthread_mutex_t mutex;
+    pthread_cond_t cond;
+    int count;
+    int trip_count;
+} pthread_barrier_t;
+
+static int pthread_barrier_init(pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count)
+{
+	if(count == 0) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	if(pthread_mutex_init(&barrier->mutex, 0) < 0) {
+		return -1;
+	}
+	if(pthread_cond_init(&barrier->cond, 0) < 0) {
+		pthread_mutex_destroy(&barrier->mutex);
+		return -1;
+	}
+	barrier->trip_count = count;
+	barrier->count = 0;
+
+	return 0;
+}
+
+static int pthread_barrier_destroy(pthread_barrier_t *barrier)
+{
+	pthread_cond_destroy(&barrier->cond);
+	pthread_mutex_destroy(&barrier->mutex);
+	return 0;
+}
+
+static int pthread_barrier_wait(pthread_barrier_t *barrier)
+{
+	pthread_mutex_lock(&barrier->mutex);
+	++(barrier->count);
+	if(barrier->count >= barrier->trip_count)
+	{
+		barrier->count = 0;
+		pthread_cond_broadcast(&barrier->cond);
+		pthread_mutex_unlock(&barrier->mutex);
+		return 1;
+	}
+	else
+	{
+		pthread_cond_wait(&barrier->cond, &(barrier->mutex));
+		pthread_mutex_unlock(&barrier->mutex);
+		return 0;
+	}
+}
+
+static int return_data(hid_device *dev, unsigned char *data, size_t length);
+
+/* Linked List of input reports received from the device. */
+struct input_report {
+	uint8_t *data;
+	size_t len;
+	struct input_report *next;
+};
+
+struct hid_device_ {
+	IOHIDDeviceRef device_handle;
+	int blocking;
+	int uses_numbered_reports;
+	int disconnected;
+	CFStringRef run_loop_mode;
+	CFRunLoopRef run_loop;
+	CFRunLoopSourceRef source;
+	uint8_t *input_report_buf;
+	CFIndex max_input_report_len;
+	struct input_report *input_reports;
+
+	pthread_t thread;
+	pthread_mutex_t mutex; /* Protects input_reports */
+	pthread_cond_t condition;
+	pthread_barrier_t barrier; /* Ensures correct startup sequence */
+	pthread_barrier_t shutdown_barrier; /* Ensures correct shutdown sequence */
+	int shutdown_thread;
+};
+
+static hid_device *new_hid_device(void)
+{
+	hid_device *dev = calloc(1, sizeof(hid_device));
+	dev->device_handle = NULL;
+	dev->blocking = 1;
+	dev->uses_numbered_reports = 0;
+	dev->disconnected = 0;
+	dev->run_loop_mode = NULL;
+	dev->run_loop = NULL;
+	dev->source = NULL;
+	dev->input_report_buf = NULL;
+	dev->input_reports = NULL;
+	dev->shutdown_thread = 0;
+
+	/* Thread objects */
+	pthread_mutex_init(&dev->mutex, NULL);
+	pthread_cond_init(&dev->condition, NULL);
+	pthread_barrier_init(&dev->barrier, NULL, 2);
+	pthread_barrier_init(&dev->shutdown_barrier, NULL, 2);
+
+	return dev;
+}
+
+static void free_hid_device(hid_device *dev)
+{
+	if (!dev)
+		return;
+
+	/* Delete any input reports still left over. */
+	struct input_report *rpt = dev->input_reports;
+	while (rpt) {
+		struct input_report *next = rpt->next;
+		free(rpt->data);
+		free(rpt);
+		rpt = next;
+	}
+
+	/* Free the string and the report buffer. The check for NULL
+	   is necessary here as CFRelease() doesn't handle NULL like
+	   free() and others do. */
+	if (dev->run_loop_mode)
+		CFRelease(dev->run_loop_mode);
+	if (dev->source)
+		CFRelease(dev->source);
+	free(dev->input_report_buf);
+
+	/* Clean up the thread objects */
+	pthread_barrier_destroy(&dev->shutdown_barrier);
+	pthread_barrier_destroy(&dev->barrier);
+	pthread_cond_destroy(&dev->condition);
+	pthread_mutex_destroy(&dev->mutex);
+
+	/* Free the structure itself. */
+	free(dev);
+}
+
+static	IOHIDManagerRef hid_mgr = 0x0;
+
+
+#if 0
+static void register_error(hid_device *device, const char *op)
+{
+
+}
+#endif
+
+
+static int32_t get_int_property(IOHIDDeviceRef device, CFStringRef key)
+{
+	CFTypeRef ref;
+	int32_t value;
+
+	ref = IOHIDDeviceGetProperty(device, key);
+	if (ref) {
+		if (CFGetTypeID(ref) == CFNumberGetTypeID()) {
+			CFNumberGetValue((CFNumberRef) ref, kCFNumberSInt32Type, &value);
+			return value;
+		}
+	}
+	return 0;
+}
+
+static unsigned short get_vendor_id(IOHIDDeviceRef device)
+{
+	return get_int_property(device, CFSTR(kIOHIDVendorIDKey));
+}
+
+static unsigned short get_product_id(IOHIDDeviceRef device)
+{
+	return get_int_property(device, CFSTR(kIOHIDProductIDKey));
+}
+
+static int32_t get_max_report_length(IOHIDDeviceRef device)
+{
+	return get_int_property(device, CFSTR(kIOHIDMaxInputReportSizeKey));
+}
+
+static int get_string_property(IOHIDDeviceRef device, CFStringRef prop, wchar_t *buf, size_t len)
+{
+	CFStringRef str;
+
+	if (!len)
+		return 0;
+
+	str = IOHIDDeviceGetProperty(device, prop);
+
+	buf[0] = 0;
+
+	if (str) {
+		CFIndex str_len = CFStringGetLength(str);
+		CFRange range;
+		CFIndex used_buf_len;
+		CFIndex chars_copied;
+
+		len --;
+
+		range.location = 0;
+		range.length = ((size_t)str_len > len)? len: (size_t)str_len;
+		chars_copied = CFStringGetBytes(str,
+			range,
+			kCFStringEncodingUTF32LE,
+			(char)'?',
+			FALSE,
+			(UInt8*)buf,
+			len * sizeof(wchar_t),
+			&used_buf_len);
+
+		if (chars_copied == len)
+			buf[len] = 0; /* len is decremented above */
+		else
+			buf[chars_copied] = 0;
+
+		return 0;
+	}
+	else
+		return -1;
+
+}
+
+static int get_serial_number(IOHIDDeviceRef device, wchar_t *buf, size_t len)
+{
+	return get_string_property(device, CFSTR(kIOHIDSerialNumberKey), buf, len);
+}
+
+static int get_manufacturer_string(IOHIDDeviceRef device, wchar_t *buf, size_t len)
+{
+	return get_string_property(device, CFSTR(kIOHIDManufacturerKey), buf, len);
+}
+
+static int get_product_string(IOHIDDeviceRef device, wchar_t *buf, size_t len)
+{
+	return get_string_property(device, CFSTR(kIOHIDProductKey), buf, len);
+}
+
+
+/* Implementation of wcsdup() for Mac. */
+static wchar_t *dup_wcs(const wchar_t *s)
+{
+	size_t len = wcslen(s);
+	wchar_t *ret = malloc((len+1)*sizeof(wchar_t));
+	wcscpy(ret, s);
+
+	return ret;
+}
+
+/* hidapi_IOHIDDeviceGetService()
+ *
+ * Return the io_service_t corresponding to a given IOHIDDeviceRef, either by:
+ * - on OS X 10.6 and above, calling IOHIDDeviceGetService()
+ * - on OS X 10.5, extract it from the IOHIDDevice struct
+ */
+static io_service_t hidapi_IOHIDDeviceGetService(IOHIDDeviceRef device)
+{
+	static void *iokit_framework = NULL;
+	static io_service_t (*dynamic_IOHIDDeviceGetService)(IOHIDDeviceRef device) = NULL;
+
+	/* Use dlopen()/dlsym() to get a pointer to IOHIDDeviceGetService() if it exists.
+	 * If any of these steps fail, dynamic_IOHIDDeviceGetService will be left NULL
+	 * and the fallback method will be used.
+	 */
+	if (iokit_framework == NULL) {
+		iokit_framework = dlopen("/System/Library/IOKit.framework/IOKit", RTLD_LAZY);
+
+		if (iokit_framework != NULL)
+			dynamic_IOHIDDeviceGetService = dlsym(iokit_framework, "IOHIDDeviceGetService");
+	}
+
+	if (dynamic_IOHIDDeviceGetService != NULL) {
+		/* Running on OS X 10.6 and above: IOHIDDeviceGetService() exists */
+		return dynamic_IOHIDDeviceGetService(device);
+	}
+	else
+	{
+		/* Running on OS X 10.5: IOHIDDeviceGetService() doesn't exist.
+		 *
+		 * Be naughty and pull the service out of the IOHIDDevice.
+		 * IOHIDDevice is an opaque struct not exposed to applications, but its
+		 * layout is stable through all available versions of OS X.
+		 * Tested and working on OS X 10.5.8 i386, x86_64, and ppc.
+		 */
+		struct IOHIDDevice_internal {
+			/* The first field of the IOHIDDevice struct is a
+			 * CFRuntimeBase (which is a private CF struct).
+			 *
+			 * a, b, and c are the 3 fields that make up a CFRuntimeBase.
+			 * See http://opensource.apple.com/source/CF/CF-476.18/CFRuntime.h
+			 *
+			 * The second field of the IOHIDDevice is the io_service_t we're looking for.
+			 */
+			uintptr_t a;
+			uint8_t b[4];
+#if __LP64__
+			uint32_t c;
+#endif
+			io_service_t service;
+		};
+		struct IOHIDDevice_internal *tmp = (struct IOHIDDevice_internal *)device;
+
+		return tmp->service;
+	}
+}
+
+/* Initialize the IOHIDManager. Return 0 for success and -1 for failure. */
+static int init_hid_manager(void)
+{
+	/* Initialize all the HID Manager Objects */
+	hid_mgr = IOHIDManagerCreate(kCFAllocatorDefault, kIOHIDOptionsTypeNone);
+	if (hid_mgr) {
+		IOHIDManagerSetDeviceMatching(hid_mgr, NULL);
+		IOHIDManagerScheduleWithRunLoop(hid_mgr, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
+		return 0;
+	}
+
+	return -1;
+}
+
+/* Initialize the IOHIDManager if necessary. This is the public function, and
+   it is safe to call this function repeatedly. Return 0 for success and -1
+   for failure. */
+int HID_API_EXPORT hid_init(void)
+{
+	if (!hid_mgr) {
+		return init_hid_manager();
+	}
+
+	/* Already initialized. */
+	return 0;
+}
+
+int HID_API_EXPORT hid_exit(void)
+{
+	if (hid_mgr) {
+		/* Close the HID manager. */
+		IOHIDManagerClose(hid_mgr, kIOHIDOptionsTypeNone);
+		CFRelease(hid_mgr);
+		hid_mgr = NULL;
+	}
+
+	return 0;
+}
+
+static void process_pending_events(void) {
+	SInt32 res;
+	do {
+		res = CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.001, FALSE);
+	} while(res != kCFRunLoopRunFinished && res != kCFRunLoopRunTimedOut);
+}
+
+struct hid_device_info  HID_API_EXPORT *hid_enumerate(unsigned short vendor_id, unsigned short product_id)
+{
+	struct hid_device_info *root = NULL; /* return object */
+	struct hid_device_info *cur_dev = NULL;
+	CFIndex num_devices;
+	int i;
+
+	/* Set up the HID Manager if it hasn't been done */
+	if (hid_init() < 0)
+		return NULL;
+
+	/* give the IOHIDManager a chance to update itself */
+	process_pending_events();
+
+	/* Get a list of the Devices */
+	IOHIDManagerSetDeviceMatching(hid_mgr, NULL);
+	CFSetRef device_set = IOHIDManagerCopyDevices(hid_mgr);
+
+	/* Convert the list into a C array so we can iterate easily. */
+	num_devices = CFSetGetCount(device_set);
+	IOHIDDeviceRef *device_array = calloc(num_devices, sizeof(IOHIDDeviceRef));
+	CFSetGetValues(device_set, (const void **) device_array);
+
+	/* Iterate over each device, making an entry for it. */
+	for (i = 0; i < num_devices; i++) {
+		unsigned short dev_vid;
+		unsigned short dev_pid;
+		#define BUF_LEN 256
+		wchar_t buf[BUF_LEN];
+
+		IOHIDDeviceRef dev = device_array[i];
+
+        if (!dev) {
+            continue;
+        }
+		dev_vid = get_vendor_id(dev);
+		dev_pid = get_product_id(dev);
+
+		/* Check the VID/PID against the arguments */
+		if ((vendor_id == 0x0 || vendor_id == dev_vid) &&
+		    (product_id == 0x0 || product_id == dev_pid)) {
+			struct hid_device_info *tmp;
+			io_object_t iokit_dev;
+			kern_return_t res;
+			io_string_t path;
+
+			/* VID/PID match. Create the record. */
+			tmp = malloc(sizeof(struct hid_device_info));
+			if (cur_dev) {
+				cur_dev->next = tmp;
+			}
+			else {
+				root = tmp;
+			}
+			cur_dev = tmp;
+
+			/* Get the Usage Page and Usage for this device. */
+			cur_dev->usage_page = get_int_property(dev, CFSTR(kIOHIDPrimaryUsagePageKey));
+			cur_dev->usage = get_int_property(dev, CFSTR(kIOHIDPrimaryUsageKey));
+
+			/* Fill out the record */
+			cur_dev->next = NULL;
+
+			/* Fill in the path (IOService plane) */
+			iokit_dev = hidapi_IOHIDDeviceGetService(dev);
+			res = IORegistryEntryGetPath(iokit_dev, kIOServicePlane, path);
+			if (res == KERN_SUCCESS)
+				cur_dev->path = strdup(path);
+			else
+				cur_dev->path = strdup("");
+
+			/* Serial Number */
+			get_serial_number(dev, buf, BUF_LEN);
+			cur_dev->serial_number = dup_wcs(buf);
+
+			/* Manufacturer and Product strings */
+			get_manufacturer_string(dev, buf, BUF_LEN);
+			cur_dev->manufacturer_string = dup_wcs(buf);
+			get_product_string(dev, buf, BUF_LEN);
+			cur_dev->product_string = dup_wcs(buf);
+
+			/* VID/PID */
+			cur_dev->vendor_id = dev_vid;
+			cur_dev->product_id = dev_pid;
+
+			/* Release Number */
+			cur_dev->release_number = get_int_property(dev, CFSTR(kIOHIDVersionNumberKey));
+
+			/* Interface Number (Unsupported on Mac)*/
+			cur_dev->interface_number = -1;
+		}
+	}
+
+	free(device_array);
+	CFRelease(device_set);
+
+	return root;
+}
+
+void  HID_API_EXPORT hid_free_enumeration(struct hid_device_info *devs)
+{
+	/* This function is identical to the Linux version. Platform independent. */
+	struct hid_device_info *d = devs;
+	while (d) {
+		struct hid_device_info *next = d->next;
+		free(d->path);
+		free(d->serial_number);
+		free(d->manufacturer_string);
+		free(d->product_string);
+		free(d);
+		d = next;
+	}
+}
+
+hid_device * HID_API_EXPORT hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number)
+{
+	/* This function is identical to the Linux version. Platform independent. */
+	struct hid_device_info *devs, *cur_dev;
+	const char *path_to_open = NULL;
+	hid_device * handle = NULL;
+
+	devs = hid_enumerate(vendor_id, product_id);
+	cur_dev = devs;
+	while (cur_dev) {
+		if (cur_dev->vendor_id == vendor_id &&
+		    cur_dev->product_id == product_id) {
+			if (serial_number) {
+				if (wcscmp(serial_number, cur_dev->serial_number) == 0) {
+					path_to_open = cur_dev->path;
+					break;
+				}
+			}
+			else {
+				path_to_open = cur_dev->path;
+				break;
+			}
+		}
+		cur_dev = cur_dev->next;
+	}
+
+	if (path_to_open) {
+		/* Open the device */
+		handle = hid_open_path(path_to_open);
+	}
+
+	hid_free_enumeration(devs);
+
+	return handle;
+}
+
+static void hid_device_removal_callback(void *context, IOReturn result,
+                                        void *sender)
+{
+	/* Stop the Run Loop for this device. */
+	hid_device *d = context;
+
+	d->disconnected = 1;
+	CFRunLoopStop(d->run_loop);
+}
+
+/* The Run Loop calls this function for each input report received.
+   This function puts the data into a linked list to be picked up by
+   hid_read(). */
+static void hid_report_callback(void *context, IOReturn result, void *sender,
+                         IOHIDReportType report_type, uint32_t report_id,
+                         uint8_t *report, CFIndex report_length)
+{
+	struct input_report *rpt;
+	hid_device *dev = context;
+
+	/* Make a new Input Report object */
+	rpt = calloc(1, sizeof(struct input_report));
+	rpt->data = calloc(1, report_length);
+	memcpy(rpt->data, report, report_length);
+	rpt->len = report_length;
+	rpt->next = NULL;
+
+	/* Lock this section */
+	pthread_mutex_lock(&dev->mutex);
+
+	/* Attach the new report object to the end of the list. */
+	if (dev->input_reports == NULL) {
+		/* The list is empty. Put it at the root. */
+		dev->input_reports = rpt;
+	}
+	else {
+		/* Find the end of the list and attach. */
+		struct input_report *cur = dev->input_reports;
+		int num_queued = 0;
+		while (cur->next != NULL) {
+			cur = cur->next;
+			num_queued++;
+		}
+		cur->next = rpt;
+
+		/* Pop one off if we've reached 30 in the queue. This
+		   way we don't grow forever if the user never reads
+		   anything from the device. */
+		if (num_queued > 30) {
+			return_data(dev, NULL, 0);
+		}
+	}
+
+	/* Signal a waiting thread that there is data. */
+	pthread_cond_signal(&dev->condition);
+
+	/* Unlock */
+	pthread_mutex_unlock(&dev->mutex);
+
+}
+
+/* This gets called when the read_thread's run loop gets signaled by
+   hid_close(), and serves to stop the read_thread's run loop. */
+static void perform_signal_callback(void *context)
+{
+	hid_device *dev = context;
+	CFRunLoopStop(dev->run_loop); /*TODO: CFRunLoopGetCurrent()*/
+}
+
+static void *read_thread(void *param)
+{
+	hid_device *dev = param;
+	SInt32 code;
+
+	/* Move the device's run loop to this thread. */
+	IOHIDDeviceScheduleWithRunLoop(dev->device_handle, CFRunLoopGetCurrent(), dev->run_loop_mode);
+
+	/* Create the RunLoopSource which is used to signal the
+	   event loop to stop when hid_close() is called. */
+	CFRunLoopSourceContext ctx;
+	memset(&ctx, 0, sizeof(ctx));
+	ctx.version = 0;
+	ctx.info = dev;
+	ctx.perform = &perform_signal_callback;
+	dev->source = CFRunLoopSourceCreate(kCFAllocatorDefault, 0/*order*/, &ctx);
+	CFRunLoopAddSource(CFRunLoopGetCurrent(), dev->source, dev->run_loop_mode);
+
+	/* Store off the Run Loop so it can be stopped from hid_close()
+	   and on device disconnection. */
+	dev->run_loop = CFRunLoopGetCurrent();
+
+	/* Notify the main thread that the read thread is up and running. */
+	pthread_barrier_wait(&dev->barrier);
+
+	/* Run the Event Loop. CFRunLoopRunInMode() will dispatch HID input
+	   reports into the hid_report_callback(). */
+	while (!dev->shutdown_thread && !dev->disconnected) {
+		code = CFRunLoopRunInMode(dev->run_loop_mode, 1000/*sec*/, FALSE);
+		/* Return if the device has been disconnected */
+		if (code == kCFRunLoopRunFinished) {
+			dev->disconnected = 1;
+			break;
+		}
+
+
+		/* Break if The Run Loop returns Finished or Stopped. */
+		if (code != kCFRunLoopRunTimedOut &&
+		    code != kCFRunLoopRunHandledSource) {
+			/* There was some kind of error. Setting
+			   shutdown seems to make sense, but
+			   there may be something else more appropriate */
+			dev->shutdown_thread = 1;
+			break;
+		}
+	}
+
+	/* Now that the read thread is stopping, Wake any threads which are
+	   waiting on data (in hid_read_timeout()). Do this under a mutex to
+	   make sure that a thread which is about to go to sleep waiting on
+	   the condition actually will go to sleep before the condition is
+	   signaled. */
+	pthread_mutex_lock(&dev->mutex);
+	pthread_cond_broadcast(&dev->condition);
+	pthread_mutex_unlock(&dev->mutex);
+
+	/* Wait here until hid_close() is called and makes it past
+	   the call to CFRunLoopWakeUp(). This thread still needs to
+	   be valid when that function is called on the other thread. */
+	pthread_barrier_wait(&dev->shutdown_barrier);
+
+	return NULL;
+}
+
+/* hid_open_path()
+ *
+ * path must be a valid path to an IOHIDDevice in the IOService plane
+ * Example: "IOService:/AppleACPIPlatformExpert/PCI0@0/AppleACPIPCI/EHC1@1D,7/AppleUSBEHCI/PLAYSTATION(R)3 Controller@fd120000/IOUSBInterface@0/IOUSBHIDDriver"
+ */
+hid_device * HID_API_EXPORT hid_open_path(const char *path)
+{
+	hid_device *dev = NULL;
+	io_registry_entry_t entry = MACH_PORT_NULL;
+
+	dev = new_hid_device();
+
+	/* Set up the HID Manager if it hasn't been done */
+	if (hid_init() < 0)
+		return NULL;
+
+	/* Get the IORegistry entry for the given path */
+	entry = IORegistryEntryFromPath(kIOMasterPortDefault, path);
+	if (entry == MACH_PORT_NULL) {
+		/* Path wasn't valid (maybe device was removed?) */
+		goto return_error;
+	}
+
+	/* Create an IOHIDDevice for the entry */
+	dev->device_handle = IOHIDDeviceCreate(kCFAllocatorDefault, entry);
+	if (dev->device_handle == NULL) {
+		/* Error creating the HID device */
+		goto return_error;
+	}
+
+	/* Open the IOHIDDevice */
+	IOReturn ret = IOHIDDeviceOpen(dev->device_handle, kIOHIDOptionsTypeSeizeDevice);
+	if (ret == kIOReturnSuccess) {
+		char str[32];
+
+		/* Create the buffers for receiving data */
+		dev->max_input_report_len = (CFIndex) get_max_report_length(dev->device_handle);
+		dev->input_report_buf = calloc(dev->max_input_report_len, sizeof(uint8_t));
+
+		/* Create the Run Loop Mode for this device.
+		   printing the reference seems to work. */
+		sprintf(str, "HIDAPI_%p", dev->device_handle);
+		dev->run_loop_mode =
+			CFStringCreateWithCString(NULL, str, kCFStringEncodingASCII);
+
+		/* Attach the device to a Run Loop */
+		IOHIDDeviceRegisterInputReportCallback(
+			dev->device_handle, dev->input_report_buf, dev->max_input_report_len,
+			&hid_report_callback, dev);
+		IOHIDDeviceRegisterRemovalCallback(dev->device_handle, hid_device_removal_callback, dev);
+
+		/* Start the read thread */
+		pthread_create(&dev->thread, NULL, read_thread, dev);
+
+		/* Wait here for the read thread to be initialized. */
+		pthread_barrier_wait(&dev->barrier);
+
+		IOObjectRelease(entry);
+		return dev;
+	}
+	else {
+		goto return_error;
+	}
+
+return_error:
+	if (dev->device_handle != NULL)
+		CFRelease(dev->device_handle);
+
+	if (entry != MACH_PORT_NULL)
+		IOObjectRelease(entry);
+
+	free_hid_device(dev);
+	return NULL;
+}
+
+static int set_report(hid_device *dev, IOHIDReportType type, const unsigned char *data, size_t length)
+{
+	const unsigned char *data_to_send;
+	size_t length_to_send;
+	IOReturn res;
+
+	/* Return if the device has been disconnected. */
+	if (dev->disconnected)
+		return -1;
+
+	if (data[0] == 0x0) {
+		/* Not using numbered Reports.
+		   Don't send the report number. */
+		data_to_send = data+1;
+		length_to_send = length-1;
+	}
+	else {
+		/* Using numbered Reports.
+		   Send the Report Number */
+		data_to_send = data;
+		length_to_send = length;
+	}
+
+	if (!dev->disconnected) {
+		res = IOHIDDeviceSetReport(dev->device_handle,
+					   type,
+					   data[0], /* Report ID*/
+					   data_to_send, length_to_send);
+
+		if (res == kIOReturnSuccess) {
+			return length;
+		}
+		else
+			return -1;
+	}
+
+	return -1;
+}
+
+int HID_API_EXPORT hid_write(hid_device *dev, const unsigned char *data, size_t length)
+{
+	return set_report(dev, kIOHIDReportTypeOutput, data, length);
+}
+
+/* Helper function, so that this isn't duplicated in hid_read(). */
+static int return_data(hid_device *dev, unsigned char *data, size_t length)
+{
+	/* Copy the data out of the linked list item (rpt) into the
+	   return buffer (data), and delete the liked list item. */
+	struct input_report *rpt = dev->input_reports;
+	size_t len = (length < rpt->len)? length: rpt->len;
+	memcpy(data, rpt->data, len);
+	dev->input_reports = rpt->next;
+	free(rpt->data);
+	free(rpt);
+	return len;
+}
+
+static int cond_wait(const hid_device *dev, pthread_cond_t *cond, pthread_mutex_t *mutex)
+{
+	while (!dev->input_reports) {
+		int res = pthread_cond_wait(cond, mutex);
+		if (res != 0)
+			return res;
+
+		/* A res of 0 means we may have been signaled or it may
+		   be a spurious wakeup. Check to see that there's acutally
+		   data in the queue before returning, and if not, go back
+		   to sleep. See the pthread_cond_timedwait() man page for
+		   details. */
+
+		if (dev->shutdown_thread || dev->disconnected)
+			return -1;
+	}
+
+	return 0;
+}
+
+static int cond_timedwait(const hid_device *dev, pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime)
+{
+	while (!dev->input_reports) {
+		int res = pthread_cond_timedwait(cond, mutex, abstime);
+		if (res != 0)
+			return res;
+
+		/* A res of 0 means we may have been signaled or it may
+		   be a spurious wakeup. Check to see that there's acutally
+		   data in the queue before returning, and if not, go back
+		   to sleep. See the pthread_cond_timedwait() man page for
+		   details. */
+
+		if (dev->shutdown_thread || dev->disconnected)
+			return -1;
+	}
+
+	return 0;
+
+}
+
+int HID_API_EXPORT hid_read_timeout(hid_device *dev, unsigned char *data, size_t length, int milliseconds)
+{
+	int bytes_read = -1;
+
+	/* Lock the access to the report list. */
+	pthread_mutex_lock(&dev->mutex);
+
+	/* There's an input report queued up. Return it. */
+	if (dev->input_reports) {
+		/* Return the first one */
+		bytes_read = return_data(dev, data, length);
+		goto ret;
+	}
+
+	/* Return if the device has been disconnected. */
+	if (dev->disconnected) {
+		bytes_read = -1;
+		goto ret;
+	}
+
+	if (dev->shutdown_thread) {
+		/* This means the device has been closed (or there
+		   has been an error. An error code of -1 should
+		   be returned. */
+		bytes_read = -1;
+		goto ret;
+	}
+
+	/* There is no data. Go to sleep and wait for data. */
+
+	if (milliseconds == -1) {
+		/* Blocking */
+		int res;
+		res = cond_wait(dev, &dev->condition, &dev->mutex);
+		if (res == 0)
+			bytes_read = return_data(dev, data, length);
+		else {
+			/* There was an error, or a device disconnection. */
+			bytes_read = -1;
+		}
+	}
+	else if (milliseconds > 0) {
+		/* Non-blocking, but called with timeout. */
+		int res;
+		struct timespec ts;
+		struct timeval tv;
+		gettimeofday(&tv, NULL);
+		TIMEVAL_TO_TIMESPEC(&tv, &ts);
+		ts.tv_sec += milliseconds / 1000;
+		ts.tv_nsec += (milliseconds % 1000) * 1000000;
+		if (ts.tv_nsec >= 1000000000L) {
+			ts.tv_sec++;
+			ts.tv_nsec -= 1000000000L;
+		}
+
+		res = cond_timedwait(dev, &dev->condition, &dev->mutex, &ts);
+		if (res == 0)
+			bytes_read = return_data(dev, data, length);
+		else if (res == ETIMEDOUT)
+			bytes_read = 0;
+		else
+			bytes_read = -1;
+	}
+	else {
+		/* Purely non-blocking */
+		bytes_read = 0;
+	}
+
+ret:
+	/* Unlock */
+	pthread_mutex_unlock(&dev->mutex);
+	return bytes_read;
+}
+
+int HID_API_EXPORT hid_read(hid_device *dev, unsigned char *data, size_t length)
+{
+	return hid_read_timeout(dev, data, length, (dev->blocking)? -1: 0);
+}
+
+int HID_API_EXPORT hid_set_nonblocking(hid_device *dev, int nonblock)
+{
+	/* All Nonblocking operation is handled by the library. */
+	dev->blocking = !nonblock;
+
+	return 0;
+}
+
+int HID_API_EXPORT hid_send_feature_report(hid_device *dev, const unsigned char *data, size_t length)
+{
+	return set_report(dev, kIOHIDReportTypeFeature, data, length);
+}
+
+int HID_API_EXPORT hid_get_feature_report(hid_device *dev, unsigned char *data, size_t length)
+{
+	CFIndex len = length;
+	IOReturn res;
+
+	/* Return if the device has been unplugged. */
+	if (dev->disconnected)
+		return -1;
+
+	res = IOHIDDeviceGetReport(dev->device_handle,
+	                           kIOHIDReportTypeFeature,
+	                           data[0], /* Report ID */
+	                           data, &len);
+	if (res == kIOReturnSuccess)
+		return len;
+	else
+		return -1;
+}
+
+
+void HID_API_EXPORT hid_close(hid_device *dev)
+{
+	if (!dev)
+		return;
+
+	/* Disconnect the report callback before close. */
+	if (!dev->disconnected) {
+		IOHIDDeviceRegisterInputReportCallback(
+			dev->device_handle, dev->input_report_buf, dev->max_input_report_len,
+			NULL, dev);
+		IOHIDDeviceRegisterRemovalCallback(dev->device_handle, NULL, dev);
+		IOHIDDeviceUnscheduleFromRunLoop(dev->device_handle, dev->run_loop, dev->run_loop_mode);
+		IOHIDDeviceScheduleWithRunLoop(dev->device_handle, CFRunLoopGetMain(), kCFRunLoopDefaultMode);
+	}
+
+	/* Cause read_thread() to stop. */
+	dev->shutdown_thread = 1;
+
+	/* Wake up the run thread's event loop so that the thread can exit. */
+	CFRunLoopSourceSignal(dev->source);
+	CFRunLoopWakeUp(dev->run_loop);
+
+	/* Notify the read thread that it can shut down now. */
+	pthread_barrier_wait(&dev->shutdown_barrier);
+
+	/* Wait for read_thread() to end. */
+	pthread_join(dev->thread, NULL);
+
+	/* Close the OS handle to the device, but only if it's not
+	   been unplugged. If it's been unplugged, then calling
+	   IOHIDDeviceClose() will crash. */
+	if (!dev->disconnected) {
+		IOHIDDeviceClose(dev->device_handle, kIOHIDOptionsTypeSeizeDevice);
+	}
+
+	/* Clear out the queue of received reports. */
+	pthread_mutex_lock(&dev->mutex);
+	while (dev->input_reports) {
+		return_data(dev, NULL, 0);
+	}
+	pthread_mutex_unlock(&dev->mutex);
+	CFRelease(dev->device_handle);
+
+	free_hid_device(dev);
+}
+
+int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device *dev, wchar_t *string, size_t maxlen)
+{
+	return get_manufacturer_string(dev->device_handle, string, maxlen);
+}
+
+int HID_API_EXPORT_CALL hid_get_product_string(hid_device *dev, wchar_t *string, size_t maxlen)
+{
+	return get_product_string(dev->device_handle, string, maxlen);
+}
+
+int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *string, size_t maxlen)
+{
+	return get_serial_number(dev->device_handle, string, maxlen);
+}
+
+int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen)
+{
+	/* TODO: */
+
+	return 0;
+}
+
+
+HID_API_EXPORT const wchar_t * HID_API_CALL  hid_error(hid_device *dev)
+{
+	/* TODO: */
+
+	return NULL;
+}
+
+
+
+
+
+
+
+#if 0
+static int32_t get_location_id(IOHIDDeviceRef device)
+{
+	return get_int_property(device, CFSTR(kIOHIDLocationIDKey));
+}
+
+static int32_t get_usage(IOHIDDeviceRef device)
+{
+	int32_t res;
+	res = get_int_property(device, CFSTR(kIOHIDDeviceUsageKey));
+	if (!res)
+		res = get_int_property(device, CFSTR(kIOHIDPrimaryUsageKey));
+	return res;
+}
+
+static int32_t get_usage_page(IOHIDDeviceRef device)
+{
+	int32_t res;
+	res = get_int_property(device, CFSTR(kIOHIDDeviceUsagePageKey));
+	if (!res)
+		res = get_int_property(device, CFSTR(kIOHIDPrimaryUsagePageKey));
+	return res;
+}
+
+static int get_transport(IOHIDDeviceRef device, wchar_t *buf, size_t len)
+{
+	return get_string_property(device, CFSTR(kIOHIDTransportKey), buf, len);
+}
+
+
+int main(void)
+{
+	IOHIDManagerRef mgr;
+	int i;
+
+	mgr = IOHIDManagerCreate(kCFAllocatorDefault, kIOHIDOptionsTypeNone);
+	IOHIDManagerSetDeviceMatching(mgr, NULL);
+	IOHIDManagerOpen(mgr, kIOHIDOptionsTypeNone);
+
+	CFSetRef device_set = IOHIDManagerCopyDevices(mgr);
+
+	CFIndex num_devices = CFSetGetCount(device_set);
+	IOHIDDeviceRef *device_array = calloc(num_devices, sizeof(IOHIDDeviceRef));
+	CFSetGetValues(device_set, (const void **) device_array);
+
+	for (i = 0; i < num_devices; i++) {
+		IOHIDDeviceRef dev = device_array[i];
+		printf("Device: %p\n", dev);
+		printf("  %04hx %04hx\n", get_vendor_id(dev), get_product_id(dev));
+
+		wchar_t serial[256], buf[256];
+		char cbuf[256];
+		get_serial_number(dev, serial, 256);
+
+
+		printf("  Serial: %ls\n", serial);
+		printf("  Loc: %ld\n", get_location_id(dev));
+		get_transport(dev, buf, 256);
+		printf("  Trans: %ls\n", buf);
+		make_path(dev, cbuf, 256);
+		printf("  Path: %s\n", cbuf);
+
+	}
+
+	return 0;
+}
+#endif
diff --git a/vendor/github.com/karalabe/usb/hidapi/windows/hid.c b/vendor/github.com/karalabe/usb/hidapi/windows/hid.c
new file mode 100644
index 000000000..60da64608
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/hidapi/windows/hid.c
@@ -0,0 +1,946 @@
+/*******************************************************
+ HIDAPI - Multi-Platform library for
+ communication with HID devices.
+
+ Alan Ott
+ Signal 11 Software
+
+ 8/22/2009
+
+ Copyright 2009, All Rights Reserved.
+
+ At the discretion of the user of this library,
+ this software may be licensed under the terms of the
+ GNU General Public License v3, a BSD-Style license, or the
+ original HIDAPI license as outlined in the LICENSE.txt,
+ LICENSE-gpl3.txt, LICENSE-bsd.txt, and LICENSE-orig.txt
+ files located at the root of the source distribution.
+ These files may also be found in the public source
+ code repository located at:
+        http://github.com/signal11/hidapi .
+********************************************************/
+
+#include <windows.h>
+
+#ifndef _NTDEF_
+typedef LONG NTSTATUS;
+#endif
+
+#ifdef __MINGW32__
+#include <ntdef.h>
+#include <winbase.h>
+#endif
+
+#ifdef __CYGWIN__
+#include <ntdef.h>
+#define _wcsdup wcsdup
+#endif
+
+/* The maximum number of characters that can be passed into the
+   HidD_Get*String() functions without it failing.*/
+#define MAX_STRING_WCHARS 0xFFF
+
+/*#define HIDAPI_USE_DDK*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+	#include <setupapi.h>
+	#include <winioctl.h>
+	#ifdef HIDAPI_USE_DDK
+		#include <hidsdi.h>
+	#endif
+
+	/* Copied from inc/ddk/hidclass.h, part of the Windows DDK. */
+	#define HID_OUT_CTL_CODE(id)  \
+		CTL_CODE(FILE_DEVICE_KEYBOARD, (id), METHOD_OUT_DIRECT, FILE_ANY_ACCESS)
+	#define IOCTL_HID_GET_FEATURE                   HID_OUT_CTL_CODE(100)
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+
+
+#include "hidapi.h"
+
+#undef MIN
+#define MIN(x,y) ((x) < (y)? (x): (y))
+
+#ifdef _MSC_VER
+	/* Thanks Microsoft, but I know how to use strncpy(). */
+	#pragma warning(disable:4996)
+#endif
+
+#pragma GCC diagnostic ignored "-Wstringop-overflow"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef HIDAPI_USE_DDK
+	/* Since we're not building with the DDK, and the HID header
+	   files aren't part of the SDK, we have to define all this
+	   stuff here. In lookup_functions(), the function pointers
+	   defined below are set. */
+	typedef struct _HIDD_ATTRIBUTES{
+		ULONG Size;
+		USHORT VendorID;
+		USHORT ProductID;
+		USHORT VersionNumber;
+	} HIDD_ATTRIBUTES, *PHIDD_ATTRIBUTES;
+
+	typedef USHORT USAGE;
+	typedef struct _HIDP_CAPS {
+		USAGE Usage;
+		USAGE UsagePage;
+		USHORT InputReportByteLength;
+		USHORT OutputReportByteLength;
+		USHORT FeatureReportByteLength;
+		USHORT Reserved[17];
+		USHORT fields_not_used_by_hidapi[10];
+	} HIDP_CAPS, *PHIDP_CAPS;
+	typedef void* PHIDP_PREPARSED_DATA;
+	#define HIDP_STATUS_SUCCESS 0x110000
+
+	typedef BOOLEAN (__stdcall *HidD_GetAttributes_)(HANDLE device, PHIDD_ATTRIBUTES attrib);
+	typedef BOOLEAN (__stdcall *HidD_GetSerialNumberString_)(HANDLE device, PVOID buffer, ULONG buffer_len);
+	typedef BOOLEAN (__stdcall *HidD_GetManufacturerString_)(HANDLE handle, PVOID buffer, ULONG buffer_len);
+	typedef BOOLEAN (__stdcall *HidD_GetProductString_)(HANDLE handle, PVOID buffer, ULONG buffer_len);
+	typedef BOOLEAN (__stdcall *HidD_SetFeature_)(HANDLE handle, PVOID data, ULONG length);
+	typedef BOOLEAN (__stdcall *HidD_GetFeature_)(HANDLE handle, PVOID data, ULONG length);
+	typedef BOOLEAN (__stdcall *HidD_GetIndexedString_)(HANDLE handle, ULONG string_index, PVOID buffer, ULONG buffer_len);
+	typedef BOOLEAN (__stdcall *HidD_GetPreparsedData_)(HANDLE handle, PHIDP_PREPARSED_DATA *preparsed_data);
+	typedef BOOLEAN (__stdcall *HidD_FreePreparsedData_)(PHIDP_PREPARSED_DATA preparsed_data);
+	typedef NTSTATUS (__stdcall *HidP_GetCaps_)(PHIDP_PREPARSED_DATA preparsed_data, HIDP_CAPS *caps);
+	typedef BOOLEAN (__stdcall *HidD_SetNumInputBuffers_)(HANDLE handle, ULONG number_buffers);
+
+	static HidD_GetAttributes_ HidD_GetAttributes;
+	static HidD_GetSerialNumberString_ HidD_GetSerialNumberString;
+	static HidD_GetManufacturerString_ HidD_GetManufacturerString;
+	static HidD_GetProductString_ HidD_GetProductString;
+	static HidD_SetFeature_ HidD_SetFeature;
+	static HidD_GetFeature_ HidD_GetFeature;
+	static HidD_GetIndexedString_ HidD_GetIndexedString;
+	static HidD_GetPreparsedData_ HidD_GetPreparsedData;
+	static HidD_FreePreparsedData_ HidD_FreePreparsedData;
+	static HidP_GetCaps_ HidP_GetCaps;
+	static HidD_SetNumInputBuffers_ HidD_SetNumInputBuffers;
+
+	static HMODULE lib_handle = NULL;
+	static BOOLEAN initialized = FALSE;
+#endif /* HIDAPI_USE_DDK */
+
+struct hid_device_ {
+		HANDLE device_handle;
+		BOOL blocking;
+		USHORT output_report_length;
+		size_t input_report_length;
+		void *last_error_str;
+		DWORD last_error_num;
+		BOOL read_pending;
+		char *read_buf;
+		OVERLAPPED ol;
+};
+
+static hid_device *new_hid_device()
+{
+	hid_device *dev = (hid_device*) calloc(1, sizeof(hid_device));
+	dev->device_handle = INVALID_HANDLE_VALUE;
+	dev->blocking = TRUE;
+	dev->output_report_length = 0;
+	dev->input_report_length = 0;
+	dev->last_error_str = NULL;
+	dev->last_error_num = 0;
+	dev->read_pending = FALSE;
+	dev->read_buf = NULL;
+	memset(&dev->ol, 0, sizeof(dev->ol));
+	dev->ol.hEvent = CreateEvent(NULL, FALSE, FALSE /*initial state f=nonsignaled*/, NULL);
+
+	return dev;
+}
+
+static void free_hid_device(hid_device *dev)
+{
+	CloseHandle(dev->ol.hEvent);
+	CloseHandle(dev->device_handle);
+	LocalFree(dev->last_error_str);
+	free(dev->read_buf);
+	free(dev);
+}
+
+static void register_error(hid_device *device, const char *op)
+{
+	WCHAR *ptr, *msg;
+
+	FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
+		FORMAT_MESSAGE_FROM_SYSTEM |
+		FORMAT_MESSAGE_IGNORE_INSERTS,
+		NULL,
+		GetLastError(),
+		MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+		(LPVOID)&msg, 0/*sz*/,
+		NULL);
+
+	/* Get rid of the CR and LF that FormatMessage() sticks at the
+	   end of the message. Thanks Microsoft! */
+	ptr = msg;
+	while (*ptr) {
+		if (*ptr == '\r') {
+			*ptr = 0x0000;
+			break;
+		}
+		ptr++;
+	}
+
+	/* Store the message off in the Device entry so that
+	   the hid_error() function can pick it up. */
+	LocalFree(device->last_error_str);
+	device->last_error_str = msg;
+}
+
+#ifndef HIDAPI_USE_DDK
+static int lookup_functions()
+{
+	lib_handle = LoadLibraryA("hid.dll");
+	if (lib_handle) {
+#define RESOLVE(x) x = (x##_)GetProcAddress(lib_handle, #x); if (!x) return -1;
+		RESOLVE(HidD_GetAttributes);
+		RESOLVE(HidD_GetSerialNumberString);
+		RESOLVE(HidD_GetManufacturerString);
+		RESOLVE(HidD_GetProductString);
+		RESOLVE(HidD_SetFeature);
+		RESOLVE(HidD_GetFeature);
+		RESOLVE(HidD_GetIndexedString);
+		RESOLVE(HidD_GetPreparsedData);
+		RESOLVE(HidD_FreePreparsedData);
+		RESOLVE(HidP_GetCaps);
+		RESOLVE(HidD_SetNumInputBuffers);
+#undef RESOLVE
+	}
+	else
+		return -1;
+
+	return 0;
+}
+#endif
+
+static HANDLE open_device(const char *path, BOOL enumerate)
+{
+	HANDLE handle;
+	DWORD desired_access = (enumerate)? 0: (GENERIC_WRITE | GENERIC_READ);
+	DWORD share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
+
+	handle = CreateFileA(path,
+		desired_access,
+		share_mode,
+		NULL,
+		OPEN_EXISTING,
+		FILE_FLAG_OVERLAPPED,/*FILE_ATTRIBUTE_NORMAL,*/
+		0);
+
+	return handle;
+}
+
+int HID_API_EXPORT hid_init(void)
+{
+#ifndef HIDAPI_USE_DDK
+	if (!initialized) {
+		if (lookup_functions() < 0) {
+			hid_exit();
+			return -1;
+		}
+		initialized = TRUE;
+	}
+#endif
+	return 0;
+}
+
+int HID_API_EXPORT hid_exit(void)
+{
+#ifndef HIDAPI_USE_DDK
+	if (lib_handle)
+		FreeLibrary(lib_handle);
+	lib_handle = NULL;
+	initialized = FALSE;
+#endif
+	return 0;
+}
+
+struct hid_device_info HID_API_EXPORT * HID_API_CALL hid_enumerate(unsigned short vendor_id, unsigned short product_id)
+{
+	BOOL res;
+	struct hid_device_info *root = NULL; /* return object */
+	struct hid_device_info *cur_dev = NULL;
+
+	/* Windows objects for interacting with the driver. */
+	GUID InterfaceClassGuid = {0x4d1e55b2, 0xf16f, 0x11cf, {0x88, 0xcb, 0x00, 0x11, 0x11, 0x00, 0x00, 0x30} };
+	SP_DEVINFO_DATA devinfo_data;
+	SP_DEVICE_INTERFACE_DATA device_interface_data;
+	SP_DEVICE_INTERFACE_DETAIL_DATA_A *device_interface_detail_data = NULL;
+	HDEVINFO device_info_set = INVALID_HANDLE_VALUE;
+	int device_index = 0;
+	int i;
+
+	if (hid_init() < 0)
+		return NULL;
+
+	/* Initialize the Windows objects. */
+	memset(&devinfo_data, 0x0, sizeof(devinfo_data));
+	devinfo_data.cbSize = sizeof(SP_DEVINFO_DATA);
+	device_interface_data.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
+
+	/* Get information for all the devices belonging to the HID class. */
+	device_info_set = SetupDiGetClassDevsA(&InterfaceClassGuid, NULL, NULL, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
+
+	/* Iterate over each device in the HID class, looking for the right one. */
+
+	for (;;) {
+		HANDLE write_handle = INVALID_HANDLE_VALUE;
+		DWORD required_size = 0;
+		HIDD_ATTRIBUTES attrib;
+
+		res = SetupDiEnumDeviceInterfaces(device_info_set,
+			NULL,
+			&InterfaceClassGuid,
+			device_index,
+			&device_interface_data);
+
+		if (!res) {
+			/* A return of FALSE from this function means that
+			   there are no more devices. */
+			break;
+		}
+
+		/* Call with 0-sized detail size, and let the function
+		   tell us how long the detail struct needs to be. The
+		   size is put in &required_size. */
+		res = SetupDiGetDeviceInterfaceDetailA(device_info_set,
+			&device_interface_data,
+			NULL,
+			0,
+			&required_size,
+			NULL);
+
+		/* Allocate a long enough structure for device_interface_detail_data. */
+		device_interface_detail_data = (SP_DEVICE_INTERFACE_DETAIL_DATA_A*) malloc(required_size);
+		device_interface_detail_data->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_A);
+
+		/* Get the detailed data for this device. The detail data gives us
+		   the device path for this device, which is then passed into
+		   CreateFile() to get a handle to the device. */
+		res = SetupDiGetDeviceInterfaceDetailA(device_info_set,
+			&device_interface_data,
+			device_interface_detail_data,
+			required_size,
+			NULL,
+			NULL);
+
+		if (!res) {
+			/* register_error(dev, "Unable to call SetupDiGetDeviceInterfaceDetail");
+			   Continue to the next device. */
+			goto cont;
+		}
+
+		/* Make sure this device is of Setup Class "HIDClass" and has a
+		   driver bound to it. */
+		for (i = 0; ; i++) {
+			char driver_name[256];
+
+			/* Populate devinfo_data. This function will return failure
+			   when there are no more interfaces left. */
+			res = SetupDiEnumDeviceInfo(device_info_set, i, &devinfo_data);
+			if (!res)
+				goto cont;
+
+			res = SetupDiGetDeviceRegistryPropertyA(device_info_set, &devinfo_data,
+			               SPDRP_CLASS, NULL, (PBYTE)driver_name, sizeof(driver_name), NULL);
+			if (!res)
+				goto cont;
+
+			if (strcmp(driver_name, "HIDClass") == 0) {
+				/* See if there's a driver bound. */
+				res = SetupDiGetDeviceRegistryPropertyA(device_info_set, &devinfo_data,
+				           SPDRP_DRIVER, NULL, (PBYTE)driver_name, sizeof(driver_name), NULL);
+				if (res)
+					break;
+			}
+		}
+
+		//wprintf(L"HandleName: %s\n", device_interface_detail_data->DevicePath);
+
+		/* Open a handle to the device */
+		write_handle = open_device(device_interface_detail_data->DevicePath, TRUE);
+
+		/* Check validity of write_handle. */
+		if (write_handle == INVALID_HANDLE_VALUE) {
+			/* Unable to open the device. */
+			//register_error(dev, "CreateFile");
+			goto cont_close;
+		}
+
+
+		/* Get the Vendor ID and Product ID for this device. */
+		attrib.Size = sizeof(HIDD_ATTRIBUTES);
+		HidD_GetAttributes(write_handle, &attrib);
+		//wprintf(L"Product/Vendor: %x %x\n", attrib.ProductID, attrib.VendorID);
+
+		/* Check the VID/PID to see if we should add this
+		   device to the enumeration list. */
+		if ((vendor_id == 0x0 || attrib.VendorID == vendor_id) &&
+		    (product_id == 0x0 || attrib.ProductID == product_id)) {
+
+			#define WSTR_LEN 512
+			const char *str;
+			struct hid_device_info *tmp;
+			PHIDP_PREPARSED_DATA pp_data = NULL;
+			HIDP_CAPS caps;
+			BOOLEAN res;
+			NTSTATUS nt_res;
+			wchar_t wstr[WSTR_LEN]; /* TODO: Determine Size */
+			size_t len;
+
+			/* VID/PID match. Create the record. */
+			tmp = (struct hid_device_info*) calloc(1, sizeof(struct hid_device_info));
+			if (cur_dev) {
+				cur_dev->next = tmp;
+			}
+			else {
+				root = tmp;
+			}
+			cur_dev = tmp;
+
+			/* Get the Usage Page and Usage for this device. */
+			res = HidD_GetPreparsedData(write_handle, &pp_data);
+			if (res) {
+				nt_res = HidP_GetCaps(pp_data, &caps);
+				if (nt_res == HIDP_STATUS_SUCCESS) {
+					cur_dev->usage_page = caps.UsagePage;
+					cur_dev->usage = caps.Usage;
+				}
+
+				HidD_FreePreparsedData(pp_data);
+			}
+
+			/* Fill out the record */
+			cur_dev->next = NULL;
+			str = device_interface_detail_data->DevicePath;
+			if (str) {
+				len = strlen(str);
+				cur_dev->path = (char*) calloc(len+1, sizeof(char));
+				strncpy(cur_dev->path, str, len+1);
+				cur_dev->path[len] = '\0';
+			}
+			else
+				cur_dev->path = NULL;
+
+			/* Serial Number */
+			res = HidD_GetSerialNumberString(write_handle, wstr, sizeof(wstr));
+			wstr[WSTR_LEN-1] = 0x0000;
+			if (res) {
+				cur_dev->serial_number = _wcsdup(wstr);
+			}
+
+			/* Manufacturer String */
+			res = HidD_GetManufacturerString(write_handle, wstr, sizeof(wstr));
+			wstr[WSTR_LEN-1] = 0x0000;
+			if (res) {
+				cur_dev->manufacturer_string = _wcsdup(wstr);
+			}
+
+			/* Product String */
+			res = HidD_GetProductString(write_handle, wstr, sizeof(wstr));
+			wstr[WSTR_LEN-1] = 0x0000;
+			if (res) {
+				cur_dev->product_string = _wcsdup(wstr);
+			}
+
+			/* VID/PID */
+			cur_dev->vendor_id = attrib.VendorID;
+			cur_dev->product_id = attrib.ProductID;
+
+			/* Release Number */
+			cur_dev->release_number = attrib.VersionNumber;
+
+			/* Interface Number. It can sometimes be parsed out of the path
+			   on Windows if a device has multiple interfaces. See
+			   http://msdn.microsoft.com/en-us/windows/hardware/gg487473 or
+			   search for "Hardware IDs for HID Devices" at MSDN. If it's not
+			   in the path, it's set to -1. */
+			cur_dev->interface_number = -1;
+			if (cur_dev->path) {
+				char *interface_component = strstr(cur_dev->path, "&mi_");
+				if (interface_component) {
+					char *hex_str = interface_component + 4;
+					char *endptr = NULL;
+					cur_dev->interface_number = strtol(hex_str, &endptr, 16);
+					if (endptr == hex_str) {
+						/* The parsing failed. Set interface_number to -1. */
+						cur_dev->interface_number = -1;
+					}
+				}
+			}
+		}
+
+cont_close:
+		CloseHandle(write_handle);
+cont:
+		/* We no longer need the detail data. It can be freed */
+		free(device_interface_detail_data);
+
+		device_index++;
+
+	}
+
+	/* Close the device information handle. */
+	SetupDiDestroyDeviceInfoList(device_info_set);
+
+	return root;
+
+}
+
+void  HID_API_EXPORT HID_API_CALL hid_free_enumeration(struct hid_device_info *devs)
+{
+	/* TODO: Merge this with the Linux version. This function is platform-independent. */
+	struct hid_device_info *d = devs;
+	while (d) {
+		struct hid_device_info *next = d->next;
+		free(d->path);
+		free(d->serial_number);
+		free(d->manufacturer_string);
+		free(d->product_string);
+		free(d);
+		d = next;
+	}
+}
+
+
+HID_API_EXPORT hid_device * HID_API_CALL hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number)
+{
+	/* TODO: Merge this functions with the Linux version. This function should be platform independent. */
+	struct hid_device_info *devs, *cur_dev;
+	const char *path_to_open = NULL;
+	hid_device *handle = NULL;
+
+	devs = hid_enumerate(vendor_id, product_id);
+	cur_dev = devs;
+	while (cur_dev) {
+		if (cur_dev->vendor_id == vendor_id &&
+		    cur_dev->product_id == product_id) {
+			if (serial_number) {
+				if (wcscmp(serial_number, cur_dev->serial_number) == 0) {
+					path_to_open = cur_dev->path;
+					break;
+				}
+			}
+			else {
+				path_to_open = cur_dev->path;
+				break;
+			}
+		}
+		cur_dev = cur_dev->next;
+	}
+
+	if (path_to_open) {
+		/* Open the device */
+		handle = hid_open_path(path_to_open);
+	}
+
+	hid_free_enumeration(devs);
+
+	return handle;
+}
+
+HID_API_EXPORT hid_device * HID_API_CALL hid_open_path(const char *path)
+{
+	hid_device *dev;
+	HIDP_CAPS caps;
+	PHIDP_PREPARSED_DATA pp_data = NULL;
+	BOOLEAN res;
+	NTSTATUS nt_res;
+
+	if (hid_init() < 0) {
+		return NULL;
+	}
+
+	dev = new_hid_device();
+
+	/* Open a handle to the device */
+	dev->device_handle = open_device(path, FALSE);
+
+	/* Check validity of write_handle. */
+	if (dev->device_handle == INVALID_HANDLE_VALUE) {
+		/* Unable to open the device. */
+		register_error(dev, "CreateFile");
+		goto err;
+	}
+
+	/* Set the Input Report buffer size to 64 reports. */
+	res = HidD_SetNumInputBuffers(dev->device_handle, 64);
+	if (!res) {
+		register_error(dev, "HidD_SetNumInputBuffers");
+		goto err;
+	}
+
+	/* Get the Input Report length for the device. */
+	res = HidD_GetPreparsedData(dev->device_handle, &pp_data);
+	if (!res) {
+		register_error(dev, "HidD_GetPreparsedData");
+		goto err;
+	}
+	nt_res = HidP_GetCaps(pp_data, &caps);
+	if (nt_res != HIDP_STATUS_SUCCESS) {
+		register_error(dev, "HidP_GetCaps");
+		goto err_pp_data;
+	}
+	dev->output_report_length = caps.OutputReportByteLength;
+	dev->input_report_length = caps.InputReportByteLength;
+	HidD_FreePreparsedData(pp_data);
+
+	dev->read_buf = (char*) malloc(dev->input_report_length);
+
+	return dev;
+
+err_pp_data:
+		HidD_FreePreparsedData(pp_data);
+err:
+		free_hid_device(dev);
+		return NULL;
+}
+
+int HID_API_EXPORT HID_API_CALL hid_write(hid_device *dev, const unsigned char *data, size_t length)
+{
+	DWORD bytes_written;
+	BOOL res;
+
+	OVERLAPPED ol;
+	unsigned char *buf;
+	memset(&ol, 0, sizeof(ol));
+
+	/* Make sure the right number of bytes are passed to WriteFile. Windows
+	   expects the number of bytes which are in the _longest_ report (plus
+	   one for the report number) bytes even if the data is a report
+	   which is shorter than that. Windows gives us this value in
+	   caps.OutputReportByteLength. If a user passes in fewer bytes than this,
+	   create a temporary buffer which is the proper size. */
+	if (length >= dev->output_report_length) {
+		/* The user passed the right number of bytes. Use the buffer as-is. */
+		buf = (unsigned char *) data;
+	} else {
+		/* Create a temporary buffer and copy the user's data
+		   into it, padding the rest with zeros. */
+		buf = (unsigned char *) malloc(dev->output_report_length);
+		memcpy(buf, data, length);
+		memset(buf + length, 0, dev->output_report_length - length);
+		length = dev->output_report_length;
+	}
+
+	res = WriteFile(dev->device_handle, buf, length, NULL, &ol);
+
+	if (!res) {
+		if (GetLastError() != ERROR_IO_PENDING) {
+			/* WriteFile() failed. Return error. */
+			register_error(dev, "WriteFile");
+			bytes_written = -1;
+			goto end_of_function;
+		}
+	}
+
+	/* Wait here until the write is done. This makes
+	   hid_write() synchronous. */
+	res = GetOverlappedResult(dev->device_handle, &ol, &bytes_written, TRUE/*wait*/);
+	if (!res) {
+		/* The Write operation failed. */
+		register_error(dev, "WriteFile");
+		bytes_written = -1;
+		goto end_of_function;
+	}
+
+end_of_function:
+	if (buf != data)
+		free(buf);
+
+	return bytes_written;
+}
+
+
+int HID_API_EXPORT HID_API_CALL hid_read_timeout(hid_device *dev, unsigned char *data, size_t length, int milliseconds)
+{
+	DWORD bytes_read = 0;
+	size_t copy_len = 0;
+	BOOL res;
+
+	/* Copy the handle for convenience. */
+	HANDLE ev = dev->ol.hEvent;
+
+	if (!dev->read_pending) {
+		/* Start an Overlapped I/O read. */
+		dev->read_pending = TRUE;
+		memset(dev->read_buf, 0, dev->input_report_length);
+		ResetEvent(ev);
+		res = ReadFile(dev->device_handle, dev->read_buf, dev->input_report_length, &bytes_read, &dev->ol);
+
+		if (!res) {
+			if (GetLastError() != ERROR_IO_PENDING) {
+				/* ReadFile() has failed.
+				   Clean up and return error. */
+				CancelIo(dev->device_handle);
+				dev->read_pending = FALSE;
+				goto end_of_function;
+			}
+		}
+	}
+
+	if (milliseconds >= 0) {
+		/* See if there is any data yet. */
+		res = WaitForSingleObject(ev, milliseconds);
+		if (res != WAIT_OBJECT_0) {
+			/* There was no data this time. Return zero bytes available,
+			   but leave the Overlapped I/O running. */
+			return 0;
+		}
+	}
+
+	/* Either WaitForSingleObject() told us that ReadFile has completed, or
+	   we are in non-blocking mode. Get the number of bytes read. The actual
+	   data has been copied to the data[] array which was passed to ReadFile(). */
+	res = GetOverlappedResult(dev->device_handle, &dev->ol, &bytes_read, TRUE/*wait*/);
+
+	/* Set pending back to false, even if GetOverlappedResult() returned error. */
+	dev->read_pending = FALSE;
+
+	if (res && bytes_read > 0) {
+		if (dev->read_buf[0] == 0x0) {
+			/* If report numbers aren't being used, but Windows sticks a report
+			   number (0x0) on the beginning of the report anyway. To make this
+			   work like the other platforms, and to make it work more like the
+			   HID spec, we'll skip over this byte. */
+			bytes_read--;
+			copy_len = length > bytes_read ? bytes_read : length;
+			memcpy(data, dev->read_buf+1, copy_len);
+		}
+		else {
+			/* Copy the whole buffer, report number and all. */
+			copy_len = length > bytes_read ? bytes_read : length;
+			memcpy(data, dev->read_buf, copy_len);
+		}
+	}
+
+end_of_function:
+	if (!res) {
+		register_error(dev, "GetOverlappedResult");
+		return -1;
+	}
+
+	return copy_len;
+}
+
+int HID_API_EXPORT HID_API_CALL hid_read(hid_device *dev, unsigned char *data, size_t length)
+{
+	return hid_read_timeout(dev, data, length, (dev->blocking)? -1: 0);
+}
+
+int HID_API_EXPORT HID_API_CALL hid_set_nonblocking(hid_device *dev, int nonblock)
+{
+	dev->blocking = !nonblock;
+	return 0; /* Success */
+}
+
+int HID_API_EXPORT HID_API_CALL hid_send_feature_report(hid_device *dev, const unsigned char *data, size_t length)
+{
+	BOOL res = HidD_SetFeature(dev->device_handle, (PVOID)data, length);
+	if (!res) {
+		register_error(dev, "HidD_SetFeature");
+		return -1;
+	}
+
+	return length;
+}
+
+
+int HID_API_EXPORT HID_API_CALL hid_get_feature_report(hid_device *dev, unsigned char *data, size_t length)
+{
+	BOOL res;
+#if 0
+	res = HidD_GetFeature(dev->device_handle, data, length);
+	if (!res) {
+		register_error(dev, "HidD_GetFeature");
+		return -1;
+	}
+	return 0; /* HidD_GetFeature() doesn't give us an actual length, unfortunately */
+#else
+	DWORD bytes_returned;
+
+	OVERLAPPED ol;
+	memset(&ol, 0, sizeof(ol));
+
+	res = DeviceIoControl(dev->device_handle,
+		IOCTL_HID_GET_FEATURE,
+		data, length,
+		data, length,
+		&bytes_returned, &ol);
+
+	if (!res) {
+		if (GetLastError() != ERROR_IO_PENDING) {
+			/* DeviceIoControl() failed. Return error. */
+			register_error(dev, "Send Feature Report DeviceIoControl");
+			return -1;
+		}
+	}
+
+	/* Wait here until the write is done. This makes
+	   hid_get_feature_report() synchronous. */
+	res = GetOverlappedResult(dev->device_handle, &ol, &bytes_returned, TRUE/*wait*/);
+	if (!res) {
+		/* The operation failed. */
+		register_error(dev, "Send Feature Report GetOverLappedResult");
+		return -1;
+	}
+
+	/* bytes_returned does not include the first byte which contains the
+	   report ID. The data buffer actually contains one more byte than
+	   bytes_returned. */
+	bytes_returned++;
+
+	return bytes_returned;
+#endif
+}
+
+void HID_API_EXPORT HID_API_CALL hid_close(hid_device *dev)
+{
+	if (!dev)
+		return;
+	CancelIo(dev->device_handle);
+	free_hid_device(dev);
+}
+
+int HID_API_EXPORT_CALL HID_API_CALL hid_get_manufacturer_string(hid_device *dev, wchar_t *string, size_t maxlen)
+{
+	BOOL res;
+
+	res = HidD_GetManufacturerString(dev->device_handle, string, sizeof(wchar_t) * MIN(maxlen, MAX_STRING_WCHARS));
+	if (!res) {
+		register_error(dev, "HidD_GetManufacturerString");
+		return -1;
+	}
+
+	return 0;
+}
+
+int HID_API_EXPORT_CALL HID_API_CALL hid_get_product_string(hid_device *dev, wchar_t *string, size_t maxlen)
+{
+	BOOL res;
+
+	res = HidD_GetProductString(dev->device_handle, string, sizeof(wchar_t) * MIN(maxlen, MAX_STRING_WCHARS));
+	if (!res) {
+		register_error(dev, "HidD_GetProductString");
+		return -1;
+	}
+
+	return 0;
+}
+
+int HID_API_EXPORT_CALL HID_API_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *string, size_t maxlen)
+{
+	BOOL res;
+
+	res = HidD_GetSerialNumberString(dev->device_handle, string, sizeof(wchar_t) * MIN(maxlen, MAX_STRING_WCHARS));
+	if (!res) {
+		register_error(dev, "HidD_GetSerialNumberString");
+		return -1;
+	}
+
+	return 0;
+}
+
+int HID_API_EXPORT_CALL HID_API_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen)
+{
+	BOOL res;
+
+	res = HidD_GetIndexedString(dev->device_handle, string_index, string, sizeof(wchar_t) * MIN(maxlen, MAX_STRING_WCHARS));
+	if (!res) {
+		register_error(dev, "HidD_GetIndexedString");
+		return -1;
+	}
+
+	return 0;
+}
+
+
+HID_API_EXPORT const wchar_t * HID_API_CALL  hid_error(hid_device *dev)
+{
+	return (wchar_t*)dev->last_error_str;
+}
+
+
+/*#define PICPGM*/
+/*#define S11*/
+#define P32
+#ifdef S11
+  unsigned short VendorID = 0xa0a0;
+	unsigned short ProductID = 0x0001;
+#endif
+
+#ifdef P32
+  unsigned short VendorID = 0x04d8;
+	unsigned short ProductID = 0x3f;
+#endif
+
+
+#ifdef PICPGM
+  unsigned short VendorID = 0x04d8;
+  unsigned short ProductID = 0x0033;
+#endif
+
+
+#if 0
+int __cdecl main(int argc, char* argv[])
+{
+	int res;
+	unsigned char buf[65];
+
+	UNREFERENCED_PARAMETER(argc);
+	UNREFERENCED_PARAMETER(argv);
+
+	/* Set up the command buffer. */
+	memset(buf,0x00,sizeof(buf));
+	buf[0] = 0;
+	buf[1] = 0x81;
+
+
+	/* Open the device. */
+	int handle = open(VendorID, ProductID, L"12345");
+	if (handle < 0)
+		printf("unable to open device\n");
+
+
+	/* Toggle LED (cmd 0x80) */
+	buf[1] = 0x80;
+	res = write(handle, buf, 65);
+	if (res < 0)
+		printf("Unable to write()\n");
+
+	/* Request state (cmd 0x81) */
+	buf[1] = 0x81;
+	write(handle, buf, 65);
+	if (res < 0)
+		printf("Unable to write() (2)\n");
+
+	/* Read requested state */
+	read(handle, buf, 65);
+	if (res < 0)
+		printf("Unable to read()\n");
+
+	/* Print out the returned buffer. */
+	for (int i = 0; i < 4; i++)
+		printf("buf[%d]: %d\n", i, buf[i]);
+
+	return 0;
+}
+#endif
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
diff --git a/vendor/github.com/karalabe/usb/libs.go b/vendor/github.com/karalabe/usb/libs.go
new file mode 100644
index 000000000..6446acee9
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libs.go
@@ -0,0 +1,74 @@
+// usb - Self contained USB and HID library for Go
+// Copyright 2019 The library Authors
+//
+// This library is free software: you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License as published by the Free
+// Software Foundation, either version 3 of the License, or (at your option) any
+// later version.
+//
+// The library is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+// A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License along
+// with the library. If not, see <http://www.gnu.org/licenses/>.
+
+// +build freebsd,cgo linux,cgo darwin,!ios,cgo windows,cgo
+
+package usb
+
+/*
+#cgo CFLAGS: -I./hidapi/hidapi
+#cgo CFLAGS: -I./libusb/libusb
+#cgo CFLAGS: -DDEFAULT_VISIBILITY=""
+#cgo CFLAGS: -DPOLL_NFDS_TYPE=int
+
+#cgo linux CFLAGS: -DOS_LINUX -D_GNU_SOURCE -DHAVE_SYS_TIME_H
+#cgo linux,!android LDFLAGS: -lrt
+#cgo darwin CFLAGS: -DOS_DARWIN -DHAVE_SYS_TIME_H
+#cgo darwin LDFLAGS: -framework CoreFoundation -framework IOKit -lobjc
+#cgo windows CFLAGS: -DOS_WINDOWS
+#cgo windows LDFLAGS: -lsetupapi
+#cgo freebsd CFLAGS: -DOS_FREEBSD
+#cgo freebsd LDFLAGS: -lusb
+#cgo openbsd CFLAGS: -DOS_OPENBSD
+
+#if defined(OS_LINUX) || defined(OS_DARWIN) || defined(DOS_FREEBSD) || defined(OS_OPENBSD)
+	#include <poll.h>
+	#include "os/threads_posix.c"
+	#include "os/poll_posix.c"
+#elif defined(OS_WINDOWS)
+	#include "os/poll_windows.c"
+	#include "os/threads_windows.c"
+#endif
+
+#ifdef OS_LINUX
+	#include "os/linux_usbfs.c"
+	#include "os/linux_netlink.c"
+	#include "hidapi/libusb/hid.c"
+#elif OS_DARWIN
+	#include "os/darwin_usb.c"
+	#include "hidapi/mac/hid.c"
+#elif OS_WINDOWS
+	#include "os/windows_nt_common.c"
+	#include "os/windows_usbdk.c"
+	#include "os/windows_winusb.c"
+	#include "hidapi/windows/hid.c"
+#elif OS_FREEBSD
+	#include <libusb.h>
+	#include "hidapi/libusb/hid.c"
+#elif DOS_OPENBSD
+	#include "os/openbsd_usb.c"
+	#include "hidapi/libusb/hid.c"
+#endif
+
+#ifndef OS_FREEBSD
+	#include "core.c"
+	#include "descriptor.c"
+	#include "hotplug.c"
+	#include "io.c"
+	#include "strerror.c"
+	#include "sync.c"
+#endif
+*/
+import "C"
diff --git a/vendor/github.com/karalabe/usb/libusb/AUTHORS b/vendor/github.com/karalabe/usb/libusb/AUTHORS
new file mode 100644
index 000000000..e90ad9bb2
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/AUTHORS
@@ -0,0 +1,119 @@
+Copyright © 2001 Johannes Erdfelt <johannes@erdfelt.com>
+Copyright © 2007-2009 Daniel Drake <dsd@gentoo.org>
+Copyright © 2010-2012 Peter Stuge <peter@stuge.se>
+Copyright © 2008-2016 Nathan Hjelm <hjelmn@users.sourceforge.net>
+Copyright © 2009-2013 Pete Batard <pete@akeo.ie>
+Copyright © 2009-2013 Ludovic Rousseau <ludovic.rousseau@gmail.com>
+Copyright © 2010-2012 Michael Plante <michael.plante@gmail.com>
+Copyright © 2011-2013 Hans de Goede <hdegoede@redhat.com>
+Copyright © 2012-2013 Martin Pieuchot <mpi@openbsd.org>
+Copyright © 2012-2013 Toby Gray <toby.gray@realvnc.com>
+Copyright © 2013-2018 Chris Dickens <christopher.a.dickens@gmail.com>
+
+Other contributors:
+Adrian Bunk
+Akshay Jaggi
+Alan Ott
+Alan Stern
+Alex Vatchenko
+Andrew Fernandes
+Andy Chunyu
+Andy McFadden
+Angus Gratton
+Anil Nair
+Anthony Clay
+Antonio Ospite
+Artem Egorkine
+Aurelien Jarno
+Bastien Nocera
+Bei Zhang
+Benjamin Dobell
+Brent Rector
+Carl Karsten
+Christophe Zeitouny
+Colin Walters
+Dave Camarillo
+David Engraf
+David Moore
+Davidlohr Bueso
+Dmitry Fleytman
+Doug Johnston
+Evan Hunter
+Federico Manzan
+Felipe Balbi
+Florian Albrechtskirchinger
+Francesco Montorsi
+Francisco Facioni
+Gaurav Gupta
+Graeme Gill
+Gustavo Zacarias
+Hans Ulrich Niedermann
+Hector Martin
+Hoi-Ho Chan
+Ilya Konstantinov
+Jakub Klama
+James Hanko
+Jeffrey Nichols
+Johann Richard
+John Sheu
+Jonathon Jongsma
+Joost Muller
+Josh Gao
+Joshua Blake
+Justin Bischoff
+KIMURA Masaru
+Karsten Koenig
+Konrad Rzepecki
+Kuangye Guo
+Lars Kanis
+Lars Wirzenius
+Lei Chen
+Luca Longinotti
+Marcus Meissner
+Markus Heidelberg
+Martin Ettl
+Martin Koegler
+Matthew Stapleton
+Matthias Bolte
+Michel Zou
+Mike Frysinger
+Mikhail Gusarov
+Morgan Leborgne
+Moritz Fischer
+Ларионов Даниил
+Nicholas Corgan
+Omri Iluz
+Orin Eman
+Paul Fertser
+Pekka Nikander
+Rob Walker
+Romain Vimont
+Roman Kalashnikov
+Sameeh Jubran
+Sean McBride
+Sebastian Pipping
+Sergey Serb
+Simon Haggett
+Simon Newton
+Stefan Agner
+Stefan Tauner
+Steinar H. Gunderson
+Thomas Röfer
+Tim Hutt
+Tim Roberts
+Tobias Klauser
+Toby Peterson
+Tormod Volden
+Trygve Laugstøl
+Uri Lublin
+Vasily Khoruzhick
+Vegard Storheil Eriksen
+Venkatesh Shukla
+Vianney le Clément de Saint-Marcq
+Victor Toso
+Vitali Lovich
+William Skellenger
+Xiaofan Chen
+Zoltán Kovács
+Роман Донченко
+parafin
diff --git a/vendor/github.com/karalabe/usb/libusb/COPYING b/vendor/github.com/karalabe/usb/libusb/COPYING
new file mode 100644
index 000000000..5ab7695ab
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/COPYING
@@ -0,0 +1,504 @@
+		  GNU LESSER GENERAL PUBLIC LICENSE
+		       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+		  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+			    NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
+
+
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/config.h b/vendor/github.com/karalabe/usb/libusb/libusb/config.h
new file mode 100644
index 000000000..e004f03cd
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/config.h
@@ -0,0 +1,3 @@
+#ifndef CONFIG_H
+#define CONFIG_H
+#endif
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/core.c b/vendor/github.com/karalabe/usb/libusb/libusb/core.c
new file mode 100644
index 000000000..50f92f6b1
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/core.c
@@ -0,0 +1,2579 @@
+/* -*- Mode: C; indent-tabs-mode:t ; c-basic-offset:8 -*- */
+/*
+ * Core functions for libusb
+ * Copyright © 2012-2013 Nathan Hjelm <hjelmn@cs.unm.edu>
+ * Copyright © 2007-2008 Daniel Drake <dsd@gentoo.org>
+ * Copyright © 2001 Johannes Erdfelt <johannes@erdfelt.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "config.h"
+
+#include <errno.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#ifdef HAVE_SYSLOG_H
+#include <syslog.h>
+#endif
+
+#ifdef __ANDROID__
+#include <android/log.h>
+#endif
+
+#include "libusbi.h"
+#include "hotplug.h"
+
+struct libusb_context *usbi_default_context = NULL;
+static const struct libusb_version libusb_version_internal =
+	{ LIBUSB_MAJOR, LIBUSB_MINOR, LIBUSB_MICRO, LIBUSB_NANO,
+	  LIBUSB_RC, "http://libusb.info" };
+static int default_context_refcnt = 0;
+static usbi_mutex_static_t default_context_lock = USBI_MUTEX_INITIALIZER;
+static struct timespec timestamp_origin = { 0, 0 };
+
+usbi_mutex_static_t active_contexts_lock = USBI_MUTEX_INITIALIZER;
+struct list_head active_contexts_list;
+
+/**
+ * \mainpage libusb-1.0 API Reference
+ *
+ * \section intro Introduction
+ *
+ * libusb is an open source library that allows you to communicate with USB
+ * devices from userspace. For more info, see the
+ * <a href="http://libusb.info">libusb homepage</a>.
+ *
+ * This documentation is aimed at application developers wishing to
+ * communicate with USB peripherals from their own software. After reviewing
+ * this documentation, feedback and questions can be sent to the
+ * <a href="http://mailing-list.libusb.info">libusb-devel mailing list</a>.
+ *
+ * This documentation assumes knowledge of how to operate USB devices from
+ * a software standpoint (descriptors, configurations, interfaces, endpoints,
+ * control/bulk/interrupt/isochronous transfers, etc). Full information
+ * can be found in the <a href="http://www.usb.org/developers/docs/">USB 3.0
+ * Specification</a> which is available for free download. You can probably
+ * find less verbose introductions by searching the web.
+ *
+ * \section API Application Programming Interface (API)
+ *
+ * See the \ref libusb_api page for a complete list of the libusb functions.
+ *
+ * \section features Library features
+ *
+ * - All transfer types supported (control/bulk/interrupt/isochronous)
+ * - 2 transfer interfaces:
+ *    -# Synchronous (simple)
+ *    -# Asynchronous (more complicated, but more powerful)
+ * - Thread safe (although the asynchronous interface means that you
+ *   usually won't need to thread)
+ * - Lightweight with lean API
+ * - Compatible with libusb-0.1 through the libusb-compat-0.1 translation layer
+ * - Hotplug support (on some platforms). See \ref libusb_hotplug.
+ *
+ * \section gettingstarted Getting Started
+ *
+ * To begin reading the API documentation, start with the Modules page which
+ * links to the different categories of libusb's functionality.
+ *
+ * One decision you will have to make is whether to use the synchronous
+ * or the asynchronous data transfer interface. The \ref libusb_io documentation
+ * provides some insight into this topic.
+ *
+ * Some example programs can be found in the libusb source distribution under
+ * the "examples" subdirectory. The libusb homepage includes a list of
+ * real-life project examples which use libusb.
+ *
+ * \section errorhandling Error handling
+ *
+ * libusb functions typically return 0 on success or a negative error code
+ * on failure. These negative error codes relate to LIBUSB_ERROR constants
+ * which are listed on the \ref libusb_misc "miscellaneous" documentation page.
+ *
+ * \section msglog Debug message logging
+ *
+ * libusb uses stderr for all logging. By default, logging is set to NONE,
+ * which means that no output will be produced. However, unless the library
+ * has been compiled with logging disabled, then any application calls to
+ * libusb_set_option(ctx, LIBUSB_OPTION_LOG_LEVEL, level), or the setting of the
+ * environmental variable LIBUSB_DEBUG outside of the application, can result
+ * in logging being produced. Your application should therefore not close
+ * stderr, but instead direct it to the null device if its output is
+ * undesirable.
+ *
+ * The libusb_set_option(ctx, LIBUSB_OPTION_LOG_LEVEL, level) function can be
+ * used to enable logging of certain messages. Under standard configuration,
+ * libusb doesn't really log much so you are advised to use this function
+ * to enable all error/warning/ informational messages. It will help debug
+ * problems with your software.
+ *
+ * The logged messages are unstructured. There is no one-to-one correspondence
+ * between messages being logged and success or failure return codes from
+ * libusb functions. There is no format to the messages, so you should not
+ * try to capture or parse them. They are not and will not be localized.
+ * These messages are not intended to being passed to your application user;
+ * instead, you should interpret the error codes returned from libusb functions
+ * and provide appropriate notification to the user. The messages are simply
+ * there to aid you as a programmer, and if you're confused because you're
+ * getting a strange error code from a libusb function, enabling message
+ * logging may give you a suitable explanation.
+ *
+ * The LIBUSB_DEBUG environment variable can be used to enable message logging
+ * at run-time. This environment variable should be set to a log level number,
+ * which is interpreted the same as the
+ * libusb_set_option(ctx, LIBUSB_OPTION_LOG_LEVEL, level) parameter. When this
+ * environment variable is set, the message logging verbosity level is fixed
+ * and libusb_set_option(ctx, LIBUSB_OPTION_LOG_LEVEL, level) effectively does
+ * nothing.
+ *
+ * libusb can be compiled without any logging functions, useful for embedded
+ * systems. In this case, libusb_set_option(ctx, LIBUSB_OPTION_LOG_LEVEL, level)
+ * and the LIBUSB_DEBUG environment variable have no effects.
+ *
+ * libusb can also be compiled with verbose debugging messages always. When
+ * the library is compiled in this way, all messages of all verbosities are
+ * always logged. libusb_set_option(ctx, LIBUSB_OPTION_LOG_LEVEL, level) and
+ * the LIBUSB_DEBUG environment variable have no effects.
+ *
+ * \section remarks Other remarks
+ *
+ * libusb does have imperfections. The \ref libusb_caveats "caveats" page attempts
+ * to document these.
+ */
+
+/**
+ * \page libusb_caveats Caveats
+ *
+ * \section fork Fork considerations
+ *
+ * libusb is <em>not</em> designed to work across fork() calls. Depending on
+ * the platform, there may be resources in the parent process that are not
+ * available to the child (e.g. the hotplug monitor thread on Linux). In
+ * addition, since the parent and child will share libusb's internal file
+ * descriptors, using libusb in any way from the child could cause the parent
+ * process's \ref libusb_context to get into an inconsistent state.
+ *
+ * On Linux, libusb's file descriptors will be marked as CLOEXEC, which means
+ * that it is safe to fork() and exec() without worrying about the child
+ * process needing to clean up state or having access to these file descriptors.
+ * Other platforms may not be so forgiving, so consider yourself warned!
+ *
+ * \section devresets Device resets
+ *
+ * The libusb_reset_device() function allows you to reset a device. If your
+ * program has to call such a function, it should obviously be aware that
+ * the reset will cause device state to change (e.g. register values may be
+ * reset).
+ *
+ * The problem is that any other program could reset the device your program
+ * is working with, at any time. libusb does not offer a mechanism to inform
+ * you when this has happened, so if someone else resets your device it will
+ * not be clear to your own program why the device state has changed.
+ *
+ * Ultimately, this is a limitation of writing drivers in userspace.
+ * Separation from the USB stack in the underlying kernel makes it difficult
+ * for the operating system to deliver such notifications to your program.
+ * The Linux kernel USB stack allows such reset notifications to be delivered
+ * to in-kernel USB drivers, but it is not clear how such notifications could
+ * be delivered to second-class drivers that live in userspace.
+ *
+ * \section blockonly Blocking-only functionality
+ *
+ * The functionality listed below is only available through synchronous,
+ * blocking functions. There are no asynchronous/non-blocking alternatives,
+ * and no clear ways of implementing these.
+ *
+ * - Configuration activation (libusb_set_configuration())
+ * - Interface/alternate setting activation (libusb_set_interface_alt_setting())
+ * - Releasing of interfaces (libusb_release_interface())
+ * - Clearing of halt/stall condition (libusb_clear_halt())
+ * - Device resets (libusb_reset_device())
+ *
+ * \section configsel Configuration selection and handling
+ *
+ * When libusb presents a device handle to an application, there is a chance
+ * that the corresponding device may be in unconfigured state. For devices
+ * with multiple configurations, there is also a chance that the configuration
+ * currently selected is not the one that the application wants to use.
+ *
+ * The obvious solution is to add a call to libusb_set_configuration() early
+ * on during your device initialization routines, but there are caveats to
+ * be aware of:
+ * -# If the device is already in the desired configuration, calling
+ *    libusb_set_configuration() using the same configuration value will cause
+ *    a lightweight device reset. This may not be desirable behaviour.
+ * -# In the case where the desired configuration is already active, libusb
+ *    may not even be able to perform a lightweight device reset. For example,
+ *    take my USB keyboard with fingerprint reader: I'm interested in driving
+ *    the fingerprint reader interface through libusb, but the kernel's
+ *    USB-HID driver will almost always have claimed the keyboard interface.
+ *    Because the kernel has claimed an interface, it is not even possible to
+ *    perform the lightweight device reset, so libusb_set_configuration() will
+ *    fail. (Luckily the device in question only has a single configuration.)
+ * -# libusb will be unable to set a configuration if other programs or
+ *    drivers have claimed interfaces. In particular, this means that kernel
+ *    drivers must be detached from all the interfaces before
+ *    libusb_set_configuration() may succeed.
+ *
+ * One solution to some of the above problems is to consider the currently
+ * active configuration. If the configuration we want is already active, then
+ * we don't have to select any configuration:
+\code
+cfg = -1;
+libusb_get_configuration(dev, &cfg);
+if (cfg != desired)
+	libusb_set_configuration(dev, desired);
+\endcode
+ *
+ * This is probably suitable for most scenarios, but is inherently racy:
+ * another application or driver may change the selected configuration
+ * <em>after</em> the libusb_get_configuration() call.
+ *
+ * Even in cases where libusb_set_configuration() succeeds, consider that other
+ * applications or drivers may change configuration after your application
+ * calls libusb_set_configuration().
+ *
+ * One possible way to lock your device into a specific configuration is as
+ * follows:
+ * -# Set the desired configuration (or use the logic above to realise that
+ *    it is already in the desired configuration)
+ * -# Claim the interface that you wish to use
+ * -# Check that the currently active configuration is the one that you want
+ *    to use.
+ *
+ * The above method works because once an interface is claimed, no application
+ * or driver is able to select another configuration.
+ *
+ * \section earlycomp Early transfer completion
+ *
+ * NOTE: This section is currently Linux-centric. I am not sure if any of these
+ * considerations apply to Darwin or other platforms.
+ *
+ * When a transfer completes early (i.e. when less data is received/sent in
+ * any one packet than the transfer buffer allows for) then libusb is designed
+ * to terminate the transfer immediately, not transferring or receiving any
+ * more data unless other transfers have been queued by the user.
+ *
+ * On legacy platforms, libusb is unable to do this in all situations. After
+ * the incomplete packet occurs, "surplus" data may be transferred. For recent
+ * versions of libusb, this information is kept (the data length of the
+ * transfer is updated) and, for device-to-host transfers, any surplus data was
+ * added to the buffer. Still, this is not a nice solution because it loses the
+ * information about the end of the short packet, and the user probably wanted
+ * that surplus data to arrive in the next logical transfer.
+ *
+ * \section zlp Zero length packets
+ *
+ * - libusb is able to send a packet of zero length to an endpoint simply by
+ * submitting a transfer of zero length.
+ * - The \ref libusb_transfer_flags::LIBUSB_TRANSFER_ADD_ZERO_PACKET
+ * "LIBUSB_TRANSFER_ADD_ZERO_PACKET" flag is currently only supported on Linux.
+ */
+
+/**
+ * \page libusb_contexts Contexts
+ *
+ * It is possible that libusb may be used simultaneously from two independent
+ * libraries linked into the same executable. For example, if your application
+ * has a plugin-like system which allows the user to dynamically load a range
+ * of modules into your program, it is feasible that two independently
+ * developed modules may both use libusb.
+ *
+ * libusb is written to allow for these multiple user scenarios. The two
+ * "instances" of libusb will not interfere: libusb_set_option() calls
+ * from one user will not affect the same settings for other users, other
+ * users can continue using libusb after one of them calls libusb_exit(), etc.
+ *
+ * This is made possible through libusb's <em>context</em> concept. When you
+ * call libusb_init(), you are (optionally) given a context. You can then pass
+ * this context pointer back into future libusb functions.
+ *
+ * In order to keep things simple for more simplistic applications, it is
+ * legal to pass NULL to all functions requiring a context pointer (as long as
+ * you're sure no other code will attempt to use libusb from the same process).
+ * When you pass NULL, the default context will be used. The default context
+ * is created the first time a process calls libusb_init() when no other
+ * context is alive. Contexts are destroyed during libusb_exit().
+ *
+ * The default context is reference-counted and can be shared. That means that
+ * if libusb_init(NULL) is called twice within the same process, the two
+ * users end up sharing the same context. The deinitialization and freeing of
+ * the default context will only happen when the last user calls libusb_exit().
+ * In other words, the default context is created and initialized when its
+ * reference count goes from 0 to 1, and is deinitialized and destroyed when
+ * its reference count goes from 1 to 0.
+ *
+ * You may be wondering why only a subset of libusb functions require a
+ * context pointer in their function definition. Internally, libusb stores
+ * context pointers in other objects (e.g. libusb_device instances) and hence
+ * can infer the context from those objects.
+ */
+
+ /**
+  * \page libusb_api Application Programming Interface
+  *
+  * This is the complete list of libusb functions, structures and
+  * enumerations in alphabetical order.
+  *
+  * \section Functions
+  * - libusb_alloc_streams()
+  * - libusb_alloc_transfer()
+  * - libusb_attach_kernel_driver()
+  * - libusb_bulk_transfer()
+  * - libusb_cancel_transfer()
+  * - libusb_claim_interface()
+  * - libusb_clear_halt()
+  * - libusb_close()
+  * - libusb_control_transfer()
+  * - libusb_control_transfer_get_data()
+  * - libusb_control_transfer_get_setup()
+  * - libusb_cpu_to_le16()
+  * - libusb_detach_kernel_driver()
+  * - libusb_dev_mem_alloc()
+  * - libusb_dev_mem_free()
+  * - libusb_error_name()
+  * - libusb_event_handler_active()
+  * - libusb_event_handling_ok()
+  * - libusb_exit()
+  * - libusb_fill_bulk_stream_transfer()
+  * - libusb_fill_bulk_transfer()
+  * - libusb_fill_control_setup()
+  * - libusb_fill_control_transfer()
+  * - libusb_fill_interrupt_transfer()
+  * - libusb_fill_iso_transfer()
+  * - libusb_free_bos_descriptor()
+  * - libusb_free_config_descriptor()
+  * - libusb_free_container_id_descriptor()
+  * - libusb_free_device_list()
+  * - libusb_free_pollfds()
+  * - libusb_free_ss_endpoint_companion_descriptor()
+  * - libusb_free_ss_usb_device_capability_descriptor()
+  * - libusb_free_streams()
+  * - libusb_free_transfer()
+  * - libusb_free_usb_2_0_extension_descriptor()
+  * - libusb_get_active_config_descriptor()
+  * - libusb_get_bos_descriptor()
+  * - libusb_get_bus_number()
+  * - libusb_get_config_descriptor()
+  * - libusb_get_config_descriptor_by_value()
+  * - libusb_get_configuration()
+  * - libusb_get_container_id_descriptor()
+  * - libusb_get_descriptor()
+  * - libusb_get_device()
+  * - libusb_get_device_address()
+  * - libusb_get_device_descriptor()
+  * - libusb_get_device_list()
+  * - libusb_get_device_speed()
+  * - libusb_get_iso_packet_buffer()
+  * - libusb_get_iso_packet_buffer_simple()
+  * - libusb_get_max_iso_packet_size()
+  * - libusb_get_max_packet_size()
+  * - libusb_get_next_timeout()
+  * - libusb_get_parent()
+  * - libusb_get_pollfds()
+  * - libusb_get_port_number()
+  * - libusb_get_port_numbers()
+  * - libusb_get_port_path()
+  * - libusb_get_ss_endpoint_companion_descriptor()
+  * - libusb_get_ss_usb_device_capability_descriptor()
+  * - libusb_get_string_descriptor()
+  * - libusb_get_string_descriptor_ascii()
+  * - libusb_get_usb_2_0_extension_descriptor()
+  * - libusb_get_version()
+  * - libusb_handle_events()
+  * - libusb_handle_events_completed()
+  * - libusb_handle_events_locked()
+  * - libusb_handle_events_timeout()
+  * - libusb_handle_events_timeout_completed()
+  * - libusb_has_capability()
+  * - libusb_hotplug_deregister_callback()
+  * - libusb_hotplug_register_callback()
+  * - libusb_init()
+  * - libusb_interrupt_event_handler()
+  * - libusb_interrupt_transfer()
+  * - libusb_kernel_driver_active()
+  * - libusb_lock_events()
+  * - libusb_lock_event_waiters()
+  * - libusb_open()
+  * - libusb_open_device_with_vid_pid()
+  * - libusb_pollfds_handle_timeouts()
+  * - libusb_ref_device()
+  * - libusb_release_interface()
+  * - libusb_reset_device()
+  * - libusb_set_auto_detach_kernel_driver()
+  * - libusb_set_configuration()
+  * - libusb_set_debug()
+  * - libusb_set_interface_alt_setting()
+  * - libusb_set_iso_packet_lengths()
+  * - libusb_set_option()
+  * - libusb_setlocale()
+  * - libusb_set_pollfd_notifiers()
+  * - libusb_strerror()
+  * - libusb_submit_transfer()
+  * - libusb_transfer_get_stream_id()
+  * - libusb_transfer_set_stream_id()
+  * - libusb_try_lock_events()
+  * - libusb_unlock_events()
+  * - libusb_unlock_event_waiters()
+  * - libusb_unref_device()
+  * - libusb_wait_for_event()
+  *
+  * \section Structures
+  * - libusb_bos_descriptor
+  * - libusb_bos_dev_capability_descriptor
+  * - libusb_config_descriptor
+  * - libusb_container_id_descriptor
+  * - \ref libusb_context
+  * - libusb_control_setup
+  * - \ref libusb_device
+  * - libusb_device_descriptor
+  * - \ref libusb_device_handle
+  * - libusb_endpoint_descriptor
+  * - libusb_interface
+  * - libusb_interface_descriptor
+  * - libusb_iso_packet_descriptor
+  * - libusb_pollfd
+  * - libusb_ss_endpoint_companion_descriptor
+  * - libusb_ss_usb_device_capability_descriptor
+  * - libusb_transfer
+  * - libusb_usb_2_0_extension_descriptor
+  * - libusb_version
+  *
+  * \section Enums
+  * - \ref libusb_bos_type
+  * - \ref libusb_capability
+  * - \ref libusb_class_code
+  * - \ref libusb_descriptor_type
+  * - \ref libusb_endpoint_direction
+  * - \ref libusb_error
+  * - \ref libusb_iso_sync_type
+  * - \ref libusb_iso_usage_type
+  * - \ref libusb_log_level
+  * - \ref libusb_option
+  * - \ref libusb_request_recipient
+  * - \ref libusb_request_type
+  * - \ref libusb_speed
+  * - \ref libusb_ss_usb_device_capability_attributes
+  * - \ref libusb_standard_request
+  * - \ref libusb_supported_speed
+  * - \ref libusb_transfer_flags
+  * - \ref libusb_transfer_status
+  * - \ref libusb_transfer_type
+  * - \ref libusb_usb_2_0_extension_attributes
+  */
+
+/**
+ * @defgroup libusb_lib Library initialization/deinitialization
+ * This page details how to initialize and deinitialize libusb. Initialization
+ * must be performed before using any libusb functionality, and similarly you
+ * must not call any libusb functions after deinitialization.
+ */
+
+/**
+ * @defgroup libusb_dev Device handling and enumeration
+ * The functionality documented below is designed to help with the following
+ * operations:
+ * - Enumerating the USB devices currently attached to the system
+ * - Choosing a device to operate from your software
+ * - Opening and closing the chosen device
+ *
+ * \section nutshell In a nutshell...
+ *
+ * The description below really makes things sound more complicated than they
+ * actually are. The following sequence of function calls will be suitable
+ * for almost all scenarios and does not require you to have such a deep
+ * understanding of the resource management issues:
+ * \code
+// discover devices
+libusb_device **list;
+libusb_device *found = NULL;
+ssize_t cnt = libusb_get_device_list(NULL, &list);
+ssize_t i = 0;
+int err = 0;
+if (cnt < 0)
+	error();
+
+for (i = 0; i < cnt; i++) {
+	libusb_device *device = list[i];
+	if (is_interesting(device)) {
+		found = device;
+		break;
+	}
+}
+
+if (found) {
+	libusb_device_handle *handle;
+
+	err = libusb_open(found, &handle);
+	if (err)
+		error();
+	// etc
+}
+
+libusb_free_device_list(list, 1);
+\endcode
+ *
+ * The two important points:
+ * - You asked libusb_free_device_list() to unreference the devices (2nd
+ *   parameter)
+ * - You opened the device before freeing the list and unreferencing the
+ *   devices
+ *
+ * If you ended up with a handle, you can now proceed to perform I/O on the
+ * device.
+ *
+ * \section devshandles Devices and device handles
+ * libusb has a concept of a USB device, represented by the
+ * \ref libusb_device opaque type. A device represents a USB device that
+ * is currently or was previously connected to the system. Using a reference
+ * to a device, you can determine certain information about the device (e.g.
+ * you can read the descriptor data).
+ *
+ * The libusb_get_device_list() function can be used to obtain a list of
+ * devices currently connected to the system. This is known as device
+ * discovery.
+ *
+ * Just because you have a reference to a device does not mean it is
+ * necessarily usable. The device may have been unplugged, you may not have
+ * permission to operate such device, or another program or driver may be
+ * using the device.
+ *
+ * When you've found a device that you'd like to operate, you must ask
+ * libusb to open the device using the libusb_open() function. Assuming
+ * success, libusb then returns you a <em>device handle</em>
+ * (a \ref libusb_device_handle pointer). All "real" I/O operations then
+ * operate on the handle rather than the original device pointer.
+ *
+ * \section devref Device discovery and reference counting
+ *
+ * Device discovery (i.e. calling libusb_get_device_list()) returns a
+ * freshly-allocated list of devices. The list itself must be freed when
+ * you are done with it. libusb also needs to know when it is OK to free
+ * the contents of the list - the devices themselves.
+ *
+ * To handle these issues, libusb provides you with two separate items:
+ * - A function to free the list itself
+ * - A reference counting system for the devices inside
+ *
+ * New devices presented by the libusb_get_device_list() function all have a
+ * reference count of 1. You can increase and decrease reference count using
+ * libusb_ref_device() and libusb_unref_device(). A device is destroyed when
+ * its reference count reaches 0.
+ *
+ * With the above information in mind, the process of opening a device can
+ * be viewed as follows:
+ * -# Discover devices using libusb_get_device_list().
+ * -# Choose the device that you want to operate, and call libusb_open().
+ * -# Unref all devices in the discovered device list.
+ * -# Free the discovered device list.
+ *
+ * The order is important - you must not unreference the device before
+ * attempting to open it, because unreferencing it may destroy the device.
+ *
+ * For convenience, the libusb_free_device_list() function includes a
+ * parameter to optionally unreference all the devices in the list before
+ * freeing the list itself. This combines steps 3 and 4 above.
+ *
+ * As an implementation detail, libusb_open() actually adds a reference to
+ * the device in question. This is because the device remains available
+ * through the handle via libusb_get_device(). The reference is deleted during
+ * libusb_close().
+ */
+
+/** @defgroup libusb_misc Miscellaneous */
+
+/* we traverse usbfs without knowing how many devices we are going to find.
+ * so we create this discovered_devs model which is similar to a linked-list
+ * which grows when required. it can be freed once discovery has completed,
+ * eliminating the need for a list node in the libusb_device structure
+ * itself. */
+#define DISCOVERED_DEVICES_SIZE_STEP 8
+
+static struct discovered_devs *discovered_devs_alloc(void)
+{
+	struct discovered_devs *ret =
+		malloc(sizeof(*ret) + (sizeof(void *) * DISCOVERED_DEVICES_SIZE_STEP));
+
+	if (ret) {
+		ret->len = 0;
+		ret->capacity = DISCOVERED_DEVICES_SIZE_STEP;
+	}
+	return ret;
+}
+
+static void discovered_devs_free(struct discovered_devs *discdevs)
+{
+	size_t i;
+
+	for (i = 0; i < discdevs->len; i++)
+		libusb_unref_device(discdevs->devices[i]);
+
+	free(discdevs);
+}
+
+/* append a device to the discovered devices collection. may realloc itself,
+ * returning new discdevs. returns NULL on realloc failure. */
+struct discovered_devs *discovered_devs_append(
+	struct discovered_devs *discdevs, struct libusb_device *dev)
+{
+	size_t len = discdevs->len;
+	size_t capacity;
+	struct discovered_devs *new_discdevs;
+
+	/* if there is space, just append the device */
+	if (len < discdevs->capacity) {
+		discdevs->devices[len] = libusb_ref_device(dev);
+		discdevs->len++;
+		return discdevs;
+	}
+
+	/* exceeded capacity, need to grow */
+	usbi_dbg("need to increase capacity");
+	capacity = discdevs->capacity + DISCOVERED_DEVICES_SIZE_STEP;
+	/* can't use usbi_reallocf here because in failure cases it would
+	 * free the existing discdevs without unreferencing its devices. */
+	new_discdevs = realloc(discdevs,
+		sizeof(*discdevs) + (sizeof(void *) * capacity));
+	if (!new_discdevs) {
+		discovered_devs_free(discdevs);
+		return NULL;
+	}
+
+	discdevs = new_discdevs;
+	discdevs->capacity = capacity;
+	discdevs->devices[len] = libusb_ref_device(dev);
+	discdevs->len++;
+
+	return discdevs;
+}
+
+/* Allocate a new device with a specific session ID. The returned device has
+ * a reference count of 1. */
+struct libusb_device *usbi_alloc_device(struct libusb_context *ctx,
+	unsigned long session_id)
+{
+	size_t priv_size = usbi_backend.device_priv_size;
+	struct libusb_device *dev = calloc(1, sizeof(*dev) + priv_size);
+	int r;
+
+	if (!dev)
+		return NULL;
+
+	r = usbi_mutex_init(&dev->lock);
+	if (r) {
+		free(dev);
+		return NULL;
+	}
+
+	dev->ctx = ctx;
+	dev->refcnt = 1;
+	dev->session_data = session_id;
+	dev->speed = LIBUSB_SPEED_UNKNOWN;
+
+	if (!libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG)) {
+		usbi_connect_device (dev);
+	}
+
+	return dev;
+}
+
+void usbi_connect_device(struct libusb_device *dev)
+{
+	struct libusb_context *ctx = DEVICE_CTX(dev);
+
+	dev->attached = 1;
+
+	usbi_mutex_lock(&dev->ctx->usb_devs_lock);
+	list_add(&dev->list, &dev->ctx->usb_devs);
+	usbi_mutex_unlock(&dev->ctx->usb_devs_lock);
+
+	/* Signal that an event has occurred for this device if we support hotplug AND
+	 * the hotplug message list is ready. This prevents an event from getting raised
+	 * during initial enumeration. */
+	if (libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG) && dev->ctx->hotplug_msgs.next) {
+		usbi_hotplug_notification(ctx, dev, LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED);
+	}
+}
+
+void usbi_disconnect_device(struct libusb_device *dev)
+{
+	struct libusb_context *ctx = DEVICE_CTX(dev);
+
+	usbi_mutex_lock(&dev->lock);
+	dev->attached = 0;
+	usbi_mutex_unlock(&dev->lock);
+
+	usbi_mutex_lock(&ctx->usb_devs_lock);
+	list_del(&dev->list);
+	usbi_mutex_unlock(&ctx->usb_devs_lock);
+
+	/* Signal that an event has occurred for this device if we support hotplug AND
+	 * the hotplug message list is ready. This prevents an event from getting raised
+	 * during initial enumeration. libusb_handle_events will take care of dereferencing
+	 * the device. */
+	if (libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG) && dev->ctx->hotplug_msgs.next) {
+		usbi_hotplug_notification(ctx, dev, LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT);
+	}
+}
+
+/* Perform some final sanity checks on a newly discovered device. If this
+ * function fails (negative return code), the device should not be added
+ * to the discovered device list. */
+int usbi_sanitize_device(struct libusb_device *dev)
+{
+	int r;
+	uint8_t num_configurations;
+
+	r = usbi_device_cache_descriptor(dev);
+	if (r < 0)
+		return r;
+
+	num_configurations = dev->device_descriptor.bNumConfigurations;
+	if (num_configurations > USB_MAXCONFIG) {
+		usbi_err(DEVICE_CTX(dev), "too many configurations");
+		return LIBUSB_ERROR_IO;
+	} else if (0 == num_configurations)
+		usbi_dbg("zero configurations, maybe an unauthorized device");
+
+	dev->num_configurations = num_configurations;
+	return 0;
+}
+
+/* Examine libusb's internal list of known devices, looking for one with
+ * a specific session ID. Returns the matching device if it was found, and
+ * NULL otherwise. */
+struct libusb_device *usbi_get_device_by_session_id(struct libusb_context *ctx,
+	unsigned long session_id)
+{
+	struct libusb_device *dev;
+	struct libusb_device *ret = NULL;
+
+	usbi_mutex_lock(&ctx->usb_devs_lock);
+	list_for_each_entry(dev, &ctx->usb_devs, list, struct libusb_device)
+		if (dev->session_data == session_id) {
+			ret = libusb_ref_device(dev);
+			break;
+		}
+	usbi_mutex_unlock(&ctx->usb_devs_lock);
+
+	return ret;
+}
+
+/** @ingroup libusb_dev
+ * Returns a list of USB devices currently attached to the system. This is
+ * your entry point into finding a USB device to operate.
+ *
+ * You are expected to unreference all the devices when you are done with
+ * them, and then free the list with libusb_free_device_list(). Note that
+ * libusb_free_device_list() can unref all the devices for you. Be careful
+ * not to unreference a device you are about to open until after you have
+ * opened it.
+ *
+ * This return value of this function indicates the number of devices in
+ * the resultant list. The list is actually one element larger, as it is
+ * NULL-terminated.
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \param list output location for a list of devices. Must be later freed with
+ * libusb_free_device_list().
+ * \returns the number of devices in the outputted list, or any
+ * \ref libusb_error according to errors encountered by the backend.
+ */
+ssize_t API_EXPORTED libusb_get_device_list(libusb_context *ctx,
+	libusb_device ***list)
+{
+	struct discovered_devs *discdevs = discovered_devs_alloc();
+	struct libusb_device **ret;
+	int r = 0;
+	ssize_t i, len;
+	USBI_GET_CONTEXT(ctx);
+	usbi_dbg("");
+
+	if (!discdevs)
+		return LIBUSB_ERROR_NO_MEM;
+
+	if (libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG)) {
+		/* backend provides hotplug support */
+		struct libusb_device *dev;
+
+		if (usbi_backend.hotplug_poll)
+			usbi_backend.hotplug_poll();
+
+		usbi_mutex_lock(&ctx->usb_devs_lock);
+		list_for_each_entry(dev, &ctx->usb_devs, list, struct libusb_device) {
+			discdevs = discovered_devs_append(discdevs, dev);
+
+			if (!discdevs) {
+				r = LIBUSB_ERROR_NO_MEM;
+				break;
+			}
+		}
+		usbi_mutex_unlock(&ctx->usb_devs_lock);
+	} else {
+		/* backend does not provide hotplug support */
+		r = usbi_backend.get_device_list(ctx, &discdevs);
+	}
+
+	if (r < 0) {
+		len = r;
+		goto out;
+	}
+
+	/* convert discovered_devs into a list */
+	len = discdevs->len;
+	ret = calloc(len + 1, sizeof(struct libusb_device *));
+	if (!ret) {
+		len = LIBUSB_ERROR_NO_MEM;
+		goto out;
+	}
+
+	ret[len] = NULL;
+	for (i = 0; i < len; i++) {
+		struct libusb_device *dev = discdevs->devices[i];
+		ret[i] = libusb_ref_device(dev);
+	}
+	*list = ret;
+
+out:
+	if (discdevs)
+		discovered_devs_free(discdevs);
+	return len;
+}
+
+/** \ingroup libusb_dev
+ * Frees a list of devices previously discovered using
+ * libusb_get_device_list(). If the unref_devices parameter is set, the
+ * reference count of each device in the list is decremented by 1.
+ * \param list the list to free
+ * \param unref_devices whether to unref the devices in the list
+ */
+void API_EXPORTED libusb_free_device_list(libusb_device **list,
+	int unref_devices)
+{
+	if (!list)
+		return;
+
+	if (unref_devices) {
+		int i = 0;
+		struct libusb_device *dev;
+
+		while ((dev = list[i++]) != NULL)
+			libusb_unref_device(dev);
+	}
+	free(list);
+}
+
+/** \ingroup libusb_dev
+ * Get the number of the bus that a device is connected to.
+ * \param dev a device
+ * \returns the bus number
+ */
+uint8_t API_EXPORTED libusb_get_bus_number(libusb_device *dev)
+{
+	return dev->bus_number;
+}
+
+/** \ingroup libusb_dev
+ * Get the number of the port that a device is connected to.
+ * Unless the OS does something funky, or you are hot-plugging USB extension cards,
+ * the port number returned by this call is usually guaranteed to be uniquely tied
+ * to a physical port, meaning that different devices plugged on the same physical
+ * port should return the same port number.
+ *
+ * But outside of this, there is no guarantee that the port number returned by this
+ * call will remain the same, or even match the order in which ports have been
+ * numbered by the HUB/HCD manufacturer.
+ *
+ * \param dev a device
+ * \returns the port number (0 if not available)
+ */
+uint8_t API_EXPORTED libusb_get_port_number(libusb_device *dev)
+{
+	return dev->port_number;
+}
+
+/** \ingroup libusb_dev
+ * Get the list of all port numbers from root for the specified device
+ *
+ * Since version 1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102
+ * \param dev a device
+ * \param port_numbers the array that should contain the port numbers
+ * \param port_numbers_len the maximum length of the array. As per the USB 3.0
+ * specs, the current maximum limit for the depth is 7.
+ * \returns the number of elements filled
+ * \returns LIBUSB_ERROR_OVERFLOW if the array is too small
+ */
+int API_EXPORTED libusb_get_port_numbers(libusb_device *dev,
+	uint8_t* port_numbers, int port_numbers_len)
+{
+	int i = port_numbers_len;
+	struct libusb_context *ctx = DEVICE_CTX(dev);
+
+	if (port_numbers_len <= 0)
+		return LIBUSB_ERROR_INVALID_PARAM;
+
+	// HCDs can be listed as devices with port #0
+	while((dev) && (dev->port_number != 0)) {
+		if (--i < 0) {
+			usbi_warn(ctx, "port numbers array is too small");
+			return LIBUSB_ERROR_OVERFLOW;
+		}
+		port_numbers[i] = dev->port_number;
+		dev = dev->parent_dev;
+	}
+	if (i < port_numbers_len)
+		memmove(port_numbers, &port_numbers[i], port_numbers_len - i);
+	return port_numbers_len - i;
+}
+
+/** \ingroup libusb_dev
+ * Deprecated please use libusb_get_port_numbers instead.
+ */
+int API_EXPORTED libusb_get_port_path(libusb_context *ctx, libusb_device *dev,
+	uint8_t* port_numbers, uint8_t port_numbers_len)
+{
+	UNUSED(ctx);
+
+	return libusb_get_port_numbers(dev, port_numbers, port_numbers_len);
+}
+
+/** \ingroup libusb_dev
+ * Get the the parent from the specified device.
+ * \param dev a device
+ * \returns the device parent or NULL if not available
+ * You should issue a \ref libusb_get_device_list() before calling this
+ * function and make sure that you only access the parent before issuing
+ * \ref libusb_free_device_list(). The reason is that libusb currently does
+ * not maintain a permanent list of device instances, and therefore can
+ * only guarantee that parents are fully instantiated within a 
+ * libusb_get_device_list() - libusb_free_device_list() block.
+ */
+DEFAULT_VISIBILITY
+libusb_device * LIBUSB_CALL libusb_get_parent(libusb_device *dev)
+{
+	return dev->parent_dev;
+}
+
+/** \ingroup libusb_dev
+ * Get the address of the device on the bus it is connected to.
+ * \param dev a device
+ * \returns the device address
+ */
+uint8_t API_EXPORTED libusb_get_device_address(libusb_device *dev)
+{
+	return dev->device_address;
+}
+
+/** \ingroup libusb_dev
+ * Get the negotiated connection speed for a device.
+ * \param dev a device
+ * \returns a \ref libusb_speed code, where LIBUSB_SPEED_UNKNOWN means that
+ * the OS doesn't know or doesn't support returning the negotiated speed.
+ */
+int API_EXPORTED libusb_get_device_speed(libusb_device *dev)
+{
+	return dev->speed;
+}
+
+static const struct libusb_endpoint_descriptor *find_endpoint(
+	struct libusb_config_descriptor *config, unsigned char endpoint)
+{
+	int iface_idx;
+	for (iface_idx = 0; iface_idx < config->bNumInterfaces; iface_idx++) {
+		const struct libusb_interface *iface = &config->interface[iface_idx];
+		int altsetting_idx;
+
+		for (altsetting_idx = 0; altsetting_idx < iface->num_altsetting;
+				altsetting_idx++) {
+			const struct libusb_interface_descriptor *altsetting
+				= &iface->altsetting[altsetting_idx];
+			int ep_idx;
+
+			for (ep_idx = 0; ep_idx < altsetting->bNumEndpoints; ep_idx++) {
+				const struct libusb_endpoint_descriptor *ep =
+					&altsetting->endpoint[ep_idx];
+				if (ep->bEndpointAddress == endpoint)
+					return ep;
+			}
+		}
+	}
+	return NULL;
+}
+
+/** \ingroup libusb_dev
+ * Convenience function to retrieve the wMaxPacketSize value for a particular
+ * endpoint in the active device configuration.
+ *
+ * This function was originally intended to be of assistance when setting up
+ * isochronous transfers, but a design mistake resulted in this function
+ * instead. It simply returns the wMaxPacketSize value without considering
+ * its contents. If you're dealing with isochronous transfers, you probably
+ * want libusb_get_max_iso_packet_size() instead.
+ *
+ * \param dev a device
+ * \param endpoint address of the endpoint in question
+ * \returns the wMaxPacketSize value
+ * \returns LIBUSB_ERROR_NOT_FOUND if the endpoint does not exist
+ * \returns LIBUSB_ERROR_OTHER on other failure
+ */
+int API_EXPORTED libusb_get_max_packet_size(libusb_device *dev,
+	unsigned char endpoint)
+{
+	struct libusb_config_descriptor *config;
+	const struct libusb_endpoint_descriptor *ep;
+	int r;
+
+	r = libusb_get_active_config_descriptor(dev, &config);
+	if (r < 0) {
+		usbi_err(DEVICE_CTX(dev),
+			"could not retrieve active config descriptor");
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	ep = find_endpoint(config, endpoint);
+	if (!ep) {
+		r = LIBUSB_ERROR_NOT_FOUND;
+		goto out;
+	}
+
+	r = ep->wMaxPacketSize;
+
+out:
+	libusb_free_config_descriptor(config);
+	return r;
+}
+
+/** \ingroup libusb_dev
+ * Calculate the maximum packet size which a specific endpoint is capable is
+ * sending or receiving in the duration of 1 microframe
+ *
+ * Only the active configuration is examined. The calculation is based on the
+ * wMaxPacketSize field in the endpoint descriptor as described in section
+ * 9.6.6 in the USB 2.0 specifications.
+ *
+ * If acting on an isochronous or interrupt endpoint, this function will
+ * multiply the value found in bits 0:10 by the number of transactions per
+ * microframe (determined by bits 11:12). Otherwise, this function just
+ * returns the numeric value found in bits 0:10.
+ *
+ * This function is useful for setting up isochronous transfers, for example
+ * you might pass the return value from this function to
+ * libusb_set_iso_packet_lengths() in order to set the length field of every
+ * isochronous packet in a transfer.
+ *
+ * Since v1.0.3.
+ *
+ * \param dev a device
+ * \param endpoint address of the endpoint in question
+ * \returns the maximum packet size which can be sent/received on this endpoint
+ * \returns LIBUSB_ERROR_NOT_FOUND if the endpoint does not exist
+ * \returns LIBUSB_ERROR_OTHER on other failure
+ */
+int API_EXPORTED libusb_get_max_iso_packet_size(libusb_device *dev,
+	unsigned char endpoint)
+{
+	struct libusb_config_descriptor *config;
+	const struct libusb_endpoint_descriptor *ep;
+	enum libusb_transfer_type ep_type;
+	uint16_t val;
+	int r;
+
+	r = libusb_get_active_config_descriptor(dev, &config);
+	if (r < 0) {
+		usbi_err(DEVICE_CTX(dev),
+			"could not retrieve active config descriptor");
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	ep = find_endpoint(config, endpoint);
+	if (!ep) {
+		r = LIBUSB_ERROR_NOT_FOUND;
+		goto out;
+	}
+
+	val = ep->wMaxPacketSize;
+	ep_type = (enum libusb_transfer_type) (ep->bmAttributes & 0x3);
+
+	r = val & 0x07ff;
+	if (ep_type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS
+			|| ep_type == LIBUSB_TRANSFER_TYPE_INTERRUPT)
+		r *= (1 + ((val >> 11) & 3));
+
+out:
+	libusb_free_config_descriptor(config);
+	return r;
+}
+
+/** \ingroup libusb_dev
+ * Increment the reference count of a device.
+ * \param dev the device to reference
+ * \returns the same device
+ */
+DEFAULT_VISIBILITY
+libusb_device * LIBUSB_CALL libusb_ref_device(libusb_device *dev)
+{
+	usbi_mutex_lock(&dev->lock);
+	dev->refcnt++;
+	usbi_mutex_unlock(&dev->lock);
+	return dev;
+}
+
+/** \ingroup libusb_dev
+ * Decrement the reference count of a device. If the decrement operation
+ * causes the reference count to reach zero, the device shall be destroyed.
+ * \param dev the device to unreference
+ */
+void API_EXPORTED libusb_unref_device(libusb_device *dev)
+{
+	int refcnt;
+
+	if (!dev)
+		return;
+
+	usbi_mutex_lock(&dev->lock);
+	refcnt = --dev->refcnt;
+	usbi_mutex_unlock(&dev->lock);
+
+	if (refcnt == 0) {
+		usbi_dbg("destroy device %d.%d", dev->bus_number, dev->device_address);
+
+		libusb_unref_device(dev->parent_dev);
+
+		if (usbi_backend.destroy_device)
+			usbi_backend.destroy_device(dev);
+
+		if (!libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG)) {
+			/* backend does not support hotplug */
+			usbi_disconnect_device(dev);
+		}
+
+		usbi_mutex_destroy(&dev->lock);
+		free(dev);
+	}
+}
+
+/*
+ * Signal the event pipe so that the event handling thread will be
+ * interrupted to process an internal event.
+ */
+int usbi_signal_event(struct libusb_context *ctx)
+{
+	unsigned char dummy = 1;
+	ssize_t r;
+
+	/* write some data on event pipe to interrupt event handlers */
+	r = usbi_write(ctx->event_pipe[1], &dummy, sizeof(dummy));
+	if (r != sizeof(dummy)) {
+		usbi_warn(ctx, "internal signalling write failed");
+		return LIBUSB_ERROR_IO;
+	}
+
+	return 0;
+}
+
+/*
+ * Clear the event pipe so that the event handling will no longer be
+ * interrupted.
+ */
+int usbi_clear_event(struct libusb_context *ctx)
+{
+	unsigned char dummy;
+	ssize_t r;
+
+	/* read some data on event pipe to clear it */
+	r = usbi_read(ctx->event_pipe[0], &dummy, sizeof(dummy));
+	if (r != sizeof(dummy)) {
+		usbi_warn(ctx, "internal signalling read failed");
+		return LIBUSB_ERROR_IO;
+	}
+
+	return 0;
+}
+
+/** \ingroup libusb_dev
+ * Open a device and obtain a device handle. A handle allows you to perform
+ * I/O on the device in question.
+ *
+ * Internally, this function adds a reference to the device and makes it
+ * available to you through libusb_get_device(). This reference is removed
+ * during libusb_close().
+ *
+ * This is a non-blocking function; no requests are sent over the bus.
+ *
+ * \param dev the device to open
+ * \param dev_handle output location for the returned device handle pointer. Only
+ * populated when the return code is 0.
+ * \returns 0 on success
+ * \returns LIBUSB_ERROR_NO_MEM on memory allocation failure
+ * \returns LIBUSB_ERROR_ACCESS if the user has insufficient permissions
+ * \returns LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * \returns another LIBUSB_ERROR code on other failure
+ */
+int API_EXPORTED libusb_open(libusb_device *dev,
+	libusb_device_handle **dev_handle)
+{
+	struct libusb_context *ctx = DEVICE_CTX(dev);
+	struct libusb_device_handle *_dev_handle;
+	size_t priv_size = usbi_backend.device_handle_priv_size;
+	int r;
+	usbi_dbg("open %d.%d", dev->bus_number, dev->device_address);
+
+	if (!dev->attached) {
+		return LIBUSB_ERROR_NO_DEVICE;
+	}
+
+	_dev_handle = malloc(sizeof(*_dev_handle) + priv_size);
+	if (!_dev_handle)
+		return LIBUSB_ERROR_NO_MEM;
+
+	r = usbi_mutex_init(&_dev_handle->lock);
+	if (r) {
+		free(_dev_handle);
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	_dev_handle->dev = libusb_ref_device(dev);
+	_dev_handle->auto_detach_kernel_driver = 0;
+	_dev_handle->claimed_interfaces = 0;
+	memset(&_dev_handle->os_priv, 0, priv_size);
+
+	r = usbi_backend.open(_dev_handle);
+	if (r < 0) {
+		usbi_dbg("open %d.%d returns %d", dev->bus_number, dev->device_address, r);
+		libusb_unref_device(dev);
+		usbi_mutex_destroy(&_dev_handle->lock);
+		free(_dev_handle);
+		return r;
+	}
+
+	usbi_mutex_lock(&ctx->open_devs_lock);
+	list_add(&_dev_handle->list, &ctx->open_devs);
+	usbi_mutex_unlock(&ctx->open_devs_lock);
+	*dev_handle = _dev_handle;
+
+	return 0;
+}
+
+/** \ingroup libusb_dev
+ * Convenience function for finding a device with a particular
+ * <tt>idVendor</tt>/<tt>idProduct</tt> combination. This function is intended
+ * for those scenarios where you are using libusb to knock up a quick test
+ * application - it allows you to avoid calling libusb_get_device_list() and
+ * worrying about traversing/freeing the list.
+ *
+ * This function has limitations and is hence not intended for use in real
+ * applications: if multiple devices have the same IDs it will only
+ * give you the first one, etc.
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \param vendor_id the idVendor value to search for
+ * \param product_id the idProduct value to search for
+ * \returns a device handle for the first found device, or NULL on error
+ * or if the device could not be found. */
+DEFAULT_VISIBILITY
+libusb_device_handle * LIBUSB_CALL libusb_open_device_with_vid_pid(
+	libusb_context *ctx, uint16_t vendor_id, uint16_t product_id)
+{
+	struct libusb_device **devs;
+	struct libusb_device *found = NULL;
+	struct libusb_device *dev;
+	struct libusb_device_handle *dev_handle = NULL;
+	size_t i = 0;
+	int r;
+
+	if (libusb_get_device_list(ctx, &devs) < 0)
+		return NULL;
+
+	while ((dev = devs[i++]) != NULL) {
+		struct libusb_device_descriptor desc;
+		r = libusb_get_device_descriptor(dev, &desc);
+		if (r < 0)
+			goto out;
+		if (desc.idVendor == vendor_id && desc.idProduct == product_id) {
+			found = dev;
+			break;
+		}
+	}
+
+	if (found) {
+		r = libusb_open(found, &dev_handle);
+		if (r < 0)
+			dev_handle = NULL;
+	}
+
+out:
+	libusb_free_device_list(devs, 1);
+	return dev_handle;
+}
+
+static void do_close(struct libusb_context *ctx,
+	struct libusb_device_handle *dev_handle)
+{
+	struct usbi_transfer *itransfer;
+	struct usbi_transfer *tmp;
+
+	/* remove any transfers in flight that are for this device */
+	usbi_mutex_lock(&ctx->flying_transfers_lock);
+
+	/* safe iteration because transfers may be being deleted */
+	list_for_each_entry_safe(itransfer, tmp, &ctx->flying_transfers, list, struct usbi_transfer) {
+		struct libusb_transfer *transfer =
+			USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+
+		if (transfer->dev_handle != dev_handle)
+			continue;
+
+		usbi_mutex_lock(&itransfer->lock);
+		if (!(itransfer->state_flags & USBI_TRANSFER_DEVICE_DISAPPEARED)) {
+			usbi_err(ctx, "Device handle closed while transfer was still being processed, but the device is still connected as far as we know");
+
+			if (itransfer->state_flags & USBI_TRANSFER_CANCELLING)
+				usbi_warn(ctx, "A cancellation for an in-flight transfer hasn't completed but closing the device handle");
+			else
+				usbi_err(ctx, "A cancellation hasn't even been scheduled on the transfer for which the device is closing");
+		}
+		usbi_mutex_unlock(&itransfer->lock);
+
+		/* remove from the list of in-flight transfers and make sure
+		 * we don't accidentally use the device handle in the future
+		 * (or that such accesses will be easily caught and identified as a crash)
+		 */
+		list_del(&itransfer->list);
+		transfer->dev_handle = NULL;
+
+		/* it is up to the user to free up the actual transfer struct.  this is
+		 * just making sure that we don't attempt to process the transfer after
+		 * the device handle is invalid
+		 */
+		usbi_dbg("Removed transfer %p from the in-flight list because device handle %p closed",
+			 transfer, dev_handle);
+	}
+	usbi_mutex_unlock(&ctx->flying_transfers_lock);
+
+	usbi_mutex_lock(&ctx->open_devs_lock);
+	list_del(&dev_handle->list);
+	usbi_mutex_unlock(&ctx->open_devs_lock);
+
+	usbi_backend.close(dev_handle);
+	libusb_unref_device(dev_handle->dev);
+	usbi_mutex_destroy(&dev_handle->lock);
+	free(dev_handle);
+}
+
+/** \ingroup libusb_dev
+ * Close a device handle. Should be called on all open handles before your
+ * application exits.
+ *
+ * Internally, this function destroys the reference that was added by
+ * libusb_open() on the given device.
+ *
+ * This is a non-blocking function; no requests are sent over the bus.
+ *
+ * \param dev_handle the device handle to close
+ */
+void API_EXPORTED libusb_close(libusb_device_handle *dev_handle)
+{
+	struct libusb_context *ctx;
+	int handling_events;
+	int pending_events;
+
+	if (!dev_handle)
+		return;
+	usbi_dbg("");
+
+	ctx = HANDLE_CTX(dev_handle);
+	handling_events = usbi_handling_events(ctx);
+
+	/* Similarly to libusb_open(), we want to interrupt all event handlers
+	 * at this point. More importantly, we want to perform the actual close of
+	 * the device while holding the event handling lock (preventing any other
+	 * thread from doing event handling) because we will be removing a file
+	 * descriptor from the polling loop. If this is being called by the current
+	 * event handler, we can bypass the interruption code because we already
+	 * hold the event handling lock. */
+
+	if (!handling_events) {
+		/* Record that we are closing a device.
+		 * Only signal an event if there are no prior pending events. */
+		usbi_mutex_lock(&ctx->event_data_lock);
+		pending_events = usbi_pending_events(ctx);
+		ctx->device_close++;
+		if (!pending_events)
+			usbi_signal_event(ctx);
+		usbi_mutex_unlock(&ctx->event_data_lock);
+
+		/* take event handling lock */
+		libusb_lock_events(ctx);
+	}
+
+	/* Close the device */
+	do_close(ctx, dev_handle);
+
+	if (!handling_events) {
+		/* We're done with closing this device.
+		 * Clear the event pipe if there are no further pending events. */
+		usbi_mutex_lock(&ctx->event_data_lock);
+		ctx->device_close--;
+		pending_events = usbi_pending_events(ctx);
+		if (!pending_events)
+			usbi_clear_event(ctx);
+		usbi_mutex_unlock(&ctx->event_data_lock);
+
+		/* Release event handling lock and wake up event waiters */
+		libusb_unlock_events(ctx);
+	}
+}
+
+/** \ingroup libusb_dev
+ * Get the underlying device for a device handle. This function does not modify
+ * the reference count of the returned device, so do not feel compelled to
+ * unreference it when you are done.
+ * \param dev_handle a device handle
+ * \returns the underlying device
+ */
+DEFAULT_VISIBILITY
+libusb_device * LIBUSB_CALL libusb_get_device(libusb_device_handle *dev_handle)
+{
+	return dev_handle->dev;
+}
+
+/** \ingroup libusb_dev
+ * Determine the bConfigurationValue of the currently active configuration.
+ *
+ * You could formulate your own control request to obtain this information,
+ * but this function has the advantage that it may be able to retrieve the
+ * information from operating system caches (no I/O involved).
+ *
+ * If the OS does not cache this information, then this function will block
+ * while a control transfer is submitted to retrieve the information.
+ *
+ * This function will return a value of 0 in the <tt>config</tt> output
+ * parameter if the device is in unconfigured state.
+ *
+ * \param dev_handle a device handle
+ * \param config output location for the bConfigurationValue of the active
+ * configuration (only valid for return code 0)
+ * \returns 0 on success
+ * \returns LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * \returns another LIBUSB_ERROR code on other failure
+ */
+int API_EXPORTED libusb_get_configuration(libusb_device_handle *dev_handle,
+	int *config)
+{
+	int r = LIBUSB_ERROR_NOT_SUPPORTED;
+
+	usbi_dbg("");
+	if (usbi_backend.get_configuration)
+		r = usbi_backend.get_configuration(dev_handle, config);
+
+	if (r == LIBUSB_ERROR_NOT_SUPPORTED) {
+		uint8_t tmp = 0;
+		usbi_dbg("falling back to control message");
+		r = libusb_control_transfer(dev_handle, LIBUSB_ENDPOINT_IN,
+			LIBUSB_REQUEST_GET_CONFIGURATION, 0, 0, &tmp, 1, 1000);
+		if (r == 0) {
+			usbi_err(HANDLE_CTX(dev_handle), "zero bytes returned in ctrl transfer?");
+			r = LIBUSB_ERROR_IO;
+		} else if (r == 1) {
+			r = 0;
+			*config = tmp;
+		} else {
+			usbi_dbg("control failed, error %d", r);
+		}
+	}
+
+	if (r == 0)
+		usbi_dbg("active config %d", *config);
+
+	return r;
+}
+
+/** \ingroup libusb_dev
+ * Set the active configuration for a device.
+ *
+ * The operating system may or may not have already set an active
+ * configuration on the device. It is up to your application to ensure the
+ * correct configuration is selected before you attempt to claim interfaces
+ * and perform other operations.
+ *
+ * If you call this function on a device already configured with the selected
+ * configuration, then this function will act as a lightweight device reset:
+ * it will issue a SET_CONFIGURATION request using the current configuration,
+ * causing most USB-related device state to be reset (altsetting reset to zero,
+ * endpoint halts cleared, toggles reset).
+ *
+ * You cannot change/reset configuration if your application has claimed
+ * interfaces. It is advised to set the desired configuration before claiming
+ * interfaces.
+ *
+ * Alternatively you can call libusb_release_interface() first. Note if you
+ * do things this way you must ensure that auto_detach_kernel_driver for
+ * <tt>dev</tt> is 0, otherwise the kernel driver will be re-attached when you
+ * release the interface(s).
+ *
+ * You cannot change/reset configuration if other applications or drivers have
+ * claimed interfaces.
+ *
+ * A configuration value of -1 will put the device in unconfigured state.
+ * The USB specifications state that a configuration value of 0 does this,
+ * however buggy devices exist which actually have a configuration 0.
+ *
+ * You should always use this function rather than formulating your own
+ * SET_CONFIGURATION control request. This is because the underlying operating
+ * system needs to know when such changes happen.
+ *
+ * This is a blocking function.
+ *
+ * \param dev_handle a device handle
+ * \param configuration the bConfigurationValue of the configuration you
+ * wish to activate, or -1 if you wish to put the device in an unconfigured
+ * state
+ * \returns 0 on success
+ * \returns LIBUSB_ERROR_NOT_FOUND if the requested configuration does not exist
+ * \returns LIBUSB_ERROR_BUSY if interfaces are currently claimed
+ * \returns LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * \returns another LIBUSB_ERROR code on other failure
+ * \see libusb_set_auto_detach_kernel_driver()
+ */
+int API_EXPORTED libusb_set_configuration(libusb_device_handle *dev_handle,
+	int configuration)
+{
+	usbi_dbg("configuration %d", configuration);
+	return usbi_backend.set_configuration(dev_handle, configuration);
+}
+
+/** \ingroup libusb_dev
+ * Claim an interface on a given device handle. You must claim the interface
+ * you wish to use before you can perform I/O on any of its endpoints.
+ *
+ * It is legal to attempt to claim an already-claimed interface, in which
+ * case libusb just returns 0 without doing anything.
+ *
+ * If auto_detach_kernel_driver is set to 1 for <tt>dev</tt>, the kernel driver
+ * will be detached if necessary, on failure the detach error is returned.
+ *
+ * Claiming of interfaces is a purely logical operation; it does not cause
+ * any requests to be sent over the bus. Interface claiming is used to
+ * instruct the underlying operating system that your application wishes
+ * to take ownership of the interface.
+ *
+ * This is a non-blocking function.
+ *
+ * \param dev_handle a device handle
+ * \param interface_number the <tt>bInterfaceNumber</tt> of the interface you
+ * wish to claim
+ * \returns 0 on success
+ * \returns LIBUSB_ERROR_NOT_FOUND if the requested interface does not exist
+ * \returns LIBUSB_ERROR_BUSY if another program or driver has claimed the
+ * interface
+ * \returns LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * \returns a LIBUSB_ERROR code on other failure
+ * \see libusb_set_auto_detach_kernel_driver()
+ */
+int API_EXPORTED libusb_claim_interface(libusb_device_handle *dev_handle,
+	int interface_number)
+{
+	int r = 0;
+
+	usbi_dbg("interface %d", interface_number);
+	if (interface_number >= USB_MAXINTERFACES)
+		return LIBUSB_ERROR_INVALID_PARAM;
+
+	if (!dev_handle->dev->attached)
+		return LIBUSB_ERROR_NO_DEVICE;
+
+	usbi_mutex_lock(&dev_handle->lock);
+	if (dev_handle->claimed_interfaces & (1 << interface_number))
+		goto out;
+
+	r = usbi_backend.claim_interface(dev_handle, interface_number);
+	if (r == 0)
+		dev_handle->claimed_interfaces |= 1 << interface_number;
+
+out:
+	usbi_mutex_unlock(&dev_handle->lock);
+	return r;
+}
+
+/** \ingroup libusb_dev
+ * Release an interface previously claimed with libusb_claim_interface(). You
+ * should release all claimed interfaces before closing a device handle.
+ *
+ * This is a blocking function. A SET_INTERFACE control request will be sent
+ * to the device, resetting interface state to the first alternate setting.
+ *
+ * If auto_detach_kernel_driver is set to 1 for <tt>dev</tt>, the kernel
+ * driver will be re-attached after releasing the interface.
+ *
+ * \param dev_handle a device handle
+ * \param interface_number the <tt>bInterfaceNumber</tt> of the
+ * previously-claimed interface
+ * \returns 0 on success
+ * \returns LIBUSB_ERROR_NOT_FOUND if the interface was not claimed
+ * \returns LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * \returns another LIBUSB_ERROR code on other failure
+ * \see libusb_set_auto_detach_kernel_driver()
+ */
+int API_EXPORTED libusb_release_interface(libusb_device_handle *dev_handle,
+	int interface_number)
+{
+	int r;
+
+	usbi_dbg("interface %d", interface_number);
+	if (interface_number >= USB_MAXINTERFACES)
+		return LIBUSB_ERROR_INVALID_PARAM;
+
+	usbi_mutex_lock(&dev_handle->lock);
+	if (!(dev_handle->claimed_interfaces & (1 << interface_number))) {
+		r = LIBUSB_ERROR_NOT_FOUND;
+		goto out;
+	}
+
+	r = usbi_backend.release_interface(dev_handle, interface_number);
+	if (r == 0)
+		dev_handle->claimed_interfaces &= ~(1 << interface_number);
+
+out:
+	usbi_mutex_unlock(&dev_handle->lock);
+	return r;
+}
+
+/** \ingroup libusb_dev
+ * Activate an alternate setting for an interface. The interface must have
+ * been previously claimed with libusb_claim_interface().
+ *
+ * You should always use this function rather than formulating your own
+ * SET_INTERFACE control request. This is because the underlying operating
+ * system needs to know when such changes happen.
+ *
+ * This is a blocking function.
+ *
+ * \param dev_handle a device handle
+ * \param interface_number the <tt>bInterfaceNumber</tt> of the
+ * previously-claimed interface
+ * \param alternate_setting the <tt>bAlternateSetting</tt> of the alternate
+ * setting to activate
+ * \returns 0 on success
+ * \returns LIBUSB_ERROR_NOT_FOUND if the interface was not claimed, or the
+ * requested alternate setting does not exist
+ * \returns LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * \returns another LIBUSB_ERROR code on other failure
+ */
+int API_EXPORTED libusb_set_interface_alt_setting(libusb_device_handle *dev_handle,
+	int interface_number, int alternate_setting)
+{
+	usbi_dbg("interface %d altsetting %d",
+		interface_number, alternate_setting);
+	if (interface_number >= USB_MAXINTERFACES)
+		return LIBUSB_ERROR_INVALID_PARAM;
+
+	usbi_mutex_lock(&dev_handle->lock);
+	if (!dev_handle->dev->attached) {
+		usbi_mutex_unlock(&dev_handle->lock);
+		return LIBUSB_ERROR_NO_DEVICE;
+	}
+
+	if (!(dev_handle->claimed_interfaces & (1 << interface_number))) {
+		usbi_mutex_unlock(&dev_handle->lock);
+		return LIBUSB_ERROR_NOT_FOUND;
+	}
+	usbi_mutex_unlock(&dev_handle->lock);
+
+	return usbi_backend.set_interface_altsetting(dev_handle, interface_number,
+		alternate_setting);
+}
+
+/** \ingroup libusb_dev
+ * Clear the halt/stall condition for an endpoint. Endpoints with halt status
+ * are unable to receive or transmit data until the halt condition is stalled.
+ *
+ * You should cancel all pending transfers before attempting to clear the halt
+ * condition.
+ *
+ * This is a blocking function.
+ *
+ * \param dev_handle a device handle
+ * \param endpoint the endpoint to clear halt status
+ * \returns 0 on success
+ * \returns LIBUSB_ERROR_NOT_FOUND if the endpoint does not exist
+ * \returns LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * \returns another LIBUSB_ERROR code on other failure
+ */
+int API_EXPORTED libusb_clear_halt(libusb_device_handle *dev_handle,
+	unsigned char endpoint)
+{
+	usbi_dbg("endpoint %x", endpoint);
+	if (!dev_handle->dev->attached)
+		return LIBUSB_ERROR_NO_DEVICE;
+
+	return usbi_backend.clear_halt(dev_handle, endpoint);
+}
+
+/** \ingroup libusb_dev
+ * Perform a USB port reset to reinitialize a device. The system will attempt
+ * to restore the previous configuration and alternate settings after the
+ * reset has completed.
+ *
+ * If the reset fails, the descriptors change, or the previous state cannot be
+ * restored, the device will appear to be disconnected and reconnected. This
+ * means that the device handle is no longer valid (you should close it) and
+ * rediscover the device. A return code of LIBUSB_ERROR_NOT_FOUND indicates
+ * when this is the case.
+ *
+ * This is a blocking function which usually incurs a noticeable delay.
+ *
+ * \param dev_handle a handle of the device to reset
+ * \returns 0 on success
+ * \returns LIBUSB_ERROR_NOT_FOUND if re-enumeration is required, or if the
+ * device has been disconnected
+ * \returns another LIBUSB_ERROR code on other failure
+ */
+int API_EXPORTED libusb_reset_device(libusb_device_handle *dev_handle)
+{
+	usbi_dbg("");
+	if (!dev_handle->dev->attached)
+		return LIBUSB_ERROR_NO_DEVICE;
+
+	return usbi_backend.reset_device(dev_handle);
+}
+
+/** \ingroup libusb_asyncio
+ * Allocate up to num_streams usb bulk streams on the specified endpoints. This
+ * function takes an array of endpoints rather then a single endpoint because
+ * some protocols require that endpoints are setup with similar stream ids.
+ * All endpoints passed in must belong to the same interface.
+ *
+ * Note this function may return less streams then requested. Also note that the
+ * same number of streams are allocated for each endpoint in the endpoint array.
+ *
+ * Stream id 0 is reserved, and should not be used to communicate with devices.
+ * If libusb_alloc_streams() returns with a value of N, you may use stream ids
+ * 1 to N.
+ *
+ * Since version 1.0.19, \ref LIBUSB_API_VERSION >= 0x01000103
+ *
+ * \param dev_handle a device handle
+ * \param num_streams number of streams to try to allocate
+ * \param endpoints array of endpoints to allocate streams on
+ * \param num_endpoints length of the endpoints array
+ * \returns number of streams allocated, or a LIBUSB_ERROR code on failure
+ */
+int API_EXPORTED libusb_alloc_streams(libusb_device_handle *dev_handle,
+	uint32_t num_streams, unsigned char *endpoints, int num_endpoints)
+{
+	usbi_dbg("streams %u eps %d", (unsigned) num_streams, num_endpoints);
+
+	if (!dev_handle->dev->attached)
+		return LIBUSB_ERROR_NO_DEVICE;
+
+	if (usbi_backend.alloc_streams)
+		return usbi_backend.alloc_streams(dev_handle, num_streams, endpoints,
+						   num_endpoints);
+	else
+		return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+/** \ingroup libusb_asyncio
+ * Free usb bulk streams allocated with libusb_alloc_streams().
+ *
+ * Note streams are automatically free-ed when releasing an interface.
+ *
+ * Since version 1.0.19, \ref LIBUSB_API_VERSION >= 0x01000103
+ *
+ * \param dev_handle a device handle
+ * \param endpoints array of endpoints to free streams on
+ * \param num_endpoints length of the endpoints array
+ * \returns LIBUSB_SUCCESS, or a LIBUSB_ERROR code on failure
+ */
+int API_EXPORTED libusb_free_streams(libusb_device_handle *dev_handle,
+	unsigned char *endpoints, int num_endpoints)
+{
+	usbi_dbg("eps %d", num_endpoints);
+
+	if (!dev_handle->dev->attached)
+		return LIBUSB_ERROR_NO_DEVICE;
+
+	if (usbi_backend.free_streams)
+		return usbi_backend.free_streams(dev_handle, endpoints,
+						  num_endpoints);
+	else
+		return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+/** \ingroup libusb_asyncio
+ * Attempts to allocate a block of persistent DMA memory suitable for transfers
+ * against the given device. If successful, will return a block of memory
+ * that is suitable for use as "buffer" in \ref libusb_transfer against this
+ * device. Using this memory instead of regular memory means that the host
+ * controller can use DMA directly into the buffer to increase performance, and
+ * also that transfers can no longer fail due to kernel memory fragmentation.
+ *
+ * Note that this means you should not modify this memory (or even data on
+ * the same cache lines) when a transfer is in progress, although it is legal
+ * to have several transfers going on within the same memory block.
+ *
+ * Will return NULL on failure. Many systems do not support such zerocopy
+ * and will always return NULL. Memory allocated with this function must be
+ * freed with \ref libusb_dev_mem_free. Specifically, this means that the
+ * flag \ref LIBUSB_TRANSFER_FREE_BUFFER cannot be used to free memory allocated
+ * with this function.
+ *
+ * Since version 1.0.21, \ref LIBUSB_API_VERSION >= 0x01000105
+ *
+ * \param dev_handle a device handle
+ * \param length size of desired data buffer
+ * \returns a pointer to the newly allocated memory, or NULL on failure
+ */
+DEFAULT_VISIBILITY
+unsigned char * LIBUSB_CALL libusb_dev_mem_alloc(libusb_device_handle *dev_handle,
+        size_t length)
+{
+	if (!dev_handle->dev->attached)
+		return NULL;
+
+	if (usbi_backend.dev_mem_alloc)
+		return usbi_backend.dev_mem_alloc(dev_handle, length);
+	else
+		return NULL;
+}
+
+/** \ingroup libusb_asyncio
+ * Free device memory allocated with libusb_dev_mem_alloc().
+ *
+ * \param dev_handle a device handle
+ * \param buffer pointer to the previously allocated memory
+ * \param length size of previously allocated memory
+ * \returns LIBUSB_SUCCESS, or a LIBUSB_ERROR code on failure
+ */
+int API_EXPORTED libusb_dev_mem_free(libusb_device_handle *dev_handle,
+	unsigned char *buffer, size_t length)
+{
+	if (usbi_backend.dev_mem_free)
+		return usbi_backend.dev_mem_free(dev_handle, buffer, length);
+	else
+		return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+/** \ingroup libusb_dev
+ * Determine if a kernel driver is active on an interface. If a kernel driver
+ * is active, you cannot claim the interface, and libusb will be unable to
+ * perform I/O.
+ *
+ * This functionality is not available on Windows.
+ *
+ * \param dev_handle a device handle
+ * \param interface_number the interface to check
+ * \returns 0 if no kernel driver is active
+ * \returns 1 if a kernel driver is active
+ * \returns LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * \returns LIBUSB_ERROR_NOT_SUPPORTED on platforms where the functionality
+ * is not available
+ * \returns another LIBUSB_ERROR code on other failure
+ * \see libusb_detach_kernel_driver()
+ */
+int API_EXPORTED libusb_kernel_driver_active(libusb_device_handle *dev_handle,
+	int interface_number)
+{
+	usbi_dbg("interface %d", interface_number);
+
+	if (!dev_handle->dev->attached)
+		return LIBUSB_ERROR_NO_DEVICE;
+
+	if (usbi_backend.kernel_driver_active)
+		return usbi_backend.kernel_driver_active(dev_handle, interface_number);
+	else
+		return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+/** \ingroup libusb_dev
+ * Detach a kernel driver from an interface. If successful, you will then be
+ * able to claim the interface and perform I/O.
+ *
+ * This functionality is not available on Darwin or Windows.
+ *
+ * Note that libusb itself also talks to the device through a special kernel
+ * driver, if this driver is already attached to the device, this call will
+ * not detach it and return LIBUSB_ERROR_NOT_FOUND.
+ *
+ * \param dev_handle a device handle
+ * \param interface_number the interface to detach the driver from
+ * \returns 0 on success
+ * \returns LIBUSB_ERROR_NOT_FOUND if no kernel driver was active
+ * \returns LIBUSB_ERROR_INVALID_PARAM if the interface does not exist
+ * \returns LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * \returns LIBUSB_ERROR_NOT_SUPPORTED on platforms where the functionality
+ * is not available
+ * \returns another LIBUSB_ERROR code on other failure
+ * \see libusb_kernel_driver_active()
+ */
+int API_EXPORTED libusb_detach_kernel_driver(libusb_device_handle *dev_handle,
+	int interface_number)
+{
+	usbi_dbg("interface %d", interface_number);
+
+	if (!dev_handle->dev->attached)
+		return LIBUSB_ERROR_NO_DEVICE;
+
+	if (usbi_backend.detach_kernel_driver)
+		return usbi_backend.detach_kernel_driver(dev_handle, interface_number);
+	else
+		return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+/** \ingroup libusb_dev
+ * Re-attach an interface's kernel driver, which was previously detached
+ * using libusb_detach_kernel_driver(). This call is only effective on
+ * Linux and returns LIBUSB_ERROR_NOT_SUPPORTED on all other platforms.
+ *
+ * This functionality is not available on Darwin or Windows.
+ *
+ * \param dev_handle a device handle
+ * \param interface_number the interface to attach the driver from
+ * \returns 0 on success
+ * \returns LIBUSB_ERROR_NOT_FOUND if no kernel driver was active
+ * \returns LIBUSB_ERROR_INVALID_PARAM if the interface does not exist
+ * \returns LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * \returns LIBUSB_ERROR_NOT_SUPPORTED on platforms where the functionality
+ * is not available
+ * \returns LIBUSB_ERROR_BUSY if the driver cannot be attached because the
+ * interface is claimed by a program or driver
+ * \returns another LIBUSB_ERROR code on other failure
+ * \see libusb_kernel_driver_active()
+ */
+int API_EXPORTED libusb_attach_kernel_driver(libusb_device_handle *dev_handle,
+	int interface_number)
+{
+	usbi_dbg("interface %d", interface_number);
+
+	if (!dev_handle->dev->attached)
+		return LIBUSB_ERROR_NO_DEVICE;
+
+	if (usbi_backend.attach_kernel_driver)
+		return usbi_backend.attach_kernel_driver(dev_handle, interface_number);
+	else
+		return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+/** \ingroup libusb_dev
+ * Enable/disable libusb's automatic kernel driver detachment. When this is
+ * enabled libusb will automatically detach the kernel driver on an interface
+ * when claiming the interface, and attach it when releasing the interface.
+ *
+ * Automatic kernel driver detachment is disabled on newly opened device
+ * handles by default.
+ *
+ * On platforms which do not have LIBUSB_CAP_SUPPORTS_DETACH_KERNEL_DRIVER
+ * this function will return LIBUSB_ERROR_NOT_SUPPORTED, and libusb will
+ * continue as if this function was never called.
+ *
+ * \param dev_handle a device handle
+ * \param enable whether to enable or disable auto kernel driver detachment
+ *
+ * \returns LIBUSB_SUCCESS on success
+ * \returns LIBUSB_ERROR_NOT_SUPPORTED on platforms where the functionality
+ * is not available
+ * \see libusb_claim_interface()
+ * \see libusb_release_interface()
+ * \see libusb_set_configuration()
+ */
+int API_EXPORTED libusb_set_auto_detach_kernel_driver(
+	libusb_device_handle *dev_handle, int enable)
+{
+	if (!(usbi_backend.caps & USBI_CAP_SUPPORTS_DETACH_KERNEL_DRIVER))
+		return LIBUSB_ERROR_NOT_SUPPORTED;
+
+	dev_handle->auto_detach_kernel_driver = enable;
+	return LIBUSB_SUCCESS;
+}
+
+/** \ingroup libusb_lib
+ * \deprecated Use libusb_set_option() instead using the
+ * \ref LIBUSB_OPTION_LOG_LEVEL option.
+ */
+void API_EXPORTED libusb_set_debug(libusb_context *ctx, int level)
+{
+#if defined(ENABLE_LOGGING) && !defined(ENABLE_DEBUG_LOGGING)
+	USBI_GET_CONTEXT(ctx);
+	if (!ctx->debug_fixed) {
+		level = CLAMP(level, LIBUSB_LOG_LEVEL_NONE, LIBUSB_LOG_LEVEL_DEBUG);
+		ctx->debug = (enum libusb_log_level)level;
+	}
+#else
+	UNUSED(ctx);
+	UNUSED(level);
+#endif
+}
+
+/** \ingroup libusb_lib
+ * Set an option in the library.
+ *
+ * Use this function to configure a specific option within the library.
+ *
+ * Some options require one or more arguments to be provided. Consult each
+ * option's documentation for specific requirements.
+ *
+ * Since version 1.0.22, \ref LIBUSB_API_VERSION >= 0x01000106
+ *
+ * \param ctx context on which to operate
+ * \param option which option to set
+ * \param ... any required arguments for the specified option
+ *
+ * \returns LIBUSB_SUCCESS on success
+ * \returns LIBUSB_ERROR_INVALID_PARAM if the option or arguments are invalid
+ * \returns LIBUSB_ERROR_NOT_SUPPORTED if the option is valid but not supported
+ * on this platform
+ */
+int API_EXPORTED libusb_set_option(libusb_context *ctx,
+	enum libusb_option option, ...)
+{
+	int arg, r = LIBUSB_SUCCESS;
+	va_list ap;
+
+	USBI_GET_CONTEXT(ctx);
+
+	va_start(ap, option);
+	switch (option) {
+	case LIBUSB_OPTION_LOG_LEVEL:
+		arg = va_arg(ap, int);
+		if (arg < LIBUSB_LOG_LEVEL_NONE || arg > LIBUSB_LOG_LEVEL_DEBUG) {
+			r = LIBUSB_ERROR_INVALID_PARAM;
+			break;
+		}
+#if defined(ENABLE_LOGGING) && !defined(ENABLE_DEBUG_LOGGING)
+		if (!ctx->debug_fixed)
+			ctx->debug = (enum libusb_log_level)arg;
+#endif
+		break;
+
+	/* Handle all backend-specific options here */
+	case LIBUSB_OPTION_USE_USBDK:
+		if (usbi_backend.set_option)
+			r = usbi_backend.set_option(ctx, option, ap);
+		else
+			r = LIBUSB_ERROR_NOT_SUPPORTED;
+		break;
+
+	default:
+		r = LIBUSB_ERROR_INVALID_PARAM;
+	}
+	va_end(ap);
+
+	return r;
+}
+
+#if defined(ENABLE_LOGGING) && !defined(ENABLE_DEBUG_LOGGING)
+/* returns the log level as defined in the LIBUSB_DEBUG environment variable.
+ * if LIBUSB_DEBUG is not present or not a number, returns LIBUSB_LOG_LEVEL_NONE.
+ * value is clamped to ensure it is within the valid range of possibilities.
+ */
+static enum libusb_log_level get_env_debug_level(void)
+{
+	const char *dbg = getenv("LIBUSB_DEBUG");
+	enum libusb_log_level level;
+	if (dbg) {
+		int dbg_level = atoi(dbg);
+		dbg_level = CLAMP(dbg_level, LIBUSB_LOG_LEVEL_NONE, LIBUSB_LOG_LEVEL_DEBUG);
+		level = (enum libusb_log_level)dbg_level;
+	} else {
+		level = LIBUSB_LOG_LEVEL_NONE;
+	}
+	return level;
+}
+#endif
+
+/** \ingroup libusb_lib
+ * Initialize libusb. This function must be called before calling any other
+ * libusb function.
+ *
+ * If you do not provide an output location for a context pointer, a default
+ * context will be created. If there was already a default context, it will
+ * be reused (and nothing will be initialized/reinitialized).
+ *
+ * \param context Optional output location for context pointer.
+ * Only valid on return code 0.
+ * \returns 0 on success, or a LIBUSB_ERROR code on failure
+ * \see libusb_contexts
+ */
+int API_EXPORTED libusb_init(libusb_context **context)
+{
+	struct libusb_device *dev, *next;
+	size_t priv_size = usbi_backend.context_priv_size;
+	struct libusb_context *ctx;
+	static int first_init = 1;
+	int r = 0;
+
+	usbi_mutex_static_lock(&default_context_lock);
+
+	if (!timestamp_origin.tv_sec) {
+		usbi_backend.clock_gettime(USBI_CLOCK_REALTIME, &timestamp_origin);
+	}
+
+	if (!context && usbi_default_context) {
+		usbi_dbg("reusing default context");
+		default_context_refcnt++;
+		usbi_mutex_static_unlock(&default_context_lock);
+		return 0;
+	}
+
+	ctx = calloc(1, sizeof(*ctx) + priv_size);
+	if (!ctx) {
+		r = LIBUSB_ERROR_NO_MEM;
+		goto err_unlock;
+	}
+
+#if defined(ENABLE_LOGGING) && !defined(ENABLE_DEBUG_LOGGING)
+	ctx->debug = get_env_debug_level();
+	if (ctx->debug != LIBUSB_LOG_LEVEL_NONE)
+		ctx->debug_fixed = 1;
+#endif
+
+	/* default context should be initialized before calling usbi_dbg */
+	if (!usbi_default_context) {
+		usbi_default_context = ctx;
+		default_context_refcnt++;
+		usbi_dbg("created default context");
+	}
+
+	usbi_dbg("libusb v%u.%u.%u.%u%s", libusb_version_internal.major, libusb_version_internal.minor,
+		libusb_version_internal.micro, libusb_version_internal.nano, libusb_version_internal.rc);
+
+	usbi_mutex_init(&ctx->usb_devs_lock);
+	usbi_mutex_init(&ctx->open_devs_lock);
+	usbi_mutex_init(&ctx->hotplug_cbs_lock);
+	list_init(&ctx->usb_devs);
+	list_init(&ctx->open_devs);
+	list_init(&ctx->hotplug_cbs);
+	ctx->next_hotplug_cb_handle = 1;
+
+	usbi_mutex_static_lock(&active_contexts_lock);
+	if (first_init) {
+		first_init = 0;
+		list_init (&active_contexts_list);
+	}
+	list_add (&ctx->list, &active_contexts_list);
+	usbi_mutex_static_unlock(&active_contexts_lock);
+
+	if (usbi_backend.init) {
+		r = usbi_backend.init(ctx);
+		if (r)
+			goto err_free_ctx;
+	}
+
+	r = usbi_io_init(ctx);
+	if (r < 0)
+		goto err_backend_exit;
+
+	usbi_mutex_static_unlock(&default_context_lock);
+
+	if (context)
+		*context = ctx;
+
+	return 0;
+
+err_backend_exit:
+	if (usbi_backend.exit)
+		usbi_backend.exit(ctx);
+err_free_ctx:
+	if (ctx == usbi_default_context) {
+		usbi_default_context = NULL;
+		default_context_refcnt--;
+	}
+
+	usbi_mutex_static_lock(&active_contexts_lock);
+	list_del (&ctx->list);
+	usbi_mutex_static_unlock(&active_contexts_lock);
+
+	usbi_mutex_lock(&ctx->usb_devs_lock);
+	list_for_each_entry_safe(dev, next, &ctx->usb_devs, list, struct libusb_device) {
+		list_del(&dev->list);
+		libusb_unref_device(dev);
+	}
+	usbi_mutex_unlock(&ctx->usb_devs_lock);
+
+	usbi_mutex_destroy(&ctx->open_devs_lock);
+	usbi_mutex_destroy(&ctx->usb_devs_lock);
+	usbi_mutex_destroy(&ctx->hotplug_cbs_lock);
+
+	free(ctx);
+err_unlock:
+	usbi_mutex_static_unlock(&default_context_lock);
+	return r;
+}
+
+/** \ingroup libusb_lib
+ * Deinitialize libusb. Should be called after closing all open devices and
+ * before your application terminates.
+ * \param ctx the context to deinitialize, or NULL for the default context
+ */
+void API_EXPORTED libusb_exit(struct libusb_context *ctx)
+{
+	struct libusb_device *dev, *next;
+	struct timeval tv = { 0, 0 };
+
+	usbi_dbg("");
+	USBI_GET_CONTEXT(ctx);
+
+	/* if working with default context, only actually do the deinitialization
+	 * if we're the last user */
+	usbi_mutex_static_lock(&default_context_lock);
+	if (ctx == usbi_default_context) {
+		if (--default_context_refcnt > 0) {
+			usbi_dbg("not destroying default context");
+			usbi_mutex_static_unlock(&default_context_lock);
+			return;
+		}
+		usbi_dbg("destroying default context");
+		usbi_default_context = NULL;
+	}
+	usbi_mutex_static_unlock(&default_context_lock);
+
+	usbi_mutex_static_lock(&active_contexts_lock);
+	list_del (&ctx->list);
+	usbi_mutex_static_unlock(&active_contexts_lock);
+
+	if (libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG)) {
+		usbi_hotplug_deregister(ctx, 1);
+
+		/*
+		 * Ensure any pending unplug events are read from the hotplug
+		 * pipe. The usb_device-s hold in the events are no longer part
+		 * of usb_devs, but the events still hold a reference!
+		 *
+		 * Note we don't do this if the application has left devices
+		 * open (which implies a buggy app) to avoid packet completion
+		 * handlers running when the app does not expect them to run.
+		 */
+		if (list_empty(&ctx->open_devs))
+			libusb_handle_events_timeout(ctx, &tv);
+
+		usbi_mutex_lock(&ctx->usb_devs_lock);
+		list_for_each_entry_safe(dev, next, &ctx->usb_devs, list, struct libusb_device) {
+			list_del(&dev->list);
+			libusb_unref_device(dev);
+		}
+		usbi_mutex_unlock(&ctx->usb_devs_lock);
+	}
+
+	/* a few sanity checks. don't bother with locking because unless
+	 * there is an application bug, nobody will be accessing these. */
+	if (!list_empty(&ctx->usb_devs))
+		usbi_warn(ctx, "some libusb_devices were leaked");
+	if (!list_empty(&ctx->open_devs))
+		usbi_warn(ctx, "application left some devices open");
+
+	usbi_io_exit(ctx);
+	if (usbi_backend.exit)
+		usbi_backend.exit(ctx);
+
+	usbi_mutex_destroy(&ctx->open_devs_lock);
+	usbi_mutex_destroy(&ctx->usb_devs_lock);
+	usbi_mutex_destroy(&ctx->hotplug_cbs_lock);
+	free(ctx);
+}
+
+/** \ingroup libusb_misc
+ * Check at runtime if the loaded library has a given capability.
+ * This call should be performed after \ref libusb_init(), to ensure the
+ * backend has updated its capability set.
+ *
+ * \param capability the \ref libusb_capability to check for
+ * \returns nonzero if the running library has the capability, 0 otherwise
+ */
+int API_EXPORTED libusb_has_capability(uint32_t capability)
+{
+	switch (capability) {
+	case LIBUSB_CAP_HAS_CAPABILITY:
+		return 1;
+	case LIBUSB_CAP_HAS_HOTPLUG:
+		return !(usbi_backend.get_device_list);
+	case LIBUSB_CAP_HAS_HID_ACCESS:
+		return (usbi_backend.caps & USBI_CAP_HAS_HID_ACCESS);
+	case LIBUSB_CAP_SUPPORTS_DETACH_KERNEL_DRIVER:
+		return (usbi_backend.caps & USBI_CAP_SUPPORTS_DETACH_KERNEL_DRIVER);
+	}
+	return 0;
+}
+
+#ifdef ENABLE_LOGGING
+
+/* this is defined in libusbi.h if needed */
+#ifdef LIBUSB_PRINTF_WIN32
+/*
+ * Prior to VS2015, Microsoft did not provide the snprintf() function and
+ * provided a vsnprintf() that did not guarantee NULL-terminated output.
+ * Microsoft did provide a _snprintf() function, but again it did not
+ * guarantee NULL-terminated output.
+ *
+ * The below implementations guarantee NULL-terminated output and are
+ * C99 compliant.
+ */
+
+int usbi_snprintf(char *str, size_t size, const char *format, ...)
+{
+	va_list ap;
+	int ret;
+
+	va_start(ap, format);
+	ret = usbi_vsnprintf(str, size, format, ap);
+	va_end(ap);
+
+	return ret;
+}
+
+int usbi_vsnprintf(char *str, size_t size, const char *format, va_list ap)
+{
+	int ret;
+
+	ret = _vsnprintf(str, size, format, ap);
+	if (ret < 0 || ret == (int)size) {
+		/* Output is truncated, ensure buffer is NULL-terminated and
+		 * determine how many characters would have been written. */
+		str[size - 1] = '\0';
+		if (ret < 0)
+			ret = _vsnprintf(NULL, 0, format, ap);
+	}
+
+	return ret;
+}
+#endif /* LIBUSB_PRINTF_WIN32 */
+
+static void usbi_log_str(enum libusb_log_level level, const char *str)
+{
+#if defined(USE_SYSTEM_LOGGING_FACILITY)
+#if defined(OS_WINDOWS)
+	OutputDebugString(str);
+#elif defined(OS_WINCE)
+	/* Windows CE only supports the Unicode version of OutputDebugString. */
+	WCHAR wbuf[USBI_MAX_LOG_LEN];
+	MultiByteToWideChar(CP_UTF8, 0, str, -1, wbuf, sizeof(wbuf));
+	OutputDebugStringW(wbuf);
+#elif defined(__ANDROID__)
+	int priority = ANDROID_LOG_UNKNOWN;
+	switch (level) {
+	case LIBUSB_LOG_LEVEL_NONE: return;
+	case LIBUSB_LOG_LEVEL_ERROR: priority = ANDROID_LOG_ERROR; break;
+	case LIBUSB_LOG_LEVEL_WARNING: priority = ANDROID_LOG_WARN; break;
+	case LIBUSB_LOG_LEVEL_INFO: priority = ANDROID_LOG_INFO; break;
+	case LIBUSB_LOG_LEVEL_DEBUG: priority = ANDROID_LOG_DEBUG; break;
+	}
+	__android_log_write(priority, "libusb", str);
+#elif defined(HAVE_SYSLOG_FUNC)
+	int syslog_level = LOG_INFO;
+	switch (level) {
+	case LIBUSB_LOG_LEVEL_NONE: return;
+	case LIBUSB_LOG_LEVEL_ERROR: syslog_level = LOG_ERR; break;
+	case LIBUSB_LOG_LEVEL_WARNING: syslog_level = LOG_WARNING; break;
+	case LIBUSB_LOG_LEVEL_INFO: syslog_level = LOG_INFO; break;
+	case LIBUSB_LOG_LEVEL_DEBUG: syslog_level = LOG_DEBUG; break;
+	}
+	syslog(syslog_level, "%s", str);
+#else /* All of gcc, Clang, XCode seem to use #warning */
+#warning System logging is not supported on this platform. Logging to stderr will be used instead.
+	fputs(str, stderr);
+#endif
+#else
+	fputs(str, stderr);
+#endif /* USE_SYSTEM_LOGGING_FACILITY */
+	UNUSED(level);
+}
+
+void usbi_log_v(struct libusb_context *ctx, enum libusb_log_level level,
+	const char *function, const char *format, va_list args)
+{
+	const char *prefix;
+	char buf[USBI_MAX_LOG_LEN];
+	struct timespec now;
+	int global_debug, header_len, text_len;
+	static int has_debug_header_been_displayed = 0;
+
+#ifdef ENABLE_DEBUG_LOGGING
+	global_debug = 1;
+	UNUSED(ctx);
+#else
+	enum libusb_log_level ctx_level = LIBUSB_LOG_LEVEL_NONE;
+
+	USBI_GET_CONTEXT(ctx);
+	if (ctx)
+		ctx_level = ctx->debug;
+	else
+		ctx_level = get_env_debug_level();
+
+	if (ctx_level == LIBUSB_LOG_LEVEL_NONE)
+		return;
+	if (level == LIBUSB_LOG_LEVEL_WARNING && ctx_level < LIBUSB_LOG_LEVEL_WARNING)
+		return;
+	if (level == LIBUSB_LOG_LEVEL_INFO && ctx_level < LIBUSB_LOG_LEVEL_INFO)
+		return;
+	if (level == LIBUSB_LOG_LEVEL_DEBUG && ctx_level < LIBUSB_LOG_LEVEL_DEBUG)
+		return;
+
+	global_debug = (ctx_level == LIBUSB_LOG_LEVEL_DEBUG);
+#endif
+
+	usbi_backend.clock_gettime(USBI_CLOCK_REALTIME, &now);
+	if ((global_debug) && (!has_debug_header_been_displayed)) {
+		has_debug_header_been_displayed = 1;
+		usbi_log_str(LIBUSB_LOG_LEVEL_DEBUG, "[timestamp] [threadID] facility level [function call] <message>" USBI_LOG_LINE_END);
+		usbi_log_str(LIBUSB_LOG_LEVEL_DEBUG, "--------------------------------------------------------------------------------" USBI_LOG_LINE_END);
+	}
+	if (now.tv_nsec < timestamp_origin.tv_nsec) {
+		now.tv_sec--;
+		now.tv_nsec += 1000000000L;
+	}
+	now.tv_sec -= timestamp_origin.tv_sec;
+	now.tv_nsec -= timestamp_origin.tv_nsec;
+
+	switch (level) {
+	case LIBUSB_LOG_LEVEL_NONE:
+		return;
+	case LIBUSB_LOG_LEVEL_ERROR:
+		prefix = "error";
+		break;
+	case LIBUSB_LOG_LEVEL_WARNING:
+		prefix = "warning";
+		break;
+	case LIBUSB_LOG_LEVEL_INFO:
+		prefix = "info";
+		break;
+	case LIBUSB_LOG_LEVEL_DEBUG:
+		prefix = "debug";
+		break;
+	default:
+		prefix = "unknown";
+		break;
+	}
+
+	if (global_debug) {
+		header_len = snprintf(buf, sizeof(buf),
+			"[%2d.%06d] [%08x] libusb: %s [%s] ",
+			(int)now.tv_sec, (int)(now.tv_nsec / 1000L), usbi_get_tid(), prefix, function);
+	} else {
+		header_len = snprintf(buf, sizeof(buf),
+			"libusb: %s [%s] ", prefix, function);
+	}
+
+	if (header_len < 0 || header_len >= (int)sizeof(buf)) {
+		/* Somehow snprintf failed to write to the buffer,
+		 * remove the header so something useful is output. */
+		header_len = 0;
+	}
+	/* Make sure buffer is NUL terminated */
+	buf[header_len] = '\0';
+	text_len = vsnprintf(buf + header_len, sizeof(buf) - header_len,
+		format, args);
+	if (text_len < 0 || text_len + header_len >= (int)sizeof(buf)) {
+		/* Truncated log output. On some platforms a -1 return value means
+		 * that the output was truncated. */
+		text_len = sizeof(buf) - header_len;
+	}
+	if (header_len + text_len + sizeof(USBI_LOG_LINE_END) >= sizeof(buf)) {
+		/* Need to truncate the text slightly to fit on the terminator. */
+		text_len -= (header_len + text_len + sizeof(USBI_LOG_LINE_END)) - sizeof(buf);
+	}
+	strcpy(buf + header_len + text_len, USBI_LOG_LINE_END);
+
+	usbi_log_str(level, buf);
+}
+
+void usbi_log(struct libusb_context *ctx, enum libusb_log_level level,
+	const char *function, const char *format, ...)
+{
+	va_list args;
+
+	va_start (args, format);
+	usbi_log_v(ctx, level, function, format, args);
+	va_end (args);
+}
+
+#endif /* ENABLE_LOGGING */
+
+/** \ingroup libusb_misc
+ * Returns a constant NULL-terminated string with the ASCII name of a libusb
+ * error or transfer status code. The caller must not free() the returned
+ * string.
+ *
+ * \param error_code The \ref libusb_error or libusb_transfer_status code to
+ * return the name of.
+ * \returns The error name, or the string **UNKNOWN** if the value of
+ * error_code is not a known error / status code.
+ */
+DEFAULT_VISIBILITY const char * LIBUSB_CALL libusb_error_name(int error_code)
+{
+	switch (error_code) {
+	case LIBUSB_ERROR_IO:
+		return "LIBUSB_ERROR_IO";
+	case LIBUSB_ERROR_INVALID_PARAM:
+		return "LIBUSB_ERROR_INVALID_PARAM";
+	case LIBUSB_ERROR_ACCESS:
+		return "LIBUSB_ERROR_ACCESS";
+	case LIBUSB_ERROR_NO_DEVICE:
+		return "LIBUSB_ERROR_NO_DEVICE";
+	case LIBUSB_ERROR_NOT_FOUND:
+		return "LIBUSB_ERROR_NOT_FOUND";
+	case LIBUSB_ERROR_BUSY:
+		return "LIBUSB_ERROR_BUSY";
+	case LIBUSB_ERROR_TIMEOUT:
+		return "LIBUSB_ERROR_TIMEOUT";
+	case LIBUSB_ERROR_OVERFLOW:
+		return "LIBUSB_ERROR_OVERFLOW";
+	case LIBUSB_ERROR_PIPE:
+		return "LIBUSB_ERROR_PIPE";
+	case LIBUSB_ERROR_INTERRUPTED:
+		return "LIBUSB_ERROR_INTERRUPTED";
+	case LIBUSB_ERROR_NO_MEM:
+		return "LIBUSB_ERROR_NO_MEM";
+	case LIBUSB_ERROR_NOT_SUPPORTED:
+		return "LIBUSB_ERROR_NOT_SUPPORTED";
+	case LIBUSB_ERROR_OTHER:
+		return "LIBUSB_ERROR_OTHER";
+
+	case LIBUSB_TRANSFER_ERROR:
+		return "LIBUSB_TRANSFER_ERROR";
+	case LIBUSB_TRANSFER_TIMED_OUT:
+		return "LIBUSB_TRANSFER_TIMED_OUT";
+	case LIBUSB_TRANSFER_CANCELLED:
+		return "LIBUSB_TRANSFER_CANCELLED";
+	case LIBUSB_TRANSFER_STALL:
+		return "LIBUSB_TRANSFER_STALL";
+	case LIBUSB_TRANSFER_NO_DEVICE:
+		return "LIBUSB_TRANSFER_NO_DEVICE";
+	case LIBUSB_TRANSFER_OVERFLOW:
+		return "LIBUSB_TRANSFER_OVERFLOW";
+
+	case 0:
+		return "LIBUSB_SUCCESS / LIBUSB_TRANSFER_COMPLETED";
+	default:
+		return "**UNKNOWN**";
+	}
+}
+
+/** \ingroup libusb_misc
+ * Returns a pointer to const struct libusb_version with the version
+ * (major, minor, micro, nano and rc) of the running library.
+ */
+DEFAULT_VISIBILITY
+const struct libusb_version * LIBUSB_CALL libusb_get_version(void)
+{
+	return &libusb_version_internal;
+}
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/descriptor.c b/vendor/github.com/karalabe/usb/libusb/libusb/descriptor.c
new file mode 100644
index 000000000..74d6de557
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/descriptor.c
@@ -0,0 +1,1192 @@
+/* -*- Mode: C; indent-tabs-mode:t ; c-basic-offset:8 -*- */
+/*
+ * USB descriptor handling functions for libusb
+ * Copyright © 2007 Daniel Drake <dsd@gentoo.org>
+ * Copyright © 2001 Johannes Erdfelt <johannes@erdfelt.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <config.h>
+
+#include <errno.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "libusbi.h"
+
+#define DESC_HEADER_LENGTH		2
+#define DEVICE_DESC_LENGTH		18
+#define CONFIG_DESC_LENGTH		9
+#define INTERFACE_DESC_LENGTH		9
+#define ENDPOINT_DESC_LENGTH		7
+#define ENDPOINT_AUDIO_DESC_LENGTH	9
+
+/** @defgroup libusb_desc USB descriptors
+ * This page details how to examine the various standard USB descriptors
+ * for detected devices
+ */
+
+/* set host_endian if the w values are already in host endian format,
+ * as opposed to bus endian. */
+int usbi_parse_descriptor(const unsigned char *source, const char *descriptor,
+	void *dest, int host_endian)
+{
+	const unsigned char *sp = source;
+	unsigned char *dp = dest;
+	uint16_t w;
+	const char *cp;
+	uint32_t d;
+
+	for (cp = descriptor; *cp; cp++) {
+		switch (*cp) {
+			case 'b':	/* 8-bit byte */
+				*dp++ = *sp++;
+				break;
+			case 'w':	/* 16-bit word, convert from little endian to CPU */
+				dp += ((uintptr_t)dp & 1);	/* Align to word boundary */
+
+				if (host_endian) {
+					memcpy(dp, sp, 2);
+				} else {
+					w = (sp[1] << 8) | sp[0];
+					*((uint16_t *)dp) = w;
+				}
+				sp += 2;
+				dp += 2;
+				break;
+			case 'd':	/* 32-bit word, convert from little endian to CPU */
+				dp += ((uintptr_t)dp & 1);	/* Align to word boundary */
+
+				if (host_endian) {
+					memcpy(dp, sp, 4);
+				} else {
+					d = (sp[3] << 24) | (sp[2] << 16) |
+						(sp[1] << 8) | sp[0];
+					*((uint32_t *)dp) = d;
+				}
+				sp += 4;
+				dp += 4;
+				break;
+			case 'u':	/* 16 byte UUID */
+				memcpy(dp, sp, 16);
+				sp += 16;
+				dp += 16;
+				break;
+		}
+	}
+
+	return (int) (sp - source);
+}
+
+static void clear_endpoint(struct libusb_endpoint_descriptor *endpoint)
+{
+	free((void *) endpoint->extra);
+}
+
+static int parse_endpoint(struct libusb_context *ctx,
+	struct libusb_endpoint_descriptor *endpoint, unsigned char *buffer,
+	int size, int host_endian)
+{
+	struct usb_descriptor_header header;
+	unsigned char *extra;
+	unsigned char *begin;
+	int parsed = 0;
+	int len;
+
+	if (size < DESC_HEADER_LENGTH) {
+		usbi_err(ctx, "short endpoint descriptor read %d/%d",
+			 size, DESC_HEADER_LENGTH);
+		return LIBUSB_ERROR_IO;
+	}
+
+	usbi_parse_descriptor(buffer, "bb", &header, 0);
+	if (header.bDescriptorType != LIBUSB_DT_ENDPOINT) {
+		usbi_err(ctx, "unexpected descriptor %x (expected %x)",
+			header.bDescriptorType, LIBUSB_DT_ENDPOINT);
+		return parsed;
+	}
+	if (header.bLength > size) {
+		usbi_warn(ctx, "short endpoint descriptor read %d/%d",
+			  size, header.bLength);
+		return parsed;
+	}
+	if (header.bLength >= ENDPOINT_AUDIO_DESC_LENGTH)
+		usbi_parse_descriptor(buffer, "bbbbwbbb", endpoint, host_endian);
+	else if (header.bLength >= ENDPOINT_DESC_LENGTH)
+		usbi_parse_descriptor(buffer, "bbbbwb", endpoint, host_endian);
+	else {
+		usbi_err(ctx, "invalid endpoint bLength (%d)", header.bLength);
+		return LIBUSB_ERROR_IO;
+	}
+
+	buffer += header.bLength;
+	size -= header.bLength;
+	parsed += header.bLength;
+
+	/* Skip over the rest of the Class Specific or Vendor Specific */
+	/*  descriptors */
+	begin = buffer;
+	while (size >= DESC_HEADER_LENGTH) {
+		usbi_parse_descriptor(buffer, "bb", &header, 0);
+		if (header.bLength < DESC_HEADER_LENGTH) {
+			usbi_err(ctx, "invalid extra ep desc len (%d)",
+				 header.bLength);
+			return LIBUSB_ERROR_IO;
+		} else if (header.bLength > size) {
+			usbi_warn(ctx, "short extra ep desc read %d/%d",
+				  size, header.bLength);
+			return parsed;
+		}
+
+		/* If we find another "proper" descriptor then we're done  */
+		if ((header.bDescriptorType == LIBUSB_DT_ENDPOINT) ||
+				(header.bDescriptorType == LIBUSB_DT_INTERFACE) ||
+				(header.bDescriptorType == LIBUSB_DT_CONFIG) ||
+				(header.bDescriptorType == LIBUSB_DT_DEVICE))
+			break;
+
+		usbi_dbg("skipping descriptor %x", header.bDescriptorType);
+		buffer += header.bLength;
+		size -= header.bLength;
+		parsed += header.bLength;
+	}
+
+	/* Copy any unknown descriptors into a storage area for drivers */
+	/*  to later parse */
+	len = (int)(buffer - begin);
+	if (!len) {
+		endpoint->extra = NULL;
+		endpoint->extra_length = 0;
+		return parsed;
+	}
+
+	extra = malloc(len);
+	endpoint->extra = extra;
+	if (!extra) {
+		endpoint->extra_length = 0;
+		return LIBUSB_ERROR_NO_MEM;
+	}
+
+	memcpy(extra, begin, len);
+	endpoint->extra_length = len;
+
+	return parsed;
+}
+
+static void clear_interface(struct libusb_interface *usb_interface)
+{
+	int i;
+	int j;
+
+	if (usb_interface->altsetting) {
+		for (i = 0; i < usb_interface->num_altsetting; i++) {
+			struct libusb_interface_descriptor *ifp =
+				(struct libusb_interface_descriptor *)
+				usb_interface->altsetting + i;
+			free((void *) ifp->extra);
+			if (ifp->endpoint) {
+				for (j = 0; j < ifp->bNumEndpoints; j++)
+					clear_endpoint((struct libusb_endpoint_descriptor *)
+						       ifp->endpoint + j);
+			}
+			free((void *) ifp->endpoint);
+		}
+	}
+	free((void *) usb_interface->altsetting);
+	usb_interface->altsetting = NULL;
+}
+
+static int parse_interface(libusb_context *ctx,
+	struct libusb_interface *usb_interface, unsigned char *buffer, int size,
+	int host_endian)
+{
+	int i;
+	int len;
+	int r;
+	int parsed = 0;
+	int interface_number = -1;
+	struct usb_descriptor_header header;
+	struct libusb_interface_descriptor *ifp;
+	unsigned char *begin;
+
+	usb_interface->num_altsetting = 0;
+
+	while (size >= INTERFACE_DESC_LENGTH) {
+		struct libusb_interface_descriptor *altsetting =
+			(struct libusb_interface_descriptor *) usb_interface->altsetting;
+		altsetting = usbi_reallocf(altsetting,
+			sizeof(struct libusb_interface_descriptor) *
+			(usb_interface->num_altsetting + 1));
+		if (!altsetting) {
+			r = LIBUSB_ERROR_NO_MEM;
+			goto err;
+		}
+		usb_interface->altsetting = altsetting;
+
+		ifp = altsetting + usb_interface->num_altsetting;
+		usbi_parse_descriptor(buffer, "bbbbbbbbb", ifp, 0);
+		if (ifp->bDescriptorType != LIBUSB_DT_INTERFACE) {
+			usbi_err(ctx, "unexpected descriptor %x (expected %x)",
+				 ifp->bDescriptorType, LIBUSB_DT_INTERFACE);
+			return parsed;
+		}
+		if (ifp->bLength < INTERFACE_DESC_LENGTH) {
+			usbi_err(ctx, "invalid interface bLength (%d)",
+				 ifp->bLength);
+			r = LIBUSB_ERROR_IO;
+			goto err;
+		}
+		if (ifp->bLength > size) {
+			usbi_warn(ctx, "short intf descriptor read %d/%d",
+				 size, ifp->bLength);
+			return parsed;
+		}
+		if (ifp->bNumEndpoints > USB_MAXENDPOINTS) {
+			usbi_err(ctx, "too many endpoints (%d)", ifp->bNumEndpoints);
+			r = LIBUSB_ERROR_IO;
+			goto err;
+		}
+
+		usb_interface->num_altsetting++;
+		ifp->extra = NULL;
+		ifp->extra_length = 0;
+		ifp->endpoint = NULL;
+
+		if (interface_number == -1)
+			interface_number = ifp->bInterfaceNumber;
+
+		/* Skip over the interface */
+		buffer += ifp->bLength;
+		parsed += ifp->bLength;
+		size -= ifp->bLength;
+
+		begin = buffer;
+
+		/* Skip over any interface, class or vendor descriptors */
+		while (size >= DESC_HEADER_LENGTH) {
+			usbi_parse_descriptor(buffer, "bb", &header, 0);
+			if (header.bLength < DESC_HEADER_LENGTH) {
+				usbi_err(ctx,
+					 "invalid extra intf desc len (%d)",
+					 header.bLength);
+				r = LIBUSB_ERROR_IO;
+				goto err;
+			} else if (header.bLength > size) {
+				usbi_warn(ctx,
+					  "short extra intf desc read %d/%d",
+					  size, header.bLength);
+				return parsed;
+			}
+
+			/* If we find another "proper" descriptor then we're done */
+			if ((header.bDescriptorType == LIBUSB_DT_INTERFACE) ||
+					(header.bDescriptorType == LIBUSB_DT_ENDPOINT) ||
+					(header.bDescriptorType == LIBUSB_DT_CONFIG) ||
+					(header.bDescriptorType == LIBUSB_DT_DEVICE))
+				break;
+
+			buffer += header.bLength;
+			parsed += header.bLength;
+			size -= header.bLength;
+		}
+
+		/* Copy any unknown descriptors into a storage area for */
+		/*  drivers to later parse */
+		len = (int)(buffer - begin);
+		if (len) {
+			ifp->extra = malloc(len);
+			if (!ifp->extra) {
+				r = LIBUSB_ERROR_NO_MEM;
+				goto err;
+			}
+			memcpy((unsigned char *) ifp->extra, begin, len);
+			ifp->extra_length = len;
+		}
+
+		if (ifp->bNumEndpoints > 0) {
+			struct libusb_endpoint_descriptor *endpoint;
+			endpoint = calloc(ifp->bNumEndpoints, sizeof(struct libusb_endpoint_descriptor));
+			ifp->endpoint = endpoint;
+			if (!endpoint) {
+				r = LIBUSB_ERROR_NO_MEM;
+				goto err;
+			}
+
+			for (i = 0; i < ifp->bNumEndpoints; i++) {
+				r = parse_endpoint(ctx, endpoint + i, buffer, size,
+					host_endian);
+				if (r < 0)
+					goto err;
+				if (r == 0) {
+					ifp->bNumEndpoints = (uint8_t)i;
+					break;
+				}
+
+				buffer += r;
+				parsed += r;
+				size -= r;
+			}
+		}
+
+		/* We check to see if it's an alternate to this one */
+		ifp = (struct libusb_interface_descriptor *) buffer;
+		if (size < LIBUSB_DT_INTERFACE_SIZE ||
+				ifp->bDescriptorType != LIBUSB_DT_INTERFACE ||
+				ifp->bInterfaceNumber != interface_number)
+			return parsed;
+	}
+
+	return parsed;
+err:
+	clear_interface(usb_interface);
+	return r;
+}
+
+static void clear_configuration(struct libusb_config_descriptor *config)
+{
+	int i;
+	if (config->interface) {
+		for (i = 0; i < config->bNumInterfaces; i++)
+			clear_interface((struct libusb_interface *)
+					config->interface + i);
+	}
+	free((void *) config->interface);
+	free((void *) config->extra);
+}
+
+static int parse_configuration(struct libusb_context *ctx,
+	struct libusb_config_descriptor *config, unsigned char *buffer,
+	int size, int host_endian)
+{
+	int i;
+	int r;
+	struct usb_descriptor_header header;
+	struct libusb_interface *usb_interface;
+
+	if (size < LIBUSB_DT_CONFIG_SIZE) {
+		usbi_err(ctx, "short config descriptor read %d/%d",
+			 size, LIBUSB_DT_CONFIG_SIZE);
+		return LIBUSB_ERROR_IO;
+	}
+
+	usbi_parse_descriptor(buffer, "bbwbbbbb", config, host_endian);
+	if (config->bDescriptorType != LIBUSB_DT_CONFIG) {
+		usbi_err(ctx, "unexpected descriptor %x (expected %x)",
+			 config->bDescriptorType, LIBUSB_DT_CONFIG);
+		return LIBUSB_ERROR_IO;
+	}
+	if (config->bLength < LIBUSB_DT_CONFIG_SIZE) {
+		usbi_err(ctx, "invalid config bLength (%d)", config->bLength);
+		return LIBUSB_ERROR_IO;
+	}
+	if (config->bLength > size) {
+		usbi_err(ctx, "short config descriptor read %d/%d",
+			 size, config->bLength);
+		return LIBUSB_ERROR_IO;
+	}
+	if (config->bNumInterfaces > USB_MAXINTERFACES) {
+		usbi_err(ctx, "too many interfaces (%d)", config->bNumInterfaces);
+		return LIBUSB_ERROR_IO;
+	}
+
+	usb_interface = calloc(config->bNumInterfaces, sizeof(struct libusb_interface));
+	config->interface = usb_interface;
+	if (!usb_interface)
+		return LIBUSB_ERROR_NO_MEM;
+
+	buffer += config->bLength;
+	size -= config->bLength;
+
+	config->extra = NULL;
+	config->extra_length = 0;
+
+	for (i = 0; i < config->bNumInterfaces; i++) {
+		int len;
+		unsigned char *begin;
+
+		/* Skip over the rest of the Class Specific or Vendor */
+		/*  Specific descriptors */
+		begin = buffer;
+		while (size >= DESC_HEADER_LENGTH) {
+			usbi_parse_descriptor(buffer, "bb", &header, 0);
+
+			if (header.bLength < DESC_HEADER_LENGTH) {
+				usbi_err(ctx,
+					 "invalid extra config desc len (%d)",
+					 header.bLength);
+				r = LIBUSB_ERROR_IO;
+				goto err;
+			} else if (header.bLength > size) {
+				usbi_warn(ctx,
+					  "short extra config desc read %d/%d",
+					  size, header.bLength);
+				config->bNumInterfaces = (uint8_t)i;
+				return size;
+			}
+
+			/* If we find another "proper" descriptor then we're done */
+			if ((header.bDescriptorType == LIBUSB_DT_ENDPOINT) ||
+					(header.bDescriptorType == LIBUSB_DT_INTERFACE) ||
+					(header.bDescriptorType == LIBUSB_DT_CONFIG) ||
+					(header.bDescriptorType == LIBUSB_DT_DEVICE))
+				break;
+
+			usbi_dbg("skipping descriptor 0x%x", header.bDescriptorType);
+			buffer += header.bLength;
+			size -= header.bLength;
+		}
+
+		/* Copy any unknown descriptors into a storage area for */
+		/*  drivers to later parse */
+		len = (int)(buffer - begin);
+		if (len) {
+			/* FIXME: We should realloc and append here */
+			if (!config->extra_length) {
+				config->extra = malloc(len);
+				if (!config->extra) {
+					r = LIBUSB_ERROR_NO_MEM;
+					goto err;
+				}
+
+				memcpy((unsigned char *) config->extra, begin, len);
+				config->extra_length = len;
+			}
+		}
+
+		r = parse_interface(ctx, usb_interface + i, buffer, size, host_endian);
+		if (r < 0)
+			goto err;
+		if (r == 0) {
+			config->bNumInterfaces = (uint8_t)i;
+			break;
+		}
+
+		buffer += r;
+		size -= r;
+	}
+
+	return size;
+
+err:
+	clear_configuration(config);
+	return r;
+}
+
+static int raw_desc_to_config(struct libusb_context *ctx,
+	unsigned char *buf, int size, int host_endian,
+	struct libusb_config_descriptor **config)
+{
+	struct libusb_config_descriptor *_config = malloc(sizeof(*_config));
+	int r;
+	
+	if (!_config)
+		return LIBUSB_ERROR_NO_MEM;
+
+	r = parse_configuration(ctx, _config, buf, size, host_endian);
+	if (r < 0) {
+		usbi_err(ctx, "parse_configuration failed with error %d", r);
+		free(_config);
+		return r;
+	} else if (r > 0) {
+		usbi_warn(ctx, "still %d bytes of descriptor data left", r);
+	}
+	
+	*config = _config;
+	return LIBUSB_SUCCESS;
+}
+
+int usbi_device_cache_descriptor(libusb_device *dev)
+{
+	int r, host_endian = 0;
+
+	r = usbi_backend.get_device_descriptor(dev, (unsigned char *) &dev->device_descriptor,
+						&host_endian);
+	if (r < 0)
+		return r;
+
+	if (!host_endian) {
+		dev->device_descriptor.bcdUSB = libusb_le16_to_cpu(dev->device_descriptor.bcdUSB);
+		dev->device_descriptor.idVendor = libusb_le16_to_cpu(dev->device_descriptor.idVendor);
+		dev->device_descriptor.idProduct = libusb_le16_to_cpu(dev->device_descriptor.idProduct);
+		dev->device_descriptor.bcdDevice = libusb_le16_to_cpu(dev->device_descriptor.bcdDevice);
+	}
+
+	return LIBUSB_SUCCESS;
+}
+
+/** \ingroup libusb_desc
+ * Get the USB device descriptor for a given device.
+ *
+ * This is a non-blocking function; the device descriptor is cached in memory.
+ *
+ * Note since libusb-1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102, this
+ * function always succeeds.
+ *
+ * \param dev the device
+ * \param desc output location for the descriptor data
+ * \returns 0 on success or a LIBUSB_ERROR code on failure
+ */
+int API_EXPORTED libusb_get_device_descriptor(libusb_device *dev,
+	struct libusb_device_descriptor *desc)
+{
+	usbi_dbg("");
+	memcpy((unsigned char *) desc, (unsigned char *) &dev->device_descriptor,
+	       sizeof (dev->device_descriptor));
+	return 0;
+}
+
+/** \ingroup libusb_desc
+ * Get the USB configuration descriptor for the currently active configuration.
+ * This is a non-blocking function which does not involve any requests being
+ * sent to the device.
+ *
+ * \param dev a device
+ * \param config output location for the USB configuration descriptor. Only
+ * valid if 0 was returned. Must be freed with libusb_free_config_descriptor()
+ * after use.
+ * \returns 0 on success
+ * \returns LIBUSB_ERROR_NOT_FOUND if the device is in unconfigured state
+ * \returns another LIBUSB_ERROR code on error
+ * \see libusb_get_config_descriptor
+ */
+int API_EXPORTED libusb_get_active_config_descriptor(libusb_device *dev,
+	struct libusb_config_descriptor **config)
+{
+	struct libusb_config_descriptor _config;
+	unsigned char tmp[LIBUSB_DT_CONFIG_SIZE];
+	unsigned char *buf = NULL;
+	int host_endian = 0;
+	int r;
+
+	r = usbi_backend.get_active_config_descriptor(dev, tmp,
+		LIBUSB_DT_CONFIG_SIZE, &host_endian);
+	if (r < 0)
+		return r;
+	if (r < LIBUSB_DT_CONFIG_SIZE) {
+		usbi_err(dev->ctx, "short config descriptor read %d/%d",
+			 r, LIBUSB_DT_CONFIG_SIZE);
+		return LIBUSB_ERROR_IO;
+	}
+
+	usbi_parse_descriptor(tmp, "bbw", &_config, host_endian);
+	buf = malloc(_config.wTotalLength);
+	if (!buf)
+		return LIBUSB_ERROR_NO_MEM;
+
+	r = usbi_backend.get_active_config_descriptor(dev, buf,
+		_config.wTotalLength, &host_endian);
+	if (r >= 0)
+		r = raw_desc_to_config(dev->ctx, buf, r, host_endian, config);
+
+	free(buf);
+	return r;
+}
+
+/** \ingroup libusb_desc
+ * Get a USB configuration descriptor based on its index.
+ * This is a non-blocking function which does not involve any requests being
+ * sent to the device.
+ *
+ * \param dev a device
+ * \param config_index the index of the configuration you wish to retrieve
+ * \param config output location for the USB configuration descriptor. Only
+ * valid if 0 was returned. Must be freed with libusb_free_config_descriptor()
+ * after use.
+ * \returns 0 on success
+ * \returns LIBUSB_ERROR_NOT_FOUND if the configuration does not exist
+ * \returns another LIBUSB_ERROR code on error
+ * \see libusb_get_active_config_descriptor()
+ * \see libusb_get_config_descriptor_by_value()
+ */
+int API_EXPORTED libusb_get_config_descriptor(libusb_device *dev,
+	uint8_t config_index, struct libusb_config_descriptor **config)
+{
+	struct libusb_config_descriptor _config;
+	unsigned char tmp[LIBUSB_DT_CONFIG_SIZE];
+	unsigned char *buf = NULL;
+	int host_endian = 0;
+	int r;
+
+	usbi_dbg("index %d", config_index);
+	if (config_index >= dev->num_configurations)
+		return LIBUSB_ERROR_NOT_FOUND;
+
+	r = usbi_backend.get_config_descriptor(dev, config_index, tmp,
+		LIBUSB_DT_CONFIG_SIZE, &host_endian);
+	if (r < 0)
+		return r;
+	if (r < LIBUSB_DT_CONFIG_SIZE) {
+		usbi_err(dev->ctx, "short config descriptor read %d/%d",
+			 r, LIBUSB_DT_CONFIG_SIZE);
+		return LIBUSB_ERROR_IO;
+	}
+
+	usbi_parse_descriptor(tmp, "bbw", &_config, host_endian);
+	buf = malloc(_config.wTotalLength);
+	if (!buf)
+		return LIBUSB_ERROR_NO_MEM;
+
+	r = usbi_backend.get_config_descriptor(dev, config_index, buf,
+		_config.wTotalLength, &host_endian);
+	if (r >= 0)
+		r = raw_desc_to_config(dev->ctx, buf, r, host_endian, config);
+
+	free(buf);
+	return r;
+}
+
+/* iterate through all configurations, returning the index of the configuration
+ * matching a specific bConfigurationValue in the idx output parameter, or -1
+ * if the config was not found.
+ * returns 0 on success or a LIBUSB_ERROR code
+ */
+int usbi_get_config_index_by_value(struct libusb_device *dev,
+	uint8_t bConfigurationValue, int *idx)
+{
+	uint8_t i;
+
+	usbi_dbg("value %d", bConfigurationValue);
+	for (i = 0; i < dev->num_configurations; i++) {
+		unsigned char tmp[6];
+		int host_endian;
+		int r = usbi_backend.get_config_descriptor(dev, i, tmp, sizeof(tmp),
+			&host_endian);
+		if (r < 0) {
+			*idx = -1;
+			return r;
+		}
+		if (tmp[5] == bConfigurationValue) {
+			*idx = i;
+			return 0;
+		}
+	}
+
+	*idx = -1;
+	return 0;
+}
+
+/** \ingroup libusb_desc
+ * Get a USB configuration descriptor with a specific bConfigurationValue.
+ * This is a non-blocking function which does not involve any requests being
+ * sent to the device.
+ *
+ * \param dev a device
+ * \param bConfigurationValue the bConfigurationValue of the configuration you
+ * wish to retrieve
+ * \param config output location for the USB configuration descriptor. Only
+ * valid if 0 was returned. Must be freed with libusb_free_config_descriptor()
+ * after use.
+ * \returns 0 on success
+ * \returns LIBUSB_ERROR_NOT_FOUND if the configuration does not exist
+ * \returns another LIBUSB_ERROR code on error
+ * \see libusb_get_active_config_descriptor()
+ * \see libusb_get_config_descriptor()
+ */
+int API_EXPORTED libusb_get_config_descriptor_by_value(libusb_device *dev,
+	uint8_t bConfigurationValue, struct libusb_config_descriptor **config)
+{
+	int r, idx, host_endian;
+	unsigned char *buf = NULL;
+
+	if (usbi_backend.get_config_descriptor_by_value) {
+		r = usbi_backend.get_config_descriptor_by_value(dev,
+			bConfigurationValue, &buf, &host_endian);
+		if (r < 0)
+			return r;
+		return raw_desc_to_config(dev->ctx, buf, r, host_endian, config);
+	}
+
+	r = usbi_get_config_index_by_value(dev, bConfigurationValue, &idx);
+	if (r < 0)
+		return r;
+	else if (idx == -1)
+		return LIBUSB_ERROR_NOT_FOUND;
+	else
+		return libusb_get_config_descriptor(dev, (uint8_t) idx, config);
+}
+
+/** \ingroup libusb_desc
+ * Free a configuration descriptor obtained from
+ * libusb_get_active_config_descriptor() or libusb_get_config_descriptor().
+ * It is safe to call this function with a NULL config parameter, in which
+ * case the function simply returns.
+ *
+ * \param config the configuration descriptor to free
+ */
+void API_EXPORTED libusb_free_config_descriptor(
+	struct libusb_config_descriptor *config)
+{
+	if (!config)
+		return;
+
+	clear_configuration(config);
+	free(config);
+}
+
+/** \ingroup libusb_desc
+ * Get an endpoints superspeed endpoint companion descriptor (if any)
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \param endpoint endpoint descriptor from which to get the superspeed
+ * endpoint companion descriptor
+ * \param ep_comp output location for the superspeed endpoint companion
+ * descriptor. Only valid if 0 was returned. Must be freed with
+ * libusb_free_ss_endpoint_companion_descriptor() after use.
+ * \returns 0 on success
+ * \returns LIBUSB_ERROR_NOT_FOUND if the configuration does not exist
+ * \returns another LIBUSB_ERROR code on error
+ */
+int API_EXPORTED libusb_get_ss_endpoint_companion_descriptor(
+	struct libusb_context *ctx,
+	const struct libusb_endpoint_descriptor *endpoint,
+	struct libusb_ss_endpoint_companion_descriptor **ep_comp)
+{
+	struct usb_descriptor_header header;
+	int size = endpoint->extra_length;
+	const unsigned char *buffer = endpoint->extra;
+
+	*ep_comp = NULL;
+
+	while (size >= DESC_HEADER_LENGTH) {
+		usbi_parse_descriptor(buffer, "bb", &header, 0);
+		if (header.bLength < 2 || header.bLength > size) {
+			usbi_err(ctx, "invalid descriptor length %d",
+				 header.bLength);
+			return LIBUSB_ERROR_IO;
+		}
+		if (header.bDescriptorType != LIBUSB_DT_SS_ENDPOINT_COMPANION) {
+			buffer += header.bLength;
+			size -= header.bLength;
+			continue;
+		}
+		if (header.bLength < LIBUSB_DT_SS_ENDPOINT_COMPANION_SIZE) {
+			usbi_err(ctx, "invalid ss-ep-comp-desc length %d",
+				 header.bLength);
+			return LIBUSB_ERROR_IO;
+		}
+		*ep_comp = malloc(sizeof(**ep_comp));
+		if (*ep_comp == NULL)
+			return LIBUSB_ERROR_NO_MEM;
+		usbi_parse_descriptor(buffer, "bbbbw", *ep_comp, 0);
+		return LIBUSB_SUCCESS;
+	}
+	return LIBUSB_ERROR_NOT_FOUND;
+}
+
+/** \ingroup libusb_desc
+ * Free a superspeed endpoint companion descriptor obtained from
+ * libusb_get_ss_endpoint_companion_descriptor().
+ * It is safe to call this function with a NULL ep_comp parameter, in which
+ * case the function simply returns.
+ *
+ * \param ep_comp the superspeed endpoint companion descriptor to free
+ */
+void API_EXPORTED libusb_free_ss_endpoint_companion_descriptor(
+	struct libusb_ss_endpoint_companion_descriptor *ep_comp)
+{
+	free(ep_comp);
+}
+
+static int parse_bos(struct libusb_context *ctx,
+	struct libusb_bos_descriptor **bos,
+	unsigned char *buffer, int size, int host_endian)
+{
+	struct libusb_bos_descriptor bos_header, *_bos;
+	struct libusb_bos_dev_capability_descriptor dev_cap;
+	int i;
+
+	if (size < LIBUSB_DT_BOS_SIZE) {
+		usbi_err(ctx, "short bos descriptor read %d/%d",
+			 size, LIBUSB_DT_BOS_SIZE);
+		return LIBUSB_ERROR_IO;
+	}
+
+	usbi_parse_descriptor(buffer, "bbwb", &bos_header, host_endian);
+	if (bos_header.bDescriptorType != LIBUSB_DT_BOS) {
+		usbi_err(ctx, "unexpected descriptor %x (expected %x)",
+			 bos_header.bDescriptorType, LIBUSB_DT_BOS);
+		return LIBUSB_ERROR_IO;
+	}
+	if (bos_header.bLength < LIBUSB_DT_BOS_SIZE) {
+		usbi_err(ctx, "invalid bos bLength (%d)", bos_header.bLength);
+		return LIBUSB_ERROR_IO;
+	}
+	if (bos_header.bLength > size) {
+		usbi_err(ctx, "short bos descriptor read %d/%d",
+			 size, bos_header.bLength);
+		return LIBUSB_ERROR_IO;
+	}
+
+	_bos = calloc (1,
+		sizeof(*_bos) + bos_header.bNumDeviceCaps * sizeof(void *));
+	if (!_bos)
+		return LIBUSB_ERROR_NO_MEM;
+
+	usbi_parse_descriptor(buffer, "bbwb", _bos, host_endian);
+	buffer += bos_header.bLength;
+	size -= bos_header.bLength;
+
+	/* Get the device capability descriptors */
+	for (i = 0; i < bos_header.bNumDeviceCaps; i++) {
+		if (size < LIBUSB_DT_DEVICE_CAPABILITY_SIZE) {
+			usbi_warn(ctx, "short dev-cap descriptor read %d/%d",
+				  size, LIBUSB_DT_DEVICE_CAPABILITY_SIZE);
+			break;
+		}
+		usbi_parse_descriptor(buffer, "bbb", &dev_cap, host_endian);
+		if (dev_cap.bDescriptorType != LIBUSB_DT_DEVICE_CAPABILITY) {
+			usbi_warn(ctx, "unexpected descriptor %x (expected %x)",
+				  dev_cap.bDescriptorType, LIBUSB_DT_DEVICE_CAPABILITY);
+			break;
+		}
+		if (dev_cap.bLength < LIBUSB_DT_DEVICE_CAPABILITY_SIZE) {
+			usbi_err(ctx, "invalid dev-cap bLength (%d)",
+				 dev_cap.bLength);
+			libusb_free_bos_descriptor(_bos);
+			return LIBUSB_ERROR_IO;
+		}
+		if (dev_cap.bLength > size) {
+			usbi_warn(ctx, "short dev-cap descriptor read %d/%d",
+				  size, dev_cap.bLength);
+			break;
+		}
+
+		_bos->dev_capability[i] = malloc(dev_cap.bLength);
+		if (!_bos->dev_capability[i]) {
+			libusb_free_bos_descriptor(_bos);
+			return LIBUSB_ERROR_NO_MEM;
+		}
+		memcpy(_bos->dev_capability[i], buffer, dev_cap.bLength);
+		buffer += dev_cap.bLength;
+		size -= dev_cap.bLength;
+	}
+	_bos->bNumDeviceCaps = (uint8_t)i;
+	*bos = _bos;
+
+	return LIBUSB_SUCCESS;
+}
+
+/** \ingroup libusb_desc
+ * Get a Binary Object Store (BOS) descriptor
+ * This is a BLOCKING function, which will send requests to the device.
+ *
+ * \param dev_handle the handle of an open libusb device
+ * \param bos output location for the BOS descriptor. Only valid if 0 was returned.
+ * Must be freed with \ref libusb_free_bos_descriptor() after use.
+ * \returns 0 on success
+ * \returns LIBUSB_ERROR_NOT_FOUND if the device doesn't have a BOS descriptor
+ * \returns another LIBUSB_ERROR code on error
+ */
+int API_EXPORTED libusb_get_bos_descriptor(libusb_device_handle *dev_handle,
+	struct libusb_bos_descriptor **bos)
+{
+	struct libusb_bos_descriptor _bos;
+	uint8_t bos_header[LIBUSB_DT_BOS_SIZE] = {0};
+	unsigned char *bos_data = NULL;
+	const int host_endian = 0;
+	int r;
+
+	/* Read the BOS. This generates 2 requests on the bus,
+	 * one for the header, and one for the full BOS */
+	r = libusb_get_descriptor(dev_handle, LIBUSB_DT_BOS, 0, bos_header,
+				  LIBUSB_DT_BOS_SIZE);
+	if (r < 0) {
+		if (r != LIBUSB_ERROR_PIPE)
+			usbi_err(HANDLE_CTX(dev_handle), "failed to read BOS (%d)", r);
+		return r;
+	}
+	if (r < LIBUSB_DT_BOS_SIZE) {
+		usbi_err(HANDLE_CTX(dev_handle), "short BOS read %d/%d",
+			 r, LIBUSB_DT_BOS_SIZE);
+		return LIBUSB_ERROR_IO;
+	}
+
+	usbi_parse_descriptor(bos_header, "bbwb", &_bos, host_endian);
+	usbi_dbg("found BOS descriptor: size %d bytes, %d capabilities",
+		 _bos.wTotalLength, _bos.bNumDeviceCaps);
+	bos_data = calloc(_bos.wTotalLength, 1);
+	if (bos_data == NULL)
+		return LIBUSB_ERROR_NO_MEM;
+
+	r = libusb_get_descriptor(dev_handle, LIBUSB_DT_BOS, 0, bos_data,
+				  _bos.wTotalLength);
+	if (r >= 0)
+		r = parse_bos(HANDLE_CTX(dev_handle), bos, bos_data, r, host_endian);
+	else
+		usbi_err(HANDLE_CTX(dev_handle), "failed to read BOS (%d)", r);
+
+	free(bos_data);
+	return r;
+}
+
+/** \ingroup libusb_desc
+ * Free a BOS descriptor obtained from libusb_get_bos_descriptor().
+ * It is safe to call this function with a NULL bos parameter, in which
+ * case the function simply returns.
+ *
+ * \param bos the BOS descriptor to free
+ */
+void API_EXPORTED libusb_free_bos_descriptor(struct libusb_bos_descriptor *bos)
+{
+	int i;
+
+	if (!bos)
+		return;
+
+	for (i = 0; i < bos->bNumDeviceCaps; i++)
+		free(bos->dev_capability[i]);
+	free(bos);
+}
+
+/** \ingroup libusb_desc
+ * Get an USB 2.0 Extension descriptor
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \param dev_cap Device Capability descriptor with a bDevCapabilityType of
+ * \ref libusb_capability_type::LIBUSB_BT_USB_2_0_EXTENSION
+ * LIBUSB_BT_USB_2_0_EXTENSION
+ * \param usb_2_0_extension output location for the USB 2.0 Extension
+ * descriptor. Only valid if 0 was returned. Must be freed with
+ * libusb_free_usb_2_0_extension_descriptor() after use.
+ * \returns 0 on success
+ * \returns a LIBUSB_ERROR code on error
+ */
+int API_EXPORTED libusb_get_usb_2_0_extension_descriptor(
+	struct libusb_context *ctx,
+	struct libusb_bos_dev_capability_descriptor *dev_cap,
+	struct libusb_usb_2_0_extension_descriptor **usb_2_0_extension)
+{
+	struct libusb_usb_2_0_extension_descriptor *_usb_2_0_extension;
+	const int host_endian = 0;
+
+	if (dev_cap->bDevCapabilityType != LIBUSB_BT_USB_2_0_EXTENSION) {
+		usbi_err(ctx, "unexpected bDevCapabilityType %x (expected %x)",
+			 dev_cap->bDevCapabilityType,
+			 LIBUSB_BT_USB_2_0_EXTENSION);
+		return LIBUSB_ERROR_INVALID_PARAM;
+	}
+	if (dev_cap->bLength < LIBUSB_BT_USB_2_0_EXTENSION_SIZE) {
+		usbi_err(ctx, "short dev-cap descriptor read %d/%d",
+			 dev_cap->bLength, LIBUSB_BT_USB_2_0_EXTENSION_SIZE);
+		return LIBUSB_ERROR_IO;
+	}
+
+	_usb_2_0_extension = malloc(sizeof(*_usb_2_0_extension));
+	if (!_usb_2_0_extension)
+		return LIBUSB_ERROR_NO_MEM;
+
+	usbi_parse_descriptor((unsigned char *)dev_cap, "bbbd",
+			      _usb_2_0_extension, host_endian);
+
+	*usb_2_0_extension = _usb_2_0_extension;
+	return LIBUSB_SUCCESS;
+}
+
+/** \ingroup libusb_desc
+ * Free a USB 2.0 Extension descriptor obtained from
+ * libusb_get_usb_2_0_extension_descriptor().
+ * It is safe to call this function with a NULL usb_2_0_extension parameter,
+ * in which case the function simply returns.
+ *
+ * \param usb_2_0_extension the USB 2.0 Extension descriptor to free
+ */
+void API_EXPORTED libusb_free_usb_2_0_extension_descriptor(
+	struct libusb_usb_2_0_extension_descriptor *usb_2_0_extension)
+{
+	free(usb_2_0_extension);
+}
+
+/** \ingroup libusb_desc
+ * Get a SuperSpeed USB Device Capability descriptor
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \param dev_cap Device Capability descriptor with a bDevCapabilityType of
+ * \ref libusb_capability_type::LIBUSB_BT_SS_USB_DEVICE_CAPABILITY
+ * LIBUSB_BT_SS_USB_DEVICE_CAPABILITY
+ * \param ss_usb_device_cap output location for the SuperSpeed USB Device
+ * Capability descriptor. Only valid if 0 was returned. Must be freed with
+ * libusb_free_ss_usb_device_capability_descriptor() after use.
+ * \returns 0 on success
+ * \returns a LIBUSB_ERROR code on error
+ */
+int API_EXPORTED libusb_get_ss_usb_device_capability_descriptor(
+	struct libusb_context *ctx,
+	struct libusb_bos_dev_capability_descriptor *dev_cap,
+	struct libusb_ss_usb_device_capability_descriptor **ss_usb_device_cap)
+{
+	struct libusb_ss_usb_device_capability_descriptor *_ss_usb_device_cap;
+	const int host_endian = 0;
+
+	if (dev_cap->bDevCapabilityType != LIBUSB_BT_SS_USB_DEVICE_CAPABILITY) {
+		usbi_err(ctx, "unexpected bDevCapabilityType %x (expected %x)",
+			 dev_cap->bDevCapabilityType,
+			 LIBUSB_BT_SS_USB_DEVICE_CAPABILITY);
+		return LIBUSB_ERROR_INVALID_PARAM;
+	}
+	if (dev_cap->bLength < LIBUSB_BT_SS_USB_DEVICE_CAPABILITY_SIZE) {
+		usbi_err(ctx, "short dev-cap descriptor read %d/%d",
+			 dev_cap->bLength, LIBUSB_BT_SS_USB_DEVICE_CAPABILITY_SIZE);
+		return LIBUSB_ERROR_IO;
+	}
+
+	_ss_usb_device_cap = malloc(sizeof(*_ss_usb_device_cap));
+	if (!_ss_usb_device_cap)
+		return LIBUSB_ERROR_NO_MEM;
+
+	usbi_parse_descriptor((unsigned char *)dev_cap, "bbbbwbbw",
+			      _ss_usb_device_cap, host_endian);
+
+	*ss_usb_device_cap = _ss_usb_device_cap;
+	return LIBUSB_SUCCESS;
+}
+
+/** \ingroup libusb_desc
+ * Free a SuperSpeed USB Device Capability descriptor obtained from
+ * libusb_get_ss_usb_device_capability_descriptor().
+ * It is safe to call this function with a NULL ss_usb_device_cap
+ * parameter, in which case the function simply returns.
+ *
+ * \param ss_usb_device_cap the USB 2.0 Extension descriptor to free
+ */
+void API_EXPORTED libusb_free_ss_usb_device_capability_descriptor(
+	struct libusb_ss_usb_device_capability_descriptor *ss_usb_device_cap)
+{
+	free(ss_usb_device_cap);
+}
+
+/** \ingroup libusb_desc
+ * Get a Container ID descriptor
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \param dev_cap Device Capability descriptor with a bDevCapabilityType of
+ * \ref libusb_capability_type::LIBUSB_BT_CONTAINER_ID
+ * LIBUSB_BT_CONTAINER_ID
+ * \param container_id output location for the Container ID descriptor.
+ * Only valid if 0 was returned. Must be freed with
+ * libusb_free_container_id_descriptor() after use.
+ * \returns 0 on success
+ * \returns a LIBUSB_ERROR code on error
+ */
+int API_EXPORTED libusb_get_container_id_descriptor(struct libusb_context *ctx,
+	struct libusb_bos_dev_capability_descriptor *dev_cap,
+	struct libusb_container_id_descriptor **container_id)
+{
+	struct libusb_container_id_descriptor *_container_id;
+	const int host_endian = 0;
+
+	if (dev_cap->bDevCapabilityType != LIBUSB_BT_CONTAINER_ID) {
+		usbi_err(ctx, "unexpected bDevCapabilityType %x (expected %x)",
+			 dev_cap->bDevCapabilityType,
+			 LIBUSB_BT_CONTAINER_ID);
+		return LIBUSB_ERROR_INVALID_PARAM;
+	}
+	if (dev_cap->bLength < LIBUSB_BT_CONTAINER_ID_SIZE) {
+		usbi_err(ctx, "short dev-cap descriptor read %d/%d",
+			 dev_cap->bLength, LIBUSB_BT_CONTAINER_ID_SIZE);
+		return LIBUSB_ERROR_IO;
+	}
+
+	_container_id = malloc(sizeof(*_container_id));
+	if (!_container_id)
+		return LIBUSB_ERROR_NO_MEM;
+
+	usbi_parse_descriptor((unsigned char *)dev_cap, "bbbbu",
+			      _container_id, host_endian);
+
+	*container_id = _container_id;
+	return LIBUSB_SUCCESS;
+}
+
+/** \ingroup libusb_desc
+ * Free a Container ID descriptor obtained from
+ * libusb_get_container_id_descriptor().
+ * It is safe to call this function with a NULL container_id parameter,
+ * in which case the function simply returns.
+ *
+ * \param container_id the USB 2.0 Extension descriptor to free
+ */
+void API_EXPORTED libusb_free_container_id_descriptor(
+	struct libusb_container_id_descriptor *container_id)
+{
+	free(container_id);
+}
+
+/** \ingroup libusb_desc
+ * Retrieve a string descriptor in C style ASCII.
+ *
+ * Wrapper around libusb_get_string_descriptor(). Uses the first language
+ * supported by the device.
+ *
+ * \param dev_handle a device handle
+ * \param desc_index the index of the descriptor to retrieve
+ * \param data output buffer for ASCII string descriptor
+ * \param length size of data buffer
+ * \returns number of bytes returned in data, or LIBUSB_ERROR code on failure
+ */
+int API_EXPORTED libusb_get_string_descriptor_ascii(libusb_device_handle *dev_handle,
+	uint8_t desc_index, unsigned char *data, int length)
+{
+	unsigned char tbuf[255]; /* Some devices choke on size > 255 */
+	int r, si, di;
+	uint16_t langid;
+
+	/* Asking for the zero'th index is special - it returns a string
+	 * descriptor that contains all the language IDs supported by the
+	 * device. Typically there aren't many - often only one. Language
+	 * IDs are 16 bit numbers, and they start at the third byte in the
+	 * descriptor. There's also no point in trying to read descriptor 0
+	 * with this function. See USB 2.0 specification section 9.6.7 for
+	 * more information.
+	 */
+
+	if (desc_index == 0)
+		return LIBUSB_ERROR_INVALID_PARAM;
+
+	r = libusb_get_string_descriptor(dev_handle, 0, 0, tbuf, sizeof(tbuf));
+	if (r < 0)
+		return r;
+
+	if (r < 4)
+		return LIBUSB_ERROR_IO;
+
+	langid = tbuf[2] | (tbuf[3] << 8);
+
+	r = libusb_get_string_descriptor(dev_handle, desc_index, langid, tbuf,
+		sizeof(tbuf));
+	if (r < 0)
+		return r;
+
+	if (tbuf[1] != LIBUSB_DT_STRING)
+		return LIBUSB_ERROR_IO;
+
+	if (tbuf[0] > r)
+		return LIBUSB_ERROR_IO;
+
+	di = 0;
+	for (si = 2; si < tbuf[0]; si += 2) {
+		if (di >= (length - 1))
+			break;
+
+		if ((tbuf[si] & 0x80) || (tbuf[si + 1])) /* non-ASCII */
+			data[di++] = '?';
+		else
+			data[di++] = tbuf[si];
+	}
+
+	data[di] = 0;
+	return di;
+}
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/hotplug.c b/vendor/github.com/karalabe/usb/libusb/libusb/hotplug.c
new file mode 100644
index 000000000..a4320bc42
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/hotplug.c
@@ -0,0 +1,373 @@
+/* -*- Mode: C; indent-tabs-mode:t ; c-basic-offset:8 -*- */
+/*
+ * Hotplug functions for libusb
+ * Copyright © 2012-2013 Nathan Hjelm <hjelmn@mac.com>
+ * Copyright © 2012-2013 Peter Stuge <peter@stuge.se>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <config.h>
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#include <assert.h>
+
+#include "libusbi.h"
+#include "hotplug.h"
+
+/**
+ * @defgroup libusb_hotplug Device hotplug event notification
+ * This page details how to use the libusb hotplug interface, where available.
+ *
+ * Be mindful that not all platforms currently implement hotplug notification and
+ * that you should first call on \ref libusb_has_capability() with parameter
+ * \ref LIBUSB_CAP_HAS_HOTPLUG to confirm that hotplug support is available.
+ *
+ * \page libusb_hotplug Device hotplug event notification
+ *
+ * \section hotplug_intro Introduction
+ *
+ * Version 1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102, has added support
+ * for hotplug events on <b>some</b> platforms (you should test if your platform
+ * supports hotplug notification by calling \ref libusb_has_capability() with
+ * parameter \ref LIBUSB_CAP_HAS_HOTPLUG). 
+ *
+ * This interface allows you to request notification for the arrival and departure
+ * of matching USB devices.
+ *
+ * To receive hotplug notification you register a callback by calling
+ * \ref libusb_hotplug_register_callback(). This function will optionally return
+ * a callback handle that can be passed to \ref libusb_hotplug_deregister_callback().
+ *
+ * A callback function must return an int (0 or 1) indicating whether the callback is
+ * expecting additional events. Returning 0 will rearm the callback and 1 will cause
+ * the callback to be deregistered. Note that when callbacks are called from
+ * libusb_hotplug_register_callback() because of the \ref LIBUSB_HOTPLUG_ENUMERATE
+ * flag, the callback return value is ignored, iow you cannot cause a callback
+ * to be deregistered by returning 1 when it is called from
+ * libusb_hotplug_register_callback().
+ *
+ * Callbacks for a particular context are automatically deregistered by libusb_exit().
+ *
+ * As of 1.0.16 there are two supported hotplug events:
+ *  - LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED: A device has arrived and is ready to use
+ *  - LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT: A device has left and is no longer available
+ *
+ * A hotplug event can listen for either or both of these events.
+ *
+ * Note: If you receive notification that a device has left and you have any
+ * a libusb_device_handles for the device it is up to you to call libusb_close()
+ * on each device handle to free up any remaining resources associated with the device.
+ * Once a device has left any libusb_device_handle associated with the device
+ * are invalid and will remain so even if the device comes back.
+ *
+ * When handling a LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED event it is considered
+ * safe to call any libusb function that takes a libusb_device. It also safe to
+ * open a device and submit asynchronous transfers. However, most other functions
+ * that take a libusb_device_handle are <b>not</b> safe to call. Examples of such
+ * functions are any of the \ref libusb_syncio "synchronous API" functions or the blocking
+ * functions that retrieve various \ref libusb_desc "USB descriptors". These functions must
+ * be used outside of the context of the hotplug callback.
+ *
+ * When handling a LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT event the only safe function
+ * is libusb_get_device_descriptor().
+ *
+ * The following code provides an example of the usage of the hotplug interface:
+\code
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <libusb.h>
+
+static int count = 0;
+
+int hotplug_callback(struct libusb_context *ctx, struct libusb_device *dev,
+                     libusb_hotplug_event event, void *user_data) {
+  static libusb_device_handle *dev_handle = NULL;
+  struct libusb_device_descriptor desc;
+  int rc;
+
+  (void)libusb_get_device_descriptor(dev, &desc);
+
+  if (LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED == event) {
+    rc = libusb_open(dev, &dev_handle);
+    if (LIBUSB_SUCCESS != rc) {
+      printf("Could not open USB device\n");
+    }
+  } else if (LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT == event) {
+    if (dev_handle) {
+      libusb_close(dev_handle);
+      dev_handle = NULL;
+    }
+  } else {
+    printf("Unhandled event %d\n", event);
+  }
+  count++;
+
+  return 0;
+}
+
+int main (void) {
+  libusb_hotplug_callback_handle callback_handle;
+  int rc;
+
+  libusb_init(NULL);
+
+  rc = libusb_hotplug_register_callback(NULL, LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED |
+                                        LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT, 0, 0x045a, 0x5005,
+                                        LIBUSB_HOTPLUG_MATCH_ANY, hotplug_callback, NULL,
+                                        &callback_handle);
+  if (LIBUSB_SUCCESS != rc) {
+    printf("Error creating a hotplug callback\n");
+    libusb_exit(NULL);
+    return EXIT_FAILURE;
+  }
+
+  while (count < 2) {
+    libusb_handle_events_completed(NULL, NULL);
+    nanosleep(&(struct timespec){0, 10000000UL}, NULL);
+  }
+
+  libusb_hotplug_deregister_callback(NULL, callback_handle);
+  libusb_exit(NULL);
+
+  return 0;
+}
+\endcode
+ */
+
+static int usbi_hotplug_match_cb(struct libusb_context *ctx,
+	struct libusb_device *dev, libusb_hotplug_event event,
+	struct libusb_hotplug_callback *hotplug_cb)
+{
+	if (!(hotplug_cb->flags & event)) {
+		return 0;
+	}
+
+	if ((hotplug_cb->flags & USBI_HOTPLUG_VENDOR_ID_VALID) &&
+	    hotplug_cb->vendor_id != dev->device_descriptor.idVendor) {
+		return 0;
+	}
+
+	if ((hotplug_cb->flags & USBI_HOTPLUG_PRODUCT_ID_VALID) &&
+	    hotplug_cb->product_id != dev->device_descriptor.idProduct) {
+		return 0;
+	}
+
+	if ((hotplug_cb->flags & USBI_HOTPLUG_DEV_CLASS_VALID) &&
+	    hotplug_cb->dev_class != dev->device_descriptor.bDeviceClass) {
+		return 0;
+	}
+
+	return hotplug_cb->cb(ctx, dev, event, hotplug_cb->user_data);
+}
+
+void usbi_hotplug_match(struct libusb_context *ctx, struct libusb_device *dev,
+	libusb_hotplug_event event)
+{
+	struct libusb_hotplug_callback *hotplug_cb, *next;
+	int ret;
+
+	usbi_mutex_lock(&ctx->hotplug_cbs_lock);
+
+	list_for_each_entry_safe(hotplug_cb, next, &ctx->hotplug_cbs, list, struct libusb_hotplug_callback) {
+		if (hotplug_cb->flags & USBI_HOTPLUG_NEEDS_FREE) {
+			/* process deregistration in usbi_hotplug_deregister() */
+			continue;
+		}
+
+		usbi_mutex_unlock(&ctx->hotplug_cbs_lock);
+		ret = usbi_hotplug_match_cb(ctx, dev, event, hotplug_cb);
+		usbi_mutex_lock(&ctx->hotplug_cbs_lock);
+
+		if (ret) {
+			list_del(&hotplug_cb->list);
+			free(hotplug_cb);
+		}
+	}
+
+	usbi_mutex_unlock(&ctx->hotplug_cbs_lock);
+}
+
+void usbi_hotplug_notification(struct libusb_context *ctx, struct libusb_device *dev,
+	libusb_hotplug_event event)
+{
+	int pending_events;
+	struct libusb_hotplug_message *message = calloc(1, sizeof(*message));
+
+	if (!message) {
+		usbi_err(ctx, "error allocating hotplug message");
+		return;
+	}
+
+	message->event = event;
+	message->device = dev;
+
+	/* Take the event data lock and add this message to the list.
+	 * Only signal an event if there are no prior pending events. */
+	usbi_mutex_lock(&ctx->event_data_lock);
+	pending_events = usbi_pending_events(ctx);
+	list_add_tail(&message->list, &ctx->hotplug_msgs);
+	if (!pending_events)
+		usbi_signal_event(ctx);
+	usbi_mutex_unlock(&ctx->event_data_lock);
+}
+
+int API_EXPORTED libusb_hotplug_register_callback(libusb_context *ctx,
+	libusb_hotplug_event events, libusb_hotplug_flag flags,
+	int vendor_id, int product_id, int dev_class,
+	libusb_hotplug_callback_fn cb_fn, void *user_data,
+	libusb_hotplug_callback_handle *callback_handle)
+{
+	struct libusb_hotplug_callback *new_callback;
+
+	/* check for sane values */
+	if ((!events || (~(LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED | LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT) & events)) ||
+	    (flags && (~LIBUSB_HOTPLUG_ENUMERATE & flags)) ||
+	    (LIBUSB_HOTPLUG_MATCH_ANY != vendor_id && (~0xffff & vendor_id)) ||
+	    (LIBUSB_HOTPLUG_MATCH_ANY != product_id && (~0xffff & product_id)) ||
+	    (LIBUSB_HOTPLUG_MATCH_ANY != dev_class && (~0xff & dev_class)) ||
+	    !cb_fn) {
+		return LIBUSB_ERROR_INVALID_PARAM;
+	}
+
+	/* check for hotplug support */
+	if (!libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG)) {
+		return LIBUSB_ERROR_NOT_SUPPORTED;
+	}
+
+	USBI_GET_CONTEXT(ctx);
+
+	new_callback = calloc(1, sizeof(*new_callback));
+	if (!new_callback) {
+		return LIBUSB_ERROR_NO_MEM;
+	}
+
+	new_callback->flags = (uint8_t)events;
+	if (LIBUSB_HOTPLUG_MATCH_ANY != vendor_id) {
+		new_callback->flags |= USBI_HOTPLUG_VENDOR_ID_VALID;
+		new_callback->vendor_id = (uint16_t)vendor_id;
+	}
+	if (LIBUSB_HOTPLUG_MATCH_ANY != product_id) {
+		new_callback->flags |= USBI_HOTPLUG_PRODUCT_ID_VALID;
+		new_callback->product_id = (uint16_t)product_id;
+	}
+	if (LIBUSB_HOTPLUG_MATCH_ANY != dev_class) {
+		new_callback->flags |= USBI_HOTPLUG_DEV_CLASS_VALID;
+		new_callback->dev_class = (uint8_t)dev_class;
+	}
+	new_callback->cb = cb_fn;
+	new_callback->user_data = user_data;
+
+	usbi_mutex_lock(&ctx->hotplug_cbs_lock);
+
+	/* protect the handle by the context hotplug lock */
+	new_callback->handle = ctx->next_hotplug_cb_handle++;
+
+	/* handle the unlikely case of overflow */
+	if (ctx->next_hotplug_cb_handle < 0)
+		ctx->next_hotplug_cb_handle = 1;
+
+	list_add(&new_callback->list, &ctx->hotplug_cbs);
+
+	usbi_mutex_unlock(&ctx->hotplug_cbs_lock);
+
+	usbi_dbg("new hotplug cb %p with handle %d", new_callback, new_callback->handle);
+
+	if ((flags & LIBUSB_HOTPLUG_ENUMERATE) && (events & LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED)) {
+		ssize_t i, len;
+		struct libusb_device **devs;
+
+		len = libusb_get_device_list(ctx, &devs);
+		if (len < 0) {
+			libusb_hotplug_deregister_callback(ctx,
+							new_callback->handle);
+			return (int)len;
+		}
+
+		for (i = 0; i < len; i++) {
+			usbi_hotplug_match_cb(ctx, devs[i],
+					LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED,
+					new_callback);
+		}
+
+		libusb_free_device_list(devs, 1);
+	}
+
+
+	if (callback_handle)
+		*callback_handle = new_callback->handle;
+
+	return LIBUSB_SUCCESS;
+}
+
+void API_EXPORTED libusb_hotplug_deregister_callback(struct libusb_context *ctx,
+	libusb_hotplug_callback_handle callback_handle)
+{
+	struct libusb_hotplug_callback *hotplug_cb;
+	int deregistered = 0;
+
+	/* check for hotplug support */
+	if (!libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG)) {
+		return;
+	}
+
+	USBI_GET_CONTEXT(ctx);
+
+	usbi_dbg("deregister hotplug cb %d", callback_handle);
+
+	usbi_mutex_lock(&ctx->hotplug_cbs_lock);
+	list_for_each_entry(hotplug_cb, &ctx->hotplug_cbs, list, struct libusb_hotplug_callback) {
+		if (callback_handle == hotplug_cb->handle) {
+			/* Mark this callback for deregistration */
+			hotplug_cb->flags |= USBI_HOTPLUG_NEEDS_FREE;
+			deregistered = 1;
+		}
+	}
+	usbi_mutex_unlock(&ctx->hotplug_cbs_lock);
+
+	if (deregistered) {
+		int pending_events;
+
+		usbi_mutex_lock(&ctx->event_data_lock);
+		pending_events = usbi_pending_events(ctx);
+		ctx->event_flags |= USBI_EVENT_HOTPLUG_CB_DEREGISTERED;
+		if (!pending_events)
+			usbi_signal_event(ctx);
+		usbi_mutex_unlock(&ctx->event_data_lock);
+	}
+}
+
+void usbi_hotplug_deregister(struct libusb_context *ctx, int forced)
+{
+	struct libusb_hotplug_callback *hotplug_cb, *next;
+
+	usbi_mutex_lock(&ctx->hotplug_cbs_lock);
+	list_for_each_entry_safe(hotplug_cb, next, &ctx->hotplug_cbs, list, struct libusb_hotplug_callback) {
+		if (forced || (hotplug_cb->flags & USBI_HOTPLUG_NEEDS_FREE)) {
+			usbi_dbg("freeing hotplug cb %p with handle %d", hotplug_cb,
+				 hotplug_cb->handle);
+			list_del(&hotplug_cb->list);
+			free(hotplug_cb);
+		}
+	}
+	usbi_mutex_unlock(&ctx->hotplug_cbs_lock);
+}
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/hotplug.h b/vendor/github.com/karalabe/usb/libusb/libusb/hotplug.h
new file mode 100644
index 000000000..dbadbcb93
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/hotplug.h
@@ -0,0 +1,99 @@
+/* -*- Mode: C; indent-tabs-mode:t ; c-basic-offset:8 -*- */
+/*
+ * Hotplug support for libusb
+ * Copyright © 2012-2013 Nathan Hjelm <hjelmn@mac.com>
+ * Copyright © 2012-2013 Peter Stuge <peter@stuge.se>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef USBI_HOTPLUG_H
+#define USBI_HOTPLUG_H
+
+#include "libusbi.h"
+
+enum usbi_hotplug_flags {
+	/* This callback is interested in device arrivals */
+	USBI_HOTPLUG_DEVICE_ARRIVED = LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED,
+
+	/* This callback is interested in device removals */
+	USBI_HOTPLUG_DEVICE_LEFT = LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT,
+
+	/* IMPORTANT: The values for the below entries must start *after*
+	 * the highest value of the above entries!!!
+	 */
+
+	/* The vendor_id field is valid for matching */
+	USBI_HOTPLUG_VENDOR_ID_VALID = (1 << 3),
+
+	/* The product_id field is valid for matching */
+	USBI_HOTPLUG_PRODUCT_ID_VALID = (1 << 4),
+
+	/* The dev_class field is valid for matching */
+	USBI_HOTPLUG_DEV_CLASS_VALID = (1 << 5),
+
+	/* This callback has been unregistered and needs to be freed */
+	USBI_HOTPLUG_NEEDS_FREE = (1 << 6),
+};
+
+/** \ingroup hotplug
+ * The hotplug callback structure. The user populates this structure with
+ * libusb_hotplug_prepare_callback() and then calls libusb_hotplug_register_callback()
+ * to receive notification of hotplug events.
+ */
+struct libusb_hotplug_callback {
+	/** Flags that control how this callback behaves */
+	uint8_t flags;
+
+	/** Vendor ID to match (if flags says this is valid) */
+	uint16_t vendor_id;
+
+	/** Product ID to match (if flags says this is valid) */
+	uint16_t product_id;
+
+	/** Device class to match (if flags says this is valid) */
+	uint8_t dev_class;
+
+	/** Callback function to invoke for matching event/device */
+	libusb_hotplug_callback_fn cb;
+
+	/** Handle for this callback (used to match on deregister) */
+	libusb_hotplug_callback_handle handle;
+
+	/** User data that will be passed to the callback function */
+	void *user_data;
+
+	/** List this callback is registered in (ctx->hotplug_cbs) */
+	struct list_head list;
+};
+
+struct libusb_hotplug_message {
+	/** The hotplug event that occurred */
+	libusb_hotplug_event event;
+
+	/** The device for which this hotplug event occurred */
+	struct libusb_device *device;
+
+	/** List this message is contained in (ctx->hotplug_msgs) */
+	struct list_head list;
+};
+
+void usbi_hotplug_deregister(struct libusb_context *ctx, int forced);
+void usbi_hotplug_match(struct libusb_context *ctx, struct libusb_device *dev,
+			libusb_hotplug_event event);
+void usbi_hotplug_notification(struct libusb_context *ctx, struct libusb_device *dev,
+			libusb_hotplug_event event);
+
+#endif
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/io.c b/vendor/github.com/karalabe/usb/libusb/libusb/io.c
new file mode 100644
index 000000000..a03bfaae1
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/io.c
@@ -0,0 +1,2822 @@
+/* -*- Mode: C; indent-tabs-mode:t ; c-basic-offset:8 -*- */
+/*
+ * I/O functions for libusb
+ * Copyright © 2007-2009 Daniel Drake <dsd@gentoo.org>
+ * Copyright © 2001 Johannes Erdfelt <johannes@erdfelt.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <config.h>
+
+#include <assert.h>
+#include <errno.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#ifdef USBI_TIMERFD_AVAILABLE
+#include <sys/timerfd.h>
+#endif
+
+#include "libusbi.h"
+#include "hotplug.h"
+
+/**
+ * \page libusb_io Synchronous and asynchronous device I/O
+ *
+ * \section io_intro Introduction
+ *
+ * If you're using libusb in your application, you're probably wanting to
+ * perform I/O with devices - you want to perform USB data transfers.
+ *
+ * libusb offers two separate interfaces for device I/O. This page aims to
+ * introduce the two in order to help you decide which one is more suitable
+ * for your application. You can also choose to use both interfaces in your
+ * application by considering each transfer on a case-by-case basis.
+ *
+ * Once you have read through the following discussion, you should consult the
+ * detailed API documentation pages for the details:
+ * - \ref libusb_syncio
+ * - \ref libusb_asyncio
+ *
+ * \section theory Transfers at a logical level
+ *
+ * At a logical level, USB transfers typically happen in two parts. For
+ * example, when reading data from a endpoint:
+ * -# A request for data is sent to the device
+ * -# Some time later, the incoming data is received by the host
+ *
+ * or when writing data to an endpoint:
+ *
+ * -# The data is sent to the device
+ * -# Some time later, the host receives acknowledgement from the device that
+ *    the data has been transferred.
+ *
+ * There may be an indefinite delay between the two steps. Consider a
+ * fictional USB input device with a button that the user can press. In order
+ * to determine when the button is pressed, you would likely submit a request
+ * to read data on a bulk or interrupt endpoint and wait for data to arrive.
+ * Data will arrive when the button is pressed by the user, which is
+ * potentially hours later.
+ *
+ * libusb offers both a synchronous and an asynchronous interface to performing
+ * USB transfers. The main difference is that the synchronous interface
+ * combines both steps indicated above into a single function call, whereas
+ * the asynchronous interface separates them.
+ *
+ * \section sync The synchronous interface
+ *
+ * The synchronous I/O interface allows you to perform a USB transfer with
+ * a single function call. When the function call returns, the transfer has
+ * completed and you can parse the results.
+ *
+ * If you have used the libusb-0.1 before, this I/O style will seem familar to
+ * you. libusb-0.1 only offered a synchronous interface.
+ *
+ * In our input device example, to read button presses you might write code
+ * in the following style:
+\code
+unsigned char data[4];
+int actual_length;
+int r = libusb_bulk_transfer(dev_handle, LIBUSB_ENDPOINT_IN, data, sizeof(data), &actual_length, 0);
+if (r == 0 && actual_length == sizeof(data)) {
+	// results of the transaction can now be found in the data buffer
+	// parse them here and report button press
+} else {
+	error();
+}
+\endcode
+ *
+ * The main advantage of this model is simplicity: you did everything with
+ * a single simple function call.
+ *
+ * However, this interface has its limitations. Your application will sleep
+ * inside libusb_bulk_transfer() until the transaction has completed. If it
+ * takes the user 3 hours to press the button, your application will be
+ * sleeping for that long. Execution will be tied up inside the library -
+ * the entire thread will be useless for that duration.
+ *
+ * Another issue is that by tieing up the thread with that single transaction
+ * there is no possibility of performing I/O with multiple endpoints and/or
+ * multiple devices simultaneously, unless you resort to creating one thread
+ * per transaction.
+ *
+ * Additionally, there is no opportunity to cancel the transfer after the
+ * request has been submitted.
+ *
+ * For details on how to use the synchronous API, see the
+ * \ref libusb_syncio "synchronous I/O API documentation" pages.
+ *
+ * \section async The asynchronous interface
+ *
+ * Asynchronous I/O is the most significant new feature in libusb-1.0.
+ * Although it is a more complex interface, it solves all the issues detailed
+ * above.
+ *
+ * Instead of providing which functions that block until the I/O has complete,
+ * libusb's asynchronous interface presents non-blocking functions which
+ * begin a transfer and then return immediately. Your application passes a
+ * callback function pointer to this non-blocking function, which libusb will
+ * call with the results of the transaction when it has completed.
+ *
+ * Transfers which have been submitted through the non-blocking functions
+ * can be cancelled with a separate function call.
+ *
+ * The non-blocking nature of this interface allows you to be simultaneously
+ * performing I/O to multiple endpoints on multiple devices, without having
+ * to use threads.
+ *
+ * This added flexibility does come with some complications though:
+ * - In the interest of being a lightweight library, libusb does not create
+ * threads and can only operate when your application is calling into it. Your
+ * application must call into libusb from it's main loop when events are ready
+ * to be handled, or you must use some other scheme to allow libusb to
+ * undertake whatever work needs to be done.
+ * - libusb also needs to be called into at certain fixed points in time in
+ * order to accurately handle transfer timeouts.
+ * - Memory handling becomes more complex. You cannot use stack memory unless
+ * the function with that stack is guaranteed not to return until the transfer
+ * callback has finished executing.
+ * - You generally lose some linearity from your code flow because submitting
+ * the transfer request is done in a separate function from where the transfer
+ * results are handled. This becomes particularly obvious when you want to
+ * submit a second transfer based on the results of an earlier transfer.
+ *
+ * Internally, libusb's synchronous interface is expressed in terms of function
+ * calls to the asynchronous interface.
+ *
+ * For details on how to use the asynchronous API, see the
+ * \ref libusb_asyncio "asynchronous I/O API" documentation pages.
+ */
+
+
+/**
+ * \page libusb_packetoverflow Packets and overflows
+ *
+ * \section packets Packet abstraction
+ *
+ * The USB specifications describe how data is transmitted in packets, with
+ * constraints on packet size defined by endpoint descriptors. The host must
+ * not send data payloads larger than the endpoint's maximum packet size.
+ *
+ * libusb and the underlying OS abstract out the packet concept, allowing you
+ * to request transfers of any size. Internally, the request will be divided
+ * up into correctly-sized packets. You do not have to be concerned with
+ * packet sizes, but there is one exception when considering overflows.
+ *
+ * \section overflow Bulk/interrupt transfer overflows
+ *
+ * When requesting data on a bulk endpoint, libusb requires you to supply a
+ * buffer and the maximum number of bytes of data that libusb can put in that
+ * buffer. However, the size of the buffer is not communicated to the device -
+ * the device is just asked to send any amount of data.
+ *
+ * There is no problem if the device sends an amount of data that is less than
+ * or equal to the buffer size. libusb reports this condition to you through
+ * the \ref libusb_transfer::actual_length "libusb_transfer.actual_length"
+ * field.
+ *
+ * Problems may occur if the device attempts to send more data than can fit in
+ * the buffer. libusb reports LIBUSB_TRANSFER_OVERFLOW for this condition but
+ * other behaviour is largely undefined: actual_length may or may not be
+ * accurate, the chunk of data that can fit in the buffer (before overflow)
+ * may or may not have been transferred.
+ *
+ * Overflows are nasty, but can be avoided. Even though you were told to
+ * ignore packets above, think about the lower level details: each transfer is
+ * split into packets (typically small, with a maximum size of 512 bytes).
+ * Overflows can only happen if the final packet in an incoming data transfer
+ * is smaller than the actual packet that the device wants to transfer.
+ * Therefore, you will never see an overflow if your transfer buffer size is a
+ * multiple of the endpoint's packet size: the final packet will either
+ * fill up completely or will be only partially filled.
+ */
+
+/**
+ * @defgroup libusb_asyncio Asynchronous device I/O
+ *
+ * This page details libusb's asynchronous (non-blocking) API for USB device
+ * I/O. This interface is very powerful but is also quite complex - you will
+ * need to read this page carefully to understand the necessary considerations
+ * and issues surrounding use of this interface. Simplistic applications
+ * may wish to consider the \ref libusb_syncio "synchronous I/O API" instead.
+ *
+ * The asynchronous interface is built around the idea of separating transfer
+ * submission and handling of transfer completion (the synchronous model
+ * combines both of these into one). There may be a long delay between
+ * submission and completion, however the asynchronous submission function
+ * is non-blocking so will return control to your application during that
+ * potentially long delay.
+ *
+ * \section asyncabstraction Transfer abstraction
+ *
+ * For the asynchronous I/O, libusb implements the concept of a generic
+ * transfer entity for all types of I/O (control, bulk, interrupt,
+ * isochronous). The generic transfer object must be treated slightly
+ * differently depending on which type of I/O you are performing with it.
+ *
+ * This is represented by the public libusb_transfer structure type.
+ *
+ * \section asynctrf Asynchronous transfers
+ *
+ * We can view asynchronous I/O as a 5 step process:
+ * -# <b>Allocation</b>: allocate a libusb_transfer
+ * -# <b>Filling</b>: populate the libusb_transfer instance with information
+ *    about the transfer you wish to perform
+ * -# <b>Submission</b>: ask libusb to submit the transfer
+ * -# <b>Completion handling</b>: examine transfer results in the
+ *    libusb_transfer structure
+ * -# <b>Deallocation</b>: clean up resources
+ *
+ *
+ * \subsection asyncalloc Allocation
+ *
+ * This step involves allocating memory for a USB transfer. This is the
+ * generic transfer object mentioned above. At this stage, the transfer
+ * is "blank" with no details about what type of I/O it will be used for.
+ *
+ * Allocation is done with the libusb_alloc_transfer() function. You must use
+ * this function rather than allocating your own transfers.
+ *
+ * \subsection asyncfill Filling
+ *
+ * This step is where you take a previously allocated transfer and fill it
+ * with information to determine the message type and direction, data buffer,
+ * callback function, etc.
+ *
+ * You can either fill the required fields yourself or you can use the
+ * helper functions: libusb_fill_control_transfer(), libusb_fill_bulk_transfer()
+ * and libusb_fill_interrupt_transfer().
+ *
+ * \subsection asyncsubmit Submission
+ *
+ * When you have allocated a transfer and filled it, you can submit it using
+ * libusb_submit_transfer(). This function returns immediately but can be
+ * regarded as firing off the I/O request in the background.
+ *
+ * \subsection asynccomplete Completion handling
+ *
+ * After a transfer has been submitted, one of four things can happen to it:
+ *
+ * - The transfer completes (i.e. some data was transferred)
+ * - The transfer has a timeout and the timeout expires before all data is
+ * transferred
+ * - The transfer fails due to an error
+ * - The transfer is cancelled
+ *
+ * Each of these will cause the user-specified transfer callback function to
+ * be invoked. It is up to the callback function to determine which of the
+ * above actually happened and to act accordingly.
+ *
+ * The user-specified callback is passed a pointer to the libusb_transfer
+ * structure which was used to setup and submit the transfer. At completion
+ * time, libusb has populated this structure with results of the transfer:
+ * success or failure reason, number of bytes of data transferred, etc. See
+ * the libusb_transfer structure documentation for more information.
+ *
+ * <b>Important Note</b>: The user-specified callback is called from an event
+ * handling context. It is therefore important that no calls are made into
+ * libusb that will attempt to perform any event handling. Examples of such
+ * functions are any listed in the \ref libusb_syncio "synchronous API" and any of
+ * the blocking functions that retrieve \ref libusb_desc "USB descriptors".
+ *
+ * \subsection Deallocation
+ *
+ * When a transfer has completed (i.e. the callback function has been invoked),
+ * you are advised to free the transfer (unless you wish to resubmit it, see
+ * below). Transfers are deallocated with libusb_free_transfer().
+ *
+ * It is undefined behaviour to free a transfer which has not completed.
+ *
+ * \section asyncresubmit Resubmission
+ *
+ * You may be wondering why allocation, filling, and submission are all
+ * separated above where they could reasonably be combined into a single
+ * operation.
+ *
+ * The reason for separation is to allow you to resubmit transfers without
+ * having to allocate new ones every time. This is especially useful for
+ * common situations dealing with interrupt endpoints - you allocate one
+ * transfer, fill and submit it, and when it returns with results you just
+ * resubmit it for the next interrupt.
+ *
+ * \section asynccancel Cancellation
+ *
+ * Another advantage of using the asynchronous interface is that you have
+ * the ability to cancel transfers which have not yet completed. This is
+ * done by calling the libusb_cancel_transfer() function.
+ *
+ * libusb_cancel_transfer() is asynchronous/non-blocking in itself. When the
+ * cancellation actually completes, the transfer's callback function will
+ * be invoked, and the callback function should check the transfer status to
+ * determine that it was cancelled.
+ *
+ * Freeing the transfer after it has been cancelled but before cancellation
+ * has completed will result in undefined behaviour.
+ *
+ * When a transfer is cancelled, some of the data may have been transferred.
+ * libusb will communicate this to you in the transfer callback. Do not assume
+ * that no data was transferred.
+ *
+ * \section bulk_overflows Overflows on device-to-host bulk/interrupt endpoints
+ *
+ * If your device does not have predictable transfer sizes (or it misbehaves),
+ * your application may submit a request for data on an IN endpoint which is
+ * smaller than the data that the device wishes to send. In some circumstances
+ * this will cause an overflow, which is a nasty condition to deal with. See
+ * the \ref libusb_packetoverflow page for discussion.
+ *
+ * \section asyncctrl Considerations for control transfers
+ *
+ * The <tt>libusb_transfer</tt> structure is generic and hence does not
+ * include specific fields for the control-specific setup packet structure.
+ *
+ * In order to perform a control transfer, you must place the 8-byte setup
+ * packet at the start of the data buffer. To simplify this, you could
+ * cast the buffer pointer to type struct libusb_control_setup, or you can
+ * use the helper function libusb_fill_control_setup().
+ *
+ * The wLength field placed in the setup packet must be the length you would
+ * expect to be sent in the setup packet: the length of the payload that
+ * follows (or the expected maximum number of bytes to receive). However,
+ * the length field of the libusb_transfer object must be the length of
+ * the data buffer - i.e. it should be wLength <em>plus</em> the size of
+ * the setup packet (LIBUSB_CONTROL_SETUP_SIZE).
+ *
+ * If you use the helper functions, this is simplified for you:
+ * -# Allocate a buffer of size LIBUSB_CONTROL_SETUP_SIZE plus the size of the
+ * data you are sending/requesting.
+ * -# Call libusb_fill_control_setup() on the data buffer, using the transfer
+ * request size as the wLength value (i.e. do not include the extra space you
+ * allocated for the control setup).
+ * -# If this is a host-to-device transfer, place the data to be transferred
+ * in the data buffer, starting at offset LIBUSB_CONTROL_SETUP_SIZE.
+ * -# Call libusb_fill_control_transfer() to associate the data buffer with
+ * the transfer (and to set the remaining details such as callback and timeout).
+ *   - Note that there is no parameter to set the length field of the transfer.
+ *     The length is automatically inferred from the wLength field of the setup
+ *     packet.
+ * -# Submit the transfer.
+ *
+ * The multi-byte control setup fields (wValue, wIndex and wLength) must
+ * be given in little-endian byte order (the endianness of the USB bus).
+ * Endianness conversion is transparently handled by
+ * libusb_fill_control_setup() which is documented to accept host-endian
+ * values.
+ *
+ * Further considerations are needed when handling transfer completion in
+ * your callback function:
+ * - As you might expect, the setup packet will still be sitting at the start
+ * of the data buffer.
+ * - If this was a device-to-host transfer, the received data will be sitting
+ * at offset LIBUSB_CONTROL_SETUP_SIZE into the buffer.
+ * - The actual_length field of the transfer structure is relative to the
+ * wLength of the setup packet, rather than the size of the data buffer. So,
+ * if your wLength was 4, your transfer's <tt>length</tt> was 12, then you
+ * should expect an <tt>actual_length</tt> of 4 to indicate that the data was
+ * transferred in entirity.
+ *
+ * To simplify parsing of setup packets and obtaining the data from the
+ * correct offset, you may wish to use the libusb_control_transfer_get_data()
+ * and libusb_control_transfer_get_setup() functions within your transfer
+ * callback.
+ *
+ * Even though control endpoints do not halt, a completed control transfer
+ * may have a LIBUSB_TRANSFER_STALL status code. This indicates the control
+ * request was not supported.
+ *
+ * \section asyncintr Considerations for interrupt transfers
+ *
+ * All interrupt transfers are performed using the polling interval presented
+ * by the bInterval value of the endpoint descriptor.
+ *
+ * \section asynciso Considerations for isochronous transfers
+ *
+ * Isochronous transfers are more complicated than transfers to
+ * non-isochronous endpoints.
+ *
+ * To perform I/O to an isochronous endpoint, allocate the transfer by calling
+ * libusb_alloc_transfer() with an appropriate number of isochronous packets.
+ *
+ * During filling, set \ref libusb_transfer::type "type" to
+ * \ref libusb_transfer_type::LIBUSB_TRANSFER_TYPE_ISOCHRONOUS
+ * "LIBUSB_TRANSFER_TYPE_ISOCHRONOUS", and set
+ * \ref libusb_transfer::num_iso_packets "num_iso_packets" to a value less than
+ * or equal to the number of packets you requested during allocation.
+ * libusb_alloc_transfer() does not set either of these fields for you, given
+ * that you might not even use the transfer on an isochronous endpoint.
+ *
+ * Next, populate the length field for the first num_iso_packets entries in
+ * the \ref libusb_transfer::iso_packet_desc "iso_packet_desc" array. Section
+ * 5.6.3 of the USB2 specifications describe how the maximum isochronous
+ * packet length is determined by the wMaxPacketSize field in the endpoint
+ * descriptor.
+ * Two functions can help you here:
+ *
+ * - libusb_get_max_iso_packet_size() is an easy way to determine the max
+ *   packet size for an isochronous endpoint. Note that the maximum packet
+ *   size is actually the maximum number of bytes that can be transmitted in
+ *   a single microframe, therefore this function multiplies the maximum number
+ *   of bytes per transaction by the number of transaction opportunities per
+ *   microframe.
+ * - libusb_set_iso_packet_lengths() assigns the same length to all packets
+ *   within a transfer, which is usually what you want.
+ *
+ * For outgoing transfers, you'll obviously fill the buffer and populate the
+ * packet descriptors in hope that all the data gets transferred. For incoming
+ * transfers, you must ensure the buffer has sufficient capacity for
+ * the situation where all packets transfer the full amount of requested data.
+ *
+ * Completion handling requires some extra consideration. The
+ * \ref libusb_transfer::actual_length "actual_length" field of the transfer
+ * is meaningless and should not be examined; instead you must refer to the
+ * \ref libusb_iso_packet_descriptor::actual_length "actual_length" field of
+ * each individual packet.
+ *
+ * The \ref libusb_transfer::status "status" field of the transfer is also a
+ * little misleading:
+ *  - If the packets were submitted and the isochronous data microframes
+ *    completed normally, status will have value
+ *    \ref libusb_transfer_status::LIBUSB_TRANSFER_COMPLETED
+ *    "LIBUSB_TRANSFER_COMPLETED". Note that bus errors and software-incurred
+ *    delays are not counted as transfer errors; the transfer.status field may
+ *    indicate COMPLETED even if some or all of the packets failed. Refer to
+ *    the \ref libusb_iso_packet_descriptor::status "status" field of each
+ *    individual packet to determine packet failures.
+ *  - The status field will have value
+ *    \ref libusb_transfer_status::LIBUSB_TRANSFER_ERROR
+ *    "LIBUSB_TRANSFER_ERROR" only when serious errors were encountered.
+ *  - Other transfer status codes occur with normal behaviour.
+ *
+ * The data for each packet will be found at an offset into the buffer that
+ * can be calculated as if each prior packet completed in full. The
+ * libusb_get_iso_packet_buffer() and libusb_get_iso_packet_buffer_simple()
+ * functions may help you here.
+ *
+ * <b>Note</b>: Some operating systems (e.g. Linux) may impose limits on the
+ * length of individual isochronous packets and/or the total length of the
+ * isochronous transfer. Such limits can be difficult for libusb to detect,
+ * so the library will simply try and submit the transfer as set up by you.
+ * If the transfer fails to submit because it is too large,
+ * libusb_submit_transfer() will return
+ * \ref libusb_error::LIBUSB_ERROR_INVALID_PARAM "LIBUSB_ERROR_INVALID_PARAM".
+ *
+ * \section asyncmem Memory caveats
+ *
+ * In most circumstances, it is not safe to use stack memory for transfer
+ * buffers. This is because the function that fired off the asynchronous
+ * transfer may return before libusb has finished using the buffer, and when
+ * the function returns it's stack gets destroyed. This is true for both
+ * host-to-device and device-to-host transfers.
+ *
+ * The only case in which it is safe to use stack memory is where you can
+ * guarantee that the function owning the stack space for the buffer does not
+ * return until after the transfer's callback function has completed. In every
+ * other case, you need to use heap memory instead.
+ *
+ * \section asyncflags Fine control
+ *
+ * Through using this asynchronous interface, you may find yourself repeating
+ * a few simple operations many times. You can apply a bitwise OR of certain
+ * flags to a transfer to simplify certain things:
+ * - \ref libusb_transfer_flags::LIBUSB_TRANSFER_SHORT_NOT_OK
+ *   "LIBUSB_TRANSFER_SHORT_NOT_OK" results in transfers which transferred
+ *   less than the requested amount of data being marked with status
+ *   \ref libusb_transfer_status::LIBUSB_TRANSFER_ERROR "LIBUSB_TRANSFER_ERROR"
+ *   (they would normally be regarded as COMPLETED)
+ * - \ref libusb_transfer_flags::LIBUSB_TRANSFER_FREE_BUFFER
+ *   "LIBUSB_TRANSFER_FREE_BUFFER" allows you to ask libusb to free the transfer
+ *   buffer when freeing the transfer.
+ * - \ref libusb_transfer_flags::LIBUSB_TRANSFER_FREE_TRANSFER
+ *   "LIBUSB_TRANSFER_FREE_TRANSFER" causes libusb to automatically free the
+ *   transfer after the transfer callback returns.
+ *
+ * \section asyncevent Event handling
+ *
+ * An asynchronous model requires that libusb perform work at various
+ * points in time - namely processing the results of previously-submitted
+ * transfers and invoking the user-supplied callback function.
+ *
+ * This gives rise to the libusb_handle_events() function which your
+ * application must call into when libusb has work do to. This gives libusb
+ * the opportunity to reap pending transfers, invoke callbacks, etc.
+ *
+ * There are 2 different approaches to dealing with libusb_handle_events:
+ *
+ * -# Repeatedly call libusb_handle_events() in blocking mode from a dedicated
+ *    thread.
+ * -# Integrate libusb with your application's main event loop. libusb
+ *    exposes a set of file descriptors which allow you to do this.
+ *
+ * The first approach has the big advantage that it will also work on Windows
+ * were libusb' poll API for select / poll integration is not available. So
+ * if you want to support Windows and use the async API, you must use this
+ * approach, see the \ref eventthread "Using an event handling thread" section
+ * below for details.
+ *
+ * If you prefer a single threaded approach with a single central event loop,
+ * see the \ref libusb_poll "polling and timing" section for how to integrate libusb
+ * into your application's main event loop.
+ *
+ * \section eventthread Using an event handling thread
+ *
+ * Lets begin with stating the obvious: If you're going to use a separate
+ * thread for libusb event handling, your callback functions MUST be
+ * threadsafe.
+ *
+ * Other then that doing event handling from a separate thread, is mostly
+ * simple. You can use an event thread function as follows:
+\code
+void *event_thread_func(void *ctx)
+{
+    while (event_thread_run)
+        libusb_handle_events(ctx);
+
+    return NULL;
+}
+\endcode
+ *
+ * There is one caveat though, stopping this thread requires setting the
+ * event_thread_run variable to 0, and after that libusb_handle_events() needs
+ * to return control to event_thread_func. But unless some event happens,
+ * libusb_handle_events() will not return.
+ *
+ * There are 2 different ways of dealing with this, depending on if your
+ * application uses libusb' \ref libusb_hotplug "hotplug" support or not.
+ *
+ * Applications which do not use hotplug support, should not start the event
+ * thread until after their first call to libusb_open(), and should stop the
+ * thread when closing the last open device as follows:
+\code
+void my_close_handle(libusb_device_handle *dev_handle)
+{
+    if (open_devs == 1)
+        event_thread_run = 0;
+
+    libusb_close(dev_handle); // This wakes up libusb_handle_events()
+
+    if (open_devs == 1)
+        pthread_join(event_thread);
+
+    open_devs--;
+}
+\endcode
+ *
+ * Applications using hotplug support should start the thread at program init,
+ * after having successfully called libusb_hotplug_register_callback(), and
+ * should stop the thread at program exit as follows:
+\code
+void my_libusb_exit(void)
+{
+    event_thread_run = 0;
+    libusb_hotplug_deregister_callback(ctx, hotplug_cb_handle); // This wakes up libusb_handle_events()
+    pthread_join(event_thread);
+    libusb_exit(ctx);
+}
+\endcode
+ */
+
+/**
+ * @defgroup libusb_poll Polling and timing
+ *
+ * This page documents libusb's functions for polling events and timing.
+ * These functions are only necessary for users of the
+ * \ref libusb_asyncio "asynchronous API". If you are only using the simpler
+ * \ref libusb_syncio "synchronous API" then you do not need to ever call these
+ * functions.
+ *
+ * The justification for the functionality described here has already been
+ * discussed in the \ref asyncevent "event handling" section of the
+ * asynchronous API documentation. In summary, libusb does not create internal
+ * threads for event processing and hence relies on your application calling
+ * into libusb at certain points in time so that pending events can be handled.
+ *
+ * Your main loop is probably already calling poll() or select() or a
+ * variant on a set of file descriptors for other event sources (e.g. keyboard
+ * button presses, mouse movements, network sockets, etc). You then add
+ * libusb's file descriptors to your poll()/select() calls, and when activity
+ * is detected on such descriptors you know it is time to call
+ * libusb_handle_events().
+ *
+ * There is one final event handling complication. libusb supports
+ * asynchronous transfers which time out after a specified time period.
+ *
+ * On some platforms a timerfd is used, so the timeout handling is just another
+ * fd, on other platforms this requires that libusb is called into at or after
+ * the timeout to handle it. So, in addition to considering libusb's file
+ * descriptors in your main event loop, you must also consider that libusb
+ * sometimes needs to be called into at fixed points in time even when there
+ * is no file descriptor activity, see \ref polltime details.
+ *
+ * In order to know precisely when libusb needs to be called into, libusb
+ * offers you a set of pollable file descriptors and information about when
+ * the next timeout expires.
+ *
+ * If you are using the asynchronous I/O API, you must take one of the two
+ * following options, otherwise your I/O will not complete.
+ *
+ * \section pollsimple The simple option
+ *
+ * If your application revolves solely around libusb and does not need to
+ * handle other event sources, you can have a program structure as follows:
+\code
+// initialize libusb
+// find and open device
+// maybe fire off some initial async I/O
+
+while (user_has_not_requested_exit)
+	libusb_handle_events(ctx);
+
+// clean up and exit
+\endcode
+ *
+ * With such a simple main loop, you do not have to worry about managing
+ * sets of file descriptors or handling timeouts. libusb_handle_events() will
+ * handle those details internally.
+ *
+ * \section libusb_pollmain The more advanced option
+ *
+ * \note This functionality is currently only available on Unix-like platforms.
+ * On Windows, libusb_get_pollfds() simply returns NULL. Applications which
+ * want to support Windows are advised to use an \ref eventthread
+ * "event handling thread" instead.
+ *
+ * In more advanced applications, you will already have a main loop which
+ * is monitoring other event sources: network sockets, X11 events, mouse
+ * movements, etc. Through exposing a set of file descriptors, libusb is
+ * designed to cleanly integrate into such main loops.
+ *
+ * In addition to polling file descriptors for the other event sources, you
+ * take a set of file descriptors from libusb and monitor those too. When you
+ * detect activity on libusb's file descriptors, you call
+ * libusb_handle_events_timeout() in non-blocking mode.
+ *
+ * What's more, libusb may also need to handle events at specific moments in
+ * time. No file descriptor activity is generated at these times, so your
+ * own application needs to be continually aware of when the next one of these
+ * moments occurs (through calling libusb_get_next_timeout()), and then it
+ * needs to call libusb_handle_events_timeout() in non-blocking mode when
+ * these moments occur. This means that you need to adjust your
+ * poll()/select() timeout accordingly.
+ *
+ * libusb provides you with a set of file descriptors to poll and expects you
+ * to poll all of them, treating them as a single entity. The meaning of each
+ * file descriptor in the set is an internal implementation detail,
+ * platform-dependent and may vary from release to release. Don't try and
+ * interpret the meaning of the file descriptors, just do as libusb indicates,
+ * polling all of them at once.
+ *
+ * In pseudo-code, you want something that looks like:
+\code
+// initialise libusb
+
+libusb_get_pollfds(ctx)
+while (user has not requested application exit) {
+	libusb_get_next_timeout(ctx);
+	poll(on libusb file descriptors plus any other event sources of interest,
+		using a timeout no larger than the value libusb just suggested)
+	if (poll() indicated activity on libusb file descriptors)
+		libusb_handle_events_timeout(ctx, &zero_tv);
+	if (time has elapsed to or beyond the libusb timeout)
+		libusb_handle_events_timeout(ctx, &zero_tv);
+	// handle events from other sources here
+}
+
+// clean up and exit
+\endcode
+ *
+ * \subsection polltime Notes on time-based events
+ *
+ * The above complication with having to track time and call into libusb at
+ * specific moments is a bit of a headache. For maximum compatibility, you do
+ * need to write your main loop as above, but you may decide that you can
+ * restrict the supported platforms of your application and get away with
+ * a more simplistic scheme.
+ *
+ * These time-based event complications are \b not required on the following
+ * platforms:
+ *  - Darwin
+ *  - Linux, provided that the following version requirements are satisfied:
+ *   - Linux v2.6.27 or newer, compiled with timerfd support
+ *   - glibc v2.9 or newer
+ *   - libusb v1.0.5 or newer
+ *
+ * Under these configurations, libusb_get_next_timeout() will \em always return
+ * 0, so your main loop can be simplified to:
+\code
+// initialise libusb
+
+libusb_get_pollfds(ctx)
+while (user has not requested application exit) {
+	poll(on libusb file descriptors plus any other event sources of interest,
+		using any timeout that you like)
+	if (poll() indicated activity on libusb file descriptors)
+		libusb_handle_events_timeout(ctx, &zero_tv);
+	// handle events from other sources here
+}
+
+// clean up and exit
+\endcode
+ *
+ * Do remember that if you simplify your main loop to the above, you will
+ * lose compatibility with some platforms (including legacy Linux platforms,
+ * and <em>any future platforms supported by libusb which may have time-based
+ * event requirements</em>). The resultant problems will likely appear as
+ * strange bugs in your application.
+ *
+ * You can use the libusb_pollfds_handle_timeouts() function to do a runtime
+ * check to see if it is safe to ignore the time-based event complications.
+ * If your application has taken the shortcut of ignoring libusb's next timeout
+ * in your main loop, then you are advised to check the return value of
+ * libusb_pollfds_handle_timeouts() during application startup, and to abort
+ * if the platform does suffer from these timing complications.
+ *
+ * \subsection fdsetchange Changes in the file descriptor set
+ *
+ * The set of file descriptors that libusb uses as event sources may change
+ * during the life of your application. Rather than having to repeatedly
+ * call libusb_get_pollfds(), you can set up notification functions for when
+ * the file descriptor set changes using libusb_set_pollfd_notifiers().
+ *
+ * \subsection mtissues Multi-threaded considerations
+ *
+ * Unfortunately, the situation is complicated further when multiple threads
+ * come into play. If two threads are monitoring the same file descriptors,
+ * the fact that only one thread will be woken up when an event occurs causes
+ * some headaches.
+ *
+ * The events lock, event waiters lock, and libusb_handle_events_locked()
+ * entities are added to solve these problems. You do not need to be concerned
+ * with these entities otherwise.
+ *
+ * See the extra documentation: \ref libusb_mtasync
+ */
+
+/** \page libusb_mtasync Multi-threaded applications and asynchronous I/O
+ *
+ * libusb is a thread-safe library, but extra considerations must be applied
+ * to applications which interact with libusb from multiple threads.
+ *
+ * The underlying issue that must be addressed is that all libusb I/O
+ * revolves around monitoring file descriptors through the poll()/select()
+ * system calls. This is directly exposed at the
+ * \ref libusb_asyncio "asynchronous interface" but it is important to note that the
+ * \ref libusb_syncio "synchronous interface" is implemented on top of the
+ * asynchonrous interface, therefore the same considerations apply.
+ *
+ * The issue is that if two or more threads are concurrently calling poll()
+ * or select() on libusb's file descriptors then only one of those threads
+ * will be woken up when an event arrives. The others will be completely
+ * oblivious that anything has happened.
+ *
+ * Consider the following pseudo-code, which submits an asynchronous transfer
+ * then waits for its completion. This style is one way you could implement a
+ * synchronous interface on top of the asynchronous interface (and libusb
+ * does something similar, albeit more advanced due to the complications
+ * explained on this page).
+ *
+\code
+void cb(struct libusb_transfer *transfer)
+{
+	int *completed = transfer->user_data;
+	*completed = 1;
+}
+
+void myfunc() {
+	struct libusb_transfer *transfer;
+	unsigned char buffer[LIBUSB_CONTROL_SETUP_SIZE] __attribute__ ((aligned (2)));
+	int completed = 0;
+
+	transfer = libusb_alloc_transfer(0);
+	libusb_fill_control_setup(buffer,
+		LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_ENDPOINT_OUT, 0x04, 0x01, 0, 0);
+	libusb_fill_control_transfer(transfer, dev, buffer, cb, &completed, 1000);
+	libusb_submit_transfer(transfer);
+
+	while (!completed) {
+		poll(libusb file descriptors, 120*1000);
+		if (poll indicates activity)
+			libusb_handle_events_timeout(ctx, &zero_tv);
+	}
+	printf("completed!");
+	// other code here
+}
+\endcode
+ *
+ * Here we are <em>serializing</em> completion of an asynchronous event
+ * against a condition - the condition being completion of a specific transfer.
+ * The poll() loop has a long timeout to minimize CPU usage during situations
+ * when nothing is happening (it could reasonably be unlimited).
+ *
+ * If this is the only thread that is polling libusb's file descriptors, there
+ * is no problem: there is no danger that another thread will swallow up the
+ * event that we are interested in. On the other hand, if there is another
+ * thread polling the same descriptors, there is a chance that it will receive
+ * the event that we were interested in. In this situation, <tt>myfunc()</tt>
+ * will only realise that the transfer has completed on the next iteration of
+ * the loop, <em>up to 120 seconds later.</em> Clearly a two-minute delay is
+ * undesirable, and don't even think about using short timeouts to circumvent
+ * this issue!
+ *
+ * The solution here is to ensure that no two threads are ever polling the
+ * file descriptors at the same time. A naive implementation of this would
+ * impact the capabilities of the library, so libusb offers the scheme
+ * documented below to ensure no loss of functionality.
+ *
+ * Before we go any further, it is worth mentioning that all libusb-wrapped
+ * event handling procedures fully adhere to the scheme documented below.
+ * This includes libusb_handle_events() and its variants, and all the
+ * synchronous I/O functions - libusb hides this headache from you.
+ *
+ * \section Using libusb_handle_events() from multiple threads
+ *
+ * Even when only using libusb_handle_events() and synchronous I/O functions,
+ * you can still have a race condition. You might be tempted to solve the
+ * above with libusb_handle_events() like so:
+ *
+\code
+	libusb_submit_transfer(transfer);
+
+	while (!completed) {
+		libusb_handle_events(ctx);
+	}
+	printf("completed!");
+\endcode
+ *
+ * This however has a race between the checking of completed and
+ * libusb_handle_events() acquiring the events lock, so another thread
+ * could have completed the transfer, resulting in this thread hanging
+ * until either a timeout or another event occurs. See also commit
+ * 6696512aade99bb15d6792af90ae329af270eba6 which fixes this in the
+ * synchronous API implementation of libusb.
+ *
+ * Fixing this race requires checking the variable completed only after
+ * taking the event lock, which defeats the concept of just calling
+ * libusb_handle_events() without worrying about locking. This is why
+ * libusb-1.0.9 introduces the new libusb_handle_events_timeout_completed()
+ * and libusb_handle_events_completed() functions, which handles doing the
+ * completion check for you after they have acquired the lock:
+ *
+\code
+	libusb_submit_transfer(transfer);
+
+	while (!completed) {
+		libusb_handle_events_completed(ctx, &completed);
+	}
+	printf("completed!");
+\endcode
+ *
+ * This nicely fixes the race in our example. Note that if all you want to
+ * do is submit a single transfer and wait for its completion, then using
+ * one of the synchronous I/O functions is much easier.
+ *
+ * \section eventlock The events lock
+ *
+ * The problem is when we consider the fact that libusb exposes file
+ * descriptors to allow for you to integrate asynchronous USB I/O into
+ * existing main loops, effectively allowing you to do some work behind
+ * libusb's back. If you do take libusb's file descriptors and pass them to
+ * poll()/select() yourself, you need to be aware of the associated issues.
+ *
+ * The first concept to be introduced is the events lock. The events lock
+ * is used to serialize threads that want to handle events, such that only
+ * one thread is handling events at any one time.
+ *
+ * You must take the events lock before polling libusb file descriptors,
+ * using libusb_lock_events(). You must release the lock as soon as you have
+ * aborted your poll()/select() loop, using libusb_unlock_events().
+ *
+ * \section threadwait Letting other threads do the work for you
+ *
+ * Although the events lock is a critical part of the solution, it is not
+ * enough on it's own. You might wonder if the following is sufficient...
+\code
+	libusb_lock_events(ctx);
+	while (!completed) {
+		poll(libusb file descriptors, 120*1000);
+		if (poll indicates activity)
+			libusb_handle_events_timeout(ctx, &zero_tv);
+	}
+	libusb_unlock_events(ctx);
+\endcode
+ * ...and the answer is that it is not. This is because the transfer in the
+ * code shown above may take a long time (say 30 seconds) to complete, and
+ * the lock is not released until the transfer is completed.
+ *
+ * Another thread with similar code that wants to do event handling may be
+ * working with a transfer that completes after a few milliseconds. Despite
+ * having such a quick completion time, the other thread cannot check that
+ * status of its transfer until the code above has finished (30 seconds later)
+ * due to contention on the lock.
+ *
+ * To solve this, libusb offers you a mechanism to determine when another
+ * thread is handling events. It also offers a mechanism to block your thread
+ * until the event handling thread has completed an event (and this mechanism
+ * does not involve polling of file descriptors).
+ *
+ * After determining that another thread is currently handling events, you
+ * obtain the <em>event waiters</em> lock using libusb_lock_event_waiters().
+ * You then re-check that some other thread is still handling events, and if
+ * so, you call libusb_wait_for_event().
+ *
+ * libusb_wait_for_event() puts your application to sleep until an event
+ * occurs, or until a thread releases the events lock. When either of these
+ * things happen, your thread is woken up, and should re-check the condition
+ * it was waiting on. It should also re-check that another thread is handling
+ * events, and if not, it should start handling events itself.
+ *
+ * This looks like the following, as pseudo-code:
+\code
+retry:
+if (libusb_try_lock_events(ctx) == 0) {
+	// we obtained the event lock: do our own event handling
+	while (!completed) {
+		if (!libusb_event_handling_ok(ctx)) {
+			libusb_unlock_events(ctx);
+			goto retry;
+		}
+		poll(libusb file descriptors, 120*1000);
+		if (poll indicates activity)
+			libusb_handle_events_locked(ctx, 0);
+	}
+	libusb_unlock_events(ctx);
+} else {
+	// another thread is doing event handling. wait for it to signal us that
+	// an event has completed
+	libusb_lock_event_waiters(ctx);
+
+	while (!completed) {
+		// now that we have the event waiters lock, double check that another
+		// thread is still handling events for us. (it may have ceased handling
+		// events in the time it took us to reach this point)
+		if (!libusb_event_handler_active(ctx)) {
+			// whoever was handling events is no longer doing so, try again
+			libusb_unlock_event_waiters(ctx);
+			goto retry;
+		}
+
+		libusb_wait_for_event(ctx, NULL);
+	}
+	libusb_unlock_event_waiters(ctx);
+}
+printf("completed!\n");
+\endcode
+ *
+ * A naive look at the above code may suggest that this can only support
+ * one event waiter (hence a total of 2 competing threads, the other doing
+ * event handling), because the event waiter seems to have taken the event
+ * waiters lock while waiting for an event. However, the system does support
+ * multiple event waiters, because libusb_wait_for_event() actually drops
+ * the lock while waiting, and reaquires it before continuing.
+ *
+ * We have now implemented code which can dynamically handle situations where
+ * nobody is handling events (so we should do it ourselves), and it can also
+ * handle situations where another thread is doing event handling (so we can
+ * piggyback onto them). It is also equipped to handle a combination of
+ * the two, for example, another thread is doing event handling, but for
+ * whatever reason it stops doing so before our condition is met, so we take
+ * over the event handling.
+ *
+ * Four functions were introduced in the above pseudo-code. Their importance
+ * should be apparent from the code shown above.
+ * -# libusb_try_lock_events() is a non-blocking function which attempts
+ *    to acquire the events lock but returns a failure code if it is contended.
+ * -# libusb_event_handling_ok() checks that libusb is still happy for your
+ *    thread to be performing event handling. Sometimes, libusb needs to
+ *    interrupt the event handler, and this is how you can check if you have
+ *    been interrupted. If this function returns 0, the correct behaviour is
+ *    for you to give up the event handling lock, and then to repeat the cycle.
+ *    The following libusb_try_lock_events() will fail, so you will become an
+ *    events waiter. For more information on this, read \ref fullstory below.
+ * -# libusb_handle_events_locked() is a variant of
+ *    libusb_handle_events_timeout() that you can call while holding the
+ *    events lock. libusb_handle_events_timeout() itself implements similar
+ *    logic to the above, so be sure not to call it when you are
+ *    "working behind libusb's back", as is the case here.
+ * -# libusb_event_handler_active() determines if someone is currently
+ *    holding the events lock
+ *
+ * You might be wondering why there is no function to wake up all threads
+ * blocked on libusb_wait_for_event(). This is because libusb can do this
+ * internally: it will wake up all such threads when someone calls
+ * libusb_unlock_events() or when a transfer completes (at the point after its
+ * callback has returned).
+ *
+ * \subsection fullstory The full story
+ *
+ * The above explanation should be enough to get you going, but if you're
+ * really thinking through the issues then you may be left with some more
+ * questions regarding libusb's internals. If you're curious, read on, and if
+ * not, skip to the next section to avoid confusing yourself!
+ *
+ * The immediate question that may spring to mind is: what if one thread
+ * modifies the set of file descriptors that need to be polled while another
+ * thread is doing event handling?
+ *
+ * There are 2 situations in which this may happen.
+ * -# libusb_open() will add another file descriptor to the poll set,
+ *    therefore it is desirable to interrupt the event handler so that it
+ *    restarts, picking up the new descriptor.
+ * -# libusb_close() will remove a file descriptor from the poll set. There
+ *    are all kinds of race conditions that could arise here, so it is
+ *    important that nobody is doing event handling at this time.
+ *
+ * libusb handles these issues internally, so application developers do not
+ * have to stop their event handlers while opening/closing devices. Here's how
+ * it works, focusing on the libusb_close() situation first:
+ *
+ * -# During initialization, libusb opens an internal pipe, and it adds the read
+ *    end of this pipe to the set of file descriptors to be polled.
+ * -# During libusb_close(), libusb writes some dummy data on this event pipe.
+ *    This immediately interrupts the event handler. libusb also records
+ *    internally that it is trying to interrupt event handlers for this
+ *    high-priority event.
+ * -# At this point, some of the functions described above start behaving
+ *    differently:
+ *   - libusb_event_handling_ok() starts returning 1, indicating that it is NOT
+ *     OK for event handling to continue.
+ *   - libusb_try_lock_events() starts returning 1, indicating that another
+ *     thread holds the event handling lock, even if the lock is uncontended.
+ *   - libusb_event_handler_active() starts returning 1, indicating that
+ *     another thread is doing event handling, even if that is not true.
+ * -# The above changes in behaviour result in the event handler stopping and
+ *    giving up the events lock very quickly, giving the high-priority
+ *    libusb_close() operation a "free ride" to acquire the events lock. All
+ *    threads that are competing to do event handling become event waiters.
+ * -# With the events lock held inside libusb_close(), libusb can safely remove
+ *    a file descriptor from the poll set, in the safety of knowledge that
+ *    nobody is polling those descriptors or trying to access the poll set.
+ * -# After obtaining the events lock, the close operation completes very
+ *    quickly (usually a matter of milliseconds) and then immediately releases
+ *    the events lock.
+ * -# At the same time, the behaviour of libusb_event_handling_ok() and friends
+ *    reverts to the original, documented behaviour.
+ * -# The release of the events lock causes the threads that are waiting for
+ *    events to be woken up and to start competing to become event handlers
+ *    again. One of them will succeed; it will then re-obtain the list of poll
+ *    descriptors, and USB I/O will then continue as normal.
+ *
+ * libusb_open() is similar, and is actually a more simplistic case. Upon a
+ * call to libusb_open():
+ *
+ * -# The device is opened and a file descriptor is added to the poll set.
+ * -# libusb sends some dummy data on the event pipe, and records that it
+ *    is trying to modify the poll descriptor set.
+ * -# The event handler is interrupted, and the same behaviour change as for
+ *    libusb_close() takes effect, causing all event handling threads to become
+ *    event waiters.
+ * -# The libusb_open() implementation takes its free ride to the events lock.
+ * -# Happy that it has successfully paused the events handler, libusb_open()
+ *    releases the events lock.
+ * -# The event waiter threads are all woken up and compete to become event
+ *    handlers again. The one that succeeds will obtain the list of poll
+ *    descriptors again, which will include the addition of the new device.
+ *
+ * \subsection concl Closing remarks
+ *
+ * The above may seem a little complicated, but hopefully I have made it clear
+ * why such complications are necessary. Also, do not forget that this only
+ * applies to applications that take libusb's file descriptors and integrate
+ * them into their own polling loops.
+ *
+ * You may decide that it is OK for your multi-threaded application to ignore
+ * some of the rules and locks detailed above, because you don't think that
+ * two threads can ever be polling the descriptors at the same time. If that
+ * is the case, then that's good news for you because you don't have to worry.
+ * But be careful here; remember that the synchronous I/O functions do event
+ * handling internally. If you have one thread doing event handling in a loop
+ * (without implementing the rules and locking semantics documented above)
+ * and another trying to send a synchronous USB transfer, you will end up with
+ * two threads monitoring the same descriptors, and the above-described
+ * undesirable behaviour occurring. The solution is for your polling thread to
+ * play by the rules; the synchronous I/O functions do so, and this will result
+ * in them getting along in perfect harmony.
+ *
+ * If you do have a dedicated thread doing event handling, it is perfectly
+ * legal for it to take the event handling lock for long periods of time. Any
+ * synchronous I/O functions you call from other threads will transparently
+ * fall back to the "event waiters" mechanism detailed above. The only
+ * consideration that your event handling thread must apply is the one related
+ * to libusb_event_handling_ok(): you must call this before every poll(), and
+ * give up the events lock if instructed.
+ */
+
+int usbi_io_init(struct libusb_context *ctx)
+{
+	int r;
+
+	usbi_mutex_init(&ctx->flying_transfers_lock);
+	usbi_mutex_init(&ctx->events_lock);
+	usbi_mutex_init(&ctx->event_waiters_lock);
+	usbi_cond_init(&ctx->event_waiters_cond);
+	usbi_mutex_init(&ctx->event_data_lock);
+	usbi_tls_key_create(&ctx->event_handling_key);
+	list_init(&ctx->flying_transfers);
+	list_init(&ctx->ipollfds);
+	list_init(&ctx->hotplug_msgs);
+	list_init(&ctx->completed_transfers);
+
+	/* FIXME should use an eventfd on kernels that support it */
+	r = usbi_pipe(ctx->event_pipe);
+	if (r < 0) {
+		r = LIBUSB_ERROR_OTHER;
+		goto err;
+	}
+
+	r = usbi_add_pollfd(ctx, ctx->event_pipe[0], POLLIN);
+	if (r < 0)
+		goto err_close_pipe;
+
+#ifdef USBI_TIMERFD_AVAILABLE
+	ctx->timerfd = timerfd_create(usbi_backend.get_timerfd_clockid(),
+		TFD_NONBLOCK | TFD_CLOEXEC);
+	if (ctx->timerfd >= 0) {
+		usbi_dbg("using timerfd for timeouts");
+		r = usbi_add_pollfd(ctx, ctx->timerfd, POLLIN);
+		if (r < 0)
+			goto err_close_timerfd;
+	} else {
+		usbi_dbg("timerfd not available (code %d error %d)", ctx->timerfd, errno);
+		ctx->timerfd = -1;
+	}
+#endif
+
+	return 0;
+
+#ifdef USBI_TIMERFD_AVAILABLE
+err_close_timerfd:
+	close(ctx->timerfd);
+	usbi_remove_pollfd(ctx, ctx->event_pipe[0]);
+#endif
+err_close_pipe:
+	usbi_close(ctx->event_pipe[0]);
+	usbi_close(ctx->event_pipe[1]);
+err:
+	usbi_mutex_destroy(&ctx->flying_transfers_lock);
+	usbi_mutex_destroy(&ctx->events_lock);
+	usbi_mutex_destroy(&ctx->event_waiters_lock);
+	usbi_cond_destroy(&ctx->event_waiters_cond);
+	usbi_mutex_destroy(&ctx->event_data_lock);
+	usbi_tls_key_delete(ctx->event_handling_key);
+	return r;
+}
+
+void usbi_io_exit(struct libusb_context *ctx)
+{
+	usbi_remove_pollfd(ctx, ctx->event_pipe[0]);
+	usbi_close(ctx->event_pipe[0]);
+	usbi_close(ctx->event_pipe[1]);
+#ifdef USBI_TIMERFD_AVAILABLE
+	if (usbi_using_timerfd(ctx)) {
+		usbi_remove_pollfd(ctx, ctx->timerfd);
+		close(ctx->timerfd);
+	}
+#endif
+	usbi_mutex_destroy(&ctx->flying_transfers_lock);
+	usbi_mutex_destroy(&ctx->events_lock);
+	usbi_mutex_destroy(&ctx->event_waiters_lock);
+	usbi_cond_destroy(&ctx->event_waiters_cond);
+	usbi_mutex_destroy(&ctx->event_data_lock);
+	usbi_tls_key_delete(ctx->event_handling_key);
+	if (ctx->pollfds)
+		free(ctx->pollfds);
+}
+
+static int calculate_timeout(struct usbi_transfer *transfer)
+{
+	int r;
+	struct timespec current_time;
+	unsigned int timeout =
+		USBI_TRANSFER_TO_LIBUSB_TRANSFER(transfer)->timeout;
+
+	if (!timeout) {
+		timerclear(&transfer->timeout);
+		return 0;
+	}
+
+	r = usbi_backend.clock_gettime(USBI_CLOCK_MONOTONIC, &current_time);
+	if (r < 0) {
+		usbi_err(ITRANSFER_CTX(transfer),
+			"failed to read monotonic clock, errno=%d", errno);
+		return r;
+	}
+
+	current_time.tv_sec += timeout / 1000;
+	current_time.tv_nsec += (timeout % 1000) * 1000000;
+
+	while (current_time.tv_nsec >= 1000000000) {
+		current_time.tv_nsec -= 1000000000;
+		current_time.tv_sec++;
+	}
+
+	TIMESPEC_TO_TIMEVAL(&transfer->timeout, &current_time);
+	return 0;
+}
+
+/** \ingroup libusb_asyncio
+ * Allocate a libusb transfer with a specified number of isochronous packet
+ * descriptors. The returned transfer is pre-initialized for you. When the new
+ * transfer is no longer needed, it should be freed with
+ * libusb_free_transfer().
+ *
+ * Transfers intended for non-isochronous endpoints (e.g. control, bulk,
+ * interrupt) should specify an iso_packets count of zero.
+ *
+ * For transfers intended for isochronous endpoints, specify an appropriate
+ * number of packet descriptors to be allocated as part of the transfer.
+ * The returned transfer is not specially initialized for isochronous I/O;
+ * you are still required to set the
+ * \ref libusb_transfer::num_iso_packets "num_iso_packets" and
+ * \ref libusb_transfer::type "type" fields accordingly.
+ *
+ * It is safe to allocate a transfer with some isochronous packets and then
+ * use it on a non-isochronous endpoint. If you do this, ensure that at time
+ * of submission, num_iso_packets is 0 and that type is set appropriately.
+ *
+ * \param iso_packets number of isochronous packet descriptors to allocate
+ * \returns a newly allocated transfer, or NULL on error
+ */
+DEFAULT_VISIBILITY
+struct libusb_transfer * LIBUSB_CALL libusb_alloc_transfer(
+	int iso_packets)
+{
+	struct libusb_transfer *transfer;
+	size_t os_alloc_size = usbi_backend.transfer_priv_size;
+	size_t alloc_size = sizeof(struct usbi_transfer)
+		+ sizeof(struct libusb_transfer)
+		+ (sizeof(struct libusb_iso_packet_descriptor) * iso_packets)
+		+ os_alloc_size;
+	struct usbi_transfer *itransfer = calloc(1, alloc_size);
+	if (!itransfer)
+		return NULL;
+
+	itransfer->num_iso_packets = iso_packets;
+	usbi_mutex_init(&itransfer->lock);
+	transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	usbi_dbg("transfer %p", transfer);
+	return transfer;
+}
+
+/** \ingroup libusb_asyncio
+ * Free a transfer structure. This should be called for all transfers
+ * allocated with libusb_alloc_transfer().
+ *
+ * If the \ref libusb_transfer_flags::LIBUSB_TRANSFER_FREE_BUFFER
+ * "LIBUSB_TRANSFER_FREE_BUFFER" flag is set and the transfer buffer is
+ * non-NULL, this function will also free the transfer buffer using the
+ * standard system memory allocator (e.g. free()).
+ *
+ * It is legal to call this function with a NULL transfer. In this case,
+ * the function will simply return safely.
+ *
+ * It is not legal to free an active transfer (one which has been submitted
+ * and has not yet completed).
+ *
+ * \param transfer the transfer to free
+ */
+void API_EXPORTED libusb_free_transfer(struct libusb_transfer *transfer)
+{
+	struct usbi_transfer *itransfer;
+	if (!transfer)
+		return;
+
+	usbi_dbg("transfer %p", transfer);
+	if (transfer->flags & LIBUSB_TRANSFER_FREE_BUFFER && transfer->buffer)
+		free(transfer->buffer);
+
+	itransfer = LIBUSB_TRANSFER_TO_USBI_TRANSFER(transfer);
+	usbi_mutex_destroy(&itransfer->lock);
+	free(itransfer);
+}
+
+#ifdef USBI_TIMERFD_AVAILABLE
+static int disarm_timerfd(struct libusb_context *ctx)
+{
+	const struct itimerspec disarm_timer = { { 0, 0 }, { 0, 0 } };
+	int r;
+
+	usbi_dbg("");
+	r = timerfd_settime(ctx->timerfd, 0, &disarm_timer, NULL);
+	if (r < 0)
+		return LIBUSB_ERROR_OTHER;
+	else
+		return 0;
+}
+
+/* iterates through the flying transfers, and rearms the timerfd based on the
+ * next upcoming timeout.
+ * must be called with flying_list locked.
+ * returns 0 on success or a LIBUSB_ERROR code on failure.
+ */
+static int arm_timerfd_for_next_timeout(struct libusb_context *ctx)
+{
+	struct usbi_transfer *transfer;
+
+	list_for_each_entry(transfer, &ctx->flying_transfers, list, struct usbi_transfer) {
+		struct timeval *cur_tv = &transfer->timeout;
+
+		/* if we've reached transfers of infinite timeout, then we have no
+		 * arming to do */
+		if (!timerisset(cur_tv))
+			goto disarm;
+
+		/* act on first transfer that has not already been handled */
+		if (!(transfer->timeout_flags & (USBI_TRANSFER_TIMEOUT_HANDLED | USBI_TRANSFER_OS_HANDLES_TIMEOUT))) {
+			int r;
+			const struct itimerspec it = { {0, 0},
+				{ cur_tv->tv_sec, cur_tv->tv_usec * 1000 } };
+			usbi_dbg("next timeout originally %dms", USBI_TRANSFER_TO_LIBUSB_TRANSFER(transfer)->timeout);
+			r = timerfd_settime(ctx->timerfd, TFD_TIMER_ABSTIME, &it, NULL);
+			if (r < 0)
+				return LIBUSB_ERROR_OTHER;
+			return 0;
+		}
+	}
+
+disarm:
+	return disarm_timerfd(ctx);
+}
+#else
+static int arm_timerfd_for_next_timeout(struct libusb_context *ctx)
+{
+	UNUSED(ctx);
+	return 0;
+}
+#endif
+
+/* add a transfer to the (timeout-sorted) active transfers list.
+ * This function will return non 0 if fails to update the timer,
+ * in which case the transfer is *not* on the flying_transfers list. */
+static int add_to_flying_list(struct usbi_transfer *transfer)
+{
+	struct usbi_transfer *cur;
+	struct timeval *timeout = &transfer->timeout;
+	struct libusb_context *ctx = ITRANSFER_CTX(transfer);
+	int r;
+	int first = 1;
+
+	r = calculate_timeout(transfer);
+	if (r)
+		return r;
+
+	/* if we have no other flying transfers, start the list with this one */
+	if (list_empty(&ctx->flying_transfers)) {
+		list_add(&transfer->list, &ctx->flying_transfers);
+		goto out;
+	}
+
+	/* if we have infinite timeout, append to end of list */
+	if (!timerisset(timeout)) {
+		list_add_tail(&transfer->list, &ctx->flying_transfers);
+		/* first is irrelevant in this case */
+		goto out;
+	}
+
+	/* otherwise, find appropriate place in list */
+	list_for_each_entry(cur, &ctx->flying_transfers, list, struct usbi_transfer) {
+		/* find first timeout that occurs after the transfer in question */
+		struct timeval *cur_tv = &cur->timeout;
+
+		if (!timerisset(cur_tv) || (cur_tv->tv_sec > timeout->tv_sec) ||
+				(cur_tv->tv_sec == timeout->tv_sec &&
+					cur_tv->tv_usec > timeout->tv_usec)) {
+			list_add_tail(&transfer->list, &cur->list);
+			goto out;
+		}
+		first = 0;
+	}
+	/* first is 0 at this stage (list not empty) */
+
+	/* otherwise we need to be inserted at the end */
+	list_add_tail(&transfer->list, &ctx->flying_transfers);
+out:
+#ifdef USBI_TIMERFD_AVAILABLE
+	if (first && usbi_using_timerfd(ctx) && timerisset(timeout)) {
+		/* if this transfer has the lowest timeout of all active transfers,
+		 * rearm the timerfd with this transfer's timeout */
+		const struct itimerspec it = { {0, 0},
+			{ timeout->tv_sec, timeout->tv_usec * 1000 } };
+		usbi_dbg("arm timerfd for timeout in %dms (first in line)",
+			USBI_TRANSFER_TO_LIBUSB_TRANSFER(transfer)->timeout);
+		r = timerfd_settime(ctx->timerfd, TFD_TIMER_ABSTIME, &it, NULL);
+		if (r < 0) {
+			usbi_warn(ctx, "failed to arm first timerfd (errno %d)", errno);
+			r = LIBUSB_ERROR_OTHER;
+		}
+	}
+#else
+	UNUSED(first);
+#endif
+
+	if (r)
+		list_del(&transfer->list);
+
+	return r;
+}
+
+/* remove a transfer from the active transfers list.
+ * This function will *always* remove the transfer from the
+ * flying_transfers list. It will return a LIBUSB_ERROR code
+ * if it fails to update the timer for the next timeout. */
+static int remove_from_flying_list(struct usbi_transfer *transfer)
+{
+	struct libusb_context *ctx = ITRANSFER_CTX(transfer);
+	int rearm_timerfd;
+	int r = 0;
+
+	usbi_mutex_lock(&ctx->flying_transfers_lock);
+	rearm_timerfd = (timerisset(&transfer->timeout) &&
+		list_first_entry(&ctx->flying_transfers, struct usbi_transfer, list) == transfer);
+	list_del(&transfer->list);
+	if (usbi_using_timerfd(ctx) && rearm_timerfd)
+		r = arm_timerfd_for_next_timeout(ctx);
+	usbi_mutex_unlock(&ctx->flying_transfers_lock);
+
+	return r;
+}
+
+/** \ingroup libusb_asyncio
+ * Submit a transfer. This function will fire off the USB transfer and then
+ * return immediately.
+ *
+ * \param transfer the transfer to submit
+ * \returns 0 on success
+ * \returns LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * \returns LIBUSB_ERROR_BUSY if the transfer has already been submitted.
+ * \returns LIBUSB_ERROR_NOT_SUPPORTED if the transfer flags are not supported
+ * by the operating system.
+ * \returns LIBUSB_ERROR_INVALID_PARAM if the transfer size is larger than
+ * the operating system and/or hardware can support
+ * \returns another LIBUSB_ERROR code on other failure
+ */
+int API_EXPORTED libusb_submit_transfer(struct libusb_transfer *transfer)
+{
+	struct usbi_transfer *itransfer =
+		LIBUSB_TRANSFER_TO_USBI_TRANSFER(transfer);
+	struct libusb_context *ctx = TRANSFER_CTX(transfer);
+	int r;
+
+	usbi_dbg("transfer %p", transfer);
+
+	/*
+	 * Important note on locking, this function takes / releases locks
+	 * in the following order:
+	 *  take flying_transfers_lock
+	 *  take itransfer->lock
+	 *  clear transfer
+	 *  add to flying_transfers list
+	 *  release flying_transfers_lock
+	 *  submit transfer
+	 *  release itransfer->lock
+	 *  if submit failed:
+	 *   take flying_transfers_lock
+	 *   remove from flying_transfers list
+	 *   release flying_transfers_lock
+	 *
+	 * Note that it takes locks in the order a-b and then releases them
+	 * in the same order a-b. This is somewhat unusual but not wrong,
+	 * release order is not important as long as *all* locks are released
+	 * before re-acquiring any locks.
+	 *
+	 * This means that the ordering of first releasing itransfer->lock
+	 * and then re-acquiring the flying_transfers_list on error is
+	 * important and must not be changed!
+	 *
+	 * This is done this way because when we take both locks we must always
+	 * take flying_transfers_lock first to avoid ab-ba style deadlocks with
+	 * the timeout handling and usbi_handle_disconnect paths.
+	 *
+	 * And we cannot release itransfer->lock before the submission is
+	 * complete otherwise timeout handling for transfers with short
+	 * timeouts may run before submission.
+	 */
+	usbi_mutex_lock(&ctx->flying_transfers_lock);
+	usbi_mutex_lock(&itransfer->lock);
+	if (itransfer->state_flags & USBI_TRANSFER_IN_FLIGHT) {
+		usbi_mutex_unlock(&ctx->flying_transfers_lock);
+		usbi_mutex_unlock(&itransfer->lock);
+		return LIBUSB_ERROR_BUSY;
+	}
+	itransfer->transferred = 0;
+	itransfer->state_flags = 0;
+	itransfer->timeout_flags = 0;
+	r = add_to_flying_list(itransfer);
+	if (r) {
+		usbi_mutex_unlock(&ctx->flying_transfers_lock);
+		usbi_mutex_unlock(&itransfer->lock);
+		return r;
+	}
+	/*
+	 * We must release the flying transfers lock here, because with
+	 * some backends the submit_transfer method is synchroneous.
+	 */
+	usbi_mutex_unlock(&ctx->flying_transfers_lock);
+
+	r = usbi_backend.submit_transfer(itransfer);
+	if (r == LIBUSB_SUCCESS) {
+		itransfer->state_flags |= USBI_TRANSFER_IN_FLIGHT;
+		/* keep a reference to this device */
+		libusb_ref_device(transfer->dev_handle->dev);
+	}
+	usbi_mutex_unlock(&itransfer->lock);
+
+	if (r != LIBUSB_SUCCESS)
+		remove_from_flying_list(itransfer);
+
+	return r;
+}
+
+/** \ingroup libusb_asyncio
+ * Asynchronously cancel a previously submitted transfer.
+ * This function returns immediately, but this does not indicate cancellation
+ * is complete. Your callback function will be invoked at some later time
+ * with a transfer status of
+ * \ref libusb_transfer_status::LIBUSB_TRANSFER_CANCELLED
+ * "LIBUSB_TRANSFER_CANCELLED."
+ *
+ * \param transfer the transfer to cancel
+ * \returns 0 on success
+ * \returns LIBUSB_ERROR_NOT_FOUND if the transfer is not in progress,
+ * already complete, or already cancelled.
+ * \returns a LIBUSB_ERROR code on failure
+ */
+int API_EXPORTED libusb_cancel_transfer(struct libusb_transfer *transfer)
+{
+	struct usbi_transfer *itransfer =
+		LIBUSB_TRANSFER_TO_USBI_TRANSFER(transfer);
+	int r;
+
+	usbi_dbg("transfer %p", transfer );
+	usbi_mutex_lock(&itransfer->lock);
+	if (!(itransfer->state_flags & USBI_TRANSFER_IN_FLIGHT)
+			|| (itransfer->state_flags & USBI_TRANSFER_CANCELLING)) {
+		r = LIBUSB_ERROR_NOT_FOUND;
+		goto out;
+	}
+	r = usbi_backend.cancel_transfer(itransfer);
+	if (r < 0) {
+		if (r != LIBUSB_ERROR_NOT_FOUND &&
+		    r != LIBUSB_ERROR_NO_DEVICE)
+			usbi_err(TRANSFER_CTX(transfer),
+				"cancel transfer failed error %d", r);
+		else
+			usbi_dbg("cancel transfer failed error %d", r);
+
+		if (r == LIBUSB_ERROR_NO_DEVICE)
+			itransfer->state_flags |= USBI_TRANSFER_DEVICE_DISAPPEARED;
+	}
+
+	itransfer->state_flags |= USBI_TRANSFER_CANCELLING;
+
+out:
+	usbi_mutex_unlock(&itransfer->lock);
+	return r;
+}
+
+/** \ingroup libusb_asyncio
+ * Set a transfers bulk stream id. Note users are advised to use
+ * libusb_fill_bulk_stream_transfer() instead of calling this function
+ * directly.
+ *
+ * Since version 1.0.19, \ref LIBUSB_API_VERSION >= 0x01000103
+ *
+ * \param transfer the transfer to set the stream id for
+ * \param stream_id the stream id to set
+ * \see libusb_alloc_streams()
+ */
+void API_EXPORTED libusb_transfer_set_stream_id(
+	struct libusb_transfer *transfer, uint32_t stream_id)
+{
+	struct usbi_transfer *itransfer =
+		LIBUSB_TRANSFER_TO_USBI_TRANSFER(transfer);
+
+	itransfer->stream_id = stream_id;
+}
+
+/** \ingroup libusb_asyncio
+ * Get a transfers bulk stream id.
+ *
+ * Since version 1.0.19, \ref LIBUSB_API_VERSION >= 0x01000103
+ *
+ * \param transfer the transfer to get the stream id for
+ * \returns the stream id for the transfer
+ */
+uint32_t API_EXPORTED libusb_transfer_get_stream_id(
+	struct libusb_transfer *transfer)
+{
+	struct usbi_transfer *itransfer =
+		LIBUSB_TRANSFER_TO_USBI_TRANSFER(transfer);
+
+	return itransfer->stream_id;
+}
+
+/* Handle completion of a transfer (completion might be an error condition).
+ * This will invoke the user-supplied callback function, which may end up
+ * freeing the transfer. Therefore you cannot use the transfer structure
+ * after calling this function, and you should free all backend-specific
+ * data before calling it.
+ * Do not call this function with the usbi_transfer lock held. User-specified
+ * callback functions may attempt to directly resubmit the transfer, which
+ * will attempt to take the lock. */
+int usbi_handle_transfer_completion(struct usbi_transfer *itransfer,
+	enum libusb_transfer_status status)
+{
+	struct libusb_transfer *transfer =
+		USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct libusb_device_handle *dev_handle = transfer->dev_handle;
+	uint8_t flags;
+	int r;
+
+	r = remove_from_flying_list(itransfer);
+	if (r < 0)
+		usbi_err(ITRANSFER_CTX(itransfer), "failed to set timer for next timeout, errno=%d", errno);
+
+	usbi_mutex_lock(&itransfer->lock);
+	itransfer->state_flags &= ~USBI_TRANSFER_IN_FLIGHT;
+	usbi_mutex_unlock(&itransfer->lock);
+
+	if (status == LIBUSB_TRANSFER_COMPLETED
+			&& transfer->flags & LIBUSB_TRANSFER_SHORT_NOT_OK) {
+		int rqlen = transfer->length;
+		if (transfer->type == LIBUSB_TRANSFER_TYPE_CONTROL)
+			rqlen -= LIBUSB_CONTROL_SETUP_SIZE;
+		if (rqlen != itransfer->transferred) {
+			usbi_dbg("interpreting short transfer as error");
+			status = LIBUSB_TRANSFER_ERROR;
+		}
+	}
+
+	flags = transfer->flags;
+	transfer->status = status;
+	transfer->actual_length = itransfer->transferred;
+	usbi_dbg("transfer %p has callback %p", transfer, transfer->callback);
+	if (transfer->callback)
+		transfer->callback(transfer);
+	/* transfer might have been freed by the above call, do not use from
+	 * this point. */
+	if (flags & LIBUSB_TRANSFER_FREE_TRANSFER)
+		libusb_free_transfer(transfer);
+	libusb_unref_device(dev_handle->dev);
+	return r;
+}
+
+/* Similar to usbi_handle_transfer_completion() but exclusively for transfers
+ * that were asynchronously cancelled. The same concerns w.r.t. freeing of
+ * transfers exist here.
+ * Do not call this function with the usbi_transfer lock held. User-specified
+ * callback functions may attempt to directly resubmit the transfer, which
+ * will attempt to take the lock. */
+int usbi_handle_transfer_cancellation(struct usbi_transfer *transfer)
+{
+	struct libusb_context *ctx = ITRANSFER_CTX(transfer);
+	uint8_t timed_out;
+
+	usbi_mutex_lock(&ctx->flying_transfers_lock);
+	timed_out = transfer->timeout_flags & USBI_TRANSFER_TIMED_OUT;
+	usbi_mutex_unlock(&ctx->flying_transfers_lock);
+
+	/* if the URB was cancelled due to timeout, report timeout to the user */
+	if (timed_out) {
+		usbi_dbg("detected timeout cancellation");
+		return usbi_handle_transfer_completion(transfer, LIBUSB_TRANSFER_TIMED_OUT);
+	}
+
+	/* otherwise its a normal async cancel */
+	return usbi_handle_transfer_completion(transfer, LIBUSB_TRANSFER_CANCELLED);
+}
+
+/* Add a completed transfer to the completed_transfers list of the
+ * context and signal the event. The backend's handle_transfer_completion()
+ * function will be called the next time an event handler runs. */
+void usbi_signal_transfer_completion(struct usbi_transfer *transfer)
+{
+	struct libusb_context *ctx = ITRANSFER_CTX(transfer);
+	int pending_events;
+
+	usbi_mutex_lock(&ctx->event_data_lock);
+	pending_events = usbi_pending_events(ctx);
+	list_add_tail(&transfer->completed_list, &ctx->completed_transfers);
+	if (!pending_events)
+		usbi_signal_event(ctx);
+	usbi_mutex_unlock(&ctx->event_data_lock);
+}
+
+/** \ingroup libusb_poll
+ * Attempt to acquire the event handling lock. This lock is used to ensure that
+ * only one thread is monitoring libusb event sources at any one time.
+ *
+ * You only need to use this lock if you are developing an application
+ * which calls poll() or select() on libusb's file descriptors directly.
+ * If you stick to libusb's event handling loop functions (e.g.
+ * libusb_handle_events()) then you do not need to be concerned with this
+ * locking.
+ *
+ * While holding this lock, you are trusted to actually be handling events.
+ * If you are no longer handling events, you must call libusb_unlock_events()
+ * as soon as possible.
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \returns 0 if the lock was obtained successfully
+ * \returns 1 if the lock was not obtained (i.e. another thread holds the lock)
+ * \ref libusb_mtasync
+ */
+int API_EXPORTED libusb_try_lock_events(libusb_context *ctx)
+{
+	int r;
+	unsigned int ru;
+	USBI_GET_CONTEXT(ctx);
+
+	/* is someone else waiting to close a device? if so, don't let this thread
+	 * start event handling */
+	usbi_mutex_lock(&ctx->event_data_lock);
+	ru = ctx->device_close;
+	usbi_mutex_unlock(&ctx->event_data_lock);
+	if (ru) {
+		usbi_dbg("someone else is closing a device");
+		return 1;
+	}
+
+	r = usbi_mutex_trylock(&ctx->events_lock);
+	if (r)
+		return 1;
+
+	ctx->event_handler_active = 1;
+	return 0;
+}
+
+/** \ingroup libusb_poll
+ * Acquire the event handling lock, blocking until successful acquisition if
+ * it is contended. This lock is used to ensure that only one thread is
+ * monitoring libusb event sources at any one time.
+ *
+ * You only need to use this lock if you are developing an application
+ * which calls poll() or select() on libusb's file descriptors directly.
+ * If you stick to libusb's event handling loop functions (e.g.
+ * libusb_handle_events()) then you do not need to be concerned with this
+ * locking.
+ *
+ * While holding this lock, you are trusted to actually be handling events.
+ * If you are no longer handling events, you must call libusb_unlock_events()
+ * as soon as possible.
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \ref libusb_mtasync
+ */
+void API_EXPORTED libusb_lock_events(libusb_context *ctx)
+{
+	USBI_GET_CONTEXT(ctx);
+	usbi_mutex_lock(&ctx->events_lock);
+	ctx->event_handler_active = 1;
+}
+
+/** \ingroup libusb_poll
+ * Release the lock previously acquired with libusb_try_lock_events() or
+ * libusb_lock_events(). Releasing this lock will wake up any threads blocked
+ * on libusb_wait_for_event().
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \ref libusb_mtasync
+ */
+void API_EXPORTED libusb_unlock_events(libusb_context *ctx)
+{
+	USBI_GET_CONTEXT(ctx);
+	ctx->event_handler_active = 0;
+	usbi_mutex_unlock(&ctx->events_lock);
+
+	/* FIXME: perhaps we should be a bit more efficient by not broadcasting
+	 * the availability of the events lock when we are modifying pollfds
+	 * (check ctx->device_close)? */
+	usbi_mutex_lock(&ctx->event_waiters_lock);
+	usbi_cond_broadcast(&ctx->event_waiters_cond);
+	usbi_mutex_unlock(&ctx->event_waiters_lock);
+}
+
+/** \ingroup libusb_poll
+ * Determine if it is still OK for this thread to be doing event handling.
+ *
+ * Sometimes, libusb needs to temporarily pause all event handlers, and this
+ * is the function you should use before polling file descriptors to see if
+ * this is the case.
+ *
+ * If this function instructs your thread to give up the events lock, you
+ * should just continue the usual logic that is documented in \ref libusb_mtasync.
+ * On the next iteration, your thread will fail to obtain the events lock,
+ * and will hence become an event waiter.
+ *
+ * This function should be called while the events lock is held: you don't
+ * need to worry about the results of this function if your thread is not
+ * the current event handler.
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \returns 1 if event handling can start or continue
+ * \returns 0 if this thread must give up the events lock
+ * \ref fullstory "Multi-threaded I/O: the full story"
+ */
+int API_EXPORTED libusb_event_handling_ok(libusb_context *ctx)
+{
+	unsigned int r;
+	USBI_GET_CONTEXT(ctx);
+
+	/* is someone else waiting to close a device? if so, don't let this thread
+	 * continue event handling */
+	usbi_mutex_lock(&ctx->event_data_lock);
+	r = ctx->device_close;
+	usbi_mutex_unlock(&ctx->event_data_lock);
+	if (r) {
+		usbi_dbg("someone else is closing a device");
+		return 0;
+	}
+
+	return 1;
+}
+
+
+/** \ingroup libusb_poll
+ * Determine if an active thread is handling events (i.e. if anyone is holding
+ * the event handling lock).
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \returns 1 if a thread is handling events
+ * \returns 0 if there are no threads currently handling events
+ * \ref libusb_mtasync
+ */
+int API_EXPORTED libusb_event_handler_active(libusb_context *ctx)
+{
+	unsigned int r;
+	USBI_GET_CONTEXT(ctx);
+
+	/* is someone else waiting to close a device? if so, don't let this thread
+	 * start event handling -- indicate that event handling is happening */
+	usbi_mutex_lock(&ctx->event_data_lock);
+	r = ctx->device_close;
+	usbi_mutex_unlock(&ctx->event_data_lock);
+	if (r) {
+		usbi_dbg("someone else is closing a device");
+		return 1;
+	}
+
+	return ctx->event_handler_active;
+}
+
+/** \ingroup libusb_poll
+ * Interrupt any active thread that is handling events. This is mainly useful
+ * for interrupting a dedicated event handling thread when an application
+ * wishes to call libusb_exit().
+ *
+ * Since version 1.0.21, \ref LIBUSB_API_VERSION >= 0x01000105
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \ref libusb_mtasync
+ */
+void API_EXPORTED libusb_interrupt_event_handler(libusb_context *ctx)
+{
+	int pending_events;
+	USBI_GET_CONTEXT(ctx);
+
+	usbi_dbg("");
+	usbi_mutex_lock(&ctx->event_data_lock);
+
+	pending_events = usbi_pending_events(ctx);
+	ctx->event_flags |= USBI_EVENT_USER_INTERRUPT;
+	if (!pending_events)
+		usbi_signal_event(ctx);
+
+	usbi_mutex_unlock(&ctx->event_data_lock);
+}
+
+/** \ingroup libusb_poll
+ * Acquire the event waiters lock. This lock is designed to be obtained under
+ * the situation where you want to be aware when events are completed, but
+ * some other thread is event handling so calling libusb_handle_events() is not
+ * allowed.
+ *
+ * You then obtain this lock, re-check that another thread is still handling
+ * events, then call libusb_wait_for_event().
+ *
+ * You only need to use this lock if you are developing an application
+ * which calls poll() or select() on libusb's file descriptors directly,
+ * <b>and</b> may potentially be handling events from 2 threads simultaenously.
+ * If you stick to libusb's event handling loop functions (e.g.
+ * libusb_handle_events()) then you do not need to be concerned with this
+ * locking.
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \ref libusb_mtasync
+ */
+void API_EXPORTED libusb_lock_event_waiters(libusb_context *ctx)
+{
+	USBI_GET_CONTEXT(ctx);
+	usbi_mutex_lock(&ctx->event_waiters_lock);
+}
+
+/** \ingroup libusb_poll
+ * Release the event waiters lock.
+ * \param ctx the context to operate on, or NULL for the default context
+ * \ref libusb_mtasync
+ */
+void API_EXPORTED libusb_unlock_event_waiters(libusb_context *ctx)
+{
+	USBI_GET_CONTEXT(ctx);
+	usbi_mutex_unlock(&ctx->event_waiters_lock);
+}
+
+/** \ingroup libusb_poll
+ * Wait for another thread to signal completion of an event. Must be called
+ * with the event waiters lock held, see libusb_lock_event_waiters().
+ *
+ * This function will block until any of the following conditions are met:
+ * -# The timeout expires
+ * -# A transfer completes
+ * -# A thread releases the event handling lock through libusb_unlock_events()
+ *
+ * Condition 1 is obvious. Condition 2 unblocks your thread <em>after</em>
+ * the callback for the transfer has completed. Condition 3 is important
+ * because it means that the thread that was previously handling events is no
+ * longer doing so, so if any events are to complete, another thread needs to
+ * step up and start event handling.
+ *
+ * This function releases the event waiters lock before putting your thread
+ * to sleep, and reacquires the lock as it is being woken up.
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \param tv maximum timeout for this blocking function. A NULL value
+ * indicates unlimited timeout.
+ * \returns 0 after a transfer completes or another thread stops event handling
+ * \returns 1 if the timeout expired
+ * \ref libusb_mtasync
+ */
+int API_EXPORTED libusb_wait_for_event(libusb_context *ctx, struct timeval *tv)
+{
+	int r;
+
+	USBI_GET_CONTEXT(ctx);
+	if (tv == NULL) {
+		usbi_cond_wait(&ctx->event_waiters_cond, &ctx->event_waiters_lock);
+		return 0;
+	}
+
+	r = usbi_cond_timedwait(&ctx->event_waiters_cond,
+		&ctx->event_waiters_lock, tv);
+
+	if (r < 0)
+		return r;
+	else
+		return (r == ETIMEDOUT);
+}
+
+static void handle_timeout(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer =
+		USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	int r;
+
+	itransfer->timeout_flags |= USBI_TRANSFER_TIMEOUT_HANDLED;
+	r = libusb_cancel_transfer(transfer);
+	if (r == LIBUSB_SUCCESS)
+		itransfer->timeout_flags |= USBI_TRANSFER_TIMED_OUT;
+	else
+		usbi_warn(TRANSFER_CTX(transfer),
+			"async cancel failed %d errno=%d", r, errno);
+}
+
+static int handle_timeouts_locked(struct libusb_context *ctx)
+{
+	int r;
+	struct timespec systime_ts;
+	struct timeval systime;
+	struct usbi_transfer *transfer;
+
+	if (list_empty(&ctx->flying_transfers))
+		return 0;
+
+	/* get current time */
+	r = usbi_backend.clock_gettime(USBI_CLOCK_MONOTONIC, &systime_ts);
+	if (r < 0)
+		return r;
+
+	TIMESPEC_TO_TIMEVAL(&systime, &systime_ts);
+
+	/* iterate through flying transfers list, finding all transfers that
+	 * have expired timeouts */
+	list_for_each_entry(transfer, &ctx->flying_transfers, list, struct usbi_transfer) {
+		struct timeval *cur_tv = &transfer->timeout;
+
+		/* if we've reached transfers of infinite timeout, we're all done */
+		if (!timerisset(cur_tv))
+			return 0;
+
+		/* ignore timeouts we've already handled */
+		if (transfer->timeout_flags & (USBI_TRANSFER_TIMEOUT_HANDLED | USBI_TRANSFER_OS_HANDLES_TIMEOUT))
+			continue;
+
+		/* if transfer has non-expired timeout, nothing more to do */
+		if ((cur_tv->tv_sec > systime.tv_sec) ||
+				(cur_tv->tv_sec == systime.tv_sec &&
+					cur_tv->tv_usec > systime.tv_usec))
+			return 0;
+
+		/* otherwise, we've got an expired timeout to handle */
+		handle_timeout(transfer);
+	}
+	return 0;
+}
+
+static int handle_timeouts(struct libusb_context *ctx)
+{
+	int r;
+	USBI_GET_CONTEXT(ctx);
+	usbi_mutex_lock(&ctx->flying_transfers_lock);
+	r = handle_timeouts_locked(ctx);
+	usbi_mutex_unlock(&ctx->flying_transfers_lock);
+	return r;
+}
+
+#ifdef USBI_TIMERFD_AVAILABLE
+static int handle_timerfd_trigger(struct libusb_context *ctx)
+{
+	int r;
+
+	usbi_mutex_lock(&ctx->flying_transfers_lock);
+
+	/* process the timeout that just happened */
+	r = handle_timeouts_locked(ctx);
+	if (r < 0)
+		goto out;
+
+	/* arm for next timeout*/
+	r = arm_timerfd_for_next_timeout(ctx);
+
+out:
+	usbi_mutex_unlock(&ctx->flying_transfers_lock);
+	return r;
+}
+#endif
+
+/* do the actual event handling. assumes that no other thread is concurrently
+ * doing the same thing. */
+static int handle_events(struct libusb_context *ctx, struct timeval *tv)
+{
+	int r;
+	struct usbi_pollfd *ipollfd;
+	POLL_NFDS_TYPE nfds = 0;
+	POLL_NFDS_TYPE internal_nfds;
+	struct pollfd *fds = NULL;
+	int i = -1;
+	int timeout_ms;
+
+	/* prevent attempts to recursively handle events (e.g. calling into
+	 * libusb_handle_events() from within a hotplug or transfer callback) */
+	if (usbi_handling_events(ctx))
+		return LIBUSB_ERROR_BUSY;
+	usbi_start_event_handling(ctx);
+
+	/* there are certain fds that libusb uses internally, currently:
+	 *
+	 *   1) event pipe
+	 *   2) timerfd
+	 *
+	 * the backend will never need to attempt to handle events on these fds, so
+	 * we determine how many fds are in use internally for this context and when
+	 * handle_events() is called in the backend, the pollfd list and count will
+	 * be adjusted to skip over these internal fds */
+	if (usbi_using_timerfd(ctx))
+		internal_nfds = 2;
+	else
+		internal_nfds = 1;
+
+	/* only reallocate the poll fds when the list of poll fds has been modified
+	 * since the last poll, otherwise reuse them to save the additional overhead */
+	usbi_mutex_lock(&ctx->event_data_lock);
+	if (ctx->event_flags & USBI_EVENT_POLLFDS_MODIFIED) {
+		usbi_dbg("poll fds modified, reallocating");
+
+		if (ctx->pollfds) {
+			free(ctx->pollfds);
+			ctx->pollfds = NULL;
+		}
+
+		/* sanity check - it is invalid for a context to have fewer than the
+		 * required internal fds (memory corruption?) */
+		assert(ctx->pollfds_cnt >= internal_nfds);
+
+		ctx->pollfds = calloc(ctx->pollfds_cnt, sizeof(*ctx->pollfds));
+		if (!ctx->pollfds) {
+			usbi_mutex_unlock(&ctx->event_data_lock);
+			r = LIBUSB_ERROR_NO_MEM;
+			goto done;
+		}
+
+		list_for_each_entry(ipollfd, &ctx->ipollfds, list, struct usbi_pollfd) {
+			struct libusb_pollfd *pollfd = &ipollfd->pollfd;
+			i++;
+			ctx->pollfds[i].fd = pollfd->fd;
+			ctx->pollfds[i].events = pollfd->events;
+		}
+
+		/* reset the flag now that we have the updated list */
+		ctx->event_flags &= ~USBI_EVENT_POLLFDS_MODIFIED;
+
+		/* if no further pending events, clear the event pipe so that we do
+		 * not immediately return from poll */
+		if (!usbi_pending_events(ctx))
+			usbi_clear_event(ctx);
+	}
+	fds = ctx->pollfds;
+	nfds = ctx->pollfds_cnt;
+	usbi_mutex_unlock(&ctx->event_data_lock);
+
+	timeout_ms = (int)(tv->tv_sec * 1000) + (tv->tv_usec / 1000);
+
+	/* round up to next millisecond */
+	if (tv->tv_usec % 1000)
+		timeout_ms++;
+
+	usbi_dbg("poll() %d fds with timeout in %dms", nfds, timeout_ms);
+	r = usbi_poll(fds, nfds, timeout_ms);
+	usbi_dbg("poll() returned %d", r);
+	if (r == 0) {
+		r = handle_timeouts(ctx);
+		goto done;
+	} else if (r == -1 && errno == EINTR) {
+		r = LIBUSB_ERROR_INTERRUPTED;
+		goto done;
+	} else if (r < 0) {
+		usbi_err(ctx, "poll failed %d err=%d", r, errno);
+		r = LIBUSB_ERROR_IO;
+		goto done;
+	}
+
+	/* fds[0] is always the event pipe */
+	if (fds[0].revents) {
+		struct list_head hotplug_msgs;
+		struct usbi_transfer *itransfer;
+		int hotplug_cb_deregistered = 0;
+		int ret = 0;
+
+		list_init(&hotplug_msgs);
+
+		usbi_dbg("caught a fish on the event pipe");
+
+		/* take the the event data lock while processing events */
+		usbi_mutex_lock(&ctx->event_data_lock);
+
+		/* check if someone added a new poll fd */
+		if (ctx->event_flags & USBI_EVENT_POLLFDS_MODIFIED)
+			usbi_dbg("someone updated the poll fds");
+
+		if (ctx->event_flags & USBI_EVENT_USER_INTERRUPT) {
+			usbi_dbg("someone purposely interrupted");
+			ctx->event_flags &= ~USBI_EVENT_USER_INTERRUPT;
+		}
+
+		if (ctx->event_flags & USBI_EVENT_HOTPLUG_CB_DEREGISTERED) {
+			usbi_dbg("someone unregistered a hotplug cb");
+			ctx->event_flags &= ~USBI_EVENT_HOTPLUG_CB_DEREGISTERED;
+			hotplug_cb_deregistered = 1;
+		}
+
+		/* check if someone is closing a device */
+		if (ctx->device_close)
+			usbi_dbg("someone is closing a device");
+
+		/* check for any pending hotplug messages */
+		if (!list_empty(&ctx->hotplug_msgs)) {
+			usbi_dbg("hotplug message received");
+			list_cut(&hotplug_msgs, &ctx->hotplug_msgs);
+		}
+
+		/* complete any pending transfers */
+		while (ret == 0 && !list_empty(&ctx->completed_transfers)) {
+			itransfer = list_first_entry(&ctx->completed_transfers, struct usbi_transfer, completed_list);
+			list_del(&itransfer->completed_list);
+			usbi_mutex_unlock(&ctx->event_data_lock);
+			ret = usbi_backend.handle_transfer_completion(itransfer);
+			if (ret)
+				usbi_err(ctx, "backend handle_transfer_completion failed with error %d", ret);
+			usbi_mutex_lock(&ctx->event_data_lock);
+		}
+
+		/* if no further pending events, clear the event pipe */
+		if (!usbi_pending_events(ctx))
+			usbi_clear_event(ctx);
+
+		usbi_mutex_unlock(&ctx->event_data_lock);
+
+		if (hotplug_cb_deregistered)
+			usbi_hotplug_deregister(ctx, 0);
+
+		/* process the hotplug messages, if any */
+		while (!list_empty(&hotplug_msgs)) {
+			struct libusb_hotplug_message *message =
+				list_first_entry(&hotplug_msgs, struct libusb_hotplug_message, list);
+
+			usbi_hotplug_match(ctx, message->device, message->event);
+
+			/* the device left, dereference the device */
+			if (LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT == message->event)
+				libusb_unref_device(message->device);
+
+			list_del(&message->list);
+			free(message);
+		}
+
+		if (ret) {
+			/* return error code */
+			r = ret;
+			goto done;
+		}
+
+		if (0 == --r)
+			goto done;
+	}
+
+#ifdef USBI_TIMERFD_AVAILABLE
+	/* on timerfd configurations, fds[1] is the timerfd */
+	if (usbi_using_timerfd(ctx) && fds[1].revents) {
+		/* timerfd indicates that a timeout has expired */
+		int ret;
+		usbi_dbg("timerfd triggered");
+
+		ret = handle_timerfd_trigger(ctx);
+		if (ret < 0) {
+			/* return error code */
+			r = ret;
+			goto done;
+		}
+
+		if (0 == --r)
+			goto done;
+	}
+#endif
+
+	r = usbi_backend.handle_events(ctx, fds + internal_nfds, nfds - internal_nfds, r);
+	if (r)
+		usbi_err(ctx, "backend handle_events failed with error %d", r);
+
+done:
+	usbi_end_event_handling(ctx);
+	return r;
+}
+
+/* returns the smallest of:
+ *  1. timeout of next URB
+ *  2. user-supplied timeout
+ * returns 1 if there is an already-expired timeout, otherwise returns 0
+ * and populates out
+ */
+static int get_next_timeout(libusb_context *ctx, struct timeval *tv,
+	struct timeval *out)
+{
+	struct timeval timeout;
+	int r = libusb_get_next_timeout(ctx, &timeout);
+	if (r) {
+		/* timeout already expired? */
+		if (!timerisset(&timeout))
+			return 1;
+
+		/* choose the smallest of next URB timeout or user specified timeout */
+		if (timercmp(&timeout, tv, <))
+			*out = timeout;
+		else
+			*out = *tv;
+	} else {
+		*out = *tv;
+	}
+	return 0;
+}
+
+/** \ingroup libusb_poll
+ * Handle any pending events.
+ *
+ * libusb determines "pending events" by checking if any timeouts have expired
+ * and by checking the set of file descriptors for activity.
+ *
+ * If a zero timeval is passed, this function will handle any already-pending
+ * events and then immediately return in non-blocking style.
+ *
+ * If a non-zero timeval is passed and no events are currently pending, this
+ * function will block waiting for events to handle up until the specified
+ * timeout. If an event arrives or a signal is raised, this function will
+ * return early.
+ *
+ * If the parameter completed is not NULL then <em>after obtaining the event
+ * handling lock</em> this function will return immediately if the integer
+ * pointed to is not 0. This allows for race free waiting for the completion
+ * of a specific transfer.
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \param tv the maximum time to block waiting for events, or an all zero
+ * timeval struct for non-blocking mode
+ * \param completed pointer to completion integer to check, or NULL
+ * \returns 0 on success, or a LIBUSB_ERROR code on failure
+ * \ref libusb_mtasync
+ */
+int API_EXPORTED libusb_handle_events_timeout_completed(libusb_context *ctx,
+	struct timeval *tv, int *completed)
+{
+	int r;
+	struct timeval poll_timeout;
+
+	USBI_GET_CONTEXT(ctx);
+	r = get_next_timeout(ctx, tv, &poll_timeout);
+	if (r) {
+		/* timeout already expired */
+		return handle_timeouts(ctx);
+	}
+
+retry:
+	if (libusb_try_lock_events(ctx) == 0) {
+		if (completed == NULL || !*completed) {
+			/* we obtained the event lock: do our own event handling */
+			usbi_dbg("doing our own event handling");
+			r = handle_events(ctx, &poll_timeout);
+		}
+		libusb_unlock_events(ctx);
+		return r;
+	}
+
+	/* another thread is doing event handling. wait for thread events that
+	 * notify event completion. */
+	libusb_lock_event_waiters(ctx);
+
+	if (completed && *completed)
+		goto already_done;
+
+	if (!libusb_event_handler_active(ctx)) {
+		/* we hit a race: whoever was event handling earlier finished in the
+		 * time it took us to reach this point. try the cycle again. */
+		libusb_unlock_event_waiters(ctx);
+		usbi_dbg("event handler was active but went away, retrying");
+		goto retry;
+	}
+
+	usbi_dbg("another thread is doing event handling");
+	r = libusb_wait_for_event(ctx, &poll_timeout);
+
+already_done:
+	libusb_unlock_event_waiters(ctx);
+
+	if (r < 0)
+		return r;
+	else if (r == 1)
+		return handle_timeouts(ctx);
+	else
+		return 0;
+}
+
+/** \ingroup libusb_poll
+ * Handle any pending events
+ *
+ * Like libusb_handle_events_timeout_completed(), but without the completed
+ * parameter, calling this function is equivalent to calling
+ * libusb_handle_events_timeout_completed() with a NULL completed parameter.
+ *
+ * This function is kept primarily for backwards compatibility.
+ * All new code should call libusb_handle_events_completed() or
+ * libusb_handle_events_timeout_completed() to avoid race conditions.
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \param tv the maximum time to block waiting for events, or an all zero
+ * timeval struct for non-blocking mode
+ * \returns 0 on success, or a LIBUSB_ERROR code on failure
+ */
+int API_EXPORTED libusb_handle_events_timeout(libusb_context *ctx,
+	struct timeval *tv)
+{
+	return libusb_handle_events_timeout_completed(ctx, tv, NULL);
+}
+
+/** \ingroup libusb_poll
+ * Handle any pending events in blocking mode. There is currently a timeout
+ * hardcoded at 60 seconds but we plan to make it unlimited in future. For
+ * finer control over whether this function is blocking or non-blocking, or
+ * for control over the timeout, use libusb_handle_events_timeout_completed()
+ * instead.
+ *
+ * This function is kept primarily for backwards compatibility.
+ * All new code should call libusb_handle_events_completed() or
+ * libusb_handle_events_timeout_completed() to avoid race conditions.
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \returns 0 on success, or a LIBUSB_ERROR code on failure
+ */
+int API_EXPORTED libusb_handle_events(libusb_context *ctx)
+{
+	struct timeval tv;
+	tv.tv_sec = 60;
+	tv.tv_usec = 0;
+	return libusb_handle_events_timeout_completed(ctx, &tv, NULL);
+}
+
+/** \ingroup libusb_poll
+ * Handle any pending events in blocking mode.
+ *
+ * Like libusb_handle_events(), with the addition of a completed parameter
+ * to allow for race free waiting for the completion of a specific transfer.
+ *
+ * See libusb_handle_events_timeout_completed() for details on the completed
+ * parameter.
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \param completed pointer to completion integer to check, or NULL
+ * \returns 0 on success, or a LIBUSB_ERROR code on failure
+ * \ref libusb_mtasync
+ */
+int API_EXPORTED libusb_handle_events_completed(libusb_context *ctx,
+	int *completed)
+{
+	struct timeval tv;
+	tv.tv_sec = 60;
+	tv.tv_usec = 0;
+	return libusb_handle_events_timeout_completed(ctx, &tv, completed);
+}
+
+/** \ingroup libusb_poll
+ * Handle any pending events by polling file descriptors, without checking if
+ * any other threads are already doing so. Must be called with the event lock
+ * held, see libusb_lock_events().
+ *
+ * This function is designed to be called under the situation where you have
+ * taken the event lock and are calling poll()/select() directly on libusb's
+ * file descriptors (as opposed to using libusb_handle_events() or similar).
+ * You detect events on libusb's descriptors, so you then call this function
+ * with a zero timeout value (while still holding the event lock).
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \param tv the maximum time to block waiting for events, or zero for
+ * non-blocking mode
+ * \returns 0 on success, or a LIBUSB_ERROR code on failure
+ * \ref libusb_mtasync
+ */
+int API_EXPORTED libusb_handle_events_locked(libusb_context *ctx,
+	struct timeval *tv)
+{
+	int r;
+	struct timeval poll_timeout;
+
+	USBI_GET_CONTEXT(ctx);
+	r = get_next_timeout(ctx, tv, &poll_timeout);
+	if (r) {
+		/* timeout already expired */
+		return handle_timeouts(ctx);
+	}
+
+	return handle_events(ctx, &poll_timeout);
+}
+
+/** \ingroup libusb_poll
+ * Determines whether your application must apply special timing considerations
+ * when monitoring libusb's file descriptors.
+ *
+ * This function is only useful for applications which retrieve and poll
+ * libusb's file descriptors in their own main loop (\ref libusb_pollmain).
+ *
+ * Ordinarily, libusb's event handler needs to be called into at specific
+ * moments in time (in addition to times when there is activity on the file
+ * descriptor set). The usual approach is to use libusb_get_next_timeout()
+ * to learn about when the next timeout occurs, and to adjust your
+ * poll()/select() timeout accordingly so that you can make a call into the
+ * library at that time.
+ *
+ * Some platforms supported by libusb do not come with this baggage - any
+ * events relevant to timing will be represented by activity on the file
+ * descriptor set, and libusb_get_next_timeout() will always return 0.
+ * This function allows you to detect whether you are running on such a
+ * platform.
+ *
+ * Since v1.0.5.
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \returns 0 if you must call into libusb at times determined by
+ * libusb_get_next_timeout(), or 1 if all timeout events are handled internally
+ * or through regular activity on the file descriptors.
+ * \ref libusb_pollmain "Polling libusb file descriptors for event handling"
+ */
+int API_EXPORTED libusb_pollfds_handle_timeouts(libusb_context *ctx)
+{
+#if defined(USBI_TIMERFD_AVAILABLE)
+	USBI_GET_CONTEXT(ctx);
+	return usbi_using_timerfd(ctx);
+#else
+	UNUSED(ctx);
+	return 0;
+#endif
+}
+
+/** \ingroup libusb_poll
+ * Determine the next internal timeout that libusb needs to handle. You only
+ * need to use this function if you are calling poll() or select() or similar
+ * on libusb's file descriptors yourself - you do not need to use it if you
+ * are calling libusb_handle_events() or a variant directly.
+ *
+ * You should call this function in your main loop in order to determine how
+ * long to wait for select() or poll() to return results. libusb needs to be
+ * called into at this timeout, so you should use it as an upper bound on
+ * your select() or poll() call.
+ *
+ * When the timeout has expired, call into libusb_handle_events_timeout()
+ * (perhaps in non-blocking mode) so that libusb can handle the timeout.
+ *
+ * This function may return 1 (success) and an all-zero timeval. If this is
+ * the case, it indicates that libusb has a timeout that has already expired
+ * so you should call libusb_handle_events_timeout() or similar immediately.
+ * A return code of 0 indicates that there are no pending timeouts.
+ *
+ * On some platforms, this function will always returns 0 (no pending
+ * timeouts). See \ref polltime.
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \param tv output location for a relative time against the current
+ * clock in which libusb must be called into in order to process timeout events
+ * \returns 0 if there are no pending timeouts, 1 if a timeout was returned,
+ * or LIBUSB_ERROR_OTHER on failure
+ */
+int API_EXPORTED libusb_get_next_timeout(libusb_context *ctx,
+	struct timeval *tv)
+{
+	struct usbi_transfer *transfer;
+	struct timespec cur_ts;
+	struct timeval cur_tv;
+	struct timeval next_timeout = { 0, 0 };
+	int r;
+
+	USBI_GET_CONTEXT(ctx);
+	if (usbi_using_timerfd(ctx))
+		return 0;
+
+	usbi_mutex_lock(&ctx->flying_transfers_lock);
+	if (list_empty(&ctx->flying_transfers)) {
+		usbi_mutex_unlock(&ctx->flying_transfers_lock);
+		usbi_dbg("no URBs, no timeout!");
+		return 0;
+	}
+
+	/* find next transfer which hasn't already been processed as timed out */
+	list_for_each_entry(transfer, &ctx->flying_transfers, list, struct usbi_transfer) {
+		if (transfer->timeout_flags & (USBI_TRANSFER_TIMEOUT_HANDLED | USBI_TRANSFER_OS_HANDLES_TIMEOUT))
+			continue;
+
+		/* if we've reached transfers of infinte timeout, we're done looking */
+		if (!timerisset(&transfer->timeout))
+			break;
+
+		next_timeout = transfer->timeout;
+		break;
+	}
+	usbi_mutex_unlock(&ctx->flying_transfers_lock);
+
+	if (!timerisset(&next_timeout)) {
+		usbi_dbg("no URB with timeout or all handled by OS; no timeout!");
+		return 0;
+	}
+
+	r = usbi_backend.clock_gettime(USBI_CLOCK_MONOTONIC, &cur_ts);
+	if (r < 0) {
+		usbi_err(ctx, "failed to read monotonic clock, errno=%d", errno);
+		return 0;
+	}
+	TIMESPEC_TO_TIMEVAL(&cur_tv, &cur_ts);
+
+	if (!timercmp(&cur_tv, &next_timeout, <)) {
+		usbi_dbg("first timeout already expired");
+		timerclear(tv);
+	} else {
+		timersub(&next_timeout, &cur_tv, tv);
+		usbi_dbg("next timeout in %d.%06ds", tv->tv_sec, tv->tv_usec);
+	}
+
+	return 1;
+}
+
+/** \ingroup libusb_poll
+ * Register notification functions for file descriptor additions/removals.
+ * These functions will be invoked for every new or removed file descriptor
+ * that libusb uses as an event source.
+ *
+ * To remove notifiers, pass NULL values for the function pointers.
+ *
+ * Note that file descriptors may have been added even before you register
+ * these notifiers (e.g. at libusb_init() time).
+ *
+ * Additionally, note that the removal notifier may be called during
+ * libusb_exit() (e.g. when it is closing file descriptors that were opened
+ * and added to the poll set at libusb_init() time). If you don't want this,
+ * remove the notifiers immediately before calling libusb_exit().
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \param added_cb pointer to function for addition notifications
+ * \param removed_cb pointer to function for removal notifications
+ * \param user_data User data to be passed back to callbacks (useful for
+ * passing context information)
+ */
+void API_EXPORTED libusb_set_pollfd_notifiers(libusb_context *ctx,
+	libusb_pollfd_added_cb added_cb, libusb_pollfd_removed_cb removed_cb,
+	void *user_data)
+{
+	USBI_GET_CONTEXT(ctx);
+	ctx->fd_added_cb = added_cb;
+	ctx->fd_removed_cb = removed_cb;
+	ctx->fd_cb_user_data = user_data;
+}
+
+/*
+ * Interrupt the iteration of the event handling thread, so that it picks
+ * up the fd change. Callers of this function must hold the event_data_lock.
+ */
+static void usbi_fd_notification(struct libusb_context *ctx)
+{
+	int pending_events;
+
+	/* Record that there is a new poll fd.
+	 * Only signal an event if there are no prior pending events. */
+	pending_events = usbi_pending_events(ctx);
+	ctx->event_flags |= USBI_EVENT_POLLFDS_MODIFIED;
+	if (!pending_events)
+		usbi_signal_event(ctx);
+}
+
+/* Add a file descriptor to the list of file descriptors to be monitored.
+ * events should be specified as a bitmask of events passed to poll(), e.g.
+ * POLLIN and/or POLLOUT. */
+int usbi_add_pollfd(struct libusb_context *ctx, int fd, short events)
+{
+	struct usbi_pollfd *ipollfd = malloc(sizeof(*ipollfd));
+	if (!ipollfd)
+		return LIBUSB_ERROR_NO_MEM;
+
+	usbi_dbg("add fd %d events %d", fd, events);
+	ipollfd->pollfd.fd = fd;
+	ipollfd->pollfd.events = events;
+	usbi_mutex_lock(&ctx->event_data_lock);
+	list_add_tail(&ipollfd->list, &ctx->ipollfds);
+	ctx->pollfds_cnt++;
+	usbi_fd_notification(ctx);
+	usbi_mutex_unlock(&ctx->event_data_lock);
+
+	if (ctx->fd_added_cb)
+		ctx->fd_added_cb(fd, events, ctx->fd_cb_user_data);
+	return 0;
+}
+
+/* Remove a file descriptor from the list of file descriptors to be polled. */
+void usbi_remove_pollfd(struct libusb_context *ctx, int fd)
+{
+	struct usbi_pollfd *ipollfd;
+	int found = 0;
+
+	usbi_dbg("remove fd %d", fd);
+	usbi_mutex_lock(&ctx->event_data_lock);
+	list_for_each_entry(ipollfd, &ctx->ipollfds, list, struct usbi_pollfd)
+		if (ipollfd->pollfd.fd == fd) {
+			found = 1;
+			break;
+		}
+
+	if (!found) {
+		usbi_dbg("couldn't find fd %d to remove", fd);
+		usbi_mutex_unlock(&ctx->event_data_lock);
+		return;
+	}
+
+	list_del(&ipollfd->list);
+	ctx->pollfds_cnt--;
+	usbi_fd_notification(ctx);
+	usbi_mutex_unlock(&ctx->event_data_lock);
+	free(ipollfd);
+	if (ctx->fd_removed_cb)
+		ctx->fd_removed_cb(fd, ctx->fd_cb_user_data);
+}
+
+/** \ingroup libusb_poll
+ * Retrieve a list of file descriptors that should be polled by your main loop
+ * as libusb event sources.
+ *
+ * The returned list is NULL-terminated and should be freed with libusb_free_pollfds()
+ * when done. The actual list contents must not be touched.
+ *
+ * As file descriptors are a Unix-specific concept, this function is not
+ * available on Windows and will always return NULL.
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \returns a NULL-terminated list of libusb_pollfd structures
+ * \returns NULL on error
+ * \returns NULL on platforms where the functionality is not available
+ */
+DEFAULT_VISIBILITY
+const struct libusb_pollfd ** LIBUSB_CALL libusb_get_pollfds(
+	libusb_context *ctx)
+{
+#ifndef OS_WINDOWS
+	struct libusb_pollfd **ret = NULL;
+	struct usbi_pollfd *ipollfd;
+	size_t i = 0;
+	USBI_GET_CONTEXT(ctx);
+
+	usbi_mutex_lock(&ctx->event_data_lock);
+
+	ret = calloc(ctx->pollfds_cnt + 1, sizeof(struct libusb_pollfd *));
+	if (!ret)
+		goto out;
+
+	list_for_each_entry(ipollfd, &ctx->ipollfds, list, struct usbi_pollfd)
+		ret[i++] = (struct libusb_pollfd *) ipollfd;
+	ret[ctx->pollfds_cnt] = NULL;
+
+out:
+	usbi_mutex_unlock(&ctx->event_data_lock);
+	return (const struct libusb_pollfd **) ret;
+#else
+	usbi_err(ctx, "external polling of libusb's internal descriptors "\
+		"is not yet supported on Windows platforms");
+	return NULL;
+#endif
+}
+
+/** \ingroup libusb_poll
+ * Free a list of libusb_pollfd structures. This should be called for all
+ * pollfd lists allocated with libusb_get_pollfds().
+ *
+ * Since version 1.0.20, \ref LIBUSB_API_VERSION >= 0x01000104
+ *
+ * It is legal to call this function with a NULL pollfd list. In this case,
+ * the function will simply return safely.
+ *
+ * \param pollfds the list of libusb_pollfd structures to free
+ */
+void API_EXPORTED libusb_free_pollfds(const struct libusb_pollfd **pollfds)
+{
+	if (!pollfds)
+		return;
+
+	free((void *)pollfds);
+}
+
+/* Backends may call this from handle_events to report disconnection of a
+ * device. This function ensures transfers get cancelled appropriately.
+ * Callers of this function must hold the events_lock.
+ */
+void usbi_handle_disconnect(struct libusb_device_handle *dev_handle)
+{
+	struct usbi_transfer *cur;
+	struct usbi_transfer *to_cancel;
+
+	usbi_dbg("device %d.%d",
+		dev_handle->dev->bus_number, dev_handle->dev->device_address);
+
+	/* terminate all pending transfers with the LIBUSB_TRANSFER_NO_DEVICE
+	 * status code.
+	 *
+	 * when we find a transfer for this device on the list, there are two
+	 * possible scenarios:
+	 * 1. the transfer is currently in-flight, in which case we terminate the
+	 *    transfer here
+	 * 2. the transfer has been added to the flying transfer list by
+	 *    libusb_submit_transfer, has failed to submit and
+	 *    libusb_submit_transfer is waiting for us to release the
+	 *    flying_transfers_lock to remove it, so we ignore it
+	 */
+
+	while (1) {
+		to_cancel = NULL;
+		usbi_mutex_lock(&HANDLE_CTX(dev_handle)->flying_transfers_lock);
+		list_for_each_entry(cur, &HANDLE_CTX(dev_handle)->flying_transfers, list, struct usbi_transfer)
+			if (USBI_TRANSFER_TO_LIBUSB_TRANSFER(cur)->dev_handle == dev_handle) {
+				usbi_mutex_lock(&cur->lock);
+				if (cur->state_flags & USBI_TRANSFER_IN_FLIGHT)
+					to_cancel = cur;
+				usbi_mutex_unlock(&cur->lock);
+
+				if (to_cancel)
+					break;
+			}
+		usbi_mutex_unlock(&HANDLE_CTX(dev_handle)->flying_transfers_lock);
+
+		if (!to_cancel)
+			break;
+
+		usbi_dbg("cancelling transfer %p from disconnect",
+			 USBI_TRANSFER_TO_LIBUSB_TRANSFER(to_cancel));
+
+		usbi_mutex_lock(&to_cancel->lock);
+		usbi_backend.clear_transfer_priv(to_cancel);
+		usbi_mutex_unlock(&to_cancel->lock);
+		usbi_handle_transfer_completion(to_cancel, LIBUSB_TRANSFER_NO_DEVICE);
+	}
+
+}
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/libusb.h b/vendor/github.com/karalabe/usb/libusb/libusb/libusb.h
new file mode 100644
index 000000000..430136b2e
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/libusb.h
@@ -0,0 +1,2039 @@
+/*
+ * Public libusb header file
+ * Copyright © 2001 Johannes Erdfelt <johannes@erdfelt.com>
+ * Copyright © 2007-2008 Daniel Drake <dsd@gentoo.org>
+ * Copyright © 2012 Pete Batard <pete@akeo.ie>
+ * Copyright © 2012 Nathan Hjelm <hjelmn@cs.unm.edu>
+ * For more information, please visit: http://libusb.info
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef LIBUSB_H
+#define LIBUSB_H
+
+#ifdef _MSC_VER
+/* on MS environments, the inline keyword is available in C++ only */
+#if !defined(__cplusplus)
+#define inline __inline
+#endif
+/* ssize_t is also not available (copy/paste from MinGW) */
+#ifndef _SSIZE_T_DEFINED
+#define _SSIZE_T_DEFINED
+#undef ssize_t
+#ifdef _WIN64
+  typedef __int64 ssize_t;
+#else
+  typedef int ssize_t;
+#endif /* _WIN64 */
+#endif /* _SSIZE_T_DEFINED */
+#endif /* _MSC_VER */
+
+/* stdint.h is not available on older MSVC */
+#if defined(_MSC_VER) && (_MSC_VER < 1600) && (!defined(_STDINT)) && (!defined(_STDINT_H))
+typedef unsigned __int8   uint8_t;
+typedef unsigned __int16  uint16_t;
+typedef unsigned __int32  uint32_t;
+#else
+#include <stdint.h>
+#endif
+
+#if !defined(_WIN32_WCE)
+#include <sys/types.h>
+#endif
+
+#if defined(__linux__) || defined(__APPLE__) || defined(__CYGWIN__) || defined(__HAIKU__)
+#include <sys/time.h>
+#endif
+
+#include <time.h>
+#include <limits.h>
+
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
+#define ZERO_SIZED_ARRAY		/* [] - valid C99 code */
+#else
+#define ZERO_SIZED_ARRAY	0	/* [0] - non-standard, but usually working code */
+#endif
+
+/* 'interface' might be defined as a macro on Windows, so we need to
+ * undefine it so as not to break the current libusb API, because
+ * libusb_config_descriptor has an 'interface' member
+ * As this can be problematic if you include windows.h after libusb.h
+ * in your sources, we force windows.h to be included first. */
+#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
+#include <windows.h>
+#if defined(interface)
+#undef interface
+#endif
+#if !defined(__CYGWIN__)
+#include <winsock.h>
+#endif
+#endif
+
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
+#define LIBUSB_DEPRECATED_FOR(f) \
+  __attribute__((deprecated("Use " #f " instead")))
+#elif __GNUC__ >= 3
+#define LIBUSB_DEPRECATED_FOR(f) __attribute__((deprecated))
+#else
+#define LIBUSB_DEPRECATED_FOR(f)
+#endif /* __GNUC__ */
+
+/** \def LIBUSB_CALL
+ * \ingroup libusb_misc
+ * libusb's Windows calling convention.
+ *
+ * Under Windows, the selection of available compilers and configurations
+ * means that, unlike other platforms, there is not <em>one true calling
+ * convention</em> (calling convention: the manner in which parameters are
+ * passed to functions in the generated assembly code).
+ *
+ * Matching the Windows API itself, libusb uses the WINAPI convention (which
+ * translates to the <tt>stdcall</tt> convention) and guarantees that the
+ * library is compiled in this way. The public header file also includes
+ * appropriate annotations so that your own software will use the right
+ * convention, even if another convention is being used by default within
+ * your codebase.
+ *
+ * The one consideration that you must apply in your software is to mark
+ * all functions which you use as libusb callbacks with this LIBUSB_CALL
+ * annotation, so that they too get compiled for the correct calling
+ * convention.
+ *
+ * On non-Windows operating systems, this macro is defined as nothing. This
+ * means that you can apply it to your code without worrying about
+ * cross-platform compatibility.
+ */
+/* LIBUSB_CALL must be defined on both definition and declaration of libusb
+ * functions. You'd think that declaration would be enough, but cygwin will
+ * complain about conflicting types unless both are marked this way.
+ * The placement of this macro is important too; it must appear after the
+ * return type, before the function name. See internal documentation for
+ * API_EXPORTED.
+ */
+#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
+#define LIBUSB_CALL WINAPI
+#else
+#define LIBUSB_CALL
+#endif
+
+/** \def LIBUSB_API_VERSION
+ * \ingroup libusb_misc
+ * libusb's API version.
+ *
+ * Since version 1.0.13, to help with feature detection, libusb defines
+ * a LIBUSB_API_VERSION macro that gets increased every time there is a
+ * significant change to the API, such as the introduction of a new call,
+ * the definition of a new macro/enum member, or any other element that
+ * libusb applications may want to detect at compilation time.
+ *
+ * The macro is typically used in an application as follows:
+ * \code
+ * #if defined(LIBUSB_API_VERSION) && (LIBUSB_API_VERSION >= 0x01001234)
+ * // Use one of the newer features from the libusb API
+ * #endif
+ * \endcode
+ *
+ * Internally, LIBUSB_API_VERSION is defined as follows:
+ * (libusb major << 24) | (libusb minor << 16) | (16 bit incremental)
+ */
+#define LIBUSB_API_VERSION 0x01000106
+
+/* The following is kept for compatibility, but will be deprecated in the future */
+#define LIBUSBX_API_VERSION LIBUSB_API_VERSION
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * \ingroup libusb_misc
+ * Convert a 16-bit value from host-endian to little-endian format. On
+ * little endian systems, this function does nothing. On big endian systems,
+ * the bytes are swapped.
+ * \param x the host-endian value to convert
+ * \returns the value in little-endian byte order
+ */
+static inline uint16_t libusb_cpu_to_le16(const uint16_t x)
+{
+	union {
+		uint8_t  b8[2];
+		uint16_t b16;
+	} _tmp;
+	_tmp.b8[1] = (uint8_t) (x >> 8);
+	_tmp.b8[0] = (uint8_t) (x & 0xff);
+	return _tmp.b16;
+}
+
+/** \def libusb_le16_to_cpu
+ * \ingroup libusb_misc
+ * Convert a 16-bit value from little-endian to host-endian format. On
+ * little endian systems, this function does nothing. On big endian systems,
+ * the bytes are swapped.
+ * \param x the little-endian value to convert
+ * \returns the value in host-endian byte order
+ */
+#define libusb_le16_to_cpu libusb_cpu_to_le16
+
+/* standard USB stuff */
+
+/** \ingroup libusb_desc
+ * Device and/or Interface Class codes */
+enum libusb_class_code {
+	/** In the context of a \ref libusb_device_descriptor "device descriptor",
+	 * this bDeviceClass value indicates that each interface specifies its
+	 * own class information and all interfaces operate independently.
+	 */
+	LIBUSB_CLASS_PER_INTERFACE = 0,
+
+	/** Audio class */
+	LIBUSB_CLASS_AUDIO = 1,
+
+	/** Communications class */
+	LIBUSB_CLASS_COMM = 2,
+
+	/** Human Interface Device class */
+	LIBUSB_CLASS_HID = 3,
+
+	/** Physical */
+	LIBUSB_CLASS_PHYSICAL = 5,
+
+	/** Printer class */
+	LIBUSB_CLASS_PRINTER = 7,
+
+	/** Image class */
+	LIBUSB_CLASS_PTP = 6, /* legacy name from libusb-0.1 usb.h */
+	LIBUSB_CLASS_IMAGE = 6,
+
+	/** Mass storage class */
+	LIBUSB_CLASS_MASS_STORAGE = 8,
+
+	/** Hub class */
+	LIBUSB_CLASS_HUB = 9,
+
+	/** Data class */
+	LIBUSB_CLASS_DATA = 10,
+
+	/** Smart Card */
+	LIBUSB_CLASS_SMART_CARD = 0x0b,
+
+	/** Content Security */
+	LIBUSB_CLASS_CONTENT_SECURITY = 0x0d,
+
+	/** Video */
+	LIBUSB_CLASS_VIDEO = 0x0e,
+
+	/** Personal Healthcare */
+	LIBUSB_CLASS_PERSONAL_HEALTHCARE = 0x0f,
+
+	/** Diagnostic Device */
+	LIBUSB_CLASS_DIAGNOSTIC_DEVICE = 0xdc,
+
+	/** Wireless class */
+	LIBUSB_CLASS_WIRELESS = 0xe0,
+
+	/** Application class */
+	LIBUSB_CLASS_APPLICATION = 0xfe,
+
+	/** Class is vendor-specific */
+	LIBUSB_CLASS_VENDOR_SPEC = 0xff
+};
+
+/** \ingroup libusb_desc
+ * Descriptor types as defined by the USB specification. */
+enum libusb_descriptor_type {
+	/** Device descriptor. See libusb_device_descriptor. */
+	LIBUSB_DT_DEVICE = 0x01,
+
+	/** Configuration descriptor. See libusb_config_descriptor. */
+	LIBUSB_DT_CONFIG = 0x02,
+
+	/** String descriptor */
+	LIBUSB_DT_STRING = 0x03,
+
+	/** Interface descriptor. See libusb_interface_descriptor. */
+	LIBUSB_DT_INTERFACE = 0x04,
+
+	/** Endpoint descriptor. See libusb_endpoint_descriptor. */
+	LIBUSB_DT_ENDPOINT = 0x05,
+
+	/** BOS descriptor */
+	LIBUSB_DT_BOS = 0x0f,
+
+	/** Device Capability descriptor */
+	LIBUSB_DT_DEVICE_CAPABILITY = 0x10,
+
+	/** HID descriptor */
+	LIBUSB_DT_HID = 0x21,
+
+	/** HID report descriptor */
+	LIBUSB_DT_REPORT = 0x22,
+
+	/** Physical descriptor */
+	LIBUSB_DT_PHYSICAL = 0x23,
+
+	/** Hub descriptor */
+	LIBUSB_DT_HUB = 0x29,
+
+	/** SuperSpeed Hub descriptor */
+	LIBUSB_DT_SUPERSPEED_HUB = 0x2a,
+
+	/** SuperSpeed Endpoint Companion descriptor */
+	LIBUSB_DT_SS_ENDPOINT_COMPANION = 0x30
+};
+
+/* Descriptor sizes per descriptor type */
+#define LIBUSB_DT_DEVICE_SIZE			18
+#define LIBUSB_DT_CONFIG_SIZE			9
+#define LIBUSB_DT_INTERFACE_SIZE		9
+#define LIBUSB_DT_ENDPOINT_SIZE			7
+#define LIBUSB_DT_ENDPOINT_AUDIO_SIZE		9	/* Audio extension */
+#define LIBUSB_DT_HUB_NONVAR_SIZE		7
+#define LIBUSB_DT_SS_ENDPOINT_COMPANION_SIZE	6
+#define LIBUSB_DT_BOS_SIZE			5
+#define LIBUSB_DT_DEVICE_CAPABILITY_SIZE	3
+
+/* BOS descriptor sizes */
+#define LIBUSB_BT_USB_2_0_EXTENSION_SIZE	7
+#define LIBUSB_BT_SS_USB_DEVICE_CAPABILITY_SIZE	10
+#define LIBUSB_BT_CONTAINER_ID_SIZE		20
+
+/* We unwrap the BOS => define its max size */
+#define LIBUSB_DT_BOS_MAX_SIZE		((LIBUSB_DT_BOS_SIZE)     +\
+					(LIBUSB_BT_USB_2_0_EXTENSION_SIZE)       +\
+					(LIBUSB_BT_SS_USB_DEVICE_CAPABILITY_SIZE) +\
+					(LIBUSB_BT_CONTAINER_ID_SIZE))
+
+#define LIBUSB_ENDPOINT_ADDRESS_MASK	0x0f    /* in bEndpointAddress */
+#define LIBUSB_ENDPOINT_DIR_MASK		0x80
+
+/** \ingroup libusb_desc
+ * Endpoint direction. Values for bit 7 of the
+ * \ref libusb_endpoint_descriptor::bEndpointAddress "endpoint address" scheme.
+ */
+enum libusb_endpoint_direction {
+	/** In: device-to-host */
+	LIBUSB_ENDPOINT_IN = 0x80,
+
+	/** Out: host-to-device */
+	LIBUSB_ENDPOINT_OUT = 0x00
+};
+
+#define LIBUSB_TRANSFER_TYPE_MASK			0x03    /* in bmAttributes */
+
+/** \ingroup libusb_desc
+ * Endpoint transfer type. Values for bits 0:1 of the
+ * \ref libusb_endpoint_descriptor::bmAttributes "endpoint attributes" field.
+ */
+enum libusb_transfer_type {
+	/** Control endpoint */
+	LIBUSB_TRANSFER_TYPE_CONTROL = 0,
+
+	/** Isochronous endpoint */
+	LIBUSB_TRANSFER_TYPE_ISOCHRONOUS = 1,
+
+	/** Bulk endpoint */
+	LIBUSB_TRANSFER_TYPE_BULK = 2,
+
+	/** Interrupt endpoint */
+	LIBUSB_TRANSFER_TYPE_INTERRUPT = 3,
+
+	/** Stream endpoint */
+	LIBUSB_TRANSFER_TYPE_BULK_STREAM = 4,
+};
+
+/** \ingroup libusb_misc
+ * Standard requests, as defined in table 9-5 of the USB 3.0 specifications */
+enum libusb_standard_request {
+	/** Request status of the specific recipient */
+	LIBUSB_REQUEST_GET_STATUS = 0x00,
+
+	/** Clear or disable a specific feature */
+	LIBUSB_REQUEST_CLEAR_FEATURE = 0x01,
+
+	/* 0x02 is reserved */
+
+	/** Set or enable a specific feature */
+	LIBUSB_REQUEST_SET_FEATURE = 0x03,
+
+	/* 0x04 is reserved */
+
+	/** Set device address for all future accesses */
+	LIBUSB_REQUEST_SET_ADDRESS = 0x05,
+
+	/** Get the specified descriptor */
+	LIBUSB_REQUEST_GET_DESCRIPTOR = 0x06,
+
+	/** Used to update existing descriptors or add new descriptors */
+	LIBUSB_REQUEST_SET_DESCRIPTOR = 0x07,
+
+	/** Get the current device configuration value */
+	LIBUSB_REQUEST_GET_CONFIGURATION = 0x08,
+
+	/** Set device configuration */
+	LIBUSB_REQUEST_SET_CONFIGURATION = 0x09,
+
+	/** Return the selected alternate setting for the specified interface */
+	LIBUSB_REQUEST_GET_INTERFACE = 0x0A,
+
+	/** Select an alternate interface for the specified interface */
+	LIBUSB_REQUEST_SET_INTERFACE = 0x0B,
+
+	/** Set then report an endpoint's synchronization frame */
+	LIBUSB_REQUEST_SYNCH_FRAME = 0x0C,
+
+	/** Sets both the U1 and U2 Exit Latency */
+	LIBUSB_REQUEST_SET_SEL = 0x30,
+
+	/** Delay from the time a host transmits a packet to the time it is
+	  * received by the device. */
+	LIBUSB_SET_ISOCH_DELAY = 0x31,
+};
+
+/** \ingroup libusb_misc
+ * Request type bits of the
+ * \ref libusb_control_setup::bmRequestType "bmRequestType" field in control
+ * transfers. */
+enum libusb_request_type {
+	/** Standard */
+	LIBUSB_REQUEST_TYPE_STANDARD = (0x00 << 5),
+
+	/** Class */
+	LIBUSB_REQUEST_TYPE_CLASS = (0x01 << 5),
+
+	/** Vendor */
+	LIBUSB_REQUEST_TYPE_VENDOR = (0x02 << 5),
+
+	/** Reserved */
+	LIBUSB_REQUEST_TYPE_RESERVED = (0x03 << 5)
+};
+
+/** \ingroup libusb_misc
+ * Recipient bits of the
+ * \ref libusb_control_setup::bmRequestType "bmRequestType" field in control
+ * transfers. Values 4 through 31 are reserved. */
+enum libusb_request_recipient {
+	/** Device */
+	LIBUSB_RECIPIENT_DEVICE = 0x00,
+
+	/** Interface */
+	LIBUSB_RECIPIENT_INTERFACE = 0x01,
+
+	/** Endpoint */
+	LIBUSB_RECIPIENT_ENDPOINT = 0x02,
+
+	/** Other */
+	LIBUSB_RECIPIENT_OTHER = 0x03,
+};
+
+#define LIBUSB_ISO_SYNC_TYPE_MASK		0x0C
+
+/** \ingroup libusb_desc
+ * Synchronization type for isochronous endpoints. Values for bits 2:3 of the
+ * \ref libusb_endpoint_descriptor::bmAttributes "bmAttributes" field in
+ * libusb_endpoint_descriptor.
+ */
+enum libusb_iso_sync_type {
+	/** No synchronization */
+	LIBUSB_ISO_SYNC_TYPE_NONE = 0,
+
+	/** Asynchronous */
+	LIBUSB_ISO_SYNC_TYPE_ASYNC = 1,
+
+	/** Adaptive */
+	LIBUSB_ISO_SYNC_TYPE_ADAPTIVE = 2,
+
+	/** Synchronous */
+	LIBUSB_ISO_SYNC_TYPE_SYNC = 3
+};
+
+#define LIBUSB_ISO_USAGE_TYPE_MASK 0x30
+
+/** \ingroup libusb_desc
+ * Usage type for isochronous endpoints. Values for bits 4:5 of the
+ * \ref libusb_endpoint_descriptor::bmAttributes "bmAttributes" field in
+ * libusb_endpoint_descriptor.
+ */
+enum libusb_iso_usage_type {
+	/** Data endpoint */
+	LIBUSB_ISO_USAGE_TYPE_DATA = 0,
+
+	/** Feedback endpoint */
+	LIBUSB_ISO_USAGE_TYPE_FEEDBACK = 1,
+
+	/** Implicit feedback Data endpoint */
+	LIBUSB_ISO_USAGE_TYPE_IMPLICIT = 2,
+};
+
+/** \ingroup libusb_desc
+ * A structure representing the standard USB device descriptor. This
+ * descriptor is documented in section 9.6.1 of the USB 3.0 specification.
+ * All multiple-byte fields are represented in host-endian format.
+ */
+struct libusb_device_descriptor {
+	/** Size of this descriptor (in bytes) */
+	uint8_t  bLength;
+
+	/** Descriptor type. Will have value
+	 * \ref libusb_descriptor_type::LIBUSB_DT_DEVICE LIBUSB_DT_DEVICE in this
+	 * context. */
+	uint8_t  bDescriptorType;
+
+	/** USB specification release number in binary-coded decimal. A value of
+	 * 0x0200 indicates USB 2.0, 0x0110 indicates USB 1.1, etc. */
+	uint16_t bcdUSB;
+
+	/** USB-IF class code for the device. See \ref libusb_class_code. */
+	uint8_t  bDeviceClass;
+
+	/** USB-IF subclass code for the device, qualified by the bDeviceClass
+	 * value */
+	uint8_t  bDeviceSubClass;
+
+	/** USB-IF protocol code for the device, qualified by the bDeviceClass and
+	 * bDeviceSubClass values */
+	uint8_t  bDeviceProtocol;
+
+	/** Maximum packet size for endpoint 0 */
+	uint8_t  bMaxPacketSize0;
+
+	/** USB-IF vendor ID */
+	uint16_t idVendor;
+
+	/** USB-IF product ID */
+	uint16_t idProduct;
+
+	/** Device release number in binary-coded decimal */
+	uint16_t bcdDevice;
+
+	/** Index of string descriptor describing manufacturer */
+	uint8_t  iManufacturer;
+
+	/** Index of string descriptor describing product */
+	uint8_t  iProduct;
+
+	/** Index of string descriptor containing device serial number */
+	uint8_t  iSerialNumber;
+
+	/** Number of possible configurations */
+	uint8_t  bNumConfigurations;
+};
+
+/** \ingroup libusb_desc
+ * A structure representing the standard USB endpoint descriptor. This
+ * descriptor is documented in section 9.6.6 of the USB 3.0 specification.
+ * All multiple-byte fields are represented in host-endian format.
+ */
+struct libusb_endpoint_descriptor {
+	/** Size of this descriptor (in bytes) */
+	uint8_t  bLength;
+
+	/** Descriptor type. Will have value
+	 * \ref libusb_descriptor_type::LIBUSB_DT_ENDPOINT LIBUSB_DT_ENDPOINT in
+	 * this context. */
+	uint8_t  bDescriptorType;
+
+	/** The address of the endpoint described by this descriptor. Bits 0:3 are
+	 * the endpoint number. Bits 4:6 are reserved. Bit 7 indicates direction,
+	 * see \ref libusb_endpoint_direction.
+	 */
+	uint8_t  bEndpointAddress;
+
+	/** Attributes which apply to the endpoint when it is configured using
+	 * the bConfigurationValue. Bits 0:1 determine the transfer type and
+	 * correspond to \ref libusb_transfer_type. Bits 2:3 are only used for
+	 * isochronous endpoints and correspond to \ref libusb_iso_sync_type.
+	 * Bits 4:5 are also only used for isochronous endpoints and correspond to
+	 * \ref libusb_iso_usage_type. Bits 6:7 are reserved.
+	 */
+	uint8_t  bmAttributes;
+
+	/** Maximum packet size this endpoint is capable of sending/receiving. */
+	uint16_t wMaxPacketSize;
+
+	/** Interval for polling endpoint for data transfers. */
+	uint8_t  bInterval;
+
+	/** For audio devices only: the rate at which synchronization feedback
+	 * is provided. */
+	uint8_t  bRefresh;
+
+	/** For audio devices only: the address if the synch endpoint */
+	uint8_t  bSynchAddress;
+
+	/** Extra descriptors. If libusb encounters unknown endpoint descriptors,
+	 * it will store them here, should you wish to parse them. */
+	const unsigned char *extra;
+
+	/** Length of the extra descriptors, in bytes. */
+	int extra_length;
+};
+
+/** \ingroup libusb_desc
+ * A structure representing the standard USB interface descriptor. This
+ * descriptor is documented in section 9.6.5 of the USB 3.0 specification.
+ * All multiple-byte fields are represented in host-endian format.
+ */
+struct libusb_interface_descriptor {
+	/** Size of this descriptor (in bytes) */
+	uint8_t  bLength;
+
+	/** Descriptor type. Will have value
+	 * \ref libusb_descriptor_type::LIBUSB_DT_INTERFACE LIBUSB_DT_INTERFACE
+	 * in this context. */
+	uint8_t  bDescriptorType;
+
+	/** Number of this interface */
+	uint8_t  bInterfaceNumber;
+
+	/** Value used to select this alternate setting for this interface */
+	uint8_t  bAlternateSetting;
+
+	/** Number of endpoints used by this interface (excluding the control
+	 * endpoint). */
+	uint8_t  bNumEndpoints;
+
+	/** USB-IF class code for this interface. See \ref libusb_class_code. */
+	uint8_t  bInterfaceClass;
+
+	/** USB-IF subclass code for this interface, qualified by the
+	 * bInterfaceClass value */
+	uint8_t  bInterfaceSubClass;
+
+	/** USB-IF protocol code for this interface, qualified by the
+	 * bInterfaceClass and bInterfaceSubClass values */
+	uint8_t  bInterfaceProtocol;
+
+	/** Index of string descriptor describing this interface */
+	uint8_t  iInterface;
+
+	/** Array of endpoint descriptors. This length of this array is determined
+	 * by the bNumEndpoints field. */
+	const struct libusb_endpoint_descriptor *endpoint;
+
+	/** Extra descriptors. If libusb encounters unknown interface descriptors,
+	 * it will store them here, should you wish to parse them. */
+	const unsigned char *extra;
+
+	/** Length of the extra descriptors, in bytes. */
+	int extra_length;
+};
+
+/** \ingroup libusb_desc
+ * A collection of alternate settings for a particular USB interface.
+ */
+struct libusb_interface {
+	/** Array of interface descriptors. The length of this array is determined
+	 * by the num_altsetting field. */
+	const struct libusb_interface_descriptor *altsetting;
+
+	/** The number of alternate settings that belong to this interface */
+	int num_altsetting;
+};
+
+/** \ingroup libusb_desc
+ * A structure representing the standard USB configuration descriptor. This
+ * descriptor is documented in section 9.6.3 of the USB 3.0 specification.
+ * All multiple-byte fields are represented in host-endian format.
+ */
+struct libusb_config_descriptor {
+	/** Size of this descriptor (in bytes) */
+	uint8_t  bLength;
+
+	/** Descriptor type. Will have value
+	 * \ref libusb_descriptor_type::LIBUSB_DT_CONFIG LIBUSB_DT_CONFIG
+	 * in this context. */
+	uint8_t  bDescriptorType;
+
+	/** Total length of data returned for this configuration */
+	uint16_t wTotalLength;
+
+	/** Number of interfaces supported by this configuration */
+	uint8_t  bNumInterfaces;
+
+	/** Identifier value for this configuration */
+	uint8_t  bConfigurationValue;
+
+	/** Index of string descriptor describing this configuration */
+	uint8_t  iConfiguration;
+
+	/** Configuration characteristics */
+	uint8_t  bmAttributes;
+
+	/** Maximum power consumption of the USB device from this bus in this
+	 * configuration when the device is fully operation. Expressed in units
+	 * of 2 mA when the device is operating in high-speed mode and in units
+	 * of 8 mA when the device is operating in super-speed mode. */
+	uint8_t  MaxPower;
+
+	/** Array of interfaces supported by this configuration. The length of
+	 * this array is determined by the bNumInterfaces field. */
+	const struct libusb_interface *interface;
+
+	/** Extra descriptors. If libusb encounters unknown configuration
+	 * descriptors, it will store them here, should you wish to parse them. */
+	const unsigned char *extra;
+
+	/** Length of the extra descriptors, in bytes. */
+	int extra_length;
+};
+
+/** \ingroup libusb_desc
+ * A structure representing the superspeed endpoint companion
+ * descriptor. This descriptor is documented in section 9.6.7 of
+ * the USB 3.0 specification. All multiple-byte fields are represented in
+ * host-endian format.
+ */
+struct libusb_ss_endpoint_companion_descriptor {
+
+	/** Size of this descriptor (in bytes) */
+	uint8_t  bLength;
+
+	/** Descriptor type. Will have value
+	 * \ref libusb_descriptor_type::LIBUSB_DT_SS_ENDPOINT_COMPANION in
+	 * this context. */
+	uint8_t  bDescriptorType;
+
+
+	/** The maximum number of packets the endpoint can send or
+	 *  receive as part of a burst. */
+	uint8_t  bMaxBurst;
+
+	/** In bulk EP:	bits 4:0 represents the	maximum	number of
+	 *  streams the	EP supports. In	isochronous EP:	bits 1:0
+	 *  represents the Mult	- a zero based value that determines
+	 *  the	maximum	number of packets within a service interval  */
+	uint8_t  bmAttributes;
+
+	/** The	total number of bytes this EP will transfer every
+	 *  service interval. valid only for periodic EPs. */
+	uint16_t wBytesPerInterval;
+};
+
+/** \ingroup libusb_desc
+ * A generic representation of a BOS Device Capability descriptor. It is
+ * advised to check bDevCapabilityType and call the matching
+ * libusb_get_*_descriptor function to get a structure fully matching the type.
+ */
+struct libusb_bos_dev_capability_descriptor {
+	/** Size of this descriptor (in bytes) */
+	uint8_t bLength;
+	/** Descriptor type. Will have value
+	 * \ref libusb_descriptor_type::LIBUSB_DT_DEVICE_CAPABILITY
+	 * LIBUSB_DT_DEVICE_CAPABILITY in this context. */
+	uint8_t bDescriptorType;
+	/** Device Capability type */
+	uint8_t bDevCapabilityType;
+	/** Device Capability data (bLength - 3 bytes) */
+	uint8_t dev_capability_data[ZERO_SIZED_ARRAY];
+};
+
+/** \ingroup libusb_desc
+ * A structure representing the Binary Device Object Store (BOS) descriptor.
+ * This descriptor is documented in section 9.6.2 of the USB 3.0 specification.
+ * All multiple-byte fields are represented in host-endian format.
+ */
+struct libusb_bos_descriptor {
+	/** Size of this descriptor (in bytes) */
+	uint8_t  bLength;
+
+	/** Descriptor type. Will have value
+	 * \ref libusb_descriptor_type::LIBUSB_DT_BOS LIBUSB_DT_BOS
+	 * in this context. */
+	uint8_t  bDescriptorType;
+
+	/** Length of this descriptor and all of its sub descriptors */
+	uint16_t wTotalLength;
+
+	/** The number of separate device capability descriptors in
+	 * the BOS */
+	uint8_t  bNumDeviceCaps;
+
+	/** bNumDeviceCap Device Capability Descriptors */
+	struct libusb_bos_dev_capability_descriptor *dev_capability[ZERO_SIZED_ARRAY];
+};
+
+/** \ingroup libusb_desc
+ * A structure representing the USB 2.0 Extension descriptor
+ * This descriptor is documented in section 9.6.2.1 of the USB 3.0 specification.
+ * All multiple-byte fields are represented in host-endian format.
+ */
+struct libusb_usb_2_0_extension_descriptor {
+	/** Size of this descriptor (in bytes) */
+	uint8_t  bLength;
+
+	/** Descriptor type. Will have value
+	 * \ref libusb_descriptor_type::LIBUSB_DT_DEVICE_CAPABILITY
+	 * LIBUSB_DT_DEVICE_CAPABILITY in this context. */
+	uint8_t  bDescriptorType;
+
+	/** Capability type. Will have value
+	 * \ref libusb_capability_type::LIBUSB_BT_USB_2_0_EXTENSION
+	 * LIBUSB_BT_USB_2_0_EXTENSION in this context. */
+	uint8_t  bDevCapabilityType;
+
+	/** Bitmap encoding of supported device level features.
+	 * A value of one in a bit location indicates a feature is
+	 * supported; a value of zero indicates it is not supported.
+	 * See \ref libusb_usb_2_0_extension_attributes. */
+	uint32_t  bmAttributes;
+};
+
+/** \ingroup libusb_desc
+ * A structure representing the SuperSpeed USB Device Capability descriptor
+ * This descriptor is documented in section 9.6.2.2 of the USB 3.0 specification.
+ * All multiple-byte fields are represented in host-endian format.
+ */
+struct libusb_ss_usb_device_capability_descriptor {
+	/** Size of this descriptor (in bytes) */
+	uint8_t  bLength;
+
+	/** Descriptor type. Will have value
+	 * \ref libusb_descriptor_type::LIBUSB_DT_DEVICE_CAPABILITY
+	 * LIBUSB_DT_DEVICE_CAPABILITY in this context. */
+	uint8_t  bDescriptorType;
+
+	/** Capability type. Will have value
+	 * \ref libusb_capability_type::LIBUSB_BT_SS_USB_DEVICE_CAPABILITY
+	 * LIBUSB_BT_SS_USB_DEVICE_CAPABILITY in this context. */
+	uint8_t  bDevCapabilityType;
+
+	/** Bitmap encoding of supported device level features.
+	 * A value of one in a bit location indicates a feature is
+	 * supported; a value of zero indicates it is not supported.
+	 * See \ref libusb_ss_usb_device_capability_attributes. */
+	uint8_t  bmAttributes;
+
+	/** Bitmap encoding of the speed supported by this device when
+	 * operating in SuperSpeed mode. See \ref libusb_supported_speed. */
+	uint16_t wSpeedSupported;
+
+	/** The lowest speed at which all the functionality supported
+	 * by the device is available to the user. For example if the
+	 * device supports all its functionality when connected at
+	 * full speed and above then it sets this value to 1. */
+	uint8_t  bFunctionalitySupport;
+
+	/** U1 Device Exit Latency. */
+	uint8_t  bU1DevExitLat;
+
+	/** U2 Device Exit Latency. */
+	uint16_t bU2DevExitLat;
+};
+
+/** \ingroup libusb_desc
+ * A structure representing the Container ID descriptor.
+ * This descriptor is documented in section 9.6.2.3 of the USB 3.0 specification.
+ * All multiple-byte fields, except UUIDs, are represented in host-endian format.
+ */
+struct libusb_container_id_descriptor {
+	/** Size of this descriptor (in bytes) */
+	uint8_t  bLength;
+
+	/** Descriptor type. Will have value
+	 * \ref libusb_descriptor_type::LIBUSB_DT_DEVICE_CAPABILITY
+	 * LIBUSB_DT_DEVICE_CAPABILITY in this context. */
+	uint8_t  bDescriptorType;
+
+	/** Capability type. Will have value
+	 * \ref libusb_capability_type::LIBUSB_BT_CONTAINER_ID
+	 * LIBUSB_BT_CONTAINER_ID in this context. */
+	uint8_t  bDevCapabilityType;
+
+	/** Reserved field */
+	uint8_t bReserved;
+
+	/** 128 bit UUID */
+	uint8_t  ContainerID[16];
+};
+
+/** \ingroup libusb_asyncio
+ * Setup packet for control transfers. */
+struct libusb_control_setup {
+	/** Request type. Bits 0:4 determine recipient, see
+	 * \ref libusb_request_recipient. Bits 5:6 determine type, see
+	 * \ref libusb_request_type. Bit 7 determines data transfer direction, see
+	 * \ref libusb_endpoint_direction.
+	 */
+	uint8_t  bmRequestType;
+
+	/** Request. If the type bits of bmRequestType are equal to
+	 * \ref libusb_request_type::LIBUSB_REQUEST_TYPE_STANDARD
+	 * "LIBUSB_REQUEST_TYPE_STANDARD" then this field refers to
+	 * \ref libusb_standard_request. For other cases, use of this field is
+	 * application-specific. */
+	uint8_t  bRequest;
+
+	/** Value. Varies according to request */
+	uint16_t wValue;
+
+	/** Index. Varies according to request, typically used to pass an index
+	 * or offset */
+	uint16_t wIndex;
+
+	/** Number of bytes to transfer */
+	uint16_t wLength;
+};
+
+#define LIBUSB_CONTROL_SETUP_SIZE (sizeof(struct libusb_control_setup))
+
+/* libusb */
+
+struct libusb_context;
+struct libusb_device;
+struct libusb_device_handle;
+
+/** \ingroup libusb_lib
+ * Structure providing the version of the libusb runtime
+ */
+struct libusb_version {
+	/** Library major version. */
+	const uint16_t major;
+
+	/** Library minor version. */
+	const uint16_t minor;
+
+	/** Library micro version. */
+	const uint16_t micro;
+
+	/** Library nano version. */
+	const uint16_t nano;
+
+	/** Library release candidate suffix string, e.g. "-rc4". */
+	const char *rc;
+
+	/** For ABI compatibility only. */
+	const char* describe;
+};
+
+/** \ingroup libusb_lib
+ * Structure representing a libusb session. The concept of individual libusb
+ * sessions allows for your program to use two libraries (or dynamically
+ * load two modules) which both independently use libusb. This will prevent
+ * interference between the individual libusb users - for example
+ * libusb_set_option() will not affect the other user of the library, and
+ * libusb_exit() will not destroy resources that the other user is still
+ * using.
+ *
+ * Sessions are created by libusb_init() and destroyed through libusb_exit().
+ * If your application is guaranteed to only ever include a single libusb
+ * user (i.e. you), you do not have to worry about contexts: pass NULL in
+ * every function call where a context is required. The default context
+ * will be used.
+ *
+ * For more information, see \ref libusb_contexts.
+ */
+typedef struct libusb_context libusb_context;
+
+/** \ingroup libusb_dev
+ * Structure representing a USB device detected on the system. This is an
+ * opaque type for which you are only ever provided with a pointer, usually
+ * originating from libusb_get_device_list().
+ *
+ * Certain operations can be performed on a device, but in order to do any
+ * I/O you will have to first obtain a device handle using libusb_open().
+ *
+ * Devices are reference counted with libusb_ref_device() and
+ * libusb_unref_device(), and are freed when the reference count reaches 0.
+ * New devices presented by libusb_get_device_list() have a reference count of
+ * 1, and libusb_free_device_list() can optionally decrease the reference count
+ * on all devices in the list. libusb_open() adds another reference which is
+ * later destroyed by libusb_close().
+ */
+typedef struct libusb_device libusb_device;
+
+
+/** \ingroup libusb_dev
+ * Structure representing a handle on a USB device. This is an opaque type for
+ * which you are only ever provided with a pointer, usually originating from
+ * libusb_open().
+ *
+ * A device handle is used to perform I/O and other operations. When finished
+ * with a device handle, you should call libusb_close().
+ */
+typedef struct libusb_device_handle libusb_device_handle;
+
+/** \ingroup libusb_dev
+ * Speed codes. Indicates the speed at which the device is operating.
+ */
+enum libusb_speed {
+	/** The OS doesn't report or know the device speed. */
+	LIBUSB_SPEED_UNKNOWN = 0,
+
+	/** The device is operating at low speed (1.5MBit/s). */
+	LIBUSB_SPEED_LOW = 1,
+
+	/** The device is operating at full speed (12MBit/s). */
+	LIBUSB_SPEED_FULL = 2,
+
+	/** The device is operating at high speed (480MBit/s). */
+	LIBUSB_SPEED_HIGH = 3,
+
+	/** The device is operating at super speed (5000MBit/s). */
+	LIBUSB_SPEED_SUPER = 4,
+
+	/** The device is operating at super speed plus (10000MBit/s). */
+	LIBUSB_SPEED_SUPER_PLUS = 5,
+};
+
+/** \ingroup libusb_dev
+ * Supported speeds (wSpeedSupported) bitfield. Indicates what
+ * speeds the device supports.
+ */
+enum libusb_supported_speed {
+	/** Low speed operation supported (1.5MBit/s). */
+	LIBUSB_LOW_SPEED_OPERATION   = 1,
+
+	/** Full speed operation supported (12MBit/s). */
+	LIBUSB_FULL_SPEED_OPERATION  = 2,
+
+	/** High speed operation supported (480MBit/s). */
+	LIBUSB_HIGH_SPEED_OPERATION  = 4,
+
+	/** Superspeed operation supported (5000MBit/s). */
+	LIBUSB_SUPER_SPEED_OPERATION = 8,
+};
+
+/** \ingroup libusb_dev
+ * Masks for the bits of the
+ * \ref libusb_usb_2_0_extension_descriptor::bmAttributes "bmAttributes" field
+ * of the USB 2.0 Extension descriptor.
+ */
+enum libusb_usb_2_0_extension_attributes {
+	/** Supports Link Power Management (LPM) */
+	LIBUSB_BM_LPM_SUPPORT = 2,
+};
+
+/** \ingroup libusb_dev
+ * Masks for the bits of the
+ * \ref libusb_ss_usb_device_capability_descriptor::bmAttributes "bmAttributes" field
+ * field of the SuperSpeed USB Device Capability descriptor.
+ */
+enum libusb_ss_usb_device_capability_attributes {
+	/** Supports Latency Tolerance Messages (LTM) */
+	LIBUSB_BM_LTM_SUPPORT = 2,
+};
+
+/** \ingroup libusb_dev
+ * USB capability types
+ */
+enum libusb_bos_type {
+	/** Wireless USB device capability */
+	LIBUSB_BT_WIRELESS_USB_DEVICE_CAPABILITY	= 1,
+
+	/** USB 2.0 extensions */
+	LIBUSB_BT_USB_2_0_EXTENSION			= 2,
+
+	/** SuperSpeed USB device capability */
+	LIBUSB_BT_SS_USB_DEVICE_CAPABILITY		= 3,
+
+	/** Container ID type */
+	LIBUSB_BT_CONTAINER_ID				= 4,
+};
+
+/** \ingroup libusb_misc
+ * Error codes. Most libusb functions return 0 on success or one of these
+ * codes on failure.
+ * You can call libusb_error_name() to retrieve a string representation of an
+ * error code or libusb_strerror() to get an end-user suitable description of
+ * an error code.
+ */
+enum libusb_error {
+	/** Success (no error) */
+	LIBUSB_SUCCESS = 0,
+
+	/** Input/output error */
+	LIBUSB_ERROR_IO = -1,
+
+	/** Invalid parameter */
+	LIBUSB_ERROR_INVALID_PARAM = -2,
+
+	/** Access denied (insufficient permissions) */
+	LIBUSB_ERROR_ACCESS = -3,
+
+	/** No such device (it may have been disconnected) */
+	LIBUSB_ERROR_NO_DEVICE = -4,
+
+	/** Entity not found */
+	LIBUSB_ERROR_NOT_FOUND = -5,
+
+	/** Resource busy */
+	LIBUSB_ERROR_BUSY = -6,
+
+	/** Operation timed out */
+	LIBUSB_ERROR_TIMEOUT = -7,
+
+	/** Overflow */
+	LIBUSB_ERROR_OVERFLOW = -8,
+
+	/** Pipe error */
+	LIBUSB_ERROR_PIPE = -9,
+
+	/** System call interrupted (perhaps due to signal) */
+	LIBUSB_ERROR_INTERRUPTED = -10,
+
+	/** Insufficient memory */
+	LIBUSB_ERROR_NO_MEM = -11,
+
+	/** Operation not supported or unimplemented on this platform */
+	LIBUSB_ERROR_NOT_SUPPORTED = -12,
+
+	/* NB: Remember to update LIBUSB_ERROR_COUNT below as well as the
+	   message strings in strerror.c when adding new error codes here. */
+
+	/** Other error */
+	LIBUSB_ERROR_OTHER = -99,
+};
+
+/* Total number of error codes in enum libusb_error */
+#define LIBUSB_ERROR_COUNT 14
+
+/** \ingroup libusb_asyncio
+ * Transfer status codes */
+enum libusb_transfer_status {
+	/** Transfer completed without error. Note that this does not indicate
+	 * that the entire amount of requested data was transferred. */
+	LIBUSB_TRANSFER_COMPLETED,
+
+	/** Transfer failed */
+	LIBUSB_TRANSFER_ERROR,
+
+	/** Transfer timed out */
+	LIBUSB_TRANSFER_TIMED_OUT,
+
+	/** Transfer was cancelled */
+	LIBUSB_TRANSFER_CANCELLED,
+
+	/** For bulk/interrupt endpoints: halt condition detected (endpoint
+	 * stalled). For control endpoints: control request not supported. */
+	LIBUSB_TRANSFER_STALL,
+
+	/** Device was disconnected */
+	LIBUSB_TRANSFER_NO_DEVICE,
+
+	/** Device sent more data than requested */
+	LIBUSB_TRANSFER_OVERFLOW,
+
+	/* NB! Remember to update libusb_error_name()
+	   when adding new status codes here. */
+};
+
+/** \ingroup libusb_asyncio
+ * libusb_transfer.flags values */
+enum libusb_transfer_flags {
+	/** Report short frames as errors */
+	LIBUSB_TRANSFER_SHORT_NOT_OK = 1<<0,
+
+	/** Automatically free() transfer buffer during libusb_free_transfer().
+	 * Note that buffers allocated with libusb_dev_mem_alloc() should not
+	 * be attempted freed in this way, since free() is not an appropriate
+	 * way to release such memory. */
+	LIBUSB_TRANSFER_FREE_BUFFER = 1<<1,
+
+	/** Automatically call libusb_free_transfer() after callback returns.
+	 * If this flag is set, it is illegal to call libusb_free_transfer()
+	 * from your transfer callback, as this will result in a double-free
+	 * when this flag is acted upon. */
+	LIBUSB_TRANSFER_FREE_TRANSFER = 1<<2,
+
+	/** Terminate transfers that are a multiple of the endpoint's
+	 * wMaxPacketSize with an extra zero length packet. This is useful
+	 * when a device protocol mandates that each logical request is
+	 * terminated by an incomplete packet (i.e. the logical requests are
+	 * not separated by other means).
+	 *
+	 * This flag only affects host-to-device transfers to bulk and interrupt
+	 * endpoints. In other situations, it is ignored.
+	 *
+	 * This flag only affects transfers with a length that is a multiple of
+	 * the endpoint's wMaxPacketSize. On transfers of other lengths, this
+	 * flag has no effect. Therefore, if you are working with a device that
+	 * needs a ZLP whenever the end of the logical request falls on a packet
+	 * boundary, then it is sensible to set this flag on <em>every</em>
+	 * transfer (you do not have to worry about only setting it on transfers
+	 * that end on the boundary).
+	 *
+	 * This flag is currently only supported on Linux.
+	 * On other systems, libusb_submit_transfer() will return
+	 * LIBUSB_ERROR_NOT_SUPPORTED for every transfer where this flag is set.
+	 *
+	 * Available since libusb-1.0.9.
+	 */
+	LIBUSB_TRANSFER_ADD_ZERO_PACKET = 1 << 3,
+};
+
+/** \ingroup libusb_asyncio
+ * Isochronous packet descriptor. */
+struct libusb_iso_packet_descriptor {
+	/** Length of data to request in this packet */
+	unsigned int length;
+
+	/** Amount of data that was actually transferred */
+	unsigned int actual_length;
+
+	/** Status code for this packet */
+	enum libusb_transfer_status status;
+};
+
+struct libusb_transfer;
+
+/** \ingroup libusb_asyncio
+ * Asynchronous transfer callback function type. When submitting asynchronous
+ * transfers, you pass a pointer to a callback function of this type via the
+ * \ref libusb_transfer::callback "callback" member of the libusb_transfer
+ * structure. libusb will call this function later, when the transfer has
+ * completed or failed. See \ref libusb_asyncio for more information.
+ * \param transfer The libusb_transfer struct the callback function is being
+ * notified about.
+ */
+typedef void (LIBUSB_CALL *libusb_transfer_cb_fn)(struct libusb_transfer *transfer);
+
+/** \ingroup libusb_asyncio
+ * The generic USB transfer structure. The user populates this structure and
+ * then submits it in order to request a transfer. After the transfer has
+ * completed, the library populates the transfer with the results and passes
+ * it back to the user.
+ */
+struct libusb_transfer {
+	/** Handle of the device that this transfer will be submitted to */
+	libusb_device_handle *dev_handle;
+
+	/** A bitwise OR combination of \ref libusb_transfer_flags. */
+	uint8_t flags;
+
+	/** Address of the endpoint where this transfer will be sent. */
+	unsigned char endpoint;
+
+	/** Type of the endpoint from \ref libusb_transfer_type */
+	unsigned char type;
+
+	/** Timeout for this transfer in milliseconds. A value of 0 indicates no
+	 * timeout. */
+	unsigned int timeout;
+
+	/** The status of the transfer. Read-only, and only for use within
+	 * transfer callback function.
+	 *
+	 * If this is an isochronous transfer, this field may read COMPLETED even
+	 * if there were errors in the frames. Use the
+	 * \ref libusb_iso_packet_descriptor::status "status" field in each packet
+	 * to determine if errors occurred. */
+	enum libusb_transfer_status status;
+
+	/** Length of the data buffer */
+	int length;
+
+	/** Actual length of data that was transferred. Read-only, and only for
+	 * use within transfer callback function. Not valid for isochronous
+	 * endpoint transfers. */
+	int actual_length;
+
+	/** Callback function. This will be invoked when the transfer completes,
+	 * fails, or is cancelled. */
+	libusb_transfer_cb_fn callback;
+
+	/** User context data to pass to the callback function. */
+	void *user_data;
+
+	/** Data buffer */
+	unsigned char *buffer;
+
+	/** Number of isochronous packets. Only used for I/O with isochronous
+	 * endpoints. */
+	int num_iso_packets;
+
+	/** Isochronous packet descriptors, for isochronous transfers only. */
+	struct libusb_iso_packet_descriptor iso_packet_desc[ZERO_SIZED_ARRAY];
+};
+
+/** \ingroup libusb_misc
+ * Capabilities supported by an instance of libusb on the current running
+ * platform. Test if the loaded library supports a given capability by calling
+ * \ref libusb_has_capability().
+ */
+enum libusb_capability {
+	/** The libusb_has_capability() API is available. */
+	LIBUSB_CAP_HAS_CAPABILITY = 0x0000,
+	/** Hotplug support is available on this platform. */
+	LIBUSB_CAP_HAS_HOTPLUG = 0x0001,
+	/** The library can access HID devices without requiring user intervention.
+	 * Note that before being able to actually access an HID device, you may
+	 * still have to call additional libusb functions such as
+	 * \ref libusb_detach_kernel_driver(). */
+	LIBUSB_CAP_HAS_HID_ACCESS = 0x0100,
+	/** The library supports detaching of the default USB driver, using 
+	 * \ref libusb_detach_kernel_driver(), if one is set by the OS kernel */
+	LIBUSB_CAP_SUPPORTS_DETACH_KERNEL_DRIVER = 0x0101
+};
+
+/** \ingroup libusb_lib
+ *  Log message levels.
+ *  - LIBUSB_LOG_LEVEL_NONE (0)    : no messages ever printed by the library (default)
+ *  - LIBUSB_LOG_LEVEL_ERROR (1)   : error messages are printed to stderr
+ *  - LIBUSB_LOG_LEVEL_WARNING (2) : warning and error messages are printed to stderr
+ *  - LIBUSB_LOG_LEVEL_INFO (3)    : informational messages are printed to stderr
+ *  - LIBUSB_LOG_LEVEL_DEBUG (4)   : debug and informational messages are printed to stderr
+ */
+enum libusb_log_level {
+	LIBUSB_LOG_LEVEL_NONE = 0,
+	LIBUSB_LOG_LEVEL_ERROR = 1,
+	LIBUSB_LOG_LEVEL_WARNING = 2,
+	LIBUSB_LOG_LEVEL_INFO = 3,
+	LIBUSB_LOG_LEVEL_DEBUG = 4,
+};
+
+int LIBUSB_CALL libusb_init(libusb_context **ctx);
+void LIBUSB_CALL libusb_exit(libusb_context *ctx);
+LIBUSB_DEPRECATED_FOR(libusb_set_option)
+void LIBUSB_CALL libusb_set_debug(libusb_context *ctx, int level);
+const struct libusb_version * LIBUSB_CALL libusb_get_version(void);
+int LIBUSB_CALL libusb_has_capability(uint32_t capability);
+const char * LIBUSB_CALL libusb_error_name(int errcode);
+int LIBUSB_CALL libusb_setlocale(const char *locale);
+const char * LIBUSB_CALL libusb_strerror(enum libusb_error errcode);
+
+ssize_t LIBUSB_CALL libusb_get_device_list(libusb_context *ctx,
+	libusb_device ***list);
+void LIBUSB_CALL libusb_free_device_list(libusb_device **list,
+	int unref_devices);
+libusb_device * LIBUSB_CALL libusb_ref_device(libusb_device *dev);
+void LIBUSB_CALL libusb_unref_device(libusb_device *dev);
+
+int LIBUSB_CALL libusb_get_configuration(libusb_device_handle *dev,
+	int *config);
+int LIBUSB_CALL libusb_get_device_descriptor(libusb_device *dev,
+	struct libusb_device_descriptor *desc);
+int LIBUSB_CALL libusb_get_active_config_descriptor(libusb_device *dev,
+	struct libusb_config_descriptor **config);
+int LIBUSB_CALL libusb_get_config_descriptor(libusb_device *dev,
+	uint8_t config_index, struct libusb_config_descriptor **config);
+int LIBUSB_CALL libusb_get_config_descriptor_by_value(libusb_device *dev,
+	uint8_t bConfigurationValue, struct libusb_config_descriptor **config);
+void LIBUSB_CALL libusb_free_config_descriptor(
+	struct libusb_config_descriptor *config);
+int LIBUSB_CALL libusb_get_ss_endpoint_companion_descriptor(
+	struct libusb_context *ctx,
+	const struct libusb_endpoint_descriptor *endpoint,
+	struct libusb_ss_endpoint_companion_descriptor **ep_comp);
+void LIBUSB_CALL libusb_free_ss_endpoint_companion_descriptor(
+	struct libusb_ss_endpoint_companion_descriptor *ep_comp);
+int LIBUSB_CALL libusb_get_bos_descriptor(libusb_device_handle *dev_handle,
+	struct libusb_bos_descriptor **bos);
+void LIBUSB_CALL libusb_free_bos_descriptor(struct libusb_bos_descriptor *bos);
+int LIBUSB_CALL libusb_get_usb_2_0_extension_descriptor(
+	struct libusb_context *ctx,
+	struct libusb_bos_dev_capability_descriptor *dev_cap,
+	struct libusb_usb_2_0_extension_descriptor **usb_2_0_extension);
+void LIBUSB_CALL libusb_free_usb_2_0_extension_descriptor(
+	struct libusb_usb_2_0_extension_descriptor *usb_2_0_extension);
+int LIBUSB_CALL libusb_get_ss_usb_device_capability_descriptor(
+	struct libusb_context *ctx,
+	struct libusb_bos_dev_capability_descriptor *dev_cap,
+	struct libusb_ss_usb_device_capability_descriptor **ss_usb_device_cap);
+void LIBUSB_CALL libusb_free_ss_usb_device_capability_descriptor(
+	struct libusb_ss_usb_device_capability_descriptor *ss_usb_device_cap);
+int LIBUSB_CALL libusb_get_container_id_descriptor(struct libusb_context *ctx,
+	struct libusb_bos_dev_capability_descriptor *dev_cap,
+	struct libusb_container_id_descriptor **container_id);
+void LIBUSB_CALL libusb_free_container_id_descriptor(
+	struct libusb_container_id_descriptor *container_id);
+uint8_t LIBUSB_CALL libusb_get_bus_number(libusb_device *dev);
+uint8_t LIBUSB_CALL libusb_get_port_number(libusb_device *dev);
+int LIBUSB_CALL libusb_get_port_numbers(libusb_device *dev, uint8_t* port_numbers, int port_numbers_len);
+LIBUSB_DEPRECATED_FOR(libusb_get_port_numbers)
+int LIBUSB_CALL libusb_get_port_path(libusb_context *ctx, libusb_device *dev, uint8_t* path, uint8_t path_length);
+libusb_device * LIBUSB_CALL libusb_get_parent(libusb_device *dev);
+uint8_t LIBUSB_CALL libusb_get_device_address(libusb_device *dev);
+int LIBUSB_CALL libusb_get_device_speed(libusb_device *dev);
+int LIBUSB_CALL libusb_get_max_packet_size(libusb_device *dev,
+	unsigned char endpoint);
+int LIBUSB_CALL libusb_get_max_iso_packet_size(libusb_device *dev,
+	unsigned char endpoint);
+
+int LIBUSB_CALL libusb_open(libusb_device *dev, libusb_device_handle **dev_handle);
+void LIBUSB_CALL libusb_close(libusb_device_handle *dev_handle);
+libusb_device * LIBUSB_CALL libusb_get_device(libusb_device_handle *dev_handle);
+
+int LIBUSB_CALL libusb_set_configuration(libusb_device_handle *dev_handle,
+	int configuration);
+int LIBUSB_CALL libusb_claim_interface(libusb_device_handle *dev_handle,
+	int interface_number);
+int LIBUSB_CALL libusb_release_interface(libusb_device_handle *dev_handle,
+	int interface_number);
+
+libusb_device_handle * LIBUSB_CALL libusb_open_device_with_vid_pid(
+	libusb_context *ctx, uint16_t vendor_id, uint16_t product_id);
+
+int LIBUSB_CALL libusb_set_interface_alt_setting(libusb_device_handle *dev_handle,
+	int interface_number, int alternate_setting);
+int LIBUSB_CALL libusb_clear_halt(libusb_device_handle *dev_handle,
+	unsigned char endpoint);
+int LIBUSB_CALL libusb_reset_device(libusb_device_handle *dev_handle);
+
+int LIBUSB_CALL libusb_alloc_streams(libusb_device_handle *dev_handle,
+	uint32_t num_streams, unsigned char *endpoints, int num_endpoints);
+int LIBUSB_CALL libusb_free_streams(libusb_device_handle *dev_handle,
+	unsigned char *endpoints, int num_endpoints);
+
+unsigned char * LIBUSB_CALL libusb_dev_mem_alloc(libusb_device_handle *dev_handle,
+	size_t length);
+int LIBUSB_CALL libusb_dev_mem_free(libusb_device_handle *dev_handle,
+	unsigned char *buffer, size_t length);
+
+int LIBUSB_CALL libusb_kernel_driver_active(libusb_device_handle *dev_handle,
+	int interface_number);
+int LIBUSB_CALL libusb_detach_kernel_driver(libusb_device_handle *dev_handle,
+	int interface_number);
+int LIBUSB_CALL libusb_attach_kernel_driver(libusb_device_handle *dev_handle,
+	int interface_number);
+int LIBUSB_CALL libusb_set_auto_detach_kernel_driver(
+	libusb_device_handle *dev_handle, int enable);
+
+/* async I/O */
+
+/** \ingroup libusb_asyncio
+ * Get the data section of a control transfer. This convenience function is here
+ * to remind you that the data does not start until 8 bytes into the actual
+ * buffer, as the setup packet comes first.
+ *
+ * Calling this function only makes sense from a transfer callback function,
+ * or situations where you have already allocated a suitably sized buffer at
+ * transfer->buffer.
+ *
+ * \param transfer a transfer
+ * \returns pointer to the first byte of the data section
+ */
+static inline unsigned char *libusb_control_transfer_get_data(
+	struct libusb_transfer *transfer)
+{
+	return transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE;
+}
+
+/** \ingroup libusb_asyncio
+ * Get the control setup packet of a control transfer. This convenience
+ * function is here to remind you that the control setup occupies the first
+ * 8 bytes of the transfer data buffer.
+ *
+ * Calling this function only makes sense from a transfer callback function,
+ * or situations where you have already allocated a suitably sized buffer at
+ * transfer->buffer.
+ *
+ * \param transfer a transfer
+ * \returns a casted pointer to the start of the transfer data buffer
+ */
+static inline struct libusb_control_setup *libusb_control_transfer_get_setup(
+	struct libusb_transfer *transfer)
+{
+	return (struct libusb_control_setup *)(void *) transfer->buffer;
+}
+
+/** \ingroup libusb_asyncio
+ * Helper function to populate the setup packet (first 8 bytes of the data
+ * buffer) for a control transfer. The wIndex, wValue and wLength values should
+ * be given in host-endian byte order.
+ *
+ * \param buffer buffer to output the setup packet into
+ * This pointer must be aligned to at least 2 bytes boundary.
+ * \param bmRequestType see the
+ * \ref libusb_control_setup::bmRequestType "bmRequestType" field of
+ * \ref libusb_control_setup
+ * \param bRequest see the
+ * \ref libusb_control_setup::bRequest "bRequest" field of
+ * \ref libusb_control_setup
+ * \param wValue see the
+ * \ref libusb_control_setup::wValue "wValue" field of
+ * \ref libusb_control_setup
+ * \param wIndex see the
+ * \ref libusb_control_setup::wIndex "wIndex" field of
+ * \ref libusb_control_setup
+ * \param wLength see the
+ * \ref libusb_control_setup::wLength "wLength" field of
+ * \ref libusb_control_setup
+ */
+static inline void libusb_fill_control_setup(unsigned char *buffer,
+	uint8_t bmRequestType, uint8_t bRequest, uint16_t wValue, uint16_t wIndex,
+	uint16_t wLength)
+{
+	struct libusb_control_setup *setup = (struct libusb_control_setup *)(void *) buffer;
+	setup->bmRequestType = bmRequestType;
+	setup->bRequest = bRequest;
+	setup->wValue = libusb_cpu_to_le16(wValue);
+	setup->wIndex = libusb_cpu_to_le16(wIndex);
+	setup->wLength = libusb_cpu_to_le16(wLength);
+}
+
+struct libusb_transfer * LIBUSB_CALL libusb_alloc_transfer(int iso_packets);
+int LIBUSB_CALL libusb_submit_transfer(struct libusb_transfer *transfer);
+int LIBUSB_CALL libusb_cancel_transfer(struct libusb_transfer *transfer);
+void LIBUSB_CALL libusb_free_transfer(struct libusb_transfer *transfer);
+void LIBUSB_CALL libusb_transfer_set_stream_id(
+	struct libusb_transfer *transfer, uint32_t stream_id);
+uint32_t LIBUSB_CALL libusb_transfer_get_stream_id(
+	struct libusb_transfer *transfer);
+
+/** \ingroup libusb_asyncio
+ * Helper function to populate the required \ref libusb_transfer fields
+ * for a control transfer.
+ *
+ * If you pass a transfer buffer to this function, the first 8 bytes will
+ * be interpreted as a control setup packet, and the wLength field will be
+ * used to automatically populate the \ref libusb_transfer::length "length"
+ * field of the transfer. Therefore the recommended approach is:
+ * -# Allocate a suitably sized data buffer (including space for control setup)
+ * -# Call libusb_fill_control_setup()
+ * -# If this is a host-to-device transfer with a data stage, put the data
+ *    in place after the setup packet
+ * -# Call this function
+ * -# Call libusb_submit_transfer()
+ *
+ * It is also legal to pass a NULL buffer to this function, in which case this
+ * function will not attempt to populate the length field. Remember that you
+ * must then populate the buffer and length fields later.
+ *
+ * \param transfer the transfer to populate
+ * \param dev_handle handle of the device that will handle the transfer
+ * \param buffer data buffer. If provided, this function will interpret the
+ * first 8 bytes as a setup packet and infer the transfer length from that.
+ * This pointer must be aligned to at least 2 bytes boundary.
+ * \param callback callback function to be invoked on transfer completion
+ * \param user_data user data to pass to callback function
+ * \param timeout timeout for the transfer in milliseconds
+ */
+static inline void libusb_fill_control_transfer(
+	struct libusb_transfer *transfer, libusb_device_handle *dev_handle,
+	unsigned char *buffer, libusb_transfer_cb_fn callback, void *user_data,
+	unsigned int timeout)
+{
+	struct libusb_control_setup *setup = (struct libusb_control_setup *)(void *) buffer;
+	transfer->dev_handle = dev_handle;
+	transfer->endpoint = 0;
+	transfer->type = LIBUSB_TRANSFER_TYPE_CONTROL;
+	transfer->timeout = timeout;
+	transfer->buffer = buffer;
+	if (setup)
+		transfer->length = (int) (LIBUSB_CONTROL_SETUP_SIZE
+			+ libusb_le16_to_cpu(setup->wLength));
+	transfer->user_data = user_data;
+	transfer->callback = callback;
+}
+
+/** \ingroup libusb_asyncio
+ * Helper function to populate the required \ref libusb_transfer fields
+ * for a bulk transfer.
+ *
+ * \param transfer the transfer to populate
+ * \param dev_handle handle of the device that will handle the transfer
+ * \param endpoint address of the endpoint where this transfer will be sent
+ * \param buffer data buffer
+ * \param length length of data buffer
+ * \param callback callback function to be invoked on transfer completion
+ * \param user_data user data to pass to callback function
+ * \param timeout timeout for the transfer in milliseconds
+ */
+static inline void libusb_fill_bulk_transfer(struct libusb_transfer *transfer,
+	libusb_device_handle *dev_handle, unsigned char endpoint,
+	unsigned char *buffer, int length, libusb_transfer_cb_fn callback,
+	void *user_data, unsigned int timeout)
+{
+	transfer->dev_handle = dev_handle;
+	transfer->endpoint = endpoint;
+	transfer->type = LIBUSB_TRANSFER_TYPE_BULK;
+	transfer->timeout = timeout;
+	transfer->buffer = buffer;
+	transfer->length = length;
+	transfer->user_data = user_data;
+	transfer->callback = callback;
+}
+
+/** \ingroup libusb_asyncio
+ * Helper function to populate the required \ref libusb_transfer fields
+ * for a bulk transfer using bulk streams.
+ *
+ * Since version 1.0.19, \ref LIBUSB_API_VERSION >= 0x01000103
+ *
+ * \param transfer the transfer to populate
+ * \param dev_handle handle of the device that will handle the transfer
+ * \param endpoint address of the endpoint where this transfer will be sent
+ * \param stream_id bulk stream id for this transfer
+ * \param buffer data buffer
+ * \param length length of data buffer
+ * \param callback callback function to be invoked on transfer completion
+ * \param user_data user data to pass to callback function
+ * \param timeout timeout for the transfer in milliseconds
+ */
+static inline void libusb_fill_bulk_stream_transfer(
+	struct libusb_transfer *transfer, libusb_device_handle *dev_handle,
+	unsigned char endpoint, uint32_t stream_id,
+	unsigned char *buffer, int length, libusb_transfer_cb_fn callback,
+	void *user_data, unsigned int timeout)
+{
+	libusb_fill_bulk_transfer(transfer, dev_handle, endpoint, buffer,
+				  length, callback, user_data, timeout);
+	transfer->type = LIBUSB_TRANSFER_TYPE_BULK_STREAM;
+	libusb_transfer_set_stream_id(transfer, stream_id);
+}
+
+/** \ingroup libusb_asyncio
+ * Helper function to populate the required \ref libusb_transfer fields
+ * for an interrupt transfer.
+ *
+ * \param transfer the transfer to populate
+ * \param dev_handle handle of the device that will handle the transfer
+ * \param endpoint address of the endpoint where this transfer will be sent
+ * \param buffer data buffer
+ * \param length length of data buffer
+ * \param callback callback function to be invoked on transfer completion
+ * \param user_data user data to pass to callback function
+ * \param timeout timeout for the transfer in milliseconds
+ */
+static inline void libusb_fill_interrupt_transfer(
+	struct libusb_transfer *transfer, libusb_device_handle *dev_handle,
+	unsigned char endpoint, unsigned char *buffer, int length,
+	libusb_transfer_cb_fn callback, void *user_data, unsigned int timeout)
+{
+	transfer->dev_handle = dev_handle;
+	transfer->endpoint = endpoint;
+	transfer->type = LIBUSB_TRANSFER_TYPE_INTERRUPT;
+	transfer->timeout = timeout;
+	transfer->buffer = buffer;
+	transfer->length = length;
+	transfer->user_data = user_data;
+	transfer->callback = callback;
+}
+
+/** \ingroup libusb_asyncio
+ * Helper function to populate the required \ref libusb_transfer fields
+ * for an isochronous transfer.
+ *
+ * \param transfer the transfer to populate
+ * \param dev_handle handle of the device that will handle the transfer
+ * \param endpoint address of the endpoint where this transfer will be sent
+ * \param buffer data buffer
+ * \param length length of data buffer
+ * \param num_iso_packets the number of isochronous packets
+ * \param callback callback function to be invoked on transfer completion
+ * \param user_data user data to pass to callback function
+ * \param timeout timeout for the transfer in milliseconds
+ */
+static inline void libusb_fill_iso_transfer(struct libusb_transfer *transfer,
+	libusb_device_handle *dev_handle, unsigned char endpoint,
+	unsigned char *buffer, int length, int num_iso_packets,
+	libusb_transfer_cb_fn callback, void *user_data, unsigned int timeout)
+{
+	transfer->dev_handle = dev_handle;
+	transfer->endpoint = endpoint;
+	transfer->type = LIBUSB_TRANSFER_TYPE_ISOCHRONOUS;
+	transfer->timeout = timeout;
+	transfer->buffer = buffer;
+	transfer->length = length;
+	transfer->num_iso_packets = num_iso_packets;
+	transfer->user_data = user_data;
+	transfer->callback = callback;
+}
+
+/** \ingroup libusb_asyncio
+ * Convenience function to set the length of all packets in an isochronous
+ * transfer, based on the num_iso_packets field in the transfer structure.
+ *
+ * \param transfer a transfer
+ * \param length the length to set in each isochronous packet descriptor
+ * \see libusb_get_max_packet_size()
+ */
+static inline void libusb_set_iso_packet_lengths(
+	struct libusb_transfer *transfer, unsigned int length)
+{
+	int i;
+	for (i = 0; i < transfer->num_iso_packets; i++)
+		transfer->iso_packet_desc[i].length = length;
+}
+
+/** \ingroup libusb_asyncio
+ * Convenience function to locate the position of an isochronous packet
+ * within the buffer of an isochronous transfer.
+ *
+ * This is a thorough function which loops through all preceding packets,
+ * accumulating their lengths to find the position of the specified packet.
+ * Typically you will assign equal lengths to each packet in the transfer,
+ * and hence the above method is sub-optimal. You may wish to use
+ * libusb_get_iso_packet_buffer_simple() instead.
+ *
+ * \param transfer a transfer
+ * \param packet the packet to return the address of
+ * \returns the base address of the packet buffer inside the transfer buffer,
+ * or NULL if the packet does not exist.
+ * \see libusb_get_iso_packet_buffer_simple()
+ */
+static inline unsigned char *libusb_get_iso_packet_buffer(
+	struct libusb_transfer *transfer, unsigned int packet)
+{
+	int i;
+	size_t offset = 0;
+	int _packet;
+
+	/* oops..slight bug in the API. packet is an unsigned int, but we use
+	 * signed integers almost everywhere else. range-check and convert to
+	 * signed to avoid compiler warnings. FIXME for libusb-2. */
+	if (packet > INT_MAX)
+		return NULL;
+	_packet = (int) packet;
+
+	if (_packet >= transfer->num_iso_packets)
+		return NULL;
+
+	for (i = 0; i < _packet; i++)
+		offset += transfer->iso_packet_desc[i].length;
+
+	return transfer->buffer + offset;
+}
+
+/** \ingroup libusb_asyncio
+ * Convenience function to locate the position of an isochronous packet
+ * within the buffer of an isochronous transfer, for transfers where each
+ * packet is of identical size.
+ *
+ * This function relies on the assumption that every packet within the transfer
+ * is of identical size to the first packet. Calculating the location of
+ * the packet buffer is then just a simple calculation:
+ * <tt>buffer + (packet_size * packet)</tt>
+ *
+ * Do not use this function on transfers other than those that have identical
+ * packet lengths for each packet.
+ *
+ * \param transfer a transfer
+ * \param packet the packet to return the address of
+ * \returns the base address of the packet buffer inside the transfer buffer,
+ * or NULL if the packet does not exist.
+ * \see libusb_get_iso_packet_buffer()
+ */
+static inline unsigned char *libusb_get_iso_packet_buffer_simple(
+	struct libusb_transfer *transfer, unsigned int packet)
+{
+	int _packet;
+
+	/* oops..slight bug in the API. packet is an unsigned int, but we use
+	 * signed integers almost everywhere else. range-check and convert to
+	 * signed to avoid compiler warnings. FIXME for libusb-2. */
+	if (packet > INT_MAX)
+		return NULL;
+	_packet = (int) packet;
+
+	if (_packet >= transfer->num_iso_packets)
+		return NULL;
+
+	return transfer->buffer + ((int) transfer->iso_packet_desc[0].length * _packet);
+}
+
+/* sync I/O */
+
+int LIBUSB_CALL libusb_control_transfer(libusb_device_handle *dev_handle,
+	uint8_t request_type, uint8_t bRequest, uint16_t wValue, uint16_t wIndex,
+	unsigned char *data, uint16_t wLength, unsigned int timeout);
+
+int LIBUSB_CALL libusb_bulk_transfer(libusb_device_handle *dev_handle,
+	unsigned char endpoint, unsigned char *data, int length,
+	int *actual_length, unsigned int timeout);
+
+int LIBUSB_CALL libusb_interrupt_transfer(libusb_device_handle *dev_handle,
+	unsigned char endpoint, unsigned char *data, int length,
+	int *actual_length, unsigned int timeout);
+
+/** \ingroup libusb_desc
+ * Retrieve a descriptor from the default control pipe.
+ * This is a convenience function which formulates the appropriate control
+ * message to retrieve the descriptor.
+ *
+ * \param dev_handle a device handle
+ * \param desc_type the descriptor type, see \ref libusb_descriptor_type
+ * \param desc_index the index of the descriptor to retrieve
+ * \param data output buffer for descriptor
+ * \param length size of data buffer
+ * \returns number of bytes returned in data, or LIBUSB_ERROR code on failure
+ */
+static inline int libusb_get_descriptor(libusb_device_handle *dev_handle,
+	uint8_t desc_type, uint8_t desc_index, unsigned char *data, int length)
+{
+	return libusb_control_transfer(dev_handle, LIBUSB_ENDPOINT_IN,
+		LIBUSB_REQUEST_GET_DESCRIPTOR, (uint16_t) ((desc_type << 8) | desc_index),
+		0, data, (uint16_t) length, 1000);
+}
+
+/** \ingroup libusb_desc
+ * Retrieve a descriptor from a device.
+ * This is a convenience function which formulates the appropriate control
+ * message to retrieve the descriptor. The string returned is Unicode, as
+ * detailed in the USB specifications.
+ *
+ * \param dev_handle a device handle
+ * \param desc_index the index of the descriptor to retrieve
+ * \param langid the language ID for the string descriptor
+ * \param data output buffer for descriptor
+ * \param length size of data buffer
+ * \returns number of bytes returned in data, or LIBUSB_ERROR code on failure
+ * \see libusb_get_string_descriptor_ascii()
+ */
+static inline int libusb_get_string_descriptor(libusb_device_handle *dev_handle,
+	uint8_t desc_index, uint16_t langid, unsigned char *data, int length)
+{
+	return libusb_control_transfer(dev_handle, LIBUSB_ENDPOINT_IN,
+		LIBUSB_REQUEST_GET_DESCRIPTOR, (uint16_t)((LIBUSB_DT_STRING << 8) | desc_index),
+		langid, data, (uint16_t) length, 1000);
+}
+
+int LIBUSB_CALL libusb_get_string_descriptor_ascii(libusb_device_handle *dev_handle,
+	uint8_t desc_index, unsigned char *data, int length);
+
+/* polling and timeouts */
+
+int LIBUSB_CALL libusb_try_lock_events(libusb_context *ctx);
+void LIBUSB_CALL libusb_lock_events(libusb_context *ctx);
+void LIBUSB_CALL libusb_unlock_events(libusb_context *ctx);
+int LIBUSB_CALL libusb_event_handling_ok(libusb_context *ctx);
+int LIBUSB_CALL libusb_event_handler_active(libusb_context *ctx);
+void LIBUSB_CALL libusb_interrupt_event_handler(libusb_context *ctx);
+void LIBUSB_CALL libusb_lock_event_waiters(libusb_context *ctx);
+void LIBUSB_CALL libusb_unlock_event_waiters(libusb_context *ctx);
+int LIBUSB_CALL libusb_wait_for_event(libusb_context *ctx, struct timeval *tv);
+
+int LIBUSB_CALL libusb_handle_events_timeout(libusb_context *ctx,
+	struct timeval *tv);
+int LIBUSB_CALL libusb_handle_events_timeout_completed(libusb_context *ctx,
+	struct timeval *tv, int *completed);
+int LIBUSB_CALL libusb_handle_events(libusb_context *ctx);
+int LIBUSB_CALL libusb_handle_events_completed(libusb_context *ctx, int *completed);
+int LIBUSB_CALL libusb_handle_events_locked(libusb_context *ctx,
+	struct timeval *tv);
+int LIBUSB_CALL libusb_pollfds_handle_timeouts(libusb_context *ctx);
+int LIBUSB_CALL libusb_get_next_timeout(libusb_context *ctx,
+	struct timeval *tv);
+
+/** \ingroup libusb_poll
+ * File descriptor for polling
+ */
+struct libusb_pollfd {
+	/** Numeric file descriptor */
+	int fd;
+
+	/** Event flags to poll for from <poll.h>. POLLIN indicates that you
+	 * should monitor this file descriptor for becoming ready to read from,
+	 * and POLLOUT indicates that you should monitor this file descriptor for
+	 * nonblocking write readiness. */
+	short events;
+};
+
+/** \ingroup libusb_poll
+ * Callback function, invoked when a new file descriptor should be added
+ * to the set of file descriptors monitored for events.
+ * \param fd the new file descriptor
+ * \param events events to monitor for, see \ref libusb_pollfd for a
+ * description
+ * \param user_data User data pointer specified in
+ * libusb_set_pollfd_notifiers() call
+ * \see libusb_set_pollfd_notifiers()
+ */
+typedef void (LIBUSB_CALL *libusb_pollfd_added_cb)(int fd, short events,
+	void *user_data);
+
+/** \ingroup libusb_poll
+ * Callback function, invoked when a file descriptor should be removed from
+ * the set of file descriptors being monitored for events. After returning
+ * from this callback, do not use that file descriptor again.
+ * \param fd the file descriptor to stop monitoring
+ * \param user_data User data pointer specified in
+ * libusb_set_pollfd_notifiers() call
+ * \see libusb_set_pollfd_notifiers()
+ */
+typedef void (LIBUSB_CALL *libusb_pollfd_removed_cb)(int fd, void *user_data);
+
+const struct libusb_pollfd ** LIBUSB_CALL libusb_get_pollfds(
+	libusb_context *ctx);
+void LIBUSB_CALL libusb_free_pollfds(const struct libusb_pollfd **pollfds);
+void LIBUSB_CALL libusb_set_pollfd_notifiers(libusb_context *ctx,
+	libusb_pollfd_added_cb added_cb, libusb_pollfd_removed_cb removed_cb,
+	void *user_data);
+
+/** \ingroup libusb_hotplug
+ * Callback handle.
+ *
+ * Callbacks handles are generated by libusb_hotplug_register_callback()
+ * and can be used to deregister callbacks. Callback handles are unique
+ * per libusb_context and it is safe to call libusb_hotplug_deregister_callback()
+ * on an already deregisted callback.
+ *
+ * Since version 1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102
+ *
+ * For more information, see \ref libusb_hotplug.
+ */
+typedef int libusb_hotplug_callback_handle;
+
+/** \ingroup libusb_hotplug
+ *
+ * Since version 1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102
+ *
+ * Flags for hotplug events */
+typedef enum {
+	/** Default value when not using any flags. */
+	LIBUSB_HOTPLUG_NO_FLAGS = 0,
+
+	/** Arm the callback and fire it for all matching currently attached devices. */
+	LIBUSB_HOTPLUG_ENUMERATE = 1<<0,
+} libusb_hotplug_flag;
+
+/** \ingroup libusb_hotplug
+ *
+ * Since version 1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102
+ *
+ * Hotplug events */
+typedef enum {
+	/** A device has been plugged in and is ready to use */
+	LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED = 0x01,
+
+	/** A device has left and is no longer available.
+	 * It is the user's responsibility to call libusb_close on any handle associated with a disconnected device.
+	 * It is safe to call libusb_get_device_descriptor on a device that has left */
+	LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT    = 0x02,
+} libusb_hotplug_event;
+
+/** \ingroup libusb_hotplug
+ * Wildcard matching for hotplug events */
+#define LIBUSB_HOTPLUG_MATCH_ANY -1
+
+/** \ingroup libusb_hotplug
+ * Hotplug callback function type. When requesting hotplug event notifications,
+ * you pass a pointer to a callback function of this type.
+ *
+ * This callback may be called by an internal event thread and as such it is
+ * recommended the callback do minimal processing before returning.
+ *
+ * libusb will call this function later, when a matching event had happened on
+ * a matching device. See \ref libusb_hotplug for more information.
+ *
+ * It is safe to call either libusb_hotplug_register_callback() or
+ * libusb_hotplug_deregister_callback() from within a callback function.
+ *
+ * Since version 1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102
+ *
+ * \param ctx            context of this notification
+ * \param device         libusb_device this event occurred on
+ * \param event          event that occurred
+ * \param user_data      user data provided when this callback was registered
+ * \returns bool whether this callback is finished processing events.
+ *                       returning 1 will cause this callback to be deregistered
+ */
+typedef int (LIBUSB_CALL *libusb_hotplug_callback_fn)(libusb_context *ctx,
+						libusb_device *device,
+						libusb_hotplug_event event,
+						void *user_data);
+
+/** \ingroup libusb_hotplug
+ * Register a hotplug callback function
+ *
+ * Register a callback with the libusb_context. The callback will fire
+ * when a matching event occurs on a matching device. The callback is
+ * armed until either it is deregistered with libusb_hotplug_deregister_callback()
+ * or the supplied callback returns 1 to indicate it is finished processing events.
+ *
+ * If the \ref LIBUSB_HOTPLUG_ENUMERATE is passed the callback will be
+ * called with a \ref LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED for all devices
+ * already plugged into the machine. Note that libusb modifies its internal
+ * device list from a separate thread, while calling hotplug callbacks from
+ * libusb_handle_events(), so it is possible for a device to already be present
+ * on, or removed from, its internal device list, while the hotplug callbacks
+ * still need to be dispatched. This means that when using \ref
+ * LIBUSB_HOTPLUG_ENUMERATE, your callback may be called twice for the arrival
+ * of the same device, once from libusb_hotplug_register_callback() and once
+ * from libusb_handle_events(); and/or your callback may be called for the
+ * removal of a device for which an arrived call was never made.
+ *
+ * Since version 1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102
+ *
+ * \param[in] ctx context to register this callback with
+ * \param[in] events bitwise or of events that will trigger this callback. See \ref
+ *            libusb_hotplug_event
+ * \param[in] flags hotplug callback flags. See \ref libusb_hotplug_flag
+ * \param[in] vendor_id the vendor id to match or \ref LIBUSB_HOTPLUG_MATCH_ANY
+ * \param[in] product_id the product id to match or \ref LIBUSB_HOTPLUG_MATCH_ANY
+ * \param[in] dev_class the device class to match or \ref LIBUSB_HOTPLUG_MATCH_ANY
+ * \param[in] cb_fn the function to be invoked on a matching event/device
+ * \param[in] user_data user data to pass to the callback function
+ * \param[out] callback_handle pointer to store the handle of the allocated callback (can be NULL)
+ * \returns LIBUSB_SUCCESS on success LIBUSB_ERROR code on failure
+ */
+int LIBUSB_CALL libusb_hotplug_register_callback(libusb_context *ctx,
+						libusb_hotplug_event events,
+						libusb_hotplug_flag flags,
+						int vendor_id, int product_id,
+						int dev_class,
+						libusb_hotplug_callback_fn cb_fn,
+						void *user_data,
+						libusb_hotplug_callback_handle *callback_handle);
+
+/** \ingroup libusb_hotplug
+ * Deregisters a hotplug callback.
+ *
+ * Deregister a callback from a libusb_context. This function is safe to call from within
+ * a hotplug callback.
+ *
+ * Since version 1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102
+ *
+ * \param[in] ctx context this callback is registered with
+ * \param[in] callback_handle the handle of the callback to deregister
+ */
+void LIBUSB_CALL libusb_hotplug_deregister_callback(libusb_context *ctx,
+						libusb_hotplug_callback_handle callback_handle);
+
+/** \ingroup libusb_lib
+ * Available option values for libusb_set_option().
+ */
+enum libusb_option {
+	/** Set the log message verbosity.
+	 *
+	 * The default level is LIBUSB_LOG_LEVEL_NONE, which means no messages are ever
+	 * printed. If you choose to increase the message verbosity level, ensure
+	 * that your application does not close the stderr file descriptor.
+	 *
+	 * You are advised to use level LIBUSB_LOG_LEVEL_WARNING. libusb is conservative
+	 * with its message logging and most of the time, will only log messages that
+	 * explain error conditions and other oddities. This will help you debug
+	 * your software.
+	 *
+	 * If the LIBUSB_DEBUG environment variable was set when libusb was
+	 * initialized, this function does nothing: the message verbosity is fixed
+	 * to the value in the environment variable.
+	 *
+	 * If libusb was compiled without any message logging, this function does
+	 * nothing: you'll never get any messages.
+	 *
+	 * If libusb was compiled with verbose debug message logging, this function
+	 * does nothing: you'll always get messages from all levels.
+	 */
+	LIBUSB_OPTION_LOG_LEVEL,
+
+	/** Use the UsbDk backend for a specific context, if available.
+	 *
+	 * This option should be set immediately after calling libusb_init(), otherwise
+	 * unspecified behavior may occur.
+	 *
+	 * Only valid on Windows.
+	 */
+	LIBUSB_OPTION_USE_USBDK,
+};
+
+int LIBUSB_CALL libusb_set_option(libusb_context *ctx, enum libusb_option option, ...);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/libusbi.h b/vendor/github.com/karalabe/usb/libusb/libusb/libusbi.h
new file mode 100644
index 000000000..31d6ce98d
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/libusbi.h
@@ -0,0 +1,1165 @@
+/*
+ * Internal header for libusb
+ * Copyright © 2007-2009 Daniel Drake <dsd@gentoo.org>
+ * Copyright © 2001 Johannes Erdfelt <johannes@erdfelt.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef LIBUSBI_H
+#define LIBUSBI_H
+
+#include <config.h>
+
+#include <stdlib.h>
+
+#include <stddef.h>
+#include <stdint.h>
+#include <time.h>
+#include <stdarg.h>
+#ifdef HAVE_POLL_H
+#include <poll.h>
+#endif
+#ifdef HAVE_MISSING_H
+#include <missing.h>
+#endif
+
+#include "libusb.h"
+#include "version.h"
+
+/* Attribute to ensure that a structure member is aligned to a natural
+ * pointer alignment. Used for os_priv member. */
+#if defined(_MSC_VER)
+#if defined(_WIN64)
+#define PTR_ALIGNED __declspec(align(8))
+#else
+#define PTR_ALIGNED __declspec(align(4))
+#endif
+#elif defined(__GNUC__)
+#define PTR_ALIGNED __attribute__((aligned(sizeof(void *))))
+#else
+#define PTR_ALIGNED
+#endif
+
+/* Inside the libusb code, mark all public functions as follows:
+ *   return_type API_EXPORTED function_name(params) { ... }
+ * But if the function returns a pointer, mark it as follows:
+ *   DEFAULT_VISIBILITY return_type * LIBUSB_CALL function_name(params) { ... }
+ * In the libusb public header, mark all declarations as:
+ *   return_type LIBUSB_CALL function_name(params);
+ */
+#define API_EXPORTED LIBUSB_CALL DEFAULT_VISIBILITY
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define DEVICE_DESC_LENGTH	18
+
+#define USB_MAXENDPOINTS	32
+#define USB_MAXINTERFACES	32
+#define USB_MAXCONFIG		8
+
+/* Backend specific capabilities */
+#define USBI_CAP_HAS_HID_ACCESS			0x00010000
+#define USBI_CAP_SUPPORTS_DETACH_KERNEL_DRIVER	0x00020000
+
+/* Maximum number of bytes in a log line */
+#define USBI_MAX_LOG_LEN	1024
+/* Terminator for log lines */
+#define USBI_LOG_LINE_END	"\n"
+
+/* The following is used to silence warnings for unused variables */
+#define UNUSED(var)		do { (void)(var); } while(0)
+
+#if !defined(ARRAYSIZE)
+#define ARRAYSIZE(array) (sizeof(array) / sizeof(array[0]))
+#endif
+
+struct list_head {
+	struct list_head *prev, *next;
+};
+
+/* Get an entry from the list
+ *  ptr - the address of this list_head element in "type"
+ *  type - the data type that contains "member"
+ *  member - the list_head element in "type"
+ */
+#define list_entry(ptr, type, member) \
+	((type *)((uintptr_t)(ptr) - (uintptr_t)offsetof(type, member)))
+
+#define list_first_entry(ptr, type, member) \
+	list_entry((ptr)->next, type, member)
+
+/* Get each entry from a list
+ *  pos - A structure pointer has a "member" element
+ *  head - list head
+ *  member - the list_head element in "pos"
+ *  type - the type of the first parameter
+ */
+#define list_for_each_entry(pos, head, member, type)			\
+	for (pos = list_entry((head)->next, type, member);		\
+		 &pos->member != (head);				\
+		 pos = list_entry(pos->member.next, type, member))
+
+#define list_for_each_entry_safe(pos, n, head, member, type)		\
+	for (pos = list_entry((head)->next, type, member),		\
+		 n = list_entry(pos->member.next, type, member);	\
+		 &pos->member != (head);				\
+		 pos = n, n = list_entry(n->member.next, type, member))
+
+#define list_empty(entry) ((entry)->next == (entry))
+
+static inline void list_init(struct list_head *entry)
+{
+	entry->prev = entry->next = entry;
+}
+
+static inline void list_add(struct list_head *entry, struct list_head *head)
+{
+	entry->next = head->next;
+	entry->prev = head;
+
+	head->next->prev = entry;
+	head->next = entry;
+}
+
+static inline void list_add_tail(struct list_head *entry,
+	struct list_head *head)
+{
+	entry->next = head;
+	entry->prev = head->prev;
+
+	head->prev->next = entry;
+	head->prev = entry;
+}
+
+static inline void list_del(struct list_head *entry)
+{
+	entry->next->prev = entry->prev;
+	entry->prev->next = entry->next;
+	entry->next = entry->prev = NULL;
+}
+
+static inline void list_cut(struct list_head *list, struct list_head *head)
+{
+	if (list_empty(head))
+		return;
+
+	list->next = head->next;
+	list->next->prev = list;
+	list->prev = head->prev;
+	list->prev->next = list;
+
+	list_init(head);
+}
+
+static inline void *usbi_reallocf(void *ptr, size_t size)
+{
+	void *ret = realloc(ptr, size);
+	if (!ret)
+		free(ptr);
+	return ret;
+}
+
+#define container_of(ptr, type, member) ({			\
+	const typeof( ((type *)0)->member ) *mptr = (ptr);	\
+	(type *)( (char *)mptr - offsetof(type,member) );})
+
+#ifndef CLAMP
+#define CLAMP(val, min, max) ((val) < (min) ? (min) : ((val) > (max) ? (max) : (val)))
+#endif
+#ifndef MIN
+#define MIN(a, b)	((a) < (b) ? (a) : (b))
+#endif
+#ifndef MAX
+#define MAX(a, b)	((a) > (b) ? (a) : (b))
+#endif
+
+#define TIMESPEC_IS_SET(ts) ((ts)->tv_sec != 0 || (ts)->tv_nsec != 0)
+
+#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
+#define TIMEVAL_TV_SEC_TYPE	long
+#else
+#define TIMEVAL_TV_SEC_TYPE	time_t
+#endif
+
+/* Some platforms don't have this define */
+#ifndef TIMESPEC_TO_TIMEVAL
+#define TIMESPEC_TO_TIMEVAL(tv, ts)					\
+	do {								\
+		(tv)->tv_sec = (TIMEVAL_TV_SEC_TYPE) (ts)->tv_sec;	\
+		(tv)->tv_usec = (ts)->tv_nsec / 1000;			\
+	} while (0)
+#endif
+
+#ifdef ENABLE_LOGGING
+
+#if defined(_MSC_VER) && (_MSC_VER < 1900)
+#define snprintf usbi_snprintf
+#define vsnprintf usbi_vsnprintf
+int usbi_snprintf(char *dst, size_t size, const char *format, ...);
+int usbi_vsnprintf(char *dst, size_t size, const char *format, va_list ap);
+#define LIBUSB_PRINTF_WIN32
+#endif /* defined(_MSC_VER) && (_MSC_VER < 1900) */
+
+void usbi_log(struct libusb_context *ctx, enum libusb_log_level level,
+	const char *function, const char *format, ...);
+
+void usbi_log_v(struct libusb_context *ctx, enum libusb_log_level level,
+	const char *function, const char *format, va_list args);
+
+#if !defined(_MSC_VER) || (_MSC_VER >= 1400)
+
+#define _usbi_log(ctx, level, ...) usbi_log(ctx, level, __FUNCTION__, __VA_ARGS__)
+
+#define usbi_err(ctx, ...) _usbi_log(ctx, LIBUSB_LOG_LEVEL_ERROR, __VA_ARGS__)
+#define usbi_warn(ctx, ...) _usbi_log(ctx, LIBUSB_LOG_LEVEL_WARNING, __VA_ARGS__)
+#define usbi_info(ctx, ...) _usbi_log(ctx, LIBUSB_LOG_LEVEL_INFO, __VA_ARGS__)
+#define usbi_dbg(...) _usbi_log(NULL, LIBUSB_LOG_LEVEL_DEBUG, __VA_ARGS__)
+
+#else /* !defined(_MSC_VER) || (_MSC_VER >= 1400) */
+
+#define LOG_BODY(ctxt, level)				\
+{							\
+	va_list args;					\
+	va_start(args, format);				\
+	usbi_log_v(ctxt, level, "", format, args);	\
+	va_end(args);					\
+}
+
+static inline void usbi_err(struct libusb_context *ctx, const char *format, ...)
+	LOG_BODY(ctx, LIBUSB_LOG_LEVEL_ERROR)
+static inline void usbi_warn(struct libusb_context *ctx, const char *format, ...)
+	LOG_BODY(ctx, LIBUSB_LOG_LEVEL_WARNING)
+static inline void usbi_info(struct libusb_context *ctx, const char *format, ...)
+	LOG_BODY(ctx, LIBUSB_LOG_LEVEL_INFO)
+static inline void usbi_dbg(const char *format, ...)
+	LOG_BODY(NULL, LIBUSB_LOG_LEVEL_DEBUG)
+
+#endif /* !defined(_MSC_VER) || (_MSC_VER >= 1400) */
+
+#else /* ENABLE_LOGGING */
+
+#define usbi_err(ctx, ...) do { (void)ctx; } while (0)
+#define usbi_warn(ctx, ...) do { (void)ctx; } while (0)
+#define usbi_info(ctx, ...) do { (void)ctx; } while (0)
+#define usbi_dbg(...) do {} while (0)
+
+#endif /* ENABLE_LOGGING */
+
+#define USBI_GET_CONTEXT(ctx)				\
+	do {						\
+		if (!(ctx))				\
+			(ctx) = usbi_default_context;	\
+	} while(0)
+
+#define DEVICE_CTX(dev)		((dev)->ctx)
+#define HANDLE_CTX(handle)	(DEVICE_CTX((handle)->dev))
+#define TRANSFER_CTX(transfer)	(HANDLE_CTX((transfer)->dev_handle))
+#define ITRANSFER_CTX(transfer) \
+	(TRANSFER_CTX(USBI_TRANSFER_TO_LIBUSB_TRANSFER(transfer)))
+
+#define IS_EPIN(ep)		(0 != ((ep) & LIBUSB_ENDPOINT_IN))
+#define IS_EPOUT(ep)		(!IS_EPIN(ep))
+#define IS_XFERIN(xfer)		(0 != ((xfer)->endpoint & LIBUSB_ENDPOINT_IN))
+#define IS_XFEROUT(xfer)	(!IS_XFERIN(xfer))
+
+/* Internal abstraction for thread synchronization */
+#if defined(THREADS_POSIX)
+#include "os/threads_posix.h"
+#elif defined(OS_WINDOWS) || defined(OS_WINCE)
+#include "os/threads_windows.h"
+#endif
+
+extern struct libusb_context *usbi_default_context;
+
+/* Forward declaration for use in context (fully defined inside poll abstraction) */
+struct pollfd;
+
+struct libusb_context {
+#if defined(ENABLE_LOGGING) && !defined(ENABLE_DEBUG_LOGGING)
+	enum libusb_log_level debug;
+	int debug_fixed;
+#endif
+
+	/* internal event pipe, used for signalling occurrence of an internal event. */
+	int event_pipe[2];
+
+	struct list_head usb_devs;
+	usbi_mutex_t usb_devs_lock;
+
+	/* A list of open handles. Backends are free to traverse this if required.
+	 */
+	struct list_head open_devs;
+	usbi_mutex_t open_devs_lock;
+
+	/* A list of registered hotplug callbacks */
+	struct list_head hotplug_cbs;
+	libusb_hotplug_callback_handle next_hotplug_cb_handle;
+	usbi_mutex_t hotplug_cbs_lock;
+
+	/* this is a list of in-flight transfer handles, sorted by timeout
+	 * expiration. URBs to timeout the soonest are placed at the beginning of
+	 * the list, URBs that will time out later are placed after, and urbs with
+	 * infinite timeout are always placed at the very end. */
+	struct list_head flying_transfers;
+	/* Note paths taking both this and usbi_transfer->lock must always
+	 * take this lock first */
+	usbi_mutex_t flying_transfers_lock;
+
+	/* user callbacks for pollfd changes */
+	libusb_pollfd_added_cb fd_added_cb;
+	libusb_pollfd_removed_cb fd_removed_cb;
+	void *fd_cb_user_data;
+
+	/* ensures that only one thread is handling events at any one time */
+	usbi_mutex_t events_lock;
+
+	/* used to see if there is an active thread doing event handling */
+	int event_handler_active;
+
+	/* A thread-local storage key to track which thread is performing event
+	 * handling */
+	usbi_tls_key_t event_handling_key;
+
+	/* used to wait for event completion in threads other than the one that is
+	 * event handling */
+	usbi_mutex_t event_waiters_lock;
+	usbi_cond_t event_waiters_cond;
+
+	/* A lock to protect internal context event data. */
+	usbi_mutex_t event_data_lock;
+
+	/* A bitmask of flags that are set to indicate specific events that need to
+	 * be handled. Protected by event_data_lock. */
+	unsigned int event_flags;
+
+	/* A counter that is set when we want to interrupt and prevent event handling,
+	 * in order to safely close a device. Protected by event_data_lock. */
+	unsigned int device_close;
+
+	/* list and count of poll fds and an array of poll fd structures that is
+	 * (re)allocated as necessary prior to polling. Protected by event_data_lock. */
+	struct list_head ipollfds;
+	struct pollfd *pollfds;
+	POLL_NFDS_TYPE pollfds_cnt;
+
+	/* A list of pending hotplug messages. Protected by event_data_lock. */
+	struct list_head hotplug_msgs;
+
+	/* A list of pending completed transfers. Protected by event_data_lock. */
+	struct list_head completed_transfers;
+
+#ifdef USBI_TIMERFD_AVAILABLE
+	/* used for timeout handling, if supported by OS.
+	 * this timerfd is maintained to trigger on the next pending timeout */
+	int timerfd;
+#endif
+
+	struct list_head list;
+
+	PTR_ALIGNED unsigned char os_priv[ZERO_SIZED_ARRAY];
+};
+
+enum usbi_event_flags {
+	/* The list of pollfds has been modified */
+	USBI_EVENT_POLLFDS_MODIFIED = 1 << 0,
+
+	/* The user has interrupted the event handler */
+	USBI_EVENT_USER_INTERRUPT = 1 << 1,
+
+	/* A hotplug callback deregistration is pending */
+	USBI_EVENT_HOTPLUG_CB_DEREGISTERED = 1 << 2,
+};
+
+/* Macros for managing event handling state */
+#define usbi_handling_events(ctx) \
+	(usbi_tls_key_get((ctx)->event_handling_key) != NULL)
+
+#define usbi_start_event_handling(ctx) \
+	usbi_tls_key_set((ctx)->event_handling_key, ctx)
+
+#define usbi_end_event_handling(ctx) \
+	usbi_tls_key_set((ctx)->event_handling_key, NULL)
+
+/* Update the following macro if new event sources are added */
+#define usbi_pending_events(ctx) \
+	((ctx)->event_flags || (ctx)->device_close \
+	 || !list_empty(&(ctx)->hotplug_msgs) || !list_empty(&(ctx)->completed_transfers))
+
+#ifdef USBI_TIMERFD_AVAILABLE
+#define usbi_using_timerfd(ctx) ((ctx)->timerfd >= 0)
+#else
+#define usbi_using_timerfd(ctx) (0)
+#endif
+
+struct libusb_device {
+	/* lock protects refcnt, everything else is finalized at initialization
+	 * time */
+	usbi_mutex_t lock;
+	int refcnt;
+
+	struct libusb_context *ctx;
+
+	uint8_t bus_number;
+	uint8_t port_number;
+	struct libusb_device* parent_dev;
+	uint8_t device_address;
+	uint8_t num_configurations;
+	enum libusb_speed speed;
+
+	struct list_head list;
+	unsigned long session_data;
+
+	struct libusb_device_descriptor device_descriptor;
+	int attached;
+
+	PTR_ALIGNED unsigned char os_priv[ZERO_SIZED_ARRAY];
+};
+
+struct libusb_device_handle {
+	/* lock protects claimed_interfaces */
+	usbi_mutex_t lock;
+	unsigned long claimed_interfaces;
+
+	struct list_head list;
+	struct libusb_device *dev;
+	int auto_detach_kernel_driver;
+
+	PTR_ALIGNED unsigned char os_priv[ZERO_SIZED_ARRAY];
+};
+
+enum {
+	USBI_CLOCK_MONOTONIC,
+	USBI_CLOCK_REALTIME
+};
+
+/* in-memory transfer layout:
+ *
+ * 1. struct usbi_transfer
+ * 2. struct libusb_transfer (which includes iso packets) [variable size]
+ * 3. os private data [variable size]
+ *
+ * from a libusb_transfer, you can get the usbi_transfer by rewinding the
+ * appropriate number of bytes.
+ * the usbi_transfer includes the number of allocated packets, so you can
+ * determine the size of the transfer and hence the start and length of the
+ * OS-private data.
+ */
+
+struct usbi_transfer {
+	int num_iso_packets;
+	struct list_head list;
+	struct list_head completed_list;
+	struct timeval timeout;
+	int transferred;
+	uint32_t stream_id;
+	uint8_t state_flags;   /* Protected by usbi_transfer->lock */
+	uint8_t timeout_flags; /* Protected by the flying_stransfers_lock */
+
+	/* this lock is held during libusb_submit_transfer() and
+	 * libusb_cancel_transfer() (allowing the OS backend to prevent duplicate
+	 * cancellation, submission-during-cancellation, etc). the OS backend
+	 * should also take this lock in the handle_events path, to prevent the user
+	 * cancelling the transfer from another thread while you are processing
+	 * its completion (presumably there would be races within your OS backend
+	 * if this were possible).
+	 * Note paths taking both this and the flying_transfers_lock must
+	 * always take the flying_transfers_lock first */
+	usbi_mutex_t lock;
+};
+
+enum usbi_transfer_state_flags {
+	/* Transfer successfully submitted by backend */
+	USBI_TRANSFER_IN_FLIGHT = 1 << 0,
+
+	/* Cancellation was requested via libusb_cancel_transfer() */
+	USBI_TRANSFER_CANCELLING = 1 << 1,
+
+	/* Operation on the transfer failed because the device disappeared */
+	USBI_TRANSFER_DEVICE_DISAPPEARED = 1 << 2,
+};
+
+enum usbi_transfer_timeout_flags {
+	/* Set by backend submit_transfer() if the OS handles timeout */
+	USBI_TRANSFER_OS_HANDLES_TIMEOUT = 1 << 0,
+
+	/* The transfer timeout has been handled */
+	USBI_TRANSFER_TIMEOUT_HANDLED = 1 << 1,
+
+	/* The transfer timeout was successfully processed */
+	USBI_TRANSFER_TIMED_OUT = 1 << 2,
+};
+
+#define USBI_TRANSFER_TO_LIBUSB_TRANSFER(transfer)			\
+	((struct libusb_transfer *)(((unsigned char *)(transfer))	\
+		+ sizeof(struct usbi_transfer)))
+#define LIBUSB_TRANSFER_TO_USBI_TRANSFER(transfer)			\
+	((struct usbi_transfer *)(((unsigned char *)(transfer))		\
+		- sizeof(struct usbi_transfer)))
+
+static inline void *usbi_transfer_get_os_priv(struct usbi_transfer *transfer)
+{
+	return ((unsigned char *)transfer) + sizeof(struct usbi_transfer)
+		+ sizeof(struct libusb_transfer)
+		+ (transfer->num_iso_packets
+			* sizeof(struct libusb_iso_packet_descriptor));
+}
+
+/* bus structures */
+
+/* All standard descriptors have these 2 fields in common */
+struct usb_descriptor_header {
+	uint8_t bLength;
+	uint8_t bDescriptorType;
+};
+
+/* shared data and functions */
+
+int usbi_io_init(struct libusb_context *ctx);
+void usbi_io_exit(struct libusb_context *ctx);
+
+struct libusb_device *usbi_alloc_device(struct libusb_context *ctx,
+	unsigned long session_id);
+struct libusb_device *usbi_get_device_by_session_id(struct libusb_context *ctx,
+	unsigned long session_id);
+int usbi_sanitize_device(struct libusb_device *dev);
+void usbi_handle_disconnect(struct libusb_device_handle *dev_handle);
+
+int usbi_handle_transfer_completion(struct usbi_transfer *itransfer,
+	enum libusb_transfer_status status);
+int usbi_handle_transfer_cancellation(struct usbi_transfer *transfer);
+void usbi_signal_transfer_completion(struct usbi_transfer *transfer);
+
+int usbi_parse_descriptor(const unsigned char *source, const char *descriptor,
+	void *dest, int host_endian);
+int usbi_device_cache_descriptor(libusb_device *dev);
+int usbi_get_config_index_by_value(struct libusb_device *dev,
+	uint8_t bConfigurationValue, int *idx);
+
+void usbi_connect_device (struct libusb_device *dev);
+void usbi_disconnect_device (struct libusb_device *dev);
+
+int usbi_signal_event(struct libusb_context *ctx);
+int usbi_clear_event(struct libusb_context *ctx);
+
+/* Internal abstraction for poll (needs struct usbi_transfer on Windows) */
+#if defined(OS_LINUX) || defined(OS_DARWIN) || defined(OS_OPENBSD) || defined(OS_NETBSD) ||\
+	defined(OS_HAIKU) || defined(OS_SUNOS)
+#include <unistd.h>
+#include "os/poll_posix.h"
+#elif defined(OS_WINDOWS) || defined(OS_WINCE)
+#include "os/poll_windows.h"
+#endif
+
+struct usbi_pollfd {
+	/* must come first */
+	struct libusb_pollfd pollfd;
+
+	struct list_head list;
+};
+
+int usbi_add_pollfd(struct libusb_context *ctx, int fd, short events);
+void usbi_remove_pollfd(struct libusb_context *ctx, int fd);
+
+/* device discovery */
+
+/* we traverse usbfs without knowing how many devices we are going to find.
+ * so we create this discovered_devs model which is similar to a linked-list
+ * which grows when required. it can be freed once discovery has completed,
+ * eliminating the need for a list node in the libusb_device structure
+ * itself. */
+struct discovered_devs {
+	size_t len;
+	size_t capacity;
+	struct libusb_device *devices[ZERO_SIZED_ARRAY];
+};
+
+struct discovered_devs *discovered_devs_append(
+	struct discovered_devs *discdevs, struct libusb_device *dev);
+
+/* OS abstraction */
+
+/* This is the interface that OS backends need to implement.
+ * All fields are mandatory, except ones explicitly noted as optional. */
+struct usbi_os_backend {
+	/* A human-readable name for your backend, e.g. "Linux usbfs" */
+	const char *name;
+
+	/* Binary mask for backend specific capabilities */
+	uint32_t caps;
+
+	/* Perform initialization of your backend. You might use this function
+	 * to determine specific capabilities of the system, allocate required
+	 * data structures for later, etc.
+	 *
+	 * This function is called when a libusb user initializes the library
+	 * prior to use.
+	 *
+	 * Return 0 on success, or a LIBUSB_ERROR code on failure.
+	 */
+	int (*init)(struct libusb_context *ctx);
+
+	/* Deinitialization. Optional. This function should destroy anything
+	 * that was set up by init.
+	 *
+	 * This function is called when the user deinitializes the library.
+	 */
+	void (*exit)(struct libusb_context *ctx);
+
+	/* Set a backend-specific option. Optional.
+	 *
+	 * This function is called when the user calls libusb_set_option() and
+	 * the option is not handled by the core library.
+	 *
+	 * Return 0 on success, or a LIBUSB_ERROR code on failure.
+	 */
+	int (*set_option)(struct libusb_context *ctx, enum libusb_option option,
+		va_list args);
+
+	/* Enumerate all the USB devices on the system, returning them in a list
+	 * of discovered devices.
+	 *
+	 * Your implementation should enumerate all devices on the system,
+	 * regardless of whether they have been seen before or not.
+	 *
+	 * When you have found a device, compute a session ID for it. The session
+	 * ID should uniquely represent that particular device for that particular
+	 * connection session since boot (i.e. if you disconnect and reconnect a
+	 * device immediately after, it should be assigned a different session ID).
+	 * If your OS cannot provide a unique session ID as described above,
+	 * presenting a session ID of (bus_number << 8 | device_address) should
+	 * be sufficient. Bus numbers and device addresses wrap and get reused,
+	 * but that is an unlikely case.
+	 *
+	 * After computing a session ID for a device, call
+	 * usbi_get_device_by_session_id(). This function checks if libusb already
+	 * knows about the device, and if so, it provides you with a reference
+	 * to a libusb_device structure for it.
+	 *
+	 * If usbi_get_device_by_session_id() returns NULL, it is time to allocate
+	 * a new device structure for the device. Call usbi_alloc_device() to
+	 * obtain a new libusb_device structure with reference count 1. Populate
+	 * the bus_number and device_address attributes of the new device, and
+	 * perform any other internal backend initialization you need to do. At
+	 * this point, you should be ready to provide device descriptors and so
+	 * on through the get_*_descriptor functions. Finally, call
+	 * usbi_sanitize_device() to perform some final sanity checks on the
+	 * device. Assuming all of the above succeeded, we can now continue.
+	 * If any of the above failed, remember to unreference the device that
+	 * was returned by usbi_alloc_device().
+	 *
+	 * At this stage we have a populated libusb_device structure (either one
+	 * that was found earlier, or one that we have just allocated and
+	 * populated). This can now be added to the discovered devices list
+	 * using discovered_devs_append(). Note that discovered_devs_append()
+	 * may reallocate the list, returning a new location for it, and also
+	 * note that reallocation can fail. Your backend should handle these
+	 * error conditions appropriately.
+	 *
+	 * This function should not generate any bus I/O and should not block.
+	 * If I/O is required (e.g. reading the active configuration value), it is
+	 * OK to ignore these suggestions :)
+	 *
+	 * This function is executed when the user wishes to retrieve a list
+	 * of USB devices connected to the system.
+	 *
+	 * If the backend has hotplug support, this function is not used!
+	 *
+	 * Return 0 on success, or a LIBUSB_ERROR code on failure.
+	 */
+	int (*get_device_list)(struct libusb_context *ctx,
+		struct discovered_devs **discdevs);
+
+	/* Apps which were written before hotplug support, may listen for
+	 * hotplug events on their own and call libusb_get_device_list on
+	 * device addition. In this case libusb_get_device_list will likely
+	 * return a list without the new device in there, as the hotplug
+	 * event thread will still be busy enumerating the device, which may
+	 * take a while, or may not even have seen the event yet.
+	 *
+	 * To avoid this libusb_get_device_list will call this optional
+	 * function for backends with hotplug support before copying
+	 * ctx->usb_devs to the user. In this function the backend should
+	 * ensure any pending hotplug events are fully processed before
+	 * returning.
+	 *
+	 * Optional, should be implemented by backends with hotplug support.
+	 */
+	void (*hotplug_poll)(void);
+
+	/* Open a device for I/O and other USB operations. The device handle
+	 * is preallocated for you, you can retrieve the device in question
+	 * through handle->dev.
+	 *
+	 * Your backend should allocate any internal resources required for I/O
+	 * and other operations so that those operations can happen (hopefully)
+	 * without hiccup. This is also a good place to inform libusb that it
+	 * should monitor certain file descriptors related to this device -
+	 * see the usbi_add_pollfd() function.
+	 *
+	 * This function should not generate any bus I/O and should not block.
+	 *
+	 * This function is called when the user attempts to obtain a device
+	 * handle for a device.
+	 *
+	 * Return:
+	 * - 0 on success
+	 * - LIBUSB_ERROR_ACCESS if the user has insufficient permissions
+	 * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since
+	 *   discovery
+	 * - another LIBUSB_ERROR code on other failure
+	 *
+	 * Do not worry about freeing the handle on failed open, the upper layers
+	 * do this for you.
+	 */
+	int (*open)(struct libusb_device_handle *dev_handle);
+
+	/* Close a device such that the handle cannot be used again. Your backend
+	 * should destroy any resources that were allocated in the open path.
+	 * This may also be a good place to call usbi_remove_pollfd() to inform
+	 * libusb of any file descriptors associated with this device that should
+	 * no longer be monitored.
+	 *
+	 * This function is called when the user closes a device handle.
+	 */
+	void (*close)(struct libusb_device_handle *dev_handle);
+
+	/* Retrieve the device descriptor from a device.
+	 *
+	 * The descriptor should be retrieved from memory, NOT via bus I/O to the
+	 * device. This means that you may have to cache it in a private structure
+	 * during get_device_list enumeration. Alternatively, you may be able
+	 * to retrieve it from a kernel interface (some Linux setups can do this)
+	 * still without generating bus I/O.
+	 *
+	 * This function is expected to write DEVICE_DESC_LENGTH (18) bytes into
+	 * buffer, which is guaranteed to be big enough.
+	 *
+	 * This function is called when sanity-checking a device before adding
+	 * it to the list of discovered devices, and also when the user requests
+	 * to read the device descriptor.
+	 *
+	 * This function is expected to return the descriptor in bus-endian format
+	 * (LE). If it returns the multi-byte values in host-endian format,
+	 * set the host_endian output parameter to "1".
+	 *
+	 * Return 0 on success or a LIBUSB_ERROR code on failure.
+	 */
+	int (*get_device_descriptor)(struct libusb_device *device,
+		unsigned char *buffer, int *host_endian);
+
+	/* Get the ACTIVE configuration descriptor for a device.
+	 *
+	 * The descriptor should be retrieved from memory, NOT via bus I/O to the
+	 * device. This means that you may have to cache it in a private structure
+	 * during get_device_list enumeration. You may also have to keep track
+	 * of which configuration is active when the user changes it.
+	 *
+	 * This function is expected to write len bytes of data into buffer, which
+	 * is guaranteed to be big enough. If you can only do a partial write,
+	 * return an error code.
+	 *
+	 * This function is expected to return the descriptor in bus-endian format
+	 * (LE). If it returns the multi-byte values in host-endian format,
+	 * set the host_endian output parameter to "1".
+	 *
+	 * Return:
+	 * - 0 on success
+	 * - LIBUSB_ERROR_NOT_FOUND if the device is in unconfigured state
+	 * - another LIBUSB_ERROR code on other failure
+	 */
+	int (*get_active_config_descriptor)(struct libusb_device *device,
+		unsigned char *buffer, size_t len, int *host_endian);
+
+	/* Get a specific configuration descriptor for a device.
+	 *
+	 * The descriptor should be retrieved from memory, NOT via bus I/O to the
+	 * device. This means that you may have to cache it in a private structure
+	 * during get_device_list enumeration.
+	 *
+	 * The requested descriptor is expressed as a zero-based index (i.e. 0
+	 * indicates that we are requesting the first descriptor). The index does
+	 * not (necessarily) equal the bConfigurationValue of the configuration
+	 * being requested.
+	 *
+	 * This function is expected to write len bytes of data into buffer, which
+	 * is guaranteed to be big enough. If you can only do a partial write,
+	 * return an error code.
+	 *
+	 * This function is expected to return the descriptor in bus-endian format
+	 * (LE). If it returns the multi-byte values in host-endian format,
+	 * set the host_endian output parameter to "1".
+	 *
+	 * Return the length read on success or a LIBUSB_ERROR code on failure.
+	 */
+	int (*get_config_descriptor)(struct libusb_device *device,
+		uint8_t config_index, unsigned char *buffer, size_t len,
+		int *host_endian);
+
+	/* Like get_config_descriptor but then by bConfigurationValue instead
+	 * of by index.
+	 *
+	 * Optional, if not present the core will call get_config_descriptor
+	 * for all configs until it finds the desired bConfigurationValue.
+	 *
+	 * Returns a pointer to the raw-descriptor in *buffer, this memory
+	 * is valid as long as device is valid.
+	 *
+	 * Returns the length of the returned raw-descriptor on success,
+	 * or a LIBUSB_ERROR code on failure.
+	 */
+	int (*get_config_descriptor_by_value)(struct libusb_device *device,
+		uint8_t bConfigurationValue, unsigned char **buffer,
+		int *host_endian);
+
+	/* Get the bConfigurationValue for the active configuration for a device.
+	 * Optional. This should only be implemented if you can retrieve it from
+	 * cache (don't generate I/O).
+	 *
+	 * If you cannot retrieve this from cache, either do not implement this
+	 * function, or return LIBUSB_ERROR_NOT_SUPPORTED. This will cause
+	 * libusb to retrieve the information through a standard control transfer.
+	 *
+	 * This function must be non-blocking.
+	 * Return:
+	 * - 0 on success
+	 * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since it
+	 *   was opened
+	 * - LIBUSB_ERROR_NOT_SUPPORTED if the value cannot be retrieved without
+	 *   blocking
+	 * - another LIBUSB_ERROR code on other failure.
+	 */
+	int (*get_configuration)(struct libusb_device_handle *dev_handle, int *config);
+
+	/* Set the active configuration for a device.
+	 *
+	 * A configuration value of -1 should put the device in unconfigured state.
+	 *
+	 * This function can block.
+	 *
+	 * Return:
+	 * - 0 on success
+	 * - LIBUSB_ERROR_NOT_FOUND if the configuration does not exist
+	 * - LIBUSB_ERROR_BUSY if interfaces are currently claimed (and hence
+	 *   configuration cannot be changed)
+	 * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since it
+	 *   was opened
+	 * - another LIBUSB_ERROR code on other failure.
+	 */
+	int (*set_configuration)(struct libusb_device_handle *dev_handle, int config);
+
+	/* Claim an interface. When claimed, the application can then perform
+	 * I/O to an interface's endpoints.
+	 *
+	 * This function should not generate any bus I/O and should not block.
+	 * Interface claiming is a logical operation that simply ensures that
+	 * no other drivers/applications are using the interface, and after
+	 * claiming, no other drivers/applications can use the interface because
+	 * we now "own" it.
+	 *
+	 * Return:
+	 * - 0 on success
+	 * - LIBUSB_ERROR_NOT_FOUND if the interface does not exist
+	 * - LIBUSB_ERROR_BUSY if the interface is in use by another driver/app
+	 * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since it
+	 *   was opened
+	 * - another LIBUSB_ERROR code on other failure
+	 */
+	int (*claim_interface)(struct libusb_device_handle *dev_handle, int interface_number);
+
+	/* Release a previously claimed interface.
+	 *
+	 * This function should also generate a SET_INTERFACE control request,
+	 * resetting the alternate setting of that interface to 0. It's OK for
+	 * this function to block as a result.
+	 *
+	 * You will only ever be asked to release an interface which was
+	 * successfully claimed earlier.
+	 *
+	 * Return:
+	 * - 0 on success
+	 * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since it
+	 *   was opened
+	 * - another LIBUSB_ERROR code on other failure
+	 */
+	int (*release_interface)(struct libusb_device_handle *dev_handle, int interface_number);
+
+	/* Set the alternate setting for an interface.
+	 *
+	 * You will only ever be asked to set the alternate setting for an
+	 * interface which was successfully claimed earlier.
+	 *
+	 * It's OK for this function to block.
+	 *
+	 * Return:
+	 * - 0 on success
+	 * - LIBUSB_ERROR_NOT_FOUND if the alternate setting does not exist
+	 * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since it
+	 *   was opened
+	 * - another LIBUSB_ERROR code on other failure
+	 */
+	int (*set_interface_altsetting)(struct libusb_device_handle *dev_handle,
+		int interface_number, int altsetting);
+
+	/* Clear a halt/stall condition on an endpoint.
+	 *
+	 * It's OK for this function to block.
+	 *
+	 * Return:
+	 * - 0 on success
+	 * - LIBUSB_ERROR_NOT_FOUND if the endpoint does not exist
+	 * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since it
+	 *   was opened
+	 * - another LIBUSB_ERROR code on other failure
+	 */
+	int (*clear_halt)(struct libusb_device_handle *dev_handle,
+		unsigned char endpoint);
+
+	/* Perform a USB port reset to reinitialize a device.
+	 *
+	 * If possible, the device handle should still be usable after the reset
+	 * completes, assuming that the device descriptors did not change during
+	 * reset and all previous interface state can be restored.
+	 *
+	 * If something changes, or you cannot easily locate/verify the resetted
+	 * device, return LIBUSB_ERROR_NOT_FOUND. This prompts the application
+	 * to close the old handle and re-enumerate the device.
+	 *
+	 * Return:
+	 * - 0 on success
+	 * - LIBUSB_ERROR_NOT_FOUND if re-enumeration is required, or if the device
+	 *   has been disconnected since it was opened
+	 * - another LIBUSB_ERROR code on other failure
+	 */
+	int (*reset_device)(struct libusb_device_handle *dev_handle);
+
+	/* Alloc num_streams usb3 bulk streams on the passed in endpoints */
+	int (*alloc_streams)(struct libusb_device_handle *dev_handle,
+		uint32_t num_streams, unsigned char *endpoints, int num_endpoints);
+
+	/* Free usb3 bulk streams allocated with alloc_streams */
+	int (*free_streams)(struct libusb_device_handle *dev_handle,
+		unsigned char *endpoints, int num_endpoints);
+
+	/* Allocate persistent DMA memory for the given device, suitable for
+	 * zerocopy. May return NULL on failure. Optional to implement.
+	 */
+	unsigned char *(*dev_mem_alloc)(struct libusb_device_handle *handle,
+		size_t len);
+
+	/* Free memory allocated by dev_mem_alloc. */
+	int (*dev_mem_free)(struct libusb_device_handle *handle,
+		unsigned char *buffer, size_t len);
+
+	/* Determine if a kernel driver is active on an interface. Optional.
+	 *
+	 * The presence of a kernel driver on an interface indicates that any
+	 * calls to claim_interface would fail with the LIBUSB_ERROR_BUSY code.
+	 *
+	 * Return:
+	 * - 0 if no driver is active
+	 * - 1 if a driver is active
+	 * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since it
+	 *   was opened
+	 * - another LIBUSB_ERROR code on other failure
+	 */
+	int (*kernel_driver_active)(struct libusb_device_handle *dev_handle,
+		int interface_number);
+
+	/* Detach a kernel driver from an interface. Optional.
+	 *
+	 * After detaching a kernel driver, the interface should be available
+	 * for claim.
+	 *
+	 * Return:
+	 * - 0 on success
+	 * - LIBUSB_ERROR_NOT_FOUND if no kernel driver was active
+	 * - LIBUSB_ERROR_INVALID_PARAM if the interface does not exist
+	 * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since it
+	 *   was opened
+	 * - another LIBUSB_ERROR code on other failure
+	 */
+	int (*detach_kernel_driver)(struct libusb_device_handle *dev_handle,
+		int interface_number);
+
+	/* Attach a kernel driver to an interface. Optional.
+	 *
+	 * Reattach a kernel driver to the device.
+	 *
+	 * Return:
+	 * - 0 on success
+	 * - LIBUSB_ERROR_NOT_FOUND if no kernel driver was active
+	 * - LIBUSB_ERROR_INVALID_PARAM if the interface does not exist
+	 * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since it
+	 *   was opened
+	 * - LIBUSB_ERROR_BUSY if a program or driver has claimed the interface,
+	 *   preventing reattachment
+	 * - another LIBUSB_ERROR code on other failure
+	 */
+	int (*attach_kernel_driver)(struct libusb_device_handle *dev_handle,
+		int interface_number);
+
+	/* Destroy a device. Optional.
+	 *
+	 * This function is called when the last reference to a device is
+	 * destroyed. It should free any resources allocated in the get_device_list
+	 * path.
+	 */
+	void (*destroy_device)(struct libusb_device *dev);
+
+	/* Submit a transfer. Your implementation should take the transfer,
+	 * morph it into whatever form your platform requires, and submit it
+	 * asynchronously.
+	 *
+	 * This function must not block.
+	 *
+	 * This function gets called with the flying_transfers_lock locked!
+	 *
+	 * Return:
+	 * - 0 on success
+	 * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+	 * - another LIBUSB_ERROR code on other failure
+	 */
+	int (*submit_transfer)(struct usbi_transfer *itransfer);
+
+	/* Cancel a previously submitted transfer.
+	 *
+	 * This function must not block. The transfer cancellation must complete
+	 * later, resulting in a call to usbi_handle_transfer_cancellation()
+	 * from the context of handle_events.
+	 */
+	int (*cancel_transfer)(struct usbi_transfer *itransfer);
+
+	/* Clear a transfer as if it has completed or cancelled, but do not
+	 * report any completion/cancellation to the library. You should free
+	 * all private data from the transfer as if you were just about to report
+	 * completion or cancellation.
+	 *
+	 * This function might seem a bit out of place. It is used when libusb
+	 * detects a disconnected device - it calls this function for all pending
+	 * transfers before reporting completion (with the disconnect code) to
+	 * the user. Maybe we can improve upon this internal interface in future.
+	 */
+	void (*clear_transfer_priv)(struct usbi_transfer *itransfer);
+
+	/* Handle any pending events on file descriptors. Optional.
+	 *
+	 * Provide this function when file descriptors directly indicate device
+	 * or transfer activity. If your backend does not have such file descriptors,
+	 * implement the handle_transfer_completion function below.
+	 *
+	 * This involves monitoring any active transfers and processing their
+	 * completion or cancellation.
+	 *
+	 * The function is passed an array of pollfd structures (size nfds)
+	 * as a result of the poll() system call. The num_ready parameter
+	 * indicates the number of file descriptors that have reported events
+	 * (i.e. the poll() return value). This should be enough information
+	 * for you to determine which actions need to be taken on the currently
+	 * active transfers.
+	 *
+	 * For any cancelled transfers, call usbi_handle_transfer_cancellation().
+	 * For completed transfers, call usbi_handle_transfer_completion().
+	 * For control/bulk/interrupt transfers, populate the "transferred"
+	 * element of the appropriate usbi_transfer structure before calling the
+	 * above functions. For isochronous transfers, populate the status and
+	 * transferred fields of the iso packet descriptors of the transfer.
+	 *
+	 * This function should also be able to detect disconnection of the
+	 * device, reporting that situation with usbi_handle_disconnect().
+	 *
+	 * When processing an event related to a transfer, you probably want to
+	 * take usbi_transfer.lock to prevent races. See the documentation for
+	 * the usbi_transfer structure.
+	 *
+	 * Return 0 on success, or a LIBUSB_ERROR code on failure.
+	 */
+	int (*handle_events)(struct libusb_context *ctx,
+		struct pollfd *fds, POLL_NFDS_TYPE nfds, int num_ready);
+
+	/* Handle transfer completion. Optional.
+	 *
+	 * Provide this function when there are no file descriptors available
+	 * that directly indicate device or transfer activity. If your backend does
+	 * have such file descriptors, implement the handle_events function above.
+	 *
+	 * Your backend must tell the library when a transfer has completed by
+	 * calling usbi_signal_transfer_completion(). You should store any private
+	 * information about the transfer and its completion status in the transfer's
+	 * private backend data.
+	 *
+	 * During event handling, this function will be called on each transfer for
+	 * which usbi_signal_transfer_completion() was called.
+	 *
+	 * For any cancelled transfers, call usbi_handle_transfer_cancellation().
+	 * For completed transfers, call usbi_handle_transfer_completion().
+	 * For control/bulk/interrupt transfers, populate the "transferred"
+	 * element of the appropriate usbi_transfer structure before calling the
+	 * above functions. For isochronous transfers, populate the status and
+	 * transferred fields of the iso packet descriptors of the transfer.
+	 *
+	 * Return 0 on success, or a LIBUSB_ERROR code on failure.
+	 */
+	int (*handle_transfer_completion)(struct usbi_transfer *itransfer);
+
+	/* Get time from specified clock. At least two clocks must be implemented
+	   by the backend: USBI_CLOCK_REALTIME, and USBI_CLOCK_MONOTONIC.
+
+	   Description of clocks:
+	     USBI_CLOCK_REALTIME : clock returns time since system epoch.
+	     USBI_CLOCK_MONOTONIC: clock returns time since unspecified start
+	                             time (usually boot).
+	 */
+	int (*clock_gettime)(int clkid, struct timespec *tp);
+
+#ifdef USBI_TIMERFD_AVAILABLE
+	/* clock ID of the clock that should be used for timerfd */
+	clockid_t (*get_timerfd_clockid)(void);
+#endif
+
+	/* Number of bytes to reserve for per-context private backend data.
+	 * This private data area is accessible through the "os_priv" field of
+	 * struct libusb_context. */
+	size_t context_priv_size;
+
+	/* Number of bytes to reserve for per-device private backend data.
+	 * This private data area is accessible through the "os_priv" field of
+	 * struct libusb_device. */
+	size_t device_priv_size;
+
+	/* Number of bytes to reserve for per-handle private backend data.
+	 * This private data area is accessible through the "os_priv" field of
+	 * struct libusb_device. */
+	size_t device_handle_priv_size;
+
+	/* Number of bytes to reserve for per-transfer private backend data.
+	 * This private data area is accessible by calling
+	 * usbi_transfer_get_os_priv() on the appropriate usbi_transfer instance.
+	 */
+	size_t transfer_priv_size;
+};
+
+extern const struct usbi_os_backend usbi_backend;
+
+extern struct list_head active_contexts_list;
+extern usbi_mutex_static_t active_contexts_lock;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/os/darwin_usb.c b/vendor/github.com/karalabe/usb/libusb/libusb/os/darwin_usb.c
new file mode 100644
index 000000000..35ea1c321
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/os/darwin_usb.c
@@ -0,0 +1,2142 @@
+/* -*- Mode: C; indent-tabs-mode:nil -*- */
+/*
+ * darwin backend for libusb 1.0
+ * Copyright © 2008-2017 Nathan Hjelm <hjelmn@users.sourceforge.net>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "config.h"
+#include <time.h>
+#include <ctype.h>
+#include <errno.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/sysctl.h>
+
+#include <mach/clock.h>
+#include <mach/clock_types.h>
+#include <mach/mach_host.h>
+#include <mach/mach_port.h>
+
+/* Suppress warnings about the use of the deprecated objc_registerThreadWithCollector
+ * function. Its use is also conditionalized to only older deployment targets. */
+#define OBJC_SILENCE_GC_DEPRECATIONS 1
+
+#include <AvailabilityMacros.h>
+#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060 && MAC_OS_X_VERSION_MIN_REQUIRED < 101200
+  #include <objc/objc-auto.h>
+#endif
+
+#if MAC_OS_X_VERSION_MIN_REQUIRED >= 101200
+/* Apple deprecated the darwin atomics in 10.12 in favor of C11 atomics */
+#include <stdatomic.h>
+#define libusb_darwin_atomic_fetch_add(x, y) atomic_fetch_add(x, y)
+
+_Atomic int32_t initCount = ATOMIC_VAR_INIT(0);
+#else
+/* use darwin atomics if the target is older than 10.12 */
+#include <libkern/OSAtomic.h>
+
+/* OSAtomicAdd32Barrier returns the new value */
+#define libusb_darwin_atomic_fetch_add(x, y) (OSAtomicAdd32Barrier(y, x) - y)
+
+static volatile int32_t initCount = 0;
+
+#endif
+
+/* On 10.12 and later, use newly available clock_*() functions */
+#if MAC_OS_X_VERSION_MIN_REQUIRED >= 101200
+#define OSX_USE_CLOCK_GETTIME 1
+#else
+#define OSX_USE_CLOCK_GETTIME 0
+#endif
+
+#include "darwin_usb.h"
+
+/* async event thread */
+static pthread_mutex_t libusb_darwin_at_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t  libusb_darwin_at_cond = PTHREAD_COND_INITIALIZER;
+
+static pthread_once_t darwin_init_once = PTHREAD_ONCE_INIT;
+
+#if !OSX_USE_CLOCK_GETTIME
+static clock_serv_t clock_realtime;
+static clock_serv_t clock_monotonic;
+#endif
+
+static CFRunLoopRef libusb_darwin_acfl = NULL; /* event cf loop */
+static CFRunLoopSourceRef libusb_darwin_acfls = NULL; /* shutdown signal for event cf loop */
+
+static usbi_mutex_t darwin_cached_devices_lock = PTHREAD_MUTEX_INITIALIZER;
+static struct list_head darwin_cached_devices = {&darwin_cached_devices, &darwin_cached_devices};
+static const char *darwin_device_class = kIOUSBDeviceClassName;
+
+#define DARWIN_CACHED_DEVICE(a) ((struct darwin_cached_device *) (((struct darwin_device_priv *)((a)->os_priv))->dev))
+
+/* async event thread */
+static pthread_t libusb_darwin_at;
+
+static int darwin_get_config_descriptor(struct libusb_device *dev, uint8_t config_index, unsigned char *buffer, size_t len, int *host_endian);
+static int darwin_claim_interface(struct libusb_device_handle *dev_handle, int iface);
+static int darwin_release_interface(struct libusb_device_handle *dev_handle, int iface);
+static int darwin_reset_device(struct libusb_device_handle *dev_handle);
+static void darwin_async_io_callback (void *refcon, IOReturn result, void *arg0);
+
+static int darwin_scan_devices(struct libusb_context *ctx);
+static int process_new_device (struct libusb_context *ctx, io_service_t service);
+
+#if defined(ENABLE_LOGGING)
+static const char *darwin_error_str (int result) {
+  static char string_buffer[50];
+  switch (result) {
+  case kIOReturnSuccess:
+    return "no error";
+  case kIOReturnNotOpen:
+    return "device not opened for exclusive access";
+  case kIOReturnNoDevice:
+    return "no connection to an IOService";
+  case kIOUSBNoAsyncPortErr:
+    return "no async port has been opened for interface";
+  case kIOReturnExclusiveAccess:
+    return "another process has device opened for exclusive access";
+  case kIOUSBPipeStalled:
+    return "pipe is stalled";
+  case kIOReturnError:
+    return "could not establish a connection to the Darwin kernel";
+  case kIOUSBTransactionTimeout:
+    return "transaction timed out";
+  case kIOReturnBadArgument:
+    return "invalid argument";
+  case kIOReturnAborted:
+    return "transaction aborted";
+  case kIOReturnNotResponding:
+    return "device not responding";
+  case kIOReturnOverrun:
+    return "data overrun";
+  case kIOReturnCannotWire:
+    return "physical memory can not be wired down";
+  case kIOReturnNoResources:
+    return "out of resources";
+  case kIOUSBHighSpeedSplitError:
+    return "high speed split error";
+  default:
+    snprintf(string_buffer, sizeof(string_buffer), "unknown error (0x%x)", result);
+    return string_buffer;
+  }
+}
+#endif
+
+static int darwin_to_libusb (int result) {
+  switch (result) {
+  case kIOReturnUnderrun:
+  case kIOReturnSuccess:
+    return LIBUSB_SUCCESS;
+  case kIOReturnNotOpen:
+  case kIOReturnNoDevice:
+    return LIBUSB_ERROR_NO_DEVICE;
+  case kIOReturnExclusiveAccess:
+    return LIBUSB_ERROR_ACCESS;
+  case kIOUSBPipeStalled:
+    return LIBUSB_ERROR_PIPE;
+  case kIOReturnBadArgument:
+    return LIBUSB_ERROR_INVALID_PARAM;
+  case kIOUSBTransactionTimeout:
+    return LIBUSB_ERROR_TIMEOUT;
+  case kIOReturnNotResponding:
+  case kIOReturnAborted:
+  case kIOReturnError:
+  case kIOUSBNoAsyncPortErr:
+  default:
+    return LIBUSB_ERROR_OTHER;
+  }
+}
+
+/* this function must be called with the darwin_cached_devices_lock held */
+static void darwin_deref_cached_device(struct darwin_cached_device *cached_dev) {
+  cached_dev->refcount--;
+  /* free the device and remove it from the cache */
+  if (0 == cached_dev->refcount) {
+    list_del(&cached_dev->list);
+
+    (*(cached_dev->device))->Release(cached_dev->device);
+    free (cached_dev);
+  }
+}
+
+static void darwin_ref_cached_device(struct darwin_cached_device *cached_dev) {
+  cached_dev->refcount++;
+}
+
+static int ep_to_pipeRef(struct libusb_device_handle *dev_handle, uint8_t ep, uint8_t *pipep, uint8_t *ifcp, struct darwin_interface **interface_out) {
+  struct darwin_device_handle_priv *priv = (struct darwin_device_handle_priv *)dev_handle->os_priv;
+
+  /* current interface */
+  struct darwin_interface *cInterface;
+
+  int8_t i, iface;
+
+  usbi_dbg ("converting ep address 0x%02x to pipeRef and interface", ep);
+
+  for (iface = 0 ; iface < USB_MAXINTERFACES ; iface++) {
+    cInterface = &priv->interfaces[iface];
+
+    if (dev_handle->claimed_interfaces & (1 << iface)) {
+      for (i = 0 ; i < cInterface->num_endpoints ; i++) {
+        if (cInterface->endpoint_addrs[i] == ep) {
+          *pipep = i + 1;
+
+          if (ifcp)
+            *ifcp = iface;
+
+          if (interface_out)
+            *interface_out = cInterface;
+
+          usbi_dbg ("pipe %d on interface %d matches", *pipep, iface);
+          return 0;
+        }
+      }
+    }
+  }
+
+  /* No pipe found with the correct endpoint address */
+  usbi_warn (HANDLE_CTX(dev_handle), "no pipeRef found with endpoint address 0x%02x.", ep);
+
+  return LIBUSB_ERROR_NOT_FOUND;
+}
+
+static int usb_setup_device_iterator (io_iterator_t *deviceIterator, UInt32 location) {
+  CFMutableDictionaryRef matchingDict = IOServiceMatching(darwin_device_class);
+
+  if (!matchingDict)
+    return kIOReturnError;
+
+  if (location) {
+    CFMutableDictionaryRef propertyMatchDict = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
+                                                                         &kCFTypeDictionaryKeyCallBacks,
+                                                                         &kCFTypeDictionaryValueCallBacks);
+
+    /* there are no unsigned CFNumber types so treat the value as signed. the OS seems to do this
+         internally (CFNumberType of locationID is kCFNumberSInt32Type) */
+    CFTypeRef locationCF = CFNumberCreate (NULL, kCFNumberSInt32Type, &location);
+
+    if (propertyMatchDict && locationCF) {
+      CFDictionarySetValue (propertyMatchDict, CFSTR(kUSBDevicePropertyLocationID), locationCF);
+      CFDictionarySetValue (matchingDict, CFSTR(kIOPropertyMatchKey), propertyMatchDict);
+    }
+    /* else we can still proceed as long as the caller accounts for the possibility of other devices in the iterator */
+
+    /* release our references as per the Create Rule */
+    if (propertyMatchDict)
+      CFRelease (propertyMatchDict);
+    if (locationCF)
+      CFRelease (locationCF);
+  }
+
+  return IOServiceGetMatchingServices(kIOMasterPortDefault, matchingDict, deviceIterator);
+}
+
+/* Returns 1 on success, 0 on failure. */
+static int get_ioregistry_value_number (io_service_t service, CFStringRef property, CFNumberType type, void *p) {
+  CFTypeRef cfNumber = IORegistryEntryCreateCFProperty (service, property, kCFAllocatorDefault, 0);
+  int ret = 0;
+
+  if (cfNumber) {
+    if (CFGetTypeID(cfNumber) == CFNumberGetTypeID()) {
+      ret = CFNumberGetValue(cfNumber, type, p);
+    }
+
+    CFRelease (cfNumber);
+  }
+
+  return ret;
+}
+
+static int get_ioregistry_value_data (io_service_t service, CFStringRef property, ssize_t size, void *p) {
+  CFTypeRef cfData = IORegistryEntryCreateCFProperty (service, property, kCFAllocatorDefault, 0);
+  int ret = 0;
+
+  if (cfData) {
+    if (CFGetTypeID (cfData) == CFDataGetTypeID ()) {
+      CFIndex length = CFDataGetLength (cfData);
+      if (length < size) {
+        size = length;
+      }
+
+      CFDataGetBytes (cfData, CFRangeMake(0, size), p);
+      ret = 1;
+    }
+
+    CFRelease (cfData);
+  }
+
+  return ret;
+}
+
+static usb_device_t **darwin_device_from_service (io_service_t service)
+{
+  io_cf_plugin_ref_t *plugInInterface = NULL;
+  usb_device_t **device;
+  kern_return_t result;
+  SInt32 score;
+
+  result = IOCreatePlugInInterfaceForService(service, kIOUSBDeviceUserClientTypeID,
+                                             kIOCFPlugInInterfaceID, &plugInInterface,
+                                             &score);
+
+  if (kIOReturnSuccess != result || !plugInInterface) {
+    usbi_dbg ("could not set up plugin for service: %s", darwin_error_str (result));
+    return NULL;
+  }
+
+  (void)(*plugInInterface)->QueryInterface(plugInInterface, CFUUIDGetUUIDBytes(DeviceInterfaceID),
+                                           (LPVOID)&device);
+  /* Use release instead of IODestroyPlugInInterface to avoid stopping IOServices associated with this device */
+  (*plugInInterface)->Release (plugInInterface);
+
+  return device;
+}
+
+static void darwin_devices_attached (void *ptr, io_iterator_t add_devices) {
+  UNUSED(ptr);
+  struct libusb_context *ctx;
+  io_service_t service;
+
+  usbi_mutex_lock(&active_contexts_lock);
+
+  while ((service = IOIteratorNext(add_devices))) {
+    /* add this device to each active context's device list */
+    list_for_each_entry(ctx, &active_contexts_list, list, struct libusb_context) {
+      process_new_device (ctx, service);
+    }
+
+    IOObjectRelease(service);
+  }
+
+  usbi_mutex_unlock(&active_contexts_lock);
+}
+
+static void darwin_devices_detached (void *ptr, io_iterator_t rem_devices) {
+  UNUSED(ptr);
+  struct libusb_device *dev = NULL;
+  struct libusb_context *ctx;
+  struct darwin_cached_device *old_device;
+
+  io_service_t device;
+  UInt64 session;
+  int ret;
+
+  usbi_mutex_lock(&active_contexts_lock);
+
+  while ((device = IOIteratorNext (rem_devices)) != 0) {
+    /* get the location from the i/o registry */
+    ret = get_ioregistry_value_number (device, CFSTR("sessionID"), kCFNumberSInt64Type, &session);
+    IOObjectRelease (device);
+    if (!ret)
+      continue;
+
+    /* we need to match darwin_ref_cached_device call made in darwin_get_cached_device function
+       otherwise no cached device will ever get freed */
+    usbi_mutex_lock(&darwin_cached_devices_lock);
+    list_for_each_entry(old_device, &darwin_cached_devices, list, struct darwin_cached_device) {
+      if (old_device->session == session) {
+        darwin_deref_cached_device (old_device);
+        break;
+      }
+    }
+    usbi_mutex_unlock(&darwin_cached_devices_lock);
+
+    list_for_each_entry(ctx, &active_contexts_list, list, struct libusb_context) {
+      usbi_dbg ("notifying context %p of device disconnect", ctx);
+
+      dev = usbi_get_device_by_session_id(ctx, (unsigned long) session);
+      if (dev) {
+        /* signal the core that this device has been disconnected. the core will tear down this device
+           when the reference count reaches 0 */
+        usbi_disconnect_device(dev);
+        libusb_unref_device(dev);
+      }
+    }
+  }
+
+  usbi_mutex_unlock(&active_contexts_lock);
+}
+
+static void darwin_hotplug_poll (void)
+{
+  /* not sure if 5 seconds will be too long/short but it should work ok */
+  mach_timespec_t timeout = {.tv_sec = 5, .tv_nsec = 0};
+
+  /* since a kernel thread may nodify the IOInterators used for
+   * hotplug notidication we can't just clear the iterators.
+   * instead just wait until all IOService providers are quiet */
+  (void) IOKitWaitQuiet (kIOMasterPortDefault, &timeout);
+}
+
+static void darwin_clear_iterator (io_iterator_t iter) {
+  io_service_t device;
+
+  while ((device = IOIteratorNext (iter)) != 0)
+    IOObjectRelease (device);
+}
+
+static void *darwin_event_thread_main (void *arg0) {
+  IOReturn kresult;
+  struct libusb_context *ctx = (struct libusb_context *)arg0;
+  CFRunLoopRef runloop;
+
+#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060
+  /* Set this thread's name, so it can be seen in the debugger
+     and crash reports. */
+  pthread_setname_np ("org.libusb.device-hotplug");
+#endif
+
+#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060 && MAC_OS_X_VERSION_MIN_REQUIRED < 101200
+  /* Tell the Objective-C garbage collector about this thread.
+     This is required because, unlike NSThreads, pthreads are
+     not automatically registered. Although we don't use
+     Objective-C, we use CoreFoundation, which does.
+     Garbage collection support was entirely removed in 10.12,
+     so don't bother there. */
+  objc_registerThreadWithCollector();
+#endif
+
+  /* hotplug (device arrival/removal) sources */
+  CFRunLoopSourceContext libusb_shutdown_cfsourcectx;
+  CFRunLoopSourceRef     libusb_notification_cfsource;
+  io_notification_port_t libusb_notification_port;
+  io_iterator_t          libusb_rem_device_iterator;
+  io_iterator_t          libusb_add_device_iterator;
+
+  usbi_dbg ("creating hotplug event source");
+
+  runloop = CFRunLoopGetCurrent ();
+  CFRetain (runloop);
+
+  /* add the shutdown cfsource to the run loop */
+  memset(&libusb_shutdown_cfsourcectx, 0, sizeof(libusb_shutdown_cfsourcectx));
+  libusb_shutdown_cfsourcectx.info = runloop;
+  libusb_shutdown_cfsourcectx.perform = (void (*)(void *))CFRunLoopStop;
+  libusb_darwin_acfls = CFRunLoopSourceCreate(NULL, 0, &libusb_shutdown_cfsourcectx);
+  CFRunLoopAddSource(runloop, libusb_darwin_acfls, kCFRunLoopDefaultMode);
+
+  /* add the notification port to the run loop */
+  libusb_notification_port     = IONotificationPortCreate (kIOMasterPortDefault);
+  libusb_notification_cfsource = IONotificationPortGetRunLoopSource (libusb_notification_port);
+  CFRunLoopAddSource(runloop, libusb_notification_cfsource, kCFRunLoopDefaultMode);
+
+  /* create notifications for removed devices */
+  kresult = IOServiceAddMatchingNotification (libusb_notification_port, kIOTerminatedNotification,
+                                              IOServiceMatching(darwin_device_class),
+                                              darwin_devices_detached,
+                                              ctx, &libusb_rem_device_iterator);
+
+  if (kresult != kIOReturnSuccess) {
+    usbi_err (ctx, "could not add hotplug event source: %s", darwin_error_str (kresult));
+
+    pthread_exit (NULL);
+  }
+
+  /* create notifications for attached devices */
+  kresult = IOServiceAddMatchingNotification(libusb_notification_port, kIOFirstMatchNotification,
+                                              IOServiceMatching(darwin_device_class),
+                                              darwin_devices_attached,
+                                              ctx, &libusb_add_device_iterator);
+
+  if (kresult != kIOReturnSuccess) {
+    usbi_err (ctx, "could not add hotplug event source: %s", darwin_error_str (kresult));
+
+    pthread_exit (NULL);
+  }
+
+  /* arm notifiers */
+  darwin_clear_iterator (libusb_rem_device_iterator);
+  darwin_clear_iterator (libusb_add_device_iterator);
+
+  usbi_dbg ("darwin event thread ready to receive events");
+
+  /* signal the main thread that the hotplug runloop has been created. */
+  pthread_mutex_lock (&libusb_darwin_at_mutex);
+  libusb_darwin_acfl = runloop;
+  pthread_cond_signal (&libusb_darwin_at_cond);
+  pthread_mutex_unlock (&libusb_darwin_at_mutex);
+
+  /* run the runloop */
+  CFRunLoopRun();
+
+  usbi_dbg ("darwin event thread exiting");
+
+  /* remove the notification cfsource */
+  CFRunLoopRemoveSource(runloop, libusb_notification_cfsource, kCFRunLoopDefaultMode);
+
+  /* remove the shutdown cfsource */
+  CFRunLoopRemoveSource(runloop, libusb_darwin_acfls, kCFRunLoopDefaultMode);
+
+  /* delete notification port */
+  IONotificationPortDestroy (libusb_notification_port);
+
+  /* delete iterators */
+  IOObjectRelease (libusb_rem_device_iterator);
+  IOObjectRelease (libusb_add_device_iterator);
+
+  CFRelease (libusb_darwin_acfls);
+  CFRelease (runloop);
+
+  libusb_darwin_acfls = NULL;
+  libusb_darwin_acfl = NULL;
+
+  pthread_exit (NULL);
+}
+
+/* cleanup function to destroy cached devices */
+static void __attribute__((destructor)) _darwin_finalize(void) {
+  struct darwin_cached_device *dev, *next;
+
+  usbi_mutex_lock(&darwin_cached_devices_lock);
+  list_for_each_entry_safe(dev, next, &darwin_cached_devices, list, struct darwin_cached_device) {
+    darwin_deref_cached_device(dev);
+  }
+  usbi_mutex_unlock(&darwin_cached_devices_lock);
+}
+
+static void darwin_check_version (void) {
+  /* adjust for changes in the USB stack in xnu 15 */
+  int sysctl_args[] = {CTL_KERN, KERN_OSRELEASE};
+  long version;
+  char version_string[256] = {'\0',};
+  size_t length = 256;
+
+  sysctl(sysctl_args, 2, version_string, &length, NULL, 0);
+
+  errno = 0;
+  version = strtol (version_string, NULL, 10);
+  if (0 == errno && version >= 15) {
+    darwin_device_class = "IOUSBHostDevice";
+  }
+}
+
+static int darwin_init(struct libusb_context *ctx) {
+  int rc;
+
+  rc = pthread_once (&darwin_init_once, darwin_check_version);
+  if (rc) {
+    return LIBUSB_ERROR_OTHER;
+  }
+
+  rc = darwin_scan_devices (ctx);
+  if (LIBUSB_SUCCESS != rc) {
+    return rc;
+  }
+
+  if (libusb_darwin_atomic_fetch_add (&initCount, 1) == 0) {
+#if !OSX_USE_CLOCK_GETTIME
+    /* create the clocks that will be used if clock_gettime() is not available */
+    host_name_port_t host_self;
+
+    host_self = mach_host_self();
+    host_get_clock_service(host_self, CALENDAR_CLOCK, &clock_realtime);
+    host_get_clock_service(host_self, SYSTEM_CLOCK, &clock_monotonic);
+    mach_port_deallocate(mach_task_self(), host_self);
+#endif
+
+    pthread_create (&libusb_darwin_at, NULL, darwin_event_thread_main, ctx);
+
+    pthread_mutex_lock (&libusb_darwin_at_mutex);
+    while (!libusb_darwin_acfl)
+      pthread_cond_wait (&libusb_darwin_at_cond, &libusb_darwin_at_mutex);
+    pthread_mutex_unlock (&libusb_darwin_at_mutex);
+  }
+
+  return rc;
+}
+
+static void darwin_exit (struct libusb_context *ctx) {
+  UNUSED(ctx);
+  if (libusb_darwin_atomic_fetch_add (&initCount, -1) == 1) {
+#if !OSX_USE_CLOCK_GETTIME
+    mach_port_deallocate(mach_task_self(), clock_realtime);
+    mach_port_deallocate(mach_task_self(), clock_monotonic);
+#endif
+
+    /* stop the event runloop and wait for the thread to terminate. */
+    CFRunLoopSourceSignal(libusb_darwin_acfls);
+    CFRunLoopWakeUp (libusb_darwin_acfl);
+    pthread_join (libusb_darwin_at, NULL);
+  }
+}
+
+static int darwin_get_device_descriptor(struct libusb_device *dev, unsigned char *buffer, int *host_endian) {
+  struct darwin_cached_device *priv = DARWIN_CACHED_DEVICE(dev);
+
+  /* return cached copy */
+  memmove (buffer, &(priv->dev_descriptor), DEVICE_DESC_LENGTH);
+
+  *host_endian = 0;
+
+  return 0;
+}
+
+static int get_configuration_index (struct libusb_device *dev, int config_value) {
+  struct darwin_cached_device *priv = DARWIN_CACHED_DEVICE(dev);
+  UInt8 i, numConfig;
+  IOUSBConfigurationDescriptorPtr desc;
+  IOReturn kresult;
+
+  /* is there a simpler way to determine the index? */
+  kresult = (*(priv->device))->GetNumberOfConfigurations (priv->device, &numConfig);
+  if (kresult != kIOReturnSuccess)
+    return darwin_to_libusb (kresult);
+
+  for (i = 0 ; i < numConfig ; i++) {
+    (*(priv->device))->GetConfigurationDescriptorPtr (priv->device, i, &desc);
+
+    if (desc->bConfigurationValue == config_value)
+      return i;
+  }
+
+  /* configuration not found */
+  return LIBUSB_ERROR_NOT_FOUND;
+}
+
+static int darwin_get_active_config_descriptor(struct libusb_device *dev, unsigned char *buffer, size_t len, int *host_endian) {
+  struct darwin_cached_device *priv = DARWIN_CACHED_DEVICE(dev);
+  int config_index;
+
+  if (0 == priv->active_config)
+    return LIBUSB_ERROR_NOT_FOUND;
+
+  config_index = get_configuration_index (dev, priv->active_config);
+  if (config_index < 0)
+    return config_index;
+
+  return darwin_get_config_descriptor (dev, config_index, buffer, len, host_endian);
+}
+
+static int darwin_get_config_descriptor(struct libusb_device *dev, uint8_t config_index, unsigned char *buffer, size_t len, int *host_endian) {
+  struct darwin_cached_device *priv = DARWIN_CACHED_DEVICE(dev);
+  IOUSBConfigurationDescriptorPtr desc;
+  IOReturn kresult;
+  int ret;
+
+  if (!priv || !priv->device)
+    return LIBUSB_ERROR_OTHER;
+
+  kresult = (*priv->device)->GetConfigurationDescriptorPtr (priv->device, config_index, &desc);
+  if (kresult == kIOReturnSuccess) {
+    /* copy descriptor */
+    if (libusb_le16_to_cpu(desc->wTotalLength) < len)
+      len = libusb_le16_to_cpu(desc->wTotalLength);
+
+    memmove (buffer, desc, len);
+
+    /* GetConfigurationDescriptorPtr returns the descriptor in USB bus order */
+    *host_endian = 0;
+  }
+
+  ret = darwin_to_libusb (kresult);
+  if (ret != LIBUSB_SUCCESS)
+    return ret;
+
+  return (int) len;
+}
+
+/* check whether the os has configured the device */
+static int darwin_check_configuration (struct libusb_context *ctx, struct darwin_cached_device *dev) {
+  usb_device_t **darwin_device = dev->device;
+
+  IOUSBConfigurationDescriptorPtr configDesc;
+  IOUSBFindInterfaceRequest request;
+  kern_return_t             kresult;
+  io_iterator_t             interface_iterator;
+  io_service_t              firstInterface;
+
+  if (dev->dev_descriptor.bNumConfigurations < 1) {
+    usbi_err (ctx, "device has no configurations");
+    return LIBUSB_ERROR_OTHER; /* no configurations at this speed so we can't use it */
+  }
+
+  /* checking the configuration of a root hub simulation takes ~1 s in 10.11. the device is
+     not usable anyway */
+  if (0x05ac == dev->dev_descriptor.idVendor && 0x8005 == dev->dev_descriptor.idProduct) {
+    usbi_dbg ("ignoring configuration on root hub simulation");
+    dev->active_config = 0;
+    return 0;
+  }
+
+  /* find the first configuration */
+  kresult = (*darwin_device)->GetConfigurationDescriptorPtr (darwin_device, 0, &configDesc);
+  dev->first_config = (kIOReturnSuccess == kresult) ? configDesc->bConfigurationValue : 1;
+
+  /* check if the device is already configured. there is probably a better way than iterating over the
+     to accomplish this (the trick is we need to avoid a call to GetConfigurations since buggy devices
+     might lock up on the device request) */
+
+  /* Setup the Interface Request */
+  request.bInterfaceClass    = kIOUSBFindInterfaceDontCare;
+  request.bInterfaceSubClass = kIOUSBFindInterfaceDontCare;
+  request.bInterfaceProtocol = kIOUSBFindInterfaceDontCare;
+  request.bAlternateSetting  = kIOUSBFindInterfaceDontCare;
+
+  kresult = (*(darwin_device))->CreateInterfaceIterator(darwin_device, &request, &interface_iterator);
+  if (kresult)
+    return darwin_to_libusb (kresult);
+
+  /* iterate once */
+  firstInterface = IOIteratorNext(interface_iterator);
+
+  /* done with the interface iterator */
+  IOObjectRelease(interface_iterator);
+
+  if (firstInterface) {
+    IOObjectRelease (firstInterface);
+
+    /* device is configured */
+    if (dev->dev_descriptor.bNumConfigurations == 1)
+      /* to avoid problems with some devices get the configurations value from the configuration descriptor */
+      dev->active_config = dev->first_config;
+    else
+      /* devices with more than one configuration should work with GetConfiguration */
+      (*darwin_device)->GetConfiguration (darwin_device, &dev->active_config);
+  } else
+    /* not configured */
+    dev->active_config = 0;
+  
+  usbi_dbg ("active config: %u, first config: %u", dev->active_config, dev->first_config);
+
+  return 0;
+}
+
+static int darwin_request_descriptor (usb_device_t **device, UInt8 desc, UInt8 desc_index, void *buffer, size_t buffer_size) {
+  IOUSBDevRequestTO req;
+
+  memset (buffer, 0, buffer_size);
+
+  /* Set up request for descriptor/ */
+  req.bmRequestType = USBmakebmRequestType(kUSBIn, kUSBStandard, kUSBDevice);
+  req.bRequest      = kUSBRqGetDescriptor;
+  req.wValue        = desc << 8;
+  req.wIndex        = desc_index;
+  req.wLength       = buffer_size;
+  req.pData         = buffer;
+  req.noDataTimeout = 20;
+  req.completionTimeout = 100;
+
+  return (*device)->DeviceRequestTO (device, &req);
+}
+
+static int darwin_cache_device_descriptor (struct libusb_context *ctx, struct darwin_cached_device *dev) {
+  usb_device_t **device = dev->device;
+  int retries = 1, delay = 30000;
+  int unsuspended = 0, try_unsuspend = 1, try_reconfigure = 1;
+  int is_open = 0;
+  int ret = 0, ret2;
+  UInt8 bDeviceClass;
+  UInt16 idProduct, idVendor;
+
+  dev->can_enumerate = 0;
+
+  (*device)->GetDeviceClass (device, &bDeviceClass);
+  (*device)->GetDeviceProduct (device, &idProduct);
+  (*device)->GetDeviceVendor (device, &idVendor);
+
+  /* According to Apple's documentation the device must be open for DeviceRequest but we may not be able to open some
+   * devices and Apple's USB Prober doesn't bother to open the device before issuing a descriptor request.  Still,
+   * to follow the spec as closely as possible, try opening the device */
+  is_open = ((*device)->USBDeviceOpenSeize(device) == kIOReturnSuccess);
+
+  do {
+    /**** retrieve device descriptor ****/
+    ret = darwin_request_descriptor (device, kUSBDeviceDesc, 0, &dev->dev_descriptor, sizeof(dev->dev_descriptor));
+
+    if (kIOReturnOverrun == ret && kUSBDeviceDesc == dev->dev_descriptor.bDescriptorType)
+      /* received an overrun error but we still received a device descriptor */
+      ret = kIOReturnSuccess;
+
+    if (kIOUSBVendorIDAppleComputer == idVendor) {
+      /* NTH: don't bother retrying or unsuspending Apple devices */
+      break;
+    }
+
+    if (kIOReturnSuccess == ret && (0 == dev->dev_descriptor.bNumConfigurations ||
+                                    0 == dev->dev_descriptor.bcdUSB)) {
+      /* work around for incorrectly configured devices */
+      if (try_reconfigure && is_open) {
+        usbi_dbg("descriptor appears to be invalid. resetting configuration before trying again...");
+
+        /* set the first configuration */
+        (*device)->SetConfiguration(device, 1);
+
+        /* don't try to reconfigure again */
+        try_reconfigure = 0;
+      }
+
+      ret = kIOUSBPipeStalled;
+    }
+
+    if (kIOReturnSuccess != ret && is_open && try_unsuspend) {
+      /* device may be suspended. unsuspend it and try again */
+#if DeviceVersion >= 320
+      UInt32 info = 0;
+
+      /* IOUSBFamily 320+ provides a way to detect device suspension but earlier versions do not */
+      (void)(*device)->GetUSBDeviceInformation (device, &info);
+
+      /* note that the device was suspended */
+      if (info & (1 << kUSBInformationDeviceIsSuspendedBit) || 0 == info)
+        try_unsuspend = 1;
+#endif
+
+      if (try_unsuspend) {
+        /* try to unsuspend the device */
+        ret2 = (*device)->USBDeviceSuspend (device, 0);
+        if (kIOReturnSuccess != ret2) {
+          /* prevent log spew from poorly behaving devices.  this indicates the
+             os actually had trouble communicating with the device */
+          usbi_dbg("could not retrieve device descriptor. failed to unsuspend: %s",darwin_error_str(ret2));
+        } else
+          unsuspended = 1;
+
+        try_unsuspend = 0;
+      }
+    }
+
+    if (kIOReturnSuccess != ret) {
+      usbi_dbg("kernel responded with code: 0x%08x. sleeping for %d ms before trying again", ret, delay/1000);
+      /* sleep for a little while before trying again */
+      nanosleep(&(struct timespec){delay / 1000000, (delay * 1000) % 1000000000UL}, NULL);
+    }
+  } while (kIOReturnSuccess != ret && retries--);
+
+  if (unsuspended)
+    /* resuspend the device */
+    (void)(*device)->USBDeviceSuspend (device, 1);
+
+  if (is_open)
+    (void) (*device)->USBDeviceClose (device);
+
+  if (ret != kIOReturnSuccess) {
+    /* a debug message was already printed out for this error */
+    if (LIBUSB_CLASS_HUB == bDeviceClass)
+      usbi_dbg ("could not retrieve device descriptor %.4x:%.4x: %s (%x). skipping device",
+                idVendor, idProduct, darwin_error_str (ret), ret);
+    else
+      usbi_warn (ctx, "could not retrieve device descriptor %.4x:%.4x: %s (%x). skipping device",
+                 idVendor, idProduct, darwin_error_str (ret), ret);
+    return darwin_to_libusb (ret);
+  }
+
+  /* catch buggy hubs (which appear to be virtual). Apple's own USB prober has problems with these devices. */
+  if (libusb_le16_to_cpu (dev->dev_descriptor.idProduct) != idProduct) {
+    /* not a valid device */
+    usbi_warn (ctx, "idProduct from iokit (%04x) does not match idProduct in descriptor (%04x). skipping device",
+               idProduct, libusb_le16_to_cpu (dev->dev_descriptor.idProduct));
+    return LIBUSB_ERROR_NO_DEVICE;
+  }
+
+  usbi_dbg ("cached device descriptor:");
+  usbi_dbg ("  bDescriptorType:    0x%02x", dev->dev_descriptor.bDescriptorType);
+  usbi_dbg ("  bcdUSB:             0x%04x", dev->dev_descriptor.bcdUSB);
+  usbi_dbg ("  bDeviceClass:       0x%02x", dev->dev_descriptor.bDeviceClass);
+  usbi_dbg ("  bDeviceSubClass:    0x%02x", dev->dev_descriptor.bDeviceSubClass);
+  usbi_dbg ("  bDeviceProtocol:    0x%02x", dev->dev_descriptor.bDeviceProtocol);
+  usbi_dbg ("  bMaxPacketSize0:    0x%02x", dev->dev_descriptor.bMaxPacketSize0);
+  usbi_dbg ("  idVendor:           0x%04x", dev->dev_descriptor.idVendor);
+  usbi_dbg ("  idProduct:          0x%04x", dev->dev_descriptor.idProduct);
+  usbi_dbg ("  bcdDevice:          0x%04x", dev->dev_descriptor.bcdDevice);
+  usbi_dbg ("  iManufacturer:      0x%02x", dev->dev_descriptor.iManufacturer);
+  usbi_dbg ("  iProduct:           0x%02x", dev->dev_descriptor.iProduct);
+  usbi_dbg ("  iSerialNumber:      0x%02x", dev->dev_descriptor.iSerialNumber);
+  usbi_dbg ("  bNumConfigurations: 0x%02x", dev->dev_descriptor.bNumConfigurations);
+
+  dev->can_enumerate = 1;
+
+  return LIBUSB_SUCCESS;
+}
+
+static int get_device_port (io_service_t service, UInt8 *port) {
+  kern_return_t result;
+  io_service_t parent;
+  int ret = 0;
+
+  if (get_ioregistry_value_number (service, CFSTR("PortNum"), kCFNumberSInt8Type, port)) {
+    return 1;
+  }
+
+  result = IORegistryEntryGetParentEntry (service, kIOServicePlane, &parent);
+  if (kIOReturnSuccess == result) {
+    ret = get_ioregistry_value_data (parent, CFSTR("port"), 1, port);
+    IOObjectRelease (parent);
+  }
+
+  return ret;
+}
+
+static int get_device_parent_sessionID(io_service_t service, UInt64 *parent_sessionID) {
+  kern_return_t result;
+  io_service_t parent;
+
+  /* Walk up the tree in the IOService plane until we find a parent that has a sessionID */
+  parent = service;
+  while((result = IORegistryEntryGetParentEntry (parent, kIOServicePlane, &parent)) == kIOReturnSuccess) {
+    if (get_ioregistry_value_number (parent, CFSTR("sessionID"), kCFNumberSInt64Type, parent_sessionID)) {
+        /* Success */
+        return 1;
+    }
+  }
+
+  /* We ran out of parents */
+  return 0;
+}
+
+static int darwin_get_cached_device(struct libusb_context *ctx, io_service_t service,
+                                    struct darwin_cached_device **cached_out) {
+  struct darwin_cached_device *new_device;
+  UInt64 sessionID = 0, parent_sessionID = 0;
+  int ret = LIBUSB_SUCCESS;
+  usb_device_t **device;
+  UInt8 port = 0;
+
+  /* get some info from the io registry */
+  (void) get_ioregistry_value_number (service, CFSTR("sessionID"), kCFNumberSInt64Type, &sessionID);
+  if (!get_device_port (service, &port)) {
+    usbi_dbg("could not get connected port number");
+  }
+
+  usbi_dbg("finding cached device for sessionID 0x%" PRIx64, sessionID);
+
+  if (get_device_parent_sessionID(service, &parent_sessionID)) {
+    usbi_dbg("parent sessionID: 0x%" PRIx64, parent_sessionID);
+  }
+
+  usbi_mutex_lock(&darwin_cached_devices_lock);
+  do {
+    *cached_out = NULL;
+
+    list_for_each_entry(new_device, &darwin_cached_devices, list, struct darwin_cached_device) {
+      usbi_dbg("matching sessionID 0x%" PRIx64 " against cached device with sessionID 0x%" PRIx64, sessionID, new_device->session);
+      if (new_device->session == sessionID) {
+        usbi_dbg("using cached device for device");
+        *cached_out = new_device;
+        break;
+      }
+    }
+
+    if (*cached_out)
+      break;
+
+    usbi_dbg("caching new device with sessionID 0x%" PRIx64, sessionID);
+
+    device = darwin_device_from_service (service);
+    if (!device) {
+      ret = LIBUSB_ERROR_NO_DEVICE;
+      break;
+    }
+
+    new_device = calloc (1, sizeof (*new_device));
+    if (!new_device) {
+      ret = LIBUSB_ERROR_NO_MEM;
+      break;
+    }
+
+    /* add this device to the cached device list */
+    list_add(&new_device->list, &darwin_cached_devices);
+
+    (*device)->GetDeviceAddress (device, (USBDeviceAddress *)&new_device->address);
+
+    /* keep a reference to this device */
+    darwin_ref_cached_device(new_device);
+
+    new_device->device = device;
+    new_device->session = sessionID;
+    (*device)->GetLocationID (device, &new_device->location);
+    new_device->port = port;
+    new_device->parent_session = parent_sessionID;
+
+    /* cache the device descriptor */
+    ret = darwin_cache_device_descriptor(ctx, new_device);
+    if (ret)
+      break;
+
+    if (new_device->can_enumerate) {
+      snprintf(new_device->sys_path, 20, "%03i-%04x-%04x-%02x-%02x", new_device->address,
+               new_device->dev_descriptor.idVendor, new_device->dev_descriptor.idProduct,
+               new_device->dev_descriptor.bDeviceClass, new_device->dev_descriptor.bDeviceSubClass);
+    }
+  } while (0);
+
+  usbi_mutex_unlock(&darwin_cached_devices_lock);
+
+  /* keep track of devices regardless of if we successfully enumerate them to
+     prevent them from being enumerated multiple times */
+
+  *cached_out = new_device;
+
+  return ret;
+}
+
+static int process_new_device (struct libusb_context *ctx, io_service_t service) {
+  struct darwin_device_priv *priv;
+  struct libusb_device *dev = NULL;
+  struct darwin_cached_device *cached_device;
+  UInt8 devSpeed;
+  int ret = 0;
+
+  do {
+    ret = darwin_get_cached_device (ctx, service, &cached_device);
+
+    if (ret < 0 || !cached_device->can_enumerate) {
+      return ret;
+    }
+
+    /* check current active configuration (and cache the first configuration value--
+       which may be used by claim_interface) */
+    ret = darwin_check_configuration (ctx, cached_device);
+    if (ret)
+      break;
+
+    usbi_dbg ("allocating new device in context %p for with session 0x%" PRIx64,
+              ctx, cached_device->session);
+
+    dev = usbi_alloc_device(ctx, (unsigned long) cached_device->session);
+    if (!dev) {
+      return LIBUSB_ERROR_NO_MEM;
+    }
+
+    priv = (struct darwin_device_priv *)dev->os_priv;
+
+    priv->dev = cached_device;
+    darwin_ref_cached_device (priv->dev);
+
+    if (cached_device->parent_session > 0) {
+      dev->parent_dev = usbi_get_device_by_session_id (ctx, (unsigned long) cached_device->parent_session);
+    } else {
+      dev->parent_dev = NULL;
+    }
+    dev->port_number    = cached_device->port;
+    dev->bus_number     = cached_device->location >> 24;
+    dev->device_address = cached_device->address;
+
+    (*(priv->dev->device))->GetDeviceSpeed (priv->dev->device, &devSpeed);
+
+    switch (devSpeed) {
+    case kUSBDeviceSpeedLow: dev->speed = LIBUSB_SPEED_LOW; break;
+    case kUSBDeviceSpeedFull: dev->speed = LIBUSB_SPEED_FULL; break;
+    case kUSBDeviceSpeedHigh: dev->speed = LIBUSB_SPEED_HIGH; break;
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
+    case kUSBDeviceSpeedSuper: dev->speed = LIBUSB_SPEED_SUPER; break;
+#endif
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 101200
+    case kUSBDeviceSpeedSuperPlus: dev->speed = LIBUSB_SPEED_SUPER_PLUS; break;
+#endif
+    default:
+      usbi_warn (ctx, "Got unknown device speed %d", devSpeed);
+    }
+
+    ret = usbi_sanitize_device (dev);
+    if (ret < 0)
+      break;
+
+    usbi_dbg ("found device with address %d port = %d parent = %p at %p", dev->device_address,
+              dev->port_number, (void *) dev->parent_dev, priv->dev->sys_path);
+  } while (0);
+
+  if (0 == ret) {
+    usbi_connect_device (dev);
+  } else {
+    libusb_unref_device (dev);
+  }
+
+  return ret;
+}
+
+static int darwin_scan_devices(struct libusb_context *ctx) {
+  io_iterator_t deviceIterator;
+  io_service_t service;
+  kern_return_t kresult;
+
+  kresult = usb_setup_device_iterator (&deviceIterator, 0);
+  if (kresult != kIOReturnSuccess)
+    return darwin_to_libusb (kresult);
+
+  while ((service = IOIteratorNext (deviceIterator))) {
+    (void) process_new_device (ctx, service);
+
+    IOObjectRelease(service);
+  }
+
+  IOObjectRelease(deviceIterator);
+
+  return 0;
+}
+
+static int darwin_open (struct libusb_device_handle *dev_handle) {
+  struct darwin_device_handle_priv *priv = (struct darwin_device_handle_priv *)dev_handle->os_priv;
+  struct darwin_cached_device *dpriv = DARWIN_CACHED_DEVICE(dev_handle->dev);
+  IOReturn kresult;
+
+  if (0 == dpriv->open_count) {
+    /* try to open the device */
+    kresult = (*(dpriv->device))->USBDeviceOpenSeize (dpriv->device);
+    if (kresult != kIOReturnSuccess) {
+      usbi_warn (HANDLE_CTX (dev_handle), "USBDeviceOpen: %s", darwin_error_str(kresult));
+
+      if (kIOReturnExclusiveAccess != kresult) {
+        return darwin_to_libusb (kresult);
+      }
+
+      /* it is possible to perform some actions on a device that is not open so do not return an error */
+      priv->is_open = 0;
+    } else {
+      priv->is_open = 1;
+    }
+
+    /* create async event source */
+    kresult = (*(dpriv->device))->CreateDeviceAsyncEventSource (dpriv->device, &priv->cfSource);
+    if (kresult != kIOReturnSuccess) {
+      usbi_err (HANDLE_CTX (dev_handle), "CreateDeviceAsyncEventSource: %s", darwin_error_str(kresult));
+
+      if (priv->is_open) {
+        (*(dpriv->device))->USBDeviceClose (dpriv->device);
+      }
+
+      priv->is_open = 0;
+
+      return darwin_to_libusb (kresult);
+    }
+
+    CFRetain (libusb_darwin_acfl);
+
+    /* add the cfSource to the aync run loop */
+    CFRunLoopAddSource(libusb_darwin_acfl, priv->cfSource, kCFRunLoopCommonModes);
+  }
+
+  /* device opened successfully */
+  dpriv->open_count++;
+
+  usbi_dbg ("device open for access");
+
+  return 0;
+}
+
+static void darwin_close (struct libusb_device_handle *dev_handle) {
+  struct darwin_device_handle_priv *priv = (struct darwin_device_handle_priv *)dev_handle->os_priv;
+  struct darwin_cached_device *dpriv = DARWIN_CACHED_DEVICE(dev_handle->dev);
+  IOReturn kresult;
+  int i;
+
+  if (dpriv->open_count == 0) {
+    /* something is probably very wrong if this is the case */
+    usbi_err (HANDLE_CTX (dev_handle), "Close called on a device that was not open!");
+    return;
+  }
+
+  dpriv->open_count--;
+
+  /* make sure all interfaces are released */
+  for (i = 0 ; i < USB_MAXINTERFACES ; i++)
+    if (dev_handle->claimed_interfaces & (1 << i))
+      libusb_release_interface (dev_handle, i);
+
+  if (0 == dpriv->open_count) {
+    /* delete the device's async event source */
+    if (priv->cfSource) {
+      CFRunLoopRemoveSource (libusb_darwin_acfl, priv->cfSource, kCFRunLoopDefaultMode);
+      CFRelease (priv->cfSource);
+      priv->cfSource = NULL;
+      CFRelease (libusb_darwin_acfl);
+    }
+
+    if (priv->is_open) {
+      /* close the device */
+      kresult = (*(dpriv->device))->USBDeviceClose(dpriv->device);
+      if (kresult) {
+        /* Log the fact that we had a problem closing the file, however failing a
+         * close isn't really an error, so return success anyway */
+        usbi_warn (HANDLE_CTX (dev_handle), "USBDeviceClose: %s", darwin_error_str(kresult));
+      }
+    }
+  }
+}
+
+static int darwin_get_configuration(struct libusb_device_handle *dev_handle, int *config) {
+  struct darwin_cached_device *dpriv = DARWIN_CACHED_DEVICE(dev_handle->dev);
+
+  *config = (int) dpriv->active_config;
+
+  return 0;
+}
+
+static int darwin_set_configuration(struct libusb_device_handle *dev_handle, int config) {
+  struct darwin_cached_device *dpriv = DARWIN_CACHED_DEVICE(dev_handle->dev);
+  IOReturn kresult;
+  int i;
+
+  /* Setting configuration will invalidate the interface, so we need
+     to reclaim it. First, dispose of existing interfaces, if any. */
+  for (i = 0 ; i < USB_MAXINTERFACES ; i++)
+    if (dev_handle->claimed_interfaces & (1 << i))
+      darwin_release_interface (dev_handle, i);
+
+  kresult = (*(dpriv->device))->SetConfiguration (dpriv->device, config);
+  if (kresult != kIOReturnSuccess)
+    return darwin_to_libusb (kresult);
+
+  /* Reclaim any interfaces. */
+  for (i = 0 ; i < USB_MAXINTERFACES ; i++)
+    if (dev_handle->claimed_interfaces & (1 << i))
+      darwin_claim_interface (dev_handle, i);
+
+  dpriv->active_config = config;
+
+  return 0;
+}
+
+static int darwin_get_interface (usb_device_t **darwin_device, uint8_t ifc, io_service_t *usbInterfacep) {
+  IOUSBFindInterfaceRequest request;
+  kern_return_t             kresult;
+  io_iterator_t             interface_iterator;
+  UInt8                     bInterfaceNumber;
+  int                       ret;
+
+  *usbInterfacep = IO_OBJECT_NULL;
+
+  /* Setup the Interface Request */
+  request.bInterfaceClass    = kIOUSBFindInterfaceDontCare;
+  request.bInterfaceSubClass = kIOUSBFindInterfaceDontCare;
+  request.bInterfaceProtocol = kIOUSBFindInterfaceDontCare;
+  request.bAlternateSetting  = kIOUSBFindInterfaceDontCare;
+
+  kresult = (*(darwin_device))->CreateInterfaceIterator(darwin_device, &request, &interface_iterator);
+  if (kresult)
+    return kresult;
+
+  while ((*usbInterfacep = IOIteratorNext(interface_iterator))) {
+    /* find the interface number */
+    ret = get_ioregistry_value_number (*usbInterfacep, CFSTR("bInterfaceNumber"), kCFNumberSInt8Type,
+                                       &bInterfaceNumber);
+
+    if (ret && bInterfaceNumber == ifc) {
+      break;
+    }
+
+    (void) IOObjectRelease (*usbInterfacep);
+  }
+
+  /* done with the interface iterator */
+  IOObjectRelease(interface_iterator);
+
+  return 0;
+}
+
+static int get_endpoints (struct libusb_device_handle *dev_handle, int iface) {
+  struct darwin_device_handle_priv *priv = (struct darwin_device_handle_priv *)dev_handle->os_priv;
+
+  /* current interface */
+  struct darwin_interface *cInterface = &priv->interfaces[iface];
+
+  kern_return_t kresult;
+
+  UInt8 numep, direction, number;
+  UInt8 dont_care1, dont_care3;
+  UInt16 dont_care2;
+  int rc;
+
+  usbi_dbg ("building table of endpoints.");
+
+  /* retrieve the total number of endpoints on this interface */
+  kresult = (*(cInterface->interface))->GetNumEndpoints(cInterface->interface, &numep);
+  if (kresult) {
+    usbi_err (HANDLE_CTX (dev_handle), "can't get number of endpoints for interface: %s", darwin_error_str(kresult));
+    return darwin_to_libusb (kresult);
+  }
+
+  /* iterate through pipe references */
+  for (int i = 1 ; i <= numep ; i++) {
+    kresult = (*(cInterface->interface))->GetPipeProperties(cInterface->interface, i, &direction, &number, &dont_care1,
+                                                            &dont_care2, &dont_care3);
+
+    if (kresult != kIOReturnSuccess) {
+      /* probably a buggy device. try to get the endpoint address from the descriptors */
+      struct libusb_config_descriptor *config;
+      const struct libusb_endpoint_descriptor *endpoint_desc;
+      UInt8 alt_setting;
+
+      kresult = (*(cInterface->interface))->GetAlternateSetting (cInterface->interface, &alt_setting);
+      if (kresult) {
+        usbi_err (HANDLE_CTX (dev_handle), "can't get alternate setting for interface");
+        return darwin_to_libusb (kresult);
+      }
+
+      rc = libusb_get_active_config_descriptor (dev_handle->dev, &config);
+      if (LIBUSB_SUCCESS != rc) {
+        return rc;
+      }
+
+      endpoint_desc = config->interface[iface].altsetting[alt_setting].endpoint + i - 1;
+
+      cInterface->endpoint_addrs[i - 1] = endpoint_desc->bEndpointAddress;
+    } else {
+      cInterface->endpoint_addrs[i - 1] = (((kUSBIn == direction) << kUSBRqDirnShift) | (number & LIBUSB_ENDPOINT_ADDRESS_MASK));
+    }
+
+    usbi_dbg ("interface: %i pipe %i: dir: %i number: %i", iface, i, cInterface->endpoint_addrs[i - 1] >> kUSBRqDirnShift,
+              cInterface->endpoint_addrs[i - 1] & LIBUSB_ENDPOINT_ADDRESS_MASK);
+  }
+
+  cInterface->num_endpoints = numep;
+
+  return 0;
+}
+
+static int darwin_claim_interface(struct libusb_device_handle *dev_handle, int iface) {
+  struct darwin_cached_device *dpriv = DARWIN_CACHED_DEVICE(dev_handle->dev);
+  struct darwin_device_handle_priv *priv = (struct darwin_device_handle_priv *)dev_handle->os_priv;
+  io_service_t          usbInterface = IO_OBJECT_NULL;
+  IOReturn kresult;
+  IOCFPlugInInterface **plugInInterface = NULL;
+  SInt32                score;
+
+  /* current interface */
+  struct darwin_interface *cInterface = &priv->interfaces[iface];
+
+  kresult = darwin_get_interface (dpriv->device, iface, &usbInterface);
+  if (kresult != kIOReturnSuccess)
+    return darwin_to_libusb (kresult);
+
+  /* make sure we have an interface */
+  if (!usbInterface && dpriv->first_config != 0) {
+    usbi_info (HANDLE_CTX (dev_handle), "no interface found; setting configuration: %d", dpriv->first_config);
+
+    /* set the configuration */
+    kresult = darwin_set_configuration (dev_handle, dpriv->first_config);
+    if (kresult != LIBUSB_SUCCESS) {
+      usbi_err (HANDLE_CTX (dev_handle), "could not set configuration");
+      return kresult;
+    }
+
+    kresult = darwin_get_interface (dpriv->device, iface, &usbInterface);
+    if (kresult) {
+      usbi_err (HANDLE_CTX (dev_handle), "darwin_get_interface: %s", darwin_error_str(kresult));
+      return darwin_to_libusb (kresult);
+    }
+  }
+
+  if (!usbInterface) {
+    usbi_err (HANDLE_CTX (dev_handle), "interface not found");
+    return LIBUSB_ERROR_NOT_FOUND;
+  }
+
+  /* get an interface to the device's interface */
+  kresult = IOCreatePlugInInterfaceForService (usbInterface, kIOUSBInterfaceUserClientTypeID,
+                                               kIOCFPlugInInterfaceID, &plugInInterface, &score);
+
+  /* ignore release error */
+  (void)IOObjectRelease (usbInterface);
+
+  if (kresult) {
+    usbi_err (HANDLE_CTX (dev_handle), "IOCreatePlugInInterfaceForService: %s", darwin_error_str(kresult));
+    return darwin_to_libusb (kresult);
+  }
+
+  if (!plugInInterface) {
+    usbi_err (HANDLE_CTX (dev_handle), "plugin interface not found");
+    return LIBUSB_ERROR_NOT_FOUND;
+  }
+
+  /* Do the actual claim */
+  kresult = (*plugInInterface)->QueryInterface(plugInInterface,
+                                               CFUUIDGetUUIDBytes(kIOUSBInterfaceInterfaceID),
+                                               (LPVOID)&cInterface->interface);
+  /* We no longer need the intermediate plug-in */
+  /* Use release instead of IODestroyPlugInInterface to avoid stopping IOServices associated with this device */
+  (*plugInInterface)->Release (plugInInterface);
+  if (kresult || !cInterface->interface) {
+    usbi_err (HANDLE_CTX (dev_handle), "QueryInterface: %s", darwin_error_str(kresult));
+    return darwin_to_libusb (kresult);
+  }
+
+  /* claim the interface */
+  kresult = (*(cInterface->interface))->USBInterfaceOpen(cInterface->interface);
+  if (kresult) {
+    usbi_err (HANDLE_CTX (dev_handle), "USBInterfaceOpen: %s", darwin_error_str(kresult));
+    return darwin_to_libusb (kresult);
+  }
+
+  /* update list of endpoints */
+  kresult = get_endpoints (dev_handle, iface);
+  if (kresult) {
+    /* this should not happen */
+    darwin_release_interface (dev_handle, iface);
+    usbi_err (HANDLE_CTX (dev_handle), "could not build endpoint table");
+    return kresult;
+  }
+
+  cInterface->cfSource = NULL;
+
+  /* create async event source */
+  kresult = (*(cInterface->interface))->CreateInterfaceAsyncEventSource (cInterface->interface, &cInterface->cfSource);
+  if (kresult != kIOReturnSuccess) {
+    usbi_err (HANDLE_CTX (dev_handle), "could not create async event source");
+
+    /* can't continue without an async event source */
+    (void)darwin_release_interface (dev_handle, iface);
+
+    return darwin_to_libusb (kresult);
+  }
+
+  /* add the cfSource to the async thread's run loop */
+  CFRunLoopAddSource(libusb_darwin_acfl, cInterface->cfSource, kCFRunLoopDefaultMode);
+
+  usbi_dbg ("interface opened");
+
+  return 0;
+}
+
+static int darwin_release_interface(struct libusb_device_handle *dev_handle, int iface) {
+  struct darwin_device_handle_priv *priv = (struct darwin_device_handle_priv *)dev_handle->os_priv;
+  IOReturn kresult;
+
+  /* current interface */
+  struct darwin_interface *cInterface = &priv->interfaces[iface];
+
+  /* Check to see if an interface is open */
+  if (!cInterface->interface)
+    return LIBUSB_SUCCESS;
+
+  /* clean up endpoint data */
+  cInterface->num_endpoints = 0;
+
+  /* delete the interface's async event source */
+  if (cInterface->cfSource) {
+    CFRunLoopRemoveSource (libusb_darwin_acfl, cInterface->cfSource, kCFRunLoopDefaultMode);
+    CFRelease (cInterface->cfSource);
+  }
+
+  kresult = (*(cInterface->interface))->USBInterfaceClose(cInterface->interface);
+  if (kresult)
+    usbi_warn (HANDLE_CTX (dev_handle), "USBInterfaceClose: %s", darwin_error_str(kresult));
+
+  kresult = (*(cInterface->interface))->Release(cInterface->interface);
+  if (kresult != kIOReturnSuccess)
+    usbi_warn (HANDLE_CTX (dev_handle), "Release: %s", darwin_error_str(kresult));
+
+  cInterface->interface = (usb_interface_t **) IO_OBJECT_NULL;
+
+  return darwin_to_libusb (kresult);
+}
+
+static int darwin_set_interface_altsetting(struct libusb_device_handle *dev_handle, int iface, int altsetting) {
+  struct darwin_device_handle_priv *priv = (struct darwin_device_handle_priv *)dev_handle->os_priv;
+  IOReturn kresult;
+
+  /* current interface */
+  struct darwin_interface *cInterface = &priv->interfaces[iface];
+
+  if (!cInterface->interface)
+    return LIBUSB_ERROR_NO_DEVICE;
+
+  kresult = (*(cInterface->interface))->SetAlternateInterface (cInterface->interface, altsetting);
+  if (kresult != kIOReturnSuccess)
+    darwin_reset_device (dev_handle);
+
+  /* update list of endpoints */
+  kresult = get_endpoints (dev_handle, iface);
+  if (kresult) {
+    /* this should not happen */
+    darwin_release_interface (dev_handle, iface);
+    usbi_err (HANDLE_CTX (dev_handle), "could not build endpoint table");
+    return kresult;
+  }
+
+  return darwin_to_libusb (kresult);
+}
+
+static int darwin_clear_halt(struct libusb_device_handle *dev_handle, unsigned char endpoint) {
+  /* current interface */
+  struct darwin_interface *cInterface;
+  IOReturn kresult;
+  uint8_t pipeRef;
+
+  /* determine the interface/endpoint to use */
+  if (ep_to_pipeRef (dev_handle, endpoint, &pipeRef, NULL, &cInterface) != 0) {
+    usbi_err (HANDLE_CTX (dev_handle), "endpoint not found on any open interface");
+
+    return LIBUSB_ERROR_NOT_FOUND;
+  }
+
+  /* newer versions of darwin support clearing additional bits on the device's endpoint */
+  kresult = (*(cInterface->interface))->ClearPipeStallBothEnds(cInterface->interface, pipeRef);
+  if (kresult)
+    usbi_warn (HANDLE_CTX (dev_handle), "ClearPipeStall: %s", darwin_error_str (kresult));
+
+  return darwin_to_libusb (kresult);
+}
+
+static int darwin_reset_device(struct libusb_device_handle *dev_handle) {
+  struct darwin_cached_device *dpriv = DARWIN_CACHED_DEVICE(dev_handle->dev);
+  IOUSBDeviceDescriptor descriptor;
+  IOUSBConfigurationDescriptorPtr cached_configuration;
+  IOUSBConfigurationDescriptor configuration;
+  bool reenumerate = false;
+  IOReturn kresult;
+  int i;
+
+  kresult = (*(dpriv->device))->ResetDevice (dpriv->device);
+  if (kresult) {
+    usbi_err (HANDLE_CTX (dev_handle), "ResetDevice: %s", darwin_error_str (kresult));
+    return darwin_to_libusb (kresult);
+  }
+
+  do {
+    usbi_dbg ("darwin/reset_device: checking if device descriptor changed");
+
+    /* ignore return code. if we can't get a descriptor it might be worthwhile re-enumerating anway */
+    (void) darwin_request_descriptor (dpriv->device, kUSBDeviceDesc, 0, &descriptor, sizeof (descriptor));
+
+    /* check if the device descriptor has changed */
+    if (0 != memcmp (&dpriv->dev_descriptor, &descriptor, sizeof (descriptor))) {
+      reenumerate = true;
+      break;
+    }
+
+    /* check if any configuration descriptor has changed */
+    for (i = 0 ; i < descriptor.bNumConfigurations ; ++i) {
+      usbi_dbg ("darwin/reset_device: checking if configuration descriptor %d changed", i);
+
+      (void) darwin_request_descriptor (dpriv->device, kUSBConfDesc, i, &configuration, sizeof (configuration));
+      (*(dpriv->device))->GetConfigurationDescriptorPtr (dpriv->device, i, &cached_configuration);
+
+      if (!cached_configuration || 0 != memcmp (cached_configuration, &configuration, sizeof (configuration))) {
+        reenumerate = true;
+        break;
+      }
+    }
+  } while (0);
+
+  if (reenumerate) {
+    usbi_dbg ("darwin/reset_device: device requires reenumeration");
+    (void) (*(dpriv->device))->USBDeviceReEnumerate (dpriv->device, 0);
+    return LIBUSB_ERROR_NOT_FOUND;
+  }
+
+  usbi_dbg ("darwin/reset_device: device reset complete");
+
+  return LIBUSB_SUCCESS;
+}
+
+static int darwin_kernel_driver_active(struct libusb_device_handle *dev_handle, int interface) {
+  struct darwin_cached_device *dpriv = DARWIN_CACHED_DEVICE(dev_handle->dev);
+  io_service_t usbInterface;
+  CFTypeRef driver;
+  IOReturn kresult;
+
+  kresult = darwin_get_interface (dpriv->device, interface, &usbInterface);
+  if (kresult) {
+    usbi_err (HANDLE_CTX (dev_handle), "darwin_get_interface: %s", darwin_error_str(kresult));
+
+    return darwin_to_libusb (kresult);
+  }
+
+  driver = IORegistryEntryCreateCFProperty (usbInterface, kIOBundleIdentifierKey, kCFAllocatorDefault, 0);
+  IOObjectRelease (usbInterface);
+
+  if (driver) {
+    CFRelease (driver);
+
+    return 1;
+  }
+
+  /* no driver */
+  return 0;
+}
+
+/* attaching/detaching kernel drivers is not currently supported (maybe in the future?) */
+static int darwin_attach_kernel_driver (struct libusb_device_handle *dev_handle, int interface) {
+  UNUSED(dev_handle);
+  UNUSED(interface);
+  return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static int darwin_detach_kernel_driver (struct libusb_device_handle *dev_handle, int interface) {
+  UNUSED(dev_handle);
+  UNUSED(interface);
+  return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static void darwin_destroy_device(struct libusb_device *dev) {
+  struct darwin_device_priv *dpriv = (struct darwin_device_priv *) dev->os_priv;
+
+  if (dpriv->dev) {
+    /* need to hold the lock in case this is the last reference to the device */
+    usbi_mutex_lock(&darwin_cached_devices_lock);
+    darwin_deref_cached_device (dpriv->dev);
+    dpriv->dev = NULL;
+    usbi_mutex_unlock(&darwin_cached_devices_lock);
+  }
+}
+
+static int submit_bulk_transfer(struct usbi_transfer *itransfer) {
+  struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+
+  IOReturn               ret;
+  uint8_t                transferType;
+  /* None of the values below are used in libusbx for bulk transfers */
+  uint8_t                direction, number, interval, pipeRef;
+  uint16_t               maxPacketSize;
+
+  struct darwin_interface *cInterface;
+
+  if (ep_to_pipeRef (transfer->dev_handle, transfer->endpoint, &pipeRef, NULL, &cInterface) != 0) {
+    usbi_err (TRANSFER_CTX (transfer), "endpoint not found on any open interface");
+
+    return LIBUSB_ERROR_NOT_FOUND;
+  }
+
+  ret = (*(cInterface->interface))->GetPipeProperties (cInterface->interface, pipeRef, &direction, &number,
+                                                       &transferType, &maxPacketSize, &interval);
+
+  if (ret) {
+    usbi_err (TRANSFER_CTX (transfer), "bulk transfer failed (dir = %s): %s (code = 0x%08x)", IS_XFERIN(transfer) ? "In" : "Out",
+              darwin_error_str(ret), ret);
+    return darwin_to_libusb (ret);
+  }
+
+  if (0 != (transfer->length % maxPacketSize)) {
+    /* do not need a zero packet */
+    transfer->flags &= ~LIBUSB_TRANSFER_ADD_ZERO_PACKET;
+  }
+
+  /* submit the request */
+  /* timeouts are unavailable on interrupt endpoints */
+  if (transferType == kUSBInterrupt) {
+    if (IS_XFERIN(transfer))
+      ret = (*(cInterface->interface))->ReadPipeAsync(cInterface->interface, pipeRef, transfer->buffer,
+                                                      transfer->length, darwin_async_io_callback, itransfer);
+    else
+      ret = (*(cInterface->interface))->WritePipeAsync(cInterface->interface, pipeRef, transfer->buffer,
+                                                       transfer->length, darwin_async_io_callback, itransfer);
+  } else {
+    itransfer->timeout_flags |= USBI_TRANSFER_OS_HANDLES_TIMEOUT;
+
+    if (IS_XFERIN(transfer))
+      ret = (*(cInterface->interface))->ReadPipeAsyncTO(cInterface->interface, pipeRef, transfer->buffer,
+                                                        transfer->length, transfer->timeout, transfer->timeout,
+                                                        darwin_async_io_callback, (void *)itransfer);
+    else
+      ret = (*(cInterface->interface))->WritePipeAsyncTO(cInterface->interface, pipeRef, transfer->buffer,
+                                                         transfer->length, transfer->timeout, transfer->timeout,
+                                                         darwin_async_io_callback, (void *)itransfer);
+  }
+
+  if (ret)
+    usbi_err (TRANSFER_CTX (transfer), "bulk transfer failed (dir = %s): %s (code = 0x%08x)", IS_XFERIN(transfer) ? "In" : "Out",
+               darwin_error_str(ret), ret);
+
+  return darwin_to_libusb (ret);
+}
+
+#if InterfaceVersion >= 550
+static int submit_stream_transfer(struct usbi_transfer *itransfer) {
+  struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+  struct darwin_interface *cInterface;
+  uint8_t pipeRef;
+  IOReturn ret;
+
+  if (ep_to_pipeRef (transfer->dev_handle, transfer->endpoint, &pipeRef, NULL, &cInterface) != 0) {
+    usbi_err (TRANSFER_CTX (transfer), "endpoint not found on any open interface");
+
+    return LIBUSB_ERROR_NOT_FOUND;
+  }
+
+  itransfer->timeout_flags |= USBI_TRANSFER_OS_HANDLES_TIMEOUT;
+
+  if (IS_XFERIN(transfer))
+    ret = (*(cInterface->interface))->ReadStreamsPipeAsyncTO(cInterface->interface, pipeRef, itransfer->stream_id,
+                                                             transfer->buffer, transfer->length, transfer->timeout,
+                                                             transfer->timeout, darwin_async_io_callback, (void *)itransfer);
+  else
+    ret = (*(cInterface->interface))->WriteStreamsPipeAsyncTO(cInterface->interface, pipeRef, itransfer->stream_id,
+                                                              transfer->buffer, transfer->length, transfer->timeout,
+                                                              transfer->timeout, darwin_async_io_callback, (void *)itransfer);
+
+  if (ret)
+    usbi_err (TRANSFER_CTX (transfer), "bulk stream transfer failed (dir = %s): %s (code = 0x%08x)", IS_XFERIN(transfer) ? "In" : "Out",
+               darwin_error_str(ret), ret);
+
+  return darwin_to_libusb (ret);
+}
+#endif
+
+static int submit_iso_transfer(struct usbi_transfer *itransfer) {
+  struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+  struct darwin_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
+
+  IOReturn kresult;
+  uint8_t direction, number, interval, pipeRef, transferType;
+  uint16_t maxPacketSize;
+  UInt64 frame;
+  AbsoluteTime atTime;
+  int i;
+
+  struct darwin_interface *cInterface;
+
+  /* construct an array of IOUSBIsocFrames, reuse the old one if possible */
+  if (tpriv->isoc_framelist && tpriv->num_iso_packets != transfer->num_iso_packets) {
+    free(tpriv->isoc_framelist);
+    tpriv->isoc_framelist = NULL;
+  }
+
+  if (!tpriv->isoc_framelist) {
+    tpriv->num_iso_packets = transfer->num_iso_packets;
+    tpriv->isoc_framelist = (IOUSBIsocFrame*) calloc (transfer->num_iso_packets, sizeof(IOUSBIsocFrame));
+    if (!tpriv->isoc_framelist)
+      return LIBUSB_ERROR_NO_MEM;
+  }
+
+  /* copy the frame list from the libusb descriptor (the structures differ only is member order) */
+  for (i = 0 ; i < transfer->num_iso_packets ; i++)
+    tpriv->isoc_framelist[i].frReqCount = transfer->iso_packet_desc[i].length;
+
+  /* determine the interface/endpoint to use */
+  if (ep_to_pipeRef (transfer->dev_handle, transfer->endpoint, &pipeRef, NULL, &cInterface) != 0) {
+    usbi_err (TRANSFER_CTX (transfer), "endpoint not found on any open interface");
+
+    return LIBUSB_ERROR_NOT_FOUND;
+  }
+
+  /* determine the properties of this endpoint and the speed of the device */
+  (*(cInterface->interface))->GetPipeProperties (cInterface->interface, pipeRef, &direction, &number,
+                                                 &transferType, &maxPacketSize, &interval);
+
+  /* Last but not least we need the bus frame number */
+  kresult = (*(cInterface->interface))->GetBusFrameNumber(cInterface->interface, &frame, &atTime);
+  if (kresult) {
+    usbi_err (TRANSFER_CTX (transfer), "failed to get bus frame number: %d", kresult);
+    free(tpriv->isoc_framelist);
+    tpriv->isoc_framelist = NULL;
+
+    return darwin_to_libusb (kresult);
+  }
+
+  (*(cInterface->interface))->GetPipeProperties (cInterface->interface, pipeRef, &direction, &number,
+                                                 &transferType, &maxPacketSize, &interval);
+
+  /* schedule for a frame a little in the future */
+  frame += 4;
+
+  if (cInterface->frames[transfer->endpoint] && frame < cInterface->frames[transfer->endpoint])
+    frame = cInterface->frames[transfer->endpoint];
+
+  /* submit the request */
+  if (IS_XFERIN(transfer))
+    kresult = (*(cInterface->interface))->ReadIsochPipeAsync(cInterface->interface, pipeRef, transfer->buffer, frame,
+                                                             transfer->num_iso_packets, tpriv->isoc_framelist, darwin_async_io_callback,
+                                                             itransfer);
+  else
+    kresult = (*(cInterface->interface))->WriteIsochPipeAsync(cInterface->interface, pipeRef, transfer->buffer, frame,
+                                                              transfer->num_iso_packets, tpriv->isoc_framelist, darwin_async_io_callback,
+                                                              itransfer);
+
+  if (LIBUSB_SPEED_FULL == transfer->dev_handle->dev->speed)
+    /* Full speed */
+    cInterface->frames[transfer->endpoint] = frame + transfer->num_iso_packets * (1 << (interval - 1));
+  else
+    /* High/super speed */
+    cInterface->frames[transfer->endpoint] = frame + transfer->num_iso_packets * (1 << (interval - 1)) / 8;
+
+  if (kresult != kIOReturnSuccess) {
+    usbi_err (TRANSFER_CTX (transfer), "isochronous transfer failed (dir: %s): %s", IS_XFERIN(transfer) ? "In" : "Out",
+               darwin_error_str(kresult));
+    free (tpriv->isoc_framelist);
+    tpriv->isoc_framelist = NULL;
+  }
+
+  return darwin_to_libusb (kresult);
+}
+
+static int submit_control_transfer(struct usbi_transfer *itransfer) {
+  struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+  struct libusb_control_setup *setup = (struct libusb_control_setup *) transfer->buffer;
+  struct darwin_cached_device *dpriv = DARWIN_CACHED_DEVICE(transfer->dev_handle->dev);
+  struct darwin_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
+
+  IOReturn               kresult;
+
+  memset(&tpriv->req, 0, sizeof(tpriv->req));
+
+  /* IOUSBDeviceInterface expects the request in cpu endianness */
+  tpriv->req.bmRequestType     = setup->bmRequestType;
+  tpriv->req.bRequest          = setup->bRequest;
+  /* these values should be in bus order from libusb_fill_control_setup */
+  tpriv->req.wValue            = OSSwapLittleToHostInt16 (setup->wValue);
+  tpriv->req.wIndex            = OSSwapLittleToHostInt16 (setup->wIndex);
+  tpriv->req.wLength           = OSSwapLittleToHostInt16 (setup->wLength);
+  /* data is stored after the libusb control block */
+  tpriv->req.pData             = transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE;
+  tpriv->req.completionTimeout = transfer->timeout;
+  tpriv->req.noDataTimeout     = transfer->timeout;
+
+  itransfer->timeout_flags |= USBI_TRANSFER_OS_HANDLES_TIMEOUT;
+
+  /* all transfers in libusb-1.0 are async */
+
+  if (transfer->endpoint) {
+    struct darwin_interface *cInterface;
+    uint8_t                 pipeRef;
+
+    if (ep_to_pipeRef (transfer->dev_handle, transfer->endpoint, &pipeRef, NULL, &cInterface) != 0) {
+      usbi_err (TRANSFER_CTX (transfer), "endpoint not found on any open interface");
+
+      return LIBUSB_ERROR_NOT_FOUND;
+    }
+
+    kresult = (*(cInterface->interface))->ControlRequestAsyncTO (cInterface->interface, pipeRef, &(tpriv->req), darwin_async_io_callback, itransfer);
+  } else
+    /* control request on endpoint 0 */
+    kresult = (*(dpriv->device))->DeviceRequestAsyncTO(dpriv->device, &(tpriv->req), darwin_async_io_callback, itransfer);
+
+  if (kresult != kIOReturnSuccess)
+    usbi_err (TRANSFER_CTX (transfer), "control request failed: %s", darwin_error_str(kresult));
+
+  return darwin_to_libusb (kresult);
+}
+
+static int darwin_submit_transfer(struct usbi_transfer *itransfer) {
+  struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+
+  switch (transfer->type) {
+  case LIBUSB_TRANSFER_TYPE_CONTROL:
+    return submit_control_transfer(itransfer);
+  case LIBUSB_TRANSFER_TYPE_BULK:
+  case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+    return submit_bulk_transfer(itransfer);
+  case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+    return submit_iso_transfer(itransfer);
+  case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
+#if InterfaceVersion >= 550
+    return submit_stream_transfer(itransfer);
+#else
+    usbi_err (TRANSFER_CTX(transfer), "IOUSBFamily version does not support bulk stream transfers");
+    return LIBUSB_ERROR_NOT_SUPPORTED;
+#endif
+  default:
+    usbi_err (TRANSFER_CTX(transfer), "unknown endpoint type %d", transfer->type);
+    return LIBUSB_ERROR_INVALID_PARAM;
+  }
+}
+
+static int cancel_control_transfer(struct usbi_transfer *itransfer) {
+  struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+  struct darwin_cached_device *dpriv = DARWIN_CACHED_DEVICE(transfer->dev_handle->dev);
+  IOReturn kresult;
+
+  usbi_warn (ITRANSFER_CTX (itransfer), "aborting all transactions control pipe");
+
+  if (!dpriv->device)
+    return LIBUSB_ERROR_NO_DEVICE;
+
+  kresult = (*(dpriv->device))->USBDeviceAbortPipeZero (dpriv->device);
+
+  return darwin_to_libusb (kresult);
+}
+
+static int darwin_abort_transfers (struct usbi_transfer *itransfer) {
+  struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+  struct darwin_cached_device *dpriv = DARWIN_CACHED_DEVICE(transfer->dev_handle->dev);
+  struct darwin_interface *cInterface;
+  uint8_t pipeRef, iface;
+  IOReturn kresult;
+
+  if (ep_to_pipeRef (transfer->dev_handle, transfer->endpoint, &pipeRef, &iface, &cInterface) != 0) {
+    usbi_err (TRANSFER_CTX (transfer), "endpoint not found on any open interface");
+
+    return LIBUSB_ERROR_NOT_FOUND;
+  }
+
+  if (!dpriv->device)
+    return LIBUSB_ERROR_NO_DEVICE;
+
+  usbi_warn (ITRANSFER_CTX (itransfer), "aborting all transactions on interface %d pipe %d", iface, pipeRef);
+
+  /* abort transactions */
+#if InterfaceVersion >= 550
+  if (LIBUSB_TRANSFER_TYPE_BULK_STREAM == transfer->type)
+    (*(cInterface->interface))->AbortStreamsPipe (cInterface->interface, pipeRef, itransfer->stream_id);
+  else
+#endif
+    (*(cInterface->interface))->AbortPipe (cInterface->interface, pipeRef);
+
+  usbi_dbg ("calling clear pipe stall to clear the data toggle bit");
+
+  /* newer versions of darwin support clearing additional bits on the device's endpoint */
+  kresult = (*(cInterface->interface))->ClearPipeStallBothEnds(cInterface->interface, pipeRef);
+
+  return darwin_to_libusb (kresult);
+}
+
+static int darwin_cancel_transfer(struct usbi_transfer *itransfer) {
+  struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+
+  switch (transfer->type) {
+  case LIBUSB_TRANSFER_TYPE_CONTROL:
+    return cancel_control_transfer(itransfer);
+  case LIBUSB_TRANSFER_TYPE_BULK:
+  case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+  case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+    return darwin_abort_transfers (itransfer);
+  default:
+    usbi_err (TRANSFER_CTX(transfer), "unknown endpoint type %d", transfer->type);
+    return LIBUSB_ERROR_INVALID_PARAM;
+  }
+}
+
+static void darwin_clear_transfer_priv (struct usbi_transfer *itransfer) {
+  struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+  struct darwin_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
+
+  if (transfer->type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS && tpriv->isoc_framelist) {
+    free (tpriv->isoc_framelist);
+    tpriv->isoc_framelist = NULL;
+  }
+}
+
+static void darwin_async_io_callback (void *refcon, IOReturn result, void *arg0) {
+  struct usbi_transfer *itransfer = (struct usbi_transfer *)refcon;
+  struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+  struct darwin_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
+
+  usbi_dbg ("an async io operation has completed");
+
+  /* if requested write a zero packet */
+  if (kIOReturnSuccess == result && IS_XFEROUT(transfer) && transfer->flags & LIBUSB_TRANSFER_ADD_ZERO_PACKET) {
+    struct darwin_interface *cInterface;
+    uint8_t pipeRef;
+
+    (void) ep_to_pipeRef (transfer->dev_handle, transfer->endpoint, &pipeRef, NULL, &cInterface);
+
+    (*(cInterface->interface))->WritePipe (cInterface->interface, pipeRef, transfer->buffer, 0);
+  }
+
+  tpriv->result = result;
+  tpriv->size = (UInt32) (uintptr_t) arg0;
+
+  /* signal the core that this transfer is complete */
+  usbi_signal_transfer_completion(itransfer);
+}
+
+static int darwin_transfer_status (struct usbi_transfer *itransfer, kern_return_t result) {
+  if (itransfer->timeout_flags & USBI_TRANSFER_TIMED_OUT)
+    result = kIOUSBTransactionTimeout;
+
+  switch (result) {
+  case kIOReturnUnderrun:
+  case kIOReturnSuccess:
+    return LIBUSB_TRANSFER_COMPLETED;
+  case kIOReturnAborted:
+    return LIBUSB_TRANSFER_CANCELLED;
+  case kIOUSBPipeStalled:
+    usbi_dbg ("transfer error: pipe is stalled");
+    return LIBUSB_TRANSFER_STALL;
+  case kIOReturnOverrun:
+    usbi_warn (ITRANSFER_CTX (itransfer), "transfer error: data overrun");
+    return LIBUSB_TRANSFER_OVERFLOW;
+  case kIOUSBTransactionTimeout:
+    usbi_warn (ITRANSFER_CTX (itransfer), "transfer error: timed out");
+    itransfer->timeout_flags |= USBI_TRANSFER_TIMED_OUT;
+    return LIBUSB_TRANSFER_TIMED_OUT;
+  default:
+    usbi_warn (ITRANSFER_CTX (itransfer), "transfer error: %s (value = 0x%08x)", darwin_error_str (result), result);
+    return LIBUSB_TRANSFER_ERROR;
+  }
+}
+
+static int darwin_handle_transfer_completion (struct usbi_transfer *itransfer) {
+  struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+  struct darwin_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
+  int isIsoc      = LIBUSB_TRANSFER_TYPE_ISOCHRONOUS == transfer->type;
+  int isBulk      = LIBUSB_TRANSFER_TYPE_BULK == transfer->type;
+  int isControl   = LIBUSB_TRANSFER_TYPE_CONTROL == transfer->type;
+  int isInterrupt = LIBUSB_TRANSFER_TYPE_INTERRUPT == transfer->type;
+  int i;
+
+  if (!isIsoc && !isBulk && !isControl && !isInterrupt) {
+    usbi_err (TRANSFER_CTX(transfer), "unknown endpoint type %d", transfer->type);
+    return LIBUSB_ERROR_INVALID_PARAM;
+  }
+
+  usbi_dbg ("handling %s completion with kernel status %d",
+             isControl ? "control" : isBulk ? "bulk" : isIsoc ? "isoc" : "interrupt", tpriv->result);
+
+  if (kIOReturnSuccess == tpriv->result || kIOReturnUnderrun == tpriv->result) {
+    if (isIsoc && tpriv->isoc_framelist) {
+      /* copy isochronous results back */
+
+      for (i = 0; i < transfer->num_iso_packets ; i++) {
+        struct libusb_iso_packet_descriptor *lib_desc = &transfer->iso_packet_desc[i];
+        lib_desc->status = darwin_to_libusb (tpriv->isoc_framelist[i].frStatus);
+        lib_desc->actual_length = tpriv->isoc_framelist[i].frActCount;
+      }
+    } else if (!isIsoc)
+      itransfer->transferred += tpriv->size;
+  }
+
+  /* it is ok to handle cancelled transfers without calling usbi_handle_transfer_cancellation (we catch timeout transfers) */
+  return usbi_handle_transfer_completion (itransfer, darwin_transfer_status (itransfer, tpriv->result));
+}
+
+static int darwin_clock_gettime(int clk_id, struct timespec *tp) {
+#if !OSX_USE_CLOCK_GETTIME
+  mach_timespec_t sys_time;
+  clock_serv_t clock_ref;
+
+  switch (clk_id) {
+  case USBI_CLOCK_REALTIME:
+    /* CLOCK_REALTIME represents time since the epoch */
+    clock_ref = clock_realtime;
+    break;
+  case USBI_CLOCK_MONOTONIC:
+    /* use system boot time as reference for the monotonic clock */
+    clock_ref = clock_monotonic;
+    break;
+  default:
+    return LIBUSB_ERROR_INVALID_PARAM;
+  }
+
+  clock_get_time (clock_ref, &sys_time);
+
+  tp->tv_sec  = sys_time.tv_sec;
+  tp->tv_nsec = sys_time.tv_nsec;
+
+  return 0;
+#else
+  switch (clk_id) {
+  case USBI_CLOCK_MONOTONIC:
+    return clock_gettime(CLOCK_MONOTONIC, tp);
+  case USBI_CLOCK_REALTIME:
+    return clock_gettime(CLOCK_REALTIME, tp);
+  default:
+    return LIBUSB_ERROR_INVALID_PARAM;
+  }
+#endif
+}
+
+#if InterfaceVersion >= 550
+static int darwin_alloc_streams (struct libusb_device_handle *dev_handle, uint32_t num_streams, unsigned char *endpoints,
+                                 int num_endpoints) {
+  struct darwin_interface *cInterface;
+  UInt32 supportsStreams;
+  uint8_t pipeRef;
+  int rc, i;
+
+  /* find the mimimum number of supported streams on the endpoint list */
+  for (i = 0 ; i < num_endpoints ; ++i) {
+    if (0 != (rc = ep_to_pipeRef (dev_handle, endpoints[i], &pipeRef, NULL, &cInterface))) {
+      return rc;
+    }
+
+    (*(cInterface->interface))->SupportsStreams (cInterface->interface, pipeRef, &supportsStreams);
+    if (num_streams > supportsStreams)
+      num_streams = supportsStreams;
+  }
+
+  /* it is an error if any endpoint in endpoints does not support streams */
+  if (0 == num_streams)
+    return LIBUSB_ERROR_INVALID_PARAM;
+
+  /* create the streams */
+  for (i = 0 ; i < num_endpoints ; ++i) {
+    (void) ep_to_pipeRef (dev_handle, endpoints[i], &pipeRef, NULL, &cInterface);
+
+    rc = (*(cInterface->interface))->CreateStreams (cInterface->interface, pipeRef, num_streams);
+    if (kIOReturnSuccess != rc)
+      return darwin_to_libusb(rc);
+  }
+
+  return num_streams;
+}
+
+static int darwin_free_streams (struct libusb_device_handle *dev_handle, unsigned char *endpoints, int num_endpoints) {
+  struct darwin_interface *cInterface;
+  UInt32 supportsStreams;
+  uint8_t pipeRef;
+  int rc;
+
+  for (int i = 0 ; i < num_endpoints ; ++i) {
+    if (0 != (rc = ep_to_pipeRef (dev_handle, endpoints[i], &pipeRef, NULL, &cInterface)))
+      return rc;
+
+    (*(cInterface->interface))->SupportsStreams (cInterface->interface, pipeRef, &supportsStreams);
+    if (0 == supportsStreams)
+      return LIBUSB_ERROR_INVALID_PARAM;
+
+    rc = (*(cInterface->interface))->CreateStreams (cInterface->interface, pipeRef, 0);
+    if (kIOReturnSuccess != rc)
+      return darwin_to_libusb(rc);
+  }
+
+  return LIBUSB_SUCCESS;
+}
+#endif
+
+const struct usbi_os_backend usbi_backend = {
+        .name = "Darwin",
+        .caps = 0,
+        .init = darwin_init,
+        .exit = darwin_exit,
+        .get_device_list = NULL, /* not needed */
+        .get_device_descriptor = darwin_get_device_descriptor,
+        .get_active_config_descriptor = darwin_get_active_config_descriptor,
+        .get_config_descriptor = darwin_get_config_descriptor,
+        .hotplug_poll = darwin_hotplug_poll,
+
+        .open = darwin_open,
+        .close = darwin_close,
+        .get_configuration = darwin_get_configuration,
+        .set_configuration = darwin_set_configuration,
+        .claim_interface = darwin_claim_interface,
+        .release_interface = darwin_release_interface,
+
+        .set_interface_altsetting = darwin_set_interface_altsetting,
+        .clear_halt = darwin_clear_halt,
+        .reset_device = darwin_reset_device,
+
+#if InterfaceVersion >= 550
+        .alloc_streams = darwin_alloc_streams,
+        .free_streams = darwin_free_streams,
+#endif
+
+        .kernel_driver_active = darwin_kernel_driver_active,
+        .detach_kernel_driver = darwin_detach_kernel_driver,
+        .attach_kernel_driver = darwin_attach_kernel_driver,
+
+        .destroy_device = darwin_destroy_device,
+
+        .submit_transfer = darwin_submit_transfer,
+        .cancel_transfer = darwin_cancel_transfer,
+        .clear_transfer_priv = darwin_clear_transfer_priv,
+
+        .handle_transfer_completion = darwin_handle_transfer_completion,
+
+        .clock_gettime = darwin_clock_gettime,
+
+        .device_priv_size = sizeof(struct darwin_device_priv),
+        .device_handle_priv_size = sizeof(struct darwin_device_handle_priv),
+        .transfer_priv_size = sizeof(struct darwin_transfer_priv),
+};
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/os/darwin_usb.h b/vendor/github.com/karalabe/usb/libusb/libusb/os/darwin_usb.h
new file mode 100644
index 000000000..474567f6a
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/os/darwin_usb.h
@@ -0,0 +1,199 @@
+/*
+ * darwin backend for libusb 1.0
+ * Copyright © 2008-2015 Nathan Hjelm <hjelmn@users.sourceforge.net>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#if !defined(LIBUSB_DARWIN_H)
+#define LIBUSB_DARWIN_H
+
+#include "libusbi.h"
+
+#include <IOKit/IOTypes.h>
+#include <IOKit/IOCFBundle.h>
+#include <IOKit/usb/IOUSBLib.h>
+#include <IOKit/IOCFPlugIn.h>
+
+/* IOUSBInterfaceInferface */
+
+/* New in OS 10.12.0. */
+#if defined (kIOUSBInterfaceInterfaceID800) && (MAC_OS_X_VERSION_MIN_REQUIRED >= 101200)
+
+#define usb_interface_t IOUSBInterfaceInterface800
+#define InterfaceInterfaceID kIOUSBInterfaceInterfaceID800
+#define InterfaceVersion 800
+
+/* New in OS 10.10.0. */
+#elif defined (kIOUSBInterfaceInterfaceID700) && (MAC_OS_X_VERSION_MIN_REQUIRED >= 101000)
+
+#define usb_interface_t IOUSBInterfaceInterface700
+#define InterfaceInterfaceID kIOUSBInterfaceInterfaceID700
+#define InterfaceVersion 700
+
+/* New in OS 10.9.0. */
+#elif defined (kIOUSBInterfaceInterfaceID650) && (MAC_OS_X_VERSION_MIN_REQUIRED >= 1090)
+
+#define usb_interface_t IOUSBInterfaceInterface650
+#define InterfaceInterfaceID kIOUSBInterfaceInterfaceID650
+#define InterfaceVersion 650
+
+/* New in OS 10.8.2 but can't test deployment target to that granularity, so round up. */
+#elif defined (kIOUSBInterfaceInterfaceID550) && (MAC_OS_X_VERSION_MIN_REQUIRED >= 1090)
+
+#define usb_interface_t IOUSBInterfaceInterface550
+#define InterfaceInterfaceID kIOUSBInterfaceInterfaceID550
+#define InterfaceVersion 550
+
+/* New in OS 10.7.3 but can't test deployment target to that granularity, so round up. */
+#elif defined (kIOUSBInterfaceInterfaceID500) && (MAC_OS_X_VERSION_MIN_REQUIRED >= 1080)
+
+#define usb_interface_t IOUSBInterfaceInterface500
+#define InterfaceInterfaceID kIOUSBInterfaceInterfaceID500
+#define InterfaceVersion 500
+
+/* New in OS 10.5.0. */
+#elif defined (kIOUSBInterfaceInterfaceID300) && (MAC_OS_X_VERSION_MIN_REQUIRED >= 1050)
+
+#define usb_interface_t IOUSBInterfaceInterface300
+#define InterfaceInterfaceID kIOUSBInterfaceInterfaceID300
+#define InterfaceVersion 300
+
+/* New in OS 10.4.5 (or 10.4.6?) but can't test deployment target to that granularity, so round up. */
+#elif defined (kIOUSBInterfaceInterfaceID245) && (MAC_OS_X_VERSION_MIN_REQUIRED >= 1050)
+
+#define usb_interface_t IOUSBInterfaceInterface245
+#define InterfaceInterfaceID kIOUSBInterfaceInterfaceID245
+#define InterfaceVersion 245
+
+/* New in OS 10.4.0. */
+#elif defined (kIOUSBInterfaceInterfaceID220) && (MAC_OS_X_VERSION_MIN_REQUIRED >= 1040)
+
+#define usb_interface_t IOUSBInterfaceInterface220
+#define InterfaceInterfaceID kIOUSBInterfaceInterfaceID220
+#define InterfaceVersion 220
+
+#else
+
+#error "IOUSBFamily is too old. Please upgrade your SDK and/or deployment target"
+
+#endif
+
+/* IOUSBDeviceInterface */
+
+/* New in OS 10.9.0. */
+#if defined (kIOUSBDeviceInterfaceID650) && (MAC_OS_X_VERSION_MIN_REQUIRED >= 1090)
+
+#define usb_device_t    IOUSBDeviceInterface650
+#define DeviceInterfaceID kIOUSBDeviceInterfaceID650
+#define DeviceVersion 650
+
+/* New in OS 10.7.3 but can't test deployment target to that granularity, so round up. */
+#elif defined (kIOUSBDeviceInterfaceID500) && (MAC_OS_X_VERSION_MIN_REQUIRED >= 1080)
+
+#define usb_device_t    IOUSBDeviceInterface500
+#define DeviceInterfaceID kIOUSBDeviceInterfaceID500
+#define DeviceVersion 500
+
+/* New in OS 10.5.4 but can't test deployment target to that granularity, so round up. */
+#elif defined (kIOUSBDeviceInterfaceID320) && (MAC_OS_X_VERSION_MIN_REQUIRED >= 1060)
+
+#define usb_device_t    IOUSBDeviceInterface320
+#define DeviceInterfaceID kIOUSBDeviceInterfaceID320
+#define DeviceVersion 320
+
+/* New in OS 10.5.0. */
+#elif defined (kIOUSBDeviceInterfaceID300) && (MAC_OS_X_VERSION_MIN_REQUIRED >= 1050)
+
+#define usb_device_t    IOUSBDeviceInterface300
+#define DeviceInterfaceID kIOUSBDeviceInterfaceID300
+#define DeviceVersion 300
+
+/* New in OS 10.4.5 (or 10.4.6?) but can't test deployment target to that granularity, so round up. */
+#elif defined (kIOUSBDeviceInterfaceID245) && (MAC_OS_X_VERSION_MIN_REQUIRED >= 1050)
+
+#define usb_device_t    IOUSBDeviceInterface245
+#define DeviceInterfaceID kIOUSBDeviceInterfaceID245
+#define DeviceVersion 245
+
+/* New in OS 10.2.3 but can't test deployment target to that granularity, so round up. */
+#elif defined (kIOUSBDeviceInterfaceID197) && (MAC_OS_X_VERSION_MIN_REQUIRED >= 1030)
+
+#define usb_device_t    IOUSBDeviceInterface197
+#define DeviceInterfaceID kIOUSBDeviceInterfaceID197
+#define DeviceVersion 197
+
+#else
+
+#error "IOUSBFamily is too old. Please upgrade your SDK and/or deployment target"
+
+#endif
+
+#if !defined(IO_OBJECT_NULL)
+#define IO_OBJECT_NULL ((io_object_t) 0)
+#endif
+
+typedef IOCFPlugInInterface *io_cf_plugin_ref_t;
+typedef IONotificationPortRef io_notification_port_t;
+
+/* private structures */
+struct darwin_cached_device {
+  struct list_head      list;
+  IOUSBDeviceDescriptor dev_descriptor;
+  UInt32                location;
+  UInt64                parent_session;
+  UInt64                session;
+  UInt16                address;
+  char                  sys_path[21];
+  usb_device_t        **device;
+  int                   open_count;
+  UInt8                 first_config, active_config, port;  
+  int                   can_enumerate;
+  int                   refcount;
+};
+
+struct darwin_device_priv {
+  struct darwin_cached_device *dev;
+};
+
+struct darwin_device_handle_priv {
+  int                  is_open;
+  CFRunLoopSourceRef   cfSource;
+
+  struct darwin_interface {
+    usb_interface_t    **interface;
+    uint8_t              num_endpoints;
+    CFRunLoopSourceRef   cfSource;
+    uint64_t             frames[256];
+    uint8_t              endpoint_addrs[USB_MAXENDPOINTS];
+  } interfaces[USB_MAXINTERFACES];
+};
+
+struct darwin_transfer_priv {
+  /* Isoc */
+  IOUSBIsocFrame *isoc_framelist;
+  int num_iso_packets;
+
+  /* Control */
+  IOUSBDevRequestTO req;
+
+  /* Bulk */
+
+  /* Completion status */
+  IOReturn result;
+  UInt32 size;
+};
+
+#endif
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/os/haiku_pollfs.cpp b/vendor/github.com/karalabe/usb/libusb/libusb/os/haiku_pollfs.cpp
new file mode 100644
index 000000000..e0c771320
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/os/haiku_pollfs.cpp
@@ -0,0 +1,367 @@
+/*
+ * Copyright 2007-2008, Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ *
+ * Authors:
+ *		Michael Lotz <mmlr@mlotz.ch>
+ */
+
+#include "haiku_usb.h"
+#include <cstdio>
+#include <Directory.h>
+#include <Entry.h>
+#include <Looper.h>
+#include <Messenger.h>
+#include <Node.h>
+#include <NodeMonitor.h>
+#include <Path.h>
+#include <cstring>
+
+class WatchedEntry {
+public:
+			WatchedEntry(BMessenger *, entry_ref *);
+			~WatchedEntry();
+	bool		EntryCreated(entry_ref *ref);
+	bool		EntryRemoved(ino_t node);
+	bool		InitCheck();
+
+private:
+	BMessenger*	fMessenger;
+	node_ref	fNode;
+	bool		fIsDirectory;
+	USBDevice*	fDevice;
+	WatchedEntry*	fEntries;
+	WatchedEntry*	fLink;
+	bool		fInitCheck;
+};
+
+
+class RosterLooper : public BLooper {
+public:
+			RosterLooper(USBRoster *);
+	void		Stop();
+	virtual void	MessageReceived(BMessage *);
+	bool		InitCheck();
+
+private:
+	USBRoster*	fRoster;
+	WatchedEntry*	fRoot;
+	BMessenger*	fMessenger;
+	bool		fInitCheck;
+};
+
+
+WatchedEntry::WatchedEntry(BMessenger *messenger, entry_ref *ref)
+	:	fMessenger(messenger),
+		fIsDirectory(false),
+		fDevice(NULL),
+		fEntries(NULL),
+		fLink(NULL),
+		fInitCheck(false)
+{
+	BEntry entry(ref);
+	entry.GetNodeRef(&fNode);
+
+	BDirectory directory;
+	if (entry.IsDirectory() && directory.SetTo(ref) >= B_OK) {
+		fIsDirectory = true;
+
+		while (directory.GetNextEntry(&entry) >= B_OK) {
+			if (entry.GetRef(ref) < B_OK)
+				continue;
+
+			WatchedEntry *child = new(std::nothrow) WatchedEntry(fMessenger, ref);
+			if (child == NULL)
+				continue;
+			if (child->InitCheck() == false) {
+				delete child;
+				continue;
+			}
+
+			child->fLink = fEntries;
+			fEntries = child;
+		}
+
+		watch_node(&fNode, B_WATCH_DIRECTORY, *fMessenger);
+	}
+	else {
+		if (strncmp(ref->name, "raw", 3) == 0)
+			return;
+
+		BPath path, parent_path;
+		entry.GetPath(&path);
+		fDevice = new(std::nothrow) USBDevice(path.Path());
+		if (fDevice != NULL && fDevice->InitCheck() == true) {
+			// Add this new device to each active context's device list
+			struct libusb_context *ctx;
+			unsigned long session_id = (unsigned long)&fDevice;
+
+			usbi_mutex_lock(&active_contexts_lock);
+			list_for_each_entry(ctx, &active_contexts_list, list, struct libusb_context) {
+				struct libusb_device *dev = usbi_get_device_by_session_id(ctx, session_id);
+				if (dev) {
+					usbi_dbg("using previously allocated device with location %lu", session_id);
+					libusb_unref_device(dev);
+					continue;
+				}
+				usbi_dbg("allocating new device with location %lu", session_id);
+				dev = usbi_alloc_device(ctx, session_id);
+				if (!dev) {
+					usbi_dbg("device allocation failed");
+					continue;
+				}
+				*((USBDevice **)dev->os_priv) = fDevice;
+
+				// Calculate pseudo-device-address
+				int addr, tmp;
+				if (strcmp(path.Leaf(), "hub") == 0)
+					tmp = 100;	//Random Number
+				else
+					sscanf(path.Leaf(), "%d", &tmp);
+				addr = tmp + 1;
+				path.GetParent(&parent_path);
+				while (strcmp(parent_path.Leaf(), "usb") != 0) {
+					sscanf(parent_path.Leaf(), "%d", &tmp);
+					addr += tmp + 1;
+					parent_path.GetParent(&parent_path);
+				}
+				sscanf(path.Path(), "/dev/bus/usb/%d", &dev->bus_number);
+				dev->device_address = addr - (dev->bus_number + 1);
+
+				if (usbi_sanitize_device(dev) < 0) {
+					usbi_dbg("device sanitization failed");
+					libusb_unref_device(dev);
+					continue;
+				}
+				usbi_connect_device(dev);
+			}
+			usbi_mutex_unlock(&active_contexts_lock);
+		}
+		else if (fDevice) {
+			delete fDevice;
+			fDevice = NULL;
+			return;
+		}
+	}
+	fInitCheck = true;
+}
+
+
+WatchedEntry::~WatchedEntry()
+{
+	if (fIsDirectory) {
+		watch_node(&fNode, B_STOP_WATCHING, *fMessenger);
+
+		WatchedEntry *child = fEntries;
+		while (child) {
+			WatchedEntry *next = child->fLink;
+			delete child;
+			child = next;
+		}
+	}
+
+	if (fDevice) {
+		// Remove this device from each active context's device list
+		struct libusb_context *ctx;
+		struct libusb_device *dev;
+		unsigned long session_id = (unsigned long)&fDevice;
+
+		usbi_mutex_lock(&active_contexts_lock);
+		list_for_each_entry(ctx, &active_contexts_list, list, struct libusb_context) {
+			dev = usbi_get_device_by_session_id(ctx, session_id);
+			if (dev != NULL) {
+				usbi_disconnect_device(dev);
+				libusb_unref_device(dev);
+			} else {
+				usbi_dbg("device with location %lu not found", session_id);
+			}
+		}
+		usbi_mutex_static_unlock(&active_contexts_lock);
+		delete fDevice;
+	}
+}
+
+
+bool
+WatchedEntry::EntryCreated(entry_ref *ref)
+{
+	if (!fIsDirectory)
+		return false;
+
+	if (ref->directory != fNode.node) {
+		WatchedEntry *child = fEntries;
+		while (child) {
+			if (child->EntryCreated(ref))
+				return true;
+			child = child->fLink;
+		}
+		return false;
+	}
+
+	WatchedEntry *child = new(std::nothrow) WatchedEntry(fMessenger, ref);
+	if (child == NULL)
+		return false;
+	child->fLink = fEntries;
+	fEntries = child;
+	return true;
+}
+
+
+bool
+WatchedEntry::EntryRemoved(ino_t node)
+{
+	if (!fIsDirectory)
+		return false;
+
+	WatchedEntry *child = fEntries;
+	WatchedEntry *lastChild = NULL;
+	while (child) {
+		if (child->fNode.node == node) {
+			if (lastChild)
+				lastChild->fLink = child->fLink;
+			else
+				fEntries = child->fLink;
+			delete child;
+			return true;
+		}
+
+		if (child->EntryRemoved(node))
+			return true;
+
+		lastChild = child;
+		child = child->fLink;
+	}
+	return false;
+}
+
+
+bool
+WatchedEntry::InitCheck()
+{
+	return fInitCheck;
+}
+
+
+RosterLooper::RosterLooper(USBRoster *roster)
+	:	BLooper("LibusbRoster Looper"),
+		fRoster(roster),
+		fRoot(NULL),
+		fMessenger(NULL),
+		fInitCheck(false)
+{
+	BEntry entry("/dev/bus/usb");
+	if (!entry.Exists()) {
+		usbi_err(NULL, "usb_raw not published");
+		return;
+	}
+
+	Run();
+	fMessenger = new(std::nothrow) BMessenger(this);
+	if (fMessenger == NULL) {
+		usbi_err(NULL, "error creating BMessenger object");
+		return;
+	}
+
+	if (Lock()) {
+		entry_ref ref;
+		entry.GetRef(&ref);
+		fRoot = new(std::nothrow) WatchedEntry(fMessenger, &ref);
+		Unlock();
+		if (fRoot == NULL)
+			return;
+		if (fRoot->InitCheck() == false) {
+			delete fRoot;
+			fRoot = NULL;
+			return;
+		}
+	}
+	fInitCheck = true;
+}
+
+
+void
+RosterLooper::Stop()
+{
+	Lock();
+	delete fRoot;
+	delete fMessenger;
+	Quit();
+}
+
+
+void
+RosterLooper::MessageReceived(BMessage *message)
+{
+	int32 opcode;
+	if (message->FindInt32("opcode", &opcode) < B_OK)
+		return;
+
+	switch (opcode) {
+		case B_ENTRY_CREATED:
+		{
+			dev_t device;
+			ino_t directory;
+			const char *name;
+			if (message->FindInt32("device", &device) < B_OK ||
+				message->FindInt64("directory", &directory) < B_OK ||
+				message->FindString("name", &name) < B_OK)
+				break;
+
+			entry_ref ref(device, directory, name);
+			fRoot->EntryCreated(&ref);
+			break;
+		}
+		case B_ENTRY_REMOVED:
+		{
+			ino_t node;
+			if (message->FindInt64("node", &node) < B_OK)
+				break;
+			fRoot->EntryRemoved(node);
+			break;
+		}
+	}
+}
+
+
+bool
+RosterLooper::InitCheck()
+{
+	return fInitCheck;
+}
+
+
+USBRoster::USBRoster()
+	:	fLooper(NULL)
+{
+}
+
+
+USBRoster::~USBRoster()
+{
+	Stop();
+}
+
+
+int
+USBRoster::Start()
+{
+	if (fLooper == NULL) {
+		fLooper = new(std::nothrow) RosterLooper(this);
+		if (fLooper == NULL || ((RosterLooper *)fLooper)->InitCheck() == false) {
+			if (fLooper)
+				fLooper = NULL;
+			return LIBUSB_ERROR_OTHER;
+		}
+	}
+	return LIBUSB_SUCCESS;
+}
+
+
+void
+USBRoster::Stop()
+{
+	if (fLooper) {
+		((RosterLooper *)fLooper)->Stop();
+		fLooper = NULL;
+	}
+}
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/os/haiku_usb.h b/vendor/github.com/karalabe/usb/libusb/libusb/os/haiku_usb.h
new file mode 100644
index 000000000..d51ae9eae
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/os/haiku_usb.h
@@ -0,0 +1,112 @@
+/*
+ * Haiku Backend for libusb
+ * Copyright © 2014 Akshay Jaggi <akshay1994.leo@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <List.h>
+#include <Locker.h>
+#include <Autolock.h>
+#include <USBKit.h>
+#include <map>
+#include "libusbi.h"
+#include "haiku_usb_raw.h"
+
+using namespace std;
+
+class USBDevice;
+class USBDeviceHandle;
+class USBTransfer;
+
+class USBDevice {
+public:
+						USBDevice(const char *);
+	virtual					~USBDevice();
+	const char*				Location() const;
+	uint8					CountConfigurations() const;
+	const usb_device_descriptor*		Descriptor() const;
+	const usb_configuration_descriptor*	ConfigurationDescriptor(uint32) const;
+	const usb_configuration_descriptor*	ActiveConfiguration() const;
+	uint8					EndpointToIndex(uint8) const;
+	uint8					EndpointToInterface(uint8) const;
+	int					ClaimInterface(int);
+	int					ReleaseInterface(int);
+	int					CheckInterfacesFree(int);
+	int					SetActiveConfiguration(int);
+	int					ActiveConfigurationIndex() const;
+	bool					InitCheck();
+private:
+	int					Initialise();
+	unsigned int				fClaimedInterfaces;	// Max Interfaces can be 32. Using a bitmask
+	usb_device_descriptor			fDeviceDescriptor;
+	unsigned char**				fConfigurationDescriptors;
+	int					fActiveConfiguration;
+	char*					fPath;
+	map<uint8,uint8>			fConfigToIndex;
+	map<uint8,uint8>*			fEndpointToIndex;
+	map<uint8,uint8>*			fEndpointToInterface;
+	bool					fInitCheck;
+};
+
+class USBDeviceHandle {
+public:
+				USBDeviceHandle(USBDevice *dev);
+	virtual			~USBDeviceHandle();
+	int			ClaimInterface(int);
+	int			ReleaseInterface(int);
+	int			SetConfiguration(int);
+	int			SetAltSetting(int, int);
+	status_t		SubmitTransfer(struct usbi_transfer *);
+	status_t		CancelTransfer(USBTransfer *);
+	bool			InitCheck();
+private:
+	int			fRawFD;
+	static status_t		TransfersThread(void *);
+	void			TransfersWorker();
+	USBDevice*		fUSBDevice;
+	unsigned int		fClaimedInterfaces;
+	BList			fTransfers;
+	BLocker			fTransfersLock;
+	sem_id			fTransfersSem;
+	thread_id		fTransfersThread;
+	bool			fInitCheck;
+};
+
+class USBTransfer {
+public:
+					USBTransfer(struct usbi_transfer *, USBDevice *);
+	virtual				~USBTransfer();
+	void				Do(int);
+	struct usbi_transfer*		UsbiTransfer();
+	void				SetCancelled();
+	bool				IsCancelled();
+private:
+	struct usbi_transfer*		fUsbiTransfer;
+	struct libusb_transfer*		fLibusbTransfer;
+	USBDevice*			fUSBDevice;
+	BLocker				fStatusLock;
+	bool				fCancelled;
+};
+
+class USBRoster {
+public:
+			USBRoster();
+	virtual		~USBRoster();
+	int		Start();
+	void		Stop();
+private:
+	void*		fLooper;
+};
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/os/haiku_usb_backend.cpp b/vendor/github.com/karalabe/usb/libusb/libusb/os/haiku_usb_backend.cpp
new file mode 100644
index 000000000..d3de8cc08
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/os/haiku_usb_backend.cpp
@@ -0,0 +1,517 @@
+/*
+ * Haiku Backend for libusb
+ * Copyright © 2014 Akshay Jaggi <akshay1994.leo@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+
+#include <unistd.h>
+#include <string.h>
+#include <stdlib.h>
+#include <new>
+#include <vector>
+
+#include "haiku_usb.h"
+
+int _errno_to_libusb(int status)
+{
+	return status;
+}
+
+USBTransfer::USBTransfer(struct usbi_transfer *itransfer, USBDevice *device)
+{
+	fUsbiTransfer = itransfer;
+	fLibusbTransfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	fUSBDevice = device;
+	fCancelled = false;
+}
+
+USBTransfer::~USBTransfer()
+{
+}
+
+struct usbi_transfer *
+USBTransfer::UsbiTransfer()
+{
+	return fUsbiTransfer;
+}
+
+void
+USBTransfer::SetCancelled()
+{
+	fCancelled = true;
+}
+
+bool
+USBTransfer::IsCancelled()
+{
+	return fCancelled;
+}
+
+void
+USBTransfer::Do(int fRawFD)
+{
+	switch (fLibusbTransfer->type) {
+		case LIBUSB_TRANSFER_TYPE_CONTROL:
+		{
+			struct libusb_control_setup *setup = (struct libusb_control_setup *)fLibusbTransfer->buffer;
+			usb_raw_command command;
+			command.control.request_type = setup->bmRequestType;
+			command.control.request = setup->bRequest;
+			command.control.value = setup->wValue;
+			command.control.index = setup->wIndex;
+			command.control.length = setup->wLength;
+			command.control.data = fLibusbTransfer->buffer + LIBUSB_CONTROL_SETUP_SIZE;
+			if (fCancelled)
+				break;
+			if (ioctl(fRawFD, B_USB_RAW_COMMAND_CONTROL_TRANSFER, &command, sizeof(command)) ||
+					command.control.status != B_USB_RAW_STATUS_SUCCESS) {
+				fUsbiTransfer->transferred = -1;
+				usbi_err(TRANSFER_CTX(fLibusbTransfer), "failed control transfer");
+				break;
+			}
+			fUsbiTransfer->transferred = command.control.length;
+		}
+		break;
+		case LIBUSB_TRANSFER_TYPE_BULK:
+		case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+		{
+			usb_raw_command command;
+			command.transfer.interface = fUSBDevice->EndpointToInterface(fLibusbTransfer->endpoint);
+			command.transfer.endpoint = fUSBDevice->EndpointToIndex(fLibusbTransfer->endpoint);
+			command.transfer.data = fLibusbTransfer->buffer;
+			command.transfer.length = fLibusbTransfer->length;
+			if (fCancelled)
+				break;
+			if (fLibusbTransfer->type == LIBUSB_TRANSFER_TYPE_BULK) {
+				if (ioctl(fRawFD, B_USB_RAW_COMMAND_BULK_TRANSFER, &command, sizeof(command)) ||
+						command.transfer.status != B_USB_RAW_STATUS_SUCCESS) {
+					fUsbiTransfer->transferred = -1;
+					usbi_err(TRANSFER_CTX(fLibusbTransfer), "failed bulk transfer");
+					break;
+				}
+			}
+			else {
+				if (ioctl(fRawFD, B_USB_RAW_COMMAND_INTERRUPT_TRANSFER, &command, sizeof(command)) ||
+						command.transfer.status != B_USB_RAW_STATUS_SUCCESS) {
+					fUsbiTransfer->transferred = -1;
+					usbi_err(TRANSFER_CTX(fLibusbTransfer), "failed interrupt transfer");
+					break;
+				}
+			}
+			fUsbiTransfer->transferred = command.transfer.length;
+		}
+		break;
+		// IsochronousTransfers not tested
+		case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+		{
+			usb_raw_command command;
+			command.isochronous.interface = fUSBDevice->EndpointToInterface(fLibusbTransfer->endpoint);
+			command.isochronous.endpoint = fUSBDevice->EndpointToIndex(fLibusbTransfer->endpoint);
+			command.isochronous.data = fLibusbTransfer->buffer;
+			command.isochronous.length = fLibusbTransfer->length;
+			command.isochronous.packet_count = fLibusbTransfer->num_iso_packets;
+			int i;
+			usb_iso_packet_descriptor *packetDescriptors = new usb_iso_packet_descriptor[fLibusbTransfer->num_iso_packets];
+			for (i = 0; i < fLibusbTransfer->num_iso_packets; i++) {
+				if ((int16)(fLibusbTransfer->iso_packet_desc[i]).length != (fLibusbTransfer->iso_packet_desc[i]).length) {
+					fUsbiTransfer->transferred = -1;
+					usbi_err(TRANSFER_CTX(fLibusbTransfer), "failed isochronous transfer");
+					break;
+				}
+				packetDescriptors[i].request_length = (int16)(fLibusbTransfer->iso_packet_desc[i]).length;
+			}
+			if (i < fLibusbTransfer->num_iso_packets)
+				break;	// TODO Handle this error
+			command.isochronous.packet_descriptors = packetDescriptors;
+			if (fCancelled)
+				break;
+			if (ioctl(fRawFD, B_USB_RAW_COMMAND_ISOCHRONOUS_TRANSFER, &command, sizeof(command)) ||
+					command.isochronous.status != B_USB_RAW_STATUS_SUCCESS) {
+				fUsbiTransfer->transferred = -1;
+				usbi_err(TRANSFER_CTX(fLibusbTransfer), "failed isochronous transfer");
+				break;
+			}
+			for (i = 0; i < fLibusbTransfer->num_iso_packets; i++) {
+				(fLibusbTransfer->iso_packet_desc[i]).actual_length = packetDescriptors[i].actual_length;
+				switch (packetDescriptors[i].status) {
+					case B_OK:
+						(fLibusbTransfer->iso_packet_desc[i]).status = LIBUSB_TRANSFER_COMPLETED;
+						break;
+					default:
+						(fLibusbTransfer->iso_packet_desc[i]).status = LIBUSB_TRANSFER_ERROR;
+						break;
+				}
+			}
+			delete[] packetDescriptors;
+			// Do we put the length of transfer here, for isochronous transfers?
+			fUsbiTransfer->transferred = command.transfer.length;
+		}
+		break;
+		default:
+			usbi_err(TRANSFER_CTX(fLibusbTransfer), "Unknown type of transfer");
+	}
+}
+
+bool
+USBDeviceHandle::InitCheck()
+{
+	return fInitCheck;
+}
+
+status_t
+USBDeviceHandle::TransfersThread(void *self)
+{
+	USBDeviceHandle *handle = (USBDeviceHandle *)self;
+	handle->TransfersWorker();
+	return B_OK;
+}
+
+void
+USBDeviceHandle::TransfersWorker()
+{
+	while (true) {
+		status_t status = acquire_sem(fTransfersSem);
+		if (status == B_BAD_SEM_ID)
+			break;
+		if (status == B_INTERRUPTED)
+			continue;
+		fTransfersLock.Lock();
+		USBTransfer *fPendingTransfer = (USBTransfer *) fTransfers.RemoveItem((int32)0);
+		fTransfersLock.Unlock();
+		fPendingTransfer->Do(fRawFD);
+		usbi_signal_transfer_completion(fPendingTransfer->UsbiTransfer());
+	}
+}
+
+status_t
+USBDeviceHandle::SubmitTransfer(struct usbi_transfer *itransfer)
+{
+	USBTransfer *transfer = new USBTransfer(itransfer, fUSBDevice);
+	*((USBTransfer **)usbi_transfer_get_os_priv(itransfer)) = transfer;
+	BAutolock locker(fTransfersLock);
+	fTransfers.AddItem(transfer);
+	release_sem(fTransfersSem);
+	return LIBUSB_SUCCESS;
+}
+
+status_t
+USBDeviceHandle::CancelTransfer(USBTransfer *transfer)
+{
+	transfer->SetCancelled();
+	fTransfersLock.Lock();
+	bool removed = fTransfers.RemoveItem(transfer);
+	fTransfersLock.Unlock();
+	if(removed)
+		usbi_signal_transfer_completion(transfer->UsbiTransfer());
+	return LIBUSB_SUCCESS;
+}
+
+USBDeviceHandle::USBDeviceHandle(USBDevice *dev)
+	:
+	fTransfersThread(-1),
+	fUSBDevice(dev),
+	fClaimedInterfaces(0),
+	fInitCheck(false)
+{
+	fRawFD = open(dev->Location(), O_RDWR | O_CLOEXEC);
+	if (fRawFD < 0) {
+		usbi_err(NULL,"failed to open device");
+		return;
+	}
+	fTransfersSem = create_sem(0, "Transfers Queue Sem");
+	fTransfersThread = spawn_thread(TransfersThread, "Transfer Worker", B_NORMAL_PRIORITY, this);
+	resume_thread(fTransfersThread);
+	fInitCheck = true;
+}
+
+USBDeviceHandle::~USBDeviceHandle()
+{
+	if (fRawFD > 0)
+		close(fRawFD);
+	for(int i = 0; i < 32; i++) {
+		if (fClaimedInterfaces & (1 << i))
+			ReleaseInterface(i);
+	}
+	delete_sem(fTransfersSem);
+	if (fTransfersThread > 0)
+		wait_for_thread(fTransfersThread, NULL);
+}
+
+int
+USBDeviceHandle::ClaimInterface(int inumber)
+{
+	int status = fUSBDevice->ClaimInterface(inumber);
+	if (status == LIBUSB_SUCCESS)
+		fClaimedInterfaces |= (1 << inumber);
+	return status;
+}
+
+int
+USBDeviceHandle::ReleaseInterface(int inumber)
+{
+	fUSBDevice->ReleaseInterface(inumber);
+	fClaimedInterfaces &= ~(1 << inumber);
+	return LIBUSB_SUCCESS;
+}
+
+int
+USBDeviceHandle::SetConfiguration(int config)
+{
+	int config_index = fUSBDevice->CheckInterfacesFree(config);
+	if(config_index == LIBUSB_ERROR_BUSY || config_index == LIBUSB_ERROR_NOT_FOUND)
+		return config_index;
+	usb_raw_command command;
+	command.config.config_index = config_index;
+	if (ioctl(fRawFD, B_USB_RAW_COMMAND_SET_CONFIGURATION, &command, sizeof(command)) ||
+			command.config.status != B_USB_RAW_STATUS_SUCCESS) {
+		return _errno_to_libusb(command.config.status);
+	}
+	fUSBDevice->SetActiveConfiguration(config_index);
+	return LIBUSB_SUCCESS;
+}
+
+int
+USBDeviceHandle::SetAltSetting(int inumber, int alt)
+{
+	usb_raw_command command;
+	command.alternate.config_index = fUSBDevice->ActiveConfigurationIndex();
+	command.alternate.interface_index = inumber;
+	if (ioctl(fRawFD, B_USB_RAW_COMMAND_GET_ACTIVE_ALT_INTERFACE_INDEX, &command, sizeof(command)) ||
+			command.alternate.status != B_USB_RAW_STATUS_SUCCESS) {
+		usbi_err(NULL, "Error retrieving active alternate interface");
+		return _errno_to_libusb(command.alternate.status);
+	}
+	if (command.alternate.alternate_info == alt) {
+		usbi_dbg("Setting alternate interface successful");
+		return LIBUSB_SUCCESS;
+	}
+	command.alternate.alternate_info = alt;
+	if (ioctl(fRawFD, B_USB_RAW_COMMAND_SET_ALT_INTERFACE, &command, sizeof(command)) ||
+			command.alternate.status != B_USB_RAW_STATUS_SUCCESS) { //IF IOCTL FAILS DEVICE DISONNECTED PROBABLY
+		usbi_err(NULL, "Error setting alternate interface");
+		return _errno_to_libusb(command.alternate.status);
+	}
+	usbi_dbg("Setting alternate interface successful");
+	return LIBUSB_SUCCESS;
+}
+
+
+USBDevice::USBDevice(const char *path)
+	:
+	fPath(NULL),
+	fActiveConfiguration(0),	//0?
+	fConfigurationDescriptors(NULL),
+	fClaimedInterfaces(0),
+	fEndpointToIndex(NULL),
+	fEndpointToInterface(NULL),
+	fInitCheck(false)
+{
+	fPath=strdup(path);
+	Initialise();
+}
+
+USBDevice::~USBDevice()
+{
+	free(fPath);
+	if (fConfigurationDescriptors) {
+		for(int i = 0; i < fDeviceDescriptor.num_configurations; i++) {
+			if (fConfigurationDescriptors[i])
+				delete fConfigurationDescriptors[i];
+		}
+		delete[] fConfigurationDescriptors;
+	}
+	if (fEndpointToIndex)
+		delete[] fEndpointToIndex;
+	if (fEndpointToInterface)
+		delete[] fEndpointToInterface;
+}
+
+bool
+USBDevice::InitCheck()
+{
+	return fInitCheck;
+}
+
+const char *
+USBDevice::Location() const
+{
+	return fPath;
+}
+
+uint8
+USBDevice::CountConfigurations() const
+{
+	return fDeviceDescriptor.num_configurations;
+}
+
+const usb_device_descriptor *
+USBDevice::Descriptor() const
+{
+	return &fDeviceDescriptor;
+}
+
+const usb_configuration_descriptor *
+USBDevice::ConfigurationDescriptor(uint32 index) const
+{
+	if (index > CountConfigurations())
+		return NULL;
+	return (usb_configuration_descriptor *) fConfigurationDescriptors[index];
+}
+
+const usb_configuration_descriptor *
+USBDevice::ActiveConfiguration() const
+{
+	return (usb_configuration_descriptor *) fConfigurationDescriptors[fActiveConfiguration];
+}
+
+int
+USBDevice::ActiveConfigurationIndex() const
+{
+	return fActiveConfiguration;
+}
+
+int USBDevice::ClaimInterface(int interface)
+{
+	if (interface > ActiveConfiguration()->number_interfaces)
+		return LIBUSB_ERROR_NOT_FOUND;
+	if (fClaimedInterfaces & (1 << interface))
+		return LIBUSB_ERROR_BUSY;
+	fClaimedInterfaces |= (1 << interface);
+	return LIBUSB_SUCCESS;
+}
+
+int USBDevice::ReleaseInterface(int interface)
+{
+	fClaimedInterfaces &= ~(1 << interface);
+	return LIBUSB_SUCCESS;
+}
+
+int
+USBDevice::CheckInterfacesFree(int config)
+{
+	if (fConfigToIndex.count(config) == 0)
+		return LIBUSB_ERROR_NOT_FOUND;
+	if (fClaimedInterfaces == 0)
+		return fConfigToIndex[(uint8)config];
+	return LIBUSB_ERROR_BUSY;
+}
+
+int
+USBDevice::SetActiveConfiguration(int config_index)
+{
+	fActiveConfiguration = config_index;
+	return LIBUSB_SUCCESS;
+}
+
+uint8
+USBDevice::EndpointToIndex(uint8 address) const
+{
+	return fEndpointToIndex[fActiveConfiguration][address];
+}
+
+uint8
+USBDevice::EndpointToInterface(uint8 address) const
+{
+	return fEndpointToInterface[fActiveConfiguration][address];
+}
+
+int
+USBDevice::Initialise()		//Do we need more error checking, etc? How to report?
+{
+	int fRawFD = open(fPath, O_RDWR | O_CLOEXEC);
+	if (fRawFD < 0)
+		return B_ERROR;
+	usb_raw_command command;
+	command.device.descriptor = &fDeviceDescriptor;
+	if (ioctl(fRawFD, B_USB_RAW_COMMAND_GET_DEVICE_DESCRIPTOR, &command, sizeof(command)) ||
+			command.device.status != B_USB_RAW_STATUS_SUCCESS) {
+		close(fRawFD);
+		return B_ERROR;
+	}
+
+	fConfigurationDescriptors = new(std::nothrow) unsigned char *[fDeviceDescriptor.num_configurations];
+	fEndpointToIndex = new(std::nothrow) map<uint8,uint8> [fDeviceDescriptor.num_configurations];
+	fEndpointToInterface = new(std::nothrow) map<uint8,uint8> [fDeviceDescriptor.num_configurations];
+	for (int i = 0; i < fDeviceDescriptor.num_configurations; i++) {
+		usb_configuration_descriptor tmp_config;
+		command.config.descriptor = &tmp_config;
+		command.config.config_index = i;
+		if (ioctl(fRawFD, B_USB_RAW_COMMAND_GET_CONFIGURATION_DESCRIPTOR, &command, sizeof(command)) ||
+				command.config.status != B_USB_RAW_STATUS_SUCCESS) {
+			usbi_err(NULL, "failed retrieving configuration descriptor");
+			close(fRawFD);
+			return B_ERROR;
+		}
+		fConfigToIndex[tmp_config.configuration_value] = i;
+		fConfigurationDescriptors[i] = new(std::nothrow) unsigned char[tmp_config.total_length];
+		command.control.request_type = 128;
+		command.control.request = 6;
+		command.control.value = (2 << 8) | i;
+		command.control.index = 0;
+		command.control.length = tmp_config.total_length;
+		command.control.data = fConfigurationDescriptors[i];
+		if (ioctl(fRawFD, B_USB_RAW_COMMAND_CONTROL_TRANSFER, &command, sizeof(command)) ||
+				command.control.status!=B_USB_RAW_STATUS_SUCCESS) {
+			usbi_err(NULL, "failed retrieving full configuration descriptor");
+			close(fRawFD);
+			return B_ERROR;
+		}
+		for (int j = 0; j < tmp_config.number_interfaces; j++) {
+			command.alternate.config_index = i;
+			command.alternate.interface_index = j;
+			if (ioctl(fRawFD, B_USB_RAW_COMMAND_GET_ALT_INTERFACE_COUNT, &command, sizeof(command)) ||
+					command.config.status != B_USB_RAW_STATUS_SUCCESS) {
+				usbi_err(NULL, "failed retrieving number of alternate interfaces");
+				close(fRawFD);
+				return B_ERROR;
+			}
+			int num_alternate = command.alternate.alternate_info;
+			for (int k = 0; k < num_alternate; k++) {
+				usb_interface_descriptor tmp_interface;
+				command.interface_etc.config_index = i;
+				command.interface_etc.interface_index = j;
+				command.interface_etc.alternate_index = k;
+				command.interface_etc.descriptor = &tmp_interface;
+				if (ioctl(fRawFD, B_USB_RAW_COMMAND_GET_INTERFACE_DESCRIPTOR_ETC, &command, sizeof(command)) ||
+						command.config.status != B_USB_RAW_STATUS_SUCCESS) {
+					usbi_err(NULL, "failed retrieving interface descriptor");
+					close(fRawFD);
+					return B_ERROR;
+				}
+				for (int l = 0; l < tmp_interface.num_endpoints; l++) {
+					usb_endpoint_descriptor tmp_endpoint;
+					command.endpoint_etc.config_index = i;
+					command.endpoint_etc.interface_index = j;
+					command.endpoint_etc.alternate_index = k;
+					command.endpoint_etc.endpoint_index = l;
+					command.endpoint_etc.descriptor = &tmp_endpoint;
+					if (ioctl(fRawFD, B_USB_RAW_COMMAND_GET_ENDPOINT_DESCRIPTOR_ETC, &command, sizeof(command)) ||
+							command.config.status != B_USB_RAW_STATUS_SUCCESS) {
+						usbi_err(NULL, "failed retrieving endpoint descriptor");
+						close(fRawFD);
+						return B_ERROR;
+					}
+					fEndpointToIndex[i][tmp_endpoint.endpoint_address] = l;
+					fEndpointToInterface[i][tmp_endpoint.endpoint_address] = j;
+				}
+			}
+		}
+	}
+	close(fRawFD);
+	fInitCheck = true;
+	return B_OK;
+}
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/os/haiku_usb_raw.cpp b/vendor/github.com/karalabe/usb/libusb/libusb/os/haiku_usb_raw.cpp
new file mode 100644
index 000000000..c701e3442
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/os/haiku_usb_raw.cpp
@@ -0,0 +1,253 @@
+/*
+ * Haiku Backend for libusb
+ * Copyright © 2014 Akshay Jaggi <akshay1994.leo@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+
+#include <unistd.h>
+#include <string.h>
+#include <stdlib.h>
+#include <new>
+#include <vector>
+
+#include "haiku_usb.h"
+
+USBRoster gUsbRoster;
+int32 gInitCount = 0;
+
+static int
+haiku_init(struct libusb_context *ctx)
+{
+	if (atomic_add(&gInitCount, 1) == 0)
+		return gUsbRoster.Start();
+	return LIBUSB_SUCCESS;
+}
+
+static void
+haiku_exit(struct libusb_context *ctx)
+{
+	UNUSED(ctx);
+	if (atomic_add(&gInitCount, -1) == 1)
+		gUsbRoster.Stop();
+}
+
+static int
+haiku_open(struct libusb_device_handle *dev_handle)
+{
+	USBDevice *dev = *((USBDevice **)dev_handle->dev->os_priv);
+	USBDeviceHandle *handle = new(std::nothrow) USBDeviceHandle(dev);
+	if (handle == NULL)
+		return LIBUSB_ERROR_NO_MEM;
+	if (handle->InitCheck() == false) {
+		delete handle;
+		return LIBUSB_ERROR_NO_DEVICE;
+	}
+	*((USBDeviceHandle **)dev_handle->os_priv) = handle;
+	return LIBUSB_SUCCESS;
+}
+
+static void
+haiku_close(struct libusb_device_handle *dev_handle)
+{
+	USBDeviceHandle *handle = *((USBDeviceHandle **)dev_handle->os_priv);
+	if (handle == NULL)
+		return;
+	delete handle;
+	*((USBDeviceHandle **)dev_handle->os_priv) = NULL;
+}
+
+static int
+haiku_get_device_descriptor(struct libusb_device *device, unsigned char *buffer, int *host_endian)
+{
+	USBDevice *dev = *((USBDevice **)device->os_priv);
+	memcpy(buffer, dev->Descriptor(), DEVICE_DESC_LENGTH);
+	*host_endian = 0;
+	return LIBUSB_SUCCESS;
+}
+
+static int
+haiku_get_active_config_descriptor(struct libusb_device *device, unsigned char *buffer, size_t len, int *host_endian)
+{
+	USBDevice *dev = *((USBDevice **)device->os_priv);
+	const usb_configuration_descriptor *act_config = dev->ActiveConfiguration();
+	if (len > act_config->total_length)
+		return LIBUSB_ERROR_OVERFLOW;
+	memcpy(buffer, act_config, len);
+	*host_endian = 0;
+	return LIBUSB_SUCCESS;
+}
+
+static int
+haiku_get_config_descriptor(struct libusb_device *device, uint8_t config_index, unsigned char *buffer, size_t len, int *host_endian)
+{
+	USBDevice *dev = *((USBDevice **)device->os_priv);
+	const usb_configuration_descriptor *config = dev->ConfigurationDescriptor(config_index);
+	if (config == NULL) {
+		usbi_err(DEVICE_CTX(device), "failed getting configuration descriptor");
+		return LIBUSB_ERROR_INVALID_PARAM;
+	}
+	if (len > config->total_length)
+		len = config->total_length;
+	memcpy(buffer, config, len);
+	*host_endian = 0;
+	return len;
+}
+
+static int
+haiku_set_configuration(struct libusb_device_handle *dev_handle, int config)
+{
+	USBDeviceHandle *handle= *((USBDeviceHandle **)dev_handle->os_priv);
+	return handle->SetConfiguration(config);
+}
+
+static int
+haiku_claim_interface(struct libusb_device_handle *dev_handle, int interface_number)
+{
+	USBDeviceHandle *handle = *((USBDeviceHandle **)dev_handle->os_priv);
+	return handle->ClaimInterface(interface_number);
+}
+
+static int
+haiku_set_altsetting(struct libusb_device_handle *dev_handle, int interface_number, int altsetting)
+{
+	USBDeviceHandle *handle = *((USBDeviceHandle **)dev_handle->os_priv);
+	return handle->SetAltSetting(interface_number, altsetting);
+}
+
+static int
+haiku_release_interface(struct libusb_device_handle *dev_handle, int interface_number)
+{
+	USBDeviceHandle *handle = *((USBDeviceHandle **)dev_handle->os_priv);
+	haiku_set_altsetting(dev_handle,interface_number, 0);
+	return handle->ReleaseInterface(interface_number);
+}
+
+static int
+haiku_submit_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *fLibusbTransfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	USBDeviceHandle *fDeviceHandle = *((USBDeviceHandle **)fLibusbTransfer->dev_handle->os_priv);
+	return fDeviceHandle->SubmitTransfer(itransfer);
+}
+
+static int
+haiku_cancel_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *fLibusbTransfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	USBDeviceHandle *fDeviceHandle = *((USBDeviceHandle **)fLibusbTransfer->dev_handle->os_priv);
+	return fDeviceHandle->CancelTransfer(*((USBTransfer **)usbi_transfer_get_os_priv(itransfer)));
+}
+
+static void
+haiku_clear_transfer_priv(struct usbi_transfer *itransfer)
+{
+	USBTransfer *transfer = *((USBTransfer **)usbi_transfer_get_os_priv(itransfer));
+	delete transfer;
+	*((USBTransfer **)usbi_transfer_get_os_priv(itransfer)) = NULL;
+}
+
+static int
+haiku_handle_transfer_completion(struct usbi_transfer *itransfer)
+{
+	USBTransfer *transfer = *((USBTransfer **)usbi_transfer_get_os_priv(itransfer));
+
+	usbi_mutex_lock(&itransfer->lock);
+	if (transfer->IsCancelled()) {
+		delete transfer;
+		*((USBTransfer **)usbi_transfer_get_os_priv(itransfer)) = NULL;
+		usbi_mutex_unlock(&itransfer->lock);
+		if (itransfer->transferred < 0)
+			itransfer->transferred = 0;
+		return usbi_handle_transfer_cancellation(itransfer);
+	}
+	libusb_transfer_status status = LIBUSB_TRANSFER_COMPLETED;
+	if (itransfer->transferred < 0) {
+		usbi_err(ITRANSFER_CTX(itransfer), "error in transfer");
+		status = LIBUSB_TRANSFER_ERROR;
+		itransfer->transferred = 0;
+	}
+	delete transfer;
+	*((USBTransfer **)usbi_transfer_get_os_priv(itransfer)) = NULL;
+	usbi_mutex_unlock(&itransfer->lock);
+	return usbi_handle_transfer_completion(itransfer, status);
+}
+
+static int
+haiku_clock_gettime(int clkid, struct timespec *tp)
+{
+	if (clkid == USBI_CLOCK_REALTIME)
+		return clock_gettime(CLOCK_REALTIME, tp);
+	if (clkid == USBI_CLOCK_MONOTONIC)
+		return clock_gettime(CLOCK_MONOTONIC, tp);
+	return LIBUSB_ERROR_INVALID_PARAM;
+}
+
+const struct usbi_os_backend usbi_backend = {
+	/*.name =*/ "Haiku usbfs",
+	/*.caps =*/ 0,
+	/*.init =*/ haiku_init,
+	/*.exit =*/ haiku_exit,
+	/*.set_option =*/ NULL,
+	/*.get_device_list =*/ NULL,
+	/*.hotplug_poll =*/ NULL,
+	/*.open =*/ haiku_open,
+	/*.close =*/ haiku_close,
+	/*.get_device_descriptor =*/ haiku_get_device_descriptor,
+	/*.get_active_config_descriptor =*/ haiku_get_active_config_descriptor,
+	/*.get_config_descriptor =*/ haiku_get_config_descriptor,
+	/*.get_config_descriptor_by_value =*/ NULL,
+
+
+	/*.get_configuration =*/ NULL,
+	/*.set_configuration =*/ haiku_set_configuration,
+	/*.claim_interface =*/ haiku_claim_interface,
+	/*.release_interface =*/ haiku_release_interface,
+
+	/*.set_interface_altsetting =*/ haiku_set_altsetting,
+	/*.clear_halt =*/ NULL,
+	/*.reset_device =*/ NULL,
+
+	/*.alloc_streams =*/ NULL,
+	/*.free_streams =*/ NULL,
+
+	/*.dev_mem_alloc =*/ NULL,
+	/*.dev_mem_free =*/ NULL,
+
+	/*.kernel_driver_active =*/ NULL,
+	/*.detach_kernel_driver =*/ NULL,
+	/*.attach_kernel_driver =*/ NULL,
+
+	/*.destroy_device =*/ NULL,
+
+	/*.submit_transfer =*/ haiku_submit_transfer,
+	/*.cancel_transfer =*/ haiku_cancel_transfer,
+	/*.clear_transfer_priv =*/ haiku_clear_transfer_priv,
+
+	/*.handle_events =*/ NULL,
+	/*.handle_transfer_completion =*/ haiku_handle_transfer_completion,
+
+	/*.clock_gettime =*/ haiku_clock_gettime,
+
+#ifdef USBI_TIMERFD_AVAILABLE
+	/*.get_timerfd_clockid =*/ NULL,
+#endif
+
+	/*.context_priv_size=*/ 0,
+	/*.device_priv_size =*/ sizeof(USBDevice *),
+	/*.device_handle_priv_size =*/ sizeof(USBDeviceHandle *),
+	/*.transfer_priv_size =*/ sizeof(USBTransfer *),
+};
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/os/haiku_usb_raw.h b/vendor/github.com/karalabe/usb/libusb/libusb/os/haiku_usb_raw.h
new file mode 100644
index 000000000..5baf53d7c
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/os/haiku_usb_raw.h
@@ -0,0 +1,180 @@
+/*
+ * Copyright 2006-2008, Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+
+#ifndef _USB_RAW_H_
+#define _USB_RAW_H_
+
+#include <USB3.h>
+
+#define B_USB_RAW_PROTOCOL_VERSION	0x0015
+#define B_USB_RAW_ACTIVE_ALTERNATE	0xffffffff
+
+typedef enum {
+	B_USB_RAW_COMMAND_GET_VERSION = 0x1000,
+
+	B_USB_RAW_COMMAND_GET_DEVICE_DESCRIPTOR = 0x2000,
+	B_USB_RAW_COMMAND_GET_CONFIGURATION_DESCRIPTOR,
+	B_USB_RAW_COMMAND_GET_INTERFACE_DESCRIPTOR,
+	B_USB_RAW_COMMAND_GET_ENDPOINT_DESCRIPTOR,
+	B_USB_RAW_COMMAND_GET_STRING_DESCRIPTOR,
+	B_USB_RAW_COMMAND_GET_GENERIC_DESCRIPTOR,
+	B_USB_RAW_COMMAND_GET_ALT_INTERFACE_COUNT,
+	B_USB_RAW_COMMAND_GET_ACTIVE_ALT_INTERFACE_INDEX,
+	B_USB_RAW_COMMAND_GET_INTERFACE_DESCRIPTOR_ETC,
+	B_USB_RAW_COMMAND_GET_ENDPOINT_DESCRIPTOR_ETC,
+	B_USB_RAW_COMMAND_GET_GENERIC_DESCRIPTOR_ETC,
+
+	B_USB_RAW_COMMAND_SET_CONFIGURATION = 0x3000,
+	B_USB_RAW_COMMAND_SET_FEATURE,
+	B_USB_RAW_COMMAND_CLEAR_FEATURE,
+	B_USB_RAW_COMMAND_GET_STATUS,
+	B_USB_RAW_COMMAND_GET_DESCRIPTOR,
+	B_USB_RAW_COMMAND_SET_ALT_INTERFACE,
+
+	B_USB_RAW_COMMAND_CONTROL_TRANSFER = 0x4000,
+	B_USB_RAW_COMMAND_INTERRUPT_TRANSFER,
+	B_USB_RAW_COMMAND_BULK_TRANSFER,
+	B_USB_RAW_COMMAND_ISOCHRONOUS_TRANSFER
+} usb_raw_command_id;
+
+
+typedef enum {
+	B_USB_RAW_STATUS_SUCCESS = 0,
+
+	B_USB_RAW_STATUS_FAILED,
+	B_USB_RAW_STATUS_ABORTED,
+	B_USB_RAW_STATUS_STALLED,
+	B_USB_RAW_STATUS_CRC_ERROR,
+	B_USB_RAW_STATUS_TIMEOUT,
+
+	B_USB_RAW_STATUS_INVALID_CONFIGURATION,
+	B_USB_RAW_STATUS_INVALID_INTERFACE,
+	B_USB_RAW_STATUS_INVALID_ENDPOINT,
+	B_USB_RAW_STATUS_INVALID_STRING,
+
+	B_USB_RAW_STATUS_NO_MEMORY
+} usb_raw_command_status;
+
+
+typedef union {
+	struct {
+		status_t status;
+	} version;
+
+	struct {
+		status_t status;
+		usb_device_descriptor *descriptor;
+	} device;
+
+	struct {
+		status_t status;
+		usb_configuration_descriptor *descriptor;
+		uint32 config_index;
+	} config;
+
+	struct {
+		status_t status;
+		uint32 alternate_info;
+		uint32 config_index;
+		uint32 interface_index;
+	} alternate;
+
+	struct {
+		status_t status;
+		usb_interface_descriptor *descriptor;
+		uint32 config_index;
+		uint32 interface_index;
+	} interface;
+
+	struct {
+		status_t status;
+		usb_interface_descriptor *descriptor;
+		uint32 config_index;
+		uint32 interface_index;
+		uint32 alternate_index;
+	} interface_etc;
+
+	struct {
+		status_t status;
+		usb_endpoint_descriptor *descriptor;
+		uint32 config_index;
+		uint32 interface_index;
+		uint32 endpoint_index;
+	} endpoint;
+
+	struct {
+		status_t status;
+		usb_endpoint_descriptor *descriptor;
+		uint32 config_index;
+		uint32 interface_index;
+		uint32 alternate_index;
+		uint32 endpoint_index;
+	} endpoint_etc;
+
+	struct {
+		status_t status;
+		usb_descriptor *descriptor;
+		uint32 config_index;
+		uint32 interface_index;
+		uint32 generic_index;
+		size_t length;
+	} generic;
+
+	struct {
+		status_t status;
+		usb_descriptor *descriptor;
+		uint32 config_index;
+		uint32 interface_index;
+		uint32 alternate_index;
+		uint32 generic_index;
+		size_t length;
+	} generic_etc;
+
+	struct {
+		status_t status;
+		usb_string_descriptor *descriptor;
+		uint32 string_index;
+		size_t length;
+	} string;
+
+	struct {
+		status_t status;
+		uint8 type;
+		uint8 index;
+		uint16 language_id;
+		void *data;
+		size_t length;
+	} descriptor;
+
+	struct {
+		status_t status;
+		uint8 request_type;
+		uint8 request;
+		uint16 value;
+		uint16 index;
+		uint16 length;
+		void *data;
+	} control;
+
+	struct {
+		status_t status;
+		uint32 interface;
+		uint32 endpoint;
+		void *data;
+		size_t length;
+	} transfer;
+
+	struct {
+		status_t status;
+		uint32 interface;
+		uint32 endpoint;
+		void *data;
+		size_t length;
+		usb_iso_packet_descriptor *packet_descriptors;
+		uint32 packet_count;
+	} isochronous;
+} usb_raw_command;
+
+#endif // _USB_RAW_H_
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/os/linux_netlink.c b/vendor/github.com/karalabe/usb/libusb/libusb/os/linux_netlink.c
new file mode 100644
index 000000000..c1ad1ec51
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/os/linux_netlink.c
@@ -0,0 +1,409 @@
+/* -*- Mode: C; c-basic-offset:8 ; indent-tabs-mode:t -*- */
+/*
+ * Linux usbfs backend for libusb
+ * Copyright (C) 2007-2009 Daniel Drake <dsd@gentoo.org>
+ * Copyright (c) 2001 Johannes Erdfelt <johannes@erdfelt.com>
+ * Copyright (c) 2013 Nathan Hjelm <hjelmn@mac.com>
+ * Copyright (c) 2016 Chris Dickens <christopher.a.dickens@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <config.h>
+
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/types.h>
+
+#ifdef HAVE_ASM_TYPES_H
+#include <asm/types.h>
+#endif
+
+#include <sys/socket.h>
+#include <linux/netlink.h>
+
+#include "libusbi.h"
+#include "linux_usbfs.h"
+
+#define NL_GROUP_KERNEL 1
+
+#ifndef SOCK_CLOEXEC
+#define SOCK_CLOEXEC	0
+#endif
+
+#ifndef SOCK_NONBLOCK
+#define SOCK_NONBLOCK	0
+#endif
+
+static int linux_netlink_socket = -1;
+static int netlink_control_pipe[2] = { -1, -1 };
+static pthread_t libusb_linux_event_thread;
+
+static void *linux_netlink_event_thread_main(void *arg);
+
+static int set_fd_cloexec_nb(int fd, int socktype)
+{
+	int flags;
+
+#if defined(FD_CLOEXEC)
+	/* Make sure the netlink socket file descriptor is marked as CLOEXEC */
+	if (!(socktype & SOCK_CLOEXEC)) {
+		flags = fcntl(fd, F_GETFD);
+		if (flags == -1) {
+			usbi_err(NULL, "failed to get netlink fd flags (%d)", errno);
+			return -1;
+		}
+
+		if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) == -1) {
+			usbi_err(NULL, "failed to set netlink fd flags (%d)", errno);
+			return -1;
+		}
+	}
+#endif
+
+	/* Make sure the netlink socket is non-blocking */
+	if (!(socktype & SOCK_NONBLOCK)) {
+		flags = fcntl(fd, F_GETFL);
+		if (flags == -1) {
+			usbi_err(NULL, "failed to get netlink fd status flags (%d)", errno);
+			return -1;
+		}
+
+		if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
+			usbi_err(NULL, "failed to set netlink fd status flags (%d)", errno);
+			return -1;
+		}
+	}
+
+	return 0;
+}
+
+int linux_netlink_start_event_monitor(void)
+{
+	struct sockaddr_nl sa_nl = { .nl_family = AF_NETLINK, .nl_groups = NL_GROUP_KERNEL };
+	int socktype = SOCK_RAW | SOCK_NONBLOCK | SOCK_CLOEXEC;
+	int opt = 1;
+	int ret;
+
+	linux_netlink_socket = socket(PF_NETLINK, socktype, NETLINK_KOBJECT_UEVENT);
+	if (linux_netlink_socket == -1 && errno == EINVAL) {
+		usbi_dbg("failed to create netlink socket of type %d, attempting SOCK_RAW", socktype);
+		socktype = SOCK_RAW;
+		linux_netlink_socket = socket(PF_NETLINK, socktype, NETLINK_KOBJECT_UEVENT);
+	}
+
+	if (linux_netlink_socket == -1) {
+		usbi_err(NULL, "failed to create netlink socket (%d)", errno);
+		goto err;
+	}
+
+	ret = set_fd_cloexec_nb(linux_netlink_socket, socktype);
+	if (ret == -1)
+		goto err_close_socket;
+
+	ret = bind(linux_netlink_socket, (struct sockaddr *)&sa_nl, sizeof(sa_nl));
+	if (ret == -1) {
+		usbi_err(NULL, "failed to bind netlink socket (%d)", errno);
+		goto err_close_socket;
+	}
+
+	ret = setsockopt(linux_netlink_socket, SOL_SOCKET, SO_PASSCRED, &opt, sizeof(opt));
+	if (ret == -1) {
+		usbi_err(NULL, "failed to set netlink socket SO_PASSCRED option (%d)", errno);
+		goto err_close_socket;
+	}
+
+	ret = usbi_pipe(netlink_control_pipe);
+	if (ret) {
+		usbi_err(NULL, "failed to create netlink control pipe");
+		goto err_close_socket;
+	}
+
+	ret = pthread_create(&libusb_linux_event_thread, NULL, linux_netlink_event_thread_main, NULL);
+	if (ret != 0) {
+		usbi_err(NULL, "failed to create netlink event thread (%d)", ret);
+		goto err_close_pipe;
+	}
+
+	return LIBUSB_SUCCESS;
+
+err_close_pipe:
+	close(netlink_control_pipe[0]);
+	close(netlink_control_pipe[1]);
+	netlink_control_pipe[0] = -1;
+	netlink_control_pipe[1] = -1;
+err_close_socket:
+	close(linux_netlink_socket);
+	linux_netlink_socket = -1;
+err:
+	return LIBUSB_ERROR_OTHER;
+}
+
+int linux_netlink_stop_event_monitor(void)
+{
+	char dummy = 1;
+	ssize_t r;
+
+	assert(linux_netlink_socket != -1);
+
+	/* Write some dummy data to the control pipe and
+	 * wait for the thread to exit */
+	r = write(netlink_control_pipe[1], &dummy, sizeof(dummy));
+	if (r <= 0)
+		usbi_warn(NULL, "netlink control pipe signal failed");
+
+	pthread_join(libusb_linux_event_thread, NULL);
+
+	close(linux_netlink_socket);
+	linux_netlink_socket = -1;
+
+	/* close and reset control pipe */
+	close(netlink_control_pipe[0]);
+	close(netlink_control_pipe[1]);
+	netlink_control_pipe[0] = -1;
+	netlink_control_pipe[1] = -1;
+
+	return LIBUSB_SUCCESS;
+}
+
+static const char *netlink_message_parse(const char *buffer, size_t len, const char *key)
+{
+	const char *end = buffer + len;
+	size_t keylen = strlen(key);
+
+	while (buffer < end && *buffer) {
+		if (strncmp(buffer, key, keylen) == 0 && buffer[keylen] == '=')
+			return buffer + keylen + 1;
+		buffer += strlen(buffer) + 1;
+	}
+
+	return NULL;
+}
+
+/* parse parts of netlink message common to both libudev and the kernel */
+static int linux_netlink_parse(const char *buffer, size_t len, int *detached,
+	const char **sys_name, uint8_t *busnum, uint8_t *devaddr)
+{
+	const char *tmp, *slash;
+
+	errno = 0;
+
+	*sys_name = NULL;
+	*detached = 0;
+	*busnum   = 0;
+	*devaddr  = 0;
+
+	tmp = netlink_message_parse(buffer, len, "ACTION");
+	if (!tmp) {
+		return -1;
+	} else if (strcmp(tmp, "remove") == 0) {
+		*detached = 1;
+	} else if (strcmp(tmp, "add") != 0) {
+		usbi_dbg("unknown device action %s", tmp);
+		return -1;
+	}
+
+	/* check that this is a usb message */
+	tmp = netlink_message_parse(buffer, len, "SUBSYSTEM");
+	if (!tmp || strcmp(tmp, "usb") != 0) {
+		/* not usb. ignore */
+		return -1;
+	}
+
+	/* check that this is an actual usb device */
+	tmp = netlink_message_parse(buffer, len, "DEVTYPE");
+	if (!tmp || strcmp(tmp, "usb_device") != 0) {
+		/* not usb. ignore */
+		return -1;
+	}
+
+	tmp = netlink_message_parse(buffer, len, "BUSNUM");
+	if (tmp) {
+		*busnum = (uint8_t)(strtoul(tmp, NULL, 10) & 0xff);
+		if (errno) {
+			errno = 0;
+			return -1;
+		}
+
+		tmp = netlink_message_parse(buffer, len, "DEVNUM");
+		if (NULL == tmp)
+			return -1;
+
+		*devaddr = (uint8_t)(strtoul(tmp, NULL, 10) & 0xff);
+		if (errno) {
+			errno = 0;
+			return -1;
+		}
+	} else {
+		/* no bus number. try "DEVICE" */
+		tmp = netlink_message_parse(buffer, len, "DEVICE");
+		if (!tmp) {
+			/* not usb. ignore */
+			return -1;
+		}
+
+		/* Parse a device path such as /dev/bus/usb/003/004 */
+		slash = strrchr(tmp, '/');
+		if (!slash)
+			return -1;
+
+		*busnum = (uint8_t)(strtoul(slash - 3, NULL, 10) & 0xff);
+		if (errno) {
+			errno = 0;
+			return -1;
+		}
+
+		*devaddr = (uint8_t)(strtoul(slash + 1, NULL, 10) & 0xff);
+		if (errno) {
+			errno = 0;
+			return -1;
+		}
+
+		return 0;
+	}
+
+	tmp = netlink_message_parse(buffer, len, "DEVPATH");
+	if (!tmp)
+		return -1;
+
+	slash = strrchr(tmp, '/');
+	if (slash)
+		*sys_name = slash + 1;
+
+	/* found a usb device */
+	return 0;
+}
+
+static int linux_netlink_read_message(void)
+{
+	char cred_buffer[CMSG_SPACE(sizeof(struct ucred))];
+	char msg_buffer[2048];
+	const char *sys_name = NULL;
+	uint8_t busnum, devaddr;
+	int detached, r;
+	ssize_t len;
+	struct cmsghdr *cmsg;
+	struct ucred *cred;
+	struct sockaddr_nl sa_nl;
+	struct iovec iov = { .iov_base = msg_buffer, .iov_len = sizeof(msg_buffer) };
+	struct msghdr msg = {
+		.msg_iov = &iov, .msg_iovlen = 1,
+		.msg_control = cred_buffer, .msg_controllen = sizeof(cred_buffer),
+		.msg_name = &sa_nl, .msg_namelen = sizeof(sa_nl)
+	};
+
+	/* read netlink message */
+	len = recvmsg(linux_netlink_socket, &msg, 0);
+	if (len == -1) {
+		if (errno != EAGAIN && errno != EINTR)
+			usbi_err(NULL, "error receiving message from netlink (%d)", errno);
+		return -1;
+	}
+
+	if (len < 32 || (msg.msg_flags & MSG_TRUNC)) {
+		usbi_err(NULL, "invalid netlink message length");
+		return -1;
+	}
+
+	if (sa_nl.nl_groups != NL_GROUP_KERNEL || sa_nl.nl_pid != 0) {
+		usbi_dbg("ignoring netlink message from unknown group/PID (%u/%u)",
+			 (unsigned int)sa_nl.nl_groups, (unsigned int)sa_nl.nl_pid);
+		return -1;
+	}
+
+	cmsg = CMSG_FIRSTHDR(&msg);
+	if (!cmsg || cmsg->cmsg_type != SCM_CREDENTIALS) {
+		usbi_dbg("ignoring netlink message with no sender credentials");
+		return -1;
+	}
+
+	cred = (struct ucred *)CMSG_DATA(cmsg);
+	if (cred->uid != 0) {
+		usbi_dbg("ignoring netlink message with non-zero sender UID %u", (unsigned int)cred->uid);
+		return -1;
+	}
+
+	r = linux_netlink_parse(msg_buffer, (size_t)len, &detached, &sys_name, &busnum, &devaddr);
+	if (r)
+		return r;
+
+	usbi_dbg("netlink hotplug found device busnum: %hhu, devaddr: %hhu, sys_name: %s, removed: %s",
+		 busnum, devaddr, sys_name, detached ? "yes" : "no");
+
+	/* signal device is available (or not) to all contexts */
+	if (detached)
+		linux_device_disconnected(busnum, devaddr);
+	else
+		linux_hotplug_enumerate(busnum, devaddr, sys_name);
+
+	return 0;
+}
+
+static void *linux_netlink_event_thread_main(void *arg)
+{
+	char dummy;
+	int r;
+	ssize_t nb;
+	struct pollfd fds[] = {
+		{ .fd = netlink_control_pipe[0],
+		  .events = POLLIN },
+		{ .fd = linux_netlink_socket,
+		  .events = POLLIN },
+	};
+
+	UNUSED(arg);
+
+	usbi_dbg("netlink event thread entering");
+
+	while ((r = poll(fds, 2, -1)) >= 0 || errno == EINTR) {
+		if (r < 0) {
+			/* temporary failure */
+			continue;
+		}
+		if (fds[0].revents & POLLIN) {
+			/* activity on control pipe, read the byte and exit */
+			nb = read(netlink_control_pipe[0], &dummy, sizeof(dummy));
+			if (nb <= 0)
+				usbi_warn(NULL, "netlink control pipe read failed");
+			break;
+		}
+		if (fds[1].revents & POLLIN) {
+			usbi_mutex_static_lock(&linux_hotplug_lock);
+			linux_netlink_read_message();
+			usbi_mutex_static_unlock(&linux_hotplug_lock);
+		}
+	}
+
+	usbi_dbg("netlink event thread exiting");
+
+	return NULL;
+}
+
+void linux_netlink_hotplug_poll(void)
+{
+	int r;
+
+	usbi_mutex_static_lock(&linux_hotplug_lock);
+	do {
+		r = linux_netlink_read_message();
+	} while (r == 0);
+	usbi_mutex_static_unlock(&linux_hotplug_lock);
+}
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/os/linux_udev.c b/vendor/github.com/karalabe/usb/libusb/libusb/os/linux_udev.c
new file mode 100644
index 000000000..c97806ba6
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/os/linux_udev.c
@@ -0,0 +1,329 @@
+/* -*- Mode: C; c-basic-offset:8 ; indent-tabs-mode:t -*- */
+/*
+ * Linux usbfs backend for libusb
+ * Copyright (C) 2007-2009 Daniel Drake <dsd@gentoo.org>
+ * Copyright (c) 2001 Johannes Erdfelt <johannes@erdfelt.com>
+ * Copyright (c) 2012-2013 Nathan Hjelm <hjelmn@mac.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <config.h>
+
+#include <assert.h>
+#include <ctype.h>
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/utsname.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#include <libudev.h>
+
+#include "libusbi.h"
+#include "linux_usbfs.h"
+
+/* udev context */
+static struct udev *udev_ctx = NULL;
+static int udev_monitor_fd = -1;
+static int udev_control_pipe[2] = {-1, -1};
+static struct udev_monitor *udev_monitor = NULL;
+static pthread_t linux_event_thread;
+
+static void udev_hotplug_event(struct udev_device* udev_dev);
+static void *linux_udev_event_thread_main(void *arg);
+
+int linux_udev_start_event_monitor(void)
+{
+	int r;
+
+	assert(udev_ctx == NULL);
+	udev_ctx = udev_new();
+	if (!udev_ctx) {
+		usbi_err(NULL, "could not create udev context");
+		goto err;
+	}
+
+	udev_monitor = udev_monitor_new_from_netlink(udev_ctx, "udev");
+	if (!udev_monitor) {
+		usbi_err(NULL, "could not initialize udev monitor");
+		goto err_free_ctx;
+	}
+
+	r = udev_monitor_filter_add_match_subsystem_devtype(udev_monitor, "usb", "usb_device");
+	if (r) {
+		usbi_err(NULL, "could not initialize udev monitor filter for \"usb\" subsystem");
+		goto err_free_monitor;
+	}
+
+	if (udev_monitor_enable_receiving(udev_monitor)) {
+		usbi_err(NULL, "failed to enable the udev monitor");
+		goto err_free_monitor;
+	}
+
+	udev_monitor_fd = udev_monitor_get_fd(udev_monitor);
+
+#if defined(FD_CLOEXEC)
+	/* Make sure the udev file descriptor is marked as CLOEXEC */
+	r = fcntl(udev_monitor_fd, F_GETFD);
+	if (r == -1) {
+		usbi_err(NULL, "geting udev monitor fd flags (%d)", errno);
+		goto err_free_monitor;
+	}
+	if (!(r & FD_CLOEXEC)) {
+		if (fcntl(udev_monitor_fd, F_SETFD, r | FD_CLOEXEC) == -1) {
+			usbi_err(NULL, "setting udev monitor fd flags (%d)", errno);
+			goto err_free_monitor;
+		}
+	}
+#endif
+
+	/* Some older versions of udev are not non-blocking by default,
+	 * so make sure this is set */
+	r = fcntl(udev_monitor_fd, F_GETFL);
+	if (r == -1) {
+		usbi_err(NULL, "getting udev monitor fd status flags (%d)", errno);
+		goto err_free_monitor;
+	}
+	if (!(r & O_NONBLOCK)) {
+		if (fcntl(udev_monitor_fd, F_SETFL, r | O_NONBLOCK) == -1) {
+			usbi_err(NULL, "setting udev monitor fd status flags (%d)", errno);
+			goto err_free_monitor;
+		}
+	}
+
+	r = usbi_pipe(udev_control_pipe);
+	if (r) {
+		usbi_err(NULL, "could not create udev control pipe");
+		goto err_free_monitor;
+	}
+
+	r = pthread_create(&linux_event_thread, NULL, linux_udev_event_thread_main, NULL);
+	if (r) {
+		usbi_err(NULL, "creating hotplug event thread (%d)", r);
+		goto err_close_pipe;
+	}
+
+	return LIBUSB_SUCCESS;
+
+err_close_pipe:
+	close(udev_control_pipe[0]);
+	close(udev_control_pipe[1]);
+err_free_monitor:
+	udev_monitor_unref(udev_monitor);
+	udev_monitor = NULL;
+	udev_monitor_fd = -1;
+err_free_ctx:
+	udev_unref(udev_ctx);
+err:
+	udev_ctx = NULL;
+	return LIBUSB_ERROR_OTHER;
+}
+
+int linux_udev_stop_event_monitor(void)
+{
+	char dummy = 1;
+	int r;
+
+	assert(udev_ctx != NULL);
+	assert(udev_monitor != NULL);
+	assert(udev_monitor_fd != -1);
+
+	/* Write some dummy data to the control pipe and
+	 * wait for the thread to exit */
+	r = write(udev_control_pipe[1], &dummy, sizeof(dummy));
+	if (r <= 0) {
+		usbi_warn(NULL, "udev control pipe signal failed");
+	}
+	pthread_join(linux_event_thread, NULL);
+
+	/* Release the udev monitor */
+	udev_monitor_unref(udev_monitor);
+	udev_monitor = NULL;
+	udev_monitor_fd = -1;
+
+	/* Clean up the udev context */
+	udev_unref(udev_ctx);
+	udev_ctx = NULL;
+
+	/* close and reset control pipe */
+	close(udev_control_pipe[0]);
+	close(udev_control_pipe[1]);
+	udev_control_pipe[0] = -1;
+	udev_control_pipe[1] = -1;
+
+	return LIBUSB_SUCCESS;
+}
+
+static void *linux_udev_event_thread_main(void *arg)
+{
+	char dummy;
+	int r;
+	ssize_t nb;
+	struct udev_device* udev_dev;
+	struct pollfd fds[] = {
+		{.fd = udev_control_pipe[0],
+		 .events = POLLIN},
+		{.fd = udev_monitor_fd,
+		 .events = POLLIN},
+	};
+
+	usbi_dbg("udev event thread entering.");
+
+	while ((r = poll(fds, 2, -1)) >= 0 || errno == EINTR) {
+		if (r < 0) {
+			/* temporary failure */
+			continue;
+		}
+		if (fds[0].revents & POLLIN) {
+			/* activity on control pipe, read the byte and exit */
+			nb = read(udev_control_pipe[0], &dummy, sizeof(dummy));
+			if (nb <= 0) {
+				usbi_warn(NULL, "udev control pipe read failed");
+			}
+			break;
+		}
+		if (fds[1].revents & POLLIN) {
+			usbi_mutex_static_lock(&linux_hotplug_lock);
+			udev_dev = udev_monitor_receive_device(udev_monitor);
+			if (udev_dev)
+				udev_hotplug_event(udev_dev);
+			usbi_mutex_static_unlock(&linux_hotplug_lock);
+		}
+	}
+
+	usbi_dbg("udev event thread exiting");
+
+	return NULL;
+}
+
+static int udev_device_info(struct libusb_context *ctx, int detached,
+			    struct udev_device *udev_dev, uint8_t *busnum,
+			    uint8_t *devaddr, const char **sys_name) {
+	const char *dev_node;
+
+	dev_node = udev_device_get_devnode(udev_dev);
+	if (!dev_node) {
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	*sys_name = udev_device_get_sysname(udev_dev);
+	if (!*sys_name) {
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	return linux_get_device_address(ctx, detached, busnum, devaddr,
+					dev_node, *sys_name);
+}
+
+static void udev_hotplug_event(struct udev_device* udev_dev)
+{
+	const char* udev_action;
+	const char* sys_name = NULL;
+	uint8_t busnum = 0, devaddr = 0;
+	int detached;
+	int r;
+
+	do {
+		udev_action = udev_device_get_action(udev_dev);
+		if (!udev_action) {
+			break;
+		}
+
+		detached = !strncmp(udev_action, "remove", 6);
+
+		r = udev_device_info(NULL, detached, udev_dev, &busnum, &devaddr, &sys_name);
+		if (LIBUSB_SUCCESS != r) {
+			break;
+		}
+
+		usbi_dbg("udev hotplug event. action: %s.", udev_action);
+
+		if (strncmp(udev_action, "add", 3) == 0) {
+			linux_hotplug_enumerate(busnum, devaddr, sys_name);
+		} else if (detached) {
+			linux_device_disconnected(busnum, devaddr);
+		} else {
+			usbi_err(NULL, "ignoring udev action %s", udev_action);
+		}
+	} while (0);
+
+	udev_device_unref(udev_dev);
+}
+
+int linux_udev_scan_devices(struct libusb_context *ctx)
+{
+	struct udev_enumerate *enumerator;
+	struct udev_list_entry *devices, *entry;
+	struct udev_device *udev_dev;
+	const char *sys_name;
+	int r;
+
+	assert(udev_ctx != NULL);
+
+	enumerator = udev_enumerate_new(udev_ctx);
+	if (NULL == enumerator) {
+		usbi_err(ctx, "error creating udev enumerator");
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	udev_enumerate_add_match_subsystem(enumerator, "usb");
+	udev_enumerate_add_match_property(enumerator, "DEVTYPE", "usb_device");
+	udev_enumerate_scan_devices(enumerator);
+	devices = udev_enumerate_get_list_entry(enumerator);
+
+	entry = NULL;
+	udev_list_entry_foreach(entry, devices) {
+		const char *path = udev_list_entry_get_name(entry);
+		uint8_t busnum = 0, devaddr = 0;
+
+		udev_dev = udev_device_new_from_syspath(udev_ctx, path);
+
+		r = udev_device_info(ctx, 0, udev_dev, &busnum, &devaddr, &sys_name);
+		if (r) {
+			udev_device_unref(udev_dev);
+			continue;
+		}
+
+		linux_enumerate_device(ctx, busnum, devaddr, sys_name);
+		udev_device_unref(udev_dev);
+	}
+
+	udev_enumerate_unref(enumerator);
+
+	return LIBUSB_SUCCESS;
+}
+
+void linux_udev_hotplug_poll(void)
+{
+	struct udev_device* udev_dev;
+
+	usbi_mutex_static_lock(&linux_hotplug_lock);
+	do {
+		udev_dev = udev_monitor_receive_device(udev_monitor);
+		if (udev_dev) {
+			usbi_dbg("Handling hotplug event from hotplug_poll");
+			udev_hotplug_event(udev_dev);
+		}
+	} while (udev_dev);
+	usbi_mutex_static_unlock(&linux_hotplug_lock);
+}
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/os/linux_usbfs.c b/vendor/github.com/karalabe/usb/libusb/libusb/os/linux_usbfs.c
new file mode 100644
index 000000000..768e7d5a6
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/os/linux_usbfs.c
@@ -0,0 +1,2800 @@
+/* -*- Mode: C; c-basic-offset:8 ; indent-tabs-mode:t -*- */
+/*
+ * Linux usbfs backend for libusb
+ * Copyright © 2007-2009 Daniel Drake <dsd@gentoo.org>
+ * Copyright © 2001 Johannes Erdfelt <johannes@erdfelt.com>
+ * Copyright © 2013 Nathan Hjelm <hjelmn@mac.com>
+ * Copyright © 2012-2013 Hans de Goede <hdegoede@redhat.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "config.h"
+
+#include <assert.h>
+#include <ctype.h>
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/utsname.h>
+#include <time.h>
+
+#include "libusbi.h"
+#include "linux_usbfs.h"
+
+/* sysfs vs usbfs:
+ * opening a usbfs node causes the device to be resumed, so we attempt to
+ * avoid this during enumeration.
+ *
+ * sysfs allows us to read the kernel's in-memory copies of device descriptors
+ * and so forth, avoiding the need to open the device:
+ *  - The binary "descriptors" file contains all config descriptors since
+ *    2.6.26, commit 217a9081d8e69026186067711131b77f0ce219ed
+ *  - The binary "descriptors" file was added in 2.6.23, commit
+ *    69d42a78f935d19384d1f6e4f94b65bb162b36df, but it only contains the
+ *    active config descriptors
+ *  - The "busnum" file was added in 2.6.22, commit
+ *    83f7d958eab2fbc6b159ee92bf1493924e1d0f72
+ *  - The "devnum" file has been present since pre-2.6.18
+ *  - the "bConfigurationValue" file has been present since pre-2.6.18
+ *
+ * If we have bConfigurationValue, busnum, and devnum, then we can determine
+ * the active configuration without having to open the usbfs node in RDWR mode.
+ * The busnum file is important as that is the only way we can relate sysfs
+ * devices to usbfs nodes.
+ *
+ * If we also have all descriptors, we can obtain the device descriptor and
+ * configuration without touching usbfs at all.
+ */
+
+/* endianness for multi-byte fields:
+ *
+ * Descriptors exposed by usbfs have the multi-byte fields in the device
+ * descriptor as host endian. Multi-byte fields in the other descriptors are
+ * bus-endian. The kernel documentation says otherwise, but it is wrong.
+ *
+ * In sysfs all descriptors are bus-endian.
+ */
+
+static const char *usbfs_path = NULL;
+
+/* use usbdev*.* device names in /dev instead of the usbfs bus directories */
+static int usbdev_names = 0;
+
+/* Linux has changed the maximum length of an individual isochronous packet
+ * over time.  Initially this limit was 1,023 bytes, but Linux 2.6.18
+ * (commit 3612242e527eb47ee4756b5350f8bdf791aa5ede) increased this value to
+ * 8,192 bytes to support higher bandwidth devices.  Linux 3.10
+ * (commit e2e2f0ea1c935edcf53feb4c4c8fdb4f86d57dd9) further increased this
+ * value to 49,152 bytes to support super speed devices.
+ */
+static unsigned int max_iso_packet_len = 0;
+
+/* Linux 2.6.23 adds support for O_CLOEXEC when opening files, which marks the
+ * close-on-exec flag in the underlying file descriptor. */
+static int supports_flag_cloexec = -1;
+
+/* Linux 2.6.32 adds support for a bulk continuation URB flag. this basically
+ * allows us to mark URBs as being part of a specific logical transfer when
+ * we submit them to the kernel. then, on any error except a cancellation, all
+ * URBs within that transfer will be cancelled and no more URBs will be
+ * accepted for the transfer, meaning that no more data can creep in.
+ *
+ * The BULK_CONTINUATION flag must be set on all URBs within a bulk transfer
+ * (in either direction) except the first.
+ * For IN transfers, we must also set SHORT_NOT_OK on all URBs except the
+ * last; it means that the kernel should treat a short reply as an error.
+ * For OUT transfers, SHORT_NOT_OK must not be set. it isn't needed (OUT
+ * transfers can't be short unless there's already some sort of error), and
+ * setting this flag is disallowed (a kernel with USB debugging enabled will
+ * reject such URBs).
+ */
+static int supports_flag_bulk_continuation = -1;
+
+/* Linux 2.6.31 fixes support for the zero length packet URB flag. This
+ * allows us to mark URBs that should be followed by a zero length data
+ * packet, which can be required by device- or class-specific protocols.
+ */
+static int supports_flag_zero_packet = -1;
+
+/* clock ID for monotonic clock, as not all clock sources are available on all
+ * systems. appropriate choice made at initialization time. */
+static clockid_t monotonic_clkid = -1;
+
+/* Linux 2.6.22 (commit 83f7d958eab2fbc6b159ee92bf1493924e1d0f72) adds a busnum
+ * to sysfs, so we can relate devices. This also implies that we can read
+ * the active configuration through bConfigurationValue */
+static int sysfs_can_relate_devices = -1;
+
+/* Linux 2.6.26 (commit 217a9081d8e69026186067711131b77f0ce219ed) adds all
+ * config descriptors (rather then just the active config) to the sysfs
+ * descriptors file, so from then on we can use them. */
+static int sysfs_has_descriptors = -1;
+
+/* how many times have we initted (and not exited) ? */
+static int init_count = 0;
+
+/* Serialize hotplug start/stop */
+static usbi_mutex_static_t linux_hotplug_startstop_lock = USBI_MUTEX_INITIALIZER;
+/* Serialize scan-devices, event-thread, and poll */
+usbi_mutex_static_t linux_hotplug_lock = USBI_MUTEX_INITIALIZER;
+
+static int linux_start_event_monitor(void);
+static int linux_stop_event_monitor(void);
+static int linux_scan_devices(struct libusb_context *ctx);
+static int sysfs_scan_device(struct libusb_context *ctx, const char *devname);
+static int detach_kernel_driver_and_claim(struct libusb_device_handle *, int);
+
+#if !defined(USE_UDEV)
+static int linux_default_scan_devices (struct libusb_context *ctx);
+#endif
+
+struct kernel_version {
+	int major;
+	int minor;
+	int sublevel;
+};
+
+struct linux_device_priv {
+	char *sysfs_dir;
+	unsigned char *descriptors;
+	int descriptors_len;
+	int active_config; /* cache val for !sysfs_can_relate_devices  */
+};
+
+struct linux_device_handle_priv {
+	int fd;
+	int fd_removed;
+	uint32_t caps;
+};
+
+enum reap_action {
+	NORMAL = 0,
+	/* submission failed after the first URB, so await cancellation/completion
+	 * of all the others */
+	SUBMIT_FAILED,
+
+	/* cancelled by user or timeout */
+	CANCELLED,
+
+	/* completed multi-URB transfer in non-final URB */
+	COMPLETED_EARLY,
+
+	/* one or more urbs encountered a low-level error */
+	ERROR,
+};
+
+struct linux_transfer_priv {
+	union {
+		struct usbfs_urb *urbs;
+		struct usbfs_urb **iso_urbs;
+	};
+
+	enum reap_action reap_action;
+	int num_urbs;
+	int num_retired;
+	enum libusb_transfer_status reap_status;
+
+	/* next iso packet in user-supplied transfer to be populated */
+	int iso_packet_offset;
+};
+
+static int _open(const char *path, int flags)
+{
+#if defined(O_CLOEXEC)
+	if (supports_flag_cloexec)
+		return open(path, flags | O_CLOEXEC);
+	else
+#endif
+		return open(path, flags);
+}
+
+static int _get_usbfs_fd(struct libusb_device *dev, mode_t mode, int silent)
+{
+	struct libusb_context *ctx = DEVICE_CTX(dev);
+	char path[PATH_MAX];
+	int fd;
+	int delay = 10000;
+
+	if (usbdev_names)
+		snprintf(path, PATH_MAX, "%s/usbdev%d.%d",
+			usbfs_path, dev->bus_number, dev->device_address);
+	else
+		snprintf(path, PATH_MAX, "%s/%03d/%03d",
+			usbfs_path, dev->bus_number, dev->device_address);
+
+	fd = _open(path, mode);
+	if (fd != -1)
+		return fd; /* Success */
+
+	if (errno == ENOENT) {
+		if (!silent) 
+			usbi_err(ctx, "File doesn't exist, wait %d ms and try again", delay/1000);
+   
+		/* Wait 10ms for USB device path creation.*/
+		nanosleep(&(struct timespec){delay / 1000000, (delay * 1000) % 1000000000UL}, NULL);
+
+		fd = _open(path, mode);
+		if (fd != -1)
+			return fd; /* Success */
+	}
+	
+	if (!silent) {
+		usbi_err(ctx, "libusb couldn't open USB device %s: %s",
+			 path, strerror(errno));
+		if (errno == EACCES && mode == O_RDWR)
+			usbi_err(ctx, "libusb requires write access to USB "
+				      "device nodes.");
+	}
+
+	if (errno == EACCES)
+		return LIBUSB_ERROR_ACCESS;
+	if (errno == ENOENT)
+		return LIBUSB_ERROR_NO_DEVICE;
+	return LIBUSB_ERROR_IO;
+}
+
+static struct linux_device_priv *_device_priv(struct libusb_device *dev)
+{
+	return (struct linux_device_priv *) dev->os_priv;
+}
+
+static struct linux_device_handle_priv *_device_handle_priv(
+	struct libusb_device_handle *handle)
+{
+	return (struct linux_device_handle_priv *) handle->os_priv;
+}
+
+/* check dirent for a /dev/usbdev%d.%d name
+ * optionally return bus/device on success */
+static int _is_usbdev_entry(struct dirent *entry, int *bus_p, int *dev_p)
+{
+	int busnum, devnum;
+
+	if (sscanf(entry->d_name, "usbdev%d.%d", &busnum, &devnum) != 2)
+		return 0;
+
+	usbi_dbg("found: %s", entry->d_name);
+	if (bus_p != NULL)
+		*bus_p = busnum;
+	if (dev_p != NULL)
+		*dev_p = devnum;
+	return 1;
+}
+
+static int check_usb_vfs(const char *dirname)
+{
+	DIR *dir;
+	struct dirent *entry;
+	int found = 0;
+
+	dir = opendir(dirname);
+	if (!dir)
+		return 0;
+
+	while ((entry = readdir(dir)) != NULL) {
+		if (entry->d_name[0] == '.')
+			continue;
+
+		/* We assume if we find any files that it must be the right place */
+		found = 1;
+		break;
+	}
+
+	closedir(dir);
+	return found;
+}
+
+static const char *find_usbfs_path(void)
+{
+	const char *path = "/dev/bus/usb";
+	const char *ret = NULL;
+
+	if (check_usb_vfs(path)) {
+		ret = path;
+	} else {
+		path = "/proc/bus/usb";
+		if (check_usb_vfs(path))
+			ret = path;
+	}
+
+	/* look for /dev/usbdev*.* if the normal places fail */
+	if (ret == NULL) {
+		struct dirent *entry;
+		DIR *dir;
+
+		path = "/dev";
+		dir = opendir(path);
+		if (dir != NULL) {
+			while ((entry = readdir(dir)) != NULL) {
+				if (_is_usbdev_entry(entry, NULL, NULL)) {
+					/* found one; that's enough */
+					ret = path;
+					usbdev_names = 1;
+					break;
+				}
+			}
+			closedir(dir);
+		}
+	}
+
+/* On udev based systems without any usb-devices /dev/bus/usb will not
+ * exist. So if we've not found anything and we're using udev for hotplug
+ * simply assume /dev/bus/usb rather then making libusb_init fail. */
+#if defined(USE_UDEV)
+	if (ret == NULL)
+		ret = "/dev/bus/usb";
+#endif
+
+	if (ret != NULL)
+		usbi_dbg("found usbfs at %s", ret);
+
+	return ret;
+}
+
+/* the monotonic clock is not usable on all systems (e.g. embedded ones often
+ * seem to lack it). fall back to REALTIME if we have to. */
+static clockid_t find_monotonic_clock(void)
+{
+#ifdef CLOCK_MONOTONIC
+	struct timespec ts;
+	int r;
+
+	/* Linux 2.6.28 adds CLOCK_MONOTONIC_RAW but we don't use it
+	 * because it's not available through timerfd */
+	r = clock_gettime(CLOCK_MONOTONIC, &ts);
+	if (r == 0)
+		return CLOCK_MONOTONIC;
+	usbi_dbg("monotonic clock doesn't work, errno %d", errno);
+#endif
+
+	return CLOCK_REALTIME;
+}
+
+static int get_kernel_version(struct libusb_context *ctx,
+	struct kernel_version *ver)
+{
+	struct utsname uts;
+	int atoms;
+
+	if (uname(&uts) < 0) {
+		usbi_err(ctx, "uname failed, errno %d", errno);
+		return -1;
+	}
+
+	atoms = sscanf(uts.release, "%d.%d.%d", &ver->major, &ver->minor, &ver->sublevel);
+	if (atoms < 1) {
+		usbi_err(ctx, "failed to parse uname release '%s'", uts.release);
+		return -1;
+	}
+
+	if (atoms < 2)
+		ver->minor = -1;
+	if (atoms < 3)
+		ver->sublevel = -1;
+
+	usbi_dbg("reported kernel version is %s", uts.release);
+
+	return 0;
+}
+
+static int kernel_version_ge(const struct kernel_version *ver,
+	int major, int minor, int sublevel)
+{
+	if (ver->major > major)
+		return 1;
+	else if (ver->major < major)
+		return 0;
+
+	/* kmajor == major */
+	if (ver->minor == -1 && ver->sublevel == -1)
+		return 0 == minor && 0 == sublevel;
+	else if (ver->minor > minor)
+		return 1;
+	else if (ver->minor < minor)
+		return 0;
+
+	/* kminor == minor */
+	if (ver->sublevel == -1)
+		return 0 == sublevel;
+
+	return ver->sublevel >= sublevel;
+}
+
+static int op_init(struct libusb_context *ctx)
+{
+	struct kernel_version kversion;
+	struct stat statbuf;
+	int r;
+
+	usbfs_path = find_usbfs_path();
+	if (!usbfs_path) {
+		usbi_err(ctx, "could not find usbfs");
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	if (monotonic_clkid == -1)
+		monotonic_clkid = find_monotonic_clock();
+
+	if (get_kernel_version(ctx, &kversion) < 0)
+		return LIBUSB_ERROR_OTHER;
+
+	if (supports_flag_cloexec == -1) {
+		/* O_CLOEXEC flag available from Linux 2.6.23 */
+		supports_flag_cloexec = kernel_version_ge(&kversion,2,6,23);
+	}
+
+	if (supports_flag_bulk_continuation == -1) {
+		/* bulk continuation URB flag available from Linux 2.6.32 */
+		supports_flag_bulk_continuation = kernel_version_ge(&kversion,2,6,32);
+	}
+
+	if (supports_flag_bulk_continuation)
+		usbi_dbg("bulk continuation flag supported");
+
+	if (-1 == supports_flag_zero_packet) {
+		/* zero length packet URB flag fixed since Linux 2.6.31 */
+		supports_flag_zero_packet = kernel_version_ge(&kversion,2,6,31);
+	}
+
+	if (supports_flag_zero_packet)
+		usbi_dbg("zero length packet flag supported");
+
+	if (!max_iso_packet_len) {
+		if (kernel_version_ge(&kversion,3,10,0))
+			max_iso_packet_len = 49152;
+		else if (kernel_version_ge(&kversion,2,6,18))
+			max_iso_packet_len = 8192;
+		else
+			max_iso_packet_len = 1023;
+	}
+
+	usbi_dbg("max iso packet length is (likely) %u bytes", max_iso_packet_len);
+
+	if (-1 == sysfs_has_descriptors) {
+		/* sysfs descriptors has all descriptors since Linux 2.6.26 */
+		sysfs_has_descriptors = kernel_version_ge(&kversion,2,6,26);
+	}
+
+	if (-1 == sysfs_can_relate_devices) {
+		/* sysfs has busnum since Linux 2.6.22 */
+		sysfs_can_relate_devices = kernel_version_ge(&kversion,2,6,22);
+	}
+
+	if (sysfs_can_relate_devices || sysfs_has_descriptors) {
+		r = stat(SYSFS_DEVICE_PATH, &statbuf);
+		if (r != 0 || !S_ISDIR(statbuf.st_mode)) {
+			usbi_warn(ctx, "sysfs not mounted");
+			sysfs_can_relate_devices = 0;
+			sysfs_has_descriptors = 0;
+		}
+	}
+
+	if (sysfs_can_relate_devices)
+		usbi_dbg("sysfs can relate devices");
+
+	if (sysfs_has_descriptors)
+		usbi_dbg("sysfs has complete descriptors");
+
+	usbi_mutex_static_lock(&linux_hotplug_startstop_lock);
+	r = LIBUSB_SUCCESS;
+	if (init_count == 0) {
+		/* start up hotplug event handler */
+		r = linux_start_event_monitor();
+	}
+	if (r == LIBUSB_SUCCESS) {
+		r = linux_scan_devices(ctx);
+		if (r == LIBUSB_SUCCESS)
+			init_count++;
+		else if (init_count == 0)
+			linux_stop_event_monitor();
+	} else
+		usbi_err(ctx, "error starting hotplug event monitor");
+	usbi_mutex_static_unlock(&linux_hotplug_startstop_lock);
+
+	return r;
+}
+
+static void op_exit(struct libusb_context *ctx)
+{
+	UNUSED(ctx);
+	usbi_mutex_static_lock(&linux_hotplug_startstop_lock);
+	assert(init_count != 0);
+	if (!--init_count) {
+		/* tear down event handler */
+		(void)linux_stop_event_monitor();
+	}
+	usbi_mutex_static_unlock(&linux_hotplug_startstop_lock);
+}
+
+static int linux_start_event_monitor(void)
+{
+#if defined(USE_UDEV)
+	return linux_udev_start_event_monitor();
+#else
+	return linux_netlink_start_event_monitor();
+#endif
+}
+
+static int linux_stop_event_monitor(void)
+{
+#if defined(USE_UDEV)
+	return linux_udev_stop_event_monitor();
+#else
+	return linux_netlink_stop_event_monitor();
+#endif
+}
+
+static int linux_scan_devices(struct libusb_context *ctx)
+{
+	int ret;
+
+	usbi_mutex_static_lock(&linux_hotplug_lock);
+
+#if defined(USE_UDEV)
+	ret = linux_udev_scan_devices(ctx);
+#else
+	ret = linux_default_scan_devices(ctx);
+#endif
+
+	usbi_mutex_static_unlock(&linux_hotplug_lock);
+
+	return ret;
+}
+
+static void op_hotplug_poll(void)
+{
+#if defined(USE_UDEV)
+	linux_udev_hotplug_poll();
+#else
+	linux_netlink_hotplug_poll();
+#endif
+}
+
+static int _open_sysfs_attr(struct libusb_device *dev, const char *attr)
+{
+	struct linux_device_priv *priv = _device_priv(dev);
+	char filename[PATH_MAX];
+	int fd;
+
+	snprintf(filename, PATH_MAX, "%s/%s/%s",
+		SYSFS_DEVICE_PATH, priv->sysfs_dir, attr);
+	fd = _open(filename, O_RDONLY);
+	if (fd < 0) {
+		usbi_err(DEVICE_CTX(dev),
+			"open %s failed ret=%d errno=%d", filename, fd, errno);
+		return LIBUSB_ERROR_IO;
+	}
+
+	return fd;
+}
+
+/* Note only suitable for attributes which always read >= 0, < 0 is error */
+static int __read_sysfs_attr(struct libusb_context *ctx,
+	const char *devname, const char *attr)
+{
+	char filename[PATH_MAX];
+	FILE *f;
+	int fd, r, value;
+
+	snprintf(filename, PATH_MAX, "%s/%s/%s", SYSFS_DEVICE_PATH,
+		 devname, attr);
+	fd = _open(filename, O_RDONLY);
+	if (fd == -1) {
+		if (errno == ENOENT) {
+			/* File doesn't exist. Assume the device has been
+			   disconnected (see trac ticket #70). */
+			return LIBUSB_ERROR_NO_DEVICE;
+		}
+		usbi_err(ctx, "open %s failed errno=%d", filename, errno);
+		return LIBUSB_ERROR_IO;
+	}
+
+	f = fdopen(fd, "r");
+	if (f == NULL) {
+		usbi_err(ctx, "fdopen %s failed errno=%d", filename, errno);
+		close(fd);
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	r = fscanf(f, "%d", &value);
+	fclose(f);
+	if (r != 1) {
+		usbi_err(ctx, "fscanf %s returned %d, errno=%d", attr, r, errno);
+		return LIBUSB_ERROR_NO_DEVICE; /* For unplug race (trac #70) */
+	}
+	if (value < 0) {
+		usbi_err(ctx, "%s contains a negative value", filename);
+		return LIBUSB_ERROR_IO;
+	}
+
+	return value;
+}
+
+static int op_get_device_descriptor(struct libusb_device *dev,
+	unsigned char *buffer, int *host_endian)
+{
+	struct linux_device_priv *priv = _device_priv(dev);
+
+	*host_endian = sysfs_has_descriptors ? 0 : 1;
+	memcpy(buffer, priv->descriptors, DEVICE_DESC_LENGTH);
+
+	return 0;
+}
+
+/* read the bConfigurationValue for a device */
+static int sysfs_get_active_config(struct libusb_device *dev, int *config)
+{
+	char *endptr;
+	char tmp[5] = {0, 0, 0, 0, 0};
+	long num;
+	int fd;
+	ssize_t r;
+
+	fd = _open_sysfs_attr(dev, "bConfigurationValue");
+	if (fd < 0)
+		return fd;
+
+	r = read(fd, tmp, sizeof(tmp));
+	close(fd);
+	if (r < 0) {
+		usbi_err(DEVICE_CTX(dev),
+			"read bConfigurationValue failed ret=%d errno=%d", r, errno);
+		return LIBUSB_ERROR_IO;
+	} else if (r == 0) {
+		usbi_dbg("device unconfigured");
+		*config = -1;
+		return 0;
+	}
+
+	if (tmp[sizeof(tmp) - 1] != 0) {
+		usbi_err(DEVICE_CTX(dev), "not null-terminated?");
+		return LIBUSB_ERROR_IO;
+	} else if (tmp[0] == 0) {
+		usbi_err(DEVICE_CTX(dev), "no configuration value?");
+		return LIBUSB_ERROR_IO;
+	}
+
+	num = strtol(tmp, &endptr, 10);
+	if (endptr == tmp) {
+		usbi_err(DEVICE_CTX(dev), "error converting '%s' to integer", tmp);
+		return LIBUSB_ERROR_IO;
+	}
+
+	*config = (int) num;
+	return 0;
+}
+
+int linux_get_device_address (struct libusb_context *ctx, int detached,
+	uint8_t *busnum, uint8_t *devaddr,const char *dev_node,
+	const char *sys_name)
+{
+	int sysfs_attr;
+
+	usbi_dbg("getting address for device: %s detached: %d", sys_name, detached);
+	/* can't use sysfs to read the bus and device number if the
+	 * device has been detached */
+	if (!sysfs_can_relate_devices || detached || NULL == sys_name) {
+		if (NULL == dev_node) {
+			return LIBUSB_ERROR_OTHER;
+		}
+
+		/* will this work with all supported kernel versions? */
+		if (!strncmp(dev_node, "/dev/bus/usb", 12)) {
+			sscanf (dev_node, "/dev/bus/usb/%hhu/%hhu", busnum, devaddr);
+		} else if (!strncmp(dev_node, "/proc/bus/usb", 13)) {
+			sscanf (dev_node, "/proc/bus/usb/%hhu/%hhu", busnum, devaddr);
+		}
+
+		return LIBUSB_SUCCESS;
+	}
+
+	usbi_dbg("scan %s", sys_name);
+
+	sysfs_attr = __read_sysfs_attr(ctx, sys_name, "busnum");
+	if (0 > sysfs_attr)
+		return sysfs_attr;
+	if (sysfs_attr > 255)
+		return LIBUSB_ERROR_INVALID_PARAM;
+	*busnum = (uint8_t) sysfs_attr;
+
+	sysfs_attr = __read_sysfs_attr(ctx, sys_name, "devnum");
+	if (0 > sysfs_attr)
+		return sysfs_attr;
+	if (sysfs_attr > 255)
+		return LIBUSB_ERROR_INVALID_PARAM;
+
+	*devaddr = (uint8_t) sysfs_attr;
+
+	usbi_dbg("bus=%d dev=%d", *busnum, *devaddr);
+
+	return LIBUSB_SUCCESS;
+}
+
+/* Return offset of the next descriptor with the given type */
+static int seek_to_next_descriptor(struct libusb_context *ctx,
+	uint8_t descriptor_type, unsigned char *buffer, int size)
+{
+	struct usb_descriptor_header header;
+	int i;
+
+	for (i = 0; size >= 0; i += header.bLength, size -= header.bLength) {
+		if (size == 0)
+			return LIBUSB_ERROR_NOT_FOUND;
+
+		if (size < 2) {
+			usbi_err(ctx, "short descriptor read %d/2", size);
+			return LIBUSB_ERROR_IO;
+		}
+		usbi_parse_descriptor(buffer + i, "bb", &header, 0);
+
+		if (i && header.bDescriptorType == descriptor_type)
+			return i;
+	}
+	usbi_err(ctx, "bLength overflow by %d bytes", -size);
+	return LIBUSB_ERROR_IO;
+}
+
+/* Return offset to next config */
+static int seek_to_next_config(struct libusb_context *ctx,
+	unsigned char *buffer, int size)
+{
+	struct libusb_config_descriptor config;
+
+	if (size == 0)
+		return LIBUSB_ERROR_NOT_FOUND;
+
+	if (size < LIBUSB_DT_CONFIG_SIZE) {
+		usbi_err(ctx, "short descriptor read %d/%d",
+			 size, LIBUSB_DT_CONFIG_SIZE);
+		return LIBUSB_ERROR_IO;
+	}
+
+	usbi_parse_descriptor(buffer, "bbwbbbbb", &config, 0);
+	if (config.bDescriptorType != LIBUSB_DT_CONFIG) {
+		usbi_err(ctx, "descriptor is not a config desc (type 0x%02x)",
+			 config.bDescriptorType);
+		return LIBUSB_ERROR_IO;
+	}
+
+	/*
+	 * In usbfs the config descriptors are config.wTotalLength bytes apart,
+	 * with any short reads from the device appearing as holes in the file.
+	 *
+	 * In sysfs wTotalLength is ignored, instead the kernel returns a
+	 * config descriptor with verified bLength fields, with descriptors
+	 * with an invalid bLength removed.
+	 */
+	if (sysfs_has_descriptors) {
+		int next = seek_to_next_descriptor(ctx, LIBUSB_DT_CONFIG,
+						   buffer, size);
+		if (next == LIBUSB_ERROR_NOT_FOUND)
+			next = size;
+		if (next < 0)
+			return next;
+
+		if (next != config.wTotalLength)
+			usbi_warn(ctx, "config length mismatch wTotalLength "
+				  "%d real %d", config.wTotalLength, next);
+		return next;
+	} else {
+		if (config.wTotalLength < LIBUSB_DT_CONFIG_SIZE) {
+			usbi_err(ctx, "invalid wTotalLength %d",
+				 config.wTotalLength);
+			return LIBUSB_ERROR_IO;
+		} else if (config.wTotalLength > size) {
+			usbi_warn(ctx, "short descriptor read %d/%d",
+				  size, config.wTotalLength);
+			return size;
+		} else
+			return config.wTotalLength;
+	}
+}
+
+static int op_get_config_descriptor_by_value(struct libusb_device *dev,
+	uint8_t value, unsigned char **buffer, int *host_endian)
+{
+	struct libusb_context *ctx = DEVICE_CTX(dev);
+	struct linux_device_priv *priv = _device_priv(dev);
+	unsigned char *descriptors = priv->descriptors;
+	int size = priv->descriptors_len;
+	struct libusb_config_descriptor *config;
+
+	*buffer = NULL;
+	/* Unlike the device desc. config descs. are always in raw format */
+	*host_endian = 0;
+
+	/* Skip device header */
+	descriptors += DEVICE_DESC_LENGTH;
+	size -= DEVICE_DESC_LENGTH;
+
+	/* Seek till the config is found, or till "EOF" */
+	while (1) {
+		int next = seek_to_next_config(ctx, descriptors, size);
+		if (next < 0)
+			return next;
+		config = (struct libusb_config_descriptor *)descriptors;
+		if (config->bConfigurationValue == value) {
+			*buffer = descriptors;
+			return next;
+		}
+		size -= next;
+		descriptors += next;
+	}
+}
+
+static int op_get_active_config_descriptor(struct libusb_device *dev,
+	unsigned char *buffer, size_t len, int *host_endian)
+{
+	int r, config;
+	unsigned char *config_desc;
+
+	if (sysfs_can_relate_devices) {
+		r = sysfs_get_active_config(dev, &config);
+		if (r < 0)
+			return r;
+	} else {
+		/* Use cached bConfigurationValue */
+		struct linux_device_priv *priv = _device_priv(dev);
+		config = priv->active_config;
+	}
+	if (config == -1)
+		return LIBUSB_ERROR_NOT_FOUND;
+
+	r = op_get_config_descriptor_by_value(dev, config, &config_desc,
+					      host_endian);
+	if (r < 0)
+		return r;
+
+	len = MIN(len, (size_t)r);
+	memcpy(buffer, config_desc, len);
+	return len;
+}
+
+static int op_get_config_descriptor(struct libusb_device *dev,
+	uint8_t config_index, unsigned char *buffer, size_t len, int *host_endian)
+{
+	struct linux_device_priv *priv = _device_priv(dev);
+	unsigned char *descriptors = priv->descriptors;
+	int i, r, size = priv->descriptors_len;
+
+	/* Unlike the device desc. config descs. are always in raw format */
+	*host_endian = 0;
+
+	/* Skip device header */
+	descriptors += DEVICE_DESC_LENGTH;
+	size -= DEVICE_DESC_LENGTH;
+
+	/* Seek till the config is found, or till "EOF" */
+	for (i = 0; ; i++) {
+		r = seek_to_next_config(DEVICE_CTX(dev), descriptors, size);
+		if (r < 0)
+			return r;
+		if (i == config_index)
+			break;
+		size -= r;
+		descriptors += r;
+	}
+
+	len = MIN(len, (size_t)r);
+	memcpy(buffer, descriptors, len);
+	return len;
+}
+
+/* send a control message to retrieve active configuration */
+static int usbfs_get_active_config(struct libusb_device *dev, int fd)
+{
+	struct linux_device_priv *priv = _device_priv(dev);
+	unsigned char active_config = 0;
+	int r;
+
+	struct usbfs_ctrltransfer ctrl = {
+		.bmRequestType = LIBUSB_ENDPOINT_IN,
+		.bRequest = LIBUSB_REQUEST_GET_CONFIGURATION,
+		.wValue = 0,
+		.wIndex = 0,
+		.wLength = 1,
+		.timeout = 1000,
+		.data = &active_config
+	};
+
+	r = ioctl(fd, IOCTL_USBFS_CONTROL, &ctrl);
+	if (r < 0) {
+		if (errno == ENODEV)
+			return LIBUSB_ERROR_NO_DEVICE;
+
+		/* we hit this error path frequently with buggy devices :( */
+		usbi_warn(DEVICE_CTX(dev),
+			"get_configuration failed ret=%d errno=%d", r, errno);
+		priv->active_config = -1;
+	} else {
+		if (active_config > 0) {
+			priv->active_config = active_config;
+		} else {
+			/* some buggy devices have a configuration 0, but we're
+			 * reaching into the corner of a corner case here, so let's
+			 * not support buggy devices in these circumstances.
+			 * stick to the specs: a configuration value of 0 means
+			 * unconfigured. */
+			usbi_warn(DEVICE_CTX(dev),
+				"active cfg 0? assuming unconfigured device");
+			priv->active_config = -1;
+		}
+	}
+
+	return LIBUSB_SUCCESS;
+}
+
+static int initialize_device(struct libusb_device *dev, uint8_t busnum,
+	uint8_t devaddr, const char *sysfs_dir)
+{
+	struct linux_device_priv *priv = _device_priv(dev);
+	struct libusb_context *ctx = DEVICE_CTX(dev);
+	int descriptors_size = 512; /* Begin with a 1024 byte alloc */
+	int fd, speed;
+	ssize_t r;
+
+	dev->bus_number = busnum;
+	dev->device_address = devaddr;
+
+	if (sysfs_dir) {
+		priv->sysfs_dir = strdup(sysfs_dir);
+		if (!priv->sysfs_dir)
+			return LIBUSB_ERROR_NO_MEM;
+
+		/* Note speed can contain 1.5, in this case __read_sysfs_attr
+		   will stop parsing at the '.' and return 1 */
+		speed = __read_sysfs_attr(DEVICE_CTX(dev), sysfs_dir, "speed");
+		if (speed >= 0) {
+			switch (speed) {
+			case     1: dev->speed = LIBUSB_SPEED_LOW; break;
+			case    12: dev->speed = LIBUSB_SPEED_FULL; break;
+			case   480: dev->speed = LIBUSB_SPEED_HIGH; break;
+			case  5000: dev->speed = LIBUSB_SPEED_SUPER; break;
+			case 10000: dev->speed = LIBUSB_SPEED_SUPER_PLUS; break;
+			default:
+				usbi_warn(DEVICE_CTX(dev), "Unknown device speed: %d Mbps", speed);
+			}
+		}
+	}
+
+	/* cache descriptors in memory */
+	if (sysfs_has_descriptors)
+		fd = _open_sysfs_attr(dev, "descriptors");
+	else
+		fd = _get_usbfs_fd(dev, O_RDONLY, 0);
+	if (fd < 0)
+		return fd;
+
+	do {
+		descriptors_size *= 2;
+		priv->descriptors = usbi_reallocf(priv->descriptors,
+						  descriptors_size);
+		if (!priv->descriptors) {
+			close(fd);
+			return LIBUSB_ERROR_NO_MEM;
+		}
+		/* usbfs has holes in the file */
+		if (!sysfs_has_descriptors) {
+			memset(priv->descriptors + priv->descriptors_len,
+			       0, descriptors_size - priv->descriptors_len);
+		}
+		r = read(fd, priv->descriptors + priv->descriptors_len,
+			 descriptors_size - priv->descriptors_len);
+		if (r < 0) {
+			usbi_err(ctx, "read descriptor failed ret=%d errno=%d",
+				 fd, errno);
+			close(fd);
+			return LIBUSB_ERROR_IO;
+		}
+		priv->descriptors_len += r;
+	} while (priv->descriptors_len == descriptors_size);
+
+	close(fd);
+
+	if (priv->descriptors_len < DEVICE_DESC_LENGTH) {
+		usbi_err(ctx, "short descriptor read (%d)",
+			 priv->descriptors_len);
+		return LIBUSB_ERROR_IO;
+	}
+
+	if (sysfs_can_relate_devices)
+		return LIBUSB_SUCCESS;
+
+	/* cache active config */
+	fd = _get_usbfs_fd(dev, O_RDWR, 1);
+	if (fd < 0) {
+		/* cannot send a control message to determine the active
+		 * config. just assume the first one is active. */
+		usbi_warn(ctx, "Missing rw usbfs access; cannot determine "
+			       "active configuration descriptor");
+		if (priv->descriptors_len >=
+				(DEVICE_DESC_LENGTH + LIBUSB_DT_CONFIG_SIZE)) {
+			struct libusb_config_descriptor config;
+			usbi_parse_descriptor(
+				priv->descriptors + DEVICE_DESC_LENGTH,
+				"bbwbbbbb", &config, 0);
+			priv->active_config = config.bConfigurationValue;
+		} else
+			priv->active_config = -1; /* No config dt */
+
+		return LIBUSB_SUCCESS;
+	}
+
+	r = usbfs_get_active_config(dev, fd);
+	close(fd);
+
+	return r;
+}
+
+static int linux_get_parent_info(struct libusb_device *dev, const char *sysfs_dir)
+{
+	struct libusb_context *ctx = DEVICE_CTX(dev);
+	struct libusb_device *it;
+	char *parent_sysfs_dir, *tmp;
+	int ret, add_parent = 1;
+
+	/* XXX -- can we figure out the topology when using usbfs? */
+	if (NULL == sysfs_dir || 0 == strncmp(sysfs_dir, "usb", 3)) {
+		/* either using usbfs or finding the parent of a root hub */
+		return LIBUSB_SUCCESS;
+	}
+
+	parent_sysfs_dir = strdup(sysfs_dir);
+	if (NULL == parent_sysfs_dir) {
+		return LIBUSB_ERROR_NO_MEM;
+	}
+	if (NULL != (tmp = strrchr(parent_sysfs_dir, '.')) ||
+	    NULL != (tmp = strrchr(parent_sysfs_dir, '-'))) {
+	        dev->port_number = atoi(tmp + 1);
+		*tmp = '\0';
+	} else {
+		usbi_warn(ctx, "Can not parse sysfs_dir: %s, no parent info",
+			  parent_sysfs_dir);
+		free (parent_sysfs_dir);
+		return LIBUSB_SUCCESS;
+	}
+
+	/* is the parent a root hub? */
+	if (NULL == strchr(parent_sysfs_dir, '-')) {
+		tmp = parent_sysfs_dir;
+		ret = asprintf (&parent_sysfs_dir, "usb%s", tmp);
+		free (tmp);
+		if (0 > ret) {
+			return LIBUSB_ERROR_NO_MEM;
+		}
+	}
+
+retry:
+	/* find the parent in the context */
+	usbi_mutex_lock(&ctx->usb_devs_lock);
+	list_for_each_entry(it, &ctx->usb_devs, list, struct libusb_device) {
+		struct linux_device_priv *priv = _device_priv(it);
+		if (priv->sysfs_dir) {
+			if (0 == strcmp (priv->sysfs_dir, parent_sysfs_dir)) {
+				dev->parent_dev = libusb_ref_device(it);
+				break;
+			}
+		}
+	}
+	usbi_mutex_unlock(&ctx->usb_devs_lock);
+
+	if (!dev->parent_dev && add_parent) {
+		usbi_dbg("parent_dev %s not enumerated yet, enumerating now",
+			 parent_sysfs_dir);
+		sysfs_scan_device(ctx, parent_sysfs_dir);
+		add_parent = 0;
+		goto retry;
+	}
+
+	usbi_dbg("Dev %p (%s) has parent %p (%s) port %d", dev, sysfs_dir,
+		 dev->parent_dev, parent_sysfs_dir, dev->port_number);
+
+	free (parent_sysfs_dir);
+
+	return LIBUSB_SUCCESS;
+}
+
+int linux_enumerate_device(struct libusb_context *ctx,
+	uint8_t busnum, uint8_t devaddr, const char *sysfs_dir)
+{
+	unsigned long session_id;
+	struct libusb_device *dev;
+	int r = 0;
+
+	/* FIXME: session ID is not guaranteed unique as addresses can wrap and
+	 * will be reused. instead we should add a simple sysfs attribute with
+	 * a session ID. */
+	session_id = busnum << 8 | devaddr;
+	usbi_dbg("busnum %d devaddr %d session_id %ld", busnum, devaddr,
+		session_id);
+
+	dev = usbi_get_device_by_session_id(ctx, session_id);
+	if (dev) {
+		/* device already exists in the context */
+		usbi_dbg("session_id %ld already exists", session_id);
+		libusb_unref_device(dev);
+		return LIBUSB_SUCCESS;
+	}
+
+	usbi_dbg("allocating new device for %d/%d (session %ld)",
+		 busnum, devaddr, session_id);
+	dev = usbi_alloc_device(ctx, session_id);
+	if (!dev)
+		return LIBUSB_ERROR_NO_MEM;
+
+	r = initialize_device(dev, busnum, devaddr, sysfs_dir);
+	if (r < 0)
+		goto out;
+	r = usbi_sanitize_device(dev);
+	if (r < 0)
+		goto out;
+
+	r = linux_get_parent_info(dev, sysfs_dir);
+	if (r < 0)
+		goto out;
+out:
+	if (r < 0)
+		libusb_unref_device(dev);
+	else
+		usbi_connect_device(dev);
+
+	return r;
+}
+
+void linux_hotplug_enumerate(uint8_t busnum, uint8_t devaddr, const char *sys_name)
+{
+	struct libusb_context *ctx;
+
+	usbi_mutex_static_lock(&active_contexts_lock);
+	list_for_each_entry(ctx, &active_contexts_list, list, struct libusb_context) {
+		linux_enumerate_device(ctx, busnum, devaddr, sys_name);
+	}
+	usbi_mutex_static_unlock(&active_contexts_lock);
+}
+
+void linux_device_disconnected(uint8_t busnum, uint8_t devaddr)
+{
+	struct libusb_context *ctx;
+	struct libusb_device *dev;
+	unsigned long session_id = busnum << 8 | devaddr;
+
+	usbi_mutex_static_lock(&active_contexts_lock);
+	list_for_each_entry(ctx, &active_contexts_list, list, struct libusb_context) {
+		dev = usbi_get_device_by_session_id (ctx, session_id);
+		if (NULL != dev) {
+			usbi_disconnect_device (dev);
+			libusb_unref_device(dev);
+		} else {
+			usbi_dbg("device not found for session %x", session_id);
+		}
+	}
+	usbi_mutex_static_unlock(&active_contexts_lock);
+}
+
+#if !defined(USE_UDEV)
+/* open a bus directory and adds all discovered devices to the context */
+static int usbfs_scan_busdir(struct libusb_context *ctx, uint8_t busnum)
+{
+	DIR *dir;
+	char dirpath[PATH_MAX];
+	struct dirent *entry;
+	int r = LIBUSB_ERROR_IO;
+
+	snprintf(dirpath, PATH_MAX, "%s/%03d", usbfs_path, busnum);
+	usbi_dbg("%s", dirpath);
+	dir = opendir(dirpath);
+	if (!dir) {
+		usbi_err(ctx, "opendir '%s' failed, errno=%d", dirpath, errno);
+		/* FIXME: should handle valid race conditions like hub unplugged
+		 * during directory iteration - this is not an error */
+		return r;
+	}
+
+	while ((entry = readdir(dir))) {
+		int devaddr;
+
+		if (entry->d_name[0] == '.')
+			continue;
+
+		devaddr = atoi(entry->d_name);
+		if (devaddr == 0) {
+			usbi_dbg("unknown dir entry %s", entry->d_name);
+			continue;
+		}
+
+		if (linux_enumerate_device(ctx, busnum, (uint8_t) devaddr, NULL)) {
+			usbi_dbg("failed to enumerate dir entry %s", entry->d_name);
+			continue;
+		}
+
+		r = 0;
+	}
+
+	closedir(dir);
+	return r;
+}
+
+static int usbfs_get_device_list(struct libusb_context *ctx)
+{
+	struct dirent *entry;
+	DIR *buses = opendir(usbfs_path);
+	int r = 0;
+
+	if (!buses) {
+		usbi_err(ctx, "opendir buses failed errno=%d", errno);
+		return LIBUSB_ERROR_IO;
+	}
+
+	while ((entry = readdir(buses))) {
+		int busnum;
+
+		if (entry->d_name[0] == '.')
+			continue;
+
+		if (usbdev_names) {
+			int devaddr;
+			if (!_is_usbdev_entry(entry, &busnum, &devaddr))
+				continue;
+
+			r = linux_enumerate_device(ctx, busnum, (uint8_t) devaddr, NULL);
+			if (r < 0) {
+				usbi_dbg("failed to enumerate dir entry %s", entry->d_name);
+				continue;
+			}
+		} else {
+			busnum = atoi(entry->d_name);
+			if (busnum == 0) {
+				usbi_dbg("unknown dir entry %s", entry->d_name);
+				continue;
+			}
+
+			r = usbfs_scan_busdir(ctx, busnum);
+			if (r < 0)
+				break;
+		}
+	}
+
+	closedir(buses);
+	return r;
+
+}
+#endif
+
+static int sysfs_scan_device(struct libusb_context *ctx, const char *devname)
+{
+	uint8_t busnum, devaddr;
+	int ret;
+
+	ret = linux_get_device_address (ctx, 0, &busnum, &devaddr, NULL, devname);
+	if (LIBUSB_SUCCESS != ret) {
+		return ret;
+	}
+
+	return linux_enumerate_device(ctx, busnum & 0xff, devaddr & 0xff,
+		devname);
+}
+
+#if !defined(USE_UDEV)
+static int sysfs_get_device_list(struct libusb_context *ctx)
+{
+	DIR *devices = opendir(SYSFS_DEVICE_PATH);
+	struct dirent *entry;
+	int num_devices = 0;
+	int num_enumerated = 0;
+
+	if (!devices) {
+		usbi_err(ctx, "opendir devices failed errno=%d", errno);
+		return LIBUSB_ERROR_IO;
+	}
+
+	while ((entry = readdir(devices))) {
+		if ((!isdigit(entry->d_name[0]) && strncmp(entry->d_name, "usb", 3))
+				|| strchr(entry->d_name, ':'))
+			continue;
+
+		num_devices++;
+
+		if (sysfs_scan_device(ctx, entry->d_name)) {
+			usbi_dbg("failed to enumerate dir entry %s", entry->d_name);
+			continue;
+		}
+
+		num_enumerated++;
+	}
+
+	closedir(devices);
+
+	/* successful if at least one device was enumerated or no devices were found */
+	if (num_enumerated || !num_devices)
+		return LIBUSB_SUCCESS;
+	else
+		return LIBUSB_ERROR_IO;
+}
+
+static int linux_default_scan_devices (struct libusb_context *ctx)
+{
+	/* we can retrieve device list and descriptors from sysfs or usbfs.
+	 * sysfs is preferable, because if we use usbfs we end up resuming
+	 * any autosuspended USB devices. however, sysfs is not available
+	 * everywhere, so we need a usbfs fallback too.
+	 *
+	 * as described in the "sysfs vs usbfs" comment at the top of this
+	 * file, sometimes we have sysfs but not enough information to
+	 * relate sysfs devices to usbfs nodes.  op_init() determines the
+	 * adequacy of sysfs and sets sysfs_can_relate_devices.
+	 */
+	if (sysfs_can_relate_devices != 0)
+		return sysfs_get_device_list(ctx);
+	else
+		return usbfs_get_device_list(ctx);
+}
+#endif
+
+static int op_open(struct libusb_device_handle *handle)
+{
+	struct linux_device_handle_priv *hpriv = _device_handle_priv(handle);
+	int r;
+
+	hpriv->fd = _get_usbfs_fd(handle->dev, O_RDWR, 0);
+	if (hpriv->fd < 0) {
+		if (hpriv->fd == LIBUSB_ERROR_NO_DEVICE) {
+			/* device will still be marked as attached if hotplug monitor thread
+			 * hasn't processed remove event yet */
+			usbi_mutex_static_lock(&linux_hotplug_lock);
+			if (handle->dev->attached) {
+				usbi_dbg("open failed with no device, but device still attached");
+				linux_device_disconnected(handle->dev->bus_number,
+						handle->dev->device_address);
+			}
+			usbi_mutex_static_unlock(&linux_hotplug_lock);
+		}
+		return hpriv->fd;
+	}
+
+	r = ioctl(hpriv->fd, IOCTL_USBFS_GET_CAPABILITIES, &hpriv->caps);
+	if (r < 0) {
+		if (errno == ENOTTY)
+			usbi_dbg("getcap not available");
+		else
+			usbi_err(HANDLE_CTX(handle), "getcap failed (%d)", errno);
+		hpriv->caps = 0;
+		if (supports_flag_zero_packet)
+			hpriv->caps |= USBFS_CAP_ZERO_PACKET;
+		if (supports_flag_bulk_continuation)
+			hpriv->caps |= USBFS_CAP_BULK_CONTINUATION;
+	}
+
+	r = usbi_add_pollfd(HANDLE_CTX(handle), hpriv->fd, POLLOUT);
+	if (r < 0)
+		close(hpriv->fd);
+
+	return r;
+}
+
+static void op_close(struct libusb_device_handle *dev_handle)
+{
+	struct linux_device_handle_priv *hpriv = _device_handle_priv(dev_handle);
+	/* fd may have already been removed by POLLERR condition in op_handle_events() */
+	if (!hpriv->fd_removed)
+		usbi_remove_pollfd(HANDLE_CTX(dev_handle), hpriv->fd);
+	close(hpriv->fd);
+}
+
+static int op_get_configuration(struct libusb_device_handle *handle,
+	int *config)
+{
+	int r;
+
+	if (sysfs_can_relate_devices) {
+		r = sysfs_get_active_config(handle->dev, config);
+	} else {
+		r = usbfs_get_active_config(handle->dev,
+					    _device_handle_priv(handle)->fd);
+		if (r == LIBUSB_SUCCESS)
+			*config = _device_priv(handle->dev)->active_config;
+	}
+	if (r < 0)
+		return r;
+
+	if (*config == -1) {
+		usbi_err(HANDLE_CTX(handle), "device unconfigured");
+		*config = 0;
+	}
+
+	return 0;
+}
+
+static int op_set_configuration(struct libusb_device_handle *handle, int config)
+{
+	struct linux_device_priv *priv = _device_priv(handle->dev);
+	int fd = _device_handle_priv(handle)->fd;
+	int r = ioctl(fd, IOCTL_USBFS_SETCONFIG, &config);
+	if (r) {
+		if (errno == EINVAL)
+			return LIBUSB_ERROR_NOT_FOUND;
+		else if (errno == EBUSY)
+			return LIBUSB_ERROR_BUSY;
+		else if (errno == ENODEV)
+			return LIBUSB_ERROR_NO_DEVICE;
+
+		usbi_err(HANDLE_CTX(handle), "failed, error %d errno %d", r, errno);
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	/* update our cached active config descriptor */
+	priv->active_config = config;
+
+	return LIBUSB_SUCCESS;
+}
+
+static int claim_interface(struct libusb_device_handle *handle, int iface)
+{
+	int fd = _device_handle_priv(handle)->fd;
+	int r = ioctl(fd, IOCTL_USBFS_CLAIMINTF, &iface);
+	if (r) {
+		if (errno == ENOENT)
+			return LIBUSB_ERROR_NOT_FOUND;
+		else if (errno == EBUSY)
+			return LIBUSB_ERROR_BUSY;
+		else if (errno == ENODEV)
+			return LIBUSB_ERROR_NO_DEVICE;
+
+		usbi_err(HANDLE_CTX(handle),
+			"claim interface failed, error %d errno %d", r, errno);
+		return LIBUSB_ERROR_OTHER;
+	}
+	return 0;
+}
+
+static int release_interface(struct libusb_device_handle *handle, int iface)
+{
+	int fd = _device_handle_priv(handle)->fd;
+	int r = ioctl(fd, IOCTL_USBFS_RELEASEINTF, &iface);
+	if (r) {
+		if (errno == ENODEV)
+			return LIBUSB_ERROR_NO_DEVICE;
+
+		usbi_err(HANDLE_CTX(handle),
+			"release interface failed, error %d errno %d", r, errno);
+		return LIBUSB_ERROR_OTHER;
+	}
+	return 0;
+}
+
+static int op_set_interface(struct libusb_device_handle *handle, int iface,
+	int altsetting)
+{
+	int fd = _device_handle_priv(handle)->fd;
+	struct usbfs_setinterface setintf;
+	int r;
+
+	setintf.interface = iface;
+	setintf.altsetting = altsetting;
+	r = ioctl(fd, IOCTL_USBFS_SETINTF, &setintf);
+	if (r) {
+		if (errno == EINVAL)
+			return LIBUSB_ERROR_NOT_FOUND;
+		else if (errno == ENODEV)
+			return LIBUSB_ERROR_NO_DEVICE;
+
+		usbi_err(HANDLE_CTX(handle),
+			"setintf failed error %d errno %d", r, errno);
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	return 0;
+}
+
+static int op_clear_halt(struct libusb_device_handle *handle,
+	unsigned char endpoint)
+{
+	int fd = _device_handle_priv(handle)->fd;
+	unsigned int _endpoint = endpoint;
+	int r = ioctl(fd, IOCTL_USBFS_CLEAR_HALT, &_endpoint);
+	if (r) {
+		if (errno == ENOENT)
+			return LIBUSB_ERROR_NOT_FOUND;
+		else if (errno == ENODEV)
+			return LIBUSB_ERROR_NO_DEVICE;
+
+		usbi_err(HANDLE_CTX(handle),
+			"clear_halt failed error %d errno %d", r, errno);
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	return 0;
+}
+
+static int op_reset_device(struct libusb_device_handle *handle)
+{
+	int fd = _device_handle_priv(handle)->fd;
+	int i, r, ret = 0;
+
+	/* Doing a device reset will cause the usbfs driver to get unbound
+	   from any interfaces it is bound to. By voluntarily unbinding
+	   the usbfs driver ourself, we stop the kernel from rebinding
+	   the interface after reset (which would end up with the interface
+	   getting bound to the in kernel driver if any). */
+	for (i = 0; i < USB_MAXINTERFACES; i++) {
+		if (handle->claimed_interfaces & (1L << i)) {
+			release_interface(handle, i);
+		}
+	}
+
+	usbi_mutex_lock(&handle->lock);
+	r = ioctl(fd, IOCTL_USBFS_RESET, NULL);
+	if (r) {
+		if (errno == ENODEV) {
+			ret = LIBUSB_ERROR_NOT_FOUND;
+			goto out;
+		}
+
+		usbi_err(HANDLE_CTX(handle),
+			"reset failed error %d errno %d", r, errno);
+		ret = LIBUSB_ERROR_OTHER;
+		goto out;
+	}
+
+	/* And re-claim any interfaces which were claimed before the reset */
+	for (i = 0; i < USB_MAXINTERFACES; i++) {
+		if (handle->claimed_interfaces & (1L << i)) {
+			/*
+			 * A driver may have completed modprobing during
+			 * IOCTL_USBFS_RESET, and bound itself as soon as
+			 * IOCTL_USBFS_RESET released the device lock
+			 */
+			r = detach_kernel_driver_and_claim(handle, i);
+			if (r) {
+				usbi_warn(HANDLE_CTX(handle),
+					"failed to re-claim interface %d after reset: %s",
+					i, libusb_error_name(r));
+				handle->claimed_interfaces &= ~(1L << i);
+				ret = LIBUSB_ERROR_NOT_FOUND;
+			}
+		}
+	}
+out:
+	usbi_mutex_unlock(&handle->lock);
+	return ret;
+}
+
+static int do_streams_ioctl(struct libusb_device_handle *handle, long req,
+	uint32_t num_streams, unsigned char *endpoints, int num_endpoints)
+{
+	int r, fd = _device_handle_priv(handle)->fd;
+	struct usbfs_streams *streams;
+
+	if (num_endpoints > 30) /* Max 15 in + 15 out eps */
+		return LIBUSB_ERROR_INVALID_PARAM;
+
+	streams = malloc(sizeof(struct usbfs_streams) + num_endpoints);
+	if (!streams)
+		return LIBUSB_ERROR_NO_MEM;
+
+	streams->num_streams = num_streams;
+	streams->num_eps = num_endpoints;
+	memcpy(streams->eps, endpoints, num_endpoints);
+
+	r = ioctl(fd, req, streams);
+
+	free(streams);
+
+	if (r < 0) {
+		if (errno == ENOTTY)
+			return LIBUSB_ERROR_NOT_SUPPORTED;
+		else if (errno == EINVAL)
+			return LIBUSB_ERROR_INVALID_PARAM;
+		else if (errno == ENODEV)
+			return LIBUSB_ERROR_NO_DEVICE;
+
+		usbi_err(HANDLE_CTX(handle),
+			"streams-ioctl failed error %d errno %d", r, errno);
+		return LIBUSB_ERROR_OTHER;
+	}
+	return r;
+}
+
+static int op_alloc_streams(struct libusb_device_handle *handle,
+	uint32_t num_streams, unsigned char *endpoints, int num_endpoints)
+{
+	return do_streams_ioctl(handle, IOCTL_USBFS_ALLOC_STREAMS,
+				num_streams, endpoints, num_endpoints);
+}
+
+static int op_free_streams(struct libusb_device_handle *handle,
+		unsigned char *endpoints, int num_endpoints)
+{
+	return do_streams_ioctl(handle, IOCTL_USBFS_FREE_STREAMS, 0,
+				endpoints, num_endpoints);
+}
+
+static unsigned char *op_dev_mem_alloc(struct libusb_device_handle *handle,
+	size_t len)
+{
+	struct linux_device_handle_priv *hpriv = _device_handle_priv(handle);
+	unsigned char *buffer = (unsigned char *)mmap(NULL, len,
+		PROT_READ | PROT_WRITE, MAP_SHARED, hpriv->fd, 0);
+	if (buffer == MAP_FAILED) {
+		usbi_err(HANDLE_CTX(handle), "alloc dev mem failed errno %d",
+			errno);
+		return NULL;
+	}
+	return buffer;
+}
+
+static int op_dev_mem_free(struct libusb_device_handle *handle,
+	unsigned char *buffer, size_t len)
+{
+	if (munmap(buffer, len) != 0) {
+		usbi_err(HANDLE_CTX(handle), "free dev mem failed errno %d",
+			errno);
+		return LIBUSB_ERROR_OTHER;
+	} else {
+		return LIBUSB_SUCCESS;
+	}
+}
+
+static int op_kernel_driver_active(struct libusb_device_handle *handle,
+	int interface)
+{
+	int fd = _device_handle_priv(handle)->fd;
+	struct usbfs_getdriver getdrv;
+	int r;
+
+	getdrv.interface = interface;
+	r = ioctl(fd, IOCTL_USBFS_GETDRIVER, &getdrv);
+	if (r) {
+		if (errno == ENODATA)
+			return 0;
+		else if (errno == ENODEV)
+			return LIBUSB_ERROR_NO_DEVICE;
+
+		usbi_err(HANDLE_CTX(handle),
+			"get driver failed error %d errno %d", r, errno);
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	return (strcmp(getdrv.driver, "usbfs") == 0) ? 0 : 1;
+}
+
+static int op_detach_kernel_driver(struct libusb_device_handle *handle,
+	int interface)
+{
+	int fd = _device_handle_priv(handle)->fd;
+	struct usbfs_ioctl command;
+	struct usbfs_getdriver getdrv;
+	int r;
+
+	command.ifno = interface;
+	command.ioctl_code = IOCTL_USBFS_DISCONNECT;
+	command.data = NULL;
+
+	getdrv.interface = interface;
+	r = ioctl(fd, IOCTL_USBFS_GETDRIVER, &getdrv);
+	if (r == 0 && strcmp(getdrv.driver, "usbfs") == 0)
+		return LIBUSB_ERROR_NOT_FOUND;
+
+	r = ioctl(fd, IOCTL_USBFS_IOCTL, &command);
+	if (r) {
+		if (errno == ENODATA)
+			return LIBUSB_ERROR_NOT_FOUND;
+		else if (errno == EINVAL)
+			return LIBUSB_ERROR_INVALID_PARAM;
+		else if (errno == ENODEV)
+			return LIBUSB_ERROR_NO_DEVICE;
+
+		usbi_err(HANDLE_CTX(handle),
+			"detach failed error %d errno %d", r, errno);
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	return 0;
+}
+
+static int op_attach_kernel_driver(struct libusb_device_handle *handle,
+	int interface)
+{
+	int fd = _device_handle_priv(handle)->fd;
+	struct usbfs_ioctl command;
+	int r;
+
+	command.ifno = interface;
+	command.ioctl_code = IOCTL_USBFS_CONNECT;
+	command.data = NULL;
+
+	r = ioctl(fd, IOCTL_USBFS_IOCTL, &command);
+	if (r < 0) {
+		if (errno == ENODATA)
+			return LIBUSB_ERROR_NOT_FOUND;
+		else if (errno == EINVAL)
+			return LIBUSB_ERROR_INVALID_PARAM;
+		else if (errno == ENODEV)
+			return LIBUSB_ERROR_NO_DEVICE;
+		else if (errno == EBUSY)
+			return LIBUSB_ERROR_BUSY;
+
+		usbi_err(HANDLE_CTX(handle),
+			"attach failed error %d errno %d", r, errno);
+		return LIBUSB_ERROR_OTHER;
+	} else if (r == 0) {
+		return LIBUSB_ERROR_NOT_FOUND;
+	}
+
+	return 0;
+}
+
+static int detach_kernel_driver_and_claim(struct libusb_device_handle *handle,
+	int interface)
+{
+	struct usbfs_disconnect_claim dc;
+	int r, fd = _device_handle_priv(handle)->fd;
+
+	dc.interface = interface;
+	strcpy(dc.driver, "usbfs");
+	dc.flags = USBFS_DISCONNECT_CLAIM_EXCEPT_DRIVER;
+	r = ioctl(fd, IOCTL_USBFS_DISCONNECT_CLAIM, &dc);
+	if (r != 0 && errno != ENOTTY) {
+		switch (errno) {
+		case EBUSY:
+			return LIBUSB_ERROR_BUSY;
+		case EINVAL:
+			return LIBUSB_ERROR_INVALID_PARAM;
+		case ENODEV:
+			return LIBUSB_ERROR_NO_DEVICE;
+		}
+		usbi_err(HANDLE_CTX(handle),
+			"disconnect-and-claim failed errno %d", errno);
+		return LIBUSB_ERROR_OTHER;
+	} else if (r == 0)
+		return 0;
+
+	/* Fallback code for kernels which don't support the
+	   disconnect-and-claim ioctl */
+	r = op_detach_kernel_driver(handle, interface);
+	if (r != 0 && r != LIBUSB_ERROR_NOT_FOUND)
+		return r;
+
+	return claim_interface(handle, interface);
+}
+
+static int op_claim_interface(struct libusb_device_handle *handle, int iface)
+{
+	if (handle->auto_detach_kernel_driver)
+		return detach_kernel_driver_and_claim(handle, iface);
+	else
+		return claim_interface(handle, iface);
+}
+
+static int op_release_interface(struct libusb_device_handle *handle, int iface)
+{
+	int r;
+
+	r = release_interface(handle, iface);
+	if (r)
+		return r;
+
+	if (handle->auto_detach_kernel_driver)
+		op_attach_kernel_driver(handle, iface);
+
+	return 0;
+}
+
+static void op_destroy_device(struct libusb_device *dev)
+{
+	struct linux_device_priv *priv = _device_priv(dev);
+	if (priv->descriptors)
+		free(priv->descriptors);
+	if (priv->sysfs_dir)
+		free(priv->sysfs_dir);
+}
+
+/* URBs are discarded in reverse order of submission to avoid races. */
+static int discard_urbs(struct usbi_transfer *itransfer, int first, int last_plus_one)
+{
+	struct libusb_transfer *transfer =
+		USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct linux_transfer_priv *tpriv =
+		usbi_transfer_get_os_priv(itransfer);
+	struct linux_device_handle_priv *dpriv =
+		_device_handle_priv(transfer->dev_handle);
+	int i, ret = 0;
+	struct usbfs_urb *urb;
+
+	for (i = last_plus_one - 1; i >= first; i--) {
+		if (LIBUSB_TRANSFER_TYPE_ISOCHRONOUS == transfer->type)
+			urb = tpriv->iso_urbs[i];
+		else
+			urb = &tpriv->urbs[i];
+
+		if (0 == ioctl(dpriv->fd, IOCTL_USBFS_DISCARDURB, urb))
+			continue;
+
+		if (EINVAL == errno) {
+			usbi_dbg("URB not found --> assuming ready to be reaped");
+			if (i == (last_plus_one - 1))
+				ret = LIBUSB_ERROR_NOT_FOUND;
+		} else if (ENODEV == errno) {
+			usbi_dbg("Device not found for URB --> assuming ready to be reaped");
+			ret = LIBUSB_ERROR_NO_DEVICE;
+		} else {
+			usbi_warn(TRANSFER_CTX(transfer),
+				"unrecognised discard errno %d", errno);
+			ret = LIBUSB_ERROR_OTHER;
+		}
+	}
+	return ret;
+}
+
+static void free_iso_urbs(struct linux_transfer_priv *tpriv)
+{
+	int i;
+	for (i = 0; i < tpriv->num_urbs; i++) {
+		struct usbfs_urb *urb = tpriv->iso_urbs[i];
+		if (!urb)
+			break;
+		free(urb);
+	}
+
+	free(tpriv->iso_urbs);
+	tpriv->iso_urbs = NULL;
+}
+
+static int submit_bulk_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer =
+		USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
+	struct linux_device_handle_priv *dpriv =
+		_device_handle_priv(transfer->dev_handle);
+	struct usbfs_urb *urbs;
+	int is_out = (transfer->endpoint & LIBUSB_ENDPOINT_DIR_MASK)
+		== LIBUSB_ENDPOINT_OUT;
+	int bulk_buffer_len, use_bulk_continuation;
+	int r;
+	int i;
+
+	if (is_out && (transfer->flags & LIBUSB_TRANSFER_ADD_ZERO_PACKET) &&
+			!(dpriv->caps & USBFS_CAP_ZERO_PACKET))
+		return LIBUSB_ERROR_NOT_SUPPORTED;
+
+	/*
+	 * Older versions of usbfs place a 16kb limit on bulk URBs. We work
+	 * around this by splitting large transfers into 16k blocks, and then
+	 * submit all urbs at once. it would be simpler to submit one urb at
+	 * a time, but there is a big performance gain doing it this way.
+	 *
+	 * Newer versions lift the 16k limit (USBFS_CAP_NO_PACKET_SIZE_LIM),
+	 * using arbritary large transfers can still be a bad idea though, as
+	 * the kernel needs to allocate physical contiguous memory for this,
+	 * which may fail for large buffers.
+	 *
+	 * The kernel solves this problem by splitting the transfer into
+	 * blocks itself when the host-controller is scatter-gather capable
+	 * (USBFS_CAP_BULK_SCATTER_GATHER), which most controllers are.
+	 *
+	 * Last, there is the issue of short-transfers when splitting, for
+	 * short split-transfers to work reliable USBFS_CAP_BULK_CONTINUATION
+	 * is needed, but this is not always available.
+	 */
+	if (dpriv->caps & USBFS_CAP_BULK_SCATTER_GATHER) {
+		/* Good! Just submit everything in one go */
+		bulk_buffer_len = transfer->length ? transfer->length : 1;
+		use_bulk_continuation = 0;
+	} else if (dpriv->caps & USBFS_CAP_BULK_CONTINUATION) {
+		/* Split the transfers and use bulk-continuation to
+		   avoid issues with short-transfers */
+		bulk_buffer_len = MAX_BULK_BUFFER_LENGTH;
+		use_bulk_continuation = 1;
+	} else if (dpriv->caps & USBFS_CAP_NO_PACKET_SIZE_LIM) {
+		/* Don't split, assume the kernel can alloc the buffer
+		   (otherwise the submit will fail with -ENOMEM) */
+		bulk_buffer_len = transfer->length ? transfer->length : 1;
+		use_bulk_continuation = 0;
+	} else {
+		/* Bad, splitting without bulk-continuation, short transfers
+		   which end before the last urb will not work reliable! */
+		/* Note we don't warn here as this is "normal" on kernels <
+		   2.6.32 and not a problem for most applications */
+		bulk_buffer_len = MAX_BULK_BUFFER_LENGTH;
+		use_bulk_continuation = 0;
+	}
+
+	int num_urbs = transfer->length / bulk_buffer_len;
+	int last_urb_partial = 0;
+
+	if (transfer->length == 0) {
+		num_urbs = 1;
+	} else if ((transfer->length % bulk_buffer_len) > 0) {
+		last_urb_partial = 1;
+		num_urbs++;
+	}
+	usbi_dbg("need %d urbs for new transfer with length %d", num_urbs,
+		transfer->length);
+	urbs = calloc(num_urbs, sizeof(struct usbfs_urb));
+	if (!urbs)
+		return LIBUSB_ERROR_NO_MEM;
+	tpriv->urbs = urbs;
+	tpriv->num_urbs = num_urbs;
+	tpriv->num_retired = 0;
+	tpriv->reap_action = NORMAL;
+	tpriv->reap_status = LIBUSB_TRANSFER_COMPLETED;
+
+	for (i = 0; i < num_urbs; i++) {
+		struct usbfs_urb *urb = &urbs[i];
+		urb->usercontext = itransfer;
+		switch (transfer->type) {
+		case LIBUSB_TRANSFER_TYPE_BULK:
+			urb->type = USBFS_URB_TYPE_BULK;
+			urb->stream_id = 0;
+			break;
+		case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
+			urb->type = USBFS_URB_TYPE_BULK;
+			urb->stream_id = itransfer->stream_id;
+			break;
+		case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+			urb->type = USBFS_URB_TYPE_INTERRUPT;
+			break;
+		}
+		urb->endpoint = transfer->endpoint;
+		urb->buffer = transfer->buffer + (i * bulk_buffer_len);
+		/* don't set the short not ok flag for the last URB */
+		if (use_bulk_continuation && !is_out && (i < num_urbs - 1))
+			urb->flags = USBFS_URB_SHORT_NOT_OK;
+		if (i == num_urbs - 1 && last_urb_partial)
+			urb->buffer_length = transfer->length % bulk_buffer_len;
+		else if (transfer->length == 0)
+			urb->buffer_length = 0;
+		else
+			urb->buffer_length = bulk_buffer_len;
+
+		if (i > 0 && use_bulk_continuation)
+			urb->flags |= USBFS_URB_BULK_CONTINUATION;
+
+		/* we have already checked that the flag is supported */
+		if (is_out && i == num_urbs - 1 &&
+		    transfer->flags & LIBUSB_TRANSFER_ADD_ZERO_PACKET)
+			urb->flags |= USBFS_URB_ZERO_PACKET;
+
+		r = ioctl(dpriv->fd, IOCTL_USBFS_SUBMITURB, urb);
+		if (r < 0) {
+			if (errno == ENODEV) {
+				r = LIBUSB_ERROR_NO_DEVICE;
+			} else {
+				usbi_err(TRANSFER_CTX(transfer),
+					"submiturb failed error %d errno=%d", r, errno);
+				r = LIBUSB_ERROR_IO;
+			}
+
+			/* if the first URB submission fails, we can simply free up and
+			 * return failure immediately. */
+			if (i == 0) {
+				usbi_dbg("first URB failed, easy peasy");
+				free(urbs);
+				tpriv->urbs = NULL;
+				return r;
+			}
+
+			/* if it's not the first URB that failed, the situation is a bit
+			 * tricky. we may need to discard all previous URBs. there are
+			 * complications:
+			 *  - discarding is asynchronous - discarded urbs will be reaped
+			 *    later. the user must not have freed the transfer when the
+			 *    discarded URBs are reaped, otherwise libusb will be using
+			 *    freed memory.
+			 *  - the earlier URBs may have completed successfully and we do
+			 *    not want to throw away any data.
+			 *  - this URB failing may be no error; EREMOTEIO means that
+			 *    this transfer simply didn't need all the URBs we submitted
+			 * so, we report that the transfer was submitted successfully and
+			 * in case of error we discard all previous URBs. later when
+			 * the final reap completes we can report error to the user,
+			 * or success if an earlier URB was completed successfully.
+			 */
+			tpriv->reap_action = EREMOTEIO == errno ? COMPLETED_EARLY : SUBMIT_FAILED;
+
+			/* The URBs we haven't submitted yet we count as already
+			 * retired. */
+			tpriv->num_retired += num_urbs - i;
+
+			/* If we completed short then don't try to discard. */
+			if (COMPLETED_EARLY == tpriv->reap_action)
+				return 0;
+
+			discard_urbs(itransfer, 0, i);
+
+			usbi_dbg("reporting successful submission but waiting for %d "
+				"discards before reporting error", i);
+			return 0;
+		}
+	}
+
+	return 0;
+}
+
+static int submit_iso_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer =
+		USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
+	struct linux_device_handle_priv *dpriv =
+		_device_handle_priv(transfer->dev_handle);
+	struct usbfs_urb **urbs;
+	int num_packets = transfer->num_iso_packets;
+	int num_packets_remaining;
+	int i, j;
+	int num_urbs;
+	unsigned int packet_len;
+	unsigned int total_len = 0;
+	unsigned char *urb_buffer = transfer->buffer;
+
+	if (num_packets < 1)
+		return LIBUSB_ERROR_INVALID_PARAM;
+
+	/* usbfs places arbitrary limits on iso URBs. this limit has changed
+	 * at least three times, but we attempt to detect this limit during
+	 * init and check it here. if the kernel rejects the request due to
+	 * its size, we return an error indicating such to the user.
+	 */
+	for (i = 0; i < num_packets; i++) {
+		packet_len = transfer->iso_packet_desc[i].length;
+
+		if (packet_len > max_iso_packet_len) {
+			usbi_warn(TRANSFER_CTX(transfer),
+				"iso packet length of %u bytes exceeds maximum of %u bytes",
+				packet_len, max_iso_packet_len);
+			return LIBUSB_ERROR_INVALID_PARAM;
+		}
+
+		total_len += packet_len;
+	}
+
+	if (transfer->length < (int)total_len)
+		return LIBUSB_ERROR_INVALID_PARAM;
+
+	/* usbfs limits the number of iso packets per URB */
+	num_urbs = (num_packets + (MAX_ISO_PACKETS_PER_URB - 1)) / MAX_ISO_PACKETS_PER_URB;
+
+	usbi_dbg("need %d urbs for new transfer with length %d", num_urbs,
+		transfer->length);
+
+	urbs = calloc(num_urbs, sizeof(*urbs));
+	if (!urbs)
+		return LIBUSB_ERROR_NO_MEM;
+
+	tpriv->iso_urbs = urbs;
+	tpriv->num_urbs = num_urbs;
+	tpriv->num_retired = 0;
+	tpriv->reap_action = NORMAL;
+	tpriv->iso_packet_offset = 0;
+
+	/* allocate + initialize each URB with the correct number of packets */
+	num_packets_remaining = num_packets;
+	for (i = 0, j = 0; i < num_urbs; i++) {
+		int num_packets_in_urb = MIN(num_packets_remaining, MAX_ISO_PACKETS_PER_URB);
+		struct usbfs_urb *urb;
+		size_t alloc_size;
+		int k;
+
+		alloc_size = sizeof(*urb)
+			+ (num_packets_in_urb * sizeof(struct usbfs_iso_packet_desc));
+		urb = calloc(1, alloc_size);
+		if (!urb) {
+			free_iso_urbs(tpriv);
+			return LIBUSB_ERROR_NO_MEM;
+		}
+		urbs[i] = urb;
+
+		/* populate packet lengths */
+		for (k = 0; k < num_packets_in_urb; j++, k++) {
+			packet_len = transfer->iso_packet_desc[j].length;
+			urb->buffer_length += packet_len;
+			urb->iso_frame_desc[k].length = packet_len;
+		}
+
+		urb->usercontext = itransfer;
+		urb->type = USBFS_URB_TYPE_ISO;
+		/* FIXME: interface for non-ASAP data? */
+		urb->flags = USBFS_URB_ISO_ASAP;
+		urb->endpoint = transfer->endpoint;
+		urb->number_of_packets = num_packets_in_urb;
+		urb->buffer = urb_buffer;
+
+		urb_buffer += urb->buffer_length;
+		num_packets_remaining -= num_packets_in_urb;
+	}
+
+	/* submit URBs */
+	for (i = 0; i < num_urbs; i++) {
+		int r = ioctl(dpriv->fd, IOCTL_USBFS_SUBMITURB, urbs[i]);
+		if (r < 0) {
+			if (errno == ENODEV) {
+				r = LIBUSB_ERROR_NO_DEVICE;
+			} else if (errno == EINVAL) {
+				usbi_warn(TRANSFER_CTX(transfer),
+					"submiturb failed, transfer too large");
+				r = LIBUSB_ERROR_INVALID_PARAM;
+			} else if (errno == EMSGSIZE) {
+				usbi_warn(TRANSFER_CTX(transfer),
+					"submiturb failed, iso packet length too large");
+				r = LIBUSB_ERROR_INVALID_PARAM;
+			} else {
+				usbi_err(TRANSFER_CTX(transfer),
+					"submiturb failed error %d errno=%d", r, errno);
+				r = LIBUSB_ERROR_IO;
+			}
+
+			/* if the first URB submission fails, we can simply free up and
+			 * return failure immediately. */
+			if (i == 0) {
+				usbi_dbg("first URB failed, easy peasy");
+				free_iso_urbs(tpriv);
+				return r;
+			}
+
+			/* if it's not the first URB that failed, the situation is a bit
+			 * tricky. we must discard all previous URBs. there are
+			 * complications:
+			 *  - discarding is asynchronous - discarded urbs will be reaped
+			 *    later. the user must not have freed the transfer when the
+			 *    discarded URBs are reaped, otherwise libusb will be using
+			 *    freed memory.
+			 *  - the earlier URBs may have completed successfully and we do
+			 *    not want to throw away any data.
+			 * so, in this case we discard all the previous URBs BUT we report
+			 * that the transfer was submitted successfully. then later when
+			 * the final discard completes we can report error to the user.
+			 */
+			tpriv->reap_action = SUBMIT_FAILED;
+
+			/* The URBs we haven't submitted yet we count as already
+			 * retired. */
+			tpriv->num_retired = num_urbs - i;
+			discard_urbs(itransfer, 0, i);
+
+			usbi_dbg("reporting successful submission but waiting for %d "
+				"discards before reporting error", i);
+			return 0;
+		}
+	}
+
+	return 0;
+}
+
+static int submit_control_transfer(struct usbi_transfer *itransfer)
+{
+	struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
+	struct libusb_transfer *transfer =
+		USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct linux_device_handle_priv *dpriv =
+		_device_handle_priv(transfer->dev_handle);
+	struct usbfs_urb *urb;
+	int r;
+
+	if (transfer->length - LIBUSB_CONTROL_SETUP_SIZE > MAX_CTRL_BUFFER_LENGTH)
+		return LIBUSB_ERROR_INVALID_PARAM;
+
+	urb = calloc(1, sizeof(struct usbfs_urb));
+	if (!urb)
+		return LIBUSB_ERROR_NO_MEM;
+	tpriv->urbs = urb;
+	tpriv->num_urbs = 1;
+	tpriv->reap_action = NORMAL;
+
+	urb->usercontext = itransfer;
+	urb->type = USBFS_URB_TYPE_CONTROL;
+	urb->endpoint = transfer->endpoint;
+	urb->buffer = transfer->buffer;
+	urb->buffer_length = transfer->length;
+
+	r = ioctl(dpriv->fd, IOCTL_USBFS_SUBMITURB, urb);
+	if (r < 0) {
+		free(urb);
+		tpriv->urbs = NULL;
+		if (errno == ENODEV)
+			return LIBUSB_ERROR_NO_DEVICE;
+
+		usbi_err(TRANSFER_CTX(transfer),
+			"submiturb failed error %d errno=%d", r, errno);
+		return LIBUSB_ERROR_IO;
+	}
+	return 0;
+}
+
+static int op_submit_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer =
+		USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+
+	switch (transfer->type) {
+	case LIBUSB_TRANSFER_TYPE_CONTROL:
+		return submit_control_transfer(itransfer);
+	case LIBUSB_TRANSFER_TYPE_BULK:
+	case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
+		return submit_bulk_transfer(itransfer);
+	case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+		return submit_bulk_transfer(itransfer);
+	case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+		return submit_iso_transfer(itransfer);
+	default:
+		usbi_err(TRANSFER_CTX(transfer),
+			"unknown endpoint type %d", transfer->type);
+		return LIBUSB_ERROR_INVALID_PARAM;
+	}
+}
+
+static int op_cancel_transfer(struct usbi_transfer *itransfer)
+{
+	struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
+	struct libusb_transfer *transfer =
+		USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	int r;
+
+	if (!tpriv->urbs)
+		return LIBUSB_ERROR_NOT_FOUND;
+
+	r = discard_urbs(itransfer, 0, tpriv->num_urbs);
+	if (r != 0)
+		return r;
+
+	switch (transfer->type) {
+	case LIBUSB_TRANSFER_TYPE_BULK:
+	case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
+		if (tpriv->reap_action == ERROR)
+			break;
+		/* else, fall through */
+	default:
+		tpriv->reap_action = CANCELLED;
+	}
+
+	return 0;
+}
+
+static void op_clear_transfer_priv(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer =
+		USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
+
+	switch (transfer->type) {
+	case LIBUSB_TRANSFER_TYPE_CONTROL:
+	case LIBUSB_TRANSFER_TYPE_BULK:
+	case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
+	case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+		if (tpriv->urbs) {
+			free(tpriv->urbs);
+			tpriv->urbs = NULL;
+		}
+		break;
+	case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+		if (tpriv->iso_urbs) {
+			free_iso_urbs(tpriv);
+			tpriv->iso_urbs = NULL;
+		}
+		break;
+	default:
+		usbi_err(TRANSFER_CTX(transfer),
+			"unknown endpoint type %d", transfer->type);
+	}
+}
+
+static int handle_bulk_completion(struct usbi_transfer *itransfer,
+	struct usbfs_urb *urb)
+{
+	struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	int urb_idx = urb - tpriv->urbs;
+
+	usbi_mutex_lock(&itransfer->lock);
+	usbi_dbg("handling completion status %d of bulk urb %d/%d", urb->status,
+		urb_idx + 1, tpriv->num_urbs);
+
+	tpriv->num_retired++;
+
+	if (tpriv->reap_action != NORMAL) {
+		/* cancelled, submit_fail, or completed early */
+		usbi_dbg("abnormal reap: urb status %d", urb->status);
+
+		/* even though we're in the process of cancelling, it's possible that
+		 * we may receive some data in these URBs that we don't want to lose.
+		 * examples:
+		 * 1. while the kernel is cancelling all the packets that make up an
+		 *    URB, a few of them might complete. so we get back a successful
+		 *    cancellation *and* some data.
+		 * 2. we receive a short URB which marks the early completion condition,
+		 *    so we start cancelling the remaining URBs. however, we're too
+		 *    slow and another URB completes (or at least completes partially).
+		 *    (this can't happen since we always use BULK_CONTINUATION.)
+		 *
+		 * When this happens, our objectives are not to lose any "surplus" data,
+		 * and also to stick it at the end of the previously-received data
+		 * (closing any holes), so that libusb reports the total amount of
+		 * transferred data and presents it in a contiguous chunk.
+		 */
+		if (urb->actual_length > 0) {
+			unsigned char *target = transfer->buffer + itransfer->transferred;
+			usbi_dbg("received %d bytes of surplus data", urb->actual_length);
+			if (urb->buffer != target) {
+				usbi_dbg("moving surplus data from offset %d to offset %d",
+					(unsigned char *) urb->buffer - transfer->buffer,
+					target - transfer->buffer);
+				memmove(target, urb->buffer, urb->actual_length);
+			}
+			itransfer->transferred += urb->actual_length;
+		}
+
+		if (tpriv->num_retired == tpriv->num_urbs) {
+			usbi_dbg("abnormal reap: last URB handled, reporting");
+			if (tpriv->reap_action != COMPLETED_EARLY &&
+			    tpriv->reap_status == LIBUSB_TRANSFER_COMPLETED)
+				tpriv->reap_status = LIBUSB_TRANSFER_ERROR;
+			goto completed;
+		}
+		goto out_unlock;
+	}
+
+	itransfer->transferred += urb->actual_length;
+
+	/* Many of these errors can occur on *any* urb of a multi-urb
+	 * transfer.  When they do, we tear down the rest of the transfer.
+	 */
+	switch (urb->status) {
+	case 0:
+		break;
+	case -EREMOTEIO: /* short transfer */
+		break;
+	case -ENOENT: /* cancelled */
+	case -ECONNRESET:
+		break;
+	case -ENODEV:
+	case -ESHUTDOWN:
+		usbi_dbg("device removed");
+		tpriv->reap_status = LIBUSB_TRANSFER_NO_DEVICE;
+		goto cancel_remaining;
+	case -EPIPE:
+		usbi_dbg("detected endpoint stall");
+		if (tpriv->reap_status == LIBUSB_TRANSFER_COMPLETED)
+			tpriv->reap_status = LIBUSB_TRANSFER_STALL;
+		goto cancel_remaining;
+	case -EOVERFLOW:
+		/* overflow can only ever occur in the last urb */
+		usbi_dbg("overflow, actual_length=%d", urb->actual_length);
+		if (tpriv->reap_status == LIBUSB_TRANSFER_COMPLETED)
+			tpriv->reap_status = LIBUSB_TRANSFER_OVERFLOW;
+		goto completed;
+	case -ETIME:
+	case -EPROTO:
+	case -EILSEQ:
+	case -ECOMM:
+	case -ENOSR:
+		usbi_dbg("low level error %d", urb->status);
+		tpriv->reap_action = ERROR;
+		goto cancel_remaining;
+	default:
+		usbi_warn(ITRANSFER_CTX(itransfer),
+			"unrecognised urb status %d", urb->status);
+		tpriv->reap_action = ERROR;
+		goto cancel_remaining;
+	}
+
+	/* if we're the last urb or we got less data than requested then we're
+	 * done */
+	if (urb_idx == tpriv->num_urbs - 1) {
+		usbi_dbg("last URB in transfer --> complete!");
+		goto completed;
+	} else if (urb->actual_length < urb->buffer_length) {
+		usbi_dbg("short transfer %d/%d --> complete!",
+			urb->actual_length, urb->buffer_length);
+		if (tpriv->reap_action == NORMAL)
+			tpriv->reap_action = COMPLETED_EARLY;
+	} else
+		goto out_unlock;
+
+cancel_remaining:
+	if (ERROR == tpriv->reap_action && LIBUSB_TRANSFER_COMPLETED == tpriv->reap_status)
+		tpriv->reap_status = LIBUSB_TRANSFER_ERROR;
+
+	if (tpriv->num_retired == tpriv->num_urbs) /* nothing to cancel */
+		goto completed;
+
+	/* cancel remaining urbs and wait for their completion before
+	 * reporting results */
+	discard_urbs(itransfer, urb_idx + 1, tpriv->num_urbs);
+
+out_unlock:
+	usbi_mutex_unlock(&itransfer->lock);
+	return 0;
+
+completed:
+	free(tpriv->urbs);
+	tpriv->urbs = NULL;
+	usbi_mutex_unlock(&itransfer->lock);
+	return CANCELLED == tpriv->reap_action ?
+		usbi_handle_transfer_cancellation(itransfer) :
+		usbi_handle_transfer_completion(itransfer, tpriv->reap_status);
+}
+
+static int handle_iso_completion(struct usbi_transfer *itransfer,
+	struct usbfs_urb *urb)
+{
+	struct libusb_transfer *transfer =
+		USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
+	int num_urbs = tpriv->num_urbs;
+	int urb_idx = 0;
+	int i;
+	enum libusb_transfer_status status = LIBUSB_TRANSFER_COMPLETED;
+
+	usbi_mutex_lock(&itransfer->lock);
+	for (i = 0; i < num_urbs; i++) {
+		if (urb == tpriv->iso_urbs[i]) {
+			urb_idx = i + 1;
+			break;
+		}
+	}
+	if (urb_idx == 0) {
+		usbi_err(TRANSFER_CTX(transfer), "could not locate urb!");
+		usbi_mutex_unlock(&itransfer->lock);
+		return LIBUSB_ERROR_NOT_FOUND;
+	}
+
+	usbi_dbg("handling completion status %d of iso urb %d/%d", urb->status,
+		urb_idx, num_urbs);
+
+	/* copy isochronous results back in */
+
+	for (i = 0; i < urb->number_of_packets; i++) {
+		struct usbfs_iso_packet_desc *urb_desc = &urb->iso_frame_desc[i];
+		struct libusb_iso_packet_descriptor *lib_desc =
+			&transfer->iso_packet_desc[tpriv->iso_packet_offset++];
+		lib_desc->status = LIBUSB_TRANSFER_COMPLETED;
+		switch (urb_desc->status) {
+		case 0:
+			break;
+		case -ENOENT: /* cancelled */
+		case -ECONNRESET:
+			break;
+		case -ENODEV:
+		case -ESHUTDOWN:
+			usbi_dbg("device removed");
+			lib_desc->status = LIBUSB_TRANSFER_NO_DEVICE;
+			break;
+		case -EPIPE:
+			usbi_dbg("detected endpoint stall");
+			lib_desc->status = LIBUSB_TRANSFER_STALL;
+			break;
+		case -EOVERFLOW:
+			usbi_dbg("overflow error");
+			lib_desc->status = LIBUSB_TRANSFER_OVERFLOW;
+			break;
+		case -ETIME:
+		case -EPROTO:
+		case -EILSEQ:
+		case -ECOMM:
+		case -ENOSR:
+		case -EXDEV:
+			usbi_dbg("low-level USB error %d", urb_desc->status);
+			lib_desc->status = LIBUSB_TRANSFER_ERROR;
+			break;
+		default:
+			usbi_warn(TRANSFER_CTX(transfer),
+				"unrecognised urb status %d", urb_desc->status);
+			lib_desc->status = LIBUSB_TRANSFER_ERROR;
+			break;
+		}
+		lib_desc->actual_length = urb_desc->actual_length;
+	}
+
+	tpriv->num_retired++;
+
+	if (tpriv->reap_action != NORMAL) { /* cancelled or submit_fail */
+		usbi_dbg("CANCEL: urb status %d", urb->status);
+
+		if (tpriv->num_retired == num_urbs) {
+			usbi_dbg("CANCEL: last URB handled, reporting");
+			free_iso_urbs(tpriv);
+			if (tpriv->reap_action == CANCELLED) {
+				usbi_mutex_unlock(&itransfer->lock);
+				return usbi_handle_transfer_cancellation(itransfer);
+			} else {
+				usbi_mutex_unlock(&itransfer->lock);
+				return usbi_handle_transfer_completion(itransfer,
+					LIBUSB_TRANSFER_ERROR);
+			}
+		}
+		goto out;
+	}
+
+	switch (urb->status) {
+	case 0:
+		break;
+	case -ENOENT: /* cancelled */
+	case -ECONNRESET:
+		break;
+	case -ESHUTDOWN:
+		usbi_dbg("device removed");
+		status = LIBUSB_TRANSFER_NO_DEVICE;
+		break;
+	default:
+		usbi_warn(TRANSFER_CTX(transfer),
+			"unrecognised urb status %d", urb->status);
+		status = LIBUSB_TRANSFER_ERROR;
+		break;
+	}
+
+	/* if we're the last urb then we're done */
+	if (urb_idx == num_urbs) {
+		usbi_dbg("last URB in transfer --> complete!");
+		free_iso_urbs(tpriv);
+		usbi_mutex_unlock(&itransfer->lock);
+		return usbi_handle_transfer_completion(itransfer, status);
+	}
+
+out:
+	usbi_mutex_unlock(&itransfer->lock);
+	return 0;
+}
+
+static int handle_control_completion(struct usbi_transfer *itransfer,
+	struct usbfs_urb *urb)
+{
+	struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
+	int status;
+
+	usbi_mutex_lock(&itransfer->lock);
+	usbi_dbg("handling completion status %d", urb->status);
+
+	itransfer->transferred += urb->actual_length;
+
+	if (tpriv->reap_action == CANCELLED) {
+		if (urb->status != 0 && urb->status != -ENOENT)
+			usbi_warn(ITRANSFER_CTX(itransfer),
+				"cancel: unrecognised urb status %d", urb->status);
+		free(tpriv->urbs);
+		tpriv->urbs = NULL;
+		usbi_mutex_unlock(&itransfer->lock);
+		return usbi_handle_transfer_cancellation(itransfer);
+	}
+
+	switch (urb->status) {
+	case 0:
+		status = LIBUSB_TRANSFER_COMPLETED;
+		break;
+	case -ENOENT: /* cancelled */
+		status = LIBUSB_TRANSFER_CANCELLED;
+		break;
+	case -ENODEV:
+	case -ESHUTDOWN:
+		usbi_dbg("device removed");
+		status = LIBUSB_TRANSFER_NO_DEVICE;
+		break;
+	case -EPIPE:
+		usbi_dbg("unsupported control request");
+		status = LIBUSB_TRANSFER_STALL;
+		break;
+	case -EOVERFLOW:
+		usbi_dbg("control overflow error");
+		status = LIBUSB_TRANSFER_OVERFLOW;
+		break;
+	case -ETIME:
+	case -EPROTO:
+	case -EILSEQ:
+	case -ECOMM:
+	case -ENOSR:
+		usbi_dbg("low-level bus error occurred");
+		status = LIBUSB_TRANSFER_ERROR;
+		break;
+	default:
+		usbi_warn(ITRANSFER_CTX(itransfer),
+			"unrecognised urb status %d", urb->status);
+		status = LIBUSB_TRANSFER_ERROR;
+		break;
+	}
+
+	free(tpriv->urbs);
+	tpriv->urbs = NULL;
+	usbi_mutex_unlock(&itransfer->lock);
+	return usbi_handle_transfer_completion(itransfer, status);
+}
+
+static int reap_for_handle(struct libusb_device_handle *handle)
+{
+	struct linux_device_handle_priv *hpriv = _device_handle_priv(handle);
+	int r;
+	struct usbfs_urb *urb;
+	struct usbi_transfer *itransfer;
+	struct libusb_transfer *transfer;
+
+	r = ioctl(hpriv->fd, IOCTL_USBFS_REAPURBNDELAY, &urb);
+	if (r == -1 && errno == EAGAIN)
+		return 1;
+	if (r < 0) {
+		if (errno == ENODEV)
+			return LIBUSB_ERROR_NO_DEVICE;
+
+		usbi_err(HANDLE_CTX(handle), "reap failed error %d errno=%d",
+			r, errno);
+		return LIBUSB_ERROR_IO;
+	}
+
+	itransfer = urb->usercontext;
+	transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+
+	usbi_dbg("urb type=%d status=%d transferred=%d", urb->type, urb->status,
+		urb->actual_length);
+
+	switch (transfer->type) {
+	case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+		return handle_iso_completion(itransfer, urb);
+	case LIBUSB_TRANSFER_TYPE_BULK:
+	case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
+	case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+		return handle_bulk_completion(itransfer, urb);
+	case LIBUSB_TRANSFER_TYPE_CONTROL:
+		return handle_control_completion(itransfer, urb);
+	default:
+		usbi_err(HANDLE_CTX(handle), "unrecognised endpoint type %x",
+			transfer->type);
+		return LIBUSB_ERROR_OTHER;
+	}
+}
+
+static int op_handle_events(struct libusb_context *ctx,
+	struct pollfd *fds, POLL_NFDS_TYPE nfds, int num_ready)
+{
+	int r;
+	unsigned int i = 0;
+
+	usbi_mutex_lock(&ctx->open_devs_lock);
+	for (i = 0; i < nfds && num_ready > 0; i++) {
+		struct pollfd *pollfd = &fds[i];
+		struct libusb_device_handle *handle;
+		struct linux_device_handle_priv *hpriv = NULL;
+
+		if (!pollfd->revents)
+			continue;
+
+		num_ready--;
+		list_for_each_entry(handle, &ctx->open_devs, list, struct libusb_device_handle) {
+			hpriv = _device_handle_priv(handle);
+			if (hpriv->fd == pollfd->fd)
+				break;
+		}
+
+		if (!hpriv || hpriv->fd != pollfd->fd) {
+			usbi_err(ctx, "cannot find handle for fd %d",
+				 pollfd->fd);
+			continue;
+		}
+
+		if (pollfd->revents & POLLERR) {
+			/* remove the fd from the pollfd set so that it doesn't continuously
+			 * trigger an event, and flag that it has been removed so op_close()
+			 * doesn't try to remove it a second time */
+			usbi_remove_pollfd(HANDLE_CTX(handle), hpriv->fd);
+			hpriv->fd_removed = 1;
+
+			/* device will still be marked as attached if hotplug monitor thread
+			 * hasn't processed remove event yet */
+			usbi_mutex_static_lock(&linux_hotplug_lock);
+			if (handle->dev->attached)
+				linux_device_disconnected(handle->dev->bus_number,
+						handle->dev->device_address);
+			usbi_mutex_static_unlock(&linux_hotplug_lock);
+
+			if (hpriv->caps & USBFS_CAP_REAP_AFTER_DISCONNECT) {
+				do {
+					r = reap_for_handle(handle);
+				} while (r == 0);
+			}
+
+			usbi_handle_disconnect(handle);
+			continue;
+		}
+
+		do {
+			r = reap_for_handle(handle);
+		} while (r == 0);
+		if (r == 1 || r == LIBUSB_ERROR_NO_DEVICE)
+			continue;
+		else if (r < 0)
+			goto out;
+	}
+
+	r = 0;
+out:
+	usbi_mutex_unlock(&ctx->open_devs_lock);
+	return r;
+}
+
+static int op_clock_gettime(int clk_id, struct timespec *tp)
+{
+	switch (clk_id) {
+	case USBI_CLOCK_MONOTONIC:
+		return clock_gettime(monotonic_clkid, tp);
+	case USBI_CLOCK_REALTIME:
+		return clock_gettime(CLOCK_REALTIME, tp);
+	default:
+		return LIBUSB_ERROR_INVALID_PARAM;
+  }
+}
+
+#ifdef USBI_TIMERFD_AVAILABLE
+static clockid_t op_get_timerfd_clockid(void)
+{
+	return monotonic_clkid;
+
+}
+#endif
+
+const struct usbi_os_backend usbi_backend = {
+	.name = "Linux usbfs",
+	.caps = USBI_CAP_HAS_HID_ACCESS|USBI_CAP_SUPPORTS_DETACH_KERNEL_DRIVER,
+	.init = op_init,
+	.exit = op_exit,
+	.get_device_list = NULL,
+	.hotplug_poll = op_hotplug_poll,
+	.get_device_descriptor = op_get_device_descriptor,
+	.get_active_config_descriptor = op_get_active_config_descriptor,
+	.get_config_descriptor = op_get_config_descriptor,
+	.get_config_descriptor_by_value = op_get_config_descriptor_by_value,
+
+	.open = op_open,
+	.close = op_close,
+	.get_configuration = op_get_configuration,
+	.set_configuration = op_set_configuration,
+	.claim_interface = op_claim_interface,
+	.release_interface = op_release_interface,
+
+	.set_interface_altsetting = op_set_interface,
+	.clear_halt = op_clear_halt,
+	.reset_device = op_reset_device,
+
+	.alloc_streams = op_alloc_streams,
+	.free_streams = op_free_streams,
+
+	.dev_mem_alloc = op_dev_mem_alloc,
+	.dev_mem_free = op_dev_mem_free,
+
+	.kernel_driver_active = op_kernel_driver_active,
+	.detach_kernel_driver = op_detach_kernel_driver,
+	.attach_kernel_driver = op_attach_kernel_driver,
+
+	.destroy_device = op_destroy_device,
+
+	.submit_transfer = op_submit_transfer,
+	.cancel_transfer = op_cancel_transfer,
+	.clear_transfer_priv = op_clear_transfer_priv,
+
+	.handle_events = op_handle_events,
+
+	.clock_gettime = op_clock_gettime,
+
+#ifdef USBI_TIMERFD_AVAILABLE
+	.get_timerfd_clockid = op_get_timerfd_clockid,
+#endif
+
+	.device_priv_size = sizeof(struct linux_device_priv),
+	.device_handle_priv_size = sizeof(struct linux_device_handle_priv),
+	.transfer_priv_size = sizeof(struct linux_transfer_priv),
+};
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/os/linux_usbfs.h b/vendor/github.com/karalabe/usb/libusb/libusb/os/linux_usbfs.h
new file mode 100644
index 000000000..24496325f
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/os/linux_usbfs.h
@@ -0,0 +1,194 @@
+/*
+ * usbfs header structures
+ * Copyright © 2007 Daniel Drake <dsd@gentoo.org>
+ * Copyright © 2001 Johannes Erdfelt <johannes@erdfelt.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef LIBUSB_USBFS_H
+#define LIBUSB_USBFS_H
+
+#include <linux/types.h>
+
+#define SYSFS_DEVICE_PATH "/sys/bus/usb/devices"
+
+struct usbfs_ctrltransfer {
+	/* keep in sync with usbdevice_fs.h:usbdevfs_ctrltransfer */
+	uint8_t  bmRequestType;
+	uint8_t  bRequest;
+	uint16_t wValue;
+	uint16_t wIndex;
+	uint16_t wLength;
+
+	uint32_t timeout;	/* in milliseconds */
+
+	/* pointer to data */
+	void *data;
+};
+
+struct usbfs_bulktransfer {
+	/* keep in sync with usbdevice_fs.h:usbdevfs_bulktransfer */
+	unsigned int ep;
+	unsigned int len;
+	unsigned int timeout;	/* in milliseconds */
+
+	/* pointer to data */
+	void *data;
+};
+
+struct usbfs_setinterface {
+	/* keep in sync with usbdevice_fs.h:usbdevfs_setinterface */
+	unsigned int interface;
+	unsigned int altsetting;
+};
+
+#define USBFS_MAXDRIVERNAME 255
+
+struct usbfs_getdriver {
+	unsigned int interface;
+	char driver[USBFS_MAXDRIVERNAME + 1];
+};
+
+#define USBFS_URB_SHORT_NOT_OK		0x01
+#define USBFS_URB_ISO_ASAP			0x02
+#define USBFS_URB_BULK_CONTINUATION	0x04
+#define USBFS_URB_QUEUE_BULK		0x10
+#define USBFS_URB_ZERO_PACKET		0x40
+
+enum usbfs_urb_type {
+	USBFS_URB_TYPE_ISO = 0,
+	USBFS_URB_TYPE_INTERRUPT = 1,
+	USBFS_URB_TYPE_CONTROL = 2,
+	USBFS_URB_TYPE_BULK = 3,
+};
+
+struct usbfs_iso_packet_desc {
+	unsigned int length;
+	unsigned int actual_length;
+	unsigned int status;
+};
+
+#define MAX_BULK_BUFFER_LENGTH		16384
+#define MAX_CTRL_BUFFER_LENGTH		4096
+
+#define MAX_ISO_PACKETS_PER_URB		128
+
+struct usbfs_urb {
+	unsigned char type;
+	unsigned char endpoint;
+	int status;
+	unsigned int flags;
+	void *buffer;
+	int buffer_length;
+	int actual_length;
+	int start_frame;
+	union {
+		int number_of_packets;	/* Only used for isoc urbs */
+		unsigned int stream_id;	/* Only used with bulk streams */
+	};
+	int error_count;
+	unsigned int signr;
+	void *usercontext;
+	struct usbfs_iso_packet_desc iso_frame_desc[0];
+};
+
+struct usbfs_connectinfo {
+	unsigned int devnum;
+	unsigned char slow;
+};
+
+struct usbfs_ioctl {
+	int ifno;	/* interface 0..N ; negative numbers reserved */
+	int ioctl_code;	/* MUST encode size + direction of data so the
+			 * macros in <asm/ioctl.h> give correct values */
+	void *data;	/* param buffer (in, or out) */
+};
+
+struct usbfs_hub_portinfo {
+	unsigned char numports;
+	unsigned char port[127];	/* port to device num mapping */
+};
+
+#define USBFS_CAP_ZERO_PACKET		0x01
+#define USBFS_CAP_BULK_CONTINUATION	0x02
+#define USBFS_CAP_NO_PACKET_SIZE_LIM	0x04
+#define USBFS_CAP_BULK_SCATTER_GATHER	0x08
+#define USBFS_CAP_REAP_AFTER_DISCONNECT	0x10
+
+#define USBFS_DISCONNECT_CLAIM_IF_DRIVER	0x01
+#define USBFS_DISCONNECT_CLAIM_EXCEPT_DRIVER	0x02
+
+struct usbfs_disconnect_claim {
+	unsigned int interface;
+	unsigned int flags;
+	char driver[USBFS_MAXDRIVERNAME + 1];
+};
+
+struct usbfs_streams {
+	unsigned int num_streams; /* Not used by USBDEVFS_FREE_STREAMS */
+	unsigned int num_eps;
+	unsigned char eps[0];
+};
+
+#define IOCTL_USBFS_CONTROL	_IOWR('U', 0, struct usbfs_ctrltransfer)
+#define IOCTL_USBFS_BULK		_IOWR('U', 2, struct usbfs_bulktransfer)
+#define IOCTL_USBFS_RESETEP	_IOR('U', 3, unsigned int)
+#define IOCTL_USBFS_SETINTF	_IOR('U', 4, struct usbfs_setinterface)
+#define IOCTL_USBFS_SETCONFIG	_IOR('U', 5, unsigned int)
+#define IOCTL_USBFS_GETDRIVER	_IOW('U', 8, struct usbfs_getdriver)
+#define IOCTL_USBFS_SUBMITURB	_IOR('U', 10, struct usbfs_urb)
+#define IOCTL_USBFS_DISCARDURB	_IO('U', 11)
+#define IOCTL_USBFS_REAPURB	_IOW('U', 12, void *)
+#define IOCTL_USBFS_REAPURBNDELAY	_IOW('U', 13, void *)
+#define IOCTL_USBFS_CLAIMINTF	_IOR('U', 15, unsigned int)
+#define IOCTL_USBFS_RELEASEINTF	_IOR('U', 16, unsigned int)
+#define IOCTL_USBFS_CONNECTINFO	_IOW('U', 17, struct usbfs_connectinfo)
+#define IOCTL_USBFS_IOCTL         _IOWR('U', 18, struct usbfs_ioctl)
+#define IOCTL_USBFS_HUB_PORTINFO	_IOR('U', 19, struct usbfs_hub_portinfo)
+#define IOCTL_USBFS_RESET		_IO('U', 20)
+#define IOCTL_USBFS_CLEAR_HALT	_IOR('U', 21, unsigned int)
+#define IOCTL_USBFS_DISCONNECT	_IO('U', 22)
+#define IOCTL_USBFS_CONNECT	_IO('U', 23)
+#define IOCTL_USBFS_CLAIM_PORT	_IOR('U', 24, unsigned int)
+#define IOCTL_USBFS_RELEASE_PORT	_IOR('U', 25, unsigned int)
+#define IOCTL_USBFS_GET_CAPABILITIES	_IOR('U', 26, __u32)
+#define IOCTL_USBFS_DISCONNECT_CLAIM	_IOR('U', 27, struct usbfs_disconnect_claim)
+#define IOCTL_USBFS_ALLOC_STREAMS	_IOR('U', 28, struct usbfs_streams)
+#define IOCTL_USBFS_FREE_STREAMS	_IOR('U', 29, struct usbfs_streams)
+
+extern usbi_mutex_static_t linux_hotplug_lock;
+
+#if defined(HAVE_LIBUDEV)
+int linux_udev_start_event_monitor(void);
+int linux_udev_stop_event_monitor(void);
+int linux_udev_scan_devices(struct libusb_context *ctx);
+void linux_udev_hotplug_poll(void);
+#else
+int linux_netlink_start_event_monitor(void);
+int linux_netlink_stop_event_monitor(void);
+void linux_netlink_hotplug_poll(void);
+#endif
+
+void linux_hotplug_enumerate(uint8_t busnum, uint8_t devaddr, const char *sys_name);
+void linux_device_disconnected(uint8_t busnum, uint8_t devaddr);
+
+int linux_get_device_address (struct libusb_context *ctx, int detached,
+	uint8_t *busnum, uint8_t *devaddr, const char *dev_node,
+	const char *sys_name);
+int linux_enumerate_device(struct libusb_context *ctx,
+	uint8_t busnum, uint8_t devaddr, const char *sysfs_dir);
+
+#endif
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/os/netbsd_usb.c b/vendor/github.com/karalabe/usb/libusb/libusb/os/netbsd_usb.c
new file mode 100644
index 000000000..d9c059a77
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/os/netbsd_usb.c
@@ -0,0 +1,677 @@
+/*
+ * Copyright © 2011 Martin Pieuchot <mpi@openbsd.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <config.h>
+
+#include <sys/time.h>
+#include <sys/types.h>
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <dev/usb/usb.h>
+
+#include "libusbi.h"
+
+struct device_priv {
+	char devnode[16];
+	int fd;
+
+	unsigned char *cdesc;			/* active config descriptor */
+	usb_device_descriptor_t ddesc;		/* usb device descriptor */
+};
+
+struct handle_priv {
+	int endpoints[USB_MAX_ENDPOINTS];
+};
+
+/*
+ * Backend functions
+ */
+static int netbsd_get_device_list(struct libusb_context *,
+    struct discovered_devs **);
+static int netbsd_open(struct libusb_device_handle *);
+static void netbsd_close(struct libusb_device_handle *);
+
+static int netbsd_get_device_descriptor(struct libusb_device *, unsigned char *,
+    int *);
+static int netbsd_get_active_config_descriptor(struct libusb_device *,
+    unsigned char *, size_t, int *);
+static int netbsd_get_config_descriptor(struct libusb_device *, uint8_t,
+    unsigned char *, size_t, int *);
+
+static int netbsd_get_configuration(struct libusb_device_handle *, int *);
+static int netbsd_set_configuration(struct libusb_device_handle *, int);
+
+static int netbsd_claim_interface(struct libusb_device_handle *, int);
+static int netbsd_release_interface(struct libusb_device_handle *, int);
+
+static int netbsd_set_interface_altsetting(struct libusb_device_handle *, int,
+    int);
+static int netbsd_clear_halt(struct libusb_device_handle *, unsigned char);
+static int netbsd_reset_device(struct libusb_device_handle *);
+static void netbsd_destroy_device(struct libusb_device *);
+
+static int netbsd_submit_transfer(struct usbi_transfer *);
+static int netbsd_cancel_transfer(struct usbi_transfer *);
+static void netbsd_clear_transfer_priv(struct usbi_transfer *);
+static int netbsd_handle_transfer_completion(struct usbi_transfer *);
+static int netbsd_clock_gettime(int, struct timespec *);
+
+/*
+ * Private functions
+ */
+static int _errno_to_libusb(int);
+static int _cache_active_config_descriptor(struct libusb_device *, int);
+static int _sync_control_transfer(struct usbi_transfer *);
+static int _sync_gen_transfer(struct usbi_transfer *);
+static int _access_endpoint(struct libusb_transfer *);
+
+const struct usbi_os_backend usbi_backend = {
+	"Synchronous NetBSD backend",
+	0,
+	NULL,				/* init() */
+	NULL,				/* exit() */
+	NULL,				/* set_option() */
+	netbsd_get_device_list,
+	NULL,				/* hotplug_poll */
+	netbsd_open,
+	netbsd_close,
+
+	netbsd_get_device_descriptor,
+	netbsd_get_active_config_descriptor,
+	netbsd_get_config_descriptor,
+	NULL,				/* get_config_descriptor_by_value() */
+
+	netbsd_get_configuration,
+	netbsd_set_configuration,
+
+	netbsd_claim_interface,
+	netbsd_release_interface,
+
+	netbsd_set_interface_altsetting,
+	netbsd_clear_halt,
+	netbsd_reset_device,
+
+	NULL,				/* alloc_streams */
+	NULL,				/* free_streams */
+
+	NULL,				/* dev_mem_alloc() */
+	NULL,				/* dev_mem_free() */
+
+	NULL,				/* kernel_driver_active() */
+	NULL,				/* detach_kernel_driver() */
+	NULL,				/* attach_kernel_driver() */
+
+	netbsd_destroy_device,
+
+	netbsd_submit_transfer,
+	netbsd_cancel_transfer,
+	netbsd_clear_transfer_priv,
+
+	NULL,				/* handle_events() */
+	netbsd_handle_transfer_completion,
+
+	netbsd_clock_gettime,
+	0,				/* context_priv_size */
+	sizeof(struct device_priv),
+	sizeof(struct handle_priv),
+	0,				/* transfer_priv_size */
+};
+
+int
+netbsd_get_device_list(struct libusb_context * ctx,
+	struct discovered_devs **discdevs)
+{
+	struct libusb_device *dev;
+	struct device_priv *dpriv;
+	struct usb_device_info di;
+	unsigned long session_id;
+	char devnode[16];
+	int fd, err, i;
+
+	usbi_dbg("");
+
+	/* Only ugen(4) is supported */
+	for (i = 0; i < USB_MAX_DEVICES; i++) {
+		/* Control endpoint is always .00 */
+		snprintf(devnode, sizeof(devnode), "/dev/ugen%d.00", i);
+
+		if ((fd = open(devnode, O_RDONLY)) < 0) {
+			if (errno != ENOENT && errno != ENXIO)
+				usbi_err(ctx, "could not open %s", devnode);
+			continue;
+		}
+
+		if (ioctl(fd, USB_GET_DEVICEINFO, &di) < 0)
+			continue;
+
+		session_id = (di.udi_bus << 8 | di.udi_addr);
+		dev = usbi_get_device_by_session_id(ctx, session_id);
+
+		if (dev == NULL) {
+			dev = usbi_alloc_device(ctx, session_id);
+			if (dev == NULL)
+				return (LIBUSB_ERROR_NO_MEM);
+
+			dev->bus_number = di.udi_bus;
+			dev->device_address = di.udi_addr;
+			dev->speed = di.udi_speed;
+
+			dpriv = (struct device_priv *)dev->os_priv;
+			strlcpy(dpriv->devnode, devnode, sizeof(devnode));
+			dpriv->fd = -1;
+
+			if (ioctl(fd, USB_GET_DEVICE_DESC, &dpriv->ddesc) < 0) {
+				err = errno;
+				goto error;
+			}
+
+			dpriv->cdesc = NULL;
+			if (_cache_active_config_descriptor(dev, fd)) {
+				err = errno;
+				goto error;
+			}
+
+			if ((err = usbi_sanitize_device(dev)))
+				goto error;
+		}
+		close(fd);
+
+		if (discovered_devs_append(*discdevs, dev) == NULL)
+			return (LIBUSB_ERROR_NO_MEM);
+
+		libusb_unref_device(dev);
+	}
+
+	return (LIBUSB_SUCCESS);
+
+error:
+	close(fd);
+	libusb_unref_device(dev);
+	return _errno_to_libusb(err);
+}
+
+int
+netbsd_open(struct libusb_device_handle *handle)
+{
+	struct device_priv *dpriv = (struct device_priv *)handle->dev->os_priv;
+
+	dpriv->fd = open(dpriv->devnode, O_RDWR);
+	if (dpriv->fd < 0) {
+		dpriv->fd = open(dpriv->devnode, O_RDONLY);
+		if (dpriv->fd < 0)
+			return _errno_to_libusb(errno);
+	}
+
+	usbi_dbg("open %s: fd %d", dpriv->devnode, dpriv->fd);
+
+	return (LIBUSB_SUCCESS);
+}
+
+void
+netbsd_close(struct libusb_device_handle *handle)
+{
+	struct device_priv *dpriv = (struct device_priv *)handle->dev->os_priv;
+
+	usbi_dbg("close: fd %d", dpriv->fd);
+
+	close(dpriv->fd);
+	dpriv->fd = -1;
+}
+
+int
+netbsd_get_device_descriptor(struct libusb_device *dev, unsigned char *buf,
+    int *host_endian)
+{
+	struct device_priv *dpriv = (struct device_priv *)dev->os_priv;
+
+	usbi_dbg("");
+
+	memcpy(buf, &dpriv->ddesc, DEVICE_DESC_LENGTH);
+
+	*host_endian = 0;
+
+	return (LIBUSB_SUCCESS);
+}
+
+int
+netbsd_get_active_config_descriptor(struct libusb_device *dev,
+    unsigned char *buf, size_t len, int *host_endian)
+{
+	struct device_priv *dpriv = (struct device_priv *)dev->os_priv;
+	usb_config_descriptor_t *ucd;
+
+	ucd = (usb_config_descriptor_t *) dpriv->cdesc;
+	len = MIN(len, UGETW(ucd->wTotalLength));
+
+	usbi_dbg("len %d", len);
+
+	memcpy(buf, dpriv->cdesc, len);
+
+	*host_endian = 0;
+
+	return len;
+}
+
+int
+netbsd_get_config_descriptor(struct libusb_device *dev, uint8_t idx,
+    unsigned char *buf, size_t len, int *host_endian)
+{
+	struct device_priv *dpriv = (struct device_priv *)dev->os_priv;
+	struct usb_full_desc ufd;
+	int fd, err;
+
+	usbi_dbg("index %d, len %d", idx, len);
+
+	/* A config descriptor may be requested before opening the device */
+	if (dpriv->fd >= 0) {
+		fd = dpriv->fd;
+	} else {
+		fd = open(dpriv->devnode, O_RDONLY);
+		if (fd < 0)
+			return _errno_to_libusb(errno);
+	}
+
+	ufd.ufd_config_index = idx;
+	ufd.ufd_size = len;
+	ufd.ufd_data = buf;
+
+	if ((ioctl(fd, USB_GET_FULL_DESC, &ufd)) < 0) {
+		err = errno;
+		if (dpriv->fd < 0)
+			close(fd);
+		return _errno_to_libusb(err);
+	}
+
+	if (dpriv->fd < 0)
+		close(fd);
+
+	*host_endian = 0;
+
+	return len;
+}
+
+int
+netbsd_get_configuration(struct libusb_device_handle *handle, int *config)
+{
+	struct device_priv *dpriv = (struct device_priv *)handle->dev->os_priv;
+
+	usbi_dbg("");
+
+	if (ioctl(dpriv->fd, USB_GET_CONFIG, config) < 0)
+		return _errno_to_libusb(errno);
+
+	usbi_dbg("configuration %d", *config);
+
+	return (LIBUSB_SUCCESS);
+}
+
+int
+netbsd_set_configuration(struct libusb_device_handle *handle, int config)
+{
+	struct device_priv *dpriv = (struct device_priv *)handle->dev->os_priv;
+
+	usbi_dbg("configuration %d", config);
+
+	if (ioctl(dpriv->fd, USB_SET_CONFIG, &config) < 0)
+		return _errno_to_libusb(errno);
+
+	return _cache_active_config_descriptor(handle->dev, dpriv->fd);
+}
+
+int
+netbsd_claim_interface(struct libusb_device_handle *handle, int iface)
+{
+	struct handle_priv *hpriv = (struct handle_priv *)handle->os_priv;
+	int i;
+
+	for (i = 0; i < USB_MAX_ENDPOINTS; i++)
+		hpriv->endpoints[i] = -1;
+
+	return (LIBUSB_SUCCESS);
+}
+
+int
+netbsd_release_interface(struct libusb_device_handle *handle, int iface)
+{
+	struct handle_priv *hpriv = (struct handle_priv *)handle->os_priv;
+	int i;
+
+	for (i = 0; i < USB_MAX_ENDPOINTS; i++)
+		if (hpriv->endpoints[i] >= 0)
+			close(hpriv->endpoints[i]);
+
+	return (LIBUSB_SUCCESS);
+}
+
+int
+netbsd_set_interface_altsetting(struct libusb_device_handle *handle, int iface,
+    int altsetting)
+{
+	struct device_priv *dpriv = (struct device_priv *)handle->dev->os_priv;
+	struct usb_alt_interface intf;
+
+	usbi_dbg("iface %d, setting %d", iface, altsetting);
+
+	memset(&intf, 0, sizeof(intf));
+
+	intf.uai_interface_index = iface;
+	intf.uai_alt_no = altsetting;
+
+	if (ioctl(dpriv->fd, USB_SET_ALTINTERFACE, &intf) < 0)
+		return _errno_to_libusb(errno);
+
+	return (LIBUSB_SUCCESS);
+}
+
+int
+netbsd_clear_halt(struct libusb_device_handle *handle, unsigned char endpoint)
+{
+	struct device_priv *dpriv = (struct device_priv *)handle->dev->os_priv;
+	struct usb_ctl_request req;
+
+	usbi_dbg("");
+
+	req.ucr_request.bmRequestType = UT_WRITE_ENDPOINT;
+	req.ucr_request.bRequest = UR_CLEAR_FEATURE;
+	USETW(req.ucr_request.wValue, UF_ENDPOINT_HALT);
+	USETW(req.ucr_request.wIndex, endpoint);
+	USETW(req.ucr_request.wLength, 0);
+
+	if (ioctl(dpriv->fd, USB_DO_REQUEST, &req) < 0)
+		return _errno_to_libusb(errno);
+
+	return (LIBUSB_SUCCESS);
+}
+
+int
+netbsd_reset_device(struct libusb_device_handle *handle)
+{
+	usbi_dbg("");
+
+	return (LIBUSB_ERROR_NOT_SUPPORTED);
+}
+
+void
+netbsd_destroy_device(struct libusb_device *dev)
+{
+	struct device_priv *dpriv = (struct device_priv *)dev->os_priv;
+
+	usbi_dbg("");
+
+	free(dpriv->cdesc);
+}
+
+int
+netbsd_submit_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer;
+	struct handle_priv *hpriv;
+	int err = 0;
+
+	usbi_dbg("");
+
+	transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	hpriv = (struct handle_priv *)transfer->dev_handle->os_priv;
+
+	switch (transfer->type) {
+	case LIBUSB_TRANSFER_TYPE_CONTROL:
+		err = _sync_control_transfer(itransfer);
+		break;
+	case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+		if (IS_XFEROUT(transfer)) {
+			/* Isochronous write is not supported */
+			err = LIBUSB_ERROR_NOT_SUPPORTED;
+			break;
+		}
+		err = _sync_gen_transfer(itransfer);
+		break;
+	case LIBUSB_TRANSFER_TYPE_BULK:
+	case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+		if (IS_XFEROUT(transfer) &&
+		    transfer->flags & LIBUSB_TRANSFER_ADD_ZERO_PACKET) {
+			err = LIBUSB_ERROR_NOT_SUPPORTED;
+			break;
+		}
+		err = _sync_gen_transfer(itransfer);
+		break;
+	case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
+		err = LIBUSB_ERROR_NOT_SUPPORTED;
+		break;
+	}
+
+	if (err)
+		return (err);
+
+	usbi_signal_transfer_completion(itransfer);
+
+	return (LIBUSB_SUCCESS);
+}
+
+int
+netbsd_cancel_transfer(struct usbi_transfer *itransfer)
+{
+	usbi_dbg("");
+
+	return (LIBUSB_ERROR_NOT_SUPPORTED);
+}
+
+void
+netbsd_clear_transfer_priv(struct usbi_transfer *itransfer)
+{
+	usbi_dbg("");
+
+	/* Nothing to do */
+}
+
+int
+netbsd_handle_transfer_completion(struct usbi_transfer *itransfer)
+{
+	return usbi_handle_transfer_completion(itransfer, LIBUSB_TRANSFER_COMPLETED);
+}
+
+int
+netbsd_clock_gettime(int clkid, struct timespec *tp)
+{
+	usbi_dbg("clock %d", clkid);
+
+	if (clkid == USBI_CLOCK_REALTIME)
+		return clock_gettime(CLOCK_REALTIME, tp);
+
+	if (clkid == USBI_CLOCK_MONOTONIC)
+		return clock_gettime(CLOCK_MONOTONIC, tp);
+
+	return (LIBUSB_ERROR_INVALID_PARAM);
+}
+
+int
+_errno_to_libusb(int err)
+{
+	switch (err) {
+	case EIO:
+		return (LIBUSB_ERROR_IO);
+	case EACCES:
+		return (LIBUSB_ERROR_ACCESS);
+	case ENOENT:
+		return (LIBUSB_ERROR_NO_DEVICE);
+	case ENOMEM:
+		return (LIBUSB_ERROR_NO_MEM);
+	}
+
+	usbi_dbg("error: %s", strerror(err));
+
+	return (LIBUSB_ERROR_OTHER);
+}
+
+int
+_cache_active_config_descriptor(struct libusb_device *dev, int fd)
+{
+	struct device_priv *dpriv = (struct device_priv *)dev->os_priv;
+	struct usb_config_desc ucd;
+	struct usb_full_desc ufd;
+	unsigned char* buf;
+	int len;
+
+	usbi_dbg("fd %d", fd);
+
+	ucd.ucd_config_index = USB_CURRENT_CONFIG_INDEX;
+
+	if ((ioctl(fd, USB_GET_CONFIG_DESC, &ucd)) < 0)
+		return _errno_to_libusb(errno);
+
+	usbi_dbg("active bLength %d", ucd.ucd_desc.bLength);
+
+	len = UGETW(ucd.ucd_desc.wTotalLength);
+	buf = malloc(len);
+	if (buf == NULL)
+		return (LIBUSB_ERROR_NO_MEM);
+
+	ufd.ufd_config_index = ucd.ucd_config_index;
+	ufd.ufd_size = len;
+	ufd.ufd_data = buf;
+
+	usbi_dbg("index %d, len %d", ufd.ufd_config_index, len);
+
+	if ((ioctl(fd, USB_GET_FULL_DESC, &ufd)) < 0) {
+		free(buf);
+		return _errno_to_libusb(errno);
+	}
+
+	if (dpriv->cdesc)
+		free(dpriv->cdesc);
+	dpriv->cdesc = buf;
+
+	return (0);
+}
+
+int
+_sync_control_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer;
+	struct libusb_control_setup *setup;
+	struct device_priv *dpriv;
+	struct usb_ctl_request req;
+
+	transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	dpriv = (struct device_priv *)transfer->dev_handle->dev->os_priv;
+	setup = (struct libusb_control_setup *)transfer->buffer;
+
+	usbi_dbg("type %d request %d value %d index %d length %d timeout %d",
+	    setup->bmRequestType, setup->bRequest,
+	    libusb_le16_to_cpu(setup->wValue),
+	    libusb_le16_to_cpu(setup->wIndex),
+	    libusb_le16_to_cpu(setup->wLength), transfer->timeout);
+
+	req.ucr_request.bmRequestType = setup->bmRequestType;
+	req.ucr_request.bRequest = setup->bRequest;
+	/* Don't use USETW, libusb already deals with the endianness */
+	(*(uint16_t *)req.ucr_request.wValue) = setup->wValue;
+	(*(uint16_t *)req.ucr_request.wIndex) = setup->wIndex;
+	(*(uint16_t *)req.ucr_request.wLength) = setup->wLength;
+	req.ucr_data = transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE;
+
+	if ((transfer->flags & LIBUSB_TRANSFER_SHORT_NOT_OK) == 0)
+		req.ucr_flags = USBD_SHORT_XFER_OK;
+
+	if ((ioctl(dpriv->fd, USB_SET_TIMEOUT, &transfer->timeout)) < 0)
+		return _errno_to_libusb(errno);
+
+	if ((ioctl(dpriv->fd, USB_DO_REQUEST, &req)) < 0)
+		return _errno_to_libusb(errno);
+
+	itransfer->transferred = req.ucr_actlen;
+
+	usbi_dbg("transferred %d", itransfer->transferred);
+
+	return (0);
+}
+
+int
+_access_endpoint(struct libusb_transfer *transfer)
+{
+	struct handle_priv *hpriv;
+	struct device_priv *dpriv;
+	char *s, devnode[16];
+	int fd, endpt;
+	mode_t mode;
+
+	hpriv = (struct handle_priv *)transfer->dev_handle->os_priv;
+	dpriv = (struct device_priv *)transfer->dev_handle->dev->os_priv;
+
+	endpt = UE_GET_ADDR(transfer->endpoint);
+	mode = IS_XFERIN(transfer) ? O_RDONLY : O_WRONLY;
+
+	usbi_dbg("endpoint %d mode %d", endpt, mode);
+
+	if (hpriv->endpoints[endpt] < 0) {
+		/* Pick the right node given the control one */
+		strlcpy(devnode, dpriv->devnode, sizeof(devnode));
+		s = strchr(devnode, '.');
+		snprintf(s, 4, ".%02d", endpt);
+
+		/* We may need to read/write to the same endpoint later. */
+		if (((fd = open(devnode, O_RDWR)) < 0) && (errno == ENXIO))
+			if ((fd = open(devnode, mode)) < 0)
+				return (-1);
+
+		hpriv->endpoints[endpt] = fd;
+	}
+
+	return (hpriv->endpoints[endpt]);
+}
+
+int
+_sync_gen_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer;
+	int fd, nr = 1;
+
+	transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+
+	/*
+	 * Bulk, Interrupt or Isochronous transfer depends on the
+	 * endpoint and thus the node to open.
+	 */
+	if ((fd = _access_endpoint(transfer)) < 0)
+		return _errno_to_libusb(errno);
+
+	if ((ioctl(fd, USB_SET_TIMEOUT, &transfer->timeout)) < 0)
+		return _errno_to_libusb(errno);
+
+	if (IS_XFERIN(transfer)) {
+		if ((transfer->flags & LIBUSB_TRANSFER_SHORT_NOT_OK) == 0)
+			if ((ioctl(fd, USB_SET_SHORT_XFER, &nr)) < 0)
+				return _errno_to_libusb(errno);
+
+		nr = read(fd, transfer->buffer, transfer->length);
+	} else {
+		nr = write(fd, transfer->buffer, transfer->length);
+	}
+
+	if (nr < 0)
+		return _errno_to_libusb(errno);
+
+	itransfer->transferred = nr;
+
+	return (0);
+}
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/os/openbsd_usb.c b/vendor/github.com/karalabe/usb/libusb/libusb/os/openbsd_usb.c
new file mode 100644
index 000000000..f174e496c
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/os/openbsd_usb.c
@@ -0,0 +1,771 @@
+/*
+ * Copyright © 2011-2013 Martin Pieuchot <mpi@openbsd.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <config.h>
+
+#include <sys/time.h>
+#include <sys/types.h>
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <dev/usb/usb.h>
+
+#include "libusbi.h"
+
+struct device_priv {
+	char *devname;				/* name of the ugen(4) node */
+	int fd;					/* device file descriptor */
+
+	unsigned char *cdesc;			/* active config descriptor */
+	usb_device_descriptor_t ddesc;		/* usb device descriptor */
+};
+
+struct handle_priv {
+	int endpoints[USB_MAX_ENDPOINTS];
+};
+
+/*
+ * Backend functions
+ */
+static int obsd_get_device_list(struct libusb_context *,
+    struct discovered_devs **);
+static int obsd_open(struct libusb_device_handle *);
+static void obsd_close(struct libusb_device_handle *);
+
+static int obsd_get_device_descriptor(struct libusb_device *, unsigned char *,
+    int *);
+static int obsd_get_active_config_descriptor(struct libusb_device *,
+    unsigned char *, size_t, int *);
+static int obsd_get_config_descriptor(struct libusb_device *, uint8_t,
+    unsigned char *, size_t, int *);
+
+static int obsd_get_configuration(struct libusb_device_handle *, int *);
+static int obsd_set_configuration(struct libusb_device_handle *, int);
+
+static int obsd_claim_interface(struct libusb_device_handle *, int);
+static int obsd_release_interface(struct libusb_device_handle *, int);
+
+static int obsd_set_interface_altsetting(struct libusb_device_handle *, int,
+    int);
+static int obsd_clear_halt(struct libusb_device_handle *, unsigned char);
+static int obsd_reset_device(struct libusb_device_handle *);
+static void obsd_destroy_device(struct libusb_device *);
+
+static int obsd_submit_transfer(struct usbi_transfer *);
+static int obsd_cancel_transfer(struct usbi_transfer *);
+static void obsd_clear_transfer_priv(struct usbi_transfer *);
+static int obsd_handle_transfer_completion(struct usbi_transfer *);
+static int obsd_clock_gettime(int, struct timespec *);
+
+/*
+ * Private functions
+ */
+static int _errno_to_libusb(int);
+static int _cache_active_config_descriptor(struct libusb_device *);
+static int _sync_control_transfer(struct usbi_transfer *);
+static int _sync_gen_transfer(struct usbi_transfer *);
+static int _access_endpoint(struct libusb_transfer *);
+
+static int _bus_open(int);
+
+
+const struct usbi_os_backend usbi_backend = {
+	"Synchronous OpenBSD backend",
+	0,
+	NULL,				/* init() */
+	NULL,				/* exit() */
+	NULL,				/* set_option() */
+	obsd_get_device_list,
+	NULL,				/* hotplug_poll */
+	obsd_open,
+	obsd_close,
+
+	obsd_get_device_descriptor,
+	obsd_get_active_config_descriptor,
+	obsd_get_config_descriptor,
+	NULL,				/* get_config_descriptor_by_value() */
+
+	obsd_get_configuration,
+	obsd_set_configuration,
+
+	obsd_claim_interface,
+	obsd_release_interface,
+
+	obsd_set_interface_altsetting,
+	obsd_clear_halt,
+	obsd_reset_device,
+
+	NULL,				/* alloc_streams */
+	NULL,				/* free_streams */
+
+	NULL,				/* dev_mem_alloc() */
+	NULL,				/* dev_mem_free() */
+
+	NULL,				/* kernel_driver_active() */
+	NULL,				/* detach_kernel_driver() */
+	NULL,				/* attach_kernel_driver() */
+
+	obsd_destroy_device,
+
+	obsd_submit_transfer,
+	obsd_cancel_transfer,
+	obsd_clear_transfer_priv,
+
+	NULL,				/* handle_events() */
+	obsd_handle_transfer_completion,
+
+	obsd_clock_gettime,
+	0,				/* context_priv_size */
+	sizeof(struct device_priv),
+	sizeof(struct handle_priv),
+	0,				/* transfer_priv_size */
+};
+
+#define DEVPATH	"/dev/"
+#define USBDEV	DEVPATH "usb"
+
+int
+obsd_get_device_list(struct libusb_context * ctx,
+	struct discovered_devs **discdevs)
+{
+	struct discovered_devs *ddd;
+	struct libusb_device *dev;
+	struct device_priv *dpriv;
+	struct usb_device_info di;
+	struct usb_device_ddesc dd;
+	unsigned long session_id;
+	char devices[USB_MAX_DEVICES];
+	char busnode[16];
+	char *udevname;
+	int fd, addr, i, j;
+
+	usbi_dbg("");
+
+	for (i = 0; i < 8; i++) {
+		snprintf(busnode, sizeof(busnode), USBDEV "%d", i);
+
+		if ((fd = open(busnode, O_RDWR)) < 0) {
+			if (errno != ENOENT && errno != ENXIO)
+				usbi_err(ctx, "could not open %s", busnode);
+			continue;
+		}
+
+		bzero(devices, sizeof(devices));
+		for (addr = 1; addr < USB_MAX_DEVICES; addr++) {
+			if (devices[addr])
+				continue;
+
+			di.udi_addr = addr;
+			if (ioctl(fd, USB_DEVICEINFO, &di) < 0)
+				continue;
+
+			/*
+			 * XXX If ugen(4) is attached to the USB device
+			 * it will be used.
+			 */
+			udevname = NULL;
+			for (j = 0; j < USB_MAX_DEVNAMES; j++)
+				if (!strncmp("ugen", di.udi_devnames[j], 4)) {
+					udevname = strdup(di.udi_devnames[j]);
+					break;
+				}
+
+			session_id = (di.udi_bus << 8 | di.udi_addr);
+			dev = usbi_get_device_by_session_id(ctx, session_id);
+
+			if (dev == NULL) {
+				dev = usbi_alloc_device(ctx, session_id);
+				if (dev == NULL) {
+					close(fd);
+					return (LIBUSB_ERROR_NO_MEM);
+				}
+
+				dev->bus_number = di.udi_bus;
+				dev->device_address = di.udi_addr;
+				dev->speed = di.udi_speed;
+
+				dpriv = (struct device_priv *)dev->os_priv;
+				dpriv->fd = -1;
+				dpriv->cdesc = NULL;
+				dpriv->devname = udevname;
+
+				dd.udd_bus = di.udi_bus;
+				dd.udd_addr = di.udi_addr;
+				if (ioctl(fd, USB_DEVICE_GET_DDESC, &dd) < 0) {
+					libusb_unref_device(dev);
+					continue;
+				}
+				dpriv->ddesc = dd.udd_desc;
+
+				if (_cache_active_config_descriptor(dev)) {
+					libusb_unref_device(dev);
+					continue;
+				}
+
+				if (usbi_sanitize_device(dev)) {
+					libusb_unref_device(dev);
+					continue;
+				}
+			}
+
+			ddd = discovered_devs_append(*discdevs, dev);
+			if (ddd == NULL) {
+				close(fd);
+				return (LIBUSB_ERROR_NO_MEM);
+			}
+			libusb_unref_device(dev);
+
+			*discdevs = ddd;
+			devices[addr] = 1;
+		}
+
+		close(fd);
+	}
+
+	return (LIBUSB_SUCCESS);
+}
+
+int
+obsd_open(struct libusb_device_handle *handle)
+{
+	struct device_priv *dpriv = (struct device_priv *)handle->dev->os_priv;
+	char devnode[16];
+
+	if (dpriv->devname) {
+		/*
+		 * Only open ugen(4) attached devices read-write, all
+		 * read-only operations are done through the bus node.
+		 */
+		snprintf(devnode, sizeof(devnode), DEVPATH "%s.00",
+		    dpriv->devname);
+		dpriv->fd = open(devnode, O_RDWR);
+		if (dpriv->fd < 0)
+			return _errno_to_libusb(errno);
+
+		usbi_dbg("open %s: fd %d", devnode, dpriv->fd);
+	}
+
+	return (LIBUSB_SUCCESS);
+}
+
+void
+obsd_close(struct libusb_device_handle *handle)
+{
+	struct device_priv *dpriv = (struct device_priv *)handle->dev->os_priv;
+
+	if (dpriv->devname) {
+		usbi_dbg("close: fd %d", dpriv->fd);
+
+		close(dpriv->fd);
+		dpriv->fd = -1;
+	}
+}
+
+int
+obsd_get_device_descriptor(struct libusb_device *dev, unsigned char *buf,
+    int *host_endian)
+{
+	struct device_priv *dpriv = (struct device_priv *)dev->os_priv;
+
+	usbi_dbg("");
+
+	memcpy(buf, &dpriv->ddesc, DEVICE_DESC_LENGTH);
+
+	*host_endian = 0;
+
+	return (LIBUSB_SUCCESS);
+}
+
+int
+obsd_get_active_config_descriptor(struct libusb_device *dev,
+    unsigned char *buf, size_t len, int *host_endian)
+{
+	struct device_priv *dpriv = (struct device_priv *)dev->os_priv;
+	usb_config_descriptor_t *ucd = (usb_config_descriptor_t *)dpriv->cdesc;
+
+	len = MIN(len, UGETW(ucd->wTotalLength));
+
+	usbi_dbg("len %d", len);
+
+	memcpy(buf, dpriv->cdesc, len);
+
+	*host_endian = 0;
+
+	return (len);
+}
+
+int
+obsd_get_config_descriptor(struct libusb_device *dev, uint8_t idx,
+    unsigned char *buf, size_t len, int *host_endian)
+{
+	struct usb_device_fdesc udf;
+	int fd, err;
+
+	if ((fd = _bus_open(dev->bus_number)) < 0)
+		return _errno_to_libusb(errno);
+
+	udf.udf_bus = dev->bus_number;
+	udf.udf_addr = dev->device_address;
+	udf.udf_config_index = idx;
+	udf.udf_size = len;
+	udf.udf_data = buf;
+
+	usbi_dbg("index %d, len %d", udf.udf_config_index, len);
+
+	if (ioctl(fd, USB_DEVICE_GET_FDESC, &udf) < 0) {
+		err = errno;
+		close(fd);
+		return _errno_to_libusb(err);
+	}
+	close(fd);
+
+	*host_endian = 0;
+
+	return (len);
+}
+
+int
+obsd_get_configuration(struct libusb_device_handle *handle, int *config)
+{
+	struct device_priv *dpriv = (struct device_priv *)handle->dev->os_priv;
+	usb_config_descriptor_t *ucd = (usb_config_descriptor_t *)dpriv->cdesc;
+
+	*config = ucd->bConfigurationValue;
+
+	usbi_dbg("bConfigurationValue %d", *config);
+
+	return (LIBUSB_SUCCESS);
+}
+
+int
+obsd_set_configuration(struct libusb_device_handle *handle, int config)
+{
+	struct device_priv *dpriv = (struct device_priv *)handle->dev->os_priv;
+
+	if (dpriv->devname == NULL)
+		return (LIBUSB_ERROR_NOT_SUPPORTED);
+
+	usbi_dbg("bConfigurationValue %d", config);
+
+	if (ioctl(dpriv->fd, USB_SET_CONFIG, &config) < 0)
+		return _errno_to_libusb(errno);
+
+	return _cache_active_config_descriptor(handle->dev);
+}
+
+int
+obsd_claim_interface(struct libusb_device_handle *handle, int iface)
+{
+	struct handle_priv *hpriv = (struct handle_priv *)handle->os_priv;
+	int i;
+
+	for (i = 0; i < USB_MAX_ENDPOINTS; i++)
+		hpriv->endpoints[i] = -1;
+
+	return (LIBUSB_SUCCESS);
+}
+
+int
+obsd_release_interface(struct libusb_device_handle *handle, int iface)
+{
+	struct handle_priv *hpriv = (struct handle_priv *)handle->os_priv;
+	int i;
+
+	for (i = 0; i < USB_MAX_ENDPOINTS; i++)
+		if (hpriv->endpoints[i] >= 0)
+			close(hpriv->endpoints[i]);
+
+	return (LIBUSB_SUCCESS);
+}
+
+int
+obsd_set_interface_altsetting(struct libusb_device_handle *handle, int iface,
+    int altsetting)
+{
+	struct device_priv *dpriv = (struct device_priv *)handle->dev->os_priv;
+	struct usb_alt_interface intf;
+
+	if (dpriv->devname == NULL)
+		return (LIBUSB_ERROR_NOT_SUPPORTED);
+
+	usbi_dbg("iface %d, setting %d", iface, altsetting);
+
+	memset(&intf, 0, sizeof(intf));
+
+	intf.uai_interface_index = iface;
+	intf.uai_alt_no = altsetting;
+
+	if (ioctl(dpriv->fd, USB_SET_ALTINTERFACE, &intf) < 0)
+		return _errno_to_libusb(errno);
+
+	return (LIBUSB_SUCCESS);
+}
+
+int
+obsd_clear_halt(struct libusb_device_handle *handle, unsigned char endpoint)
+{
+	struct usb_ctl_request req;
+	int fd, err;
+
+	if ((fd = _bus_open(handle->dev->bus_number)) < 0)
+		return _errno_to_libusb(errno);
+
+	usbi_dbg("");
+
+	req.ucr_addr = handle->dev->device_address;
+	req.ucr_request.bmRequestType = UT_WRITE_ENDPOINT;
+	req.ucr_request.bRequest = UR_CLEAR_FEATURE;
+	USETW(req.ucr_request.wValue, UF_ENDPOINT_HALT);
+	USETW(req.ucr_request.wIndex, endpoint);
+	USETW(req.ucr_request.wLength, 0);
+
+	if (ioctl(fd, USB_REQUEST, &req) < 0) {
+		err = errno;
+		close(fd);
+		return _errno_to_libusb(err);
+	}
+	close(fd);
+
+	return (LIBUSB_SUCCESS);
+}
+
+int
+obsd_reset_device(struct libusb_device_handle *handle)
+{
+	usbi_dbg("");
+
+	return (LIBUSB_ERROR_NOT_SUPPORTED);
+}
+
+void
+obsd_destroy_device(struct libusb_device *dev)
+{
+	struct device_priv *dpriv = (struct device_priv *)dev->os_priv;
+
+	usbi_dbg("");
+
+	free(dpriv->cdesc);
+	free(dpriv->devname);
+}
+
+int
+obsd_submit_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer;
+	struct handle_priv *hpriv;
+	int err = 0;
+
+	usbi_dbg("");
+
+	transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	hpriv = (struct handle_priv *)transfer->dev_handle->os_priv;
+
+	switch (transfer->type) {
+	case LIBUSB_TRANSFER_TYPE_CONTROL:
+		err = _sync_control_transfer(itransfer);
+		break;
+	case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+		if (IS_XFEROUT(transfer)) {
+			/* Isochronous write is not supported */
+			err = LIBUSB_ERROR_NOT_SUPPORTED;
+			break;
+		}
+		err = _sync_gen_transfer(itransfer);
+		break;
+	case LIBUSB_TRANSFER_TYPE_BULK:
+	case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+		if (IS_XFEROUT(transfer) &&
+		    transfer->flags & LIBUSB_TRANSFER_ADD_ZERO_PACKET) {
+			err = LIBUSB_ERROR_NOT_SUPPORTED;
+			break;
+		}
+		err = _sync_gen_transfer(itransfer);
+		break;
+	case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
+		err = LIBUSB_ERROR_NOT_SUPPORTED;
+		break;
+	}
+
+	if (err)
+		return (err);
+
+	usbi_signal_transfer_completion(itransfer);
+
+	return (LIBUSB_SUCCESS);
+}
+
+int
+obsd_cancel_transfer(struct usbi_transfer *itransfer)
+{
+	usbi_dbg("");
+
+	return (LIBUSB_ERROR_NOT_SUPPORTED);
+}
+
+void
+obsd_clear_transfer_priv(struct usbi_transfer *itransfer)
+{
+	usbi_dbg("");
+
+	/* Nothing to do */
+}
+
+int
+obsd_handle_transfer_completion(struct usbi_transfer *itransfer)
+{
+	return usbi_handle_transfer_completion(itransfer, LIBUSB_TRANSFER_COMPLETED);
+}
+
+int
+obsd_clock_gettime(int clkid, struct timespec *tp)
+{
+	usbi_dbg("clock %d", clkid);
+
+	if (clkid == USBI_CLOCK_REALTIME)
+		return clock_gettime(CLOCK_REALTIME, tp);
+
+	if (clkid == USBI_CLOCK_MONOTONIC)
+		return clock_gettime(CLOCK_MONOTONIC, tp);
+
+	return (LIBUSB_ERROR_INVALID_PARAM);
+}
+
+int
+_errno_to_libusb(int err)
+{
+	usbi_dbg("error: %s (%d)", strerror(err), err);
+
+	switch (err) {
+	case EIO:
+		return (LIBUSB_ERROR_IO);
+	case EACCES:
+		return (LIBUSB_ERROR_ACCESS);
+	case ENOENT:
+		return (LIBUSB_ERROR_NO_DEVICE);
+	case ENOMEM:
+		return (LIBUSB_ERROR_NO_MEM);
+	case ETIMEDOUT:
+		return (LIBUSB_ERROR_TIMEOUT);
+	}
+
+	return (LIBUSB_ERROR_OTHER);
+}
+
+int
+_cache_active_config_descriptor(struct libusb_device *dev)
+{
+	struct device_priv *dpriv = (struct device_priv *)dev->os_priv;
+	struct usb_device_cdesc udc;
+	struct usb_device_fdesc udf;
+	unsigned char* buf;
+	int fd, len, err;
+
+	if ((fd = _bus_open(dev->bus_number)) < 0)
+		return _errno_to_libusb(errno);
+
+	usbi_dbg("fd %d, addr %d", fd, dev->device_address);
+
+	udc.udc_bus = dev->bus_number;
+	udc.udc_addr = dev->device_address;
+	udc.udc_config_index = USB_CURRENT_CONFIG_INDEX;
+	if (ioctl(fd, USB_DEVICE_GET_CDESC, &udc) < 0) {
+		err = errno;
+		close(fd);
+		return _errno_to_libusb(errno);
+	}
+
+	usbi_dbg("active bLength %d", udc.udc_desc.bLength);
+
+	len = UGETW(udc.udc_desc.wTotalLength);
+	buf = malloc(len);
+	if (buf == NULL)
+		return (LIBUSB_ERROR_NO_MEM);
+
+	udf.udf_bus = dev->bus_number;
+	udf.udf_addr = dev->device_address;
+	udf.udf_config_index = udc.udc_config_index;
+	udf.udf_size = len;
+	udf.udf_data = buf;
+
+	usbi_dbg("index %d, len %d", udf.udf_config_index, len);
+
+	if (ioctl(fd, USB_DEVICE_GET_FDESC, &udf) < 0) {
+		err = errno;
+		close(fd);
+		free(buf);
+		return _errno_to_libusb(err);
+	}
+	close(fd);
+
+	if (dpriv->cdesc)
+		free(dpriv->cdesc);
+	dpriv->cdesc = buf;
+
+	return (LIBUSB_SUCCESS);
+}
+
+int
+_sync_control_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer;
+	struct libusb_control_setup *setup;
+	struct device_priv *dpriv;
+	struct usb_ctl_request req;
+
+	transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	dpriv = (struct device_priv *)transfer->dev_handle->dev->os_priv;
+	setup = (struct libusb_control_setup *)transfer->buffer;
+
+	usbi_dbg("type %x request %x value %x index %d length %d timeout %d",
+	    setup->bmRequestType, setup->bRequest,
+	    libusb_le16_to_cpu(setup->wValue),
+	    libusb_le16_to_cpu(setup->wIndex),
+	    libusb_le16_to_cpu(setup->wLength), transfer->timeout);
+
+	req.ucr_addr = transfer->dev_handle->dev->device_address;
+	req.ucr_request.bmRequestType = setup->bmRequestType;
+	req.ucr_request.bRequest = setup->bRequest;
+	/* Don't use USETW, libusb already deals with the endianness */
+	(*(uint16_t *)req.ucr_request.wValue) = setup->wValue;
+	(*(uint16_t *)req.ucr_request.wIndex) = setup->wIndex;
+	(*(uint16_t *)req.ucr_request.wLength) = setup->wLength;
+	req.ucr_data = transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE;
+
+	if ((transfer->flags & LIBUSB_TRANSFER_SHORT_NOT_OK) == 0)
+		req.ucr_flags = USBD_SHORT_XFER_OK;
+
+	if (dpriv->devname == NULL) {
+		/*
+		 * XXX If the device is not attached to ugen(4) it is
+		 * XXX still possible to submit a control transfer but
+		 * XXX with the default timeout only.
+		 */
+		int fd, err;
+
+		if ((fd = _bus_open(transfer->dev_handle->dev->bus_number)) < 0)
+			return _errno_to_libusb(errno);
+
+		if ((ioctl(fd, USB_REQUEST, &req)) < 0) {
+			err = errno;
+			close(fd);
+			return _errno_to_libusb(err);
+		}
+		close(fd);
+	} else {
+		if ((ioctl(dpriv->fd, USB_SET_TIMEOUT, &transfer->timeout)) < 0)
+			return _errno_to_libusb(errno);
+
+		if ((ioctl(dpriv->fd, USB_DO_REQUEST, &req)) < 0)
+			return _errno_to_libusb(errno);
+	}
+
+	itransfer->transferred = req.ucr_actlen;
+
+	usbi_dbg("transferred %d", itransfer->transferred);
+
+	return (0);
+}
+
+int
+_access_endpoint(struct libusb_transfer *transfer)
+{
+	struct handle_priv *hpriv;
+	struct device_priv *dpriv;
+	char devnode[16];
+	int fd, endpt;
+	mode_t mode;
+
+	hpriv = (struct handle_priv *)transfer->dev_handle->os_priv;
+	dpriv = (struct device_priv *)transfer->dev_handle->dev->os_priv;
+
+	endpt = UE_GET_ADDR(transfer->endpoint);
+	mode = IS_XFERIN(transfer) ? O_RDONLY : O_WRONLY;
+
+	usbi_dbg("endpoint %d mode %d", endpt, mode);
+
+	if (hpriv->endpoints[endpt] < 0) {
+		/* Pick the right endpoint node */
+		snprintf(devnode, sizeof(devnode), DEVPATH "%s.%02d",
+		    dpriv->devname, endpt);
+
+		/* We may need to read/write to the same endpoint later. */
+		if (((fd = open(devnode, O_RDWR)) < 0) && (errno == ENXIO))
+			if ((fd = open(devnode, mode)) < 0)
+				return (-1);
+
+		hpriv->endpoints[endpt] = fd;
+	}
+
+	return (hpriv->endpoints[endpt]);
+}
+
+int
+_sync_gen_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer;
+	struct device_priv *dpriv;
+	int fd, nr = 1;
+
+	transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	dpriv = (struct device_priv *)transfer->dev_handle->dev->os_priv;
+
+	if (dpriv->devname == NULL)
+		return (LIBUSB_ERROR_NOT_SUPPORTED);
+
+	/*
+	 * Bulk, Interrupt or Isochronous transfer depends on the
+	 * endpoint and thus the node to open.
+	 */
+	if ((fd = _access_endpoint(transfer)) < 0)
+		return _errno_to_libusb(errno);
+
+	if ((ioctl(fd, USB_SET_TIMEOUT, &transfer->timeout)) < 0)
+		return _errno_to_libusb(errno);
+
+	if (IS_XFERIN(transfer)) {
+		if ((transfer->flags & LIBUSB_TRANSFER_SHORT_NOT_OK) == 0)
+			if ((ioctl(fd, USB_SET_SHORT_XFER, &nr)) < 0)
+				return _errno_to_libusb(errno);
+
+		nr = read(fd, transfer->buffer, transfer->length);
+	} else {
+		nr = write(fd, transfer->buffer, transfer->length);
+	}
+
+	if (nr < 0)
+		return _errno_to_libusb(errno);
+
+	itransfer->transferred = nr;
+
+	return (0);
+}
+
+int
+_bus_open(int number)
+{
+	char busnode[16];
+
+	snprintf(busnode, sizeof(busnode), USBDEV "%d", number);
+
+	return open(busnode, O_RDWR);
+}
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/os/poll_posix.c b/vendor/github.com/karalabe/usb/libusb/libusb/os/poll_posix.c
new file mode 100644
index 000000000..337714aa6
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/os/poll_posix.c
@@ -0,0 +1,84 @@
+/*
+ * poll_posix: poll compatibility wrapper for POSIX systems
+ * Copyright © 2013 RealVNC Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <config.h>
+
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <stdlib.h>
+
+#include "libusbi.h"
+
+int usbi_pipe(int pipefd[2])
+{
+#if defined(HAVE_PIPE2)
+	int ret = pipe2(pipefd, O_CLOEXEC);
+#else
+	int ret = pipe(pipefd);
+#endif
+
+	if (ret != 0) {
+		usbi_err(NULL, "failed to create pipe (%d)", errno);
+		return ret;
+	}
+
+#if !defined(HAVE_PIPE2) && defined(FD_CLOEXEC)
+	ret = fcntl(pipefd[0], F_GETFD);
+	if (ret == -1) {
+		usbi_err(NULL, "failed to get pipe fd flags (%d)", errno);
+		goto err_close_pipe;
+	}
+	ret = fcntl(pipefd[0], F_SETFD, ret | FD_CLOEXEC);
+	if (ret == -1) {
+		usbi_err(NULL, "failed to set pipe fd flags (%d)", errno);
+		goto err_close_pipe;
+	}
+
+	ret = fcntl(pipefd[1], F_GETFD);
+	if (ret == -1) {
+		usbi_err(NULL, "failed to get pipe fd flags (%d)", errno);
+		goto err_close_pipe;
+	}
+	ret = fcntl(pipefd[1], F_SETFD, ret | FD_CLOEXEC);
+	if (ret == -1) {
+		usbi_err(NULL, "failed to set pipe fd flags (%d)", errno);
+		goto err_close_pipe;
+	}
+#endif
+
+	ret = fcntl(pipefd[1], F_GETFL);
+	if (ret == -1) {
+		usbi_err(NULL, "failed to get pipe fd status flags (%d)", errno);
+		goto err_close_pipe;
+	}
+	ret = fcntl(pipefd[1], F_SETFL, ret | O_NONBLOCK);
+	if (ret == -1) {
+		usbi_err(NULL, "failed to set pipe fd status flags (%d)", errno);
+		goto err_close_pipe;
+	}
+
+	return 0;
+
+err_close_pipe:
+	close(pipefd[0]);
+	close(pipefd[1]);
+	return ret;
+}
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/os/poll_posix.h b/vendor/github.com/karalabe/usb/libusb/libusb/os/poll_posix.h
new file mode 100644
index 000000000..5b4b2c905
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/os/poll_posix.h
@@ -0,0 +1,11 @@
+#ifndef LIBUSB_POLL_POSIX_H
+#define LIBUSB_POLL_POSIX_H
+
+#define usbi_write write
+#define usbi_read read
+#define usbi_close close
+#define usbi_poll poll
+
+int usbi_pipe(int pipefd[2]);
+
+#endif /* LIBUSB_POLL_POSIX_H */
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/os/poll_windows.c b/vendor/github.com/karalabe/usb/libusb/libusb/os/poll_windows.c
new file mode 100644
index 000000000..4d283333d
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/os/poll_windows.c
@@ -0,0 +1,364 @@
+/*
+ * poll_windows: poll compatibility wrapper for Windows
+ * Copyright © 2017 Chris Dickens <christopher.a.dickens@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+/*
+ * poll() and pipe() Windows compatibility layer for libusb 1.0
+ *
+ * The way this layer works is by using OVERLAPPED with async I/O transfers, as
+ * OVERLAPPED have an associated event which is flagged for I/O completion.
+ *
+ * For USB pollable async I/O, you would typically:
+ * - obtain a Windows HANDLE to a file or device that has been opened in
+ *   OVERLAPPED mode
+ * - call usbi_create_fd with this handle to obtain a custom fd.
+ * - leave the core functions call the poll routine and flag POLLIN/POLLOUT
+ *
+ * The pipe pollable synchronous I/O works using the overlapped event associated
+ * with a fake pipe. The read/write functions are only meant to be used in that
+ * context.
+ */
+#include <config.h>
+
+#include <assert.h>
+#include <errno.h>
+#include <stdlib.h>
+
+#include "libusbi.h"
+#include "windows_common.h"
+
+// public fd data
+const struct winfd INVALID_WINFD = { -1, NULL };
+
+// private data
+struct file_descriptor {
+	enum fd_type { FD_TYPE_PIPE, FD_TYPE_TRANSFER } type;
+	OVERLAPPED overlapped;
+};
+
+static usbi_mutex_static_t fd_table_lock = USBI_MUTEX_INITIALIZER;
+static struct file_descriptor *fd_table[MAX_FDS];
+
+static struct file_descriptor *create_fd(enum fd_type type)
+{
+	struct file_descriptor *fd = calloc(1, sizeof(*fd));
+	if (fd == NULL)
+		return NULL;
+	fd->overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
+	if (fd->overlapped.hEvent == NULL) {
+		free(fd);
+		return NULL;
+	}
+	fd->type = type;
+	return fd;
+}
+
+static void free_fd(struct file_descriptor *fd)
+{
+	CloseHandle(fd->overlapped.hEvent);
+	free(fd);
+}
+
+/*
+ * Create both an fd and an OVERLAPPED, so that it can be used with our
+ * polling function
+ * The handle MUST support overlapped transfers (usually requires CreateFile
+ * with FILE_FLAG_OVERLAPPED)
+ * Return a pollable file descriptor struct, or INVALID_WINFD on error
+ *
+ * Note that the fd returned by this function is a per-transfer fd, rather
+ * than a per-session fd and cannot be used for anything else but our
+ * custom functions.
+ * if you plan to do R/W on the same handle, you MUST create 2 fds: one for
+ * read and one for write. Using a single R/W fd is unsupported and will
+ * produce unexpected results
+ */
+struct winfd usbi_create_fd(void)
+{
+	struct file_descriptor *fd;
+	struct winfd wfd;
+
+	fd = create_fd(FD_TYPE_TRANSFER);
+	if (fd == NULL)
+		return INVALID_WINFD;
+
+	usbi_mutex_static_lock(&fd_table_lock);
+	for (wfd.fd = 0; wfd.fd < MAX_FDS; wfd.fd++) {
+		if (fd_table[wfd.fd] != NULL)
+			continue;
+		fd_table[wfd.fd] = fd;
+		break;
+	}
+	usbi_mutex_static_unlock(&fd_table_lock);
+
+	if (wfd.fd == MAX_FDS) {
+		free_fd(fd);
+		return INVALID_WINFD;
+	}
+
+	wfd.overlapped = &fd->overlapped;
+
+	return wfd;
+}
+
+static int check_pollfds(struct pollfd *fds, unsigned int nfds,
+	HANDLE *wait_handles, DWORD *nb_wait_handles)
+{
+	struct file_descriptor *fd;
+	unsigned int n;
+	int nready = 0;
+
+	usbi_mutex_static_lock(&fd_table_lock);
+
+	for (n = 0; n < nfds; ++n) {
+		fds[n].revents = 0;
+
+		// Keep it simple - only allow either POLLIN *or* POLLOUT
+		assert((fds[n].events == POLLIN) || (fds[n].events == POLLOUT));
+		if ((fds[n].events != POLLIN) && (fds[n].events != POLLOUT)) {
+			fds[n].revents = POLLNVAL;
+			nready++;
+			continue;
+		}
+
+		if ((fds[n].fd >= 0) && (fds[n].fd < MAX_FDS))
+			fd = fd_table[fds[n].fd];
+		else
+			fd = NULL;
+
+		assert(fd != NULL);
+		if (fd == NULL) {
+			fds[n].revents = POLLNVAL;
+			nready++;
+			continue;
+		}
+
+		if (HasOverlappedIoCompleted(&fd->overlapped)
+				&& (WaitForSingleObject(fd->overlapped.hEvent, 0) == WAIT_OBJECT_0)) {
+			fds[n].revents = fds[n].events;
+			nready++;
+		} else if (wait_handles != NULL) {
+			if (*nb_wait_handles == MAXIMUM_WAIT_OBJECTS) {
+				usbi_warn(NULL, "too many HANDLEs to wait on");
+				continue;
+			}
+			wait_handles[*nb_wait_handles] = fd->overlapped.hEvent;
+			(*nb_wait_handles)++;
+		}
+	}
+
+	usbi_mutex_static_unlock(&fd_table_lock);
+
+	return nready;
+}
+/*
+ * POSIX poll equivalent, using Windows OVERLAPPED
+ * Currently, this function only accepts one of POLLIN or POLLOUT per fd
+ * (but you can create multiple fds from the same handle for read and write)
+ */
+int usbi_poll(struct pollfd *fds, unsigned int nfds, int timeout)
+{
+	HANDLE wait_handles[MAXIMUM_WAIT_OBJECTS];
+	DWORD nb_wait_handles = 0;
+	DWORD ret;
+	int nready;
+
+	nready = check_pollfds(fds, nfds, wait_handles, &nb_wait_handles);
+
+	// If nothing was triggered, wait on all fds that require it
+	if ((nready == 0) && (nb_wait_handles != 0) && (timeout != 0)) {
+		ret = WaitForMultipleObjects(nb_wait_handles, wait_handles,
+			FALSE, (timeout < 0) ? INFINITE : (DWORD)timeout);
+		if (ret < (WAIT_OBJECT_0 + nb_wait_handles)) {
+			nready = check_pollfds(fds, nfds, NULL, NULL);
+		} else if (ret != WAIT_TIMEOUT) {
+			if (ret == WAIT_FAILED)
+				usbi_err(NULL, "WaitForMultipleObjects failed: %u", (unsigned int)GetLastError());
+			nready = -1;
+		}
+	}
+
+	return nready;
+}
+
+/*
+ * close a fake file descriptor
+ */
+int usbi_close(int _fd)
+{
+	struct file_descriptor *fd;
+
+	if (_fd < 0 || _fd >= MAX_FDS)
+		goto err_badfd;
+
+	usbi_mutex_static_lock(&fd_table_lock);
+	fd = fd_table[_fd];
+	fd_table[_fd] = NULL;
+	usbi_mutex_static_unlock(&fd_table_lock);
+
+	if (fd == NULL)
+		goto err_badfd;
+
+	if (fd->type == FD_TYPE_PIPE) {
+		// InternalHigh is our reference count
+		fd->overlapped.InternalHigh--;
+		if (fd->overlapped.InternalHigh == 0)
+			free_fd(fd);
+	} else {
+		free_fd(fd);
+	}
+
+	return 0;
+
+err_badfd:
+	errno = EBADF;
+	return -1;
+}
+
+/*
+* Create a fake pipe.
+* As libusb only uses pipes for signaling, all we need from a pipe is an
+* event. To that extent, we create a single wfd and overlapped as a means
+* to access that event.
+*/
+int usbi_pipe(int filedes[2])
+{
+	struct file_descriptor *fd;
+	int r_fd = -1, w_fd = -1;
+	int i;
+
+	fd = create_fd(FD_TYPE_PIPE);
+	if (fd == NULL) {
+		errno = ENOMEM;
+		return -1;
+	}
+
+	// Use InternalHigh as a reference count
+	fd->overlapped.Internal = STATUS_PENDING;
+	fd->overlapped.InternalHigh = 2;
+
+	usbi_mutex_static_lock(&fd_table_lock);
+	do {
+		for (i = 0; i < MAX_FDS; i++) {
+			if (fd_table[i] != NULL)
+				continue;
+			if (r_fd == -1) {
+				r_fd = i;
+			} else if (w_fd == -1) {
+				w_fd = i;
+				break;
+			}
+		}
+
+		if (i == MAX_FDS)
+			break;
+
+		fd_table[r_fd] = fd;
+		fd_table[w_fd] = fd;
+
+	} while (0);
+	usbi_mutex_static_unlock(&fd_table_lock);
+
+	if (i == MAX_FDS) {
+		free_fd(fd);
+		errno = EMFILE;
+		return -1;
+	}
+
+	filedes[0] = r_fd;
+	filedes[1] = w_fd;
+
+	return 0;
+}
+
+/*
+ * synchronous write for fake "pipe" signaling
+ */
+ssize_t usbi_write(int fd, const void *buf, size_t count)
+{
+	int error = EBADF;
+
+	UNUSED(buf);
+
+	if (fd < 0 || fd >= MAX_FDS)
+		goto err_out;
+
+	if (count != sizeof(unsigned char)) {
+		usbi_err(NULL, "this function should only used for signaling");
+		error = EINVAL;
+		goto err_out;
+	}
+
+	usbi_mutex_static_lock(&fd_table_lock);
+	if ((fd_table[fd] != NULL) && (fd_table[fd]->type == FD_TYPE_PIPE)) {
+		assert(fd_table[fd]->overlapped.Internal == STATUS_PENDING);
+		assert(fd_table[fd]->overlapped.InternalHigh == 2);
+		fd_table[fd]->overlapped.Internal = STATUS_WAIT_0;
+		SetEvent(fd_table[fd]->overlapped.hEvent);
+		error = 0;
+	}
+	usbi_mutex_static_unlock(&fd_table_lock);
+
+	if (error)
+		goto err_out;
+
+	return sizeof(unsigned char);
+
+err_out:
+	errno = error;
+	return -1;
+}
+
+/*
+ * synchronous read for fake "pipe" signaling
+ */
+ssize_t usbi_read(int fd, void *buf, size_t count)
+{
+	int error = EBADF;
+
+	UNUSED(buf);
+
+	if (fd < 0 || fd >= MAX_FDS)
+		goto err_out;
+
+	if (count != sizeof(unsigned char)) {
+		usbi_err(NULL, "this function should only used for signaling");
+		error = EINVAL;
+		goto err_out;
+	}
+
+	usbi_mutex_static_lock(&fd_table_lock);
+	if ((fd_table[fd] != NULL) && (fd_table[fd]->type == FD_TYPE_PIPE)) {
+		assert(fd_table[fd]->overlapped.Internal == STATUS_WAIT_0);
+		assert(fd_table[fd]->overlapped.InternalHigh == 2);
+		fd_table[fd]->overlapped.Internal = STATUS_PENDING;
+		ResetEvent(fd_table[fd]->overlapped.hEvent);
+		error = 0;
+	}
+	usbi_mutex_static_unlock(&fd_table_lock);
+
+	if (error)
+		goto err_out;
+
+	return sizeof(unsigned char);
+
+err_out:
+	errno = error;
+	return -1;
+}
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/os/poll_windows.h b/vendor/github.com/karalabe/usb/libusb/libusb/os/poll_windows.h
new file mode 100644
index 000000000..bd22c7f62
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/os/poll_windows.h
@@ -0,0 +1,97 @@
+/*
+ * Windows compat: POSIX compatibility wrapper
+ * Copyright © 2012-2013 RealVNC Ltd.
+ * Copyright © 2009-2010 Pete Batard <pete@akeo.ie>
+ * Copyright © 2016-2018 Chris Dickens <christopher.a.dickens@gmail.com>
+ * With contributions from Michael Plante, Orin Eman et al.
+ * Parts of poll implementation from libusb-win32, by Stephan Meyer et al.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+#pragma once
+
+#if defined(_MSC_VER)
+// disable /W4 MSVC warnings that are benign
+#pragma warning(disable:4127) // conditional expression is constant
+#endif
+
+// Handle synchronous completion through the overlapped structure
+#if !defined(STATUS_REPARSE)	// reuse the REPARSE status code
+#define STATUS_REPARSE ((LONG)0x00000104L)
+#endif
+#define STATUS_COMPLETED_SYNCHRONOUSLY	STATUS_REPARSE
+#if defined(_WIN32_WCE)
+// WinCE doesn't have a HasOverlappedIoCompleted() macro, so attempt to emulate it
+#define HasOverlappedIoCompleted(lpOverlapped) (((DWORD)(lpOverlapped)->Internal) != STATUS_PENDING)
+#endif
+#define HasOverlappedIoCompletedSync(lpOverlapped)	(((DWORD)(lpOverlapped)->Internal) == STATUS_COMPLETED_SYNCHRONOUSLY)
+
+#define DUMMY_HANDLE ((HANDLE)(LONG_PTR)-2)
+
+#define MAX_FDS     256
+
+#define POLLIN      0x0001    /* There is data to read */
+#define POLLPRI     0x0002    /* There is urgent data to read */
+#define POLLOUT     0x0004    /* Writing now will not block */
+#define POLLERR     0x0008    /* Error condition */
+#define POLLHUP     0x0010    /* Hung up */
+#define POLLNVAL    0x0020    /* Invalid request: fd not open */
+
+struct pollfd {
+	int fd;		/* file descriptor */
+	short events;	/* requested events */
+	short revents;	/* returned events */
+};
+
+struct winfd {
+	int fd;				// what's exposed to libusb core
+	OVERLAPPED *overlapped;		// what will report our I/O status
+};
+
+extern const struct winfd INVALID_WINFD;
+
+struct winfd usbi_create_fd(void);
+
+int usbi_pipe(int pipefd[2]);
+int usbi_poll(struct pollfd *fds, unsigned int nfds, int timeout);
+ssize_t usbi_write(int fd, const void *buf, size_t count);
+ssize_t usbi_read(int fd, void *buf, size_t count);
+int usbi_close(int fd);
+
+/*
+ * Timeval operations
+ */
+#if defined(DDKBUILD)
+#include <winsock.h>	// defines timeval functions on DDK
+#endif
+
+#if !defined(TIMESPEC_TO_TIMEVAL)
+#define TIMESPEC_TO_TIMEVAL(tv, ts) {                   \
+	(tv)->tv_sec = (long)(ts)->tv_sec;                  \
+	(tv)->tv_usec = (long)(ts)->tv_nsec / 1000;         \
+}
+#endif
+#if !defined(timersub)
+#define timersub(a, b, result)                          \
+do {                                                    \
+	(result)->tv_sec = (a)->tv_sec - (b)->tv_sec;       \
+	(result)->tv_usec = (a)->tv_usec - (b)->tv_usec;    \
+	if ((result)->tv_usec < 0) {                        \
+		--(result)->tv_sec;                             \
+		(result)->tv_usec += 1000000;                   \
+	}                                                   \
+} while (0)
+#endif
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/os/sunos_usb.c b/vendor/github.com/karalabe/usb/libusb/libusb/os/sunos_usb.c
new file mode 100644
index 000000000..7150a3e9d
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/os/sunos_usb.c
@@ -0,0 +1,1675 @@
+/*
+ *
+ * Copyright (c) 2016, Oracle and/or its affiliates.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <config.h>
+
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/list.h>
+#include <sys/stat.h>
+#include <strings.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <wait.h>
+#include <unistd.h>
+#include <aio.h>
+#include <libdevinfo.h>
+#include <sys/nvpair.h>
+#include <sys/devctl.h>
+#include <sys/usb/clients/ugen/usb_ugen.h>
+#include <errno.h>
+#include <sys/usb/usba.h>
+#include <sys/pci.h>
+
+#include "libusbi.h"
+#include "sunos_usb.h"
+
+#define UPDATEDRV_PATH	"/usr/sbin/update_drv"
+#define UPDATEDRV	"update_drv"
+
+typedef list_t string_list_t;
+typedef struct string_node {
+	char		*string;
+	list_node_t	link;
+} string_node_t;
+
+/*
+ * Backend functions
+ */
+static int sunos_init(struct libusb_context *);
+static void sunos_exit(struct libusb_context *);
+static int sunos_get_device_list(struct libusb_context *,
+    struct discovered_devs **);
+static int sunos_open(struct libusb_device_handle *);
+static void sunos_close(struct libusb_device_handle *);
+static int sunos_get_device_descriptor(struct libusb_device *,
+    uint8_t*, int *);
+static int sunos_get_active_config_descriptor(struct libusb_device *,
+    uint8_t*, size_t, int *);
+static int sunos_get_config_descriptor(struct libusb_device *, uint8_t,
+    uint8_t*, size_t, int *);
+static int sunos_get_configuration(struct libusb_device_handle *, int *);
+static int sunos_set_configuration(struct libusb_device_handle *, int);
+static int sunos_claim_interface(struct libusb_device_handle *, int);
+static int sunos_release_interface(struct libusb_device_handle *, int);
+static int sunos_set_interface_altsetting(struct libusb_device_handle *,
+    int, int);
+static int sunos_clear_halt(struct libusb_device_handle *, uint8_t);
+static int sunos_reset_device(struct libusb_device_handle *);
+static void sunos_destroy_device(struct libusb_device *);
+static int sunos_submit_transfer(struct usbi_transfer *);
+static int sunos_cancel_transfer(struct usbi_transfer *);
+static void sunos_clear_transfer_priv(struct usbi_transfer *);
+static int sunos_handle_transfer_completion(struct usbi_transfer *);
+static int sunos_clock_gettime(int, struct timespec *);
+static int sunos_kernel_driver_active(struct libusb_device_handle *, int interface);
+static int sunos_detach_kernel_driver (struct libusb_device_handle *dev, int interface_number);
+static int sunos_attach_kernel_driver (struct libusb_device_handle *dev, int interface_number);
+static int sunos_usb_open_ep0(sunos_dev_handle_priv_t *hpriv, sunos_dev_priv_t *dpriv);
+static int sunos_usb_ioctl(struct libusb_device *dev, int cmd);
+
+static struct devctl_iocdata iocdata;
+static int sunos_get_link(di_devlink_t devlink, void *arg)
+{
+	walk_link_t *larg = (walk_link_t *)arg;
+	const char *p;
+	const char *q;
+
+	if (larg->path) {
+		char *content = (char *)di_devlink_content(devlink);
+		char *start = strstr(content, "/devices/");
+		start += strlen("/devices");
+		usbi_dbg("%s", start);
+
+		/* line content must have minor node */
+		if (start == NULL ||
+		    strncmp(start, larg->path, larg->len) != 0 ||
+		    start[larg->len] != ':')
+			return (DI_WALK_CONTINUE);
+	}
+
+	p = di_devlink_path(devlink);
+	q = strrchr(p, '/');
+	usbi_dbg("%s", q);
+
+	*(larg->linkpp) = strndup(p, strlen(p) - strlen(q));
+
+	return (DI_WALK_TERMINATE);
+}
+
+
+static int sunos_physpath_to_devlink(
+	const char *node_path, const char *match, char **link_path)
+{
+	walk_link_t larg;
+	di_devlink_handle_t hdl;
+
+	*link_path = NULL;
+	larg.linkpp = link_path;
+	if ((hdl = di_devlink_init(NULL, 0)) == NULL) {
+		usbi_dbg("di_devlink_init failure");
+		return (-1);
+	}
+
+	larg.len = strlen(node_path);
+	larg.path = (char *)node_path;
+
+	(void) di_devlink_walk(hdl, match, NULL, DI_PRIMARY_LINK,
+	    (void *)&larg, sunos_get_link);
+
+	(void) di_devlink_fini(&hdl);
+
+	if (*link_path == NULL) {
+		usbi_dbg("there is no devlink for this path");
+		return (-1);
+	}
+
+	return 0;
+}
+
+static int
+sunos_usb_ioctl(struct libusb_device *dev, int cmd)
+{
+	int fd;
+	nvlist_t *nvlist;
+	char *end;
+	char *phypath;
+	char *hubpath;
+	char path_arg[PATH_MAX];
+	sunos_dev_priv_t *dpriv;
+	devctl_ap_state_t devctl_ap_state;
+
+	dpriv = (sunos_dev_priv_t *)dev->os_priv;
+	phypath = dpriv->phypath;
+
+	end = strrchr(phypath, '/');
+	if (end == NULL)
+		return (-1);
+	hubpath = strndup(phypath, end - phypath);
+	if (hubpath == NULL)
+		return (-1);
+
+	end = strrchr(hubpath, '@');
+	if (end == NULL) {
+		free(hubpath);
+		return (-1);
+	}
+	end++;
+	usbi_dbg("unitaddr: %s", end);
+
+	nvlist_alloc(&nvlist, NV_UNIQUE_NAME_TYPE, KM_NOSLEEP);
+	nvlist_add_int32(nvlist, "port", dev->port_number);
+	//find the hub path
+	snprintf(path_arg, sizeof(path_arg), "/devices%s:hubd", hubpath);
+	usbi_dbg("ioctl hub path: %s", path_arg);
+
+	fd = open(path_arg, O_RDONLY);
+	if (fd < 0) {
+		usbi_err(DEVICE_CTX(dev), "open failed: %d (%s)", errno, strerror(errno));
+		nvlist_free(nvlist);
+		free(hubpath);
+		return (-1);
+	}
+
+	memset(&iocdata, 0, sizeof(iocdata));
+	memset(&devctl_ap_state, 0, sizeof(devctl_ap_state));
+
+	nvlist_pack(nvlist, (char **)&iocdata.nvl_user, &iocdata.nvl_usersz, NV_ENCODE_NATIVE, 0);
+
+	iocdata.cmd = DEVCTL_AP_GETSTATE;
+	iocdata.flags = 0;
+	iocdata.c_nodename = "hub";
+	iocdata.c_unitaddr = end;
+	iocdata.cpyout_buf = &devctl_ap_state;
+	usbi_dbg("%p, %d", iocdata.nvl_user, iocdata.nvl_usersz);
+
+	errno = 0;
+	if (ioctl(fd, DEVCTL_AP_GETSTATE, &iocdata) == -1) {
+		usbi_err(DEVICE_CTX(dev), "ioctl failed: fd %d, cmd %x, errno %d (%s)",
+			 fd, DEVCTL_AP_GETSTATE, errno, strerror(errno));
+	} else {
+		usbi_dbg("dev rstate: %d", devctl_ap_state.ap_rstate);
+		usbi_dbg("dev ostate: %d", devctl_ap_state.ap_ostate);
+	}
+
+	errno = 0;
+	iocdata.cmd = cmd;
+	if (ioctl(fd, (int)cmd, &iocdata) != 0) {
+		usbi_err(DEVICE_CTX(dev), "ioctl failed: fd %d, cmd %x, errno %d (%s)",
+			 fd, cmd, errno, strerror(errno));
+		sleep(2);
+	}
+
+	close(fd);
+	free(iocdata.nvl_user);
+	nvlist_free(nvlist);
+	free(hubpath);
+
+	return (-errno);
+}
+
+static int
+sunos_kernel_driver_active(struct libusb_device_handle *dev, int interface)
+{
+	sunos_dev_priv_t *dpriv;
+	dpriv = (sunos_dev_priv_t *)dev->dev->os_priv;
+
+	usbi_dbg("%s", dpriv->ugenpath);
+
+	return (dpriv->ugenpath == NULL);
+}
+
+/*
+ * Private functions
+ */
+static int _errno_to_libusb(int);
+static int sunos_usb_get_status(int fd);
+
+static int sunos_init(struct libusb_context *ctx)
+{
+	return (LIBUSB_SUCCESS);
+}
+
+static void sunos_exit(struct libusb_context *ctx)
+{
+	usbi_dbg("");
+}
+
+static string_list_t *
+sunos_new_string_list(void)
+{
+	string_list_t *list;
+
+	list = calloc(1, sizeof(*list));
+	if (list != NULL)
+		list_create(list, sizeof(string_node_t),
+			    offsetof(string_node_t, link));
+
+	return (list);
+}
+
+static int
+sunos_append_to_string_list(string_list_t *list, const char *arg)
+{
+	string_node_t *np;
+
+	np = calloc(1, sizeof(*np));
+	if (!np)
+		return (-1);
+
+	np->string = strdup(arg);
+	if (!np->string) {
+		free(np);
+		return (-1);
+	}
+
+	list_insert_tail(list, np);
+
+	return (0);
+}
+
+static void
+sunos_free_string_list(string_list_t *list)
+{
+	string_node_t *np;
+
+	while ((np = list_remove_head(list)) != NULL) {
+		free(np->string);
+		free(np);
+	}
+
+	free(list);
+}
+
+static char **
+sunos_build_argv_list(string_list_t *list)
+{
+	char **argv_list;
+	string_node_t *np;
+	int n;
+
+	n = 1; /* Start at 1 for NULL terminator */
+	for (np = list_head(list); np != NULL; np = list_next(list, np))
+		n++;
+
+	argv_list = calloc(n, sizeof(char *));
+	if (argv_list == NULL)
+		return NULL;
+
+	n = 0;
+	for (np = list_head(list); np != NULL; np = list_next(list, np))
+		argv_list[n++] = np->string;
+
+	return (argv_list);
+}
+
+
+static int
+sunos_exec_command(struct libusb_context *ctx, const char *path,
+	string_list_t *list)
+{
+	pid_t pid;
+	int status;
+	int waitstat;
+	int exit_status;
+	char **argv_list;
+
+	argv_list = sunos_build_argv_list(list);
+	if (argv_list == NULL)
+		return (-1);
+
+	pid = fork();
+	if (pid == 0) {
+		/* child */
+		execv(path, argv_list);
+		_exit(127);
+	} else if (pid > 0) {
+		/* parent */
+		do {
+			waitstat = waitpid(pid, &status, 0);
+		} while ((waitstat == -1 && errno == EINTR) ||
+			 (waitstat == 0 && !WIFEXITED(status) && !WIFSIGNALED(status)));
+
+		if (waitstat == 0) {
+			if (WIFEXITED(status))
+				exit_status = WEXITSTATUS(status);
+			else
+				exit_status = WTERMSIG(status);
+		} else {
+			usbi_err(ctx, "waitpid failed: errno %d (%s)", errno, strerror(errno));
+			exit_status = -1;
+		}
+	} else {
+		/* fork failed */
+		usbi_err(ctx, "fork failed: errno %d (%s)", errno, strerror(errno));
+		exit_status = -1;
+	}
+
+	free(argv_list);
+
+	return (exit_status);
+}
+
+static int
+sunos_detach_kernel_driver(struct libusb_device_handle *dev_handle,
+	int interface_number)
+{
+	struct libusb_context *ctx = HANDLE_CTX(dev_handle);
+	string_list_t *list;
+	char path_arg[PATH_MAX];
+	sunos_dev_priv_t *dpriv;
+	int r;
+
+	dpriv = (sunos_dev_priv_t *)dev_handle->dev->os_priv;
+	snprintf(path_arg, sizeof(path_arg), "\'\"%s\"\'", dpriv->phypath);
+	usbi_dbg("%s", path_arg);
+
+	list = sunos_new_string_list();
+	if (list == NULL)
+		return (LIBUSB_ERROR_NO_MEM);
+
+	/* attach ugen driver */
+	r = 0;
+	r |= sunos_append_to_string_list(list, UPDATEDRV);
+	r |= sunos_append_to_string_list(list, "-a"); /* add rule */
+	r |= sunos_append_to_string_list(list, "-i"); /* specific device */
+	r |= sunos_append_to_string_list(list, path_arg); /* physical path */
+	r |= sunos_append_to_string_list(list, "ugen");
+	if (r) {
+		sunos_free_string_list(list);
+		return (LIBUSB_ERROR_NO_MEM);
+	}
+
+	r = sunos_exec_command(ctx, UPDATEDRV_PATH, list);
+	sunos_free_string_list(list);
+	if (r < 0)
+		return (LIBUSB_ERROR_OTHER);
+
+	/* reconfigure the driver node */
+	r = 0;
+	r |= sunos_usb_ioctl(dev_handle->dev, DEVCTL_AP_DISCONNECT);
+	r |= sunos_usb_ioctl(dev_handle->dev, DEVCTL_AP_CONFIGURE);
+	if (r)
+		usbi_warn(HANDLE_CTX(dev_handle), "one or more ioctls failed");
+
+	snprintf(path_arg, sizeof(path_arg), "^usb/%x.%x", dpriv->dev_descr.idVendor,
+	    dpriv->dev_descr.idProduct);
+	sunos_physpath_to_devlink(dpriv->phypath, path_arg, &dpriv->ugenpath);
+
+	if (access(dpriv->ugenpath, F_OK) == -1) {
+		usbi_err(HANDLE_CTX(dev_handle), "fail to detach kernel driver");
+		return (LIBUSB_ERROR_IO);
+	}
+
+	return sunos_usb_open_ep0((sunos_dev_handle_priv_t *)dev_handle->os_priv, dpriv);
+}
+
+static int
+sunos_attach_kernel_driver(struct libusb_device_handle *dev_handle,
+	int interface_number)
+{
+	struct libusb_context *ctx = HANDLE_CTX(dev_handle);
+	string_list_t *list;
+	char path_arg[PATH_MAX];
+	sunos_dev_priv_t *dpriv;
+	int r;
+
+	/* we open the dev in detach driver, so we need close it first. */
+	sunos_close(dev_handle);
+
+	dpriv = (sunos_dev_priv_t *)dev_handle->dev->os_priv;
+	snprintf(path_arg, sizeof(path_arg), "\'\"%s\"\'", dpriv->phypath);
+	usbi_dbg("%s", path_arg);
+
+	list = sunos_new_string_list();
+	if (list == NULL)
+		return (LIBUSB_ERROR_NO_MEM);
+
+	/* detach ugen driver */
+	r = 0;
+	r |= sunos_append_to_string_list(list, UPDATEDRV);
+	r |= sunos_append_to_string_list(list, "-d"); /* add rule */
+	r |= sunos_append_to_string_list(list, "-i"); /* specific device */
+	r |= sunos_append_to_string_list(list, path_arg); /* physical path */
+	r |= sunos_append_to_string_list(list, "ugen");
+	if (r) {
+		sunos_free_string_list(list);
+		return (LIBUSB_ERROR_NO_MEM);
+	}
+
+	r = sunos_exec_command(ctx, UPDATEDRV_PATH, list);
+	sunos_free_string_list(list);
+	if (r < 0)
+		return (LIBUSB_ERROR_OTHER);
+
+	/* reconfigure the driver node */
+	r = 0;
+	r |= sunos_usb_ioctl(dev_handle->dev, DEVCTL_AP_CONFIGURE);
+	r |= sunos_usb_ioctl(dev_handle->dev, DEVCTL_AP_DISCONNECT);
+	r |= sunos_usb_ioctl(dev_handle->dev, DEVCTL_AP_CONFIGURE);
+	if (r)
+		usbi_warn(HANDLE_CTX(dev_handle), "one or more ioctls failed");
+
+	return 0;
+}
+
+static int
+sunos_fill_in_dev_info(di_node_t node, struct libusb_device *dev)
+{
+	int	proplen;
+	int	n, *addr, *port_prop;
+	char	*phypath;
+	uint8_t	*rdata;
+	struct libusb_device_descriptor	*descr;
+	sunos_dev_priv_t	*dpriv = (sunos_dev_priv_t *)dev->os_priv;
+	char	match_str[PATH_MAX];
+
+	/* Device descriptors */
+	proplen = di_prop_lookup_bytes(DDI_DEV_T_ANY, node,
+	    "usb-dev-descriptor", &rdata);
+	if (proplen <= 0) {
+
+		return (LIBUSB_ERROR_IO);
+	}
+
+	descr = (struct libusb_device_descriptor *)rdata;
+	bcopy(descr, &dpriv->dev_descr, LIBUSB_DT_DEVICE_SIZE);
+	dpriv->dev_descr.bcdUSB = libusb_cpu_to_le16(descr->bcdUSB);
+	dpriv->dev_descr.idVendor = libusb_cpu_to_le16(descr->idVendor);
+	dpriv->dev_descr.idProduct = libusb_cpu_to_le16(descr->idProduct);
+	dpriv->dev_descr.bcdDevice = libusb_cpu_to_le16(descr->bcdDevice);
+
+	/* Raw configuration descriptors */
+	proplen = di_prop_lookup_bytes(DDI_DEV_T_ANY, node,
+	    "usb-raw-cfg-descriptors", &rdata);
+	if (proplen <= 0) {
+		usbi_dbg("can't find raw config descriptors");
+
+		return (LIBUSB_ERROR_IO);
+	}
+	dpriv->raw_cfgdescr = calloc(1, proplen);
+	if (dpriv->raw_cfgdescr == NULL) {
+		return (LIBUSB_ERROR_NO_MEM);
+	} else {
+		bcopy(rdata, dpriv->raw_cfgdescr, proplen);
+		dpriv->cfgvalue = ((struct libusb_config_descriptor *)
+		    rdata)->bConfigurationValue;
+	}
+
+	n = di_prop_lookup_ints(DDI_DEV_T_ANY, node, "reg", &port_prop);
+
+	if ((n != 1) || (*port_prop <= 0)) {
+		return (LIBUSB_ERROR_IO);
+	}
+	dev->port_number = *port_prop;
+
+	/* device physical path */
+	phypath = di_devfs_path(node);
+	if (phypath) {
+		dpriv->phypath = strdup(phypath);
+		snprintf(match_str, sizeof(match_str), "^usb/%x.%x", dpriv->dev_descr.idVendor, dpriv->dev_descr.idProduct);
+		usbi_dbg("match is %s", match_str);
+		sunos_physpath_to_devlink(dpriv->phypath, match_str,  &dpriv->ugenpath);
+		di_devfs_path_free(phypath);
+
+	} else {
+		free(dpriv->raw_cfgdescr);
+
+		return (LIBUSB_ERROR_IO);
+	}
+
+	/* address */
+	n = di_prop_lookup_ints(DDI_DEV_T_ANY, node, "assigned-address", &addr);
+	if (n != 1 || *addr == 0) {
+		usbi_dbg("can't get address");
+	} else {
+		dev->device_address = *addr;
+	}
+
+	/* speed */
+	if (di_prop_exists(DDI_DEV_T_ANY, node, "low-speed") == 1) {
+		dev->speed = LIBUSB_SPEED_LOW;
+	} else if (di_prop_exists(DDI_DEV_T_ANY, node, "high-speed") == 1) {
+		dev->speed = LIBUSB_SPEED_HIGH;
+	} else if (di_prop_exists(DDI_DEV_T_ANY, node, "full-speed") == 1) {
+		dev->speed = LIBUSB_SPEED_FULL;
+	} else if (di_prop_exists(DDI_DEV_T_ANY, node, "super-speed") == 1) {
+		dev->speed = LIBUSB_SPEED_SUPER;
+	}
+
+	usbi_dbg("vid=%x pid=%x, path=%s, bus_nmber=0x%x, port_number=%d, "
+	    "speed=%d", dpriv->dev_descr.idVendor, dpriv->dev_descr.idProduct,
+	    dpriv->phypath, dev->bus_number, dev->port_number, dev->speed);
+
+	return (LIBUSB_SUCCESS);
+}
+
+static int
+sunos_add_devices(di_devlink_t link, void *arg)
+{
+	struct devlink_cbarg	*largs = (struct devlink_cbarg *)arg;
+	struct node_args	*nargs;
+	di_node_t		myself, dn;
+	uint64_t		session_id = 0;
+	uint64_t		sid = 0;
+	uint64_t		bdf = 0;
+	struct libusb_device	*dev;
+	sunos_dev_priv_t	*devpriv;
+	int			n;
+	int			i = 0;
+	int			*addr_prop;
+	uint8_t			bus_number = 0;
+	uint32_t * 		regbuf = NULL;
+	uint32_t		reg;
+
+	nargs = (struct node_args *)largs->nargs;
+	myself = largs->myself;
+
+	/*
+	 * Construct session ID.
+	 * session ID = dev_addr | hub addr |parent hub addr|...|root hub bdf
+	 * 		8 bits       8bits          8 bits               16bits
+	 */
+	if (myself == DI_NODE_NIL)
+		return (DI_WALK_CONTINUE);
+
+	dn = myself;
+	/* find the root hub */
+	while (di_prop_exists(DDI_DEV_T_ANY, dn, "root-hub") != 1) {
+		usbi_dbg("find_root_hub:%s", di_devfs_path(dn));
+		n = di_prop_lookup_ints(DDI_DEV_T_ANY, dn,
+				"assigned-address", &addr_prop);
+		session_id |= ((addr_prop[0] & 0xff) << i++ * 8);
+		dn = di_parent_node(dn);
+	}
+
+	/* dn is the root hub node */
+	n = di_prop_lookup_ints(DDI_DEV_T_ANY, dn, "reg", (int **)&regbuf);
+	reg = regbuf[0];
+	bdf = (PCI_REG_BUS_G(reg) << 8) | (PCI_REG_DEV_G(reg) << 3) | PCI_REG_FUNC_G(reg);
+	/* bdf must larger than i*8 bits */
+	session_id |= (bdf << i * 8);
+	bus_number = (PCI_REG_DEV_G(reg) << 3) | PCI_REG_FUNC_G(reg);
+
+	usbi_dbg("device bus address=%s:%x, name:%s",
+	    di_bus_addr(myself), bus_number, di_node_name(dn));
+	usbi_dbg("session id org:%lx", session_id);
+
+	/* dn is the usb device */
+	for (dn = di_child_node(myself); dn != DI_NODE_NIL; dn = di_sibling_node(dn)) {
+		usbi_dbg("device path:%s", di_devfs_path(dn));
+		/* skip hub devices, because its driver can not been unload */
+		if (di_prop_lookup_ints(DDI_DEV_T_ANY, dn, "usb-port-count", &addr_prop) != -1)
+			continue;
+		/* usb_addr */
+		n = di_prop_lookup_ints(DDI_DEV_T_ANY, dn,
+		    "assigned-address", &addr_prop);
+		if ((n != 1) || (addr_prop[0] == 0)) {
+			usbi_dbg("cannot get valid usb_addr");
+			continue;
+		}
+
+		sid = (session_id << 8) | (addr_prop[0] & 0xff) ;
+		usbi_dbg("session id %lx", sid);
+
+		dev = usbi_get_device_by_session_id(nargs->ctx, sid);
+		if (dev == NULL) {
+			dev = usbi_alloc_device(nargs->ctx, sid);
+			if (dev == NULL) {
+				usbi_dbg("can't alloc device");
+				continue;
+			}
+			devpriv = (sunos_dev_priv_t *)dev->os_priv;
+			dev->bus_number = bus_number;
+
+			if (sunos_fill_in_dev_info(dn, dev) != LIBUSB_SUCCESS) {
+				libusb_unref_device(dev);
+				usbi_dbg("get infomation fail");
+				continue;
+			}
+			if (usbi_sanitize_device(dev) < 0) {
+				libusb_unref_device(dev);
+				usbi_dbg("sanatize failed: ");
+				return (DI_WALK_TERMINATE);
+			}
+		} else {
+			devpriv = (sunos_dev_priv_t *)dev->os_priv;
+			usbi_dbg("Dev %s exists", devpriv->ugenpath);
+		}
+
+		if (discovered_devs_append(*(nargs->discdevs), dev) == NULL) {
+			usbi_dbg("cannot append device");
+		}
+
+		/*
+		 * we alloc and hence ref this dev. We don't need to ref it
+		 * hereafter. Front end or app should take care of their ref.
+		 */
+		libusb_unref_device(dev);
+
+		usbi_dbg("Device %s %s id=0x%llx, devcount:%d, bdf=%x",
+		    devpriv->ugenpath, di_devfs_path(dn), (uint64_t)sid,
+		    (*nargs->discdevs)->len, bdf);
+	}
+
+	return (DI_WALK_CONTINUE);
+}
+
+static int
+sunos_walk_minor_node_link(di_node_t node, void *args)
+{
+        di_minor_t minor = DI_MINOR_NIL;
+        char *minor_path;
+        struct devlink_cbarg arg;
+	struct node_args *nargs = (struct node_args *)args;
+	di_devlink_handle_t devlink_hdl = nargs->dlink_hdl;
+
+	/* walk each minor to find usb devices */
+        while ((minor = di_minor_next(node, minor)) != DI_MINOR_NIL) {
+                minor_path = di_devfs_minor_path(minor);
+                arg.nargs = args;
+		arg.myself = node;
+                arg.minor = minor;
+                (void) di_devlink_walk(devlink_hdl,
+		    "^usb/hub[0-9]+", minor_path,
+		    DI_PRIMARY_LINK, (void *)&arg, sunos_add_devices);
+                di_devfs_path_free(minor_path);
+        }
+
+	/* switch to a different node */
+	nargs->last_ugenpath = NULL;
+
+	return (DI_WALK_CONTINUE);
+}
+
+int
+sunos_get_device_list(struct libusb_context * ctx,
+	struct discovered_devs **discdevs)
+{
+	di_node_t root_node;
+	struct node_args args;
+	di_devlink_handle_t devlink_hdl;
+
+	args.ctx = ctx;
+	args.discdevs = discdevs;
+	args.last_ugenpath = NULL;
+	if ((root_node = di_init("/", DINFOCPYALL)) == DI_NODE_NIL) {
+		usbi_dbg("di_int() failed: %s", strerror(errno));
+		return (LIBUSB_ERROR_IO);
+	}
+
+	if ((devlink_hdl = di_devlink_init(NULL, 0)) == NULL) {
+		di_fini(root_node);
+		usbi_dbg("di_devlink_init() failed: %s", strerror(errno));
+
+		return (LIBUSB_ERROR_IO);
+	}
+	args.dlink_hdl = devlink_hdl;
+
+	/* walk each node to find USB devices */
+	if (di_walk_node(root_node, DI_WALK_SIBFIRST, &args,
+	    sunos_walk_minor_node_link) == -1) {
+		usbi_dbg("di_walk_node() failed: %s", strerror(errno));
+		di_fini(root_node);
+
+		return (LIBUSB_ERROR_IO);
+	}
+
+	di_fini(root_node);
+	di_devlink_fini(&devlink_hdl);
+
+	usbi_dbg("%d devices", (*discdevs)->len);
+
+	return ((*discdevs)->len);
+}
+
+static int
+sunos_usb_open_ep0(sunos_dev_handle_priv_t *hpriv, sunos_dev_priv_t *dpriv)
+{
+	char filename[PATH_MAX + 1];
+
+	if (hpriv->eps[0].datafd > 0) {
+
+		return (LIBUSB_SUCCESS);
+	}
+	snprintf(filename, PATH_MAX, "%s/cntrl0", dpriv->ugenpath);
+
+	usbi_dbg("opening %s", filename);
+	hpriv->eps[0].datafd = open(filename, O_RDWR);
+	if (hpriv->eps[0].datafd < 0) {
+		return(_errno_to_libusb(errno));
+	}
+
+	snprintf(filename, PATH_MAX, "%s/cntrl0stat", dpriv->ugenpath);
+	hpriv->eps[0].statfd = open(filename, O_RDONLY);
+	if (hpriv->eps[0].statfd < 0) {
+		close(hpriv->eps[0].datafd);
+		hpriv->eps[0].datafd = -1;
+
+		return(_errno_to_libusb(errno));
+	}
+
+	return (LIBUSB_SUCCESS);
+}
+
+static void
+sunos_usb_close_all_eps(sunos_dev_handle_priv_t *hdev)
+{
+	int i;
+
+	/* not close ep0 */
+	for (i = 1; i < USB_MAXENDPOINTS; i++) {
+		if (hdev->eps[i].datafd != -1) {
+			(void) close(hdev->eps[i].datafd);
+			hdev->eps[i].datafd = -1;
+		}
+		if (hdev->eps[i].statfd != -1) {
+			(void) close(hdev->eps[i].statfd);
+			hdev->eps[i].statfd = -1;
+		}
+	}
+}
+
+static void
+sunos_usb_close_ep0(sunos_dev_handle_priv_t *hdev, sunos_dev_priv_t *dpriv)
+{
+	if (hdev->eps[0].datafd >= 0) {
+		close(hdev->eps[0].datafd);
+		close(hdev->eps[0].statfd);
+		hdev->eps[0].datafd = -1;
+		hdev->eps[0].statfd = -1;
+	}
+}
+
+static uchar_t
+sunos_usb_ep_index(uint8_t ep_addr)
+{
+	return ((ep_addr & LIBUSB_ENDPOINT_ADDRESS_MASK) +
+	    ((ep_addr & LIBUSB_ENDPOINT_DIR_MASK) ? 16 : 0));
+}
+
+static int
+sunos_find_interface(struct libusb_device_handle *hdev,
+    uint8_t endpoint, uint8_t *interface)
+{
+	struct libusb_config_descriptor *config;
+	int r;
+	int iface_idx;
+
+	r = libusb_get_active_config_descriptor(hdev->dev, &config);
+	if (r < 0) {
+		return (LIBUSB_ERROR_INVALID_PARAM);
+	}
+
+	for (iface_idx = 0; iface_idx < config->bNumInterfaces; iface_idx++) {
+		const struct libusb_interface *iface =
+		    &config->interface[iface_idx];
+		int altsetting_idx;
+
+		for (altsetting_idx = 0; altsetting_idx < iface->num_altsetting;
+		    altsetting_idx++) {
+			const struct libusb_interface_descriptor *altsetting =
+			    &iface->altsetting[altsetting_idx];
+			int ep_idx;
+
+			for (ep_idx = 0; ep_idx < altsetting->bNumEndpoints;
+			    ep_idx++) {
+				const struct libusb_endpoint_descriptor *ep =
+					&altsetting->endpoint[ep_idx];
+				if (ep->bEndpointAddress == endpoint) {
+					*interface = iface_idx;
+					libusb_free_config_descriptor(config);
+
+					return (LIBUSB_SUCCESS);
+				}
+			}
+		}
+	}
+	libusb_free_config_descriptor(config);
+
+	return (LIBUSB_ERROR_INVALID_PARAM);
+}
+
+static int
+sunos_check_device_and_status_open(struct libusb_device_handle *hdl,
+    uint8_t ep_addr, int ep_type)
+{
+	char	filename[PATH_MAX + 1], statfilename[PATH_MAX + 1];
+	char	cfg_num[16], alt_num[16];
+	int	fd, fdstat, mode;
+	uint8_t	ifc = 0;
+	uint8_t	ep_index;
+	sunos_dev_handle_priv_t *hpriv;
+
+	usbi_dbg("open ep 0x%02x", ep_addr);
+	hpriv = (sunos_dev_handle_priv_t *)hdl->os_priv;
+	ep_index = sunos_usb_ep_index(ep_addr);
+	/* ep already opened */
+	if ((hpriv->eps[ep_index].datafd > 0) &&
+	    (hpriv->eps[ep_index].statfd > 0)) {
+		usbi_dbg("ep 0x%02x already opened, return success",
+			ep_addr);
+
+		return (0);
+	}
+
+	if (sunos_find_interface(hdl, ep_addr, &ifc) < 0) {
+		usbi_dbg("can't find interface for endpoint 0x%02x",
+		    ep_addr);
+
+		return (EACCES);
+	}
+
+	/* create filename */
+	if (hpriv->config_index > 0) {
+		(void) snprintf(cfg_num, sizeof (cfg_num), "cfg%d",
+		    hpriv->config_index + 1);
+	} else {
+		bzero(cfg_num, sizeof (cfg_num));
+	}
+
+	if (hpriv->altsetting[ifc] > 0) {
+		(void) snprintf(alt_num, sizeof (alt_num), ".%d",
+		    hpriv->altsetting[ifc]);
+	} else {
+		bzero(alt_num, sizeof (alt_num));
+	}
+
+	(void) snprintf(filename, PATH_MAX, "%s/%sif%d%s%s%d",
+	    hpriv->dpriv->ugenpath, cfg_num, ifc, alt_num,
+	    (ep_addr & LIBUSB_ENDPOINT_DIR_MASK) ? "in" :
+	    "out", (ep_addr & LIBUSB_ENDPOINT_ADDRESS_MASK));
+	(void) snprintf(statfilename, PATH_MAX, "%sstat", filename);
+
+	/*
+	 * for interrupt IN endpoints, we need to enable one xfer
+	 * mode before opening the endpoint
+	 */
+	if ((ep_type == LIBUSB_TRANSFER_TYPE_INTERRUPT) &&
+	    (ep_addr & LIBUSB_ENDPOINT_IN)) {
+		char	control = USB_EP_INTR_ONE_XFER;
+		int	count;
+
+		/* open the status device node for the ep first RDWR */
+		if ((fdstat = open(statfilename, O_RDWR)) == -1) {
+			usbi_dbg("can't open %s RDWR: %d",
+				statfilename, errno);
+		} else {
+			count = write(fdstat, &control, sizeof (control));
+			if (count != 1) {
+				/* this should have worked */
+				usbi_dbg("can't write to %s: %d",
+					statfilename, errno);
+				(void) close(fdstat);
+
+				return (errno);
+			}
+			/* close status node and open xfer node first */
+			close (fdstat);
+		}
+	}
+
+	/* open the xfer node first in case alt needs to be changed */
+	if (ep_type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS) {
+		mode = O_RDWR;
+	} else if (ep_addr & LIBUSB_ENDPOINT_IN) {
+		mode = O_RDONLY;
+	} else {
+		mode = O_WRONLY;
+	}
+
+	/*
+	 * IMPORTANT: must open data xfer node first and then open stat node
+	 * Otherwise, it will fail on multi-config or multi-altsetting devices
+	 * with "Device Busy" error. See ugen_epxs_switch_cfg_alt() and
+	 * ugen_epxs_check_alt_switch() in ugen driver source code.
+	 */
+	if ((fd = open(filename, mode)) == -1) {
+		usbi_dbg("can't open %s: %d(%s)", filename, errno,
+		    strerror(errno));
+
+		return (errno);
+	}
+	/* open the status node */
+	if ((fdstat = open(statfilename, O_RDONLY)) == -1) {
+		usbi_dbg("can't open %s: %d", statfilename, errno);
+
+		(void) close(fd);
+
+		return (errno);
+	}
+
+	hpriv->eps[ep_index].datafd = fd;
+	hpriv->eps[ep_index].statfd = fdstat;
+	usbi_dbg("ep=0x%02x datafd=%d, statfd=%d", ep_addr, fd, fdstat);
+
+	return (0);
+}
+
+int
+sunos_open(struct libusb_device_handle *handle)
+{
+	sunos_dev_handle_priv_t	*hpriv;
+	sunos_dev_priv_t	*dpriv;
+	int	i;
+	int	ret;
+
+	hpriv = (sunos_dev_handle_priv_t *)handle->os_priv;
+	dpriv = (sunos_dev_priv_t *)handle->dev->os_priv;
+	hpriv->dpriv = dpriv;
+
+	/* set all file descriptors to "closed" */
+	for (i = 0; i < USB_MAXENDPOINTS; i++) {
+		hpriv->eps[i].datafd = -1;
+		hpriv->eps[i].statfd = -1;
+	}
+
+	if (sunos_kernel_driver_active(handle, 0)) {
+		/* pretend we can open the device */
+		return (LIBUSB_SUCCESS);
+	}
+
+	if ((ret = sunos_usb_open_ep0(hpriv, dpriv)) != LIBUSB_SUCCESS) {
+		usbi_dbg("fail: %d", ret);
+		return (ret);
+	}
+
+	return (LIBUSB_SUCCESS);
+}
+
+void
+sunos_close(struct libusb_device_handle *handle)
+{
+	sunos_dev_handle_priv_t *hpriv;
+	sunos_dev_priv_t *dpriv;
+
+	usbi_dbg("");
+	if (!handle) {
+		return;
+	}
+
+	hpriv = (sunos_dev_handle_priv_t *)handle->os_priv;
+	if (!hpriv) {
+		return;
+	}
+	dpriv = (sunos_dev_priv_t *)handle->dev->os_priv;
+	if (!dpriv) {
+		return;
+	}
+
+	sunos_usb_close_all_eps(hpriv);
+	sunos_usb_close_ep0(hpriv, dpriv);
+}
+
+int
+sunos_get_device_descriptor(struct libusb_device *dev, uint8_t *buf,
+    int *host_endian)
+{
+	sunos_dev_priv_t *dpriv = (sunos_dev_priv_t *)dev->os_priv;
+
+	memcpy(buf, &dpriv->dev_descr, LIBUSB_DT_DEVICE_SIZE);
+	*host_endian = 0;
+
+	return (LIBUSB_SUCCESS);
+}
+
+int
+sunos_get_active_config_descriptor(struct libusb_device *dev,
+    uint8_t *buf, size_t len, int *host_endian)
+{
+	sunos_dev_priv_t *dpriv = (sunos_dev_priv_t *)dev->os_priv;
+	struct libusb_config_descriptor *cfg;
+	int proplen;
+	di_node_t node;
+	uint8_t	*rdata;
+
+	/*
+	 * Keep raw configuration descriptors updated, in case config
+	 * has ever been changed through setCfg.
+	 */
+	if ((node = di_init(dpriv->phypath, DINFOCPYALL)) == DI_NODE_NIL) {
+		usbi_dbg("di_int() failed: %s", strerror(errno));
+		return (LIBUSB_ERROR_IO);
+	}
+	proplen = di_prop_lookup_bytes(DDI_DEV_T_ANY, node,
+	    "usb-raw-cfg-descriptors", &rdata);
+	if (proplen <= 0) {
+		usbi_dbg("can't find raw config descriptors");
+
+		return (LIBUSB_ERROR_IO);
+	}
+	dpriv->raw_cfgdescr = realloc(dpriv->raw_cfgdescr, proplen);
+	if (dpriv->raw_cfgdescr == NULL) {
+		return (LIBUSB_ERROR_NO_MEM);
+	} else {
+		bcopy(rdata, dpriv->raw_cfgdescr, proplen);
+		dpriv->cfgvalue = ((struct libusb_config_descriptor *)
+		    rdata)->bConfigurationValue;
+	}
+	di_fini(node);
+
+	cfg = (struct libusb_config_descriptor *)dpriv->raw_cfgdescr;
+	len = MIN(len, libusb_le16_to_cpu(cfg->wTotalLength));
+	memcpy(buf, dpriv->raw_cfgdescr, len);
+	*host_endian = 0;
+	usbi_dbg("path:%s len %d", dpriv->phypath, len);
+
+	return (len);
+}
+
+int
+sunos_get_config_descriptor(struct libusb_device *dev, uint8_t idx,
+    uint8_t *buf, size_t len, int *host_endian)
+{
+	/* XXX */
+	return(sunos_get_active_config_descriptor(dev, buf, len, host_endian));
+}
+
+int
+sunos_get_configuration(struct libusb_device_handle *handle, int *config)
+{
+	sunos_dev_priv_t *dpriv = (sunos_dev_priv_t *)handle->dev->os_priv;
+
+	*config = dpriv->cfgvalue;
+
+	usbi_dbg("bConfigurationValue %d", *config);
+
+	return (LIBUSB_SUCCESS);
+}
+
+int
+sunos_set_configuration(struct libusb_device_handle *handle, int config)
+{
+	sunos_dev_priv_t *dpriv = (sunos_dev_priv_t *)handle->dev->os_priv;
+	sunos_dev_handle_priv_t *hpriv;
+
+	usbi_dbg("bConfigurationValue %d", config);
+	hpriv = (sunos_dev_handle_priv_t *)handle->os_priv;
+
+	if (dpriv->ugenpath == NULL)
+		return (LIBUSB_ERROR_NOT_SUPPORTED);
+
+	if (config < 1 || config > dpriv->dev_descr.bNumConfigurations)
+		return (LIBUSB_ERROR_INVALID_PARAM);
+
+	dpriv->cfgvalue = config;
+	hpriv->config_index = config - 1;
+
+	return (LIBUSB_SUCCESS);
+}
+
+int
+sunos_claim_interface(struct libusb_device_handle *handle, int iface)
+{
+	usbi_dbg("iface %d", iface);
+	if (iface < 0) {
+		return (LIBUSB_ERROR_INVALID_PARAM);
+	}
+
+	return (LIBUSB_SUCCESS);
+}
+
+int
+sunos_release_interface(struct libusb_device_handle *handle, int iface)
+{
+	sunos_dev_handle_priv_t *hpriv =
+	    (sunos_dev_handle_priv_t *)handle->os_priv;
+
+	usbi_dbg("iface %d", iface);
+	if (iface < 0) {
+		return (LIBUSB_ERROR_INVALID_PARAM);
+	}
+
+	/* XXX: can we release it? */
+	hpriv->altsetting[iface] = 0;
+
+	return (LIBUSB_SUCCESS);
+}
+
+int
+sunos_set_interface_altsetting(struct libusb_device_handle *handle, int iface,
+    int altsetting)
+{
+	sunos_dev_priv_t *dpriv = (sunos_dev_priv_t *)handle->dev->os_priv;
+	sunos_dev_handle_priv_t *hpriv =
+	    (sunos_dev_handle_priv_t *)handle->os_priv;
+
+	usbi_dbg("iface %d, setting %d", iface, altsetting);
+
+	if (iface < 0 || altsetting < 0) {
+		return (LIBUSB_ERROR_INVALID_PARAM);
+	}
+	if (dpriv->ugenpath == NULL)
+		return (LIBUSB_ERROR_NOT_FOUND);
+
+	/* XXX: can we switch altsetting? */
+	hpriv->altsetting[iface] = altsetting;
+
+	return (LIBUSB_SUCCESS);
+}
+
+static void
+usb_dump_data(unsigned char *data, size_t size)
+{
+	int i;
+
+	if (getenv("LIBUSB_DEBUG") == NULL) {
+		return;
+	}
+
+	(void) fprintf(stderr, "data dump:");
+	for (i = 0; i < size; i++) {
+		if (i % 16 == 0) {
+			(void) fprintf(stderr, "\n%08x	", i);
+		}
+		(void) fprintf(stderr, "%02x ", (uchar_t)data[i]);
+	}
+	(void) fprintf(stderr, "\n");
+}
+
+static void
+sunos_async_callback(union sigval arg)
+{
+	struct sunos_transfer_priv *tpriv =
+	    (struct sunos_transfer_priv *)arg.sival_ptr;
+	struct libusb_transfer *xfer = tpriv->transfer;
+	struct aiocb *aiocb = &tpriv->aiocb;
+	int ret;
+	sunos_dev_handle_priv_t *hpriv;
+	uint8_t ep;
+
+	hpriv = (sunos_dev_handle_priv_t *)xfer->dev_handle->os_priv;
+	ep = sunos_usb_ep_index(xfer->endpoint);
+
+	ret = aio_error(aiocb);
+	if (ret != 0) {
+		xfer->status = sunos_usb_get_status(hpriv->eps[ep].statfd);
+	} else {
+		xfer->actual_length =
+		    LIBUSB_TRANSFER_TO_USBI_TRANSFER(xfer)->transferred =
+		    aio_return(aiocb);
+	}
+
+	usb_dump_data(xfer->buffer, xfer->actual_length);
+
+	usbi_dbg("ret=%d, len=%d, actual_len=%d", ret, xfer->length,
+	    xfer->actual_length);
+
+	/* async notification */
+	usbi_signal_transfer_completion(LIBUSB_TRANSFER_TO_USBI_TRANSFER(xfer));
+}
+
+static int
+sunos_do_async_io(struct libusb_transfer *transfer)
+{
+	int ret = -1;
+	struct aiocb *aiocb;
+	sunos_dev_handle_priv_t *hpriv;
+	uint8_t ep;
+	struct sunos_transfer_priv *tpriv;
+
+	usbi_dbg("");
+
+	tpriv = usbi_transfer_get_os_priv(LIBUSB_TRANSFER_TO_USBI_TRANSFER(transfer));
+	hpriv = (sunos_dev_handle_priv_t *)transfer->dev_handle->os_priv;
+	ep = sunos_usb_ep_index(transfer->endpoint);
+
+	tpriv->transfer = transfer;
+	aiocb = &tpriv->aiocb;
+	bzero(aiocb, sizeof (*aiocb));
+	aiocb->aio_fildes = hpriv->eps[ep].datafd;
+	aiocb->aio_buf = transfer->buffer;
+	aiocb->aio_nbytes = transfer->length;
+	aiocb->aio_lio_opcode =
+	    ((transfer->endpoint & LIBUSB_ENDPOINT_DIR_MASK) ==
+	    LIBUSB_ENDPOINT_IN) ? LIO_READ:LIO_WRITE;
+	aiocb->aio_sigevent.sigev_notify = SIGEV_THREAD;
+	aiocb->aio_sigevent.sigev_value.sival_ptr = tpriv;
+	aiocb->aio_sigevent.sigev_notify_function = sunos_async_callback;
+
+	if (aiocb->aio_lio_opcode == LIO_READ) {
+		ret = aio_read(aiocb);
+	} else {
+		ret = aio_write(aiocb);
+	}
+
+	return (ret);
+}
+
+/* return the number of bytes read/written */
+static int
+usb_do_io(int fd, int stat_fd, char *data, size_t size, int flag, int *status)
+{
+	int error;
+	int ret = -1;
+
+	usbi_dbg("usb_do_io(): datafd=%d statfd=%d size=0x%x flag=%s",
+	    fd, stat_fd, size, flag? "WRITE":"READ");
+
+	switch (flag) {
+	case READ:
+		errno = 0;
+		ret = read(fd, data, size);
+		usb_dump_data(data, size);
+		break;
+	case WRITE:
+		usb_dump_data(data, size);
+		errno = 0;
+		ret = write(fd, data, size);
+		break;
+	}
+
+	usbi_dbg("usb_do_io(): amount=%d", ret);
+
+	if (ret < 0) {
+		int save_errno = errno;
+
+		usbi_dbg("TID=%x io %s errno=%d(%s) ret=%d", pthread_self(),
+		    flag?"WRITE":"READ", errno, strerror(errno), ret);
+
+		/* sunos_usb_get_status will do a read and overwrite errno */
+		error = sunos_usb_get_status(stat_fd);
+		usbi_dbg("io status=%d errno=%d(%s)", error,
+			save_errno, strerror(save_errno));
+
+		if (status) {
+			*status = save_errno;
+		}
+
+		return (save_errno);
+
+	} else if (status) {
+		*status = 0;
+	}
+
+	return (ret);
+}
+
+static int
+solaris_submit_ctrl_on_default(struct libusb_transfer *transfer)
+{
+	int		ret = -1, setup_ret;
+	int		status;
+	sunos_dev_handle_priv_t *hpriv;
+	struct		libusb_device_handle *hdl = transfer->dev_handle;
+	uint16_t	wLength;
+	uint8_t		*data = transfer->buffer;
+
+	hpriv = (sunos_dev_handle_priv_t *)hdl->os_priv;
+	wLength = transfer->length - LIBUSB_CONTROL_SETUP_SIZE;
+
+	if (hpriv->eps[0].datafd == -1) {
+		usbi_dbg("ep0 not opened");
+
+		return (LIBUSB_ERROR_NOT_FOUND);
+	}
+
+	if ((data[0] & LIBUSB_ENDPOINT_DIR_MASK) == LIBUSB_ENDPOINT_IN) {
+		usbi_dbg("IN request");
+		ret = usb_do_io(hpriv->eps[0].datafd,
+		    hpriv->eps[0].statfd, (char *)data, LIBUSB_CONTROL_SETUP_SIZE,
+		    WRITE, (int *)&status);
+	} else {
+		usbi_dbg("OUT request");
+		ret = usb_do_io(hpriv->eps[0].datafd, hpriv->eps[0].statfd,
+		    transfer->buffer, transfer->length, WRITE,
+		    (int *)&transfer->status);
+	}
+
+	setup_ret = ret;
+	if (ret < LIBUSB_CONTROL_SETUP_SIZE) {
+		usbi_dbg("error sending control msg: %d", ret);
+
+		return (LIBUSB_ERROR_IO);
+	}
+
+	ret = transfer->length - LIBUSB_CONTROL_SETUP_SIZE;
+
+	/* Read the remaining bytes for IN request */
+	if ((wLength) && ((data[0] & LIBUSB_ENDPOINT_DIR_MASK) ==
+	    LIBUSB_ENDPOINT_IN)) {
+		usbi_dbg("DATA: %d", transfer->length - setup_ret);
+		ret = usb_do_io(hpriv->eps[0].datafd,
+			hpriv->eps[0].statfd,
+			(char *)transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE,
+			wLength, READ, (int *)&transfer->status);
+	}
+
+	if (ret >= 0) {
+		transfer->actual_length = ret;
+		LIBUSB_TRANSFER_TO_USBI_TRANSFER(transfer)->transferred = ret;
+	}
+	usbi_dbg("Done: ctrl data bytes %d", ret);
+
+	/* sync transfer handling */
+	ret = usbi_handle_transfer_completion(LIBUSB_TRANSFER_TO_USBI_TRANSFER(transfer),
+	    transfer->status);
+
+	return (ret);
+}
+
+int
+sunos_clear_halt(struct libusb_device_handle *handle, uint8_t endpoint)
+{
+	int ret;
+
+	usbi_dbg("endpoint=0x%02x", endpoint);
+
+	ret = libusb_control_transfer(handle, LIBUSB_ENDPOINT_OUT |
+	    LIBUSB_RECIPIENT_ENDPOINT | LIBUSB_REQUEST_TYPE_STANDARD,
+	    LIBUSB_REQUEST_CLEAR_FEATURE, 0, endpoint, NULL, 0, 1000);
+
+	usbi_dbg("ret=%d", ret);
+
+	return (ret);
+}
+
+int
+sunos_reset_device(struct libusb_device_handle *handle)
+{
+	usbi_dbg("");
+
+	return (LIBUSB_ERROR_NOT_SUPPORTED);
+}
+
+void
+sunos_destroy_device(struct libusb_device *dev)
+{
+	sunos_dev_priv_t *dpriv = (sunos_dev_priv_t *)dev->os_priv;
+	usbi_dbg("destroy everyting");
+	free(dpriv->raw_cfgdescr);
+	free(dpriv->ugenpath);
+	free(dpriv->phypath);
+}
+
+int
+sunos_submit_transfer(struct usbi_transfer *itransfer)
+{
+	struct	libusb_transfer *transfer;
+	struct	libusb_device_handle *hdl;
+	int	err = 0;
+
+	transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	hdl = transfer->dev_handle;
+
+	err = sunos_check_device_and_status_open(hdl,
+	    transfer->endpoint, transfer->type);
+	if (err < 0) {
+
+		return (_errno_to_libusb(err));
+	}
+
+	switch (transfer->type) {
+	case LIBUSB_TRANSFER_TYPE_CONTROL:
+		/* sync transfer */
+		usbi_dbg("CTRL transfer: %d", transfer->length);
+		err = solaris_submit_ctrl_on_default(transfer);
+		break;
+
+	case LIBUSB_TRANSFER_TYPE_BULK:
+		/* fallthru */
+	case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+		if (transfer->type == LIBUSB_TRANSFER_TYPE_BULK)
+			usbi_dbg("BULK transfer: %d", transfer->length);
+		else
+			usbi_dbg("INTR transfer: %d", transfer->length);
+		err = sunos_do_async_io(transfer);
+		break;
+
+	case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+		/* Isochronous/Stream is not supported */
+
+		/* fallthru */
+	case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
+		if (transfer->type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS)
+			usbi_dbg("ISOC transfer: %d", transfer->length);
+		else
+			usbi_dbg("BULK STREAM transfer: %d", transfer->length);
+		err = LIBUSB_ERROR_NOT_SUPPORTED;
+		break;
+	}
+
+	return (err);
+}
+
+int
+sunos_cancel_transfer(struct usbi_transfer *itransfer)
+{
+	sunos_xfer_priv_t	*tpriv;
+	sunos_dev_handle_priv_t	*hpriv;
+	struct libusb_transfer	*transfer;
+	struct aiocb	*aiocb;
+	uint8_t		ep;
+	int		ret;
+
+	tpriv = usbi_transfer_get_os_priv(itransfer);
+	aiocb = &tpriv->aiocb;
+	transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	hpriv = (sunos_dev_handle_priv_t *)transfer->dev_handle->os_priv;
+	ep = sunos_usb_ep_index(transfer->endpoint);
+
+	ret = aio_cancel(hpriv->eps[ep].datafd, aiocb);
+
+	usbi_dbg("aio->fd=%d fd=%d ret = %d, %s", aiocb->aio_fildes,
+	    hpriv->eps[ep].datafd, ret, (ret == AIO_CANCELED)?
+	    strerror(0):strerror(errno));
+
+	if (ret != AIO_CANCELED) {
+		ret = _errno_to_libusb(errno);
+	} else {
+	/*
+	 * we don't need to call usbi_handle_transfer_cancellation(),
+	 * because we'll handle everything in sunos_async_callback.
+	 */
+		ret = LIBUSB_SUCCESS;
+	}
+
+	return (ret);
+}
+
+void
+sunos_clear_transfer_priv(struct usbi_transfer *itransfer)
+{
+	usbi_dbg("");
+
+	/* Nothing to do */
+}
+
+int
+sunos_handle_transfer_completion(struct usbi_transfer *itransfer)
+{
+	return usbi_handle_transfer_completion(itransfer, LIBUSB_TRANSFER_COMPLETED);
+}
+
+int
+sunos_clock_gettime(int clkid, struct timespec *tp)
+{
+	usbi_dbg("clock %d", clkid);
+
+	if (clkid == USBI_CLOCK_REALTIME)
+		return clock_gettime(CLOCK_REALTIME, tp);
+
+	if (clkid == USBI_CLOCK_MONOTONIC)
+		return clock_gettime(CLOCK_MONOTONIC, tp);
+
+	return (LIBUSB_ERROR_INVALID_PARAM);
+}
+
+int
+_errno_to_libusb(int err)
+{
+	usbi_dbg("error: %s (%d)", strerror(err), err);
+
+	switch (err) {
+	case EIO:
+		return (LIBUSB_ERROR_IO);
+	case EACCES:
+		return (LIBUSB_ERROR_ACCESS);
+	case ENOENT:
+		return (LIBUSB_ERROR_NO_DEVICE);
+	case ENOMEM:
+		return (LIBUSB_ERROR_NO_MEM);
+	case ETIMEDOUT:
+		return (LIBUSB_ERROR_TIMEOUT);
+	}
+
+	return (LIBUSB_ERROR_OTHER);
+}
+
+/*
+ * sunos_usb_get_status:
+ *	gets status of endpoint
+ *
+ * Returns: ugen's last cmd status
+ */
+static int
+sunos_usb_get_status(int fd)
+{
+	int status, ret;
+
+	usbi_dbg("sunos_usb_get_status(): fd=%d", fd);
+
+	ret = read(fd, &status, sizeof (status));
+	if (ret == sizeof (status)) {
+		switch (status) {
+		case USB_LC_STAT_NOERROR:
+			usbi_dbg("No Error");
+			break;
+		case USB_LC_STAT_CRC:
+			usbi_dbg("CRC Timeout Detected\n");
+			break;
+		case USB_LC_STAT_BITSTUFFING:
+			usbi_dbg("Bit Stuffing Violation\n");
+			break;
+		case USB_LC_STAT_DATA_TOGGLE_MM:
+			usbi_dbg("Data Toggle Mismatch\n");
+			break;
+		case USB_LC_STAT_STALL:
+			usbi_dbg("End Point Stalled\n");
+			break;
+		case USB_LC_STAT_DEV_NOT_RESP:
+			usbi_dbg("Device is Not Responding\n");
+			break;
+		case USB_LC_STAT_PID_CHECKFAILURE:
+			usbi_dbg("PID Check Failure\n");
+			break;
+		case USB_LC_STAT_UNEXP_PID:
+			usbi_dbg("Unexpected PID\n");
+			break;
+		case USB_LC_STAT_DATA_OVERRUN:
+			usbi_dbg("Data Exceeded Size\n");
+			break;
+		case USB_LC_STAT_DATA_UNDERRUN:
+			usbi_dbg("Less data received\n");
+			break;
+		case USB_LC_STAT_BUFFER_OVERRUN:
+			usbi_dbg("Buffer Size Exceeded\n");
+			break;
+		case USB_LC_STAT_BUFFER_UNDERRUN:
+			usbi_dbg("Buffer Underrun\n");
+			break;
+		case USB_LC_STAT_TIMEOUT:
+			usbi_dbg("Command Timed Out\n");
+			break;
+		case USB_LC_STAT_NOT_ACCESSED:
+			usbi_dbg("Not Accessed by h/w\n");
+			break;
+		case USB_LC_STAT_UNSPECIFIED_ERR:
+			usbi_dbg("Unspecified Error\n");
+			break;
+		case USB_LC_STAT_NO_BANDWIDTH:
+			usbi_dbg("No Bandwidth\n");
+			break;
+		case USB_LC_STAT_HW_ERR:
+			usbi_dbg("Host Controller h/w Error\n");
+			break;
+		case USB_LC_STAT_SUSPENDED:
+			usbi_dbg("Device was Suspended\n");
+			break;
+		case USB_LC_STAT_DISCONNECTED:
+			usbi_dbg("Device was Disconnected\n");
+			break;
+		case USB_LC_STAT_INTR_BUF_FULL:
+			usbi_dbg("Interrupt buffer was full\n");
+			break;
+		case USB_LC_STAT_INVALID_REQ:
+			usbi_dbg("Request was Invalid\n");
+			break;
+		case USB_LC_STAT_INTERRUPTED:
+			usbi_dbg("Request was Interrupted\n");
+			break;
+		case USB_LC_STAT_NO_RESOURCES:
+			usbi_dbg("No resources available for "
+			    "request\n");
+			break;
+		case USB_LC_STAT_INTR_POLLING_FAILED:
+			usbi_dbg("Failed to Restart Poll");
+			break;
+		default:
+			usbi_dbg("Error Not Determined %d\n",
+			    status);
+			break;
+		}
+	} else {
+		usbi_dbg("read stat error: %s",strerror(errno));
+		status = -1;
+	}
+
+	return (status);
+}
+
+const struct usbi_os_backend usbi_backend = {
+        .name = "Solaris",
+        .caps = 0,
+        .init = sunos_init,
+        .exit = sunos_exit,
+        .get_device_list = sunos_get_device_list,
+        .get_device_descriptor = sunos_get_device_descriptor,
+        .get_active_config_descriptor = sunos_get_active_config_descriptor,
+        .get_config_descriptor = sunos_get_config_descriptor,
+        .hotplug_poll = NULL,
+        .open = sunos_open,
+        .close = sunos_close,
+        .get_configuration = sunos_get_configuration,
+        .set_configuration = sunos_set_configuration,
+
+        .claim_interface = sunos_claim_interface,
+        .release_interface = sunos_release_interface,
+        .set_interface_altsetting = sunos_set_interface_altsetting,
+        .clear_halt = sunos_clear_halt,
+        .reset_device = sunos_reset_device, /* TODO */
+        .alloc_streams = NULL,
+        .free_streams = NULL,
+        .kernel_driver_active = sunos_kernel_driver_active,
+        .detach_kernel_driver = sunos_detach_kernel_driver,
+        .attach_kernel_driver = sunos_attach_kernel_driver,
+        .destroy_device = sunos_destroy_device,
+        .submit_transfer = sunos_submit_transfer,
+        .cancel_transfer = sunos_cancel_transfer,
+	.handle_events = NULL,
+        .clear_transfer_priv = sunos_clear_transfer_priv,
+        .handle_transfer_completion = sunos_handle_transfer_completion,
+        .clock_gettime = sunos_clock_gettime,
+        .device_priv_size = sizeof(sunos_dev_priv_t),
+        .device_handle_priv_size = sizeof(sunos_dev_handle_priv_t),
+        .transfer_priv_size = sizeof(sunos_xfer_priv_t),
+};
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/os/sunos_usb.h b/vendor/github.com/karalabe/usb/libusb/libusb/os/sunos_usb.h
new file mode 100644
index 000000000..52bb3d33a
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/os/sunos_usb.h
@@ -0,0 +1,80 @@
+/*
+ *
+ * Copyright (c) 2016, Oracle and/or its affiliates.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef	LIBUSB_SUNOS_H
+#define	LIBUSB_SUNOS_H
+
+#include <libdevinfo.h>
+#include <pthread.h>
+#include "libusbi.h"
+
+#define	READ	0
+#define	WRITE	1
+
+typedef struct sunos_device_priv {
+	uint8_t	cfgvalue;		/* active config value */
+	uint8_t	*raw_cfgdescr;		/* active config descriptor */
+	struct libusb_device_descriptor	dev_descr;	/* usb device descriptor */
+	char	*ugenpath;		/* name of the ugen(4) node */
+	char	*phypath;		/* physical path */
+} sunos_dev_priv_t;
+
+typedef	struct endpoint {
+	int datafd;	/* data file */
+	int statfd;	/* state file */
+} sunos_ep_priv_t;
+
+typedef struct sunos_device_handle_priv {
+	uint8_t			altsetting[USB_MAXINTERFACES];	/* a interface's alt */
+	uint8_t			config_index;
+	sunos_ep_priv_t		eps[USB_MAXENDPOINTS];
+	sunos_dev_priv_t	*dpriv; /* device private */
+} sunos_dev_handle_priv_t;
+
+typedef	struct sunos_transfer_priv {
+	struct aiocb		aiocb;
+	struct libusb_transfer	*transfer;
+} sunos_xfer_priv_t;
+
+struct node_args {
+	struct libusb_context	*ctx;
+	struct discovered_devs	**discdevs;
+	const char		*last_ugenpath;
+	di_devlink_handle_t	dlink_hdl;
+};
+
+struct devlink_cbarg {
+	struct node_args	*nargs;	/* di node walk arguments */
+	di_node_t		myself;	/* the di node */
+	di_minor_t		minor;
+};
+
+typedef struct walk_link {
+	char *path;
+	int len;
+	char **linkpp;
+} walk_link_t;
+
+/* AIO callback args */
+struct aio_callback_args{
+	struct libusb_transfer *transfer;
+	struct aiocb aiocb;
+};
+
+#endif /* LIBUSB_SUNOS_H */
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/os/threads_posix.c b/vendor/github.com/karalabe/usb/libusb/libusb/os/threads_posix.c
new file mode 100644
index 000000000..16a7578b8
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/os/threads_posix.c
@@ -0,0 +1,80 @@
+/*
+ * libusb synchronization using POSIX Threads
+ *
+ * Copyright © 2011 Vitali Lovich <vlovich@aliph.com>
+ * Copyright © 2011 Peter Stuge <peter@stuge.se>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <config.h>
+
+#include <time.h>
+#if defined(__linux__) || defined(__OpenBSD__)
+# if defined(__OpenBSD__)
+#  define _BSD_SOURCE
+# endif
+# include <unistd.h>
+# include <sys/syscall.h>
+#elif defined(__APPLE__)
+# include <pthread.h>
+#elif defined(__CYGWIN__)
+# include <windows.h>
+#endif
+
+#include "threads_posix.h"
+#include "libusbi.h"
+
+int usbi_cond_timedwait(pthread_cond_t *cond,
+	pthread_mutex_t *mutex, const struct timeval *tv)
+{
+	struct timespec timeout;
+	int r;
+
+	r = usbi_backend.clock_gettime(USBI_CLOCK_REALTIME, &timeout);
+	if (r < 0)
+		return r;
+
+	timeout.tv_sec += tv->tv_sec;
+	timeout.tv_nsec += tv->tv_usec * 1000;
+	while (timeout.tv_nsec >= 1000000000L) {
+		timeout.tv_nsec -= 1000000000L;
+		timeout.tv_sec++;
+	}
+
+	return pthread_cond_timedwait(cond, mutex, &timeout);
+}
+
+int usbi_get_tid(void)
+{
+	int ret;
+#if defined(__ANDROID__)
+	ret = gettid();
+#elif defined(__linux__)
+	ret = syscall(SYS_gettid);
+#elif defined(__OpenBSD__)
+	/* The following only works with OpenBSD > 5.1 as it requires
+	   real thread support. For 5.1 and earlier, -1 is returned. */
+	ret = syscall(SYS_getthrid);
+#elif defined(__APPLE__)
+	ret = (int)pthread_mach_thread_np(pthread_self());
+#elif defined(__CYGWIN__)
+	ret = GetCurrentThreadId();
+#else
+	ret = -1;
+#endif
+/* TODO: NetBSD thread ID support */
+	return ret;
+}
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/os/threads_posix.h b/vendor/github.com/karalabe/usb/libusb/libusb/os/threads_posix.h
new file mode 100644
index 000000000..9f1ef94bc
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/os/threads_posix.h
@@ -0,0 +1,102 @@
+/*
+ * libusb synchronization using POSIX Threads
+ *
+ * Copyright © 2010 Peter Stuge <peter@stuge.se>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef LIBUSB_THREADS_POSIX_H
+#define LIBUSB_THREADS_POSIX_H
+
+#include <pthread.h>
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+
+#define USBI_MUTEX_INITIALIZER	PTHREAD_MUTEX_INITIALIZER
+typedef pthread_mutex_t usbi_mutex_static_t;
+static inline void usbi_mutex_static_lock(usbi_mutex_static_t *mutex)
+{
+	(void)pthread_mutex_lock(mutex);
+}
+static inline void usbi_mutex_static_unlock(usbi_mutex_static_t *mutex)
+{
+	(void)pthread_mutex_unlock(mutex);
+}
+
+typedef pthread_mutex_t usbi_mutex_t;
+static inline int usbi_mutex_init(usbi_mutex_t *mutex)
+{
+	return pthread_mutex_init(mutex, NULL);
+}
+static inline void usbi_mutex_lock(usbi_mutex_t *mutex)
+{
+	(void)pthread_mutex_lock(mutex);
+}
+static inline void usbi_mutex_unlock(usbi_mutex_t *mutex)
+{
+	(void)pthread_mutex_unlock(mutex);
+}
+static inline int usbi_mutex_trylock(usbi_mutex_t *mutex)
+{
+	return pthread_mutex_trylock(mutex);
+}
+static inline void usbi_mutex_destroy(usbi_mutex_t *mutex)
+{
+	(void)pthread_mutex_destroy(mutex);
+}
+
+typedef pthread_cond_t usbi_cond_t;
+static inline void usbi_cond_init(pthread_cond_t *cond)
+{
+	(void)pthread_cond_init(cond, NULL);
+}
+static inline int usbi_cond_wait(usbi_cond_t *cond, usbi_mutex_t *mutex)
+{
+	return pthread_cond_wait(cond, mutex);
+}
+int usbi_cond_timedwait(usbi_cond_t *cond,
+	usbi_mutex_t *mutex, const struct timeval *tv);
+static inline void usbi_cond_broadcast(usbi_cond_t *cond)
+{
+	(void)pthread_cond_broadcast(cond);
+}
+static inline void usbi_cond_destroy(usbi_cond_t *cond)
+{
+	(void)pthread_cond_destroy(cond);
+}
+
+typedef pthread_key_t usbi_tls_key_t;
+static inline void usbi_tls_key_create(usbi_tls_key_t *key)
+{
+	(void)pthread_key_create(key, NULL);
+}
+static inline void *usbi_tls_key_get(usbi_tls_key_t key)
+{
+	return pthread_getspecific(key);
+}
+static inline void usbi_tls_key_set(usbi_tls_key_t key, void *ptr)
+{
+	(void)pthread_setspecific(key, ptr);
+}
+static inline void usbi_tls_key_delete(usbi_tls_key_t key)
+{
+	(void)pthread_key_delete(key);
+}
+
+int usbi_get_tid(void);
+
+#endif /* LIBUSB_THREADS_POSIX_H */
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/os/threads_windows.c b/vendor/github.com/karalabe/usb/libusb/libusb/os/threads_windows.c
new file mode 100644
index 000000000..409c49055
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/os/threads_windows.c
@@ -0,0 +1,126 @@
+/*
+ * libusb synchronization on Microsoft Windows
+ *
+ * Copyright © 2010 Michael Plante <michael.plante@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <config.h>
+
+#include <errno.h>
+
+#include "libusbi.h"
+
+struct usbi_cond_perthread {
+	struct list_head list;
+	HANDLE event;
+};
+
+void usbi_mutex_static_lock(usbi_mutex_static_t *mutex)
+{
+	while (InterlockedExchange(mutex, 1L) == 1L)
+		SleepEx(0, TRUE);
+}
+
+void usbi_cond_init(usbi_cond_t *cond)
+{
+	list_init(&cond->waiters);
+	list_init(&cond->not_waiting);
+}
+
+static int usbi_cond_intwait(usbi_cond_t *cond,
+	usbi_mutex_t *mutex, DWORD timeout_ms)
+{
+	struct usbi_cond_perthread *pos;
+	DWORD r;
+
+	// Same assumption as usbi_cond_broadcast() holds
+	if (list_empty(&cond->not_waiting)) {
+		pos = malloc(sizeof(*pos));
+		if (pos == NULL)
+			return ENOMEM; // This errno is not POSIX-allowed.
+		pos->event = CreateEvent(NULL, FALSE, FALSE, NULL); // auto-reset.
+		if (pos->event == NULL) {
+			free(pos);
+			return ENOMEM;
+		}
+	} else {
+		pos = list_first_entry(&cond->not_waiting, struct usbi_cond_perthread, list);
+		list_del(&pos->list); // remove from not_waiting list.
+		// Ensure the event is clear before waiting
+		WaitForSingleObject(pos->event, 0);
+	}
+
+	list_add(&pos->list, &cond->waiters);
+
+	LeaveCriticalSection(mutex);
+	r = WaitForSingleObject(pos->event, timeout_ms);
+	EnterCriticalSection(mutex);
+
+	list_del(&pos->list);
+	list_add(&pos->list, &cond->not_waiting);
+
+	if (r == WAIT_OBJECT_0)
+		return 0;
+	else if (r == WAIT_TIMEOUT)
+		return ETIMEDOUT;
+	else
+		return EINVAL;
+}
+
+// N.B.: usbi_cond_*wait() can also return ENOMEM, even though pthread_cond_*wait cannot!
+int usbi_cond_wait(usbi_cond_t *cond, usbi_mutex_t *mutex)
+{
+	return usbi_cond_intwait(cond, mutex, INFINITE);
+}
+
+int usbi_cond_timedwait(usbi_cond_t *cond,
+	usbi_mutex_t *mutex, const struct timeval *tv)
+{
+	DWORD millis;
+
+	millis = (DWORD)(tv->tv_sec * 1000) + (tv->tv_usec / 1000);
+	/* round up to next millisecond */
+	if (tv->tv_usec % 1000)
+		millis++;
+	return usbi_cond_intwait(cond, mutex, millis);
+}
+
+void usbi_cond_broadcast(usbi_cond_t *cond)
+{
+	// Assumes mutex is locked; this is not in keeping with POSIX spec, but
+	//   libusb does this anyway, so we simplify by not adding more sync
+	//   primitives to the CV definition!
+	struct usbi_cond_perthread *pos;
+
+	list_for_each_entry(pos, &cond->waiters, list, struct usbi_cond_perthread)
+		SetEvent(pos->event);
+	// The wait function will remove its respective item from the list.
+}
+
+void usbi_cond_destroy(usbi_cond_t *cond)
+{
+	// This assumes no one is using this anymore.  The check MAY NOT BE safe.
+	struct usbi_cond_perthread *pos, *next;
+
+	if (!list_empty(&cond->waiters))
+		return; // (!see above!)
+	list_for_each_entry_safe(pos, next, &cond->not_waiting, list, struct usbi_cond_perthread) {
+		CloseHandle(pos->event);
+		list_del(&pos->list);
+		free(pos);
+	}
+}
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/os/threads_windows.h b/vendor/github.com/karalabe/usb/libusb/libusb/os/threads_windows.h
new file mode 100644
index 000000000..409de2d0e
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/os/threads_windows.h
@@ -0,0 +1,111 @@
+/*
+ * libusb synchronization on Microsoft Windows
+ *
+ * Copyright © 2010 Michael Plante <michael.plante@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef LIBUSB_THREADS_WINDOWS_H
+#define LIBUSB_THREADS_WINDOWS_H
+
+#define USBI_MUTEX_INITIALIZER	0L
+#ifdef _WIN32_WCE
+typedef LONG usbi_mutex_static_t;
+#else
+typedef volatile LONG usbi_mutex_static_t;
+#endif
+void usbi_mutex_static_lock(usbi_mutex_static_t *mutex);
+static inline void usbi_mutex_static_unlock(usbi_mutex_static_t *mutex)
+{
+	InterlockedExchange(mutex, 0L);
+}
+
+typedef CRITICAL_SECTION usbi_mutex_t;
+static inline int usbi_mutex_init(usbi_mutex_t *mutex)
+{
+	InitializeCriticalSection(mutex);
+	return 0;
+}
+static inline void usbi_mutex_lock(usbi_mutex_t *mutex)
+{
+	EnterCriticalSection(mutex);
+}
+static inline void usbi_mutex_unlock(usbi_mutex_t *mutex)
+{
+	LeaveCriticalSection(mutex);
+}
+static inline int usbi_mutex_trylock(usbi_mutex_t *mutex)
+{
+	return !TryEnterCriticalSection(mutex);
+}
+static inline void usbi_mutex_destroy(usbi_mutex_t *mutex)
+{
+	DeleteCriticalSection(mutex);
+}
+
+// We *were* getting timespec from pthread.h:
+#if (!defined(HAVE_STRUCT_TIMESPEC) && !defined(_TIMESPEC_DEFINED))
+#define HAVE_STRUCT_TIMESPEC 1
+#define _TIMESPEC_DEFINED 1
+struct timespec {
+	long tv_sec;
+	long tv_nsec;
+};
+#endif /* HAVE_STRUCT_TIMESPEC | _TIMESPEC_DEFINED */
+
+// We *were* getting ETIMEDOUT from pthread.h:
+#ifndef ETIMEDOUT
+#define ETIMEDOUT	10060	/* This is the value in winsock.h. */
+#endif
+
+typedef struct usbi_cond {
+	// Every time a thread touches the CV, it winds up in one of these lists.
+	//   It stays there until the CV is destroyed, even if the thread terminates.
+	struct list_head waiters;
+	struct list_head not_waiting;
+} usbi_cond_t;
+
+void usbi_cond_init(usbi_cond_t *cond);
+int usbi_cond_wait(usbi_cond_t *cond, usbi_mutex_t *mutex);
+int usbi_cond_timedwait(usbi_cond_t *cond,
+	usbi_mutex_t *mutex, const struct timeval *tv);
+void usbi_cond_broadcast(usbi_cond_t *cond);
+void usbi_cond_destroy(usbi_cond_t *cond);
+
+typedef DWORD usbi_tls_key_t;
+static inline void usbi_tls_key_create(usbi_tls_key_t *key)
+{
+	*key = TlsAlloc();
+}
+static inline void *usbi_tls_key_get(usbi_tls_key_t key)
+{
+	return TlsGetValue(key);
+}
+static inline void usbi_tls_key_set(usbi_tls_key_t key, void *ptr)
+{
+	(void)TlsSetValue(key, ptr);
+}
+static inline void usbi_tls_key_delete(usbi_tls_key_t key)
+{
+	(void)TlsFree(key);
+}
+
+static inline int usbi_get_tid(void)
+{
+	return (int)GetCurrentThreadId();
+}
+
+#endif /* LIBUSB_THREADS_WINDOWS_H */
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/os/wince_usb.c b/vendor/github.com/karalabe/usb/libusb/libusb/os/wince_usb.c
new file mode 100644
index 000000000..a0f35e93e
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/os/wince_usb.c
@@ -0,0 +1,888 @@
+/*
+ * Windows CE backend for libusb 1.0
+ * Copyright © 2011-2013 RealVNC Ltd.
+ * Large portions taken from Windows backend, which is
+ * Copyright © 2009-2010 Pete Batard <pbatard@gmail.com>
+ * With contributions from Michael Plante, Orin Eman et al.
+ * Parts of this code adapted from libusb-win32-v1 by Stephan Meyer
+ * Major code testing contribution by Xiaofan Chen
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <config.h>
+
+#include <stdint.h>
+#include <inttypes.h>
+
+#include "libusbi.h"
+#include "wince_usb.h"
+
+// Global variables
+int errno = 0;
+static uint64_t hires_frequency, hires_ticks_to_ps;
+static HANDLE driver_handle = INVALID_HANDLE_VALUE;
+static int concurrent_usage = -1;
+
+/*
+ * Converts a windows error to human readable string
+ * uses retval as errorcode, or, if 0, use GetLastError()
+ */
+#if defined(ENABLE_LOGGING)
+static const char *windows_error_str(DWORD error_code)
+{
+	static TCHAR wErr_string[ERR_BUFFER_SIZE];
+	static char err_string[ERR_BUFFER_SIZE];
+
+	DWORD size;
+	int len;
+
+	if (error_code == 0)
+		error_code = GetLastError();
+
+	len = sprintf(err_string, "[%u] ", (unsigned int)error_code);
+
+	size = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,
+		NULL, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+		wErr_string, ERR_BUFFER_SIZE, NULL);
+	if (size == 0) {
+		DWORD format_error = GetLastError();
+		if (format_error)
+			snprintf(err_string, ERR_BUFFER_SIZE,
+				"Windows error code %u (FormatMessage error code %u)",
+				(unsigned int)error_code, (unsigned int)format_error);
+		else
+			snprintf(err_string, ERR_BUFFER_SIZE, "Unknown error code %u", (unsigned int)error_code);
+	} else {
+		// Remove CR/LF terminators, if present
+		size_t pos = size - 2;
+		if (wErr_string[pos] == 0x0D)
+			wErr_string[pos] = 0;
+
+		if (!WideCharToMultiByte(CP_ACP, 0, wErr_string, -1, &err_string[len], ERR_BUFFER_SIZE - len, NULL, NULL))
+			strcpy(err_string, "Unable to convert error string");
+	}
+
+	return err_string;
+}
+#endif
+
+static struct wince_device_priv *_device_priv(struct libusb_device *dev)
+{
+	return (struct wince_device_priv *)dev->os_priv;
+}
+
+// ceusbkwrapper to libusb error code mapping
+static int translate_driver_error(DWORD error)
+{
+	switch (error) {
+	case ERROR_INVALID_PARAMETER:
+		return LIBUSB_ERROR_INVALID_PARAM;
+	case ERROR_CALL_NOT_IMPLEMENTED:
+	case ERROR_NOT_SUPPORTED:
+		return LIBUSB_ERROR_NOT_SUPPORTED;
+	case ERROR_NOT_ENOUGH_MEMORY:
+		return LIBUSB_ERROR_NO_MEM;
+	case ERROR_INVALID_HANDLE:
+		return LIBUSB_ERROR_NO_DEVICE;
+	case ERROR_BUSY:
+		return LIBUSB_ERROR_BUSY;
+
+	// Error codes that are either unexpected, or have
+	// no suitable LIBUSB_ERROR equivalent.
+	case ERROR_CANCELLED:
+	case ERROR_INTERNAL_ERROR:
+	default:
+		return LIBUSB_ERROR_OTHER;
+	}
+}
+
+static BOOL init_dllimports(void)
+{
+	DLL_GET_HANDLE(ceusbkwrapper);
+	DLL_LOAD_FUNC(ceusbkwrapper, UkwOpenDriver, TRUE);
+	DLL_LOAD_FUNC(ceusbkwrapper, UkwGetDeviceList, TRUE);
+	DLL_LOAD_FUNC(ceusbkwrapper, UkwReleaseDeviceList, TRUE);
+	DLL_LOAD_FUNC(ceusbkwrapper, UkwGetDeviceAddress, TRUE);
+	DLL_LOAD_FUNC(ceusbkwrapper, UkwGetDeviceDescriptor, TRUE);
+	DLL_LOAD_FUNC(ceusbkwrapper, UkwGetConfigDescriptor, TRUE);
+	DLL_LOAD_FUNC(ceusbkwrapper, UkwCloseDriver, TRUE);
+	DLL_LOAD_FUNC(ceusbkwrapper, UkwCancelTransfer, TRUE);
+	DLL_LOAD_FUNC(ceusbkwrapper, UkwIssueControlTransfer, TRUE);
+	DLL_LOAD_FUNC(ceusbkwrapper, UkwClaimInterface, TRUE);
+	DLL_LOAD_FUNC(ceusbkwrapper, UkwReleaseInterface, TRUE);
+	DLL_LOAD_FUNC(ceusbkwrapper, UkwSetInterfaceAlternateSetting, TRUE);
+	DLL_LOAD_FUNC(ceusbkwrapper, UkwClearHaltHost, TRUE);
+	DLL_LOAD_FUNC(ceusbkwrapper, UkwClearHaltDevice, TRUE);
+	DLL_LOAD_FUNC(ceusbkwrapper, UkwGetConfig, TRUE);
+	DLL_LOAD_FUNC(ceusbkwrapper, UkwSetConfig, TRUE);
+	DLL_LOAD_FUNC(ceusbkwrapper, UkwResetDevice, TRUE);
+	DLL_LOAD_FUNC(ceusbkwrapper, UkwKernelDriverActive, TRUE);
+	DLL_LOAD_FUNC(ceusbkwrapper, UkwAttachKernelDriver, TRUE);
+	DLL_LOAD_FUNC(ceusbkwrapper, UkwDetachKernelDriver, TRUE);
+	DLL_LOAD_FUNC(ceusbkwrapper, UkwIssueBulkTransfer, TRUE);
+	DLL_LOAD_FUNC(ceusbkwrapper, UkwIsPipeHalted, TRUE);
+
+	return TRUE;
+}
+
+static void exit_dllimports(void)
+{
+	DLL_FREE_HANDLE(ceusbkwrapper);
+}
+
+static int init_device(
+	struct libusb_device *dev, UKW_DEVICE drv_dev,
+	unsigned char bus_addr, unsigned char dev_addr)
+{
+	struct wince_device_priv *priv = _device_priv(dev);
+	int r = LIBUSB_SUCCESS;
+
+	dev->bus_number = bus_addr;
+	dev->device_address = dev_addr;
+	priv->dev = drv_dev;
+
+	if (!UkwGetDeviceDescriptor(priv->dev, &(priv->desc)))
+		r = translate_driver_error(GetLastError());
+
+	return r;
+}
+
+// Internal API functions
+static int wince_init(struct libusb_context *ctx)
+{
+	int r = LIBUSB_ERROR_OTHER;
+	HANDLE semaphore;
+	LARGE_INTEGER li_frequency;
+	TCHAR sem_name[11 + 8 + 1]; // strlen("libusb_init") + (32-bit hex PID) + '\0'
+
+	_stprintf(sem_name, _T("libusb_init%08X"), (unsigned int)(GetCurrentProcessId() & 0xFFFFFFFF));
+	semaphore = CreateSemaphore(NULL, 1, 1, sem_name);
+	if (semaphore == NULL) {
+		usbi_err(ctx, "could not create semaphore: %s", windows_error_str(0));
+		return LIBUSB_ERROR_NO_MEM;
+	}
+
+	// A successful wait brings our semaphore count to 0 (unsignaled)
+	// => any concurent wait stalls until the semaphore's release
+	if (WaitForSingleObject(semaphore, INFINITE) != WAIT_OBJECT_0) {
+		usbi_err(ctx, "failure to access semaphore: %s", windows_error_str(0));
+		CloseHandle(semaphore);
+		return LIBUSB_ERROR_NO_MEM;
+	}
+
+	// NB: concurrent usage supposes that init calls are equally balanced with
+	// exit calls. If init is called more than exit, we will not exit properly
+	if ( ++concurrent_usage == 0 ) {	// First init?
+		// Load DLL imports
+		if (!init_dllimports()) {
+			usbi_err(ctx, "could not resolve DLL functions");
+			r = LIBUSB_ERROR_NOT_SUPPORTED;
+			goto init_exit;
+		}
+
+		// try to open a handle to the driver
+		driver_handle = UkwOpenDriver();
+		if (driver_handle == INVALID_HANDLE_VALUE) {
+			usbi_err(ctx, "could not connect to driver");
+			r = LIBUSB_ERROR_NOT_SUPPORTED;
+			goto init_exit;
+		}
+
+		// find out if we have access to a monotonic (hires) timer
+		if (QueryPerformanceFrequency(&li_frequency)) {
+			hires_frequency = li_frequency.QuadPart;
+			// The hires frequency can go as high as 4 GHz, so we'll use a conversion
+			// to picoseconds to compute the tv_nsecs part in clock_gettime
+			hires_ticks_to_ps = UINT64_C(1000000000000) / hires_frequency;
+			usbi_dbg("hires timer available (Frequency: %"PRIu64" Hz)", hires_frequency);
+		} else {
+			usbi_dbg("no hires timer available on this platform");
+			hires_frequency = 0;
+			hires_ticks_to_ps = UINT64_C(0);
+		}
+	}
+	// At this stage, either we went through full init successfully, or didn't need to
+	r = LIBUSB_SUCCESS;
+
+init_exit: // Holds semaphore here.
+	if (!concurrent_usage && r != LIBUSB_SUCCESS) { // First init failed?
+		exit_dllimports();
+
+		if (driver_handle != INVALID_HANDLE_VALUE) {
+			UkwCloseDriver(driver_handle);
+			driver_handle = INVALID_HANDLE_VALUE;
+		}
+	}
+
+	if (r != LIBUSB_SUCCESS)
+		--concurrent_usage; // Not expected to call libusb_exit if we failed.
+
+	ReleaseSemaphore(semaphore, 1, NULL);	// increase count back to 1
+	CloseHandle(semaphore);
+	return r;
+}
+
+static void wince_exit(struct libusb_context *ctx)
+{
+	HANDLE semaphore;
+	TCHAR sem_name[11 + 8 + 1]; // strlen("libusb_init") + (32-bit hex PID) + '\0'
+	UNUSED(ctx);
+
+	_stprintf(sem_name, _T("libusb_init%08X"), (unsigned int)(GetCurrentProcessId() & 0xFFFFFFFF));
+	semaphore = CreateSemaphore(NULL, 1, 1, sem_name);
+	if (semaphore == NULL)
+		return;
+
+	// A successful wait brings our semaphore count to 0 (unsignaled)
+	// => any concurent wait stalls until the semaphore release
+	if (WaitForSingleObject(semaphore, INFINITE) != WAIT_OBJECT_0) {
+		CloseHandle(semaphore);
+		return;
+	}
+
+	// Only works if exits and inits are balanced exactly
+	if (--concurrent_usage < 0) {	// Last exit
+		exit_dllimports();
+
+		if (driver_handle != INVALID_HANDLE_VALUE) {
+			UkwCloseDriver(driver_handle);
+			driver_handle = INVALID_HANDLE_VALUE;
+		}
+	}
+
+	ReleaseSemaphore(semaphore, 1, NULL);	// increase count back to 1
+	CloseHandle(semaphore);
+}
+
+static int wince_get_device_list(
+	struct libusb_context *ctx,
+	struct discovered_devs **discdevs)
+{
+	UKW_DEVICE devices[MAX_DEVICE_COUNT];
+	struct discovered_devs *new_devices = *discdevs;
+	DWORD count = 0, i;
+	struct libusb_device *dev = NULL;
+	unsigned char bus_addr, dev_addr;
+	unsigned long session_id;
+	BOOL success;
+	DWORD release_list_offset = 0;
+	int r = LIBUSB_SUCCESS;
+
+	success = UkwGetDeviceList(driver_handle, devices, MAX_DEVICE_COUNT, &count);
+	if (!success) {
+		int libusbErr = translate_driver_error(GetLastError());
+		usbi_err(ctx, "could not get devices: %s", windows_error_str(0));
+		return libusbErr;
+	}
+
+	for (i = 0; i < count; ++i) {
+		release_list_offset = i;
+		success = UkwGetDeviceAddress(devices[i], &bus_addr, &dev_addr, &session_id);
+		if (!success) {
+			r = translate_driver_error(GetLastError());
+			usbi_err(ctx, "could not get device address for %u: %s", (unsigned int)i, windows_error_str(0));
+			goto err_out;
+		}
+
+		dev = usbi_get_device_by_session_id(ctx, session_id);
+		if (dev) {
+			usbi_dbg("using existing device for %u/%u (session %lu)",
+					bus_addr, dev_addr, session_id);
+			// Release just this element in the device list (as we already hold a
+			// reference to it).
+			UkwReleaseDeviceList(driver_handle, &devices[i], 1);
+			release_list_offset++;
+		} else {
+			usbi_dbg("allocating new device for %u/%u (session %lu)",
+					bus_addr, dev_addr, session_id);
+			dev = usbi_alloc_device(ctx, session_id);
+			if (!dev) {
+				r = LIBUSB_ERROR_NO_MEM;
+				goto err_out;
+			}
+
+			r = init_device(dev, devices[i], bus_addr, dev_addr);
+			if (r < 0)
+				goto err_out;
+
+			r = usbi_sanitize_device(dev);
+			if (r < 0)
+				goto err_out;
+		}
+
+		new_devices = discovered_devs_append(new_devices, dev);
+		if (!new_devices) {
+			r = LIBUSB_ERROR_NO_MEM;
+			goto err_out;
+		}
+
+		libusb_unref_device(dev);
+	}
+
+	*discdevs = new_devices;
+	return r;
+err_out:
+	*discdevs = new_devices;
+	libusb_unref_device(dev);
+	// Release the remainder of the unprocessed device list.
+	// The devices added to new_devices already will still be passed up to libusb,
+	// which can dispose of them at its leisure.
+	UkwReleaseDeviceList(driver_handle, &devices[release_list_offset], count - release_list_offset);
+	return r;
+}
+
+static int wince_open(struct libusb_device_handle *handle)
+{
+	// Nothing to do to open devices as a handle to it has
+	// been retrieved by wince_get_device_list
+	return LIBUSB_SUCCESS;
+}
+
+static void wince_close(struct libusb_device_handle *handle)
+{
+	// Nothing to do as wince_open does nothing.
+}
+
+static int wince_get_device_descriptor(
+	struct libusb_device *device,
+	unsigned char *buffer, int *host_endian)
+{
+	struct wince_device_priv *priv = _device_priv(device);
+
+	*host_endian = 1;
+	memcpy(buffer, &priv->desc, DEVICE_DESC_LENGTH);
+	return LIBUSB_SUCCESS;
+}
+
+static int wince_get_active_config_descriptor(
+	struct libusb_device *device,
+	unsigned char *buffer, size_t len, int *host_endian)
+{
+	struct wince_device_priv *priv = _device_priv(device);
+	DWORD actualSize = len;
+
+	*host_endian = 0;
+	if (!UkwGetConfigDescriptor(priv->dev, UKW_ACTIVE_CONFIGURATION, buffer, len, &actualSize))
+		return translate_driver_error(GetLastError());
+
+	return actualSize;
+}
+
+static int wince_get_config_descriptor(
+	struct libusb_device *device,
+	uint8_t config_index,
+	unsigned char *buffer, size_t len, int *host_endian)
+{
+	struct wince_device_priv *priv = _device_priv(device);
+	DWORD actualSize = len;
+
+	*host_endian = 0;
+	if (!UkwGetConfigDescriptor(priv->dev, config_index, buffer, len, &actualSize))
+		return translate_driver_error(GetLastError());
+
+	return actualSize;
+}
+
+static int wince_get_configuration(
+	struct libusb_device_handle *handle,
+	int *config)
+{
+	struct wince_device_priv *priv = _device_priv(handle->dev);
+	UCHAR cv = 0;
+
+	if (!UkwGetConfig(priv->dev, &cv))
+		return translate_driver_error(GetLastError());
+
+	(*config) = cv;
+	return LIBUSB_SUCCESS;
+}
+
+static int wince_set_configuration(
+	struct libusb_device_handle *handle,
+	int config)
+{
+	struct wince_device_priv *priv = _device_priv(handle->dev);
+	// Setting configuration 0 places the device in Address state.
+	// This should correspond to the "unconfigured state" required by
+	// libusb when the specified configuration is -1.
+	UCHAR cv = (config < 0) ? 0 : config;
+	if (!UkwSetConfig(priv->dev, cv))
+		return translate_driver_error(GetLastError());
+
+	return LIBUSB_SUCCESS;
+}
+
+static int wince_claim_interface(
+	struct libusb_device_handle *handle,
+	int interface_number)
+{
+	struct wince_device_priv *priv = _device_priv(handle->dev);
+
+	if (!UkwClaimInterface(priv->dev, interface_number))
+		return translate_driver_error(GetLastError());
+
+	return LIBUSB_SUCCESS;
+}
+
+static int wince_release_interface(
+	struct libusb_device_handle *handle,
+	int interface_number)
+{
+	struct wince_device_priv *priv = _device_priv(handle->dev);
+
+	if (!UkwSetInterfaceAlternateSetting(priv->dev, interface_number, 0))
+		return translate_driver_error(GetLastError());
+
+	if (!UkwReleaseInterface(priv->dev, interface_number))
+		return translate_driver_error(GetLastError());
+
+	return LIBUSB_SUCCESS;
+}
+
+static int wince_set_interface_altsetting(
+	struct libusb_device_handle *handle,
+	int interface_number, int altsetting)
+{
+	struct wince_device_priv *priv = _device_priv(handle->dev);
+
+	if (!UkwSetInterfaceAlternateSetting(priv->dev, interface_number, altsetting))
+		return translate_driver_error(GetLastError());
+
+	return LIBUSB_SUCCESS;
+}
+
+static int wince_clear_halt(
+	struct libusb_device_handle *handle,
+	unsigned char endpoint)
+{
+	struct wince_device_priv *priv = _device_priv(handle->dev);
+
+	if (!UkwClearHaltHost(priv->dev, endpoint))
+		return translate_driver_error(GetLastError());
+
+	if (!UkwClearHaltDevice(priv->dev, endpoint))
+		return translate_driver_error(GetLastError());
+
+	return LIBUSB_SUCCESS;
+}
+
+static int wince_reset_device(
+	struct libusb_device_handle *handle)
+{
+	struct wince_device_priv *priv = _device_priv(handle->dev);
+
+	if (!UkwResetDevice(priv->dev))
+		return translate_driver_error(GetLastError());
+
+	return LIBUSB_SUCCESS;
+}
+
+static int wince_kernel_driver_active(
+	struct libusb_device_handle *handle,
+	int interface_number)
+{
+	struct wince_device_priv *priv = _device_priv(handle->dev);
+	BOOL result = FALSE;
+
+	if (!UkwKernelDriverActive(priv->dev, interface_number, &result))
+		return translate_driver_error(GetLastError());
+
+	return result ? 1 : 0;
+}
+
+static int wince_detach_kernel_driver(
+	struct libusb_device_handle *handle,
+	int interface_number)
+{
+	struct wince_device_priv *priv = _device_priv(handle->dev);
+
+	if (!UkwDetachKernelDriver(priv->dev, interface_number))
+		return translate_driver_error(GetLastError());
+
+	return LIBUSB_SUCCESS;
+}
+
+static int wince_attach_kernel_driver(
+	struct libusb_device_handle *handle,
+	int interface_number)
+{
+	struct wince_device_priv *priv = _device_priv(handle->dev);
+
+	if (!UkwAttachKernelDriver(priv->dev, interface_number))
+		return translate_driver_error(GetLastError());
+
+	return LIBUSB_SUCCESS;
+}
+
+static void wince_destroy_device(struct libusb_device *dev)
+{
+	struct wince_device_priv *priv = _device_priv(dev);
+
+	UkwReleaseDeviceList(driver_handle, &priv->dev, 1);
+}
+
+static void wince_clear_transfer_priv(struct usbi_transfer *itransfer)
+{
+	struct wince_transfer_priv *transfer_priv = usbi_transfer_get_os_priv(itransfer);
+
+	usbi_close(transfer_priv->pollable_fd.fd);
+	transfer_priv->pollable_fd = INVALID_WINFD;
+}
+
+static int wince_cancel_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct wince_device_priv *priv = _device_priv(transfer->dev_handle->dev);
+	struct wince_transfer_priv *transfer_priv = usbi_transfer_get_os_priv(itransfer);
+
+	if (!UkwCancelTransfer(priv->dev, transfer_priv->pollable_fd.overlapped, UKW_TF_NO_WAIT))
+		return translate_driver_error(GetLastError());
+
+	return LIBUSB_SUCCESS;
+}
+
+static int wince_submit_control_or_bulk_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct libusb_context *ctx = DEVICE_CTX(transfer->dev_handle->dev);
+	struct wince_transfer_priv *transfer_priv = usbi_transfer_get_os_priv(itransfer);
+	struct wince_device_priv *priv = _device_priv(transfer->dev_handle->dev);
+	BOOL direction_in, ret;
+	struct winfd wfd;
+	DWORD flags;
+	PUKW_CONTROL_HEADER setup = NULL;
+	const BOOL control_transfer = transfer->type == LIBUSB_TRANSFER_TYPE_CONTROL;
+	int r;
+
+	if (control_transfer) {
+		setup = (PUKW_CONTROL_HEADER) transfer->buffer;
+		direction_in = setup->bmRequestType & LIBUSB_ENDPOINT_IN;
+	} else {
+		direction_in = transfer->endpoint & LIBUSB_ENDPOINT_IN;
+	}
+	flags = direction_in ? UKW_TF_IN_TRANSFER : UKW_TF_OUT_TRANSFER;
+	flags |= UKW_TF_SHORT_TRANSFER_OK;
+
+	wfd = usbi_create_fd();
+	if (wfd.fd < 0)
+		return LIBUSB_ERROR_NO_MEM;
+
+	r = usbi_add_pollfd(ctx, wfd.fd, direction_in ? POLLIN : POLLOUT);
+	if (r) {
+		usbi_close(wfd.fd);
+		return r;
+	}
+
+	transfer_priv->pollable_fd = wfd;
+
+	if (control_transfer) {
+		// Split out control setup header and data buffer
+		DWORD bufLen = transfer->length - sizeof(UKW_CONTROL_HEADER);
+		PVOID buf = (PVOID) &transfer->buffer[sizeof(UKW_CONTROL_HEADER)];
+
+		ret = UkwIssueControlTransfer(priv->dev, flags, setup, buf, bufLen, &transfer->actual_length, wfd.overlapped);
+	} else {
+		ret = UkwIssueBulkTransfer(priv->dev, flags, transfer->endpoint, transfer->buffer,
+			transfer->length, &transfer->actual_length, wfd.overlapped);
+	}
+
+	if (!ret) {
+		int libusbErr = translate_driver_error(GetLastError());
+		usbi_err(ctx, "UkwIssue%sTransfer failed: error %u",
+			control_transfer ? "Control" : "Bulk", (unsigned int)GetLastError());
+		usbi_remove_pollfd(ctx, wfd.fd);
+		usbi_close(wfd.fd);
+		transfer_priv->pollable_fd = INVALID_WINFD;
+		return libusbErr;
+	}
+
+
+	return LIBUSB_SUCCESS;
+}
+
+static int wince_submit_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+
+	switch (transfer->type) {
+	case LIBUSB_TRANSFER_TYPE_CONTROL:
+	case LIBUSB_TRANSFER_TYPE_BULK:
+	case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+		return wince_submit_control_or_bulk_transfer(itransfer);
+	case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+	case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
+		return LIBUSB_ERROR_NOT_SUPPORTED;
+	default:
+		usbi_err(TRANSFER_CTX(transfer), "unknown endpoint type %d", transfer->type);
+		return LIBUSB_ERROR_INVALID_PARAM;
+	}
+}
+
+static void wince_transfer_callback(
+	struct usbi_transfer *itransfer,
+	uint32_t io_result, uint32_t io_size)
+{
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct wince_transfer_priv *transfer_priv = (struct wince_transfer_priv*)usbi_transfer_get_os_priv(itransfer);
+	struct wince_device_priv *priv = _device_priv(transfer->dev_handle->dev);
+	int status;
+
+	usbi_dbg("handling I/O completion with errcode %u", io_result);
+
+	if (io_result == ERROR_NOT_SUPPORTED &&
+		transfer->type != LIBUSB_TRANSFER_TYPE_CONTROL) {
+		/* For functional stalls, the WinCE USB layer (and therefore the USB Kernel Wrapper
+		 * Driver) will report USB_ERROR_STALL/ERROR_NOT_SUPPORTED in situations where the
+		 * endpoint isn't actually stalled.
+		 *
+		 * One example of this is that some devices will occasionally fail to reply to an IN
+		 * token. The WinCE USB layer carries on with the transaction until it is completed
+		 * (or cancelled) but then completes it with USB_ERROR_STALL.
+		 *
+		 * This code therefore needs to confirm that there really is a stall error, by both
+		 * checking the pipe status and requesting the endpoint status from the device.
+		 */
+		BOOL halted = FALSE;
+		usbi_dbg("checking I/O completion with errcode ERROR_NOT_SUPPORTED is really a stall");
+		if (UkwIsPipeHalted(priv->dev, transfer->endpoint, &halted)) {
+			/* Pipe status retrieved, so now request endpoint status by sending a GET_STATUS
+			 * control request to the device. This is done synchronously, which is a bit
+			 * naughty, but this is a special corner case.
+			 */
+			WORD wStatus = 0;
+			DWORD written = 0;
+			UKW_CONTROL_HEADER ctrlHeader;
+			ctrlHeader.bmRequestType = LIBUSB_REQUEST_TYPE_STANDARD |
+				LIBUSB_ENDPOINT_IN | LIBUSB_RECIPIENT_ENDPOINT;
+			ctrlHeader.bRequest = LIBUSB_REQUEST_GET_STATUS;
+			ctrlHeader.wValue = 0;
+			ctrlHeader.wIndex = transfer->endpoint;
+			ctrlHeader.wLength = sizeof(wStatus);
+			if (UkwIssueControlTransfer(priv->dev,
+					UKW_TF_IN_TRANSFER | UKW_TF_SEND_TO_ENDPOINT,
+					&ctrlHeader, &wStatus, sizeof(wStatus), &written, NULL)) {
+				if (written == sizeof(wStatus) &&
+						(wStatus & STATUS_HALT_FLAG) == 0) {
+					if (!halted || UkwClearHaltHost(priv->dev, transfer->endpoint)) {
+						usbi_dbg("Endpoint doesn't appear to be stalled, overriding error with success");
+						io_result = ERROR_SUCCESS;
+					} else {
+						usbi_dbg("Endpoint doesn't appear to be stalled, but the host is halted, changing error");
+						io_result = ERROR_IO_DEVICE;
+					}
+				}
+			}
+		}
+	}
+
+	switch(io_result) {
+	case ERROR_SUCCESS:
+		itransfer->transferred += io_size;
+		status = LIBUSB_TRANSFER_COMPLETED;
+		break;
+	case ERROR_CANCELLED:
+		usbi_dbg("detected transfer cancel");
+		status = LIBUSB_TRANSFER_CANCELLED;
+		break;
+	case ERROR_NOT_SUPPORTED:
+	case ERROR_GEN_FAILURE:
+		usbi_dbg("detected endpoint stall");
+		status = LIBUSB_TRANSFER_STALL;
+		break;
+	case ERROR_SEM_TIMEOUT:
+		usbi_dbg("detected semaphore timeout");
+		status = LIBUSB_TRANSFER_TIMED_OUT;
+		break;
+	case ERROR_OPERATION_ABORTED:
+		usbi_dbg("detected operation aborted");
+		status = LIBUSB_TRANSFER_CANCELLED;
+		break;
+	default:
+		usbi_err(ITRANSFER_CTX(itransfer), "detected I/O error: %s", windows_error_str(io_result));
+		status = LIBUSB_TRANSFER_ERROR;
+		break;
+	}
+
+	wince_clear_transfer_priv(itransfer);
+	if (status == LIBUSB_TRANSFER_CANCELLED)
+		usbi_handle_transfer_cancellation(itransfer);
+	else
+		usbi_handle_transfer_completion(itransfer, (enum libusb_transfer_status)status);
+}
+
+static void wince_handle_callback(
+	struct usbi_transfer *itransfer,
+	uint32_t io_result, uint32_t io_size)
+{
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+
+	switch (transfer->type) {
+	case LIBUSB_TRANSFER_TYPE_CONTROL:
+	case LIBUSB_TRANSFER_TYPE_BULK:
+	case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+	case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+		wince_transfer_callback (itransfer, io_result, io_size);
+		break;
+	case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
+		break;
+	default:
+		usbi_err(ITRANSFER_CTX(itransfer), "unknown endpoint type %d", transfer->type);
+	}
+}
+
+static int wince_handle_events(
+	struct libusb_context *ctx,
+	struct pollfd *fds, POLL_NFDS_TYPE nfds, int num_ready)
+{
+	struct wince_transfer_priv* transfer_priv = NULL;
+	POLL_NFDS_TYPE i = 0;
+	BOOL found = FALSE;
+	struct usbi_transfer *itransfer;
+	DWORD io_size, io_result;
+	int r = LIBUSB_SUCCESS;
+
+	usbi_mutex_lock(&ctx->open_devs_lock);
+	for (i = 0; i < nfds && num_ready > 0; i++) {
+
+		usbi_dbg("checking fd %d with revents = %04x", fds[i].fd, fds[i].revents);
+
+		if (!fds[i].revents)
+			continue;
+
+		num_ready--;
+
+		// Because a Windows OVERLAPPED is used for poll emulation,
+		// a pollable fd is created and stored with each transfer
+		usbi_mutex_lock(&ctx->flying_transfers_lock);
+		list_for_each_entry(itransfer, &ctx->flying_transfers, list, struct usbi_transfer) {
+			transfer_priv = usbi_transfer_get_os_priv(itransfer);
+			if (transfer_priv->pollable_fd.fd == fds[i].fd) {
+				found = TRUE;
+				break;
+			}
+		}
+		usbi_mutex_unlock(&ctx->flying_transfers_lock);
+
+		if (found && HasOverlappedIoCompleted(transfer_priv->pollable_fd.overlapped)) {
+			io_result = (DWORD)transfer_priv->pollable_fd.overlapped->Internal;
+			io_size = (DWORD)transfer_priv->pollable_fd.overlapped->InternalHigh;
+			usbi_remove_pollfd(ctx, transfer_priv->pollable_fd.fd);
+			// let handle_callback free the event using the transfer wfd
+			// If you don't use the transfer wfd, you run a risk of trying to free a
+			// newly allocated wfd that took the place of the one from the transfer.
+			wince_handle_callback(itransfer, io_result, io_size);
+		} else if (found) {
+			usbi_err(ctx, "matching transfer for fd %d has not completed", fds[i]);
+			r = LIBUSB_ERROR_OTHER;
+			break;
+		} else {
+			usbi_err(ctx, "could not find a matching transfer for fd %d", fds[i]);
+			r = LIBUSB_ERROR_NOT_FOUND;
+			break;
+		}
+	}
+	usbi_mutex_unlock(&ctx->open_devs_lock);
+
+	return r;
+}
+
+/*
+ * Monotonic and real time functions
+ */
+static int wince_clock_gettime(int clk_id, struct timespec *tp)
+{
+	LARGE_INTEGER hires_counter;
+	ULARGE_INTEGER rtime;
+	FILETIME filetime;
+	SYSTEMTIME st;
+
+	switch(clk_id) {
+	case USBI_CLOCK_MONOTONIC:
+		if (hires_frequency != 0 && QueryPerformanceCounter(&hires_counter)) {
+			tp->tv_sec = (long)(hires_counter.QuadPart / hires_frequency);
+			tp->tv_nsec = (long)(((hires_counter.QuadPart % hires_frequency) / 1000) * hires_ticks_to_ps);
+			return LIBUSB_SUCCESS;
+		}
+		// Fall through and return real-time if monotonic read failed or was not detected @ init
+	case USBI_CLOCK_REALTIME:
+		// We follow http://msdn.microsoft.com/en-us/library/ms724928%28VS.85%29.aspx
+		// with a predef epoch time to have an epoch that starts at 1970.01.01 00:00
+		// Note however that our resolution is bounded by the Windows system time
+		// functions and is at best of the order of 1 ms (or, usually, worse)
+		GetSystemTime(&st);
+		SystemTimeToFileTime(&st, &filetime);
+		rtime.LowPart = filetime.dwLowDateTime;
+		rtime.HighPart = filetime.dwHighDateTime;
+		rtime.QuadPart -= EPOCH_TIME;
+		tp->tv_sec = (long)(rtime.QuadPart / 10000000);
+		tp->tv_nsec = (long)((rtime.QuadPart % 10000000)*100);
+		return LIBUSB_SUCCESS;
+	default:
+		return LIBUSB_ERROR_INVALID_PARAM;
+	}
+}
+
+const struct usbi_os_backend usbi_backend = {
+	"Windows CE",
+	0,
+	wince_init,
+	wince_exit,
+	NULL,				/* set_option() */
+
+	wince_get_device_list,
+	NULL,				/* hotplug_poll */
+	wince_open,
+	wince_close,
+
+	wince_get_device_descriptor,
+	wince_get_active_config_descriptor,
+	wince_get_config_descriptor,
+	NULL,				/* get_config_descriptor_by_value() */
+
+	wince_get_configuration,
+	wince_set_configuration,
+	wince_claim_interface,
+	wince_release_interface,
+
+	wince_set_interface_altsetting,
+	wince_clear_halt,
+	wince_reset_device,
+
+	NULL,				/* alloc_streams */
+	NULL,				/* free_streams */
+
+	NULL,				/* dev_mem_alloc() */
+	NULL,				/* dev_mem_free() */
+
+	wince_kernel_driver_active,
+	wince_detach_kernel_driver,
+	wince_attach_kernel_driver,
+
+	wince_destroy_device,
+
+	wince_submit_transfer,
+	wince_cancel_transfer,
+	wince_clear_transfer_priv,
+
+	wince_handle_events,
+	NULL,				/* handle_transfer_completion() */
+
+	wince_clock_gettime,
+	0,
+	sizeof(struct wince_device_priv),
+	0,
+	sizeof(struct wince_transfer_priv),
+};
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/os/wince_usb.h b/vendor/github.com/karalabe/usb/libusb/libusb/os/wince_usb.h
new file mode 100644
index 000000000..edcb9fcc4
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/os/wince_usb.h
@@ -0,0 +1,126 @@
+/*
+ * Windows CE backend for libusb 1.0
+ * Copyright © 2011-2013 RealVNC Ltd.
+ * Portions taken from Windows backend, which is
+ * Copyright © 2009-2010 Pete Batard <pbatard@gmail.com>
+ * With contributions from Michael Plante, Orin Eman et al.
+ * Parts of this code adapted from libusb-win32-v1 by Stephan Meyer
+ * Major code testing contribution by Xiaofan Chen
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+#pragma once
+
+#include "windows_common.h"
+
+#include <windows.h>
+#include "poll_windows.h"
+
+#define MAX_DEVICE_COUNT            256
+
+// This is a modified dump of the types in the ceusbkwrapper.h library header
+// with functions transformed into extern pointers.
+//
+// This backend dynamically loads ceusbkwrapper.dll and doesn't include
+// ceusbkwrapper.h directly to simplify the build process. The kernel
+// side wrapper driver is built using the platform image build tools,
+// which makes it difficult to reference directly from the libusb build
+// system.
+struct UKW_DEVICE_PRIV;
+typedef struct UKW_DEVICE_PRIV *UKW_DEVICE;
+typedef UKW_DEVICE *PUKW_DEVICE, *LPUKW_DEVICE;
+
+typedef struct {
+	UINT8 bLength;
+	UINT8 bDescriptorType;
+	UINT16 bcdUSB;
+	UINT8 bDeviceClass;
+	UINT8 bDeviceSubClass;
+	UINT8 bDeviceProtocol;
+	UINT8 bMaxPacketSize0;
+	UINT16 idVendor;
+	UINT16 idProduct;
+	UINT16 bcdDevice;
+	UINT8 iManufacturer;
+	UINT8 iProduct;
+	UINT8 iSerialNumber;
+	UINT8 bNumConfigurations;
+} UKW_DEVICE_DESCRIPTOR, *PUKW_DEVICE_DESCRIPTOR, *LPUKW_DEVICE_DESCRIPTOR;
+
+typedef struct {
+	UINT8 bmRequestType;
+	UINT8 bRequest;
+	UINT16 wValue;
+	UINT16 wIndex;
+	UINT16 wLength;
+} UKW_CONTROL_HEADER, *PUKW_CONTROL_HEADER, *LPUKW_CONTROL_HEADER;
+
+// Collection of flags which can be used when issuing transfer requests
+/* Indicates that the transfer direction is 'in' */
+#define UKW_TF_IN_TRANSFER        0x00000001
+/* Indicates that the transfer direction is 'out' */
+#define UKW_TF_OUT_TRANSFER       0x00000000
+/* Specifies that the transfer should complete as soon as possible,
+ * even if no OVERLAPPED structure has been provided. */
+#define UKW_TF_NO_WAIT            0x00000100
+/* Indicates that transfers shorter than the buffer are ok */
+#define UKW_TF_SHORT_TRANSFER_OK  0x00000200
+#define UKW_TF_SEND_TO_DEVICE     0x00010000
+#define UKW_TF_SEND_TO_INTERFACE  0x00020000
+#define UKW_TF_SEND_TO_ENDPOINT   0x00040000
+/* Don't block when waiting for memory allocations */
+#define UKW_TF_DONT_BLOCK_FOR_MEM 0x00080000
+
+/* Value to use when dealing with configuration values, such as UkwGetConfigDescriptor, 
+ * to specify the currently active configuration for the device. */
+#define UKW_ACTIVE_CONFIGURATION -1
+
+DLL_DECLARE_HANDLE(ceusbkwrapper);
+DLL_DECLARE_FUNC(WINAPI, HANDLE, UkwOpenDriver, ());
+DLL_DECLARE_FUNC(WINAPI, BOOL, UkwGetDeviceList, (HANDLE, LPUKW_DEVICE, DWORD, LPDWORD));
+DLL_DECLARE_FUNC(WINAPI, void, UkwReleaseDeviceList, (HANDLE, LPUKW_DEVICE, DWORD));
+DLL_DECLARE_FUNC(WINAPI, BOOL, UkwGetDeviceAddress, (UKW_DEVICE, unsigned char*, unsigned char*, unsigned long*));
+DLL_DECLARE_FUNC(WINAPI, BOOL, UkwGetDeviceDescriptor, (UKW_DEVICE, LPUKW_DEVICE_DESCRIPTOR));
+DLL_DECLARE_FUNC(WINAPI, BOOL, UkwGetConfigDescriptor, (UKW_DEVICE, DWORD, LPVOID, DWORD, LPDWORD));
+DLL_DECLARE_FUNC(WINAPI, void, UkwCloseDriver, (HANDLE));
+DLL_DECLARE_FUNC(WINAPI, BOOL, UkwCancelTransfer, (UKW_DEVICE, LPOVERLAPPED, DWORD));
+DLL_DECLARE_FUNC(WINAPI, BOOL, UkwIssueControlTransfer, (UKW_DEVICE, DWORD, LPUKW_CONTROL_HEADER, LPVOID, DWORD, LPDWORD, LPOVERLAPPED));
+DLL_DECLARE_FUNC(WINAPI, BOOL, UkwClaimInterface, (UKW_DEVICE, DWORD));
+DLL_DECLARE_FUNC(WINAPI, BOOL, UkwReleaseInterface, (UKW_DEVICE, DWORD));
+DLL_DECLARE_FUNC(WINAPI, BOOL, UkwSetInterfaceAlternateSetting, (UKW_DEVICE, DWORD, DWORD));
+DLL_DECLARE_FUNC(WINAPI, BOOL, UkwClearHaltHost, (UKW_DEVICE, UCHAR));
+DLL_DECLARE_FUNC(WINAPI, BOOL, UkwClearHaltDevice, (UKW_DEVICE, UCHAR));
+DLL_DECLARE_FUNC(WINAPI, BOOL, UkwGetConfig, (UKW_DEVICE, PUCHAR));
+DLL_DECLARE_FUNC(WINAPI, BOOL, UkwSetConfig, (UKW_DEVICE, UCHAR));
+DLL_DECLARE_FUNC(WINAPI, BOOL, UkwResetDevice, (UKW_DEVICE));
+DLL_DECLARE_FUNC(WINAPI, BOOL, UkwKernelDriverActive, (UKW_DEVICE, DWORD, PBOOL));
+DLL_DECLARE_FUNC(WINAPI, BOOL, UkwAttachKernelDriver, (UKW_DEVICE, DWORD));
+DLL_DECLARE_FUNC(WINAPI, BOOL, UkwDetachKernelDriver, (UKW_DEVICE, DWORD));
+DLL_DECLARE_FUNC(WINAPI, BOOL, UkwIssueBulkTransfer, (UKW_DEVICE, DWORD, UCHAR, LPVOID, DWORD, LPDWORD, LPOVERLAPPED));
+DLL_DECLARE_FUNC(WINAPI, BOOL, UkwIsPipeHalted, (UKW_DEVICE, UCHAR, LPBOOL));
+
+// Used to determine if an endpoint status really is halted on a failed transfer.
+#define STATUS_HALT_FLAG 0x1
+
+struct wince_device_priv {
+	UKW_DEVICE dev;
+	UKW_DEVICE_DESCRIPTOR desc;
+};
+
+struct wince_transfer_priv {
+	struct winfd pollable_fd;
+	uint8_t interface_number;
+};
+
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/os/windows_common.h b/vendor/github.com/karalabe/usb/libusb/libusb/os/windows_common.h
new file mode 100644
index 000000000..b1725c2e3
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/os/windows_common.h
@@ -0,0 +1,128 @@
+/*
+ * Windows backend common header for libusb 1.0
+ *
+ * This file brings together header code common between
+ * the desktop Windows and Windows CE backends.
+ * Copyright © 2012-2013 RealVNC Ltd.
+ * Copyright © 2009-2012 Pete Batard <pete@akeo.ie>
+ * With contributions from Michael Plante, Orin Eman et al.
+ * Parts of this code adapted from libusb-win32-v1 by Stephan Meyer
+ * Major code testing contribution by Xiaofan Chen
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#pragma once
+
+// Windows API default is uppercase - ugh!
+#if !defined(bool)
+#define bool BOOL
+#endif
+#if !defined(true)
+#define true TRUE
+#endif
+#if !defined(false)
+#define false FALSE
+#endif
+
+#define EPOCH_TIME	UINT64_C(116444736000000000)	// 1970.01.01 00:00:000 in MS Filetime
+
+#if defined(__CYGWIN__ )
+#define _stricmp strcasecmp
+#define _strdup strdup
+// _beginthreadex is MSVCRT => unavailable for cygwin. Fallback to using CreateThread
+#define _beginthreadex(a, b, c, d, e, f) CreateThread(a, b, (LPTHREAD_START_ROUTINE)c, d, e, (LPDWORD)f)
+#endif
+
+#define safe_free(p) do {if (p != NULL) {free((void *)p); p = NULL;}} while (0)
+
+#ifndef ARRAYSIZE
+#define ARRAYSIZE(A) (sizeof(A)/sizeof((A)[0]))
+#endif
+
+#define ERR_BUFFER_SIZE	256
+
+/*
+ * API macros - leveraged from libusb-win32 1.x
+ */
+#ifndef _WIN32_WCE
+#define DLL_STRINGIFY(s) #s
+#define DLL_LOAD_LIBRARY(name) LoadLibraryA(DLL_STRINGIFY(name))
+#else
+#define DLL_STRINGIFY(s) L#s
+#define DLL_LOAD_LIBRARY(name) LoadLibrary(DLL_STRINGIFY(name))
+#endif
+
+/*
+ * Macros for handling DLL themselves
+ */
+#define DLL_HANDLE_NAME(name) __dll_##name##_handle
+
+#define DLL_DECLARE_HANDLE(name)				\
+	static HMODULE DLL_HANDLE_NAME(name) = NULL
+
+#define DLL_GET_HANDLE(name)					\
+	do {							\
+		DLL_HANDLE_NAME(name) = DLL_LOAD_LIBRARY(name);	\
+		if (!DLL_HANDLE_NAME(name))			\
+			return FALSE;				\
+	} while (0)
+
+#define DLL_FREE_HANDLE(name)					\
+	do {							\
+		if (DLL_HANDLE_NAME(name)) {			\
+			FreeLibrary(DLL_HANDLE_NAME(name));	\
+			DLL_HANDLE_NAME(name) = NULL;		\
+		}						\
+	} while (0)
+
+
+/*
+ * Macros for handling functions within a DLL
+ */
+#define DLL_FUNC_NAME(name) __dll_##name##_func_t
+
+#define DLL_DECLARE_FUNC_PREFIXNAME(api, ret, prefixname, name, args)	\
+	typedef ret (api * DLL_FUNC_NAME(name))args;			\
+	static DLL_FUNC_NAME(name) prefixname = NULL
+
+#define DLL_DECLARE_FUNC(api, ret, name, args)				\
+	DLL_DECLARE_FUNC_PREFIXNAME(api, ret, name, name, args)
+#define DLL_DECLARE_FUNC_PREFIXED(api, ret, prefix, name, args)		\
+	DLL_DECLARE_FUNC_PREFIXNAME(api, ret, prefix##name, name, args)
+
+#define DLL_LOAD_FUNC_PREFIXNAME(dll, prefixname, name, ret_on_failure)	\
+	do {								\
+		HMODULE h = DLL_HANDLE_NAME(dll);			\
+		prefixname = (DLL_FUNC_NAME(name))GetProcAddress(h,	\
+				DLL_STRINGIFY(name));			\
+		if (prefixname)						\
+			break;						\
+		prefixname = (DLL_FUNC_NAME(name))GetProcAddress(h,	\
+				DLL_STRINGIFY(name) DLL_STRINGIFY(A));	\
+		if (prefixname)						\
+			break;						\
+		prefixname = (DLL_FUNC_NAME(name))GetProcAddress(h,	\
+				DLL_STRINGIFY(name) DLL_STRINGIFY(W));	\
+		if (prefixname)						\
+			break;						\
+		if (ret_on_failure)					\
+			return FALSE;					\
+	} while (0)
+
+#define DLL_LOAD_FUNC(dll, name, ret_on_failure)			\
+	DLL_LOAD_FUNC_PREFIXNAME(dll, name, name, ret_on_failure)
+#define DLL_LOAD_FUNC_PREFIXED(dll, prefix, name, ret_on_failure)	\
+	DLL_LOAD_FUNC_PREFIXNAME(dll, prefix##name, name, ret_on_failure)
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/os/windows_nt_common.c b/vendor/github.com/karalabe/usb/libusb/libusb/os/windows_nt_common.c
new file mode 100644
index 000000000..92dbde5a8
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/os/windows_nt_common.c
@@ -0,0 +1,1008 @@
+/*
+ * windows backend for libusb 1.0
+ * Copyright © 2009-2012 Pete Batard <pete@akeo.ie>
+ * With contributions from Michael Plante, Orin Eman et al.
+ * Parts of this code adapted from libusb-win32-v1 by Stephan Meyer
+ * HID Reports IOCTLs inspired from HIDAPI by Alan Ott, Signal 11 Software
+ * Hash table functions adapted from glibc, by Ulrich Drepper et al.
+ * Major code testing contribution by Xiaofan Chen
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <config.h>
+
+#include <inttypes.h>
+#include <process.h>
+#include <stdio.h>
+
+#include "libusbi.h"
+#include "windows_common.h"
+#include "windows_nt_common.h"
+
+// Public
+BOOL (WINAPI *pCancelIoEx)(HANDLE, LPOVERLAPPED);
+enum windows_version windows_version = WINDOWS_UNDEFINED;
+
+ // Global variables for init/exit
+static unsigned int init_count = 0;
+static bool usbdk_available = false;
+
+// Global variables for clock_gettime mechanism
+static uint64_t hires_ticks_to_ps;
+static uint64_t hires_frequency;
+
+#define TIMER_REQUEST_RETRY_MS	100
+#define WM_TIMER_REQUEST	(WM_USER + 1)
+#define WM_TIMER_EXIT		(WM_USER + 2)
+
+// used for monotonic clock_gettime()
+struct timer_request {
+	struct timespec *tp;
+	HANDLE event;
+};
+
+// Timer thread
+static HANDLE timer_thread = NULL;
+static DWORD timer_thread_id = 0;
+
+/* Kernel32 dependencies */
+DLL_DECLARE_HANDLE(Kernel32);
+/* This call is only available from XP SP2 */
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, IsWow64Process, (HANDLE, PBOOL));
+
+/* User32 dependencies */
+DLL_DECLARE_HANDLE(User32);
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, GetMessageA, (LPMSG, HWND, UINT, UINT));
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, PeekMessageA, (LPMSG, HWND, UINT, UINT, UINT));
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, PostThreadMessageA, (DWORD, UINT, WPARAM, LPARAM));
+
+static unsigned __stdcall windows_clock_gettime_threaded(void *param);
+
+/*
+* Converts a windows error to human readable string
+* uses retval as errorcode, or, if 0, use GetLastError()
+*/
+#if defined(ENABLE_LOGGING)
+const char *windows_error_str(DWORD error_code)
+{
+	static char err_string[ERR_BUFFER_SIZE];
+
+	DWORD size;
+	int len;
+
+	if (error_code == 0)
+		error_code = GetLastError();
+
+	len = sprintf(err_string, "[%u] ", (unsigned int)error_code);
+
+	// Translate codes returned by SetupAPI. The ones we are dealing with are either
+	// in 0x0000xxxx or 0xE000xxxx and can be distinguished from standard error codes.
+	// See http://msdn.microsoft.com/en-us/library/windows/hardware/ff545011.aspx
+	switch (error_code & 0xE0000000) {
+	case 0:
+		error_code = HRESULT_FROM_WIN32(error_code); // Still leaves ERROR_SUCCESS unmodified
+		break;
+	case 0xE0000000:
+		error_code = 0x80000000 | (FACILITY_SETUPAPI << 16) | (error_code & 0x0000FFFF);
+		break;
+	default:
+		break;
+	}
+
+	size = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,
+			NULL, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+			&err_string[len], ERR_BUFFER_SIZE - len, NULL);
+	if (size == 0) {
+		DWORD format_error = GetLastError();
+		if (format_error)
+			snprintf(err_string, ERR_BUFFER_SIZE,
+				"Windows error code %u (FormatMessage error code %u)",
+				(unsigned int)error_code, (unsigned int)format_error);
+		else
+			snprintf(err_string, ERR_BUFFER_SIZE, "Unknown error code %u", (unsigned int)error_code);
+	} else {
+		// Remove CRLF from end of message, if present
+		size_t pos = len + size - 2;
+		if (err_string[pos] == '\r')
+			err_string[pos] = '\0';
+	}
+
+	return err_string;
+}
+#endif
+
+static inline struct windows_context_priv *_context_priv(struct libusb_context *ctx)
+{
+	return (struct windows_context_priv *)ctx->os_priv;
+}
+
+/* Hash table functions - modified From glibc 2.3.2:
+   [Aho,Sethi,Ullman] Compilers: Principles, Techniques and Tools, 1986
+   [Knuth]            The Art of Computer Programming, part 3 (6.4)  */
+
+#define HTAB_SIZE 1021UL	// *MUST* be a prime number!!
+
+typedef struct htab_entry {
+	unsigned long used;
+	char *str;
+} htab_entry;
+
+static htab_entry *htab_table = NULL;
+static usbi_mutex_t htab_mutex;
+static unsigned long htab_filled;
+
+/* Before using the hash table we must allocate memory for it.
+   We allocate one element more as the found prime number says.
+   This is done for more effective indexing as explained in the
+   comment for the hash function.  */
+static bool htab_create(struct libusb_context *ctx)
+{
+	if (htab_table != NULL) {
+		usbi_err(ctx, "hash table already allocated");
+		return true;
+	}
+
+	// Create a mutex
+	usbi_mutex_init(&htab_mutex);
+
+	usbi_dbg("using %lu entries hash table", HTAB_SIZE);
+	htab_filled = 0;
+
+	// allocate memory and zero out.
+	htab_table = calloc(HTAB_SIZE + 1, sizeof(htab_entry));
+	if (htab_table == NULL) {
+		usbi_err(ctx, "could not allocate space for hash table");
+		return false;
+	}
+
+	return true;
+}
+
+/* After using the hash table it has to be destroyed.  */
+static void htab_destroy(void)
+{
+	unsigned long i;
+
+	if (htab_table == NULL)
+		return;
+
+	for (i = 0; i < HTAB_SIZE; i++)
+		free(htab_table[i].str);
+
+	safe_free(htab_table);
+
+	usbi_mutex_destroy(&htab_mutex);
+}
+
+/* This is the search function. It uses double hashing with open addressing.
+   We use a trick to speed up the lookup. The table is created with one
+   more element available. This enables us to use the index zero special.
+   This index will never be used because we store the first hash index in
+   the field used where zero means not used. Every other value means used.
+   The used field can be used as a first fast comparison for equality of
+   the stored and the parameter value. This helps to prevent unnecessary
+   expensive calls of strcmp.  */
+unsigned long htab_hash(const char *str)
+{
+	unsigned long hval, hval2;
+	unsigned long idx;
+	unsigned long r = 5381;
+	int c;
+	const char *sz = str;
+
+	if (str == NULL)
+		return 0;
+
+	// Compute main hash value (algorithm suggested by Nokia)
+	while ((c = *sz++) != 0)
+		r = ((r << 5) + r) + c;
+	if (r == 0)
+		++r;
+
+	// compute table hash: simply take the modulus
+	hval = r % HTAB_SIZE;
+	if (hval == 0)
+		++hval;
+
+	// Try the first index
+	idx = hval;
+
+	// Mutually exclusive access (R/W lock would be better)
+	usbi_mutex_lock(&htab_mutex);
+
+	if (htab_table[idx].used) {
+		if ((htab_table[idx].used == hval) && (strcmp(str, htab_table[idx].str) == 0))
+			goto out_unlock; // existing hash
+
+		usbi_dbg("hash collision ('%s' vs '%s')", str, htab_table[idx].str);
+
+		// Second hash function, as suggested in [Knuth]
+		hval2 = 1 + hval % (HTAB_SIZE - 2);
+
+		do {
+			// Because size is prime this guarantees to step through all available indexes
+			if (idx <= hval2)
+				idx = HTAB_SIZE + idx - hval2;
+			else
+				idx -= hval2;
+
+			// If we visited all entries leave the loop unsuccessfully
+			if (idx == hval)
+				break;
+
+			// If entry is found use it.
+			if ((htab_table[idx].used == hval) && (strcmp(str, htab_table[idx].str) == 0))
+				goto out_unlock;
+		} while (htab_table[idx].used);
+	}
+
+	// Not found => New entry
+
+	// If the table is full return an error
+	if (htab_filled >= HTAB_SIZE) {
+		usbi_err(NULL, "hash table is full (%lu entries)", HTAB_SIZE);
+		idx = 0;
+		goto out_unlock;
+	}
+
+	htab_table[idx].str = _strdup(str);
+	if (htab_table[idx].str == NULL) {
+		usbi_err(NULL, "could not duplicate string for hash table");
+		idx = 0;
+		goto out_unlock;
+	}
+
+	htab_table[idx].used = hval;
+	++htab_filled;
+
+out_unlock:
+	usbi_mutex_unlock(&htab_mutex);
+
+	return idx;
+}
+
+/*
+* Make a transfer complete synchronously
+*/
+void windows_force_sync_completion(OVERLAPPED *overlapped, ULONG size)
+{
+	overlapped->Internal = STATUS_COMPLETED_SYNCHRONOUSLY;
+	overlapped->InternalHigh = size;
+	SetEvent(overlapped->hEvent);
+}
+
+static BOOL windows_init_dlls(void)
+{
+	DLL_GET_HANDLE(Kernel32);
+	DLL_LOAD_FUNC_PREFIXED(Kernel32, p, IsWow64Process, FALSE);
+	pCancelIoEx = (BOOL (WINAPI *)(HANDLE, LPOVERLAPPED))
+		GetProcAddress(DLL_HANDLE_NAME(Kernel32), "CancelIoEx");
+	usbi_dbg("Will use CancelIo%s for I/O cancellation", pCancelIoEx ? "Ex" : "");
+
+	DLL_GET_HANDLE(User32);
+	DLL_LOAD_FUNC_PREFIXED(User32, p, GetMessageA, TRUE);
+	DLL_LOAD_FUNC_PREFIXED(User32, p, PeekMessageA, TRUE);
+	DLL_LOAD_FUNC_PREFIXED(User32, p, PostThreadMessageA, TRUE);
+
+	return TRUE;
+}
+
+static void windows_exit_dlls(void)
+{
+	DLL_FREE_HANDLE(Kernel32);
+	DLL_FREE_HANDLE(User32);
+}
+
+static bool windows_init_clock(struct libusb_context *ctx)
+{
+	DWORD_PTR affinity, dummy;
+	HANDLE event;
+	LARGE_INTEGER li_frequency;
+	int i;
+
+	if (QueryPerformanceFrequency(&li_frequency)) {
+		// The hires frequency can go as high as 4 GHz, so we'll use a conversion
+		// to picoseconds to compute the tv_nsecs part in clock_gettime
+		hires_frequency = li_frequency.QuadPart;
+		hires_ticks_to_ps = UINT64_C(1000000000000) / hires_frequency;
+		usbi_dbg("hires timer available (Frequency: %"PRIu64" Hz)", hires_frequency);
+
+		// Because QueryPerformanceCounter might report different values when
+		// running on different cores, we create a separate thread for the timer
+		// calls, which we glue to the first available core always to prevent timing discrepancies.
+		if (!GetProcessAffinityMask(GetCurrentProcess(), &affinity, &dummy) || (affinity == 0)) {
+			usbi_err(ctx, "could not get process affinity: %s", windows_error_str(0));
+			return false;
+		}
+
+		// The process affinity mask is a bitmask where each set bit represents a core on
+		// which this process is allowed to run, so we find the first set bit
+		for (i = 0; !(affinity & (DWORD_PTR)(1 << i)); i++);
+		affinity = (DWORD_PTR)(1 << i);
+
+		usbi_dbg("timer thread will run on core #%d", i);
+
+		event = CreateEvent(NULL, FALSE, FALSE, NULL);
+		if (event == NULL) {
+			usbi_err(ctx, "could not create event: %s", windows_error_str(0));
+			return false;
+		}
+
+		timer_thread = (HANDLE)_beginthreadex(NULL, 0, windows_clock_gettime_threaded, (void *)event,
+				0, (unsigned int *)&timer_thread_id);
+		if (timer_thread == NULL) {
+			usbi_err(ctx, "unable to create timer thread - aborting");
+			CloseHandle(event);
+			return false;
+		}
+
+		if (!SetThreadAffinityMask(timer_thread, affinity))
+			usbi_warn(ctx, "unable to set timer thread affinity, timer discrepancies may arise");
+
+		// Wait for timer thread to init before continuing.
+		if (WaitForSingleObject(event, INFINITE) != WAIT_OBJECT_0) {
+			usbi_err(ctx, "failed to wait for timer thread to become ready - aborting");
+			CloseHandle(event);
+			return false;
+		}
+
+		CloseHandle(event);
+	} else {
+		usbi_dbg("no hires timer available on this platform");
+		hires_frequency = 0;
+		hires_ticks_to_ps = UINT64_C(0);
+	}
+
+	return true;
+}
+
+static void windows_destroy_clock(void)
+{
+	if (timer_thread) {
+		// actually the signal to quit the thread.
+		if (!pPostThreadMessageA(timer_thread_id, WM_TIMER_EXIT, 0, 0)
+				|| (WaitForSingleObject(timer_thread, INFINITE) != WAIT_OBJECT_0)) {
+			usbi_dbg("could not wait for timer thread to quit");
+			TerminateThread(timer_thread, 1);
+			// shouldn't happen, but we're destroying
+			// all objects it might have held anyway.
+		}
+		CloseHandle(timer_thread);
+		timer_thread = NULL;
+		timer_thread_id = 0;
+	}
+}
+
+/* Windows version detection */
+static BOOL is_x64(void)
+{
+	BOOL ret = FALSE;
+
+	// Detect if we're running a 32 or 64 bit system
+	if (sizeof(uintptr_t) < 8) {
+		if (pIsWow64Process != NULL)
+			pIsWow64Process(GetCurrentProcess(), &ret);
+	} else {
+		ret = TRUE;
+	}
+
+	return ret;
+}
+
+static void get_windows_version(void)
+{
+	OSVERSIONINFOEXA vi, vi2;
+	const char *arch, *w = NULL;
+	unsigned major, minor, version;
+	ULONGLONG major_equal, minor_equal;
+	BOOL ws;
+
+	windows_version = WINDOWS_UNDEFINED;
+
+	memset(&vi, 0, sizeof(vi));
+	vi.dwOSVersionInfoSize = sizeof(vi);
+	if (!GetVersionExA((OSVERSIONINFOA *)&vi)) {
+		memset(&vi, 0, sizeof(vi));
+		vi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
+		if (!GetVersionExA((OSVERSIONINFOA *)&vi))
+			return;
+	}
+
+	if (vi.dwPlatformId != VER_PLATFORM_WIN32_NT)
+		return;
+
+	if ((vi.dwMajorVersion > 6) || ((vi.dwMajorVersion == 6) && (vi.dwMinorVersion >= 2))) {
+		// Starting with Windows 8.1 Preview, GetVersionEx() does no longer report the actual OS version
+		// See: http://msdn.microsoft.com/en-us/library/windows/desktop/dn302074.aspx
+
+		major_equal = VerSetConditionMask(0, VER_MAJORVERSION, VER_EQUAL);
+		for (major = vi.dwMajorVersion; major <= 9; major++) {
+			memset(&vi2, 0, sizeof(vi2));
+			vi2.dwOSVersionInfoSize = sizeof(vi2);
+			vi2.dwMajorVersion = major;
+			if (!VerifyVersionInfoA(&vi2, VER_MAJORVERSION, major_equal))
+				continue;
+
+			if (vi.dwMajorVersion < major) {
+				vi.dwMajorVersion = major;
+				vi.dwMinorVersion = 0;
+			}
+
+			minor_equal = VerSetConditionMask(0, VER_MINORVERSION, VER_EQUAL);
+			for (minor = vi.dwMinorVersion; minor <= 9; minor++) {
+				memset(&vi2, 0, sizeof(vi2));
+				vi2.dwOSVersionInfoSize = sizeof(vi2);
+				vi2.dwMinorVersion = minor;
+				if (!VerifyVersionInfoA(&vi2, VER_MINORVERSION, minor_equal))
+					continue;
+
+				vi.dwMinorVersion = minor;
+				break;
+			}
+
+			break;
+		}
+	}
+
+	if ((vi.dwMajorVersion > 0xf) || (vi.dwMinorVersion > 0xf))
+		return;
+
+	ws = (vi.wProductType <= VER_NT_WORKSTATION);
+	version = vi.dwMajorVersion << 4 | vi.dwMinorVersion;
+	switch (version) {
+	case 0x50: windows_version = WINDOWS_2000;  w = "2000";	break;
+	case 0x51: windows_version = WINDOWS_XP;    w = "XP";	break;
+	case 0x52: windows_version = WINDOWS_2003;  w = "2003";	break;
+	case 0x60: windows_version = WINDOWS_VISTA; w = (ws ? "Vista" : "2008");  break;
+	case 0x61: windows_version = WINDOWS_7;	    w = (ws ? "7" : "2008_R2");	  break;
+	case 0x62: windows_version = WINDOWS_8;	    w = (ws ? "8" : "2012");	  break;
+	case 0x63: windows_version = WINDOWS_8_1;   w = (ws ? "8.1" : "2012_R2"); break;
+	case 0x64: windows_version = WINDOWS_10;    w = (ws ? "10" : "2016");	  break;
+	default:
+		if (version < 0x50) {
+			return;
+		} else {
+			windows_version = WINDOWS_11_OR_LATER;
+			w = "11 or later";
+		}
+	}
+
+	arch = is_x64() ? "64-bit" : "32-bit";
+
+	if (vi.wServicePackMinor)
+		usbi_dbg("Windows %s SP%u.%u %s", w, vi.wServicePackMajor, vi.wServicePackMinor, arch);
+	else if (vi.wServicePackMajor)
+		usbi_dbg("Windows %s SP%u %s", w, vi.wServicePackMajor, arch);
+	else
+		usbi_dbg("Windows %s %s", w, arch);
+}
+
+/*
+* Monotonic and real time functions
+*/
+static unsigned __stdcall windows_clock_gettime_threaded(void *param)
+{
+	struct timer_request *request;
+	LARGE_INTEGER hires_counter;
+	MSG msg;
+
+	// The following call will create this thread's message queue
+	// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms644946.aspx
+	pPeekMessageA(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
+
+	// Signal windows_init_clock() that we're ready to service requests
+	if (!SetEvent((HANDLE)param))
+		usbi_dbg("SetEvent failed for timer init event: %s", windows_error_str(0));
+	param = NULL;
+
+	// Main loop - wait for requests
+	while (1) {
+		if (pGetMessageA(&msg, NULL, WM_TIMER_REQUEST, WM_TIMER_EXIT) == -1) {
+			usbi_err(NULL, "GetMessage failed for timer thread: %s", windows_error_str(0));
+			return 1;
+		}
+
+		switch (msg.message) {
+		case WM_TIMER_REQUEST:
+			// Requests to this thread are for hires always
+			// Microsoft says that this function always succeeds on XP and later
+			// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms644904.aspx
+			request = (struct timer_request *)msg.lParam;
+			QueryPerformanceCounter(&hires_counter);
+			request->tp->tv_sec = (long)(hires_counter.QuadPart / hires_frequency);
+			request->tp->tv_nsec = (long)(((hires_counter.QuadPart % hires_frequency) / 1000) * hires_ticks_to_ps);
+			if (!SetEvent(request->event))
+				usbi_err(NULL, "SetEvent failed for timer request: %s", windows_error_str(0));
+			break;
+		case WM_TIMER_EXIT:
+			usbi_dbg("timer thread quitting");
+			return 0;
+		}
+	}
+}
+
+static void windows_transfer_callback(const struct windows_backend *backend,
+	struct usbi_transfer *itransfer, DWORD io_result, DWORD io_size)
+{
+	int status, istatus;
+
+	usbi_dbg("handling I/O completion with errcode %u, size %u", (unsigned int)io_result, (unsigned int)io_size);
+
+	switch (io_result) {
+	case NO_ERROR:
+		status = backend->copy_transfer_data(itransfer, (uint32_t)io_size);
+		break;
+	case ERROR_GEN_FAILURE:
+		usbi_dbg("detected endpoint stall");
+		status = LIBUSB_TRANSFER_STALL;
+		break;
+	case ERROR_SEM_TIMEOUT:
+		usbi_dbg("detected semaphore timeout");
+		status = LIBUSB_TRANSFER_TIMED_OUT;
+		break;
+	case ERROR_OPERATION_ABORTED:
+		istatus = backend->copy_transfer_data(itransfer, (uint32_t)io_size);
+		if (istatus != LIBUSB_TRANSFER_COMPLETED)
+			usbi_dbg("Failed to copy partial data in aborted operation: %d", istatus);
+
+		usbi_dbg("detected operation aborted");
+		status = LIBUSB_TRANSFER_CANCELLED;
+		break;
+	case ERROR_FILE_NOT_FOUND:
+		usbi_dbg("detected device removed");
+		status = LIBUSB_TRANSFER_NO_DEVICE;
+		break;
+	default:
+		usbi_err(ITRANSFER_CTX(itransfer), "detected I/O error %u: %s", (unsigned int)io_result, windows_error_str(io_result));
+		status = LIBUSB_TRANSFER_ERROR;
+		break;
+	}
+	backend->clear_transfer_priv(itransfer);	// Cancel polling
+	if (status == LIBUSB_TRANSFER_CANCELLED)
+		usbi_handle_transfer_cancellation(itransfer);
+	else
+		usbi_handle_transfer_completion(itransfer, (enum libusb_transfer_status)status);
+}
+
+static void windows_handle_callback(const struct windows_backend *backend,
+	struct usbi_transfer *itransfer, DWORD io_result, DWORD io_size)
+{
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+
+	switch (transfer->type) {
+	case LIBUSB_TRANSFER_TYPE_CONTROL:
+	case LIBUSB_TRANSFER_TYPE_BULK:
+	case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+	case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+		windows_transfer_callback(backend, itransfer, io_result, io_size);
+		break;
+	case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
+		usbi_warn(ITRANSFER_CTX(itransfer), "bulk stream transfers are not yet supported on this platform");
+		break;
+	default:
+		usbi_err(ITRANSFER_CTX(itransfer), "unknown endpoint type %d", transfer->type);
+	}
+}
+
+static int windows_init(struct libusb_context *ctx)
+{
+	struct windows_context_priv *priv = _context_priv(ctx);
+	HANDLE semaphore;
+	char sem_name[11 + 8 + 1]; // strlen("libusb_init") + (32-bit hex PID) + '\0'
+	int r = LIBUSB_ERROR_OTHER;
+	bool winusb_backend_init = false;
+
+	sprintf(sem_name, "libusb_init%08X", (unsigned int)(GetCurrentProcessId() & 0xFFFFFFFF));
+	semaphore = CreateSemaphoreA(NULL, 1, 1, sem_name);
+	if (semaphore == NULL) {
+		usbi_err(ctx, "could not create semaphore: %s", windows_error_str(0));
+		return LIBUSB_ERROR_NO_MEM;
+	}
+
+	// A successful wait brings our semaphore count to 0 (unsignaled)
+	// => any concurent wait stalls until the semaphore's release
+	if (WaitForSingleObject(semaphore, INFINITE) != WAIT_OBJECT_0) {
+		usbi_err(ctx, "failure to access semaphore: %s", windows_error_str(0));
+		CloseHandle(semaphore);
+		return LIBUSB_ERROR_NO_MEM;
+	}
+
+	// NB: concurrent usage supposes that init calls are equally balanced with
+	// exit calls. If init is called more than exit, we will not exit properly
+	if (++init_count == 1) { // First init?
+		// Load DLL imports
+		if (!windows_init_dlls()) {
+			usbi_err(ctx, "could not resolve DLL functions");
+			goto init_exit;
+		}
+
+		get_windows_version();
+
+		if (windows_version == WINDOWS_UNDEFINED) {
+			usbi_err(ctx, "failed to detect Windows version");
+			r = LIBUSB_ERROR_NOT_SUPPORTED;
+			goto init_exit;
+		}
+
+		if (!windows_init_clock(ctx))
+			goto init_exit;
+
+		if (!htab_create(ctx))
+			goto init_exit;
+
+		r = winusb_backend.init(ctx);
+		if (r != LIBUSB_SUCCESS)
+			goto init_exit;
+		winusb_backend_init = true;
+
+		r = usbdk_backend.init(ctx);
+		if (r == LIBUSB_SUCCESS) {
+			usbi_dbg("UsbDk backend is available");
+			usbdk_available = true;
+		} else {
+			usbi_info(ctx, "UsbDk backend is not available");
+			// Do not report this as an error
+			r = LIBUSB_SUCCESS;
+		}
+	}
+
+	// By default, new contexts will use the WinUSB backend
+	priv->backend = &winusb_backend;
+
+	r = LIBUSB_SUCCESS;
+
+init_exit: // Holds semaphore here
+	if ((init_count == 1) && (r != LIBUSB_SUCCESS)) { // First init failed?
+		if (winusb_backend_init)
+			winusb_backend.exit(ctx);
+		htab_destroy();
+		windows_destroy_clock();
+		windows_exit_dlls();
+		--init_count;
+	}
+
+	ReleaseSemaphore(semaphore, 1, NULL); // increase count back to 1
+	CloseHandle(semaphore);
+	return r;
+}
+
+static void windows_exit(struct libusb_context *ctx)
+{
+	HANDLE semaphore;
+	char sem_name[11 + 8 + 1]; // strlen("libusb_init") + (32-bit hex PID) + '\0'
+	UNUSED(ctx);
+
+	sprintf(sem_name, "libusb_init%08X", (unsigned int)(GetCurrentProcessId() & 0xFFFFFFFF));
+	semaphore = CreateSemaphoreA(NULL, 1, 1, sem_name);
+	if (semaphore == NULL)
+		return;
+
+	// A successful wait brings our semaphore count to 0 (unsignaled)
+	// => any concurent wait stalls until the semaphore release
+	if (WaitForSingleObject(semaphore, INFINITE) != WAIT_OBJECT_0) {
+		CloseHandle(semaphore);
+		return;
+	}
+
+	// Only works if exits and inits are balanced exactly
+	if (--init_count == 0) { // Last exit
+		if (usbdk_available) {
+			usbdk_backend.exit(ctx);
+			usbdk_available = false;
+		}
+		winusb_backend.exit(ctx);
+		htab_destroy();
+		windows_destroy_clock();
+		windows_exit_dlls();
+	}
+
+	ReleaseSemaphore(semaphore, 1, NULL); // increase count back to 1
+	CloseHandle(semaphore);
+}
+
+static int windows_set_option(struct libusb_context *ctx, enum libusb_option option, va_list ap)
+{
+	struct windows_context_priv *priv = _context_priv(ctx);
+
+	UNUSED(ap);
+
+	switch (option) {
+	case LIBUSB_OPTION_USE_USBDK:
+		if (usbdk_available) {
+			usbi_dbg("switching context %p to use UsbDk backend", ctx);
+			priv->backend = &usbdk_backend;
+		} else {
+			usbi_err(ctx, "UsbDk backend not available");
+			return LIBUSB_ERROR_NOT_FOUND;
+		}
+		return LIBUSB_SUCCESS;
+	default:
+		return LIBUSB_ERROR_NOT_SUPPORTED;
+	}
+
+}
+
+static int windows_get_device_list(struct libusb_context *ctx, struct discovered_devs **discdevs)
+{
+	struct windows_context_priv *priv = _context_priv(ctx);
+	return priv->backend->get_device_list(ctx, discdevs);
+}
+
+static int windows_open(struct libusb_device_handle *dev_handle)
+{
+	struct windows_context_priv *priv = _context_priv(HANDLE_CTX(dev_handle));
+	return priv->backend->open(dev_handle);
+}
+
+static void windows_close(struct libusb_device_handle *dev_handle)
+{
+	struct windows_context_priv *priv = _context_priv(HANDLE_CTX(dev_handle));
+	priv->backend->close(dev_handle);
+}
+
+static int windows_get_device_descriptor(struct libusb_device *dev,
+	unsigned char *buffer, int *host_endian)
+{
+	struct windows_context_priv *priv = _context_priv(DEVICE_CTX(dev));
+	*host_endian = 0;
+	return priv->backend->get_device_descriptor(dev, buffer);
+}
+
+static int windows_get_active_config_descriptor(struct libusb_device *dev,
+	unsigned char *buffer, size_t len, int *host_endian)
+{
+	struct windows_context_priv *priv = _context_priv(DEVICE_CTX(dev));
+	*host_endian = 0;
+	return priv->backend->get_active_config_descriptor(dev, buffer, len);
+}
+
+static int windows_get_config_descriptor(struct libusb_device *dev,
+	uint8_t config_index, unsigned char *buffer, size_t len, int *host_endian)
+{
+	struct windows_context_priv *priv = _context_priv(DEVICE_CTX(dev));
+	*host_endian = 0;
+	return priv->backend->get_config_descriptor(dev, config_index, buffer, len);
+}
+
+static int windows_get_config_descriptor_by_value(struct libusb_device *dev,
+	uint8_t bConfigurationValue, unsigned char **buffer, int *host_endian)
+{
+	struct windows_context_priv *priv = _context_priv(DEVICE_CTX(dev));
+	*host_endian = 0;
+	return priv->backend->get_config_descriptor_by_value(dev, bConfigurationValue, buffer);
+}
+
+static int windows_get_configuration(struct libusb_device_handle *dev_handle, int *config)
+{
+	struct windows_context_priv *priv = _context_priv(HANDLE_CTX(dev_handle));
+	return priv->backend->get_configuration(dev_handle, config);
+}
+
+static int windows_set_configuration(struct libusb_device_handle *dev_handle, int config)
+{
+	struct windows_context_priv *priv = _context_priv(HANDLE_CTX(dev_handle));
+	return priv->backend->set_configuration(dev_handle, config);
+}
+
+static int windows_claim_interface(struct libusb_device_handle *dev_handle, int interface_number)
+{
+	struct windows_context_priv *priv = _context_priv(HANDLE_CTX(dev_handle));
+	return priv->backend->claim_interface(dev_handle, interface_number);
+}
+
+static int windows_release_interface(struct libusb_device_handle *dev_handle, int interface_number)
+{
+	struct windows_context_priv *priv = _context_priv(HANDLE_CTX(dev_handle));
+	return priv->backend->release_interface(dev_handle, interface_number);
+}
+
+static int windows_set_interface_altsetting(struct libusb_device_handle *dev_handle,
+	int interface_number, int altsetting)
+{
+	struct windows_context_priv *priv = _context_priv(HANDLE_CTX(dev_handle));
+	return priv->backend->set_interface_altsetting(dev_handle, interface_number, altsetting);
+}
+
+static int windows_clear_halt(struct libusb_device_handle *dev_handle, unsigned char endpoint)
+{
+	struct windows_context_priv *priv = _context_priv(HANDLE_CTX(dev_handle));
+	return priv->backend->clear_halt(dev_handle, endpoint);
+}
+
+static int windows_reset_device(struct libusb_device_handle *dev_handle)
+{
+	struct windows_context_priv *priv = _context_priv(HANDLE_CTX(dev_handle));
+	return priv->backend->reset_device(dev_handle);
+}
+
+static void windows_destroy_device(struct libusb_device *dev)
+{
+	struct windows_context_priv *priv = _context_priv(DEVICE_CTX(dev));
+	priv->backend->destroy_device(dev);
+}
+
+static int windows_submit_transfer(struct usbi_transfer *itransfer)
+{
+	struct windows_context_priv *priv = _context_priv(ITRANSFER_CTX(itransfer));
+	return priv->backend->submit_transfer(itransfer);
+}
+
+static int windows_cancel_transfer(struct usbi_transfer *itransfer)
+{
+	struct windows_context_priv *priv = _context_priv(ITRANSFER_CTX(itransfer));
+	return priv->backend->cancel_transfer(itransfer);
+}
+
+static void windows_clear_transfer_priv(struct usbi_transfer *itransfer)
+{
+	struct windows_context_priv *priv = _context_priv(ITRANSFER_CTX(itransfer));
+	priv->backend->clear_transfer_priv(itransfer);
+}
+
+static int windows_handle_events(struct libusb_context *ctx, struct pollfd *fds, POLL_NFDS_TYPE nfds, int num_ready)
+{
+	struct windows_context_priv *priv = _context_priv(ctx);
+	struct usbi_transfer *itransfer;
+	DWORD io_size, io_result;
+	POLL_NFDS_TYPE i;
+	bool found;
+	int transfer_fd;
+	int r = LIBUSB_SUCCESS;
+
+	usbi_mutex_lock(&ctx->open_devs_lock);
+	for (i = 0; i < nfds && num_ready > 0; i++) {
+
+		usbi_dbg("checking fd %d with revents = %04x", fds[i].fd, fds[i].revents);
+
+		if (!fds[i].revents)
+			continue;
+
+		num_ready--;
+
+		// Because a Windows OVERLAPPED is used for poll emulation,
+		// a pollable fd is created and stored with each transfer
+		found = false;
+		transfer_fd = -1;
+		usbi_mutex_lock(&ctx->flying_transfers_lock);
+		list_for_each_entry(itransfer, &ctx->flying_transfers, list, struct usbi_transfer) {
+			transfer_fd = priv->backend->get_transfer_fd(itransfer);
+			if (transfer_fd == fds[i].fd) {
+				found = true;
+				break;
+			}
+		}
+		usbi_mutex_unlock(&ctx->flying_transfers_lock);
+
+		if (found) {
+			priv->backend->get_overlapped_result(itransfer, &io_result, &io_size);
+
+			usbi_remove_pollfd(ctx, transfer_fd);
+
+			// let handle_callback free the event using the transfer wfd
+			// If you don't use the transfer wfd, you run a risk of trying to free a
+			// newly allocated wfd that took the place of the one from the transfer.
+			windows_handle_callback(priv->backend, itransfer, io_result, io_size);
+		} else {
+			usbi_err(ctx, "could not find a matching transfer for fd %d", fds[i].fd);
+			r = LIBUSB_ERROR_NOT_FOUND;
+			break;
+		}
+	}
+	usbi_mutex_unlock(&ctx->open_devs_lock);
+
+	return r;
+}
+
+static int windows_clock_gettime(int clk_id, struct timespec *tp)
+{
+	struct timer_request request;
+#if !defined(_MSC_VER) || (_MSC_VER < 1900)
+	FILETIME filetime;
+	ULARGE_INTEGER rtime;
+#endif
+	DWORD r;
+
+	switch (clk_id) {
+	case USBI_CLOCK_MONOTONIC:
+		if (timer_thread) {
+			request.tp = tp;
+			request.event = CreateEvent(NULL, FALSE, FALSE, NULL);
+			if (request.event == NULL)
+				return LIBUSB_ERROR_NO_MEM;
+
+			if (!pPostThreadMessageA(timer_thread_id, WM_TIMER_REQUEST, 0, (LPARAM)&request)) {
+				usbi_err(NULL, "PostThreadMessage failed for timer thread: %s", windows_error_str(0));
+				CloseHandle(request.event);
+				return LIBUSB_ERROR_OTHER;
+			}
+
+			do {
+				r = WaitForSingleObject(request.event, TIMER_REQUEST_RETRY_MS);
+				if (r == WAIT_TIMEOUT)
+					usbi_dbg("could not obtain a timer value within reasonable timeframe - too much load?");
+				else if (r == WAIT_FAILED)
+					usbi_err(NULL, "WaitForSingleObject failed: %s", windows_error_str(0));
+			} while (r == WAIT_TIMEOUT);
+			CloseHandle(request.event);
+
+			if (r == WAIT_OBJECT_0)
+				return LIBUSB_SUCCESS;
+			else
+				return LIBUSB_ERROR_OTHER;
+		}
+		// Fall through and return real-time if monotonic was not detected @ timer init
+	case USBI_CLOCK_REALTIME:
+#if defined(_MSC_VER) && (_MSC_VER >= 1900)
+		timespec_get(tp, TIME_UTC);
+#else
+		// We follow http://msdn.microsoft.com/en-us/library/ms724928%28VS.85%29.aspx
+		// with a predef epoch time to have an epoch that starts at 1970.01.01 00:00
+		// Note however that our resolution is bounded by the Windows system time
+		// functions and is at best of the order of 1 ms (or, usually, worse)
+		GetSystemTimeAsFileTime(&filetime);
+		rtime.LowPart = filetime.dwLowDateTime;
+		rtime.HighPart = filetime.dwHighDateTime;
+		rtime.QuadPart -= EPOCH_TIME;
+		tp->tv_sec = (long)(rtime.QuadPart / 10000000);
+		tp->tv_nsec = (long)((rtime.QuadPart % 10000000) * 100);
+#endif
+		return LIBUSB_SUCCESS;
+	default:
+		return LIBUSB_ERROR_INVALID_PARAM;
+	}
+}
+
+// NB: MSVC6 does not support named initializers.
+const struct usbi_os_backend usbi_backend = {
+	"Windows",
+	USBI_CAP_HAS_HID_ACCESS,
+	windows_init,
+	windows_exit,
+	windows_set_option,
+	windows_get_device_list,
+	NULL,	/* hotplug_poll */
+	windows_open,
+	windows_close,
+	windows_get_device_descriptor,
+	windows_get_active_config_descriptor,
+	windows_get_config_descriptor,
+	windows_get_config_descriptor_by_value,
+	windows_get_configuration,
+	windows_set_configuration,
+	windows_claim_interface,
+	windows_release_interface,
+	windows_set_interface_altsetting,
+	windows_clear_halt,
+	windows_reset_device,
+	NULL,	/* alloc_streams */
+	NULL,	/* free_streams */
+	NULL,	/* dev_mem_alloc */
+	NULL,	/* dev_mem_free */
+	NULL,	/* kernel_driver_active */
+	NULL,	/* detach_kernel_driver */
+	NULL,	/* attach_kernel_driver */
+	windows_destroy_device,
+	windows_submit_transfer,
+	windows_cancel_transfer,
+	windows_clear_transfer_priv,
+	windows_handle_events,
+	NULL,	/* handle_transfer_completion */
+	windows_clock_gettime,
+	sizeof(struct windows_context_priv),
+	sizeof(union windows_device_priv),
+	sizeof(union windows_device_handle_priv),
+	sizeof(union windows_transfer_priv),
+};
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/os/windows_nt_common.h b/vendor/github.com/karalabe/usb/libusb/libusb/os/windows_nt_common.h
new file mode 100644
index 000000000..e155b5d3e
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/os/windows_nt_common.h
@@ -0,0 +1,110 @@
+/*
+ * Windows backend common header for libusb 1.0
+ *
+ * This file brings together header code common between
+ * the desktop Windows backends.
+ * Copyright © 2012-2013 RealVNC Ltd.
+ * Copyright © 2009-2012 Pete Batard <pete@akeo.ie>
+ * With contributions from Michael Plante, Orin Eman et al.
+ * Parts of this code adapted from libusb-win32-v1 by Stephan Meyer
+ * Major code testing contribution by Xiaofan Chen
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#pragma once
+
+#include "windows_nt_shared_types.h"
+
+ /* Windows versions */
+enum windows_version {
+	WINDOWS_UNDEFINED,
+	WINDOWS_2000,
+	WINDOWS_XP,
+	WINDOWS_2003,	// Also XP x64
+	WINDOWS_VISTA,
+	WINDOWS_7,
+	WINDOWS_8,
+	WINDOWS_8_1,
+	WINDOWS_10,
+	WINDOWS_11_OR_LATER
+};
+
+extern enum windows_version windows_version;
+
+/* This call is only available from Vista */
+extern BOOL (WINAPI *pCancelIoEx)(HANDLE, LPOVERLAPPED);
+
+struct windows_backend {
+	int (*init)(struct libusb_context *ctx);
+	void (*exit)(struct libusb_context *ctx);
+	int (*get_device_list)(struct libusb_context *ctx,
+		struct discovered_devs **discdevs);
+	int (*open)(struct libusb_device_handle *dev_handle);
+	void (*close)(struct libusb_device_handle *dev_handle);
+	int (*get_device_descriptor)(struct libusb_device *device, unsigned char *buffer);
+	int (*get_active_config_descriptor)(struct libusb_device *device,
+		unsigned char *buffer, size_t len);
+	int (*get_config_descriptor)(struct libusb_device *device,
+		uint8_t config_index, unsigned char *buffer, size_t len);
+	int (*get_config_descriptor_by_value)(struct libusb_device *device,
+		uint8_t bConfigurationValue, unsigned char **buffer);
+	int (*get_configuration)(struct libusb_device_handle *dev_handle, int *config);
+	int (*set_configuration)(struct libusb_device_handle *dev_handle, int config);
+	int (*claim_interface)(struct libusb_device_handle *dev_handle, int interface_number);
+	int (*release_interface)(struct libusb_device_handle *dev_handle, int interface_number);
+	int (*set_interface_altsetting)(struct libusb_device_handle *dev_handle,
+		int interface_number, int altsetting);
+	int (*clear_halt)(struct libusb_device_handle *dev_handle,
+		unsigned char endpoint);
+	int (*reset_device)(struct libusb_device_handle *dev_handle);
+	void (*destroy_device)(struct libusb_device *dev);
+	int (*submit_transfer)(struct usbi_transfer *itransfer);
+	int (*cancel_transfer)(struct usbi_transfer *itransfer);
+	void (*clear_transfer_priv)(struct usbi_transfer *itransfer);
+	int (*copy_transfer_data)(struct usbi_transfer *itransfer, uint32_t io_size);
+	int (*get_transfer_fd)(struct usbi_transfer *itransfer);
+	void (*get_overlapped_result)(struct usbi_transfer *itransfer,
+		DWORD *io_result, DWORD *io_size);
+};
+
+struct windows_context_priv {
+	const struct windows_backend *backend;
+};
+
+union windows_device_priv {
+	struct usbdk_device_priv usbdk_priv;
+	struct winusb_device_priv winusb_priv;
+};
+
+union windows_device_handle_priv {
+	struct usbdk_device_handle_priv usbdk_priv;
+	struct winusb_device_handle_priv winusb_priv;
+};
+
+union windows_transfer_priv {
+	struct usbdk_transfer_priv usbdk_priv;
+	struct winusb_transfer_priv winusb_priv;
+};
+
+extern const struct windows_backend usbdk_backend;
+extern const struct windows_backend winusb_backend;
+
+unsigned long htab_hash(const char *str);
+void windows_force_sync_completion(OVERLAPPED *overlapped, ULONG size);
+
+#if defined(ENABLE_LOGGING)
+const char *windows_error_str(DWORD error_code);
+#endif
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/os/windows_nt_shared_types.h b/vendor/github.com/karalabe/usb/libusb/libusb/os/windows_nt_shared_types.h
new file mode 100644
index 000000000..68bf261d5
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/os/windows_nt_shared_types.h
@@ -0,0 +1,138 @@
+#pragma once
+
+#include "windows_common.h"
+
+#include <pshpack1.h>
+
+typedef struct USB_DEVICE_DESCRIPTOR {
+	UCHAR  bLength;
+	UCHAR  bDescriptorType;
+	USHORT bcdUSB;
+	UCHAR  bDeviceClass;
+	UCHAR  bDeviceSubClass;
+	UCHAR  bDeviceProtocol;
+	UCHAR  bMaxPacketSize0;
+	USHORT idVendor;
+	USHORT idProduct;
+	USHORT bcdDevice;
+	UCHAR  iManufacturer;
+	UCHAR  iProduct;
+	UCHAR  iSerialNumber;
+	UCHAR  bNumConfigurations;
+} USB_DEVICE_DESCRIPTOR, *PUSB_DEVICE_DESCRIPTOR;
+
+typedef struct USB_CONFIGURATION_DESCRIPTOR {
+	UCHAR  bLength;
+	UCHAR  bDescriptorType;
+	USHORT wTotalLength;
+	UCHAR  bNumInterfaces;
+	UCHAR  bConfigurationValue;
+	UCHAR  iConfiguration;
+	UCHAR  bmAttributes;
+	UCHAR  MaxPower;
+} USB_CONFIGURATION_DESCRIPTOR, *PUSB_CONFIGURATION_DESCRIPTOR;
+
+#include <poppack.h>
+
+#define MAX_DEVICE_ID_LEN	200
+
+typedef struct USB_DK_DEVICE_ID {
+	WCHAR DeviceID[MAX_DEVICE_ID_LEN];
+	WCHAR InstanceID[MAX_DEVICE_ID_LEN];
+} USB_DK_DEVICE_ID, *PUSB_DK_DEVICE_ID;
+
+typedef struct USB_DK_DEVICE_INFO {
+	USB_DK_DEVICE_ID ID;
+	ULONG64 FilterID;
+	ULONG64 Port;
+	ULONG64 Speed;
+	USB_DEVICE_DESCRIPTOR DeviceDescriptor;
+} USB_DK_DEVICE_INFO, *PUSB_DK_DEVICE_INFO;
+
+typedef struct USB_DK_ISO_TRANSFER_RESULT {
+	ULONG64 ActualLength;
+	ULONG64 TransferResult;
+} USB_DK_ISO_TRANSFER_RESULT, *PUSB_DK_ISO_TRANSFER_RESULT;
+
+typedef struct USB_DK_GEN_TRANSFER_RESULT {
+	ULONG64 BytesTransferred;
+	ULONG64 UsbdStatus; // USBD_STATUS code
+} USB_DK_GEN_TRANSFER_RESULT, *PUSB_DK_GEN_TRANSFER_RESULT;
+
+typedef struct USB_DK_TRANSFER_RESULT {
+	USB_DK_GEN_TRANSFER_RESULT GenResult;
+	PVOID64 IsochronousResultsArray; // array of USB_DK_ISO_TRANSFER_RESULT
+} USB_DK_TRANSFER_RESULT, *PUSB_DK_TRANSFER_RESULT;
+
+typedef struct USB_DK_TRANSFER_REQUEST {
+	ULONG64 EndpointAddress;
+	PVOID64 Buffer;
+	ULONG64 BufferLength;
+	ULONG64 TransferType;
+	ULONG64 IsochronousPacketsArraySize;
+	PVOID64 IsochronousPacketsArray;
+	USB_DK_TRANSFER_RESULT Result;
+} USB_DK_TRANSFER_REQUEST, *PUSB_DK_TRANSFER_REQUEST;
+
+struct usbdk_device_priv {
+	USB_DK_DEVICE_INFO info;
+	PUSB_CONFIGURATION_DESCRIPTOR *config_descriptors;
+	HANDLE redirector_handle;
+	HANDLE system_handle;
+	uint8_t active_configuration;
+};
+
+struct winusb_device_priv {
+	bool initialized;
+	bool root_hub;
+	uint8_t active_config;
+	uint8_t depth; // distance to HCD
+	const struct windows_usb_api_backend *apib;
+	char *dev_id;
+	char *path;  // device interface path
+	int sub_api; // for WinUSB-like APIs
+	struct {
+		char *path; // each interface needs a device interface path,
+		const struct windows_usb_api_backend *apib; // an API backend (multiple drivers support),
+		int sub_api;
+		int8_t nb_endpoints; // and a set of endpoint addresses (USB_MAXENDPOINTS)
+		uint8_t *endpoint;
+		bool restricted_functionality;  // indicates if the interface functionality is restricted
+						// by Windows (eg. HID keyboards or mice cannot do R/W)
+	} usb_interface[USB_MAXINTERFACES];
+	struct hid_device_priv *hid;
+	USB_DEVICE_DESCRIPTOR dev_descriptor;
+	PUSB_CONFIGURATION_DESCRIPTOR *config_descriptor; // list of pointers to the cached config descriptors
+};
+
+struct usbdk_device_handle_priv {
+	// Not currently used
+	char dummy;
+};
+
+struct winusb_device_handle_priv {
+	int active_interface;
+	struct {
+		HANDLE dev_handle; // WinUSB needs an extra handle for the file
+		HANDLE api_handle; // used by the API to communicate with the device
+	} interface_handle[USB_MAXINTERFACES];
+	int autoclaim_count[USB_MAXINTERFACES]; // For auto-release
+};
+
+struct usbdk_transfer_priv {
+	USB_DK_TRANSFER_REQUEST request;
+	struct winfd pollable_fd;
+	HANDLE system_handle;
+	PULONG64 IsochronousPacketsArray;
+	PUSB_DK_ISO_TRANSFER_RESULT IsochronousResultsArray;
+};
+
+struct winusb_transfer_priv {
+	struct winfd pollable_fd;
+	HANDLE handle;
+	uint8_t interface_number;
+	uint8_t *hid_buffer; // 1 byte extended data buffer, required for HID
+	uint8_t *hid_dest;   // transfer buffer destination, required for HID
+	size_t hid_expected_size;
+	void *iso_context;
+};
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/os/windows_usbdk.c b/vendor/github.com/karalabe/usb/libusb/libusb/os/windows_usbdk.c
new file mode 100644
index 000000000..fbccbd5cf
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/os/windows_usbdk.c
@@ -0,0 +1,830 @@
+/*
+ * windows UsbDk backend for libusb 1.0
+ * Copyright © 2014 Red Hat, Inc.
+
+ * Authors:
+ * Dmitry Fleytman <dmitry@daynix.com>
+ * Pavel Gurvich <pavel@daynix.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <config.h>
+
+#include <windows.h>
+#include <stdio.h>
+
+#include "libusbi.h"
+#include "windows_common.h"
+#include "windows_nt_common.h"
+#include "windows_usbdk.h"
+
+#if !defined(STATUS_SUCCESS)
+typedef LONG NTSTATUS;
+#define STATUS_SUCCESS			((NTSTATUS)0x00000000L)
+#endif
+
+#if !defined(STATUS_CANCELLED)
+#define STATUS_CANCELLED		((NTSTATUS)0xC0000120L)
+#endif
+
+#if !defined(STATUS_REQUEST_CANCELED)
+#define STATUS_REQUEST_CANCELED		((NTSTATUS)0xC0000703L)
+#endif
+
+#if !defined(USBD_SUCCESS)
+typedef LONG USBD_STATUS;
+#define USBD_SUCCESS(Status)		((USBD_STATUS) (Status) >= 0)
+#define USBD_PENDING(Status)		((ULONG) (Status) >> 30 == 1)
+#define USBD_ERROR(Status)		((USBD_STATUS) (Status) < 0)
+#define USBD_STATUS_STALL_PID		((USBD_STATUS) 0xc0000004)
+#define USBD_STATUS_ENDPOINT_HALTED	((USBD_STATUS) 0xc0000030)
+#define USBD_STATUS_BAD_START_FRAME	((USBD_STATUS) 0xc0000a00)
+#define USBD_STATUS_TIMEOUT		((USBD_STATUS) 0xc0006000)
+#define USBD_STATUS_CANCELED		((USBD_STATUS) 0xc0010000)
+#endif
+
+static inline struct usbdk_device_priv *_usbdk_device_priv(struct libusb_device *dev)
+{
+	return (struct usbdk_device_priv *)dev->os_priv;
+}
+
+static inline struct usbdk_transfer_priv *_usbdk_transfer_priv(struct usbi_transfer *itransfer)
+{
+	return (struct usbdk_transfer_priv *)usbi_transfer_get_os_priv(itransfer);
+}
+
+static struct {
+	HMODULE module;
+
+	USBDK_GET_DEVICES_LIST			GetDevicesList;
+	USBDK_RELEASE_DEVICES_LIST		ReleaseDevicesList;
+	USBDK_START_REDIRECT			StartRedirect;
+	USBDK_STOP_REDIRECT			StopRedirect;
+	USBDK_GET_CONFIGURATION_DESCRIPTOR	GetConfigurationDescriptor;
+	USBDK_RELEASE_CONFIGURATION_DESCRIPTOR	ReleaseConfigurationDescriptor;
+	USBDK_READ_PIPE				ReadPipe;
+	USBDK_WRITE_PIPE			WritePipe;
+	USBDK_ABORT_PIPE			AbortPipe;
+	USBDK_RESET_PIPE			ResetPipe;
+	USBDK_SET_ALTSETTING			SetAltsetting;
+	USBDK_RESET_DEVICE			ResetDevice;
+	USBDK_GET_REDIRECTOR_SYSTEM_HANDLE	GetRedirectorSystemHandle;
+} usbdk_helper;
+
+static FARPROC get_usbdk_proc_addr(struct libusb_context *ctx, LPCSTR api_name)
+{
+	FARPROC api_ptr = GetProcAddress(usbdk_helper.module, api_name);
+
+	if (api_ptr == NULL)
+		usbi_err(ctx, "UsbDkHelper API %s not found: %s", api_name, windows_error_str(0));
+
+	return api_ptr;
+}
+
+static void unload_usbdk_helper_dll(void)
+{
+	if (usbdk_helper.module != NULL) {
+		FreeLibrary(usbdk_helper.module);
+		usbdk_helper.module = NULL;
+	}
+}
+
+static int load_usbdk_helper_dll(struct libusb_context *ctx)
+{
+	usbdk_helper.module = LoadLibraryA("UsbDkHelper");
+	if (usbdk_helper.module == NULL) {
+		usbi_err(ctx, "Failed to load UsbDkHelper.dll: %s", windows_error_str(0));
+		return LIBUSB_ERROR_NOT_FOUND;
+	}
+
+	usbdk_helper.GetDevicesList = (USBDK_GET_DEVICES_LIST)get_usbdk_proc_addr(ctx, "UsbDk_GetDevicesList");
+	if (usbdk_helper.GetDevicesList == NULL)
+		goto error_unload;
+
+	usbdk_helper.ReleaseDevicesList = (USBDK_RELEASE_DEVICES_LIST)get_usbdk_proc_addr(ctx, "UsbDk_ReleaseDevicesList");
+	if (usbdk_helper.ReleaseDevicesList == NULL)
+		goto error_unload;
+
+	usbdk_helper.StartRedirect = (USBDK_START_REDIRECT)get_usbdk_proc_addr(ctx, "UsbDk_StartRedirect");
+	if (usbdk_helper.StartRedirect == NULL)
+		goto error_unload;
+
+	usbdk_helper.StopRedirect = (USBDK_STOP_REDIRECT)get_usbdk_proc_addr(ctx, "UsbDk_StopRedirect");
+	if (usbdk_helper.StopRedirect == NULL)
+		goto error_unload;
+
+	usbdk_helper.GetConfigurationDescriptor = (USBDK_GET_CONFIGURATION_DESCRIPTOR)get_usbdk_proc_addr(ctx, "UsbDk_GetConfigurationDescriptor");
+	if (usbdk_helper.GetConfigurationDescriptor == NULL)
+		goto error_unload;
+
+	usbdk_helper.ReleaseConfigurationDescriptor = (USBDK_RELEASE_CONFIGURATION_DESCRIPTOR)get_usbdk_proc_addr(ctx, "UsbDk_ReleaseConfigurationDescriptor");
+	if (usbdk_helper.ReleaseConfigurationDescriptor == NULL)
+		goto error_unload;
+
+	usbdk_helper.ReadPipe = (USBDK_READ_PIPE)get_usbdk_proc_addr(ctx, "UsbDk_ReadPipe");
+	if (usbdk_helper.ReadPipe == NULL)
+		goto error_unload;
+
+	usbdk_helper.WritePipe = (USBDK_WRITE_PIPE)get_usbdk_proc_addr(ctx, "UsbDk_WritePipe");
+	if (usbdk_helper.WritePipe == NULL)
+		goto error_unload;
+
+	usbdk_helper.AbortPipe = (USBDK_ABORT_PIPE)get_usbdk_proc_addr(ctx, "UsbDk_AbortPipe");
+	if (usbdk_helper.AbortPipe == NULL)
+		goto error_unload;
+
+	usbdk_helper.ResetPipe = (USBDK_RESET_PIPE)get_usbdk_proc_addr(ctx, "UsbDk_ResetPipe");
+	if (usbdk_helper.ResetPipe == NULL)
+		goto error_unload;
+
+	usbdk_helper.SetAltsetting = (USBDK_SET_ALTSETTING)get_usbdk_proc_addr(ctx, "UsbDk_SetAltsetting");
+	if (usbdk_helper.SetAltsetting == NULL)
+		goto error_unload;
+
+	usbdk_helper.ResetDevice = (USBDK_RESET_DEVICE)get_usbdk_proc_addr(ctx, "UsbDk_ResetDevice");
+	if (usbdk_helper.ResetDevice == NULL)
+		goto error_unload;
+
+	usbdk_helper.GetRedirectorSystemHandle = (USBDK_GET_REDIRECTOR_SYSTEM_HANDLE)get_usbdk_proc_addr(ctx, "UsbDk_GetRedirectorSystemHandle");
+	if (usbdk_helper.GetRedirectorSystemHandle == NULL)
+		goto error_unload;
+
+	return LIBUSB_SUCCESS;
+
+error_unload:
+	FreeLibrary(usbdk_helper.module);
+	usbdk_helper.module = NULL;
+	return LIBUSB_ERROR_NOT_FOUND;
+}
+
+static int usbdk_init(struct libusb_context *ctx)
+{
+	SC_HANDLE managerHandle;
+	SC_HANDLE serviceHandle;
+
+	managerHandle = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT);
+	if (managerHandle == NULL) {
+		usbi_warn(ctx, "failed to open service control manager: %s", windows_error_str(0));
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	serviceHandle = OpenServiceA(managerHandle, "UsbDk", GENERIC_READ);
+	CloseServiceHandle(managerHandle);
+
+	if (serviceHandle == NULL) {
+		if (GetLastError() != ERROR_SERVICE_DOES_NOT_EXIST)
+			usbi_warn(ctx, "failed to open UsbDk service: %s", windows_error_str(0));
+		return LIBUSB_ERROR_NOT_FOUND;
+	}
+
+	CloseServiceHandle(serviceHandle);
+
+	return load_usbdk_helper_dll(ctx);
+}
+
+static void usbdk_exit(struct libusb_context *ctx)
+{
+	UNUSED(ctx);
+	unload_usbdk_helper_dll();
+}
+
+static int usbdk_get_session_id_for_device(struct libusb_context *ctx,
+	PUSB_DK_DEVICE_ID id, unsigned long *session_id)
+{
+	char dev_identity[ARRAYSIZE(id->DeviceID) + ARRAYSIZE(id->InstanceID) + 1];
+
+	if (snprintf(dev_identity, sizeof(dev_identity), "%S%S", id->DeviceID, id->InstanceID) == -1) {
+		usbi_warn(ctx, "cannot form device identity", id->DeviceID);
+		return LIBUSB_ERROR_NOT_SUPPORTED;
+	}
+
+	*session_id = htab_hash(dev_identity);
+
+	return LIBUSB_SUCCESS;
+}
+
+static void usbdk_release_config_descriptors(struct usbdk_device_priv *p, uint8_t count)
+{
+	uint8_t i;
+
+	for (i = 0; i < count; i++)
+		usbdk_helper.ReleaseConfigurationDescriptor(p->config_descriptors[i]);
+
+	free(p->config_descriptors);
+	p->config_descriptors = NULL;
+}
+
+static int usbdk_cache_config_descriptors(struct libusb_context *ctx,
+	struct usbdk_device_priv *p, PUSB_DK_DEVICE_INFO info)
+{
+	uint8_t i;
+	USB_DK_CONFIG_DESCRIPTOR_REQUEST Request;
+	Request.ID = info->ID;
+
+	p->config_descriptors = calloc(info->DeviceDescriptor.bNumConfigurations, sizeof(PUSB_CONFIGURATION_DESCRIPTOR));
+	if (p->config_descriptors == NULL) {
+		usbi_err(ctx, "failed to allocate configuration descriptors holder");
+		return LIBUSB_ERROR_NO_MEM;
+	}
+
+	for (i = 0; i < info->DeviceDescriptor.bNumConfigurations; i++) {
+		ULONG Length;
+
+		Request.Index = i;
+		if (!usbdk_helper.GetConfigurationDescriptor(&Request, &p->config_descriptors[i], &Length)) {
+			usbi_err(ctx, "failed to retrieve configuration descriptors");
+			usbdk_release_config_descriptors(p, i);
+			return LIBUSB_ERROR_OTHER;
+		}
+	}
+
+	return LIBUSB_SUCCESS;
+}
+
+static inline int usbdk_device_priv_init(struct libusb_context *ctx, struct libusb_device *dev, PUSB_DK_DEVICE_INFO info)
+{
+	struct usbdk_device_priv *p = _usbdk_device_priv(dev);
+
+	p->info = *info;
+	p->active_configuration = 0;
+
+	return usbdk_cache_config_descriptors(ctx, p, info);
+}
+
+static void usbdk_device_init(libusb_device *dev, PUSB_DK_DEVICE_INFO info)
+{
+	dev->bus_number = (uint8_t)info->FilterID;
+	dev->port_number = (uint8_t)info->Port;
+	dev->parent_dev = NULL;
+
+	// Addresses in libusb are 1-based
+	dev->device_address = (uint8_t)(info->Port + 1);
+
+	dev->num_configurations = info->DeviceDescriptor.bNumConfigurations;
+	memcpy(&dev->device_descriptor, &info->DeviceDescriptor, LIBUSB_DT_DEVICE_SIZE);
+
+	switch (info->Speed) {
+	case LowSpeed:
+		dev->speed = LIBUSB_SPEED_LOW;
+		break;
+	case FullSpeed:
+		dev->speed = LIBUSB_SPEED_FULL;
+		break;
+	case HighSpeed:
+		dev->speed = LIBUSB_SPEED_HIGH;
+		break;
+	case SuperSpeed:
+		dev->speed = LIBUSB_SPEED_SUPER;
+		break;
+	case NoSpeed:
+	default:
+		dev->speed = LIBUSB_SPEED_UNKNOWN;
+		break;
+	}
+}
+
+static int usbdk_get_device_list(struct libusb_context *ctx, struct discovered_devs **_discdevs)
+{
+	int r = LIBUSB_SUCCESS;
+	ULONG i;
+	struct discovered_devs *discdevs = NULL;
+	ULONG dev_number;
+	PUSB_DK_DEVICE_INFO devices;
+
+	if (!usbdk_helper.GetDevicesList(&devices, &dev_number))
+		return LIBUSB_ERROR_OTHER;
+
+	for (i = 0; i < dev_number; i++) {
+		unsigned long session_id;
+		struct libusb_device *dev = NULL;
+
+		if (usbdk_get_session_id_for_device(ctx, &devices[i].ID, &session_id))
+			continue;
+
+		dev = usbi_get_device_by_session_id(ctx, session_id);
+		if (dev == NULL) {
+			dev = usbi_alloc_device(ctx, session_id);
+			if (dev == NULL) {
+				usbi_err(ctx, "failed to allocate a new device structure");
+				continue;
+			}
+
+			usbdk_device_init(dev, &devices[i]);
+			if (usbdk_device_priv_init(ctx, dev, &devices[i]) != LIBUSB_SUCCESS) {
+				libusb_unref_device(dev);
+				continue;
+			}
+		}
+
+		discdevs = discovered_devs_append(*_discdevs, dev);
+		libusb_unref_device(dev);
+		if (!discdevs) {
+			usbi_err(ctx, "cannot append new device to list");
+			r = LIBUSB_ERROR_NO_MEM;
+			goto func_exit;
+		}
+
+		*_discdevs = discdevs;
+	}
+
+func_exit:
+	usbdk_helper.ReleaseDevicesList(devices);
+	return r;
+}
+
+static int usbdk_get_device_descriptor(struct libusb_device *dev, unsigned char *buffer)
+{
+	struct usbdk_device_priv *priv = _usbdk_device_priv(dev);
+
+	memcpy(buffer, &priv->info.DeviceDescriptor, DEVICE_DESC_LENGTH);
+
+	return LIBUSB_SUCCESS;
+}
+
+static int usbdk_get_config_descriptor(struct libusb_device *dev, uint8_t config_index, unsigned char *buffer, size_t len)
+{
+	struct usbdk_device_priv *priv = _usbdk_device_priv(dev);
+	PUSB_CONFIGURATION_DESCRIPTOR config_header;
+	size_t size;
+
+	if (config_index >= dev->num_configurations)
+		return LIBUSB_ERROR_INVALID_PARAM;
+
+	config_header = (PUSB_CONFIGURATION_DESCRIPTOR)priv->config_descriptors[config_index];
+
+	size = min(config_header->wTotalLength, len);
+	memcpy(buffer, config_header, size);
+	return (int)size;
+}
+
+static int usbdk_get_config_descriptor_by_value(struct libusb_device *dev, uint8_t bConfigurationValue,
+	unsigned char **buffer)
+{
+	struct usbdk_device_priv *priv = _usbdk_device_priv(dev);
+	PUSB_CONFIGURATION_DESCRIPTOR config_header;
+	uint8_t index;
+
+	for (index = 0; index < dev->num_configurations; index++) {
+		config_header = priv->config_descriptors[index];
+		if (config_header->bConfigurationValue == bConfigurationValue) {
+			*buffer = (unsigned char *)priv->config_descriptors[index];
+			return (int)config_header->wTotalLength;
+		}
+	}
+
+	return LIBUSB_ERROR_NOT_FOUND;
+}
+
+static int usbdk_get_active_config_descriptor(struct libusb_device *dev, unsigned char *buffer, size_t len)
+{
+	return usbdk_get_config_descriptor(dev, _usbdk_device_priv(dev)->active_configuration,
+			buffer, len);
+}
+
+static int usbdk_open(struct libusb_device_handle *dev_handle)
+{
+	struct usbdk_device_priv *priv = _usbdk_device_priv(dev_handle->dev);
+
+	priv->redirector_handle = usbdk_helper.StartRedirect(&priv->info.ID);
+	if (priv->redirector_handle == INVALID_HANDLE_VALUE) {
+		usbi_err(DEVICE_CTX(dev_handle->dev), "Redirector startup failed");
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	priv->system_handle = usbdk_helper.GetRedirectorSystemHandle(priv->redirector_handle);
+
+	return LIBUSB_SUCCESS;
+}
+
+static void usbdk_close(struct libusb_device_handle *dev_handle)
+{
+	struct usbdk_device_priv *priv = _usbdk_device_priv(dev_handle->dev);
+
+	if (!usbdk_helper.StopRedirect(priv->redirector_handle))
+		usbi_err(HANDLE_CTX(dev_handle), "Redirector shutdown failed");
+}
+
+static int usbdk_get_configuration(struct libusb_device_handle *dev_handle, int *config)
+{
+	*config = _usbdk_device_priv(dev_handle->dev)->active_configuration;
+
+	return LIBUSB_SUCCESS;
+}
+
+static int usbdk_set_configuration(struct libusb_device_handle *dev_handle, int config)
+{
+	UNUSED(dev_handle);
+	UNUSED(config);
+	return LIBUSB_SUCCESS;
+}
+
+static int usbdk_claim_interface(struct libusb_device_handle *dev_handle, int iface)
+{
+	UNUSED(dev_handle);
+	UNUSED(iface);
+	return LIBUSB_SUCCESS;
+}
+
+static int usbdk_set_interface_altsetting(struct libusb_device_handle *dev_handle, int iface, int altsetting)
+{
+	struct libusb_context *ctx = HANDLE_CTX(dev_handle);
+	struct usbdk_device_priv *priv = _usbdk_device_priv(dev_handle->dev);
+
+	if (!usbdk_helper.SetAltsetting(priv->redirector_handle, iface, altsetting)) {
+		usbi_err(ctx, "SetAltsetting failed: %s", windows_error_str(0));
+		return LIBUSB_ERROR_NO_DEVICE;
+	}
+
+	return LIBUSB_SUCCESS;
+}
+
+static int usbdk_release_interface(struct libusb_device_handle *dev_handle, int iface)
+{
+	UNUSED(dev_handle);
+	UNUSED(iface);
+	return LIBUSB_SUCCESS;
+}
+
+static int usbdk_clear_halt(struct libusb_device_handle *dev_handle, unsigned char endpoint)
+{
+	struct libusb_context *ctx = HANDLE_CTX(dev_handle);
+	struct usbdk_device_priv *priv = _usbdk_device_priv(dev_handle->dev);
+
+	if (!usbdk_helper.ResetPipe(priv->redirector_handle, endpoint)) {
+		usbi_err(ctx, "ResetPipe failed: %s", windows_error_str(0));
+		return LIBUSB_ERROR_NO_DEVICE;
+	}
+
+	return LIBUSB_SUCCESS;
+}
+
+static int usbdk_reset_device(struct libusb_device_handle *dev_handle)
+{
+	struct libusb_context *ctx = HANDLE_CTX(dev_handle);
+	struct usbdk_device_priv *priv = _usbdk_device_priv(dev_handle->dev);
+
+	if (!usbdk_helper.ResetDevice(priv->redirector_handle)) {
+		usbi_err(ctx, "ResetDevice failed: %s", windows_error_str(0));
+		return LIBUSB_ERROR_NO_DEVICE;
+	}
+
+	return LIBUSB_SUCCESS;
+}
+
+static void usbdk_destroy_device(struct libusb_device *dev)
+{
+	struct usbdk_device_priv* p = _usbdk_device_priv(dev);
+
+	if (p->config_descriptors != NULL)
+		usbdk_release_config_descriptors(p, p->info.DeviceDescriptor.bNumConfigurations);
+}
+
+static void usbdk_clear_transfer_priv(struct usbi_transfer *itransfer)
+{
+	struct usbdk_transfer_priv *transfer_priv = _usbdk_transfer_priv(itransfer);
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+
+	usbi_close(transfer_priv->pollable_fd.fd);
+	transfer_priv->pollable_fd = INVALID_WINFD;
+	transfer_priv->system_handle = NULL;
+
+	if (transfer->type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS) {
+		safe_free(transfer_priv->IsochronousPacketsArray);
+		safe_free(transfer_priv->IsochronousResultsArray);
+	}
+}
+
+static int usbdk_do_control_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct usbdk_device_priv *priv = _usbdk_device_priv(transfer->dev_handle->dev);
+	struct usbdk_transfer_priv *transfer_priv = _usbdk_transfer_priv(itransfer);
+	struct libusb_context *ctx = TRANSFER_CTX(transfer);
+	OVERLAPPED *overlapped = transfer_priv->pollable_fd.overlapped;
+	TransferResult transResult;
+
+	transfer_priv->request.Buffer = (PVOID64)transfer->buffer;
+	transfer_priv->request.BufferLength = transfer->length;
+	transfer_priv->request.TransferType = ControlTransferType;
+
+	if (transfer->buffer[0] & LIBUSB_ENDPOINT_IN)
+		transResult = usbdk_helper.ReadPipe(priv->redirector_handle, &transfer_priv->request, overlapped);
+	else
+		transResult = usbdk_helper.WritePipe(priv->redirector_handle, &transfer_priv->request, overlapped);
+
+	switch (transResult) {
+	case TransferSuccess:
+		windows_force_sync_completion(overlapped, (ULONG)transfer_priv->request.Result.GenResult.BytesTransferred);
+		break;
+	case TransferSuccessAsync:
+		break;
+	case TransferFailure:
+		usbi_err(ctx, "ControlTransfer failed: %s", windows_error_str(0));
+		return LIBUSB_ERROR_IO;
+	}
+
+	return LIBUSB_SUCCESS;
+}
+
+static int usbdk_do_bulk_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct usbdk_device_priv *priv = _usbdk_device_priv(transfer->dev_handle->dev);
+	struct usbdk_transfer_priv *transfer_priv = _usbdk_transfer_priv(itransfer);
+	struct libusb_context *ctx = TRANSFER_CTX(transfer);
+	OVERLAPPED *overlapped = transfer_priv->pollable_fd.overlapped;
+	TransferResult transferRes;
+
+	transfer_priv->request.Buffer = (PVOID64)transfer->buffer;
+	transfer_priv->request.BufferLength = transfer->length;
+	transfer_priv->request.EndpointAddress = transfer->endpoint;
+
+	switch (transfer->type) {
+	case LIBUSB_TRANSFER_TYPE_BULK:
+		transfer_priv->request.TransferType = BulkTransferType;
+		break;
+	case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+		transfer_priv->request.TransferType = InterruptTransferType;
+		break;
+	default:
+		usbi_err(ctx, "Wrong transfer type (%d) in usbdk_do_bulk_transfer", transfer->type);
+		return LIBUSB_ERROR_INVALID_PARAM;
+	}
+
+	if (IS_XFERIN(transfer))
+		transferRes = usbdk_helper.ReadPipe(priv->redirector_handle, &transfer_priv->request, overlapped);
+	else
+		transferRes = usbdk_helper.WritePipe(priv->redirector_handle, &transfer_priv->request, overlapped);
+
+	switch (transferRes) {
+	case TransferSuccess:
+		windows_force_sync_completion(overlapped, (ULONG)transfer_priv->request.Result.GenResult.BytesTransferred);
+		break;
+	case TransferSuccessAsync:
+		break;
+	case TransferFailure:
+		usbi_err(ctx, "ReadPipe/WritePipe failed: %s", windows_error_str(0));
+		return LIBUSB_ERROR_IO;
+	}
+
+	return LIBUSB_SUCCESS;
+}
+
+static int usbdk_do_iso_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct usbdk_device_priv *priv = _usbdk_device_priv(transfer->dev_handle->dev);
+	struct usbdk_transfer_priv *transfer_priv = _usbdk_transfer_priv(itransfer);
+	struct libusb_context *ctx = TRANSFER_CTX(transfer);
+	OVERLAPPED *overlapped = transfer_priv->pollable_fd.overlapped;
+	TransferResult transferRes;
+	int i;
+
+	transfer_priv->request.Buffer = (PVOID64)transfer->buffer;
+	transfer_priv->request.BufferLength = transfer->length;
+	transfer_priv->request.EndpointAddress = transfer->endpoint;
+	transfer_priv->request.TransferType = IsochronousTransferType;
+	transfer_priv->request.IsochronousPacketsArraySize = transfer->num_iso_packets;
+	transfer_priv->IsochronousPacketsArray = malloc(transfer->num_iso_packets * sizeof(ULONG64));
+	transfer_priv->request.IsochronousPacketsArray = (PVOID64)transfer_priv->IsochronousPacketsArray;
+	if (!transfer_priv->IsochronousPacketsArray) {
+		usbi_err(ctx, "Allocation of IsochronousPacketsArray failed");
+		return LIBUSB_ERROR_NO_MEM;
+	}
+
+	transfer_priv->IsochronousResultsArray = malloc(transfer->num_iso_packets * sizeof(USB_DK_ISO_TRANSFER_RESULT));
+	transfer_priv->request.Result.IsochronousResultsArray = (PVOID64)transfer_priv->IsochronousResultsArray;
+	if (!transfer_priv->IsochronousResultsArray) {
+		usbi_err(ctx, "Allocation of isochronousResultsArray failed");
+		return LIBUSB_ERROR_NO_MEM;
+	}
+
+	for (i = 0; i < transfer->num_iso_packets; i++)
+		transfer_priv->IsochronousPacketsArray[i] = transfer->iso_packet_desc[i].length;
+
+	if (IS_XFERIN(transfer))
+		transferRes = usbdk_helper.ReadPipe(priv->redirector_handle, &transfer_priv->request, overlapped);
+	else
+		transferRes = usbdk_helper.WritePipe(priv->redirector_handle, &transfer_priv->request, overlapped);
+
+	switch (transferRes) {
+	case TransferSuccess:
+		windows_force_sync_completion(overlapped, (ULONG)transfer_priv->request.Result.GenResult.BytesTransferred);
+		break;
+	case TransferSuccessAsync:
+		break;
+	case TransferFailure:
+		return LIBUSB_ERROR_IO;
+	}
+
+	return LIBUSB_SUCCESS;
+}
+
+static int usbdk_do_submit_transfer(struct usbi_transfer *itransfer,
+	short events, int (*transfer_fn)(struct usbi_transfer *))
+{
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct libusb_context *ctx = TRANSFER_CTX(transfer);
+	struct usbdk_device_priv *priv = _usbdk_device_priv(transfer->dev_handle->dev);
+	struct usbdk_transfer_priv *transfer_priv = _usbdk_transfer_priv(itransfer);
+	struct winfd wfd;
+	int r;
+
+	wfd = usbi_create_fd();
+	if (wfd.fd < 0)
+		return LIBUSB_ERROR_NO_MEM;
+
+	r = usbi_add_pollfd(ctx, wfd.fd, events);
+	if (r) {
+		usbi_close(wfd.fd);
+		return r;
+	}
+
+	// Use transfer_priv to store data needed for async polling
+	transfer_priv->pollable_fd = wfd;
+	transfer_priv->system_handle = priv->system_handle;
+
+	r = transfer_fn(itransfer);
+	if (r != LIBUSB_SUCCESS) {
+		usbi_remove_pollfd(ctx, wfd.fd);
+		usbdk_clear_transfer_priv(itransfer);
+		return r;
+	}
+
+	return LIBUSB_SUCCESS;
+}
+
+static int usbdk_submit_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	int (*transfer_fn)(struct usbi_transfer *);
+	short events;
+
+	switch (transfer->type) {
+	case LIBUSB_TRANSFER_TYPE_CONTROL:
+		events = (transfer->buffer[0] & LIBUSB_ENDPOINT_IN) ? POLLIN : POLLOUT;
+		transfer_fn = usbdk_do_control_transfer;
+		break;
+	case LIBUSB_TRANSFER_TYPE_BULK:
+	case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+		if (IS_XFEROUT(transfer) && (transfer->flags & LIBUSB_TRANSFER_ADD_ZERO_PACKET))
+			return LIBUSB_ERROR_NOT_SUPPORTED; //TODO: Check whether we can support this in UsbDk
+		events = IS_XFERIN(transfer) ? POLLIN : POLLOUT;
+		transfer_fn = usbdk_do_bulk_transfer;
+		break;
+	case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+		events = IS_XFERIN(transfer) ? POLLIN : POLLOUT;
+		transfer_fn = usbdk_do_iso_transfer;
+		break;
+	default:
+		usbi_err(TRANSFER_CTX(transfer), "unknown endpoint type %d", transfer->type);
+		return LIBUSB_ERROR_INVALID_PARAM;
+	}
+
+	return usbdk_do_submit_transfer(itransfer, events, transfer_fn);
+}
+
+static int usbdk_abort_transfers(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct libusb_context *ctx = TRANSFER_CTX(transfer);
+	struct usbdk_device_priv *priv = _usbdk_device_priv(transfer->dev_handle->dev);
+	struct usbdk_transfer_priv *transfer_priv = _usbdk_transfer_priv(itransfer);
+	struct winfd *pollable_fd = &transfer_priv->pollable_fd;
+
+	if (pCancelIoEx != NULL) {
+		// Use CancelIoEx if available to cancel just a single transfer
+		if (!pCancelIoEx(priv->system_handle, pollable_fd->overlapped)) {
+			usbi_err(ctx, "CancelIoEx failed: %s", windows_error_str(0));
+			return LIBUSB_ERROR_NO_DEVICE;
+		}
+	} else {
+		if (!usbdk_helper.AbortPipe(priv->redirector_handle, transfer->endpoint)) {
+			usbi_err(ctx, "AbortPipe failed: %s", windows_error_str(0));
+			return LIBUSB_ERROR_NO_DEVICE;
+		}
+	}
+
+	return LIBUSB_SUCCESS;
+}
+
+static int usbdk_cancel_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+
+	switch (transfer->type) {
+	case LIBUSB_TRANSFER_TYPE_CONTROL:
+		// Control transfers cancelled by IoCancelXXX() API
+		// No special treatment needed
+		return LIBUSB_SUCCESS;
+	case LIBUSB_TRANSFER_TYPE_BULK:
+	case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+	case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+		return usbdk_abort_transfers(itransfer);
+	default:
+		usbi_err(ITRANSFER_CTX(itransfer), "unknown endpoint type %d", transfer->type);
+		return LIBUSB_ERROR_INVALID_PARAM;
+	}
+}
+
+static int usbdk_copy_transfer_data(struct usbi_transfer *itransfer, uint32_t io_size)
+{
+	itransfer->transferred += io_size;
+	return LIBUSB_TRANSFER_COMPLETED;
+}
+
+static int usbdk_get_transfer_fd(struct usbi_transfer *itransfer)
+{
+	struct usbdk_transfer_priv *transfer_priv = _usbdk_transfer_priv(itransfer);
+	return transfer_priv->pollable_fd.fd;
+}
+
+static DWORD usbdk_translate_usbd_status(USBD_STATUS UsbdStatus)
+{
+	if (USBD_SUCCESS(UsbdStatus))
+		return NO_ERROR;
+
+	switch (UsbdStatus) {
+	case USBD_STATUS_TIMEOUT:
+		return ERROR_SEM_TIMEOUT;
+	case USBD_STATUS_CANCELED:
+		return ERROR_OPERATION_ABORTED;
+	default:
+		return ERROR_GEN_FAILURE;
+	}
+}
+
+static void usbdk_get_overlapped_result(struct usbi_transfer *itransfer, DWORD *io_result, DWORD *io_size)
+{
+	struct usbdk_transfer_priv *transfer_priv = _usbdk_transfer_priv(itransfer);
+	struct winfd *pollable_fd = &transfer_priv->pollable_fd;
+
+	if (HasOverlappedIoCompletedSync(pollable_fd->overlapped) // Handle async requests that completed synchronously first
+			|| GetOverlappedResult(transfer_priv->system_handle, pollable_fd->overlapped, io_size, FALSE)) { // Regular async overlapped
+		struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+
+		if (transfer->type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS) {
+			ULONG64 i;
+			for (i = 0; i < transfer_priv->request.IsochronousPacketsArraySize; i++) {
+				struct libusb_iso_packet_descriptor *lib_desc = &transfer->iso_packet_desc[i];
+
+				switch (transfer_priv->IsochronousResultsArray[i].TransferResult) {
+				case STATUS_SUCCESS:
+				case STATUS_CANCELLED:
+				case STATUS_REQUEST_CANCELED:
+					lib_desc->status = LIBUSB_TRANSFER_COMPLETED; // == ERROR_SUCCESS
+					break;
+				default:
+					lib_desc->status = LIBUSB_TRANSFER_ERROR; // ERROR_UNKNOWN_EXCEPTION;
+					break;
+				}
+
+				lib_desc->actual_length = (unsigned int)transfer_priv->IsochronousResultsArray[i].ActualLength;
+			}
+		}
+
+		*io_size = (DWORD)transfer_priv->request.Result.GenResult.BytesTransferred;
+		*io_result = usbdk_translate_usbd_status((USBD_STATUS)transfer_priv->request.Result.GenResult.UsbdStatus);
+	} else {
+		*io_result = GetLastError();
+	}
+}
+
+const struct windows_backend usbdk_backend = {
+	usbdk_init,
+	usbdk_exit,
+	usbdk_get_device_list,
+	usbdk_open,
+	usbdk_close,
+	usbdk_get_device_descriptor,
+	usbdk_get_active_config_descriptor,
+	usbdk_get_config_descriptor,
+	usbdk_get_config_descriptor_by_value,
+	usbdk_get_configuration,
+	usbdk_set_configuration,
+	usbdk_claim_interface,
+	usbdk_release_interface,
+	usbdk_set_interface_altsetting,
+	usbdk_clear_halt,
+	usbdk_reset_device,
+	usbdk_destroy_device,
+	usbdk_submit_transfer,
+	usbdk_cancel_transfer,
+	usbdk_clear_transfer_priv,
+	usbdk_copy_transfer_data,
+	usbdk_get_transfer_fd,
+	usbdk_get_overlapped_result,
+};
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/os/windows_usbdk.h b/vendor/github.com/karalabe/usb/libusb/libusb/os/windows_usbdk.h
new file mode 100644
index 000000000..77660ae97
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/os/windows_usbdk.h
@@ -0,0 +1,103 @@
+/*
+* windows UsbDk backend for libusb 1.0
+* Copyright © 2014 Red Hat, Inc.
+
+* Authors:
+* Dmitry Fleytman <dmitry@daynix.com>
+* Pavel Gurvich <pavel@daynix.com>
+*
+* This library is free software; you can redistribute it and/or
+* modify it under the terms of the GNU Lesser General Public
+* License as published by the Free Software Foundation; either
+* version 2.1 of the License, or (at your option) any later version.
+*
+* This library is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public
+* License along with this library; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+*/
+
+#pragma once
+
+#include "windows_nt_common.h"
+
+typedef struct USB_DK_CONFIG_DESCRIPTOR_REQUEST {
+	USB_DK_DEVICE_ID ID;
+	ULONG64 Index;
+} USB_DK_CONFIG_DESCRIPTOR_REQUEST, *PUSB_DK_CONFIG_DESCRIPTOR_REQUEST;
+
+typedef enum {
+	TransferFailure = 0,
+	TransferSuccess,
+	TransferSuccessAsync
+} TransferResult;
+
+typedef enum {
+	NoSpeed = 0,
+	LowSpeed,
+	FullSpeed,
+	HighSpeed,
+	SuperSpeed
+} USB_DK_DEVICE_SPEED;
+
+typedef enum {
+	ControlTransferType,
+	BulkTransferType,
+	InterruptTransferType,
+	IsochronousTransferType
+} USB_DK_TRANSFER_TYPE;
+
+typedef BOOL (__cdecl *USBDK_GET_DEVICES_LIST)(
+	PUSB_DK_DEVICE_INFO *DeviceInfo,
+	PULONG DeviceNumber
+);
+typedef void (__cdecl *USBDK_RELEASE_DEVICES_LIST)(
+	PUSB_DK_DEVICE_INFO DeviceInfo
+);
+typedef HANDLE (__cdecl *USBDK_START_REDIRECT)(
+	PUSB_DK_DEVICE_ID DeviceId
+);
+typedef BOOL (__cdecl *USBDK_STOP_REDIRECT)(
+	HANDLE DeviceHandle
+);
+typedef BOOL (__cdecl *USBDK_GET_CONFIGURATION_DESCRIPTOR)(
+	PUSB_DK_CONFIG_DESCRIPTOR_REQUEST Request,
+	PUSB_CONFIGURATION_DESCRIPTOR *Descriptor,
+	PULONG Length
+);
+typedef void (__cdecl *USBDK_RELEASE_CONFIGURATION_DESCRIPTOR)(
+	PUSB_CONFIGURATION_DESCRIPTOR Descriptor
+);
+typedef TransferResult (__cdecl *USBDK_WRITE_PIPE)(
+	HANDLE DeviceHandle,
+	PUSB_DK_TRANSFER_REQUEST Request,
+	LPOVERLAPPED lpOverlapped
+);
+typedef TransferResult (__cdecl *USBDK_READ_PIPE)(
+	HANDLE DeviceHandle,
+	PUSB_DK_TRANSFER_REQUEST Request,
+	LPOVERLAPPED lpOverlapped
+);
+typedef BOOL (__cdecl *USBDK_ABORT_PIPE)(
+	HANDLE DeviceHandle,
+	ULONG64 PipeAddress
+);
+typedef BOOL (__cdecl *USBDK_RESET_PIPE)(
+	HANDLE DeviceHandle,
+	ULONG64 PipeAddress
+);
+typedef BOOL (__cdecl *USBDK_SET_ALTSETTING)(
+	HANDLE DeviceHandle,
+	ULONG64 InterfaceIdx,
+	ULONG64 AltSettingIdx
+);
+typedef BOOL (__cdecl *USBDK_RESET_DEVICE)(
+	HANDLE DeviceHandle
+);
+typedef HANDLE (__cdecl *USBDK_GET_REDIRECTOR_SYSTEM_HANDLE)(
+	HANDLE DeviceHandle
+);
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/os/windows_winusb.c b/vendor/github.com/karalabe/usb/libusb/libusb/os/windows_winusb.c
new file mode 100644
index 000000000..ce1b55cd6
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/os/windows_winusb.c
@@ -0,0 +1,3009 @@
+/*
+ * windows backend for libusb 1.0
+ * Copyright © 2009-2012 Pete Batard <pete@akeo.ie>
+ * Copyright © 2016-2018 Chris Dickens <christopher.a.dickens@gmail.com>
+ * With contributions from Michael Plante, Orin Eman et al.
+ * Parts of this code adapted from libusb-win32-v1 by Stephan Meyer
+ * HID Reports IOCTLs inspired from HIDAPI by Alan Ott, Signal 11 Software
+ * Hash table functions adapted from glibc, by Ulrich Drepper et al.
+ * Major code testing contribution by Xiaofan Chen
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <config.h>
+
+#include <windows.h>
+#include <setupapi.h>
+#include <ctype.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <process.h>
+#include <stdio.h>
+#include <inttypes.h>
+#include <objbase.h>
+#include <winioctl.h>
+
+#include "libusbi.h"
+#include "windows_common.h"
+#include "windows_nt_common.h"
+#include "windows_winusb.h"
+
+// Unfuckup the 'inferface' keyword
+#undef interface
+
+#define HANDLE_VALID(h) (((h) != NULL) && ((h) != INVALID_HANDLE_VALUE))
+
+// The 2 macros below are used in conjunction with safe loops.
+#define LOOP_CHECK(fcall)			\
+	{					\
+		r = fcall;			\
+		if (r != LIBUSB_SUCCESS)	\
+			continue;		\
+	}
+#define LOOP_BREAK(err)				\
+	{					\
+		r = err;			\
+		continue;			\
+	}
+
+// WinUSB-like API prototypes
+static int winusbx_init(struct libusb_context *ctx);
+static void winusbx_exit(void);
+static int winusbx_open(int sub_api, struct libusb_device_handle *dev_handle);
+static void winusbx_close(int sub_api, struct libusb_device_handle *dev_handle);
+static int winusbx_configure_endpoints(int sub_api, struct libusb_device_handle *dev_handle, int iface);
+static int winusbx_claim_interface(int sub_api, struct libusb_device_handle *dev_handle, int iface);
+static int winusbx_release_interface(int sub_api, struct libusb_device_handle *dev_handle, int iface);
+static int winusbx_submit_control_transfer(int sub_api, struct usbi_transfer *itransfer);
+static int winusbx_set_interface_altsetting(int sub_api, struct libusb_device_handle *dev_handle, int iface, int altsetting);
+static int winusbx_submit_iso_transfer(int sub_api, struct usbi_transfer *itransfer);
+static int winusbx_submit_bulk_transfer(int sub_api, struct usbi_transfer *itransfer);
+static int winusbx_clear_halt(int sub_api, struct libusb_device_handle *dev_handle, unsigned char endpoint);
+static int winusbx_abort_transfers(int sub_api, struct usbi_transfer *itransfer);
+static int winusbx_abort_control(int sub_api, struct usbi_transfer *itransfer);
+static int winusbx_reset_device(int sub_api, struct libusb_device_handle *dev_handle);
+static int winusbx_copy_transfer_data(int sub_api, struct usbi_transfer *itransfer, uint32_t io_size);
+// Composite API prototypes
+static int composite_open(int sub_api, struct libusb_device_handle *dev_handle);
+static void composite_close(int sub_api, struct libusb_device_handle *dev_handle);
+static int composite_claim_interface(int sub_api, struct libusb_device_handle *dev_handle, int iface);
+static int composite_set_interface_altsetting(int sub_api, struct libusb_device_handle *dev_handle, int iface, int altsetting);
+static int composite_release_interface(int sub_api, struct libusb_device_handle *dev_handle, int iface);
+static int composite_submit_control_transfer(int sub_api, struct usbi_transfer *itransfer);
+static int composite_submit_bulk_transfer(int sub_api, struct usbi_transfer *itransfer);
+static int composite_submit_iso_transfer(int sub_api, struct usbi_transfer *itransfer);
+static int composite_clear_halt(int sub_api, struct libusb_device_handle *dev_handle, unsigned char endpoint);
+static int composite_abort_transfers(int sub_api, struct usbi_transfer *itransfer);
+static int composite_abort_control(int sub_api, struct usbi_transfer *itransfer);
+static int composite_reset_device(int sub_api, struct libusb_device_handle *dev_handle);
+static int composite_copy_transfer_data(int sub_api, struct usbi_transfer *itransfer, uint32_t io_size);
+
+static usbi_mutex_t autoclaim_lock;
+
+// API globals
+static HMODULE WinUSBX_handle = NULL;
+static struct winusb_interface WinUSBX[SUB_API_MAX];
+#define CHECK_WINUSBX_AVAILABLE(sub_api)		\
+	do {						\
+		if (sub_api == SUB_API_NOTSET)		\
+			sub_api = priv->sub_api;	\
+		if (!WinUSBX[sub_api].initialized) 	\
+			return LIBUSB_ERROR_ACCESS;	\
+	} while (0)
+
+static bool api_hid_available = false;
+#define CHECK_HID_AVAILABLE				\
+	do {						\
+		if (!api_hid_available)			\
+			return LIBUSB_ERROR_ACCESS;	\
+	} while (0)
+
+#if defined(ENABLE_LOGGING)
+static const char *guid_to_string(const GUID *guid)
+{
+	static char guid_string[MAX_GUID_STRING_LENGTH];
+
+	if (guid == NULL)
+		return "";
+
+	sprintf(guid_string, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
+		(unsigned int)guid->Data1, guid->Data2, guid->Data3,
+		guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
+		guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7]);
+
+	return guid_string;
+}
+#endif
+
+/*
+ * Sanitize Microsoft's paths: convert to uppercase, add prefix and fix backslashes.
+ * Return an allocated sanitized string or NULL on error.
+ */
+static char *sanitize_path(const char *path)
+{
+	const char root_prefix[] = {'\\', '\\', '.', '\\'};
+	size_t j, size;
+	char *ret_path;
+	size_t add_root = 0;
+
+	if (path == NULL)
+		return NULL;
+
+	size = strlen(path) + 1;
+
+	// Microsoft indiscriminately uses '\\?\', '\\.\', '##?#" or "##.#" for root prefixes.
+	if (!((size > 3) && (((path[0] == '\\') && (path[1] == '\\') && (path[3] == '\\'))
+			|| ((path[0] == '#') && (path[1] == '#') && (path[3] == '#'))))) {
+		add_root = sizeof(root_prefix);
+		size += add_root;
+	}
+
+	ret_path = malloc(size);
+	if (ret_path == NULL)
+		return NULL;
+
+	strcpy(&ret_path[add_root], path);
+
+	// Ensure consistency with root prefix
+	memcpy(ret_path, root_prefix, sizeof(root_prefix));
+
+	// Same goes for '\' and '#' after the root prefix. Ensure '#' is used
+	for (j = sizeof(root_prefix); j < size; j++) {
+		ret_path[j] = (char)toupper((int)ret_path[j]); // Fix case too
+		if (ret_path[j] == '\\')
+			ret_path[j] = '#';
+	}
+
+	return ret_path;
+}
+
+/*
+ * Cfgmgr32, AdvAPI32, OLE32 and SetupAPI DLL functions
+ */
+static BOOL init_dlls(void)
+{
+	DLL_GET_HANDLE(Cfgmgr32);
+	DLL_LOAD_FUNC(Cfgmgr32, CM_Get_Parent, TRUE);
+	DLL_LOAD_FUNC(Cfgmgr32, CM_Get_Child, TRUE);
+
+	// Prefixed to avoid conflict with header files
+	DLL_GET_HANDLE(AdvAPI32);
+	DLL_LOAD_FUNC_PREFIXED(AdvAPI32, p, RegQueryValueExW, TRUE);
+	DLL_LOAD_FUNC_PREFIXED(AdvAPI32, p, RegCloseKey, TRUE);
+
+	DLL_GET_HANDLE(OLE32);
+	DLL_LOAD_FUNC_PREFIXED(OLE32, p, IIDFromString, TRUE);
+
+	DLL_GET_HANDLE(SetupAPI);
+	DLL_LOAD_FUNC_PREFIXED(SetupAPI, p, SetupDiGetClassDevsA, TRUE);
+	DLL_LOAD_FUNC_PREFIXED(SetupAPI, p, SetupDiEnumDeviceInfo, TRUE);
+	DLL_LOAD_FUNC_PREFIXED(SetupAPI, p, SetupDiEnumDeviceInterfaces, TRUE);
+	DLL_LOAD_FUNC_PREFIXED(SetupAPI, p, SetupDiGetDeviceInstanceIdA, TRUE);
+	DLL_LOAD_FUNC_PREFIXED(SetupAPI, p, SetupDiGetDeviceInterfaceDetailA, TRUE);
+	DLL_LOAD_FUNC_PREFIXED(SetupAPI, p, SetupDiGetDeviceRegistryPropertyA, TRUE);
+	DLL_LOAD_FUNC_PREFIXED(SetupAPI, p, SetupDiDestroyDeviceInfoList, TRUE);
+	DLL_LOAD_FUNC_PREFIXED(SetupAPI, p, SetupDiOpenDevRegKey, TRUE);
+	DLL_LOAD_FUNC_PREFIXED(SetupAPI, p, SetupDiOpenDeviceInterfaceRegKey, TRUE);
+
+	return TRUE;
+}
+
+static void exit_dlls(void)
+{
+	DLL_FREE_HANDLE(Cfgmgr32);
+	DLL_FREE_HANDLE(AdvAPI32);
+	DLL_FREE_HANDLE(OLE32);
+	DLL_FREE_HANDLE(SetupAPI);
+}
+
+/*
+ * enumerate interfaces for the whole USB class
+ *
+ * Parameters:
+ * dev_info: a pointer to a dev_info list
+ * dev_info_data: a pointer to an SP_DEVINFO_DATA to be filled (or NULL if not needed)
+ * enumerator: the generic USB class for which to retrieve interface details
+ * index: zero based index of the interface in the device info list
+ *
+ * Note: it is the responsibility of the caller to free the DEVICE_INTERFACE_DETAIL_DATA
+ * structure returned and call this function repeatedly using the same guid (with an
+ * incremented index starting at zero) until all interfaces have been returned.
+ */
+static bool get_devinfo_data(struct libusb_context *ctx,
+	HDEVINFO *dev_info, SP_DEVINFO_DATA *dev_info_data, const char *enumerator, unsigned _index)
+{
+	if (_index == 0) {
+		*dev_info = pSetupDiGetClassDevsA(NULL, enumerator, NULL, DIGCF_PRESENT|DIGCF_ALLCLASSES);
+		if (*dev_info == INVALID_HANDLE_VALUE) {
+			usbi_err(ctx, "could not obtain device info set for PnP enumerator '%s': %s",
+				enumerator, windows_error_str(0));
+			return false;
+		}
+	}
+
+	dev_info_data->cbSize = sizeof(SP_DEVINFO_DATA);
+	if (!pSetupDiEnumDeviceInfo(*dev_info, _index, dev_info_data)) {
+		if (GetLastError() != ERROR_NO_MORE_ITEMS)
+			usbi_err(ctx, "could not obtain device info data for PnP enumerator '%s' index %u: %s",
+				enumerator, _index, windows_error_str(0));
+
+		pSetupDiDestroyDeviceInfoList(*dev_info);
+		*dev_info = INVALID_HANDLE_VALUE;
+		return false;
+	}
+	return true;
+}
+
+/*
+ * enumerate interfaces for a specific GUID
+ *
+ * Parameters:
+ * dev_info: a pointer to a dev_info list
+ * dev_info_data: a pointer to an SP_DEVINFO_DATA to be filled (or NULL if not needed)
+ * guid: the GUID for which to retrieve interface details
+ * index: zero based index of the interface in the device info list
+ *
+ * Note: it is the responsibility of the caller to free the DEVICE_INTERFACE_DETAIL_DATA
+ * structure returned and call this function repeatedly using the same guid (with an
+ * incremented index starting at zero) until all interfaces have been returned.
+ */
+static int get_interface_details(struct libusb_context *ctx, HDEVINFO dev_info,
+	PSP_DEVINFO_DATA dev_info_data, LPCGUID guid, DWORD *_index, char **dev_interface_path)
+{
+	SP_DEVICE_INTERFACE_DATA dev_interface_data;
+	PSP_DEVICE_INTERFACE_DETAIL_DATA_A dev_interface_details;
+	DWORD size;
+
+	dev_info_data->cbSize = sizeof(SP_DEVINFO_DATA);
+	dev_interface_data.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
+	for (;;) {
+		if (!pSetupDiEnumDeviceInfo(dev_info, *_index, dev_info_data)) {
+			if (GetLastError() != ERROR_NO_MORE_ITEMS) {
+				usbi_err(ctx, "Could not obtain device info data for %s index %u: %s",
+					guid_to_string(guid), *_index, windows_error_str(0));
+				return LIBUSB_ERROR_OTHER;
+			}
+
+			// No more devices
+			return LIBUSB_SUCCESS;
+		}
+
+		// Always advance the index for the next iteration
+		(*_index)++;
+
+		if (pSetupDiEnumDeviceInterfaces(dev_info, dev_info_data, guid, 0, &dev_interface_data))
+			break;
+
+		if (GetLastError() != ERROR_NO_MORE_ITEMS) {
+			usbi_err(ctx, "Could not obtain interface data for %s devInst %X: %s",
+				guid_to_string(guid), dev_info_data->DevInst, windows_error_str(0));
+			return LIBUSB_ERROR_OTHER;
+		}
+
+		// Device does not have an interface matching this GUID, skip
+	}
+
+	// Read interface data (dummy + actual) to access the device path
+	if (!pSetupDiGetDeviceInterfaceDetailA(dev_info, &dev_interface_data, NULL, 0, &size, NULL)) {
+		// The dummy call should fail with ERROR_INSUFFICIENT_BUFFER
+		if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
+			usbi_err(ctx, "could not access interface data (dummy) for %s devInst %X: %s",
+				guid_to_string(guid), dev_info_data->DevInst, windows_error_str(0));
+			return LIBUSB_ERROR_OTHER;
+		}
+	} else {
+		usbi_err(ctx, "program assertion failed - http://msdn.microsoft.com/en-us/library/ms792901.aspx is wrong");
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	dev_interface_details = malloc(size);
+	if (dev_interface_details == NULL) {
+		usbi_err(ctx, "could not allocate interface data for %s devInst %X",
+			guid_to_string(guid), dev_info_data->DevInst);
+		return LIBUSB_ERROR_NO_MEM;
+	}
+
+	dev_interface_details->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_A);
+	if (!pSetupDiGetDeviceInterfaceDetailA(dev_info, &dev_interface_data,
+		dev_interface_details, size, NULL, NULL)) {
+		usbi_err(ctx, "could not access interface data (actual) for %s devInst %X: %s",
+			guid_to_string(guid), dev_info_data->DevInst, windows_error_str(0));
+		free(dev_interface_details);
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	*dev_interface_path = sanitize_path(dev_interface_details->DevicePath);
+	free(dev_interface_details);
+
+	if (*dev_interface_path == NULL) {
+		usbi_err(ctx, "could not allocate interface path for %s devInst %X",
+			guid_to_string(guid), dev_info_data->DevInst);
+		return LIBUSB_ERROR_NO_MEM;
+	}
+
+	return LIBUSB_SUCCESS;
+}
+
+/* For libusb0 filter */
+static SP_DEVICE_INTERFACE_DETAIL_DATA_A *get_interface_details_filter(struct libusb_context *ctx,
+	HDEVINFO *dev_info, SP_DEVINFO_DATA *dev_info_data, const GUID *guid, unsigned _index, char *filter_path)
+{
+	SP_DEVICE_INTERFACE_DATA dev_interface_data;
+	SP_DEVICE_INTERFACE_DETAIL_DATA_A *dev_interface_details;
+	DWORD size;
+
+	if (_index == 0)
+		*dev_info = pSetupDiGetClassDevsA(guid, NULL, NULL, DIGCF_PRESENT|DIGCF_DEVICEINTERFACE);
+
+	if (dev_info_data != NULL) {
+		dev_info_data->cbSize = sizeof(SP_DEVINFO_DATA);
+		if (!pSetupDiEnumDeviceInfo(*dev_info, _index, dev_info_data)) {
+			if (GetLastError() != ERROR_NO_MORE_ITEMS)
+				usbi_err(ctx, "Could not obtain device info data for index %u: %s",
+					_index, windows_error_str(0));
+
+			pSetupDiDestroyDeviceInfoList(*dev_info);
+			*dev_info = INVALID_HANDLE_VALUE;
+			return NULL;
+		}
+	}
+
+	dev_interface_data.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
+	if (!pSetupDiEnumDeviceInterfaces(*dev_info, NULL, guid, _index, &dev_interface_data)) {
+		if (GetLastError() != ERROR_NO_MORE_ITEMS)
+			usbi_err(ctx, "Could not obtain interface data for index %u: %s",
+				_index, windows_error_str(0));
+
+		pSetupDiDestroyDeviceInfoList(*dev_info);
+		*dev_info = INVALID_HANDLE_VALUE;
+		return NULL;
+	}
+
+	// Read interface data (dummy + actual) to access the device path
+	if (!pSetupDiGetDeviceInterfaceDetailA(*dev_info, &dev_interface_data, NULL, 0, &size, NULL)) {
+		// The dummy call should fail with ERROR_INSUFFICIENT_BUFFER
+		if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
+			usbi_err(ctx, "could not access interface data (dummy) for index %u: %s",
+				_index, windows_error_str(0));
+			goto err_exit;
+		}
+	} else {
+		usbi_err(ctx, "program assertion failed - http://msdn.microsoft.com/en-us/library/ms792901.aspx is wrong.");
+		goto err_exit;
+	}
+
+	dev_interface_details = calloc(1, size);
+	if (dev_interface_details == NULL) {
+		usbi_err(ctx, "could not allocate interface data for index %u.", _index);
+		goto err_exit;
+	}
+
+	dev_interface_details->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_A);
+	if (!pSetupDiGetDeviceInterfaceDetailA(*dev_info, &dev_interface_data, dev_interface_details, size, &size, NULL))
+		usbi_err(ctx, "could not access interface data (actual) for index %u: %s",
+			_index, windows_error_str(0));
+
+	// [trobinso] lookup the libusb0 symbolic index.
+	if (dev_interface_details) {
+		HKEY hkey_device_interface = pSetupDiOpenDeviceInterfaceRegKey(*dev_info, &dev_interface_data, 0, KEY_READ);
+		if (hkey_device_interface != INVALID_HANDLE_VALUE) {
+			DWORD libusb0_symboliclink_index = 0;
+			DWORD value_length = sizeof(DWORD);
+			DWORD value_type = 0;
+			LONG status;
+
+			status = pRegQueryValueExW(hkey_device_interface, L"LUsb0", NULL, &value_type,
+				(LPBYTE)&libusb0_symboliclink_index, &value_length);
+			if (status == ERROR_SUCCESS) {
+				if (libusb0_symboliclink_index < 256) {
+					// libusb0.sys is connected to this device instance.
+					// If the the device interface guid is {F9F3FF14-AE21-48A0-8A25-8011A7A931D9} then it's a filter.
+					sprintf(filter_path, "\\\\.\\libusb0-%04u", (unsigned int)libusb0_symboliclink_index);
+					usbi_dbg("assigned libusb0 symbolic link %s", filter_path);
+				} else {
+					// libusb0.sys was connected to this device instance at one time; but not anymore.
+				}
+			}
+			pRegCloseKey(hkey_device_interface);
+		}
+	}
+
+	return dev_interface_details;
+
+err_exit:
+	pSetupDiDestroyDeviceInfoList(*dev_info);
+	*dev_info = INVALID_HANDLE_VALUE;
+	return NULL;
+}
+
+/*
+ * Returns the first known ancestor of a device
+ */
+static struct libusb_device *get_ancestor(struct libusb_context *ctx,
+	DEVINST devinst, PDEVINST _parent_devinst)
+{
+	struct libusb_device *dev = NULL;
+	DEVINST parent_devinst;
+
+	while (dev == NULL) {
+		if (CM_Get_Parent(&parent_devinst, devinst, 0) != CR_SUCCESS)
+			break;
+		devinst = parent_devinst;
+		dev = usbi_get_device_by_session_id(ctx, (unsigned long)devinst);
+	}
+
+	if ((dev != NULL) && (_parent_devinst != NULL))
+		*_parent_devinst = devinst;
+
+	return dev;
+}
+
+/*
+ * Determine which interface the given endpoint address belongs to
+ */
+static int get_interface_by_endpoint(struct libusb_config_descriptor *conf_desc, uint8_t ep)
+{
+	const struct libusb_interface *intf;
+	const struct libusb_interface_descriptor *intf_desc;
+	int i, j, k;
+
+	for (i = 0; i < conf_desc->bNumInterfaces; i++) {
+		intf = &conf_desc->interface[i];
+		for (j = 0; j < intf->num_altsetting; j++) {
+			intf_desc = &intf->altsetting[j];
+			for (k = 0; k < intf_desc->bNumEndpoints; k++) {
+				if (intf_desc->endpoint[k].bEndpointAddress == ep) {
+					usbi_dbg("found endpoint %02X on interface %d", intf_desc->bInterfaceNumber, i);
+					return intf_desc->bInterfaceNumber;
+				}
+			}
+		}
+	}
+
+	usbi_dbg("endpoint %02X not found on any interface", ep);
+	return LIBUSB_ERROR_NOT_FOUND;
+}
+
+/*
+ * Populate the endpoints addresses of the device_priv interface helper structs
+ */
+static int windows_assign_endpoints(struct libusb_device_handle *dev_handle, int iface, int altsetting)
+{
+	int i, r;
+	struct winusb_device_priv *priv = _device_priv(dev_handle->dev);
+	struct libusb_config_descriptor *conf_desc;
+	const struct libusb_interface_descriptor *if_desc;
+	struct libusb_context *ctx = DEVICE_CTX(dev_handle->dev);
+
+	r = libusb_get_active_config_descriptor(dev_handle->dev, &conf_desc);
+	if (r != LIBUSB_SUCCESS) {
+		usbi_warn(ctx, "could not read config descriptor: error %d", r);
+		return r;
+	}
+
+	if_desc = &conf_desc->interface[iface].altsetting[altsetting];
+	safe_free(priv->usb_interface[iface].endpoint);
+
+	if (if_desc->bNumEndpoints == 0) {
+		usbi_dbg("no endpoints found for interface %d", iface);
+		libusb_free_config_descriptor(conf_desc);
+		return LIBUSB_SUCCESS;
+	}
+
+	priv->usb_interface[iface].endpoint = malloc(if_desc->bNumEndpoints);
+	if (priv->usb_interface[iface].endpoint == NULL) {
+		libusb_free_config_descriptor(conf_desc);
+		return LIBUSB_ERROR_NO_MEM;
+	}
+
+	priv->usb_interface[iface].nb_endpoints = if_desc->bNumEndpoints;
+	for (i = 0; i < if_desc->bNumEndpoints; i++) {
+		priv->usb_interface[iface].endpoint[i] = if_desc->endpoint[i].bEndpointAddress;
+		usbi_dbg("(re)assigned endpoint %02X to interface %d", priv->usb_interface[iface].endpoint[i], iface);
+	}
+	libusb_free_config_descriptor(conf_desc);
+
+	// Extra init may be required to configure endpoints
+	if (priv->apib->configure_endpoints)
+		r = priv->apib->configure_endpoints(SUB_API_NOTSET, dev_handle, iface);
+
+	return r;
+}
+
+// Lookup for a match in the list of API driver names
+// return -1 if not found, driver match number otherwise
+static int get_sub_api(char *driver, int api)
+{
+	int i;
+	const char sep_str[2] = {LIST_SEPARATOR, 0};
+	char *tok, *tmp_str;
+	size_t len = strlen(driver);
+
+	if (len == 0)
+		return SUB_API_NOTSET;
+
+	tmp_str = _strdup(driver);
+	if (tmp_str == NULL)
+		return SUB_API_NOTSET;
+
+	tok = strtok(tmp_str, sep_str);
+	while (tok != NULL) {
+		for (i = 0; i < usb_api_backend[api].nb_driver_names; i++) {
+			if (_stricmp(tok, usb_api_backend[api].driver_name_list[i]) == 0) {
+				free(tmp_str);
+				return i;
+			}
+		}
+		tok = strtok(NULL, sep_str);
+	}
+
+	free(tmp_str);
+	return SUB_API_NOTSET;
+}
+
+/*
+ * auto-claiming and auto-release helper functions
+ */
+static int auto_claim(struct libusb_transfer *transfer, int *interface_number, int api_type)
+{
+	struct libusb_context *ctx = DEVICE_CTX(transfer->dev_handle->dev);
+	struct winusb_device_handle_priv *handle_priv = _device_handle_priv(
+		transfer->dev_handle);
+	struct winusb_device_priv *priv = _device_priv(transfer->dev_handle->dev);
+	int current_interface = *interface_number;
+	int r = LIBUSB_SUCCESS;
+
+	switch (api_type) {
+	case USB_API_WINUSBX:
+	case USB_API_HID:
+		break;
+	default:
+		return LIBUSB_ERROR_INVALID_PARAM;
+	}
+
+	usbi_mutex_lock(&autoclaim_lock);
+	if (current_interface < 0) { // No serviceable interface was found
+		for (current_interface = 0; current_interface < USB_MAXINTERFACES; current_interface++) {
+			// Must claim an interface of the same API type
+			if ((priv->usb_interface[current_interface].apib->id == api_type)
+					&& (libusb_claim_interface(transfer->dev_handle, current_interface) == LIBUSB_SUCCESS)) {
+				usbi_dbg("auto-claimed interface %d for control request", current_interface);
+				if (handle_priv->autoclaim_count[current_interface] != 0)
+					usbi_warn(ctx, "program assertion failed - autoclaim_count was nonzero");
+				handle_priv->autoclaim_count[current_interface]++;
+				break;
+			}
+		}
+		if (current_interface == USB_MAXINTERFACES) {
+			usbi_err(ctx, "could not auto-claim any interface");
+			r = LIBUSB_ERROR_NOT_FOUND;
+		}
+	} else {
+		// If we have a valid interface that was autoclaimed, we must increment
+		// its autoclaim count so that we can prevent an early release.
+		if (handle_priv->autoclaim_count[current_interface] != 0)
+			handle_priv->autoclaim_count[current_interface]++;
+	}
+	usbi_mutex_unlock(&autoclaim_lock);
+
+	*interface_number = current_interface;
+	return r;
+}
+
+static void auto_release(struct usbi_transfer *itransfer)
+{
+	struct winusb_transfer_priv *transfer_priv = usbi_transfer_get_os_priv(itransfer);
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	libusb_device_handle *dev_handle = transfer->dev_handle;
+	struct winusb_device_handle_priv *handle_priv = _device_handle_priv(dev_handle);
+	int r;
+
+	usbi_mutex_lock(&autoclaim_lock);
+	if (handle_priv->autoclaim_count[transfer_priv->interface_number] > 0) {
+		handle_priv->autoclaim_count[transfer_priv->interface_number]--;
+		if (handle_priv->autoclaim_count[transfer_priv->interface_number] == 0) {
+			r = libusb_release_interface(dev_handle, transfer_priv->interface_number);
+			if (r == LIBUSB_SUCCESS)
+				usbi_dbg("auto-released interface %d", transfer_priv->interface_number);
+			else
+				usbi_dbg("failed to auto-release interface %d (%s)",
+					transfer_priv->interface_number, libusb_error_name((enum libusb_error)r));
+		}
+	}
+	usbi_mutex_unlock(&autoclaim_lock);
+}
+
+/*
+ * init: libusb backend init function
+ */
+static int winusb_init(struct libusb_context *ctx)
+{
+	int i;
+
+	// We need a lock for proper auto-release
+	usbi_mutex_init(&autoclaim_lock);
+
+	// Load DLL imports
+	if (!init_dlls()) {
+		usbi_err(ctx, "could not resolve DLL functions");
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	// Initialize the low level APIs (we don't care about errors at this stage)
+	for (i = 0; i < USB_API_MAX; i++) {
+		if (usb_api_backend[i].init && usb_api_backend[i].init(ctx))
+			usbi_warn(ctx, "error initializing %s backend",
+				usb_api_backend[i].designation);
+	}
+
+	return LIBUSB_SUCCESS;
+}
+
+/*
+* exit: libusb backend deinitialization function
+*/
+static void winusb_exit(struct libusb_context *ctx)
+{
+	int i;
+
+	for (i = 0; i < USB_API_MAX; i++) {
+		if (usb_api_backend[i].exit)
+			usb_api_backend[i].exit();
+	}
+
+	exit_dlls();
+	usbi_mutex_destroy(&autoclaim_lock);
+}
+
+/*
+ * fetch and cache all the config descriptors through I/O
+ */
+static void cache_config_descriptors(struct libusb_device *dev, HANDLE hub_handle)
+{
+	struct libusb_context *ctx = DEVICE_CTX(dev);
+	struct winusb_device_priv *priv = _device_priv(dev);
+	DWORD size, ret_size;
+	uint8_t i;
+
+	USB_CONFIGURATION_DESCRIPTOR_SHORT cd_buf_short; // dummy request
+	PUSB_DESCRIPTOR_REQUEST cd_buf_actual = NULL;    // actual request
+	PUSB_CONFIGURATION_DESCRIPTOR cd_data;
+
+	if (dev->num_configurations == 0)
+		return;
+
+	priv->config_descriptor = calloc(dev->num_configurations, sizeof(PUSB_CONFIGURATION_DESCRIPTOR));
+	if (priv->config_descriptor == NULL) {
+		usbi_err(ctx, "could not allocate configuration descriptor array for '%s'", priv->dev_id);
+		return;
+	}
+
+	for (i = 0; i <= dev->num_configurations; i++) {
+		safe_free(cd_buf_actual);
+
+		if (i == dev->num_configurations)
+			break;
+
+		size = sizeof(cd_buf_short);
+		memset(&cd_buf_short, 0, size);
+
+		cd_buf_short.req.ConnectionIndex = (ULONG)dev->port_number;
+		cd_buf_short.req.SetupPacket.bmRequest = LIBUSB_ENDPOINT_IN;
+		cd_buf_short.req.SetupPacket.bRequest = LIBUSB_REQUEST_GET_DESCRIPTOR;
+		cd_buf_short.req.SetupPacket.wValue = (LIBUSB_DT_CONFIG << 8) | i;
+		cd_buf_short.req.SetupPacket.wIndex = 0;
+		cd_buf_short.req.SetupPacket.wLength = (USHORT)sizeof(USB_CONFIGURATION_DESCRIPTOR);
+
+		// Dummy call to get the required data size. Initial failures are reported as info rather
+		// than error as they can occur for non-penalizing situations, such as with some hubs.
+		// coverity[tainted_data_argument]
+		if (!DeviceIoControl(hub_handle, IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION, &cd_buf_short, size,
+			&cd_buf_short, size, &ret_size, NULL)) {
+			usbi_info(ctx, "could not access configuration descriptor %u (dummy) for '%s': %s", i, priv->dev_id, windows_error_str(0));
+			continue;
+		}
+
+		if ((ret_size != size) || (cd_buf_short.desc.wTotalLength < sizeof(USB_CONFIGURATION_DESCRIPTOR))) {
+			usbi_info(ctx, "unexpected configuration descriptor %u size (dummy) for '%s'", i, priv->dev_id);
+			continue;
+		}
+
+		size = sizeof(USB_DESCRIPTOR_REQUEST) + cd_buf_short.desc.wTotalLength;
+		cd_buf_actual = malloc(size);
+		if (cd_buf_actual == NULL) {
+			usbi_err(ctx, "could not allocate configuration descriptor %u buffer for '%s'", i, priv->dev_id);
+			continue;
+		}
+
+		// Actual call
+		cd_buf_actual->ConnectionIndex = (ULONG)dev->port_number;
+		cd_buf_actual->SetupPacket.bmRequest = LIBUSB_ENDPOINT_IN;
+		cd_buf_actual->SetupPacket.bRequest = LIBUSB_REQUEST_GET_DESCRIPTOR;
+		cd_buf_actual->SetupPacket.wValue = (LIBUSB_DT_CONFIG << 8) | i;
+		cd_buf_actual->SetupPacket.wIndex = 0;
+		cd_buf_actual->SetupPacket.wLength = cd_buf_short.desc.wTotalLength;
+
+		if (!DeviceIoControl(hub_handle, IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION, cd_buf_actual, size,
+			cd_buf_actual, size, &ret_size, NULL)) {
+			usbi_err(ctx, "could not access configuration descriptor %u (actual) for '%s': %s", i, priv->dev_id, windows_error_str(0));
+			continue;
+		}
+
+		cd_data = (PUSB_CONFIGURATION_DESCRIPTOR)((UCHAR *)cd_buf_actual + sizeof(USB_DESCRIPTOR_REQUEST));
+
+		if ((size != ret_size) || (cd_data->wTotalLength != cd_buf_short.desc.wTotalLength)) {
+			usbi_err(ctx, "unexpected configuration descriptor %u size (actual) for '%s'", i, priv->dev_id);
+			continue;
+		}
+
+		if (cd_data->bDescriptorType != LIBUSB_DT_CONFIG) {
+			usbi_err(ctx, "descriptor %u not a configuration descriptor for '%s'", i, priv->dev_id);
+			continue;
+		}
+
+		usbi_dbg("cached config descriptor %u (bConfigurationValue=%u, %u bytes)",
+			i, cd_data->bConfigurationValue, cd_data->wTotalLength);
+
+		// Cache the descriptor
+		priv->config_descriptor[i] = malloc(cd_data->wTotalLength);
+		if (priv->config_descriptor[i] != NULL) {
+			memcpy(priv->config_descriptor[i], cd_data, cd_data->wTotalLength);
+		} else {
+			usbi_err(ctx, "could not allocate configuration descriptor %u buffer for '%s'", i, priv->dev_id);
+		}
+	}
+}
+
+/*
+ * Populate a libusb device structure
+ */
+static int init_device(struct libusb_device *dev, struct libusb_device *parent_dev,
+	uint8_t port_number, DEVINST devinst)
+{
+	struct libusb_context *ctx;
+	struct libusb_device *tmp_dev;
+	struct winusb_device_priv *priv, *parent_priv;
+	USB_NODE_CONNECTION_INFORMATION_EX conn_info;
+	USB_NODE_CONNECTION_INFORMATION_EX_V2 conn_info_v2;
+	HANDLE hub_handle;
+	DWORD size;
+	uint8_t bus_number, depth;
+	int r;
+
+	priv = _device_priv(dev);
+
+	// If the device is already initialized, we can stop here
+	if (priv->initialized)
+		return LIBUSB_SUCCESS;
+
+	if (parent_dev != NULL) { // Not a HCD root hub
+		ctx = DEVICE_CTX(dev);
+		parent_priv = _device_priv(parent_dev);
+		if (parent_priv->apib->id != USB_API_HUB) {
+			usbi_warn(ctx, "parent for device '%s' is not a hub", priv->dev_id);
+			return LIBUSB_ERROR_NOT_FOUND;
+		}
+
+		// Calculate depth and fetch bus number
+		bus_number = parent_dev->bus_number;
+		if (bus_number == 0) {
+			tmp_dev = get_ancestor(ctx, devinst, &devinst);
+			if (tmp_dev != parent_dev) {
+				usbi_err(ctx, "program assertion failed - first ancestor is not parent");
+				return LIBUSB_ERROR_NOT_FOUND;
+			}
+			libusb_unref_device(tmp_dev);
+
+			for (depth = 1; bus_number == 0; depth++) {
+				tmp_dev = get_ancestor(ctx, devinst, &devinst);
+				if (tmp_dev->bus_number != 0) {
+					bus_number = tmp_dev->bus_number;
+					depth += _device_priv(tmp_dev)->depth;
+				}
+				libusb_unref_device(tmp_dev);
+			}
+		} else {
+			depth = parent_priv->depth + 1;
+		}
+
+		if (bus_number == 0) {
+			usbi_err(ctx, "program assertion failed - bus number not found for '%s'", priv->dev_id);
+			return LIBUSB_ERROR_NOT_FOUND;
+		}
+
+		dev->bus_number = bus_number;
+		dev->port_number = port_number;
+		dev->parent_dev = parent_dev;
+		priv->depth = depth;
+
+		hub_handle = CreateFileA(parent_priv->path, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
+				     0, NULL);
+		if (hub_handle == INVALID_HANDLE_VALUE) {
+			usbi_warn(ctx, "could not open hub %s: %s", parent_priv->path, windows_error_str(0));
+			return LIBUSB_ERROR_ACCESS;
+		}
+
+		memset(&conn_info, 0, sizeof(conn_info));
+		conn_info.ConnectionIndex = (ULONG)port_number;
+		// coverity[tainted_data_argument]
+		if (!DeviceIoControl(hub_handle, IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX, &conn_info, sizeof(conn_info),
+			&conn_info, sizeof(conn_info), &size, NULL)) {
+			usbi_warn(ctx, "could not get node connection information for device '%s': %s",
+				  priv->dev_id, windows_error_str(0));
+			CloseHandle(hub_handle);
+			return LIBUSB_ERROR_NO_DEVICE;
+		}
+
+		if (conn_info.ConnectionStatus == NoDeviceConnected) {
+			usbi_err(ctx, "device '%s' is no longer connected!", priv->dev_id);
+			CloseHandle(hub_handle);
+			return LIBUSB_ERROR_NO_DEVICE;
+		}
+
+		memcpy(&priv->dev_descriptor, &(conn_info.DeviceDescriptor), sizeof(USB_DEVICE_DESCRIPTOR));
+		dev->num_configurations = priv->dev_descriptor.bNumConfigurations;
+		priv->active_config = conn_info.CurrentConfigurationValue;
+		usbi_dbg("found %u configurations (active conf: %u)", dev->num_configurations, priv->active_config);
+
+		// Cache as many config descriptors as we can
+		cache_config_descriptors(dev, hub_handle);
+
+		// In their great wisdom, Microsoft decided to BREAK the USB speed report between Windows 7 and Windows 8
+		if (windows_version >= WINDOWS_8) {
+			conn_info_v2.ConnectionIndex = (ULONG)port_number;
+			conn_info_v2.Length = sizeof(USB_NODE_CONNECTION_INFORMATION_EX_V2);
+			conn_info_v2.SupportedUsbProtocols.Usb300 = 1;
+			if (!DeviceIoControl(hub_handle, IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX_V2,
+				&conn_info_v2, sizeof(conn_info_v2), &conn_info_v2, sizeof(conn_info_v2), &size, NULL)) {
+				usbi_warn(ctx, "could not get node connection information (V2) for device '%s': %s",
+					  priv->dev_id,  windows_error_str(0));
+			} else if (conn_info_v2.Flags.DeviceIsOperatingAtSuperSpeedOrHigher) {
+				conn_info.Speed = 3;
+			}
+		}
+
+		CloseHandle(hub_handle);
+
+		if (conn_info.DeviceAddress > UINT8_MAX)
+			usbi_err(ctx, "program assertion failed - device address overflow");
+
+		dev->device_address = (uint8_t)conn_info.DeviceAddress;
+
+		switch (conn_info.Speed) {
+		case 0: dev->speed = LIBUSB_SPEED_LOW; break;
+		case 1: dev->speed = LIBUSB_SPEED_FULL; break;
+		case 2: dev->speed = LIBUSB_SPEED_HIGH; break;
+		case 3: dev->speed = LIBUSB_SPEED_SUPER; break;
+		default:
+			usbi_warn(ctx, "unknown device speed %u", conn_info.Speed);
+			break;
+		}
+	}
+
+	r = usbi_sanitize_device(dev);
+	if (r)
+		return r;
+
+	priv->initialized = true;
+
+	usbi_dbg("(bus: %u, addr: %u, depth: %u, port: %u): '%s'",
+		dev->bus_number, dev->device_address, priv->depth, dev->port_number, priv->dev_id);
+
+	return LIBUSB_SUCCESS;
+}
+
+static int enumerate_hcd_root_hub(struct libusb_context *ctx, const char *dev_id,
+	uint8_t bus_number, DEVINST devinst)
+{
+	struct libusb_device *dev;
+	struct winusb_device_priv *priv;
+	unsigned long session_id;
+	DEVINST child_devinst;
+
+	if (CM_Get_Child(&child_devinst, devinst, 0) != CR_SUCCESS) {
+		usbi_err(ctx, "could not get child devinst for '%s'", dev_id);
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	session_id = (unsigned long)child_devinst;
+	dev = usbi_get_device_by_session_id(ctx, session_id);
+	if (dev == NULL) {
+		usbi_err(ctx, "program assertion failed - HCD '%s' child not found", dev_id);
+		return LIBUSB_ERROR_NO_DEVICE;
+	}
+
+	if (dev->bus_number == 0) {
+		// Only do this once
+		usbi_dbg("assigning HCD '%s' bus number %u", dev_id, bus_number);
+		priv = _device_priv(dev);
+		dev->bus_number = bus_number;
+		dev->num_configurations = 1;
+		priv->dev_descriptor.bLength = LIBUSB_DT_DEVICE_SIZE;
+		priv->dev_descriptor.bDescriptorType = LIBUSB_DT_DEVICE;
+		priv->dev_descriptor.bDeviceClass = LIBUSB_CLASS_HUB;
+		priv->dev_descriptor.bNumConfigurations = 1;
+		priv->active_config = 1;
+		priv->root_hub = true;
+		if (sscanf(dev_id, "PCI\\VEN_%04hx&DEV_%04hx%*s", &priv->dev_descriptor.idVendor, &priv->dev_descriptor.idProduct) != 2) {
+			usbi_warn(ctx, "could not infer VID/PID of HCD root hub from '%s'", dev_id);
+			priv->dev_descriptor.idVendor = 0x1d6b; // Linux Foundation root hub
+			priv->dev_descriptor.idProduct = 1;
+		}
+	}
+
+	libusb_unref_device(dev);
+	return LIBUSB_SUCCESS;
+}
+
+// Returns the api type, or 0 if not found/unsupported
+static void get_api_type(struct libusb_context *ctx, HDEVINFO *dev_info,
+	SP_DEVINFO_DATA *dev_info_data, int *api, int *sub_api)
+{
+	// Precedence for filter drivers vs driver is in the order of this array
+	struct driver_lookup lookup[3] = {
+		{"\0\0", SPDRP_SERVICE, "driver"},
+		{"\0\0", SPDRP_UPPERFILTERS, "upper filter driver"},
+		{"\0\0", SPDRP_LOWERFILTERS, "lower filter driver"}
+	};
+	DWORD size, reg_type;
+	unsigned k, l;
+	int i, j;
+
+	// Check the service & filter names to know the API we should use
+	for (k = 0; k < 3; k++) {
+		if (pSetupDiGetDeviceRegistryPropertyA(*dev_info, dev_info_data, lookup[k].reg_prop,
+			&reg_type, (PBYTE)lookup[k].list, MAX_KEY_LENGTH, &size)) {
+			// Turn the REG_SZ SPDRP_SERVICE into REG_MULTI_SZ
+			if (lookup[k].reg_prop == SPDRP_SERVICE)
+				// our buffers are MAX_KEY_LENGTH + 1 so we can overflow if needed
+				lookup[k].list[strlen(lookup[k].list) + 1] = 0;
+
+			// MULTI_SZ is a pain to work with. Turn it into something much more manageable
+			// NB: none of the driver names we check against contain LIST_SEPARATOR,
+			// (currently ';'), so even if an unsuported one does, it's not an issue
+			for (l = 0; (lookup[k].list[l] != 0) || (lookup[k].list[l + 1] != 0); l++) {
+				if (lookup[k].list[l] == 0)
+					lookup[k].list[l] = LIST_SEPARATOR;
+			}
+			usbi_dbg("%s(s): %s", lookup[k].designation, lookup[k].list);
+		} else {
+			if (GetLastError() != ERROR_INVALID_DATA)
+				usbi_dbg("could not access %s: %s", lookup[k].designation, windows_error_str(0));
+			lookup[k].list[0] = 0;
+		}
+	}
+
+	for (i = 2; i < USB_API_MAX; i++) {
+		for (k = 0; k < 3; k++) {
+			j = get_sub_api(lookup[k].list, i);
+			if (j >= 0) {
+				usbi_dbg("matched %s name against %s", lookup[k].designation,
+					(i != USB_API_WINUSBX) ? usb_api_backend[i].designation : usb_api_backend[i].driver_name_list[j]);
+				*api = i;
+				*sub_api = j;
+				return;
+			}
+		}
+	}
+}
+
+static int set_composite_interface(struct libusb_context *ctx, struct libusb_device *dev,
+	char *dev_interface_path, char *device_id, int api, int sub_api)
+{
+	struct winusb_device_priv *priv = _device_priv(dev);
+	int interface_number;
+	const char *mi_str;
+
+	// Because MI_## are not necessarily in sequential order (some composite
+	// devices will have only MI_00 & MI_03 for instance), we retrieve the actual
+	// interface number from the path's MI value
+	mi_str = strstr(device_id, "MI_");
+	if ((mi_str != NULL) && isdigit(mi_str[3]) && isdigit(mi_str[4])) {
+		interface_number = ((mi_str[3] - '0') * 10) + (mi_str[4] - '0');
+	} else {
+		usbi_warn(ctx, "failure to read interface number for %s, using default value", device_id);
+		interface_number = 0;
+	}
+
+	if (interface_number >= USB_MAXINTERFACES) {
+		usbi_warn(ctx, "interface %d too large - ignoring interface path %s", interface_number, dev_interface_path);
+		return LIBUSB_ERROR_ACCESS;
+	}
+
+	if (priv->usb_interface[interface_number].path != NULL) {
+		if (api == USB_API_HID) {
+			// HID devices can have multiple collections (COL##) for each MI_## interface
+			usbi_dbg("interface[%d] already set - ignoring HID collection: %s",
+				interface_number, device_id);
+			return LIBUSB_ERROR_ACCESS;
+		}
+		// In other cases, just use the latest data
+		safe_free(priv->usb_interface[interface_number].path);
+	}
+
+	usbi_dbg("interface[%d] = %s", interface_number, dev_interface_path);
+	priv->usb_interface[interface_number].path = dev_interface_path;
+	priv->usb_interface[interface_number].apib = &usb_api_backend[api];
+	priv->usb_interface[interface_number].sub_api = sub_api;
+	if ((api == USB_API_HID) && (priv->hid == NULL)) {
+		priv->hid = calloc(1, sizeof(struct hid_device_priv));
+		if (priv->hid == NULL)
+			return LIBUSB_ERROR_NO_MEM;
+	}
+
+	return LIBUSB_SUCCESS;
+}
+
+static int set_hid_interface(struct libusb_context *ctx, struct libusb_device *dev,
+	char *dev_interface_path)
+{
+	int i;
+	struct winusb_device_priv *priv = _device_priv(dev);
+
+	if (priv->hid == NULL) {
+		usbi_err(ctx, "program assertion failed: parent is not HID");
+		return LIBUSB_ERROR_NO_DEVICE;
+	} else if (priv->hid->nb_interfaces == USB_MAXINTERFACES) {
+		usbi_err(ctx, "program assertion failed: max USB interfaces reached for HID device");
+		return LIBUSB_ERROR_NO_DEVICE;
+	}
+
+	for (i = 0; i < priv->hid->nb_interfaces; i++) {
+		if ((priv->usb_interface[i].path != NULL) && strcmp(priv->usb_interface[i].path, dev_interface_path) == 0) {
+			usbi_dbg("interface[%d] already set to %s", i, dev_interface_path);
+			return LIBUSB_ERROR_ACCESS;
+		}
+	}
+
+	priv->usb_interface[priv->hid->nb_interfaces].path = dev_interface_path;
+	priv->usb_interface[priv->hid->nb_interfaces].apib = &usb_api_backend[USB_API_HID];
+	usbi_dbg("interface[%u] = %s", priv->hid->nb_interfaces, dev_interface_path);
+	priv->hid->nb_interfaces++;
+	return LIBUSB_SUCCESS;
+}
+
+/*
+ * get_device_list: libusb backend device enumeration function
+ */
+static int winusb_get_device_list(struct libusb_context *ctx, struct discovered_devs **_discdevs)
+{
+	struct discovered_devs *discdevs;
+	HDEVINFO *dev_info, dev_info_intf, dev_info_enum;
+	SP_DEVINFO_DATA dev_info_data;
+	DWORD _index = 0;
+	GUID hid_guid;
+	int r = LIBUSB_SUCCESS;
+	int api, sub_api;
+	unsigned int pass, i, j;
+	char enumerator[16];
+	char dev_id[MAX_PATH_LENGTH];
+	struct libusb_device *dev, *parent_dev;
+	struct winusb_device_priv *priv, *parent_priv;
+	char *dev_interface_path = NULL;
+	unsigned long session_id;
+	DWORD size, port_nr, reg_type, install_state;
+	HKEY key;
+	WCHAR guid_string_w[MAX_GUID_STRING_LENGTH];
+	GUID *if_guid;
+	LONG s;
+#define HUB_PASS 0
+#define DEV_PASS 1
+#define HCD_PASS 2
+#define GEN_PASS 3
+#define HID_PASS 4
+#define EXT_PASS 5
+	// Keep a list of guids that will be enumerated
+#define GUID_SIZE_STEP 8
+	const GUID **guid_list, **new_guid_list;
+	unsigned int guid_size = GUID_SIZE_STEP;
+	unsigned int nb_guids;
+	// Keep a list of PnP enumerator strings that are found
+	char *usb_enumerator[8] = { "USB" };
+	unsigned int nb_usb_enumerators = 1;
+	unsigned int usb_enum_index = 0;
+	// Keep a list of newly allocated devs to unref
+#define UNREF_SIZE_STEP 16
+	libusb_device **unref_list, **new_unref_list;
+	unsigned int unref_size = UNREF_SIZE_STEP;
+	unsigned int unref_cur = 0;
+
+	// PASS 1 : (re)enumerate HCDs (allows for HCD hotplug)
+	// PASS 2 : (re)enumerate HUBS
+	// PASS 3 : (re)enumerate generic USB devices (including driverless)
+	//           and list additional USB device interface GUIDs to explore
+	// PASS 4 : (re)enumerate master USB devices that have a device interface
+	// PASS 5+: (re)enumerate device interfaced GUIDs (including HID) and
+	//           set the device interfaces.
+
+	// Init the GUID table
+	guid_list = malloc(guid_size * sizeof(void *));
+	if (guid_list == NULL) {
+		usbi_err(ctx, "failed to alloc guid list");
+		return LIBUSB_ERROR_NO_MEM;
+	}
+
+	guid_list[HUB_PASS] = &GUID_DEVINTERFACE_USB_HUB;
+	guid_list[DEV_PASS] = &GUID_DEVINTERFACE_USB_DEVICE;
+	guid_list[HCD_PASS] = &GUID_DEVINTERFACE_USB_HOST_CONTROLLER;
+	guid_list[GEN_PASS] = NULL;
+	if (api_hid_available) {
+		HidD_GetHidGuid(&hid_guid);
+		guid_list[HID_PASS] = &hid_guid;
+	} else {
+		guid_list[HID_PASS] = NULL;
+	}
+	nb_guids = EXT_PASS;
+
+	unref_list = malloc(unref_size * sizeof(void *));
+	if (unref_list == NULL) {
+		usbi_err(ctx, "failed to alloc unref list");
+		free((void *)guid_list);
+		return LIBUSB_ERROR_NO_MEM;
+	}
+
+	dev_info_intf = pSetupDiGetClassDevsA(NULL, NULL, NULL, DIGCF_ALLCLASSES | DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
+	if (dev_info_intf == INVALID_HANDLE_VALUE) {
+		usbi_err(ctx, "failed to obtain device info list: %s", windows_error_str(0));
+		free(unref_list);
+		free((void *)guid_list);
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	for (pass = 0; ((pass < nb_guids) && (r == LIBUSB_SUCCESS)); pass++) {
+//#define ENUM_DEBUG
+#if defined(ENABLE_LOGGING) && defined(ENUM_DEBUG)
+		const char * const passname[] = {"HUB", "DEV", "HCD", "GEN", "HID", "EXT"};
+		usbi_dbg("#### PROCESSING %ss %s", passname[MIN(pass, EXT_PASS)], guid_to_string(guid_list[pass]));
+#endif
+		if ((pass == HID_PASS) && (guid_list[HID_PASS] == NULL))
+			continue;
+
+		dev_info = (pass != GEN_PASS) ? &dev_info_intf : &dev_info_enum;
+
+		for (i = 0; ; i++) {
+			// safe loop: free up any (unprotected) dynamic resource
+			// NB: this is always executed before breaking the loop
+			safe_free(dev_interface_path);
+			priv = parent_priv = NULL;
+			dev = parent_dev = NULL;
+
+			// Safe loop: end of loop conditions
+			if (r != LIBUSB_SUCCESS)
+				break;
+
+			if ((pass == HCD_PASS) && (i == UINT8_MAX)) {
+				usbi_warn(ctx, "program assertion failed - found more than %u buses, skipping the rest.", UINT8_MAX);
+				break;
+			}
+
+			if (pass != GEN_PASS) {
+				// Except for GEN, all passes deal with device interfaces
+				r = get_interface_details(ctx, *dev_info, &dev_info_data, guid_list[pass], &_index, &dev_interface_path);
+				if ((r != LIBUSB_SUCCESS) || (dev_interface_path == NULL)) {
+					_index = 0;
+					break;
+				}
+			} else {
+				// Workaround for a Nec/Renesas USB 3.0 driver bug where root hubs are
+				// being listed under the "NUSB3" PnP Symbolic Name rather than "USB".
+				// The Intel USB 3.0 driver behaves similar, but uses "IUSB3"
+				// The Intel Alpine Ridge USB 3.1 driver uses "IARUSB3"
+				for (; usb_enum_index < nb_usb_enumerators; usb_enum_index++) {
+					if (get_devinfo_data(ctx, dev_info, &dev_info_data, usb_enumerator[usb_enum_index], i))
+						break;
+					i = 0;
+				}
+				if (usb_enum_index == nb_usb_enumerators)
+					break;
+			}
+
+			// Read the Device ID path
+			if (!pSetupDiGetDeviceInstanceIdA(*dev_info, &dev_info_data, dev_id, sizeof(dev_id), NULL)) {
+				usbi_warn(ctx, "could not read the device instance ID for devInst %X, skipping",
+					  dev_info_data.DevInst);
+				continue;
+			}
+
+#ifdef ENUM_DEBUG
+			usbi_dbg("PRO: %s", dev_id);
+#endif
+
+			// Set API to use or get additional data from generic pass
+			api = USB_API_UNSUPPORTED;
+			sub_api = SUB_API_NOTSET;
+			switch (pass) {
+			case HCD_PASS:
+				break;
+			case HUB_PASS:
+				api = USB_API_HUB;
+				// Fetch the PnP enumerator class for this hub
+				// This will allow us to enumerate all classes during the GEN pass
+				if (!pSetupDiGetDeviceRegistryPropertyA(*dev_info, &dev_info_data, SPDRP_ENUMERATOR_NAME,
+					NULL, (PBYTE)enumerator, sizeof(enumerator), NULL)) {
+					usbi_err(ctx, "could not read enumerator string for device '%s': %s", dev_id, windows_error_str(0));
+					LOOP_BREAK(LIBUSB_ERROR_OTHER);
+				}
+				for (j = 0; j < nb_usb_enumerators; j++) {
+					if (strcmp(usb_enumerator[j], enumerator) == 0)
+						break;
+				}
+				if (j == nb_usb_enumerators) {
+					usbi_dbg("found new PnP enumerator string '%s'", enumerator);
+					if (nb_usb_enumerators < ARRAYSIZE(usb_enumerator)) {
+						usb_enumerator[nb_usb_enumerators] = _strdup(enumerator);
+						if (usb_enumerator[nb_usb_enumerators] != NULL) {
+							nb_usb_enumerators++;
+						} else {
+							usbi_err(ctx, "could not allocate enumerator string '%s'", enumerator);
+							LOOP_BREAK(LIBUSB_ERROR_NO_MEM);
+						}
+					} else {
+						usbi_warn(ctx, "too many enumerator strings, some devices may not be accessible");
+					}
+				}
+				break;
+			case GEN_PASS:
+				// We use the GEN pass to detect driverless devices...
+				if (!pSetupDiGetDeviceRegistryPropertyA(*dev_info, &dev_info_data, SPDRP_DRIVER,
+					NULL, NULL, 0, NULL) && (GetLastError() != ERROR_INSUFFICIENT_BUFFER)) {
+					usbi_info(ctx, "The following device has no driver: '%s'", dev_id);
+					usbi_info(ctx, "libusb will not be able to access it");
+				}
+				// ...and to add the additional device interface GUIDs
+				key = pSetupDiOpenDevRegKey(*dev_info, &dev_info_data, DICS_FLAG_GLOBAL, 0, DIREG_DEV, KEY_READ);
+				if (key == INVALID_HANDLE_VALUE)
+					break;
+				// Look for both DeviceInterfaceGUIDs *and* DeviceInterfaceGUID, in that order
+				size = sizeof(guid_string_w);
+				s = pRegQueryValueExW(key, L"DeviceInterfaceGUIDs", NULL, &reg_type,
+					(LPBYTE)guid_string_w, &size);
+				if (s == ERROR_FILE_NOT_FOUND)
+					s = pRegQueryValueExW(key, L"DeviceInterfaceGUID", NULL, &reg_type,
+						(LPBYTE)guid_string_w, &size);
+				pRegCloseKey(key);
+				if ((s == ERROR_SUCCESS) &&
+				    (((reg_type == REG_SZ) && (size == (sizeof(guid_string_w) - sizeof(WCHAR)))) ||
+				     ((reg_type == REG_MULTI_SZ) && (size == sizeof(guid_string_w))))) {
+					if (nb_guids == guid_size) {
+						new_guid_list = realloc((void *)guid_list, (guid_size + GUID_SIZE_STEP) * sizeof(void *));
+						if (new_guid_list == NULL) {
+							usbi_err(ctx, "failed to realloc guid list");
+							LOOP_BREAK(LIBUSB_ERROR_NO_MEM);
+						}
+						guid_list = new_guid_list;
+						guid_size += GUID_SIZE_STEP;
+					}
+					if_guid = malloc(sizeof(*if_guid));
+					if (if_guid == NULL) {
+						usbi_err(ctx, "failed to alloc if_guid");
+						LOOP_BREAK(LIBUSB_ERROR_NO_MEM);
+					}
+					if (pIIDFromString(guid_string_w, if_guid) != 0) {
+						usbi_warn(ctx, "device '%s' has malformed DeviceInterfaceGUID string, skipping", dev_id);
+						free(if_guid);
+					} else {
+						// Check if we've already seen this GUID
+						for (j = EXT_PASS; j < nb_guids; j++) {
+							if (memcmp(guid_list[j], if_guid, sizeof(*if_guid)) == 0)
+								break;
+						}
+						if (j == nb_guids) {
+							usbi_dbg("extra GUID: %s", guid_to_string(if_guid));
+							guid_list[nb_guids++] = if_guid;
+						} else {
+							// Duplicate, ignore
+							free(if_guid);
+						}
+					}
+				} else if (s == ERROR_SUCCESS) {
+					usbi_warn(ctx, "unexpected type/size of DeviceInterfaceGUID for '%s'", dev_id);
+				}
+				break;
+			case HID_PASS:
+				api = USB_API_HID;
+				break;
+			default:
+				// Get the API type (after checking that the driver installation is OK)
+				if ((!pSetupDiGetDeviceRegistryPropertyA(*dev_info, &dev_info_data, SPDRP_INSTALL_STATE,
+					NULL, (PBYTE)&install_state, sizeof(install_state), &size)) || (size != sizeof(install_state))) {
+					usbi_warn(ctx, "could not detect installation state of driver for '%s': %s",
+						dev_id, windows_error_str(0));
+				} else if (install_state != 0) {
+					usbi_warn(ctx, "driver for device '%s' is reporting an issue (code: %u) - skipping",
+						dev_id, (unsigned int)install_state);
+					continue;
+				}
+				get_api_type(ctx, dev_info, &dev_info_data, &api, &sub_api);
+				break;
+			}
+
+			// Find parent device (for the passes that need it)
+			if (pass >= GEN_PASS) {
+				parent_dev = get_ancestor(ctx, dev_info_data.DevInst, NULL);
+				if (parent_dev == NULL) {
+					// Root hubs will not have a parent
+					dev = usbi_get_device_by_session_id(ctx, (unsigned long)dev_info_data.DevInst);
+					if (dev != NULL) {
+						priv = _device_priv(dev);
+						if (priv->root_hub)
+							goto track_unref;
+						libusb_unref_device(dev);
+					}
+
+					usbi_dbg("unlisted ancestor for '%s' (non USB HID, newly connected, etc.) - ignoring", dev_id);
+					continue;
+				}
+
+				parent_priv = _device_priv(parent_dev);
+				// virtual USB devices are also listed during GEN - don't process these yet
+				if ((pass == GEN_PASS) && (parent_priv->apib->id != USB_API_HUB)) {
+					libusb_unref_device(parent_dev);
+					continue;
+				}
+			}
+
+			// Create new or match existing device, using the devInst as session id
+			if ((pass <= GEN_PASS) && (pass != HCD_PASS)) {	// For subsequent passes, we'll lookup the parent
+				// These are the passes that create "new" devices
+				session_id = (unsigned long)dev_info_data.DevInst;
+				dev = usbi_get_device_by_session_id(ctx, session_id);
+				if (dev == NULL) {
+				alloc_device:
+					usbi_dbg("allocating new device for session [%lX]", session_id);
+					dev = usbi_alloc_device(ctx, session_id);
+					if (dev == NULL)
+						LOOP_BREAK(LIBUSB_ERROR_NO_MEM);
+
+					priv = winusb_device_priv_init(dev);
+					priv->dev_id = _strdup(dev_id);
+					if (priv->dev_id == NULL) {
+						libusb_unref_device(dev);
+						LOOP_BREAK(LIBUSB_ERROR_NO_MEM);
+					}
+				} else {
+					usbi_dbg("found existing device for session [%lX]", session_id);
+
+					priv = _device_priv(dev);
+					if (strcmp(priv->dev_id, dev_id) != 0) {
+						usbi_dbg("device instance ID for session [%lX] changed", session_id);
+						usbi_disconnect_device(dev);
+						libusb_unref_device(dev);
+						goto alloc_device;
+					}
+				}
+
+			track_unref:
+				// Keep track of devices that need unref
+				if (unref_cur == unref_size) {
+					new_unref_list = realloc(unref_list, (unref_size + UNREF_SIZE_STEP) * sizeof(void *));
+					if (new_unref_list == NULL) {
+						usbi_err(ctx, "could not realloc list for unref - aborting");
+						LOOP_BREAK(LIBUSB_ERROR_NO_MEM);
+					}
+					unref_list = new_unref_list;
+					unref_size += UNREF_SIZE_STEP;
+				}
+				unref_list[unref_cur++] = dev;
+			}
+
+			// Setup device
+			switch (pass) {
+			case HUB_PASS:
+			case DEV_PASS:
+				// If the device has already been setup, don't do it again
+				if (priv->path != NULL)
+					break;
+				// Take care of API initialization
+				priv->path = dev_interface_path;
+				dev_interface_path = NULL;
+				priv->apib = &usb_api_backend[api];
+				priv->sub_api = sub_api;
+				switch (api) {
+				case USB_API_COMPOSITE:
+				case USB_API_HUB:
+					break;
+				case USB_API_HID:
+					priv->hid = calloc(1, sizeof(struct hid_device_priv));
+					if (priv->hid == NULL)
+						LOOP_BREAK(LIBUSB_ERROR_NO_MEM);
+					break;
+				default:
+					// For other devices, the first interface is the same as the device
+					priv->usb_interface[0].path = _strdup(priv->path);
+					if (priv->usb_interface[0].path == NULL)
+						LOOP_BREAK(LIBUSB_ERROR_NO_MEM);
+					// The following is needed if we want API calls to work for both simple
+					// and composite devices.
+					for (j = 0; j < USB_MAXINTERFACES; j++)
+						priv->usb_interface[j].apib = &usb_api_backend[api];
+					break;
+				}
+				break;
+			case HCD_PASS:
+				r = enumerate_hcd_root_hub(ctx, dev_id, (uint8_t)(i + 1), dev_info_data.DevInst);
+				break;
+			case GEN_PASS:
+				// The SPDRP_ADDRESS for USB devices is the device port number on the hub
+				port_nr = 0;
+				if (!pSetupDiGetDeviceRegistryPropertyA(*dev_info, &dev_info_data, SPDRP_ADDRESS,
+						NULL, (PBYTE)&port_nr, sizeof(port_nr), &size) || (size != sizeof(port_nr)))
+					usbi_warn(ctx, "could not retrieve port number for device '%s': %s", dev_id, windows_error_str(0));
+				r = init_device(dev, parent_dev, (uint8_t)port_nr, dev_info_data.DevInst);
+				if (r == LIBUSB_SUCCESS) {
+					// Append device to the list of discovered devices
+					discdevs = discovered_devs_append(*_discdevs, dev);
+					if (!discdevs)
+						LOOP_BREAK(LIBUSB_ERROR_NO_MEM);
+
+					*_discdevs = discdevs;
+				} else if (r == LIBUSB_ERROR_NO_DEVICE) {
+					// This can occur if the device was disconnected but Windows hasn't
+					// refreshed its enumeration yet - in that case, we ignore the device
+					r = LIBUSB_SUCCESS;
+				}
+				break;
+			default: // HID_PASS and later
+				if (parent_priv->apib->id == USB_API_HID || parent_priv->apib->id == USB_API_COMPOSITE) {
+					if (parent_priv->apib->id == USB_API_HID) {
+						usbi_dbg("setting HID interface for [%lX]:", parent_dev->session_data);
+						r = set_hid_interface(ctx, parent_dev, dev_interface_path);
+					} else {
+						usbi_dbg("setting composite interface for [%lX]:", parent_dev->session_data);
+						r = set_composite_interface(ctx, parent_dev, dev_interface_path, dev_id, api, sub_api);
+					}
+					switch (r) {
+					case LIBUSB_SUCCESS:
+						dev_interface_path = NULL;
+						break;
+					case LIBUSB_ERROR_ACCESS:
+						// interface has already been set => make sure dev_interface_path is freed then
+						r = LIBUSB_SUCCESS;
+						break;
+					default:
+						LOOP_BREAK(r);
+						break;
+					}
+				}
+				libusb_unref_device(parent_dev);
+				break;
+			}
+		}
+	}
+
+	pSetupDiDestroyDeviceInfoList(dev_info_intf);
+
+	// Free any additional GUIDs
+	for (pass = EXT_PASS; pass < nb_guids; pass++)
+		free((void *)guid_list[pass]);
+	free((void *)guid_list);
+
+	// Free any PnP enumerator strings
+	for (i = 1; i < nb_usb_enumerators; i++)
+		free(usb_enumerator[i]);
+
+	// Unref newly allocated devs
+	for (i = 0; i < unref_cur; i++)
+		libusb_unref_device(unref_list[i]);
+	free(unref_list);
+
+	return r;
+}
+
+static int winusb_get_device_descriptor(struct libusb_device *dev, unsigned char *buffer)
+{
+	struct winusb_device_priv *priv = _device_priv(dev);
+
+	memcpy(buffer, &priv->dev_descriptor, DEVICE_DESC_LENGTH);
+	return LIBUSB_SUCCESS;
+}
+
+static int winusb_get_config_descriptor(struct libusb_device *dev, uint8_t config_index, unsigned char *buffer, size_t len)
+{
+	struct winusb_device_priv *priv = _device_priv(dev);
+	PUSB_CONFIGURATION_DESCRIPTOR config_header;
+	size_t size;
+
+	// config index is zero based
+	if (config_index >= dev->num_configurations)
+		return LIBUSB_ERROR_INVALID_PARAM;
+
+	if ((priv->config_descriptor == NULL) || (priv->config_descriptor[config_index] == NULL))
+		return LIBUSB_ERROR_NOT_FOUND;
+
+	config_header = priv->config_descriptor[config_index];
+
+	size = MIN(config_header->wTotalLength, len);
+	memcpy(buffer, priv->config_descriptor[config_index], size);
+	return (int)size;
+}
+
+static int winusb_get_config_descriptor_by_value(struct libusb_device *dev, uint8_t bConfigurationValue,
+	unsigned char **buffer)
+{
+	struct winusb_device_priv *priv = _device_priv(dev);
+	PUSB_CONFIGURATION_DESCRIPTOR config_header;
+	uint8_t index;
+
+	if (priv->config_descriptor == NULL)
+		return LIBUSB_ERROR_NOT_FOUND;
+
+	for (index = 0; index < dev->num_configurations; index++) {
+		config_header = priv->config_descriptor[index];
+		if (config_header == NULL)
+			continue;
+		if (config_header->bConfigurationValue == bConfigurationValue) {
+			*buffer = (unsigned char *)priv->config_descriptor[index];
+			return (int)config_header->wTotalLength;
+		}
+	}
+
+	return LIBUSB_ERROR_NOT_FOUND;
+}
+
+/*
+ * return the cached copy of the active config descriptor
+ */
+static int winusb_get_active_config_descriptor(struct libusb_device *dev, unsigned char *buffer, size_t len)
+{
+	struct winusb_device_priv *priv = _device_priv(dev);
+	unsigned char *config_desc;
+	int r;
+
+	if (priv->active_config == 0)
+		return LIBUSB_ERROR_NOT_FOUND;
+
+	r = winusb_get_config_descriptor_by_value(dev, priv->active_config, &config_desc);
+	if (r < 0)
+		return r;
+
+	len = MIN((size_t)r, len);
+	memcpy(buffer, config_desc, len);
+	return (int)len;
+}
+
+static int winusb_open(struct libusb_device_handle *dev_handle)
+{
+	struct winusb_device_priv *priv = _device_priv(dev_handle->dev);
+
+	CHECK_SUPPORTED_API(priv->apib, open);
+
+	return priv->apib->open(SUB_API_NOTSET, dev_handle);
+}
+
+static void winusb_close(struct libusb_device_handle *dev_handle)
+{
+	struct winusb_device_priv *priv = _device_priv(dev_handle->dev);
+
+	if (priv->apib->close)
+		priv->apib->close(SUB_API_NOTSET, dev_handle);
+}
+
+static int winusb_get_configuration(struct libusb_device_handle *dev_handle, int *config)
+{
+	struct winusb_device_priv *priv = _device_priv(dev_handle->dev);
+
+	if (priv->active_config == 0) {
+		*config = 0;
+		return LIBUSB_ERROR_NOT_FOUND;
+	}
+
+	*config = priv->active_config;
+	return LIBUSB_SUCCESS;
+}
+
+/*
+ * from http://msdn.microsoft.com/en-us/library/ms793522.aspx: "The port driver
+ * does not currently expose a service that allows higher-level drivers to set
+ * the configuration."
+ */
+static int winusb_set_configuration(struct libusb_device_handle *dev_handle, int config)
+{
+	struct winusb_device_priv *priv = _device_priv(dev_handle->dev);
+	int r = LIBUSB_SUCCESS;
+
+	if (config >= USB_MAXCONFIG)
+		return LIBUSB_ERROR_INVALID_PARAM;
+
+	r = libusb_control_transfer(dev_handle, LIBUSB_ENDPOINT_OUT |
+		LIBUSB_REQUEST_TYPE_STANDARD | LIBUSB_RECIPIENT_DEVICE,
+		LIBUSB_REQUEST_SET_CONFIGURATION, (uint16_t)config,
+		0, NULL, 0, 1000);
+
+	if (r == LIBUSB_SUCCESS)
+		priv->active_config = (uint8_t)config;
+
+	return r;
+}
+
+static int winusb_claim_interface(struct libusb_device_handle *dev_handle, int iface)
+{
+	struct winusb_device_priv *priv = _device_priv(dev_handle->dev);
+	int r;
+
+	CHECK_SUPPORTED_API(priv->apib, claim_interface);
+
+	safe_free(priv->usb_interface[iface].endpoint);
+	priv->usb_interface[iface].nb_endpoints = 0;
+
+	r = priv->apib->claim_interface(SUB_API_NOTSET, dev_handle, iface);
+
+	if (r == LIBUSB_SUCCESS)
+		r = windows_assign_endpoints(dev_handle, iface, 0);
+
+	return r;
+}
+
+static int winusb_set_interface_altsetting(struct libusb_device_handle *dev_handle, int iface, int altsetting)
+{
+	struct winusb_device_priv *priv = _device_priv(dev_handle->dev);
+	int r;
+
+	CHECK_SUPPORTED_API(priv->apib, set_interface_altsetting);
+
+	safe_free(priv->usb_interface[iface].endpoint);
+	priv->usb_interface[iface].nb_endpoints = 0;
+
+	r = priv->apib->set_interface_altsetting(SUB_API_NOTSET, dev_handle, iface, altsetting);
+
+	if (r == LIBUSB_SUCCESS)
+		r = windows_assign_endpoints(dev_handle, iface, altsetting);
+
+	return r;
+}
+
+static int winusb_release_interface(struct libusb_device_handle *dev_handle, int iface)
+{
+	struct winusb_device_priv *priv = _device_priv(dev_handle->dev);
+
+	CHECK_SUPPORTED_API(priv->apib, release_interface);
+
+	return priv->apib->release_interface(SUB_API_NOTSET, dev_handle, iface);
+}
+
+static int winusb_clear_halt(struct libusb_device_handle *dev_handle, unsigned char endpoint)
+{
+	struct winusb_device_priv *priv = _device_priv(dev_handle->dev);
+
+	CHECK_SUPPORTED_API(priv->apib, clear_halt);
+
+	return priv->apib->clear_halt(SUB_API_NOTSET, dev_handle, endpoint);
+}
+
+static int winusb_reset_device(struct libusb_device_handle *dev_handle)
+{
+	struct winusb_device_priv *priv = _device_priv(dev_handle->dev);
+
+	CHECK_SUPPORTED_API(priv->apib, reset_device);
+
+	return priv->apib->reset_device(SUB_API_NOTSET, dev_handle);
+}
+
+static void winusb_destroy_device(struct libusb_device *dev)
+{
+	winusb_device_priv_release(dev);
+}
+
+static void winusb_clear_transfer_priv(struct usbi_transfer *itransfer)
+{
+	struct winusb_transfer_priv *transfer_priv = usbi_transfer_get_os_priv(itransfer);
+
+	usbi_close(transfer_priv->pollable_fd.fd);
+	transfer_priv->pollable_fd = INVALID_WINFD;
+	transfer_priv->handle = NULL;
+	safe_free(transfer_priv->hid_buffer);
+	safe_free(transfer_priv->iso_context);
+
+	// When auto claim is in use, attempt to release the auto-claimed interface
+	auto_release(itransfer);
+}
+
+static int do_submit_transfer(struct usbi_transfer *itransfer, short events,
+	int (*transfer_fn)(int, struct usbi_transfer *))
+{
+	struct libusb_context *ctx = ITRANSFER_CTX(itransfer);
+	struct winusb_transfer_priv *transfer_priv = usbi_transfer_get_os_priv(itransfer);
+	struct winfd wfd;
+	int r;
+
+	wfd = usbi_create_fd();
+	if (wfd.fd < 0)
+		return LIBUSB_ERROR_NO_MEM;
+
+	r = usbi_add_pollfd(ctx, wfd.fd, events);
+	if (r) {
+		usbi_close(wfd.fd);
+		return r;
+	}
+
+	// Use transfer_priv to store data needed for async polling
+	transfer_priv->pollable_fd = wfd;
+
+	r = transfer_fn(SUB_API_NOTSET, itransfer);
+
+	if ((r != LIBUSB_SUCCESS) && (r != LIBUSB_ERROR_OVERFLOW)) {
+		usbi_remove_pollfd(ctx, wfd.fd);
+		usbi_close(wfd.fd);
+		transfer_priv->pollable_fd = INVALID_WINFD;
+	}
+
+	return r;
+}
+
+static int winusb_submit_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct winusb_device_priv *priv = _device_priv(transfer->dev_handle->dev);
+	int (*transfer_fn)(int, struct usbi_transfer *);
+	short events;
+
+	switch (transfer->type) {
+	case LIBUSB_TRANSFER_TYPE_CONTROL:
+		events = (transfer->buffer[0] & LIBUSB_ENDPOINT_IN) ? POLLIN : POLLOUT;
+		transfer_fn = priv->apib->submit_control_transfer;
+		break;
+	case LIBUSB_TRANSFER_TYPE_BULK:
+	case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+		if (IS_XFEROUT(transfer) && (transfer->flags & LIBUSB_TRANSFER_ADD_ZERO_PACKET))
+			return LIBUSB_ERROR_NOT_SUPPORTED;
+		events = IS_XFERIN(transfer) ? POLLIN : POLLOUT;
+		transfer_fn = priv->apib->submit_bulk_transfer;
+		break;
+	case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+		events = IS_XFERIN(transfer) ? POLLIN : POLLOUT;
+		transfer_fn = priv->apib->submit_iso_transfer;
+		break;
+	case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
+		return LIBUSB_ERROR_NOT_SUPPORTED;
+	default:
+		usbi_err(TRANSFER_CTX(transfer), "unknown endpoint type %d", transfer->type);
+		return LIBUSB_ERROR_INVALID_PARAM;
+	}
+
+	if (transfer_fn == NULL) {
+		usbi_warn(TRANSFER_CTX(transfer),
+			"unsupported transfer type %d (unrecognized device driver)",
+			transfer->type);
+		return LIBUSB_ERROR_NOT_SUPPORTED;
+	}
+
+	return do_submit_transfer(itransfer, events, transfer_fn);
+}
+
+static int windows_abort_control(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct winusb_device_priv *priv = _device_priv(transfer->dev_handle->dev);
+
+	CHECK_SUPPORTED_API(priv->apib, abort_control);
+
+	return priv->apib->abort_control(SUB_API_NOTSET, itransfer);
+}
+
+static int windows_abort_transfers(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct winusb_device_priv *priv = _device_priv(transfer->dev_handle->dev);
+
+	CHECK_SUPPORTED_API(priv->apib, abort_transfers);
+
+	return priv->apib->abort_transfers(SUB_API_NOTSET, itransfer);
+}
+
+static int winusb_cancel_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+
+	switch (transfer->type) {
+	case LIBUSB_TRANSFER_TYPE_CONTROL:
+		return windows_abort_control(itransfer);
+	case LIBUSB_TRANSFER_TYPE_BULK:
+	case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+	case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+		return windows_abort_transfers(itransfer);
+	case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
+		return LIBUSB_ERROR_NOT_SUPPORTED;
+	default:
+		usbi_err(ITRANSFER_CTX(itransfer), "unknown endpoint type %d", transfer->type);
+		return LIBUSB_ERROR_INVALID_PARAM;
+	}
+}
+
+static int winusb_copy_transfer_data(struct usbi_transfer *itransfer, uint32_t io_size)
+{
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct winusb_device_priv *priv = _device_priv(transfer->dev_handle->dev);
+	return priv->apib->copy_transfer_data(SUB_API_NOTSET, itransfer, io_size);
+}
+
+static int winusb_get_transfer_fd(struct usbi_transfer *itransfer)
+{
+	struct winusb_transfer_priv *transfer_priv = usbi_transfer_get_os_priv(itransfer);
+	return transfer_priv->pollable_fd.fd;
+}
+
+static void winusb_get_overlapped_result(struct usbi_transfer *itransfer,
+	DWORD *io_result, DWORD *io_size)
+{
+	struct winusb_transfer_priv *transfer_priv = usbi_transfer_get_os_priv(itransfer);
+	struct winfd *pollable_fd = &transfer_priv->pollable_fd;
+
+	if (HasOverlappedIoCompletedSync(pollable_fd->overlapped)) {
+		*io_result = NO_ERROR;
+		*io_size = (DWORD)pollable_fd->overlapped->InternalHigh;
+	} else if (GetOverlappedResult(transfer_priv->handle, pollable_fd->overlapped, io_size, FALSE)) {
+		// Regular async overlapped
+		*io_result = NO_ERROR;
+	} else {
+		*io_result = GetLastError();
+	}
+}
+
+// NB: MSVC6 does not support named initializers.
+const struct windows_backend winusb_backend = {
+	winusb_init,
+	winusb_exit,
+	winusb_get_device_list,
+	winusb_open,
+	winusb_close,
+	winusb_get_device_descriptor,
+	winusb_get_active_config_descriptor,
+	winusb_get_config_descriptor,
+	winusb_get_config_descriptor_by_value,
+	winusb_get_configuration,
+	winusb_set_configuration,
+	winusb_claim_interface,
+	winusb_release_interface,
+	winusb_set_interface_altsetting,
+	winusb_clear_halt,
+	winusb_reset_device,
+	winusb_destroy_device,
+	winusb_submit_transfer,
+	winusb_cancel_transfer,
+	winusb_clear_transfer_priv,
+	winusb_copy_transfer_data,
+	winusb_get_transfer_fd,
+	winusb_get_overlapped_result,
+};
+
+/*
+ * USB API backends
+ */
+
+static const char * const composite_driver_names[] = {"USBCCGP"};
+static const char * const winusbx_driver_names[] = {"libusbK", "libusb0", "WinUSB"};
+static const char * const hid_driver_names[] = {"HIDUSB", "MOUHID", "KBDHID"};
+const struct windows_usb_api_backend usb_api_backend[USB_API_MAX] = {
+	{
+		USB_API_UNSUPPORTED,
+		"Unsupported API",
+		// No supported operations
+	},
+	{
+		USB_API_HUB,
+		"HUB API",
+		// No supported operations
+	},
+	{
+		USB_API_COMPOSITE,
+		"Composite API",
+		composite_driver_names,
+		ARRAYSIZE(composite_driver_names),
+		NULL,	/* init */
+		NULL,	/* exit */
+		composite_open,
+		composite_close,
+		NULL,	/* configure_endpoints */
+		composite_claim_interface,
+		composite_set_interface_altsetting,
+		composite_release_interface,
+		composite_clear_halt,
+		composite_reset_device,
+		composite_submit_bulk_transfer,
+		composite_submit_iso_transfer,
+		composite_submit_control_transfer,
+		composite_abort_control,
+		composite_abort_transfers,
+		composite_copy_transfer_data,
+	},
+	{
+		USB_API_WINUSBX,
+		"WinUSB-like APIs",
+		winusbx_driver_names,
+		ARRAYSIZE(winusbx_driver_names),
+		winusbx_init,
+		winusbx_exit,
+		winusbx_open,
+		winusbx_close,
+		winusbx_configure_endpoints,
+		winusbx_claim_interface,
+		winusbx_set_interface_altsetting,
+		winusbx_release_interface,
+		winusbx_clear_halt,
+		winusbx_reset_device,
+		winusbx_submit_bulk_transfer,
+		winusbx_submit_iso_transfer,
+		winusbx_submit_control_transfer,
+		winusbx_abort_control,
+		winusbx_abort_transfers,
+		winusbx_copy_transfer_data,
+	},
+	{
+		USB_API_HID,
+		"HID API",
+		// No supported operations
+	},
+};
+
+
+/*
+ * WinUSB-like (WinUSB, libusb0/libusbK through libusbk DLL) API functions
+ */
+#define WinUSBX_Set(fn)										\
+	do {											\
+		if (native_winusb)								\
+			WinUSBX[i].fn = (WinUsb_##fn##_t)GetProcAddress(h, "WinUsb_" #fn);	\
+		else										\
+			pLibK_GetProcAddress((PVOID *)&WinUSBX[i].fn, i, KUSB_FNID_##fn);	\
+	} while (0)
+
+static int winusbx_init(struct libusb_context *ctx)
+{
+	HMODULE h;
+	bool native_winusb;
+	int i;
+	KLIB_VERSION LibK_Version;
+	LibK_GetProcAddress_t pLibK_GetProcAddress = NULL;
+	LibK_GetVersion_t pLibK_GetVersion;
+
+	h = LoadLibraryA("libusbK");
+
+	if (h == NULL) {
+		usbi_info(ctx, "libusbK DLL is not available, will use native WinUSB");
+		h = LoadLibraryA("WinUSB");
+
+		if (h == NULL) {
+			usbi_warn(ctx, "WinUSB DLL is not available either, "
+				"you will not be able to access devices outside of enumeration");
+			return LIBUSB_ERROR_NOT_FOUND;
+		}
+	} else {
+		usbi_dbg("using libusbK DLL for universal access");
+		pLibK_GetVersion = (LibK_GetVersion_t)GetProcAddress(h, "LibK_GetVersion");
+		if (pLibK_GetVersion != NULL) {
+			pLibK_GetVersion(&LibK_Version);
+			usbi_dbg("libusbK version: %d.%d.%d.%d", LibK_Version.Major, LibK_Version.Minor,
+				LibK_Version.Micro, LibK_Version.Nano);
+		}
+		pLibK_GetProcAddress = (LibK_GetProcAddress_t)GetProcAddress(h, "LibK_GetProcAddress");
+		if (pLibK_GetProcAddress == NULL) {
+			usbi_err(ctx, "LibK_GetProcAddress() not found in libusbK DLL");
+			FreeLibrary(h);
+			return LIBUSB_ERROR_NOT_FOUND;
+		}
+	}
+
+	native_winusb = (pLibK_GetProcAddress == NULL);
+	for (i = 0; i < SUB_API_MAX; i++) {
+		WinUSBX_Set(AbortPipe);
+		WinUSBX_Set(ControlTransfer);
+		WinUSBX_Set(FlushPipe);
+		WinUSBX_Set(Free);
+		WinUSBX_Set(GetAssociatedInterface);
+		WinUSBX_Set(Initialize);
+		WinUSBX_Set(ReadPipe);
+		if (!native_winusb)
+			WinUSBX_Set(ResetDevice);
+		WinUSBX_Set(ResetPipe);
+		WinUSBX_Set(SetCurrentAlternateSetting);
+		WinUSBX_Set(SetPipePolicy);
+		WinUSBX_Set(WritePipe);
+		WinUSBX_Set(IsoReadPipe);
+		WinUSBX_Set(IsoWritePipe);
+
+		if (WinUSBX[i].Initialize != NULL) {
+			WinUSBX[i].initialized = true;
+			// Assume driver supports CancelIoEx() if it is available
+			WinUSBX[i].CancelIoEx_supported = (pCancelIoEx != NULL);
+			usbi_dbg("initalized sub API %s", winusbx_driver_names[i]);
+		} else {
+			usbi_warn(ctx, "Failed to initalize sub API %s", winusbx_driver_names[i]);
+			WinUSBX[i].initialized = false;
+		}
+	}
+
+	WinUSBX_handle = h;
+	return LIBUSB_SUCCESS;
+}
+
+static void winusbx_exit(void)
+{
+	if (WinUSBX_handle != NULL) {
+		FreeLibrary(WinUSBX_handle);
+		WinUSBX_handle = NULL;
+
+		/* Reset the WinUSBX API structures */
+		memset(&WinUSBX, 0, sizeof(WinUSBX));
+	}
+}
+
+// NB: open and close must ensure that they only handle interface of
+// the right API type, as these functions can be called wholesale from
+// composite_open(), with interfaces belonging to different APIs
+static int winusbx_open(int sub_api, struct libusb_device_handle *dev_handle)
+{
+	struct libusb_context *ctx = DEVICE_CTX(dev_handle->dev);
+	struct winusb_device_priv *priv = _device_priv(dev_handle->dev);
+	struct winusb_device_handle_priv *handle_priv = _device_handle_priv(dev_handle);
+	HANDLE file_handle;
+	int i;
+
+	CHECK_WINUSBX_AVAILABLE(sub_api);
+
+	// WinUSB requires a separate handle for each interface
+	for (i = 0; i < USB_MAXINTERFACES; i++) {
+		if ((priv->usb_interface[i].path != NULL)
+				&& (priv->usb_interface[i].apib->id == USB_API_WINUSBX)) {
+			file_handle = CreateFileA(priv->usb_interface[i].path, GENERIC_WRITE | GENERIC_READ, FILE_SHARE_WRITE | FILE_SHARE_READ,
+				NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL);
+			if (file_handle == INVALID_HANDLE_VALUE) {
+				usbi_err(ctx, "could not open device %s (interface %d): %s", priv->usb_interface[i].path, i, windows_error_str(0));
+				switch (GetLastError()) {
+				case ERROR_FILE_NOT_FOUND: // The device was disconnected
+					return LIBUSB_ERROR_NO_DEVICE;
+				case ERROR_ACCESS_DENIED:
+					return LIBUSB_ERROR_ACCESS;
+				default:
+					return LIBUSB_ERROR_IO;
+				}
+			}
+			handle_priv->interface_handle[i].dev_handle = file_handle;
+		}
+	}
+	return LIBUSB_SUCCESS;
+}
+
+static void winusbx_close(int sub_api, struct libusb_device_handle *dev_handle)
+{
+	struct winusb_device_handle_priv *handle_priv = _device_handle_priv(dev_handle);
+	struct winusb_device_priv *priv = _device_priv(dev_handle->dev);
+	HANDLE handle;
+	int i;
+
+	if (sub_api == SUB_API_NOTSET)
+		sub_api = priv->sub_api;
+
+	if (!WinUSBX[sub_api].initialized)
+		return;
+
+	if (priv->apib->id == USB_API_COMPOSITE) {
+		// If this is a composite device, just free and close all WinUSB-like
+		// interfaces directly (each is independent and not associated with another)
+		for (i = 0; i < USB_MAXINTERFACES; i++) {
+			if (priv->usb_interface[i].apib->id == USB_API_WINUSBX) {
+				handle = handle_priv->interface_handle[i].api_handle;
+				if (HANDLE_VALID(handle))
+					WinUSBX[sub_api].Free(handle);
+
+				handle = handle_priv->interface_handle[i].dev_handle;
+				if (HANDLE_VALID(handle))
+					CloseHandle(handle);
+			}
+		}
+	} else {
+		// If this is a WinUSB device, free all interfaces above interface 0,
+		// then free and close interface 0 last
+		for (i = 1; i < USB_MAXINTERFACES; i++) {
+			handle = handle_priv->interface_handle[i].api_handle;
+			if (HANDLE_VALID(handle))
+				WinUSBX[sub_api].Free(handle);
+		}
+		handle = handle_priv->interface_handle[0].api_handle;
+		if (HANDLE_VALID(handle))
+			WinUSBX[sub_api].Free(handle);
+
+		handle = handle_priv->interface_handle[0].dev_handle;
+		if (HANDLE_VALID(handle))
+			CloseHandle(handle);
+	}
+}
+
+static int winusbx_configure_endpoints(int sub_api, struct libusb_device_handle *dev_handle, int iface)
+{
+	struct winusb_device_handle_priv *handle_priv = _device_handle_priv(dev_handle);
+	struct winusb_device_priv *priv = _device_priv(dev_handle->dev);
+	HANDLE winusb_handle = handle_priv->interface_handle[iface].api_handle;
+	UCHAR policy;
+	ULONG timeout = 0;
+	uint8_t endpoint_address;
+	int i;
+
+	CHECK_WINUSBX_AVAILABLE(sub_api);
+
+	// With handle and enpoints set (in parent), we can setup the default pipe properties
+	// see http://download.microsoft.com/download/D/1/D/D1DD7745-426B-4CC3-A269-ABBBE427C0EF/DVC-T705_DDC08.pptx
+	for (i = -1; i < priv->usb_interface[iface].nb_endpoints; i++) {
+		endpoint_address = (i == -1) ? 0 : priv->usb_interface[iface].endpoint[i];
+		if (!WinUSBX[sub_api].SetPipePolicy(winusb_handle, endpoint_address,
+			PIPE_TRANSFER_TIMEOUT, sizeof(ULONG), &timeout))
+			usbi_dbg("failed to set PIPE_TRANSFER_TIMEOUT for control endpoint %02X", endpoint_address);
+
+		if ((i == -1) || (sub_api == SUB_API_LIBUSB0))
+			continue; // Other policies don't apply to control endpoint or libusb0
+
+		policy = false;
+		if (!WinUSBX[sub_api].SetPipePolicy(winusb_handle, endpoint_address,
+			SHORT_PACKET_TERMINATE, sizeof(UCHAR), &policy))
+			usbi_dbg("failed to disable SHORT_PACKET_TERMINATE for endpoint %02X", endpoint_address);
+
+		if (!WinUSBX[sub_api].SetPipePolicy(winusb_handle, endpoint_address,
+			IGNORE_SHORT_PACKETS, sizeof(UCHAR), &policy))
+			usbi_dbg("failed to disable IGNORE_SHORT_PACKETS for endpoint %02X", endpoint_address);
+
+		policy = true;
+		/* ALLOW_PARTIAL_READS must be enabled due to likely libusbK bug. See:
+		   https://sourceforge.net/mailarchive/message.php?msg_id=29736015 */
+		if (!WinUSBX[sub_api].SetPipePolicy(winusb_handle, endpoint_address,
+			ALLOW_PARTIAL_READS, sizeof(UCHAR), &policy))
+			usbi_dbg("failed to enable ALLOW_PARTIAL_READS for endpoint %02X", endpoint_address);
+
+		if (!WinUSBX[sub_api].SetPipePolicy(winusb_handle, endpoint_address,
+			AUTO_CLEAR_STALL, sizeof(UCHAR), &policy))
+			usbi_dbg("failed to enable AUTO_CLEAR_STALL for endpoint %02X", endpoint_address);
+	}
+
+	return LIBUSB_SUCCESS;
+}
+
+static int winusbx_claim_interface(int sub_api, struct libusb_device_handle *dev_handle, int iface)
+{
+	struct libusb_context *ctx = DEVICE_CTX(dev_handle->dev);
+	struct winusb_device_handle_priv *handle_priv = _device_handle_priv(dev_handle);
+	struct winusb_device_priv *priv = _device_priv(dev_handle->dev);
+	bool is_using_usbccgp = (priv->apib->id == USB_API_COMPOSITE);
+	SP_DEVICE_INTERFACE_DETAIL_DATA_A *dev_interface_details = NULL;
+	HDEVINFO dev_info = INVALID_HANDLE_VALUE;
+	SP_DEVINFO_DATA dev_info_data;
+	char *dev_path_no_guid = NULL;
+	char filter_path[] = "\\\\.\\libusb0-0000";
+	bool found_filter = false;
+	HANDLE file_handle, winusb_handle;
+	DWORD err;
+	int i;
+
+	CHECK_WINUSBX_AVAILABLE(sub_api);
+
+	// If the device is composite, but using the default Windows composite parent driver (usbccgp)
+	// or if it's the first WinUSB-like interface, we get a handle through Initialize().
+	if ((is_using_usbccgp) || (iface == 0)) {
+		// composite device (independent interfaces) or interface 0
+		file_handle = handle_priv->interface_handle[iface].dev_handle;
+		if (!HANDLE_VALID(file_handle))
+			return LIBUSB_ERROR_NOT_FOUND;
+
+		if (!WinUSBX[sub_api].Initialize(file_handle, &winusb_handle)) {
+			handle_priv->interface_handle[iface].api_handle = INVALID_HANDLE_VALUE;
+			err = GetLastError();
+			switch (err) {
+			case ERROR_BAD_COMMAND:
+				// The device was disconnected
+				usbi_err(ctx, "could not access interface %d: %s", iface, windows_error_str(0));
+				return LIBUSB_ERROR_NO_DEVICE;
+			default:
+				// it may be that we're using the libusb0 filter driver.
+				// TODO: can we move this whole business into the K/0 DLL?
+				for (i = 0; ; i++) {
+					safe_free(dev_interface_details);
+					safe_free(dev_path_no_guid);
+
+					dev_interface_details = get_interface_details_filter(ctx, &dev_info, &dev_info_data, &GUID_DEVINTERFACE_LIBUSB0_FILTER, i, filter_path);
+					if ((found_filter) || (dev_interface_details == NULL))
+						break;
+
+					// ignore GUID part
+					dev_path_no_guid = sanitize_path(strtok(dev_interface_details->DevicePath, "{"));
+					if (dev_path_no_guid == NULL)
+						continue;
+
+					if (strncmp(dev_path_no_guid, priv->usb_interface[iface].path, strlen(dev_path_no_guid)) == 0) {
+						file_handle = CreateFileA(filter_path, GENERIC_WRITE | GENERIC_READ, FILE_SHARE_WRITE | FILE_SHARE_READ,
+							NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL);
+						if (file_handle != INVALID_HANDLE_VALUE) {
+							if (WinUSBX[sub_api].Initialize(file_handle, &winusb_handle)) {
+								// Replace the existing file handle with the working one
+								CloseHandle(handle_priv->interface_handle[iface].dev_handle);
+								handle_priv->interface_handle[iface].dev_handle = file_handle;
+								found_filter = true;
+							} else {
+								usbi_err(ctx, "could not initialize filter driver for %s", filter_path);
+								CloseHandle(file_handle);
+							}
+						} else {
+							usbi_err(ctx, "could not open device %s: %s", filter_path, windows_error_str(0));
+						}
+					}
+				}
+				free(dev_interface_details);
+				if (!found_filter) {
+					usbi_err(ctx, "could not access interface %d: %s", iface, windows_error_str(err));
+					return LIBUSB_ERROR_ACCESS;
+				}
+			}
+		}
+		handle_priv->interface_handle[iface].api_handle = winusb_handle;
+	} else {
+		// For all other interfaces, use GetAssociatedInterface()
+		winusb_handle = handle_priv->interface_handle[0].api_handle;
+		// It is a requirement for multiple interface devices on Windows that, to you
+		// must first claim the first interface before you claim the others
+		if (!HANDLE_VALID(winusb_handle)) {
+			file_handle = handle_priv->interface_handle[0].dev_handle;
+			if (WinUSBX[sub_api].Initialize(file_handle, &winusb_handle)) {
+				handle_priv->interface_handle[0].api_handle = winusb_handle;
+				usbi_warn(ctx, "auto-claimed interface 0 (required to claim %d with WinUSB)", iface);
+			} else {
+				usbi_warn(ctx, "failed to auto-claim interface 0 (required to claim %d with WinUSB): %s", iface, windows_error_str(0));
+				return LIBUSB_ERROR_ACCESS;
+			}
+		}
+		if (!WinUSBX[sub_api].GetAssociatedInterface(winusb_handle, (UCHAR)(iface - 1),
+			&handle_priv->interface_handle[iface].api_handle)) {
+			handle_priv->interface_handle[iface].api_handle = INVALID_HANDLE_VALUE;
+			switch (GetLastError()) {
+			case ERROR_NO_MORE_ITEMS:   // invalid iface
+				return LIBUSB_ERROR_NOT_FOUND;
+			case ERROR_BAD_COMMAND:     // The device was disconnected
+				return LIBUSB_ERROR_NO_DEVICE;
+			case ERROR_ALREADY_EXISTS:  // already claimed
+				return LIBUSB_ERROR_BUSY;
+			default:
+				usbi_err(ctx, "could not claim interface %d: %s", iface, windows_error_str(0));
+				return LIBUSB_ERROR_ACCESS;
+			}
+		}
+	}
+	usbi_dbg("claimed interface %d", iface);
+	handle_priv->active_interface = iface;
+
+	return LIBUSB_SUCCESS;
+}
+
+static int winusbx_release_interface(int sub_api, struct libusb_device_handle *dev_handle, int iface)
+{
+	struct winusb_device_handle_priv *handle_priv = _device_handle_priv(dev_handle);
+	struct winusb_device_priv *priv = _device_priv(dev_handle->dev);
+	HANDLE winusb_handle;
+
+	CHECK_WINUSBX_AVAILABLE(sub_api);
+
+	winusb_handle = handle_priv->interface_handle[iface].api_handle;
+	if (!HANDLE_VALID(winusb_handle))
+		return LIBUSB_ERROR_NOT_FOUND;
+
+	WinUSBX[sub_api].Free(winusb_handle);
+	handle_priv->interface_handle[iface].api_handle = INVALID_HANDLE_VALUE;
+
+	return LIBUSB_SUCCESS;
+}
+
+/*
+ * Return the first valid interface (of the same API type), for control transfers
+ */
+static int get_valid_interface(struct libusb_device_handle *dev_handle, int api_id)
+{
+	struct winusb_device_handle_priv *handle_priv = _device_handle_priv(dev_handle);
+	struct winusb_device_priv *priv = _device_priv(dev_handle->dev);
+	int i;
+
+	if ((api_id < USB_API_WINUSBX) || (api_id > USB_API_HID)) {
+		usbi_dbg("unsupported API ID");
+		return -1;
+	}
+
+	for (i = 0; i < USB_MAXINTERFACES; i++) {
+		if (HANDLE_VALID(handle_priv->interface_handle[i].dev_handle)
+				&& HANDLE_VALID(handle_priv->interface_handle[i].api_handle)
+				&& (priv->usb_interface[i].apib->id == api_id))
+			return i;
+	}
+
+	return -1;
+}
+
+/*
+ * Lookup interface by endpoint address. -1 if not found
+ */
+static int interface_by_endpoint(struct winusb_device_priv *priv,
+	struct winusb_device_handle_priv *handle_priv, uint8_t endpoint_address)
+{
+	int i, j;
+
+	for (i = 0; i < USB_MAXINTERFACES; i++) {
+		if (!HANDLE_VALID(handle_priv->interface_handle[i].api_handle))
+			continue;
+		if (priv->usb_interface[i].endpoint == NULL)
+			continue;
+		for (j = 0; j < priv->usb_interface[i].nb_endpoints; j++) {
+			if (priv->usb_interface[i].endpoint[j] == endpoint_address)
+				return i;
+		}
+	}
+
+	return -1;
+}
+
+static int winusbx_submit_control_transfer(int sub_api, struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct libusb_context *ctx = DEVICE_CTX(transfer->dev_handle->dev);
+	struct winusb_device_priv *priv = _device_priv(transfer->dev_handle->dev);
+	struct winusb_transfer_priv *transfer_priv = usbi_transfer_get_os_priv(itransfer);
+	struct winusb_device_handle_priv *handle_priv = _device_handle_priv(transfer->dev_handle);
+	PWINUSB_SETUP_PACKET setup = (PWINUSB_SETUP_PACKET)transfer->buffer;
+	ULONG size;
+	HANDLE winusb_handle;
+	OVERLAPPED *overlapped;
+	int current_interface;
+
+	CHECK_WINUSBX_AVAILABLE(sub_api);
+
+	size = transfer->length - LIBUSB_CONTROL_SETUP_SIZE;
+
+	// Windows places upper limits on the control transfer size
+	// See: https://msdn.microsoft.com/en-us/library/windows/hardware/ff538112.aspx
+	if (size > MAX_CTRL_BUFFER_LENGTH)
+		return LIBUSB_ERROR_INVALID_PARAM;
+
+	current_interface = get_valid_interface(transfer->dev_handle, USB_API_WINUSBX);
+	if (current_interface < 0) {
+		if (auto_claim(transfer, &current_interface, USB_API_WINUSBX) != LIBUSB_SUCCESS)
+			return LIBUSB_ERROR_NOT_FOUND;
+	}
+
+	usbi_dbg("will use interface %d", current_interface);
+
+	transfer_priv->handle = winusb_handle = handle_priv->interface_handle[current_interface].api_handle;
+	overlapped = transfer_priv->pollable_fd.overlapped;
+
+	// Sending of set configuration control requests from WinUSB creates issues
+	if ((LIBUSB_REQ_TYPE(setup->RequestType) == LIBUSB_REQUEST_TYPE_STANDARD)
+			&& (setup->Request == LIBUSB_REQUEST_SET_CONFIGURATION)) {
+		if (setup->Value != priv->active_config) {
+			usbi_warn(ctx, "cannot set configuration other than the default one");
+			return LIBUSB_ERROR_INVALID_PARAM;
+		}
+		windows_force_sync_completion(overlapped, 0);
+	} else {
+		if (!WinUSBX[sub_api].ControlTransfer(winusb_handle, *setup, transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE, size, NULL, overlapped)) {
+			if (GetLastError() != ERROR_IO_PENDING) {
+				usbi_warn(ctx, "ControlTransfer failed: %s", windows_error_str(0));
+				return LIBUSB_ERROR_IO;
+			}
+		} else {
+			windows_force_sync_completion(overlapped, size);
+		}
+	}
+
+	transfer_priv->interface_number = (uint8_t)current_interface;
+
+	return LIBUSB_SUCCESS;
+}
+
+static int winusbx_set_interface_altsetting(int sub_api, struct libusb_device_handle *dev_handle, int iface, int altsetting)
+{
+	struct libusb_context *ctx = DEVICE_CTX(dev_handle->dev);
+	struct winusb_device_handle_priv *handle_priv = _device_handle_priv(dev_handle);
+	struct winusb_device_priv *priv = _device_priv(dev_handle->dev);
+	HANDLE winusb_handle;
+
+	CHECK_WINUSBX_AVAILABLE(sub_api);
+
+	if (altsetting > 255)
+		return LIBUSB_ERROR_INVALID_PARAM;
+
+	winusb_handle = handle_priv->interface_handle[iface].api_handle;
+	if (!HANDLE_VALID(winusb_handle)) {
+		usbi_err(ctx, "interface must be claimed first");
+		return LIBUSB_ERROR_NOT_FOUND;
+	}
+
+	if (!WinUSBX[sub_api].SetCurrentAlternateSetting(winusb_handle, (UCHAR)altsetting)) {
+		usbi_err(ctx, "SetCurrentAlternateSetting failed: %s", windows_error_str(0));
+		return LIBUSB_ERROR_IO;
+	}
+
+	return LIBUSB_SUCCESS;
+}
+
+static int winusbx_submit_iso_transfer(int sub_api, struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct libusb_context *ctx = DEVICE_CTX(transfer->dev_handle->dev);
+	struct winusb_transfer_priv *transfer_priv = usbi_transfer_get_os_priv(itransfer);
+	struct winusb_device_handle_priv *handle_priv = _device_handle_priv(transfer->dev_handle);
+	struct winusb_device_priv *priv = _device_priv(transfer->dev_handle->dev);
+	HANDLE winusb_handle;
+	OVERLAPPED *overlapped;
+	bool ret;
+	int current_interface;
+	int i;
+	UINT offset;
+	PKISO_CONTEXT iso_context;
+	size_t iso_ctx_size;
+
+	CHECK_WINUSBX_AVAILABLE(sub_api);
+
+	if ((sub_api != SUB_API_LIBUSBK) && (sub_api != SUB_API_LIBUSB0)) {
+		// iso only supported on libusbk-based backends
+		PRINT_UNSUPPORTED_API(submit_iso_transfer);
+		return LIBUSB_ERROR_NOT_SUPPORTED;
+	};
+
+	current_interface = interface_by_endpoint(priv, handle_priv, transfer->endpoint);
+	if (current_interface < 0) {
+		usbi_err(ctx, "unable to match endpoint to an open interface - cancelling transfer");
+		return LIBUSB_ERROR_NOT_FOUND;
+	}
+
+	usbi_dbg("matched endpoint %02X with interface %d", transfer->endpoint, current_interface);
+
+	transfer_priv->handle = winusb_handle = handle_priv->interface_handle[current_interface].api_handle;
+	overlapped = transfer_priv->pollable_fd.overlapped;
+
+	iso_ctx_size = sizeof(KISO_CONTEXT) + (transfer->num_iso_packets * sizeof(KISO_PACKET));
+	transfer_priv->iso_context = iso_context = calloc(1, iso_ctx_size);
+	if (transfer_priv->iso_context == NULL)
+		return LIBUSB_ERROR_NO_MEM;
+
+	// start ASAP
+	iso_context->StartFrame = 0;
+	iso_context->NumberOfPackets = (SHORT)transfer->num_iso_packets;
+
+	// convert the transfer packet lengths to iso_packet offsets
+	offset = 0;
+	for (i = 0; i < transfer->num_iso_packets; i++) {
+		iso_context->IsoPackets[i].offset = offset;
+		offset += transfer->iso_packet_desc[i].length;
+	}
+
+	if (IS_XFERIN(transfer)) {
+		usbi_dbg("reading %d iso packets", transfer->num_iso_packets);
+		ret = WinUSBX[sub_api].IsoReadPipe(winusb_handle, transfer->endpoint, transfer->buffer, transfer->length, overlapped, iso_context);
+	} else {
+		usbi_dbg("writing %d iso packets", transfer->num_iso_packets);
+		ret = WinUSBX[sub_api].IsoWritePipe(winusb_handle, transfer->endpoint, transfer->buffer, transfer->length, overlapped, iso_context);
+	}
+
+	if (!ret) {
+		if (GetLastError() != ERROR_IO_PENDING) {
+			usbi_err(ctx, "IsoReadPipe/IsoWritePipe failed: %s", windows_error_str(0));
+			return LIBUSB_ERROR_IO;
+		}
+	} else {
+		windows_force_sync_completion(overlapped, (ULONG)transfer->length);
+	}
+
+	transfer_priv->interface_number = (uint8_t)current_interface;
+
+	return LIBUSB_SUCCESS;
+}
+
+static int winusbx_submit_bulk_transfer(int sub_api, struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct libusb_context *ctx = DEVICE_CTX(transfer->dev_handle->dev);
+	struct winusb_transfer_priv *transfer_priv = usbi_transfer_get_os_priv(itransfer);
+	struct winusb_device_handle_priv *handle_priv = _device_handle_priv(transfer->dev_handle);
+	struct winusb_device_priv *priv = _device_priv(transfer->dev_handle->dev);
+	HANDLE winusb_handle;
+	OVERLAPPED *overlapped;
+	bool ret;
+	int current_interface;
+
+	CHECK_WINUSBX_AVAILABLE(sub_api);
+
+	current_interface = interface_by_endpoint(priv, handle_priv, transfer->endpoint);
+	if (current_interface < 0) {
+		usbi_err(ctx, "unable to match endpoint to an open interface - cancelling transfer");
+		return LIBUSB_ERROR_NOT_FOUND;
+	}
+
+	usbi_dbg("matched endpoint %02X with interface %d", transfer->endpoint, current_interface);
+
+	transfer_priv->handle = winusb_handle = handle_priv->interface_handle[current_interface].api_handle;
+	overlapped = transfer_priv->pollable_fd.overlapped;
+
+	if (IS_XFERIN(transfer)) {
+		usbi_dbg("reading %d bytes", transfer->length);
+		ret = WinUSBX[sub_api].ReadPipe(winusb_handle, transfer->endpoint, transfer->buffer, transfer->length, NULL, overlapped);
+	} else {
+		usbi_dbg("writing %d bytes", transfer->length);
+		ret = WinUSBX[sub_api].WritePipe(winusb_handle, transfer->endpoint, transfer->buffer, transfer->length, NULL, overlapped);
+	}
+
+	if (!ret) {
+		if (GetLastError() != ERROR_IO_PENDING) {
+			usbi_err(ctx, "ReadPipe/WritePipe failed: %s", windows_error_str(0));
+			return LIBUSB_ERROR_IO;
+		}
+	} else {
+		windows_force_sync_completion(overlapped, (ULONG)transfer->length);
+	}
+
+	transfer_priv->interface_number = (uint8_t)current_interface;
+
+	return LIBUSB_SUCCESS;
+}
+
+static int winusbx_clear_halt(int sub_api, struct libusb_device_handle *dev_handle, unsigned char endpoint)
+{
+	struct libusb_context *ctx = DEVICE_CTX(dev_handle->dev);
+	struct winusb_device_handle_priv *handle_priv = _device_handle_priv(dev_handle);
+	struct winusb_device_priv *priv = _device_priv(dev_handle->dev);
+	HANDLE winusb_handle;
+	int current_interface;
+
+	CHECK_WINUSBX_AVAILABLE(sub_api);
+
+	current_interface = interface_by_endpoint(priv, handle_priv, endpoint);
+	if (current_interface < 0) {
+		usbi_err(ctx, "unable to match endpoint to an open interface - cannot clear");
+		return LIBUSB_ERROR_NOT_FOUND;
+	}
+
+	usbi_dbg("matched endpoint %02X with interface %d", endpoint, current_interface);
+	winusb_handle = handle_priv->interface_handle[current_interface].api_handle;
+
+	if (!WinUSBX[sub_api].ResetPipe(winusb_handle, endpoint)) {
+		usbi_err(ctx, "ResetPipe failed: %s", windows_error_str(0));
+		return LIBUSB_ERROR_NO_DEVICE;
+	}
+
+	return LIBUSB_SUCCESS;
+}
+
+/*
+ * from http://www.winvistatips.com/winusb-bugchecks-t335323.html (confirmed
+ * through testing as well):
+ * "You can not call WinUsb_AbortPipe on control pipe. You can possibly cancel
+ * the control transfer using CancelIo"
+ */
+static int winusbx_abort_control(int sub_api, struct usbi_transfer *itransfer)
+{
+	// Cancelling of the I/O is done in the parent
+	return LIBUSB_SUCCESS;
+}
+
+static int winusbx_abort_transfers(int sub_api, struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct libusb_context *ctx = DEVICE_CTX(transfer->dev_handle->dev);
+	struct winusb_device_handle_priv *handle_priv = _device_handle_priv(transfer->dev_handle);
+	struct winusb_transfer_priv *transfer_priv = usbi_transfer_get_os_priv(itransfer);
+	struct winusb_device_priv *priv = _device_priv(transfer->dev_handle->dev);
+	HANDLE handle;
+	int current_interface;
+
+	CHECK_WINUSBX_AVAILABLE(sub_api);
+
+	current_interface = transfer_priv->interface_number;
+	if ((current_interface < 0) || (current_interface >= USB_MAXINTERFACES)) {
+		usbi_err(ctx, "program assertion failed: invalid interface_number");
+		return LIBUSB_ERROR_NOT_FOUND;
+	}
+	usbi_dbg("will use interface %d", current_interface);
+
+	if (WinUSBX[sub_api].CancelIoEx_supported) {
+		// Try to use CancelIoEx if available to cancel just a single transfer
+		handle = handle_priv->interface_handle[current_interface].dev_handle;
+		if (pCancelIoEx(handle, transfer_priv->pollable_fd.overlapped))
+			return LIBUSB_SUCCESS;
+		else if (GetLastError() == ERROR_NOT_FOUND)
+			return LIBUSB_ERROR_NOT_FOUND;
+
+		// Not every driver implements the necessary functionality for CancelIoEx
+		usbi_warn(ctx, "CancelIoEx not supported for sub API %s", winusbx_driver_names[sub_api]);
+		WinUSBX[sub_api].CancelIoEx_supported = false;
+	}
+
+	handle = handle_priv->interface_handle[current_interface].api_handle;
+	if (!WinUSBX[sub_api].AbortPipe(handle, transfer->endpoint)) {
+		usbi_err(ctx, "AbortPipe failed: %s", windows_error_str(0));
+		return LIBUSB_ERROR_NO_DEVICE;
+	}
+
+	return LIBUSB_SUCCESS;
+}
+
+/*
+ * from the "How to Use WinUSB to Communicate with a USB Device" Microsoft white paper
+ * (http://www.microsoft.com/whdc/connect/usb/winusb_howto.mspx):
+ * "WinUSB does not support host-initiated reset port and cycle port operations" and
+ * IOCTL_INTERNAL_USB_CYCLE_PORT is only available in kernel mode and the
+ * IOCTL_USB_HUB_CYCLE_PORT ioctl was removed from Vista => the best we can do is
+ * cycle the pipes (and even then, the control pipe can not be reset using WinUSB)
+ */
+// TODO: (post hotplug): see if we can force eject the device and redetect it (reuse hotplug?)
+static int winusbx_reset_device(int sub_api, struct libusb_device_handle *dev_handle)
+{
+	struct libusb_context *ctx = DEVICE_CTX(dev_handle->dev);
+	struct winusb_device_handle_priv *handle_priv = _device_handle_priv(dev_handle);
+	struct winusb_device_priv *priv = _device_priv(dev_handle->dev);
+	HANDLE winusb_handle;
+	int i, j;
+
+	CHECK_WINUSBX_AVAILABLE(sub_api);
+
+	// Reset any available pipe (except control)
+	for (i = 0; i < USB_MAXINTERFACES; i++) {
+		winusb_handle = handle_priv->interface_handle[i].api_handle;
+		if (HANDLE_VALID(winusb_handle)) {
+			for (j = 0; j < priv->usb_interface[i].nb_endpoints; j++) {
+				usbi_dbg("resetting ep %02X", priv->usb_interface[i].endpoint[j]);
+				if (!WinUSBX[sub_api].AbortPipe(winusb_handle, priv->usb_interface[i].endpoint[j]))
+					usbi_err(ctx, "AbortPipe (pipe address %02X) failed: %s",
+						priv->usb_interface[i].endpoint[j], windows_error_str(0));
+
+				// FlushPipe seems to fail on OUT pipes
+				if (IS_EPIN(priv->usb_interface[i].endpoint[j])
+						&& (!WinUSBX[sub_api].FlushPipe(winusb_handle, priv->usb_interface[i].endpoint[j])))
+					usbi_err(ctx, "FlushPipe (pipe address %02X) failed: %s",
+						priv->usb_interface[i].endpoint[j], windows_error_str(0));
+
+				if (!WinUSBX[sub_api].ResetPipe(winusb_handle, priv->usb_interface[i].endpoint[j]))
+					usbi_err(ctx, "ResetPipe (pipe address %02X) failed: %s",
+						priv->usb_interface[i].endpoint[j], windows_error_str(0));
+			}
+		}
+	}
+
+	// libusbK & libusb0 have the ability to issue an actual device reset
+	if (WinUSBX[sub_api].ResetDevice != NULL) {
+		winusb_handle = handle_priv->interface_handle[0].api_handle;
+		if (HANDLE_VALID(winusb_handle))
+			WinUSBX[sub_api].ResetDevice(winusb_handle);
+	}
+
+	return LIBUSB_SUCCESS;
+}
+
+static int winusbx_copy_transfer_data(int sub_api, struct usbi_transfer *itransfer, uint32_t io_size)
+{
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct winusb_transfer_priv *transfer_priv = usbi_transfer_get_os_priv(itransfer);
+	struct winusb_device_priv *priv = _device_priv(transfer->dev_handle->dev);
+	PKISO_CONTEXT iso_context;
+	int i;
+
+	if (transfer->type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS) {
+		CHECK_WINUSBX_AVAILABLE(sub_api);
+
+		// for isochronous, need to copy the individual iso packet actual_lengths and statuses
+		if ((sub_api == SUB_API_LIBUSBK) || (sub_api == SUB_API_LIBUSB0)) {
+			// iso only supported on libusbk-based backends for now
+			iso_context = transfer_priv->iso_context;
+			for (i = 0; i < transfer->num_iso_packets; i++) {
+				transfer->iso_packet_desc[i].actual_length = iso_context->IsoPackets[i].actual_length;
+				// TODO translate USDB_STATUS codes http://msdn.microsoft.com/en-us/library/ff539136(VS.85).aspx to libusb_transfer_status
+				//transfer->iso_packet_desc[i].status = transfer_priv->iso_context->IsoPackets[i].status;
+			}
+		} else {
+			// This should only occur if backend is not set correctly or other backend isoc is partially implemented
+			PRINT_UNSUPPORTED_API(copy_transfer_data);
+			return LIBUSB_ERROR_NOT_SUPPORTED;
+		}
+	}
+
+	itransfer->transferred += io_size;
+	return LIBUSB_TRANSFER_COMPLETED;
+}
+
+/*
+ * Composite API functions
+ */
+static int composite_open(int sub_api, struct libusb_device_handle *dev_handle)
+{
+	struct winusb_device_priv *priv = _device_priv(dev_handle->dev);
+	int r = LIBUSB_ERROR_NOT_FOUND;
+	uint8_t i;
+	// SUB_API_MAX + 1 as the SUB_API_MAX pos is used to indicate availability of HID
+	bool available[SUB_API_MAX + 1] = { 0 };
+
+	for (i = 0; i < USB_MAXINTERFACES; i++) {
+		switch (priv->usb_interface[i].apib->id) {
+		case USB_API_WINUSBX:
+			if (priv->usb_interface[i].sub_api != SUB_API_NOTSET) {
+				available[priv->usb_interface[i].sub_api] = true;
+			}
+			break;
+		case USB_API_HID:
+			available[SUB_API_MAX] = true;
+			break;
+		default:
+			break;
+		}
+	}
+
+	for (i = 0; i < SUB_API_MAX; i++) { // WinUSB-like drivers
+		if (available[i]) {
+			r = usb_api_backend[USB_API_WINUSBX].open(i, dev_handle);
+			if (r != LIBUSB_SUCCESS) {
+				return r;
+			}
+		}
+	}
+/*
+	if (available[SUB_API_MAX]) // HID driver
+		r = hid_open(SUB_API_NOTSET, dev_handle);
+*/
+	return r;
+}
+
+static void composite_close(int sub_api, struct libusb_device_handle *dev_handle)
+{
+	struct winusb_device_priv *priv = _device_priv(dev_handle->dev);
+	uint8_t i;
+	// SUB_API_MAX + 1 as the SUB_API_MAX pos is used to indicate availability of HID
+	bool available[SUB_API_MAX + 1] = { 0 };
+
+	for (i = 0; i < USB_MAXINTERFACES; i++) {
+		switch (priv->usb_interface[i].apib->id) {
+		case USB_API_WINUSBX:
+			if (priv->usb_interface[i].sub_api != SUB_API_NOTSET)
+				available[priv->usb_interface[i].sub_api] = true;
+			break;
+		case USB_API_HID:
+			available[SUB_API_MAX] = true;
+			break;
+		default:
+			break;
+		}
+	}
+
+	for (i = 0; i < SUB_API_MAX; i++) { // WinUSB-like drivers
+		if (available[i])
+			usb_api_backend[USB_API_WINUSBX].close(i, dev_handle);
+	}
+/*
+	if (available[SUB_API_MAX]) // HID driver
+		hid_close(SUB_API_NOTSET, dev_handle);
+*/
+}
+
+static int composite_claim_interface(int sub_api, struct libusb_device_handle *dev_handle, int iface)
+{
+	struct winusb_device_priv *priv = _device_priv(dev_handle->dev);
+
+	CHECK_SUPPORTED_API(priv->usb_interface[iface].apib, claim_interface);
+
+	return priv->usb_interface[iface].apib->
+		claim_interface(priv->usb_interface[iface].sub_api, dev_handle, iface);
+}
+
+static int composite_set_interface_altsetting(int sub_api, struct libusb_device_handle *dev_handle, int iface, int altsetting)
+{
+	struct winusb_device_priv *priv = _device_priv(dev_handle->dev);
+
+	CHECK_SUPPORTED_API(priv->usb_interface[iface].apib, set_interface_altsetting);
+
+	return priv->usb_interface[iface].apib->
+		set_interface_altsetting(priv->usb_interface[iface].sub_api, dev_handle, iface, altsetting);
+}
+
+static int composite_release_interface(int sub_api, struct libusb_device_handle *dev_handle, int iface)
+{
+	struct winusb_device_priv *priv = _device_priv(dev_handle->dev);
+
+	CHECK_SUPPORTED_API(priv->usb_interface[iface].apib, release_interface);
+
+	return priv->usb_interface[iface].apib->
+		release_interface(priv->usb_interface[iface].sub_api, dev_handle, iface);
+}
+
+static int composite_submit_control_transfer(int sub_api, struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct libusb_context *ctx = DEVICE_CTX(transfer->dev_handle->dev);
+	struct winusb_device_priv *priv = _device_priv(transfer->dev_handle->dev);
+	struct libusb_config_descriptor *conf_desc;
+	WINUSB_SETUP_PACKET *setup = (WINUSB_SETUP_PACKET *)transfer->buffer;
+	int iface, pass, r;
+
+	// Interface shouldn't matter for control, but it does in practice, with Windows'
+	// restrictions with regards to accessing HID keyboards and mice. Try to target
+	// a specific interface first, if possible.
+	switch (LIBUSB_REQ_RECIPIENT(setup->RequestType)) {
+	case LIBUSB_RECIPIENT_INTERFACE:
+		iface = setup->Index & 0xFF;
+		break;
+	case LIBUSB_RECIPIENT_ENDPOINT:
+		r = libusb_get_active_config_descriptor(transfer->dev_handle->dev, &conf_desc);
+		if (r == LIBUSB_SUCCESS) {
+			iface = get_interface_by_endpoint(conf_desc, (setup->Index & 0xFF));
+			libusb_free_config_descriptor(conf_desc);
+			break;
+		}
+		// Fall through if not able to determine interface
+	default:
+		iface = -1;
+		break;
+	}
+
+	// Try and target a specific interface if the control setup indicates such
+	if ((iface >= 0) && (iface < USB_MAXINTERFACES)) {
+		usbi_dbg("attempting control transfer targeted to interface %d", iface);
+		if ((priv->usb_interface[iface].path != NULL)
+				&& (priv->usb_interface[iface].apib->submit_control_transfer != NULL)) {
+			r = priv->usb_interface[iface].apib->submit_control_transfer(priv->usb_interface[iface].sub_api, itransfer);
+			if (r == LIBUSB_SUCCESS)
+				return r;
+		}
+	}
+
+	// Either not targeted to a specific interface or no luck in doing so.
+	// Try a 2 pass approach with all interfaces.
+	for (pass = 0; pass < 2; pass++) {
+		for (iface = 0; iface < USB_MAXINTERFACES; iface++) {
+			if ((priv->usb_interface[iface].path != NULL)
+					&& (priv->usb_interface[iface].apib->submit_control_transfer != NULL)) {
+				if ((pass == 0) && (priv->usb_interface[iface].restricted_functionality)) {
+					usbi_dbg("trying to skip restricted interface #%d (HID keyboard or mouse?)", iface);
+					continue;
+				}
+				usbi_dbg("using interface %d", iface);
+				r = priv->usb_interface[iface].apib->submit_control_transfer(priv->usb_interface[iface].sub_api, itransfer);
+				// If not supported on this API, it may be supported on another, so don't give up yet!!
+				if (r == LIBUSB_ERROR_NOT_SUPPORTED)
+					continue;
+				return r;
+			}
+		}
+	}
+	usbi_err(ctx, "no libusb supported interfaces to complete request");
+	return LIBUSB_ERROR_NOT_FOUND;
+}
+
+static int composite_submit_bulk_transfer(int sub_api, struct usbi_transfer *itransfer) {
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct libusb_context *ctx = DEVICE_CTX(transfer->dev_handle->dev);
+	struct winusb_device_handle_priv *handle_priv = _device_handle_priv(transfer->dev_handle);
+	struct winusb_device_priv *priv = _device_priv(transfer->dev_handle->dev);
+	int current_interface;
+
+	current_interface = interface_by_endpoint(priv, handle_priv, transfer->endpoint);
+	if (current_interface < 0) {
+		usbi_err(ctx, "unable to match endpoint to an open interface - cancelling transfer");
+		return LIBUSB_ERROR_NOT_FOUND;
+	}
+
+	CHECK_SUPPORTED_API(priv->usb_interface[current_interface].apib, submit_bulk_transfer);
+
+	return priv->usb_interface[current_interface].apib->
+		submit_bulk_transfer(priv->usb_interface[current_interface].sub_api, itransfer);
+}
+
+static int composite_submit_iso_transfer(int sub_api, struct usbi_transfer *itransfer) {
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct libusb_context *ctx = DEVICE_CTX(transfer->dev_handle->dev);
+	struct winusb_device_handle_priv *handle_priv = _device_handle_priv(transfer->dev_handle);
+	struct winusb_device_priv *priv = _device_priv(transfer->dev_handle->dev);
+	int current_interface;
+
+	current_interface = interface_by_endpoint(priv, handle_priv, transfer->endpoint);
+	if (current_interface < 0) {
+		usbi_err(ctx, "unable to match endpoint to an open interface - cancelling transfer");
+		return LIBUSB_ERROR_NOT_FOUND;
+	}
+
+	CHECK_SUPPORTED_API(priv->usb_interface[current_interface].apib, submit_iso_transfer);
+
+	return priv->usb_interface[current_interface].apib->
+		submit_iso_transfer(priv->usb_interface[current_interface].sub_api, itransfer);
+}
+
+static int composite_clear_halt(int sub_api, struct libusb_device_handle *dev_handle, unsigned char endpoint)
+{
+	struct libusb_context *ctx = DEVICE_CTX(dev_handle->dev);
+	struct winusb_device_handle_priv *handle_priv = _device_handle_priv(dev_handle);
+	struct winusb_device_priv *priv = _device_priv(dev_handle->dev);
+	int current_interface;
+
+	current_interface = interface_by_endpoint(priv, handle_priv, endpoint);
+	if (current_interface < 0) {
+		usbi_err(ctx, "unable to match endpoint to an open interface - cannot clear");
+		return LIBUSB_ERROR_NOT_FOUND;
+	}
+
+	CHECK_SUPPORTED_API(priv->usb_interface[current_interface].apib, clear_halt);
+
+	return priv->usb_interface[current_interface].apib->
+		clear_halt(priv->usb_interface[current_interface].sub_api, dev_handle, endpoint);
+}
+
+static int composite_abort_control(int sub_api, struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct winusb_transfer_priv *transfer_priv = usbi_transfer_get_os_priv(itransfer);
+	struct winusb_device_priv *priv = _device_priv(transfer->dev_handle->dev);
+	int current_interface = transfer_priv->interface_number;
+
+	if ((current_interface < 0) || (current_interface >= USB_MAXINTERFACES)) {
+		usbi_err(TRANSFER_CTX(transfer), "program assertion failed: invalid interface_number");
+		return LIBUSB_ERROR_NOT_FOUND;
+	}
+
+	CHECK_SUPPORTED_API(priv->usb_interface[current_interface].apib, abort_control);
+
+	return priv->usb_interface[current_interface].apib->
+		abort_control(priv->usb_interface[current_interface].sub_api, itransfer);
+}
+
+static int composite_abort_transfers(int sub_api, struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct winusb_transfer_priv *transfer_priv = usbi_transfer_get_os_priv(itransfer);
+	struct winusb_device_priv *priv = _device_priv(transfer->dev_handle->dev);
+	int current_interface = transfer_priv->interface_number;
+
+	if ((current_interface < 0) || (current_interface >= USB_MAXINTERFACES)) {
+		usbi_err(TRANSFER_CTX(transfer), "program assertion failed: invalid interface_number");
+		return LIBUSB_ERROR_NOT_FOUND;
+	}
+
+	CHECK_SUPPORTED_API(priv->usb_interface[current_interface].apib, abort_transfers);
+
+	return priv->usb_interface[current_interface].apib->
+		abort_transfers(priv->usb_interface[current_interface].sub_api, itransfer);
+}
+
+static int composite_reset_device(int sub_api, struct libusb_device_handle *dev_handle)
+{
+	struct winusb_device_priv *priv = _device_priv(dev_handle->dev);
+	int r;
+	uint8_t i;
+	bool available[SUB_API_MAX];
+
+	for (i = 0; i < SUB_API_MAX; i++)
+		available[i] = false;
+
+	for (i = 0; i < USB_MAXINTERFACES; i++) {
+		if ((priv->usb_interface[i].apib->id == USB_API_WINUSBX)
+				&& (priv->usb_interface[i].sub_api != SUB_API_NOTSET))
+			available[priv->usb_interface[i].sub_api] = true;
+	}
+
+	for (i = 0; i < SUB_API_MAX; i++) {
+		if (available[i]) {
+			r = usb_api_backend[USB_API_WINUSBX].reset_device(i, dev_handle);
+			if (r != LIBUSB_SUCCESS)
+				return r;
+		}
+	}
+
+	return LIBUSB_SUCCESS;
+}
+
+static int composite_copy_transfer_data(int sub_api, struct usbi_transfer *itransfer, uint32_t io_size)
+{
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct winusb_transfer_priv *transfer_priv = usbi_transfer_get_os_priv(itransfer);
+	struct winusb_device_priv *priv = _device_priv(transfer->dev_handle->dev);
+	int current_interface = transfer_priv->interface_number;
+
+	CHECK_SUPPORTED_API(priv->usb_interface[current_interface].apib, copy_transfer_data);
+
+	return priv->usb_interface[current_interface].apib->
+		copy_transfer_data(priv->usb_interface[current_interface].sub_api, itransfer, io_size);
+}
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/os/windows_winusb.h b/vendor/github.com/karalabe/usb/libusb/libusb/os/windows_winusb.h
new file mode 100644
index 000000000..c1ad4eb9b
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/os/windows_winusb.h
@@ -0,0 +1,680 @@
+/*
+ * Windows backend for libusb 1.0
+ * Copyright © 2009-2012 Pete Batard <pete@akeo.ie>
+ * With contributions from Michael Plante, Orin Eman et al.
+ * Parts of this code adapted from libusb-win32-v1 by Stephan Meyer
+ * Major code testing contribution by Xiaofan Chen
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#pragma once
+
+#include "windows_common.h"
+#include "windows_nt_common.h"
+
+#if defined(_MSC_VER)
+// disable /W4 MSVC warnings that are benign
+#pragma warning(disable:4100)  // unreferenced formal parameter
+#pragma warning(disable:4127)  // conditional expression is constant
+#pragma warning(disable:4201)  // nameless struct/union
+#pragma warning(disable:4214)  // bit field types other than int
+#pragma warning(disable:4996)  // deprecated API calls
+#pragma warning(disable:28159) // more deprecated API calls
+#endif
+
+// Missing from MSVC6 setupapi.h
+#ifndef SPDRP_ADDRESS
+#define SPDRP_ADDRESS		28
+#endif
+#ifndef SPDRP_INSTALL_STATE
+#define SPDRP_INSTALL_STATE	34
+#endif
+
+#define MAX_CTRL_BUFFER_LENGTH	4096
+#define MAX_USB_STRING_LENGTH	128
+#define MAX_HID_REPORT_SIZE	1024
+#define MAX_HID_DESCRIPTOR_SIZE	256
+#define MAX_GUID_STRING_LENGTH	40
+#define MAX_PATH_LENGTH		128
+#define MAX_KEY_LENGTH		256
+#define LIST_SEPARATOR		';'
+
+// Handle code for HID interface that have been claimed ("dibs")
+#define INTERFACE_CLAIMED	((HANDLE)(intptr_t)0xD1B5)
+// Additional return code for HID operations that completed synchronously
+#define LIBUSB_COMPLETED	(LIBUSB_SUCCESS + 1)
+
+// http://msdn.microsoft.com/en-us/library/ff545978.aspx
+// http://msdn.microsoft.com/en-us/library/ff545972.aspx
+// http://msdn.microsoft.com/en-us/library/ff545982.aspx
+#ifndef GUID_DEVINTERFACE_USB_HOST_CONTROLLER
+const GUID GUID_DEVINTERFACE_USB_HOST_CONTROLLER = {0x3ABF6F2D, 0x71C4, 0x462A, {0x8A, 0x92, 0x1E, 0x68, 0x61, 0xE6, 0xAF, 0x27}};
+#endif
+#ifndef GUID_DEVINTERFACE_USB_DEVICE
+const GUID GUID_DEVINTERFACE_USB_DEVICE = {0xA5DCBF10, 0x6530, 0x11D2, {0x90, 0x1F, 0x00, 0xC0, 0x4F, 0xB9, 0x51, 0xED}};
+#endif
+#ifndef GUID_DEVINTERFACE_USB_HUB
+const GUID GUID_DEVINTERFACE_USB_HUB = {0xF18A0E88, 0xC30C, 0x11D0, {0x88, 0x15, 0x00, 0xA0, 0xC9, 0x06, 0xBE, 0xD8}};
+#endif
+#ifndef GUID_DEVINTERFACE_LIBUSB0_FILTER
+const GUID GUID_DEVINTERFACE_LIBUSB0_FILTER = {0xF9F3FF14, 0xAE21, 0x48A0, {0x8A, 0x25, 0x80, 0x11, 0xA7, 0xA9, 0x31, 0xD9}};
+#endif
+
+
+/*
+ * Multiple USB API backend support
+ */
+#define USB_API_UNSUPPORTED	0
+#define USB_API_HUB		1
+#define USB_API_COMPOSITE	2
+#define USB_API_WINUSBX		3
+#define USB_API_HID		4
+#define USB_API_MAX		5
+
+// Sub-APIs for WinUSB-like driver APIs (WinUSB, libusbK, libusb-win32 through the libusbK DLL)
+// Must have the same values as the KUSB_DRVID enum from libusbk.h
+#define SUB_API_NOTSET		-1
+#define SUB_API_LIBUSBK		0
+#define SUB_API_LIBUSB0		1
+#define SUB_API_WINUSB		2
+#define SUB_API_MAX		3
+
+struct windows_usb_api_backend {
+	const uint8_t id;
+	const char * const designation;
+	const char * const * const driver_name_list; // Driver name, without .sys, e.g. "usbccgp"
+	const uint8_t nb_driver_names;
+	int (*init)(struct libusb_context *ctx);
+	void (*exit)(void);
+	int (*open)(int sub_api, struct libusb_device_handle *dev_handle);
+	void (*close)(int sub_api, struct libusb_device_handle *dev_handle);
+	int (*configure_endpoints)(int sub_api, struct libusb_device_handle *dev_handle, int iface);
+	int (*claim_interface)(int sub_api, struct libusb_device_handle *dev_handle, int iface);
+	int (*set_interface_altsetting)(int sub_api, struct libusb_device_handle *dev_handle, int iface, int altsetting);
+	int (*release_interface)(int sub_api, struct libusb_device_handle *dev_handle, int iface);
+	int (*clear_halt)(int sub_api, struct libusb_device_handle *dev_handle, unsigned char endpoint);
+	int (*reset_device)(int sub_api, struct libusb_device_handle *dev_handle);
+	int (*submit_bulk_transfer)(int sub_api, struct usbi_transfer *itransfer);
+	int (*submit_iso_transfer)(int sub_api, struct usbi_transfer *itransfer);
+	int (*submit_control_transfer)(int sub_api, struct usbi_transfer *itransfer);
+	int (*abort_control)(int sub_api, struct usbi_transfer *itransfer);
+	int (*abort_transfers)(int sub_api, struct usbi_transfer *itransfer);
+	int (*copy_transfer_data)(int sub_api, struct usbi_transfer *itransfer, uint32_t io_size);
+};
+
+extern const struct windows_usb_api_backend usb_api_backend[USB_API_MAX];
+
+#define PRINT_UNSUPPORTED_API(fname)				\
+	usbi_dbg("unsupported API call for '%s' "		\
+		"(unrecognized device driver)", #fname)
+
+#define CHECK_SUPPORTED_API(apip, fname)			\
+	do {							\
+		if ((apip)->fname == NULL) {			\
+			PRINT_UNSUPPORTED_API(fname);		\
+			return LIBUSB_ERROR_NOT_SUPPORTED;	\
+		}						\
+	} while (0)
+
+/*
+ * private structures definition
+ * with inline pseudo constructors/destructors
+ */
+
+// TODO (v2+): move hid desc to libusb.h?
+struct libusb_hid_descriptor {
+	uint8_t bLength;
+	uint8_t bDescriptorType;
+	uint16_t bcdHID;
+	uint8_t bCountryCode;
+	uint8_t bNumDescriptors;
+	uint8_t bClassDescriptorType;
+	uint16_t wClassDescriptorLength;
+};
+
+#define LIBUSB_DT_HID_SIZE		9
+#define HID_MAX_CONFIG_DESC_SIZE (LIBUSB_DT_CONFIG_SIZE + LIBUSB_DT_INTERFACE_SIZE \
+	+ LIBUSB_DT_HID_SIZE + 2 * LIBUSB_DT_ENDPOINT_SIZE)
+#define HID_MAX_REPORT_SIZE		1024
+#define HID_IN_EP			0x81
+#define HID_OUT_EP			0x02
+#define LIBUSB_REQ_RECIPIENT(request_type)	((request_type) & 0x1F)
+#define LIBUSB_REQ_TYPE(request_type)		((request_type) & (0x03 << 5))
+#define LIBUSB_REQ_IN(request_type)		((request_type) & LIBUSB_ENDPOINT_IN)
+#define LIBUSB_REQ_OUT(request_type)		(!LIBUSB_REQ_IN(request_type))
+
+#ifndef CTL_CODE
+#define CTL_CODE(DeviceType, Function, Method, Access) \
+	(((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method))
+#endif
+
+// The following are used for HID reports IOCTLs
+#define HID_IN_CTL_CODE(id) \
+	CTL_CODE(FILE_DEVICE_KEYBOARD, (id), METHOD_IN_DIRECT, FILE_ANY_ACCESS)
+#define HID_OUT_CTL_CODE(id) \
+	CTL_CODE(FILE_DEVICE_KEYBOARD, (id), METHOD_OUT_DIRECT, FILE_ANY_ACCESS)
+
+#define IOCTL_HID_GET_FEATURE		HID_OUT_CTL_CODE(100)
+#define IOCTL_HID_GET_INPUT_REPORT	HID_OUT_CTL_CODE(104)
+#define IOCTL_HID_SET_FEATURE		HID_IN_CTL_CODE(100)
+#define IOCTL_HID_SET_OUTPUT_REPORT	HID_IN_CTL_CODE(101)
+
+enum libusb_hid_request_type {
+	HID_REQ_GET_REPORT = 0x01,
+	HID_REQ_GET_IDLE = 0x02,
+	HID_REQ_GET_PROTOCOL = 0x03,
+	HID_REQ_SET_REPORT = 0x09,
+	HID_REQ_SET_IDLE = 0x0A,
+	HID_REQ_SET_PROTOCOL = 0x0B
+};
+
+enum libusb_hid_report_type {
+	HID_REPORT_TYPE_INPUT = 0x01,
+	HID_REPORT_TYPE_OUTPUT = 0x02,
+	HID_REPORT_TYPE_FEATURE = 0x03
+};
+
+struct hid_device_priv {
+	uint16_t vid;
+	uint16_t pid;
+	uint8_t config;
+	uint8_t nb_interfaces;
+	bool uses_report_ids[3]; // input, ouptput, feature
+	uint16_t input_report_size;
+	uint16_t output_report_size;
+	uint16_t feature_report_size;
+	uint16_t usage;
+	uint16_t usagePage;
+	WCHAR string[3][MAX_USB_STRING_LENGTH];
+	uint8_t string_index[3]; // man, prod, ser
+};
+
+static inline struct winusb_device_priv *_device_priv(struct libusb_device *dev)
+{
+	return (struct winusb_device_priv *)dev->os_priv;
+}
+
+static inline struct winusb_device_priv *winusb_device_priv_init(struct libusb_device *dev)
+{
+	struct winusb_device_priv *p = _device_priv(dev);
+	int i;
+
+	p->apib = &usb_api_backend[USB_API_UNSUPPORTED];
+	p->sub_api = SUB_API_NOTSET;
+	for (i = 0; i < USB_MAXINTERFACES; i++) {
+		p->usb_interface[i].apib = &usb_api_backend[USB_API_UNSUPPORTED];
+		p->usb_interface[i].sub_api = SUB_API_NOTSET;
+	}
+
+	return p;
+}
+
+static inline void winusb_device_priv_release(struct libusb_device *dev)
+{
+	struct winusb_device_priv *p = _device_priv(dev);
+	int i;
+
+	free(p->dev_id);
+	free(p->path);
+	if ((dev->num_configurations > 0) && (p->config_descriptor != NULL)) {
+		for (i = 0; i < dev->num_configurations; i++)
+			free(p->config_descriptor[i]);
+	}
+	free(p->config_descriptor);
+	free(p->hid);
+	for (i = 0; i < USB_MAXINTERFACES; i++) {
+		free(p->usb_interface[i].path);
+		free(p->usb_interface[i].endpoint);
+	}
+}
+
+static inline struct winusb_device_handle_priv *_device_handle_priv(
+	struct libusb_device_handle *handle)
+{
+	return (struct winusb_device_handle_priv *)handle->os_priv;
+}
+
+// used to match a device driver (including filter drivers) against a supported API
+struct driver_lookup {
+	char list[MAX_KEY_LENGTH + 1]; // REG_MULTI_SZ list of services (driver) names
+	const DWORD reg_prop;          // SPDRP registry key to use to retrieve list
+	const char* designation;       // internal designation (for debug output)
+};
+
+/*
+ * Windows DDK API definitions. Most of it copied from MinGW's includes
+ */
+typedef DWORD DEVNODE, DEVINST;
+typedef DEVNODE *PDEVNODE, *PDEVINST;
+typedef DWORD RETURN_TYPE;
+typedef RETURN_TYPE CONFIGRET;
+
+#define CR_SUCCESS	0x00000000
+
+/* Cfgmgr32 dependencies */
+DLL_DECLARE_HANDLE(Cfgmgr32);
+DLL_DECLARE_FUNC(WINAPI, CONFIGRET, CM_Get_Parent, (PDEVINST, DEVINST, ULONG));
+DLL_DECLARE_FUNC(WINAPI, CONFIGRET, CM_Get_Child, (PDEVINST, DEVINST, ULONG));
+
+/* AdvAPI32 dependencies */
+DLL_DECLARE_HANDLE(AdvAPI32);
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, LONG, p, RegQueryValueExW, (HKEY, LPCWSTR, LPDWORD, LPDWORD, LPBYTE, LPDWORD));
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, LONG, p, RegCloseKey, (HKEY));
+
+/* OLE32 dependency */
+DLL_DECLARE_HANDLE(OLE32);
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, HRESULT, p, IIDFromString, (LPCOLESTR, LPIID));
+
+/* SetupAPI dependencies */
+DLL_DECLARE_HANDLE(SetupAPI);
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, HDEVINFO, p, SetupDiGetClassDevsA, (LPCGUID, PCSTR, HWND, DWORD));
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, SetupDiEnumDeviceInfo, (HDEVINFO, DWORD, PSP_DEVINFO_DATA));
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, SetupDiEnumDeviceInterfaces, (HDEVINFO, PSP_DEVINFO_DATA,
+			LPCGUID, DWORD, PSP_DEVICE_INTERFACE_DATA));
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, SetupDiGetDeviceInstanceIdA, (HDEVINFO, PSP_DEVINFO_DATA,
+			PCSTR, DWORD, PDWORD));
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, SetupDiGetDeviceInterfaceDetailA, (HDEVINFO, PSP_DEVICE_INTERFACE_DATA,
+			PSP_DEVICE_INTERFACE_DETAIL_DATA_A, DWORD, PDWORD, PSP_DEVINFO_DATA));
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, SetupDiGetDeviceRegistryPropertyA, (HDEVINFO,
+			PSP_DEVINFO_DATA, DWORD, PDWORD, PBYTE, DWORD, PDWORD));
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, SetupDiDestroyDeviceInfoList, (HDEVINFO));
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, HKEY, p, SetupDiOpenDevRegKey, (HDEVINFO, PSP_DEVINFO_DATA, DWORD, DWORD, DWORD, REGSAM));
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, HKEY, p, SetupDiOpenDeviceInterfaceRegKey, (HDEVINFO, PSP_DEVICE_INTERFACE_DATA, DWORD, DWORD));
+
+
+#ifndef USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION
+#define USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION		260
+#endif
+#ifndef USB_GET_NODE_CONNECTION_INFORMATION_EX
+#define USB_GET_NODE_CONNECTION_INFORMATION_EX		274
+#endif
+#ifndef USB_GET_NODE_CONNECTION_INFORMATION_EX_V2
+#define USB_GET_NODE_CONNECTION_INFORMATION_EX_V2	279
+#endif
+
+#ifndef FILE_DEVICE_USB
+#define FILE_DEVICE_USB		FILE_DEVICE_UNKNOWN
+#endif
+
+#define USB_CTL_CODE(id) \
+	CTL_CODE(FILE_DEVICE_USB, (id), METHOD_BUFFERED, FILE_ANY_ACCESS)
+
+#define IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION \
+	USB_CTL_CODE(USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION)
+
+#define IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX \
+	USB_CTL_CODE(USB_GET_NODE_CONNECTION_INFORMATION_EX)
+
+#define IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX_V2 \
+	USB_CTL_CODE(USB_GET_NODE_CONNECTION_INFORMATION_EX_V2)
+
+typedef enum USB_CONNECTION_STATUS {
+	NoDeviceConnected,
+	DeviceConnected,
+	DeviceFailedEnumeration,
+	DeviceGeneralFailure,
+	DeviceCausedOvercurrent,
+	DeviceNotEnoughPower,
+	DeviceNotEnoughBandwidth,
+	DeviceHubNestedTooDeeply,
+	DeviceInLegacyHub
+} USB_CONNECTION_STATUS, *PUSB_CONNECTION_STATUS;
+
+typedef enum USB_HUB_NODE {
+	UsbHub,
+	UsbMIParent
+} USB_HUB_NODE;
+
+// Most of the structures below need to be packed
+#include <pshpack1.h>
+
+typedef struct _USB_DESCRIPTOR_REQUEST {
+	ULONG ConnectionIndex;
+	struct {
+		UCHAR bmRequest;
+		UCHAR bRequest;
+		USHORT wValue;
+		USHORT wIndex;
+		USHORT wLength;
+	} SetupPacket;
+//	UCHAR Data[0];
+} USB_DESCRIPTOR_REQUEST, *PUSB_DESCRIPTOR_REQUEST;
+
+typedef struct _USB_CONFIGURATION_DESCRIPTOR_SHORT {
+	USB_DESCRIPTOR_REQUEST req;
+	USB_CONFIGURATION_DESCRIPTOR desc;
+} USB_CONFIGURATION_DESCRIPTOR_SHORT;
+
+typedef struct USB_INTERFACE_DESCRIPTOR {
+	UCHAR bLength;
+	UCHAR bDescriptorType;
+	UCHAR bInterfaceNumber;
+	UCHAR bAlternateSetting;
+	UCHAR bNumEndpoints;
+	UCHAR bInterfaceClass;
+	UCHAR bInterfaceSubClass;
+	UCHAR bInterfaceProtocol;
+	UCHAR iInterface;
+} USB_INTERFACE_DESCRIPTOR, *PUSB_INTERFACE_DESCRIPTOR;
+
+typedef struct _USB_NODE_CONNECTION_INFORMATION_EX {
+	ULONG ConnectionIndex;
+	USB_DEVICE_DESCRIPTOR DeviceDescriptor;
+	UCHAR CurrentConfigurationValue;
+	UCHAR Speed;
+	BOOLEAN DeviceIsHub;
+	USHORT DeviceAddress;
+	ULONG NumberOfOpenPipes;
+	USB_CONNECTION_STATUS ConnectionStatus;
+//	USB_PIPE_INFO PipeList[0];
+} USB_NODE_CONNECTION_INFORMATION_EX, *PUSB_NODE_CONNECTION_INFORMATION_EX;
+
+typedef union _USB_PROTOCOLS {
+	ULONG ul;
+	struct {
+		ULONG Usb110:1;
+		ULONG Usb200:1;
+		ULONG Usb300:1;
+		ULONG ReservedMBZ:29;
+	};
+} USB_PROTOCOLS, *PUSB_PROTOCOLS;
+
+typedef union _USB_NODE_CONNECTION_INFORMATION_EX_V2_FLAGS {
+	ULONG ul;
+	struct {
+		ULONG DeviceIsOperatingAtSuperSpeedOrHigher:1;
+		ULONG DeviceIsSuperSpeedCapableOrHigher:1;
+		ULONG ReservedMBZ:30;
+	};
+} USB_NODE_CONNECTION_INFORMATION_EX_V2_FLAGS, *PUSB_NODE_CONNECTION_INFORMATION_EX_V2_FLAGS;
+
+typedef struct _USB_NODE_CONNECTION_INFORMATION_EX_V2 {
+	ULONG ConnectionIndex;
+	ULONG Length;
+	USB_PROTOCOLS SupportedUsbProtocols;
+	USB_NODE_CONNECTION_INFORMATION_EX_V2_FLAGS Flags;
+} USB_NODE_CONNECTION_INFORMATION_EX_V2, *PUSB_NODE_CONNECTION_INFORMATION_EX_V2;
+
+#include <poppack.h>
+
+/* winusb.dll interface */
+
+#define SHORT_PACKET_TERMINATE	0x01
+#define AUTO_CLEAR_STALL	0x02
+#define PIPE_TRANSFER_TIMEOUT	0x03
+#define IGNORE_SHORT_PACKETS	0x04
+#define ALLOW_PARTIAL_READS	0x05
+#define AUTO_FLUSH		0x06
+#define RAW_IO			0x07
+#define MAXIMUM_TRANSFER_SIZE	0x08
+
+typedef enum _USBD_PIPE_TYPE {
+	UsbdPipeTypeControl,
+	UsbdPipeTypeIsochronous,
+	UsbdPipeTypeBulk,
+	UsbdPipeTypeInterrupt
+} USBD_PIPE_TYPE;
+
+#include <pshpack1.h>
+
+typedef struct _WINUSB_SETUP_PACKET {
+	UCHAR RequestType;
+	UCHAR Request;
+	USHORT Value;
+	USHORT Index;
+	USHORT Length;
+} WINUSB_SETUP_PACKET, *PWINUSB_SETUP_PACKET;
+
+#include <poppack.h>
+
+typedef void *WINUSB_INTERFACE_HANDLE, *PWINUSB_INTERFACE_HANDLE;
+
+typedef BOOL (WINAPI *WinUsb_AbortPipe_t)(
+	WINUSB_INTERFACE_HANDLE InterfaceHandle,
+	UCHAR PipeID
+);
+typedef BOOL (WINAPI *WinUsb_ControlTransfer_t)(
+	WINUSB_INTERFACE_HANDLE InterfaceHandle,
+	WINUSB_SETUP_PACKET SetupPacket,
+	PUCHAR Buffer,
+	ULONG BufferLength,
+	PULONG LengthTransferred,
+	LPOVERLAPPED Overlapped
+);
+typedef BOOL (WINAPI *WinUsb_FlushPipe_t)(
+	WINUSB_INTERFACE_HANDLE InterfaceHandle,
+	UCHAR PipeID
+);
+typedef BOOL (WINAPI *WinUsb_Free_t)(
+	WINUSB_INTERFACE_HANDLE InterfaceHandle
+);
+typedef BOOL (WINAPI *WinUsb_GetAssociatedInterface_t)(
+	WINUSB_INTERFACE_HANDLE InterfaceHandle,
+	UCHAR AssociatedInterfaceIndex,
+	PWINUSB_INTERFACE_HANDLE AssociatedInterfaceHandle
+);
+typedef BOOL (WINAPI *WinUsb_Initialize_t)(
+	HANDLE DeviceHandle,
+	PWINUSB_INTERFACE_HANDLE InterfaceHandle
+);
+typedef BOOL (WINAPI *WinUsb_ReadPipe_t)(
+	WINUSB_INTERFACE_HANDLE InterfaceHandle,
+	UCHAR PipeID,
+	PUCHAR Buffer,
+	ULONG BufferLength,
+	PULONG LengthTransferred,
+	LPOVERLAPPED Overlapped
+);
+typedef BOOL (WINAPI *WinUsb_ResetDevice_t)(
+	WINUSB_INTERFACE_HANDLE InterfaceHandle
+);
+typedef BOOL (WINAPI *WinUsb_ResetPipe_t)(
+	WINUSB_INTERFACE_HANDLE InterfaceHandle,
+	UCHAR PipeID
+);
+typedef BOOL (WINAPI *WinUsb_SetCurrentAlternateSetting_t)(
+	WINUSB_INTERFACE_HANDLE InterfaceHandle,
+	UCHAR AlternateSetting
+);
+typedef BOOL (WINAPI *WinUsb_SetPipePolicy_t)(
+	WINUSB_INTERFACE_HANDLE InterfaceHandle,
+	UCHAR PipeID,
+	ULONG PolicyType,
+	ULONG ValueLength,
+	PVOID Value
+);
+typedef BOOL (WINAPI *WinUsb_WritePipe_t)(
+	WINUSB_INTERFACE_HANDLE InterfaceHandle,
+	UCHAR PipeID,
+	PUCHAR Buffer,
+	ULONG BufferLength,
+	PULONG LengthTransferred,
+	LPOVERLAPPED Overlapped
+);
+
+/* /!\ These must match the ones from the official libusbk.h */
+typedef enum _KUSB_FNID {
+	KUSB_FNID_Init,
+	KUSB_FNID_Free,
+	KUSB_FNID_ClaimInterface,
+	KUSB_FNID_ReleaseInterface,
+	KUSB_FNID_SetAltInterface,
+	KUSB_FNID_GetAltInterface,
+	KUSB_FNID_GetDescriptor,
+	KUSB_FNID_ControlTransfer,
+	KUSB_FNID_SetPowerPolicy,
+	KUSB_FNID_GetPowerPolicy,
+	KUSB_FNID_SetConfiguration,
+	KUSB_FNID_GetConfiguration,
+	KUSB_FNID_ResetDevice,
+	KUSB_FNID_Initialize,
+	KUSB_FNID_SelectInterface,
+	KUSB_FNID_GetAssociatedInterface,
+	KUSB_FNID_Clone,
+	KUSB_FNID_QueryInterfaceSettings,
+	KUSB_FNID_QueryDeviceInformation,
+	KUSB_FNID_SetCurrentAlternateSetting,
+	KUSB_FNID_GetCurrentAlternateSetting,
+	KUSB_FNID_QueryPipe,
+	KUSB_FNID_SetPipePolicy,
+	KUSB_FNID_GetPipePolicy,
+	KUSB_FNID_ReadPipe,
+	KUSB_FNID_WritePipe,
+	KUSB_FNID_ResetPipe,
+	KUSB_FNID_AbortPipe,
+	KUSB_FNID_FlushPipe,
+	KUSB_FNID_IsoReadPipe,
+	KUSB_FNID_IsoWritePipe,
+	KUSB_FNID_GetCurrentFrameNumber,
+	KUSB_FNID_GetOverlappedResult,
+	KUSB_FNID_GetProperty,
+	KUSB_FNID_COUNT,
+} KUSB_FNID;
+
+typedef struct _KLIB_VERSION {
+	INT Major;
+	INT Minor;
+	INT Micro;
+	INT Nano;
+} KLIB_VERSION, *PKLIB_VERSION;
+
+typedef BOOL (WINAPI *LibK_GetProcAddress_t)(
+	PVOID *ProcAddress,
+	ULONG DriverID,
+	ULONG FunctionID
+);
+
+typedef VOID (WINAPI *LibK_GetVersion_t)(
+	PKLIB_VERSION Version
+);
+
+//KISO_PACKET is equivalent of libusb_iso_packet_descriptor except uses absolute "offset" field instead of sequential Lengths
+typedef struct _KISO_PACKET {
+	UINT offset;
+	USHORT actual_length; //changed from libusbk_shared.h "Length" for clarity
+	USHORT status;
+} KISO_PACKET, *PKISO_PACKET;
+
+typedef enum _KISO_FLAG {
+	KISO_FLAG_NONE = 0,
+	KISO_FLAG_SET_START_FRAME = 0x00000001,
+} KISO_FLAG;
+
+//KISO_CONTEXT is the conceptual equivalent of libusb_transfer except is isochronous-specific and must match libusbk's version
+typedef struct _KISO_CONTEXT {
+	KISO_FLAG Flags;
+	UINT StartFrame;
+	SHORT ErrorCount;
+	SHORT NumberOfPackets;
+	UINT UrbHdrStatus;
+	KISO_PACKET IsoPackets[0];
+} KISO_CONTEXT, *PKISO_CONTEXT;
+
+typedef BOOL(WINAPI *WinUsb_IsoReadPipe_t)(
+	WINUSB_INTERFACE_HANDLE InterfaceHandle,
+	UCHAR PipeID,
+	PUCHAR Buffer,
+	ULONG BufferLength,
+	LPOVERLAPPED Overlapped,
+	PKISO_CONTEXT IsoContext
+);
+
+typedef BOOL(WINAPI *WinUsb_IsoWritePipe_t)(
+	WINUSB_INTERFACE_HANDLE InterfaceHandle,
+	UCHAR PipeID,
+	PUCHAR Buffer,
+	ULONG BufferLength,
+	LPOVERLAPPED Overlapped,
+	PKISO_CONTEXT IsoContext
+);
+
+struct winusb_interface {
+	bool initialized;
+	bool CancelIoEx_supported;
+	WinUsb_AbortPipe_t AbortPipe;
+	WinUsb_ControlTransfer_t ControlTransfer;
+	WinUsb_FlushPipe_t FlushPipe;
+	WinUsb_Free_t Free;
+	WinUsb_GetAssociatedInterface_t GetAssociatedInterface;
+	WinUsb_Initialize_t Initialize;
+	WinUsb_ReadPipe_t ReadPipe;
+	WinUsb_ResetDevice_t ResetDevice;
+	WinUsb_ResetPipe_t ResetPipe;
+	WinUsb_SetCurrentAlternateSetting_t SetCurrentAlternateSetting;
+	WinUsb_SetPipePolicy_t SetPipePolicy;
+	WinUsb_WritePipe_t WritePipe;
+	WinUsb_IsoReadPipe_t IsoReadPipe;
+	WinUsb_IsoWritePipe_t IsoWritePipe;
+};
+
+/* hid.dll interface */
+
+#define HIDP_STATUS_SUCCESS	0x110000
+typedef void * PHIDP_PREPARSED_DATA;
+
+#include <pshpack1.h>
+#include <poppack.h>
+
+typedef USHORT USAGE;
+
+typedef enum _HIDP_REPORT_TYPE {
+	HidP_Input,
+	HidP_Output,
+	HidP_Feature
+} HIDP_REPORT_TYPE;
+
+typedef struct _HIDP_VALUE_CAPS {
+	USAGE UsagePage;
+	UCHAR ReportID;
+	BOOLEAN IsAlias;
+	USHORT BitField;
+	USHORT LinkCollection;
+	USAGE LinkUsage;
+	USAGE LinkUsagePage;
+	BOOLEAN IsRange;
+	BOOLEAN IsStringRange;
+	BOOLEAN IsDesignatorRange;
+	BOOLEAN IsAbsolute;
+	BOOLEAN HasNull;
+	UCHAR Reserved;
+	USHORT BitSize;
+	USHORT ReportCount;
+	USHORT Reserved2[5];
+	ULONG UnitsExp;
+	ULONG Units;
+	LONG LogicalMin, LogicalMax;
+	LONG PhysicalMin, PhysicalMax;
+	union {
+		struct {
+			USAGE UsageMin, UsageMax;
+			USHORT StringMin, StringMax;
+			USHORT DesignatorMin, DesignatorMax;
+			USHORT DataIndexMin, DataIndexMax;
+		} Range;
+		struct {
+			USAGE Usage, Reserved1;
+			USHORT StringIndex, Reserved2;
+			USHORT DesignatorIndex, Reserved3;
+			USHORT DataIndex, Reserved4;
+		} NotRange;
+	} u;
+} HIDP_VALUE_CAPS, *PHIDP_VALUE_CAPS;
+
+DLL_DECLARE_HANDLE(hid);
+DLL_DECLARE_FUNC(WINAPI, VOID, HidD_GetHidGuid, (LPGUID));
+DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetPhysicalDescriptor, (HANDLE, PVOID, ULONG));
+DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_FlushQueue, (HANDLE));
+DLL_DECLARE_FUNC(WINAPI, BOOL, HidP_GetValueCaps, (HIDP_REPORT_TYPE, PHIDP_VALUE_CAPS, PULONG, PHIDP_PREPARSED_DATA));
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/strerror.c b/vendor/github.com/karalabe/usb/libusb/libusb/strerror.c
new file mode 100644
index 000000000..d2be0e2a0
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/strerror.c
@@ -0,0 +1,202 @@
+/*
+ * libusb strerror code
+ * Copyright © 2013 Hans de Goede <hdegoede@redhat.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <config.h>
+
+#include <locale.h>
+#include <stdlib.h>
+#include <string.h>
+#if defined(HAVE_STRINGS_H)
+#include <strings.h>
+#endif
+
+#include "libusbi.h"
+
+#if defined(_MSC_VER)
+#define strncasecmp _strnicmp
+#endif
+
+static size_t usbi_locale = 0;
+
+/** \ingroup libusb_misc
+ * How to add a new \ref libusb_strerror() translation:
+ * <ol>
+ * <li> Download the latest \c strerror.c from:<br>
+ *      https://raw.github.com/libusb/libusb/master/libusb/sterror.c </li>
+ * <li> Open the file in an UTF-8 capable editor </li>
+ * <li> Add the 2 letter <a href="http://en.wikipedia.org/wiki/List_of_ISO_639-1_codes">ISO 639-1</a>
+ *      code for your locale at the end of \c usbi_locale_supported[]<br>
+ *    Eg. for Chinese, you would add "zh" so that:
+ *    \code... usbi_locale_supported[] = { "en", "nl", "fr" };\endcode
+ *    becomes:
+ *    \code... usbi_locale_supported[] = { "en", "nl", "fr", "zh" };\endcode </li>
+ * <li> Copy the <tt>{ / * English (en) * / ... }</tt> section and add it at the end of \c usbi_localized_errors<br>
+ *    Eg. for Chinese, the last section of \c usbi_localized_errors could look like:
+ *    \code
+ *     }, { / * Chinese (zh) * /
+ *         "Success",
+ *         ...
+ *         "Other error",
+ *     }
+ * };\endcode </li>
+ * <li> Translate each of the English messages from the section you copied into your language </li>
+ * <li> Save the file (in UTF-8 format) and send it to \c libusb-devel\@lists.sourceforge.net </li>
+ * </ol>
+ */
+
+static const char* usbi_locale_supported[] = { "en", "nl", "fr", "ru" };
+static const char* usbi_localized_errors[ARRAYSIZE(usbi_locale_supported)][LIBUSB_ERROR_COUNT] = {
+	{ /* English (en) */
+		"Success",
+		"Input/Output Error",
+		"Invalid parameter",
+		"Access denied (insufficient permissions)",
+		"No such device (it may have been disconnected)",
+		"Entity not found",
+		"Resource busy",
+		"Operation timed out",
+		"Overflow",
+		"Pipe error",
+		"System call interrupted (perhaps due to signal)",
+		"Insufficient memory",
+		"Operation not supported or unimplemented on this platform",
+		"Other error",
+	}, { /* Dutch (nl) */
+		"Gelukt",
+		"Invoer-/uitvoerfout",
+		"Ongeldig argument",
+		"Toegang geweigerd (onvoldoende toegangsrechten)",
+		"Apparaat bestaat niet (verbinding met apparaat verbroken?)",
+		"Niet gevonden",
+		"Apparaat of hulpbron is bezig",
+		"Bewerking verlopen",
+		"Waarde is te groot",
+		"Gebroken pijp",
+		"Onderbroken systeemaanroep",
+		"Onvoldoende geheugen beschikbaar",
+		"Bewerking wordt niet ondersteund",
+		"Andere fout",
+	}, { /* French (fr) */
+		"Succès",
+		"Erreur d'entrée/sortie",
+		"Paramètre invalide",
+		"Accès refusé (permissions insuffisantes)",
+		"Périphérique introuvable (peut-être déconnecté)",
+		"Elément introuvable",
+		"Resource déjà occupée",
+		"Operation expirée",
+		"Débordement",
+		"Erreur de pipe",
+		"Appel système abandonné (peut-être à cause d’un signal)",
+		"Mémoire insuffisante",
+		"Opération non supportée or non implémentée sur cette plateforme",
+		"Autre erreur",
+	}, { /* Russian (ru) */
+		"Успех",
+		"Ошибка ввода/вывода",
+		"Неверный параметр",
+		"Доступ запрещён (не хватает прав)",
+		"Устройство отсутствует (возможно, оно было отсоединено)",
+		"Элемент не найден",
+		"Ресурс занят",
+		"Истекло время ожидания операции",
+		"Переполнение",
+		"Ошибка канала",
+		"Системный вызов прерван (возможно, сигналом)",
+		"Память исчерпана",
+		"Операция не поддерживается данной платформой",
+		"Неизвестная ошибка"
+	}
+};
+
+/** \ingroup libusb_misc
+ * Set the language, and only the language, not the encoding! used for
+ * translatable libusb messages.
+ *
+ * This takes a locale string in the default setlocale format: lang[-region]
+ * or lang[_country_region][.codeset]. Only the lang part of the string is
+ * used, and only 2 letter ISO 639-1 codes are accepted for it, such as "de".
+ * The optional region, country_region or codeset parts are ignored. This
+ * means that functions which return translatable strings will NOT honor the
+ * specified encoding. 
+ * All strings returned are encoded as UTF-8 strings.
+ *
+ * If libusb_setlocale() is not called, all messages will be in English.
+ *
+ * The following functions return translatable strings: libusb_strerror().
+ * Note that the libusb log messages controlled through libusb_set_debug()
+ * are not translated, they are always in English.
+ *
+ * For POSIX UTF-8 environments if you want libusb to follow the standard
+ * locale settings, call libusb_setlocale(setlocale(LC_MESSAGES, NULL)),
+ * after your app has done its locale setup.
+ *
+ * \param locale locale-string in the form of lang[_country_region][.codeset]
+ * or lang[-region], where lang is a 2 letter ISO 639-1 code
+ * \returns LIBUSB_SUCCESS on success
+ * \returns LIBUSB_ERROR_INVALID_PARAM if the locale doesn't meet the requirements
+ * \returns LIBUSB_ERROR_NOT_FOUND if the requested language is not supported
+ * \returns a LIBUSB_ERROR code on other errors
+ */
+
+int API_EXPORTED libusb_setlocale(const char *locale)
+{
+	size_t i;
+
+	if ( (locale == NULL) || (strlen(locale) < 2)
+	  || ((strlen(locale) > 2) && (locale[2] != '-') && (locale[2] != '_') && (locale[2] != '.')) )
+		return LIBUSB_ERROR_INVALID_PARAM;
+
+	for (i=0; i<ARRAYSIZE(usbi_locale_supported); i++) {
+		if (strncasecmp(usbi_locale_supported[i], locale, 2) == 0)
+			break;
+	}
+	if (i >= ARRAYSIZE(usbi_locale_supported)) {
+		return LIBUSB_ERROR_NOT_FOUND;
+	}
+
+	usbi_locale = i;
+
+	return LIBUSB_SUCCESS;
+}
+
+/** \ingroup libusb_misc
+ * Returns a constant string with a short description of the given error code,
+ * this description is intended for displaying to the end user and will be in
+ * the language set by libusb_setlocale().
+ *
+ * The returned string is encoded in UTF-8.
+ *
+ * The messages always start with a capital letter and end without any dot.
+ * The caller must not free() the returned string.
+ *
+ * \param errcode the error code whose description is desired
+ * \returns a short description of the error code in UTF-8 encoding
+ */
+DEFAULT_VISIBILITY const char* LIBUSB_CALL libusb_strerror(enum libusb_error errcode)
+{
+	int errcode_index = -errcode;
+
+	if ((errcode_index < 0) || (errcode_index >= LIBUSB_ERROR_COUNT)) {
+		/* "Other Error", which should always be our last message, is returned */
+		errcode_index = LIBUSB_ERROR_COUNT - 1;
+	}
+
+	return usbi_localized_errors[usbi_locale][errcode_index];
+}
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/sync.c b/vendor/github.com/karalabe/usb/libusb/libusb/sync.c
new file mode 100644
index 000000000..a609f65f4
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/sync.c
@@ -0,0 +1,327 @@
+/*
+ * Synchronous I/O functions for libusb
+ * Copyright © 2007-2008 Daniel Drake <dsd@gentoo.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <config.h>
+
+#include <errno.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "libusbi.h"
+
+/**
+ * @defgroup libusb_syncio Synchronous device I/O
+ *
+ * This page documents libusb's synchronous (blocking) API for USB device I/O.
+ * This interface is easy to use but has some limitations. More advanced users
+ * may wish to consider using the \ref libusb_asyncio "asynchronous I/O API" instead.
+ */
+
+static void LIBUSB_CALL sync_transfer_cb(struct libusb_transfer *transfer)
+{
+	int *completed = transfer->user_data;
+	*completed = 1;
+	usbi_dbg("actual_length=%d", transfer->actual_length);
+	/* caller interprets result and frees transfer */
+}
+
+static void sync_transfer_wait_for_completion(struct libusb_transfer *transfer)
+{
+	int r, *completed = transfer->user_data;
+	struct libusb_context *ctx = HANDLE_CTX(transfer->dev_handle);
+
+	while (!*completed) {
+		r = libusb_handle_events_completed(ctx, completed);
+		if (r < 0) {
+			if (r == LIBUSB_ERROR_INTERRUPTED)
+				continue;
+			usbi_err(ctx, "libusb_handle_events failed: %s, cancelling transfer and retrying",
+				 libusb_error_name(r));
+			libusb_cancel_transfer(transfer);
+			continue;
+		}
+	}
+}
+
+/** \ingroup libusb_syncio
+ * Perform a USB control transfer.
+ *
+ * The direction of the transfer is inferred from the bmRequestType field of
+ * the setup packet.
+ *
+ * The wValue, wIndex and wLength fields values should be given in host-endian
+ * byte order.
+ *
+ * \param dev_handle a handle for the device to communicate with
+ * \param bmRequestType the request type field for the setup packet
+ * \param bRequest the request field for the setup packet
+ * \param wValue the value field for the setup packet
+ * \param wIndex the index field for the setup packet
+ * \param data a suitably-sized data buffer for either input or output
+ * (depending on direction bits within bmRequestType)
+ * \param wLength the length field for the setup packet. The data buffer should
+ * be at least this size.
+ * \param timeout timeout (in millseconds) that this function should wait
+ * before giving up due to no response being received. For an unlimited
+ * timeout, use value 0.
+ * \returns on success, the number of bytes actually transferred
+ * \returns LIBUSB_ERROR_TIMEOUT if the transfer timed out
+ * \returns LIBUSB_ERROR_PIPE if the control request was not supported by the
+ * device
+ * \returns LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * \returns LIBUSB_ERROR_BUSY if called from event handling context
+ * \returns LIBUSB_ERROR_INVALID_PARAM if the transfer size is larger than
+ * the operating system and/or hardware can support
+ * \returns another LIBUSB_ERROR code on other failures
+ */
+int API_EXPORTED libusb_control_transfer(libusb_device_handle *dev_handle,
+	uint8_t bmRequestType, uint8_t bRequest, uint16_t wValue, uint16_t wIndex,
+	unsigned char *data, uint16_t wLength, unsigned int timeout)
+{
+	struct libusb_transfer *transfer;
+	unsigned char *buffer;
+	int completed = 0;
+	int r;
+
+	if (usbi_handling_events(HANDLE_CTX(dev_handle)))
+		return LIBUSB_ERROR_BUSY;
+
+	transfer = libusb_alloc_transfer(0);
+	if (!transfer)
+		return LIBUSB_ERROR_NO_MEM;
+
+	buffer = (unsigned char*) malloc(LIBUSB_CONTROL_SETUP_SIZE + wLength);
+	if (!buffer) {
+		libusb_free_transfer(transfer);
+		return LIBUSB_ERROR_NO_MEM;
+	}
+
+	libusb_fill_control_setup(buffer, bmRequestType, bRequest, wValue, wIndex,
+		wLength);
+	if ((bmRequestType & LIBUSB_ENDPOINT_DIR_MASK) == LIBUSB_ENDPOINT_OUT)
+		memcpy(buffer + LIBUSB_CONTROL_SETUP_SIZE, data, wLength);
+
+	libusb_fill_control_transfer(transfer, dev_handle, buffer,
+		sync_transfer_cb, &completed, timeout);
+	transfer->flags = LIBUSB_TRANSFER_FREE_BUFFER;
+	r = libusb_submit_transfer(transfer);
+	if (r < 0) {
+		libusb_free_transfer(transfer);
+		return r;
+	}
+
+	sync_transfer_wait_for_completion(transfer);
+
+	if ((bmRequestType & LIBUSB_ENDPOINT_DIR_MASK) == LIBUSB_ENDPOINT_IN)
+		memcpy(data, libusb_control_transfer_get_data(transfer),
+			transfer->actual_length);
+
+	switch (transfer->status) {
+	case LIBUSB_TRANSFER_COMPLETED:
+		r = transfer->actual_length;
+		break;
+	case LIBUSB_TRANSFER_TIMED_OUT:
+		r = LIBUSB_ERROR_TIMEOUT;
+		break;
+	case LIBUSB_TRANSFER_STALL:
+		r = LIBUSB_ERROR_PIPE;
+		break;
+	case LIBUSB_TRANSFER_NO_DEVICE:
+		r = LIBUSB_ERROR_NO_DEVICE;
+		break;
+	case LIBUSB_TRANSFER_OVERFLOW:
+		r = LIBUSB_ERROR_OVERFLOW;
+		break;
+	case LIBUSB_TRANSFER_ERROR:
+	case LIBUSB_TRANSFER_CANCELLED:
+		r = LIBUSB_ERROR_IO;
+		break;
+	default:
+		usbi_warn(HANDLE_CTX(dev_handle),
+			"unrecognised status code %d", transfer->status);
+		r = LIBUSB_ERROR_OTHER;
+	}
+
+	libusb_free_transfer(transfer);
+	return r;
+}
+
+static int do_sync_bulk_transfer(struct libusb_device_handle *dev_handle,
+	unsigned char endpoint, unsigned char *buffer, int length,
+	int *transferred, unsigned int timeout, unsigned char type)
+{
+	struct libusb_transfer *transfer;
+	int completed = 0;
+	int r;
+
+	if (usbi_handling_events(HANDLE_CTX(dev_handle)))
+		return LIBUSB_ERROR_BUSY;
+
+	transfer = libusb_alloc_transfer(0);
+	if (!transfer)
+		return LIBUSB_ERROR_NO_MEM;
+
+	libusb_fill_bulk_transfer(transfer, dev_handle, endpoint, buffer, length,
+		sync_transfer_cb, &completed, timeout);
+	transfer->type = type;
+
+	r = libusb_submit_transfer(transfer);
+	if (r < 0) {
+		libusb_free_transfer(transfer);
+		return r;
+	}
+
+	sync_transfer_wait_for_completion(transfer);
+
+	if (transferred)
+		*transferred = transfer->actual_length;
+
+	switch (transfer->status) {
+	case LIBUSB_TRANSFER_COMPLETED:
+		r = 0;
+		break;
+	case LIBUSB_TRANSFER_TIMED_OUT:
+		r = LIBUSB_ERROR_TIMEOUT;
+		break;
+	case LIBUSB_TRANSFER_STALL:
+		r = LIBUSB_ERROR_PIPE;
+		break;
+	case LIBUSB_TRANSFER_OVERFLOW:
+		r = LIBUSB_ERROR_OVERFLOW;
+		break;
+	case LIBUSB_TRANSFER_NO_DEVICE:
+		r = LIBUSB_ERROR_NO_DEVICE;
+		break;
+	case LIBUSB_TRANSFER_ERROR:
+	case LIBUSB_TRANSFER_CANCELLED:
+		r = LIBUSB_ERROR_IO;
+		break;
+	default:
+		usbi_warn(HANDLE_CTX(dev_handle),
+			"unrecognised status code %d", transfer->status);
+		r = LIBUSB_ERROR_OTHER;
+	}
+
+	libusb_free_transfer(transfer);
+	return r;
+}
+
+/** \ingroup libusb_syncio
+ * Perform a USB bulk transfer. The direction of the transfer is inferred from
+ * the direction bits of the endpoint address.
+ *
+ * For bulk reads, the <tt>length</tt> field indicates the maximum length of
+ * data you are expecting to receive. If less data arrives than expected,
+ * this function will return that data, so be sure to check the
+ * <tt>transferred</tt> output parameter.
+ *
+ * You should also check the <tt>transferred</tt> parameter for bulk writes.
+ * Not all of the data may have been written.
+ *
+ * Also check <tt>transferred</tt> when dealing with a timeout error code.
+ * libusb may have to split your transfer into a number of chunks to satisfy
+ * underlying O/S requirements, meaning that the timeout may expire after
+ * the first few chunks have completed. libusb is careful not to lose any data
+ * that may have been transferred; do not assume that timeout conditions
+ * indicate a complete lack of I/O.
+ *
+ * \param dev_handle a handle for the device to communicate with
+ * \param endpoint the address of a valid endpoint to communicate with
+ * \param data a suitably-sized data buffer for either input or output
+ * (depending on endpoint)
+ * \param length for bulk writes, the number of bytes from data to be sent. for
+ * bulk reads, the maximum number of bytes to receive into the data buffer.
+ * \param transferred output location for the number of bytes actually
+ * transferred. Since version 1.0.21 (\ref LIBUSB_API_VERSION >= 0x01000105),
+ * it is legal to pass a NULL pointer if you do not wish to receive this
+ * information.
+ * \param timeout timeout (in millseconds) that this function should wait
+ * before giving up due to no response being received. For an unlimited
+ * timeout, use value 0.
+ *
+ * \returns 0 on success (and populates <tt>transferred</tt>)
+ * \returns LIBUSB_ERROR_TIMEOUT if the transfer timed out (and populates
+ * <tt>transferred</tt>)
+ * \returns LIBUSB_ERROR_PIPE if the endpoint halted
+ * \returns LIBUSB_ERROR_OVERFLOW if the device offered more data, see
+ * \ref libusb_packetoverflow
+ * \returns LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * \returns LIBUSB_ERROR_BUSY if called from event handling context
+ * \returns another LIBUSB_ERROR code on other failures
+ */
+int API_EXPORTED libusb_bulk_transfer(struct libusb_device_handle *dev_handle,
+	unsigned char endpoint, unsigned char *data, int length, int *transferred,
+	unsigned int timeout)
+{
+	return do_sync_bulk_transfer(dev_handle, endpoint, data, length,
+		transferred, timeout, LIBUSB_TRANSFER_TYPE_BULK);
+}
+
+/** \ingroup libusb_syncio
+ * Perform a USB interrupt transfer. The direction of the transfer is inferred
+ * from the direction bits of the endpoint address.
+ *
+ * For interrupt reads, the <tt>length</tt> field indicates the maximum length
+ * of data you are expecting to receive. If less data arrives than expected,
+ * this function will return that data, so be sure to check the
+ * <tt>transferred</tt> output parameter.
+ *
+ * You should also check the <tt>transferred</tt> parameter for interrupt
+ * writes. Not all of the data may have been written.
+ *
+ * Also check <tt>transferred</tt> when dealing with a timeout error code.
+ * libusb may have to split your transfer into a number of chunks to satisfy
+ * underlying O/S requirements, meaning that the timeout may expire after
+ * the first few chunks have completed. libusb is careful not to lose any data
+ * that may have been transferred; do not assume that timeout conditions
+ * indicate a complete lack of I/O.
+ *
+ * The default endpoint bInterval value is used as the polling interval.
+ *
+ * \param dev_handle a handle for the device to communicate with
+ * \param endpoint the address of a valid endpoint to communicate with
+ * \param data a suitably-sized data buffer for either input or output
+ * (depending on endpoint)
+ * \param length for bulk writes, the number of bytes from data to be sent. for
+ * bulk reads, the maximum number of bytes to receive into the data buffer.
+ * \param transferred output location for the number of bytes actually
+ * transferred. Since version 1.0.21 (\ref LIBUSB_API_VERSION >= 0x01000105),
+ * it is legal to pass a NULL pointer if you do not wish to receive this
+ * information.
+ * \param timeout timeout (in millseconds) that this function should wait
+ * before giving up due to no response being received. For an unlimited
+ * timeout, use value 0.
+ *
+ * \returns 0 on success (and populates <tt>transferred</tt>)
+ * \returns LIBUSB_ERROR_TIMEOUT if the transfer timed out
+ * \returns LIBUSB_ERROR_PIPE if the endpoint halted
+ * \returns LIBUSB_ERROR_OVERFLOW if the device offered more data, see
+ * \ref libusb_packetoverflow
+ * \returns LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * \returns LIBUSB_ERROR_BUSY if called from event handling context
+ * \returns another LIBUSB_ERROR code on other error
+ */
+int API_EXPORTED libusb_interrupt_transfer(
+	struct libusb_device_handle *dev_handle, unsigned char endpoint,
+	unsigned char *data, int length, int *transferred, unsigned int timeout)
+{
+	return do_sync_bulk_transfer(dev_handle, endpoint, data, length,
+		transferred, timeout, LIBUSB_TRANSFER_TYPE_INTERRUPT);
+}
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/version.h b/vendor/github.com/karalabe/usb/libusb/libusb/version.h
new file mode 100644
index 000000000..c6dfe3709
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/version.h
@@ -0,0 +1,18 @@
+/* This file is parsed by m4 and windres and RC.EXE so please keep it simple. */
+#include "version_nano.h"
+#ifndef LIBUSB_MAJOR
+#define LIBUSB_MAJOR 1
+#endif
+#ifndef LIBUSB_MINOR
+#define LIBUSB_MINOR 0
+#endif
+#ifndef LIBUSB_MICRO
+#define LIBUSB_MICRO 22
+#endif
+#ifndef LIBUSB_NANO
+#define LIBUSB_NANO 0
+#endif
+/* LIBUSB_RC is the release candidate suffix. Should normally be empty. */
+#ifndef LIBUSB_RC
+#define LIBUSB_RC ""
+#endif
diff --git a/vendor/github.com/karalabe/usb/libusb/libusb/version_nano.h b/vendor/github.com/karalabe/usb/libusb/libusb/version_nano.h
new file mode 100644
index 000000000..90a782a6b
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/libusb/libusb/version_nano.h
@@ -0,0 +1 @@
+#define LIBUSB_NANO 11312
diff --git a/vendor/github.com/karalabe/usb/raw_disabled.go b/vendor/github.com/karalabe/usb/raw_disabled.go
new file mode 100644
index 000000000..a05ef8ebb
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/raw_disabled.go
@@ -0,0 +1,42 @@
+// usb - Self contained USB and HID library for Go
+// Copyright 2017 The library Authors
+//
+// This library is free software: you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License as published by the Free
+// Software Foundation, either version 3 of the License, or (at your option) any
+// later version.
+//
+// The library is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+// A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License along
+// with the library. If not, see <http://www.gnu.org/licenses/>.
+
+// +build !freebsd,!linux,!darwin,!windows ios !cgo
+
+package usb
+
+// RawDevice is a live raw USB connected device handle. On platforms that this file
+// implements, the type lacks the actual USB device and all methods are noop.
+type RawDevice struct {
+	DeviceInfo // Embed the infos for easier access
+}
+
+// Close releases the USB device handle. On platforms that this file implements,
+// the method is just a noop.
+func (dev *RawDevice) Close() error {
+	return ErrUnsupportedPlatform
+}
+
+// Write sends a binary blob to a USB device. On platforms that this file
+// implements, the method just returns an error.
+func (dev *RawDevice) Write(b []byte) (int, error) {
+	return 0, ErrUnsupportedPlatform
+}
+
+// Read retrieves a binary blob from a USB device. On platforms that this file
+// implements, the method just returns an error.
+func (dev *RawDevice) Read(b []byte) (int, error) {
+	return 0, ErrUnsupportedPlatform
+}
diff --git a/vendor/github.com/karalabe/usb/raw_enabled.go b/vendor/github.com/karalabe/usb/raw_enabled.go
new file mode 100644
index 000000000..326ac97ad
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/raw_enabled.go
@@ -0,0 +1,253 @@
+// usb - Self contained USB and HID library for Go
+// Copyright 2019 The library Authors
+//
+// This library is free software: you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License as published by the Free
+// Software Foundation, either version 3 of the License, or (at your option) any
+// later version.
+//
+// The library is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+// A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License along
+// with the library. If not, see <http://www.gnu.org/licenses/>.
+
+// +build freebsd,cgo linux,cgo darwin,!ios,cgo windows,cgo
+
+package usb
+
+/*
+	#include "./libusb/libusb/libusb.h"
+
+	// ctx is a global libusb context to interact with devices through.
+	libusb_context* ctx;
+*/
+import "C"
+
+import (
+	"fmt"
+	"reflect"
+	"sync"
+	"unsafe"
+)
+
+// enumerateRaw returns a list of all the USB devices attached to the system which
+// match the vendor and product id:
+//  - If the vendor id is set to 0 then any vendor matches.
+//  - If the product id is set to 0 then any product matches.
+//  - If the vendor and product id are both 0, all USB devices are returned.
+func enumerateRaw(vendorID uint16, productID uint16) ([]DeviceInfo, error) {
+	// Enumerate the devices, and free all the matching refcounts (we'll reopen any
+	// explicitly requested).
+	infos, err := enumerateRawWithRef(vendorID, productID)
+	for _, info := range infos {
+		C.libusb_unref_device(info.rawDevice.(*C.libusb_device))
+	}
+	// If enumeration failed, don't return anything, otherwise everything
+	if err != nil {
+		return nil, err
+	}
+	return infos, nil
+}
+
+// enumerateRawWithRef is the internal device enumerator that retains 1 reference
+// to every matched device so they may selectively be opened on request.
+func enumerateRawWithRef(vendorID uint16, productID uint16) ([]DeviceInfo, error) {
+	// Ensure we have a libusb context to interact through. The enumerate call is
+	// protexted by a mutex outside, so it's fine to do the below check and init.
+	if C.ctx == nil {
+		if err := fromRawErrno(C.libusb_init((**C.libusb_context)(&C.ctx))); err != nil {
+			return nil, fmt.Errorf("failed to initialize libusb: %v", err)
+		}
+	}
+	// Retrieve all the available USB devices and wrap them in Go
+	var deviceList **C.libusb_device
+	count := C.libusb_get_device_list(C.ctx, &deviceList)
+	if count < 0 {
+		return nil, rawError(count)
+	}
+	defer C.libusb_free_device_list(deviceList, 1)
+
+	var devices []*C.libusb_device
+	*(*reflect.SliceHeader)(unsafe.Pointer(&devices)) = reflect.SliceHeader{
+		Data: uintptr(unsafe.Pointer(deviceList)),
+		Len:  int(count),
+		Cap:  int(count),
+	}
+	//
+	var infos []DeviceInfo
+	for devnum, dev := range devices {
+		// Retrieve the libusb device descriptor and skip non-queried ones
+		var desc C.struct_libusb_device_descriptor
+		if err := fromRawErrno(C.libusb_get_device_descriptor(dev, &desc)); err != nil {
+			return infos, fmt.Errorf("failed to get device %d descriptor: %v", devnum, err)
+		}
+		if (vendorID > 0 && uint16(desc.idVendor) != vendorID) || (productID > 0 && uint16(desc.idProduct) != productID) {
+			continue
+		}
+		// Skip HID devices, they are handled directly by OS libraries
+		if desc.bDeviceClass == C.LIBUSB_CLASS_HID {
+			continue
+		}
+		// Iterate over all the configurations and find raw interfaces
+		for cfgnum := 0; cfgnum < int(desc.bNumConfigurations); cfgnum++ {
+			// Retrieve the all the possible USB configurations of the device
+			var cfg *C.struct_libusb_config_descriptor
+			if err := fromRawErrno(C.libusb_get_config_descriptor(dev, C.uint8_t(cfgnum), &cfg)); err != nil {
+				return infos, fmt.Errorf("failed to get device %d config %d: %v", devnum, cfgnum, err)
+			}
+			var ifaces []C.struct_libusb_interface
+			*(*reflect.SliceHeader)(unsafe.Pointer(&ifaces)) = reflect.SliceHeader{
+				Data: uintptr(unsafe.Pointer(cfg._interface)),
+				Len:  int(cfg.bNumInterfaces),
+				Cap:  int(cfg.bNumInterfaces),
+			}
+			// Drill down into each advertised interface
+			for ifacenum, iface := range ifaces {
+				if iface.num_altsetting == 0 {
+					continue
+				}
+				var alts []C.struct_libusb_interface_descriptor
+				*(*reflect.SliceHeader)(unsafe.Pointer(&alts)) = reflect.SliceHeader{
+					Data: uintptr(unsafe.Pointer(iface.altsetting)),
+					Len:  int(iface.num_altsetting),
+					Cap:  int(iface.num_altsetting),
+				}
+				for _, alt := range alts {
+					// Skip HID interfaces, they are handled directly by OS libraries
+					if alt.bInterfaceClass == C.LIBUSB_CLASS_HID {
+						continue
+					}
+					// Find the endpoints that can speak libusb interrupts
+					var ends []C.struct_libusb_endpoint_descriptor
+					*(*reflect.SliceHeader)(unsafe.Pointer(&ends)) = reflect.SliceHeader{
+						Data: uintptr(unsafe.Pointer(alt.endpoint)),
+						Len:  int(alt.bNumEndpoints),
+						Cap:  int(alt.bNumEndpoints),
+					}
+					var reader, writer *uint8
+					for _, end := range ends {
+						// Skip any non-interrupt endpoints
+						if end.bmAttributes != C.LIBUSB_TRANSFER_TYPE_INTERRUPT {
+							continue
+						}
+						if end.bEndpointAddress&C.LIBUSB_ENDPOINT_IN == C.LIBUSB_ENDPOINT_IN {
+							reader = new(uint8)
+							*reader = uint8(end.bEndpointAddress)
+						} else {
+							writer = new(uint8)
+							*writer = uint8(end.bEndpointAddress)
+						}
+					}
+					// If both in and out interrupts are available, match the device
+					if reader != nil && writer != nil {
+						// Enumeration matched, bump the device refcount to avoid cleaning it up
+						C.libusb_ref_device(dev)
+
+						port := uint8(C.libusb_get_port_number(dev))
+						infos = append(infos, DeviceInfo{
+							Path:      fmt.Sprintf("%04x:%04x:%02d", vendorID, uint16(desc.idProduct), port),
+							VendorID:  uint16(desc.idVendor),
+							ProductID: uint16(desc.idProduct),
+							Interface: ifacenum,
+							rawDevice: dev,
+							rawPort:   &port,
+							rawReader: reader,
+							rawWriter: writer,
+						})
+					}
+				}
+			}
+		}
+	}
+	return infos, nil
+}
+
+// openRaw connects to a low level libusb device by its path name.
+func openRaw(info DeviceInfo) (*rawDevice, error) {
+	// Enumerate all the devices matching this particular info
+	matches, err := enumerateRawWithRef(info.VendorID, info.ProductID)
+	if err != nil {
+		// Enumeration failed, make sure any subresults are released
+		for _, match := range matches {
+			C.libusb_unref_device(match.rawDevice.(*C.libusb_device))
+		}
+		return nil, err
+	}
+	// Find the specific endpoint we're interested in
+	var device *C.libusb_device
+	for _, match := range matches {
+		// Keep the matching device reference, release anything else
+		if device == nil && *match.rawPort == *info.rawPort && match.Interface == info.Interface {
+			device = match.rawDevice.(*C.libusb_device)
+		} else {
+			C.libusb_unref_device(match.rawDevice.(*C.libusb_device))
+		}
+	}
+	if device == nil {
+		return nil, fmt.Errorf("failed to open device: not found")
+	}
+	// Open the mathcing device
+	info.rawDevice = device
+
+	var handle *C.struct_libusb_device_handle
+	if err := fromRawErrno(C.libusb_open(info.rawDevice.(*C.libusb_device), (**C.struct_libusb_device_handle)(&handle))); err != nil {
+		return nil, fmt.Errorf("failed to open device: %v", err)
+	}
+	if err := fromRawErrno(C.libusb_claim_interface(handle, (C.int)(info.Interface))); err != nil {
+		C.libusb_close(handle)
+		return nil, fmt.Errorf("failed to claim interface: %v", err)
+	}
+	return &rawDevice{
+		DeviceInfo: info,
+		handle:     handle,
+	}, nil
+}
+
+// rawDevice is a live low level USB connected device handle.
+type rawDevice struct {
+	DeviceInfo // Embed the infos for easier access
+
+	handle *C.struct_libusb_device_handle // Low level USB device to communicate through
+	lock   sync.Mutex
+}
+
+// Close releases the raw USB device handle.
+func (dev *rawDevice) Close() error {
+	dev.lock.Lock()
+	defer dev.lock.Unlock()
+
+	if dev.handle != nil {
+		C.libusb_release_interface(dev.handle, (C.int)(dev.Interface))
+		C.libusb_close(dev.handle)
+		dev.handle = nil
+	}
+	C.libusb_unref_device(dev.rawDevice.(*C.libusb_device))
+
+	return nil
+}
+
+// Write sends a binary blob to a low level USB device.
+func (dev *rawDevice) Write(b []byte) (int, error) {
+	dev.lock.Lock()
+	defer dev.lock.Unlock()
+
+	var transferred C.int
+	if err := fromRawErrno(C.libusb_interrupt_transfer(dev.handle, (C.uchar)(*dev.rawWriter), (*C.uchar)(&b[0]), (C.int)(len(b)), &transferred, (C.uint)(0))); err != nil {
+		return 0, fmt.Errorf("failed to write to device: %v", err)
+	}
+	return int(transferred), nil
+}
+
+// Read retrieves a binary blob from a low level USB device.
+func (dev *rawDevice) Read(b []byte) (int, error) {
+	dev.lock.Lock()
+	defer dev.lock.Unlock()
+
+	var transferred C.int
+	if err := fromRawErrno(C.libusb_interrupt_transfer(dev.handle, (C.uchar)(*dev.rawReader), (*C.uchar)(&b[0]), (C.int)(len(b)), &transferred, (C.uint)(0))); err != nil {
+		return 0, fmt.Errorf("failed to read from device: %v", err)
+	}
+	return int(transferred), nil
+}
diff --git a/vendor/github.com/karalabe/usb/raw_errors.go b/vendor/github.com/karalabe/usb/raw_errors.go
new file mode 100644
index 000000000..9e071f861
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/raw_errors.go
@@ -0,0 +1,74 @@
+// Copyright 2013 Google Inc.  All rights reserved.
+// Copyright 2016 the gousb Authors.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package usb
+
+import (
+	"fmt"
+)
+
+// #include "./libusb/libusb/libusb.h"
+import "C"
+
+// rawError is an error code from libusb.
+type rawError C.int
+
+// Error implements the error interface.
+func (e rawError) Error() string {
+	return fmt.Sprintf("libusb: %s [code %d]", rawErrorString[e], e)
+}
+
+// fromRawErrno converts a raw libusb error into a Go type.
+func fromRawErrno(errno C.int) error {
+	err := rawError(errno)
+	if err == errSuccess {
+		return nil
+	}
+	return err
+}
+
+const (
+	errSuccess      rawError = C.LIBUSB_SUCCESS
+	errIO           rawError = C.LIBUSB_ERROR_IO
+	errInvalidParam rawError = C.LIBUSB_ERROR_INVALID_PARAM
+	errAccess       rawError = C.LIBUSB_ERROR_ACCESS
+	errNoDevice     rawError = C.LIBUSB_ERROR_NO_DEVICE
+	errNotFound     rawError = C.LIBUSB_ERROR_NOT_FOUND
+	errBusy         rawError = C.LIBUSB_ERROR_BUSY
+	errTimeout      rawError = C.LIBUSB_ERROR_TIMEOUT
+	errOverflow     rawError = C.LIBUSB_ERROR_OVERFLOW
+	errPipe         rawError = C.LIBUSB_ERROR_PIPE
+	errInterrupted  rawError = C.LIBUSB_ERROR_INTERRUPTED
+	errNoMem        rawError = C.LIBUSB_ERROR_NO_MEM
+	errNotSupported rawError = C.LIBUSB_ERROR_NOT_SUPPORTED
+	errOther        rawError = C.LIBUSB_ERROR_OTHER
+)
+
+var rawErrorString = map[rawError]string{
+	errSuccess:      "success",
+	errIO:           "i/o error",
+	errInvalidParam: "invalid param",
+	errAccess:       "bad access",
+	errNoDevice:     "no device",
+	errNotFound:     "not found",
+	errBusy:         "device or resource busy",
+	errTimeout:      "timeout",
+	errOverflow:     "overflow",
+	errPipe:         "pipe error",
+	errInterrupted:  "interrupted",
+	errNoMem:        "out of memory",
+	errNotSupported: "not supported",
+	errOther:        "unknown error",
+}
diff --git a/vendor/github.com/karalabe/usb/usb.go b/vendor/github.com/karalabe/usb/usb.go
new file mode 100644
index 000000000..96a1e2502
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/usb.go
@@ -0,0 +1,68 @@
+// usb - Self contained USB and HID library for Go
+// Copyright 2019 The library Authors
+//
+// This library is free software: you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License as published by the Free
+// Software Foundation, either version 3 of the License, or (at your option) any
+// later version.
+//
+// The library is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+// A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License along
+// with the library. If not, see <http://www.gnu.org/licenses/>.
+
+// Package usb provide interfaces for generic USB devices.
+package usb
+
+import "errors"
+
+// ErrDeviceClosed is returned for operations where the device closed before or
+// during the execution.
+var ErrDeviceClosed = errors.New("usb: device closed")
+
+// ErrUnsupportedPlatform is returned for all operations where the underlying
+// operating system is not supported by the library.
+var ErrUnsupportedPlatform = errors.New("usb: unsupported platform")
+
+// DeviceInfo contains all the information we know about a USB device. In case of
+// HID devices, that might be a lot more extensive (empty fields for raw USB).
+type DeviceInfo struct {
+	Path         string // Platform-specific device path
+	VendorID     uint16 // Device Vendor ID
+	ProductID    uint16 // Device Product ID
+	Release      uint16 // Device Release Number in binary-coded decimal, also known as Device Version Number
+	Serial       string // Serial Number
+	Manufacturer string // Manufacturer String
+	Product      string // Product string
+	UsagePage    uint16 // Usage Page for this Device/Interface (Windows/Mac only)
+	Usage        uint16 // Usage for this Device/Interface (Windows/Mac only)
+
+	// The USB interface which this logical device
+	// represents. Valid on both Linux implementations
+	// in all cases, and valid on the Windows implementation
+	// only if the device contains more than one interface.
+	Interface int
+
+	// Raw low level libusb endpoint data for simplified communication
+	rawDevice interface{}
+	rawPort   *uint8 // Pointer to differentiate between unset and port 0
+	rawReader *uint8 // Pointer to differentiate between unset and endpoint 0
+	rawWriter *uint8 // Pointer to differentiate between unset and endpoint 0
+}
+
+// Device is a generic USB device interface. It may either be backed by a USB HID
+// device or a low level raw (libusb) device.
+type Device interface {
+	// Close releases the USB device handle.
+	Close() error
+
+	// Write sends a binary blob to a USB device. For HID devices write uses reports,
+	// for low level USB write uses interrupt transfers.
+	Write(b []byte) (int, error)
+
+	// Read retrieves a binary blob from a USB device. For HID devices read uses
+	// reports, for low level USB read uses interrupt transfers.
+	Read(b []byte) (int, error)
+}
diff --git a/vendor/github.com/karalabe/usb/usb_disabled.go b/vendor/github.com/karalabe/usb/usb_disabled.go
new file mode 100644
index 000000000..77c900761
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/usb_disabled.go
@@ -0,0 +1,51 @@
+// usb - Self contained USB and HID library for Go
+// Copyright 2019 The library Authors
+//
+// This library is free software: you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License as published by the Free
+// Software Foundation, either version 3 of the License, or (at your option) any
+// later version.
+//
+// The library is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+// A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License along
+// with the library. If not, see <http://www.gnu.org/licenses/>.
+
+// +build !freebsd,!linux,!darwin,!windows ios !cgo
+
+package usb
+
+// Supported returns whether this platform is supported by the USB library or not.
+// The goal of this method is to allow programatically handling platforms that do
+// not support USB and not having to fall back to build constraints.
+func Supported() bool {
+	return false
+}
+
+// Enumerate returns a list of all the USB devices attached to the system which
+// match the vendor and product id. On platforms that this file implements the
+// function is a noop and returns an empty list always.
+func Enumerate(vendorID uint16, productID uint16) ([]DeviceInfo, error) {
+	return nil, nil
+}
+
+// EnumerateRaw returns a list of all the USB devices attached to the system which
+// match the vendor and product id. On platforms that this file implements the
+// function is a noop and returns an empty list always.
+func EnumerateRaw(vendorID uint16, productID uint16) ([]DeviceInfo, error) {
+	return nil, nil
+}
+
+// EnumerateHid returns a list of all the HID devices attached to the system which
+// match the vendor and product id. On platforms that this file implements the
+// function is a noop and returns an empty list always.
+func EnumerateHid(vendorID uint16, productID uint16) ([]DeviceInfo, error) {
+	return nil, nil
+}
+
+// Open connects to a previsouly discovered USB device.
+func (info DeviceInfo) Open() (Device, error) {
+	return nil, ErrUnsupportedPlatform
+}
diff --git a/vendor/github.com/karalabe/usb/usb_enabled.go b/vendor/github.com/karalabe/usb/usb_enabled.go
new file mode 100644
index 000000000..6ba37af7b
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/usb_enabled.go
@@ -0,0 +1,98 @@
+// usb - Self contained USB and HID library for Go
+// Copyright 2019 The library Authors
+//
+// This library is free software: you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License as published by the Free
+// Software Foundation, either version 3 of the License, or (at your option) any
+// later version.
+//
+// The library is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+// A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License along
+// with the library. If not, see <http://www.gnu.org/licenses/>.
+
+// +build freebsd,cgo linux,cgo darwin,!ios,cgo windows,cgo
+
+package usb
+
+import (
+	"sync"
+)
+
+// enumerateLock is a mutex serializing access to USB device enumeration needed
+// by the macOS USB HID system calls, which require 2 consecutive method calls
+// for enumeration, causing crashes if called concurrently.
+//
+// For more details, see:
+//   https://developer.apple.com/documentation/iokit/1438371-iohidmanagersetdevicematching
+//   > "subsequent calls will cause the hid manager to release previously enumerated devices"
+var enumerateLock sync.Mutex
+
+// Supported returns whether this platform is supported by the USB library or not.
+// The goal of this method is to allow programatically handling platforms that do
+// not support USB and not having to fall back to build constraints.
+func Supported() bool {
+	return true
+}
+
+// Enumerate returns a list of all the USB devices attached to the system which
+// match the vendor and product id:
+//  - If the vendor id is set to 0 then any vendor matches.
+//  - If the product id is set to 0 then any product matches.
+//  - If the vendor and product id are both 0, all devices are returned.
+//
+// For any device that is HID capable, the enumeration will return an interface
+// to the HID endpoints. For pure raw USB access, please use EnumerateRaw.
+func Enumerate(vendorID uint16, productID uint16) ([]DeviceInfo, error) {
+	enumerateLock.Lock()
+	defer enumerateLock.Unlock()
+
+	// Enumerate all the raw USB devices and skip the HID ones
+	raws, err := enumerateRaw(vendorID, productID)
+	if err != nil {
+		return nil, err
+	}
+	// Enumerate all the HID USB devices
+	hids, err := enumerateHid(vendorID, productID)
+	if err != nil {
+		return nil, err
+	}
+	return append(raws, hids...), nil
+}
+
+// EnumerateRaw returns a list of all the USB devices attached to the system which
+// match the vendor and product id:
+//  - If the vendor id is set to 0 then any vendor matches.
+//  - If the product id is set to 0 then any product matches.
+//  - If the vendor and product id are both 0, all devices are returned.
+func EnumerateRaw(vendorID uint16, productID uint16) ([]DeviceInfo, error) {
+	enumerateLock.Lock()
+	defer enumerateLock.Unlock()
+
+	return enumerateRaw(vendorID, productID)
+}
+
+// EnumerateHid returns a list of all the HID devices attached to the system which
+// match the vendor and product id:
+//  - If the vendor id is set to 0 then any vendor matches.
+//  - If the product id is set to 0 then any product matches.
+//  - If the vendor and product id are both 0, all devices are returned.
+func EnumerateHid(vendorID uint16, productID uint16) ([]DeviceInfo, error) {
+	enumerateLock.Lock()
+	defer enumerateLock.Unlock()
+
+	return enumerateHid(vendorID, productID)
+}
+
+// Open connects to a previsouly discovered USB device.
+func (info DeviceInfo) Open() (Device, error) {
+	enumerateLock.Lock()
+	defer enumerateLock.Unlock()
+
+	if info.rawDevice == nil {
+		return openHid(info)
+	}
+	return openRaw(info)
+}
diff --git a/vendor/github.com/karalabe/usb/wchar.go b/vendor/github.com/karalabe/usb/wchar.go
new file mode 100644
index 000000000..cbc7e4d56
--- /dev/null
+++ b/vendor/github.com/karalabe/usb/wchar.go
@@ -0,0 +1,227 @@
+// This file is https://github.com/orofarne/gowchar/blob/master/gowchar.go
+//
+// It was vendored inline to work around CGO limitations that don't allow C types
+// to directly cross package API boundaries.
+//
+// The vendored file is licensed under the 3-clause BSD license, according to:
+// https://github.com/orofarne/gowchar/blob/master/LICENSE
+
+// +build !ios
+// +build freebsd linux darwin windows
+
+package usb
+
+/*
+#include <wchar.h>
+
+const size_t SIZEOF_WCHAR_T = sizeof(wchar_t);
+
+void gowchar_set (wchar_t *arr, int pos, wchar_t val)
+{
+	arr[pos] = val;
+}
+
+wchar_t gowchar_get (wchar_t *arr, int pos)
+{
+	return arr[pos];
+}
+*/
+import "C"
+
+import (
+	"fmt"
+	"unicode/utf16"
+	"unicode/utf8"
+)
+
+var sizeofWcharT C.size_t = C.size_t(C.SIZEOF_WCHAR_T)
+
+func stringToWcharT(s string) (*C.wchar_t, C.size_t) {
+	switch sizeofWcharT {
+	case 2:
+		return stringToWchar2(s) // Windows
+	case 4:
+		return stringToWchar4(s) // Unix
+	default:
+		panic(fmt.Sprintf("Invalid sizeof(wchar_t) = %v", sizeofWcharT))
+	}
+}
+
+func wcharTToString(s *C.wchar_t) (string, error) {
+	switch sizeofWcharT {
+	case 2:
+		return wchar2ToString(s) // Windows
+	case 4:
+		return wchar4ToString(s) // Unix
+	default:
+		panic(fmt.Sprintf("Invalid sizeof(wchar_t) = %v", sizeofWcharT))
+	}
+}
+
+func wcharTNToString(s *C.wchar_t, size C.size_t) (string, error) {
+	switch sizeofWcharT {
+	case 2:
+		return wchar2NToString(s, size) // Windows
+	case 4:
+		return wchar4NToString(s, size) // Unix
+	default:
+		panic(fmt.Sprintf("Invalid sizeof(wchar_t) = %v", sizeofWcharT))
+	}
+}
+
+// Windows
+func stringToWchar2(s string) (*C.wchar_t, C.size_t) {
+	var slen int
+	s1 := s
+	for len(s1) > 0 {
+		r, size := utf8.DecodeRuneInString(s1)
+		if er, _ := utf16.EncodeRune(r); er == '\uFFFD' {
+			slen += 1
+		} else {
+			slen += 2
+		}
+		s1 = s1[size:]
+	}
+	slen++ // \0
+	res := C.malloc(C.size_t(slen) * sizeofWcharT)
+	var i int
+	for len(s) > 0 {
+		r, size := utf8.DecodeRuneInString(s)
+		if r1, r2 := utf16.EncodeRune(r); r1 != '\uFFFD' {
+			C.gowchar_set((*C.wchar_t)(res), C.int(i), C.wchar_t(r1))
+			i++
+			C.gowchar_set((*C.wchar_t)(res), C.int(i), C.wchar_t(r2))
+			i++
+		} else {
+			C.gowchar_set((*C.wchar_t)(res), C.int(i), C.wchar_t(r))
+			i++
+		}
+		s = s[size:]
+	}
+	C.gowchar_set((*C.wchar_t)(res), C.int(slen-1), C.wchar_t(0)) // \0
+	return (*C.wchar_t)(res), C.size_t(slen)
+}
+
+// Unix
+func stringToWchar4(s string) (*C.wchar_t, C.size_t) {
+	slen := utf8.RuneCountInString(s)
+	slen++ // \0
+	res := C.malloc(C.size_t(slen) * sizeofWcharT)
+	var i int
+	for len(s) > 0 {
+		r, size := utf8.DecodeRuneInString(s)
+		C.gowchar_set((*C.wchar_t)(res), C.int(i), C.wchar_t(r))
+		s = s[size:]
+		i++
+	}
+	C.gowchar_set((*C.wchar_t)(res), C.int(slen-1), C.wchar_t(0)) // \0
+	return (*C.wchar_t)(res), C.size_t(slen)
+}
+
+// Windows
+func wchar2ToString(s *C.wchar_t) (string, error) {
+	var i int
+	var res string
+	for {
+		ch := C.gowchar_get(s, C.int(i))
+		if ch == 0 {
+			break
+		}
+		r := rune(ch)
+		i++
+		if !utf16.IsSurrogate(r) {
+			if !utf8.ValidRune(r) {
+				err := fmt.Errorf("Invalid rune at position %v", i)
+				return "", err
+			}
+			res += string(r)
+		} else {
+			ch2 := C.gowchar_get(s, C.int(i))
+			r2 := rune(ch2)
+			r12 := utf16.DecodeRune(r, r2)
+			if r12 == '\uFFFD' {
+				err := fmt.Errorf("Invalid surrogate pair at position %v", i-1)
+				return "", err
+			}
+			res += string(r12)
+			i++
+		}
+	}
+	return res, nil
+}
+
+// Unix
+func wchar4ToString(s *C.wchar_t) (string, error) {
+	var i int
+	var res string
+	for {
+		ch := C.gowchar_get(s, C.int(i))
+		if ch == 0 {
+			break
+		}
+		r := rune(ch)
+		if !utf8.ValidRune(r) {
+			err := fmt.Errorf("Invalid rune at position %v", i)
+			return "", err
+		}
+		res += string(r)
+		i++
+	}
+	return res, nil
+}
+
+// Windows
+func wchar2NToString(s *C.wchar_t, size C.size_t) (string, error) {
+	var i int
+	var res string
+	N := int(size)
+	for i < N {
+		ch := C.gowchar_get(s, C.int(i))
+		if ch == 0 {
+			break
+		}
+		r := rune(ch)
+		i++
+		if !utf16.IsSurrogate(r) {
+			if !utf8.ValidRune(r) {
+				err := fmt.Errorf("Invalid rune at position %v", i)
+				return "", err
+			}
+
+			res += string(r)
+		} else {
+			if i >= N {
+				err := fmt.Errorf("Invalid surrogate pair at position %v", i-1)
+				return "", err
+			}
+			ch2 := C.gowchar_get(s, C.int(i))
+			r2 := rune(ch2)
+			r12 := utf16.DecodeRune(r, r2)
+			if r12 == '\uFFFD' {
+				err := fmt.Errorf("Invalid surrogate pair at position %v", i-1)
+				return "", err
+			}
+			res += string(r12)
+			i++
+		}
+	}
+	return res, nil
+}
+
+// Unix
+func wchar4NToString(s *C.wchar_t, size C.size_t) (string, error) {
+	var i int
+	var res string
+	N := int(size)
+	for i < N {
+		ch := C.gowchar_get(s, C.int(i))
+		r := rune(ch)
+		if !utf8.ValidRune(r) {
+			err := fmt.Errorf("Invalid rune at position %v", i)
+			return "", err
+		}
+		res += string(r)
+		i++
+	}
+	return res, nil
+}
diff --git a/vendor/github.com/usb b/vendor/github.com/usb
new file mode 160000
index 000000000..4ea20957c
--- /dev/null
+++ b/vendor/github.com/usb
@@ -0,0 +1 @@
+Subproject commit 4ea20957c2104ef4130bb8884e6a6dfb4201a4c8
diff --git a/vendor/google.golang.org/protobuf/.gitignore b/vendor/google.golang.org/protobuf/.gitignore
new file mode 100644
index 000000000..698e891b6
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/.gitignore
@@ -0,0 +1,9 @@
+/.cache/
+/.gocache/
+/bin/
+/vendor/
+
+# This file includes artifacts of the system test that should not be checked in.
+# For files created by specific development environment (e.g. editor),
+# use alternative ways to exclude files from git.
+# For example, set up .git/info/exclude or use a global .gitignore.
diff --git a/vendor/google.golang.org/protobuf/.travis.yml b/vendor/google.golang.org/protobuf/.travis.yml
new file mode 100644
index 000000000..c390ccc33
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/.travis.yml
@@ -0,0 +1,16 @@
+language: go
+go: 1.12.x
+install:
+  - unset GOROOT
+  - unset GOPATH
+matrix:
+  include:
+    - os: linux
+      dist: xenial
+    - os: osx
+      osx_image: xcode10.1
+script:
+  - ./test.bash
+cache:
+  directories:
+    - .cache
diff --git a/vendor/google.golang.org/protobuf/AUTHORS b/vendor/google.golang.org/protobuf/AUTHORS
new file mode 100644
index 000000000..2b00ddba0
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/AUTHORS
@@ -0,0 +1,3 @@
+# This source code refers to The Go Authors for copyright purposes.
+# The master list of authors is in the main Go distribution,
+# visible at https://tip.golang.org/AUTHORS.
diff --git a/vendor/google.golang.org/protobuf/CONTRIBUTING.md b/vendor/google.golang.org/protobuf/CONTRIBUTING.md
new file mode 100644
index 000000000..1f8083bb5
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/CONTRIBUTING.md
@@ -0,0 +1,80 @@
+# Contributing to Go Protocol Buffers
+
+Go protocol buffers is an open source project and accepts contributions.
+The source of truth for this repository is at
+[go.googlesource.com/protobuf](https://go.googlesource.com/protobuf).
+The code review tool used is
+[Gerrit Code Review](https://www.gerritcodereview.com/).
+At this time, we are unfortunately unable to accept GitHub pull requests.
+
+
+## Becoming a contributor
+
+The first step is to configure your environment.
+Please follow the steps outlined in
+["Becoming a contributor" (golang.org)](https://golang.org/doc/contribute.html#contributor)
+as the setup for contributing to the `protobuf` project is identical
+to that for contributing to the `go` project.
+
+
+## Before contributing code
+
+The project welcomes submissions, but to make sure things are well coordinated
+we ask that contributors discuss any significant changes before starting work.
+Best practice is to connect your work to the
+[issue tracker](https://github.com/golang/protobuf/issues),
+either by filing a new issue or by claiming an existing issue.
+
+
+## Sending a change via Gerrit
+
+The `protobuf` project performs development in Gerrit.
+Below are the steps to send a change using Gerrit.
+
+
+**Step 1:** Clone the Go source code:
+```
+$ git clone https://go.googlesource.com/protobuf
+```
+
+**Step 2:** Setup a Git hook:
+Setup a hook to run the tests prior to submitting changes to Gerrit:
+```
+$ (cd protobuf/.git/hooks && echo -e '#!/bin/bash\n./test.bash' > pre-push && chmod a+x pre-push)
+```
+
+**Step 3:** Prepare changes in a new branch, created from the `master` branch.
+To commit the changes, use `git codereview change`;
+that will create or amend a single commit in the branch.
+
+```
+$ git checkout -b mybranch
+$ [edit files...]
+$ git add [files...]
+$ git codereview change   # create commit in the branch
+$ [edit again...]
+$ git add [files...]
+$ git codereview change   # amend the existing commit with new changes
+$ [etc.]
+```
+
+**Step 4:** Send the changes for review to Gerrit using `git codereview mail`.
+```
+$ git codereview mail     # send changes to Gerrit
+```
+
+**Step 5:** After a review, there may be changes that are required.
+Do so by applying changes to the same commit and mail them to Gerrit again:
+```
+$ [edit files...]
+$ git add [files...]
+$ git codereview change   # update same commit
+$ git codereview mail     # send to Gerrit again
+```
+
+When calling `git codereview mail`, it will call `git push` under the hood,
+which will trigger the test hook that was setup in step 2.
+
+The [Contribution Guidelines](https://golang.org/doc/contribute.html) for the
+Go project provides additional details that are also relevant to
+contributing to the Go `protobuf` project.
diff --git a/vendor/google.golang.org/protobuf/CONTRIBUTORS b/vendor/google.golang.org/protobuf/CONTRIBUTORS
new file mode 100644
index 000000000..1fbd3e976
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/CONTRIBUTORS
@@ -0,0 +1,3 @@
+# This source code was written by the Go contributors.
+# The master list of contributors is in the main Go distribution,
+# visible at https://tip.golang.org/CONTRIBUTORS.
diff --git a/vendor/google.golang.org/protobuf/LICENSE b/vendor/google.golang.org/protobuf/LICENSE
new file mode 100644
index 000000000..49ea0f928
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2018 The Go Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/google.golang.org/protobuf/PATENTS b/vendor/google.golang.org/protobuf/PATENTS
new file mode 100644
index 000000000..733099041
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/PATENTS
@@ -0,0 +1,22 @@
+Additional IP Rights Grant (Patents)
+
+"This implementation" means the copyrightable works distributed by
+Google as part of the Go project.
+
+Google hereby grants to You a perpetual, worldwide, non-exclusive,
+no-charge, royalty-free, irrevocable (except as stated in this section)
+patent license to make, have made, use, offer to sell, sell, import,
+transfer and otherwise run, modify and propagate the contents of this
+implementation of Go, where such license applies only to those patent
+claims, both currently owned or controlled by Google and acquired in
+the future, licensable by Google that are necessarily infringed by this
+implementation of Go.  This grant does not include claims that would be
+infringed only as a consequence of further modification of this
+implementation.  If you or your agent or exclusive licensee institute or
+order or agree to the institution of patent litigation against any
+entity (including a cross-claim or counterclaim in a lawsuit) alleging
+that this implementation of Go or any code incorporated within this
+implementation of Go constitutes direct or contributory patent
+infringement, or inducement of patent infringement, then any patent
+rights granted to you under this License for this implementation of Go
+shall terminate as of the date such litigation is filed.
diff --git a/vendor/google.golang.org/protobuf/README.md b/vendor/google.golang.org/protobuf/README.md
new file mode 100644
index 000000000..8b598494e
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/README.md
@@ -0,0 +1,327 @@
+# Go support for Protocol Buffers
+
+[![GoDev](https://img.shields.io/static/v1?label=godev&message=reference&color=00add8)](https://pkg.go.dev/mod/google.golang.org/protobuf)
+[![Build Status](https://travis-ci.org/protocolbuffers/protobuf-go.svg?branch=master)](https://travis-ci.org/protocolbuffers/protobuf-go)
+
+This project hosts the Go implementation for
+[protocol buffers](https://developers.google.com/protocol-buffers), which is a
+language-neutral, platform-neutral, extensible mechanism for serializing
+structured data. The protocol buffer language is a language for specifying the
+schema for structured data. This schema is compiled into language specific
+bindings. This project provides both a tool to generate Go code for the
+protocol buffer language, and also the runtime implementation to handle
+serialization of messages in Go. See the
+[protocol buffer developer guide](https://developers.google.com/protocol-buffers/docs/overview)
+for more information about protocol buffers themselves.
+
+This project is comprised of two components:
+
+*   Code generator: The
+    [`protoc-gen-go`](https://pkg.go.dev/google.golang.org/protobuf/cmd/protoc-gen-go)
+    tool is a compiler plugin to `protoc`, the protocol buffer compiler. It
+    augments the `protoc` compiler so that it knows how to
+    [generate Go specific code for a given `.proto` file](https://developers.google.com/protocol-buffers/docs/reference/go-generated).
+
+*   Runtime library: The
+    [`protobuf`](https://pkg.go.dev/mod/google.golang.org/protobuf) module
+    contains a set of Go packages that form the runtime implementation of
+    protobufs in Go. This provides the set of interfaces that
+    [define what a message is](https://pkg.go.dev/google.golang.org/protobuf/reflect/protoreflect)
+    and functionality to serialize message in various formats (e.g.,
+    [wire](https://pkg.go.dev/google.golang.org/protobuf/proto),
+    [JSON](https://pkg.go.dev/google.golang.org/protobuf/encoding/protojson),
+    and
+    [text](https://pkg.go.dev/google.golang.org/protobuf/encoding/prototext)).
+
+See the
+[developer guide for protocol buffers in Go](https://developers.google.com/protocol-buffers/docs/gotutorial)
+for a general guide for how to get started using protobufs in Go.
+
+This project is the second major revision of the Go protocol buffer API
+implemented by the
+[`google.golang.org/protobuf`](https://pkg.go.dev/mod/google.golang.org/protobuf)
+module. The first major version is implemented by the
+[`github.com/golang/protobuf`](https://pkg.go.dev/mod/github.com/golang/protobuf)
+module.
+
+## Package index
+
+Summary of the packages provided by this module:
+
+*   [`proto`](https://pkg.go.dev/google.golang.org/protobuf/proto): Package
+    `proto` provides functions operating on protobuf messages such as cloning,
+    merging, and checking equality, as well as binary serialization.
+*   [`encoding/protojson`](https://pkg.go.dev/google.golang.org/protobuf/encoding/protojson):
+    Package `protojson` serializes protobuf messages as JSON.
+*   [`encoding/prototext`](https://pkg.go.dev/google.golang.org/protobuf/encoding/prototext):
+    Package `prototext` serializes protobuf messages as the text format.
+*   [`encoding/protowire`](https://pkg.go.dev/google.golang.org/protobuf/encoding/protowire):
+    Package `protowire` parses and formats the low-level raw wire encoding. Most
+    users should use package `proto` to serialize messages in the wire format.
+*   [`reflect/protoreflect`](https://pkg.go.dev/google.golang.org/protobuf/reflect/protoreflect):
+    Package `protoreflect` provides interfaces to dynamically manipulate
+    protobuf messages.
+*   [`reflect/protoregistry`](https://pkg.go.dev/google.golang.org/protobuf/reflect/protoregistry):
+    Package `protoregistry` provides data structures to register and lookup
+    protobuf descriptor types.
+*   [`reflect/protodesc`](https://pkg.go.dev/google.golang.org/protobuf/reflect/protodesc):
+    Package `protodesc` provides functionality for converting
+    `descriptorpb.FileDescriptorProto` messages to/from the reflective
+    `protoreflect.FileDescriptor`.
+*   [`testing/protocmp`](https://pkg.go.dev/google.golang.org/protobuf/testing/protocmp):
+    Package `protocmp` provides protobuf specific options for the `cmp` package.
+*   [`testing/protopack`](https://pkg.go.dev/google.golang.org/protobuf/testing/protopack):
+    Package `protopack` aids manual encoding and decoding of the wire format.
+*   [`testing/prototest`](https://pkg.go.dev/google.golang.org/protobuf/testing/prototest):
+    Package `prototest` exercises the protobuf reflection implementation for
+    concrete message types.
+*   [`types/dynamicpb`](https://pkg.go.dev/google.golang.org/protobuf/types/dynamicpb):
+    Package `dynamicpb` creates protobuf messages at runtime from protobuf
+    descriptors.
+*   [`types/known/anypb`](https://pkg.go.dev/google.golang.org/protobuf/types/known/anypb):
+    Package `anypb` is the generated package for `google/protobuf/any.proto`.
+*   [`types/known/emptypb`](https://pkg.go.dev/google.golang.org/protobuf/types/known/emptypb):
+    Package `emptypb` is the generated package for
+    `google/protobuf/empty.proto`.
+*   [`types/known/timestamppb`](https://pkg.go.dev/google.golang.org/protobuf/types/known/timestamppb):
+    Package `timestamppb` is the generated package for
+    `google/protobuf/timestamp.proto`.
+*   [`types/known/durationpb`](https://pkg.go.dev/google.golang.org/protobuf/types/known/durationpb):
+    Package `durationpb` is the generated package for
+    `google/protobuf/duration.proto`.
+*   [`types/known/wrapperspb`](https://pkg.go.dev/google.golang.org/protobuf/types/known/wrapperspb):
+    Package `wrapperspb` is the generated package for
+    `google/protobuf/wrappers.proto`.
+*   [`types/known/structpb`](https://pkg.go.dev/google.golang.org/protobuf/types/known/structpb):
+    Package `structpb` is the generated package for
+    `google/protobuf/struct.proto`.
+*   [`types/descriptorpb`](https://pkg.go.dev/google.golang.org/protobuf/types/descriptorpb):
+    Package `descriptorpb` is the generated package for
+    `google/protobuf/descriptor.proto`.
+*   [`types/pluginpb`](https://pkg.go.dev/google.golang.org/protobuf/types/pluginpb):
+    Package `pluginpb` is the generated package for
+    `google/protobuf/compiler/plugin.proto`.
+*   [`compiler/protogen`](https://pkg.go.dev/google.golang.org/protobuf/compiler/protogen):
+    Package `protogen` provides support for writing protoc plugins.
+*   [`cmd/protoc-gen-go`](https://pkg.go.dev/google.golang.org/protobuf/cmd/protoc-gen-go):
+    The `protoc-gen-go` binary is a protoc plugin to generate a Go protocol
+    buffer package.
+
+## Reporting issues
+
+The issue tracker for this project is currently located at
+[golang/protobuf](https://github.com/golang/protobuf/issues).
+
+Please report any issues there with a sufficient description of the bug or
+feature request. Bug reports should ideally be accompanied by a minimal
+reproduction of the issue. Irreproducible bugs are difficult to diagnose and fix
+(and likely to be closed after some period of time). Bug reports must specify
+the version of the
+[Go protocol buffer module](https://github.com/protocolbuffers/protobuf-go/releases)
+and also the version of the
+[protocol buffer toolchain](https://github.com/protocolbuffers/protobuf/releases)
+being used.
+
+## Contributing
+
+This project is open-source and accepts contributions. See the
+[contribution guide](https://github.com/protocolbuffers/protobuf-go/blob/master/CONTRIBUTING.md)
+for more information.
+
+## Compatibility
+
+This module and the generated code are expected to be stable over time. However,
+we reserve the right to make breaking changes without notice for the following
+reasons:
+
+*   **Security:** A security issue in the specification or implementation may
+    come to light whose resolution requires breaking compatibility. We reserve
+    the right to address such issues.
+*   **Unspecified behavior:** There are some aspects of the protocol buffer
+    specification that are undefined. Programs that depend on unspecified
+    behavior may break in future releases.
+*   **Specification changes:** It may become necessary to address an
+    inconsistency, incompleteness, or change in the protocol buffer
+    specification, which may affect the behavior of existing programs. We
+    reserve the right to address such changes.
+*   **Bugs:** If a package has a bug that violates correctness, a program
+    depending on the buggy behavior may break if the bug is fixed. We reserve
+    the right to fix such bugs.
+*   **Generated additions**: We reserve the right to add new declarations to
+    generated Go packages of `.proto` files. This includes declared constants,
+    variables, functions, types, fields in structs, and methods on types. This
+    may break attempts at injecting additional code on top of what is generated
+    by `protoc-gen-go`. Such practice is not supported by this project.
+*   **Internal changes**: We reserve the right to add, modify, and remove
+    internal code, which includes all unexported declarations, the
+    [`protoc-gen-go/internal_gengo`](https://pkg.go.dev/google.golang.org/protobuf/cmd/protoc-gen-go/internal_gengo)
+    package, the
+    [`runtime/protoimpl`](https://pkg.go.dev/google.golang.org/protobuf/runtime/protoimpl?tab=doc)
+    package, and all packages under
+    [`internal`](https://pkg.go.dev/google.golang.org/protobuf/internal).
+
+Any breaking changes outside of these will be announced 6 months in advance to
+[protobuf@googlegroups.com](https://groups.google.com/forum/#!forum/protobuf).
+
+Users should use generated code produced by a version of
+[`protoc-gen-go`](https://pkg.go.dev/google.golang.org/protobuf/cmd/protoc-gen-go)
+that is identical to the runtime version provided by the
+[protobuf module](https://pkg.go.dev/mod/google.golang.org/protobuf). This
+project promises that the runtime remains compatible with code produced by a
+version of the generator that is no older than 1 year from the version of the
+runtime used, according to the release dates of the minor version. Generated
+code is expected to use a runtime version that is at least as new as the
+generator used to produce it. Generated code contains references to
+[`protoimpl.EnforceVersion`](https://pkg.go.dev/google.golang.org/protobuf/runtime/protoimpl?tab=doc#EnforceVersion)
+to statically ensure that the generated code and runtime do not drift
+sufficiently far apart.
+
+## Historical legacy
+
+This project is the second major revision
+([released in 2020](https://blog.golang.org/a-new-go-api-for-protocol-buffers))
+of the Go protocol buffer API implemented by the
+[`google.golang.org/protobuf`](https://pkg.go.dev/mod/google.golang.org/protobuf)
+module. The first major version
+([released publicly in 2010](https://blog.golang.org/third-party-libraries-goprotobuf-and))
+is implemented by the
+[`github.com/golang/protobuf`](https://pkg.go.dev/mod/github.com/golang/protobuf)
+module.
+
+The first version predates the release of Go 1 by several years. It has a long
+history as one of the first core pieces of infrastructure software ever written
+in Go. As such, the Go protobuf project was one of many pioneers for determining
+what the Go language should even look like and what would eventually be
+considered good design patterns and “idiomatic” Go (by simultaneously being
+both positive and negative examples of it).
+
+Consider the changing signature of the `proto.Unmarshal` function as an example
+of Go language and library evolution throughout the life of this project:
+
+```go
+// 2007/09/25 - Conception of Go
+
+// 2008/11/12
+export func UnMarshal(r io.Read, pb_e reflect.Empty) *os.Error
+
+// 2008/11/13
+export func UnMarshal(buf *[]byte, pb_e reflect.Empty) *os.Error
+
+// 2008/11/24
+export func UnMarshal(buf *[]byte, pb_e interface{}) *os.Error
+
+// 2008/12/18
+export func UnMarshal(buf []byte, pb_e interface{}) *os.Error
+
+// 2009/01/20
+func UnMarshal(buf []byte, pb_e interface{}) *os.Error
+
+// 2009/04/17
+func UnMarshal(buf []byte, pb_e interface{}) os.Error
+
+// 2009/05/22
+func Unmarshal(buf []byte, pb_e interface{}) os.Error
+
+// 2011/11/03
+func Unmarshal(buf []byte, pb_e interface{}) error
+
+// 2012/03/28 - Release of Go 1
+
+// 2012/06/12
+func Unmarshal(buf []byte, pb Message) error
+```
+
+These changes demonstrate the difficulty of determining what the right API is
+for any new technology. It takes time multiplied by many users to determine what
+is best; even then, “best” is often still somewhere over the horizon.
+
+The change on June 6th, 2012 added a degree of type-safety to Go protobufs by
+declaring a new interface that all protobuf messages were required to implement:
+
+```go
+type Message interface {
+   Reset()
+   String() string
+   ProtoMessage()
+}
+```
+
+This interface reduced the set of types that can be passed to `proto.Unmarshal`
+from the universal set of all possible Go types to those with a special
+`ProtoMessage` marker method. The intention of this change is to limit the
+protobuf API to only operate on protobuf data types (i.e., protobuf messages).
+For example, there is no sensible operation if a Go channel were passed to the
+protobuf API as a channel cannot be serialized. The restricted interface would
+prevent that.
+
+This interface does not behaviorally describe what a protobuf message is, but
+acts as a marker with an undocumented expectation that protobuf messages must be
+a Go struct with a specific layout of fields with formatted tags. This
+expectation is not statically enforced by the Go language, for it is an
+implementation detail checked dynamically at runtime using Go reflection. Back
+in 2012, the only types with this marker were those generated by
+`protoc-gen-go`. Since `protoc-gen-go` would always generate messages with the
+proper layout of fields, this was deemed an acceptable and dramatic improvement
+over `interface{}`.
+
+Over the next 10 years,
+[use of Go would skyrocket](https://blog.golang.org/10years) and use of
+protobufs in Go would skyrocket as well. With increased popularity also came
+more diverse usages and requirements for Go protobufs and an increased number of
+custom `proto.Message` implementations that were not generated by
+`protoc-gen-go`.
+
+The increasingly diverse ecosystem of Go types implementing the `proto.Message`
+interface led to incompatibilities, which often occurred when:
+
+*   **Passing custom `proto.Message` types to the protobuf APIs**: A concrete
+    message implementation might work with some top-level functions (e.g.,
+    `proto.Marshal`), but cause others (e.g., `proto.Equal`) to choke and panic.
+    This occurs because the type only had partial support for being an actual
+    message by only implementing the `proto.Marshaler` interface or having
+    malformed struct field tags that happened to work with one function, but not
+    another.
+
+*   **Using Go reflection on any `proto.Message` types**: A common desire is to
+    write general-purpose code that operates on any protobuf message. For
+    example, a microservice might want to populate a `trace_id` field if it is
+    present in a message. To accomplish this, one would use Go reflection to
+    introspect the message type, and assume it were a pointer to a Go struct
+    with a field named `TraceId` (as would be commonly produced by
+    `protoc-gen-go`). If the concrete message type did not match this
+    expectation, it either failed to work or even resulted in a panic. Such was
+    the case for concrete message types that might be backed by a Go map instead
+    of a Go struct.
+
+Both of these issues are solved by following the idiom that _interfaces should
+describe behavior, not data_. This means that the interface itself should
+provide sufficient functionality through its methods that users can introspect
+and interact with all aspects of a protobuf message through a principled API.
+This feature is called _protobuf reflection_. Just as how Go reflection provides
+an API for programmatically interacting with any arbitrary Go value, protobuf
+reflection provides an API for programmatically interacting with any arbitrary
+protobuf message.
+
+Since an interface cannot be extended in a backwards compatible way, this
+suggested the need for a new major version that defines a new `proto.Message`
+interface:
+
+```go
+type Message interface {
+    ProtoReflect() protoreflect.Message
+}
+```
+
+The new
+[`proto.Message`](https://pkg.go.dev/google.golang.org/protobuf/proto?tab=doc#Message)
+interface contains a single `ProtoReflect` method that returns a
+[`protoreflect.Message`](https://pkg.go.dev/google.golang.org/protobuf/reflect/protoreflect?tab=doc#Message),
+which is a reflective view over a protobuf message. In addition to making a
+breaking change to the `proto.Message` interface, we took this opportunity to
+cleanup the supporting functionality that operate on a `proto.Message`, split up
+complicated functionality apart into manageable packages, and to hide
+implementation details away from the public API.
+
+The goal for this major revision is to improve upon all the benefits of, while
+addressing all the shortcomings of the old API. We hope that it will serve the
+Go ecosystem well for the next 10 years and beyond.
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/annotation_test.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/annotation_test.go
new file mode 100644
index 000000000..5108f105c
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/annotation_test.go
@@ -0,0 +1,71 @@
+// 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 main
+
+import (
+	"bytes"
+	"io/ioutil"
+	"testing"
+
+	"google.golang.org/protobuf/encoding/prototext"
+	"google.golang.org/protobuf/internal/fieldnum"
+	"google.golang.org/protobuf/proto"
+
+	"google.golang.org/protobuf/types/descriptorpb"
+)
+
+func TestAnnotations(t *testing.T) {
+	sourceFile, err := ioutil.ReadFile("testdata/annotations/annotations.pb.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	metaFile, err := ioutil.ReadFile("testdata/annotations/annotations.pb.go.meta")
+	if err != nil {
+		t.Fatal(err)
+	}
+	gotInfo := &descriptorpb.GeneratedCodeInfo{}
+	if err := prototext.Unmarshal(metaFile, gotInfo); err != nil {
+		t.Fatalf("can't parse meta file: %v", err)
+	}
+
+	wantInfo := &descriptorpb.GeneratedCodeInfo{}
+	for _, want := range []struct {
+		prefix, text, suffix string
+		path                 []int32
+	}{{
+		"type ", "AnnotationsTestEnum", " int32",
+		[]int32{fieldnum.FileDescriptorProto_EnumType, 0},
+	}, {
+		"\t", "AnnotationsTestEnum_ANNOTATIONS_TEST_ENUM_VALUE", " AnnotationsTestEnum = 0",
+		[]int32{fieldnum.FileDescriptorProto_EnumType, 0, fieldnum.EnumDescriptorProto_Value, 0},
+	}, {
+		"type ", "AnnotationsTestMessage", " struct {",
+		[]int32{fieldnum.FileDescriptorProto_MessageType, 0},
+	}, {
+		"\t", "AnnotationsTestField", " ",
+		[]int32{fieldnum.FileDescriptorProto_MessageType, 0, fieldnum.DescriptorProto_Field, 0},
+	}, {
+		"func (x *AnnotationsTestMessage) ", "GetAnnotationsTestField", "() string {",
+		[]int32{fieldnum.FileDescriptorProto_MessageType, 0, fieldnum.DescriptorProto_Field, 0},
+	}} {
+		s := want.prefix + want.text + want.suffix
+		pos := bytes.Index(sourceFile, []byte(s))
+		if pos < 0 {
+			t.Errorf("source file does not contain: %v", s)
+			continue
+		}
+		begin := pos + len(want.prefix)
+		end := begin + len(want.text)
+		wantInfo.Annotation = append(wantInfo.Annotation, &descriptorpb.GeneratedCodeInfo_Annotation{
+			Path:       want.path,
+			Begin:      proto.Int32(int32(begin)),
+			End:        proto.Int32(int32(end)),
+			SourceFile: proto.String("cmd/protoc-gen-go/testdata/annotations/annotations.proto"),
+		})
+	}
+	if !proto.Equal(gotInfo, wantInfo) {
+		t.Errorf("unexpected annotations for annotations.proto; got:\n%v\nwant:\n%v", gotInfo, wantInfo)
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/internal_gengo/init.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/internal_gengo/init.go
new file mode 100644
index 000000000..369df13da
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/internal_gengo/init.go
@@ -0,0 +1,168 @@
+// Copyright 2019 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 internal_gengo
+
+import (
+	"unicode"
+	"unicode/utf8"
+
+	"google.golang.org/protobuf/compiler/protogen"
+	"google.golang.org/protobuf/encoding/protowire"
+
+	"google.golang.org/protobuf/types/descriptorpb"
+)
+
+type fileInfo struct {
+	*protogen.File
+
+	allEnums      []*enumInfo
+	allMessages   []*messageInfo
+	allExtensions []*extensionInfo
+
+	allEnumsByPtr         map[*enumInfo]int    // value is index into allEnums
+	allMessagesByPtr      map[*messageInfo]int // value is index into allMessages
+	allMessageFieldsByPtr map[*messageInfo]*structFields
+
+	// needRawDesc specifies whether the generator should emit logic to provide
+	// the legacy raw descriptor in GZIP'd form.
+	// This is updated by enum and message generation logic as necessary,
+	// and checked at the end of file generation.
+	needRawDesc bool
+}
+
+type structFields struct {
+	count      int
+	unexported map[int]string
+}
+
+func (sf *structFields) append(name string) {
+	if r, _ := utf8.DecodeRuneInString(name); !unicode.IsUpper(r) {
+		if sf.unexported == nil {
+			sf.unexported = make(map[int]string)
+		}
+		sf.unexported[sf.count] = name
+	}
+	sf.count++
+}
+
+func newFileInfo(file *protogen.File) *fileInfo {
+	f := &fileInfo{File: file}
+
+	// Collect all enums, messages, and extensions in "flattened ordering".
+	// See filetype.TypeBuilder.
+	var walkMessages func([]*protogen.Message, func(*protogen.Message))
+	walkMessages = func(messages []*protogen.Message, f func(*protogen.Message)) {
+		for _, m := range messages {
+			f(m)
+			walkMessages(m.Messages, f)
+		}
+	}
+	initEnumInfos := func(enums []*protogen.Enum) {
+		for _, enum := range enums {
+			f.allEnums = append(f.allEnums, newEnumInfo(f, enum))
+		}
+	}
+	initMessageInfos := func(messages []*protogen.Message) {
+		for _, message := range messages {
+			f.allMessages = append(f.allMessages, newMessageInfo(f, message))
+		}
+	}
+	initExtensionInfos := func(extensions []*protogen.Extension) {
+		for _, extension := range extensions {
+			f.allExtensions = append(f.allExtensions, newExtensionInfo(f, extension))
+		}
+	}
+	initEnumInfos(f.Enums)
+	initMessageInfos(f.Messages)
+	initExtensionInfos(f.Extensions)
+	walkMessages(f.Messages, func(m *protogen.Message) {
+		initEnumInfos(m.Enums)
+		initMessageInfos(m.Messages)
+		initExtensionInfos(m.Extensions)
+	})
+
+	// Derive a reverse mapping of enum and message pointers to their index
+	// in allEnums and allMessages.
+	if len(f.allEnums) > 0 {
+		f.allEnumsByPtr = make(map[*enumInfo]int)
+		for i, e := range f.allEnums {
+			f.allEnumsByPtr[e] = i
+		}
+	}
+	if len(f.allMessages) > 0 {
+		f.allMessagesByPtr = make(map[*messageInfo]int)
+		f.allMessageFieldsByPtr = make(map[*messageInfo]*structFields)
+		for i, m := range f.allMessages {
+			f.allMessagesByPtr[m] = i
+			f.allMessageFieldsByPtr[m] = new(structFields)
+		}
+	}
+
+	return f
+}
+
+type enumInfo struct {
+	*protogen.Enum
+
+	genJSONMethod    bool
+	genRawDescMethod bool
+}
+
+func newEnumInfo(f *fileInfo, enum *protogen.Enum) *enumInfo {
+	e := &enumInfo{Enum: enum}
+	e.genJSONMethod = true
+	e.genRawDescMethod = true
+	return e
+}
+
+type messageInfo struct {
+	*protogen.Message
+
+	genRawDescMethod  bool
+	genExtRangeMethod bool
+
+	isTracked bool
+	hasWeak   bool
+}
+
+func newMessageInfo(f *fileInfo, message *protogen.Message) *messageInfo {
+	m := &messageInfo{Message: message}
+	m.genRawDescMethod = true
+	m.genExtRangeMethod = true
+	m.isTracked = isTrackedMessage(m)
+	for _, field := range m.Fields {
+		m.hasWeak = m.hasWeak || field.Desc.IsWeak()
+	}
+	return m
+}
+
+// isTrackedMessage reports whether field tracking is enabled on the message.
+func isTrackedMessage(m *messageInfo) (tracked bool) {
+	const trackFieldUse_fieldNumber = 37383685
+
+	// Decode the option from unknown fields to avoid a dependency on the
+	// annotation proto from protoc-gen-go.
+	b := m.Desc.Options().(*descriptorpb.MessageOptions).ProtoReflect().GetUnknown()
+	for len(b) > 0 {
+		num, typ, n := protowire.ConsumeTag(b)
+		b = b[n:]
+		if num == trackFieldUse_fieldNumber && typ == protowire.VarintType {
+			v, _ := protowire.ConsumeVarint(b)
+			tracked = protowire.DecodeBool(v)
+		}
+		m := protowire.ConsumeFieldValue(num, typ, b)
+		b = b[m:]
+	}
+	return tracked
+}
+
+type extensionInfo struct {
+	*protogen.Extension
+}
+
+func newExtensionInfo(f *fileInfo, extension *protogen.Extension) *extensionInfo {
+	x := &extensionInfo{Extension: extension}
+	return x
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/internal_gengo/main.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/internal_gengo/main.go
new file mode 100644
index 000000000..d8f86c05d
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/internal_gengo/main.go
@@ -0,0 +1,892 @@
+// 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 internal_gengo is internal to the protobuf module.
+package internal_gengo
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"math"
+	"strconv"
+	"strings"
+	"unicode"
+	"unicode/utf8"
+
+	"google.golang.org/protobuf/compiler/protogen"
+	"google.golang.org/protobuf/internal/encoding/messageset"
+	"google.golang.org/protobuf/internal/encoding/tag"
+	"google.golang.org/protobuf/internal/fieldnum"
+	"google.golang.org/protobuf/internal/genname"
+	"google.golang.org/protobuf/internal/version"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/runtime/protoimpl"
+
+	"google.golang.org/protobuf/types/descriptorpb"
+	"google.golang.org/protobuf/types/pluginpb"
+)
+
+// SupportedFeatures reports the set of supported protobuf language features.
+var SupportedFeatures = uint64(pluginpb.CodeGeneratorResponse_FEATURE_PROTO3_OPTIONAL)
+
+// GenerateVersionMarkers specifies whether to generate version markers.
+var GenerateVersionMarkers = true
+
+// Standard library dependencies.
+const (
+	mathPackage    = protogen.GoImportPath("math")
+	reflectPackage = protogen.GoImportPath("reflect")
+	syncPackage    = protogen.GoImportPath("sync")
+)
+
+// Protobuf library dependencies.
+//
+// These are declared as an interface type so that they can be more easily
+// patched to support unique build environments that impose restrictions
+// on the dependencies of generated source code.
+var (
+	protoPackage        goImportPath = protogen.GoImportPath("google.golang.org/protobuf/proto")
+	protoifacePackage   goImportPath = protogen.GoImportPath("google.golang.org/protobuf/runtime/protoiface")
+	protoimplPackage    goImportPath = protogen.GoImportPath("google.golang.org/protobuf/runtime/protoimpl")
+	protoreflectPackage goImportPath = protogen.GoImportPath("google.golang.org/protobuf/reflect/protoreflect")
+	protoV1Package      goImportPath = protogen.GoImportPath("github.com/golang/protobuf/proto")
+)
+
+type goImportPath interface {
+	String() string
+	Ident(string) protogen.GoIdent
+}
+
+// GenerateFile generates the contents of a .pb.go file.
+func GenerateFile(gen *protogen.Plugin, file *protogen.File) *protogen.GeneratedFile {
+	filename := file.GeneratedFilenamePrefix + ".pb.go"
+	g := gen.NewGeneratedFile(filename, file.GoImportPath)
+	f := newFileInfo(file)
+
+	genStandaloneComments(g, f, fieldnum.FileDescriptorProto_Syntax)
+	genGeneratedHeader(gen, g, f)
+	genStandaloneComments(g, f, fieldnum.FileDescriptorProto_Package)
+	g.P("package ", f.GoPackageName)
+	g.P()
+
+	// Emit a static check that enforces a minimum version of the proto package.
+	if GenerateVersionMarkers {
+		g.P("const (")
+		g.P("// Verify that this generated code is sufficiently up-to-date.")
+		g.P("_ = ", protoimplPackage.Ident("EnforceVersion"), "(", protoimpl.GenVersion, " - ", protoimplPackage.Ident("MinVersion"), ")")
+		g.P("// Verify that runtime/protoimpl is sufficiently up-to-date.")
+		g.P("_ = ", protoimplPackage.Ident("EnforceVersion"), "(", protoimplPackage.Ident("MaxVersion"), " - ", protoimpl.GenVersion, ")")
+		g.P(")")
+		g.P()
+
+		// TODO: Remove this after some soak-in period after the v2 release.
+		g.P("// This is a compile-time assertion that a sufficiently up-to-date version")
+		g.P("// of the legacy proto package is being used.")
+		g.P("const _ = ", protoV1Package.Ident("ProtoPackageIsVersion4"))
+		g.P()
+	}
+
+	for i, imps := 0, f.Desc.Imports(); i < imps.Len(); i++ {
+		genImport(gen, g, f, imps.Get(i))
+	}
+	for _, enum := range f.allEnums {
+		genEnum(g, f, enum)
+	}
+	for _, message := range f.allMessages {
+		genMessage(g, f, message)
+	}
+	genExtensions(g, f)
+
+	genReflectFileDescriptor(gen, g, f)
+
+	return g
+}
+
+// genStandaloneComments prints all leading comments for a FileDescriptorProto
+// location identified by the field number n.
+func genStandaloneComments(g *protogen.GeneratedFile, f *fileInfo, n int32) {
+	for _, loc := range f.Proto.GetSourceCodeInfo().GetLocation() {
+		if len(loc.Path) == 1 && loc.Path[0] == n {
+			for _, s := range loc.GetLeadingDetachedComments() {
+				g.P(protogen.Comments(s))
+				g.P()
+			}
+			if s := loc.GetLeadingComments(); s != "" {
+				g.P(protogen.Comments(s))
+				g.P()
+			}
+		}
+	}
+}
+
+func genGeneratedHeader(gen *protogen.Plugin, g *protogen.GeneratedFile, f *fileInfo) {
+	g.P("// Code generated by protoc-gen-go. DO NOT EDIT.")
+
+	if GenerateVersionMarkers {
+		g.P("// versions:")
+		protocGenGoVersion := version.String()
+		protocVersion := "(unknown)"
+		if v := gen.Request.GetCompilerVersion(); v != nil {
+			protocVersion = fmt.Sprintf("v%v.%v.%v", v.GetMajor(), v.GetMinor(), v.GetPatch())
+		}
+		g.P("// \tprotoc-gen-go ", protocGenGoVersion)
+		g.P("// \tprotoc        ", protocVersion)
+	}
+
+	if f.Proto.GetOptions().GetDeprecated() {
+		g.P("// ", f.Desc.Path(), " is a deprecated file.")
+	} else {
+		g.P("// source: ", f.Desc.Path())
+	}
+	g.P()
+}
+
+func genImport(gen *protogen.Plugin, g *protogen.GeneratedFile, f *fileInfo, imp protoreflect.FileImport) {
+	impFile, ok := gen.FilesByPath[imp.Path()]
+	if !ok {
+		return
+	}
+	if impFile.GoImportPath == f.GoImportPath {
+		// Don't generate imports or aliases for types in the same Go package.
+		return
+	}
+	// Generate imports for all non-weak dependencies, even if they are not
+	// referenced, because other code and tools depend on having the
+	// full transitive closure of protocol buffer types in the binary.
+	if !imp.IsWeak {
+		g.Import(impFile.GoImportPath)
+	}
+	if !imp.IsPublic {
+		return
+	}
+
+	// Generate public imports by generating the imported file, parsing it,
+	// and extracting every symbol that should receive a forwarding declaration.
+	impGen := GenerateFile(gen, impFile)
+	impGen.Skip()
+	b, err := impGen.Content()
+	if err != nil {
+		gen.Error(err)
+		return
+	}
+	fset := token.NewFileSet()
+	astFile, err := parser.ParseFile(fset, "", b, parser.ParseComments)
+	if err != nil {
+		gen.Error(err)
+		return
+	}
+	genForward := func(tok token.Token, name string, expr ast.Expr) {
+		// Don't import unexported symbols.
+		r, _ := utf8.DecodeRuneInString(name)
+		if !unicode.IsUpper(r) {
+			return
+		}
+		// Don't import the FileDescriptor.
+		if name == impFile.GoDescriptorIdent.GoName {
+			return
+		}
+		// Don't import decls referencing a symbol defined in another package.
+		// i.e., don't import decls which are themselves public imports:
+		//
+		//	type T = somepackage.T
+		if _, ok := expr.(*ast.SelectorExpr); ok {
+			return
+		}
+		g.P(tok, " ", name, " = ", impFile.GoImportPath.Ident(name))
+	}
+	g.P("// Symbols defined in public import of ", imp.Path(), ".")
+	g.P()
+	for _, decl := range astFile.Decls {
+		switch decl := decl.(type) {
+		case *ast.GenDecl:
+			for _, spec := range decl.Specs {
+				switch spec := spec.(type) {
+				case *ast.TypeSpec:
+					genForward(decl.Tok, spec.Name.Name, spec.Type)
+				case *ast.ValueSpec:
+					for i, name := range spec.Names {
+						var expr ast.Expr
+						if i < len(spec.Values) {
+							expr = spec.Values[i]
+						}
+						genForward(decl.Tok, name.Name, expr)
+					}
+				case *ast.ImportSpec:
+				default:
+					panic(fmt.Sprintf("can't generate forward for spec type %T", spec))
+				}
+			}
+		}
+	}
+	g.P()
+}
+
+func genEnum(g *protogen.GeneratedFile, f *fileInfo, e *enumInfo) {
+	// Enum type declaration.
+	g.Annotate(e.GoIdent.GoName, e.Location)
+	leadingComments := appendDeprecationSuffix(e.Comments.Leading,
+		e.Desc.Options().(*descriptorpb.EnumOptions).GetDeprecated())
+	g.P(leadingComments,
+		"type ", e.GoIdent, " int32")
+
+	// Enum value constants.
+	g.P("const (")
+	for _, value := range e.Values {
+		g.Annotate(value.GoIdent.GoName, value.Location)
+		leadingComments := appendDeprecationSuffix(value.Comments.Leading,
+			value.Desc.Options().(*descriptorpb.EnumValueOptions).GetDeprecated())
+		g.P(leadingComments,
+			value.GoIdent, " ", e.GoIdent, " = ", value.Desc.Number(),
+			trailingComment(value.Comments.Trailing))
+	}
+	g.P(")")
+	g.P()
+
+	// Enum value maps.
+	g.P("// Enum value maps for ", e.GoIdent, ".")
+	g.P("var (")
+	g.P(e.GoIdent.GoName+"_name", " = map[int32]string{")
+	for _, value := range e.Values {
+		duplicate := ""
+		if value.Desc != e.Desc.Values().ByNumber(value.Desc.Number()) {
+			duplicate = "// Duplicate value: "
+		}
+		g.P(duplicate, value.Desc.Number(), ": ", strconv.Quote(string(value.Desc.Name())), ",")
+	}
+	g.P("}")
+	g.P(e.GoIdent.GoName+"_value", " = map[string]int32{")
+	for _, value := range e.Values {
+		g.P(strconv.Quote(string(value.Desc.Name())), ": ", value.Desc.Number(), ",")
+	}
+	g.P("}")
+	g.P(")")
+	g.P()
+
+	// Enum method.
+	//
+	// NOTE: A pointer value is needed to represent presence in proto2.
+	// Since a proto2 message can reference a proto3 enum, it is useful to
+	// always generate this method (even on proto3 enums) to support that case.
+	g.P("func (x ", e.GoIdent, ") Enum() *", e.GoIdent, " {")
+	g.P("p := new(", e.GoIdent, ")")
+	g.P("*p = x")
+	g.P("return p")
+	g.P("}")
+	g.P()
+
+	// String method.
+	g.P("func (x ", e.GoIdent, ") String() string {")
+	g.P("return ", protoimplPackage.Ident("X"), ".EnumStringOf(x.Descriptor(), ", protoreflectPackage.Ident("EnumNumber"), "(x))")
+	g.P("}")
+	g.P()
+
+	genEnumReflectMethods(g, f, e)
+
+	// UnmarshalJSON method.
+	if e.genJSONMethod && e.Desc.Syntax() == protoreflect.Proto2 {
+		g.P("// Deprecated: Do not use.")
+		g.P("func (x *", e.GoIdent, ") UnmarshalJSON(b []byte) error {")
+		g.P("num, err := ", protoimplPackage.Ident("X"), ".UnmarshalJSONEnum(x.Descriptor(), b)")
+		g.P("if err != nil {")
+		g.P("return err")
+		g.P("}")
+		g.P("*x = ", e.GoIdent, "(num)")
+		g.P("return nil")
+		g.P("}")
+		g.P()
+	}
+
+	// EnumDescriptor method.
+	if e.genRawDescMethod {
+		var indexes []string
+		for i := 1; i < len(e.Location.Path); i += 2 {
+			indexes = append(indexes, strconv.Itoa(int(e.Location.Path[i])))
+		}
+		g.P("// Deprecated: Use ", e.GoIdent, ".Descriptor instead.")
+		g.P("func (", e.GoIdent, ") EnumDescriptor() ([]byte, []int) {")
+		g.P("return ", rawDescVarName(f), "GZIP(), []int{", strings.Join(indexes, ","), "}")
+		g.P("}")
+		g.P()
+		f.needRawDesc = true
+	}
+}
+
+func genMessage(g *protogen.GeneratedFile, f *fileInfo, m *messageInfo) {
+	if m.Desc.IsMapEntry() {
+		return
+	}
+
+	// Message type declaration.
+	g.Annotate(m.GoIdent.GoName, m.Location)
+	leadingComments := appendDeprecationSuffix(m.Comments.Leading,
+		m.Desc.Options().(*descriptorpb.MessageOptions).GetDeprecated())
+	g.P(leadingComments,
+		"type ", m.GoIdent, " struct {")
+	genMessageFields(g, f, m)
+	g.P("}")
+	g.P()
+
+	genMessageDefaultDecls(g, f, m)
+	genMessageMethods(g, f, m)
+	genMessageOneofWrapperTypes(g, f, m)
+}
+
+func genMessageFields(g *protogen.GeneratedFile, f *fileInfo, m *messageInfo) {
+	sf := f.allMessageFieldsByPtr[m]
+	genMessageInternalFields(g, f, m, sf)
+	for _, field := range m.Fields {
+		genMessageField(g, f, m, field, sf)
+	}
+}
+
+func genMessageInternalFields(g *protogen.GeneratedFile, f *fileInfo, m *messageInfo, sf *structFields) {
+	g.P(genname.State, " ", protoimplPackage.Ident("MessageState"))
+	sf.append(genname.State)
+	g.P(genname.SizeCache, " ", protoimplPackage.Ident("SizeCache"))
+	sf.append(genname.SizeCache)
+	if m.hasWeak {
+		g.P(genname.WeakFields, " ", protoimplPackage.Ident("WeakFields"))
+		sf.append(genname.WeakFields)
+	}
+	g.P(genname.UnknownFields, " ", protoimplPackage.Ident("UnknownFields"))
+	sf.append(genname.UnknownFields)
+	if m.Desc.ExtensionRanges().Len() > 0 {
+		g.P(genname.ExtensionFields, " ", protoimplPackage.Ident("ExtensionFields"))
+		sf.append(genname.ExtensionFields)
+	}
+	if sf.count > 0 {
+		g.P()
+	}
+}
+
+func genMessageField(g *protogen.GeneratedFile, f *fileInfo, m *messageInfo, field *protogen.Field, sf *structFields) {
+	if oneof := field.Oneof; oneof != nil && !oneof.Desc.IsSynthetic() {
+		// It would be a bit simpler to iterate over the oneofs below,
+		// but generating the field here keeps the contents of the Go
+		// struct in the same order as the contents of the source
+		// .proto file.
+		if oneof.Fields[0] != field {
+			return // only generate for first appearance
+		}
+
+		tags := structTags{
+			{"protobuf_oneof", string(oneof.Desc.Name())},
+		}
+		if m.isTracked {
+			tags = append(tags, gotrackTags...)
+		}
+
+		g.Annotate(m.GoIdent.GoName+"."+oneof.GoName, oneof.Location)
+		leadingComments := oneof.Comments.Leading
+		if leadingComments != "" {
+			leadingComments += "\n"
+		}
+		ss := []string{fmt.Sprintf(" Types that are assignable to %s:\n", oneof.GoName)}
+		for _, field := range oneof.Fields {
+			ss = append(ss, "\t*"+field.GoIdent.GoName+"\n")
+		}
+		leadingComments += protogen.Comments(strings.Join(ss, ""))
+		g.P(leadingComments,
+			oneof.GoName, " ", oneofInterfaceName(oneof), tags)
+		sf.append(oneof.GoName)
+		return
+	}
+	goType, pointer := fieldGoType(g, f, field)
+	if pointer {
+		goType = "*" + goType
+	}
+	tags := structTags{
+		{"protobuf", fieldProtobufTagValue(field)},
+		{"json", fieldJSONTagValue(field)},
+	}
+	if field.Desc.IsMap() {
+		key := field.Message.Fields[0]
+		val := field.Message.Fields[1]
+		tags = append(tags, structTags{
+			{"protobuf_key", fieldProtobufTagValue(key)},
+			{"protobuf_val", fieldProtobufTagValue(val)},
+		}...)
+	}
+	if m.isTracked {
+		tags = append(tags, gotrackTags...)
+	}
+
+	name := field.GoName
+	if field.Desc.IsWeak() {
+		name = genname.WeakFieldPrefix + name
+	}
+	g.Annotate(m.GoIdent.GoName+"."+name, field.Location)
+	leadingComments := appendDeprecationSuffix(field.Comments.Leading,
+		field.Desc.Options().(*descriptorpb.FieldOptions).GetDeprecated())
+	g.P(leadingComments,
+		name, " ", goType, tags,
+		trailingComment(field.Comments.Trailing))
+	sf.append(field.GoName)
+}
+
+// genMessageDefaultDecls generates consts and vars holding the default
+// values of fields.
+func genMessageDefaultDecls(g *protogen.GeneratedFile, f *fileInfo, m *messageInfo) {
+	var consts, vars []string
+	for _, field := range m.Fields {
+		if !field.Desc.HasDefault() {
+			continue
+		}
+		name := "Default_" + m.GoIdent.GoName + "_" + field.GoName
+		goType, _ := fieldGoType(g, f, field)
+		defVal := field.Desc.Default()
+		switch field.Desc.Kind() {
+		case protoreflect.StringKind:
+			consts = append(consts, fmt.Sprintf("%s = %s(%q)", name, goType, defVal.String()))
+		case protoreflect.BytesKind:
+			vars = append(vars, fmt.Sprintf("%s = %s(%q)", name, goType, defVal.Bytes()))
+		case protoreflect.EnumKind:
+			idx := field.Desc.DefaultEnumValue().Index()
+			val := field.Enum.Values[idx]
+			consts = append(consts, fmt.Sprintf("%s = %s", name, g.QualifiedGoIdent(val.GoIdent)))
+		case protoreflect.FloatKind, protoreflect.DoubleKind:
+			if f := defVal.Float(); math.IsNaN(f) || math.IsInf(f, 0) {
+				var fn, arg string
+				switch f := defVal.Float(); {
+				case math.IsInf(f, -1):
+					fn, arg = g.QualifiedGoIdent(mathPackage.Ident("Inf")), "-1"
+				case math.IsInf(f, +1):
+					fn, arg = g.QualifiedGoIdent(mathPackage.Ident("Inf")), "+1"
+				case math.IsNaN(f):
+					fn, arg = g.QualifiedGoIdent(mathPackage.Ident("NaN")), ""
+				}
+				vars = append(vars, fmt.Sprintf("%s = %s(%s(%s))", name, goType, fn, arg))
+			} else {
+				consts = append(consts, fmt.Sprintf("%s = %s(%v)", name, goType, f))
+			}
+		default:
+			consts = append(consts, fmt.Sprintf("%s = %s(%v)", name, goType, defVal.Interface()))
+		}
+	}
+	if len(consts) > 0 {
+		g.P("// Default values for ", m.GoIdent, " fields.")
+		g.P("const (")
+		for _, s := range consts {
+			g.P(s)
+		}
+		g.P(")")
+	}
+	if len(vars) > 0 {
+		g.P("// Default values for ", m.GoIdent, " fields.")
+		g.P("var (")
+		for _, s := range vars {
+			g.P(s)
+		}
+		g.P(")")
+	}
+	g.P()
+}
+
+func genMessageMethods(g *protogen.GeneratedFile, f *fileInfo, m *messageInfo) {
+	genMessageBaseMethods(g, f, m)
+	genMessageGetterMethods(g, f, m)
+	genMessageSetterMethods(g, f, m)
+}
+
+func genMessageBaseMethods(g *protogen.GeneratedFile, f *fileInfo, m *messageInfo) {
+	// Reset method.
+	g.P("func (x *", m.GoIdent, ") Reset() {")
+	g.P("*x = ", m.GoIdent, "{}")
+	g.P("if ", protoimplPackage.Ident("UnsafeEnabled"), " {")
+	g.P("mi := &", messageTypesVarName(f), "[", f.allMessagesByPtr[m], "]")
+	g.P("ms := ", protoimplPackage.Ident("X"), ".MessageStateOf(", protoimplPackage.Ident("Pointer"), "(x))")
+	g.P("ms.StoreMessageInfo(mi)")
+	g.P("}")
+	g.P("}")
+	g.P()
+
+	// String method.
+	g.P("func (x *", m.GoIdent, ") String() string {")
+	g.P("return ", protoimplPackage.Ident("X"), ".MessageStringOf(x)")
+	g.P("}")
+	g.P()
+
+	// ProtoMessage method.
+	g.P("func (*", m.GoIdent, ") ProtoMessage() {}")
+	g.P()
+
+	// ProtoReflect method.
+	genMessageReflectMethods(g, f, m)
+
+	// Descriptor method.
+	if m.genRawDescMethod {
+		var indexes []string
+		for i := 1; i < len(m.Location.Path); i += 2 {
+			indexes = append(indexes, strconv.Itoa(int(m.Location.Path[i])))
+		}
+		g.P("// Deprecated: Use ", m.GoIdent, ".ProtoReflect.Descriptor instead.")
+		g.P("func (*", m.GoIdent, ") Descriptor() ([]byte, []int) {")
+		g.P("return ", rawDescVarName(f), "GZIP(), []int{", strings.Join(indexes, ","), "}")
+		g.P("}")
+		g.P()
+		f.needRawDesc = true
+	}
+
+	// ExtensionRangeArray method.
+	extRanges := m.Desc.ExtensionRanges()
+	if m.genExtRangeMethod && extRanges.Len() > 0 {
+		protoExtRange := protoifacePackage.Ident("ExtensionRangeV1")
+		extRangeVar := "extRange_" + m.GoIdent.GoName
+		g.P("var ", extRangeVar, " = []", protoExtRange, " {")
+		for i := 0; i < extRanges.Len(); i++ {
+			r := extRanges.Get(i)
+			g.P("{Start:", r[0], ", End:", r[1]-1 /* inclusive */, "},")
+		}
+		g.P("}")
+		g.P()
+		g.P("// Deprecated: Use ", m.GoIdent, ".ProtoReflect.Descriptor.ExtensionRanges instead.")
+		g.P("func (*", m.GoIdent, ") ExtensionRangeArray() []", protoExtRange, " {")
+		g.P("return ", extRangeVar)
+		g.P("}")
+		g.P()
+	}
+}
+
+func genMessageGetterMethods(g *protogen.GeneratedFile, f *fileInfo, m *messageInfo) {
+	for _, field := range m.Fields {
+		genNoInterfacePragma(g, m.isTracked)
+
+		// Getter for parent oneof.
+		if oneof := field.Oneof; oneof != nil && oneof.Fields[0] == field && !oneof.Desc.IsSynthetic() {
+			g.Annotate(m.GoIdent.GoName+".Get"+oneof.GoName, oneof.Location)
+			g.P("func (m *", m.GoIdent.GoName, ") Get", oneof.GoName, "() ", oneofInterfaceName(oneof), " {")
+			g.P("if m != nil {")
+			g.P("return m.", oneof.GoName)
+			g.P("}")
+			g.P("return nil")
+			g.P("}")
+			g.P()
+		}
+
+		// Getter for message field.
+		goType, pointer := fieldGoType(g, f, field)
+		defaultValue := fieldDefaultValue(g, m, field)
+		g.Annotate(m.GoIdent.GoName+".Get"+field.GoName, field.Location)
+		leadingComments := appendDeprecationSuffix("",
+			field.Desc.Options().(*descriptorpb.FieldOptions).GetDeprecated())
+		switch {
+		case field.Desc.IsWeak():
+			g.P(leadingComments, "func (x *", m.GoIdent, ") Get", field.GoName, "() ", protoPackage.Ident("Message"), "{")
+			g.P("var w ", protoimplPackage.Ident("WeakFields"))
+			g.P("if x != nil {")
+			g.P("w = x.", genname.WeakFields)
+			if m.isTracked {
+				g.P("_ = x.", genname.WeakFieldPrefix+field.GoName)
+			}
+			g.P("}")
+			g.P("return ", protoimplPackage.Ident("X"), ".GetWeak(w, ", field.Desc.Number(), ", ", strconv.Quote(string(field.Message.Desc.FullName())), ")")
+			g.P("}")
+		case field.Oneof != nil && !field.Oneof.Desc.IsSynthetic():
+			g.P(leadingComments, "func (x *", m.GoIdent, ") Get", field.GoName, "() ", goType, " {")
+			g.P("if x, ok := x.Get", field.Oneof.GoName, "().(*", field.GoIdent, "); ok {")
+			g.P("return x.", field.GoName)
+			g.P("}")
+			g.P("return ", defaultValue)
+			g.P("}")
+		default:
+			g.P(leadingComments, "func (x *", m.GoIdent, ") Get", field.GoName, "() ", goType, " {")
+			if !field.Desc.HasPresence() || defaultValue == "nil" {
+				g.P("if x != nil {")
+			} else {
+				g.P("if x != nil && x.", field.GoName, " != nil {")
+			}
+			star := ""
+			if pointer {
+				star = "*"
+			}
+			g.P("return ", star, " x.", field.GoName)
+			g.P("}")
+			g.P("return ", defaultValue)
+			g.P("}")
+		}
+		g.P()
+	}
+}
+
+func genMessageSetterMethods(g *protogen.GeneratedFile, f *fileInfo, m *messageInfo) {
+	for _, field := range m.Fields {
+		if !field.Desc.IsWeak() {
+			continue
+		}
+
+		genNoInterfacePragma(g, m.isTracked)
+
+		g.Annotate(m.GoIdent.GoName+".Set"+field.GoName, field.Location)
+		leadingComments := appendDeprecationSuffix("",
+			field.Desc.Options().(*descriptorpb.FieldOptions).GetDeprecated())
+		g.P(leadingComments, "func (x *", m.GoIdent, ") Set", field.GoName, "(v ", protoPackage.Ident("Message"), ") {")
+		g.P("var w *", protoimplPackage.Ident("WeakFields"))
+		g.P("if x != nil {")
+		g.P("w = &x.", genname.WeakFields)
+		if m.isTracked {
+			g.P("_ = x.", genname.WeakFieldPrefix+field.GoName)
+		}
+		g.P("}")
+		g.P(protoimplPackage.Ident("X"), ".SetWeak(w, ", field.Desc.Number(), ", ", strconv.Quote(string(field.Message.Desc.FullName())), ", v)")
+		g.P("}")
+		g.P()
+	}
+}
+
+// fieldGoType returns the Go type used for a field.
+//
+// If it returns pointer=true, the struct field is a pointer to the type.
+func fieldGoType(g *protogen.GeneratedFile, f *fileInfo, field *protogen.Field) (goType string, pointer bool) {
+	if field.Desc.IsWeak() {
+		return "struct{}", false
+	}
+
+	pointer = field.Desc.HasPresence()
+	switch field.Desc.Kind() {
+	case protoreflect.BoolKind:
+		goType = "bool"
+	case protoreflect.EnumKind:
+		goType = g.QualifiedGoIdent(field.Enum.GoIdent)
+	case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
+		goType = "int32"
+	case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
+		goType = "uint32"
+	case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
+		goType = "int64"
+	case protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
+		goType = "uint64"
+	case protoreflect.FloatKind:
+		goType = "float32"
+	case protoreflect.DoubleKind:
+		goType = "float64"
+	case protoreflect.StringKind:
+		goType = "string"
+	case protoreflect.BytesKind:
+		goType = "[]byte"
+		pointer = false // rely on nullability of slices for presence
+	case protoreflect.MessageKind, protoreflect.GroupKind:
+		goType = "*" + g.QualifiedGoIdent(field.Message.GoIdent)
+		pointer = false // pointer captured as part of the type
+	}
+	switch {
+	case field.Desc.IsList():
+		return "[]" + goType, false
+	case field.Desc.IsMap():
+		keyType, _ := fieldGoType(g, f, field.Message.Fields[0])
+		valType, _ := fieldGoType(g, f, field.Message.Fields[1])
+		return fmt.Sprintf("map[%v]%v", keyType, valType), false
+	}
+	return goType, pointer
+}
+
+func fieldProtobufTagValue(field *protogen.Field) string {
+	var enumName string
+	if field.Desc.Kind() == protoreflect.EnumKind {
+		enumName = protoimpl.X.LegacyEnumName(field.Enum.Desc)
+	}
+	return tag.Marshal(field.Desc, enumName)
+}
+
+func fieldDefaultValue(g *protogen.GeneratedFile, m *messageInfo, field *protogen.Field) string {
+	if field.Desc.IsList() {
+		return "nil"
+	}
+	if field.Desc.HasDefault() {
+		defVarName := "Default_" + m.GoIdent.GoName + "_" + field.GoName
+		if field.Desc.Kind() == protoreflect.BytesKind {
+			return "append([]byte(nil), " + defVarName + "...)"
+		}
+		return defVarName
+	}
+	switch field.Desc.Kind() {
+	case protoreflect.BoolKind:
+		return "false"
+	case protoreflect.StringKind:
+		return `""`
+	case protoreflect.MessageKind, protoreflect.GroupKind, protoreflect.BytesKind:
+		return "nil"
+	case protoreflect.EnumKind:
+		return g.QualifiedGoIdent(field.Enum.Values[0].GoIdent)
+	default:
+		return "0"
+	}
+}
+
+func fieldJSONTagValue(field *protogen.Field) string {
+	return string(field.Desc.Name()) + ",omitempty"
+}
+
+func genExtensions(g *protogen.GeneratedFile, f *fileInfo) {
+	if len(f.allExtensions) == 0 {
+		return
+	}
+
+	g.P("var ", extensionTypesVarName(f), " = []", protoimplPackage.Ident("ExtensionInfo"), "{")
+	for _, x := range f.allExtensions {
+		// For MessageSet extensions, the name used is the parent message.
+		name := x.Desc.FullName()
+		if messageset.IsMessageSetExtension(x.Desc) {
+			name = name.Parent()
+		}
+
+		g.P("{")
+		g.P("ExtendedType: (*", x.Extendee.GoIdent, ")(nil),")
+		goType, pointer := fieldGoType(g, f, x.Extension)
+		if pointer {
+			goType = "*" + goType
+		}
+		g.P("ExtensionType: (", goType, ")(nil),")
+		g.P("Field: ", x.Desc.Number(), ",")
+		g.P("Name: ", strconv.Quote(string(name)), ",")
+		g.P("Tag: ", strconv.Quote(fieldProtobufTagValue(x.Extension)), ",")
+		g.P("Filename: ", strconv.Quote(f.Desc.Path()), ",")
+		g.P("},")
+	}
+	g.P("}")
+	g.P()
+
+	// Group extensions by the target message.
+	var orderedTargets []protogen.GoIdent
+	allExtensionsByTarget := make(map[protogen.GoIdent][]*extensionInfo)
+	allExtensionsByPtr := make(map[*extensionInfo]int)
+	for i, x := range f.allExtensions {
+		target := x.Extendee.GoIdent
+		if len(allExtensionsByTarget[target]) == 0 {
+			orderedTargets = append(orderedTargets, target)
+		}
+		allExtensionsByTarget[target] = append(allExtensionsByTarget[target], x)
+		allExtensionsByPtr[x] = i
+	}
+	for _, target := range orderedTargets {
+		g.P("// Extension fields to ", target, ".")
+		g.P("var (")
+		for _, x := range allExtensionsByTarget[target] {
+			xd := x.Desc
+			typeName := xd.Kind().String()
+			switch xd.Kind() {
+			case protoreflect.EnumKind:
+				typeName = string(xd.Enum().FullName())
+			case protoreflect.MessageKind, protoreflect.GroupKind:
+				typeName = string(xd.Message().FullName())
+			}
+			fieldName := string(xd.Name())
+
+			leadingComments := x.Comments.Leading
+			if leadingComments != "" {
+				leadingComments += "\n"
+			}
+			leadingComments += protogen.Comments(fmt.Sprintf(" %v %v %v = %v;\n",
+				xd.Cardinality(), typeName, fieldName, xd.Number()))
+			leadingComments = appendDeprecationSuffix(leadingComments,
+				x.Desc.Options().(*descriptorpb.FieldOptions).GetDeprecated())
+			g.P(leadingComments,
+				"E_", x.GoIdent, " = &", extensionTypesVarName(f), "[", allExtensionsByPtr[x], "]",
+				trailingComment(x.Comments.Trailing))
+		}
+		g.P(")")
+		g.P()
+	}
+}
+
+// genMessageOneofWrapperTypes generates the oneof wrapper types and
+// associates the types with the parent message type.
+func genMessageOneofWrapperTypes(g *protogen.GeneratedFile, f *fileInfo, m *messageInfo) {
+	for _, oneof := range m.Oneofs {
+		if oneof.Desc.IsSynthetic() {
+			continue
+		}
+		ifName := oneofInterfaceName(oneof)
+		g.P("type ", ifName, " interface {")
+		g.P(ifName, "()")
+		g.P("}")
+		g.P()
+		for _, field := range oneof.Fields {
+			g.Annotate(field.GoIdent.GoName, field.Location)
+			g.Annotate(field.GoIdent.GoName+"."+field.GoName, field.Location)
+			g.P("type ", field.GoIdent, " struct {")
+			goType, _ := fieldGoType(g, f, field)
+			tags := structTags{
+				{"protobuf", fieldProtobufTagValue(field)},
+			}
+			if m.isTracked {
+				tags = append(tags, gotrackTags...)
+			}
+			leadingComments := appendDeprecationSuffix(field.Comments.Leading,
+				field.Desc.Options().(*descriptorpb.FieldOptions).GetDeprecated())
+			g.P(leadingComments,
+				field.GoName, " ", goType, tags,
+				trailingComment(field.Comments.Trailing))
+			g.P("}")
+			g.P()
+		}
+		for _, field := range oneof.Fields {
+			g.P("func (*", field.GoIdent, ") ", ifName, "() {}")
+			g.P()
+		}
+	}
+}
+
+// oneofInterfaceName returns the name of the interface type implemented by
+// the oneof field value types.
+func oneofInterfaceName(oneof *protogen.Oneof) string {
+	return "is" + oneof.GoIdent.GoName
+}
+
+// genNoInterfacePragma generates a standalone "nointerface" pragma to
+// decorate methods with field-tracking support.
+func genNoInterfacePragma(g *protogen.GeneratedFile, tracked bool) {
+	if tracked {
+		g.P("//go:nointerface")
+		g.P()
+	}
+}
+
+var gotrackTags = structTags{{"go", "track"}}
+
+// structTags is a data structure for build idiomatic Go struct tags.
+// Each [2]string is a key-value pair, where value is the unescaped string.
+//
+// Example: structTags{{"key", "value"}}.String() -> `key:"value"`
+type structTags [][2]string
+
+func (tags structTags) String() string {
+	if len(tags) == 0 {
+		return ""
+	}
+	var ss []string
+	for _, tag := range tags {
+		// NOTE: When quoting the value, we need to make sure the backtick
+		// character does not appear. Convert all cases to the escaped hex form.
+		key := tag[0]
+		val := strings.Replace(strconv.Quote(tag[1]), "`", `\x60`, -1)
+		ss = append(ss, fmt.Sprintf("%s:%s", key, val))
+	}
+	return "`" + strings.Join(ss, " ") + "`"
+}
+
+// appendDeprecationSuffix optionally appends a deprecation notice as a suffix.
+func appendDeprecationSuffix(prefix protogen.Comments, deprecated bool) protogen.Comments {
+	if !deprecated {
+		return prefix
+	}
+	if prefix != "" {
+		prefix += "\n"
+	}
+	return prefix + " Deprecated: Do not use.\n"
+}
+
+// trailingComment is like protogen.Comments, but lacks a trailing newline.
+type trailingComment protogen.Comments
+
+func (c trailingComment) String() string {
+	s := strings.TrimSuffix(protogen.Comments(c).String(), "\n")
+	if strings.Contains(s, "\n") {
+		// We don't support multi-lined trailing comments as it is unclear
+		// how to best render them in the generated code.
+		return ""
+	}
+	return s
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/internal_gengo/reflect.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/internal_gengo/reflect.go
new file mode 100644
index 000000000..1319a1267
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/internal_gengo/reflect.go
@@ -0,0 +1,351 @@
+// 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 internal_gengo
+
+import (
+	"fmt"
+	"math"
+	"strings"
+	"unicode/utf8"
+
+	"google.golang.org/protobuf/compiler/protogen"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protoreflect"
+
+	"google.golang.org/protobuf/types/descriptorpb"
+)
+
+func genReflectFileDescriptor(gen *protogen.Plugin, g *protogen.GeneratedFile, f *fileInfo) {
+	g.P("var ", f.GoDescriptorIdent, " ", protoreflectPackage.Ident("FileDescriptor"))
+	g.P()
+
+	genFileDescriptor(gen, g, f)
+	if len(f.allEnums) > 0 {
+		g.P("var ", enumTypesVarName(f), " = make([]", protoimplPackage.Ident("EnumInfo"), ",", len(f.allEnums), ")")
+	}
+	if len(f.allMessages) > 0 {
+		g.P("var ", messageTypesVarName(f), " = make([]", protoimplPackage.Ident("MessageInfo"), ",", len(f.allMessages), ")")
+	}
+
+	// Generate a unique list of Go types for all declarations and dependencies,
+	// and the associated index into the type list for all dependencies.
+	var goTypes []string
+	var depIdxs []string
+	seen := map[protoreflect.FullName]int{}
+	genDep := func(name protoreflect.FullName, depSource string) {
+		if depSource != "" {
+			line := fmt.Sprintf("%d, // %d: %s -> %s", seen[name], len(depIdxs), depSource, name)
+			depIdxs = append(depIdxs, line)
+		}
+	}
+	genEnum := func(e *protogen.Enum, depSource string) {
+		if e != nil {
+			name := e.Desc.FullName()
+			if _, ok := seen[name]; !ok {
+				line := fmt.Sprintf("(%s)(0), // %d: %s", g.QualifiedGoIdent(e.GoIdent), len(goTypes), name)
+				goTypes = append(goTypes, line)
+				seen[name] = len(seen)
+			}
+			if depSource != "" {
+				genDep(name, depSource)
+			}
+		}
+	}
+	genMessage := func(m *protogen.Message, depSource string) {
+		if m != nil {
+			name := m.Desc.FullName()
+			if _, ok := seen[name]; !ok {
+				line := fmt.Sprintf("(*%s)(nil), // %d: %s", g.QualifiedGoIdent(m.GoIdent), len(goTypes), name)
+				if m.Desc.IsMapEntry() {
+					// Map entry messages have no associated Go type.
+					line = fmt.Sprintf("nil, // %d: %s", len(goTypes), name)
+				}
+				goTypes = append(goTypes, line)
+				seen[name] = len(seen)
+			}
+			if depSource != "" {
+				genDep(name, depSource)
+			}
+		}
+	}
+
+	// This ordering is significant.
+	// See filetype.TypeBuilder.DependencyIndexes.
+	type offsetEntry struct {
+		start int
+		name  string
+	}
+	var depOffsets []offsetEntry
+	for _, enum := range f.allEnums {
+		genEnum(enum.Enum, "")
+	}
+	for _, message := range f.allMessages {
+		genMessage(message.Message, "")
+	}
+	depOffsets = append(depOffsets, offsetEntry{len(depIdxs), "field type_name"})
+	for _, message := range f.allMessages {
+		for _, field := range message.Fields {
+			if field.Desc.IsWeak() {
+				continue
+			}
+			source := string(field.Desc.FullName())
+			genEnum(field.Enum, source+":type_name")
+			genMessage(field.Message, source+":type_name")
+		}
+	}
+	depOffsets = append(depOffsets, offsetEntry{len(depIdxs), "extension extendee"})
+	for _, extension := range f.allExtensions {
+		source := string(extension.Desc.FullName())
+		genMessage(extension.Extendee, source+":extendee")
+	}
+	depOffsets = append(depOffsets, offsetEntry{len(depIdxs), "extension type_name"})
+	for _, extension := range f.allExtensions {
+		source := string(extension.Desc.FullName())
+		genEnum(extension.Enum, source+":type_name")
+		genMessage(extension.Message, source+":type_name")
+	}
+	depOffsets = append(depOffsets, offsetEntry{len(depIdxs), "method input_type"})
+	for _, service := range f.Services {
+		for _, method := range service.Methods {
+			source := string(method.Desc.FullName())
+			genMessage(method.Input, source+":input_type")
+		}
+	}
+	depOffsets = append(depOffsets, offsetEntry{len(depIdxs), "method output_type"})
+	for _, service := range f.Services {
+		for _, method := range service.Methods {
+			source := string(method.Desc.FullName())
+			genMessage(method.Output, source+":output_type")
+		}
+	}
+	depOffsets = append(depOffsets, offsetEntry{len(depIdxs), ""})
+	for i := len(depOffsets) - 2; i >= 0; i-- {
+		curr, next := depOffsets[i], depOffsets[i+1]
+		depIdxs = append(depIdxs, fmt.Sprintf("%d, // [%d:%d] is the sub-list for %s",
+			curr.start, curr.start, next.start, curr.name))
+	}
+	if len(depIdxs) > math.MaxInt32 {
+		panic("too many dependencies") // sanity check
+	}
+
+	g.P("var ", goTypesVarName(f), " = []interface{}{")
+	for _, s := range goTypes {
+		g.P(s)
+	}
+	g.P("}")
+
+	g.P("var ", depIdxsVarName(f), " = []int32{")
+	for _, s := range depIdxs {
+		g.P(s)
+	}
+	g.P("}")
+
+	g.P("func init() { ", initFuncName(f.File), "() }")
+
+	g.P("func ", initFuncName(f.File), "() {")
+	g.P("if ", f.GoDescriptorIdent, " != nil {")
+	g.P("return")
+	g.P("}")
+
+	// Ensure that initialization functions for different files in the same Go
+	// package run in the correct order: Call the init funcs for every .proto file
+	// imported by this one that is in the same Go package.
+	for i, imps := 0, f.Desc.Imports(); i < imps.Len(); i++ {
+		impFile := gen.FilesByPath[imps.Get(i).Path()]
+		if impFile.GoImportPath != f.GoImportPath {
+			continue
+		}
+		g.P(initFuncName(impFile), "()")
+	}
+
+	if len(f.allMessages) > 0 {
+		// Populate MessageInfo.Exporters.
+		g.P("if !", protoimplPackage.Ident("UnsafeEnabled"), " {")
+		for _, message := range f.allMessages {
+			if sf := f.allMessageFieldsByPtr[message]; len(sf.unexported) > 0 {
+				idx := f.allMessagesByPtr[message]
+				typesVar := messageTypesVarName(f)
+
+				g.P(typesVar, "[", idx, "].Exporter = func(v interface{}, i int) interface{} {")
+				g.P("switch v := v.(*", message.GoIdent, "); i {")
+				for i := 0; i < sf.count; i++ {
+					if name := sf.unexported[i]; name != "" {
+						g.P("case ", i, ": return &v.", name)
+					}
+				}
+				g.P("default: return nil")
+				g.P("}")
+				g.P("}")
+			}
+		}
+		g.P("}")
+
+		// Populate MessageInfo.OneofWrappers.
+		for _, message := range f.allMessages {
+			if len(message.Oneofs) > 0 {
+				idx := f.allMessagesByPtr[message]
+				typesVar := messageTypesVarName(f)
+
+				// Associate the wrapper types by directly passing them to the MessageInfo.
+				g.P(typesVar, "[", idx, "].OneofWrappers = []interface{} {")
+				for _, oneof := range message.Oneofs {
+					if !oneof.Desc.IsSynthetic() {
+						for _, field := range oneof.Fields {
+							g.P("(*", field.GoIdent, ")(nil),")
+						}
+					}
+				}
+				g.P("}")
+			}
+		}
+	}
+
+	g.P("type x struct{}")
+	g.P("out := ", protoimplPackage.Ident("TypeBuilder"), "{")
+	g.P("File: ", protoimplPackage.Ident("DescBuilder"), "{")
+	g.P("GoPackagePath: ", reflectPackage.Ident("TypeOf"), "(x{}).PkgPath(),")
+	g.P("RawDescriptor: ", rawDescVarName(f), ",")
+	g.P("NumEnums: ", len(f.allEnums), ",")
+	g.P("NumMessages: ", len(f.allMessages), ",")
+	g.P("NumExtensions: ", len(f.allExtensions), ",")
+	g.P("NumServices: ", len(f.Services), ",")
+	g.P("},")
+	g.P("GoTypes: ", goTypesVarName(f), ",")
+	g.P("DependencyIndexes: ", depIdxsVarName(f), ",")
+	if len(f.allEnums) > 0 {
+		g.P("EnumInfos: ", enumTypesVarName(f), ",")
+	}
+	if len(f.allMessages) > 0 {
+		g.P("MessageInfos: ", messageTypesVarName(f), ",")
+	}
+	if len(f.allExtensions) > 0 {
+		g.P("ExtensionInfos: ", extensionTypesVarName(f), ",")
+	}
+	g.P("}.Build()")
+	g.P(f.GoDescriptorIdent, " = out.File")
+
+	// Set inputs to nil to allow GC to reclaim resources.
+	g.P(rawDescVarName(f), " = nil")
+	g.P(goTypesVarName(f), " = nil")
+	g.P(depIdxsVarName(f), " = nil")
+	g.P("}")
+}
+
+func genFileDescriptor(gen *protogen.Plugin, g *protogen.GeneratedFile, f *fileInfo) {
+	descProto := proto.Clone(f.Proto).(*descriptorpb.FileDescriptorProto)
+	descProto.SourceCodeInfo = nil // drop source code information
+
+	b, err := proto.MarshalOptions{AllowPartial: true, Deterministic: true}.Marshal(descProto)
+	if err != nil {
+		gen.Error(err)
+		return
+	}
+
+	g.P("var ", rawDescVarName(f), " = []byte{")
+	for len(b) > 0 {
+		n := 16
+		if n > len(b) {
+			n = len(b)
+		}
+
+		s := ""
+		for _, c := range b[:n] {
+			s += fmt.Sprintf("0x%02x,", c)
+		}
+		g.P(s)
+
+		b = b[n:]
+	}
+	g.P("}")
+	g.P()
+
+	if f.needRawDesc {
+		onceVar := rawDescVarName(f) + "Once"
+		dataVar := rawDescVarName(f) + "Data"
+		g.P("var (")
+		g.P(onceVar, " ", syncPackage.Ident("Once"))
+		g.P(dataVar, " = ", rawDescVarName(f))
+		g.P(")")
+		g.P()
+
+		g.P("func ", rawDescVarName(f), "GZIP() []byte {")
+		g.P(onceVar, ".Do(func() {")
+		g.P(dataVar, " = ", protoimplPackage.Ident("X"), ".CompressGZIP(", dataVar, ")")
+		g.P("})")
+		g.P("return ", dataVar)
+		g.P("}")
+		g.P()
+	}
+}
+
+func genEnumReflectMethods(g *protogen.GeneratedFile, f *fileInfo, e *enumInfo) {
+	idx := f.allEnumsByPtr[e]
+	typesVar := enumTypesVarName(f)
+
+	// Descriptor method.
+	g.P("func (", e.GoIdent, ") Descriptor() ", protoreflectPackage.Ident("EnumDescriptor"), " {")
+	g.P("return ", typesVar, "[", idx, "].Descriptor()")
+	g.P("}")
+	g.P()
+
+	// Type method.
+	g.P("func (", e.GoIdent, ") Type() ", protoreflectPackage.Ident("EnumType"), " {")
+	g.P("return &", typesVar, "[", idx, "]")
+	g.P("}")
+	g.P()
+
+	// Number method.
+	g.P("func (x ", e.GoIdent, ") Number() ", protoreflectPackage.Ident("EnumNumber"), " {")
+	g.P("return ", protoreflectPackage.Ident("EnumNumber"), "(x)")
+	g.P("}")
+	g.P()
+}
+
+func genMessageReflectMethods(g *protogen.GeneratedFile, f *fileInfo, m *messageInfo) {
+	idx := f.allMessagesByPtr[m]
+	typesVar := messageTypesVarName(f)
+
+	// ProtoReflect method.
+	g.P("func (x *", m.GoIdent, ") ProtoReflect() ", protoreflectPackage.Ident("Message"), " {")
+	g.P("mi := &", typesVar, "[", idx, "]")
+	g.P("if ", protoimplPackage.Ident("UnsafeEnabled"), " && x != nil {")
+	g.P("ms := ", protoimplPackage.Ident("X"), ".MessageStateOf(", protoimplPackage.Ident("Pointer"), "(x))")
+	g.P("if ms.LoadMessageInfo() == nil {")
+	g.P("ms.StoreMessageInfo(mi)")
+	g.P("}")
+	g.P("return ms")
+	g.P("}")
+	g.P("return mi.MessageOf(x)")
+	g.P("}")
+	g.P()
+}
+
+func fileVarName(f *protogen.File, suffix string) string {
+	prefix := f.GoDescriptorIdent.GoName
+	_, n := utf8.DecodeRuneInString(prefix)
+	prefix = strings.ToLower(prefix[:n]) + prefix[n:]
+	return prefix + "_" + suffix
+}
+func rawDescVarName(f *fileInfo) string {
+	return fileVarName(f.File, "rawDesc")
+}
+func goTypesVarName(f *fileInfo) string {
+	return fileVarName(f.File, "goTypes")
+}
+func depIdxsVarName(f *fileInfo) string {
+	return fileVarName(f.File, "depIdxs")
+}
+func enumTypesVarName(f *fileInfo) string {
+	return fileVarName(f.File, "enumTypes")
+}
+func messageTypesVarName(f *fileInfo) string {
+	return fileVarName(f.File, "msgTypes")
+}
+func extensionTypesVarName(f *fileInfo) string {
+	return fileVarName(f.File, "extTypes")
+}
+func initFuncName(f *protogen.File) string {
+	return fileVarName(f, "init")
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/main.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/main.go
new file mode 100644
index 000000000..55a58df87
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/main.go
@@ -0,0 +1,52 @@
+// 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.
+
+// The protoc-gen-go binary is a protoc plugin to generate Go code for
+// both proto2 and proto3 versions of the protocol buffer language.
+//
+// For more information about the usage of this plugin, see:
+//	https://developers.google.com/protocol-buffers/docs/reference/go-generated
+package main
+
+import (
+	"errors"
+	"flag"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	gengo "google.golang.org/protobuf/cmd/protoc-gen-go/internal_gengo"
+	"google.golang.org/protobuf/compiler/protogen"
+	"google.golang.org/protobuf/internal/version"
+)
+
+func main() {
+	if len(os.Args) == 2 && os.Args[1] == "--version" {
+		fmt.Fprintf(os.Stderr, "%v %v\n", filepath.Base(os.Args[0]), version.String())
+		os.Exit(1)
+	}
+
+	var (
+		flags        flag.FlagSet
+		plugins      = flags.String("plugins", "", "deprecated option")
+		importPrefix = flags.String("import_prefix", "", "deprecated option")
+	)
+	protogen.Options{
+		ParamFunc: flags.Set,
+	}.Run(func(gen *protogen.Plugin) error {
+		if *plugins != "" {
+			return errors.New("protoc-gen-go: plugins are not supported; use 'protoc --go-grpc_out=...' to generate gRPC")
+		}
+		if *importPrefix != "" {
+			return errors.New("protoc-gen-go: import_prefix is not supported")
+		}
+		for _, f := range gen.Files {
+			if f.Generate {
+				gengo.GenerateFile(gen, f)
+			}
+		}
+		gen.SupportedFeatures = gengo.SupportedFeatures
+		return nil
+	})
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/annotations/annotations.pb.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/annotations/annotations.pb.go
new file mode 100644
index 000000000..2a5fd2475
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/annotations/annotations.pb.go
@@ -0,0 +1,205 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: cmd/protoc-gen-go/testdata/annotations/annotations.proto
+
+package annotations
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type AnnotationsTestEnum int32
+
+const (
+	AnnotationsTestEnum_ANNOTATIONS_TEST_ENUM_VALUE AnnotationsTestEnum = 0
+)
+
+// Enum value maps for AnnotationsTestEnum.
+var (
+	AnnotationsTestEnum_name = map[int32]string{
+		0: "ANNOTATIONS_TEST_ENUM_VALUE",
+	}
+	AnnotationsTestEnum_value = map[string]int32{
+		"ANNOTATIONS_TEST_ENUM_VALUE": 0,
+	}
+)
+
+func (x AnnotationsTestEnum) Enum() *AnnotationsTestEnum {
+	p := new(AnnotationsTestEnum)
+	*p = x
+	return p
+}
+
+func (x AnnotationsTestEnum) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (AnnotationsTestEnum) Descriptor() protoreflect.EnumDescriptor {
+	return file_cmd_protoc_gen_go_testdata_annotations_annotations_proto_enumTypes[0].Descriptor()
+}
+
+func (AnnotationsTestEnum) Type() protoreflect.EnumType {
+	return &file_cmd_protoc_gen_go_testdata_annotations_annotations_proto_enumTypes[0]
+}
+
+func (x AnnotationsTestEnum) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *AnnotationsTestEnum) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = AnnotationsTestEnum(num)
+	return nil
+}
+
+// Deprecated: Use AnnotationsTestEnum.Descriptor instead.
+func (AnnotationsTestEnum) EnumDescriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_annotations_annotations_proto_rawDescGZIP(), []int{0}
+}
+
+type AnnotationsTestMessage struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	AnnotationsTestField *string `protobuf:"bytes,1,opt,name=AnnotationsTestField" json:"AnnotationsTestField,omitempty"`
+}
+
+func (x *AnnotationsTestMessage) Reset() {
+	*x = AnnotationsTestMessage{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_annotations_annotations_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *AnnotationsTestMessage) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AnnotationsTestMessage) ProtoMessage() {}
+
+func (x *AnnotationsTestMessage) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_annotations_annotations_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use AnnotationsTestMessage.ProtoReflect.Descriptor instead.
+func (*AnnotationsTestMessage) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_annotations_annotations_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *AnnotationsTestMessage) GetAnnotationsTestField() string {
+	if x != nil && x.AnnotationsTestField != nil {
+		return *x.AnnotationsTestField
+	}
+	return ""
+}
+
+var File_cmd_protoc_gen_go_testdata_annotations_annotations_proto protoreflect.FileDescriptor
+
+var file_cmd_protoc_gen_go_testdata_annotations_annotations_proto_rawDesc = []byte{
+	0x0a, 0x38, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x61, 0x6e, 0x6e,
+	0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1a, 0x67, 0x6f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x61, 0x6e, 0x6e, 0x6f, 0x74,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x4c, 0x0a, 0x16, 0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x73, 0x54, 0x65, 0x73, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x12, 0x32, 0x0a, 0x14, 0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x54,
+	0x65, 0x73, 0x74, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x14,
+	0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x54, 0x65, 0x73, 0x74, 0x46,
+	0x69, 0x65, 0x6c, 0x64, 0x2a, 0x36, 0x0a, 0x13, 0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x73, 0x54, 0x65, 0x73, 0x74, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x1f, 0x0a, 0x1b, 0x41,
+	0x4e, 0x4e, 0x4f, 0x54, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x53, 0x5f, 0x54, 0x45, 0x53, 0x54, 0x5f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x10, 0x00, 0x42, 0x43, 0x5a, 0x41,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72,
+	0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x63, 0x6d, 0x64, 0x2f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73,
+	0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x73,
+}
+
+var (
+	file_cmd_protoc_gen_go_testdata_annotations_annotations_proto_rawDescOnce sync.Once
+	file_cmd_protoc_gen_go_testdata_annotations_annotations_proto_rawDescData = file_cmd_protoc_gen_go_testdata_annotations_annotations_proto_rawDesc
+)
+
+func file_cmd_protoc_gen_go_testdata_annotations_annotations_proto_rawDescGZIP() []byte {
+	file_cmd_protoc_gen_go_testdata_annotations_annotations_proto_rawDescOnce.Do(func() {
+		file_cmd_protoc_gen_go_testdata_annotations_annotations_proto_rawDescData = protoimpl.X.CompressGZIP(file_cmd_protoc_gen_go_testdata_annotations_annotations_proto_rawDescData)
+	})
+	return file_cmd_protoc_gen_go_testdata_annotations_annotations_proto_rawDescData
+}
+
+var file_cmd_protoc_gen_go_testdata_annotations_annotations_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
+var file_cmd_protoc_gen_go_testdata_annotations_annotations_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_cmd_protoc_gen_go_testdata_annotations_annotations_proto_goTypes = []interface{}{
+	(AnnotationsTestEnum)(0),       // 0: goproto.protoc.annotations.AnnotationsTestEnum
+	(*AnnotationsTestMessage)(nil), // 1: goproto.protoc.annotations.AnnotationsTestMessage
+}
+var file_cmd_protoc_gen_go_testdata_annotations_annotations_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_cmd_protoc_gen_go_testdata_annotations_annotations_proto_init() }
+func file_cmd_protoc_gen_go_testdata_annotations_annotations_proto_init() {
+	if File_cmd_protoc_gen_go_testdata_annotations_annotations_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_cmd_protoc_gen_go_testdata_annotations_annotations_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*AnnotationsTestMessage); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cmd_protoc_gen_go_testdata_annotations_annotations_proto_rawDesc,
+			NumEnums:      1,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_cmd_protoc_gen_go_testdata_annotations_annotations_proto_goTypes,
+		DependencyIndexes: file_cmd_protoc_gen_go_testdata_annotations_annotations_proto_depIdxs,
+		EnumInfos:         file_cmd_protoc_gen_go_testdata_annotations_annotations_proto_enumTypes,
+		MessageInfos:      file_cmd_protoc_gen_go_testdata_annotations_annotations_proto_msgTypes,
+	}.Build()
+	File_cmd_protoc_gen_go_testdata_annotations_annotations_proto = out.File
+	file_cmd_protoc_gen_go_testdata_annotations_annotations_proto_rawDesc = nil
+	file_cmd_protoc_gen_go_testdata_annotations_annotations_proto_goTypes = nil
+	file_cmd_protoc_gen_go_testdata_annotations_annotations_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/annotations/annotations.pb.go.meta b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/annotations/annotations.pb.go.meta
new file mode 100644
index 000000000..91f84f356
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/annotations/annotations.pb.go.meta
@@ -0,0 +1 @@
+annotation:{path:5 path:0 source_file:"cmd/protoc-gen-go/testdata/annotations/annotations.proto" begin:470 end:489} annotation:{path:5 path:0 path:2 path:0 source_file:"cmd/protoc-gen-go/testdata/annotations/annotations.proto" begin:506 end:553} annotation:{path:4 path:0 source_file:"cmd/protoc-gen-go/testdata/annotations/annotations.proto" begin:1912 end:1934} annotation:{path:4 path:0 path:2 path:0 source_file:"cmd/protoc-gen-go/testdata/annotations/annotations.proto" begin:2058 end:2078} annotation:{path:4 path:0 path:2 path:0 source_file:"cmd/protoc-gen-go/testdata/annotations/annotations.proto" begin:3225 end:3248}
\ No newline at end of file
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/annotations/annotations.proto b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/annotations/annotations.proto
new file mode 100644
index 000000000..acd7b866d
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/annotations/annotations.proto
@@ -0,0 +1,17 @@
+// 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.
+
+syntax = "proto2";
+
+package goproto.protoc.annotations;
+
+option go_package = "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/annotations";
+
+message AnnotationsTestMessage {
+  optional string AnnotationsTestField = 1;
+}
+
+enum AnnotationsTestEnum {
+  ANNOTATIONS_TEST_ENUM_VALUE = 0;
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/comments/comments.pb.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/comments/comments.pb.go
new file mode 100644
index 000000000..22f29c60f
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/comments/comments.pb.go
@@ -0,0 +1,552 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: cmd/protoc-gen-go/testdata/comments/comments.proto
+
+// COMMENT: package goproto.protoc.comments;
+
+package comments
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoiface "google.golang.org/protobuf/runtime/protoiface"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+// COMMENT: Enum1.Leading
+type Enum1 int32
+
+const (
+	// COMMENT: FOO.Leading
+	Enum1_FOO Enum1 = 0 // COMMENT: FOO.InlineTrailing
+	// COMMENT: BAR.Leading
+	Enum1_BAR Enum1 = 1
+)
+
+// Enum value maps for Enum1.
+var (
+	Enum1_name = map[int32]string{
+		0: "FOO",
+		1: "BAR",
+	}
+	Enum1_value = map[string]int32{
+		"FOO": 0,
+		"BAR": 1,
+	}
+)
+
+func (x Enum1) Enum() *Enum1 {
+	p := new(Enum1)
+	*p = x
+	return p
+}
+
+func (x Enum1) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum1) Descriptor() protoreflect.EnumDescriptor {
+	return file_cmd_protoc_gen_go_testdata_comments_comments_proto_enumTypes[0].Descriptor()
+}
+
+func (Enum1) Type() protoreflect.EnumType {
+	return &file_cmd_protoc_gen_go_testdata_comments_comments_proto_enumTypes[0]
+}
+
+func (x Enum1) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum1) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum1(num)
+	return nil
+}
+
+// Deprecated: Use Enum1.Descriptor instead.
+func (Enum1) EnumDescriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_comments_comments_proto_rawDescGZIP(), []int{0}
+}
+
+// COMMENT: Message1.Leading
+type Message1 struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+
+	// COMMENT: Field1A.Leading
+	Field1A *string `protobuf:"bytes,1,opt,name=Field1A" json:"Field1A,omitempty"` // COMMENT: Field1A.Trailing
+	// COMMENT: Oneof1A.Leading
+	//
+	// Types that are assignable to Oneof1A:
+	//	*Message1_Oneof1AField1
+	Oneof1A isMessage1_Oneof1A `protobuf_oneof:"Oneof1a"`
+}
+
+func (x *Message1) Reset() {
+	*x = Message1{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_comments_comments_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message1) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message1) ProtoMessage() {}
+
+func (x *Message1) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_comments_comments_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message1.ProtoReflect.Descriptor instead.
+func (*Message1) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_comments_comments_proto_rawDescGZIP(), []int{0}
+}
+
+var extRange_Message1 = []protoiface.ExtensionRangeV1{
+	{Start: 100, End: 536870911},
+}
+
+// Deprecated: Use Message1.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*Message1) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_Message1
+}
+
+func (x *Message1) GetField1A() string {
+	if x != nil && x.Field1A != nil {
+		return *x.Field1A
+	}
+	return ""
+}
+
+func (m *Message1) GetOneof1A() isMessage1_Oneof1A {
+	if m != nil {
+		return m.Oneof1A
+	}
+	return nil
+}
+
+func (x *Message1) GetOneof1AField1() string {
+	if x, ok := x.GetOneof1A().(*Message1_Oneof1AField1); ok {
+		return x.Oneof1AField1
+	}
+	return ""
+}
+
+type isMessage1_Oneof1A interface {
+	isMessage1_Oneof1A()
+}
+
+type Message1_Oneof1AField1 struct {
+	// COMMENT: Oneof1AField1.Leading
+	Oneof1AField1 string `protobuf:"bytes,2,opt,name=Oneof1AField1,oneof"` // COMMENT: Oneof1AField1.Trailing
+}
+
+func (*Message1_Oneof1AField1) isMessage1_Oneof1A() {}
+
+// COMMENT: Message2
+type Message2 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message2) Reset() {
+	*x = Message2{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_comments_comments_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message2) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message2) ProtoMessage() {}
+
+func (x *Message2) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_comments_comments_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message2.ProtoReflect.Descriptor instead.
+func (*Message2) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_comments_comments_proto_rawDescGZIP(), []int{1}
+}
+
+// COMMENT: Message1A.Leading
+type Message1_Message1A struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message1_Message1A) Reset() {
+	*x = Message1_Message1A{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_comments_comments_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message1_Message1A) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message1_Message1A) ProtoMessage() {}
+
+func (x *Message1_Message1A) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_comments_comments_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message1_Message1A.ProtoReflect.Descriptor instead.
+func (*Message1_Message1A) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_comments_comments_proto_rawDescGZIP(), []int{0, 0}
+}
+
+// COMMENT: Message1B
+type Message1_Message1B struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message1_Message1B) Reset() {
+	*x = Message1_Message1B{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_comments_comments_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message1_Message1B) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message1_Message1B) ProtoMessage() {}
+
+func (x *Message1_Message1B) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_comments_comments_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message1_Message1B.ProtoReflect.Descriptor instead.
+func (*Message1_Message1B) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_comments_comments_proto_rawDescGZIP(), []int{0, 1}
+}
+
+// COMMENT: Message2A
+type Message2_Message2A struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message2_Message2A) Reset() {
+	*x = Message2_Message2A{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_comments_comments_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message2_Message2A) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message2_Message2A) ProtoMessage() {}
+
+func (x *Message2_Message2A) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_comments_comments_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message2_Message2A.ProtoReflect.Descriptor instead.
+func (*Message2_Message2A) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_comments_comments_proto_rawDescGZIP(), []int{1, 0}
+}
+
+// COMMENT: Message2B
+type Message2_Message2B struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message2_Message2B) Reset() {
+	*x = Message2_Message2B{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_comments_comments_proto_msgTypes[5]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message2_Message2B) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message2_Message2B) ProtoMessage() {}
+
+func (x *Message2_Message2B) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_comments_comments_proto_msgTypes[5]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message2_Message2B.ProtoReflect.Descriptor instead.
+func (*Message2_Message2B) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_comments_comments_proto_rawDescGZIP(), []int{1, 1}
+}
+
+var file_cmd_protoc_gen_go_testdata_comments_comments_proto_extTypes = []protoimpl.ExtensionInfo{
+	{
+		ExtendedType:  (*Message1)(nil),
+		ExtensionType: (*Message1)(nil),
+		Field:         100,
+		Name:          "goproto.protoc.comments.extension",
+		Tag:           "bytes,100,opt,name=extension",
+		Filename:      "cmd/protoc-gen-go/testdata/comments/comments.proto",
+	},
+}
+
+// Extension fields to Message1.
+var (
+	// COMMENT: Extension.Leading
+	//
+	// optional goproto.protoc.comments.Message1 extension = 100;
+	E_Extension = &file_cmd_protoc_gen_go_testdata_comments_comments_proto_extTypes[0] // COMMENT: Extension.Trailing
+)
+
+var File_cmd_protoc_gen_go_testdata_comments_comments_proto protoreflect.FileDescriptor
+
+var file_cmd_protoc_gen_go_testdata_comments_comments_proto_rawDesc = []byte{
+	0x0a, 0x32, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x63, 0x6f, 0x6d,
+	0x6d, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x12, 0x17, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x22, 0x7b, 0x0a,
+	0x08, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x12, 0x18, 0x0a, 0x07, 0x46, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x41, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x46, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x41, 0x12, 0x26, 0x0a, 0x0d, 0x4f, 0x6e, 0x65, 0x6f, 0x66, 0x31, 0x41, 0x46, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0d, 0x4f, 0x6e,
+	0x65, 0x6f, 0x66, 0x31, 0x41, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x1a, 0x0b, 0x0a, 0x09, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x41, 0x1a, 0x0b, 0x0a, 0x09, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x31, 0x42, 0x2a, 0x08, 0x08, 0x64, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x42,
+	0x09, 0x0a, 0x07, 0x4f, 0x6e, 0x65, 0x6f, 0x66, 0x31, 0x61, 0x22, 0x24, 0x0a, 0x08, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x1a, 0x0b, 0x0a, 0x09, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x32, 0x41, 0x1a, 0x0b, 0x0a, 0x09, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x42,
+	0x2a, 0x19, 0x0a, 0x05, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x12, 0x07, 0x0a, 0x03, 0x46, 0x4f, 0x4f,
+	0x10, 0x00, 0x12, 0x07, 0x0a, 0x03, 0x42, 0x41, 0x52, 0x10, 0x01, 0x3a, 0x62, 0x0a, 0x09, 0x65,
+	0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x21, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e,
+	0x74, 0x73, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x18, 0x64, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x21, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x63, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x31, 0x52, 0x09, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x42,
+	0x40, 0x5a, 0x3e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67,
+	0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x63, 0x6d,
+	0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f,
+	0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74,
+	0x73,
+}
+
+var (
+	file_cmd_protoc_gen_go_testdata_comments_comments_proto_rawDescOnce sync.Once
+	file_cmd_protoc_gen_go_testdata_comments_comments_proto_rawDescData = file_cmd_protoc_gen_go_testdata_comments_comments_proto_rawDesc
+)
+
+func file_cmd_protoc_gen_go_testdata_comments_comments_proto_rawDescGZIP() []byte {
+	file_cmd_protoc_gen_go_testdata_comments_comments_proto_rawDescOnce.Do(func() {
+		file_cmd_protoc_gen_go_testdata_comments_comments_proto_rawDescData = protoimpl.X.CompressGZIP(file_cmd_protoc_gen_go_testdata_comments_comments_proto_rawDescData)
+	})
+	return file_cmd_protoc_gen_go_testdata_comments_comments_proto_rawDescData
+}
+
+var file_cmd_protoc_gen_go_testdata_comments_comments_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
+var file_cmd_protoc_gen_go_testdata_comments_comments_proto_msgTypes = make([]protoimpl.MessageInfo, 6)
+var file_cmd_protoc_gen_go_testdata_comments_comments_proto_goTypes = []interface{}{
+	(Enum1)(0),                 // 0: goproto.protoc.comments.Enum1
+	(*Message1)(nil),           // 1: goproto.protoc.comments.Message1
+	(*Message2)(nil),           // 2: goproto.protoc.comments.Message2
+	(*Message1_Message1A)(nil), // 3: goproto.protoc.comments.Message1.Message1A
+	(*Message1_Message1B)(nil), // 4: goproto.protoc.comments.Message1.Message1B
+	(*Message2_Message2A)(nil), // 5: goproto.protoc.comments.Message2.Message2A
+	(*Message2_Message2B)(nil), // 6: goproto.protoc.comments.Message2.Message2B
+}
+var file_cmd_protoc_gen_go_testdata_comments_comments_proto_depIdxs = []int32{
+	1, // 0: goproto.protoc.comments.extension:extendee -> goproto.protoc.comments.Message1
+	1, // 1: goproto.protoc.comments.extension:type_name -> goproto.protoc.comments.Message1
+	2, // [2:2] is the sub-list for method output_type
+	2, // [2:2] is the sub-list for method input_type
+	1, // [1:2] is the sub-list for extension type_name
+	0, // [0:1] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_cmd_protoc_gen_go_testdata_comments_comments_proto_init() }
+func file_cmd_protoc_gen_go_testdata_comments_comments_proto_init() {
+	if File_cmd_protoc_gen_go_testdata_comments_comments_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_cmd_protoc_gen_go_testdata_comments_comments_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message1); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_cmd_protoc_gen_go_testdata_comments_comments_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message2); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cmd_protoc_gen_go_testdata_comments_comments_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message1_Message1A); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cmd_protoc_gen_go_testdata_comments_comments_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message1_Message1B); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cmd_protoc_gen_go_testdata_comments_comments_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message2_Message2A); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cmd_protoc_gen_go_testdata_comments_comments_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message2_Message2B); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	file_cmd_protoc_gen_go_testdata_comments_comments_proto_msgTypes[0].OneofWrappers = []interface{}{
+		(*Message1_Oneof1AField1)(nil),
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cmd_protoc_gen_go_testdata_comments_comments_proto_rawDesc,
+			NumEnums:      1,
+			NumMessages:   6,
+			NumExtensions: 1,
+			NumServices:   0,
+		},
+		GoTypes:           file_cmd_protoc_gen_go_testdata_comments_comments_proto_goTypes,
+		DependencyIndexes: file_cmd_protoc_gen_go_testdata_comments_comments_proto_depIdxs,
+		EnumInfos:         file_cmd_protoc_gen_go_testdata_comments_comments_proto_enumTypes,
+		MessageInfos:      file_cmd_protoc_gen_go_testdata_comments_comments_proto_msgTypes,
+		ExtensionInfos:    file_cmd_protoc_gen_go_testdata_comments_comments_proto_extTypes,
+	}.Build()
+	File_cmd_protoc_gen_go_testdata_comments_comments_proto = out.File
+	file_cmd_protoc_gen_go_testdata_comments_comments_proto_rawDesc = nil
+	file_cmd_protoc_gen_go_testdata_comments_comments_proto_goTypes = nil
+	file_cmd_protoc_gen_go_testdata_comments_comments_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/comments/comments.proto b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/comments/comments.proto
new file mode 100644
index 000000000..02998ce31
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/comments/comments.proto
@@ -0,0 +1,61 @@
+// 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.
+
+syntax = "proto2";
+
+// COMMENT: package goproto.protoc.comments;
+package goproto.protoc.comments;
+
+option go_package = "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/comments";
+
+// COMMENT: Enum1.Leading
+enum Enum1 {
+  // COMMENT: FOO.Leading
+  FOO = 0; // COMMENT: FOO.InlineTrailing
+  // COMMENT: BAR.Leading
+  BAR = 1;
+  // COMMENT: BAR.Trailing1
+  // COMMENT: BAR.Trailing2
+
+  // COMMENT: Enum1.EndBody
+}
+
+// COMMENT: Message1.Leading
+message Message1 {
+  // COMMENT: Message1A.Leading
+  message Message1A {
+  } // COMMENT: Message1A.Trailing
+
+  // COMMENT: Message1B
+  message Message1B {
+  }
+
+  // COMMENT: Field1A.Leading
+  optional string Field1A = 1; // COMMENT: Field1A.Trailing
+
+  // COMMENT: Oneof1A.Leading
+  oneof Oneof1a {
+    // COMMENT: Oneof1AField1.Leading
+    string Oneof1AField1 = 2; // COMMENT: Oneof1AField1.Trailing
+  } // COMMENT: Oneof1A.Trailing
+
+  extensions 100 to max;
+} // COMMENT: Message1.Trailing
+
+// COMMENT: Extend
+extend Message1 {
+  // COMMENT: Extension.Leading
+  optional Message1 extension = 100; // COMMENT: Extension.Trailing
+}
+
+// COMMENT: Message2
+message Message2 {
+  // COMMENT: Message2A
+  message Message2A {
+  }
+
+  // COMMENT: Message2B
+  message Message2B {
+  }
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/comments/deprecated.pb.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/comments/deprecated.pb.go
new file mode 100644
index 000000000..a23f64c8e
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/comments/deprecated.pb.go
@@ -0,0 +1,198 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// cmd/protoc-gen-go/testdata/comments/deprecated.proto is a deprecated file.
+
+package comments
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+// Deprecated: Do not use.
+type DeprecatedEnum int32
+
+const (
+	// Deprecated: Do not use.
+	DeprecatedEnum_DEPRECATED DeprecatedEnum = 0
+)
+
+// Enum value maps for DeprecatedEnum.
+var (
+	DeprecatedEnum_name = map[int32]string{
+		0: "DEPRECATED",
+	}
+	DeprecatedEnum_value = map[string]int32{
+		"DEPRECATED": 0,
+	}
+)
+
+func (x DeprecatedEnum) Enum() *DeprecatedEnum {
+	p := new(DeprecatedEnum)
+	*p = x
+	return p
+}
+
+func (x DeprecatedEnum) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (DeprecatedEnum) Descriptor() protoreflect.EnumDescriptor {
+	return file_cmd_protoc_gen_go_testdata_comments_deprecated_proto_enumTypes[0].Descriptor()
+}
+
+func (DeprecatedEnum) Type() protoreflect.EnumType {
+	return &file_cmd_protoc_gen_go_testdata_comments_deprecated_proto_enumTypes[0]
+}
+
+func (x DeprecatedEnum) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use DeprecatedEnum.Descriptor instead.
+func (DeprecatedEnum) EnumDescriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_comments_deprecated_proto_rawDescGZIP(), []int{0}
+}
+
+// Deprecated: Do not use.
+type DeprecatedMessage struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// Deprecated: Do not use.
+	DeprecatedField string `protobuf:"bytes,1,opt,name=deprecated_field,json=deprecatedField,proto3" json:"deprecated_field,omitempty"`
+}
+
+func (x *DeprecatedMessage) Reset() {
+	*x = DeprecatedMessage{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_comments_deprecated_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *DeprecatedMessage) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DeprecatedMessage) ProtoMessage() {}
+
+func (x *DeprecatedMessage) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_comments_deprecated_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use DeprecatedMessage.ProtoReflect.Descriptor instead.
+func (*DeprecatedMessage) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_comments_deprecated_proto_rawDescGZIP(), []int{0}
+}
+
+// Deprecated: Do not use.
+func (x *DeprecatedMessage) GetDeprecatedField() string {
+	if x != nil {
+		return x.DeprecatedField
+	}
+	return ""
+}
+
+var File_cmd_protoc_gen_go_testdata_comments_deprecated_proto protoreflect.FileDescriptor
+
+var file_cmd_protoc_gen_go_testdata_comments_deprecated_proto_rawDesc = []byte{
+	0x0a, 0x34, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x63, 0x6f, 0x6d,
+	0x6d, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x17, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x22,
+	0x46, 0x0a, 0x11, 0x44, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x12, 0x2d, 0x0a, 0x10, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74,
+	0x65, 0x64, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x02,
+	0x18, 0x01, 0x52, 0x0f, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x46, 0x69,
+	0x65, 0x6c, 0x64, 0x3a, 0x02, 0x18, 0x01, 0x2a, 0x28, 0x0a, 0x0e, 0x44, 0x65, 0x70, 0x72, 0x65,
+	0x63, 0x61, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x12, 0x0a, 0x0a, 0x44, 0x45, 0x50,
+	0x52, 0x45, 0x43, 0x41, 0x54, 0x45, 0x44, 0x10, 0x00, 0x1a, 0x02, 0x08, 0x01, 0x1a, 0x02, 0x18,
+	0x01, 0x42, 0x43, 0x5a, 0x3e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61,
+	0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f,
+	0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67,
+	0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x65,
+	0x6e, 0x74, 0x73, 0xb8, 0x01, 0x01, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_cmd_protoc_gen_go_testdata_comments_deprecated_proto_rawDescOnce sync.Once
+	file_cmd_protoc_gen_go_testdata_comments_deprecated_proto_rawDescData = file_cmd_protoc_gen_go_testdata_comments_deprecated_proto_rawDesc
+)
+
+func file_cmd_protoc_gen_go_testdata_comments_deprecated_proto_rawDescGZIP() []byte {
+	file_cmd_protoc_gen_go_testdata_comments_deprecated_proto_rawDescOnce.Do(func() {
+		file_cmd_protoc_gen_go_testdata_comments_deprecated_proto_rawDescData = protoimpl.X.CompressGZIP(file_cmd_protoc_gen_go_testdata_comments_deprecated_proto_rawDescData)
+	})
+	return file_cmd_protoc_gen_go_testdata_comments_deprecated_proto_rawDescData
+}
+
+var file_cmd_protoc_gen_go_testdata_comments_deprecated_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
+var file_cmd_protoc_gen_go_testdata_comments_deprecated_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_cmd_protoc_gen_go_testdata_comments_deprecated_proto_goTypes = []interface{}{
+	(DeprecatedEnum)(0),       // 0: goproto.protoc.comments.DeprecatedEnum
+	(*DeprecatedMessage)(nil), // 1: goproto.protoc.comments.DeprecatedMessage
+}
+var file_cmd_protoc_gen_go_testdata_comments_deprecated_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_cmd_protoc_gen_go_testdata_comments_deprecated_proto_init() }
+func file_cmd_protoc_gen_go_testdata_comments_deprecated_proto_init() {
+	if File_cmd_protoc_gen_go_testdata_comments_deprecated_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_cmd_protoc_gen_go_testdata_comments_deprecated_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*DeprecatedMessage); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cmd_protoc_gen_go_testdata_comments_deprecated_proto_rawDesc,
+			NumEnums:      1,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_cmd_protoc_gen_go_testdata_comments_deprecated_proto_goTypes,
+		DependencyIndexes: file_cmd_protoc_gen_go_testdata_comments_deprecated_proto_depIdxs,
+		EnumInfos:         file_cmd_protoc_gen_go_testdata_comments_deprecated_proto_enumTypes,
+		MessageInfos:      file_cmd_protoc_gen_go_testdata_comments_deprecated_proto_msgTypes,
+	}.Build()
+	File_cmd_protoc_gen_go_testdata_comments_deprecated_proto = out.File
+	file_cmd_protoc_gen_go_testdata_comments_deprecated_proto_rawDesc = nil
+	file_cmd_protoc_gen_go_testdata_comments_deprecated_proto_goTypes = nil
+	file_cmd_protoc_gen_go_testdata_comments_deprecated_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/comments/deprecated.proto b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/comments/deprecated.proto
new file mode 100644
index 000000000..daac493b1
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/comments/deprecated.proto
@@ -0,0 +1,20 @@
+// 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.
+
+syntax = "proto3";
+
+package goproto.protoc.comments;
+
+option deprecated = true;
+option go_package = "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/comments";
+
+message DeprecatedMessage {
+  option deprecated = true;
+  string deprecated_field = 1 [deprecated=true];
+}
+
+enum DeprecatedEnum {
+  option deprecated = true;
+  DEPRECATED = 0 [deprecated=true];
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/extensions/base/base.pb.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/extensions/base/base.pb.go
new file mode 100644
index 000000000..f24599686
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/extensions/base/base.pb.go
@@ -0,0 +1,224 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: cmd/protoc-gen-go/testdata/extensions/base/base.proto
+
+package base
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoiface "google.golang.org/protobuf/runtime/protoiface"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type BaseMessage struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+
+	Field *string `protobuf:"bytes,1,opt,name=field" json:"field,omitempty"`
+}
+
+func (x *BaseMessage) Reset() {
+	*x = BaseMessage{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_extensions_base_base_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *BaseMessage) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BaseMessage) ProtoMessage() {}
+
+func (x *BaseMessage) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_extensions_base_base_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use BaseMessage.ProtoReflect.Descriptor instead.
+func (*BaseMessage) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_extensions_base_base_proto_rawDescGZIP(), []int{0}
+}
+
+var extRange_BaseMessage = []protoiface.ExtensionRangeV1{
+	{Start: 4, End: 9},
+	{Start: 16, End: 536870911},
+}
+
+// Deprecated: Use BaseMessage.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*BaseMessage) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_BaseMessage
+}
+
+func (x *BaseMessage) GetField() string {
+	if x != nil && x.Field != nil {
+		return *x.Field
+	}
+	return ""
+}
+
+type MessageSetWireFormatMessage struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+}
+
+func (x *MessageSetWireFormatMessage) Reset() {
+	*x = MessageSetWireFormatMessage{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_extensions_base_base_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MessageSetWireFormatMessage) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MessageSetWireFormatMessage) ProtoMessage() {}
+
+func (x *MessageSetWireFormatMessage) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_extensions_base_base_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use MessageSetWireFormatMessage.ProtoReflect.Descriptor instead.
+func (*MessageSetWireFormatMessage) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_extensions_base_base_proto_rawDescGZIP(), []int{1}
+}
+
+var extRange_MessageSetWireFormatMessage = []protoiface.ExtensionRangeV1{
+	{Start: 100, End: 2147483646},
+}
+
+// Deprecated: Use MessageSetWireFormatMessage.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*MessageSetWireFormatMessage) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_MessageSetWireFormatMessage
+}
+
+var File_cmd_protoc_gen_go_testdata_extensions_base_base_proto protoreflect.FileDescriptor
+
+var file_cmd_protoc_gen_go_testdata_extensions_base_base_proto_rawDesc = []byte{
+	0x0a, 0x35, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x65, 0x78, 0x74,
+	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x62, 0x61, 0x73, 0x65, 0x2f, 0x62, 0x61, 0x73,
+	0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1d, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f,
+	0x6e, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x22, 0x33, 0x0a, 0x0b, 0x42, 0x61, 0x73, 0x65, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x2a, 0x04, 0x08, 0x04, 0x10,
+	0x0a, 0x2a, 0x08, 0x08, 0x10, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x22, 0x2b, 0x0a, 0x1b, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x57, 0x69, 0x72, 0x65, 0x46, 0x6f, 0x72,
+	0x6d, 0x61, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2a, 0x08, 0x08, 0x64, 0x10, 0xff,
+	0xff, 0xff, 0xff, 0x07, 0x3a, 0x02, 0x08, 0x01, 0x42, 0x47, 0x5a, 0x45, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74,
+	0x61, 0x2f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x62, 0x61, 0x73,
+	0x65,
+}
+
+var (
+	file_cmd_protoc_gen_go_testdata_extensions_base_base_proto_rawDescOnce sync.Once
+	file_cmd_protoc_gen_go_testdata_extensions_base_base_proto_rawDescData = file_cmd_protoc_gen_go_testdata_extensions_base_base_proto_rawDesc
+)
+
+func file_cmd_protoc_gen_go_testdata_extensions_base_base_proto_rawDescGZIP() []byte {
+	file_cmd_protoc_gen_go_testdata_extensions_base_base_proto_rawDescOnce.Do(func() {
+		file_cmd_protoc_gen_go_testdata_extensions_base_base_proto_rawDescData = protoimpl.X.CompressGZIP(file_cmd_protoc_gen_go_testdata_extensions_base_base_proto_rawDescData)
+	})
+	return file_cmd_protoc_gen_go_testdata_extensions_base_base_proto_rawDescData
+}
+
+var file_cmd_protoc_gen_go_testdata_extensions_base_base_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
+var file_cmd_protoc_gen_go_testdata_extensions_base_base_proto_goTypes = []interface{}{
+	(*BaseMessage)(nil),                 // 0: goproto.protoc.extension.base.BaseMessage
+	(*MessageSetWireFormatMessage)(nil), // 1: goproto.protoc.extension.base.MessageSetWireFormatMessage
+}
+var file_cmd_protoc_gen_go_testdata_extensions_base_base_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_cmd_protoc_gen_go_testdata_extensions_base_base_proto_init() }
+func file_cmd_protoc_gen_go_testdata_extensions_base_base_proto_init() {
+	if File_cmd_protoc_gen_go_testdata_extensions_base_base_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_cmd_protoc_gen_go_testdata_extensions_base_base_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*BaseMessage); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_cmd_protoc_gen_go_testdata_extensions_base_base_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MessageSetWireFormatMessage); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cmd_protoc_gen_go_testdata_extensions_base_base_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   2,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_cmd_protoc_gen_go_testdata_extensions_base_base_proto_goTypes,
+		DependencyIndexes: file_cmd_protoc_gen_go_testdata_extensions_base_base_proto_depIdxs,
+		MessageInfos:      file_cmd_protoc_gen_go_testdata_extensions_base_base_proto_msgTypes,
+	}.Build()
+	File_cmd_protoc_gen_go_testdata_extensions_base_base_proto = out.File
+	file_cmd_protoc_gen_go_testdata_extensions_base_base_proto_rawDesc = nil
+	file_cmd_protoc_gen_go_testdata_extensions_base_base_proto_goTypes = nil
+	file_cmd_protoc_gen_go_testdata_extensions_base_base_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/extensions/base/base.proto b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/extensions/base/base.proto
new file mode 100644
index 000000000..32d242edf
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/extensions/base/base.proto
@@ -0,0 +1,20 @@
+// 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.
+
+syntax = "proto2";
+
+package goproto.protoc.extension.base;
+
+option go_package = "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/extensions/base";
+
+message BaseMessage {
+  optional string field = 1;
+  extensions 4 to 9;
+  extensions 16 to max;
+}
+
+message MessageSetWireFormatMessage {
+  option message_set_wire_format = true;
+  extensions 100 to max;
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/extensions/ext/ext.pb.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/extensions/ext/ext.pb.go
new file mode 100644
index 000000000..b4c58c3d3
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/extensions/ext/ext.pb.go
@@ -0,0 +1,1412 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: cmd/protoc-gen-go/testdata/extensions/ext/ext.proto
+
+package ext
+
+import (
+	base "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/extensions/base"
+	extra "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/extensions/extra"
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoiface "google.golang.org/protobuf/runtime/protoiface"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type Enum int32
+
+const (
+	Enum_ZERO Enum = 0
+)
+
+// Enum value maps for Enum.
+var (
+	Enum_name = map[int32]string{
+		0: "ZERO",
+	}
+	Enum_value = map[string]int32{
+		"ZERO": 0,
+	}
+)
+
+func (x Enum) Enum() *Enum {
+	p := new(Enum)
+	*p = x
+	return p
+}
+
+func (x Enum) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum) Descriptor() protoreflect.EnumDescriptor {
+	return file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_enumTypes[0].Descriptor()
+}
+
+func (Enum) Type() protoreflect.EnumType {
+	return &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_enumTypes[0]
+}
+
+func (x Enum) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum(num)
+	return nil
+}
+
+// Deprecated: Use Enum.Descriptor instead.
+func (Enum) EnumDescriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_rawDescGZIP(), []int{0}
+}
+
+type Message struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Data []byte `protobuf:"bytes,1,opt,name=data" json:"data,omitempty"`
+}
+
+func (x *Message) Reset() {
+	*x = Message{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message) ProtoMessage() {}
+
+func (x *Message) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message.ProtoReflect.Descriptor instead.
+func (*Message) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Message) GetData() []byte {
+	if x != nil {
+		return x.Data
+	}
+	return nil
+}
+
+type ExtensionGroup struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	ExtensionGroup *string `protobuf:"bytes,120,opt,name=extension_group,json=extensionGroup" json:"extension_group,omitempty"`
+}
+
+func (x *ExtensionGroup) Reset() {
+	*x = ExtensionGroup{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *ExtensionGroup) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ExtensionGroup) ProtoMessage() {}
+
+func (x *ExtensionGroup) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ExtensionGroup.ProtoReflect.Descriptor instead.
+func (*ExtensionGroup) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *ExtensionGroup) GetExtensionGroup() string {
+	if x != nil && x.ExtensionGroup != nil {
+		return *x.ExtensionGroup
+	}
+	return ""
+}
+
+// Extend in the scope of another type.
+type ExtendingMessage struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *ExtendingMessage) Reset() {
+	*x = ExtendingMessage{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *ExtendingMessage) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ExtendingMessage) ProtoMessage() {}
+
+func (x *ExtendingMessage) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ExtendingMessage.ProtoReflect.Descriptor instead.
+func (*ExtendingMessage) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_rawDescGZIP(), []int{2}
+}
+
+type RepeatedGroup struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	RepeatedXGroup []string `protobuf:"bytes,319,rep,name=repeated_x_group,json=repeatedXGroup" json:"repeated_x_group,omitempty"`
+}
+
+func (x *RepeatedGroup) Reset() {
+	*x = RepeatedGroup{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *RepeatedGroup) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*RepeatedGroup) ProtoMessage() {}
+
+func (x *RepeatedGroup) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use RepeatedGroup.ProtoReflect.Descriptor instead.
+func (*RepeatedGroup) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *RepeatedGroup) GetRepeatedXGroup() []string {
+	if x != nil {
+		return x.RepeatedXGroup
+	}
+	return nil
+}
+
+// An extension of an extension.
+type Extendable struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+}
+
+func (x *Extendable) Reset() {
+	*x = Extendable{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Extendable) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Extendable) ProtoMessage() {}
+
+func (x *Extendable) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Extendable.ProtoReflect.Descriptor instead.
+func (*Extendable) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_rawDescGZIP(), []int{4}
+}
+
+var extRange_Extendable = []protoiface.ExtensionRangeV1{
+	{Start: 1, End: 536870911},
+}
+
+// Deprecated: Use Extendable.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*Extendable) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_Extendable
+}
+
+// Message set wire format.
+type MessageSetWireFormatExtension struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *MessageSetWireFormatExtension) Reset() {
+	*x = MessageSetWireFormatExtension{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_msgTypes[5]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MessageSetWireFormatExtension) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MessageSetWireFormatExtension) ProtoMessage() {}
+
+func (x *MessageSetWireFormatExtension) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_msgTypes[5]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use MessageSetWireFormatExtension.ProtoReflect.Descriptor instead.
+func (*MessageSetWireFormatExtension) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_rawDescGZIP(), []int{5}
+}
+
+type Message_M struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message_M) Reset() {
+	*x = Message_M{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_msgTypes[6]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message_M) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message_M) ProtoMessage() {}
+
+func (x *Message_M) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_msgTypes[6]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message_M.ProtoReflect.Descriptor instead.
+func (*Message_M) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_rawDescGZIP(), []int{0, 0}
+}
+
+type ExtendingMessage_ExtendingMessageSubmessage struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *ExtendingMessage_ExtendingMessageSubmessage) Reset() {
+	*x = ExtendingMessage_ExtendingMessageSubmessage{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_msgTypes[7]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *ExtendingMessage_ExtendingMessageSubmessage) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ExtendingMessage_ExtendingMessageSubmessage) ProtoMessage() {}
+
+func (x *ExtendingMessage_ExtendingMessageSubmessage) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_msgTypes[7]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ExtendingMessage_ExtendingMessageSubmessage.ProtoReflect.Descriptor instead.
+func (*ExtendingMessage_ExtendingMessageSubmessage) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_rawDescGZIP(), []int{2, 0}
+}
+
+var file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes = []protoimpl.ExtensionInfo{
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: (*bool)(nil),
+		Field:         101,
+		Name:          "goproto.protoc.extension.ext.extension_bool",
+		Tag:           "varint,101,opt,name=extension_bool",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: (*Enum)(nil),
+		Field:         102,
+		Name:          "goproto.protoc.extension.ext.extension_enum",
+		Tag:           "varint,102,opt,name=extension_enum,enum=goproto.protoc.extension.ext.Enum",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: (*int32)(nil),
+		Field:         103,
+		Name:          "goproto.protoc.extension.ext.extension_int32",
+		Tag:           "varint,103,opt,name=extension_int32",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: (*int32)(nil),
+		Field:         104,
+		Name:          "goproto.protoc.extension.ext.extension_sint32",
+		Tag:           "zigzag32,104,opt,name=extension_sint32",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: (*uint32)(nil),
+		Field:         105,
+		Name:          "goproto.protoc.extension.ext.extension_uint32",
+		Tag:           "varint,105,opt,name=extension_uint32",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: (*int64)(nil),
+		Field:         106,
+		Name:          "goproto.protoc.extension.ext.extension_int64",
+		Tag:           "varint,106,opt,name=extension_int64",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: (*int64)(nil),
+		Field:         107,
+		Name:          "goproto.protoc.extension.ext.extension_sint64",
+		Tag:           "zigzag64,107,opt,name=extension_sint64",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: (*uint64)(nil),
+		Field:         108,
+		Name:          "goproto.protoc.extension.ext.extension_uint64",
+		Tag:           "varint,108,opt,name=extension_uint64",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: (*int32)(nil),
+		Field:         109,
+		Name:          "goproto.protoc.extension.ext.extension_sfixed32",
+		Tag:           "fixed32,109,opt,name=extension_sfixed32",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: (*uint32)(nil),
+		Field:         110,
+		Name:          "goproto.protoc.extension.ext.extension_fixed32",
+		Tag:           "fixed32,110,opt,name=extension_fixed32",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: (*float32)(nil),
+		Field:         111,
+		Name:          "goproto.protoc.extension.ext.extension_float",
+		Tag:           "fixed32,111,opt,name=extension_float",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: (*int64)(nil),
+		Field:         112,
+		Name:          "goproto.protoc.extension.ext.extension_sfixed64",
+		Tag:           "fixed64,112,opt,name=extension_sfixed64",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: (*uint64)(nil),
+		Field:         113,
+		Name:          "goproto.protoc.extension.ext.extension_fixed64",
+		Tag:           "fixed64,113,opt,name=extension_fixed64",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: (*float64)(nil),
+		Field:         114,
+		Name:          "goproto.protoc.extension.ext.extension_double",
+		Tag:           "fixed64,114,opt,name=extension_double",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: (*string)(nil),
+		Field:         115,
+		Name:          "goproto.protoc.extension.ext.extension_string",
+		Tag:           "bytes,115,opt,name=extension_string",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: ([]byte)(nil),
+		Field:         116,
+		Name:          "goproto.protoc.extension.ext.extension_bytes",
+		Tag:           "bytes,116,opt,name=extension_bytes",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: (*Message)(nil),
+		Field:         117,
+		Name:          "goproto.protoc.extension.ext.extension_Message",
+		Tag:           "bytes,117,opt,name=extension_Message",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: (*Message_M)(nil),
+		Field:         118,
+		Name:          "goproto.protoc.extension.ext.extension_MessageM",
+		Tag:           "bytes,118,opt,name=extension_MessageM",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: (*ExtensionGroup)(nil),
+		Field:         119,
+		Name:          "goproto.protoc.extension.ext.extensiongroup",
+		Tag:           "group,119,opt,name=ExtensionGroup",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: (*extra.ExtraMessage)(nil),
+		Field:         9,
+		Name:          "goproto.protoc.extension.ext.extra_message",
+		Tag:           "bytes,9,opt,name=extra_message",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: ([]bool)(nil),
+		Field:         301,
+		Name:          "goproto.protoc.extension.ext.repeated_x_bool",
+		Tag:           "varint,301,rep,name=repeated_x_bool",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: ([]Enum)(nil),
+		Field:         302,
+		Name:          "goproto.protoc.extension.ext.repeated_x_enum",
+		Tag:           "varint,302,rep,name=repeated_x_enum,enum=goproto.protoc.extension.ext.Enum",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: ([]int32)(nil),
+		Field:         303,
+		Name:          "goproto.protoc.extension.ext.repeated_x_int32",
+		Tag:           "varint,303,rep,name=repeated_x_int32",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: ([]int32)(nil),
+		Field:         304,
+		Name:          "goproto.protoc.extension.ext.repeated_x_sint32",
+		Tag:           "zigzag32,304,rep,name=repeated_x_sint32",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: ([]uint32)(nil),
+		Field:         305,
+		Name:          "goproto.protoc.extension.ext.repeated_x_uint32",
+		Tag:           "varint,305,rep,name=repeated_x_uint32",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: ([]int64)(nil),
+		Field:         306,
+		Name:          "goproto.protoc.extension.ext.repeated_x_int64",
+		Tag:           "varint,306,rep,name=repeated_x_int64",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: ([]int64)(nil),
+		Field:         307,
+		Name:          "goproto.protoc.extension.ext.repeated_x_sint64",
+		Tag:           "zigzag64,307,rep,name=repeated_x_sint64",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: ([]uint64)(nil),
+		Field:         308,
+		Name:          "goproto.protoc.extension.ext.repeated_x_uint64",
+		Tag:           "varint,308,rep,name=repeated_x_uint64",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: ([]int32)(nil),
+		Field:         309,
+		Name:          "goproto.protoc.extension.ext.repeated_x_sfixed32",
+		Tag:           "fixed32,309,rep,name=repeated_x_sfixed32",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: ([]uint32)(nil),
+		Field:         310,
+		Name:          "goproto.protoc.extension.ext.repeated_x_fixed32",
+		Tag:           "fixed32,310,rep,name=repeated_x_fixed32",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: ([]float32)(nil),
+		Field:         311,
+		Name:          "goproto.protoc.extension.ext.repeated_x_float",
+		Tag:           "fixed32,311,rep,name=repeated_x_float",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: ([]int64)(nil),
+		Field:         312,
+		Name:          "goproto.protoc.extension.ext.repeated_x_sfixed64",
+		Tag:           "fixed64,312,rep,name=repeated_x_sfixed64",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: ([]uint64)(nil),
+		Field:         313,
+		Name:          "goproto.protoc.extension.ext.repeated_x_fixed64",
+		Tag:           "fixed64,313,rep,name=repeated_x_fixed64",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: ([]float64)(nil),
+		Field:         314,
+		Name:          "goproto.protoc.extension.ext.repeated_x_double",
+		Tag:           "fixed64,314,rep,name=repeated_x_double",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: ([]string)(nil),
+		Field:         315,
+		Name:          "goproto.protoc.extension.ext.repeated_x_string",
+		Tag:           "bytes,315,rep,name=repeated_x_string",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: ([][]byte)(nil),
+		Field:         316,
+		Name:          "goproto.protoc.extension.ext.repeated_x_bytes",
+		Tag:           "bytes,316,rep,name=repeated_x_bytes",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: ([]*Message)(nil),
+		Field:         317,
+		Name:          "goproto.protoc.extension.ext.repeated_x_Message",
+		Tag:           "bytes,317,rep,name=repeated_x_Message",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: ([]*RepeatedGroup)(nil),
+		Field:         318,
+		Name:          "goproto.protoc.extension.ext.repeatedgroup",
+		Tag:           "group,318,rep,name=RepeatedGroup",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: (*Extendable)(nil),
+		Field:         400,
+		Name:          "goproto.protoc.extension.ext.extendable_field",
+		Tag:           "bytes,400,opt,name=extendable_field",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*Extendable)(nil),
+		ExtensionType: (*string)(nil),
+		Field:         1,
+		Name:          "goproto.protoc.extension.ext.extendable_string_field",
+		Tag:           "bytes,1,opt,name=extendable_string_field",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.MessageSetWireFormatMessage)(nil),
+		ExtensionType: (*MessageSetWireFormatExtension)(nil),
+		Field:         101,
+		Name:          "goproto.protoc.extension.ext.message_set_extension",
+		Tag:           "bytes,101,opt,name=message_set_extension",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: (*string)(nil),
+		Field:         200,
+		Name:          "goproto.protoc.extension.ext.ExtendingMessage.extending_message_string",
+		Tag:           "bytes,200,opt,name=extending_message_string",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.BaseMessage)(nil),
+		ExtensionType: (*ExtendingMessage_ExtendingMessageSubmessage)(nil),
+		Field:         201,
+		Name:          "goproto.protoc.extension.ext.ExtendingMessage.extending_message_submessage",
+		Tag:           "bytes,201,opt,name=extending_message_submessage",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+	{
+		ExtendedType:  (*base.MessageSetWireFormatMessage)(nil),
+		ExtensionType: (*MessageSetWireFormatExtension)(nil),
+		Field:         100,
+		Name:          "goproto.protoc.extension.ext.MessageSetWireFormatExtension",
+		Tag:           "bytes,100,opt,name=message_set_extension",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/ext/ext.proto",
+	},
+}
+
+// Extension fields to base.BaseMessage.
+var (
+	// optional bool extension_bool = 101;
+	E_ExtensionBool = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[0]
+	// optional goproto.protoc.extension.ext.Enum extension_enum = 102;
+	E_ExtensionEnum = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[1]
+	// optional int32 extension_int32 = 103;
+	E_ExtensionInt32 = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[2]
+	// optional sint32 extension_sint32 = 104;
+	E_ExtensionSint32 = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[3]
+	// optional uint32 extension_uint32 = 105;
+	E_ExtensionUint32 = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[4]
+	// optional int64 extension_int64 = 106;
+	E_ExtensionInt64 = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[5]
+	// optional sint64 extension_sint64 = 107;
+	E_ExtensionSint64 = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[6]
+	// optional uint64 extension_uint64 = 108;
+	E_ExtensionUint64 = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[7]
+	// optional sfixed32 extension_sfixed32 = 109;
+	E_ExtensionSfixed32 = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[8]
+	// optional fixed32 extension_fixed32 = 110;
+	E_ExtensionFixed32 = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[9]
+	// optional float extension_float = 111;
+	E_ExtensionFloat = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[10]
+	// optional sfixed64 extension_sfixed64 = 112;
+	E_ExtensionSfixed64 = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[11]
+	// optional fixed64 extension_fixed64 = 113;
+	E_ExtensionFixed64 = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[12]
+	// optional double extension_double = 114;
+	E_ExtensionDouble = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[13]
+	// optional string extension_string = 115;
+	E_ExtensionString = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[14]
+	// optional bytes extension_bytes = 116;
+	E_ExtensionBytes = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[15]
+	// optional goproto.protoc.extension.ext.Message extension_Message = 117;
+	E_Extension_Message = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[16]
+	// optional goproto.protoc.extension.ext.Message.M extension_MessageM = 118;
+	E_Extension_MessageM = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[17]
+	// optional goproto.protoc.extension.ext.ExtensionGroup extensiongroup = 119;
+	E_Extensiongroup = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[18]
+	// optional goproto.protoc.extension.extra.ExtraMessage extra_message = 9;
+	E_ExtraMessage = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[19]
+	// repeated bool repeated_x_bool = 301;
+	E_RepeatedXBool = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[20]
+	// repeated goproto.protoc.extension.ext.Enum repeated_x_enum = 302;
+	E_RepeatedXEnum = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[21]
+	// repeated int32 repeated_x_int32 = 303;
+	E_RepeatedXInt32 = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[22]
+	// repeated sint32 repeated_x_sint32 = 304;
+	E_RepeatedXSint32 = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[23]
+	// repeated uint32 repeated_x_uint32 = 305;
+	E_RepeatedXUint32 = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[24]
+	// repeated int64 repeated_x_int64 = 306;
+	E_RepeatedXInt64 = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[25]
+	// repeated sint64 repeated_x_sint64 = 307;
+	E_RepeatedXSint64 = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[26]
+	// repeated uint64 repeated_x_uint64 = 308;
+	E_RepeatedXUint64 = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[27]
+	// repeated sfixed32 repeated_x_sfixed32 = 309;
+	E_RepeatedXSfixed32 = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[28]
+	// repeated fixed32 repeated_x_fixed32 = 310;
+	E_RepeatedXFixed32 = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[29]
+	// repeated float repeated_x_float = 311;
+	E_RepeatedXFloat = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[30]
+	// repeated sfixed64 repeated_x_sfixed64 = 312;
+	E_RepeatedXSfixed64 = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[31]
+	// repeated fixed64 repeated_x_fixed64 = 313;
+	E_RepeatedXFixed64 = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[32]
+	// repeated double repeated_x_double = 314;
+	E_RepeatedXDouble = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[33]
+	// repeated string repeated_x_string = 315;
+	E_RepeatedXString = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[34]
+	// repeated bytes repeated_x_bytes = 316;
+	E_RepeatedXBytes = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[35]
+	// repeated goproto.protoc.extension.ext.Message repeated_x_Message = 317;
+	E_RepeatedX_Message = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[36]
+	// repeated goproto.protoc.extension.ext.RepeatedGroup repeatedgroup = 318;
+	E_Repeatedgroup = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[37]
+	// optional goproto.protoc.extension.ext.Extendable extendable_field = 400;
+	E_ExtendableField = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[38]
+	// optional string extending_message_string = 200;
+	E_ExtendingMessage_ExtendingMessageString = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[41]
+	// optional goproto.protoc.extension.ext.ExtendingMessage.ExtendingMessageSubmessage extending_message_submessage = 201;
+	E_ExtendingMessage_ExtendingMessageSubmessage = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[42]
+)
+
+// Extension fields to Extendable.
+var (
+	// optional string extendable_string_field = 1;
+	E_ExtendableStringField = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[39]
+)
+
+// Extension fields to base.MessageSetWireFormatMessage.
+var (
+	// optional goproto.protoc.extension.ext.MessageSetWireFormatExtension message_set_extension = 101;
+	E_MessageSetExtension = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[40]
+	// optional goproto.protoc.extension.ext.MessageSetWireFormatExtension message_set_extension = 100;
+	E_MessageSetWireFormatExtension_MessageSetExtension = &file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes[43]
+)
+
+var File_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto protoreflect.FileDescriptor
+
+var file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_rawDesc = []byte{
+	0x0a, 0x33, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x65, 0x78, 0x74,
+	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x65, 0x78, 0x74, 0x2f, 0x65, 0x78, 0x74, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1c, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e,
+	0x65, 0x78, 0x74, 0x1a, 0x35, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d,
+	0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f,
+	0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x62, 0x61, 0x73, 0x65, 0x2f,
+	0x62, 0x61, 0x73, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x37, 0x63, 0x6d, 0x64, 0x2f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65,
+	0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
+	0x73, 0x2f, 0x65, 0x78, 0x74, 0x72, 0x61, 0x2f, 0x65, 0x78, 0x74, 0x72, 0x61, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x22, 0x22, 0x0a, 0x07, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x12,
+	0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61,
+	0x74, 0x61, 0x1a, 0x03, 0x0a, 0x01, 0x4d, 0x22, 0x39, 0x0a, 0x0e, 0x45, 0x78, 0x74, 0x65, 0x6e,
+	0x73, 0x69, 0x6f, 0x6e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x27, 0x0a, 0x0f, 0x65, 0x78, 0x74,
+	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x78, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x0e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x47, 0x72, 0x6f,
+	0x75, 0x70, 0x22, 0xd2, 0x02, 0x0a, 0x10, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x1a, 0x1c, 0x0a, 0x1a, 0x45, 0x78, 0x74, 0x65, 0x6e,
+	0x64, 0x69, 0x6e, 0x67, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x75, 0x62, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x65, 0x0a, 0x18, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x69,
+	0x6e, 0x67, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e,
+	0x67, 0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x62, 0x61, 0x73,
+	0x65, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0xc8, 0x01,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x16, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x32, 0xb8, 0x01, 0x0a,
+	0x1c, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x5f, 0x73, 0x75, 0x62, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x2a, 0x2e,
+	0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65,
+	0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x42, 0x61,
+	0x73, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0xc9, 0x01, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x49, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x65, 0x78, 0x74, 0x2e,
+	0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x53, 0x75, 0x62, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x1a, 0x65, 0x78, 0x74,
+	0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x75, 0x62,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x3a, 0x0a, 0x0d, 0x52, 0x65, 0x70, 0x65, 0x61,
+	0x74, 0x65, 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x29, 0x0a, 0x10, 0x72, 0x65, 0x70, 0x65,
+	0x61, 0x74, 0x65, 0x64, 0x5f, 0x78, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0xbf, 0x02, 0x20,
+	0x03, 0x28, 0x09, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x58, 0x47, 0x72,
+	0x6f, 0x75, 0x70, 0x22, 0x16, 0x0a, 0x0a, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x61, 0x62, 0x6c,
+	0x65, 0x2a, 0x08, 0x08, 0x01, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x22, 0xcd, 0x01, 0x0a, 0x1d,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x57, 0x69, 0x72, 0x65, 0x46, 0x6f,
+	0x72, 0x6d, 0x61, 0x74, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x32, 0xab, 0x01,
+	0x0a, 0x15, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x65, 0x74, 0x5f, 0x65, 0x78,
+	0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x3a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69,
+	0x6f, 0x6e, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53,
+	0x65, 0x74, 0x57, 0x69, 0x72, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x18, 0x64, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x3b, 0x2e, 0x67, 0x6f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e,
+	0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x65, 0x78, 0x74, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x53, 0x65, 0x74, 0x57, 0x69, 0x72, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x45, 0x78, 0x74,
+	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53,
+	0x65, 0x74, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2a, 0x10, 0x0a, 0x04, 0x45,
+	0x6e, 0x75, 0x6d, 0x12, 0x08, 0x0a, 0x04, 0x5a, 0x45, 0x52, 0x4f, 0x10, 0x00, 0x3a, 0x51, 0x0a,
+	0x0e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x12,
+	0x2a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63,
+	0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e,
+	0x42, 0x61, 0x73, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x65, 0x20, 0x01, 0x28,
+	0x08, 0x52, 0x0d, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x42, 0x6f, 0x6f, 0x6c,
+	0x3a, 0x75, 0x0a, 0x0e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x65, 0x6e,
+	0x75, 0x6d, 0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x62, 0x61,
+	0x73, 0x65, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x66,
+	0x20, 0x01, 0x28, 0x0e, 0x32, 0x22, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e,
+	0x65, 0x78, 0x74, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0d, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73,
+	0x69, 0x6f, 0x6e, 0x45, 0x6e, 0x75, 0x6d, 0x3a, 0x53, 0x0a, 0x0f, 0x65, 0x78, 0x74, 0x65, 0x6e,
+	0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65,
+	0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x67, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, 0x65, 0x78,
+	0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x3a, 0x55, 0x0a, 0x10,
+	0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x33, 0x32,
+	0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x62, 0x61, 0x73, 0x65,
+	0x2e, 0x42, 0x61, 0x73, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x68, 0x20, 0x01,
+	0x28, 0x11, 0x52, 0x0f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x53, 0x69, 0x6e,
+	0x74, 0x33, 0x32, 0x3a, 0x55, 0x0a, 0x10, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
+	0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69,
+	0x6f, 0x6e, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x18, 0x69, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0f, 0x65, 0x78, 0x74, 0x65, 0x6e,
+	0x73, 0x69, 0x6f, 0x6e, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x3a, 0x53, 0x0a, 0x0f, 0x65, 0x78,
+	0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x2a, 0x2e,
+	0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65,
+	0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x42, 0x61,
+	0x73, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x6a, 0x20, 0x01, 0x28, 0x03, 0x52,
+	0x0e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x3a,
+	0x55, 0x0a, 0x10, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x69, 0x6e,
+	0x74, 0x36, 0x34, 0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x62,
+	0x61, 0x73, 0x65, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18,
+	0x6b, 0x20, 0x01, 0x28, 0x12, 0x52, 0x0f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
+	0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x3a, 0x55, 0x0a, 0x10, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73,
+	0x69, 0x6f, 0x6e, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65,
+	0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x6c, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0f, 0x65, 0x78,
+	0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x3a, 0x59, 0x0a,
+	0x12, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65,
+	0x64, 0x33, 0x32, 0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x62,
+	0x61, 0x73, 0x65, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18,
+	0x6d, 0x20, 0x01, 0x28, 0x0f, 0x52, 0x11, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
+	0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x3a, 0x57, 0x0a, 0x11, 0x65, 0x78, 0x74, 0x65,
+	0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x2a, 0x2e,
+	0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65,
+	0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x42, 0x61,
+	0x73, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x6e, 0x20, 0x01, 0x28, 0x07, 0x52,
+	0x10, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33,
+	0x32, 0x3a, 0x53, 0x0a, 0x0f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x66,
+	0x6c, 0x6f, 0x61, 0x74, 0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e,
+	0x62, 0x61, 0x73, 0x65, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x18, 0x6f, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f,
+	0x6e, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x3a, 0x59, 0x0a, 0x12, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73,
+	0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x2a, 0x2e, 0x67,
+	0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78,
+	0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x42, 0x61, 0x73,
+	0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x70, 0x20, 0x01, 0x28, 0x10, 0x52, 0x11,
+	0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36,
+	0x34, 0x3a, 0x57, 0x0a, 0x11, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x66,
+	0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f,
+	0x6e, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x18, 0x71, 0x20, 0x01, 0x28, 0x06, 0x52, 0x10, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73,
+	0x69, 0x6f, 0x6e, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x3a, 0x55, 0x0a, 0x10, 0x65, 0x78,
+	0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x2a,
+	0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e,
+	0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x42,
+	0x61, 0x73, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x72, 0x20, 0x01, 0x28, 0x01,
+	0x52, 0x0f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x44, 0x6f, 0x75, 0x62, 0x6c,
+	0x65, 0x3a, 0x55, 0x0a, 0x10, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x73,
+	0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
+	0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x18, 0x73, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69,
+	0x6f, 0x6e, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3a, 0x53, 0x0a, 0x0f, 0x65, 0x78, 0x74, 0x65,
+	0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x12, 0x2a, 0x2e, 0x67, 0x6f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74,
+	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x42, 0x61, 0x73, 0x65,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x74, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0e, 0x65,
+	0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x42, 0x79, 0x74, 0x65, 0x73, 0x3a, 0x7e, 0x0a,
+	0x11, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x62, 0x61,
+	0x73, 0x65, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x75,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e,
+	0x65, 0x78, 0x74, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x10, 0x65, 0x78, 0x74,
+	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x3a, 0x82, 0x01,
+	0x0a, 0x12, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x4d, 0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e,
+	0x62, 0x61, 0x73, 0x65, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x18, 0x76, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f,
+	0x6e, 0x2e, 0x65, 0x78, 0x74, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x4d, 0x52,
+	0x11, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x4d, 0x3a, 0x80, 0x01, 0x0a, 0x0e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
+	0x67, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
+	0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x18, 0x77, 0x20, 0x01, 0x28, 0x0a, 0x32, 0x2c, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69,
+	0x6f, 0x6e, 0x2e, 0x65, 0x78, 0x74, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
+	0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x0e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
+	0x67, 0x72, 0x6f, 0x75, 0x70, 0x3a, 0x7d, 0x0a, 0x0d, 0x65, 0x78, 0x74, 0x72, 0x61, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f,
+	0x6e, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73,
+	0x69, 0x6f, 0x6e, 0x2e, 0x65, 0x78, 0x74, 0x72, 0x61, 0x2e, 0x45, 0x78, 0x74, 0x72, 0x61, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0c, 0x65, 0x78, 0x74, 0x72, 0x61, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x3a, 0x53, 0x0a, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
+	0x5f, 0x78, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69,
+	0x6f, 0x6e, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x18, 0xad, 0x02, 0x20, 0x03, 0x28, 0x08, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x65,
+	0x61, 0x74, 0x65, 0x64, 0x58, 0x42, 0x6f, 0x6f, 0x6c, 0x3a, 0x77, 0x0a, 0x0f, 0x72, 0x65, 0x70,
+	0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x78, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x12, 0x2a, 0x2e, 0x67,
+	0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78,
+	0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x42, 0x61, 0x73,
+	0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0xae, 0x02, 0x20, 0x03, 0x28, 0x0e, 0x32,
+	0x22, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63,
+	0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x65, 0x78, 0x74, 0x2e, 0x45,
+	0x6e, 0x75, 0x6d, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x58, 0x45, 0x6e,
+	0x75, 0x6d, 0x3a, 0x55, 0x0a, 0x10, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x78,
+	0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f,
+	0x6e, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x18, 0xaf, 0x02, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61,
+	0x74, 0x65, 0x64, 0x58, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x3a, 0x57, 0x0a, 0x11, 0x72, 0x65, 0x70,
+	0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x78, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x2a,
+	0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e,
+	0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x42,
+	0x61, 0x73, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0xb0, 0x02, 0x20, 0x03, 0x28,
+	0x11, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x58, 0x53, 0x69, 0x6e, 0x74,
+	0x33, 0x32, 0x3a, 0x57, 0x0a, 0x11, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x78,
+	0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69,
+	0x6f, 0x6e, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x18, 0xb1, 0x02, 0x20, 0x03, 0x28, 0x0d, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x65,
+	0x61, 0x74, 0x65, 0x64, 0x58, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x3a, 0x55, 0x0a, 0x10, 0x72,
+	0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x78, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12,
+	0x2a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63,
+	0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e,
+	0x42, 0x61, 0x73, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0xb2, 0x02, 0x20, 0x03,
+	0x28, 0x03, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x58, 0x49, 0x6e, 0x74,
+	0x36, 0x34, 0x3a, 0x57, 0x0a, 0x11, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x78,
+	0x5f, 0x73, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69,
+	0x6f, 0x6e, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x18, 0xb3, 0x02, 0x20, 0x03, 0x28, 0x12, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x65,
+	0x61, 0x74, 0x65, 0x64, 0x58, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x3a, 0x57, 0x0a, 0x11, 0x72,
+	0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x78, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34,
+	0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x62, 0x61, 0x73, 0x65,
+	0x2e, 0x42, 0x61, 0x73, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0xb4, 0x02, 0x20,
+	0x03, 0x28, 0x04, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x58, 0x55, 0x69,
+	0x6e, 0x74, 0x36, 0x34, 0x3a, 0x5b, 0x0a, 0x13, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
+	0x5f, 0x78, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x2a, 0x2e, 0x67, 0x6f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74,
+	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x42, 0x61, 0x73, 0x65,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0xb5, 0x02, 0x20, 0x03, 0x28, 0x0f, 0x52, 0x11,
+	0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x58, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33,
+	0x32, 0x3a, 0x59, 0x0a, 0x12, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x78, 0x5f,
+	0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69,
+	0x6f, 0x6e, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x18, 0xb6, 0x02, 0x20, 0x03, 0x28, 0x07, 0x52, 0x10, 0x72, 0x65, 0x70, 0x65,
+	0x61, 0x74, 0x65, 0x64, 0x58, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x3a, 0x55, 0x0a, 0x10,
+	0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x78, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74,
+	0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x62, 0x61, 0x73, 0x65,
+	0x2e, 0x42, 0x61, 0x73, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0xb7, 0x02, 0x20,
+	0x03, 0x28, 0x02, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x58, 0x46, 0x6c,
+	0x6f, 0x61, 0x74, 0x3a, 0x5b, 0x0a, 0x13, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f,
+	0x78, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65,
+	0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0xb8, 0x02, 0x20, 0x03, 0x28, 0x10, 0x52, 0x11, 0x72,
+	0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x58, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34,
+	0x3a, 0x59, 0x0a, 0x12, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x78, 0x5f, 0x66,
+	0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f,
+	0x6e, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x18, 0xb9, 0x02, 0x20, 0x03, 0x28, 0x06, 0x52, 0x10, 0x72, 0x65, 0x70, 0x65, 0x61,
+	0x74, 0x65, 0x64, 0x58, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x3a, 0x57, 0x0a, 0x11, 0x72,
+	0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x78, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65,
+	0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x62, 0x61, 0x73, 0x65,
+	0x2e, 0x42, 0x61, 0x73, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0xba, 0x02, 0x20,
+	0x03, 0x28, 0x01, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x58, 0x44, 0x6f,
+	0x75, 0x62, 0x6c, 0x65, 0x3a, 0x57, 0x0a, 0x11, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
+	0x5f, 0x78, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e,
+	0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0xbb, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0f, 0x72, 0x65,
+	0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x58, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3a, 0x55, 0x0a,
+	0x10, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x78, 0x5f, 0x62, 0x79, 0x74, 0x65,
+	0x73, 0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x62, 0x61, 0x73,
+	0x65, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0xbc, 0x02,
+	0x20, 0x03, 0x28, 0x0c, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x58, 0x42,
+	0x79, 0x74, 0x65, 0x73, 0x3a, 0x80, 0x01, 0x0a, 0x12, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65,
+	0x64, 0x5f, 0x78, 0x5f, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x2a, 0x2e, 0x67, 0x6f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74,
+	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x42, 0x61, 0x73, 0x65,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0xbd, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25,
+	0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e,
+	0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x65, 0x78, 0x74, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x10, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x58,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x3a, 0x7e, 0x0a, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61,
+	0x74, 0x65, 0x64, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73,
+	0x69, 0x6f, 0x6e, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x18, 0xbe, 0x02, 0x20, 0x03, 0x28, 0x0a, 0x32, 0x2b, 0x2e, 0x67, 0x6f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74,
+	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x65, 0x78, 0x74, 0x2e, 0x52, 0x65, 0x70, 0x65, 0x61,
+	0x74, 0x65, 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74,
+	0x65, 0x64, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x3a, 0x80, 0x01, 0x0a, 0x10, 0x65, 0x78, 0x74, 0x65,
+	0x6e, 0x64, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x2a, 0x2e, 0x67,
+	0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78,
+	0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x42, 0x61, 0x73,
+	0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x90, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x28, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63,
+	0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x65, 0x78, 0x74, 0x2e, 0x45,
+	0x78, 0x74, 0x65, 0x6e, 0x64, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x0f, 0x65, 0x78, 0x74, 0x65, 0x6e,
+	0x64, 0x61, 0x62, 0x6c, 0x65, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x3a, 0x60, 0x0a, 0x17, 0x65, 0x78,
+	0x74, 0x65, 0x6e, 0x64, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x28, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
+	0x2e, 0x65, 0x78, 0x74, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x61, 0x62, 0x6c, 0x65, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x15, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x61, 0x62, 0x6c,
+	0x65, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x3a, 0xab, 0x01, 0x0a,
+	0x15, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x65, 0x74, 0x5f, 0x65, 0x78, 0x74,
+	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x3a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f,
+	0x6e, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65,
+	0x74, 0x57, 0x69, 0x72, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x18, 0x65, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x3b, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73,
+	0x69, 0x6f, 0x6e, 0x2e, 0x65, 0x78, 0x74, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53,
+	0x65, 0x74, 0x57, 0x69, 0x72, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x45, 0x78, 0x74, 0x65,
+	0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65,
+	0x74, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x42, 0x46, 0x5a, 0x44, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64,
+	0x61, 0x74, 0x61, 0x2f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x65,
+	0x78, 0x74,
+}
+
+var (
+	file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_rawDescOnce sync.Once
+	file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_rawDescData = file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_rawDesc
+)
+
+func file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_rawDescGZIP() []byte {
+	file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_rawDescOnce.Do(func() {
+		file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_rawDescData = protoimpl.X.CompressGZIP(file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_rawDescData)
+	})
+	return file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_rawDescData
+}
+
+var file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
+var file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_msgTypes = make([]protoimpl.MessageInfo, 8)
+var file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_goTypes = []interface{}{
+	(Enum)(0),                             // 0: goproto.protoc.extension.ext.Enum
+	(*Message)(nil),                       // 1: goproto.protoc.extension.ext.Message
+	(*ExtensionGroup)(nil),                // 2: goproto.protoc.extension.ext.ExtensionGroup
+	(*ExtendingMessage)(nil),              // 3: goproto.protoc.extension.ext.ExtendingMessage
+	(*RepeatedGroup)(nil),                 // 4: goproto.protoc.extension.ext.RepeatedGroup
+	(*Extendable)(nil),                    // 5: goproto.protoc.extension.ext.Extendable
+	(*MessageSetWireFormatExtension)(nil), // 6: goproto.protoc.extension.ext.MessageSetWireFormatExtension
+	(*Message_M)(nil),                     // 7: goproto.protoc.extension.ext.Message.M
+	(*ExtendingMessage_ExtendingMessageSubmessage)(nil), // 8: goproto.protoc.extension.ext.ExtendingMessage.ExtendingMessageSubmessage
+	(*base.BaseMessage)(nil),                            // 9: goproto.protoc.extension.base.BaseMessage
+	(*base.MessageSetWireFormatMessage)(nil),            // 10: goproto.protoc.extension.base.MessageSetWireFormatMessage
+	(*extra.ExtraMessage)(nil),                          // 11: goproto.protoc.extension.extra.ExtraMessage
+}
+var file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_depIdxs = []int32{
+	9,  // 0: goproto.protoc.extension.ext.extension_bool:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 1: goproto.protoc.extension.ext.extension_enum:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 2: goproto.protoc.extension.ext.extension_int32:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 3: goproto.protoc.extension.ext.extension_sint32:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 4: goproto.protoc.extension.ext.extension_uint32:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 5: goproto.protoc.extension.ext.extension_int64:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 6: goproto.protoc.extension.ext.extension_sint64:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 7: goproto.protoc.extension.ext.extension_uint64:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 8: goproto.protoc.extension.ext.extension_sfixed32:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 9: goproto.protoc.extension.ext.extension_fixed32:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 10: goproto.protoc.extension.ext.extension_float:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 11: goproto.protoc.extension.ext.extension_sfixed64:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 12: goproto.protoc.extension.ext.extension_fixed64:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 13: goproto.protoc.extension.ext.extension_double:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 14: goproto.protoc.extension.ext.extension_string:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 15: goproto.protoc.extension.ext.extension_bytes:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 16: goproto.protoc.extension.ext.extension_Message:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 17: goproto.protoc.extension.ext.extension_MessageM:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 18: goproto.protoc.extension.ext.extensiongroup:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 19: goproto.protoc.extension.ext.extra_message:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 20: goproto.protoc.extension.ext.repeated_x_bool:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 21: goproto.protoc.extension.ext.repeated_x_enum:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 22: goproto.protoc.extension.ext.repeated_x_int32:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 23: goproto.protoc.extension.ext.repeated_x_sint32:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 24: goproto.protoc.extension.ext.repeated_x_uint32:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 25: goproto.protoc.extension.ext.repeated_x_int64:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 26: goproto.protoc.extension.ext.repeated_x_sint64:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 27: goproto.protoc.extension.ext.repeated_x_uint64:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 28: goproto.protoc.extension.ext.repeated_x_sfixed32:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 29: goproto.protoc.extension.ext.repeated_x_fixed32:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 30: goproto.protoc.extension.ext.repeated_x_float:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 31: goproto.protoc.extension.ext.repeated_x_sfixed64:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 32: goproto.protoc.extension.ext.repeated_x_fixed64:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 33: goproto.protoc.extension.ext.repeated_x_double:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 34: goproto.protoc.extension.ext.repeated_x_string:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 35: goproto.protoc.extension.ext.repeated_x_bytes:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 36: goproto.protoc.extension.ext.repeated_x_Message:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 37: goproto.protoc.extension.ext.repeatedgroup:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 38: goproto.protoc.extension.ext.extendable_field:extendee -> goproto.protoc.extension.base.BaseMessage
+	5,  // 39: goproto.protoc.extension.ext.extendable_string_field:extendee -> goproto.protoc.extension.ext.Extendable
+	10, // 40: goproto.protoc.extension.ext.message_set_extension:extendee -> goproto.protoc.extension.base.MessageSetWireFormatMessage
+	9,  // 41: goproto.protoc.extension.ext.ExtendingMessage.extending_message_string:extendee -> goproto.protoc.extension.base.BaseMessage
+	9,  // 42: goproto.protoc.extension.ext.ExtendingMessage.extending_message_submessage:extendee -> goproto.protoc.extension.base.BaseMessage
+	10, // 43: goproto.protoc.extension.ext.MessageSetWireFormatExtension.message_set_extension:extendee -> goproto.protoc.extension.base.MessageSetWireFormatMessage
+	0,  // 44: goproto.protoc.extension.ext.extension_enum:type_name -> goproto.protoc.extension.ext.Enum
+	1,  // 45: goproto.protoc.extension.ext.extension_Message:type_name -> goproto.protoc.extension.ext.Message
+	7,  // 46: goproto.protoc.extension.ext.extension_MessageM:type_name -> goproto.protoc.extension.ext.Message.M
+	2,  // 47: goproto.protoc.extension.ext.extensiongroup:type_name -> goproto.protoc.extension.ext.ExtensionGroup
+	11, // 48: goproto.protoc.extension.ext.extra_message:type_name -> goproto.protoc.extension.extra.ExtraMessage
+	0,  // 49: goproto.protoc.extension.ext.repeated_x_enum:type_name -> goproto.protoc.extension.ext.Enum
+	1,  // 50: goproto.protoc.extension.ext.repeated_x_Message:type_name -> goproto.protoc.extension.ext.Message
+	4,  // 51: goproto.protoc.extension.ext.repeatedgroup:type_name -> goproto.protoc.extension.ext.RepeatedGroup
+	5,  // 52: goproto.protoc.extension.ext.extendable_field:type_name -> goproto.protoc.extension.ext.Extendable
+	6,  // 53: goproto.protoc.extension.ext.message_set_extension:type_name -> goproto.protoc.extension.ext.MessageSetWireFormatExtension
+	8,  // 54: goproto.protoc.extension.ext.ExtendingMessage.extending_message_submessage:type_name -> goproto.protoc.extension.ext.ExtendingMessage.ExtendingMessageSubmessage
+	6,  // 55: goproto.protoc.extension.ext.MessageSetWireFormatExtension.message_set_extension:type_name -> goproto.protoc.extension.ext.MessageSetWireFormatExtension
+	56, // [56:56] is the sub-list for method output_type
+	56, // [56:56] is the sub-list for method input_type
+	44, // [44:56] is the sub-list for extension type_name
+	0,  // [0:44] is the sub-list for extension extendee
+	0,  // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_init() }
+func file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_init() {
+	if File_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ExtensionGroup); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ExtendingMessage); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*RepeatedGroup); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Extendable); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MessageSetWireFormatExtension); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message_M); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ExtendingMessage_ExtendingMessageSubmessage); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_rawDesc,
+			NumEnums:      1,
+			NumMessages:   8,
+			NumExtensions: 44,
+			NumServices:   0,
+		},
+		GoTypes:           file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_goTypes,
+		DependencyIndexes: file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_depIdxs,
+		EnumInfos:         file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_enumTypes,
+		MessageInfos:      file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_msgTypes,
+		ExtensionInfos:    file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_extTypes,
+	}.Build()
+	File_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto = out.File
+	file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_rawDesc = nil
+	file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_goTypes = nil
+	file_cmd_protoc_gen_go_testdata_extensions_ext_ext_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/extensions/ext/ext.proto b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/extensions/ext/ext.proto
new file mode 100644
index 000000000..5156c1c66
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/extensions/ext/ext.proto
@@ -0,0 +1,108 @@
+// 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.
+
+syntax = "proto2";
+
+import "cmd/protoc-gen-go/testdata/extensions/base/base.proto";
+import "cmd/protoc-gen-go/testdata/extensions/extra/extra.proto";
+
+package goproto.protoc.extension.ext;
+
+option go_package = "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/extensions/ext";
+
+message Message {
+  optional bytes data = 1;
+
+  message M {}
+}
+
+enum Enum {
+  ZERO = 0;
+}
+
+// Extend with various types.
+extend goproto.protoc.extension.base.BaseMessage {
+  optional bool      extension_bool     = 101;
+  optional Enum      extension_enum     = 102;
+  optional int32     extension_int32    = 103;
+  optional sint32    extension_sint32   = 104;
+  optional uint32    extension_uint32   = 105;
+  optional int64     extension_int64    = 106;
+  optional sint64    extension_sint64   = 107;
+  optional uint64    extension_uint64   = 108;
+  optional sfixed32  extension_sfixed32 = 109;
+  optional fixed32   extension_fixed32  = 110;
+  optional float     extension_float    = 111;
+  optional sfixed64  extension_sfixed64 = 112;
+  optional fixed64   extension_fixed64  = 113;
+  optional double    extension_double   = 114;
+  optional string    extension_string   = 115;
+  optional bytes     extension_bytes    = 116;
+  optional Message   extension_Message  = 117;
+  optional Message.M extension_MessageM = 118;
+  optional group ExtensionGroup = 119 {
+    optional string extension_group = 120;
+  }
+}
+
+// Extend with a foreign message.
+extend goproto.protoc.extension.base.BaseMessage {
+  optional goproto.protoc.extension.extra.ExtraMessage extra_message = 9;
+}
+
+// Extend in the scope of another type.
+message ExtendingMessage {
+  extend goproto.protoc.extension.base.BaseMessage {
+    optional string extending_message_string = 200;
+    optional ExtendingMessageSubmessage extending_message_submessage = 201;
+  }
+  message ExtendingMessageSubmessage {}
+}
+
+// Extend with repeated fields.
+extend goproto.protoc.extension.base.BaseMessage {
+  repeated bool     repeated_x_bool     = 301;
+  repeated Enum     repeated_x_enum     = 302;
+  repeated int32    repeated_x_int32    = 303;
+  repeated sint32   repeated_x_sint32   = 304;
+  repeated uint32   repeated_x_uint32   = 305;
+  repeated int64    repeated_x_int64    = 306;
+  repeated sint64   repeated_x_sint64   = 307;
+  repeated uint64   repeated_x_uint64   = 308;
+  repeated sfixed32 repeated_x_sfixed32 = 309;
+  repeated fixed32  repeated_x_fixed32  = 310;
+  repeated float    repeated_x_float    = 311;
+  repeated sfixed64 repeated_x_sfixed64 = 312;
+  repeated fixed64  repeated_x_fixed64  = 313;
+  repeated double   repeated_x_double   = 314;
+  repeated string   repeated_x_string   = 315;
+  repeated bytes    repeated_x_bytes    = 316;
+  repeated Message  repeated_x_Message  = 317;
+  repeated group RepeatedGroup = 318 {
+    repeated string repeated_x_group = 319;
+  }
+}
+
+// An extension of an extension.
+message Extendable {
+  extensions 1 to max;
+}
+extend goproto.protoc.extension.base.BaseMessage {
+  optional Extendable extendable_field = 400;
+}
+extend Extendable {
+  optional string extendable_string_field = 1;
+}
+
+// Message set wire format.
+message MessageSetWireFormatExtension {
+  extend goproto.protoc.extension.base.MessageSetWireFormatMessage {
+    optional MessageSetWireFormatExtension message_set_extension = 100;
+  }
+}
+
+// Message set extension, not nested in a message.
+extend goproto.protoc.extension.base.MessageSetWireFormatMessage {
+  optional MessageSetWireFormatExtension message_set_extension = 101;
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/extensions/extra/extra.pb.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/extensions/extra/extra.pb.go
new file mode 100644
index 000000000..c056c4b40
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/extensions/extra/extra.pb.go
@@ -0,0 +1,143 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: cmd/protoc-gen-go/testdata/extensions/extra/extra.proto
+
+package extra
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type ExtraMessage struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Data []byte `protobuf:"bytes,1,opt,name=data" json:"data,omitempty"`
+}
+
+func (x *ExtraMessage) Reset() {
+	*x = ExtraMessage{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_extensions_extra_extra_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *ExtraMessage) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ExtraMessage) ProtoMessage() {}
+
+func (x *ExtraMessage) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_extensions_extra_extra_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ExtraMessage.ProtoReflect.Descriptor instead.
+func (*ExtraMessage) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_extensions_extra_extra_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *ExtraMessage) GetData() []byte {
+	if x != nil {
+		return x.Data
+	}
+	return nil
+}
+
+var File_cmd_protoc_gen_go_testdata_extensions_extra_extra_proto protoreflect.FileDescriptor
+
+var file_cmd_protoc_gen_go_testdata_extensions_extra_extra_proto_rawDesc = []byte{
+	0x0a, 0x37, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x65, 0x78, 0x74,
+	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x65, 0x78, 0x74, 0x72, 0x61, 0x2f, 0x65, 0x78,
+	0x74, 0x72, 0x61, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1e, 0x67, 0x6f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73,
+	0x69, 0x6f, 0x6e, 0x2e, 0x65, 0x78, 0x74, 0x72, 0x61, 0x22, 0x22, 0x0a, 0x0c, 0x45, 0x78, 0x74,
+	0x72, 0x61, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74,
+	0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x42, 0x48, 0x5a,
+	0x46, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f,
+	0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x63, 0x6d, 0x64, 0x2f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65,
+	0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
+	0x73, 0x2f, 0x65, 0x78, 0x74, 0x72, 0x61,
+}
+
+var (
+	file_cmd_protoc_gen_go_testdata_extensions_extra_extra_proto_rawDescOnce sync.Once
+	file_cmd_protoc_gen_go_testdata_extensions_extra_extra_proto_rawDescData = file_cmd_protoc_gen_go_testdata_extensions_extra_extra_proto_rawDesc
+)
+
+func file_cmd_protoc_gen_go_testdata_extensions_extra_extra_proto_rawDescGZIP() []byte {
+	file_cmd_protoc_gen_go_testdata_extensions_extra_extra_proto_rawDescOnce.Do(func() {
+		file_cmd_protoc_gen_go_testdata_extensions_extra_extra_proto_rawDescData = protoimpl.X.CompressGZIP(file_cmd_protoc_gen_go_testdata_extensions_extra_extra_proto_rawDescData)
+	})
+	return file_cmd_protoc_gen_go_testdata_extensions_extra_extra_proto_rawDescData
+}
+
+var file_cmd_protoc_gen_go_testdata_extensions_extra_extra_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_cmd_protoc_gen_go_testdata_extensions_extra_extra_proto_goTypes = []interface{}{
+	(*ExtraMessage)(nil), // 0: goproto.protoc.extension.extra.ExtraMessage
+}
+var file_cmd_protoc_gen_go_testdata_extensions_extra_extra_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_cmd_protoc_gen_go_testdata_extensions_extra_extra_proto_init() }
+func file_cmd_protoc_gen_go_testdata_extensions_extra_extra_proto_init() {
+	if File_cmd_protoc_gen_go_testdata_extensions_extra_extra_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_cmd_protoc_gen_go_testdata_extensions_extra_extra_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ExtraMessage); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cmd_protoc_gen_go_testdata_extensions_extra_extra_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_cmd_protoc_gen_go_testdata_extensions_extra_extra_proto_goTypes,
+		DependencyIndexes: file_cmd_protoc_gen_go_testdata_extensions_extra_extra_proto_depIdxs,
+		MessageInfos:      file_cmd_protoc_gen_go_testdata_extensions_extra_extra_proto_msgTypes,
+	}.Build()
+	File_cmd_protoc_gen_go_testdata_extensions_extra_extra_proto = out.File
+	file_cmd_protoc_gen_go_testdata_extensions_extra_extra_proto_rawDesc = nil
+	file_cmd_protoc_gen_go_testdata_extensions_extra_extra_proto_goTypes = nil
+	file_cmd_protoc_gen_go_testdata_extensions_extra_extra_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/extensions/extra/extra.proto b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/extensions/extra/extra.proto
new file mode 100644
index 000000000..eeea42384
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/extensions/extra/extra.proto
@@ -0,0 +1,13 @@
+// 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.
+
+syntax = "proto2";
+
+package goproto.protoc.extension.extra;
+
+option go_package = "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/extensions/extra";
+
+message ExtraMessage {
+  optional bytes data = 1;
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/extensions/proto3/ext3.pb.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/extensions/proto3/ext3.pb.go
new file mode 100644
index 000000000..586f7c8a9
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/extensions/proto3/ext3.pb.go
@@ -0,0 +1,762 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto
+
+package proto3
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	descriptorpb "google.golang.org/protobuf/types/descriptorpb"
+	reflect "reflect"
+	sync "sync"
+)
+
+type Enum int32
+
+const (
+	Enum_ZERO Enum = 0
+)
+
+// Enum value maps for Enum.
+var (
+	Enum_name = map[int32]string{
+		0: "ZERO",
+	}
+	Enum_value = map[string]int32{
+		"ZERO": 0,
+	}
+)
+
+func (x Enum) Enum() *Enum {
+	p := new(Enum)
+	*p = x
+	return p
+}
+
+func (x Enum) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum) Descriptor() protoreflect.EnumDescriptor {
+	return file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_enumTypes[0].Descriptor()
+}
+
+func (Enum) Type() protoreflect.EnumType {
+	return &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_enumTypes[0]
+}
+
+func (x Enum) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use Enum.Descriptor instead.
+func (Enum) EnumDescriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_rawDescGZIP(), []int{0}
+}
+
+type Message struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message) Reset() {
+	*x = Message{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message) ProtoMessage() {}
+
+func (x *Message) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message.ProtoReflect.Descriptor instead.
+func (*Message) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_rawDescGZIP(), []int{0}
+}
+
+var file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes = []protoimpl.ExtensionInfo{
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*bool)(nil),
+		Field:         1001,
+		Name:          "goproto.protoc.extension.proto3.extension_bool",
+		Tag:           "varint,1001,opt,name=extension_bool",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*Enum)(nil),
+		Field:         1002,
+		Name:          "goproto.protoc.extension.proto3.extension_enum",
+		Tag:           "varint,1002,opt,name=extension_enum,enum=goproto.protoc.extension.proto3.Enum",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*int32)(nil),
+		Field:         1003,
+		Name:          "goproto.protoc.extension.proto3.extension_int32",
+		Tag:           "varint,1003,opt,name=extension_int32",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*int32)(nil),
+		Field:         1004,
+		Name:          "goproto.protoc.extension.proto3.extension_sint32",
+		Tag:           "zigzag32,1004,opt,name=extension_sint32",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*uint32)(nil),
+		Field:         1005,
+		Name:          "goproto.protoc.extension.proto3.extension_uint32",
+		Tag:           "varint,1005,opt,name=extension_uint32",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*int64)(nil),
+		Field:         1006,
+		Name:          "goproto.protoc.extension.proto3.extension_int64",
+		Tag:           "varint,1006,opt,name=extension_int64",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*int64)(nil),
+		Field:         1007,
+		Name:          "goproto.protoc.extension.proto3.extension_sint64",
+		Tag:           "zigzag64,1007,opt,name=extension_sint64",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*uint64)(nil),
+		Field:         1008,
+		Name:          "goproto.protoc.extension.proto3.extension_uint64",
+		Tag:           "varint,1008,opt,name=extension_uint64",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*int32)(nil),
+		Field:         1009,
+		Name:          "goproto.protoc.extension.proto3.extension_sfixed32",
+		Tag:           "fixed32,1009,opt,name=extension_sfixed32",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*uint32)(nil),
+		Field:         1010,
+		Name:          "goproto.protoc.extension.proto3.extension_fixed32",
+		Tag:           "fixed32,1010,opt,name=extension_fixed32",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*float32)(nil),
+		Field:         1011,
+		Name:          "goproto.protoc.extension.proto3.extension_float",
+		Tag:           "fixed32,1011,opt,name=extension_float",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*int64)(nil),
+		Field:         1012,
+		Name:          "goproto.protoc.extension.proto3.extension_sfixed64",
+		Tag:           "fixed64,1012,opt,name=extension_sfixed64",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*uint64)(nil),
+		Field:         1013,
+		Name:          "goproto.protoc.extension.proto3.extension_fixed64",
+		Tag:           "fixed64,1013,opt,name=extension_fixed64",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*float64)(nil),
+		Field:         1014,
+		Name:          "goproto.protoc.extension.proto3.extension_double",
+		Tag:           "fixed64,1014,opt,name=extension_double",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*string)(nil),
+		Field:         1015,
+		Name:          "goproto.protoc.extension.proto3.extension_string",
+		Tag:           "bytes,1015,opt,name=extension_string",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: ([]byte)(nil),
+		Field:         1016,
+		Name:          "goproto.protoc.extension.proto3.extension_bytes",
+		Tag:           "bytes,1016,opt,name=extension_bytes",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*Message)(nil),
+		Field:         1017,
+		Name:          "goproto.protoc.extension.proto3.extension_Message",
+		Tag:           "bytes,1017,opt,name=extension_Message",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: ([]bool)(nil),
+		Field:         2001,
+		Name:          "goproto.protoc.extension.proto3.repeated_extension_bool",
+		Tag:           "varint,2001,rep,name=repeated_extension_bool",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: ([]Enum)(nil),
+		Field:         2002,
+		Name:          "goproto.protoc.extension.proto3.repeated_extension_enum",
+		Tag:           "varint,2002,rep,name=repeated_extension_enum,enum=goproto.protoc.extension.proto3.Enum",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: ([]int32)(nil),
+		Field:         2003,
+		Name:          "goproto.protoc.extension.proto3.repeated_extension_int32",
+		Tag:           "varint,2003,rep,name=repeated_extension_int32",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: ([]int32)(nil),
+		Field:         2004,
+		Name:          "goproto.protoc.extension.proto3.repeated_extension_sint32",
+		Tag:           "zigzag32,2004,rep,name=repeated_extension_sint32",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: ([]uint32)(nil),
+		Field:         2005,
+		Name:          "goproto.protoc.extension.proto3.repeated_extension_uint32",
+		Tag:           "varint,2005,rep,name=repeated_extension_uint32",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: ([]int64)(nil),
+		Field:         2006,
+		Name:          "goproto.protoc.extension.proto3.repeated_extension_int64",
+		Tag:           "varint,2006,rep,name=repeated_extension_int64",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: ([]int64)(nil),
+		Field:         2007,
+		Name:          "goproto.protoc.extension.proto3.repeated_extension_sint64",
+		Tag:           "zigzag64,2007,rep,name=repeated_extension_sint64",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: ([]uint64)(nil),
+		Field:         2008,
+		Name:          "goproto.protoc.extension.proto3.repeated_extension_uint64",
+		Tag:           "varint,2008,rep,name=repeated_extension_uint64",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: ([]int32)(nil),
+		Field:         2009,
+		Name:          "goproto.protoc.extension.proto3.repeated_extension_sfixed32",
+		Tag:           "fixed32,2009,rep,name=repeated_extension_sfixed32",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: ([]uint32)(nil),
+		Field:         2010,
+		Name:          "goproto.protoc.extension.proto3.repeated_extension_fixed32",
+		Tag:           "fixed32,2010,rep,name=repeated_extension_fixed32",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: ([]float32)(nil),
+		Field:         2011,
+		Name:          "goproto.protoc.extension.proto3.repeated_extension_float",
+		Tag:           "fixed32,2011,rep,name=repeated_extension_float",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: ([]int64)(nil),
+		Field:         2012,
+		Name:          "goproto.protoc.extension.proto3.repeated_extension_sfixed64",
+		Tag:           "fixed64,2012,rep,name=repeated_extension_sfixed64",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: ([]uint64)(nil),
+		Field:         2013,
+		Name:          "goproto.protoc.extension.proto3.repeated_extension_fixed64",
+		Tag:           "fixed64,2013,rep,name=repeated_extension_fixed64",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: ([]float64)(nil),
+		Field:         2014,
+		Name:          "goproto.protoc.extension.proto3.repeated_extension_double",
+		Tag:           "fixed64,2014,rep,name=repeated_extension_double",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: ([]string)(nil),
+		Field:         2015,
+		Name:          "goproto.protoc.extension.proto3.repeated_extension_string",
+		Tag:           "bytes,2015,rep,name=repeated_extension_string",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: ([][]byte)(nil),
+		Field:         2016,
+		Name:          "goproto.protoc.extension.proto3.repeated_extension_bytes",
+		Tag:           "bytes,2016,rep,name=repeated_extension_bytes",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: ([]*Message)(nil),
+		Field:         2017,
+		Name:          "goproto.protoc.extension.proto3.repeated_extension_Message",
+		Tag:           "bytes,2017,rep,name=repeated_extension_Message",
+		Filename:      "cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto",
+	},
+}
+
+// Extension fields to descriptorpb.MessageOptions.
+var (
+	// optional bool extension_bool = 1001;
+	E_ExtensionBool = &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes[0]
+	// optional goproto.protoc.extension.proto3.Enum extension_enum = 1002;
+	E_ExtensionEnum = &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes[1]
+	// optional int32 extension_int32 = 1003;
+	E_ExtensionInt32 = &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes[2]
+	// optional sint32 extension_sint32 = 1004;
+	E_ExtensionSint32 = &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes[3]
+	// optional uint32 extension_uint32 = 1005;
+	E_ExtensionUint32 = &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes[4]
+	// optional int64 extension_int64 = 1006;
+	E_ExtensionInt64 = &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes[5]
+	// optional sint64 extension_sint64 = 1007;
+	E_ExtensionSint64 = &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes[6]
+	// optional uint64 extension_uint64 = 1008;
+	E_ExtensionUint64 = &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes[7]
+	// optional sfixed32 extension_sfixed32 = 1009;
+	E_ExtensionSfixed32 = &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes[8]
+	// optional fixed32 extension_fixed32 = 1010;
+	E_ExtensionFixed32 = &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes[9]
+	// optional float extension_float = 1011;
+	E_ExtensionFloat = &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes[10]
+	// optional sfixed64 extension_sfixed64 = 1012;
+	E_ExtensionSfixed64 = &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes[11]
+	// optional fixed64 extension_fixed64 = 1013;
+	E_ExtensionFixed64 = &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes[12]
+	// optional double extension_double = 1014;
+	E_ExtensionDouble = &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes[13]
+	// optional string extension_string = 1015;
+	E_ExtensionString = &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes[14]
+	// optional bytes extension_bytes = 1016;
+	E_ExtensionBytes = &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes[15]
+	// optional goproto.protoc.extension.proto3.Message extension_Message = 1017;
+	E_Extension_Message = &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes[16]
+	// repeated bool repeated_extension_bool = 2001;
+	E_RepeatedExtensionBool = &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes[17]
+	// repeated goproto.protoc.extension.proto3.Enum repeated_extension_enum = 2002;
+	E_RepeatedExtensionEnum = &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes[18]
+	// repeated int32 repeated_extension_int32 = 2003;
+	E_RepeatedExtensionInt32 = &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes[19]
+	// repeated sint32 repeated_extension_sint32 = 2004;
+	E_RepeatedExtensionSint32 = &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes[20]
+	// repeated uint32 repeated_extension_uint32 = 2005;
+	E_RepeatedExtensionUint32 = &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes[21]
+	// repeated int64 repeated_extension_int64 = 2006;
+	E_RepeatedExtensionInt64 = &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes[22]
+	// repeated sint64 repeated_extension_sint64 = 2007;
+	E_RepeatedExtensionSint64 = &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes[23]
+	// repeated uint64 repeated_extension_uint64 = 2008;
+	E_RepeatedExtensionUint64 = &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes[24]
+	// repeated sfixed32 repeated_extension_sfixed32 = 2009;
+	E_RepeatedExtensionSfixed32 = &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes[25]
+	// repeated fixed32 repeated_extension_fixed32 = 2010;
+	E_RepeatedExtensionFixed32 = &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes[26]
+	// repeated float repeated_extension_float = 2011;
+	E_RepeatedExtensionFloat = &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes[27]
+	// repeated sfixed64 repeated_extension_sfixed64 = 2012;
+	E_RepeatedExtensionSfixed64 = &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes[28]
+	// repeated fixed64 repeated_extension_fixed64 = 2013;
+	E_RepeatedExtensionFixed64 = &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes[29]
+	// repeated double repeated_extension_double = 2014;
+	E_RepeatedExtensionDouble = &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes[30]
+	// repeated string repeated_extension_string = 2015;
+	E_RepeatedExtensionString = &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes[31]
+	// repeated bytes repeated_extension_bytes = 2016;
+	E_RepeatedExtensionBytes = &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes[32]
+	// repeated goproto.protoc.extension.proto3.Message repeated_extension_Message = 2017;
+	E_RepeatedExtension_Message = &file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes[33]
+)
+
+var File_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto protoreflect.FileDescriptor
+
+var file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_rawDesc = []byte{
+	0x0a, 0x37, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x65, 0x78, 0x74,
+	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2f, 0x65,
+	0x78, 0x74, 0x33, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1f, 0x67, 0x6f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73,
+	0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x1a, 0x20, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x65, 0x73, 0x63,
+	0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x09, 0x0a, 0x07,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2a, 0x10, 0x0a, 0x04, 0x45, 0x6e, 0x75, 0x6d, 0x12,
+	0x08, 0x0a, 0x04, 0x5a, 0x45, 0x52, 0x4f, 0x10, 0x00, 0x3a, 0x47, 0x0a, 0x0e, 0x65, 0x78, 0x74,
+	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x12, 0x1f, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xe9, 0x07, 0x20,
+	0x01, 0x28, 0x08, 0x52, 0x0d, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x42, 0x6f,
+	0x6f, 0x6c, 0x3a, 0x6e, 0x0a, 0x0e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f,
+	0x65, 0x6e, 0x75, 0x6d, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70,
+	0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xea, 0x07, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x67,
+	0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78,
+	0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x45,
+	0x6e, 0x75, 0x6d, 0x52, 0x0d, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x45, 0x6e,
+	0x75, 0x6d, 0x3a, 0x49, 0x0a, 0x0f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f,
+	0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xeb, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, 0x65,
+	0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x3a, 0x4b, 0x0a,
+	0x10, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x33,
+	0x32, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x73, 0x18, 0xec, 0x07, 0x20, 0x01, 0x28, 0x11, 0x52, 0x0f, 0x65, 0x78, 0x74, 0x65, 0x6e,
+	0x73, 0x69, 0x6f, 0x6e, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x3a, 0x4b, 0x0a, 0x10, 0x65, 0x78,
+	0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x1f,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18,
+	0xed, 0x07, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f,
+	0x6e, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x3a, 0x49, 0x0a, 0x0f, 0x65, 0x78, 0x74, 0x65, 0x6e,
+	0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xee, 0x07, 0x20, 0x01,
+	0x28, 0x03, 0x52, 0x0e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x74,
+	0x36, 0x34, 0x3a, 0x4b, 0x0a, 0x10, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f,
+	0x73, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xef, 0x07, 0x20, 0x01, 0x28, 0x12, 0x52, 0x0f,
+	0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x3a,
+	0x4b, 0x0a, 0x10, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x75, 0x69, 0x6e,
+	0x74, 0x36, 0x34, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x73, 0x18, 0xf0, 0x07, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0f, 0x65, 0x78, 0x74,
+	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x3a, 0x4f, 0x0a, 0x12,
+	0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64,
+	0x33, 0x32, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x73, 0x18, 0xf1, 0x07, 0x20, 0x01, 0x28, 0x0f, 0x52, 0x11, 0x65, 0x78, 0x74, 0x65,
+	0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x3a, 0x4d, 0x0a,
+	0x11, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64,
+	0x33, 0x32, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x73, 0x18, 0xf2, 0x07, 0x20, 0x01, 0x28, 0x07, 0x52, 0x10, 0x65, 0x78, 0x74, 0x65,
+	0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x3a, 0x49, 0x0a, 0x0f,
+	0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x12,
+	0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73,
+	0x18, 0xf3, 0x07, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69,
+	0x6f, 0x6e, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x3a, 0x4f, 0x0a, 0x12, 0x65, 0x78, 0x74, 0x65, 0x6e,
+	0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x1f, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xf4,
+	0x07, 0x20, 0x01, 0x28, 0x10, 0x52, 0x11, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
+	0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x3a, 0x4d, 0x0a, 0x11, 0x65, 0x78, 0x74, 0x65,
+	0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x1f, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xf5,
+	0x07, 0x20, 0x01, 0x28, 0x06, 0x52, 0x10, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
+	0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x3a, 0x4b, 0x0a, 0x10, 0x65, 0x78, 0x74, 0x65, 0x6e,
+	0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x1f, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xf6, 0x07, 0x20,
+	0x01, 0x28, 0x01, 0x52, 0x0f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x44, 0x6f,
+	0x75, 0x62, 0x6c, 0x65, 0x3a, 0x4b, 0x0a, 0x10, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f,
+	0x6e, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xf7, 0x07, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x72, 0x69, 0x6e,
+	0x67, 0x3a, 0x49, 0x0a, 0x0f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x62,
+	0x79, 0x74, 0x65, 0x73, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70,
+	0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xf8, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0e, 0x65, 0x78,
+	0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x42, 0x79, 0x74, 0x65, 0x73, 0x3a, 0x77, 0x0a, 0x11,
+	0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x73, 0x18, 0xf9, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x67, 0x6f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e,
+	0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x52, 0x10, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x3a, 0x58, 0x0a, 0x17, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65,
+	0x64, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x62, 0x6f, 0x6f, 0x6c,
+	0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
+	0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+	0x73, 0x18, 0xd1, 0x0f, 0x20, 0x03, 0x28, 0x08, 0x52, 0x15, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74,
+	0x65, 0x64, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x42, 0x6f, 0x6f, 0x6c, 0x3a,
+	0x7f, 0x0a, 0x17, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x78, 0x74, 0x65,
+	0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xd2, 0x0f, 0x20, 0x03,
+	0x28, 0x0e, 0x32, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x63, 0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x15, 0x72, 0x65, 0x70, 0x65, 0x61,
+	0x74, 0x65, 0x64, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x45, 0x6e, 0x75, 0x6d,
+	0x3a, 0x5a, 0x0a, 0x18, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x78, 0x74,
+	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x1f, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xd3, 0x0f,
+	0x20, 0x03, 0x28, 0x05, 0x52, 0x16, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x45, 0x78,
+	0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x3a, 0x5c, 0x0a, 0x19,
+	0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69,
+	0x6f, 0x6e, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xd4, 0x0f, 0x20, 0x03, 0x28,
+	0x11, 0x52, 0x17, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x45, 0x78, 0x74, 0x65, 0x6e,
+	0x73, 0x69, 0x6f, 0x6e, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x3a, 0x5c, 0x0a, 0x19, 0x72, 0x65,
+	0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
+	0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xd5, 0x0f, 0x20, 0x03, 0x28, 0x0d, 0x52,
+	0x17, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69,
+	0x6f, 0x6e, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x3a, 0x5a, 0x0a, 0x18, 0x72, 0x65, 0x70, 0x65,
+	0x61, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69,
+	0x6e, 0x74, 0x36, 0x34, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70,
+	0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xd6, 0x0f, 0x20, 0x03, 0x28, 0x03, 0x52, 0x16, 0x72, 0x65,
+	0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x49,
+	0x6e, 0x74, 0x36, 0x34, 0x3a, 0x5c, 0x0a, 0x19, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
+	0x5f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x36,
+	0x34, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x73, 0x18, 0xd7, 0x0f, 0x20, 0x03, 0x28, 0x12, 0x52, 0x17, 0x72, 0x65, 0x70, 0x65, 0x61,
+	0x74, 0x65, 0x64, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x53, 0x69, 0x6e, 0x74,
+	0x36, 0x34, 0x3a, 0x5c, 0x0a, 0x19, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x65,
+	0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12,
+	0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73,
+	0x18, 0xd8, 0x0f, 0x20, 0x03, 0x28, 0x04, 0x52, 0x17, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65,
+	0x64, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34,
+	0x3a, 0x60, 0x0a, 0x1b, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x78, 0x74,
+	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12,
+	0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73,
+	0x18, 0xd9, 0x0f, 0x20, 0x03, 0x28, 0x0f, 0x52, 0x19, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65,
+	0x64, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64,
+	0x33, 0x32, 0x3a, 0x5e, 0x0a, 0x1a, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x65,
+	0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32,
+	0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
+	0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+	0x73, 0x18, 0xda, 0x0f, 0x20, 0x03, 0x28, 0x07, 0x52, 0x18, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74,
+	0x65, 0x64, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x46, 0x69, 0x78, 0x65, 0x64,
+	0x33, 0x32, 0x3a, 0x5a, 0x0a, 0x18, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x65,
+	0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x1f,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18,
+	0xdb, 0x0f, 0x20, 0x03, 0x28, 0x02, 0x52, 0x16, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
+	0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x3a, 0x60,
+	0x0a, 0x1b, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x6e,
+	0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x1f, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xdc,
+	0x0f, 0x20, 0x03, 0x28, 0x10, 0x52, 0x19, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x45,
+	0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34,
+	0x3a, 0x5e, 0x0a, 0x1a, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x78, 0x74,
+	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x1f,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18,
+	0xdd, 0x0f, 0x20, 0x03, 0x28, 0x06, 0x52, 0x18, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
+	0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34,
+	0x3a, 0x5c, 0x0a, 0x19, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x78, 0x74,
+	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x1f, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xde,
+	0x0f, 0x20, 0x03, 0x28, 0x01, 0x52, 0x17, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x45,
+	0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x3a, 0x5c,
+	0x0a, 0x19, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x6e,
+	0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x1f, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xdf, 0x0f, 0x20,
+	0x03, 0x28, 0x09, 0x52, 0x17, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x45, 0x78, 0x74,
+	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3a, 0x5a, 0x0a, 0x18,
+	0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69,
+	0x6f, 0x6e, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xe0, 0x0f, 0x20, 0x03, 0x28, 0x0c,
+	0x52, 0x16, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73,
+	0x69, 0x6f, 0x6e, 0x42, 0x79, 0x74, 0x65, 0x73, 0x3a, 0x88, 0x01, 0x0a, 0x1a, 0x72, 0x65, 0x70,
+	0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xe1, 0x0f, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x28, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63,
+	0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x18, 0x72, 0x65, 0x70, 0x65, 0x61,
+	0x74, 0x65, 0x64, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x42, 0x49, 0x5a, 0x47, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f,
+	0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x2f, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x65, 0x78, 0x74,
+	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x62, 0x06,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_rawDescOnce sync.Once
+	file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_rawDescData = file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_rawDesc
+)
+
+func file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_rawDescGZIP() []byte {
+	file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_rawDescOnce.Do(func() {
+		file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_rawDescData = protoimpl.X.CompressGZIP(file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_rawDescData)
+	})
+	return file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_rawDescData
+}
+
+var file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
+var file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_goTypes = []interface{}{
+	(Enum)(0),                           // 0: goproto.protoc.extension.proto3.Enum
+	(*Message)(nil),                     // 1: goproto.protoc.extension.proto3.Message
+	(*descriptorpb.MessageOptions)(nil), // 2: google.protobuf.MessageOptions
+}
+var file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_depIdxs = []int32{
+	2,  // 0: goproto.protoc.extension.proto3.extension_bool:extendee -> google.protobuf.MessageOptions
+	2,  // 1: goproto.protoc.extension.proto3.extension_enum:extendee -> google.protobuf.MessageOptions
+	2,  // 2: goproto.protoc.extension.proto3.extension_int32:extendee -> google.protobuf.MessageOptions
+	2,  // 3: goproto.protoc.extension.proto3.extension_sint32:extendee -> google.protobuf.MessageOptions
+	2,  // 4: goproto.protoc.extension.proto3.extension_uint32:extendee -> google.protobuf.MessageOptions
+	2,  // 5: goproto.protoc.extension.proto3.extension_int64:extendee -> google.protobuf.MessageOptions
+	2,  // 6: goproto.protoc.extension.proto3.extension_sint64:extendee -> google.protobuf.MessageOptions
+	2,  // 7: goproto.protoc.extension.proto3.extension_uint64:extendee -> google.protobuf.MessageOptions
+	2,  // 8: goproto.protoc.extension.proto3.extension_sfixed32:extendee -> google.protobuf.MessageOptions
+	2,  // 9: goproto.protoc.extension.proto3.extension_fixed32:extendee -> google.protobuf.MessageOptions
+	2,  // 10: goproto.protoc.extension.proto3.extension_float:extendee -> google.protobuf.MessageOptions
+	2,  // 11: goproto.protoc.extension.proto3.extension_sfixed64:extendee -> google.protobuf.MessageOptions
+	2,  // 12: goproto.protoc.extension.proto3.extension_fixed64:extendee -> google.protobuf.MessageOptions
+	2,  // 13: goproto.protoc.extension.proto3.extension_double:extendee -> google.protobuf.MessageOptions
+	2,  // 14: goproto.protoc.extension.proto3.extension_string:extendee -> google.protobuf.MessageOptions
+	2,  // 15: goproto.protoc.extension.proto3.extension_bytes:extendee -> google.protobuf.MessageOptions
+	2,  // 16: goproto.protoc.extension.proto3.extension_Message:extendee -> google.protobuf.MessageOptions
+	2,  // 17: goproto.protoc.extension.proto3.repeated_extension_bool:extendee -> google.protobuf.MessageOptions
+	2,  // 18: goproto.protoc.extension.proto3.repeated_extension_enum:extendee -> google.protobuf.MessageOptions
+	2,  // 19: goproto.protoc.extension.proto3.repeated_extension_int32:extendee -> google.protobuf.MessageOptions
+	2,  // 20: goproto.protoc.extension.proto3.repeated_extension_sint32:extendee -> google.protobuf.MessageOptions
+	2,  // 21: goproto.protoc.extension.proto3.repeated_extension_uint32:extendee -> google.protobuf.MessageOptions
+	2,  // 22: goproto.protoc.extension.proto3.repeated_extension_int64:extendee -> google.protobuf.MessageOptions
+	2,  // 23: goproto.protoc.extension.proto3.repeated_extension_sint64:extendee -> google.protobuf.MessageOptions
+	2,  // 24: goproto.protoc.extension.proto3.repeated_extension_uint64:extendee -> google.protobuf.MessageOptions
+	2,  // 25: goproto.protoc.extension.proto3.repeated_extension_sfixed32:extendee -> google.protobuf.MessageOptions
+	2,  // 26: goproto.protoc.extension.proto3.repeated_extension_fixed32:extendee -> google.protobuf.MessageOptions
+	2,  // 27: goproto.protoc.extension.proto3.repeated_extension_float:extendee -> google.protobuf.MessageOptions
+	2,  // 28: goproto.protoc.extension.proto3.repeated_extension_sfixed64:extendee -> google.protobuf.MessageOptions
+	2,  // 29: goproto.protoc.extension.proto3.repeated_extension_fixed64:extendee -> google.protobuf.MessageOptions
+	2,  // 30: goproto.protoc.extension.proto3.repeated_extension_double:extendee -> google.protobuf.MessageOptions
+	2,  // 31: goproto.protoc.extension.proto3.repeated_extension_string:extendee -> google.protobuf.MessageOptions
+	2,  // 32: goproto.protoc.extension.proto3.repeated_extension_bytes:extendee -> google.protobuf.MessageOptions
+	2,  // 33: goproto.protoc.extension.proto3.repeated_extension_Message:extendee -> google.protobuf.MessageOptions
+	0,  // 34: goproto.protoc.extension.proto3.extension_enum:type_name -> goproto.protoc.extension.proto3.Enum
+	1,  // 35: goproto.protoc.extension.proto3.extension_Message:type_name -> goproto.protoc.extension.proto3.Message
+	0,  // 36: goproto.protoc.extension.proto3.repeated_extension_enum:type_name -> goproto.protoc.extension.proto3.Enum
+	1,  // 37: goproto.protoc.extension.proto3.repeated_extension_Message:type_name -> goproto.protoc.extension.proto3.Message
+	38, // [38:38] is the sub-list for method output_type
+	38, // [38:38] is the sub-list for method input_type
+	34, // [34:38] is the sub-list for extension type_name
+	0,  // [0:34] is the sub-list for extension extendee
+	0,  // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_init() }
+func file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_init() {
+	if File_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_rawDesc,
+			NumEnums:      1,
+			NumMessages:   1,
+			NumExtensions: 34,
+			NumServices:   0,
+		},
+		GoTypes:           file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_goTypes,
+		DependencyIndexes: file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_depIdxs,
+		EnumInfos:         file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_enumTypes,
+		MessageInfos:      file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_msgTypes,
+		ExtensionInfos:    file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_extTypes,
+	}.Build()
+	File_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto = out.File
+	file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_rawDesc = nil
+	file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_goTypes = nil
+	file_cmd_protoc_gen_go_testdata_extensions_proto3_ext3_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto
new file mode 100644
index 000000000..3d48c1fa6
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/extensions/proto3/ext3.proto
@@ -0,0 +1,53 @@
+// 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.
+
+syntax = "proto3";
+
+import "google/protobuf/descriptor.proto";
+
+package goproto.protoc.extension.proto3;
+
+option go_package = "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/extensions/proto3";
+
+message Message {}
+enum Enum { ZERO = 0; }
+
+// The only types proto3 is allowed to extend are descriptor options.
+extend google.protobuf.MessageOptions {
+  bool     extension_bool     = 1001;
+  Enum     extension_enum     = 1002;
+  int32    extension_int32    = 1003;
+  sint32   extension_sint32   = 1004;
+  uint32   extension_uint32   = 1005;
+  int64    extension_int64    = 1006;
+  sint64   extension_sint64   = 1007;
+  uint64   extension_uint64   = 1008;
+  sfixed32 extension_sfixed32 = 1009;
+  fixed32  extension_fixed32  = 1010;
+  float    extension_float    = 1011;
+  sfixed64 extension_sfixed64 = 1012;
+  fixed64  extension_fixed64  = 1013;
+  double   extension_double   = 1014;
+  string   extension_string   = 1015;
+  bytes    extension_bytes    = 1016;
+  Message  extension_Message  = 1017;
+
+  repeated bool     repeated_extension_bool     = 2001;
+  repeated Enum     repeated_extension_enum     = 2002;
+  repeated int32    repeated_extension_int32    = 2003;
+  repeated sint32   repeated_extension_sint32   = 2004;
+  repeated uint32   repeated_extension_uint32   = 2005;
+  repeated int64    repeated_extension_int64    = 2006;
+  repeated sint64   repeated_extension_sint64   = 2007;
+  repeated uint64   repeated_extension_uint64   = 2008;
+  repeated sfixed32 repeated_extension_sfixed32 = 2009;
+  repeated fixed32  repeated_extension_fixed32  = 2010;
+  repeated float    repeated_extension_float    = 2011;
+  repeated sfixed64 repeated_extension_sfixed64 = 2012;
+  repeated fixed64  repeated_extension_fixed64  = 2013;
+  repeated double   repeated_extension_double   = 2014;
+  repeated string   repeated_extension_string   = 2015;
+  repeated bytes    repeated_extension_bytes    = 2016;
+  repeated Message  repeated_extension_Message  = 2017;
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/fieldnames/fieldnames.pb.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/fieldnames/fieldnames.pb.go
new file mode 100644
index 000000000..ed3e0dbf7
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/fieldnames/fieldnames.pb.go
@@ -0,0 +1,455 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: cmd/protoc-gen-go/testdata/fieldnames/fieldnames.proto
+
+package fieldnames
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+// Assorted edge cases in field name conflict resolution.
+//
+// Not all (or possibly any) of these behave in an easily-understood fashion.
+// This exists to demonstrate the current behavior and catch unintended
+// changes in it.
+type Message struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// Various CamelCase conversions.
+	FieldOne   *string `protobuf:"bytes,1,opt,name=field_one,json=fieldOne" json:"field_one,omitempty"`
+	FieldTwo   *string `protobuf:"bytes,2,opt,name=FieldTwo" json:"FieldTwo,omitempty"`
+	FieldThree *string `protobuf:"bytes,3,opt,name=fieldThree" json:"fieldThree,omitempty"`
+	Field_Four *string `protobuf:"bytes,4,opt,name=field__four,json=fieldFour" json:"field__four,omitempty"`
+	// Field names that conflict with standard methods on the message struct.
+	Descriptor_   *string `protobuf:"bytes,10,opt,name=descriptor" json:"descriptor,omitempty"`
+	Marshal_      *string `protobuf:"bytes,11,opt,name=marshal" json:"marshal,omitempty"`
+	Unmarshal_    *string `protobuf:"bytes,12,opt,name=unmarshal" json:"unmarshal,omitempty"`
+	ProtoMessage_ *string `protobuf:"bytes,13,opt,name=proto_message,json=protoMessage" json:"proto_message,omitempty"`
+	// Field names that conflict with each other after CamelCasing.
+	CamelCase    *string `protobuf:"bytes,20,opt,name=CamelCase" json:"CamelCase,omitempty"`
+	CamelCase_   *string `protobuf:"bytes,21,opt,name=CamelCase_,json=CamelCase" json:"CamelCase_,omitempty"`
+	CamelCase__  *string `protobuf:"bytes,22,opt,name=camel_case,json=camelCase" json:"camel_case,omitempty"`   // conflicts with 20, 21
+	CamelCase___ *string `protobuf:"bytes,23,opt,name=CamelCase__,json=CamelCase" json:"CamelCase__,omitempty"` // conflicts with 21, 21, renamed 22
+	// Field with a getter that conflicts with another field.
+	GetName *string `protobuf:"bytes,30,opt,name=get_name,json=getName" json:"get_name,omitempty"`
+	Name_   *string `protobuf:"bytes,31,opt,name=name" json:"name,omitempty"`
+	// Oneof that conflicts with its first field: The oneof is renamed.
+	//
+	// Types that are assignable to OneofConflictA_:
+	//	*Message_OneofConflictA
+	OneofConflictA_ isMessage_OneofConflictA_ `protobuf_oneof:"oneof_conflict_a"`
+	// Oneof that conflicts with its second field: The field is renamed.
+	//
+	// Types that are assignable to OneofConflictB:
+	//	*Message_OneofNoConflict
+	//	*Message_OneofConflictB_
+	OneofConflictB isMessage_OneofConflictB `protobuf_oneof:"oneof_conflict_b"`
+	// Oneof with a field name that conflicts with a nested message.
+	//
+	// Types that are assignable to OneofConflictC:
+	//	*Message_OneofMessageConflict_
+	OneofConflictC isMessage_OneofConflictC `protobuf_oneof:"oneof_conflict_c"`
+}
+
+func (x *Message) Reset() {
+	*x = Message{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_fieldnames_fieldnames_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message) ProtoMessage() {}
+
+func (x *Message) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_fieldnames_fieldnames_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message.ProtoReflect.Descriptor instead.
+func (*Message) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_fieldnames_fieldnames_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Message) GetFieldOne() string {
+	if x != nil && x.FieldOne != nil {
+		return *x.FieldOne
+	}
+	return ""
+}
+
+func (x *Message) GetFieldTwo() string {
+	if x != nil && x.FieldTwo != nil {
+		return *x.FieldTwo
+	}
+	return ""
+}
+
+func (x *Message) GetFieldThree() string {
+	if x != nil && x.FieldThree != nil {
+		return *x.FieldThree
+	}
+	return ""
+}
+
+func (x *Message) GetField_Four() string {
+	if x != nil && x.Field_Four != nil {
+		return *x.Field_Four
+	}
+	return ""
+}
+
+func (x *Message) GetDescriptor_() string {
+	if x != nil && x.Descriptor_ != nil {
+		return *x.Descriptor_
+	}
+	return ""
+}
+
+func (x *Message) GetMarshal_() string {
+	if x != nil && x.Marshal_ != nil {
+		return *x.Marshal_
+	}
+	return ""
+}
+
+func (x *Message) GetUnmarshal_() string {
+	if x != nil && x.Unmarshal_ != nil {
+		return *x.Unmarshal_
+	}
+	return ""
+}
+
+func (x *Message) GetProtoMessage_() string {
+	if x != nil && x.ProtoMessage_ != nil {
+		return *x.ProtoMessage_
+	}
+	return ""
+}
+
+func (x *Message) GetCamelCase() string {
+	if x != nil && x.CamelCase != nil {
+		return *x.CamelCase
+	}
+	return ""
+}
+
+func (x *Message) GetCamelCase_() string {
+	if x != nil && x.CamelCase_ != nil {
+		return *x.CamelCase_
+	}
+	return ""
+}
+
+func (x *Message) GetCamelCase__() string {
+	if x != nil && x.CamelCase__ != nil {
+		return *x.CamelCase__
+	}
+	return ""
+}
+
+func (x *Message) GetCamelCase___() string {
+	if x != nil && x.CamelCase___ != nil {
+		return *x.CamelCase___
+	}
+	return ""
+}
+
+func (x *Message) GetGetName() string {
+	if x != nil && x.GetName != nil {
+		return *x.GetName
+	}
+	return ""
+}
+
+func (x *Message) GetName_() string {
+	if x != nil && x.Name_ != nil {
+		return *x.Name_
+	}
+	return ""
+}
+
+func (m *Message) GetOneofConflictA_() isMessage_OneofConflictA_ {
+	if m != nil {
+		return m.OneofConflictA_
+	}
+	return nil
+}
+
+func (x *Message) GetOneofConflictA() string {
+	if x, ok := x.GetOneofConflictA_().(*Message_OneofConflictA); ok {
+		return x.OneofConflictA
+	}
+	return ""
+}
+
+func (m *Message) GetOneofConflictB() isMessage_OneofConflictB {
+	if m != nil {
+		return m.OneofConflictB
+	}
+	return nil
+}
+
+func (x *Message) GetOneofNoConflict() string {
+	if x, ok := x.GetOneofConflictB().(*Message_OneofNoConflict); ok {
+		return x.OneofNoConflict
+	}
+	return ""
+}
+
+func (x *Message) GetOneofConflictB_() string {
+	if x, ok := x.GetOneofConflictB().(*Message_OneofConflictB_); ok {
+		return x.OneofConflictB_
+	}
+	return ""
+}
+
+func (m *Message) GetOneofConflictC() isMessage_OneofConflictC {
+	if m != nil {
+		return m.OneofConflictC
+	}
+	return nil
+}
+
+func (x *Message) GetOneofMessageConflict() string {
+	if x, ok := x.GetOneofConflictC().(*Message_OneofMessageConflict_); ok {
+		return x.OneofMessageConflict
+	}
+	return ""
+}
+
+type isMessage_OneofConflictA_ interface {
+	isMessage_OneofConflictA_()
+}
+
+type Message_OneofConflictA struct {
+	OneofConflictA string `protobuf:"bytes,40,opt,name=OneofConflictA,oneof"`
+}
+
+func (*Message_OneofConflictA) isMessage_OneofConflictA_() {}
+
+type isMessage_OneofConflictB interface {
+	isMessage_OneofConflictB()
+}
+
+type Message_OneofNoConflict struct {
+	OneofNoConflict string `protobuf:"bytes,50,opt,name=oneof_no_conflict,json=oneofNoConflict,oneof"`
+}
+
+type Message_OneofConflictB_ struct {
+	OneofConflictB_ string `protobuf:"bytes,51,opt,name=OneofConflictB,oneof"`
+}
+
+func (*Message_OneofNoConflict) isMessage_OneofConflictB() {}
+
+func (*Message_OneofConflictB_) isMessage_OneofConflictB() {}
+
+type isMessage_OneofConflictC interface {
+	isMessage_OneofConflictC()
+}
+
+type Message_OneofMessageConflict_ struct {
+	OneofMessageConflict string `protobuf:"bytes,60,opt,name=oneof_message_conflict,json=oneofMessageConflict,oneof"`
+}
+
+func (*Message_OneofMessageConflict_) isMessage_OneofConflictC() {}
+
+type Message_OneofMessageConflict struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message_OneofMessageConflict) Reset() {
+	*x = Message_OneofMessageConflict{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_fieldnames_fieldnames_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message_OneofMessageConflict) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message_OneofMessageConflict) ProtoMessage() {}
+
+func (x *Message_OneofMessageConflict) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_fieldnames_fieldnames_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message_OneofMessageConflict.ProtoReflect.Descriptor instead.
+func (*Message_OneofMessageConflict) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_fieldnames_fieldnames_proto_rawDescGZIP(), []int{0, 0}
+}
+
+var File_cmd_protoc_gen_go_testdata_fieldnames_fieldnames_proto protoreflect.FileDescriptor
+
+var file_cmd_protoc_gen_go_testdata_fieldnames_fieldnames_proto_rawDesc = []byte{
+	0x0a, 0x36, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x2f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x6e, 0x61, 0x6d,
+	0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x19, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x6e, 0x61,
+	0x6d, 0x65, 0x73, 0x22, 0xb8, 0x05, 0x0a, 0x07, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12,
+	0x1b, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x6f, 0x6e, 0x65, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x4f, 0x6e, 0x65, 0x12, 0x1a, 0x0a, 0x08,
+	0x46, 0x69, 0x65, 0x6c, 0x64, 0x54, 0x77, 0x6f, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08,
+	0x46, 0x69, 0x65, 0x6c, 0x64, 0x54, 0x77, 0x6f, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x54, 0x68, 0x72, 0x65, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x54, 0x68, 0x72, 0x65, 0x65, 0x12, 0x1e, 0x0a, 0x0b, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x5f, 0x5f, 0x66, 0x6f, 0x75, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x46, 0x6f, 0x75, 0x72, 0x12, 0x1e, 0x0a, 0x0a, 0x64, 0x65, 0x73, 0x63,
+	0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x64, 0x65,
+	0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x61, 0x72, 0x73,
+	0x68, 0x61, 0x6c, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x61, 0x72, 0x73, 0x68,
+	0x61, 0x6c, 0x12, 0x1c, 0x0a, 0x09, 0x75, 0x6e, 0x6d, 0x61, 0x72, 0x73, 0x68, 0x61, 0x6c, 0x18,
+	0x0c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x75, 0x6e, 0x6d, 0x61, 0x72, 0x73, 0x68, 0x61, 0x6c,
+	0x12, 0x23, 0x0a, 0x0d, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x43, 0x61, 0x6d, 0x65, 0x6c, 0x43, 0x61,
+	0x73, 0x65, 0x18, 0x14, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x43, 0x61, 0x6d, 0x65, 0x6c, 0x43,
+	0x61, 0x73, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x43, 0x61, 0x6d, 0x65, 0x6c, 0x43, 0x61, 0x73, 0x65,
+	0x5f, 0x18, 0x15, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x43, 0x61, 0x6d, 0x65, 0x6c, 0x43, 0x61,
+	0x73, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x61, 0x6d, 0x65, 0x6c, 0x5f, 0x63, 0x61, 0x73, 0x65,
+	0x18, 0x16, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x61, 0x6d, 0x65, 0x6c, 0x43, 0x61, 0x73,
+	0x65, 0x12, 0x1e, 0x0a, 0x0b, 0x43, 0x61, 0x6d, 0x65, 0x6c, 0x43, 0x61, 0x73, 0x65, 0x5f, 0x5f,
+	0x18, 0x17, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x43, 0x61, 0x6d, 0x65, 0x6c, 0x43, 0x61, 0x73,
+	0x65, 0x12, 0x19, 0x0a, 0x08, 0x67, 0x65, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x1e, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x07, 0x67, 0x65, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04,
+	0x6e, 0x61, 0x6d, 0x65, 0x18, 0x1f, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65,
+	0x12, 0x28, 0x0a, 0x0e, 0x4f, 0x6e, 0x65, 0x6f, 0x66, 0x43, 0x6f, 0x6e, 0x66, 0x6c, 0x69, 0x63,
+	0x74, 0x41, 0x18, 0x28, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0e, 0x4f, 0x6e, 0x65, 0x6f,
+	0x66, 0x43, 0x6f, 0x6e, 0x66, 0x6c, 0x69, 0x63, 0x74, 0x41, 0x12, 0x2c, 0x0a, 0x11, 0x6f, 0x6e,
+	0x65, 0x6f, 0x66, 0x5f, 0x6e, 0x6f, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x6c, 0x69, 0x63, 0x74, 0x18,
+	0x32, 0x20, 0x01, 0x28, 0x09, 0x48, 0x01, 0x52, 0x0f, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x4e, 0x6f,
+	0x43, 0x6f, 0x6e, 0x66, 0x6c, 0x69, 0x63, 0x74, 0x12, 0x28, 0x0a, 0x0e, 0x4f, 0x6e, 0x65, 0x6f,
+	0x66, 0x43, 0x6f, 0x6e, 0x66, 0x6c, 0x69, 0x63, 0x74, 0x42, 0x18, 0x33, 0x20, 0x01, 0x28, 0x09,
+	0x48, 0x01, 0x52, 0x0e, 0x4f, 0x6e, 0x65, 0x6f, 0x66, 0x43, 0x6f, 0x6e, 0x66, 0x6c, 0x69, 0x63,
+	0x74, 0x42, 0x12, 0x36, 0x0a, 0x16, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x6c, 0x69, 0x63, 0x74, 0x18, 0x3c, 0x20, 0x01,
+	0x28, 0x09, 0x48, 0x02, 0x52, 0x14, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x6c, 0x69, 0x63, 0x74, 0x1a, 0x16, 0x0a, 0x14, 0x4f, 0x6e,
+	0x65, 0x6f, 0x66, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x6c, 0x69,
+	0x63, 0x74, 0x42, 0x12, 0x0a, 0x10, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x63, 0x6f, 0x6e, 0x66,
+	0x6c, 0x69, 0x63, 0x74, 0x5f, 0x61, 0x42, 0x12, 0x0a, 0x10, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f,
+	0x63, 0x6f, 0x6e, 0x66, 0x6c, 0x69, 0x63, 0x74, 0x5f, 0x62, 0x42, 0x12, 0x0a, 0x10, 0x6f, 0x6e,
+	0x65, 0x6f, 0x66, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x6c, 0x69, 0x63, 0x74, 0x5f, 0x63, 0x42, 0x42,
+	0x5a, 0x40, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e,
+	0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x63, 0x6d, 0x64,
+	0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x74,
+	0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x6e, 0x61, 0x6d,
+	0x65, 0x73,
+}
+
+var (
+	file_cmd_protoc_gen_go_testdata_fieldnames_fieldnames_proto_rawDescOnce sync.Once
+	file_cmd_protoc_gen_go_testdata_fieldnames_fieldnames_proto_rawDescData = file_cmd_protoc_gen_go_testdata_fieldnames_fieldnames_proto_rawDesc
+)
+
+func file_cmd_protoc_gen_go_testdata_fieldnames_fieldnames_proto_rawDescGZIP() []byte {
+	file_cmd_protoc_gen_go_testdata_fieldnames_fieldnames_proto_rawDescOnce.Do(func() {
+		file_cmd_protoc_gen_go_testdata_fieldnames_fieldnames_proto_rawDescData = protoimpl.X.CompressGZIP(file_cmd_protoc_gen_go_testdata_fieldnames_fieldnames_proto_rawDescData)
+	})
+	return file_cmd_protoc_gen_go_testdata_fieldnames_fieldnames_proto_rawDescData
+}
+
+var file_cmd_protoc_gen_go_testdata_fieldnames_fieldnames_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
+var file_cmd_protoc_gen_go_testdata_fieldnames_fieldnames_proto_goTypes = []interface{}{
+	(*Message)(nil),                      // 0: goproto.protoc.fieldnames.Message
+	(*Message_OneofMessageConflict)(nil), // 1: goproto.protoc.fieldnames.Message.OneofMessageConflict
+}
+var file_cmd_protoc_gen_go_testdata_fieldnames_fieldnames_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_cmd_protoc_gen_go_testdata_fieldnames_fieldnames_proto_init() }
+func file_cmd_protoc_gen_go_testdata_fieldnames_fieldnames_proto_init() {
+	if File_cmd_protoc_gen_go_testdata_fieldnames_fieldnames_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_cmd_protoc_gen_go_testdata_fieldnames_fieldnames_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cmd_protoc_gen_go_testdata_fieldnames_fieldnames_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message_OneofMessageConflict); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	file_cmd_protoc_gen_go_testdata_fieldnames_fieldnames_proto_msgTypes[0].OneofWrappers = []interface{}{
+		(*Message_OneofConflictA)(nil),
+		(*Message_OneofNoConflict)(nil),
+		(*Message_OneofConflictB_)(nil),
+		(*Message_OneofMessageConflict_)(nil),
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cmd_protoc_gen_go_testdata_fieldnames_fieldnames_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   2,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_cmd_protoc_gen_go_testdata_fieldnames_fieldnames_proto_goTypes,
+		DependencyIndexes: file_cmd_protoc_gen_go_testdata_fieldnames_fieldnames_proto_depIdxs,
+		MessageInfos:      file_cmd_protoc_gen_go_testdata_fieldnames_fieldnames_proto_msgTypes,
+	}.Build()
+	File_cmd_protoc_gen_go_testdata_fieldnames_fieldnames_proto = out.File
+	file_cmd_protoc_gen_go_testdata_fieldnames_fieldnames_proto_rawDesc = nil
+	file_cmd_protoc_gen_go_testdata_fieldnames_fieldnames_proto_goTypes = nil
+	file_cmd_protoc_gen_go_testdata_fieldnames_fieldnames_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/fieldnames/fieldnames.proto b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/fieldnames/fieldnames.proto
new file mode 100644
index 000000000..00f6752ed
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/fieldnames/fieldnames.proto
@@ -0,0 +1,55 @@
+// 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.
+
+syntax = "proto2";
+
+package goproto.protoc.fieldnames;
+
+option go_package = "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/fieldnames";
+
+// Assorted edge cases in field name conflict resolution.
+//
+// Not all (or possibly any) of these behave in an easily-understood fashion.
+// This exists to demonstrate the current behavior and catch unintended
+// changes in it.
+message Message {
+  // Various CamelCase conversions.
+  optional string field_one = 1;
+  optional string FieldTwo = 2;
+  optional string fieldThree = 3;
+  optional string field__four = 4;
+
+  // Field names that conflict with standard methods on the message struct.
+  optional string descriptor = 10;
+  optional string marshal = 11;
+  optional string unmarshal = 12;
+  optional string proto_message = 13;
+
+  // Field names that conflict with each other after CamelCasing.
+  optional string CamelCase = 20;
+  optional string CamelCase_ = 21;
+  optional string camel_case = 22; // conflicts with 20, 21
+  optional string CamelCase__ = 23; // conflicts with 21, 21, renamed 22
+
+  // Field with a getter that conflicts with another field.
+  optional string get_name = 30;
+  optional string name = 31;
+
+  // Oneof that conflicts with its first field: The oneof is renamed.
+  oneof oneof_conflict_a {
+    string OneofConflictA = 40;
+  }
+
+  // Oneof that conflicts with its second field: The field is renamed.
+  oneof oneof_conflict_b {
+    string oneof_no_conflict = 50;
+    string OneofConflictB = 51;
+  }
+
+  // Oneof with a field name that conflicts with a nested message.
+  oneof oneof_conflict_c {
+    string oneof_message_conflict = 60;
+  }
+  message OneofMessageConflict {}
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/gen_test.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/gen_test.go
new file mode 100644
index 000000000..fa411566f
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/gen_test.go
@@ -0,0 +1,29 @@
+// Copyright 2019 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.
+
+// Code generated by generate-protos. DO NOT EDIT.
+
+package main
+
+import (
+	_ "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/annotations"
+	_ "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/comments"
+	_ "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/extensions/base"
+	_ "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/extensions/ext"
+	_ "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/extensions/extra"
+	_ "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/extensions/proto3"
+	_ "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/fieldnames"
+	_ "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public"
+	_ "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/sub"
+	_ "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/sub2"
+	_ "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports"
+	_ "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/fmt"
+	_ "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_a_1"
+	_ "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_a_2"
+	_ "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_b_1"
+	_ "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/issue780_oneof_conflict"
+	_ "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/nopackage"
+	_ "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto2"
+	_ "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto3"
+)
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/a.pb.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/a.pb.go
new file mode 100644
index 000000000..06e18d64b
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/a.pb.go
@@ -0,0 +1,219 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: cmd/protoc-gen-go/testdata/import_public/a.proto
+
+package import_public
+
+import (
+	sub "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/sub"
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+// Symbols defined in public import of cmd/protoc-gen-go/testdata/import_public/sub/a.proto.
+
+type E = sub.E
+
+const E_ZERO = sub.E_ZERO
+
+var E_name = sub.E_name
+var E_value = sub.E_value
+
+type M_Subenum = sub.M_Subenum
+
+const M_M_ZERO = sub.M_M_ZERO
+
+var M_Subenum_name = sub.M_Subenum_name
+var M_Subenum_value = sub.M_Subenum_value
+
+type M_Submessage_Submessage_Subenum = sub.M_Submessage_Submessage_Subenum
+
+const M_Submessage_M_SUBMESSAGE_ZERO = sub.M_Submessage_M_SUBMESSAGE_ZERO
+
+var M_Submessage_Submessage_Subenum_name = sub.M_Submessage_Submessage_Subenum_name
+var M_Submessage_Submessage_Subenum_value = sub.M_Submessage_Submessage_Subenum_value
+
+type M = sub.M
+
+const Default_M_S = sub.Default_M_S
+
+var Default_M_B = sub.Default_M_B
+var Default_M_F = sub.Default_M_F
+
+type M_OneofInt32 = sub.M_OneofInt32
+type M_OneofInt64 = sub.M_OneofInt64
+type M_Submessage = sub.M_Submessage
+type M_Submessage_SubmessageOneofInt32 = sub.M_Submessage_SubmessageOneofInt32
+type M_Submessage_SubmessageOneofInt64 = sub.M_Submessage_SubmessageOneofInt64
+
+var E_ExtensionField = sub.E_ExtensionField
+
+type Public struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	M     *sub.M `protobuf:"bytes,1,opt,name=m" json:"m,omitempty"`
+	E     *sub.E `protobuf:"varint,2,opt,name=e,enum=goproto.protoc.import_public.sub.E" json:"e,omitempty"`
+	Local *Local `protobuf:"bytes,3,opt,name=local" json:"local,omitempty"`
+}
+
+func (x *Public) Reset() {
+	*x = Public{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_import_public_a_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Public) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Public) ProtoMessage() {}
+
+func (x *Public) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_import_public_a_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Public.ProtoReflect.Descriptor instead.
+func (*Public) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_import_public_a_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Public) GetM() *sub.M {
+	if x != nil {
+		return x.M
+	}
+	return nil
+}
+
+func (x *Public) GetE() sub.E {
+	if x != nil && x.E != nil {
+		return *x.E
+	}
+	return sub.E_ZERO
+}
+
+func (x *Public) GetLocal() *Local {
+	if x != nil {
+		return x.Local
+	}
+	return nil
+}
+
+var File_cmd_protoc_gen_go_testdata_import_public_a_proto protoreflect.FileDescriptor
+
+var file_cmd_protoc_gen_go_testdata_import_public_a_proto_rawDesc = []byte{
+	0x0a, 0x30, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70,
+	0x6f, 0x72, 0x74, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x2f, 0x61, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x12, 0x1c, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x63, 0x2e, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63,
+	0x1a, 0x34, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70,
+	0x6f, 0x72, 0x74, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x2f, 0x73, 0x75, 0x62, 0x2f, 0x61,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x30, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61,
+	0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63,
+	0x2f, 0x62, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xa9, 0x01, 0x0a, 0x06, 0x50, 0x75, 0x62,
+	0x6c, 0x69, 0x63, 0x12, 0x31, 0x0a, 0x01, 0x6d, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23,
+	0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e,
+	0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x2e, 0x73, 0x75,
+	0x62, 0x2e, 0x4d, 0x52, 0x01, 0x6d, 0x12, 0x31, 0x0a, 0x01, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x0e, 0x32, 0x23, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x63, 0x2e, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63,
+	0x2e, 0x73, 0x75, 0x62, 0x2e, 0x45, 0x52, 0x01, 0x65, 0x12, 0x39, 0x0a, 0x05, 0x6c, 0x6f, 0x63,
+	0x61, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74,
+	0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x2e, 0x4c, 0x6f, 0x63, 0x61, 0x6c, 0x52, 0x05, 0x6c,
+	0x6f, 0x63, 0x61, 0x6c, 0x42, 0x45, 0x5a, 0x43, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67,
+	0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
+	0x75, 0x66, 0x2f, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65,
+	0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d,
+	0x70, 0x6f, 0x72, 0x74, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x50, 0x00, 0x50, 0x01,
+}
+
+var (
+	file_cmd_protoc_gen_go_testdata_import_public_a_proto_rawDescOnce sync.Once
+	file_cmd_protoc_gen_go_testdata_import_public_a_proto_rawDescData = file_cmd_protoc_gen_go_testdata_import_public_a_proto_rawDesc
+)
+
+func file_cmd_protoc_gen_go_testdata_import_public_a_proto_rawDescGZIP() []byte {
+	file_cmd_protoc_gen_go_testdata_import_public_a_proto_rawDescOnce.Do(func() {
+		file_cmd_protoc_gen_go_testdata_import_public_a_proto_rawDescData = protoimpl.X.CompressGZIP(file_cmd_protoc_gen_go_testdata_import_public_a_proto_rawDescData)
+	})
+	return file_cmd_protoc_gen_go_testdata_import_public_a_proto_rawDescData
+}
+
+var file_cmd_protoc_gen_go_testdata_import_public_a_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_cmd_protoc_gen_go_testdata_import_public_a_proto_goTypes = []interface{}{
+	(*Public)(nil), // 0: goproto.protoc.import_public.Public
+	(*sub.M)(nil),  // 1: goproto.protoc.import_public.sub.M
+	(sub.E)(0),     // 2: goproto.protoc.import_public.sub.E
+	(*Local)(nil),  // 3: goproto.protoc.import_public.Local
+}
+var file_cmd_protoc_gen_go_testdata_import_public_a_proto_depIdxs = []int32{
+	1, // 0: goproto.protoc.import_public.Public.m:type_name -> goproto.protoc.import_public.sub.M
+	2, // 1: goproto.protoc.import_public.Public.e:type_name -> goproto.protoc.import_public.sub.E
+	3, // 2: goproto.protoc.import_public.Public.local:type_name -> goproto.protoc.import_public.Local
+	3, // [3:3] is the sub-list for method output_type
+	3, // [3:3] is the sub-list for method input_type
+	3, // [3:3] is the sub-list for extension type_name
+	3, // [3:3] is the sub-list for extension extendee
+	0, // [0:3] is the sub-list for field type_name
+}
+
+func init() { file_cmd_protoc_gen_go_testdata_import_public_a_proto_init() }
+func file_cmd_protoc_gen_go_testdata_import_public_a_proto_init() {
+	if File_cmd_protoc_gen_go_testdata_import_public_a_proto != nil {
+		return
+	}
+	file_cmd_protoc_gen_go_testdata_import_public_b_proto_init()
+	if !protoimpl.UnsafeEnabled {
+		file_cmd_protoc_gen_go_testdata_import_public_a_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Public); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cmd_protoc_gen_go_testdata_import_public_a_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_cmd_protoc_gen_go_testdata_import_public_a_proto_goTypes,
+		DependencyIndexes: file_cmd_protoc_gen_go_testdata_import_public_a_proto_depIdxs,
+		MessageInfos:      file_cmd_protoc_gen_go_testdata_import_public_a_proto_msgTypes,
+	}.Build()
+	File_cmd_protoc_gen_go_testdata_import_public_a_proto = out.File
+	file_cmd_protoc_gen_go_testdata_import_public_a_proto_rawDesc = nil
+	file_cmd_protoc_gen_go_testdata_import_public_a_proto_goTypes = nil
+	file_cmd_protoc_gen_go_testdata_import_public_a_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/a.proto b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/a.proto
new file mode 100644
index 000000000..621012522
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/a.proto
@@ -0,0 +1,18 @@
+// 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.
+
+syntax = "proto2";
+
+package goproto.protoc.import_public;
+
+option go_package = "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public";
+
+import public "cmd/protoc-gen-go/testdata/import_public/sub/a.proto";  // Different Go package.
+import public "cmd/protoc-gen-go/testdata/import_public/b.proto";      // Same Go package.
+
+message Public {
+  optional goproto.protoc.import_public.sub.M m = 1;
+  optional goproto.protoc.import_public.sub.E e = 2;
+  optional Local local = 3;
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/b.pb.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/b.pb.go
new file mode 100644
index 000000000..5c7748072
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/b.pb.go
@@ -0,0 +1,163 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: cmd/protoc-gen-go/testdata/import_public/b.proto
+
+package import_public
+
+import (
+	sub "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/sub"
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type Local struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	M *sub.M `protobuf:"bytes,1,opt,name=m" json:"m,omitempty"`
+	E *sub.E `protobuf:"varint,2,opt,name=e,enum=goproto.protoc.import_public.sub.E" json:"e,omitempty"`
+}
+
+func (x *Local) Reset() {
+	*x = Local{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_import_public_b_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Local) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Local) ProtoMessage() {}
+
+func (x *Local) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_import_public_b_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Local.ProtoReflect.Descriptor instead.
+func (*Local) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_import_public_b_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Local) GetM() *sub.M {
+	if x != nil {
+		return x.M
+	}
+	return nil
+}
+
+func (x *Local) GetE() sub.E {
+	if x != nil && x.E != nil {
+		return *x.E
+	}
+	return sub.E_ZERO
+}
+
+var File_cmd_protoc_gen_go_testdata_import_public_b_proto protoreflect.FileDescriptor
+
+var file_cmd_protoc_gen_go_testdata_import_public_b_proto_rawDesc = []byte{
+	0x0a, 0x30, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70,
+	0x6f, 0x72, 0x74, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x2f, 0x62, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x12, 0x1c, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x63, 0x2e, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63,
+	0x1a, 0x34, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70,
+	0x6f, 0x72, 0x74, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x2f, 0x73, 0x75, 0x62, 0x2f, 0x61,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x6d, 0x0a, 0x05, 0x4c, 0x6f, 0x63, 0x61, 0x6c, 0x12,
+	0x31, 0x0a, 0x01, 0x6d, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x67, 0x6f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x69, 0x6d, 0x70, 0x6f,
+	0x72, 0x74, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x2e, 0x73, 0x75, 0x62, 0x2e, 0x4d, 0x52,
+	0x01, 0x6d, 0x12, 0x31, 0x0a, 0x01, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x23, 0x2e,
+	0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x69,
+	0x6d, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x2e, 0x73, 0x75, 0x62,
+	0x2e, 0x45, 0x52, 0x01, 0x65, 0x42, 0x45, 0x5a, 0x43, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
+	0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x62, 0x75, 0x66, 0x2f, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67,
+	0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x69,
+	0x6d, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63,
+}
+
+var (
+	file_cmd_protoc_gen_go_testdata_import_public_b_proto_rawDescOnce sync.Once
+	file_cmd_protoc_gen_go_testdata_import_public_b_proto_rawDescData = file_cmd_protoc_gen_go_testdata_import_public_b_proto_rawDesc
+)
+
+func file_cmd_protoc_gen_go_testdata_import_public_b_proto_rawDescGZIP() []byte {
+	file_cmd_protoc_gen_go_testdata_import_public_b_proto_rawDescOnce.Do(func() {
+		file_cmd_protoc_gen_go_testdata_import_public_b_proto_rawDescData = protoimpl.X.CompressGZIP(file_cmd_protoc_gen_go_testdata_import_public_b_proto_rawDescData)
+	})
+	return file_cmd_protoc_gen_go_testdata_import_public_b_proto_rawDescData
+}
+
+var file_cmd_protoc_gen_go_testdata_import_public_b_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_cmd_protoc_gen_go_testdata_import_public_b_proto_goTypes = []interface{}{
+	(*Local)(nil), // 0: goproto.protoc.import_public.Local
+	(*sub.M)(nil), // 1: goproto.protoc.import_public.sub.M
+	(sub.E)(0),    // 2: goproto.protoc.import_public.sub.E
+}
+var file_cmd_protoc_gen_go_testdata_import_public_b_proto_depIdxs = []int32{
+	1, // 0: goproto.protoc.import_public.Local.m:type_name -> goproto.protoc.import_public.sub.M
+	2, // 1: goproto.protoc.import_public.Local.e:type_name -> goproto.protoc.import_public.sub.E
+	2, // [2:2] is the sub-list for method output_type
+	2, // [2:2] is the sub-list for method input_type
+	2, // [2:2] is the sub-list for extension type_name
+	2, // [2:2] is the sub-list for extension extendee
+	0, // [0:2] is the sub-list for field type_name
+}
+
+func init() { file_cmd_protoc_gen_go_testdata_import_public_b_proto_init() }
+func file_cmd_protoc_gen_go_testdata_import_public_b_proto_init() {
+	if File_cmd_protoc_gen_go_testdata_import_public_b_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_cmd_protoc_gen_go_testdata_import_public_b_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Local); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cmd_protoc_gen_go_testdata_import_public_b_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_cmd_protoc_gen_go_testdata_import_public_b_proto_goTypes,
+		DependencyIndexes: file_cmd_protoc_gen_go_testdata_import_public_b_proto_depIdxs,
+		MessageInfos:      file_cmd_protoc_gen_go_testdata_import_public_b_proto_msgTypes,
+	}.Build()
+	File_cmd_protoc_gen_go_testdata_import_public_b_proto = out.File
+	file_cmd_protoc_gen_go_testdata_import_public_b_proto_rawDesc = nil
+	file_cmd_protoc_gen_go_testdata_import_public_b_proto_goTypes = nil
+	file_cmd_protoc_gen_go_testdata_import_public_b_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/b.proto b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/b.proto
new file mode 100644
index 000000000..f710dcecc
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/b.proto
@@ -0,0 +1,16 @@
+// 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.
+
+syntax = "proto2";
+
+package goproto.protoc.import_public;
+
+option go_package = "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public";
+
+import "cmd/protoc-gen-go/testdata/import_public/sub/a.proto";
+
+message Local {
+  optional goproto.protoc.import_public.sub.M m = 1;
+  optional goproto.protoc.import_public.sub.E e = 2;
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/c.pb.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/c.pb.go
new file mode 100644
index 000000000..ee2dbeabe
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/c.pb.go
@@ -0,0 +1,169 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: cmd/protoc-gen-go/testdata/import_public/c.proto
+
+package import_public
+
+import (
+	sub2 "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/sub2"
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type UsingPublicImport struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// Local is declared in b.proto, which is a public import of a.proto.
+	Local *Local `protobuf:"bytes,1,opt,name=local" json:"local,omitempty"`
+	// Sub2Message is declared in sub2/a.proto, which is a public import of
+	// sub/a.proto, which is a public import of a.proto.
+	Sub2 *sub2.Sub2Message `protobuf:"bytes,2,opt,name=sub2" json:"sub2,omitempty"` // declared in sub2/a.proto
+}
+
+func (x *UsingPublicImport) Reset() {
+	*x = UsingPublicImport{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_import_public_c_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *UsingPublicImport) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*UsingPublicImport) ProtoMessage() {}
+
+func (x *UsingPublicImport) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_import_public_c_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use UsingPublicImport.ProtoReflect.Descriptor instead.
+func (*UsingPublicImport) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_import_public_c_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *UsingPublicImport) GetLocal() *Local {
+	if x != nil {
+		return x.Local
+	}
+	return nil
+}
+
+func (x *UsingPublicImport) GetSub2() *sub2.Sub2Message {
+	if x != nil {
+		return x.Sub2
+	}
+	return nil
+}
+
+var File_cmd_protoc_gen_go_testdata_import_public_c_proto protoreflect.FileDescriptor
+
+var file_cmd_protoc_gen_go_testdata_import_public_c_proto_rawDesc = []byte{
+	0x0a, 0x30, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70,
+	0x6f, 0x72, 0x74, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x2f, 0x63, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x12, 0x1c, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x63, 0x2e, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63,
+	0x1a, 0x30, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70,
+	0x6f, 0x72, 0x74, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x2f, 0x61, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x22, 0x92, 0x01, 0x0a, 0x11, 0x55, 0x73, 0x69, 0x6e, 0x67, 0x50, 0x75, 0x62, 0x6c,
+	0x69, 0x63, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x12, 0x39, 0x0a, 0x05, 0x6c, 0x6f, 0x63, 0x61,
+	0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x5f,
+	0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x2e, 0x4c, 0x6f, 0x63, 0x61, 0x6c, 0x52, 0x05, 0x6c, 0x6f,
+	0x63, 0x61, 0x6c, 0x12, 0x42, 0x0a, 0x04, 0x73, 0x75, 0x62, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x2e, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x63, 0x2e, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63,
+	0x2e, 0x73, 0x75, 0x62, 0x32, 0x2e, 0x53, 0x75, 0x62, 0x32, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x52, 0x04, 0x73, 0x75, 0x62, 0x32, 0x42, 0x45, 0x5a, 0x43, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63,
+	0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61,
+	0x2f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63,
+}
+
+var (
+	file_cmd_protoc_gen_go_testdata_import_public_c_proto_rawDescOnce sync.Once
+	file_cmd_protoc_gen_go_testdata_import_public_c_proto_rawDescData = file_cmd_protoc_gen_go_testdata_import_public_c_proto_rawDesc
+)
+
+func file_cmd_protoc_gen_go_testdata_import_public_c_proto_rawDescGZIP() []byte {
+	file_cmd_protoc_gen_go_testdata_import_public_c_proto_rawDescOnce.Do(func() {
+		file_cmd_protoc_gen_go_testdata_import_public_c_proto_rawDescData = protoimpl.X.CompressGZIP(file_cmd_protoc_gen_go_testdata_import_public_c_proto_rawDescData)
+	})
+	return file_cmd_protoc_gen_go_testdata_import_public_c_proto_rawDescData
+}
+
+var file_cmd_protoc_gen_go_testdata_import_public_c_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_cmd_protoc_gen_go_testdata_import_public_c_proto_goTypes = []interface{}{
+	(*UsingPublicImport)(nil), // 0: goproto.protoc.import_public.UsingPublicImport
+	(*Local)(nil),             // 1: goproto.protoc.import_public.Local
+	(*sub2.Sub2Message)(nil),  // 2: goproto.protoc.import_public.sub2.Sub2Message
+}
+var file_cmd_protoc_gen_go_testdata_import_public_c_proto_depIdxs = []int32{
+	1, // 0: goproto.protoc.import_public.UsingPublicImport.local:type_name -> goproto.protoc.import_public.Local
+	2, // 1: goproto.protoc.import_public.UsingPublicImport.sub2:type_name -> goproto.protoc.import_public.sub2.Sub2Message
+	2, // [2:2] is the sub-list for method output_type
+	2, // [2:2] is the sub-list for method input_type
+	2, // [2:2] is the sub-list for extension type_name
+	2, // [2:2] is the sub-list for extension extendee
+	0, // [0:2] is the sub-list for field type_name
+}
+
+func init() { file_cmd_protoc_gen_go_testdata_import_public_c_proto_init() }
+func file_cmd_protoc_gen_go_testdata_import_public_c_proto_init() {
+	if File_cmd_protoc_gen_go_testdata_import_public_c_proto != nil {
+		return
+	}
+	file_cmd_protoc_gen_go_testdata_import_public_a_proto_init()
+	if !protoimpl.UnsafeEnabled {
+		file_cmd_protoc_gen_go_testdata_import_public_c_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*UsingPublicImport); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cmd_protoc_gen_go_testdata_import_public_c_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_cmd_protoc_gen_go_testdata_import_public_c_proto_goTypes,
+		DependencyIndexes: file_cmd_protoc_gen_go_testdata_import_public_c_proto_depIdxs,
+		MessageInfos:      file_cmd_protoc_gen_go_testdata_import_public_c_proto_msgTypes,
+	}.Build()
+	File_cmd_protoc_gen_go_testdata_import_public_c_proto = out.File
+	file_cmd_protoc_gen_go_testdata_import_public_c_proto_rawDesc = nil
+	file_cmd_protoc_gen_go_testdata_import_public_c_proto_goTypes = nil
+	file_cmd_protoc_gen_go_testdata_import_public_c_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/c.proto b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/c.proto
new file mode 100644
index 000000000..86b02a389
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/c.proto
@@ -0,0 +1,19 @@
+// 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.
+
+syntax = "proto2";
+
+package goproto.protoc.import_public;
+
+option go_package = "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public";
+
+import "cmd/protoc-gen-go/testdata/import_public/a.proto";
+
+message UsingPublicImport {
+  // Local is declared in b.proto, which is a public import of a.proto.
+  optional Local local = 1;
+  // Sub2Message is declared in sub2/a.proto, which is a public import of
+  // sub/a.proto, which is a public import of a.proto.
+  optional sub2.Sub2Message sub2 = 2; // declared in sub2/a.proto
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/sub/a.pb.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/sub/a.pb.go
new file mode 100644
index 000000000..21f5eb46c
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/sub/a.pb.go
@@ -0,0 +1,564 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: cmd/protoc-gen-go/testdata/import_public/sub/a.proto
+
+package sub
+
+import (
+	sub2 "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/sub2"
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoiface "google.golang.org/protobuf/runtime/protoiface"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	math "math"
+	reflect "reflect"
+	sync "sync"
+)
+
+// Symbols defined in public import of cmd/protoc-gen-go/testdata/import_public/sub2/a.proto.
+
+type Sub2Message = sub2.Sub2Message
+
+type E int32
+
+const (
+	E_ZERO E = 0
+)
+
+// Enum value maps for E.
+var (
+	E_name = map[int32]string{
+		0: "ZERO",
+	}
+	E_value = map[string]int32{
+		"ZERO": 0,
+	}
+)
+
+func (x E) Enum() *E {
+	p := new(E)
+	*p = x
+	return p
+}
+
+func (x E) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (E) Descriptor() protoreflect.EnumDescriptor {
+	return file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_enumTypes[0].Descriptor()
+}
+
+func (E) Type() protoreflect.EnumType {
+	return &file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_enumTypes[0]
+}
+
+func (x E) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *E) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = E(num)
+	return nil
+}
+
+// Deprecated: Use E.Descriptor instead.
+func (E) EnumDescriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_rawDescGZIP(), []int{0}
+}
+
+type M_Subenum int32
+
+const (
+	M_M_ZERO M_Subenum = 0
+)
+
+// Enum value maps for M_Subenum.
+var (
+	M_Subenum_name = map[int32]string{
+		0: "M_ZERO",
+	}
+	M_Subenum_value = map[string]int32{
+		"M_ZERO": 0,
+	}
+)
+
+func (x M_Subenum) Enum() *M_Subenum {
+	p := new(M_Subenum)
+	*p = x
+	return p
+}
+
+func (x M_Subenum) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (M_Subenum) Descriptor() protoreflect.EnumDescriptor {
+	return file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_enumTypes[1].Descriptor()
+}
+
+func (M_Subenum) Type() protoreflect.EnumType {
+	return &file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_enumTypes[1]
+}
+
+func (x M_Subenum) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *M_Subenum) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = M_Subenum(num)
+	return nil
+}
+
+// Deprecated: Use M_Subenum.Descriptor instead.
+func (M_Subenum) EnumDescriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_rawDescGZIP(), []int{0, 0}
+}
+
+type M_Submessage_Submessage_Subenum int32
+
+const (
+	M_Submessage_M_SUBMESSAGE_ZERO M_Submessage_Submessage_Subenum = 0
+)
+
+// Enum value maps for M_Submessage_Submessage_Subenum.
+var (
+	M_Submessage_Submessage_Subenum_name = map[int32]string{
+		0: "M_SUBMESSAGE_ZERO",
+	}
+	M_Submessage_Submessage_Subenum_value = map[string]int32{
+		"M_SUBMESSAGE_ZERO": 0,
+	}
+)
+
+func (x M_Submessage_Submessage_Subenum) Enum() *M_Submessage_Submessage_Subenum {
+	p := new(M_Submessage_Submessage_Subenum)
+	*p = x
+	return p
+}
+
+func (x M_Submessage_Submessage_Subenum) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (M_Submessage_Submessage_Subenum) Descriptor() protoreflect.EnumDescriptor {
+	return file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_enumTypes[2].Descriptor()
+}
+
+func (M_Submessage_Submessage_Subenum) Type() protoreflect.EnumType {
+	return &file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_enumTypes[2]
+}
+
+func (x M_Submessage_Submessage_Subenum) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *M_Submessage_Submessage_Subenum) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = M_Submessage_Submessage_Subenum(num)
+	return nil
+}
+
+// Deprecated: Use M_Submessage_Submessage_Subenum.Descriptor instead.
+func (M_Submessage_Submessage_Subenum) EnumDescriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_rawDescGZIP(), []int{0, 0, 0}
+}
+
+type M struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+
+	// Field using a type in the same Go package, but a different source file.
+	M2 *M2      `protobuf:"bytes,1,opt,name=m2" json:"m2,omitempty"`
+	S  *string  `protobuf:"bytes,4,opt,name=s,def=default" json:"s,omitempty"`
+	B  []byte   `protobuf:"bytes,5,opt,name=b,def=default" json:"b,omitempty"`
+	F  *float64 `protobuf:"fixed64,6,opt,name=f,def=nan" json:"f,omitempty"`
+	// Types that are assignable to OneofField:
+	//	*M_OneofInt32
+	//	*M_OneofInt64
+	OneofField isM_OneofField `protobuf_oneof:"oneof_field"`
+}
+
+// Default values for M fields.
+const (
+	Default_M_S = string("default")
+)
+
+// Default values for M fields.
+var (
+	Default_M_B = []byte("default")
+	Default_M_F = float64(math.NaN())
+)
+
+func (x *M) Reset() {
+	*x = M{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *M) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*M) ProtoMessage() {}
+
+func (x *M) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use M.ProtoReflect.Descriptor instead.
+func (*M) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_rawDescGZIP(), []int{0}
+}
+
+var extRange_M = []protoiface.ExtensionRangeV1{
+	{Start: 100, End: 536870911},
+}
+
+// Deprecated: Use M.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*M) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_M
+}
+
+func (x *M) GetM2() *M2 {
+	if x != nil {
+		return x.M2
+	}
+	return nil
+}
+
+func (x *M) GetS() string {
+	if x != nil && x.S != nil {
+		return *x.S
+	}
+	return Default_M_S
+}
+
+func (x *M) GetB() []byte {
+	if x != nil && x.B != nil {
+		return x.B
+	}
+	return append([]byte(nil), Default_M_B...)
+}
+
+func (x *M) GetF() float64 {
+	if x != nil && x.F != nil {
+		return *x.F
+	}
+	return Default_M_F
+}
+
+func (m *M) GetOneofField() isM_OneofField {
+	if m != nil {
+		return m.OneofField
+	}
+	return nil
+}
+
+func (x *M) GetOneofInt32() int32 {
+	if x, ok := x.GetOneofField().(*M_OneofInt32); ok {
+		return x.OneofInt32
+	}
+	return 0
+}
+
+func (x *M) GetOneofInt64() int64 {
+	if x, ok := x.GetOneofField().(*M_OneofInt64); ok {
+		return x.OneofInt64
+	}
+	return 0
+}
+
+type isM_OneofField interface {
+	isM_OneofField()
+}
+
+type M_OneofInt32 struct {
+	OneofInt32 int32 `protobuf:"varint,2,opt,name=oneof_int32,json=oneofInt32,oneof"`
+}
+
+type M_OneofInt64 struct {
+	OneofInt64 int64 `protobuf:"varint,3,opt,name=oneof_int64,json=oneofInt64,oneof"`
+}
+
+func (*M_OneofInt32) isM_OneofField() {}
+
+func (*M_OneofInt64) isM_OneofField() {}
+
+type M_Submessage struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// Types that are assignable to SubmessageOneofField:
+	//	*M_Submessage_SubmessageOneofInt32
+	//	*M_Submessage_SubmessageOneofInt64
+	SubmessageOneofField isM_Submessage_SubmessageOneofField `protobuf_oneof:"submessage_oneof_field"`
+}
+
+func (x *M_Submessage) Reset() {
+	*x = M_Submessage{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *M_Submessage) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*M_Submessage) ProtoMessage() {}
+
+func (x *M_Submessage) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use M_Submessage.ProtoReflect.Descriptor instead.
+func (*M_Submessage) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_rawDescGZIP(), []int{0, 0}
+}
+
+func (m *M_Submessage) GetSubmessageOneofField() isM_Submessage_SubmessageOneofField {
+	if m != nil {
+		return m.SubmessageOneofField
+	}
+	return nil
+}
+
+func (x *M_Submessage) GetSubmessageOneofInt32() int32 {
+	if x, ok := x.GetSubmessageOneofField().(*M_Submessage_SubmessageOneofInt32); ok {
+		return x.SubmessageOneofInt32
+	}
+	return 0
+}
+
+func (x *M_Submessage) GetSubmessageOneofInt64() int64 {
+	if x, ok := x.GetSubmessageOneofField().(*M_Submessage_SubmessageOneofInt64); ok {
+		return x.SubmessageOneofInt64
+	}
+	return 0
+}
+
+type isM_Submessage_SubmessageOneofField interface {
+	isM_Submessage_SubmessageOneofField()
+}
+
+type M_Submessage_SubmessageOneofInt32 struct {
+	SubmessageOneofInt32 int32 `protobuf:"varint,1,opt,name=submessage_oneof_int32,json=submessageOneofInt32,oneof"`
+}
+
+type M_Submessage_SubmessageOneofInt64 struct {
+	SubmessageOneofInt64 int64 `protobuf:"varint,2,opt,name=submessage_oneof_int64,json=submessageOneofInt64,oneof"`
+}
+
+func (*M_Submessage_SubmessageOneofInt32) isM_Submessage_SubmessageOneofField() {}
+
+func (*M_Submessage_SubmessageOneofInt64) isM_Submessage_SubmessageOneofField() {}
+
+var file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_extTypes = []protoimpl.ExtensionInfo{
+	{
+		ExtendedType:  (*M)(nil),
+		ExtensionType: (*string)(nil),
+		Field:         100,
+		Name:          "goproto.protoc.import_public.sub.extension_field",
+		Tag:           "bytes,100,opt,name=extension_field",
+		Filename:      "cmd/protoc-gen-go/testdata/import_public/sub/a.proto",
+	},
+}
+
+// Extension fields to M.
+var (
+	// optional string extension_field = 100;
+	E_ExtensionField = &file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_extTypes[0]
+)
+
+var File_cmd_protoc_gen_go_testdata_import_public_sub_a_proto protoreflect.FileDescriptor
+
+var file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_rawDesc = []byte{
+	0x0a, 0x34, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70,
+	0x6f, 0x72, 0x74, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x2f, 0x73, 0x75, 0x62, 0x2f, 0x61,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x20, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x70, 0x75,
+	0x62, 0x6c, 0x69, 0x63, 0x2e, 0x73, 0x75, 0x62, 0x1a, 0x34, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74,
+	0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x70, 0x75, 0x62, 0x6c,
+	0x69, 0x63, 0x2f, 0x73, 0x75, 0x62, 0x2f, 0x62, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x35,
+	0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67,
+	0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70, 0x6f, 0x72,
+	0x74, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x2f, 0x73, 0x75, 0x62, 0x32, 0x2f, 0x61, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xb6, 0x03, 0x0a, 0x01, 0x4d, 0x12, 0x34, 0x0a, 0x02, 0x6d,
+	0x32, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x5f,
+	0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x2e, 0x73, 0x75, 0x62, 0x2e, 0x4d, 0x32, 0x52, 0x02, 0x6d,
+	0x32, 0x12, 0x15, 0x0a, 0x01, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x3a, 0x07, 0x64, 0x65,
+	0x66, 0x61, 0x75, 0x6c, 0x74, 0x52, 0x01, 0x73, 0x12, 0x15, 0x0a, 0x01, 0x62, 0x18, 0x05, 0x20,
+	0x01, 0x28, 0x0c, 0x3a, 0x07, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x52, 0x01, 0x62, 0x12,
+	0x11, 0x0a, 0x01, 0x66, 0x18, 0x06, 0x20, 0x01, 0x28, 0x01, 0x3a, 0x03, 0x6e, 0x61, 0x6e, 0x52,
+	0x01, 0x66, 0x12, 0x21, 0x0a, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x69, 0x6e, 0x74, 0x33,
+	0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, 0x0a, 0x6f, 0x6e, 0x65, 0x6f, 0x66,
+	0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x21, 0x0a, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x69,
+	0x6e, 0x74, 0x36, 0x34, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x48, 0x00, 0x52, 0x0a, 0x6f, 0x6e,
+	0x65, 0x6f, 0x66, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x1a, 0xc3, 0x01, 0x0a, 0x0a, 0x53, 0x75, 0x62,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x36, 0x0a, 0x16, 0x73, 0x75, 0x62, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x69, 0x6e, 0x74, 0x33,
+	0x32, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, 0x14, 0x73, 0x75, 0x62, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x6e, 0x65, 0x6f, 0x66, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12,
+	0x36, 0x0a, 0x16, 0x73, 0x75, 0x62, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x6f, 0x6e,
+	0x65, 0x6f, 0x66, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x48,
+	0x00, 0x52, 0x14, 0x73, 0x75, 0x62, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x6e, 0x65,
+	0x6f, 0x66, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x22, 0x2b, 0x0a, 0x12, 0x53, 0x75, 0x62, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x53, 0x75, 0x62, 0x65, 0x6e, 0x75, 0x6d, 0x12, 0x15, 0x0a,
+	0x11, 0x4d, 0x5f, 0x53, 0x55, 0x42, 0x4d, 0x45, 0x53, 0x53, 0x41, 0x47, 0x45, 0x5f, 0x5a, 0x45,
+	0x52, 0x4f, 0x10, 0x00, 0x42, 0x18, 0x0a, 0x16, 0x73, 0x75, 0x62, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x5f, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x22, 0x15,
+	0x0a, 0x07, 0x53, 0x75, 0x62, 0x65, 0x6e, 0x75, 0x6d, 0x12, 0x0a, 0x0a, 0x06, 0x4d, 0x5f, 0x5a,
+	0x45, 0x52, 0x4f, 0x10, 0x00, 0x2a, 0x08, 0x08, 0x64, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x42,
+	0x0d, 0x0a, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x2a, 0x0d,
+	0x0a, 0x01, 0x45, 0x12, 0x08, 0x0a, 0x04, 0x5a, 0x45, 0x52, 0x4f, 0x10, 0x00, 0x3a, 0x4c, 0x0a,
+	0x0f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x12, 0x23, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x63, 0x2e, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x2e,
+	0x73, 0x75, 0x62, 0x2e, 0x4d, 0x18, 0x64, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x65, 0x78, 0x74,
+	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42, 0x49, 0x5a, 0x47, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67,
+	0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74,
+	0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x70, 0x75, 0x62, 0x6c,
+	0x69, 0x63, 0x2f, 0x73, 0x75, 0x62, 0x50, 0x01,
+}
+
+var (
+	file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_rawDescOnce sync.Once
+	file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_rawDescData = file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_rawDesc
+)
+
+func file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_rawDescGZIP() []byte {
+	file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_rawDescOnce.Do(func() {
+		file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_rawDescData = protoimpl.X.CompressGZIP(file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_rawDescData)
+	})
+	return file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_rawDescData
+}
+
+var file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_enumTypes = make([]protoimpl.EnumInfo, 3)
+var file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
+var file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_goTypes = []interface{}{
+	(E)(0),                               // 0: goproto.protoc.import_public.sub.E
+	(M_Subenum)(0),                       // 1: goproto.protoc.import_public.sub.M.Subenum
+	(M_Submessage_Submessage_Subenum)(0), // 2: goproto.protoc.import_public.sub.M.Submessage.Submessage_Subenum
+	(*M)(nil),                            // 3: goproto.protoc.import_public.sub.M
+	(*M_Submessage)(nil),                 // 4: goproto.protoc.import_public.sub.M.Submessage
+	(*M2)(nil),                           // 5: goproto.protoc.import_public.sub.M2
+}
+var file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_depIdxs = []int32{
+	5, // 0: goproto.protoc.import_public.sub.M.m2:type_name -> goproto.protoc.import_public.sub.M2
+	3, // 1: goproto.protoc.import_public.sub.extension_field:extendee -> goproto.protoc.import_public.sub.M
+	2, // [2:2] is the sub-list for method output_type
+	2, // [2:2] is the sub-list for method input_type
+	2, // [2:2] is the sub-list for extension type_name
+	1, // [1:2] is the sub-list for extension extendee
+	0, // [0:1] is the sub-list for field type_name
+}
+
+func init() { file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_init() }
+func file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_init() {
+	if File_cmd_protoc_gen_go_testdata_import_public_sub_a_proto != nil {
+		return
+	}
+	file_cmd_protoc_gen_go_testdata_import_public_sub_b_proto_init()
+	if !protoimpl.UnsafeEnabled {
+		file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*M); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*M_Submessage); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_msgTypes[0].OneofWrappers = []interface{}{
+		(*M_OneofInt32)(nil),
+		(*M_OneofInt64)(nil),
+	}
+	file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_msgTypes[1].OneofWrappers = []interface{}{
+		(*M_Submessage_SubmessageOneofInt32)(nil),
+		(*M_Submessage_SubmessageOneofInt64)(nil),
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_rawDesc,
+			NumEnums:      3,
+			NumMessages:   2,
+			NumExtensions: 1,
+			NumServices:   0,
+		},
+		GoTypes:           file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_goTypes,
+		DependencyIndexes: file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_depIdxs,
+		EnumInfos:         file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_enumTypes,
+		MessageInfos:      file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_msgTypes,
+		ExtensionInfos:    file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_extTypes,
+	}.Build()
+	File_cmd_protoc_gen_go_testdata_import_public_sub_a_proto = out.File
+	file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_rawDesc = nil
+	file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_goTypes = nil
+	file_cmd_protoc_gen_go_testdata_import_public_sub_a_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/sub/a.proto b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/sub/a.proto
new file mode 100644
index 000000000..9fa4cb853
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/sub/a.proto
@@ -0,0 +1,50 @@
+// 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.
+
+syntax = "proto2";
+
+package goproto.protoc.import_public.sub;
+
+option go_package = "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/sub";
+
+import "cmd/protoc-gen-go/testdata/import_public/sub/b.proto";
+import public "cmd/protoc-gen-go/testdata/import_public/sub2/a.proto";
+
+message M {
+  // Field using a type in the same Go package, but a different source file.
+  optional M2 m2 = 1;
+  optional string s = 4 [default="default"];
+  optional bytes b = 5 [default="default"];
+  optional double f = 6 [default=nan];
+
+  oneof oneof_field {
+    int32 oneof_int32 = 2;
+    int64 oneof_int64 = 3;
+  }
+
+  message Submessage {
+    enum Submessage_Subenum {
+      M_SUBMESSAGE_ZERO = 0;
+    }
+
+    oneof submessage_oneof_field {
+      int32 submessage_oneof_int32 = 1;
+      int64 submessage_oneof_int64 = 2;
+    }
+  }
+
+  enum Subenum {
+    M_ZERO = 0;
+  }
+
+  extensions 100 to max;
+}
+
+extend M {
+  optional string extension_field = 100;
+}
+
+enum E {
+  ZERO = 0;
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/sub/b.pb.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/sub/b.pb.go
new file mode 100644
index 000000000..5679e9596
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/sub/b.pb.go
@@ -0,0 +1,132 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: cmd/protoc-gen-go/testdata/import_public/sub/b.proto
+
+package sub
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type M2 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *M2) Reset() {
+	*x = M2{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_import_public_sub_b_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *M2) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*M2) ProtoMessage() {}
+
+func (x *M2) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_import_public_sub_b_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use M2.ProtoReflect.Descriptor instead.
+func (*M2) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_import_public_sub_b_proto_rawDescGZIP(), []int{0}
+}
+
+var File_cmd_protoc_gen_go_testdata_import_public_sub_b_proto protoreflect.FileDescriptor
+
+var file_cmd_protoc_gen_go_testdata_import_public_sub_b_proto_rawDesc = []byte{
+	0x0a, 0x34, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70,
+	0x6f, 0x72, 0x74, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x2f, 0x73, 0x75, 0x62, 0x2f, 0x62,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x20, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x70, 0x75,
+	0x62, 0x6c, 0x69, 0x63, 0x2e, 0x73, 0x75, 0x62, 0x22, 0x04, 0x0a, 0x02, 0x4d, 0x32, 0x42, 0x49,
+	0x5a, 0x47, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e,
+	0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x63, 0x6d, 0x64,
+	0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x74,
+	0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x70,
+	0x75, 0x62, 0x6c, 0x69, 0x63, 0x2f, 0x73, 0x75, 0x62,
+}
+
+var (
+	file_cmd_protoc_gen_go_testdata_import_public_sub_b_proto_rawDescOnce sync.Once
+	file_cmd_protoc_gen_go_testdata_import_public_sub_b_proto_rawDescData = file_cmd_protoc_gen_go_testdata_import_public_sub_b_proto_rawDesc
+)
+
+func file_cmd_protoc_gen_go_testdata_import_public_sub_b_proto_rawDescGZIP() []byte {
+	file_cmd_protoc_gen_go_testdata_import_public_sub_b_proto_rawDescOnce.Do(func() {
+		file_cmd_protoc_gen_go_testdata_import_public_sub_b_proto_rawDescData = protoimpl.X.CompressGZIP(file_cmd_protoc_gen_go_testdata_import_public_sub_b_proto_rawDescData)
+	})
+	return file_cmd_protoc_gen_go_testdata_import_public_sub_b_proto_rawDescData
+}
+
+var file_cmd_protoc_gen_go_testdata_import_public_sub_b_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_cmd_protoc_gen_go_testdata_import_public_sub_b_proto_goTypes = []interface{}{
+	(*M2)(nil), // 0: goproto.protoc.import_public.sub.M2
+}
+var file_cmd_protoc_gen_go_testdata_import_public_sub_b_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_cmd_protoc_gen_go_testdata_import_public_sub_b_proto_init() }
+func file_cmd_protoc_gen_go_testdata_import_public_sub_b_proto_init() {
+	if File_cmd_protoc_gen_go_testdata_import_public_sub_b_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_cmd_protoc_gen_go_testdata_import_public_sub_b_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*M2); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cmd_protoc_gen_go_testdata_import_public_sub_b_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_cmd_protoc_gen_go_testdata_import_public_sub_b_proto_goTypes,
+		DependencyIndexes: file_cmd_protoc_gen_go_testdata_import_public_sub_b_proto_depIdxs,
+		MessageInfos:      file_cmd_protoc_gen_go_testdata_import_public_sub_b_proto_msgTypes,
+	}.Build()
+	File_cmd_protoc_gen_go_testdata_import_public_sub_b_proto = out.File
+	file_cmd_protoc_gen_go_testdata_import_public_sub_b_proto_rawDesc = nil
+	file_cmd_protoc_gen_go_testdata_import_public_sub_b_proto_goTypes = nil
+	file_cmd_protoc_gen_go_testdata_import_public_sub_b_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/sub/b.proto b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/sub/b.proto
new file mode 100644
index 000000000..2f1bb5d62
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/sub/b.proto
@@ -0,0 +1,12 @@
+// 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.
+
+syntax = "proto2";
+
+package goproto.protoc.import_public.sub;
+
+option go_package = "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/sub";
+
+message M2 {
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/sub2/a.pb.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/sub2/a.pb.go
new file mode 100644
index 000000000..98499fd34
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/sub2/a.pb.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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: cmd/protoc-gen-go/testdata/import_public/sub2/a.proto
+
+package sub2
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type Sub2Message struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Sub2Message) Reset() {
+	*x = Sub2Message{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_import_public_sub2_a_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Sub2Message) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Sub2Message) ProtoMessage() {}
+
+func (x *Sub2Message) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_import_public_sub2_a_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Sub2Message.ProtoReflect.Descriptor instead.
+func (*Sub2Message) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_import_public_sub2_a_proto_rawDescGZIP(), []int{0}
+}
+
+var File_cmd_protoc_gen_go_testdata_import_public_sub2_a_proto protoreflect.FileDescriptor
+
+var file_cmd_protoc_gen_go_testdata_import_public_sub2_a_proto_rawDesc = []byte{
+	0x0a, 0x35, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70,
+	0x6f, 0x72, 0x74, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x2f, 0x73, 0x75, 0x62, 0x32, 0x2f,
+	0x61, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x21, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x70,
+	0x75, 0x62, 0x6c, 0x69, 0x63, 0x2e, 0x73, 0x75, 0x62, 0x32, 0x22, 0x0d, 0x0a, 0x0b, 0x53, 0x75,
+	0x62, 0x32, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x42, 0x4a, 0x5a, 0x48, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61,
+	0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63,
+	0x2f, 0x73, 0x75, 0x62, 0x32,
+}
+
+var (
+	file_cmd_protoc_gen_go_testdata_import_public_sub2_a_proto_rawDescOnce sync.Once
+	file_cmd_protoc_gen_go_testdata_import_public_sub2_a_proto_rawDescData = file_cmd_protoc_gen_go_testdata_import_public_sub2_a_proto_rawDesc
+)
+
+func file_cmd_protoc_gen_go_testdata_import_public_sub2_a_proto_rawDescGZIP() []byte {
+	file_cmd_protoc_gen_go_testdata_import_public_sub2_a_proto_rawDescOnce.Do(func() {
+		file_cmd_protoc_gen_go_testdata_import_public_sub2_a_proto_rawDescData = protoimpl.X.CompressGZIP(file_cmd_protoc_gen_go_testdata_import_public_sub2_a_proto_rawDescData)
+	})
+	return file_cmd_protoc_gen_go_testdata_import_public_sub2_a_proto_rawDescData
+}
+
+var file_cmd_protoc_gen_go_testdata_import_public_sub2_a_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_cmd_protoc_gen_go_testdata_import_public_sub2_a_proto_goTypes = []interface{}{
+	(*Sub2Message)(nil), // 0: goproto.protoc.import_public.sub2.Sub2Message
+}
+var file_cmd_protoc_gen_go_testdata_import_public_sub2_a_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_cmd_protoc_gen_go_testdata_import_public_sub2_a_proto_init() }
+func file_cmd_protoc_gen_go_testdata_import_public_sub2_a_proto_init() {
+	if File_cmd_protoc_gen_go_testdata_import_public_sub2_a_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_cmd_protoc_gen_go_testdata_import_public_sub2_a_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Sub2Message); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cmd_protoc_gen_go_testdata_import_public_sub2_a_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_cmd_protoc_gen_go_testdata_import_public_sub2_a_proto_goTypes,
+		DependencyIndexes: file_cmd_protoc_gen_go_testdata_import_public_sub2_a_proto_depIdxs,
+		MessageInfos:      file_cmd_protoc_gen_go_testdata_import_public_sub2_a_proto_msgTypes,
+	}.Build()
+	File_cmd_protoc_gen_go_testdata_import_public_sub2_a_proto = out.File
+	file_cmd_protoc_gen_go_testdata_import_public_sub2_a_proto_rawDesc = nil
+	file_cmd_protoc_gen_go_testdata_import_public_sub2_a_proto_goTypes = nil
+	file_cmd_protoc_gen_go_testdata_import_public_sub2_a_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/sub2/a.proto b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/sub2/a.proto
new file mode 100644
index 000000000..ec8aa9099
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/sub2/a.proto
@@ -0,0 +1,11 @@
+// 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.
+
+syntax = "proto2";
+
+package goproto.protoc.import_public.sub2;
+
+option go_package = "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/sub2";
+
+message Sub2Message {}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/fmt/m.pb.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/fmt/m.pb.go
new file mode 100644
index 000000000..7d8914678
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/fmt/m.pb.go
@@ -0,0 +1,130 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: cmd/protoc-gen-go/testdata/imports/fmt/m.proto
+
+package fmt
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type M struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *M) Reset() {
+	*x = M{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_imports_fmt_m_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *M) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*M) ProtoMessage() {}
+
+func (x *M) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_imports_fmt_m_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use M.ProtoReflect.Descriptor instead.
+func (*M) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_imports_fmt_m_proto_rawDescGZIP(), []int{0}
+}
+
+var File_cmd_protoc_gen_go_testdata_imports_fmt_m_proto protoreflect.FileDescriptor
+
+var file_cmd_protoc_gen_go_testdata_imports_fmt_m_proto_rawDesc = []byte{
+	0x0a, 0x2e, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70,
+	0x6f, 0x72, 0x74, 0x73, 0x2f, 0x66, 0x6d, 0x74, 0x2f, 0x6d, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x12, 0x03, 0x66, 0x6d, 0x74, 0x22, 0x03, 0x0a, 0x01, 0x4d, 0x42, 0x43, 0x5a, 0x41, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64,
+	0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x2f, 0x66, 0x6d, 0x74, 0x62,
+	0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_cmd_protoc_gen_go_testdata_imports_fmt_m_proto_rawDescOnce sync.Once
+	file_cmd_protoc_gen_go_testdata_imports_fmt_m_proto_rawDescData = file_cmd_protoc_gen_go_testdata_imports_fmt_m_proto_rawDesc
+)
+
+func file_cmd_protoc_gen_go_testdata_imports_fmt_m_proto_rawDescGZIP() []byte {
+	file_cmd_protoc_gen_go_testdata_imports_fmt_m_proto_rawDescOnce.Do(func() {
+		file_cmd_protoc_gen_go_testdata_imports_fmt_m_proto_rawDescData = protoimpl.X.CompressGZIP(file_cmd_protoc_gen_go_testdata_imports_fmt_m_proto_rawDescData)
+	})
+	return file_cmd_protoc_gen_go_testdata_imports_fmt_m_proto_rawDescData
+}
+
+var file_cmd_protoc_gen_go_testdata_imports_fmt_m_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_cmd_protoc_gen_go_testdata_imports_fmt_m_proto_goTypes = []interface{}{
+	(*M)(nil), // 0: fmt.M
+}
+var file_cmd_protoc_gen_go_testdata_imports_fmt_m_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_cmd_protoc_gen_go_testdata_imports_fmt_m_proto_init() }
+func file_cmd_protoc_gen_go_testdata_imports_fmt_m_proto_init() {
+	if File_cmd_protoc_gen_go_testdata_imports_fmt_m_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_cmd_protoc_gen_go_testdata_imports_fmt_m_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*M); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cmd_protoc_gen_go_testdata_imports_fmt_m_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_cmd_protoc_gen_go_testdata_imports_fmt_m_proto_goTypes,
+		DependencyIndexes: file_cmd_protoc_gen_go_testdata_imports_fmt_m_proto_depIdxs,
+		MessageInfos:      file_cmd_protoc_gen_go_testdata_imports_fmt_m_proto_msgTypes,
+	}.Build()
+	File_cmd_protoc_gen_go_testdata_imports_fmt_m_proto = out.File
+	file_cmd_protoc_gen_go_testdata_imports_fmt_m_proto_rawDesc = nil
+	file_cmd_protoc_gen_go_testdata_imports_fmt_m_proto_goTypes = nil
+	file_cmd_protoc_gen_go_testdata_imports_fmt_m_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/fmt/m.proto b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/fmt/m.proto
new file mode 100644
index 000000000..580c2b5d9
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/fmt/m.proto
@@ -0,0 +1,8 @@
+// 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.
+
+syntax = "proto3";
+package fmt;
+option go_package = "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/fmt";
+message M {}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_a_1/m1.pb.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_a_1/m1.pb.go
new file mode 100644
index 000000000..363f0b7bb
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_a_1/m1.pb.go
@@ -0,0 +1,241 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: cmd/protoc-gen-go/testdata/imports/test_a_1/m1.proto
+
+package test_a_1
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type E1 int32
+
+const (
+	E1_E1_ZERO E1 = 0
+)
+
+// Enum value maps for E1.
+var (
+	E1_name = map[int32]string{
+		0: "E1_ZERO",
+	}
+	E1_value = map[string]int32{
+		"E1_ZERO": 0,
+	}
+)
+
+func (x E1) Enum() *E1 {
+	p := new(E1)
+	*p = x
+	return p
+}
+
+func (x E1) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (E1) Descriptor() protoreflect.EnumDescriptor {
+	return file_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto_enumTypes[0].Descriptor()
+}
+
+func (E1) Type() protoreflect.EnumType {
+	return &file_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto_enumTypes[0]
+}
+
+func (x E1) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use E1.Descriptor instead.
+func (E1) EnumDescriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto_rawDescGZIP(), []int{0}
+}
+
+type M1 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *M1) Reset() {
+	*x = M1{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *M1) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*M1) ProtoMessage() {}
+
+func (x *M1) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use M1.ProtoReflect.Descriptor instead.
+func (*M1) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto_rawDescGZIP(), []int{0}
+}
+
+type M1_1 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	M1 *M1 `protobuf:"bytes,1,opt,name=m1,proto3" json:"m1,omitempty"`
+}
+
+func (x *M1_1) Reset() {
+	*x = M1_1{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *M1_1) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*M1_1) ProtoMessage() {}
+
+func (x *M1_1) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use M1_1.ProtoReflect.Descriptor instead.
+func (*M1_1) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *M1_1) GetM1() *M1 {
+	if x != nil {
+		return x.M1
+	}
+	return nil
+}
+
+var File_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto protoreflect.FileDescriptor
+
+var file_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto_rawDesc = []byte{
+	0x0a, 0x34, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70,
+	0x6f, 0x72, 0x74, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x5f, 0x31, 0x2f, 0x6d, 0x31,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x06, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x61, 0x22, 0x04,
+	0x0a, 0x02, 0x4d, 0x31, 0x22, 0x22, 0x0a, 0x04, 0x4d, 0x31, 0x5f, 0x31, 0x12, 0x1a, 0x0a, 0x02,
+	0x6d, 0x31, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0a, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e,
+	0x61, 0x2e, 0x4d, 0x31, 0x52, 0x02, 0x6d, 0x31, 0x2a, 0x11, 0x0a, 0x02, 0x45, 0x31, 0x12, 0x0b,
+	0x0a, 0x07, 0x45, 0x31, 0x5f, 0x5a, 0x45, 0x52, 0x4f, 0x10, 0x00, 0x42, 0x48, 0x5a, 0x46, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67,
+	0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74,
+	0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x2f, 0x74, 0x65, 0x73,
+	0x74, 0x5f, 0x61, 0x5f, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto_rawDescOnce sync.Once
+	file_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto_rawDescData = file_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto_rawDesc
+)
+
+func file_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto_rawDescGZIP() []byte {
+	file_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto_rawDescOnce.Do(func() {
+		file_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto_rawDescData = protoimpl.X.CompressGZIP(file_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto_rawDescData)
+	})
+	return file_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto_rawDescData
+}
+
+var file_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
+var file_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
+var file_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto_goTypes = []interface{}{
+	(E1)(0),      // 0: test.a.E1
+	(*M1)(nil),   // 1: test.a.M1
+	(*M1_1)(nil), // 2: test.a.M1_1
+}
+var file_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto_depIdxs = []int32{
+	1, // 0: test.a.M1_1.m1:type_name -> test.a.M1
+	1, // [1:1] is the sub-list for method output_type
+	1, // [1:1] is the sub-list for method input_type
+	1, // [1:1] is the sub-list for extension type_name
+	1, // [1:1] is the sub-list for extension extendee
+	0, // [0:1] is the sub-list for field type_name
+}
+
+func init() { file_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto_init() }
+func file_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto_init() {
+	if File_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*M1); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*M1_1); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto_rawDesc,
+			NumEnums:      1,
+			NumMessages:   2,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto_goTypes,
+		DependencyIndexes: file_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto_depIdxs,
+		EnumInfos:         file_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto_enumTypes,
+		MessageInfos:      file_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto_msgTypes,
+	}.Build()
+	File_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto = out.File
+	file_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto_rawDesc = nil
+	file_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto_goTypes = nil
+	file_cmd_protoc_gen_go_testdata_imports_test_a_1_m1_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_a_1/m1.proto b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_a_1/m1.proto
new file mode 100644
index 000000000..0c2f3e124
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_a_1/m1.proto
@@ -0,0 +1,17 @@
+// 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.
+
+syntax = "proto3";
+package test.a;
+option go_package = "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_a_1";
+
+message M1 {}
+
+message M1_1 {
+  M1 m1 = 1;
+}
+
+enum E1 {
+  E1_ZERO = 0;
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_a_1/m2.pb.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_a_1/m2.pb.go
new file mode 100644
index 000000000..978732146
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_a_1/m2.pb.go
@@ -0,0 +1,131 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: cmd/protoc-gen-go/testdata/imports/test_a_1/m2.proto
+
+package test_a_1
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type M2 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *M2) Reset() {
+	*x = M2{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_imports_test_a_1_m2_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *M2) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*M2) ProtoMessage() {}
+
+func (x *M2) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_imports_test_a_1_m2_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use M2.ProtoReflect.Descriptor instead.
+func (*M2) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_imports_test_a_1_m2_proto_rawDescGZIP(), []int{0}
+}
+
+var File_cmd_protoc_gen_go_testdata_imports_test_a_1_m2_proto protoreflect.FileDescriptor
+
+var file_cmd_protoc_gen_go_testdata_imports_test_a_1_m2_proto_rawDesc = []byte{
+	0x0a, 0x34, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70,
+	0x6f, 0x72, 0x74, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x5f, 0x31, 0x2f, 0x6d, 0x32,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x06, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x61, 0x22, 0x04,
+	0x0a, 0x02, 0x4d, 0x32, 0x42, 0x48, 0x5a, 0x46, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67,
+	0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
+	0x75, 0x66, 0x2f, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65,
+	0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d,
+	0x70, 0x6f, 0x72, 0x74, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x5f, 0x31, 0x62, 0x06,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_cmd_protoc_gen_go_testdata_imports_test_a_1_m2_proto_rawDescOnce sync.Once
+	file_cmd_protoc_gen_go_testdata_imports_test_a_1_m2_proto_rawDescData = file_cmd_protoc_gen_go_testdata_imports_test_a_1_m2_proto_rawDesc
+)
+
+func file_cmd_protoc_gen_go_testdata_imports_test_a_1_m2_proto_rawDescGZIP() []byte {
+	file_cmd_protoc_gen_go_testdata_imports_test_a_1_m2_proto_rawDescOnce.Do(func() {
+		file_cmd_protoc_gen_go_testdata_imports_test_a_1_m2_proto_rawDescData = protoimpl.X.CompressGZIP(file_cmd_protoc_gen_go_testdata_imports_test_a_1_m2_proto_rawDescData)
+	})
+	return file_cmd_protoc_gen_go_testdata_imports_test_a_1_m2_proto_rawDescData
+}
+
+var file_cmd_protoc_gen_go_testdata_imports_test_a_1_m2_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_cmd_protoc_gen_go_testdata_imports_test_a_1_m2_proto_goTypes = []interface{}{
+	(*M2)(nil), // 0: test.a.M2
+}
+var file_cmd_protoc_gen_go_testdata_imports_test_a_1_m2_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_cmd_protoc_gen_go_testdata_imports_test_a_1_m2_proto_init() }
+func file_cmd_protoc_gen_go_testdata_imports_test_a_1_m2_proto_init() {
+	if File_cmd_protoc_gen_go_testdata_imports_test_a_1_m2_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_cmd_protoc_gen_go_testdata_imports_test_a_1_m2_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*M2); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cmd_protoc_gen_go_testdata_imports_test_a_1_m2_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_cmd_protoc_gen_go_testdata_imports_test_a_1_m2_proto_goTypes,
+		DependencyIndexes: file_cmd_protoc_gen_go_testdata_imports_test_a_1_m2_proto_depIdxs,
+		MessageInfos:      file_cmd_protoc_gen_go_testdata_imports_test_a_1_m2_proto_msgTypes,
+	}.Build()
+	File_cmd_protoc_gen_go_testdata_imports_test_a_1_m2_proto = out.File
+	file_cmd_protoc_gen_go_testdata_imports_test_a_1_m2_proto_rawDesc = nil
+	file_cmd_protoc_gen_go_testdata_imports_test_a_1_m2_proto_goTypes = nil
+	file_cmd_protoc_gen_go_testdata_imports_test_a_1_m2_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_a_1/m2.proto b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_a_1/m2.proto
new file mode 100644
index 000000000..31aa90961
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_a_1/m2.proto
@@ -0,0 +1,8 @@
+// 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.
+
+syntax = "proto3";
+package test.a;
+option go_package = "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_a_1";
+message M2 {}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_a_2/m3.pb.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_a_2/m3.pb.go
new file mode 100644
index 000000000..3eabde129
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_a_2/m3.pb.go
@@ -0,0 +1,131 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: cmd/protoc-gen-go/testdata/imports/test_a_2/m3.proto
+
+package test_a_2
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type M3 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *M3) Reset() {
+	*x = M3{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_imports_test_a_2_m3_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *M3) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*M3) ProtoMessage() {}
+
+func (x *M3) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_imports_test_a_2_m3_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use M3.ProtoReflect.Descriptor instead.
+func (*M3) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_imports_test_a_2_m3_proto_rawDescGZIP(), []int{0}
+}
+
+var File_cmd_protoc_gen_go_testdata_imports_test_a_2_m3_proto protoreflect.FileDescriptor
+
+var file_cmd_protoc_gen_go_testdata_imports_test_a_2_m3_proto_rawDesc = []byte{
+	0x0a, 0x34, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70,
+	0x6f, 0x72, 0x74, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x5f, 0x32, 0x2f, 0x6d, 0x33,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x06, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x61, 0x22, 0x04,
+	0x0a, 0x02, 0x4d, 0x33, 0x42, 0x48, 0x5a, 0x46, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67,
+	0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
+	0x75, 0x66, 0x2f, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65,
+	0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d,
+	0x70, 0x6f, 0x72, 0x74, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x5f, 0x32, 0x62, 0x06,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_cmd_protoc_gen_go_testdata_imports_test_a_2_m3_proto_rawDescOnce sync.Once
+	file_cmd_protoc_gen_go_testdata_imports_test_a_2_m3_proto_rawDescData = file_cmd_protoc_gen_go_testdata_imports_test_a_2_m3_proto_rawDesc
+)
+
+func file_cmd_protoc_gen_go_testdata_imports_test_a_2_m3_proto_rawDescGZIP() []byte {
+	file_cmd_protoc_gen_go_testdata_imports_test_a_2_m3_proto_rawDescOnce.Do(func() {
+		file_cmd_protoc_gen_go_testdata_imports_test_a_2_m3_proto_rawDescData = protoimpl.X.CompressGZIP(file_cmd_protoc_gen_go_testdata_imports_test_a_2_m3_proto_rawDescData)
+	})
+	return file_cmd_protoc_gen_go_testdata_imports_test_a_2_m3_proto_rawDescData
+}
+
+var file_cmd_protoc_gen_go_testdata_imports_test_a_2_m3_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_cmd_protoc_gen_go_testdata_imports_test_a_2_m3_proto_goTypes = []interface{}{
+	(*M3)(nil), // 0: test.a.M3
+}
+var file_cmd_protoc_gen_go_testdata_imports_test_a_2_m3_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_cmd_protoc_gen_go_testdata_imports_test_a_2_m3_proto_init() }
+func file_cmd_protoc_gen_go_testdata_imports_test_a_2_m3_proto_init() {
+	if File_cmd_protoc_gen_go_testdata_imports_test_a_2_m3_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_cmd_protoc_gen_go_testdata_imports_test_a_2_m3_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*M3); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cmd_protoc_gen_go_testdata_imports_test_a_2_m3_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_cmd_protoc_gen_go_testdata_imports_test_a_2_m3_proto_goTypes,
+		DependencyIndexes: file_cmd_protoc_gen_go_testdata_imports_test_a_2_m3_proto_depIdxs,
+		MessageInfos:      file_cmd_protoc_gen_go_testdata_imports_test_a_2_m3_proto_msgTypes,
+	}.Build()
+	File_cmd_protoc_gen_go_testdata_imports_test_a_2_m3_proto = out.File
+	file_cmd_protoc_gen_go_testdata_imports_test_a_2_m3_proto_rawDesc = nil
+	file_cmd_protoc_gen_go_testdata_imports_test_a_2_m3_proto_goTypes = nil
+	file_cmd_protoc_gen_go_testdata_imports_test_a_2_m3_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_a_2/m3.proto b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_a_2/m3.proto
new file mode 100644
index 000000000..c9b3f3466
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_a_2/m3.proto
@@ -0,0 +1,8 @@
+// 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.
+
+syntax = "proto3";
+package test.a;
+option go_package = "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_a_2";
+message M3 {}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_a_2/m4.pb.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_a_2/m4.pb.go
new file mode 100644
index 000000000..be5ec6cf7
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_a_2/m4.pb.go
@@ -0,0 +1,131 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: cmd/protoc-gen-go/testdata/imports/test_a_2/m4.proto
+
+package test_a_2
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type M4 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *M4) Reset() {
+	*x = M4{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_imports_test_a_2_m4_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *M4) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*M4) ProtoMessage() {}
+
+func (x *M4) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_imports_test_a_2_m4_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use M4.ProtoReflect.Descriptor instead.
+func (*M4) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_imports_test_a_2_m4_proto_rawDescGZIP(), []int{0}
+}
+
+var File_cmd_protoc_gen_go_testdata_imports_test_a_2_m4_proto protoreflect.FileDescriptor
+
+var file_cmd_protoc_gen_go_testdata_imports_test_a_2_m4_proto_rawDesc = []byte{
+	0x0a, 0x34, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70,
+	0x6f, 0x72, 0x74, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x5f, 0x32, 0x2f, 0x6d, 0x34,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x06, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x61, 0x22, 0x04,
+	0x0a, 0x02, 0x4d, 0x34, 0x42, 0x48, 0x5a, 0x46, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67,
+	0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
+	0x75, 0x66, 0x2f, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65,
+	0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d,
+	0x70, 0x6f, 0x72, 0x74, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x5f, 0x32, 0x62, 0x06,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_cmd_protoc_gen_go_testdata_imports_test_a_2_m4_proto_rawDescOnce sync.Once
+	file_cmd_protoc_gen_go_testdata_imports_test_a_2_m4_proto_rawDescData = file_cmd_protoc_gen_go_testdata_imports_test_a_2_m4_proto_rawDesc
+)
+
+func file_cmd_protoc_gen_go_testdata_imports_test_a_2_m4_proto_rawDescGZIP() []byte {
+	file_cmd_protoc_gen_go_testdata_imports_test_a_2_m4_proto_rawDescOnce.Do(func() {
+		file_cmd_protoc_gen_go_testdata_imports_test_a_2_m4_proto_rawDescData = protoimpl.X.CompressGZIP(file_cmd_protoc_gen_go_testdata_imports_test_a_2_m4_proto_rawDescData)
+	})
+	return file_cmd_protoc_gen_go_testdata_imports_test_a_2_m4_proto_rawDescData
+}
+
+var file_cmd_protoc_gen_go_testdata_imports_test_a_2_m4_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_cmd_protoc_gen_go_testdata_imports_test_a_2_m4_proto_goTypes = []interface{}{
+	(*M4)(nil), // 0: test.a.M4
+}
+var file_cmd_protoc_gen_go_testdata_imports_test_a_2_m4_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_cmd_protoc_gen_go_testdata_imports_test_a_2_m4_proto_init() }
+func file_cmd_protoc_gen_go_testdata_imports_test_a_2_m4_proto_init() {
+	if File_cmd_protoc_gen_go_testdata_imports_test_a_2_m4_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_cmd_protoc_gen_go_testdata_imports_test_a_2_m4_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*M4); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cmd_protoc_gen_go_testdata_imports_test_a_2_m4_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_cmd_protoc_gen_go_testdata_imports_test_a_2_m4_proto_goTypes,
+		DependencyIndexes: file_cmd_protoc_gen_go_testdata_imports_test_a_2_m4_proto_depIdxs,
+		MessageInfos:      file_cmd_protoc_gen_go_testdata_imports_test_a_2_m4_proto_msgTypes,
+	}.Build()
+	File_cmd_protoc_gen_go_testdata_imports_test_a_2_m4_proto = out.File
+	file_cmd_protoc_gen_go_testdata_imports_test_a_2_m4_proto_rawDesc = nil
+	file_cmd_protoc_gen_go_testdata_imports_test_a_2_m4_proto_goTypes = nil
+	file_cmd_protoc_gen_go_testdata_imports_test_a_2_m4_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_a_2/m4.proto b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_a_2/m4.proto
new file mode 100644
index 000000000..248e07329
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_a_2/m4.proto
@@ -0,0 +1,8 @@
+// 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.
+
+syntax = "proto3";
+package test.a;
+option go_package = "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_a_2";
+message M4 {}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_b_1/m1.pb.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_b_1/m1.pb.go
new file mode 100644
index 000000000..238ee727b
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_b_1/m1.pb.go
@@ -0,0 +1,132 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: cmd/protoc-gen-go/testdata/imports/test_b_1/m1.proto
+
+package beta
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type M1 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *M1) Reset() {
+	*x = M1{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_imports_test_b_1_m1_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *M1) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*M1) ProtoMessage() {}
+
+func (x *M1) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_imports_test_b_1_m1_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use M1.ProtoReflect.Descriptor instead.
+func (*M1) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_imports_test_b_1_m1_proto_rawDescGZIP(), []int{0}
+}
+
+var File_cmd_protoc_gen_go_testdata_imports_test_b_1_m1_proto protoreflect.FileDescriptor
+
+var file_cmd_protoc_gen_go_testdata_imports_test_b_1_m1_proto_rawDesc = []byte{
+	0x0a, 0x34, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70,
+	0x6f, 0x72, 0x74, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x62, 0x5f, 0x31, 0x2f, 0x6d, 0x31,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0c, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x62, 0x2e, 0x70,
+	0x61, 0x72, 0x74, 0x31, 0x22, 0x04, 0x0a, 0x02, 0x4d, 0x31, 0x42, 0x4d, 0x5a, 0x4b, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64,
+	0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74,
+	0x5f, 0x62, 0x5f, 0x31, 0x3b, 0x62, 0x65, 0x74, 0x61, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x33,
+}
+
+var (
+	file_cmd_protoc_gen_go_testdata_imports_test_b_1_m1_proto_rawDescOnce sync.Once
+	file_cmd_protoc_gen_go_testdata_imports_test_b_1_m1_proto_rawDescData = file_cmd_protoc_gen_go_testdata_imports_test_b_1_m1_proto_rawDesc
+)
+
+func file_cmd_protoc_gen_go_testdata_imports_test_b_1_m1_proto_rawDescGZIP() []byte {
+	file_cmd_protoc_gen_go_testdata_imports_test_b_1_m1_proto_rawDescOnce.Do(func() {
+		file_cmd_protoc_gen_go_testdata_imports_test_b_1_m1_proto_rawDescData = protoimpl.X.CompressGZIP(file_cmd_protoc_gen_go_testdata_imports_test_b_1_m1_proto_rawDescData)
+	})
+	return file_cmd_protoc_gen_go_testdata_imports_test_b_1_m1_proto_rawDescData
+}
+
+var file_cmd_protoc_gen_go_testdata_imports_test_b_1_m1_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_cmd_protoc_gen_go_testdata_imports_test_b_1_m1_proto_goTypes = []interface{}{
+	(*M1)(nil), // 0: test.b.part1.M1
+}
+var file_cmd_protoc_gen_go_testdata_imports_test_b_1_m1_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_cmd_protoc_gen_go_testdata_imports_test_b_1_m1_proto_init() }
+func file_cmd_protoc_gen_go_testdata_imports_test_b_1_m1_proto_init() {
+	if File_cmd_protoc_gen_go_testdata_imports_test_b_1_m1_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_cmd_protoc_gen_go_testdata_imports_test_b_1_m1_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*M1); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cmd_protoc_gen_go_testdata_imports_test_b_1_m1_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_cmd_protoc_gen_go_testdata_imports_test_b_1_m1_proto_goTypes,
+		DependencyIndexes: file_cmd_protoc_gen_go_testdata_imports_test_b_1_m1_proto_depIdxs,
+		MessageInfos:      file_cmd_protoc_gen_go_testdata_imports_test_b_1_m1_proto_msgTypes,
+	}.Build()
+	File_cmd_protoc_gen_go_testdata_imports_test_b_1_m1_proto = out.File
+	file_cmd_protoc_gen_go_testdata_imports_test_b_1_m1_proto_rawDesc = nil
+	file_cmd_protoc_gen_go_testdata_imports_test_b_1_m1_proto_goTypes = nil
+	file_cmd_protoc_gen_go_testdata_imports_test_b_1_m1_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_b_1/m1.proto b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_b_1/m1.proto
new file mode 100644
index 000000000..77e0fc6e6
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_b_1/m1.proto
@@ -0,0 +1,8 @@
+// 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.
+
+syntax = "proto3";
+package test.b.part1;
+option go_package = "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_b_1;beta";
+message M1 {}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_b_1/m2.pb.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_b_1/m2.pb.go
new file mode 100644
index 000000000..72880135e
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_b_1/m2.pb.go
@@ -0,0 +1,132 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: cmd/protoc-gen-go/testdata/imports/test_b_1/m2.proto
+
+package beta
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type M2 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *M2) Reset() {
+	*x = M2{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_imports_test_b_1_m2_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *M2) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*M2) ProtoMessage() {}
+
+func (x *M2) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_imports_test_b_1_m2_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use M2.ProtoReflect.Descriptor instead.
+func (*M2) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_imports_test_b_1_m2_proto_rawDescGZIP(), []int{0}
+}
+
+var File_cmd_protoc_gen_go_testdata_imports_test_b_1_m2_proto protoreflect.FileDescriptor
+
+var file_cmd_protoc_gen_go_testdata_imports_test_b_1_m2_proto_rawDesc = []byte{
+	0x0a, 0x34, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70,
+	0x6f, 0x72, 0x74, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x62, 0x5f, 0x31, 0x2f, 0x6d, 0x32,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0c, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x62, 0x2e, 0x70,
+	0x61, 0x72, 0x74, 0x32, 0x22, 0x04, 0x0a, 0x02, 0x4d, 0x32, 0x42, 0x4d, 0x5a, 0x4b, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64,
+	0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74,
+	0x5f, 0x62, 0x5f, 0x31, 0x3b, 0x62, 0x65, 0x74, 0x61, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x33,
+}
+
+var (
+	file_cmd_protoc_gen_go_testdata_imports_test_b_1_m2_proto_rawDescOnce sync.Once
+	file_cmd_protoc_gen_go_testdata_imports_test_b_1_m2_proto_rawDescData = file_cmd_protoc_gen_go_testdata_imports_test_b_1_m2_proto_rawDesc
+)
+
+func file_cmd_protoc_gen_go_testdata_imports_test_b_1_m2_proto_rawDescGZIP() []byte {
+	file_cmd_protoc_gen_go_testdata_imports_test_b_1_m2_proto_rawDescOnce.Do(func() {
+		file_cmd_protoc_gen_go_testdata_imports_test_b_1_m2_proto_rawDescData = protoimpl.X.CompressGZIP(file_cmd_protoc_gen_go_testdata_imports_test_b_1_m2_proto_rawDescData)
+	})
+	return file_cmd_protoc_gen_go_testdata_imports_test_b_1_m2_proto_rawDescData
+}
+
+var file_cmd_protoc_gen_go_testdata_imports_test_b_1_m2_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_cmd_protoc_gen_go_testdata_imports_test_b_1_m2_proto_goTypes = []interface{}{
+	(*M2)(nil), // 0: test.b.part2.M2
+}
+var file_cmd_protoc_gen_go_testdata_imports_test_b_1_m2_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_cmd_protoc_gen_go_testdata_imports_test_b_1_m2_proto_init() }
+func file_cmd_protoc_gen_go_testdata_imports_test_b_1_m2_proto_init() {
+	if File_cmd_protoc_gen_go_testdata_imports_test_b_1_m2_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_cmd_protoc_gen_go_testdata_imports_test_b_1_m2_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*M2); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cmd_protoc_gen_go_testdata_imports_test_b_1_m2_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_cmd_protoc_gen_go_testdata_imports_test_b_1_m2_proto_goTypes,
+		DependencyIndexes: file_cmd_protoc_gen_go_testdata_imports_test_b_1_m2_proto_depIdxs,
+		MessageInfos:      file_cmd_protoc_gen_go_testdata_imports_test_b_1_m2_proto_msgTypes,
+	}.Build()
+	File_cmd_protoc_gen_go_testdata_imports_test_b_1_m2_proto = out.File
+	file_cmd_protoc_gen_go_testdata_imports_test_b_1_m2_proto_rawDesc = nil
+	file_cmd_protoc_gen_go_testdata_imports_test_b_1_m2_proto_goTypes = nil
+	file_cmd_protoc_gen_go_testdata_imports_test_b_1_m2_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_b_1/m2.proto b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_b_1/m2.proto
new file mode 100644
index 000000000..ed68630c6
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_b_1/m2.proto
@@ -0,0 +1,8 @@
+// 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.
+
+syntax = "proto3";
+package test.b.part2;
+option go_package = "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_b_1;beta";
+message M2 {}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_import_a1m1.pb.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_import_a1m1.pb.go
new file mode 100644
index 000000000..155c28505
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_import_a1m1.pb.go
@@ -0,0 +1,148 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: cmd/protoc-gen-go/testdata/imports/test_import_a1m1.proto
+
+package imports
+
+import (
+	test_a_1 "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_a_1"
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type A1M1 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	F *test_a_1.M1 `protobuf:"bytes,1,opt,name=f,proto3" json:"f,omitempty"`
+}
+
+func (x *A1M1) Reset() {
+	*x = A1M1{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_imports_test_import_a1m1_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *A1M1) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*A1M1) ProtoMessage() {}
+
+func (x *A1M1) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_imports_test_import_a1m1_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use A1M1.ProtoReflect.Descriptor instead.
+func (*A1M1) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_imports_test_import_a1m1_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *A1M1) GetF() *test_a_1.M1 {
+	if x != nil {
+		return x.F
+	}
+	return nil
+}
+
+var File_cmd_protoc_gen_go_testdata_imports_test_import_a1m1_proto protoreflect.FileDescriptor
+
+var file_cmd_protoc_gen_go_testdata_imports_test_import_a1m1_proto_rawDesc = []byte{
+	0x0a, 0x39, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70,
+	0x6f, 0x72, 0x74, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74,
+	0x5f, 0x61, 0x31, 0x6d, 0x31, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x04, 0x74, 0x65, 0x73,
+	0x74, 0x1a, 0x34, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65,
+	0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d,
+	0x70, 0x6f, 0x72, 0x74, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x5f, 0x31, 0x2f, 0x6d,
+	0x31, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x20, 0x0a, 0x04, 0x41, 0x31, 0x4d, 0x31, 0x12,
+	0x18, 0x0a, 0x01, 0x66, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0a, 0x2e, 0x74, 0x65, 0x73,
+	0x74, 0x2e, 0x61, 0x2e, 0x4d, 0x31, 0x52, 0x01, 0x66, 0x42, 0x3f, 0x5a, 0x3d, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61,
+	0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x33,
+}
+
+var (
+	file_cmd_protoc_gen_go_testdata_imports_test_import_a1m1_proto_rawDescOnce sync.Once
+	file_cmd_protoc_gen_go_testdata_imports_test_import_a1m1_proto_rawDescData = file_cmd_protoc_gen_go_testdata_imports_test_import_a1m1_proto_rawDesc
+)
+
+func file_cmd_protoc_gen_go_testdata_imports_test_import_a1m1_proto_rawDescGZIP() []byte {
+	file_cmd_protoc_gen_go_testdata_imports_test_import_a1m1_proto_rawDescOnce.Do(func() {
+		file_cmd_protoc_gen_go_testdata_imports_test_import_a1m1_proto_rawDescData = protoimpl.X.CompressGZIP(file_cmd_protoc_gen_go_testdata_imports_test_import_a1m1_proto_rawDescData)
+	})
+	return file_cmd_protoc_gen_go_testdata_imports_test_import_a1m1_proto_rawDescData
+}
+
+var file_cmd_protoc_gen_go_testdata_imports_test_import_a1m1_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_cmd_protoc_gen_go_testdata_imports_test_import_a1m1_proto_goTypes = []interface{}{
+	(*A1M1)(nil),        // 0: test.A1M1
+	(*test_a_1.M1)(nil), // 1: test.a.M1
+}
+var file_cmd_protoc_gen_go_testdata_imports_test_import_a1m1_proto_depIdxs = []int32{
+	1, // 0: test.A1M1.f:type_name -> test.a.M1
+	1, // [1:1] is the sub-list for method output_type
+	1, // [1:1] is the sub-list for method input_type
+	1, // [1:1] is the sub-list for extension type_name
+	1, // [1:1] is the sub-list for extension extendee
+	0, // [0:1] is the sub-list for field type_name
+}
+
+func init() { file_cmd_protoc_gen_go_testdata_imports_test_import_a1m1_proto_init() }
+func file_cmd_protoc_gen_go_testdata_imports_test_import_a1m1_proto_init() {
+	if File_cmd_protoc_gen_go_testdata_imports_test_import_a1m1_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_cmd_protoc_gen_go_testdata_imports_test_import_a1m1_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*A1M1); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cmd_protoc_gen_go_testdata_imports_test_import_a1m1_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_cmd_protoc_gen_go_testdata_imports_test_import_a1m1_proto_goTypes,
+		DependencyIndexes: file_cmd_protoc_gen_go_testdata_imports_test_import_a1m1_proto_depIdxs,
+		MessageInfos:      file_cmd_protoc_gen_go_testdata_imports_test_import_a1m1_proto_msgTypes,
+	}.Build()
+	File_cmd_protoc_gen_go_testdata_imports_test_import_a1m1_proto = out.File
+	file_cmd_protoc_gen_go_testdata_imports_test_import_a1m1_proto_rawDesc = nil
+	file_cmd_protoc_gen_go_testdata_imports_test_import_a1m1_proto_goTypes = nil
+	file_cmd_protoc_gen_go_testdata_imports_test_import_a1m1_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_import_a1m1.proto b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_import_a1m1.proto
new file mode 100644
index 000000000..670e62e2e
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_import_a1m1.proto
@@ -0,0 +1,15 @@
+// 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.
+
+syntax = "proto3";
+
+package test;
+
+option go_package = "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports";
+
+import "cmd/protoc-gen-go/testdata/imports/test_a_1/m1.proto";
+
+message A1M1 {
+  test.a.M1 f = 1;
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_import_a1m2.pb.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_import_a1m2.pb.go
new file mode 100644
index 000000000..bbb0cfbaa
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_import_a1m2.pb.go
@@ -0,0 +1,148 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: cmd/protoc-gen-go/testdata/imports/test_import_a1m2.proto
+
+package imports
+
+import (
+	test_a_1 "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_a_1"
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type A1M2 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	F *test_a_1.M2 `protobuf:"bytes,1,opt,name=f,proto3" json:"f,omitempty"`
+}
+
+func (x *A1M2) Reset() {
+	*x = A1M2{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_imports_test_import_a1m2_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *A1M2) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*A1M2) ProtoMessage() {}
+
+func (x *A1M2) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_imports_test_import_a1m2_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use A1M2.ProtoReflect.Descriptor instead.
+func (*A1M2) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_imports_test_import_a1m2_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *A1M2) GetF() *test_a_1.M2 {
+	if x != nil {
+		return x.F
+	}
+	return nil
+}
+
+var File_cmd_protoc_gen_go_testdata_imports_test_import_a1m2_proto protoreflect.FileDescriptor
+
+var file_cmd_protoc_gen_go_testdata_imports_test_import_a1m2_proto_rawDesc = []byte{
+	0x0a, 0x39, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70,
+	0x6f, 0x72, 0x74, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74,
+	0x5f, 0x61, 0x31, 0x6d, 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x04, 0x74, 0x65, 0x73,
+	0x74, 0x1a, 0x34, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65,
+	0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d,
+	0x70, 0x6f, 0x72, 0x74, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x5f, 0x31, 0x2f, 0x6d,
+	0x32, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x20, 0x0a, 0x04, 0x41, 0x31, 0x4d, 0x32, 0x12,
+	0x18, 0x0a, 0x01, 0x66, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0a, 0x2e, 0x74, 0x65, 0x73,
+	0x74, 0x2e, 0x61, 0x2e, 0x4d, 0x32, 0x52, 0x01, 0x66, 0x42, 0x3f, 0x5a, 0x3d, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61,
+	0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x33,
+}
+
+var (
+	file_cmd_protoc_gen_go_testdata_imports_test_import_a1m2_proto_rawDescOnce sync.Once
+	file_cmd_protoc_gen_go_testdata_imports_test_import_a1m2_proto_rawDescData = file_cmd_protoc_gen_go_testdata_imports_test_import_a1m2_proto_rawDesc
+)
+
+func file_cmd_protoc_gen_go_testdata_imports_test_import_a1m2_proto_rawDescGZIP() []byte {
+	file_cmd_protoc_gen_go_testdata_imports_test_import_a1m2_proto_rawDescOnce.Do(func() {
+		file_cmd_protoc_gen_go_testdata_imports_test_import_a1m2_proto_rawDescData = protoimpl.X.CompressGZIP(file_cmd_protoc_gen_go_testdata_imports_test_import_a1m2_proto_rawDescData)
+	})
+	return file_cmd_protoc_gen_go_testdata_imports_test_import_a1m2_proto_rawDescData
+}
+
+var file_cmd_protoc_gen_go_testdata_imports_test_import_a1m2_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_cmd_protoc_gen_go_testdata_imports_test_import_a1m2_proto_goTypes = []interface{}{
+	(*A1M2)(nil),        // 0: test.A1M2
+	(*test_a_1.M2)(nil), // 1: test.a.M2
+}
+var file_cmd_protoc_gen_go_testdata_imports_test_import_a1m2_proto_depIdxs = []int32{
+	1, // 0: test.A1M2.f:type_name -> test.a.M2
+	1, // [1:1] is the sub-list for method output_type
+	1, // [1:1] is the sub-list for method input_type
+	1, // [1:1] is the sub-list for extension type_name
+	1, // [1:1] is the sub-list for extension extendee
+	0, // [0:1] is the sub-list for field type_name
+}
+
+func init() { file_cmd_protoc_gen_go_testdata_imports_test_import_a1m2_proto_init() }
+func file_cmd_protoc_gen_go_testdata_imports_test_import_a1m2_proto_init() {
+	if File_cmd_protoc_gen_go_testdata_imports_test_import_a1m2_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_cmd_protoc_gen_go_testdata_imports_test_import_a1m2_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*A1M2); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cmd_protoc_gen_go_testdata_imports_test_import_a1m2_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_cmd_protoc_gen_go_testdata_imports_test_import_a1m2_proto_goTypes,
+		DependencyIndexes: file_cmd_protoc_gen_go_testdata_imports_test_import_a1m2_proto_depIdxs,
+		MessageInfos:      file_cmd_protoc_gen_go_testdata_imports_test_import_a1m2_proto_msgTypes,
+	}.Build()
+	File_cmd_protoc_gen_go_testdata_imports_test_import_a1m2_proto = out.File
+	file_cmd_protoc_gen_go_testdata_imports_test_import_a1m2_proto_rawDesc = nil
+	file_cmd_protoc_gen_go_testdata_imports_test_import_a1m2_proto_goTypes = nil
+	file_cmd_protoc_gen_go_testdata_imports_test_import_a1m2_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_import_a1m2.proto b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_import_a1m2.proto
new file mode 100644
index 000000000..8cef2809e
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_import_a1m2.proto
@@ -0,0 +1,15 @@
+// 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.
+
+syntax = "proto3";
+
+package test;
+
+option go_package = "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports";
+
+import "cmd/protoc-gen-go/testdata/imports/test_a_1/m2.proto";
+
+message A1M2 {
+  test.a.M2 f = 1;
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_import_all.pb.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_import_all.pb.go
new file mode 100644
index 000000000..288e52468
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_import_all.pb.go
@@ -0,0 +1,219 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: cmd/protoc-gen-go/testdata/imports/test_import_all.proto
+
+package imports
+
+import (
+	fmt "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/fmt"
+	test_a_1 "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_a_1"
+	_ "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_a_2"
+	test_b_1 "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_b_1"
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type All struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Am1 *test_a_1.M1 `protobuf:"bytes,1,opt,name=am1,proto3" json:"am1,omitempty"`
+	Am2 *test_a_1.M2 `protobuf:"bytes,2,opt,name=am2,proto3" json:"am2,omitempty"`
+	Bm1 *test_b_1.M1 `protobuf:"bytes,5,opt,name=bm1,proto3" json:"bm1,omitempty"`
+	Bm2 *test_b_1.M2 `protobuf:"bytes,6,opt,name=bm2,proto3" json:"bm2,omitempty"`
+	Fmt *fmt.M       `protobuf:"bytes,7,opt,name=fmt,proto3" json:"fmt,omitempty"`
+}
+
+func (x *All) Reset() {
+	*x = All{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_imports_test_import_all_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *All) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*All) ProtoMessage() {}
+
+func (x *All) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_imports_test_import_all_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use All.ProtoReflect.Descriptor instead.
+func (*All) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_imports_test_import_all_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *All) GetAm1() *test_a_1.M1 {
+	if x != nil {
+		return x.Am1
+	}
+	return nil
+}
+
+func (x *All) GetAm2() *test_a_1.M2 {
+	if x != nil {
+		return x.Am2
+	}
+	return nil
+}
+
+func (x *All) GetBm1() *test_b_1.M1 {
+	if x != nil {
+		return x.Bm1
+	}
+	return nil
+}
+
+func (x *All) GetBm2() *test_b_1.M2 {
+	if x != nil {
+		return x.Bm2
+	}
+	return nil
+}
+
+func (x *All) GetFmt() *fmt.M {
+	if x != nil {
+		return x.Fmt
+	}
+	return nil
+}
+
+var File_cmd_protoc_gen_go_testdata_imports_test_import_all_proto protoreflect.FileDescriptor
+
+var file_cmd_protoc_gen_go_testdata_imports_test_import_all_proto_rawDesc = []byte{
+	0x0a, 0x38, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70,
+	0x6f, 0x72, 0x74, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74,
+	0x5f, 0x61, 0x6c, 0x6c, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x04, 0x74, 0x65, 0x73, 0x74,
+	0x1a, 0x34, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70,
+	0x6f, 0x72, 0x74, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x5f, 0x31, 0x2f, 0x6d, 0x31,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x34, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61,
+	0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x5f,
+	0x61, 0x5f, 0x31, 0x2f, 0x6d, 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x34, 0x63, 0x6d,
+	0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f,
+	0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x73,
+	0x2f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x5f, 0x32, 0x2f, 0x6d, 0x33, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x1a, 0x34, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67,
+	0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x69,
+	0x6d, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x5f, 0x32, 0x2f,
+	0x6d, 0x34, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x34, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74,
+	0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x2f, 0x74, 0x65, 0x73,
+	0x74, 0x5f, 0x62, 0x5f, 0x31, 0x2f, 0x6d, 0x31, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x34,
+	0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67,
+	0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70, 0x6f, 0x72,
+	0x74, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x62, 0x5f, 0x31, 0x2f, 0x6d, 0x32, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x2e, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63,
+	0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61,
+	0x2f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x2f, 0x66, 0x6d, 0x74, 0x2f, 0x6d, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x22, 0xa3, 0x01, 0x0a, 0x03, 0x41, 0x6c, 0x6c, 0x12, 0x1c, 0x0a, 0x03,
+	0x61, 0x6d, 0x31, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0a, 0x2e, 0x74, 0x65, 0x73, 0x74,
+	0x2e, 0x61, 0x2e, 0x4d, 0x31, 0x52, 0x03, 0x61, 0x6d, 0x31, 0x12, 0x1c, 0x0a, 0x03, 0x61, 0x6d,
+	0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0a, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x61,
+	0x2e, 0x4d, 0x32, 0x52, 0x03, 0x61, 0x6d, 0x32, 0x12, 0x22, 0x0a, 0x03, 0x62, 0x6d, 0x31, 0x18,
+	0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x62, 0x2e, 0x70,
+	0x61, 0x72, 0x74, 0x31, 0x2e, 0x4d, 0x31, 0x52, 0x03, 0x62, 0x6d, 0x31, 0x12, 0x22, 0x0a, 0x03,
+	0x62, 0x6d, 0x32, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x74, 0x65, 0x73, 0x74,
+	0x2e, 0x62, 0x2e, 0x70, 0x61, 0x72, 0x74, 0x32, 0x2e, 0x4d, 0x32, 0x52, 0x03, 0x62, 0x6d, 0x32,
+	0x12, 0x18, 0x0a, 0x03, 0x66, 0x6d, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x06, 0x2e,
+	0x66, 0x6d, 0x74, 0x2e, 0x4d, 0x52, 0x03, 0x66, 0x6d, 0x74, 0x42, 0x3f, 0x5a, 0x3d, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64,
+	0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x33,
+}
+
+var (
+	file_cmd_protoc_gen_go_testdata_imports_test_import_all_proto_rawDescOnce sync.Once
+	file_cmd_protoc_gen_go_testdata_imports_test_import_all_proto_rawDescData = file_cmd_protoc_gen_go_testdata_imports_test_import_all_proto_rawDesc
+)
+
+func file_cmd_protoc_gen_go_testdata_imports_test_import_all_proto_rawDescGZIP() []byte {
+	file_cmd_protoc_gen_go_testdata_imports_test_import_all_proto_rawDescOnce.Do(func() {
+		file_cmd_protoc_gen_go_testdata_imports_test_import_all_proto_rawDescData = protoimpl.X.CompressGZIP(file_cmd_protoc_gen_go_testdata_imports_test_import_all_proto_rawDescData)
+	})
+	return file_cmd_protoc_gen_go_testdata_imports_test_import_all_proto_rawDescData
+}
+
+var file_cmd_protoc_gen_go_testdata_imports_test_import_all_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_cmd_protoc_gen_go_testdata_imports_test_import_all_proto_goTypes = []interface{}{
+	(*All)(nil),         // 0: test.All
+	(*test_a_1.M1)(nil), // 1: test.a.M1
+	(*test_a_1.M2)(nil), // 2: test.a.M2
+	(*test_b_1.M1)(nil), // 3: test.b.part1.M1
+	(*test_b_1.M2)(nil), // 4: test.b.part2.M2
+	(*fmt.M)(nil),       // 5: fmt.M
+}
+var file_cmd_protoc_gen_go_testdata_imports_test_import_all_proto_depIdxs = []int32{
+	1, // 0: test.All.am1:type_name -> test.a.M1
+	2, // 1: test.All.am2:type_name -> test.a.M2
+	3, // 2: test.All.bm1:type_name -> test.b.part1.M1
+	4, // 3: test.All.bm2:type_name -> test.b.part2.M2
+	5, // 4: test.All.fmt:type_name -> fmt.M
+	5, // [5:5] is the sub-list for method output_type
+	5, // [5:5] is the sub-list for method input_type
+	5, // [5:5] is the sub-list for extension type_name
+	5, // [5:5] is the sub-list for extension extendee
+	0, // [0:5] is the sub-list for field type_name
+}
+
+func init() { file_cmd_protoc_gen_go_testdata_imports_test_import_all_proto_init() }
+func file_cmd_protoc_gen_go_testdata_imports_test_import_all_proto_init() {
+	if File_cmd_protoc_gen_go_testdata_imports_test_import_all_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_cmd_protoc_gen_go_testdata_imports_test_import_all_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*All); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cmd_protoc_gen_go_testdata_imports_test_import_all_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_cmd_protoc_gen_go_testdata_imports_test_import_all_proto_goTypes,
+		DependencyIndexes: file_cmd_protoc_gen_go_testdata_imports_test_import_all_proto_depIdxs,
+		MessageInfos:      file_cmd_protoc_gen_go_testdata_imports_test_import_all_proto_msgTypes,
+	}.Build()
+	File_cmd_protoc_gen_go_testdata_imports_test_import_all_proto = out.File
+	file_cmd_protoc_gen_go_testdata_imports_test_import_all_proto_rawDesc = nil
+	file_cmd_protoc_gen_go_testdata_imports_test_import_all_proto_goTypes = nil
+	file_cmd_protoc_gen_go_testdata_imports_test_import_all_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_import_all.proto b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_import_all.proto
new file mode 100644
index 000000000..3909f2de5
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports/test_import_all.proto
@@ -0,0 +1,29 @@
+// 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.
+
+syntax = "proto3";
+
+package test;
+
+option go_package = "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/imports";
+
+// test_a_1/m*.proto are in the same Go package and proto package.
+// test_a_*/*.proto are in different Go packages, but the same proto package.
+// test_b_1/*.proto are in the same Go package, but different proto packages.
+// fmt/m.proto has a package name which conflicts with "fmt".
+import "cmd/protoc-gen-go/testdata/imports/test_a_1/m1.proto";
+import "cmd/protoc-gen-go/testdata/imports/test_a_1/m2.proto";
+import "cmd/protoc-gen-go/testdata/imports/test_a_2/m3.proto"; // unused in this file
+import "cmd/protoc-gen-go/testdata/imports/test_a_2/m4.proto"; // unused in this file
+import "cmd/protoc-gen-go/testdata/imports/test_b_1/m1.proto";
+import "cmd/protoc-gen-go/testdata/imports/test_b_1/m2.proto";
+import "cmd/protoc-gen-go/testdata/imports/fmt/m.proto";
+
+message All {
+  test.a.M1 am1 = 1;
+  test.a.M2 am2 = 2;
+  test.b.part1.M1 bm1 = 5;
+  test.b.part2.M2 bm2 = 6;
+  fmt.M fmt = 7;
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/issue780_oneof_conflict/test.pb.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/issue780_oneof_conflict/test.pb.go
new file mode 100644
index 000000000..e4164c583
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/issue780_oneof_conflict/test.pb.go
@@ -0,0 +1,165 @@
+// Copyright 2020 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: cmd/protoc-gen-go/testdata/issue780_oneof_conflict/test.proto
+
+package issue780_oneof_conflict
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type Foo struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// Types that are assignable to Bar:
+	//	*Foo_GetBar
+	Bar isFoo_Bar `protobuf_oneof:"bar"`
+}
+
+func (x *Foo) Reset() {
+	*x = Foo{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_issue780_oneof_conflict_test_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Foo) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Foo) ProtoMessage() {}
+
+func (x *Foo) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_issue780_oneof_conflict_test_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Foo.ProtoReflect.Descriptor instead.
+func (*Foo) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_issue780_oneof_conflict_test_proto_rawDescGZIP(), []int{0}
+}
+
+func (m *Foo) GetBar() isFoo_Bar {
+	if m != nil {
+		return m.Bar
+	}
+	return nil
+}
+
+func (x *Foo) GetGetBar() string {
+	if x, ok := x.GetBar().(*Foo_GetBar); ok {
+		return x.GetBar
+	}
+	return ""
+}
+
+type isFoo_Bar interface {
+	isFoo_Bar()
+}
+
+type Foo_GetBar struct {
+	GetBar string `protobuf:"bytes,1,opt,name=get_bar,json=getBar,oneof"`
+}
+
+func (*Foo_GetBar) isFoo_Bar() {}
+
+var File_cmd_protoc_gen_go_testdata_issue780_oneof_conflict_test_proto protoreflect.FileDescriptor
+
+var file_cmd_protoc_gen_go_testdata_issue780_oneof_conflict_test_proto_rawDesc = []byte{
+	0x0a, 0x3d, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x73, 0x73,
+	0x75, 0x65, 0x37, 0x38, 0x30, 0x5f, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x63, 0x6f, 0x6e, 0x66,
+	0x6c, 0x69, 0x63, 0x74, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12,
+	0x09, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x74, 0x65, 0x73, 0x74, 0x22, 0x27, 0x0a, 0x03, 0x46, 0x6f,
+	0x6f, 0x12, 0x19, 0x0a, 0x07, 0x67, 0x65, 0x74, 0x5f, 0x62, 0x61, 0x72, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x09, 0x48, 0x00, 0x52, 0x06, 0x67, 0x65, 0x74, 0x42, 0x61, 0x72, 0x42, 0x05, 0x0a, 0x03,
+	0x62, 0x61, 0x72, 0x42, 0x4f, 0x5a, 0x4d, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f,
+	0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x2f, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x69, 0x73, 0x73,
+	0x75, 0x65, 0x37, 0x38, 0x30, 0x5f, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x63, 0x6f, 0x6e, 0x66,
+	0x6c, 0x69, 0x63, 0x74,
+}
+
+var (
+	file_cmd_protoc_gen_go_testdata_issue780_oneof_conflict_test_proto_rawDescOnce sync.Once
+	file_cmd_protoc_gen_go_testdata_issue780_oneof_conflict_test_proto_rawDescData = file_cmd_protoc_gen_go_testdata_issue780_oneof_conflict_test_proto_rawDesc
+)
+
+func file_cmd_protoc_gen_go_testdata_issue780_oneof_conflict_test_proto_rawDescGZIP() []byte {
+	file_cmd_protoc_gen_go_testdata_issue780_oneof_conflict_test_proto_rawDescOnce.Do(func() {
+		file_cmd_protoc_gen_go_testdata_issue780_oneof_conflict_test_proto_rawDescData = protoimpl.X.CompressGZIP(file_cmd_protoc_gen_go_testdata_issue780_oneof_conflict_test_proto_rawDescData)
+	})
+	return file_cmd_protoc_gen_go_testdata_issue780_oneof_conflict_test_proto_rawDescData
+}
+
+var file_cmd_protoc_gen_go_testdata_issue780_oneof_conflict_test_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_cmd_protoc_gen_go_testdata_issue780_oneof_conflict_test_proto_goTypes = []interface{}{
+	(*Foo)(nil), // 0: oneoftest.Foo
+}
+var file_cmd_protoc_gen_go_testdata_issue780_oneof_conflict_test_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_cmd_protoc_gen_go_testdata_issue780_oneof_conflict_test_proto_init() }
+func file_cmd_protoc_gen_go_testdata_issue780_oneof_conflict_test_proto_init() {
+	if File_cmd_protoc_gen_go_testdata_issue780_oneof_conflict_test_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_cmd_protoc_gen_go_testdata_issue780_oneof_conflict_test_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Foo); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	file_cmd_protoc_gen_go_testdata_issue780_oneof_conflict_test_proto_msgTypes[0].OneofWrappers = []interface{}{
+		(*Foo_GetBar)(nil),
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cmd_protoc_gen_go_testdata_issue780_oneof_conflict_test_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_cmd_protoc_gen_go_testdata_issue780_oneof_conflict_test_proto_goTypes,
+		DependencyIndexes: file_cmd_protoc_gen_go_testdata_issue780_oneof_conflict_test_proto_depIdxs,
+		MessageInfos:      file_cmd_protoc_gen_go_testdata_issue780_oneof_conflict_test_proto_msgTypes,
+	}.Build()
+	File_cmd_protoc_gen_go_testdata_issue780_oneof_conflict_test_proto = out.File
+	file_cmd_protoc_gen_go_testdata_issue780_oneof_conflict_test_proto_rawDesc = nil
+	file_cmd_protoc_gen_go_testdata_issue780_oneof_conflict_test_proto_goTypes = nil
+	file_cmd_protoc_gen_go_testdata_issue780_oneof_conflict_test_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/issue780_oneof_conflict/test.proto b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/issue780_oneof_conflict/test.proto
new file mode 100644
index 000000000..d6d269da2
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/issue780_oneof_conflict/test.proto
@@ -0,0 +1,15 @@
+// Copyright 2020 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.
+
+syntax = "proto2";
+
+package oneoftest;
+
+option go_package = "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/issue780_oneof_conflict";
+
+message Foo {
+	oneof bar { // must be generated as Bar field in Foo struct
+		string get_bar = 1;
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/nopackage/nopackage.pb.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/nopackage/nopackage.pb.go
new file mode 100644
index 000000000..a81e00194
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/nopackage/nopackage.pb.go
@@ -0,0 +1,211 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: cmd/protoc-gen-go/testdata/nopackage/nopackage.proto
+
+package nopackage
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type Enum int32
+
+const (
+	Enum_ZERO Enum = 0
+)
+
+// Enum value maps for Enum.
+var (
+	Enum_name = map[int32]string{
+		0: "ZERO",
+	}
+	Enum_value = map[string]int32{
+		"ZERO": 0,
+	}
+)
+
+func (x Enum) Enum() *Enum {
+	p := new(Enum)
+	*p = x
+	return p
+}
+
+func (x Enum) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum) Descriptor() protoreflect.EnumDescriptor {
+	return file_cmd_protoc_gen_go_testdata_nopackage_nopackage_proto_enumTypes[0].Descriptor()
+}
+
+func (Enum) Type() protoreflect.EnumType {
+	return &file_cmd_protoc_gen_go_testdata_nopackage_nopackage_proto_enumTypes[0]
+}
+
+func (x Enum) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum(num)
+	return nil
+}
+
+// Deprecated: Use Enum.Descriptor instead.
+func (Enum) EnumDescriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_nopackage_nopackage_proto_rawDescGZIP(), []int{0}
+}
+
+type Message struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	StringField *string `protobuf:"bytes,1,opt,name=string_field,json=stringField" json:"string_field,omitempty"`
+	EnumField   *Enum   `protobuf:"varint,2,opt,name=enum_field,json=enumField,enum=Enum,def=0" json:"enum_field,omitempty"`
+}
+
+// Default values for Message fields.
+const (
+	Default_Message_EnumField = Enum_ZERO
+)
+
+func (x *Message) Reset() {
+	*x = Message{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_nopackage_nopackage_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message) ProtoMessage() {}
+
+func (x *Message) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_nopackage_nopackage_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message.ProtoReflect.Descriptor instead.
+func (*Message) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_nopackage_nopackage_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Message) GetStringField() string {
+	if x != nil && x.StringField != nil {
+		return *x.StringField
+	}
+	return ""
+}
+
+func (x *Message) GetEnumField() Enum {
+	if x != nil && x.EnumField != nil {
+		return *x.EnumField
+	}
+	return Default_Message_EnumField
+}
+
+var File_cmd_protoc_gen_go_testdata_nopackage_nopackage_proto protoreflect.FileDescriptor
+
+var file_cmd_protoc_gen_go_testdata_nopackage_nopackage_proto_rawDesc = []byte{
+	0x0a, 0x34, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x6e, 0x6f, 0x70,
+	0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x2f, 0x6e, 0x6f, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x58, 0x0a, 0x07, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x46,
+	0x69, 0x65, 0x6c, 0x64, 0x12, 0x2a, 0x0a, 0x0a, 0x65, 0x6e, 0x75, 0x6d, 0x5f, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x05, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x3a,
+	0x04, 0x5a, 0x45, 0x52, 0x4f, 0x52, 0x09, 0x65, 0x6e, 0x75, 0x6d, 0x46, 0x69, 0x65, 0x6c, 0x64,
+	0x2a, 0x10, 0x0a, 0x04, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x08, 0x0a, 0x04, 0x5a, 0x45, 0x52, 0x4f,
+	0x10, 0x00,
+}
+
+var (
+	file_cmd_protoc_gen_go_testdata_nopackage_nopackage_proto_rawDescOnce sync.Once
+	file_cmd_protoc_gen_go_testdata_nopackage_nopackage_proto_rawDescData = file_cmd_protoc_gen_go_testdata_nopackage_nopackage_proto_rawDesc
+)
+
+func file_cmd_protoc_gen_go_testdata_nopackage_nopackage_proto_rawDescGZIP() []byte {
+	file_cmd_protoc_gen_go_testdata_nopackage_nopackage_proto_rawDescOnce.Do(func() {
+		file_cmd_protoc_gen_go_testdata_nopackage_nopackage_proto_rawDescData = protoimpl.X.CompressGZIP(file_cmd_protoc_gen_go_testdata_nopackage_nopackage_proto_rawDescData)
+	})
+	return file_cmd_protoc_gen_go_testdata_nopackage_nopackage_proto_rawDescData
+}
+
+var file_cmd_protoc_gen_go_testdata_nopackage_nopackage_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
+var file_cmd_protoc_gen_go_testdata_nopackage_nopackage_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_cmd_protoc_gen_go_testdata_nopackage_nopackage_proto_goTypes = []interface{}{
+	(Enum)(0),       // 0: Enum
+	(*Message)(nil), // 1: Message
+}
+var file_cmd_protoc_gen_go_testdata_nopackage_nopackage_proto_depIdxs = []int32{
+	0, // 0: Message.enum_field:type_name -> Enum
+	1, // [1:1] is the sub-list for method output_type
+	1, // [1:1] is the sub-list for method input_type
+	1, // [1:1] is the sub-list for extension type_name
+	1, // [1:1] is the sub-list for extension extendee
+	0, // [0:1] is the sub-list for field type_name
+}
+
+func init() { file_cmd_protoc_gen_go_testdata_nopackage_nopackage_proto_init() }
+func file_cmd_protoc_gen_go_testdata_nopackage_nopackage_proto_init() {
+	if File_cmd_protoc_gen_go_testdata_nopackage_nopackage_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_cmd_protoc_gen_go_testdata_nopackage_nopackage_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cmd_protoc_gen_go_testdata_nopackage_nopackage_proto_rawDesc,
+			NumEnums:      1,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_cmd_protoc_gen_go_testdata_nopackage_nopackage_proto_goTypes,
+		DependencyIndexes: file_cmd_protoc_gen_go_testdata_nopackage_nopackage_proto_depIdxs,
+		EnumInfos:         file_cmd_protoc_gen_go_testdata_nopackage_nopackage_proto_enumTypes,
+		MessageInfos:      file_cmd_protoc_gen_go_testdata_nopackage_nopackage_proto_msgTypes,
+	}.Build()
+	File_cmd_protoc_gen_go_testdata_nopackage_nopackage_proto = out.File
+	file_cmd_protoc_gen_go_testdata_nopackage_nopackage_proto_rawDesc = nil
+	file_cmd_protoc_gen_go_testdata_nopackage_nopackage_proto_goTypes = nil
+	file_cmd_protoc_gen_go_testdata_nopackage_nopackage_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/nopackage/nopackage.proto b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/nopackage/nopackage.proto
new file mode 100644
index 000000000..892bb0662
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/nopackage/nopackage.proto
@@ -0,0 +1,16 @@
+// 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.
+
+syntax = "proto2";
+
+// File contains no 'package' statement.
+
+enum Enum {
+  ZERO = 0;
+}
+
+message Message {
+  optional string string_field = 1;
+  optional Enum   enum_field   = 2 [default=ZERO];
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto2/enum.pb.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto2/enum.pb.go
new file mode 100644
index 000000000..c031b3938
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto2/enum.pb.go
@@ -0,0 +1,577 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: cmd/protoc-gen-go/testdata/proto2/enum.proto
+
+package proto2
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+// EnumType1 comment.
+type EnumType1 int32
+
+const (
+	// EnumType1_ONE comment.
+	EnumType1_ONE EnumType1 = 1
+	// EnumType1_TWO comment.
+	EnumType1_TWO EnumType1 = 2
+)
+
+// Enum value maps for EnumType1.
+var (
+	EnumType1_name = map[int32]string{
+		1: "ONE",
+		2: "TWO",
+	}
+	EnumType1_value = map[string]int32{
+		"ONE": 1,
+		"TWO": 2,
+	}
+)
+
+func (x EnumType1) Enum() *EnumType1 {
+	p := new(EnumType1)
+	*p = x
+	return p
+}
+
+func (x EnumType1) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (EnumType1) Descriptor() protoreflect.EnumDescriptor {
+	return file_cmd_protoc_gen_go_testdata_proto2_enum_proto_enumTypes[0].Descriptor()
+}
+
+func (EnumType1) Type() protoreflect.EnumType {
+	return &file_cmd_protoc_gen_go_testdata_proto2_enum_proto_enumTypes[0]
+}
+
+func (x EnumType1) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *EnumType1) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = EnumType1(num)
+	return nil
+}
+
+// Deprecated: Use EnumType1.Descriptor instead.
+func (EnumType1) EnumDescriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_proto2_enum_proto_rawDescGZIP(), []int{0}
+}
+
+type EnumType2 int32
+
+const (
+	EnumType2_duplicate1 EnumType2 = 1
+	EnumType2_duplicate2 EnumType2 = 1
+)
+
+// Enum value maps for EnumType2.
+var (
+	EnumType2_name = map[int32]string{
+		1: "duplicate1",
+		// Duplicate value: 1: "duplicate2",
+	}
+	EnumType2_value = map[string]int32{
+		"duplicate1": 1,
+		"duplicate2": 1,
+	}
+)
+
+func (x EnumType2) Enum() *EnumType2 {
+	p := new(EnumType2)
+	*p = x
+	return p
+}
+
+func (x EnumType2) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (EnumType2) Descriptor() protoreflect.EnumDescriptor {
+	return file_cmd_protoc_gen_go_testdata_proto2_enum_proto_enumTypes[1].Descriptor()
+}
+
+func (EnumType2) Type() protoreflect.EnumType {
+	return &file_cmd_protoc_gen_go_testdata_proto2_enum_proto_enumTypes[1]
+}
+
+func (x EnumType2) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *EnumType2) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = EnumType2(num)
+	return nil
+}
+
+// Deprecated: Use EnumType2.Descriptor instead.
+func (EnumType2) EnumDescriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_proto2_enum_proto_rawDescGZIP(), []int{1}
+}
+
+// NestedEnumType1A comment.
+type EnumContainerMessage1_NestedEnumType1A int32
+
+const (
+	// NestedEnumType1A_VALUE comment.
+	EnumContainerMessage1_NESTED_1A_VALUE EnumContainerMessage1_NestedEnumType1A = 0
+)
+
+// Enum value maps for EnumContainerMessage1_NestedEnumType1A.
+var (
+	EnumContainerMessage1_NestedEnumType1A_name = map[int32]string{
+		0: "NESTED_1A_VALUE",
+	}
+	EnumContainerMessage1_NestedEnumType1A_value = map[string]int32{
+		"NESTED_1A_VALUE": 0,
+	}
+)
+
+func (x EnumContainerMessage1_NestedEnumType1A) Enum() *EnumContainerMessage1_NestedEnumType1A {
+	p := new(EnumContainerMessage1_NestedEnumType1A)
+	*p = x
+	return p
+}
+
+func (x EnumContainerMessage1_NestedEnumType1A) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (EnumContainerMessage1_NestedEnumType1A) Descriptor() protoreflect.EnumDescriptor {
+	return file_cmd_protoc_gen_go_testdata_proto2_enum_proto_enumTypes[2].Descriptor()
+}
+
+func (EnumContainerMessage1_NestedEnumType1A) Type() protoreflect.EnumType {
+	return &file_cmd_protoc_gen_go_testdata_proto2_enum_proto_enumTypes[2]
+}
+
+func (x EnumContainerMessage1_NestedEnumType1A) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *EnumContainerMessage1_NestedEnumType1A) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = EnumContainerMessage1_NestedEnumType1A(num)
+	return nil
+}
+
+// Deprecated: Use EnumContainerMessage1_NestedEnumType1A.Descriptor instead.
+func (EnumContainerMessage1_NestedEnumType1A) EnumDescriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_proto2_enum_proto_rawDescGZIP(), []int{0, 0}
+}
+
+type EnumContainerMessage1_NestedEnumType1B int32
+
+const (
+	EnumContainerMessage1_NESTED_1B_VALUE EnumContainerMessage1_NestedEnumType1B = 0
+)
+
+// Enum value maps for EnumContainerMessage1_NestedEnumType1B.
+var (
+	EnumContainerMessage1_NestedEnumType1B_name = map[int32]string{
+		0: "NESTED_1B_VALUE",
+	}
+	EnumContainerMessage1_NestedEnumType1B_value = map[string]int32{
+		"NESTED_1B_VALUE": 0,
+	}
+)
+
+func (x EnumContainerMessage1_NestedEnumType1B) Enum() *EnumContainerMessage1_NestedEnumType1B {
+	p := new(EnumContainerMessage1_NestedEnumType1B)
+	*p = x
+	return p
+}
+
+func (x EnumContainerMessage1_NestedEnumType1B) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (EnumContainerMessage1_NestedEnumType1B) Descriptor() protoreflect.EnumDescriptor {
+	return file_cmd_protoc_gen_go_testdata_proto2_enum_proto_enumTypes[3].Descriptor()
+}
+
+func (EnumContainerMessage1_NestedEnumType1B) Type() protoreflect.EnumType {
+	return &file_cmd_protoc_gen_go_testdata_proto2_enum_proto_enumTypes[3]
+}
+
+func (x EnumContainerMessage1_NestedEnumType1B) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *EnumContainerMessage1_NestedEnumType1B) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = EnumContainerMessage1_NestedEnumType1B(num)
+	return nil
+}
+
+// Deprecated: Use EnumContainerMessage1_NestedEnumType1B.Descriptor instead.
+func (EnumContainerMessage1_NestedEnumType1B) EnumDescriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_proto2_enum_proto_rawDescGZIP(), []int{0, 1}
+}
+
+// NestedEnumType2A comment.
+type EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2A int32
+
+const (
+	// NestedEnumType2A_VALUE comment.
+	EnumContainerMessage1_EnumContainerMessage2_NESTED_2A_VALUE EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2A = 0
+)
+
+// Enum value maps for EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2A.
+var (
+	EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2A_name = map[int32]string{
+		0: "NESTED_2A_VALUE",
+	}
+	EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2A_value = map[string]int32{
+		"NESTED_2A_VALUE": 0,
+	}
+)
+
+func (x EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2A) Enum() *EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2A {
+	p := new(EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2A)
+	*p = x
+	return p
+}
+
+func (x EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2A) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2A) Descriptor() protoreflect.EnumDescriptor {
+	return file_cmd_protoc_gen_go_testdata_proto2_enum_proto_enumTypes[4].Descriptor()
+}
+
+func (EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2A) Type() protoreflect.EnumType {
+	return &file_cmd_protoc_gen_go_testdata_proto2_enum_proto_enumTypes[4]
+}
+
+func (x EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2A) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2A) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2A(num)
+	return nil
+}
+
+// Deprecated: Use EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2A.Descriptor instead.
+func (EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2A) EnumDescriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_proto2_enum_proto_rawDescGZIP(), []int{0, 0, 0}
+}
+
+type EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2B int32
+
+const (
+	EnumContainerMessage1_EnumContainerMessage2_NESTED_2B_VALUE EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2B = 0
+)
+
+// Enum value maps for EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2B.
+var (
+	EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2B_name = map[int32]string{
+		0: "NESTED_2B_VALUE",
+	}
+	EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2B_value = map[string]int32{
+		"NESTED_2B_VALUE": 0,
+	}
+)
+
+func (x EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2B) Enum() *EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2B {
+	p := new(EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2B)
+	*p = x
+	return p
+}
+
+func (x EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2B) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2B) Descriptor() protoreflect.EnumDescriptor {
+	return file_cmd_protoc_gen_go_testdata_proto2_enum_proto_enumTypes[5].Descriptor()
+}
+
+func (EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2B) Type() protoreflect.EnumType {
+	return &file_cmd_protoc_gen_go_testdata_proto2_enum_proto_enumTypes[5]
+}
+
+func (x EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2B) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2B) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2B(num)
+	return nil
+}
+
+// Deprecated: Use EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2B.Descriptor instead.
+func (EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2B) EnumDescriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_proto2_enum_proto_rawDescGZIP(), []int{0, 0, 1}
+}
+
+type EnumContainerMessage1 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	DefaultDuplicate1 *EnumType2 `protobuf:"varint,1,opt,name=default_duplicate1,json=defaultDuplicate1,enum=goproto.protoc.proto2.EnumType2,def=1" json:"default_duplicate1,omitempty"`
+	DefaultDuplicate2 *EnumType2 `protobuf:"varint,2,opt,name=default_duplicate2,json=defaultDuplicate2,enum=goproto.protoc.proto2.EnumType2,def=1" json:"default_duplicate2,omitempty"`
+}
+
+// Default values for EnumContainerMessage1 fields.
+const (
+	Default_EnumContainerMessage1_DefaultDuplicate1 = EnumType2_duplicate1
+	Default_EnumContainerMessage1_DefaultDuplicate2 = EnumType2_duplicate2
+)
+
+func (x *EnumContainerMessage1) Reset() {
+	*x = EnumContainerMessage1{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_proto2_enum_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *EnumContainerMessage1) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*EnumContainerMessage1) ProtoMessage() {}
+
+func (x *EnumContainerMessage1) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_proto2_enum_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use EnumContainerMessage1.ProtoReflect.Descriptor instead.
+func (*EnumContainerMessage1) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_proto2_enum_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *EnumContainerMessage1) GetDefaultDuplicate1() EnumType2 {
+	if x != nil && x.DefaultDuplicate1 != nil {
+		return *x.DefaultDuplicate1
+	}
+	return Default_EnumContainerMessage1_DefaultDuplicate1
+}
+
+func (x *EnumContainerMessage1) GetDefaultDuplicate2() EnumType2 {
+	if x != nil && x.DefaultDuplicate2 != nil {
+		return *x.DefaultDuplicate2
+	}
+	return Default_EnumContainerMessage1_DefaultDuplicate2
+}
+
+type EnumContainerMessage1_EnumContainerMessage2 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *EnumContainerMessage1_EnumContainerMessage2) Reset() {
+	*x = EnumContainerMessage1_EnumContainerMessage2{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_proto2_enum_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *EnumContainerMessage1_EnumContainerMessage2) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*EnumContainerMessage1_EnumContainerMessage2) ProtoMessage() {}
+
+func (x *EnumContainerMessage1_EnumContainerMessage2) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_proto2_enum_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use EnumContainerMessage1_EnumContainerMessage2.ProtoReflect.Descriptor instead.
+func (*EnumContainerMessage1_EnumContainerMessage2) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_proto2_enum_proto_rawDescGZIP(), []int{0, 0}
+}
+
+var File_cmd_protoc_gen_go_testdata_proto2_enum_proto protoreflect.FileDescriptor
+
+var file_cmd_protoc_gen_go_testdata_proto2_enum_proto_rawDesc = []byte{
+	0x0a, 0x2c, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x32, 0x2f, 0x65, 0x6e, 0x75, 0x6d, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x15,
+	0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x32, 0x22, 0x8e, 0x03, 0x0a, 0x15, 0x45, 0x6e, 0x75, 0x6d, 0x43, 0x6f,
+	0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x12,
+	0x5b, 0x0a, 0x12, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x64, 0x75, 0x70, 0x6c, 0x69,
+	0x63, 0x61, 0x74, 0x65, 0x31, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x20, 0x2e, 0x67, 0x6f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x32, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x54, 0x79, 0x70, 0x65, 0x32, 0x3a, 0x0a, 0x64,
+	0x75, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x65, 0x31, 0x52, 0x11, 0x64, 0x65, 0x66, 0x61, 0x75,
+	0x6c, 0x74, 0x44, 0x75, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x65, 0x31, 0x12, 0x5b, 0x0a, 0x12,
+	0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x64, 0x75, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74,
+	0x65, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x20, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32,
+	0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x54, 0x79, 0x70, 0x65, 0x32, 0x3a, 0x0a, 0x64, 0x75, 0x70, 0x6c,
+	0x69, 0x63, 0x61, 0x74, 0x65, 0x32, 0x52, 0x11, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x44,
+	0x75, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x65, 0x32, 0x1a, 0x69, 0x0a, 0x15, 0x45, 0x6e, 0x75,
+	0x6d, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x32, 0x22, 0x27, 0x0a, 0x10, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d,
+	0x54, 0x79, 0x70, 0x65, 0x32, 0x41, 0x12, 0x13, 0x0a, 0x0f, 0x4e, 0x45, 0x53, 0x54, 0x45, 0x44,
+	0x5f, 0x32, 0x41, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x10, 0x00, 0x22, 0x27, 0x0a, 0x10, 0x4e,
+	0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x54, 0x79, 0x70, 0x65, 0x32, 0x42, 0x12,
+	0x13, 0x0a, 0x0f, 0x4e, 0x45, 0x53, 0x54, 0x45, 0x44, 0x5f, 0x32, 0x42, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x10, 0x00, 0x22, 0x27, 0x0a, 0x10, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e,
+	0x75, 0x6d, 0x54, 0x79, 0x70, 0x65, 0x31, 0x41, 0x12, 0x13, 0x0a, 0x0f, 0x4e, 0x45, 0x53, 0x54,
+	0x45, 0x44, 0x5f, 0x31, 0x41, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x10, 0x00, 0x22, 0x27, 0x0a,
+	0x10, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x54, 0x79, 0x70, 0x65, 0x31,
+	0x42, 0x12, 0x13, 0x0a, 0x0f, 0x4e, 0x45, 0x53, 0x54, 0x45, 0x44, 0x5f, 0x31, 0x42, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x10, 0x00, 0x2a, 0x1d, 0x0a, 0x09, 0x45, 0x6e, 0x75, 0x6d, 0x54, 0x79,
+	0x70, 0x65, 0x31, 0x12, 0x07, 0x0a, 0x03, 0x4f, 0x4e, 0x45, 0x10, 0x01, 0x12, 0x07, 0x0a, 0x03,
+	0x54, 0x57, 0x4f, 0x10, 0x02, 0x2a, 0x51, 0x0a, 0x09, 0x45, 0x6e, 0x75, 0x6d, 0x54, 0x79, 0x70,
+	0x65, 0x32, 0x12, 0x0e, 0x0a, 0x0a, 0x64, 0x75, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x65, 0x31,
+	0x10, 0x01, 0x12, 0x0e, 0x0a, 0x0a, 0x64, 0x75, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x65, 0x32,
+	0x10, 0x01, 0x1a, 0x02, 0x10, 0x01, 0x22, 0x04, 0x08, 0x02, 0x10, 0x02, 0x22, 0x04, 0x08, 0x03,
+	0x10, 0x03, 0x2a, 0x09, 0x52, 0x45, 0x53, 0x45, 0x52, 0x56, 0x45, 0x44, 0x31, 0x2a, 0x09, 0x52,
+	0x45, 0x53, 0x45, 0x52, 0x56, 0x45, 0x44, 0x32, 0x42, 0x3e, 0x5a, 0x3c, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74,
+	0x61, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32,
+}
+
+var (
+	file_cmd_protoc_gen_go_testdata_proto2_enum_proto_rawDescOnce sync.Once
+	file_cmd_protoc_gen_go_testdata_proto2_enum_proto_rawDescData = file_cmd_protoc_gen_go_testdata_proto2_enum_proto_rawDesc
+)
+
+func file_cmd_protoc_gen_go_testdata_proto2_enum_proto_rawDescGZIP() []byte {
+	file_cmd_protoc_gen_go_testdata_proto2_enum_proto_rawDescOnce.Do(func() {
+		file_cmd_protoc_gen_go_testdata_proto2_enum_proto_rawDescData = protoimpl.X.CompressGZIP(file_cmd_protoc_gen_go_testdata_proto2_enum_proto_rawDescData)
+	})
+	return file_cmd_protoc_gen_go_testdata_proto2_enum_proto_rawDescData
+}
+
+var file_cmd_protoc_gen_go_testdata_proto2_enum_proto_enumTypes = make([]protoimpl.EnumInfo, 6)
+var file_cmd_protoc_gen_go_testdata_proto2_enum_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
+var file_cmd_protoc_gen_go_testdata_proto2_enum_proto_goTypes = []interface{}{
+	(EnumType1)(0), // 0: goproto.protoc.proto2.EnumType1
+	(EnumType2)(0), // 1: goproto.protoc.proto2.EnumType2
+	(EnumContainerMessage1_NestedEnumType1A)(0),                       // 2: goproto.protoc.proto2.EnumContainerMessage1.NestedEnumType1A
+	(EnumContainerMessage1_NestedEnumType1B)(0),                       // 3: goproto.protoc.proto2.EnumContainerMessage1.NestedEnumType1B
+	(EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2A)(0), // 4: goproto.protoc.proto2.EnumContainerMessage1.EnumContainerMessage2.NestedEnumType2A
+	(EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2B)(0), // 5: goproto.protoc.proto2.EnumContainerMessage1.EnumContainerMessage2.NestedEnumType2B
+	(*EnumContainerMessage1)(nil),                                     // 6: goproto.protoc.proto2.EnumContainerMessage1
+	(*EnumContainerMessage1_EnumContainerMessage2)(nil),               // 7: goproto.protoc.proto2.EnumContainerMessage1.EnumContainerMessage2
+}
+var file_cmd_protoc_gen_go_testdata_proto2_enum_proto_depIdxs = []int32{
+	1, // 0: goproto.protoc.proto2.EnumContainerMessage1.default_duplicate1:type_name -> goproto.protoc.proto2.EnumType2
+	1, // 1: goproto.protoc.proto2.EnumContainerMessage1.default_duplicate2:type_name -> goproto.protoc.proto2.EnumType2
+	2, // [2:2] is the sub-list for method output_type
+	2, // [2:2] is the sub-list for method input_type
+	2, // [2:2] is the sub-list for extension type_name
+	2, // [2:2] is the sub-list for extension extendee
+	0, // [0:2] is the sub-list for field type_name
+}
+
+func init() { file_cmd_protoc_gen_go_testdata_proto2_enum_proto_init() }
+func file_cmd_protoc_gen_go_testdata_proto2_enum_proto_init() {
+	if File_cmd_protoc_gen_go_testdata_proto2_enum_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_cmd_protoc_gen_go_testdata_proto2_enum_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*EnumContainerMessage1); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cmd_protoc_gen_go_testdata_proto2_enum_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*EnumContainerMessage1_EnumContainerMessage2); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cmd_protoc_gen_go_testdata_proto2_enum_proto_rawDesc,
+			NumEnums:      6,
+			NumMessages:   2,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_cmd_protoc_gen_go_testdata_proto2_enum_proto_goTypes,
+		DependencyIndexes: file_cmd_protoc_gen_go_testdata_proto2_enum_proto_depIdxs,
+		EnumInfos:         file_cmd_protoc_gen_go_testdata_proto2_enum_proto_enumTypes,
+		MessageInfos:      file_cmd_protoc_gen_go_testdata_proto2_enum_proto_msgTypes,
+	}.Build()
+	File_cmd_protoc_gen_go_testdata_proto2_enum_proto = out.File
+	file_cmd_protoc_gen_go_testdata_proto2_enum_proto_rawDesc = nil
+	file_cmd_protoc_gen_go_testdata_proto2_enum_proto_goTypes = nil
+	file_cmd_protoc_gen_go_testdata_proto2_enum_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto2/enum.proto b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto2/enum.proto
new file mode 100644
index 000000000..c30c8ecfa
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto2/enum.proto
@@ -0,0 +1,54 @@
+// 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.
+
+syntax = "proto2";
+
+package goproto.protoc.proto2;
+
+option go_package = "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto2";
+
+// EnumType1 comment.
+enum EnumType1 {
+  // EnumType1_ONE comment.
+  ONE = 1;
+  // EnumType1_TWO comment.
+  TWO = 2;
+}
+
+enum EnumType2 {
+  option allow_alias = true;
+  duplicate1 = 1;
+  duplicate2 = 1;
+
+  reserved "RESERVED1";
+  reserved "RESERVED2";
+  reserved 2, 3;
+}
+
+message EnumContainerMessage1 {
+  optional EnumType2 default_duplicate1 = 1 [default=duplicate1];
+  optional EnumType2 default_duplicate2 = 2 [default=duplicate2];
+
+  // NestedEnumType1A comment.
+  enum NestedEnumType1A {
+    // NestedEnumType1A_VALUE comment.
+    NESTED_1A_VALUE = 0;
+  }
+
+  enum NestedEnumType1B {
+    NESTED_1B_VALUE = 0;
+  }
+
+  message EnumContainerMessage2 {
+    // NestedEnumType2A comment.
+    enum NestedEnumType2A {
+      // NestedEnumType2A_VALUE comment.
+      NESTED_2A_VALUE = 0;
+    }
+
+    enum NestedEnumType2B {
+      NESTED_2B_VALUE = 0;
+    }
+  }
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto2/fields.pb.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto2/fields.pb.go
new file mode 100644
index 000000000..bb979ac74
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto2/fields.pb.go
@@ -0,0 +1,1889 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: cmd/protoc-gen-go/testdata/proto2/fields.proto
+
+package proto2
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	math "math"
+	reflect "reflect"
+	sync "sync"
+)
+
+type FieldTestMessage_Enum int32
+
+const (
+	FieldTestMessage_ZERO FieldTestMessage_Enum = 0
+	FieldTestMessage_ONE  FieldTestMessage_Enum = 1
+)
+
+// Enum value maps for FieldTestMessage_Enum.
+var (
+	FieldTestMessage_Enum_name = map[int32]string{
+		0: "ZERO",
+		1: "ONE",
+	}
+	FieldTestMessage_Enum_value = map[string]int32{
+		"ZERO": 0,
+		"ONE":  1,
+	}
+)
+
+func (x FieldTestMessage_Enum) Enum() *FieldTestMessage_Enum {
+	p := new(FieldTestMessage_Enum)
+	*p = x
+	return p
+}
+
+func (x FieldTestMessage_Enum) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (FieldTestMessage_Enum) Descriptor() protoreflect.EnumDescriptor {
+	return file_cmd_protoc_gen_go_testdata_proto2_fields_proto_enumTypes[0].Descriptor()
+}
+
+func (FieldTestMessage_Enum) Type() protoreflect.EnumType {
+	return &file_cmd_protoc_gen_go_testdata_proto2_fields_proto_enumTypes[0]
+}
+
+func (x FieldTestMessage_Enum) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *FieldTestMessage_Enum) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = FieldTestMessage_Enum(num)
+	return nil
+}
+
+// Deprecated: Use FieldTestMessage_Enum.Descriptor instead.
+func (FieldTestMessage_Enum) EnumDescriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_proto2_fields_proto_rawDescGZIP(), []int{0, 0}
+}
+
+type FieldTestMessage struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	OptionalBool        *bool                                `protobuf:"varint,1,opt,name=optional_bool,json=optionalBool" json:"optional_bool,omitempty"`
+	OptionalEnum        *FieldTestMessage_Enum               `protobuf:"varint,2,opt,name=optional_enum,json=optionalEnum,enum=goproto.protoc.proto2.FieldTestMessage_Enum" json:"optional_enum,omitempty"`
+	OptionalInt32       *int32                               `protobuf:"varint,3,opt,name=optional_int32,json=optionalInt32" json:"optional_int32,omitempty"`
+	OptionalSint32      *int32                               `protobuf:"zigzag32,4,opt,name=optional_sint32,json=optionalSint32" json:"optional_sint32,omitempty"`
+	OptionalUint32      *uint32                              `protobuf:"varint,5,opt,name=optional_uint32,json=optionalUint32" json:"optional_uint32,omitempty"`
+	OptionalInt64       *int64                               `protobuf:"varint,6,opt,name=optional_int64,json=optionalInt64" json:"optional_int64,omitempty"`
+	OptionalSint64      *int64                               `protobuf:"zigzag64,7,opt,name=optional_sint64,json=optionalSint64" json:"optional_sint64,omitempty"`
+	OptionalUint64      *uint64                              `protobuf:"varint,8,opt,name=optional_uint64,json=optionalUint64" json:"optional_uint64,omitempty"`
+	OptionalSfixed32    *int32                               `protobuf:"fixed32,9,opt,name=optional_sfixed32,json=optionalSfixed32" json:"optional_sfixed32,omitempty"`
+	OptionalFixed32     *uint32                              `protobuf:"fixed32,10,opt,name=optional_fixed32,json=optionalFixed32" json:"optional_fixed32,omitempty"`
+	OptionalFloat       *float32                             `protobuf:"fixed32,11,opt,name=optional_float,json=optionalFloat" json:"optional_float,omitempty"`
+	OptionalSfixed64    *int64                               `protobuf:"fixed64,12,opt,name=optional_sfixed64,json=optionalSfixed64" json:"optional_sfixed64,omitempty"`
+	OptionalFixed64     *uint64                              `protobuf:"fixed64,13,opt,name=optional_fixed64,json=optionalFixed64" json:"optional_fixed64,omitempty"`
+	OptionalDouble      *float64                             `protobuf:"fixed64,14,opt,name=optional_double,json=optionalDouble" json:"optional_double,omitempty"`
+	OptionalString      *string                              `protobuf:"bytes,15,opt,name=optional_string,json=optionalString" json:"optional_string,omitempty"`
+	OptionalBytes       []byte                               `protobuf:"bytes,16,opt,name=optional_bytes,json=optionalBytes" json:"optional_bytes,omitempty"`
+	Optional_Message    *FieldTestMessage_Message            `protobuf:"bytes,17,opt,name=optional_Message,json=optionalMessage" json:"optional_Message,omitempty"`
+	Optionalgroup       *FieldTestMessage_OptionalGroup      `protobuf:"group,18,opt,name=OptionalGroup,json=optionalgroup" json:"optionalgroup,omitempty"`
+	RequiredBool        *bool                                `protobuf:"varint,101,req,name=required_bool,json=requiredBool" json:"required_bool,omitempty"`
+	RequiredEnum        *FieldTestMessage_Enum               `protobuf:"varint,102,req,name=required_enum,json=requiredEnum,enum=goproto.protoc.proto2.FieldTestMessage_Enum" json:"required_enum,omitempty"`
+	RequiredInt32       *int32                               `protobuf:"varint,103,req,name=required_int32,json=requiredInt32" json:"required_int32,omitempty"`
+	RequiredSint32      *int32                               `protobuf:"zigzag32,104,req,name=required_sint32,json=requiredSint32" json:"required_sint32,omitempty"`
+	RequiredUint32      *uint32                              `protobuf:"varint,105,req,name=required_uint32,json=requiredUint32" json:"required_uint32,omitempty"`
+	RequiredInt64       *int64                               `protobuf:"varint,106,req,name=required_int64,json=requiredInt64" json:"required_int64,omitempty"`
+	RequiredSint64      *int64                               `protobuf:"zigzag64,107,req,name=required_sint64,json=requiredSint64" json:"required_sint64,omitempty"`
+	RequiredUint64      *uint64                              `protobuf:"varint,108,req,name=required_uint64,json=requiredUint64" json:"required_uint64,omitempty"`
+	RequiredSfixed32    *int32                               `protobuf:"fixed32,109,req,name=required_sfixed32,json=requiredSfixed32" json:"required_sfixed32,omitempty"`
+	RequiredFixed32     *uint32                              `protobuf:"fixed32,110,req,name=required_fixed32,json=requiredFixed32" json:"required_fixed32,omitempty"`
+	RequiredFloat       *float32                             `protobuf:"fixed32,111,req,name=required_float,json=requiredFloat" json:"required_float,omitempty"`
+	RequiredSfixed64    *int64                               `protobuf:"fixed64,112,req,name=required_sfixed64,json=requiredSfixed64" json:"required_sfixed64,omitempty"`
+	RequiredFixed64     *uint64                              `protobuf:"fixed64,113,req,name=required_fixed64,json=requiredFixed64" json:"required_fixed64,omitempty"`
+	RequiredDouble      *float64                             `protobuf:"fixed64,114,req,name=required_double,json=requiredDouble" json:"required_double,omitempty"`
+	RequiredString      *string                              `protobuf:"bytes,115,req,name=required_string,json=requiredString" json:"required_string,omitempty"`
+	RequiredBytes       []byte                               `protobuf:"bytes,116,req,name=required_bytes,json=requiredBytes" json:"required_bytes,omitempty"`
+	Required_Message    *FieldTestMessage_Message            `protobuf:"bytes,117,req,name=required_Message,json=requiredMessage" json:"required_Message,omitempty"`
+	Requiredgroup       *FieldTestMessage_RequiredGroup      `protobuf:"group,118,req,name=RequiredGroup,json=requiredgroup" json:"requiredgroup,omitempty"`
+	RepeatedBool        []bool                               `protobuf:"varint,201,rep,name=repeated_bool,json=repeatedBool" json:"repeated_bool,omitempty"`
+	RepeatedEnum        []FieldTestMessage_Enum              `protobuf:"varint,202,rep,name=repeated_enum,json=repeatedEnum,enum=goproto.protoc.proto2.FieldTestMessage_Enum" json:"repeated_enum,omitempty"`
+	RepeatedInt32       []int32                              `protobuf:"varint,203,rep,name=repeated_int32,json=repeatedInt32" json:"repeated_int32,omitempty"`
+	RepeatedSint32      []int32                              `protobuf:"zigzag32,204,rep,name=repeated_sint32,json=repeatedSint32" json:"repeated_sint32,omitempty"`
+	RepeatedUint32      []uint32                             `protobuf:"varint,205,rep,name=repeated_uint32,json=repeatedUint32" json:"repeated_uint32,omitempty"`
+	RepeatedInt64       []int64                              `protobuf:"varint,206,rep,name=repeated_int64,json=repeatedInt64" json:"repeated_int64,omitempty"`
+	RepeatedSint64      []int64                              `protobuf:"zigzag64,207,rep,name=repeated_sint64,json=repeatedSint64" json:"repeated_sint64,omitempty"`
+	RepeatedUint64      []uint64                             `protobuf:"varint,208,rep,name=repeated_uint64,json=repeatedUint64" json:"repeated_uint64,omitempty"`
+	RepeatedSfixed32    []int32                              `protobuf:"fixed32,209,rep,name=repeated_sfixed32,json=repeatedSfixed32" json:"repeated_sfixed32,omitempty"`
+	RepeatedFixed32     []uint32                             `protobuf:"fixed32,210,rep,name=repeated_fixed32,json=repeatedFixed32" json:"repeated_fixed32,omitempty"`
+	RepeatedFloat       []float32                            `protobuf:"fixed32,211,rep,name=repeated_float,json=repeatedFloat" json:"repeated_float,omitempty"`
+	RepeatedSfixed64    []int64                              `protobuf:"fixed64,212,rep,name=repeated_sfixed64,json=repeatedSfixed64" json:"repeated_sfixed64,omitempty"`
+	RepeatedFixed64     []uint64                             `protobuf:"fixed64,213,rep,name=repeated_fixed64,json=repeatedFixed64" json:"repeated_fixed64,omitempty"`
+	RepeatedDouble      []float64                            `protobuf:"fixed64,214,rep,name=repeated_double,json=repeatedDouble" json:"repeated_double,omitempty"`
+	RepeatedString      []string                             `protobuf:"bytes,215,rep,name=repeated_string,json=repeatedString" json:"repeated_string,omitempty"`
+	RepeatedBytes       [][]byte                             `protobuf:"bytes,216,rep,name=repeated_bytes,json=repeatedBytes" json:"repeated_bytes,omitempty"`
+	Repeated_Message    []*FieldTestMessage_Message          `protobuf:"bytes,217,rep,name=repeated_Message,json=repeatedMessage" json:"repeated_Message,omitempty"`
+	Repeatedgroup       []*FieldTestMessage_RepeatedGroup    `protobuf:"group,218,rep,name=RepeatedGroup,json=repeatedgroup" json:"repeatedgroup,omitempty"`
+	DefaultBool         *bool                                `protobuf:"varint,301,opt,name=default_bool,json=defaultBool,def=1" json:"default_bool,omitempty"`
+	DefaultEnum         *FieldTestMessage_Enum               `protobuf:"varint,302,opt,name=default_enum,json=defaultEnum,enum=goproto.protoc.proto2.FieldTestMessage_Enum,def=1" json:"default_enum,omitempty"`
+	DefaultInt32        *int32                               `protobuf:"varint,303,opt,name=default_int32,json=defaultInt32,def=1" json:"default_int32,omitempty"`
+	DefaultSint32       *int32                               `protobuf:"zigzag32,304,opt,name=default_sint32,json=defaultSint32,def=1" json:"default_sint32,omitempty"`
+	DefaultUint32       *uint32                              `protobuf:"varint,305,opt,name=default_uint32,json=defaultUint32,def=1" json:"default_uint32,omitempty"`
+	DefaultInt64        *int64                               `protobuf:"varint,306,opt,name=default_int64,json=defaultInt64,def=1" json:"default_int64,omitempty"`
+	DefaultSint64       *int64                               `protobuf:"zigzag64,307,opt,name=default_sint64,json=defaultSint64,def=1" json:"default_sint64,omitempty"`
+	DefaultUint64       *uint64                              `protobuf:"varint,308,opt,name=default_uint64,json=defaultUint64,def=1" json:"default_uint64,omitempty"`
+	DefaultSfixed32     *int32                               `protobuf:"fixed32,309,opt,name=default_sfixed32,json=defaultSfixed32,def=1" json:"default_sfixed32,omitempty"`
+	DefaultFixed32      *uint32                              `protobuf:"fixed32,310,opt,name=default_fixed32,json=defaultFixed32,def=1" json:"default_fixed32,omitempty"`
+	DefaultFloat        *float32                             `protobuf:"fixed32,311,opt,name=default_float,json=defaultFloat,def=3.14" json:"default_float,omitempty"`
+	DefaultSfixed64     *int64                               `protobuf:"fixed64,312,opt,name=default_sfixed64,json=defaultSfixed64,def=1" json:"default_sfixed64,omitempty"`
+	DefaultFixed64      *uint64                              `protobuf:"fixed64,313,opt,name=default_fixed64,json=defaultFixed64,def=1" json:"default_fixed64,omitempty"`
+	DefaultDouble       *float64                             `protobuf:"fixed64,314,opt,name=default_double,json=defaultDouble,def=3.1415" json:"default_double,omitempty"`
+	DefaultString       *string                              `protobuf:"bytes,315,opt,name=default_string,json=defaultString,def=hello,\"world!\"\n" json:"default_string,omitempty"`
+	DefaultBytes        []byte                               `protobuf:"bytes,316,opt,name=default_bytes,json=defaultBytes,def=hello,\\336\\255\\276\\357" json:"default_bytes,omitempty"`
+	DefaultZeroString   *string                              `protobuf:"bytes,350,opt,name=default_zero_string,json=defaultZeroString,def=" json:"default_zero_string,omitempty"`
+	DefaultZeroBytes    []byte                               `protobuf:"bytes,351,opt,name=default_zero_bytes,json=defaultZeroBytes,def=" json:"default_zero_bytes,omitempty"`
+	DefaultFloatNeginf  *float32                             `protobuf:"fixed32,400,opt,name=default_float_neginf,json=defaultFloatNeginf,def=-inf" json:"default_float_neginf,omitempty"`
+	DefaultFloatPosinf  *float32                             `protobuf:"fixed32,401,opt,name=default_float_posinf,json=defaultFloatPosinf,def=inf" json:"default_float_posinf,omitempty"`
+	DefaultFloatNan     *float32                             `protobuf:"fixed32,402,opt,name=default_float_nan,json=defaultFloatNan,def=nan" json:"default_float_nan,omitempty"`
+	DefaultDoubleNeginf *float64                             `protobuf:"fixed64,403,opt,name=default_double_neginf,json=defaultDoubleNeginf,def=-inf" json:"default_double_neginf,omitempty"`
+	DefaultDoublePosinf *float64                             `protobuf:"fixed64,404,opt,name=default_double_posinf,json=defaultDoublePosinf,def=inf" json:"default_double_posinf,omitempty"`
+	DefaultDoubleNan    *float64                             `protobuf:"fixed64,405,opt,name=default_double_nan,json=defaultDoubleNan,def=nan" json:"default_double_nan,omitempty"`
+	MapInt32Int64       map[int32]int64                      `protobuf:"bytes,500,rep,name=map_int32_int64,json=mapInt32Int64" json:"map_int32_int64,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
+	MapStringMessage    map[string]*FieldTestMessage_Message `protobuf:"bytes,501,rep,name=map_string_message,json=mapStringMessage" json:"map_string_message,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+	MapFixed64Enum      map[uint64]FieldTestMessage_Enum     `protobuf:"bytes,502,rep,name=map_fixed64_enum,json=mapFixed64Enum" json:"map_fixed64_enum,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=goproto.protoc.proto2.FieldTestMessage_Enum"`
+	// Types that are assignable to OneofField:
+	//	*FieldTestMessage_OneofBool
+	//	*FieldTestMessage_OneofEnum
+	//	*FieldTestMessage_OneofInt32
+	//	*FieldTestMessage_OneofSint32
+	//	*FieldTestMessage_OneofUint32
+	//	*FieldTestMessage_OneofInt64
+	//	*FieldTestMessage_OneofSint64
+	//	*FieldTestMessage_OneofUint64
+	//	*FieldTestMessage_OneofSfixed32
+	//	*FieldTestMessage_OneofFixed32
+	//	*FieldTestMessage_OneofFloat
+	//	*FieldTestMessage_OneofSfixed64
+	//	*FieldTestMessage_OneofFixed64
+	//	*FieldTestMessage_OneofDouble
+	//	*FieldTestMessage_OneofString
+	//	*FieldTestMessage_OneofBytes
+	//	*FieldTestMessage_Oneof_Message
+	//	*FieldTestMessage_Oneofgroup
+	//	*FieldTestMessage_OneofLargestTag
+	OneofField isFieldTestMessage_OneofField `protobuf_oneof:"oneof_field"`
+	// Types that are assignable to OneofTwo:
+	//	*FieldTestMessage_OneofTwo_1
+	//	*FieldTestMessage_OneofTwo_2
+	OneofTwo isFieldTestMessage_OneofTwo `protobuf_oneof:"oneof_two"`
+}
+
+// Default values for FieldTestMessage fields.
+const (
+	Default_FieldTestMessage_DefaultBool       = bool(true)
+	Default_FieldTestMessage_DefaultEnum       = FieldTestMessage_ONE
+	Default_FieldTestMessage_DefaultInt32      = int32(1)
+	Default_FieldTestMessage_DefaultSint32     = int32(1)
+	Default_FieldTestMessage_DefaultUint32     = uint32(1)
+	Default_FieldTestMessage_DefaultInt64      = int64(1)
+	Default_FieldTestMessage_DefaultSint64     = int64(1)
+	Default_FieldTestMessage_DefaultUint64     = uint64(1)
+	Default_FieldTestMessage_DefaultSfixed32   = int32(1)
+	Default_FieldTestMessage_DefaultFixed32    = uint32(1)
+	Default_FieldTestMessage_DefaultFloat      = float32(3.140000104904175)
+	Default_FieldTestMessage_DefaultSfixed64   = int64(1)
+	Default_FieldTestMessage_DefaultFixed64    = uint64(1)
+	Default_FieldTestMessage_DefaultDouble     = float64(3.1415)
+	Default_FieldTestMessage_DefaultString     = string("hello,\"world!\"\n")
+	Default_FieldTestMessage_DefaultZeroString = string("")
+)
+
+// Default values for FieldTestMessage fields.
+var (
+	Default_FieldTestMessage_DefaultBytes        = []byte("hello,ޭ\xbe\xef")
+	Default_FieldTestMessage_DefaultZeroBytes    = []byte("")
+	Default_FieldTestMessage_DefaultFloatNeginf  = float32(math.Inf(-1))
+	Default_FieldTestMessage_DefaultFloatPosinf  = float32(math.Inf(+1))
+	Default_FieldTestMessage_DefaultFloatNan     = float32(math.NaN())
+	Default_FieldTestMessage_DefaultDoubleNeginf = float64(math.Inf(-1))
+	Default_FieldTestMessage_DefaultDoublePosinf = float64(math.Inf(+1))
+	Default_FieldTestMessage_DefaultDoubleNan    = float64(math.NaN())
+)
+
+func (x *FieldTestMessage) Reset() {
+	*x = FieldTestMessage{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_proto2_fields_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *FieldTestMessage) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*FieldTestMessage) ProtoMessage() {}
+
+func (x *FieldTestMessage) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_proto2_fields_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use FieldTestMessage.ProtoReflect.Descriptor instead.
+func (*FieldTestMessage) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_proto2_fields_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *FieldTestMessage) GetOptionalBool() bool {
+	if x != nil && x.OptionalBool != nil {
+		return *x.OptionalBool
+	}
+	return false
+}
+
+func (x *FieldTestMessage) GetOptionalEnum() FieldTestMessage_Enum {
+	if x != nil && x.OptionalEnum != nil {
+		return *x.OptionalEnum
+	}
+	return FieldTestMessage_ZERO
+}
+
+func (x *FieldTestMessage) GetOptionalInt32() int32 {
+	if x != nil && x.OptionalInt32 != nil {
+		return *x.OptionalInt32
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOptionalSint32() int32 {
+	if x != nil && x.OptionalSint32 != nil {
+		return *x.OptionalSint32
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOptionalUint32() uint32 {
+	if x != nil && x.OptionalUint32 != nil {
+		return *x.OptionalUint32
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOptionalInt64() int64 {
+	if x != nil && x.OptionalInt64 != nil {
+		return *x.OptionalInt64
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOptionalSint64() int64 {
+	if x != nil && x.OptionalSint64 != nil {
+		return *x.OptionalSint64
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOptionalUint64() uint64 {
+	if x != nil && x.OptionalUint64 != nil {
+		return *x.OptionalUint64
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOptionalSfixed32() int32 {
+	if x != nil && x.OptionalSfixed32 != nil {
+		return *x.OptionalSfixed32
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOptionalFixed32() uint32 {
+	if x != nil && x.OptionalFixed32 != nil {
+		return *x.OptionalFixed32
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOptionalFloat() float32 {
+	if x != nil && x.OptionalFloat != nil {
+		return *x.OptionalFloat
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOptionalSfixed64() int64 {
+	if x != nil && x.OptionalSfixed64 != nil {
+		return *x.OptionalSfixed64
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOptionalFixed64() uint64 {
+	if x != nil && x.OptionalFixed64 != nil {
+		return *x.OptionalFixed64
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOptionalDouble() float64 {
+	if x != nil && x.OptionalDouble != nil {
+		return *x.OptionalDouble
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOptionalString() string {
+	if x != nil && x.OptionalString != nil {
+		return *x.OptionalString
+	}
+	return ""
+}
+
+func (x *FieldTestMessage) GetOptionalBytes() []byte {
+	if x != nil {
+		return x.OptionalBytes
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetOptional_Message() *FieldTestMessage_Message {
+	if x != nil {
+		return x.Optional_Message
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetOptionalgroup() *FieldTestMessage_OptionalGroup {
+	if x != nil {
+		return x.Optionalgroup
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRequiredBool() bool {
+	if x != nil && x.RequiredBool != nil {
+		return *x.RequiredBool
+	}
+	return false
+}
+
+func (x *FieldTestMessage) GetRequiredEnum() FieldTestMessage_Enum {
+	if x != nil && x.RequiredEnum != nil {
+		return *x.RequiredEnum
+	}
+	return FieldTestMessage_ZERO
+}
+
+func (x *FieldTestMessage) GetRequiredInt32() int32 {
+	if x != nil && x.RequiredInt32 != nil {
+		return *x.RequiredInt32
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetRequiredSint32() int32 {
+	if x != nil && x.RequiredSint32 != nil {
+		return *x.RequiredSint32
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetRequiredUint32() uint32 {
+	if x != nil && x.RequiredUint32 != nil {
+		return *x.RequiredUint32
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetRequiredInt64() int64 {
+	if x != nil && x.RequiredInt64 != nil {
+		return *x.RequiredInt64
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetRequiredSint64() int64 {
+	if x != nil && x.RequiredSint64 != nil {
+		return *x.RequiredSint64
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetRequiredUint64() uint64 {
+	if x != nil && x.RequiredUint64 != nil {
+		return *x.RequiredUint64
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetRequiredSfixed32() int32 {
+	if x != nil && x.RequiredSfixed32 != nil {
+		return *x.RequiredSfixed32
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetRequiredFixed32() uint32 {
+	if x != nil && x.RequiredFixed32 != nil {
+		return *x.RequiredFixed32
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetRequiredFloat() float32 {
+	if x != nil && x.RequiredFloat != nil {
+		return *x.RequiredFloat
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetRequiredSfixed64() int64 {
+	if x != nil && x.RequiredSfixed64 != nil {
+		return *x.RequiredSfixed64
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetRequiredFixed64() uint64 {
+	if x != nil && x.RequiredFixed64 != nil {
+		return *x.RequiredFixed64
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetRequiredDouble() float64 {
+	if x != nil && x.RequiredDouble != nil {
+		return *x.RequiredDouble
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetRequiredString() string {
+	if x != nil && x.RequiredString != nil {
+		return *x.RequiredString
+	}
+	return ""
+}
+
+func (x *FieldTestMessage) GetRequiredBytes() []byte {
+	if x != nil {
+		return x.RequiredBytes
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRequired_Message() *FieldTestMessage_Message {
+	if x != nil {
+		return x.Required_Message
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRequiredgroup() *FieldTestMessage_RequiredGroup {
+	if x != nil {
+		return x.Requiredgroup
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRepeatedBool() []bool {
+	if x != nil {
+		return x.RepeatedBool
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRepeatedEnum() []FieldTestMessage_Enum {
+	if x != nil {
+		return x.RepeatedEnum
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRepeatedInt32() []int32 {
+	if x != nil {
+		return x.RepeatedInt32
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRepeatedSint32() []int32 {
+	if x != nil {
+		return x.RepeatedSint32
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRepeatedUint32() []uint32 {
+	if x != nil {
+		return x.RepeatedUint32
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRepeatedInt64() []int64 {
+	if x != nil {
+		return x.RepeatedInt64
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRepeatedSint64() []int64 {
+	if x != nil {
+		return x.RepeatedSint64
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRepeatedUint64() []uint64 {
+	if x != nil {
+		return x.RepeatedUint64
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRepeatedSfixed32() []int32 {
+	if x != nil {
+		return x.RepeatedSfixed32
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRepeatedFixed32() []uint32 {
+	if x != nil {
+		return x.RepeatedFixed32
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRepeatedFloat() []float32 {
+	if x != nil {
+		return x.RepeatedFloat
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRepeatedSfixed64() []int64 {
+	if x != nil {
+		return x.RepeatedSfixed64
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRepeatedFixed64() []uint64 {
+	if x != nil {
+		return x.RepeatedFixed64
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRepeatedDouble() []float64 {
+	if x != nil {
+		return x.RepeatedDouble
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRepeatedString() []string {
+	if x != nil {
+		return x.RepeatedString
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRepeatedBytes() [][]byte {
+	if x != nil {
+		return x.RepeatedBytes
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRepeated_Message() []*FieldTestMessage_Message {
+	if x != nil {
+		return x.Repeated_Message
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRepeatedgroup() []*FieldTestMessage_RepeatedGroup {
+	if x != nil {
+		return x.Repeatedgroup
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetDefaultBool() bool {
+	if x != nil && x.DefaultBool != nil {
+		return *x.DefaultBool
+	}
+	return Default_FieldTestMessage_DefaultBool
+}
+
+func (x *FieldTestMessage) GetDefaultEnum() FieldTestMessage_Enum {
+	if x != nil && x.DefaultEnum != nil {
+		return *x.DefaultEnum
+	}
+	return Default_FieldTestMessage_DefaultEnum
+}
+
+func (x *FieldTestMessage) GetDefaultInt32() int32 {
+	if x != nil && x.DefaultInt32 != nil {
+		return *x.DefaultInt32
+	}
+	return Default_FieldTestMessage_DefaultInt32
+}
+
+func (x *FieldTestMessage) GetDefaultSint32() int32 {
+	if x != nil && x.DefaultSint32 != nil {
+		return *x.DefaultSint32
+	}
+	return Default_FieldTestMessage_DefaultSint32
+}
+
+func (x *FieldTestMessage) GetDefaultUint32() uint32 {
+	if x != nil && x.DefaultUint32 != nil {
+		return *x.DefaultUint32
+	}
+	return Default_FieldTestMessage_DefaultUint32
+}
+
+func (x *FieldTestMessage) GetDefaultInt64() int64 {
+	if x != nil && x.DefaultInt64 != nil {
+		return *x.DefaultInt64
+	}
+	return Default_FieldTestMessage_DefaultInt64
+}
+
+func (x *FieldTestMessage) GetDefaultSint64() int64 {
+	if x != nil && x.DefaultSint64 != nil {
+		return *x.DefaultSint64
+	}
+	return Default_FieldTestMessage_DefaultSint64
+}
+
+func (x *FieldTestMessage) GetDefaultUint64() uint64 {
+	if x != nil && x.DefaultUint64 != nil {
+		return *x.DefaultUint64
+	}
+	return Default_FieldTestMessage_DefaultUint64
+}
+
+func (x *FieldTestMessage) GetDefaultSfixed32() int32 {
+	if x != nil && x.DefaultSfixed32 != nil {
+		return *x.DefaultSfixed32
+	}
+	return Default_FieldTestMessage_DefaultSfixed32
+}
+
+func (x *FieldTestMessage) GetDefaultFixed32() uint32 {
+	if x != nil && x.DefaultFixed32 != nil {
+		return *x.DefaultFixed32
+	}
+	return Default_FieldTestMessage_DefaultFixed32
+}
+
+func (x *FieldTestMessage) GetDefaultFloat() float32 {
+	if x != nil && x.DefaultFloat != nil {
+		return *x.DefaultFloat
+	}
+	return Default_FieldTestMessage_DefaultFloat
+}
+
+func (x *FieldTestMessage) GetDefaultSfixed64() int64 {
+	if x != nil && x.DefaultSfixed64 != nil {
+		return *x.DefaultSfixed64
+	}
+	return Default_FieldTestMessage_DefaultSfixed64
+}
+
+func (x *FieldTestMessage) GetDefaultFixed64() uint64 {
+	if x != nil && x.DefaultFixed64 != nil {
+		return *x.DefaultFixed64
+	}
+	return Default_FieldTestMessage_DefaultFixed64
+}
+
+func (x *FieldTestMessage) GetDefaultDouble() float64 {
+	if x != nil && x.DefaultDouble != nil {
+		return *x.DefaultDouble
+	}
+	return Default_FieldTestMessage_DefaultDouble
+}
+
+func (x *FieldTestMessage) GetDefaultString() string {
+	if x != nil && x.DefaultString != nil {
+		return *x.DefaultString
+	}
+	return Default_FieldTestMessage_DefaultString
+}
+
+func (x *FieldTestMessage) GetDefaultBytes() []byte {
+	if x != nil && x.DefaultBytes != nil {
+		return x.DefaultBytes
+	}
+	return append([]byte(nil), Default_FieldTestMessage_DefaultBytes...)
+}
+
+func (x *FieldTestMessage) GetDefaultZeroString() string {
+	if x != nil && x.DefaultZeroString != nil {
+		return *x.DefaultZeroString
+	}
+	return Default_FieldTestMessage_DefaultZeroString
+}
+
+func (x *FieldTestMessage) GetDefaultZeroBytes() []byte {
+	if x != nil && x.DefaultZeroBytes != nil {
+		return x.DefaultZeroBytes
+	}
+	return append([]byte(nil), Default_FieldTestMessage_DefaultZeroBytes...)
+}
+
+func (x *FieldTestMessage) GetDefaultFloatNeginf() float32 {
+	if x != nil && x.DefaultFloatNeginf != nil {
+		return *x.DefaultFloatNeginf
+	}
+	return Default_FieldTestMessage_DefaultFloatNeginf
+}
+
+func (x *FieldTestMessage) GetDefaultFloatPosinf() float32 {
+	if x != nil && x.DefaultFloatPosinf != nil {
+		return *x.DefaultFloatPosinf
+	}
+	return Default_FieldTestMessage_DefaultFloatPosinf
+}
+
+func (x *FieldTestMessage) GetDefaultFloatNan() float32 {
+	if x != nil && x.DefaultFloatNan != nil {
+		return *x.DefaultFloatNan
+	}
+	return Default_FieldTestMessage_DefaultFloatNan
+}
+
+func (x *FieldTestMessage) GetDefaultDoubleNeginf() float64 {
+	if x != nil && x.DefaultDoubleNeginf != nil {
+		return *x.DefaultDoubleNeginf
+	}
+	return Default_FieldTestMessage_DefaultDoubleNeginf
+}
+
+func (x *FieldTestMessage) GetDefaultDoublePosinf() float64 {
+	if x != nil && x.DefaultDoublePosinf != nil {
+		return *x.DefaultDoublePosinf
+	}
+	return Default_FieldTestMessage_DefaultDoublePosinf
+}
+
+func (x *FieldTestMessage) GetDefaultDoubleNan() float64 {
+	if x != nil && x.DefaultDoubleNan != nil {
+		return *x.DefaultDoubleNan
+	}
+	return Default_FieldTestMessage_DefaultDoubleNan
+}
+
+func (x *FieldTestMessage) GetMapInt32Int64() map[int32]int64 {
+	if x != nil {
+		return x.MapInt32Int64
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetMapStringMessage() map[string]*FieldTestMessage_Message {
+	if x != nil {
+		return x.MapStringMessage
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetMapFixed64Enum() map[uint64]FieldTestMessage_Enum {
+	if x != nil {
+		return x.MapFixed64Enum
+	}
+	return nil
+}
+
+func (m *FieldTestMessage) GetOneofField() isFieldTestMessage_OneofField {
+	if m != nil {
+		return m.OneofField
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetOneofBool() bool {
+	if x, ok := x.GetOneofField().(*FieldTestMessage_OneofBool); ok {
+		return x.OneofBool
+	}
+	return false
+}
+
+func (x *FieldTestMessage) GetOneofEnum() FieldTestMessage_Enum {
+	if x, ok := x.GetOneofField().(*FieldTestMessage_OneofEnum); ok {
+		return x.OneofEnum
+	}
+	return FieldTestMessage_ZERO
+}
+
+func (x *FieldTestMessage) GetOneofInt32() int32 {
+	if x, ok := x.GetOneofField().(*FieldTestMessage_OneofInt32); ok {
+		return x.OneofInt32
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOneofSint32() int32 {
+	if x, ok := x.GetOneofField().(*FieldTestMessage_OneofSint32); ok {
+		return x.OneofSint32
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOneofUint32() uint32 {
+	if x, ok := x.GetOneofField().(*FieldTestMessage_OneofUint32); ok {
+		return x.OneofUint32
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOneofInt64() int64 {
+	if x, ok := x.GetOneofField().(*FieldTestMessage_OneofInt64); ok {
+		return x.OneofInt64
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOneofSint64() int64 {
+	if x, ok := x.GetOneofField().(*FieldTestMessage_OneofSint64); ok {
+		return x.OneofSint64
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOneofUint64() uint64 {
+	if x, ok := x.GetOneofField().(*FieldTestMessage_OneofUint64); ok {
+		return x.OneofUint64
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOneofSfixed32() int32 {
+	if x, ok := x.GetOneofField().(*FieldTestMessage_OneofSfixed32); ok {
+		return x.OneofSfixed32
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOneofFixed32() uint32 {
+	if x, ok := x.GetOneofField().(*FieldTestMessage_OneofFixed32); ok {
+		return x.OneofFixed32
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOneofFloat() float32 {
+	if x, ok := x.GetOneofField().(*FieldTestMessage_OneofFloat); ok {
+		return x.OneofFloat
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOneofSfixed64() int64 {
+	if x, ok := x.GetOneofField().(*FieldTestMessage_OneofSfixed64); ok {
+		return x.OneofSfixed64
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOneofFixed64() uint64 {
+	if x, ok := x.GetOneofField().(*FieldTestMessage_OneofFixed64); ok {
+		return x.OneofFixed64
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOneofDouble() float64 {
+	if x, ok := x.GetOneofField().(*FieldTestMessage_OneofDouble); ok {
+		return x.OneofDouble
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOneofString() string {
+	if x, ok := x.GetOneofField().(*FieldTestMessage_OneofString); ok {
+		return x.OneofString
+	}
+	return ""
+}
+
+func (x *FieldTestMessage) GetOneofBytes() []byte {
+	if x, ok := x.GetOneofField().(*FieldTestMessage_OneofBytes); ok {
+		return x.OneofBytes
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetOneof_Message() *FieldTestMessage_Message {
+	if x, ok := x.GetOneofField().(*FieldTestMessage_Oneof_Message); ok {
+		return x.Oneof_Message
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetOneofgroup() *FieldTestMessage_OneofGroup {
+	if x, ok := x.GetOneofField().(*FieldTestMessage_Oneofgroup); ok {
+		return x.Oneofgroup
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetOneofLargestTag() int32 {
+	if x, ok := x.GetOneofField().(*FieldTestMessage_OneofLargestTag); ok {
+		return x.OneofLargestTag
+	}
+	return 0
+}
+
+func (m *FieldTestMessage) GetOneofTwo() isFieldTestMessage_OneofTwo {
+	if m != nil {
+		return m.OneofTwo
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetOneofTwo_1() int32 {
+	if x, ok := x.GetOneofTwo().(*FieldTestMessage_OneofTwo_1); ok {
+		return x.OneofTwo_1
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOneofTwo_2() int64 {
+	if x, ok := x.GetOneofTwo().(*FieldTestMessage_OneofTwo_2); ok {
+		return x.OneofTwo_2
+	}
+	return 0
+}
+
+type isFieldTestMessage_OneofField interface {
+	isFieldTestMessage_OneofField()
+}
+
+type FieldTestMessage_OneofBool struct {
+	OneofBool bool `protobuf:"varint,601,opt,name=oneof_bool,json=oneofBool,oneof"`
+}
+
+type FieldTestMessage_OneofEnum struct {
+	OneofEnum FieldTestMessage_Enum `protobuf:"varint,602,opt,name=oneof_enum,json=oneofEnum,enum=goproto.protoc.proto2.FieldTestMessage_Enum,oneof"`
+}
+
+type FieldTestMessage_OneofInt32 struct {
+	OneofInt32 int32 `protobuf:"varint,603,opt,name=oneof_int32,json=oneofInt32,oneof"`
+}
+
+type FieldTestMessage_OneofSint32 struct {
+	OneofSint32 int32 `protobuf:"zigzag32,604,opt,name=oneof_sint32,json=oneofSint32,oneof"`
+}
+
+type FieldTestMessage_OneofUint32 struct {
+	OneofUint32 uint32 `protobuf:"varint,605,opt,name=oneof_uint32,json=oneofUint32,oneof"`
+}
+
+type FieldTestMessage_OneofInt64 struct {
+	OneofInt64 int64 `protobuf:"varint,606,opt,name=oneof_int64,json=oneofInt64,oneof"`
+}
+
+type FieldTestMessage_OneofSint64 struct {
+	OneofSint64 int64 `protobuf:"zigzag64,607,opt,name=oneof_sint64,json=oneofSint64,oneof"`
+}
+
+type FieldTestMessage_OneofUint64 struct {
+	OneofUint64 uint64 `protobuf:"varint,608,opt,name=oneof_uint64,json=oneofUint64,oneof"`
+}
+
+type FieldTestMessage_OneofSfixed32 struct {
+	OneofSfixed32 int32 `protobuf:"fixed32,609,opt,name=oneof_sfixed32,json=oneofSfixed32,oneof"`
+}
+
+type FieldTestMessage_OneofFixed32 struct {
+	OneofFixed32 uint32 `protobuf:"fixed32,610,opt,name=oneof_fixed32,json=oneofFixed32,oneof"`
+}
+
+type FieldTestMessage_OneofFloat struct {
+	OneofFloat float32 `protobuf:"fixed32,611,opt,name=oneof_float,json=oneofFloat,oneof"`
+}
+
+type FieldTestMessage_OneofSfixed64 struct {
+	OneofSfixed64 int64 `protobuf:"fixed64,612,opt,name=oneof_sfixed64,json=oneofSfixed64,oneof"`
+}
+
+type FieldTestMessage_OneofFixed64 struct {
+	OneofFixed64 uint64 `protobuf:"fixed64,613,opt,name=oneof_fixed64,json=oneofFixed64,oneof"`
+}
+
+type FieldTestMessage_OneofDouble struct {
+	OneofDouble float64 `protobuf:"fixed64,614,opt,name=oneof_double,json=oneofDouble,oneof"`
+}
+
+type FieldTestMessage_OneofString struct {
+	OneofString string `protobuf:"bytes,615,opt,name=oneof_string,json=oneofString,oneof"`
+}
+
+type FieldTestMessage_OneofBytes struct {
+	OneofBytes []byte `protobuf:"bytes,616,opt,name=oneof_bytes,json=oneofBytes,oneof"`
+}
+
+type FieldTestMessage_Oneof_Message struct {
+	Oneof_Message *FieldTestMessage_Message `protobuf:"bytes,617,opt,name=oneof_Message,json=oneofMessage,oneof"`
+}
+
+type FieldTestMessage_Oneofgroup struct {
+	Oneofgroup *FieldTestMessage_OneofGroup `protobuf:"group,618,opt,name=OneofGroup,json=oneofgroup,oneof"`
+}
+
+type FieldTestMessage_OneofLargestTag struct {
+	OneofLargestTag int32 `protobuf:"varint,536870911,opt,name=oneof_largest_tag,json=oneofLargestTag,oneof"`
+}
+
+func (*FieldTestMessage_OneofBool) isFieldTestMessage_OneofField() {}
+
+func (*FieldTestMessage_OneofEnum) isFieldTestMessage_OneofField() {}
+
+func (*FieldTestMessage_OneofInt32) isFieldTestMessage_OneofField() {}
+
+func (*FieldTestMessage_OneofSint32) isFieldTestMessage_OneofField() {}
+
+func (*FieldTestMessage_OneofUint32) isFieldTestMessage_OneofField() {}
+
+func (*FieldTestMessage_OneofInt64) isFieldTestMessage_OneofField() {}
+
+func (*FieldTestMessage_OneofSint64) isFieldTestMessage_OneofField() {}
+
+func (*FieldTestMessage_OneofUint64) isFieldTestMessage_OneofField() {}
+
+func (*FieldTestMessage_OneofSfixed32) isFieldTestMessage_OneofField() {}
+
+func (*FieldTestMessage_OneofFixed32) isFieldTestMessage_OneofField() {}
+
+func (*FieldTestMessage_OneofFloat) isFieldTestMessage_OneofField() {}
+
+func (*FieldTestMessage_OneofSfixed64) isFieldTestMessage_OneofField() {}
+
+func (*FieldTestMessage_OneofFixed64) isFieldTestMessage_OneofField() {}
+
+func (*FieldTestMessage_OneofDouble) isFieldTestMessage_OneofField() {}
+
+func (*FieldTestMessage_OneofString) isFieldTestMessage_OneofField() {}
+
+func (*FieldTestMessage_OneofBytes) isFieldTestMessage_OneofField() {}
+
+func (*FieldTestMessage_Oneof_Message) isFieldTestMessage_OneofField() {}
+
+func (*FieldTestMessage_Oneofgroup) isFieldTestMessage_OneofField() {}
+
+func (*FieldTestMessage_OneofLargestTag) isFieldTestMessage_OneofField() {}
+
+type isFieldTestMessage_OneofTwo interface {
+	isFieldTestMessage_OneofTwo()
+}
+
+type FieldTestMessage_OneofTwo_1 struct {
+	OneofTwo_1 int32 `protobuf:"varint,700,opt,name=oneof_two_1,json=oneofTwo1,oneof"`
+}
+
+type FieldTestMessage_OneofTwo_2 struct {
+	OneofTwo_2 int64 `protobuf:"varint,701,opt,name=oneof_two_2,json=oneofTwo2,oneof"`
+}
+
+func (*FieldTestMessage_OneofTwo_1) isFieldTestMessage_OneofTwo() {}
+
+func (*FieldTestMessage_OneofTwo_2) isFieldTestMessage_OneofTwo() {}
+
+type FieldTestMessage_OptionalGroup struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	OptionalGroup *string `protobuf:"bytes,19,opt,name=optional_group,json=optionalGroup" json:"optional_group,omitempty"`
+}
+
+func (x *FieldTestMessage_OptionalGroup) Reset() {
+	*x = FieldTestMessage_OptionalGroup{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_proto2_fields_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *FieldTestMessage_OptionalGroup) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*FieldTestMessage_OptionalGroup) ProtoMessage() {}
+
+func (x *FieldTestMessage_OptionalGroup) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_proto2_fields_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use FieldTestMessage_OptionalGroup.ProtoReflect.Descriptor instead.
+func (*FieldTestMessage_OptionalGroup) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_proto2_fields_proto_rawDescGZIP(), []int{0, 0}
+}
+
+func (x *FieldTestMessage_OptionalGroup) GetOptionalGroup() string {
+	if x != nil && x.OptionalGroup != nil {
+		return *x.OptionalGroup
+	}
+	return ""
+}
+
+type FieldTestMessage_RequiredGroup struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	RequiredGroup *string `protobuf:"bytes,119,req,name=required_group,json=requiredGroup" json:"required_group,omitempty"`
+}
+
+func (x *FieldTestMessage_RequiredGroup) Reset() {
+	*x = FieldTestMessage_RequiredGroup{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_proto2_fields_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *FieldTestMessage_RequiredGroup) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*FieldTestMessage_RequiredGroup) ProtoMessage() {}
+
+func (x *FieldTestMessage_RequiredGroup) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_proto2_fields_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use FieldTestMessage_RequiredGroup.ProtoReflect.Descriptor instead.
+func (*FieldTestMessage_RequiredGroup) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_proto2_fields_proto_rawDescGZIP(), []int{0, 1}
+}
+
+func (x *FieldTestMessage_RequiredGroup) GetRequiredGroup() string {
+	if x != nil && x.RequiredGroup != nil {
+		return *x.RequiredGroup
+	}
+	return ""
+}
+
+type FieldTestMessage_RepeatedGroup struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	RepeatedGroup []string `protobuf:"bytes,219,rep,name=repeated_group,json=repeatedGroup" json:"repeated_group,omitempty"`
+}
+
+func (x *FieldTestMessage_RepeatedGroup) Reset() {
+	*x = FieldTestMessage_RepeatedGroup{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_proto2_fields_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *FieldTestMessage_RepeatedGroup) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*FieldTestMessage_RepeatedGroup) ProtoMessage() {}
+
+func (x *FieldTestMessage_RepeatedGroup) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_proto2_fields_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use FieldTestMessage_RepeatedGroup.ProtoReflect.Descriptor instead.
+func (*FieldTestMessage_RepeatedGroup) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_proto2_fields_proto_rawDescGZIP(), []int{0, 2}
+}
+
+func (x *FieldTestMessage_RepeatedGroup) GetRepeatedGroup() []string {
+	if x != nil {
+		return x.RepeatedGroup
+	}
+	return nil
+}
+
+type FieldTestMessage_OneofGroup struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	OneofGroupField *string `protobuf:"bytes,619,opt,name=oneof_group_field,json=oneofGroupField" json:"oneof_group_field,omitempty"`
+}
+
+func (x *FieldTestMessage_OneofGroup) Reset() {
+	*x = FieldTestMessage_OneofGroup{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_proto2_fields_proto_msgTypes[7]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *FieldTestMessage_OneofGroup) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*FieldTestMessage_OneofGroup) ProtoMessage() {}
+
+func (x *FieldTestMessage_OneofGroup) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_proto2_fields_proto_msgTypes[7]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use FieldTestMessage_OneofGroup.ProtoReflect.Descriptor instead.
+func (*FieldTestMessage_OneofGroup) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_proto2_fields_proto_rawDescGZIP(), []int{0, 6}
+}
+
+func (x *FieldTestMessage_OneofGroup) GetOneofGroupField() string {
+	if x != nil && x.OneofGroupField != nil {
+		return *x.OneofGroupField
+	}
+	return ""
+}
+
+type FieldTestMessage_Message struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *FieldTestMessage_Message) Reset() {
+	*x = FieldTestMessage_Message{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_proto2_fields_proto_msgTypes[8]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *FieldTestMessage_Message) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*FieldTestMessage_Message) ProtoMessage() {}
+
+func (x *FieldTestMessage_Message) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_proto2_fields_proto_msgTypes[8]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use FieldTestMessage_Message.ProtoReflect.Descriptor instead.
+func (*FieldTestMessage_Message) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_proto2_fields_proto_rawDescGZIP(), []int{0, 7}
+}
+
+var File_cmd_protoc_gen_go_testdata_proto2_fields_proto protoreflect.FileDescriptor
+
+var file_cmd_protoc_gen_go_testdata_proto2_fields_proto_rawDesc = []byte{
+	0x0a, 0x2e, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x32, 0x2f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x12, 0x15, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x22, 0xa7, 0x2d, 0x0a, 0x10, 0x46, 0x69, 0x65, 0x6c,
+	0x64, 0x54, 0x65, 0x73, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x23, 0x0a, 0x0d,
+	0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x08, 0x52, 0x0c, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x42, 0x6f, 0x6f,
+	0x6c, 0x12, 0x51, 0x0a, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x65, 0x6e,
+	0x75, 0x6d, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2c, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32,
+	0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x54, 0x65, 0x73, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0c, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x45, 0x6e, 0x75, 0x6d, 0x12, 0x25, 0x0a, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x6f, 0x70,
+	0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x27, 0x0a, 0x0f, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x04,
+	0x20, 0x01, 0x28, 0x11, 0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x69,
+	0x6e, 0x74, 0x33, 0x32, 0x12, 0x27, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0e, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x25, 0x0a,
+	0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18,
+	0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x49,
+	0x6e, 0x74, 0x36, 0x34, 0x12, 0x27, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x5f, 0x73, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x07, 0x20, 0x01, 0x28, 0x12, 0x52, 0x0e, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x27, 0x0a,
+	0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34,
+	0x18, 0x08, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x2b, 0x0a, 0x11, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+	0x61, 0x6c, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x09, 0x20, 0x01, 0x28,
+	0x0f, 0x52, 0x10, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x66, 0x69, 0x78, 0x65,
+	0x64, 0x33, 0x32, 0x12, 0x29, 0x0a, 0x10, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f,
+	0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x07, 0x52, 0x0f, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x25,
+	0x0a, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74,
+	0x18, 0x0b, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x2b, 0x0a, 0x11, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x10,
+	0x52, 0x10, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64,
+	0x36, 0x34, 0x12, 0x29, 0x0a, 0x10, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x66,
+	0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x06, 0x52, 0x0f, 0x6f, 0x70,
+	0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x27, 0x0a,
+	0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65,
+	0x18, 0x0e, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+	0x61, 0x6c, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12,
+	0x25, 0x0a, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x62, 0x79, 0x74, 0x65,
+	0x73, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x5a, 0x0a, 0x10, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+	0x61, 0x6c, 0x5f, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x11, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x2f, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x54, 0x65,
+	0x73, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x52, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x12, 0x5b, 0x0a, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x67, 0x72,
+	0x6f, 0x75, 0x70, 0x18, 0x12, 0x20, 0x01, 0x28, 0x0a, 0x32, 0x35, 0x2e, 0x67, 0x6f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x32, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x54, 0x65, 0x73, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x2e, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x47, 0x72, 0x6f, 0x75, 0x70,
+	0x52, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x12,
+	0x23, 0x0a, 0x0d, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x5f, 0x62, 0x6f, 0x6f, 0x6c,
+	0x18, 0x65, 0x20, 0x02, 0x28, 0x08, 0x52, 0x0c, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64,
+	0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x51, 0x0a, 0x0d, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64,
+	0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x66, 0x20, 0x02, 0x28, 0x0e, 0x32, 0x2c, 0x2e, 0x67, 0x6f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x32, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x54, 0x65, 0x73, 0x74, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0c, 0x72, 0x65, 0x71, 0x75, 0x69,
+	0x72, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x71, 0x75, 0x69,
+	0x72, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x67, 0x20, 0x02, 0x28, 0x05, 0x52,
+	0x0d, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x27,
+	0x0a, 0x0f, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x33,
+	0x32, 0x18, 0x68, 0x20, 0x02, 0x28, 0x11, 0x52, 0x0e, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65,
+	0x64, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x71, 0x75, 0x69,
+	0x72, 0x65, 0x64, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x69, 0x20, 0x02, 0x28, 0x0d,
+	0x52, 0x0e, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32,
+	0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x74,
+	0x36, 0x34, 0x18, 0x6a, 0x20, 0x02, 0x28, 0x03, 0x52, 0x0d, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72,
+	0x65, 0x64, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x71, 0x75, 0x69,
+	0x72, 0x65, 0x64, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x6b, 0x20, 0x02, 0x28, 0x12,
+	0x52, 0x0e, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34,
+	0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x5f, 0x75, 0x69, 0x6e,
+	0x74, 0x36, 0x34, 0x18, 0x6c, 0x20, 0x02, 0x28, 0x04, 0x52, 0x0e, 0x72, 0x65, 0x71, 0x75, 0x69,
+	0x72, 0x65, 0x64, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x2b, 0x0a, 0x11, 0x72, 0x65, 0x71,
+	0x75, 0x69, 0x72, 0x65, 0x64, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x6d,
+	0x20, 0x02, 0x28, 0x0f, 0x52, 0x10, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x53, 0x66,
+	0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x29, 0x0a, 0x10, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72,
+	0x65, 0x64, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x6e, 0x20, 0x02, 0x28, 0x07,
+	0x52, 0x0f, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33,
+	0x32, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x5f, 0x66, 0x6c,
+	0x6f, 0x61, 0x74, 0x18, 0x6f, 0x20, 0x02, 0x28, 0x02, 0x52, 0x0d, 0x72, 0x65, 0x71, 0x75, 0x69,
+	0x72, 0x65, 0x64, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x2b, 0x0a, 0x11, 0x72, 0x65, 0x71, 0x75,
+	0x69, 0x72, 0x65, 0x64, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x70, 0x20,
+	0x02, 0x28, 0x10, 0x52, 0x10, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x53, 0x66, 0x69,
+	0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x29, 0x0a, 0x10, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65,
+	0x64, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x71, 0x20, 0x02, 0x28, 0x06, 0x52,
+	0x0f, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34,
+	0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x5f, 0x64, 0x6f, 0x75,
+	0x62, 0x6c, 0x65, 0x18, 0x72, 0x20, 0x02, 0x28, 0x01, 0x52, 0x0e, 0x72, 0x65, 0x71, 0x75, 0x69,
+	0x72, 0x65, 0x64, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x71,
+	0x75, 0x69, 0x72, 0x65, 0x64, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x73, 0x20, 0x02,
+	0x28, 0x09, 0x52, 0x0e, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x53, 0x74, 0x72, 0x69,
+	0x6e, 0x67, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x5f, 0x62,
+	0x79, 0x74, 0x65, 0x73, 0x18, 0x74, 0x20, 0x02, 0x28, 0x0c, 0x52, 0x0d, 0x72, 0x65, 0x71, 0x75,
+	0x69, 0x72, 0x65, 0x64, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x5a, 0x0a, 0x10, 0x72, 0x65, 0x71,
+	0x75, 0x69, 0x72, 0x65, 0x64, 0x5f, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x75, 0x20,
+	0x02, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x46, 0x69, 0x65, 0x6c,
+	0x64, 0x54, 0x65, 0x73, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x52, 0x0f, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x5b, 0x0a, 0x0d, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65,
+	0x64, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x76, 0x20, 0x02, 0x28, 0x0a, 0x32, 0x35, 0x2e, 0x67,
+	0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x54, 0x65, 0x73, 0x74, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x47, 0x72,
+	0x6f, 0x75, 0x70, 0x52, 0x0d, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x67, 0x72, 0x6f,
+	0x75, 0x70, 0x12, 0x24, 0x0a, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x62,
+	0x6f, 0x6f, 0x6c, 0x18, 0xc9, 0x01, 0x20, 0x03, 0x28, 0x08, 0x52, 0x0c, 0x72, 0x65, 0x70, 0x65,
+	0x61, 0x74, 0x65, 0x64, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x52, 0x0a, 0x0d, 0x72, 0x65, 0x70, 0x65,
+	0x61, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0xca, 0x01, 0x20, 0x03, 0x28, 0x0e,
+	0x32, 0x2c, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x54, 0x65,
+	0x73, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0c,
+	0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x26, 0x0a, 0x0e,
+	0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0xcb,
+	0x01, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x49,
+	0x6e, 0x74, 0x33, 0x32, 0x12, 0x28, 0x0a, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
+	0x5f, 0x73, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0xcc, 0x01, 0x20, 0x03, 0x28, 0x11, 0x52, 0x0e,
+	0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x28,
+	0x0a, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33,
+	0x32, 0x18, 0xcd, 0x01, 0x20, 0x03, 0x28, 0x0d, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74,
+	0x65, 0x64, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x26, 0x0a, 0x0e, 0x72, 0x65, 0x70, 0x65,
+	0x61, 0x74, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0xce, 0x01, 0x20, 0x03, 0x28,
+	0x03, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x49, 0x6e, 0x74, 0x36, 0x34,
+	0x12, 0x28, 0x0a, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x73, 0x69, 0x6e,
+	0x74, 0x36, 0x34, 0x18, 0xcf, 0x01, 0x20, 0x03, 0x28, 0x12, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65,
+	0x61, 0x74, 0x65, 0x64, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x28, 0x0a, 0x0f, 0x72, 0x65,
+	0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0xd0, 0x01,
+	0x20, 0x03, 0x28, 0x04, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x55, 0x69,
+	0x6e, 0x74, 0x36, 0x34, 0x12, 0x2c, 0x0a, 0x11, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
+	0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0xd1, 0x01, 0x20, 0x03, 0x28, 0x0f,
+	0x52, 0x10, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64,
+	0x33, 0x32, 0x12, 0x2a, 0x0a, 0x10, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x66,
+	0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0xd2, 0x01, 0x20, 0x03, 0x28, 0x07, 0x52, 0x0f, 0x72,
+	0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x26,
+	0x0a, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74,
+	0x18, 0xd3, 0x01, 0x20, 0x03, 0x28, 0x02, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65,
+	0x64, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x2c, 0x0a, 0x11, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74,
+	0x65, 0x64, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0xd4, 0x01, 0x20, 0x03,
+	0x28, 0x10, 0x52, 0x10, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x53, 0x66, 0x69, 0x78,
+	0x65, 0x64, 0x36, 0x34, 0x12, 0x2a, 0x0a, 0x10, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
+	0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0xd5, 0x01, 0x20, 0x03, 0x28, 0x06, 0x52,
+	0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34,
+	0x12, 0x28, 0x0a, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x64, 0x6f, 0x75,
+	0x62, 0x6c, 0x65, 0x18, 0xd6, 0x01, 0x20, 0x03, 0x28, 0x01, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65,
+	0x61, 0x74, 0x65, 0x64, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x28, 0x0a, 0x0f, 0x72, 0x65,
+	0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0xd7, 0x01,
+	0x20, 0x03, 0x28, 0x09, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x53, 0x74,
+	0x72, 0x69, 0x6e, 0x67, 0x12, 0x26, 0x0a, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
+	0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0xd8, 0x01, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x0d, 0x72,
+	0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x5b, 0x0a, 0x10,
+	0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x18, 0xd9, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e,
+	0x46, 0x69, 0x65, 0x6c, 0x64, 0x54, 0x65, 0x73, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74,
+	0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x5c, 0x0a, 0x0d, 0x72, 0x65, 0x70,
+	0x65, 0x61, 0x74, 0x65, 0x64, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0xda, 0x01, 0x20, 0x03, 0x28,
+	0x0a, 0x32, 0x35, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x54,
+	0x65, 0x73, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x52, 0x65, 0x70, 0x65, 0x61,
+	0x74, 0x65, 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74,
+	0x65, 0x64, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x28, 0x0a, 0x0c, 0x64, 0x65, 0x66, 0x61, 0x75,
+	0x6c, 0x74, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18, 0xad, 0x02, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x04,
+	0x74, 0x72, 0x75, 0x65, 0x52, 0x0b, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x42, 0x6f, 0x6f,
+	0x6c, 0x12, 0x55, 0x0a, 0x0c, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x65, 0x6e, 0x75,
+	0x6d, 0x18, 0xae, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2c, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32,
+	0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x54, 0x65, 0x73, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x3a, 0x03, 0x4f, 0x4e, 0x45, 0x52, 0x0b, 0x64, 0x65, 0x66,
+	0x61, 0x75, 0x6c, 0x74, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x27, 0x0a, 0x0d, 0x64, 0x65, 0x66, 0x61,
+	0x75, 0x6c, 0x74, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0xaf, 0x02, 0x20, 0x01, 0x28, 0x05,
+	0x3a, 0x01, 0x31, 0x52, 0x0c, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x49, 0x6e, 0x74, 0x33,
+	0x32, 0x12, 0x29, 0x0a, 0x0e, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x73, 0x69, 0x6e,
+	0x74, 0x33, 0x32, 0x18, 0xb0, 0x02, 0x20, 0x01, 0x28, 0x11, 0x3a, 0x01, 0x31, 0x52, 0x0d, 0x64,
+	0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x29, 0x0a, 0x0e,
+	0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0xb1,
+	0x02, 0x20, 0x01, 0x28, 0x0d, 0x3a, 0x01, 0x31, 0x52, 0x0d, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c,
+	0x74, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x27, 0x0a, 0x0d, 0x64, 0x65, 0x66, 0x61, 0x75,
+	0x6c, 0x74, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0xb2, 0x02, 0x20, 0x01, 0x28, 0x03, 0x3a,
+	0x01, 0x31, 0x52, 0x0c, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x49, 0x6e, 0x74, 0x36, 0x34,
+	0x12, 0x29, 0x0a, 0x0e, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x73, 0x69, 0x6e, 0x74,
+	0x36, 0x34, 0x18, 0xb3, 0x02, 0x20, 0x01, 0x28, 0x12, 0x3a, 0x01, 0x31, 0x52, 0x0d, 0x64, 0x65,
+	0x66, 0x61, 0x75, 0x6c, 0x74, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x29, 0x0a, 0x0e, 0x64,
+	0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0xb4, 0x02,
+	0x20, 0x01, 0x28, 0x04, 0x3a, 0x01, 0x31, 0x52, 0x0d, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74,
+	0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x2d, 0x0a, 0x10, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c,
+	0x74, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0xb5, 0x02, 0x20, 0x01, 0x28,
+	0x0f, 0x3a, 0x01, 0x31, 0x52, 0x0f, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x53, 0x66, 0x69,
+	0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x2b, 0x0a, 0x0f, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74,
+	0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0xb6, 0x02, 0x20, 0x01, 0x28, 0x07, 0x3a,
+	0x01, 0x31, 0x52, 0x0e, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x46, 0x69, 0x78, 0x65, 0x64,
+	0x33, 0x32, 0x12, 0x2a, 0x0a, 0x0d, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x66, 0x6c,
+	0x6f, 0x61, 0x74, 0x18, 0xb7, 0x02, 0x20, 0x01, 0x28, 0x02, 0x3a, 0x04, 0x33, 0x2e, 0x31, 0x34,
+	0x52, 0x0c, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x2d,
+	0x0a, 0x10, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64,
+	0x36, 0x34, 0x18, 0xb8, 0x02, 0x20, 0x01, 0x28, 0x10, 0x3a, 0x01, 0x31, 0x52, 0x0f, 0x64, 0x65,
+	0x66, 0x61, 0x75, 0x6c, 0x74, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x2b, 0x0a,
+	0x0f, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34,
+	0x18, 0xb9, 0x02, 0x20, 0x01, 0x28, 0x06, 0x3a, 0x01, 0x31, 0x52, 0x0e, 0x64, 0x65, 0x66, 0x61,
+	0x75, 0x6c, 0x74, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x2e, 0x0a, 0x0e, 0x64, 0x65,
+	0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0xba, 0x02, 0x20,
+	0x01, 0x28, 0x01, 0x3a, 0x06, 0x33, 0x2e, 0x31, 0x34, 0x31, 0x35, 0x52, 0x0d, 0x64, 0x65, 0x66,
+	0x61, 0x75, 0x6c, 0x74, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x37, 0x0a, 0x0e, 0x64, 0x65,
+	0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0xbb, 0x02, 0x20,
+	0x01, 0x28, 0x09, 0x3a, 0x0f, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x2c, 0x22, 0x77, 0x6f, 0x72, 0x6c,
+	0x64, 0x21, 0x22, 0x0a, 0x52, 0x0d, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x53, 0x74, 0x72,
+	0x69, 0x6e, 0x67, 0x12, 0x3c, 0x0a, 0x0d, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x62,
+	0x79, 0x74, 0x65, 0x73, 0x18, 0xbc, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x3a, 0x16, 0x68, 0x65, 0x6c,
+	0x6c, 0x6f, 0x2c, 0x5c, 0x33, 0x33, 0x36, 0x5c, 0x32, 0x35, 0x35, 0x5c, 0x32, 0x37, 0x36, 0x5c,
+	0x33, 0x35, 0x37, 0x52, 0x0c, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x42, 0x79, 0x74, 0x65,
+	0x73, 0x12, 0x31, 0x0a, 0x13, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x7a, 0x65, 0x72,
+	0x6f, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0xde, 0x02, 0x20, 0x01, 0x28, 0x09, 0x3a,
+	0x00, 0x52, 0x11, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5a, 0x65, 0x72, 0x6f, 0x53, 0x74,
+	0x72, 0x69, 0x6e, 0x67, 0x12, 0x2f, 0x0a, 0x12, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f,
+	0x7a, 0x65, 0x72, 0x6f, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0xdf, 0x02, 0x20, 0x01, 0x28,
+	0x0c, 0x3a, 0x00, 0x52, 0x10, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5a, 0x65, 0x72, 0x6f,
+	0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x37, 0x0a, 0x14, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74,
+	0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x5f, 0x6e, 0x65, 0x67, 0x69, 0x6e, 0x66, 0x18, 0x90, 0x03,
+	0x20, 0x01, 0x28, 0x02, 0x3a, 0x04, 0x2d, 0x69, 0x6e, 0x66, 0x52, 0x12, 0x64, 0x65, 0x66, 0x61,
+	0x75, 0x6c, 0x74, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x4e, 0x65, 0x67, 0x69, 0x6e, 0x66, 0x12, 0x36,
+	0x0a, 0x14, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x5f,
+	0x70, 0x6f, 0x73, 0x69, 0x6e, 0x66, 0x18, 0x91, 0x03, 0x20, 0x01, 0x28, 0x02, 0x3a, 0x03, 0x69,
+	0x6e, 0x66, 0x52, 0x12, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x46, 0x6c, 0x6f, 0x61, 0x74,
+	0x50, 0x6f, 0x73, 0x69, 0x6e, 0x66, 0x12, 0x30, 0x0a, 0x11, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c,
+	0x74, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x5f, 0x6e, 0x61, 0x6e, 0x18, 0x92, 0x03, 0x20, 0x01,
+	0x28, 0x02, 0x3a, 0x03, 0x6e, 0x61, 0x6e, 0x52, 0x0f, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74,
+	0x46, 0x6c, 0x6f, 0x61, 0x74, 0x4e, 0x61, 0x6e, 0x12, 0x39, 0x0a, 0x15, 0x64, 0x65, 0x66, 0x61,
+	0x75, 0x6c, 0x74, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x5f, 0x6e, 0x65, 0x67, 0x69, 0x6e,
+	0x66, 0x18, 0x93, 0x03, 0x20, 0x01, 0x28, 0x01, 0x3a, 0x04, 0x2d, 0x69, 0x6e, 0x66, 0x52, 0x13,
+	0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x4e, 0x65, 0x67,
+	0x69, 0x6e, 0x66, 0x12, 0x38, 0x0a, 0x15, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x64,
+	0x6f, 0x75, 0x62, 0x6c, 0x65, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x6e, 0x66, 0x18, 0x94, 0x03, 0x20,
+	0x01, 0x28, 0x01, 0x3a, 0x03, 0x69, 0x6e, 0x66, 0x52, 0x13, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c,
+	0x74, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x50, 0x6f, 0x73, 0x69, 0x6e, 0x66, 0x12, 0x32, 0x0a,
+	0x12, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x5f,
+	0x6e, 0x61, 0x6e, 0x18, 0x95, 0x03, 0x20, 0x01, 0x28, 0x01, 0x3a, 0x03, 0x6e, 0x61, 0x6e, 0x52,
+	0x10, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x4e, 0x61,
+	0x6e, 0x12, 0x63, 0x0a, 0x0f, 0x6d, 0x61, 0x70, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x69,
+	0x6e, 0x74, 0x36, 0x34, 0x18, 0xf4, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3a, 0x2e, 0x67, 0x6f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x32, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x54, 0x65, 0x73, 0x74, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x2e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x49, 0x6e, 0x74,
+	0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0d, 0x6d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x33,
+	0x32, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x6c, 0x0a, 0x12, 0x6d, 0x61, 0x70, 0x5f, 0x73, 0x74,
+	0x72, 0x69, 0x6e, 0x67, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0xf5, 0x03, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x3d, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x46, 0x69, 0x65, 0x6c,
+	0x64, 0x54, 0x65, 0x73, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x4d, 0x61, 0x70,
+	0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x45, 0x6e, 0x74,
+	0x72, 0x79, 0x52, 0x10, 0x6d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x12, 0x66, 0x0a, 0x10, 0x6d, 0x61, 0x70, 0x5f, 0x66, 0x69, 0x78, 0x65,
+	0x64, 0x36, 0x34, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0xf6, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x3b, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x54, 0x65, 0x73,
+	0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x4d, 0x61, 0x70, 0x46, 0x69, 0x78, 0x65,
+	0x64, 0x36, 0x34, 0x45, 0x6e, 0x75, 0x6d, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, 0x6d, 0x61,
+	0x70, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x20, 0x0a, 0x0a,
+	0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18, 0xd9, 0x04, 0x20, 0x01, 0x28,
+	0x08, 0x48, 0x00, 0x52, 0x09, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x4e,
+	0x0a, 0x0a, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0xda, 0x04, 0x20,
+	0x01, 0x28, 0x0e, 0x32, 0x2c, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x46, 0x69, 0x65, 0x6c,
+	0x64, 0x54, 0x65, 0x73, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x45, 0x6e, 0x75,
+	0x6d, 0x48, 0x00, 0x52, 0x09, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x22,
+	0x0a, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0xdb, 0x04,
+	0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, 0x0a, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x49, 0x6e, 0x74,
+	0x33, 0x32, 0x12, 0x24, 0x0a, 0x0c, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x73, 0x69, 0x6e, 0x74,
+	0x33, 0x32, 0x18, 0xdc, 0x04, 0x20, 0x01, 0x28, 0x11, 0x48, 0x00, 0x52, 0x0b, 0x6f, 0x6e, 0x65,
+	0x6f, 0x66, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x24, 0x0a, 0x0c, 0x6f, 0x6e, 0x65, 0x6f,
+	0x66, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0xdd, 0x04, 0x20, 0x01, 0x28, 0x0d, 0x48,
+	0x00, 0x52, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x22,
+	0x0a, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0xde, 0x04,
+	0x20, 0x01, 0x28, 0x03, 0x48, 0x00, 0x52, 0x0a, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x49, 0x6e, 0x74,
+	0x36, 0x34, 0x12, 0x24, 0x0a, 0x0c, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x73, 0x69, 0x6e, 0x74,
+	0x36, 0x34, 0x18, 0xdf, 0x04, 0x20, 0x01, 0x28, 0x12, 0x48, 0x00, 0x52, 0x0b, 0x6f, 0x6e, 0x65,
+	0x6f, 0x66, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x24, 0x0a, 0x0c, 0x6f, 0x6e, 0x65, 0x6f,
+	0x66, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0xe0, 0x04, 0x20, 0x01, 0x28, 0x04, 0x48,
+	0x00, 0x52, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x28,
+	0x0a, 0x0e, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32,
+	0x18, 0xe1, 0x04, 0x20, 0x01, 0x28, 0x0f, 0x48, 0x00, 0x52, 0x0d, 0x6f, 0x6e, 0x65, 0x6f, 0x66,
+	0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x26, 0x0a, 0x0d, 0x6f, 0x6e, 0x65, 0x6f,
+	0x66, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0xe2, 0x04, 0x20, 0x01, 0x28, 0x07,
+	0x48, 0x00, 0x52, 0x0c, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32,
+	0x12, 0x22, 0x0a, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x18,
+	0xe3, 0x04, 0x20, 0x01, 0x28, 0x02, 0x48, 0x00, 0x52, 0x0a, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x46,
+	0x6c, 0x6f, 0x61, 0x74, 0x12, 0x28, 0x0a, 0x0e, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x73, 0x66,
+	0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0xe4, 0x04, 0x20, 0x01, 0x28, 0x10, 0x48, 0x00, 0x52,
+	0x0d, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x26,
+	0x0a, 0x0d, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18,
+	0xe5, 0x04, 0x20, 0x01, 0x28, 0x06, 0x48, 0x00, 0x52, 0x0c, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x46,
+	0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x24, 0x0a, 0x0c, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f,
+	0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0xe6, 0x04, 0x20, 0x01, 0x28, 0x01, 0x48, 0x00, 0x52,
+	0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x24, 0x0a, 0x0c,
+	0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0xe7, 0x04, 0x20,
+	0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x53, 0x74, 0x72, 0x69,
+	0x6e, 0x67, 0x12, 0x22, 0x0a, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x62, 0x79, 0x74, 0x65,
+	0x73, 0x18, 0xe8, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x0a, 0x6f, 0x6e, 0x65, 0x6f,
+	0x66, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x57, 0x0a, 0x0d, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0xe9, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2f,
+	0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x54, 0x65, 0x73, 0x74,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x48,
+	0x00, 0x52, 0x0c, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12,
+	0x55, 0x0a, 0x0a, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0xea, 0x04,
+	0x20, 0x01, 0x28, 0x0a, 0x32, 0x32, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x46, 0x69, 0x65,
+	0x6c, 0x64, 0x54, 0x65, 0x73, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x4f, 0x6e,
+	0x65, 0x6f, 0x66, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x48, 0x00, 0x52, 0x0a, 0x6f, 0x6e, 0x65, 0x6f,
+	0x66, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x30, 0x0a, 0x11, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f,
+	0x6c, 0x61, 0x72, 0x67, 0x65, 0x73, 0x74, 0x5f, 0x74, 0x61, 0x67, 0x18, 0xff, 0xff, 0xff, 0xff,
+	0x01, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, 0x0f, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x4c, 0x61,
+	0x72, 0x67, 0x65, 0x73, 0x74, 0x54, 0x61, 0x67, 0x12, 0x21, 0x0a, 0x0b, 0x6f, 0x6e, 0x65, 0x6f,
+	0x66, 0x5f, 0x74, 0x77, 0x6f, 0x5f, 0x31, 0x18, 0xbc, 0x05, 0x20, 0x01, 0x28, 0x05, 0x48, 0x01,
+	0x52, 0x09, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x54, 0x77, 0x6f, 0x31, 0x12, 0x21, 0x0a, 0x0b, 0x6f,
+	0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x74, 0x77, 0x6f, 0x5f, 0x32, 0x18, 0xbd, 0x05, 0x20, 0x01, 0x28,
+	0x03, 0x48, 0x01, 0x52, 0x09, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x54, 0x77, 0x6f, 0x32, 0x1a, 0x36,
+	0x0a, 0x0d, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12,
+	0x25, 0x0a, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x67, 0x72, 0x6f, 0x75,
+	0x70, 0x18, 0x13, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x1a, 0x36, 0x0a, 0x0d, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72,
+	0x65, 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x71, 0x75, 0x69,
+	0x72, 0x65, 0x64, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x77, 0x20, 0x02, 0x28, 0x09, 0x52,
+	0x0d, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x1a, 0x37,
+	0x0a, 0x0d, 0x52, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12,
+	0x26, 0x0a, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x67, 0x72, 0x6f, 0x75,
+	0x70, 0x18, 0xdb, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74,
+	0x65, 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x1a, 0x40, 0x0a, 0x12, 0x4d, 0x61, 0x70, 0x49, 0x6e,
+	0x74, 0x33, 0x32, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a,
+	0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12,
+	0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05,
+	0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x74, 0x0a, 0x15, 0x4d, 0x61, 0x70,
+	0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x45, 0x6e, 0x74,
+	0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x03, 0x6b, 0x65, 0x79, 0x12, 0x45, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x46, 0x69, 0x65, 0x6c,
+	0x64, 0x54, 0x65, 0x73, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a,
+	0x6f, 0x0a, 0x13, 0x4d, 0x61, 0x70, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x45, 0x6e, 0x75,
+	0x6d, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x06, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x42, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75,
+	0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2c, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e,
+	0x46, 0x69, 0x65, 0x6c, 0x64, 0x54, 0x65, 0x73, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01,
+	0x1a, 0x39, 0x0a, 0x0a, 0x4f, 0x6e, 0x65, 0x6f, 0x66, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x2b,
+	0x0a, 0x11, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x18, 0xeb, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x6f, 0x6e, 0x65, 0x6f,
+	0x66, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x1a, 0x09, 0x0a, 0x07, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x19, 0x0a, 0x04, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x08,
+	0x0a, 0x04, 0x5a, 0x45, 0x52, 0x4f, 0x10, 0x00, 0x12, 0x07, 0x0a, 0x03, 0x4f, 0x4e, 0x45, 0x10,
+	0x01, 0x42, 0x0d, 0x0a, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x42, 0x0b, 0x0a, 0x09, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x74, 0x77, 0x6f, 0x4a, 0x06, 0x08,
+	0x90, 0x4e, 0x10, 0x91, 0x4e, 0x4a, 0x06, 0x08, 0x91, 0x4e, 0x10, 0x92, 0x4e, 0x52, 0x0c, 0x54,
+	0x45, 0x4e, 0x5f, 0x54, 0x48, 0x4f, 0x55, 0x53, 0x41, 0x4e, 0x44, 0x52, 0x14, 0x54, 0x45, 0x4e,
+	0x5f, 0x54, 0x48, 0x4f, 0x55, 0x53, 0x41, 0x4e, 0x44, 0x5f, 0x41, 0x4e, 0x44, 0x5f, 0x4f, 0x4e,
+	0x45, 0x42, 0x3e, 0x5a, 0x3c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61,
+	0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f,
+	0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67,
+	0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x32,
+}
+
+var (
+	file_cmd_protoc_gen_go_testdata_proto2_fields_proto_rawDescOnce sync.Once
+	file_cmd_protoc_gen_go_testdata_proto2_fields_proto_rawDescData = file_cmd_protoc_gen_go_testdata_proto2_fields_proto_rawDesc
+)
+
+func file_cmd_protoc_gen_go_testdata_proto2_fields_proto_rawDescGZIP() []byte {
+	file_cmd_protoc_gen_go_testdata_proto2_fields_proto_rawDescOnce.Do(func() {
+		file_cmd_protoc_gen_go_testdata_proto2_fields_proto_rawDescData = protoimpl.X.CompressGZIP(file_cmd_protoc_gen_go_testdata_proto2_fields_proto_rawDescData)
+	})
+	return file_cmd_protoc_gen_go_testdata_proto2_fields_proto_rawDescData
+}
+
+var file_cmd_protoc_gen_go_testdata_proto2_fields_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
+var file_cmd_protoc_gen_go_testdata_proto2_fields_proto_msgTypes = make([]protoimpl.MessageInfo, 9)
+var file_cmd_protoc_gen_go_testdata_proto2_fields_proto_goTypes = []interface{}{
+	(FieldTestMessage_Enum)(0),             // 0: goproto.protoc.proto2.FieldTestMessage.Enum
+	(*FieldTestMessage)(nil),               // 1: goproto.protoc.proto2.FieldTestMessage
+	(*FieldTestMessage_OptionalGroup)(nil), // 2: goproto.protoc.proto2.FieldTestMessage.OptionalGroup
+	(*FieldTestMessage_RequiredGroup)(nil), // 3: goproto.protoc.proto2.FieldTestMessage.RequiredGroup
+	(*FieldTestMessage_RepeatedGroup)(nil), // 4: goproto.protoc.proto2.FieldTestMessage.RepeatedGroup
+	nil,                                    // 5: goproto.protoc.proto2.FieldTestMessage.MapInt32Int64Entry
+	nil,                                    // 6: goproto.protoc.proto2.FieldTestMessage.MapStringMessageEntry
+	nil,                                    // 7: goproto.protoc.proto2.FieldTestMessage.MapFixed64EnumEntry
+	(*FieldTestMessage_OneofGroup)(nil),    // 8: goproto.protoc.proto2.FieldTestMessage.OneofGroup
+	(*FieldTestMessage_Message)(nil),       // 9: goproto.protoc.proto2.FieldTestMessage.Message
+}
+var file_cmd_protoc_gen_go_testdata_proto2_fields_proto_depIdxs = []int32{
+	0,  // 0: goproto.protoc.proto2.FieldTestMessage.optional_enum:type_name -> goproto.protoc.proto2.FieldTestMessage.Enum
+	9,  // 1: goproto.protoc.proto2.FieldTestMessage.optional_Message:type_name -> goproto.protoc.proto2.FieldTestMessage.Message
+	2,  // 2: goproto.protoc.proto2.FieldTestMessage.optionalgroup:type_name -> goproto.protoc.proto2.FieldTestMessage.OptionalGroup
+	0,  // 3: goproto.protoc.proto2.FieldTestMessage.required_enum:type_name -> goproto.protoc.proto2.FieldTestMessage.Enum
+	9,  // 4: goproto.protoc.proto2.FieldTestMessage.required_Message:type_name -> goproto.protoc.proto2.FieldTestMessage.Message
+	3,  // 5: goproto.protoc.proto2.FieldTestMessage.requiredgroup:type_name -> goproto.protoc.proto2.FieldTestMessage.RequiredGroup
+	0,  // 6: goproto.protoc.proto2.FieldTestMessage.repeated_enum:type_name -> goproto.protoc.proto2.FieldTestMessage.Enum
+	9,  // 7: goproto.protoc.proto2.FieldTestMessage.repeated_Message:type_name -> goproto.protoc.proto2.FieldTestMessage.Message
+	4,  // 8: goproto.protoc.proto2.FieldTestMessage.repeatedgroup:type_name -> goproto.protoc.proto2.FieldTestMessage.RepeatedGroup
+	0,  // 9: goproto.protoc.proto2.FieldTestMessage.default_enum:type_name -> goproto.protoc.proto2.FieldTestMessage.Enum
+	5,  // 10: goproto.protoc.proto2.FieldTestMessage.map_int32_int64:type_name -> goproto.protoc.proto2.FieldTestMessage.MapInt32Int64Entry
+	6,  // 11: goproto.protoc.proto2.FieldTestMessage.map_string_message:type_name -> goproto.protoc.proto2.FieldTestMessage.MapStringMessageEntry
+	7,  // 12: goproto.protoc.proto2.FieldTestMessage.map_fixed64_enum:type_name -> goproto.protoc.proto2.FieldTestMessage.MapFixed64EnumEntry
+	0,  // 13: goproto.protoc.proto2.FieldTestMessage.oneof_enum:type_name -> goproto.protoc.proto2.FieldTestMessage.Enum
+	9,  // 14: goproto.protoc.proto2.FieldTestMessage.oneof_Message:type_name -> goproto.protoc.proto2.FieldTestMessage.Message
+	8,  // 15: goproto.protoc.proto2.FieldTestMessage.oneofgroup:type_name -> goproto.protoc.proto2.FieldTestMessage.OneofGroup
+	9,  // 16: goproto.protoc.proto2.FieldTestMessage.MapStringMessageEntry.value:type_name -> goproto.protoc.proto2.FieldTestMessage.Message
+	0,  // 17: goproto.protoc.proto2.FieldTestMessage.MapFixed64EnumEntry.value:type_name -> goproto.protoc.proto2.FieldTestMessage.Enum
+	18, // [18:18] is the sub-list for method output_type
+	18, // [18:18] is the sub-list for method input_type
+	18, // [18:18] is the sub-list for extension type_name
+	18, // [18:18] is the sub-list for extension extendee
+	0,  // [0:18] is the sub-list for field type_name
+}
+
+func init() { file_cmd_protoc_gen_go_testdata_proto2_fields_proto_init() }
+func file_cmd_protoc_gen_go_testdata_proto2_fields_proto_init() {
+	if File_cmd_protoc_gen_go_testdata_proto2_fields_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_cmd_protoc_gen_go_testdata_proto2_fields_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*FieldTestMessage); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cmd_protoc_gen_go_testdata_proto2_fields_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*FieldTestMessage_OptionalGroup); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cmd_protoc_gen_go_testdata_proto2_fields_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*FieldTestMessage_RequiredGroup); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cmd_protoc_gen_go_testdata_proto2_fields_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*FieldTestMessage_RepeatedGroup); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cmd_protoc_gen_go_testdata_proto2_fields_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*FieldTestMessage_OneofGroup); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cmd_protoc_gen_go_testdata_proto2_fields_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*FieldTestMessage_Message); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	file_cmd_protoc_gen_go_testdata_proto2_fields_proto_msgTypes[0].OneofWrappers = []interface{}{
+		(*FieldTestMessage_OneofBool)(nil),
+		(*FieldTestMessage_OneofEnum)(nil),
+		(*FieldTestMessage_OneofInt32)(nil),
+		(*FieldTestMessage_OneofSint32)(nil),
+		(*FieldTestMessage_OneofUint32)(nil),
+		(*FieldTestMessage_OneofInt64)(nil),
+		(*FieldTestMessage_OneofSint64)(nil),
+		(*FieldTestMessage_OneofUint64)(nil),
+		(*FieldTestMessage_OneofSfixed32)(nil),
+		(*FieldTestMessage_OneofFixed32)(nil),
+		(*FieldTestMessage_OneofFloat)(nil),
+		(*FieldTestMessage_OneofSfixed64)(nil),
+		(*FieldTestMessage_OneofFixed64)(nil),
+		(*FieldTestMessage_OneofDouble)(nil),
+		(*FieldTestMessage_OneofString)(nil),
+		(*FieldTestMessage_OneofBytes)(nil),
+		(*FieldTestMessage_Oneof_Message)(nil),
+		(*FieldTestMessage_Oneofgroup)(nil),
+		(*FieldTestMessage_OneofLargestTag)(nil),
+		(*FieldTestMessage_OneofTwo_1)(nil),
+		(*FieldTestMessage_OneofTwo_2)(nil),
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cmd_protoc_gen_go_testdata_proto2_fields_proto_rawDesc,
+			NumEnums:      1,
+			NumMessages:   9,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_cmd_protoc_gen_go_testdata_proto2_fields_proto_goTypes,
+		DependencyIndexes: file_cmd_protoc_gen_go_testdata_proto2_fields_proto_depIdxs,
+		EnumInfos:         file_cmd_protoc_gen_go_testdata_proto2_fields_proto_enumTypes,
+		MessageInfos:      file_cmd_protoc_gen_go_testdata_proto2_fields_proto_msgTypes,
+	}.Build()
+	File_cmd_protoc_gen_go_testdata_proto2_fields_proto = out.File
+	file_cmd_protoc_gen_go_testdata_proto2_fields_proto_rawDesc = nil
+	file_cmd_protoc_gen_go_testdata_proto2_fields_proto_goTypes = nil
+	file_cmd_protoc_gen_go_testdata_proto2_fields_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto2/fields.proto b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto2/fields.proto
new file mode 100644
index 000000000..f3c4c915e
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto2/fields.proto
@@ -0,0 +1,143 @@
+// 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.
+
+syntax = "proto2";
+
+package goproto.protoc.proto2;
+
+option go_package = "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto2";
+
+message FieldTestMessage {
+  optional bool     optional_bool     = 1;
+  optional Enum     optional_enum     = 2;
+  optional int32    optional_int32    = 3;
+  optional sint32   optional_sint32   = 4;
+  optional uint32   optional_uint32   = 5;
+  optional int64    optional_int64    = 6;
+  optional sint64   optional_sint64   = 7;
+  optional uint64   optional_uint64   = 8;
+  optional sfixed32 optional_sfixed32 = 9;
+  optional fixed32  optional_fixed32  = 10;
+  optional float    optional_float    = 11;
+  optional sfixed64 optional_sfixed64 = 12;
+  optional fixed64  optional_fixed64  = 13;
+  optional double   optional_double   = 14;
+  optional string   optional_string   = 15;
+  optional bytes    optional_bytes    = 16;
+  optional Message  optional_Message  = 17;
+  optional group OptionalGroup = 18 {
+    optional string optional_group = 19;
+  }
+
+  required bool     required_bool     = 101;
+  required Enum     required_enum     = 102;
+  required int32    required_int32    = 103;
+  required sint32   required_sint32   = 104;
+  required uint32   required_uint32   = 105;
+  required int64    required_int64    = 106;
+  required sint64   required_sint64   = 107;
+  required uint64   required_uint64   = 108;
+  required sfixed32 required_sfixed32 = 109;
+  required fixed32  required_fixed32  = 110;
+  required float    required_float    = 111;
+  required sfixed64 required_sfixed64 = 112;
+  required fixed64  required_fixed64  = 113;
+  required double   required_double   = 114;
+  required string   required_string   = 115;
+  required bytes    required_bytes    = 116;
+  required Message  required_Message  = 117;
+  required group RequiredGroup = 118 {
+    required string required_group = 119;
+  }
+
+  repeated bool     repeated_bool     = 201;
+  repeated Enum     repeated_enum     = 202;
+  repeated int32    repeated_int32    = 203;
+  repeated sint32   repeated_sint32   = 204;
+  repeated uint32   repeated_uint32   = 205;
+  repeated int64    repeated_int64    = 206;
+  repeated sint64   repeated_sint64   = 207;
+  repeated uint64   repeated_uint64   = 208;
+  repeated sfixed32 repeated_sfixed32 = 209;
+  repeated fixed32  repeated_fixed32  = 210;
+  repeated float    repeated_float    = 211;
+  repeated sfixed64 repeated_sfixed64 = 212;
+  repeated fixed64  repeated_fixed64  = 213;
+  repeated double   repeated_double   = 214;
+  repeated string   repeated_string   = 215;
+  repeated bytes    repeated_bytes    = 216;
+  repeated Message  repeated_Message  = 217;
+  repeated group RepeatedGroup = 218 {
+    repeated string repeated_group = 219;
+  }
+
+  optional bool     default_bool     = 301 [default=true];
+  optional Enum     default_enum     = 302 [default=ONE];
+  optional int32    default_int32    = 303 [default=1];
+  optional sint32   default_sint32   = 304 [default=1];
+  optional uint32   default_uint32   = 305 [default=1];
+  optional int64    default_int64    = 306 [default=1];
+  optional sint64   default_sint64   = 307 [default=1];
+  optional uint64   default_uint64   = 308 [default=1];
+  optional sfixed32 default_sfixed32 = 309 [default=1];
+  optional fixed32  default_fixed32  = 310 [default=1];
+  optional float    default_float    = 311 [default=3.14];
+  optional sfixed64 default_sfixed64 = 312 [default=1];
+  optional fixed64  default_fixed64  = 313 [default=1];
+  optional double   default_double   = 314 [default=3.1415];
+  optional string   default_string   = 315 [default="hello,\"world!\"\n"];
+  optional bytes    default_bytes    = 316 [default="hello,\xde\xad\xbe\xef"];
+
+  optional string default_zero_string = 350 [default=""];
+  optional bytes  default_zero_bytes  = 351 [default=""];
+
+  optional float  default_float_neginf  = 400 [default=-inf];
+  optional float  default_float_posinf  = 401 [default=inf];
+  optional float  default_float_nan     = 402 [default=nan];
+  optional double default_double_neginf = 403 [default=-inf];
+  optional double default_double_posinf = 404 [default=inf];
+  optional double default_double_nan    = 405 [default=nan];
+
+  map<int32, int64>   map_int32_int64    = 500;
+  map<string,Message> map_string_message = 501;
+  map<fixed64,Enum>   map_fixed64_enum   = 502;
+
+  oneof oneof_field {
+    bool     oneof_bool     = 601;
+    Enum     oneof_enum     = 602;
+    int32    oneof_int32    = 603;
+    sint32   oneof_sint32   = 604;
+    uint32   oneof_uint32   = 605;
+    int64    oneof_int64    = 606;
+    sint64   oneof_sint64   = 607;
+    uint64   oneof_uint64   = 608;
+    sfixed32 oneof_sfixed32 = 609;
+    fixed32  oneof_fixed32  = 610;
+    float    oneof_float    = 611;
+    sfixed64 oneof_sfixed64 = 612;
+    fixed64  oneof_fixed64  = 613;
+    double   oneof_double   = 614;
+    string   oneof_string   = 615;
+    bytes    oneof_bytes    = 616;
+    Message  oneof_Message  = 617;
+    group OneofGroup = 618 {
+      optional string oneof_group_field = 619;
+    }
+    int32 oneof_largest_tag = 536870911;
+  }
+
+  oneof oneof_two {
+    int32 oneof_two_1 = 700;
+    int64 oneof_two_2 = 701;
+  }
+
+  enum Enum {
+    ZERO = 0;
+    ONE = 1;
+  }
+  message Message {}
+
+  reserved 10000, 10001;
+  reserved "TEN_THOUSAND", "TEN_THOUSAND_AND_ONE";
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto2/nested_messages.pb.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto2/nested_messages.pb.go
new file mode 100644
index 000000000..9e7137a27
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto2/nested_messages.pb.go
@@ -0,0 +1,274 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: cmd/protoc-gen-go/testdata/proto2/nested_messages.proto
+
+package proto2
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type Layer1 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	L2 *Layer1_Layer2        `protobuf:"bytes,1,opt,name=l2" json:"l2,omitempty"`
+	L3 *Layer1_Layer2_Layer3 `protobuf:"bytes,2,opt,name=l3" json:"l3,omitempty"`
+}
+
+func (x *Layer1) Reset() {
+	*x = Layer1{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Layer1) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Layer1) ProtoMessage() {}
+
+func (x *Layer1) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Layer1.ProtoReflect.Descriptor instead.
+func (*Layer1) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Layer1) GetL2() *Layer1_Layer2 {
+	if x != nil {
+		return x.L2
+	}
+	return nil
+}
+
+func (x *Layer1) GetL3() *Layer1_Layer2_Layer3 {
+	if x != nil {
+		return x.L3
+	}
+	return nil
+}
+
+type Layer1_Layer2 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	L3 *Layer1_Layer2_Layer3 `protobuf:"bytes,1,opt,name=l3" json:"l3,omitempty"`
+}
+
+func (x *Layer1_Layer2) Reset() {
+	*x = Layer1_Layer2{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Layer1_Layer2) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Layer1_Layer2) ProtoMessage() {}
+
+func (x *Layer1_Layer2) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Layer1_Layer2.ProtoReflect.Descriptor instead.
+func (*Layer1_Layer2) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto_rawDescGZIP(), []int{0, 0}
+}
+
+func (x *Layer1_Layer2) GetL3() *Layer1_Layer2_Layer3 {
+	if x != nil {
+		return x.L3
+	}
+	return nil
+}
+
+type Layer1_Layer2_Layer3 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Layer1_Layer2_Layer3) Reset() {
+	*x = Layer1_Layer2_Layer3{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Layer1_Layer2_Layer3) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Layer1_Layer2_Layer3) ProtoMessage() {}
+
+func (x *Layer1_Layer2_Layer3) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Layer1_Layer2_Layer3.ProtoReflect.Descriptor instead.
+func (*Layer1_Layer2_Layer3) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto_rawDescGZIP(), []int{0, 0, 0}
+}
+
+var File_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto protoreflect.FileDescriptor
+
+var file_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto_rawDesc = []byte{
+	0x0a, 0x37, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x32, 0x2f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x15, 0x67, 0x6f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32,
+	0x22, 0xcc, 0x01, 0x0a, 0x06, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x31, 0x12, 0x34, 0x0a, 0x02, 0x6c,
+	0x32, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e,
+	0x4c, 0x61, 0x79, 0x65, 0x72, 0x31, 0x2e, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x32, 0x52, 0x02, 0x6c,
+	0x32, 0x12, 0x3b, 0x0a, 0x02, 0x6c, 0x33, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e,
+	0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x31, 0x2e, 0x4c, 0x61, 0x79,
+	0x65, 0x72, 0x32, 0x2e, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x33, 0x52, 0x02, 0x6c, 0x33, 0x1a, 0x4f,
+	0x0a, 0x06, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x32, 0x12, 0x3b, 0x0a, 0x02, 0x6c, 0x33, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x4c, 0x61, 0x79,
+	0x65, 0x72, 0x31, 0x2e, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x32, 0x2e, 0x4c, 0x61, 0x79, 0x65, 0x72,
+	0x33, 0x52, 0x02, 0x6c, 0x33, 0x1a, 0x08, 0x0a, 0x06, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x33, 0x42,
+	0x3e, 0x5a, 0x3c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67,
+	0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x63, 0x6d,
+	0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f,
+	0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32,
+}
+
+var (
+	file_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto_rawDescOnce sync.Once
+	file_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto_rawDescData = file_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto_rawDesc
+)
+
+func file_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto_rawDescGZIP() []byte {
+	file_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto_rawDescOnce.Do(func() {
+		file_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto_rawDescData = protoimpl.X.CompressGZIP(file_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto_rawDescData)
+	})
+	return file_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto_rawDescData
+}
+
+var file_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto_msgTypes = make([]protoimpl.MessageInfo, 3)
+var file_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto_goTypes = []interface{}{
+	(*Layer1)(nil),               // 0: goproto.protoc.proto2.Layer1
+	(*Layer1_Layer2)(nil),        // 1: goproto.protoc.proto2.Layer1.Layer2
+	(*Layer1_Layer2_Layer3)(nil), // 2: goproto.protoc.proto2.Layer1.Layer2.Layer3
+}
+var file_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto_depIdxs = []int32{
+	1, // 0: goproto.protoc.proto2.Layer1.l2:type_name -> goproto.protoc.proto2.Layer1.Layer2
+	2, // 1: goproto.protoc.proto2.Layer1.l3:type_name -> goproto.protoc.proto2.Layer1.Layer2.Layer3
+	2, // 2: goproto.protoc.proto2.Layer1.Layer2.l3:type_name -> goproto.protoc.proto2.Layer1.Layer2.Layer3
+	3, // [3:3] is the sub-list for method output_type
+	3, // [3:3] is the sub-list for method input_type
+	3, // [3:3] is the sub-list for extension type_name
+	3, // [3:3] is the sub-list for extension extendee
+	0, // [0:3] is the sub-list for field type_name
+}
+
+func init() { file_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto_init() }
+func file_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto_init() {
+	if File_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Layer1); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Layer1_Layer2); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Layer1_Layer2_Layer3); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   3,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto_goTypes,
+		DependencyIndexes: file_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto_depIdxs,
+		MessageInfos:      file_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto_msgTypes,
+	}.Build()
+	File_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto = out.File
+	file_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto_rawDesc = nil
+	file_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto_goTypes = nil
+	file_cmd_protoc_gen_go_testdata_proto2_nested_messages_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto2/nested_messages.proto b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto2/nested_messages.proto
new file mode 100644
index 000000000..e42af75f6
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto2/nested_messages.proto
@@ -0,0 +1,19 @@
+// 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.
+
+syntax = "proto2";
+
+package goproto.protoc.proto2;
+
+option go_package = "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto2";
+
+message Layer1 {
+  message Layer2 {
+    message Layer3 {
+    }
+    optional Layer3 l3 = 1;
+  }
+  optional Layer2 l2 = 1;
+  optional Layer2.Layer3 l3 = 2;
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto2/proto2.pb.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto2/proto2.pb.go
new file mode 100644
index 000000000..5a4f97d2a
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto2/proto2.pb.go
@@ -0,0 +1,153 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: cmd/protoc-gen-go/testdata/proto2/proto2.proto
+
+package proto2
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type Message struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	I32 *int32   `protobuf:"varint,1,opt,name=i32" json:"i32,omitempty"`
+	M   *Message `protobuf:"bytes,2,opt,name=m" json:"m,omitempty"`
+}
+
+func (x *Message) Reset() {
+	*x = Message{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_proto2_proto2_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message) ProtoMessage() {}
+
+func (x *Message) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_proto2_proto2_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message.ProtoReflect.Descriptor instead.
+func (*Message) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_proto2_proto2_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Message) GetI32() int32 {
+	if x != nil && x.I32 != nil {
+		return *x.I32
+	}
+	return 0
+}
+
+func (x *Message) GetM() *Message {
+	if x != nil {
+		return x.M
+	}
+	return nil
+}
+
+var File_cmd_protoc_gen_go_testdata_proto2_proto2_proto protoreflect.FileDescriptor
+
+var file_cmd_protoc_gen_go_testdata_proto2_proto2_proto_rawDesc = []byte{
+	0x0a, 0x2e, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x32, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x12, 0x15, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x22, 0x49, 0x0a, 0x07, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x69, 0x33, 0x32, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x03, 0x69, 0x33, 0x32, 0x12, 0x2c, 0x0a, 0x01, 0x6d, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x1e, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x01, 0x6d, 0x42, 0x3e, 0x5a, 0x3c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c,
+	0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
+	0x2f, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d,
+	0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x32,
+}
+
+var (
+	file_cmd_protoc_gen_go_testdata_proto2_proto2_proto_rawDescOnce sync.Once
+	file_cmd_protoc_gen_go_testdata_proto2_proto2_proto_rawDescData = file_cmd_protoc_gen_go_testdata_proto2_proto2_proto_rawDesc
+)
+
+func file_cmd_protoc_gen_go_testdata_proto2_proto2_proto_rawDescGZIP() []byte {
+	file_cmd_protoc_gen_go_testdata_proto2_proto2_proto_rawDescOnce.Do(func() {
+		file_cmd_protoc_gen_go_testdata_proto2_proto2_proto_rawDescData = protoimpl.X.CompressGZIP(file_cmd_protoc_gen_go_testdata_proto2_proto2_proto_rawDescData)
+	})
+	return file_cmd_protoc_gen_go_testdata_proto2_proto2_proto_rawDescData
+}
+
+var file_cmd_protoc_gen_go_testdata_proto2_proto2_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_cmd_protoc_gen_go_testdata_proto2_proto2_proto_goTypes = []interface{}{
+	(*Message)(nil), // 0: goproto.protoc.proto2.Message
+}
+var file_cmd_protoc_gen_go_testdata_proto2_proto2_proto_depIdxs = []int32{
+	0, // 0: goproto.protoc.proto2.Message.m:type_name -> goproto.protoc.proto2.Message
+	1, // [1:1] is the sub-list for method output_type
+	1, // [1:1] is the sub-list for method input_type
+	1, // [1:1] is the sub-list for extension type_name
+	1, // [1:1] is the sub-list for extension extendee
+	0, // [0:1] is the sub-list for field type_name
+}
+
+func init() { file_cmd_protoc_gen_go_testdata_proto2_proto2_proto_init() }
+func file_cmd_protoc_gen_go_testdata_proto2_proto2_proto_init() {
+	if File_cmd_protoc_gen_go_testdata_proto2_proto2_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_cmd_protoc_gen_go_testdata_proto2_proto2_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cmd_protoc_gen_go_testdata_proto2_proto2_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_cmd_protoc_gen_go_testdata_proto2_proto2_proto_goTypes,
+		DependencyIndexes: file_cmd_protoc_gen_go_testdata_proto2_proto2_proto_depIdxs,
+		MessageInfos:      file_cmd_protoc_gen_go_testdata_proto2_proto2_proto_msgTypes,
+	}.Build()
+	File_cmd_protoc_gen_go_testdata_proto2_proto2_proto = out.File
+	file_cmd_protoc_gen_go_testdata_proto2_proto2_proto_rawDesc = nil
+	file_cmd_protoc_gen_go_testdata_proto2_proto2_proto_goTypes = nil
+	file_cmd_protoc_gen_go_testdata_proto2_proto2_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto2/proto2.proto b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto2/proto2.proto
new file mode 100644
index 000000000..55e052eb1
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto2/proto2.proto
@@ -0,0 +1,15 @@
+// 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.
+
+syntax = "proto2";
+
+package goproto.protoc.proto2;
+
+option go_package = "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto2";
+
+message Message {
+  optional int32 i32 = 1;
+
+  optional Message m = 2;
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto3/enum.pb.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto3/enum.pb.go
new file mode 100644
index 000000000..2ff0fee56
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto3/enum.pb.go
@@ -0,0 +1,130 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: cmd/protoc-gen-go/testdata/proto3/enum.proto
+
+package proto3
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type Enum int32
+
+const (
+	Enum_ZERO Enum = 0
+	Enum_ONE  Enum = 1
+	Enum_TWO  Enum = 2
+)
+
+// Enum value maps for Enum.
+var (
+	Enum_name = map[int32]string{
+		0: "ZERO",
+		1: "ONE",
+		2: "TWO",
+	}
+	Enum_value = map[string]int32{
+		"ZERO": 0,
+		"ONE":  1,
+		"TWO":  2,
+	}
+)
+
+func (x Enum) Enum() *Enum {
+	p := new(Enum)
+	*p = x
+	return p
+}
+
+func (x Enum) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum) Descriptor() protoreflect.EnumDescriptor {
+	return file_cmd_protoc_gen_go_testdata_proto3_enum_proto_enumTypes[0].Descriptor()
+}
+
+func (Enum) Type() protoreflect.EnumType {
+	return &file_cmd_protoc_gen_go_testdata_proto3_enum_proto_enumTypes[0]
+}
+
+func (x Enum) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use Enum.Descriptor instead.
+func (Enum) EnumDescriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_proto3_enum_proto_rawDescGZIP(), []int{0}
+}
+
+var File_cmd_protoc_gen_go_testdata_proto3_enum_proto protoreflect.FileDescriptor
+
+var file_cmd_protoc_gen_go_testdata_proto3_enum_proto_rawDesc = []byte{
+	0x0a, 0x2c, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x33, 0x2f, 0x65, 0x6e, 0x75, 0x6d, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x15,
+	0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2a, 0x22, 0x0a, 0x04, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x08, 0x0a,
+	0x04, 0x5a, 0x45, 0x52, 0x4f, 0x10, 0x00, 0x12, 0x07, 0x0a, 0x03, 0x4f, 0x4e, 0x45, 0x10, 0x01,
+	0x12, 0x07, 0x0a, 0x03, 0x54, 0x57, 0x4f, 0x10, 0x02, 0x42, 0x3e, 0x5a, 0x3c, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61,
+	0x74, 0x61, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x33,
+}
+
+var (
+	file_cmd_protoc_gen_go_testdata_proto3_enum_proto_rawDescOnce sync.Once
+	file_cmd_protoc_gen_go_testdata_proto3_enum_proto_rawDescData = file_cmd_protoc_gen_go_testdata_proto3_enum_proto_rawDesc
+)
+
+func file_cmd_protoc_gen_go_testdata_proto3_enum_proto_rawDescGZIP() []byte {
+	file_cmd_protoc_gen_go_testdata_proto3_enum_proto_rawDescOnce.Do(func() {
+		file_cmd_protoc_gen_go_testdata_proto3_enum_proto_rawDescData = protoimpl.X.CompressGZIP(file_cmd_protoc_gen_go_testdata_proto3_enum_proto_rawDescData)
+	})
+	return file_cmd_protoc_gen_go_testdata_proto3_enum_proto_rawDescData
+}
+
+var file_cmd_protoc_gen_go_testdata_proto3_enum_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
+var file_cmd_protoc_gen_go_testdata_proto3_enum_proto_goTypes = []interface{}{
+	(Enum)(0), // 0: goproto.protoc.proto3.Enum
+}
+var file_cmd_protoc_gen_go_testdata_proto3_enum_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_cmd_protoc_gen_go_testdata_proto3_enum_proto_init() }
+func file_cmd_protoc_gen_go_testdata_proto3_enum_proto_init() {
+	if File_cmd_protoc_gen_go_testdata_proto3_enum_proto != nil {
+		return
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cmd_protoc_gen_go_testdata_proto3_enum_proto_rawDesc,
+			NumEnums:      1,
+			NumMessages:   0,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_cmd_protoc_gen_go_testdata_proto3_enum_proto_goTypes,
+		DependencyIndexes: file_cmd_protoc_gen_go_testdata_proto3_enum_proto_depIdxs,
+		EnumInfos:         file_cmd_protoc_gen_go_testdata_proto3_enum_proto_enumTypes,
+	}.Build()
+	File_cmd_protoc_gen_go_testdata_proto3_enum_proto = out.File
+	file_cmd_protoc_gen_go_testdata_proto3_enum_proto_rawDesc = nil
+	file_cmd_protoc_gen_go_testdata_proto3_enum_proto_goTypes = nil
+	file_cmd_protoc_gen_go_testdata_proto3_enum_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto3/enum.proto b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto3/enum.proto
new file mode 100644
index 000000000..595af3d91
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto3/enum.proto
@@ -0,0 +1,15 @@
+// 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.
+
+syntax = "proto3";
+
+package goproto.protoc.proto3;
+
+option go_package = "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto3";
+
+enum Enum {
+  ZERO = 0;
+  ONE = 1;
+  TWO = 2;
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto3/fields.pb.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto3/fields.pb.go
new file mode 100644
index 000000000..cba44b613
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto3/fields.pb.go
@@ -0,0 +1,678 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: cmd/protoc-gen-go/testdata/proto3/fields.proto
+
+package proto3
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type FieldTestMessage_Enum int32
+
+const (
+	FieldTestMessage_ZERO FieldTestMessage_Enum = 0
+)
+
+// Enum value maps for FieldTestMessage_Enum.
+var (
+	FieldTestMessage_Enum_name = map[int32]string{
+		0: "ZERO",
+	}
+	FieldTestMessage_Enum_value = map[string]int32{
+		"ZERO": 0,
+	}
+)
+
+func (x FieldTestMessage_Enum) Enum() *FieldTestMessage_Enum {
+	p := new(FieldTestMessage_Enum)
+	*p = x
+	return p
+}
+
+func (x FieldTestMessage_Enum) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (FieldTestMessage_Enum) Descriptor() protoreflect.EnumDescriptor {
+	return file_cmd_protoc_gen_go_testdata_proto3_fields_proto_enumTypes[0].Descriptor()
+}
+
+func (FieldTestMessage_Enum) Type() protoreflect.EnumType {
+	return &file_cmd_protoc_gen_go_testdata_proto3_fields_proto_enumTypes[0]
+}
+
+func (x FieldTestMessage_Enum) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use FieldTestMessage_Enum.Descriptor instead.
+func (FieldTestMessage_Enum) EnumDescriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_proto3_fields_proto_rawDescGZIP(), []int{0, 0}
+}
+
+type FieldTestMessage struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	OptionalBool     string                               `protobuf:"bytes,1,opt,name=optional_bool,json=optionalBool,proto3" json:"optional_bool,omitempty"`
+	OptionalEnum     FieldTestMessage_Enum                `protobuf:"varint,2,opt,name=optional_enum,json=optionalEnum,proto3,enum=goproto.protoc.proto3.FieldTestMessage_Enum" json:"optional_enum,omitempty"`
+	OptionalInt32    int32                                `protobuf:"varint,3,opt,name=optional_int32,json=optionalInt32,proto3" json:"optional_int32,omitempty"`
+	OptionalSint32   int32                                `protobuf:"zigzag32,4,opt,name=optional_sint32,json=optionalSint32,proto3" json:"optional_sint32,omitempty"`
+	OptionalUint32   uint32                               `protobuf:"varint,5,opt,name=optional_uint32,json=optionalUint32,proto3" json:"optional_uint32,omitempty"`
+	OptionalInt64    int64                                `protobuf:"varint,6,opt,name=optional_int64,json=optionalInt64,proto3" json:"optional_int64,omitempty"`
+	OptionalSint64   int64                                `protobuf:"zigzag64,7,opt,name=optional_sint64,json=optionalSint64,proto3" json:"optional_sint64,omitempty"`
+	OptionalUint64   uint64                               `protobuf:"varint,8,opt,name=optional_uint64,json=optionalUint64,proto3" json:"optional_uint64,omitempty"`
+	OptionalSfixed32 int32                                `protobuf:"fixed32,9,opt,name=optional_sfixed32,json=optionalSfixed32,proto3" json:"optional_sfixed32,omitempty"`
+	OptionalFixed32  uint32                               `protobuf:"fixed32,10,opt,name=optional_fixed32,json=optionalFixed32,proto3" json:"optional_fixed32,omitempty"`
+	OptionalFloat    float32                              `protobuf:"fixed32,11,opt,name=optional_float,json=optionalFloat,proto3" json:"optional_float,omitempty"`
+	OptionalSfixed64 int64                                `protobuf:"fixed64,12,opt,name=optional_sfixed64,json=optionalSfixed64,proto3" json:"optional_sfixed64,omitempty"`
+	OptionalFixed64  uint64                               `protobuf:"fixed64,13,opt,name=optional_fixed64,json=optionalFixed64,proto3" json:"optional_fixed64,omitempty"`
+	OptionalDouble   float64                              `protobuf:"fixed64,14,opt,name=optional_double,json=optionalDouble,proto3" json:"optional_double,omitempty"`
+	OptionalString   string                               `protobuf:"bytes,15,opt,name=optional_string,json=optionalString,proto3" json:"optional_string,omitempty"`
+	OptionalBytes    []byte                               `protobuf:"bytes,16,opt,name=optional_bytes,json=optionalBytes,proto3" json:"optional_bytes,omitempty"`
+	Optional_Message *FieldTestMessage_Message            `protobuf:"bytes,17,opt,name=optional_Message,json=optionalMessage,proto3" json:"optional_Message,omitempty"`
+	RepeatedBool     []bool                               `protobuf:"varint,201,rep,packed,name=repeated_bool,json=repeatedBool,proto3" json:"repeated_bool,omitempty"`
+	RepeatedEnum     []FieldTestMessage_Enum              `protobuf:"varint,202,rep,packed,name=repeated_enum,json=repeatedEnum,proto3,enum=goproto.protoc.proto3.FieldTestMessage_Enum" json:"repeated_enum,omitempty"`
+	RepeatedInt32    []int32                              `protobuf:"varint,203,rep,packed,name=repeated_int32,json=repeatedInt32,proto3" json:"repeated_int32,omitempty"`
+	RepeatedSint32   []int32                              `protobuf:"zigzag32,204,rep,packed,name=repeated_sint32,json=repeatedSint32,proto3" json:"repeated_sint32,omitempty"`
+	RepeatedUint32   []uint32                             `protobuf:"varint,205,rep,packed,name=repeated_uint32,json=repeatedUint32,proto3" json:"repeated_uint32,omitempty"`
+	RepeatedInt64    []int64                              `protobuf:"varint,206,rep,packed,name=repeated_int64,json=repeatedInt64,proto3" json:"repeated_int64,omitempty"`
+	RepeatedSint64   []int64                              `protobuf:"zigzag64,207,rep,packed,name=repeated_sint64,json=repeatedSint64,proto3" json:"repeated_sint64,omitempty"`
+	RepeatedUint64   []uint64                             `protobuf:"varint,208,rep,packed,name=repeated_uint64,json=repeatedUint64,proto3" json:"repeated_uint64,omitempty"`
+	RepeatedSfixed32 []int32                              `protobuf:"fixed32,209,rep,packed,name=repeated_sfixed32,json=repeatedSfixed32,proto3" json:"repeated_sfixed32,omitempty"`
+	RepeatedFixed32  []uint32                             `protobuf:"fixed32,210,rep,packed,name=repeated_fixed32,json=repeatedFixed32,proto3" json:"repeated_fixed32,omitempty"`
+	RepeatedFloat    []float32                            `protobuf:"fixed32,211,rep,packed,name=repeated_float,json=repeatedFloat,proto3" json:"repeated_float,omitempty"`
+	RepeatedSfixed64 []int64                              `protobuf:"fixed64,212,rep,packed,name=repeated_sfixed64,json=repeatedSfixed64,proto3" json:"repeated_sfixed64,omitempty"`
+	RepeatedFixed64  []uint64                             `protobuf:"fixed64,213,rep,packed,name=repeated_fixed64,json=repeatedFixed64,proto3" json:"repeated_fixed64,omitempty"`
+	RepeatedDouble   []float64                            `protobuf:"fixed64,214,rep,packed,name=repeated_double,json=repeatedDouble,proto3" json:"repeated_double,omitempty"`
+	RepeatedString   []string                             `protobuf:"bytes,215,rep,name=repeated_string,json=repeatedString,proto3" json:"repeated_string,omitempty"`
+	RepeatedBytes    [][]byte                             `protobuf:"bytes,216,rep,name=repeated_bytes,json=repeatedBytes,proto3" json:"repeated_bytes,omitempty"`
+	Repeated_Message []*FieldTestMessage_Message          `protobuf:"bytes,217,rep,name=repeated_Message,json=repeatedMessage,proto3" json:"repeated_Message,omitempty"`
+	MapInt32Int64    map[int32]int64                      `protobuf:"bytes,500,rep,name=map_int32_int64,json=mapInt32Int64,proto3" json:"map_int32_int64,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+	MapStringMessage map[string]*FieldTestMessage_Message `protobuf:"bytes,501,rep,name=map_string_message,json=mapStringMessage,proto3" json:"map_string_message,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	MapFixed64Enum   map[uint64]FieldTestMessage_Enum     `protobuf:"bytes,502,rep,name=map_fixed64_enum,json=mapFixed64Enum,proto3" json:"map_fixed64_enum,omitempty" protobuf_key:"fixed64,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3,enum=goproto.protoc.proto3.FieldTestMessage_Enum"`
+}
+
+func (x *FieldTestMessage) Reset() {
+	*x = FieldTestMessage{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_proto3_fields_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *FieldTestMessage) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*FieldTestMessage) ProtoMessage() {}
+
+func (x *FieldTestMessage) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_proto3_fields_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use FieldTestMessage.ProtoReflect.Descriptor instead.
+func (*FieldTestMessage) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_proto3_fields_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *FieldTestMessage) GetOptionalBool() string {
+	if x != nil {
+		return x.OptionalBool
+	}
+	return ""
+}
+
+func (x *FieldTestMessage) GetOptionalEnum() FieldTestMessage_Enum {
+	if x != nil {
+		return x.OptionalEnum
+	}
+	return FieldTestMessage_ZERO
+}
+
+func (x *FieldTestMessage) GetOptionalInt32() int32 {
+	if x != nil {
+		return x.OptionalInt32
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOptionalSint32() int32 {
+	if x != nil {
+		return x.OptionalSint32
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOptionalUint32() uint32 {
+	if x != nil {
+		return x.OptionalUint32
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOptionalInt64() int64 {
+	if x != nil {
+		return x.OptionalInt64
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOptionalSint64() int64 {
+	if x != nil {
+		return x.OptionalSint64
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOptionalUint64() uint64 {
+	if x != nil {
+		return x.OptionalUint64
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOptionalSfixed32() int32 {
+	if x != nil {
+		return x.OptionalSfixed32
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOptionalFixed32() uint32 {
+	if x != nil {
+		return x.OptionalFixed32
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOptionalFloat() float32 {
+	if x != nil {
+		return x.OptionalFloat
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOptionalSfixed64() int64 {
+	if x != nil {
+		return x.OptionalSfixed64
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOptionalFixed64() uint64 {
+	if x != nil {
+		return x.OptionalFixed64
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOptionalDouble() float64 {
+	if x != nil {
+		return x.OptionalDouble
+	}
+	return 0
+}
+
+func (x *FieldTestMessage) GetOptionalString() string {
+	if x != nil {
+		return x.OptionalString
+	}
+	return ""
+}
+
+func (x *FieldTestMessage) GetOptionalBytes() []byte {
+	if x != nil {
+		return x.OptionalBytes
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetOptional_Message() *FieldTestMessage_Message {
+	if x != nil {
+		return x.Optional_Message
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRepeatedBool() []bool {
+	if x != nil {
+		return x.RepeatedBool
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRepeatedEnum() []FieldTestMessage_Enum {
+	if x != nil {
+		return x.RepeatedEnum
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRepeatedInt32() []int32 {
+	if x != nil {
+		return x.RepeatedInt32
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRepeatedSint32() []int32 {
+	if x != nil {
+		return x.RepeatedSint32
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRepeatedUint32() []uint32 {
+	if x != nil {
+		return x.RepeatedUint32
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRepeatedInt64() []int64 {
+	if x != nil {
+		return x.RepeatedInt64
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRepeatedSint64() []int64 {
+	if x != nil {
+		return x.RepeatedSint64
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRepeatedUint64() []uint64 {
+	if x != nil {
+		return x.RepeatedUint64
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRepeatedSfixed32() []int32 {
+	if x != nil {
+		return x.RepeatedSfixed32
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRepeatedFixed32() []uint32 {
+	if x != nil {
+		return x.RepeatedFixed32
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRepeatedFloat() []float32 {
+	if x != nil {
+		return x.RepeatedFloat
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRepeatedSfixed64() []int64 {
+	if x != nil {
+		return x.RepeatedSfixed64
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRepeatedFixed64() []uint64 {
+	if x != nil {
+		return x.RepeatedFixed64
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRepeatedDouble() []float64 {
+	if x != nil {
+		return x.RepeatedDouble
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRepeatedString() []string {
+	if x != nil {
+		return x.RepeatedString
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRepeatedBytes() [][]byte {
+	if x != nil {
+		return x.RepeatedBytes
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetRepeated_Message() []*FieldTestMessage_Message {
+	if x != nil {
+		return x.Repeated_Message
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetMapInt32Int64() map[int32]int64 {
+	if x != nil {
+		return x.MapInt32Int64
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetMapStringMessage() map[string]*FieldTestMessage_Message {
+	if x != nil {
+		return x.MapStringMessage
+	}
+	return nil
+}
+
+func (x *FieldTestMessage) GetMapFixed64Enum() map[uint64]FieldTestMessage_Enum {
+	if x != nil {
+		return x.MapFixed64Enum
+	}
+	return nil
+}
+
+type FieldTestMessage_Message struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *FieldTestMessage_Message) Reset() {
+	*x = FieldTestMessage_Message{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cmd_protoc_gen_go_testdata_proto3_fields_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *FieldTestMessage_Message) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*FieldTestMessage_Message) ProtoMessage() {}
+
+func (x *FieldTestMessage_Message) ProtoReflect() protoreflect.Message {
+	mi := &file_cmd_protoc_gen_go_testdata_proto3_fields_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use FieldTestMessage_Message.ProtoReflect.Descriptor instead.
+func (*FieldTestMessage_Message) Descriptor() ([]byte, []int) {
+	return file_cmd_protoc_gen_go_testdata_proto3_fields_proto_rawDescGZIP(), []int{0, 3}
+}
+
+var File_cmd_protoc_gen_go_testdata_proto3_fields_proto protoreflect.FileDescriptor
+
+var file_cmd_protoc_gen_go_testdata_proto3_fields_proto_rawDesc = []byte{
+	0x0a, 0x2e, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e,
+	0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x33, 0x2f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x12, 0x15, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x22, 0xd0, 0x11, 0x0a, 0x10, 0x46, 0x69, 0x65, 0x6c,
+	0x64, 0x54, 0x65, 0x73, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x23, 0x0a, 0x0d,
+	0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x0c, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x42, 0x6f, 0x6f,
+	0x6c, 0x12, 0x51, 0x0a, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x65, 0x6e,
+	0x75, 0x6d, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2c, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x54, 0x65, 0x73, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0c, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x45, 0x6e, 0x75, 0x6d, 0x12, 0x25, 0x0a, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x6f, 0x70,
+	0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x27, 0x0a, 0x0f, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x04,
+	0x20, 0x01, 0x28, 0x11, 0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x69,
+	0x6e, 0x74, 0x33, 0x32, 0x12, 0x27, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0e, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x25, 0x0a,
+	0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18,
+	0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x49,
+	0x6e, 0x74, 0x36, 0x34, 0x12, 0x27, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x5f, 0x73, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x07, 0x20, 0x01, 0x28, 0x12, 0x52, 0x0e, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x27, 0x0a,
+	0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34,
+	0x18, 0x08, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x2b, 0x0a, 0x11, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+	0x61, 0x6c, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x09, 0x20, 0x01, 0x28,
+	0x0f, 0x52, 0x10, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x66, 0x69, 0x78, 0x65,
+	0x64, 0x33, 0x32, 0x12, 0x29, 0x0a, 0x10, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f,
+	0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x07, 0x52, 0x0f, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x25,
+	0x0a, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74,
+	0x18, 0x0b, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x2b, 0x0a, 0x11, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x10,
+	0x52, 0x10, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64,
+	0x36, 0x34, 0x12, 0x29, 0x0a, 0x10, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x66,
+	0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x06, 0x52, 0x0f, 0x6f, 0x70,
+	0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x27, 0x0a,
+	0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65,
+	0x18, 0x0e, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+	0x61, 0x6c, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12,
+	0x25, 0x0a, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x62, 0x79, 0x74, 0x65,
+	0x73, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x5a, 0x0a, 0x10, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+	0x61, 0x6c, 0x5f, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x11, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x2f, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x54, 0x65,
+	0x73, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x52, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x12, 0x24, 0x0a, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x62,
+	0x6f, 0x6f, 0x6c, 0x18, 0xc9, 0x01, 0x20, 0x03, 0x28, 0x08, 0x52, 0x0c, 0x72, 0x65, 0x70, 0x65,
+	0x61, 0x74, 0x65, 0x64, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x52, 0x0a, 0x0d, 0x72, 0x65, 0x70, 0x65,
+	0x61, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0xca, 0x01, 0x20, 0x03, 0x28, 0x0e,
+	0x32, 0x2c, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x54, 0x65,
+	0x73, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0c,
+	0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x26, 0x0a, 0x0e,
+	0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0xcb,
+	0x01, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x49,
+	0x6e, 0x74, 0x33, 0x32, 0x12, 0x28, 0x0a, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
+	0x5f, 0x73, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0xcc, 0x01, 0x20, 0x03, 0x28, 0x11, 0x52, 0x0e,
+	0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x28,
+	0x0a, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33,
+	0x32, 0x18, 0xcd, 0x01, 0x20, 0x03, 0x28, 0x0d, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74,
+	0x65, 0x64, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x26, 0x0a, 0x0e, 0x72, 0x65, 0x70, 0x65,
+	0x61, 0x74, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0xce, 0x01, 0x20, 0x03, 0x28,
+	0x03, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x49, 0x6e, 0x74, 0x36, 0x34,
+	0x12, 0x28, 0x0a, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x73, 0x69, 0x6e,
+	0x74, 0x36, 0x34, 0x18, 0xcf, 0x01, 0x20, 0x03, 0x28, 0x12, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65,
+	0x61, 0x74, 0x65, 0x64, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x28, 0x0a, 0x0f, 0x72, 0x65,
+	0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0xd0, 0x01,
+	0x20, 0x03, 0x28, 0x04, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x55, 0x69,
+	0x6e, 0x74, 0x36, 0x34, 0x12, 0x2c, 0x0a, 0x11, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
+	0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0xd1, 0x01, 0x20, 0x03, 0x28, 0x0f,
+	0x52, 0x10, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64,
+	0x33, 0x32, 0x12, 0x2a, 0x0a, 0x10, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x66,
+	0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0xd2, 0x01, 0x20, 0x03, 0x28, 0x07, 0x52, 0x0f, 0x72,
+	0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x26,
+	0x0a, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74,
+	0x18, 0xd3, 0x01, 0x20, 0x03, 0x28, 0x02, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65,
+	0x64, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x2c, 0x0a, 0x11, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74,
+	0x65, 0x64, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0xd4, 0x01, 0x20, 0x03,
+	0x28, 0x10, 0x52, 0x10, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x53, 0x66, 0x69, 0x78,
+	0x65, 0x64, 0x36, 0x34, 0x12, 0x2a, 0x0a, 0x10, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
+	0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0xd5, 0x01, 0x20, 0x03, 0x28, 0x06, 0x52,
+	0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34,
+	0x12, 0x28, 0x0a, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x64, 0x6f, 0x75,
+	0x62, 0x6c, 0x65, 0x18, 0xd6, 0x01, 0x20, 0x03, 0x28, 0x01, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65,
+	0x61, 0x74, 0x65, 0x64, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x28, 0x0a, 0x0f, 0x72, 0x65,
+	0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0xd7, 0x01,
+	0x20, 0x03, 0x28, 0x09, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x53, 0x74,
+	0x72, 0x69, 0x6e, 0x67, 0x12, 0x26, 0x0a, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
+	0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0xd8, 0x01, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x0d, 0x72,
+	0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x5b, 0x0a, 0x10,
+	0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x18, 0xd9, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e,
+	0x46, 0x69, 0x65, 0x6c, 0x64, 0x54, 0x65, 0x73, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74,
+	0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x63, 0x0a, 0x0f, 0x6d, 0x61, 0x70,
+	0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0xf4, 0x03, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x3a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x46, 0x69, 0x65, 0x6c,
+	0x64, 0x54, 0x65, 0x73, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x4d, 0x61, 0x70,
+	0x49, 0x6e, 0x74, 0x33, 0x32, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52,
+	0x0d, 0x6d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x6c,
+	0x0a, 0x12, 0x6d, 0x61, 0x70, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x18, 0xf5, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3d, 0x2e, 0x67, 0x6f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x33, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x54, 0x65, 0x73, 0x74, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x10, 0x6d, 0x61, 0x70, 0x53,
+	0x74, 0x72, 0x69, 0x6e, 0x67, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x66, 0x0a, 0x10,
+	0x6d, 0x61, 0x70, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x5f, 0x65, 0x6e, 0x75, 0x6d,
+	0x18, 0xf6, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3b, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e,
+	0x46, 0x69, 0x65, 0x6c, 0x64, 0x54, 0x65, 0x73, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x2e, 0x4d, 0x61, 0x70, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x45, 0x6e, 0x75, 0x6d, 0x45,
+	0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, 0x6d, 0x61, 0x70, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34,
+	0x45, 0x6e, 0x75, 0x6d, 0x1a, 0x40, 0x0a, 0x12, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x33, 0x32,
+	0x49, 0x6e, 0x74, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65,
+	0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05,
+	0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, 0x61, 0x6c,
+	0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x74, 0x0a, 0x15, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72,
+	0x69, 0x6e, 0x67, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12,
+	0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65,
+	0x79, 0x12, 0x45, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x2f, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x54, 0x65,
+	0x73, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x6f, 0x0a, 0x13,
+	0x4d, 0x61, 0x70, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x45, 0x6e, 0x75, 0x6d, 0x45, 0x6e,
+	0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x06,
+	0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x42, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x0e, 0x32, 0x2c, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x46, 0x69, 0x65,
+	0x6c, 0x64, 0x54, 0x65, 0x73, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x45, 0x6e,
+	0x75, 0x6d, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x09, 0x0a,
+	0x07, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x10, 0x0a, 0x04, 0x45, 0x6e, 0x75, 0x6d,
+	0x12, 0x08, 0x0a, 0x04, 0x5a, 0x45, 0x52, 0x4f, 0x10, 0x00, 0x42, 0x3e, 0x5a, 0x3c, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64,
+	0x61, 0x74, 0x61, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x33,
+}
+
+var (
+	file_cmd_protoc_gen_go_testdata_proto3_fields_proto_rawDescOnce sync.Once
+	file_cmd_protoc_gen_go_testdata_proto3_fields_proto_rawDescData = file_cmd_protoc_gen_go_testdata_proto3_fields_proto_rawDesc
+)
+
+func file_cmd_protoc_gen_go_testdata_proto3_fields_proto_rawDescGZIP() []byte {
+	file_cmd_protoc_gen_go_testdata_proto3_fields_proto_rawDescOnce.Do(func() {
+		file_cmd_protoc_gen_go_testdata_proto3_fields_proto_rawDescData = protoimpl.X.CompressGZIP(file_cmd_protoc_gen_go_testdata_proto3_fields_proto_rawDescData)
+	})
+	return file_cmd_protoc_gen_go_testdata_proto3_fields_proto_rawDescData
+}
+
+var file_cmd_protoc_gen_go_testdata_proto3_fields_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
+var file_cmd_protoc_gen_go_testdata_proto3_fields_proto_msgTypes = make([]protoimpl.MessageInfo, 5)
+var file_cmd_protoc_gen_go_testdata_proto3_fields_proto_goTypes = []interface{}{
+	(FieldTestMessage_Enum)(0),       // 0: goproto.protoc.proto3.FieldTestMessage.Enum
+	(*FieldTestMessage)(nil),         // 1: goproto.protoc.proto3.FieldTestMessage
+	nil,                              // 2: goproto.protoc.proto3.FieldTestMessage.MapInt32Int64Entry
+	nil,                              // 3: goproto.protoc.proto3.FieldTestMessage.MapStringMessageEntry
+	nil,                              // 4: goproto.protoc.proto3.FieldTestMessage.MapFixed64EnumEntry
+	(*FieldTestMessage_Message)(nil), // 5: goproto.protoc.proto3.FieldTestMessage.Message
+}
+var file_cmd_protoc_gen_go_testdata_proto3_fields_proto_depIdxs = []int32{
+	0, // 0: goproto.protoc.proto3.FieldTestMessage.optional_enum:type_name -> goproto.protoc.proto3.FieldTestMessage.Enum
+	5, // 1: goproto.protoc.proto3.FieldTestMessage.optional_Message:type_name -> goproto.protoc.proto3.FieldTestMessage.Message
+	0, // 2: goproto.protoc.proto3.FieldTestMessage.repeated_enum:type_name -> goproto.protoc.proto3.FieldTestMessage.Enum
+	5, // 3: goproto.protoc.proto3.FieldTestMessage.repeated_Message:type_name -> goproto.protoc.proto3.FieldTestMessage.Message
+	2, // 4: goproto.protoc.proto3.FieldTestMessage.map_int32_int64:type_name -> goproto.protoc.proto3.FieldTestMessage.MapInt32Int64Entry
+	3, // 5: goproto.protoc.proto3.FieldTestMessage.map_string_message:type_name -> goproto.protoc.proto3.FieldTestMessage.MapStringMessageEntry
+	4, // 6: goproto.protoc.proto3.FieldTestMessage.map_fixed64_enum:type_name -> goproto.protoc.proto3.FieldTestMessage.MapFixed64EnumEntry
+	5, // 7: goproto.protoc.proto3.FieldTestMessage.MapStringMessageEntry.value:type_name -> goproto.protoc.proto3.FieldTestMessage.Message
+	0, // 8: goproto.protoc.proto3.FieldTestMessage.MapFixed64EnumEntry.value:type_name -> goproto.protoc.proto3.FieldTestMessage.Enum
+	9, // [9:9] is the sub-list for method output_type
+	9, // [9:9] is the sub-list for method input_type
+	9, // [9:9] is the sub-list for extension type_name
+	9, // [9:9] is the sub-list for extension extendee
+	0, // [0:9] is the sub-list for field type_name
+}
+
+func init() { file_cmd_protoc_gen_go_testdata_proto3_fields_proto_init() }
+func file_cmd_protoc_gen_go_testdata_proto3_fields_proto_init() {
+	if File_cmd_protoc_gen_go_testdata_proto3_fields_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_cmd_protoc_gen_go_testdata_proto3_fields_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*FieldTestMessage); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cmd_protoc_gen_go_testdata_proto3_fields_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*FieldTestMessage_Message); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cmd_protoc_gen_go_testdata_proto3_fields_proto_rawDesc,
+			NumEnums:      1,
+			NumMessages:   5,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_cmd_protoc_gen_go_testdata_proto3_fields_proto_goTypes,
+		DependencyIndexes: file_cmd_protoc_gen_go_testdata_proto3_fields_proto_depIdxs,
+		EnumInfos:         file_cmd_protoc_gen_go_testdata_proto3_fields_proto_enumTypes,
+		MessageInfos:      file_cmd_protoc_gen_go_testdata_proto3_fields_proto_msgTypes,
+	}.Build()
+	File_cmd_protoc_gen_go_testdata_proto3_fields_proto = out.File
+	file_cmd_protoc_gen_go_testdata_proto3_fields_proto_rawDesc = nil
+	file_cmd_protoc_gen_go_testdata_proto3_fields_proto_goTypes = nil
+	file_cmd_protoc_gen_go_testdata_proto3_fields_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto3/fields.proto b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto3/fields.proto
new file mode 100644
index 000000000..1dfd7057e
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto3/fields.proto
@@ -0,0 +1,55 @@
+// 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.
+
+syntax = "proto3";
+
+package goproto.protoc.proto3;
+
+option go_package = "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/proto3";
+
+message FieldTestMessage {
+  string   optional_bool     = 1;
+  Enum     optional_enum     = 2;
+  int32    optional_int32    = 3;
+  sint32   optional_sint32   = 4;
+  uint32   optional_uint32   = 5;
+  int64    optional_int64    = 6;
+  sint64   optional_sint64   = 7;
+  uint64   optional_uint64   = 8;
+  sfixed32 optional_sfixed32 = 9;
+  fixed32  optional_fixed32  = 10;
+  float    optional_float    = 11;
+  sfixed64 optional_sfixed64 = 12;
+  fixed64  optional_fixed64  = 13;
+  double   optional_double   = 14;
+  string   optional_string   = 15;
+  bytes    optional_bytes    = 16;
+  Message  optional_Message  = 17;
+
+  repeated bool     repeated_bool     = 201;
+  repeated Enum     repeated_enum     = 202;
+  repeated int32    repeated_int32    = 203;
+  repeated sint32   repeated_sint32   = 204;
+  repeated uint32   repeated_uint32   = 205;
+  repeated int64    repeated_int64    = 206;
+  repeated sint64   repeated_sint64   = 207;
+  repeated uint64   repeated_uint64   = 208;
+  repeated sfixed32 repeated_sfixed32 = 209;
+  repeated fixed32  repeated_fixed32  = 210;
+  repeated float    repeated_float    = 211;
+  repeated sfixed64 repeated_sfixed64 = 212;
+  repeated fixed64  repeated_fixed64  = 213;
+  repeated double   repeated_double   = 214;
+  repeated string   repeated_string   = 215;
+  repeated bytes    repeated_bytes    = 216;
+  repeated Message  repeated_Message  = 217;
+
+  map<int32, int64>   map_int32_int64    = 500;
+  map<string,Message> map_string_message = 501;
+  map<fixed64,Enum>   map_fixed64_enum   = 502;
+
+  enum Enum { ZERO = 0; }
+  message Message {}
+}
+
diff --git a/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/registry_test.go b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/registry_test.go
new file mode 100644
index 000000000..aca90369d
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/cmd/protoc-gen-go/testdata/registry_test.go
@@ -0,0 +1,27 @@
+// Copyright 2019 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 main
+
+import (
+	"testing"
+
+	"google.golang.org/protobuf/internal/filedesc"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/reflect/protoregistry"
+)
+
+func TestRegistry(t *testing.T) {
+	var hasFiles bool
+	protoregistry.GlobalFiles.RangeFiles(func(fd protoreflect.FileDescriptor) bool {
+		if fd.(*filedesc.File).L2 != nil {
+			t.Errorf("file %q eagerly went through lazy initialization", fd.Path())
+		}
+		hasFiles = true
+		return true
+	})
+	if !hasFiles {
+		t.Errorf("protoregistry.GlobalFiles is empty")
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/compiler/protogen/protogen.go b/vendor/google.golang.org/protobuf/compiler/protogen/protogen.go
new file mode 100644
index 000000000..b3f7a6ee1
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/compiler/protogen/protogen.go
@@ -0,0 +1,1419 @@
+// 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 protogen provides support for writing protoc plugins.
+//
+// Plugins for protoc, the Protocol Buffer compiler,
+// are programs which read a CodeGeneratorRequest message from standard input
+// and write a CodeGeneratorResponse message to standard output.
+// This package provides support for writing plugins which generate Go code.
+package protogen
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/printer"
+	"go/token"
+	"go/types"
+	"io/ioutil"
+	"log"
+	"os"
+	"path"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+
+	"google.golang.org/protobuf/encoding/prototext"
+	"google.golang.org/protobuf/internal/fieldnum"
+	"google.golang.org/protobuf/internal/strs"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protodesc"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/reflect/protoregistry"
+
+	"google.golang.org/protobuf/types/descriptorpb"
+	"google.golang.org/protobuf/types/pluginpb"
+)
+
+const goPackageDocURL = "https://developers.google.com/protocol-buffers/docs/reference/go-generated#package"
+
+// Run executes a function as a protoc plugin.
+//
+// It reads a CodeGeneratorRequest message from os.Stdin, invokes the plugin
+// function, and writes a CodeGeneratorResponse message to os.Stdout.
+//
+// If a failure occurs while reading or writing, Run prints an error to
+// os.Stderr and calls os.Exit(1).
+func (opts Options) Run(f func(*Plugin) error) {
+	if err := run(opts, f); err != nil {
+		fmt.Fprintf(os.Stderr, "%s: %v\n", filepath.Base(os.Args[0]), err)
+		os.Exit(1)
+	}
+}
+
+func run(opts Options, f func(*Plugin) error) error {
+	if len(os.Args) > 1 {
+		return fmt.Errorf("unknown argument %q (this program should be run by protoc, not directly)", os.Args[1])
+	}
+	in, err := ioutil.ReadAll(os.Stdin)
+	if err != nil {
+		return err
+	}
+	req := &pluginpb.CodeGeneratorRequest{}
+	if err := proto.Unmarshal(in, req); err != nil {
+		return err
+	}
+	gen, err := opts.New(req)
+	if err != nil {
+		return err
+	}
+	if err := f(gen); err != nil {
+		// Errors from the plugin function are reported by setting the
+		// error field in the CodeGeneratorResponse.
+		//
+		// In contrast, errors that indicate a problem in protoc
+		// itself (unparsable input, I/O errors, etc.) are reported
+		// to stderr.
+		gen.Error(err)
+	}
+	resp := gen.Response()
+	out, err := proto.Marshal(resp)
+	if err != nil {
+		return err
+	}
+	if _, err := os.Stdout.Write(out); err != nil {
+		return err
+	}
+	return nil
+}
+
+// A Plugin is a protoc plugin invocation.
+type Plugin struct {
+	// Request is the CodeGeneratorRequest provided by protoc.
+	Request *pluginpb.CodeGeneratorRequest
+
+	// Files is the set of files to generate and everything they import.
+	// Files appear in topological order, so each file appears before any
+	// file that imports it.
+	Files       []*File
+	FilesByPath map[string]*File
+
+	// SupportedFeatures is the set of protobuf language features supported by
+	// this generator plugin. See the documentation for
+	// google.protobuf.CodeGeneratorResponse.supported_features for details.
+	SupportedFeatures uint64
+
+	fileReg        *protoregistry.Files
+	enumsByName    map[protoreflect.FullName]*Enum
+	messagesByName map[protoreflect.FullName]*Message
+	annotateCode   bool
+	pathType       pathType
+	module         string
+	genFiles       []*GeneratedFile
+	opts           Options
+	err            error
+}
+
+type Options struct {
+	// If ParamFunc is non-nil, it will be called with each unknown
+	// generator parameter.
+	//
+	// Plugins for protoc can accept parameters from the command line,
+	// passed in the --<lang>_out protoc, separated from the output
+	// directory with a colon; e.g.,
+	//
+	//   --go_out=<param1>=<value1>,<param2>=<value2>:<output_directory>
+	//
+	// Parameters passed in this fashion as a comma-separated list of
+	// key=value pairs will be passed to the ParamFunc.
+	//
+	// The (flag.FlagSet).Set method matches this function signature,
+	// so parameters can be converted into flags as in the following:
+	//
+	//   var flags flag.FlagSet
+	//   value := flags.Bool("param", false, "")
+	//   opts := &protogen.Options{
+	//     ParamFunc: flags.Set,
+	//   }
+	//   protogen.Run(opts, func(p *protogen.Plugin) error {
+	//     if *value { ... }
+	//   })
+	ParamFunc func(name, value string) error
+
+	// ImportRewriteFunc is called with the import path of each package
+	// imported by a generated file. It returns the import path to use
+	// for this package.
+	ImportRewriteFunc func(GoImportPath) GoImportPath
+}
+
+// New returns a new Plugin.
+func (opts Options) New(req *pluginpb.CodeGeneratorRequest) (*Plugin, error) {
+	gen := &Plugin{
+		Request:        req,
+		FilesByPath:    make(map[string]*File),
+		fileReg:        new(protoregistry.Files),
+		enumsByName:    make(map[protoreflect.FullName]*Enum),
+		messagesByName: make(map[protoreflect.FullName]*Message),
+		opts:           opts,
+	}
+
+	packageNames := make(map[string]GoPackageName) // filename -> package name
+	importPaths := make(map[string]GoImportPath)   // filename -> import path
+	mfiles := make(map[string]bool)                // filename set
+	var packageImportPath GoImportPath
+	for _, param := range strings.Split(req.GetParameter(), ",") {
+		var value string
+		if i := strings.Index(param, "="); i >= 0 {
+			value = param[i+1:]
+			param = param[0:i]
+		}
+		switch param {
+		case "":
+			// Ignore.
+		case "import_path":
+			packageImportPath = GoImportPath(value)
+		case "module":
+			gen.module = value
+		case "paths":
+			switch value {
+			case "import":
+				gen.pathType = pathTypeImport
+			case "source_relative":
+				gen.pathType = pathTypeSourceRelative
+			default:
+				return nil, fmt.Errorf(`unknown path type %q: want "import" or "source_relative"`, value)
+			}
+		case "annotate_code":
+			switch value {
+			case "true", "":
+				gen.annotateCode = true
+			case "false":
+			default:
+				return nil, fmt.Errorf(`bad value for parameter %q: want "true" or "false"`, param)
+			}
+		default:
+			if param[0] == 'M' {
+				if i := strings.Index(value, ";"); i >= 0 {
+					pkgName := GoPackageName(value[i+1:])
+					if otherName, ok := packageNames[param[1:]]; ok && pkgName != otherName {
+						return nil, fmt.Errorf("inconsistent package names for %q: %q != %q", value[:i], pkgName, otherName)
+					}
+					packageNames[param[1:]] = pkgName
+					value = value[:i]
+				}
+				importPaths[param[1:]] = GoImportPath(value)
+				mfiles[param[1:]] = true
+				continue
+			}
+			if opts.ParamFunc != nil {
+				if err := opts.ParamFunc(param, value); err != nil {
+					return nil, err
+				}
+			}
+		}
+	}
+	if gen.module != "" {
+		// When the module= option is provided, we strip the module name
+		// prefix from generated files. This only makes sense if generated
+		// filenames are based on the import path, so default to paths=import
+		// and complain if source_relative was selected manually.
+		switch gen.pathType {
+		case pathTypeLegacy:
+			gen.pathType = pathTypeImport
+		case pathTypeSourceRelative:
+			return nil, fmt.Errorf("cannot use module= with paths=source_relative")
+		}
+	}
+
+	// Figure out the import path and package name for each file.
+	//
+	// The rules here are complicated and have grown organically over time.
+	// Interactions between different ways of specifying package information
+	// may be surprising.
+	//
+	// The recommended approach is to include a go_package option in every
+	// .proto source file specifying the full import path of the Go package
+	// associated with this file.
+	//
+	//     option go_package = "google.golang.org/protobuf/types/known/anypb";
+	//
+	// Build systems which want to exert full control over import paths may
+	// specify M<filename>=<import_path> flags.
+	//
+	// Other approaches are not recommend.
+	generatedFileNames := make(map[string]bool)
+	for _, name := range gen.Request.FileToGenerate {
+		generatedFileNames[name] = true
+	}
+	// We need to determine the import paths before the package names,
+	// because the Go package name for a file is sometimes derived from
+	// different file in the same package.
+	packageNameForImportPath := make(map[GoImportPath]GoPackageName)
+	for _, fdesc := range gen.Request.ProtoFile {
+		filename := fdesc.GetName()
+		packageName, importPath := goPackageOption(fdesc)
+		switch {
+		case importPaths[filename] != "":
+			// Command line: Mfoo.proto=quux/bar
+			//
+			// Explicit mapping of source file to import path.
+		case generatedFileNames[filename] && packageImportPath != "":
+			// Command line: import_path=quux/bar
+			//
+			// The import_path flag sets the import path for every file that
+			// we generate code for.
+			importPaths[filename] = packageImportPath
+		case importPath != "":
+			// Source file: option go_package = "quux/bar";
+			//
+			// The go_package option sets the import path. Most users should use this.
+			importPaths[filename] = importPath
+		default:
+			// Source filename.
+			//
+			// Last resort when nothing else is available.
+			importPaths[filename] = GoImportPath(path.Dir(filename))
+		}
+		if packageName != "" {
+			packageNameForImportPath[importPaths[filename]] = packageName
+		}
+	}
+	for _, fdesc := range gen.Request.ProtoFile {
+		filename := fdesc.GetName()
+		packageName, importPath := goPackageOption(fdesc)
+		defaultPackageName := packageNameForImportPath[importPaths[filename]]
+		switch {
+		case packageNames[filename] != "":
+			// A package name specified by the "M" command-line argument.
+		case packageName != "":
+			// TODO: For the "M" command-line argument, this means that the
+			// package name can be derived from the go_package option.
+			// Go package information should either consistently come from the
+			// command-line or the .proto source file, but not both.
+			// See how to make this consistent.
+
+			// Source file: option go_package = "quux/bar";
+			packageNames[filename] = packageName
+		case defaultPackageName != "":
+			// A go_package option in another file in the same package.
+			//
+			// This is a poor choice in general, since every source file should
+			// contain a go_package option. Supported mainly for historical
+			// compatibility.
+			packageNames[filename] = defaultPackageName
+		case generatedFileNames[filename] && packageImportPath != "":
+			// Command line: import_path=quux/bar
+			packageNames[filename] = cleanPackageName(path.Base(string(packageImportPath)))
+		case fdesc.GetPackage() != "":
+			// Source file: package quux.bar;
+			packageNames[filename] = cleanPackageName(fdesc.GetPackage())
+		default:
+			// Source filename.
+			packageNames[filename] = cleanPackageName(baseName(filename))
+		}
+
+		goPkgOpt := string(importPaths[filename])
+		if path.Base(string(goPkgOpt)) != string(packageNames[filename]) {
+			goPkgOpt += ";" + string(packageNames[filename])
+		}
+		switch {
+		case packageImportPath != "":
+			// Command line: import_path=quux/bar
+			warn("Deprecated use of the 'import_path' command-line argument. In %q, please specify:\n"+
+				"\toption go_package = %q;\n"+
+				"A future release of protoc-gen-go will no longer support the 'import_path' argument.\n"+
+				"See "+goPackageDocURL+" for more information.\n"+
+				"\n", fdesc.GetName(), goPkgOpt)
+		case mfiles[filename]:
+			// Command line: M=foo.proto=quux/bar
+		case packageName != "" && importPath == "":
+			// Source file: option go_package = "quux";
+			warn("Deprecated use of 'go_package' option without a full import path in %q, please specify:\n"+
+				"\toption go_package = %q;\n"+
+				"A future release of protoc-gen-go will require the import path be specified.\n"+
+				"See "+goPackageDocURL+" for more information.\n"+
+				"\n", fdesc.GetName(), goPkgOpt)
+		case packageName == "" && importPath == "":
+			// No Go package information provided.
+			dotIdx := strings.Index(goPkgOpt, ".")   // heuristic for top-level domain
+			slashIdx := strings.Index(goPkgOpt, "/") // heuristic for multi-segment path
+			if isFull := 0 <= dotIdx && dotIdx <= slashIdx; isFull {
+				warn("Missing 'go_package' option in %q, please specify:\n"+
+					"\toption go_package = %q;\n"+
+					"A future release of protoc-gen-go will require this be specified.\n"+
+					"See "+goPackageDocURL+" for more information.\n"+
+					"\n", fdesc.GetName(), goPkgOpt)
+			} else {
+				warn("Missing 'go_package' option in %q,\n"+
+					"please specify it with the full Go package path as\n"+
+					"a future release of protoc-gen-go will require this be specified.\n"+
+					"See "+goPackageDocURL+" for more information.\n"+
+					"\n", fdesc.GetName())
+			}
+		}
+	}
+
+	// Consistency check: Every file with the same Go import path should have
+	// the same Go package name.
+	packageFiles := make(map[GoImportPath][]string)
+	for filename, importPath := range importPaths {
+		if _, ok := packageNames[filename]; !ok {
+			// Skip files mentioned in a M<file>=<import_path> parameter
+			// but which do not appear in the CodeGeneratorRequest.
+			continue
+		}
+		packageFiles[importPath] = append(packageFiles[importPath], filename)
+	}
+	for importPath, filenames := range packageFiles {
+		for i := 1; i < len(filenames); i++ {
+			if a, b := packageNames[filenames[0]], packageNames[filenames[i]]; a != b {
+				return nil, fmt.Errorf("Go package %v has inconsistent names %v (%v) and %v (%v)",
+					importPath, a, filenames[0], b, filenames[i])
+			}
+		}
+	}
+
+	for _, fdesc := range gen.Request.ProtoFile {
+		filename := fdesc.GetName()
+		if gen.FilesByPath[filename] != nil {
+			return nil, fmt.Errorf("duplicate file name: %q", filename)
+		}
+		f, err := newFile(gen, fdesc, packageNames[filename], importPaths[filename])
+		if err != nil {
+			return nil, err
+		}
+		gen.Files = append(gen.Files, f)
+		gen.FilesByPath[filename] = f
+	}
+	for _, filename := range gen.Request.FileToGenerate {
+		f, ok := gen.FilesByPath[filename]
+		if !ok {
+			return nil, fmt.Errorf("no descriptor for generated file: %v", filename)
+		}
+		f.Generate = true
+	}
+	return gen, nil
+}
+
+// Error records an error in code generation. The generator will report the
+// error back to protoc and will not produce output.
+func (gen *Plugin) Error(err error) {
+	if gen.err == nil {
+		gen.err = err
+	}
+}
+
+// Response returns the generator output.
+func (gen *Plugin) Response() *pluginpb.CodeGeneratorResponse {
+	resp := &pluginpb.CodeGeneratorResponse{}
+	if gen.err != nil {
+		resp.Error = proto.String(gen.err.Error())
+		return resp
+	}
+	for _, g := range gen.genFiles {
+		if g.skip {
+			continue
+		}
+		content, err := g.Content()
+		if err != nil {
+			return &pluginpb.CodeGeneratorResponse{
+				Error: proto.String(err.Error()),
+			}
+		}
+		filename := g.filename
+		if gen.module != "" {
+			trim := gen.module + "/"
+			if !strings.HasPrefix(filename, trim) {
+				return &pluginpb.CodeGeneratorResponse{
+					Error: proto.String(fmt.Sprintf("%v: generated file does not match prefix %q", filename, gen.module)),
+				}
+			}
+			filename = strings.TrimPrefix(filename, trim)
+		}
+		resp.File = append(resp.File, &pluginpb.CodeGeneratorResponse_File{
+			Name:    proto.String(filename),
+			Content: proto.String(string(content)),
+		})
+		if gen.annotateCode && strings.HasSuffix(g.filename, ".go") {
+			meta, err := g.metaFile(content)
+			if err != nil {
+				return &pluginpb.CodeGeneratorResponse{
+					Error: proto.String(err.Error()),
+				}
+			}
+			resp.File = append(resp.File, &pluginpb.CodeGeneratorResponse_File{
+				Name:    proto.String(filename + ".meta"),
+				Content: proto.String(meta),
+			})
+		}
+	}
+	if gen.SupportedFeatures > 0 {
+		resp.SupportedFeatures = proto.Uint64(gen.SupportedFeatures)
+	}
+	return resp
+}
+
+// A File describes a .proto source file.
+type File struct {
+	Desc  protoreflect.FileDescriptor
+	Proto *descriptorpb.FileDescriptorProto
+
+	GoDescriptorIdent GoIdent       // name of Go variable for the file descriptor
+	GoPackageName     GoPackageName // name of this file's Go package
+	GoImportPath      GoImportPath  // import path of this file's Go package
+
+	Enums      []*Enum      // top-level enum declarations
+	Messages   []*Message   // top-level message declarations
+	Extensions []*Extension // top-level extension declarations
+	Services   []*Service   // top-level service declarations
+
+	Generate bool // true if we should generate code for this file
+
+	// GeneratedFilenamePrefix is used to construct filenames for generated
+	// files associated with this source file.
+	//
+	// For example, the source file "dir/foo.proto" might have a filename prefix
+	// of "dir/foo". Appending ".pb.go" produces an output file of "dir/foo.pb.go".
+	GeneratedFilenamePrefix string
+
+	comments map[pathKey]CommentSet
+}
+
+func newFile(gen *Plugin, p *descriptorpb.FileDescriptorProto, packageName GoPackageName, importPath GoImportPath) (*File, error) {
+	desc, err := protodesc.NewFile(p, gen.fileReg)
+	if err != nil {
+		return nil, fmt.Errorf("invalid FileDescriptorProto %q: %v", p.GetName(), err)
+	}
+	if err := gen.fileReg.RegisterFile(desc); err != nil {
+		return nil, fmt.Errorf("cannot register descriptor %q: %v", p.GetName(), err)
+	}
+	f := &File{
+		Desc:          desc,
+		Proto:         p,
+		GoPackageName: packageName,
+		GoImportPath:  importPath,
+		comments:      make(map[pathKey]CommentSet),
+	}
+
+	// Determine the prefix for generated Go files.
+	prefix := p.GetName()
+	if ext := path.Ext(prefix); ext == ".proto" || ext == ".protodevel" {
+		prefix = prefix[:len(prefix)-len(ext)]
+	}
+	switch gen.pathType {
+	case pathTypeLegacy:
+		// The default is to derive the output filename from the Go import path
+		// if the file contains a go_package option,or from the input filename instead.
+		if _, importPath := goPackageOption(p); importPath != "" {
+			prefix = path.Join(string(importPath), path.Base(prefix))
+		}
+	case pathTypeImport:
+		// If paths=import, the output filename is derived from the Go import path.
+		prefix = path.Join(string(f.GoImportPath), path.Base(prefix))
+	case pathTypeSourceRelative:
+		// If paths=source_relative, the output filename is derived from
+		// the input filename.
+	}
+	f.GoDescriptorIdent = GoIdent{
+		GoName:       "File_" + strs.GoSanitized(p.GetName()),
+		GoImportPath: f.GoImportPath,
+	}
+	f.GeneratedFilenamePrefix = prefix
+
+	for _, loc := range p.GetSourceCodeInfo().GetLocation() {
+		// Descriptors declarations are guaranteed to have unique comment sets.
+		// Other locations may not be unique, but we don't use them.
+		var leadingDetached []Comments
+		for _, s := range loc.GetLeadingDetachedComments() {
+			leadingDetached = append(leadingDetached, Comments(s))
+		}
+		f.comments[newPathKey(loc.Path)] = CommentSet{
+			LeadingDetached: leadingDetached,
+			Leading:         Comments(loc.GetLeadingComments()),
+			Trailing:        Comments(loc.GetTrailingComments()),
+		}
+	}
+	for i, eds := 0, desc.Enums(); i < eds.Len(); i++ {
+		f.Enums = append(f.Enums, newEnum(gen, f, nil, eds.Get(i)))
+	}
+	for i, mds := 0, desc.Messages(); i < mds.Len(); i++ {
+		f.Messages = append(f.Messages, newMessage(gen, f, nil, mds.Get(i)))
+	}
+	for i, xds := 0, desc.Extensions(); i < xds.Len(); i++ {
+		f.Extensions = append(f.Extensions, newField(gen, f, nil, xds.Get(i)))
+	}
+	for i, sds := 0, desc.Services(); i < sds.Len(); i++ {
+		f.Services = append(f.Services, newService(gen, f, sds.Get(i)))
+	}
+	for _, message := range f.Messages {
+		if err := message.resolveDependencies(gen); err != nil {
+			return nil, err
+		}
+	}
+	for _, extension := range f.Extensions {
+		if err := extension.resolveDependencies(gen); err != nil {
+			return nil, err
+		}
+	}
+	for _, service := range f.Services {
+		for _, method := range service.Methods {
+			if err := method.resolveDependencies(gen); err != nil {
+				return nil, err
+			}
+		}
+	}
+	return f, nil
+}
+
+func (f *File) location(idxPath ...int32) Location {
+	return Location{
+		SourceFile: f.Desc.Path(),
+		Path:       idxPath,
+	}
+}
+
+// goPackageOption interprets a file's go_package option.
+// If there is no go_package, it returns ("", "").
+// If there's a simple name, it returns (pkg, "").
+// If the option implies an import path, it returns (pkg, impPath).
+func goPackageOption(d *descriptorpb.FileDescriptorProto) (pkg GoPackageName, impPath GoImportPath) {
+	opt := d.GetOptions().GetGoPackage()
+	if opt == "" {
+		return "", ""
+	}
+	rawPkg, impPath := goPackageOptionRaw(opt)
+	pkg = cleanPackageName(rawPkg)
+	if string(pkg) != rawPkg && impPath != "" {
+		warn("Malformed 'go_package' option in %q, please specify:\n"+
+			"\toption go_package = %q;\n"+
+			"A future release of protoc-gen-go will reject this.\n"+
+			"See "+goPackageDocURL+" for more information.\n"+
+			"\n", d.GetName(), string(impPath)+";"+string(pkg))
+	}
+	return pkg, impPath
+}
+func goPackageOptionRaw(opt string) (rawPkg string, impPath GoImportPath) {
+	// A semicolon-delimited suffix delimits the import path and package name.
+	if i := strings.Index(opt, ";"); i >= 0 {
+		return opt[i+1:], GoImportPath(opt[:i])
+	}
+	// The presence of a slash implies there's an import path.
+	if i := strings.LastIndex(opt, "/"); i >= 0 {
+		return opt[i+1:], GoImportPath(opt)
+	}
+	return opt, ""
+}
+
+// An Enum describes an enum.
+type Enum struct {
+	Desc protoreflect.EnumDescriptor
+
+	GoIdent GoIdent // name of the generated Go type
+
+	Values []*EnumValue // enum value declarations
+
+	Location Location   // location of this enum
+	Comments CommentSet // comments associated with this enum
+}
+
+func newEnum(gen *Plugin, f *File, parent *Message, desc protoreflect.EnumDescriptor) *Enum {
+	var loc Location
+	if parent != nil {
+		loc = parent.Location.appendPath(fieldnum.DescriptorProto_EnumType, int32(desc.Index()))
+	} else {
+		loc = f.location(fieldnum.FileDescriptorProto_EnumType, int32(desc.Index()))
+	}
+	enum := &Enum{
+		Desc:     desc,
+		GoIdent:  newGoIdent(f, desc),
+		Location: loc,
+		Comments: f.comments[newPathKey(loc.Path)],
+	}
+	gen.enumsByName[desc.FullName()] = enum
+	for i, vds := 0, enum.Desc.Values(); i < vds.Len(); i++ {
+		enum.Values = append(enum.Values, newEnumValue(gen, f, parent, enum, vds.Get(i)))
+	}
+	return enum
+}
+
+// An EnumValue describes an enum value.
+type EnumValue struct {
+	Desc protoreflect.EnumValueDescriptor
+
+	GoIdent GoIdent // name of the generated Go declaration
+
+	Parent *Enum // enum in which this value is declared
+
+	Location Location   // location of this enum value
+	Comments CommentSet // comments associated with this enum value
+}
+
+func newEnumValue(gen *Plugin, f *File, message *Message, enum *Enum, desc protoreflect.EnumValueDescriptor) *EnumValue {
+	// A top-level enum value's name is: EnumName_ValueName
+	// An enum value contained in a message is: MessageName_ValueName
+	//
+	// For historical reasons, enum value names are not camel-cased.
+	parentIdent := enum.GoIdent
+	if message != nil {
+		parentIdent = message.GoIdent
+	}
+	name := parentIdent.GoName + "_" + string(desc.Name())
+	loc := enum.Location.appendPath(fieldnum.EnumDescriptorProto_Value, int32(desc.Index()))
+	return &EnumValue{
+		Desc:     desc,
+		GoIdent:  f.GoImportPath.Ident(name),
+		Parent:   enum,
+		Location: loc,
+		Comments: f.comments[newPathKey(loc.Path)],
+	}
+}
+
+// A Message describes a message.
+type Message struct {
+	Desc protoreflect.MessageDescriptor
+
+	GoIdent GoIdent // name of the generated Go type
+
+	Fields []*Field // message field declarations
+	Oneofs []*Oneof // message oneof declarations
+
+	Enums      []*Enum      // nested enum declarations
+	Messages   []*Message   // nested message declarations
+	Extensions []*Extension // nested extension declarations
+
+	Location Location   // location of this message
+	Comments CommentSet // comments associated with this message
+}
+
+func newMessage(gen *Plugin, f *File, parent *Message, desc protoreflect.MessageDescriptor) *Message {
+	var loc Location
+	if parent != nil {
+		loc = parent.Location.appendPath(fieldnum.DescriptorProto_NestedType, int32(desc.Index()))
+	} else {
+		loc = f.location(fieldnum.FileDescriptorProto_MessageType, int32(desc.Index()))
+	}
+	message := &Message{
+		Desc:     desc,
+		GoIdent:  newGoIdent(f, desc),
+		Location: loc,
+		Comments: f.comments[newPathKey(loc.Path)],
+	}
+	gen.messagesByName[desc.FullName()] = message
+	for i, eds := 0, desc.Enums(); i < eds.Len(); i++ {
+		message.Enums = append(message.Enums, newEnum(gen, f, message, eds.Get(i)))
+	}
+	for i, mds := 0, desc.Messages(); i < mds.Len(); i++ {
+		message.Messages = append(message.Messages, newMessage(gen, f, message, mds.Get(i)))
+	}
+	for i, fds := 0, desc.Fields(); i < fds.Len(); i++ {
+		message.Fields = append(message.Fields, newField(gen, f, message, fds.Get(i)))
+	}
+	for i, ods := 0, desc.Oneofs(); i < ods.Len(); i++ {
+		message.Oneofs = append(message.Oneofs, newOneof(gen, f, message, ods.Get(i)))
+	}
+	for i, xds := 0, desc.Extensions(); i < xds.Len(); i++ {
+		message.Extensions = append(message.Extensions, newField(gen, f, message, xds.Get(i)))
+	}
+
+	// Resolve local references between fields and oneofs.
+	for _, field := range message.Fields {
+		if od := field.Desc.ContainingOneof(); od != nil {
+			oneof := message.Oneofs[od.Index()]
+			field.Oneof = oneof
+			oneof.Fields = append(oneof.Fields, field)
+		}
+	}
+
+	// Field name conflict resolution.
+	//
+	// We assume well-known method names that may be attached to a generated
+	// message type, as well as a 'Get*' method for each field. For each
+	// field in turn, we add _s to its name until there are no conflicts.
+	//
+	// Any change to the following set of method names is a potential
+	// incompatible API change because it may change generated field names.
+	//
+	// TODO: If we ever support a 'go_name' option to set the Go name of a
+	// field, we should consider dropping this entirely. The conflict
+	// resolution algorithm is subtle and surprising (changing the order
+	// in which fields appear in the .proto source file can change the
+	// names of fields in generated code), and does not adapt well to
+	// adding new per-field methods such as setters.
+	usedNames := map[string]bool{
+		"Reset":               true,
+		"String":              true,
+		"ProtoMessage":        true,
+		"Marshal":             true,
+		"Unmarshal":           true,
+		"ExtensionRangeArray": true,
+		"ExtensionMap":        true,
+		"Descriptor":          true,
+	}
+	makeNameUnique := func(name string, hasGetter bool) string {
+		for usedNames[name] || (hasGetter && usedNames["Get"+name]) {
+			name += "_"
+		}
+		usedNames[name] = true
+		usedNames["Get"+name] = hasGetter
+		return name
+	}
+	for _, field := range message.Fields {
+		field.GoName = makeNameUnique(field.GoName, true)
+		field.GoIdent.GoName = message.GoIdent.GoName + "_" + field.GoName
+		if field.Oneof != nil && field.Oneof.Fields[0] == field {
+			// Make the name for a oneof unique as well. For historical reasons,
+			// this assumes that a getter method is not generated for oneofs.
+			// This is incorrect, but fixing it breaks existing code.
+			field.Oneof.GoName = makeNameUnique(field.Oneof.GoName, false)
+			field.Oneof.GoIdent.GoName = message.GoIdent.GoName + "_" + field.Oneof.GoName
+		}
+	}
+
+	// Oneof field name conflict resolution.
+	//
+	// This conflict resolution is incomplete as it does not consider collisions
+	// with other oneof field types, but fixing it breaks existing code.
+	for _, field := range message.Fields {
+		if field.Oneof != nil {
+		Loop:
+			for {
+				for _, nestedMessage := range message.Messages {
+					if nestedMessage.GoIdent == field.GoIdent {
+						field.GoIdent.GoName += "_"
+						continue Loop
+					}
+				}
+				for _, nestedEnum := range message.Enums {
+					if nestedEnum.GoIdent == field.GoIdent {
+						field.GoIdent.GoName += "_"
+						continue Loop
+					}
+				}
+				break Loop
+			}
+		}
+	}
+
+	return message
+}
+
+func (message *Message) resolveDependencies(gen *Plugin) error {
+	for _, field := range message.Fields {
+		if err := field.resolveDependencies(gen); err != nil {
+			return err
+		}
+	}
+	for _, message := range message.Messages {
+		if err := message.resolveDependencies(gen); err != nil {
+			return err
+		}
+	}
+	for _, extension := range message.Extensions {
+		if err := extension.resolveDependencies(gen); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// A Field describes a message field.
+type Field struct {
+	Desc protoreflect.FieldDescriptor
+
+	// GoName is the base name of this field's Go field and methods.
+	// For code generated by protoc-gen-go, this means a field named
+	// '{{GoName}}' and a getter method named 'Get{{GoName}}'.
+	GoName string // e.g., "FieldName"
+
+	// GoIdent is the base name of a top-level declaration for this field.
+	// For code generated by protoc-gen-go, this means a wrapper type named
+	// '{{GoIdent}}' for members fields of a oneof, and a variable named
+	// 'E_{{GoIdent}}' for extension fields.
+	GoIdent GoIdent // e.g., "MessageName_FieldName"
+
+	Parent   *Message // message in which this field is declared; nil if top-level extension
+	Oneof    *Oneof   // containing oneof; nil if not part of a oneof
+	Extendee *Message // extended message for extension fields; nil otherwise
+
+	Enum    *Enum    // type for enum fields; nil otherwise
+	Message *Message // type for message or group fields; nil otherwise
+
+	Location Location   // location of this field
+	Comments CommentSet // comments associated with this field
+}
+
+func newField(gen *Plugin, f *File, message *Message, desc protoreflect.FieldDescriptor) *Field {
+	var loc Location
+	switch {
+	case desc.IsExtension() && message == nil:
+		loc = f.location(fieldnum.FileDescriptorProto_Extension, int32(desc.Index()))
+	case desc.IsExtension() && message != nil:
+		loc = message.Location.appendPath(fieldnum.DescriptorProto_Extension, int32(desc.Index()))
+	default:
+		loc = message.Location.appendPath(fieldnum.DescriptorProto_Field, int32(desc.Index()))
+	}
+	camelCased := strs.GoCamelCase(string(desc.Name()))
+	var parentPrefix string
+	if message != nil {
+		parentPrefix = message.GoIdent.GoName + "_"
+	}
+	field := &Field{
+		Desc:   desc,
+		GoName: camelCased,
+		GoIdent: GoIdent{
+			GoImportPath: f.GoImportPath,
+			GoName:       parentPrefix + camelCased,
+		},
+		Parent:   message,
+		Location: loc,
+		Comments: f.comments[newPathKey(loc.Path)],
+	}
+	return field
+}
+
+func (field *Field) resolveDependencies(gen *Plugin) error {
+	desc := field.Desc
+	switch desc.Kind() {
+	case protoreflect.EnumKind:
+		name := field.Desc.Enum().FullName()
+		enum, ok := gen.enumsByName[name]
+		if !ok {
+			return fmt.Errorf("field %v: no descriptor for enum %v", desc.FullName(), name)
+		}
+		field.Enum = enum
+	case protoreflect.MessageKind, protoreflect.GroupKind:
+		name := desc.Message().FullName()
+		message, ok := gen.messagesByName[name]
+		if !ok {
+			return fmt.Errorf("field %v: no descriptor for type %v", desc.FullName(), name)
+		}
+		field.Message = message
+	}
+	if desc.IsExtension() {
+		name := desc.ContainingMessage().FullName()
+		message, ok := gen.messagesByName[name]
+		if !ok {
+			return fmt.Errorf("field %v: no descriptor for type %v", desc.FullName(), name)
+		}
+		field.Extendee = message
+	}
+	return nil
+}
+
+// A Oneof describes a message oneof.
+type Oneof struct {
+	Desc protoreflect.OneofDescriptor
+
+	// GoName is the base name of this oneof's Go field and methods.
+	// For code generated by protoc-gen-go, this means a field named
+	// '{{GoName}}' and a getter method named 'Get{{GoName}}'.
+	GoName string // e.g., "OneofName"
+
+	// GoIdent is the base name of a top-level declaration for this oneof.
+	GoIdent GoIdent // e.g., "MessageName_OneofName"
+
+	Parent *Message // message in which this oneof is declared
+
+	Fields []*Field // fields that are part of this oneof
+
+	Location Location   // location of this oneof
+	Comments CommentSet // comments associated with this oneof
+}
+
+func newOneof(gen *Plugin, f *File, message *Message, desc protoreflect.OneofDescriptor) *Oneof {
+	loc := message.Location.appendPath(fieldnum.DescriptorProto_OneofDecl, int32(desc.Index()))
+	camelCased := strs.GoCamelCase(string(desc.Name()))
+	parentPrefix := message.GoIdent.GoName + "_"
+	return &Oneof{
+		Desc:   desc,
+		Parent: message,
+		GoName: camelCased,
+		GoIdent: GoIdent{
+			GoImportPath: f.GoImportPath,
+			GoName:       parentPrefix + camelCased,
+		},
+		Location: loc,
+		Comments: f.comments[newPathKey(loc.Path)],
+	}
+}
+
+// Extension is an alias of Field for documentation.
+type Extension = Field
+
+// A Service describes a service.
+type Service struct {
+	Desc protoreflect.ServiceDescriptor
+
+	GoName string
+
+	Methods []*Method // service method declarations
+
+	Location Location   // location of this service
+	Comments CommentSet // comments associated with this service
+}
+
+func newService(gen *Plugin, f *File, desc protoreflect.ServiceDescriptor) *Service {
+	loc := f.location(fieldnum.FileDescriptorProto_Service, int32(desc.Index()))
+	service := &Service{
+		Desc:     desc,
+		GoName:   strs.GoCamelCase(string(desc.Name())),
+		Location: loc,
+		Comments: f.comments[newPathKey(loc.Path)],
+	}
+	for i, mds := 0, desc.Methods(); i < mds.Len(); i++ {
+		service.Methods = append(service.Methods, newMethod(gen, f, service, mds.Get(i)))
+	}
+	return service
+}
+
+// A Method describes a method in a service.
+type Method struct {
+	Desc protoreflect.MethodDescriptor
+
+	GoName string
+
+	Parent *Service // service in which this method is declared
+
+	Input  *Message
+	Output *Message
+
+	Location Location   // location of this method
+	Comments CommentSet // comments associated with this method
+}
+
+func newMethod(gen *Plugin, f *File, service *Service, desc protoreflect.MethodDescriptor) *Method {
+	loc := service.Location.appendPath(fieldnum.ServiceDescriptorProto_Method, int32(desc.Index()))
+	method := &Method{
+		Desc:     desc,
+		GoName:   strs.GoCamelCase(string(desc.Name())),
+		Parent:   service,
+		Location: loc,
+		Comments: f.comments[newPathKey(loc.Path)],
+	}
+	return method
+}
+
+func (method *Method) resolveDependencies(gen *Plugin) error {
+	desc := method.Desc
+
+	inName := desc.Input().FullName()
+	in, ok := gen.messagesByName[inName]
+	if !ok {
+		return fmt.Errorf("method %v: no descriptor for type %v", desc.FullName(), inName)
+	}
+	method.Input = in
+
+	outName := desc.Output().FullName()
+	out, ok := gen.messagesByName[outName]
+	if !ok {
+		return fmt.Errorf("method %v: no descriptor for type %v", desc.FullName(), outName)
+	}
+	method.Output = out
+
+	return nil
+}
+
+// A GeneratedFile is a generated file.
+type GeneratedFile struct {
+	gen              *Plugin
+	skip             bool
+	filename         string
+	goImportPath     GoImportPath
+	buf              bytes.Buffer
+	packageNames     map[GoImportPath]GoPackageName
+	usedPackageNames map[GoPackageName]bool
+	manualImports    map[GoImportPath]bool
+	annotations      map[string][]Location
+}
+
+// NewGeneratedFile creates a new generated file with the given filename
+// and import path.
+func (gen *Plugin) NewGeneratedFile(filename string, goImportPath GoImportPath) *GeneratedFile {
+	g := &GeneratedFile{
+		gen:              gen,
+		filename:         filename,
+		goImportPath:     goImportPath,
+		packageNames:     make(map[GoImportPath]GoPackageName),
+		usedPackageNames: make(map[GoPackageName]bool),
+		manualImports:    make(map[GoImportPath]bool),
+		annotations:      make(map[string][]Location),
+	}
+
+	// All predeclared identifiers in Go are already used.
+	for _, s := range types.Universe.Names() {
+		g.usedPackageNames[GoPackageName(s)] = true
+	}
+
+	gen.genFiles = append(gen.genFiles, g)
+	return g
+}
+
+// P prints a line to the generated output. It converts each parameter to a
+// string following the same rules as fmt.Print. It never inserts spaces
+// between parameters.
+func (g *GeneratedFile) P(v ...interface{}) {
+	for _, x := range v {
+		switch x := x.(type) {
+		case GoIdent:
+			fmt.Fprint(&g.buf, g.QualifiedGoIdent(x))
+		default:
+			fmt.Fprint(&g.buf, x)
+		}
+	}
+	fmt.Fprintln(&g.buf)
+}
+
+// QualifiedGoIdent returns the string to use for a Go identifier.
+//
+// If the identifier is from a different Go package than the generated file,
+// the returned name will be qualified (package.name) and an import statement
+// for the identifier's package will be included in the file.
+func (g *GeneratedFile) QualifiedGoIdent(ident GoIdent) string {
+	if ident.GoImportPath == g.goImportPath {
+		return ident.GoName
+	}
+	if packageName, ok := g.packageNames[ident.GoImportPath]; ok {
+		return string(packageName) + "." + ident.GoName
+	}
+	packageName := cleanPackageName(baseName(string(ident.GoImportPath)))
+	for i, orig := 1, packageName; g.usedPackageNames[packageName]; i++ {
+		packageName = orig + GoPackageName(strconv.Itoa(i))
+	}
+	g.packageNames[ident.GoImportPath] = packageName
+	g.usedPackageNames[packageName] = true
+	return string(packageName) + "." + ident.GoName
+}
+
+// Import ensures a package is imported by the generated file.
+//
+// Packages referenced by QualifiedGoIdent are automatically imported.
+// Explicitly importing a package with Import is generally only necessary
+// when the import will be blank (import _ "package").
+func (g *GeneratedFile) Import(importPath GoImportPath) {
+	g.manualImports[importPath] = true
+}
+
+// Write implements io.Writer.
+func (g *GeneratedFile) Write(p []byte) (n int, err error) {
+	return g.buf.Write(p)
+}
+
+// Skip removes the generated file from the plugin output.
+func (g *GeneratedFile) Skip() {
+	g.skip = true
+}
+
+// Unskip reverts a previous call to Skip, re-including the generated file in
+// the plugin output.
+func (g *GeneratedFile) Unskip() {
+	g.skip = false
+}
+
+// Annotate associates a symbol in a generated Go file with a location in a
+// source .proto file.
+//
+// The symbol may refer to a type, constant, variable, function, method, or
+// struct field.  The "T.sel" syntax is used to identify the method or field
+// 'sel' on type 'T'.
+func (g *GeneratedFile) Annotate(symbol string, loc Location) {
+	g.annotations[symbol] = append(g.annotations[symbol], loc)
+}
+
+// Content returns the contents of the generated file.
+func (g *GeneratedFile) Content() ([]byte, error) {
+	if !strings.HasSuffix(g.filename, ".go") {
+		return g.buf.Bytes(), nil
+	}
+
+	// Reformat generated code.
+	original := g.buf.Bytes()
+	fset := token.NewFileSet()
+	file, err := parser.ParseFile(fset, "", original, parser.ParseComments)
+	if err != nil {
+		// Print out the bad code with line numbers.
+		// This should never happen in practice, but it can while changing generated code
+		// so consider this a debugging aid.
+		var src bytes.Buffer
+		s := bufio.NewScanner(bytes.NewReader(original))
+		for line := 1; s.Scan(); line++ {
+			fmt.Fprintf(&src, "%5d\t%s\n", line, s.Bytes())
+		}
+		return nil, fmt.Errorf("%v: unparsable Go source: %v\n%v", g.filename, err, src.String())
+	}
+
+	// Collect a sorted list of all imports.
+	var importPaths [][2]string
+	rewriteImport := func(importPath string) string {
+		if f := g.gen.opts.ImportRewriteFunc; f != nil {
+			return string(f(GoImportPath(importPath)))
+		}
+		return importPath
+	}
+	for importPath := range g.packageNames {
+		pkgName := string(g.packageNames[GoImportPath(importPath)])
+		pkgPath := rewriteImport(string(importPath))
+		importPaths = append(importPaths, [2]string{pkgName, pkgPath})
+	}
+	for importPath := range g.manualImports {
+		if _, ok := g.packageNames[importPath]; !ok {
+			pkgPath := rewriteImport(string(importPath))
+			importPaths = append(importPaths, [2]string{"_", pkgPath})
+		}
+	}
+	sort.Slice(importPaths, func(i, j int) bool {
+		return importPaths[i][1] < importPaths[j][1]
+	})
+
+	// Modify the AST to include a new import block.
+	if len(importPaths) > 0 {
+		// Insert block after package statement or
+		// possible comment attached to the end of the package statement.
+		pos := file.Package
+		tokFile := fset.File(file.Package)
+		pkgLine := tokFile.Line(file.Package)
+		for _, c := range file.Comments {
+			if tokFile.Line(c.Pos()) > pkgLine {
+				break
+			}
+			pos = c.End()
+		}
+
+		// Construct the import block.
+		impDecl := &ast.GenDecl{
+			Tok:    token.IMPORT,
+			TokPos: pos,
+			Lparen: pos,
+			Rparen: pos,
+		}
+		for _, importPath := range importPaths {
+			impDecl.Specs = append(impDecl.Specs, &ast.ImportSpec{
+				Name: &ast.Ident{
+					Name:    importPath[0],
+					NamePos: pos,
+				},
+				Path: &ast.BasicLit{
+					Kind:     token.STRING,
+					Value:    strconv.Quote(importPath[1]),
+					ValuePos: pos,
+				},
+				EndPos: pos,
+			})
+		}
+		file.Decls = append([]ast.Decl{impDecl}, file.Decls...)
+	}
+
+	var out bytes.Buffer
+	if err = (&printer.Config{Mode: printer.TabIndent | printer.UseSpaces, Tabwidth: 8}).Fprint(&out, fset, file); err != nil {
+		return nil, fmt.Errorf("%v: can not reformat Go source: %v", g.filename, err)
+	}
+	return out.Bytes(), nil
+}
+
+// metaFile returns the contents of the file's metadata file, which is a
+// text formatted string of the google.protobuf.GeneratedCodeInfo.
+func (g *GeneratedFile) metaFile(content []byte) (string, error) {
+	fset := token.NewFileSet()
+	astFile, err := parser.ParseFile(fset, "", content, 0)
+	if err != nil {
+		return "", err
+	}
+	info := &descriptorpb.GeneratedCodeInfo{}
+
+	seenAnnotations := make(map[string]bool)
+	annotate := func(s string, ident *ast.Ident) {
+		seenAnnotations[s] = true
+		for _, loc := range g.annotations[s] {
+			info.Annotation = append(info.Annotation, &descriptorpb.GeneratedCodeInfo_Annotation{
+				SourceFile: proto.String(loc.SourceFile),
+				Path:       loc.Path,
+				Begin:      proto.Int32(int32(fset.Position(ident.Pos()).Offset)),
+				End:        proto.Int32(int32(fset.Position(ident.End()).Offset)),
+			})
+		}
+	}
+	for _, decl := range astFile.Decls {
+		switch decl := decl.(type) {
+		case *ast.GenDecl:
+			for _, spec := range decl.Specs {
+				switch spec := spec.(type) {
+				case *ast.TypeSpec:
+					annotate(spec.Name.Name, spec.Name)
+					switch st := spec.Type.(type) {
+					case *ast.StructType:
+						for _, field := range st.Fields.List {
+							for _, name := range field.Names {
+								annotate(spec.Name.Name+"."+name.Name, name)
+							}
+						}
+					case *ast.InterfaceType:
+						for _, field := range st.Methods.List {
+							for _, name := range field.Names {
+								annotate(spec.Name.Name+"."+name.Name, name)
+							}
+						}
+					}
+				case *ast.ValueSpec:
+					for _, name := range spec.Names {
+						annotate(name.Name, name)
+					}
+				}
+			}
+		case *ast.FuncDecl:
+			if decl.Recv == nil {
+				annotate(decl.Name.Name, decl.Name)
+			} else {
+				recv := decl.Recv.List[0].Type
+				if s, ok := recv.(*ast.StarExpr); ok {
+					recv = s.X
+				}
+				if id, ok := recv.(*ast.Ident); ok {
+					annotate(id.Name+"."+decl.Name.Name, decl.Name)
+				}
+			}
+		}
+	}
+	for a := range g.annotations {
+		if !seenAnnotations[a] {
+			return "", fmt.Errorf("%v: no symbol matching annotation %q", g.filename, a)
+		}
+	}
+
+	b, err := prototext.Marshal(info)
+	if err != nil {
+		return "", err
+	}
+	return string(b), nil
+}
+
+// A GoIdent is a Go identifier, consisting of a name and import path.
+// The name is a single identifier and may not be a dot-qualified selector.
+type GoIdent struct {
+	GoName       string
+	GoImportPath GoImportPath
+}
+
+func (id GoIdent) String() string { return fmt.Sprintf("%q.%v", id.GoImportPath, id.GoName) }
+
+// newGoIdent returns the Go identifier for a descriptor.
+func newGoIdent(f *File, d protoreflect.Descriptor) GoIdent {
+	name := strings.TrimPrefix(string(d.FullName()), string(f.Desc.Package())+".")
+	return GoIdent{
+		GoName:       strs.GoCamelCase(name),
+		GoImportPath: f.GoImportPath,
+	}
+}
+
+// A GoImportPath is the import path of a Go package.
+// For example: "google.golang.org/protobuf/compiler/protogen"
+type GoImportPath string
+
+func (p GoImportPath) String() string { return strconv.Quote(string(p)) }
+
+// Ident returns a GoIdent with s as the GoName and p as the GoImportPath.
+func (p GoImportPath) Ident(s string) GoIdent {
+	return GoIdent{GoName: s, GoImportPath: p}
+}
+
+// A GoPackageName is the name of a Go package. e.g., "protobuf".
+type GoPackageName string
+
+// cleanPackageName converts a string to a valid Go package name.
+func cleanPackageName(name string) GoPackageName {
+	return GoPackageName(strs.GoSanitized(name))
+}
+
+// baseName returns the last path element of the name, with the last dotted suffix removed.
+func baseName(name string) string {
+	// First, find the last element
+	if i := strings.LastIndex(name, "/"); i >= 0 {
+		name = name[i+1:]
+	}
+	// Now drop the suffix
+	if i := strings.LastIndex(name, "."); i >= 0 {
+		name = name[:i]
+	}
+	return name
+}
+
+type pathType int
+
+const (
+	pathTypeLegacy pathType = iota
+	pathTypeImport
+	pathTypeSourceRelative
+)
+
+// A Location is a location in a .proto source file.
+//
+// See the google.protobuf.SourceCodeInfo documentation in descriptor.proto
+// for details.
+type Location struct {
+	SourceFile string
+	Path       protoreflect.SourcePath
+}
+
+// appendPath add elements to a Location's path, returning a new Location.
+func (loc Location) appendPath(a ...int32) Location {
+	var n protoreflect.SourcePath
+	n = append(n, loc.Path...)
+	n = append(n, a...)
+	return Location{
+		SourceFile: loc.SourceFile,
+		Path:       n,
+	}
+}
+
+// A pathKey is a representation of a location path suitable for use as a map key.
+type pathKey struct {
+	s string
+}
+
+// newPathKey converts a location path to a pathKey.
+func newPathKey(idxPath []int32) pathKey {
+	buf := make([]byte, 4*len(idxPath))
+	for i, x := range idxPath {
+		binary.LittleEndian.PutUint32(buf[i*4:], uint32(x))
+	}
+	return pathKey{string(buf)}
+}
+
+// CommentSet is a set of leading and trailing comments associated
+// with a .proto descriptor declaration.
+type CommentSet struct {
+	LeadingDetached []Comments
+	Leading         Comments
+	Trailing        Comments
+}
+
+// Comments is a comments string as provided by protoc.
+type Comments string
+
+// String formats the comments by inserting // to the start of each line,
+// ensuring that there is a trailing newline.
+// An empty comment is formatted as an empty string.
+func (c Comments) String() string {
+	if c == "" {
+		return ""
+	}
+	var b []byte
+	for _, line := range strings.Split(strings.TrimSuffix(string(c), "\n"), "\n") {
+		b = append(b, "//"...)
+		b = append(b, line...)
+		b = append(b, "\n"...)
+	}
+	return string(b)
+}
+
+var warnings = true
+
+func warn(format string, a ...interface{}) {
+	if warnings {
+		log.Printf("WARNING: "+format, a...)
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/compiler/protogen/protogen_test.go b/vendor/google.golang.org/protobuf/compiler/protogen/protogen_test.go
new file mode 100644
index 000000000..36dbf72c8
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/compiler/protogen/protogen_test.go
@@ -0,0 +1,371 @@
+// 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 protogen
+
+import (
+	"flag"
+	"fmt"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protoreflect"
+
+	"google.golang.org/protobuf/types/descriptorpb"
+	"google.golang.org/protobuf/types/pluginpb"
+)
+
+func init() {
+	warnings = false // avoid spam in tests
+}
+
+func TestPluginParameters(t *testing.T) {
+	var flags flag.FlagSet
+	value := flags.Int("integer", 0, "")
+	const params = "integer=2"
+	_, err := Options{
+		ParamFunc: flags.Set,
+	}.New(&pluginpb.CodeGeneratorRequest{
+		Parameter: proto.String(params),
+	})
+	if err != nil {
+		t.Errorf("New(generator parameters %q): %v", params, err)
+	}
+	if *value != 2 {
+		t.Errorf("New(generator parameters %q): integer=%v, want 2", params, *value)
+	}
+}
+
+func TestPluginParameterErrors(t *testing.T) {
+	for _, parameter := range []string{
+		"unknown=1",
+		"boolean=error",
+	} {
+		var flags flag.FlagSet
+		flags.Bool("boolean", false, "")
+		_, err := Options{
+			ParamFunc: flags.Set,
+		}.New(&pluginpb.CodeGeneratorRequest{
+			Parameter: proto.String(parameter),
+		})
+		if err == nil {
+			t.Errorf("New(generator parameters %q): want error, got nil", parameter)
+		}
+	}
+}
+
+func TestNoGoPackage(t *testing.T) {
+	gen, err := Options{}.New(&pluginpb.CodeGeneratorRequest{
+		ProtoFile: []*descriptorpb.FileDescriptorProto{
+			{
+				Name:    proto.String("testdata/go_package/no_go_package.proto"),
+				Syntax:  proto.String(protoreflect.Proto3.String()),
+				Package: proto.String("goproto.testdata"),
+			},
+			{
+				Name:       proto.String("testdata/go_package/no_go_package_import.proto"),
+				Syntax:     proto.String(protoreflect.Proto3.String()),
+				Package:    proto.String("goproto.testdata"),
+				Dependency: []string{"testdata/go_package/no_go_package.proto"},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	for i, f := range gen.Files {
+		if got, want := string(f.GoPackageName), "goproto_testdata"; got != want {
+			t.Errorf("gen.Files[%d].GoPackageName = %v, want %v", i, got, want)
+		}
+		if got, want := string(f.GoImportPath), "testdata/go_package"; got != want {
+			t.Errorf("gen.Files[%d].GoImportPath = %v, want %v", i, got, want)
+		}
+	}
+}
+
+func TestPackageNamesAndPaths(t *testing.T) {
+	const (
+		filename         = "dir/filename.proto"
+		protoPackageName = "proto.package"
+	)
+	for _, test := range []struct {
+		desc            string
+		parameter       string
+		goPackageOption string
+		generate        bool
+		wantPackageName GoPackageName
+		wantImportPath  GoImportPath
+		wantFilename    string
+	}{
+		{
+			desc:            "no parameters, no go_package option",
+			generate:        true,
+			wantPackageName: "proto_package",
+			wantImportPath:  "dir",
+			wantFilename:    "dir/filename",
+		},
+		{
+			desc:            "go_package option sets import path",
+			goPackageOption: "golang.org/x/foo",
+			generate:        true,
+			wantPackageName: "foo",
+			wantImportPath:  "golang.org/x/foo",
+			wantFilename:    "golang.org/x/foo/filename",
+		},
+		{
+			desc:            "go_package option sets import path and package",
+			goPackageOption: "golang.org/x/foo;bar",
+			generate:        true,
+			wantPackageName: "bar",
+			wantImportPath:  "golang.org/x/foo",
+			wantFilename:    "golang.org/x/foo/filename",
+		},
+		{
+			desc:            "go_package option sets package",
+			goPackageOption: "foo",
+			generate:        true,
+			wantPackageName: "foo",
+			wantImportPath:  "dir",
+			wantFilename:    "dir/filename",
+		},
+		{
+			desc:            "command line sets import path for a file",
+			parameter:       "Mdir/filename.proto=golang.org/x/bar",
+			goPackageOption: "golang.org/x/foo",
+			generate:        true,
+			wantPackageName: "foo",
+			wantImportPath:  "golang.org/x/bar",
+			wantFilename:    "golang.org/x/foo/filename",
+		},
+		{
+			desc:            "command line sets import path for a file with package name specified",
+			parameter:       "Mdir/filename.proto=golang.org/x/bar;bar",
+			goPackageOption: "golang.org/x/foo",
+			generate:        true,
+			wantPackageName: "bar",
+			wantImportPath:  "golang.org/x/bar",
+			wantFilename:    "golang.org/x/foo/filename",
+		},
+		{
+			desc:            "import_path parameter sets import path of generated files",
+			parameter:       "import_path=golang.org/x/bar",
+			goPackageOption: "golang.org/x/foo",
+			generate:        true,
+			wantPackageName: "foo",
+			wantImportPath:  "golang.org/x/bar",
+			wantFilename:    "golang.org/x/foo/filename",
+		},
+		{
+			desc:            "import_path parameter does not set import path of dependencies",
+			parameter:       "import_path=golang.org/x/bar",
+			goPackageOption: "golang.org/x/foo",
+			generate:        false,
+			wantPackageName: "foo",
+			wantImportPath:  "golang.org/x/foo",
+			wantFilename:    "golang.org/x/foo/filename",
+		},
+		{
+			desc:            "module option set",
+			parameter:       "module=golang.org/x",
+			goPackageOption: "golang.org/x/foo",
+			generate:        false,
+			wantPackageName: "foo",
+			wantImportPath:  "golang.org/x/foo",
+			wantFilename:    "foo/filename",
+		},
+		{
+			desc:            "paths=import uses import path from command line",
+			parameter:       "paths=import,Mdir/filename.proto=golang.org/x/bar",
+			goPackageOption: "golang.org/x/foo",
+			generate:        true,
+			wantPackageName: "foo",
+			wantImportPath:  "golang.org/x/bar",
+			wantFilename:    "golang.org/x/bar/filename",
+		},
+		{
+			desc:            "module option implies paths=import",
+			parameter:       "module=golang.org/x,Mdir/filename.proto=golang.org/x/foo",
+			generate:        false,
+			wantPackageName: "proto_package",
+			wantImportPath:  "golang.org/x/foo",
+			wantFilename:    "foo/filename",
+		},
+	} {
+		context := fmt.Sprintf(`
+TEST: %v
+  --go_out=%v:.
+  file %q: generate=%v
+  option go_package = %q;
+
+  `,
+			test.desc, test.parameter, filename, test.generate, test.goPackageOption)
+
+		req := &pluginpb.CodeGeneratorRequest{
+			Parameter: proto.String(test.parameter),
+			ProtoFile: []*descriptorpb.FileDescriptorProto{
+				{
+					Name:    proto.String(filename),
+					Package: proto.String(protoPackageName),
+					Options: &descriptorpb.FileOptions{
+						GoPackage: proto.String(test.goPackageOption),
+					},
+				},
+			},
+		}
+		if test.generate {
+			req.FileToGenerate = []string{filename}
+		}
+		gen, err := Options{}.New(req)
+		if err != nil {
+			t.Errorf("%vNew(req) = %v", context, err)
+			continue
+		}
+		gotFile, ok := gen.FilesByPath[filename]
+		if !ok {
+			t.Errorf("%v%v: missing file info", context, filename)
+			continue
+		}
+		if got, want := gotFile.GoPackageName, test.wantPackageName; got != want {
+			t.Errorf("%vGoPackageName=%v, want %v", context, got, want)
+		}
+		if got, want := gotFile.GoImportPath, test.wantImportPath; got != want {
+			t.Errorf("%vGoImportPath=%v, want %v", context, got, want)
+		}
+		gen.NewGeneratedFile(gotFile.GeneratedFilenamePrefix, "")
+		resp := gen.Response()
+		if got, want := resp.File[0].GetName(), test.wantFilename; got != want {
+			t.Errorf("%vgenerated filename=%v, want %v", context, got, want)
+		}
+	}
+}
+
+func TestPackageNameInference(t *testing.T) {
+	gen, err := Options{}.New(&pluginpb.CodeGeneratorRequest{
+		ProtoFile: []*descriptorpb.FileDescriptorProto{
+			{
+				Name:    proto.String("dir/file1.proto"),
+				Package: proto.String("proto.package"),
+			},
+			{
+				Name:    proto.String("dir/file2.proto"),
+				Package: proto.String("proto.package"),
+				Options: &descriptorpb.FileOptions{
+					GoPackage: proto.String("foo"),
+				},
+			},
+		},
+		FileToGenerate: []string{"dir/file1.proto", "dir/file2.proto"},
+	})
+	if err != nil {
+		t.Fatalf("New(req) = %v", err)
+	}
+	if f1, ok := gen.FilesByPath["dir/file1.proto"]; !ok {
+		t.Errorf("missing file info for dir/file1.proto")
+	} else if f1.GoPackageName != "foo" {
+		t.Errorf("dir/file1.proto: GoPackageName=%v, want foo; package name should be derived from dir/file2.proto", f1.GoPackageName)
+	}
+}
+
+func TestInconsistentPackageNames(t *testing.T) {
+	_, err := Options{}.New(&pluginpb.CodeGeneratorRequest{
+		ProtoFile: []*descriptorpb.FileDescriptorProto{
+			{
+				Name:    proto.String("dir/file1.proto"),
+				Package: proto.String("proto.package"),
+				Options: &descriptorpb.FileOptions{
+					GoPackage: proto.String("golang.org/x/foo"),
+				},
+			},
+			{
+				Name:    proto.String("dir/file2.proto"),
+				Package: proto.String("proto.package"),
+				Options: &descriptorpb.FileOptions{
+					GoPackage: proto.String("golang.org/x/foo;bar"),
+				},
+			},
+		},
+		FileToGenerate: []string{"dir/file1.proto", "dir/file2.proto"},
+	})
+	if err == nil {
+		t.Fatalf("inconsistent package names for the same import path: New(req) = nil, want error")
+	}
+}
+
+func TestImports(t *testing.T) {
+	gen, err := Options{}.New(&pluginpb.CodeGeneratorRequest{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	g := gen.NewGeneratedFile("foo.go", "golang.org/x/foo")
+	g.P("package foo")
+	g.P()
+	for _, importPath := range []GoImportPath{
+		"golang.org/x/foo",
+		// Multiple references to the same package.
+		"golang.org/x/bar",
+		"golang.org/x/bar",
+		// Reference to a different package with the same basename.
+		"golang.org/y/bar",
+		"golang.org/x/baz",
+		// Reference to a package conflicting with a predeclared identifier.
+		"golang.org/z/string",
+	} {
+		g.P("var _ = ", GoIdent{GoName: "X", GoImportPath: importPath}, " // ", importPath)
+	}
+	want := `package foo
+
+import (
+	bar "golang.org/x/bar"
+	baz "golang.org/x/baz"
+	bar1 "golang.org/y/bar"
+	string1 "golang.org/z/string"
+)
+
+var _ = X         // "golang.org/x/foo"
+var _ = bar.X     // "golang.org/x/bar"
+var _ = bar.X     // "golang.org/x/bar"
+var _ = bar1.X    // "golang.org/y/bar"
+var _ = baz.X     // "golang.org/x/baz"
+var _ = string1.X // "golang.org/z/string"
+`
+	got, err := g.Content()
+	if err != nil {
+		t.Fatalf("g.Content() = %v", err)
+	}
+	if diff := cmp.Diff(string(want), string(got)); diff != "" {
+		t.Fatalf("content mismatch (-want +got):\n%s", diff)
+	}
+}
+
+func TestImportRewrites(t *testing.T) {
+	gen, err := Options{
+		ImportRewriteFunc: func(i GoImportPath) GoImportPath {
+			return "prefix/" + i
+		},
+	}.New(&pluginpb.CodeGeneratorRequest{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	g := gen.NewGeneratedFile("foo.go", "golang.org/x/foo")
+	g.P("package foo")
+	g.P("var _ = ", GoIdent{GoName: "X", GoImportPath: "golang.org/x/bar"})
+	want := `package foo
+
+import (
+	bar "prefix/golang.org/x/bar"
+)
+
+var _ = bar.X
+`
+	got, err := g.Content()
+	if err != nil {
+		t.Fatalf("g.Content() = %v", err)
+	}
+	if diff := cmp.Diff(string(want), string(got)); diff != "" {
+		t.Fatalf("content mismatch (-want +got):\n%s", diff)
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/encoding/bench_test.go b/vendor/google.golang.org/protobuf/encoding/bench_test.go
new file mode 100644
index 000000000..490656b30
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/encoding/bench_test.go
@@ -0,0 +1,175 @@
+// 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 encoding_test
+
+import (
+	"fmt"
+	"testing"
+
+	"google.golang.org/protobuf/encoding/protojson"
+	"google.golang.org/protobuf/encoding/prototext"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+
+	tpb "google.golang.org/protobuf/internal/testprotos/test"
+)
+
+// The results of these microbenchmarks are unlikely to correspond well
+// to real world peformance. They are mainly useful as a quick check to
+// detect unexpected regressions and for profiling specific cases.
+
+const maxRecurseLevel = 3
+
+func makeProto() *tpb.TestAllTypes {
+	m := &tpb.TestAllTypes{}
+	fillMessage(m.ProtoReflect(), 0)
+	return m
+}
+
+func fillMessage(m pref.Message, level int) {
+	if level > maxRecurseLevel {
+		return
+	}
+
+	fieldDescs := m.Descriptor().Fields()
+	for i := 0; i < fieldDescs.Len(); i++ {
+		fd := fieldDescs.Get(i)
+		switch {
+		case fd.IsList():
+			setList(m.Mutable(fd).List(), fd, level)
+		case fd.IsMap():
+			setMap(m.Mutable(fd).Map(), fd, level)
+		default:
+			setScalarField(m, fd, level)
+		}
+	}
+}
+
+func setScalarField(m pref.Message, fd pref.FieldDescriptor, level int) {
+	switch fd.Kind() {
+	case pref.MessageKind, pref.GroupKind:
+		val := m.NewField(fd)
+		fillMessage(val.Message(), level+1)
+		m.Set(fd, val)
+	default:
+		m.Set(fd, scalarField(fd.Kind()))
+	}
+}
+
+func scalarField(kind pref.Kind) pref.Value {
+	switch kind {
+	case pref.BoolKind:
+		return pref.ValueOfBool(true)
+
+	case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
+		return pref.ValueOfInt32(1 << 30)
+
+	case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
+		return pref.ValueOfInt64(1 << 30)
+
+	case pref.Uint32Kind, pref.Fixed32Kind:
+		return pref.ValueOfUint32(1 << 30)
+
+	case pref.Uint64Kind, pref.Fixed64Kind:
+		return pref.ValueOfUint64(1 << 30)
+
+	case pref.FloatKind:
+		return pref.ValueOfFloat32(3.14159265)
+
+	case pref.DoubleKind:
+		return pref.ValueOfFloat64(3.14159265)
+
+	case pref.BytesKind:
+		return pref.ValueOfBytes([]byte("hello world"))
+
+	case pref.StringKind:
+		return pref.ValueOfString("hello world")
+
+	case pref.EnumKind:
+		return pref.ValueOfEnum(42)
+	}
+
+	panic(fmt.Sprintf("FieldDescriptor.Kind %v is not valid", kind))
+}
+
+func setList(list pref.List, fd pref.FieldDescriptor, level int) {
+	switch fd.Kind() {
+	case pref.MessageKind, pref.GroupKind:
+		for i := 0; i < 10; i++ {
+			val := list.NewElement()
+			fillMessage(val.Message(), level+1)
+			list.Append(val)
+		}
+	default:
+		for i := 0; i < 100; i++ {
+			list.Append(scalarField(fd.Kind()))
+		}
+	}
+}
+
+func setMap(mmap pref.Map, fd pref.FieldDescriptor, level int) {
+	fields := fd.Message().Fields()
+	keyDesc := fields.ByNumber(1)
+	valDesc := fields.ByNumber(2)
+
+	pkey := scalarField(keyDesc.Kind())
+	switch kind := valDesc.Kind(); kind {
+	case pref.MessageKind, pref.GroupKind:
+		val := mmap.NewValue()
+		fillMessage(val.Message(), level+1)
+		mmap.Set(pkey.MapKey(), val)
+	default:
+		mmap.Set(pkey.MapKey(), scalarField(kind))
+	}
+}
+
+func BenchmarkTextEncode(b *testing.B) {
+	m := makeProto()
+	for i := 0; i < b.N; i++ {
+		_, err := prototext.MarshalOptions{Indent: "  "}.Marshal(m)
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func BenchmarkTextDecode(b *testing.B) {
+	m := makeProto()
+	in, err := prototext.MarshalOptions{Indent: "  "}.Marshal(m)
+	if err != nil {
+		b.Fatal(err)
+	}
+
+	for i := 0; i < b.N; i++ {
+		m := &tpb.TestAllTypes{}
+		if err := prototext.Unmarshal(in, m); err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func BenchmarkJSONEncode(b *testing.B) {
+	m := makeProto()
+	for i := 0; i < b.N; i++ {
+		_, err := protojson.MarshalOptions{Indent: "  "}.Marshal(m)
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func BenchmarkJSONDecode(b *testing.B) {
+	m := makeProto()
+	out, err := protojson.MarshalOptions{Indent: "  "}.Marshal(m)
+	if err != nil {
+		b.Fatal(err)
+	}
+
+	for i := 0; i < b.N; i++ {
+		m := &tpb.TestAllTypes{}
+		if err := protojson.Unmarshal(out, m); err != nil {
+			b.Fatal(err)
+		}
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/encoding/protojson/bench_test.go b/vendor/google.golang.org/protobuf/encoding/protojson/bench_test.go
new file mode 100644
index 000000000..8d5a0bb68
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/encoding/protojson/bench_test.go
@@ -0,0 +1,24 @@
+// Copyright 2019 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 protojson_test
+
+import (
+	"testing"
+
+	"google.golang.org/protobuf/encoding/protojson"
+
+	"google.golang.org/protobuf/types/known/durationpb"
+)
+
+func BenchmarkUnmarshal_Duration(b *testing.B) {
+	input := []byte(`"-123456789.123456789s"`)
+
+	for i := 0; i < b.N; i++ {
+		err := protojson.Unmarshal(input, &durationpb.Duration{})
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/encoding/protojson/decode.go b/vendor/google.golang.org/protobuf/encoding/protojson/decode.go
new file mode 100644
index 000000000..71c755c15
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/encoding/protojson/decode.go
@@ -0,0 +1,683 @@
+// Copyright 2019 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 protojson
+
+import (
+	"encoding/base64"
+	"fmt"
+	"math"
+	"strconv"
+	"strings"
+
+	"google.golang.org/protobuf/internal/encoding/json"
+	"google.golang.org/protobuf/internal/encoding/messageset"
+	"google.golang.org/protobuf/internal/errors"
+	"google.golang.org/protobuf/internal/flags"
+	"google.golang.org/protobuf/internal/pragma"
+	"google.golang.org/protobuf/internal/set"
+	"google.golang.org/protobuf/proto"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/reflect/protoregistry"
+)
+
+// Unmarshal reads the given []byte into the given proto.Message.
+func Unmarshal(b []byte, m proto.Message) error {
+	return UnmarshalOptions{}.Unmarshal(b, m)
+}
+
+// UnmarshalOptions is a configurable JSON format parser.
+type UnmarshalOptions struct {
+	pragma.NoUnkeyedLiterals
+
+	// If AllowPartial is set, input for messages that will result in missing
+	// required fields will not return an error.
+	AllowPartial bool
+
+	// If DiscardUnknown is set, unknown fields are ignored.
+	DiscardUnknown bool
+
+	// Resolver is used for looking up types when unmarshaling
+	// google.protobuf.Any messages or extension fields.
+	// If nil, this defaults to using protoregistry.GlobalTypes.
+	Resolver interface {
+		protoregistry.MessageTypeResolver
+		protoregistry.ExtensionTypeResolver
+	}
+}
+
+// Unmarshal reads the given []byte and populates the given proto.Message using
+// options in UnmarshalOptions object. It will clear the message first before
+// setting the fields. If it returns an error, the given message may be
+// partially set.
+func (o UnmarshalOptions) Unmarshal(b []byte, m proto.Message) error {
+	proto.Reset(m)
+
+	if o.Resolver == nil {
+		o.Resolver = protoregistry.GlobalTypes
+	}
+
+	dec := decoder{json.NewDecoder(b), o}
+	if err := dec.unmarshalMessage(m.ProtoReflect(), false); err != nil {
+		return err
+	}
+
+	// Check for EOF.
+	tok, err := dec.Read()
+	if err != nil {
+		return err
+	}
+	if tok.Kind() != json.EOF {
+		return dec.unexpectedTokenError(tok)
+	}
+
+	if o.AllowPartial {
+		return nil
+	}
+	return proto.CheckInitialized(m)
+}
+
+type decoder struct {
+	*json.Decoder
+	opts UnmarshalOptions
+}
+
+// newError returns an error object with position info.
+func (d decoder) newError(pos int, f string, x ...interface{}) error {
+	line, column := d.Position(pos)
+	head := fmt.Sprintf("(line %d:%d): ", line, column)
+	return errors.New(head+f, x...)
+}
+
+// unexpectedTokenError returns a syntax error for the given unexpected token.
+func (d decoder) unexpectedTokenError(tok json.Token) error {
+	return d.syntaxError(tok.Pos(), "unexpected token %s", tok.RawString())
+}
+
+// syntaxError returns a syntax error for given position.
+func (d decoder) syntaxError(pos int, f string, x ...interface{}) error {
+	line, column := d.Position(pos)
+	head := fmt.Sprintf("syntax error (line %d:%d): ", line, column)
+	return errors.New(head+f, x...)
+}
+
+// unmarshalMessage unmarshals a message into the given protoreflect.Message.
+func (d decoder) unmarshalMessage(m pref.Message, skipTypeURL bool) error {
+	if isCustomType(m.Descriptor().FullName()) {
+		return d.unmarshalCustomType(m)
+	}
+
+	tok, err := d.Read()
+	if err != nil {
+		return err
+	}
+	if tok.Kind() != json.ObjectOpen {
+		return d.unexpectedTokenError(tok)
+	}
+
+	if err := d.unmarshalFields(m, skipTypeURL); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// unmarshalFields unmarshals the fields into the given protoreflect.Message.
+func (d decoder) unmarshalFields(m pref.Message, skipTypeURL bool) error {
+	messageDesc := m.Descriptor()
+	if !flags.ProtoLegacy && messageset.IsMessageSet(messageDesc) {
+		return errors.New("no support for proto1 MessageSets")
+	}
+
+	var seenNums set.Ints
+	var seenOneofs set.Ints
+	fieldDescs := messageDesc.Fields()
+	for {
+		// Read field name.
+		tok, err := d.Read()
+		if err != nil {
+			return err
+		}
+		switch tok.Kind() {
+		default:
+			return d.unexpectedTokenError(tok)
+		case json.ObjectClose:
+			return nil
+		case json.Name:
+			// Continue below.
+		}
+
+		name := tok.Name()
+		// Unmarshaling a non-custom embedded message in Any will contain the
+		// JSON field "@type" which should be skipped because it is not a field
+		// of the embedded message, but simply an artifact of the Any format.
+		if skipTypeURL && name == "@type" {
+			d.Read()
+			continue
+		}
+
+		// Get the FieldDescriptor.
+		var fd pref.FieldDescriptor
+		if strings.HasPrefix(name, "[") && strings.HasSuffix(name, "]") {
+			// Only extension names are in [name] format.
+			extName := pref.FullName(name[1 : len(name)-1])
+			extType, err := d.findExtension(extName)
+			if err != nil && err != protoregistry.NotFound {
+				return d.newError(tok.Pos(), "unable to resolve %s: %v", tok.RawString(), err)
+			}
+			if extType != nil {
+				fd = extType.TypeDescriptor()
+				if !messageDesc.ExtensionRanges().Has(fd.Number()) || fd.ContainingMessage().FullName() != messageDesc.FullName() {
+					return d.newError(tok.Pos(), "message %v cannot be extended by %v", messageDesc.FullName(), fd.FullName())
+				}
+			}
+		} else {
+			// The name can either be the JSON name or the proto field name.
+			fd = fieldDescs.ByJSONName(name)
+			if fd == nil {
+				fd = fieldDescs.ByName(pref.Name(name))
+				if fd == nil {
+					// The proto name of a group field is in all lowercase,
+					// while the textual field name is the group message name.
+					gd := fieldDescs.ByName(pref.Name(strings.ToLower(name)))
+					if gd != nil && gd.Kind() == pref.GroupKind && gd.Message().Name() == pref.Name(name) {
+						fd = gd
+					}
+				} else if fd.Kind() == pref.GroupKind && fd.Message().Name() != pref.Name(name) {
+					fd = nil // reset since field name is actually the message name
+				}
+			}
+		}
+		if flags.ProtoLegacy {
+			if fd != nil && fd.IsWeak() && fd.Message().IsPlaceholder() {
+				fd = nil // reset since the weak reference is not linked in
+			}
+		}
+
+		if fd == nil {
+			// Field is unknown.
+			if d.opts.DiscardUnknown {
+				if err := d.skipJSONValue(); err != nil {
+					return err
+				}
+				continue
+			}
+			return d.newError(tok.Pos(), "unknown field %v", tok.RawString())
+		}
+
+		// Do not allow duplicate fields.
+		num := uint64(fd.Number())
+		if seenNums.Has(num) {
+			return d.newError(tok.Pos(), "duplicate field %v", tok.RawString())
+		}
+		seenNums.Set(num)
+
+		// No need to set values for JSON null unless the field type is
+		// google.protobuf.Value or google.protobuf.NullValue.
+		if tok, _ := d.Peek(); tok.Kind() == json.Null && !isKnownValue(fd) && !isNullValue(fd) {
+			d.Read()
+			continue
+		}
+
+		switch {
+		case fd.IsList():
+			list := m.Mutable(fd).List()
+			if err := d.unmarshalList(list, fd); err != nil {
+				return err
+			}
+		case fd.IsMap():
+			mmap := m.Mutable(fd).Map()
+			if err := d.unmarshalMap(mmap, fd); err != nil {
+				return err
+			}
+		default:
+			// If field is a oneof, check if it has already been set.
+			if od := fd.ContainingOneof(); od != nil {
+				idx := uint64(od.Index())
+				if seenOneofs.Has(idx) {
+					return d.newError(tok.Pos(), "error parsing %s, oneof %v is already set", tok.RawString(), od.FullName())
+				}
+				seenOneofs.Set(idx)
+			}
+
+			// Required or optional fields.
+			if err := d.unmarshalSingular(m, fd); err != nil {
+				return err
+			}
+		}
+	}
+}
+
+// findExtension returns protoreflect.ExtensionType from the resolver if found.
+func (d decoder) findExtension(xtName pref.FullName) (pref.ExtensionType, error) {
+	xt, err := d.opts.Resolver.FindExtensionByName(xtName)
+	if err == nil {
+		return xt, nil
+	}
+	return messageset.FindMessageSetExtension(d.opts.Resolver, xtName)
+}
+
+func isKnownValue(fd pref.FieldDescriptor) bool {
+	md := fd.Message()
+	return md != nil && md.FullName() == "google.protobuf.Value"
+}
+
+func isNullValue(fd pref.FieldDescriptor) bool {
+	ed := fd.Enum()
+	return ed != nil && ed.FullName() == "google.protobuf.NullValue"
+}
+
+// unmarshalSingular unmarshals to the non-repeated field specified
+// by the given FieldDescriptor.
+func (d decoder) unmarshalSingular(m pref.Message, fd pref.FieldDescriptor) error {
+	var val pref.Value
+	var err error
+	switch fd.Kind() {
+	case pref.MessageKind, pref.GroupKind:
+		val = m.NewField(fd)
+		err = d.unmarshalMessage(val.Message(), false)
+	default:
+		val, err = d.unmarshalScalar(fd)
+	}
+
+	if err != nil {
+		return err
+	}
+	m.Set(fd, val)
+	return nil
+}
+
+// unmarshalScalar unmarshals to a scalar/enum protoreflect.Value specified by
+// the given FieldDescriptor.
+func (d decoder) unmarshalScalar(fd pref.FieldDescriptor) (pref.Value, error) {
+	const b32 int = 32
+	const b64 int = 64
+
+	tok, err := d.Read()
+	if err != nil {
+		return pref.Value{}, err
+	}
+
+	kind := fd.Kind()
+	switch kind {
+	case pref.BoolKind:
+		if tok.Kind() == json.Bool {
+			return pref.ValueOfBool(tok.Bool()), nil
+		}
+
+	case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
+		if v, ok := unmarshalInt(tok, b32); ok {
+			return v, nil
+		}
+
+	case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
+		if v, ok := unmarshalInt(tok, b64); ok {
+			return v, nil
+		}
+
+	case pref.Uint32Kind, pref.Fixed32Kind:
+		if v, ok := unmarshalUint(tok, b32); ok {
+			return v, nil
+		}
+
+	case pref.Uint64Kind, pref.Fixed64Kind:
+		if v, ok := unmarshalUint(tok, b64); ok {
+			return v, nil
+		}
+
+	case pref.FloatKind:
+		if v, ok := unmarshalFloat(tok, b32); ok {
+			return v, nil
+		}
+
+	case pref.DoubleKind:
+		if v, ok := unmarshalFloat(tok, b64); ok {
+			return v, nil
+		}
+
+	case pref.StringKind:
+		if tok.Kind() == json.String {
+			return pref.ValueOfString(tok.ParsedString()), nil
+		}
+
+	case pref.BytesKind:
+		if v, ok := unmarshalBytes(tok); ok {
+			return v, nil
+		}
+
+	case pref.EnumKind:
+		if v, ok := unmarshalEnum(tok, fd); ok {
+			return v, nil
+		}
+
+	default:
+		panic(fmt.Sprintf("unmarshalScalar: invalid scalar kind %v", kind))
+	}
+
+	return pref.Value{}, d.newError(tok.Pos(), "invalid value for %v type: %v", kind, tok.RawString())
+}
+
+func unmarshalInt(tok json.Token, bitSize int) (pref.Value, bool) {
+	switch tok.Kind() {
+	case json.Number:
+		return getInt(tok, bitSize)
+
+	case json.String:
+		// Decode number from string.
+		s := strings.TrimSpace(tok.ParsedString())
+		if len(s) != len(tok.ParsedString()) {
+			return pref.Value{}, false
+		}
+		dec := json.NewDecoder([]byte(s))
+		tok, err := dec.Read()
+		if err != nil {
+			return pref.Value{}, false
+		}
+		return getInt(tok, bitSize)
+	}
+	return pref.Value{}, false
+}
+
+func getInt(tok json.Token, bitSize int) (pref.Value, bool) {
+	n, ok := tok.Int(bitSize)
+	if !ok {
+		return pref.Value{}, false
+	}
+	if bitSize == 32 {
+		return pref.ValueOfInt32(int32(n)), true
+	}
+	return pref.ValueOfInt64(n), true
+}
+
+func unmarshalUint(tok json.Token, bitSize int) (pref.Value, bool) {
+	switch tok.Kind() {
+	case json.Number:
+		return getUint(tok, bitSize)
+
+	case json.String:
+		// Decode number from string.
+		s := strings.TrimSpace(tok.ParsedString())
+		if len(s) != len(tok.ParsedString()) {
+			return pref.Value{}, false
+		}
+		dec := json.NewDecoder([]byte(s))
+		tok, err := dec.Read()
+		if err != nil {
+			return pref.Value{}, false
+		}
+		return getUint(tok, bitSize)
+	}
+	return pref.Value{}, false
+}
+
+func getUint(tok json.Token, bitSize int) (pref.Value, bool) {
+	n, ok := tok.Uint(bitSize)
+	if !ok {
+		return pref.Value{}, false
+	}
+	if bitSize == 32 {
+		return pref.ValueOfUint32(uint32(n)), true
+	}
+	return pref.ValueOfUint64(n), true
+}
+
+func unmarshalFloat(tok json.Token, bitSize int) (pref.Value, bool) {
+	switch tok.Kind() {
+	case json.Number:
+		return getFloat(tok, bitSize)
+
+	case json.String:
+		s := tok.ParsedString()
+		switch s {
+		case "NaN":
+			if bitSize == 32 {
+				return pref.ValueOfFloat32(float32(math.NaN())), true
+			}
+			return pref.ValueOfFloat64(math.NaN()), true
+		case "Infinity":
+			if bitSize == 32 {
+				return pref.ValueOfFloat32(float32(math.Inf(+1))), true
+			}
+			return pref.ValueOfFloat64(math.Inf(+1)), true
+		case "-Infinity":
+			if bitSize == 32 {
+				return pref.ValueOfFloat32(float32(math.Inf(-1))), true
+			}
+			return pref.ValueOfFloat64(math.Inf(-1)), true
+		}
+
+		// Decode number from string.
+		if len(s) != len(strings.TrimSpace(s)) {
+			return pref.Value{}, false
+		}
+		dec := json.NewDecoder([]byte(s))
+		tok, err := dec.Read()
+		if err != nil {
+			return pref.Value{}, false
+		}
+		return getFloat(tok, bitSize)
+	}
+	return pref.Value{}, false
+}
+
+func getFloat(tok json.Token, bitSize int) (pref.Value, bool) {
+	n, ok := tok.Float(bitSize)
+	if !ok {
+		return pref.Value{}, false
+	}
+	if bitSize == 32 {
+		return pref.ValueOfFloat32(float32(n)), true
+	}
+	return pref.ValueOfFloat64(n), true
+}
+
+func unmarshalBytes(tok json.Token) (pref.Value, bool) {
+	if tok.Kind() != json.String {
+		return pref.Value{}, false
+	}
+
+	s := tok.ParsedString()
+	enc := base64.StdEncoding
+	if strings.ContainsAny(s, "-_") {
+		enc = base64.URLEncoding
+	}
+	if len(s)%4 != 0 {
+		enc = enc.WithPadding(base64.NoPadding)
+	}
+	b, err := enc.DecodeString(s)
+	if err != nil {
+		return pref.Value{}, false
+	}
+	return pref.ValueOfBytes(b), true
+}
+
+func unmarshalEnum(tok json.Token, fd pref.FieldDescriptor) (pref.Value, bool) {
+	switch tok.Kind() {
+	case json.String:
+		// Lookup EnumNumber based on name.
+		s := tok.ParsedString()
+		if enumVal := fd.Enum().Values().ByName(pref.Name(s)); enumVal != nil {
+			return pref.ValueOfEnum(enumVal.Number()), true
+		}
+
+	case json.Number:
+		if n, ok := tok.Int(32); ok {
+			return pref.ValueOfEnum(pref.EnumNumber(n)), true
+		}
+
+	case json.Null:
+		// This is only valid for google.protobuf.NullValue.
+		if isNullValue(fd) {
+			return pref.ValueOfEnum(0), true
+		}
+	}
+
+	return pref.Value{}, false
+}
+
+func (d decoder) unmarshalList(list pref.List, fd pref.FieldDescriptor) error {
+	tok, err := d.Read()
+	if err != nil {
+		return err
+	}
+	if tok.Kind() != json.ArrayOpen {
+		return d.unexpectedTokenError(tok)
+	}
+
+	switch fd.Kind() {
+	case pref.MessageKind, pref.GroupKind:
+		for {
+			tok, err := d.Peek()
+			if err != nil {
+				return err
+			}
+
+			if tok.Kind() == json.ArrayClose {
+				d.Read()
+				return nil
+			}
+
+			val := list.NewElement()
+			if err := d.unmarshalMessage(val.Message(), false); err != nil {
+				return err
+			}
+			list.Append(val)
+		}
+	default:
+		for {
+			tok, err := d.Peek()
+			if err != nil {
+				return err
+			}
+
+			if tok.Kind() == json.ArrayClose {
+				d.Read()
+				return nil
+			}
+
+			val, err := d.unmarshalScalar(fd)
+			if err != nil {
+				return err
+			}
+			list.Append(val)
+		}
+	}
+
+	return nil
+}
+
+func (d decoder) unmarshalMap(mmap pref.Map, fd pref.FieldDescriptor) error {
+	tok, err := d.Read()
+	if err != nil {
+		return err
+	}
+	if tok.Kind() != json.ObjectOpen {
+		return d.unexpectedTokenError(tok)
+	}
+
+	// Determine ahead whether map entry is a scalar type or a message type in
+	// order to call the appropriate unmarshalMapValue func inside the for loop
+	// below.
+	var unmarshalMapValue func() (pref.Value, error)
+	switch fd.MapValue().Kind() {
+	case pref.MessageKind, pref.GroupKind:
+		unmarshalMapValue = func() (pref.Value, error) {
+			val := mmap.NewValue()
+			if err := d.unmarshalMessage(val.Message(), false); err != nil {
+				return pref.Value{}, err
+			}
+			return val, nil
+		}
+	default:
+		unmarshalMapValue = func() (pref.Value, error) {
+			return d.unmarshalScalar(fd.MapValue())
+		}
+	}
+
+Loop:
+	for {
+		// Read field name.
+		tok, err := d.Read()
+		if err != nil {
+			return err
+		}
+		switch tok.Kind() {
+		default:
+			return d.unexpectedTokenError(tok)
+		case json.ObjectClose:
+			break Loop
+		case json.Name:
+			// Continue.
+		}
+
+		// Unmarshal field name.
+		pkey, err := d.unmarshalMapKey(tok, fd.MapKey())
+		if err != nil {
+			return err
+		}
+
+		// Check for duplicate field name.
+		if mmap.Has(pkey) {
+			return d.newError(tok.Pos(), "duplicate map key %v", tok.RawString())
+		}
+
+		// Read and unmarshal field value.
+		pval, err := unmarshalMapValue()
+		if err != nil {
+			return err
+		}
+
+		mmap.Set(pkey, pval)
+	}
+
+	return nil
+}
+
+// unmarshalMapKey converts given token of Name kind into a protoreflect.MapKey.
+// A map key type is any integral or string type.
+func (d decoder) unmarshalMapKey(tok json.Token, fd pref.FieldDescriptor) (pref.MapKey, error) {
+	const b32 = 32
+	const b64 = 64
+	const base10 = 10
+
+	name := tok.Name()
+	kind := fd.Kind()
+	switch kind {
+	case pref.StringKind:
+		return pref.ValueOfString(name).MapKey(), nil
+
+	case pref.BoolKind:
+		switch name {
+		case "true":
+			return pref.ValueOfBool(true).MapKey(), nil
+		case "false":
+			return pref.ValueOfBool(false).MapKey(), nil
+		}
+
+	case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
+		if n, err := strconv.ParseInt(name, base10, b32); err == nil {
+			return pref.ValueOfInt32(int32(n)).MapKey(), nil
+		}
+
+	case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
+		if n, err := strconv.ParseInt(name, base10, b64); err == nil {
+			return pref.ValueOfInt64(int64(n)).MapKey(), nil
+		}
+
+	case pref.Uint32Kind, pref.Fixed32Kind:
+		if n, err := strconv.ParseUint(name, base10, b32); err == nil {
+			return pref.ValueOfUint32(uint32(n)).MapKey(), nil
+		}
+
+	case pref.Uint64Kind, pref.Fixed64Kind:
+		if n, err := strconv.ParseUint(name, base10, b64); err == nil {
+			return pref.ValueOfUint64(uint64(n)).MapKey(), nil
+		}
+
+	default:
+		panic(fmt.Sprintf("invalid kind for map key: %v", kind))
+	}
+
+	return pref.MapKey{}, d.newError(tok.Pos(), "invalid value for %v key: %s", kind, tok.RawString())
+}
diff --git a/vendor/google.golang.org/protobuf/encoding/protojson/decode_test.go b/vendor/google.golang.org/protobuf/encoding/protojson/decode_test.go
new file mode 100644
index 000000000..396bbe0eb
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/encoding/protojson/decode_test.go
@@ -0,0 +1,2460 @@
+// Copyright 2019 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 protojson_test
+
+import (
+	"math"
+	"strings"
+	"testing"
+
+	"google.golang.org/protobuf/encoding/protojson"
+	"google.golang.org/protobuf/internal/errors"
+	"google.golang.org/protobuf/internal/flags"
+	"google.golang.org/protobuf/proto"
+	preg "google.golang.org/protobuf/reflect/protoregistry"
+
+	fieldmaskpb "google.golang.org/protobuf/internal/testprotos/fieldmaskpb"
+	testpb "google.golang.org/protobuf/internal/testprotos/test"
+	weakpb "google.golang.org/protobuf/internal/testprotos/test/weak1"
+	pb2 "google.golang.org/protobuf/internal/testprotos/textpb2"
+	pb3 "google.golang.org/protobuf/internal/testprotos/textpb3"
+	"google.golang.org/protobuf/types/known/anypb"
+	"google.golang.org/protobuf/types/known/durationpb"
+	"google.golang.org/protobuf/types/known/emptypb"
+	"google.golang.org/protobuf/types/known/structpb"
+	"google.golang.org/protobuf/types/known/timestamppb"
+	"google.golang.org/protobuf/types/known/wrapperspb"
+)
+
+func TestUnmarshal(t *testing.T) {
+	tests := []struct {
+		desc         string
+		umo          protojson.UnmarshalOptions
+		inputMessage proto.Message
+		inputText    string
+		wantMessage  proto.Message
+		wantErr      string // Expected error substring.
+		skip         bool
+	}{{
+		desc:         "proto2 empty message",
+		inputMessage: &pb2.Scalars{},
+		inputText:    "{}",
+		wantMessage:  &pb2.Scalars{},
+	}, {
+		desc:         "unexpected value instead of EOF",
+		inputMessage: &pb2.Scalars{},
+		inputText:    "{} {}",
+		wantErr:      `(line 1:4): unexpected token {`,
+	}, {
+		desc:         "proto2 optional scalars set to zero values",
+		inputMessage: &pb2.Scalars{},
+		inputText: `{
+  "optBool": false,
+  "optInt32": 0,
+  "optInt64": 0,
+  "optUint32": 0,
+  "optUint64": 0,
+  "optSint32": 0,
+  "optSint64": 0,
+  "optFixed32": 0,
+  "optFixed64": 0,
+  "optSfixed32": 0,
+  "optSfixed64": 0,
+  "optFloat": 0,
+  "optDouble": 0,
+  "optBytes": "",
+  "optString": ""
+}`,
+		wantMessage: &pb2.Scalars{
+			OptBool:     proto.Bool(false),
+			OptInt32:    proto.Int32(0),
+			OptInt64:    proto.Int64(0),
+			OptUint32:   proto.Uint32(0),
+			OptUint64:   proto.Uint64(0),
+			OptSint32:   proto.Int32(0),
+			OptSint64:   proto.Int64(0),
+			OptFixed32:  proto.Uint32(0),
+			OptFixed64:  proto.Uint64(0),
+			OptSfixed32: proto.Int32(0),
+			OptSfixed64: proto.Int64(0),
+			OptFloat:    proto.Float32(0),
+			OptDouble:   proto.Float64(0),
+			OptBytes:    []byte{},
+			OptString:   proto.String(""),
+		},
+	}, {
+		desc:         "proto3 scalars set to zero values",
+		inputMessage: &pb3.Scalars{},
+		inputText: `{
+  "sBool": false,
+  "sInt32": 0,
+  "sInt64": 0,
+  "sUint32": 0,
+  "sUint64": 0,
+  "sSint32": 0,
+  "sSint64": 0,
+  "sFixed32": 0,
+  "sFixed64": 0,
+  "sSfixed32": 0,
+  "sSfixed64": 0,
+  "sFloat": 0,
+  "sDouble": 0,
+  "sBytes": "",
+  "sString": ""
+}`,
+		wantMessage: &pb3.Scalars{},
+	}, {
+		desc:         "proto3 optional set to zero values",
+		inputMessage: &pb3.Proto3Optional{},
+		inputText: `{
+  "optBool": false,
+  "optInt32": 0,
+  "optInt64": 0,
+  "optUint32": 0,
+  "optUint64": 0,
+  "optFloat": 0,
+  "optDouble": 0,
+  "optString": "",
+  "optBytes": "",
+  "optEnum": "ZERO",
+  "optMessage": {}
+}`,
+		wantMessage: &pb3.Proto3Optional{
+			OptBool:    proto.Bool(false),
+			OptInt32:   proto.Int32(0),
+			OptInt64:   proto.Int64(0),
+			OptUint32:  proto.Uint32(0),
+			OptUint64:  proto.Uint64(0),
+			OptFloat:   proto.Float32(0),
+			OptDouble:  proto.Float64(0),
+			OptString:  proto.String(""),
+			OptBytes:   []byte{},
+			OptEnum:    pb3.Enum_ZERO.Enum(),
+			OptMessage: &pb3.Nested{},
+		},
+	}, {
+		desc:         "proto2 optional scalars set to null",
+		inputMessage: &pb2.Scalars{},
+		inputText: `{
+  "optBool": null,
+  "optInt32": null,
+  "optInt64": null,
+  "optUint32": null,
+  "optUint64": null,
+  "optSint32": null,
+  "optSint64": null,
+  "optFixed32": null,
+  "optFixed64": null,
+  "optSfixed32": null,
+  "optSfixed64": null,
+  "optFloat": null,
+  "optDouble": null,
+  "optBytes": null,
+  "optString": null
+}`,
+		wantMessage: &pb2.Scalars{},
+	}, {
+		desc:         "proto3 scalars set to null",
+		inputMessage: &pb3.Scalars{},
+		inputText: `{
+  "sBool": null,
+  "sInt32": null,
+  "sInt64": null,
+  "sUint32": null,
+  "sUint64": null,
+  "sSint32": null,
+  "sSint64": null,
+  "sFixed32": null,
+  "sFixed64": null,
+  "sSfixed32": null,
+  "sSfixed64": null,
+  "sFloat": null,
+  "sDouble": null,
+  "sBytes": null,
+  "sString": null
+}`,
+		wantMessage: &pb3.Scalars{},
+	}, {
+		desc:         "boolean",
+		inputMessage: &pb3.Scalars{},
+		inputText:    `{"sBool": true}`,
+		wantMessage: &pb3.Scalars{
+			SBool: true,
+		},
+	}, {
+		desc:         "not boolean",
+		inputMessage: &pb3.Scalars{},
+		inputText:    `{"sBool": "true"}`,
+		wantErr:      `invalid value for bool type: "true"`,
+	}, {
+		desc:         "float and double",
+		inputMessage: &pb3.Scalars{},
+		inputText: `{
+  "sFloat": 1.234,
+  "sDouble": 5.678
+}`,
+		wantMessage: &pb3.Scalars{
+			SFloat:  1.234,
+			SDouble: 5.678,
+		},
+	}, {
+		desc:         "float and double in string",
+		inputMessage: &pb3.Scalars{},
+		inputText: `{
+  "sFloat": "1.234",
+  "sDouble": "5.678"
+}`,
+		wantMessage: &pb3.Scalars{
+			SFloat:  1.234,
+			SDouble: 5.678,
+		},
+	}, {
+		desc:         "float and double in E notation",
+		inputMessage: &pb3.Scalars{},
+		inputText: `{
+  "sFloat": 12.34E-1,
+  "sDouble": 5.678e4
+}`,
+		wantMessage: &pb3.Scalars{
+			SFloat:  1.234,
+			SDouble: 56780,
+		},
+	}, {
+		desc:         "float and double in string E notation",
+		inputMessage: &pb3.Scalars{},
+		inputText: `{
+  "sFloat": "12.34E-1",
+  "sDouble": "5.678e4"
+}`,
+		wantMessage: &pb3.Scalars{
+			SFloat:  1.234,
+			SDouble: 56780,
+		},
+	}, {
+		desc:         "float exceeds limit",
+		inputMessage: &pb3.Scalars{},
+		inputText:    `{"sFloat": 3.4e39}`,
+		wantErr:      `invalid value for float type: 3.4e39`,
+	}, {
+		desc:         "float in string exceeds limit",
+		inputMessage: &pb3.Scalars{},
+		inputText:    `{"sFloat": "-3.4e39"}`,
+		wantErr:      `invalid value for float type: "-3.4e39"`,
+	}, {
+		desc:         "double exceeds limit",
+		inputMessage: &pb3.Scalars{},
+		inputText:    `{"sDouble": -1.79e+309}`,
+		wantErr:      `invalid value for double type: -1.79e+309`,
+	}, {
+		desc:         "double in string exceeds limit",
+		inputMessage: &pb3.Scalars{},
+		inputText:    `{"sDouble": "1.79e+309"}`,
+		wantErr:      `invalid value for double type: "1.79e+309"`,
+	}, {
+		desc:         "infinites",
+		inputMessage: &pb3.Scalars{},
+		inputText:    `{"sFloat": "Infinity", "sDouble": "-Infinity"}`,
+		wantMessage: &pb3.Scalars{
+			SFloat:  float32(math.Inf(+1)),
+			SDouble: math.Inf(-1),
+		},
+	}, {
+		desc:         "float string with leading space",
+		inputMessage: &pb3.Scalars{},
+		inputText:    `{"sFloat": " 1.234"}`,
+		wantErr:      `invalid value for float type: " 1.234"`,
+	}, {
+		desc:         "double string with trailing space",
+		inputMessage: &pb3.Scalars{},
+		inputText:    `{"sDouble": "5.678 "}`,
+		wantErr:      `invalid value for double type: "5.678 "`,
+	}, {
+		desc:         "not float",
+		inputMessage: &pb3.Scalars{},
+		inputText:    `{"sFloat": true}`,
+		wantErr:      `invalid value for float type: true`,
+	}, {
+		desc:         "not double",
+		inputMessage: &pb3.Scalars{},
+		inputText:    `{"sDouble": "not a number"}`,
+		wantErr:      `invalid value for double type: "not a number"`,
+	}, {
+		desc:         "integers",
+		inputMessage: &pb3.Scalars{},
+		inputText: `{
+  "sInt32": 1234,
+  "sInt64": -1234,
+  "sUint32": 1e2,
+  "sUint64": 100E-2,
+  "sSint32": 1.0,
+  "sSint64": -1.0,
+  "sFixed32": 1.234e+5,
+  "sFixed64": 1200E-2,
+  "sSfixed32": -1.234e05,
+  "sSfixed64": -1200e-02
+}`,
+		wantMessage: &pb3.Scalars{
+			SInt32:    1234,
+			SInt64:    -1234,
+			SUint32:   100,
+			SUint64:   1,
+			SSint32:   1,
+			SSint64:   -1,
+			SFixed32:  123400,
+			SFixed64:  12,
+			SSfixed32: -123400,
+			SSfixed64: -12,
+		},
+	}, {
+		desc:         "integers in string",
+		inputMessage: &pb3.Scalars{},
+		inputText: `{
+  "sInt32": "1234",
+  "sInt64": "-1234",
+  "sUint32": "1e2",
+  "sUint64": "100E-2",
+  "sSint32": "1.0",
+  "sSint64": "-1.0",
+  "sFixed32": "1.234e+5",
+  "sFixed64": "1200E-2",
+  "sSfixed32": "-1.234e05",
+  "sSfixed64": "-1200e-02"
+}`,
+		wantMessage: &pb3.Scalars{
+			SInt32:    1234,
+			SInt64:    -1234,
+			SUint32:   100,
+			SUint64:   1,
+			SSint32:   1,
+			SSint64:   -1,
+			SFixed32:  123400,
+			SFixed64:  12,
+			SSfixed32: -123400,
+			SSfixed64: -12,
+		},
+	}, {
+		desc:         "integers in escaped string",
+		inputMessage: &pb3.Scalars{},
+		inputText:    `{"sInt32": "\u0031\u0032"}`,
+		wantMessage: &pb3.Scalars{
+			SInt32: 12,
+		},
+	}, {
+		desc:         "integer string with leading space",
+		inputMessage: &pb3.Scalars{},
+		inputText:    `{"sInt32": " 1234"}`,
+		wantErr:      `invalid value for int32 type: " 1234"`,
+	}, {
+		desc:         "integer string with trailing space",
+		inputMessage: &pb3.Scalars{},
+		inputText:    `{"sUint32": "1e2 "}`,
+		wantErr:      `invalid value for uint32 type: "1e2 "`,
+	}, {
+		desc:         "number is not an integer",
+		inputMessage: &pb3.Scalars{},
+		inputText:    `{"sInt32": 1.001}`,
+		wantErr:      `invalid value for int32 type: 1.001`,
+	}, {
+		desc:         "32-bit int exceeds limit",
+		inputMessage: &pb3.Scalars{},
+		inputText:    `{"sInt32": 2e10}`,
+		wantErr:      `invalid value for int32 type: 2e10`,
+	}, {
+		desc:         "64-bit int exceeds limit",
+		inputMessage: &pb3.Scalars{},
+		inputText:    `{"sSfixed64": -9e19}`,
+		wantErr:      `invalid value for sfixed64 type: -9e19`,
+	}, {
+		desc:         "not integer",
+		inputMessage: &pb3.Scalars{},
+		inputText:    `{"sInt32": "not a number"}`,
+		wantErr:      `invalid value for int32 type: "not a number"`,
+	}, {
+		desc:         "not unsigned integer",
+		inputMessage: &pb3.Scalars{},
+		inputText:    `{"sUint32": "not a number"}`,
+		wantErr:      `invalid value for uint32 type: "not a number"`,
+	}, {
+		desc:         "number is not an unsigned integer",
+		inputMessage: &pb3.Scalars{},
+		inputText:    `{"sUint32": -1}`,
+		wantErr:      `invalid value for uint32 type: -1`,
+	}, {
+		desc:         "string",
+		inputMessage: &pb2.Scalars{},
+		inputText:    `{"optString": "谷歌"}`,
+		wantMessage: &pb2.Scalars{
+			OptString: proto.String("谷歌"),
+		},
+	}, {
+		desc:         "string with invalid UTF-8",
+		inputMessage: &pb3.Scalars{},
+		inputText:    "{\"sString\": \"\xff\"}",
+		wantErr:      `(line 1:13): invalid UTF-8 in string`,
+	}, {
+		desc:         "not string",
+		inputMessage: &pb2.Scalars{},
+		inputText:    `{"optString": 42}`,
+		wantErr:      `invalid value for string type: 42`,
+	}, {
+		desc:         "bytes",
+		inputMessage: &pb3.Scalars{},
+		inputText:    `{"sBytes": "aGVsbG8gd29ybGQ"}`,
+		wantMessage: &pb3.Scalars{
+			SBytes: []byte("hello world"),
+		},
+	}, {
+		desc:         "bytes padded",
+		inputMessage: &pb3.Scalars{},
+		inputText:    `{"sBytes": "aGVsbG8gd29ybGQ="}`,
+		wantMessage: &pb3.Scalars{
+			SBytes: []byte("hello world"),
+		},
+	}, {
+		desc:         "not bytes",
+		inputMessage: &pb3.Scalars{},
+		inputText:    `{"sBytes": true}`,
+		wantErr:      `invalid value for bytes type: true`,
+	}, {
+		desc:         "proto2 enum",
+		inputMessage: &pb2.Enums{},
+		inputText: `{
+  "optEnum": "ONE",
+  "optNestedEnum": "UNO"
+}`,
+		wantMessage: &pb2.Enums{
+			OptEnum:       pb2.Enum_ONE.Enum(),
+			OptNestedEnum: pb2.Enums_UNO.Enum(),
+		},
+	}, {
+		desc:         "proto3 enum",
+		inputMessage: &pb3.Enums{},
+		inputText: `{
+  "sEnum": "ONE",
+  "sNestedEnum": "DIEZ"
+}`,
+		wantMessage: &pb3.Enums{
+			SEnum:       pb3.Enum_ONE,
+			SNestedEnum: pb3.Enums_DIEZ,
+		},
+	}, {
+		desc:         "enum numeric value",
+		inputMessage: &pb3.Enums{},
+		inputText: `{
+  "sEnum": 2,
+  "sNestedEnum": 2
+}`,
+		wantMessage: &pb3.Enums{
+			SEnum:       pb3.Enum_TWO,
+			SNestedEnum: pb3.Enums_DOS,
+		},
+	}, {
+		desc:         "enum unnamed numeric value",
+		inputMessage: &pb3.Enums{},
+		inputText: `{
+  "sEnum": 101,
+  "sNestedEnum": -101
+}`,
+		wantMessage: &pb3.Enums{
+			SEnum:       101,
+			SNestedEnum: -101,
+		},
+	}, {
+		desc:         "enum set to number string",
+		inputMessage: &pb3.Enums{},
+		inputText: `{
+  "sEnum": "1"
+}`,
+		wantErr: `invalid value for enum type: "1"`,
+	}, {
+		desc:         "enum set to invalid named",
+		inputMessage: &pb3.Enums{},
+		inputText: `{
+  "sEnum": "UNNAMED"
+}`,
+		wantErr: `invalid value for enum type: "UNNAMED"`,
+	}, {
+		desc:         "enum set to not enum",
+		inputMessage: &pb3.Enums{},
+		inputText: `{
+  "sEnum": true
+}`,
+		wantErr: `invalid value for enum type: true`,
+	}, {
+		desc:         "enum set to JSON null",
+		inputMessage: &pb3.Enums{},
+		inputText: `{
+  "sEnum": null
+}`,
+		wantMessage: &pb3.Enums{},
+	}, {
+		desc:         "proto name",
+		inputMessage: &pb3.JSONNames{},
+		inputText: `{
+  "s_string": "proto name used"
+}`,
+		wantMessage: &pb3.JSONNames{
+			SString: "proto name used",
+		},
+	}, {
+		desc:         "proto group name",
+		inputMessage: &pb2.Nests{},
+		inputText: `{
+		"OptGroup": {"optString": "hello"},
+		"RptGroup": [{"rptString": ["goodbye"]}]
+	}`,
+		wantMessage: &pb2.Nests{
+			Optgroup: &pb2.Nests_OptGroup{OptString: proto.String("hello")},
+			Rptgroup: []*pb2.Nests_RptGroup{{RptString: []string{"goodbye"}}},
+		},
+	}, {
+		desc:         "json_name",
+		inputMessage: &pb3.JSONNames{},
+		inputText: `{
+  "foo_bar": "json_name used"
+}`,
+		wantMessage: &pb3.JSONNames{
+			SString: "json_name used",
+		},
+	}, {
+		desc:         "camelCase name",
+		inputMessage: &pb3.JSONNames{},
+		inputText: `{
+  "sString": "camelcase used"
+}`,
+		wantErr: `unknown field "sString"`,
+	}, {
+		desc:         "proto name and json_name",
+		inputMessage: &pb3.JSONNames{},
+		inputText: `{
+  "foo_bar": "json_name used",
+  "s_string": "proto name used"
+}`,
+		wantErr: `(line 3:3): duplicate field "s_string"`,
+	}, {
+		desc:         "duplicate field names",
+		inputMessage: &pb3.JSONNames{},
+		inputText: `{
+  "foo_bar": "one",
+  "foo_bar": "two",
+}`,
+		wantErr: `(line 3:3): duplicate field "foo_bar"`,
+	}, {
+		desc:         "null message",
+		inputMessage: &pb2.Nests{},
+		inputText:    "null",
+		wantErr:      `unexpected token null`,
+	}, {
+		desc:         "proto2 nested message not set",
+		inputMessage: &pb2.Nests{},
+		inputText:    "{}",
+		wantMessage:  &pb2.Nests{},
+	}, {
+		desc:         "proto2 nested message set to null",
+		inputMessage: &pb2.Nests{},
+		inputText: `{
+  "optNested": null,
+  "optgroup": null
+}`,
+		wantMessage: &pb2.Nests{},
+	}, {
+		desc:         "proto2 nested message set to empty",
+		inputMessage: &pb2.Nests{},
+		inputText: `{
+  "optNested": {},
+  "optgroup": {}
+}`,
+		wantMessage: &pb2.Nests{
+			OptNested: &pb2.Nested{},
+			Optgroup:  &pb2.Nests_OptGroup{},
+		},
+	}, {
+		desc:         "proto2 nested messages",
+		inputMessage: &pb2.Nests{},
+		inputText: `{
+  "optNested": {
+    "optString": "nested message",
+    "optNested": {
+      "optString": "another nested message"
+    }
+  }
+}`,
+		wantMessage: &pb2.Nests{
+			OptNested: &pb2.Nested{
+				OptString: proto.String("nested message"),
+				OptNested: &pb2.Nested{
+					OptString: proto.String("another nested message"),
+				},
+			},
+		},
+	}, {
+		desc:         "proto2 groups",
+		inputMessage: &pb2.Nests{},
+		inputText: `{
+  "optgroup": {
+    "optString": "inside a group",
+    "optNested": {
+      "optString": "nested message inside a group"
+    },
+    "optnestedgroup": {
+      "optFixed32": 47
+    }
+  }
+}`,
+		wantMessage: &pb2.Nests{
+			Optgroup: &pb2.Nests_OptGroup{
+				OptString: proto.String("inside a group"),
+				OptNested: &pb2.Nested{
+					OptString: proto.String("nested message inside a group"),
+				},
+				Optnestedgroup: &pb2.Nests_OptGroup_OptNestedGroup{
+					OptFixed32: proto.Uint32(47),
+				},
+			},
+		},
+	}, {
+		desc:         "proto3 nested message not set",
+		inputMessage: &pb3.Nests{},
+		inputText:    "{}",
+		wantMessage:  &pb3.Nests{},
+	}, {
+		desc:         "proto3 nested message set to null",
+		inputMessage: &pb3.Nests{},
+		inputText:    `{"sNested": null}`,
+		wantMessage:  &pb3.Nests{},
+	}, {
+		desc:         "proto3 nested message set to empty",
+		inputMessage: &pb3.Nests{},
+		inputText:    `{"sNested": {}}`,
+		wantMessage: &pb3.Nests{
+			SNested: &pb3.Nested{},
+		},
+	}, {
+		desc:         "proto3 nested message",
+		inputMessage: &pb3.Nests{},
+		inputText: `{
+  "sNested": {
+    "sString": "nested message",
+    "sNested": {
+      "sString": "another nested message"
+    }
+  }
+}`,
+		wantMessage: &pb3.Nests{
+			SNested: &pb3.Nested{
+				SString: "nested message",
+				SNested: &pb3.Nested{
+					SString: "another nested message",
+				},
+			},
+		},
+	}, {
+		desc:         "message set to non-message",
+		inputMessage: &pb3.Nests{},
+		inputText:    `"not valid"`,
+		wantErr:      `unexpected token "not valid"`,
+	}, {
+		desc:         "nested message set to non-message",
+		inputMessage: &pb3.Nests{},
+		inputText:    `{"sNested": true}`,
+		wantErr:      `(line 1:13): unexpected token true`,
+	}, {
+		desc:         "oneof not set",
+		inputMessage: &pb3.Oneofs{},
+		inputText:    "{}",
+		wantMessage:  &pb3.Oneofs{},
+	}, {
+		desc:         "oneof set to empty string",
+		inputMessage: &pb3.Oneofs{},
+		inputText:    `{"oneofString": ""}`,
+		wantMessage: &pb3.Oneofs{
+			Union: &pb3.Oneofs_OneofString{},
+		},
+	}, {
+		desc:         "oneof set to string",
+		inputMessage: &pb3.Oneofs{},
+		inputText:    `{"oneofString": "hello"}`,
+		wantMessage: &pb3.Oneofs{
+			Union: &pb3.Oneofs_OneofString{
+				OneofString: "hello",
+			},
+		},
+	}, {
+		desc:         "oneof set to enum",
+		inputMessage: &pb3.Oneofs{},
+		inputText:    `{"oneofEnum": "ZERO"}`,
+		wantMessage: &pb3.Oneofs{
+			Union: &pb3.Oneofs_OneofEnum{
+				OneofEnum: pb3.Enum_ZERO,
+			},
+		},
+	}, {
+		desc:         "oneof set to empty message",
+		inputMessage: &pb3.Oneofs{},
+		inputText:    `{"oneofNested": {}}`,
+		wantMessage: &pb3.Oneofs{
+			Union: &pb3.Oneofs_OneofNested{
+				OneofNested: &pb3.Nested{},
+			},
+		},
+	}, {
+		desc:         "oneof set to message",
+		inputMessage: &pb3.Oneofs{},
+		inputText: `{
+  "oneofNested": {
+    "sString": "nested message"
+  }
+}`,
+		wantMessage: &pb3.Oneofs{
+			Union: &pb3.Oneofs_OneofNested{
+				OneofNested: &pb3.Nested{
+					SString: "nested message",
+				},
+			},
+		},
+	}, {
+		desc:         "oneof set to more than one field",
+		inputMessage: &pb3.Oneofs{},
+		inputText: `{
+  "oneofEnum": "ZERO",
+  "oneofString": "hello"
+}`,
+		wantErr: `(line 3:3): error parsing "oneofString", oneof pb3.Oneofs.union is already set`,
+	}, {
+		desc:         "oneof set to null and value",
+		inputMessage: &pb3.Oneofs{},
+		inputText: `{
+  "oneofEnum": "ZERO",
+  "oneofString": null
+}`,
+		wantMessage: &pb3.Oneofs{
+			Union: &pb3.Oneofs_OneofEnum{
+				OneofEnum: pb3.Enum_ZERO,
+			},
+		},
+	}, {
+		desc:         "repeated null fields",
+		inputMessage: &pb2.Repeats{},
+		inputText: `{
+  "rptString": null,
+  "rptInt32" : null,
+  "rptFloat" : null,
+  "rptBytes" : null
+}`,
+		wantMessage: &pb2.Repeats{},
+	}, {
+		desc:         "repeated scalars",
+		inputMessage: &pb2.Repeats{},
+		inputText: `{
+  "rptString": ["hello", "world"],
+  "rptInt32" : [-1, 0, 1],
+  "rptBool"  : [false, true]
+}`,
+		wantMessage: &pb2.Repeats{
+			RptString: []string{"hello", "world"},
+			RptInt32:  []int32{-1, 0, 1},
+			RptBool:   []bool{false, true},
+		},
+	}, {
+		desc:         "repeated enums",
+		inputMessage: &pb2.Enums{},
+		inputText: `{
+  "rptEnum"      : ["TEN", 1, 42],
+  "rptNestedEnum": ["DOS", 2, -47]
+}`,
+		wantMessage: &pb2.Enums{
+			RptEnum:       []pb2.Enum{pb2.Enum_TEN, pb2.Enum_ONE, 42},
+			RptNestedEnum: []pb2.Enums_NestedEnum{pb2.Enums_DOS, pb2.Enums_DOS, -47},
+		},
+	}, {
+		desc:         "repeated messages",
+		inputMessage: &pb2.Nests{},
+		inputText: `{
+  "rptNested": [
+    {
+      "optString": "repeat nested one"
+    },
+    {
+      "optString": "repeat nested two",
+      "optNested": {
+        "optString": "inside repeat nested two"
+      }
+    },
+    {}
+  ]
+}`,
+		wantMessage: &pb2.Nests{
+			RptNested: []*pb2.Nested{
+				{
+					OptString: proto.String("repeat nested one"),
+				},
+				{
+					OptString: proto.String("repeat nested two"),
+					OptNested: &pb2.Nested{
+						OptString: proto.String("inside repeat nested two"),
+					},
+				},
+				{},
+			},
+		},
+	}, {
+		desc:         "repeated groups",
+		inputMessage: &pb2.Nests{},
+		inputText: `{
+  "rptgroup": [
+    {
+      "rptString": ["hello", "world"]
+    },
+    {}
+  ]
+}
+`,
+		wantMessage: &pb2.Nests{
+			Rptgroup: []*pb2.Nests_RptGroup{
+				{
+					RptString: []string{"hello", "world"},
+				},
+				{},
+			},
+		},
+	}, {
+		desc:         "repeated string contains invalid UTF8",
+		inputMessage: &pb2.Repeats{},
+		inputText:    `{"rptString": ["` + "abc\xff" + `"]}`,
+		wantErr:      `invalid UTF-8`,
+	}, {
+		desc:         "repeated messages contain invalid UTF8",
+		inputMessage: &pb2.Nests{},
+		inputText:    `{"rptNested": [{"optString": "` + "abc\xff" + `"}]}`,
+		wantErr:      `invalid UTF-8`,
+	}, {
+		desc:         "repeated scalars contain invalid type",
+		inputMessage: &pb2.Repeats{},
+		inputText:    `{"rptString": ["hello", null, "world"]}`,
+		wantErr:      `invalid value for string type: null`,
+	}, {
+		desc:         "repeated messages contain invalid type",
+		inputMessage: &pb2.Nests{},
+		inputText:    `{"rptNested": [{}, null]}`,
+		wantErr:      `unexpected token null`,
+	}, {
+		desc:         "map fields 1",
+		inputMessage: &pb3.Maps{},
+		inputText: `{
+  "int32ToStr": {
+    "-101": "-101",
+	"0"   : "zero",
+	"255" : "0xff"
+  },
+  "boolToUint32": {
+    "false": 101,
+	"true" : "42"
+  }
+}`,
+		wantMessage: &pb3.Maps{
+			Int32ToStr: map[int32]string{
+				-101: "-101",
+				0xff: "0xff",
+				0:    "zero",
+			},
+			BoolToUint32: map[bool]uint32{
+				true:  42,
+				false: 101,
+			},
+		},
+	}, {
+		desc:         "map fields 2",
+		inputMessage: &pb3.Maps{},
+		inputText: `{
+  "uint64ToEnum": {
+    "1" : "ONE",
+	"2" : 2,
+	"10": 101
+  }
+}`,
+		wantMessage: &pb3.Maps{
+			Uint64ToEnum: map[uint64]pb3.Enum{
+				1:  pb3.Enum_ONE,
+				2:  pb3.Enum_TWO,
+				10: 101,
+			},
+		},
+	}, {
+		desc:         "map fields 3",
+		inputMessage: &pb3.Maps{},
+		inputText: `{
+  "strToNested": {
+    "nested_one": {
+	  "sString": "nested in a map"
+    },
+    "nested_two": {}
+  }
+}`,
+		wantMessage: &pb3.Maps{
+			StrToNested: map[string]*pb3.Nested{
+				"nested_one": {
+					SString: "nested in a map",
+				},
+				"nested_two": {},
+			},
+		},
+	}, {
+		desc:         "map fields 4",
+		inputMessage: &pb3.Maps{},
+		inputText: `{
+  "strToOneofs": {
+    "nested": {
+	  "oneofNested": {
+	    "sString": "nested oneof in map field value"
+      }
+	},
+	"string": {
+      "oneofString": "hello"
+    }
+  }
+}`,
+		wantMessage: &pb3.Maps{
+			StrToOneofs: map[string]*pb3.Oneofs{
+				"string": {
+					Union: &pb3.Oneofs_OneofString{
+						OneofString: "hello",
+					},
+				},
+				"nested": {
+					Union: &pb3.Oneofs_OneofNested{
+						OneofNested: &pb3.Nested{
+							SString: "nested oneof in map field value",
+						},
+					},
+				},
+			},
+		},
+	}, {
+		desc:         "map contains duplicate keys",
+		inputMessage: &pb3.Maps{},
+		inputText: `{
+  "int32ToStr": {
+    "0": "cero",
+    "0": "zero"
+  }
+}
+`,
+		wantErr: `(line 4:5): duplicate map key "0"`,
+	}, {
+		desc:         "map key empty string",
+		inputMessage: &pb3.Maps{},
+		inputText: `{
+  "strToNested": {
+    "": {}
+  }
+}`,
+		wantMessage: &pb3.Maps{
+			StrToNested: map[string]*pb3.Nested{
+				"": {},
+			},
+		},
+	}, {
+		desc:         "map contains invalid key 1",
+		inputMessage: &pb3.Maps{},
+		inputText: `{
+  "int32ToStr": {
+    "invalid": "cero"
+  }
+}`,
+		wantErr: `invalid value for int32 key: "invalid"`,
+	}, {
+		desc:         "map contains invalid key 2",
+		inputMessage: &pb3.Maps{},
+		inputText: `{
+  "int32ToStr": {
+    "1.02": "float"
+  }
+}`,
+		wantErr: `invalid value for int32 key: "1.02"`,
+	}, {
+		desc:         "map contains invalid key 3",
+		inputMessage: &pb3.Maps{},
+		inputText: `{
+  "int32ToStr": {
+    "2147483648": "exceeds 32-bit integer max limit"
+  }
+}`,
+		wantErr: `invalid value for int32 key: "2147483648"`,
+	}, {
+		desc:         "map contains invalid key 4",
+		inputMessage: &pb3.Maps{},
+		inputText: `{
+  "uint64ToEnum": {
+    "-1": 0
+  }
+}`,
+		wantErr: `invalid value for uint64 key: "-1"`,
+	}, {
+		desc:         "map contains invalid value",
+		inputMessage: &pb3.Maps{},
+		inputText: `{
+  "int32ToStr": {
+    "101": true
+}`,
+		wantErr: `invalid value for string type: true`,
+	}, {
+		desc:         "map contains null for scalar value",
+		inputMessage: &pb3.Maps{},
+		inputText: `{
+  "int32ToStr": {
+    "101": null
+}`,
+		wantErr: `invalid value for string type: null`,
+	}, {
+		desc:         "map contains null for message value",
+		inputMessage: &pb3.Maps{},
+		inputText: `{
+  "strToNested": {
+    "hello": null
+  }
+}`,
+		wantErr: `unexpected token null`,
+	}, {
+		desc:         "map contains contains message value with invalid UTF8",
+		inputMessage: &pb3.Maps{},
+		inputText: `{
+  "strToNested": {
+    "hello": {
+      "sString": "` + "abc\xff" + `"
+	}
+  }
+}`,
+		wantErr: `invalid UTF-8`,
+	}, {
+		desc:         "map key contains invalid UTF8",
+		inputMessage: &pb3.Maps{},
+		inputText: `{
+  "strToNested": {
+    "` + "abc\xff" + `": {}
+  }
+}`,
+		wantErr: `invalid UTF-8`,
+	}, {
+		desc:         "required fields not set",
+		inputMessage: &pb2.Requireds{},
+		inputText:    `{}`,
+		wantErr:      errors.RequiredNotSet("pb2.Requireds.req_bool").Error(),
+	}, {
+		desc:         "required field set",
+		inputMessage: &pb2.PartialRequired{},
+		inputText: `{
+  "reqString": "this is required"
+}`,
+		wantMessage: &pb2.PartialRequired{
+			ReqString: proto.String("this is required"),
+		},
+	}, {
+		desc:         "required fields partially set",
+		inputMessage: &pb2.Requireds{},
+		inputText: `{
+  "reqBool": false,
+  "reqSfixed64": 42,
+  "reqString": "hello",
+  "reqEnum": "ONE"
+}`,
+		wantMessage: &pb2.Requireds{
+			ReqBool:     proto.Bool(false),
+			ReqSfixed64: proto.Int64(42),
+			ReqString:   proto.String("hello"),
+			ReqEnum:     pb2.Enum_ONE.Enum(),
+		},
+		wantErr: errors.RequiredNotSet("pb2.Requireds.req_double").Error(),
+	}, {
+		desc:         "required fields partially set with AllowPartial",
+		umo:          protojson.UnmarshalOptions{AllowPartial: true},
+		inputMessage: &pb2.Requireds{},
+		inputText: `{
+  "reqBool": false,
+  "reqSfixed64": 42,
+  "reqString": "hello",
+  "reqEnum": "ONE"
+}`,
+		wantMessage: &pb2.Requireds{
+			ReqBool:     proto.Bool(false),
+			ReqSfixed64: proto.Int64(42),
+			ReqString:   proto.String("hello"),
+			ReqEnum:     pb2.Enum_ONE.Enum(),
+		},
+	}, {
+		desc:         "required fields all set",
+		inputMessage: &pb2.Requireds{},
+		inputText: `{
+  "reqBool": false,
+  "reqSfixed64": 42,
+  "reqDouble": 1.23,
+  "reqString": "hello",
+  "reqEnum": "ONE",
+  "reqNested": {}
+}`,
+		wantMessage: &pb2.Requireds{
+			ReqBool:     proto.Bool(false),
+			ReqSfixed64: proto.Int64(42),
+			ReqDouble:   proto.Float64(1.23),
+			ReqString:   proto.String("hello"),
+			ReqEnum:     pb2.Enum_ONE.Enum(),
+			ReqNested:   &pb2.Nested{},
+		},
+	}, {
+		desc:         "indirect required field",
+		inputMessage: &pb2.IndirectRequired{},
+		inputText: `{
+  "optNested": {}
+}`,
+		wantMessage: &pb2.IndirectRequired{
+			OptNested: &pb2.NestedWithRequired{},
+		},
+		wantErr: errors.RequiredNotSet("pb2.NestedWithRequired.req_string").Error(),
+	}, {
+		desc:         "indirect required field with AllowPartial",
+		umo:          protojson.UnmarshalOptions{AllowPartial: true},
+		inputMessage: &pb2.IndirectRequired{},
+		inputText: `{
+  "optNested": {}
+}`,
+		wantMessage: &pb2.IndirectRequired{
+			OptNested: &pb2.NestedWithRequired{},
+		},
+	}, {
+		desc:         "indirect required field in repeated",
+		inputMessage: &pb2.IndirectRequired{},
+		inputText: `{
+  "rptNested": [
+    {"reqString": "one"},
+    {}
+  ]
+}`,
+		wantMessage: &pb2.IndirectRequired{
+			RptNested: []*pb2.NestedWithRequired{
+				{
+					ReqString: proto.String("one"),
+				},
+				{},
+			},
+		},
+		wantErr: errors.RequiredNotSet("pb2.NestedWithRequired.req_string").Error(),
+	}, {
+		desc:         "indirect required field in repeated with AllowPartial",
+		umo:          protojson.UnmarshalOptions{AllowPartial: true},
+		inputMessage: &pb2.IndirectRequired{},
+		inputText: `{
+  "rptNested": [
+    {"reqString": "one"},
+    {}
+  ]
+}`,
+		wantMessage: &pb2.IndirectRequired{
+			RptNested: []*pb2.NestedWithRequired{
+				{
+					ReqString: proto.String("one"),
+				},
+				{},
+			},
+		},
+	}, {
+		desc:         "indirect required field in map",
+		inputMessage: &pb2.IndirectRequired{},
+		inputText: `{
+  "strToNested": {
+    "missing": {},
+	"contains": {
+      "reqString": "here"
+    }
+  }
+}`,
+		wantMessage: &pb2.IndirectRequired{
+			StrToNested: map[string]*pb2.NestedWithRequired{
+				"missing": &pb2.NestedWithRequired{},
+				"contains": &pb2.NestedWithRequired{
+					ReqString: proto.String("here"),
+				},
+			},
+		},
+		wantErr: errors.RequiredNotSet("pb2.NestedWithRequired.req_string").Error(),
+	}, {
+		desc:         "indirect required field in map with AllowPartial",
+		umo:          protojson.UnmarshalOptions{AllowPartial: true},
+		inputMessage: &pb2.IndirectRequired{},
+		inputText: `{
+  "strToNested": {
+    "missing": {},
+	"contains": {
+      "reqString": "here"
+    }
+  }
+}`,
+		wantMessage: &pb2.IndirectRequired{
+			StrToNested: map[string]*pb2.NestedWithRequired{
+				"missing": &pb2.NestedWithRequired{},
+				"contains": &pb2.NestedWithRequired{
+					ReqString: proto.String("here"),
+				},
+			},
+		},
+	}, {
+		desc:         "indirect required field in oneof",
+		inputMessage: &pb2.IndirectRequired{},
+		inputText: `{
+  "oneofNested": {}
+}`,
+		wantMessage: &pb2.IndirectRequired{
+			Union: &pb2.IndirectRequired_OneofNested{
+				OneofNested: &pb2.NestedWithRequired{},
+			},
+		},
+		wantErr: errors.RequiredNotSet("pb2.NestedWithRequired.req_string").Error(),
+	}, {
+		desc:         "indirect required field in oneof with AllowPartial",
+		umo:          protojson.UnmarshalOptions{AllowPartial: true},
+		inputMessage: &pb2.IndirectRequired{},
+		inputText: `{
+  "oneofNested": {}
+}`,
+		wantMessage: &pb2.IndirectRequired{
+			Union: &pb2.IndirectRequired_OneofNested{
+				OneofNested: &pb2.NestedWithRequired{},
+			},
+		},
+	}, {
+		desc:         "extensions of non-repeated fields",
+		inputMessage: &pb2.Extensions{},
+		inputText: `{
+  "optString": "non-extension field",
+  "optBool": true,
+  "optInt32": 42,
+  "[pb2.opt_ext_bool]": true,
+  "[pb2.opt_ext_nested]": {
+    "optString": "nested in an extension",
+    "optNested": {
+      "optString": "another nested in an extension"
+    }
+  },
+  "[pb2.opt_ext_string]": "extension field",
+  "[pb2.opt_ext_enum]": "TEN"
+}`,
+		wantMessage: func() proto.Message {
+			m := &pb2.Extensions{
+				OptString: proto.String("non-extension field"),
+				OptBool:   proto.Bool(true),
+				OptInt32:  proto.Int32(42),
+			}
+			proto.SetExtension(m, pb2.E_OptExtBool, true)
+			proto.SetExtension(m, pb2.E_OptExtString, "extension field")
+			proto.SetExtension(m, pb2.E_OptExtEnum, pb2.Enum_TEN)
+			proto.SetExtension(m, pb2.E_OptExtNested, &pb2.Nested{
+				OptString: proto.String("nested in an extension"),
+				OptNested: &pb2.Nested{
+					OptString: proto.String("another nested in an extension"),
+				},
+			})
+			return m
+		}(),
+	}, {
+		desc:         "extensions of repeated fields",
+		inputMessage: &pb2.Extensions{},
+		inputText: `{
+  "[pb2.rpt_ext_enum]": ["TEN", 101, "ONE"],
+  "[pb2.rpt_ext_fixed32]": [42, 47],
+  "[pb2.rpt_ext_nested]": [
+    {"optString": "one"},
+	{"optString": "two"},
+	{"optString": "three"}
+  ]
+}`,
+		wantMessage: func() proto.Message {
+			m := &pb2.Extensions{}
+			proto.SetExtension(m, pb2.E_RptExtEnum, []pb2.Enum{pb2.Enum_TEN, 101, pb2.Enum_ONE})
+			proto.SetExtension(m, pb2.E_RptExtFixed32, []uint32{42, 47})
+			proto.SetExtension(m, pb2.E_RptExtNested, []*pb2.Nested{
+				&pb2.Nested{OptString: proto.String("one")},
+				&pb2.Nested{OptString: proto.String("two")},
+				&pb2.Nested{OptString: proto.String("three")},
+			})
+			return m
+		}(),
+	}, {
+		desc:         "extensions of non-repeated fields in another message",
+		inputMessage: &pb2.Extensions{},
+		inputText: `{
+  "[pb2.ExtensionsContainer.opt_ext_bool]": true,
+  "[pb2.ExtensionsContainer.opt_ext_enum]": "TEN",
+  "[pb2.ExtensionsContainer.opt_ext_nested]": {
+    "optString": "nested in an extension",
+    "optNested": {
+      "optString": "another nested in an extension"
+    }
+  },
+  "[pb2.ExtensionsContainer.opt_ext_string]": "extension field"
+}`,
+		wantMessage: func() proto.Message {
+			m := &pb2.Extensions{}
+			proto.SetExtension(m, pb2.E_ExtensionsContainer_OptExtBool, true)
+			proto.SetExtension(m, pb2.E_ExtensionsContainer_OptExtString, "extension field")
+			proto.SetExtension(m, pb2.E_ExtensionsContainer_OptExtEnum, pb2.Enum_TEN)
+			proto.SetExtension(m, pb2.E_ExtensionsContainer_OptExtNested, &pb2.Nested{
+				OptString: proto.String("nested in an extension"),
+				OptNested: &pb2.Nested{
+					OptString: proto.String("another nested in an extension"),
+				},
+			})
+			return m
+		}(),
+	}, {
+		desc:         "extensions of repeated fields in another message",
+		inputMessage: &pb2.Extensions{},
+		inputText: `{
+  "optString": "non-extension field",
+  "optBool": true,
+  "optInt32": 42,
+  "[pb2.ExtensionsContainer.rpt_ext_nested]": [
+    {"optString": "one"},
+    {"optString": "two"},
+    {"optString": "three"}
+  ],
+  "[pb2.ExtensionsContainer.rpt_ext_enum]": ["TEN", 101, "ONE"],
+  "[pb2.ExtensionsContainer.rpt_ext_string]": ["hello", "world"]
+}`,
+		wantMessage: func() proto.Message {
+			m := &pb2.Extensions{
+				OptString: proto.String("non-extension field"),
+				OptBool:   proto.Bool(true),
+				OptInt32:  proto.Int32(42),
+			}
+			proto.SetExtension(m, pb2.E_ExtensionsContainer_RptExtEnum, []pb2.Enum{pb2.Enum_TEN, 101, pb2.Enum_ONE})
+			proto.SetExtension(m, pb2.E_ExtensionsContainer_RptExtString, []string{"hello", "world"})
+			proto.SetExtension(m, pb2.E_ExtensionsContainer_RptExtNested, []*pb2.Nested{
+				&pb2.Nested{OptString: proto.String("one")},
+				&pb2.Nested{OptString: proto.String("two")},
+				&pb2.Nested{OptString: proto.String("three")},
+			})
+			return m
+		}(),
+	}, {
+		desc:         "invalid extension field name",
+		inputMessage: &pb2.Extensions{},
+		inputText:    `{ "[pb2.invalid_message_field]": true }`,
+		wantErr:      `(line 1:3): unknown field "[pb2.invalid_message_field]"`,
+	}, {
+		desc:         "extensions of repeated field contains null",
+		inputMessage: &pb2.Extensions{},
+		inputText: `{
+  "[pb2.ExtensionsContainer.rpt_ext_nested]": [
+    {"optString": "one"},
+    null,
+    {"optString": "three"}
+  ],
+}`,
+		wantErr: `(line 4:5): unexpected token null`,
+	}, {
+		desc:         "MessageSet",
+		inputMessage: &pb2.MessageSet{},
+		inputText: `{
+  "[pb2.MessageSetExtension]": {
+    "optString": "a messageset extension"
+  },
+  "[pb2.MessageSetExtension.ext_nested]": {
+    "optString": "just a regular extension"
+  },
+  "[pb2.MessageSetExtension.not_message_set_extension]": {
+    "optString": "not a messageset extension"
+  }
+}`,
+		wantMessage: func() proto.Message {
+			m := &pb2.MessageSet{}
+			proto.SetExtension(m, pb2.E_MessageSetExtension_MessageSetExtension, &pb2.MessageSetExtension{
+				OptString: proto.String("a messageset extension"),
+			})
+			proto.SetExtension(m, pb2.E_MessageSetExtension_NotMessageSetExtension, &pb2.MessageSetExtension{
+				OptString: proto.String("not a messageset extension"),
+			})
+			proto.SetExtension(m, pb2.E_MessageSetExtension_ExtNested, &pb2.Nested{
+				OptString: proto.String("just a regular extension"),
+			})
+			return m
+		}(),
+		skip: !flags.ProtoLegacy,
+	}, {
+		desc:         "not real MessageSet 1",
+		inputMessage: &pb2.FakeMessageSet{},
+		inputText: `{
+  "[pb2.FakeMessageSetExtension.message_set_extension]": {
+    "optString": "not a messageset extension"
+  }
+}`,
+		wantMessage: func() proto.Message {
+			m := &pb2.FakeMessageSet{}
+			proto.SetExtension(m, pb2.E_FakeMessageSetExtension_MessageSetExtension, &pb2.FakeMessageSetExtension{
+				OptString: proto.String("not a messageset extension"),
+			})
+			return m
+		}(),
+		skip: !flags.ProtoLegacy,
+	}, {
+		desc:         "not real MessageSet 2",
+		inputMessage: &pb2.FakeMessageSet{},
+		inputText: `{
+  "[pb2.FakeMessageSetExtension]": {
+    "optString": "not a messageset extension"
+  }
+}`,
+		wantErr: `unknown field "[pb2.FakeMessageSetExtension]"`,
+		skip:    !flags.ProtoLegacy,
+	}, {
+		desc:         "not real MessageSet 3",
+		inputMessage: &pb2.MessageSet{},
+		inputText: `{
+  "[pb2.message_set_extension]": {
+    "optString": "another not a messageset extension"
+  }
+}`,
+		wantMessage: func() proto.Message {
+			m := &pb2.MessageSet{}
+			proto.SetExtension(m, pb2.E_MessageSetExtension, &pb2.FakeMessageSetExtension{
+				OptString: proto.String("another not a messageset extension"),
+			})
+			return m
+		}(),
+		skip: !flags.ProtoLegacy,
+	}, {
+		desc:         "Empty",
+		inputMessage: &emptypb.Empty{},
+		inputText:    `{}`,
+		wantMessage:  &emptypb.Empty{},
+	}, {
+		desc:         "Empty contains unknown",
+		inputMessage: &emptypb.Empty{},
+		inputText:    `{"unknown": null}`,
+		wantErr:      `unknown field "unknown"`,
+	}, {
+		desc:         "BoolValue false",
+		inputMessage: &wrapperspb.BoolValue{},
+		inputText:    `false`,
+		wantMessage:  &wrapperspb.BoolValue{},
+	}, {
+		desc:         "BoolValue true",
+		inputMessage: &wrapperspb.BoolValue{},
+		inputText:    `true`,
+		wantMessage:  &wrapperspb.BoolValue{Value: true},
+	}, {
+		desc:         "BoolValue invalid value",
+		inputMessage: &wrapperspb.BoolValue{},
+		inputText:    `{}`,
+		wantErr:      `invalid value for bool type: {`,
+	}, {
+		desc:         "Int32Value",
+		inputMessage: &wrapperspb.Int32Value{},
+		inputText:    `42`,
+		wantMessage:  &wrapperspb.Int32Value{Value: 42},
+	}, {
+		desc:         "Int32Value in JSON string",
+		inputMessage: &wrapperspb.Int32Value{},
+		inputText:    `"1.23e3"`,
+		wantMessage:  &wrapperspb.Int32Value{Value: 1230},
+	}, {
+		desc:         "Int64Value",
+		inputMessage: &wrapperspb.Int64Value{},
+		inputText:    `"42"`,
+		wantMessage:  &wrapperspb.Int64Value{Value: 42},
+	}, {
+		desc:         "UInt32Value",
+		inputMessage: &wrapperspb.UInt32Value{},
+		inputText:    `42`,
+		wantMessage:  &wrapperspb.UInt32Value{Value: 42},
+	}, {
+		desc:         "UInt64Value",
+		inputMessage: &wrapperspb.UInt64Value{},
+		inputText:    `"42"`,
+		wantMessage:  &wrapperspb.UInt64Value{Value: 42},
+	}, {
+		desc:         "FloatValue",
+		inputMessage: &wrapperspb.FloatValue{},
+		inputText:    `1.02`,
+		wantMessage:  &wrapperspb.FloatValue{Value: 1.02},
+	}, {
+		desc:         "FloatValue exceeds max limit",
+		inputMessage: &wrapperspb.FloatValue{},
+		inputText:    `1.23e+40`,
+		wantErr:      `invalid value for float type: 1.23e+40`,
+	}, {
+		desc:         "FloatValue Infinity",
+		inputMessage: &wrapperspb.FloatValue{},
+		inputText:    `"-Infinity"`,
+		wantMessage:  &wrapperspb.FloatValue{Value: float32(math.Inf(-1))},
+	}, {
+		desc:         "DoubleValue",
+		inputMessage: &wrapperspb.DoubleValue{},
+		inputText:    `1.02`,
+		wantMessage:  &wrapperspb.DoubleValue{Value: 1.02},
+	}, {
+		desc:         "DoubleValue Infinity",
+		inputMessage: &wrapperspb.DoubleValue{},
+		inputText:    `"Infinity"`,
+		wantMessage:  &wrapperspb.DoubleValue{Value: math.Inf(+1)},
+	}, {
+		desc:         "StringValue empty",
+		inputMessage: &wrapperspb.StringValue{},
+		inputText:    `""`,
+		wantMessage:  &wrapperspb.StringValue{},
+	}, {
+		desc:         "StringValue",
+		inputMessage: &wrapperspb.StringValue{},
+		inputText:    `"谷歌"`,
+		wantMessage:  &wrapperspb.StringValue{Value: "谷歌"},
+	}, {
+		desc:         "StringValue with invalid UTF8 error",
+		inputMessage: &wrapperspb.StringValue{},
+		inputText:    "\"abc\xff\"",
+		wantErr:      `invalid UTF-8`,
+	}, {
+		desc:         "StringValue field with invalid UTF8 error",
+		inputMessage: &pb2.KnownTypes{},
+		inputText:    "{\n  \"optString\": \"abc\xff\"\n}",
+		wantErr:      `invalid UTF-8`,
+	}, {
+		desc:         "NullValue field with JSON null",
+		inputMessage: &pb2.KnownTypes{},
+		inputText: `{
+  "optNull": null
+}`,
+		wantMessage: &pb2.KnownTypes{OptNull: new(structpb.NullValue)},
+	}, {
+		desc:         "NullValue field with string",
+		inputMessage: &pb2.KnownTypes{},
+		inputText: `{
+  "optNull": "NULL_VALUE"
+}`,
+		wantMessage: &pb2.KnownTypes{OptNull: new(structpb.NullValue)},
+	}, {
+		desc:         "BytesValue",
+		inputMessage: &wrapperspb.BytesValue{},
+		inputText:    `"aGVsbG8="`,
+		wantMessage:  &wrapperspb.BytesValue{Value: []byte("hello")},
+	}, {
+		desc:         "Value null",
+		inputMessage: &structpb.Value{},
+		inputText:    `null`,
+		wantMessage:  &structpb.Value{Kind: &structpb.Value_NullValue{}},
+	}, {
+		desc:         "Value field null",
+		inputMessage: &pb2.KnownTypes{},
+		inputText: `{
+  "optValue": null
+}`,
+		wantMessage: &pb2.KnownTypes{
+			OptValue: &structpb.Value{Kind: &structpb.Value_NullValue{}},
+		},
+	}, {
+		desc:         "Value bool",
+		inputMessage: &structpb.Value{},
+		inputText:    `false`,
+		wantMessage:  &structpb.Value{Kind: &structpb.Value_BoolValue{}},
+	}, {
+		desc:         "Value field bool",
+		inputMessage: &pb2.KnownTypes{},
+		inputText: `{
+  "optValue": true
+}`,
+		wantMessage: &pb2.KnownTypes{
+			OptValue: &structpb.Value{Kind: &structpb.Value_BoolValue{true}},
+		},
+	}, {
+		desc:         "Value number",
+		inputMessage: &structpb.Value{},
+		inputText:    `1.02`,
+		wantMessage:  &structpb.Value{Kind: &structpb.Value_NumberValue{1.02}},
+	}, {
+		desc:         "Value field number",
+		inputMessage: &pb2.KnownTypes{},
+		inputText: `{
+  "optValue": 1.02
+}`,
+		wantMessage: &pb2.KnownTypes{
+			OptValue: &structpb.Value{Kind: &structpb.Value_NumberValue{1.02}},
+		},
+	}, {
+		desc:         "Value string",
+		inputMessage: &structpb.Value{},
+		inputText:    `"hello"`,
+		wantMessage:  &structpb.Value{Kind: &structpb.Value_StringValue{"hello"}},
+	}, {
+		desc:         "Value string with invalid UTF8",
+		inputMessage: &structpb.Value{},
+		inputText:    "\"\xff\"",
+		wantErr:      `invalid UTF-8`,
+	}, {
+		desc:         "Value field string",
+		inputMessage: &pb2.KnownTypes{},
+		inputText: `{
+  "optValue": "NaN"
+}`,
+		wantMessage: &pb2.KnownTypes{
+			OptValue: &structpb.Value{Kind: &structpb.Value_StringValue{"NaN"}},
+		},
+	}, {
+		desc:         "Value field string with invalid UTF8",
+		inputMessage: &pb2.KnownTypes{},
+		inputText: `{
+  "optValue": "` + "\xff" + `"
+}`,
+		wantErr: `invalid UTF-8`,
+	}, {
+		desc:         "Value empty struct",
+		inputMessage: &structpb.Value{},
+		inputText:    `{}`,
+		wantMessage: &structpb.Value{
+			Kind: &structpb.Value_StructValue{
+				&structpb.Struct{Fields: map[string]*structpb.Value{}},
+			},
+		},
+	}, {
+		desc:         "Value struct",
+		inputMessage: &structpb.Value{},
+		inputText: `{
+  "string": "hello",
+  "number": 123,
+  "null": null,
+  "bool": false,
+  "struct": {
+    "string": "world"
+  },
+  "list": []
+}`,
+		wantMessage: &structpb.Value{
+			Kind: &structpb.Value_StructValue{
+				&structpb.Struct{
+					Fields: map[string]*structpb.Value{
+						"string": {Kind: &structpb.Value_StringValue{"hello"}},
+						"number": {Kind: &structpb.Value_NumberValue{123}},
+						"null":   {Kind: &structpb.Value_NullValue{}},
+						"bool":   {Kind: &structpb.Value_BoolValue{false}},
+						"struct": {
+							Kind: &structpb.Value_StructValue{
+								&structpb.Struct{
+									Fields: map[string]*structpb.Value{
+										"string": {Kind: &structpb.Value_StringValue{"world"}},
+									},
+								},
+							},
+						},
+						"list": {
+							Kind: &structpb.Value_ListValue{&structpb.ListValue{}},
+						},
+					},
+				},
+			},
+		},
+	}, {
+		desc:         "Value struct with invalid UTF8 string",
+		inputMessage: &structpb.Value{},
+		inputText:    "{\"string\": \"abc\xff\"}",
+		wantErr:      `invalid UTF-8`,
+	}, {
+		desc:         "Value field struct",
+		inputMessage: &pb2.KnownTypes{},
+		inputText: `{
+  "optValue": {
+    "string": "hello"
+  }
+}`,
+		wantMessage: &pb2.KnownTypes{
+			OptValue: &structpb.Value{
+				Kind: &structpb.Value_StructValue{
+					&structpb.Struct{
+						Fields: map[string]*structpb.Value{
+							"string": {Kind: &structpb.Value_StringValue{"hello"}},
+						},
+					},
+				},
+			},
+		},
+	}, {
+		desc:         "Value empty list",
+		inputMessage: &structpb.Value{},
+		inputText:    `[]`,
+		wantMessage: &structpb.Value{
+			Kind: &structpb.Value_ListValue{
+				&structpb.ListValue{Values: []*structpb.Value{}},
+			},
+		},
+	}, {
+		desc:         "Value list",
+		inputMessage: &structpb.Value{},
+		inputText: `[
+  "string",
+  123,
+  null,
+  true,
+  {},
+  [
+    "string",
+	1.23,
+	null,
+	false
+  ]
+]`,
+		wantMessage: &structpb.Value{
+			Kind: &structpb.Value_ListValue{
+				&structpb.ListValue{
+					Values: []*structpb.Value{
+						{Kind: &structpb.Value_StringValue{"string"}},
+						{Kind: &structpb.Value_NumberValue{123}},
+						{Kind: &structpb.Value_NullValue{}},
+						{Kind: &structpb.Value_BoolValue{true}},
+						{Kind: &structpb.Value_StructValue{&structpb.Struct{}}},
+						{
+							Kind: &structpb.Value_ListValue{
+								&structpb.ListValue{
+									Values: []*structpb.Value{
+										{Kind: &structpb.Value_StringValue{"string"}},
+										{Kind: &structpb.Value_NumberValue{1.23}},
+										{Kind: &structpb.Value_NullValue{}},
+										{Kind: &structpb.Value_BoolValue{false}},
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	}, {
+		desc:         "Value list with invalid UTF8 string",
+		inputMessage: &structpb.Value{},
+		inputText:    "[\"abc\xff\"]",
+		wantErr:      `invalid UTF-8`,
+	}, {
+		desc:         "Value field list with invalid UTF8 string",
+		inputMessage: &pb2.KnownTypes{},
+		inputText: `{
+  "optValue": [ "` + "abc\xff" + `"]
+}`,
+		wantErr: `(line 2:17): invalid UTF-8`,
+	}, {
+		desc:         "Duration empty string",
+		inputMessage: &durationpb.Duration{},
+		inputText:    `""`,
+		wantErr:      `invalid google.protobuf.Duration value ""`,
+	}, {
+		desc:         "Duration with secs",
+		inputMessage: &durationpb.Duration{},
+		inputText:    `"3s"`,
+		wantMessage:  &durationpb.Duration{Seconds: 3},
+	}, {
+		desc:         "Duration with escaped unicode",
+		inputMessage: &durationpb.Duration{},
+		inputText:    `"\u0033s"`,
+		wantMessage:  &durationpb.Duration{Seconds: 3},
+	}, {
+		desc:         "Duration with -secs",
+		inputMessage: &durationpb.Duration{},
+		inputText:    `"-3s"`,
+		wantMessage:  &durationpb.Duration{Seconds: -3},
+	}, {
+		desc:         "Duration with plus sign",
+		inputMessage: &durationpb.Duration{},
+		inputText:    `"+3s"`,
+		wantMessage:  &durationpb.Duration{Seconds: 3},
+	}, {
+		desc:         "Duration with nanos",
+		inputMessage: &durationpb.Duration{},
+		inputText:    `"0.001s"`,
+		wantMessage:  &durationpb.Duration{Nanos: 1e6},
+	}, {
+		desc:         "Duration with -nanos",
+		inputMessage: &durationpb.Duration{},
+		inputText:    `"-0.001s"`,
+		wantMessage:  &durationpb.Duration{Nanos: -1e6},
+	}, {
+		desc:         "Duration with -nanos",
+		inputMessage: &durationpb.Duration{},
+		inputText:    `"-.001s"`,
+		wantMessage:  &durationpb.Duration{Nanos: -1e6},
+	}, {
+		desc:         "Duration with +nanos",
+		inputMessage: &durationpb.Duration{},
+		inputText:    `"+.001s"`,
+		wantMessage:  &durationpb.Duration{Nanos: 1e6},
+	}, {
+		desc:         "Duration with -secs -nanos",
+		inputMessage: &durationpb.Duration{},
+		inputText:    `"-123.000000450s"`,
+		wantMessage:  &durationpb.Duration{Seconds: -123, Nanos: -450},
+	}, {
+		desc:         "Duration with large secs",
+		inputMessage: &durationpb.Duration{},
+		inputText:    `"10000000000.000000001s"`,
+		wantMessage:  &durationpb.Duration{Seconds: 1e10, Nanos: 1},
+	}, {
+		desc:         "Duration with decimal without fractional",
+		inputMessage: &durationpb.Duration{},
+		inputText:    `"3.s"`,
+		wantMessage:  &durationpb.Duration{Seconds: 3},
+	}, {
+		desc:         "Duration with decimal without integer",
+		inputMessage: &durationpb.Duration{},
+		inputText:    `"0.5s"`,
+		wantMessage:  &durationpb.Duration{Nanos: 5e8},
+	}, {
+		desc:         "Duration max value",
+		inputMessage: &durationpb.Duration{},
+		inputText:    `"315576000000.999999999s"`,
+		wantMessage:  &durationpb.Duration{Seconds: 315576000000, Nanos: 999999999},
+	}, {
+		desc:         "Duration min value",
+		inputMessage: &durationpb.Duration{},
+		inputText:    `"-315576000000.999999999s"`,
+		wantMessage:  &durationpb.Duration{Seconds: -315576000000, Nanos: -999999999},
+	}, {
+		desc:         "Duration with +secs out of range",
+		inputMessage: &durationpb.Duration{},
+		inputText:    `"315576000001s"`,
+		wantErr:      `google.protobuf.Duration value out of range: "315576000001s"`,
+	}, {
+		desc:         "Duration with -secs out of range",
+		inputMessage: &durationpb.Duration{},
+		inputText:    `"-315576000001s"`,
+		wantErr:      `google.protobuf.Duration value out of range: "-315576000001s"`,
+	}, {
+		desc:         "Duration with nanos beyond 9 digits",
+		inputMessage: &durationpb.Duration{},
+		inputText:    `"0.1000000000s"`,
+		wantErr:      `invalid google.protobuf.Duration value "0.1000000000s"`,
+	}, {
+		desc:         "Duration without suffix s",
+		inputMessage: &durationpb.Duration{},
+		inputText:    `"123"`,
+		wantErr:      `invalid google.protobuf.Duration value "123"`,
+	}, {
+		desc:         "Duration invalid signed fraction",
+		inputMessage: &durationpb.Duration{},
+		inputText:    `"123.+123s"`,
+		wantErr:      `invalid google.protobuf.Duration value "123.+123s"`,
+	}, {
+		desc:         "Duration invalid multiple .",
+		inputMessage: &durationpb.Duration{},
+		inputText:    `"123.123.s"`,
+		wantErr:      `invalid google.protobuf.Duration value "123.123.s"`,
+	}, {
+		desc:         "Duration invalid integer",
+		inputMessage: &durationpb.Duration{},
+		inputText:    `"01s"`,
+		wantErr:      `invalid google.protobuf.Duration value "01s"`,
+	}, {
+		desc:         "Timestamp zero",
+		inputMessage: &timestamppb.Timestamp{},
+		inputText:    `"1970-01-01T00:00:00Z"`,
+		wantMessage:  &timestamppb.Timestamp{},
+	}, {
+		desc:         "Timestamp with tz adjustment",
+		inputMessage: &timestamppb.Timestamp{},
+		inputText:    `"1970-01-01T00:00:00+01:00"`,
+		wantMessage:  &timestamppb.Timestamp{Seconds: -3600},
+	}, {
+		desc:         "Timestamp UTC",
+		inputMessage: &timestamppb.Timestamp{},
+		inputText:    `"2019-03-19T23:03:21Z"`,
+		wantMessage:  &timestamppb.Timestamp{Seconds: 1553036601},
+	}, {
+		desc:         "Timestamp with escaped unicode",
+		inputMessage: &timestamppb.Timestamp{},
+		inputText:    `"2019-0\u0033-19T23:03:21Z"`,
+		wantMessage:  &timestamppb.Timestamp{Seconds: 1553036601},
+	}, {
+		desc:         "Timestamp with nanos",
+		inputMessage: &timestamppb.Timestamp{},
+		inputText:    `"2019-03-19T23:03:21.000000001Z"`,
+		wantMessage:  &timestamppb.Timestamp{Seconds: 1553036601, Nanos: 1},
+	}, {
+		desc:         "Timestamp max value",
+		inputMessage: &timestamppb.Timestamp{},
+		inputText:    `"9999-12-31T23:59:59.999999999Z"`,
+		wantMessage:  &timestamppb.Timestamp{Seconds: 253402300799, Nanos: 999999999},
+	}, {
+		desc:         "Timestamp above max value",
+		inputMessage: &timestamppb.Timestamp{},
+		inputText:    `"9999-12-31T23:59:59-01:00"`,
+		wantErr:      `google.protobuf.Timestamp value out of range: "9999-12-31T23:59:59-01:00"`,
+	}, {
+		desc:         "Timestamp min value",
+		inputMessage: &timestamppb.Timestamp{},
+		inputText:    `"0001-01-01T00:00:00Z"`,
+		wantMessage:  &timestamppb.Timestamp{Seconds: -62135596800},
+	}, {
+		desc:         "Timestamp below min value",
+		inputMessage: &timestamppb.Timestamp{},
+		inputText:    `"0001-01-01T00:00:00+01:00"`,
+		wantErr:      `google.protobuf.Timestamp value out of range: "0001-01-01T00:00:00+01:00"`,
+	}, {
+		desc:         "Timestamp with nanos beyond 9 digits",
+		inputMessage: &timestamppb.Timestamp{},
+		inputText:    `"1970-01-01T00:00:00.0000000001Z"`,
+		wantErr:      `invalid google.protobuf.Timestamp value`,
+	}, {
+		desc:         "FieldMask empty",
+		inputMessage: &fieldmaskpb.FieldMask{},
+		inputText:    `""`,
+		wantMessage:  &fieldmaskpb.FieldMask{Paths: []string{}},
+	}, {
+		desc:         "FieldMask",
+		inputMessage: &fieldmaskpb.FieldMask{},
+		inputText:    `"foo,fooBar , foo.barQux ,Foo"`,
+		wantMessage: &fieldmaskpb.FieldMask{
+			Paths: []string{
+				"foo",
+				"foo_bar",
+				"foo.bar_qux",
+				"_foo",
+			},
+		},
+	}, {
+		desc:         "FieldMask field",
+		inputMessage: &pb2.KnownTypes{},
+		inputText: `{
+  "optFieldmask": "foo, qux.fooBar"
+}`,
+		wantMessage: &pb2.KnownTypes{
+			OptFieldmask: &fieldmaskpb.FieldMask{
+				Paths: []string{
+					"foo",
+					"qux.foo_bar",
+				},
+			},
+		},
+	}, {
+		desc:         "Any empty",
+		inputMessage: &anypb.Any{},
+		inputText:    `{}`,
+		wantMessage:  &anypb.Any{},
+	}, {
+		desc:         "Any with non-custom message",
+		inputMessage: &anypb.Any{},
+		inputText: `{
+  "@type": "foo/pb2.Nested",
+  "optString": "embedded inside Any",
+  "optNested": {
+    "optString": "inception"
+  }
+}`,
+		wantMessage: func() proto.Message {
+			m := &pb2.Nested{
+				OptString: proto.String("embedded inside Any"),
+				OptNested: &pb2.Nested{
+					OptString: proto.String("inception"),
+				},
+			}
+			b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			return &anypb.Any{
+				TypeUrl: "foo/pb2.Nested",
+				Value:   b,
+			}
+		}(),
+	}, {
+		desc:         "Any with empty embedded message",
+		inputMessage: &anypb.Any{},
+		inputText:    `{"@type": "foo/pb2.Nested"}`,
+		wantMessage:  &anypb.Any{TypeUrl: "foo/pb2.Nested"},
+	}, {
+		desc:         "Any without registered type",
+		umo:          protojson.UnmarshalOptions{Resolver: new(preg.Types)},
+		inputMessage: &anypb.Any{},
+		inputText:    `{"@type": "foo/pb2.Nested"}`,
+		wantErr:      `(line 1:11): unable to resolve "foo/pb2.Nested":`,
+	}, {
+		desc:         "Any with missing required",
+		inputMessage: &anypb.Any{},
+		inputText: `{
+  "@type": "pb2.PartialRequired",
+  "optString": "embedded inside Any"
+}`,
+		wantMessage: func() proto.Message {
+			m := &pb2.PartialRequired{
+				OptString: proto.String("embedded inside Any"),
+			}
+			b, err := proto.MarshalOptions{
+				Deterministic: true,
+				AllowPartial:  true,
+			}.Marshal(m)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			return &anypb.Any{
+				TypeUrl: string(m.ProtoReflect().Descriptor().FullName()),
+				Value:   b,
+			}
+		}(),
+	}, {
+		desc: "Any with partial required and AllowPartial",
+		umo: protojson.UnmarshalOptions{
+			AllowPartial: true,
+		},
+		inputMessage: &anypb.Any{},
+		inputText: `{
+  "@type": "pb2.PartialRequired",
+  "optString": "embedded inside Any"
+}`,
+		wantMessage: func() proto.Message {
+			m := &pb2.PartialRequired{
+				OptString: proto.String("embedded inside Any"),
+			}
+			b, err := proto.MarshalOptions{
+				Deterministic: true,
+				AllowPartial:  true,
+			}.Marshal(m)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			return &anypb.Any{
+				TypeUrl: string(m.ProtoReflect().Descriptor().FullName()),
+				Value:   b,
+			}
+		}(),
+	}, {
+		desc:         "Any with invalid UTF8",
+		inputMessage: &anypb.Any{},
+		inputText: `{
+  "optString": "` + "abc\xff" + `",
+  "@type": "foo/pb2.Nested"
+}`,
+		wantErr: `(line 2:16): invalid UTF-8`,
+	}, {
+		desc:         "Any with BoolValue",
+		inputMessage: &anypb.Any{},
+		inputText: `{
+  "@type": "type.googleapis.com/google.protobuf.BoolValue",
+  "value": true
+}`,
+		wantMessage: func() proto.Message {
+			m := &wrapperspb.BoolValue{Value: true}
+			b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			return &anypb.Any{
+				TypeUrl: "type.googleapis.com/google.protobuf.BoolValue",
+				Value:   b,
+			}
+		}(),
+	}, {
+		desc:         "Any with Empty",
+		inputMessage: &anypb.Any{},
+		inputText: `{
+  "value": {},
+  "@type": "type.googleapis.com/google.protobuf.Empty"
+}`,
+		wantMessage: &anypb.Any{
+			TypeUrl: "type.googleapis.com/google.protobuf.Empty",
+		},
+	}, {
+		desc:         "Any with missing Empty",
+		inputMessage: &anypb.Any{},
+		inputText: `{
+  "@type": "type.googleapis.com/google.protobuf.Empty"
+}`,
+		wantErr: `(line 3:1): missing "value" field`,
+	}, {
+		desc:         "Any with StringValue containing invalid UTF8",
+		inputMessage: &anypb.Any{},
+		inputText: `{
+  "@type": "google.protobuf.StringValue",
+  "value": "` + "abc\xff" + `"
+}`,
+		wantErr: `(line 3:12): invalid UTF-8`,
+	}, {
+		desc:         "Any with Int64Value",
+		inputMessage: &anypb.Any{},
+		inputText: `{
+  "@type": "google.protobuf.Int64Value",
+  "value": "42"
+}`,
+		wantMessage: func() proto.Message {
+			m := &wrapperspb.Int64Value{Value: 42}
+			b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			return &anypb.Any{
+				TypeUrl: "google.protobuf.Int64Value",
+				Value:   b,
+			}
+		}(),
+	}, {
+		desc:         "Any with invalid Int64Value",
+		inputMessage: &anypb.Any{},
+		inputText: `{
+  "@type": "google.protobuf.Int64Value",
+  "value": "forty-two"
+}`,
+		wantErr: `(line 3:12): invalid value for int64 type: "forty-two"`,
+	}, {
+		desc:         "Any with invalid UInt64Value",
+		inputMessage: &anypb.Any{},
+		inputText: `{
+  "@type": "google.protobuf.UInt64Value",
+  "value": -42
+}`,
+		wantErr: `(line 3:12): invalid value for uint64 type: -42`,
+	}, {
+		desc:         "Any with Duration",
+		inputMessage: &anypb.Any{},
+		inputText: `{
+  "@type": "type.googleapis.com/google.protobuf.Duration",
+  "value": "0s"
+}`,
+		wantMessage: func() proto.Message {
+			m := &durationpb.Duration{}
+			b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			return &anypb.Any{
+				TypeUrl: "type.googleapis.com/google.protobuf.Duration",
+				Value:   b,
+			}
+		}(),
+	}, {
+		desc:         "Any with Value of StringValue",
+		inputMessage: &anypb.Any{},
+		inputText: `{
+  "@type": "google.protobuf.Value",
+  "value": "` + "abc\xff" + `"
+}`,
+		wantErr: `(line 3:12): invalid UTF-8`,
+	}, {
+		desc:         "Any with Value of NullValue",
+		inputMessage: &anypb.Any{},
+		inputText: `{
+  "@type": "google.protobuf.Value",
+  "value": null
+}`,
+		wantMessage: func() proto.Message {
+			m := &structpb.Value{Kind: &structpb.Value_NullValue{}}
+			b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			return &anypb.Any{
+				TypeUrl: "google.protobuf.Value",
+				Value:   b,
+			}
+		}(),
+	}, {
+		desc:         "Any with Struct",
+		inputMessage: &anypb.Any{},
+		inputText: `{
+  "@type": "google.protobuf.Struct",
+  "value": {
+    "bool": true,
+    "null": null,
+    "string": "hello",
+    "struct": {
+      "string": "world"
+    }
+  }
+}`,
+		wantMessage: func() proto.Message {
+			m := &structpb.Struct{
+				Fields: map[string]*structpb.Value{
+					"bool":   {Kind: &structpb.Value_BoolValue{true}},
+					"null":   {Kind: &structpb.Value_NullValue{}},
+					"string": {Kind: &structpb.Value_StringValue{"hello"}},
+					"struct": {
+						Kind: &structpb.Value_StructValue{
+							&structpb.Struct{
+								Fields: map[string]*structpb.Value{
+									"string": {Kind: &structpb.Value_StringValue{"world"}},
+								},
+							},
+						},
+					},
+				},
+			}
+			b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			return &anypb.Any{
+				TypeUrl: "google.protobuf.Struct",
+				Value:   b,
+			}
+		}(),
+	}, {
+		desc:         "Any with missing @type",
+		umo:          protojson.UnmarshalOptions{},
+		inputMessage: &anypb.Any{},
+		inputText: `{
+  "value": {}
+}`,
+		wantErr: `(line 1:1): missing "@type" field`,
+	}, {
+		desc:         "Any with empty @type",
+		inputMessage: &anypb.Any{},
+		inputText: `{
+  "@type": ""
+}`,
+		wantErr: `(line 2:12): @type field contains empty value`,
+	}, {
+		desc:         "Any with duplicate @type",
+		inputMessage: &anypb.Any{},
+		inputText: `{
+  "@type": "google.protobuf.StringValue",
+  "value": "hello",
+  "@type": "pb2.Nested"
+}`,
+		wantErr: `(line 4:3): duplicate "@type" field`,
+	}, {
+		desc:         "Any with duplicate value",
+		inputMessage: &anypb.Any{},
+		inputText: `{
+  "@type": "google.protobuf.StringValue",
+  "value": "hello",
+  "value": "world"
+}`,
+		wantErr: `(line 4:3): duplicate "value" field`,
+	}, {
+		desc:         "Any with unknown field",
+		inputMessage: &anypb.Any{},
+		inputText: `{
+  "@type": "pb2.Nested",
+  "optString": "hello",
+  "unknown": "world"
+}`,
+		wantErr: `(line 4:3): unknown field "unknown"`,
+	}, {
+		desc:         "Any with embedded type containing Any",
+		inputMessage: &anypb.Any{},
+		inputText: `{
+  "@type": "pb2.KnownTypes",
+  "optAny": {
+    "@type": "google.protobuf.StringValue",
+    "value": "` + "abc\xff" + `"
+  }
+}`,
+		wantErr: `(line 5:14): invalid UTF-8`,
+	}, {
+		desc:         "well known types as field values",
+		inputMessage: &pb2.KnownTypes{},
+		inputText: `{
+  "optBool": false,
+  "optInt32": 42,
+  "optInt64": "42",
+  "optUint32": 42,
+  "optUint64": "42",
+  "optFloat": 1.23,
+  "optDouble": 3.1415,
+  "optString": "hello",
+  "optBytes": "aGVsbG8=",
+  "optDuration": "123s",
+  "optTimestamp": "2019-03-19T23:03:21Z",
+  "optStruct": {
+    "string": "hello"
+  },
+  "optList": [
+    null,
+    "",
+    {},
+    []
+  ],
+  "optValue": "world",
+  "optEmpty": {},
+  "optAny": {
+    "@type": "google.protobuf.Empty",
+    "value": {}
+  },
+  "optFieldmask": "fooBar,barFoo"
+}`,
+		wantMessage: &pb2.KnownTypes{
+			OptBool:      &wrapperspb.BoolValue{Value: false},
+			OptInt32:     &wrapperspb.Int32Value{Value: 42},
+			OptInt64:     &wrapperspb.Int64Value{Value: 42},
+			OptUint32:    &wrapperspb.UInt32Value{Value: 42},
+			OptUint64:    &wrapperspb.UInt64Value{Value: 42},
+			OptFloat:     &wrapperspb.FloatValue{Value: 1.23},
+			OptDouble:    &wrapperspb.DoubleValue{Value: 3.1415},
+			OptString:    &wrapperspb.StringValue{Value: "hello"},
+			OptBytes:     &wrapperspb.BytesValue{Value: []byte("hello")},
+			OptDuration:  &durationpb.Duration{Seconds: 123},
+			OptTimestamp: &timestamppb.Timestamp{Seconds: 1553036601},
+			OptStruct: &structpb.Struct{
+				Fields: map[string]*structpb.Value{
+					"string": {Kind: &structpb.Value_StringValue{"hello"}},
+				},
+			},
+			OptList: &structpb.ListValue{
+				Values: []*structpb.Value{
+					{Kind: &structpb.Value_NullValue{}},
+					{Kind: &structpb.Value_StringValue{}},
+					{
+						Kind: &structpb.Value_StructValue{
+							&structpb.Struct{Fields: map[string]*structpb.Value{}},
+						},
+					},
+					{
+						Kind: &structpb.Value_ListValue{
+							&structpb.ListValue{Values: []*structpb.Value{}},
+						},
+					},
+				},
+			},
+			OptValue: &structpb.Value{
+				Kind: &structpb.Value_StringValue{"world"},
+			},
+			OptEmpty: &emptypb.Empty{},
+			OptAny: &anypb.Any{
+				TypeUrl: "google.protobuf.Empty",
+			},
+			OptFieldmask: &fieldmaskpb.FieldMask{
+				Paths: []string{"foo_bar", "bar_foo"},
+			},
+		},
+	}, {
+		desc:         "DiscardUnknown: regular messages",
+		umo:          protojson.UnmarshalOptions{DiscardUnknown: true},
+		inputMessage: &pb3.Nests{},
+		inputText: `{
+  "sNested": {
+    "unknown": {
+      "foo": 1,
+	  "bar": [1, 2, 3]
+    }
+  },
+  "unknown": "not known"
+}`,
+		wantMessage: &pb3.Nests{SNested: &pb3.Nested{}},
+	}, {
+		desc:         "DiscardUnknown: repeated",
+		umo:          protojson.UnmarshalOptions{DiscardUnknown: true},
+		inputMessage: &pb2.Nests{},
+		inputText: `{
+  "rptNested": [
+    {"unknown": "blah"},
+	{"optString": "hello"}
+  ]
+}`,
+		wantMessage: &pb2.Nests{
+			RptNested: []*pb2.Nested{
+				{},
+				{OptString: proto.String("hello")},
+			},
+		},
+	}, {
+		desc:         "DiscardUnknown: map",
+		umo:          protojson.UnmarshalOptions{DiscardUnknown: true},
+		inputMessage: &pb3.Maps{},
+		inputText: `{
+  "strToNested": {
+    "nested_one": {
+	  "unknown": "what you see is not"
+    }
+  }
+}`,
+		wantMessage: &pb3.Maps{
+			StrToNested: map[string]*pb3.Nested{
+				"nested_one": {},
+			},
+		},
+	}, {
+		desc:         "DiscardUnknown: extension",
+		umo:          protojson.UnmarshalOptions{DiscardUnknown: true},
+		inputMessage: &pb2.Extensions{},
+		inputText: `{
+  "[pb2.opt_ext_nested]": {
+	"unknown": []
+  }
+}`,
+		wantMessage: func() proto.Message {
+			m := &pb2.Extensions{}
+			proto.SetExtension(m, pb2.E_OptExtNested, &pb2.Nested{})
+			return m
+		}(),
+	}, {
+		desc:         "DiscardUnknown: Empty",
+		umo:          protojson.UnmarshalOptions{DiscardUnknown: true},
+		inputMessage: &emptypb.Empty{},
+		inputText:    `{"unknown": "something"}`,
+		wantMessage:  &emptypb.Empty{},
+	}, {
+		desc:         "DiscardUnknown: Any without type",
+		umo:          protojson.UnmarshalOptions{DiscardUnknown: true},
+		inputMessage: &anypb.Any{},
+		inputText: `{
+  "value": {"foo": "bar"},
+  "unknown": true
+}`,
+		wantMessage: &anypb.Any{},
+	}, {
+		desc: "DiscardUnknown: Any",
+		umo: protojson.UnmarshalOptions{
+			DiscardUnknown: true,
+		},
+		inputMessage: &anypb.Any{},
+		inputText: `{
+  "@type": "foo/pb2.Nested",
+  "unknown": "none"
+}`,
+		wantMessage: &anypb.Any{
+			TypeUrl: "foo/pb2.Nested",
+		},
+	}, {
+		desc: "DiscardUnknown: Any with Empty",
+		umo: protojson.UnmarshalOptions{
+			DiscardUnknown: true,
+		},
+		inputMessage: &anypb.Any{},
+		inputText: `{
+  "@type": "type.googleapis.com/google.protobuf.Empty",
+  "value": {"unknown": 47}
+}`,
+		wantMessage: &anypb.Any{
+			TypeUrl: "type.googleapis.com/google.protobuf.Empty",
+		},
+	}, {
+		desc:         "weak fields",
+		inputMessage: &testpb.TestWeak{},
+		inputText:    `{"weak_message1":{"a":1}}`,
+		wantMessage: func() *testpb.TestWeak {
+			m := new(testpb.TestWeak)
+			m.SetWeakMessage1(&weakpb.WeakImportMessage1{A: proto.Int32(1)})
+			return m
+		}(),
+		skip: !flags.ProtoLegacy,
+	}, {
+		desc:         "weak fields; unknown field",
+		inputMessage: &testpb.TestWeak{},
+		inputText:    `{"weak_message1":{"a":1}, "weak_message2":{"a":1}}`,
+		wantErr:      `unknown field "weak_message2"`, // weak_message2 is unknown since the package containing it is not imported
+		skip:         !flags.ProtoLegacy,
+	}}
+
+	for _, tt := range tests {
+		tt := tt
+		if tt.skip {
+			continue
+		}
+		t.Run(tt.desc, func(t *testing.T) {
+			err := tt.umo.Unmarshal([]byte(tt.inputText), tt.inputMessage)
+			if err != nil {
+				if tt.wantErr == "" {
+					t.Errorf("Unmarshal() got unexpected error: %v", err)
+				} else if !strings.Contains(err.Error(), tt.wantErr) {
+					t.Errorf("Unmarshal() error got %q, want %q", err, tt.wantErr)
+				}
+				return
+			}
+			if tt.wantErr != "" {
+				t.Errorf("Unmarshal() got nil error, want error %q", tt.wantErr)
+			}
+			if tt.wantMessage != nil && !proto.Equal(tt.inputMessage, tt.wantMessage) {
+				t.Errorf("Unmarshal()\n<got>\n%v\n<want>\n%v\n", tt.inputMessage, tt.wantMessage)
+			}
+		})
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/encoding/protojson/doc.go b/vendor/google.golang.org/protobuf/encoding/protojson/doc.go
new file mode 100644
index 000000000..00ea2fecf
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/encoding/protojson/doc.go
@@ -0,0 +1,11 @@
+// Copyright 2019 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 protojson marshals and unmarshals protocol buffer messages as JSON
+// format. It follows the guide at
+// https://developers.google.com/protocol-buffers/docs/proto3#json.
+//
+// This package produces a different output than the standard "encoding/json"
+// package, which does not operate correctly on protocol buffer messages.
+package protojson
diff --git a/vendor/google.golang.org/protobuf/encoding/protojson/encode.go b/vendor/google.golang.org/protobuf/encoding/protojson/encode.go
new file mode 100644
index 000000000..e545feb53
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/encoding/protojson/encode.go
@@ -0,0 +1,394 @@
+// Copyright 2019 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 protojson
+
+import (
+	"encoding/base64"
+	"fmt"
+	"sort"
+
+	"google.golang.org/protobuf/internal/encoding/json"
+	"google.golang.org/protobuf/internal/encoding/messageset"
+	"google.golang.org/protobuf/internal/errors"
+	"google.golang.org/protobuf/internal/flags"
+	"google.golang.org/protobuf/internal/pragma"
+	"google.golang.org/protobuf/proto"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/reflect/protoregistry"
+)
+
+const defaultIndent = "  "
+
+// Format formats the message as a multiline string.
+// This function is only intended for human consumption and ignores errors.
+// Do not depend on the output being stable. It may change over time across
+// different versions of the program.
+func Format(m proto.Message) string {
+	return MarshalOptions{Multiline: true}.Format(m)
+}
+
+// Marshal writes the given proto.Message in JSON format using default options.
+// Do not depend on the output being stable. It may change over time across
+// different versions of the program.
+func Marshal(m proto.Message) ([]byte, error) {
+	return MarshalOptions{}.Marshal(m)
+}
+
+// MarshalOptions is a configurable JSON format marshaler.
+type MarshalOptions struct {
+	pragma.NoUnkeyedLiterals
+
+	// Multiline specifies whether the marshaler should format the output in
+	// indented-form with every textual element on a new line.
+	// If Indent is an empty string, then an arbitrary indent is chosen.
+	Multiline bool
+
+	// Indent specifies the set of indentation characters to use in a multiline
+	// formatted output such that every entry is preceded by Indent and
+	// terminated by a newline. If non-empty, then Multiline is treated as true.
+	// Indent can only be composed of space or tab characters.
+	Indent string
+
+	// AllowPartial allows messages that have missing required fields to marshal
+	// without returning an error. If AllowPartial is false (the default),
+	// Marshal will return error if there are any missing required fields.
+	AllowPartial bool
+
+	// UseProtoNames uses proto field name instead of lowerCamelCase name in JSON
+	// field names.
+	UseProtoNames bool
+
+	// UseEnumNumbers emits enum values as numbers.
+	UseEnumNumbers bool
+
+	// EmitUnpopulated specifies whether to emit unpopulated fields. It does not
+	// emit unpopulated oneof fields or unpopulated extension fields.
+	// The JSON value emitted for unpopulated fields are as follows:
+	//  ╔═══════╤════════════════════════════╗
+	//  ║ JSON  │ Protobuf field             ║
+	//  ╠═══════╪════════════════════════════╣
+	//  ║ false │ proto3 boolean fields      ║
+	//  ║ 0     │ proto3 numeric fields      ║
+	//  ║ ""    │ proto3 string/bytes fields ║
+	//  ║ null  │ proto2 scalar fields       ║
+	//  ║ null  │ message fields             ║
+	//  ║ []    │ list fields                ║
+	//  ║ {}    │ map fields                 ║
+	//  ╚═══════╧════════════════════════════╝
+	EmitUnpopulated bool
+
+	// Resolver is used for looking up types when expanding google.protobuf.Any
+	// messages. If nil, this defaults to using protoregistry.GlobalTypes.
+	Resolver interface {
+		protoregistry.ExtensionTypeResolver
+		protoregistry.MessageTypeResolver
+	}
+}
+
+// Format formats the message as a string.
+// This method is only intended for human consumption and ignores errors.
+// Do not depend on the output being stable. It may change over time across
+// different versions of the program.
+func (o MarshalOptions) Format(m proto.Message) string {
+	if m == nil || !m.ProtoReflect().IsValid() {
+		return "<nil>" // invalid syntax, but okay since this is for debugging
+	}
+	o.AllowPartial = true
+	b, _ := o.Marshal(m)
+	return string(b)
+}
+
+// Marshal marshals the given proto.Message in the JSON format using options in
+// MarshalOptions. Do not depend on the output being stable. It may change over
+// time across different versions of the program.
+func (o MarshalOptions) Marshal(m proto.Message) ([]byte, error) {
+	if o.Multiline && o.Indent == "" {
+		o.Indent = defaultIndent
+	}
+	if o.Resolver == nil {
+		o.Resolver = protoregistry.GlobalTypes
+	}
+
+	internalEnc, err := json.NewEncoder(o.Indent)
+	if err != nil {
+		return nil, err
+	}
+
+	// Treat nil message interface as an empty message,
+	// in which case the output in an empty JSON object.
+	if m == nil {
+		return []byte("{}"), nil
+	}
+
+	enc := encoder{internalEnc, o}
+	if err := enc.marshalMessage(m.ProtoReflect()); err != nil {
+		return nil, err
+	}
+	if o.AllowPartial {
+		return enc.Bytes(), nil
+	}
+	return enc.Bytes(), proto.CheckInitialized(m)
+}
+
+type encoder struct {
+	*json.Encoder
+	opts MarshalOptions
+}
+
+// marshalMessage marshals the given protoreflect.Message.
+func (e encoder) marshalMessage(m pref.Message) error {
+	if isCustomType(m.Descriptor().FullName()) {
+		return e.marshalCustomType(m)
+	}
+
+	e.StartObject()
+	defer e.EndObject()
+	if err := e.marshalFields(m); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// marshalFields marshals the fields in the given protoreflect.Message.
+func (e encoder) marshalFields(m pref.Message) error {
+	messageDesc := m.Descriptor()
+	if !flags.ProtoLegacy && messageset.IsMessageSet(messageDesc) {
+		return errors.New("no support for proto1 MessageSets")
+	}
+
+	// Marshal out known fields.
+	fieldDescs := messageDesc.Fields()
+	for i := 0; i < fieldDescs.Len(); {
+		fd := fieldDescs.Get(i)
+		if od := fd.ContainingOneof(); od != nil {
+			fd = m.WhichOneof(od)
+			i += od.Fields().Len()
+			if fd == nil {
+				continue // unpopulated oneofs are not affected by EmitUnpopulated
+			}
+		} else {
+			i++
+		}
+
+		val := m.Get(fd)
+		if !m.Has(fd) {
+			if !e.opts.EmitUnpopulated {
+				continue
+			}
+			isProto2Scalar := fd.Syntax() == pref.Proto2 && fd.Default().IsValid()
+			isSingularMessage := fd.Cardinality() != pref.Repeated && fd.Message() != nil
+			if isProto2Scalar || isSingularMessage {
+				// Use invalid value to emit null.
+				val = pref.Value{}
+			}
+		}
+
+		name := fd.JSONName()
+		if e.opts.UseProtoNames {
+			name = string(fd.Name())
+			// Use type name for group field name.
+			if fd.Kind() == pref.GroupKind {
+				name = string(fd.Message().Name())
+			}
+		}
+		if err := e.WriteName(name); err != nil {
+			return err
+		}
+		if err := e.marshalValue(val, fd); err != nil {
+			return err
+		}
+	}
+
+	// Marshal out extensions.
+	if err := e.marshalExtensions(m); err != nil {
+		return err
+	}
+	return nil
+}
+
+// marshalValue marshals the given protoreflect.Value.
+func (e encoder) marshalValue(val pref.Value, fd pref.FieldDescriptor) error {
+	switch {
+	case fd.IsList():
+		return e.marshalList(val.List(), fd)
+	case fd.IsMap():
+		return e.marshalMap(val.Map(), fd)
+	default:
+		return e.marshalSingular(val, fd)
+	}
+}
+
+// marshalSingular marshals the given non-repeated field value. This includes
+// all scalar types, enums, messages, and groups.
+func (e encoder) marshalSingular(val pref.Value, fd pref.FieldDescriptor) error {
+	if !val.IsValid() {
+		e.WriteNull()
+		return nil
+	}
+
+	switch kind := fd.Kind(); kind {
+	case pref.BoolKind:
+		e.WriteBool(val.Bool())
+
+	case pref.StringKind:
+		if e.WriteString(val.String()) != nil {
+			return errors.InvalidUTF8(string(fd.FullName()))
+		}
+
+	case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
+		e.WriteInt(val.Int())
+
+	case pref.Uint32Kind, pref.Fixed32Kind:
+		e.WriteUint(val.Uint())
+
+	case pref.Int64Kind, pref.Sint64Kind, pref.Uint64Kind,
+		pref.Sfixed64Kind, pref.Fixed64Kind:
+		// 64-bit integers are written out as JSON string.
+		e.WriteString(val.String())
+
+	case pref.FloatKind:
+		// Encoder.WriteFloat handles the special numbers NaN and infinites.
+		e.WriteFloat(val.Float(), 32)
+
+	case pref.DoubleKind:
+		// Encoder.WriteFloat handles the special numbers NaN and infinites.
+		e.WriteFloat(val.Float(), 64)
+
+	case pref.BytesKind:
+		e.WriteString(base64.StdEncoding.EncodeToString(val.Bytes()))
+
+	case pref.EnumKind:
+		if fd.Enum().FullName() == "google.protobuf.NullValue" {
+			e.WriteNull()
+		} else {
+			desc := fd.Enum().Values().ByNumber(val.Enum())
+			if e.opts.UseEnumNumbers || desc == nil {
+				e.WriteInt(int64(val.Enum()))
+			} else {
+				e.WriteString(string(desc.Name()))
+			}
+		}
+
+	case pref.MessageKind, pref.GroupKind:
+		if err := e.marshalMessage(val.Message()); err != nil {
+			return err
+		}
+
+	default:
+		panic(fmt.Sprintf("%v has unknown kind: %v", fd.FullName(), kind))
+	}
+	return nil
+}
+
+// marshalList marshals the given protoreflect.List.
+func (e encoder) marshalList(list pref.List, fd pref.FieldDescriptor) error {
+	e.StartArray()
+	defer e.EndArray()
+
+	for i := 0; i < list.Len(); i++ {
+		item := list.Get(i)
+		if err := e.marshalSingular(item, fd); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+type mapEntry struct {
+	key   pref.MapKey
+	value pref.Value
+}
+
+// marshalMap marshals given protoreflect.Map.
+func (e encoder) marshalMap(mmap pref.Map, fd pref.FieldDescriptor) error {
+	e.StartObject()
+	defer e.EndObject()
+
+	// Get a sorted list based on keyType first.
+	entries := make([]mapEntry, 0, mmap.Len())
+	mmap.Range(func(key pref.MapKey, val pref.Value) bool {
+		entries = append(entries, mapEntry{key: key, value: val})
+		return true
+	})
+	sortMap(fd.MapKey().Kind(), entries)
+
+	// Write out sorted list.
+	for _, entry := range entries {
+		if err := e.WriteName(entry.key.String()); err != nil {
+			return err
+		}
+		if err := e.marshalSingular(entry.value, fd.MapValue()); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// sortMap orders list based on value of key field for deterministic ordering.
+func sortMap(keyKind pref.Kind, values []mapEntry) {
+	sort.Slice(values, func(i, j int) bool {
+		switch keyKind {
+		case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind,
+			pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
+			return values[i].key.Int() < values[j].key.Int()
+
+		case pref.Uint32Kind, pref.Fixed32Kind,
+			pref.Uint64Kind, pref.Fixed64Kind:
+			return values[i].key.Uint() < values[j].key.Uint()
+		}
+		return values[i].key.String() < values[j].key.String()
+	})
+}
+
+// marshalExtensions marshals extension fields.
+func (e encoder) marshalExtensions(m pref.Message) error {
+	type entry struct {
+		key   string
+		value pref.Value
+		desc  pref.FieldDescriptor
+	}
+
+	// Get a sorted list based on field key first.
+	var entries []entry
+	m.Range(func(fd pref.FieldDescriptor, v pref.Value) bool {
+		if !fd.IsExtension() {
+			return true
+		}
+
+		// For MessageSet extensions, the name used is the parent message.
+		name := fd.FullName()
+		if messageset.IsMessageSetExtension(fd) {
+			name = name.Parent()
+		}
+
+		// Use [name] format for JSON field name.
+		entries = append(entries, entry{
+			key:   string(name),
+			value: v,
+			desc:  fd,
+		})
+		return true
+	})
+
+	// Sort extensions lexicographically.
+	sort.Slice(entries, func(i, j int) bool {
+		return entries[i].key < entries[j].key
+	})
+
+	// Write out sorted list.
+	for _, entry := range entries {
+		// JSON field name is the proto field name enclosed in [], similar to
+		// textproto. This is consistent with Go v1 lib. C++ lib v3.7.0 does not
+		// marshal out extension fields.
+		if err := e.WriteName("[" + entry.key + "]"); err != nil {
+			return err
+		}
+		if err := e.marshalValue(entry.value, entry.desc); err != nil {
+			return err
+		}
+	}
+	return nil
+}
diff --git a/vendor/google.golang.org/protobuf/encoding/protojson/encode_test.go b/vendor/google.golang.org/protobuf/encoding/protojson/encode_test.go
new file mode 100644
index 000000000..420070505
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/encoding/protojson/encode_test.go
@@ -0,0 +1,2225 @@
+// Copyright 2019 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 protojson_test
+
+import (
+	"bytes"
+	"math"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+
+	"google.golang.org/protobuf/encoding/protojson"
+	"google.golang.org/protobuf/internal/detrand"
+	"google.golang.org/protobuf/internal/flags"
+	"google.golang.org/protobuf/proto"
+	preg "google.golang.org/protobuf/reflect/protoregistry"
+	"google.golang.org/protobuf/testing/protopack"
+
+	fieldmaskpb "google.golang.org/protobuf/internal/testprotos/fieldmaskpb"
+	pb2 "google.golang.org/protobuf/internal/testprotos/textpb2"
+	pb3 "google.golang.org/protobuf/internal/testprotos/textpb3"
+	"google.golang.org/protobuf/types/known/anypb"
+	"google.golang.org/protobuf/types/known/durationpb"
+	"google.golang.org/protobuf/types/known/emptypb"
+	"google.golang.org/protobuf/types/known/structpb"
+	"google.golang.org/protobuf/types/known/timestamppb"
+	"google.golang.org/protobuf/types/known/wrapperspb"
+)
+
+// Disable detrand to enable direct comparisons on outputs.
+func init() { detrand.Disable() }
+
+func TestMarshal(t *testing.T) {
+	tests := []struct {
+		desc    string
+		mo      protojson.MarshalOptions
+		input   proto.Message
+		want    string
+		wantErr bool // TODO: Verify error message substring.
+		skip    bool
+	}{{
+		desc:  "proto2 optional scalars not set",
+		input: &pb2.Scalars{},
+		want:  "{}",
+	}, {
+		desc:  "proto3 scalars not set",
+		input: &pb3.Scalars{},
+		want:  "{}",
+	}, {
+		desc:  "proto3 optional not set",
+		input: &pb3.Proto3Optional{},
+		want:  "{}",
+	}, {
+		desc: "proto2 optional scalars set to zero values",
+		input: &pb2.Scalars{
+			OptBool:     proto.Bool(false),
+			OptInt32:    proto.Int32(0),
+			OptInt64:    proto.Int64(0),
+			OptUint32:   proto.Uint32(0),
+			OptUint64:   proto.Uint64(0),
+			OptSint32:   proto.Int32(0),
+			OptSint64:   proto.Int64(0),
+			OptFixed32:  proto.Uint32(0),
+			OptFixed64:  proto.Uint64(0),
+			OptSfixed32: proto.Int32(0),
+			OptSfixed64: proto.Int64(0),
+			OptFloat:    proto.Float32(0),
+			OptDouble:   proto.Float64(0),
+			OptBytes:    []byte{},
+			OptString:   proto.String(""),
+		},
+		want: `{
+  "optBool": false,
+  "optInt32": 0,
+  "optInt64": "0",
+  "optUint32": 0,
+  "optUint64": "0",
+  "optSint32": 0,
+  "optSint64": "0",
+  "optFixed32": 0,
+  "optFixed64": "0",
+  "optSfixed32": 0,
+  "optSfixed64": "0",
+  "optFloat": 0,
+  "optDouble": 0,
+  "optBytes": "",
+  "optString": ""
+}`,
+	}, {
+		desc: "proto3 optional set to zero values",
+		input: &pb3.Proto3Optional{
+			OptBool:    proto.Bool(false),
+			OptInt32:   proto.Int32(0),
+			OptInt64:   proto.Int64(0),
+			OptUint32:  proto.Uint32(0),
+			OptUint64:  proto.Uint64(0),
+			OptFloat:   proto.Float32(0),
+			OptDouble:  proto.Float64(0),
+			OptString:  proto.String(""),
+			OptBytes:   []byte{},
+			OptEnum:    pb3.Enum_ZERO.Enum(),
+			OptMessage: &pb3.Nested{},
+		},
+		want: `{
+  "optBool": false,
+  "optInt32": 0,
+  "optInt64": "0",
+  "optUint32": 0,
+  "optUint64": "0",
+  "optFloat": 0,
+  "optDouble": 0,
+  "optString": "",
+  "optBytes": "",
+  "optEnum": "ZERO",
+  "optMessage": {}
+}`,
+	}, {
+		desc: "proto2 optional scalars set to some values",
+		input: &pb2.Scalars{
+			OptBool:     proto.Bool(true),
+			OptInt32:    proto.Int32(0xff),
+			OptInt64:    proto.Int64(0xdeadbeef),
+			OptUint32:   proto.Uint32(47),
+			OptUint64:   proto.Uint64(0xdeadbeef),
+			OptSint32:   proto.Int32(-1001),
+			OptSint64:   proto.Int64(-0xffff),
+			OptFixed64:  proto.Uint64(64),
+			OptSfixed32: proto.Int32(-32),
+			OptFloat:    proto.Float32(1.02),
+			OptDouble:   proto.Float64(1.234),
+			OptBytes:    []byte("谷歌"),
+			OptString:   proto.String("谷歌"),
+		},
+		want: `{
+  "optBool": true,
+  "optInt32": 255,
+  "optInt64": "3735928559",
+  "optUint32": 47,
+  "optUint64": "3735928559",
+  "optSint32": -1001,
+  "optSint64": "-65535",
+  "optFixed64": "64",
+  "optSfixed32": -32,
+  "optFloat": 1.02,
+  "optDouble": 1.234,
+  "optBytes": "6LC35q2M",
+  "optString": "谷歌"
+}`,
+	}, {
+		desc: "string",
+		input: &pb3.Scalars{
+			SString: "谷歌",
+		},
+		want: `{
+  "sString": "谷歌"
+}`,
+	}, {
+		desc: "string with invalid UTF8",
+		input: &pb3.Scalars{
+			SString: "abc\xff",
+		},
+		wantErr: true,
+	}, {
+		desc: "float nan",
+		input: &pb3.Scalars{
+			SFloat: float32(math.NaN()),
+		},
+		want: `{
+  "sFloat": "NaN"
+}`,
+	}, {
+		desc: "float positive infinity",
+		input: &pb3.Scalars{
+			SFloat: float32(math.Inf(1)),
+		},
+		want: `{
+  "sFloat": "Infinity"
+}`,
+	}, {
+		desc: "float negative infinity",
+		input: &pb3.Scalars{
+			SFloat: float32(math.Inf(-1)),
+		},
+		want: `{
+  "sFloat": "-Infinity"
+}`,
+	}, {
+		desc: "double nan",
+		input: &pb3.Scalars{
+			SDouble: math.NaN(),
+		},
+		want: `{
+  "sDouble": "NaN"
+}`,
+	}, {
+		desc: "double positive infinity",
+		input: &pb3.Scalars{
+			SDouble: math.Inf(1),
+		},
+		want: `{
+  "sDouble": "Infinity"
+}`,
+	}, {
+		desc: "double negative infinity",
+		input: &pb3.Scalars{
+			SDouble: math.Inf(-1),
+		},
+		want: `{
+  "sDouble": "-Infinity"
+}`,
+	}, {
+		desc:  "proto2 enum not set",
+		input: &pb2.Enums{},
+		want:  "{}",
+	}, {
+		desc: "proto2 enum set to zero value",
+		input: &pb2.Enums{
+			OptEnum:       pb2.Enum(0).Enum(),
+			OptNestedEnum: pb2.Enums_NestedEnum(0).Enum(),
+		},
+		want: `{
+  "optEnum": 0,
+  "optNestedEnum": 0
+}`,
+	}, {
+		desc: "proto2 enum",
+		input: &pb2.Enums{
+			OptEnum:       pb2.Enum_ONE.Enum(),
+			OptNestedEnum: pb2.Enums_UNO.Enum(),
+		},
+		want: `{
+  "optEnum": "ONE",
+  "optNestedEnum": "UNO"
+}`,
+	}, {
+		desc: "proto2 enum set to numeric values",
+		input: &pb2.Enums{
+			OptEnum:       pb2.Enum(2).Enum(),
+			OptNestedEnum: pb2.Enums_NestedEnum(2).Enum(),
+		},
+		want: `{
+  "optEnum": "TWO",
+  "optNestedEnum": "DOS"
+}`,
+	}, {
+		desc: "proto2 enum set to unnamed numeric values",
+		input: &pb2.Enums{
+			OptEnum:       pb2.Enum(101).Enum(),
+			OptNestedEnum: pb2.Enums_NestedEnum(-101).Enum(),
+		},
+		want: `{
+  "optEnum": 101,
+  "optNestedEnum": -101
+}`,
+	}, {
+		desc:  "proto3 enum not set",
+		input: &pb3.Enums{},
+		want:  "{}",
+	}, {
+		desc: "proto3 enum set to zero value",
+		input: &pb3.Enums{
+			SEnum:       pb3.Enum_ZERO,
+			SNestedEnum: pb3.Enums_CERO,
+		},
+		want: "{}",
+	}, {
+		desc: "proto3 enum",
+		input: &pb3.Enums{
+			SEnum:       pb3.Enum_ONE,
+			SNestedEnum: pb3.Enums_UNO,
+		},
+		want: `{
+  "sEnum": "ONE",
+  "sNestedEnum": "UNO"
+}`,
+	}, {
+		desc: "proto3 enum set to numeric values",
+		input: &pb3.Enums{
+			SEnum:       2,
+			SNestedEnum: 2,
+		},
+		want: `{
+  "sEnum": "TWO",
+  "sNestedEnum": "DOS"
+}`,
+	}, {
+		desc: "proto3 enum set to unnamed numeric values",
+		input: &pb3.Enums{
+			SEnum:       -47,
+			SNestedEnum: 47,
+		},
+		want: `{
+  "sEnum": -47,
+  "sNestedEnum": 47
+}`,
+	}, {
+		desc:  "proto2 nested message not set",
+		input: &pb2.Nests{},
+		want:  "{}",
+	}, {
+		desc: "proto2 nested message set to empty",
+		input: &pb2.Nests{
+			OptNested: &pb2.Nested{},
+			Optgroup:  &pb2.Nests_OptGroup{},
+		},
+		want: `{
+  "optNested": {},
+  "optgroup": {}
+}`,
+	}, {
+		desc: "proto2 nested messages",
+		input: &pb2.Nests{
+			OptNested: &pb2.Nested{
+				OptString: proto.String("nested message"),
+				OptNested: &pb2.Nested{
+					OptString: proto.String("another nested message"),
+				},
+			},
+		},
+		want: `{
+  "optNested": {
+    "optString": "nested message",
+    "optNested": {
+      "optString": "another nested message"
+    }
+  }
+}`,
+	}, {
+		desc: "proto2 groups",
+		input: &pb2.Nests{
+			Optgroup: &pb2.Nests_OptGroup{
+				OptString: proto.String("inside a group"),
+				OptNested: &pb2.Nested{
+					OptString: proto.String("nested message inside a group"),
+				},
+				Optnestedgroup: &pb2.Nests_OptGroup_OptNestedGroup{
+					OptFixed32: proto.Uint32(47),
+				},
+			},
+		},
+		want: `{
+  "optgroup": {
+    "optString": "inside a group",
+    "optNested": {
+      "optString": "nested message inside a group"
+    },
+    "optnestedgroup": {
+      "optFixed32": 47
+    }
+  }
+}`,
+	}, {
+		desc:  "proto3 nested message not set",
+		input: &pb3.Nests{},
+		want:  "{}",
+	}, {
+		desc: "proto3 nested message set to empty",
+		input: &pb3.Nests{
+			SNested: &pb3.Nested{},
+		},
+		want: `{
+  "sNested": {}
+}`,
+	}, {
+		desc: "proto3 nested message",
+		input: &pb3.Nests{
+			SNested: &pb3.Nested{
+				SString: "nested message",
+				SNested: &pb3.Nested{
+					SString: "another nested message",
+				},
+			},
+		},
+		want: `{
+  "sNested": {
+    "sString": "nested message",
+    "sNested": {
+      "sString": "another nested message"
+    }
+  }
+}`,
+	}, {
+		desc:  "oneof not set",
+		input: &pb3.Oneofs{},
+		want:  "{}",
+	}, {
+		desc: "oneof set to empty string",
+		input: &pb3.Oneofs{
+			Union: &pb3.Oneofs_OneofString{},
+		},
+		want: `{
+  "oneofString": ""
+}`,
+	}, {
+		desc: "oneof set to string",
+		input: &pb3.Oneofs{
+			Union: &pb3.Oneofs_OneofString{
+				OneofString: "hello",
+			},
+		},
+		want: `{
+  "oneofString": "hello"
+}`,
+	}, {
+		desc: "oneof set to enum",
+		input: &pb3.Oneofs{
+			Union: &pb3.Oneofs_OneofEnum{
+				OneofEnum: pb3.Enum_ZERO,
+			},
+		},
+		want: `{
+  "oneofEnum": "ZERO"
+}`,
+	}, {
+		desc: "oneof set to empty message",
+		input: &pb3.Oneofs{
+			Union: &pb3.Oneofs_OneofNested{
+				OneofNested: &pb3.Nested{},
+			},
+		},
+		want: `{
+  "oneofNested": {}
+}`,
+	}, {
+		desc: "oneof set to message",
+		input: &pb3.Oneofs{
+			Union: &pb3.Oneofs_OneofNested{
+				OneofNested: &pb3.Nested{
+					SString: "nested message",
+				},
+			},
+		},
+		want: `{
+  "oneofNested": {
+    "sString": "nested message"
+  }
+}`,
+	}, {
+		desc:  "repeated fields not set",
+		input: &pb2.Repeats{},
+		want:  "{}",
+	}, {
+		desc: "repeated fields set to empty slices",
+		input: &pb2.Repeats{
+			RptBool:   []bool{},
+			RptInt32:  []int32{},
+			RptInt64:  []int64{},
+			RptUint32: []uint32{},
+			RptUint64: []uint64{},
+			RptFloat:  []float32{},
+			RptDouble: []float64{},
+			RptBytes:  [][]byte{},
+		},
+		want: "{}",
+	}, {
+		desc: "repeated fields set to some values",
+		input: &pb2.Repeats{
+			RptBool:   []bool{true, false, true, true},
+			RptInt32:  []int32{1, 6, 0, 0},
+			RptInt64:  []int64{-64, 47},
+			RptUint32: []uint32{0xff, 0xffff},
+			RptUint64: []uint64{0xdeadbeef},
+			RptFloat:  []float32{float32(math.NaN()), float32(math.Inf(1)), float32(math.Inf(-1)), 1.034},
+			RptDouble: []float64{math.NaN(), math.Inf(1), math.Inf(-1), 1.23e-308},
+			RptString: []string{"hello", "世界"},
+			RptBytes: [][]byte{
+				[]byte("hello"),
+				[]byte("\xe4\xb8\x96\xe7\x95\x8c"),
+			},
+		},
+		want: `{
+  "rptBool": [
+    true,
+    false,
+    true,
+    true
+  ],
+  "rptInt32": [
+    1,
+    6,
+    0,
+    0
+  ],
+  "rptInt64": [
+    "-64",
+    "47"
+  ],
+  "rptUint32": [
+    255,
+    65535
+  ],
+  "rptUint64": [
+    "3735928559"
+  ],
+  "rptFloat": [
+    "NaN",
+    "Infinity",
+    "-Infinity",
+    1.034
+  ],
+  "rptDouble": [
+    "NaN",
+    "Infinity",
+    "-Infinity",
+    1.23e-308
+  ],
+  "rptString": [
+    "hello",
+    "世界"
+  ],
+  "rptBytes": [
+    "aGVsbG8=",
+    "5LiW55WM"
+  ]
+}`,
+	}, {
+		desc: "repeated enums",
+		input: &pb2.Enums{
+			RptEnum:       []pb2.Enum{pb2.Enum_ONE, 2, pb2.Enum_TEN, 42},
+			RptNestedEnum: []pb2.Enums_NestedEnum{2, 47, 10},
+		},
+		want: `{
+  "rptEnum": [
+    "ONE",
+    "TWO",
+    "TEN",
+    42
+  ],
+  "rptNestedEnum": [
+    "DOS",
+    47,
+    "DIEZ"
+  ]
+}`,
+	}, {
+		desc: "repeated messages set to empty",
+		input: &pb2.Nests{
+			RptNested: []*pb2.Nested{},
+			Rptgroup:  []*pb2.Nests_RptGroup{},
+		},
+		want: "{}",
+	}, {
+		desc: "repeated messages",
+		input: &pb2.Nests{
+			RptNested: []*pb2.Nested{
+				{
+					OptString: proto.String("repeat nested one"),
+				},
+				{
+					OptString: proto.String("repeat nested two"),
+					OptNested: &pb2.Nested{
+						OptString: proto.String("inside repeat nested two"),
+					},
+				},
+				{},
+			},
+		},
+		want: `{
+  "rptNested": [
+    {
+      "optString": "repeat nested one"
+    },
+    {
+      "optString": "repeat nested two",
+      "optNested": {
+        "optString": "inside repeat nested two"
+      }
+    },
+    {}
+  ]
+}`,
+	}, {
+		desc: "repeated messages contains nil value",
+		input: &pb2.Nests{
+			RptNested: []*pb2.Nested{nil, {}},
+		},
+		want: `{
+  "rptNested": [
+    {},
+    {}
+  ]
+}`,
+	}, {
+		desc: "repeated groups",
+		input: &pb2.Nests{
+			Rptgroup: []*pb2.Nests_RptGroup{
+				{
+					RptString: []string{"hello", "world"},
+				},
+				{},
+				nil,
+			},
+		},
+		want: `{
+  "rptgroup": [
+    {
+      "rptString": [
+        "hello",
+        "world"
+      ]
+    },
+    {},
+    {}
+  ]
+}`,
+	}, {
+		desc:  "map fields not set",
+		input: &pb3.Maps{},
+		want:  "{}",
+	}, {
+		desc: "map fields set to empty",
+		input: &pb3.Maps{
+			Int32ToStr:   map[int32]string{},
+			BoolToUint32: map[bool]uint32{},
+			Uint64ToEnum: map[uint64]pb3.Enum{},
+			StrToNested:  map[string]*pb3.Nested{},
+			StrToOneofs:  map[string]*pb3.Oneofs{},
+		},
+		want: "{}",
+	}, {
+		desc: "map fields 1",
+		input: &pb3.Maps{
+			BoolToUint32: map[bool]uint32{
+				true:  42,
+				false: 101,
+			},
+		},
+		want: `{
+  "boolToUint32": {
+    "false": 101,
+    "true": 42
+  }
+}`,
+	}, {
+		desc: "map fields 2",
+		input: &pb3.Maps{
+			Int32ToStr: map[int32]string{
+				-101: "-101",
+				0xff: "0xff",
+				0:    "zero",
+			},
+		},
+		want: `{
+  "int32ToStr": {
+    "-101": "-101",
+    "0": "zero",
+    "255": "0xff"
+  }
+}`,
+	}, {
+		desc: "map fields 3",
+		input: &pb3.Maps{
+			Uint64ToEnum: map[uint64]pb3.Enum{
+				1:  pb3.Enum_ONE,
+				2:  pb3.Enum_TWO,
+				10: pb3.Enum_TEN,
+				47: 47,
+			},
+		},
+		want: `{
+  "uint64ToEnum": {
+    "1": "ONE",
+    "2": "TWO",
+    "10": "TEN",
+    "47": 47
+  }
+}`,
+	}, {
+		desc: "map fields 4",
+		input: &pb3.Maps{
+			StrToNested: map[string]*pb3.Nested{
+				"nested": &pb3.Nested{
+					SString: "nested in a map",
+				},
+			},
+		},
+		want: `{
+  "strToNested": {
+    "nested": {
+      "sString": "nested in a map"
+    }
+  }
+}`,
+	}, {
+		desc: "map fields 5",
+		input: &pb3.Maps{
+			StrToOneofs: map[string]*pb3.Oneofs{
+				"string": &pb3.Oneofs{
+					Union: &pb3.Oneofs_OneofString{
+						OneofString: "hello",
+					},
+				},
+				"nested": &pb3.Oneofs{
+					Union: &pb3.Oneofs_OneofNested{
+						OneofNested: &pb3.Nested{
+							SString: "nested oneof in map field value",
+						},
+					},
+				},
+			},
+		},
+		want: `{
+  "strToOneofs": {
+    "nested": {
+      "oneofNested": {
+        "sString": "nested oneof in map field value"
+      }
+    },
+    "string": {
+      "oneofString": "hello"
+    }
+  }
+}`,
+	}, {
+		desc: "map field contains nil value",
+		input: &pb3.Maps{
+			StrToNested: map[string]*pb3.Nested{
+				"nil": nil,
+			},
+		},
+		want: `{
+  "strToNested": {
+    "nil": {}
+  }
+}`,
+	}, {
+		desc:    "required fields not set",
+		input:   &pb2.Requireds{},
+		want:    `{}`,
+		wantErr: true,
+	}, {
+		desc: "required fields partially set",
+		input: &pb2.Requireds{
+			ReqBool:     proto.Bool(false),
+			ReqSfixed64: proto.Int64(0),
+			ReqDouble:   proto.Float64(1.23),
+			ReqString:   proto.String("hello"),
+			ReqEnum:     pb2.Enum_ONE.Enum(),
+		},
+		want: `{
+  "reqBool": false,
+  "reqSfixed64": "0",
+  "reqDouble": 1.23,
+  "reqString": "hello",
+  "reqEnum": "ONE"
+}`,
+		wantErr: true,
+	}, {
+		desc: "required fields not set with AllowPartial",
+		mo:   protojson.MarshalOptions{AllowPartial: true},
+		input: &pb2.Requireds{
+			ReqBool:     proto.Bool(false),
+			ReqSfixed64: proto.Int64(0),
+			ReqDouble:   proto.Float64(1.23),
+			ReqString:   proto.String("hello"),
+			ReqEnum:     pb2.Enum_ONE.Enum(),
+		},
+		want: `{
+  "reqBool": false,
+  "reqSfixed64": "0",
+  "reqDouble": 1.23,
+  "reqString": "hello",
+  "reqEnum": "ONE"
+}`,
+	}, {
+		desc: "required fields all set",
+		input: &pb2.Requireds{
+			ReqBool:     proto.Bool(false),
+			ReqSfixed64: proto.Int64(0),
+			ReqDouble:   proto.Float64(1.23),
+			ReqString:   proto.String("hello"),
+			ReqEnum:     pb2.Enum_ONE.Enum(),
+			ReqNested:   &pb2.Nested{},
+		},
+		want: `{
+  "reqBool": false,
+  "reqSfixed64": "0",
+  "reqDouble": 1.23,
+  "reqString": "hello",
+  "reqEnum": "ONE",
+  "reqNested": {}
+}`,
+	}, {
+		desc: "indirect required field",
+		input: &pb2.IndirectRequired{
+			OptNested: &pb2.NestedWithRequired{},
+		},
+		want: `{
+  "optNested": {}
+}`,
+		wantErr: true,
+	}, {
+		desc: "indirect required field with AllowPartial",
+		mo:   protojson.MarshalOptions{AllowPartial: true},
+		input: &pb2.IndirectRequired{
+			OptNested: &pb2.NestedWithRequired{},
+		},
+		want: `{
+  "optNested": {}
+}`,
+	}, {
+		desc: "indirect required field in empty repeated",
+		input: &pb2.IndirectRequired{
+			RptNested: []*pb2.NestedWithRequired{},
+		},
+		want: `{}`,
+	}, {
+		desc: "indirect required field in repeated",
+		input: &pb2.IndirectRequired{
+			RptNested: []*pb2.NestedWithRequired{
+				&pb2.NestedWithRequired{},
+			},
+		},
+		want: `{
+  "rptNested": [
+    {}
+  ]
+}`,
+		wantErr: true,
+	}, {
+		desc: "indirect required field in repeated with AllowPartial",
+		mo:   protojson.MarshalOptions{AllowPartial: true},
+		input: &pb2.IndirectRequired{
+			RptNested: []*pb2.NestedWithRequired{
+				&pb2.NestedWithRequired{},
+			},
+		},
+		want: `{
+  "rptNested": [
+    {}
+  ]
+}`,
+	}, {
+		desc: "indirect required field in empty map",
+		input: &pb2.IndirectRequired{
+			StrToNested: map[string]*pb2.NestedWithRequired{},
+		},
+		want: "{}",
+	}, {
+		desc: "indirect required field in map",
+		input: &pb2.IndirectRequired{
+			StrToNested: map[string]*pb2.NestedWithRequired{
+				"fail": &pb2.NestedWithRequired{},
+			},
+		},
+		want: `{
+  "strToNested": {
+    "fail": {}
+  }
+}`,
+		wantErr: true,
+	}, {
+		desc: "indirect required field in map with AllowPartial",
+		mo:   protojson.MarshalOptions{AllowPartial: true},
+		input: &pb2.IndirectRequired{
+			StrToNested: map[string]*pb2.NestedWithRequired{
+				"fail": &pb2.NestedWithRequired{},
+			},
+		},
+		want: `{
+  "strToNested": {
+    "fail": {}
+  }
+}`,
+	}, {
+		desc: "indirect required field in oneof",
+		input: &pb2.IndirectRequired{
+			Union: &pb2.IndirectRequired_OneofNested{
+				OneofNested: &pb2.NestedWithRequired{},
+			},
+		},
+		want: `{
+  "oneofNested": {}
+}`,
+		wantErr: true,
+	}, {
+		desc: "indirect required field in oneof with AllowPartial",
+		mo:   protojson.MarshalOptions{AllowPartial: true},
+		input: &pb2.IndirectRequired{
+			Union: &pb2.IndirectRequired_OneofNested{
+				OneofNested: &pb2.NestedWithRequired{},
+			},
+		},
+		want: `{
+  "oneofNested": {}
+}`,
+	}, {
+		desc: "unknown fields are ignored",
+		input: func() proto.Message {
+			m := &pb2.Scalars{
+				OptString: proto.String("no unknowns"),
+			}
+			m.ProtoReflect().SetUnknown(protopack.Message{
+				protopack.Tag{101, protopack.BytesType}, protopack.String("hello world"),
+			}.Marshal())
+			return m
+		}(),
+		want: `{
+  "optString": "no unknowns"
+}`,
+	}, {
+		desc: "json_name",
+		input: &pb3.JSONNames{
+			SString: "json_name",
+		},
+		want: `{
+  "foo_bar": "json_name"
+}`,
+	}, {
+		desc: "extensions of non-repeated fields",
+		input: func() proto.Message {
+			m := &pb2.Extensions{
+				OptString: proto.String("non-extension field"),
+				OptBool:   proto.Bool(true),
+				OptInt32:  proto.Int32(42),
+			}
+			proto.SetExtension(m, pb2.E_OptExtBool, true)
+			proto.SetExtension(m, pb2.E_OptExtString, "extension field")
+			proto.SetExtension(m, pb2.E_OptExtEnum, pb2.Enum_TEN)
+			proto.SetExtension(m, pb2.E_OptExtNested, &pb2.Nested{
+				OptString: proto.String("nested in an extension"),
+				OptNested: &pb2.Nested{
+					OptString: proto.String("another nested in an extension"),
+				},
+			})
+			return m
+		}(),
+		want: `{
+  "optString": "non-extension field",
+  "optBool": true,
+  "optInt32": 42,
+  "[pb2.opt_ext_bool]": true,
+  "[pb2.opt_ext_enum]": "TEN",
+  "[pb2.opt_ext_nested]": {
+    "optString": "nested in an extension",
+    "optNested": {
+      "optString": "another nested in an extension"
+    }
+  },
+  "[pb2.opt_ext_string]": "extension field"
+}`,
+	}, {
+		desc: "extensions of repeated fields",
+		input: func() proto.Message {
+			m := &pb2.Extensions{}
+			proto.SetExtension(m, pb2.E_RptExtEnum, []pb2.Enum{pb2.Enum_TEN, 101, pb2.Enum_ONE})
+			proto.SetExtension(m, pb2.E_RptExtFixed32, []uint32{42, 47})
+			proto.SetExtension(m, pb2.E_RptExtNested, []*pb2.Nested{
+				&pb2.Nested{OptString: proto.String("one")},
+				&pb2.Nested{OptString: proto.String("two")},
+				&pb2.Nested{OptString: proto.String("three")},
+			})
+			return m
+		}(),
+		want: `{
+  "[pb2.rpt_ext_enum]": [
+    "TEN",
+    101,
+    "ONE"
+  ],
+  "[pb2.rpt_ext_fixed32]": [
+    42,
+    47
+  ],
+  "[pb2.rpt_ext_nested]": [
+    {
+      "optString": "one"
+    },
+    {
+      "optString": "two"
+    },
+    {
+      "optString": "three"
+    }
+  ]
+}`,
+	}, {
+		desc: "extensions of non-repeated fields in another message",
+		input: func() proto.Message {
+			m := &pb2.Extensions{}
+			proto.SetExtension(m, pb2.E_ExtensionsContainer_OptExtBool, true)
+			proto.SetExtension(m, pb2.E_ExtensionsContainer_OptExtString, "extension field")
+			proto.SetExtension(m, pb2.E_ExtensionsContainer_OptExtEnum, pb2.Enum_TEN)
+			proto.SetExtension(m, pb2.E_ExtensionsContainer_OptExtNested, &pb2.Nested{
+				OptString: proto.String("nested in an extension"),
+				OptNested: &pb2.Nested{
+					OptString: proto.String("another nested in an extension"),
+				},
+			})
+			return m
+		}(),
+		want: `{
+  "[pb2.ExtensionsContainer.opt_ext_bool]": true,
+  "[pb2.ExtensionsContainer.opt_ext_enum]": "TEN",
+  "[pb2.ExtensionsContainer.opt_ext_nested]": {
+    "optString": "nested in an extension",
+    "optNested": {
+      "optString": "another nested in an extension"
+    }
+  },
+  "[pb2.ExtensionsContainer.opt_ext_string]": "extension field"
+}`,
+	}, {
+		desc: "extensions of repeated fields in another message",
+		input: func() proto.Message {
+			m := &pb2.Extensions{
+				OptString: proto.String("non-extension field"),
+				OptBool:   proto.Bool(true),
+				OptInt32:  proto.Int32(42),
+			}
+			proto.SetExtension(m, pb2.E_ExtensionsContainer_RptExtEnum, []pb2.Enum{pb2.Enum_TEN, 101, pb2.Enum_ONE})
+			proto.SetExtension(m, pb2.E_ExtensionsContainer_RptExtString, []string{"hello", "world"})
+			proto.SetExtension(m, pb2.E_ExtensionsContainer_RptExtNested, []*pb2.Nested{
+				&pb2.Nested{OptString: proto.String("one")},
+				&pb2.Nested{OptString: proto.String("two")},
+				&pb2.Nested{OptString: proto.String("three")},
+			})
+			return m
+		}(),
+		want: `{
+  "optString": "non-extension field",
+  "optBool": true,
+  "optInt32": 42,
+  "[pb2.ExtensionsContainer.rpt_ext_enum]": [
+    "TEN",
+    101,
+    "ONE"
+  ],
+  "[pb2.ExtensionsContainer.rpt_ext_nested]": [
+    {
+      "optString": "one"
+    },
+    {
+      "optString": "two"
+    },
+    {
+      "optString": "three"
+    }
+  ],
+  "[pb2.ExtensionsContainer.rpt_ext_string]": [
+    "hello",
+    "world"
+  ]
+}`,
+	}, {
+		desc: "MessageSet",
+		input: func() proto.Message {
+			m := &pb2.MessageSet{}
+			proto.SetExtension(m, pb2.E_MessageSetExtension_MessageSetExtension, &pb2.MessageSetExtension{
+				OptString: proto.String("a messageset extension"),
+			})
+			proto.SetExtension(m, pb2.E_MessageSetExtension_NotMessageSetExtension, &pb2.MessageSetExtension{
+				OptString: proto.String("not a messageset extension"),
+			})
+			proto.SetExtension(m, pb2.E_MessageSetExtension_ExtNested, &pb2.Nested{
+				OptString: proto.String("just a regular extension"),
+			})
+			return m
+		}(),
+		want: `{
+  "[pb2.MessageSetExtension]": {
+    "optString": "a messageset extension"
+  },
+  "[pb2.MessageSetExtension.ext_nested]": {
+    "optString": "just a regular extension"
+  },
+  "[pb2.MessageSetExtension.not_message_set_extension]": {
+    "optString": "not a messageset extension"
+  }
+}`,
+		skip: !flags.ProtoLegacy,
+	}, {
+		desc: "not real MessageSet 1",
+		input: func() proto.Message {
+			m := &pb2.FakeMessageSet{}
+			proto.SetExtension(m, pb2.E_FakeMessageSetExtension_MessageSetExtension, &pb2.FakeMessageSetExtension{
+				OptString: proto.String("not a messageset extension"),
+			})
+			return m
+		}(),
+		want: `{
+  "[pb2.FakeMessageSetExtension.message_set_extension]": {
+    "optString": "not a messageset extension"
+  }
+}`,
+		skip: !flags.ProtoLegacy,
+	}, {
+		desc: "not real MessageSet 2",
+		input: func() proto.Message {
+			m := &pb2.MessageSet{}
+			proto.SetExtension(m, pb2.E_MessageSetExtension, &pb2.FakeMessageSetExtension{
+				OptString: proto.String("another not a messageset extension"),
+			})
+			return m
+		}(),
+		want: `{
+  "[pb2.message_set_extension]": {
+    "optString": "another not a messageset extension"
+  }
+}`,
+		skip: !flags.ProtoLegacy,
+	}, {
+		desc:  "BoolValue empty",
+		input: &wrapperspb.BoolValue{},
+		want:  `false`,
+	}, {
+		desc:  "BoolValue",
+		input: &wrapperspb.BoolValue{Value: true},
+		want:  `true`,
+	}, {
+		desc:  "Int32Value empty",
+		input: &wrapperspb.Int32Value{},
+		want:  `0`,
+	}, {
+		desc:  "Int32Value",
+		input: &wrapperspb.Int32Value{Value: 42},
+		want:  `42`,
+	}, {
+		desc:  "Int64Value",
+		input: &wrapperspb.Int64Value{Value: 42},
+		want:  `"42"`,
+	}, {
+		desc:  "UInt32Value",
+		input: &wrapperspb.UInt32Value{Value: 42},
+		want:  `42`,
+	}, {
+		desc:  "UInt64Value",
+		input: &wrapperspb.UInt64Value{Value: 42},
+		want:  `"42"`,
+	}, {
+		desc:  "FloatValue",
+		input: &wrapperspb.FloatValue{Value: 1.02},
+		want:  `1.02`,
+	}, {
+		desc:  "FloatValue Infinity",
+		input: &wrapperspb.FloatValue{Value: float32(math.Inf(-1))},
+		want:  `"-Infinity"`,
+	}, {
+		desc:  "DoubleValue",
+		input: &wrapperspb.DoubleValue{Value: 1.02},
+		want:  `1.02`,
+	}, {
+		desc:  "DoubleValue NaN",
+		input: &wrapperspb.DoubleValue{Value: math.NaN()},
+		want:  `"NaN"`,
+	}, {
+		desc:  "StringValue empty",
+		input: &wrapperspb.StringValue{},
+		want:  `""`,
+	}, {
+		desc:  "StringValue",
+		input: &wrapperspb.StringValue{Value: "谷歌"},
+		want:  `"谷歌"`,
+	}, {
+		desc:    "StringValue with invalid UTF8 error",
+		input:   &wrapperspb.StringValue{Value: "abc\xff"},
+		wantErr: true,
+	}, {
+		desc: "StringValue field with invalid UTF8 error",
+		input: &pb2.KnownTypes{
+			OptString: &wrapperspb.StringValue{Value: "abc\xff"},
+		},
+		wantErr: true,
+	}, {
+		desc:  "BytesValue",
+		input: &wrapperspb.BytesValue{Value: []byte("hello")},
+		want:  `"aGVsbG8="`,
+	}, {
+		desc:  "Empty",
+		input: &emptypb.Empty{},
+		want:  `{}`,
+	}, {
+		desc:  "NullValue field",
+		input: &pb2.KnownTypes{OptNull: new(structpb.NullValue)},
+		want: `{
+  "optNull": null
+}`,
+	}, {
+		desc:    "Value empty",
+		input:   &structpb.Value{},
+		wantErr: true,
+	}, {
+		desc: "Value empty field",
+		input: &pb2.KnownTypes{
+			OptValue: &structpb.Value{},
+		},
+		wantErr: true,
+	}, {
+		desc:  "Value contains NullValue",
+		input: &structpb.Value{Kind: &structpb.Value_NullValue{}},
+		want:  `null`,
+	}, {
+		desc:  "Value contains BoolValue",
+		input: &structpb.Value{Kind: &structpb.Value_BoolValue{}},
+		want:  `false`,
+	}, {
+		desc:  "Value contains NumberValue",
+		input: &structpb.Value{Kind: &structpb.Value_NumberValue{1.02}},
+		want:  `1.02`,
+	}, {
+		desc:  "Value contains StringValue",
+		input: &structpb.Value{Kind: &structpb.Value_StringValue{"hello"}},
+		want:  `"hello"`,
+	}, {
+		desc:    "Value contains StringValue with invalid UTF8",
+		input:   &structpb.Value{Kind: &structpb.Value_StringValue{"\xff"}},
+		wantErr: true,
+	}, {
+		desc: "Value contains Struct",
+		input: &structpb.Value{
+			Kind: &structpb.Value_StructValue{
+				&structpb.Struct{
+					Fields: map[string]*structpb.Value{
+						"null":   {Kind: &structpb.Value_NullValue{}},
+						"number": {Kind: &structpb.Value_NumberValue{}},
+						"string": {Kind: &structpb.Value_StringValue{}},
+						"struct": {Kind: &structpb.Value_StructValue{}},
+						"list":   {Kind: &structpb.Value_ListValue{}},
+						"bool":   {Kind: &structpb.Value_BoolValue{}},
+					},
+				},
+			},
+		},
+		want: `{
+  "bool": false,
+  "list": [],
+  "null": null,
+  "number": 0,
+  "string": "",
+  "struct": {}
+}`,
+	}, {
+		desc: "Value contains ListValue",
+		input: &structpb.Value{
+			Kind: &structpb.Value_ListValue{
+				&structpb.ListValue{
+					Values: []*structpb.Value{
+						{Kind: &structpb.Value_BoolValue{}},
+						{Kind: &structpb.Value_NullValue{}},
+						{Kind: &structpb.Value_NumberValue{}},
+						{Kind: &structpb.Value_StringValue{}},
+						{Kind: &structpb.Value_StructValue{}},
+						{Kind: &structpb.Value_ListValue{}},
+					},
+				},
+			},
+		},
+		want: `[
+  false,
+  null,
+  0,
+  "",
+  {},
+  []
+]`,
+	}, {
+		desc:  "Struct with nil map",
+		input: &structpb.Struct{},
+		want:  `{}`,
+	}, {
+		desc: "Struct with empty map",
+		input: &structpb.Struct{
+			Fields: map[string]*structpb.Value{},
+		},
+		want: `{}`,
+	}, {
+		desc: "Struct",
+		input: &structpb.Struct{
+			Fields: map[string]*structpb.Value{
+				"bool":   {Kind: &structpb.Value_BoolValue{true}},
+				"null":   {Kind: &structpb.Value_NullValue{}},
+				"number": {Kind: &structpb.Value_NumberValue{3.1415}},
+				"string": {Kind: &structpb.Value_StringValue{"hello"}},
+				"struct": {
+					Kind: &structpb.Value_StructValue{
+						&structpb.Struct{
+							Fields: map[string]*structpb.Value{
+								"string": {Kind: &structpb.Value_StringValue{"world"}},
+							},
+						},
+					},
+				},
+				"list": {
+					Kind: &structpb.Value_ListValue{
+						&structpb.ListValue{
+							Values: []*structpb.Value{
+								{Kind: &structpb.Value_BoolValue{}},
+								{Kind: &structpb.Value_NullValue{}},
+								{Kind: &structpb.Value_NumberValue{}},
+							},
+						},
+					},
+				},
+			},
+		},
+		want: `{
+  "bool": true,
+  "list": [
+    false,
+    null,
+    0
+  ],
+  "null": null,
+  "number": 3.1415,
+  "string": "hello",
+  "struct": {
+    "string": "world"
+  }
+}`,
+	}, {
+		desc: "Struct message with invalid UTF8 string",
+		input: &structpb.Struct{
+			Fields: map[string]*structpb.Value{
+				"string": {Kind: &structpb.Value_StringValue{"\xff"}},
+			},
+		},
+		wantErr: true,
+	}, {
+		desc:  "ListValue with nil values",
+		input: &structpb.ListValue{},
+		want:  `[]`,
+	}, {
+		desc: "ListValue with empty values",
+		input: &structpb.ListValue{
+			Values: []*structpb.Value{},
+		},
+		want: `[]`,
+	}, {
+		desc: "ListValue",
+		input: &structpb.ListValue{
+			Values: []*structpb.Value{
+				{Kind: &structpb.Value_BoolValue{true}},
+				{Kind: &structpb.Value_NullValue{}},
+				{Kind: &structpb.Value_NumberValue{3.1415}},
+				{Kind: &structpb.Value_StringValue{"hello"}},
+				{
+					Kind: &structpb.Value_ListValue{
+						&structpb.ListValue{
+							Values: []*structpb.Value{
+								{Kind: &structpb.Value_BoolValue{}},
+								{Kind: &structpb.Value_NullValue{}},
+								{Kind: &structpb.Value_NumberValue{}},
+							},
+						},
+					},
+				},
+				{
+					Kind: &structpb.Value_StructValue{
+						&structpb.Struct{
+							Fields: map[string]*structpb.Value{
+								"string": {Kind: &structpb.Value_StringValue{"world"}},
+							},
+						},
+					},
+				},
+			},
+		},
+		want: `[
+  true,
+  null,
+  3.1415,
+  "hello",
+  [
+    false,
+    null,
+    0
+  ],
+  {
+    "string": "world"
+  }
+]`,
+	}, {
+		desc: "ListValue with invalid UTF8 string",
+		input: &structpb.ListValue{
+			Values: []*structpb.Value{
+				{Kind: &structpb.Value_StringValue{"\xff"}},
+			},
+		},
+		wantErr: true,
+	}, {
+		desc:  "Duration empty",
+		input: &durationpb.Duration{},
+		want:  `"0s"`,
+	}, {
+		desc:  "Duration with secs",
+		input: &durationpb.Duration{Seconds: 3},
+		want:  `"3s"`,
+	}, {
+		desc:  "Duration with -secs",
+		input: &durationpb.Duration{Seconds: -3},
+		want:  `"-3s"`,
+	}, {
+		desc:  "Duration with nanos",
+		input: &durationpb.Duration{Nanos: 1e6},
+		want:  `"0.001s"`,
+	}, {
+		desc:  "Duration with -nanos",
+		input: &durationpb.Duration{Nanos: -1e6},
+		want:  `"-0.001s"`,
+	}, {
+		desc:  "Duration with large secs",
+		input: &durationpb.Duration{Seconds: 1e10, Nanos: 1},
+		want:  `"10000000000.000000001s"`,
+	}, {
+		desc:  "Duration with 6-digit nanos",
+		input: &durationpb.Duration{Nanos: 1e4},
+		want:  `"0.000010s"`,
+	}, {
+		desc:  "Duration with 3-digit nanos",
+		input: &durationpb.Duration{Nanos: 1e6},
+		want:  `"0.001s"`,
+	}, {
+		desc:  "Duration with -secs -nanos",
+		input: &durationpb.Duration{Seconds: -123, Nanos: -450},
+		want:  `"-123.000000450s"`,
+	}, {
+		desc:  "Duration max value",
+		input: &durationpb.Duration{Seconds: 315576000000, Nanos: 999999999},
+		want:  `"315576000000.999999999s"`,
+	}, {
+		desc:  "Duration min value",
+		input: &durationpb.Duration{Seconds: -315576000000, Nanos: -999999999},
+		want:  `"-315576000000.999999999s"`,
+	}, {
+		desc:    "Duration with +secs -nanos",
+		input:   &durationpb.Duration{Seconds: 1, Nanos: -1},
+		wantErr: true,
+	}, {
+		desc:    "Duration with -secs +nanos",
+		input:   &durationpb.Duration{Seconds: -1, Nanos: 1},
+		wantErr: true,
+	}, {
+		desc:    "Duration with +secs out of range",
+		input:   &durationpb.Duration{Seconds: 315576000001},
+		wantErr: true,
+	}, {
+		desc:    "Duration with -secs out of range",
+		input:   &durationpb.Duration{Seconds: -315576000001},
+		wantErr: true,
+	}, {
+		desc:    "Duration with +nanos out of range",
+		input:   &durationpb.Duration{Seconds: 0, Nanos: 1e9},
+		wantErr: true,
+	}, {
+		desc:    "Duration with -nanos out of range",
+		input:   &durationpb.Duration{Seconds: 0, Nanos: -1e9},
+		wantErr: true,
+	}, {
+		desc:  "Timestamp zero",
+		input: &timestamppb.Timestamp{},
+		want:  `"1970-01-01T00:00:00Z"`,
+	}, {
+		desc:  "Timestamp",
+		input: &timestamppb.Timestamp{Seconds: 1553036601},
+		want:  `"2019-03-19T23:03:21Z"`,
+	}, {
+		desc:  "Timestamp with nanos",
+		input: &timestamppb.Timestamp{Seconds: 1553036601, Nanos: 1},
+		want:  `"2019-03-19T23:03:21.000000001Z"`,
+	}, {
+		desc:  "Timestamp with 6-digit nanos",
+		input: &timestamppb.Timestamp{Nanos: 1e3},
+		want:  `"1970-01-01T00:00:00.000001Z"`,
+	}, {
+		desc:  "Timestamp with 3-digit nanos",
+		input: &timestamppb.Timestamp{Nanos: 1e7},
+		want:  `"1970-01-01T00:00:00.010Z"`,
+	}, {
+		desc:  "Timestamp max value",
+		input: &timestamppb.Timestamp{Seconds: 253402300799, Nanos: 999999999},
+		want:  `"9999-12-31T23:59:59.999999999Z"`,
+	}, {
+		desc:  "Timestamp min value",
+		input: &timestamppb.Timestamp{Seconds: -62135596800},
+		want:  `"0001-01-01T00:00:00Z"`,
+	}, {
+		desc:    "Timestamp with +secs out of range",
+		input:   &timestamppb.Timestamp{Seconds: 253402300800},
+		wantErr: true,
+	}, {
+		desc:    "Timestamp with -secs out of range",
+		input:   &timestamppb.Timestamp{Seconds: -62135596801},
+		wantErr: true,
+	}, {
+		desc:    "Timestamp with -nanos",
+		input:   &timestamppb.Timestamp{Nanos: -1},
+		wantErr: true,
+	}, {
+		desc:    "Timestamp with +nanos out of range",
+		input:   &timestamppb.Timestamp{Nanos: 1e9},
+		wantErr: true,
+	}, {
+		desc:  "FieldMask empty",
+		input: &fieldmaskpb.FieldMask{},
+		want:  `""`,
+	}, {
+		desc: "FieldMask",
+		input: &fieldmaskpb.FieldMask{
+			Paths: []string{
+				"foo",
+				"foo_bar",
+				"foo.bar_qux",
+				"_foo",
+			},
+		},
+		want: `"foo,fooBar,foo.barQux,Foo"`,
+	}, {
+		desc: "FieldMask error 1",
+		input: &fieldmaskpb.FieldMask{
+			Paths: []string{"foo_"},
+		},
+		wantErr: true,
+	}, {
+		desc: "FieldMask error 2",
+		input: &fieldmaskpb.FieldMask{
+			Paths: []string{"foo__bar"},
+		},
+		wantErr: true,
+	}, {
+		desc:  "Any empty",
+		input: &anypb.Any{},
+		want:  `{}`,
+	}, {
+		desc: "Any with non-custom message",
+		input: func() proto.Message {
+			m := &pb2.Nested{
+				OptString: proto.String("embedded inside Any"),
+				OptNested: &pb2.Nested{
+					OptString: proto.String("inception"),
+				},
+			}
+			b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			return &anypb.Any{
+				TypeUrl: "foo/pb2.Nested",
+				Value:   b,
+			}
+		}(),
+		want: `{
+  "@type": "foo/pb2.Nested",
+  "optString": "embedded inside Any",
+  "optNested": {
+    "optString": "inception"
+  }
+}`,
+	}, {
+		desc:  "Any with empty embedded message",
+		input: &anypb.Any{TypeUrl: "foo/pb2.Nested"},
+		want: `{
+  "@type": "foo/pb2.Nested"
+}`,
+	}, {
+		desc:    "Any without registered type",
+		mo:      protojson.MarshalOptions{Resolver: new(preg.Types)},
+		input:   &anypb.Any{TypeUrl: "foo/pb2.Nested"},
+		wantErr: true,
+	}, {
+		desc: "Any with missing required",
+		input: func() proto.Message {
+			m := &pb2.PartialRequired{
+				OptString: proto.String("embedded inside Any"),
+			}
+			b, err := proto.MarshalOptions{
+				AllowPartial:  true,
+				Deterministic: true,
+			}.Marshal(m)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			return &anypb.Any{
+				TypeUrl: string(m.ProtoReflect().Descriptor().FullName()),
+				Value:   b,
+			}
+		}(),
+		want: `{
+  "@type": "pb2.PartialRequired",
+  "optString": "embedded inside Any"
+}`,
+	}, {
+		desc: "Any with partial required and AllowPartial",
+		mo: protojson.MarshalOptions{
+			AllowPartial: true,
+		},
+		input: func() proto.Message {
+			m := &pb2.PartialRequired{
+				OptString: proto.String("embedded inside Any"),
+			}
+			b, err := proto.MarshalOptions{
+				AllowPartial:  true,
+				Deterministic: true,
+			}.Marshal(m)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			return &anypb.Any{
+				TypeUrl: string(m.ProtoReflect().Descriptor().FullName()),
+				Value:   b,
+			}
+		}(),
+		want: `{
+  "@type": "pb2.PartialRequired",
+  "optString": "embedded inside Any"
+}`,
+	}, {
+		desc: "Any with invalid UTF8",
+		input: func() proto.Message {
+			m := &pb2.Nested{
+				OptString: proto.String("abc\xff"),
+			}
+			b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			return &anypb.Any{
+				TypeUrl: "foo/pb2.Nested",
+				Value:   b,
+			}
+		}(),
+		wantErr: true,
+	}, {
+		desc: "Any with invalid value",
+		input: &anypb.Any{
+			TypeUrl: "foo/pb2.Nested",
+			Value:   []byte("\x80"),
+		},
+		wantErr: true,
+	}, {
+		desc: "Any with BoolValue",
+		input: func() proto.Message {
+			m := &wrapperspb.BoolValue{Value: true}
+			b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			return &anypb.Any{
+				TypeUrl: "type.googleapis.com/google.protobuf.BoolValue",
+				Value:   b,
+			}
+		}(),
+		want: `{
+  "@type": "type.googleapis.com/google.protobuf.BoolValue",
+  "value": true
+}`,
+	}, {
+		desc: "Any with Empty",
+		input: func() proto.Message {
+			m := &emptypb.Empty{}
+			b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			return &anypb.Any{
+				TypeUrl: "type.googleapis.com/google.protobuf.Empty",
+				Value:   b,
+			}
+		}(),
+		want: `{
+  "@type": "type.googleapis.com/google.protobuf.Empty",
+  "value": {}
+}`,
+	}, {
+		desc: "Any with StringValue containing invalid UTF8",
+		input: func() proto.Message {
+			m := &wrapperspb.StringValue{Value: "abcd"}
+			b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			return &anypb.Any{
+				TypeUrl: "google.protobuf.StringValue",
+				Value:   bytes.Replace(b, []byte("abcd"), []byte("abc\xff"), -1),
+			}
+		}(),
+		wantErr: true,
+	}, {
+		desc: "Any with Int64Value",
+		input: func() proto.Message {
+			m := &wrapperspb.Int64Value{Value: 42}
+			b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			return &anypb.Any{
+				TypeUrl: "google.protobuf.Int64Value",
+				Value:   b,
+			}
+		}(),
+		want: `{
+  "@type": "google.protobuf.Int64Value",
+  "value": "42"
+}`,
+	}, {
+		desc: "Any with Duration",
+		input: func() proto.Message {
+			m := &durationpb.Duration{}
+			b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			return &anypb.Any{
+				TypeUrl: "type.googleapis.com/google.protobuf.Duration",
+				Value:   b,
+			}
+		}(),
+		want: `{
+  "@type": "type.googleapis.com/google.protobuf.Duration",
+  "value": "0s"
+}`,
+	}, {
+		desc: "Any with empty Value",
+		input: func() proto.Message {
+			m := &structpb.Value{}
+			b, err := proto.Marshal(m)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			return &anypb.Any{
+				TypeUrl: "type.googleapis.com/google.protobuf.Value",
+				Value:   b,
+			}
+		}(),
+		wantErr: true,
+	}, {
+		desc: "Any with Value of StringValue",
+		input: func() proto.Message {
+			m := &structpb.Value{Kind: &structpb.Value_StringValue{"abcd"}}
+			b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			return &anypb.Any{
+				TypeUrl: "type.googleapis.com/google.protobuf.Value",
+				Value:   bytes.Replace(b, []byte("abcd"), []byte("abc\xff"), -1),
+			}
+		}(),
+		wantErr: true,
+	}, {
+		desc: "Any with Value of NullValue",
+		input: func() proto.Message {
+			m := &structpb.Value{Kind: &structpb.Value_NullValue{}}
+			b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			return &anypb.Any{
+				TypeUrl: "type.googleapis.com/google.protobuf.Value",
+				Value:   b,
+			}
+		}(),
+		want: `{
+  "@type": "type.googleapis.com/google.protobuf.Value",
+  "value": null
+}`,
+	}, {
+		desc: "Any with Struct",
+		input: func() proto.Message {
+			m := &structpb.Struct{
+				Fields: map[string]*structpb.Value{
+					"bool":   {Kind: &structpb.Value_BoolValue{true}},
+					"null":   {Kind: &structpb.Value_NullValue{}},
+					"string": {Kind: &structpb.Value_StringValue{"hello"}},
+					"struct": {
+						Kind: &structpb.Value_StructValue{
+							&structpb.Struct{
+								Fields: map[string]*structpb.Value{
+									"string": {Kind: &structpb.Value_StringValue{"world"}},
+								},
+							},
+						},
+					},
+				},
+			}
+			b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			return &anypb.Any{
+				TypeUrl: "google.protobuf.Struct",
+				Value:   b,
+			}
+		}(),
+		want: `{
+  "@type": "google.protobuf.Struct",
+  "value": {
+    "bool": true,
+    "null": null,
+    "string": "hello",
+    "struct": {
+      "string": "world"
+    }
+  }
+}`,
+	}, {
+		desc: "Any with missing type_url",
+		input: func() proto.Message {
+			m := &wrapperspb.BoolValue{Value: true}
+			b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			return &anypb.Any{
+				Value: b,
+			}
+		}(),
+		wantErr: true,
+	}, {
+		desc: "well known types as field values",
+		input: &pb2.KnownTypes{
+			OptBool:      &wrapperspb.BoolValue{Value: false},
+			OptInt32:     &wrapperspb.Int32Value{Value: 42},
+			OptInt64:     &wrapperspb.Int64Value{Value: 42},
+			OptUint32:    &wrapperspb.UInt32Value{Value: 42},
+			OptUint64:    &wrapperspb.UInt64Value{Value: 42},
+			OptFloat:     &wrapperspb.FloatValue{Value: 1.23},
+			OptDouble:    &wrapperspb.DoubleValue{Value: 3.1415},
+			OptString:    &wrapperspb.StringValue{Value: "hello"},
+			OptBytes:     &wrapperspb.BytesValue{Value: []byte("hello")},
+			OptDuration:  &durationpb.Duration{Seconds: 123},
+			OptTimestamp: &timestamppb.Timestamp{Seconds: 1553036601},
+			OptStruct: &structpb.Struct{
+				Fields: map[string]*structpb.Value{
+					"string": {Kind: &structpb.Value_StringValue{"hello"}},
+				},
+			},
+			OptList: &structpb.ListValue{
+				Values: []*structpb.Value{
+					{Kind: &structpb.Value_NullValue{}},
+					{Kind: &structpb.Value_StringValue{}},
+					{Kind: &structpb.Value_StructValue{}},
+					{Kind: &structpb.Value_ListValue{}},
+				},
+			},
+			OptValue: &structpb.Value{
+				Kind: &structpb.Value_StringValue{"world"},
+			},
+			OptEmpty: &emptypb.Empty{},
+			OptAny: &anypb.Any{
+				TypeUrl: "google.protobuf.Empty",
+			},
+			OptFieldmask: &fieldmaskpb.FieldMask{
+				Paths: []string{"foo_bar", "bar_foo"},
+			},
+		},
+		want: `{
+  "optBool": false,
+  "optInt32": 42,
+  "optInt64": "42",
+  "optUint32": 42,
+  "optUint64": "42",
+  "optFloat": 1.23,
+  "optDouble": 3.1415,
+  "optString": "hello",
+  "optBytes": "aGVsbG8=",
+  "optDuration": "123s",
+  "optTimestamp": "2019-03-19T23:03:21Z",
+  "optStruct": {
+    "string": "hello"
+  },
+  "optList": [
+    null,
+    "",
+    {},
+    []
+  ],
+  "optValue": "world",
+  "optEmpty": {},
+  "optAny": {
+    "@type": "google.protobuf.Empty",
+    "value": {}
+  },
+  "optFieldmask": "fooBar,barFoo"
+}`,
+	}, {
+		desc:  "EmitUnpopulated: proto2 optional scalars",
+		mo:    protojson.MarshalOptions{EmitUnpopulated: true},
+		input: &pb2.Scalars{},
+		want: `{
+  "optBool": null,
+  "optInt32": null,
+  "optInt64": null,
+  "optUint32": null,
+  "optUint64": null,
+  "optSint32": null,
+  "optSint64": null,
+  "optFixed32": null,
+  "optFixed64": null,
+  "optSfixed32": null,
+  "optSfixed64": null,
+  "optFloat": null,
+  "optDouble": null,
+  "optBytes": null,
+  "optString": null
+}`,
+	}, {
+		desc:  "EmitUnpopulated: proto3 scalars",
+		mo:    protojson.MarshalOptions{EmitUnpopulated: true},
+		input: &pb3.Scalars{},
+		want: `{
+  "sBool": false,
+  "sInt32": 0,
+  "sInt64": "0",
+  "sUint32": 0,
+  "sUint64": "0",
+  "sSint32": 0,
+  "sSint64": "0",
+  "sFixed32": 0,
+  "sFixed64": "0",
+  "sSfixed32": 0,
+  "sSfixed64": "0",
+  "sFloat": 0,
+  "sDouble": 0,
+  "sBytes": "",
+  "sString": ""
+}`,
+	}, {
+		desc:  "EmitUnpopulated: proto2 enum",
+		mo:    protojson.MarshalOptions{EmitUnpopulated: true},
+		input: &pb2.Enums{},
+		want: `{
+  "optEnum": null,
+  "rptEnum": [],
+  "optNestedEnum": null,
+  "rptNestedEnum": []
+}`,
+	}, {
+		desc:  "EmitUnpopulated: proto3 enum",
+		mo:    protojson.MarshalOptions{EmitUnpopulated: true},
+		input: &pb3.Enums{},
+		want: `{
+  "sEnum": "ZERO",
+  "sNestedEnum": "CERO"
+}`,
+	}, {
+		desc:  "EmitUnpopulated: proto2 message and group fields",
+		mo:    protojson.MarshalOptions{EmitUnpopulated: true},
+		input: &pb2.Nests{},
+		want: `{
+  "optNested": null,
+  "optgroup": null,
+  "rptNested": [],
+  "rptgroup": []
+}`,
+	}, {
+		desc:  "EmitUnpopulated: proto3 message field",
+		mo:    protojson.MarshalOptions{EmitUnpopulated: true},
+		input: &pb3.Nests{},
+		want: `{
+  "sNested": null
+}`,
+	}, {
+		desc: "EmitUnpopulated: proto2 empty message and group fields",
+		mo:   protojson.MarshalOptions{EmitUnpopulated: true},
+		input: &pb2.Nests{
+			OptNested: &pb2.Nested{},
+			Optgroup:  &pb2.Nests_OptGroup{},
+		},
+		want: `{
+  "optNested": {
+    "optString": null,
+    "optNested": null
+  },
+  "optgroup": {
+    "optString": null,
+    "optNested": null,
+    "optnestedgroup": null
+  },
+  "rptNested": [],
+  "rptgroup": []
+}`,
+	}, {
+		desc: "EmitUnpopulated: proto3 empty message field",
+		mo:   protojson.MarshalOptions{EmitUnpopulated: true},
+		input: &pb3.Nests{
+			SNested: &pb3.Nested{},
+		},
+		want: `{
+  "sNested": {
+    "sString": "",
+    "sNested": null
+  }
+}`,
+	}, {
+		desc: "EmitUnpopulated: proto2 required fields",
+		mo: protojson.MarshalOptions{
+			AllowPartial:    true,
+			EmitUnpopulated: true,
+		},
+		input: &pb2.Requireds{},
+		want: `{
+  "reqBool": null,
+  "reqSfixed64": null,
+  "reqDouble": null,
+  "reqString": null,
+  "reqEnum": null,
+  "reqNested": null
+}`,
+	}, {
+		desc:  "EmitUnpopulated: repeated fields",
+		mo:    protojson.MarshalOptions{EmitUnpopulated: true},
+		input: &pb2.Repeats{},
+		want: `{
+  "rptBool": [],
+  "rptInt32": [],
+  "rptInt64": [],
+  "rptUint32": [],
+  "rptUint64": [],
+  "rptFloat": [],
+  "rptDouble": [],
+  "rptString": [],
+  "rptBytes": []
+}`,
+	}, {
+		desc: "EmitUnpopulated: repeated containing empty message",
+		mo:   protojson.MarshalOptions{EmitUnpopulated: true},
+		input: &pb2.Nests{
+			RptNested: []*pb2.Nested{nil, {}},
+		},
+		want: `{
+  "optNested": null,
+  "optgroup": null,
+  "rptNested": [
+    {
+      "optString": null,
+      "optNested": null
+    },
+    {
+      "optString": null,
+      "optNested": null
+    }
+  ],
+  "rptgroup": []
+}`,
+	}, {
+		desc:  "EmitUnpopulated: map fields",
+		mo:    protojson.MarshalOptions{EmitUnpopulated: true},
+		input: &pb3.Maps{},
+		want: `{
+  "int32ToStr": {},
+  "boolToUint32": {},
+  "uint64ToEnum": {},
+  "strToNested": {},
+  "strToOneofs": {}
+}`,
+	}, {
+		desc: "EmitUnpopulated: map containing empty message",
+		mo:   protojson.MarshalOptions{EmitUnpopulated: true},
+		input: &pb3.Maps{
+			StrToNested: map[string]*pb3.Nested{
+				"nested": &pb3.Nested{},
+			},
+			StrToOneofs: map[string]*pb3.Oneofs{
+				"nested": &pb3.Oneofs{},
+			},
+		},
+		want: `{
+  "int32ToStr": {},
+  "boolToUint32": {},
+  "uint64ToEnum": {},
+  "strToNested": {
+    "nested": {
+      "sString": "",
+      "sNested": null
+    }
+  },
+  "strToOneofs": {
+    "nested": {}
+  }
+}`,
+	}, {
+		desc:  "EmitUnpopulated: oneof fields",
+		mo:    protojson.MarshalOptions{EmitUnpopulated: true},
+		input: &pb3.Oneofs{},
+		want:  `{}`,
+	}, {
+		desc: "EmitUnpopulated: extensions",
+		mo:   protojson.MarshalOptions{EmitUnpopulated: true},
+		input: func() proto.Message {
+			m := &pb2.Extensions{}
+			proto.SetExtension(m, pb2.E_OptExtNested, &pb2.Nested{})
+			proto.SetExtension(m, pb2.E_RptExtNested, []*pb2.Nested{
+				nil,
+				{},
+			})
+			return m
+		}(),
+		want: `{
+  "optString": null,
+  "optBool": null,
+  "optInt32": null,
+  "[pb2.opt_ext_nested]": {
+    "optString": null,
+    "optNested": null
+  },
+  "[pb2.rpt_ext_nested]": [
+    {
+      "optString": null,
+      "optNested": null
+    },
+    {
+      "optString": null,
+      "optNested": null
+    }
+  ]
+}`,
+	}, {
+		desc: "UseEnumNumbers in singular field",
+		mo:   protojson.MarshalOptions{UseEnumNumbers: true},
+		input: &pb2.Enums{
+			OptEnum:       pb2.Enum_ONE.Enum(),
+			OptNestedEnum: pb2.Enums_UNO.Enum(),
+		},
+		want: `{
+  "optEnum": 1,
+  "optNestedEnum": 1
+}`,
+	}, {
+		desc: "UseEnumNumbers in repeated field",
+		mo:   protojson.MarshalOptions{UseEnumNumbers: true},
+		input: &pb2.Enums{
+			RptEnum:       []pb2.Enum{pb2.Enum_ONE, 2, pb2.Enum_TEN, 42},
+			RptNestedEnum: []pb2.Enums_NestedEnum{pb2.Enums_UNO, pb2.Enums_DOS, 47},
+		},
+		want: `{
+  "rptEnum": [
+    1,
+    2,
+    10,
+    42
+  ],
+  "rptNestedEnum": [
+    1,
+    2,
+    47
+  ]
+}`,
+	}, {
+		desc: "UseEnumNumbers in map field",
+		mo:   protojson.MarshalOptions{UseEnumNumbers: true},
+		input: &pb3.Maps{
+			Uint64ToEnum: map[uint64]pb3.Enum{
+				1:  pb3.Enum_ONE,
+				2:  pb3.Enum_TWO,
+				10: pb3.Enum_TEN,
+				47: 47,
+			},
+		},
+		want: `{
+  "uint64ToEnum": {
+    "1": 1,
+    "2": 2,
+    "10": 10,
+    "47": 47
+  }
+}`,
+	}, {
+		desc: "UseProtoNames",
+		mo:   protojson.MarshalOptions{UseProtoNames: true},
+		input: &pb2.Nests{
+			OptNested: &pb2.Nested{},
+			Optgroup: &pb2.Nests_OptGroup{
+				OptString: proto.String("inside a group"),
+				OptNested: &pb2.Nested{
+					OptString: proto.String("nested message inside a group"),
+				},
+				Optnestedgroup: &pb2.Nests_OptGroup_OptNestedGroup{
+					OptFixed32: proto.Uint32(47),
+				},
+			},
+			Rptgroup: []*pb2.Nests_RptGroup{
+				{
+					RptString: []string{"hello", "world"},
+				},
+			},
+		},
+		want: `{
+  "opt_nested": {},
+  "OptGroup": {
+    "opt_string": "inside a group",
+    "opt_nested": {
+      "opt_string": "nested message inside a group"
+    },
+    "OptNestedGroup": {
+      "opt_fixed32": 47
+    }
+  },
+  "RptGroup": [
+    {
+      "rpt_string": [
+        "hello",
+        "world"
+      ]
+    }
+  ]
+}`,
+	}}
+
+	for _, tt := range tests {
+		tt := tt
+		if tt.skip {
+			continue
+		}
+		t.Run(tt.desc, func(t *testing.T) {
+			// Use 2-space indentation on all MarshalOptions.
+			tt.mo.Indent = "  "
+			b, err := tt.mo.Marshal(tt.input)
+			if err != nil && !tt.wantErr {
+				t.Errorf("Marshal() returned error: %v\n", err)
+			}
+			if err == nil && tt.wantErr {
+				t.Errorf("Marshal() got nil error, want error\n")
+			}
+			got := string(b)
+			if got != tt.want {
+				t.Errorf("Marshal()\n<got>\n%v\n<want>\n%v\n", got, tt.want)
+				if diff := cmp.Diff(tt.want, got); diff != "" {
+					t.Errorf("Marshal() diff -want +got\n%v\n", diff)
+				}
+			}
+		})
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/encoding/protojson/well_known_types.go b/vendor/google.golang.org/protobuf/encoding/protojson/well_known_types.go
new file mode 100644
index 000000000..3c3ef14da
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/encoding/protojson/well_known_types.go
@@ -0,0 +1,903 @@
+// Copyright 2019 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 protojson
+
+import (
+	"bytes"
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+
+	"google.golang.org/protobuf/internal/detectknown"
+	"google.golang.org/protobuf/internal/encoding/json"
+	"google.golang.org/protobuf/internal/errors"
+	"google.golang.org/protobuf/internal/fieldnum"
+	"google.golang.org/protobuf/internal/strs"
+	"google.golang.org/protobuf/proto"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+)
+
+// isCustomType returns true if type name has special JSON conversion rules.
+// The list of custom types here has to match the ones in marshalCustomType and
+// unmarshalCustomType.
+func isCustomType(name pref.FullName) bool {
+	switch detectknown.Which(name) {
+	case detectknown.AnyProto:
+	case detectknown.TimestampProto:
+	case detectknown.DurationProto:
+	case detectknown.WrappersProto:
+	case detectknown.StructProto:
+	case detectknown.FieldMaskProto:
+	case detectknown.EmptyProto:
+	default:
+		return false
+	}
+	return true
+}
+
+// marshalCustomType marshals given well-known type message that have special
+// JSON conversion rules. It needs to be a message type where isCustomType
+// returns true, else it will panic.
+func (e encoder) marshalCustomType(m pref.Message) error {
+	name := m.Descriptor().FullName()
+	switch detectknown.Which(name) {
+	case detectknown.AnyProto:
+		return e.marshalAny(m)
+	case detectknown.TimestampProto:
+		return e.marshalTimestamp(m)
+	case detectknown.DurationProto:
+		return e.marshalDuration(m)
+	case detectknown.WrappersProto:
+		return e.marshalWrapperType(m)
+	case detectknown.StructProto:
+		return e.marshalStructType(m)
+	case detectknown.FieldMaskProto:
+		return e.marshalFieldMask(m)
+	case detectknown.EmptyProto:
+		return e.marshalEmpty(m)
+	default:
+		panic(fmt.Sprintf("%s does not have a custom marshaler", name))
+	}
+}
+
+// unmarshalCustomType unmarshals given well-known type message that have
+// special JSON conversion rules. It needs to be a message type where
+// isCustomType returns true, else it will panic.
+func (d decoder) unmarshalCustomType(m pref.Message) error {
+	name := m.Descriptor().FullName()
+	switch detectknown.Which(name) {
+	case detectknown.AnyProto:
+		return d.unmarshalAny(m)
+	case detectknown.TimestampProto:
+		return d.unmarshalTimestamp(m)
+	case detectknown.DurationProto:
+		return d.unmarshalDuration(m)
+	case detectknown.WrappersProto:
+		return d.unmarshalWrapperType(m)
+	case detectknown.StructProto:
+		return d.unmarshalStructType(m)
+	case detectknown.FieldMaskProto:
+		return d.unmarshalFieldMask(m)
+	case detectknown.EmptyProto:
+		return d.unmarshalEmpty(m)
+	default:
+		panic(fmt.Sprintf("%s does not have a custom unmarshaler", name))
+	}
+}
+
+// The JSON representation of an Any message uses the regular representation of
+// the deserialized, embedded message, with an additional field `@type` which
+// contains the type URL. If the embedded message type is well-known and has a
+// custom JSON representation, that representation will be embedded adding a
+// field `value` which holds the custom JSON in addition to the `@type` field.
+
+func (e encoder) marshalAny(m pref.Message) error {
+	fds := m.Descriptor().Fields()
+	fdType := fds.ByNumber(fieldnum.Any_TypeUrl)
+	fdValue := fds.ByNumber(fieldnum.Any_Value)
+
+	// Start writing the JSON object.
+	e.StartObject()
+	defer e.EndObject()
+
+	if !m.Has(fdType) {
+		if !m.Has(fdValue) {
+			// If message is empty, marshal out empty JSON object.
+			return nil
+		} else {
+			// Return error if type_url field is not set, but value is set.
+			return errors.New("%s: type_url is not set", m.Descriptor().FullName())
+		}
+	}
+
+	typeVal := m.Get(fdType)
+	valueVal := m.Get(fdValue)
+
+	// Marshal out @type field.
+	typeURL := typeVal.String()
+	e.WriteName("@type")
+	if err := e.WriteString(typeURL); err != nil {
+		return err
+	}
+
+	// Resolve the type in order to unmarshal value field.
+	emt, err := e.opts.Resolver.FindMessageByURL(typeURL)
+	if err != nil {
+		return errors.New("%s: unable to resolve %q: %v", m.Descriptor().FullName(), typeURL, err)
+	}
+
+	em := emt.New()
+	err = proto.UnmarshalOptions{
+		AllowPartial: true, // never check required fields inside an Any
+		Resolver:     e.opts.Resolver,
+	}.Unmarshal(valueVal.Bytes(), em.Interface())
+	if err != nil {
+		return errors.New("%s: unable to unmarshal %q: %v", m.Descriptor().FullName(), typeURL, err)
+	}
+
+	// If type of value has custom JSON encoding, marshal out a field "value"
+	// with corresponding custom JSON encoding of the embedded message as a
+	// field.
+	if isCustomType(emt.Descriptor().FullName()) {
+		e.WriteName("value")
+		return e.marshalCustomType(em)
+	}
+
+	// Else, marshal out the embedded message's fields in this Any object.
+	if err := e.marshalFields(em); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (d decoder) unmarshalAny(m pref.Message) error {
+	// Peek to check for json.ObjectOpen to avoid advancing a read.
+	start, err := d.Peek()
+	if err != nil {
+		return err
+	}
+	if start.Kind() != json.ObjectOpen {
+		return d.unexpectedTokenError(start)
+	}
+
+	// Use another decoder to parse the unread bytes for @type field. This
+	// avoids advancing a read from current decoder because the current JSON
+	// object may contain the fields of the embedded type.
+	dec := decoder{d.Clone(), UnmarshalOptions{}}
+	tok, err := findTypeURL(dec)
+	switch err {
+	case errEmptyObject:
+		// An empty JSON object translates to an empty Any message.
+		d.Read() // Read json.ObjectOpen.
+		d.Read() // Read json.ObjectClose.
+		return nil
+
+	case errMissingType:
+		if d.opts.DiscardUnknown {
+			// Treat all fields as unknowns, similar to an empty object.
+			return d.skipJSONValue()
+		}
+		// Use start.Pos() for line position.
+		return d.newError(start.Pos(), err.Error())
+
+	default:
+		if err != nil {
+			return err
+		}
+	}
+
+	typeURL := tok.ParsedString()
+	emt, err := d.opts.Resolver.FindMessageByURL(typeURL)
+	if err != nil {
+		return d.newError(tok.Pos(), "unable to resolve %v: %q", tok.RawString(), err)
+	}
+
+	// Create new message for the embedded message type and unmarshal into it.
+	em := emt.New()
+	if isCustomType(emt.Descriptor().FullName()) {
+		// If embedded message is a custom type,
+		// unmarshal the JSON "value" field into it.
+		if err := d.unmarshalAnyValue(em); err != nil {
+			return err
+		}
+	} else {
+		// Else unmarshal the current JSON object into it.
+		if err := d.unmarshalMessage(em, true); err != nil {
+			return err
+		}
+	}
+	// Serialize the embedded message and assign the resulting bytes to the
+	// proto value field.
+	b, err := proto.MarshalOptions{
+		AllowPartial:  true, // No need to check required fields inside an Any.
+		Deterministic: true,
+	}.Marshal(em.Interface())
+	if err != nil {
+		return d.newError(start.Pos(), "error in marshaling Any.value field: %v", err)
+	}
+
+	fds := m.Descriptor().Fields()
+	fdType := fds.ByNumber(fieldnum.Any_TypeUrl)
+	fdValue := fds.ByNumber(fieldnum.Any_Value)
+
+	m.Set(fdType, pref.ValueOfString(typeURL))
+	m.Set(fdValue, pref.ValueOfBytes(b))
+	return nil
+}
+
+var errEmptyObject = fmt.Errorf(`empty object`)
+var errMissingType = fmt.Errorf(`missing "@type" field`)
+
+// findTypeURL returns the token for the "@type" field value from the given
+// JSON bytes. It is expected that the given bytes start with json.ObjectOpen.
+// It returns errEmptyObject if the JSON object is empty or errMissingType if
+// @type field does not exist. It returns other error if the @type field is not
+// valid or other decoding issues.
+func findTypeURL(d decoder) (json.Token, error) {
+	var typeURL string
+	var typeTok json.Token
+	numFields := 0
+	// Skip start object.
+	d.Read()
+
+Loop:
+	for {
+		tok, err := d.Read()
+		if err != nil {
+			return json.Token{}, err
+		}
+
+		switch tok.Kind() {
+		case json.ObjectClose:
+			if typeURL == "" {
+				// Did not find @type field.
+				if numFields > 0 {
+					return json.Token{}, errMissingType
+				}
+				return json.Token{}, errEmptyObject
+			}
+			break Loop
+
+		case json.Name:
+			numFields++
+			if tok.Name() != "@type" {
+				// Skip value.
+				if err := d.skipJSONValue(); err != nil {
+					return json.Token{}, err
+				}
+				continue
+			}
+
+			// Return error if this was previously set already.
+			if typeURL != "" {
+				return json.Token{}, d.newError(tok.Pos(), `duplicate "@type" field`)
+			}
+			// Read field value.
+			tok, err := d.Read()
+			if err != nil {
+				return json.Token{}, err
+			}
+			if tok.Kind() != json.String {
+				return json.Token{}, d.newError(tok.Pos(), `@type field value is not a string: %v`, tok.RawString())
+			}
+			typeURL = tok.ParsedString()
+			if typeURL == "" {
+				return json.Token{}, d.newError(tok.Pos(), `@type field contains empty value`)
+			}
+			typeTok = tok
+		}
+	}
+
+	return typeTok, nil
+}
+
+// skipJSONValue parses a JSON value (null, boolean, string, number, object and
+// array) in order to advance the read to the next JSON value. It relies on
+// the decoder returning an error if the types are not in valid sequence.
+func (d decoder) skipJSONValue() error {
+	tok, err := d.Read()
+	if err != nil {
+		return err
+	}
+	// Only need to continue reading for objects and arrays.
+	switch tok.Kind() {
+	case json.ObjectOpen:
+		for {
+			tok, err := d.Read()
+			if err != nil {
+				return err
+			}
+			switch tok.Kind() {
+			case json.ObjectClose:
+				return nil
+			case json.Name:
+				// Skip object field value.
+				if err := d.skipJSONValue(); err != nil {
+					return err
+				}
+			}
+		}
+
+	case json.ArrayOpen:
+		for {
+			tok, err := d.Peek()
+			if err != nil {
+				return err
+			}
+			switch tok.Kind() {
+			case json.ArrayClose:
+				d.Read()
+				return nil
+			default:
+				// Skip array item.
+				if err := d.skipJSONValue(); err != nil {
+					return err
+				}
+			}
+		}
+	}
+	return nil
+}
+
+// unmarshalAnyValue unmarshals the given custom-type message from the JSON
+// object's "value" field.
+func (d decoder) unmarshalAnyValue(m pref.Message) error {
+	// Skip ObjectOpen, and start reading the fields.
+	d.Read()
+
+	var found bool // Used for detecting duplicate "value".
+	for {
+		tok, err := d.Read()
+		if err != nil {
+			return err
+		}
+		switch tok.Kind() {
+		case json.ObjectClose:
+			if !found {
+				return d.newError(tok.Pos(), `missing "value" field`)
+			}
+			return nil
+
+		case json.Name:
+			switch tok.Name() {
+			case "@type":
+				// Skip the value as this was previously parsed already.
+				d.Read()
+
+			case "value":
+				if found {
+					return d.newError(tok.Pos(), `duplicate "value" field`)
+				}
+				// Unmarshal the field value into the given message.
+				if err := d.unmarshalCustomType(m); err != nil {
+					return err
+				}
+				found = true
+
+			default:
+				if d.opts.DiscardUnknown {
+					if err := d.skipJSONValue(); err != nil {
+						return err
+					}
+					continue
+				}
+				return d.newError(tok.Pos(), "unknown field %v", tok.RawString())
+			}
+		}
+	}
+}
+
+// Wrapper types are encoded as JSON primitives like string, number or boolean.
+
+// The "value" field has the same field number for all wrapper types.
+const wrapperFieldNumber = fieldnum.BoolValue_Value
+
+func (e encoder) marshalWrapperType(m pref.Message) error {
+	fd := m.Descriptor().Fields().ByNumber(wrapperFieldNumber)
+	val := m.Get(fd)
+	return e.marshalSingular(val, fd)
+}
+
+func (d decoder) unmarshalWrapperType(m pref.Message) error {
+	fd := m.Descriptor().Fields().ByNumber(wrapperFieldNumber)
+	val, err := d.unmarshalScalar(fd)
+	if err != nil {
+		return err
+	}
+	m.Set(fd, val)
+	return nil
+}
+
+// The JSON representation for Empty is an empty JSON object.
+
+func (e encoder) marshalEmpty(pref.Message) error {
+	e.StartObject()
+	e.EndObject()
+	return nil
+}
+
+func (d decoder) unmarshalEmpty(pref.Message) error {
+	tok, err := d.Read()
+	if err != nil {
+		return err
+	}
+	if tok.Kind() != json.ObjectOpen {
+		return d.unexpectedTokenError(tok)
+	}
+
+	for {
+		tok, err := d.Read()
+		if err != nil {
+			return err
+		}
+		switch tok.Kind() {
+		case json.ObjectClose:
+			return nil
+
+		case json.Name:
+			if d.opts.DiscardUnknown {
+				if err := d.skipJSONValue(); err != nil {
+					return err
+				}
+				continue
+			}
+			return d.newError(tok.Pos(), "unknown field %v", tok.RawString())
+
+		default:
+			return d.unexpectedTokenError(tok)
+		}
+	}
+}
+
+func (e encoder) marshalStructType(m pref.Message) error {
+	switch m.Descriptor().Name() {
+	case "Struct":
+		return e.marshalStruct(m)
+	case "ListValue":
+		return e.marshalListValue(m)
+	case "Value":
+		return e.marshalKnownValue(m)
+	default:
+		panic(fmt.Sprintf("invalid struct type: %v", m.Descriptor().FullName()))
+	}
+}
+
+func (d decoder) unmarshalStructType(m pref.Message) error {
+	switch m.Descriptor().Name() {
+	case "Struct":
+		return d.unmarshalStruct(m)
+	case "ListValue":
+		return d.unmarshalListValue(m)
+	case "Value":
+		return d.unmarshalKnownValue(m)
+	default:
+		panic(fmt.Sprintf("invalid struct type: %v", m.Descriptor().FullName()))
+	}
+}
+
+// The JSON representation for Struct is a JSON object that contains the encoded
+// Struct.fields map and follows the serialization rules for a map.
+
+func (e encoder) marshalStruct(m pref.Message) error {
+	fd := m.Descriptor().Fields().ByNumber(fieldnum.Struct_Fields)
+	return e.marshalMap(m.Get(fd).Map(), fd)
+}
+
+func (d decoder) unmarshalStruct(m pref.Message) error {
+	fd := m.Descriptor().Fields().ByNumber(fieldnum.Struct_Fields)
+	return d.unmarshalMap(m.Mutable(fd).Map(), fd)
+}
+
+// The JSON representation for ListValue is JSON array that contains the encoded
+// ListValue.values repeated field and follows the serialization rules for a
+// repeated field.
+
+func (e encoder) marshalListValue(m pref.Message) error {
+	fd := m.Descriptor().Fields().ByNumber(fieldnum.ListValue_Values)
+	return e.marshalList(m.Get(fd).List(), fd)
+}
+
+func (d decoder) unmarshalListValue(m pref.Message) error {
+	fd := m.Descriptor().Fields().ByNumber(fieldnum.ListValue_Values)
+	return d.unmarshalList(m.Mutable(fd).List(), fd)
+}
+
+// The JSON representation for a Value is dependent on the oneof field that is
+// set. Each of the field in the oneof has its own custom serialization rule. A
+// Value message needs to be a oneof field set, else it is an error.
+
+func (e encoder) marshalKnownValue(m pref.Message) error {
+	od := m.Descriptor().Oneofs().ByName("kind")
+	fd := m.WhichOneof(od)
+	if fd == nil {
+		return errors.New("%s: none of the oneof fields is set", m.Descriptor().FullName())
+	}
+	return e.marshalSingular(m.Get(fd), fd)
+}
+
+func (d decoder) unmarshalKnownValue(m pref.Message) error {
+	tok, err := d.Peek()
+	if err != nil {
+		return err
+	}
+
+	var fd pref.FieldDescriptor
+	var val pref.Value
+	switch tok.Kind() {
+	case json.Null:
+		d.Read()
+		fd = m.Descriptor().Fields().ByNumber(fieldnum.Value_NullValue)
+		val = pref.ValueOfEnum(0)
+
+	case json.Bool:
+		tok, err := d.Read()
+		if err != nil {
+			return err
+		}
+		fd = m.Descriptor().Fields().ByNumber(fieldnum.Value_BoolValue)
+		val = pref.ValueOfBool(tok.Bool())
+
+	case json.Number:
+		tok, err := d.Read()
+		if err != nil {
+			return err
+		}
+		fd = m.Descriptor().Fields().ByNumber(fieldnum.Value_NumberValue)
+		var ok bool
+		val, ok = unmarshalFloat(tok, 64)
+		if !ok {
+			return d.newError(tok.Pos(), "invalid google.protobuf.Value: %v", tok.RawString())
+		}
+
+	case json.String:
+		// A JSON string may have been encoded from the number_value field,
+		// e.g. "NaN", "Infinity", etc. Parsing a proto double type also allows
+		// for it to be in JSON string form. Given this custom encoding spec,
+		// however, there is no way to identify that and hence a JSON string is
+		// always assigned to the string_value field, which means that certain
+		// encoding cannot be parsed back to the same field.
+		tok, err := d.Read()
+		if err != nil {
+			return err
+		}
+		fd = m.Descriptor().Fields().ByNumber(fieldnum.Value_StringValue)
+		val = pref.ValueOfString(tok.ParsedString())
+
+	case json.ObjectOpen:
+		fd = m.Descriptor().Fields().ByNumber(fieldnum.Value_StructValue)
+		val = m.NewField(fd)
+		if err := d.unmarshalStruct(val.Message()); err != nil {
+			return err
+		}
+
+	case json.ArrayOpen:
+		fd = m.Descriptor().Fields().ByNumber(fieldnum.Value_ListValue)
+		val = m.NewField(fd)
+		if err := d.unmarshalListValue(val.Message()); err != nil {
+			return err
+		}
+
+	default:
+		return d.newError(tok.Pos(), "invalid google.protobuf.Value: %v", tok.RawString())
+	}
+
+	m.Set(fd, val)
+	return nil
+}
+
+// The JSON representation for a Duration is a JSON string that ends in the
+// suffix "s" (indicating seconds) and is preceded by the number of seconds,
+// with nanoseconds expressed as fractional seconds.
+//
+// Durations less than one second are represented with a 0 seconds field and a
+// positive or negative nanos field. For durations of one second or more, a
+// non-zero value for the nanos field must be of the same sign as the seconds
+// field.
+//
+// Duration.seconds must be from -315,576,000,000 to +315,576,000,000 inclusive.
+// Duration.nanos must be from -999,999,999 to +999,999,999 inclusive.
+
+const (
+	secondsInNanos       = 999999999
+	maxSecondsInDuration = 315576000000
+)
+
+func (e encoder) marshalDuration(m pref.Message) error {
+	fds := m.Descriptor().Fields()
+	fdSeconds := fds.ByNumber(fieldnum.Duration_Seconds)
+	fdNanos := fds.ByNumber(fieldnum.Duration_Nanos)
+
+	secsVal := m.Get(fdSeconds)
+	nanosVal := m.Get(fdNanos)
+	secs := secsVal.Int()
+	nanos := nanosVal.Int()
+	if secs < -maxSecondsInDuration || secs > maxSecondsInDuration {
+		return errors.New("%s: seconds out of range %v", m.Descriptor().FullName(), secs)
+	}
+	if nanos < -secondsInNanos || nanos > secondsInNanos {
+		return errors.New("%s: nanos out of range %v", m.Descriptor().FullName(), nanos)
+	}
+	if (secs > 0 && nanos < 0) || (secs < 0 && nanos > 0) {
+		return errors.New("%s: signs of seconds and nanos do not match", m.Descriptor().FullName())
+	}
+	// Generated output always contains 0, 3, 6, or 9 fractional digits,
+	// depending on required precision, followed by the suffix "s".
+	f := "%d.%09d"
+	if nanos < 0 {
+		nanos = -nanos
+		if secs == 0 {
+			f = "-%d.%09d"
+		}
+	}
+	x := fmt.Sprintf(f, secs, nanos)
+	x = strings.TrimSuffix(x, "000")
+	x = strings.TrimSuffix(x, "000")
+	x = strings.TrimSuffix(x, ".000")
+	e.WriteString(x + "s")
+	return nil
+}
+
+func (d decoder) unmarshalDuration(m pref.Message) error {
+	tok, err := d.Read()
+	if err != nil {
+		return err
+	}
+	if tok.Kind() != json.String {
+		return d.unexpectedTokenError(tok)
+	}
+
+	secs, nanos, ok := parseDuration(tok.ParsedString())
+	if !ok {
+		return d.newError(tok.Pos(), "invalid google.protobuf.Duration value %v", tok.RawString())
+	}
+	// Validate seconds. No need to validate nanos because parseDuration would
+	// have covered that already.
+	if secs < -maxSecondsInDuration || secs > maxSecondsInDuration {
+		return d.newError(tok.Pos(), "google.protobuf.Duration value out of range: %v", tok.RawString())
+	}
+
+	fds := m.Descriptor().Fields()
+	fdSeconds := fds.ByNumber(fieldnum.Duration_Seconds)
+	fdNanos := fds.ByNumber(fieldnum.Duration_Nanos)
+
+	m.Set(fdSeconds, pref.ValueOfInt64(secs))
+	m.Set(fdNanos, pref.ValueOfInt32(nanos))
+	return nil
+}
+
+// parseDuration parses the given input string for seconds and nanoseconds value
+// for the Duration JSON format. The format is a decimal number with a suffix
+// 's'. It can have optional plus/minus sign. There needs to be at least an
+// integer or fractional part. Fractional part is limited to 9 digits only for
+// nanoseconds precision, regardless of whether there are trailing zero digits.
+// Example values are 1s, 0.1s, 1.s, .1s, +1s, -1s, -.1s.
+func parseDuration(input string) (int64, int32, bool) {
+	b := []byte(input)
+	size := len(b)
+	if size < 2 {
+		return 0, 0, false
+	}
+	if b[size-1] != 's' {
+		return 0, 0, false
+	}
+	b = b[:size-1]
+
+	// Read optional plus/minus symbol.
+	var neg bool
+	switch b[0] {
+	case '-':
+		neg = true
+		b = b[1:]
+	case '+':
+		b = b[1:]
+	}
+	if len(b) == 0 {
+		return 0, 0, false
+	}
+
+	// Read the integer part.
+	var intp []byte
+	switch {
+	case b[0] == '0':
+		b = b[1:]
+
+	case '1' <= b[0] && b[0] <= '9':
+		intp = b[0:]
+		b = b[1:]
+		n := 1
+		for len(b) > 0 && '0' <= b[0] && b[0] <= '9' {
+			n++
+			b = b[1:]
+		}
+		intp = intp[:n]
+
+	case b[0] == '.':
+		// Continue below.
+
+	default:
+		return 0, 0, false
+	}
+
+	hasFrac := false
+	var frac [9]byte
+	if len(b) > 0 {
+		if b[0] != '.' {
+			return 0, 0, false
+		}
+		// Read the fractional part.
+		b = b[1:]
+		n := 0
+		for len(b) > 0 && n < 9 && '0' <= b[0] && b[0] <= '9' {
+			frac[n] = b[0]
+			n++
+			b = b[1:]
+		}
+		// It is not valid if there are more bytes left.
+		if len(b) > 0 {
+			return 0, 0, false
+		}
+		// Pad fractional part with 0s.
+		for i := n; i < 9; i++ {
+			frac[i] = '0'
+		}
+		hasFrac = true
+	}
+
+	var secs int64
+	if len(intp) > 0 {
+		var err error
+		secs, err = strconv.ParseInt(string(intp), 10, 64)
+		if err != nil {
+			return 0, 0, false
+		}
+	}
+
+	var nanos int64
+	if hasFrac {
+		nanob := bytes.TrimLeft(frac[:], "0")
+		if len(nanob) > 0 {
+			var err error
+			nanos, err = strconv.ParseInt(string(nanob), 10, 32)
+			if err != nil {
+				return 0, 0, false
+			}
+		}
+	}
+
+	if neg {
+		if secs > 0 {
+			secs = -secs
+		}
+		if nanos > 0 {
+			nanos = -nanos
+		}
+	}
+	return secs, int32(nanos), true
+}
+
+// The JSON representation for a Timestamp is a JSON string in the RFC 3339
+// format, i.e. "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where
+// {year} is always expressed using four digits while {month}, {day}, {hour},
+// {min}, and {sec} are zero-padded to two digits each. The fractional seconds,
+// which can go up to 9 digits, up to 1 nanosecond resolution, is optional. The
+// "Z" suffix indicates the timezone ("UTC"); the timezone is required. Encoding
+// should always use UTC (as indicated by "Z") and a decoder should be able to
+// accept both UTC and other timezones (as indicated by an offset).
+//
+// Timestamp.seconds must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z
+// inclusive.
+// Timestamp.nanos must be from 0 to 999,999,999 inclusive.
+
+const (
+	maxTimestampSeconds = 253402300799
+	minTimestampSeconds = -62135596800
+)
+
+func (e encoder) marshalTimestamp(m pref.Message) error {
+	fds := m.Descriptor().Fields()
+	fdSeconds := fds.ByNumber(fieldnum.Timestamp_Seconds)
+	fdNanos := fds.ByNumber(fieldnum.Timestamp_Nanos)
+
+	secsVal := m.Get(fdSeconds)
+	nanosVal := m.Get(fdNanos)
+	secs := secsVal.Int()
+	nanos := nanosVal.Int()
+	if secs < minTimestampSeconds || secs > maxTimestampSeconds {
+		return errors.New("%s: seconds out of range %v", m.Descriptor().FullName(), secs)
+	}
+	if nanos < 0 || nanos > secondsInNanos {
+		return errors.New("%s: nanos out of range %v", m.Descriptor().FullName(), nanos)
+	}
+	// Uses RFC 3339, where generated output will be Z-normalized and uses 0, 3,
+	// 6 or 9 fractional digits.
+	t := time.Unix(secs, nanos).UTC()
+	x := t.Format("2006-01-02T15:04:05.000000000")
+	x = strings.TrimSuffix(x, "000")
+	x = strings.TrimSuffix(x, "000")
+	x = strings.TrimSuffix(x, ".000")
+	e.WriteString(x + "Z")
+	return nil
+}
+
+func (d decoder) unmarshalTimestamp(m pref.Message) error {
+	tok, err := d.Read()
+	if err != nil {
+		return err
+	}
+	if tok.Kind() != json.String {
+		return d.unexpectedTokenError(tok)
+	}
+
+	t, err := time.Parse(time.RFC3339Nano, tok.ParsedString())
+	if err != nil {
+		return d.newError(tok.Pos(), "invalid google.protobuf.Timestamp value %v", tok.RawString())
+	}
+	// Validate seconds. No need to validate nanos because time.Parse would have
+	// covered that already.
+	secs := t.Unix()
+	if secs < minTimestampSeconds || secs > maxTimestampSeconds {
+		return d.newError(tok.Pos(), "google.protobuf.Timestamp value out of range: %v", tok.RawString())
+	}
+
+	fds := m.Descriptor().Fields()
+	fdSeconds := fds.ByNumber(fieldnum.Timestamp_Seconds)
+	fdNanos := fds.ByNumber(fieldnum.Timestamp_Nanos)
+
+	m.Set(fdSeconds, pref.ValueOfInt64(secs))
+	m.Set(fdNanos, pref.ValueOfInt32(int32(t.Nanosecond())))
+	return nil
+}
+
+// The JSON representation for a FieldMask is a JSON string where paths are
+// separated by a comma. Fields name in each path are converted to/from
+// lower-camel naming conventions. Encoding should fail if the path name would
+// end up differently after a round-trip.
+
+func (e encoder) marshalFieldMask(m pref.Message) error {
+	fd := m.Descriptor().Fields().ByNumber(fieldnum.FieldMask_Paths)
+	list := m.Get(fd).List()
+	paths := make([]string, 0, list.Len())
+
+	for i := 0; i < list.Len(); i++ {
+		s := list.Get(i).String()
+		// Return error if conversion to camelCase is not reversible.
+		cc := strs.JSONCamelCase(s)
+		if s != strs.JSONSnakeCase(cc) {
+			return errors.New("%s.paths contains irreversible value %q", m.Descriptor().FullName(), s)
+		}
+		paths = append(paths, cc)
+	}
+
+	e.WriteString(strings.Join(paths, ","))
+	return nil
+}
+
+func (d decoder) unmarshalFieldMask(m pref.Message) error {
+	tok, err := d.Read()
+	if err != nil {
+		return err
+	}
+	if tok.Kind() != json.String {
+		return d.unexpectedTokenError(tok)
+	}
+	str := strings.TrimSpace(tok.ParsedString())
+	if str == "" {
+		return nil
+	}
+	paths := strings.Split(str, ",")
+
+	fd := m.Descriptor().Fields().ByNumber(fieldnum.FieldMask_Paths)
+	list := m.Mutable(fd).List()
+
+	for _, s := range paths {
+		s = strings.TrimSpace(s)
+		// Convert to snake_case. Unlike encoding, no validation is done because
+		// it is not possible to know the original path names.
+		list.Append(pref.ValueOfString(strs.JSONSnakeCase(s)))
+	}
+	return nil
+}
diff --git a/vendor/google.golang.org/protobuf/encoding/prototext/decode.go b/vendor/google.golang.org/protobuf/encoding/prototext/decode.go
new file mode 100644
index 000000000..77dbe1b5c
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/encoding/prototext/decode.go
@@ -0,0 +1,789 @@
+// 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 prototext
+
+import (
+	"fmt"
+	"strings"
+	"unicode/utf8"
+
+	"google.golang.org/protobuf/internal/encoding/messageset"
+	"google.golang.org/protobuf/internal/encoding/text"
+	"google.golang.org/protobuf/internal/errors"
+	"google.golang.org/protobuf/internal/fieldnum"
+	"google.golang.org/protobuf/internal/flags"
+	"google.golang.org/protobuf/internal/pragma"
+	"google.golang.org/protobuf/internal/set"
+	"google.golang.org/protobuf/internal/strs"
+	"google.golang.org/protobuf/proto"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/reflect/protoregistry"
+)
+
+// Unmarshal reads the given []byte into the given proto.Message.
+func Unmarshal(b []byte, m proto.Message) error {
+	return UnmarshalOptions{}.Unmarshal(b, m)
+}
+
+// UnmarshalOptions is a configurable textproto format unmarshaler.
+type UnmarshalOptions struct {
+	pragma.NoUnkeyedLiterals
+
+	// AllowPartial accepts input for messages that will result in missing
+	// required fields. If AllowPartial is false (the default), Unmarshal will
+	// return error if there are any missing required fields.
+	AllowPartial bool
+
+	// DiscardUnknown specifies whether to ignore unknown fields when parsing.
+	// An unknown field is any field whose field name or field number does not
+	// resolve to any known or extension field in the message.
+	// By default, unmarshal rejects unknown fields as an error.
+	DiscardUnknown bool
+
+	// Resolver is used for looking up types when unmarshaling
+	// google.protobuf.Any messages or extension fields.
+	// If nil, this defaults to using protoregistry.GlobalTypes.
+	Resolver interface {
+		protoregistry.MessageTypeResolver
+		protoregistry.ExtensionTypeResolver
+	}
+}
+
+// Unmarshal reads the given []byte and populates the given proto.Message using options in
+// UnmarshalOptions object.
+func (o UnmarshalOptions) Unmarshal(b []byte, m proto.Message) error {
+	proto.Reset(m)
+
+	if o.Resolver == nil {
+		o.Resolver = protoregistry.GlobalTypes
+	}
+
+	dec := decoder{text.NewDecoder(b), o}
+	if err := dec.unmarshalMessage(m.ProtoReflect(), false); err != nil {
+		return err
+	}
+	if o.AllowPartial {
+		return nil
+	}
+	return proto.CheckInitialized(m)
+}
+
+type decoder struct {
+	*text.Decoder
+	opts UnmarshalOptions
+}
+
+// newError returns an error object with position info.
+func (d decoder) newError(pos int, f string, x ...interface{}) error {
+	line, column := d.Position(pos)
+	head := fmt.Sprintf("(line %d:%d): ", line, column)
+	return errors.New(head+f, x...)
+}
+
+// unexpectedTokenError returns a syntax error for the given unexpected token.
+func (d decoder) unexpectedTokenError(tok text.Token) error {
+	return d.syntaxError(tok.Pos(), "unexpected token: %s", tok.RawString())
+}
+
+// syntaxError returns a syntax error for given position.
+func (d decoder) syntaxError(pos int, f string, x ...interface{}) error {
+	line, column := d.Position(pos)
+	head := fmt.Sprintf("syntax error (line %d:%d): ", line, column)
+	return errors.New(head+f, x...)
+}
+
+// unmarshalMessage unmarshals into the given protoreflect.Message.
+func (d decoder) unmarshalMessage(m pref.Message, checkDelims bool) error {
+	messageDesc := m.Descriptor()
+	if !flags.ProtoLegacy && messageset.IsMessageSet(messageDesc) {
+		return errors.New("no support for proto1 MessageSets")
+	}
+
+	if messageDesc.FullName() == "google.protobuf.Any" {
+		return d.unmarshalAny(m, checkDelims)
+	}
+
+	if checkDelims {
+		tok, err := d.Read()
+		if err != nil {
+			return err
+		}
+
+		if tok.Kind() != text.MessageOpen {
+			return d.unexpectedTokenError(tok)
+		}
+	}
+
+	var seenNums set.Ints
+	var seenOneofs set.Ints
+	fieldDescs := messageDesc.Fields()
+
+	for {
+		// Read field name.
+		tok, err := d.Read()
+		if err != nil {
+			return err
+		}
+		switch typ := tok.Kind(); typ {
+		case text.Name:
+			// Continue below.
+		case text.EOF:
+			if checkDelims {
+				return text.ErrUnexpectedEOF
+			}
+			return nil
+		default:
+			if checkDelims && typ == text.MessageClose {
+				return nil
+			}
+			return d.unexpectedTokenError(tok)
+		}
+
+		// Resolve the field descriptor.
+		var name pref.Name
+		var fd pref.FieldDescriptor
+		var xt pref.ExtensionType
+		var xtErr error
+		var isFieldNumberName bool
+
+		switch tok.NameKind() {
+		case text.IdentName:
+			name = pref.Name(tok.IdentName())
+			fd = fieldDescs.ByName(name)
+			if fd == nil {
+				// The proto name of a group field is in all lowercase,
+				// while the textproto field name is the group message name.
+				gd := fieldDescs.ByName(pref.Name(strings.ToLower(string(name))))
+				if gd != nil && gd.Kind() == pref.GroupKind && gd.Message().Name() == name {
+					fd = gd
+				}
+			} else if fd.Kind() == pref.GroupKind && fd.Message().Name() != name {
+				fd = nil // reset since field name is actually the message name
+			}
+
+		case text.TypeName:
+			// Handle extensions only. This code path is not for Any.
+			xt, xtErr = d.findExtension(pref.FullName(tok.TypeName()))
+
+		case text.FieldNumber:
+			isFieldNumberName = true
+			num := pref.FieldNumber(tok.FieldNumber())
+			if !num.IsValid() {
+				return d.newError(tok.Pos(), "invalid field number: %d", num)
+			}
+			fd = fieldDescs.ByNumber(num)
+			if fd == nil {
+				xt, xtErr = d.opts.Resolver.FindExtensionByNumber(messageDesc.FullName(), num)
+			}
+		}
+
+		if xt != nil {
+			fd = xt.TypeDescriptor()
+			if !messageDesc.ExtensionRanges().Has(fd.Number()) || fd.ContainingMessage().FullName() != messageDesc.FullName() {
+				return d.newError(tok.Pos(), "message %v cannot be extended by %v", messageDesc.FullName(), fd.FullName())
+			}
+		} else if xtErr != nil && xtErr != protoregistry.NotFound {
+			return d.newError(tok.Pos(), "unable to resolve [%s]: %v", tok.RawString(), xtErr)
+		}
+		if flags.ProtoLegacy {
+			if fd != nil && fd.IsWeak() && fd.Message().IsPlaceholder() {
+				fd = nil // reset since the weak reference is not linked in
+			}
+		}
+
+		// Handle unknown fields.
+		if fd == nil {
+			if d.opts.DiscardUnknown || messageDesc.ReservedNames().Has(name) {
+				d.skipValue()
+				continue
+			}
+			return d.newError(tok.Pos(), "unknown field: %v", tok.RawString())
+		}
+
+		// Handle fields identified by field number.
+		if isFieldNumberName {
+			// TODO: Add an option to permit parsing field numbers.
+			//
+			// This requires careful thought as the MarshalOptions.EmitUnknown
+			// option allows formatting unknown fields as the field number and the
+			// best-effort textual representation of the field value.  In that case,
+			// it may not be possible to unmarshal the value from a parser that does
+			// have information about the unknown field.
+			return d.newError(tok.Pos(), "cannot specify field by number: %v", tok.RawString())
+		}
+
+		switch {
+		case fd.IsList():
+			kind := fd.Kind()
+			if kind != pref.MessageKind && kind != pref.GroupKind && !tok.HasSeparator() {
+				return d.syntaxError(tok.Pos(), "missing field separator :")
+			}
+
+			list := m.Mutable(fd).List()
+			if err := d.unmarshalList(fd, list); err != nil {
+				return err
+			}
+
+		case fd.IsMap():
+			mmap := m.Mutable(fd).Map()
+			if err := d.unmarshalMap(fd, mmap); err != nil {
+				return err
+			}
+
+		default:
+			kind := fd.Kind()
+			if kind != pref.MessageKind && kind != pref.GroupKind && !tok.HasSeparator() {
+				return d.syntaxError(tok.Pos(), "missing field separator :")
+			}
+
+			// If field is a oneof, check if it has already been set.
+			if od := fd.ContainingOneof(); od != nil {
+				idx := uint64(od.Index())
+				if seenOneofs.Has(idx) {
+					return d.newError(tok.Pos(), "error parsing %q, oneof %v is already set", tok.RawString(), od.FullName())
+				}
+				seenOneofs.Set(idx)
+			}
+
+			num := uint64(fd.Number())
+			if seenNums.Has(num) {
+				return d.newError(tok.Pos(), "non-repeated field %q is repeated", tok.RawString())
+			}
+
+			if err := d.unmarshalSingular(fd, m); err != nil {
+				return err
+			}
+			seenNums.Set(num)
+		}
+	}
+
+	return nil
+}
+
+// findExtension returns protoreflect.ExtensionType from the Resolver if found.
+func (d decoder) findExtension(xtName pref.FullName) (pref.ExtensionType, error) {
+	xt, err := d.opts.Resolver.FindExtensionByName(xtName)
+	if err == nil {
+		return xt, nil
+	}
+	return messageset.FindMessageSetExtension(d.opts.Resolver, xtName)
+}
+
+// unmarshalSingular unmarshals a non-repeated field value specified by the
+// given FieldDescriptor.
+func (d decoder) unmarshalSingular(fd pref.FieldDescriptor, m pref.Message) error {
+	var val pref.Value
+	var err error
+	switch fd.Kind() {
+	case pref.MessageKind, pref.GroupKind:
+		val = m.NewField(fd)
+		err = d.unmarshalMessage(val.Message(), true)
+	default:
+		val, err = d.unmarshalScalar(fd)
+	}
+	if err == nil {
+		m.Set(fd, val)
+	}
+	return err
+}
+
+// unmarshalScalar unmarshals a scalar/enum protoreflect.Value specified by the
+// given FieldDescriptor.
+func (d decoder) unmarshalScalar(fd pref.FieldDescriptor) (pref.Value, error) {
+	tok, err := d.Read()
+	if err != nil {
+		return pref.Value{}, err
+	}
+
+	if tok.Kind() != text.Scalar {
+		return pref.Value{}, d.unexpectedTokenError(tok)
+	}
+
+	kind := fd.Kind()
+	switch kind {
+	case pref.BoolKind:
+		if b, ok := tok.Bool(); ok {
+			return pref.ValueOfBool(b), nil
+		}
+
+	case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
+		if n, ok := tok.Int32(); ok {
+			return pref.ValueOfInt32(n), nil
+		}
+
+	case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
+		if n, ok := tok.Int64(); ok {
+			return pref.ValueOfInt64(n), nil
+		}
+
+	case pref.Uint32Kind, pref.Fixed32Kind:
+		if n, ok := tok.Uint32(); ok {
+			return pref.ValueOfUint32(n), nil
+		}
+
+	case pref.Uint64Kind, pref.Fixed64Kind:
+		if n, ok := tok.Uint64(); ok {
+			return pref.ValueOfUint64(n), nil
+		}
+
+	case pref.FloatKind:
+		if n, ok := tok.Float32(); ok {
+			return pref.ValueOfFloat32(n), nil
+		}
+
+	case pref.DoubleKind:
+		if n, ok := tok.Float64(); ok {
+			return pref.ValueOfFloat64(n), nil
+		}
+
+	case pref.StringKind:
+		if s, ok := tok.String(); ok {
+			if strs.EnforceUTF8(fd) && !utf8.ValidString(s) {
+				return pref.Value{}, d.newError(tok.Pos(), "contains invalid UTF-8")
+			}
+			return pref.ValueOfString(s), nil
+		}
+
+	case pref.BytesKind:
+		if b, ok := tok.String(); ok {
+			return pref.ValueOfBytes([]byte(b)), nil
+		}
+
+	case pref.EnumKind:
+		if lit, ok := tok.Enum(); ok {
+			// Lookup EnumNumber based on name.
+			if enumVal := fd.Enum().Values().ByName(pref.Name(lit)); enumVal != nil {
+				return pref.ValueOfEnum(enumVal.Number()), nil
+			}
+		}
+		if num, ok := tok.Int32(); ok {
+			return pref.ValueOfEnum(pref.EnumNumber(num)), nil
+		}
+
+	default:
+		panic(fmt.Sprintf("invalid scalar kind %v", kind))
+	}
+
+	return pref.Value{}, d.newError(tok.Pos(), "invalid value for %v type: %v", kind, tok.RawString())
+}
+
+// unmarshalList unmarshals into given protoreflect.List. A list value can
+// either be in [] syntax or simply just a single scalar/message value.
+func (d decoder) unmarshalList(fd pref.FieldDescriptor, list pref.List) error {
+	tok, err := d.Peek()
+	if err != nil {
+		return err
+	}
+
+	switch fd.Kind() {
+	case pref.MessageKind, pref.GroupKind:
+		switch tok.Kind() {
+		case text.ListOpen:
+			d.Read()
+			for {
+				tok, err := d.Peek()
+				if err != nil {
+					return err
+				}
+
+				switch tok.Kind() {
+				case text.ListClose:
+					d.Read()
+					return nil
+				case text.MessageOpen:
+					pval := list.NewElement()
+					if err := d.unmarshalMessage(pval.Message(), true); err != nil {
+						return err
+					}
+					list.Append(pval)
+				default:
+					return d.unexpectedTokenError(tok)
+				}
+			}
+
+		case text.MessageOpen:
+			pval := list.NewElement()
+			if err := d.unmarshalMessage(pval.Message(), true); err != nil {
+				return err
+			}
+			list.Append(pval)
+			return nil
+		}
+
+	default:
+		switch tok.Kind() {
+		case text.ListOpen:
+			d.Read()
+			for {
+				tok, err := d.Peek()
+				if err != nil {
+					return err
+				}
+
+				switch tok.Kind() {
+				case text.ListClose:
+					d.Read()
+					return nil
+				case text.Scalar:
+					pval, err := d.unmarshalScalar(fd)
+					if err != nil {
+						return err
+					}
+					list.Append(pval)
+				default:
+					return d.unexpectedTokenError(tok)
+				}
+			}
+
+		case text.Scalar:
+			pval, err := d.unmarshalScalar(fd)
+			if err != nil {
+				return err
+			}
+			list.Append(pval)
+			return nil
+		}
+	}
+
+	return d.unexpectedTokenError(tok)
+}
+
+// unmarshalMap unmarshals into given protoreflect.Map. A map value is a
+// textproto message containing {key: <kvalue>, value: <mvalue>}.
+func (d decoder) unmarshalMap(fd pref.FieldDescriptor, mmap pref.Map) error {
+	// Determine ahead whether map entry is a scalar type or a message type in
+	// order to call the appropriate unmarshalMapValue func inside
+	// unmarshalMapEntry.
+	var unmarshalMapValue func() (pref.Value, error)
+	switch fd.MapValue().Kind() {
+	case pref.MessageKind, pref.GroupKind:
+		unmarshalMapValue = func() (pref.Value, error) {
+			pval := mmap.NewValue()
+			if err := d.unmarshalMessage(pval.Message(), true); err != nil {
+				return pref.Value{}, err
+			}
+			return pval, nil
+		}
+	default:
+		unmarshalMapValue = func() (pref.Value, error) {
+			return d.unmarshalScalar(fd.MapValue())
+		}
+	}
+
+	tok, err := d.Read()
+	if err != nil {
+		return err
+	}
+	switch tok.Kind() {
+	case text.MessageOpen:
+		return d.unmarshalMapEntry(fd, mmap, unmarshalMapValue)
+
+	case text.ListOpen:
+		for {
+			tok, err := d.Read()
+			if err != nil {
+				return err
+			}
+			switch tok.Kind() {
+			case text.ListClose:
+				return nil
+			case text.MessageOpen:
+				if err := d.unmarshalMapEntry(fd, mmap, unmarshalMapValue); err != nil {
+					return err
+				}
+			default:
+				return d.unexpectedTokenError(tok)
+			}
+		}
+
+	default:
+		return d.unexpectedTokenError(tok)
+	}
+}
+
+// unmarshalMap unmarshals into given protoreflect.Map. A map value is a
+// textproto message containing {key: <kvalue>, value: <mvalue>}.
+func (d decoder) unmarshalMapEntry(fd pref.FieldDescriptor, mmap pref.Map, unmarshalMapValue func() (pref.Value, error)) error {
+	var key pref.MapKey
+	var pval pref.Value
+Loop:
+	for {
+		// Read field name.
+		tok, err := d.Read()
+		if err != nil {
+			return err
+		}
+		switch tok.Kind() {
+		case text.Name:
+			if tok.NameKind() != text.IdentName {
+				if !d.opts.DiscardUnknown {
+					return d.newError(tok.Pos(), "unknown map entry field %q", tok.RawString())
+				}
+				d.skipValue()
+				continue Loop
+			}
+			// Continue below.
+		case text.MessageClose:
+			break Loop
+		default:
+			return d.unexpectedTokenError(tok)
+		}
+
+		name := tok.IdentName()
+		switch name {
+		case "key":
+			if !tok.HasSeparator() {
+				return d.syntaxError(tok.Pos(), "missing field separator :")
+			}
+			if key.IsValid() {
+				return d.newError(tok.Pos(), `map entry "key" cannot be repeated`)
+			}
+			val, err := d.unmarshalScalar(fd.MapKey())
+			if err != nil {
+				return err
+			}
+			key = val.MapKey()
+
+		case "value":
+			if kind := fd.MapValue().Kind(); (kind != pref.MessageKind) && (kind != pref.GroupKind) {
+				if !tok.HasSeparator() {
+					return d.syntaxError(tok.Pos(), "missing field separator :")
+				}
+			}
+			if pval.IsValid() {
+				return d.newError(tok.Pos(), `map entry "value" cannot be repeated`)
+			}
+			pval, err = unmarshalMapValue()
+			if err != nil {
+				return err
+			}
+
+		default:
+			if !d.opts.DiscardUnknown {
+				return d.newError(tok.Pos(), "unknown map entry field %q", name)
+			}
+			d.skipValue()
+		}
+	}
+
+	if !key.IsValid() {
+		key = fd.MapKey().Default().MapKey()
+	}
+	if !pval.IsValid() {
+		switch fd.MapValue().Kind() {
+		case pref.MessageKind, pref.GroupKind:
+			// If value field is not set for message/group types, construct an
+			// empty one as default.
+			pval = mmap.NewValue()
+		default:
+			pval = fd.MapValue().Default()
+		}
+	}
+	mmap.Set(key, pval)
+	return nil
+}
+
+// unmarshalAny unmarshals an Any textproto. It can either be in expanded form
+// or non-expanded form.
+func (d decoder) unmarshalAny(m pref.Message, checkDelims bool) error {
+	var typeURL string
+	var bValue []byte
+
+	// hasFields tracks which valid fields have been seen in the loop below in
+	// order to flag an error if there are duplicates or conflicts. It may
+	// contain the strings "type_url", "value" and "expanded".  The literal
+	// "expanded" is used to indicate that the expanded form has been
+	// encountered already.
+	hasFields := map[string]bool{}
+
+	if checkDelims {
+		tok, err := d.Read()
+		if err != nil {
+			return err
+		}
+
+		if tok.Kind() != text.MessageOpen {
+			return d.unexpectedTokenError(tok)
+		}
+	}
+
+Loop:
+	for {
+		// Read field name. Can only have 3 possible field names, i.e. type_url,
+		// value and type URL name inside [].
+		tok, err := d.Read()
+		if err != nil {
+			return err
+		}
+		if typ := tok.Kind(); typ != text.Name {
+			if checkDelims {
+				if typ == text.MessageClose {
+					break Loop
+				}
+			} else if typ == text.EOF {
+				break Loop
+			}
+			return d.unexpectedTokenError(tok)
+		}
+
+		switch tok.NameKind() {
+		case text.IdentName:
+			// Both type_url and value fields require field separator :.
+			if !tok.HasSeparator() {
+				return d.syntaxError(tok.Pos(), "missing field separator :")
+			}
+
+			switch tok.IdentName() {
+			case "type_url":
+				if hasFields["type_url"] {
+					return d.newError(tok.Pos(), "duplicate Any type_url field")
+				}
+				if hasFields["expanded"] {
+					return d.newError(tok.Pos(), "conflict with [%s] field", typeURL)
+				}
+				tok, err := d.Read()
+				if err != nil {
+					return err
+				}
+				var ok bool
+				typeURL, ok = tok.String()
+				if !ok {
+					return d.newError(tok.Pos(), "invalid Any type_url: %v", tok.RawString())
+				}
+				hasFields["type_url"] = true
+
+			case "value":
+				if hasFields["value"] {
+					return d.newError(tok.Pos(), "duplicate Any value field")
+				}
+				if hasFields["expanded"] {
+					return d.newError(tok.Pos(), "conflict with [%s] field", typeURL)
+				}
+				tok, err := d.Read()
+				if err != nil {
+					return err
+				}
+				s, ok := tok.String()
+				if !ok {
+					return d.newError(tok.Pos(), "invalid Any value: %v", tok.RawString())
+				}
+				bValue = []byte(s)
+				hasFields["value"] = true
+
+			default:
+				if !d.opts.DiscardUnknown {
+					return d.newError(tok.Pos(), "invalid field name %q in google.protobuf.Any message", tok.RawString())
+				}
+			}
+
+		case text.TypeName:
+			if hasFields["expanded"] {
+				return d.newError(tok.Pos(), "cannot have more than one type")
+			}
+			if hasFields["type_url"] {
+				return d.newError(tok.Pos(), "conflict with type_url field")
+			}
+			typeURL = tok.TypeName()
+			var err error
+			bValue, err = d.unmarshalExpandedAny(typeURL, tok.Pos())
+			if err != nil {
+				return err
+			}
+			hasFields["expanded"] = true
+
+		default:
+			if !d.opts.DiscardUnknown {
+				return d.newError(tok.Pos(), "invalid field name %q in google.protobuf.Any message", tok.RawString())
+			}
+		}
+	}
+
+	fds := m.Descriptor().Fields()
+	if len(typeURL) > 0 {
+		m.Set(fds.ByNumber(fieldnum.Any_TypeUrl), pref.ValueOfString(typeURL))
+	}
+	if len(bValue) > 0 {
+		m.Set(fds.ByNumber(fieldnum.Any_Value), pref.ValueOfBytes(bValue))
+	}
+	return nil
+}
+
+func (d decoder) unmarshalExpandedAny(typeURL string, pos int) ([]byte, error) {
+	mt, err := d.opts.Resolver.FindMessageByURL(typeURL)
+	if err != nil {
+		return nil, d.newError(pos, "unable to resolve message [%v]: %v", typeURL, err)
+	}
+	// Create new message for the embedded message type and unmarshal the value
+	// field into it.
+	m := mt.New()
+	if err := d.unmarshalMessage(m, true); err != nil {
+		return nil, err
+	}
+	// Serialize the embedded message and return the resulting bytes.
+	b, err := proto.MarshalOptions{
+		AllowPartial:  true, // Never check required fields inside an Any.
+		Deterministic: true,
+	}.Marshal(m.Interface())
+	if err != nil {
+		return nil, d.newError(pos, "error in marshaling message into Any.value: %v", err)
+	}
+	return b, nil
+}
+
+// skipValue makes the decoder parse a field value in order to advance the read
+// to the next field. It relies on Read returning an error if the types are not
+// in valid sequence.
+func (d decoder) skipValue() error {
+	tok, err := d.Read()
+	if err != nil {
+		return err
+	}
+	// Only need to continue reading for messages and lists.
+	switch tok.Kind() {
+	case text.MessageOpen:
+		return d.skipMessageValue()
+
+	case text.ListOpen:
+		for {
+			tok, err := d.Read()
+			if err != nil {
+				return err
+			}
+			switch tok.Kind() {
+			case text.ListClose:
+				return nil
+			case text.MessageOpen:
+				return d.skipMessageValue()
+			default:
+				// Skip items. This will not validate whether skipped values are
+				// of the same type or not, same behavior as C++
+				// TextFormat::Parser::AllowUnknownField(true) version 3.8.0.
+				if err := d.skipValue(); err != nil {
+					return err
+				}
+			}
+		}
+	}
+	return nil
+}
+
+// skipMessageValue makes the decoder parse and skip over all fields in a
+// message. It assumes that the previous read type is MessageOpen.
+func (d decoder) skipMessageValue() error {
+	for {
+		tok, err := d.Read()
+		if err != nil {
+			return err
+		}
+		switch tok.Kind() {
+		case text.MessageClose:
+			return nil
+		case text.Name:
+			if err := d.skipValue(); err != nil {
+				return err
+			}
+		}
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/encoding/prototext/decode_test.go b/vendor/google.golang.org/protobuf/encoding/prototext/decode_test.go
new file mode 100644
index 000000000..dceded162
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/encoding/prototext/decode_test.go
@@ -0,0 +1,1689 @@
+// 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 prototext_test
+
+import (
+	"math"
+	"strings"
+	"testing"
+
+	"google.golang.org/protobuf/encoding/prototext"
+	"google.golang.org/protobuf/internal/flags"
+	"google.golang.org/protobuf/proto"
+	preg "google.golang.org/protobuf/reflect/protoregistry"
+
+	testpb "google.golang.org/protobuf/internal/testprotos/test"
+	weakpb "google.golang.org/protobuf/internal/testprotos/test/weak1"
+	pb2 "google.golang.org/protobuf/internal/testprotos/textpb2"
+	pb3 "google.golang.org/protobuf/internal/testprotos/textpb3"
+	"google.golang.org/protobuf/types/known/anypb"
+)
+
+func TestUnmarshal(t *testing.T) {
+	tests := []struct {
+		desc         string
+		umo          prototext.UnmarshalOptions
+		inputMessage proto.Message
+		inputText    string
+		wantMessage  proto.Message
+		wantErr      string // Expected error substring.
+		skip         bool
+	}{{
+		desc:         "proto2 empty message",
+		inputMessage: &pb2.Scalars{},
+		wantMessage:  &pb2.Scalars{},
+	}, {
+		desc:         "proto2 optional scalars set to zero values",
+		inputMessage: &pb2.Scalars{},
+		inputText: `opt_bool: false
+opt_int32: 0
+opt_int64: 0
+opt_uint32: 0
+opt_uint64: 0
+opt_sint32: 0
+opt_sint64: 0
+opt_fixed32: 0
+opt_fixed64: 0
+opt_sfixed32: 0
+opt_sfixed64: 0
+opt_float: 0
+opt_double: 0
+opt_bytes: ""
+opt_string: ""
+`,
+		wantMessage: &pb2.Scalars{
+			OptBool:     proto.Bool(false),
+			OptInt32:    proto.Int32(0),
+			OptInt64:    proto.Int64(0),
+			OptUint32:   proto.Uint32(0),
+			OptUint64:   proto.Uint64(0),
+			OptSint32:   proto.Int32(0),
+			OptSint64:   proto.Int64(0),
+			OptFixed32:  proto.Uint32(0),
+			OptFixed64:  proto.Uint64(0),
+			OptSfixed32: proto.Int32(0),
+			OptSfixed64: proto.Int64(0),
+			OptFloat:    proto.Float32(0),
+			OptDouble:   proto.Float64(0),
+			OptBytes:    []byte{},
+			OptString:   proto.String(""),
+		},
+	}, {
+		desc:         "proto3 scalars set to zero values",
+		inputMessage: &pb3.Scalars{},
+		inputText: `s_bool: false
+s_int32: 0
+s_int64: 0
+s_uint32: 0
+s_uint64: 0
+s_sint32: 0
+s_sint64: 0
+s_fixed32: 0
+s_fixed64: 0
+s_sfixed32: 0
+s_sfixed64: 0
+s_float: 0
+s_double: 0
+s_bytes: ""
+s_string: ""
+`,
+		wantMessage: &pb3.Scalars{},
+	}, {
+		desc:         "proto3 optional set to zero values",
+		inputMessage: &pb3.Proto3Optional{},
+		inputText: `opt_bool: false
+opt_int32: 0
+opt_int64: 0
+opt_uint32: 0
+opt_uint64: 0
+opt_float: 0
+opt_double: 0
+opt_string: ""
+opt_bytes: ""
+opt_enum: ZERO
+opt_message: {}
+`,
+		wantMessage: &pb3.Proto3Optional{
+			OptBool:    proto.Bool(false),
+			OptInt32:   proto.Int32(0),
+			OptInt64:   proto.Int64(0),
+			OptUint32:  proto.Uint32(0),
+			OptUint64:  proto.Uint64(0),
+			OptFloat:   proto.Float32(0),
+			OptDouble:  proto.Float64(0),
+			OptString:  proto.String(""),
+			OptBytes:   []byte{},
+			OptEnum:    pb3.Enum_ZERO.Enum(),
+			OptMessage: &pb3.Nested{},
+		},
+	}, {
+		desc:         "proto2 optional scalars",
+		inputMessage: &pb2.Scalars{},
+		inputText: `opt_bool: true
+opt_int32: 255
+opt_int64: 3735928559
+opt_uint32: 0xff
+opt_uint64: 0xdeadbeef
+opt_sint32: -1001
+opt_sint64: -0xffff
+opt_fixed64: 64
+opt_sfixed32: -32
+opt_float: 1.234
+opt_double: 1.23e+100
+opt_bytes: "\xe8\xb0\xb7\xe6\xad\x8c"
+opt_string: "谷歌"
+`,
+		wantMessage: &pb2.Scalars{
+			OptBool:     proto.Bool(true),
+			OptInt32:    proto.Int32(0xff),
+			OptInt64:    proto.Int64(0xdeadbeef),
+			OptUint32:   proto.Uint32(0xff),
+			OptUint64:   proto.Uint64(0xdeadbeef),
+			OptSint32:   proto.Int32(-1001),
+			OptSint64:   proto.Int64(-0xffff),
+			OptFixed64:  proto.Uint64(64),
+			OptSfixed32: proto.Int32(-32),
+			OptFloat:    proto.Float32(1.234),
+			OptDouble:   proto.Float64(1.23e100),
+			OptBytes:    []byte("\xe8\xb0\xb7\xe6\xad\x8c"),
+			OptString:   proto.String("谷歌"),
+		},
+	}, {
+		desc:         "case sensitive",
+		inputMessage: &pb3.Scalars{},
+		inputText:    `S_BOOL: true`,
+		wantErr:      "unknown field: S_BOOL",
+	}, {
+		desc:         "proto3 scalars",
+		inputMessage: &pb3.Scalars{},
+		inputText: `s_bool: true
+s_int32: 255
+s_int64: 3735928559
+s_uint32: 0xff
+s_uint64: 0xdeadbeef
+s_sint32: -1001
+s_sint64: -0xffff
+s_fixed64: 64
+s_sfixed32: -32
+s_float: 1.234
+s_double: 1.23e+100
+s_bytes: "\xe8\xb0\xb7\xe6\xad\x8c"
+s_string: "谷歌"
+`,
+		wantMessage: &pb3.Scalars{
+			SBool:     true,
+			SInt32:    0xff,
+			SInt64:    0xdeadbeef,
+			SUint32:   0xff,
+			SUint64:   0xdeadbeef,
+			SSint32:   -1001,
+			SSint64:   -0xffff,
+			SFixed64:  64,
+			SSfixed32: -32,
+			SFloat:    1.234,
+			SDouble:   1.23e100,
+			SBytes:    []byte("\xe8\xb0\xb7\xe6\xad\x8c"),
+			SString:   "谷歌",
+		},
+	}, {
+		desc:         "proto2 string with invalid UTF-8",
+		inputMessage: &pb2.Scalars{},
+		inputText:    `opt_string: "abc\xff"`,
+		wantMessage: &pb2.Scalars{
+			OptString: proto.String("abc\xff"),
+		},
+	}, {
+		desc:         "proto3 string with invalid UTF-8",
+		inputMessage: &pb3.Scalars{},
+		inputText:    `s_string: "abc\xff"`,
+		wantErr:      "(line 1:11): contains invalid UTF-8",
+	}, {
+		desc:         "proto2 message contains unknown field",
+		inputMessage: &pb2.Scalars{},
+		inputText:    "unknown_field: 123",
+		wantErr:      "unknown field",
+	}, {
+		desc:         "proto3 message contains unknown field",
+		inputMessage: &pb3.Scalars{},
+		inputText:    "unknown_field: 456",
+		wantErr:      "unknown field",
+	}, {
+		desc:         "proto2 message contains discarded unknown field",
+		umo:          prototext.UnmarshalOptions{DiscardUnknown: true},
+		inputMessage: &pb2.Scalars{},
+		inputText:    `unknown_field:123 1000:"hello"`,
+	}, {
+		desc:         "proto3 message contains discarded unknown field",
+		umo:          prototext.UnmarshalOptions{DiscardUnknown: true},
+		inputMessage: &pb3.Scalars{},
+		inputText:    `unknown_field:456 1000:"goodbye"`,
+	}, {
+		desc:         "proto2 message cannot parse field number",
+		umo:          prototext.UnmarshalOptions{DiscardUnknown: true},
+		inputMessage: &pb2.Scalars{},
+		inputText:    `13:"hello"`,
+		wantErr:      "cannot specify field by number",
+	}, {
+		desc:         "proto3 message cannot parse field number",
+		umo:          prototext.UnmarshalOptions{DiscardUnknown: true},
+		inputMessage: &pb3.Scalars{},
+		inputText:    `13:"goodbye"`,
+		wantErr:      "cannot specify field by number",
+	}, {
+		desc:         "proto2 numeric key field",
+		inputMessage: &pb2.Scalars{},
+		inputText:    "1: true",
+		wantErr:      "cannot specify field by number",
+	}, {
+		desc:         "proto3 numeric key field",
+		inputMessage: &pb3.Scalars{},
+		inputText:    "1: true",
+		wantErr:      "cannot specify field by number",
+	}, {
+		desc:         "invalid bool value",
+		inputMessage: &pb3.Scalars{},
+		inputText:    "s_bool: 123",
+		wantErr:      "invalid value for bool",
+	}, {
+		desc:         "invalid int32 value",
+		inputMessage: &pb3.Scalars{},
+		inputText:    "s_int32: not_a_num",
+		wantErr:      "invalid value for int32",
+	}, {
+		desc:         "invalid int64 value",
+		inputMessage: &pb3.Scalars{},
+		inputText:    "s_int64: 'not a num either'",
+		wantErr:      "invalid value for int64",
+	}, {
+		desc:         "invalid uint32 value",
+		inputMessage: &pb3.Scalars{},
+		inputText:    "s_fixed32: -42",
+		wantErr:      "invalid value for fixed32",
+	}, {
+		desc:         "invalid uint64 value",
+		inputMessage: &pb3.Scalars{},
+		inputText:    "s_uint64: -47",
+		wantErr:      "invalid value for uint64",
+	}, {
+		desc:         "invalid sint32 value",
+		inputMessage: &pb3.Scalars{},
+		inputText:    "s_sint32: '42'",
+		wantErr:      "invalid value for sint32",
+	}, {
+		desc:         "invalid sint64 value",
+		inputMessage: &pb3.Scalars{},
+		inputText:    "s_sint64: '-47'",
+		wantErr:      "invalid value for sint64",
+	}, {
+		desc:         "invalid fixed32 value",
+		inputMessage: &pb3.Scalars{},
+		inputText:    "s_fixed32: -42",
+		wantErr:      "invalid value for fixed32",
+	}, {
+		desc:         "invalid fixed64 value",
+		inputMessage: &pb3.Scalars{},
+		inputText:    "s_fixed64: -42",
+		wantErr:      "invalid value for fixed64",
+	}, {
+		desc:         "invalid sfixed32 value",
+		inputMessage: &pb3.Scalars{},
+		inputText:    "s_sfixed32: 'not valid'",
+		wantErr:      "invalid value for sfixed32",
+	}, {
+		desc:         "invalid sfixed64 value",
+		inputMessage: &pb3.Scalars{},
+		inputText:    "s_sfixed64: bad",
+		wantErr:      "invalid value for sfixed64",
+	}, {
+		desc:         "conformance: FloatFieldMaxValue",
+		inputMessage: &pb2.Scalars{},
+		inputText:    `opt_float: 3.4028235e+38`,
+		wantMessage: &pb2.Scalars{
+			OptFloat: proto.Float32(3.40282347e+38),
+		},
+	}, {
+		desc:         "conformance: FloatFieldLargerThanUint64",
+		inputMessage: &pb2.Scalars{},
+		inputText:    `opt_float: 18446744073709551616`,
+		wantMessage: &pb2.Scalars{
+			OptFloat: proto.Float32(1.84467441e+19),
+		},
+	}, {
+		desc:         "conformance: FloatFieldTooLarge",
+		inputMessage: &pb2.Scalars{},
+		inputText:    `opt_float: 3.4028235e+39`,
+		wantMessage: &pb2.Scalars{
+			OptFloat: proto.Float32(float32(math.Inf(1))),
+		},
+	}, {
+		desc:         "invalid string value",
+		inputMessage: &pb3.Scalars{},
+		inputText:    "s_string: invalid_string",
+		wantErr:      "invalid value for string type",
+	}, {
+		desc:         "proto2 bytes set to empty string",
+		inputMessage: &pb2.Scalars{},
+		inputText:    "opt_bytes: ''",
+		wantMessage: &pb2.Scalars{
+			OptBytes: []byte(""),
+		},
+	}, {
+		desc:         "proto3 bytes set to empty string",
+		inputMessage: &pb3.Scalars{},
+		inputText:    "s_bytes: ''",
+		wantMessage:  &pb3.Scalars{},
+	}, {
+		desc:         "proto2 duplicate singular field",
+		inputMessage: &pb2.Scalars{},
+		inputText: `
+opt_bool: true
+opt_bool: false
+`,
+		wantErr: `(line 3:1): non-repeated field "opt_bool" is repeated`,
+	}, {
+		desc:         "proto2 more duplicate singular field",
+		inputMessage: &pb2.Scalars{},
+		inputText: `
+opt_bool: true
+opt_string: "hello"
+opt_bool: false
+`,
+		wantErr: `(line 4:1): non-repeated field "opt_bool" is repeated`,
+	}, {
+		desc:         "proto2 invalid singular field",
+		inputMessage: &pb2.Scalars{},
+		inputText: `
+opt_bool: [true, false]
+`,
+		wantErr: "(line 2:11): unexpected token: [",
+	}, {
+		desc:         "proto3 duplicate singular field",
+		inputMessage: &pb3.Scalars{},
+		inputText: `
+s_bool: false
+s_bool: true
+`,
+		wantErr: `non-repeated field "s_bool" is repeated`,
+	}, {
+		desc:         "proto3 more duplicate singular field",
+		inputMessage: &pb3.Scalars{},
+		inputText: `
+s_bool: false
+s_string: ""
+s_bool: true
+`,
+		wantErr: `non-repeated field "s_bool" is repeated`,
+	}, {
+		desc:         "proto2 enum",
+		inputMessage: &pb2.Enums{},
+		inputText: `
+opt_enum: ONE
+opt_nested_enum: UNO
+`,
+		wantMessage: &pb2.Enums{
+			OptEnum:       pb2.Enum_ONE.Enum(),
+			OptNestedEnum: pb2.Enums_UNO.Enum(),
+		},
+	}, {
+		desc:         "proto2 enum set to numeric values",
+		inputMessage: &pb2.Enums{},
+		inputText: `
+opt_enum: 2
+opt_nested_enum: 2
+`,
+		wantMessage: &pb2.Enums{
+			OptEnum:       pb2.Enum_TWO.Enum(),
+			OptNestedEnum: pb2.Enums_DOS.Enum(),
+		},
+	}, {
+		desc:         "proto2 enum set to unnamed numeric values",
+		inputMessage: &pb2.Enums{},
+		inputText: `
+opt_enum: 101
+opt_nested_enum: -101
+`,
+		wantMessage: &pb2.Enums{
+			OptEnum:       pb2.Enum(101).Enum(),
+			OptNestedEnum: pb2.Enums_NestedEnum(-101).Enum(),
+		},
+	}, {
+		desc:         "proto2 enum set to invalid named",
+		inputMessage: &pb2.Enums{},
+		inputText: `
+opt_enum: UNNAMED
+opt_nested_enum: UNNAMED_TOO
+`,
+		wantErr: "invalid value for enum type: UNNAMED",
+	}, {
+		desc:         "proto3 enum name value",
+		inputMessage: &pb3.Enums{},
+		inputText: `
+s_enum: ONE
+s_nested_enum: DIEZ
+`,
+		wantMessage: &pb3.Enums{
+			SEnum:       pb3.Enum_ONE,
+			SNestedEnum: pb3.Enums_DIEZ,
+		},
+	}, {
+		desc:         "proto3 enum numeric value",
+		inputMessage: &pb3.Enums{},
+		inputText: `
+s_enum: 2
+s_nested_enum: 2
+`,
+		wantMessage: &pb3.Enums{
+			SEnum:       pb3.Enum_TWO,
+			SNestedEnum: pb3.Enums_DOS,
+		},
+	}, {
+		desc:         "proto3 enum unnamed numeric value",
+		inputMessage: &pb3.Enums{},
+		inputText: `
+s_enum: 0x7fffffff
+s_nested_enum: -0x80000000
+`,
+		wantMessage: &pb3.Enums{
+			SEnum:       0x7fffffff,
+			SNestedEnum: -0x80000000,
+		},
+	}, {
+		desc:         "proto2 nested empty messages",
+		inputMessage: &pb2.Nests{},
+		inputText: `
+opt_nested: {}
+OptGroup: {}
+`,
+		wantMessage: &pb2.Nests{
+			OptNested: &pb2.Nested{},
+			Optgroup:  &pb2.Nests_OptGroup{},
+		},
+	}, {
+		desc:         "message fields with no field separator",
+		inputMessage: &pb2.Nests{},
+		inputText: `
+opt_nested {}
+OptGroup {}
+`,
+		wantMessage: &pb2.Nests{
+			OptNested: &pb2.Nested{},
+			Optgroup:  &pb2.Nests_OptGroup{},
+		},
+	}, {
+		desc:         "group field name",
+		inputMessage: &pb2.Nests{},
+		inputText:    `optgroup: {}`,
+		wantErr:      "unknown field: optgroup",
+	}, {
+		desc:         "proto2 nested messages",
+		inputMessage: &pb2.Nests{},
+		inputText: `
+opt_nested: {
+  opt_string: "nested message"
+  opt_nested: {
+    opt_string: "another nested message"
+  }
+}
+`,
+		wantMessage: &pb2.Nests{
+			OptNested: &pb2.Nested{
+				OptString: proto.String("nested message"),
+				OptNested: &pb2.Nested{
+					OptString: proto.String("another nested message"),
+				},
+			},
+		},
+	}, {
+		desc:         "proto3 nested empty message",
+		inputMessage: &pb3.Nests{},
+		inputText:    "s_nested: {}",
+		wantMessage: &pb3.Nests{
+			SNested: &pb3.Nested{},
+		},
+	}, {
+		desc:         "proto3 nested message",
+		inputMessage: &pb3.Nests{},
+		inputText: `
+s_nested: {
+  s_string: "nested message"
+  s_nested: {
+    s_string: "another nested message"
+  }
+}
+`,
+		wantMessage: &pb3.Nests{
+			SNested: &pb3.Nested{
+				SString: "nested message",
+				SNested: &pb3.Nested{
+					SString: "another nested message",
+				},
+			},
+		},
+	}, {
+		desc:         "proto3 nested message contains invalid UTF-8",
+		inputMessage: &pb3.Nests{},
+		inputText: `s_nested: {
+  s_string: "abc\xff"
+}
+`,
+		wantErr: "contains invalid UTF-8",
+	}, {
+		desc:         "oneof set to empty string",
+		inputMessage: &pb3.Oneofs{},
+		inputText:    "oneof_string: ''",
+		wantMessage: &pb3.Oneofs{
+			Union: &pb3.Oneofs_OneofString{},
+		},
+	}, {
+		desc:         "oneof set to string",
+		inputMessage: &pb3.Oneofs{},
+		inputText:    "oneof_string: 'hello'",
+		wantMessage: &pb3.Oneofs{
+			Union: &pb3.Oneofs_OneofString{
+				OneofString: "hello",
+			},
+		},
+	}, {
+		desc:         "oneof set to enum",
+		inputMessage: &pb3.Oneofs{},
+		inputText:    "oneof_enum: TEN",
+		wantMessage: &pb3.Oneofs{
+			Union: &pb3.Oneofs_OneofEnum{
+				OneofEnum: pb3.Enum_TEN,
+			},
+		},
+	}, {
+		desc:         "oneof set to empty message",
+		inputMessage: &pb3.Oneofs{},
+		inputText:    "oneof_nested: {}",
+		wantMessage: &pb3.Oneofs{
+			Union: &pb3.Oneofs_OneofNested{
+				OneofNested: &pb3.Nested{},
+			},
+		},
+	}, {
+		desc:         "oneof set to message",
+		inputMessage: &pb3.Oneofs{},
+		inputText: `
+oneof_nested: {
+  s_string: "nested message"
+}
+`,
+		wantMessage: &pb3.Oneofs{
+			Union: &pb3.Oneofs_OneofNested{
+				OneofNested: &pb3.Nested{
+					SString: "nested message",
+				},
+			},
+		},
+	}, {
+		desc:         "oneof set to more than one field",
+		inputMessage: &pb3.Oneofs{},
+		inputText: `
+oneof_enum: ZERO
+oneof_string: "hello"
+`,
+		wantErr: `error parsing "oneof_string", oneof pb3.Oneofs.union is already set`,
+	}, {
+		desc:         "repeated scalar using same field name",
+		inputMessage: &pb2.Repeats{},
+		inputText: `
+rpt_string: "a"
+rpt_string: "b"
+rpt_int32: 0xff
+rpt_float: 1.23
+rpt_bytes: "bytes"
+`,
+		wantMessage: &pb2.Repeats{
+			RptString: []string{"a", "b"},
+			RptInt32:  []int32{0xff},
+			RptFloat:  []float32{1.23},
+			RptBytes:  [][]byte{[]byte("bytes")},
+		},
+	}, {
+		desc:         "repeated using mix of [] and repeated field name",
+		inputMessage: &pb2.Repeats{},
+		inputText: `
+rpt_string: "a"
+rpt_bool: true
+rpt_string: ["x", "y"]
+rpt_bool: [ false, true ]
+rpt_string: "b"
+`,
+		wantMessage: &pb2.Repeats{
+			RptString: []string{"a", "x", "y", "b"},
+			RptBool:   []bool{true, false, true},
+		},
+	}, {
+		desc:         "repeated proto2 contains invalid UTF-8",
+		inputMessage: &pb2.Repeats{},
+		inputText:    `rpt_string: "abc\xff"`,
+		wantMessage: &pb2.Repeats{
+			RptString: []string{"abc\xff"},
+		},
+	}, {
+		desc:         "repeated proto3 contains invalid UTF-8",
+		inputMessage: &pb3.Repeats{},
+		inputText:    `rpt_string: "abc\xff"`,
+		wantErr:      "contains invalid UTF-8",
+	}, {
+		desc:         "repeated enums",
+		inputMessage: &pb2.Enums{},
+		inputText: `
+rpt_enum: TEN
+rpt_enum: 1
+rpt_nested_enum: [DOS, 2]
+rpt_enum: 42
+rpt_nested_enum: -47
+`,
+		wantMessage: &pb2.Enums{
+			RptEnum:       []pb2.Enum{pb2.Enum_TEN, pb2.Enum_ONE, 42},
+			RptNestedEnum: []pb2.Enums_NestedEnum{pb2.Enums_DOS, pb2.Enums_DOS, -47},
+		},
+	}, {
+		desc:         "repeated nested messages",
+		inputMessage: &pb2.Nests{},
+		inputText: `
+rpt_nested: {
+  opt_string: "repeat nested one"
+}
+rpt_nested: {
+  opt_string: "repeat nested two"
+  opt_nested: {
+    opt_string: "inside repeat nested two"
+  }
+}
+rpt_nested: {}
+`,
+		wantMessage: &pb2.Nests{
+			RptNested: []*pb2.Nested{
+				{
+					OptString: proto.String("repeat nested one"),
+				},
+				{
+					OptString: proto.String("repeat nested two"),
+					OptNested: &pb2.Nested{
+						OptString: proto.String("inside repeat nested two"),
+					},
+				},
+				{},
+			},
+		},
+	}, {
+		desc:         "repeated group fields",
+		inputMessage: &pb2.Nests{},
+		inputText: `
+RptGroup: {
+  rpt_string: "hello"
+  rpt_string: "world"
+}
+RptGroup: {}
+`,
+		wantMessage: &pb2.Nests{
+			Rptgroup: []*pb2.Nests_RptGroup{
+				{
+					RptString: []string{"hello", "world"},
+				},
+				{},
+			},
+		},
+	}, {
+		desc:         "repeated message fields without field separator",
+		inputMessage: &pb2.Nests{},
+		inputText: `
+rpt_nested {
+  opt_string: "repeat nested one"
+}
+rpt_nested: [
+  {
+    opt_string: "repeat nested two"
+  },
+  {}
+]
+`,
+		wantMessage: &pb2.Nests{
+			RptNested: []*pb2.Nested{
+				{
+					OptString: proto.String("repeat nested one"),
+				},
+				{
+					OptString: proto.String("repeat nested two"),
+				},
+				{},
+			},
+		},
+	}, {
+		desc:         "bools",
+		inputMessage: &pb2.Repeats{},
+		inputText: `
+rpt_bool: [ True, true, t, 1, False, false, f, 0 ]
+`,
+		wantMessage: &pb2.Repeats{
+			RptBool: []bool{true, true, true, true, false, false, false, false},
+		},
+	}, {
+		desc:         "special floats and doubles",
+		inputMessage: &pb2.Repeats{},
+		inputText: `
+rpt_float: [ inf, Inf, infinity, InFiniTy, -inf, -inF, -infinitY, -InfinitY, nan, NaN, Nan ],
+rpt_double: [ inf, Inf, infinity, InFiniTy, -inf, -inF, -infinitY, -InfinitY, nan, NaN, Nan ],
+`,
+		wantMessage: &pb2.Repeats{
+			RptFloat: []float32{
+				float32(math.Inf(1)),
+				float32(math.Inf(1)),
+				float32(math.Inf(1)),
+				float32(math.Inf(1)),
+				float32(math.Inf(-1)),
+				float32(math.Inf(-1)),
+				float32(math.Inf(-1)),
+				float32(math.Inf(-1)),
+				float32(math.NaN()),
+				float32(math.NaN()),
+				float32(math.NaN()),
+			},
+			RptDouble: []float64{
+				math.Inf(1),
+				math.Inf(1),
+				math.Inf(1),
+				math.Inf(1),
+				math.Inf(-1),
+				math.Inf(-1),
+				math.Inf(-1),
+				math.Inf(-1),
+				math.NaN(),
+				math.NaN(),
+				math.NaN(),
+			},
+		},
+	}, {
+		desc:         "map fields 1",
+		inputMessage: &pb3.Maps{},
+		inputText: `
+int32_to_str: {
+  key: -101
+  value: "-101"
+}
+int32_to_str {
+  key: 0
+  value: "zero"
+}
+bool_to_uint32: {
+  key: false
+  value: 101
+}
+int32_to_str: {
+  key: 255
+  value: "0xff"
+}
+bool_to_uint32 {
+  key: true
+  value: 42
+}
+`,
+		wantMessage: &pb3.Maps{
+			Int32ToStr: map[int32]string{
+				-101: "-101",
+				0xff: "0xff",
+				0:    "zero",
+			},
+			BoolToUint32: map[bool]uint32{
+				true:  42,
+				false: 101,
+			},
+		},
+	}, {
+		desc:         "map fields 2",
+		inputMessage: &pb3.Maps{},
+		inputText: `
+uint64_to_enum: {
+  key: 1
+  value: ONE
+}
+uint64_to_enum: {
+  key: 2
+  value: 2
+}
+uint64_to_enum: {
+  key: 10
+  value: 101
+}
+`,
+		wantMessage: &pb3.Maps{
+			Uint64ToEnum: map[uint64]pb3.Enum{
+				1:  pb3.Enum_ONE,
+				2:  pb3.Enum_TWO,
+				10: 101,
+			},
+		},
+	}, {
+		desc:         "map fields 3",
+		inputMessage: &pb3.Maps{},
+		inputText: `
+str_to_nested: {
+  key: "nested_one"
+  value {
+    s_string: "nested in a map"
+  }
+}
+`,
+		wantMessage: &pb3.Maps{
+			StrToNested: map[string]*pb3.Nested{
+				"nested_one": &pb3.Nested{
+					SString: "nested in a map",
+				},
+			},
+		},
+	}, {
+		desc:         "map fields 4",
+		inputMessage: &pb3.Maps{},
+		inputText: `
+str_to_oneofs: {
+  key: "nested"
+  value: {
+    oneof_nested: {
+      s_string: "nested oneof in map field value"
+    }
+  }
+}
+str_to_oneofs: {
+  key: "string"
+  value: {
+    oneof_string: "hello"
+  }
+}
+`,
+		wantMessage: &pb3.Maps{
+			StrToOneofs: map[string]*pb3.Oneofs{
+				"string": &pb3.Oneofs{
+					Union: &pb3.Oneofs_OneofString{
+						OneofString: "hello",
+					},
+				},
+				"nested": &pb3.Oneofs{
+					Union: &pb3.Oneofs_OneofNested{
+						OneofNested: &pb3.Nested{
+							SString: "nested oneof in map field value",
+						},
+					},
+				},
+			},
+		},
+	}, {
+		desc:         "map contains duplicate keys",
+		inputMessage: &pb3.Maps{},
+		inputText: `
+int32_to_str: {
+  key: 0
+  value: "cero"
+}
+int32_to_str: {
+  key: 0
+  value: "zero"
+}
+`,
+		wantMessage: &pb3.Maps{
+			Int32ToStr: map[int32]string{
+				0: "zero",
+			},
+		},
+	}, {
+		desc:         "map contains duplicate key fields",
+		inputMessage: &pb3.Maps{},
+		inputText: `
+int32_to_str: {
+  key: 0
+  key: 1
+  value: "cero"
+}
+`,
+		wantErr: `map entry "key" cannot be repeated`,
+	}, {
+		desc:         "map contains duplicate value fields",
+		inputMessage: &pb3.Maps{},
+		inputText: `
+int32_to_str: {
+  key: 1
+  value: "cero"
+  value: "uno"
+}
+`,
+		wantErr: `map entry "value" cannot be repeated`,
+	}, {
+		desc:         "map contains missing key",
+		inputMessage: &pb3.Maps{},
+		inputText: `
+int32_to_str: {
+  value: "zero"
+}
+bool_to_uint32: {
+  value: 47
+}
+str_to_nested: {
+  value: {}
+}
+`,
+		wantMessage: &pb3.Maps{
+			Int32ToStr: map[int32]string{
+				0: "zero",
+			},
+			BoolToUint32: map[bool]uint32{
+				false: 47,
+			},
+			StrToNested: map[string]*pb3.Nested{
+				"": {},
+			},
+		},
+	}, {
+		desc:         "map contains missing value",
+		inputMessage: &pb3.Maps{},
+		inputText: `
+int32_to_str: {
+  key: 100
+}
+bool_to_uint32: {
+  key: true
+}
+uint64_to_enum: {
+  key: 101
+}
+str_to_nested: {
+  key: "hello"
+}
+`,
+		wantMessage: &pb3.Maps{
+			Int32ToStr: map[int32]string{
+				100: "",
+			},
+			BoolToUint32: map[bool]uint32{
+				true: 0,
+			},
+			Uint64ToEnum: map[uint64]pb3.Enum{
+				101: pb3.Enum_ZERO,
+			},
+			StrToNested: map[string]*pb3.Nested{
+				"hello": {},
+			},
+		},
+	}, {
+		desc:         "map contains missing key and value",
+		inputMessage: &pb3.Maps{},
+		inputText: `
+int32_to_str: {}
+bool_to_uint32: {}
+uint64_to_enum: {}
+str_to_nested: {}
+`,
+		wantMessage: &pb3.Maps{
+			Int32ToStr: map[int32]string{
+				0: "",
+			},
+			BoolToUint32: map[bool]uint32{
+				false: 0,
+			},
+			Uint64ToEnum: map[uint64]pb3.Enum{
+				0: pb3.Enum_ZERO,
+			},
+			StrToNested: map[string]*pb3.Nested{
+				"": {},
+			},
+		},
+	}, {
+		desc:         "map contains overriding entries",
+		inputMessage: &pb3.Maps{},
+		inputText: `
+int32_to_str: {
+  key: 0
+}
+int32_to_str: {
+  value: "empty"
+}
+int32_to_str: {}
+`,
+		wantMessage: &pb3.Maps{
+			Int32ToStr: map[int32]string{
+				0: "",
+			},
+		},
+	}, {
+		desc:         "proto2 map field value contains invalid UTF-8",
+		inputMessage: &pb2.Maps{},
+		inputText: `int32_to_str: {
+  key: 101
+  value: "abc\xff"
+}
+`,
+		wantMessage: &pb2.Maps{
+			Int32ToStr: map[int32]string{101: "abc\xff"},
+		},
+	}, {
+		desc:         "proto2 map field key contains invalid UTF-8",
+		inputMessage: &pb2.Maps{},
+		inputText: `str_to_nested: {
+  key: "abc\xff"
+  value: {}
+}
+`,
+		wantMessage: &pb2.Maps{
+			StrToNested: map[string]*pb2.Nested{"abc\xff": {}},
+		},
+	}, {
+		desc:         "proto3 map field value contains invalid UTF-8",
+		inputMessage: &pb3.Maps{},
+		inputText: `int32_to_str: {
+  key: 101
+  value: "abc\xff"
+}
+`,
+		wantErr: "contains invalid UTF-8",
+	}, {
+		desc:         "proto3 map field key contains invalid UTF-8",
+		inputMessage: &pb3.Maps{},
+		inputText: `str_to_nested: {
+  key: "abc\xff"
+  value: {}
+}
+`,
+		wantErr: "contains invalid UTF-8",
+	}, {
+		desc:         "map contains unknown field",
+		inputMessage: &pb3.Maps{},
+		inputText: `
+int32_to_str: {
+  key: 0
+  value: "cero"
+  unknown: "bad"
+}
+`,
+		wantErr: `(line 5:3): unknown map entry field "unknown"`,
+	}, {
+		desc:         "map contains extension-like key field",
+		inputMessage: &pb3.Maps{},
+		inputText: `
+int32_to_str: {
+  [key]: 10
+  value: "ten"
+}
+`,
+		wantErr: `unknown map entry field "[key]"`,
+	}, {
+		desc:         "map contains invalid key",
+		inputMessage: &pb3.Maps{},
+		inputText: `
+int32_to_str: {
+  key: "invalid"
+  value: "cero"
+}
+`,
+		wantErr: "(line 3:8): invalid value for int32 type",
+	}, {
+		desc:         "map contains invalid value",
+		inputMessage: &pb3.Maps{},
+		inputText: `
+int32_to_str: {
+  key: 100
+  value: 101
+}
+`,
+		wantErr: "(line 4:10): invalid value for string type",
+	}, {
+		desc:         "map contains invalid message value",
+		inputMessage: &pb3.Maps{},
+		inputText: `
+str_to_nested: {
+  key: "one"
+  value: 1
+}
+`,
+		wantErr: "syntax error (line 4:10): unexpected token: 1",
+	}, {
+		desc:         "map using mix of [] and repeated",
+		inputMessage: &pb3.Maps{},
+		inputText: `
+int32_to_str: {
+  key: 1
+  value: "one"
+}
+int32_to_str: [
+  {
+    key: 2
+    value: "not this"
+  },
+  {
+  },
+  {
+    key: 3
+    value: "three"
+  }
+]
+int32_to_str: {
+  key: 2
+  value: "two"
+}
+`,
+		wantMessage: &pb3.Maps{
+			Int32ToStr: map[int32]string{
+				0: "",
+				1: "one",
+				2: "two",
+				3: "three",
+			},
+		},
+	}, {
+		desc:         "required fields not set",
+		inputMessage: &pb2.Requireds{},
+		wantErr:      "required field",
+	}, {
+		desc:         "required field set",
+		inputMessage: &pb2.PartialRequired{},
+		inputText:    "req_string: 'this is required'",
+		wantMessage: &pb2.PartialRequired{
+			ReqString: proto.String("this is required"),
+		},
+	}, {
+		desc:         "required fields partially set",
+		inputMessage: &pb2.Requireds{},
+		inputText: `
+req_bool: false
+req_sfixed64: 3203386110
+req_string: "hello"
+req_enum: ONE
+`,
+		wantMessage: &pb2.Requireds{
+			ReqBool:     proto.Bool(false),
+			ReqSfixed64: proto.Int64(0xbeefcafe),
+			ReqString:   proto.String("hello"),
+			ReqEnum:     pb2.Enum_ONE.Enum(),
+		},
+		wantErr: "required field",
+	}, {
+		desc:         "required fields partially set with AllowPartial",
+		umo:          prototext.UnmarshalOptions{AllowPartial: true},
+		inputMessage: &pb2.Requireds{},
+		inputText: `
+req_bool: false
+req_sfixed64: 3203386110
+req_string: "hello"
+req_enum: ONE
+`,
+		wantMessage: &pb2.Requireds{
+			ReqBool:     proto.Bool(false),
+			ReqSfixed64: proto.Int64(0xbeefcafe),
+			ReqString:   proto.String("hello"),
+			ReqEnum:     pb2.Enum_ONE.Enum(),
+		},
+	}, {
+		desc:         "required fields all set",
+		inputMessage: &pb2.Requireds{},
+		inputText: `
+req_bool: false
+req_sfixed64: 0
+req_double: 0
+req_string: ""
+req_enum: ONE
+req_nested: {}
+`,
+		wantMessage: &pb2.Requireds{
+			ReqBool:     proto.Bool(false),
+			ReqSfixed64: proto.Int64(0),
+			ReqDouble:   proto.Float64(0),
+			ReqString:   proto.String(""),
+			ReqEnum:     pb2.Enum_ONE.Enum(),
+			ReqNested:   &pb2.Nested{},
+		},
+	}, {
+		desc:         "indirect required field",
+		inputMessage: &pb2.IndirectRequired{},
+		inputText:    "opt_nested: {}",
+		wantMessage: &pb2.IndirectRequired{
+			OptNested: &pb2.NestedWithRequired{},
+		},
+		wantErr: "required field",
+	}, {
+		desc:         "indirect required field with AllowPartial",
+		umo:          prototext.UnmarshalOptions{AllowPartial: true},
+		inputMessage: &pb2.IndirectRequired{},
+		inputText:    "opt_nested: {}",
+		wantMessage: &pb2.IndirectRequired{
+			OptNested: &pb2.NestedWithRequired{},
+		},
+	}, {
+		desc:         "indirect required field in repeated",
+		inputMessage: &pb2.IndirectRequired{},
+		inputText: `
+rpt_nested: {
+  req_string: "one"
+}
+rpt_nested: {}
+`,
+		wantMessage: &pb2.IndirectRequired{
+			RptNested: []*pb2.NestedWithRequired{
+				{
+					ReqString: proto.String("one"),
+				},
+				{},
+			},
+		},
+		wantErr: "required field",
+	}, {
+		desc:         "indirect required field in repeated with AllowPartial",
+		umo:          prototext.UnmarshalOptions{AllowPartial: true},
+		inputMessage: &pb2.IndirectRequired{},
+		inputText: `
+rpt_nested: {
+  req_string: "one"
+}
+rpt_nested: {}
+`,
+		wantMessage: &pb2.IndirectRequired{
+			RptNested: []*pb2.NestedWithRequired{
+				{
+					ReqString: proto.String("one"),
+				},
+				{},
+			},
+		},
+	}, {
+		desc:         "indirect required field in map",
+		inputMessage: &pb2.IndirectRequired{},
+		inputText: `
+str_to_nested: {
+  key: "missing"
+}
+str_to_nested: {
+  key: "contains"
+  value: {
+    req_string: "here"
+  }
+}
+`,
+		wantMessage: &pb2.IndirectRequired{
+			StrToNested: map[string]*pb2.NestedWithRequired{
+				"missing": &pb2.NestedWithRequired{},
+				"contains": &pb2.NestedWithRequired{
+					ReqString: proto.String("here"),
+				},
+			},
+		},
+		wantErr: "required field",
+	}, {
+		desc:         "indirect required field in map with AllowPartial",
+		umo:          prototext.UnmarshalOptions{AllowPartial: true},
+		inputMessage: &pb2.IndirectRequired{},
+		inputText: `
+str_to_nested: {
+  key: "missing"
+}
+str_to_nested: {
+  key: "contains"
+  value: {
+    req_string: "here"
+  }
+}
+`,
+		wantMessage: &pb2.IndirectRequired{
+			StrToNested: map[string]*pb2.NestedWithRequired{
+				"missing": &pb2.NestedWithRequired{},
+				"contains": &pb2.NestedWithRequired{
+					ReqString: proto.String("here"),
+				},
+			},
+		},
+	}, {
+		desc:         "indirect required field in oneof",
+		inputMessage: &pb2.IndirectRequired{},
+		inputText: `oneof_nested: {}
+`,
+		wantMessage: &pb2.IndirectRequired{
+			Union: &pb2.IndirectRequired_OneofNested{
+				OneofNested: &pb2.NestedWithRequired{},
+			},
+		},
+		wantErr: "required field",
+	}, {
+		desc:         "indirect required field in oneof with AllowPartial",
+		umo:          prototext.UnmarshalOptions{AllowPartial: true},
+		inputMessage: &pb2.IndirectRequired{},
+		inputText: `oneof_nested: {}
+`,
+		wantMessage: &pb2.IndirectRequired{
+			Union: &pb2.IndirectRequired_OneofNested{
+				OneofNested: &pb2.NestedWithRequired{},
+			},
+		},
+	}, {
+		desc:         "ignore reserved field",
+		inputMessage: &pb2.Nests{},
+		inputText:    "reserved_field: 'ignore this'",
+		wantMessage:  &pb2.Nests{},
+	}, {
+		desc:         "extensions of non-repeated fields",
+		inputMessage: &pb2.Extensions{},
+		inputText: `opt_string: "non-extension field"
+[pb2.opt_ext_bool]: true
+opt_bool: true
+[pb2.opt_ext_nested]: {
+  opt_string: "nested in an extension"
+  opt_nested: {
+    opt_string: "another nested in an extension"
+  }
+}
+[pb2.opt_ext_string]: "extension field"
+opt_int32: 42
+[pb2.opt_ext_enum]: TEN
+`,
+		wantMessage: func() proto.Message {
+			m := &pb2.Extensions{
+				OptString: proto.String("non-extension field"),
+				OptBool:   proto.Bool(true),
+				OptInt32:  proto.Int32(42),
+			}
+			proto.SetExtension(m, pb2.E_OptExtBool, true)
+			proto.SetExtension(m, pb2.E_OptExtString, "extension field")
+			proto.SetExtension(m, pb2.E_OptExtEnum, pb2.Enum_TEN)
+			proto.SetExtension(m, pb2.E_OptExtNested, &pb2.Nested{
+				OptString: proto.String("nested in an extension"),
+				OptNested: &pb2.Nested{
+					OptString: proto.String("another nested in an extension"),
+				},
+			})
+			return m
+		}(),
+	}, {
+		desc:         "extension field contains invalid UTF-8",
+		inputMessage: &pb2.Extensions{},
+		inputText:    `[pb2.opt_ext_string]: "abc\xff"`,
+		wantMessage: func() proto.Message {
+			m := &pb2.Extensions{}
+			proto.SetExtension(m, pb2.E_OptExtString, "abc\xff")
+			return m
+		}(),
+	}, {
+		desc:         "extensions of repeated fields",
+		inputMessage: &pb2.Extensions{},
+		inputText: `[pb2.rpt_ext_enum]: TEN
+[pb2.rpt_ext_enum]: 101
+[pb2.rpt_ext_fixed32]: 42
+[pb2.rpt_ext_enum]: ONE
+[pb2.rpt_ext_nested]: {
+  opt_string: "one"
+}
+[pb2.rpt_ext_nested]: {
+  opt_string: "two"
+}
+[pb2.rpt_ext_fixed32]: 47
+[pb2.rpt_ext_nested]: {
+  opt_string: "three"
+}
+`,
+		wantMessage: func() proto.Message {
+			m := &pb2.Extensions{}
+			proto.SetExtension(m, pb2.E_RptExtEnum, []pb2.Enum{pb2.Enum_TEN, 101, pb2.Enum_ONE})
+			proto.SetExtension(m, pb2.E_RptExtFixed32, []uint32{42, 47})
+			proto.SetExtension(m, pb2.E_RptExtNested, []*pb2.Nested{
+				&pb2.Nested{OptString: proto.String("one")},
+				&pb2.Nested{OptString: proto.String("two")},
+				&pb2.Nested{OptString: proto.String("three")},
+			})
+			return m
+		}(),
+	}, {
+		desc:         "extensions of non-repeated fields in another message",
+		inputMessage: &pb2.Extensions{},
+		inputText: `[pb2.ExtensionsContainer.opt_ext_bool]: true
+[pb2.ExtensionsContainer.opt_ext_enum]: TEN
+[pb2.ExtensionsContainer.opt_ext_nested]: {
+  opt_string: "nested in an extension"
+  opt_nested: {
+    opt_string: "another nested in an extension"
+  }
+}
+[pb2.ExtensionsContainer.opt_ext_string]: "extension field"
+`,
+		wantMessage: func() proto.Message {
+			m := &pb2.Extensions{}
+			proto.SetExtension(m, pb2.E_ExtensionsContainer_OptExtBool, true)
+			proto.SetExtension(m, pb2.E_ExtensionsContainer_OptExtString, "extension field")
+			proto.SetExtension(m, pb2.E_ExtensionsContainer_OptExtEnum, pb2.Enum_TEN)
+			proto.SetExtension(m, pb2.E_ExtensionsContainer_OptExtNested, &pb2.Nested{
+				OptString: proto.String("nested in an extension"),
+				OptNested: &pb2.Nested{
+					OptString: proto.String("another nested in an extension"),
+				},
+			})
+			return m
+		}(),
+	}, {
+		desc:         "extensions of repeated fields in another message",
+		inputMessage: &pb2.Extensions{},
+		inputText: `opt_string: "non-extension field"
+opt_bool: true
+opt_int32: 42
+[pb2.ExtensionsContainer.rpt_ext_nested]: {
+  opt_string: "one"
+}
+[pb2.ExtensionsContainer.rpt_ext_enum]: TEN
+[pb2.ExtensionsContainer.rpt_ext_nested]: {
+  opt_string: "two"
+}
+[pb2.ExtensionsContainer.rpt_ext_enum]: 101
+[pb2.ExtensionsContainer.rpt_ext_string]: "hello"
+[pb2.ExtensionsContainer.rpt_ext_enum]: ONE
+[pb2.ExtensionsContainer.rpt_ext_nested]: {
+  opt_string: "three"
+}
+[pb2.ExtensionsContainer.rpt_ext_string]: "world"
+`,
+		wantMessage: func() proto.Message {
+			m := &pb2.Extensions{
+				OptString: proto.String("non-extension field"),
+				OptBool:   proto.Bool(true),
+				OptInt32:  proto.Int32(42),
+			}
+			proto.SetExtension(m, pb2.E_ExtensionsContainer_RptExtEnum, []pb2.Enum{pb2.Enum_TEN, 101, pb2.Enum_ONE})
+			proto.SetExtension(m, pb2.E_ExtensionsContainer_RptExtString, []string{"hello", "world"})
+			proto.SetExtension(m, pb2.E_ExtensionsContainer_RptExtNested, []*pb2.Nested{
+				&pb2.Nested{OptString: proto.String("one")},
+				&pb2.Nested{OptString: proto.String("two")},
+				&pb2.Nested{OptString: proto.String("three")},
+			})
+			return m
+		}(),
+	}, {
+		desc:         "invalid extension field name",
+		inputMessage: &pb2.Extensions{},
+		inputText:    "[pb2.invalid_message_field]: true",
+		wantErr:      "unknown field",
+	}, {
+		desc:         "MessageSet",
+		inputMessage: &pb2.MessageSet{},
+		inputText: `
+[pb2.MessageSetExtension]: {
+  opt_string: "a messageset extension"
+}
+[pb2.MessageSetExtension.ext_nested]: {
+  opt_string: "just a regular extension"
+}
+[pb2.MessageSetExtension.not_message_set_extension]: {
+  opt_string: "not a messageset extension"
+}
+`,
+		wantMessage: func() proto.Message {
+			m := &pb2.MessageSet{}
+			proto.SetExtension(m, pb2.E_MessageSetExtension_MessageSetExtension, &pb2.MessageSetExtension{
+				OptString: proto.String("a messageset extension"),
+			})
+			proto.SetExtension(m, pb2.E_MessageSetExtension_NotMessageSetExtension, &pb2.MessageSetExtension{
+				OptString: proto.String("not a messageset extension"),
+			})
+			proto.SetExtension(m, pb2.E_MessageSetExtension_ExtNested, &pb2.Nested{
+				OptString: proto.String("just a regular extension"),
+			})
+			return m
+		}(),
+		skip: !flags.ProtoLegacy,
+	}, {
+		desc:         "not real MessageSet 1",
+		inputMessage: &pb2.FakeMessageSet{},
+		inputText: `
+[pb2.FakeMessageSetExtension.message_set_extension]: {
+  opt_string: "not a messageset extension"
+}
+`,
+		wantMessage: func() proto.Message {
+			m := &pb2.FakeMessageSet{}
+			proto.SetExtension(m, pb2.E_FakeMessageSetExtension_MessageSetExtension, &pb2.FakeMessageSetExtension{
+				OptString: proto.String("not a messageset extension"),
+			})
+			return m
+		}(),
+		skip: !flags.ProtoLegacy,
+	}, {
+		desc:         "not real MessageSet 2",
+		inputMessage: &pb2.FakeMessageSet{},
+		inputText: `
+[pb2.FakeMessageSetExtension]: {
+  opt_string: "not a messageset extension"
+}
+`,
+		wantErr: "unknown field: [pb2.FakeMessageSetExtension]",
+		skip:    !flags.ProtoLegacy,
+	}, {
+		desc:         "not real MessageSet 3",
+		inputMessage: &pb2.MessageSet{},
+		inputText: `
+[pb2.message_set_extension]: {
+  opt_string: "another not a messageset extension"
+}`,
+		wantMessage: func() proto.Message {
+			m := &pb2.MessageSet{}
+			proto.SetExtension(m, pb2.E_MessageSetExtension, &pb2.FakeMessageSetExtension{
+				OptString: proto.String("another not a messageset extension"),
+			})
+			return m
+		}(),
+		skip: !flags.ProtoLegacy,
+	}, {
+		desc:         "Any not expanded",
+		inputMessage: &anypb.Any{},
+		inputText: `
+type_url: "pb2.Nested"
+value: "some bytes"
+`,
+		wantMessage: &anypb.Any{
+			TypeUrl: "pb2.Nested",
+			Value:   []byte("some bytes"),
+		},
+	}, {
+		desc:         "Any not expanded missing value",
+		inputMessage: &anypb.Any{},
+		inputText:    `type_url: "pb2.Nested"`,
+		wantMessage: &anypb.Any{
+			TypeUrl: "pb2.Nested",
+		},
+	}, {
+		desc:         "Any not expanded missing type_url",
+		inputMessage: &anypb.Any{},
+		inputText:    `value: "some bytes"`,
+		wantMessage: &anypb.Any{
+			Value: []byte("some bytes"),
+		},
+	}, {
+		desc:         "Any expanded",
+		inputMessage: &anypb.Any{},
+		inputText: `
+[foobar/pb2.Nested]: {
+  opt_string: "embedded inside Any"
+  opt_nested: {
+    opt_string: "inception"
+  }
+}
+`,
+		wantMessage: func() proto.Message {
+			m := &pb2.Nested{
+				OptString: proto.String("embedded inside Any"),
+				OptNested: &pb2.Nested{
+					OptString: proto.String("inception"),
+				},
+			}
+			b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			return &anypb.Any{
+				TypeUrl: "foobar/pb2.Nested",
+				Value:   b,
+			}
+		}(),
+	}, {
+		desc:         "Any expanded with empty value",
+		inputMessage: &anypb.Any{},
+		inputText:    `[foo.com/pb2.Nested]: {}`,
+		wantMessage: &anypb.Any{
+			TypeUrl: "foo.com/pb2.Nested",
+		},
+	}, {
+		desc:         "Any expanded with missing required",
+		inputMessage: &anypb.Any{},
+		inputText: `
+[pb2.PartialRequired]: {
+  opt_string: "embedded inside Any"
+}
+`,
+		wantMessage: func() proto.Message {
+			m := &pb2.PartialRequired{
+				OptString: proto.String("embedded inside Any"),
+			}
+			b, err := proto.MarshalOptions{
+				AllowPartial:  true,
+				Deterministic: true,
+			}.Marshal(m)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			return &anypb.Any{
+				TypeUrl: "pb2.PartialRequired",
+				Value:   b,
+			}
+		}(),
+	}, {
+		desc:         "Any with invalid UTF-8",
+		inputMessage: &anypb.Any{},
+		inputText: `
+[pb3.Nested]: {
+  s_string: "abc\xff"
+}
+`,
+		wantErr: "contains invalid UTF-8",
+	}, {
+		desc:         "Any expanded with unregistered type",
+		umo:          prototext.UnmarshalOptions{Resolver: new(preg.Types)},
+		inputMessage: &anypb.Any{},
+		inputText:    `[SomeMessage]: {}`,
+		wantErr:      "unable to resolve message [SomeMessage]",
+	}, {
+		desc:         "Any expanded with invalid value",
+		inputMessage: &anypb.Any{},
+		inputText:    `[pb2.Nested]: 123`,
+		wantErr:      "unexpected token: 123",
+	}, {
+		desc:         "Any expanded with unknown fields",
+		inputMessage: &anypb.Any{},
+		inputText: `
+[pb2.Nested]: {}
+unknown: ""
+`,
+		wantErr: `invalid field name "unknown" in google.protobuf.Any message`,
+	}, {
+		desc:         "Any contains expanded and unexpanded fields",
+		inputMessage: &anypb.Any{},
+		inputText: `
+[pb2.Nested]: {}
+type_url: "pb2.Nested"
+`,
+		wantErr: "(line 3:1): conflict with [pb2.Nested] field",
+	}, {
+		desc:         "weak fields",
+		inputMessage: &testpb.TestWeak{},
+		inputText:    `weak_message1:{a:1}`,
+		wantMessage: func() *testpb.TestWeak {
+			m := new(testpb.TestWeak)
+			m.SetWeakMessage1(&weakpb.WeakImportMessage1{A: proto.Int32(1)})
+			return m
+		}(),
+		skip: !flags.ProtoLegacy,
+	}, {
+		desc:         "weak fields; unknown field",
+		inputMessage: &testpb.TestWeak{},
+		inputText:    `weak_message1:{a:1} weak_message2:{a:1}`,
+		wantErr:      "unknown field: weak_message2", // weak_message2 is unknown since the package containing it is not imported
+		skip:         !flags.ProtoLegacy,
+	}}
+
+	for _, tt := range tests {
+		tt := tt
+		if tt.skip {
+			continue
+		}
+		t.Run(tt.desc, func(t *testing.T) {
+			err := tt.umo.Unmarshal([]byte(tt.inputText), tt.inputMessage)
+			if err != nil {
+				if tt.wantErr == "" {
+					t.Errorf("Unmarshal() got unexpected error: %v", err)
+				} else if !strings.Contains(err.Error(), tt.wantErr) {
+					t.Errorf("Unmarshal() error got %q, want %q", err, tt.wantErr)
+				}
+				return
+			}
+			if tt.wantErr != "" {
+				t.Errorf("Unmarshal() got nil error, want error %q", tt.wantErr)
+				return
+			}
+			if tt.wantMessage != nil && !proto.Equal(tt.inputMessage, tt.wantMessage) {
+				t.Errorf("Unmarshal()\n<got>\n%v\n<want>\n%v\n", tt.inputMessage, tt.wantMessage)
+			}
+		})
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/encoding/prototext/doc.go b/vendor/google.golang.org/protobuf/encoding/prototext/doc.go
new file mode 100644
index 000000000..162b4f98a
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/encoding/prototext/doc.go
@@ -0,0 +1,7 @@
+// Copyright 2019 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 prototext marshals and unmarshals protocol buffer messages as the
+// textproto format.
+package prototext
diff --git a/vendor/google.golang.org/protobuf/encoding/prototext/encode.go b/vendor/google.golang.org/protobuf/encoding/prototext/encode.go
new file mode 100644
index 000000000..dece22973
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/encoding/prototext/encode.go
@@ -0,0 +1,426 @@
+// 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 prototext
+
+import (
+	"fmt"
+	"sort"
+	"strconv"
+	"unicode/utf8"
+
+	"google.golang.org/protobuf/encoding/protowire"
+	"google.golang.org/protobuf/internal/encoding/messageset"
+	"google.golang.org/protobuf/internal/encoding/text"
+	"google.golang.org/protobuf/internal/errors"
+	"google.golang.org/protobuf/internal/fieldnum"
+	"google.golang.org/protobuf/internal/flags"
+	"google.golang.org/protobuf/internal/mapsort"
+	"google.golang.org/protobuf/internal/pragma"
+	"google.golang.org/protobuf/internal/strs"
+	"google.golang.org/protobuf/proto"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/reflect/protoregistry"
+)
+
+const defaultIndent = "  "
+
+// Format formats the message as a multiline string.
+// This function is only intended for human consumption and ignores errors.
+// Do not depend on the output being stable. It may change over time across
+// different versions of the program.
+func Format(m proto.Message) string {
+	return MarshalOptions{Multiline: true}.Format(m)
+}
+
+// Marshal writes the given proto.Message in textproto format using default
+// options. Do not depend on the output being stable. It may change over time
+// across different versions of the program.
+func Marshal(m proto.Message) ([]byte, error) {
+	return MarshalOptions{}.Marshal(m)
+}
+
+// MarshalOptions is a configurable text format marshaler.
+type MarshalOptions struct {
+	pragma.NoUnkeyedLiterals
+
+	// Multiline specifies whether the marshaler should format the output in
+	// indented-form with every textual element on a new line.
+	// If Indent is an empty string, then an arbitrary indent is chosen.
+	Multiline bool
+
+	// Indent specifies the set of indentation characters to use in a multiline
+	// formatted output such that every entry is preceded by Indent and
+	// terminated by a newline. If non-empty, then Multiline is treated as true.
+	// Indent can only be composed of space or tab characters.
+	Indent string
+
+	// EmitASCII specifies whether to format strings and bytes as ASCII only
+	// as opposed to using UTF-8 encoding when possible.
+	EmitASCII bool
+
+	// allowInvalidUTF8 specifies whether to permit the encoding of strings
+	// with invalid UTF-8. This is unexported as it is intended to only
+	// be specified by the Format method.
+	allowInvalidUTF8 bool
+
+	// AllowPartial allows messages that have missing required fields to marshal
+	// without returning an error. If AllowPartial is false (the default),
+	// Marshal will return error if there are any missing required fields.
+	AllowPartial bool
+
+	// EmitUnknown specifies whether to emit unknown fields in the output.
+	// If specified, the unmarshaler may be unable to parse the output.
+	// The default is to exclude unknown fields.
+	EmitUnknown bool
+
+	// Resolver is used for looking up types when expanding google.protobuf.Any
+	// messages. If nil, this defaults to using protoregistry.GlobalTypes.
+	Resolver interface {
+		protoregistry.ExtensionTypeResolver
+		protoregistry.MessageTypeResolver
+	}
+}
+
+// Format formats the message as a string.
+// This method is only intended for human consumption and ignores errors.
+// Do not depend on the output being stable. It may change over time across
+// different versions of the program.
+func (o MarshalOptions) Format(m proto.Message) string {
+	if m == nil || !m.ProtoReflect().IsValid() {
+		return "<nil>" // invalid syntax, but okay since this is for debugging
+	}
+	o.allowInvalidUTF8 = true
+	o.AllowPartial = true
+	o.EmitUnknown = true
+	b, _ := o.Marshal(m)
+	return string(b)
+}
+
+// Marshal writes the given proto.Message in textproto format using options in
+// MarshalOptions object. Do not depend on the output being stable. It may
+// change over time across different versions of the program.
+func (o MarshalOptions) Marshal(m proto.Message) ([]byte, error) {
+	var delims = [2]byte{'{', '}'}
+
+	if o.Multiline && o.Indent == "" {
+		o.Indent = defaultIndent
+	}
+	if o.Resolver == nil {
+		o.Resolver = protoregistry.GlobalTypes
+	}
+
+	internalEnc, err := text.NewEncoder(o.Indent, delims, o.EmitASCII)
+	if err != nil {
+		return nil, err
+	}
+
+	// Treat nil message interface as an empty message,
+	// in which case there is nothing to output.
+	if m == nil {
+		return []byte{}, nil
+	}
+
+	enc := encoder{internalEnc, o}
+	err = enc.marshalMessage(m.ProtoReflect(), false)
+	if err != nil {
+		return nil, err
+	}
+	out := enc.Bytes()
+	if len(o.Indent) > 0 && len(out) > 0 {
+		out = append(out, '\n')
+	}
+	if o.AllowPartial {
+		return out, nil
+	}
+	return out, proto.CheckInitialized(m)
+}
+
+type encoder struct {
+	*text.Encoder
+	opts MarshalOptions
+}
+
+// marshalMessage marshals the given protoreflect.Message.
+func (e encoder) marshalMessage(m pref.Message, inclDelims bool) error {
+	messageDesc := m.Descriptor()
+	if !flags.ProtoLegacy && messageset.IsMessageSet(messageDesc) {
+		return errors.New("no support for proto1 MessageSets")
+	}
+
+	if inclDelims {
+		e.StartMessage()
+		defer e.EndMessage()
+	}
+
+	// Handle Any expansion.
+	if messageDesc.FullName() == "google.protobuf.Any" {
+		if e.marshalAny(m) {
+			return nil
+		}
+		// If unable to expand, continue on to marshal Any as a regular message.
+	}
+
+	// Marshal known fields.
+	fieldDescs := messageDesc.Fields()
+	size := fieldDescs.Len()
+	for i := 0; i < size; {
+		fd := fieldDescs.Get(i)
+		if od := fd.ContainingOneof(); od != nil {
+			fd = m.WhichOneof(od)
+			i += od.Fields().Len()
+		} else {
+			i++
+		}
+
+		if fd == nil || !m.Has(fd) {
+			continue
+		}
+
+		name := fd.Name()
+		// Use type name for group field name.
+		if fd.Kind() == pref.GroupKind {
+			name = fd.Message().Name()
+		}
+		val := m.Get(fd)
+		if err := e.marshalField(string(name), val, fd); err != nil {
+			return err
+		}
+	}
+
+	// Marshal extensions.
+	if err := e.marshalExtensions(m); err != nil {
+		return err
+	}
+
+	// Marshal unknown fields.
+	if e.opts.EmitUnknown {
+		e.marshalUnknown(m.GetUnknown())
+	}
+
+	return nil
+}
+
+// marshalField marshals the given field with protoreflect.Value.
+func (e encoder) marshalField(name string, val pref.Value, fd pref.FieldDescriptor) error {
+	switch {
+	case fd.IsList():
+		return e.marshalList(name, val.List(), fd)
+	case fd.IsMap():
+		return e.marshalMap(name, val.Map(), fd)
+	default:
+		e.WriteName(name)
+		return e.marshalSingular(val, fd)
+	}
+}
+
+// marshalSingular marshals the given non-repeated field value. This includes
+// all scalar types, enums, messages, and groups.
+func (e encoder) marshalSingular(val pref.Value, fd pref.FieldDescriptor) error {
+	kind := fd.Kind()
+	switch kind {
+	case pref.BoolKind:
+		e.WriteBool(val.Bool())
+
+	case pref.StringKind:
+		s := val.String()
+		if !e.opts.allowInvalidUTF8 && strs.EnforceUTF8(fd) && !utf8.ValidString(s) {
+			return errors.InvalidUTF8(string(fd.FullName()))
+		}
+		e.WriteString(s)
+
+	case pref.Int32Kind, pref.Int64Kind,
+		pref.Sint32Kind, pref.Sint64Kind,
+		pref.Sfixed32Kind, pref.Sfixed64Kind:
+		e.WriteInt(val.Int())
+
+	case pref.Uint32Kind, pref.Uint64Kind,
+		pref.Fixed32Kind, pref.Fixed64Kind:
+		e.WriteUint(val.Uint())
+
+	case pref.FloatKind:
+		// Encoder.WriteFloat handles the special numbers NaN and infinites.
+		e.WriteFloat(val.Float(), 32)
+
+	case pref.DoubleKind:
+		// Encoder.WriteFloat handles the special numbers NaN and infinites.
+		e.WriteFloat(val.Float(), 64)
+
+	case pref.BytesKind:
+		e.WriteString(string(val.Bytes()))
+
+	case pref.EnumKind:
+		num := val.Enum()
+		if desc := fd.Enum().Values().ByNumber(num); desc != nil {
+			e.WriteLiteral(string(desc.Name()))
+		} else {
+			// Use numeric value if there is no enum description.
+			e.WriteInt(int64(num))
+		}
+
+	case pref.MessageKind, pref.GroupKind:
+		return e.marshalMessage(val.Message(), true)
+
+	default:
+		panic(fmt.Sprintf("%v has unknown kind: %v", fd.FullName(), kind))
+	}
+	return nil
+}
+
+// marshalList marshals the given protoreflect.List as multiple name-value fields.
+func (e encoder) marshalList(name string, list pref.List, fd pref.FieldDescriptor) error {
+	size := list.Len()
+	for i := 0; i < size; i++ {
+		e.WriteName(name)
+		if err := e.marshalSingular(list.Get(i), fd); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// marshalMap marshals the given protoreflect.Map as multiple name-value fields.
+func (e encoder) marshalMap(name string, mmap pref.Map, fd pref.FieldDescriptor) error {
+	var err error
+	mapsort.Range(mmap, fd.MapKey().Kind(), func(key pref.MapKey, val pref.Value) bool {
+		e.WriteName(name)
+		e.StartMessage()
+		defer e.EndMessage()
+
+		e.WriteName("key")
+		err = e.marshalSingular(key.Value(), fd.MapKey())
+		if err != nil {
+			return false
+		}
+
+		e.WriteName("value")
+		err = e.marshalSingular(val, fd.MapValue())
+		if err != nil {
+			return false
+		}
+		return true
+	})
+	return err
+}
+
+// marshalExtensions marshals extension fields.
+func (e encoder) marshalExtensions(m pref.Message) error {
+	type entry struct {
+		key   string
+		value pref.Value
+		desc  pref.FieldDescriptor
+	}
+
+	// Get a sorted list based on field key first.
+	var entries []entry
+	m.Range(func(fd pref.FieldDescriptor, v pref.Value) bool {
+		if !fd.IsExtension() {
+			return true
+		}
+		// For MessageSet extensions, the name used is the parent message.
+		name := fd.FullName()
+		if messageset.IsMessageSetExtension(fd) {
+			name = name.Parent()
+		}
+		entries = append(entries, entry{
+			key:   string(name),
+			value: v,
+			desc:  fd,
+		})
+		return true
+	})
+	// Sort extensions lexicographically.
+	sort.Slice(entries, func(i, j int) bool {
+		return entries[i].key < entries[j].key
+	})
+
+	// Write out sorted list.
+	for _, entry := range entries {
+		// Extension field name is the proto field name enclosed in [].
+		name := "[" + entry.key + "]"
+		if err := e.marshalField(name, entry.value, entry.desc); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// marshalUnknown parses the given []byte and marshals fields out.
+// This function assumes proper encoding in the given []byte.
+func (e encoder) marshalUnknown(b []byte) {
+	const dec = 10
+	const hex = 16
+	for len(b) > 0 {
+		num, wtype, n := protowire.ConsumeTag(b)
+		b = b[n:]
+		e.WriteName(strconv.FormatInt(int64(num), dec))
+
+		switch wtype {
+		case protowire.VarintType:
+			var v uint64
+			v, n = protowire.ConsumeVarint(b)
+			e.WriteUint(v)
+		case protowire.Fixed32Type:
+			var v uint32
+			v, n = protowire.ConsumeFixed32(b)
+			e.WriteLiteral("0x" + strconv.FormatUint(uint64(v), hex))
+		case protowire.Fixed64Type:
+			var v uint64
+			v, n = protowire.ConsumeFixed64(b)
+			e.WriteLiteral("0x" + strconv.FormatUint(v, hex))
+		case protowire.BytesType:
+			var v []byte
+			v, n = protowire.ConsumeBytes(b)
+			e.WriteString(string(v))
+		case protowire.StartGroupType:
+			e.StartMessage()
+			var v []byte
+			v, n = protowire.ConsumeGroup(num, b)
+			e.marshalUnknown(v)
+			e.EndMessage()
+		default:
+			panic(fmt.Sprintf("prototext: error parsing unknown field wire type: %v", wtype))
+		}
+
+		b = b[n:]
+	}
+}
+
+// marshalAny marshals the given google.protobuf.Any message in expanded form.
+// It returns true if it was able to marshal, else false.
+func (e encoder) marshalAny(any pref.Message) bool {
+	// Construct the embedded message.
+	fds := any.Descriptor().Fields()
+	fdType := fds.ByNumber(fieldnum.Any_TypeUrl)
+	typeURL := any.Get(fdType).String()
+	mt, err := e.opts.Resolver.FindMessageByURL(typeURL)
+	if err != nil {
+		return false
+	}
+	m := mt.New().Interface()
+
+	// Unmarshal bytes into embedded message.
+	fdValue := fds.ByNumber(fieldnum.Any_Value)
+	value := any.Get(fdValue)
+	err = proto.UnmarshalOptions{
+		AllowPartial: true,
+		Resolver:     e.opts.Resolver,
+	}.Unmarshal(value.Bytes(), m)
+	if err != nil {
+		return false
+	}
+
+	// Get current encoder position. If marshaling fails, reset encoder output
+	// back to this position.
+	pos := e.Snapshot()
+
+	// Field name is the proto field name enclosed in [].
+	e.WriteName("[" + typeURL + "]")
+	err = e.marshalMessage(m.ProtoReflect(), true)
+	if err != nil {
+		e.Reset(pos)
+		return false
+	}
+	return true
+}
diff --git a/vendor/google.golang.org/protobuf/encoding/prototext/encode_test.go b/vendor/google.golang.org/protobuf/encoding/prototext/encode_test.go
new file mode 100644
index 000000000..4de385cd0
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/encoding/prototext/encode_test.go
@@ -0,0 +1,1437 @@
+// 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 prototext_test
+
+import (
+	"math"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+
+	"google.golang.org/protobuf/encoding/prototext"
+	"google.golang.org/protobuf/internal/detrand"
+	"google.golang.org/protobuf/internal/flags"
+	"google.golang.org/protobuf/proto"
+	preg "google.golang.org/protobuf/reflect/protoregistry"
+	"google.golang.org/protobuf/testing/protopack"
+
+	pb2 "google.golang.org/protobuf/internal/testprotos/textpb2"
+	pb3 "google.golang.org/protobuf/internal/testprotos/textpb3"
+	"google.golang.org/protobuf/types/known/anypb"
+)
+
+func init() {
+	// Disable detrand to enable direct comparisons on outputs.
+	detrand.Disable()
+}
+
+func TestMarshal(t *testing.T) {
+	tests := []struct {
+		desc    string
+		mo      prototext.MarshalOptions
+		input   proto.Message
+		want    string
+		wantErr bool // TODO: Verify error message content.
+		skip    bool
+	}{{
+		desc:  "proto2 optional scalars not set",
+		input: &pb2.Scalars{},
+		want:  "",
+	}, {
+		desc:  "proto3 scalars not set",
+		input: &pb3.Scalars{},
+		want:  "",
+	}, {
+		desc:  "proto3 optional not set",
+		input: &pb3.Proto3Optional{},
+		want:  "",
+	}, {
+		desc: "proto2 optional scalars set to zero values",
+		input: &pb2.Scalars{
+			OptBool:     proto.Bool(false),
+			OptInt32:    proto.Int32(0),
+			OptInt64:    proto.Int64(0),
+			OptUint32:   proto.Uint32(0),
+			OptUint64:   proto.Uint64(0),
+			OptSint32:   proto.Int32(0),
+			OptSint64:   proto.Int64(0),
+			OptFixed32:  proto.Uint32(0),
+			OptFixed64:  proto.Uint64(0),
+			OptSfixed32: proto.Int32(0),
+			OptSfixed64: proto.Int64(0),
+			OptFloat:    proto.Float32(0),
+			OptDouble:   proto.Float64(0),
+			OptBytes:    []byte{},
+			OptString:   proto.String(""),
+		},
+		want: `opt_bool: false
+opt_int32: 0
+opt_int64: 0
+opt_uint32: 0
+opt_uint64: 0
+opt_sint32: 0
+opt_sint64: 0
+opt_fixed32: 0
+opt_fixed64: 0
+opt_sfixed32: 0
+opt_sfixed64: 0
+opt_float: 0
+opt_double: 0
+opt_bytes: ""
+opt_string: ""
+`,
+	}, {
+		desc: "proto3 optional set to zero values",
+		input: &pb3.Proto3Optional{
+			OptBool:    proto.Bool(false),
+			OptInt32:   proto.Int32(0),
+			OptInt64:   proto.Int64(0),
+			OptUint32:  proto.Uint32(0),
+			OptUint64:  proto.Uint64(0),
+			OptFloat:   proto.Float32(0),
+			OptDouble:  proto.Float64(0),
+			OptString:  proto.String(""),
+			OptBytes:   []byte{},
+			OptEnum:    pb3.Enum_ZERO.Enum(),
+			OptMessage: &pb3.Nested{},
+		},
+		want: `opt_bool: false
+opt_int32: 0
+opt_int64: 0
+opt_uint32: 0
+opt_uint64: 0
+opt_float: 0
+opt_double: 0
+opt_string: ""
+opt_bytes: ""
+opt_enum: ZERO
+opt_message: {}
+`,
+	}, {
+		desc: "proto3 scalars set to zero values",
+		input: &pb3.Scalars{
+			SBool:     false,
+			SInt32:    0,
+			SInt64:    0,
+			SUint32:   0,
+			SUint64:   0,
+			SSint32:   0,
+			SSint64:   0,
+			SFixed32:  0,
+			SFixed64:  0,
+			SSfixed32: 0,
+			SSfixed64: 0,
+			SFloat:    0,
+			SDouble:   0,
+			SBytes:    []byte{},
+			SString:   "",
+		},
+		want: "",
+	}, {
+		desc: "proto2 optional scalars set to some values",
+		input: &pb2.Scalars{
+			OptBool:     proto.Bool(true),
+			OptInt32:    proto.Int32(0xff),
+			OptInt64:    proto.Int64(0xdeadbeef),
+			OptUint32:   proto.Uint32(47),
+			OptUint64:   proto.Uint64(0xdeadbeef),
+			OptSint32:   proto.Int32(-1001),
+			OptSint64:   proto.Int64(-0xffff),
+			OptFixed64:  proto.Uint64(64),
+			OptSfixed32: proto.Int32(-32),
+			OptFloat:    proto.Float32(1.02),
+			OptDouble:   proto.Float64(1.0199999809265137),
+			OptBytes:    []byte("\xe8\xb0\xb7\xe6\xad\x8c"),
+			OptString:   proto.String("谷歌"),
+		},
+		want: `opt_bool: true
+opt_int32: 255
+opt_int64: 3735928559
+opt_uint32: 47
+opt_uint64: 3735928559
+opt_sint32: -1001
+opt_sint64: -65535
+opt_fixed64: 64
+opt_sfixed32: -32
+opt_float: 1.02
+opt_double: 1.0199999809265137
+opt_bytes: "谷歌"
+opt_string: "谷歌"
+`,
+	}, {
+		desc: "proto2 string with invalid UTF-8",
+		input: &pb2.Scalars{
+			OptString: proto.String("abc\xff"),
+		},
+		want: `opt_string: "abc\xff"
+`,
+	}, {
+		desc: "proto3 string with invalid UTF-8",
+		input: &pb3.Scalars{
+			SString: "abc\xff",
+		},
+		wantErr: true,
+	}, {
+		desc: "float nan",
+		input: &pb3.Scalars{
+			SFloat: float32(math.NaN()),
+		},
+		want: "s_float: nan\n",
+	}, {
+		desc: "float positive infinity",
+		input: &pb3.Scalars{
+			SFloat: float32(math.Inf(1)),
+		},
+		want: "s_float: inf\n",
+	}, {
+		desc: "float negative infinity",
+		input: &pb3.Scalars{
+			SFloat: float32(math.Inf(-1)),
+		},
+		want: "s_float: -inf\n",
+	}, {
+		desc: "double nan",
+		input: &pb3.Scalars{
+			SDouble: math.NaN(),
+		},
+		want: "s_double: nan\n",
+	}, {
+		desc: "double positive infinity",
+		input: &pb3.Scalars{
+			SDouble: math.Inf(1),
+		},
+		want: "s_double: inf\n",
+	}, {
+		desc: "double negative infinity",
+		input: &pb3.Scalars{
+			SDouble: math.Inf(-1),
+		},
+		want: "s_double: -inf\n",
+	}, {
+		desc:  "proto2 enum not set",
+		input: &pb2.Enums{},
+		want:  "",
+	}, {
+		desc: "proto2 enum set to zero value",
+		input: &pb2.Enums{
+			OptEnum:       pb2.Enum(0).Enum(),
+			OptNestedEnum: pb2.Enums_NestedEnum(0).Enum(),
+		},
+		want: `opt_enum: 0
+opt_nested_enum: 0
+`,
+	}, {
+		desc: "proto2 enum",
+		input: &pb2.Enums{
+			OptEnum:       pb2.Enum_ONE.Enum(),
+			OptNestedEnum: pb2.Enums_UNO.Enum(),
+		},
+		want: `opt_enum: ONE
+opt_nested_enum: UNO
+`,
+	}, {
+		desc: "proto2 enum set to numeric values",
+		input: &pb2.Enums{
+			OptEnum:       pb2.Enum(2).Enum(),
+			OptNestedEnum: pb2.Enums_NestedEnum(2).Enum(),
+		},
+		want: `opt_enum: TWO
+opt_nested_enum: DOS
+`,
+	}, {
+		desc: "proto2 enum set to unnamed numeric values",
+		input: &pb2.Enums{
+			OptEnum:       pb2.Enum(101).Enum(),
+			OptNestedEnum: pb2.Enums_NestedEnum(-101).Enum(),
+		},
+		want: `opt_enum: 101
+opt_nested_enum: -101
+`,
+	}, {
+		desc:  "proto3 enum not set",
+		input: &pb3.Enums{},
+		want:  "",
+	}, {
+		desc: "proto3 enum set to zero value",
+		input: &pb3.Enums{
+			SEnum:       pb3.Enum_ZERO,
+			SNestedEnum: pb3.Enums_CERO,
+		},
+		want: "",
+	}, {
+		desc: "proto3 enum",
+		input: &pb3.Enums{
+			SEnum:       pb3.Enum_ONE,
+			SNestedEnum: pb3.Enums_UNO,
+		},
+		want: `s_enum: ONE
+s_nested_enum: UNO
+`,
+	}, {
+		desc: "proto3 enum set to numeric values",
+		input: &pb3.Enums{
+			SEnum:       2,
+			SNestedEnum: 2,
+		},
+		want: `s_enum: TWO
+s_nested_enum: DOS
+`,
+	}, {
+		desc: "proto3 enum set to unnamed numeric values",
+		input: &pb3.Enums{
+			SEnum:       -47,
+			SNestedEnum: 47,
+		},
+		want: `s_enum: -47
+s_nested_enum: 47
+`,
+	}, {
+		desc:  "proto2 nested message not set",
+		input: &pb2.Nests{},
+		want:  "",
+	}, {
+		desc: "proto2 nested message set to empty",
+		input: &pb2.Nests{
+			OptNested: &pb2.Nested{},
+			Optgroup:  &pb2.Nests_OptGroup{},
+		},
+		want: `opt_nested: {}
+OptGroup: {}
+`,
+	}, {
+		desc: "proto2 nested messages",
+		input: &pb2.Nests{
+			OptNested: &pb2.Nested{
+				OptString: proto.String("nested message"),
+				OptNested: &pb2.Nested{
+					OptString: proto.String("another nested message"),
+				},
+			},
+		},
+		want: `opt_nested: {
+  opt_string: "nested message"
+  opt_nested: {
+    opt_string: "another nested message"
+  }
+}
+`,
+	}, {
+		desc: "proto2 groups",
+		input: &pb2.Nests{
+			Optgroup: &pb2.Nests_OptGroup{
+				OptString: proto.String("inside a group"),
+				OptNested: &pb2.Nested{
+					OptString: proto.String("nested message inside a group"),
+				},
+				Optnestedgroup: &pb2.Nests_OptGroup_OptNestedGroup{
+					OptFixed32: proto.Uint32(47),
+				},
+			},
+		},
+		want: `OptGroup: {
+  opt_string: "inside a group"
+  opt_nested: {
+    opt_string: "nested message inside a group"
+  }
+  OptNestedGroup: {
+    opt_fixed32: 47
+  }
+}
+`,
+	}, {
+		desc:  "proto3 nested message not set",
+		input: &pb3.Nests{},
+		want:  "",
+	}, {
+		desc: "proto3 nested message set to empty",
+		input: &pb3.Nests{
+			SNested: &pb3.Nested{},
+		},
+		want: "s_nested: {}\n",
+	}, {
+		desc: "proto3 nested message",
+		input: &pb3.Nests{
+			SNested: &pb3.Nested{
+				SString: "nested message",
+				SNested: &pb3.Nested{
+					SString: "another nested message",
+				},
+			},
+		},
+		want: `s_nested: {
+  s_string: "nested message"
+  s_nested: {
+    s_string: "another nested message"
+  }
+}
+`,
+	}, {
+		desc: "proto3 nested message contains invalid UTF-8",
+		input: &pb3.Nests{
+			SNested: &pb3.Nested{
+				SString: "abc\xff",
+			},
+		},
+		wantErr: true,
+	}, {
+		desc:  "oneof not set",
+		input: &pb3.Oneofs{},
+		want:  "",
+	}, {
+		desc: "oneof set to empty string",
+		input: &pb3.Oneofs{
+			Union: &pb3.Oneofs_OneofString{},
+		},
+		want: `oneof_string: ""
+`,
+	}, {
+		desc: "oneof set to string",
+		input: &pb3.Oneofs{
+			Union: &pb3.Oneofs_OneofString{
+				OneofString: "hello",
+			},
+		},
+		want: `oneof_string: "hello"
+`,
+	}, {
+		desc: "oneof set to enum",
+		input: &pb3.Oneofs{
+			Union: &pb3.Oneofs_OneofEnum{
+				OneofEnum: pb3.Enum_ZERO,
+			},
+		},
+		want: `oneof_enum: ZERO
+`,
+	}, {
+		desc: "oneof set to empty message",
+		input: &pb3.Oneofs{
+			Union: &pb3.Oneofs_OneofNested{
+				OneofNested: &pb3.Nested{},
+			},
+		},
+		want: "oneof_nested: {}\n",
+	}, {
+		desc: "oneof set to message",
+		input: &pb3.Oneofs{
+			Union: &pb3.Oneofs_OneofNested{
+				OneofNested: &pb3.Nested{
+					SString: "nested message",
+				},
+			},
+		},
+		want: `oneof_nested: {
+  s_string: "nested message"
+}
+`,
+	}, {
+		desc:  "repeated fields not set",
+		input: &pb2.Repeats{},
+		want:  "",
+	}, {
+		desc: "repeated fields set to empty slices",
+		input: &pb2.Repeats{
+			RptBool:   []bool{},
+			RptInt32:  []int32{},
+			RptInt64:  []int64{},
+			RptUint32: []uint32{},
+			RptUint64: []uint64{},
+			RptFloat:  []float32{},
+			RptDouble: []float64{},
+			RptBytes:  [][]byte{},
+		},
+		want: "",
+	}, {
+		desc: "repeated fields set to some values",
+		input: &pb2.Repeats{
+			RptBool:   []bool{true, false, true, true},
+			RptInt32:  []int32{1, 6, 0, 0},
+			RptInt64:  []int64{-64, 47},
+			RptUint32: []uint32{0xff, 0xffff},
+			RptUint64: []uint64{0xdeadbeef},
+			RptFloat:  []float32{float32(math.NaN()), float32(math.Inf(1)), float32(math.Inf(-1)), 1.034},
+			RptDouble: []float64{math.NaN(), math.Inf(1), math.Inf(-1), 1.23e-308},
+			RptString: []string{"hello", "世界"},
+			RptBytes: [][]byte{
+				[]byte("hello"),
+				[]byte("\xe4\xb8\x96\xe7\x95\x8c"),
+			},
+		},
+		want: `rpt_bool: true
+rpt_bool: false
+rpt_bool: true
+rpt_bool: true
+rpt_int32: 1
+rpt_int32: 6
+rpt_int32: 0
+rpt_int32: 0
+rpt_int64: -64
+rpt_int64: 47
+rpt_uint32: 255
+rpt_uint32: 65535
+rpt_uint64: 3735928559
+rpt_float: nan
+rpt_float: inf
+rpt_float: -inf
+rpt_float: 1.034
+rpt_double: nan
+rpt_double: inf
+rpt_double: -inf
+rpt_double: 1.23e-308
+rpt_string: "hello"
+rpt_string: "世界"
+rpt_bytes: "hello"
+rpt_bytes: "世界"
+`,
+	}, {
+		desc: "repeated proto2 contains invalid UTF-8",
+		input: &pb2.Repeats{
+			RptString: []string{"abc\xff"},
+		},
+		want: `rpt_string: "abc\xff"
+`,
+	}, {
+		desc: "repeated proto3 contains invalid UTF-8",
+		input: &pb3.Repeats{
+			RptString: []string{"abc\xff"},
+		},
+		wantErr: true,
+	}, {
+		desc: "repeated enums",
+		input: &pb2.Enums{
+			RptEnum:       []pb2.Enum{pb2.Enum_ONE, 2, pb2.Enum_TEN, 42},
+			RptNestedEnum: []pb2.Enums_NestedEnum{2, 47, 10},
+		},
+		want: `rpt_enum: ONE
+rpt_enum: TWO
+rpt_enum: TEN
+rpt_enum: 42
+rpt_nested_enum: DOS
+rpt_nested_enum: 47
+rpt_nested_enum: DIEZ
+`,
+	}, {
+		desc: "repeated messages set to empty",
+		input: &pb2.Nests{
+			RptNested: []*pb2.Nested{},
+			Rptgroup:  []*pb2.Nests_RptGroup{},
+		},
+		want: "",
+	}, {
+		desc: "repeated messages",
+		input: &pb2.Nests{
+			RptNested: []*pb2.Nested{
+				{
+					OptString: proto.String("repeat nested one"),
+				},
+				{
+					OptString: proto.String("repeat nested two"),
+					OptNested: &pb2.Nested{
+						OptString: proto.String("inside repeat nested two"),
+					},
+				},
+				{},
+			},
+		},
+		want: `rpt_nested: {
+  opt_string: "repeat nested one"
+}
+rpt_nested: {
+  opt_string: "repeat nested two"
+  opt_nested: {
+    opt_string: "inside repeat nested two"
+  }
+}
+rpt_nested: {}
+`,
+	}, {
+		desc: "repeated messages contains nil value",
+		input: &pb2.Nests{
+			RptNested: []*pb2.Nested{nil, {}},
+		},
+		want: `rpt_nested: {}
+rpt_nested: {}
+`,
+	}, {
+		desc: "repeated groups",
+		input: &pb2.Nests{
+			Rptgroup: []*pb2.Nests_RptGroup{
+				{
+					RptString: []string{"hello", "world"},
+				},
+				{},
+				nil,
+			},
+		},
+		want: `RptGroup: {
+  rpt_string: "hello"
+  rpt_string: "world"
+}
+RptGroup: {}
+RptGroup: {}
+`,
+	}, {
+		desc:  "map fields not set",
+		input: &pb3.Maps{},
+		want:  "",
+	}, {
+		desc: "map fields set to empty",
+		input: &pb3.Maps{
+			Int32ToStr:   map[int32]string{},
+			BoolToUint32: map[bool]uint32{},
+			Uint64ToEnum: map[uint64]pb3.Enum{},
+			StrToNested:  map[string]*pb3.Nested{},
+			StrToOneofs:  map[string]*pb3.Oneofs{},
+		},
+		want: "",
+	}, {
+		desc: "map fields 1",
+		input: &pb3.Maps{
+			Int32ToStr: map[int32]string{
+				-101: "-101",
+				0xff: "0xff",
+				0:    "zero",
+			},
+			BoolToUint32: map[bool]uint32{
+				true:  42,
+				false: 101,
+			},
+		},
+		want: `int32_to_str: {
+  key: -101
+  value: "-101"
+}
+int32_to_str: {
+  key: 0
+  value: "zero"
+}
+int32_to_str: {
+  key: 255
+  value: "0xff"
+}
+bool_to_uint32: {
+  key: false
+  value: 101
+}
+bool_to_uint32: {
+  key: true
+  value: 42
+}
+`,
+	}, {
+		desc: "map fields 2",
+		input: &pb3.Maps{
+			Uint64ToEnum: map[uint64]pb3.Enum{
+				1:  pb3.Enum_ONE,
+				2:  pb3.Enum_TWO,
+				10: pb3.Enum_TEN,
+				47: 47,
+			},
+		},
+		want: `uint64_to_enum: {
+  key: 1
+  value: ONE
+}
+uint64_to_enum: {
+  key: 2
+  value: TWO
+}
+uint64_to_enum: {
+  key: 10
+  value: TEN
+}
+uint64_to_enum: {
+  key: 47
+  value: 47
+}
+`,
+	}, {
+		desc: "map fields 3",
+		input: &pb3.Maps{
+			StrToNested: map[string]*pb3.Nested{
+				"nested": &pb3.Nested{
+					SString: "nested in a map",
+				},
+			},
+		},
+		want: `str_to_nested: {
+  key: "nested"
+  value: {
+    s_string: "nested in a map"
+  }
+}
+`,
+	}, {
+		desc: "map fields 4",
+		input: &pb3.Maps{
+			StrToOneofs: map[string]*pb3.Oneofs{
+				"string": &pb3.Oneofs{
+					Union: &pb3.Oneofs_OneofString{
+						OneofString: "hello",
+					},
+				},
+				"nested": &pb3.Oneofs{
+					Union: &pb3.Oneofs_OneofNested{
+						OneofNested: &pb3.Nested{
+							SString: "nested oneof in map field value",
+						},
+					},
+				},
+			},
+		},
+		want: `str_to_oneofs: {
+  key: "nested"
+  value: {
+    oneof_nested: {
+      s_string: "nested oneof in map field value"
+    }
+  }
+}
+str_to_oneofs: {
+  key: "string"
+  value: {
+    oneof_string: "hello"
+  }
+}
+`,
+	}, {
+		desc: "proto2 map field value contains invalid UTF-8",
+		input: &pb2.Maps{
+			Int32ToStr: map[int32]string{
+				101: "abc\xff",
+			},
+		},
+		want: `int32_to_str: {
+  key: 101
+  value: "abc\xff"
+}
+`,
+	}, {
+		desc: "proto2 map field key contains invalid UTF-8",
+		input: &pb2.Maps{
+			StrToNested: map[string]*pb2.Nested{
+				"abc\xff": {},
+			},
+		},
+		want: `str_to_nested: {
+  key: "abc\xff"
+  value: {}
+}
+`,
+	}, {
+		desc: "proto3 map field value contains invalid UTF-8",
+		input: &pb3.Maps{
+			Int32ToStr: map[int32]string{
+				101: "abc\xff",
+			},
+		},
+		wantErr: true,
+	}, {
+		desc: "proto3 map field key contains invalid UTF-8",
+		input: &pb3.Maps{
+			StrToNested: map[string]*pb3.Nested{
+				"abc\xff": {},
+			},
+		},
+		wantErr: true,
+	}, {
+		desc: "map field contains nil value",
+		input: &pb3.Maps{
+			StrToNested: map[string]*pb3.Nested{
+				"nil": nil,
+			},
+		},
+		want: `str_to_nested: {
+  key: "nil"
+  value: {}
+}
+`,
+	}, {
+		desc:    "required fields not set",
+		input:   &pb2.Requireds{},
+		want:    "",
+		wantErr: true,
+	}, {
+		desc: "required fields partially set",
+		input: &pb2.Requireds{
+			ReqBool:     proto.Bool(false),
+			ReqSfixed64: proto.Int64(0xbeefcafe),
+			ReqDouble:   proto.Float64(math.NaN()),
+			ReqString:   proto.String("hello"),
+			ReqEnum:     pb2.Enum_ONE.Enum(),
+		},
+		want: `req_bool: false
+req_sfixed64: 3203386110
+req_double: nan
+req_string: "hello"
+req_enum: ONE
+`,
+		wantErr: true,
+	}, {
+		desc: "required fields not set with AllowPartial",
+		mo:   prototext.MarshalOptions{AllowPartial: true},
+		input: &pb2.Requireds{
+			ReqBool:     proto.Bool(false),
+			ReqSfixed64: proto.Int64(0xbeefcafe),
+			ReqDouble:   proto.Float64(math.NaN()),
+			ReqString:   proto.String("hello"),
+			ReqEnum:     pb2.Enum_ONE.Enum(),
+		},
+		want: `req_bool: false
+req_sfixed64: 3203386110
+req_double: nan
+req_string: "hello"
+req_enum: ONE
+`,
+	}, {
+		desc: "required fields all set",
+		input: &pb2.Requireds{
+			ReqBool:     proto.Bool(false),
+			ReqSfixed64: proto.Int64(0),
+			ReqDouble:   proto.Float64(1.23),
+			ReqString:   proto.String(""),
+			ReqEnum:     pb2.Enum_ONE.Enum(),
+			ReqNested:   &pb2.Nested{},
+		},
+		want: `req_bool: false
+req_sfixed64: 0
+req_double: 1.23
+req_string: ""
+req_enum: ONE
+req_nested: {}
+`,
+	}, {
+		desc: "indirect required field",
+		input: &pb2.IndirectRequired{
+			OptNested: &pb2.NestedWithRequired{},
+		},
+		want:    "opt_nested: {}\n",
+		wantErr: true,
+	}, {
+		desc: "indirect required field with AllowPartial",
+		mo:   prototext.MarshalOptions{AllowPartial: true},
+		input: &pb2.IndirectRequired{
+			OptNested: &pb2.NestedWithRequired{},
+		},
+		want: "opt_nested: {}\n",
+	}, {
+		desc: "indirect required field in empty repeated",
+		input: &pb2.IndirectRequired{
+			RptNested: []*pb2.NestedWithRequired{},
+		},
+		want: "",
+	}, {
+		desc: "indirect required field in repeated",
+		input: &pb2.IndirectRequired{
+			RptNested: []*pb2.NestedWithRequired{
+				&pb2.NestedWithRequired{},
+			},
+		},
+		want:    "rpt_nested: {}\n",
+		wantErr: true,
+	}, {
+		desc: "indirect required field in repeated with AllowPartial",
+		mo:   prototext.MarshalOptions{AllowPartial: true},
+		input: &pb2.IndirectRequired{
+			RptNested: []*pb2.NestedWithRequired{
+				&pb2.NestedWithRequired{},
+			},
+		},
+		want: "rpt_nested: {}\n",
+	}, {
+		desc: "indirect required field in empty map",
+		input: &pb2.IndirectRequired{
+			StrToNested: map[string]*pb2.NestedWithRequired{},
+		},
+		want: "",
+	}, {
+		desc: "indirect required field in map",
+		input: &pb2.IndirectRequired{
+			StrToNested: map[string]*pb2.NestedWithRequired{
+				"fail": &pb2.NestedWithRequired{},
+			},
+		},
+		want: `str_to_nested: {
+  key: "fail"
+  value: {}
+}
+`,
+		wantErr: true,
+	}, {
+		desc: "indirect required field in map with AllowPartial",
+		mo:   prototext.MarshalOptions{AllowPartial: true},
+		input: &pb2.IndirectRequired{
+			StrToNested: map[string]*pb2.NestedWithRequired{
+				"fail": &pb2.NestedWithRequired{},
+			},
+		},
+		want: `str_to_nested: {
+  key: "fail"
+  value: {}
+}
+`,
+	}, {
+		desc: "indirect required field in oneof",
+		input: &pb2.IndirectRequired{
+			Union: &pb2.IndirectRequired_OneofNested{
+				OneofNested: &pb2.NestedWithRequired{},
+			},
+		},
+		want:    "oneof_nested: {}\n",
+		wantErr: true,
+	}, {
+		desc: "indirect required field in oneof with AllowPartial",
+		mo:   prototext.MarshalOptions{AllowPartial: true},
+		input: &pb2.IndirectRequired{
+			Union: &pb2.IndirectRequired_OneofNested{
+				OneofNested: &pb2.NestedWithRequired{},
+			},
+		},
+		want: "oneof_nested: {}\n",
+	}, {
+		desc: "unknown fields not printed",
+		input: func() proto.Message {
+			m := &pb2.Scalars{
+				OptString: proto.String("this message contains unknown fields"),
+			}
+			m.ProtoReflect().SetUnknown(protopack.Message{
+				protopack.Tag{101, protopack.VarintType}, protopack.Bool(true),
+				protopack.Tag{102, protopack.VarintType}, protopack.Varint(0xff),
+				protopack.Tag{103, protopack.Fixed32Type}, protopack.Uint32(47),
+				protopack.Tag{104, protopack.Fixed64Type}, protopack.Int64(0xdeadbeef),
+			}.Marshal())
+			return m
+		}(),
+		want: `opt_string: "this message contains unknown fields"
+`,
+	}, {
+		desc: "unknown varint and fixed types",
+		mo:   prototext.MarshalOptions{EmitUnknown: true},
+		input: func() proto.Message {
+			m := &pb2.Scalars{
+				OptString: proto.String("this message contains unknown fields"),
+			}
+			m.ProtoReflect().SetUnknown(protopack.Message{
+				protopack.Tag{101, protopack.VarintType}, protopack.Bool(true),
+				protopack.Tag{102, protopack.VarintType}, protopack.Varint(0xff),
+				protopack.Tag{103, protopack.Fixed32Type}, protopack.Uint32(0x47),
+				protopack.Tag{104, protopack.Fixed64Type}, protopack.Int64(0xdeadbeef),
+			}.Marshal())
+			return m
+		}(),
+		want: `opt_string: "this message contains unknown fields"
+101: 1
+102: 255
+103: 0x47
+104: 0xdeadbeef
+`,
+	}, {
+		desc: "unknown length-delimited",
+		mo:   prototext.MarshalOptions{EmitUnknown: true},
+		input: func() proto.Message {
+			m := new(pb2.Scalars)
+			m.ProtoReflect().SetUnknown(protopack.Message{
+				protopack.Tag{101, protopack.BytesType}, protopack.LengthPrefix{protopack.Bool(true), protopack.Bool(false)},
+				protopack.Tag{102, protopack.BytesType}, protopack.String("hello world"),
+				protopack.Tag{103, protopack.BytesType}, protopack.Bytes("\xe4\xb8\x96\xe7\x95\x8c"),
+			}.Marshal())
+			return m
+		}(),
+		want: `101: "\x01\x00"
+102: "hello world"
+103: "世界"
+`,
+	}, {
+		desc: "unknown group type",
+		mo:   prototext.MarshalOptions{EmitUnknown: true},
+		input: func() proto.Message {
+			m := new(pb2.Scalars)
+			m.ProtoReflect().SetUnknown(protopack.Message{
+				protopack.Tag{101, protopack.StartGroupType}, protopack.Tag{101, protopack.EndGroupType},
+				protopack.Tag{102, protopack.StartGroupType},
+				protopack.Tag{101, protopack.VarintType}, protopack.Bool(false),
+				protopack.Tag{102, protopack.BytesType}, protopack.String("inside a group"),
+				protopack.Tag{102, protopack.EndGroupType},
+			}.Marshal())
+			return m
+		}(),
+		want: `101: {}
+102: {
+  101: 0
+  102: "inside a group"
+}
+`,
+	}, {
+		desc: "unknown unpack repeated field",
+		mo:   prototext.MarshalOptions{EmitUnknown: true},
+		input: func() proto.Message {
+			m := new(pb2.Scalars)
+			m.ProtoReflect().SetUnknown(protopack.Message{
+				protopack.Tag{101, protopack.BytesType}, protopack.LengthPrefix{protopack.Bool(true), protopack.Bool(false), protopack.Bool(true)},
+				protopack.Tag{102, protopack.BytesType}, protopack.String("hello"),
+				protopack.Tag{101, protopack.VarintType}, protopack.Bool(true),
+				protopack.Tag{102, protopack.BytesType}, protopack.String("世界"),
+			}.Marshal())
+			return m
+		}(),
+		want: `101: "\x01\x00\x01"
+102: "hello"
+101: 1
+102: "世界"
+`,
+	}, {
+		desc: "extensions of non-repeated fields",
+		input: func() proto.Message {
+			m := &pb2.Extensions{
+				OptString: proto.String("non-extension field"),
+				OptBool:   proto.Bool(true),
+				OptInt32:  proto.Int32(42),
+			}
+			proto.SetExtension(m, pb2.E_OptExtBool, true)
+			proto.SetExtension(m, pb2.E_OptExtString, "extension field")
+			proto.SetExtension(m, pb2.E_OptExtEnum, pb2.Enum_TEN)
+			proto.SetExtension(m, pb2.E_OptExtNested, &pb2.Nested{
+				OptString: proto.String("nested in an extension"),
+				OptNested: &pb2.Nested{
+					OptString: proto.String("another nested in an extension"),
+				},
+			})
+			return m
+		}(),
+		want: `opt_string: "non-extension field"
+opt_bool: true
+opt_int32: 42
+[pb2.opt_ext_bool]: true
+[pb2.opt_ext_enum]: TEN
+[pb2.opt_ext_nested]: {
+  opt_string: "nested in an extension"
+  opt_nested: {
+    opt_string: "another nested in an extension"
+  }
+}
+[pb2.opt_ext_string]: "extension field"
+`,
+	}, {
+		desc: "proto2 extension field contains invalid UTF-8",
+		input: func() proto.Message {
+			m := &pb2.Extensions{}
+			proto.SetExtension(m, pb2.E_OptExtString, "abc\xff")
+			return m
+		}(),
+		want: `[pb2.opt_ext_string]: "abc\xff"
+`,
+	}, {
+		desc: "extension partial returns error",
+		input: func() proto.Message {
+			m := &pb2.Extensions{}
+			proto.SetExtension(m, pb2.E_OptExtPartial, &pb2.PartialRequired{
+				OptString: proto.String("partial1"),
+			})
+			proto.SetExtension(m, pb2.E_ExtensionsContainer_OptExtPartial, &pb2.PartialRequired{
+				OptString: proto.String("partial2"),
+			})
+			return m
+		}(),
+		want: `[pb2.ExtensionsContainer.opt_ext_partial]: {
+  opt_string: "partial2"
+}
+[pb2.opt_ext_partial]: {
+  opt_string: "partial1"
+}
+`,
+		wantErr: true,
+	}, {
+		desc: "extension partial with AllowPartial",
+		mo:   prototext.MarshalOptions{AllowPartial: true},
+		input: func() proto.Message {
+			m := &pb2.Extensions{}
+			proto.SetExtension(m, pb2.E_OptExtPartial, &pb2.PartialRequired{
+				OptString: proto.String("partial1"),
+			})
+			return m
+		}(),
+		want: `[pb2.opt_ext_partial]: {
+  opt_string: "partial1"
+}
+`,
+	}, {
+		desc: "extensions of repeated fields",
+		input: func() proto.Message {
+			m := &pb2.Extensions{}
+			proto.SetExtension(m, pb2.E_RptExtEnum, []pb2.Enum{pb2.Enum_TEN, 101, pb2.Enum_ONE})
+			proto.SetExtension(m, pb2.E_RptExtFixed32, []uint32{42, 47})
+			proto.SetExtension(m, pb2.E_RptExtNested, []*pb2.Nested{
+				&pb2.Nested{OptString: proto.String("one")},
+				&pb2.Nested{OptString: proto.String("two")},
+				&pb2.Nested{OptString: proto.String("three")},
+			})
+			return m
+		}(),
+		want: `[pb2.rpt_ext_enum]: TEN
+[pb2.rpt_ext_enum]: 101
+[pb2.rpt_ext_enum]: ONE
+[pb2.rpt_ext_fixed32]: 42
+[pb2.rpt_ext_fixed32]: 47
+[pb2.rpt_ext_nested]: {
+  opt_string: "one"
+}
+[pb2.rpt_ext_nested]: {
+  opt_string: "two"
+}
+[pb2.rpt_ext_nested]: {
+  opt_string: "three"
+}
+`,
+	}, {
+		desc: "extensions of non-repeated fields in another message",
+		input: func() proto.Message {
+			m := &pb2.Extensions{}
+			proto.SetExtension(m, pb2.E_ExtensionsContainer_OptExtBool, true)
+			proto.SetExtension(m, pb2.E_ExtensionsContainer_OptExtString, "extension field")
+			proto.SetExtension(m, pb2.E_ExtensionsContainer_OptExtEnum, pb2.Enum_TEN)
+			proto.SetExtension(m, pb2.E_ExtensionsContainer_OptExtNested, &pb2.Nested{
+				OptString: proto.String("nested in an extension"),
+				OptNested: &pb2.Nested{
+					OptString: proto.String("another nested in an extension"),
+				},
+			})
+			return m
+		}(),
+		want: `[pb2.ExtensionsContainer.opt_ext_bool]: true
+[pb2.ExtensionsContainer.opt_ext_enum]: TEN
+[pb2.ExtensionsContainer.opt_ext_nested]: {
+  opt_string: "nested in an extension"
+  opt_nested: {
+    opt_string: "another nested in an extension"
+  }
+}
+[pb2.ExtensionsContainer.opt_ext_string]: "extension field"
+`,
+	}, {
+		desc: "extensions of repeated fields in another message",
+		input: func() proto.Message {
+			m := &pb2.Extensions{
+				OptString: proto.String("non-extension field"),
+				OptBool:   proto.Bool(true),
+				OptInt32:  proto.Int32(42),
+			}
+			proto.SetExtension(m, pb2.E_ExtensionsContainer_RptExtEnum, []pb2.Enum{pb2.Enum_TEN, 101, pb2.Enum_ONE})
+			proto.SetExtension(m, pb2.E_ExtensionsContainer_RptExtString, []string{"hello", "world"})
+			proto.SetExtension(m, pb2.E_ExtensionsContainer_RptExtNested, []*pb2.Nested{
+				&pb2.Nested{OptString: proto.String("one")},
+				&pb2.Nested{OptString: proto.String("two")},
+				&pb2.Nested{OptString: proto.String("three")},
+			})
+			return m
+		}(),
+		want: `opt_string: "non-extension field"
+opt_bool: true
+opt_int32: 42
+[pb2.ExtensionsContainer.rpt_ext_enum]: TEN
+[pb2.ExtensionsContainer.rpt_ext_enum]: 101
+[pb2.ExtensionsContainer.rpt_ext_enum]: ONE
+[pb2.ExtensionsContainer.rpt_ext_nested]: {
+  opt_string: "one"
+}
+[pb2.ExtensionsContainer.rpt_ext_nested]: {
+  opt_string: "two"
+}
+[pb2.ExtensionsContainer.rpt_ext_nested]: {
+  opt_string: "three"
+}
+[pb2.ExtensionsContainer.rpt_ext_string]: "hello"
+[pb2.ExtensionsContainer.rpt_ext_string]: "world"
+`,
+	}, {
+		desc: "MessageSet",
+		input: func() proto.Message {
+			m := &pb2.MessageSet{}
+			proto.SetExtension(m, pb2.E_MessageSetExtension_MessageSetExtension, &pb2.MessageSetExtension{
+				OptString: proto.String("a messageset extension"),
+			})
+			proto.SetExtension(m, pb2.E_MessageSetExtension_NotMessageSetExtension, &pb2.MessageSetExtension{
+				OptString: proto.String("not a messageset extension"),
+			})
+			proto.SetExtension(m, pb2.E_MessageSetExtension_ExtNested, &pb2.Nested{
+				OptString: proto.String("just a regular extension"),
+			})
+			return m
+		}(),
+		want: `[pb2.MessageSetExtension]: {
+  opt_string: "a messageset extension"
+}
+[pb2.MessageSetExtension.ext_nested]: {
+  opt_string: "just a regular extension"
+}
+[pb2.MessageSetExtension.not_message_set_extension]: {
+  opt_string: "not a messageset extension"
+}
+`,
+		skip: !flags.ProtoLegacy,
+	}, {
+		desc: "not real MessageSet 1",
+		input: func() proto.Message {
+			m := &pb2.FakeMessageSet{}
+			proto.SetExtension(m, pb2.E_FakeMessageSetExtension_MessageSetExtension, &pb2.FakeMessageSetExtension{
+				OptString: proto.String("not a messageset extension"),
+			})
+			return m
+		}(),
+		want: `[pb2.FakeMessageSetExtension.message_set_extension]: {
+  opt_string: "not a messageset extension"
+}
+`,
+		skip: !flags.ProtoLegacy,
+	}, {
+		desc: "not real MessageSet 2",
+		input: func() proto.Message {
+			m := &pb2.MessageSet{}
+			proto.SetExtension(m, pb2.E_MessageSetExtension, &pb2.FakeMessageSetExtension{
+				OptString: proto.String("another not a messageset extension"),
+			})
+			return m
+		}(),
+		want: `[pb2.message_set_extension]: {
+  opt_string: "another not a messageset extension"
+}
+`,
+		skip: !flags.ProtoLegacy,
+	}, {
+		desc: "Any not expanded",
+		mo: prototext.MarshalOptions{
+			Resolver: new(preg.Types),
+		},
+		input: func() proto.Message {
+			m := &pb2.Nested{
+				OptString: proto.String("embedded inside Any"),
+				OptNested: &pb2.Nested{
+					OptString: proto.String("inception"),
+				},
+			}
+			b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			return &anypb.Any{
+				TypeUrl: "pb2.Nested",
+				Value:   b,
+			}
+		}(),
+		want: `type_url: "pb2.Nested"
+value: "\n\x13embedded inside Any\x12\x0b\n\tinception"
+`,
+	}, {
+		desc: "Any expanded",
+		input: func() proto.Message {
+			m := &pb2.Nested{
+				OptString: proto.String("embedded inside Any"),
+				OptNested: &pb2.Nested{
+					OptString: proto.String("inception"),
+				},
+			}
+			b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			return &anypb.Any{
+				TypeUrl: "foo/pb2.Nested",
+				Value:   b,
+			}
+		}(),
+		want: `[foo/pb2.Nested]: {
+  opt_string: "embedded inside Any"
+  opt_nested: {
+    opt_string: "inception"
+  }
+}
+`,
+	}, {
+		desc: "Any expanded with missing required",
+		input: func() proto.Message {
+			m := &pb2.PartialRequired{
+				OptString: proto.String("embedded inside Any"),
+			}
+			b, err := proto.MarshalOptions{
+				AllowPartial:  true,
+				Deterministic: true,
+			}.Marshal(m)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			return &anypb.Any{
+				TypeUrl: string(m.ProtoReflect().Descriptor().FullName()),
+				Value:   b,
+			}
+		}(),
+		want: `[pb2.PartialRequired]: {
+  opt_string: "embedded inside Any"
+}
+`,
+	}, {
+		desc: "Any with invalid value",
+		input: &anypb.Any{
+			TypeUrl: "foo/pb2.Nested",
+			Value:   []byte("\x80"),
+		},
+		want: `type_url: "foo/pb2.Nested"
+value: "\x80"
+`,
+	}, {
+		desc: "Any expanded in another message",
+		input: func() *pb2.KnownTypes {
+			m1 := &pb2.Nested{
+				OptString: proto.String("message inside Any of another Any field"),
+			}
+			b1, err := proto.MarshalOptions{Deterministic: true}.Marshal(m1)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			m2 := &anypb.Any{
+				TypeUrl: "pb2.Nested",
+				Value:   b1,
+			}
+			b2, err := proto.MarshalOptions{Deterministic: true}.Marshal(m2)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			return &pb2.KnownTypes{
+				OptAny: &anypb.Any{
+					TypeUrl: "google.protobuf.Any",
+					Value:   b2,
+				},
+			}
+		}(),
+		want: `opt_any: {
+  [google.protobuf.Any]: {
+    [pb2.Nested]: {
+      opt_string: "message inside Any of another Any field"
+    }
+  }
+}
+`,
+	}, {
+		desc: "Any expanded with invalid UTF-8 in proto2",
+		input: func() *pb2.KnownTypes {
+			m := &pb2.Nested{
+				OptString: proto.String("invalid UTF-8 abc\xff"),
+			}
+			b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			return &pb2.KnownTypes{
+				OptAny: &anypb.Any{
+					TypeUrl: "pb2.Nested",
+					Value:   b,
+				},
+			}
+		}(),
+		want: `opt_any: {
+  [pb2.Nested]: {
+    opt_string: "invalid UTF-8 abc\xff"
+  }
+}
+`,
+	}, {
+		desc: "Any not expanded due to invalid data",
+		mo:   prototext.MarshalOptions{EmitASCII: true},
+		input: func() *pb2.KnownTypes {
+			return &pb2.KnownTypes{
+				OptAny: &anypb.Any{
+					TypeUrl: "pb3.Scalar",
+					Value:   []byte("\xde\xad\xbe\xef"),
+				},
+			}
+		}(),
+		want: `opt_any: {
+  type_url: "pb3.Scalar"
+  value: "\u07ad\xbe\xef"
+}
+`,
+	}, {
+		desc: "Any inside Any expanded",
+		input: func() *pb2.KnownTypes {
+			m1 := &pb2.Nested{
+				OptString: proto.String("invalid UTF-8 abc\xff"),
+			}
+			b1, err := proto.MarshalOptions{Deterministic: true}.Marshal(m1)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			m2 := &anypb.Any{
+				TypeUrl: "pb2.Nested",
+				Value:   b1,
+			}
+			b2, err := proto.MarshalOptions{Deterministic: true}.Marshal(m2)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			return &pb2.KnownTypes{
+				OptAny: &anypb.Any{
+					TypeUrl: "google.protobuf.Any",
+					Value:   b2,
+				},
+			}
+		}(),
+		want: `opt_any: {
+  [google.protobuf.Any]: {
+    [pb2.Nested]: {
+      opt_string: "invalid UTF-8 abc\xff"
+    }
+  }
+}
+`,
+	}, {
+		desc: "Any inside Any not expanded due to invalid data",
+		mo:   prototext.MarshalOptions{EmitASCII: true},
+		input: func() *pb2.KnownTypes {
+			m := &anypb.Any{
+				TypeUrl: "pb2.Nested",
+				Value:   []byte("\xde\xad\xbe\xef"),
+			}
+			b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			return &pb2.KnownTypes{
+				OptAny: &anypb.Any{
+					TypeUrl: "google.protobuf.Any",
+					Value:   b,
+				},
+			}
+		}(),
+		want: `opt_any: {
+  [google.protobuf.Any]: {
+    type_url: "pb2.Nested"
+    value: "\u07ad\xbe\xef"
+  }
+}
+`,
+	}}
+
+	for _, tt := range tests {
+		tt := tt
+		if tt.skip {
+			continue
+		}
+		t.Run(tt.desc, func(t *testing.T) {
+			// Use 2-space indentation on all MarshalOptions.
+			tt.mo.Indent = "  "
+			b, err := tt.mo.Marshal(tt.input)
+			if err != nil && !tt.wantErr {
+				t.Errorf("Marshal() returned error: %v\n", err)
+			}
+			if err == nil && tt.wantErr {
+				t.Error("Marshal() got nil error, want error\n")
+			}
+			got := string(b)
+			if tt.want != "" && got != tt.want {
+				t.Errorf("Marshal()\n<got>\n%v\n<want>\n%v\n", got, tt.want)
+				if diff := cmp.Diff(tt.want, got); diff != "" {
+					t.Errorf("Marshal() diff -want +got\n%v\n", diff)
+				}
+			}
+		})
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/encoding/prototext/other_test.go b/vendor/google.golang.org/protobuf/encoding/prototext/other_test.go
new file mode 100644
index 000000000..cb0f35f43
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/encoding/prototext/other_test.go
@@ -0,0 +1,238 @@
+// Copyright 2019 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 prototext_test
+
+import (
+	"testing"
+
+	"google.golang.org/protobuf/encoding/prototext"
+	"google.golang.org/protobuf/proto"
+	preg "google.golang.org/protobuf/reflect/protoregistry"
+
+	pb2 "google.golang.org/protobuf/internal/testprotos/textpb2"
+	"google.golang.org/protobuf/types/known/anypb"
+	"google.golang.org/protobuf/types/known/durationpb"
+	"google.golang.org/protobuf/types/known/emptypb"
+	"google.golang.org/protobuf/types/known/structpb"
+	"google.golang.org/protobuf/types/known/timestamppb"
+	"google.golang.org/protobuf/types/known/wrapperspb"
+)
+
+func TestRoundTrip(t *testing.T) {
+	tests := []struct {
+		desc     string
+		resolver *preg.Types
+		message  proto.Message
+	}{{
+		desc: "well-known type fields set to empty messages",
+		message: &pb2.KnownTypes{
+			OptBool:      &wrapperspb.BoolValue{},
+			OptInt32:     &wrapperspb.Int32Value{},
+			OptInt64:     &wrapperspb.Int64Value{},
+			OptUint32:    &wrapperspb.UInt32Value{},
+			OptUint64:    &wrapperspb.UInt64Value{},
+			OptFloat:     &wrapperspb.FloatValue{},
+			OptDouble:    &wrapperspb.DoubleValue{},
+			OptString:    &wrapperspb.StringValue{},
+			OptBytes:     &wrapperspb.BytesValue{},
+			OptDuration:  &durationpb.Duration{},
+			OptTimestamp: &timestamppb.Timestamp{},
+			OptStruct:    &structpb.Struct{},
+			OptList:      &structpb.ListValue{},
+			OptValue:     &structpb.Value{},
+			OptEmpty:     &emptypb.Empty{},
+			OptAny:       &anypb.Any{},
+		},
+	}, {
+		desc: "well-known type scalar fields",
+		message: &pb2.KnownTypes{
+			OptBool: &wrapperspb.BoolValue{
+				Value: true,
+			},
+			OptInt32: &wrapperspb.Int32Value{
+				Value: -42,
+			},
+			OptInt64: &wrapperspb.Int64Value{
+				Value: -42,
+			},
+			OptUint32: &wrapperspb.UInt32Value{
+				Value: 0xff,
+			},
+			OptUint64: &wrapperspb.UInt64Value{
+				Value: 0xffff,
+			},
+			OptFloat: &wrapperspb.FloatValue{
+				Value: 1.234,
+			},
+			OptDouble: &wrapperspb.DoubleValue{
+				Value: 1.23e308,
+			},
+			OptString: &wrapperspb.StringValue{
+				Value: "谷歌",
+			},
+			OptBytes: &wrapperspb.BytesValue{
+				Value: []byte("\xe8\xb0\xb7\xe6\xad\x8c"),
+			},
+		},
+	}, {
+		desc: "well-known type time-related fields",
+		message: &pb2.KnownTypes{
+			OptDuration: &durationpb.Duration{
+				Seconds: -3600,
+				Nanos:   -123,
+			},
+			OptTimestamp: &timestamppb.Timestamp{
+				Seconds: 1257894000,
+				Nanos:   123,
+			},
+		},
+	}, {
+		desc: "Struct field and different Value types",
+		message: &pb2.KnownTypes{
+			OptStruct: &structpb.Struct{
+				Fields: map[string]*structpb.Value{
+					"bool": &structpb.Value{
+						Kind: &structpb.Value_BoolValue{
+							BoolValue: true,
+						},
+					},
+					"double": &structpb.Value{
+						Kind: &structpb.Value_NumberValue{
+							NumberValue: 3.1415,
+						},
+					},
+					"null": &structpb.Value{
+						Kind: &structpb.Value_NullValue{
+							NullValue: structpb.NullValue_NULL_VALUE,
+						},
+					},
+					"string": &structpb.Value{
+						Kind: &structpb.Value_StringValue{
+							StringValue: "string",
+						},
+					},
+					"struct": &structpb.Value{
+						Kind: &structpb.Value_StructValue{
+							StructValue: &structpb.Struct{
+								Fields: map[string]*structpb.Value{
+									"bool": &structpb.Value{
+										Kind: &structpb.Value_BoolValue{
+											BoolValue: false,
+										},
+									},
+								},
+							},
+						},
+					},
+					"list": &structpb.Value{
+						Kind: &structpb.Value_ListValue{
+							ListValue: &structpb.ListValue{
+								Values: []*structpb.Value{
+									{
+										Kind: &structpb.Value_BoolValue{
+											BoolValue: false,
+										},
+									},
+									{
+										Kind: &structpb.Value_StringValue{
+											StringValue: "hello",
+										},
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	}, {
+		desc:     "Any field without registered type",
+		resolver: new(preg.Types),
+		message: func() proto.Message {
+			m := &pb2.Nested{
+				OptString: proto.String("embedded inside Any"),
+				OptNested: &pb2.Nested{
+					OptString: proto.String("inception"),
+				},
+			}
+			b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			return &pb2.KnownTypes{
+				OptAny: &anypb.Any{
+					TypeUrl: string(m.ProtoReflect().Descriptor().FullName()),
+					Value:   b,
+				},
+			}
+		}(),
+	}, {
+		desc: "Any field with registered type",
+		message: func() *pb2.KnownTypes {
+			m := &pb2.Nested{
+				OptString: proto.String("embedded inside Any"),
+				OptNested: &pb2.Nested{
+					OptString: proto.String("inception"),
+				},
+			}
+			b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			return &pb2.KnownTypes{
+				OptAny: &anypb.Any{
+					TypeUrl: string(m.ProtoReflect().Descriptor().FullName()),
+					Value:   b,
+				},
+			}
+		}(),
+	}, {
+		desc: "Any field containing Any message",
+		message: func() *pb2.KnownTypes {
+			m1 := &pb2.Nested{
+				OptString: proto.String("message inside Any of another Any field"),
+			}
+			b1, err := proto.MarshalOptions{Deterministic: true}.Marshal(m1)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			m2 := &anypb.Any{
+				TypeUrl: "pb2.Nested",
+				Value:   b1,
+			}
+			b2, err := proto.MarshalOptions{Deterministic: true}.Marshal(m2)
+			if err != nil {
+				t.Fatalf("error in binary marshaling message for Any.value: %v", err)
+			}
+			return &pb2.KnownTypes{
+				OptAny: &anypb.Any{
+					TypeUrl: "google.protobuf.Any",
+					Value:   b2,
+				},
+			}
+		}(),
+	}}
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.desc, func(t *testing.T) {
+			t.Parallel()
+			b, err := prototext.MarshalOptions{Resolver: tt.resolver}.Marshal(tt.message)
+			if err != nil {
+				t.Errorf("Marshal() returned error: %v\n\n", err)
+			}
+
+			gotMessage := new(pb2.KnownTypes)
+			err = prototext.UnmarshalOptions{Resolver: tt.resolver}.Unmarshal(b, gotMessage)
+			if err != nil {
+				t.Errorf("Unmarshal() returned error: %v\n\n", err)
+			}
+
+			if !proto.Equal(gotMessage, tt.message) {
+				t.Errorf("Unmarshal()\n<got>\n%v\n<want>\n%v\n", gotMessage, tt.message)
+			}
+		})
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/encoding/protowire/wire.go b/vendor/google.golang.org/protobuf/encoding/protowire/wire.go
new file mode 100644
index 000000000..a427f8b70
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/encoding/protowire/wire.go
@@ -0,0 +1,538 @@
+// 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 protowire parses and formats the raw wire encoding.
+// See https://developers.google.com/protocol-buffers/docs/encoding.
+//
+// For marshaling and unmarshaling entire protobuf messages,
+// use the "google.golang.org/protobuf/proto" package instead.
+package protowire
+
+import (
+	"io"
+	"math"
+	"math/bits"
+
+	"google.golang.org/protobuf/internal/errors"
+)
+
+// Number represents the field number.
+type Number int32
+
+const (
+	MinValidNumber      Number = 1
+	FirstReservedNumber Number = 19000
+	LastReservedNumber  Number = 19999
+	MaxValidNumber      Number = 1<<29 - 1
+)
+
+// IsValid reports whether the field number is semantically valid.
+//
+// Note that while numbers within the reserved range are semantically invalid,
+// they are syntactically valid in the wire format.
+// Implementations may treat records with reserved field numbers as unknown.
+func (n Number) IsValid() bool {
+	return MinValidNumber <= n && n < FirstReservedNumber || LastReservedNumber < n && n <= MaxValidNumber
+}
+
+// Type represents the wire type.
+type Type int8
+
+const (
+	VarintType     Type = 0
+	Fixed32Type    Type = 5
+	Fixed64Type    Type = 1
+	BytesType      Type = 2
+	StartGroupType Type = 3
+	EndGroupType   Type = 4
+)
+
+const (
+	_ = -iota
+	errCodeTruncated
+	errCodeFieldNumber
+	errCodeOverflow
+	errCodeReserved
+	errCodeEndGroup
+)
+
+var (
+	errFieldNumber = errors.New("invalid field number")
+	errOverflow    = errors.New("variable length integer overflow")
+	errReserved    = errors.New("cannot parse reserved wire type")
+	errEndGroup    = errors.New("mismatching end group marker")
+	errParse       = errors.New("parse error")
+)
+
+// ParseError converts an error code into an error value.
+// This returns nil if n is a non-negative number.
+func ParseError(n int) error {
+	if n >= 0 {
+		return nil
+	}
+	switch n {
+	case errCodeTruncated:
+		return io.ErrUnexpectedEOF
+	case errCodeFieldNumber:
+		return errFieldNumber
+	case errCodeOverflow:
+		return errOverflow
+	case errCodeReserved:
+		return errReserved
+	case errCodeEndGroup:
+		return errEndGroup
+	default:
+		return errParse
+	}
+}
+
+// ConsumeField parses an entire field record (both tag and value) and returns
+// the field number, the wire type, and the total length.
+// This returns a negative length upon an error (see ParseError).
+//
+// The total length includes the tag header and the end group marker (if the
+// field is a group).
+func ConsumeField(b []byte) (Number, Type, int) {
+	num, typ, n := ConsumeTag(b)
+	if n < 0 {
+		return 0, 0, n // forward error code
+	}
+	m := ConsumeFieldValue(num, typ, b[n:])
+	if m < 0 {
+		return 0, 0, m // forward error code
+	}
+	return num, typ, n + m
+}
+
+// ConsumeFieldValue parses a field value and returns its length.
+// This assumes that the field Number and wire Type have already been parsed.
+// This returns a negative length upon an error (see ParseError).
+//
+// When parsing a group, the length includes the end group marker and
+// the end group is verified to match the starting field number.
+func ConsumeFieldValue(num Number, typ Type, b []byte) (n int) {
+	switch typ {
+	case VarintType:
+		_, n = ConsumeVarint(b)
+		return n
+	case Fixed32Type:
+		_, n = ConsumeFixed32(b)
+		return n
+	case Fixed64Type:
+		_, n = ConsumeFixed64(b)
+		return n
+	case BytesType:
+		_, n = ConsumeBytes(b)
+		return n
+	case StartGroupType:
+		n0 := len(b)
+		for {
+			num2, typ2, n := ConsumeTag(b)
+			if n < 0 {
+				return n // forward error code
+			}
+			b = b[n:]
+			if typ2 == EndGroupType {
+				if num != num2 {
+					return errCodeEndGroup
+				}
+				return n0 - len(b)
+			}
+
+			n = ConsumeFieldValue(num2, typ2, b)
+			if n < 0 {
+				return n // forward error code
+			}
+			b = b[n:]
+		}
+	case EndGroupType:
+		return errCodeEndGroup
+	default:
+		return errCodeReserved
+	}
+}
+
+// AppendTag encodes num and typ as a varint-encoded tag and appends it to b.
+func AppendTag(b []byte, num Number, typ Type) []byte {
+	return AppendVarint(b, EncodeTag(num, typ))
+}
+
+// ConsumeTag parses b as a varint-encoded tag, reporting its length.
+// This returns a negative length upon an error (see ParseError).
+func ConsumeTag(b []byte) (Number, Type, int) {
+	v, n := ConsumeVarint(b)
+	if n < 0 {
+		return 0, 0, n // forward error code
+	}
+	num, typ := DecodeTag(v)
+	if num < MinValidNumber {
+		return 0, 0, errCodeFieldNumber
+	}
+	return num, typ, n
+}
+
+func SizeTag(num Number) int {
+	return SizeVarint(EncodeTag(num, 0)) // wire type has no effect on size
+}
+
+// AppendVarint appends v to b as a varint-encoded uint64.
+func AppendVarint(b []byte, v uint64) []byte {
+	switch {
+	case v < 1<<7:
+		b = append(b, byte(v))
+	case v < 1<<14:
+		b = append(b,
+			byte((v>>0)&0x7f|0x80),
+			byte(v>>7))
+	case v < 1<<21:
+		b = append(b,
+			byte((v>>0)&0x7f|0x80),
+			byte((v>>7)&0x7f|0x80),
+			byte(v>>14))
+	case v < 1<<28:
+		b = append(b,
+			byte((v>>0)&0x7f|0x80),
+			byte((v>>7)&0x7f|0x80),
+			byte((v>>14)&0x7f|0x80),
+			byte(v>>21))
+	case v < 1<<35:
+		b = append(b,
+			byte((v>>0)&0x7f|0x80),
+			byte((v>>7)&0x7f|0x80),
+			byte((v>>14)&0x7f|0x80),
+			byte((v>>21)&0x7f|0x80),
+			byte(v>>28))
+	case v < 1<<42:
+		b = append(b,
+			byte((v>>0)&0x7f|0x80),
+			byte((v>>7)&0x7f|0x80),
+			byte((v>>14)&0x7f|0x80),
+			byte((v>>21)&0x7f|0x80),
+			byte((v>>28)&0x7f|0x80),
+			byte(v>>35))
+	case v < 1<<49:
+		b = append(b,
+			byte((v>>0)&0x7f|0x80),
+			byte((v>>7)&0x7f|0x80),
+			byte((v>>14)&0x7f|0x80),
+			byte((v>>21)&0x7f|0x80),
+			byte((v>>28)&0x7f|0x80),
+			byte((v>>35)&0x7f|0x80),
+			byte(v>>42))
+	case v < 1<<56:
+		b = append(b,
+			byte((v>>0)&0x7f|0x80),
+			byte((v>>7)&0x7f|0x80),
+			byte((v>>14)&0x7f|0x80),
+			byte((v>>21)&0x7f|0x80),
+			byte((v>>28)&0x7f|0x80),
+			byte((v>>35)&0x7f|0x80),
+			byte((v>>42)&0x7f|0x80),
+			byte(v>>49))
+	case v < 1<<63:
+		b = append(b,
+			byte((v>>0)&0x7f|0x80),
+			byte((v>>7)&0x7f|0x80),
+			byte((v>>14)&0x7f|0x80),
+			byte((v>>21)&0x7f|0x80),
+			byte((v>>28)&0x7f|0x80),
+			byte((v>>35)&0x7f|0x80),
+			byte((v>>42)&0x7f|0x80),
+			byte((v>>49)&0x7f|0x80),
+			byte(v>>56))
+	default:
+		b = append(b,
+			byte((v>>0)&0x7f|0x80),
+			byte((v>>7)&0x7f|0x80),
+			byte((v>>14)&0x7f|0x80),
+			byte((v>>21)&0x7f|0x80),
+			byte((v>>28)&0x7f|0x80),
+			byte((v>>35)&0x7f|0x80),
+			byte((v>>42)&0x7f|0x80),
+			byte((v>>49)&0x7f|0x80),
+			byte((v>>56)&0x7f|0x80),
+			1)
+	}
+	return b
+}
+
+// ConsumeVarint parses b as a varint-encoded uint64, reporting its length.
+// This returns a negative length upon an error (see ParseError).
+func ConsumeVarint(b []byte) (v uint64, n int) {
+	var y uint64
+	if len(b) <= 0 {
+		return 0, errCodeTruncated
+	}
+	v = uint64(b[0])
+	if v < 0x80 {
+		return v, 1
+	}
+	v -= 0x80
+
+	if len(b) <= 1 {
+		return 0, errCodeTruncated
+	}
+	y = uint64(b[1])
+	v += y << 7
+	if y < 0x80 {
+		return v, 2
+	}
+	v -= 0x80 << 7
+
+	if len(b) <= 2 {
+		return 0, errCodeTruncated
+	}
+	y = uint64(b[2])
+	v += y << 14
+	if y < 0x80 {
+		return v, 3
+	}
+	v -= 0x80 << 14
+
+	if len(b) <= 3 {
+		return 0, errCodeTruncated
+	}
+	y = uint64(b[3])
+	v += y << 21
+	if y < 0x80 {
+		return v, 4
+	}
+	v -= 0x80 << 21
+
+	if len(b) <= 4 {
+		return 0, errCodeTruncated
+	}
+	y = uint64(b[4])
+	v += y << 28
+	if y < 0x80 {
+		return v, 5
+	}
+	v -= 0x80 << 28
+
+	if len(b) <= 5 {
+		return 0, errCodeTruncated
+	}
+	y = uint64(b[5])
+	v += y << 35
+	if y < 0x80 {
+		return v, 6
+	}
+	v -= 0x80 << 35
+
+	if len(b) <= 6 {
+		return 0, errCodeTruncated
+	}
+	y = uint64(b[6])
+	v += y << 42
+	if y < 0x80 {
+		return v, 7
+	}
+	v -= 0x80 << 42
+
+	if len(b) <= 7 {
+		return 0, errCodeTruncated
+	}
+	y = uint64(b[7])
+	v += y << 49
+	if y < 0x80 {
+		return v, 8
+	}
+	v -= 0x80 << 49
+
+	if len(b) <= 8 {
+		return 0, errCodeTruncated
+	}
+	y = uint64(b[8])
+	v += y << 56
+	if y < 0x80 {
+		return v, 9
+	}
+	v -= 0x80 << 56
+
+	if len(b) <= 9 {
+		return 0, errCodeTruncated
+	}
+	y = uint64(b[9])
+	v += y << 63
+	if y < 2 {
+		return v, 10
+	}
+	return 0, errCodeOverflow
+}
+
+// SizeVarint returns the encoded size of a varint.
+// The size is guaranteed to be within 1 and 10, inclusive.
+func SizeVarint(v uint64) int {
+	// This computes 1 + (bits.Len64(v)-1)/7.
+	// 9/64 is a good enough approximation of 1/7
+	return int(9*uint32(bits.Len64(v))+64) / 64
+}
+
+// AppendFixed32 appends v to b as a little-endian uint32.
+func AppendFixed32(b []byte, v uint32) []byte {
+	return append(b,
+		byte(v>>0),
+		byte(v>>8),
+		byte(v>>16),
+		byte(v>>24))
+}
+
+// ConsumeFixed32 parses b as a little-endian uint32, reporting its length.
+// This returns a negative length upon an error (see ParseError).
+func ConsumeFixed32(b []byte) (v uint32, n int) {
+	if len(b) < 4 {
+		return 0, errCodeTruncated
+	}
+	v = uint32(b[0])<<0 | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
+	return v, 4
+}
+
+// SizeFixed32 returns the encoded size of a fixed32; which is always 4.
+func SizeFixed32() int {
+	return 4
+}
+
+// AppendFixed64 appends v to b as a little-endian uint64.
+func AppendFixed64(b []byte, v uint64) []byte {
+	return append(b,
+		byte(v>>0),
+		byte(v>>8),
+		byte(v>>16),
+		byte(v>>24),
+		byte(v>>32),
+		byte(v>>40),
+		byte(v>>48),
+		byte(v>>56))
+}
+
+// ConsumeFixed64 parses b as a little-endian uint64, reporting its length.
+// This returns a negative length upon an error (see ParseError).
+func ConsumeFixed64(b []byte) (v uint64, n int) {
+	if len(b) < 8 {
+		return 0, errCodeTruncated
+	}
+	v = uint64(b[0])<<0 | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
+	return v, 8
+}
+
+// SizeFixed64 returns the encoded size of a fixed64; which is always 8.
+func SizeFixed64() int {
+	return 8
+}
+
+// AppendBytes appends v to b as a length-prefixed bytes value.
+func AppendBytes(b []byte, v []byte) []byte {
+	return append(AppendVarint(b, uint64(len(v))), v...)
+}
+
+// ConsumeBytes parses b as a length-prefixed bytes value, reporting its length.
+// This returns a negative length upon an error (see ParseError).
+func ConsumeBytes(b []byte) (v []byte, n int) {
+	m, n := ConsumeVarint(b)
+	if n < 0 {
+		return nil, n // forward error code
+	}
+	if m > uint64(len(b[n:])) {
+		return nil, errCodeTruncated
+	}
+	return b[n:][:m], n + int(m)
+}
+
+// SizeBytes returns the encoded size of a length-prefixed bytes value,
+// given only the length.
+func SizeBytes(n int) int {
+	return SizeVarint(uint64(n)) + n
+}
+
+// AppendString appends v to b as a length-prefixed bytes value.
+func AppendString(b []byte, v string) []byte {
+	return append(AppendVarint(b, uint64(len(v))), v...)
+}
+
+// ConsumeString parses b as a length-prefixed bytes value, reporting its length.
+// This returns a negative length upon an error (see ParseError).
+func ConsumeString(b []byte) (v string, n int) {
+	bb, n := ConsumeBytes(b)
+	return string(bb), n
+}
+
+// AppendGroup appends v to b as group value, with a trailing end group marker.
+// The value v must not contain the end marker.
+func AppendGroup(b []byte, num Number, v []byte) []byte {
+	return AppendVarint(append(b, v...), EncodeTag(num, EndGroupType))
+}
+
+// ConsumeGroup parses b as a group value until the trailing end group marker,
+// and verifies that the end marker matches the provided num. The value v
+// does not contain the end marker, while the length does contain the end marker.
+// This returns a negative length upon an error (see ParseError).
+func ConsumeGroup(num Number, b []byte) (v []byte, n int) {
+	n = ConsumeFieldValue(num, StartGroupType, b)
+	if n < 0 {
+		return nil, n // forward error code
+	}
+	b = b[:n]
+
+	// Truncate off end group marker, but need to handle denormalized varints.
+	// Assuming end marker is never 0 (which is always the case since
+	// EndGroupType is non-zero), we can truncate all trailing bytes where the
+	// lower 7 bits are all zero (implying that the varint is denormalized).
+	for len(b) > 0 && b[len(b)-1]&0x7f == 0 {
+		b = b[:len(b)-1]
+	}
+	b = b[:len(b)-SizeTag(num)]
+	return b, n
+}
+
+// SizeGroup returns the encoded size of a group, given only the length.
+func SizeGroup(num Number, n int) int {
+	return n + SizeTag(num)
+}
+
+// DecodeTag decodes the field Number and wire Type from its unified form.
+// The Number is -1 if the decoded field number overflows int32.
+// Other than overflow, this does not check for field number validity.
+func DecodeTag(x uint64) (Number, Type) {
+	// NOTE: MessageSet allows for larger field numbers than normal.
+	if x>>3 > uint64(math.MaxInt32) {
+		return -1, 0
+	}
+	return Number(x >> 3), Type(x & 7)
+}
+
+// EncodeTag encodes the field Number and wire Type into its unified form.
+func EncodeTag(num Number, typ Type) uint64 {
+	return uint64(num)<<3 | uint64(typ&7)
+}
+
+// DecodeZigZag decodes a zig-zag-encoded uint64 as an int64.
+//	Input:  {…,  5,  3,  1,  0,  2,  4,  6, …}
+//	Output: {…, -3, -2, -1,  0, +1, +2, +3, …}
+func DecodeZigZag(x uint64) int64 {
+	return int64(x>>1) ^ int64(x)<<63>>63
+}
+
+// EncodeZigZag encodes an int64 as a zig-zag-encoded uint64.
+//	Input:  {…, -3, -2, -1,  0, +1, +2, +3, …}
+//	Output: {…,  5,  3,  1,  0,  2,  4,  6, …}
+func EncodeZigZag(x int64) uint64 {
+	return uint64(x<<1) ^ uint64(x>>63)
+}
+
+// DecodeBool decodes a uint64 as a bool.
+//	Input:  {    0,    1,    2, …}
+//	Output: {false, true, true, …}
+func DecodeBool(x uint64) bool {
+	return x != 0
+}
+
+// EncodeBool encodes a bool as a uint64.
+//	Input:  {false, true}
+//	Output: {    0,    1}
+func EncodeBool(x bool) uint64 {
+	if x {
+		return 1
+	}
+	return 0
+}
diff --git a/vendor/google.golang.org/protobuf/encoding/protowire/wire_test.go b/vendor/google.golang.org/protobuf/encoding/protowire/wire_test.go
new file mode 100644
index 000000000..10ec7f805
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/encoding/protowire/wire_test.go
@@ -0,0 +1,680 @@
+// 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 protowire
+
+import (
+	"bytes"
+	"encoding/hex"
+	"io"
+	"math"
+	"strings"
+	"testing"
+)
+
+type (
+	testOps struct {
+		// appendOps is a sequence of append operations, each appending to
+		// the output of the previous append operation.
+		appendOps []appendOp
+
+		// wantRaw (if not nil) is the bytes that the appendOps should produce.
+		wantRaw []byte
+
+		// consumeOps are a sequence of consume operations, each consuming the
+		// remaining output after the previous consume operation.
+		// The first consume operation starts with the output of appendOps.
+		consumeOps []consumeOp
+	}
+
+	// appendOp represents an Append operation.
+	appendOp  = interface{}
+	appendTag struct {
+		inNum  Number
+		inType Type
+	}
+	appendVarint struct {
+		inVal uint64
+	}
+	appendFixed32 struct {
+		inVal uint32
+	}
+	appendFixed64 struct {
+		inVal uint64
+	}
+	appendBytes struct {
+		inVal []byte
+	}
+	appendGroup struct {
+		inNum Number
+		inVal []byte
+	}
+	appendRaw []byte
+
+	// consumeOp represents an Consume operation.
+	consumeOp    = interface{}
+	consumeField struct {
+		wantNum  Number
+		wantType Type
+		wantCnt  int
+		wantErr  error
+	}
+	consumeFieldValue struct {
+		inNum   Number
+		inType  Type
+		wantCnt int
+		wantErr error
+	}
+	consumeTag struct {
+		wantNum  Number
+		wantType Type
+		wantCnt  int
+		wantErr  error
+	}
+	consumeVarint struct {
+		wantVal uint64
+		wantCnt int
+		wantErr error
+	}
+	consumeFixed32 struct {
+		wantVal uint32
+		wantCnt int
+		wantErr error
+	}
+	consumeFixed64 struct {
+		wantVal uint64
+		wantCnt int
+		wantErr error
+	}
+	consumeBytes struct {
+		wantVal []byte
+		wantCnt int
+		wantErr error
+	}
+	consumeGroup struct {
+		inNum   Number
+		wantVal []byte
+		wantCnt int
+		wantErr error
+	}
+
+	ops []interface{}
+)
+
+// dhex decodes a hex-string and returns the bytes and panics if s is invalid.
+func dhex(s string) []byte {
+	b, err := hex.DecodeString(s)
+	if err != nil {
+		panic(err)
+	}
+	return b
+}
+
+func TestTag(t *testing.T) {
+	runTests(t, []testOps{{
+		appendOps:  ops{appendRaw(dhex(""))},
+		consumeOps: ops{consumeTag{wantErr: io.ErrUnexpectedEOF}},
+	}, {
+		appendOps:  ops{appendTag{inNum: 0, inType: Fixed32Type}},
+		wantRaw:    dhex("05"),
+		consumeOps: ops{consumeTag{wantErr: errFieldNumber}},
+	}, {
+		appendOps:  ops{appendTag{inNum: 1, inType: Fixed32Type}},
+		wantRaw:    dhex("0d"),
+		consumeOps: ops{consumeTag{wantNum: 1, wantType: Fixed32Type, wantCnt: 1}},
+	}, {
+		appendOps:  ops{appendTag{inNum: FirstReservedNumber, inType: BytesType}},
+		wantRaw:    dhex("c2a309"),
+		consumeOps: ops{consumeTag{wantNum: FirstReservedNumber, wantType: BytesType, wantCnt: 3}},
+	}, {
+		appendOps:  ops{appendTag{inNum: LastReservedNumber, inType: StartGroupType}},
+		wantRaw:    dhex("fbe109"),
+		consumeOps: ops{consumeTag{wantNum: LastReservedNumber, wantType: StartGroupType, wantCnt: 3}},
+	}, {
+		appendOps:  ops{appendTag{inNum: MaxValidNumber, inType: VarintType}},
+		wantRaw:    dhex("f8ffffff0f"),
+		consumeOps: ops{consumeTag{wantNum: MaxValidNumber, wantType: VarintType, wantCnt: 5}},
+	}, {
+		appendOps:  ops{appendVarint{inVal: ((math.MaxInt32+1)<<3 | uint64(VarintType))}},
+		wantRaw:    dhex("8080808040"),
+		consumeOps: ops{consumeTag{wantErr: errFieldNumber}},
+	}})
+}
+
+func TestVarint(t *testing.T) {
+	runTests(t, []testOps{{
+		appendOps:  ops{appendRaw(dhex(""))},
+		consumeOps: ops{consumeVarint{wantErr: io.ErrUnexpectedEOF}},
+	}, {
+		appendOps:  ops{appendRaw(dhex("80"))},
+		consumeOps: ops{consumeVarint{wantErr: io.ErrUnexpectedEOF}},
+	}, {
+		appendOps:  ops{appendRaw(dhex("8080"))},
+		consumeOps: ops{consumeVarint{wantErr: io.ErrUnexpectedEOF}},
+	}, {
+		appendOps:  ops{appendRaw(dhex("808080"))},
+		consumeOps: ops{consumeVarint{wantErr: io.ErrUnexpectedEOF}},
+	}, {
+		appendOps:  ops{appendRaw(dhex("80808080"))},
+		consumeOps: ops{consumeVarint{wantErr: io.ErrUnexpectedEOF}},
+	}, {
+		appendOps:  ops{appendRaw(dhex("8080808080"))},
+		consumeOps: ops{consumeVarint{wantErr: io.ErrUnexpectedEOF}},
+	}, {
+		appendOps:  ops{appendRaw(dhex("808080808080"))},
+		consumeOps: ops{consumeVarint{wantErr: io.ErrUnexpectedEOF}},
+	}, {
+		appendOps:  ops{appendRaw(dhex("80808080808080"))},
+		consumeOps: ops{consumeVarint{wantErr: io.ErrUnexpectedEOF}},
+	}, {
+		appendOps:  ops{appendRaw(dhex("8080808080808080"))},
+		consumeOps: ops{consumeVarint{wantErr: io.ErrUnexpectedEOF}},
+	}, {
+		appendOps:  ops{appendRaw(dhex("808080808080808080"))},
+		consumeOps: ops{consumeVarint{wantErr: io.ErrUnexpectedEOF}},
+	}, {
+		appendOps:  ops{appendRaw(dhex("80808080808080808080"))},
+		consumeOps: ops{consumeVarint{wantErr: errOverflow}},
+	}, {
+		// Test varints at various boundaries where the length changes.
+		appendOps:  ops{appendVarint{inVal: 0x0}},
+		wantRaw:    dhex("00"),
+		consumeOps: ops{consumeVarint{wantVal: 0, wantCnt: 1}},
+	}, {
+		appendOps:  ops{appendVarint{inVal: 0x1}},
+		wantRaw:    dhex("01"),
+		consumeOps: ops{consumeVarint{wantVal: 1, wantCnt: 1}},
+	}, {
+		appendOps:  ops{appendVarint{inVal: 0x7f}},
+		wantRaw:    dhex("7f"),
+		consumeOps: ops{consumeVarint{wantVal: 0x7f, wantCnt: 1}},
+	}, {
+		appendOps:  ops{appendVarint{inVal: 0x7f + 1}},
+		wantRaw:    dhex("8001"),
+		consumeOps: ops{consumeVarint{wantVal: 0x7f + 1, wantCnt: 2}},
+	}, {
+		appendOps:  ops{appendVarint{inVal: 0x3fff}},
+		wantRaw:    dhex("ff7f"),
+		consumeOps: ops{consumeVarint{wantVal: 0x3fff, wantCnt: 2}},
+	}, {
+		appendOps:  ops{appendVarint{inVal: 0x3fff + 1}},
+		wantRaw:    dhex("808001"),
+		consumeOps: ops{consumeVarint{wantVal: 0x3fff + 1, wantCnt: 3}},
+	}, {
+		appendOps:  ops{appendVarint{inVal: 0x1fffff}},
+		wantRaw:    dhex("ffff7f"),
+		consumeOps: ops{consumeVarint{wantVal: 0x1fffff, wantCnt: 3}},
+	}, {
+		appendOps:  ops{appendVarint{inVal: 0x1fffff + 1}},
+		wantRaw:    dhex("80808001"),
+		consumeOps: ops{consumeVarint{wantVal: 0x1fffff + 1, wantCnt: 4}},
+	}, {
+		appendOps:  ops{appendVarint{inVal: 0xfffffff}},
+		wantRaw:    dhex("ffffff7f"),
+		consumeOps: ops{consumeVarint{wantVal: 0xfffffff, wantCnt: 4}},
+	}, {
+		appendOps:  ops{appendVarint{inVal: 0xfffffff + 1}},
+		wantRaw:    dhex("8080808001"),
+		consumeOps: ops{consumeVarint{wantVal: 0xfffffff + 1, wantCnt: 5}},
+	}, {
+		appendOps:  ops{appendVarint{inVal: 0x7ffffffff}},
+		wantRaw:    dhex("ffffffff7f"),
+		consumeOps: ops{consumeVarint{wantVal: 0x7ffffffff, wantCnt: 5}},
+	}, {
+		appendOps:  ops{appendVarint{inVal: 0x7ffffffff + 1}},
+		wantRaw:    dhex("808080808001"),
+		consumeOps: ops{consumeVarint{wantVal: 0x7ffffffff + 1, wantCnt: 6}},
+	}, {
+		appendOps:  ops{appendVarint{inVal: 0x3ffffffffff}},
+		wantRaw:    dhex("ffffffffff7f"),
+		consumeOps: ops{consumeVarint{wantVal: 0x3ffffffffff, wantCnt: 6}},
+	}, {
+		appendOps:  ops{appendVarint{inVal: 0x3ffffffffff + 1}},
+		wantRaw:    dhex("80808080808001"),
+		consumeOps: ops{consumeVarint{wantVal: 0x3ffffffffff + 1, wantCnt: 7}},
+	}, {
+		appendOps:  ops{appendVarint{inVal: 0x1ffffffffffff}},
+		wantRaw:    dhex("ffffffffffff7f"),
+		consumeOps: ops{consumeVarint{wantVal: 0x1ffffffffffff, wantCnt: 7}},
+	}, {
+		appendOps:  ops{appendVarint{inVal: 0x1ffffffffffff + 1}},
+		wantRaw:    dhex("8080808080808001"),
+		consumeOps: ops{consumeVarint{wantVal: 0x1ffffffffffff + 1, wantCnt: 8}},
+	}, {
+		appendOps:  ops{appendVarint{inVal: 0xffffffffffffff}},
+		wantRaw:    dhex("ffffffffffffff7f"),
+		consumeOps: ops{consumeVarint{wantVal: 0xffffffffffffff, wantCnt: 8}},
+	}, {
+		appendOps:  ops{appendVarint{inVal: 0xffffffffffffff + 1}},
+		wantRaw:    dhex("808080808080808001"),
+		consumeOps: ops{consumeVarint{wantVal: 0xffffffffffffff + 1, wantCnt: 9}},
+	}, {
+		appendOps:  ops{appendVarint{inVal: 0x7fffffffffffffff}},
+		wantRaw:    dhex("ffffffffffffffff7f"),
+		consumeOps: ops{consumeVarint{wantVal: 0x7fffffffffffffff, wantCnt: 9}},
+	}, {
+		appendOps:  ops{appendVarint{inVal: 0x7fffffffffffffff + 1}},
+		wantRaw:    dhex("80808080808080808001"),
+		consumeOps: ops{consumeVarint{wantVal: 0x7fffffffffffffff + 1, wantCnt: 10}},
+	}, {
+		appendOps:  ops{appendVarint{inVal: math.MaxUint64}},
+		wantRaw:    dhex("ffffffffffffffffff01"),
+		consumeOps: ops{consumeVarint{wantVal: math.MaxUint64, wantCnt: 10}},
+	}, {
+		appendOps:  ops{appendRaw(dhex("ffffffffffffffffff02"))},
+		consumeOps: ops{consumeVarint{wantErr: errOverflow}},
+	}, {
+		// Test denormalized varints; where the encoding, while valid, is
+		// larger than necessary.
+		appendOps:  ops{appendRaw(dhex("01"))},
+		consumeOps: ops{consumeVarint{wantVal: 1, wantCnt: 1}},
+	}, {
+		appendOps:  ops{appendRaw(dhex("8100"))},
+		consumeOps: ops{consumeVarint{wantVal: 1, wantCnt: 2}},
+	}, {
+		appendOps:  ops{appendRaw(dhex("818000"))},
+		consumeOps: ops{consumeVarint{wantVal: 1, wantCnt: 3}},
+	}, {
+		appendOps:  ops{appendRaw(dhex("81808000"))},
+		consumeOps: ops{consumeVarint{wantVal: 1, wantCnt: 4}},
+	}, {
+		appendOps:  ops{appendRaw(dhex("8180808000"))},
+		consumeOps: ops{consumeVarint{wantVal: 1, wantCnt: 5}},
+	}, {
+		appendOps:  ops{appendRaw(dhex("818080808000"))},
+		consumeOps: ops{consumeVarint{wantVal: 1, wantCnt: 6}},
+	}, {
+		appendOps:  ops{appendRaw(dhex("81808080808000"))},
+		consumeOps: ops{consumeVarint{wantVal: 1, wantCnt: 7}},
+	}, {
+		appendOps:  ops{appendRaw(dhex("8180808080808000"))},
+		consumeOps: ops{consumeVarint{wantVal: 1, wantCnt: 8}},
+	}, {
+		appendOps:  ops{appendRaw(dhex("818080808080808000"))},
+		consumeOps: ops{consumeVarint{wantVal: 1, wantCnt: 9}},
+	}, {
+		appendOps:  ops{appendRaw(dhex("81808080808080808000"))},
+		consumeOps: ops{consumeVarint{wantVal: 1, wantCnt: 10}},
+	}, {
+		appendOps:  ops{appendRaw(dhex("8180808080808080808000"))},
+		consumeOps: ops{consumeVarint{wantErr: errOverflow}},
+	}})
+}
+
+func TestFixed32(t *testing.T) {
+	runTests(t, []testOps{{
+		appendOps:  ops{appendRaw(dhex(""))},
+		consumeOps: ops{consumeFixed32{wantErr: io.ErrUnexpectedEOF}},
+	}, {
+		appendOps:  ops{appendRaw(dhex("000000"))},
+		consumeOps: ops{consumeFixed32{wantErr: io.ErrUnexpectedEOF}},
+	}, {
+		appendOps:  ops{appendFixed32{0}},
+		wantRaw:    dhex("00000000"),
+		consumeOps: ops{consumeFixed32{wantVal: 0, wantCnt: 4}},
+	}, {
+		appendOps:  ops{appendFixed32{math.MaxUint32}},
+		wantRaw:    dhex("ffffffff"),
+		consumeOps: ops{consumeFixed32{wantVal: math.MaxUint32, wantCnt: 4}},
+	}, {
+		appendOps:  ops{appendFixed32{0xf0e1d2c3}},
+		wantRaw:    dhex("c3d2e1f0"),
+		consumeOps: ops{consumeFixed32{wantVal: 0xf0e1d2c3, wantCnt: 4}},
+	}})
+}
+
+func TestFixed64(t *testing.T) {
+	runTests(t, []testOps{{
+		appendOps:  ops{appendRaw(dhex(""))},
+		consumeOps: ops{consumeFixed64{wantErr: io.ErrUnexpectedEOF}},
+	}, {
+		appendOps:  ops{appendRaw(dhex("00000000000000"))},
+		consumeOps: ops{consumeFixed64{wantErr: io.ErrUnexpectedEOF}},
+	}, {
+		appendOps:  ops{appendFixed64{0}},
+		wantRaw:    dhex("0000000000000000"),
+		consumeOps: ops{consumeFixed64{wantVal: 0, wantCnt: 8}},
+	}, {
+		appendOps:  ops{appendFixed64{math.MaxUint64}},
+		wantRaw:    dhex("ffffffffffffffff"),
+		consumeOps: ops{consumeFixed64{wantVal: math.MaxUint64, wantCnt: 8}},
+	}, {
+		appendOps:  ops{appendFixed64{0xf0e1d2c3b4a59687}},
+		wantRaw:    dhex("8796a5b4c3d2e1f0"),
+		consumeOps: ops{consumeFixed64{wantVal: 0xf0e1d2c3b4a59687, wantCnt: 8}},
+	}})
+}
+
+func TestBytes(t *testing.T) {
+	runTests(t, []testOps{{
+		appendOps:  ops{appendRaw(dhex(""))},
+		consumeOps: ops{consumeBytes{wantErr: io.ErrUnexpectedEOF}},
+	}, {
+		appendOps:  ops{appendRaw(dhex("01"))},
+		consumeOps: ops{consumeBytes{wantErr: io.ErrUnexpectedEOF}},
+	}, {
+		appendOps:  ops{appendVarint{0}, appendRaw("")},
+		wantRaw:    dhex("00"),
+		consumeOps: ops{consumeBytes{wantVal: dhex(""), wantCnt: 1}},
+	}, {
+		appendOps:  ops{appendBytes{[]byte("hello")}},
+		wantRaw:    []byte("\x05hello"),
+		consumeOps: ops{consumeBytes{wantVal: []byte("hello"), wantCnt: 6}},
+	}, {
+		appendOps:  ops{appendBytes{[]byte(strings.Repeat("hello", 50))}},
+		wantRaw:    []byte("\xfa\x01" + strings.Repeat("hello", 50)),
+		consumeOps: ops{consumeBytes{wantVal: []byte(strings.Repeat("hello", 50)), wantCnt: 252}},
+	}, {
+		appendOps:  ops{appendRaw("\x85\x80\x00hello")},
+		consumeOps: ops{consumeBytes{wantVal: []byte("hello"), wantCnt: 8}},
+	}, {
+		appendOps:  ops{appendRaw("\x85\x80\x00hell")},
+		consumeOps: ops{consumeBytes{wantErr: io.ErrUnexpectedEOF}},
+	}})
+}
+
+func TestGroup(t *testing.T) {
+	runTests(t, []testOps{{
+		appendOps:  ops{appendRaw(dhex(""))},
+		consumeOps: ops{consumeGroup{wantErr: io.ErrUnexpectedEOF}},
+	}, {
+		appendOps:  ops{appendTag{inNum: 0, inType: StartGroupType}},
+		consumeOps: ops{consumeGroup{inNum: 1, wantErr: errFieldNumber}},
+	}, {
+		appendOps:  ops{appendTag{inNum: 2, inType: EndGroupType}},
+		consumeOps: ops{consumeGroup{inNum: 1, wantErr: errEndGroup}},
+	}, {
+		appendOps:  ops{appendTag{inNum: 1, inType: EndGroupType}},
+		consumeOps: ops{consumeGroup{inNum: 1, wantCnt: 1}},
+	}, {
+		appendOps: ops{
+			appendTag{inNum: 5, inType: Fixed32Type},
+			appendFixed32{0xf0e1d2c3},
+			appendTag{inNum: 5, inType: EndGroupType},
+		},
+		wantRaw:    dhex("2dc3d2e1f02c"),
+		consumeOps: ops{consumeGroup{inNum: 5, wantVal: dhex("2dc3d2e1f0"), wantCnt: 6}},
+	}, {
+		appendOps: ops{
+			appendTag{inNum: 5, inType: Fixed32Type},
+			appendFixed32{0xf0e1d2c3},
+			appendRaw(dhex("ac808000")),
+		},
+		consumeOps: ops{consumeGroup{inNum: 5, wantVal: dhex("2dc3d2e1f0"), wantCnt: 9}},
+	}})
+}
+
+func TestField(t *testing.T) {
+	runTests(t, []testOps{{
+		appendOps:  ops{appendRaw(dhex(""))},
+		consumeOps: ops{consumeField{wantErr: io.ErrUnexpectedEOF}},
+	}, {
+		appendOps: ops{
+			appendTag{inNum: 5000, inType: StartGroupType},
+			appendTag{inNum: 1, inType: VarintType},
+			appendVarint{123456789},
+			appendTag{inNum: 12, inType: Fixed32Type},
+			appendFixed32{123456789},
+			appendTag{inNum: 123, inType: Fixed64Type},
+			appendFixed64{123456789},
+			appendTag{inNum: 1234, inType: BytesType},
+			appendBytes{[]byte("hello")},
+			appendTag{inNum: 12345, inType: StartGroupType},
+			appendTag{inNum: 11, inType: VarintType},
+			appendVarint{123456789},
+			appendTag{inNum: 1212, inType: Fixed32Type},
+			appendFixed32{123456789},
+			appendTag{inNum: 123123, inType: Fixed64Type},
+			appendFixed64{123456789},
+			appendTag{inNum: 12341234, inType: BytesType},
+			appendBytes{[]byte("goodbye")},
+			appendTag{inNum: 12345, inType: EndGroupType},
+			appendTag{inNum: 5000, inType: EndGroupType},
+		},
+		wantRaw: dhex("c3b80208959aef3a6515cd5b07d90715cd5b0700000000924d0568656c6c6fcb830658959aef3ae54b15cd5b07998f3c15cd5b070000000092ff892f07676f6f64627965cc8306c4b802"),
+		consumeOps: ops{
+			consumeTag{wantNum: 5000, wantType: StartGroupType, wantCnt: 3},
+			consumeTag{wantNum: 1, wantType: VarintType, wantCnt: 1},
+			consumeVarint{wantVal: 123456789, wantCnt: 4},
+			consumeTag{wantNum: 12, wantType: Fixed32Type, wantCnt: 1},
+			consumeFixed32{wantVal: 123456789, wantCnt: 4},
+			consumeTag{wantNum: 123, wantType: Fixed64Type, wantCnt: 2},
+			consumeFixed64{wantVal: 123456789, wantCnt: 8},
+			consumeTag{wantNum: 1234, wantType: BytesType, wantCnt: 2},
+			consumeBytes{wantVal: []byte("hello"), wantCnt: 6},
+			consumeTag{wantNum: 12345, wantType: StartGroupType, wantCnt: 3},
+			consumeTag{wantNum: 11, wantType: VarintType, wantCnt: 1},
+			consumeVarint{wantVal: 123456789, wantCnt: 4},
+			consumeTag{wantNum: 1212, wantType: Fixed32Type, wantCnt: 2},
+			consumeFixed32{wantVal: 123456789, wantCnt: 4},
+			consumeTag{wantNum: 123123, wantType: Fixed64Type, wantCnt: 3},
+			consumeFixed64{wantVal: 123456789, wantCnt: 8},
+			consumeTag{wantNum: 12341234, wantType: BytesType, wantCnt: 4},
+			consumeBytes{wantVal: []byte("goodbye"), wantCnt: 8},
+			consumeTag{wantNum: 12345, wantType: EndGroupType, wantCnt: 3},
+			consumeTag{wantNum: 5000, wantType: EndGroupType, wantCnt: 3},
+		},
+	}, {
+		appendOps:  ops{appendRaw(dhex("c3b80208959aef3a6515cd5b07d90715cd5b0700000000924d0568656c6c6fcb830658959aef3ae54b15cd5b07998f3c15cd5b070000000092ff892f07676f6f64627965cc8306c4b802"))},
+		consumeOps: ops{consumeField{wantNum: 5000, wantType: StartGroupType, wantCnt: 74}},
+	}, {
+		appendOps:  ops{appendTag{inNum: 5, inType: EndGroupType}},
+		wantRaw:    dhex("2c"),
+		consumeOps: ops{consumeField{wantErr: errEndGroup}},
+	}, {
+		appendOps: ops{
+			appendTag{inNum: 1, inType: StartGroupType},
+			appendTag{inNum: 22, inType: StartGroupType},
+			appendTag{inNum: 333, inType: StartGroupType},
+			appendTag{inNum: 4444, inType: StartGroupType},
+			appendTag{inNum: 4444, inType: EndGroupType},
+			appendTag{inNum: 333, inType: EndGroupType},
+			appendTag{inNum: 22, inType: EndGroupType},
+			appendTag{inNum: 1, inType: EndGroupType},
+		},
+		wantRaw:    dhex("0bb301eb14e39502e49502ec14b4010c"),
+		consumeOps: ops{consumeField{wantNum: 1, wantType: StartGroupType, wantCnt: 16}},
+	}, {
+		appendOps: ops{
+			appendTag{inNum: 1, inType: StartGroupType},
+			appendGroup{inNum: 1, inVal: dhex("b301eb14e39502e49502ec14b401")},
+		},
+		wantRaw:    dhex("0b" + "b301eb14e39502e49502ec14b401" + "0c"),
+		consumeOps: ops{consumeField{wantNum: 1, wantType: StartGroupType, wantCnt: 16}},
+	}, {
+		appendOps: ops{
+			appendTag{inNum: 1, inType: StartGroupType},
+			appendTag{inNum: 22, inType: StartGroupType},
+			appendTag{inNum: 333, inType: StartGroupType},
+			appendTag{inNum: 4444, inType: StartGroupType},
+			appendTag{inNum: 333, inType: EndGroupType},
+			appendTag{inNum: 22, inType: EndGroupType},
+			appendTag{inNum: 1, inType: EndGroupType},
+		},
+		consumeOps: ops{consumeField{wantErr: errEndGroup}},
+	}, {
+		appendOps: ops{
+			appendTag{inNum: 1, inType: StartGroupType},
+			appendTag{inNum: 22, inType: StartGroupType},
+			appendTag{inNum: 333, inType: StartGroupType},
+			appendTag{inNum: 4444, inType: StartGroupType},
+			appendTag{inNum: 4444, inType: EndGroupType},
+			appendTag{inNum: 333, inType: EndGroupType},
+			appendTag{inNum: 22, inType: EndGroupType},
+		},
+		consumeOps: ops{consumeField{wantErr: io.ErrUnexpectedEOF}},
+	}, {
+		appendOps: ops{
+			appendTag{inNum: 1, inType: StartGroupType},
+			appendTag{inNum: 22, inType: StartGroupType},
+			appendTag{inNum: 333, inType: StartGroupType},
+			appendTag{inNum: 4444, inType: StartGroupType},
+			appendTag{inNum: 0, inType: VarintType},
+			appendTag{inNum: 4444, inType: EndGroupType},
+			appendTag{inNum: 333, inType: EndGroupType},
+			appendTag{inNum: 22, inType: EndGroupType},
+			appendTag{inNum: 1, inType: EndGroupType},
+		},
+		consumeOps: ops{consumeField{wantErr: errFieldNumber}},
+	}, {
+		appendOps: ops{
+			appendTag{inNum: 1, inType: StartGroupType},
+			appendTag{inNum: 22, inType: StartGroupType},
+			appendTag{inNum: 333, inType: StartGroupType},
+			appendTag{inNum: 4444, inType: StartGroupType},
+			appendTag{inNum: 1, inType: 6},
+			appendTag{inNum: 4444, inType: EndGroupType},
+			appendTag{inNum: 333, inType: EndGroupType},
+			appendTag{inNum: 22, inType: EndGroupType},
+			appendTag{inNum: 1, inType: EndGroupType},
+		},
+		consumeOps: ops{consumeField{wantErr: errReserved}},
+	}})
+}
+
+func runTests(t *testing.T, tests []testOps) {
+	for _, tt := range tests {
+		t.Run("", func(t *testing.T) {
+			var b []byte
+			for _, op := range tt.appendOps {
+				b0 := b
+				switch op := op.(type) {
+				case appendTag:
+					b = AppendTag(b, op.inNum, op.inType)
+				case appendVarint:
+					b = AppendVarint(b, op.inVal)
+				case appendFixed32:
+					b = AppendFixed32(b, op.inVal)
+				case appendFixed64:
+					b = AppendFixed64(b, op.inVal)
+				case appendBytes:
+					b = AppendBytes(b, op.inVal)
+				case appendGroup:
+					b = AppendGroup(b, op.inNum, op.inVal)
+				case appendRaw:
+					b = append(b, op...)
+				}
+
+				check := func(label string, want int) {
+					t.Helper()
+					if got := len(b) - len(b0); got != want {
+						t.Errorf("len(Append%v) and Size%v mismatch: got %v, want %v", label, label, got, want)
+					}
+				}
+				switch op := op.(type) {
+				case appendTag:
+					check("Tag", SizeTag(op.inNum))
+				case appendVarint:
+					check("Varint", SizeVarint(op.inVal))
+				case appendFixed32:
+					check("Fixed32", SizeFixed32())
+				case appendFixed64:
+					check("Fixed64", SizeFixed64())
+				case appendBytes:
+					check("Bytes", SizeBytes(len(op.inVal)))
+				case appendGroup:
+					check("Group", SizeGroup(op.inNum, len(op.inVal)))
+				}
+			}
+
+			if tt.wantRaw != nil && !bytes.Equal(b, tt.wantRaw) {
+				t.Errorf("raw output mismatch:\ngot  %x\nwant %x", b, tt.wantRaw)
+			}
+
+			for _, op := range tt.consumeOps {
+				check := func(label string, gotCnt, wantCnt int, wantErr error) {
+					t.Helper()
+					gotErr := ParseError(gotCnt)
+					if gotCnt < 0 {
+						gotCnt = 0
+					}
+					if gotCnt != wantCnt {
+						t.Errorf("Consume%v(): consumed %d bytes, want %d bytes consumed", label, gotCnt, wantCnt)
+					}
+					if gotErr != wantErr {
+						t.Errorf("Consume%v(): got %v error, want %v error", label, gotErr, wantErr)
+					}
+					b = b[gotCnt:]
+				}
+				switch op := op.(type) {
+				case consumeField:
+					gotNum, gotType, n := ConsumeField(b)
+					if gotNum != op.wantNum || gotType != op.wantType {
+						t.Errorf("ConsumeField() = (%d, %v), want (%d, %v)", gotNum, gotType, op.wantNum, op.wantType)
+					}
+					check("Field", n, op.wantCnt, op.wantErr)
+				case consumeFieldValue:
+					n := ConsumeFieldValue(op.inNum, op.inType, b)
+					check("FieldValue", n, op.wantCnt, op.wantErr)
+				case consumeTag:
+					gotNum, gotType, n := ConsumeTag(b)
+					if gotNum != op.wantNum || gotType != op.wantType {
+						t.Errorf("ConsumeTag() = (%d, %v), want (%d, %v)", gotNum, gotType, op.wantNum, op.wantType)
+					}
+					check("Tag", n, op.wantCnt, op.wantErr)
+				case consumeVarint:
+					gotVal, n := ConsumeVarint(b)
+					if gotVal != op.wantVal {
+						t.Errorf("ConsumeVarint() = %d, want %d", gotVal, op.wantVal)
+					}
+					check("Varint", n, op.wantCnt, op.wantErr)
+				case consumeFixed32:
+					gotVal, n := ConsumeFixed32(b)
+					if gotVal != op.wantVal {
+						t.Errorf("ConsumeFixed32() = %d, want %d", gotVal, op.wantVal)
+					}
+					check("Fixed32", n, op.wantCnt, op.wantErr)
+				case consumeFixed64:
+					gotVal, n := ConsumeFixed64(b)
+					if gotVal != op.wantVal {
+						t.Errorf("ConsumeFixed64() = %d, want %d", gotVal, op.wantVal)
+					}
+					check("Fixed64", n, op.wantCnt, op.wantErr)
+				case consumeBytes:
+					gotVal, n := ConsumeBytes(b)
+					if !bytes.Equal(gotVal, op.wantVal) {
+						t.Errorf("ConsumeBytes() = %x, want %x", gotVal, op.wantVal)
+					}
+					check("Bytes", n, op.wantCnt, op.wantErr)
+				case consumeGroup:
+					gotVal, n := ConsumeGroup(op.inNum, b)
+					if !bytes.Equal(gotVal, op.wantVal) {
+						t.Errorf("ConsumeGroup() = %x, want %x", gotVal, op.wantVal)
+					}
+					check("Group", n, op.wantCnt, op.wantErr)
+				}
+			}
+		})
+	}
+}
+
+func TestZigZag(t *testing.T) {
+	tests := []struct {
+		dec int64
+		enc uint64
+	}{
+		{math.MinInt64 + 0, math.MaxUint64 - 0},
+		{math.MinInt64 + 1, math.MaxUint64 - 2},
+		{math.MinInt64 + 2, math.MaxUint64 - 4},
+		{-3, 5},
+		{-2, 3},
+		{-1, 1},
+		{0, 0},
+		{+1, 2},
+		{+2, 4},
+		{+3, 6},
+		{math.MaxInt64 - 2, math.MaxUint64 - 5},
+		{math.MaxInt64 - 1, math.MaxUint64 - 3},
+		{math.MaxInt64 - 0, math.MaxUint64 - 1},
+	}
+
+	for _, tt := range tests {
+		if enc := EncodeZigZag(tt.dec); enc != tt.enc {
+			t.Errorf("EncodeZigZag(%d) = %d, want %d", tt.dec, enc, tt.enc)
+		}
+		if dec := DecodeZigZag(tt.enc); dec != tt.dec {
+			t.Errorf("DecodeZigZag(%d) = %d, want %d", tt.enc, dec, tt.dec)
+		}
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/go.mod b/vendor/google.golang.org/protobuf/go.mod
new file mode 100644
index 000000000..bebf0972d
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/go.mod
@@ -0,0 +1,8 @@
+module google.golang.org/protobuf
+
+go 1.9
+
+require (
+	github.com/golang/protobuf v1.4.0
+	github.com/google/go-cmp v0.4.0
+)
diff --git a/vendor/google.golang.org/protobuf/go.sum b/vendor/google.golang.org/protobuf/go.sum
new file mode 100644
index 000000000..a40ccf1a1
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/go.sum
@@ -0,0 +1,17 @@
+github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
+github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
+github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
+github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
+github.com/golang/protobuf v1.4.0 h1:oOuy+ugB+P/kBdUnG5QaMXSIyJ1q38wWSojYCb3z5VQ=
+github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
+github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.4.0 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
+google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
+google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
+google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
+google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
diff --git a/vendor/google.golang.org/protobuf/integration_test.go b/vendor/google.golang.org/protobuf/integration_test.go
new file mode 100644
index 000000000..07bda42c3
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/integration_test.go
@@ -0,0 +1,428 @@
+// Copyright 2019 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.
+
+// +build ignore
+
+package main
+
+import (
+	"archive/tar"
+	"bytes"
+	"compress/gzip"
+	"flag"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	"google.golang.org/protobuf/internal/version"
+)
+
+var (
+	regenerate   = flag.Bool("regenerate", false, "regenerate files")
+	buildRelease = flag.Bool("buildRelease", false, "build release binaries")
+
+	protobufVersion = "ef7cc811" // v3.12.0-rc1
+	golangVersions  = []string{"1.9.7", "1.10.8", "1.11.13", "1.12.17", "1.13.8", "1.14"}
+	golangLatest    = golangVersions[len(golangVersions)-1]
+
+	// purgeTimeout determines the maximum age of unused sub-directories.
+	purgeTimeout = 30 * 24 * time.Hour // 1 month
+
+	// Variables initialized by mustInitDeps.
+	goPath       string
+	modulePath   string
+	protobufPath string
+)
+
+func Test(t *testing.T) {
+	mustInitDeps(t)
+	mustHandleFlags(t)
+
+	// Report dirt in the working tree quickly, rather than after
+	// going through all the presubmits.
+	//
+	// Fail the test late, so we can test uncommitted changes with -failfast.
+	gitDiff := mustRunCommand(t, "git", "diff", "HEAD")
+	if strings.TrimSpace(gitDiff) != "" {
+		fmt.Printf("WARNING: working tree contains uncommitted changes:\n%v\n", gitDiff)
+	}
+	gitUntracked := mustRunCommand(t, "git", "ls-files", "--others", "--exclude-standard")
+	if strings.TrimSpace(gitUntracked) != "" {
+		fmt.Printf("WARNING: working tree contains untracked files:\n%v\n", gitUntracked)
+	}
+
+	// Do the relatively fast checks up-front.
+	t.Run("GeneratedGoFiles", func(t *testing.T) {
+		diff := mustRunCommand(t, "go", "run", "-tags", "protolegacy", "./internal/cmd/generate-types")
+		if strings.TrimSpace(diff) != "" {
+			t.Fatalf("stale generated files:\n%v", diff)
+		}
+		diff = mustRunCommand(t, "go", "run", "-tags", "protolegacy", "./internal/cmd/generate-protos")
+		if strings.TrimSpace(diff) != "" {
+			t.Fatalf("stale generated files:\n%v", diff)
+		}
+	})
+	t.Run("FormattedGoFiles", func(t *testing.T) {
+		files := strings.Split(strings.TrimSpace(mustRunCommand(t, "git", "ls-files", "*.go")), "\n")
+		diff := mustRunCommand(t, append([]string{"gofmt", "-d"}, files...)...)
+		if strings.TrimSpace(diff) != "" {
+			t.Fatalf("unformatted source files:\n%v", diff)
+		}
+	})
+	t.Run("CopyrightHeaders", func(t *testing.T) {
+		files := strings.Split(strings.TrimSpace(mustRunCommand(t, "git", "ls-files", "*.go", "*.proto")), "\n")
+		mustHaveCopyrightHeader(t, files)
+	})
+
+	var wg sync.WaitGroup
+	sema := make(chan bool, (runtime.NumCPU()+1)/2)
+	for i := range golangVersions {
+		goVersion := golangVersions[i]
+		goLabel := "Go" + goVersion
+		runGo := func(label, workDir string, args ...string) {
+			wg.Add(1)
+			sema <- true
+			go func() {
+				defer wg.Done()
+				defer func() { <-sema }()
+				t.Run(goLabel+"/"+label, func(t *testing.T) {
+					args[0] += goVersion
+					command{Dir: workDir}.mustRun(t, args...)
+				})
+			}()
+		}
+
+		workDir := filepath.Join(goPath, "src", modulePath)
+		runGo("Normal", workDir, "go", "test", "-race", "./...")
+		runGo("PureGo", workDir, "go", "test", "-race", "-tags", "purego", "./...")
+		runGo("Reflect", workDir, "go", "test", "-race", "-tags", "protoreflect", "./...")
+		if goVersion == golangLatest {
+			runGo("ProtoLegacy", workDir, "go", "test", "-race", "-tags", "protolegacy", "./...")
+			runGo("ProtocGenGo", "cmd/protoc-gen-go/testdata", "go", "test")
+			runGo("Conformance", "internal/conformance", "go", "test", "-execute")
+		}
+	}
+	wg.Wait()
+
+	t.Run("CommittedGitChanges", func(t *testing.T) {
+		if strings.TrimSpace(gitDiff) != "" {
+			t.Fatalf("uncommitted changes")
+		}
+	})
+	t.Run("TrackedGitFiles", func(t *testing.T) {
+		if strings.TrimSpace(gitUntracked) != "" {
+			t.Fatalf("untracked files")
+		}
+	})
+}
+
+func mustInitDeps(t *testing.T) {
+	check := func(err error) {
+		t.Helper()
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	// Determine the directory to place the test directory.
+	repoRoot, err := os.Getwd()
+	check(err)
+	testDir := filepath.Join(repoRoot, ".cache")
+	check(os.MkdirAll(testDir, 0775))
+
+	// Travis-CI has a hard-coded timeout where it kills the test after
+	// 10 minutes of a lack of activity on stdout.
+	// We work around this restriction by periodically printing the timestamp.
+	ticker := time.NewTicker(5 * time.Minute)
+	done := make(chan struct{})
+	go func() {
+		now := time.Now()
+		for {
+			select {
+			case t := <-ticker.C:
+				fmt.Printf("\tt=%0.fmin\n", t.Sub(now).Minutes())
+			case <-done:
+				return
+			}
+		}
+	}()
+	defer close(done)
+	defer ticker.Stop()
+
+	// Delete the current directory if non-empty,
+	// which only occurs if a dependency failed to initialize properly.
+	var workingDir string
+	defer func() {
+		if workingDir != "" {
+			os.RemoveAll(workingDir) // best-effort
+		}
+	}()
+
+	// Delete other sub-directories that are no longer relevant.
+	defer func() {
+		subDirs := map[string]bool{"bin": true, "gopath": true}
+		subDirs["protobuf-"+protobufVersion] = true
+		for _, v := range golangVersions {
+			subDirs["go"+v] = true
+		}
+
+		now := time.Now()
+		fis, _ := ioutil.ReadDir(testDir)
+		for _, fi := range fis {
+			if subDirs[fi.Name()] {
+				os.Chtimes(filepath.Join(testDir, fi.Name()), now, now) // best-effort
+				continue
+			}
+			if now.Sub(fi.ModTime()) < purgeTimeout {
+				continue
+			}
+			fmt.Printf("delete %v\n", fi.Name())
+			os.RemoveAll(filepath.Join(testDir, fi.Name())) // best-effort
+		}
+	}()
+
+	// The bin directory contains symlinks to each tool by version.
+	// It is safe to delete this directory and run the test script from scratch.
+	binPath := filepath.Join(testDir, "bin")
+	check(os.RemoveAll(binPath))
+	check(os.Mkdir(binPath, 0775))
+	check(os.Setenv("PATH", binPath+":"+os.Getenv("PATH")))
+	registerBinary := func(name, path string) {
+		check(os.Symlink(path, filepath.Join(binPath, name)))
+	}
+
+	// Download and build the protobuf toolchain.
+	// We avoid downloading the pre-compiled binaries since they do not contain
+	// the conformance test runner.
+	workingDir = filepath.Join(testDir, "protobuf-"+protobufVersion)
+	protobufPath = workingDir
+	if _, err := os.Stat(protobufPath); err != nil {
+		fmt.Printf("download %v\n", filepath.Base(protobufPath))
+		if isCommit := strings.Trim(protobufVersion, "0123456789abcdef") == ""; isCommit {
+			command{Dir: testDir}.mustRun(t, "git", "clone", "https://github.com/protocolbuffers/protobuf", "protobuf-"+protobufVersion)
+			command{Dir: protobufPath}.mustRun(t, "git", "checkout", protobufVersion)
+		} else {
+			url := fmt.Sprintf("https://github.com/google/protobuf/releases/download/v%v/protobuf-all-%v.tar.gz", protobufVersion, protobufVersion)
+			downloadArchive(check, protobufPath, url, "protobuf-"+protobufVersion)
+		}
+
+		fmt.Printf("build %v\n", filepath.Base(protobufPath))
+		command{Dir: protobufPath}.mustRun(t, "./autogen.sh")
+		command{Dir: protobufPath}.mustRun(t, "./configure")
+		command{Dir: protobufPath}.mustRun(t, "make")
+		command{Dir: filepath.Join(protobufPath, "conformance")}.mustRun(t, "make")
+	}
+	check(os.Setenv("PROTOBUF_ROOT", protobufPath)) // for generate-protos
+	registerBinary("conform-test-runner", filepath.Join(protobufPath, "conformance", "conformance-test-runner"))
+	registerBinary("protoc", filepath.Join(protobufPath, "src", "protoc"))
+	workingDir = ""
+
+	// Download each Go toolchain version.
+	for _, v := range golangVersions {
+		workingDir = filepath.Join(testDir, "go"+v)
+		if _, err := os.Stat(workingDir); err != nil {
+			fmt.Printf("download %v\n", filepath.Base(workingDir))
+			url := fmt.Sprintf("https://dl.google.com/go/go%v.%v-%v.tar.gz", v, runtime.GOOS, runtime.GOARCH)
+			downloadArchive(check, workingDir, url, "go")
+		}
+		registerBinary("go"+v, filepath.Join(workingDir, "bin", "go"))
+	}
+	registerBinary("go", filepath.Join(testDir, "go"+golangLatest, "bin", "go"))
+	registerBinary("gofmt", filepath.Join(testDir, "go"+golangLatest, "bin", "gofmt"))
+	workingDir = ""
+
+	// Travis-CI sets GOROOT, which confuses invocations of the Go toolchain.
+	// Explicitly clear GOROOT, so each toolchain uses their default GOROOT.
+	check(os.Unsetenv("GOROOT"))
+
+	// Set a cache directory outside the test directory.
+	check(os.Setenv("GOCACHE", filepath.Join(repoRoot, ".gocache")))
+
+	// Setup GOPATH for pre-module support (i.e., go1.10 and earlier).
+	goPath = filepath.Join(testDir, "gopath")
+	modulePath = strings.TrimSpace(command{Dir: testDir}.mustRun(t, "go", "list", "-m", "-f", "{{.Path}}"))
+	check(os.RemoveAll(filepath.Join(goPath, "src")))
+	check(os.MkdirAll(filepath.Join(goPath, "src", filepath.Dir(modulePath)), 0775))
+	check(os.Symlink(repoRoot, filepath.Join(goPath, "src", modulePath)))
+	command{Dir: repoRoot}.mustRun(t, "go", "mod", "tidy")
+	command{Dir: repoRoot}.mustRun(t, "go", "mod", "vendor")
+	check(os.Setenv("GOPATH", goPath))
+}
+
+func downloadFile(check func(error), dstPath, srcURL string) {
+	resp, err := http.Get(srcURL)
+	check(err)
+	defer resp.Body.Close()
+
+	check(os.MkdirAll(filepath.Dir(dstPath), 0775))
+	f, err := os.Create(dstPath)
+	check(err)
+
+	_, err = io.Copy(f, resp.Body)
+	check(err)
+}
+
+func downloadArchive(check func(error), dstPath, srcURL, skipPrefix string) {
+	check(os.RemoveAll(dstPath))
+
+	resp, err := http.Get(srcURL)
+	check(err)
+	defer resp.Body.Close()
+
+	zr, err := gzip.NewReader(resp.Body)
+	check(err)
+
+	tr := tar.NewReader(zr)
+	for {
+		h, err := tr.Next()
+		if err == io.EOF {
+			return
+		}
+		check(err)
+
+		// Skip directories or files outside the prefix directory.
+		if len(skipPrefix) > 0 {
+			if !strings.HasPrefix(h.Name, skipPrefix) {
+				continue
+			}
+			if len(h.Name) > len(skipPrefix) && h.Name[len(skipPrefix)] != '/' {
+				continue
+			}
+		}
+
+		path := strings.TrimPrefix(strings.TrimPrefix(h.Name, skipPrefix), "/")
+		path = filepath.Join(dstPath, filepath.FromSlash(path))
+		mode := os.FileMode(h.Mode & 0777)
+		switch h.Typeflag {
+		case tar.TypeReg:
+			b, err := ioutil.ReadAll(tr)
+			check(err)
+			check(ioutil.WriteFile(path, b, mode))
+		case tar.TypeDir:
+			check(os.Mkdir(path, mode))
+		}
+	}
+}
+
+func mustHandleFlags(t *testing.T) {
+	if *regenerate {
+		t.Run("Generate", func(t *testing.T) {
+			fmt.Print(mustRunCommand(t, "go", "run", "-tags", "protolegacy", "./internal/cmd/generate-types", "-execute"))
+			fmt.Print(mustRunCommand(t, "go", "run", "-tags", "protolegacy", "./internal/cmd/generate-protos", "-execute"))
+			files := strings.Split(strings.TrimSpace(mustRunCommand(t, "git", "ls-files", "*.go")), "\n")
+			mustRunCommand(t, append([]string{"gofmt", "-w"}, files...)...)
+		})
+	}
+	if *buildRelease {
+		t.Run("BuildRelease", func(t *testing.T) {
+			v := version.String()
+			for _, goos := range []string{"linux", "darwin", "windows"} {
+				for _, goarch := range []string{"386", "amd64"} {
+					binPath := filepath.Join("bin", fmt.Sprintf("protoc-gen-go.%v.%v.%v", v, goos, goarch))
+
+					// Build the binary.
+					cmd := command{Env: append(os.Environ(), "GOOS="+goos, "GOARCH="+goarch)}
+					cmd.mustRun(t, "go", "build", "-trimpath", "-ldflags", "-s -w -buildid=", "-o", binPath, "./cmd/protoc-gen-go")
+
+					// Archive and compress the binary.
+					in, err := ioutil.ReadFile(binPath)
+					if err != nil {
+						t.Fatal(err)
+					}
+					out := new(bytes.Buffer)
+					gz, _ := gzip.NewWriterLevel(out, gzip.BestCompression)
+					gz.Comment = fmt.Sprintf("protoc-gen-go VERSION=%v GOOS=%v GOARCH=%v", v, goos, goarch)
+					tw := tar.NewWriter(gz)
+					tw.WriteHeader(&tar.Header{
+						Name: "protoc-gen-go",
+						Mode: int64(0775),
+						Size: int64(len(in)),
+					})
+					tw.Write(in)
+					tw.Close()
+					gz.Close()
+					if err := ioutil.WriteFile(binPath+".tar.gz", out.Bytes(), 0664); err != nil {
+						t.Fatal(err)
+					}
+				}
+			}
+		})
+	}
+	if *regenerate || *buildRelease {
+		t.SkipNow()
+	}
+}
+
+var copyrightRegex = []*regexp.Regexp{
+	regexp.MustCompile(`^// Copyright \d\d\d\d 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\.
+`),
+	// Generated .pb.go files from main protobuf repo.
+	regexp.MustCompile(`^// Protocol Buffers - Google's data interchange format
+// Copyright \d\d\d\d Google Inc\.  All rights reserved\.
+`),
+}
+
+func mustHaveCopyrightHeader(t *testing.T, files []string) {
+	var bad []string
+File:
+	for _, file := range files {
+		b, err := ioutil.ReadFile(file)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, re := range copyrightRegex {
+			if loc := re.FindIndex(b); loc != nil && loc[0] == 0 {
+				continue File
+			}
+		}
+		bad = append(bad, file)
+	}
+	if len(bad) > 0 {
+		t.Fatalf("files with missing/bad copyright headers:\n  %v", strings.Join(bad, "\n  "))
+	}
+}
+
+type command struct {
+	Dir string
+	Env []string
+}
+
+func (c command) mustRun(t *testing.T, args ...string) string {
+	t.Helper()
+	stdout := new(bytes.Buffer)
+	stderr := new(bytes.Buffer)
+	cmd := exec.Command(args[0], args[1:]...)
+	cmd.Dir = "."
+	if c.Dir != "" {
+		cmd.Dir = c.Dir
+	}
+	cmd.Env = os.Environ()
+	if c.Env != nil {
+		cmd.Env = c.Env
+	}
+	cmd.Env = append(cmd.Env, "PWD="+cmd.Dir)
+	cmd.Stdout = stdout
+	cmd.Stderr = stderr
+	if err := cmd.Run(); err != nil {
+		t.Fatalf("executing (%v): %v\n%s%s", strings.Join(args, " "), err, stdout.String(), stderr.String())
+	}
+	return stdout.String()
+}
+
+func mustRunCommand(t *testing.T, args ...string) string {
+	t.Helper()
+	return command{}.mustRun(t, args...)
+}
diff --git a/vendor/google.golang.org/protobuf/internal/benchmarks/bench_test.go b/vendor/google.golang.org/protobuf/internal/benchmarks/bench_test.go
new file mode 100644
index 000000000..33b18fcaa
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/benchmarks/bench_test.go
@@ -0,0 +1,216 @@
+// Copyright 2019 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 bench_test
+
+import (
+	"flag"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"google.golang.org/protobuf/encoding/protojson"
+	"google.golang.org/protobuf/encoding/prototext"
+	"google.golang.org/protobuf/proto"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+	preg "google.golang.org/protobuf/reflect/protoregistry"
+
+	benchpb "google.golang.org/protobuf/internal/testprotos/benchmarks"
+	_ "google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message1/proto2"
+	_ "google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message1/proto3"
+	_ "google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message2"
+	_ "google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3"
+	_ "google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message4"
+)
+
+func BenchmarkWire(b *testing.B) {
+	bench(b, "Unmarshal", func(ds dataset, pb *testing.PB) {
+		for pb.Next() {
+			for _, p := range ds.wire {
+				m := ds.messageType.New().Interface()
+				if err := proto.Unmarshal(p, m); err != nil {
+					b.Fatal(err)
+				}
+			}
+		}
+	})
+	bench(b, "Marshal", func(ds dataset, pb *testing.PB) {
+		for pb.Next() {
+			for _, m := range ds.messages {
+				if _, err := proto.Marshal(m); err != nil {
+					b.Fatal(err)
+				}
+			}
+		}
+	})
+	bench(b, "Size", func(ds dataset, pb *testing.PB) {
+		for pb.Next() {
+			for _, m := range ds.messages {
+				proto.Size(m)
+			}
+		}
+	})
+}
+
+func BenchmarkText(b *testing.B) {
+	bench(b, "Unmarshal", func(ds dataset, pb *testing.PB) {
+		for pb.Next() {
+			for _, p := range ds.text {
+				m := ds.messageType.New().Interface()
+				if err := prototext.Unmarshal(p, m); err != nil {
+					b.Fatal(err)
+				}
+			}
+		}
+	})
+	bench(b, "Marshal", func(ds dataset, pb *testing.PB) {
+		for pb.Next() {
+			for _, m := range ds.messages {
+				if _, err := prototext.Marshal(m); err != nil {
+					b.Fatal(err)
+				}
+			}
+		}
+	})
+}
+
+func BenchmarkJSON(b *testing.B) {
+	bench(b, "Unmarshal", func(ds dataset, pb *testing.PB) {
+		for pb.Next() {
+			for _, p := range ds.json {
+				m := ds.messageType.New().Interface()
+				if err := protojson.Unmarshal(p, m); err != nil {
+					b.Fatal(err)
+				}
+			}
+		}
+	})
+	bench(b, "Marshal", func(ds dataset, pb *testing.PB) {
+		for pb.Next() {
+			for _, m := range ds.messages {
+				if _, err := protojson.Marshal(m); err != nil {
+					b.Fatal(err)
+				}
+			}
+		}
+	})
+}
+
+func Benchmark(b *testing.B) {
+	bench(b, "Clone", func(ds dataset, pb *testing.PB) {
+		for pb.Next() {
+			for _, src := range ds.messages {
+				proto.Clone(src)
+			}
+		}
+	})
+}
+
+func bench(b *testing.B, name string, f func(dataset, *testing.PB)) {
+	b.Helper()
+	b.Run(name, func(b *testing.B) {
+		for _, ds := range datasets {
+			b.Run(ds.name, func(b *testing.B) {
+				b.RunParallel(func(pb *testing.PB) {
+					f(ds, pb)
+				})
+			})
+		}
+	})
+}
+
+type dataset struct {
+	name        string
+	messageType pref.MessageType
+	messages    []proto.Message
+	wire        [][]byte
+	text        [][]byte
+	json        [][]byte
+}
+
+var datasets []dataset
+
+func TestMain(m *testing.M) {
+	// Load benchmark data early, to avoid including this step in -cpuprofile/-memprofile.
+	//
+	// For the larger benchmark datasets (not downloaded by default), preparing
+	// this data is quite expensive. In addition, keeping the unmarshaled messages
+	// in memory makes GC scans a substantial fraction of runtime CPU cost.
+	//
+	// It would be nice to avoid loading the data we aren't going to use. Unfortunately,
+	// there isn't any simple way to tell what benchmarks are going to run; we can examine
+	// the -test.bench flag, but parsing it is quite complicated.
+	flag.Parse()
+	if v := flag.Lookup("test.bench").Value.(flag.Getter).Get(); v == "" {
+		// Don't bother loading data if we aren't going to run any benchmarks.
+		// Avoids slowing down go test ./...
+		return
+	}
+	if v := flag.Lookup("test.timeout").Value.(flag.Getter).Get().(time.Duration); v != 0 && v <= 10*time.Minute {
+		// The default test timeout of 10m is too short if running all the benchmarks.
+		// It's quite frustrating to discover this 10m through a benchmark run, so
+		// catch the condition.
+		//
+		// The -timeout and -test.timeout flags are handled by the go command, which
+		// forwards them along to the test binary, so we can't just set the default
+		// to something reasonable; the go command will override it with its default.
+		// We also can't ignore the timeout, because the go command kills a test which
+		// runs more than a minute past its deadline.
+		fmt.Fprintf(os.Stderr, "Test timeout of %v is probably too short; set -test.timeout=0.\n", v)
+		os.Exit(1)
+	}
+	out, err := exec.Command("git", "rev-parse", "--show-toplevel").CombinedOutput()
+	if err != nil {
+		panic(err)
+	}
+	repoRoot := strings.TrimSpace(string(out))
+	dataDir := filepath.Join(repoRoot, ".cache", "benchdata")
+	filepath.Walk(dataDir, func(path string, _ os.FileInfo, _ error) error {
+		if filepath.Ext(path) != ".pb" {
+			return nil
+		}
+		raw, err := ioutil.ReadFile(path)
+		if err != nil {
+			panic(err)
+		}
+		dspb := &benchpb.BenchmarkDataset{}
+		if err := proto.Unmarshal(raw, dspb); err != nil {
+			panic(err)
+		}
+		mt, err := preg.GlobalTypes.FindMessageByName(pref.FullName(dspb.MessageName))
+		if err != nil {
+			panic(err)
+		}
+		ds := dataset{
+			name:        dspb.Name,
+			messageType: mt,
+			wire:        dspb.Payload,
+		}
+		for _, payload := range dspb.Payload {
+			m := mt.New().Interface()
+			if err := proto.Unmarshal(payload, m); err != nil {
+				panic(err)
+			}
+			ds.messages = append(ds.messages, m)
+			b, err := prototext.Marshal(m)
+			if err != nil {
+				panic(err)
+			}
+			ds.text = append(ds.text, b)
+			b, err = protojson.Marshal(m)
+			if err != nil {
+				panic(err)
+			}
+			ds.json = append(ds.json, b)
+		}
+		datasets = append(datasets, ds)
+		return nil
+	})
+	os.Exit(m.Run())
+}
diff --git a/vendor/google.golang.org/protobuf/internal/benchmarks/download_benchdata.bash b/vendor/google.golang.org/protobuf/internal/benchmarks/download_benchdata.bash
new file mode 100644
index 000000000..30399e7f7
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/benchmarks/download_benchdata.bash
@@ -0,0 +1,17 @@
+#!/bin/bash
+# Copyright 2019 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.
+
+cd "$(git rev-parse --show-toplevel)"
+mkdir -p .cache/benchdata
+cd .cache/benchdata
+
+# Download small benchmark datasets.
+PROTOBUF_VERSION=v3.11.4
+curl -s -O https://raw.githubusercontent.com/protocolbuffers/protobuf/$PROTOBUF_VERSION/benchmarks/datasets/google_message1/proto2/dataset.google_message1_proto2.pb
+curl -s -O https://raw.githubusercontent.com/protocolbuffers/protobuf/$PROTOBUF_VERSION/benchmarks/datasets/google_message1/proto3/dataset.google_message1_proto3.pb
+curl -s -O https://raw.githubusercontent.com/protocolbuffers/protobuf/$PROTOBUF_VERSION/benchmarks/datasets/google_message2/dataset.google_message2.pb
+
+# Download large benchmark datasets.
+curl -s https://storage.googleapis.com/protobuf_opensource_benchmark_data/datasets.tar.gz | tar zx
diff --git a/vendor/google.golang.org/protobuf/internal/benchmarks/micro/micro_test.go b/vendor/google.golang.org/protobuf/internal/benchmarks/micro/micro_test.go
new file mode 100644
index 000000000..dd967448b
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/benchmarks/micro/micro_test.go
@@ -0,0 +1,198 @@
+// Copyright 2020 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.
+
+// This package contains microbenchmarks exercising specific areas of interest.
+// The benchmarks here are not comprehensive and are not necessarily indicative
+// real-world performance.
+
+package micro_test
+
+import (
+	"testing"
+
+	"google.golang.org/protobuf/internal/impl"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/runtime/protoiface"
+	"google.golang.org/protobuf/types/known/emptypb"
+
+	micropb "google.golang.org/protobuf/internal/testprotos/benchmarks/micro"
+	testpb "google.golang.org/protobuf/internal/testprotos/test"
+)
+
+// BenchmarkEmptyMessage tests a google.protobuf.Empty.
+//
+// It measures per-operation overhead.
+func BenchmarkEmptyMessage(b *testing.B) {
+	b.Run("Wire/Marshal", func(b *testing.B) {
+		b.RunParallel(func(pb *testing.PB) {
+			m := &emptypb.Empty{}
+			for pb.Next() {
+				if _, err := proto.Marshal(m); err != nil {
+					b.Fatal(err)
+				}
+			}
+		})
+	})
+	b.Run("Wire/Unmarshal", func(b *testing.B) {
+		opts := proto.UnmarshalOptions{
+			Merge: true,
+		}
+		b.RunParallel(func(pb *testing.PB) {
+			m := &emptypb.Empty{}
+			for pb.Next() {
+				if err := opts.Unmarshal([]byte{}, m); err != nil {
+					b.Fatal(err)
+				}
+			}
+		})
+	})
+	b.Run("Wire/Validate", func(b *testing.B) {
+		b.RunParallel(func(pb *testing.PB) {
+			mt := (&emptypb.Empty{}).ProtoReflect().Type()
+			for pb.Next() {
+				_, got := impl.Validate(mt, protoiface.UnmarshalInput{})
+				want := impl.ValidationValid
+				if got != want {
+					b.Fatalf("Validate = %v, want %v", got, want)
+				}
+			}
+		})
+	})
+	b.Run("Clone", func(b *testing.B) {
+		b.RunParallel(func(pb *testing.PB) {
+			m := &emptypb.Empty{}
+			for pb.Next() {
+				proto.Clone(m)
+			}
+		})
+	})
+}
+
+// BenchmarkRepeatedInt32 tests a message containing 500 non-packed repeated int32s.
+//
+// For unmarshal operations, it measures the cost of the field decode loop, since each
+// item in the repeated field has an individual tag and value.
+func BenchmarkRepeatedInt32(b *testing.B) {
+	m := &testpb.TestAllTypes{}
+	for i := int32(0); i < 500; i++ {
+		m.RepeatedInt32 = append(m.RepeatedInt32, i)
+	}
+	w, err := proto.Marshal(m)
+	if err != nil {
+		b.Fatal(err)
+	}
+	b.Run("Wire/Marshal", func(b *testing.B) {
+		b.RunParallel(func(pb *testing.PB) {
+			for pb.Next() {
+				if _, err := proto.Marshal(m); err != nil {
+					b.Fatal(err)
+				}
+			}
+		})
+	})
+	b.Run("Wire/Unmarshal", func(b *testing.B) {
+		opts := proto.UnmarshalOptions{
+			Merge: true,
+		}
+		b.RunParallel(func(pb *testing.PB) {
+			m := &testpb.TestAllTypes{}
+			for pb.Next() {
+				m.RepeatedInt32 = m.RepeatedInt32[:0]
+				if err := opts.Unmarshal(w, m); err != nil {
+					b.Fatal(err)
+				}
+			}
+		})
+	})
+	b.Run("Wire/Validate", func(b *testing.B) {
+		b.RunParallel(func(pb *testing.PB) {
+			mt := (&testpb.TestAllTypes{}).ProtoReflect().Type()
+			for pb.Next() {
+				_, got := impl.Validate(mt, protoiface.UnmarshalInput{
+					Buf: w,
+				})
+				want := impl.ValidationValid
+				if got != want {
+					b.Fatalf("Validate = %v, want %v", got, want)
+				}
+			}
+		})
+	})
+	b.Run("Clone", func(b *testing.B) {
+		b.RunParallel(func(pb *testing.PB) {
+			for pb.Next() {
+				proto.Clone(m)
+			}
+		})
+	})
+}
+
+// BenchmarkRequired tests a message containing a required field.
+func BenchmarkRequired(b *testing.B) {
+	m := &micropb.SixteenRequired{
+		F1:  proto.Int32(1),
+		F2:  proto.Int32(1),
+		F3:  proto.Int32(1),
+		F4:  proto.Int32(1),
+		F5:  proto.Int32(1),
+		F6:  proto.Int32(1),
+		F7:  proto.Int32(1),
+		F8:  proto.Int32(1),
+		F9:  proto.Int32(1),
+		F10: proto.Int32(1),
+		F11: proto.Int32(1),
+		F12: proto.Int32(1),
+		F13: proto.Int32(1),
+		F14: proto.Int32(1),
+		F15: proto.Int32(1),
+		F16: proto.Int32(1),
+	}
+	w, err := proto.Marshal(m)
+	if err != nil {
+		b.Fatal(err)
+	}
+	b.Run("Wire/Marshal", func(b *testing.B) {
+		b.RunParallel(func(pb *testing.PB) {
+			for pb.Next() {
+				if _, err := proto.Marshal(m); err != nil {
+					b.Fatal(err)
+				}
+			}
+		})
+	})
+	b.Run("Wire/Unmarshal", func(b *testing.B) {
+		opts := proto.UnmarshalOptions{
+			Merge: true,
+		}
+		b.RunParallel(func(pb *testing.PB) {
+			m := &micropb.SixteenRequired{}
+			for pb.Next() {
+				if err := opts.Unmarshal(w, m); err != nil {
+					b.Fatal(err)
+				}
+			}
+		})
+	})
+	b.Run("Wire/Validate", func(b *testing.B) {
+		b.RunParallel(func(pb *testing.PB) {
+			mt := (&micropb.SixteenRequired{}).ProtoReflect().Type()
+			for pb.Next() {
+				_, got := impl.Validate(mt, protoiface.UnmarshalInput{
+					Buf: w,
+				})
+				want := impl.ValidationValid
+				if got != want {
+					b.Fatalf("Validate = %v, want %v", got, want)
+				}
+			}
+		})
+	})
+	b.Run("Clone", func(b *testing.B) {
+		b.RunParallel(func(pb *testing.PB) {
+			for pb.Next() {
+				proto.Clone(m)
+			}
+		})
+	})
+}
diff --git a/vendor/google.golang.org/protobuf/internal/cmd/generate-corpus/main.go b/vendor/google.golang.org/protobuf/internal/cmd/generate-corpus/main.go
new file mode 100644
index 000000000..8f77dea95
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/cmd/generate-corpus/main.go
@@ -0,0 +1,137 @@
+// Copyright 2019 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.
+
+// Program generate-corpus generates a seed corpus for the fuzzers.
+//
+// This command is not run automatically because its output is not stable.
+// It's present in source control mainly as documentation of where the seed
+// corpus came from.
+package main
+
+import (
+	"crypto/sha1"
+	"fmt"
+	"io/ioutil"
+	"log"
+
+	"google.golang.org/protobuf/encoding/protojson"
+	"google.golang.org/protobuf/encoding/prototext"
+	"google.golang.org/protobuf/proto"
+
+	fuzzpb "google.golang.org/protobuf/internal/testprotos/fuzz"
+	testpb "google.golang.org/protobuf/internal/testprotos/test"
+)
+
+var messages = []proto.Message{
+	&fuzzpb.Fuzz{
+		TestAllTypes: &testpb.TestAllTypes{
+			OptionalInt32:      proto.Int32(1001),
+			OptionalInt64:      proto.Int64(1002),
+			OptionalUint32:     proto.Uint32(1003),
+			OptionalUint64:     proto.Uint64(1004),
+			OptionalSint32:     proto.Int32(1005),
+			OptionalSint64:     proto.Int64(1006),
+			OptionalFixed32:    proto.Uint32(1007),
+			OptionalFixed64:    proto.Uint64(1008),
+			OptionalSfixed32:   proto.Int32(1009),
+			OptionalSfixed64:   proto.Int64(1010),
+			OptionalFloat:      proto.Float32(1011.5),
+			OptionalDouble:     proto.Float64(1012.5),
+			OptionalBool:       proto.Bool(true),
+			OptionalString:     proto.String("string"),
+			OptionalBytes:      []byte("bytes"),
+			OptionalNestedEnum: testpb.TestAllTypes_BAR.Enum(),
+			Optionalgroup: &testpb.TestAllTypes_OptionalGroup{
+				A: proto.Int32(1017),
+			},
+			OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{
+				A: proto.Int32(42),
+				Corecursive: &testpb.TestAllTypes{
+					OptionalInt32: proto.Int32(43),
+				},
+			},
+			RepeatedInt32:    []int32{1001, 2001},
+			RepeatedInt64:    []int64{1002, 2002},
+			RepeatedUint32:   []uint32{1003, 2003},
+			RepeatedUint64:   []uint64{1004, 2004},
+			RepeatedSint32:   []int32{1005, 2005},
+			RepeatedSint64:   []int64{1006, 2006},
+			RepeatedFixed32:  []uint32{1007, 2007},
+			RepeatedFixed64:  []uint64{1008, 2008},
+			RepeatedSfixed32: []int32{1009, 2009},
+			RepeatedSfixed64: []int64{1010, 2010},
+			RepeatedFloat:    []float32{1011.5, 2011.5},
+			RepeatedDouble:   []float64{1012.5, 2012.5},
+			RepeatedBool:     []bool{true, false},
+			RepeatedString:   []string{"foo", "bar"},
+			RepeatedBytes:    [][]byte{[]byte("FOO"), []byte("BAR")},
+			RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{
+				testpb.TestAllTypes_FOO,
+				testpb.TestAllTypes_BAR,
+			},
+			RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{
+				{A: proto.Int32(1)},
+				nil,
+				{A: proto.Int32(2)},
+			},
+			Repeatedgroup: []*testpb.TestAllTypes_RepeatedGroup{
+				{A: proto.Int32(1017)},
+				nil,
+				{A: proto.Int32(2017)},
+			},
+			MapInt32Int32:       map[int32]int32{1056: 1156, 2056: 2156},
+			MapInt64Int64:       map[int64]int64{1057: 1157, 2057: 2157},
+			MapUint32Uint32:     map[uint32]uint32{1058: 1158, 2058: 2158},
+			MapUint64Uint64:     map[uint64]uint64{1059: 1159, 2059: 2159},
+			MapSint32Sint32:     map[int32]int32{1060: 1160, 2060: 2160},
+			MapSint64Sint64:     map[int64]int64{1061: 1161, 2061: 2161},
+			MapFixed32Fixed32:   map[uint32]uint32{1062: 1162, 2062: 2162},
+			MapFixed64Fixed64:   map[uint64]uint64{1063: 1163, 2063: 2163},
+			MapSfixed32Sfixed32: map[int32]int32{1064: 1164, 2064: 2164},
+			MapSfixed64Sfixed64: map[int64]int64{1065: 1165, 2065: 2165},
+			MapInt32Float:       map[int32]float32{1066: 1166.5, 2066: 2166.5},
+			MapInt32Double:      map[int32]float64{1067: 1167.5, 2067: 2167.5},
+			MapBoolBool:         map[bool]bool{true: false, false: true},
+			MapStringString:     map[string]string{"69.1.key": "69.1.val", "69.2.key": "69.2.val"},
+			MapStringBytes:      map[string][]byte{"70.1.key": []byte("70.1.val"), "70.2.key": []byte("70.2.val")},
+			MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{
+				"71.1.key": {A: proto.Int32(1171)},
+				"71.2.key": {A: proto.Int32(2171)},
+			},
+			MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{
+				"73.1.key": testpb.TestAllTypes_FOO,
+				"73.2.key": testpb.TestAllTypes_BAR,
+			},
+			OneofField: &testpb.TestAllTypes_OneofUint32{1111},
+		},
+	},
+}
+
+func main() {
+	for _, m := range messages {
+		wire, err := proto.Marshal(m)
+		if err != nil {
+			log.Fatal(err)
+		}
+		if err := ioutil.WriteFile(fmt.Sprintf("internal/fuzz/wirefuzz/corpus/%x", sha1.Sum(wire)), wire, 0777); err != nil {
+			log.Fatal(err)
+		}
+
+		text, err := prototext.Marshal(m)
+		if err != nil {
+			log.Fatal(err)
+		}
+		if err := ioutil.WriteFile(fmt.Sprintf("internal/fuzz/textfuzz/corpus/%x", sha1.Sum(text)), text, 0777); err != nil {
+			log.Fatal(err)
+		}
+
+		json, err := protojson.Marshal(m)
+		if err != nil {
+			log.Fatal(err)
+		}
+		if err := ioutil.WriteFile(fmt.Sprintf("internal/fuzz/jsonfuzz/corpus/%x", sha1.Sum(json)), json, 0777); err != nil {
+			log.Fatal(err)
+		}
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/cmd/generate-protos/main.go b/vendor/google.golang.org/protobuf/internal/cmd/generate-protos/main.go
new file mode 100644
index 000000000..8544cad0b
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/cmd/generate-protos/main.go
@@ -0,0 +1,370 @@
+// Copyright 2019 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.
+
+//go:generate go run . -execute
+
+package main
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"go/format"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strings"
+
+	gengo "google.golang.org/protobuf/cmd/protoc-gen-go/internal_gengo"
+	"google.golang.org/protobuf/compiler/protogen"
+	"google.golang.org/protobuf/internal/detrand"
+	"google.golang.org/protobuf/reflect/protoreflect"
+)
+
+// Override the location of the Go package for various source files.
+// TOOD: Commit these changes upstream.
+var protoPackages = map[string]string{
+	// Locally override field_mask.proto to an internal copy.
+	// We need this package as a dependency of several tests,
+	// but it currently lives in google.golang.org/genproto, which
+	// we do not want a dependency on.
+	//
+	// TODO: Move the canonical package into this module.
+	"google/protobuf/field_mask.proto": "google.golang.org/protobuf/internal/testprotos/fieldmaskpb",
+
+	"google/protobuf/any.proto":                  "google.golang.org/protobuf/types/known/anypb;anypb",
+	"google/protobuf/duration.proto":             "google.golang.org/protobuf/types/known/durationpb;durationpb",
+	"google/protobuf/empty.proto":                "google.golang.org/protobuf/types/known/emptypb;emptypb",
+	"google/protobuf/struct.proto":               "google.golang.org/protobuf/types/known/structpb;structpb",
+	"google/protobuf/timestamp.proto":            "google.golang.org/protobuf/types/known/timestamppb;timestamppb",
+	"google/protobuf/wrappers.proto":             "google.golang.org/protobuf/types/known/wrapperspb;wrapperspb",
+	"google/protobuf/descriptor.proto":           "google.golang.org/protobuf/types/descriptorpb;descriptorpb",
+	"google/protobuf/compiler/plugin.proto":      "google.golang.org/protobuf/types/pluginpb;pluginpb",
+	"conformance/conformance.proto":              "google.golang.org/protobuf/internal/testprotos/conformance;conformance",
+	"google/protobuf/test_messages_proto2.proto": "google.golang.org/protobuf/internal/testprotos/conformance;conformance",
+	"google/protobuf/test_messages_proto3.proto": "google.golang.org/protobuf/internal/testprotos/conformance;conformance",
+
+	"benchmarks.proto": "google.golang.org/protobuf/internal/testprotos/benchmarks;benchmarks",
+	"datasets/google_message1/proto2/benchmark_message1_proto2.proto": "google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message1/proto2;proto2",
+	"datasets/google_message1/proto3/benchmark_message1_proto3.proto": "google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message1/proto3;proto3",
+	"datasets/google_message2/benchmark_message2.proto":               "google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message2;google_message2",
+	"datasets/google_message3/benchmark_message3.proto":               "google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3;google_message3",
+	"datasets/google_message3/benchmark_message3_1.proto":             "google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3;google_message3",
+	"datasets/google_message3/benchmark_message3_2.proto":             "google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3;google_message3",
+	"datasets/google_message3/benchmark_message3_3.proto":             "google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3;google_message3",
+	"datasets/google_message3/benchmark_message3_4.proto":             "google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3;google_message3",
+	"datasets/google_message3/benchmark_message3_5.proto":             "google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3;google_message3",
+	"datasets/google_message3/benchmark_message3_6.proto":             "google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3;google_message3",
+	"datasets/google_message3/benchmark_message3_7.proto":             "google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3;google_message3",
+	"datasets/google_message3/benchmark_message3_8.proto":             "google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3;google_message3",
+	"datasets/google_message4/benchmark_message4.proto":               "google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message4;google_message4",
+	"datasets/google_message4/benchmark_message4_1.proto":             "google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message4;google_message4",
+	"datasets/google_message4/benchmark_message4_2.proto":             "google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message4;google_message4",
+	"datasets/google_message4/benchmark_message4_3.proto":             "google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message4;google_message4",
+
+	"cmd/protoc-gen-go/testdata/nopackage/nopackage.proto": "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/nopackage",
+}
+
+func init() {
+	// Determine repository root path.
+	out, err := exec.Command("git", "rev-parse", "--show-toplevel").CombinedOutput()
+	check(err)
+	repoRoot = strings.TrimSpace(string(out))
+
+	// Determine the module path.
+	cmd := exec.Command("go", "list", "-m", "-f", "{{.Path}}")
+	cmd.Dir = repoRoot
+	out, err = cmd.CombinedOutput()
+	check(err)
+	modulePath = strings.TrimSpace(string(out))
+
+	// When the environment variable RUN_AS_PROTOC_PLUGIN is set,
+	// we skip running main and instead act as a protoc plugin.
+	// This allows the binary to pass itself to protoc.
+	if plugin := os.Getenv("RUN_AS_PROTOC_PLUGIN"); plugin != "" {
+		// Disable deliberate output instability for generated files.
+		// This is reasonable since we fully control the output.
+		detrand.Disable()
+
+		protogen.Options{}.Run(func(gen *protogen.Plugin) error {
+			for _, file := range gen.Files {
+				if file.Generate {
+					gengo.GenerateVersionMarkers = false
+					gengo.GenerateFile(gen, file)
+					generateFieldNumbers(gen, file)
+				}
+			}
+			gen.SupportedFeatures = gengo.SupportedFeatures
+			return nil
+		})
+		os.Exit(0)
+	}
+}
+
+var (
+	run        bool
+	protoRoot  string
+	repoRoot   string
+	modulePath string
+
+	generatedPreamble = []string{
+		"// Copyright 2019 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.",
+		"",
+		"// Code generated by generate-protos. DO NOT EDIT.",
+		"",
+	}
+)
+
+func main() {
+	flag.BoolVar(&run, "execute", false, "Write generated files to destination.")
+	flag.StringVar(&protoRoot, "protoroot", os.Getenv("PROTOBUF_ROOT"), "The root of the protobuf source tree.")
+	flag.Parse()
+	if protoRoot == "" {
+		panic("protobuf source root is not set")
+	}
+
+	generateLocalProtos()
+	generateRemoteProtos()
+}
+
+func generateLocalProtos() {
+	tmpDir, err := ioutil.TempDir(repoRoot, "tmp")
+	check(err)
+	defer os.RemoveAll(tmpDir)
+
+	// Generate all local proto files (except version-locked files).
+	dirs := []struct {
+		path        string
+		annotateFor map[string]bool
+		exclude     map[string]bool
+	}{
+		{path: "cmd/protoc-gen-go/testdata", annotateFor: map[string]bool{
+			"cmd/protoc-gen-go/testdata/annotations/annotations.proto": true},
+		},
+		{path: "internal/testprotos", exclude: map[string]bool{
+			"internal/testprotos/irregular/irregular.proto": true,
+		}},
+	}
+	excludeRx := regexp.MustCompile(`legacy/.*/`)
+	for _, d := range dirs {
+		subDirs := map[string]bool{}
+
+		dstDir := tmpDir
+		check(os.MkdirAll(dstDir, 0775))
+
+		srcDir := filepath.Join(repoRoot, filepath.FromSlash(d.path))
+		filepath.Walk(srcDir, func(srcPath string, _ os.FileInfo, _ error) error {
+			if !strings.HasSuffix(srcPath, ".proto") || excludeRx.MatchString(srcPath) {
+				return nil
+			}
+			relPath, err := filepath.Rel(repoRoot, srcPath)
+			check(err)
+
+			srcRelPath, err := filepath.Rel(srcDir, srcPath)
+			check(err)
+			subDirs[filepath.Dir(srcRelPath)] = true
+
+			if d.exclude[filepath.ToSlash(relPath)] {
+				return nil
+			}
+
+			opts := "module=" + modulePath
+			opts += "," + protoMapOpt()
+
+			// Emit a .meta file for certain files.
+			if d.annotateFor[filepath.ToSlash(relPath)] {
+				opts += ",annotate_code"
+			}
+
+			protoc("-I"+filepath.Join(protoRoot, "src"), "-I"+repoRoot, "--go_out="+opts+":"+dstDir, relPath)
+			return nil
+		})
+
+		// For directories in testdata, generate a test that links in all
+		// generated packages to ensure that it builds and initializes properly.
+		// This is done because "go build ./..." does not build sub-packages
+		// under testdata.
+		if filepath.Base(d.path) == "testdata" {
+			var imports []string
+			for sd := range subDirs {
+				imports = append(imports, fmt.Sprintf("_ %q", path.Join(modulePath, d.path, filepath.ToSlash(sd))))
+			}
+			sort.Strings(imports)
+
+			s := strings.Join(append(generatedPreamble, []string{
+				"package main",
+				"",
+				"import (" + strings.Join(imports, "\n") + ")",
+			}...), "\n")
+			b, err := format.Source([]byte(s))
+			check(err)
+			check(ioutil.WriteFile(filepath.Join(tmpDir, filepath.FromSlash(d.path+"/gen_test.go")), b, 0664))
+		}
+	}
+
+	syncOutput(repoRoot, tmpDir)
+}
+
+func generateRemoteProtos() {
+	tmpDir, err := ioutil.TempDir(repoRoot, "tmp")
+	check(err)
+	defer os.RemoveAll(tmpDir)
+
+	// Generate all remote proto files.
+	files := []struct{ prefix, path string }{
+		{"", "conformance/conformance.proto"},
+		{"benchmarks", "benchmarks.proto"},
+		{"benchmarks", "datasets/google_message1/proto2/benchmark_message1_proto2.proto"},
+		{"benchmarks", "datasets/google_message1/proto3/benchmark_message1_proto3.proto"},
+		{"benchmarks", "datasets/google_message2/benchmark_message2.proto"},
+		{"benchmarks", "datasets/google_message3/benchmark_message3.proto"},
+		{"benchmarks", "datasets/google_message3/benchmark_message3_1.proto"},
+		{"benchmarks", "datasets/google_message3/benchmark_message3_2.proto"},
+		{"benchmarks", "datasets/google_message3/benchmark_message3_3.proto"},
+		{"benchmarks", "datasets/google_message3/benchmark_message3_4.proto"},
+		{"benchmarks", "datasets/google_message3/benchmark_message3_5.proto"},
+		{"benchmarks", "datasets/google_message3/benchmark_message3_6.proto"},
+		{"benchmarks", "datasets/google_message3/benchmark_message3_7.proto"},
+		{"benchmarks", "datasets/google_message3/benchmark_message3_8.proto"},
+		{"benchmarks", "datasets/google_message4/benchmark_message4.proto"},
+		{"benchmarks", "datasets/google_message4/benchmark_message4_1.proto"},
+		{"benchmarks", "datasets/google_message4/benchmark_message4_2.proto"},
+		{"benchmarks", "datasets/google_message4/benchmark_message4_3.proto"},
+		// TODO: The commented-out entires below are currently part of
+		// google.golang.org/genproto. Move them into this module.
+		{"src", "google/protobuf/any.proto"},
+		//{"src", "google/protobuf/api.proto"},
+		{"src", "google/protobuf/compiler/plugin.proto"},
+		{"src", "google/protobuf/descriptor.proto"},
+		{"src", "google/protobuf/duration.proto"},
+		{"src", "google/protobuf/empty.proto"},
+		{"src", "google/protobuf/field_mask.proto"},
+		//{"src", "google/protobuf/source_context.proto"},
+		{"src", "google/protobuf/struct.proto"},
+		{"src", "google/protobuf/test_messages_proto2.proto"},
+		{"src", "google/protobuf/test_messages_proto3.proto"},
+		{"src", "google/protobuf/timestamp.proto"},
+		//{"src", "google/protobuf/type.proto"},
+		{"src", "google/protobuf/wrappers.proto"},
+	}
+	for _, f := range files {
+		protoc("-I"+filepath.Join(protoRoot, f.prefix), "--go_out=paths=import,"+protoMapOpt()+":"+tmpDir, f.path)
+	}
+
+	syncOutput(repoRoot, filepath.Join(tmpDir, modulePath))
+
+	// Sanity check for unsynchronized files.
+	os.RemoveAll(filepath.Join(tmpDir, modulePath))
+	check(filepath.Walk(tmpDir, func(path string, fi os.FileInfo, err error) error {
+		if !fi.IsDir() {
+			return fmt.Errorf("unsynchronized generated file: %v", strings.TrimPrefix(path, tmpDir))
+		}
+		return err
+	}))
+}
+
+func protoc(args ...string) {
+	// TODO: Remove --experimental_allow_proto3_optional flag.
+	cmd := exec.Command("protoc", "--plugin=protoc-gen-go="+os.Args[0], "--experimental_allow_proto3_optional")
+	cmd.Args = append(cmd.Args, args...)
+	cmd.Env = append(os.Environ(), "RUN_AS_PROTOC_PLUGIN=1")
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		fmt.Printf("executing: %v\n%s\n", strings.Join(cmd.Args, " "), out)
+	}
+	check(err)
+}
+
+// generateFieldNumbers generates an internal package for descriptor.proto
+// and well-known types.
+func generateFieldNumbers(gen *protogen.Plugin, file *protogen.File) {
+	if file.Desc.Package() != "google.protobuf" {
+		return
+	}
+
+	importPath := modulePath + "/internal/fieldnum"
+	base := strings.TrimSuffix(path.Base(file.Desc.Path()), ".proto")
+	g := gen.NewGeneratedFile(importPath+"/"+base+"_gen.go", protogen.GoImportPath(importPath))
+	for _, s := range generatedPreamble {
+		g.P(s)
+	}
+	g.P("package ", path.Base(importPath))
+	g.P("")
+
+	var processMessages func([]*protogen.Message)
+	processMessages = func(messages []*protogen.Message) {
+		for _, message := range messages {
+			g.P("// Field numbers for ", message.Desc.FullName(), ".")
+			g.P("const (")
+			for _, field := range message.Fields {
+				fd := field.Desc
+				typeName := fd.Kind().String()
+				switch fd.Kind() {
+				case protoreflect.EnumKind:
+					typeName = string(fd.Enum().FullName())
+				case protoreflect.MessageKind, protoreflect.GroupKind:
+					typeName = string(fd.Message().FullName())
+				}
+				g.P(message.GoIdent.GoName, "_", field.GoName, "=", fd.Number(), "// ", fd.Cardinality(), " ", typeName)
+			}
+			g.P(")")
+			processMessages(message.Messages)
+		}
+	}
+	processMessages(file.Messages)
+}
+
+func syncOutput(dstDir, srcDir string) {
+	filepath.Walk(srcDir, func(srcPath string, _ os.FileInfo, _ error) error {
+		if !strings.HasSuffix(srcPath, ".go") && !strings.HasSuffix(srcPath, ".meta") {
+			return nil
+		}
+		relPath, err := filepath.Rel(srcDir, srcPath)
+		check(err)
+		dstPath := filepath.Join(dstDir, relPath)
+
+		if run {
+			if copyFile(dstPath, srcPath) {
+				fmt.Println("#", relPath)
+			}
+		} else {
+			cmd := exec.Command("diff", dstPath, srcPath, "-N", "-u")
+			cmd.Stdout = os.Stdout
+			cmd.Run()
+		}
+		return nil
+	})
+}
+
+func copyFile(dstPath, srcPath string) (changed bool) {
+	src, err := ioutil.ReadFile(srcPath)
+	check(err)
+	check(os.MkdirAll(filepath.Dir(dstPath), 0775))
+	dst, _ := ioutil.ReadFile(dstPath)
+	if bytes.Equal(src, dst) {
+		return false
+	}
+	check(ioutil.WriteFile(dstPath, src, 0664))
+	return true
+}
+
+func protoMapOpt() string {
+	var opts []string
+	for k, v := range protoPackages {
+		opts = append(opts, fmt.Sprintf("M%v=%v", k, v))
+	}
+	return strings.Join(opts, ",")
+}
+
+func check(err error) {
+	if err != nil {
+		panic(err)
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/cmd/generate-types/impl.go b/vendor/google.golang.org/protobuf/internal/cmd/generate-types/impl.go
new file mode 100644
index 000000000..6068671b8
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/cmd/generate-types/impl.go
@@ -0,0 +1,874 @@
+// Copyright 2019 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 main
+
+import (
+	"text/template"
+)
+
+func generateImplCodec() string {
+	return mustExecute(implCodecTemplate, ProtoKinds)
+}
+
+var implCodecTemplate = template.Must(template.New("").Parse(`
+{{- /*
+  IsZero is an expression testing if 'v' is the zero value.
+*/ -}}
+{{- define "IsZero" -}}
+{{if eq .WireType "Bytes" -}}
+len(v) == 0
+{{- else if or (eq .Name "Double") (eq .Name "Float") -}}
+v == 0 && !math.Signbit(float64(v))
+{{- else -}}
+v == {{.GoType.Zero}}
+{{- end -}}
+{{- end -}}
+
+{{- /*
+  Size is an expression computing the size of 'v'.
+*/ -}}
+{{- define "Size" -}}
+{{- if .WireType.ConstSize -}}
+protowire.Size{{.WireType}}()
+{{- else if eq .WireType "Bytes" -}}
+protowire.SizeBytes(len({{.FromGoType}}))
+{{- else -}}
+protowire.Size{{.WireType}}({{.FromGoType}})
+{{- end -}}
+{{- end -}}
+
+{{- define "SizeValue" -}}
+{{- if .WireType.ConstSize -}}
+protowire.Size{{.WireType}}()
+{{- else if eq .WireType "Bytes" -}}
+protowire.SizeBytes(len({{.FromValue}}))
+{{- else -}}
+protowire.Size{{.WireType}}({{.FromValue}})
+{{- end -}}
+{{- end -}}
+
+{{- /*
+  Append is a set of statements appending 'v' to 'b'.
+*/ -}}
+{{- define "Append" -}}
+{{- if eq .Name "String" -}}
+b = protowire.AppendString(b, {{.FromGoType}})
+{{- else -}}
+b = protowire.Append{{.WireType}}(b, {{.FromGoType}})
+{{- end -}}
+{{- end -}}
+
+{{- define "AppendValue" -}}
+{{- if eq .Name "String" -}}
+b = protowire.AppendString(b, {{.FromValue}})
+{{- else -}}
+b = protowire.Append{{.WireType}}(b, {{.FromValue}})
+{{- end -}}
+{{- end -}}
+
+{{- define "Consume" -}}
+{{- if eq .Name "String" -}}
+v, n := protowire.ConsumeString(b)
+{{- else if eq .WireType "Varint" -}}
+var v uint64
+var n int
+if len(b) >= 1 && b[0] < 0x80 {
+	v = uint64(b[0])
+	n = 1
+} else if len(b) >= 2 && b[1] < 128 {
+	v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+	n = 2
+} else {
+	v, n = protowire.ConsumeVarint(b)
+}
+{{- else -}}
+v, n := protowire.Consume{{.WireType}}(b)
+{{- end -}}
+{{- end -}}
+
+{{- range .}}
+
+{{- if .FromGoType }}
+// size{{.Name}} returns the size of wire encoding a {{.GoType}} pointer as a {{.Name}}.
+func size{{.Name}}(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	{{if not .WireType.ConstSize -}}
+	v := *p.{{.GoType.PointerMethod}}()
+	{{- end}}
+	return f.tagsize + {{template "Size" .}}
+}
+
+// append{{.Name}} wire encodes a {{.GoType}} pointer as a {{.Name}}.
+func append{{.Name}}(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.{{.GoType.PointerMethod}}()
+	b = protowire.AppendVarint(b, f.wiretag)
+	{{template "Append" .}}
+	return b, nil
+}
+
+// consume{{.Name}} wire decodes a {{.GoType}} pointer as a {{.Name}}.
+func consume{{.Name}}(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != {{.WireType.Expr}} {
+		return out, errUnknown
+	}
+	{{template "Consume" .}}
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	*p.{{.GoType.PointerMethod}}() = {{.ToGoType}}
+	out.n = n
+	return out, nil
+}
+
+var coder{{.Name}} = pointerCoderFuncs{
+	size:      size{{.Name}},
+	marshal:   append{{.Name}},
+	unmarshal: consume{{.Name}},
+	merge:     merge{{.GoType.PointerMethod}},
+}
+
+{{if or (eq .Name "Bytes") (eq .Name "String")}}
+// append{{.Name}}ValidateUTF8 wire encodes a {{.GoType}} pointer as a {{.Name}}.
+func append{{.Name}}ValidateUTF8(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.{{.GoType.PointerMethod}}()
+	b = protowire.AppendVarint(b, f.wiretag)
+	{{template "Append" .}}
+	if !utf8.Valid{{if eq .Name "String"}}String{{end}}(v) {
+		return b, errInvalidUTF8{}
+	}
+	return b, nil
+}
+
+// consume{{.Name}}ValidateUTF8 wire decodes a {{.GoType}} pointer as a {{.Name}}.
+func consume{{.Name}}ValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != {{.WireType.Expr}} {
+		return out, errUnknown
+	}
+	{{template "Consume" .}}
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	if !utf8.Valid{{if eq .Name "String"}}String{{end}}(v) {
+		return out, errInvalidUTF8{}
+	}
+	*p.{{.GoType.PointerMethod}}() = {{.ToGoType}}
+	out.n = n
+	return out, nil
+}
+
+var coder{{.Name}}ValidateUTF8 = pointerCoderFuncs{
+	size:      size{{.Name}},
+	marshal:   append{{.Name}}ValidateUTF8,
+	unmarshal: consume{{.Name}}ValidateUTF8,
+	merge:     merge{{.GoType.PointerMethod}},
+}
+{{end}}
+
+// size{{.Name}}NoZero returns the size of wire encoding a {{.GoType}} pointer as a {{.Name}}.
+// The zero value is not encoded.
+func size{{.Name}}NoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	v := *p.{{.GoType.PointerMethod}}()
+	if {{template "IsZero" .}} {
+		return 0
+	}
+	return f.tagsize + {{template "Size" .}}
+}
+
+// append{{.Name}}NoZero wire encodes a {{.GoType}} pointer as a {{.Name}}.
+// The zero value is not encoded.
+func append{{.Name}}NoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.{{.GoType.PointerMethod}}()
+	if {{template "IsZero" .}} {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, f.wiretag)
+	{{template "Append" .}}
+	return b, nil
+}
+
+{{if .ToGoTypeNoZero}}
+// consume{{.Name}}NoZero wire decodes a {{.GoType}} pointer as a {{.Name}}.
+// The zero value is not decoded.
+func consume{{.Name}}NoZero(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != {{.WireType.Expr}} {
+		return out, errUnknown
+	}
+	{{template "Consume" .}}
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	*p.{{.GoType.PointerMethod}}() = {{.ToGoTypeNoZero}}
+	out.n = n
+	return out, nil
+}
+{{end}}
+
+var coder{{.Name}}NoZero = pointerCoderFuncs{
+	size:      size{{.Name}}NoZero,
+	marshal:   append{{.Name}}NoZero,
+	unmarshal: consume{{.Name}}{{if .ToGoTypeNoZero}}NoZero{{end}},
+	merge:     merge{{.GoType.PointerMethod}}NoZero,
+}
+
+{{if or (eq .Name "Bytes") (eq .Name "String")}}
+// append{{.Name}}NoZeroValidateUTF8 wire encodes a {{.GoType}} pointer as a {{.Name}}.
+// The zero value is not encoded.
+func append{{.Name}}NoZeroValidateUTF8(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.{{.GoType.PointerMethod}}()
+	if {{template "IsZero" .}} {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, f.wiretag)
+	{{template "Append" .}}
+	if !utf8.Valid{{if eq .Name "String"}}String{{end}}(v) {
+		return b, errInvalidUTF8{}
+	}
+	return b, nil
+}
+
+{{if .ToGoTypeNoZero}}
+// consume{{.Name}}NoZeroValidateUTF8 wire decodes a {{.GoType}} pointer as a {{.Name}}.
+func consume{{.Name}}NoZeroValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != {{.WireType.Expr}} {
+		return out, errUnknown
+	}
+	{{template "Consume" .}}
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	if !utf8.Valid{{if eq .Name "String"}}String{{end}}(v) {
+		return out, errInvalidUTF8{}
+	}
+	*p.{{.GoType.PointerMethod}}() = {{.ToGoTypeNoZero}}
+	out.n = n
+	return out, nil
+}
+{{end}}
+
+var coder{{.Name}}NoZeroValidateUTF8 = pointerCoderFuncs{
+	size:      size{{.Name}}NoZero,
+	marshal:   append{{.Name}}NoZeroValidateUTF8,
+	unmarshal: consume{{.Name}}{{if .ToGoTypeNoZero}}NoZero{{end}}ValidateUTF8,
+	merge:     merge{{.GoType.PointerMethod}}NoZero,
+}
+{{end}}
+
+{{- if not .NoPointer}}
+// size{{.Name}}Ptr returns the size of wire encoding a *{{.GoType}} pointer as a {{.Name}}.
+// It panics if the pointer is nil.
+func size{{.Name}}Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	{{if not .WireType.ConstSize -}}
+	v := **p.{{.GoType.PointerMethod}}Ptr()
+	{{end -}}
+	return f.tagsize + {{template "Size" .}}
+}
+
+// append{{.Name}}Ptr wire encodes a *{{.GoType}} pointer as a {{.Name}}.
+// It panics if the pointer is nil.
+func append{{.Name}}Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := **p.{{.GoType.PointerMethod}}Ptr()
+	b = protowire.AppendVarint(b, f.wiretag)
+	{{template "Append" .}}
+	return b, nil
+}
+
+// consume{{.Name}}Ptr wire decodes a *{{.GoType}} pointer as a {{.Name}}.
+func consume{{.Name}}Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != {{.WireType.Expr}} {
+		return out, errUnknown
+	}
+	{{template "Consume" .}}
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	vp := p.{{.GoType.PointerMethod}}Ptr()
+	if *vp == nil {
+		*vp = new({{.GoType}})
+	}
+	**vp = {{.ToGoType}}
+	out.n = n
+	return out, nil
+}
+
+var coder{{.Name}}Ptr = pointerCoderFuncs{
+	size:      size{{.Name}}Ptr,
+	marshal:   append{{.Name}}Ptr,
+	unmarshal: consume{{.Name}}Ptr,
+	merge:     merge{{.GoType.PointerMethod}}Ptr,
+}
+{{end}}
+
+{{if (eq .Name "String")}}
+// append{{.Name}}PtrValidateUTF8 wire encodes a *{{.GoType}} pointer as a {{.Name}}.
+// It panics if the pointer is nil.
+func append{{.Name}}PtrValidateUTF8(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := **p.{{.GoType.PointerMethod}}Ptr()
+	b = protowire.AppendVarint(b, f.wiretag)
+	{{template "Append" .}}
+	if !utf8.Valid{{if eq .Name "String"}}String{{end}}(v) {
+		return b, errInvalidUTF8{}
+	}
+	return b, nil
+}
+
+// consume{{.Name}}PtrValidateUTF8 wire decodes a *{{.GoType}} pointer as a {{.Name}}.
+func consume{{.Name}}PtrValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != {{.WireType.Expr}} {
+		return out, errUnknown
+	}
+	{{template "Consume" .}}
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	if !utf8.Valid{{if eq .Name "String"}}String{{end}}(v) {
+		return out, errInvalidUTF8{}
+	}
+	vp := p.{{.GoType.PointerMethod}}Ptr()
+	if *vp == nil {
+		*vp = new({{.GoType}})
+	}
+	**vp = {{.ToGoType}}
+	out.n = n
+	return out, nil
+}
+
+var coder{{.Name}}PtrValidateUTF8 = pointerCoderFuncs{
+	size:      size{{.Name}}Ptr,
+	marshal:   append{{.Name}}PtrValidateUTF8,
+	unmarshal: consume{{.Name}}PtrValidateUTF8,
+	merge:     merge{{.GoType.PointerMethod}}Ptr,
+}
+{{end}}
+
+// size{{.Name}}Slice returns the size of wire encoding a []{{.GoType}} pointer as a repeated {{.Name}}.
+func size{{.Name}}Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	s := *p.{{.GoType.PointerMethod}}Slice()
+	{{if .WireType.ConstSize -}}
+	size = len(s) * (f.tagsize + {{template "Size" .}})
+	{{- else -}}
+	for _, v := range s {
+		size += f.tagsize + {{template "Size" .}}
+	}
+	{{- end}}
+	return size
+}
+
+// append{{.Name}}Slice encodes a []{{.GoType}} pointer as a repeated {{.Name}}.
+func append{{.Name}}Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	s := *p.{{.GoType.PointerMethod}}Slice()
+	for _, v := range s {
+		b = protowire.AppendVarint(b, f.wiretag)
+		{{template "Append" .}}
+	}
+	return b, nil
+}
+
+// consume{{.Name}}Slice wire decodes a []{{.GoType}} pointer as a repeated {{.Name}}.
+func consume{{.Name}}Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	sp := p.{{.GoType.PointerMethod}}Slice()
+	{{- if .WireType.Packable}}
+	if wtyp == protowire.BytesType {
+		s := *sp
+		b, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return out, protowire.ParseError(n)
+		}
+		for len(b) > 0 {
+			{{template "Consume" .}}
+			if n < 0 {
+				return out, protowire.ParseError(n)
+			}
+			s = append(s, {{.ToGoType}})
+			b = b[n:]
+		}
+		*sp = s
+		out.n = n
+		return out, nil
+	}
+	{{- end}}
+	if wtyp != {{.WireType.Expr}} {
+		return out, errUnknown
+	}
+	{{template "Consume" .}}
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	*sp = append(*sp, {{.ToGoType}})
+	out.n = n
+	return out, nil
+}
+
+var coder{{.Name}}Slice = pointerCoderFuncs{
+	size:      size{{.Name}}Slice,
+	marshal:   append{{.Name}}Slice,
+	unmarshal: consume{{.Name}}Slice,
+	merge:     merge{{.GoType.PointerMethod}}Slice,
+}
+
+{{if or (eq .Name "Bytes") (eq .Name "String")}}
+// append{{.Name}}SliceValidateUTF8 encodes a []{{.GoType}} pointer as a repeated {{.Name}}.
+func append{{.Name}}SliceValidateUTF8(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	s := *p.{{.GoType.PointerMethod}}Slice()
+	for _, v := range s {
+		b = protowire.AppendVarint(b, f.wiretag)
+		{{template "Append" .}}
+		if !utf8.Valid{{if eq .Name "String"}}String{{end}}(v) {
+			return b, errInvalidUTF8{}
+		}
+	}
+	return b, nil
+}
+
+// consume{{.Name}}SliceValidateUTF8 wire decodes a []{{.GoType}} pointer as a repeated {{.Name}}.
+func consume{{.Name}}SliceValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	sp := p.{{.GoType.PointerMethod}}Slice()
+	if wtyp != {{.WireType.Expr}} {
+		return out, errUnknown
+	}
+	{{template "Consume" .}}
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	if !utf8.Valid{{if eq .Name "String"}}String{{end}}(v) {
+		return out, errInvalidUTF8{}
+	}
+	*sp = append(*sp, {{.ToGoType}})
+	out.n = n
+	return out, nil
+}
+
+var coder{{.Name}}SliceValidateUTF8 = pointerCoderFuncs{
+	size:      size{{.Name}}Slice,
+	marshal:   append{{.Name}}SliceValidateUTF8,
+	unmarshal: consume{{.Name}}SliceValidateUTF8,
+	merge:     merge{{.GoType.PointerMethod}}Slice,
+}
+{{end}}
+
+{{if or (eq .WireType "Varint") (eq .WireType "Fixed32") (eq .WireType "Fixed64")}}
+// size{{.Name}}PackedSlice returns the size of wire encoding a []{{.GoType}} pointer as a packed repeated {{.Name}}.
+func size{{.Name}}PackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	s := *p.{{.GoType.PointerMethod}}Slice()
+	if len(s) == 0 {
+		return 0
+	}
+	{{if .WireType.ConstSize -}}
+	n := len(s) * {{template "Size" .}}
+	{{- else -}}
+	n := 0
+	for _, v := range s {
+		n += {{template "Size" .}}
+	}
+	{{- end}}
+	return f.tagsize + protowire.SizeBytes(n)
+}
+
+// append{{.Name}}PackedSlice encodes a []{{.GoType}} pointer as a packed repeated {{.Name}}.
+func append{{.Name}}PackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	s := *p.{{.GoType.PointerMethod}}Slice()
+	if len(s) == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, f.wiretag)
+	{{if .WireType.ConstSize -}}
+	n := len(s) * {{template "Size" .}}
+	{{- else -}}
+	n := 0
+	for _, v := range s {
+		n += {{template "Size" .}}
+	}
+	{{- end}}
+	b = protowire.AppendVarint(b, uint64(n))
+	for _, v := range s {
+		{{template "Append" .}}
+	}
+	return b, nil
+}
+
+var coder{{.Name}}PackedSlice = pointerCoderFuncs{
+	size:      size{{.Name}}PackedSlice,
+	marshal:   append{{.Name}}PackedSlice,
+	unmarshal: consume{{.Name}}Slice,
+	merge:     merge{{.GoType.PointerMethod}}Slice,
+}
+{{end}}
+
+{{end -}}
+
+{{- if not .NoValueCodec}}
+// size{{.Name}}Value returns the size of wire encoding a {{.GoType}} value as a {{.Name}}.
+func size{{.Name}}Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
+	return tagsize + {{template "SizeValue" .}}
+}
+
+// append{{.Name}}Value encodes a {{.GoType}} value as a {{.Name}}.
+func append{{.Name}}Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	b = protowire.AppendVarint(b, wiretag)
+	{{template "AppendValue" .}}
+	return b, nil
+}
+
+// consume{{.Name}}Value decodes a {{.GoType}} value as a {{.Name}}.
+func consume{{.Name}}Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != {{.WireType.Expr}} {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	{{template "Consume" .}}
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	out.n = n
+	return {{.ToValue}}, out, nil
+}
+
+var coder{{.Name}}Value = valueCoderFuncs{
+	size:      size{{.Name}}Value,
+	marshal:   append{{.Name}}Value,
+	unmarshal: consume{{.Name}}Value,
+{{- if (eq .Name "Bytes")}}
+	merge:     mergeBytesValue,
+{{- else}}
+	merge:     mergeScalarValue,
+{{- end}}
+}
+
+{{if (eq .Name "String")}}
+// append{{.Name}}ValueValidateUTF8 encodes a {{.GoType}} value as a {{.Name}}.
+func append{{.Name}}ValueValidateUTF8(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	b = protowire.AppendVarint(b, wiretag)
+	{{template "AppendValue" .}}
+	if !utf8.ValidString({{.FromValue}}) {
+		return b, errInvalidUTF8{}
+	}
+	return b, nil
+}
+
+// consume{{.Name}}ValueValidateUTF8 decodes a {{.GoType}} value as a {{.Name}}.
+func consume{{.Name}}ValueValidateUTF8(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != {{.WireType.Expr}} {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	{{template "Consume" .}}
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	if !utf8.ValidString(v) {
+		return protoreflect.Value{}, out, errInvalidUTF8{}
+	}
+	out.n = n
+	return {{.ToValue}}, out, nil
+}
+
+var coder{{.Name}}ValueValidateUTF8 = valueCoderFuncs{
+	size:      size{{.Name}}Value,
+	marshal:   append{{.Name}}ValueValidateUTF8,
+	unmarshal: consume{{.Name}}ValueValidateUTF8,
+	merge:     mergeScalarValue,
+}
+{{end}}
+
+// size{{.Name}}SliceValue returns the size of wire encoding a []{{.GoType}} value as a repeated {{.Name}}.
+func size{{.Name}}SliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
+	list := listv.List()
+	{{if .WireType.ConstSize -}}
+	size = list.Len() * (tagsize + {{template "SizeValue" .}})
+	{{- else -}}
+	for i, llen := 0, list.Len(); i < llen; i++ {
+		v := list.Get(i)
+		size += tagsize + {{template "SizeValue" .}}
+	}
+	{{- end}}
+	return size
+}
+
+// append{{.Name}}SliceValue encodes a []{{.GoType}} value as a repeated {{.Name}}.
+func append{{.Name}}SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	list := listv.List()
+	for i, llen := 0, list.Len(); i < llen; i++ {
+		v := list.Get(i)
+		b = protowire.AppendVarint(b, wiretag)
+		{{template "AppendValue" .}}
+	}
+	return b, nil
+}
+
+// consume{{.Name}}SliceValue wire decodes a []{{.GoType}} value as a repeated {{.Name}}.
+func consume{{.Name}}SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	list := listv.List()
+	{{- if .WireType.Packable}}
+	if wtyp == protowire.BytesType {
+		b, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return protoreflect.Value{}, out, protowire.ParseError(n)
+		}
+		for len(b) > 0 {
+			{{template "Consume" .}}
+			if n < 0 {
+				return protoreflect.Value{}, out, protowire.ParseError(n)
+			}
+			list.Append({{.ToValue}})
+			b = b[n:]
+		}
+		out.n = n
+		return listv, out, nil
+	}
+	{{- end}}
+	if wtyp != {{.WireType.Expr}} {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	{{template "Consume" .}}
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	list.Append({{.ToValue}})
+	out.n = n
+	return listv, out, nil
+}
+
+var coder{{.Name}}SliceValue = valueCoderFuncs{
+	size:      size{{.Name}}SliceValue,
+	marshal:   append{{.Name}}SliceValue,
+	unmarshal: consume{{.Name}}SliceValue,
+{{- if (eq .Name "Bytes")}}
+	merge:     mergeBytesListValue,
+{{- else}}
+	merge:     mergeListValue,
+{{- end}}
+}
+
+{{if or (eq .WireType "Varint") (eq .WireType "Fixed32") (eq .WireType "Fixed64")}}
+// size{{.Name}}PackedSliceValue returns the size of wire encoding a []{{.GoType}} value as a packed repeated {{.Name}}.
+func size{{.Name}}PackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
+	list := listv.List()
+	llen := list.Len()
+	if llen == 0 {
+		return 0
+	}
+	{{if .WireType.ConstSize -}}
+	n := llen * {{template "SizeValue" .}}
+	{{- else -}}
+	n := 0
+	for i, llen := 0, llen; i < llen; i++ {
+		v := list.Get(i)
+		n += {{template "SizeValue" .}}
+	}
+	{{- end}}
+	return tagsize + protowire.SizeBytes(n)
+}
+
+// append{{.Name}}PackedSliceValue encodes a []{{.GoType}} value as a packed repeated {{.Name}}.
+func append{{.Name}}PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	list := listv.List()
+	llen := list.Len()
+	if llen == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, wiretag)
+	{{if .WireType.ConstSize -}}
+	n := llen * {{template "SizeValue" .}}
+	{{- else -}}
+	n := 0
+	for i := 0; i < llen; i++ {
+		v := list.Get(i)
+		n += {{template "SizeValue" .}}
+	}
+	{{- end}}
+	b = protowire.AppendVarint(b, uint64(n))
+	for i := 0; i < llen; i++ {
+		v := list.Get(i)
+		{{template "AppendValue" .}}
+	}
+	return b, nil
+}
+
+var coder{{.Name}}PackedSliceValue = valueCoderFuncs{
+	size:      size{{.Name}}PackedSliceValue,
+	marshal:   append{{.Name}}PackedSliceValue,
+	unmarshal: consume{{.Name}}SliceValue,
+	merge:     mergeListValue,
+}
+{{end}}
+
+{{- end}}{{/* if not .NoValueCodec */}}
+
+{{end -}}
+
+// We append to an empty array rather than a nil []byte to get non-nil zero-length byte slices.
+var emptyBuf [0]byte
+
+var wireTypes = map[protoreflect.Kind]protowire.Type{
+{{range . -}}
+	protoreflect.{{.Name}}Kind: {{.WireType.Expr}},
+{{end}}
+}
+`))
+
+func generateImplMessage() string {
+	return mustExecute(implMessageTemplate, []string{"messageState", "messageReflectWrapper"})
+}
+
+var implMessageTemplate = template.Must(template.New("").Parse(`
+{{range . -}}
+func (m *{{.}}) Descriptor() protoreflect.MessageDescriptor {
+	return m.messageInfo().Desc
+}
+func (m *{{.}}) Type() protoreflect.MessageType {
+	return m.messageInfo()
+}
+func (m *{{.}}) New() protoreflect.Message {
+	return m.messageInfo().New()
+}
+func (m *{{.}}) Interface() protoreflect.ProtoMessage {
+	{{if eq . "messageState" -}}
+	return m.protoUnwrap().(protoreflect.ProtoMessage)
+	{{- else -}}
+	if m, ok := m.protoUnwrap().(protoreflect.ProtoMessage); ok {
+		return m
+	}
+	return (*messageIfaceWrapper)(m)
+	{{- end -}}
+}
+func (m *{{.}}) protoUnwrap() interface{} {
+	return m.pointer().AsIfaceOf(m.messageInfo().GoReflectType.Elem())
+}
+func (m *{{.}}) ProtoMethods() *protoiface.Methods {
+	m.messageInfo().init()
+	return &m.messageInfo().methods
+}
+
+// ProtoMessageInfo is a pseudo-internal API for allowing the v1 code
+// to be able to retrieve a v2 MessageInfo struct.
+//
+// WARNING: This method is exempt from the compatibility promise and
+// may be removed in the future without warning.
+func (m *{{.}}) ProtoMessageInfo() *MessageInfo {
+	return m.messageInfo()
+}
+
+func (m *{{.}}) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	m.messageInfo().init()
+	for _, ri := range m.messageInfo().rangeInfos {
+		switch ri := ri.(type) {
+		case *fieldInfo:
+			if ri.has(m.pointer()) {
+				if !f(ri.fieldDesc, ri.get(m.pointer())) {
+					return
+				}
+			}
+		case *oneofInfo:
+			if n := ri.which(m.pointer()); n > 0 {
+				fi := m.messageInfo().fields[n]
+				if !f(fi.fieldDesc, fi.get(m.pointer())) {
+					return
+				}
+			}
+		}
+	}
+	m.messageInfo().extensionMap(m.pointer()).Range(f)
+}
+func (m *{{.}}) Has(fd protoreflect.FieldDescriptor) bool {
+	m.messageInfo().init()
+	if fi, xt := m.messageInfo().checkField(fd); fi != nil {
+		return fi.has(m.pointer())
+	} else {
+		return m.messageInfo().extensionMap(m.pointer()).Has(xt)
+	}
+}
+func (m *{{.}}) Clear(fd protoreflect.FieldDescriptor) {
+	m.messageInfo().init()
+	if fi, xt := m.messageInfo().checkField(fd); fi != nil {
+		fi.clear(m.pointer())
+	} else {
+		m.messageInfo().extensionMap(m.pointer()).Clear(xt)
+	}
+}
+func (m *{{.}}) Get(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	m.messageInfo().init()
+	if fi, xt := m.messageInfo().checkField(fd); fi != nil {
+		return fi.get(m.pointer())
+	} else {
+		return m.messageInfo().extensionMap(m.pointer()).Get(xt)
+	}
+}
+func (m *{{.}}) Set(fd protoreflect.FieldDescriptor, v protoreflect.Value) {
+	m.messageInfo().init()
+	if fi, xt := m.messageInfo().checkField(fd); fi != nil {
+		fi.set(m.pointer(), v)
+	} else {
+		m.messageInfo().extensionMap(m.pointer()).Set(xt, v)
+	}
+}
+func (m *{{.}}) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	m.messageInfo().init()
+	if fi, xt := m.messageInfo().checkField(fd); fi != nil {
+		return fi.mutable(m.pointer())
+	} else {
+		return m.messageInfo().extensionMap(m.pointer()).Mutable(xt)
+	}
+}
+func (m *{{.}}) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	m.messageInfo().init()
+	if fi, xt := m.messageInfo().checkField(fd); fi != nil {
+		return fi.newField()
+	} else {
+		return xt.New()
+	}
+}
+func (m *{{.}}) WhichOneof(od protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	m.messageInfo().init()
+	if oi := m.messageInfo().oneofs[od.Name()]; oi != nil && oi.oneofDesc == od {
+		return od.Fields().ByNumber(oi.which(m.pointer()))
+	}
+	panic("invalid oneof descriptor " + string(od.FullName()) + " for message " + string(m.Descriptor().FullName()))
+}
+func (m *{{.}}) GetUnknown() protoreflect.RawFields {
+	m.messageInfo().init()
+	return m.messageInfo().getUnknown(m.pointer())
+}
+func (m *{{.}}) SetUnknown(b protoreflect.RawFields) {
+	m.messageInfo().init()
+	m.messageInfo().setUnknown(m.pointer(), b)
+}
+func (m *{{.}}) IsValid() bool {
+	return !m.pointer().IsNil()
+}
+
+{{end}}
+`))
+
+func generateImplMerge() string {
+	return mustExecute(implMergeTemplate, GoTypes)
+}
+
+var implMergeTemplate = template.Must(template.New("").Parse(`
+{{range .}}
+{{if ne . "[]byte"}}
+func merge{{.PointerMethod}}(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	*dst.{{.PointerMethod}}() = *src.{{.PointerMethod}}()
+}
+
+func merge{{.PointerMethod}}NoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	v := *src.{{.PointerMethod}}()
+	if v != {{.Zero}} {
+		*dst.{{.PointerMethod}}() = v
+	}
+}
+
+func merge{{.PointerMethod}}Ptr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	p := *src.{{.PointerMethod}}Ptr()
+	if p != nil {
+		v := *p
+		*dst.{{.PointerMethod}}Ptr() = &v
+	}
+}
+
+func merge{{.PointerMethod}}Slice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	ds := dst.{{.PointerMethod}}Slice()
+	ss := src.{{.PointerMethod}}Slice()
+	*ds = append(*ds, *ss...)
+}
+
+{{end}}
+{{end}}
+`))
diff --git a/vendor/google.golang.org/protobuf/internal/cmd/generate-types/main.go b/vendor/google.golang.org/protobuf/internal/cmd/generate-types/main.go
new file mode 100644
index 000000000..0d3e73191
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/cmd/generate-types/main.go
@@ -0,0 +1,249 @@
+// 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.
+
+//go:generate go run . -execute
+
+package main
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"go/format"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"text/template"
+)
+
+var (
+	run      bool
+	repoRoot string
+)
+
+func main() {
+	flag.BoolVar(&run, "execute", false, "Write generated files to destination.")
+	flag.Parse()
+
+	// Determine repository root path.
+	out, err := exec.Command("git", "rev-parse", "--show-toplevel").CombinedOutput()
+	check(err)
+	repoRoot = strings.TrimSpace(string(out))
+
+	chdirRoot()
+	writeSource("internal/filedesc/desc_list_gen.go", generateDescListTypes())
+	writeSource("internal/impl/codec_gen.go", generateImplCodec())
+	writeSource("internal/impl/message_reflect_gen.go", generateImplMessage())
+	writeSource("internal/impl/merge_gen.go", generateImplMerge())
+	writeSource("proto/decode_gen.go", generateProtoDecode())
+	writeSource("proto/encode_gen.go", generateProtoEncode())
+	writeSource("proto/size_gen.go", generateProtoSize())
+}
+
+// chdirRoot changes the working directory to the repository root.
+func chdirRoot() {
+	out, err := exec.Command("git", "rev-parse", "--show-toplevel").CombinedOutput()
+	check(err)
+	check(os.Chdir(strings.TrimSpace(string(out))))
+}
+
+// Expr is a single line Go expression.
+type Expr string
+
+type DescriptorType string
+
+const (
+	MessageDesc   DescriptorType = "Message"
+	FieldDesc     DescriptorType = "Field"
+	OneofDesc     DescriptorType = "Oneof"
+	ExtensionDesc DescriptorType = "Extension"
+	EnumDesc      DescriptorType = "Enum"
+	EnumValueDesc DescriptorType = "EnumValue"
+	ServiceDesc   DescriptorType = "Service"
+	MethodDesc    DescriptorType = "Method"
+)
+
+func (d DescriptorType) Expr() Expr {
+	return "protoreflect." + Expr(d) + "Descriptor"
+}
+func (d DescriptorType) NumberExpr() Expr {
+	switch d {
+	case FieldDesc:
+		return "protoreflect.FieldNumber"
+	case EnumValueDesc:
+		return "protoreflect.EnumNumber"
+	default:
+		return ""
+	}
+}
+
+func generateDescListTypes() string {
+	return mustExecute(descListTypesTemplate, []DescriptorType{
+		EnumDesc, EnumValueDesc, MessageDesc, FieldDesc, OneofDesc, ExtensionDesc, ServiceDesc, MethodDesc,
+	})
+}
+
+var descListTypesTemplate = template.Must(template.New("").Parse(`
+	{{- range .}}
+	{{$nameList := (printf "%ss" .)}} {{/* e.g., "Messages" */}}
+	{{$nameDesc := (printf "%s"  .)}} {{/* e.g., "Message" */}}
+
+	type {{$nameList}} struct {
+		List   []{{$nameDesc}}
+		once   sync.Once
+		byName map[protoreflect.Name]*{{$nameDesc}} // protected by once
+		{{- if (eq . "Field")}}
+		byJSON map[string]*{{$nameDesc}}            // protected by once
+		{{- end}}
+		{{- if .NumberExpr}}
+		byNum  map[{{.NumberExpr}}]*{{$nameDesc}}   // protected by once
+		{{- end}}
+	}
+
+	func (p *{{$nameList}}) Len() int {
+		return len(p.List)
+	}
+	func (p *{{$nameList}}) Get(i int) {{.Expr}} {
+		return &p.List[i]
+	}
+	func (p *{{$nameList}}) ByName(s protoreflect.Name) {{.Expr}} {
+		if d := p.lazyInit().byName[s]; d != nil {
+			return d
+		}
+		return nil
+	}
+	{{- if (eq . "Field")}}
+	func (p *{{$nameList}}) ByJSONName(s string) {{.Expr}} {
+		if d := p.lazyInit().byJSON[s]; d != nil {
+			return d
+		}
+		return nil
+	}
+	{{- end}}
+	{{- if .NumberExpr}}
+	func (p *{{$nameList}}) ByNumber(n {{.NumberExpr}}) {{.Expr}} {
+		if d := p.lazyInit().byNum[n]; d != nil {
+			return d
+		}
+		return nil
+	}
+	{{- end}}
+	func (p *{{$nameList}}) Format(s fmt.State, r rune) {
+		descfmt.FormatList(s, r, p)
+	}
+	func (p *{{$nameList}}) ProtoInternal(pragma.DoNotImplement) {}
+	func (p *{{$nameList}}) lazyInit() *{{$nameList}} {
+		p.once.Do(func() {
+			if len(p.List) > 0 {
+				p.byName = make(map[protoreflect.Name]*{{$nameDesc}}, len(p.List))
+				{{- if (eq . "Field")}}
+				p.byJSON = make(map[string]*{{$nameDesc}}, len(p.List))
+				{{- end}}
+				{{- if .NumberExpr}}
+				p.byNum = make(map[{{.NumberExpr}}]*{{$nameDesc}}, len(p.List))
+				{{- end}}
+				for i := range p.List {
+					d := &p.List[i]
+					if _, ok := p.byName[d.Name()]; !ok {
+						p.byName[d.Name()] = d
+					}
+					{{- if (eq . "Field")}}
+					if _, ok := p.byJSON[d.JSONName()]; !ok {
+						p.byJSON[d.JSONName()] = d
+					}
+					{{- end}}
+					{{- if .NumberExpr}}
+					if _, ok := p.byNum[d.Number()]; !ok {
+						p.byNum[d.Number()] = d
+					}
+					{{- end}}
+				}
+			}
+		})
+		return p
+	}
+	{{- end}}
+`))
+
+func mustExecute(t *template.Template, data interface{}) string {
+	var b bytes.Buffer
+	if err := t.Execute(&b, data); err != nil {
+		panic(err)
+	}
+	return b.String()
+}
+
+func writeSource(file, src string) {
+	// Crude but effective way to detect used imports.
+	var imports []string
+	for _, pkg := range []string{
+		"fmt",
+		"math",
+		"reflect",
+		"sync",
+		"unicode/utf8",
+		"",
+		"google.golang.org/protobuf/internal/descfmt",
+		"google.golang.org/protobuf/encoding/protowire",
+		"google.golang.org/protobuf/internal/errors",
+		"google.golang.org/protobuf/internal/strs",
+		"google.golang.org/protobuf/internal/pragma",
+		"google.golang.org/protobuf/reflect/protoreflect",
+		"google.golang.org/protobuf/runtime/protoiface",
+	} {
+		if pkg == "" {
+			imports = append(imports, "") // blank line between stdlib and proto packages
+		} else if regexp.MustCompile(`[^\pL_0-9]` + path.Base(pkg) + `\.`).MatchString(src) {
+			imports = append(imports, strconv.Quote(pkg))
+		}
+	}
+
+	s := strings.Join([]string{
+		"// 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.",
+		"",
+		"// Code generated by generate-types. DO NOT EDIT.",
+		"",
+		"package " + path.Base(path.Dir(path.Join("proto", file))),
+		"",
+		"import (" + strings.Join(imports, "\n") + ")",
+		"",
+		src,
+	}, "\n")
+	b, err := format.Source([]byte(s))
+	if err != nil {
+		// Just print the error and output the unformatted file for examination.
+		fmt.Fprintf(os.Stderr, "%v:%v\n", file, err)
+		b = []byte(s)
+	}
+
+	absFile := filepath.Join(repoRoot, file)
+	if run {
+		prev, _ := ioutil.ReadFile(absFile)
+		if !bytes.Equal(b, prev) {
+			fmt.Println("#", file)
+			check(ioutil.WriteFile(absFile, b, 0664))
+		}
+	} else {
+		check(ioutil.WriteFile(absFile+".tmp", b, 0664))
+		defer os.Remove(absFile + ".tmp")
+
+		cmd := exec.Command("diff", file, file+".tmp", "-N", "-u")
+		cmd.Dir = repoRoot
+		cmd.Stdout = os.Stdout
+		cmd.Run()
+	}
+}
+
+func check(err error) {
+	if err != nil {
+		panic(err)
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/cmd/generate-types/proto.go b/vendor/google.golang.org/protobuf/internal/cmd/generate-types/proto.go
new file mode 100644
index 000000000..8ea491b8e
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/cmd/generate-types/proto.go
@@ -0,0 +1,436 @@
+// 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 main
+
+import (
+	"strings"
+	"text/template"
+)
+
+type WireType string
+
+const (
+	WireVarint  WireType = "Varint"
+	WireFixed32 WireType = "Fixed32"
+	WireFixed64 WireType = "Fixed64"
+	WireBytes   WireType = "Bytes"
+	WireGroup   WireType = "Group"
+)
+
+func (w WireType) Expr() Expr {
+	if w == WireGroup {
+		return "protowire.StartGroupType"
+	}
+	return "protowire." + Expr(w) + "Type"
+}
+
+func (w WireType) Packable() bool {
+	return w == WireVarint || w == WireFixed32 || w == WireFixed64
+}
+
+func (w WireType) ConstSize() bool {
+	return w == WireFixed32 || w == WireFixed64
+}
+
+type GoType string
+
+var GoTypes = []GoType{
+	GoBool,
+	GoInt32,
+	GoUint32,
+	GoInt64,
+	GoUint64,
+	GoFloat32,
+	GoFloat64,
+	GoString,
+	GoBytes,
+}
+
+const (
+	GoBool    = "bool"
+	GoInt32   = "int32"
+	GoUint32  = "uint32"
+	GoInt64   = "int64"
+	GoUint64  = "uint64"
+	GoFloat32 = "float32"
+	GoFloat64 = "float64"
+	GoString  = "string"
+	GoBytes   = "[]byte"
+)
+
+func (g GoType) Zero() Expr {
+	switch g {
+	case GoBool:
+		return "false"
+	case GoString:
+		return `""`
+	case GoBytes:
+		return "nil"
+	}
+	return "0"
+}
+
+// Kind is the reflect.Kind of the type.
+func (g GoType) Kind() Expr {
+	if g == "" || g == GoBytes {
+		return ""
+	}
+	return "reflect." + Expr(strings.ToUpper(string(g[:1]))+string(g[1:]))
+}
+
+// PointerMethod is the "internal/impl".pointer method used to access a pointer to this type.
+func (g GoType) PointerMethod() Expr {
+	if g == GoBytes {
+		return "Bytes"
+	}
+	return Expr(strings.ToUpper(string(g[:1])) + string(g[1:]))
+}
+
+type ProtoKind struct {
+	Name     string
+	WireType WireType
+
+	// Conversions to/from protoreflect.Value.
+	ToValue   Expr
+	FromValue Expr
+
+	// Conversions to/from generated structures.
+	GoType         GoType
+	ToGoType       Expr
+	ToGoTypeNoZero Expr
+	FromGoType     Expr
+	NoPointer      bool
+	NoValueCodec   bool
+}
+
+func (k ProtoKind) Expr() Expr {
+	return "protoreflect." + Expr(k.Name) + "Kind"
+}
+
+var ProtoKinds = []ProtoKind{
+	{
+		Name:       "Bool",
+		WireType:   WireVarint,
+		ToValue:    "protoreflect.ValueOfBool(protowire.DecodeBool(v))",
+		FromValue:  "protowire.EncodeBool(v.Bool())",
+		GoType:     GoBool,
+		ToGoType:   "protowire.DecodeBool(v)",
+		FromGoType: "protowire.EncodeBool(v)",
+	},
+	{
+		Name:      "Enum",
+		WireType:  WireVarint,
+		ToValue:   "protoreflect.ValueOfEnum(protoreflect.EnumNumber(v))",
+		FromValue: "uint64(v.Enum())",
+	},
+	{
+		Name:       "Int32",
+		WireType:   WireVarint,
+		ToValue:    "protoreflect.ValueOfInt32(int32(v))",
+		FromValue:  "uint64(int32(v.Int()))",
+		GoType:     GoInt32,
+		ToGoType:   "int32(v)",
+		FromGoType: "uint64(v)",
+	},
+	{
+		Name:       "Sint32",
+		WireType:   WireVarint,
+		ToValue:    "protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32)))",
+		FromValue:  "protowire.EncodeZigZag(int64(int32(v.Int())))",
+		GoType:     GoInt32,
+		ToGoType:   "int32(protowire.DecodeZigZag(v & math.MaxUint32))",
+		FromGoType: "protowire.EncodeZigZag(int64(v))",
+	},
+	{
+		Name:       "Uint32",
+		WireType:   WireVarint,
+		ToValue:    "protoreflect.ValueOfUint32(uint32(v))",
+		FromValue:  "uint64(uint32(v.Uint()))",
+		GoType:     GoUint32,
+		ToGoType:   "uint32(v)",
+		FromGoType: "uint64(v)",
+	},
+	{
+		Name:       "Int64",
+		WireType:   WireVarint,
+		ToValue:    "protoreflect.ValueOfInt64(int64(v))",
+		FromValue:  "uint64(v.Int())",
+		GoType:     GoInt64,
+		ToGoType:   "int64(v)",
+		FromGoType: "uint64(v)",
+	},
+	{
+		Name:       "Sint64",
+		WireType:   WireVarint,
+		ToValue:    "protoreflect.ValueOfInt64(protowire.DecodeZigZag(v))",
+		FromValue:  "protowire.EncodeZigZag(v.Int())",
+		GoType:     GoInt64,
+		ToGoType:   "protowire.DecodeZigZag(v)",
+		FromGoType: "protowire.EncodeZigZag(v)",
+	},
+	{
+		Name:       "Uint64",
+		WireType:   WireVarint,
+		ToValue:    "protoreflect.ValueOfUint64(v)",
+		FromValue:  "v.Uint()",
+		GoType:     GoUint64,
+		ToGoType:   "v",
+		FromGoType: "v",
+	},
+	{
+		Name:       "Sfixed32",
+		WireType:   WireFixed32,
+		ToValue:    "protoreflect.ValueOfInt32(int32(v))",
+		FromValue:  "uint32(v.Int())",
+		GoType:     GoInt32,
+		ToGoType:   "int32(v)",
+		FromGoType: "uint32(v)",
+	},
+	{
+		Name:       "Fixed32",
+		WireType:   WireFixed32,
+		ToValue:    "protoreflect.ValueOfUint32(uint32(v))",
+		FromValue:  "uint32(v.Uint())",
+		GoType:     GoUint32,
+		ToGoType:   "v",
+		FromGoType: "v",
+	},
+	{
+		Name:       "Float",
+		WireType:   WireFixed32,
+		ToValue:    "protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v)))",
+		FromValue:  "math.Float32bits(float32(v.Float()))",
+		GoType:     GoFloat32,
+		ToGoType:   "math.Float32frombits(v)",
+		FromGoType: "math.Float32bits(v)",
+	},
+	{
+		Name:       "Sfixed64",
+		WireType:   WireFixed64,
+		ToValue:    "protoreflect.ValueOfInt64(int64(v))",
+		FromValue:  "uint64(v.Int())",
+		GoType:     GoInt64,
+		ToGoType:   "int64(v)",
+		FromGoType: "uint64(v)",
+	},
+	{
+		Name:       "Fixed64",
+		WireType:   WireFixed64,
+		ToValue:    "protoreflect.ValueOfUint64(v)",
+		FromValue:  "v.Uint()",
+		GoType:     GoUint64,
+		ToGoType:   "v",
+		FromGoType: "v",
+	},
+	{
+		Name:       "Double",
+		WireType:   WireFixed64,
+		ToValue:    "protoreflect.ValueOfFloat64(math.Float64frombits(v))",
+		FromValue:  "math.Float64bits(v.Float())",
+		GoType:     GoFloat64,
+		ToGoType:   "math.Float64frombits(v)",
+		FromGoType: "math.Float64bits(v)",
+	},
+	{
+		Name:       "String",
+		WireType:   WireBytes,
+		ToValue:    "protoreflect.ValueOfString(string(v))",
+		FromValue:  "v.String()",
+		GoType:     GoString,
+		ToGoType:   "v",
+		FromGoType: "v",
+	},
+	{
+		Name:           "Bytes",
+		WireType:       WireBytes,
+		ToValue:        "protoreflect.ValueOfBytes(append(emptyBuf[:], v...))",
+		FromValue:      "v.Bytes()",
+		GoType:         GoBytes,
+		ToGoType:       "append(emptyBuf[:], v...)",
+		ToGoTypeNoZero: "append(([]byte)(nil), v...)",
+		FromGoType:     "v",
+		NoPointer:      true,
+	},
+	{
+		Name:         "Message",
+		WireType:     WireBytes,
+		ToValue:      "protoreflect.ValueOfBytes(v)",
+		FromValue:    "v",
+		NoValueCodec: true,
+	},
+	{
+		Name:         "Group",
+		WireType:     WireGroup,
+		ToValue:      "protoreflect.ValueOfBytes(v)",
+		FromValue:    "v",
+		NoValueCodec: true,
+	},
+}
+
+func generateProtoDecode() string {
+	return mustExecute(protoDecodeTemplate, ProtoKinds)
+}
+
+var protoDecodeTemplate = template.Must(template.New("").Parse(`
+// unmarshalScalar decodes a value of the given kind.
+//
+// Message values are decoded into a []byte which aliases the input data.
+func (o UnmarshalOptions) unmarshalScalar(b []byte, wtyp protowire.Type, fd protoreflect.FieldDescriptor) (val protoreflect.Value, n int, err error) {
+	switch fd.Kind() {
+	{{- range .}}
+	case {{.Expr}}:
+		if wtyp != {{.WireType.Expr}} {
+			return val, 0, errUnknown
+		}
+		{{if (eq .WireType "Group") -}}
+		v, n := protowire.ConsumeGroup(fd.Number(), b)
+		{{- else -}}
+		v, n := protowire.Consume{{.WireType}}(b)
+		{{- end}}
+		if n < 0 {
+			return val, 0, protowire.ParseError(n)
+		}
+		{{if (eq .Name "String") -}}
+		if strs.EnforceUTF8(fd) && !utf8.Valid(v) {
+			return protoreflect.Value{}, 0, errors.InvalidUTF8(string(fd.FullName()))
+		}
+		{{end -}}
+		return {{.ToValue}}, n, nil
+	{{- end}}
+	default:
+		return val, 0, errUnknown
+	}
+}
+
+func (o UnmarshalOptions) unmarshalList(b []byte, wtyp protowire.Type, list protoreflect.List, fd protoreflect.FieldDescriptor) (n int, err error) {
+	switch fd.Kind() {
+	{{- range .}}
+	case {{.Expr}}:
+		{{- if .WireType.Packable}}
+		if wtyp == protowire.BytesType {
+			buf, n := protowire.ConsumeBytes(b)
+			if n < 0 {
+				return 0, protowire.ParseError(n)
+			}
+			for len(buf) > 0 {
+				v, n := protowire.Consume{{.WireType}}(buf)
+				if n < 0 {
+					return 0, protowire.ParseError(n)
+				}
+				buf = buf[n:]
+				list.Append({{.ToValue}})
+			}
+			return n, nil
+		}
+		{{- end}}
+		if wtyp != {{.WireType.Expr}} {
+			return 0, errUnknown
+		}
+		{{if (eq .WireType "Group") -}}
+		v, n := protowire.ConsumeGroup(fd.Number(), b)
+		{{- else -}}
+		v, n := protowire.Consume{{.WireType}}(b)
+		{{- end}}
+		if n < 0 {
+			return 0, protowire.ParseError(n)
+		}
+		{{if (eq .Name "String") -}}
+		if strs.EnforceUTF8(fd) && !utf8.Valid(v) {
+			return 0, errors.InvalidUTF8(string(fd.FullName()))
+		}
+		{{end -}}
+		{{if or (eq .Name "Message") (eq .Name "Group") -}}
+		m := list.NewElement()
+		if err := o.unmarshalMessage(v, m.Message()); err != nil {
+			return 0, err
+		}
+		list.Append(m)
+		{{- else -}}
+		list.Append({{.ToValue}})
+		{{- end}}
+		return n, nil
+	{{- end}}
+	default:
+		return 0, errUnknown
+	}
+}
+
+// We append to an empty array rather than a nil []byte to get non-nil zero-length byte slices.
+var emptyBuf [0]byte
+`))
+
+func generateProtoEncode() string {
+	return mustExecute(protoEncodeTemplate, ProtoKinds)
+}
+
+var protoEncodeTemplate = template.Must(template.New("").Parse(`
+var wireTypes = map[protoreflect.Kind]protowire.Type{
+{{- range .}}
+	{{.Expr}}: {{.WireType.Expr}},
+{{- end}}
+}
+
+func (o MarshalOptions) marshalSingular(b []byte, fd protoreflect.FieldDescriptor, v protoreflect.Value) ([]byte, error) {
+	switch fd.Kind() {
+	{{- range .}}
+	case {{.Expr}}:
+		{{- if (eq .Name "String") }}
+		if strs.EnforceUTF8(fd) && !utf8.ValidString(v.String()) {
+			return b, errors.InvalidUTF8(string(fd.FullName()))
+		}
+		b = protowire.AppendString(b, {{.FromValue}})
+		{{- else if (eq .Name "Message") -}}
+		var pos int
+		var err error
+		b, pos = appendSpeculativeLength(b)
+		b, err = o.marshalMessage(b, v.Message())
+		if err != nil {
+			return b, err
+		}
+		b = finishSpeculativeLength(b, pos)
+		{{- else if (eq .Name "Group") -}}
+		var err error
+		b, err = o.marshalMessage(b, v.Message())
+		if err != nil {
+			return b, err
+		}
+		b = protowire.AppendVarint(b, protowire.EncodeTag(fd.Number(), protowire.EndGroupType))
+		{{- else -}}
+		b = protowire.Append{{.WireType}}(b, {{.FromValue}})
+		{{- end}}
+	{{- end}}
+	default:
+		return b, errors.New("invalid kind %v", fd.Kind())
+	}
+	return b, nil
+}
+`))
+
+func generateProtoSize() string {
+	return mustExecute(protoSizeTemplate, ProtoKinds)
+}
+
+var protoSizeTemplate = template.Must(template.New("").Parse(`
+func sizeSingular(num protowire.Number, kind protoreflect.Kind, v protoreflect.Value) int {
+	switch kind {
+	{{- range .}}
+	case {{.Expr}}:
+		{{if (eq .Name "Message") -}}
+		return protowire.SizeBytes(sizeMessage(v.Message()))
+		{{- else if or (eq .WireType "Fixed32") (eq .WireType "Fixed64") -}}
+		return protowire.Size{{.WireType}}()
+		{{- else if (eq .WireType "Bytes") -}}
+		return protowire.Size{{.WireType}}(len({{.FromValue}}))
+		{{- else if (eq .WireType "Group") -}}
+		return protowire.Size{{.WireType}}(num, sizeMessage(v.Message()))
+		{{- else -}}
+		return protowire.Size{{.WireType}}({{.FromValue}})
+		{{- end}}
+	{{- end}}
+	default:
+		return 0
+	}
+}
+`))
diff --git a/vendor/google.golang.org/protobuf/internal/cmd/pbdump/pbdump.go b/vendor/google.golang.org/protobuf/internal/cmd/pbdump/pbdump.go
new file mode 100644
index 000000000..87d60307c
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/cmd/pbdump/pbdump.go
@@ -0,0 +1,262 @@
+// 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.
+
+// pbdump is a tool for decoding the wire format for protocol buffer messages.
+package main
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"os"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+
+	"google.golang.org/protobuf/encoding/protowire"
+	"google.golang.org/protobuf/internal/errors"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protodesc"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/testing/protopack"
+
+	"google.golang.org/protobuf/types/descriptorpb"
+)
+
+func main() {
+	log.SetFlags(0)
+	log.SetOutput(os.Stderr)
+
+	var fs fields
+	var flagUsages []string
+	flagVar := func(value flag.Value, name, usage string) {
+		flagUsages = append(flagUsages, fmt.Sprintf("  -%-16v  %v", name+" "+value.String(), usage))
+		flag.Var(value, name, usage)
+	}
+	flagBool := func(name, usage string) *bool {
+		flagUsages = append(flagUsages, fmt.Sprintf("  -%-16v  %v", name, usage))
+		return flag.Bool(name, false, usage)
+	}
+	flagVar(fieldsFlag{&fs, protoreflect.BoolKind}, "bools", "List of bool fields")
+	flagVar(fieldsFlag{&fs, protoreflect.Int64Kind}, "ints", "List of int32 or int64 fields")
+	flagVar(fieldsFlag{&fs, protoreflect.Sint64Kind}, "sints", "List of sint32 or sint64 fields")
+	flagVar(fieldsFlag{&fs, protoreflect.Uint64Kind}, "uints", "List of enum, uint32, or uint64 fields")
+	flagVar(fieldsFlag{&fs, protoreflect.Fixed32Kind}, "uint32s", "List of fixed32 fields")
+	flagVar(fieldsFlag{&fs, protoreflect.Sfixed32Kind}, "int32s", "List of sfixed32 fields")
+	flagVar(fieldsFlag{&fs, protoreflect.FloatKind}, "float32s", "List of float fields")
+	flagVar(fieldsFlag{&fs, protoreflect.Fixed64Kind}, "uint64s", "List of fixed64 fields")
+	flagVar(fieldsFlag{&fs, protoreflect.Sfixed64Kind}, "int64s", "List of sfixed64 fields")
+	flagVar(fieldsFlag{&fs, protoreflect.DoubleKind}, "float64s", "List of double fields")
+	flagVar(fieldsFlag{&fs, protoreflect.StringKind}, "strings", "List of string fields")
+	flagVar(fieldsFlag{&fs, protoreflect.BytesKind}, "bytes", "List of bytes fields")
+	flagVar(fieldsFlag{&fs, protoreflect.MessageKind}, "messages", "List of message fields")
+	flagVar(fieldsFlag{&fs, protoreflect.GroupKind}, "groups", "List of group fields")
+	printDesc := flagBool("print_descriptor", "Print the message descriptor")
+	printSource := flagBool("print_source", "Print the output in valid Go syntax")
+	flag.Usage = func() {
+		fmt.Printf("Usage: %s [OPTIONS]... [INPUTS]...\n\n%s\n", filepath.Base(os.Args[0]), strings.Join(append([]string{
+			"Print structured representations of encoded protocol buffer messages.",
+			"Since the protobuf wire format is not fully self-describing, type information",
+			"about the proto message can be provided using flags (e.g., -messages).",
+			"Each field list is a comma-separated list of field identifiers,",
+			"where each field identifier is a dot-separated list of field numbers,",
+			"identifying each field relative to the root message.",
+			"",
+			"For example, \"-messages 1,3,3.1 -float32s 1.2 -bools 3.1.2\" represents:",
+			"",
+			"    message M {",
+			"        optional M1 f1 = 1;           // -messages 1",
+			"        message M1 {",
+			"            repeated float f2 = 2;    // -float32s 1.2",
+			"        }",
+			"        optional M3 f3 = 3;           // -messages 3",
+			"        message M3 {",
+			"            optional M1 f1 = 1;       // -messages 3.1",
+			"            message M1 {",
+			"                repeated bool f2 = 2; // -bools 3.1.2",
+			"            }",
+			"        }",
+			"    }",
+			"",
+			"Arbitrarily complex message schemas can be represented using these flags.",
+			"Scalar field types are marked as repeated so that pbdump can decode",
+			"the packed representations of such field types.",
+			"",
+			"If no inputs are specified, the wire data is read in from stdin, otherwise",
+			"the contents of each specified input file is concatenated and",
+			"treated as one large message.",
+			"",
+			"Options:",
+		}, flagUsages...), "\n"))
+	}
+	flag.Parse()
+
+	// Create message types.
+	var desc protoreflect.MessageDescriptor
+	if len(fs) > 0 {
+		var err error
+		desc, err = fs.Descriptor()
+		if err != nil {
+			log.Fatalf("Descriptor error: %v", err)
+		}
+		if *printDesc {
+			fmt.Printf("%#v\n", desc)
+		}
+	}
+
+	// Read message input.
+	var buf []byte
+	if flag.NArg() == 0 {
+		b, err := ioutil.ReadAll(os.Stdin)
+		if err != nil {
+			log.Fatalf("ReadAll error: %v", err)
+		}
+		buf = b
+	}
+	for _, f := range flag.Args() {
+		b, err := ioutil.ReadFile(f)
+		if err != nil {
+			log.Fatalf("ReadFile error: %v", err)
+		}
+		buf = append(buf, b...)
+	}
+
+	// Parse and print message structure.
+	defer log.Printf("fatal input: %q", buf) // debug printout if panic occurs
+	var m protopack.Message
+	m.UnmarshalDescriptor(buf, desc)
+	if *printSource {
+		fmt.Printf("%#v\n", m)
+	} else {
+		fmt.Printf("%+v\n", m)
+	}
+	if !bytes.Equal(buf, m.Marshal()) || len(buf) != m.Size() {
+		log.Fatalf("roundtrip mismatch:\n\tgot:  %d %x\n\twant: %d %x", m.Size(), m, len(buf), buf)
+	}
+	os.Exit(0) // exit cleanly, avoid debug printout
+}
+
+// fields is a tree of fields, keyed by a field number.
+// Fields representing messages or groups have sub-fields.
+type fields map[protowire.Number]*field
+type field struct {
+	kind protoreflect.Kind
+	sub  fields // only for MessageKind or GroupKind
+}
+
+// Set parses s as a comma-separated list (see the help above for the format)
+// and treats each field identifier as the specified kind.
+func (fs *fields) Set(s string, k protoreflect.Kind) error {
+	if *fs == nil {
+		*fs = make(fields)
+	}
+	for _, s := range strings.Split(s, ",") {
+		if err := fs.set("", strings.TrimSpace(s), k); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+func (fs fields) set(prefix, s string, k protoreflect.Kind) error {
+	if s == "" {
+		return nil
+	}
+
+	// Parse next field number.
+	i := strings.IndexByte(s, '.')
+	if i < 0 {
+		i = len(s)
+	}
+	prefix = strings.TrimPrefix(prefix+"."+s[:i], ".")
+	n, _ := strconv.ParseInt(s[:i], 10, 32)
+	num := protowire.Number(n)
+	if num < protowire.MinValidNumber || protowire.MaxValidNumber < num {
+		return errors.New("invalid field: %v", prefix)
+	}
+	s = strings.TrimPrefix(s[i:], ".")
+
+	// Handle the current field.
+	if fs[num] == nil {
+		fs[num] = &field{0, make(fields)}
+	}
+	if len(s) == 0 {
+		if fs[num].kind.IsValid() {
+			return errors.New("field %v already set as %v type", prefix, fs[num].kind)
+		}
+		fs[num].kind = k
+	}
+	if err := fs[num].sub.set(prefix, s, k); err != nil {
+		return err
+	}
+
+	// Verify that only messages or groups can have sub-fields.
+	k2 := fs[num].kind
+	if k2 > 0 && k2 != protoreflect.MessageKind && k2 != protoreflect.GroupKind && len(fs[num].sub) > 0 {
+		return errors.New("field %v of %v type cannot have sub-fields", prefix, k2)
+	}
+	return nil
+}
+
+// Descriptor returns the field tree as a message descriptor.
+func (fs fields) Descriptor() (protoreflect.MessageDescriptor, error) {
+	fd, err := protodesc.NewFile(&descriptorpb.FileDescriptorProto{
+		Name:        proto.String("dump.proto"),
+		Syntax:      proto.String("proto2"),
+		MessageType: []*descriptorpb.DescriptorProto{fs.messageDescriptor("X")},
+	}, nil)
+	if err != nil {
+		return nil, err
+	}
+	return fd.Messages().Get(0), nil
+}
+func (fs fields) messageDescriptor(name protoreflect.FullName) *descriptorpb.DescriptorProto {
+	m := &descriptorpb.DescriptorProto{Name: proto.String(string(name.Name()))}
+	for _, n := range fs.sortedNums() {
+		k := fs[n].kind
+		if !k.IsValid() {
+			k = protoreflect.MessageKind
+		}
+		f := &descriptorpb.FieldDescriptorProto{
+			Name:   proto.String(fmt.Sprintf("x%d", n)),
+			Number: proto.Int32(int32(n)),
+			Label:  descriptorpb.FieldDescriptorProto_LABEL_OPTIONAL.Enum(),
+			Type:   descriptorpb.FieldDescriptorProto_Type(k).Enum(),
+		}
+		switch k {
+		case protoreflect.BoolKind, protoreflect.EnumKind,
+			protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Uint32Kind,
+			protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Uint64Kind,
+			protoreflect.Sfixed32Kind, protoreflect.Fixed32Kind, protoreflect.FloatKind,
+			protoreflect.Sfixed64Kind, protoreflect.Fixed64Kind, protoreflect.DoubleKind:
+			f.Label = descriptorpb.FieldDescriptorProto_LABEL_REPEATED.Enum()
+			f.Options = &descriptorpb.FieldOptions{Packed: proto.Bool(true)}
+		case protoreflect.MessageKind, protoreflect.GroupKind:
+			s := name.Append(protoreflect.Name(fmt.Sprintf("X%d", n)))
+			f.TypeName = proto.String(string("." + s))
+			m.NestedType = append(m.NestedType, fs[n].sub.messageDescriptor(s))
+		}
+		m.Field = append(m.Field, f)
+	}
+	return m
+}
+
+func (fs fields) sortedNums() (ns []protowire.Number) {
+	for n := range fs {
+		ns = append(ns, n)
+	}
+	sort.Slice(ns, func(i, j int) bool { return ns[i] < ns[j] })
+	return ns
+}
+
+// fieldsFlag is an implementation of flag.Value that is keyed a specific kind.
+type fieldsFlag struct {
+	f *fields
+	k protoreflect.Kind
+}
+
+func (fs fieldsFlag) String() string     { return "FIELDS" }
+func (fs fieldsFlag) Set(s string) error { return fs.f.Set(s, fs.k) }
diff --git a/vendor/google.golang.org/protobuf/internal/cmd/pbdump/pbdump_test.go b/vendor/google.golang.org/protobuf/internal/cmd/pbdump/pbdump_test.go
new file mode 100644
index 000000000..567cea0e2
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/cmd/pbdump/pbdump_test.go
@@ -0,0 +1,115 @@
+// 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 main
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"google.golang.org/protobuf/encoding/prototext"
+	"google.golang.org/protobuf/proto"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+
+	"google.golang.org/protobuf/types/descriptorpb"
+)
+
+func mustMakeMessage(s string) *descriptorpb.DescriptorProto {
+	s = fmt.Sprintf(`name:"test.proto" syntax:"proto2" message_type:[{%s}]`, s)
+	pb := new(descriptorpb.FileDescriptorProto)
+	if err := prototext.Unmarshal([]byte(s), pb); err != nil {
+		panic(err)
+	}
+	return pb.MessageType[0]
+}
+
+func TestFields(t *testing.T) {
+	type fieldsKind struct {
+		kind   pref.Kind
+		fields string
+	}
+	tests := []struct {
+		inFields []fieldsKind
+		wantMsg  *descriptorpb.DescriptorProto
+		wantErr  string
+	}{{
+		inFields: []fieldsKind{{pref.MessageKind, ""}},
+		wantMsg:  mustMakeMessage(`name:"X"`),
+	}, {
+		inFields: []fieldsKind{{pref.MessageKind, "987654321"}},
+		wantErr:  "invalid field: 987654321",
+	}, {
+		inFields: []fieldsKind{{pref.MessageKind, "-1"}},
+		wantErr:  "invalid field: -1",
+	}, {
+		inFields: []fieldsKind{{pref.MessageKind, "k"}},
+		wantErr:  "invalid field: k",
+	}, {
+		inFields: []fieldsKind{{pref.MessageKind, "1.2"}, {pref.Int32Kind, "1"}},
+		wantErr:  "field 1 of int32 type cannot have sub-fields",
+	}, {
+		inFields: []fieldsKind{{pref.Int32Kind, "1"}, {pref.MessageKind, "1.2"}},
+		wantErr:  "field 1 of int32 type cannot have sub-fields",
+	}, {
+		inFields: []fieldsKind{{pref.Int32Kind, "30"}, {pref.Int32Kind, "30"}},
+		wantErr:  "field 30 already set as int32 type",
+	}, {
+		inFields: []fieldsKind{
+			{pref.Int32Kind, "10.20.31"},
+			{pref.MessageKind, "  10.20.30, 10.21   "},
+			{pref.GroupKind, "10"},
+		},
+		wantMsg: mustMakeMessage(`
+			name: "X"
+			field: [
+				{name:"x10" number:10 label:LABEL_OPTIONAL type:TYPE_GROUP type_name:".X.X10"}
+			]
+			nested_type: [{
+				name: "X10"
+				field: [
+					{name:"x20" number:20 label:LABEL_OPTIONAL type:TYPE_MESSAGE type_name:".X.X10.X20"},
+					{name:"x21" number:21 label:LABEL_OPTIONAL type:TYPE_MESSAGE type_name:".X.X10.X21"}
+				]
+				nested_type: [{
+					name: "X20"
+					field:[
+						{name:"x30" number:30 label:LABEL_OPTIONAL type:TYPE_MESSAGE, type_name:".X.X10.X20.X30"},
+						{name:"x31" number:31 label:LABEL_REPEATED type:TYPE_INT32 options:{packed:true}}
+					]
+					nested_type: [{
+						name: "X30"
+					}]
+				}, {
+					name: "X21"
+				}]
+			}]
+		`),
+	}}
+
+	for _, tt := range tests {
+		t.Run("", func(t *testing.T) {
+			var fields fields
+			for i, tc := range tt.inFields {
+				gotErr := fields.Set(tc.fields, tc.kind)
+				if gotErr != nil {
+					if tt.wantErr == "" || !strings.Contains(fmt.Sprint(gotErr), tt.wantErr) {
+						t.Fatalf("fields %d, Set(%q, %v) = %v, want %v", i, tc.fields, tc.kind, gotErr, tt.wantErr)
+					}
+					return
+				}
+			}
+			if tt.wantErr != "" {
+				t.Errorf("all Set calls succeeded, want %v error", tt.wantErr)
+			}
+			gotMsg := fields.messageDescriptor("X")
+			if !proto.Equal(gotMsg, tt.wantMsg) {
+				t.Errorf("messageDescriptor() mismatch:\ngot  %v\nwant %v", gotMsg, tt.wantMsg)
+			}
+			if _, err := fields.Descriptor(); err != nil {
+				t.Errorf("Descriptor() = %v, want nil error", err)
+			}
+		})
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/conformance/conformance_test.go b/vendor/google.golang.org/protobuf/internal/conformance/conformance_test.go
new file mode 100644
index 000000000..1202050a0
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/conformance/conformance_test.go
@@ -0,0 +1,169 @@
+// Copyright 2019 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 conformance_test
+
+import (
+	"encoding/binary"
+	"flag"
+	"io"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+
+	"google.golang.org/protobuf/encoding/protojson"
+	"google.golang.org/protobuf/encoding/prototext"
+	"google.golang.org/protobuf/proto"
+
+	pb "google.golang.org/protobuf/internal/testprotos/conformance"
+)
+
+func init() {
+	// When the environment variable RUN_AS_CONFORMANCE_PLUGIN is set,
+	// we skip running the tests and instead act as a conformance plugin.
+	// This allows the binary to pass itself to conformance.
+	if os.Getenv("RUN_AS_CONFORMANCE_PLUGIN") == "1" {
+		main()
+		os.Exit(0)
+	}
+}
+
+var (
+	execute   = flag.Bool("execute", false, "execute the conformance test")
+	protoRoot = flag.String("protoroot", os.Getenv("PROTOBUF_ROOT"), "The root of the protobuf source tree.")
+)
+
+func Test(t *testing.T) {
+	if !*execute {
+		t.SkipNow()
+	}
+	binPath := filepath.Join(*protoRoot, "conformance", "conformance-test-runner")
+	cmd := exec.Command(binPath,
+		"--failure_list", "failing_tests.txt",
+		"--text_format_failure_list", "failing_tests_text_format.txt",
+		"--enforce_recommended",
+		os.Args[0])
+	cmd.Env = append(os.Environ(), "RUN_AS_CONFORMANCE_PLUGIN=1")
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("execution error: %v\n\n%s", err, out)
+	}
+}
+
+func main() {
+	var sizeBuf [4]byte
+	inbuf := make([]byte, 0, 4096)
+	for {
+		_, err := io.ReadFull(os.Stdin, sizeBuf[:])
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			log.Fatalf("conformance: read request: %v", err)
+		}
+		size := binary.LittleEndian.Uint32(sizeBuf[:])
+		if int(size) > cap(inbuf) {
+			inbuf = make([]byte, size)
+		}
+		inbuf = inbuf[:size]
+		if _, err := io.ReadFull(os.Stdin, inbuf); err != nil {
+			log.Fatalf("conformance: read request: %v", err)
+		}
+
+		req := &pb.ConformanceRequest{}
+		if err := proto.Unmarshal(inbuf, req); err != nil {
+			log.Fatalf("conformance: parse request: %v", err)
+		}
+		res := handle(req)
+
+		out, err := proto.Marshal(res)
+		if err != nil {
+			log.Fatalf("conformance: marshal response: %v", err)
+		}
+		binary.LittleEndian.PutUint32(sizeBuf[:], uint32(len(out)))
+		if _, err := os.Stdout.Write(sizeBuf[:]); err != nil {
+			log.Fatalf("conformance: write response: %v", err)
+		}
+		if _, err := os.Stdout.Write(out); err != nil {
+			log.Fatalf("conformance: write response: %v", err)
+		}
+	}
+}
+
+func handle(req *pb.ConformanceRequest) (res *pb.ConformanceResponse) {
+	var msg proto.Message = &pb.TestAllTypesProto2{}
+	if req.GetMessageType() == "protobuf_test_messages.proto3.TestAllTypesProto3" {
+		msg = &pb.TestAllTypesProto3{}
+	}
+
+	// Unmarshal the test message.
+	var err error
+	switch p := req.Payload.(type) {
+	case *pb.ConformanceRequest_ProtobufPayload:
+		err = proto.Unmarshal(p.ProtobufPayload, msg)
+	case *pb.ConformanceRequest_JsonPayload:
+		err = protojson.UnmarshalOptions{
+			DiscardUnknown: req.TestCategory == pb.TestCategory_JSON_IGNORE_UNKNOWN_PARSING_TEST,
+		}.Unmarshal([]byte(p.JsonPayload), msg)
+	case *pb.ConformanceRequest_TextPayload:
+		err = prototext.Unmarshal([]byte(p.TextPayload), msg)
+	default:
+		return &pb.ConformanceResponse{
+			Result: &pb.ConformanceResponse_RuntimeError{
+				RuntimeError: "unknown request payload type",
+			},
+		}
+	}
+	if err != nil {
+		return &pb.ConformanceResponse{
+			Result: &pb.ConformanceResponse_ParseError{
+				ParseError: err.Error(),
+			},
+		}
+	}
+
+	// Marshal the test message.
+	var b []byte
+	switch req.RequestedOutputFormat {
+	case pb.WireFormat_PROTOBUF:
+		b, err = proto.Marshal(msg)
+		res = &pb.ConformanceResponse{
+			Result: &pb.ConformanceResponse_ProtobufPayload{
+				ProtobufPayload: b,
+			},
+		}
+	case pb.WireFormat_JSON:
+		b, err = protojson.Marshal(msg)
+		res = &pb.ConformanceResponse{
+			Result: &pb.ConformanceResponse_JsonPayload{
+				JsonPayload: string(b),
+			},
+		}
+	case pb.WireFormat_TEXT_FORMAT:
+		b, err = prototext.MarshalOptions{
+			EmitUnknown: req.PrintUnknownFields,
+		}.Marshal(msg)
+		res = &pb.ConformanceResponse{
+			Result: &pb.ConformanceResponse_TextPayload{
+				TextPayload: string(b),
+			},
+		}
+	default:
+		return &pb.ConformanceResponse{
+			Result: &pb.ConformanceResponse_RuntimeError{
+				RuntimeError: "unknown output format",
+			},
+		}
+	}
+	if err != nil {
+		return &pb.ConformanceResponse{
+			Result: &pb.ConformanceResponse_SerializeError{
+				SerializeError: err.Error(),
+			},
+		}
+	}
+	return res
+}
diff --git a/vendor/google.golang.org/protobuf/internal/conformance/failing_tests.txt b/vendor/google.golang.org/protobuf/internal/conformance/failing_tests.txt
new file mode 100644
index 000000000..92dc37430
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/conformance/failing_tests.txt
@@ -0,0 +1 @@
+Recommended.Proto3.JsonInput.FieldMaskInvalidCharacter
diff --git a/vendor/google.golang.org/protobuf/internal/conformance/failing_tests_text_format.txt b/vendor/google.golang.org/protobuf/internal/conformance/failing_tests_text_format.txt
new file mode 100644
index 000000000..570abde59
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/conformance/failing_tests_text_format.txt
@@ -0,0 +1 @@
+Recommended.Proto3.ProtobufInput.MessageUnknownFields_Print.TextFormatOutput
diff --git a/vendor/google.golang.org/protobuf/internal/descfmt/desc_test.go b/vendor/google.golang.org/protobuf/internal/descfmt/desc_test.go
new file mode 100644
index 000000000..6d683b2d6
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/descfmt/desc_test.go
@@ -0,0 +1,62 @@
+// 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 descfmt
+
+import (
+	"testing"
+)
+
+// TestDescriptorAccessors tests that descriptorAccessors is up-to-date.
+func TestDescriptorAccessors(t *testing.T) {
+	ignore := map[string]bool{
+		"ParentFile":    true,
+		"Parent":        true,
+		"Index":         true,
+		"Syntax":        true,
+		"Name":          true,
+		"FullName":      true,
+		"IsPlaceholder": true,
+		"Options":       true,
+		"ProtoInternal": true,
+		"ProtoType":     true,
+
+		"HasOptionalKeyword": true, // captured by HasPresence
+		"IsSynthetic":        true, // captured by HasPresence
+
+		"SourceLocations":       true, // specific to FileDescriptor
+		"ExtensionRangeOptions": true, // specific to MessageDescriptor
+		"DefaultEnumValue":      true, // specific to FieldDescriptor
+		"MapKey":                true, // specific to FieldDescriptor
+		"MapValue":              true, // specific to FieldDescriptor
+	}
+
+	for rt, m := range descriptorAccessors {
+		got := map[string]bool{}
+		for _, s := range m {
+			got[s] = true
+		}
+		want := map[string]bool{}
+		for i := 0; i < rt.NumMethod(); i++ {
+			want[rt.Method(i).Name] = true
+		}
+
+		// Check if descriptorAccessors contains a non-existent accessor.
+		// If this test fails, remove the accessor from descriptorAccessors.
+		for s := range got {
+			if !want[s] && !ignore[s] {
+				t.Errorf("%v.%v does not exist", rt, s)
+			}
+		}
+
+		// Check if there are new protoreflect interface methods that are not
+		// handled by the formatter. If this fails, either add the method to
+		// ignore or add them to descriptorAccessors.
+		for s := range want {
+			if !got[s] && !ignore[s] {
+				t.Errorf("%v.%v is not called by formatter", rt, s)
+			}
+		}
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/descfmt/stringer.go b/vendor/google.golang.org/protobuf/internal/descfmt/stringer.go
new file mode 100644
index 000000000..e7af0fe0d
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/descfmt/stringer.go
@@ -0,0 +1,316 @@
+// 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 descfmt provides functionality to format descriptors.
+package descfmt
+
+import (
+	"fmt"
+	"io"
+	"reflect"
+	"strconv"
+	"strings"
+
+	"google.golang.org/protobuf/internal/detrand"
+	"google.golang.org/protobuf/internal/pragma"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+)
+
+type list interface {
+	Len() int
+	pragma.DoNotImplement
+}
+
+func FormatList(s fmt.State, r rune, vs list) {
+	io.WriteString(s, formatListOpt(vs, true, r == 'v' && (s.Flag('+') || s.Flag('#'))))
+}
+func formatListOpt(vs list, isRoot, allowMulti bool) string {
+	start, end := "[", "]"
+	if isRoot {
+		var name string
+		switch vs.(type) {
+		case pref.Names:
+			name = "Names"
+		case pref.FieldNumbers:
+			name = "FieldNumbers"
+		case pref.FieldRanges:
+			name = "FieldRanges"
+		case pref.EnumRanges:
+			name = "EnumRanges"
+		case pref.FileImports:
+			name = "FileImports"
+		case pref.Descriptor:
+			name = reflect.ValueOf(vs).MethodByName("Get").Type().Out(0).Name() + "s"
+		}
+		start, end = name+"{", "}"
+	}
+
+	var ss []string
+	switch vs := vs.(type) {
+	case pref.Names:
+		for i := 0; i < vs.Len(); i++ {
+			ss = append(ss, fmt.Sprint(vs.Get(i)))
+		}
+		return start + joinStrings(ss, false) + end
+	case pref.FieldNumbers:
+		for i := 0; i < vs.Len(); i++ {
+			ss = append(ss, fmt.Sprint(vs.Get(i)))
+		}
+		return start + joinStrings(ss, false) + end
+	case pref.FieldRanges:
+		for i := 0; i < vs.Len(); i++ {
+			r := vs.Get(i)
+			if r[0]+1 == r[1] {
+				ss = append(ss, fmt.Sprintf("%d", r[0]))
+			} else {
+				ss = append(ss, fmt.Sprintf("%d:%d", r[0], r[1])) // enum ranges are end exclusive
+			}
+		}
+		return start + joinStrings(ss, false) + end
+	case pref.EnumRanges:
+		for i := 0; i < vs.Len(); i++ {
+			r := vs.Get(i)
+			if r[0] == r[1] {
+				ss = append(ss, fmt.Sprintf("%d", r[0]))
+			} else {
+				ss = append(ss, fmt.Sprintf("%d:%d", r[0], int64(r[1])+1)) // enum ranges are end inclusive
+			}
+		}
+		return start + joinStrings(ss, false) + end
+	case pref.FileImports:
+		for i := 0; i < vs.Len(); i++ {
+			var rs records
+			rs.Append(reflect.ValueOf(vs.Get(i)), "Path", "Package", "IsPublic", "IsWeak")
+			ss = append(ss, "{"+rs.Join()+"}")
+		}
+		return start + joinStrings(ss, allowMulti) + end
+	default:
+		_, isEnumValue := vs.(pref.EnumValueDescriptors)
+		for i := 0; i < vs.Len(); i++ {
+			m := reflect.ValueOf(vs).MethodByName("Get")
+			v := m.Call([]reflect.Value{reflect.ValueOf(i)})[0].Interface()
+			ss = append(ss, formatDescOpt(v.(pref.Descriptor), false, allowMulti && !isEnumValue))
+		}
+		return start + joinStrings(ss, allowMulti && isEnumValue) + end
+	}
+}
+
+// descriptorAccessors is a list of accessors to print for each descriptor.
+//
+// Do not print all accessors since some contain redundant information,
+// while others are pointers that we do not want to follow since the descriptor
+// is actually a cyclic graph.
+//
+// Using a list allows us to print the accessors in a sensible order.
+var descriptorAccessors = map[reflect.Type][]string{
+	reflect.TypeOf((*pref.FileDescriptor)(nil)).Elem():      {"Path", "Package", "Imports", "Messages", "Enums", "Extensions", "Services"},
+	reflect.TypeOf((*pref.MessageDescriptor)(nil)).Elem():   {"IsMapEntry", "Fields", "Oneofs", "ReservedNames", "ReservedRanges", "RequiredNumbers", "ExtensionRanges", "Messages", "Enums", "Extensions"},
+	reflect.TypeOf((*pref.FieldDescriptor)(nil)).Elem():     {"Number", "Cardinality", "Kind", "HasJSONName", "JSONName", "HasPresence", "IsExtension", "IsPacked", "IsWeak", "IsList", "IsMap", "MapKey", "MapValue", "HasDefault", "Default", "ContainingOneof", "ContainingMessage", "Message", "Enum"},
+	reflect.TypeOf((*pref.OneofDescriptor)(nil)).Elem():     {"Fields"}, // not directly used; must keep in sync with formatDescOpt
+	reflect.TypeOf((*pref.EnumDescriptor)(nil)).Elem():      {"Values", "ReservedNames", "ReservedRanges"},
+	reflect.TypeOf((*pref.EnumValueDescriptor)(nil)).Elem(): {"Number"},
+	reflect.TypeOf((*pref.ServiceDescriptor)(nil)).Elem():   {"Methods"},
+	reflect.TypeOf((*pref.MethodDescriptor)(nil)).Elem():    {"Input", "Output", "IsStreamingClient", "IsStreamingServer"},
+}
+
+func FormatDesc(s fmt.State, r rune, t pref.Descriptor) {
+	io.WriteString(s, formatDescOpt(t, true, r == 'v' && (s.Flag('+') || s.Flag('#'))))
+}
+func formatDescOpt(t pref.Descriptor, isRoot, allowMulti bool) string {
+	rv := reflect.ValueOf(t)
+	rt := rv.MethodByName("ProtoType").Type().In(0)
+
+	start, end := "{", "}"
+	if isRoot {
+		start = rt.Name() + "{"
+	}
+
+	_, isFile := t.(pref.FileDescriptor)
+	rs := records{allowMulti: allowMulti}
+	if t.IsPlaceholder() {
+		if isFile {
+			rs.Append(rv, "Path", "Package", "IsPlaceholder")
+		} else {
+			rs.Append(rv, "FullName", "IsPlaceholder")
+		}
+	} else {
+		switch {
+		case isFile:
+			rs.Append(rv, "Syntax")
+		case isRoot:
+			rs.Append(rv, "Syntax", "FullName")
+		default:
+			rs.Append(rv, "Name")
+		}
+		switch t := t.(type) {
+		case pref.FieldDescriptor:
+			for _, s := range descriptorAccessors[rt] {
+				switch s {
+				case "MapKey":
+					if k := t.MapKey(); k != nil {
+						rs.recs = append(rs.recs, [2]string{"MapKey", k.Kind().String()})
+					}
+				case "MapValue":
+					if v := t.MapValue(); v != nil {
+						switch v.Kind() {
+						case pref.EnumKind:
+							rs.recs = append(rs.recs, [2]string{"MapValue", string(v.Enum().FullName())})
+						case pref.MessageKind, pref.GroupKind:
+							rs.recs = append(rs.recs, [2]string{"MapValue", string(v.Message().FullName())})
+						default:
+							rs.recs = append(rs.recs, [2]string{"MapValue", v.Kind().String()})
+						}
+					}
+				case "ContainingOneof":
+					if od := t.ContainingOneof(); od != nil {
+						rs.recs = append(rs.recs, [2]string{"Oneof", string(od.Name())})
+					}
+				case "ContainingMessage":
+					if t.IsExtension() {
+						rs.recs = append(rs.recs, [2]string{"Extendee", string(t.ContainingMessage().FullName())})
+					}
+				case "Message":
+					if !t.IsMap() {
+						rs.Append(rv, s)
+					}
+				default:
+					rs.Append(rv, s)
+				}
+			}
+		case pref.OneofDescriptor:
+			var ss []string
+			fs := t.Fields()
+			for i := 0; i < fs.Len(); i++ {
+				ss = append(ss, string(fs.Get(i).Name()))
+			}
+			if len(ss) > 0 {
+				rs.recs = append(rs.recs, [2]string{"Fields", "[" + joinStrings(ss, false) + "]"})
+			}
+		default:
+			rs.Append(rv, descriptorAccessors[rt]...)
+		}
+		if rv.MethodByName("GoType").IsValid() {
+			rs.Append(rv, "GoType")
+		}
+	}
+	return start + rs.Join() + end
+}
+
+type records struct {
+	recs       [][2]string
+	allowMulti bool
+}
+
+func (rs *records) Append(v reflect.Value, accessors ...string) {
+	for _, a := range accessors {
+		var rv reflect.Value
+		if m := v.MethodByName(a); m.IsValid() {
+			rv = m.Call(nil)[0]
+		}
+		if v.Kind() == reflect.Struct && !rv.IsValid() {
+			rv = v.FieldByName(a)
+		}
+		if !rv.IsValid() {
+			panic(fmt.Sprintf("unknown accessor: %v.%s", v.Type(), a))
+		}
+		if _, ok := rv.Interface().(pref.Value); ok {
+			rv = rv.MethodByName("Interface").Call(nil)[0]
+			if !rv.IsNil() {
+				rv = rv.Elem()
+			}
+		}
+
+		// Ignore zero values.
+		var isZero bool
+		switch rv.Kind() {
+		case reflect.Interface, reflect.Slice:
+			isZero = rv.IsNil()
+		case reflect.Bool:
+			isZero = rv.Bool() == false
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			isZero = rv.Int() == 0
+		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+			isZero = rv.Uint() == 0
+		case reflect.String:
+			isZero = rv.String() == ""
+		}
+		if n, ok := rv.Interface().(list); ok {
+			isZero = n.Len() == 0
+		}
+		if isZero {
+			continue
+		}
+
+		// Format the value.
+		var s string
+		v := rv.Interface()
+		switch v := v.(type) {
+		case list:
+			s = formatListOpt(v, false, rs.allowMulti)
+		case pref.FieldDescriptor, pref.OneofDescriptor, pref.EnumValueDescriptor, pref.MethodDescriptor:
+			s = string(v.(pref.Descriptor).Name())
+		case pref.Descriptor:
+			s = string(v.FullName())
+		case string:
+			s = strconv.Quote(v)
+		case []byte:
+			s = fmt.Sprintf("%q", v)
+		default:
+			s = fmt.Sprint(v)
+		}
+		rs.recs = append(rs.recs, [2]string{a, s})
+	}
+}
+
+func (rs *records) Join() string {
+	var ss []string
+
+	// In single line mode, simply join all records with commas.
+	if !rs.allowMulti {
+		for _, r := range rs.recs {
+			ss = append(ss, r[0]+formatColon(0)+r[1])
+		}
+		return joinStrings(ss, false)
+	}
+
+	// In allowMulti line mode, align single line records for more readable output.
+	var maxLen int
+	flush := func(i int) {
+		for _, r := range rs.recs[len(ss):i] {
+			ss = append(ss, r[0]+formatColon(maxLen-len(r[0]))+r[1])
+		}
+		maxLen = 0
+	}
+	for i, r := range rs.recs {
+		if isMulti := strings.Contains(r[1], "\n"); isMulti {
+			flush(i)
+			ss = append(ss, r[0]+formatColon(0)+strings.Join(strings.Split(r[1], "\n"), "\n\t"))
+		} else if maxLen < len(r[0]) {
+			maxLen = len(r[0])
+		}
+	}
+	flush(len(rs.recs))
+	return joinStrings(ss, true)
+}
+
+func formatColon(padding int) string {
+	// Deliberately introduce instability into the debug output to
+	// discourage users from performing string comparisons.
+	// This provides us flexibility to change the output in the future.
+	if detrand.Bool() {
+		return ":" + strings.Repeat(" ", 1+padding) // use non-breaking spaces (U+00a0)
+	} else {
+		return ":" + strings.Repeat(" ", 1+padding) // use regular spaces (U+0020)
+	}
+}
+
+func joinStrings(ss []string, isMulti bool) string {
+	if len(ss) == 0 {
+		return ""
+	}
+	if isMulti {
+		return "\n\t" + strings.Join(ss, "\n\t") + "\n"
+	}
+	return strings.Join(ss, ", ")
+}
diff --git a/vendor/google.golang.org/protobuf/internal/descopts/options.go b/vendor/google.golang.org/protobuf/internal/descopts/options.go
new file mode 100644
index 000000000..8401be8c8
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/descopts/options.go
@@ -0,0 +1,29 @@
+// Copyright 2019 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 descopts contains the nil pointers to concrete descriptor options.
+//
+// This package exists as a form of reverse dependency injection so that certain
+// packages (e.g., internal/filedesc and internal/filetype can avoid a direct
+// dependency on the descriptor proto package).
+package descopts
+
+import pref "google.golang.org/protobuf/reflect/protoreflect"
+
+// These variables are set by the init function in descriptor.pb.go via logic
+// in internal/filetype. In other words, so long as the descriptor proto package
+// is linked in, these variables will be populated.
+//
+// Each variable is populated with a nil pointer to the options struct.
+var (
+	File           pref.ProtoMessage
+	Enum           pref.ProtoMessage
+	EnumValue      pref.ProtoMessage
+	Message        pref.ProtoMessage
+	Field          pref.ProtoMessage
+	Oneof          pref.ProtoMessage
+	ExtensionRange pref.ProtoMessage
+	Service        pref.ProtoMessage
+	Method         pref.ProtoMessage
+)
diff --git a/vendor/google.golang.org/protobuf/internal/detectknown/detect.go b/vendor/google.golang.org/protobuf/internal/detectknown/detect.go
new file mode 100644
index 000000000..091c4233d
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/detectknown/detect.go
@@ -0,0 +1,47 @@
+// Copyright 2020 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 detectknown provides functionality for detecting well-known types
+// and identifying them by name.
+package detectknown
+
+import "google.golang.org/protobuf/reflect/protoreflect"
+
+type ProtoFile int
+
+const (
+	Unknown ProtoFile = iota
+	AnyProto
+	TimestampProto
+	DurationProto
+	WrappersProto
+	StructProto
+	FieldMaskProto
+	EmptyProto
+)
+
+var wellKnownTypes = map[protoreflect.FullName]ProtoFile{
+	"google.protobuf.Any":         AnyProto,
+	"google.protobuf.Timestamp":   TimestampProto,
+	"google.protobuf.Duration":    DurationProto,
+	"google.protobuf.BoolValue":   WrappersProto,
+	"google.protobuf.Int32Value":  WrappersProto,
+	"google.protobuf.Int64Value":  WrappersProto,
+	"google.protobuf.UInt32Value": WrappersProto,
+	"google.protobuf.UInt64Value": WrappersProto,
+	"google.protobuf.FloatValue":  WrappersProto,
+	"google.protobuf.DoubleValue": WrappersProto,
+	"google.protobuf.BytesValue":  WrappersProto,
+	"google.protobuf.StringValue": WrappersProto,
+	"google.protobuf.Struct":      StructProto,
+	"google.protobuf.ListValue":   StructProto,
+	"google.protobuf.Value":       StructProto,
+	"google.protobuf.FieldMask":   FieldMaskProto,
+	"google.protobuf.Empty":       EmptyProto,
+}
+
+// Which identifies the proto file that a well-known type belongs to.
+func Which(s protoreflect.FullName) ProtoFile {
+	return wellKnownTypes[s]
+}
diff --git a/vendor/google.golang.org/protobuf/internal/detectknown/detect_test.go b/vendor/google.golang.org/protobuf/internal/detectknown/detect_test.go
new file mode 100644
index 000000000..c9a31c954
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/detectknown/detect_test.go
@@ -0,0 +1,58 @@
+// Copyright 2020 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 detectknown_test
+
+import (
+	"testing"
+
+	"google.golang.org/protobuf/internal/detectknown"
+	"google.golang.org/protobuf/reflect/protoreflect"
+
+	fieldmaskpb "google.golang.org/protobuf/internal/testprotos/fieldmaskpb"
+	"google.golang.org/protobuf/types/descriptorpb"
+	"google.golang.org/protobuf/types/known/anypb"
+	"google.golang.org/protobuf/types/known/durationpb"
+	"google.golang.org/protobuf/types/known/emptypb"
+	"google.golang.org/protobuf/types/known/structpb"
+	"google.golang.org/protobuf/types/known/timestamppb"
+	"google.golang.org/protobuf/types/known/wrapperspb"
+	"google.golang.org/protobuf/types/pluginpb"
+)
+
+func TestWhich(t *testing.T) {
+	tests := []struct {
+		in   protoreflect.FileDescriptor
+		want detectknown.ProtoFile
+	}{
+		{descriptorpb.File_google_protobuf_descriptor_proto, detectknown.Unknown},
+		{pluginpb.File_google_protobuf_compiler_plugin_proto, detectknown.Unknown},
+		{anypb.File_google_protobuf_any_proto, detectknown.AnyProto},
+		{timestamppb.File_google_protobuf_timestamp_proto, detectknown.TimestampProto},
+		{durationpb.File_google_protobuf_duration_proto, detectknown.DurationProto},
+		{wrapperspb.File_google_protobuf_wrappers_proto, detectknown.WrappersProto},
+		{structpb.File_google_protobuf_struct_proto, detectknown.StructProto},
+		{fieldmaskpb.File_google_protobuf_field_mask_proto, detectknown.FieldMaskProto},
+		{emptypb.File_google_protobuf_empty_proto, detectknown.EmptyProto},
+	}
+
+	for _, tt := range tests {
+		rangeMessages(tt.in.Messages(), func(md protoreflect.MessageDescriptor) {
+			got := detectknown.Which(md.FullName())
+			if got != tt.want {
+				t.Errorf("Which(%s) = %v, want %v", md.FullName(), got, tt.want)
+			}
+		})
+	}
+}
+
+func rangeMessages(mds protoreflect.MessageDescriptors, f func(protoreflect.MessageDescriptor)) {
+	for i := 0; i < mds.Len(); i++ {
+		md := mds.Get(i)
+		if !md.IsMapEntry() {
+			f(md)
+		}
+		rangeMessages(md.Messages(), f)
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/detrand/rand.go b/vendor/google.golang.org/protobuf/internal/detrand/rand.go
new file mode 100644
index 000000000..a904dd1f9
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/detrand/rand.go
@@ -0,0 +1,61 @@
+// 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 detrand provides deterministically random functionality.
+//
+// The pseudo-randomness of these functions is seeded by the program binary
+// itself and guarantees that the output does not change within a program,
+// while ensuring that the output is unstable across different builds.
+package detrand
+
+import (
+	"encoding/binary"
+	"hash/fnv"
+	"os"
+)
+
+// Disable disables detrand such that all functions returns the zero value.
+// This function is not concurrent-safe and must be called during program init.
+func Disable() {
+	randSeed = 0
+}
+
+// Bool returns a deterministically random boolean.
+func Bool() bool {
+	return randSeed%2 == 1
+}
+
+// randSeed is a best-effort at an approximate hash of the Go binary.
+var randSeed = binaryHash()
+
+func binaryHash() uint64 {
+	// Open the Go binary.
+	s, err := os.Executable()
+	if err != nil {
+		return 0
+	}
+	f, err := os.Open(s)
+	if err != nil {
+		return 0
+	}
+	defer f.Close()
+
+	// Hash the size and several samples of the Go binary.
+	const numSamples = 8
+	var buf [64]byte
+	h := fnv.New64()
+	fi, err := f.Stat()
+	if err != nil {
+		return 0
+	}
+	binary.LittleEndian.PutUint64(buf[:8], uint64(fi.Size()))
+	h.Write(buf[:8])
+	for i := int64(0); i < numSamples; i++ {
+		if _, err := f.ReadAt(buf[:], i*fi.Size()/numSamples); err != nil {
+			return 0
+		}
+		h.Write(buf[:])
+	}
+	return h.Sum64()
+}
diff --git a/vendor/google.golang.org/protobuf/internal/detrand/rand_test.go b/vendor/google.golang.org/protobuf/internal/detrand/rand_test.go
new file mode 100644
index 000000000..68c55d284
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/detrand/rand_test.go
@@ -0,0 +1,14 @@
+// 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 detrand
+
+import "testing"
+
+func Benchmark(b *testing.B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		binaryHash()
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/defval/default.go b/vendor/google.golang.org/protobuf/internal/encoding/defval/default.go
new file mode 100644
index 000000000..fdd9b13f2
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/encoding/defval/default.go
@@ -0,0 +1,213 @@
+// 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 defval marshals and unmarshals textual forms of default values.
+//
+// This package handles both the form historically used in Go struct field tags
+// and also the form used by google.protobuf.FieldDescriptorProto.default_value
+// since they differ in superficial ways.
+package defval
+
+import (
+	"fmt"
+	"math"
+	"strconv"
+
+	ptext "google.golang.org/protobuf/internal/encoding/text"
+	errors "google.golang.org/protobuf/internal/errors"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+)
+
+// Format is the serialization format used to represent the default value.
+type Format int
+
+const (
+	_ Format = iota
+
+	// Descriptor uses the serialization format that protoc uses with the
+	// google.protobuf.FieldDescriptorProto.default_value field.
+	Descriptor
+
+	// GoTag uses the historical serialization format in Go struct field tags.
+	GoTag
+)
+
+// Unmarshal deserializes the default string s according to the given kind k.
+// When k is an enum, a list of enum value descriptors must be provided.
+func Unmarshal(s string, k pref.Kind, evs pref.EnumValueDescriptors, f Format) (pref.Value, pref.EnumValueDescriptor, error) {
+	switch k {
+	case pref.BoolKind:
+		if f == GoTag {
+			switch s {
+			case "1":
+				return pref.ValueOfBool(true), nil, nil
+			case "0":
+				return pref.ValueOfBool(false), nil, nil
+			}
+		} else {
+			switch s {
+			case "true":
+				return pref.ValueOfBool(true), nil, nil
+			case "false":
+				return pref.ValueOfBool(false), nil, nil
+			}
+		}
+	case pref.EnumKind:
+		if f == GoTag {
+			// Go tags use the numeric form of the enum value.
+			if n, err := strconv.ParseInt(s, 10, 32); err == nil {
+				if ev := evs.ByNumber(pref.EnumNumber(n)); ev != nil {
+					return pref.ValueOfEnum(ev.Number()), ev, nil
+				}
+			}
+		} else {
+			// Descriptor default_value use the enum identifier.
+			ev := evs.ByName(pref.Name(s))
+			if ev != nil {
+				return pref.ValueOfEnum(ev.Number()), ev, nil
+			}
+		}
+	case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
+		if v, err := strconv.ParseInt(s, 10, 32); err == nil {
+			return pref.ValueOfInt32(int32(v)), nil, nil
+		}
+	case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
+		if v, err := strconv.ParseInt(s, 10, 64); err == nil {
+			return pref.ValueOfInt64(int64(v)), nil, nil
+		}
+	case pref.Uint32Kind, pref.Fixed32Kind:
+		if v, err := strconv.ParseUint(s, 10, 32); err == nil {
+			return pref.ValueOfUint32(uint32(v)), nil, nil
+		}
+	case pref.Uint64Kind, pref.Fixed64Kind:
+		if v, err := strconv.ParseUint(s, 10, 64); err == nil {
+			return pref.ValueOfUint64(uint64(v)), nil, nil
+		}
+	case pref.FloatKind, pref.DoubleKind:
+		var v float64
+		var err error
+		switch s {
+		case "-inf":
+			v = math.Inf(-1)
+		case "inf":
+			v = math.Inf(+1)
+		case "nan":
+			v = math.NaN()
+		default:
+			v, err = strconv.ParseFloat(s, 64)
+		}
+		if err == nil {
+			if k == pref.FloatKind {
+				return pref.ValueOfFloat32(float32(v)), nil, nil
+			} else {
+				return pref.ValueOfFloat64(float64(v)), nil, nil
+			}
+		}
+	case pref.StringKind:
+		// String values are already unescaped and can be used as is.
+		return pref.ValueOfString(s), nil, nil
+	case pref.BytesKind:
+		if b, ok := unmarshalBytes(s); ok {
+			return pref.ValueOfBytes(b), nil, nil
+		}
+	}
+	return pref.Value{}, nil, errors.New("could not parse value for %v: %q", k, s)
+}
+
+// Marshal serializes v as the default string according to the given kind k.
+// When specifying the Descriptor format for an enum kind, the associated
+// enum value descriptor must be provided.
+func Marshal(v pref.Value, ev pref.EnumValueDescriptor, k pref.Kind, f Format) (string, error) {
+	switch k {
+	case pref.BoolKind:
+		if f == GoTag {
+			if v.Bool() {
+				return "1", nil
+			} else {
+				return "0", nil
+			}
+		} else {
+			if v.Bool() {
+				return "true", nil
+			} else {
+				return "false", nil
+			}
+		}
+	case pref.EnumKind:
+		if f == GoTag {
+			return strconv.FormatInt(int64(v.Enum()), 10), nil
+		} else {
+			return string(ev.Name()), nil
+		}
+	case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind, pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
+		return strconv.FormatInt(v.Int(), 10), nil
+	case pref.Uint32Kind, pref.Fixed32Kind, pref.Uint64Kind, pref.Fixed64Kind:
+		return strconv.FormatUint(v.Uint(), 10), nil
+	case pref.FloatKind, pref.DoubleKind:
+		f := v.Float()
+		switch {
+		case math.IsInf(f, -1):
+			return "-inf", nil
+		case math.IsInf(f, +1):
+			return "inf", nil
+		case math.IsNaN(f):
+			return "nan", nil
+		default:
+			if k == pref.FloatKind {
+				return strconv.FormatFloat(f, 'g', -1, 32), nil
+			} else {
+				return strconv.FormatFloat(f, 'g', -1, 64), nil
+			}
+		}
+	case pref.StringKind:
+		// String values are serialized as is without any escaping.
+		return v.String(), nil
+	case pref.BytesKind:
+		if s, ok := marshalBytes(v.Bytes()); ok {
+			return s, nil
+		}
+	}
+	return "", errors.New("could not format value for %v: %v", k, v)
+}
+
+// unmarshalBytes deserializes bytes by applying C unescaping.
+func unmarshalBytes(s string) ([]byte, bool) {
+	// Bytes values use the same escaping as the text format,
+	// however they lack the surrounding double quotes.
+	v, err := ptext.UnmarshalString(`"` + s + `"`)
+	if err != nil {
+		return nil, false
+	}
+	return []byte(v), true
+}
+
+// marshalBytes serializes bytes by using C escaping.
+// To match the exact output of protoc, this is identical to the
+// CEscape function in strutil.cc of the protoc source code.
+func marshalBytes(b []byte) (string, bool) {
+	var s []byte
+	for _, c := range b {
+		switch c {
+		case '\n':
+			s = append(s, `\n`...)
+		case '\r':
+			s = append(s, `\r`...)
+		case '\t':
+			s = append(s, `\t`...)
+		case '"':
+			s = append(s, `\"`...)
+		case '\'':
+			s = append(s, `\'`...)
+		case '\\':
+			s = append(s, `\\`...)
+		default:
+			if printableASCII := c >= 0x20 && c <= 0x7e; printableASCII {
+				s = append(s, c)
+			} else {
+				s = append(s, fmt.Sprintf(`\%03o`, c)...)
+			}
+		}
+	}
+	return string(s), true
+}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/defval/default_test.go b/vendor/google.golang.org/protobuf/internal/encoding/defval/default_test.go
new file mode 100644
index 000000000..d81150d71
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/encoding/defval/default_test.go
@@ -0,0 +1,105 @@
+// 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 defval_test
+
+import (
+	"math"
+	"reflect"
+	"testing"
+
+	"google.golang.org/protobuf/internal/encoding/defval"
+	fdesc "google.golang.org/protobuf/internal/filedesc"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+)
+
+func Test(t *testing.T) {
+	evs := fdesc.EnumValues{List: []fdesc.EnumValue{{}}}
+	evs.List[0].L0.ParentFile = fdesc.SurrogateProto2
+	evs.List[0].L0.FullName = "ALPHA"
+	evs.List[0].L1.Number = 1
+
+	V := pref.ValueOf
+	tests := []struct {
+		val   pref.Value
+		enum  pref.EnumValueDescriptor
+		enums pref.EnumValueDescriptors
+		kind  pref.Kind
+		strPB string
+		strGo string
+	}{{
+		val:   V(bool(true)),
+		enum:  nil,
+		enums: nil,
+		kind:  pref.BoolKind,
+		strPB: "true",
+		strGo: "1",
+	}, {
+		val:   V(int32(-0x1234)),
+		enum:  nil,
+		enums: nil,
+		kind:  pref.Int32Kind,
+		strPB: "-4660",
+		strGo: "-4660",
+	}, {
+		val:   V(float32(math.Pi)),
+		enum:  nil,
+		enums: nil,
+		kind:  pref.FloatKind,
+		strPB: "3.1415927",
+		strGo: "3.1415927",
+	}, {
+		val:   V(float64(math.Pi)),
+		enum:  nil,
+		enums: nil,
+		kind:  pref.DoubleKind,
+		strPB: "3.141592653589793",
+		strGo: "3.141592653589793",
+	}, {
+		val:   V(string("hello, \xde\xad\xbe\xef\n")),
+		enum:  nil,
+		enums: nil,
+		kind:  pref.StringKind,
+		strPB: "hello, \xde\xad\xbe\xef\n",
+		strGo: "hello, \xde\xad\xbe\xef\n",
+	}, {
+		val:   V([]byte("hello, \xde\xad\xbe\xef\n")),
+		enum:  nil,
+		enums: nil,
+		kind:  pref.BytesKind,
+		strPB: "hello, \\336\\255\\276\\357\\n",
+		strGo: "hello, \\336\\255\\276\\357\\n",
+	}, {
+		val:   V(pref.EnumNumber(1)),
+		enum:  &evs.List[0],
+		enums: &evs,
+		kind:  pref.EnumKind,
+		strPB: "ALPHA",
+		strGo: "1",
+	}}
+
+	for _, tt := range tests {
+		t.Run("", func(t *testing.T) {
+			gotStr, _ := defval.Marshal(tt.val, tt.enum, tt.kind, defval.Descriptor)
+			if gotStr != tt.strPB {
+				t.Errorf("Marshal(%v, %v, Descriptor) = %q, want %q", tt.val, tt.kind, gotStr, tt.strPB)
+			}
+
+			gotStr, _ = defval.Marshal(tt.val, tt.enum, tt.kind, defval.GoTag)
+			if gotStr != tt.strGo {
+				t.Errorf("Marshal(%v, %v, GoTag) = %q, want %q", tt.val, tt.kind, gotStr, tt.strGo)
+			}
+
+			gotVal, gotEnum, _ := defval.Unmarshal(tt.strPB, tt.kind, tt.enums, defval.Descriptor)
+			if !reflect.DeepEqual(gotVal.Interface(), tt.val.Interface()) || gotEnum != tt.enum {
+				t.Errorf("Unmarshal(%v, %v, Descriptor) = (%q, %v), want (%q, %v)", tt.strPB, tt.kind, gotVal, gotEnum, tt.val, tt.enum)
+			}
+
+			gotVal, gotEnum, _ = defval.Unmarshal(tt.strGo, tt.kind, tt.enums, defval.GoTag)
+			if !reflect.DeepEqual(gotVal.Interface(), tt.val.Interface()) || gotEnum != tt.enum {
+				t.Errorf("Unmarshal(%v, %v, GoTag) = (%q, %v), want (%q, %v)", tt.strGo, tt.kind, gotVal, gotEnum, tt.val, tt.enum)
+			}
+		})
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/json/bench_test.go b/vendor/google.golang.org/protobuf/internal/encoding/json/bench_test.go
new file mode 100644
index 000000000..bee85451d
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/encoding/json/bench_test.go
@@ -0,0 +1,63 @@
+// Copyright 2019 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 json_test
+
+import (
+	"testing"
+
+	"google.golang.org/protobuf/internal/encoding/json"
+)
+
+func BenchmarkFloat(b *testing.B) {
+	input := []byte(`1.797693134862315708145274237317043567981e+308`)
+	for i := 0; i < b.N; i++ {
+		dec := json.NewDecoder(input)
+		val, err := dec.Read()
+		if err != nil {
+			b.Fatal(err)
+		}
+		if _, ok := val.Float(64); !ok {
+			b.Fatal("not a flaot")
+		}
+	}
+}
+
+func BenchmarkInt(b *testing.B) {
+	input := []byte(`922337203.6854775807e+10`)
+	for i := 0; i < b.N; i++ {
+		dec := json.NewDecoder(input)
+		val, err := dec.Read()
+		if err != nil {
+			b.Fatal(err)
+		}
+		if _, ok := val.Int(64); !ok {
+			b.Fatal("not an int64")
+		}
+	}
+}
+
+func BenchmarkString(b *testing.B) {
+	input := []byte(`"abcdefghijklmnopqrstuvwxyz0123456789\\n\\t"`)
+	for i := 0; i < b.N; i++ {
+		dec := json.NewDecoder(input)
+		val, err := dec.Read()
+		if err != nil {
+			b.Fatal(err)
+		}
+		_ = val.ParsedString()
+	}
+}
+
+func BenchmarkBool(b *testing.B) {
+	input := []byte(`true`)
+	for i := 0; i < b.N; i++ {
+		dec := json.NewDecoder(input)
+		val, err := dec.Read()
+		if err != nil {
+			b.Fatal(err)
+		}
+		_ = val.Bool()
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/json/decode.go b/vendor/google.golang.org/protobuf/internal/encoding/json/decode.go
new file mode 100644
index 000000000..b13fd29e8
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/encoding/json/decode.go
@@ -0,0 +1,340 @@
+// 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 json
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"regexp"
+	"unicode/utf8"
+
+	"google.golang.org/protobuf/internal/errors"
+)
+
+// call specifies which Decoder method was invoked.
+type call uint8
+
+const (
+	readCall call = iota
+	peekCall
+)
+
+const unexpectedFmt = "unexpected token %s"
+
+// ErrUnexpectedEOF means that EOF was encountered in the middle of the input.
+var ErrUnexpectedEOF = errors.New("%v", io.ErrUnexpectedEOF)
+
+// Decoder is a token-based JSON decoder.
+type Decoder struct {
+	// lastCall is last method called, either readCall or peekCall.
+	// Initial value is readCall.
+	lastCall call
+
+	// lastToken contains the last read token.
+	lastToken Token
+
+	// lastErr contains the last read error.
+	lastErr error
+
+	// openStack is a stack containing ObjectOpen and ArrayOpen values. The
+	// top of stack represents the object or the array the current value is
+	// directly located in.
+	openStack []Kind
+
+	// orig is used in reporting line and column.
+	orig []byte
+	// in contains the unconsumed input.
+	in []byte
+}
+
+// NewDecoder returns a Decoder to read the given []byte.
+func NewDecoder(b []byte) *Decoder {
+	return &Decoder{orig: b, in: b}
+}
+
+// Peek looks ahead and returns the next token kind without advancing a read.
+func (d *Decoder) Peek() (Token, error) {
+	defer func() { d.lastCall = peekCall }()
+	if d.lastCall == readCall {
+		d.lastToken, d.lastErr = d.Read()
+	}
+	return d.lastToken, d.lastErr
+}
+
+// Read returns the next JSON token.
+// It will return an error if there is no valid token.
+func (d *Decoder) Read() (Token, error) {
+	const scalar = Null | Bool | Number | String
+
+	defer func() { d.lastCall = readCall }()
+	if d.lastCall == peekCall {
+		return d.lastToken, d.lastErr
+	}
+
+	tok, err := d.parseNext()
+	if err != nil {
+		return Token{}, err
+	}
+
+	switch tok.kind {
+	case EOF:
+		if len(d.openStack) != 0 ||
+			d.lastToken.kind&scalar|ObjectClose|ArrayClose == 0 {
+			return Token{}, ErrUnexpectedEOF
+		}
+
+	case Null:
+		if !d.isValueNext() {
+			return Token{}, d.newSyntaxError(tok.pos, unexpectedFmt, tok.RawString())
+		}
+
+	case Bool, Number:
+		if !d.isValueNext() {
+			return Token{}, d.newSyntaxError(tok.pos, unexpectedFmt, tok.RawString())
+		}
+
+	case String:
+		if d.isValueNext() {
+			break
+		}
+		// This string token should only be for a field name.
+		if d.lastToken.kind&(ObjectOpen|comma) == 0 {
+			return Token{}, d.newSyntaxError(tok.pos, unexpectedFmt, tok.RawString())
+		}
+		if len(d.in) == 0 {
+			return Token{}, ErrUnexpectedEOF
+		}
+		if c := d.in[0]; c != ':' {
+			return Token{}, d.newSyntaxError(d.currPos(), `unexpected character %s, missing ":" after field name`, string(c))
+		}
+		tok.kind = Name
+		d.consume(1)
+
+	case ObjectOpen, ArrayOpen:
+		if !d.isValueNext() {
+			return Token{}, d.newSyntaxError(tok.pos, unexpectedFmt, tok.RawString())
+		}
+		d.openStack = append(d.openStack, tok.kind)
+
+	case ObjectClose:
+		if len(d.openStack) == 0 ||
+			d.lastToken.kind == comma ||
+			d.openStack[len(d.openStack)-1] != ObjectOpen {
+			return Token{}, d.newSyntaxError(tok.pos, unexpectedFmt, tok.RawString())
+		}
+		d.openStack = d.openStack[:len(d.openStack)-1]
+
+	case ArrayClose:
+		if len(d.openStack) == 0 ||
+			d.lastToken.kind == comma ||
+			d.openStack[len(d.openStack)-1] != ArrayOpen {
+			return Token{}, d.newSyntaxError(tok.pos, unexpectedFmt, tok.RawString())
+		}
+		d.openStack = d.openStack[:len(d.openStack)-1]
+
+	case comma:
+		if len(d.openStack) == 0 ||
+			d.lastToken.kind&(scalar|ObjectClose|ArrayClose) == 0 {
+			return Token{}, d.newSyntaxError(tok.pos, unexpectedFmt, tok.RawString())
+		}
+	}
+
+	// Update d.lastToken only after validating token to be in the right sequence.
+	d.lastToken = tok
+
+	if d.lastToken.kind == comma {
+		return d.Read()
+	}
+	return tok, nil
+}
+
+// Any sequence that looks like a non-delimiter (for error reporting).
+var errRegexp = regexp.MustCompile(`^([-+._a-zA-Z0-9]{1,32}|.)`)
+
+// parseNext parses for the next JSON token. It returns a Token object for
+// different types, except for Name. It does not handle whether the next token
+// is in a valid sequence or not.
+func (d *Decoder) parseNext() (Token, error) {
+	// Trim leading spaces.
+	d.consume(0)
+
+	in := d.in
+	if len(in) == 0 {
+		return d.consumeToken(EOF, 0), nil
+	}
+
+	switch in[0] {
+	case 'n':
+		if n := matchWithDelim("null", in); n != 0 {
+			return d.consumeToken(Null, n), nil
+		}
+
+	case 't':
+		if n := matchWithDelim("true", in); n != 0 {
+			return d.consumeBoolToken(true, n), nil
+		}
+
+	case 'f':
+		if n := matchWithDelim("false", in); n != 0 {
+			return d.consumeBoolToken(false, n), nil
+		}
+
+	case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+		if n, ok := parseNumber(in); ok {
+			return d.consumeToken(Number, n), nil
+		}
+
+	case '"':
+		s, n, err := d.parseString(in)
+		if err != nil {
+			return Token{}, err
+		}
+		return d.consumeStringToken(s, n), nil
+
+	case '{':
+		return d.consumeToken(ObjectOpen, 1), nil
+
+	case '}':
+		return d.consumeToken(ObjectClose, 1), nil
+
+	case '[':
+		return d.consumeToken(ArrayOpen, 1), nil
+
+	case ']':
+		return d.consumeToken(ArrayClose, 1), nil
+
+	case ',':
+		return d.consumeToken(comma, 1), nil
+	}
+	return Token{}, d.newSyntaxError(d.currPos(), "invalid value %s", errRegexp.Find(in))
+}
+
+// newSyntaxError returns an error with line and column information useful for
+// syntax errors.
+func (d *Decoder) newSyntaxError(pos int, f string, x ...interface{}) error {
+	e := errors.New(f, x...)
+	line, column := d.Position(pos)
+	return errors.New("syntax error (line %d:%d): %v", line, column, e)
+}
+
+// Position returns line and column number of given index of the original input.
+// It will panic if index is out of range.
+func (d *Decoder) Position(idx int) (line int, column int) {
+	b := d.orig[:idx]
+	line = bytes.Count(b, []byte("\n")) + 1
+	if i := bytes.LastIndexByte(b, '\n'); i >= 0 {
+		b = b[i+1:]
+	}
+	column = utf8.RuneCount(b) + 1 // ignore multi-rune characters
+	return line, column
+}
+
+// currPos returns the current index position of d.in from d.orig.
+func (d *Decoder) currPos() int {
+	return len(d.orig) - len(d.in)
+}
+
+// matchWithDelim matches s with the input b and verifies that the match
+// terminates with a delimiter of some form (e.g., r"[^-+_.a-zA-Z0-9]").
+// As a special case, EOF is considered a delimiter. It returns the length of s
+// if there is a match, else 0.
+func matchWithDelim(s string, b []byte) int {
+	if !bytes.HasPrefix(b, []byte(s)) {
+		return 0
+	}
+
+	n := len(s)
+	if n < len(b) && isNotDelim(b[n]) {
+		return 0
+	}
+	return n
+}
+
+// isNotDelim returns true if given byte is a not delimiter character.
+func isNotDelim(c byte) bool {
+	return (c == '-' || c == '+' || c == '.' || c == '_' ||
+		('a' <= c && c <= 'z') ||
+		('A' <= c && c <= 'Z') ||
+		('0' <= c && c <= '9'))
+}
+
+// consume consumes n bytes of input and any subsequent whitespace.
+func (d *Decoder) consume(n int) {
+	d.in = d.in[n:]
+	for len(d.in) > 0 {
+		switch d.in[0] {
+		case ' ', '\n', '\r', '\t':
+			d.in = d.in[1:]
+		default:
+			return
+		}
+	}
+}
+
+// isValueNext returns true if next type should be a JSON value: Null,
+// Number, String or Bool.
+func (d *Decoder) isValueNext() bool {
+	if len(d.openStack) == 0 {
+		return d.lastToken.kind == 0
+	}
+
+	start := d.openStack[len(d.openStack)-1]
+	switch start {
+	case ObjectOpen:
+		return d.lastToken.kind&Name != 0
+	case ArrayOpen:
+		return d.lastToken.kind&(ArrayOpen|comma) != 0
+	}
+	panic(fmt.Sprintf(
+		"unreachable logic in Decoder.isValueNext, lastToken.kind: %v, openStack: %v",
+		d.lastToken.kind, start))
+}
+
+// consumeToken constructs a Token for given Kind with raw value derived from
+// current d.in and given size, and consumes the given size-lenght of it.
+func (d *Decoder) consumeToken(kind Kind, size int) Token {
+	tok := Token{
+		kind: kind,
+		raw:  d.in[:size],
+		pos:  len(d.orig) - len(d.in),
+	}
+	d.consume(size)
+	return tok
+}
+
+// consumeBoolToken constructs a Token for a Bool kind with raw value derived from
+// current d.in and given size.
+func (d *Decoder) consumeBoolToken(b bool, size int) Token {
+	tok := Token{
+		kind: Bool,
+		raw:  d.in[:size],
+		pos:  len(d.orig) - len(d.in),
+		boo:  b,
+	}
+	d.consume(size)
+	return tok
+}
+
+// consumeStringToken constructs a Token for a String kind with raw value derived
+// from current d.in and given size.
+func (d *Decoder) consumeStringToken(s string, size int) Token {
+	tok := Token{
+		kind: String,
+		raw:  d.in[:size],
+		pos:  len(d.orig) - len(d.in),
+		str:  s,
+	}
+	d.consume(size)
+	return tok
+}
+
+// Clone returns a copy of the Decoder for use in reading ahead the next JSON
+// object, array or other values without affecting current Decoder.
+func (d *Decoder) Clone() *Decoder {
+	ret := *d
+	ret.openStack = append([]Kind(nil), ret.openStack...)
+	return &ret
+}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/json/decode_number.go b/vendor/google.golang.org/protobuf/internal/encoding/json/decode_number.go
new file mode 100644
index 000000000..2999d7133
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/encoding/json/decode_number.go
@@ -0,0 +1,254 @@
+// 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 json
+
+import (
+	"bytes"
+	"strconv"
+)
+
+// parseNumber reads the given []byte for a valid JSON number. If it is valid,
+// it returns the number of bytes.  Parsing logic follows the definition in
+// https://tools.ietf.org/html/rfc7159#section-6, and is based off
+// encoding/json.isValidNumber function.
+func parseNumber(input []byte) (int, bool) {
+	var n int
+
+	s := input
+	if len(s) == 0 {
+		return 0, false
+	}
+
+	// Optional -
+	if s[0] == '-' {
+		s = s[1:]
+		n++
+		if len(s) == 0 {
+			return 0, false
+		}
+	}
+
+	// Digits
+	switch {
+	case s[0] == '0':
+		s = s[1:]
+		n++
+
+	case '1' <= s[0] && s[0] <= '9':
+		s = s[1:]
+		n++
+		for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
+			s = s[1:]
+			n++
+		}
+
+	default:
+		return 0, false
+	}
+
+	// . followed by 1 or more digits.
+	if len(s) >= 2 && s[0] == '.' && '0' <= s[1] && s[1] <= '9' {
+		s = s[2:]
+		n += 2
+		for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
+			s = s[1:]
+			n++
+		}
+	}
+
+	// e or E followed by an optional - or + and
+	// 1 or more digits.
+	if len(s) >= 2 && (s[0] == 'e' || s[0] == 'E') {
+		s = s[1:]
+		n++
+		if s[0] == '+' || s[0] == '-' {
+			s = s[1:]
+			n++
+			if len(s) == 0 {
+				return 0, false
+			}
+		}
+		for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
+			s = s[1:]
+			n++
+		}
+	}
+
+	// Check that next byte is a delimiter or it is at the end.
+	if n < len(input) && isNotDelim(input[n]) {
+		return 0, false
+	}
+
+	return n, true
+}
+
+// numberParts is the result of parsing out a valid JSON number. It contains
+// the parts of a number. The parts are used for integer conversion.
+type numberParts struct {
+	neg  bool
+	intp []byte
+	frac []byte
+	exp  []byte
+}
+
+// parseNumber constructs numberParts from given []byte. The logic here is
+// similar to consumeNumber above with the difference of having to construct
+// numberParts. The slice fields in numberParts are subslices of the input.
+func parseNumberParts(input []byte) (numberParts, bool) {
+	var neg bool
+	var intp []byte
+	var frac []byte
+	var exp []byte
+
+	s := input
+	if len(s) == 0 {
+		return numberParts{}, false
+	}
+
+	// Optional -
+	if s[0] == '-' {
+		neg = true
+		s = s[1:]
+		if len(s) == 0 {
+			return numberParts{}, false
+		}
+	}
+
+	// Digits
+	switch {
+	case s[0] == '0':
+		// Skip first 0 and no need to store.
+		s = s[1:]
+
+	case '1' <= s[0] && s[0] <= '9':
+		intp = s
+		n := 1
+		s = s[1:]
+		for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
+			s = s[1:]
+			n++
+		}
+		intp = intp[:n]
+
+	default:
+		return numberParts{}, false
+	}
+
+	// . followed by 1 or more digits.
+	if len(s) >= 2 && s[0] == '.' && '0' <= s[1] && s[1] <= '9' {
+		frac = s[1:]
+		n := 1
+		s = s[2:]
+		for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
+			s = s[1:]
+			n++
+		}
+		frac = frac[:n]
+	}
+
+	// e or E followed by an optional - or + and
+	// 1 or more digits.
+	if len(s) >= 2 && (s[0] == 'e' || s[0] == 'E') {
+		s = s[1:]
+		exp = s
+		n := 0
+		if s[0] == '+' || s[0] == '-' {
+			s = s[1:]
+			n++
+			if len(s) == 0 {
+				return numberParts{}, false
+			}
+		}
+		for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
+			s = s[1:]
+			n++
+		}
+		exp = exp[:n]
+	}
+
+	return numberParts{
+		neg:  neg,
+		intp: intp,
+		frac: bytes.TrimRight(frac, "0"), // Remove unnecessary 0s to the right.
+		exp:  exp,
+	}, true
+}
+
+// normalizeToIntString returns an integer string in normal form without the
+// E-notation for given numberParts. It will return false if it is not an
+// integer or if the exponent exceeds than max/min int value.
+func normalizeToIntString(n numberParts) (string, bool) {
+	intpSize := len(n.intp)
+	fracSize := len(n.frac)
+
+	if intpSize == 0 && fracSize == 0 {
+		return "0", true
+	}
+
+	var exp int
+	if len(n.exp) > 0 {
+		i, err := strconv.ParseInt(string(n.exp), 10, 32)
+		if err != nil {
+			return "", false
+		}
+		exp = int(i)
+	}
+
+	var num []byte
+	if exp >= 0 {
+		// For positive E, shift fraction digits into integer part and also pad
+		// with zeroes as needed.
+
+		// If there are more digits in fraction than the E value, then the
+		// number is not an integer.
+		if fracSize > exp {
+			return "", false
+		}
+
+		// Make sure resulting digits are within max value limit to avoid
+		// unnecessarily constructing a large byte slice that may simply fail
+		// later on.
+		const maxDigits = 20 // Max uint64 value has 20 decimal digits.
+		if intpSize+exp > maxDigits {
+			return "", false
+		}
+
+		// Set cap to make a copy of integer part when appended.
+		num = n.intp[:len(n.intp):len(n.intp)]
+		num = append(num, n.frac...)
+		for i := 0; i < exp-fracSize; i++ {
+			num = append(num, '0')
+		}
+	} else {
+		// For negative E, shift digits in integer part out.
+
+		// If there are fractions, then the number is not an integer.
+		if fracSize > 0 {
+			return "", false
+		}
+
+		// index is where the decimal point will be after adjusting for negative
+		// exponent.
+		index := intpSize + exp
+		if index < 0 {
+			return "", false
+		}
+
+		num = n.intp
+		// If any of the digits being shifted to the right of the decimal point
+		// is non-zero, then the number is not an integer.
+		for i := index; i < intpSize; i++ {
+			if num[i] != '0' {
+				return "", false
+			}
+		}
+		num = num[:index]
+	}
+
+	if n.neg {
+		return "-" + string(num), true
+	}
+	return string(num), true
+}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/json/decode_string.go b/vendor/google.golang.org/protobuf/internal/encoding/json/decode_string.go
new file mode 100644
index 000000000..f7fea7d8d
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/encoding/json/decode_string.go
@@ -0,0 +1,91 @@
+// 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 json
+
+import (
+	"strconv"
+	"unicode"
+	"unicode/utf16"
+	"unicode/utf8"
+
+	"google.golang.org/protobuf/internal/strs"
+)
+
+func (d *Decoder) parseString(in []byte) (string, int, error) {
+	in0 := in
+	if len(in) == 0 {
+		return "", 0, ErrUnexpectedEOF
+	}
+	if in[0] != '"' {
+		return "", 0, d.newSyntaxError(d.currPos(), "invalid character %q at start of string", in[0])
+	}
+	in = in[1:]
+	i := indexNeedEscapeInBytes(in)
+	in, out := in[i:], in[:i:i] // set cap to prevent mutations
+	for len(in) > 0 {
+		switch r, n := utf8.DecodeRune(in); {
+		case r == utf8.RuneError && n == 1:
+			return "", 0, d.newSyntaxError(d.currPos(), "invalid UTF-8 in string")
+		case r < ' ':
+			return "", 0, d.newSyntaxError(d.currPos(), "invalid character %q in string", r)
+		case r == '"':
+			in = in[1:]
+			n := len(in0) - len(in)
+			return string(out), n, nil
+		case r == '\\':
+			if len(in) < 2 {
+				return "", 0, ErrUnexpectedEOF
+			}
+			switch r := in[1]; r {
+			case '"', '\\', '/':
+				in, out = in[2:], append(out, r)
+			case 'b':
+				in, out = in[2:], append(out, '\b')
+			case 'f':
+				in, out = in[2:], append(out, '\f')
+			case 'n':
+				in, out = in[2:], append(out, '\n')
+			case 'r':
+				in, out = in[2:], append(out, '\r')
+			case 't':
+				in, out = in[2:], append(out, '\t')
+			case 'u':
+				if len(in) < 6 {
+					return "", 0, ErrUnexpectedEOF
+				}
+				v, err := strconv.ParseUint(string(in[2:6]), 16, 16)
+				if err != nil {
+					return "", 0, d.newSyntaxError(d.currPos(), "invalid escape code %q in string", in[:6])
+				}
+				in = in[6:]
+
+				r := rune(v)
+				if utf16.IsSurrogate(r) {
+					if len(in) < 6 {
+						return "", 0, ErrUnexpectedEOF
+					}
+					v, err := strconv.ParseUint(string(in[2:6]), 16, 16)
+					r = utf16.DecodeRune(r, rune(v))
+					if in[0] != '\\' || in[1] != 'u' ||
+						r == unicode.ReplacementChar || err != nil {
+						return "", 0, d.newSyntaxError(d.currPos(), "invalid escape code %q in string", in[:6])
+					}
+					in = in[6:]
+				}
+				out = append(out, string(r)...)
+			default:
+				return "", 0, d.newSyntaxError(d.currPos(), "invalid escape code %q in string", in[:2])
+			}
+		default:
+			i := indexNeedEscapeInBytes(in[n:])
+			in, out = in[n+i:], append(out, in[:n+i]...)
+		}
+	}
+	return "", 0, ErrUnexpectedEOF
+}
+
+// indexNeedEscapeInBytes returns the index of the character that needs
+// escaping. If no characters need escaping, this returns the input length.
+func indexNeedEscapeInBytes(b []byte) int { return indexNeedEscapeInString(strs.UnsafeString(b)) }
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/json/decode_test.go b/vendor/google.golang.org/protobuf/internal/encoding/json/decode_test.go
new file mode 100644
index 000000000..d70c3de0e
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/encoding/json/decode_test.go
@@ -0,0 +1,1414 @@
+// Copyright 2019 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 json_test
+
+import (
+	"fmt"
+	"math"
+	"strings"
+	"testing"
+	"unicode/utf8"
+
+	"github.com/google/go-cmp/cmp"
+
+	"google.golang.org/protobuf/internal/encoding/json"
+)
+
+type R struct {
+	// E is expected error substring from calling Decoder.Read if set.
+	E string
+	// V is one of the checker implementations that validates the token value.
+	V checker
+	// P is expected Token.Pos() if set > 0.
+	P int
+	// RS is expected result from Token.RawString() if not empty.
+	RS string
+}
+
+// checker defines API for Token validation.
+type checker interface {
+	// check checks and expects for token API call to return and compare
+	// against implementation-stored value. Returns empty string if success,
+	// else returns error message describing the error.
+	check(json.Token) string
+}
+
+// checkers that checks the token kind only.
+var (
+	EOF         = kindOnly{json.EOF}
+	Null        = kindOnly{json.Null}
+	ObjectOpen  = kindOnly{json.ObjectOpen}
+	ObjectClose = kindOnly{json.ObjectClose}
+	ArrayOpen   = kindOnly{json.ArrayOpen}
+	ArrayClose  = kindOnly{json.ArrayClose}
+)
+
+type kindOnly struct {
+	want json.Kind
+}
+
+func (x kindOnly) check(tok json.Token) string {
+	if got := tok.Kind(); got != x.want {
+		return fmt.Sprintf("Token.Kind(): got %v, want %v", got, x.want)
+	}
+	return ""
+}
+
+type Name struct {
+	val string
+}
+
+func (x Name) check(tok json.Token) string {
+	if got := tok.Kind(); got != json.Name {
+		return fmt.Sprintf("Token.Kind(): got %v, want %v", got, json.Name)
+	}
+
+	if got := tok.Name(); got != x.val {
+		return fmt.Sprintf("Token.Name(): got %v, want %v", got, x.val)
+	}
+	return ""
+}
+
+type Bool struct {
+	val bool
+}
+
+func (x Bool) check(tok json.Token) string {
+	if got := tok.Kind(); got != json.Bool {
+		return fmt.Sprintf("Token.Kind(): got %v, want %v", got, json.Bool)
+	}
+
+	if got := tok.Bool(); got != x.val {
+		return fmt.Sprintf("Token.Bool(): got %v, want %v", got, x.val)
+	}
+	return ""
+}
+
+type Str struct {
+	val string
+}
+
+func (x Str) check(tok json.Token) string {
+	if got := tok.Kind(); got != json.String {
+		return fmt.Sprintf("Token.Kind(): got %v, want %v", got, json.String)
+	}
+
+	if got := tok.ParsedString(); got != x.val {
+		return fmt.Sprintf("Token.ParsedString(): got %v, want %v", got, x.val)
+	}
+	return ""
+}
+
+type F64 struct {
+	val float64
+}
+
+func (x F64) check(tok json.Token) string {
+	if got := tok.Kind(); got != json.Number {
+		return fmt.Sprintf("Token.Kind(): got %v, want %v", got, json.Number)
+	}
+
+	got, ok := tok.Float(64)
+	if !ok {
+		return fmt.Sprintf("Token.Float(64): returned not ok")
+	}
+	if got != x.val {
+		return fmt.Sprintf("Token.Float(64): got %v, want %v", got, x.val)
+	}
+	return ""
+}
+
+type F32 struct {
+	val float32
+}
+
+func (x F32) check(tok json.Token) string {
+	if got := tok.Kind(); got != json.Number {
+		return fmt.Sprintf("Token.Kind(): got %v, want %v", got, json.Number)
+	}
+
+	got, ok := tok.Float(32)
+	if !ok {
+		return fmt.Sprintf("Token.Float(32): returned not ok")
+	}
+	if float32(got) != x.val {
+		return fmt.Sprintf("Token.Float(32): got %v, want %v", got, x.val)
+	}
+	return ""
+}
+
+// NotF64 is a checker to validate a Number token where Token.Float(64) returns not ok.
+var NotF64 = xf64{}
+
+type xf64 struct{}
+
+func (x xf64) check(tok json.Token) string {
+	if got := tok.Kind(); got != json.Number {
+		return fmt.Sprintf("Token.Kind(): got %v, want %v", got, json.Number)
+	}
+
+	_, ok := tok.Float(64)
+	if ok {
+		return fmt.Sprintf("Token.Float(64): returned ok")
+	}
+	return ""
+}
+
+// NotF32 is a checker to validate a Number token where Token.Float(32) returns not ok.
+var NotF32 = xf32{}
+
+type xf32 struct{}
+
+func (x xf32) check(tok json.Token) string {
+	if got := tok.Kind(); got != json.Number {
+		return fmt.Sprintf("Token.Kind(): got %v, want %v", got, json.Number)
+	}
+
+	_, ok := tok.Float(32)
+	if ok {
+		return fmt.Sprintf("Token.Float(32): returned ok")
+	}
+	return ""
+}
+
+type I64 struct {
+	val int64
+}
+
+func (x I64) check(tok json.Token) string {
+	if got := tok.Kind(); got != json.Number {
+		return fmt.Sprintf("Token.Kind(): got %v, want %v", got, json.Number)
+	}
+
+	got, ok := tok.Int(64)
+	if !ok {
+		return fmt.Sprintf("Token.Int(64): returned not ok")
+	}
+	if got != x.val {
+		return fmt.Sprintf("Token.Int(64): got %v, want %v", got, x.val)
+	}
+	return ""
+}
+
+type I32 struct {
+	val int32
+}
+
+func (x I32) check(tok json.Token) string {
+	if got := tok.Kind(); got != json.Number {
+		return fmt.Sprintf("Token.Kind(): got %v, want %v", got, json.Number)
+	}
+
+	got, ok := tok.Int(32)
+	if !ok {
+		return fmt.Sprintf("Token.Int(32): returned not ok")
+	}
+	if int32(got) != x.val {
+		return fmt.Sprintf("Token.Int(32): got %v, want %v", got, x.val)
+	}
+	return ""
+}
+
+// NotI64 is a checker to validate a Number token where Token.Int(64) returns not ok.
+var NotI64 = xi64{}
+
+type xi64 struct{}
+
+func (x xi64) check(tok json.Token) string {
+	if got := tok.Kind(); got != json.Number {
+		return fmt.Sprintf("Token.Kind(): got %v, want %v", got, json.Number)
+	}
+
+	_, ok := tok.Int(64)
+	if ok {
+		return fmt.Sprintf("Token.Int(64): returned ok")
+	}
+	return ""
+}
+
+// NotI32 is a checker to validate a Number token where Token.Int(32) returns not ok.
+var NotI32 = xi32{}
+
+type xi32 struct{}
+
+func (x xi32) check(tok json.Token) string {
+	if got := tok.Kind(); got != json.Number {
+		return fmt.Sprintf("Token.Kind(): got %v, want %v", got, json.Number)
+	}
+
+	_, ok := tok.Int(32)
+	if ok {
+		return fmt.Sprintf("Token.Int(32): returned ok")
+	}
+	return ""
+}
+
+type Ui64 struct {
+	val uint64
+}
+
+func (x Ui64) check(tok json.Token) string {
+	if got := tok.Kind(); got != json.Number {
+		return fmt.Sprintf("Token.Kind(): got %v, want %v", got, json.Number)
+	}
+
+	got, ok := tok.Uint(64)
+	if !ok {
+		return fmt.Sprintf("Token.Uint(64): returned not ok")
+	}
+	if got != x.val {
+		return fmt.Sprintf("Token.Uint(64): got %v, want %v", got, x.val)
+	}
+	return ""
+}
+
+type Ui32 struct {
+	val uint32
+}
+
+func (x Ui32) check(tok json.Token) string {
+	if got := tok.Kind(); got != json.Number {
+		return fmt.Sprintf("Token.Kind(): got %v, want %v", got, json.Number)
+	}
+
+	got, ok := tok.Uint(32)
+	if !ok {
+		return fmt.Sprintf("Token.Uint(32): returned not ok")
+	}
+	if uint32(got) != x.val {
+		return fmt.Sprintf("Token.Uint(32): got %v, want %v", got, x.val)
+	}
+	return ""
+}
+
+// NotUi64 is a checker to validate a Number token where Token.Uint(64) returns not ok.
+var NotUi64 = xui64{}
+
+type xui64 struct{}
+
+func (x xui64) check(tok json.Token) string {
+	if got := tok.Kind(); got != json.Number {
+		return fmt.Sprintf("Token.Kind(): got %v, want %v", got, json.Number)
+	}
+
+	_, ok := tok.Uint(64)
+	if ok {
+		return fmt.Sprintf("Token.Uint(64): returned ok")
+	}
+	return ""
+}
+
+// NotI32 is a checker to validate a Number token where Token.Uint(32) returns not ok.
+var NotUi32 = xui32{}
+
+type xui32 struct{}
+
+func (x xui32) check(tok json.Token) string {
+	if got := tok.Kind(); got != json.Number {
+		return fmt.Sprintf("Token.Kind(): got %v, want %v", got, json.Number)
+	}
+
+	_, ok := tok.Uint(32)
+	if ok {
+		return fmt.Sprintf("Token.Uint(32): returned ok")
+	}
+	return ""
+}
+
+var errEOF = json.ErrUnexpectedEOF.Error()
+
+func TestDecoder(t *testing.T) {
+	const space = " \n\r\t"
+
+	tests := []struct {
+		in string
+		// want is a list of expected values returned from calling
+		// Decoder.Read. An item makes the test code invoke
+		// Decoder.Read and compare against R.E for error returned or use R.V to
+		// validate the returned Token object.
+		want []R
+	}{
+		{
+			in:   ``,
+			want: []R{{V: EOF}},
+		},
+		{
+			in:   space,
+			want: []R{{V: EOF}},
+		},
+		{
+			// Calling Read after EOF will keep returning EOF for
+			// succeeding Read calls.
+			in: space,
+			want: []R{
+				{V: EOF},
+				{V: EOF},
+				{V: EOF},
+			},
+		},
+
+		// JSON literals.
+		{
+			in: space + `null` + space,
+			want: []R{
+				{V: Null, P: len(space), RS: `null`},
+				{V: EOF},
+			},
+		},
+		{
+			in: space + `true` + space,
+			want: []R{
+				{V: Bool{true}},
+				{V: EOF},
+			},
+		},
+		{
+			in: space + `false` + space,
+			want: []R{
+				{V: Bool{false}},
+				{V: EOF},
+			},
+		},
+		{
+			// Error returned will produce the same error again.
+			in: space + `foo` + space,
+			want: []R{
+				{E: `invalid value foo`},
+				{E: `invalid value foo`},
+			},
+		},
+
+		// JSON strings.
+		{
+			in: space + `""` + space,
+			want: []R{
+				{V: Str{}},
+				{V: EOF},
+			},
+		},
+		{
+			in: space + `"hello"` + space,
+			want: []R{
+				{V: Str{"hello"}, RS: `"hello"`},
+				{V: EOF},
+			},
+		},
+		{
+			in:   `"hello`,
+			want: []R{{E: errEOF}},
+		},
+		{
+			in:   "\"\x00\"",
+			want: []R{{E: `invalid character '\x00' in string`}},
+		},
+		{
+			in: "\"\u0031\u0032\"",
+			want: []R{
+				{V: Str{"12"}, RS: "\"\u0031\u0032\""},
+				{V: EOF},
+			},
+		},
+		{
+			// Invalid UTF-8 error is returned in ReadString instead of Read.
+			in:   "\"\xff\"",
+			want: []R{{E: `syntax error (line 1:1): invalid UTF-8 in string`}},
+		},
+		{
+			in: `"` + string(utf8.RuneError) + `"`,
+			want: []R{
+				{V: Str{string(utf8.RuneError)}},
+				{V: EOF},
+			},
+		},
+		{
+			in: `"\uFFFD"`,
+			want: []R{
+				{V: Str{string(utf8.RuneError)}},
+				{V: EOF},
+			},
+		},
+		{
+			in:   `"\x"`,
+			want: []R{{E: `invalid escape code "\\x" in string`}},
+		},
+		{
+			in:   `"\uXXXX"`,
+			want: []R{{E: `invalid escape code "\\uXXXX" in string`}},
+		},
+		{
+			in:   `"\uDEAD"`, // unmatched surrogate pair
+			want: []R{{E: errEOF}},
+		},
+		{
+			in:   `"\uDEAD\uBEEF"`, // invalid surrogate half
+			want: []R{{E: `invalid escape code "\\uBEEF" in string`}},
+		},
+		{
+			in: `"\uD800\udead"`, // valid surrogate pair
+			want: []R{
+				{V: Str{`𐊭`}},
+				{V: EOF},
+			},
+		},
+		{
+			in: `"\u0000\"\\\/\b\f\n\r\t"`,
+			want: []R{
+				{V: Str{"\u0000\"\\/\b\f\n\r\t"}},
+				{V: EOF},
+			},
+		},
+
+		// Invalid JSON numbers.
+		{
+			in:   `-`,
+			want: []R{{E: `invalid value -`}},
+		},
+		{
+			in:   `+0`,
+			want: []R{{E: `invalid value +0`}},
+		},
+		{
+			in:   `-+`,
+			want: []R{{E: `invalid value -+`}},
+		},
+		{
+			in:   `0.`,
+			want: []R{{E: `invalid value 0.`}},
+		},
+		{
+			in:   `.1`,
+			want: []R{{E: `invalid value .1`}},
+		},
+		{
+			in:   `1.0.1`,
+			want: []R{{E: `invalid value 1.0.1`}},
+		},
+		{
+			in:   `1..1`,
+			want: []R{{E: `invalid value 1..1`}},
+		},
+		{
+			in:   `-1-2`,
+			want: []R{{E: `invalid value -1-2`}},
+		},
+		{
+			in:   `01`,
+			want: []R{{E: `invalid value 01`}},
+		},
+		{
+			in:   `1e`,
+			want: []R{{E: `invalid value 1e`}},
+		},
+		{
+			in:   `1e1.2`,
+			want: []R{{E: `invalid value 1e1.2`}},
+		},
+		{
+			in:   `1Ee`,
+			want: []R{{E: `invalid value 1Ee`}},
+		},
+		{
+			in:   `1.e1`,
+			want: []R{{E: `invalid value 1.e1`}},
+		},
+		{
+			in:   `1.e+`,
+			want: []R{{E: `invalid value 1.e+`}},
+		},
+		{
+			in:   `1e+-2`,
+			want: []R{{E: `invalid value 1e+-2`}},
+		},
+		{
+			in:   `1e--2`,
+			want: []R{{E: `invalid value 1e--2`}},
+		},
+		{
+			in:   `1.0true`,
+			want: []R{{E: `invalid value 1.0true`}},
+		},
+
+		// JSON numbers as floating point.
+		{
+			in: space + `0.0` + space,
+			want: []R{
+				{V: F32{0}, P: len(space), RS: `0.0`},
+				{V: EOF},
+			},
+		},
+		{
+			in: space + `0` + space,
+			want: []R{
+				{V: F32{0}},
+				{V: EOF},
+			},
+		},
+		{
+			in: space + `-0` + space,
+			want: []R{
+				{V: F32{float32(math.Copysign(0, -1))}},
+				{V: EOF},
+			},
+		},
+		{
+			in: `-0`,
+			want: []R{
+				{V: F64{math.Copysign(0, -1)}},
+				{V: EOF},
+			},
+		},
+		{
+			in: `-0.0`,
+			want: []R{
+				{V: F32{float32(math.Copysign(0, -1))}},
+				{V: EOF},
+			},
+		},
+		{
+			in: `-0.0`,
+			want: []R{
+				{V: F64{math.Copysign(0, -1)}},
+				{V: EOF},
+			},
+		},
+		{
+			in: `-1.02`,
+			want: []R{
+				{V: F32{-1.02}},
+				{V: EOF},
+			},
+		},
+		{
+			in: `1.020000`,
+			want: []R{
+				{V: F32{1.02}},
+				{V: EOF},
+			},
+		},
+		{
+			in: `-1.0e0`,
+			want: []R{
+				{V: F32{-1}},
+				{V: EOF},
+			},
+		},
+		{
+			in: `1.0e-000`,
+			want: []R{
+				{V: F32{1}},
+				{V: EOF},
+			},
+		},
+		{
+			in: `1e+00`,
+			want: []R{
+				{V: F32{1}},
+				{V: EOF},
+			},
+		},
+		{
+			in: `1.02e3`,
+			want: []R{
+				{V: F32{1.02e3}},
+				{V: EOF},
+			},
+		},
+		{
+			in: `-1.02E03`,
+			want: []R{
+				{V: F32{-1.02e3}},
+				{V: EOF},
+			},
+		},
+		{
+			in: `1.0200e+3`,
+			want: []R{
+				{V: F32{1.02e3}},
+				{V: EOF},
+			},
+		},
+		{
+			in: `-1.0200E+03`,
+			want: []R{
+				{V: F32{-1.02e3}},
+				{V: EOF},
+			},
+		},
+		{
+			in: `1.0200e-3`,
+			want: []R{
+				{V: F32{1.02e-3}},
+				{V: EOF},
+			},
+		},
+		{
+			in: `-1.0200E-03`,
+			want: []R{
+				{V: F32{-1.02e-3}},
+				{V: EOF},
+			},
+		},
+		{
+			// Exceeds max float32 limit, but should be ok for float64.
+			in: `3.4e39`,
+			want: []R{
+				{V: F64{3.4e39}},
+				{V: EOF},
+			},
+		},
+
+		{
+			// Exceeds max float32 limit.
+			in: `3.4e39`,
+			want: []R{
+				{V: NotF32},
+				{V: EOF},
+			},
+		},
+		{
+			// Less than negative max float32 limit.
+			in: `-3.4e39`,
+			want: []R{
+				{V: NotF32},
+				{V: EOF},
+			},
+		},
+		{
+			// Exceeds max float64 limit.
+			in: `1.79e+309`,
+			want: []R{
+				{V: NotF64},
+				{V: EOF},
+			},
+		},
+		{
+			// Less than negative max float64 limit.
+			in: `-1.79e+309`,
+			want: []R{
+				{V: NotF64},
+				{V: EOF},
+			},
+		},
+
+		// JSON numbers as signed integers.
+		{
+			in: space + `0` + space,
+			want: []R{
+				{V: I32{0}},
+				{V: EOF},
+			},
+		},
+		{
+			in: space + `-0` + space,
+			want: []R{
+				{V: I32{0}},
+				{V: EOF},
+			},
+		},
+		{
+			// Fractional part equals 0 is ok.
+			in: `1.00000`,
+			want: []R{
+				{V: I32{1}},
+				{V: EOF},
+			},
+		},
+		{
+			// Fractional part not equals 0 returns error.
+			in: `1.0000000001`,
+			want: []R{
+				{V: NotI32},
+				{V: EOF},
+			},
+		},
+		{
+			in: `0e0`,
+			want: []R{
+				{V: I32{0}},
+				{V: EOF},
+			},
+		},
+		{
+			in: `0.0E0`,
+			want: []R{
+				{V: I32{0}},
+				{V: EOF},
+			},
+		},
+		{
+			in: `0.0E10`,
+			want: []R{
+				{V: I32{0}},
+				{V: EOF},
+			},
+		},
+		{
+			in: `-1`,
+			want: []R{
+				{V: I32{-1}},
+				{V: EOF},
+			},
+		},
+		{
+			in: `1.0e+0`,
+			want: []R{
+				{V: I32{1}},
+				{V: EOF},
+			},
+		},
+		{
+			in: `-1E-0`,
+			want: []R{
+				{V: I32{-1}},
+				{V: EOF},
+			},
+		},
+		{
+			in: `1E1`,
+			want: []R{
+				{V: I32{10}},
+				{V: EOF},
+			},
+		},
+		{
+			in: `-100.00e-02`,
+			want: []R{
+				{V: I32{-1}},
+				{V: EOF},
+			},
+		},
+		{
+			in: `0.1200E+02`,
+			want: []R{
+				{V: I64{12}},
+				{V: EOF},
+			},
+		},
+		{
+			in: `0.012e2`,
+			want: []R{
+				{V: NotI32},
+				{V: EOF},
+			},
+		},
+		{
+			in: `12e-2`,
+			want: []R{
+				{V: NotI32},
+				{V: EOF},
+			},
+		},
+		{
+			// Exceeds math.MaxInt32.
+			in: `2147483648`,
+			want: []R{
+				{V: NotI32},
+				{V: EOF},
+			},
+		},
+		{
+			// Exceeds math.MinInt32.
+			in: `-2147483649`,
+			want: []R{
+				{V: NotI32},
+				{V: EOF},
+			},
+		},
+		{
+			// Exceeds math.MaxInt32, but ok for int64.
+			in: `2147483648`,
+			want: []R{
+				{V: I64{2147483648}},
+				{V: EOF},
+			},
+		},
+		{
+			// Exceeds math.MinInt32, but ok for int64.
+			in: `-2147483649`,
+			want: []R{
+				{V: I64{-2147483649}},
+				{V: EOF},
+			},
+		},
+		{
+			// Exceeds math.MaxInt64.
+			in: `9223372036854775808`,
+			want: []R{
+				{V: NotI64},
+				{V: EOF},
+			},
+		},
+		{
+			// Exceeds math.MinInt64.
+			in: `-9223372036854775809`,
+			want: []R{
+				{V: NotI64},
+				{V: EOF},
+			},
+		},
+
+		// JSON numbers as unsigned integers.
+		{
+			in: space + `0` + space,
+			want: []R{
+				{V: Ui32{0}},
+				{V: EOF},
+			},
+		},
+		{
+			in: space + `-0` + space,
+			want: []R{
+				{V: Ui32{0}},
+				{V: EOF},
+			},
+		},
+		{
+			in: `-1`,
+			want: []R{
+				{V: NotUi32},
+				{V: EOF},
+			},
+		},
+		{
+			// Exceeds math.MaxUint32.
+			in: `4294967296`,
+			want: []R{
+				{V: NotUi32},
+				{V: EOF},
+			},
+		},
+		{
+			// Exceeds math.MaxUint64.
+			in: `18446744073709551616`,
+			want: []R{
+				{V: NotUi64},
+				{V: EOF},
+			},
+		},
+
+		// JSON sequence of values.
+		{
+			in: `true null`,
+			want: []R{
+				{V: Bool{true}},
+				{E: `(line 1:6): unexpected token null`},
+			},
+		},
+		{
+			in: "null false",
+			want: []R{
+				{V: Null},
+				{E: `unexpected token false`},
+			},
+		},
+		{
+			in: `true,false`,
+			want: []R{
+				{V: Bool{true}},
+				{E: `unexpected token ,`},
+			},
+		},
+		{
+			in: `47"hello"`,
+			want: []R{
+				{V: I32{47}},
+				{E: `unexpected token "hello"`},
+			},
+		},
+		{
+			in: `47 "hello"`,
+			want: []R{
+				{V: I32{47}},
+				{E: `unexpected token "hello"`},
+			},
+		},
+		{
+			in: `true 42`,
+			want: []R{
+				{V: Bool{true}},
+				{E: `unexpected token 42`},
+			},
+		},
+
+		// JSON arrays.
+		{
+			in: space + `[]` + space,
+			want: []R{
+				{V: ArrayOpen},
+				{V: ArrayClose},
+				{V: EOF},
+			},
+		},
+		{
+			in: space + `[` + space + `]` + space,
+			want: []R{
+				{V: ArrayOpen, P: len(space), RS: `[`},
+				{V: ArrayClose},
+				{V: EOF},
+			},
+		},
+		{
+			in: space + `[` + space,
+			want: []R{
+				{V: ArrayOpen},
+				{E: errEOF},
+			},
+		},
+		{
+			in:   space + `]` + space,
+			want: []R{{E: `unexpected token ]`}},
+		},
+		{
+			in: `[null,true,false,  1e1, "hello"   ]`,
+			want: []R{
+				{V: ArrayOpen},
+				{V: Null},
+				{V: Bool{true}},
+				{V: Bool{false}},
+				{V: I32{10}},
+				{V: Str{"hello"}},
+				{V: ArrayClose},
+				{V: EOF},
+			},
+		},
+		{
+			in: `[` + space + `true` + space + `,` + space + `"hello"` + space + `]`,
+			want: []R{
+				{V: ArrayOpen},
+				{V: Bool{true}},
+				{V: Str{"hello"}},
+				{V: ArrayClose},
+				{V: EOF},
+			},
+		},
+		{
+			in: `[` + space + `true` + space + `,` + space + `]`,
+			want: []R{
+				{V: ArrayOpen},
+				{V: Bool{true}},
+				{E: `unexpected token ]`},
+			},
+		},
+		{
+			in: `[` + space + `false` + space + `]`,
+			want: []R{
+				{V: ArrayOpen},
+				{V: Bool{false}},
+				{V: ArrayClose},
+				{V: EOF},
+			},
+		},
+		{
+			in: `[` + space + `1` + space + `0` + space + `]`,
+			want: []R{
+				{V: ArrayOpen},
+				{V: I64{1}},
+				{E: `unexpected token 0`},
+			},
+		},
+		{
+			in: `[null`,
+			want: []R{
+				{V: ArrayOpen},
+				{V: Null},
+				{E: errEOF},
+			},
+		},
+		{
+			in: `[foo]`,
+			want: []R{
+				{V: ArrayOpen},
+				{E: `invalid value foo`},
+			},
+		},
+		{
+			in: `[{}, "hello", [true, false], null]`,
+			want: []R{
+				{V: ArrayOpen},
+				{V: ObjectOpen},
+				{V: ObjectClose},
+				{V: Str{"hello"}},
+				{V: ArrayOpen},
+				{V: Bool{true}},
+				{V: Bool{false}},
+				{V: ArrayClose},
+				{V: Null},
+				{V: ArrayClose},
+				{V: EOF},
+			},
+		},
+		{
+			in: `[{ ]`,
+			want: []R{
+				{V: ArrayOpen},
+				{V: ObjectOpen},
+				{E: `unexpected token ]`},
+			},
+		},
+		{
+			in: `[[ ]`,
+			want: []R{
+				{V: ArrayOpen},
+				{V: ArrayOpen},
+				{V: ArrayClose},
+				{E: errEOF},
+			},
+		},
+		{
+			in: `[,]`,
+			want: []R{
+				{V: ArrayOpen},
+				{E: `unexpected token ,`},
+			},
+		},
+		{
+			in: `[true "hello"]`,
+			want: []R{
+				{V: ArrayOpen},
+				{V: Bool{true}},
+				{E: `unexpected token "hello"`},
+			},
+		},
+		{
+			in: `[] null`,
+			want: []R{
+				{V: ArrayOpen},
+				{V: ArrayClose},
+				{E: `unexpected token null`},
+			},
+		},
+		{
+			in: `true []`,
+			want: []R{
+				{V: Bool{true}},
+				{E: `unexpected token [`},
+			},
+		},
+
+		// JSON objects.
+		{
+			in: space + `{}` + space,
+			want: []R{
+				{V: ObjectOpen},
+				{V: ObjectClose},
+				{V: EOF},
+			},
+		},
+		{
+			in: space + `{` + space + `}` + space,
+			want: []R{
+				{V: ObjectOpen},
+				{V: ObjectClose},
+				{V: EOF},
+			},
+		},
+		{
+			in: space + `{` + space,
+			want: []R{
+				{V: ObjectOpen},
+				{E: errEOF},
+			},
+		},
+		{
+			in:   space + `}` + space,
+			want: []R{{E: `unexpected token }`}},
+		},
+		{
+			in: `{` + space + `null` + space + `}`,
+			want: []R{
+				{V: ObjectOpen},
+				{E: `unexpected token null`},
+			},
+		},
+		{
+			in: `{[]}`,
+			want: []R{
+				{V: ObjectOpen},
+				{E: `(line 1:2): unexpected token [`},
+			},
+		},
+		{
+			in: `{,}`,
+			want: []R{
+				{V: ObjectOpen},
+				{E: `unexpected token ,`},
+			},
+		},
+		{
+			in: `{"345678"}`,
+			want: []R{
+				{V: ObjectOpen},
+				{E: `(line 1:10): unexpected character }, missing ":" after field name`},
+			},
+		},
+		{
+			in: `{` + space + `"hello"` + space + `:` + space + `"world"` + space + `}`,
+			want: []R{
+				{V: ObjectOpen},
+				{V: Name{"hello"}, P: len(space) + 1, RS: `"hello"`},
+				{V: Str{"world"}, RS: `"world"`},
+				{V: ObjectClose},
+				{V: EOF},
+			},
+		},
+		{
+			in: `{"hello" "world"}`,
+			want: []R{
+				{V: ObjectOpen},
+				{E: `(line 1:10): unexpected character ", missing ":" after field name`},
+			},
+		},
+		{
+			in: `{"hello":`,
+			want: []R{
+				{V: ObjectOpen},
+				{V: Name{"hello"}},
+				{E: errEOF},
+			},
+		},
+		{
+			in: `{"hello":"world"`,
+			want: []R{
+				{V: ObjectOpen},
+				{V: Name{"hello"}},
+				{V: Str{"world"}},
+				{E: errEOF},
+			},
+		},
+		{
+			in: `{"hello":"world",`,
+			want: []R{
+				{V: ObjectOpen},
+				{V: Name{"hello"}},
+				{V: Str{"world"}},
+				{E: errEOF},
+			},
+		},
+		{
+			in: `{""`,
+			want: []R{
+				{V: ObjectOpen},
+				{E: errEOF},
+			},
+		},
+		{
+			in: `{"34":"89",}`,
+			want: []R{
+				{V: ObjectOpen},
+				{V: Name{"34"}, RS: `"34"`},
+				{V: Str{"89"}},
+				{E: `syntax error (line 1:12): unexpected token }`},
+			},
+		},
+		{
+			in: `{
+			  "number": 123e2,
+			  "bool"  : false,
+			  "object": {"string": "world"},
+			  "null"  : null,
+			  "array" : [1.01, "hello", true],
+			  "string": "hello"
+			}`,
+			want: []R{
+				{V: ObjectOpen},
+
+				{V: Name{"number"}},
+				{V: I32{12300}},
+
+				{V: Name{"bool"}},
+				{V: Bool{false}},
+
+				{V: Name{"object"}},
+				{V: ObjectOpen},
+				{V: Name{"string"}},
+				{V: Str{"world"}},
+				{V: ObjectClose},
+
+				{V: Name{"null"}},
+				{V: Null},
+
+				{V: Name{"array"}},
+				{V: ArrayOpen},
+				{V: F32{1.01}},
+				{V: Str{"hello"}},
+				{V: Bool{true}},
+				{V: ArrayClose},
+
+				{V: Name{"string"}},
+				{V: Str{"hello"}},
+
+				{V: ObjectClose},
+				{V: EOF},
+			},
+		},
+		{
+			in: `[
+			  {"object": {"number": 47}},
+			  ["list"],
+			  null
+			]`,
+			want: []R{
+				{V: ArrayOpen},
+
+				{V: ObjectOpen},
+				{V: Name{"object"}},
+				{V: ObjectOpen},
+				{V: Name{"number"}},
+				{V: I32{47}},
+				{V: ObjectClose},
+				{V: ObjectClose},
+
+				{V: ArrayOpen},
+				{V: Str{"list"}},
+				{V: ArrayClose},
+
+				{V: Null},
+
+				{V: ArrayClose},
+				{V: EOF},
+			},
+		},
+
+		// Tests for line and column info.
+		{
+			in: `12345678 x`,
+			want: []R{
+				{V: I64{12345678}},
+				{E: `syntax error (line 1:10): invalid value x`},
+			},
+		},
+		{
+			in: "\ntrue\n   x",
+			want: []R{
+				{V: Bool{true}},
+				{E: `syntax error (line 3:4): invalid value x`},
+			},
+		},
+		{
+			in: `"💩"x`,
+			want: []R{
+				{V: Str{"💩"}},
+				{E: `syntax error (line 1:4): invalid value x`},
+			},
+		},
+		{
+			in: "\n\n[\"🔥🔥🔥\"x",
+			want: []R{
+				{V: ArrayOpen},
+				{V: Str{"🔥🔥🔥"}},
+				{E: `syntax error (line 3:7): invalid value x`},
+			},
+		},
+		{
+			// Multi-rune emojis.
+			in: `["👍🏻👍🏿"x`,
+			want: []R{
+				{V: ArrayOpen},
+				{V: Str{"👍🏻👍🏿"}},
+				{E: `syntax error (line 1:8): invalid value x`},
+			},
+		},
+	}
+
+	for _, tc := range tests {
+		tc := tc
+		t.Run("", func(t *testing.T) {
+			dec := json.NewDecoder([]byte(tc.in))
+			for i, want := range tc.want {
+				peekTok, peekErr := dec.Peek()
+				tok, err := dec.Read()
+				if err != nil {
+					if want.E == "" {
+						errorf(t, tc.in, "want#%d: Read() got unexpected error: %v", i, err)
+					} else if !strings.Contains(err.Error(), want.E) {
+						errorf(t, tc.in, "want#%d: Read() got %q, want %q", i, err, want.E)
+					}
+					return
+				}
+				if want.E != "" {
+					errorf(t, tc.in, "want#%d: Read() got nil error, want %q", i, want.E)
+					return
+				}
+				checkToken(t, tok, i, want, tc.in)
+				if !cmp.Equal(tok, peekTok, cmp.Comparer(json.TokenEquals)) {
+					errorf(t, tc.in, "want#%d: Peek() %+v != Read() token %+v", i, peekTok, tok)
+				}
+				if err != peekErr {
+					errorf(t, tc.in, "want#%d: Peek() error %v != Read() error %v", i, err, peekErr)
+				}
+			}
+		})
+	}
+}
+
+func checkToken(t *testing.T, tok json.Token, idx int, r R, in string) {
+	// Validate Token.Pos() if R.P is set.
+	if r.P > 0 {
+		got := tok.Pos()
+		if got != r.P {
+			errorf(t, in, "want#%d: Token.Pos() got %v want %v", idx, got, r.P)
+		}
+	}
+	// Validate Token.RawString if R.RS is set.
+	if len(r.RS) > 0 {
+		got := tok.RawString()
+		if got != r.RS {
+			errorf(t, in, "want#%d: Token.RawString() got %v want %v", idx, got, r.P)
+		}
+	}
+
+	// Skip checking for Token details if r.V is not set.
+	if r.V == nil {
+		return
+	}
+
+	if err := r.V.check(tok); err != "" {
+		errorf(t, in, "want#%d: %s", idx, err)
+	}
+	return
+}
+
+func errorf(t *testing.T, in string, fmtStr string, args ...interface{}) {
+	t.Helper()
+	vargs := []interface{}{in}
+	for _, arg := range args {
+		vargs = append(vargs, arg)
+	}
+	t.Errorf("input:\n%s\n~end~\n"+fmtStr, vargs...)
+}
+
+func TestClone(t *testing.T) {
+	input := `{"outer":{"str":"hello", "number": 123}}`
+	dec := json.NewDecoder([]byte(input))
+
+	// Clone at the start should produce the same reads as the original.
+	clone := dec.Clone()
+	compareDecoders(t, dec, clone)
+
+	// Advance to inner object, clone and compare again.
+	dec.Read() // Read ObjectOpen.
+	dec.Read() // Read Name.
+	clone = dec.Clone()
+	compareDecoders(t, dec, clone)
+}
+
+func compareDecoders(t *testing.T, d1 *json.Decoder, d2 *json.Decoder) {
+	for {
+		tok1, err1 := d1.Read()
+		tok2, err2 := d2.Read()
+		if tok1.Kind() != tok2.Kind() {
+			t.Errorf("cloned decoder: got Kind %v, want %v", tok2.Kind(), tok1.Kind())
+		}
+		if tok1.RawString() != tok2.RawString() {
+			t.Errorf("cloned decoder: got RawString %v, want %v", tok2.RawString(), tok1.RawString())
+		}
+		if err1 != err2 {
+			t.Errorf("cloned decoder: got error %v, want %v", err2, err1)
+		}
+		if tok1.Kind() == json.EOF {
+			break
+		}
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/json/decode_token.go b/vendor/google.golang.org/protobuf/internal/encoding/json/decode_token.go
new file mode 100644
index 000000000..2eb7023b2
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/encoding/json/decode_token.go
@@ -0,0 +1,193 @@
+// Copyright 2019 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 json
+
+import (
+	"bytes"
+	"fmt"
+	"strconv"
+)
+
+// Kind represents a token kind expressible in the JSON format.
+type Kind uint16
+
+const (
+	Invalid Kind = (1 << iota) / 2
+	EOF
+	Null
+	Bool
+	Number
+	String
+	Name
+	ObjectOpen
+	ObjectClose
+	ArrayOpen
+	ArrayClose
+
+	// comma is only for parsing in between tokens and
+	// does not need to be exported.
+	comma
+)
+
+func (k Kind) String() string {
+	switch k {
+	case EOF:
+		return "eof"
+	case Null:
+		return "null"
+	case Bool:
+		return "bool"
+	case Number:
+		return "number"
+	case String:
+		return "string"
+	case ObjectOpen:
+		return "{"
+	case ObjectClose:
+		return "}"
+	case Name:
+		return "name"
+	case ArrayOpen:
+		return "["
+	case ArrayClose:
+		return "]"
+	case comma:
+		return ","
+	}
+	return "<invalid>"
+}
+
+// Token provides a parsed token kind and value.
+//
+// Values are provided by the difference accessor methods. The accessor methods
+// Name, Bool, and ParsedString will panic if called on the wrong kind. There
+// are different accessor methods for the Number kind for converting to the
+// appropriate Go numeric type and those methods have the ok return value.
+type Token struct {
+	// Token kind.
+	kind Kind
+	// pos provides the position of the token in the original input.
+	pos int
+	// raw bytes of the serialized token.
+	// This is a subslice into the original input.
+	raw []byte
+	// boo is parsed boolean value.
+	boo bool
+	// str is parsed string value.
+	str string
+}
+
+// Kind returns the token kind.
+func (t Token) Kind() Kind {
+	return t.kind
+}
+
+// RawString returns the read value in string.
+func (t Token) RawString() string {
+	return string(t.raw)
+}
+
+// Pos returns the token position from the input.
+func (t Token) Pos() int {
+	return t.pos
+}
+
+// Name returns the object name if token is Name, else it will return an error.
+func (t Token) Name() string {
+	if t.kind == Name {
+		return t.str
+	}
+	panic(fmt.Sprintf("Token is not a Name: %v", t.RawString()))
+}
+
+// Bool returns the bool value if token kind is Bool, else it panics.
+func (t Token) Bool() bool {
+	if t.kind == Bool {
+		return t.boo
+	}
+	panic(fmt.Sprintf("Token is not a Bool: %v", t.RawString()))
+}
+
+// ParsedString returns the string value for a JSON string token or the read
+// value in string if token is not a string.
+func (t Token) ParsedString() string {
+	if t.kind == String {
+		return t.str
+	}
+	panic(fmt.Sprintf("Token is not a String: %v", t.RawString()))
+}
+
+// Float returns the floating-point number if token kind is Number.
+//
+// The floating-point precision is specified by the bitSize parameter: 32 for
+// float32 or 64 for float64. If bitSize=32, the result still has type float64,
+// but it will be convertible to float32 without changing its value. It will
+// return false if the number exceeds the floating point limits for given
+// bitSize.
+func (t Token) Float(bitSize int) (float64, bool) {
+	if t.kind != Number {
+		return 0, false
+	}
+	f, err := strconv.ParseFloat(t.RawString(), bitSize)
+	if err != nil {
+		return 0, false
+	}
+	return f, true
+}
+
+// Int returns the signed integer number if token is Number.
+//
+// The given bitSize specifies the integer type that the result must fit into.
+// It returns false if the number is not an integer value or if the result
+// exceeds the limits for given bitSize.
+func (t Token) Int(bitSize int) (int64, bool) {
+	s, ok := t.getIntStr()
+	if !ok {
+		return 0, false
+	}
+	n, err := strconv.ParseInt(s, 10, bitSize)
+	if err != nil {
+		return 0, false
+	}
+	return n, true
+}
+
+// Uint returns the signed integer number if token is Number, else it will
+// return an error.
+//
+// The given bitSize specifies the unsigned integer type that the result must
+// fit into. It returns false if the number is not an unsigned integer value
+// or if the result exceeds the limits for given bitSize.
+func (t Token) Uint(bitSize int) (uint64, bool) {
+	s, ok := t.getIntStr()
+	if !ok {
+		return 0, false
+	}
+	n, err := strconv.ParseUint(s, 10, bitSize)
+	if err != nil {
+		return 0, false
+	}
+	return n, true
+}
+
+func (t Token) getIntStr() (string, bool) {
+	if t.kind != Number {
+		return "", false
+	}
+	parts, ok := parseNumberParts(t.raw)
+	if !ok {
+		return "", false
+	}
+	return normalizeToIntString(parts)
+}
+
+// TokenEquals returns true if given Tokens are equal, else false.
+func TokenEquals(x, y Token) bool {
+	return x.kind == y.kind &&
+		x.pos == y.pos &&
+		bytes.Equal(x.raw, y.raw) &&
+		x.boo == y.boo &&
+		x.str == y.str
+}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/json/encode.go b/vendor/google.golang.org/protobuf/internal/encoding/json/encode.go
new file mode 100644
index 000000000..fbdf34873
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/encoding/json/encode.go
@@ -0,0 +1,276 @@
+// 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 json
+
+import (
+	"math"
+	"math/bits"
+	"strconv"
+	"strings"
+	"unicode/utf8"
+
+	"google.golang.org/protobuf/internal/detrand"
+	"google.golang.org/protobuf/internal/errors"
+)
+
+// kind represents an encoding type.
+type kind uint8
+
+const (
+	_ kind = (1 << iota) / 2
+	name
+	scalar
+	objectOpen
+	objectClose
+	arrayOpen
+	arrayClose
+)
+
+// Encoder provides methods to write out JSON constructs and values. The user is
+// responsible for producing valid sequences of JSON constructs and values.
+type Encoder struct {
+	indent   string
+	lastKind kind
+	indents  []byte
+	out      []byte
+}
+
+// NewEncoder returns an Encoder.
+//
+// If indent is a non-empty string, it causes every entry for an Array or Object
+// to be preceded by the indent and trailed by a newline.
+func NewEncoder(indent string) (*Encoder, error) {
+	e := &Encoder{}
+	if len(indent) > 0 {
+		if strings.Trim(indent, " \t") != "" {
+			return nil, errors.New("indent may only be composed of space or tab characters")
+		}
+		e.indent = indent
+	}
+	return e, nil
+}
+
+// Bytes returns the content of the written bytes.
+func (e *Encoder) Bytes() []byte {
+	return e.out
+}
+
+// WriteNull writes out the null value.
+func (e *Encoder) WriteNull() {
+	e.prepareNext(scalar)
+	e.out = append(e.out, "null"...)
+}
+
+// WriteBool writes out the given boolean value.
+func (e *Encoder) WriteBool(b bool) {
+	e.prepareNext(scalar)
+	if b {
+		e.out = append(e.out, "true"...)
+	} else {
+		e.out = append(e.out, "false"...)
+	}
+}
+
+// WriteString writes out the given string in JSON string value. Returns error
+// if input string contains invalid UTF-8.
+func (e *Encoder) WriteString(s string) error {
+	e.prepareNext(scalar)
+	var err error
+	if e.out, err = appendString(e.out, s); err != nil {
+		return err
+	}
+	return nil
+}
+
+// Sentinel error used for indicating invalid UTF-8.
+var errInvalidUTF8 = errors.New("invalid UTF-8")
+
+func appendString(out []byte, in string) ([]byte, error) {
+	out = append(out, '"')
+	i := indexNeedEscapeInString(in)
+	in, out = in[i:], append(out, in[:i]...)
+	for len(in) > 0 {
+		switch r, n := utf8.DecodeRuneInString(in); {
+		case r == utf8.RuneError && n == 1:
+			return out, errInvalidUTF8
+		case r < ' ' || r == '"' || r == '\\':
+			out = append(out, '\\')
+			switch r {
+			case '"', '\\':
+				out = append(out, byte(r))
+			case '\b':
+				out = append(out, 'b')
+			case '\f':
+				out = append(out, 'f')
+			case '\n':
+				out = append(out, 'n')
+			case '\r':
+				out = append(out, 'r')
+			case '\t':
+				out = append(out, 't')
+			default:
+				out = append(out, 'u')
+				out = append(out, "0000"[1+(bits.Len32(uint32(r))-1)/4:]...)
+				out = strconv.AppendUint(out, uint64(r), 16)
+			}
+			in = in[n:]
+		default:
+			i := indexNeedEscapeInString(in[n:])
+			in, out = in[n+i:], append(out, in[:n+i]...)
+		}
+	}
+	out = append(out, '"')
+	return out, nil
+}
+
+// indexNeedEscapeInString returns the index of the character that needs
+// escaping. If no characters need escaping, this returns the input length.
+func indexNeedEscapeInString(s string) int {
+	for i, r := range s {
+		if r < ' ' || r == '\\' || r == '"' || r == utf8.RuneError {
+			return i
+		}
+	}
+	return len(s)
+}
+
+// WriteFloat writes out the given float and bitSize in JSON number value.
+func (e *Encoder) WriteFloat(n float64, bitSize int) {
+	e.prepareNext(scalar)
+	e.out = appendFloat(e.out, n, bitSize)
+}
+
+// appendFloat formats given float in bitSize, and appends to the given []byte.
+func appendFloat(out []byte, n float64, bitSize int) []byte {
+	switch {
+	case math.IsNaN(n):
+		return append(out, `"NaN"`...)
+	case math.IsInf(n, +1):
+		return append(out, `"Infinity"`...)
+	case math.IsInf(n, -1):
+		return append(out, `"-Infinity"`...)
+	}
+
+	// JSON number formatting logic based on encoding/json.
+	// See floatEncoder.encode for reference.
+	fmt := byte('f')
+	if abs := math.Abs(n); abs != 0 {
+		if bitSize == 64 && (abs < 1e-6 || abs >= 1e21) ||
+			bitSize == 32 && (float32(abs) < 1e-6 || float32(abs) >= 1e21) {
+			fmt = 'e'
+		}
+	}
+	out = strconv.AppendFloat(out, n, fmt, -1, bitSize)
+	if fmt == 'e' {
+		n := len(out)
+		if n >= 4 && out[n-4] == 'e' && out[n-3] == '-' && out[n-2] == '0' {
+			out[n-2] = out[n-1]
+			out = out[:n-1]
+		}
+	}
+	return out
+}
+
+// WriteInt writes out the given signed integer in JSON number value.
+func (e *Encoder) WriteInt(n int64) {
+	e.prepareNext(scalar)
+	e.out = append(e.out, strconv.FormatInt(n, 10)...)
+}
+
+// WriteUint writes out the given unsigned integer in JSON number value.
+func (e *Encoder) WriteUint(n uint64) {
+	e.prepareNext(scalar)
+	e.out = append(e.out, strconv.FormatUint(n, 10)...)
+}
+
+// StartObject writes out the '{' symbol.
+func (e *Encoder) StartObject() {
+	e.prepareNext(objectOpen)
+	e.out = append(e.out, '{')
+}
+
+// EndObject writes out the '}' symbol.
+func (e *Encoder) EndObject() {
+	e.prepareNext(objectClose)
+	e.out = append(e.out, '}')
+}
+
+// WriteName writes out the given string in JSON string value and the name
+// separator ':'. Returns error if input string contains invalid UTF-8, which
+// should not be likely as protobuf field names should be valid.
+func (e *Encoder) WriteName(s string) error {
+	e.prepareNext(name)
+	var err error
+	// Append to output regardless of error.
+	e.out, err = appendString(e.out, s)
+	e.out = append(e.out, ':')
+	return err
+}
+
+// StartArray writes out the '[' symbol.
+func (e *Encoder) StartArray() {
+	e.prepareNext(arrayOpen)
+	e.out = append(e.out, '[')
+}
+
+// EndArray writes out the ']' symbol.
+func (e *Encoder) EndArray() {
+	e.prepareNext(arrayClose)
+	e.out = append(e.out, ']')
+}
+
+// prepareNext adds possible comma and indentation for the next value based
+// on last type and indent option. It also updates lastKind to next.
+func (e *Encoder) prepareNext(next kind) {
+	defer func() {
+		// Set lastKind to next.
+		e.lastKind = next
+	}()
+
+	if len(e.indent) == 0 {
+		// Need to add comma on the following condition.
+		if e.lastKind&(scalar|objectClose|arrayClose) != 0 &&
+			next&(name|scalar|objectOpen|arrayOpen) != 0 {
+			e.out = append(e.out, ',')
+			// For single-line output, add a random extra space after each
+			// comma to make output unstable.
+			if detrand.Bool() {
+				e.out = append(e.out, ' ')
+			}
+		}
+		return
+	}
+
+	switch {
+	case e.lastKind&(objectOpen|arrayOpen) != 0:
+		// If next type is NOT closing, add indent and newline.
+		if next&(objectClose|arrayClose) == 0 {
+			e.indents = append(e.indents, e.indent...)
+			e.out = append(e.out, '\n')
+			e.out = append(e.out, e.indents...)
+		}
+
+	case e.lastKind&(scalar|objectClose|arrayClose) != 0:
+		switch {
+		// If next type is either a value or name, add comma and newline.
+		case next&(name|scalar|objectOpen|arrayOpen) != 0:
+			e.out = append(e.out, ',', '\n')
+
+		// If next type is a closing object or array, adjust indentation.
+		case next&(objectClose|arrayClose) != 0:
+			e.indents = e.indents[:len(e.indents)-len(e.indent)]
+			e.out = append(e.out, '\n')
+		}
+		e.out = append(e.out, e.indents...)
+
+	case e.lastKind&name != 0:
+		e.out = append(e.out, ' ')
+		// For multi-line output, add a random extra space after key: to make
+		// output unstable.
+		if detrand.Bool() {
+			e.out = append(e.out, ' ')
+		}
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/json/encode_test.go b/vendor/google.golang.org/protobuf/internal/encoding/json/encode_test.go
new file mode 100644
index 000000000..5370f8b87
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/encoding/json/encode_test.go
@@ -0,0 +1,399 @@
+// Copyright 2019 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 json_test
+
+import (
+	"math"
+	"strings"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/cmpopts"
+
+	"google.golang.org/protobuf/internal/detrand"
+	"google.golang.org/protobuf/internal/encoding/json"
+)
+
+// Disable detrand to enable direct comparisons on outputs.
+func init() { detrand.Disable() }
+
+// splitLines is a cmpopts.Option for comparing strings with line breaks.
+var splitLines = cmpopts.AcyclicTransformer("SplitLines", func(s string) []string {
+	return strings.Split(s, "\n")
+})
+
+func TestEncoder(t *testing.T) {
+	tests := []struct {
+		desc          string
+		write         func(*json.Encoder)
+		wantOut       string
+		wantOutIndent string
+	}{
+		{
+			desc: "null",
+			write: func(e *json.Encoder) {
+				e.WriteNull()
+			},
+			wantOut: `null`,
+		},
+		{
+			desc: "true",
+			write: func(e *json.Encoder) {
+				e.WriteBool(true)
+			},
+			wantOut: `true`,
+		},
+		{
+			desc: "false",
+			write: func(e *json.Encoder) {
+				e.WriteBool(false)
+			},
+			wantOut: `false`,
+		},
+		{
+			desc: "string",
+			write: func(e *json.Encoder) {
+				e.WriteString("hello world")
+			},
+			wantOut: `"hello world"`,
+		},
+		{
+			desc: "string contains escaped characters",
+			write: func(e *json.Encoder) {
+				e.WriteString("\u0000\"\\/\b\f\n\r\t")
+			},
+			wantOut: `"\u0000\"\\/\b\f\n\r\t"`,
+		},
+		{
+			desc: "float64",
+			write: func(e *json.Encoder) {
+				e.WriteFloat(1.0199999809265137, 64)
+			},
+			wantOut: `1.0199999809265137`,
+		},
+		{
+			desc: "float64 max value",
+			write: func(e *json.Encoder) {
+				e.WriteFloat(math.MaxFloat64, 64)
+			},
+			wantOut: `1.7976931348623157e+308`,
+		},
+		{
+			desc: "float64 min value",
+			write: func(e *json.Encoder) {
+				e.WriteFloat(-math.MaxFloat64, 64)
+			},
+			wantOut: `-1.7976931348623157e+308`,
+		},
+		{
+			desc: "float64 NaN",
+			write: func(e *json.Encoder) {
+				e.WriteFloat(math.NaN(), 64)
+			},
+			wantOut: `"NaN"`,
+		},
+		{
+			desc: "float64 Infinity",
+			write: func(e *json.Encoder) {
+				e.WriteFloat(math.Inf(+1), 64)
+			},
+			wantOut: `"Infinity"`,
+		},
+		{
+			desc: "float64 -Infinity",
+			write: func(e *json.Encoder) {
+				e.WriteFloat(math.Inf(-1), 64)
+			},
+			wantOut: `"-Infinity"`,
+		},
+		{
+			desc: "float64 negative zero",
+			write: func(e *json.Encoder) {
+				e.WriteFloat(math.Copysign(0, -1), 64)
+			},
+			wantOut: `-0`,
+		},
+		{
+			desc: "float32",
+			write: func(e *json.Encoder) {
+				e.WriteFloat(1.02, 32)
+			},
+			wantOut: `1.02`,
+		},
+		{
+			desc: "float32 max value",
+			write: func(e *json.Encoder) {
+				e.WriteFloat(math.MaxFloat32, 32)
+			},
+			wantOut: `3.4028235e+38`,
+		},
+		{
+			desc: "float32 min value",
+			write: func(e *json.Encoder) {
+				e.WriteFloat(-math.MaxFloat32, 32)
+			},
+			wantOut: `-3.4028235e+38`,
+		},
+		{
+			desc: "float32 negative zero",
+			write: func(e *json.Encoder) {
+				e.WriteFloat(math.Copysign(0, -1), 32)
+			},
+			wantOut: `-0`,
+		},
+		{
+			desc: "int",
+			write: func(e *json.Encoder) {
+				e.WriteInt(-math.MaxInt64)
+			},
+			wantOut: `-9223372036854775807`,
+		},
+		{
+			desc: "uint",
+			write: func(e *json.Encoder) {
+				e.WriteUint(math.MaxUint64)
+			},
+			wantOut: `18446744073709551615`,
+		},
+		{
+			desc: "empty object",
+			write: func(e *json.Encoder) {
+				e.StartObject()
+				e.EndObject()
+			},
+			wantOut: `{}`,
+		},
+		{
+			desc: "empty array",
+			write: func(e *json.Encoder) {
+				e.StartArray()
+				e.EndArray()
+			},
+			wantOut: `[]`,
+		},
+		{
+			desc: "object with one member",
+			write: func(e *json.Encoder) {
+				e.StartObject()
+				e.WriteName("hello")
+				e.WriteString("world")
+				e.EndObject()
+			},
+			wantOut: `{"hello":"world"}`,
+			wantOutIndent: `{
+	"hello": "world"
+}`,
+		},
+		{
+			desc: "array with one member",
+			write: func(e *json.Encoder) {
+				e.StartArray()
+				e.WriteNull()
+				e.EndArray()
+			},
+			wantOut: `[null]`,
+			wantOutIndent: `[
+	null
+]`,
+		},
+		{
+			desc: "simple object",
+			write: func(e *json.Encoder) {
+				e.StartObject()
+				{
+					e.WriteName("null")
+					e.WriteNull()
+				}
+				{
+					e.WriteName("bool")
+					e.WriteBool(true)
+				}
+				{
+					e.WriteName("string")
+					e.WriteString("hello")
+				}
+				{
+					e.WriteName("float")
+					e.WriteFloat(6.28318, 64)
+				}
+				{
+					e.WriteName("int")
+					e.WriteInt(42)
+				}
+				{
+					e.WriteName("uint")
+					e.WriteUint(47)
+				}
+				e.EndObject()
+			},
+			wantOut: `{"null":null,"bool":true,"string":"hello","float":6.28318,"int":42,"uint":47}`,
+			wantOutIndent: `{
+	"null": null,
+	"bool": true,
+	"string": "hello",
+	"float": 6.28318,
+	"int": 42,
+	"uint": 47
+}`,
+		},
+		{
+			desc: "simple array",
+			write: func(e *json.Encoder) {
+				e.StartArray()
+				{
+					e.WriteString("hello")
+					e.WriteFloat(6.28318, 32)
+					e.WriteInt(42)
+					e.WriteUint(47)
+					e.WriteBool(true)
+					e.WriteNull()
+				}
+				e.EndArray()
+			},
+			wantOut: `["hello",6.28318,42,47,true,null]`,
+			wantOutIndent: `[
+	"hello",
+	6.28318,
+	42,
+	47,
+	true,
+	null
+]`,
+		},
+		{
+			desc: "fancy object",
+			write: func(e *json.Encoder) {
+				e.StartObject()
+				{
+					e.WriteName("object0")
+					e.StartObject()
+					e.EndObject()
+				}
+				{
+					e.WriteName("array0")
+					e.StartArray()
+					e.EndArray()
+				}
+				{
+					e.WriteName("object1")
+					e.StartObject()
+					{
+						e.WriteName("null")
+						e.WriteNull()
+					}
+					{
+						e.WriteName("object1-1")
+						e.StartObject()
+						{
+							e.WriteName("bool")
+							e.WriteBool(false)
+						}
+						{
+							e.WriteName("float")
+							e.WriteFloat(3.14159, 32)
+						}
+						e.EndObject()
+					}
+					e.EndObject()
+				}
+				{
+					e.WriteName("array1")
+					e.StartArray()
+					{
+						e.WriteNull()
+						e.StartObject()
+						e.EndObject()
+						e.StartObject()
+						{
+							e.WriteName("hello")
+							e.WriteString("world")
+						}
+						{
+							e.WriteName("hola")
+							e.WriteString("mundo")
+						}
+						e.EndObject()
+						e.StartArray()
+						{
+							e.WriteUint(1)
+							e.WriteUint(0)
+							e.WriteUint(1)
+						}
+						e.EndArray()
+					}
+					e.EndArray()
+				}
+				e.EndObject()
+			},
+			wantOutIndent: `{
+	"object0": {},
+	"array0": [],
+	"object1": {
+		"null": null,
+		"object1-1": {
+			"bool": false,
+			"float": 3.14159
+		}
+	},
+	"array1": [
+		null,
+		{},
+		{
+			"hello": "world",
+			"hola": "mundo"
+		},
+		[
+			1,
+			0,
+			1
+		]
+	]
+}`,
+		}}
+
+	for _, tc := range tests {
+		t.Run(tc.desc, func(t *testing.T) {
+			if tc.wantOut != "" {
+				enc, err := json.NewEncoder("")
+				if err != nil {
+					t.Fatalf("NewEncoder() returned error: %v", err)
+				}
+				tc.write(enc)
+				got := string(enc.Bytes())
+				if got != tc.wantOut {
+					t.Errorf("%s:\n<got>:\n%v\n<want>\n%v\n", tc.desc, got, tc.wantOut)
+				}
+			}
+			if tc.wantOutIndent != "" {
+				enc, err := json.NewEncoder("\t")
+				if err != nil {
+					t.Fatalf("NewEncoder() returned error: %v", err)
+				}
+				tc.write(enc)
+				got, want := string(enc.Bytes()), tc.wantOutIndent
+				if got != want {
+					t.Errorf("%s(indent):\n<got>:\n%v\n<want>\n%v\n<diff -want +got>\n%v\n",
+						tc.desc, got, want, cmp.Diff(want, got, splitLines))
+				}
+			}
+		})
+	}
+}
+
+func TestWriteStringError(t *testing.T) {
+	tests := []string{"abc\xff"}
+
+	for _, in := range tests {
+		t.Run(in, func(t *testing.T) {
+			enc, err := json.NewEncoder("")
+			if err != nil {
+				t.Fatalf("NewEncoder() returned error: %v", err)
+			}
+			if err := enc.WriteString(in); err == nil {
+				t.Errorf("WriteString(%v): got nil error, want error", in)
+			}
+		})
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/messageset/messageset.go b/vendor/google.golang.org/protobuf/internal/encoding/messageset/messageset.go
new file mode 100644
index 000000000..b1eeea507
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/encoding/messageset/messageset.go
@@ -0,0 +1,258 @@
+// Copyright 2019 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 messageset encodes and decodes the obsolete MessageSet wire format.
+package messageset
+
+import (
+	"math"
+
+	"google.golang.org/protobuf/encoding/protowire"
+	"google.golang.org/protobuf/internal/errors"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+	preg "google.golang.org/protobuf/reflect/protoregistry"
+)
+
+// The MessageSet wire format is equivalent to a message defiend as follows,
+// where each Item defines an extension field with a field number of 'type_id'
+// and content of 'message'. MessageSet extensions must be non-repeated message
+// fields.
+//
+//	message MessageSet {
+//		repeated group Item = 1 {
+//			required int32 type_id = 2;
+//			required string message = 3;
+//		}
+//	}
+const (
+	FieldItem    = protowire.Number(1)
+	FieldTypeID  = protowire.Number(2)
+	FieldMessage = protowire.Number(3)
+)
+
+// ExtensionName is the field name for extensions of MessageSet.
+//
+// A valid MessageSet extension must be of the form:
+//	message MyMessage {
+//		extend proto2.bridge.MessageSet {
+//			optional MyMessage message_set_extension = 1234;
+//		}
+//		...
+//	}
+const ExtensionName = "message_set_extension"
+
+// IsMessageSet returns whether the message uses the MessageSet wire format.
+func IsMessageSet(md pref.MessageDescriptor) bool {
+	xmd, ok := md.(interface{ IsMessageSet() bool })
+	return ok && xmd.IsMessageSet()
+}
+
+// IsMessageSetExtension reports this field extends a MessageSet.
+func IsMessageSetExtension(fd pref.FieldDescriptor) bool {
+	if fd.Name() != ExtensionName {
+		return false
+	}
+	if fd.FullName().Parent() != fd.Message().FullName() {
+		return false
+	}
+	return IsMessageSet(fd.ContainingMessage())
+}
+
+// FindMessageSetExtension locates a MessageSet extension field by name.
+// In text and JSON formats, the extension name used is the message itself.
+// The extension field name is derived by appending ExtensionName.
+func FindMessageSetExtension(r preg.ExtensionTypeResolver, s pref.FullName) (pref.ExtensionType, error) {
+	name := s.Append(ExtensionName)
+	xt, err := r.FindExtensionByName(name)
+	if err != nil {
+		if err == preg.NotFound {
+			return nil, err
+		}
+		return nil, errors.Wrap(err, "%q", name)
+	}
+	if !IsMessageSetExtension(xt.TypeDescriptor()) {
+		return nil, preg.NotFound
+	}
+	return xt, nil
+}
+
+// SizeField returns the size of a MessageSet item field containing an extension
+// with the given field number, not counting the contents of the message subfield.
+func SizeField(num protowire.Number) int {
+	return 2*protowire.SizeTag(FieldItem) + protowire.SizeTag(FieldTypeID) + protowire.SizeVarint(uint64(num))
+}
+
+// Unmarshal parses a MessageSet.
+//
+// It calls fn with the type ID and value of each item in the MessageSet.
+// Unknown fields are discarded.
+//
+// If wantLen is true, the item values include the varint length prefix.
+// This is ugly, but simplifies the fast-path decoder in internal/impl.
+func Unmarshal(b []byte, wantLen bool, fn func(typeID protowire.Number, value []byte) error) error {
+	for len(b) > 0 {
+		num, wtyp, n := protowire.ConsumeTag(b)
+		if n < 0 {
+			return protowire.ParseError(n)
+		}
+		b = b[n:]
+		if num != FieldItem || wtyp != protowire.StartGroupType {
+			n := protowire.ConsumeFieldValue(num, wtyp, b)
+			if n < 0 {
+				return protowire.ParseError(n)
+			}
+			b = b[n:]
+			continue
+		}
+		typeID, value, n, err := ConsumeFieldValue(b, wantLen)
+		if err != nil {
+			return err
+		}
+		b = b[n:]
+		if typeID == 0 {
+			continue
+		}
+		if err := fn(typeID, value); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// ConsumeFieldValue parses b as a MessageSet item field value until and including
+// the trailing end group marker. It assumes the start group tag has already been parsed.
+// It returns the contents of the type_id and message subfields and the total
+// item length.
+//
+// If wantLen is true, the returned message value includes the length prefix.
+func ConsumeFieldValue(b []byte, wantLen bool) (typeid protowire.Number, message []byte, n int, err error) {
+	ilen := len(b)
+	for {
+		num, wtyp, n := protowire.ConsumeTag(b)
+		if n < 0 {
+			return 0, nil, 0, protowire.ParseError(n)
+		}
+		b = b[n:]
+		switch {
+		case num == FieldItem && wtyp == protowire.EndGroupType:
+			if wantLen && len(message) == 0 {
+				// The message field was missing, which should never happen.
+				// Be prepared for this case anyway.
+				message = protowire.AppendVarint(message, 0)
+			}
+			return typeid, message, ilen - len(b), nil
+		case num == FieldTypeID && wtyp == protowire.VarintType:
+			v, n := protowire.ConsumeVarint(b)
+			if n < 0 {
+				return 0, nil, 0, protowire.ParseError(n)
+			}
+			b = b[n:]
+			if v < 1 || v > math.MaxInt32 {
+				return 0, nil, 0, errors.New("invalid type_id in message set")
+			}
+			typeid = protowire.Number(v)
+		case num == FieldMessage && wtyp == protowire.BytesType:
+			m, n := protowire.ConsumeBytes(b)
+			if n < 0 {
+				return 0, nil, 0, protowire.ParseError(n)
+			}
+			if message == nil {
+				if wantLen {
+					message = b[:n:n]
+				} else {
+					message = m[:len(m):len(m)]
+				}
+			} else {
+				// This case should never happen in practice, but handle it for
+				// correctness: The MessageSet item contains multiple message
+				// fields, which need to be merged.
+				//
+				// In the case where we're returning the length, this becomes
+				// quite inefficient since we need to strip the length off
+				// the existing data and reconstruct it with the combined length.
+				if wantLen {
+					_, nn := protowire.ConsumeVarint(message)
+					m0 := message[nn:]
+					message = nil
+					message = protowire.AppendVarint(message, uint64(len(m0)+len(m)))
+					message = append(message, m0...)
+					message = append(message, m...)
+				} else {
+					message = append(message, m...)
+				}
+			}
+			b = b[n:]
+		default:
+			// We have no place to put it, so we just ignore unknown fields.
+			n := protowire.ConsumeFieldValue(num, wtyp, b)
+			if n < 0 {
+				return 0, nil, 0, protowire.ParseError(n)
+			}
+			b = b[n:]
+		}
+	}
+}
+
+// AppendFieldStart appends the start of a MessageSet item field containing
+// an extension with the given number. The caller must add the message
+// subfield (including the tag).
+func AppendFieldStart(b []byte, num protowire.Number) []byte {
+	b = protowire.AppendTag(b, FieldItem, protowire.StartGroupType)
+	b = protowire.AppendTag(b, FieldTypeID, protowire.VarintType)
+	b = protowire.AppendVarint(b, uint64(num))
+	return b
+}
+
+// AppendFieldEnd appends the trailing end group marker for a MessageSet item field.
+func AppendFieldEnd(b []byte) []byte {
+	return protowire.AppendTag(b, FieldItem, protowire.EndGroupType)
+}
+
+// SizeUnknown returns the size of an unknown fields section in MessageSet format.
+//
+// See AppendUnknown.
+func SizeUnknown(unknown []byte) (size int) {
+	for len(unknown) > 0 {
+		num, typ, n := protowire.ConsumeTag(unknown)
+		if n < 0 || typ != protowire.BytesType {
+			return 0
+		}
+		unknown = unknown[n:]
+		_, n = protowire.ConsumeBytes(unknown)
+		if n < 0 {
+			return 0
+		}
+		unknown = unknown[n:]
+		size += SizeField(num) + protowire.SizeTag(FieldMessage) + n
+	}
+	return size
+}
+
+// AppendUnknown appends unknown fields to b in MessageSet format.
+//
+// For historic reasons, unresolved items in a MessageSet are stored in a
+// message's unknown fields section in non-MessageSet format. That is, an
+// unknown item with typeID T and value V appears in the unknown fields as
+// a field with number T and value V.
+//
+// This function converts the unknown fields back into MessageSet form.
+func AppendUnknown(b, unknown []byte) ([]byte, error) {
+	for len(unknown) > 0 {
+		num, typ, n := protowire.ConsumeTag(unknown)
+		if n < 0 || typ != protowire.BytesType {
+			return nil, errors.New("invalid data in message set unknown fields")
+		}
+		unknown = unknown[n:]
+		_, n = protowire.ConsumeBytes(unknown)
+		if n < 0 {
+			return nil, errors.New("invalid data in message set unknown fields")
+		}
+		b = AppendFieldStart(b, num)
+		b = protowire.AppendTag(b, FieldMessage, protowire.BytesType)
+		b = append(b, unknown[:n]...)
+		b = AppendFieldEnd(b)
+		unknown = unknown[n:]
+	}
+	return b, nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/tag/tag.go b/vendor/google.golang.org/protobuf/internal/encoding/tag/tag.go
new file mode 100644
index 000000000..16c02d7b6
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/encoding/tag/tag.go
@@ -0,0 +1,207 @@
+// 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 tag marshals and unmarshals the legacy struct tags as generated
+// by historical versions of protoc-gen-go.
+package tag
+
+import (
+	"reflect"
+	"strconv"
+	"strings"
+
+	defval "google.golang.org/protobuf/internal/encoding/defval"
+	fdesc "google.golang.org/protobuf/internal/filedesc"
+	"google.golang.org/protobuf/internal/strs"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+)
+
+var byteType = reflect.TypeOf(byte(0))
+
+// Unmarshal decodes the tag into a prototype.Field.
+//
+// The goType is needed to determine the original protoreflect.Kind since the
+// tag does not record sufficient information to determine that.
+// The type is the underlying field type (e.g., a repeated field may be
+// represented by []T, but the Go type passed in is just T).
+// A list of enum value descriptors must be provided for enum fields.
+// This does not populate the Enum or Message (except for weak message).
+//
+// This function is a best effort attempt; parsing errors are ignored.
+func Unmarshal(tag string, goType reflect.Type, evs pref.EnumValueDescriptors) pref.FieldDescriptor {
+	f := new(fdesc.Field)
+	f.L0.ParentFile = fdesc.SurrogateProto2
+	for len(tag) > 0 {
+		i := strings.IndexByte(tag, ',')
+		if i < 0 {
+			i = len(tag)
+		}
+		switch s := tag[:i]; {
+		case strings.HasPrefix(s, "name="):
+			f.L0.FullName = pref.FullName(s[len("name="):])
+		case strings.Trim(s, "0123456789") == "":
+			n, _ := strconv.ParseUint(s, 10, 32)
+			f.L1.Number = pref.FieldNumber(n)
+		case s == "opt":
+			f.L1.Cardinality = pref.Optional
+		case s == "req":
+			f.L1.Cardinality = pref.Required
+		case s == "rep":
+			f.L1.Cardinality = pref.Repeated
+		case s == "varint":
+			switch goType.Kind() {
+			case reflect.Bool:
+				f.L1.Kind = pref.BoolKind
+			case reflect.Int32:
+				f.L1.Kind = pref.Int32Kind
+			case reflect.Int64:
+				f.L1.Kind = pref.Int64Kind
+			case reflect.Uint32:
+				f.L1.Kind = pref.Uint32Kind
+			case reflect.Uint64:
+				f.L1.Kind = pref.Uint64Kind
+			}
+		case s == "zigzag32":
+			if goType.Kind() == reflect.Int32 {
+				f.L1.Kind = pref.Sint32Kind
+			}
+		case s == "zigzag64":
+			if goType.Kind() == reflect.Int64 {
+				f.L1.Kind = pref.Sint64Kind
+			}
+		case s == "fixed32":
+			switch goType.Kind() {
+			case reflect.Int32:
+				f.L1.Kind = pref.Sfixed32Kind
+			case reflect.Uint32:
+				f.L1.Kind = pref.Fixed32Kind
+			case reflect.Float32:
+				f.L1.Kind = pref.FloatKind
+			}
+		case s == "fixed64":
+			switch goType.Kind() {
+			case reflect.Int64:
+				f.L1.Kind = pref.Sfixed64Kind
+			case reflect.Uint64:
+				f.L1.Kind = pref.Fixed64Kind
+			case reflect.Float64:
+				f.L1.Kind = pref.DoubleKind
+			}
+		case s == "bytes":
+			switch {
+			case goType.Kind() == reflect.String:
+				f.L1.Kind = pref.StringKind
+			case goType.Kind() == reflect.Slice && goType.Elem() == byteType:
+				f.L1.Kind = pref.BytesKind
+			default:
+				f.L1.Kind = pref.MessageKind
+			}
+		case s == "group":
+			f.L1.Kind = pref.GroupKind
+		case strings.HasPrefix(s, "enum="):
+			f.L1.Kind = pref.EnumKind
+		case strings.HasPrefix(s, "json="):
+			jsonName := s[len("json="):]
+			if jsonName != strs.JSONCamelCase(string(f.L0.FullName.Name())) {
+				f.L1.JSONName.Init(jsonName)
+			}
+		case s == "packed":
+			f.L1.HasPacked = true
+			f.L1.IsPacked = true
+		case strings.HasPrefix(s, "weak="):
+			f.L1.IsWeak = true
+			f.L1.Message = fdesc.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)
+			v, ev, _ := defval.Unmarshal(s, f.L1.Kind, evs, defval.GoTag)
+			f.L1.Default = fdesc.DefaultValue(v, ev)
+		case s == "proto3":
+			f.L0.ParentFile = fdesc.SurrogateProto3
+		}
+		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.L1.Kind == pref.GroupKind {
+		f.L0.FullName = pref.FullName(strings.ToLower(string(f.L0.FullName)))
+	}
+	return f
+}
+
+// Marshal encodes the protoreflect.FieldDescriptor as a tag.
+//
+// The enumName must be provided if the kind is an enum.
+// Historically, the formulation of the enum "name" was the proto package
+// dot-concatenated with the generated Go identifier for the enum type.
+// Depending on the context on how Marshal is called, there are different ways
+// through which that information is determined. As such it is the caller's
+// responsibility to provide a function to obtain that information.
+func Marshal(fd pref.FieldDescriptor, enumName string) string {
+	var tag []string
+	switch fd.Kind() {
+	case pref.BoolKind, pref.EnumKind, pref.Int32Kind, pref.Uint32Kind, pref.Int64Kind, pref.Uint64Kind:
+		tag = append(tag, "varint")
+	case pref.Sint32Kind:
+		tag = append(tag, "zigzag32")
+	case pref.Sint64Kind:
+		tag = append(tag, "zigzag64")
+	case pref.Sfixed32Kind, pref.Fixed32Kind, pref.FloatKind:
+		tag = append(tag, "fixed32")
+	case pref.Sfixed64Kind, pref.Fixed64Kind, pref.DoubleKind:
+		tag = append(tag, "fixed64")
+	case pref.StringKind, pref.BytesKind, pref.MessageKind:
+		tag = append(tag, "bytes")
+	case pref.GroupKind:
+		tag = append(tag, "group")
+	}
+	tag = append(tag, strconv.Itoa(int(fd.Number())))
+	switch fd.Cardinality() {
+	case pref.Optional:
+		tag = append(tag, "opt")
+	case pref.Required:
+		tag = append(tag, "req")
+	case pref.Repeated:
+		tag = append(tag, "rep")
+	}
+	if fd.IsPacked() {
+		tag = append(tag, "packed")
+	}
+	name := string(fd.Name())
+	if fd.Kind() == pref.GroupKind {
+		// The name of the FieldDescriptor for a group field is
+		// lowercased. To find the original capitalization, we
+		// look in the field's MessageType.
+		name = string(fd.Message().Name())
+	}
+	tag = append(tag, "name="+name)
+	if jsonName := fd.JSONName(); jsonName != "" && jsonName != name && !fd.IsExtension() {
+		// NOTE: The jsonName != name condition is suspect, but it preserve
+		// the exact same semantics from the previous generator.
+		tag = append(tag, "json="+jsonName)
+	}
+	if fd.IsWeak() {
+		tag = append(tag, "weak="+string(fd.Message().FullName()))
+	}
+	// The previous implementation does not tag extension fields as proto3,
+	// even when the field is defined in a proto3 file. Match that behavior
+	// for consistency.
+	if fd.Syntax() == pref.Proto3 && !fd.IsExtension() {
+		tag = append(tag, "proto3")
+	}
+	if fd.Kind() == pref.EnumKind && enumName != "" {
+		tag = append(tag, "enum="+enumName)
+	}
+	if fd.ContainingOneof() != nil {
+		tag = append(tag, "oneof")
+	}
+	// This must appear last in the tag, since commas in strings aren't escaped.
+	if fd.HasDefault() {
+		def, _ := defval.Marshal(fd.Default(), fd.DefaultEnumValue(), fd.Kind(), defval.GoTag)
+		tag = append(tag, "def="+def)
+	}
+	return strings.Join(tag, ",")
+}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/tag/tag_test.go b/vendor/google.golang.org/protobuf/internal/encoding/tag/tag_test.go
new file mode 100644
index 000000000..9f22521d7
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/encoding/tag/tag_test.go
@@ -0,0 +1,40 @@
+// 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 tag_test
+
+import (
+	"reflect"
+	"testing"
+
+	"google.golang.org/protobuf/internal/encoding/tag"
+	fdesc "google.golang.org/protobuf/internal/filedesc"
+	"google.golang.org/protobuf/proto"
+	pdesc "google.golang.org/protobuf/reflect/protodesc"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+)
+
+func Test(t *testing.T) {
+	fd := new(fdesc.Field)
+	fd.L0.ParentFile = fdesc.SurrogateProto3
+	fd.L0.FullName = "foo_field"
+	fd.L1.Number = 1337
+	fd.L1.Cardinality = pref.Repeated
+	fd.L1.Kind = pref.BytesKind
+	fd.L1.Default = fdesc.DefaultValue(pref.ValueOf([]byte("hello, \xde\xad\xbe\xef\n")), nil)
+
+	// Marshal test.
+	gotTag := tag.Marshal(fd, "")
+	wantTag := `bytes,1337,rep,name=foo_field,json=fooField,proto3,def=hello, \336\255\276\357\n`
+	if gotTag != wantTag {
+		t.Errorf("Marshal() = `%v`, want `%v`", gotTag, wantTag)
+	}
+
+	// Unmarshal test.
+	gotFD := tag.Unmarshal(wantTag, reflect.TypeOf([]byte{}), nil)
+	wantFD := fd
+	if !proto.Equal(pdesc.ToFieldDescriptorProto(gotFD), pdesc.ToFieldDescriptorProto(wantFD)) {
+		t.Errorf("Umarshal() mismatch:\ngot  %v\nwant %v", gotFD, wantFD)
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/text/decode.go b/vendor/google.golang.org/protobuf/internal/encoding/text/decode.go
new file mode 100644
index 000000000..eb10ea102
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/encoding/text/decode.go
@@ -0,0 +1,665 @@
+// 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 text
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"regexp"
+	"strconv"
+	"unicode/utf8"
+
+	"google.golang.org/protobuf/internal/errors"
+)
+
+// Decoder is a token-based textproto decoder.
+type Decoder struct {
+	// lastCall is last method called, either readCall or peekCall.
+	// Initial value is readCall.
+	lastCall call
+
+	// lastToken contains the last read token.
+	lastToken Token
+
+	// lastErr contains the last read error.
+	lastErr error
+
+	// openStack is a stack containing the byte characters for MessageOpen and
+	// ListOpen kinds. The top of stack represents the message or the list that
+	// the current token is nested in. An empty stack means the current token is
+	// at the top level message. The characters '{' and '<' both represent the
+	// MessageOpen kind.
+	openStack []byte
+
+	// orig is used in reporting line and column.
+	orig []byte
+	// in contains the unconsumed input.
+	in []byte
+}
+
+// NewDecoder returns a Decoder to read the given []byte.
+func NewDecoder(b []byte) *Decoder {
+	return &Decoder{orig: b, in: b}
+}
+
+// ErrUnexpectedEOF means that EOF was encountered in the middle of the input.
+var ErrUnexpectedEOF = errors.New("%v", io.ErrUnexpectedEOF)
+
+// call specifies which Decoder method was invoked.
+type call uint8
+
+const (
+	readCall call = iota
+	peekCall
+)
+
+// Peek looks ahead and returns the next token and error without advancing a read.
+func (d *Decoder) Peek() (Token, error) {
+	defer func() { d.lastCall = peekCall }()
+	if d.lastCall == readCall {
+		d.lastToken, d.lastErr = d.Read()
+	}
+	return d.lastToken, d.lastErr
+}
+
+// Read returns the next token.
+// It will return an error if there is no valid token.
+func (d *Decoder) Read() (Token, error) {
+	defer func() { d.lastCall = readCall }()
+	if d.lastCall == peekCall {
+		return d.lastToken, d.lastErr
+	}
+
+	tok, err := d.parseNext(d.lastToken.kind)
+	if err != nil {
+		return Token{}, err
+	}
+
+	switch tok.kind {
+	case comma, semicolon:
+		tok, err = d.parseNext(tok.kind)
+		if err != nil {
+			return Token{}, err
+		}
+	}
+	d.lastToken = tok
+	return tok, nil
+}
+
+const (
+	mismatchedFmt = "mismatched close character %q"
+	unexpectedFmt = "unexpected character %q"
+)
+
+// parseNext parses the next Token based on given last kind.
+func (d *Decoder) parseNext(lastKind Kind) (Token, error) {
+	// Trim leading spaces.
+	d.consume(0)
+	isEOF := false
+	if len(d.in) == 0 {
+		isEOF = true
+	}
+
+	switch lastKind {
+	case EOF:
+		return d.consumeToken(EOF, 0, 0), nil
+
+	case bof:
+		// Start of top level message. Next token can be EOF or Name.
+		if isEOF {
+			return d.consumeToken(EOF, 0, 0), nil
+		}
+		return d.parseFieldName()
+
+	case Name:
+		// Next token can be MessageOpen, ListOpen or Scalar.
+		if isEOF {
+			return Token{}, ErrUnexpectedEOF
+		}
+		switch ch := d.in[0]; ch {
+		case '{', '<':
+			d.pushOpenStack(ch)
+			return d.consumeToken(MessageOpen, 1, 0), nil
+		case '[':
+			d.pushOpenStack(ch)
+			return d.consumeToken(ListOpen, 1, 0), nil
+		default:
+			return d.parseScalar()
+		}
+
+	case Scalar:
+		openKind, closeCh := d.currentOpenKind()
+		switch openKind {
+		case bof:
+			// Top level message.
+			// 	Next token can be EOF, comma, semicolon or Name.
+			if isEOF {
+				return d.consumeToken(EOF, 0, 0), nil
+			}
+			switch d.in[0] {
+			case ',':
+				return d.consumeToken(comma, 1, 0), nil
+			case ';':
+				return d.consumeToken(semicolon, 1, 0), nil
+			default:
+				return d.parseFieldName()
+			}
+
+		case MessageOpen:
+			// Next token can be MessageClose, comma, semicolon or Name.
+			if isEOF {
+				return Token{}, ErrUnexpectedEOF
+			}
+			switch ch := d.in[0]; ch {
+			case closeCh:
+				d.popOpenStack()
+				return d.consumeToken(MessageClose, 1, 0), nil
+			case otherCloseChar[closeCh]:
+				return Token{}, d.newSyntaxError(mismatchedFmt, ch)
+			case ',':
+				return d.consumeToken(comma, 1, 0), nil
+			case ';':
+				return d.consumeToken(semicolon, 1, 0), nil
+			default:
+				return d.parseFieldName()
+			}
+
+		case ListOpen:
+			// Next token can be ListClose or comma.
+			if isEOF {
+				return Token{}, ErrUnexpectedEOF
+			}
+			switch ch := d.in[0]; ch {
+			case ']':
+				d.popOpenStack()
+				return d.consumeToken(ListClose, 1, 0), nil
+			case ',':
+				return d.consumeToken(comma, 1, 0), nil
+			default:
+				return Token{}, d.newSyntaxError(unexpectedFmt, ch)
+			}
+		}
+
+	case MessageOpen:
+		// Next token can be MessageClose or Name.
+		if isEOF {
+			return Token{}, ErrUnexpectedEOF
+		}
+		_, closeCh := d.currentOpenKind()
+		switch ch := d.in[0]; ch {
+		case closeCh:
+			d.popOpenStack()
+			return d.consumeToken(MessageClose, 1, 0), nil
+		case otherCloseChar[closeCh]:
+			return Token{}, d.newSyntaxError(mismatchedFmt, ch)
+		default:
+			return d.parseFieldName()
+		}
+
+	case MessageClose:
+		openKind, closeCh := d.currentOpenKind()
+		switch openKind {
+		case bof:
+			// Top level message.
+			// Next token can be EOF, comma, semicolon or Name.
+			if isEOF {
+				return d.consumeToken(EOF, 0, 0), nil
+			}
+			switch ch := d.in[0]; ch {
+			case ',':
+				return d.consumeToken(comma, 1, 0), nil
+			case ';':
+				return d.consumeToken(semicolon, 1, 0), nil
+			default:
+				return d.parseFieldName()
+			}
+
+		case MessageOpen:
+			// Next token can be MessageClose, comma, semicolon or Name.
+			if isEOF {
+				return Token{}, ErrUnexpectedEOF
+			}
+			switch ch := d.in[0]; ch {
+			case closeCh:
+				d.popOpenStack()
+				return d.consumeToken(MessageClose, 1, 0), nil
+			case otherCloseChar[closeCh]:
+				return Token{}, d.newSyntaxError(mismatchedFmt, ch)
+			case ',':
+				return d.consumeToken(comma, 1, 0), nil
+			case ';':
+				return d.consumeToken(semicolon, 1, 0), nil
+			default:
+				return d.parseFieldName()
+			}
+
+		case ListOpen:
+			// Next token can be ListClose or comma
+			if isEOF {
+				return Token{}, ErrUnexpectedEOF
+			}
+			switch ch := d.in[0]; ch {
+			case closeCh:
+				d.popOpenStack()
+				return d.consumeToken(ListClose, 1, 0), nil
+			case ',':
+				return d.consumeToken(comma, 1, 0), nil
+			default:
+				return Token{}, d.newSyntaxError(unexpectedFmt, ch)
+			}
+		}
+
+	case ListOpen:
+		// Next token can be ListClose, MessageStart or Scalar.
+		if isEOF {
+			return Token{}, ErrUnexpectedEOF
+		}
+		switch ch := d.in[0]; ch {
+		case ']':
+			d.popOpenStack()
+			return d.consumeToken(ListClose, 1, 0), nil
+		case '{', '<':
+			d.pushOpenStack(ch)
+			return d.consumeToken(MessageOpen, 1, 0), nil
+		default:
+			return d.parseScalar()
+		}
+
+	case ListClose:
+		openKind, closeCh := d.currentOpenKind()
+		switch openKind {
+		case bof:
+			// Top level message.
+			// Next token can be EOF, comma, semicolon or Name.
+			if isEOF {
+				return d.consumeToken(EOF, 0, 0), nil
+			}
+			switch ch := d.in[0]; ch {
+			case ',':
+				return d.consumeToken(comma, 1, 0), nil
+			case ';':
+				return d.consumeToken(semicolon, 1, 0), nil
+			default:
+				return d.parseFieldName()
+			}
+
+		case MessageOpen:
+			// Next token can be MessageClose, comma, semicolon or Name.
+			if isEOF {
+				return Token{}, ErrUnexpectedEOF
+			}
+			switch ch := d.in[0]; ch {
+			case closeCh:
+				d.popOpenStack()
+				return d.consumeToken(MessageClose, 1, 0), nil
+			case otherCloseChar[closeCh]:
+				return Token{}, d.newSyntaxError(mismatchedFmt, ch)
+			case ',':
+				return d.consumeToken(comma, 1, 0), nil
+			case ';':
+				return d.consumeToken(semicolon, 1, 0), nil
+			default:
+				return d.parseFieldName()
+			}
+
+		default:
+			// It is not possible to have this case. Let it panic below.
+		}
+
+	case comma, semicolon:
+		openKind, closeCh := d.currentOpenKind()
+		switch openKind {
+		case bof:
+			// Top level message. Next token can be EOF or Name.
+			if isEOF {
+				return d.consumeToken(EOF, 0, 0), nil
+			}
+			return d.parseFieldName()
+
+		case MessageOpen:
+			// Next token can be MessageClose or Name.
+			if isEOF {
+				return Token{}, ErrUnexpectedEOF
+			}
+			switch ch := d.in[0]; ch {
+			case closeCh:
+				d.popOpenStack()
+				return d.consumeToken(MessageClose, 1, 0), nil
+			case otherCloseChar[closeCh]:
+				return Token{}, d.newSyntaxError(mismatchedFmt, ch)
+			default:
+				return d.parseFieldName()
+			}
+
+		case ListOpen:
+			if lastKind == semicolon {
+				// It is not be possible to have this case as logic here
+				// should not have produced a semicolon Token when inside a
+				// list. Let it panic below.
+				break
+			}
+			// Next token can be MessageOpen or Scalar.
+			if isEOF {
+				return Token{}, ErrUnexpectedEOF
+			}
+			switch ch := d.in[0]; ch {
+			case '{', '<':
+				d.pushOpenStack(ch)
+				return d.consumeToken(MessageOpen, 1, 0), nil
+			default:
+				return d.parseScalar()
+			}
+		}
+	}
+
+	line, column := d.Position(len(d.orig) - len(d.in))
+	panic(fmt.Sprintf("Decoder.parseNext: bug at handling line %d:%d with lastKind=%v", line, column, lastKind))
+}
+
+var otherCloseChar = map[byte]byte{
+	'}': '>',
+	'>': '}',
+}
+
+// currentOpenKind indicates whether current position is inside a message, list
+// or top-level message by returning MessageOpen, ListOpen or bof respectively.
+// If the returned kind is either a MessageOpen or ListOpen, it also returns the
+// corresponding closing character.
+func (d *Decoder) currentOpenKind() (Kind, byte) {
+	if len(d.openStack) == 0 {
+		return bof, 0
+	}
+	openCh := d.openStack[len(d.openStack)-1]
+	switch openCh {
+	case '{':
+		return MessageOpen, '}'
+	case '<':
+		return MessageOpen, '>'
+	case '[':
+		return ListOpen, ']'
+	}
+	panic(fmt.Sprintf("Decoder: openStack contains invalid byte %s", string(openCh)))
+}
+
+func (d *Decoder) pushOpenStack(ch byte) {
+	d.openStack = append(d.openStack, ch)
+}
+
+func (d *Decoder) popOpenStack() {
+	d.openStack = d.openStack[:len(d.openStack)-1]
+}
+
+// parseFieldName parses field name and separator.
+func (d *Decoder) parseFieldName() (tok Token, err error) {
+	defer func() {
+		if err == nil && d.tryConsumeChar(':') {
+			tok.attrs |= hasSeparator
+		}
+	}()
+
+	// Extension or Any type URL.
+	if d.in[0] == '[' {
+		return d.parseTypeName()
+	}
+
+	// Identifier.
+	if size := parseIdent(d.in, false); size > 0 {
+		return d.consumeToken(Name, size, uint8(IdentName)), nil
+	}
+
+	// Field number. Identify if input is a valid number that is not negative
+	// and is decimal integer within 32-bit range.
+	if num := parseNumber(d.in); num.size > 0 {
+		if !num.neg && num.kind == numDec {
+			if _, err := strconv.ParseInt(string(d.in[:num.size]), 10, 32); err == nil {
+				return d.consumeToken(Name, num.size, uint8(FieldNumber)), nil
+			}
+		}
+		return Token{}, d.newSyntaxError("invalid field number: %s", d.in[:num.size])
+	}
+
+	return Token{}, d.newSyntaxError("invalid field name: %s", errRegexp.Find(d.in))
+}
+
+// parseTypeName parses Any type URL or extension field name. The name is
+// enclosed in [ and ] characters. The C++ parser does not handle many legal URL
+// strings. This implementation is more liberal and allows for the pattern
+// ^[-_a-zA-Z0-9]+([./][-_a-zA-Z0-9]+)*`). Whitespaces and comments are allowed
+// in between [ ], '.', '/' and the sub names.
+func (d *Decoder) parseTypeName() (Token, error) {
+	startPos := len(d.orig) - len(d.in)
+	// Use alias s to advance first in order to use d.in for error handling.
+	// Caller already checks for [ as first character.
+	s := consume(d.in[1:], 0)
+	if len(s) == 0 {
+		return Token{}, ErrUnexpectedEOF
+	}
+
+	var name []byte
+	for len(s) > 0 && isTypeNameChar(s[0]) {
+		name = append(name, s[0])
+		s = s[1:]
+	}
+	s = consume(s, 0)
+
+	var closed bool
+	for len(s) > 0 && !closed {
+		switch {
+		case s[0] == ']':
+			s = s[1:]
+			closed = true
+
+		case s[0] == '/', s[0] == '.':
+			if len(name) > 0 && (name[len(name)-1] == '/' || name[len(name)-1] == '.') {
+				return Token{}, d.newSyntaxError("invalid type URL/extension field name: %s",
+					d.orig[startPos:len(d.orig)-len(s)+1])
+			}
+			name = append(name, s[0])
+			s = s[1:]
+			s = consume(s, 0)
+			for len(s) > 0 && isTypeNameChar(s[0]) {
+				name = append(name, s[0])
+				s = s[1:]
+			}
+			s = consume(s, 0)
+
+		default:
+			return Token{}, d.newSyntaxError(
+				"invalid type URL/extension field name: %s", d.orig[startPos:len(d.orig)-len(s)+1])
+		}
+	}
+
+	if !closed {
+		return Token{}, ErrUnexpectedEOF
+	}
+
+	// First character cannot be '.'. Last character cannot be '.' or '/'.
+	size := len(name)
+	if size == 0 || name[0] == '.' || name[size-1] == '.' || name[size-1] == '/' {
+		return Token{}, d.newSyntaxError("invalid type URL/extension field name: %s",
+			d.orig[startPos:len(d.orig)-len(s)])
+	}
+
+	d.in = s
+	endPos := len(d.orig) - len(d.in)
+	d.consume(0)
+
+	return Token{
+		kind:  Name,
+		attrs: uint8(TypeName),
+		pos:   startPos,
+		raw:   d.orig[startPos:endPos],
+		str:   string(name),
+	}, nil
+}
+
+func isTypeNameChar(b byte) bool {
+	return (b == '-' || b == '_' ||
+		('0' <= b && b <= '9') ||
+		('a' <= b && b <= 'z') ||
+		('A' <= b && b <= 'Z'))
+}
+
+func isWhiteSpace(b byte) bool {
+	switch b {
+	case ' ', '\n', '\r', '\t':
+		return true
+	default:
+		return false
+	}
+}
+
+// parseIdent parses an unquoted proto identifier and returns size.
+// If allowNeg is true, it allows '-' to be the first character in the
+// identifier. This is used when parsing literal values like -infinity, etc.
+// Regular expression matches an identifier: `^[_a-zA-Z][_a-zA-Z0-9]*`
+func parseIdent(input []byte, allowNeg bool) int {
+	var size int
+
+	s := input
+	if len(s) == 0 {
+		return 0
+	}
+
+	if allowNeg && s[0] == '-' {
+		s = s[1:]
+		size++
+		if len(s) == 0 {
+			return 0
+		}
+	}
+
+	switch {
+	case s[0] == '_',
+		'a' <= s[0] && s[0] <= 'z',
+		'A' <= s[0] && s[0] <= 'Z':
+		s = s[1:]
+		size++
+	default:
+		return 0
+	}
+
+	for len(s) > 0 && (s[0] == '_' ||
+		'a' <= s[0] && s[0] <= 'z' ||
+		'A' <= s[0] && s[0] <= 'Z' ||
+		'0' <= s[0] && s[0] <= '9') {
+		s = s[1:]
+		size++
+	}
+
+	if len(s) > 0 && !isDelim(s[0]) {
+		return 0
+	}
+
+	return size
+}
+
+// parseScalar parses for a string, literal or number value.
+func (d *Decoder) parseScalar() (Token, error) {
+	if d.in[0] == '"' || d.in[0] == '\'' {
+		return d.parseStringValue()
+	}
+
+	if tok, ok := d.parseLiteralValue(); ok {
+		return tok, nil
+	}
+
+	if tok, ok := d.parseNumberValue(); ok {
+		return tok, nil
+	}
+
+	return Token{}, d.newSyntaxError("invalid scalar value: %s", errRegexp.Find(d.in))
+}
+
+// parseLiteralValue parses a literal value. A literal value is used for
+// bools, special floats and enums. This function simply identifies that the
+// field value is a literal.
+func (d *Decoder) parseLiteralValue() (Token, bool) {
+	size := parseIdent(d.in, true)
+	if size == 0 {
+		return Token{}, false
+	}
+	return d.consumeToken(Scalar, size, literalValue), true
+}
+
+// consumeToken constructs a Token for given Kind from d.in and consumes given
+// size-length from it.
+func (d *Decoder) consumeToken(kind Kind, size int, attrs uint8) Token {
+	// Important to compute raw and pos before consuming.
+	tok := Token{
+		kind:  kind,
+		attrs: attrs,
+		pos:   len(d.orig) - len(d.in),
+		raw:   d.in[:size],
+	}
+	d.consume(size)
+	return tok
+}
+
+// newSyntaxError returns a syntax error with line and column information for
+// current position.
+func (d *Decoder) newSyntaxError(f string, x ...interface{}) error {
+	e := errors.New(f, x...)
+	line, column := d.Position(len(d.orig) - len(d.in))
+	return errors.New("syntax error (line %d:%d): %v", line, column, e)
+}
+
+// Position returns line and column number of given index of the original input.
+// It will panic if index is out of range.
+func (d *Decoder) Position(idx int) (line int, column int) {
+	b := d.orig[:idx]
+	line = bytes.Count(b, []byte("\n")) + 1
+	if i := bytes.LastIndexByte(b, '\n'); i >= 0 {
+		b = b[i+1:]
+	}
+	column = utf8.RuneCount(b) + 1 // ignore multi-rune characters
+	return line, column
+}
+
+func (d *Decoder) tryConsumeChar(c byte) bool {
+	if len(d.in) > 0 && d.in[0] == c {
+		d.consume(1)
+		return true
+	}
+	return false
+}
+
+// consume consumes n bytes of input and any subsequent whitespace or comments.
+func (d *Decoder) consume(n int) {
+	d.in = consume(d.in, n)
+	return
+}
+
+// consume consumes n bytes of input and any subsequent whitespace or comments.
+func consume(b []byte, n int) []byte {
+	b = b[n:]
+	for len(b) > 0 {
+		switch b[0] {
+		case ' ', '\n', '\r', '\t':
+			b = b[1:]
+		case '#':
+			if i := bytes.IndexByte(b, '\n'); i >= 0 {
+				b = b[i+len("\n"):]
+			} else {
+				b = nil
+			}
+		default:
+			return b
+		}
+	}
+	return b
+}
+
+// Any sequence that looks like a non-delimiter (for error reporting).
+var errRegexp = regexp.MustCompile(`^([-+._a-zA-Z0-9\/]+|.)`)
+
+// isDelim returns true if given byte is a delimiter character.
+func isDelim(c byte) bool {
+	return !(c == '-' || c == '+' || c == '.' || c == '_' ||
+		('a' <= c && c <= 'z') ||
+		('A' <= c && c <= 'Z') ||
+		('0' <= c && c <= '9'))
+}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/text/decode_number.go b/vendor/google.golang.org/protobuf/internal/encoding/text/decode_number.go
new file mode 100644
index 000000000..f2d90b789
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/encoding/text/decode_number.go
@@ -0,0 +1,190 @@
+// 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 text
+
+// parseNumberValue parses a number from the input and returns a Token object.
+func (d *Decoder) parseNumberValue() (Token, bool) {
+	in := d.in
+	num := parseNumber(in)
+	if num.size == 0 {
+		return Token{}, false
+	}
+	numAttrs := num.kind
+	if num.neg {
+		numAttrs |= isNegative
+	}
+	strSize := num.size
+	last := num.size - 1
+	if num.kind == numFloat && (d.in[last] == 'f' || d.in[last] == 'F') {
+		strSize = last
+	}
+	tok := Token{
+		kind:     Scalar,
+		attrs:    numberValue,
+		pos:      len(d.orig) - len(d.in),
+		raw:      d.in[:num.size],
+		str:      string(d.in[:strSize]),
+		numAttrs: numAttrs,
+	}
+	d.consume(num.size)
+	return tok, true
+}
+
+const (
+	numDec uint8 = (1 << iota) / 2
+	numHex
+	numOct
+	numFloat
+)
+
+// number is the result of parsing out a valid number from parseNumber. It
+// contains data for doing float or integer conversion via the strconv package
+// in conjunction with the input bytes.
+type number struct {
+	kind uint8
+	neg  bool
+	size int
+}
+
+// parseNumber constructs a number object from given input. It allows for the
+// following patterns:
+//   integer: ^-?([1-9][0-9]*|0[xX][0-9a-fA-F]+|0[0-7]*)
+//   float: ^-?((0|[1-9][0-9]*)?([.][0-9]*)?([eE][+-]?[0-9]+)?[fF]?)
+// It also returns the number of parsed bytes for the given number, 0 if it is
+// not a number.
+func parseNumber(input []byte) number {
+	kind := numDec
+	var size int
+	var neg bool
+
+	s := input
+	if len(s) == 0 {
+		return number{}
+	}
+
+	// Optional -
+	if s[0] == '-' {
+		neg = true
+		s = s[1:]
+		size++
+		if len(s) == 0 {
+			return number{}
+		}
+	}
+
+	// C++ allows for whitespace and comments in between the negative sign and
+	// the rest of the number. This logic currently does not but is consistent
+	// with v1.
+
+	switch {
+	case s[0] == '0':
+		if len(s) > 1 {
+			switch {
+			case s[1] == 'x' || s[1] == 'X':
+				// Parse as hex number.
+				kind = numHex
+				n := 2
+				s = s[2:]
+				for len(s) > 0 && (('0' <= s[0] && s[0] <= '9') ||
+					('a' <= s[0] && s[0] <= 'f') ||
+					('A' <= s[0] && s[0] <= 'F')) {
+					s = s[1:]
+					n++
+				}
+				if n == 2 {
+					return number{}
+				}
+				size += n
+
+			case '0' <= s[1] && s[1] <= '7':
+				// Parse as octal number.
+				kind = numOct
+				n := 2
+				s = s[2:]
+				for len(s) > 0 && '0' <= s[0] && s[0] <= '7' {
+					s = s[1:]
+					n++
+				}
+				size += n
+			}
+
+			if kind&(numHex|numOct) > 0 {
+				if len(s) > 0 && !isDelim(s[0]) {
+					return number{}
+				}
+				return number{kind: kind, neg: neg, size: size}
+			}
+		}
+		s = s[1:]
+		size++
+
+	case '1' <= s[0] && s[0] <= '9':
+		n := 1
+		s = s[1:]
+		for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
+			s = s[1:]
+			n++
+		}
+		size += n
+
+	case s[0] == '.':
+		// Set kind to numFloat to signify the intent to parse as float. And
+		// that it needs to have other digits after '.'.
+		kind = numFloat
+
+	default:
+		return number{}
+	}
+
+	// . followed by 0 or more digits.
+	if len(s) > 0 && s[0] == '.' {
+		n := 1
+		s = s[1:]
+		// If decimal point was before any digits, it should be followed by
+		// other digits.
+		if len(s) == 0 && kind == numFloat {
+			return number{}
+		}
+		for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
+			s = s[1:]
+			n++
+		}
+		size += n
+		kind = numFloat
+	}
+
+	// e or E followed by an optional - or + and 1 or more digits.
+	if len(s) >= 2 && (s[0] == 'e' || s[0] == 'E') {
+		kind = numFloat
+		s = s[1:]
+		n := 1
+		if s[0] == '+' || s[0] == '-' {
+			s = s[1:]
+			n++
+			if len(s) == 0 {
+				return number{}
+			}
+		}
+		for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
+			s = s[1:]
+			n++
+		}
+		size += n
+	}
+
+	// Optional suffix f or F for floats.
+	if len(s) > 0 && (s[0] == 'f' || s[0] == 'F') {
+		kind = numFloat
+		s = s[1:]
+		size++
+	}
+
+	// Check that next byte is a delimiter or it is at the end.
+	if len(s) > 0 && !isDelim(s[0]) {
+		return number{}
+	}
+
+	return number{kind: kind, neg: neg, size: size}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/text/decode_string.go b/vendor/google.golang.org/protobuf/internal/encoding/text/decode_string.go
new file mode 100644
index 000000000..d4d349023
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/encoding/text/decode_string.go
@@ -0,0 +1,161 @@
+// 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 text
+
+import (
+	"bytes"
+	"strconv"
+	"strings"
+	"unicode"
+	"unicode/utf16"
+	"unicode/utf8"
+
+	"google.golang.org/protobuf/internal/strs"
+)
+
+// parseStringValue parses string field token.
+// This differs from parseString since the text format allows
+// multiple back-to-back string literals where they are semantically treated
+// as a single large string with all values concatenated.
+//
+// E.g., `"foo" "bar" "baz"` => "foobarbaz"
+func (d *Decoder) parseStringValue() (Token, error) {
+	// Note that the ending quote is sufficient to unambiguously mark the end
+	// of a string. Thus, the text grammar does not require intervening
+	// whitespace or control characters in-between strings.
+	// Thus, the following is valid:
+	//	`"foo"'bar'"baz"` => "foobarbaz"
+	in0 := d.in
+	var ss []string
+	for len(d.in) > 0 && (d.in[0] == '"' || d.in[0] == '\'') {
+		s, err := d.parseString()
+		if err != nil {
+			return Token{}, err
+		}
+		ss = append(ss, s)
+	}
+	// d.in already points to the end of the value at this point.
+	return Token{
+		kind:  Scalar,
+		attrs: stringValue,
+		pos:   len(d.orig) - len(in0),
+		raw:   in0[:len(in0)-len(d.in)],
+		str:   strings.Join(ss, ""),
+	}, nil
+}
+
+// parseString parses a string value enclosed in " or '.
+func (d *Decoder) parseString() (string, error) {
+	in := d.in
+	if len(in) == 0 {
+		return "", ErrUnexpectedEOF
+	}
+	quote := in[0]
+	in = in[1:]
+	i := indexNeedEscapeInBytes(in)
+	in, out := in[i:], in[:i:i] // set cap to prevent mutations
+	for len(in) > 0 {
+		switch r, n := utf8.DecodeRune(in); {
+		case r == utf8.RuneError && n == 1:
+			return "", d.newSyntaxError("invalid UTF-8 detected")
+		case r == 0 || r == '\n':
+			return "", d.newSyntaxError("invalid character %q in string", r)
+		case r == rune(quote):
+			in = in[1:]
+			d.consume(len(d.in) - len(in))
+			return string(out), nil
+		case r == '\\':
+			if len(in) < 2 {
+				return "", ErrUnexpectedEOF
+			}
+			switch r := in[1]; r {
+			case '"', '\'', '\\', '?':
+				in, out = in[2:], append(out, r)
+			case 'a':
+				in, out = in[2:], append(out, '\a')
+			case 'b':
+				in, out = in[2:], append(out, '\b')
+			case 'n':
+				in, out = in[2:], append(out, '\n')
+			case 'r':
+				in, out = in[2:], append(out, '\r')
+			case 't':
+				in, out = in[2:], append(out, '\t')
+			case 'v':
+				in, out = in[2:], append(out, '\v')
+			case 'f':
+				in, out = in[2:], append(out, '\f')
+			case '0', '1', '2', '3', '4', '5', '6', '7':
+				// One, two, or three octal characters.
+				n := len(in[1:]) - len(bytes.TrimLeft(in[1:], "01234567"))
+				if n > 3 {
+					n = 3
+				}
+				v, err := strconv.ParseUint(string(in[1:1+n]), 8, 8)
+				if err != nil {
+					return "", d.newSyntaxError("invalid octal escape code %q in string", in[:1+n])
+				}
+				in, out = in[1+n:], append(out, byte(v))
+			case 'x':
+				// One or two hexadecimal characters.
+				n := len(in[2:]) - len(bytes.TrimLeft(in[2:], "0123456789abcdefABCDEF"))
+				if n > 2 {
+					n = 2
+				}
+				v, err := strconv.ParseUint(string(in[2:2+n]), 16, 8)
+				if err != nil {
+					return "", d.newSyntaxError("invalid hex escape code %q in string", in[:2+n])
+				}
+				in, out = in[2+n:], append(out, byte(v))
+			case 'u', 'U':
+				// Four or eight hexadecimal characters
+				n := 6
+				if r == 'U' {
+					n = 10
+				}
+				if len(in) < n {
+					return "", ErrUnexpectedEOF
+				}
+				v, err := strconv.ParseUint(string(in[2:n]), 16, 32)
+				if utf8.MaxRune < v || err != nil {
+					return "", d.newSyntaxError("invalid Unicode escape code %q in string", in[:n])
+				}
+				in = in[n:]
+
+				r := rune(v)
+				if utf16.IsSurrogate(r) {
+					if len(in) < 6 {
+						return "", ErrUnexpectedEOF
+					}
+					v, err := strconv.ParseUint(string(in[2:6]), 16, 16)
+					r = utf16.DecodeRune(r, rune(v))
+					if in[0] != '\\' || in[1] != 'u' || r == unicode.ReplacementChar || err != nil {
+						return "", d.newSyntaxError("invalid Unicode escape code %q in string", in[:6])
+					}
+					in = in[6:]
+				}
+				out = append(out, string(r)...)
+			default:
+				return "", d.newSyntaxError("invalid escape code %q in string", in[:2])
+			}
+		default:
+			i := indexNeedEscapeInBytes(in[n:])
+			in, out = in[n+i:], append(out, in[:n+i]...)
+		}
+	}
+	return "", ErrUnexpectedEOF
+}
+
+// indexNeedEscapeInString returns the index of the character that needs
+// escaping. If no characters need escaping, this returns the input length.
+func indexNeedEscapeInBytes(b []byte) int { return indexNeedEscapeInString(strs.UnsafeString(b)) }
+
+// UnmarshalString returns an unescaped string given a textproto string value.
+// String value needs to contain single or double quotes. This is only used by
+// internal/encoding/defval package for unmarshaling bytes.
+func UnmarshalString(s string) (string, error) {
+	d := NewDecoder([]byte(s))
+	return d.parseString()
+}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/text/decode_test.go b/vendor/google.golang.org/protobuf/internal/encoding/text/decode_test.go
new file mode 100644
index 000000000..3f8047f25
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/encoding/text/decode_test.go
@@ -0,0 +1,1917 @@
+// Copyright 2019 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 text_test
+
+import (
+	"fmt"
+	"math"
+	"strings"
+	"testing"
+	"unicode/utf8"
+
+	"github.com/google/go-cmp/cmp"
+
+	"google.golang.org/protobuf/internal/encoding/text"
+	"google.golang.org/protobuf/internal/flags"
+)
+
+var eofErr = text.ErrUnexpectedEOF.Error()
+
+type R struct {
+	// K is expected Kind of the returned Token object from calling Decoder.Read.
+	K text.Kind
+	// E is expected error substring from calling Decoder.Read if set.
+	E string
+	// T contains NT (if K is Name) or ST (if K is Scalar) or nil (others)
+	T interface{}
+	// P is expected Token.Pos if set > 0.
+	P int
+	// RS is expected result from Token.RawString() if not empty.
+	RS string
+}
+
+// NT contains data for checking against a name token.
+type NT struct {
+	K text.NameKind
+	// Sep is true if name token should have separator character, else false.
+	Sep bool
+	// If K is IdentName or TypeName, invoke corresponding getter and compare against this field.
+	S string
+	// If K is FieldNumber, invoke getter and compare against this field.
+	N int32
+}
+
+// ST contains data for checking against a scalar token.
+type ST struct {
+	// checker that is expected to return OK.
+	ok checker
+	// checker that is expected to return not OK.
+	nok checker
+}
+
+// checker provides API for the token wrapper API call types Str, Enum, Bool,
+// Uint64, Uint32, Int64, Int32, Float64, Float32.
+type checker interface {
+	// checkOk checks and expects for token API call to return ok and compare
+	// against implementation-stored value. Returns empty string if success,
+	// else returns error message describing the error.
+	checkOk(text.Token) string
+	// checkNok checks and expects for token API call to return not ok. Returns
+	// empty string if success, else returns error message describing the error.
+	checkNok(text.Token) string
+}
+
+type Str struct {
+	val string
+}
+
+func (s Str) checkOk(tok text.Token) string {
+	got, ok := tok.String()
+	if !ok {
+		return fmt.Sprintf("Token.String() returned not OK for token: %v", tok.RawString())
+	}
+	if got != s.val {
+		return fmt.Sprintf("Token.String() got %q want %q for token: %v", got, s.val, tok.RawString())
+	}
+	return ""
+}
+
+func (s Str) checkNok(tok text.Token) string {
+	if _, ok := tok.String(); ok {
+		return fmt.Sprintf("Token.String() returned OK for token: %v", tok.RawString())
+	}
+	return ""
+}
+
+type Enum struct {
+	val string
+}
+
+func (e Enum) checkOk(tok text.Token) string {
+	got, ok := tok.Enum()
+	if !ok {
+		return fmt.Sprintf("Token.Enum() returned not OK for token: %v", tok.RawString())
+	}
+	if got != e.val {
+		return fmt.Sprintf("Token.Enum() got %q want %q for token: %v", got, e.val, tok.RawString())
+	}
+	return ""
+}
+
+func (e Enum) checkNok(tok text.Token) string {
+	if _, ok := tok.Enum(); ok {
+		return fmt.Sprintf("Token.Enum() returned OK for token: %v", tok.RawString())
+	}
+	return ""
+}
+
+type Bool struct {
+	val bool
+}
+
+func (b Bool) checkOk(tok text.Token) string {
+	got, ok := tok.Bool()
+	if !ok {
+		return fmt.Sprintf("Token.Bool() returned not OK for token: %v", tok.RawString())
+	}
+	if got != b.val {
+		return fmt.Sprintf("Token.Bool() got %v want %v for token: %v", got, b.val, tok.RawString())
+	}
+	return ""
+}
+
+func (b Bool) checkNok(tok text.Token) string {
+	if _, ok := tok.Bool(); ok {
+		return fmt.Sprintf("Token.Bool() returned OK for token: %v", tok.RawString())
+	}
+	return ""
+}
+
+type Uint64 struct {
+	val uint64
+}
+
+func (n Uint64) checkOk(tok text.Token) string {
+	got, ok := tok.Uint64()
+	if !ok {
+		return fmt.Sprintf("Token.Uint64() returned not OK for token: %v", tok.RawString())
+	}
+	if got != n.val {
+		return fmt.Sprintf("Token.Uint64() got %v want %v for token: %v", got, n.val, tok.RawString())
+	}
+	return ""
+}
+
+func (n Uint64) checkNok(tok text.Token) string {
+	if _, ok := tok.Uint64(); ok {
+		return fmt.Sprintf("Token.Uint64() returned OK for token: %v", tok.RawString())
+	}
+	return ""
+}
+
+type Uint32 struct {
+	val uint32
+}
+
+func (n Uint32) checkOk(tok text.Token) string {
+	got, ok := tok.Uint32()
+	if !ok {
+		return fmt.Sprintf("Token.Uint32() returned not OK for token: %v", tok.RawString())
+	}
+	if got != n.val {
+		return fmt.Sprintf("Token.Uint32() got %v want %v for token: %v", got, n.val, tok.RawString())
+	}
+	return ""
+}
+
+func (n Uint32) checkNok(tok text.Token) string {
+	if _, ok := tok.Uint32(); ok {
+		return fmt.Sprintf("Token.Uint32() returned OK for token: %v", tok.RawString())
+	}
+	return ""
+}
+
+type Int64 struct {
+	val int64
+}
+
+func (n Int64) checkOk(tok text.Token) string {
+	got, ok := tok.Int64()
+	if !ok {
+		return fmt.Sprintf("Token.Int64() returned not OK for token: %v", tok.RawString())
+	}
+	if got != n.val {
+		return fmt.Sprintf("Token.Int64() got %v want %v for token: %v", got, n.val, tok.RawString())
+	}
+	return ""
+}
+
+func (n Int64) checkNok(tok text.Token) string {
+	if _, ok := tok.Int64(); ok {
+		return fmt.Sprintf("Token.Int64() returned OK for token: %v", tok.RawString())
+	}
+	return ""
+}
+
+type Int32 struct {
+	val int32
+}
+
+func (n Int32) checkOk(tok text.Token) string {
+	got, ok := tok.Int32()
+	if !ok {
+		return fmt.Sprintf("Token.Int32() returned not OK for token: %v", tok.RawString())
+	}
+	if got != n.val {
+		return fmt.Sprintf("Token.Int32() got %v want %v for token: %v", got, n.val, tok.RawString())
+	}
+	return ""
+}
+
+func (n Int32) checkNok(tok text.Token) string {
+	if _, ok := tok.Int32(); ok {
+		return fmt.Sprintf("Token.Int32() returned OK for token: %v", tok.RawString())
+	}
+	return ""
+}
+
+type Float64 struct {
+	val float64
+}
+
+func (n Float64) checkOk(tok text.Token) string {
+	got, ok := tok.Float64()
+	if !ok {
+		return fmt.Sprintf("Token.Float64() returned not OK for token: %v", tok.RawString())
+	}
+	if math.IsNaN(got) && math.IsNaN(n.val) {
+		return ""
+	}
+	if got != n.val {
+		return fmt.Sprintf("Token.Float64() got %v want %v for token: %v", got, n.val, tok.RawString())
+	}
+	return ""
+}
+
+func (n Float64) checkNok(tok text.Token) string {
+	if _, ok := tok.Float64(); ok {
+		return fmt.Sprintf("Token.Float64() returned OK for token: %v", tok.RawString())
+	}
+	return ""
+}
+
+type Float32 struct {
+	val float32
+}
+
+func (n Float32) checkOk(tok text.Token) string {
+	got, ok := tok.Float32()
+	if !ok {
+		return fmt.Sprintf("Token.Float32() returned not OK for token: %v", tok.RawString())
+	}
+	if math.IsNaN(float64(got)) && math.IsNaN(float64(n.val)) {
+		return ""
+	}
+	if got != n.val {
+		return fmt.Sprintf("Token.Float32() got %v want %v for token: %v", got, n.val, tok.RawString())
+	}
+	return ""
+}
+
+func (n Float32) checkNok(tok text.Token) string {
+	if _, ok := tok.Float32(); ok {
+		return fmt.Sprintf("Token.Float32() returned OK for token: %v", tok.RawString())
+	}
+	return ""
+}
+
+func TestDecoder(t *testing.T) {
+	const space = " \n\r\t"
+	tests := []struct {
+		in string
+		// want is a list of expected Tokens returned from calling Decoder.Read.
+		// An item makes the test code invoke Decoder.Read and compare against
+		// R.K and R.E. If R.K is Name, it compares
+		want []R
+	}{
+		{
+			in:   "",
+			want: []R{{K: text.EOF}},
+		},
+		{
+			in:   "# comment",
+			want: []R{{K: text.EOF}},
+		},
+		{
+			in:   space + "# comment" + space,
+			want: []R{{K: text.EOF}},
+		},
+		{
+			in:   space,
+			want: []R{{K: text.EOF, P: len(space)}},
+		},
+		{
+			// Calling Read after EOF will keep returning EOF for
+			// succeeding Read calls.
+			in: space,
+			want: []R{
+				{K: text.EOF},
+				{K: text.EOF},
+				{K: text.EOF},
+			},
+		},
+		{
+			// NUL is an invalid whitespace since C++ uses C-strings.
+			in:   "\x00",
+			want: []R{{E: "invalid field name: \x00"}},
+		},
+
+		// Field names.
+		{
+			in: "name",
+			want: []R{
+				{K: text.Name, T: NT{K: text.IdentName, S: "name"}, RS: "name"},
+				{E: eofErr},
+			},
+		},
+		{
+			in: space + "name:" + space,
+			want: []R{
+				{K: text.Name, T: NT{K: text.IdentName, Sep: true, S: "name"}},
+				{E: eofErr},
+			},
+		},
+		{
+			in: space + "name" + space + ":" + space,
+			want: []R{
+				{K: text.Name, T: NT{K: text.IdentName, Sep: true, S: "name"}},
+				{E: eofErr},
+			},
+		},
+		{
+			in: "name # comment",
+			want: []R{
+				{K: text.Name, T: NT{K: text.IdentName, S: "name"}},
+				{E: eofErr},
+			},
+		},
+		{
+			// Comments only extend until the newline.
+			in: "# comment \nname",
+			want: []R{
+				{K: text.Name, T: NT{K: text.IdentName, S: "name"}, P: 11},
+			},
+		},
+		{
+			in: "name # comment \n:",
+			want: []R{
+				{K: text.Name, T: NT{K: text.IdentName, Sep: true, S: "name"}},
+			},
+		},
+		{
+			in: "name123",
+			want: []R{
+				{K: text.Name, T: NT{K: text.IdentName, S: "name123"}},
+			},
+		},
+		{
+			in: "name_123",
+			want: []R{
+				{K: text.Name, T: NT{K: text.IdentName, S: "name_123"}},
+			},
+		},
+		{
+			in: "_123",
+			want: []R{
+				{K: text.Name, T: NT{K: text.IdentName, S: "_123"}},
+			},
+		},
+		{
+			in:   ":",
+			want: []R{{E: "syntax error (line 1:1): invalid field name: :"}},
+		},
+		{
+			in:   "\n\n\n {",
+			want: []R{{E: "syntax error (line 4:2): invalid field name: {"}},
+		},
+		{
+			in:   "123name",
+			want: []R{{E: "invalid field name: 123name"}},
+		},
+		{
+			in: "[type]",
+			want: []R{
+				{K: text.Name, T: NT{K: text.TypeName, S: "type"}, RS: "[type]"},
+			},
+		},
+		{
+			// V1 allows this syntax. C++ does not, however, C++ also fails if
+			// field is Any and does not contain '/'.
+			in: "[/type]",
+			want: []R{
+				{K: text.Name, T: NT{K: text.TypeName, S: "/type"}},
+			},
+		},
+		{
+			in:   "[.type]",
+			want: []R{{E: "invalid type URL/extension field name: [.type]"}},
+		},
+		{
+			in: "[pkg.Foo.extension_field]",
+			want: []R{
+				{K: text.Name, T: NT{K: text.TypeName, S: "pkg.Foo.extension_field"}},
+			},
+		},
+		{
+			in: "[domain.com/type]",
+			want: []R{
+				{K: text.Name, T: NT{K: text.TypeName, S: "domain.com/type"}},
+			},
+		},
+		{
+			in: "[domain.com/pkg.type]",
+			want: []R{
+				{K: text.Name, T: NT{K: text.TypeName, S: "domain.com/pkg.type"}},
+			},
+		},
+		{
+			in: "[sub.domain.com\x2fpath\x2fto\x2fproto.package.name]",
+			want: []R{
+				{
+					K: text.Name,
+					T: NT{
+						K: text.TypeName,
+						S: "sub.domain.com/path/to/proto.package.name",
+					},
+					RS: "[sub.domain.com\x2fpath\x2fto\x2fproto.package.name]",
+				},
+			},
+		},
+		{
+			// V2 no longer allows a quoted string for the Any type URL.
+			in:   `["domain.com/pkg.type"]`,
+			want: []R{{E: `invalid type URL/extension field name: ["`}},
+		},
+		{
+			// V2 no longer allows a quoted string for the Any type URL.
+			in:   `['domain.com/pkg.type']`,
+			want: []R{{E: `invalid type URL/extension field name: ['`}},
+		},
+		{
+			in:   "[pkg.Foo.extension_field:",
+			want: []R{{E: "invalid type URL/extension field name: [pkg.Foo.extension_field:"}},
+		},
+		{
+			// V2 no longer allows whitespace within identifier "word".
+			in:   "[proto.packa ge.field]",
+			want: []R{{E: "invalid type URL/extension field name: [proto.packa g"}},
+		},
+		{
+			// V2 no longer allows comments within identifier "word".
+			in:   "[proto.packa # comment\n ge.field]",
+			want: []R{{E: "invalid type URL/extension field name: [proto.packa # comment\n g"}},
+		},
+		{
+			in:   "[proto.package.]",
+			want: []R{{E: "invalid type URL/extension field name: [proto.package."}},
+		},
+		{
+			in:   "[proto.package/]",
+			want: []R{{E: "invalid type URL/extension field name: [proto.package/"}},
+		},
+		{
+			in: `message_field{[bad@]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.MessageOpen},
+				{E: `invalid type URL/extension field name: [bad@`},
+			},
+		},
+		{
+			in: `message_field{[invalid//type]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.MessageOpen},
+				{E: `invalid type URL/extension field name: [invalid//`},
+			},
+		},
+		{
+			in: `message_field{[proto.package.]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.MessageOpen},
+				{E: `invalid type URL/extension field name: [proto.package.`},
+			},
+		},
+		{
+			in:   "[proto.package",
+			want: []R{{E: eofErr}},
+		},
+		{
+			in: "[" + space + "type" + space + "]" + space + ":",
+			want: []R{
+				{
+					K: text.Name,
+					T: NT{
+						K:   text.TypeName,
+						Sep: true,
+						S:   "type",
+					},
+					RS: "[" + space + "type" + space + "]",
+				},
+			},
+		},
+		{
+			// Whitespaces/comments are only allowed betweeb
+			in: "[" + space + "domain" + space + "." + space + "com # comment\n" +
+				"/" + "pkg" + space + "." + space + "type" + space + "]",
+			want: []R{
+				{K: text.Name, T: NT{K: text.TypeName, S: "domain.com/pkg.type"}},
+			},
+		},
+		{
+			in: "42",
+			want: []R{
+				{K: text.Name, T: NT{K: text.FieldNumber, N: 42}},
+			},
+		},
+		{
+			in:   "0x42:",
+			want: []R{{E: "invalid field number: 0x42"}},
+		},
+		{
+			in:   "042:",
+			want: []R{{E: "invalid field number: 042"}},
+		},
+		{
+			in:   "123.456:",
+			want: []R{{E: "invalid field number: 123.456"}},
+		},
+		{
+			in:   "-123",
+			want: []R{{E: "invalid field number: -123"}},
+		},
+		{
+			// Field number > math.MaxInt32.
+			in:   "2147483648:",
+			want: []R{{E: "invalid field number: 2147483648"}},
+		},
+
+		// String field value. More string parsing specific testing in
+		// TestUnmarshalString.
+		{
+			in: `name: "hello world"`,
+			want: []R{
+				{K: text.Name},
+				{
+					K:  text.Scalar,
+					T:  ST{ok: Str{"hello world"}, nok: Enum{}},
+					RS: `"hello world"`,
+				},
+				{K: text.EOF},
+			},
+		},
+		{
+			in: `name: 'hello'`,
+			want: []R{
+				{K: text.Name},
+				{K: text.Scalar, T: ST{ok: Str{"hello"}}},
+			},
+		},
+		{
+			in: `name: "hello'`,
+			want: []R{
+				{K: text.Name},
+				{E: eofErr},
+			},
+		},
+		{
+			in: `name: 'hello`,
+			want: []R{
+				{K: text.Name},
+				{E: eofErr},
+			},
+		},
+		{
+			// Field name without separator is ok. prototext package will need
+			// to determine that this is not valid for scalar values.
+			in: space + `name` + space + `"hello"` + space,
+			want: []R{
+				{K: text.Name},
+				{K: text.Scalar, T: ST{ok: Str{"hello"}}},
+			},
+		},
+		{
+			in: `name'hello'`,
+			want: []R{
+				{K: text.Name},
+				{K: text.Scalar, T: ST{ok: Str{"hello"}}},
+			},
+		},
+		{
+			in: `name: ` + space + `"hello"` + space + `,`,
+			want: []R{
+				{K: text.Name},
+				{K: text.Scalar, T: ST{ok: Str{"hello"}}},
+				{K: text.EOF},
+			},
+		},
+		{
+			in: `name` + space + `:` + `"hello"` + space + `;` + space,
+			want: []R{
+				{K: text.Name},
+				{K: text.Scalar, T: ST{ok: Str{"hello"}}},
+				{K: text.EOF},
+			},
+		},
+		{
+			in: `name:"hello" , ,`,
+			want: []R{
+				{K: text.Name},
+				{K: text.Scalar},
+				{E: "(line 1:16): invalid field name: ,"},
+			},
+		},
+		{
+			in: `name:"hello" , ;`,
+			want: []R{
+				{K: text.Name},
+				{K: text.Scalar},
+				{E: "(line 1:16): invalid field name: ;"},
+			},
+		},
+		{
+			in: `name:"hello" name:'world'`,
+			want: []R{
+				{K: text.Name},
+				{K: text.Scalar, T: ST{ok: Str{"hello"}}},
+				{K: text.Name},
+				{K: text.Scalar, T: ST{ok: Str{"world"}}},
+				{K: text.EOF},
+			},
+		},
+		{
+			in: `name:"hello", name:"world"`,
+			want: []R{
+				{K: text.Name},
+				{K: text.Scalar, T: ST{ok: Str{"hello"}}},
+				{K: text.Name},
+				{K: text.Scalar, T: ST{ok: Str{"world"}}},
+				{K: text.EOF},
+			},
+		},
+		{
+			in: `name:"hello"; name:"world",`,
+			want: []R{
+				{K: text.Name},
+				{K: text.Scalar, T: ST{ok: Str{"hello"}}},
+				{K: text.Name},
+				{K: text.Scalar, T: ST{ok: Str{"world"}}},
+				{K: text.EOF},
+			},
+		},
+		{
+			in: `foo:"hello"bar:"world"`,
+			want: []R{
+				{K: text.Name, T: NT{K: text.IdentName, Sep: true, S: "foo"}},
+				{K: text.Scalar, T: ST{ok: Str{"hello"}}},
+				{K: text.Name, T: NT{K: text.IdentName, Sep: true, S: "bar"}},
+				{K: text.Scalar, T: ST{ok: Str{"world"}}},
+				{K: text.EOF},
+			},
+		},
+		{
+			in: `foo:"hello"[bar]:"world"`,
+			want: []R{
+				{K: text.Name, T: NT{K: text.IdentName, Sep: true, S: "foo"}},
+				{K: text.Scalar, T: ST{ok: Str{"hello"}}},
+				{K: text.Name, T: NT{K: text.TypeName, Sep: true, S: "bar"}},
+				{K: text.Scalar, T: ST{ok: Str{"world"}}},
+				{K: text.EOF},
+			},
+		},
+		{
+			in: `name:"foo"` + space + `"bar"` + space + `'qux'`,
+			want: []R{
+				{K: text.Name, T: NT{K: text.IdentName, Sep: true, S: "name"}},
+				{K: text.Scalar, T: ST{ok: Str{"foobarqux"}}},
+				{K: text.EOF},
+			},
+		},
+		{
+			in: `name:"foo"'bar'"qux"`,
+			want: []R{
+				{K: text.Name, T: NT{K: text.IdentName, Sep: true, S: "name"}},
+				{K: text.Scalar, T: ST{ok: Str{"foobarqux"}}},
+				{K: text.EOF},
+			},
+		},
+		{
+			in: `name:"foo"` + space + `"bar" # comment` + "\n'qux' # comment",
+			want: []R{
+				{K: text.Name, T: NT{K: text.IdentName, Sep: true, S: "name"}},
+				{K: text.Scalar, T: ST{ok: Str{"foobarqux"}}},
+				{K: text.EOF},
+			},
+		},
+
+		// Lists.
+		{
+			in: `name: [`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{E: eofErr},
+			},
+		},
+		{
+			in: `name: []`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.ListClose},
+				{K: text.EOF},
+			},
+		},
+		{
+			in: `name []`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.ListClose},
+				{K: text.EOF},
+			},
+		},
+		{
+			in: `name: [,`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{E: `(line 1:8): invalid scalar value: ,`},
+			},
+		},
+		{
+			in: `name: [0`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar},
+				{E: eofErr},
+			},
+		},
+		{
+			in: `name: [` + space + `"hello"` + space + `]` + space,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{ok: Str{"hello"}}, P: len(space) + 7},
+				{K: text.ListClose},
+				{K: text.EOF},
+			},
+		},
+		{
+			in: `name: ["hello",]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{ok: Str{"hello"}}},
+				{E: `invalid scalar value: ]`},
+			},
+		},
+		{
+			in: `name: ["foo"` + space + `'bar' "qux"]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{ok: Str{"foobarqux"}}},
+				{K: text.ListClose},
+				{K: text.EOF},
+			},
+		},
+		{
+			in: `name:` + space + `["foo",` + space + "'bar', # comment\n\n" + `"qux"]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{ok: Str{"foo"}}},
+				{K: text.Scalar, T: ST{ok: Str{"bar"}}},
+				{K: text.Scalar, T: ST{ok: Str{"qux"}}},
+				{K: text.ListClose},
+				{K: text.EOF},
+			},
+		},
+
+		{
+			// List within list is not allowed.
+			in: `name: [[]]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{E: `syntax error (line 1:8): invalid scalar value: [`},
+			},
+		},
+		{
+			// List items need to be separated by ,.
+			in: `name: ["foo" true]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{ok: Str{"foo"}}},
+				{E: `syntax error (line 1:14): unexpected character 't'`},
+			},
+		},
+		{
+			in: `name: ["foo"; "bar"]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{ok: Str{"foo"}}},
+				{E: `syntax error (line 1:13): unexpected character ';'`},
+			},
+		},
+		{
+			in: `name: ["foo", true, ENUM, 1.0]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{ok: Str{"foo"}}},
+				{K: text.Scalar, T: ST{ok: Enum{"true"}}},
+				{K: text.Scalar, T: ST{ok: Enum{"ENUM"}}},
+				{K: text.Scalar, T: ST{ok: Float32{1.0}}},
+				{K: text.ListClose},
+			},
+		},
+
+		// Boolean literal values.
+		{
+			in: `name: True`,
+			want: []R{
+				{K: text.Name},
+				{
+					K: text.Scalar,
+					T: ST{ok: Bool{true}},
+				},
+				{K: text.EOF},
+			},
+		},
+		{
+			in: `name false`,
+			want: []R{
+				{K: text.Name},
+				{
+					K: text.Scalar,
+					T: ST{ok: Bool{false}},
+				},
+				{K: text.EOF},
+			},
+		},
+		{
+			in: `name: [t, f, True, False, true, false, 1, 0, 0x01, 0x00, 01, 00]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{ok: Bool{true}}},
+				{K: text.Scalar, T: ST{ok: Bool{false}}},
+				{K: text.Scalar, T: ST{ok: Bool{true}}},
+				{K: text.Scalar, T: ST{ok: Bool{false}}},
+				{K: text.Scalar, T: ST{ok: Bool{true}}},
+				{K: text.Scalar, T: ST{ok: Bool{false}}},
+				{K: text.Scalar, T: ST{ok: Bool{true}}},
+				{K: text.Scalar, T: ST{ok: Bool{false}}},
+				{K: text.Scalar, T: ST{ok: Bool{true}}},
+				{K: text.Scalar, T: ST{ok: Bool{false}}},
+				{K: text.Scalar, T: ST{ok: Bool{true}}},
+				{K: text.Scalar, T: ST{ok: Bool{false}}},
+				{K: text.ListClose},
+			},
+		},
+		{
+			// Looks like boolean but not.
+			in: `name: [tRUe, falSE, -1, -0, -0x01, -0x00, -01, -00, 0.0]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{nok: Bool{}}},
+				{K: text.Scalar, T: ST{nok: Bool{}}},
+				{K: text.Scalar, T: ST{nok: Bool{}}},
+				{K: text.Scalar, T: ST{nok: Bool{}}},
+				{K: text.Scalar, T: ST{nok: Bool{}}},
+				{K: text.Scalar, T: ST{nok: Bool{}}},
+				{K: text.Scalar, T: ST{nok: Bool{}}},
+				{K: text.Scalar, T: ST{nok: Bool{}}},
+				{K: text.Scalar, T: ST{nok: Bool{}}},
+				{K: text.ListClose},
+			},
+		},
+		{
+			in: `foo: true[bar] false`,
+			want: []R{
+				{K: text.Name},
+				{K: text.Scalar, T: ST{ok: Bool{true}}},
+				{K: text.Name},
+				{K: text.Scalar, T: ST{ok: Bool{false}}},
+			},
+		},
+
+		// Enum field values.
+		{
+			in: space + `name: ENUM`,
+			want: []R{
+				{K: text.Name},
+				{K: text.Scalar, T: ST{ok: Enum{"ENUM"}}},
+			},
+		},
+		{
+			in: space + `name:[TRUE, FALSE, T, F, t, f]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{ok: Enum{"TRUE"}}},
+				{K: text.Scalar, T: ST{ok: Enum{"FALSE"}}},
+				{K: text.Scalar, T: ST{ok: Enum{"T"}}},
+				{K: text.Scalar, T: ST{ok: Enum{"F"}}},
+				{K: text.Scalar, T: ST{ok: Enum{"t"}}},
+				{K: text.Scalar, T: ST{ok: Enum{"f"}}},
+				{K: text.ListClose},
+			},
+		},
+		{
+			in: `foo: Enum1[bar]:Enum2`,
+			want: []R{
+				{K: text.Name},
+				{K: text.Scalar, T: ST{ok: Enum{"Enum1"}}},
+				{K: text.Name},
+				{K: text.Scalar, T: ST{ok: Enum{"Enum2"}}},
+			},
+		},
+		{
+			// Invalid enum values.
+			in: `name: [-inf, -foo, "string", 42, 1.0, 0x47]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{nok: Enum{}}},
+				{K: text.Scalar, T: ST{nok: Enum{}}},
+				{K: text.Scalar, T: ST{nok: Enum{}}},
+				{K: text.Scalar, T: ST{nok: Enum{}}},
+				{K: text.Scalar, T: ST{nok: Enum{}}},
+				{K: text.Scalar, T: ST{nok: Enum{}}},
+				{K: text.ListClose},
+			},
+		},
+		{
+			in: `name: true.`,
+			want: []R{
+				{K: text.Name},
+				{E: `invalid scalar value: true.`},
+			},
+		},
+
+		// Numeric values.
+		{
+			in: `nums:42 nums:0x2A nums:052`,
+			want: []R{
+				{K: text.Name},
+				{K: text.Scalar, T: ST{ok: Uint64{42}}},
+				{K: text.Name},
+				{K: text.Scalar, T: ST{ok: Uint64{42}}},
+				{K: text.Name},
+				{K: text.Scalar, T: ST{ok: Uint64{42}}},
+			},
+		},
+		{
+			in: `nums:[-42, -0x2a, -052]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{nok: Uint64{}}},
+				{K: text.Scalar, T: ST{nok: Uint64{}}},
+				{K: text.Scalar, T: ST{nok: Uint64{}}},
+				{K: text.ListClose},
+			},
+		},
+		{
+			in: `nums:[-42, -0x2a, -052]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{ok: Int64{-42}}},
+				{K: text.Scalar, T: ST{ok: Int64{-42}}},
+				{K: text.Scalar, T: ST{ok: Int64{-42}}},
+				{K: text.ListClose},
+			},
+		},
+		{
+			in: `nums: [0,0x0,00,-9876543210,9876543210,0x0123456789abcdef,-0x0123456789abcdef,01234567,-01234567]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{ok: Uint64{0}}},
+				{K: text.Scalar, T: ST{ok: Int64{0}}},
+				{K: text.Scalar, T: ST{ok: Uint64{0}}},
+				{K: text.Scalar, T: ST{ok: Int64{-9876543210}}},
+				{K: text.Scalar, T: ST{ok: Uint64{9876543210}}},
+				{K: text.Scalar, T: ST{ok: Uint64{0x0123456789abcdef}}},
+				{K: text.Scalar, T: ST{ok: Int64{-0x0123456789abcdef}}},
+				{K: text.Scalar, T: ST{ok: Uint64{01234567}}},
+				{K: text.Scalar, T: ST{ok: Int64{-01234567}}},
+				{K: text.ListClose},
+			},
+		},
+		{
+			in: `nums: [0,0x0,00,-876543210,876543210,0x01234,-0x01234,01234567,-01234567]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{ok: Uint32{0}}},
+				{K: text.Scalar, T: ST{ok: Int32{0}}},
+				{K: text.Scalar, T: ST{ok: Uint32{0}}},
+				{K: text.Scalar, T: ST{ok: Int32{-876543210}}},
+				{K: text.Scalar, T: ST{ok: Uint32{876543210}}},
+				{K: text.Scalar, T: ST{ok: Uint32{0x01234}}},
+				{K: text.Scalar, T: ST{ok: Int32{-0x01234}}},
+				{K: text.Scalar, T: ST{ok: Uint32{01234567}}},
+				{K: text.Scalar, T: ST{ok: Int32{-01234567}}},
+				{K: text.ListClose},
+			},
+		},
+		{
+			in: `nums: [` +
+				fmt.Sprintf("%d", uint64(math.MaxUint64)) + `,` +
+				fmt.Sprintf("%d", uint32(math.MaxUint32)) + `,` +
+				fmt.Sprintf("%d", math.MaxInt64) + `,` +
+				fmt.Sprintf("%d", math.MinInt64) + `,` +
+				fmt.Sprintf("%d", math.MaxInt32) + `,` +
+				fmt.Sprintf("%d", math.MinInt32) +
+				`]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{ok: Uint64{math.MaxUint64}}},
+				{K: text.Scalar, T: ST{ok: Uint32{math.MaxUint32}}},
+				{K: text.Scalar, T: ST{ok: Int64{math.MaxInt64}}},
+				{K: text.Scalar, T: ST{ok: Int64{math.MinInt64}}},
+				{K: text.Scalar, T: ST{ok: Int32{math.MaxInt32}}},
+				{K: text.Scalar, T: ST{ok: Int32{math.MinInt32}}},
+				{K: text.ListClose},
+			},
+		},
+		{
+			// Integer exceeds range.
+			in: `nums: [` +
+				`18446744073709551616,` + // max uint64 + 1
+				fmt.Sprintf("%d", uint64(math.MaxUint32+1)) + `,` +
+				fmt.Sprintf("%d", uint64(math.MaxInt64+1)) + `,` +
+				`-9223372036854775809,` + // min int64 - 1
+				fmt.Sprintf("%d", uint64(math.MaxInt32+1)) + `,` +
+				fmt.Sprintf("%d", int64(math.MinInt32-1)) + `` +
+				`]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{nok: Uint64{}}},
+				{K: text.Scalar, T: ST{nok: Uint32{}}},
+				{K: text.Scalar, T: ST{nok: Int64{}}},
+				{K: text.Scalar, T: ST{nok: Int64{}}},
+				{K: text.Scalar, T: ST{nok: Int32{}}},
+				{K: text.Scalar, T: ST{nok: Int32{}}},
+				{K: text.ListClose},
+			},
+		},
+		{
+			in: `nums: [0xbeefbeef, 0xbeefbeefbeefbeef]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{
+					K: text.Scalar,
+					T: func() ST {
+						if flags.ProtoLegacy {
+							return ST{ok: Int32{-1091584273}}
+						}
+						return ST{nok: Int32{}}
+					}(),
+				},
+				{
+					K: text.Scalar,
+					T: func() ST {
+						if flags.ProtoLegacy {
+							return ST{ok: Int64{-4688318750159552785}}
+						}
+						return ST{nok: Int64{}}
+					}(),
+				},
+				{K: text.ListClose},
+			},
+		},
+		{
+			in: `nums: [0.,0f,1f,10f,-0f,-1f,-10f,1.0,0.1e-3,1.5e+5,1e10,.0]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{ok: Float64{0.0}}},
+				{K: text.Scalar, T: ST{ok: Float64{0.0}}},
+				{K: text.Scalar, T: ST{ok: Float64{1.0}}},
+				{K: text.Scalar, T: ST{ok: Float64{10.0}}},
+				{K: text.Scalar, T: ST{ok: Float64{-0.0}}},
+				{K: text.Scalar, T: ST{ok: Float64{-1.0}}},
+				{K: text.Scalar, T: ST{ok: Float64{-10.0}}},
+				{K: text.Scalar, T: ST{ok: Float64{1.0}}},
+				{K: text.Scalar, T: ST{ok: Float64{0.1e-3}}},
+				{K: text.Scalar, T: ST{ok: Float64{1.5e+5}}},
+				{K: text.Scalar, T: ST{ok: Float64{1.0e+10}}},
+				{K: text.Scalar, T: ST{ok: Float64{0.0}}},
+				{K: text.ListClose},
+			},
+		},
+		{
+			in: `nums: [0.,0f,1f,10f,-0f,-1f,-10f,1.0,0.1e-3,1.5e+5,1e10,.0]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{ok: Float32{0.0}}},
+				{K: text.Scalar, T: ST{ok: Float32{0.0}}},
+				{K: text.Scalar, T: ST{ok: Float32{1.0}}},
+				{K: text.Scalar, T: ST{ok: Float32{10.0}}},
+				{K: text.Scalar, T: ST{ok: Float32{-0.0}}},
+				{K: text.Scalar, T: ST{ok: Float32{-1.0}}},
+				{K: text.Scalar, T: ST{ok: Float32{-10.0}}},
+				{K: text.Scalar, T: ST{ok: Float32{1.0}}},
+				{K: text.Scalar, T: ST{ok: Float32{0.1e-3}}},
+				{K: text.Scalar, T: ST{ok: Float32{1.5e+5}}},
+				{K: text.Scalar, T: ST{ok: Float32{1.0e+10}}},
+				{K: text.Scalar, T: ST{ok: Float32{0.0}}},
+				{K: text.ListClose},
+			},
+		},
+		{
+			in: `nums: [0.,1f,10F,1e1,1.10]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{nok: Int64{}}},
+				{K: text.Scalar, T: ST{nok: Int64{}}},
+				{K: text.Scalar, T: ST{nok: Int64{}}},
+				{K: text.Scalar, T: ST{nok: Int64{}}},
+				{K: text.Scalar, T: ST{nok: Int64{}}},
+				{K: text.ListClose},
+			},
+		},
+		{
+			in: `nums: [0.,1f,10F,1e1,1.10]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{nok: Int32{}}},
+				{K: text.Scalar, T: ST{nok: Int32{}}},
+				{K: text.Scalar, T: ST{nok: Int32{}}},
+				{K: text.Scalar, T: ST{nok: Int32{}}},
+				{K: text.Scalar, T: ST{nok: Int32{}}},
+				{K: text.ListClose},
+			},
+		},
+		{
+			in: `nums: [0.,1f,10F,1e1,1.10]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{nok: Uint64{}}},
+				{K: text.Scalar, T: ST{nok: Uint64{}}},
+				{K: text.Scalar, T: ST{nok: Uint64{}}},
+				{K: text.Scalar, T: ST{nok: Uint64{}}},
+				{K: text.Scalar, T: ST{nok: Uint64{}}},
+				{K: text.ListClose},
+			},
+		},
+		{
+			in: `nums: [0.,1f,10F,1e1,1.10]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{nok: Uint32{}}},
+				{K: text.Scalar, T: ST{nok: Uint32{}}},
+				{K: text.Scalar, T: ST{nok: Uint32{}}},
+				{K: text.Scalar, T: ST{nok: Uint32{}}},
+				{K: text.Scalar, T: ST{nok: Uint32{}}},
+				{K: text.ListClose},
+			},
+		},
+		{
+			in: `nums: [` +
+				fmt.Sprintf("%g", math.MaxFloat32) + `,` +
+				fmt.Sprintf("%g", -math.MaxFloat32) + `,` +
+				fmt.Sprintf("%g", math.MaxFloat32*2) + `,` +
+				fmt.Sprintf("%g", -math.MaxFloat32*2) + `,` +
+				`3.59539e+308,` + // math.MaxFloat64 * 2
+				`-3.59539e+308,` + // -math.MaxFloat64 * 2
+				fmt.Sprintf("%d000", uint64(math.MaxUint64)) +
+				`]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{ok: Float32{float32(math.MaxFloat32)}}},
+				{K: text.Scalar, T: ST{ok: Float32{float32(-math.MaxFloat32)}}},
+				{K: text.Scalar, T: ST{ok: Float32{float32(math.Inf(1))}}},
+				{K: text.Scalar, T: ST{ok: Float32{float32(math.Inf(-1))}}},
+				{K: text.Scalar, T: ST{ok: Float32{float32(math.Inf(1))}}},
+				{K: text.Scalar, T: ST{ok: Float32{float32(math.Inf(-1))}}},
+				{K: text.Scalar, T: ST{ok: Float32{float32(math.MaxUint64) * 1000}}},
+				{K: text.ListClose},
+			},
+		},
+		{
+			in: `nums: [` +
+				fmt.Sprintf("%g", math.MaxFloat64) + `,` +
+				fmt.Sprintf("%g", -math.MaxFloat64) + `,` +
+				`3.59539e+308,` + // math.MaxFloat64 * 2
+				`-3.59539e+308,` + // -math.MaxFloat64 * 2
+				fmt.Sprintf("%d000", uint64(math.MaxUint64)) +
+				`]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{ok: Float64{math.MaxFloat64}}},
+				{K: text.Scalar, T: ST{ok: Float64{-math.MaxFloat64}}},
+				{K: text.Scalar, T: ST{ok: Float64{math.Inf(1)}}},
+				{K: text.Scalar, T: ST{ok: Float64{math.Inf(-1)}}},
+				{K: text.Scalar, T: ST{ok: Float64{float64(math.MaxUint64) * 1000}}},
+				{K: text.ListClose},
+			},
+		},
+		{
+			// -0 is only valid for signed types. It is not valid for unsigned types.
+			in: `num: [-0, -0]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{nok: Uint32{}}},
+				{K: text.Scalar, T: ST{nok: Uint64{}}},
+				{K: text.ListClose},
+			},
+		},
+		{
+			// -0 is only valid for signed types. It is not valid for unsigned types.
+			in: `num: [-0, -0]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{ok: Int32{0}}},
+				{K: text.Scalar, T: ST{ok: Int64{0}}},
+				{K: text.ListClose},
+			},
+		},
+		{
+			// Negative zeros on float64 should preserve sign bit.
+			in: `num: [-0, -.0]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{ok: Float64{math.Copysign(0, -1)}}},
+				{K: text.Scalar, T: ST{ok: Float64{math.Copysign(0, -1)}}},
+				{K: text.ListClose},
+			},
+		},
+		{
+			// Negative zeros on float32 should preserve sign bit.
+			in: `num: [-0, -.0]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{ok: Float32{float32(math.Copysign(0, -1))}}},
+				{K: text.Scalar, T: ST{ok: Float32{float32(math.Copysign(0, -1))}}},
+				{K: text.ListClose},
+			},
+		},
+		{
+			in: `num: +0`,
+			want: []R{
+				{K: text.Name},
+				{E: `invalid scalar value: +`},
+			},
+		},
+		{
+			in: `num: 01.1234`,
+			want: []R{
+				{K: text.Name},
+				{E: `invalid scalar value: 01.1234`},
+			},
+		},
+		{
+			in: `num: 0x`,
+			want: []R{
+				{K: text.Name},
+				{E: `invalid scalar value: 0x`},
+			},
+		},
+		{
+			in: `num: 0xX`,
+			want: []R{
+				{K: text.Name},
+				{E: `invalid scalar value: 0xX`},
+			},
+		},
+		{
+			in: `num: 0800`,
+			want: []R{
+				{K: text.Name},
+				{E: `invalid scalar value: 0800`},
+			},
+		},
+		{
+			in: `num: 1.`,
+			want: []R{
+				{K: text.Name},
+				{K: text.Scalar, T: ST{ok: Float32{1.0}}},
+			},
+		},
+		{
+			in: `num: -.`,
+			want: []R{
+				{K: text.Name},
+				{E: `invalid scalar value: -.`},
+			},
+		},
+
+		// Float special literal values, case-insensitive match.
+		{
+			in: `name:[nan, NaN, Nan, NAN]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{ok: Float64{math.NaN()}}},
+				{K: text.Scalar, T: ST{ok: Float64{math.NaN()}}},
+				{K: text.Scalar, T: ST{ok: Float64{math.NaN()}}},
+				{K: text.Scalar, T: ST{ok: Float64{math.NaN()}}},
+				{K: text.ListClose},
+			},
+		},
+		{
+			in: `name:[inf, INF, infinity, Infinity, INFinity]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{ok: Float64{math.Inf(1)}}},
+				{K: text.Scalar, T: ST{ok: Float64{math.Inf(1)}}},
+				{K: text.Scalar, T: ST{ok: Float64{math.Inf(1)}}},
+				{K: text.Scalar, T: ST{ok: Float64{math.Inf(1)}}},
+				{K: text.Scalar, T: ST{ok: Float64{math.Inf(1)}}},
+				{K: text.ListClose},
+			},
+		},
+		{
+			in: `name:[-inf, -INF, -infinity, -Infinity, -INFinity]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{ok: Float64{math.Inf(-1)}}},
+				{K: text.Scalar, T: ST{ok: Float64{math.Inf(-1)}}},
+				{K: text.Scalar, T: ST{ok: Float64{math.Inf(-1)}}},
+				{K: text.Scalar, T: ST{ok: Float64{math.Inf(-1)}}},
+				{K: text.Scalar, T: ST{ok: Float64{math.Inf(-1)}}},
+				{K: text.ListClose},
+			},
+		},
+		{
+			in: `name:[nan, NaN, Nan, NAN]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{ok: Float32{float32(math.NaN())}}},
+				{K: text.Scalar, T: ST{ok: Float32{float32(math.NaN())}}},
+				{K: text.Scalar, T: ST{ok: Float32{float32(math.NaN())}}},
+				{K: text.Scalar, T: ST{ok: Float32{float32(math.NaN())}}},
+				{K: text.ListClose},
+			},
+		},
+		{
+			in: `name:[inf, INF, infinity, Infinity, INFinity]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{ok: Float32{float32(math.Inf(1))}}},
+				{K: text.Scalar, T: ST{ok: Float32{float32(math.Inf(1))}}},
+				{K: text.Scalar, T: ST{ok: Float32{float32(math.Inf(1))}}},
+				{K: text.Scalar, T: ST{ok: Float32{float32(math.Inf(1))}}},
+				{K: text.Scalar, T: ST{ok: Float32{float32(math.Inf(1))}}},
+				{K: text.ListClose},
+			},
+		},
+		{
+			in: `name:[-inf, -INF, -infinity, -Infinity, -INFinity]`,
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{ok: Float32{float32(math.Inf(-1))}}},
+				{K: text.Scalar, T: ST{ok: Float32{float32(math.Inf(-1))}}},
+				{K: text.Scalar, T: ST{ok: Float32{float32(math.Inf(-1))}}},
+				{K: text.Scalar, T: ST{ok: Float32{float32(math.Inf(-1))}}},
+				{K: text.Scalar, T: ST{ok: Float32{float32(math.Inf(-1))}}},
+				{K: text.ListClose},
+			},
+		},
+		{
+			// C++ permits this, but we currently reject this. It is easy to add
+			// if needed.
+			in: `name: -nan`,
+			want: []R{
+				{K: text.Name},
+				{K: text.Scalar, T: ST{nok: Float64{}}},
+			},
+		},
+		// Messages.
+		{
+			in: `m: {}`,
+			want: []R{
+				{K: text.Name},
+				{K: text.MessageOpen},
+				{K: text.MessageClose},
+				{K: text.EOF},
+			},
+		},
+		{
+			in: `m: <>`,
+			want: []R{
+				{K: text.Name},
+				{K: text.MessageOpen},
+				{K: text.MessageClose},
+				{K: text.EOF},
+			},
+		},
+		{
+			in: space + `m {` + space + "\n# comment\n" + `}` + space,
+			want: []R{
+				{K: text.Name},
+				{K: text.MessageOpen},
+				{K: text.MessageClose},
+			},
+		},
+		{
+			in: `m { foo: < bar: "hello" > }`,
+			want: []R{
+				{K: text.Name, RS: "m"},
+				{K: text.MessageOpen},
+
+				{K: text.Name, RS: "foo"},
+				{K: text.MessageOpen},
+
+				{K: text.Name, RS: "bar"},
+				{K: text.Scalar, T: ST{ok: Str{"hello"}}},
+
+				{K: text.MessageClose},
+
+				{K: text.MessageClose},
+			},
+		},
+		{
+			in: `list [ <s:"hello">, {s:"world"} ]`,
+			want: []R{
+				{K: text.Name, RS: "list"},
+				{K: text.ListOpen},
+
+				{K: text.MessageOpen},
+				{K: text.Name, RS: "s"},
+				{K: text.Scalar, T: ST{ok: Str{"hello"}}},
+				{K: text.MessageClose},
+
+				{K: text.MessageOpen},
+				{K: text.Name, RS: "s"},
+				{K: text.Scalar, T: ST{ok: Str{"world"}}},
+				{K: text.MessageClose},
+
+				{K: text.ListClose},
+				{K: text.EOF},
+			},
+		},
+		{
+			in: `m: { >`,
+			want: []R{
+				{K: text.Name},
+				{K: text.MessageOpen},
+				{E: `mismatched close character '>'`},
+			},
+		},
+		{
+			in: `m: <s: "hello"}`,
+			want: []R{
+				{K: text.Name},
+				{K: text.MessageOpen},
+
+				{K: text.Name},
+				{K: text.Scalar, T: ST{ok: Str{"hello"}}},
+
+				{E: `mismatched close character '}'`},
+			},
+		},
+		{
+			in:   `{}`,
+			want: []R{{E: `invalid field name: {`}},
+		},
+		{
+			in: `
+m: {
+  foo: true;
+  bar: {
+	enum: ENUM
+	list: [ < >, { } ] ;
+  }
+  [qux]: "end"
+}
+				`,
+			want: []R{
+				{K: text.Name},
+				{K: text.MessageOpen},
+
+				{K: text.Name, RS: "foo"},
+				{K: text.Scalar, T: ST{ok: Bool{true}}},
+
+				{K: text.Name, RS: "bar"},
+				{K: text.MessageOpen},
+
+				{K: text.Name, RS: "enum"},
+				{K: text.Scalar, T: ST{ok: Enum{"ENUM"}}},
+
+				{K: text.Name, RS: "list"},
+				{K: text.ListOpen},
+				{K: text.MessageOpen},
+				{K: text.MessageClose},
+				{K: text.MessageOpen},
+				{K: text.MessageClose},
+				{K: text.ListClose},
+
+				{K: text.MessageClose},
+
+				{K: text.Name, RS: "[qux]"},
+				{K: text.Scalar, T: ST{ok: Str{"end"}}},
+
+				{K: text.MessageClose},
+				{K: text.EOF},
+			},
+		},
+
+		// Other syntax errors.
+		{
+			in: "x: -",
+			want: []R{
+				{K: text.Name},
+				{E: `syntax error (line 1:4): invalid scalar value: -`},
+			},
+		},
+		{
+			in: "x:[\"💩\"x",
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{ok: Str{"💩"}}, P: 3},
+				{E: `syntax error (line 1:7)`},
+			},
+		},
+		{
+			in: "x:\n\n[\"🔥🔥🔥\"x",
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{ok: Str{"🔥🔥🔥"}}, P: 5},
+				{E: `syntax error (line 3:7)`},
+			},
+		},
+		{
+			// multi-rune emojis; could be column:8
+			in: "x:[\"👍🏻👍🏿\"x",
+			want: []R{
+				{K: text.Name},
+				{K: text.ListOpen},
+				{K: text.Scalar, T: ST{ok: Str{"👍🏻👍🏿"}}, P: 3},
+				{E: `syntax error (line 1:10)`},
+			},
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run("", func(t *testing.T) {
+			tc := tc
+			in := []byte(tc.in)
+			dec := text.NewDecoder(in[:len(in):len(in)])
+			for i, want := range tc.want {
+				peekTok, peekErr := dec.Peek()
+				tok, err := dec.Read()
+				if err != nil {
+					if want.E == "" {
+						errorf(t, tc.in, "Read() got unexpected error: %v", err)
+					} else if !strings.Contains(err.Error(), want.E) {
+						errorf(t, tc.in, "Read() got %q, want %q", err, want.E)
+					}
+					return
+				}
+				if want.E != "" {
+					errorf(t, tc.in, "Read() got nil error, want %q", want.E)
+					return
+				}
+				gotK := tok.Kind()
+				if gotK != want.K {
+					errorf(t, tc.in, "Read() got %v, want %v", gotK, want.K)
+					return
+				}
+				checkToken(t, tok, i, want, tc.in)
+				if !cmp.Equal(tok, peekTok, cmp.Comparer(text.TokenEquals)) {
+					errorf(t, tc.in, "Peek() %+v != Read() token %+v", peekTok, tok)
+				}
+				if err != peekErr {
+					errorf(t, tc.in, "Peek() error %v != Read() error %v", err, peekErr)
+				}
+			}
+		})
+	}
+}
+
+func checkToken(t *testing.T, tok text.Token, idx int, r R, in string) {
+	// Validate Token.Pos() if R.P is set.
+	if r.P > 0 {
+		got := tok.Pos()
+		if got != r.P {
+			errorf(t, in, "want#%d: Token.Pos() got %v want %v", idx, got, r.P)
+		}
+	}
+
+	// Validate Token.RawString if R.RS is set.
+	if len(r.RS) > 0 {
+		got := tok.RawString()
+		if got != r.RS {
+			errorf(t, in, "want#%d: Token.RawString() got %v want %v", idx, got, r.P)
+		}
+	}
+
+	// Skip checking for Token details if r.T is not set.
+	if r.T == nil {
+		return
+	}
+
+	switch tok.Kind() {
+	case text.Name:
+		want := r.T.(NT)
+		kind := tok.NameKind()
+		if kind != want.K {
+			errorf(t, in, "want#%d: Token.NameKind() got %v want %v", idx, kind, want.K)
+			return
+		}
+		switch kind {
+		case text.IdentName:
+			got := tok.IdentName()
+			if got != want.S {
+				errorf(t, in, "want#%d: Token.IdentName() got %v want %v", idx, got, want.S)
+			}
+		case text.TypeName:
+			got := tok.TypeName()
+			if got != want.S {
+				errorf(t, in, "want#%d: Token.TypeName() got %v want %v", idx, got, want.S)
+			}
+		case text.FieldNumber:
+			got := tok.FieldNumber()
+			if got != want.N {
+				errorf(t, in, "want#%d: Token.FieldNumber() got %v want %v", idx, got, want.N)
+			}
+		}
+
+	case text.Scalar:
+		want := r.T.(ST)
+		if ok := want.ok; ok != nil {
+			if err := ok.checkOk(tok); err != "" {
+				errorf(t, in, "want#%d: %s", idx, err)
+			}
+		}
+		if nok := want.nok; nok != nil {
+			if err := nok.checkNok(tok); err != "" {
+				errorf(t, in, "want#%d: %s", idx, err)
+			}
+		}
+	}
+}
+
+func errorf(t *testing.T, in string, fmtStr string, args ...interface{}) {
+	t.Helper()
+	vargs := []interface{}{in}
+	for _, arg := range args {
+		vargs = append(vargs, arg)
+	}
+	t.Errorf("input:\n%s\n~end~\n"+fmtStr, vargs...)
+}
+
+func TestUnmarshalString(t *testing.T) {
+	tests := []struct {
+		in string
+		// want is expected string result.
+		want string
+		// err is expected error substring from calling DecodeString if set.
+		err string
+	}{
+		{
+			in: func() string {
+				var b []byte
+				for i := 0; i < utf8.RuneSelf; i++ {
+					switch i {
+					case 0, '\\', '\n', '\'': // these must be escaped, so ignore them
+					default:
+						b = append(b, byte(i))
+					}
+				}
+				return "'" + string(b) + "'"
+			}(),
+			want: "\x01\x02\x03\x04\x05\x06\a\b\t\v\f\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !\"#$%&()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~\u007f",
+		},
+		{
+			in:  "'\xde\xad\xbe\xef'",
+			err: `invalid UTF-8 detected`,
+		},
+		{
+			// Valid UTF-8 wire encoding, but sub-optimal encoding.
+			in:  "'\xc0\x80'",
+			err: "invalid UTF-8 detected",
+		},
+		{
+			// Valid UTF-8 wire encoding, but invalid rune (surrogate pair).
+			in:  "'\xed\xa0\x80'",
+			err: "invalid UTF-8 detected",
+		},
+		{
+			// Valid UTF-8 wire encoding, but invalid rune (above max rune).
+			in:  "'\xf7\xbf\xbf\xbf'",
+			err: "invalid UTF-8 detected",
+		},
+		{
+			// Valid UTF-8 wire encoding of the RuneError rune.
+			in:   "'\xef\xbf\xbd'",
+			want: string(utf8.RuneError),
+		},
+		{
+			in:   "'hello\u1234world'",
+			want: "hello\u1234world",
+		},
+		{
+			in:   `'\"\'\\\?\a\b\n\r\t\v\f\1\12\123\xA\xaB\x12\uAb8f\U0010FFFF'`,
+			want: "\"'\\?\a\b\n\r\t\v\f\x01\nS\n\xab\x12\uab8f\U0010ffff",
+		},
+		{
+			in:  `str: '\8'`,
+			err: `invalid escape code "\\8" in string`,
+		},
+		{
+			in:   `'\1x'`,
+			want: "\001x",
+		},
+		{
+			in:   `'\12x'`,
+			want: "\012x",
+		},
+		{
+			in:   `'\123x'`,
+			want: "\123x",
+		},
+		{
+			in:   `'\1234x'`,
+			want: "\1234x",
+		},
+		{
+			in:   `'\1'`,
+			want: "\001",
+		},
+		{
+			in:   `'\12'`,
+			want: "\012",
+		},
+		{
+			in:   `'\123'`,
+			want: "\123",
+		},
+		{
+			in:   `'\1234'`,
+			want: "\1234",
+		},
+		{
+			in:   `'\377'`,
+			want: "\377",
+		},
+		{
+			// Overflow octal escape.
+			in:  `'\400'`,
+			err: `invalid octal escape code "\\400" in string`,
+		},
+		{
+			in:   `'\xfx'`,
+			want: "\x0fx",
+		},
+		{
+			in:   `'\xffx'`,
+			want: "\xffx",
+		},
+		{
+			in:   `'\xfffx'`,
+			want: "\xfffx",
+		},
+		{
+			in:   `'\xf'`,
+			want: "\x0f",
+		},
+		{
+			in:   `'\xff'`,
+			want: "\xff",
+		},
+		{
+			in:   `'\xfff'`,
+			want: "\xfff",
+		},
+		{
+			in:  `'\xz'`,
+			err: `invalid hex escape code "\\x" in string`,
+		},
+		{
+			in:  `'\uPo'`,
+			err: eofErr,
+		},
+		{
+			in:  `'\uPoo'`,
+			err: `invalid Unicode escape code "\\uPoo'" in string`,
+		},
+		{
+			in:  `str: '\uPoop'`,
+			err: `invalid Unicode escape code "\\uPoop" in string`,
+		},
+		{
+			// Unmatched surrogate pair.
+			in:  `str: '\uDEAD'`,
+			err: `unexpected EOF`, // trying to reader other half
+		},
+		{
+			// Surrogate pair with invalid other half.
+			in:  `str: '\uDEAD\u0000'`,
+			err: `invalid Unicode escape code "\\u0000" in string`,
+		},
+		{
+			// Properly matched surrogate pair.
+			in:   `'\uD800\uDEAD'`,
+			want: "𐊭",
+		},
+		{
+			// Overflow on Unicode rune.
+			in:  `'\U00110000'`,
+			err: `invalid Unicode escape code "\\U00110000" in string`,
+		},
+		{
+			in:  `'\z'`,
+			err: `invalid escape code "\\z" in string`,
+		},
+		{
+			// Strings cannot have NUL literal since C-style strings forbid them.
+			in:  "'\x00'",
+			err: `invalid character '\x00' in string`,
+		},
+		{
+			// Strings cannot have newline literal. The C++ permits them if an
+			// option is specified to allow them. In Go, we always forbid them.
+			in:  "'\n'",
+			err: `invalid character '\n' in string`,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run("", func(t *testing.T) {
+			got, err := text.UnmarshalString(tc.in)
+			if err != nil {
+				if tc.err == "" {
+					errorf(t, tc.in, "UnmarshalString() got unexpected error: %q", err)
+				} else if !strings.Contains(err.Error(), tc.err) {
+					errorf(t, tc.in, "UnmarshalString() error got %q, want %q", err, tc.err)
+				}
+				return
+			}
+			if tc.err != "" {
+				errorf(t, tc.in, "UnmarshalString() got nil error, want %q", tc.err)
+				return
+			}
+			if got != tc.want {
+				errorf(t, tc.in, "UnmarshalString()\n[got]\n%s\n[want]\n%s", got, tc.want)
+			}
+		})
+	}
+}
+
+// Tests line and column number produced by Decoder.Position.
+func TestPosition(t *testing.T) {
+	dec := text.NewDecoder([]byte("0123456789\n12345\n789"))
+
+	tests := []struct {
+		pos int
+		row int
+		col int
+	}{
+		{
+			pos: 0,
+			row: 1,
+			col: 1,
+		},
+		{
+			pos: 10,
+			row: 1,
+			col: 11,
+		},
+		{
+			pos: 11,
+			row: 2,
+			col: 1,
+		},
+		{
+			pos: 18,
+			row: 3,
+			col: 2,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run("", func(t *testing.T) {
+			row, col := dec.Position(tc.pos)
+			if row != tc.row || col != tc.col {
+				t.Errorf("Position(%d) got (%d,%d) want (%d,%d)", tc.pos, row, col, tc.row, tc.col)
+			}
+		})
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/text/decode_token.go b/vendor/google.golang.org/protobuf/internal/encoding/text/decode_token.go
new file mode 100644
index 000000000..83d2b0d5a
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/encoding/text/decode_token.go
@@ -0,0 +1,373 @@
+// 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 text
+
+import (
+	"bytes"
+	"fmt"
+	"math"
+	"strconv"
+	"strings"
+
+	"google.golang.org/protobuf/internal/flags"
+)
+
+// Kind represents a token kind expressible in the textproto format.
+type Kind uint8
+
+// Kind values.
+const (
+	Invalid Kind = iota
+	EOF
+	Name   // Name indicates the field name.
+	Scalar // Scalar are scalar values, e.g. "string", 47, ENUM_LITERAL, true.
+	MessageOpen
+	MessageClose
+	ListOpen
+	ListClose
+
+	// comma and semi-colon are only for parsing in between values and should not be exposed.
+	comma
+	semicolon
+
+	// bof indicates beginning of file, which is the default token
+	// kind at the beginning of parsing.
+	bof = Invalid
+)
+
+func (t Kind) String() string {
+	switch t {
+	case Invalid:
+		return "<invalid>"
+	case EOF:
+		return "eof"
+	case Scalar:
+		return "scalar"
+	case Name:
+		return "name"
+	case MessageOpen:
+		return "{"
+	case MessageClose:
+		return "}"
+	case ListOpen:
+		return "["
+	case ListClose:
+		return "]"
+	case comma:
+		return ","
+	case semicolon:
+		return ";"
+	default:
+		return fmt.Sprintf("<invalid:%v>", uint8(t))
+	}
+}
+
+// NameKind represents different types of field names.
+type NameKind uint8
+
+// NameKind values.
+const (
+	IdentName NameKind = iota + 1
+	TypeName
+	FieldNumber
+)
+
+func (t NameKind) String() string {
+	switch t {
+	case IdentName:
+		return "IdentName"
+	case TypeName:
+		return "TypeName"
+	case FieldNumber:
+		return "FieldNumber"
+	default:
+		return fmt.Sprintf("<invalid:%v>", uint8(t))
+	}
+}
+
+// Bit mask in Token.attrs to indicate if a Name token is followed by the
+// separator char ':'. The field name separator char is optional for message
+// field or repeated message field, but required for all other types. Decoder
+// simply indicates whether a Name token is followed by separator or not.  It is
+// up to the prototext package to validate.
+const hasSeparator = 1 << 7
+
+// Scalar value types.
+const (
+	numberValue = iota + 1
+	stringValue
+	literalValue
+)
+
+// Bit mask in Token.numAttrs to indicate that the number is a negative.
+const isNegative = 1 << 7
+
+// Token provides a parsed token kind and value. Values are provided by the
+// different accessor methods.
+type Token struct {
+	// Kind of the Token object.
+	kind Kind
+	// attrs contains metadata for the following Kinds:
+	// Name: hasSeparator bit and one of NameKind.
+	// Scalar: one of numberValue, stringValue, literalValue.
+	attrs uint8
+	// numAttrs contains metadata for numberValue:
+	// - highest bit is whether negative or positive.
+	// - lower bits indicate one of numDec, numHex, numOct, numFloat.
+	numAttrs uint8
+	// pos provides the position of the token in the original input.
+	pos int
+	// raw bytes of the serialized token.
+	// This is a subslice into the original input.
+	raw []byte
+	// str contains parsed string for the following:
+	// - stringValue of Scalar kind
+	// - numberValue of Scalar kind
+	// - TypeName of Name kind
+	str string
+}
+
+// Kind returns the token kind.
+func (t Token) Kind() Kind {
+	return t.kind
+}
+
+// RawString returns the read value in string.
+func (t Token) RawString() string {
+	return string(t.raw)
+}
+
+// Pos returns the token position from the input.
+func (t Token) Pos() int {
+	return t.pos
+}
+
+// NameKind returns IdentName, TypeName or FieldNumber.
+// It panics if type is not Name.
+func (t Token) NameKind() NameKind {
+	if t.kind == Name {
+		return NameKind(t.attrs &^ hasSeparator)
+	}
+	panic(fmt.Sprintf("Token is not a Name type: %s", t.kind))
+}
+
+// HasSeparator returns true if the field name is followed by the separator char
+// ':', else false. It panics if type is not Name.
+func (t Token) HasSeparator() bool {
+	if t.kind == Name {
+		return t.attrs&hasSeparator != 0
+	}
+	panic(fmt.Sprintf("Token is not a Name type: %s", t.kind))
+}
+
+// IdentName returns the value for IdentName type.
+func (t Token) IdentName() string {
+	if t.kind == Name && t.attrs&uint8(IdentName) != 0 {
+		return string(t.raw)
+	}
+	panic(fmt.Sprintf("Token is not an IdentName: %s:%s", t.kind, NameKind(t.attrs&^hasSeparator)))
+}
+
+// TypeName returns the value for TypeName type.
+func (t Token) TypeName() string {
+	if t.kind == Name && t.attrs&uint8(TypeName) != 0 {
+		return t.str
+	}
+	panic(fmt.Sprintf("Token is not a TypeName: %s:%s", t.kind, NameKind(t.attrs&^hasSeparator)))
+}
+
+// FieldNumber returns the value for FieldNumber type. It returns a
+// non-negative int32 value. Caller will still need to validate for the correct
+// field number range.
+func (t Token) FieldNumber() int32 {
+	if t.kind != Name || t.attrs&uint8(FieldNumber) == 0 {
+		panic(fmt.Sprintf("Token is not a FieldNumber: %s:%s", t.kind, NameKind(t.attrs&^hasSeparator)))
+	}
+	// Following should not return an error as it had already been called right
+	// before this Token was constructed.
+	num, _ := strconv.ParseInt(string(t.raw), 10, 32)
+	return int32(num)
+}
+
+// String returns the string value for a Scalar type.
+func (t Token) String() (string, bool) {
+	if t.kind != Scalar || t.attrs != stringValue {
+		return "", false
+	}
+	return t.str, true
+}
+
+// Enum returns the literal value for a Scalar type for use as enum literals.
+func (t Token) Enum() (string, bool) {
+	if t.kind != Scalar || t.attrs != literalValue || (len(t.raw) > 0 && t.raw[0] == '-') {
+		return "", false
+	}
+	return string(t.raw), true
+}
+
+// Bool returns the bool value for a Scalar type.
+func (t Token) Bool() (bool, bool) {
+	if t.kind != Scalar {
+		return false, false
+	}
+	switch t.attrs {
+	case literalValue:
+		if b, ok := boolLits[string(t.raw)]; ok {
+			return b, true
+		}
+	case numberValue:
+		// Unsigned integer representation of 0 or 1 is permitted: 00, 0x0, 01,
+		// 0x1, etc.
+		n, err := strconv.ParseUint(t.str, 0, 64)
+		if err == nil {
+			switch n {
+			case 0:
+				return false, true
+			case 1:
+				return true, true
+			}
+		}
+	}
+	return false, false
+}
+
+// These exact boolean literals are the ones supported in C++.
+var boolLits = map[string]bool{
+	"t":     true,
+	"true":  true,
+	"True":  true,
+	"f":     false,
+	"false": false,
+	"False": false,
+}
+
+// Uint64 returns the uint64 value for a Scalar type.
+func (t Token) Uint64() (uint64, bool) {
+	if t.kind != Scalar || t.attrs != numberValue ||
+		t.numAttrs&isNegative > 0 || t.numAttrs&numFloat > 0 {
+		return 0, false
+	}
+	n, err := strconv.ParseUint(t.str, 0, 64)
+	if err != nil {
+		return 0, false
+	}
+	return n, true
+}
+
+// Uint32 returns the uint32 value for a Scalar type.
+func (t Token) Uint32() (uint32, bool) {
+	if t.kind != Scalar || t.attrs != numberValue ||
+		t.numAttrs&isNegative > 0 || t.numAttrs&numFloat > 0 {
+		return 0, false
+	}
+	n, err := strconv.ParseUint(t.str, 0, 32)
+	if err != nil {
+		return 0, false
+	}
+	return uint32(n), true
+}
+
+// Int64 returns the int64 value for a Scalar type.
+func (t Token) Int64() (int64, bool) {
+	if t.kind != Scalar || t.attrs != numberValue || t.numAttrs&numFloat > 0 {
+		return 0, false
+	}
+	if n, err := strconv.ParseInt(t.str, 0, 64); err == nil {
+		return n, true
+	}
+	// C++ accepts large positive hex numbers as negative values.
+	// This feature is here for proto1 backwards compatibility purposes.
+	if flags.ProtoLegacy && (t.numAttrs == numHex) {
+		if n, err := strconv.ParseUint(t.str, 0, 64); err == nil {
+			return int64(n), true
+		}
+	}
+	return 0, false
+}
+
+// Int32 returns the int32 value for a Scalar type.
+func (t Token) Int32() (int32, bool) {
+	if t.kind != Scalar || t.attrs != numberValue || t.numAttrs&numFloat > 0 {
+		return 0, false
+	}
+	if n, err := strconv.ParseInt(t.str, 0, 32); err == nil {
+		return int32(n), true
+	}
+	// C++ accepts large positive hex numbers as negative values.
+	// This feature is here for proto1 backwards compatibility purposes.
+	if flags.ProtoLegacy && (t.numAttrs == numHex) {
+		if n, err := strconv.ParseUint(t.str, 0, 32); err == nil {
+			return int32(n), true
+		}
+	}
+	return 0, false
+}
+
+// Float64 returns the float64 value for a Scalar type.
+func (t Token) Float64() (float64, bool) {
+	if t.kind != Scalar {
+		return 0, false
+	}
+	switch t.attrs {
+	case literalValue:
+		if f, ok := floatLits[strings.ToLower(string(t.raw))]; ok {
+			return f, true
+		}
+	case numberValue:
+		n, err := strconv.ParseFloat(t.str, 64)
+		if err == nil {
+			return n, true
+		}
+		nerr := err.(*strconv.NumError)
+		if nerr.Err == strconv.ErrRange {
+			return n, true
+		}
+	}
+	return 0, false
+}
+
+// Float32 returns the float32 value for a Scalar type.
+func (t Token) Float32() (float32, bool) {
+	if t.kind != Scalar {
+		return 0, false
+	}
+	switch t.attrs {
+	case literalValue:
+		if f, ok := floatLits[strings.ToLower(string(t.raw))]; ok {
+			return float32(f), true
+		}
+	case numberValue:
+		n, err := strconv.ParseFloat(t.str, 64)
+		if err == nil {
+			// Overflows are treated as (-)infinity.
+			return float32(n), true
+		}
+		nerr := err.(*strconv.NumError)
+		if nerr.Err == strconv.ErrRange {
+			return float32(n), true
+		}
+	}
+	return 0, false
+}
+
+// These are the supported float literals which C++ permits case-insensitive
+// variants of these.
+var floatLits = map[string]float64{
+	"nan":       math.NaN(),
+	"inf":       math.Inf(1),
+	"infinity":  math.Inf(1),
+	"-inf":      math.Inf(-1),
+	"-infinity": math.Inf(-1),
+}
+
+// TokenEquals returns true if given Tokens are equal, else false.
+func TokenEquals(x, y Token) bool {
+	return x.kind == y.kind &&
+		x.attrs == y.attrs &&
+		x.numAttrs == y.numAttrs &&
+		x.pos == y.pos &&
+		bytes.Equal(x.raw, y.raw) &&
+		x.str == y.str
+}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/text/doc.go b/vendor/google.golang.org/protobuf/internal/encoding/text/doc.go
new file mode 100644
index 000000000..0ce8d6fb8
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/encoding/text/doc.go
@@ -0,0 +1,29 @@
+// 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 text implements the text format for protocol buffers.
+// This package has no semantic understanding for protocol buffers and is only
+// a parser and composer for the format.
+//
+// There is no formal specification for the protobuf text format, as such the
+// C++ implementation (see google::protobuf::TextFormat) is the reference
+// implementation of the text format.
+//
+// This package is neither a superset nor a subset of the C++ implementation.
+// This implementation permits a more liberal grammar in some cases to be
+// backwards compatible with the historical Go implementation.
+// Future parsings unique to Go should not be added.
+// Some grammars allowed by the C++ implementation are deliberately
+// not implemented here because they are considered a bug by the protobuf team
+// and should not be replicated.
+//
+// The Go implementation should implement a sufficient amount of the C++
+// grammar such that the default text serialization by C++ can be parsed by Go.
+// However, just because the C++ parser accepts some input does not mean that
+// the Go implementation should as well.
+//
+// The text format is almost a superset of JSON except:
+//	* message keys are not quoted strings, but identifiers
+//	* the top-level value must be a message without the delimiters
+package text
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/text/encode.go b/vendor/google.golang.org/protobuf/internal/encoding/text/encode.go
new file mode 100644
index 000000000..c4ba1c598
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/encoding/text/encode.go
@@ -0,0 +1,267 @@
+// 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 text
+
+import (
+	"math"
+	"math/bits"
+	"strconv"
+	"strings"
+	"unicode/utf8"
+
+	"google.golang.org/protobuf/internal/detrand"
+	"google.golang.org/protobuf/internal/errors"
+)
+
+// encType represents an encoding type.
+type encType uint8
+
+const (
+	_ encType = (1 << iota) / 2
+	name
+	scalar
+	messageOpen
+	messageClose
+)
+
+// Encoder provides methods to write out textproto constructs and values. The user is
+// responsible for producing valid sequences of constructs and values.
+type Encoder struct {
+	encoderState
+
+	indent      string
+	newline     string // set to "\n" if len(indent) > 0
+	delims      [2]byte
+	outputASCII bool
+}
+
+type encoderState struct {
+	lastType encType
+	indents  []byte
+	out      []byte
+}
+
+// NewEncoder returns an Encoder.
+//
+// If indent is a non-empty string, it causes every entry in a List or Message
+// to be preceded by the indent and trailed by a newline.
+//
+// If delims is not the zero value, it controls the delimiter characters used
+// for messages (e.g., "{}" vs "<>").
+//
+// If outputASCII is true, strings will be serialized in such a way that
+// multi-byte UTF-8 sequences are escaped. This property ensures that the
+// overall output is ASCII (as opposed to UTF-8).
+func NewEncoder(indent string, delims [2]byte, outputASCII bool) (*Encoder, error) {
+	e := &Encoder{}
+	if len(indent) > 0 {
+		if strings.Trim(indent, " \t") != "" {
+			return nil, errors.New("indent may only be composed of space and tab characters")
+		}
+		e.indent = indent
+		e.newline = "\n"
+	}
+	switch delims {
+	case [2]byte{0, 0}:
+		e.delims = [2]byte{'{', '}'}
+	case [2]byte{'{', '}'}, [2]byte{'<', '>'}:
+		e.delims = delims
+	default:
+		return nil, errors.New("delimiters may only be \"{}\" or \"<>\"")
+	}
+	e.outputASCII = outputASCII
+
+	return e, nil
+}
+
+// Bytes returns the content of the written bytes.
+func (e *Encoder) Bytes() []byte {
+	return e.out
+}
+
+// StartMessage writes out the '{' or '<' symbol.
+func (e *Encoder) StartMessage() {
+	e.prepareNext(messageOpen)
+	e.out = append(e.out, e.delims[0])
+}
+
+// EndMessage writes out the '}' or '>' symbol.
+func (e *Encoder) EndMessage() {
+	e.prepareNext(messageClose)
+	e.out = append(e.out, e.delims[1])
+}
+
+// WriteName writes out the field name and the separator ':'.
+func (e *Encoder) WriteName(s string) {
+	e.prepareNext(name)
+	e.out = append(e.out, s...)
+	e.out = append(e.out, ':')
+}
+
+// WriteBool writes out the given boolean value.
+func (e *Encoder) WriteBool(b bool) {
+	if b {
+		e.WriteLiteral("true")
+	} else {
+		e.WriteLiteral("false")
+	}
+}
+
+// WriteString writes out the given string value.
+func (e *Encoder) WriteString(s string) {
+	e.prepareNext(scalar)
+	e.out = appendString(e.out, s, e.outputASCII)
+}
+
+func appendString(out []byte, in string, outputASCII bool) []byte {
+	out = append(out, '"')
+	i := indexNeedEscapeInString(in)
+	in, out = in[i:], append(out, in[:i]...)
+	for len(in) > 0 {
+		switch r, n := utf8.DecodeRuneInString(in); {
+		case r == utf8.RuneError && n == 1:
+			// We do not report invalid UTF-8 because strings in the text format
+			// are used to represent both the proto string and bytes type.
+			r = rune(in[0])
+			fallthrough
+		case r < ' ' || r == '"' || r == '\\':
+			out = append(out, '\\')
+			switch r {
+			case '"', '\\':
+				out = append(out, byte(r))
+			case '\n':
+				out = append(out, 'n')
+			case '\r':
+				out = append(out, 'r')
+			case '\t':
+				out = append(out, 't')
+			default:
+				out = append(out, 'x')
+				out = append(out, "00"[1+(bits.Len32(uint32(r))-1)/4:]...)
+				out = strconv.AppendUint(out, uint64(r), 16)
+			}
+			in = in[n:]
+		case outputASCII && r >= utf8.RuneSelf:
+			out = append(out, '\\')
+			if r <= math.MaxUint16 {
+				out = append(out, 'u')
+				out = append(out, "0000"[1+(bits.Len32(uint32(r))-1)/4:]...)
+				out = strconv.AppendUint(out, uint64(r), 16)
+			} else {
+				out = append(out, 'U')
+				out = append(out, "00000000"[1+(bits.Len32(uint32(r))-1)/4:]...)
+				out = strconv.AppendUint(out, uint64(r), 16)
+			}
+			in = in[n:]
+		default:
+			i := indexNeedEscapeInString(in[n:])
+			in, out = in[n+i:], append(out, in[:n+i]...)
+		}
+	}
+	out = append(out, '"')
+	return out
+}
+
+// indexNeedEscapeInString returns the index of the character that needs
+// escaping. If no characters need escaping, this returns the input length.
+func indexNeedEscapeInString(s string) int {
+	for i := 0; i < len(s); i++ {
+		if c := s[i]; c < ' ' || c == '"' || c == '\'' || c == '\\' || c >= utf8.RuneSelf {
+			return i
+		}
+	}
+	return len(s)
+}
+
+// WriteFloat writes out the given float value for given bitSize.
+func (e *Encoder) WriteFloat(n float64, bitSize int) {
+	e.prepareNext(scalar)
+	e.out = appendFloat(e.out, n, bitSize)
+}
+
+func appendFloat(out []byte, n float64, bitSize int) []byte {
+	switch {
+	case math.IsNaN(n):
+		return append(out, "nan"...)
+	case math.IsInf(n, +1):
+		return append(out, "inf"...)
+	case math.IsInf(n, -1):
+		return append(out, "-inf"...)
+	default:
+		return strconv.AppendFloat(out, n, 'g', -1, bitSize)
+	}
+}
+
+// WriteInt writes out the given signed integer value.
+func (e *Encoder) WriteInt(n int64) {
+	e.prepareNext(scalar)
+	e.out = append(e.out, strconv.FormatInt(n, 10)...)
+}
+
+// WriteUint writes out the given unsigned integer value.
+func (e *Encoder) WriteUint(n uint64) {
+	e.prepareNext(scalar)
+	e.out = append(e.out, strconv.FormatUint(n, 10)...)
+}
+
+// WriteLiteral writes out the given string as a literal value without quotes.
+// This is used for writing enum literal strings.
+func (e *Encoder) WriteLiteral(s string) {
+	e.prepareNext(scalar)
+	e.out = append(e.out, s...)
+}
+
+// prepareNext adds possible space and indentation for the next value based
+// on last encType and indent option. It also updates e.lastType to next.
+func (e *Encoder) prepareNext(next encType) {
+	defer func() {
+		e.lastType = next
+	}()
+
+	// Single line.
+	if len(e.indent) == 0 {
+		// Add space after each field before the next one.
+		if e.lastType&(scalar|messageClose) != 0 && next == name {
+			e.out = append(e.out, ' ')
+			// Add a random extra space to make output unstable.
+			if detrand.Bool() {
+				e.out = append(e.out, ' ')
+			}
+		}
+		return
+	}
+
+	// Multi-line.
+	switch {
+	case e.lastType == name:
+		e.out = append(e.out, ' ')
+		// Add a random extra space after name: to make output unstable.
+		if detrand.Bool() {
+			e.out = append(e.out, ' ')
+		}
+
+	case e.lastType == messageOpen && next != messageClose:
+		e.indents = append(e.indents, e.indent...)
+		e.out = append(e.out, '\n')
+		e.out = append(e.out, e.indents...)
+
+	case e.lastType&(scalar|messageClose) != 0:
+		if next == messageClose {
+			e.indents = e.indents[:len(e.indents)-len(e.indent)]
+		}
+		e.out = append(e.out, '\n')
+		e.out = append(e.out, e.indents...)
+	}
+}
+
+// Snapshot returns the current snapshot for use in Reset.
+func (e *Encoder) Snapshot() encoderState {
+	return e.encoderState
+}
+
+// Reset resets the Encoder to the given encoderState from a Snapshot.
+func (e *Encoder) Reset(es encoderState) {
+	e.encoderState = es
+}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/text/encode_test.go b/vendor/google.golang.org/protobuf/internal/encoding/text/encode_test.go
new file mode 100644
index 000000000..2588b1b0b
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/encoding/text/encode_test.go
@@ -0,0 +1,550 @@
+// Copyright 2019 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 text_test
+
+import (
+	"math"
+	"strings"
+	"testing"
+	"unicode/utf8"
+
+	"github.com/google/go-cmp/cmp"
+
+	"google.golang.org/protobuf/internal/detrand"
+	"google.golang.org/protobuf/internal/encoding/text"
+)
+
+// Disable detrand to enable direct comparisons on outputs.
+func init() { detrand.Disable() }
+
+func TestEncoder(t *testing.T) {
+	tests := []encoderTestCase{
+		{
+			desc:          "no-opt",
+			write:         func(e *text.Encoder) {},
+			wantOut:       ``,
+			wantOutIndent: ``,
+		},
+		{
+			desc: "true",
+			write: func(e *text.Encoder) {
+				e.WriteName("bool")
+				e.WriteBool(true)
+			},
+			wantOut:       `bool:true`,
+			wantOutIndent: `bool: true`,
+		},
+		{
+			desc: "false",
+			write: func(e *text.Encoder) {
+				e.WriteName("bool")
+				e.WriteBool(false)
+			},
+			wantOut:       `bool:false`,
+			wantOutIndent: `bool: false`,
+		},
+		{
+			desc: "bracket name",
+			write: func(e *text.Encoder) {
+				e.WriteName("[extension]")
+				e.WriteString("hello")
+			},
+			wantOut:       `[extension]:"hello"`,
+			wantOutIndent: `[extension]: "hello"`,
+		},
+		{
+			desc: "numeric name",
+			write: func(e *text.Encoder) {
+				e.WriteName("01234")
+				e.WriteString("hello")
+			},
+			wantOut:       `01234:"hello"`,
+			wantOutIndent: `01234: "hello"`,
+		},
+		{
+			desc: "string",
+			write: func(e *text.Encoder) {
+				e.WriteName("str")
+				e.WriteString("hello world")
+			},
+			wantOut:       `str:"hello world"`,
+			wantOutIndent: `str: "hello world"`,
+		},
+		{
+			desc: "enum",
+			write: func(e *text.Encoder) {
+				e.WriteName("enum")
+				e.WriteLiteral("ENUM_VALUE")
+			},
+			wantOut:       `enum:ENUM_VALUE`,
+			wantOutIndent: `enum: ENUM_VALUE`,
+		},
+		{
+			desc: "float64",
+			write: func(e *text.Encoder) {
+				e.WriteName("float64")
+				e.WriteFloat(1.0199999809265137, 64)
+			},
+			wantOut:       `float64:1.0199999809265137`,
+			wantOutIndent: `float64: 1.0199999809265137`,
+		},
+		{
+			desc: "float64 max value",
+			write: func(e *text.Encoder) {
+				e.WriteName("float64")
+				e.WriteFloat(math.MaxFloat64, 64)
+			},
+			wantOut:       `float64:1.7976931348623157e+308`,
+			wantOutIndent: `float64: 1.7976931348623157e+308`,
+		},
+		{
+			desc: "float64 min value",
+			write: func(e *text.Encoder) {
+				e.WriteName("float64")
+				e.WriteFloat(-math.MaxFloat64, 64)
+			},
+			wantOut:       `float64:-1.7976931348623157e+308`,
+			wantOutIndent: `float64: -1.7976931348623157e+308`,
+		},
+		{
+			desc: "float64 nan",
+			write: func(e *text.Encoder) {
+				e.WriteName("float64")
+				e.WriteFloat(math.NaN(), 64)
+			},
+			wantOut:       `float64:nan`,
+			wantOutIndent: `float64: nan`,
+		},
+		{
+			desc: "float64 inf",
+			write: func(e *text.Encoder) {
+				e.WriteName("float64")
+				e.WriteFloat(math.Inf(+1), 64)
+			},
+			wantOut:       `float64:inf`,
+			wantOutIndent: `float64: inf`,
+		},
+		{
+			desc: "float64 -inf",
+			write: func(e *text.Encoder) {
+				e.WriteName("float64")
+				e.WriteFloat(math.Inf(-1), 64)
+			},
+			wantOut:       `float64:-inf`,
+			wantOutIndent: `float64: -inf`,
+		},
+		{
+			desc: "float64 negative zero",
+			write: func(e *text.Encoder) {
+				e.WriteName("float64")
+				e.WriteFloat(math.Copysign(0, -1), 64)
+			},
+			wantOut:       `float64:-0`,
+			wantOutIndent: `float64: -0`,
+		},
+		{
+			desc: "float32",
+			write: func(e *text.Encoder) {
+				e.WriteName("float")
+				e.WriteFloat(1.02, 32)
+			},
+			wantOut:       `float:1.02`,
+			wantOutIndent: `float: 1.02`,
+		},
+		{
+			desc: "float32 max value",
+			write: func(e *text.Encoder) {
+				e.WriteName("float32")
+				e.WriteFloat(math.MaxFloat32, 32)
+			},
+			wantOut:       `float32:3.4028235e+38`,
+			wantOutIndent: `float32: 3.4028235e+38`,
+		},
+		{
+			desc: "float32 nan",
+			write: func(e *text.Encoder) {
+				e.WriteName("float32")
+				e.WriteFloat(math.NaN(), 32)
+			},
+			wantOut:       `float32:nan`,
+			wantOutIndent: `float32: nan`,
+		},
+		{
+			desc: "float32 inf",
+			write: func(e *text.Encoder) {
+				e.WriteName("float32")
+				e.WriteFloat(math.Inf(+1), 32)
+			},
+			wantOut:       `float32:inf`,
+			wantOutIndent: `float32: inf`,
+		},
+		{
+			desc: "float32 -inf",
+			write: func(e *text.Encoder) {
+				e.WriteName("float32")
+				e.WriteFloat(math.Inf(-1), 32)
+			},
+			wantOut:       `float32:-inf`,
+			wantOutIndent: `float32: -inf`,
+		},
+		{
+			desc: "float32 negative zero",
+			write: func(e *text.Encoder) {
+				e.WriteName("float32")
+				e.WriteFloat(math.Copysign(0, -1), 32)
+			},
+			wantOut:       `float32:-0`,
+			wantOutIndent: `float32: -0`,
+		},
+		{
+			desc: "int64 max value",
+			write: func(e *text.Encoder) {
+				e.WriteName("int")
+				e.WriteInt(math.MaxInt64)
+			},
+			wantOut:       `int:9223372036854775807`,
+			wantOutIndent: `int: 9223372036854775807`,
+		},
+		{
+			desc: "int64 min value",
+			write: func(e *text.Encoder) {
+				e.WriteName("int")
+				e.WriteInt(math.MinInt64)
+			},
+			wantOut:       `int:-9223372036854775808`,
+			wantOutIndent: `int: -9223372036854775808`,
+		},
+		{
+			desc: "uint",
+			write: func(e *text.Encoder) {
+				e.WriteName("uint")
+				e.WriteUint(math.MaxUint64)
+			},
+			wantOut:       `uint:18446744073709551615`,
+			wantOutIndent: `uint: 18446744073709551615`,
+		},
+		{
+			desc: "empty message field",
+			write: func(e *text.Encoder) {
+				e.WriteName("m")
+				e.StartMessage()
+				e.EndMessage()
+			},
+			wantOut:       `m:{}`,
+			wantOutIndent: `m: {}`,
+		},
+		{
+			desc: "multiple fields",
+			write: func(e *text.Encoder) {
+				e.WriteName("bool")
+				e.WriteBool(true)
+				e.WriteName("str")
+				e.WriteString("hello")
+				e.WriteName("str")
+				e.WriteString("world")
+				e.WriteName("m")
+				e.StartMessage()
+				e.EndMessage()
+				e.WriteName("[int]")
+				e.WriteInt(49)
+				e.WriteName("float64")
+				e.WriteFloat(1.00023e4, 64)
+				e.WriteName("101")
+				e.WriteString("unknown")
+			},
+			wantOut: `bool:true str:"hello" str:"world" m:{} [int]:49 float64:10002.3 101:"unknown"`,
+			wantOutIndent: `bool: true
+str: "hello"
+str: "world"
+m: {}
+[int]: 49
+float64: 10002.3
+101: "unknown"`,
+		},
+		{
+			desc: "populated message fields",
+			write: func(e *text.Encoder) {
+				e.WriteName("m1")
+				e.StartMessage()
+				{
+					e.WriteName("str")
+					e.WriteString("hello")
+				}
+				e.EndMessage()
+
+				e.WriteName("bool")
+				e.WriteBool(true)
+
+				e.WriteName("m2")
+				e.StartMessage()
+				{
+					e.WriteName("str")
+					e.WriteString("world")
+					e.WriteName("m2-1")
+					e.StartMessage()
+					e.EndMessage()
+					e.WriteName("m2-2")
+					e.StartMessage()
+					{
+						e.WriteName("[int]")
+						e.WriteInt(49)
+					}
+					e.EndMessage()
+					e.WriteName("float64")
+					e.WriteFloat(1.00023e4, 64)
+				}
+				e.EndMessage()
+
+				e.WriteName("101")
+				e.WriteString("unknown")
+			},
+			wantOut: `m1:{str:"hello"} bool:true m2:{str:"world" m2-1:{} m2-2:{[int]:49} float64:10002.3} 101:"unknown"`,
+			wantOutIndent: `m1: {
+	str: "hello"
+}
+bool: true
+m2: {
+	str: "world"
+	m2-1: {}
+	m2-2: {
+		[int]: 49
+	}
+	float64: 10002.3
+}
+101: "unknown"`,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.desc, func(t *testing.T) {
+			runEncoderTest(t, tc, [2]byte{})
+
+			// Test using the angle brackets.
+			// Testcases should not contain characters '{' and '}'.
+			tc.wantOut = replaceDelims(tc.wantOut)
+			tc.wantOutIndent = replaceDelims(tc.wantOutIndent)
+			runEncoderTest(t, tc, [2]byte{'<', '>'})
+		})
+	}
+}
+
+type encoderTestCase struct {
+	desc          string
+	write         func(*text.Encoder)
+	wantOut       string
+	wantOutIndent string
+}
+
+func runEncoderTest(t *testing.T, tc encoderTestCase, delims [2]byte) {
+	t.Helper()
+
+	if tc.wantOut != "" {
+		enc, err := text.NewEncoder("", delims, false)
+		if err != nil {
+			t.Fatalf("NewEncoder returned error: %v", err)
+		}
+		tc.write(enc)
+		got := string(enc.Bytes())
+		if got != tc.wantOut {
+			t.Errorf("(compact)\n<got>\n%v\n<want>\n%v\n", got, tc.wantOut)
+		}
+	}
+	if tc.wantOutIndent != "" {
+		enc, err := text.NewEncoder("\t", delims, false)
+		if err != nil {
+			t.Fatalf("NewEncoder returned error: %v", err)
+		}
+		tc.write(enc)
+		got, want := string(enc.Bytes()), tc.wantOutIndent
+		if got != want {
+			t.Errorf("(multi-line)\n<got>\n%v\n<want>\n%v\n<diff -want +got>\n%v\n",
+				got, want, cmp.Diff(want, got))
+		}
+	}
+}
+
+func replaceDelims(s string) string {
+	s = strings.Replace(s, "{", "<", -1)
+	return strings.Replace(s, "}", ">", -1)
+}
+
+// Test for UTF-8 and ASCII outputs.
+func TestEncodeStrings(t *testing.T) {
+	tests := []struct {
+		in           string
+		wantOut      string
+		wantOutASCII string
+	}{
+		{
+			in:      `"`,
+			wantOut: `"\""`,
+		},
+		{
+			in:      `'`,
+			wantOut: `"'"`,
+		},
+		{
+			in:           "hello\u1234world",
+			wantOut:      "\"hello\u1234world\"",
+			wantOutASCII: `"hello\u1234world"`,
+		},
+		{
+			// String that has as few escaped characters as possible.
+			in: func() string {
+				var b []byte
+				for i := 0; i < utf8.RuneSelf; i++ {
+					switch i {
+					case 0, '\\', '\n', '\'': // these must be escaped, so ignore them
+					default:
+						b = append(b, byte(i))
+					}
+				}
+				return string(b)
+			}(),
+			wantOut:      `"\x01\x02\x03\x04\x05\x06\x07\x08\t\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !\"#$%&()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_` + "`abcdefghijklmnopqrstuvwxyz{|}~\x7f\"",
+			wantOutASCII: `"\x01\x02\x03\x04\x05\x06\x07\x08\t\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !\"#$%&()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_` + "`abcdefghijklmnopqrstuvwxyz{|}~\x7f\"",
+		},
+		{
+			// Valid UTF-8 wire encoding of the RuneError rune.
+			in:           string(utf8.RuneError),
+			wantOut:      `"` + string(utf8.RuneError) + `"`,
+			wantOutASCII: `"\ufffd"`,
+		},
+		{
+			in:           "\"'\\?\a\b\n\r\t\v\f\x01\nS\n\xab\x12\uab8f\U0010ffff",
+			wantOut:      `"\"'\\?\x07\x08\n\r\t\x0b\x0c\x01\nS\n\xab\x12` + "\uab8f\U0010ffff" + `"`,
+			wantOutASCII: `"\"'\\?\x07\x08\n\r\t\x0b\x0c\x01\nS\n\xab\x12\uab8f\U0010ffff"`,
+		},
+		{
+			in:           "\001x",
+			wantOut:      `"\x01x"`,
+			wantOutASCII: `"\x01x"`,
+		},
+		{
+			in:           "\012x",
+			wantOut:      `"\nx"`,
+			wantOutASCII: `"\nx"`,
+		},
+		{
+			in:           "\123x",
+			wantOut:      `"Sx"`,
+			wantOutASCII: `"Sx"`,
+		},
+		{
+			in:           "\1234x",
+			wantOut:      `"S4x"`,
+			wantOutASCII: `"S4x"`,
+		},
+		{
+			in:           "\001",
+			wantOut:      `"\x01"`,
+			wantOutASCII: `"\x01"`,
+		},
+		{
+			in:           "\012",
+			wantOut:      `"\n"`,
+			wantOutASCII: `"\n"`,
+		},
+		{
+			in:           "\123",
+			wantOut:      `"S"`,
+			wantOutASCII: `"S"`,
+		},
+		{
+			in:           "\1234",
+			wantOut:      `"S4"`,
+			wantOutASCII: `"S4"`,
+		},
+		{
+			in:           "\377",
+			wantOut:      `"\xff"`,
+			wantOutASCII: `"\xff"`,
+		},
+		{
+			in:           "\x0fx",
+			wantOut:      `"\x0fx"`,
+			wantOutASCII: `"\x0fx"`,
+		},
+		{
+			in:           "\xffx",
+			wantOut:      `"\xffx"`,
+			wantOutASCII: `"\xffx"`,
+		},
+		{
+			in:           "\xfffx",
+			wantOut:      `"\xfffx"`,
+			wantOutASCII: `"\xfffx"`,
+		},
+		{
+			in:           "\x0f",
+			wantOut:      `"\x0f"`,
+			wantOutASCII: `"\x0f"`,
+		},
+		{
+			in:           "\xff",
+			wantOut:      `"\xff"`,
+			wantOutASCII: `"\xff"`,
+		},
+		{
+			in:           "\xfff",
+			wantOut:      `"\xfff"`,
+			wantOutASCII: `"\xfff"`,
+		},
+	}
+	for _, tc := range tests {
+		t.Run("", func(t *testing.T) {
+			if tc.wantOut != "" {
+				runEncodeStringsTest(t, tc.in, tc.wantOut, false)
+			}
+			if tc.wantOutASCII != "" {
+				runEncodeStringsTest(t, tc.in, tc.wantOutASCII, true)
+			}
+		})
+	}
+}
+
+func runEncodeStringsTest(t *testing.T, in string, want string, outputASCII bool) {
+	t.Helper()
+
+	charType := "UTF-8"
+	if outputASCII {
+		charType = "ASCII"
+	}
+
+	enc, err := text.NewEncoder("", [2]byte{}, outputASCII)
+	if err != nil {
+		t.Fatalf("[%s] NewEncoder returned error: %v", charType, err)
+	}
+	enc.WriteString(in)
+	got := string(enc.Bytes())
+	if got != want {
+		t.Errorf("[%s] WriteString(%q)\n<got>\n%v\n<want>\n%v\n", charType, in, got, want)
+	}
+}
+
+func TestReset(t *testing.T) {
+	enc, err := text.NewEncoder("\t", [2]byte{}, false)
+	if err != nil {
+		t.Fatalf("NewEncoder returned error: %v", err)
+	}
+
+	enc.WriteName("foo")
+	pos := enc.Snapshot()
+
+	// Attempt to write a message value.
+	enc.StartMessage()
+	enc.WriteName("bar")
+	enc.WriteUint(10)
+
+	// Reset the value and decided to write a string value instead.
+	enc.Reset(pos)
+	enc.WriteString("0123456789")
+
+	got := string(enc.Bytes())
+	want := `foo: "0123456789"`
+	if got != want {
+		t.Errorf("Reset did not restore given position:\n<got>\n%v\n<want>\n%v\n", got, want)
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/errors/errors.go b/vendor/google.golang.org/protobuf/internal/errors/errors.go
new file mode 100644
index 000000000..20c17b35e
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/errors/errors.go
@@ -0,0 +1,89 @@
+// 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 errors implements functions to manipulate errors.
+package errors
+
+import (
+	"errors"
+	"fmt"
+
+	"google.golang.org/protobuf/internal/detrand"
+)
+
+// Error is a sentinel matching all errors produced by this package.
+var Error = errors.New("protobuf error")
+
+// New formats a string according to the format specifier and arguments and
+// returns an error that has a "proto" prefix.
+func New(f string, x ...interface{}) error {
+	return &prefixError{s: format(f, x...)}
+}
+
+type prefixError struct{ s string }
+
+var prefix = func() string {
+	// Deliberately introduce instability into the error message string to
+	// discourage users from performing error string comparisons.
+	if detrand.Bool() {
+		return "proto: " // use non-breaking spaces (U+00a0)
+	} else {
+		return "proto: " // use regular spaces (U+0020)
+	}
+}()
+
+func (e *prefixError) Error() string {
+	return prefix + e.s
+}
+
+func (e *prefixError) Unwrap() error {
+	return Error
+}
+
+// Wrap returns an error that has a "proto" prefix, the formatted string described
+// by the format specifier and arguments, and a suffix of err. The error wraps err.
+func Wrap(err error, f string, x ...interface{}) error {
+	return &wrapError{
+		s:   format(f, x...),
+		err: err,
+	}
+}
+
+type wrapError struct {
+	s   string
+	err error
+}
+
+func (e *wrapError) Error() string {
+	return format("%v%v: %v", prefix, e.s, e.err)
+}
+
+func (e *wrapError) Unwrap() error {
+	return e.err
+}
+
+func (e *wrapError) Is(target error) bool {
+	return target == Error
+}
+
+func format(f string, x ...interface{}) string {
+	// avoid "proto: " prefix when chaining
+	for i := 0; i < len(x); i++ {
+		switch e := x[i].(type) {
+		case *prefixError:
+			x[i] = e.s
+		case *wrapError:
+			x[i] = format("%v: %v", e.s, e.err)
+		}
+	}
+	return fmt.Sprintf(f, x...)
+}
+
+func InvalidUTF8(name string) error {
+	return New("field %v contains invalid UTF-8", name)
+}
+
+func RequiredNotSet(name string) error {
+	return New("required field %v not set", name)
+}
diff --git a/vendor/google.golang.org/protobuf/internal/errors/errors_test.go b/vendor/google.golang.org/protobuf/internal/errors/errors_test.go
new file mode 100644
index 000000000..804eb96c2
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/errors/errors_test.go
@@ -0,0 +1,67 @@
+// 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 errors
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestErrors(t *testing.T) {
+	var sentinel = New("sentinel")
+	var foreign = errors.New("foreign")
+	for _, test := range []struct {
+		what     string
+		err      error
+		wantText string
+		is       []error
+		isNot    []error
+	}{{
+		what:     `New("abc")`,
+		err:      New("abc"),
+		wantText: "abc",
+	}, {
+		what:     `New("%v", sentinel)`,
+		err:      New("%v", sentinel),
+		wantText: "sentinel",
+		isNot:    []error{sentinel},
+	}, {
+		what:     `Wrap(sentinel, "%v", "text")`,
+		err:      Wrap(sentinel, "%v", "text"),
+		wantText: "text: sentinel",
+		is:       []error{sentinel},
+	}, {
+		what:     `New("%v", foreign)`,
+		err:      New("%v", foreign),
+		wantText: "foreign",
+		isNot:    []error{foreign},
+	}, {
+		what:     `Wrap(foreign, "%v", "text")`,
+		err:      Wrap(foreign, "%v", "text"),
+		wantText: "text: foreign",
+		is:       []error{foreign},
+	}} {
+		if got, want := test.err.Error(), prefix; !strings.HasPrefix(got, want) {
+			t.Errorf("%v.Error() = %q, want prefix %q", test.what, got, want)
+		}
+		if got, want := test.err.Error(), prefix+test.wantText; got != want {
+			t.Errorf("%v.Error() = %q, want %q", test.what, got, want)
+		}
+		if got, want := Is(test.err, Error), true; got != want {
+			t.Errorf("errors.Is(%v, errors.Error) = %v, want %v", test.what, got, want)
+		}
+		for _, err := range test.is {
+			if got, want := Is(test.err, err), true; got != want {
+				t.Errorf("errors.Is(%v, %v) = %v, want %v", test.what, err, got, want)
+			}
+		}
+		for _, err := range test.isNot {
+			if got, want := Is(test.err, err), false; got != want {
+				t.Errorf("errors.Is(%v, %v) = %v, want %v", test.what, err, got, want)
+			}
+		}
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/errors/is_go112.go b/vendor/google.golang.org/protobuf/internal/errors/is_go112.go
new file mode 100644
index 000000000..f90e909b3
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/errors/is_go112.go
@@ -0,0 +1,39 @@
+// Copyright 2020 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.
+
+// +build !go1.13
+
+package errors
+
+import "reflect"
+
+// Is is a copy of Go 1.13's errors.Is for use with older Go versions.
+func Is(err, target error) bool {
+	if target == nil {
+		return err == target
+	}
+
+	isComparable := reflect.TypeOf(target).Comparable()
+	for {
+		if isComparable && err == target {
+			return true
+		}
+		if x, ok := err.(interface{ Is(error) bool }); ok && x.Is(target) {
+			return true
+		}
+		if err = unwrap(err); err == nil {
+			return false
+		}
+	}
+}
+
+func unwrap(err error) error {
+	u, ok := err.(interface {
+		Unwrap() error
+	})
+	if !ok {
+		return nil
+	}
+	return u.Unwrap()
+}
diff --git a/vendor/google.golang.org/protobuf/internal/errors/is_go113.go b/vendor/google.golang.org/protobuf/internal/errors/is_go113.go
new file mode 100644
index 000000000..dc05f4191
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/errors/is_go113.go
@@ -0,0 +1,12 @@
+// Copyright 2020 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.
+
+// +build go1.13
+
+package errors
+
+import "errors"
+
+// Is is errors.Is.
+func Is(err, target error) bool { return errors.Is(err, target) }
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/any_gen.go b/vendor/google.golang.org/protobuf/internal/fieldnum/any_gen.go
new file mode 100644
index 000000000..74c5fef24
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/fieldnum/any_gen.go
@@ -0,0 +1,13 @@
+// Copyright 2019 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.
+
+// Code generated by generate-protos. DO NOT EDIT.
+
+package fieldnum
+
+// Field numbers for google.protobuf.Any.
+const (
+	Any_TypeUrl = 1 // optional string
+	Any_Value   = 2 // optional bytes
+)
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/api_gen.go b/vendor/google.golang.org/protobuf/internal/fieldnum/api_gen.go
new file mode 100644
index 000000000..9a6b5f29b
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/fieldnum/api_gen.go
@@ -0,0 +1,35 @@
+// Copyright 2019 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.
+
+// Code generated by generate-protos. DO NOT EDIT.
+
+package fieldnum
+
+// Field numbers for google.protobuf.Api.
+const (
+	Api_Name          = 1 // optional string
+	Api_Methods       = 2 // repeated google.protobuf.Method
+	Api_Options       = 3 // repeated google.protobuf.Option
+	Api_Version       = 4 // optional string
+	Api_SourceContext = 5 // optional google.protobuf.SourceContext
+	Api_Mixins        = 6 // repeated google.protobuf.Mixin
+	Api_Syntax        = 7 // optional google.protobuf.Syntax
+)
+
+// Field numbers for google.protobuf.Method.
+const (
+	Method_Name              = 1 // optional string
+	Method_RequestTypeUrl    = 2 // optional string
+	Method_RequestStreaming  = 3 // optional bool
+	Method_ResponseTypeUrl   = 4 // optional string
+	Method_ResponseStreaming = 5 // optional bool
+	Method_Options           = 6 // repeated google.protobuf.Option
+	Method_Syntax            = 7 // optional google.protobuf.Syntax
+)
+
+// Field numbers for google.protobuf.Mixin.
+const (
+	Mixin_Name = 1 // optional string
+	Mixin_Root = 2 // optional string
+)
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/descriptor_gen.go b/vendor/google.golang.org/protobuf/internal/fieldnum/descriptor_gen.go
new file mode 100644
index 000000000..6e37b59e9
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/fieldnum/descriptor_gen.go
@@ -0,0 +1,240 @@
+// Copyright 2019 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.
+
+// Code generated by generate-protos. DO NOT EDIT.
+
+package fieldnum
+
+// Field numbers for google.protobuf.FileDescriptorSet.
+const (
+	FileDescriptorSet_File = 1 // repeated google.protobuf.FileDescriptorProto
+)
+
+// Field numbers for google.protobuf.FileDescriptorProto.
+const (
+	FileDescriptorProto_Name             = 1  // optional string
+	FileDescriptorProto_Package          = 2  // optional string
+	FileDescriptorProto_Dependency       = 3  // repeated string
+	FileDescriptorProto_PublicDependency = 10 // repeated int32
+	FileDescriptorProto_WeakDependency   = 11 // repeated int32
+	FileDescriptorProto_MessageType      = 4  // repeated google.protobuf.DescriptorProto
+	FileDescriptorProto_EnumType         = 5  // repeated google.protobuf.EnumDescriptorProto
+	FileDescriptorProto_Service          = 6  // repeated google.protobuf.ServiceDescriptorProto
+	FileDescriptorProto_Extension        = 7  // repeated google.protobuf.FieldDescriptorProto
+	FileDescriptorProto_Options          = 8  // optional google.protobuf.FileOptions
+	FileDescriptorProto_SourceCodeInfo   = 9  // optional google.protobuf.SourceCodeInfo
+	FileDescriptorProto_Syntax           = 12 // optional string
+)
+
+// Field numbers for google.protobuf.DescriptorProto.
+const (
+	DescriptorProto_Name           = 1  // optional string
+	DescriptorProto_Field          = 2  // repeated google.protobuf.FieldDescriptorProto
+	DescriptorProto_Extension      = 6  // repeated google.protobuf.FieldDescriptorProto
+	DescriptorProto_NestedType     = 3  // repeated google.protobuf.DescriptorProto
+	DescriptorProto_EnumType       = 4  // repeated google.protobuf.EnumDescriptorProto
+	DescriptorProto_ExtensionRange = 5  // repeated google.protobuf.DescriptorProto.ExtensionRange
+	DescriptorProto_OneofDecl      = 8  // repeated google.protobuf.OneofDescriptorProto
+	DescriptorProto_Options        = 7  // optional google.protobuf.MessageOptions
+	DescriptorProto_ReservedRange  = 9  // repeated google.protobuf.DescriptorProto.ReservedRange
+	DescriptorProto_ReservedName   = 10 // repeated string
+)
+
+// Field numbers for google.protobuf.DescriptorProto.ExtensionRange.
+const (
+	DescriptorProto_ExtensionRange_Start   = 1 // optional int32
+	DescriptorProto_ExtensionRange_End     = 2 // optional int32
+	DescriptorProto_ExtensionRange_Options = 3 // optional google.protobuf.ExtensionRangeOptions
+)
+
+// Field numbers for google.protobuf.DescriptorProto.ReservedRange.
+const (
+	DescriptorProto_ReservedRange_Start = 1 // optional int32
+	DescriptorProto_ReservedRange_End   = 2 // optional int32
+)
+
+// Field numbers for google.protobuf.ExtensionRangeOptions.
+const (
+	ExtensionRangeOptions_UninterpretedOption = 999 // repeated google.protobuf.UninterpretedOption
+)
+
+// Field numbers for google.protobuf.FieldDescriptorProto.
+const (
+	FieldDescriptorProto_Name           = 1  // optional string
+	FieldDescriptorProto_Number         = 3  // optional int32
+	FieldDescriptorProto_Label          = 4  // optional google.protobuf.FieldDescriptorProto.Label
+	FieldDescriptorProto_Type           = 5  // optional google.protobuf.FieldDescriptorProto.Type
+	FieldDescriptorProto_TypeName       = 6  // optional string
+	FieldDescriptorProto_Extendee       = 2  // optional string
+	FieldDescriptorProto_DefaultValue   = 7  // optional string
+	FieldDescriptorProto_OneofIndex     = 9  // optional int32
+	FieldDescriptorProto_JsonName       = 10 // optional string
+	FieldDescriptorProto_Options        = 8  // optional google.protobuf.FieldOptions
+	FieldDescriptorProto_Proto3Optional = 17 // optional bool
+)
+
+// Field numbers for google.protobuf.OneofDescriptorProto.
+const (
+	OneofDescriptorProto_Name    = 1 // optional string
+	OneofDescriptorProto_Options = 2 // optional google.protobuf.OneofOptions
+)
+
+// Field numbers for google.protobuf.EnumDescriptorProto.
+const (
+	EnumDescriptorProto_Name          = 1 // optional string
+	EnumDescriptorProto_Value         = 2 // repeated google.protobuf.EnumValueDescriptorProto
+	EnumDescriptorProto_Options       = 3 // optional google.protobuf.EnumOptions
+	EnumDescriptorProto_ReservedRange = 4 // repeated google.protobuf.EnumDescriptorProto.EnumReservedRange
+	EnumDescriptorProto_ReservedName  = 5 // repeated string
+)
+
+// Field numbers for google.protobuf.EnumDescriptorProto.EnumReservedRange.
+const (
+	EnumDescriptorProto_EnumReservedRange_Start = 1 // optional int32
+	EnumDescriptorProto_EnumReservedRange_End   = 2 // optional int32
+)
+
+// Field numbers for google.protobuf.EnumValueDescriptorProto.
+const (
+	EnumValueDescriptorProto_Name    = 1 // optional string
+	EnumValueDescriptorProto_Number  = 2 // optional int32
+	EnumValueDescriptorProto_Options = 3 // optional google.protobuf.EnumValueOptions
+)
+
+// Field numbers for google.protobuf.ServiceDescriptorProto.
+const (
+	ServiceDescriptorProto_Name    = 1 // optional string
+	ServiceDescriptorProto_Method  = 2 // repeated google.protobuf.MethodDescriptorProto
+	ServiceDescriptorProto_Options = 3 // optional google.protobuf.ServiceOptions
+)
+
+// Field numbers for google.protobuf.MethodDescriptorProto.
+const (
+	MethodDescriptorProto_Name            = 1 // optional string
+	MethodDescriptorProto_InputType       = 2 // optional string
+	MethodDescriptorProto_OutputType      = 3 // optional string
+	MethodDescriptorProto_Options         = 4 // optional google.protobuf.MethodOptions
+	MethodDescriptorProto_ClientStreaming = 5 // optional bool
+	MethodDescriptorProto_ServerStreaming = 6 // optional bool
+)
+
+// Field numbers for google.protobuf.FileOptions.
+const (
+	FileOptions_JavaPackage               = 1   // optional string
+	FileOptions_JavaOuterClassname        = 8   // optional string
+	FileOptions_JavaMultipleFiles         = 10  // optional bool
+	FileOptions_JavaGenerateEqualsAndHash = 20  // optional bool
+	FileOptions_JavaStringCheckUtf8       = 27  // optional bool
+	FileOptions_OptimizeFor               = 9   // optional google.protobuf.FileOptions.OptimizeMode
+	FileOptions_GoPackage                 = 11  // optional string
+	FileOptions_CcGenericServices         = 16  // optional bool
+	FileOptions_JavaGenericServices       = 17  // optional bool
+	FileOptions_PyGenericServices         = 18  // optional bool
+	FileOptions_PhpGenericServices        = 42  // optional bool
+	FileOptions_Deprecated                = 23  // optional bool
+	FileOptions_CcEnableArenas            = 31  // optional bool
+	FileOptions_ObjcClassPrefix           = 36  // optional string
+	FileOptions_CsharpNamespace           = 37  // optional string
+	FileOptions_SwiftPrefix               = 39  // optional string
+	FileOptions_PhpClassPrefix            = 40  // optional string
+	FileOptions_PhpNamespace              = 41  // optional string
+	FileOptions_PhpMetadataNamespace      = 44  // optional string
+	FileOptions_RubyPackage               = 45  // optional string
+	FileOptions_UninterpretedOption       = 999 // repeated google.protobuf.UninterpretedOption
+)
+
+// Field numbers for google.protobuf.MessageOptions.
+const (
+	MessageOptions_MessageSetWireFormat         = 1   // optional bool
+	MessageOptions_NoStandardDescriptorAccessor = 2   // optional bool
+	MessageOptions_Deprecated                   = 3   // optional bool
+	MessageOptions_MapEntry                     = 7   // optional bool
+	MessageOptions_UninterpretedOption          = 999 // repeated google.protobuf.UninterpretedOption
+)
+
+// Field numbers for google.protobuf.FieldOptions.
+const (
+	FieldOptions_Ctype               = 1   // optional google.protobuf.FieldOptions.CType
+	FieldOptions_Packed              = 2   // optional bool
+	FieldOptions_Jstype              = 6   // optional google.protobuf.FieldOptions.JSType
+	FieldOptions_Lazy                = 5   // optional bool
+	FieldOptions_Deprecated          = 3   // optional bool
+	FieldOptions_Weak                = 10  // optional bool
+	FieldOptions_UninterpretedOption = 999 // repeated google.protobuf.UninterpretedOption
+)
+
+// Field numbers for google.protobuf.OneofOptions.
+const (
+	OneofOptions_UninterpretedOption = 999 // repeated google.protobuf.UninterpretedOption
+)
+
+// Field numbers for google.protobuf.EnumOptions.
+const (
+	EnumOptions_AllowAlias          = 2   // optional bool
+	EnumOptions_Deprecated          = 3   // optional bool
+	EnumOptions_UninterpretedOption = 999 // repeated google.protobuf.UninterpretedOption
+)
+
+// Field numbers for google.protobuf.EnumValueOptions.
+const (
+	EnumValueOptions_Deprecated          = 1   // optional bool
+	EnumValueOptions_UninterpretedOption = 999 // repeated google.protobuf.UninterpretedOption
+)
+
+// Field numbers for google.protobuf.ServiceOptions.
+const (
+	ServiceOptions_Deprecated          = 33  // optional bool
+	ServiceOptions_UninterpretedOption = 999 // repeated google.protobuf.UninterpretedOption
+)
+
+// Field numbers for google.protobuf.MethodOptions.
+const (
+	MethodOptions_Deprecated          = 33  // optional bool
+	MethodOptions_IdempotencyLevel    = 34  // optional google.protobuf.MethodOptions.IdempotencyLevel
+	MethodOptions_UninterpretedOption = 999 // repeated google.protobuf.UninterpretedOption
+)
+
+// Field numbers for google.protobuf.UninterpretedOption.
+const (
+	UninterpretedOption_Name             = 2 // repeated google.protobuf.UninterpretedOption.NamePart
+	UninterpretedOption_IdentifierValue  = 3 // optional string
+	UninterpretedOption_PositiveIntValue = 4 // optional uint64
+	UninterpretedOption_NegativeIntValue = 5 // optional int64
+	UninterpretedOption_DoubleValue      = 6 // optional double
+	UninterpretedOption_StringValue      = 7 // optional bytes
+	UninterpretedOption_AggregateValue   = 8 // optional string
+)
+
+// Field numbers for google.protobuf.UninterpretedOption.NamePart.
+const (
+	UninterpretedOption_NamePart_NamePart    = 1 // required string
+	UninterpretedOption_NamePart_IsExtension = 2 // required bool
+)
+
+// Field numbers for google.protobuf.SourceCodeInfo.
+const (
+	SourceCodeInfo_Location = 1 // repeated google.protobuf.SourceCodeInfo.Location
+)
+
+// Field numbers for google.protobuf.SourceCodeInfo.Location.
+const (
+	SourceCodeInfo_Location_Path                    = 1 // repeated int32
+	SourceCodeInfo_Location_Span                    = 2 // repeated int32
+	SourceCodeInfo_Location_LeadingComments         = 3 // optional string
+	SourceCodeInfo_Location_TrailingComments        = 4 // optional string
+	SourceCodeInfo_Location_LeadingDetachedComments = 6 // repeated string
+)
+
+// Field numbers for google.protobuf.GeneratedCodeInfo.
+const (
+	GeneratedCodeInfo_Annotation = 1 // repeated google.protobuf.GeneratedCodeInfo.Annotation
+)
+
+// Field numbers for google.protobuf.GeneratedCodeInfo.Annotation.
+const (
+	GeneratedCodeInfo_Annotation_Path       = 1 // repeated int32
+	GeneratedCodeInfo_Annotation_SourceFile = 2 // optional string
+	GeneratedCodeInfo_Annotation_Begin      = 3 // optional int32
+	GeneratedCodeInfo_Annotation_End        = 4 // optional int32
+)
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/doc.go b/vendor/google.golang.org/protobuf/internal/fieldnum/doc.go
new file mode 100644
index 000000000..e59788599
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/fieldnum/doc.go
@@ -0,0 +1,7 @@
+// Copyright 2019 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 fieldnum contains constants for field numbers of fields in messages
+// declared in descriptor.proto and any of the well-known types.
+package fieldnum
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/duration_gen.go b/vendor/google.golang.org/protobuf/internal/fieldnum/duration_gen.go
new file mode 100644
index 000000000..8816c7358
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/fieldnum/duration_gen.go
@@ -0,0 +1,13 @@
+// Copyright 2019 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.
+
+// Code generated by generate-protos. DO NOT EDIT.
+
+package fieldnum
+
+// Field numbers for google.protobuf.Duration.
+const (
+	Duration_Seconds = 1 // optional int64
+	Duration_Nanos   = 2 // optional int32
+)
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/empty_gen.go b/vendor/google.golang.org/protobuf/internal/fieldnum/empty_gen.go
new file mode 100644
index 000000000..b5130a6dd
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/fieldnum/empty_gen.go
@@ -0,0 +1,10 @@
+// Copyright 2019 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.
+
+// Code generated by generate-protos. DO NOT EDIT.
+
+package fieldnum
+
+// Field numbers for google.protobuf.Empty.
+const ()
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/field_mask_gen.go b/vendor/google.golang.org/protobuf/internal/fieldnum/field_mask_gen.go
new file mode 100644
index 000000000..7e3bfa27b
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/fieldnum/field_mask_gen.go
@@ -0,0 +1,12 @@
+// Copyright 2019 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.
+
+// Code generated by generate-protos. DO NOT EDIT.
+
+package fieldnum
+
+// Field numbers for google.protobuf.FieldMask.
+const (
+	FieldMask_Paths = 1 // repeated string
+)
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/source_context_gen.go b/vendor/google.golang.org/protobuf/internal/fieldnum/source_context_gen.go
new file mode 100644
index 000000000..241972b1f
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/fieldnum/source_context_gen.go
@@ -0,0 +1,12 @@
+// Copyright 2019 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.
+
+// Code generated by generate-protos. DO NOT EDIT.
+
+package fieldnum
+
+// Field numbers for google.protobuf.SourceContext.
+const (
+	SourceContext_FileName = 1 // optional string
+)
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/struct_gen.go b/vendor/google.golang.org/protobuf/internal/fieldnum/struct_gen.go
new file mode 100644
index 000000000..c460aab44
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/fieldnum/struct_gen.go
@@ -0,0 +1,33 @@
+// Copyright 2019 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.
+
+// Code generated by generate-protos. DO NOT EDIT.
+
+package fieldnum
+
+// Field numbers for google.protobuf.Struct.
+const (
+	Struct_Fields = 1 // repeated google.protobuf.Struct.FieldsEntry
+)
+
+// Field numbers for google.protobuf.Struct.FieldsEntry.
+const (
+	Struct_FieldsEntry_Key   = 1 // optional string
+	Struct_FieldsEntry_Value = 2 // optional google.protobuf.Value
+)
+
+// Field numbers for google.protobuf.Value.
+const (
+	Value_NullValue   = 1 // optional google.protobuf.NullValue
+	Value_NumberValue = 2 // optional double
+	Value_StringValue = 3 // optional string
+	Value_BoolValue   = 4 // optional bool
+	Value_StructValue = 5 // optional google.protobuf.Struct
+	Value_ListValue   = 6 // optional google.protobuf.ListValue
+)
+
+// Field numbers for google.protobuf.ListValue.
+const (
+	ListValue_Values = 1 // repeated google.protobuf.Value
+)
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/timestamp_gen.go b/vendor/google.golang.org/protobuf/internal/fieldnum/timestamp_gen.go
new file mode 100644
index 000000000..b4346fba5
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/fieldnum/timestamp_gen.go
@@ -0,0 +1,13 @@
+// Copyright 2019 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.
+
+// Code generated by generate-protos. DO NOT EDIT.
+
+package fieldnum
+
+// Field numbers for google.protobuf.Timestamp.
+const (
+	Timestamp_Seconds = 1 // optional int64
+	Timestamp_Nanos   = 2 // optional int32
+)
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/type_gen.go b/vendor/google.golang.org/protobuf/internal/fieldnum/type_gen.go
new file mode 100644
index 000000000..b392e9598
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/fieldnum/type_gen.go
@@ -0,0 +1,53 @@
+// Copyright 2019 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.
+
+// Code generated by generate-protos. DO NOT EDIT.
+
+package fieldnum
+
+// Field numbers for google.protobuf.Type.
+const (
+	Type_Name          = 1 // optional string
+	Type_Fields        = 2 // repeated google.protobuf.Field
+	Type_Oneofs        = 3 // repeated string
+	Type_Options       = 4 // repeated google.protobuf.Option
+	Type_SourceContext = 5 // optional google.protobuf.SourceContext
+	Type_Syntax        = 6 // optional google.protobuf.Syntax
+)
+
+// Field numbers for google.protobuf.Field.
+const (
+	Field_Kind         = 1  // optional google.protobuf.Field.Kind
+	Field_Cardinality  = 2  // optional google.protobuf.Field.Cardinality
+	Field_Number       = 3  // optional int32
+	Field_Name         = 4  // optional string
+	Field_TypeUrl      = 6  // optional string
+	Field_OneofIndex   = 7  // optional int32
+	Field_Packed       = 8  // optional bool
+	Field_Options      = 9  // repeated google.protobuf.Option
+	Field_JsonName     = 10 // optional string
+	Field_DefaultValue = 11 // optional string
+)
+
+// Field numbers for google.protobuf.Enum.
+const (
+	Enum_Name          = 1 // optional string
+	Enum_Enumvalue     = 2 // repeated google.protobuf.EnumValue
+	Enum_Options       = 3 // repeated google.protobuf.Option
+	Enum_SourceContext = 4 // optional google.protobuf.SourceContext
+	Enum_Syntax        = 5 // optional google.protobuf.Syntax
+)
+
+// Field numbers for google.protobuf.EnumValue.
+const (
+	EnumValue_Name    = 1 // optional string
+	EnumValue_Number  = 2 // optional int32
+	EnumValue_Options = 3 // repeated google.protobuf.Option
+)
+
+// Field numbers for google.protobuf.Option.
+const (
+	Option_Name  = 1 // optional string
+	Option_Value = 2 // optional google.protobuf.Any
+)
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/wrappers_gen.go b/vendor/google.golang.org/protobuf/internal/fieldnum/wrappers_gen.go
new file mode 100644
index 000000000..42f846a9f
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/fieldnum/wrappers_gen.go
@@ -0,0 +1,52 @@
+// Copyright 2019 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.
+
+// Code generated by generate-protos. DO NOT EDIT.
+
+package fieldnum
+
+// Field numbers for google.protobuf.DoubleValue.
+const (
+	DoubleValue_Value = 1 // optional double
+)
+
+// Field numbers for google.protobuf.FloatValue.
+const (
+	FloatValue_Value = 1 // optional float
+)
+
+// Field numbers for google.protobuf.Int64Value.
+const (
+	Int64Value_Value = 1 // optional int64
+)
+
+// Field numbers for google.protobuf.UInt64Value.
+const (
+	UInt64Value_Value = 1 // optional uint64
+)
+
+// Field numbers for google.protobuf.Int32Value.
+const (
+	Int32Value_Value = 1 // optional int32
+)
+
+// Field numbers for google.protobuf.UInt32Value.
+const (
+	UInt32Value_Value = 1 // optional uint32
+)
+
+// Field numbers for google.protobuf.BoolValue.
+const (
+	BoolValue_Value = 1 // optional bool
+)
+
+// Field numbers for google.protobuf.StringValue.
+const (
+	StringValue_Value = 1 // optional string
+)
+
+// Field numbers for google.protobuf.BytesValue.
+const (
+	BytesValue_Value = 1 // optional bytes
+)
diff --git a/vendor/google.golang.org/protobuf/internal/fieldsort/fieldsort.go b/vendor/google.golang.org/protobuf/internal/fieldsort/fieldsort.go
new file mode 100644
index 000000000..517c4e2a0
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/fieldsort/fieldsort.go
@@ -0,0 +1,40 @@
+// Copyright 2019 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 fieldsort defines an ordering of fields.
+//
+// The ordering defined by this package matches the historic behavior of the proto
+// package, placing extensions first and oneofs last.
+//
+// There is no guarantee about stability of the wire encoding, and users should not
+// depend on the order defined in this package as it is subject to change without
+// notice.
+package fieldsort
+
+import (
+	"google.golang.org/protobuf/reflect/protoreflect"
+)
+
+// Less returns true if field a comes before field j in ordered wire marshal output.
+func Less(a, b protoreflect.FieldDescriptor) bool {
+	ea := a.IsExtension()
+	eb := b.IsExtension()
+	oa := a.ContainingOneof()
+	ob := b.ContainingOneof()
+	switch {
+	case ea != eb:
+		return ea
+	case oa != nil && ob != nil:
+		if oa == ob {
+			return a.Number() < b.Number()
+		}
+		return oa.Index() < ob.Index()
+	case oa != nil && !oa.IsSynthetic():
+		return false
+	case ob != nil && !ob.IsSynthetic():
+		return true
+	default:
+		return a.Number() < b.Number()
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/filedesc/build.go b/vendor/google.golang.org/protobuf/internal/filedesc/build.go
new file mode 100644
index 000000000..462d384e9
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/filedesc/build.go
@@ -0,0 +1,155 @@
+// Copyright 2019 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 filedesc provides functionality for constructing descriptors.
+package filedesc
+
+import (
+	"google.golang.org/protobuf/encoding/protowire"
+	"google.golang.org/protobuf/internal/fieldnum"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+	preg "google.golang.org/protobuf/reflect/protoregistry"
+)
+
+// Builder construct a protoreflect.FileDescriptor from the raw descriptor.
+type Builder struct {
+	// GoPackagePath is the Go package path that is invoking this builder.
+	GoPackagePath string
+
+	// RawDescriptor is the wire-encoded bytes of FileDescriptorProto
+	// and must be populated.
+	RawDescriptor []byte
+
+	// NumEnums is the total number of enums declared in the file.
+	NumEnums int32
+	// NumMessages is the total number of messages declared in the file.
+	// It includes the implicit message declarations for map entries.
+	NumMessages int32
+	// NumExtensions is the total number of extensions declared in the file.
+	NumExtensions int32
+	// NumServices is the total number of services declared in the file.
+	NumServices int32
+
+	// TypeResolver resolves extension field types for descriptor options.
+	// If nil, it uses protoregistry.GlobalTypes.
+	TypeResolver interface {
+		preg.ExtensionTypeResolver
+	}
+
+	// FileRegistry is use to lookup file, enum, and message dependencies.
+	// Once constructed, the file descriptor is registered here.
+	// If nil, it uses protoregistry.GlobalFiles.
+	FileRegistry interface {
+		FindFileByPath(string) (protoreflect.FileDescriptor, error)
+		FindDescriptorByName(pref.FullName) (pref.Descriptor, error)
+		RegisterFile(pref.FileDescriptor) error
+	}
+}
+
+// resolverByIndex is an interface Builder.FileRegistry may implement.
+// If so, it permits looking up an enum or message dependency based on the
+// sub-list and element index into filetype.Builder.DependencyIndexes.
+type resolverByIndex interface {
+	FindEnumByIndex(int32, int32, []Enum, []Message) pref.EnumDescriptor
+	FindMessageByIndex(int32, int32, []Enum, []Message) pref.MessageDescriptor
+}
+
+// Indexes of each sub-list in filetype.Builder.DependencyIndexes.
+const (
+	listFieldDeps int32 = iota
+	listExtTargets
+	listExtDeps
+	listMethInDeps
+	listMethOutDeps
+)
+
+// Out is the output of the Builder.
+type Out struct {
+	File pref.FileDescriptor
+
+	// Enums is all enum descriptors in "flattened ordering".
+	Enums []Enum
+	// Messages is all message descriptors in "flattened ordering".
+	// It includes the implicit message declarations for map entries.
+	Messages []Message
+	// Extensions is all extension descriptors in "flattened ordering".
+	Extensions []Extension
+	// Service is all service descriptors in "flattened ordering".
+	Services []Service
+}
+
+// Build constructs a FileDescriptor given the parameters set in Builder.
+// It assumes that the inputs are well-formed and panics if any inconsistencies
+// are encountered.
+//
+// If NumEnums+NumMessages+NumExtensions+NumServices is zero,
+// then Build automatically derives them from the raw descriptor.
+func (db Builder) Build() (out Out) {
+	// Populate the counts if uninitialized.
+	if db.NumEnums+db.NumMessages+db.NumExtensions+db.NumServices == 0 {
+		db.unmarshalCounts(db.RawDescriptor, true)
+	}
+
+	// Initialize resolvers and registries if unpopulated.
+	if db.TypeResolver == nil {
+		db.TypeResolver = preg.GlobalTypes
+	}
+	if db.FileRegistry == nil {
+		db.FileRegistry = preg.GlobalFiles
+	}
+
+	fd := newRawFile(db)
+	out.File = fd
+	out.Enums = fd.allEnums
+	out.Messages = fd.allMessages
+	out.Extensions = fd.allExtensions
+	out.Services = fd.allServices
+
+	if err := db.FileRegistry.RegisterFile(fd); err != nil {
+		panic(err)
+	}
+	return out
+}
+
+// unmarshalCounts counts the number of enum, message, extension, and service
+// declarations in the raw message, which is either a FileDescriptorProto
+// or a MessageDescriptorProto depending on whether isFile is set.
+func (db *Builder) unmarshalCounts(b []byte, isFile bool) {
+	for len(b) > 0 {
+		num, typ, n := protowire.ConsumeTag(b)
+		b = b[n:]
+		switch typ {
+		case protowire.BytesType:
+			v, m := protowire.ConsumeBytes(b)
+			b = b[m:]
+			if isFile {
+				switch num {
+				case fieldnum.FileDescriptorProto_EnumType:
+					db.NumEnums++
+				case fieldnum.FileDescriptorProto_MessageType:
+					db.unmarshalCounts(v, false)
+					db.NumMessages++
+				case fieldnum.FileDescriptorProto_Extension:
+					db.NumExtensions++
+				case fieldnum.FileDescriptorProto_Service:
+					db.NumServices++
+				}
+			} else {
+				switch num {
+				case fieldnum.DescriptorProto_EnumType:
+					db.NumEnums++
+				case fieldnum.DescriptorProto_NestedType:
+					db.unmarshalCounts(v, false)
+					db.NumMessages++
+				case fieldnum.DescriptorProto_Extension:
+					db.NumExtensions++
+				}
+			}
+		default:
+			m := protowire.ConsumeFieldValue(num, typ, b)
+			b = b[m:]
+		}
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/filedesc/build_test.go b/vendor/google.golang.org/protobuf/internal/filedesc/build_test.go
new file mode 100644
index 000000000..f8007a047
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/filedesc/build_test.go
@@ -0,0 +1,135 @@
+// 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 filedesc_test
+
+import (
+	"bytes"
+	"compress/gzip"
+	"io/ioutil"
+	"testing"
+
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protodesc"
+	"google.golang.org/protobuf/reflect/protoreflect"
+
+	testpb "google.golang.org/protobuf/internal/testprotos/test"
+	_ "google.golang.org/protobuf/internal/testprotos/test/weak1"
+	"google.golang.org/protobuf/types/descriptorpb"
+)
+
+var testFile = new(testpb.TestAllTypes).ProtoReflect().Descriptor().ParentFile()
+
+func TestInit(t *testing.T) {
+	// Compare the FileDescriptorProto for the same test file from two different sources:
+	//
+	// 1. The result of passing the filedesc-produced FileDescriptor through protodesc.
+	// 2. The protoc-generated wire-encoded message.
+	//
+	// This serves as a test of both filedesc and protodesc.
+	got := protodesc.ToFileDescriptorProto(testFile)
+
+	want := &descriptorpb.FileDescriptorProto{}
+	zb, _ := (&testpb.TestAllTypes{}).Descriptor()
+	r, _ := gzip.NewReader(bytes.NewBuffer(zb))
+	b, _ := ioutil.ReadAll(r)
+	if err := proto.Unmarshal(b, want); err != nil {
+		t.Fatal(err)
+	}
+
+	if !proto.Equal(got, want) {
+		t.Errorf("protodesc.ToFileDescriptorProto(testpb.Test_protoFile) is not equal to the protoc-generated FileDescriptorProto for internal/testprotos/test/test.proto")
+	}
+
+	// Verify that the test proto file provides exhaustive coverage of all descriptor fields.
+	seen := make(map[protoreflect.FullName]bool)
+	visitFields(want.ProtoReflect(), func(field protoreflect.FieldDescriptor) {
+		seen[field.FullName()] = true
+	})
+	descFile := new(descriptorpb.DescriptorProto).ProtoReflect().Descriptor().ParentFile()
+	descPkg := descFile.Package()
+	ignore := map[protoreflect.FullName]bool{
+		// The protoreflect descriptors don't include source info.
+		descPkg.Append("FileDescriptorProto.source_code_info"): true,
+		descPkg.Append("FileDescriptorProto.syntax"):           true,
+
+		// Impossible to test proto3 optional in a proto2 file.
+		descPkg.Append("FieldDescriptorProto.proto3_optional"): true,
+
+		// TODO: Test oneof and extension options. Testing these requires extending the
+		// options messages (because they contain no user-settable fields), but importing
+		// decriptor.proto from test.proto currently causes an import cycle. Add test
+		// cases when that import cycle has been fixed.
+		descPkg.Append("OneofDescriptorProto.options"): true,
+	}
+	for _, messageName := range []protoreflect.Name{
+		"FileDescriptorProto",
+		"DescriptorProto",
+		"FieldDescriptorProto",
+		"OneofDescriptorProto",
+		"EnumDescriptorProto",
+		"EnumValueDescriptorProto",
+	} {
+		message := descFile.Messages().ByName(messageName)
+		for i, fields := 0, message.Fields(); i < fields.Len(); i++ {
+			if name := fields.Get(i).FullName(); !seen[name] && !ignore[name] {
+				t.Errorf("No test for descriptor field: %v", name)
+			}
+		}
+	}
+
+	// Verify that message descriptors for map entries have no Go type info.
+	mapEntryName := protoreflect.FullName("goproto.proto.test.TestAllTypes.MapInt32Int32Entry")
+	d := testFile.Messages().ByName("TestAllTypes").Fields().ByName("map_int32_int32").Message()
+	if gotName, wantName := d.FullName(), mapEntryName; gotName != wantName {
+		t.Fatalf("looked up wrong descriptor: got %v, want %v", gotName, wantName)
+	}
+	if _, ok := d.(protoreflect.MessageType); ok {
+		t.Errorf("message descriptor for %v must not implement protoreflect.MessageType", mapEntryName)
+	}
+}
+
+// visitFields calls f for every field set in m and its children.
+func visitFields(m protoreflect.Message, f func(protoreflect.FieldDescriptor)) {
+	m.Range(func(fd protoreflect.FieldDescriptor, value protoreflect.Value) bool {
+		f(fd)
+		switch fd.Kind() {
+		case protoreflect.MessageKind, protoreflect.GroupKind:
+			if fd.IsList() {
+				for i, list := 0, value.List(); i < list.Len(); i++ {
+					visitFields(list.Get(i).Message(), f)
+				}
+			} else {
+				visitFields(value.Message(), f)
+			}
+		}
+		return true
+	})
+}
+
+func TestWeakInit(t *testing.T) {
+	// We do not expect to get a placeholder since weak1 is imported.
+	fd1 := testFile.Messages().ByName("TestWeak").Fields().ByName("weak_message1")
+	if got, want := fd1.IsWeak(), true; got != want {
+		t.Errorf("field %v: IsWeak() = %v, want %v", fd1.FullName(), got, want)
+	}
+	if got, want := fd1.Message().IsPlaceholder(), false; got != want {
+		t.Errorf("field %v: Message.IsPlaceholder() = %v, want %v", fd1.FullName(), got, want)
+	}
+	if got, want := fd1.Message().Fields().Len(), 1; got != want {
+		t.Errorf("field %v: Message().Fields().Len() == %d, want %d", fd1.FullName(), got, want)
+	}
+
+	// We do expect to get a placeholder since weak2 is not imported.
+	fd2 := testFile.Messages().ByName("TestWeak").Fields().ByName("weak_message2")
+	if got, want := fd2.IsWeak(), true; got != want {
+		t.Errorf("field %v: IsWeak() = %v, want %v", fd2.FullName(), got, want)
+	}
+	if got, want := fd2.Message().IsPlaceholder(), true; got != want {
+		t.Errorf("field %v: Message.IsPlaceholder() = %v, want %v", fd2.FullName(), got, want)
+	}
+	if got, want := fd2.Message().Fields().Len(), 0; got != want {
+		t.Errorf("field %v: Message().Fields().Len() == %d, want %d", fd2.FullName(), got, want)
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/filedesc/desc.go b/vendor/google.golang.org/protobuf/internal/filedesc/desc.go
new file mode 100644
index 000000000..2540befd6
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/filedesc/desc.go
@@ -0,0 +1,613 @@
+// Copyright 2019 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 filedesc
+
+import (
+	"bytes"
+	"fmt"
+	"sync"
+	"sync/atomic"
+
+	"google.golang.org/protobuf/internal/descfmt"
+	"google.golang.org/protobuf/internal/descopts"
+	"google.golang.org/protobuf/internal/encoding/defval"
+	"google.golang.org/protobuf/internal/pragma"
+	"google.golang.org/protobuf/internal/strs"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/reflect/protoregistry"
+)
+
+// The types in this file may have a suffix:
+//	• L0: Contains fields common to all descriptors (except File) and
+//	must be initialized up front.
+//	• L1: Contains fields specific to a descriptor and
+//	must be initialized up front.
+//	• L2: Contains fields that are lazily initialized when constructing
+//	from the raw file descriptor. When constructing as a literal, the L2
+//	fields must be initialized up front.
+//
+// The types are exported so that packages like reflect/protodesc can
+// directly construct descriptors.
+
+type (
+	File struct {
+		fileRaw
+		L1 FileL1
+
+		once uint32     // atomically set if L2 is valid
+		mu   sync.Mutex // protects L2
+		L2   *FileL2
+	}
+	FileL1 struct {
+		Syntax  pref.Syntax
+		Path    string
+		Package pref.FullName
+
+		Enums      Enums
+		Messages   Messages
+		Extensions Extensions
+		Services   Services
+	}
+	FileL2 struct {
+		Options   func() pref.ProtoMessage
+		Imports   FileImports
+		Locations SourceLocations
+	}
+)
+
+func (fd *File) ParentFile() pref.FileDescriptor { return fd }
+func (fd *File) Parent() pref.Descriptor         { return nil }
+func (fd *File) Index() int                      { return 0 }
+func (fd *File) Syntax() pref.Syntax             { return fd.L1.Syntax }
+func (fd *File) Name() pref.Name                 { return fd.L1.Package.Name() }
+func (fd *File) FullName() pref.FullName         { return fd.L1.Package }
+func (fd *File) IsPlaceholder() bool             { return false }
+func (fd *File) Options() pref.ProtoMessage {
+	if f := fd.lazyInit().Options; f != nil {
+		return f()
+	}
+	return descopts.File
+}
+func (fd *File) Path() string                          { return fd.L1.Path }
+func (fd *File) Package() pref.FullName                { return fd.L1.Package }
+func (fd *File) Imports() pref.FileImports             { return &fd.lazyInit().Imports }
+func (fd *File) Enums() pref.EnumDescriptors           { return &fd.L1.Enums }
+func (fd *File) Messages() pref.MessageDescriptors     { return &fd.L1.Messages }
+func (fd *File) Extensions() pref.ExtensionDescriptors { return &fd.L1.Extensions }
+func (fd *File) Services() pref.ServiceDescriptors     { return &fd.L1.Services }
+func (fd *File) SourceLocations() pref.SourceLocations { return &fd.lazyInit().Locations }
+func (fd *File) Format(s fmt.State, r rune)            { descfmt.FormatDesc(s, r, fd) }
+func (fd *File) ProtoType(pref.FileDescriptor)         {}
+func (fd *File) ProtoInternal(pragma.DoNotImplement)   {}
+
+func (fd *File) lazyInit() *FileL2 {
+	if atomic.LoadUint32(&fd.once) == 0 {
+		fd.lazyInitOnce()
+	}
+	return fd.L2
+}
+
+func (fd *File) lazyInitOnce() {
+	fd.mu.Lock()
+	if fd.L2 == nil {
+		fd.lazyRawInit() // recursively initializes all L2 structures
+	}
+	atomic.StoreUint32(&fd.once, 1)
+	fd.mu.Unlock()
+}
+
+// ProtoLegacyRawDesc is a pseudo-internal API for allowing the v1 code
+// to be able to retrieve the raw descriptor.
+//
+// WARNING: This method is exempt from the compatibility promise and may be
+// removed in the future without warning.
+func (fd *File) ProtoLegacyRawDesc() []byte {
+	return fd.builder.RawDescriptor
+}
+
+// GoPackagePath is a pseudo-internal API for determining the Go package path
+// that this file descriptor is declared in.
+//
+// WARNING: This method is exempt from the compatibility promise and may be
+// removed in the future without warning.
+func (fd *File) GoPackagePath() string {
+	return fd.builder.GoPackagePath
+}
+
+type (
+	Enum struct {
+		Base
+		L1 EnumL1
+		L2 *EnumL2 // protected by fileDesc.once
+	}
+	EnumL1 struct {
+		eagerValues bool // controls whether EnumL2.Values is already populated
+	}
+	EnumL2 struct {
+		Options        func() pref.ProtoMessage
+		Values         EnumValues
+		ReservedNames  Names
+		ReservedRanges EnumRanges
+	}
+
+	EnumValue struct {
+		Base
+		L1 EnumValueL1
+	}
+	EnumValueL1 struct {
+		Options func() pref.ProtoMessage
+		Number  pref.EnumNumber
+	}
+)
+
+func (ed *Enum) Options() pref.ProtoMessage {
+	if f := ed.lazyInit().Options; f != nil {
+		return f()
+	}
+	return descopts.Enum
+}
+func (ed *Enum) Values() pref.EnumValueDescriptors {
+	if ed.L1.eagerValues {
+		return &ed.L2.Values
+	}
+	return &ed.lazyInit().Values
+}
+func (ed *Enum) ReservedNames() pref.Names       { return &ed.lazyInit().ReservedNames }
+func (ed *Enum) ReservedRanges() pref.EnumRanges { return &ed.lazyInit().ReservedRanges }
+func (ed *Enum) Format(s fmt.State, r rune)      { descfmt.FormatDesc(s, r, ed) }
+func (ed *Enum) ProtoType(pref.EnumDescriptor)   {}
+func (ed *Enum) lazyInit() *EnumL2 {
+	ed.L0.ParentFile.lazyInit() // implicitly initializes L2
+	return ed.L2
+}
+
+func (ed *EnumValue) Options() pref.ProtoMessage {
+	if f := ed.L1.Options; f != nil {
+		return f()
+	}
+	return descopts.EnumValue
+}
+func (ed *EnumValue) Number() pref.EnumNumber            { return ed.L1.Number }
+func (ed *EnumValue) Format(s fmt.State, r rune)         { descfmt.FormatDesc(s, r, ed) }
+func (ed *EnumValue) ProtoType(pref.EnumValueDescriptor) {}
+
+type (
+	Message struct {
+		Base
+		L1 MessageL1
+		L2 *MessageL2 // protected by fileDesc.once
+	}
+	MessageL1 struct {
+		Enums        Enums
+		Messages     Messages
+		Extensions   Extensions
+		IsMapEntry   bool // promoted from google.protobuf.MessageOptions
+		IsMessageSet bool // promoted from google.protobuf.MessageOptions
+	}
+	MessageL2 struct {
+		Options               func() pref.ProtoMessage
+		Fields                Fields
+		Oneofs                Oneofs
+		ReservedNames         Names
+		ReservedRanges        FieldRanges
+		RequiredNumbers       FieldNumbers // must be consistent with Fields.Cardinality
+		ExtensionRanges       FieldRanges
+		ExtensionRangeOptions []func() pref.ProtoMessage // must be same length as ExtensionRanges
+	}
+
+	Field struct {
+		Base
+		L1 FieldL1
+	}
+	FieldL1 struct {
+		Options          func() pref.ProtoMessage
+		Number           pref.FieldNumber
+		Cardinality      pref.Cardinality // must be consistent with Message.RequiredNumbers
+		Kind             pref.Kind
+		JSONName         jsonName
+		IsProto3Optional bool // promoted from google.protobuf.FieldDescriptorProto
+		IsWeak           bool // promoted from google.protobuf.FieldOptions
+		HasPacked        bool // promoted from google.protobuf.FieldOptions
+		IsPacked         bool // promoted from google.protobuf.FieldOptions
+		HasEnforceUTF8   bool // promoted from google.protobuf.FieldOptions
+		EnforceUTF8      bool // promoted from google.protobuf.FieldOptions
+		Default          defaultValue
+		ContainingOneof  pref.OneofDescriptor // must be consistent with Message.Oneofs.Fields
+		Enum             pref.EnumDescriptor
+		Message          pref.MessageDescriptor
+	}
+
+	Oneof struct {
+		Base
+		L1 OneofL1
+	}
+	OneofL1 struct {
+		Options func() pref.ProtoMessage
+		Fields  OneofFields // must be consistent with Message.Fields.ContainingOneof
+	}
+)
+
+func (md *Message) Options() pref.ProtoMessage {
+	if f := md.lazyInit().Options; f != nil {
+		return f()
+	}
+	return descopts.Message
+}
+func (md *Message) IsMapEntry() bool                   { return md.L1.IsMapEntry }
+func (md *Message) Fields() pref.FieldDescriptors      { return &md.lazyInit().Fields }
+func (md *Message) Oneofs() pref.OneofDescriptors      { return &md.lazyInit().Oneofs }
+func (md *Message) ReservedNames() pref.Names          { return &md.lazyInit().ReservedNames }
+func (md *Message) ReservedRanges() pref.FieldRanges   { return &md.lazyInit().ReservedRanges }
+func (md *Message) RequiredNumbers() pref.FieldNumbers { return &md.lazyInit().RequiredNumbers }
+func (md *Message) ExtensionRanges() pref.FieldRanges  { return &md.lazyInit().ExtensionRanges }
+func (md *Message) ExtensionRangeOptions(i int) pref.ProtoMessage {
+	if f := md.lazyInit().ExtensionRangeOptions[i]; f != nil {
+		return f()
+	}
+	return descopts.ExtensionRange
+}
+func (md *Message) Enums() pref.EnumDescriptors           { return &md.L1.Enums }
+func (md *Message) Messages() pref.MessageDescriptors     { return &md.L1.Messages }
+func (md *Message) Extensions() pref.ExtensionDescriptors { return &md.L1.Extensions }
+func (md *Message) ProtoType(pref.MessageDescriptor)      {}
+func (md *Message) Format(s fmt.State, r rune)            { descfmt.FormatDesc(s, r, md) }
+func (md *Message) lazyInit() *MessageL2 {
+	md.L0.ParentFile.lazyInit() // implicitly initializes L2
+	return md.L2
+}
+
+// IsMessageSet is a pseudo-internal API for checking whether a message
+// should serialize in the proto1 message format.
+//
+// WARNING: This method is exempt from the compatibility promise and may be
+// removed in the future without warning.
+func (md *Message) IsMessageSet() bool {
+	return md.L1.IsMessageSet
+}
+
+func (fd *Field) Options() pref.ProtoMessage {
+	if f := fd.L1.Options; f != nil {
+		return f()
+	}
+	return descopts.Field
+}
+func (fd *Field) Number() pref.FieldNumber      { return fd.L1.Number }
+func (fd *Field) Cardinality() pref.Cardinality { return fd.L1.Cardinality }
+func (fd *Field) Kind() pref.Kind               { return fd.L1.Kind }
+func (fd *Field) HasJSONName() bool             { return fd.L1.JSONName.has }
+func (fd *Field) JSONName() string              { return fd.L1.JSONName.get(fd) }
+func (fd *Field) HasPresence() bool {
+	return fd.L1.Cardinality != pref.Repeated && (fd.L0.ParentFile.L1.Syntax == pref.Proto2 || fd.L1.Message != nil || fd.L1.ContainingOneof != nil)
+}
+func (fd *Field) HasOptionalKeyword() bool {
+	return (fd.L0.ParentFile.L1.Syntax == pref.Proto2 && fd.L1.Cardinality == pref.Optional && fd.L1.ContainingOneof == nil) || fd.L1.IsProto3Optional
+}
+func (fd *Field) IsPacked() bool {
+	if !fd.L1.HasPacked && fd.L0.ParentFile.L1.Syntax != pref.Proto2 && fd.L1.Cardinality == pref.Repeated {
+		switch fd.L1.Kind {
+		case pref.StringKind, pref.BytesKind, pref.MessageKind, pref.GroupKind:
+		default:
+			return true
+		}
+	}
+	return fd.L1.IsPacked
+}
+func (fd *Field) IsExtension() bool { return false }
+func (fd *Field) IsWeak() bool      { return fd.L1.IsWeak }
+func (fd *Field) IsList() bool      { return fd.Cardinality() == pref.Repeated && !fd.IsMap() }
+func (fd *Field) IsMap() bool       { return fd.Message() != nil && fd.Message().IsMapEntry() }
+func (fd *Field) MapKey() pref.FieldDescriptor {
+	if !fd.IsMap() {
+		return nil
+	}
+	return fd.Message().Fields().ByNumber(1)
+}
+func (fd *Field) MapValue() pref.FieldDescriptor {
+	if !fd.IsMap() {
+		return nil
+	}
+	return fd.Message().Fields().ByNumber(2)
+}
+func (fd *Field) HasDefault() bool                           { return fd.L1.Default.has }
+func (fd *Field) Default() pref.Value                        { return fd.L1.Default.get(fd) }
+func (fd *Field) DefaultEnumValue() pref.EnumValueDescriptor { return fd.L1.Default.enum }
+func (fd *Field) ContainingOneof() pref.OneofDescriptor      { return fd.L1.ContainingOneof }
+func (fd *Field) ContainingMessage() pref.MessageDescriptor {
+	return fd.L0.Parent.(pref.MessageDescriptor)
+}
+func (fd *Field) Enum() pref.EnumDescriptor {
+	return fd.L1.Enum
+}
+func (fd *Field) Message() pref.MessageDescriptor {
+	if fd.L1.IsWeak {
+		if d, _ := protoregistry.GlobalFiles.FindDescriptorByName(fd.L1.Message.FullName()); d != nil {
+			return d.(pref.MessageDescriptor)
+		}
+	}
+	return fd.L1.Message
+}
+func (fd *Field) Format(s fmt.State, r rune)     { descfmt.FormatDesc(s, r, fd) }
+func (fd *Field) ProtoType(pref.FieldDescriptor) {}
+
+// EnforceUTF8 is a pseudo-internal API to determine whether to enforce UTF-8
+// validation for the string field. This exists for Google-internal use only
+// since proto3 did not enforce UTF-8 validity prior to the open-source release.
+// If this method does not exist, the default is to enforce valid UTF-8.
+//
+// WARNING: This method is exempt from the compatibility promise and may be
+// removed in the future without warning.
+func (fd *Field) EnforceUTF8() bool {
+	if fd.L1.HasEnforceUTF8 {
+		return fd.L1.EnforceUTF8
+	}
+	return fd.L0.ParentFile.L1.Syntax == pref.Proto3
+}
+
+func (od *Oneof) IsSynthetic() bool {
+	return od.L0.ParentFile.L1.Syntax == pref.Proto3 && len(od.L1.Fields.List) == 1 && od.L1.Fields.List[0].HasOptionalKeyword()
+}
+func (od *Oneof) Options() pref.ProtoMessage {
+	if f := od.L1.Options; f != nil {
+		return f()
+	}
+	return descopts.Oneof
+}
+func (od *Oneof) Fields() pref.FieldDescriptors  { return &od.L1.Fields }
+func (od *Oneof) Format(s fmt.State, r rune)     { descfmt.FormatDesc(s, r, od) }
+func (od *Oneof) ProtoType(pref.OneofDescriptor) {}
+
+type (
+	Extension struct {
+		Base
+		L1 ExtensionL1
+		L2 *ExtensionL2 // protected by fileDesc.once
+	}
+	ExtensionL1 struct {
+		Number      pref.FieldNumber
+		Extendee    pref.MessageDescriptor
+		Cardinality pref.Cardinality
+		Kind        pref.Kind
+	}
+	ExtensionL2 struct {
+		Options          func() pref.ProtoMessage
+		JSONName         jsonName
+		IsProto3Optional bool // promoted from google.protobuf.FieldDescriptorProto
+		IsPacked         bool // promoted from google.protobuf.FieldOptions
+		Default          defaultValue
+		Enum             pref.EnumDescriptor
+		Message          pref.MessageDescriptor
+	}
+)
+
+func (xd *Extension) Options() pref.ProtoMessage {
+	if f := xd.lazyInit().Options; f != nil {
+		return f()
+	}
+	return descopts.Field
+}
+func (xd *Extension) Number() pref.FieldNumber      { return xd.L1.Number }
+func (xd *Extension) Cardinality() pref.Cardinality { return xd.L1.Cardinality }
+func (xd *Extension) Kind() pref.Kind               { return xd.L1.Kind }
+func (xd *Extension) HasJSONName() bool             { return xd.lazyInit().JSONName.has }
+func (xd *Extension) JSONName() string              { return xd.lazyInit().JSONName.get(xd) }
+func (xd *Extension) HasPresence() bool             { return xd.L1.Cardinality != pref.Repeated }
+func (xd *Extension) HasOptionalKeyword() bool {
+	return (xd.L0.ParentFile.L1.Syntax == pref.Proto2 && xd.L1.Cardinality == pref.Optional) || xd.lazyInit().IsProto3Optional
+}
+func (xd *Extension) IsPacked() bool                             { return xd.lazyInit().IsPacked }
+func (xd *Extension) IsExtension() bool                          { return true }
+func (xd *Extension) IsWeak() bool                               { return false }
+func (xd *Extension) IsList() bool                               { return xd.Cardinality() == pref.Repeated }
+func (xd *Extension) IsMap() bool                                { return false }
+func (xd *Extension) MapKey() pref.FieldDescriptor               { return nil }
+func (xd *Extension) MapValue() pref.FieldDescriptor             { return nil }
+func (xd *Extension) HasDefault() bool                           { return xd.lazyInit().Default.has }
+func (xd *Extension) Default() pref.Value                        { return xd.lazyInit().Default.get(xd) }
+func (xd *Extension) DefaultEnumValue() pref.EnumValueDescriptor { return xd.lazyInit().Default.enum }
+func (xd *Extension) ContainingOneof() pref.OneofDescriptor      { return nil }
+func (xd *Extension) ContainingMessage() pref.MessageDescriptor  { return xd.L1.Extendee }
+func (xd *Extension) Enum() pref.EnumDescriptor                  { return xd.lazyInit().Enum }
+func (xd *Extension) Message() pref.MessageDescriptor            { return xd.lazyInit().Message }
+func (xd *Extension) Format(s fmt.State, r rune)                 { descfmt.FormatDesc(s, r, xd) }
+func (xd *Extension) ProtoType(pref.FieldDescriptor)             {}
+func (xd *Extension) ProtoInternal(pragma.DoNotImplement)        {}
+func (xd *Extension) lazyInit() *ExtensionL2 {
+	xd.L0.ParentFile.lazyInit() // implicitly initializes L2
+	return xd.L2
+}
+
+type (
+	Service struct {
+		Base
+		L1 ServiceL1
+		L2 *ServiceL2 // protected by fileDesc.once
+	}
+	ServiceL1 struct{}
+	ServiceL2 struct {
+		Options func() pref.ProtoMessage
+		Methods Methods
+	}
+
+	Method struct {
+		Base
+		L1 MethodL1
+	}
+	MethodL1 struct {
+		Options           func() pref.ProtoMessage
+		Input             pref.MessageDescriptor
+		Output            pref.MessageDescriptor
+		IsStreamingClient bool
+		IsStreamingServer bool
+	}
+)
+
+func (sd *Service) Options() pref.ProtoMessage {
+	if f := sd.lazyInit().Options; f != nil {
+		return f()
+	}
+	return descopts.Service
+}
+func (sd *Service) Methods() pref.MethodDescriptors     { return &sd.lazyInit().Methods }
+func (sd *Service) Format(s fmt.State, r rune)          { descfmt.FormatDesc(s, r, sd) }
+func (sd *Service) ProtoType(pref.ServiceDescriptor)    {}
+func (sd *Service) ProtoInternal(pragma.DoNotImplement) {}
+func (sd *Service) lazyInit() *ServiceL2 {
+	sd.L0.ParentFile.lazyInit() // implicitly initializes L2
+	return sd.L2
+}
+
+func (md *Method) Options() pref.ProtoMessage {
+	if f := md.L1.Options; f != nil {
+		return f()
+	}
+	return descopts.Method
+}
+func (md *Method) Input() pref.MessageDescriptor       { return md.L1.Input }
+func (md *Method) Output() pref.MessageDescriptor      { return md.L1.Output }
+func (md *Method) IsStreamingClient() bool             { return md.L1.IsStreamingClient }
+func (md *Method) IsStreamingServer() bool             { return md.L1.IsStreamingServer }
+func (md *Method) Format(s fmt.State, r rune)          { descfmt.FormatDesc(s, r, md) }
+func (md *Method) ProtoType(pref.MethodDescriptor)     {}
+func (md *Method) ProtoInternal(pragma.DoNotImplement) {}
+
+// Surrogate files are can be used to create standalone descriptors
+// where the syntax is only information derived from the parent file.
+var (
+	SurrogateProto2 = &File{L1: FileL1{Syntax: pref.Proto2}, L2: &FileL2{}}
+	SurrogateProto3 = &File{L1: FileL1{Syntax: pref.Proto3}, L2: &FileL2{}}
+)
+
+type (
+	Base struct {
+		L0 BaseL0
+	}
+	BaseL0 struct {
+		FullName   pref.FullName // must be populated
+		ParentFile *File         // must be populated
+		Parent     pref.Descriptor
+		Index      int
+	}
+)
+
+func (d *Base) Name() pref.Name         { return d.L0.FullName.Name() }
+func (d *Base) FullName() pref.FullName { return d.L0.FullName }
+func (d *Base) ParentFile() pref.FileDescriptor {
+	if d.L0.ParentFile == SurrogateProto2 || d.L0.ParentFile == SurrogateProto3 {
+		return nil // surrogate files are not real parents
+	}
+	return d.L0.ParentFile
+}
+func (d *Base) Parent() pref.Descriptor             { return d.L0.Parent }
+func (d *Base) Index() int                          { return d.L0.Index }
+func (d *Base) Syntax() pref.Syntax                 { return d.L0.ParentFile.Syntax() }
+func (d *Base) IsPlaceholder() bool                 { return false }
+func (d *Base) ProtoInternal(pragma.DoNotImplement) {}
+
+type jsonName struct {
+	has  bool
+	once sync.Once
+	name string
+}
+
+// Init initializes the name. It is exported for use by other internal packages.
+func (js *jsonName) Init(s string) {
+	js.has = true
+	js.name = s
+}
+
+func (js *jsonName) get(fd pref.FieldDescriptor) string {
+	if !js.has {
+		js.once.Do(func() {
+			js.name = strs.JSONCamelCase(string(fd.Name()))
+		})
+	}
+	return js.name
+}
+
+func DefaultValue(v pref.Value, ev pref.EnumValueDescriptor) defaultValue {
+	dv := defaultValue{has: v.IsValid(), val: v, enum: ev}
+	if b, ok := v.Interface().([]byte); ok {
+		// Store a copy of the default bytes, so that we can detect
+		// accidental mutations of the original value.
+		dv.bytes = append([]byte(nil), b...)
+	}
+	return dv
+}
+
+func unmarshalDefault(b []byte, k pref.Kind, pf *File, ed pref.EnumDescriptor) defaultValue {
+	var evs pref.EnumValueDescriptors
+	if k == pref.EnumKind {
+		// If the enum is declared within the same file, be careful not to
+		// blindly call the Values method, lest we bind ourselves in a deadlock.
+		if e, ok := ed.(*Enum); ok && e.L0.ParentFile == pf {
+			evs = &e.L2.Values
+		} else {
+			evs = ed.Values()
+		}
+
+		// If we are unable to resolve the enum dependency, use a placeholder
+		// enum value since we will not be able to parse the default value.
+		if ed.IsPlaceholder() && pref.Name(b).IsValid() {
+			v := pref.ValueOfEnum(0)
+			ev := PlaceholderEnumValue(ed.FullName().Parent().Append(pref.Name(b)))
+			return DefaultValue(v, ev)
+		}
+	}
+
+	v, ev, err := defval.Unmarshal(string(b), k, evs, defval.Descriptor)
+	if err != nil {
+		panic(err)
+	}
+	return DefaultValue(v, ev)
+}
+
+type defaultValue struct {
+	has   bool
+	val   pref.Value
+	enum  pref.EnumValueDescriptor
+	bytes []byte
+}
+
+func (dv *defaultValue) get(fd pref.FieldDescriptor) pref.Value {
+	// Return the zero value as the default if unpopulated.
+	if !dv.has {
+		if fd.Cardinality() == pref.Repeated {
+			return pref.Value{}
+		}
+		switch fd.Kind() {
+		case pref.BoolKind:
+			return pref.ValueOfBool(false)
+		case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
+			return pref.ValueOfInt32(0)
+		case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
+			return pref.ValueOfInt64(0)
+		case pref.Uint32Kind, pref.Fixed32Kind:
+			return pref.ValueOfUint32(0)
+		case pref.Uint64Kind, pref.Fixed64Kind:
+			return pref.ValueOfUint64(0)
+		case pref.FloatKind:
+			return pref.ValueOfFloat32(0)
+		case pref.DoubleKind:
+			return pref.ValueOfFloat64(0)
+		case pref.StringKind:
+			return pref.ValueOfString("")
+		case pref.BytesKind:
+			return pref.ValueOfBytes(nil)
+		case pref.EnumKind:
+			if evs := fd.Enum().Values(); evs.Len() > 0 {
+				return pref.ValueOfEnum(evs.Get(0).Number())
+			}
+			return pref.ValueOfEnum(0)
+		}
+	}
+
+	if len(dv.bytes) > 0 && !bytes.Equal(dv.bytes, dv.val.Bytes()) {
+		// TODO: Avoid panic if we're running with the race detector
+		// and instead spawn a goroutine that periodically resets
+		// this value back to the original to induce a race.
+		panic(fmt.Sprintf("detected mutation on the default bytes for %v", fd.FullName()))
+	}
+	return dv.val
+}
diff --git a/vendor/google.golang.org/protobuf/internal/filedesc/desc_init.go b/vendor/google.golang.org/protobuf/internal/filedesc/desc_init.go
new file mode 100644
index 000000000..c0cddf86a
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/filedesc/desc_init.go
@@ -0,0 +1,471 @@
+// Copyright 2019 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 filedesc
+
+import (
+	"sync"
+
+	"google.golang.org/protobuf/encoding/protowire"
+	"google.golang.org/protobuf/internal/fieldnum"
+	"google.golang.org/protobuf/internal/strs"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+)
+
+// fileRaw is a data struct used when initializing a file descriptor from
+// a raw FileDescriptorProto.
+type fileRaw struct {
+	builder       Builder
+	allEnums      []Enum
+	allMessages   []Message
+	allExtensions []Extension
+	allServices   []Service
+}
+
+func newRawFile(db Builder) *File {
+	fd := &File{fileRaw: fileRaw{builder: db}}
+	fd.initDecls(db.NumEnums, db.NumMessages, db.NumExtensions, db.NumServices)
+	fd.unmarshalSeed(db.RawDescriptor)
+
+	// Extended message targets are eagerly resolved since registration
+	// needs this information at program init time.
+	for i := range fd.allExtensions {
+		xd := &fd.allExtensions[i]
+		xd.L1.Extendee = fd.resolveMessageDependency(xd.L1.Extendee, listExtTargets, int32(i))
+	}
+
+	fd.checkDecls()
+	return fd
+}
+
+// initDecls pre-allocates slices for the exact number of enums, messages
+// (including map entries), extensions, and services declared in the proto file.
+// This is done to avoid regrowing the slice, which would change the address
+// for any previously seen declaration.
+//
+// The alloc methods "allocates" slices by pulling from the capacity.
+func (fd *File) initDecls(numEnums, numMessages, numExtensions, numServices int32) {
+	fd.allEnums = make([]Enum, 0, numEnums)
+	fd.allMessages = make([]Message, 0, numMessages)
+	fd.allExtensions = make([]Extension, 0, numExtensions)
+	fd.allServices = make([]Service, 0, numServices)
+}
+
+func (fd *File) allocEnums(n int) []Enum {
+	total := len(fd.allEnums)
+	es := fd.allEnums[total : total+n]
+	fd.allEnums = fd.allEnums[:total+n]
+	return es
+}
+func (fd *File) allocMessages(n int) []Message {
+	total := len(fd.allMessages)
+	ms := fd.allMessages[total : total+n]
+	fd.allMessages = fd.allMessages[:total+n]
+	return ms
+}
+func (fd *File) allocExtensions(n int) []Extension {
+	total := len(fd.allExtensions)
+	xs := fd.allExtensions[total : total+n]
+	fd.allExtensions = fd.allExtensions[:total+n]
+	return xs
+}
+func (fd *File) allocServices(n int) []Service {
+	total := len(fd.allServices)
+	xs := fd.allServices[total : total+n]
+	fd.allServices = fd.allServices[:total+n]
+	return xs
+}
+
+// checkDecls performs a sanity check that the expected number of expected
+// declarations matches the number that were found in the descriptor proto.
+func (fd *File) checkDecls() {
+	switch {
+	case len(fd.allEnums) != cap(fd.allEnums):
+	case len(fd.allMessages) != cap(fd.allMessages):
+	case len(fd.allExtensions) != cap(fd.allExtensions):
+	case len(fd.allServices) != cap(fd.allServices):
+	default:
+		return
+	}
+	panic("mismatching cardinality")
+}
+
+func (fd *File) unmarshalSeed(b []byte) {
+	sb := getBuilder()
+	defer putBuilder(sb)
+
+	var prevField pref.FieldNumber
+	var numEnums, numMessages, numExtensions, numServices int
+	var posEnums, posMessages, posExtensions, posServices int
+	b0 := b
+	for len(b) > 0 {
+		num, typ, n := protowire.ConsumeTag(b)
+		b = b[n:]
+		switch typ {
+		case protowire.BytesType:
+			v, m := protowire.ConsumeBytes(b)
+			b = b[m:]
+			switch num {
+			case fieldnum.FileDescriptorProto_Syntax:
+				switch string(v) {
+				case "proto2":
+					fd.L1.Syntax = pref.Proto2
+				case "proto3":
+					fd.L1.Syntax = pref.Proto3
+				default:
+					panic("invalid syntax")
+				}
+			case fieldnum.FileDescriptorProto_Name:
+				fd.L1.Path = sb.MakeString(v)
+			case fieldnum.FileDescriptorProto_Package:
+				fd.L1.Package = pref.FullName(sb.MakeString(v))
+			case fieldnum.FileDescriptorProto_EnumType:
+				if prevField != fieldnum.FileDescriptorProto_EnumType {
+					if numEnums > 0 {
+						panic("non-contiguous repeated field")
+					}
+					posEnums = len(b0) - len(b) - n - m
+				}
+				numEnums++
+			case fieldnum.FileDescriptorProto_MessageType:
+				if prevField != fieldnum.FileDescriptorProto_MessageType {
+					if numMessages > 0 {
+						panic("non-contiguous repeated field")
+					}
+					posMessages = len(b0) - len(b) - n - m
+				}
+				numMessages++
+			case fieldnum.FileDescriptorProto_Extension:
+				if prevField != fieldnum.FileDescriptorProto_Extension {
+					if numExtensions > 0 {
+						panic("non-contiguous repeated field")
+					}
+					posExtensions = len(b0) - len(b) - n - m
+				}
+				numExtensions++
+			case fieldnum.FileDescriptorProto_Service:
+				if prevField != fieldnum.FileDescriptorProto_Service {
+					if numServices > 0 {
+						panic("non-contiguous repeated field")
+					}
+					posServices = len(b0) - len(b) - n - m
+				}
+				numServices++
+			}
+			prevField = num
+		default:
+			m := protowire.ConsumeFieldValue(num, typ, b)
+			b = b[m:]
+			prevField = -1 // ignore known field numbers of unknown wire type
+		}
+	}
+
+	// If syntax is missing, it is assumed to be proto2.
+	if fd.L1.Syntax == 0 {
+		fd.L1.Syntax = pref.Proto2
+	}
+
+	// Must allocate all declarations before parsing each descriptor type
+	// to ensure we handled all descriptors in "flattened ordering".
+	if numEnums > 0 {
+		fd.L1.Enums.List = fd.allocEnums(numEnums)
+	}
+	if numMessages > 0 {
+		fd.L1.Messages.List = fd.allocMessages(numMessages)
+	}
+	if numExtensions > 0 {
+		fd.L1.Extensions.List = fd.allocExtensions(numExtensions)
+	}
+	if numServices > 0 {
+		fd.L1.Services.List = fd.allocServices(numServices)
+	}
+
+	if numEnums > 0 {
+		b := b0[posEnums:]
+		for i := range fd.L1.Enums.List {
+			_, n := protowire.ConsumeVarint(b)
+			v, m := protowire.ConsumeBytes(b[n:])
+			fd.L1.Enums.List[i].unmarshalSeed(v, sb, fd, fd, i)
+			b = b[n+m:]
+		}
+	}
+	if numMessages > 0 {
+		b := b0[posMessages:]
+		for i := range fd.L1.Messages.List {
+			_, n := protowire.ConsumeVarint(b)
+			v, m := protowire.ConsumeBytes(b[n:])
+			fd.L1.Messages.List[i].unmarshalSeed(v, sb, fd, fd, i)
+			b = b[n+m:]
+		}
+	}
+	if numExtensions > 0 {
+		b := b0[posExtensions:]
+		for i := range fd.L1.Extensions.List {
+			_, n := protowire.ConsumeVarint(b)
+			v, m := protowire.ConsumeBytes(b[n:])
+			fd.L1.Extensions.List[i].unmarshalSeed(v, sb, fd, fd, i)
+			b = b[n+m:]
+		}
+	}
+	if numServices > 0 {
+		b := b0[posServices:]
+		for i := range fd.L1.Services.List {
+			_, n := protowire.ConsumeVarint(b)
+			v, m := protowire.ConsumeBytes(b[n:])
+			fd.L1.Services.List[i].unmarshalSeed(v, sb, fd, fd, i)
+			b = b[n+m:]
+		}
+	}
+}
+
+func (ed *Enum) unmarshalSeed(b []byte, sb *strs.Builder, pf *File, pd pref.Descriptor, i int) {
+	ed.L0.ParentFile = pf
+	ed.L0.Parent = pd
+	ed.L0.Index = i
+
+	var numValues int
+	for b := b; len(b) > 0; {
+		num, typ, n := protowire.ConsumeTag(b)
+		b = b[n:]
+		switch typ {
+		case protowire.BytesType:
+			v, m := protowire.ConsumeBytes(b)
+			b = b[m:]
+			switch num {
+			case fieldnum.EnumDescriptorProto_Name:
+				ed.L0.FullName = appendFullName(sb, pd.FullName(), v)
+			case fieldnum.EnumDescriptorProto_Value:
+				numValues++
+			}
+		default:
+			m := protowire.ConsumeFieldValue(num, typ, b)
+			b = b[m:]
+		}
+	}
+
+	// Only construct enum value descriptors for top-level enums since
+	// they are needed for registration.
+	if pd != pf {
+		return
+	}
+	ed.L1.eagerValues = true
+	ed.L2 = new(EnumL2)
+	ed.L2.Values.List = make([]EnumValue, numValues)
+	for i := 0; len(b) > 0; {
+		num, typ, n := protowire.ConsumeTag(b)
+		b = b[n:]
+		switch typ {
+		case protowire.BytesType:
+			v, m := protowire.ConsumeBytes(b)
+			b = b[m:]
+			switch num {
+			case fieldnum.EnumDescriptorProto_Value:
+				ed.L2.Values.List[i].unmarshalFull(v, sb, pf, ed, i)
+				i++
+			}
+		default:
+			m := protowire.ConsumeFieldValue(num, typ, b)
+			b = b[m:]
+		}
+	}
+}
+
+func (md *Message) unmarshalSeed(b []byte, sb *strs.Builder, pf *File, pd pref.Descriptor, i int) {
+	md.L0.ParentFile = pf
+	md.L0.Parent = pd
+	md.L0.Index = i
+
+	var prevField pref.FieldNumber
+	var numEnums, numMessages, numExtensions int
+	var posEnums, posMessages, posExtensions int
+	b0 := b
+	for len(b) > 0 {
+		num, typ, n := protowire.ConsumeTag(b)
+		b = b[n:]
+		switch typ {
+		case protowire.BytesType:
+			v, m := protowire.ConsumeBytes(b)
+			b = b[m:]
+			switch num {
+			case fieldnum.DescriptorProto_Name:
+				md.L0.FullName = appendFullName(sb, pd.FullName(), v)
+			case fieldnum.DescriptorProto_EnumType:
+				if prevField != fieldnum.DescriptorProto_EnumType {
+					if numEnums > 0 {
+						panic("non-contiguous repeated field")
+					}
+					posEnums = len(b0) - len(b) - n - m
+				}
+				numEnums++
+			case fieldnum.DescriptorProto_NestedType:
+				if prevField != fieldnum.DescriptorProto_NestedType {
+					if numMessages > 0 {
+						panic("non-contiguous repeated field")
+					}
+					posMessages = len(b0) - len(b) - n - m
+				}
+				numMessages++
+			case fieldnum.DescriptorProto_Extension:
+				if prevField != fieldnum.DescriptorProto_Extension {
+					if numExtensions > 0 {
+						panic("non-contiguous repeated field")
+					}
+					posExtensions = len(b0) - len(b) - n - m
+				}
+				numExtensions++
+			case fieldnum.DescriptorProto_Options:
+				md.unmarshalSeedOptions(v)
+			}
+			prevField = num
+		default:
+			m := protowire.ConsumeFieldValue(num, typ, b)
+			b = b[m:]
+			prevField = -1 // ignore known field numbers of unknown wire type
+		}
+	}
+
+	// Must allocate all declarations before parsing each descriptor type
+	// to ensure we handled all descriptors in "flattened ordering".
+	if numEnums > 0 {
+		md.L1.Enums.List = pf.allocEnums(numEnums)
+	}
+	if numMessages > 0 {
+		md.L1.Messages.List = pf.allocMessages(numMessages)
+	}
+	if numExtensions > 0 {
+		md.L1.Extensions.List = pf.allocExtensions(numExtensions)
+	}
+
+	if numEnums > 0 {
+		b := b0[posEnums:]
+		for i := range md.L1.Enums.List {
+			_, n := protowire.ConsumeVarint(b)
+			v, m := protowire.ConsumeBytes(b[n:])
+			md.L1.Enums.List[i].unmarshalSeed(v, sb, pf, md, i)
+			b = b[n+m:]
+		}
+	}
+	if numMessages > 0 {
+		b := b0[posMessages:]
+		for i := range md.L1.Messages.List {
+			_, n := protowire.ConsumeVarint(b)
+			v, m := protowire.ConsumeBytes(b[n:])
+			md.L1.Messages.List[i].unmarshalSeed(v, sb, pf, md, i)
+			b = b[n+m:]
+		}
+	}
+	if numExtensions > 0 {
+		b := b0[posExtensions:]
+		for i := range md.L1.Extensions.List {
+			_, n := protowire.ConsumeVarint(b)
+			v, m := protowire.ConsumeBytes(b[n:])
+			md.L1.Extensions.List[i].unmarshalSeed(v, sb, pf, md, i)
+			b = b[n+m:]
+		}
+	}
+}
+
+func (md *Message) unmarshalSeedOptions(b []byte) {
+	for len(b) > 0 {
+		num, typ, n := protowire.ConsumeTag(b)
+		b = b[n:]
+		switch typ {
+		case protowire.VarintType:
+			v, m := protowire.ConsumeVarint(b)
+			b = b[m:]
+			switch num {
+			case fieldnum.MessageOptions_MapEntry:
+				md.L1.IsMapEntry = protowire.DecodeBool(v)
+			case fieldnum.MessageOptions_MessageSetWireFormat:
+				md.L1.IsMessageSet = protowire.DecodeBool(v)
+			}
+		default:
+			m := protowire.ConsumeFieldValue(num, typ, b)
+			b = b[m:]
+		}
+	}
+}
+
+func (xd *Extension) unmarshalSeed(b []byte, sb *strs.Builder, pf *File, pd pref.Descriptor, i int) {
+	xd.L0.ParentFile = pf
+	xd.L0.Parent = pd
+	xd.L0.Index = i
+
+	for len(b) > 0 {
+		num, typ, n := protowire.ConsumeTag(b)
+		b = b[n:]
+		switch typ {
+		case protowire.VarintType:
+			v, m := protowire.ConsumeVarint(b)
+			b = b[m:]
+			switch num {
+			case fieldnum.FieldDescriptorProto_Number:
+				xd.L1.Number = pref.FieldNumber(v)
+			case fieldnum.FieldDescriptorProto_Label:
+				xd.L1.Cardinality = pref.Cardinality(v)
+			case fieldnum.FieldDescriptorProto_Type:
+				xd.L1.Kind = pref.Kind(v)
+			}
+		case protowire.BytesType:
+			v, m := protowire.ConsumeBytes(b)
+			b = b[m:]
+			switch num {
+			case fieldnum.FieldDescriptorProto_Name:
+				xd.L0.FullName = appendFullName(sb, pd.FullName(), v)
+			case fieldnum.FieldDescriptorProto_Extendee:
+				xd.L1.Extendee = PlaceholderMessage(makeFullName(sb, v))
+			}
+		default:
+			m := protowire.ConsumeFieldValue(num, typ, b)
+			b = b[m:]
+		}
+	}
+}
+
+func (sd *Service) unmarshalSeed(b []byte, sb *strs.Builder, pf *File, pd pref.Descriptor, i int) {
+	sd.L0.ParentFile = pf
+	sd.L0.Parent = pd
+	sd.L0.Index = i
+
+	for len(b) > 0 {
+		num, typ, n := protowire.ConsumeTag(b)
+		b = b[n:]
+		switch typ {
+		case protowire.BytesType:
+			v, m := protowire.ConsumeBytes(b)
+			b = b[m:]
+			switch num {
+			case fieldnum.ServiceDescriptorProto_Name:
+				sd.L0.FullName = appendFullName(sb, pd.FullName(), v)
+			}
+		default:
+			m := protowire.ConsumeFieldValue(num, typ, b)
+			b = b[m:]
+		}
+	}
+}
+
+var nameBuilderPool = sync.Pool{
+	New: func() interface{} { return new(strs.Builder) },
+}
+
+func getBuilder() *strs.Builder {
+	return nameBuilderPool.Get().(*strs.Builder)
+}
+func putBuilder(b *strs.Builder) {
+	nameBuilderPool.Put(b)
+}
+
+// makeFullName converts b to a protoreflect.FullName,
+// where b must start with a leading dot.
+func makeFullName(sb *strs.Builder, b []byte) pref.FullName {
+	if len(b) == 0 || b[0] != '.' {
+		panic("name reference must be fully qualified")
+	}
+	return pref.FullName(sb.MakeString(b[1:]))
+}
+
+func appendFullName(sb *strs.Builder, prefix pref.FullName, suffix []byte) pref.FullName {
+	return sb.AppendFullName(prefix, pref.Name(strs.UnsafeString(suffix)))
+}
diff --git a/vendor/google.golang.org/protobuf/internal/filedesc/desc_lazy.go b/vendor/google.golang.org/protobuf/internal/filedesc/desc_lazy.go
new file mode 100644
index 000000000..bc215944a
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/filedesc/desc_lazy.go
@@ -0,0 +1,704 @@
+// Copyright 2019 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 filedesc
+
+import (
+	"reflect"
+	"sync"
+
+	"google.golang.org/protobuf/encoding/protowire"
+	"google.golang.org/protobuf/internal/descopts"
+	"google.golang.org/protobuf/internal/fieldnum"
+	"google.golang.org/protobuf/internal/strs"
+	"google.golang.org/protobuf/proto"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+)
+
+func (fd *File) lazyRawInit() {
+	fd.unmarshalFull(fd.builder.RawDescriptor)
+	fd.resolveMessages()
+	fd.resolveExtensions()
+	fd.resolveServices()
+}
+
+func (file *File) resolveMessages() {
+	var depIdx int32
+	for i := range file.allMessages {
+		md := &file.allMessages[i]
+
+		// Resolve message field dependencies.
+		for j := range md.L2.Fields.List {
+			fd := &md.L2.Fields.List[j]
+
+			// Weak fields are resolved upon actual use.
+			if fd.L1.IsWeak {
+				continue
+			}
+
+			// Resolve message field dependency.
+			switch fd.L1.Kind {
+			case pref.EnumKind:
+				fd.L1.Enum = file.resolveEnumDependency(fd.L1.Enum, listFieldDeps, depIdx)
+				depIdx++
+			case pref.MessageKind, pref.GroupKind:
+				fd.L1.Message = file.resolveMessageDependency(fd.L1.Message, listFieldDeps, depIdx)
+				depIdx++
+			}
+
+			// Default is resolved here since it depends on Enum being resolved.
+			if v := fd.L1.Default.val; v.IsValid() {
+				fd.L1.Default = unmarshalDefault(v.Bytes(), fd.L1.Kind, file, fd.L1.Enum)
+			}
+		}
+	}
+}
+
+func (file *File) resolveExtensions() {
+	var depIdx int32
+	for i := range file.allExtensions {
+		xd := &file.allExtensions[i]
+
+		// Resolve extension field dependency.
+		switch xd.L1.Kind {
+		case pref.EnumKind:
+			xd.L2.Enum = file.resolveEnumDependency(xd.L2.Enum, listExtDeps, depIdx)
+			depIdx++
+		case pref.MessageKind, pref.GroupKind:
+			xd.L2.Message = file.resolveMessageDependency(xd.L2.Message, listExtDeps, depIdx)
+			depIdx++
+		}
+
+		// Default is resolved here since it depends on Enum being resolved.
+		if v := xd.L2.Default.val; v.IsValid() {
+			xd.L2.Default = unmarshalDefault(v.Bytes(), xd.L1.Kind, file, xd.L2.Enum)
+		}
+	}
+}
+
+func (file *File) resolveServices() {
+	var depIdx int32
+	for i := range file.allServices {
+		sd := &file.allServices[i]
+
+		// Resolve method dependencies.
+		for j := range sd.L2.Methods.List {
+			md := &sd.L2.Methods.List[j]
+			md.L1.Input = file.resolveMessageDependency(md.L1.Input, listMethInDeps, depIdx)
+			md.L1.Output = file.resolveMessageDependency(md.L1.Output, listMethOutDeps, depIdx)
+			depIdx++
+		}
+	}
+}
+
+func (file *File) resolveEnumDependency(ed pref.EnumDescriptor, i, j int32) pref.EnumDescriptor {
+	r := file.builder.FileRegistry
+	if r, ok := r.(resolverByIndex); ok {
+		if ed2 := r.FindEnumByIndex(i, j, file.allEnums, file.allMessages); ed2 != nil {
+			return ed2
+		}
+	}
+	for i := range file.allEnums {
+		if ed2 := &file.allEnums[i]; ed2.L0.FullName == ed.FullName() {
+			return ed2
+		}
+	}
+	if d, _ := r.FindDescriptorByName(ed.FullName()); d != nil {
+		return d.(pref.EnumDescriptor)
+	}
+	return ed
+}
+
+func (file *File) resolveMessageDependency(md pref.MessageDescriptor, i, j int32) pref.MessageDescriptor {
+	r := file.builder.FileRegistry
+	if r, ok := r.(resolverByIndex); ok {
+		if md2 := r.FindMessageByIndex(i, j, file.allEnums, file.allMessages); md2 != nil {
+			return md2
+		}
+	}
+	for i := range file.allMessages {
+		if md2 := &file.allMessages[i]; md2.L0.FullName == md.FullName() {
+			return md2
+		}
+	}
+	if d, _ := r.FindDescriptorByName(md.FullName()); d != nil {
+		return d.(pref.MessageDescriptor)
+	}
+	return md
+}
+
+func (fd *File) unmarshalFull(b []byte) {
+	sb := getBuilder()
+	defer putBuilder(sb)
+
+	var enumIdx, messageIdx, extensionIdx, serviceIdx int
+	var rawOptions []byte
+	fd.L2 = new(FileL2)
+	for len(b) > 0 {
+		num, typ, n := protowire.ConsumeTag(b)
+		b = b[n:]
+		switch typ {
+		case protowire.VarintType:
+			v, m := protowire.ConsumeVarint(b)
+			b = b[m:]
+			switch num {
+			case fieldnum.FileDescriptorProto_PublicDependency:
+				fd.L2.Imports[v].IsPublic = true
+			case fieldnum.FileDescriptorProto_WeakDependency:
+				fd.L2.Imports[v].IsWeak = true
+			}
+		case protowire.BytesType:
+			v, m := protowire.ConsumeBytes(b)
+			b = b[m:]
+			switch num {
+			case fieldnum.FileDescriptorProto_Dependency:
+				path := sb.MakeString(v)
+				imp, _ := fd.builder.FileRegistry.FindFileByPath(path)
+				if imp == nil {
+					imp = PlaceholderFile(path)
+				}
+				fd.L2.Imports = append(fd.L2.Imports, pref.FileImport{FileDescriptor: imp})
+			case fieldnum.FileDescriptorProto_EnumType:
+				fd.L1.Enums.List[enumIdx].unmarshalFull(v, sb)
+				enumIdx++
+			case fieldnum.FileDescriptorProto_MessageType:
+				fd.L1.Messages.List[messageIdx].unmarshalFull(v, sb)
+				messageIdx++
+			case fieldnum.FileDescriptorProto_Extension:
+				fd.L1.Extensions.List[extensionIdx].unmarshalFull(v, sb)
+				extensionIdx++
+			case fieldnum.FileDescriptorProto_Service:
+				fd.L1.Services.List[serviceIdx].unmarshalFull(v, sb)
+				serviceIdx++
+			case fieldnum.FileDescriptorProto_Options:
+				rawOptions = appendOptions(rawOptions, v)
+			}
+		default:
+			m := protowire.ConsumeFieldValue(num, typ, b)
+			b = b[m:]
+		}
+	}
+	fd.L2.Options = fd.builder.optionsUnmarshaler(&descopts.File, rawOptions)
+}
+
+func (ed *Enum) unmarshalFull(b []byte, sb *strs.Builder) {
+	var rawValues [][]byte
+	var rawOptions []byte
+	if !ed.L1.eagerValues {
+		ed.L2 = new(EnumL2)
+	}
+	for len(b) > 0 {
+		num, typ, n := protowire.ConsumeTag(b)
+		b = b[n:]
+		switch typ {
+		case protowire.BytesType:
+			v, m := protowire.ConsumeBytes(b)
+			b = b[m:]
+			switch num {
+			case fieldnum.EnumDescriptorProto_Value:
+				rawValues = append(rawValues, v)
+			case fieldnum.EnumDescriptorProto_ReservedName:
+				ed.L2.ReservedNames.List = append(ed.L2.ReservedNames.List, pref.Name(sb.MakeString(v)))
+			case fieldnum.EnumDescriptorProto_ReservedRange:
+				ed.L2.ReservedRanges.List = append(ed.L2.ReservedRanges.List, unmarshalEnumReservedRange(v))
+			case fieldnum.EnumDescriptorProto_Options:
+				rawOptions = appendOptions(rawOptions, v)
+			}
+		default:
+			m := protowire.ConsumeFieldValue(num, typ, b)
+			b = b[m:]
+		}
+	}
+	if !ed.L1.eagerValues && len(rawValues) > 0 {
+		ed.L2.Values.List = make([]EnumValue, len(rawValues))
+		for i, b := range rawValues {
+			ed.L2.Values.List[i].unmarshalFull(b, sb, ed.L0.ParentFile, ed, i)
+		}
+	}
+	ed.L2.Options = ed.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Enum, rawOptions)
+}
+
+func unmarshalEnumReservedRange(b []byte) (r [2]pref.EnumNumber) {
+	for len(b) > 0 {
+		num, typ, n := protowire.ConsumeTag(b)
+		b = b[n:]
+		switch typ {
+		case protowire.VarintType:
+			v, m := protowire.ConsumeVarint(b)
+			b = b[m:]
+			switch num {
+			case fieldnum.EnumDescriptorProto_EnumReservedRange_Start:
+				r[0] = pref.EnumNumber(v)
+			case fieldnum.EnumDescriptorProto_EnumReservedRange_End:
+				r[1] = pref.EnumNumber(v)
+			}
+		default:
+			m := protowire.ConsumeFieldValue(num, typ, b)
+			b = b[m:]
+		}
+	}
+	return r
+}
+
+func (vd *EnumValue) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd pref.Descriptor, i int) {
+	vd.L0.ParentFile = pf
+	vd.L0.Parent = pd
+	vd.L0.Index = i
+
+	var rawOptions []byte
+	for len(b) > 0 {
+		num, typ, n := protowire.ConsumeTag(b)
+		b = b[n:]
+		switch typ {
+		case protowire.VarintType:
+			v, m := protowire.ConsumeVarint(b)
+			b = b[m:]
+			switch num {
+			case fieldnum.EnumValueDescriptorProto_Number:
+				vd.L1.Number = pref.EnumNumber(v)
+			}
+		case protowire.BytesType:
+			v, m := protowire.ConsumeBytes(b)
+			b = b[m:]
+			switch num {
+			case fieldnum.EnumValueDescriptorProto_Name:
+				// NOTE: Enum values are in the same scope as the enum parent.
+				vd.L0.FullName = appendFullName(sb, pd.Parent().FullName(), v)
+			case fieldnum.EnumValueDescriptorProto_Options:
+				rawOptions = appendOptions(rawOptions, v)
+			}
+		default:
+			m := protowire.ConsumeFieldValue(num, typ, b)
+			b = b[m:]
+		}
+	}
+	vd.L1.Options = pf.builder.optionsUnmarshaler(&descopts.EnumValue, rawOptions)
+}
+
+func (md *Message) unmarshalFull(b []byte, sb *strs.Builder) {
+	var rawFields, rawOneofs [][]byte
+	var enumIdx, messageIdx, extensionIdx int
+	var rawOptions []byte
+	md.L2 = new(MessageL2)
+	for len(b) > 0 {
+		num, typ, n := protowire.ConsumeTag(b)
+		b = b[n:]
+		switch typ {
+		case protowire.BytesType:
+			v, m := protowire.ConsumeBytes(b)
+			b = b[m:]
+			switch num {
+			case fieldnum.DescriptorProto_Field:
+				rawFields = append(rawFields, v)
+			case fieldnum.DescriptorProto_OneofDecl:
+				rawOneofs = append(rawOneofs, v)
+			case fieldnum.DescriptorProto_ReservedName:
+				md.L2.ReservedNames.List = append(md.L2.ReservedNames.List, pref.Name(sb.MakeString(v)))
+			case fieldnum.DescriptorProto_ReservedRange:
+				md.L2.ReservedRanges.List = append(md.L2.ReservedRanges.List, unmarshalMessageReservedRange(v))
+			case fieldnum.DescriptorProto_ExtensionRange:
+				r, rawOptions := unmarshalMessageExtensionRange(v)
+				opts := md.L0.ParentFile.builder.optionsUnmarshaler(&descopts.ExtensionRange, rawOptions)
+				md.L2.ExtensionRanges.List = append(md.L2.ExtensionRanges.List, r)
+				md.L2.ExtensionRangeOptions = append(md.L2.ExtensionRangeOptions, opts)
+			case fieldnum.DescriptorProto_EnumType:
+				md.L1.Enums.List[enumIdx].unmarshalFull(v, sb)
+				enumIdx++
+			case fieldnum.DescriptorProto_NestedType:
+				md.L1.Messages.List[messageIdx].unmarshalFull(v, sb)
+				messageIdx++
+			case fieldnum.DescriptorProto_Extension:
+				md.L1.Extensions.List[extensionIdx].unmarshalFull(v, sb)
+				extensionIdx++
+			case fieldnum.DescriptorProto_Options:
+				md.unmarshalOptions(v)
+				rawOptions = appendOptions(rawOptions, v)
+			}
+		default:
+			m := protowire.ConsumeFieldValue(num, typ, b)
+			b = b[m:]
+		}
+	}
+	if len(rawFields) > 0 || len(rawOneofs) > 0 {
+		md.L2.Fields.List = make([]Field, len(rawFields))
+		md.L2.Oneofs.List = make([]Oneof, len(rawOneofs))
+		for i, b := range rawFields {
+			fd := &md.L2.Fields.List[i]
+			fd.unmarshalFull(b, sb, md.L0.ParentFile, md, i)
+			if fd.L1.Cardinality == pref.Required {
+				md.L2.RequiredNumbers.List = append(md.L2.RequiredNumbers.List, fd.L1.Number)
+			}
+		}
+		for i, b := range rawOneofs {
+			od := &md.L2.Oneofs.List[i]
+			od.unmarshalFull(b, sb, md.L0.ParentFile, md, i)
+		}
+	}
+	md.L2.Options = md.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Message, rawOptions)
+}
+
+func (md *Message) unmarshalOptions(b []byte) {
+	for len(b) > 0 {
+		num, typ, n := protowire.ConsumeTag(b)
+		b = b[n:]
+		switch typ {
+		case protowire.VarintType:
+			v, m := protowire.ConsumeVarint(b)
+			b = b[m:]
+			switch num {
+			case fieldnum.MessageOptions_MapEntry:
+				md.L1.IsMapEntry = protowire.DecodeBool(v)
+			case fieldnum.MessageOptions_MessageSetWireFormat:
+				md.L1.IsMessageSet = protowire.DecodeBool(v)
+			}
+		default:
+			m := protowire.ConsumeFieldValue(num, typ, b)
+			b = b[m:]
+		}
+	}
+}
+
+func unmarshalMessageReservedRange(b []byte) (r [2]pref.FieldNumber) {
+	for len(b) > 0 {
+		num, typ, n := protowire.ConsumeTag(b)
+		b = b[n:]
+		switch typ {
+		case protowire.VarintType:
+			v, m := protowire.ConsumeVarint(b)
+			b = b[m:]
+			switch num {
+			case fieldnum.DescriptorProto_ReservedRange_Start:
+				r[0] = pref.FieldNumber(v)
+			case fieldnum.DescriptorProto_ReservedRange_End:
+				r[1] = pref.FieldNumber(v)
+			}
+		default:
+			m := protowire.ConsumeFieldValue(num, typ, b)
+			b = b[m:]
+		}
+	}
+	return r
+}
+
+func unmarshalMessageExtensionRange(b []byte) (r [2]pref.FieldNumber, rawOptions []byte) {
+	for len(b) > 0 {
+		num, typ, n := protowire.ConsumeTag(b)
+		b = b[n:]
+		switch typ {
+		case protowire.VarintType:
+			v, m := protowire.ConsumeVarint(b)
+			b = b[m:]
+			switch num {
+			case fieldnum.DescriptorProto_ExtensionRange_Start:
+				r[0] = pref.FieldNumber(v)
+			case fieldnum.DescriptorProto_ExtensionRange_End:
+				r[1] = pref.FieldNumber(v)
+			}
+		case protowire.BytesType:
+			v, m := protowire.ConsumeBytes(b)
+			b = b[m:]
+			switch num {
+			case fieldnum.DescriptorProto_ExtensionRange_Options:
+				rawOptions = appendOptions(rawOptions, v)
+			}
+		default:
+			m := protowire.ConsumeFieldValue(num, typ, b)
+			b = b[m:]
+		}
+	}
+	return r, rawOptions
+}
+
+func (fd *Field) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd pref.Descriptor, i int) {
+	fd.L0.ParentFile = pf
+	fd.L0.Parent = pd
+	fd.L0.Index = i
+
+	var rawTypeName []byte
+	var rawOptions []byte
+	for len(b) > 0 {
+		num, typ, n := protowire.ConsumeTag(b)
+		b = b[n:]
+		switch typ {
+		case protowire.VarintType:
+			v, m := protowire.ConsumeVarint(b)
+			b = b[m:]
+			switch num {
+			case fieldnum.FieldDescriptorProto_Number:
+				fd.L1.Number = pref.FieldNumber(v)
+			case fieldnum.FieldDescriptorProto_Label:
+				fd.L1.Cardinality = pref.Cardinality(v)
+			case fieldnum.FieldDescriptorProto_Type:
+				fd.L1.Kind = pref.Kind(v)
+			case fieldnum.FieldDescriptorProto_OneofIndex:
+				// In Message.unmarshalFull, we allocate slices for both
+				// the field and oneof descriptors before unmarshaling either
+				// of them. This ensures pointers to slice elements are stable.
+				od := &pd.(*Message).L2.Oneofs.List[v]
+				od.L1.Fields.List = append(od.L1.Fields.List, fd)
+				if fd.L1.ContainingOneof != nil {
+					panic("oneof type already set")
+				}
+				fd.L1.ContainingOneof = od
+			case fieldnum.FieldDescriptorProto_Proto3Optional:
+				fd.L1.IsProto3Optional = protowire.DecodeBool(v)
+			}
+		case protowire.BytesType:
+			v, m := protowire.ConsumeBytes(b)
+			b = b[m:]
+			switch num {
+			case fieldnum.FieldDescriptorProto_Name:
+				fd.L0.FullName = appendFullName(sb, pd.FullName(), v)
+			case fieldnum.FieldDescriptorProto_JsonName:
+				fd.L1.JSONName.Init(sb.MakeString(v))
+			case fieldnum.FieldDescriptorProto_DefaultValue:
+				fd.L1.Default.val = pref.ValueOfBytes(v) // temporarily store as bytes; later resolved in resolveMessages
+			case fieldnum.FieldDescriptorProto_TypeName:
+				rawTypeName = v
+			case fieldnum.FieldDescriptorProto_Options:
+				fd.unmarshalOptions(v)
+				rawOptions = appendOptions(rawOptions, v)
+			}
+		default:
+			m := protowire.ConsumeFieldValue(num, typ, b)
+			b = b[m:]
+		}
+	}
+	if rawTypeName != nil {
+		name := makeFullName(sb, rawTypeName)
+		switch fd.L1.Kind {
+		case pref.EnumKind:
+			fd.L1.Enum = PlaceholderEnum(name)
+		case pref.MessageKind, pref.GroupKind:
+			fd.L1.Message = PlaceholderMessage(name)
+		}
+	}
+	fd.L1.Options = pf.builder.optionsUnmarshaler(&descopts.Field, rawOptions)
+}
+
+func (fd *Field) unmarshalOptions(b []byte) {
+	const FieldOptions_EnforceUTF8 = 13
+
+	for len(b) > 0 {
+		num, typ, n := protowire.ConsumeTag(b)
+		b = b[n:]
+		switch typ {
+		case protowire.VarintType:
+			v, m := protowire.ConsumeVarint(b)
+			b = b[m:]
+			switch num {
+			case fieldnum.FieldOptions_Packed:
+				fd.L1.HasPacked = true
+				fd.L1.IsPacked = protowire.DecodeBool(v)
+			case fieldnum.FieldOptions_Weak:
+				fd.L1.IsWeak = protowire.DecodeBool(v)
+			case FieldOptions_EnforceUTF8:
+				fd.L1.HasEnforceUTF8 = true
+				fd.L1.EnforceUTF8 = protowire.DecodeBool(v)
+			}
+		default:
+			m := protowire.ConsumeFieldValue(num, typ, b)
+			b = b[m:]
+		}
+	}
+}
+
+func (od *Oneof) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd pref.Descriptor, i int) {
+	od.L0.ParentFile = pf
+	od.L0.Parent = pd
+	od.L0.Index = i
+
+	var rawOptions []byte
+	for len(b) > 0 {
+		num, typ, n := protowire.ConsumeTag(b)
+		b = b[n:]
+		switch typ {
+		case protowire.BytesType:
+			v, m := protowire.ConsumeBytes(b)
+			b = b[m:]
+			switch num {
+			case fieldnum.OneofDescriptorProto_Name:
+				od.L0.FullName = appendFullName(sb, pd.FullName(), v)
+			case fieldnum.OneofDescriptorProto_Options:
+				rawOptions = appendOptions(rawOptions, v)
+			}
+		default:
+			m := protowire.ConsumeFieldValue(num, typ, b)
+			b = b[m:]
+		}
+	}
+	od.L1.Options = pf.builder.optionsUnmarshaler(&descopts.Oneof, rawOptions)
+}
+
+func (xd *Extension) unmarshalFull(b []byte, sb *strs.Builder) {
+	var rawTypeName []byte
+	var rawOptions []byte
+	xd.L2 = new(ExtensionL2)
+	for len(b) > 0 {
+		num, typ, n := protowire.ConsumeTag(b)
+		b = b[n:]
+		switch typ {
+		case protowire.VarintType:
+			v, m := protowire.ConsumeVarint(b)
+			b = b[m:]
+			switch num {
+			case fieldnum.FieldDescriptorProto_Proto3Optional:
+				xd.L2.IsProto3Optional = protowire.DecodeBool(v)
+			}
+		case protowire.BytesType:
+			v, m := protowire.ConsumeBytes(b)
+			b = b[m:]
+			switch num {
+			case fieldnum.FieldDescriptorProto_JsonName:
+				xd.L2.JSONName.Init(sb.MakeString(v))
+			case fieldnum.FieldDescriptorProto_DefaultValue:
+				xd.L2.Default.val = pref.ValueOfBytes(v) // temporarily store as bytes; later resolved in resolveExtensions
+			case fieldnum.FieldDescriptorProto_TypeName:
+				rawTypeName = v
+			case fieldnum.FieldDescriptorProto_Options:
+				xd.unmarshalOptions(v)
+				rawOptions = appendOptions(rawOptions, v)
+			}
+		default:
+			m := protowire.ConsumeFieldValue(num, typ, b)
+			b = b[m:]
+		}
+	}
+	if rawTypeName != nil {
+		name := makeFullName(sb, rawTypeName)
+		switch xd.L1.Kind {
+		case pref.EnumKind:
+			xd.L2.Enum = PlaceholderEnum(name)
+		case pref.MessageKind, pref.GroupKind:
+			xd.L2.Message = PlaceholderMessage(name)
+		}
+	}
+	xd.L2.Options = xd.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Field, rawOptions)
+}
+
+func (xd *Extension) unmarshalOptions(b []byte) {
+	for len(b) > 0 {
+		num, typ, n := protowire.ConsumeTag(b)
+		b = b[n:]
+		switch typ {
+		case protowire.VarintType:
+			v, m := protowire.ConsumeVarint(b)
+			b = b[m:]
+			switch num {
+			case fieldnum.FieldOptions_Packed:
+				xd.L2.IsPacked = protowire.DecodeBool(v)
+			}
+		default:
+			m := protowire.ConsumeFieldValue(num, typ, b)
+			b = b[m:]
+		}
+	}
+}
+
+func (sd *Service) unmarshalFull(b []byte, sb *strs.Builder) {
+	var rawMethods [][]byte
+	var rawOptions []byte
+	sd.L2 = new(ServiceL2)
+	for len(b) > 0 {
+		num, typ, n := protowire.ConsumeTag(b)
+		b = b[n:]
+		switch typ {
+		case protowire.BytesType:
+			v, m := protowire.ConsumeBytes(b)
+			b = b[m:]
+			switch num {
+			case fieldnum.ServiceDescriptorProto_Method:
+				rawMethods = append(rawMethods, v)
+			case fieldnum.ServiceDescriptorProto_Options:
+				rawOptions = appendOptions(rawOptions, v)
+			}
+		default:
+			m := protowire.ConsumeFieldValue(num, typ, b)
+			b = b[m:]
+		}
+	}
+	if len(rawMethods) > 0 {
+		sd.L2.Methods.List = make([]Method, len(rawMethods))
+		for i, b := range rawMethods {
+			sd.L2.Methods.List[i].unmarshalFull(b, sb, sd.L0.ParentFile, sd, i)
+		}
+	}
+	sd.L2.Options = sd.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Service, rawOptions)
+}
+
+func (md *Method) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd pref.Descriptor, i int) {
+	md.L0.ParentFile = pf
+	md.L0.Parent = pd
+	md.L0.Index = i
+
+	var rawOptions []byte
+	for len(b) > 0 {
+		num, typ, n := protowire.ConsumeTag(b)
+		b = b[n:]
+		switch typ {
+		case protowire.VarintType:
+			v, m := protowire.ConsumeVarint(b)
+			b = b[m:]
+			switch num {
+			case fieldnum.MethodDescriptorProto_ClientStreaming:
+				md.L1.IsStreamingClient = protowire.DecodeBool(v)
+			case fieldnum.MethodDescriptorProto_ServerStreaming:
+				md.L1.IsStreamingServer = protowire.DecodeBool(v)
+			}
+		case protowire.BytesType:
+			v, m := protowire.ConsumeBytes(b)
+			b = b[m:]
+			switch num {
+			case fieldnum.MethodDescriptorProto_Name:
+				md.L0.FullName = appendFullName(sb, pd.FullName(), v)
+			case fieldnum.MethodDescriptorProto_InputType:
+				md.L1.Input = PlaceholderMessage(makeFullName(sb, v))
+			case fieldnum.MethodDescriptorProto_OutputType:
+				md.L1.Output = PlaceholderMessage(makeFullName(sb, v))
+			case fieldnum.MethodDescriptorProto_Options:
+				rawOptions = appendOptions(rawOptions, v)
+			}
+		default:
+			m := protowire.ConsumeFieldValue(num, typ, b)
+			b = b[m:]
+		}
+	}
+	md.L1.Options = pf.builder.optionsUnmarshaler(&descopts.Method, rawOptions)
+}
+
+// appendOptions appends src to dst, where the returned slice is never nil.
+// This is necessary to distinguish between empty and unpopulated options.
+func appendOptions(dst, src []byte) []byte {
+	if dst == nil {
+		dst = []byte{}
+	}
+	return append(dst, src...)
+}
+
+// optionsUnmarshaler constructs a lazy unmarshal function for an options message.
+//
+// The type of message to unmarshal to is passed as a pointer since the
+// vars in descopts may not yet be populated at the time this function is called.
+func (db *Builder) optionsUnmarshaler(p *pref.ProtoMessage, b []byte) func() pref.ProtoMessage {
+	if b == nil {
+		return nil
+	}
+	var opts pref.ProtoMessage
+	var once sync.Once
+	return func() pref.ProtoMessage {
+		once.Do(func() {
+			if *p == nil {
+				panic("Descriptor.Options called without importing the descriptor package")
+			}
+			opts = reflect.New(reflect.TypeOf(*p).Elem()).Interface().(pref.ProtoMessage)
+			if err := (proto.UnmarshalOptions{
+				AllowPartial: true,
+				Resolver:     db.TypeResolver,
+			}).Unmarshal(b, opts); err != nil {
+				panic(err)
+			}
+		})
+		return opts
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/filedesc/desc_list.go b/vendor/google.golang.org/protobuf/internal/filedesc/desc_list.go
new file mode 100644
index 000000000..1b7089b64
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/filedesc/desc_list.go
@@ -0,0 +1,286 @@
+// Copyright 2019 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 filedesc
+
+import (
+	"fmt"
+	"math"
+	"sort"
+	"sync"
+
+	"google.golang.org/protobuf/encoding/protowire"
+	"google.golang.org/protobuf/internal/descfmt"
+	"google.golang.org/protobuf/internal/errors"
+	"google.golang.org/protobuf/internal/pragma"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+)
+
+type FileImports []pref.FileImport
+
+func (p *FileImports) Len() int                            { return len(*p) }
+func (p *FileImports) Get(i int) pref.FileImport           { return (*p)[i] }
+func (p *FileImports) Format(s fmt.State, r rune)          { descfmt.FormatList(s, r, p) }
+func (p *FileImports) ProtoInternal(pragma.DoNotImplement) {}
+
+type Names struct {
+	List []pref.Name
+	once sync.Once
+	has  map[pref.Name]int // protected by once
+}
+
+func (p *Names) Len() int                            { return len(p.List) }
+func (p *Names) Get(i int) pref.Name                 { return p.List[i] }
+func (p *Names) Has(s pref.Name) bool                { return p.lazyInit().has[s] > 0 }
+func (p *Names) Format(s fmt.State, r rune)          { descfmt.FormatList(s, r, p) }
+func (p *Names) ProtoInternal(pragma.DoNotImplement) {}
+func (p *Names) lazyInit() *Names {
+	p.once.Do(func() {
+		if len(p.List) > 0 {
+			p.has = make(map[pref.Name]int, len(p.List))
+			for _, s := range p.List {
+				p.has[s] = p.has[s] + 1
+			}
+		}
+	})
+	return p
+}
+
+// CheckValid reports any errors with the set of names with an error message
+// that completes the sentence: "ranges is invalid because it has ..."
+func (p *Names) CheckValid() error {
+	for s, n := range p.lazyInit().has {
+		switch {
+		case n > 1:
+			return errors.New("duplicate name: %q", s)
+		case false && !s.IsValid():
+			// NOTE: The C++ implementation does not validate the identifier.
+			// See https://github.com/protocolbuffers/protobuf/issues/6335.
+			return errors.New("invalid name: %q", s)
+		}
+	}
+	return nil
+}
+
+type EnumRanges struct {
+	List   [][2]pref.EnumNumber // start inclusive; end inclusive
+	once   sync.Once
+	sorted [][2]pref.EnumNumber // protected by once
+}
+
+func (p *EnumRanges) Len() int                     { return len(p.List) }
+func (p *EnumRanges) Get(i int) [2]pref.EnumNumber { return p.List[i] }
+func (p *EnumRanges) Has(n pref.EnumNumber) bool {
+	for ls := p.lazyInit().sorted; len(ls) > 0; {
+		i := len(ls) / 2
+		switch r := enumRange(ls[i]); {
+		case n < r.Start():
+			ls = ls[:i] // search lower
+		case n > r.End():
+			ls = ls[i+1:] // search upper
+		default:
+			return true
+		}
+	}
+	return false
+}
+func (p *EnumRanges) Format(s fmt.State, r rune)          { descfmt.FormatList(s, r, p) }
+func (p *EnumRanges) ProtoInternal(pragma.DoNotImplement) {}
+func (p *EnumRanges) lazyInit() *EnumRanges {
+	p.once.Do(func() {
+		p.sorted = append(p.sorted, p.List...)
+		sort.Slice(p.sorted, func(i, j int) bool {
+			return p.sorted[i][0] < p.sorted[j][0]
+		})
+	})
+	return p
+}
+
+// CheckValid reports any errors with the set of names with an error message
+// that completes the sentence: "ranges is invalid because it has ..."
+func (p *EnumRanges) CheckValid() error {
+	var rp enumRange
+	for i, r := range p.lazyInit().sorted {
+		r := enumRange(r)
+		switch {
+		case !(r.Start() <= r.End()):
+			return errors.New("invalid range: %v", r)
+		case !(rp.End() < r.Start()) && i > 0:
+			return errors.New("overlapping ranges: %v with %v", rp, r)
+		}
+		rp = r
+	}
+	return nil
+}
+
+type enumRange [2]protoreflect.EnumNumber
+
+func (r enumRange) Start() protoreflect.EnumNumber { return r[0] } // inclusive
+func (r enumRange) End() protoreflect.EnumNumber   { return r[1] } // inclusive
+func (r enumRange) String() string {
+	if r.Start() == r.End() {
+		return fmt.Sprintf("%d", r.Start())
+	}
+	return fmt.Sprintf("%d to %d", r.Start(), r.End())
+}
+
+type FieldRanges struct {
+	List   [][2]pref.FieldNumber // start inclusive; end exclusive
+	once   sync.Once
+	sorted [][2]pref.FieldNumber // protected by once
+}
+
+func (p *FieldRanges) Len() int                      { return len(p.List) }
+func (p *FieldRanges) Get(i int) [2]pref.FieldNumber { return p.List[i] }
+func (p *FieldRanges) Has(n pref.FieldNumber) bool {
+	for ls := p.lazyInit().sorted; len(ls) > 0; {
+		i := len(ls) / 2
+		switch r := fieldRange(ls[i]); {
+		case n < r.Start():
+			ls = ls[:i] // search lower
+		case n > r.End():
+			ls = ls[i+1:] // search upper
+		default:
+			return true
+		}
+	}
+	return false
+}
+func (p *FieldRanges) Format(s fmt.State, r rune)          { descfmt.FormatList(s, r, p) }
+func (p *FieldRanges) ProtoInternal(pragma.DoNotImplement) {}
+func (p *FieldRanges) lazyInit() *FieldRanges {
+	p.once.Do(func() {
+		p.sorted = append(p.sorted, p.List...)
+		sort.Slice(p.sorted, func(i, j int) bool {
+			return p.sorted[i][0] < p.sorted[j][0]
+		})
+	})
+	return p
+}
+
+// CheckValid reports any errors with the set of ranges with an error message
+// that completes the sentence: "ranges is invalid because it has ..."
+func (p *FieldRanges) CheckValid(isMessageSet bool) error {
+	var rp fieldRange
+	for i, r := range p.lazyInit().sorted {
+		r := fieldRange(r)
+		switch {
+		case !isValidFieldNumber(r.Start(), isMessageSet):
+			return errors.New("invalid field number: %d", r.Start())
+		case !isValidFieldNumber(r.End(), isMessageSet):
+			return errors.New("invalid field number: %d", r.End())
+		case !(r.Start() <= r.End()):
+			return errors.New("invalid range: %v", r)
+		case !(rp.End() < r.Start()) && i > 0:
+			return errors.New("overlapping ranges: %v with %v", rp, r)
+		}
+		rp = r
+	}
+	return nil
+}
+
+// isValidFieldNumber reports whether the field number is valid.
+// Unlike the FieldNumber.IsValid method, it allows ranges that cover the
+// reserved number range.
+func isValidFieldNumber(n protoreflect.FieldNumber, isMessageSet bool) bool {
+	if isMessageSet {
+		return protowire.MinValidNumber <= n && n <= math.MaxInt32
+	}
+	return protowire.MinValidNumber <= n && n <= protowire.MaxValidNumber
+}
+
+// CheckOverlap reports an error if p and q overlap.
+func (p *FieldRanges) CheckOverlap(q *FieldRanges) error {
+	rps := p.lazyInit().sorted
+	rqs := q.lazyInit().sorted
+	for pi, qi := 0, 0; pi < len(rps) && qi < len(rqs); {
+		rp := fieldRange(rps[pi])
+		rq := fieldRange(rqs[qi])
+		if !(rp.End() < rq.Start() || rq.End() < rp.Start()) {
+			return errors.New("overlapping ranges: %v with %v", rp, rq)
+		}
+		if rp.Start() < rq.Start() {
+			pi++
+		} else {
+			qi++
+		}
+	}
+	return nil
+}
+
+type fieldRange [2]protoreflect.FieldNumber
+
+func (r fieldRange) Start() protoreflect.FieldNumber { return r[0] }     // inclusive
+func (r fieldRange) End() protoreflect.FieldNumber   { return r[1] - 1 } // inclusive
+func (r fieldRange) String() string {
+	if r.Start() == r.End() {
+		return fmt.Sprintf("%d", r.Start())
+	}
+	return fmt.Sprintf("%d to %d", r.Start(), r.End())
+}
+
+type FieldNumbers struct {
+	List []pref.FieldNumber
+	once sync.Once
+	has  map[pref.FieldNumber]struct{} // protected by once
+}
+
+func (p *FieldNumbers) Len() int                   { return len(p.List) }
+func (p *FieldNumbers) Get(i int) pref.FieldNumber { return p.List[i] }
+func (p *FieldNumbers) Has(n pref.FieldNumber) bool {
+	p.once.Do(func() {
+		if len(p.List) > 0 {
+			p.has = make(map[pref.FieldNumber]struct{}, len(p.List))
+			for _, n := range p.List {
+				p.has[n] = struct{}{}
+			}
+		}
+	})
+	_, ok := p.has[n]
+	return ok
+}
+func (p *FieldNumbers) Format(s fmt.State, r rune)          { descfmt.FormatList(s, r, p) }
+func (p *FieldNumbers) ProtoInternal(pragma.DoNotImplement) {}
+
+type OneofFields struct {
+	List   []pref.FieldDescriptor
+	once   sync.Once
+	byName map[pref.Name]pref.FieldDescriptor        // protected by once
+	byJSON map[string]pref.FieldDescriptor           // protected by once
+	byNum  map[pref.FieldNumber]pref.FieldDescriptor // protected by once
+}
+
+func (p *OneofFields) Len() int                                         { return len(p.List) }
+func (p *OneofFields) Get(i int) pref.FieldDescriptor                   { return p.List[i] }
+func (p *OneofFields) ByName(s pref.Name) pref.FieldDescriptor          { return p.lazyInit().byName[s] }
+func (p *OneofFields) ByJSONName(s string) pref.FieldDescriptor         { return p.lazyInit().byJSON[s] }
+func (p *OneofFields) ByNumber(n pref.FieldNumber) pref.FieldDescriptor { return p.lazyInit().byNum[n] }
+func (p *OneofFields) Format(s fmt.State, r rune)                       { descfmt.FormatList(s, r, p) }
+func (p *OneofFields) ProtoInternal(pragma.DoNotImplement)              {}
+
+func (p *OneofFields) lazyInit() *OneofFields {
+	p.once.Do(func() {
+		if len(p.List) > 0 {
+			p.byName = make(map[pref.Name]pref.FieldDescriptor, len(p.List))
+			p.byJSON = make(map[string]pref.FieldDescriptor, len(p.List))
+			p.byNum = make(map[pref.FieldNumber]pref.FieldDescriptor, len(p.List))
+			for _, f := range p.List {
+				// Field names and numbers are guaranteed to be unique.
+				p.byName[f.Name()] = f
+				p.byJSON[f.JSONName()] = f
+				p.byNum[f.Number()] = f
+			}
+		}
+	})
+	return p
+}
+
+type SourceLocations struct {
+	List []pref.SourceLocation
+}
+
+func (p *SourceLocations) Len() int                            { return len(p.List) }
+func (p *SourceLocations) Get(i int) pref.SourceLocation       { return p.List[i] }
+func (p *SourceLocations) ProtoInternal(pragma.DoNotImplement) {}
diff --git a/vendor/google.golang.org/protobuf/internal/filedesc/desc_list_gen.go b/vendor/google.golang.org/protobuf/internal/filedesc/desc_list_gen.go
new file mode 100644
index 000000000..6a8825e80
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/filedesc/desc_list_gen.go
@@ -0,0 +1,345 @@
+// 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.
+
+// Code generated by generate-types. DO NOT EDIT.
+
+package filedesc
+
+import (
+	"fmt"
+	"sync"
+
+	"google.golang.org/protobuf/internal/descfmt"
+	"google.golang.org/protobuf/internal/pragma"
+	"google.golang.org/protobuf/reflect/protoreflect"
+)
+
+type Enums struct {
+	List   []Enum
+	once   sync.Once
+	byName map[protoreflect.Name]*Enum // protected by once
+}
+
+func (p *Enums) Len() int {
+	return len(p.List)
+}
+func (p *Enums) Get(i int) protoreflect.EnumDescriptor {
+	return &p.List[i]
+}
+func (p *Enums) ByName(s protoreflect.Name) protoreflect.EnumDescriptor {
+	if d := p.lazyInit().byName[s]; d != nil {
+		return d
+	}
+	return nil
+}
+func (p *Enums) Format(s fmt.State, r rune) {
+	descfmt.FormatList(s, r, p)
+}
+func (p *Enums) ProtoInternal(pragma.DoNotImplement) {}
+func (p *Enums) lazyInit() *Enums {
+	p.once.Do(func() {
+		if len(p.List) > 0 {
+			p.byName = make(map[protoreflect.Name]*Enum, len(p.List))
+			for i := range p.List {
+				d := &p.List[i]
+				if _, ok := p.byName[d.Name()]; !ok {
+					p.byName[d.Name()] = d
+				}
+			}
+		}
+	})
+	return p
+}
+
+type EnumValues struct {
+	List   []EnumValue
+	once   sync.Once
+	byName map[protoreflect.Name]*EnumValue       // protected by once
+	byNum  map[protoreflect.EnumNumber]*EnumValue // protected by once
+}
+
+func (p *EnumValues) Len() int {
+	return len(p.List)
+}
+func (p *EnumValues) Get(i int) protoreflect.EnumValueDescriptor {
+	return &p.List[i]
+}
+func (p *EnumValues) ByName(s protoreflect.Name) protoreflect.EnumValueDescriptor {
+	if d := p.lazyInit().byName[s]; d != nil {
+		return d
+	}
+	return nil
+}
+func (p *EnumValues) ByNumber(n protoreflect.EnumNumber) protoreflect.EnumValueDescriptor {
+	if d := p.lazyInit().byNum[n]; d != nil {
+		return d
+	}
+	return nil
+}
+func (p *EnumValues) Format(s fmt.State, r rune) {
+	descfmt.FormatList(s, r, p)
+}
+func (p *EnumValues) ProtoInternal(pragma.DoNotImplement) {}
+func (p *EnumValues) lazyInit() *EnumValues {
+	p.once.Do(func() {
+		if len(p.List) > 0 {
+			p.byName = make(map[protoreflect.Name]*EnumValue, len(p.List))
+			p.byNum = make(map[protoreflect.EnumNumber]*EnumValue, len(p.List))
+			for i := range p.List {
+				d := &p.List[i]
+				if _, ok := p.byName[d.Name()]; !ok {
+					p.byName[d.Name()] = d
+				}
+				if _, ok := p.byNum[d.Number()]; !ok {
+					p.byNum[d.Number()] = d
+				}
+			}
+		}
+	})
+	return p
+}
+
+type Messages struct {
+	List   []Message
+	once   sync.Once
+	byName map[protoreflect.Name]*Message // protected by once
+}
+
+func (p *Messages) Len() int {
+	return len(p.List)
+}
+func (p *Messages) Get(i int) protoreflect.MessageDescriptor {
+	return &p.List[i]
+}
+func (p *Messages) ByName(s protoreflect.Name) protoreflect.MessageDescriptor {
+	if d := p.lazyInit().byName[s]; d != nil {
+		return d
+	}
+	return nil
+}
+func (p *Messages) Format(s fmt.State, r rune) {
+	descfmt.FormatList(s, r, p)
+}
+func (p *Messages) ProtoInternal(pragma.DoNotImplement) {}
+func (p *Messages) lazyInit() *Messages {
+	p.once.Do(func() {
+		if len(p.List) > 0 {
+			p.byName = make(map[protoreflect.Name]*Message, len(p.List))
+			for i := range p.List {
+				d := &p.List[i]
+				if _, ok := p.byName[d.Name()]; !ok {
+					p.byName[d.Name()] = d
+				}
+			}
+		}
+	})
+	return p
+}
+
+type Fields struct {
+	List   []Field
+	once   sync.Once
+	byName map[protoreflect.Name]*Field        // protected by once
+	byJSON map[string]*Field                   // protected by once
+	byNum  map[protoreflect.FieldNumber]*Field // protected by once
+}
+
+func (p *Fields) Len() int {
+	return len(p.List)
+}
+func (p *Fields) Get(i int) protoreflect.FieldDescriptor {
+	return &p.List[i]
+}
+func (p *Fields) ByName(s protoreflect.Name) protoreflect.FieldDescriptor {
+	if d := p.lazyInit().byName[s]; d != nil {
+		return d
+	}
+	return nil
+}
+func (p *Fields) ByJSONName(s string) protoreflect.FieldDescriptor {
+	if d := p.lazyInit().byJSON[s]; d != nil {
+		return d
+	}
+	return nil
+}
+func (p *Fields) ByNumber(n protoreflect.FieldNumber) protoreflect.FieldDescriptor {
+	if d := p.lazyInit().byNum[n]; d != nil {
+		return d
+	}
+	return nil
+}
+func (p *Fields) Format(s fmt.State, r rune) {
+	descfmt.FormatList(s, r, p)
+}
+func (p *Fields) ProtoInternal(pragma.DoNotImplement) {}
+func (p *Fields) lazyInit() *Fields {
+	p.once.Do(func() {
+		if len(p.List) > 0 {
+			p.byName = make(map[protoreflect.Name]*Field, len(p.List))
+			p.byJSON = make(map[string]*Field, len(p.List))
+			p.byNum = make(map[protoreflect.FieldNumber]*Field, len(p.List))
+			for i := range p.List {
+				d := &p.List[i]
+				if _, ok := p.byName[d.Name()]; !ok {
+					p.byName[d.Name()] = d
+				}
+				if _, ok := p.byJSON[d.JSONName()]; !ok {
+					p.byJSON[d.JSONName()] = d
+				}
+				if _, ok := p.byNum[d.Number()]; !ok {
+					p.byNum[d.Number()] = d
+				}
+			}
+		}
+	})
+	return p
+}
+
+type Oneofs struct {
+	List   []Oneof
+	once   sync.Once
+	byName map[protoreflect.Name]*Oneof // protected by once
+}
+
+func (p *Oneofs) Len() int {
+	return len(p.List)
+}
+func (p *Oneofs) Get(i int) protoreflect.OneofDescriptor {
+	return &p.List[i]
+}
+func (p *Oneofs) ByName(s protoreflect.Name) protoreflect.OneofDescriptor {
+	if d := p.lazyInit().byName[s]; d != nil {
+		return d
+	}
+	return nil
+}
+func (p *Oneofs) Format(s fmt.State, r rune) {
+	descfmt.FormatList(s, r, p)
+}
+func (p *Oneofs) ProtoInternal(pragma.DoNotImplement) {}
+func (p *Oneofs) lazyInit() *Oneofs {
+	p.once.Do(func() {
+		if len(p.List) > 0 {
+			p.byName = make(map[protoreflect.Name]*Oneof, len(p.List))
+			for i := range p.List {
+				d := &p.List[i]
+				if _, ok := p.byName[d.Name()]; !ok {
+					p.byName[d.Name()] = d
+				}
+			}
+		}
+	})
+	return p
+}
+
+type Extensions struct {
+	List   []Extension
+	once   sync.Once
+	byName map[protoreflect.Name]*Extension // protected by once
+}
+
+func (p *Extensions) Len() int {
+	return len(p.List)
+}
+func (p *Extensions) Get(i int) protoreflect.ExtensionDescriptor {
+	return &p.List[i]
+}
+func (p *Extensions) ByName(s protoreflect.Name) protoreflect.ExtensionDescriptor {
+	if d := p.lazyInit().byName[s]; d != nil {
+		return d
+	}
+	return nil
+}
+func (p *Extensions) Format(s fmt.State, r rune) {
+	descfmt.FormatList(s, r, p)
+}
+func (p *Extensions) ProtoInternal(pragma.DoNotImplement) {}
+func (p *Extensions) lazyInit() *Extensions {
+	p.once.Do(func() {
+		if len(p.List) > 0 {
+			p.byName = make(map[protoreflect.Name]*Extension, len(p.List))
+			for i := range p.List {
+				d := &p.List[i]
+				if _, ok := p.byName[d.Name()]; !ok {
+					p.byName[d.Name()] = d
+				}
+			}
+		}
+	})
+	return p
+}
+
+type Services struct {
+	List   []Service
+	once   sync.Once
+	byName map[protoreflect.Name]*Service // protected by once
+}
+
+func (p *Services) Len() int {
+	return len(p.List)
+}
+func (p *Services) Get(i int) protoreflect.ServiceDescriptor {
+	return &p.List[i]
+}
+func (p *Services) ByName(s protoreflect.Name) protoreflect.ServiceDescriptor {
+	if d := p.lazyInit().byName[s]; d != nil {
+		return d
+	}
+	return nil
+}
+func (p *Services) Format(s fmt.State, r rune) {
+	descfmt.FormatList(s, r, p)
+}
+func (p *Services) ProtoInternal(pragma.DoNotImplement) {}
+func (p *Services) lazyInit() *Services {
+	p.once.Do(func() {
+		if len(p.List) > 0 {
+			p.byName = make(map[protoreflect.Name]*Service, len(p.List))
+			for i := range p.List {
+				d := &p.List[i]
+				if _, ok := p.byName[d.Name()]; !ok {
+					p.byName[d.Name()] = d
+				}
+			}
+		}
+	})
+	return p
+}
+
+type Methods struct {
+	List   []Method
+	once   sync.Once
+	byName map[protoreflect.Name]*Method // protected by once
+}
+
+func (p *Methods) Len() int {
+	return len(p.List)
+}
+func (p *Methods) Get(i int) protoreflect.MethodDescriptor {
+	return &p.List[i]
+}
+func (p *Methods) ByName(s protoreflect.Name) protoreflect.MethodDescriptor {
+	if d := p.lazyInit().byName[s]; d != nil {
+		return d
+	}
+	return nil
+}
+func (p *Methods) Format(s fmt.State, r rune) {
+	descfmt.FormatList(s, r, p)
+}
+func (p *Methods) ProtoInternal(pragma.DoNotImplement) {}
+func (p *Methods) lazyInit() *Methods {
+	p.once.Do(func() {
+		if len(p.List) > 0 {
+			p.byName = make(map[protoreflect.Name]*Method, len(p.List))
+			for i := range p.List {
+				d := &p.List[i]
+				if _, ok := p.byName[d.Name()]; !ok {
+					p.byName[d.Name()] = d
+				}
+			}
+		}
+	})
+	return p
+}
diff --git a/vendor/google.golang.org/protobuf/internal/filedesc/desc_test.go b/vendor/google.golang.org/protobuf/internal/filedesc/desc_test.go
new file mode 100644
index 000000000..4aef0fb6f
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/filedesc/desc_test.go
@@ -0,0 +1,789 @@
+// 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 filedesc_test
+
+import (
+	"fmt"
+	"reflect"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+
+	detrand "google.golang.org/protobuf/internal/detrand"
+	"google.golang.org/protobuf/internal/filedesc"
+	"google.golang.org/protobuf/proto"
+	pdesc "google.golang.org/protobuf/reflect/protodesc"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+
+	"google.golang.org/protobuf/types/descriptorpb"
+)
+
+func init() {
+	// Disable detrand to enable direct comparisons on outputs.
+	detrand.Disable()
+}
+
+// TODO: Test protodesc.NewFile with imported files.
+
+func TestFile(t *testing.T) {
+	f1 := &descriptorpb.FileDescriptorProto{
+		Syntax:  proto.String("proto2"),
+		Name:    proto.String("path/to/file.proto"),
+		Package: proto.String("test"),
+		Options: &descriptorpb.FileOptions{Deprecated: proto.Bool(true)},
+		MessageType: []*descriptorpb.DescriptorProto{{
+			Name: proto.String("A"),
+			Options: &descriptorpb.MessageOptions{
+				Deprecated: proto.Bool(true),
+			},
+		}, {
+			Name: proto.String("B"),
+			Field: []*descriptorpb.FieldDescriptorProto{{
+				Name:         proto.String("field_one"),
+				Number:       proto.Int32(1),
+				Label:        descriptorpb.FieldDescriptorProto_Label(pref.Optional).Enum(),
+				Type:         descriptorpb.FieldDescriptorProto_Type(pref.StringKind).Enum(),
+				DefaultValue: proto.String("hello, \"world!\"\n"),
+				OneofIndex:   proto.Int32(0),
+			}, {
+				Name:         proto.String("field_two"),
+				JsonName:     proto.String("Field2"),
+				Number:       proto.Int32(2),
+				Label:        descriptorpb.FieldDescriptorProto_Label(pref.Optional).Enum(),
+				Type:         descriptorpb.FieldDescriptorProto_Type(pref.EnumKind).Enum(),
+				DefaultValue: proto.String("BAR"),
+				TypeName:     proto.String(".test.E1"),
+				OneofIndex:   proto.Int32(1),
+			}, {
+				Name:       proto.String("field_three"),
+				Number:     proto.Int32(3),
+				Label:      descriptorpb.FieldDescriptorProto_Label(pref.Optional).Enum(),
+				Type:       descriptorpb.FieldDescriptorProto_Type(pref.MessageKind).Enum(),
+				TypeName:   proto.String(".test.C"),
+				OneofIndex: proto.Int32(1),
+			}, {
+				Name:     proto.String("field_four"),
+				JsonName: proto.String("Field4"),
+				Number:   proto.Int32(4),
+				Label:    descriptorpb.FieldDescriptorProto_Label(pref.Repeated).Enum(),
+				Type:     descriptorpb.FieldDescriptorProto_Type(pref.MessageKind).Enum(),
+				TypeName: proto.String(".test.B.FieldFourEntry"),
+			}, {
+				Name:    proto.String("field_five"),
+				Number:  proto.Int32(5),
+				Label:   descriptorpb.FieldDescriptorProto_Label(pref.Repeated).Enum(),
+				Type:    descriptorpb.FieldDescriptorProto_Type(pref.Int32Kind).Enum(),
+				Options: &descriptorpb.FieldOptions{Packed: proto.Bool(true)},
+			}, {
+				Name:   proto.String("field_six"),
+				Number: proto.Int32(6),
+				Label:  descriptorpb.FieldDescriptorProto_Label(pref.Required).Enum(),
+				Type:   descriptorpb.FieldDescriptorProto_Type(pref.BytesKind).Enum(),
+			}},
+			OneofDecl: []*descriptorpb.OneofDescriptorProto{
+				{
+					Name: proto.String("O1"),
+					Options: &descriptorpb.OneofOptions{
+						UninterpretedOption: []*descriptorpb.UninterpretedOption{
+							{StringValue: []byte("option")},
+						},
+					},
+				},
+				{Name: proto.String("O2")},
+			},
+			ReservedName: []string{"fizz", "buzz"},
+			ReservedRange: []*descriptorpb.DescriptorProto_ReservedRange{
+				{Start: proto.Int32(100), End: proto.Int32(200)},
+				{Start: proto.Int32(300), End: proto.Int32(301)},
+			},
+			ExtensionRange: []*descriptorpb.DescriptorProto_ExtensionRange{
+				{Start: proto.Int32(1000), End: proto.Int32(2000)},
+				{Start: proto.Int32(3000), End: proto.Int32(3001), Options: new(descriptorpb.ExtensionRangeOptions)},
+			},
+			NestedType: []*descriptorpb.DescriptorProto{{
+				Name: proto.String("FieldFourEntry"),
+				Field: []*descriptorpb.FieldDescriptorProto{{
+					Name:   proto.String("key"),
+					Number: proto.Int32(1),
+					Label:  descriptorpb.FieldDescriptorProto_Label(pref.Optional).Enum(),
+					Type:   descriptorpb.FieldDescriptorProto_Type(pref.StringKind).Enum(),
+				}, {
+					Name:     proto.String("value"),
+					Number:   proto.Int32(2),
+					Label:    descriptorpb.FieldDescriptorProto_Label(pref.Optional).Enum(),
+					Type:     descriptorpb.FieldDescriptorProto_Type(pref.MessageKind).Enum(),
+					TypeName: proto.String(".test.B"),
+				}},
+				Options: &descriptorpb.MessageOptions{
+					MapEntry: proto.Bool(true),
+				},
+			}},
+		}, {
+			Name: proto.String("C"),
+			NestedType: []*descriptorpb.DescriptorProto{{
+				Name: proto.String("A"),
+				Field: []*descriptorpb.FieldDescriptorProto{{
+					Name:         proto.String("F"),
+					Number:       proto.Int32(1),
+					Label:        descriptorpb.FieldDescriptorProto_Label(pref.Required).Enum(),
+					Type:         descriptorpb.FieldDescriptorProto_Type(pref.BytesKind).Enum(),
+					DefaultValue: proto.String(`dead\276\357`),
+				}},
+			}},
+			EnumType: []*descriptorpb.EnumDescriptorProto{{
+				Name: proto.String("E1"),
+				Value: []*descriptorpb.EnumValueDescriptorProto{
+					{Name: proto.String("FOO"), Number: proto.Int32(0)},
+					{Name: proto.String("BAR"), Number: proto.Int32(1)},
+				},
+			}},
+			Extension: []*descriptorpb.FieldDescriptorProto{{
+				Name:     proto.String("X"),
+				Number:   proto.Int32(1000),
+				Label:    descriptorpb.FieldDescriptorProto_Label(pref.Repeated).Enum(),
+				Type:     descriptorpb.FieldDescriptorProto_Type(pref.MessageKind).Enum(),
+				TypeName: proto.String(".test.C"),
+				Extendee: proto.String(".test.B"),
+			}},
+		}},
+		EnumType: []*descriptorpb.EnumDescriptorProto{{
+			Name:    proto.String("E1"),
+			Options: &descriptorpb.EnumOptions{Deprecated: proto.Bool(true)},
+			Value: []*descriptorpb.EnumValueDescriptorProto{
+				{
+					Name:    proto.String("FOO"),
+					Number:  proto.Int32(0),
+					Options: &descriptorpb.EnumValueOptions{Deprecated: proto.Bool(true)},
+				},
+				{Name: proto.String("BAR"), Number: proto.Int32(1)},
+			},
+			ReservedName: []string{"FIZZ", "BUZZ"},
+			ReservedRange: []*descriptorpb.EnumDescriptorProto_EnumReservedRange{
+				{Start: proto.Int32(10), End: proto.Int32(19)},
+				{Start: proto.Int32(30), End: proto.Int32(30)},
+			},
+		}},
+		Extension: []*descriptorpb.FieldDescriptorProto{{
+			Name:     proto.String("X"),
+			Number:   proto.Int32(1000),
+			Label:    descriptorpb.FieldDescriptorProto_Label(pref.Repeated).Enum(),
+			Type:     descriptorpb.FieldDescriptorProto_Type(pref.EnumKind).Enum(),
+			Options:  &descriptorpb.FieldOptions{Packed: proto.Bool(true)},
+			TypeName: proto.String(".test.E1"),
+			Extendee: proto.String(".test.B"),
+		}},
+		Service: []*descriptorpb.ServiceDescriptorProto{{
+			Name:    proto.String("S"),
+			Options: &descriptorpb.ServiceOptions{Deprecated: proto.Bool(true)},
+			Method: []*descriptorpb.MethodDescriptorProto{{
+				Name:            proto.String("M"),
+				InputType:       proto.String(".test.A"),
+				OutputType:      proto.String(".test.C.A"),
+				ClientStreaming: proto.Bool(true),
+				ServerStreaming: proto.Bool(true),
+				Options:         &descriptorpb.MethodOptions{Deprecated: proto.Bool(true)},
+			}},
+		}},
+	}
+	fd1, err := pdesc.NewFile(f1, nil)
+	if err != nil {
+		t.Fatalf("protodesc.NewFile() error: %v", err)
+	}
+
+	b, err := proto.Marshal(f1)
+	if err != nil {
+		t.Fatalf("proto.Marshal() error: %v", err)
+	}
+	fd2 := filedesc.Builder{RawDescriptor: b}.Build().File
+
+	tests := []struct {
+		name string
+		desc pref.FileDescriptor
+	}{
+		{"protodesc.NewFile", fd1},
+		{"filedesc.Builder.Build", fd2},
+	}
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			// Run sub-tests in parallel to induce potential races.
+			for i := 0; i < 2; i++ {
+				t.Run("Accessors", func(t *testing.T) { t.Parallel(); testFileAccessors(t, tt.desc) })
+				t.Run("Format", func(t *testing.T) { t.Parallel(); testFileFormat(t, tt.desc) })
+			}
+		})
+	}
+}
+
+func testFileAccessors(t *testing.T, fd pref.FileDescriptor) {
+	// Represent the descriptor as a map where each key is an accessor method
+	// and the value is either the wanted tail value or another accessor map.
+	type M = map[string]interface{}
+	want := M{
+		"Parent":        nil,
+		"Index":         0,
+		"Syntax":        pref.Proto2,
+		"Name":          pref.Name("test"),
+		"FullName":      pref.FullName("test"),
+		"Path":          "path/to/file.proto",
+		"Package":       pref.FullName("test"),
+		"IsPlaceholder": false,
+		"Options":       &descriptorpb.FileOptions{Deprecated: proto.Bool(true)},
+		"Messages": M{
+			"Len": 3,
+			"Get:0": M{
+				"Parent":        M{"FullName": pref.FullName("test")},
+				"Index":         0,
+				"Syntax":        pref.Proto2,
+				"Name":          pref.Name("A"),
+				"FullName":      pref.FullName("test.A"),
+				"IsPlaceholder": false,
+				"IsMapEntry":    false,
+				"Options": &descriptorpb.MessageOptions{
+					Deprecated: proto.Bool(true),
+				},
+				"Oneofs":          M{"Len": 0},
+				"RequiredNumbers": M{"Len": 0},
+				"ExtensionRanges": M{"Len": 0},
+				"Messages":        M{"Len": 0},
+				"Enums":           M{"Len": 0},
+				"Extensions":      M{"Len": 0},
+			},
+			"ByName:B": M{
+				"Name":  pref.Name("B"),
+				"Index": 1,
+				"Fields": M{
+					"Len":                  6,
+					"ByJSONName:field_one": nil,
+					"ByJSONName:fieldOne": M{
+						"Name":              pref.Name("field_one"),
+						"Index":             0,
+						"JSONName":          "fieldOne",
+						"Default":           "hello, \"world!\"\n",
+						"ContainingOneof":   M{"Name": pref.Name("O1"), "IsPlaceholder": false},
+						"ContainingMessage": M{"FullName": pref.FullName("test.B")},
+					},
+					"ByJSONName:fieldTwo": nil,
+					"ByJSONName:Field2": M{
+						"Name":            pref.Name("field_two"),
+						"Index":           1,
+						"HasJSONName":     true,
+						"JSONName":        "Field2",
+						"Default":         pref.EnumNumber(1),
+						"ContainingOneof": M{"Name": pref.Name("O2"), "IsPlaceholder": false},
+					},
+					"ByName:fieldThree": nil,
+					"ByName:field_three": M{
+						"IsExtension":       false,
+						"IsMap":             false,
+						"MapKey":            nil,
+						"MapValue":          nil,
+						"Message":           M{"FullName": pref.FullName("test.C"), "IsPlaceholder": false},
+						"ContainingOneof":   M{"Name": pref.Name("O2"), "IsPlaceholder": false},
+						"ContainingMessage": M{"FullName": pref.FullName("test.B")},
+					},
+					"ByNumber:12": nil,
+					"ByNumber:4": M{
+						"Cardinality": pref.Repeated,
+						"IsExtension": false,
+						"IsList":      false,
+						"IsMap":       true,
+						"MapKey":      M{"Kind": pref.StringKind},
+						"MapValue":    M{"Kind": pref.MessageKind, "Message": M{"FullName": pref.FullName("test.B")}},
+						"Default":     nil,
+						"Message":     M{"FullName": pref.FullName("test.B.FieldFourEntry"), "IsPlaceholder": false},
+					},
+					"ByNumber:5": M{
+						"Cardinality": pref.Repeated,
+						"Kind":        pref.Int32Kind,
+						"IsPacked":    true,
+						"IsList":      true,
+						"IsMap":       false,
+						"Default":     nil,
+					},
+					"ByNumber:6": M{
+						"Cardinality":     pref.Required,
+						"Default":         []byte(nil),
+						"ContainingOneof": nil,
+					},
+				},
+				"Oneofs": M{
+					"Len":       2,
+					"ByName:O0": nil,
+					"ByName:O1": M{
+						"FullName": pref.FullName("test.B.O1"),
+						"Index":    0,
+						"Options": &descriptorpb.OneofOptions{
+							UninterpretedOption: []*descriptorpb.UninterpretedOption{
+								{StringValue: []byte("option")},
+							},
+						},
+						"Fields": M{
+							"Len":   1,
+							"Get:0": M{"FullName": pref.FullName("test.B.field_one")},
+						},
+					},
+					"Get:1": M{
+						"FullName": pref.FullName("test.B.O2"),
+						"Index":    1,
+						"Fields": M{
+							"Len":              2,
+							"ByName:field_two": M{"Name": pref.Name("field_two")},
+							"Get:1":            M{"Name": pref.Name("field_three")},
+						},
+					},
+				},
+				"ReservedNames": M{
+					"Len":         2,
+					"Get:0":       pref.Name("fizz"),
+					"Has:buzz":    true,
+					"Has:noexist": false,
+				},
+				"ReservedRanges": M{
+					"Len":     2,
+					"Get:0":   [2]pref.FieldNumber{100, 200},
+					"Has:99":  false,
+					"Has:100": true,
+					"Has:150": true,
+					"Has:199": true,
+					"Has:200": false,
+					"Has:300": true,
+					"Has:301": false,
+				},
+				"RequiredNumbers": M{
+					"Len":   1,
+					"Get:0": pref.FieldNumber(6),
+					"Has:1": false,
+					"Has:6": true,
+				},
+				"ExtensionRanges": M{
+					"Len":      2,
+					"Get:0":    [2]pref.FieldNumber{1000, 2000},
+					"Has:999":  false,
+					"Has:1000": true,
+					"Has:1500": true,
+					"Has:1999": true,
+					"Has:2000": false,
+					"Has:3000": true,
+					"Has:3001": false,
+				},
+				"ExtensionRangeOptions:0": (*descriptorpb.ExtensionRangeOptions)(nil),
+				"ExtensionRangeOptions:1": new(descriptorpb.ExtensionRangeOptions),
+				"Messages": M{
+					"Get:0": M{
+						"Fields": M{
+							"Len": 2,
+							"ByNumber:1": M{
+								"Parent":            M{"FullName": pref.FullName("test.B.FieldFourEntry")},
+								"Index":             0,
+								"Name":              pref.Name("key"),
+								"FullName":          pref.FullName("test.B.FieldFourEntry.key"),
+								"Number":            pref.FieldNumber(1),
+								"Cardinality":       pref.Optional,
+								"Kind":              pref.StringKind,
+								"Options":           (*descriptorpb.FieldOptions)(nil),
+								"HasJSONName":       false,
+								"JSONName":          "key",
+								"IsPacked":          false,
+								"IsList":            false,
+								"IsMap":             false,
+								"IsExtension":       false,
+								"IsWeak":            false,
+								"Default":           "",
+								"ContainingOneof":   nil,
+								"ContainingMessage": M{"FullName": pref.FullName("test.B.FieldFourEntry")},
+								"Message":           nil,
+								"Enum":              nil,
+							},
+							"ByNumber:2": M{
+								"Parent":            M{"FullName": pref.FullName("test.B.FieldFourEntry")},
+								"Index":             1,
+								"Name":              pref.Name("value"),
+								"FullName":          pref.FullName("test.B.FieldFourEntry.value"),
+								"Number":            pref.FieldNumber(2),
+								"Cardinality":       pref.Optional,
+								"Kind":              pref.MessageKind,
+								"JSONName":          "value",
+								"IsPacked":          false,
+								"IsList":            false,
+								"IsMap":             false,
+								"IsExtension":       false,
+								"IsWeak":            false,
+								"Default":           nil,
+								"ContainingOneof":   nil,
+								"ContainingMessage": M{"FullName": pref.FullName("test.B.FieldFourEntry")},
+								"Message":           M{"FullName": pref.FullName("test.B"), "IsPlaceholder": false},
+								"Enum":              nil,
+							},
+							"ByNumber:3": nil,
+						},
+					},
+				},
+			},
+			"Get:2": M{
+				"Name":  pref.Name("C"),
+				"Index": 2,
+				"Messages": M{
+					"Len":   1,
+					"Get:0": M{"FullName": pref.FullName("test.C.A")},
+				},
+				"Enums": M{
+					"Len":   1,
+					"Get:0": M{"FullName": pref.FullName("test.C.E1")},
+				},
+				"Extensions": M{
+					"Len":   1,
+					"Get:0": M{"FullName": pref.FullName("test.C.X")},
+				},
+			},
+		},
+		"Enums": M{
+			"Len": 1,
+			"Get:0": M{
+				"Name":    pref.Name("E1"),
+				"Options": &descriptorpb.EnumOptions{Deprecated: proto.Bool(true)},
+				"Values": M{
+					"Len":        2,
+					"ByName:Foo": nil,
+					"ByName:FOO": M{
+						"FullName": pref.FullName("test.FOO"),
+						"Options":  &descriptorpb.EnumValueOptions{Deprecated: proto.Bool(true)},
+					},
+					"ByNumber:2": nil,
+					"ByNumber:1": M{"FullName": pref.FullName("test.BAR")},
+				},
+				"ReservedNames": M{
+					"Len":         2,
+					"Get:0":       pref.Name("FIZZ"),
+					"Has:BUZZ":    true,
+					"Has:NOEXIST": false,
+				},
+				"ReservedRanges": M{
+					"Len":    2,
+					"Get:0":  [2]pref.EnumNumber{10, 19},
+					"Has:9":  false,
+					"Has:10": true,
+					"Has:15": true,
+					"Has:19": true,
+					"Has:20": false,
+					"Has:30": true,
+					"Has:31": false,
+				},
+			},
+		},
+		"Extensions": M{
+			"Len": 1,
+			"ByName:X": M{
+				"Name":              pref.Name("X"),
+				"Number":            pref.FieldNumber(1000),
+				"Cardinality":       pref.Repeated,
+				"Kind":              pref.EnumKind,
+				"IsExtension":       true,
+				"IsPacked":          true,
+				"IsList":            true,
+				"IsMap":             false,
+				"MapKey":            nil,
+				"MapValue":          nil,
+				"ContainingOneof":   nil,
+				"ContainingMessage": M{"FullName": pref.FullName("test.B"), "IsPlaceholder": false},
+				"Enum":              M{"FullName": pref.FullName("test.E1"), "IsPlaceholder": false},
+				"Options":           &descriptorpb.FieldOptions{Packed: proto.Bool(true)},
+			},
+		},
+		"Services": M{
+			"Len":      1,
+			"ByName:s": nil,
+			"ByName:S": M{
+				"Parent":   M{"FullName": pref.FullName("test")},
+				"Name":     pref.Name("S"),
+				"FullName": pref.FullName("test.S"),
+				"Options":  &descriptorpb.ServiceOptions{Deprecated: proto.Bool(true)},
+				"Methods": M{
+					"Len": 1,
+					"Get:0": M{
+						"Parent":            M{"FullName": pref.FullName("test.S")},
+						"Name":              pref.Name("M"),
+						"FullName":          pref.FullName("test.S.M"),
+						"Input":             M{"FullName": pref.FullName("test.A"), "IsPlaceholder": false},
+						"Output":            M{"FullName": pref.FullName("test.C.A"), "IsPlaceholder": false},
+						"IsStreamingClient": true,
+						"IsStreamingServer": true,
+						"Options":           &descriptorpb.MethodOptions{Deprecated: proto.Bool(true)},
+					},
+				},
+			},
+		},
+	}
+	checkAccessors(t, "", reflect.ValueOf(fd), want)
+}
+func checkAccessors(t *testing.T, p string, rv reflect.Value, want map[string]interface{}) {
+	p0 := p
+	defer func() {
+		if ex := recover(); ex != nil {
+			t.Errorf("panic at %v: %v", p, ex)
+		}
+	}()
+
+	if rv.Interface() == nil {
+		t.Errorf("%v is nil, want non-nil", p)
+		return
+	}
+	for s, v := range want {
+		// Call the accessor method.
+		p = p0 + "." + s
+		var rets []reflect.Value
+		if i := strings.IndexByte(s, ':'); i >= 0 {
+			// Accessor method takes in a single argument, which is encoded
+			// after the accessor name, separated by a ':' delimiter.
+			fnc := rv.MethodByName(s[:i])
+			arg := reflect.New(fnc.Type().In(0)).Elem()
+			s = s[i+len(":"):]
+			switch arg.Kind() {
+			case reflect.String:
+				arg.SetString(s)
+			case reflect.Int32, reflect.Int:
+				n, _ := strconv.ParseInt(s, 0, 64)
+				arg.SetInt(n)
+			}
+			rets = fnc.Call([]reflect.Value{arg})
+		} else {
+			rets = rv.MethodByName(s).Call(nil)
+		}
+
+		// Check that (val, ok) pattern is internally consistent.
+		if len(rets) == 2 {
+			if rets[0].IsNil() && rets[1].Bool() {
+				t.Errorf("%v = (nil, true), want (nil, false)", p)
+			}
+			if !rets[0].IsNil() && !rets[1].Bool() {
+				t.Errorf("%v = (non-nil, false), want (non-nil, true)", p)
+			}
+		}
+
+		// Check that the accessor output matches.
+		if want, ok := v.(map[string]interface{}); ok {
+			checkAccessors(t, p, rets[0], want)
+			continue
+		}
+
+		got := rets[0].Interface()
+		if pv, ok := got.(pref.Value); ok {
+			got = pv.Interface()
+		}
+
+		// Compare with proto.Equal if possible.
+		gotMsg, gotMsgOK := got.(proto.Message)
+		wantMsg, wantMsgOK := v.(proto.Message)
+		if gotMsgOK && wantMsgOK {
+			gotNil := reflect.ValueOf(gotMsg).IsNil()
+			wantNil := reflect.ValueOf(wantMsg).IsNil()
+			switch {
+			case !gotNil && wantNil:
+				t.Errorf("%v = non-nil, want nil", p)
+			case gotNil && !wantNil:
+				t.Errorf("%v = nil, want non-nil", p)
+			case !proto.Equal(gotMsg, wantMsg):
+				t.Errorf("%v = %v, want %v", p, gotMsg, wantMsg)
+			}
+			continue
+		}
+
+		if want := v; !reflect.DeepEqual(got, want) {
+			t.Errorf("%v = %T(%v), want %T(%v)", p, got, got, want, want)
+		}
+	}
+}
+
+func testFileFormat(t *testing.T, fd pref.FileDescriptor) {
+	const want = `FileDescriptor{
+	Syntax:  proto2
+	Path:    "path/to/file.proto"
+	Package: test
+	Messages: [{
+		Name: A
+	}, {
+		Name: B
+		Fields: [{
+			Name:        field_one
+			Number:      1
+			Cardinality: optional
+			Kind:        string
+			JSONName:    "fieldOne"
+			HasPresence: true
+			HasDefault:  true
+			Default:     "hello, \"world!\"\n"
+			Oneof:       O1
+		}, {
+			Name:        field_two
+			Number:      2
+			Cardinality: optional
+			Kind:        enum
+			HasJSONName: true
+			JSONName:    "Field2"
+			HasPresence: true
+			HasDefault:  true
+			Default:     1
+			Oneof:       O2
+			Enum:        test.E1
+		}, {
+			Name:        field_three
+			Number:      3
+			Cardinality: optional
+			Kind:        message
+			JSONName:    "fieldThree"
+			HasPresence: true
+			Oneof:       O2
+			Message:     test.C
+		}, {
+			Name:        field_four
+			Number:      4
+			Cardinality: repeated
+			Kind:        message
+			HasJSONName: true
+			JSONName:    "Field4"
+			IsMap:       true
+			MapKey:      string
+			MapValue:    test.B
+		}, {
+			Name:        field_five
+			Number:      5
+			Cardinality: repeated
+			Kind:        int32
+			JSONName:    "fieldFive"
+			IsPacked:    true
+			IsList:      true
+		}, {
+			Name:        field_six
+			Number:      6
+			Cardinality: required
+			Kind:        bytes
+			JSONName:    "fieldSix"
+			HasPresence: true
+		}]
+		Oneofs: [{
+			Name:   O1
+			Fields: [field_one]
+		}, {
+			Name:   O2
+			Fields: [field_two, field_three]
+		}]
+		ReservedNames:   [fizz, buzz]
+		ReservedRanges:  [100:200, 300]
+		RequiredNumbers: [6]
+		ExtensionRanges: [1000:2000, 3000]
+		Messages: [{
+			Name:       FieldFourEntry
+			IsMapEntry: true
+			Fields: [{
+				Name:        key
+				Number:      1
+				Cardinality: optional
+				Kind:        string
+				JSONName:    "key"
+				HasPresence: true
+			}, {
+				Name:        value
+				Number:      2
+				Cardinality: optional
+				Kind:        message
+				JSONName:    "value"
+				HasPresence: true
+				Message:     test.B
+			}]
+		}]
+	}, {
+		Name: C
+		Messages: [{
+			Name: A
+			Fields: [{
+				Name:        F
+				Number:      1
+				Cardinality: required
+				Kind:        bytes
+				JSONName:    "F"
+				HasPresence: true
+				HasDefault:  true
+				Default:     "dead\xbe\xef"
+			}]
+			RequiredNumbers: [1]
+		}]
+		Enums: [{
+			Name: E1
+			Values: [
+				{Name: FOO}
+				{Name: BAR, Number: 1}
+			]
+		}]
+		Extensions: [{
+			Name:        X
+			Number:      1000
+			Cardinality: repeated
+			Kind:        message
+			JSONName:    "X"
+			IsExtension: true
+			IsList:      true
+			Extendee:    test.B
+			Message:     test.C
+		}]
+	}]
+	Enums: [{
+		Name: E1
+		Values: [
+			{Name: FOO}
+			{Name: BAR, Number: 1}
+		]
+		ReservedNames:  [FIZZ, BUZZ]
+		ReservedRanges: [10:20, 30]
+	}]
+	Extensions: [{
+		Name:        X
+		Number:      1000
+		Cardinality: repeated
+		Kind:        enum
+		JSONName:    "X"
+		IsExtension: true
+		IsPacked:    true
+		IsList:      true
+		Extendee:    test.B
+		Enum:        test.E1
+	}]
+	Services: [{
+		Name: S
+		Methods: [{
+			Name:              M
+			Input:             test.A
+			Output:            test.C.A
+			IsStreamingClient: true
+			IsStreamingServer: true
+		}]
+	}]
+}`
+	tests := []struct{ fmt, want string }{{"%v", compactMultiFormat(want)}, {"%+v", want}}
+	for _, tt := range tests {
+		got := fmt.Sprintf(tt.fmt, fd)
+		if diff := cmp.Diff(got, tt.want); diff != "" {
+			t.Errorf("fmt.Sprintf(%q, fd) mismatch (-got +want):\n%s", tt.fmt, diff)
+		}
+	}
+}
+
+// compactMultiFormat returns the single line form of a multi line output.
+func compactMultiFormat(s string) string {
+	var b []byte
+	for _, s := range strings.Split(s, "\n") {
+		s = strings.TrimSpace(s)
+		s = regexp.MustCompile(": +").ReplaceAllString(s, ": ")
+		prevWord := len(b) > 0 && b[len(b)-1] != '[' && b[len(b)-1] != '{'
+		nextWord := len(s) > 0 && s[0] != ']' && s[0] != '}'
+		if prevWord && nextWord {
+			b = append(b, ", "...)
+		}
+		b = append(b, s...)
+	}
+	return string(b)
+}
diff --git a/vendor/google.golang.org/protobuf/internal/filedesc/placeholder.go b/vendor/google.golang.org/protobuf/internal/filedesc/placeholder.go
new file mode 100644
index 000000000..dbf2c605b
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/filedesc/placeholder.go
@@ -0,0 +1,107 @@
+// Copyright 2019 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 filedesc
+
+import (
+	"google.golang.org/protobuf/internal/descopts"
+	"google.golang.org/protobuf/internal/pragma"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+)
+
+var (
+	emptyNames           = new(Names)
+	emptyEnumRanges      = new(EnumRanges)
+	emptyFieldRanges     = new(FieldRanges)
+	emptyFieldNumbers    = new(FieldNumbers)
+	emptySourceLocations = new(SourceLocations)
+
+	emptyFiles      = new(FileImports)
+	emptyMessages   = new(Messages)
+	emptyFields     = new(Fields)
+	emptyOneofs     = new(Oneofs)
+	emptyEnums      = new(Enums)
+	emptyEnumValues = new(EnumValues)
+	emptyExtensions = new(Extensions)
+	emptyServices   = new(Services)
+)
+
+// PlaceholderFile is a placeholder, representing only the file path.
+type PlaceholderFile string
+
+func (f PlaceholderFile) ParentFile() pref.FileDescriptor       { return f }
+func (f PlaceholderFile) Parent() pref.Descriptor               { return nil }
+func (f PlaceholderFile) Index() int                            { return 0 }
+func (f PlaceholderFile) Syntax() pref.Syntax                   { return 0 }
+func (f PlaceholderFile) Name() pref.Name                       { return "" }
+func (f PlaceholderFile) FullName() pref.FullName               { return "" }
+func (f PlaceholderFile) IsPlaceholder() bool                   { return true }
+func (f PlaceholderFile) Options() pref.ProtoMessage            { return descopts.File }
+func (f PlaceholderFile) Path() string                          { return string(f) }
+func (f PlaceholderFile) Package() pref.FullName                { return "" }
+func (f PlaceholderFile) Imports() pref.FileImports             { return emptyFiles }
+func (f PlaceholderFile) Messages() pref.MessageDescriptors     { return emptyMessages }
+func (f PlaceholderFile) Enums() pref.EnumDescriptors           { return emptyEnums }
+func (f PlaceholderFile) Extensions() pref.ExtensionDescriptors { return emptyExtensions }
+func (f PlaceholderFile) Services() pref.ServiceDescriptors     { return emptyServices }
+func (f PlaceholderFile) SourceLocations() pref.SourceLocations { return emptySourceLocations }
+func (f PlaceholderFile) ProtoType(pref.FileDescriptor)         { return }
+func (f PlaceholderFile) ProtoInternal(pragma.DoNotImplement)   { return }
+
+// PlaceholderEnum is a placeholder, representing only the full name.
+type PlaceholderEnum pref.FullName
+
+func (e PlaceholderEnum) ParentFile() pref.FileDescriptor     { return nil }
+func (e PlaceholderEnum) Parent() pref.Descriptor             { return nil }
+func (e PlaceholderEnum) Index() int                          { return 0 }
+func (e PlaceholderEnum) Syntax() pref.Syntax                 { return 0 }
+func (e PlaceholderEnum) Name() pref.Name                     { return pref.FullName(e).Name() }
+func (e PlaceholderEnum) FullName() pref.FullName             { return pref.FullName(e) }
+func (e PlaceholderEnum) IsPlaceholder() bool                 { return true }
+func (e PlaceholderEnum) Options() pref.ProtoMessage          { return descopts.Enum }
+func (e PlaceholderEnum) Values() pref.EnumValueDescriptors   { return emptyEnumValues }
+func (e PlaceholderEnum) ReservedNames() pref.Names           { return emptyNames }
+func (e PlaceholderEnum) ReservedRanges() pref.EnumRanges     { return emptyEnumRanges }
+func (e PlaceholderEnum) ProtoType(pref.EnumDescriptor)       { return }
+func (e PlaceholderEnum) ProtoInternal(pragma.DoNotImplement) { return }
+
+// PlaceholderEnumValue is a placeholder, representing only the full name.
+type PlaceholderEnumValue pref.FullName
+
+func (e PlaceholderEnumValue) ParentFile() pref.FileDescriptor     { return nil }
+func (e PlaceholderEnumValue) Parent() pref.Descriptor             { return nil }
+func (e PlaceholderEnumValue) Index() int                          { return 0 }
+func (e PlaceholderEnumValue) Syntax() pref.Syntax                 { return 0 }
+func (e PlaceholderEnumValue) Name() pref.Name                     { return pref.FullName(e).Name() }
+func (e PlaceholderEnumValue) FullName() pref.FullName             { return pref.FullName(e) }
+func (e PlaceholderEnumValue) IsPlaceholder() bool                 { return true }
+func (e PlaceholderEnumValue) Options() pref.ProtoMessage          { return descopts.EnumValue }
+func (e PlaceholderEnumValue) Number() pref.EnumNumber             { return 0 }
+func (e PlaceholderEnumValue) ProtoType(pref.EnumValueDescriptor)  { return }
+func (e PlaceholderEnumValue) ProtoInternal(pragma.DoNotImplement) { return }
+
+// PlaceholderMessage is a placeholder, representing only the full name.
+type PlaceholderMessage pref.FullName
+
+func (m PlaceholderMessage) ParentFile() pref.FileDescriptor             { return nil }
+func (m PlaceholderMessage) Parent() pref.Descriptor                     { return nil }
+func (m PlaceholderMessage) Index() int                                  { return 0 }
+func (m PlaceholderMessage) Syntax() pref.Syntax                         { return 0 }
+func (m PlaceholderMessage) Name() pref.Name                             { return pref.FullName(m).Name() }
+func (m PlaceholderMessage) FullName() pref.FullName                     { return pref.FullName(m) }
+func (m PlaceholderMessage) IsPlaceholder() bool                         { return true }
+func (m PlaceholderMessage) Options() pref.ProtoMessage                  { return descopts.Message }
+func (m PlaceholderMessage) IsMapEntry() bool                            { return false }
+func (m PlaceholderMessage) Fields() pref.FieldDescriptors               { return emptyFields }
+func (m PlaceholderMessage) Oneofs() pref.OneofDescriptors               { return emptyOneofs }
+func (m PlaceholderMessage) ReservedNames() pref.Names                   { return emptyNames }
+func (m PlaceholderMessage) ReservedRanges() pref.FieldRanges            { return emptyFieldRanges }
+func (m PlaceholderMessage) RequiredNumbers() pref.FieldNumbers          { return emptyFieldNumbers }
+func (m PlaceholderMessage) ExtensionRanges() pref.FieldRanges           { return emptyFieldRanges }
+func (m PlaceholderMessage) ExtensionRangeOptions(int) pref.ProtoMessage { panic("index out of range") }
+func (m PlaceholderMessage) Messages() pref.MessageDescriptors           { return emptyMessages }
+func (m PlaceholderMessage) Enums() pref.EnumDescriptors                 { return emptyEnums }
+func (m PlaceholderMessage) Extensions() pref.ExtensionDescriptors       { return emptyExtensions }
+func (m PlaceholderMessage) ProtoType(pref.MessageDescriptor)            { return }
+func (m PlaceholderMessage) ProtoInternal(pragma.DoNotImplement)         { return }
diff --git a/vendor/google.golang.org/protobuf/internal/filetype/build.go b/vendor/google.golang.org/protobuf/internal/filetype/build.go
new file mode 100644
index 000000000..0a0dd35de
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/filetype/build.go
@@ -0,0 +1,297 @@
+// Copyright 2019 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 filetype provides functionality for wrapping descriptors
+// with Go type information.
+package filetype
+
+import (
+	"reflect"
+
+	"google.golang.org/protobuf/internal/descopts"
+	fdesc "google.golang.org/protobuf/internal/filedesc"
+	pimpl "google.golang.org/protobuf/internal/impl"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+	preg "google.golang.org/protobuf/reflect/protoregistry"
+)
+
+// Builder constructs type descriptors from a raw file descriptor
+// and associated Go types for each enum and message declaration.
+//
+//
+// Flattened Ordering
+//
+// The protobuf type system represents declarations as a tree. Certain nodes in
+// the tree require us to either associate it with a concrete Go type or to
+// resolve a dependency, which is information that must be provided separately
+// since it cannot be derived from the file descriptor alone.
+//
+// However, representing a tree as Go literals is difficult to simply do in a
+// space and time efficient way. Thus, we store them as a flattened list of
+// objects where the serialization order from the tree-based form is important.
+//
+// The "flattened ordering" is defined as a tree traversal of all enum, message,
+// extension, and service declarations using the following algorithm:
+//
+//	def VisitFileDecls(fd):
+//		for e in fd.Enums:      yield e
+//		for m in fd.Messages:   yield m
+//		for x in fd.Extensions: yield x
+//		for s in fd.Services:   yield s
+//		for m in fd.Messages:   yield from VisitMessageDecls(m)
+//
+//	def VisitMessageDecls(md):
+//		for e in md.Enums:      yield e
+//		for m in md.Messages:   yield m
+//		for x in md.Extensions: yield x
+//		for m in md.Messages:   yield from VisitMessageDecls(m)
+//
+// The traversal starts at the root file descriptor and yields each direct
+// declaration within each node before traversing into sub-declarations
+// that children themselves may have.
+type Builder struct {
+	// File is the underlying file descriptor builder.
+	File fdesc.Builder
+
+	// GoTypes is a unique set of the Go types for all declarations and
+	// dependencies. Each type is represented as a zero value of the Go type.
+	//
+	// Declarations are Go types generated for enums and messages directly
+	// declared (not publicly imported) in the proto source file.
+	// Messages for map entries are accounted for, but represented by nil.
+	// Enum declarations in "flattened ordering" come first, followed by
+	// message declarations in "flattened ordering".
+	//
+	// Dependencies are Go types for enums or messages referenced by
+	// message fields (excluding weak fields), for parent extended messages of
+	// extension fields, for enums or messages referenced by extension fields,
+	// and for input and output messages referenced by service methods.
+	// Dependencies must come after declarations, but the ordering of
+	// dependencies themselves is unspecified.
+	GoTypes []interface{}
+
+	// DependencyIndexes is an ordered list of indexes into GoTypes for the
+	// dependencies of messages, extensions, or services.
+	//
+	// There are 5 sub-lists in "flattened ordering" concatenated back-to-back:
+	//	0. Message field dependencies: list of the enum or message type
+	//	referred to by every message field.
+	//	1. Extension field targets: list of the extended parent message of
+	//	every extension.
+	//	2. Extension field dependencies: list of the enum or message type
+	//	referred to by every extension field.
+	//	3. Service method inputs: list of the input message type
+	//	referred to by every service method.
+	//	4. Service method outputs: list of the output message type
+	//	referred to by every service method.
+	//
+	// The offset into DependencyIndexes for the start of each sub-list
+	// is appended to the end in reverse order.
+	DependencyIndexes []int32
+
+	// EnumInfos is a list of enum infos in "flattened ordering".
+	EnumInfos []pimpl.EnumInfo
+
+	// MessageInfos is a list of message infos in "flattened ordering".
+	// If provided, the GoType and PBType for each element is populated.
+	//
+	// Requirement: len(MessageInfos) == len(Build.Messages)
+	MessageInfos []pimpl.MessageInfo
+
+	// ExtensionInfos is a list of extension infos in "flattened ordering".
+	// Each element is initialized and registered with the protoregistry package.
+	//
+	// Requirement: len(LegacyExtensions) == len(Build.Extensions)
+	ExtensionInfos []pimpl.ExtensionInfo
+
+	// TypeRegistry is the registry to register each type descriptor.
+	// If nil, it uses protoregistry.GlobalTypes.
+	TypeRegistry interface {
+		RegisterMessage(pref.MessageType) error
+		RegisterEnum(pref.EnumType) error
+		RegisterExtension(pref.ExtensionType) error
+	}
+}
+
+// Out is the output of the builder.
+type Out struct {
+	File pref.FileDescriptor
+}
+
+func (tb Builder) Build() (out Out) {
+	// Replace the resolver with one that resolves dependencies by index,
+	// which is faster and more reliable than relying on the global registry.
+	if tb.File.FileRegistry == nil {
+		tb.File.FileRegistry = preg.GlobalFiles
+	}
+	tb.File.FileRegistry = &resolverByIndex{
+		goTypes:      tb.GoTypes,
+		depIdxs:      tb.DependencyIndexes,
+		fileRegistry: tb.File.FileRegistry,
+	}
+
+	// Initialize registry if unpopulated.
+	if tb.TypeRegistry == nil {
+		tb.TypeRegistry = preg.GlobalTypes
+	}
+
+	fbOut := tb.File.Build()
+	out.File = fbOut.File
+
+	// Process enums.
+	enumGoTypes := tb.GoTypes[:len(fbOut.Enums)]
+	if len(tb.EnumInfos) != len(fbOut.Enums) {
+		panic("mismatching enum lengths")
+	}
+	if len(fbOut.Enums) > 0 {
+		for i := range fbOut.Enums {
+			tb.EnumInfos[i] = pimpl.EnumInfo{
+				GoReflectType: reflect.TypeOf(enumGoTypes[i]),
+				Desc:          &fbOut.Enums[i],
+			}
+			// Register enum types.
+			if err := tb.TypeRegistry.RegisterEnum(&tb.EnumInfos[i]); err != nil {
+				panic(err)
+			}
+		}
+	}
+
+	// Process messages.
+	messageGoTypes := tb.GoTypes[len(fbOut.Enums):][:len(fbOut.Messages)]
+	if len(tb.MessageInfos) != len(fbOut.Messages) {
+		panic("mismatching message lengths")
+	}
+	if len(fbOut.Messages) > 0 {
+		for i := range fbOut.Messages {
+			if messageGoTypes[i] == nil {
+				continue // skip map entry
+			}
+
+			tb.MessageInfos[i].GoReflectType = reflect.TypeOf(messageGoTypes[i])
+			tb.MessageInfos[i].Desc = &fbOut.Messages[i]
+
+			// Register message types.
+			if err := tb.TypeRegistry.RegisterMessage(&tb.MessageInfos[i]); err != nil {
+				panic(err)
+			}
+		}
+
+		// As a special-case for descriptor.proto,
+		// locally register concrete message type for the options.
+		if out.File.Path() == "google/protobuf/descriptor.proto" && out.File.Package() == "google.protobuf" {
+			for i := range fbOut.Messages {
+				switch fbOut.Messages[i].Name() {
+				case "FileOptions":
+					descopts.File = messageGoTypes[i].(pref.ProtoMessage)
+				case "EnumOptions":
+					descopts.Enum = messageGoTypes[i].(pref.ProtoMessage)
+				case "EnumValueOptions":
+					descopts.EnumValue = messageGoTypes[i].(pref.ProtoMessage)
+				case "MessageOptions":
+					descopts.Message = messageGoTypes[i].(pref.ProtoMessage)
+				case "FieldOptions":
+					descopts.Field = messageGoTypes[i].(pref.ProtoMessage)
+				case "OneofOptions":
+					descopts.Oneof = messageGoTypes[i].(pref.ProtoMessage)
+				case "ExtensionRangeOptions":
+					descopts.ExtensionRange = messageGoTypes[i].(pref.ProtoMessage)
+				case "ServiceOptions":
+					descopts.Service = messageGoTypes[i].(pref.ProtoMessage)
+				case "MethodOptions":
+					descopts.Method = messageGoTypes[i].(pref.ProtoMessage)
+				}
+			}
+		}
+	}
+
+	// Process extensions.
+	if len(tb.ExtensionInfos) != len(fbOut.Extensions) {
+		panic("mismatching extension lengths")
+	}
+	var depIdx int32
+	for i := range fbOut.Extensions {
+		// For enum and message kinds, determine the referent Go type so
+		// that we can construct their constructors.
+		const listExtDeps = 2
+		var goType reflect.Type
+		switch fbOut.Extensions[i].L1.Kind {
+		case pref.EnumKind:
+			j := depIdxs.Get(tb.DependencyIndexes, listExtDeps, depIdx)
+			goType = reflect.TypeOf(tb.GoTypes[j])
+			depIdx++
+		case pref.MessageKind, pref.GroupKind:
+			j := depIdxs.Get(tb.DependencyIndexes, listExtDeps, depIdx)
+			goType = reflect.TypeOf(tb.GoTypes[j])
+			depIdx++
+		default:
+			goType = goTypeForPBKind[fbOut.Extensions[i].L1.Kind]
+		}
+		if fbOut.Extensions[i].IsList() {
+			goType = reflect.SliceOf(goType)
+		}
+
+		pimpl.InitExtensionInfo(&tb.ExtensionInfos[i], &fbOut.Extensions[i], goType)
+
+		// Register extension types.
+		if err := tb.TypeRegistry.RegisterExtension(&tb.ExtensionInfos[i]); err != nil {
+			panic(err)
+		}
+	}
+
+	return out
+}
+
+var goTypeForPBKind = map[pref.Kind]reflect.Type{
+	pref.BoolKind:     reflect.TypeOf(bool(false)),
+	pref.Int32Kind:    reflect.TypeOf(int32(0)),
+	pref.Sint32Kind:   reflect.TypeOf(int32(0)),
+	pref.Sfixed32Kind: reflect.TypeOf(int32(0)),
+	pref.Int64Kind:    reflect.TypeOf(int64(0)),
+	pref.Sint64Kind:   reflect.TypeOf(int64(0)),
+	pref.Sfixed64Kind: reflect.TypeOf(int64(0)),
+	pref.Uint32Kind:   reflect.TypeOf(uint32(0)),
+	pref.Fixed32Kind:  reflect.TypeOf(uint32(0)),
+	pref.Uint64Kind:   reflect.TypeOf(uint64(0)),
+	pref.Fixed64Kind:  reflect.TypeOf(uint64(0)),
+	pref.FloatKind:    reflect.TypeOf(float32(0)),
+	pref.DoubleKind:   reflect.TypeOf(float64(0)),
+	pref.StringKind:   reflect.TypeOf(string("")),
+	pref.BytesKind:    reflect.TypeOf([]byte(nil)),
+}
+
+type depIdxs []int32
+
+// Get retrieves the jth element of the ith sub-list.
+func (x depIdxs) Get(i, j int32) int32 {
+	return x[x[int32(len(x))-i-1]+j]
+}
+
+type (
+	resolverByIndex struct {
+		goTypes []interface{}
+		depIdxs depIdxs
+		fileRegistry
+	}
+	fileRegistry interface {
+		FindFileByPath(string) (pref.FileDescriptor, error)
+		FindDescriptorByName(pref.FullName) (pref.Descriptor, error)
+		RegisterFile(pref.FileDescriptor) error
+	}
+)
+
+func (r *resolverByIndex) FindEnumByIndex(i, j int32, es []fdesc.Enum, ms []fdesc.Message) pref.EnumDescriptor {
+	if depIdx := int(r.depIdxs.Get(i, j)); int(depIdx) < len(es)+len(ms) {
+		return &es[depIdx]
+	} else {
+		return pimpl.Export{}.EnumDescriptorOf(r.goTypes[depIdx])
+	}
+}
+
+func (r *resolverByIndex) FindMessageByIndex(i, j int32, es []fdesc.Enum, ms []fdesc.Message) pref.MessageDescriptor {
+	if depIdx := int(r.depIdxs.Get(i, j)); depIdx < len(es)+len(ms) {
+		return &ms[depIdx-len(es)]
+	} else {
+		return pimpl.Export{}.MessageDescriptorOf(r.goTypes[depIdx])
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/flags/flags.go b/vendor/google.golang.org/protobuf/internal/flags/flags.go
new file mode 100644
index 000000000..58372dd34
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/flags/flags.go
@@ -0,0 +1,24 @@
+// 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 flags provides a set of flags controlled by build tags.
+package flags
+
+// ProtoLegacy specifies whether to enable support for legacy functionality
+// such as MessageSets, weak fields, and various other obscure behavior
+// that is necessary to maintain backwards compatibility with proto1 or
+// the pre-release variants of proto2 and proto3.
+//
+// This is disabled by default unless built with the "protolegacy" tag.
+//
+// WARNING: The compatibility agreement covers nothing provided by this flag.
+// As such, functionality may suddenly be removed or changed at our discretion.
+const ProtoLegacy = protoLegacy
+
+// LazyUnmarshalExtensions specifies whether to lazily unmarshal extensions.
+//
+// Lazy extension unmarshaling validates the contents of message-valued
+// extension fields at unmarshal time, but defers creating the message
+// structure until the extension is first accessed.
+const LazyUnmarshalExtensions = ProtoLegacy
diff --git a/vendor/google.golang.org/protobuf/internal/flags/proto_legacy_disable.go b/vendor/google.golang.org/protobuf/internal/flags/proto_legacy_disable.go
new file mode 100644
index 000000000..a72995f02
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/flags/proto_legacy_disable.go
@@ -0,0 +1,9 @@
+// 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.
+
+// +build !protolegacy
+
+package flags
+
+const protoLegacy = false
diff --git a/vendor/google.golang.org/protobuf/internal/flags/proto_legacy_enable.go b/vendor/google.golang.org/protobuf/internal/flags/proto_legacy_enable.go
new file mode 100644
index 000000000..772e2f0e4
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/flags/proto_legacy_enable.go
@@ -0,0 +1,9 @@
+// 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.
+
+// +build protolegacy
+
+package flags
+
+const protoLegacy = true
diff --git a/vendor/google.golang.org/protobuf/internal/fuzz/README.md b/vendor/google.golang.org/protobuf/internal/fuzz/README.md
new file mode 100644
index 000000000..62793fe44
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/fuzz/README.md
@@ -0,0 +1,26 @@
+# Fuzzing
+
+Fuzzing support using [go-fuzz](https://github.com/dvyukov/go-fuzz).
+
+Basic operation:
+
+```sh
+$ go install github.com/dvyukov/go-fuzz/go-fuzz
+$ go install github.com/mdempsky/go114-fuzz-build
+$ cd internal/fuzz/{fuzzer}
+$ go114-fuzz-build google.golang.org/protobuf/internal/fuzz/{fuzzer}
+$ go-fuzz
+```
+
+## OSS-Fuzz
+
+Fuzzers are automatically run by
+[OSS-Fuzz](https://github.com/google/oss-fuzz).
+
+The OSS-Fuzz
+[configuration](https://github.com/google/oss-fuzz/blob/master/projects/golang-protobuf/build.sh)
+currently builds fuzzers in every directory under internal/fuzz.
+Only add fuzzers (not support packages) in this directory.
+
+Fuzzing results are available at the [OSS-Fuzz console](https://oss-fuzz.com/),
+under `golang-protobuf`.
diff --git a/vendor/google.golang.org/protobuf/internal/fuzz/jsonfuzz/corpus/e619335648415cae976b3200d5a291e8da4b4866 b/vendor/google.golang.org/protobuf/internal/fuzz/jsonfuzz/corpus/e619335648415cae976b3200d5a291e8da4b4866
new file mode 100644
index 000000000..f8b6e0069
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/fuzz/jsonfuzz/corpus/e619335648415cae976b3200d5a291e8da4b4866
@@ -0,0 +1 @@
+{"testAllTypes":{"optionalInt32":1001, "optionalInt64":"1002", "optionalUint32":1003, "optionalUint64":"1004", "optionalSint32":1005, "optionalSint64":"1006", "optionalFixed32":1007, "optionalFixed64":"1008", "optionalSfixed32":1009, "optionalSfixed64":"1010", "optionalFloat":1011.5, "optionalDouble":1012.5, "optionalBool":true, "optionalString":"string", "optionalBytes":"Ynl0ZXM=", "optionalgroup":{"a":1017}, "optionalNestedMessage":{"a":42, "corecursive":{"optionalInt32":43}}, "optionalNestedEnum":"BAR", "repeatedInt32":[1001, 2001], "repeatedInt64":["1002", "2002"], "repeatedUint32":[1003, 2003], "repeatedUint64":["1004", "2004"], "repeatedSint32":[1005, 2005], "repeatedSint64":["1006", "2006"], "repeatedFixed32":[1007, 2007], "repeatedFixed64":["1008", "2008"], "repeatedSfixed32":[1009, 2009], "repeatedSfixed64":["1010", "2010"], "repeatedFloat":[1011.5, 2011.5], "repeatedDouble":[1012.5, 2012.5], "repeatedBool":[true, false], "repeatedString":["foo", "bar"], "repeatedBytes":["Rk9P", "QkFS"], "repeatedgroup":[{"a":1017}, {}, {"a":2017}], "repeatedNestedMessage":[{"a":1}, {}, {"a":2}], "repeatedNestedEnum":["FOO", "BAR"], "mapInt32Int32":{"1056":1156, "2056":2156}, "mapInt64Int64":{"1057":"1157", "2057":"2157"}, "mapUint32Uint32":{"1058":1158, "2058":2158}, "mapUint64Uint64":{"1059":"1159", "2059":"2159"}, "mapSint32Sint32":{"1060":1160, "2060":2160}, "mapSint64Sint64":{"1061":"1161", "2061":"2161"}, "mapFixed32Fixed32":{"1062":1162, "2062":2162}, "mapFixed64Fixed64":{"1063":"1163", "2063":"2163"}, "mapSfixed32Sfixed32":{"1064":1164, "2064":2164}, "mapSfixed64Sfixed64":{"1065":"1165", "2065":"2165"}, "mapInt32Float":{"1066":1166.5, "2066":2166.5}, "mapInt32Double":{"1067":1167.5, "2067":2167.5}, "mapBoolBool":{"false":true, "true":false}, "mapStringString":{"69.1.key":"69.1.val", "69.2.key":"69.2.val"}, "mapStringBytes":{"70.1.key":"NzAuMS52YWw=", "70.2.key":"NzAuMi52YWw="}, "mapStringNestedMessage":{"71.1.key":{"a":1171}, "71.2.key":{"a":2171}}, "mapStringNestedEnum":{"73.1.key":"FOO", "73.2.key":"BAR"}, "oneofUint32":1111}}
\ No newline at end of file
diff --git a/vendor/google.golang.org/protobuf/internal/fuzz/jsonfuzz/fuzz.go b/vendor/google.golang.org/protobuf/internal/fuzz/jsonfuzz/fuzz.go
new file mode 100644
index 000000000..b99034601
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/fuzz/jsonfuzz/fuzz.go
@@ -0,0 +1,39 @@
+// Copyright 2019 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 jsonfuzz includes fuzzers for protojson.Marshal and protojson.Unmarshal.
+package jsonfuzz
+
+import (
+	"google.golang.org/protobuf/encoding/protojson"
+	"google.golang.org/protobuf/proto"
+
+	fuzzpb "google.golang.org/protobuf/internal/testprotos/fuzz"
+)
+
+// Fuzz is a fuzzer for proto.Marshal and proto.Unmarshal.
+func Fuzz(data []byte) (score int) {
+	m1 := &fuzzpb.Fuzz{}
+	if err := (protojson.UnmarshalOptions{
+		AllowPartial: true,
+	}).Unmarshal(data, m1); err != nil {
+		return 0
+	}
+	data1, err := protojson.MarshalOptions{
+		AllowPartial: true,
+	}.Marshal(m1)
+	if err != nil {
+		panic(err)
+	}
+	m2 := &fuzzpb.Fuzz{}
+	if err := (protojson.UnmarshalOptions{
+		AllowPartial: true,
+	}).Unmarshal(data1, m2); err != nil {
+		return 0
+	}
+	if !proto.Equal(m1, m2) {
+		panic("not equal")
+	}
+	return 1
+}
diff --git a/vendor/google.golang.org/protobuf/internal/fuzz/jsonfuzz/fuzz_test.go b/vendor/google.golang.org/protobuf/internal/fuzz/jsonfuzz/fuzz_test.go
new file mode 100644
index 000000000..1c81e6fd8
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/fuzz/jsonfuzz/fuzz_test.go
@@ -0,0 +1,15 @@
+// Copyright 2019 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 jsonfuzz
+
+import (
+	"testing"
+
+	"google.golang.org/protobuf/internal/fuzztest"
+)
+
+func Test(t *testing.T) {
+	fuzztest.Test(t, Fuzz)
+}
diff --git a/vendor/google.golang.org/protobuf/internal/fuzz/oss-fuzz-build.sh b/vendor/google.golang.org/protobuf/internal/fuzz/oss-fuzz-build.sh
new file mode 100644
index 000000000..0953101ef
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/fuzz/oss-fuzz-build.sh
@@ -0,0 +1,25 @@
+# Copyright 2020 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.
+
+# This script is executed by OSS-Fuzz's build to create fuzzer binaries.
+
+function compile_fuzzer {
+  path=$1
+  function=$2
+  fuzzer=$3
+
+   # Instrument all Go files relevant to this fuzzer
+  go-fuzz -tags=protolegacy -func $function -o $fuzzer.a $path
+
+   # Instrumented, compiled Go ($fuzzer.a) + fuzzing engine = fuzzer binary
+  $CXX $CXXFLAGS $LIB_FUZZING_ENGINE $fuzzer.a -lpthread -o $OUT/$fuzzer
+}
+
+for x in internal/fuzz/*; do
+  if [ -d $x/corpus ]; then
+    name=$(basename $x)
+    compile_fuzzer google.golang.org/protobuf/$x Fuzz $name
+    zip -jr $OUT/${name}_seed_corpus.zip $x/corpus
+  fi
+done
diff --git a/vendor/google.golang.org/protobuf/internal/fuzz/textfuzz/corpus/a950e4f0890f34717c5c9beffe1bd0cee33e5a2b b/vendor/google.golang.org/protobuf/internal/fuzz/textfuzz/corpus/a950e4f0890f34717c5c9beffe1bd0cee33e5a2b
new file mode 100644
index 000000000..84107ddd4
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/fuzz/textfuzz/corpus/a950e4f0890f34717c5c9beffe1bd0cee33e5a2b
@@ -0,0 +1 @@
+test_all_types:{optional_int32:1001  optional_int64:1002  optional_uint32:1003  optional_uint64:1004  optional_sint32:1005  optional_sint64:1006  optional_fixed32:1007  optional_fixed64:1008  optional_sfixed32:1009  optional_sfixed64:1010  optional_float:1011.5  optional_double:1012.5  optional_bool:true  optional_string:"string"  optional_bytes:"bytes"  OptionalGroup:{a:1017}  optional_nested_message:{a:42  corecursive:{optional_int32:43}}  optional_nested_enum:BAR  repeated_int32:1001  repeated_int32:2001  repeated_int64:1002  repeated_int64:2002  repeated_uint32:1003  repeated_uint32:2003  repeated_uint64:1004  repeated_uint64:2004  repeated_sint32:1005  repeated_sint32:2005  repeated_sint64:1006  repeated_sint64:2006  repeated_fixed32:1007  repeated_fixed32:2007  repeated_fixed64:1008  repeated_fixed64:2008  repeated_sfixed32:1009  repeated_sfixed32:2009  repeated_sfixed64:1010  repeated_sfixed64:2010  repeated_float:1011.5  repeated_float:2011.5  repeated_double:1012.5  repeated_double:2012.5  repeated_bool:true  repeated_bool:false  repeated_string:"foo"  repeated_string:"bar"  repeated_bytes:"FOO"  repeated_bytes:"BAR"  RepeatedGroup:{a:1017}  RepeatedGroup:{}  RepeatedGroup:{a:2017}  repeated_nested_message:{a:1}  repeated_nested_message:{}  repeated_nested_message:{a:2}  repeated_nested_enum:FOO  repeated_nested_enum:BAR  map_int32_int32:{key:1056  value:1156}  map_int32_int32:{key:2056  value:2156}  map_int64_int64:{key:1057  value:1157}  map_int64_int64:{key:2057  value:2157}  map_uint32_uint32:{key:1058  value:1158}  map_uint32_uint32:{key:2058  value:2158}  map_uint64_uint64:{key:1059  value:1159}  map_uint64_uint64:{key:2059  value:2159}  map_sint32_sint32:{key:1060  value:1160}  map_sint32_sint32:{key:2060  value:2160}  map_sint64_sint64:{key:1061  value:1161}  map_sint64_sint64:{key:2061  value:2161}  map_fixed32_fixed32:{key:1062  value:1162}  map_fixed32_fixed32:{key:2062  value:2162}  map_fixed64_fixed64:{key:1063  value:1163}  map_fixed64_fixed64:{key:2063  value:2163}  map_sfixed32_sfixed32:{key:1064  value:1164}  map_sfixed32_sfixed32:{key:2064  value:2164}  map_sfixed64_sfixed64:{key:1065  value:1165}  map_sfixed64_sfixed64:{key:2065  value:2165}  map_int32_float:{key:1066  value:1166.5}  map_int32_float:{key:2066  value:2166.5}  map_int32_double:{key:1067  value:1167.5}  map_int32_double:{key:2067  value:2167.5}  map_bool_bool:{key:false  value:true}  map_bool_bool:{key:true  value:false}  map_string_string:{key:"69.1.key"  value:"69.1.val"}  map_string_string:{key:"69.2.key"  value:"69.2.val"}  map_string_bytes:{key:"70.1.key"  value:"70.1.val"}  map_string_bytes:{key:"70.2.key"  value:"70.2.val"}  map_string_nested_message:{key:"71.1.key"  value:{a:1171}}  map_string_nested_message:{key:"71.2.key"  value:{a:2171}}  map_string_nested_enum:{key:"73.1.key"  value:FOO}  map_string_nested_enum:{key:"73.2.key"  value:BAR}  oneof_uint32:1111}
\ No newline at end of file
diff --git a/vendor/google.golang.org/protobuf/internal/fuzz/textfuzz/fuzz.go b/vendor/google.golang.org/protobuf/internal/fuzz/textfuzz/fuzz.go
new file mode 100644
index 000000000..242e4b635
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/fuzz/textfuzz/fuzz.go
@@ -0,0 +1,39 @@
+// Copyright 2019 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 textfuzz includes fuzzers for prototext.Marshal and prototext.Unmarshal.
+package textfuzz
+
+import (
+	"google.golang.org/protobuf/encoding/prototext"
+	"google.golang.org/protobuf/proto"
+
+	fuzzpb "google.golang.org/protobuf/internal/testprotos/fuzz"
+)
+
+// Fuzz is a fuzzer for proto.Marshal and proto.Unmarshal.
+func Fuzz(data []byte) (score int) {
+	m1 := &fuzzpb.Fuzz{}
+	if err := (prototext.UnmarshalOptions{
+		AllowPartial: true,
+	}).Unmarshal(data, m1); err != nil {
+		return 0
+	}
+	data1, err := prototext.MarshalOptions{
+		AllowPartial: true,
+	}.Marshal(m1)
+	if err != nil {
+		panic(err)
+	}
+	m2 := &fuzzpb.Fuzz{}
+	if err := (prototext.UnmarshalOptions{
+		AllowPartial: true,
+	}).Unmarshal(data1, m2); err != nil {
+		return 0
+	}
+	if !proto.Equal(m1, m2) {
+		panic("not equal")
+	}
+	return 1
+}
diff --git a/vendor/google.golang.org/protobuf/internal/fuzz/textfuzz/fuzz_test.go b/vendor/google.golang.org/protobuf/internal/fuzz/textfuzz/fuzz_test.go
new file mode 100644
index 000000000..af27f06bb
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/fuzz/textfuzz/fuzz_test.go
@@ -0,0 +1,15 @@
+// Copyright 2019 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 textfuzz
+
+import (
+	"testing"
+
+	"google.golang.org/protobuf/internal/fuzztest"
+)
+
+func Test(t *testing.T) {
+	fuzztest.Test(t, Fuzz)
+}
diff --git a/vendor/google.golang.org/protobuf/internal/fuzz/wirefuzz/corpus/20019c4ef10ebf8031c8d204bdd0ae1ec214bf90 b/vendor/google.golang.org/protobuf/internal/fuzz/wirefuzz/corpus/20019c4ef10ebf8031c8d204bdd0ae1ec214bf90
new file mode 100644
index 000000000..59e56623c
Binary files /dev/null and b/vendor/google.golang.org/protobuf/internal/fuzz/wirefuzz/corpus/20019c4ef10ebf8031c8d204bdd0ae1ec214bf90 differ
diff --git a/vendor/google.golang.org/protobuf/internal/fuzz/wirefuzz/fuzz.go b/vendor/google.golang.org/protobuf/internal/fuzz/wirefuzz/fuzz.go
new file mode 100644
index 000000000..f7a9b74a4
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/fuzz/wirefuzz/fuzz.go
@@ -0,0 +1,86 @@
+// Copyright 2019 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 wirefuzz includes a fuzzer for the wire marshaler and unmarshaler.
+package wirefuzz
+
+import (
+	"fmt"
+
+	"google.golang.org/protobuf/internal/impl"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protoregistry"
+	piface "google.golang.org/protobuf/runtime/protoiface"
+
+	fuzzpb "google.golang.org/protobuf/internal/testprotos/fuzz"
+)
+
+// Fuzz is a fuzzer for proto.Marshal and proto.Unmarshal.
+func Fuzz(data []byte) (score int) {
+	// Unmarshal and Validate should agree about the validity of the message.
+	m1 := &fuzzpb.Fuzz{}
+	mt := m1.ProtoReflect().Type()
+	_, valid := impl.Validate(mt, piface.UnmarshalInput{Buf: data})
+	if err := (proto.UnmarshalOptions{AllowPartial: true}).Unmarshal(data, m1); err != nil {
+		switch valid {
+		case impl.ValidationUnknown:
+		case impl.ValidationInvalid:
+		default:
+			panic("unmarshal error with validation status: " + valid.String())
+		}
+		return 0
+	}
+	switch valid {
+	case impl.ValidationUnknown:
+	case impl.ValidationValid:
+	default:
+		panic("unmarshal ok with validation status: " + valid.String())
+	}
+
+	// Unmarshal, Validate, and CheckInitialized should agree about initialization.
+	checkInit := proto.CheckInitialized(m1) == nil
+	methods := m1.ProtoReflect().ProtoMethods()
+	in := piface.UnmarshalInput{Message: mt.New(), Resolver: protoregistry.GlobalTypes}
+	if checkInit {
+		// If the message initialized, the both Unmarshal and Validate should
+		// report it as such. False negatives are tolerated, but have a
+		// significant impact on performance. In general, they should always
+		// properly determine initialization for any normalized message,
+		// we produce by re-marshaling the message.
+		in.Buf, _ = proto.Marshal(m1)
+		if out, _ := methods.Unmarshal(in); out.Flags&piface.UnmarshalInitialized == 0 {
+			panic("unmarshal reports initialized message as partial")
+		}
+		if out, _ := impl.Validate(mt, in); out.Flags&piface.UnmarshalInitialized == 0 {
+			panic("validate reports initialized message as partial")
+		}
+	} else {
+		// If the message is partial, then neither Unmarshal nor Validate
+		// should ever report it as such. False positives are unacceptable.
+		in.Buf = data
+		if out, _ := methods.Unmarshal(in); out.Flags&piface.UnmarshalInitialized != 0 {
+			panic("unmarshal reports partial message as initialized")
+		}
+		if out, _ := impl.Validate(mt, in); out.Flags&piface.UnmarshalInitialized != 0 {
+			panic("validate reports partial message as initialized")
+		}
+	}
+
+	// Round-trip Marshal and Unmarshal should produce the same messages.
+	data1, err := proto.MarshalOptions{AllowPartial: !checkInit}.Marshal(m1)
+	if err != nil {
+		panic(err)
+	}
+	if proto.Size(m1) != len(data1) {
+		panic(fmt.Errorf("size does not match output: %d != %d", proto.Size(m1), len(data1)))
+	}
+	m2 := &fuzzpb.Fuzz{}
+	if err := (proto.UnmarshalOptions{AllowPartial: !checkInit}).Unmarshal(data1, m2); err != nil {
+		panic(err)
+	}
+	if !proto.Equal(m1, m2) {
+		panic("not equal")
+	}
+	return 1
+}
diff --git a/vendor/google.golang.org/protobuf/internal/fuzz/wirefuzz/fuzz_test.go b/vendor/google.golang.org/protobuf/internal/fuzz/wirefuzz/fuzz_test.go
new file mode 100644
index 000000000..d4510d201
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/fuzz/wirefuzz/fuzz_test.go
@@ -0,0 +1,15 @@
+// Copyright 2019 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 wirefuzz
+
+import (
+	"testing"
+
+	"google.golang.org/protobuf/internal/fuzztest"
+)
+
+func Test(t *testing.T) {
+	fuzztest.Test(t, Fuzz)
+}
diff --git a/vendor/google.golang.org/protobuf/internal/fuzztest/fuzztest.go b/vendor/google.golang.org/protobuf/internal/fuzztest/fuzztest.go
new file mode 100644
index 000000000..2b54eb59f
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/fuzztest/fuzztest.go
@@ -0,0 +1,45 @@
+// Copyright 2019 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 fuzztest contains a common fuzzer test.
+package fuzztest
+
+import (
+	"flag"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"sort"
+	"testing"
+)
+
+var corpus = flag.String("corpus", "corpus", "directory containing the fuzzer corpus")
+
+// Test executes a fuzz function for every entry in the corpus.
+func Test(t *testing.T, fuzz func(b []byte) int) {
+	dir, err := os.Open(*corpus)
+	if err != nil {
+		t.Fatal(err)
+	}
+	infos, err := dir.Readdir(0)
+	if err != nil {
+		t.Fatal(err)
+
+	}
+	var names []string
+	for _, info := range infos {
+		names = append(names, info.Name())
+	}
+	sort.Strings(names)
+	for _, name := range names {
+		t.Run(name, func(t *testing.T) {
+			b, err := ioutil.ReadFile(filepath.Join(*corpus, name))
+			if err != nil {
+				t.Fatal(err)
+			}
+			b = b[:len(b):len(b)] // set cap to len
+			fuzz(b)
+		})
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/genname/name.go b/vendor/google.golang.org/protobuf/internal/genname/name.go
new file mode 100644
index 000000000..f45509fbd
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/genname/name.go
@@ -0,0 +1,25 @@
+// Copyright 2019 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 genname contains constants for generated names.
+package genname
+
+const (
+	State = "state"
+
+	SizeCache  = "sizeCache"
+	SizeCacheA = "XXX_sizecache"
+
+	WeakFields  = "weakFields"
+	WeakFieldsA = "XXX_weak"
+
+	UnknownFields  = "unknownFields"
+	UnknownFieldsA = "XXX_unrecognized"
+
+	ExtensionFields  = "extensionFields"
+	ExtensionFieldsA = "XXX_InternalExtensions"
+	ExtensionFieldsB = "XXX_extensions"
+
+	WeakFieldPrefix = "XXX_weak_"
+)
diff --git a/vendor/google.golang.org/protobuf/internal/impl/api_export.go b/vendor/google.golang.org/protobuf/internal/impl/api_export.go
new file mode 100644
index 000000000..4d22c9604
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/api_export.go
@@ -0,0 +1,170 @@
+// 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"
+	"reflect"
+	"strconv"
+
+	"google.golang.org/protobuf/encoding/prototext"
+	"google.golang.org/protobuf/proto"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+	piface "google.golang.org/protobuf/runtime/protoiface"
+)
+
+// Export is a zero-length named type that exists only to export a set of
+// functions that we do not want to appear in godoc.
+type Export struct{}
+
+// enum is any enum type generated by protoc-gen-go
+// and must be a named int32 type.
+type enum = interface{}
+
+// EnumOf returns the protoreflect.Enum interface over e.
+// It returns nil if e is nil.
+func (Export) EnumOf(e enum) pref.Enum {
+	switch e := e.(type) {
+	case nil:
+		return nil
+	case pref.Enum:
+		return e
+	default:
+		return legacyWrapEnum(reflect.ValueOf(e))
+	}
+}
+
+// EnumDescriptorOf returns the protoreflect.EnumDescriptor for e.
+// It returns nil if e is nil.
+func (Export) EnumDescriptorOf(e enum) pref.EnumDescriptor {
+	switch e := e.(type) {
+	case nil:
+		return nil
+	case pref.Enum:
+		return e.Descriptor()
+	default:
+		return LegacyLoadEnumDesc(reflect.TypeOf(e))
+	}
+}
+
+// EnumTypeOf returns the protoreflect.EnumType for e.
+// It returns nil if e is nil.
+func (Export) EnumTypeOf(e enum) pref.EnumType {
+	switch e := e.(type) {
+	case nil:
+		return nil
+	case pref.Enum:
+		return e.Type()
+	default:
+		return legacyLoadEnumType(reflect.TypeOf(e))
+	}
+}
+
+// EnumStringOf returns the enum value as a string, either as the name if
+// the number is resolvable, or the number formatted as a string.
+func (Export) EnumStringOf(ed pref.EnumDescriptor, n pref.EnumNumber) string {
+	ev := ed.Values().ByNumber(n)
+	if ev != nil {
+		return string(ev.Name())
+	}
+	return strconv.Itoa(int(n))
+}
+
+// message is any message type generated by protoc-gen-go
+// and must be a pointer to a named struct type.
+type message = interface{}
+
+// legacyMessageWrapper wraps a v2 message as a v1 message.
+type legacyMessageWrapper struct{ m pref.ProtoMessage }
+
+func (m legacyMessageWrapper) Reset()         { proto.Reset(m.m) }
+func (m legacyMessageWrapper) String() string { return Export{}.MessageStringOf(m.m) }
+func (m legacyMessageWrapper) ProtoMessage()  {}
+
+// ProtoMessageV1Of converts either a v1 or v2 message to a v1 message.
+// It returns nil if m is nil.
+func (Export) ProtoMessageV1Of(m message) piface.MessageV1 {
+	switch mv := m.(type) {
+	case nil:
+		return nil
+	case piface.MessageV1:
+		return mv
+	case unwrapper:
+		return Export{}.ProtoMessageV1Of(mv.protoUnwrap())
+	case pref.ProtoMessage:
+		return legacyMessageWrapper{mv}
+	default:
+		panic(fmt.Sprintf("message %T is neither a v1 or v2 Message", m))
+	}
+}
+
+func (Export) protoMessageV2Of(m message) pref.ProtoMessage {
+	switch mv := m.(type) {
+	case nil:
+		return nil
+	case pref.ProtoMessage:
+		return mv
+	case legacyMessageWrapper:
+		return mv.m
+	case piface.MessageV1:
+		return nil
+	default:
+		panic(fmt.Sprintf("message %T is neither a v1 or v2 Message", m))
+	}
+}
+
+// ProtoMessageV2Of converts either a v1 or v2 message to a v2 message.
+// It returns nil if m is nil.
+func (Export) ProtoMessageV2Of(m message) pref.ProtoMessage {
+	if m == nil {
+		return nil
+	}
+	if mv := (Export{}).protoMessageV2Of(m); mv != nil {
+		return mv
+	}
+	return legacyWrapMessage(reflect.ValueOf(m)).Interface()
+}
+
+// MessageOf returns the protoreflect.Message interface over m.
+// It returns nil if m is nil.
+func (Export) MessageOf(m message) pref.Message {
+	if m == nil {
+		return nil
+	}
+	if mv := (Export{}).protoMessageV2Of(m); mv != nil {
+		return mv.ProtoReflect()
+	}
+	return legacyWrapMessage(reflect.ValueOf(m))
+}
+
+// MessageDescriptorOf returns the protoreflect.MessageDescriptor for m.
+// It returns nil if m is nil.
+func (Export) MessageDescriptorOf(m message) pref.MessageDescriptor {
+	if m == nil {
+		return nil
+	}
+	if mv := (Export{}).protoMessageV2Of(m); mv != nil {
+		return mv.ProtoReflect().Descriptor()
+	}
+	return LegacyLoadMessageDesc(reflect.TypeOf(m))
+}
+
+// MessageTypeOf returns the protoreflect.MessageType for m.
+// It returns nil if m is nil.
+func (Export) MessageTypeOf(m message) pref.MessageType {
+	if m == nil {
+		return nil
+	}
+	if mv := (Export{}).protoMessageV2Of(m); mv != nil {
+		return mv.ProtoReflect().Type()
+	}
+	return legacyLoadMessageInfo(reflect.TypeOf(m), "")
+}
+
+// MessageStringOf returns the message value as a string,
+// which is the message serialized in the protobuf text format.
+func (Export) MessageStringOf(m pref.ProtoMessage) string {
+	return prototext.MarshalOptions{Multiline: false}.Format(m)
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/checkinit.go b/vendor/google.golang.org/protobuf/internal/impl/checkinit.go
new file mode 100644
index 000000000..b82341e57
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/checkinit.go
@@ -0,0 +1,141 @@
+// Copyright 2019 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 (
+	"sync"
+
+	"google.golang.org/protobuf/internal/errors"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+	piface "google.golang.org/protobuf/runtime/protoiface"
+)
+
+func (mi *MessageInfo) checkInitialized(in piface.CheckInitializedInput) (piface.CheckInitializedOutput, error) {
+	var p pointer
+	if ms, ok := in.Message.(*messageState); ok {
+		p = ms.pointer()
+	} else {
+		p = in.Message.(*messageReflectWrapper).pointer()
+	}
+	return piface.CheckInitializedOutput{}, mi.checkInitializedPointer(p)
+}
+
+func (mi *MessageInfo) checkInitializedPointer(p pointer) error {
+	mi.init()
+	if !mi.needsInitCheck {
+		return nil
+	}
+	if p.IsNil() {
+		for _, f := range mi.orderedCoderFields {
+			if f.isRequired {
+				return errors.RequiredNotSet(string(mi.Desc.Fields().ByNumber(f.num).FullName()))
+			}
+		}
+		return nil
+	}
+	if mi.extensionOffset.IsValid() {
+		e := p.Apply(mi.extensionOffset).Extensions()
+		if err := mi.isInitExtensions(e); err != nil {
+			return err
+		}
+	}
+	for _, f := range mi.orderedCoderFields {
+		if !f.isRequired && f.funcs.isInit == nil {
+			continue
+		}
+		fptr := p.Apply(f.offset)
+		if f.isPointer && fptr.Elem().IsNil() {
+			if f.isRequired {
+				return errors.RequiredNotSet(string(mi.Desc.Fields().ByNumber(f.num).FullName()))
+			}
+			continue
+		}
+		if f.funcs.isInit == nil {
+			continue
+		}
+		if err := f.funcs.isInit(fptr, f); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (mi *MessageInfo) isInitExtensions(ext *map[int32]ExtensionField) error {
+	if ext == nil {
+		return nil
+	}
+	for _, x := range *ext {
+		ei := getExtensionFieldInfo(x.Type())
+		if ei.funcs.isInit == nil {
+			continue
+		}
+		v := x.Value()
+		if !v.IsValid() {
+			continue
+		}
+		if err := ei.funcs.isInit(v); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+var (
+	needsInitCheckMu  sync.Mutex
+	needsInitCheckMap sync.Map
+)
+
+// needsInitCheck reports whether a message needs to be checked for partial initialization.
+//
+// It returns true if the message transitively includes any required or extension fields.
+func needsInitCheck(md pref.MessageDescriptor) bool {
+	if v, ok := needsInitCheckMap.Load(md); ok {
+		if has, ok := v.(bool); ok {
+			return has
+		}
+	}
+	needsInitCheckMu.Lock()
+	defer needsInitCheckMu.Unlock()
+	return needsInitCheckLocked(md)
+}
+
+func needsInitCheckLocked(md pref.MessageDescriptor) (has bool) {
+	if v, ok := needsInitCheckMap.Load(md); ok {
+		// If has is true, we've previously determined that this message
+		// needs init checks.
+		//
+		// If has is false, we've previously determined that it can never
+		// be uninitialized.
+		//
+		// If has is not a bool, we've just encountered a cycle in the
+		// message graph. In this case, it is safe to return false: If
+		// the message does have required fields, we'll detect them later
+		// in the graph traversal.
+		has, ok := v.(bool)
+		return ok && has
+	}
+	needsInitCheckMap.Store(md, struct{}{}) // avoid cycles while descending into this message
+	defer func() {
+		needsInitCheckMap.Store(md, has)
+	}()
+	if md.RequiredNumbers().Len() > 0 {
+		return true
+	}
+	if md.ExtensionRanges().Len() > 0 {
+		return true
+	}
+	for i := 0; i < md.Fields().Len(); i++ {
+		fd := md.Fields().Get(i)
+		// Map keys are never messages, so just consider the map value.
+		if fd.IsMap() {
+			fd = fd.MapValue()
+		}
+		fmd := fd.Message()
+		if fmd != nil && needsInitCheckLocked(fmd) {
+			return true
+		}
+	}
+	return false
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_extension.go b/vendor/google.golang.org/protobuf/internal/impl/codec_extension.go
new file mode 100644
index 000000000..08d35170b
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/codec_extension.go
@@ -0,0 +1,223 @@
+// Copyright 2019 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 (
+	"sync"
+	"sync/atomic"
+
+	"google.golang.org/protobuf/encoding/protowire"
+	"google.golang.org/protobuf/internal/errors"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+)
+
+type extensionFieldInfo struct {
+	wiretag             uint64
+	tagsize             int
+	unmarshalNeedsValue bool
+	funcs               valueCoderFuncs
+	validation          validationInfo
+}
+
+var legacyExtensionFieldInfoCache sync.Map // map[protoreflect.ExtensionType]*extensionFieldInfo
+
+func getExtensionFieldInfo(xt pref.ExtensionType) *extensionFieldInfo {
+	if xi, ok := xt.(*ExtensionInfo); ok {
+		xi.lazyInit()
+		return xi.info
+	}
+	return legacyLoadExtensionFieldInfo(xt)
+}
+
+// legacyLoadExtensionFieldInfo dynamically loads a *ExtensionInfo for xt.
+func legacyLoadExtensionFieldInfo(xt pref.ExtensionType) *extensionFieldInfo {
+	if xi, ok := legacyExtensionFieldInfoCache.Load(xt); ok {
+		return xi.(*extensionFieldInfo)
+	}
+	e := makeExtensionFieldInfo(xt.TypeDescriptor())
+	if e, ok := legacyMessageTypeCache.LoadOrStore(xt, e); ok {
+		return e.(*extensionFieldInfo)
+	}
+	return e
+}
+
+func makeExtensionFieldInfo(xd pref.ExtensionDescriptor) *extensionFieldInfo {
+	var wiretag uint64
+	if !xd.IsPacked() {
+		wiretag = protowire.EncodeTag(xd.Number(), wireTypes[xd.Kind()])
+	} else {
+		wiretag = protowire.EncodeTag(xd.Number(), protowire.BytesType)
+	}
+	e := &extensionFieldInfo{
+		wiretag: wiretag,
+		tagsize: protowire.SizeVarint(wiretag),
+		funcs:   encoderFuncsForValue(xd),
+	}
+	// Does the unmarshal function need a value passed to it?
+	// This is true for composite types, where we pass in a message, list, or map to fill in,
+	// and for enums, where we pass in a prototype value to specify the concrete enum type.
+	switch xd.Kind() {
+	case pref.MessageKind, pref.GroupKind, pref.EnumKind:
+		e.unmarshalNeedsValue = true
+	default:
+		if xd.Cardinality() == pref.Repeated {
+			e.unmarshalNeedsValue = true
+		}
+	}
+	return e
+}
+
+type lazyExtensionValue struct {
+	atomicOnce uint32 // atomically set if value is valid
+	mu         sync.Mutex
+	xi         *extensionFieldInfo
+	value      pref.Value
+	b          []byte
+	fn         func() pref.Value
+}
+
+type ExtensionField struct {
+	typ pref.ExtensionType
+
+	// value is either the value of GetValue,
+	// or a *lazyExtensionValue that then returns the value of GetValue.
+	value pref.Value
+	lazy  *lazyExtensionValue
+}
+
+func (f *ExtensionField) appendLazyBytes(xt pref.ExtensionType, xi *extensionFieldInfo, num protowire.Number, wtyp protowire.Type, b []byte) {
+	if f.lazy == nil {
+		f.lazy = &lazyExtensionValue{xi: xi}
+	}
+	f.typ = xt
+	f.lazy.xi = xi
+	f.lazy.b = protowire.AppendTag(f.lazy.b, num, wtyp)
+	f.lazy.b = append(f.lazy.b, b...)
+}
+
+func (f *ExtensionField) canLazy(xt pref.ExtensionType) bool {
+	if f.typ == nil {
+		return true
+	}
+	if f.typ == xt && f.lazy != nil && atomic.LoadUint32(&f.lazy.atomicOnce) == 0 {
+		return true
+	}
+	return false
+}
+
+func (f *ExtensionField) lazyInit() {
+	f.lazy.mu.Lock()
+	defer f.lazy.mu.Unlock()
+	if atomic.LoadUint32(&f.lazy.atomicOnce) == 1 {
+		return
+	}
+	if f.lazy.xi != nil {
+		b := f.lazy.b
+		val := f.typ.New()
+		for len(b) > 0 {
+			var tag uint64
+			if b[0] < 0x80 {
+				tag = uint64(b[0])
+				b = b[1:]
+			} else if len(b) >= 2 && b[1] < 128 {
+				tag = uint64(b[0]&0x7f) + uint64(b[1])<<7
+				b = b[2:]
+			} else {
+				var n int
+				tag, n = protowire.ConsumeVarint(b)
+				if n < 0 {
+					panic(errors.New("bad tag in lazy extension decoding"))
+				}
+				b = b[n:]
+			}
+			num := protowire.Number(tag >> 3)
+			wtyp := protowire.Type(tag & 7)
+			var out unmarshalOutput
+			var err error
+			val, out, err = f.lazy.xi.funcs.unmarshal(b, val, num, wtyp, lazyUnmarshalOptions)
+			if err != nil {
+				panic(errors.New("decode failure in lazy extension decoding: %v", err))
+			}
+			b = b[out.n:]
+		}
+		f.lazy.value = val
+	} else {
+		f.lazy.value = f.lazy.fn()
+	}
+	f.lazy.xi = nil
+	f.lazy.fn = nil
+	f.lazy.b = nil
+	atomic.StoreUint32(&f.lazy.atomicOnce, 1)
+}
+
+// Set sets the type and value of the extension field.
+// This must not be called concurrently.
+func (f *ExtensionField) Set(t pref.ExtensionType, v pref.Value) {
+	f.typ = t
+	f.value = v
+	f.lazy = nil
+}
+
+// SetLazy sets the type and a value that is to be lazily evaluated upon first use.
+// This must not be called concurrently.
+func (f *ExtensionField) SetLazy(t pref.ExtensionType, fn func() pref.Value) {
+	f.typ = t
+	f.lazy = &lazyExtensionValue{fn: fn}
+}
+
+// Value returns the value of the extension field.
+// This may be called concurrently.
+func (f *ExtensionField) Value() pref.Value {
+	if f.lazy != nil {
+		if atomic.LoadUint32(&f.lazy.atomicOnce) == 0 {
+			f.lazyInit()
+		}
+		return f.lazy.value
+	}
+	return f.value
+}
+
+// Type returns the type of the extension field.
+// This may be called concurrently.
+func (f ExtensionField) Type() pref.ExtensionType {
+	return f.typ
+}
+
+// IsSet returns whether the extension field is set.
+// This may be called concurrently.
+func (f ExtensionField) IsSet() bool {
+	return f.typ != nil
+}
+
+// IsLazy reports whether a field is lazily encoded.
+// It is exported for testing.
+func IsLazy(m pref.Message, fd pref.FieldDescriptor) bool {
+	var mi *MessageInfo
+	var p pointer
+	switch m := m.(type) {
+	case *messageState:
+		mi = m.messageInfo()
+		p = m.pointer()
+	case *messageReflectWrapper:
+		mi = m.messageInfo()
+		p = m.pointer()
+	default:
+		return false
+	}
+	xd, ok := fd.(pref.ExtensionTypeDescriptor)
+	if !ok {
+		return false
+	}
+	xt := xd.Type()
+	ext := mi.extensionMap(p)
+	if ext == nil {
+		return false
+	}
+	f, ok := (*ext)[int32(fd.Number())]
+	if !ok {
+		return false
+	}
+	return f.typ == xt && f.lazy != nil && atomic.LoadUint32(&f.lazy.atomicOnce) == 0
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_field.go b/vendor/google.golang.org/protobuf/internal/impl/codec_field.go
new file mode 100644
index 000000000..c00744d38
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/codec_field.go
@@ -0,0 +1,828 @@
+// Copyright 2019 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"
+	"reflect"
+	"sync"
+
+	"google.golang.org/protobuf/encoding/protowire"
+	"google.golang.org/protobuf/proto"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+	preg "google.golang.org/protobuf/reflect/protoregistry"
+	piface "google.golang.org/protobuf/runtime/protoiface"
+)
+
+type errInvalidUTF8 struct{}
+
+func (errInvalidUTF8) Error() string     { return "string field contains invalid UTF-8" }
+func (errInvalidUTF8) InvalidUTF8() bool { return true }
+
+// initOneofFieldCoders initializes the fast-path functions for the fields in a oneof.
+//
+// For size, marshal, and isInit operations, functions are set only on the first field
+// in the oneof. The functions are called when the oneof is non-nil, and will dispatch
+// to the appropriate field-specific function as necessary.
+//
+// The unmarshal function is set on each field individually as usual.
+func (mi *MessageInfo) initOneofFieldCoders(od pref.OneofDescriptor, si structInfo) {
+	fs := si.oneofsByName[od.Name()]
+	ft := fs.Type
+	oneofFields := make(map[reflect.Type]*coderFieldInfo)
+	needIsInit := false
+	fields := od.Fields()
+	for i, lim := 0, fields.Len(); i < lim; i++ {
+		fd := od.Fields().Get(i)
+		num := fd.Number()
+		// Make a copy of the original coderFieldInfo for use in unmarshaling.
+		//
+		// oneofFields[oneofType].funcs.marshal is the field-specific marshal function.
+		//
+		// mi.coderFields[num].marshal is set on only the first field in the oneof,
+		// and dispatches to the field-specific marshaler in oneofFields.
+		cf := *mi.coderFields[num]
+		ot := si.oneofWrappersByNumber[num]
+		cf.ft = ot.Field(0).Type
+		cf.mi, cf.funcs = fieldCoder(fd, cf.ft)
+		oneofFields[ot] = &cf
+		if cf.funcs.isInit != nil {
+			needIsInit = true
+		}
+		mi.coderFields[num].funcs.unmarshal = func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
+			var vw reflect.Value         // pointer to wrapper type
+			vi := p.AsValueOf(ft).Elem() // oneof field value of interface kind
+			if !vi.IsNil() && !vi.Elem().IsNil() && vi.Elem().Elem().Type() == ot {
+				vw = vi.Elem()
+			} else {
+				vw = reflect.New(ot)
+			}
+			out, err := cf.funcs.unmarshal(b, pointerOfValue(vw).Apply(zeroOffset), wtyp, &cf, opts)
+			if err != nil {
+				return out, err
+			}
+			vi.Set(vw)
+			return out, nil
+		}
+	}
+	getInfo := func(p pointer) (pointer, *coderFieldInfo) {
+		v := p.AsValueOf(ft).Elem()
+		if v.IsNil() {
+			return pointer{}, nil
+		}
+		v = v.Elem() // interface -> *struct
+		if v.IsNil() {
+			return pointer{}, nil
+		}
+		return pointerOfValue(v).Apply(zeroOffset), oneofFields[v.Elem().Type()]
+	}
+	first := mi.coderFields[od.Fields().Get(0).Number()]
+	first.funcs.size = func(p pointer, _ *coderFieldInfo, opts marshalOptions) int {
+		p, info := getInfo(p)
+		if info == nil || info.funcs.size == nil {
+			return 0
+		}
+		return info.funcs.size(p, info, opts)
+	}
+	first.funcs.marshal = func(b []byte, p pointer, _ *coderFieldInfo, opts marshalOptions) ([]byte, error) {
+		p, info := getInfo(p)
+		if info == nil || info.funcs.marshal == nil {
+			return b, nil
+		}
+		return info.funcs.marshal(b, p, info, opts)
+	}
+	first.funcs.merge = func(dst, src pointer, _ *coderFieldInfo, opts mergeOptions) {
+		srcp, srcinfo := getInfo(src)
+		if srcinfo == nil || srcinfo.funcs.merge == nil {
+			return
+		}
+		dstp, dstinfo := getInfo(dst)
+		if dstinfo != srcinfo {
+			dst.AsValueOf(ft).Elem().Set(reflect.New(src.AsValueOf(ft).Elem().Elem().Elem().Type()))
+			dstp = pointerOfValue(dst.AsValueOf(ft).Elem().Elem()).Apply(zeroOffset)
+		}
+		srcinfo.funcs.merge(dstp, srcp, srcinfo, opts)
+	}
+	if needIsInit {
+		first.funcs.isInit = func(p pointer, _ *coderFieldInfo) error {
+			p, info := getInfo(p)
+			if info == nil || info.funcs.isInit == nil {
+				return nil
+			}
+			return info.funcs.isInit(p, info)
+		}
+	}
+}
+
+func makeWeakMessageFieldCoder(fd pref.FieldDescriptor) pointerCoderFuncs {
+	var once sync.Once
+	var messageType pref.MessageType
+	lazyInit := func() {
+		once.Do(func() {
+			messageName := fd.Message().FullName()
+			messageType, _ = preg.GlobalTypes.FindMessageByName(messageName)
+		})
+	}
+
+	return pointerCoderFuncs{
+		size: func(p pointer, f *coderFieldInfo, opts marshalOptions) int {
+			m, ok := p.WeakFields().get(f.num)
+			if !ok {
+				return 0
+			}
+			lazyInit()
+			if messageType == nil {
+				panic(fmt.Sprintf("weak message %v is not linked in", fd.Message().FullName()))
+			}
+			return sizeMessage(m, f.tagsize, opts)
+		},
+		marshal: func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
+			m, ok := p.WeakFields().get(f.num)
+			if !ok {
+				return b, nil
+			}
+			lazyInit()
+			if messageType == nil {
+				panic(fmt.Sprintf("weak message %v is not linked in", fd.Message().FullName()))
+			}
+			return appendMessage(b, m, f.wiretag, opts)
+		},
+		unmarshal: func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
+			fs := p.WeakFields()
+			m, ok := fs.get(f.num)
+			if !ok {
+				lazyInit()
+				if messageType == nil {
+					return unmarshalOutput{}, errUnknown
+				}
+				m = messageType.New().Interface()
+				fs.set(f.num, m)
+			}
+			return consumeMessage(b, m, wtyp, opts)
+		},
+		isInit: func(p pointer, f *coderFieldInfo) error {
+			m, ok := p.WeakFields().get(f.num)
+			if !ok {
+				return nil
+			}
+			return proto.CheckInitialized(m)
+		},
+		merge: func(dst, src pointer, f *coderFieldInfo, opts mergeOptions) {
+			sm, ok := src.WeakFields().get(f.num)
+			if !ok {
+				return
+			}
+			dm, ok := dst.WeakFields().get(f.num)
+			if !ok {
+				lazyInit()
+				if messageType == nil {
+					panic(fmt.Sprintf("weak message %v is not linked in", fd.Message().FullName()))
+				}
+				dm = messageType.New().Interface()
+				dst.WeakFields().set(f.num, dm)
+			}
+			opts.Merge(dm, sm)
+		},
+	}
+}
+
+func makeMessageFieldCoder(fd pref.FieldDescriptor, ft reflect.Type) pointerCoderFuncs {
+	if mi := getMessageInfo(ft); mi != nil {
+		funcs := pointerCoderFuncs{
+			size:      sizeMessageInfo,
+			marshal:   appendMessageInfo,
+			unmarshal: consumeMessageInfo,
+			merge:     mergeMessage,
+		}
+		if needsInitCheck(mi.Desc) {
+			funcs.isInit = isInitMessageInfo
+		}
+		return funcs
+	} else {
+		return pointerCoderFuncs{
+			size: func(p pointer, f *coderFieldInfo, opts marshalOptions) int {
+				m := asMessage(p.AsValueOf(ft).Elem())
+				return sizeMessage(m, f.tagsize, opts)
+			},
+			marshal: func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
+				m := asMessage(p.AsValueOf(ft).Elem())
+				return appendMessage(b, m, f.wiretag, opts)
+			},
+			unmarshal: func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
+				mp := p.AsValueOf(ft).Elem()
+				if mp.IsNil() {
+					mp.Set(reflect.New(ft.Elem()))
+				}
+				return consumeMessage(b, asMessage(mp), wtyp, opts)
+			},
+			isInit: func(p pointer, f *coderFieldInfo) error {
+				m := asMessage(p.AsValueOf(ft).Elem())
+				return proto.CheckInitialized(m)
+			},
+			merge: mergeMessage,
+		}
+	}
+}
+
+func sizeMessageInfo(p pointer, f *coderFieldInfo, opts marshalOptions) int {
+	return protowire.SizeBytes(f.mi.sizePointer(p.Elem(), opts)) + f.tagsize
+}
+
+func appendMessageInfo(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, uint64(f.mi.sizePointer(p.Elem(), opts)))
+	return f.mi.marshalAppendPointer(b, p.Elem(), opts)
+}
+
+func consumeMessageInfo(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.BytesType {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeBytes(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	if p.Elem().IsNil() {
+		p.SetPointer(pointerOfValue(reflect.New(f.mi.GoReflectType.Elem())))
+	}
+	o, err := f.mi.unmarshalPointer(v, p.Elem(), 0, opts)
+	if err != nil {
+		return out, err
+	}
+	out.n = n
+	out.initialized = o.initialized
+	return out, nil
+}
+
+func isInitMessageInfo(p pointer, f *coderFieldInfo) error {
+	return f.mi.checkInitializedPointer(p.Elem())
+}
+
+func sizeMessage(m proto.Message, tagsize int, _ marshalOptions) int {
+	return protowire.SizeBytes(proto.Size(m)) + tagsize
+}
+
+func appendMessage(b []byte, m proto.Message, wiretag uint64, opts marshalOptions) ([]byte, error) {
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendVarint(b, uint64(proto.Size(m)))
+	return opts.Options().MarshalAppend(b, m)
+}
+
+func consumeMessage(b []byte, m proto.Message, wtyp protowire.Type, opts unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.BytesType {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeBytes(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	o, err := opts.Options().UnmarshalState(piface.UnmarshalInput{
+		Buf:     v,
+		Message: m.ProtoReflect(),
+	})
+	if err != nil {
+		return out, err
+	}
+	out.n = n
+	out.initialized = o.Flags&piface.UnmarshalInitialized != 0
+	return out, nil
+}
+
+func sizeMessageValue(v pref.Value, tagsize int, opts marshalOptions) int {
+	m := v.Message().Interface()
+	return sizeMessage(m, tagsize, opts)
+}
+
+func appendMessageValue(b []byte, v pref.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
+	m := v.Message().Interface()
+	return appendMessage(b, m, wiretag, opts)
+}
+
+func consumeMessageValue(b []byte, v pref.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (pref.Value, unmarshalOutput, error) {
+	m := v.Message().Interface()
+	out, err := consumeMessage(b, m, wtyp, opts)
+	return v, out, err
+}
+
+func isInitMessageValue(v pref.Value) error {
+	m := v.Message().Interface()
+	return proto.CheckInitialized(m)
+}
+
+var coderMessageValue = valueCoderFuncs{
+	size:      sizeMessageValue,
+	marshal:   appendMessageValue,
+	unmarshal: consumeMessageValue,
+	isInit:    isInitMessageValue,
+	merge:     mergeMessageValue,
+}
+
+func sizeGroupValue(v pref.Value, tagsize int, opts marshalOptions) int {
+	m := v.Message().Interface()
+	return sizeGroup(m, tagsize, opts)
+}
+
+func appendGroupValue(b []byte, v pref.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
+	m := v.Message().Interface()
+	return appendGroup(b, m, wiretag, opts)
+}
+
+func consumeGroupValue(b []byte, v pref.Value, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (pref.Value, unmarshalOutput, error) {
+	m := v.Message().Interface()
+	out, err := consumeGroup(b, m, num, wtyp, opts)
+	return v, out, err
+}
+
+var coderGroupValue = valueCoderFuncs{
+	size:      sizeGroupValue,
+	marshal:   appendGroupValue,
+	unmarshal: consumeGroupValue,
+	isInit:    isInitMessageValue,
+	merge:     mergeMessageValue,
+}
+
+func makeGroupFieldCoder(fd pref.FieldDescriptor, ft reflect.Type) pointerCoderFuncs {
+	num := fd.Number()
+	if mi := getMessageInfo(ft); mi != nil {
+		funcs := pointerCoderFuncs{
+			size:      sizeGroupType,
+			marshal:   appendGroupType,
+			unmarshal: consumeGroupType,
+			merge:     mergeMessage,
+		}
+		if needsInitCheck(mi.Desc) {
+			funcs.isInit = isInitMessageInfo
+		}
+		return funcs
+	} else {
+		return pointerCoderFuncs{
+			size: func(p pointer, f *coderFieldInfo, opts marshalOptions) int {
+				m := asMessage(p.AsValueOf(ft).Elem())
+				return sizeGroup(m, f.tagsize, opts)
+			},
+			marshal: func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
+				m := asMessage(p.AsValueOf(ft).Elem())
+				return appendGroup(b, m, f.wiretag, opts)
+			},
+			unmarshal: func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
+				mp := p.AsValueOf(ft).Elem()
+				if mp.IsNil() {
+					mp.Set(reflect.New(ft.Elem()))
+				}
+				return consumeGroup(b, asMessage(mp), num, wtyp, opts)
+			},
+			isInit: func(p pointer, f *coderFieldInfo) error {
+				m := asMessage(p.AsValueOf(ft).Elem())
+				return proto.CheckInitialized(m)
+			},
+			merge: mergeMessage,
+		}
+	}
+}
+
+func sizeGroupType(p pointer, f *coderFieldInfo, opts marshalOptions) int {
+	return 2*f.tagsize + f.mi.sizePointer(p.Elem(), opts)
+}
+
+func appendGroupType(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
+	b = protowire.AppendVarint(b, f.wiretag) // start group
+	b, err := f.mi.marshalAppendPointer(b, p.Elem(), opts)
+	b = protowire.AppendVarint(b, f.wiretag+1) // end group
+	return b, err
+}
+
+func consumeGroupType(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.StartGroupType {
+		return out, errUnknown
+	}
+	if p.Elem().IsNil() {
+		p.SetPointer(pointerOfValue(reflect.New(f.mi.GoReflectType.Elem())))
+	}
+	return f.mi.unmarshalPointer(b, p.Elem(), f.num, opts)
+}
+
+func sizeGroup(m proto.Message, tagsize int, _ marshalOptions) int {
+	return 2*tagsize + proto.Size(m)
+}
+
+func appendGroup(b []byte, m proto.Message, wiretag uint64, opts marshalOptions) ([]byte, error) {
+	b = protowire.AppendVarint(b, wiretag) // start group
+	b, err := opts.Options().MarshalAppend(b, m)
+	b = protowire.AppendVarint(b, wiretag+1) // end group
+	return b, err
+}
+
+func consumeGroup(b []byte, m proto.Message, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.StartGroupType {
+		return out, errUnknown
+	}
+	b, n := protowire.ConsumeGroup(num, b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	o, err := opts.Options().UnmarshalState(piface.UnmarshalInput{
+		Buf:     b,
+		Message: m.ProtoReflect(),
+	})
+	if err != nil {
+		return out, err
+	}
+	out.n = n
+	out.initialized = o.Flags&piface.UnmarshalInitialized != 0
+	return out, nil
+}
+
+func makeMessageSliceFieldCoder(fd pref.FieldDescriptor, ft reflect.Type) pointerCoderFuncs {
+	if mi := getMessageInfo(ft); mi != nil {
+		funcs := pointerCoderFuncs{
+			size:      sizeMessageSliceInfo,
+			marshal:   appendMessageSliceInfo,
+			unmarshal: consumeMessageSliceInfo,
+			merge:     mergeMessageSlice,
+		}
+		if needsInitCheck(mi.Desc) {
+			funcs.isInit = isInitMessageSliceInfo
+		}
+		return funcs
+	}
+	return pointerCoderFuncs{
+		size: func(p pointer, f *coderFieldInfo, opts marshalOptions) int {
+			return sizeMessageSlice(p, ft, f.tagsize, opts)
+		},
+		marshal: func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
+			return appendMessageSlice(b, p, f.wiretag, ft, opts)
+		},
+		unmarshal: func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
+			return consumeMessageSlice(b, p, ft, wtyp, opts)
+		},
+		isInit: func(p pointer, f *coderFieldInfo) error {
+			return isInitMessageSlice(p, ft)
+		},
+		merge: mergeMessageSlice,
+	}
+}
+
+func sizeMessageSliceInfo(p pointer, f *coderFieldInfo, opts marshalOptions) int {
+	s := p.PointerSlice()
+	n := 0
+	for _, v := range s {
+		n += protowire.SizeBytes(f.mi.sizePointer(v, opts)) + f.tagsize
+	}
+	return n
+}
+
+func appendMessageSliceInfo(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
+	s := p.PointerSlice()
+	var err error
+	for _, v := range s {
+		b = protowire.AppendVarint(b, f.wiretag)
+		siz := f.mi.sizePointer(v, opts)
+		b = protowire.AppendVarint(b, uint64(siz))
+		b, err = f.mi.marshalAppendPointer(b, v, opts)
+		if err != nil {
+			return b, err
+		}
+	}
+	return b, nil
+}
+
+func consumeMessageSliceInfo(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.BytesType {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeBytes(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	m := reflect.New(f.mi.GoReflectType.Elem()).Interface()
+	mp := pointerOfIface(m)
+	o, err := f.mi.unmarshalPointer(v, mp, 0, opts)
+	if err != nil {
+		return out, err
+	}
+	p.AppendPointerSlice(mp)
+	out.n = n
+	out.initialized = o.initialized
+	return out, nil
+}
+
+func isInitMessageSliceInfo(p pointer, f *coderFieldInfo) error {
+	s := p.PointerSlice()
+	for _, v := range s {
+		if err := f.mi.checkInitializedPointer(v); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func sizeMessageSlice(p pointer, goType reflect.Type, tagsize int, _ marshalOptions) int {
+	s := p.PointerSlice()
+	n := 0
+	for _, v := range s {
+		m := asMessage(v.AsValueOf(goType.Elem()))
+		n += protowire.SizeBytes(proto.Size(m)) + tagsize
+	}
+	return n
+}
+
+func appendMessageSlice(b []byte, p pointer, wiretag uint64, goType reflect.Type, opts marshalOptions) ([]byte, error) {
+	s := p.PointerSlice()
+	var err error
+	for _, v := range s {
+		m := asMessage(v.AsValueOf(goType.Elem()))
+		b = protowire.AppendVarint(b, wiretag)
+		siz := proto.Size(m)
+		b = protowire.AppendVarint(b, uint64(siz))
+		b, err = opts.Options().MarshalAppend(b, m)
+		if err != nil {
+			return b, err
+		}
+	}
+	return b, nil
+}
+
+func consumeMessageSlice(b []byte, p pointer, goType reflect.Type, wtyp protowire.Type, opts unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.BytesType {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeBytes(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	mp := reflect.New(goType.Elem())
+	o, err := opts.Options().UnmarshalState(piface.UnmarshalInput{
+		Buf:     v,
+		Message: asMessage(mp).ProtoReflect(),
+	})
+	if err != nil {
+		return out, err
+	}
+	p.AppendPointerSlice(pointerOfValue(mp))
+	out.n = n
+	out.initialized = o.Flags&piface.UnmarshalInitialized != 0
+	return out, nil
+}
+
+func isInitMessageSlice(p pointer, goType reflect.Type) error {
+	s := p.PointerSlice()
+	for _, v := range s {
+		m := asMessage(v.AsValueOf(goType.Elem()))
+		if err := proto.CheckInitialized(m); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Slices of messages
+
+func sizeMessageSliceValue(listv pref.Value, tagsize int, opts marshalOptions) int {
+	list := listv.List()
+	n := 0
+	for i, llen := 0, list.Len(); i < llen; i++ {
+		m := list.Get(i).Message().Interface()
+		n += protowire.SizeBytes(proto.Size(m)) + tagsize
+	}
+	return n
+}
+
+func appendMessageSliceValue(b []byte, listv pref.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
+	list := listv.List()
+	mopts := opts.Options()
+	for i, llen := 0, list.Len(); i < llen; i++ {
+		m := list.Get(i).Message().Interface()
+		b = protowire.AppendVarint(b, wiretag)
+		siz := proto.Size(m)
+		b = protowire.AppendVarint(b, uint64(siz))
+		var err error
+		b, err = mopts.MarshalAppend(b, m)
+		if err != nil {
+			return b, err
+		}
+	}
+	return b, nil
+}
+
+func consumeMessageSliceValue(b []byte, listv pref.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ pref.Value, out unmarshalOutput, err error) {
+	list := listv.List()
+	if wtyp != protowire.BytesType {
+		return pref.Value{}, out, errUnknown
+	}
+	v, n := protowire.ConsumeBytes(b)
+	if n < 0 {
+		return pref.Value{}, out, protowire.ParseError(n)
+	}
+	m := list.NewElement()
+	o, err := opts.Options().UnmarshalState(piface.UnmarshalInput{
+		Buf:     v,
+		Message: m.Message(),
+	})
+	if err != nil {
+		return pref.Value{}, out, err
+	}
+	list.Append(m)
+	out.n = n
+	out.initialized = o.Flags&piface.UnmarshalInitialized != 0
+	return listv, out, nil
+}
+
+func isInitMessageSliceValue(listv pref.Value) error {
+	list := listv.List()
+	for i, llen := 0, list.Len(); i < llen; i++ {
+		m := list.Get(i).Message().Interface()
+		if err := proto.CheckInitialized(m); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+var coderMessageSliceValue = valueCoderFuncs{
+	size:      sizeMessageSliceValue,
+	marshal:   appendMessageSliceValue,
+	unmarshal: consumeMessageSliceValue,
+	isInit:    isInitMessageSliceValue,
+	merge:     mergeMessageListValue,
+}
+
+func sizeGroupSliceValue(listv pref.Value, tagsize int, opts marshalOptions) int {
+	list := listv.List()
+	n := 0
+	for i, llen := 0, list.Len(); i < llen; i++ {
+		m := list.Get(i).Message().Interface()
+		n += 2*tagsize + proto.Size(m)
+	}
+	return n
+}
+
+func appendGroupSliceValue(b []byte, listv pref.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
+	list := listv.List()
+	mopts := opts.Options()
+	for i, llen := 0, list.Len(); i < llen; i++ {
+		m := list.Get(i).Message().Interface()
+		b = protowire.AppendVarint(b, wiretag) // start group
+		var err error
+		b, err = mopts.MarshalAppend(b, m)
+		if err != nil {
+			return b, err
+		}
+		b = protowire.AppendVarint(b, wiretag+1) // end group
+	}
+	return b, nil
+}
+
+func consumeGroupSliceValue(b []byte, listv pref.Value, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ pref.Value, out unmarshalOutput, err error) {
+	list := listv.List()
+	if wtyp != protowire.StartGroupType {
+		return pref.Value{}, out, errUnknown
+	}
+	b, n := protowire.ConsumeGroup(num, b)
+	if n < 0 {
+		return pref.Value{}, out, protowire.ParseError(n)
+	}
+	m := list.NewElement()
+	o, err := opts.Options().UnmarshalState(piface.UnmarshalInput{
+		Buf:     b,
+		Message: m.Message(),
+	})
+	if err != nil {
+		return pref.Value{}, out, err
+	}
+	list.Append(m)
+	out.n = n
+	out.initialized = o.Flags&piface.UnmarshalInitialized != 0
+	return listv, out, nil
+}
+
+var coderGroupSliceValue = valueCoderFuncs{
+	size:      sizeGroupSliceValue,
+	marshal:   appendGroupSliceValue,
+	unmarshal: consumeGroupSliceValue,
+	isInit:    isInitMessageSliceValue,
+	merge:     mergeMessageListValue,
+}
+
+func makeGroupSliceFieldCoder(fd pref.FieldDescriptor, ft reflect.Type) pointerCoderFuncs {
+	num := fd.Number()
+	if mi := getMessageInfo(ft); mi != nil {
+		funcs := pointerCoderFuncs{
+			size:      sizeGroupSliceInfo,
+			marshal:   appendGroupSliceInfo,
+			unmarshal: consumeGroupSliceInfo,
+			merge:     mergeMessageSlice,
+		}
+		if needsInitCheck(mi.Desc) {
+			funcs.isInit = isInitMessageSliceInfo
+		}
+		return funcs
+	}
+	return pointerCoderFuncs{
+		size: func(p pointer, f *coderFieldInfo, opts marshalOptions) int {
+			return sizeGroupSlice(p, ft, f.tagsize, opts)
+		},
+		marshal: func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
+			return appendGroupSlice(b, p, f.wiretag, ft, opts)
+		},
+		unmarshal: func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
+			return consumeGroupSlice(b, p, num, wtyp, ft, opts)
+		},
+		isInit: func(p pointer, f *coderFieldInfo) error {
+			return isInitMessageSlice(p, ft)
+		},
+		merge: mergeMessageSlice,
+	}
+}
+
+func sizeGroupSlice(p pointer, messageType reflect.Type, tagsize int, _ marshalOptions) int {
+	s := p.PointerSlice()
+	n := 0
+	for _, v := range s {
+		m := asMessage(v.AsValueOf(messageType.Elem()))
+		n += 2*tagsize + proto.Size(m)
+	}
+	return n
+}
+
+func appendGroupSlice(b []byte, p pointer, wiretag uint64, messageType reflect.Type, opts marshalOptions) ([]byte, error) {
+	s := p.PointerSlice()
+	var err error
+	for _, v := range s {
+		m := asMessage(v.AsValueOf(messageType.Elem()))
+		b = protowire.AppendVarint(b, wiretag) // start group
+		b, err = opts.Options().MarshalAppend(b, m)
+		if err != nil {
+			return b, err
+		}
+		b = protowire.AppendVarint(b, wiretag+1) // end group
+	}
+	return b, nil
+}
+
+func consumeGroupSlice(b []byte, p pointer, num protowire.Number, wtyp protowire.Type, goType reflect.Type, opts unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.StartGroupType {
+		return out, errUnknown
+	}
+	b, n := protowire.ConsumeGroup(num, b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	mp := reflect.New(goType.Elem())
+	o, err := opts.Options().UnmarshalState(piface.UnmarshalInput{
+		Buf:     b,
+		Message: asMessage(mp).ProtoReflect(),
+	})
+	if err != nil {
+		return out, err
+	}
+	p.AppendPointerSlice(pointerOfValue(mp))
+	out.n = n
+	out.initialized = o.Flags&piface.UnmarshalInitialized != 0
+	return out, nil
+}
+
+func sizeGroupSliceInfo(p pointer, f *coderFieldInfo, opts marshalOptions) int {
+	s := p.PointerSlice()
+	n := 0
+	for _, v := range s {
+		n += 2*f.tagsize + f.mi.sizePointer(v, opts)
+	}
+	return n
+}
+
+func appendGroupSliceInfo(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
+	s := p.PointerSlice()
+	var err error
+	for _, v := range s {
+		b = protowire.AppendVarint(b, f.wiretag) // start group
+		b, err = f.mi.marshalAppendPointer(b, v, opts)
+		if err != nil {
+			return b, err
+		}
+		b = protowire.AppendVarint(b, f.wiretag+1) // end group
+	}
+	return b, nil
+}
+
+func consumeGroupSliceInfo(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
+	if wtyp != protowire.StartGroupType {
+		return unmarshalOutput{}, errUnknown
+	}
+	m := reflect.New(f.mi.GoReflectType.Elem()).Interface()
+	mp := pointerOfIface(m)
+	out, err := f.mi.unmarshalPointer(b, mp, f.num, opts)
+	if err != nil {
+		return out, err
+	}
+	p.AppendPointerSlice(mp)
+	return out, nil
+}
+
+func asMessage(v reflect.Value) pref.ProtoMessage {
+	if m, ok := v.Interface().(pref.ProtoMessage); ok {
+		return m
+	}
+	return legacyWrapMessage(v).Interface()
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_gen.go b/vendor/google.golang.org/protobuf/internal/impl/codec_gen.go
new file mode 100644
index 000000000..ff198d0a1
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/codec_gen.go
@@ -0,0 +1,5637 @@
+// 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.
+
+// Code generated by generate-types. DO NOT EDIT.
+
+package impl
+
+import (
+	"math"
+	"unicode/utf8"
+
+	"google.golang.org/protobuf/encoding/protowire"
+	"google.golang.org/protobuf/reflect/protoreflect"
+)
+
+// sizeBool returns the size of wire encoding a bool pointer as a Bool.
+func sizeBool(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	v := *p.Bool()
+	return f.tagsize + protowire.SizeVarint(protowire.EncodeBool(v))
+}
+
+// appendBool wire encodes a bool pointer as a Bool.
+func appendBool(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.Bool()
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, protowire.EncodeBool(v))
+	return b, nil
+}
+
+// consumeBool wire decodes a bool pointer as a Bool.
+func consumeBool(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
+		return out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	*p.Bool() = protowire.DecodeBool(v)
+	out.n = n
+	return out, nil
+}
+
+var coderBool = pointerCoderFuncs{
+	size:      sizeBool,
+	marshal:   appendBool,
+	unmarshal: consumeBool,
+	merge:     mergeBool,
+}
+
+// sizeBoolNoZero returns the size of wire encoding a bool pointer as a Bool.
+// The zero value is not encoded.
+func sizeBoolNoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	v := *p.Bool()
+	if v == false {
+		return 0
+	}
+	return f.tagsize + protowire.SizeVarint(protowire.EncodeBool(v))
+}
+
+// appendBoolNoZero wire encodes a bool pointer as a Bool.
+// The zero value is not encoded.
+func appendBoolNoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.Bool()
+	if v == false {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, protowire.EncodeBool(v))
+	return b, nil
+}
+
+var coderBoolNoZero = pointerCoderFuncs{
+	size:      sizeBoolNoZero,
+	marshal:   appendBoolNoZero,
+	unmarshal: consumeBool,
+	merge:     mergeBoolNoZero,
+}
+
+// sizeBoolPtr returns the size of wire encoding a *bool pointer as a Bool.
+// It panics if the pointer is nil.
+func sizeBoolPtr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	v := **p.BoolPtr()
+	return f.tagsize + protowire.SizeVarint(protowire.EncodeBool(v))
+}
+
+// appendBoolPtr wire encodes a *bool pointer as a Bool.
+// It panics if the pointer is nil.
+func appendBoolPtr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := **p.BoolPtr()
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, protowire.EncodeBool(v))
+	return b, nil
+}
+
+// consumeBoolPtr wire decodes a *bool pointer as a Bool.
+func consumeBoolPtr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
+		return out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	vp := p.BoolPtr()
+	if *vp == nil {
+		*vp = new(bool)
+	}
+	**vp = protowire.DecodeBool(v)
+	out.n = n
+	return out, nil
+}
+
+var coderBoolPtr = pointerCoderFuncs{
+	size:      sizeBoolPtr,
+	marshal:   appendBoolPtr,
+	unmarshal: consumeBoolPtr,
+	merge:     mergeBoolPtr,
+}
+
+// sizeBoolSlice returns the size of wire encoding a []bool pointer as a repeated Bool.
+func sizeBoolSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	s := *p.BoolSlice()
+	for _, v := range s {
+		size += f.tagsize + protowire.SizeVarint(protowire.EncodeBool(v))
+	}
+	return size
+}
+
+// appendBoolSlice encodes a []bool pointer as a repeated Bool.
+func appendBoolSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	s := *p.BoolSlice()
+	for _, v := range s {
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendVarint(b, protowire.EncodeBool(v))
+	}
+	return b, nil
+}
+
+// consumeBoolSlice wire decodes a []bool pointer as a repeated Bool.
+func consumeBoolSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	sp := p.BoolSlice()
+	if wtyp == protowire.BytesType {
+		s := *sp
+		b, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return out, protowire.ParseError(n)
+		}
+		for len(b) > 0 {
+			var v uint64
+			var n int
+			if len(b) >= 1 && b[0] < 0x80 {
+				v = uint64(b[0])
+				n = 1
+			} else if len(b) >= 2 && b[1] < 128 {
+				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+				n = 2
+			} else {
+				v, n = protowire.ConsumeVarint(b)
+			}
+			if n < 0 {
+				return out, protowire.ParseError(n)
+			}
+			s = append(s, protowire.DecodeBool(v))
+			b = b[n:]
+		}
+		*sp = s
+		out.n = n
+		return out, nil
+	}
+	if wtyp != protowire.VarintType {
+		return out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	*sp = append(*sp, protowire.DecodeBool(v))
+	out.n = n
+	return out, nil
+}
+
+var coderBoolSlice = pointerCoderFuncs{
+	size:      sizeBoolSlice,
+	marshal:   appendBoolSlice,
+	unmarshal: consumeBoolSlice,
+	merge:     mergeBoolSlice,
+}
+
+// sizeBoolPackedSlice returns the size of wire encoding a []bool pointer as a packed repeated Bool.
+func sizeBoolPackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	s := *p.BoolSlice()
+	if len(s) == 0 {
+		return 0
+	}
+	n := 0
+	for _, v := range s {
+		n += protowire.SizeVarint(protowire.EncodeBool(v))
+	}
+	return f.tagsize + protowire.SizeBytes(n)
+}
+
+// appendBoolPackedSlice encodes a []bool pointer as a packed repeated Bool.
+func appendBoolPackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	s := *p.BoolSlice()
+	if len(s) == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, f.wiretag)
+	n := 0
+	for _, v := range s {
+		n += protowire.SizeVarint(protowire.EncodeBool(v))
+	}
+	b = protowire.AppendVarint(b, uint64(n))
+	for _, v := range s {
+		b = protowire.AppendVarint(b, protowire.EncodeBool(v))
+	}
+	return b, nil
+}
+
+var coderBoolPackedSlice = pointerCoderFuncs{
+	size:      sizeBoolPackedSlice,
+	marshal:   appendBoolPackedSlice,
+	unmarshal: consumeBoolSlice,
+	merge:     mergeBoolSlice,
+}
+
+// sizeBoolValue returns the size of wire encoding a bool value as a Bool.
+func sizeBoolValue(v protoreflect.Value, tagsize int, _ marshalOptions) int {
+	return tagsize + protowire.SizeVarint(protowire.EncodeBool(v.Bool()))
+}
+
+// appendBoolValue encodes a bool value as a Bool.
+func appendBoolValue(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendVarint(b, protowire.EncodeBool(v.Bool()))
+	return b, nil
+}
+
+// consumeBoolValue decodes a bool value as a Bool.
+func consumeBoolValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	out.n = n
+	return protoreflect.ValueOfBool(protowire.DecodeBool(v)), out, nil
+}
+
+var coderBoolValue = valueCoderFuncs{
+	size:      sizeBoolValue,
+	marshal:   appendBoolValue,
+	unmarshal: consumeBoolValue,
+	merge:     mergeScalarValue,
+}
+
+// sizeBoolSliceValue returns the size of wire encoding a []bool value as a repeated Bool.
+func sizeBoolSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
+	list := listv.List()
+	for i, llen := 0, list.Len(); i < llen; i++ {
+		v := list.Get(i)
+		size += tagsize + protowire.SizeVarint(protowire.EncodeBool(v.Bool()))
+	}
+	return size
+}
+
+// appendBoolSliceValue encodes a []bool value as a repeated Bool.
+func appendBoolSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	list := listv.List()
+	for i, llen := 0, list.Len(); i < llen; i++ {
+		v := list.Get(i)
+		b = protowire.AppendVarint(b, wiretag)
+		b = protowire.AppendVarint(b, protowire.EncodeBool(v.Bool()))
+	}
+	return b, nil
+}
+
+// consumeBoolSliceValue wire decodes a []bool value as a repeated Bool.
+func consumeBoolSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	list := listv.List()
+	if wtyp == protowire.BytesType {
+		b, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return protoreflect.Value{}, out, protowire.ParseError(n)
+		}
+		for len(b) > 0 {
+			var v uint64
+			var n int
+			if len(b) >= 1 && b[0] < 0x80 {
+				v = uint64(b[0])
+				n = 1
+			} else if len(b) >= 2 && b[1] < 128 {
+				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+				n = 2
+			} else {
+				v, n = protowire.ConsumeVarint(b)
+			}
+			if n < 0 {
+				return protoreflect.Value{}, out, protowire.ParseError(n)
+			}
+			list.Append(protoreflect.ValueOfBool(protowire.DecodeBool(v)))
+			b = b[n:]
+		}
+		out.n = n
+		return listv, out, nil
+	}
+	if wtyp != protowire.VarintType {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	list.Append(protoreflect.ValueOfBool(protowire.DecodeBool(v)))
+	out.n = n
+	return listv, out, nil
+}
+
+var coderBoolSliceValue = valueCoderFuncs{
+	size:      sizeBoolSliceValue,
+	marshal:   appendBoolSliceValue,
+	unmarshal: consumeBoolSliceValue,
+	merge:     mergeListValue,
+}
+
+// sizeBoolPackedSliceValue returns the size of wire encoding a []bool value as a packed repeated Bool.
+func sizeBoolPackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
+	list := listv.List()
+	llen := list.Len()
+	if llen == 0 {
+		return 0
+	}
+	n := 0
+	for i, llen := 0, llen; i < llen; i++ {
+		v := list.Get(i)
+		n += protowire.SizeVarint(protowire.EncodeBool(v.Bool()))
+	}
+	return tagsize + protowire.SizeBytes(n)
+}
+
+// appendBoolPackedSliceValue encodes a []bool value as a packed repeated Bool.
+func appendBoolPackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	list := listv.List()
+	llen := list.Len()
+	if llen == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, wiretag)
+	n := 0
+	for i := 0; i < llen; i++ {
+		v := list.Get(i)
+		n += protowire.SizeVarint(protowire.EncodeBool(v.Bool()))
+	}
+	b = protowire.AppendVarint(b, uint64(n))
+	for i := 0; i < llen; i++ {
+		v := list.Get(i)
+		b = protowire.AppendVarint(b, protowire.EncodeBool(v.Bool()))
+	}
+	return b, nil
+}
+
+var coderBoolPackedSliceValue = valueCoderFuncs{
+	size:      sizeBoolPackedSliceValue,
+	marshal:   appendBoolPackedSliceValue,
+	unmarshal: consumeBoolSliceValue,
+	merge:     mergeListValue,
+}
+
+// sizeEnumValue returns the size of wire encoding a  value as a Enum.
+func sizeEnumValue(v protoreflect.Value, tagsize int, _ marshalOptions) int {
+	return tagsize + protowire.SizeVarint(uint64(v.Enum()))
+}
+
+// appendEnumValue encodes a  value as a Enum.
+func appendEnumValue(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendVarint(b, uint64(v.Enum()))
+	return b, nil
+}
+
+// consumeEnumValue decodes a  value as a Enum.
+func consumeEnumValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	out.n = n
+	return protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)), out, nil
+}
+
+var coderEnumValue = valueCoderFuncs{
+	size:      sizeEnumValue,
+	marshal:   appendEnumValue,
+	unmarshal: consumeEnumValue,
+	merge:     mergeScalarValue,
+}
+
+// sizeEnumSliceValue returns the size of wire encoding a [] value as a repeated Enum.
+func sizeEnumSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
+	list := listv.List()
+	for i, llen := 0, list.Len(); i < llen; i++ {
+		v := list.Get(i)
+		size += tagsize + protowire.SizeVarint(uint64(v.Enum()))
+	}
+	return size
+}
+
+// appendEnumSliceValue encodes a [] value as a repeated Enum.
+func appendEnumSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	list := listv.List()
+	for i, llen := 0, list.Len(); i < llen; i++ {
+		v := list.Get(i)
+		b = protowire.AppendVarint(b, wiretag)
+		b = protowire.AppendVarint(b, uint64(v.Enum()))
+	}
+	return b, nil
+}
+
+// consumeEnumSliceValue wire decodes a [] value as a repeated Enum.
+func consumeEnumSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	list := listv.List()
+	if wtyp == protowire.BytesType {
+		b, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return protoreflect.Value{}, out, protowire.ParseError(n)
+		}
+		for len(b) > 0 {
+			var v uint64
+			var n int
+			if len(b) >= 1 && b[0] < 0x80 {
+				v = uint64(b[0])
+				n = 1
+			} else if len(b) >= 2 && b[1] < 128 {
+				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+				n = 2
+			} else {
+				v, n = protowire.ConsumeVarint(b)
+			}
+			if n < 0 {
+				return protoreflect.Value{}, out, protowire.ParseError(n)
+			}
+			list.Append(protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)))
+			b = b[n:]
+		}
+		out.n = n
+		return listv, out, nil
+	}
+	if wtyp != protowire.VarintType {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	list.Append(protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)))
+	out.n = n
+	return listv, out, nil
+}
+
+var coderEnumSliceValue = valueCoderFuncs{
+	size:      sizeEnumSliceValue,
+	marshal:   appendEnumSliceValue,
+	unmarshal: consumeEnumSliceValue,
+	merge:     mergeListValue,
+}
+
+// sizeEnumPackedSliceValue returns the size of wire encoding a [] value as a packed repeated Enum.
+func sizeEnumPackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
+	list := listv.List()
+	llen := list.Len()
+	if llen == 0 {
+		return 0
+	}
+	n := 0
+	for i, llen := 0, llen; i < llen; i++ {
+		v := list.Get(i)
+		n += protowire.SizeVarint(uint64(v.Enum()))
+	}
+	return tagsize + protowire.SizeBytes(n)
+}
+
+// appendEnumPackedSliceValue encodes a [] value as a packed repeated Enum.
+func appendEnumPackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	list := listv.List()
+	llen := list.Len()
+	if llen == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, wiretag)
+	n := 0
+	for i := 0; i < llen; i++ {
+		v := list.Get(i)
+		n += protowire.SizeVarint(uint64(v.Enum()))
+	}
+	b = protowire.AppendVarint(b, uint64(n))
+	for i := 0; i < llen; i++ {
+		v := list.Get(i)
+		b = protowire.AppendVarint(b, uint64(v.Enum()))
+	}
+	return b, nil
+}
+
+var coderEnumPackedSliceValue = valueCoderFuncs{
+	size:      sizeEnumPackedSliceValue,
+	marshal:   appendEnumPackedSliceValue,
+	unmarshal: consumeEnumSliceValue,
+	merge:     mergeListValue,
+}
+
+// sizeInt32 returns the size of wire encoding a int32 pointer as a Int32.
+func sizeInt32(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	v := *p.Int32()
+	return f.tagsize + protowire.SizeVarint(uint64(v))
+}
+
+// appendInt32 wire encodes a int32 pointer as a Int32.
+func appendInt32(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.Int32()
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, uint64(v))
+	return b, nil
+}
+
+// consumeInt32 wire decodes a int32 pointer as a Int32.
+func consumeInt32(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
+		return out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	*p.Int32() = int32(v)
+	out.n = n
+	return out, nil
+}
+
+var coderInt32 = pointerCoderFuncs{
+	size:      sizeInt32,
+	marshal:   appendInt32,
+	unmarshal: consumeInt32,
+	merge:     mergeInt32,
+}
+
+// sizeInt32NoZero returns the size of wire encoding a int32 pointer as a Int32.
+// The zero value is not encoded.
+func sizeInt32NoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	v := *p.Int32()
+	if v == 0 {
+		return 0
+	}
+	return f.tagsize + protowire.SizeVarint(uint64(v))
+}
+
+// appendInt32NoZero wire encodes a int32 pointer as a Int32.
+// The zero value is not encoded.
+func appendInt32NoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.Int32()
+	if v == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, uint64(v))
+	return b, nil
+}
+
+var coderInt32NoZero = pointerCoderFuncs{
+	size:      sizeInt32NoZero,
+	marshal:   appendInt32NoZero,
+	unmarshal: consumeInt32,
+	merge:     mergeInt32NoZero,
+}
+
+// sizeInt32Ptr returns the size of wire encoding a *int32 pointer as a Int32.
+// It panics if the pointer is nil.
+func sizeInt32Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	v := **p.Int32Ptr()
+	return f.tagsize + protowire.SizeVarint(uint64(v))
+}
+
+// appendInt32Ptr wire encodes a *int32 pointer as a Int32.
+// It panics if the pointer is nil.
+func appendInt32Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := **p.Int32Ptr()
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, uint64(v))
+	return b, nil
+}
+
+// consumeInt32Ptr wire decodes a *int32 pointer as a Int32.
+func consumeInt32Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
+		return out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	vp := p.Int32Ptr()
+	if *vp == nil {
+		*vp = new(int32)
+	}
+	**vp = int32(v)
+	out.n = n
+	return out, nil
+}
+
+var coderInt32Ptr = pointerCoderFuncs{
+	size:      sizeInt32Ptr,
+	marshal:   appendInt32Ptr,
+	unmarshal: consumeInt32Ptr,
+	merge:     mergeInt32Ptr,
+}
+
+// sizeInt32Slice returns the size of wire encoding a []int32 pointer as a repeated Int32.
+func sizeInt32Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	s := *p.Int32Slice()
+	for _, v := range s {
+		size += f.tagsize + protowire.SizeVarint(uint64(v))
+	}
+	return size
+}
+
+// appendInt32Slice encodes a []int32 pointer as a repeated Int32.
+func appendInt32Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	s := *p.Int32Slice()
+	for _, v := range s {
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendVarint(b, uint64(v))
+	}
+	return b, nil
+}
+
+// consumeInt32Slice wire decodes a []int32 pointer as a repeated Int32.
+func consumeInt32Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	sp := p.Int32Slice()
+	if wtyp == protowire.BytesType {
+		s := *sp
+		b, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return out, protowire.ParseError(n)
+		}
+		for len(b) > 0 {
+			var v uint64
+			var n int
+			if len(b) >= 1 && b[0] < 0x80 {
+				v = uint64(b[0])
+				n = 1
+			} else if len(b) >= 2 && b[1] < 128 {
+				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+				n = 2
+			} else {
+				v, n = protowire.ConsumeVarint(b)
+			}
+			if n < 0 {
+				return out, protowire.ParseError(n)
+			}
+			s = append(s, int32(v))
+			b = b[n:]
+		}
+		*sp = s
+		out.n = n
+		return out, nil
+	}
+	if wtyp != protowire.VarintType {
+		return out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	*sp = append(*sp, int32(v))
+	out.n = n
+	return out, nil
+}
+
+var coderInt32Slice = pointerCoderFuncs{
+	size:      sizeInt32Slice,
+	marshal:   appendInt32Slice,
+	unmarshal: consumeInt32Slice,
+	merge:     mergeInt32Slice,
+}
+
+// sizeInt32PackedSlice returns the size of wire encoding a []int32 pointer as a packed repeated Int32.
+func sizeInt32PackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	s := *p.Int32Slice()
+	if len(s) == 0 {
+		return 0
+	}
+	n := 0
+	for _, v := range s {
+		n += protowire.SizeVarint(uint64(v))
+	}
+	return f.tagsize + protowire.SizeBytes(n)
+}
+
+// appendInt32PackedSlice encodes a []int32 pointer as a packed repeated Int32.
+func appendInt32PackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	s := *p.Int32Slice()
+	if len(s) == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, f.wiretag)
+	n := 0
+	for _, v := range s {
+		n += protowire.SizeVarint(uint64(v))
+	}
+	b = protowire.AppendVarint(b, uint64(n))
+	for _, v := range s {
+		b = protowire.AppendVarint(b, uint64(v))
+	}
+	return b, nil
+}
+
+var coderInt32PackedSlice = pointerCoderFuncs{
+	size:      sizeInt32PackedSlice,
+	marshal:   appendInt32PackedSlice,
+	unmarshal: consumeInt32Slice,
+	merge:     mergeInt32Slice,
+}
+
+// sizeInt32Value returns the size of wire encoding a int32 value as a Int32.
+func sizeInt32Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
+	return tagsize + protowire.SizeVarint(uint64(int32(v.Int())))
+}
+
+// appendInt32Value encodes a int32 value as a Int32.
+func appendInt32Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendVarint(b, uint64(int32(v.Int())))
+	return b, nil
+}
+
+// consumeInt32Value decodes a int32 value as a Int32.
+func consumeInt32Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	out.n = n
+	return protoreflect.ValueOfInt32(int32(v)), out, nil
+}
+
+var coderInt32Value = valueCoderFuncs{
+	size:      sizeInt32Value,
+	marshal:   appendInt32Value,
+	unmarshal: consumeInt32Value,
+	merge:     mergeScalarValue,
+}
+
+// sizeInt32SliceValue returns the size of wire encoding a []int32 value as a repeated Int32.
+func sizeInt32SliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
+	list := listv.List()
+	for i, llen := 0, list.Len(); i < llen; i++ {
+		v := list.Get(i)
+		size += tagsize + protowire.SizeVarint(uint64(int32(v.Int())))
+	}
+	return size
+}
+
+// appendInt32SliceValue encodes a []int32 value as a repeated Int32.
+func appendInt32SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	list := listv.List()
+	for i, llen := 0, list.Len(); i < llen; i++ {
+		v := list.Get(i)
+		b = protowire.AppendVarint(b, wiretag)
+		b = protowire.AppendVarint(b, uint64(int32(v.Int())))
+	}
+	return b, nil
+}
+
+// consumeInt32SliceValue wire decodes a []int32 value as a repeated Int32.
+func consumeInt32SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	list := listv.List()
+	if wtyp == protowire.BytesType {
+		b, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return protoreflect.Value{}, out, protowire.ParseError(n)
+		}
+		for len(b) > 0 {
+			var v uint64
+			var n int
+			if len(b) >= 1 && b[0] < 0x80 {
+				v = uint64(b[0])
+				n = 1
+			} else if len(b) >= 2 && b[1] < 128 {
+				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+				n = 2
+			} else {
+				v, n = protowire.ConsumeVarint(b)
+			}
+			if n < 0 {
+				return protoreflect.Value{}, out, protowire.ParseError(n)
+			}
+			list.Append(protoreflect.ValueOfInt32(int32(v)))
+			b = b[n:]
+		}
+		out.n = n
+		return listv, out, nil
+	}
+	if wtyp != protowire.VarintType {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	list.Append(protoreflect.ValueOfInt32(int32(v)))
+	out.n = n
+	return listv, out, nil
+}
+
+var coderInt32SliceValue = valueCoderFuncs{
+	size:      sizeInt32SliceValue,
+	marshal:   appendInt32SliceValue,
+	unmarshal: consumeInt32SliceValue,
+	merge:     mergeListValue,
+}
+
+// sizeInt32PackedSliceValue returns the size of wire encoding a []int32 value as a packed repeated Int32.
+func sizeInt32PackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
+	list := listv.List()
+	llen := list.Len()
+	if llen == 0 {
+		return 0
+	}
+	n := 0
+	for i, llen := 0, llen; i < llen; i++ {
+		v := list.Get(i)
+		n += protowire.SizeVarint(uint64(int32(v.Int())))
+	}
+	return tagsize + protowire.SizeBytes(n)
+}
+
+// appendInt32PackedSliceValue encodes a []int32 value as a packed repeated Int32.
+func appendInt32PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	list := listv.List()
+	llen := list.Len()
+	if llen == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, wiretag)
+	n := 0
+	for i := 0; i < llen; i++ {
+		v := list.Get(i)
+		n += protowire.SizeVarint(uint64(int32(v.Int())))
+	}
+	b = protowire.AppendVarint(b, uint64(n))
+	for i := 0; i < llen; i++ {
+		v := list.Get(i)
+		b = protowire.AppendVarint(b, uint64(int32(v.Int())))
+	}
+	return b, nil
+}
+
+var coderInt32PackedSliceValue = valueCoderFuncs{
+	size:      sizeInt32PackedSliceValue,
+	marshal:   appendInt32PackedSliceValue,
+	unmarshal: consumeInt32SliceValue,
+	merge:     mergeListValue,
+}
+
+// sizeSint32 returns the size of wire encoding a int32 pointer as a Sint32.
+func sizeSint32(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	v := *p.Int32()
+	return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
+}
+
+// appendSint32 wire encodes a int32 pointer as a Sint32.
+func appendSint32(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.Int32()
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(v)))
+	return b, nil
+}
+
+// consumeSint32 wire decodes a int32 pointer as a Sint32.
+func consumeSint32(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
+		return out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	*p.Int32() = int32(protowire.DecodeZigZag(v & math.MaxUint32))
+	out.n = n
+	return out, nil
+}
+
+var coderSint32 = pointerCoderFuncs{
+	size:      sizeSint32,
+	marshal:   appendSint32,
+	unmarshal: consumeSint32,
+	merge:     mergeInt32,
+}
+
+// sizeSint32NoZero returns the size of wire encoding a int32 pointer as a Sint32.
+// The zero value is not encoded.
+func sizeSint32NoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	v := *p.Int32()
+	if v == 0 {
+		return 0
+	}
+	return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
+}
+
+// appendSint32NoZero wire encodes a int32 pointer as a Sint32.
+// The zero value is not encoded.
+func appendSint32NoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.Int32()
+	if v == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(v)))
+	return b, nil
+}
+
+var coderSint32NoZero = pointerCoderFuncs{
+	size:      sizeSint32NoZero,
+	marshal:   appendSint32NoZero,
+	unmarshal: consumeSint32,
+	merge:     mergeInt32NoZero,
+}
+
+// sizeSint32Ptr returns the size of wire encoding a *int32 pointer as a Sint32.
+// It panics if the pointer is nil.
+func sizeSint32Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	v := **p.Int32Ptr()
+	return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
+}
+
+// appendSint32Ptr wire encodes a *int32 pointer as a Sint32.
+// It panics if the pointer is nil.
+func appendSint32Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := **p.Int32Ptr()
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(v)))
+	return b, nil
+}
+
+// consumeSint32Ptr wire decodes a *int32 pointer as a Sint32.
+func consumeSint32Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
+		return out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	vp := p.Int32Ptr()
+	if *vp == nil {
+		*vp = new(int32)
+	}
+	**vp = int32(protowire.DecodeZigZag(v & math.MaxUint32))
+	out.n = n
+	return out, nil
+}
+
+var coderSint32Ptr = pointerCoderFuncs{
+	size:      sizeSint32Ptr,
+	marshal:   appendSint32Ptr,
+	unmarshal: consumeSint32Ptr,
+	merge:     mergeInt32Ptr,
+}
+
+// sizeSint32Slice returns the size of wire encoding a []int32 pointer as a repeated Sint32.
+func sizeSint32Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	s := *p.Int32Slice()
+	for _, v := range s {
+		size += f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
+	}
+	return size
+}
+
+// appendSint32Slice encodes a []int32 pointer as a repeated Sint32.
+func appendSint32Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	s := *p.Int32Slice()
+	for _, v := range s {
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(v)))
+	}
+	return b, nil
+}
+
+// consumeSint32Slice wire decodes a []int32 pointer as a repeated Sint32.
+func consumeSint32Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	sp := p.Int32Slice()
+	if wtyp == protowire.BytesType {
+		s := *sp
+		b, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return out, protowire.ParseError(n)
+		}
+		for len(b) > 0 {
+			var v uint64
+			var n int
+			if len(b) >= 1 && b[0] < 0x80 {
+				v = uint64(b[0])
+				n = 1
+			} else if len(b) >= 2 && b[1] < 128 {
+				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+				n = 2
+			} else {
+				v, n = protowire.ConsumeVarint(b)
+			}
+			if n < 0 {
+				return out, protowire.ParseError(n)
+			}
+			s = append(s, int32(protowire.DecodeZigZag(v&math.MaxUint32)))
+			b = b[n:]
+		}
+		*sp = s
+		out.n = n
+		return out, nil
+	}
+	if wtyp != protowire.VarintType {
+		return out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	*sp = append(*sp, int32(protowire.DecodeZigZag(v&math.MaxUint32)))
+	out.n = n
+	return out, nil
+}
+
+var coderSint32Slice = pointerCoderFuncs{
+	size:      sizeSint32Slice,
+	marshal:   appendSint32Slice,
+	unmarshal: consumeSint32Slice,
+	merge:     mergeInt32Slice,
+}
+
+// sizeSint32PackedSlice returns the size of wire encoding a []int32 pointer as a packed repeated Sint32.
+func sizeSint32PackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	s := *p.Int32Slice()
+	if len(s) == 0 {
+		return 0
+	}
+	n := 0
+	for _, v := range s {
+		n += protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
+	}
+	return f.tagsize + protowire.SizeBytes(n)
+}
+
+// appendSint32PackedSlice encodes a []int32 pointer as a packed repeated Sint32.
+func appendSint32PackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	s := *p.Int32Slice()
+	if len(s) == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, f.wiretag)
+	n := 0
+	for _, v := range s {
+		n += protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
+	}
+	b = protowire.AppendVarint(b, uint64(n))
+	for _, v := range s {
+		b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(v)))
+	}
+	return b, nil
+}
+
+var coderSint32PackedSlice = pointerCoderFuncs{
+	size:      sizeSint32PackedSlice,
+	marshal:   appendSint32PackedSlice,
+	unmarshal: consumeSint32Slice,
+	merge:     mergeInt32Slice,
+}
+
+// sizeSint32Value returns the size of wire encoding a int32 value as a Sint32.
+func sizeSint32Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
+	return tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(int32(v.Int()))))
+}
+
+// appendSint32Value encodes a int32 value as a Sint32.
+func appendSint32Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(int32(v.Int()))))
+	return b, nil
+}
+
+// consumeSint32Value decodes a int32 value as a Sint32.
+func consumeSint32Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	out.n = n
+	return protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))), out, nil
+}
+
+var coderSint32Value = valueCoderFuncs{
+	size:      sizeSint32Value,
+	marshal:   appendSint32Value,
+	unmarshal: consumeSint32Value,
+	merge:     mergeScalarValue,
+}
+
+// sizeSint32SliceValue returns the size of wire encoding a []int32 value as a repeated Sint32.
+func sizeSint32SliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
+	list := listv.List()
+	for i, llen := 0, list.Len(); i < llen; i++ {
+		v := list.Get(i)
+		size += tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(int32(v.Int()))))
+	}
+	return size
+}
+
+// appendSint32SliceValue encodes a []int32 value as a repeated Sint32.
+func appendSint32SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	list := listv.List()
+	for i, llen := 0, list.Len(); i < llen; i++ {
+		v := list.Get(i)
+		b = protowire.AppendVarint(b, wiretag)
+		b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(int32(v.Int()))))
+	}
+	return b, nil
+}
+
+// consumeSint32SliceValue wire decodes a []int32 value as a repeated Sint32.
+func consumeSint32SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	list := listv.List()
+	if wtyp == protowire.BytesType {
+		b, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return protoreflect.Value{}, out, protowire.ParseError(n)
+		}
+		for len(b) > 0 {
+			var v uint64
+			var n int
+			if len(b) >= 1 && b[0] < 0x80 {
+				v = uint64(b[0])
+				n = 1
+			} else if len(b) >= 2 && b[1] < 128 {
+				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+				n = 2
+			} else {
+				v, n = protowire.ConsumeVarint(b)
+			}
+			if n < 0 {
+				return protoreflect.Value{}, out, protowire.ParseError(n)
+			}
+			list.Append(protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))))
+			b = b[n:]
+		}
+		out.n = n
+		return listv, out, nil
+	}
+	if wtyp != protowire.VarintType {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	list.Append(protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))))
+	out.n = n
+	return listv, out, nil
+}
+
+var coderSint32SliceValue = valueCoderFuncs{
+	size:      sizeSint32SliceValue,
+	marshal:   appendSint32SliceValue,
+	unmarshal: consumeSint32SliceValue,
+	merge:     mergeListValue,
+}
+
+// sizeSint32PackedSliceValue returns the size of wire encoding a []int32 value as a packed repeated Sint32.
+func sizeSint32PackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
+	list := listv.List()
+	llen := list.Len()
+	if llen == 0 {
+		return 0
+	}
+	n := 0
+	for i, llen := 0, llen; i < llen; i++ {
+		v := list.Get(i)
+		n += protowire.SizeVarint(protowire.EncodeZigZag(int64(int32(v.Int()))))
+	}
+	return tagsize + protowire.SizeBytes(n)
+}
+
+// appendSint32PackedSliceValue encodes a []int32 value as a packed repeated Sint32.
+func appendSint32PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	list := listv.List()
+	llen := list.Len()
+	if llen == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, wiretag)
+	n := 0
+	for i := 0; i < llen; i++ {
+		v := list.Get(i)
+		n += protowire.SizeVarint(protowire.EncodeZigZag(int64(int32(v.Int()))))
+	}
+	b = protowire.AppendVarint(b, uint64(n))
+	for i := 0; i < llen; i++ {
+		v := list.Get(i)
+		b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(int32(v.Int()))))
+	}
+	return b, nil
+}
+
+var coderSint32PackedSliceValue = valueCoderFuncs{
+	size:      sizeSint32PackedSliceValue,
+	marshal:   appendSint32PackedSliceValue,
+	unmarshal: consumeSint32SliceValue,
+	merge:     mergeListValue,
+}
+
+// sizeUint32 returns the size of wire encoding a uint32 pointer as a Uint32.
+func sizeUint32(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	v := *p.Uint32()
+	return f.tagsize + protowire.SizeVarint(uint64(v))
+}
+
+// appendUint32 wire encodes a uint32 pointer as a Uint32.
+func appendUint32(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.Uint32()
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, uint64(v))
+	return b, nil
+}
+
+// consumeUint32 wire decodes a uint32 pointer as a Uint32.
+func consumeUint32(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
+		return out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	*p.Uint32() = uint32(v)
+	out.n = n
+	return out, nil
+}
+
+var coderUint32 = pointerCoderFuncs{
+	size:      sizeUint32,
+	marshal:   appendUint32,
+	unmarshal: consumeUint32,
+	merge:     mergeUint32,
+}
+
+// sizeUint32NoZero returns the size of wire encoding a uint32 pointer as a Uint32.
+// The zero value is not encoded.
+func sizeUint32NoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	v := *p.Uint32()
+	if v == 0 {
+		return 0
+	}
+	return f.tagsize + protowire.SizeVarint(uint64(v))
+}
+
+// appendUint32NoZero wire encodes a uint32 pointer as a Uint32.
+// The zero value is not encoded.
+func appendUint32NoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.Uint32()
+	if v == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, uint64(v))
+	return b, nil
+}
+
+var coderUint32NoZero = pointerCoderFuncs{
+	size:      sizeUint32NoZero,
+	marshal:   appendUint32NoZero,
+	unmarshal: consumeUint32,
+	merge:     mergeUint32NoZero,
+}
+
+// sizeUint32Ptr returns the size of wire encoding a *uint32 pointer as a Uint32.
+// It panics if the pointer is nil.
+func sizeUint32Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	v := **p.Uint32Ptr()
+	return f.tagsize + protowire.SizeVarint(uint64(v))
+}
+
+// appendUint32Ptr wire encodes a *uint32 pointer as a Uint32.
+// It panics if the pointer is nil.
+func appendUint32Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := **p.Uint32Ptr()
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, uint64(v))
+	return b, nil
+}
+
+// consumeUint32Ptr wire decodes a *uint32 pointer as a Uint32.
+func consumeUint32Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
+		return out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	vp := p.Uint32Ptr()
+	if *vp == nil {
+		*vp = new(uint32)
+	}
+	**vp = uint32(v)
+	out.n = n
+	return out, nil
+}
+
+var coderUint32Ptr = pointerCoderFuncs{
+	size:      sizeUint32Ptr,
+	marshal:   appendUint32Ptr,
+	unmarshal: consumeUint32Ptr,
+	merge:     mergeUint32Ptr,
+}
+
+// sizeUint32Slice returns the size of wire encoding a []uint32 pointer as a repeated Uint32.
+func sizeUint32Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	s := *p.Uint32Slice()
+	for _, v := range s {
+		size += f.tagsize + protowire.SizeVarint(uint64(v))
+	}
+	return size
+}
+
+// appendUint32Slice encodes a []uint32 pointer as a repeated Uint32.
+func appendUint32Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	s := *p.Uint32Slice()
+	for _, v := range s {
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendVarint(b, uint64(v))
+	}
+	return b, nil
+}
+
+// consumeUint32Slice wire decodes a []uint32 pointer as a repeated Uint32.
+func consumeUint32Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	sp := p.Uint32Slice()
+	if wtyp == protowire.BytesType {
+		s := *sp
+		b, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return out, protowire.ParseError(n)
+		}
+		for len(b) > 0 {
+			var v uint64
+			var n int
+			if len(b) >= 1 && b[0] < 0x80 {
+				v = uint64(b[0])
+				n = 1
+			} else if len(b) >= 2 && b[1] < 128 {
+				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+				n = 2
+			} else {
+				v, n = protowire.ConsumeVarint(b)
+			}
+			if n < 0 {
+				return out, protowire.ParseError(n)
+			}
+			s = append(s, uint32(v))
+			b = b[n:]
+		}
+		*sp = s
+		out.n = n
+		return out, nil
+	}
+	if wtyp != protowire.VarintType {
+		return out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	*sp = append(*sp, uint32(v))
+	out.n = n
+	return out, nil
+}
+
+var coderUint32Slice = pointerCoderFuncs{
+	size:      sizeUint32Slice,
+	marshal:   appendUint32Slice,
+	unmarshal: consumeUint32Slice,
+	merge:     mergeUint32Slice,
+}
+
+// sizeUint32PackedSlice returns the size of wire encoding a []uint32 pointer as a packed repeated Uint32.
+func sizeUint32PackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	s := *p.Uint32Slice()
+	if len(s) == 0 {
+		return 0
+	}
+	n := 0
+	for _, v := range s {
+		n += protowire.SizeVarint(uint64(v))
+	}
+	return f.tagsize + protowire.SizeBytes(n)
+}
+
+// appendUint32PackedSlice encodes a []uint32 pointer as a packed repeated Uint32.
+func appendUint32PackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	s := *p.Uint32Slice()
+	if len(s) == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, f.wiretag)
+	n := 0
+	for _, v := range s {
+		n += protowire.SizeVarint(uint64(v))
+	}
+	b = protowire.AppendVarint(b, uint64(n))
+	for _, v := range s {
+		b = protowire.AppendVarint(b, uint64(v))
+	}
+	return b, nil
+}
+
+var coderUint32PackedSlice = pointerCoderFuncs{
+	size:      sizeUint32PackedSlice,
+	marshal:   appendUint32PackedSlice,
+	unmarshal: consumeUint32Slice,
+	merge:     mergeUint32Slice,
+}
+
+// sizeUint32Value returns the size of wire encoding a uint32 value as a Uint32.
+func sizeUint32Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
+	return tagsize + protowire.SizeVarint(uint64(uint32(v.Uint())))
+}
+
+// appendUint32Value encodes a uint32 value as a Uint32.
+func appendUint32Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendVarint(b, uint64(uint32(v.Uint())))
+	return b, nil
+}
+
+// consumeUint32Value decodes a uint32 value as a Uint32.
+func consumeUint32Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	out.n = n
+	return protoreflect.ValueOfUint32(uint32(v)), out, nil
+}
+
+var coderUint32Value = valueCoderFuncs{
+	size:      sizeUint32Value,
+	marshal:   appendUint32Value,
+	unmarshal: consumeUint32Value,
+	merge:     mergeScalarValue,
+}
+
+// sizeUint32SliceValue returns the size of wire encoding a []uint32 value as a repeated Uint32.
+func sizeUint32SliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
+	list := listv.List()
+	for i, llen := 0, list.Len(); i < llen; i++ {
+		v := list.Get(i)
+		size += tagsize + protowire.SizeVarint(uint64(uint32(v.Uint())))
+	}
+	return size
+}
+
+// appendUint32SliceValue encodes a []uint32 value as a repeated Uint32.
+func appendUint32SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	list := listv.List()
+	for i, llen := 0, list.Len(); i < llen; i++ {
+		v := list.Get(i)
+		b = protowire.AppendVarint(b, wiretag)
+		b = protowire.AppendVarint(b, uint64(uint32(v.Uint())))
+	}
+	return b, nil
+}
+
+// consumeUint32SliceValue wire decodes a []uint32 value as a repeated Uint32.
+func consumeUint32SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	list := listv.List()
+	if wtyp == protowire.BytesType {
+		b, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return protoreflect.Value{}, out, protowire.ParseError(n)
+		}
+		for len(b) > 0 {
+			var v uint64
+			var n int
+			if len(b) >= 1 && b[0] < 0x80 {
+				v = uint64(b[0])
+				n = 1
+			} else if len(b) >= 2 && b[1] < 128 {
+				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+				n = 2
+			} else {
+				v, n = protowire.ConsumeVarint(b)
+			}
+			if n < 0 {
+				return protoreflect.Value{}, out, protowire.ParseError(n)
+			}
+			list.Append(protoreflect.ValueOfUint32(uint32(v)))
+			b = b[n:]
+		}
+		out.n = n
+		return listv, out, nil
+	}
+	if wtyp != protowire.VarintType {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	list.Append(protoreflect.ValueOfUint32(uint32(v)))
+	out.n = n
+	return listv, out, nil
+}
+
+var coderUint32SliceValue = valueCoderFuncs{
+	size:      sizeUint32SliceValue,
+	marshal:   appendUint32SliceValue,
+	unmarshal: consumeUint32SliceValue,
+	merge:     mergeListValue,
+}
+
+// sizeUint32PackedSliceValue returns the size of wire encoding a []uint32 value as a packed repeated Uint32.
+func sizeUint32PackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
+	list := listv.List()
+	llen := list.Len()
+	if llen == 0 {
+		return 0
+	}
+	n := 0
+	for i, llen := 0, llen; i < llen; i++ {
+		v := list.Get(i)
+		n += protowire.SizeVarint(uint64(uint32(v.Uint())))
+	}
+	return tagsize + protowire.SizeBytes(n)
+}
+
+// appendUint32PackedSliceValue encodes a []uint32 value as a packed repeated Uint32.
+func appendUint32PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	list := listv.List()
+	llen := list.Len()
+	if llen == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, wiretag)
+	n := 0
+	for i := 0; i < llen; i++ {
+		v := list.Get(i)
+		n += protowire.SizeVarint(uint64(uint32(v.Uint())))
+	}
+	b = protowire.AppendVarint(b, uint64(n))
+	for i := 0; i < llen; i++ {
+		v := list.Get(i)
+		b = protowire.AppendVarint(b, uint64(uint32(v.Uint())))
+	}
+	return b, nil
+}
+
+var coderUint32PackedSliceValue = valueCoderFuncs{
+	size:      sizeUint32PackedSliceValue,
+	marshal:   appendUint32PackedSliceValue,
+	unmarshal: consumeUint32SliceValue,
+	merge:     mergeListValue,
+}
+
+// sizeInt64 returns the size of wire encoding a int64 pointer as a Int64.
+func sizeInt64(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	v := *p.Int64()
+	return f.tagsize + protowire.SizeVarint(uint64(v))
+}
+
+// appendInt64 wire encodes a int64 pointer as a Int64.
+func appendInt64(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.Int64()
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, uint64(v))
+	return b, nil
+}
+
+// consumeInt64 wire decodes a int64 pointer as a Int64.
+func consumeInt64(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
+		return out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	*p.Int64() = int64(v)
+	out.n = n
+	return out, nil
+}
+
+var coderInt64 = pointerCoderFuncs{
+	size:      sizeInt64,
+	marshal:   appendInt64,
+	unmarshal: consumeInt64,
+	merge:     mergeInt64,
+}
+
+// sizeInt64NoZero returns the size of wire encoding a int64 pointer as a Int64.
+// The zero value is not encoded.
+func sizeInt64NoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	v := *p.Int64()
+	if v == 0 {
+		return 0
+	}
+	return f.tagsize + protowire.SizeVarint(uint64(v))
+}
+
+// appendInt64NoZero wire encodes a int64 pointer as a Int64.
+// The zero value is not encoded.
+func appendInt64NoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.Int64()
+	if v == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, uint64(v))
+	return b, nil
+}
+
+var coderInt64NoZero = pointerCoderFuncs{
+	size:      sizeInt64NoZero,
+	marshal:   appendInt64NoZero,
+	unmarshal: consumeInt64,
+	merge:     mergeInt64NoZero,
+}
+
+// sizeInt64Ptr returns the size of wire encoding a *int64 pointer as a Int64.
+// It panics if the pointer is nil.
+func sizeInt64Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	v := **p.Int64Ptr()
+	return f.tagsize + protowire.SizeVarint(uint64(v))
+}
+
+// appendInt64Ptr wire encodes a *int64 pointer as a Int64.
+// It panics if the pointer is nil.
+func appendInt64Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := **p.Int64Ptr()
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, uint64(v))
+	return b, nil
+}
+
+// consumeInt64Ptr wire decodes a *int64 pointer as a Int64.
+func consumeInt64Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
+		return out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	vp := p.Int64Ptr()
+	if *vp == nil {
+		*vp = new(int64)
+	}
+	**vp = int64(v)
+	out.n = n
+	return out, nil
+}
+
+var coderInt64Ptr = pointerCoderFuncs{
+	size:      sizeInt64Ptr,
+	marshal:   appendInt64Ptr,
+	unmarshal: consumeInt64Ptr,
+	merge:     mergeInt64Ptr,
+}
+
+// sizeInt64Slice returns the size of wire encoding a []int64 pointer as a repeated Int64.
+func sizeInt64Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	s := *p.Int64Slice()
+	for _, v := range s {
+		size += f.tagsize + protowire.SizeVarint(uint64(v))
+	}
+	return size
+}
+
+// appendInt64Slice encodes a []int64 pointer as a repeated Int64.
+func appendInt64Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	s := *p.Int64Slice()
+	for _, v := range s {
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendVarint(b, uint64(v))
+	}
+	return b, nil
+}
+
+// consumeInt64Slice wire decodes a []int64 pointer as a repeated Int64.
+func consumeInt64Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	sp := p.Int64Slice()
+	if wtyp == protowire.BytesType {
+		s := *sp
+		b, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return out, protowire.ParseError(n)
+		}
+		for len(b) > 0 {
+			var v uint64
+			var n int
+			if len(b) >= 1 && b[0] < 0x80 {
+				v = uint64(b[0])
+				n = 1
+			} else if len(b) >= 2 && b[1] < 128 {
+				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+				n = 2
+			} else {
+				v, n = protowire.ConsumeVarint(b)
+			}
+			if n < 0 {
+				return out, protowire.ParseError(n)
+			}
+			s = append(s, int64(v))
+			b = b[n:]
+		}
+		*sp = s
+		out.n = n
+		return out, nil
+	}
+	if wtyp != protowire.VarintType {
+		return out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	*sp = append(*sp, int64(v))
+	out.n = n
+	return out, nil
+}
+
+var coderInt64Slice = pointerCoderFuncs{
+	size:      sizeInt64Slice,
+	marshal:   appendInt64Slice,
+	unmarshal: consumeInt64Slice,
+	merge:     mergeInt64Slice,
+}
+
+// sizeInt64PackedSlice returns the size of wire encoding a []int64 pointer as a packed repeated Int64.
+func sizeInt64PackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	s := *p.Int64Slice()
+	if len(s) == 0 {
+		return 0
+	}
+	n := 0
+	for _, v := range s {
+		n += protowire.SizeVarint(uint64(v))
+	}
+	return f.tagsize + protowire.SizeBytes(n)
+}
+
+// appendInt64PackedSlice encodes a []int64 pointer as a packed repeated Int64.
+func appendInt64PackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	s := *p.Int64Slice()
+	if len(s) == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, f.wiretag)
+	n := 0
+	for _, v := range s {
+		n += protowire.SizeVarint(uint64(v))
+	}
+	b = protowire.AppendVarint(b, uint64(n))
+	for _, v := range s {
+		b = protowire.AppendVarint(b, uint64(v))
+	}
+	return b, nil
+}
+
+var coderInt64PackedSlice = pointerCoderFuncs{
+	size:      sizeInt64PackedSlice,
+	marshal:   appendInt64PackedSlice,
+	unmarshal: consumeInt64Slice,
+	merge:     mergeInt64Slice,
+}
+
+// sizeInt64Value returns the size of wire encoding a int64 value as a Int64.
+func sizeInt64Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
+	return tagsize + protowire.SizeVarint(uint64(v.Int()))
+}
+
+// appendInt64Value encodes a int64 value as a Int64.
+func appendInt64Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendVarint(b, uint64(v.Int()))
+	return b, nil
+}
+
+// consumeInt64Value decodes a int64 value as a Int64.
+func consumeInt64Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	out.n = n
+	return protoreflect.ValueOfInt64(int64(v)), out, nil
+}
+
+var coderInt64Value = valueCoderFuncs{
+	size:      sizeInt64Value,
+	marshal:   appendInt64Value,
+	unmarshal: consumeInt64Value,
+	merge:     mergeScalarValue,
+}
+
+// sizeInt64SliceValue returns the size of wire encoding a []int64 value as a repeated Int64.
+func sizeInt64SliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
+	list := listv.List()
+	for i, llen := 0, list.Len(); i < llen; i++ {
+		v := list.Get(i)
+		size += tagsize + protowire.SizeVarint(uint64(v.Int()))
+	}
+	return size
+}
+
+// appendInt64SliceValue encodes a []int64 value as a repeated Int64.
+func appendInt64SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	list := listv.List()
+	for i, llen := 0, list.Len(); i < llen; i++ {
+		v := list.Get(i)
+		b = protowire.AppendVarint(b, wiretag)
+		b = protowire.AppendVarint(b, uint64(v.Int()))
+	}
+	return b, nil
+}
+
+// consumeInt64SliceValue wire decodes a []int64 value as a repeated Int64.
+func consumeInt64SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	list := listv.List()
+	if wtyp == protowire.BytesType {
+		b, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return protoreflect.Value{}, out, protowire.ParseError(n)
+		}
+		for len(b) > 0 {
+			var v uint64
+			var n int
+			if len(b) >= 1 && b[0] < 0x80 {
+				v = uint64(b[0])
+				n = 1
+			} else if len(b) >= 2 && b[1] < 128 {
+				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+				n = 2
+			} else {
+				v, n = protowire.ConsumeVarint(b)
+			}
+			if n < 0 {
+				return protoreflect.Value{}, out, protowire.ParseError(n)
+			}
+			list.Append(protoreflect.ValueOfInt64(int64(v)))
+			b = b[n:]
+		}
+		out.n = n
+		return listv, out, nil
+	}
+	if wtyp != protowire.VarintType {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	list.Append(protoreflect.ValueOfInt64(int64(v)))
+	out.n = n
+	return listv, out, nil
+}
+
+var coderInt64SliceValue = valueCoderFuncs{
+	size:      sizeInt64SliceValue,
+	marshal:   appendInt64SliceValue,
+	unmarshal: consumeInt64SliceValue,
+	merge:     mergeListValue,
+}
+
+// sizeInt64PackedSliceValue returns the size of wire encoding a []int64 value as a packed repeated Int64.
+func sizeInt64PackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
+	list := listv.List()
+	llen := list.Len()
+	if llen == 0 {
+		return 0
+	}
+	n := 0
+	for i, llen := 0, llen; i < llen; i++ {
+		v := list.Get(i)
+		n += protowire.SizeVarint(uint64(v.Int()))
+	}
+	return tagsize + protowire.SizeBytes(n)
+}
+
+// appendInt64PackedSliceValue encodes a []int64 value as a packed repeated Int64.
+func appendInt64PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	list := listv.List()
+	llen := list.Len()
+	if llen == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, wiretag)
+	n := 0
+	for i := 0; i < llen; i++ {
+		v := list.Get(i)
+		n += protowire.SizeVarint(uint64(v.Int()))
+	}
+	b = protowire.AppendVarint(b, uint64(n))
+	for i := 0; i < llen; i++ {
+		v := list.Get(i)
+		b = protowire.AppendVarint(b, uint64(v.Int()))
+	}
+	return b, nil
+}
+
+var coderInt64PackedSliceValue = valueCoderFuncs{
+	size:      sizeInt64PackedSliceValue,
+	marshal:   appendInt64PackedSliceValue,
+	unmarshal: consumeInt64SliceValue,
+	merge:     mergeListValue,
+}
+
+// sizeSint64 returns the size of wire encoding a int64 pointer as a Sint64.
+func sizeSint64(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	v := *p.Int64()
+	return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v))
+}
+
+// appendSint64 wire encodes a int64 pointer as a Sint64.
+func appendSint64(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.Int64()
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, protowire.EncodeZigZag(v))
+	return b, nil
+}
+
+// consumeSint64 wire decodes a int64 pointer as a Sint64.
+func consumeSint64(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
+		return out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	*p.Int64() = protowire.DecodeZigZag(v)
+	out.n = n
+	return out, nil
+}
+
+var coderSint64 = pointerCoderFuncs{
+	size:      sizeSint64,
+	marshal:   appendSint64,
+	unmarshal: consumeSint64,
+	merge:     mergeInt64,
+}
+
+// sizeSint64NoZero returns the size of wire encoding a int64 pointer as a Sint64.
+// The zero value is not encoded.
+func sizeSint64NoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	v := *p.Int64()
+	if v == 0 {
+		return 0
+	}
+	return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v))
+}
+
+// appendSint64NoZero wire encodes a int64 pointer as a Sint64.
+// The zero value is not encoded.
+func appendSint64NoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.Int64()
+	if v == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, protowire.EncodeZigZag(v))
+	return b, nil
+}
+
+var coderSint64NoZero = pointerCoderFuncs{
+	size:      sizeSint64NoZero,
+	marshal:   appendSint64NoZero,
+	unmarshal: consumeSint64,
+	merge:     mergeInt64NoZero,
+}
+
+// sizeSint64Ptr returns the size of wire encoding a *int64 pointer as a Sint64.
+// It panics if the pointer is nil.
+func sizeSint64Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	v := **p.Int64Ptr()
+	return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v))
+}
+
+// appendSint64Ptr wire encodes a *int64 pointer as a Sint64.
+// It panics if the pointer is nil.
+func appendSint64Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := **p.Int64Ptr()
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, protowire.EncodeZigZag(v))
+	return b, nil
+}
+
+// consumeSint64Ptr wire decodes a *int64 pointer as a Sint64.
+func consumeSint64Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
+		return out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	vp := p.Int64Ptr()
+	if *vp == nil {
+		*vp = new(int64)
+	}
+	**vp = protowire.DecodeZigZag(v)
+	out.n = n
+	return out, nil
+}
+
+var coderSint64Ptr = pointerCoderFuncs{
+	size:      sizeSint64Ptr,
+	marshal:   appendSint64Ptr,
+	unmarshal: consumeSint64Ptr,
+	merge:     mergeInt64Ptr,
+}
+
+// sizeSint64Slice returns the size of wire encoding a []int64 pointer as a repeated Sint64.
+func sizeSint64Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	s := *p.Int64Slice()
+	for _, v := range s {
+		size += f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v))
+	}
+	return size
+}
+
+// appendSint64Slice encodes a []int64 pointer as a repeated Sint64.
+func appendSint64Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	s := *p.Int64Slice()
+	for _, v := range s {
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendVarint(b, protowire.EncodeZigZag(v))
+	}
+	return b, nil
+}
+
+// consumeSint64Slice wire decodes a []int64 pointer as a repeated Sint64.
+func consumeSint64Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	sp := p.Int64Slice()
+	if wtyp == protowire.BytesType {
+		s := *sp
+		b, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return out, protowire.ParseError(n)
+		}
+		for len(b) > 0 {
+			var v uint64
+			var n int
+			if len(b) >= 1 && b[0] < 0x80 {
+				v = uint64(b[0])
+				n = 1
+			} else if len(b) >= 2 && b[1] < 128 {
+				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+				n = 2
+			} else {
+				v, n = protowire.ConsumeVarint(b)
+			}
+			if n < 0 {
+				return out, protowire.ParseError(n)
+			}
+			s = append(s, protowire.DecodeZigZag(v))
+			b = b[n:]
+		}
+		*sp = s
+		out.n = n
+		return out, nil
+	}
+	if wtyp != protowire.VarintType {
+		return out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	*sp = append(*sp, protowire.DecodeZigZag(v))
+	out.n = n
+	return out, nil
+}
+
+var coderSint64Slice = pointerCoderFuncs{
+	size:      sizeSint64Slice,
+	marshal:   appendSint64Slice,
+	unmarshal: consumeSint64Slice,
+	merge:     mergeInt64Slice,
+}
+
+// sizeSint64PackedSlice returns the size of wire encoding a []int64 pointer as a packed repeated Sint64.
+func sizeSint64PackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	s := *p.Int64Slice()
+	if len(s) == 0 {
+		return 0
+	}
+	n := 0
+	for _, v := range s {
+		n += protowire.SizeVarint(protowire.EncodeZigZag(v))
+	}
+	return f.tagsize + protowire.SizeBytes(n)
+}
+
+// appendSint64PackedSlice encodes a []int64 pointer as a packed repeated Sint64.
+func appendSint64PackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	s := *p.Int64Slice()
+	if len(s) == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, f.wiretag)
+	n := 0
+	for _, v := range s {
+		n += protowire.SizeVarint(protowire.EncodeZigZag(v))
+	}
+	b = protowire.AppendVarint(b, uint64(n))
+	for _, v := range s {
+		b = protowire.AppendVarint(b, protowire.EncodeZigZag(v))
+	}
+	return b, nil
+}
+
+var coderSint64PackedSlice = pointerCoderFuncs{
+	size:      sizeSint64PackedSlice,
+	marshal:   appendSint64PackedSlice,
+	unmarshal: consumeSint64Slice,
+	merge:     mergeInt64Slice,
+}
+
+// sizeSint64Value returns the size of wire encoding a int64 value as a Sint64.
+func sizeSint64Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
+	return tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v.Int()))
+}
+
+// appendSint64Value encodes a int64 value as a Sint64.
+func appendSint64Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendVarint(b, protowire.EncodeZigZag(v.Int()))
+	return b, nil
+}
+
+// consumeSint64Value decodes a int64 value as a Sint64.
+func consumeSint64Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	out.n = n
+	return protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)), out, nil
+}
+
+var coderSint64Value = valueCoderFuncs{
+	size:      sizeSint64Value,
+	marshal:   appendSint64Value,
+	unmarshal: consumeSint64Value,
+	merge:     mergeScalarValue,
+}
+
+// sizeSint64SliceValue returns the size of wire encoding a []int64 value as a repeated Sint64.
+func sizeSint64SliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
+	list := listv.List()
+	for i, llen := 0, list.Len(); i < llen; i++ {
+		v := list.Get(i)
+		size += tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v.Int()))
+	}
+	return size
+}
+
+// appendSint64SliceValue encodes a []int64 value as a repeated Sint64.
+func appendSint64SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	list := listv.List()
+	for i, llen := 0, list.Len(); i < llen; i++ {
+		v := list.Get(i)
+		b = protowire.AppendVarint(b, wiretag)
+		b = protowire.AppendVarint(b, protowire.EncodeZigZag(v.Int()))
+	}
+	return b, nil
+}
+
+// consumeSint64SliceValue wire decodes a []int64 value as a repeated Sint64.
+func consumeSint64SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	list := listv.List()
+	if wtyp == protowire.BytesType {
+		b, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return protoreflect.Value{}, out, protowire.ParseError(n)
+		}
+		for len(b) > 0 {
+			var v uint64
+			var n int
+			if len(b) >= 1 && b[0] < 0x80 {
+				v = uint64(b[0])
+				n = 1
+			} else if len(b) >= 2 && b[1] < 128 {
+				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+				n = 2
+			} else {
+				v, n = protowire.ConsumeVarint(b)
+			}
+			if n < 0 {
+				return protoreflect.Value{}, out, protowire.ParseError(n)
+			}
+			list.Append(protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)))
+			b = b[n:]
+		}
+		out.n = n
+		return listv, out, nil
+	}
+	if wtyp != protowire.VarintType {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	list.Append(protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)))
+	out.n = n
+	return listv, out, nil
+}
+
+var coderSint64SliceValue = valueCoderFuncs{
+	size:      sizeSint64SliceValue,
+	marshal:   appendSint64SliceValue,
+	unmarshal: consumeSint64SliceValue,
+	merge:     mergeListValue,
+}
+
+// sizeSint64PackedSliceValue returns the size of wire encoding a []int64 value as a packed repeated Sint64.
+func sizeSint64PackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
+	list := listv.List()
+	llen := list.Len()
+	if llen == 0 {
+		return 0
+	}
+	n := 0
+	for i, llen := 0, llen; i < llen; i++ {
+		v := list.Get(i)
+		n += protowire.SizeVarint(protowire.EncodeZigZag(v.Int()))
+	}
+	return tagsize + protowire.SizeBytes(n)
+}
+
+// appendSint64PackedSliceValue encodes a []int64 value as a packed repeated Sint64.
+func appendSint64PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	list := listv.List()
+	llen := list.Len()
+	if llen == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, wiretag)
+	n := 0
+	for i := 0; i < llen; i++ {
+		v := list.Get(i)
+		n += protowire.SizeVarint(protowire.EncodeZigZag(v.Int()))
+	}
+	b = protowire.AppendVarint(b, uint64(n))
+	for i := 0; i < llen; i++ {
+		v := list.Get(i)
+		b = protowire.AppendVarint(b, protowire.EncodeZigZag(v.Int()))
+	}
+	return b, nil
+}
+
+var coderSint64PackedSliceValue = valueCoderFuncs{
+	size:      sizeSint64PackedSliceValue,
+	marshal:   appendSint64PackedSliceValue,
+	unmarshal: consumeSint64SliceValue,
+	merge:     mergeListValue,
+}
+
+// sizeUint64 returns the size of wire encoding a uint64 pointer as a Uint64.
+func sizeUint64(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	v := *p.Uint64()
+	return f.tagsize + protowire.SizeVarint(v)
+}
+
+// appendUint64 wire encodes a uint64 pointer as a Uint64.
+func appendUint64(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.Uint64()
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, v)
+	return b, nil
+}
+
+// consumeUint64 wire decodes a uint64 pointer as a Uint64.
+func consumeUint64(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
+		return out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	*p.Uint64() = v
+	out.n = n
+	return out, nil
+}
+
+var coderUint64 = pointerCoderFuncs{
+	size:      sizeUint64,
+	marshal:   appendUint64,
+	unmarshal: consumeUint64,
+	merge:     mergeUint64,
+}
+
+// sizeUint64NoZero returns the size of wire encoding a uint64 pointer as a Uint64.
+// The zero value is not encoded.
+func sizeUint64NoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	v := *p.Uint64()
+	if v == 0 {
+		return 0
+	}
+	return f.tagsize + protowire.SizeVarint(v)
+}
+
+// appendUint64NoZero wire encodes a uint64 pointer as a Uint64.
+// The zero value is not encoded.
+func appendUint64NoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.Uint64()
+	if v == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, v)
+	return b, nil
+}
+
+var coderUint64NoZero = pointerCoderFuncs{
+	size:      sizeUint64NoZero,
+	marshal:   appendUint64NoZero,
+	unmarshal: consumeUint64,
+	merge:     mergeUint64NoZero,
+}
+
+// sizeUint64Ptr returns the size of wire encoding a *uint64 pointer as a Uint64.
+// It panics if the pointer is nil.
+func sizeUint64Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	v := **p.Uint64Ptr()
+	return f.tagsize + protowire.SizeVarint(v)
+}
+
+// appendUint64Ptr wire encodes a *uint64 pointer as a Uint64.
+// It panics if the pointer is nil.
+func appendUint64Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := **p.Uint64Ptr()
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, v)
+	return b, nil
+}
+
+// consumeUint64Ptr wire decodes a *uint64 pointer as a Uint64.
+func consumeUint64Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
+		return out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	vp := p.Uint64Ptr()
+	if *vp == nil {
+		*vp = new(uint64)
+	}
+	**vp = v
+	out.n = n
+	return out, nil
+}
+
+var coderUint64Ptr = pointerCoderFuncs{
+	size:      sizeUint64Ptr,
+	marshal:   appendUint64Ptr,
+	unmarshal: consumeUint64Ptr,
+	merge:     mergeUint64Ptr,
+}
+
+// sizeUint64Slice returns the size of wire encoding a []uint64 pointer as a repeated Uint64.
+func sizeUint64Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	s := *p.Uint64Slice()
+	for _, v := range s {
+		size += f.tagsize + protowire.SizeVarint(v)
+	}
+	return size
+}
+
+// appendUint64Slice encodes a []uint64 pointer as a repeated Uint64.
+func appendUint64Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	s := *p.Uint64Slice()
+	for _, v := range s {
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendVarint(b, v)
+	}
+	return b, nil
+}
+
+// consumeUint64Slice wire decodes a []uint64 pointer as a repeated Uint64.
+func consumeUint64Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	sp := p.Uint64Slice()
+	if wtyp == protowire.BytesType {
+		s := *sp
+		b, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return out, protowire.ParseError(n)
+		}
+		for len(b) > 0 {
+			var v uint64
+			var n int
+			if len(b) >= 1 && b[0] < 0x80 {
+				v = uint64(b[0])
+				n = 1
+			} else if len(b) >= 2 && b[1] < 128 {
+				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+				n = 2
+			} else {
+				v, n = protowire.ConsumeVarint(b)
+			}
+			if n < 0 {
+				return out, protowire.ParseError(n)
+			}
+			s = append(s, v)
+			b = b[n:]
+		}
+		*sp = s
+		out.n = n
+		return out, nil
+	}
+	if wtyp != protowire.VarintType {
+		return out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	*sp = append(*sp, v)
+	out.n = n
+	return out, nil
+}
+
+var coderUint64Slice = pointerCoderFuncs{
+	size:      sizeUint64Slice,
+	marshal:   appendUint64Slice,
+	unmarshal: consumeUint64Slice,
+	merge:     mergeUint64Slice,
+}
+
+// sizeUint64PackedSlice returns the size of wire encoding a []uint64 pointer as a packed repeated Uint64.
+func sizeUint64PackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	s := *p.Uint64Slice()
+	if len(s) == 0 {
+		return 0
+	}
+	n := 0
+	for _, v := range s {
+		n += protowire.SizeVarint(v)
+	}
+	return f.tagsize + protowire.SizeBytes(n)
+}
+
+// appendUint64PackedSlice encodes a []uint64 pointer as a packed repeated Uint64.
+func appendUint64PackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	s := *p.Uint64Slice()
+	if len(s) == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, f.wiretag)
+	n := 0
+	for _, v := range s {
+		n += protowire.SizeVarint(v)
+	}
+	b = protowire.AppendVarint(b, uint64(n))
+	for _, v := range s {
+		b = protowire.AppendVarint(b, v)
+	}
+	return b, nil
+}
+
+var coderUint64PackedSlice = pointerCoderFuncs{
+	size:      sizeUint64PackedSlice,
+	marshal:   appendUint64PackedSlice,
+	unmarshal: consumeUint64Slice,
+	merge:     mergeUint64Slice,
+}
+
+// sizeUint64Value returns the size of wire encoding a uint64 value as a Uint64.
+func sizeUint64Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
+	return tagsize + protowire.SizeVarint(v.Uint())
+}
+
+// appendUint64Value encodes a uint64 value as a Uint64.
+func appendUint64Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendVarint(b, v.Uint())
+	return b, nil
+}
+
+// consumeUint64Value decodes a uint64 value as a Uint64.
+func consumeUint64Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	out.n = n
+	return protoreflect.ValueOfUint64(v), out, nil
+}
+
+var coderUint64Value = valueCoderFuncs{
+	size:      sizeUint64Value,
+	marshal:   appendUint64Value,
+	unmarshal: consumeUint64Value,
+	merge:     mergeScalarValue,
+}
+
+// sizeUint64SliceValue returns the size of wire encoding a []uint64 value as a repeated Uint64.
+func sizeUint64SliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
+	list := listv.List()
+	for i, llen := 0, list.Len(); i < llen; i++ {
+		v := list.Get(i)
+		size += tagsize + protowire.SizeVarint(v.Uint())
+	}
+	return size
+}
+
+// appendUint64SliceValue encodes a []uint64 value as a repeated Uint64.
+func appendUint64SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	list := listv.List()
+	for i, llen := 0, list.Len(); i < llen; i++ {
+		v := list.Get(i)
+		b = protowire.AppendVarint(b, wiretag)
+		b = protowire.AppendVarint(b, v.Uint())
+	}
+	return b, nil
+}
+
+// consumeUint64SliceValue wire decodes a []uint64 value as a repeated Uint64.
+func consumeUint64SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	list := listv.List()
+	if wtyp == protowire.BytesType {
+		b, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return protoreflect.Value{}, out, protowire.ParseError(n)
+		}
+		for len(b) > 0 {
+			var v uint64
+			var n int
+			if len(b) >= 1 && b[0] < 0x80 {
+				v = uint64(b[0])
+				n = 1
+			} else if len(b) >= 2 && b[1] < 128 {
+				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+				n = 2
+			} else {
+				v, n = protowire.ConsumeVarint(b)
+			}
+			if n < 0 {
+				return protoreflect.Value{}, out, protowire.ParseError(n)
+			}
+			list.Append(protoreflect.ValueOfUint64(v))
+			b = b[n:]
+		}
+		out.n = n
+		return listv, out, nil
+	}
+	if wtyp != protowire.VarintType {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	var v uint64
+	var n int
+	if len(b) >= 1 && b[0] < 0x80 {
+		v = uint64(b[0])
+		n = 1
+	} else if len(b) >= 2 && b[1] < 128 {
+		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
+		n = 2
+	} else {
+		v, n = protowire.ConsumeVarint(b)
+	}
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	list.Append(protoreflect.ValueOfUint64(v))
+	out.n = n
+	return listv, out, nil
+}
+
+var coderUint64SliceValue = valueCoderFuncs{
+	size:      sizeUint64SliceValue,
+	marshal:   appendUint64SliceValue,
+	unmarshal: consumeUint64SliceValue,
+	merge:     mergeListValue,
+}
+
+// sizeUint64PackedSliceValue returns the size of wire encoding a []uint64 value as a packed repeated Uint64.
+func sizeUint64PackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
+	list := listv.List()
+	llen := list.Len()
+	if llen == 0 {
+		return 0
+	}
+	n := 0
+	for i, llen := 0, llen; i < llen; i++ {
+		v := list.Get(i)
+		n += protowire.SizeVarint(v.Uint())
+	}
+	return tagsize + protowire.SizeBytes(n)
+}
+
+// appendUint64PackedSliceValue encodes a []uint64 value as a packed repeated Uint64.
+func appendUint64PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	list := listv.List()
+	llen := list.Len()
+	if llen == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, wiretag)
+	n := 0
+	for i := 0; i < llen; i++ {
+		v := list.Get(i)
+		n += protowire.SizeVarint(v.Uint())
+	}
+	b = protowire.AppendVarint(b, uint64(n))
+	for i := 0; i < llen; i++ {
+		v := list.Get(i)
+		b = protowire.AppendVarint(b, v.Uint())
+	}
+	return b, nil
+}
+
+var coderUint64PackedSliceValue = valueCoderFuncs{
+	size:      sizeUint64PackedSliceValue,
+	marshal:   appendUint64PackedSliceValue,
+	unmarshal: consumeUint64SliceValue,
+	merge:     mergeListValue,
+}
+
+// sizeSfixed32 returns the size of wire encoding a int32 pointer as a Sfixed32.
+func sizeSfixed32(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+
+	return f.tagsize + protowire.SizeFixed32()
+}
+
+// appendSfixed32 wire encodes a int32 pointer as a Sfixed32.
+func appendSfixed32(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.Int32()
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed32(b, uint32(v))
+	return b, nil
+}
+
+// consumeSfixed32 wire decodes a int32 pointer as a Sfixed32.
+func consumeSfixed32(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed32Type {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeFixed32(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	*p.Int32() = int32(v)
+	out.n = n
+	return out, nil
+}
+
+var coderSfixed32 = pointerCoderFuncs{
+	size:      sizeSfixed32,
+	marshal:   appendSfixed32,
+	unmarshal: consumeSfixed32,
+	merge:     mergeInt32,
+}
+
+// sizeSfixed32NoZero returns the size of wire encoding a int32 pointer as a Sfixed32.
+// The zero value is not encoded.
+func sizeSfixed32NoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	v := *p.Int32()
+	if v == 0 {
+		return 0
+	}
+	return f.tagsize + protowire.SizeFixed32()
+}
+
+// appendSfixed32NoZero wire encodes a int32 pointer as a Sfixed32.
+// The zero value is not encoded.
+func appendSfixed32NoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.Int32()
+	if v == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed32(b, uint32(v))
+	return b, nil
+}
+
+var coderSfixed32NoZero = pointerCoderFuncs{
+	size:      sizeSfixed32NoZero,
+	marshal:   appendSfixed32NoZero,
+	unmarshal: consumeSfixed32,
+	merge:     mergeInt32NoZero,
+}
+
+// sizeSfixed32Ptr returns the size of wire encoding a *int32 pointer as a Sfixed32.
+// It panics if the pointer is nil.
+func sizeSfixed32Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	return f.tagsize + protowire.SizeFixed32()
+}
+
+// appendSfixed32Ptr wire encodes a *int32 pointer as a Sfixed32.
+// It panics if the pointer is nil.
+func appendSfixed32Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := **p.Int32Ptr()
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed32(b, uint32(v))
+	return b, nil
+}
+
+// consumeSfixed32Ptr wire decodes a *int32 pointer as a Sfixed32.
+func consumeSfixed32Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed32Type {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeFixed32(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	vp := p.Int32Ptr()
+	if *vp == nil {
+		*vp = new(int32)
+	}
+	**vp = int32(v)
+	out.n = n
+	return out, nil
+}
+
+var coderSfixed32Ptr = pointerCoderFuncs{
+	size:      sizeSfixed32Ptr,
+	marshal:   appendSfixed32Ptr,
+	unmarshal: consumeSfixed32Ptr,
+	merge:     mergeInt32Ptr,
+}
+
+// sizeSfixed32Slice returns the size of wire encoding a []int32 pointer as a repeated Sfixed32.
+func sizeSfixed32Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	s := *p.Int32Slice()
+	size = len(s) * (f.tagsize + protowire.SizeFixed32())
+	return size
+}
+
+// appendSfixed32Slice encodes a []int32 pointer as a repeated Sfixed32.
+func appendSfixed32Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	s := *p.Int32Slice()
+	for _, v := range s {
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendFixed32(b, uint32(v))
+	}
+	return b, nil
+}
+
+// consumeSfixed32Slice wire decodes a []int32 pointer as a repeated Sfixed32.
+func consumeSfixed32Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	sp := p.Int32Slice()
+	if wtyp == protowire.BytesType {
+		s := *sp
+		b, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return out, protowire.ParseError(n)
+		}
+		for len(b) > 0 {
+			v, n := protowire.ConsumeFixed32(b)
+			if n < 0 {
+				return out, protowire.ParseError(n)
+			}
+			s = append(s, int32(v))
+			b = b[n:]
+		}
+		*sp = s
+		out.n = n
+		return out, nil
+	}
+	if wtyp != protowire.Fixed32Type {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeFixed32(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	*sp = append(*sp, int32(v))
+	out.n = n
+	return out, nil
+}
+
+var coderSfixed32Slice = pointerCoderFuncs{
+	size:      sizeSfixed32Slice,
+	marshal:   appendSfixed32Slice,
+	unmarshal: consumeSfixed32Slice,
+	merge:     mergeInt32Slice,
+}
+
+// sizeSfixed32PackedSlice returns the size of wire encoding a []int32 pointer as a packed repeated Sfixed32.
+func sizeSfixed32PackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	s := *p.Int32Slice()
+	if len(s) == 0 {
+		return 0
+	}
+	n := len(s) * protowire.SizeFixed32()
+	return f.tagsize + protowire.SizeBytes(n)
+}
+
+// appendSfixed32PackedSlice encodes a []int32 pointer as a packed repeated Sfixed32.
+func appendSfixed32PackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	s := *p.Int32Slice()
+	if len(s) == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, f.wiretag)
+	n := len(s) * protowire.SizeFixed32()
+	b = protowire.AppendVarint(b, uint64(n))
+	for _, v := range s {
+		b = protowire.AppendFixed32(b, uint32(v))
+	}
+	return b, nil
+}
+
+var coderSfixed32PackedSlice = pointerCoderFuncs{
+	size:      sizeSfixed32PackedSlice,
+	marshal:   appendSfixed32PackedSlice,
+	unmarshal: consumeSfixed32Slice,
+	merge:     mergeInt32Slice,
+}
+
+// sizeSfixed32Value returns the size of wire encoding a int32 value as a Sfixed32.
+func sizeSfixed32Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
+	return tagsize + protowire.SizeFixed32()
+}
+
+// appendSfixed32Value encodes a int32 value as a Sfixed32.
+func appendSfixed32Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendFixed32(b, uint32(v.Int()))
+	return b, nil
+}
+
+// consumeSfixed32Value decodes a int32 value as a Sfixed32.
+func consumeSfixed32Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed32Type {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	v, n := protowire.ConsumeFixed32(b)
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	out.n = n
+	return protoreflect.ValueOfInt32(int32(v)), out, nil
+}
+
+var coderSfixed32Value = valueCoderFuncs{
+	size:      sizeSfixed32Value,
+	marshal:   appendSfixed32Value,
+	unmarshal: consumeSfixed32Value,
+	merge:     mergeScalarValue,
+}
+
+// sizeSfixed32SliceValue returns the size of wire encoding a []int32 value as a repeated Sfixed32.
+func sizeSfixed32SliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
+	list := listv.List()
+	size = list.Len() * (tagsize + protowire.SizeFixed32())
+	return size
+}
+
+// appendSfixed32SliceValue encodes a []int32 value as a repeated Sfixed32.
+func appendSfixed32SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	list := listv.List()
+	for i, llen := 0, list.Len(); i < llen; i++ {
+		v := list.Get(i)
+		b = protowire.AppendVarint(b, wiretag)
+		b = protowire.AppendFixed32(b, uint32(v.Int()))
+	}
+	return b, nil
+}
+
+// consumeSfixed32SliceValue wire decodes a []int32 value as a repeated Sfixed32.
+func consumeSfixed32SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	list := listv.List()
+	if wtyp == protowire.BytesType {
+		b, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return protoreflect.Value{}, out, protowire.ParseError(n)
+		}
+		for len(b) > 0 {
+			v, n := protowire.ConsumeFixed32(b)
+			if n < 0 {
+				return protoreflect.Value{}, out, protowire.ParseError(n)
+			}
+			list.Append(protoreflect.ValueOfInt32(int32(v)))
+			b = b[n:]
+		}
+		out.n = n
+		return listv, out, nil
+	}
+	if wtyp != protowire.Fixed32Type {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	v, n := protowire.ConsumeFixed32(b)
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	list.Append(protoreflect.ValueOfInt32(int32(v)))
+	out.n = n
+	return listv, out, nil
+}
+
+var coderSfixed32SliceValue = valueCoderFuncs{
+	size:      sizeSfixed32SliceValue,
+	marshal:   appendSfixed32SliceValue,
+	unmarshal: consumeSfixed32SliceValue,
+	merge:     mergeListValue,
+}
+
+// sizeSfixed32PackedSliceValue returns the size of wire encoding a []int32 value as a packed repeated Sfixed32.
+func sizeSfixed32PackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
+	list := listv.List()
+	llen := list.Len()
+	if llen == 0 {
+		return 0
+	}
+	n := llen * protowire.SizeFixed32()
+	return tagsize + protowire.SizeBytes(n)
+}
+
+// appendSfixed32PackedSliceValue encodes a []int32 value as a packed repeated Sfixed32.
+func appendSfixed32PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	list := listv.List()
+	llen := list.Len()
+	if llen == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, wiretag)
+	n := llen * protowire.SizeFixed32()
+	b = protowire.AppendVarint(b, uint64(n))
+	for i := 0; i < llen; i++ {
+		v := list.Get(i)
+		b = protowire.AppendFixed32(b, uint32(v.Int()))
+	}
+	return b, nil
+}
+
+var coderSfixed32PackedSliceValue = valueCoderFuncs{
+	size:      sizeSfixed32PackedSliceValue,
+	marshal:   appendSfixed32PackedSliceValue,
+	unmarshal: consumeSfixed32SliceValue,
+	merge:     mergeListValue,
+}
+
+// sizeFixed32 returns the size of wire encoding a uint32 pointer as a Fixed32.
+func sizeFixed32(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+
+	return f.tagsize + protowire.SizeFixed32()
+}
+
+// appendFixed32 wire encodes a uint32 pointer as a Fixed32.
+func appendFixed32(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.Uint32()
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed32(b, v)
+	return b, nil
+}
+
+// consumeFixed32 wire decodes a uint32 pointer as a Fixed32.
+func consumeFixed32(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed32Type {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeFixed32(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	*p.Uint32() = v
+	out.n = n
+	return out, nil
+}
+
+var coderFixed32 = pointerCoderFuncs{
+	size:      sizeFixed32,
+	marshal:   appendFixed32,
+	unmarshal: consumeFixed32,
+	merge:     mergeUint32,
+}
+
+// sizeFixed32NoZero returns the size of wire encoding a uint32 pointer as a Fixed32.
+// The zero value is not encoded.
+func sizeFixed32NoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	v := *p.Uint32()
+	if v == 0 {
+		return 0
+	}
+	return f.tagsize + protowire.SizeFixed32()
+}
+
+// appendFixed32NoZero wire encodes a uint32 pointer as a Fixed32.
+// The zero value is not encoded.
+func appendFixed32NoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.Uint32()
+	if v == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed32(b, v)
+	return b, nil
+}
+
+var coderFixed32NoZero = pointerCoderFuncs{
+	size:      sizeFixed32NoZero,
+	marshal:   appendFixed32NoZero,
+	unmarshal: consumeFixed32,
+	merge:     mergeUint32NoZero,
+}
+
+// sizeFixed32Ptr returns the size of wire encoding a *uint32 pointer as a Fixed32.
+// It panics if the pointer is nil.
+func sizeFixed32Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	return f.tagsize + protowire.SizeFixed32()
+}
+
+// appendFixed32Ptr wire encodes a *uint32 pointer as a Fixed32.
+// It panics if the pointer is nil.
+func appendFixed32Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := **p.Uint32Ptr()
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed32(b, v)
+	return b, nil
+}
+
+// consumeFixed32Ptr wire decodes a *uint32 pointer as a Fixed32.
+func consumeFixed32Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed32Type {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeFixed32(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	vp := p.Uint32Ptr()
+	if *vp == nil {
+		*vp = new(uint32)
+	}
+	**vp = v
+	out.n = n
+	return out, nil
+}
+
+var coderFixed32Ptr = pointerCoderFuncs{
+	size:      sizeFixed32Ptr,
+	marshal:   appendFixed32Ptr,
+	unmarshal: consumeFixed32Ptr,
+	merge:     mergeUint32Ptr,
+}
+
+// sizeFixed32Slice returns the size of wire encoding a []uint32 pointer as a repeated Fixed32.
+func sizeFixed32Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	s := *p.Uint32Slice()
+	size = len(s) * (f.tagsize + protowire.SizeFixed32())
+	return size
+}
+
+// appendFixed32Slice encodes a []uint32 pointer as a repeated Fixed32.
+func appendFixed32Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	s := *p.Uint32Slice()
+	for _, v := range s {
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendFixed32(b, v)
+	}
+	return b, nil
+}
+
+// consumeFixed32Slice wire decodes a []uint32 pointer as a repeated Fixed32.
+func consumeFixed32Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	sp := p.Uint32Slice()
+	if wtyp == protowire.BytesType {
+		s := *sp
+		b, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return out, protowire.ParseError(n)
+		}
+		for len(b) > 0 {
+			v, n := protowire.ConsumeFixed32(b)
+			if n < 0 {
+				return out, protowire.ParseError(n)
+			}
+			s = append(s, v)
+			b = b[n:]
+		}
+		*sp = s
+		out.n = n
+		return out, nil
+	}
+	if wtyp != protowire.Fixed32Type {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeFixed32(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	*sp = append(*sp, v)
+	out.n = n
+	return out, nil
+}
+
+var coderFixed32Slice = pointerCoderFuncs{
+	size:      sizeFixed32Slice,
+	marshal:   appendFixed32Slice,
+	unmarshal: consumeFixed32Slice,
+	merge:     mergeUint32Slice,
+}
+
+// sizeFixed32PackedSlice returns the size of wire encoding a []uint32 pointer as a packed repeated Fixed32.
+func sizeFixed32PackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	s := *p.Uint32Slice()
+	if len(s) == 0 {
+		return 0
+	}
+	n := len(s) * protowire.SizeFixed32()
+	return f.tagsize + protowire.SizeBytes(n)
+}
+
+// appendFixed32PackedSlice encodes a []uint32 pointer as a packed repeated Fixed32.
+func appendFixed32PackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	s := *p.Uint32Slice()
+	if len(s) == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, f.wiretag)
+	n := len(s) * protowire.SizeFixed32()
+	b = protowire.AppendVarint(b, uint64(n))
+	for _, v := range s {
+		b = protowire.AppendFixed32(b, v)
+	}
+	return b, nil
+}
+
+var coderFixed32PackedSlice = pointerCoderFuncs{
+	size:      sizeFixed32PackedSlice,
+	marshal:   appendFixed32PackedSlice,
+	unmarshal: consumeFixed32Slice,
+	merge:     mergeUint32Slice,
+}
+
+// sizeFixed32Value returns the size of wire encoding a uint32 value as a Fixed32.
+func sizeFixed32Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
+	return tagsize + protowire.SizeFixed32()
+}
+
+// appendFixed32Value encodes a uint32 value as a Fixed32.
+func appendFixed32Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendFixed32(b, uint32(v.Uint()))
+	return b, nil
+}
+
+// consumeFixed32Value decodes a uint32 value as a Fixed32.
+func consumeFixed32Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed32Type {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	v, n := protowire.ConsumeFixed32(b)
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	out.n = n
+	return protoreflect.ValueOfUint32(uint32(v)), out, nil
+}
+
+var coderFixed32Value = valueCoderFuncs{
+	size:      sizeFixed32Value,
+	marshal:   appendFixed32Value,
+	unmarshal: consumeFixed32Value,
+	merge:     mergeScalarValue,
+}
+
+// sizeFixed32SliceValue returns the size of wire encoding a []uint32 value as a repeated Fixed32.
+func sizeFixed32SliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
+	list := listv.List()
+	size = list.Len() * (tagsize + protowire.SizeFixed32())
+	return size
+}
+
+// appendFixed32SliceValue encodes a []uint32 value as a repeated Fixed32.
+func appendFixed32SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	list := listv.List()
+	for i, llen := 0, list.Len(); i < llen; i++ {
+		v := list.Get(i)
+		b = protowire.AppendVarint(b, wiretag)
+		b = protowire.AppendFixed32(b, uint32(v.Uint()))
+	}
+	return b, nil
+}
+
+// consumeFixed32SliceValue wire decodes a []uint32 value as a repeated Fixed32.
+func consumeFixed32SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	list := listv.List()
+	if wtyp == protowire.BytesType {
+		b, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return protoreflect.Value{}, out, protowire.ParseError(n)
+		}
+		for len(b) > 0 {
+			v, n := protowire.ConsumeFixed32(b)
+			if n < 0 {
+				return protoreflect.Value{}, out, protowire.ParseError(n)
+			}
+			list.Append(protoreflect.ValueOfUint32(uint32(v)))
+			b = b[n:]
+		}
+		out.n = n
+		return listv, out, nil
+	}
+	if wtyp != protowire.Fixed32Type {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	v, n := protowire.ConsumeFixed32(b)
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	list.Append(protoreflect.ValueOfUint32(uint32(v)))
+	out.n = n
+	return listv, out, nil
+}
+
+var coderFixed32SliceValue = valueCoderFuncs{
+	size:      sizeFixed32SliceValue,
+	marshal:   appendFixed32SliceValue,
+	unmarshal: consumeFixed32SliceValue,
+	merge:     mergeListValue,
+}
+
+// sizeFixed32PackedSliceValue returns the size of wire encoding a []uint32 value as a packed repeated Fixed32.
+func sizeFixed32PackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
+	list := listv.List()
+	llen := list.Len()
+	if llen == 0 {
+		return 0
+	}
+	n := llen * protowire.SizeFixed32()
+	return tagsize + protowire.SizeBytes(n)
+}
+
+// appendFixed32PackedSliceValue encodes a []uint32 value as a packed repeated Fixed32.
+func appendFixed32PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	list := listv.List()
+	llen := list.Len()
+	if llen == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, wiretag)
+	n := llen * protowire.SizeFixed32()
+	b = protowire.AppendVarint(b, uint64(n))
+	for i := 0; i < llen; i++ {
+		v := list.Get(i)
+		b = protowire.AppendFixed32(b, uint32(v.Uint()))
+	}
+	return b, nil
+}
+
+var coderFixed32PackedSliceValue = valueCoderFuncs{
+	size:      sizeFixed32PackedSliceValue,
+	marshal:   appendFixed32PackedSliceValue,
+	unmarshal: consumeFixed32SliceValue,
+	merge:     mergeListValue,
+}
+
+// sizeFloat returns the size of wire encoding a float32 pointer as a Float.
+func sizeFloat(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+
+	return f.tagsize + protowire.SizeFixed32()
+}
+
+// appendFloat wire encodes a float32 pointer as a Float.
+func appendFloat(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.Float32()
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed32(b, math.Float32bits(v))
+	return b, nil
+}
+
+// consumeFloat wire decodes a float32 pointer as a Float.
+func consumeFloat(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed32Type {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeFixed32(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	*p.Float32() = math.Float32frombits(v)
+	out.n = n
+	return out, nil
+}
+
+var coderFloat = pointerCoderFuncs{
+	size:      sizeFloat,
+	marshal:   appendFloat,
+	unmarshal: consumeFloat,
+	merge:     mergeFloat32,
+}
+
+// sizeFloatNoZero returns the size of wire encoding a float32 pointer as a Float.
+// The zero value is not encoded.
+func sizeFloatNoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	v := *p.Float32()
+	if v == 0 && !math.Signbit(float64(v)) {
+		return 0
+	}
+	return f.tagsize + protowire.SizeFixed32()
+}
+
+// appendFloatNoZero wire encodes a float32 pointer as a Float.
+// The zero value is not encoded.
+func appendFloatNoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.Float32()
+	if v == 0 && !math.Signbit(float64(v)) {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed32(b, math.Float32bits(v))
+	return b, nil
+}
+
+var coderFloatNoZero = pointerCoderFuncs{
+	size:      sizeFloatNoZero,
+	marshal:   appendFloatNoZero,
+	unmarshal: consumeFloat,
+	merge:     mergeFloat32NoZero,
+}
+
+// sizeFloatPtr returns the size of wire encoding a *float32 pointer as a Float.
+// It panics if the pointer is nil.
+func sizeFloatPtr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	return f.tagsize + protowire.SizeFixed32()
+}
+
+// appendFloatPtr wire encodes a *float32 pointer as a Float.
+// It panics if the pointer is nil.
+func appendFloatPtr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := **p.Float32Ptr()
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed32(b, math.Float32bits(v))
+	return b, nil
+}
+
+// consumeFloatPtr wire decodes a *float32 pointer as a Float.
+func consumeFloatPtr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed32Type {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeFixed32(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	vp := p.Float32Ptr()
+	if *vp == nil {
+		*vp = new(float32)
+	}
+	**vp = math.Float32frombits(v)
+	out.n = n
+	return out, nil
+}
+
+var coderFloatPtr = pointerCoderFuncs{
+	size:      sizeFloatPtr,
+	marshal:   appendFloatPtr,
+	unmarshal: consumeFloatPtr,
+	merge:     mergeFloat32Ptr,
+}
+
+// sizeFloatSlice returns the size of wire encoding a []float32 pointer as a repeated Float.
+func sizeFloatSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	s := *p.Float32Slice()
+	size = len(s) * (f.tagsize + protowire.SizeFixed32())
+	return size
+}
+
+// appendFloatSlice encodes a []float32 pointer as a repeated Float.
+func appendFloatSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	s := *p.Float32Slice()
+	for _, v := range s {
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendFixed32(b, math.Float32bits(v))
+	}
+	return b, nil
+}
+
+// consumeFloatSlice wire decodes a []float32 pointer as a repeated Float.
+func consumeFloatSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	sp := p.Float32Slice()
+	if wtyp == protowire.BytesType {
+		s := *sp
+		b, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return out, protowire.ParseError(n)
+		}
+		for len(b) > 0 {
+			v, n := protowire.ConsumeFixed32(b)
+			if n < 0 {
+				return out, protowire.ParseError(n)
+			}
+			s = append(s, math.Float32frombits(v))
+			b = b[n:]
+		}
+		*sp = s
+		out.n = n
+		return out, nil
+	}
+	if wtyp != protowire.Fixed32Type {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeFixed32(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	*sp = append(*sp, math.Float32frombits(v))
+	out.n = n
+	return out, nil
+}
+
+var coderFloatSlice = pointerCoderFuncs{
+	size:      sizeFloatSlice,
+	marshal:   appendFloatSlice,
+	unmarshal: consumeFloatSlice,
+	merge:     mergeFloat32Slice,
+}
+
+// sizeFloatPackedSlice returns the size of wire encoding a []float32 pointer as a packed repeated Float.
+func sizeFloatPackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	s := *p.Float32Slice()
+	if len(s) == 0 {
+		return 0
+	}
+	n := len(s) * protowire.SizeFixed32()
+	return f.tagsize + protowire.SizeBytes(n)
+}
+
+// appendFloatPackedSlice encodes a []float32 pointer as a packed repeated Float.
+func appendFloatPackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	s := *p.Float32Slice()
+	if len(s) == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, f.wiretag)
+	n := len(s) * protowire.SizeFixed32()
+	b = protowire.AppendVarint(b, uint64(n))
+	for _, v := range s {
+		b = protowire.AppendFixed32(b, math.Float32bits(v))
+	}
+	return b, nil
+}
+
+var coderFloatPackedSlice = pointerCoderFuncs{
+	size:      sizeFloatPackedSlice,
+	marshal:   appendFloatPackedSlice,
+	unmarshal: consumeFloatSlice,
+	merge:     mergeFloat32Slice,
+}
+
+// sizeFloatValue returns the size of wire encoding a float32 value as a Float.
+func sizeFloatValue(v protoreflect.Value, tagsize int, _ marshalOptions) int {
+	return tagsize + protowire.SizeFixed32()
+}
+
+// appendFloatValue encodes a float32 value as a Float.
+func appendFloatValue(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendFixed32(b, math.Float32bits(float32(v.Float())))
+	return b, nil
+}
+
+// consumeFloatValue decodes a float32 value as a Float.
+func consumeFloatValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed32Type {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	v, n := protowire.ConsumeFixed32(b)
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	out.n = n
+	return protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))), out, nil
+}
+
+var coderFloatValue = valueCoderFuncs{
+	size:      sizeFloatValue,
+	marshal:   appendFloatValue,
+	unmarshal: consumeFloatValue,
+	merge:     mergeScalarValue,
+}
+
+// sizeFloatSliceValue returns the size of wire encoding a []float32 value as a repeated Float.
+func sizeFloatSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
+	list := listv.List()
+	size = list.Len() * (tagsize + protowire.SizeFixed32())
+	return size
+}
+
+// appendFloatSliceValue encodes a []float32 value as a repeated Float.
+func appendFloatSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	list := listv.List()
+	for i, llen := 0, list.Len(); i < llen; i++ {
+		v := list.Get(i)
+		b = protowire.AppendVarint(b, wiretag)
+		b = protowire.AppendFixed32(b, math.Float32bits(float32(v.Float())))
+	}
+	return b, nil
+}
+
+// consumeFloatSliceValue wire decodes a []float32 value as a repeated Float.
+func consumeFloatSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	list := listv.List()
+	if wtyp == protowire.BytesType {
+		b, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return protoreflect.Value{}, out, protowire.ParseError(n)
+		}
+		for len(b) > 0 {
+			v, n := protowire.ConsumeFixed32(b)
+			if n < 0 {
+				return protoreflect.Value{}, out, protowire.ParseError(n)
+			}
+			list.Append(protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))))
+			b = b[n:]
+		}
+		out.n = n
+		return listv, out, nil
+	}
+	if wtyp != protowire.Fixed32Type {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	v, n := protowire.ConsumeFixed32(b)
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	list.Append(protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))))
+	out.n = n
+	return listv, out, nil
+}
+
+var coderFloatSliceValue = valueCoderFuncs{
+	size:      sizeFloatSliceValue,
+	marshal:   appendFloatSliceValue,
+	unmarshal: consumeFloatSliceValue,
+	merge:     mergeListValue,
+}
+
+// sizeFloatPackedSliceValue returns the size of wire encoding a []float32 value as a packed repeated Float.
+func sizeFloatPackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
+	list := listv.List()
+	llen := list.Len()
+	if llen == 0 {
+		return 0
+	}
+	n := llen * protowire.SizeFixed32()
+	return tagsize + protowire.SizeBytes(n)
+}
+
+// appendFloatPackedSliceValue encodes a []float32 value as a packed repeated Float.
+func appendFloatPackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	list := listv.List()
+	llen := list.Len()
+	if llen == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, wiretag)
+	n := llen * protowire.SizeFixed32()
+	b = protowire.AppendVarint(b, uint64(n))
+	for i := 0; i < llen; i++ {
+		v := list.Get(i)
+		b = protowire.AppendFixed32(b, math.Float32bits(float32(v.Float())))
+	}
+	return b, nil
+}
+
+var coderFloatPackedSliceValue = valueCoderFuncs{
+	size:      sizeFloatPackedSliceValue,
+	marshal:   appendFloatPackedSliceValue,
+	unmarshal: consumeFloatSliceValue,
+	merge:     mergeListValue,
+}
+
+// sizeSfixed64 returns the size of wire encoding a int64 pointer as a Sfixed64.
+func sizeSfixed64(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+
+	return f.tagsize + protowire.SizeFixed64()
+}
+
+// appendSfixed64 wire encodes a int64 pointer as a Sfixed64.
+func appendSfixed64(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.Int64()
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed64(b, uint64(v))
+	return b, nil
+}
+
+// consumeSfixed64 wire decodes a int64 pointer as a Sfixed64.
+func consumeSfixed64(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed64Type {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeFixed64(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	*p.Int64() = int64(v)
+	out.n = n
+	return out, nil
+}
+
+var coderSfixed64 = pointerCoderFuncs{
+	size:      sizeSfixed64,
+	marshal:   appendSfixed64,
+	unmarshal: consumeSfixed64,
+	merge:     mergeInt64,
+}
+
+// sizeSfixed64NoZero returns the size of wire encoding a int64 pointer as a Sfixed64.
+// The zero value is not encoded.
+func sizeSfixed64NoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	v := *p.Int64()
+	if v == 0 {
+		return 0
+	}
+	return f.tagsize + protowire.SizeFixed64()
+}
+
+// appendSfixed64NoZero wire encodes a int64 pointer as a Sfixed64.
+// The zero value is not encoded.
+func appendSfixed64NoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.Int64()
+	if v == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed64(b, uint64(v))
+	return b, nil
+}
+
+var coderSfixed64NoZero = pointerCoderFuncs{
+	size:      sizeSfixed64NoZero,
+	marshal:   appendSfixed64NoZero,
+	unmarshal: consumeSfixed64,
+	merge:     mergeInt64NoZero,
+}
+
+// sizeSfixed64Ptr returns the size of wire encoding a *int64 pointer as a Sfixed64.
+// It panics if the pointer is nil.
+func sizeSfixed64Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	return f.tagsize + protowire.SizeFixed64()
+}
+
+// appendSfixed64Ptr wire encodes a *int64 pointer as a Sfixed64.
+// It panics if the pointer is nil.
+func appendSfixed64Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := **p.Int64Ptr()
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed64(b, uint64(v))
+	return b, nil
+}
+
+// consumeSfixed64Ptr wire decodes a *int64 pointer as a Sfixed64.
+func consumeSfixed64Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed64Type {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeFixed64(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	vp := p.Int64Ptr()
+	if *vp == nil {
+		*vp = new(int64)
+	}
+	**vp = int64(v)
+	out.n = n
+	return out, nil
+}
+
+var coderSfixed64Ptr = pointerCoderFuncs{
+	size:      sizeSfixed64Ptr,
+	marshal:   appendSfixed64Ptr,
+	unmarshal: consumeSfixed64Ptr,
+	merge:     mergeInt64Ptr,
+}
+
+// sizeSfixed64Slice returns the size of wire encoding a []int64 pointer as a repeated Sfixed64.
+func sizeSfixed64Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	s := *p.Int64Slice()
+	size = len(s) * (f.tagsize + protowire.SizeFixed64())
+	return size
+}
+
+// appendSfixed64Slice encodes a []int64 pointer as a repeated Sfixed64.
+func appendSfixed64Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	s := *p.Int64Slice()
+	for _, v := range s {
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendFixed64(b, uint64(v))
+	}
+	return b, nil
+}
+
+// consumeSfixed64Slice wire decodes a []int64 pointer as a repeated Sfixed64.
+func consumeSfixed64Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	sp := p.Int64Slice()
+	if wtyp == protowire.BytesType {
+		s := *sp
+		b, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return out, protowire.ParseError(n)
+		}
+		for len(b) > 0 {
+			v, n := protowire.ConsumeFixed64(b)
+			if n < 0 {
+				return out, protowire.ParseError(n)
+			}
+			s = append(s, int64(v))
+			b = b[n:]
+		}
+		*sp = s
+		out.n = n
+		return out, nil
+	}
+	if wtyp != protowire.Fixed64Type {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeFixed64(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	*sp = append(*sp, int64(v))
+	out.n = n
+	return out, nil
+}
+
+var coderSfixed64Slice = pointerCoderFuncs{
+	size:      sizeSfixed64Slice,
+	marshal:   appendSfixed64Slice,
+	unmarshal: consumeSfixed64Slice,
+	merge:     mergeInt64Slice,
+}
+
+// sizeSfixed64PackedSlice returns the size of wire encoding a []int64 pointer as a packed repeated Sfixed64.
+func sizeSfixed64PackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	s := *p.Int64Slice()
+	if len(s) == 0 {
+		return 0
+	}
+	n := len(s) * protowire.SizeFixed64()
+	return f.tagsize + protowire.SizeBytes(n)
+}
+
+// appendSfixed64PackedSlice encodes a []int64 pointer as a packed repeated Sfixed64.
+func appendSfixed64PackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	s := *p.Int64Slice()
+	if len(s) == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, f.wiretag)
+	n := len(s) * protowire.SizeFixed64()
+	b = protowire.AppendVarint(b, uint64(n))
+	for _, v := range s {
+		b = protowire.AppendFixed64(b, uint64(v))
+	}
+	return b, nil
+}
+
+var coderSfixed64PackedSlice = pointerCoderFuncs{
+	size:      sizeSfixed64PackedSlice,
+	marshal:   appendSfixed64PackedSlice,
+	unmarshal: consumeSfixed64Slice,
+	merge:     mergeInt64Slice,
+}
+
+// sizeSfixed64Value returns the size of wire encoding a int64 value as a Sfixed64.
+func sizeSfixed64Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
+	return tagsize + protowire.SizeFixed64()
+}
+
+// appendSfixed64Value encodes a int64 value as a Sfixed64.
+func appendSfixed64Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendFixed64(b, uint64(v.Int()))
+	return b, nil
+}
+
+// consumeSfixed64Value decodes a int64 value as a Sfixed64.
+func consumeSfixed64Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed64Type {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	v, n := protowire.ConsumeFixed64(b)
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	out.n = n
+	return protoreflect.ValueOfInt64(int64(v)), out, nil
+}
+
+var coderSfixed64Value = valueCoderFuncs{
+	size:      sizeSfixed64Value,
+	marshal:   appendSfixed64Value,
+	unmarshal: consumeSfixed64Value,
+	merge:     mergeScalarValue,
+}
+
+// sizeSfixed64SliceValue returns the size of wire encoding a []int64 value as a repeated Sfixed64.
+func sizeSfixed64SliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
+	list := listv.List()
+	size = list.Len() * (tagsize + protowire.SizeFixed64())
+	return size
+}
+
+// appendSfixed64SliceValue encodes a []int64 value as a repeated Sfixed64.
+func appendSfixed64SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	list := listv.List()
+	for i, llen := 0, list.Len(); i < llen; i++ {
+		v := list.Get(i)
+		b = protowire.AppendVarint(b, wiretag)
+		b = protowire.AppendFixed64(b, uint64(v.Int()))
+	}
+	return b, nil
+}
+
+// consumeSfixed64SliceValue wire decodes a []int64 value as a repeated Sfixed64.
+func consumeSfixed64SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	list := listv.List()
+	if wtyp == protowire.BytesType {
+		b, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return protoreflect.Value{}, out, protowire.ParseError(n)
+		}
+		for len(b) > 0 {
+			v, n := protowire.ConsumeFixed64(b)
+			if n < 0 {
+				return protoreflect.Value{}, out, protowire.ParseError(n)
+			}
+			list.Append(protoreflect.ValueOfInt64(int64(v)))
+			b = b[n:]
+		}
+		out.n = n
+		return listv, out, nil
+	}
+	if wtyp != protowire.Fixed64Type {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	v, n := protowire.ConsumeFixed64(b)
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	list.Append(protoreflect.ValueOfInt64(int64(v)))
+	out.n = n
+	return listv, out, nil
+}
+
+var coderSfixed64SliceValue = valueCoderFuncs{
+	size:      sizeSfixed64SliceValue,
+	marshal:   appendSfixed64SliceValue,
+	unmarshal: consumeSfixed64SliceValue,
+	merge:     mergeListValue,
+}
+
+// sizeSfixed64PackedSliceValue returns the size of wire encoding a []int64 value as a packed repeated Sfixed64.
+func sizeSfixed64PackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
+	list := listv.List()
+	llen := list.Len()
+	if llen == 0 {
+		return 0
+	}
+	n := llen * protowire.SizeFixed64()
+	return tagsize + protowire.SizeBytes(n)
+}
+
+// appendSfixed64PackedSliceValue encodes a []int64 value as a packed repeated Sfixed64.
+func appendSfixed64PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	list := listv.List()
+	llen := list.Len()
+	if llen == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, wiretag)
+	n := llen * protowire.SizeFixed64()
+	b = protowire.AppendVarint(b, uint64(n))
+	for i := 0; i < llen; i++ {
+		v := list.Get(i)
+		b = protowire.AppendFixed64(b, uint64(v.Int()))
+	}
+	return b, nil
+}
+
+var coderSfixed64PackedSliceValue = valueCoderFuncs{
+	size:      sizeSfixed64PackedSliceValue,
+	marshal:   appendSfixed64PackedSliceValue,
+	unmarshal: consumeSfixed64SliceValue,
+	merge:     mergeListValue,
+}
+
+// sizeFixed64 returns the size of wire encoding a uint64 pointer as a Fixed64.
+func sizeFixed64(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+
+	return f.tagsize + protowire.SizeFixed64()
+}
+
+// appendFixed64 wire encodes a uint64 pointer as a Fixed64.
+func appendFixed64(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.Uint64()
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed64(b, v)
+	return b, nil
+}
+
+// consumeFixed64 wire decodes a uint64 pointer as a Fixed64.
+func consumeFixed64(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed64Type {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeFixed64(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	*p.Uint64() = v
+	out.n = n
+	return out, nil
+}
+
+var coderFixed64 = pointerCoderFuncs{
+	size:      sizeFixed64,
+	marshal:   appendFixed64,
+	unmarshal: consumeFixed64,
+	merge:     mergeUint64,
+}
+
+// sizeFixed64NoZero returns the size of wire encoding a uint64 pointer as a Fixed64.
+// The zero value is not encoded.
+func sizeFixed64NoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	v := *p.Uint64()
+	if v == 0 {
+		return 0
+	}
+	return f.tagsize + protowire.SizeFixed64()
+}
+
+// appendFixed64NoZero wire encodes a uint64 pointer as a Fixed64.
+// The zero value is not encoded.
+func appendFixed64NoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.Uint64()
+	if v == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed64(b, v)
+	return b, nil
+}
+
+var coderFixed64NoZero = pointerCoderFuncs{
+	size:      sizeFixed64NoZero,
+	marshal:   appendFixed64NoZero,
+	unmarshal: consumeFixed64,
+	merge:     mergeUint64NoZero,
+}
+
+// sizeFixed64Ptr returns the size of wire encoding a *uint64 pointer as a Fixed64.
+// It panics if the pointer is nil.
+func sizeFixed64Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	return f.tagsize + protowire.SizeFixed64()
+}
+
+// appendFixed64Ptr wire encodes a *uint64 pointer as a Fixed64.
+// It panics if the pointer is nil.
+func appendFixed64Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := **p.Uint64Ptr()
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed64(b, v)
+	return b, nil
+}
+
+// consumeFixed64Ptr wire decodes a *uint64 pointer as a Fixed64.
+func consumeFixed64Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed64Type {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeFixed64(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	vp := p.Uint64Ptr()
+	if *vp == nil {
+		*vp = new(uint64)
+	}
+	**vp = v
+	out.n = n
+	return out, nil
+}
+
+var coderFixed64Ptr = pointerCoderFuncs{
+	size:      sizeFixed64Ptr,
+	marshal:   appendFixed64Ptr,
+	unmarshal: consumeFixed64Ptr,
+	merge:     mergeUint64Ptr,
+}
+
+// sizeFixed64Slice returns the size of wire encoding a []uint64 pointer as a repeated Fixed64.
+func sizeFixed64Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	s := *p.Uint64Slice()
+	size = len(s) * (f.tagsize + protowire.SizeFixed64())
+	return size
+}
+
+// appendFixed64Slice encodes a []uint64 pointer as a repeated Fixed64.
+func appendFixed64Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	s := *p.Uint64Slice()
+	for _, v := range s {
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendFixed64(b, v)
+	}
+	return b, nil
+}
+
+// consumeFixed64Slice wire decodes a []uint64 pointer as a repeated Fixed64.
+func consumeFixed64Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	sp := p.Uint64Slice()
+	if wtyp == protowire.BytesType {
+		s := *sp
+		b, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return out, protowire.ParseError(n)
+		}
+		for len(b) > 0 {
+			v, n := protowire.ConsumeFixed64(b)
+			if n < 0 {
+				return out, protowire.ParseError(n)
+			}
+			s = append(s, v)
+			b = b[n:]
+		}
+		*sp = s
+		out.n = n
+		return out, nil
+	}
+	if wtyp != protowire.Fixed64Type {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeFixed64(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	*sp = append(*sp, v)
+	out.n = n
+	return out, nil
+}
+
+var coderFixed64Slice = pointerCoderFuncs{
+	size:      sizeFixed64Slice,
+	marshal:   appendFixed64Slice,
+	unmarshal: consumeFixed64Slice,
+	merge:     mergeUint64Slice,
+}
+
+// sizeFixed64PackedSlice returns the size of wire encoding a []uint64 pointer as a packed repeated Fixed64.
+func sizeFixed64PackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	s := *p.Uint64Slice()
+	if len(s) == 0 {
+		return 0
+	}
+	n := len(s) * protowire.SizeFixed64()
+	return f.tagsize + protowire.SizeBytes(n)
+}
+
+// appendFixed64PackedSlice encodes a []uint64 pointer as a packed repeated Fixed64.
+func appendFixed64PackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	s := *p.Uint64Slice()
+	if len(s) == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, f.wiretag)
+	n := len(s) * protowire.SizeFixed64()
+	b = protowire.AppendVarint(b, uint64(n))
+	for _, v := range s {
+		b = protowire.AppendFixed64(b, v)
+	}
+	return b, nil
+}
+
+var coderFixed64PackedSlice = pointerCoderFuncs{
+	size:      sizeFixed64PackedSlice,
+	marshal:   appendFixed64PackedSlice,
+	unmarshal: consumeFixed64Slice,
+	merge:     mergeUint64Slice,
+}
+
+// sizeFixed64Value returns the size of wire encoding a uint64 value as a Fixed64.
+func sizeFixed64Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
+	return tagsize + protowire.SizeFixed64()
+}
+
+// appendFixed64Value encodes a uint64 value as a Fixed64.
+func appendFixed64Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendFixed64(b, v.Uint())
+	return b, nil
+}
+
+// consumeFixed64Value decodes a uint64 value as a Fixed64.
+func consumeFixed64Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed64Type {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	v, n := protowire.ConsumeFixed64(b)
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	out.n = n
+	return protoreflect.ValueOfUint64(v), out, nil
+}
+
+var coderFixed64Value = valueCoderFuncs{
+	size:      sizeFixed64Value,
+	marshal:   appendFixed64Value,
+	unmarshal: consumeFixed64Value,
+	merge:     mergeScalarValue,
+}
+
+// sizeFixed64SliceValue returns the size of wire encoding a []uint64 value as a repeated Fixed64.
+func sizeFixed64SliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
+	list := listv.List()
+	size = list.Len() * (tagsize + protowire.SizeFixed64())
+	return size
+}
+
+// appendFixed64SliceValue encodes a []uint64 value as a repeated Fixed64.
+func appendFixed64SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	list := listv.List()
+	for i, llen := 0, list.Len(); i < llen; i++ {
+		v := list.Get(i)
+		b = protowire.AppendVarint(b, wiretag)
+		b = protowire.AppendFixed64(b, v.Uint())
+	}
+	return b, nil
+}
+
+// consumeFixed64SliceValue wire decodes a []uint64 value as a repeated Fixed64.
+func consumeFixed64SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	list := listv.List()
+	if wtyp == protowire.BytesType {
+		b, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return protoreflect.Value{}, out, protowire.ParseError(n)
+		}
+		for len(b) > 0 {
+			v, n := protowire.ConsumeFixed64(b)
+			if n < 0 {
+				return protoreflect.Value{}, out, protowire.ParseError(n)
+			}
+			list.Append(protoreflect.ValueOfUint64(v))
+			b = b[n:]
+		}
+		out.n = n
+		return listv, out, nil
+	}
+	if wtyp != protowire.Fixed64Type {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	v, n := protowire.ConsumeFixed64(b)
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	list.Append(protoreflect.ValueOfUint64(v))
+	out.n = n
+	return listv, out, nil
+}
+
+var coderFixed64SliceValue = valueCoderFuncs{
+	size:      sizeFixed64SliceValue,
+	marshal:   appendFixed64SliceValue,
+	unmarshal: consumeFixed64SliceValue,
+	merge:     mergeListValue,
+}
+
+// sizeFixed64PackedSliceValue returns the size of wire encoding a []uint64 value as a packed repeated Fixed64.
+func sizeFixed64PackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
+	list := listv.List()
+	llen := list.Len()
+	if llen == 0 {
+		return 0
+	}
+	n := llen * protowire.SizeFixed64()
+	return tagsize + protowire.SizeBytes(n)
+}
+
+// appendFixed64PackedSliceValue encodes a []uint64 value as a packed repeated Fixed64.
+func appendFixed64PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	list := listv.List()
+	llen := list.Len()
+	if llen == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, wiretag)
+	n := llen * protowire.SizeFixed64()
+	b = protowire.AppendVarint(b, uint64(n))
+	for i := 0; i < llen; i++ {
+		v := list.Get(i)
+		b = protowire.AppendFixed64(b, v.Uint())
+	}
+	return b, nil
+}
+
+var coderFixed64PackedSliceValue = valueCoderFuncs{
+	size:      sizeFixed64PackedSliceValue,
+	marshal:   appendFixed64PackedSliceValue,
+	unmarshal: consumeFixed64SliceValue,
+	merge:     mergeListValue,
+}
+
+// sizeDouble returns the size of wire encoding a float64 pointer as a Double.
+func sizeDouble(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+
+	return f.tagsize + protowire.SizeFixed64()
+}
+
+// appendDouble wire encodes a float64 pointer as a Double.
+func appendDouble(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.Float64()
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed64(b, math.Float64bits(v))
+	return b, nil
+}
+
+// consumeDouble wire decodes a float64 pointer as a Double.
+func consumeDouble(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed64Type {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeFixed64(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	*p.Float64() = math.Float64frombits(v)
+	out.n = n
+	return out, nil
+}
+
+var coderDouble = pointerCoderFuncs{
+	size:      sizeDouble,
+	marshal:   appendDouble,
+	unmarshal: consumeDouble,
+	merge:     mergeFloat64,
+}
+
+// sizeDoubleNoZero returns the size of wire encoding a float64 pointer as a Double.
+// The zero value is not encoded.
+func sizeDoubleNoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	v := *p.Float64()
+	if v == 0 && !math.Signbit(float64(v)) {
+		return 0
+	}
+	return f.tagsize + protowire.SizeFixed64()
+}
+
+// appendDoubleNoZero wire encodes a float64 pointer as a Double.
+// The zero value is not encoded.
+func appendDoubleNoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.Float64()
+	if v == 0 && !math.Signbit(float64(v)) {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed64(b, math.Float64bits(v))
+	return b, nil
+}
+
+var coderDoubleNoZero = pointerCoderFuncs{
+	size:      sizeDoubleNoZero,
+	marshal:   appendDoubleNoZero,
+	unmarshal: consumeDouble,
+	merge:     mergeFloat64NoZero,
+}
+
+// sizeDoublePtr returns the size of wire encoding a *float64 pointer as a Double.
+// It panics if the pointer is nil.
+func sizeDoublePtr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	return f.tagsize + protowire.SizeFixed64()
+}
+
+// appendDoublePtr wire encodes a *float64 pointer as a Double.
+// It panics if the pointer is nil.
+func appendDoublePtr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := **p.Float64Ptr()
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed64(b, math.Float64bits(v))
+	return b, nil
+}
+
+// consumeDoublePtr wire decodes a *float64 pointer as a Double.
+func consumeDoublePtr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed64Type {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeFixed64(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	vp := p.Float64Ptr()
+	if *vp == nil {
+		*vp = new(float64)
+	}
+	**vp = math.Float64frombits(v)
+	out.n = n
+	return out, nil
+}
+
+var coderDoublePtr = pointerCoderFuncs{
+	size:      sizeDoublePtr,
+	marshal:   appendDoublePtr,
+	unmarshal: consumeDoublePtr,
+	merge:     mergeFloat64Ptr,
+}
+
+// sizeDoubleSlice returns the size of wire encoding a []float64 pointer as a repeated Double.
+func sizeDoubleSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	s := *p.Float64Slice()
+	size = len(s) * (f.tagsize + protowire.SizeFixed64())
+	return size
+}
+
+// appendDoubleSlice encodes a []float64 pointer as a repeated Double.
+func appendDoubleSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	s := *p.Float64Slice()
+	for _, v := range s {
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendFixed64(b, math.Float64bits(v))
+	}
+	return b, nil
+}
+
+// consumeDoubleSlice wire decodes a []float64 pointer as a repeated Double.
+func consumeDoubleSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	sp := p.Float64Slice()
+	if wtyp == protowire.BytesType {
+		s := *sp
+		b, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return out, protowire.ParseError(n)
+		}
+		for len(b) > 0 {
+			v, n := protowire.ConsumeFixed64(b)
+			if n < 0 {
+				return out, protowire.ParseError(n)
+			}
+			s = append(s, math.Float64frombits(v))
+			b = b[n:]
+		}
+		*sp = s
+		out.n = n
+		return out, nil
+	}
+	if wtyp != protowire.Fixed64Type {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeFixed64(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	*sp = append(*sp, math.Float64frombits(v))
+	out.n = n
+	return out, nil
+}
+
+var coderDoubleSlice = pointerCoderFuncs{
+	size:      sizeDoubleSlice,
+	marshal:   appendDoubleSlice,
+	unmarshal: consumeDoubleSlice,
+	merge:     mergeFloat64Slice,
+}
+
+// sizeDoublePackedSlice returns the size of wire encoding a []float64 pointer as a packed repeated Double.
+func sizeDoublePackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	s := *p.Float64Slice()
+	if len(s) == 0 {
+		return 0
+	}
+	n := len(s) * protowire.SizeFixed64()
+	return f.tagsize + protowire.SizeBytes(n)
+}
+
+// appendDoublePackedSlice encodes a []float64 pointer as a packed repeated Double.
+func appendDoublePackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	s := *p.Float64Slice()
+	if len(s) == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, f.wiretag)
+	n := len(s) * protowire.SizeFixed64()
+	b = protowire.AppendVarint(b, uint64(n))
+	for _, v := range s {
+		b = protowire.AppendFixed64(b, math.Float64bits(v))
+	}
+	return b, nil
+}
+
+var coderDoublePackedSlice = pointerCoderFuncs{
+	size:      sizeDoublePackedSlice,
+	marshal:   appendDoublePackedSlice,
+	unmarshal: consumeDoubleSlice,
+	merge:     mergeFloat64Slice,
+}
+
+// sizeDoubleValue returns the size of wire encoding a float64 value as a Double.
+func sizeDoubleValue(v protoreflect.Value, tagsize int, _ marshalOptions) int {
+	return tagsize + protowire.SizeFixed64()
+}
+
+// appendDoubleValue encodes a float64 value as a Double.
+func appendDoubleValue(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendFixed64(b, math.Float64bits(v.Float()))
+	return b, nil
+}
+
+// consumeDoubleValue decodes a float64 value as a Double.
+func consumeDoubleValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed64Type {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	v, n := protowire.ConsumeFixed64(b)
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	out.n = n
+	return protoreflect.ValueOfFloat64(math.Float64frombits(v)), out, nil
+}
+
+var coderDoubleValue = valueCoderFuncs{
+	size:      sizeDoubleValue,
+	marshal:   appendDoubleValue,
+	unmarshal: consumeDoubleValue,
+	merge:     mergeScalarValue,
+}
+
+// sizeDoubleSliceValue returns the size of wire encoding a []float64 value as a repeated Double.
+func sizeDoubleSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
+	list := listv.List()
+	size = list.Len() * (tagsize + protowire.SizeFixed64())
+	return size
+}
+
+// appendDoubleSliceValue encodes a []float64 value as a repeated Double.
+func appendDoubleSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	list := listv.List()
+	for i, llen := 0, list.Len(); i < llen; i++ {
+		v := list.Get(i)
+		b = protowire.AppendVarint(b, wiretag)
+		b = protowire.AppendFixed64(b, math.Float64bits(v.Float()))
+	}
+	return b, nil
+}
+
+// consumeDoubleSliceValue wire decodes a []float64 value as a repeated Double.
+func consumeDoubleSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	list := listv.List()
+	if wtyp == protowire.BytesType {
+		b, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return protoreflect.Value{}, out, protowire.ParseError(n)
+		}
+		for len(b) > 0 {
+			v, n := protowire.ConsumeFixed64(b)
+			if n < 0 {
+				return protoreflect.Value{}, out, protowire.ParseError(n)
+			}
+			list.Append(protoreflect.ValueOfFloat64(math.Float64frombits(v)))
+			b = b[n:]
+		}
+		out.n = n
+		return listv, out, nil
+	}
+	if wtyp != protowire.Fixed64Type {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	v, n := protowire.ConsumeFixed64(b)
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	list.Append(protoreflect.ValueOfFloat64(math.Float64frombits(v)))
+	out.n = n
+	return listv, out, nil
+}
+
+var coderDoubleSliceValue = valueCoderFuncs{
+	size:      sizeDoubleSliceValue,
+	marshal:   appendDoubleSliceValue,
+	unmarshal: consumeDoubleSliceValue,
+	merge:     mergeListValue,
+}
+
+// sizeDoublePackedSliceValue returns the size of wire encoding a []float64 value as a packed repeated Double.
+func sizeDoublePackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
+	list := listv.List()
+	llen := list.Len()
+	if llen == 0 {
+		return 0
+	}
+	n := llen * protowire.SizeFixed64()
+	return tagsize + protowire.SizeBytes(n)
+}
+
+// appendDoublePackedSliceValue encodes a []float64 value as a packed repeated Double.
+func appendDoublePackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	list := listv.List()
+	llen := list.Len()
+	if llen == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, wiretag)
+	n := llen * protowire.SizeFixed64()
+	b = protowire.AppendVarint(b, uint64(n))
+	for i := 0; i < llen; i++ {
+		v := list.Get(i)
+		b = protowire.AppendFixed64(b, math.Float64bits(v.Float()))
+	}
+	return b, nil
+}
+
+var coderDoublePackedSliceValue = valueCoderFuncs{
+	size:      sizeDoublePackedSliceValue,
+	marshal:   appendDoublePackedSliceValue,
+	unmarshal: consumeDoubleSliceValue,
+	merge:     mergeListValue,
+}
+
+// sizeString returns the size of wire encoding a string pointer as a String.
+func sizeString(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	v := *p.String()
+	return f.tagsize + protowire.SizeBytes(len(v))
+}
+
+// appendString wire encodes a string pointer as a String.
+func appendString(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.String()
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendString(b, v)
+	return b, nil
+}
+
+// consumeString wire decodes a string pointer as a String.
+func consumeString(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.BytesType {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeString(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	*p.String() = v
+	out.n = n
+	return out, nil
+}
+
+var coderString = pointerCoderFuncs{
+	size:      sizeString,
+	marshal:   appendString,
+	unmarshal: consumeString,
+	merge:     mergeString,
+}
+
+// appendStringValidateUTF8 wire encodes a string pointer as a String.
+func appendStringValidateUTF8(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.String()
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendString(b, v)
+	if !utf8.ValidString(v) {
+		return b, errInvalidUTF8{}
+	}
+	return b, nil
+}
+
+// consumeStringValidateUTF8 wire decodes a string pointer as a String.
+func consumeStringValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.BytesType {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeString(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	if !utf8.ValidString(v) {
+		return out, errInvalidUTF8{}
+	}
+	*p.String() = v
+	out.n = n
+	return out, nil
+}
+
+var coderStringValidateUTF8 = pointerCoderFuncs{
+	size:      sizeString,
+	marshal:   appendStringValidateUTF8,
+	unmarshal: consumeStringValidateUTF8,
+	merge:     mergeString,
+}
+
+// sizeStringNoZero returns the size of wire encoding a string pointer as a String.
+// The zero value is not encoded.
+func sizeStringNoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	v := *p.String()
+	if len(v) == 0 {
+		return 0
+	}
+	return f.tagsize + protowire.SizeBytes(len(v))
+}
+
+// appendStringNoZero wire encodes a string pointer as a String.
+// The zero value is not encoded.
+func appendStringNoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.String()
+	if len(v) == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendString(b, v)
+	return b, nil
+}
+
+var coderStringNoZero = pointerCoderFuncs{
+	size:      sizeStringNoZero,
+	marshal:   appendStringNoZero,
+	unmarshal: consumeString,
+	merge:     mergeStringNoZero,
+}
+
+// appendStringNoZeroValidateUTF8 wire encodes a string pointer as a String.
+// The zero value is not encoded.
+func appendStringNoZeroValidateUTF8(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.String()
+	if len(v) == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendString(b, v)
+	if !utf8.ValidString(v) {
+		return b, errInvalidUTF8{}
+	}
+	return b, nil
+}
+
+var coderStringNoZeroValidateUTF8 = pointerCoderFuncs{
+	size:      sizeStringNoZero,
+	marshal:   appendStringNoZeroValidateUTF8,
+	unmarshal: consumeStringValidateUTF8,
+	merge:     mergeStringNoZero,
+}
+
+// sizeStringPtr returns the size of wire encoding a *string pointer as a String.
+// It panics if the pointer is nil.
+func sizeStringPtr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	v := **p.StringPtr()
+	return f.tagsize + protowire.SizeBytes(len(v))
+}
+
+// appendStringPtr wire encodes a *string pointer as a String.
+// It panics if the pointer is nil.
+func appendStringPtr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := **p.StringPtr()
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendString(b, v)
+	return b, nil
+}
+
+// consumeStringPtr wire decodes a *string pointer as a String.
+func consumeStringPtr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.BytesType {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeString(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	vp := p.StringPtr()
+	if *vp == nil {
+		*vp = new(string)
+	}
+	**vp = v
+	out.n = n
+	return out, nil
+}
+
+var coderStringPtr = pointerCoderFuncs{
+	size:      sizeStringPtr,
+	marshal:   appendStringPtr,
+	unmarshal: consumeStringPtr,
+	merge:     mergeStringPtr,
+}
+
+// appendStringPtrValidateUTF8 wire encodes a *string pointer as a String.
+// It panics if the pointer is nil.
+func appendStringPtrValidateUTF8(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := **p.StringPtr()
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendString(b, v)
+	if !utf8.ValidString(v) {
+		return b, errInvalidUTF8{}
+	}
+	return b, nil
+}
+
+// consumeStringPtrValidateUTF8 wire decodes a *string pointer as a String.
+func consumeStringPtrValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.BytesType {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeString(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	if !utf8.ValidString(v) {
+		return out, errInvalidUTF8{}
+	}
+	vp := p.StringPtr()
+	if *vp == nil {
+		*vp = new(string)
+	}
+	**vp = v
+	out.n = n
+	return out, nil
+}
+
+var coderStringPtrValidateUTF8 = pointerCoderFuncs{
+	size:      sizeStringPtr,
+	marshal:   appendStringPtrValidateUTF8,
+	unmarshal: consumeStringPtrValidateUTF8,
+	merge:     mergeStringPtr,
+}
+
+// sizeStringSlice returns the size of wire encoding a []string pointer as a repeated String.
+func sizeStringSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	s := *p.StringSlice()
+	for _, v := range s {
+		size += f.tagsize + protowire.SizeBytes(len(v))
+	}
+	return size
+}
+
+// appendStringSlice encodes a []string pointer as a repeated String.
+func appendStringSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	s := *p.StringSlice()
+	for _, v := range s {
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendString(b, v)
+	}
+	return b, nil
+}
+
+// consumeStringSlice wire decodes a []string pointer as a repeated String.
+func consumeStringSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	sp := p.StringSlice()
+	if wtyp != protowire.BytesType {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeString(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	*sp = append(*sp, v)
+	out.n = n
+	return out, nil
+}
+
+var coderStringSlice = pointerCoderFuncs{
+	size:      sizeStringSlice,
+	marshal:   appendStringSlice,
+	unmarshal: consumeStringSlice,
+	merge:     mergeStringSlice,
+}
+
+// appendStringSliceValidateUTF8 encodes a []string pointer as a repeated String.
+func appendStringSliceValidateUTF8(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	s := *p.StringSlice()
+	for _, v := range s {
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendString(b, v)
+		if !utf8.ValidString(v) {
+			return b, errInvalidUTF8{}
+		}
+	}
+	return b, nil
+}
+
+// consumeStringSliceValidateUTF8 wire decodes a []string pointer as a repeated String.
+func consumeStringSliceValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	sp := p.StringSlice()
+	if wtyp != protowire.BytesType {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeString(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	if !utf8.ValidString(v) {
+		return out, errInvalidUTF8{}
+	}
+	*sp = append(*sp, v)
+	out.n = n
+	return out, nil
+}
+
+var coderStringSliceValidateUTF8 = pointerCoderFuncs{
+	size:      sizeStringSlice,
+	marshal:   appendStringSliceValidateUTF8,
+	unmarshal: consumeStringSliceValidateUTF8,
+	merge:     mergeStringSlice,
+}
+
+// sizeStringValue returns the size of wire encoding a string value as a String.
+func sizeStringValue(v protoreflect.Value, tagsize int, _ marshalOptions) int {
+	return tagsize + protowire.SizeBytes(len(v.String()))
+}
+
+// appendStringValue encodes a string value as a String.
+func appendStringValue(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendString(b, v.String())
+	return b, nil
+}
+
+// consumeStringValue decodes a string value as a String.
+func consumeStringValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != protowire.BytesType {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	v, n := protowire.ConsumeString(b)
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	out.n = n
+	return protoreflect.ValueOfString(string(v)), out, nil
+}
+
+var coderStringValue = valueCoderFuncs{
+	size:      sizeStringValue,
+	marshal:   appendStringValue,
+	unmarshal: consumeStringValue,
+	merge:     mergeScalarValue,
+}
+
+// appendStringValueValidateUTF8 encodes a string value as a String.
+func appendStringValueValidateUTF8(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendString(b, v.String())
+	if !utf8.ValidString(v.String()) {
+		return b, errInvalidUTF8{}
+	}
+	return b, nil
+}
+
+// consumeStringValueValidateUTF8 decodes a string value as a String.
+func consumeStringValueValidateUTF8(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != protowire.BytesType {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	v, n := protowire.ConsumeString(b)
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	if !utf8.ValidString(v) {
+		return protoreflect.Value{}, out, errInvalidUTF8{}
+	}
+	out.n = n
+	return protoreflect.ValueOfString(string(v)), out, nil
+}
+
+var coderStringValueValidateUTF8 = valueCoderFuncs{
+	size:      sizeStringValue,
+	marshal:   appendStringValueValidateUTF8,
+	unmarshal: consumeStringValueValidateUTF8,
+	merge:     mergeScalarValue,
+}
+
+// sizeStringSliceValue returns the size of wire encoding a []string value as a repeated String.
+func sizeStringSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
+	list := listv.List()
+	for i, llen := 0, list.Len(); i < llen; i++ {
+		v := list.Get(i)
+		size += tagsize + protowire.SizeBytes(len(v.String()))
+	}
+	return size
+}
+
+// appendStringSliceValue encodes a []string value as a repeated String.
+func appendStringSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	list := listv.List()
+	for i, llen := 0, list.Len(); i < llen; i++ {
+		v := list.Get(i)
+		b = protowire.AppendVarint(b, wiretag)
+		b = protowire.AppendString(b, v.String())
+	}
+	return b, nil
+}
+
+// consumeStringSliceValue wire decodes a []string value as a repeated String.
+func consumeStringSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	list := listv.List()
+	if wtyp != protowire.BytesType {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	v, n := protowire.ConsumeString(b)
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	list.Append(protoreflect.ValueOfString(string(v)))
+	out.n = n
+	return listv, out, nil
+}
+
+var coderStringSliceValue = valueCoderFuncs{
+	size:      sizeStringSliceValue,
+	marshal:   appendStringSliceValue,
+	unmarshal: consumeStringSliceValue,
+	merge:     mergeListValue,
+}
+
+// sizeBytes returns the size of wire encoding a []byte pointer as a Bytes.
+func sizeBytes(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	v := *p.Bytes()
+	return f.tagsize + protowire.SizeBytes(len(v))
+}
+
+// appendBytes wire encodes a []byte pointer as a Bytes.
+func appendBytes(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.Bytes()
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendBytes(b, v)
+	return b, nil
+}
+
+// consumeBytes wire decodes a []byte pointer as a Bytes.
+func consumeBytes(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.BytesType {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeBytes(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	*p.Bytes() = append(emptyBuf[:], v...)
+	out.n = n
+	return out, nil
+}
+
+var coderBytes = pointerCoderFuncs{
+	size:      sizeBytes,
+	marshal:   appendBytes,
+	unmarshal: consumeBytes,
+	merge:     mergeBytes,
+}
+
+// appendBytesValidateUTF8 wire encodes a []byte pointer as a Bytes.
+func appendBytesValidateUTF8(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.Bytes()
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendBytes(b, v)
+	if !utf8.Valid(v) {
+		return b, errInvalidUTF8{}
+	}
+	return b, nil
+}
+
+// consumeBytesValidateUTF8 wire decodes a []byte pointer as a Bytes.
+func consumeBytesValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.BytesType {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeBytes(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	if !utf8.Valid(v) {
+		return out, errInvalidUTF8{}
+	}
+	*p.Bytes() = append(emptyBuf[:], v...)
+	out.n = n
+	return out, nil
+}
+
+var coderBytesValidateUTF8 = pointerCoderFuncs{
+	size:      sizeBytes,
+	marshal:   appendBytesValidateUTF8,
+	unmarshal: consumeBytesValidateUTF8,
+	merge:     mergeBytes,
+}
+
+// sizeBytesNoZero returns the size of wire encoding a []byte pointer as a Bytes.
+// The zero value is not encoded.
+func sizeBytesNoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	v := *p.Bytes()
+	if len(v) == 0 {
+		return 0
+	}
+	return f.tagsize + protowire.SizeBytes(len(v))
+}
+
+// appendBytesNoZero wire encodes a []byte pointer as a Bytes.
+// The zero value is not encoded.
+func appendBytesNoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.Bytes()
+	if len(v) == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendBytes(b, v)
+	return b, nil
+}
+
+// consumeBytesNoZero wire decodes a []byte pointer as a Bytes.
+// The zero value is not decoded.
+func consumeBytesNoZero(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.BytesType {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeBytes(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	*p.Bytes() = append(([]byte)(nil), v...)
+	out.n = n
+	return out, nil
+}
+
+var coderBytesNoZero = pointerCoderFuncs{
+	size:      sizeBytesNoZero,
+	marshal:   appendBytesNoZero,
+	unmarshal: consumeBytesNoZero,
+	merge:     mergeBytesNoZero,
+}
+
+// appendBytesNoZeroValidateUTF8 wire encodes a []byte pointer as a Bytes.
+// The zero value is not encoded.
+func appendBytesNoZeroValidateUTF8(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	v := *p.Bytes()
+	if len(v) == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendBytes(b, v)
+	if !utf8.Valid(v) {
+		return b, errInvalidUTF8{}
+	}
+	return b, nil
+}
+
+// consumeBytesNoZeroValidateUTF8 wire decodes a []byte pointer as a Bytes.
+func consumeBytesNoZeroValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.BytesType {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeBytes(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	if !utf8.Valid(v) {
+		return out, errInvalidUTF8{}
+	}
+	*p.Bytes() = append(([]byte)(nil), v...)
+	out.n = n
+	return out, nil
+}
+
+var coderBytesNoZeroValidateUTF8 = pointerCoderFuncs{
+	size:      sizeBytesNoZero,
+	marshal:   appendBytesNoZeroValidateUTF8,
+	unmarshal: consumeBytesNoZeroValidateUTF8,
+	merge:     mergeBytesNoZero,
+}
+
+// sizeBytesSlice returns the size of wire encoding a [][]byte pointer as a repeated Bytes.
+func sizeBytesSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	s := *p.BytesSlice()
+	for _, v := range s {
+		size += f.tagsize + protowire.SizeBytes(len(v))
+	}
+	return size
+}
+
+// appendBytesSlice encodes a [][]byte pointer as a repeated Bytes.
+func appendBytesSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	s := *p.BytesSlice()
+	for _, v := range s {
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendBytes(b, v)
+	}
+	return b, nil
+}
+
+// consumeBytesSlice wire decodes a [][]byte pointer as a repeated Bytes.
+func consumeBytesSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	sp := p.BytesSlice()
+	if wtyp != protowire.BytesType {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeBytes(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	*sp = append(*sp, append(emptyBuf[:], v...))
+	out.n = n
+	return out, nil
+}
+
+var coderBytesSlice = pointerCoderFuncs{
+	size:      sizeBytesSlice,
+	marshal:   appendBytesSlice,
+	unmarshal: consumeBytesSlice,
+	merge:     mergeBytesSlice,
+}
+
+// appendBytesSliceValidateUTF8 encodes a [][]byte pointer as a repeated Bytes.
+func appendBytesSliceValidateUTF8(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
+	s := *p.BytesSlice()
+	for _, v := range s {
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendBytes(b, v)
+		if !utf8.Valid(v) {
+			return b, errInvalidUTF8{}
+		}
+	}
+	return b, nil
+}
+
+// consumeBytesSliceValidateUTF8 wire decodes a [][]byte pointer as a repeated Bytes.
+func consumeBytesSliceValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	sp := p.BytesSlice()
+	if wtyp != protowire.BytesType {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeBytes(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	if !utf8.Valid(v) {
+		return out, errInvalidUTF8{}
+	}
+	*sp = append(*sp, append(emptyBuf[:], v...))
+	out.n = n
+	return out, nil
+}
+
+var coderBytesSliceValidateUTF8 = pointerCoderFuncs{
+	size:      sizeBytesSlice,
+	marshal:   appendBytesSliceValidateUTF8,
+	unmarshal: consumeBytesSliceValidateUTF8,
+	merge:     mergeBytesSlice,
+}
+
+// sizeBytesValue returns the size of wire encoding a []byte value as a Bytes.
+func sizeBytesValue(v protoreflect.Value, tagsize int, _ marshalOptions) int {
+	return tagsize + protowire.SizeBytes(len(v.Bytes()))
+}
+
+// appendBytesValue encodes a []byte value as a Bytes.
+func appendBytesValue(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendBytes(b, v.Bytes())
+	return b, nil
+}
+
+// consumeBytesValue decodes a []byte value as a Bytes.
+func consumeBytesValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != protowire.BytesType {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	v, n := protowire.ConsumeBytes(b)
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	out.n = n
+	return protoreflect.ValueOfBytes(append(emptyBuf[:], v...)), out, nil
+}
+
+var coderBytesValue = valueCoderFuncs{
+	size:      sizeBytesValue,
+	marshal:   appendBytesValue,
+	unmarshal: consumeBytesValue,
+	merge:     mergeBytesValue,
+}
+
+// sizeBytesSliceValue returns the size of wire encoding a [][]byte value as a repeated Bytes.
+func sizeBytesSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
+	list := listv.List()
+	for i, llen := 0, list.Len(); i < llen; i++ {
+		v := list.Get(i)
+		size += tagsize + protowire.SizeBytes(len(v.Bytes()))
+	}
+	return size
+}
+
+// appendBytesSliceValue encodes a [][]byte value as a repeated Bytes.
+func appendBytesSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
+	list := listv.List()
+	for i, llen := 0, list.Len(); i < llen; i++ {
+		v := list.Get(i)
+		b = protowire.AppendVarint(b, wiretag)
+		b = protowire.AppendBytes(b, v.Bytes())
+	}
+	return b, nil
+}
+
+// consumeBytesSliceValue wire decodes a [][]byte value as a repeated Bytes.
+func consumeBytesSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	list := listv.List()
+	if wtyp != protowire.BytesType {
+		return protoreflect.Value{}, out, errUnknown
+	}
+	v, n := protowire.ConsumeBytes(b)
+	if n < 0 {
+		return protoreflect.Value{}, out, protowire.ParseError(n)
+	}
+	list.Append(protoreflect.ValueOfBytes(append(emptyBuf[:], v...)))
+	out.n = n
+	return listv, out, nil
+}
+
+var coderBytesSliceValue = valueCoderFuncs{
+	size:      sizeBytesSliceValue,
+	marshal:   appendBytesSliceValue,
+	unmarshal: consumeBytesSliceValue,
+	merge:     mergeBytesListValue,
+}
+
+// We append to an empty array rather than a nil []byte to get non-nil zero-length byte slices.
+var emptyBuf [0]byte
+
+var wireTypes = map[protoreflect.Kind]protowire.Type{
+	protoreflect.BoolKind:     protowire.VarintType,
+	protoreflect.EnumKind:     protowire.VarintType,
+	protoreflect.Int32Kind:    protowire.VarintType,
+	protoreflect.Sint32Kind:   protowire.VarintType,
+	protoreflect.Uint32Kind:   protowire.VarintType,
+	protoreflect.Int64Kind:    protowire.VarintType,
+	protoreflect.Sint64Kind:   protowire.VarintType,
+	protoreflect.Uint64Kind:   protowire.VarintType,
+	protoreflect.Sfixed32Kind: protowire.Fixed32Type,
+	protoreflect.Fixed32Kind:  protowire.Fixed32Type,
+	protoreflect.FloatKind:    protowire.Fixed32Type,
+	protoreflect.Sfixed64Kind: protowire.Fixed64Type,
+	protoreflect.Fixed64Kind:  protowire.Fixed64Type,
+	protoreflect.DoubleKind:   protowire.Fixed64Type,
+	protoreflect.StringKind:   protowire.BytesType,
+	protoreflect.BytesKind:    protowire.BytesType,
+	protoreflect.MessageKind:  protowire.BytesType,
+	protoreflect.GroupKind:    protowire.StartGroupType,
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_map.go b/vendor/google.golang.org/protobuf/internal/impl/codec_map.go
new file mode 100644
index 000000000..35a67c25b
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/codec_map.go
@@ -0,0 +1,388 @@
+// Copyright 2019 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 (
+	"errors"
+	"reflect"
+	"sort"
+
+	"google.golang.org/protobuf/encoding/protowire"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+)
+
+type mapInfo struct {
+	goType     reflect.Type
+	keyWiretag uint64
+	valWiretag uint64
+	keyFuncs   valueCoderFuncs
+	valFuncs   valueCoderFuncs
+	keyZero    pref.Value
+	keyKind    pref.Kind
+	conv       *mapConverter
+}
+
+func encoderFuncsForMap(fd pref.FieldDescriptor, ft reflect.Type) (valueMessage *MessageInfo, funcs pointerCoderFuncs) {
+	// TODO: Consider generating specialized map coders.
+	keyField := fd.MapKey()
+	valField := fd.MapValue()
+	keyWiretag := protowire.EncodeTag(1, wireTypes[keyField.Kind()])
+	valWiretag := protowire.EncodeTag(2, wireTypes[valField.Kind()])
+	keyFuncs := encoderFuncsForValue(keyField)
+	valFuncs := encoderFuncsForValue(valField)
+	conv := newMapConverter(ft, fd)
+
+	mapi := &mapInfo{
+		goType:     ft,
+		keyWiretag: keyWiretag,
+		valWiretag: valWiretag,
+		keyFuncs:   keyFuncs,
+		valFuncs:   valFuncs,
+		keyZero:    keyField.Default(),
+		keyKind:    keyField.Kind(),
+		conv:       conv,
+	}
+	if valField.Kind() == pref.MessageKind {
+		valueMessage = getMessageInfo(ft.Elem())
+	}
+
+	funcs = pointerCoderFuncs{
+		size: func(p pointer, f *coderFieldInfo, opts marshalOptions) int {
+			return sizeMap(p.AsValueOf(ft).Elem(), mapi, f, opts)
+		},
+		marshal: func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
+			return appendMap(b, p.AsValueOf(ft).Elem(), mapi, f, opts)
+		},
+		unmarshal: func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
+			mp := p.AsValueOf(ft)
+			if mp.Elem().IsNil() {
+				mp.Elem().Set(reflect.MakeMap(mapi.goType))
+			}
+			if f.mi == nil {
+				return consumeMap(b, mp.Elem(), wtyp, mapi, f, opts)
+			} else {
+				return consumeMapOfMessage(b, mp.Elem(), wtyp, mapi, f, opts)
+			}
+		},
+	}
+	switch valField.Kind() {
+	case pref.MessageKind:
+		funcs.merge = mergeMapOfMessage
+	case pref.BytesKind:
+		funcs.merge = mergeMapOfBytes
+	default:
+		funcs.merge = mergeMap
+	}
+	if valFuncs.isInit != nil {
+		funcs.isInit = func(p pointer, f *coderFieldInfo) error {
+			return isInitMap(p.AsValueOf(ft).Elem(), mapi, f)
+		}
+	}
+	return valueMessage, funcs
+}
+
+const (
+	mapKeyTagSize = 1 // field 1, tag size 1.
+	mapValTagSize = 1 // field 2, tag size 2.
+)
+
+func sizeMap(mapv reflect.Value, mapi *mapInfo, f *coderFieldInfo, opts marshalOptions) int {
+	if mapv.Len() == 0 {
+		return 0
+	}
+	n := 0
+	iter := mapRange(mapv)
+	for iter.Next() {
+		key := mapi.conv.keyConv.PBValueOf(iter.Key()).MapKey()
+		keySize := mapi.keyFuncs.size(key.Value(), mapKeyTagSize, opts)
+		var valSize int
+		value := mapi.conv.valConv.PBValueOf(iter.Value())
+		if f.mi == nil {
+			valSize = mapi.valFuncs.size(value, mapValTagSize, opts)
+		} else {
+			p := pointerOfValue(iter.Value())
+			valSize += mapValTagSize
+			valSize += protowire.SizeBytes(f.mi.sizePointer(p, opts))
+		}
+		n += f.tagsize + protowire.SizeBytes(keySize+valSize)
+	}
+	return n
+}
+
+func consumeMap(b []byte, mapv reflect.Value, wtyp protowire.Type, mapi *mapInfo, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.BytesType {
+		return out, errUnknown
+	}
+	b, n := protowire.ConsumeBytes(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	var (
+		key = mapi.keyZero
+		val = mapi.conv.valConv.New()
+	)
+	for len(b) > 0 {
+		num, wtyp, n := protowire.ConsumeTag(b)
+		if n < 0 {
+			return out, protowire.ParseError(n)
+		}
+		if num > protowire.MaxValidNumber {
+			return out, errors.New("invalid field number")
+		}
+		b = b[n:]
+		err := errUnknown
+		switch num {
+		case 1:
+			var v pref.Value
+			var o unmarshalOutput
+			v, o, err = mapi.keyFuncs.unmarshal(b, key, num, wtyp, opts)
+			if err != nil {
+				break
+			}
+			key = v
+			n = o.n
+		case 2:
+			var v pref.Value
+			var o unmarshalOutput
+			v, o, err = mapi.valFuncs.unmarshal(b, val, num, wtyp, opts)
+			if err != nil {
+				break
+			}
+			val = v
+			n = o.n
+		}
+		if err == errUnknown {
+			n = protowire.ConsumeFieldValue(num, wtyp, b)
+			if n < 0 {
+				return out, protowire.ParseError(n)
+			}
+		} else if err != nil {
+			return out, err
+		}
+		b = b[n:]
+	}
+	mapv.SetMapIndex(mapi.conv.keyConv.GoValueOf(key), mapi.conv.valConv.GoValueOf(val))
+	out.n = n
+	return out, nil
+}
+
+func consumeMapOfMessage(b []byte, mapv reflect.Value, wtyp protowire.Type, mapi *mapInfo, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.BytesType {
+		return out, errUnknown
+	}
+	b, n := protowire.ConsumeBytes(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	var (
+		key = mapi.keyZero
+		val = reflect.New(f.mi.GoReflectType.Elem())
+	)
+	for len(b) > 0 {
+		num, wtyp, n := protowire.ConsumeTag(b)
+		if n < 0 {
+			return out, protowire.ParseError(n)
+		}
+		if num > protowire.MaxValidNumber {
+			return out, errors.New("invalid field number")
+		}
+		b = b[n:]
+		err := errUnknown
+		switch num {
+		case 1:
+			var v pref.Value
+			var o unmarshalOutput
+			v, o, err = mapi.keyFuncs.unmarshal(b, key, num, wtyp, opts)
+			if err != nil {
+				break
+			}
+			key = v
+			n = o.n
+		case 2:
+			if wtyp != protowire.BytesType {
+				break
+			}
+			var v []byte
+			v, n = protowire.ConsumeBytes(b)
+			if n < 0 {
+				return out, protowire.ParseError(n)
+			}
+			var o unmarshalOutput
+			o, err = f.mi.unmarshalPointer(v, pointerOfValue(val), 0, opts)
+			if o.initialized {
+				// Consider this map item initialized so long as we see
+				// an initialized value.
+				out.initialized = true
+			}
+		}
+		if err == errUnknown {
+			n = protowire.ConsumeFieldValue(num, wtyp, b)
+			if n < 0 {
+				return out, protowire.ParseError(n)
+			}
+		} else if err != nil {
+			return out, err
+		}
+		b = b[n:]
+	}
+	mapv.SetMapIndex(mapi.conv.keyConv.GoValueOf(key), val)
+	out.n = n
+	return out, nil
+}
+
+func appendMapItem(b []byte, keyrv, valrv reflect.Value, mapi *mapInfo, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
+	if f.mi == nil {
+		key := mapi.conv.keyConv.PBValueOf(keyrv).MapKey()
+		val := mapi.conv.valConv.PBValueOf(valrv)
+		size := 0
+		size += mapi.keyFuncs.size(key.Value(), mapKeyTagSize, opts)
+		size += mapi.valFuncs.size(val, mapValTagSize, opts)
+		b = protowire.AppendVarint(b, uint64(size))
+		b, err := mapi.keyFuncs.marshal(b, key.Value(), mapi.keyWiretag, opts)
+		if err != nil {
+			return nil, err
+		}
+		return mapi.valFuncs.marshal(b, val, mapi.valWiretag, opts)
+	} else {
+		key := mapi.conv.keyConv.PBValueOf(keyrv).MapKey()
+		val := pointerOfValue(valrv)
+		valSize := f.mi.sizePointer(val, opts)
+		size := 0
+		size += mapi.keyFuncs.size(key.Value(), mapKeyTagSize, opts)
+		size += mapValTagSize + protowire.SizeBytes(valSize)
+		b = protowire.AppendVarint(b, uint64(size))
+		b, err := mapi.keyFuncs.marshal(b, key.Value(), mapi.keyWiretag, opts)
+		if err != nil {
+			return nil, err
+		}
+		b = protowire.AppendVarint(b, mapi.valWiretag)
+		b = protowire.AppendVarint(b, uint64(valSize))
+		return f.mi.marshalAppendPointer(b, val, opts)
+	}
+}
+
+func appendMap(b []byte, mapv reflect.Value, mapi *mapInfo, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
+	if mapv.Len() == 0 {
+		return b, nil
+	}
+	if opts.Deterministic() {
+		return appendMapDeterministic(b, mapv, mapi, f, opts)
+	}
+	iter := mapRange(mapv)
+	for iter.Next() {
+		var err error
+		b = protowire.AppendVarint(b, f.wiretag)
+		b, err = appendMapItem(b, iter.Key(), iter.Value(), mapi, f, opts)
+		if err != nil {
+			return b, err
+		}
+	}
+	return b, nil
+}
+
+func appendMapDeterministic(b []byte, mapv reflect.Value, mapi *mapInfo, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
+	keys := mapv.MapKeys()
+	sort.Slice(keys, func(i, j int) bool {
+		switch keys[i].Kind() {
+		case reflect.Bool:
+			return !keys[i].Bool() && keys[j].Bool()
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			return keys[i].Int() < keys[j].Int()
+		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+			return keys[i].Uint() < keys[j].Uint()
+		case reflect.Float32, reflect.Float64:
+			return keys[i].Float() < keys[j].Float()
+		case reflect.String:
+			return keys[i].String() < keys[j].String()
+		default:
+			panic("invalid kind: " + keys[i].Kind().String())
+		}
+	})
+	for _, key := range keys {
+		var err error
+		b = protowire.AppendVarint(b, f.wiretag)
+		b, err = appendMapItem(b, key, mapv.MapIndex(key), mapi, f, opts)
+		if err != nil {
+			return b, err
+		}
+	}
+	return b, nil
+}
+
+func isInitMap(mapv reflect.Value, mapi *mapInfo, f *coderFieldInfo) error {
+	if mi := f.mi; mi != nil {
+		mi.init()
+		if !mi.needsInitCheck {
+			return nil
+		}
+		iter := mapRange(mapv)
+		for iter.Next() {
+			val := pointerOfValue(iter.Value())
+			if err := mi.checkInitializedPointer(val); err != nil {
+				return err
+			}
+		}
+	} else {
+		iter := mapRange(mapv)
+		for iter.Next() {
+			val := mapi.conv.valConv.PBValueOf(iter.Value())
+			if err := mapi.valFuncs.isInit(val); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func mergeMap(dst, src pointer, f *coderFieldInfo, opts mergeOptions) {
+	dstm := dst.AsValueOf(f.ft).Elem()
+	srcm := src.AsValueOf(f.ft).Elem()
+	if srcm.Len() == 0 {
+		return
+	}
+	if dstm.IsNil() {
+		dstm.Set(reflect.MakeMap(f.ft))
+	}
+	iter := mapRange(srcm)
+	for iter.Next() {
+		dstm.SetMapIndex(iter.Key(), iter.Value())
+	}
+}
+
+func mergeMapOfBytes(dst, src pointer, f *coderFieldInfo, opts mergeOptions) {
+	dstm := dst.AsValueOf(f.ft).Elem()
+	srcm := src.AsValueOf(f.ft).Elem()
+	if srcm.Len() == 0 {
+		return
+	}
+	if dstm.IsNil() {
+		dstm.Set(reflect.MakeMap(f.ft))
+	}
+	iter := mapRange(srcm)
+	for iter.Next() {
+		dstm.SetMapIndex(iter.Key(), reflect.ValueOf(append(emptyBuf[:], iter.Value().Bytes()...)))
+	}
+}
+
+func mergeMapOfMessage(dst, src pointer, f *coderFieldInfo, opts mergeOptions) {
+	dstm := dst.AsValueOf(f.ft).Elem()
+	srcm := src.AsValueOf(f.ft).Elem()
+	if srcm.Len() == 0 {
+		return
+	}
+	if dstm.IsNil() {
+		dstm.Set(reflect.MakeMap(f.ft))
+	}
+	iter := mapRange(srcm)
+	for iter.Next() {
+		val := reflect.New(f.ft.Elem().Elem())
+		if f.mi != nil {
+			f.mi.mergePointer(pointerOfValue(val), pointerOfValue(iter.Value()), opts)
+		} else {
+			opts.Merge(asMessage(val), asMessage(iter.Value()))
+		}
+		dstm.SetMapIndex(iter.Key(), val)
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_map_go111.go b/vendor/google.golang.org/protobuf/internal/impl/codec_map_go111.go
new file mode 100644
index 000000000..2706bb67f
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/codec_map_go111.go
@@ -0,0 +1,37 @@
+// Copyright 2019 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.
+
+// +build !go1.12
+
+package impl
+
+import "reflect"
+
+type mapIter struct {
+	v    reflect.Value
+	keys []reflect.Value
+}
+
+// mapRange provides a less-efficient equivalent to
+// the Go 1.12 reflect.Value.MapRange method.
+func mapRange(v reflect.Value) *mapIter {
+	return &mapIter{v: v}
+}
+
+func (i *mapIter) Next() bool {
+	if i.keys == nil {
+		i.keys = i.v.MapKeys()
+	} else {
+		i.keys = i.keys[1:]
+	}
+	return len(i.keys) > 0
+}
+
+func (i *mapIter) Key() reflect.Value {
+	return i.keys[0]
+}
+
+func (i *mapIter) Value() reflect.Value {
+	return i.v.MapIndex(i.keys[0])
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_map_go112.go b/vendor/google.golang.org/protobuf/internal/impl/codec_map_go112.go
new file mode 100644
index 000000000..1533ef600
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/codec_map_go112.go
@@ -0,0 +1,11 @@
+// Copyright 2019 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.
+
+// +build go1.12
+
+package impl
+
+import "reflect"
+
+func mapRange(v reflect.Value) *reflect.MapIter { return v.MapRange() }
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_message.go b/vendor/google.golang.org/protobuf/internal/impl/codec_message.go
new file mode 100644
index 000000000..0e176d565
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/codec_message.go
@@ -0,0 +1,159 @@
+// Copyright 2019 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"
+	"reflect"
+	"sort"
+
+	"google.golang.org/protobuf/encoding/protowire"
+	"google.golang.org/protobuf/internal/encoding/messageset"
+	"google.golang.org/protobuf/internal/fieldsort"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+	piface "google.golang.org/protobuf/runtime/protoiface"
+)
+
+// coderMessageInfo contains per-message information used by the fast-path functions.
+// This is a different type from MessageInfo to keep MessageInfo as general-purpose as
+// possible.
+type coderMessageInfo struct {
+	methods piface.Methods
+
+	orderedCoderFields []*coderFieldInfo
+	denseCoderFields   []*coderFieldInfo
+	coderFields        map[protowire.Number]*coderFieldInfo
+	sizecacheOffset    offset
+	unknownOffset      offset
+	extensionOffset    offset
+	needsInitCheck     bool
+	isMessageSet       bool
+	numRequiredFields  uint8
+}
+
+type coderFieldInfo struct {
+	funcs      pointerCoderFuncs // fast-path per-field functions
+	mi         *MessageInfo      // field's message
+	ft         reflect.Type
+	validation validationInfo   // information used by message validation
+	num        pref.FieldNumber // field number
+	offset     offset           // struct field offset
+	wiretag    uint64           // field tag (number + wire type)
+	tagsize    int              // size of the varint-encoded tag
+	isPointer  bool             // true if IsNil may be called on the struct field
+	isRequired bool             // true if field is required
+}
+
+func (mi *MessageInfo) makeCoderMethods(t reflect.Type, si structInfo) {
+	mi.sizecacheOffset = si.sizecacheOffset
+	mi.unknownOffset = si.unknownOffset
+	mi.extensionOffset = si.extensionOffset
+
+	mi.coderFields = make(map[protowire.Number]*coderFieldInfo)
+	fields := mi.Desc.Fields()
+	preallocFields := make([]coderFieldInfo, fields.Len())
+	for i := 0; i < fields.Len(); i++ {
+		fd := fields.Get(i)
+
+		fs := si.fieldsByNumber[fd.Number()]
+		isOneof := fd.ContainingOneof() != nil && !fd.ContainingOneof().IsSynthetic()
+		if isOneof {
+			fs = si.oneofsByName[fd.ContainingOneof().Name()]
+		}
+		ft := fs.Type
+		var wiretag uint64
+		if !fd.IsPacked() {
+			wiretag = protowire.EncodeTag(fd.Number(), wireTypes[fd.Kind()])
+		} else {
+			wiretag = protowire.EncodeTag(fd.Number(), protowire.BytesType)
+		}
+		var fieldOffset offset
+		var funcs pointerCoderFuncs
+		var childMessage *MessageInfo
+		switch {
+		case isOneof:
+			fieldOffset = offsetOf(fs, mi.Exporter)
+		case fd.IsWeak():
+			fieldOffset = si.weakOffset
+			funcs = makeWeakMessageFieldCoder(fd)
+		default:
+			fieldOffset = offsetOf(fs, mi.Exporter)
+			childMessage, funcs = fieldCoder(fd, ft)
+		}
+		cf := &preallocFields[i]
+		*cf = coderFieldInfo{
+			num:        fd.Number(),
+			offset:     fieldOffset,
+			wiretag:    wiretag,
+			ft:         ft,
+			tagsize:    protowire.SizeVarint(wiretag),
+			funcs:      funcs,
+			mi:         childMessage,
+			validation: newFieldValidationInfo(mi, si, fd, ft),
+			isPointer:  fd.Cardinality() == pref.Repeated || fd.HasPresence(),
+			isRequired: fd.Cardinality() == pref.Required,
+		}
+		mi.orderedCoderFields = append(mi.orderedCoderFields, cf)
+		mi.coderFields[cf.num] = cf
+	}
+	for i, oneofs := 0, mi.Desc.Oneofs(); i < oneofs.Len(); i++ {
+		if od := oneofs.Get(i); !od.IsSynthetic() {
+			mi.initOneofFieldCoders(od, si)
+		}
+	}
+	if messageset.IsMessageSet(mi.Desc) {
+		if !mi.extensionOffset.IsValid() {
+			panic(fmt.Sprintf("%v: MessageSet with no extensions field", mi.Desc.FullName()))
+		}
+		if !mi.unknownOffset.IsValid() {
+			panic(fmt.Sprintf("%v: MessageSet with no unknown field", mi.Desc.FullName()))
+		}
+		mi.isMessageSet = true
+	}
+	sort.Slice(mi.orderedCoderFields, func(i, j int) bool {
+		return mi.orderedCoderFields[i].num < mi.orderedCoderFields[j].num
+	})
+
+	var maxDense pref.FieldNumber
+	for _, cf := range mi.orderedCoderFields {
+		if cf.num >= 16 && cf.num >= 2*maxDense {
+			break
+		}
+		maxDense = cf.num
+	}
+	mi.denseCoderFields = make([]*coderFieldInfo, maxDense+1)
+	for _, cf := range mi.orderedCoderFields {
+		if int(cf.num) >= len(mi.denseCoderFields) {
+			break
+		}
+		mi.denseCoderFields[cf.num] = cf
+	}
+
+	// To preserve compatibility with historic wire output, marshal oneofs last.
+	if mi.Desc.Oneofs().Len() > 0 {
+		sort.Slice(mi.orderedCoderFields, func(i, j int) bool {
+			fi := fields.ByNumber(mi.orderedCoderFields[i].num)
+			fj := fields.ByNumber(mi.orderedCoderFields[j].num)
+			return fieldsort.Less(fi, fj)
+		})
+	}
+
+	mi.needsInitCheck = needsInitCheck(mi.Desc)
+	if mi.methods.Marshal == nil && mi.methods.Size == nil {
+		mi.methods.Flags |= piface.SupportMarshalDeterministic
+		mi.methods.Marshal = mi.marshal
+		mi.methods.Size = mi.size
+	}
+	if mi.methods.Unmarshal == nil {
+		mi.methods.Flags |= piface.SupportUnmarshalDiscardUnknown
+		mi.methods.Unmarshal = mi.unmarshal
+	}
+	if mi.methods.CheckInitialized == nil {
+		mi.methods.CheckInitialized = mi.checkInitialized
+	}
+	if mi.methods.Merge == nil {
+		mi.methods.Merge = mi.merge
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_messageset.go b/vendor/google.golang.org/protobuf/internal/impl/codec_messageset.go
new file mode 100644
index 000000000..cfb68e12f
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/codec_messageset.go
@@ -0,0 +1,120 @@
+// Copyright 2019 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 (
+	"sort"
+
+	"google.golang.org/protobuf/encoding/protowire"
+	"google.golang.org/protobuf/internal/encoding/messageset"
+	"google.golang.org/protobuf/internal/errors"
+	"google.golang.org/protobuf/internal/flags"
+)
+
+func sizeMessageSet(mi *MessageInfo, p pointer, opts marshalOptions) (size int) {
+	if !flags.ProtoLegacy {
+		return 0
+	}
+
+	ext := *p.Apply(mi.extensionOffset).Extensions()
+	for _, x := range ext {
+		xi := getExtensionFieldInfo(x.Type())
+		if xi.funcs.size == nil {
+			continue
+		}
+		num, _ := protowire.DecodeTag(xi.wiretag)
+		size += messageset.SizeField(num)
+		size += xi.funcs.size(x.Value(), protowire.SizeTag(messageset.FieldMessage), opts)
+	}
+
+	unknown := *p.Apply(mi.unknownOffset).Bytes()
+	size += messageset.SizeUnknown(unknown)
+
+	return size
+}
+
+func marshalMessageSet(mi *MessageInfo, b []byte, p pointer, opts marshalOptions) ([]byte, error) {
+	if !flags.ProtoLegacy {
+		return b, errors.New("no support for message_set_wire_format")
+	}
+
+	ext := *p.Apply(mi.extensionOffset).Extensions()
+	switch len(ext) {
+	case 0:
+	case 1:
+		// Fast-path for one extension: Don't bother sorting the keys.
+		for _, x := range ext {
+			var err error
+			b, err = marshalMessageSetField(mi, b, x, opts)
+			if err != nil {
+				return b, err
+			}
+		}
+	default:
+		// Sort the keys to provide a deterministic encoding.
+		// Not sure this is required, but the old code does it.
+		keys := make([]int, 0, len(ext))
+		for k := range ext {
+			keys = append(keys, int(k))
+		}
+		sort.Ints(keys)
+		for _, k := range keys {
+			var err error
+			b, err = marshalMessageSetField(mi, b, ext[int32(k)], opts)
+			if err != nil {
+				return b, err
+			}
+		}
+	}
+
+	unknown := *p.Apply(mi.unknownOffset).Bytes()
+	b, err := messageset.AppendUnknown(b, unknown)
+	if err != nil {
+		return b, err
+	}
+
+	return b, nil
+}
+
+func marshalMessageSetField(mi *MessageInfo, b []byte, x ExtensionField, opts marshalOptions) ([]byte, error) {
+	xi := getExtensionFieldInfo(x.Type())
+	num, _ := protowire.DecodeTag(xi.wiretag)
+	b = messageset.AppendFieldStart(b, num)
+	b, err := xi.funcs.marshal(b, x.Value(), protowire.EncodeTag(messageset.FieldMessage, protowire.BytesType), opts)
+	if err != nil {
+		return b, err
+	}
+	b = messageset.AppendFieldEnd(b)
+	return b, nil
+}
+
+func unmarshalMessageSet(mi *MessageInfo, b []byte, p pointer, opts unmarshalOptions) (out unmarshalOutput, err error) {
+	if !flags.ProtoLegacy {
+		return out, errors.New("no support for message_set_wire_format")
+	}
+
+	ep := p.Apply(mi.extensionOffset).Extensions()
+	if *ep == nil {
+		*ep = make(map[int32]ExtensionField)
+	}
+	ext := *ep
+	unknown := p.Apply(mi.unknownOffset).Bytes()
+	initialized := true
+	err = messageset.Unmarshal(b, true, func(num protowire.Number, v []byte) error {
+		o, err := mi.unmarshalExtension(v, num, protowire.BytesType, ext, opts)
+		if err == errUnknown {
+			*unknown = protowire.AppendTag(*unknown, num, protowire.BytesType)
+			*unknown = append(*unknown, v...)
+			return nil
+		}
+		if !o.initialized {
+			initialized = false
+		}
+		return err
+	})
+	out.n = len(b)
+	out.initialized = initialized
+	return out, err
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_reflect.go b/vendor/google.golang.org/protobuf/internal/impl/codec_reflect.go
new file mode 100644
index 000000000..86f7dc3c9
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/codec_reflect.go
@@ -0,0 +1,209 @@
+// Copyright 2019 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.
+
+// +build purego appengine
+
+package impl
+
+import (
+	"reflect"
+
+	"google.golang.org/protobuf/encoding/protowire"
+)
+
+func sizeEnum(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
+	v := p.v.Elem().Int()
+	return f.tagsize + protowire.SizeVarint(uint64(v))
+}
+
+func appendEnum(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
+	v := p.v.Elem().Int()
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, uint64(v))
+	return b, nil
+}
+
+func consumeEnum(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeVarint(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	p.v.Elem().SetInt(int64(v))
+	out.n = n
+	return out, nil
+}
+
+func mergeEnum(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	dst.v.Elem().Set(src.v.Elem())
+}
+
+var coderEnum = pointerCoderFuncs{
+	size:      sizeEnum,
+	marshal:   appendEnum,
+	unmarshal: consumeEnum,
+	merge:     mergeEnum,
+}
+
+func sizeEnumNoZero(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
+	if p.v.Elem().Int() == 0 {
+		return 0
+	}
+	return sizeEnum(p, f, opts)
+}
+
+func appendEnumNoZero(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
+	if p.v.Elem().Int() == 0 {
+		return b, nil
+	}
+	return appendEnum(b, p, f, opts)
+}
+
+func mergeEnumNoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	if src.v.Elem().Int() != 0 {
+		dst.v.Elem().Set(src.v.Elem())
+	}
+}
+
+var coderEnumNoZero = pointerCoderFuncs{
+	size:      sizeEnumNoZero,
+	marshal:   appendEnumNoZero,
+	unmarshal: consumeEnum,
+	merge:     mergeEnumNoZero,
+}
+
+func sizeEnumPtr(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
+	return sizeEnum(pointer{p.v.Elem()}, f, opts)
+}
+
+func appendEnumPtr(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
+	return appendEnum(b, pointer{p.v.Elem()}, f, opts)
+}
+
+func consumeEnumPtr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
+		return out, errUnknown
+	}
+	if p.v.Elem().IsNil() {
+		p.v.Elem().Set(reflect.New(p.v.Elem().Type().Elem()))
+	}
+	return consumeEnum(b, pointer{p.v.Elem()}, wtyp, f, opts)
+}
+
+func mergeEnumPtr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	if !src.v.Elem().IsNil() {
+		v := reflect.New(dst.v.Type().Elem().Elem())
+		v.Elem().Set(src.v.Elem().Elem())
+		dst.v.Elem().Set(v)
+	}
+}
+
+var coderEnumPtr = pointerCoderFuncs{
+	size:      sizeEnumPtr,
+	marshal:   appendEnumPtr,
+	unmarshal: consumeEnumPtr,
+	merge:     mergeEnumPtr,
+}
+
+func sizeEnumSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
+	s := p.v.Elem()
+	for i, llen := 0, s.Len(); i < llen; i++ {
+		size += protowire.SizeVarint(uint64(s.Index(i).Int())) + f.tagsize
+	}
+	return size
+}
+
+func appendEnumSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
+	s := p.v.Elem()
+	for i, llen := 0, s.Len(); i < llen; i++ {
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendVarint(b, uint64(s.Index(i).Int()))
+	}
+	return b, nil
+}
+
+func consumeEnumSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
+	s := p.v.Elem()
+	if wtyp == protowire.BytesType {
+		b, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return out, protowire.ParseError(n)
+		}
+		for len(b) > 0 {
+			v, n := protowire.ConsumeVarint(b)
+			if n < 0 {
+				return out, protowire.ParseError(n)
+			}
+			rv := reflect.New(s.Type().Elem()).Elem()
+			rv.SetInt(int64(v))
+			s.Set(reflect.Append(s, rv))
+			b = b[n:]
+		}
+		out.n = n
+		return out, nil
+	}
+	if wtyp != protowire.VarintType {
+		return out, errUnknown
+	}
+	v, n := protowire.ConsumeVarint(b)
+	if n < 0 {
+		return out, protowire.ParseError(n)
+	}
+	rv := reflect.New(s.Type().Elem()).Elem()
+	rv.SetInt(int64(v))
+	s.Set(reflect.Append(s, rv))
+	out.n = n
+	return out, nil
+}
+
+func mergeEnumSlice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	dst.v.Elem().Set(reflect.AppendSlice(dst.v.Elem(), src.v.Elem()))
+}
+
+var coderEnumSlice = pointerCoderFuncs{
+	size:      sizeEnumSlice,
+	marshal:   appendEnumSlice,
+	unmarshal: consumeEnumSlice,
+	merge:     mergeEnumSlice,
+}
+
+func sizeEnumPackedSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
+	s := p.v.Elem()
+	llen := s.Len()
+	if llen == 0 {
+		return 0
+	}
+	n := 0
+	for i := 0; i < llen; i++ {
+		n += protowire.SizeVarint(uint64(s.Index(i).Int()))
+	}
+	return f.tagsize + protowire.SizeBytes(n)
+}
+
+func appendEnumPackedSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
+	s := p.v.Elem()
+	llen := s.Len()
+	if llen == 0 {
+		return b, nil
+	}
+	b = protowire.AppendVarint(b, f.wiretag)
+	n := 0
+	for i := 0; i < llen; i++ {
+		n += protowire.SizeVarint(uint64(s.Index(i).Int()))
+	}
+	b = protowire.AppendVarint(b, uint64(n))
+	for i := 0; i < llen; i++ {
+		b = protowire.AppendVarint(b, uint64(s.Index(i).Int()))
+	}
+	return b, nil
+}
+
+var coderEnumPackedSlice = pointerCoderFuncs{
+	size:      sizeEnumPackedSlice,
+	marshal:   appendEnumPackedSlice,
+	unmarshal: consumeEnumSlice,
+	merge:     mergeEnumSlice,
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_tables.go b/vendor/google.golang.org/protobuf/internal/impl/codec_tables.go
new file mode 100644
index 000000000..e89971238
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/codec_tables.go
@@ -0,0 +1,557 @@
+// Copyright 2019 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"
+	"reflect"
+
+	"google.golang.org/protobuf/encoding/protowire"
+	"google.golang.org/protobuf/internal/strs"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+)
+
+// pointerCoderFuncs is a set of pointer encoding functions.
+type pointerCoderFuncs struct {
+	mi        *MessageInfo
+	size      func(p pointer, f *coderFieldInfo, opts marshalOptions) int
+	marshal   func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error)
+	unmarshal func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error)
+	isInit    func(p pointer, f *coderFieldInfo) error
+	merge     func(dst, src pointer, f *coderFieldInfo, opts mergeOptions)
+}
+
+// valueCoderFuncs is a set of protoreflect.Value encoding functions.
+type valueCoderFuncs struct {
+	size      func(v pref.Value, tagsize int, opts marshalOptions) int
+	marshal   func(b []byte, v pref.Value, wiretag uint64, opts marshalOptions) ([]byte, error)
+	unmarshal func(b []byte, v pref.Value, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (pref.Value, unmarshalOutput, error)
+	isInit    func(v pref.Value) error
+	merge     func(dst, src pref.Value, opts mergeOptions) pref.Value
+}
+
+// fieldCoder returns pointer functions for a field, used for operating on
+// struct fields.
+func fieldCoder(fd pref.FieldDescriptor, ft reflect.Type) (*MessageInfo, pointerCoderFuncs) {
+	switch {
+	case fd.IsMap():
+		return encoderFuncsForMap(fd, ft)
+	case fd.Cardinality() == pref.Repeated && !fd.IsPacked():
+		// Repeated fields (not packed).
+		if ft.Kind() != reflect.Slice {
+			break
+		}
+		ft := ft.Elem()
+		switch fd.Kind() {
+		case pref.BoolKind:
+			if ft.Kind() == reflect.Bool {
+				return nil, coderBoolSlice
+			}
+		case pref.EnumKind:
+			if ft.Kind() == reflect.Int32 {
+				return nil, coderEnumSlice
+			}
+		case pref.Int32Kind:
+			if ft.Kind() == reflect.Int32 {
+				return nil, coderInt32Slice
+			}
+		case pref.Sint32Kind:
+			if ft.Kind() == reflect.Int32 {
+				return nil, coderSint32Slice
+			}
+		case pref.Uint32Kind:
+			if ft.Kind() == reflect.Uint32 {
+				return nil, coderUint32Slice
+			}
+		case pref.Int64Kind:
+			if ft.Kind() == reflect.Int64 {
+				return nil, coderInt64Slice
+			}
+		case pref.Sint64Kind:
+			if ft.Kind() == reflect.Int64 {
+				return nil, coderSint64Slice
+			}
+		case pref.Uint64Kind:
+			if ft.Kind() == reflect.Uint64 {
+				return nil, coderUint64Slice
+			}
+		case pref.Sfixed32Kind:
+			if ft.Kind() == reflect.Int32 {
+				return nil, coderSfixed32Slice
+			}
+		case pref.Fixed32Kind:
+			if ft.Kind() == reflect.Uint32 {
+				return nil, coderFixed32Slice
+			}
+		case pref.FloatKind:
+			if ft.Kind() == reflect.Float32 {
+				return nil, coderFloatSlice
+			}
+		case pref.Sfixed64Kind:
+			if ft.Kind() == reflect.Int64 {
+				return nil, coderSfixed64Slice
+			}
+		case pref.Fixed64Kind:
+			if ft.Kind() == reflect.Uint64 {
+				return nil, coderFixed64Slice
+			}
+		case pref.DoubleKind:
+			if ft.Kind() == reflect.Float64 {
+				return nil, coderDoubleSlice
+			}
+		case pref.StringKind:
+			if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) {
+				return nil, coderStringSliceValidateUTF8
+			}
+			if ft.Kind() == reflect.String {
+				return nil, coderStringSlice
+			}
+			if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 && strs.EnforceUTF8(fd) {
+				return nil, coderBytesSliceValidateUTF8
+			}
+			if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 {
+				return nil, coderBytesSlice
+			}
+		case pref.BytesKind:
+			if ft.Kind() == reflect.String {
+				return nil, coderStringSlice
+			}
+			if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 {
+				return nil, coderBytesSlice
+			}
+		case pref.MessageKind:
+			return getMessageInfo(ft), makeMessageSliceFieldCoder(fd, ft)
+		case pref.GroupKind:
+			return getMessageInfo(ft), makeGroupSliceFieldCoder(fd, ft)
+		}
+	case fd.Cardinality() == pref.Repeated && fd.IsPacked():
+		// Packed repeated fields.
+		//
+		// Only repeated fields of primitive numeric types
+		// (Varint, Fixed32, or Fixed64 wire type) can be packed.
+		if ft.Kind() != reflect.Slice {
+			break
+		}
+		ft := ft.Elem()
+		switch fd.Kind() {
+		case pref.BoolKind:
+			if ft.Kind() == reflect.Bool {
+				return nil, coderBoolPackedSlice
+			}
+		case pref.EnumKind:
+			if ft.Kind() == reflect.Int32 {
+				return nil, coderEnumPackedSlice
+			}
+		case pref.Int32Kind:
+			if ft.Kind() == reflect.Int32 {
+				return nil, coderInt32PackedSlice
+			}
+		case pref.Sint32Kind:
+			if ft.Kind() == reflect.Int32 {
+				return nil, coderSint32PackedSlice
+			}
+		case pref.Uint32Kind:
+			if ft.Kind() == reflect.Uint32 {
+				return nil, coderUint32PackedSlice
+			}
+		case pref.Int64Kind:
+			if ft.Kind() == reflect.Int64 {
+				return nil, coderInt64PackedSlice
+			}
+		case pref.Sint64Kind:
+			if ft.Kind() == reflect.Int64 {
+				return nil, coderSint64PackedSlice
+			}
+		case pref.Uint64Kind:
+			if ft.Kind() == reflect.Uint64 {
+				return nil, coderUint64PackedSlice
+			}
+		case pref.Sfixed32Kind:
+			if ft.Kind() == reflect.Int32 {
+				return nil, coderSfixed32PackedSlice
+			}
+		case pref.Fixed32Kind:
+			if ft.Kind() == reflect.Uint32 {
+				return nil, coderFixed32PackedSlice
+			}
+		case pref.FloatKind:
+			if ft.Kind() == reflect.Float32 {
+				return nil, coderFloatPackedSlice
+			}
+		case pref.Sfixed64Kind:
+			if ft.Kind() == reflect.Int64 {
+				return nil, coderSfixed64PackedSlice
+			}
+		case pref.Fixed64Kind:
+			if ft.Kind() == reflect.Uint64 {
+				return nil, coderFixed64PackedSlice
+			}
+		case pref.DoubleKind:
+			if ft.Kind() == reflect.Float64 {
+				return nil, coderDoublePackedSlice
+			}
+		}
+	case fd.Kind() == pref.MessageKind:
+		return getMessageInfo(ft), makeMessageFieldCoder(fd, ft)
+	case fd.Kind() == pref.GroupKind:
+		return getMessageInfo(ft), makeGroupFieldCoder(fd, ft)
+	case fd.Syntax() == pref.Proto3 && fd.ContainingOneof() == nil:
+		// Populated oneof fields always encode even if set to the zero value,
+		// which normally are not encoded in proto3.
+		switch fd.Kind() {
+		case pref.BoolKind:
+			if ft.Kind() == reflect.Bool {
+				return nil, coderBoolNoZero
+			}
+		case pref.EnumKind:
+			if ft.Kind() == reflect.Int32 {
+				return nil, coderEnumNoZero
+			}
+		case pref.Int32Kind:
+			if ft.Kind() == reflect.Int32 {
+				return nil, coderInt32NoZero
+			}
+		case pref.Sint32Kind:
+			if ft.Kind() == reflect.Int32 {
+				return nil, coderSint32NoZero
+			}
+		case pref.Uint32Kind:
+			if ft.Kind() == reflect.Uint32 {
+				return nil, coderUint32NoZero
+			}
+		case pref.Int64Kind:
+			if ft.Kind() == reflect.Int64 {
+				return nil, coderInt64NoZero
+			}
+		case pref.Sint64Kind:
+			if ft.Kind() == reflect.Int64 {
+				return nil, coderSint64NoZero
+			}
+		case pref.Uint64Kind:
+			if ft.Kind() == reflect.Uint64 {
+				return nil, coderUint64NoZero
+			}
+		case pref.Sfixed32Kind:
+			if ft.Kind() == reflect.Int32 {
+				return nil, coderSfixed32NoZero
+			}
+		case pref.Fixed32Kind:
+			if ft.Kind() == reflect.Uint32 {
+				return nil, coderFixed32NoZero
+			}
+		case pref.FloatKind:
+			if ft.Kind() == reflect.Float32 {
+				return nil, coderFloatNoZero
+			}
+		case pref.Sfixed64Kind:
+			if ft.Kind() == reflect.Int64 {
+				return nil, coderSfixed64NoZero
+			}
+		case pref.Fixed64Kind:
+			if ft.Kind() == reflect.Uint64 {
+				return nil, coderFixed64NoZero
+			}
+		case pref.DoubleKind:
+			if ft.Kind() == reflect.Float64 {
+				return nil, coderDoubleNoZero
+			}
+		case pref.StringKind:
+			if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) {
+				return nil, coderStringNoZeroValidateUTF8
+			}
+			if ft.Kind() == reflect.String {
+				return nil, coderStringNoZero
+			}
+			if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 && strs.EnforceUTF8(fd) {
+				return nil, coderBytesNoZeroValidateUTF8
+			}
+			if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 {
+				return nil, coderBytesNoZero
+			}
+		case pref.BytesKind:
+			if ft.Kind() == reflect.String {
+				return nil, coderStringNoZero
+			}
+			if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 {
+				return nil, coderBytesNoZero
+			}
+		}
+	case ft.Kind() == reflect.Ptr:
+		ft := ft.Elem()
+		switch fd.Kind() {
+		case pref.BoolKind:
+			if ft.Kind() == reflect.Bool {
+				return nil, coderBoolPtr
+			}
+		case pref.EnumKind:
+			if ft.Kind() == reflect.Int32 {
+				return nil, coderEnumPtr
+			}
+		case pref.Int32Kind:
+			if ft.Kind() == reflect.Int32 {
+				return nil, coderInt32Ptr
+			}
+		case pref.Sint32Kind:
+			if ft.Kind() == reflect.Int32 {
+				return nil, coderSint32Ptr
+			}
+		case pref.Uint32Kind:
+			if ft.Kind() == reflect.Uint32 {
+				return nil, coderUint32Ptr
+			}
+		case pref.Int64Kind:
+			if ft.Kind() == reflect.Int64 {
+				return nil, coderInt64Ptr
+			}
+		case pref.Sint64Kind:
+			if ft.Kind() == reflect.Int64 {
+				return nil, coderSint64Ptr
+			}
+		case pref.Uint64Kind:
+			if ft.Kind() == reflect.Uint64 {
+				return nil, coderUint64Ptr
+			}
+		case pref.Sfixed32Kind:
+			if ft.Kind() == reflect.Int32 {
+				return nil, coderSfixed32Ptr
+			}
+		case pref.Fixed32Kind:
+			if ft.Kind() == reflect.Uint32 {
+				return nil, coderFixed32Ptr
+			}
+		case pref.FloatKind:
+			if ft.Kind() == reflect.Float32 {
+				return nil, coderFloatPtr
+			}
+		case pref.Sfixed64Kind:
+			if ft.Kind() == reflect.Int64 {
+				return nil, coderSfixed64Ptr
+			}
+		case pref.Fixed64Kind:
+			if ft.Kind() == reflect.Uint64 {
+				return nil, coderFixed64Ptr
+			}
+		case pref.DoubleKind:
+			if ft.Kind() == reflect.Float64 {
+				return nil, coderDoublePtr
+			}
+		case pref.StringKind:
+			if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) {
+				return nil, coderStringPtrValidateUTF8
+			}
+			if ft.Kind() == reflect.String {
+				return nil, coderStringPtr
+			}
+		case pref.BytesKind:
+			if ft.Kind() == reflect.String {
+				return nil, coderStringPtr
+			}
+		}
+	default:
+		switch fd.Kind() {
+		case pref.BoolKind:
+			if ft.Kind() == reflect.Bool {
+				return nil, coderBool
+			}
+		case pref.EnumKind:
+			if ft.Kind() == reflect.Int32 {
+				return nil, coderEnum
+			}
+		case pref.Int32Kind:
+			if ft.Kind() == reflect.Int32 {
+				return nil, coderInt32
+			}
+		case pref.Sint32Kind:
+			if ft.Kind() == reflect.Int32 {
+				return nil, coderSint32
+			}
+		case pref.Uint32Kind:
+			if ft.Kind() == reflect.Uint32 {
+				return nil, coderUint32
+			}
+		case pref.Int64Kind:
+			if ft.Kind() == reflect.Int64 {
+				return nil, coderInt64
+			}
+		case pref.Sint64Kind:
+			if ft.Kind() == reflect.Int64 {
+				return nil, coderSint64
+			}
+		case pref.Uint64Kind:
+			if ft.Kind() == reflect.Uint64 {
+				return nil, coderUint64
+			}
+		case pref.Sfixed32Kind:
+			if ft.Kind() == reflect.Int32 {
+				return nil, coderSfixed32
+			}
+		case pref.Fixed32Kind:
+			if ft.Kind() == reflect.Uint32 {
+				return nil, coderFixed32
+			}
+		case pref.FloatKind:
+			if ft.Kind() == reflect.Float32 {
+				return nil, coderFloat
+			}
+		case pref.Sfixed64Kind:
+			if ft.Kind() == reflect.Int64 {
+				return nil, coderSfixed64
+			}
+		case pref.Fixed64Kind:
+			if ft.Kind() == reflect.Uint64 {
+				return nil, coderFixed64
+			}
+		case pref.DoubleKind:
+			if ft.Kind() == reflect.Float64 {
+				return nil, coderDouble
+			}
+		case pref.StringKind:
+			if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) {
+				return nil, coderStringValidateUTF8
+			}
+			if ft.Kind() == reflect.String {
+				return nil, coderString
+			}
+			if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 && strs.EnforceUTF8(fd) {
+				return nil, coderBytesValidateUTF8
+			}
+			if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 {
+				return nil, coderBytes
+			}
+		case pref.BytesKind:
+			if ft.Kind() == reflect.String {
+				return nil, coderString
+			}
+			if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 {
+				return nil, coderBytes
+			}
+		}
+	}
+	panic(fmt.Sprintf("invalid type: no encoder for %v %v %v/%v", fd.FullName(), fd.Cardinality(), fd.Kind(), ft))
+}
+
+// encoderFuncsForValue returns value functions for a field, used for
+// extension values and map encoding.
+func encoderFuncsForValue(fd pref.FieldDescriptor) valueCoderFuncs {
+	switch {
+	case fd.Cardinality() == pref.Repeated && !fd.IsPacked():
+		switch fd.Kind() {
+		case pref.BoolKind:
+			return coderBoolSliceValue
+		case pref.EnumKind:
+			return coderEnumSliceValue
+		case pref.Int32Kind:
+			return coderInt32SliceValue
+		case pref.Sint32Kind:
+			return coderSint32SliceValue
+		case pref.Uint32Kind:
+			return coderUint32SliceValue
+		case pref.Int64Kind:
+			return coderInt64SliceValue
+		case pref.Sint64Kind:
+			return coderSint64SliceValue
+		case pref.Uint64Kind:
+			return coderUint64SliceValue
+		case pref.Sfixed32Kind:
+			return coderSfixed32SliceValue
+		case pref.Fixed32Kind:
+			return coderFixed32SliceValue
+		case pref.FloatKind:
+			return coderFloatSliceValue
+		case pref.Sfixed64Kind:
+			return coderSfixed64SliceValue
+		case pref.Fixed64Kind:
+			return coderFixed64SliceValue
+		case pref.DoubleKind:
+			return coderDoubleSliceValue
+		case pref.StringKind:
+			// We don't have a UTF-8 validating coder for repeated string fields.
+			// Value coders are used for extensions and maps.
+			// Extensions are never proto3, and maps never contain lists.
+			return coderStringSliceValue
+		case pref.BytesKind:
+			return coderBytesSliceValue
+		case pref.MessageKind:
+			return coderMessageSliceValue
+		case pref.GroupKind:
+			return coderGroupSliceValue
+		}
+	case fd.Cardinality() == pref.Repeated && fd.IsPacked():
+		switch fd.Kind() {
+		case pref.BoolKind:
+			return coderBoolPackedSliceValue
+		case pref.EnumKind:
+			return coderEnumPackedSliceValue
+		case pref.Int32Kind:
+			return coderInt32PackedSliceValue
+		case pref.Sint32Kind:
+			return coderSint32PackedSliceValue
+		case pref.Uint32Kind:
+			return coderUint32PackedSliceValue
+		case pref.Int64Kind:
+			return coderInt64PackedSliceValue
+		case pref.Sint64Kind:
+			return coderSint64PackedSliceValue
+		case pref.Uint64Kind:
+			return coderUint64PackedSliceValue
+		case pref.Sfixed32Kind:
+			return coderSfixed32PackedSliceValue
+		case pref.Fixed32Kind:
+			return coderFixed32PackedSliceValue
+		case pref.FloatKind:
+			return coderFloatPackedSliceValue
+		case pref.Sfixed64Kind:
+			return coderSfixed64PackedSliceValue
+		case pref.Fixed64Kind:
+			return coderFixed64PackedSliceValue
+		case pref.DoubleKind:
+			return coderDoublePackedSliceValue
+		}
+	default:
+		switch fd.Kind() {
+		default:
+		case pref.BoolKind:
+			return coderBoolValue
+		case pref.EnumKind:
+			return coderEnumValue
+		case pref.Int32Kind:
+			return coderInt32Value
+		case pref.Sint32Kind:
+			return coderSint32Value
+		case pref.Uint32Kind:
+			return coderUint32Value
+		case pref.Int64Kind:
+			return coderInt64Value
+		case pref.Sint64Kind:
+			return coderSint64Value
+		case pref.Uint64Kind:
+			return coderUint64Value
+		case pref.Sfixed32Kind:
+			return coderSfixed32Value
+		case pref.Fixed32Kind:
+			return coderFixed32Value
+		case pref.FloatKind:
+			return coderFloatValue
+		case pref.Sfixed64Kind:
+			return coderSfixed64Value
+		case pref.Fixed64Kind:
+			return coderFixed64Value
+		case pref.DoubleKind:
+			return coderDoubleValue
+		case pref.StringKind:
+			if strs.EnforceUTF8(fd) {
+				return coderStringValueValidateUTF8
+			}
+			return coderStringValue
+		case pref.BytesKind:
+			return coderBytesValue
+		case pref.MessageKind:
+			return coderMessageValue
+		case pref.GroupKind:
+			return coderGroupValue
+		}
+	}
+	panic(fmt.Sprintf("invalid field: no encoder for %v %v %v", fd.FullName(), fd.Cardinality(), fd.Kind()))
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_unsafe.go b/vendor/google.golang.org/protobuf/internal/impl/codec_unsafe.go
new file mode 100644
index 000000000..e118af1e2
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/codec_unsafe.go
@@ -0,0 +1,17 @@
+// Copyright 2019 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.
+
+// +build !purego,!appengine
+
+package impl
+
+// When using unsafe pointers, we can just treat enum values as int32s.
+
+var (
+	coderEnumNoZero      = coderInt32NoZero
+	coderEnum            = coderInt32
+	coderEnumPtr         = coderInt32Ptr
+	coderEnumSlice       = coderInt32Slice
+	coderEnumPackedSlice = coderInt32PackedSlice
+)
diff --git a/vendor/google.golang.org/protobuf/internal/impl/convert.go b/vendor/google.golang.org/protobuf/internal/impl/convert.go
new file mode 100644
index 000000000..36a90dff3
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/convert.go
@@ -0,0 +1,467 @@
+// 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"
+	"reflect"
+
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+)
+
+// unwrapper unwraps the value to the underlying value.
+// This is implemented by List and Map.
+type unwrapper interface {
+	protoUnwrap() interface{}
+}
+
+// A Converter coverts to/from Go reflect.Value types and protobuf protoreflect.Value types.
+type Converter interface {
+	// PBValueOf converts a reflect.Value to a protoreflect.Value.
+	PBValueOf(reflect.Value) pref.Value
+
+	// GoValueOf converts a protoreflect.Value to a reflect.Value.
+	GoValueOf(pref.Value) reflect.Value
+
+	// IsValidPB returns whether a protoreflect.Value is compatible with this type.
+	IsValidPB(pref.Value) bool
+
+	// IsValidGo returns whether a reflect.Value is compatible with this type.
+	IsValidGo(reflect.Value) bool
+
+	// New returns a new field value.
+	// For scalars, it returns the default value of the field.
+	// For composite types, it returns a new mutable value.
+	New() pref.Value
+
+	// Zero returns a new field value.
+	// For scalars, it returns the default value of the field.
+	// For composite types, it returns an immutable, empty value.
+	Zero() pref.Value
+}
+
+// NewConverter matches a Go type with a protobuf field and returns a Converter
+// that converts between the two. Enums must be a named int32 kind that
+// implements protoreflect.Enum, and messages must be pointer to a named
+// struct type that implements protoreflect.ProtoMessage.
+//
+// This matcher deliberately supports a wider range of Go types than what
+// protoc-gen-go historically generated to be able to automatically wrap some
+// v1 messages generated by other forks of protoc-gen-go.
+func NewConverter(t reflect.Type, fd pref.FieldDescriptor) Converter {
+	switch {
+	case fd.IsList():
+		return newListConverter(t, fd)
+	case fd.IsMap():
+		return newMapConverter(t, fd)
+	default:
+		return newSingularConverter(t, fd)
+	}
+	panic(fmt.Sprintf("invalid Go type %v for field %v", t, fd.FullName()))
+}
+
+var (
+	boolType    = reflect.TypeOf(bool(false))
+	int32Type   = reflect.TypeOf(int32(0))
+	int64Type   = reflect.TypeOf(int64(0))
+	uint32Type  = reflect.TypeOf(uint32(0))
+	uint64Type  = reflect.TypeOf(uint64(0))
+	float32Type = reflect.TypeOf(float32(0))
+	float64Type = reflect.TypeOf(float64(0))
+	stringType  = reflect.TypeOf(string(""))
+	bytesType   = reflect.TypeOf([]byte(nil))
+	byteType    = reflect.TypeOf(byte(0))
+)
+
+var (
+	boolZero    = pref.ValueOfBool(false)
+	int32Zero   = pref.ValueOfInt32(0)
+	int64Zero   = pref.ValueOfInt64(0)
+	uint32Zero  = pref.ValueOfUint32(0)
+	uint64Zero  = pref.ValueOfUint64(0)
+	float32Zero = pref.ValueOfFloat32(0)
+	float64Zero = pref.ValueOfFloat64(0)
+	stringZero  = pref.ValueOfString("")
+	bytesZero   = pref.ValueOfBytes(nil)
+)
+
+func newSingularConverter(t reflect.Type, fd pref.FieldDescriptor) Converter {
+	defVal := func(fd pref.FieldDescriptor, zero pref.Value) pref.Value {
+		if fd.Cardinality() == pref.Repeated {
+			// Default isn't defined for repeated fields.
+			return zero
+		}
+		return fd.Default()
+	}
+	switch fd.Kind() {
+	case pref.BoolKind:
+		if t.Kind() == reflect.Bool {
+			return &boolConverter{t, defVal(fd, boolZero)}
+		}
+	case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
+		if t.Kind() == reflect.Int32 {
+			return &int32Converter{t, defVal(fd, int32Zero)}
+		}
+	case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
+		if t.Kind() == reflect.Int64 {
+			return &int64Converter{t, defVal(fd, int64Zero)}
+		}
+	case pref.Uint32Kind, pref.Fixed32Kind:
+		if t.Kind() == reflect.Uint32 {
+			return &uint32Converter{t, defVal(fd, uint32Zero)}
+		}
+	case pref.Uint64Kind, pref.Fixed64Kind:
+		if t.Kind() == reflect.Uint64 {
+			return &uint64Converter{t, defVal(fd, uint64Zero)}
+		}
+	case pref.FloatKind:
+		if t.Kind() == reflect.Float32 {
+			return &float32Converter{t, defVal(fd, float32Zero)}
+		}
+	case pref.DoubleKind:
+		if t.Kind() == reflect.Float64 {
+			return &float64Converter{t, defVal(fd, float64Zero)}
+		}
+	case pref.StringKind:
+		if t.Kind() == reflect.String || (t.Kind() == reflect.Slice && t.Elem() == byteType) {
+			return &stringConverter{t, defVal(fd, stringZero)}
+		}
+	case pref.BytesKind:
+		if t.Kind() == reflect.String || (t.Kind() == reflect.Slice && t.Elem() == byteType) {
+			return &bytesConverter{t, defVal(fd, bytesZero)}
+		}
+	case pref.EnumKind:
+		// Handle enums, which must be a named int32 type.
+		if t.Kind() == reflect.Int32 {
+			return newEnumConverter(t, fd)
+		}
+	case pref.MessageKind, pref.GroupKind:
+		return newMessageConverter(t)
+	}
+	panic(fmt.Sprintf("invalid Go type %v for field %v", t, fd.FullName()))
+}
+
+type boolConverter struct {
+	goType reflect.Type
+	def    pref.Value
+}
+
+func (c *boolConverter) PBValueOf(v reflect.Value) pref.Value {
+	if v.Type() != c.goType {
+		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
+	}
+	return pref.ValueOfBool(v.Bool())
+}
+func (c *boolConverter) GoValueOf(v pref.Value) reflect.Value {
+	return reflect.ValueOf(v.Bool()).Convert(c.goType)
+}
+func (c *boolConverter) IsValidPB(v pref.Value) bool {
+	_, ok := v.Interface().(bool)
+	return ok
+}
+func (c *boolConverter) IsValidGo(v reflect.Value) bool {
+	return v.IsValid() && v.Type() == c.goType
+}
+func (c *boolConverter) New() pref.Value  { return c.def }
+func (c *boolConverter) Zero() pref.Value { return c.def }
+
+type int32Converter struct {
+	goType reflect.Type
+	def    pref.Value
+}
+
+func (c *int32Converter) PBValueOf(v reflect.Value) pref.Value {
+	if v.Type() != c.goType {
+		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
+	}
+	return pref.ValueOfInt32(int32(v.Int()))
+}
+func (c *int32Converter) GoValueOf(v pref.Value) reflect.Value {
+	return reflect.ValueOf(int32(v.Int())).Convert(c.goType)
+}
+func (c *int32Converter) IsValidPB(v pref.Value) bool {
+	_, ok := v.Interface().(int32)
+	return ok
+}
+func (c *int32Converter) IsValidGo(v reflect.Value) bool {
+	return v.IsValid() && v.Type() == c.goType
+}
+func (c *int32Converter) New() pref.Value  { return c.def }
+func (c *int32Converter) Zero() pref.Value { return c.def }
+
+type int64Converter struct {
+	goType reflect.Type
+	def    pref.Value
+}
+
+func (c *int64Converter) PBValueOf(v reflect.Value) pref.Value {
+	if v.Type() != c.goType {
+		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
+	}
+	return pref.ValueOfInt64(int64(v.Int()))
+}
+func (c *int64Converter) GoValueOf(v pref.Value) reflect.Value {
+	return reflect.ValueOf(int64(v.Int())).Convert(c.goType)
+}
+func (c *int64Converter) IsValidPB(v pref.Value) bool {
+	_, ok := v.Interface().(int64)
+	return ok
+}
+func (c *int64Converter) IsValidGo(v reflect.Value) bool {
+	return v.IsValid() && v.Type() == c.goType
+}
+func (c *int64Converter) New() pref.Value  { return c.def }
+func (c *int64Converter) Zero() pref.Value { return c.def }
+
+type uint32Converter struct {
+	goType reflect.Type
+	def    pref.Value
+}
+
+func (c *uint32Converter) PBValueOf(v reflect.Value) pref.Value {
+	if v.Type() != c.goType {
+		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
+	}
+	return pref.ValueOfUint32(uint32(v.Uint()))
+}
+func (c *uint32Converter) GoValueOf(v pref.Value) reflect.Value {
+	return reflect.ValueOf(uint32(v.Uint())).Convert(c.goType)
+}
+func (c *uint32Converter) IsValidPB(v pref.Value) bool {
+	_, ok := v.Interface().(uint32)
+	return ok
+}
+func (c *uint32Converter) IsValidGo(v reflect.Value) bool {
+	return v.IsValid() && v.Type() == c.goType
+}
+func (c *uint32Converter) New() pref.Value  { return c.def }
+func (c *uint32Converter) Zero() pref.Value { return c.def }
+
+type uint64Converter struct {
+	goType reflect.Type
+	def    pref.Value
+}
+
+func (c *uint64Converter) PBValueOf(v reflect.Value) pref.Value {
+	if v.Type() != c.goType {
+		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
+	}
+	return pref.ValueOfUint64(uint64(v.Uint()))
+}
+func (c *uint64Converter) GoValueOf(v pref.Value) reflect.Value {
+	return reflect.ValueOf(uint64(v.Uint())).Convert(c.goType)
+}
+func (c *uint64Converter) IsValidPB(v pref.Value) bool {
+	_, ok := v.Interface().(uint64)
+	return ok
+}
+func (c *uint64Converter) IsValidGo(v reflect.Value) bool {
+	return v.IsValid() && v.Type() == c.goType
+}
+func (c *uint64Converter) New() pref.Value  { return c.def }
+func (c *uint64Converter) Zero() pref.Value { return c.def }
+
+type float32Converter struct {
+	goType reflect.Type
+	def    pref.Value
+}
+
+func (c *float32Converter) PBValueOf(v reflect.Value) pref.Value {
+	if v.Type() != c.goType {
+		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
+	}
+	return pref.ValueOfFloat32(float32(v.Float()))
+}
+func (c *float32Converter) GoValueOf(v pref.Value) reflect.Value {
+	return reflect.ValueOf(float32(v.Float())).Convert(c.goType)
+}
+func (c *float32Converter) IsValidPB(v pref.Value) bool {
+	_, ok := v.Interface().(float32)
+	return ok
+}
+func (c *float32Converter) IsValidGo(v reflect.Value) bool {
+	return v.IsValid() && v.Type() == c.goType
+}
+func (c *float32Converter) New() pref.Value  { return c.def }
+func (c *float32Converter) Zero() pref.Value { return c.def }
+
+type float64Converter struct {
+	goType reflect.Type
+	def    pref.Value
+}
+
+func (c *float64Converter) PBValueOf(v reflect.Value) pref.Value {
+	if v.Type() != c.goType {
+		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
+	}
+	return pref.ValueOfFloat64(float64(v.Float()))
+}
+func (c *float64Converter) GoValueOf(v pref.Value) reflect.Value {
+	return reflect.ValueOf(float64(v.Float())).Convert(c.goType)
+}
+func (c *float64Converter) IsValidPB(v pref.Value) bool {
+	_, ok := v.Interface().(float64)
+	return ok
+}
+func (c *float64Converter) IsValidGo(v reflect.Value) bool {
+	return v.IsValid() && v.Type() == c.goType
+}
+func (c *float64Converter) New() pref.Value  { return c.def }
+func (c *float64Converter) Zero() pref.Value { return c.def }
+
+type stringConverter struct {
+	goType reflect.Type
+	def    pref.Value
+}
+
+func (c *stringConverter) PBValueOf(v reflect.Value) pref.Value {
+	if v.Type() != c.goType {
+		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
+	}
+	return pref.ValueOfString(v.Convert(stringType).String())
+}
+func (c *stringConverter) GoValueOf(v pref.Value) reflect.Value {
+	// pref.Value.String never panics, so we go through an interface
+	// conversion here to check the type.
+	s := v.Interface().(string)
+	if c.goType.Kind() == reflect.Slice && s == "" {
+		return reflect.Zero(c.goType) // ensure empty string is []byte(nil)
+	}
+	return reflect.ValueOf(s).Convert(c.goType)
+}
+func (c *stringConverter) IsValidPB(v pref.Value) bool {
+	_, ok := v.Interface().(string)
+	return ok
+}
+func (c *stringConverter) IsValidGo(v reflect.Value) bool {
+	return v.IsValid() && v.Type() == c.goType
+}
+func (c *stringConverter) New() pref.Value  { return c.def }
+func (c *stringConverter) Zero() pref.Value { return c.def }
+
+type bytesConverter struct {
+	goType reflect.Type
+	def    pref.Value
+}
+
+func (c *bytesConverter) PBValueOf(v reflect.Value) pref.Value {
+	if v.Type() != c.goType {
+		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
+	}
+	if c.goType.Kind() == reflect.String && v.Len() == 0 {
+		return pref.ValueOfBytes(nil) // ensure empty string is []byte(nil)
+	}
+	return pref.ValueOfBytes(v.Convert(bytesType).Bytes())
+}
+func (c *bytesConverter) GoValueOf(v pref.Value) reflect.Value {
+	return reflect.ValueOf(v.Bytes()).Convert(c.goType)
+}
+func (c *bytesConverter) IsValidPB(v pref.Value) bool {
+	_, ok := v.Interface().([]byte)
+	return ok
+}
+func (c *bytesConverter) IsValidGo(v reflect.Value) bool {
+	return v.IsValid() && v.Type() == c.goType
+}
+func (c *bytesConverter) New() pref.Value  { return c.def }
+func (c *bytesConverter) Zero() pref.Value { return c.def }
+
+type enumConverter struct {
+	goType reflect.Type
+	def    pref.Value
+}
+
+func newEnumConverter(goType reflect.Type, fd pref.FieldDescriptor) Converter {
+	var def pref.Value
+	if fd.Cardinality() == pref.Repeated {
+		def = pref.ValueOfEnum(fd.Enum().Values().Get(0).Number())
+	} else {
+		def = fd.Default()
+	}
+	return &enumConverter{goType, def}
+}
+
+func (c *enumConverter) PBValueOf(v reflect.Value) pref.Value {
+	if v.Type() != c.goType {
+		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
+	}
+	return pref.ValueOfEnum(pref.EnumNumber(v.Int()))
+}
+
+func (c *enumConverter) GoValueOf(v pref.Value) reflect.Value {
+	return reflect.ValueOf(v.Enum()).Convert(c.goType)
+}
+
+func (c *enumConverter) IsValidPB(v pref.Value) bool {
+	_, ok := v.Interface().(pref.EnumNumber)
+	return ok
+}
+
+func (c *enumConverter) IsValidGo(v reflect.Value) bool {
+	return v.IsValid() && v.Type() == c.goType
+}
+
+func (c *enumConverter) New() pref.Value {
+	return c.def
+}
+
+func (c *enumConverter) Zero() pref.Value {
+	return c.def
+}
+
+type messageConverter struct {
+	goType reflect.Type
+}
+
+func newMessageConverter(goType reflect.Type) Converter {
+	return &messageConverter{goType}
+}
+
+func (c *messageConverter) PBValueOf(v reflect.Value) pref.Value {
+	if v.Type() != c.goType {
+		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
+	}
+	if m, ok := v.Interface().(pref.ProtoMessage); ok {
+		return pref.ValueOfMessage(m.ProtoReflect())
+	}
+	return pref.ValueOfMessage(legacyWrapMessage(v))
+}
+
+func (c *messageConverter) GoValueOf(v pref.Value) reflect.Value {
+	m := v.Message()
+	var rv reflect.Value
+	if u, ok := m.(unwrapper); ok {
+		rv = reflect.ValueOf(u.protoUnwrap())
+	} else {
+		rv = reflect.ValueOf(m.Interface())
+	}
+	if rv.Type() != c.goType {
+		panic(fmt.Sprintf("invalid type: got %v, want %v", rv.Type(), c.goType))
+	}
+	return rv
+}
+
+func (c *messageConverter) IsValidPB(v pref.Value) bool {
+	m := v.Message()
+	var rv reflect.Value
+	if u, ok := m.(unwrapper); ok {
+		rv = reflect.ValueOf(u.protoUnwrap())
+	} else {
+		rv = reflect.ValueOf(m.Interface())
+	}
+	return rv.Type() == c.goType
+}
+
+func (c *messageConverter) IsValidGo(v reflect.Value) bool {
+	return v.IsValid() && v.Type() == c.goType
+}
+
+func (c *messageConverter) New() pref.Value {
+	return c.PBValueOf(reflect.New(c.goType.Elem()))
+}
+
+func (c *messageConverter) Zero() pref.Value {
+	return c.PBValueOf(reflect.Zero(c.goType))
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/convert_list.go b/vendor/google.golang.org/protobuf/internal/impl/convert_list.go
new file mode 100644
index 000000000..6fccab520
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/convert_list.go
@@ -0,0 +1,141 @@
+// 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"
+	"reflect"
+
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+)
+
+func newListConverter(t reflect.Type, fd pref.FieldDescriptor) Converter {
+	switch {
+	case t.Kind() == reflect.Ptr && t.Elem().Kind() == reflect.Slice:
+		return &listPtrConverter{t, newSingularConverter(t.Elem().Elem(), fd)}
+	case t.Kind() == reflect.Slice:
+		return &listConverter{t, newSingularConverter(t.Elem(), fd)}
+	}
+	panic(fmt.Sprintf("invalid Go type %v for field %v", t, fd.FullName()))
+}
+
+type listConverter struct {
+	goType reflect.Type // []T
+	c      Converter
+}
+
+func (c *listConverter) PBValueOf(v reflect.Value) pref.Value {
+	if v.Type() != c.goType {
+		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
+	}
+	pv := reflect.New(c.goType)
+	pv.Elem().Set(v)
+	return pref.ValueOfList(&listReflect{pv, c.c})
+}
+
+func (c *listConverter) GoValueOf(v pref.Value) reflect.Value {
+	rv := v.List().(*listReflect).v
+	if rv.IsNil() {
+		return reflect.Zero(c.goType)
+	}
+	return rv.Elem()
+}
+
+func (c *listConverter) IsValidPB(v pref.Value) bool {
+	list, ok := v.Interface().(*listReflect)
+	if !ok {
+		return false
+	}
+	return list.v.Type().Elem() == c.goType
+}
+
+func (c *listConverter) IsValidGo(v reflect.Value) bool {
+	return v.IsValid() && v.Type() == c.goType
+}
+
+func (c *listConverter) New() pref.Value {
+	return pref.ValueOfList(&listReflect{reflect.New(c.goType), c.c})
+}
+
+func (c *listConverter) Zero() pref.Value {
+	return pref.ValueOfList(&listReflect{reflect.Zero(reflect.PtrTo(c.goType)), c.c})
+}
+
+type listPtrConverter struct {
+	goType reflect.Type // *[]T
+	c      Converter
+}
+
+func (c *listPtrConverter) PBValueOf(v reflect.Value) pref.Value {
+	if v.Type() != c.goType {
+		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
+	}
+	return pref.ValueOfList(&listReflect{v, c.c})
+}
+
+func (c *listPtrConverter) GoValueOf(v pref.Value) reflect.Value {
+	return v.List().(*listReflect).v
+}
+
+func (c *listPtrConverter) IsValidPB(v pref.Value) bool {
+	list, ok := v.Interface().(*listReflect)
+	if !ok {
+		return false
+	}
+	return list.v.Type() == c.goType
+}
+
+func (c *listPtrConverter) IsValidGo(v reflect.Value) bool {
+	return v.IsValid() && v.Type() == c.goType
+}
+
+func (c *listPtrConverter) New() pref.Value {
+	return c.PBValueOf(reflect.New(c.goType.Elem()))
+}
+
+func (c *listPtrConverter) Zero() pref.Value {
+	return c.PBValueOf(reflect.Zero(c.goType))
+}
+
+type listReflect struct {
+	v    reflect.Value // *[]T
+	conv Converter
+}
+
+func (ls *listReflect) Len() int {
+	if ls.v.IsNil() {
+		return 0
+	}
+	return ls.v.Elem().Len()
+}
+func (ls *listReflect) Get(i int) pref.Value {
+	return ls.conv.PBValueOf(ls.v.Elem().Index(i))
+}
+func (ls *listReflect) Set(i int, v pref.Value) {
+	ls.v.Elem().Index(i).Set(ls.conv.GoValueOf(v))
+}
+func (ls *listReflect) Append(v pref.Value) {
+	ls.v.Elem().Set(reflect.Append(ls.v.Elem(), ls.conv.GoValueOf(v)))
+}
+func (ls *listReflect) AppendMutable() pref.Value {
+	if _, ok := ls.conv.(*messageConverter); !ok {
+		panic("invalid AppendMutable on list with non-message type")
+	}
+	v := ls.NewElement()
+	ls.Append(v)
+	return v
+}
+func (ls *listReflect) Truncate(i int) {
+	ls.v.Elem().Set(ls.v.Elem().Slice(0, i))
+}
+func (ls *listReflect) NewElement() pref.Value {
+	return ls.conv.New()
+}
+func (ls *listReflect) IsValid() bool {
+	return !ls.v.IsNil()
+}
+func (ls *listReflect) protoUnwrap() interface{} {
+	return ls.v.Interface()
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/convert_map.go b/vendor/google.golang.org/protobuf/internal/impl/convert_map.go
new file mode 100644
index 000000000..de06b2593
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/convert_map.go
@@ -0,0 +1,121 @@
+// 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"
+	"reflect"
+
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+)
+
+type mapConverter struct {
+	goType           reflect.Type // map[K]V
+	keyConv, valConv Converter
+}
+
+func newMapConverter(t reflect.Type, fd pref.FieldDescriptor) *mapConverter {
+	if t.Kind() != reflect.Map {
+		panic(fmt.Sprintf("invalid Go type %v for field %v", t, fd.FullName()))
+	}
+	return &mapConverter{
+		goType:  t,
+		keyConv: newSingularConverter(t.Key(), fd.MapKey()),
+		valConv: newSingularConverter(t.Elem(), fd.MapValue()),
+	}
+}
+
+func (c *mapConverter) PBValueOf(v reflect.Value) pref.Value {
+	if v.Type() != c.goType {
+		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
+	}
+	return pref.ValueOfMap(&mapReflect{v, c.keyConv, c.valConv})
+}
+
+func (c *mapConverter) GoValueOf(v pref.Value) reflect.Value {
+	return v.Map().(*mapReflect).v
+}
+
+func (c *mapConverter) IsValidPB(v pref.Value) bool {
+	mapv, ok := v.Interface().(*mapReflect)
+	if !ok {
+		return false
+	}
+	return mapv.v.Type() == c.goType
+}
+
+func (c *mapConverter) IsValidGo(v reflect.Value) bool {
+	return v.IsValid() && v.Type() == c.goType
+}
+
+func (c *mapConverter) New() pref.Value {
+	return c.PBValueOf(reflect.MakeMap(c.goType))
+}
+
+func (c *mapConverter) Zero() pref.Value {
+	return c.PBValueOf(reflect.Zero(c.goType))
+}
+
+type mapReflect struct {
+	v       reflect.Value // map[K]V
+	keyConv Converter
+	valConv Converter
+}
+
+func (ms *mapReflect) Len() int {
+	return ms.v.Len()
+}
+func (ms *mapReflect) Has(k pref.MapKey) bool {
+	rk := ms.keyConv.GoValueOf(k.Value())
+	rv := ms.v.MapIndex(rk)
+	return rv.IsValid()
+}
+func (ms *mapReflect) Get(k pref.MapKey) pref.Value {
+	rk := ms.keyConv.GoValueOf(k.Value())
+	rv := ms.v.MapIndex(rk)
+	if !rv.IsValid() {
+		return pref.Value{}
+	}
+	return ms.valConv.PBValueOf(rv)
+}
+func (ms *mapReflect) Set(k pref.MapKey, v pref.Value) {
+	rk := ms.keyConv.GoValueOf(k.Value())
+	rv := ms.valConv.GoValueOf(v)
+	ms.v.SetMapIndex(rk, rv)
+}
+func (ms *mapReflect) Clear(k pref.MapKey) {
+	rk := ms.keyConv.GoValueOf(k.Value())
+	ms.v.SetMapIndex(rk, reflect.Value{})
+}
+func (ms *mapReflect) Mutable(k pref.MapKey) pref.Value {
+	if _, ok := ms.valConv.(*messageConverter); !ok {
+		panic("invalid Mutable on map with non-message value type")
+	}
+	v := ms.Get(k)
+	if !v.IsValid() {
+		v = ms.NewValue()
+		ms.Set(k, v)
+	}
+	return v
+}
+func (ms *mapReflect) Range(f func(pref.MapKey, pref.Value) bool) {
+	iter := mapRange(ms.v)
+	for iter.Next() {
+		k := ms.keyConv.PBValueOf(iter.Key()).MapKey()
+		v := ms.valConv.PBValueOf(iter.Value())
+		if !f(k, v) {
+			return
+		}
+	}
+}
+func (ms *mapReflect) NewValue() pref.Value {
+	return ms.valConv.New()
+}
+func (ms *mapReflect) IsValid() bool {
+	return !ms.v.IsNil()
+}
+func (ms *mapReflect) protoUnwrap() interface{} {
+	return ms.v.Interface()
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/decode.go b/vendor/google.golang.org/protobuf/internal/impl/decode.go
new file mode 100644
index 000000000..85ba1d3b3
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/decode.go
@@ -0,0 +1,274 @@
+// Copyright 2019 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 (
+	"math/bits"
+
+	"google.golang.org/protobuf/encoding/protowire"
+	"google.golang.org/protobuf/internal/errors"
+	"google.golang.org/protobuf/internal/flags"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	preg "google.golang.org/protobuf/reflect/protoregistry"
+	"google.golang.org/protobuf/runtime/protoiface"
+	piface "google.golang.org/protobuf/runtime/protoiface"
+)
+
+type unmarshalOptions struct {
+	flags    protoiface.UnmarshalInputFlags
+	resolver interface {
+		FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error)
+		FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error)
+	}
+}
+
+func (o unmarshalOptions) Options() proto.UnmarshalOptions {
+	return proto.UnmarshalOptions{
+		Merge:          true,
+		AllowPartial:   true,
+		DiscardUnknown: o.DiscardUnknown(),
+		Resolver:       o.resolver,
+	}
+}
+
+func (o unmarshalOptions) DiscardUnknown() bool { return o.flags&piface.UnmarshalDiscardUnknown != 0 }
+
+func (o unmarshalOptions) IsDefault() bool {
+	return o.flags == 0 && o.resolver == preg.GlobalTypes
+}
+
+var lazyUnmarshalOptions = unmarshalOptions{
+	resolver: preg.GlobalTypes,
+}
+
+type unmarshalOutput struct {
+	n           int // number of bytes consumed
+	initialized bool
+}
+
+// unmarshal is protoreflect.Methods.Unmarshal.
+func (mi *MessageInfo) unmarshal(in piface.UnmarshalInput) (piface.UnmarshalOutput, error) {
+	var p pointer
+	if ms, ok := in.Message.(*messageState); ok {
+		p = ms.pointer()
+	} else {
+		p = in.Message.(*messageReflectWrapper).pointer()
+	}
+	out, err := mi.unmarshalPointer(in.Buf, p, 0, unmarshalOptions{
+		flags:    in.Flags,
+		resolver: in.Resolver,
+	})
+	var flags piface.UnmarshalOutputFlags
+	if out.initialized {
+		flags |= piface.UnmarshalInitialized
+	}
+	return piface.UnmarshalOutput{
+		Flags: flags,
+	}, err
+}
+
+// errUnknown is returned during unmarshaling to indicate a parse error that
+// should result in a field being placed in the unknown fields section (for example,
+// when the wire type doesn't match) as opposed to the entire unmarshal operation
+// failing (for example, when a field extends past the available input).
+//
+// This is a sentinel error which should never be visible to the user.
+var errUnknown = errors.New("unknown")
+
+func (mi *MessageInfo) unmarshalPointer(b []byte, p pointer, groupTag protowire.Number, opts unmarshalOptions) (out unmarshalOutput, err error) {
+	mi.init()
+	if flags.ProtoLegacy && mi.isMessageSet {
+		return unmarshalMessageSet(mi, b, p, opts)
+	}
+	initialized := true
+	var requiredMask uint64
+	var exts *map[int32]ExtensionField
+	start := len(b)
+	for len(b) > 0 {
+		// Parse the tag (field number and wire type).
+		var tag uint64
+		if b[0] < 0x80 {
+			tag = uint64(b[0])
+			b = b[1:]
+		} else if len(b) >= 2 && b[1] < 128 {
+			tag = uint64(b[0]&0x7f) + uint64(b[1])<<7
+			b = b[2:]
+		} else {
+			var n int
+			tag, n = protowire.ConsumeVarint(b)
+			if n < 0 {
+				return out, protowire.ParseError(n)
+			}
+			b = b[n:]
+		}
+		var num protowire.Number
+		if n := tag >> 3; n < uint64(protowire.MinValidNumber) || n > uint64(protowire.MaxValidNumber) {
+			return out, errors.New("invalid field number")
+		} else {
+			num = protowire.Number(n)
+		}
+		wtyp := protowire.Type(tag & 7)
+
+		if wtyp == protowire.EndGroupType {
+			if num != groupTag {
+				return out, errors.New("mismatching end group marker")
+			}
+			groupTag = 0
+			break
+		}
+
+		var f *coderFieldInfo
+		if int(num) < len(mi.denseCoderFields) {
+			f = mi.denseCoderFields[num]
+		} else {
+			f = mi.coderFields[num]
+		}
+		var n int
+		err := errUnknown
+		switch {
+		case f != nil:
+			if f.funcs.unmarshal == nil {
+				break
+			}
+			var o unmarshalOutput
+			o, err = f.funcs.unmarshal(b, p.Apply(f.offset), wtyp, f, opts)
+			n = o.n
+			if err != nil {
+				break
+			}
+			requiredMask |= f.validation.requiredBit
+			if f.funcs.isInit != nil && !o.initialized {
+				initialized = false
+			}
+		default:
+			// Possible extension.
+			if exts == nil && mi.extensionOffset.IsValid() {
+				exts = p.Apply(mi.extensionOffset).Extensions()
+				if *exts == nil {
+					*exts = make(map[int32]ExtensionField)
+				}
+			}
+			if exts == nil {
+				break
+			}
+			var o unmarshalOutput
+			o, err = mi.unmarshalExtension(b, num, wtyp, *exts, opts)
+			if err != nil {
+				break
+			}
+			n = o.n
+			if !o.initialized {
+				initialized = false
+			}
+		}
+		if err != nil {
+			if err != errUnknown {
+				return out, err
+			}
+			n = protowire.ConsumeFieldValue(num, wtyp, b)
+			if n < 0 {
+				return out, protowire.ParseError(n)
+			}
+			if !opts.DiscardUnknown() && mi.unknownOffset.IsValid() {
+				u := p.Apply(mi.unknownOffset).Bytes()
+				*u = protowire.AppendTag(*u, num, wtyp)
+				*u = append(*u, b[:n]...)
+			}
+		}
+		b = b[n:]
+	}
+	if groupTag != 0 {
+		return out, errors.New("missing end group marker")
+	}
+	if mi.numRequiredFields > 0 && bits.OnesCount64(requiredMask) != int(mi.numRequiredFields) {
+		initialized = false
+	}
+	if initialized {
+		out.initialized = true
+	}
+	out.n = start - len(b)
+	return out, nil
+}
+
+func (mi *MessageInfo) unmarshalExtension(b []byte, num protowire.Number, wtyp protowire.Type, exts map[int32]ExtensionField, opts unmarshalOptions) (out unmarshalOutput, err error) {
+	x := exts[int32(num)]
+	xt := x.Type()
+	if xt == nil {
+		var err error
+		xt, err = opts.resolver.FindExtensionByNumber(mi.Desc.FullName(), num)
+		if err != nil {
+			if err == preg.NotFound {
+				return out, errUnknown
+			}
+			return out, errors.New("%v: unable to resolve extension %v: %v", mi.Desc.FullName(), num, err)
+		}
+	}
+	xi := getExtensionFieldInfo(xt)
+	if xi.funcs.unmarshal == nil {
+		return out, errUnknown
+	}
+	if flags.LazyUnmarshalExtensions {
+		if opts.IsDefault() && x.canLazy(xt) {
+			out, valid := skipExtension(b, xi, num, wtyp, opts)
+			switch valid {
+			case ValidationValid:
+				if out.initialized {
+					x.appendLazyBytes(xt, xi, num, wtyp, b[:out.n])
+					exts[int32(num)] = x
+					return out, nil
+				}
+			case ValidationInvalid:
+				return out, errors.New("invalid wire format")
+			case ValidationUnknown:
+			}
+		}
+	}
+	ival := x.Value()
+	if !ival.IsValid() && xi.unmarshalNeedsValue {
+		// Create a new message, list, or map value to fill in.
+		// For enums, create a prototype value to let the unmarshal func know the
+		// concrete type.
+		ival = xt.New()
+	}
+	v, out, err := xi.funcs.unmarshal(b, ival, num, wtyp, opts)
+	if err != nil {
+		return out, err
+	}
+	if xi.funcs.isInit == nil {
+		out.initialized = true
+	}
+	x.Set(xt, v)
+	exts[int32(num)] = x
+	return out, nil
+}
+
+func skipExtension(b []byte, xi *extensionFieldInfo, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (out unmarshalOutput, _ ValidationStatus) {
+	if xi.validation.mi == nil {
+		return out, ValidationUnknown
+	}
+	xi.validation.mi.init()
+	switch xi.validation.typ {
+	case validationTypeMessage:
+		if wtyp != protowire.BytesType {
+			return out, ValidationUnknown
+		}
+		v, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return out, ValidationUnknown
+		}
+		out, st := xi.validation.mi.validate(v, 0, opts)
+		out.n = n
+		return out, st
+	case validationTypeGroup:
+		if wtyp != protowire.StartGroupType {
+			return out, ValidationUnknown
+		}
+		out, st := xi.validation.mi.validate(b, num, opts)
+		return out, st
+	default:
+		return out, ValidationUnknown
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/encode.go b/vendor/google.golang.org/protobuf/internal/impl/encode.go
new file mode 100644
index 000000000..8c8a794c6
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/encode.go
@@ -0,0 +1,199 @@
+// Copyright 2019 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 (
+	"math"
+	"sort"
+	"sync/atomic"
+
+	"google.golang.org/protobuf/internal/flags"
+	proto "google.golang.org/protobuf/proto"
+	piface "google.golang.org/protobuf/runtime/protoiface"
+)
+
+type marshalOptions struct {
+	flags piface.MarshalInputFlags
+}
+
+func (o marshalOptions) Options() proto.MarshalOptions {
+	return proto.MarshalOptions{
+		AllowPartial:  true,
+		Deterministic: o.Deterministic(),
+		UseCachedSize: o.UseCachedSize(),
+	}
+}
+
+func (o marshalOptions) Deterministic() bool { return o.flags&piface.MarshalDeterministic != 0 }
+func (o marshalOptions) UseCachedSize() bool { return o.flags&piface.MarshalUseCachedSize != 0 }
+
+// size is protoreflect.Methods.Size.
+func (mi *MessageInfo) size(in piface.SizeInput) piface.SizeOutput {
+	var p pointer
+	if ms, ok := in.Message.(*messageState); ok {
+		p = ms.pointer()
+	} else {
+		p = in.Message.(*messageReflectWrapper).pointer()
+	}
+	size := mi.sizePointer(p, marshalOptions{
+		flags: in.Flags,
+	})
+	return piface.SizeOutput{Size: size}
+}
+
+func (mi *MessageInfo) sizePointer(p pointer, opts marshalOptions) (size int) {
+	mi.init()
+	if p.IsNil() {
+		return 0
+	}
+	if opts.UseCachedSize() && mi.sizecacheOffset.IsValid() {
+		if size := atomic.LoadInt32(p.Apply(mi.sizecacheOffset).Int32()); size >= 0 {
+			return int(size)
+		}
+	}
+	return mi.sizePointerSlow(p, opts)
+}
+
+func (mi *MessageInfo) sizePointerSlow(p pointer, opts marshalOptions) (size int) {
+	if flags.ProtoLegacy && mi.isMessageSet {
+		size = sizeMessageSet(mi, p, opts)
+		if mi.sizecacheOffset.IsValid() {
+			atomic.StoreInt32(p.Apply(mi.sizecacheOffset).Int32(), int32(size))
+		}
+		return size
+	}
+	if mi.extensionOffset.IsValid() {
+		e := p.Apply(mi.extensionOffset).Extensions()
+		size += mi.sizeExtensions(e, opts)
+	}
+	for _, f := range mi.orderedCoderFields {
+		if f.funcs.size == nil {
+			continue
+		}
+		fptr := p.Apply(f.offset)
+		if f.isPointer && fptr.Elem().IsNil() {
+			continue
+		}
+		size += f.funcs.size(fptr, f, opts)
+	}
+	if mi.unknownOffset.IsValid() {
+		u := *p.Apply(mi.unknownOffset).Bytes()
+		size += len(u)
+	}
+	if mi.sizecacheOffset.IsValid() {
+		if size > math.MaxInt32 {
+			// The size is too large for the int32 sizecache field.
+			// We will need to recompute the size when encoding;
+			// unfortunately expensive, but better than invalid output.
+			atomic.StoreInt32(p.Apply(mi.sizecacheOffset).Int32(), -1)
+		} else {
+			atomic.StoreInt32(p.Apply(mi.sizecacheOffset).Int32(), int32(size))
+		}
+	}
+	return size
+}
+
+// marshal is protoreflect.Methods.Marshal.
+func (mi *MessageInfo) marshal(in piface.MarshalInput) (out piface.MarshalOutput, err error) {
+	var p pointer
+	if ms, ok := in.Message.(*messageState); ok {
+		p = ms.pointer()
+	} else {
+		p = in.Message.(*messageReflectWrapper).pointer()
+	}
+	b, err := mi.marshalAppendPointer(in.Buf, p, marshalOptions{
+		flags: in.Flags,
+	})
+	return piface.MarshalOutput{Buf: b}, err
+}
+
+func (mi *MessageInfo) marshalAppendPointer(b []byte, p pointer, opts marshalOptions) ([]byte, error) {
+	mi.init()
+	if p.IsNil() {
+		return b, nil
+	}
+	if flags.ProtoLegacy && mi.isMessageSet {
+		return marshalMessageSet(mi, b, p, opts)
+	}
+	var err error
+	// The old marshaler encodes extensions at beginning.
+	if mi.extensionOffset.IsValid() {
+		e := p.Apply(mi.extensionOffset).Extensions()
+		// TODO: Special handling for MessageSet?
+		b, err = mi.appendExtensions(b, e, opts)
+		if err != nil {
+			return b, err
+		}
+	}
+	for _, f := range mi.orderedCoderFields {
+		if f.funcs.marshal == nil {
+			continue
+		}
+		fptr := p.Apply(f.offset)
+		if f.isPointer && fptr.Elem().IsNil() {
+			continue
+		}
+		b, err = f.funcs.marshal(b, fptr, f, opts)
+		if err != nil {
+			return b, err
+		}
+	}
+	if mi.unknownOffset.IsValid() && !mi.isMessageSet {
+		u := *p.Apply(mi.unknownOffset).Bytes()
+		b = append(b, u...)
+	}
+	return b, nil
+}
+
+func (mi *MessageInfo) sizeExtensions(ext *map[int32]ExtensionField, opts marshalOptions) (n int) {
+	if ext == nil {
+		return 0
+	}
+	for _, x := range *ext {
+		xi := getExtensionFieldInfo(x.Type())
+		if xi.funcs.size == nil {
+			continue
+		}
+		n += xi.funcs.size(x.Value(), xi.tagsize, opts)
+	}
+	return n
+}
+
+func (mi *MessageInfo) appendExtensions(b []byte, ext *map[int32]ExtensionField, opts marshalOptions) ([]byte, error) {
+	if ext == nil {
+		return b, nil
+	}
+
+	switch len(*ext) {
+	case 0:
+		return b, nil
+	case 1:
+		// Fast-path for one extension: Don't bother sorting the keys.
+		var err error
+		for _, x := range *ext {
+			xi := getExtensionFieldInfo(x.Type())
+			b, err = xi.funcs.marshal(b, x.Value(), xi.wiretag, opts)
+		}
+		return b, err
+	default:
+		// Sort the keys to provide a deterministic encoding.
+		// Not sure this is required, but the old code does it.
+		keys := make([]int, 0, len(*ext))
+		for k := range *ext {
+			keys = append(keys, int(k))
+		}
+		sort.Ints(keys)
+		var err error
+		for _, k := range keys {
+			x := (*ext)[int32(k)]
+			xi := getExtensionFieldInfo(x.Type())
+			b, err = xi.funcs.marshal(b, x.Value(), xi.wiretag, opts)
+			if err != nil {
+				return b, err
+			}
+		}
+		return b, nil
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/enum.go b/vendor/google.golang.org/protobuf/internal/impl/enum.go
new file mode 100644
index 000000000..8c1eab4bf
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/enum.go
@@ -0,0 +1,21 @@
+// Copyright 2019 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"
+
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+)
+
+type EnumInfo struct {
+	GoReflectType reflect.Type // int32 kind
+	Desc          pref.EnumDescriptor
+}
+
+func (t *EnumInfo) New(n pref.EnumNumber) pref.Enum {
+	return reflect.ValueOf(n).Convert(t.GoReflectType).Interface().(pref.Enum)
+}
+func (t *EnumInfo) Descriptor() pref.EnumDescriptor { return t.Desc }
diff --git a/vendor/google.golang.org/protobuf/internal/impl/enum_test.go b/vendor/google.golang.org/protobuf/internal/impl/enum_test.go
new file mode 100644
index 000000000..7e04500a5
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/enum_test.go
@@ -0,0 +1,20 @@
+// Copyright 2019 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_test
+
+import (
+	"testing"
+
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+
+	testpb "google.golang.org/protobuf/internal/testprotos/test"
+)
+
+func TestEnum(t *testing.T) {
+	et := testpb.ForeignEnum_FOREIGN_FOO.Type()
+	if got, want := et.New(pref.EnumNumber(testpb.ForeignEnum_FOREIGN_FOO)), pref.Enum(testpb.ForeignEnum_FOREIGN_FOO); got != want {
+		t.Errorf("testpb.ForeignEnum_FOREIGN_FOO.Type().New() = %[1]T(%[1]v), want %[2]T(%[2]v)", got, want)
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/extension.go b/vendor/google.golang.org/protobuf/internal/impl/extension.go
new file mode 100644
index 000000000..e904fd993
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/extension.go
@@ -0,0 +1,156 @@
+// Copyright 2019 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"
+	"sync"
+	"sync/atomic"
+
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+	piface "google.golang.org/protobuf/runtime/protoiface"
+)
+
+// ExtensionInfo implements ExtensionType.
+//
+// This type contains a number of exported fields for legacy compatibility.
+// The only non-deprecated use of this type is through the methods of the
+// ExtensionType interface.
+type ExtensionInfo struct {
+	// An ExtensionInfo may exist in several stages of initialization.
+	//
+	// extensionInfoUninitialized: Some or all of the legacy exported
+	// fields may be set, but none of the unexported fields have been
+	// initialized. This is the starting state for an ExtensionInfo
+	// in legacy generated code.
+	//
+	// extensionInfoDescInit: The desc field is set, but other unexported fields
+	// may not be initialized. Legacy exported fields may or may not be set.
+	// This is the starting state for an ExtensionInfo in newly generated code.
+	//
+	// extensionInfoFullInit: The ExtensionInfo is fully initialized.
+	// This state is only entered after lazy initialization is complete.
+	init uint32
+	mu   sync.Mutex
+
+	goType reflect.Type
+	desc   extensionTypeDescriptor
+	conv   Converter
+	info   *extensionFieldInfo // for fast-path method implementations
+
+	// ExtendedType is a typed nil-pointer to the parent message type that
+	// is being extended. It is possible for this to be unpopulated in v2
+	// since the message may no longer implement the MessageV1 interface.
+	//
+	// Deprecated: Use the ExtendedType method instead.
+	ExtendedType piface.MessageV1
+
+	// ExtensionType is the zero value of the extension type.
+	//
+	// For historical reasons, reflect.TypeOf(ExtensionType) and the
+	// type returned by InterfaceOf may not be identical.
+	//
+	// Deprecated: Use InterfaceOf(xt.Zero()) instead.
+	ExtensionType interface{}
+
+	// Field is the field number of the extension.
+	//
+	// Deprecated: Use the Descriptor().Number method instead.
+	Field int32
+
+	// Name is the fully qualified name of extension.
+	//
+	// Deprecated: Use the Descriptor().FullName method instead.
+	Name string
+
+	// Tag is the protobuf struct tag used in the v1 API.
+	//
+	// Deprecated: Do not use.
+	Tag string
+
+	// Filename is the proto filename in which the extension is defined.
+	//
+	// Deprecated: Use Descriptor().ParentFile().Path() instead.
+	Filename string
+}
+
+// Stages of initialization: See the ExtensionInfo.init field.
+const (
+	extensionInfoUninitialized = 0
+	extensionInfoDescInit      = 1
+	extensionInfoFullInit      = 2
+)
+
+func InitExtensionInfo(xi *ExtensionInfo, xd pref.ExtensionDescriptor, goType reflect.Type) {
+	xi.goType = goType
+	xi.desc = extensionTypeDescriptor{xd, xi}
+	xi.init = extensionInfoDescInit
+}
+
+func (xi *ExtensionInfo) New() pref.Value {
+	return xi.lazyInit().New()
+}
+func (xi *ExtensionInfo) Zero() pref.Value {
+	return xi.lazyInit().Zero()
+}
+func (xi *ExtensionInfo) ValueOf(v interface{}) pref.Value {
+	return xi.lazyInit().PBValueOf(reflect.ValueOf(v))
+}
+func (xi *ExtensionInfo) InterfaceOf(v pref.Value) interface{} {
+	return xi.lazyInit().GoValueOf(v).Interface()
+}
+func (xi *ExtensionInfo) IsValidValue(v pref.Value) bool {
+	return xi.lazyInit().IsValidPB(v)
+}
+func (xi *ExtensionInfo) IsValidInterface(v interface{}) bool {
+	return xi.lazyInit().IsValidGo(reflect.ValueOf(v))
+}
+func (xi *ExtensionInfo) TypeDescriptor() pref.ExtensionTypeDescriptor {
+	if atomic.LoadUint32(&xi.init) < extensionInfoDescInit {
+		xi.lazyInitSlow()
+	}
+	return &xi.desc
+}
+
+func (xi *ExtensionInfo) lazyInit() Converter {
+	if atomic.LoadUint32(&xi.init) < extensionInfoFullInit {
+		xi.lazyInitSlow()
+	}
+	return xi.conv
+}
+
+func (xi *ExtensionInfo) lazyInitSlow() {
+	xi.mu.Lock()
+	defer xi.mu.Unlock()
+
+	if xi.init == extensionInfoFullInit {
+		return
+	}
+	defer atomic.StoreUint32(&xi.init, extensionInfoFullInit)
+
+	if xi.desc.ExtensionDescriptor == nil {
+		xi.initFromLegacy()
+	}
+	if !xi.desc.ExtensionDescriptor.IsPlaceholder() {
+		if xi.ExtensionType == nil {
+			xi.initToLegacy()
+		}
+		xi.conv = NewConverter(xi.goType, xi.desc.ExtensionDescriptor)
+		xi.info = makeExtensionFieldInfo(xi.desc.ExtensionDescriptor)
+		xi.info.validation = newValidationInfo(xi.desc.ExtensionDescriptor, xi.goType)
+	}
+}
+
+type extensionTypeDescriptor struct {
+	pref.ExtensionDescriptor
+	xi *ExtensionInfo
+}
+
+func (xtd *extensionTypeDescriptor) Type() pref.ExtensionType {
+	return xtd.xi
+}
+func (xtd *extensionTypeDescriptor) Descriptor() pref.ExtensionDescriptor {
+	return xtd.ExtensionDescriptor
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/extension_test.go b/vendor/google.golang.org/protobuf/internal/impl/extension_test.go
new file mode 100644
index 000000000..171f31222
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/extension_test.go
@@ -0,0 +1,132 @@
+// Copyright 2019 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_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+
+	"google.golang.org/protobuf/proto"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+
+	testpb "google.golang.org/protobuf/internal/testprotos/test"
+)
+
+func TestExtensionType(t *testing.T) {
+	cmpOpts := cmp.Options{
+		cmp.Comparer(func(x, y proto.Message) bool {
+			return proto.Equal(x, y)
+		}),
+	}
+	for _, test := range []struct {
+		xt    pref.ExtensionType
+		value interface{}
+	}{
+		{
+			xt:    testpb.E_OptionalInt32,
+			value: int32(0),
+		},
+		{
+			xt:    testpb.E_OptionalInt64,
+			value: int64(0),
+		},
+		{
+			xt:    testpb.E_OptionalUint32,
+			value: uint32(0),
+		},
+		{
+			xt:    testpb.E_OptionalUint64,
+			value: uint64(0),
+		},
+		{
+			xt:    testpb.E_OptionalFloat,
+			value: float32(0),
+		},
+		{
+			xt:    testpb.E_OptionalDouble,
+			value: float64(0),
+		},
+		{
+			xt:    testpb.E_OptionalBool,
+			value: true,
+		},
+		{
+			xt:    testpb.E_OptionalString,
+			value: "",
+		},
+		{
+			xt:    testpb.E_OptionalBytes,
+			value: []byte{},
+		},
+		{
+			xt:    testpb.E_OptionalNestedMessage,
+			value: &testpb.TestAllExtensions_NestedMessage{},
+		},
+		{
+			xt:    testpb.E_OptionalNestedEnum,
+			value: testpb.TestAllTypes_FOO,
+		},
+		{
+			xt:    testpb.E_RepeatedInt32,
+			value: []int32{0},
+		},
+		{
+			xt:    testpb.E_RepeatedInt64,
+			value: []int64{0},
+		},
+		{
+			xt:    testpb.E_RepeatedUint32,
+			value: []uint32{0},
+		},
+		{
+			xt:    testpb.E_RepeatedUint64,
+			value: []uint64{0},
+		},
+		{
+			xt:    testpb.E_RepeatedFloat,
+			value: []float32{0},
+		},
+		{
+			xt:    testpb.E_RepeatedDouble,
+			value: []float64{0},
+		},
+		{
+			xt:    testpb.E_RepeatedBool,
+			value: []bool{true},
+		},
+		{
+			xt:    testpb.E_RepeatedString,
+			value: []string{""},
+		},
+		{
+			xt:    testpb.E_RepeatedBytes,
+			value: [][]byte{nil},
+		},
+		{
+			xt:    testpb.E_RepeatedNestedMessage,
+			value: []*testpb.TestAllExtensions_NestedMessage{{}},
+		},
+		{
+			xt:    testpb.E_RepeatedNestedEnum,
+			value: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_FOO},
+		},
+	} {
+		name := test.xt.TypeDescriptor().FullName()
+		t.Run(fmt.Sprint(name), func(t *testing.T) {
+			if !test.xt.IsValidInterface(test.value) {
+				t.Fatalf("IsValidInterface(%[1]T(%[1]v)) = false, want true", test.value)
+			}
+			v := test.xt.ValueOf(test.value)
+			if !test.xt.IsValidValue(v) {
+				t.Fatalf("IsValidValue(%[1]T(%[1]v)) = false, want true", v)
+			}
+			if got, want := test.xt.InterfaceOf(v), test.value; !cmp.Equal(got, want, cmpOpts) {
+				t.Fatalf("round trip InterfaceOf(ValueOf(x)) = %v, want %v", got, want)
+			}
+		})
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/lazy_test.go b/vendor/google.golang.org/protobuf/internal/impl/lazy_test.go
new file mode 100644
index 000000000..3a52f874b
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/lazy_test.go
@@ -0,0 +1,52 @@
+// Copyright 2020 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_test
+
+import (
+	"testing"
+
+	"google.golang.org/protobuf/internal/flags"
+	"google.golang.org/protobuf/internal/impl"
+	"google.golang.org/protobuf/internal/protobuild"
+	"google.golang.org/protobuf/proto"
+
+	testpb "google.golang.org/protobuf/internal/testprotos/test"
+)
+
+func TestLazyExtensions(t *testing.T) {
+	checkLazy := func(when string, m *testpb.TestAllExtensions, want bool) {
+		xd := testpb.E_OptionalNestedMessage.TypeDescriptor()
+		if got := impl.IsLazy(m.ProtoReflect(), xd); got != want {
+			t.Errorf("%v: m.optional_nested_message lazy=%v, want %v", when, got, want)
+		}
+		e := proto.GetExtension(m, testpb.E_OptionalNestedMessage).(*testpb.TestAllExtensions_NestedMessage).Corecursive
+		if got := impl.IsLazy(e.ProtoReflect(), xd); got != want {
+			t.Errorf("%v: m.optional_nested_message.corecursive.optional_nested_message lazy=%v, want %v", when, got, want)
+		}
+	}
+
+	m1 := &testpb.TestAllExtensions{}
+	protobuild.Message{
+		"optional_nested_message": protobuild.Message{
+			"a": 1,
+			"corecursive": protobuild.Message{
+				"optional_nested_message": protobuild.Message{
+					"a": 2,
+				},
+			},
+		},
+	}.Build(m1.ProtoReflect())
+	checkLazy("before unmarshal", m1, false)
+
+	w, err := proto.Marshal(m1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	m := &testpb.TestAllExtensions{}
+	if err := proto.Unmarshal(w, m); err != nil {
+		t.Fatal(err)
+	}
+	checkLazy("after unmarshal", m, flags.LazyUnmarshalExtensions)
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/legacy_aberrant_test.go b/vendor/google.golang.org/protobuf/internal/impl/legacy_aberrant_test.go
new file mode 100644
index 000000000..905981a47
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/legacy_aberrant_test.go
@@ -0,0 +1,358 @@
+// Copyright 2019 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_test
+
+import (
+	"io"
+	"reflect"
+	"sync"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+
+	"google.golang.org/protobuf/encoding/prototext"
+	"google.golang.org/protobuf/internal/impl"
+	"google.golang.org/protobuf/reflect/protodesc"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/runtime/protoiface"
+	"google.golang.org/protobuf/testing/protocmp"
+
+	"google.golang.org/protobuf/types/descriptorpb"
+)
+
+type AberrantMessage struct {
+	OptionalBool     *bool            `protobuf:"varint,1,opt,name=opt_bool,def=1"`
+	OptionalInt32    *int32           `protobuf:"varint,2,opt,name=opt_int32,def=-12345"`
+	OptionalSint32   *int32           `protobuf:"zigzag32,3,opt,name=opt_sint32,def=-3200"`
+	OptionalUint32   *uint32          `protobuf:"varint,4,opt,name=opt_uint32,def=3200"`
+	OptionalInt64    *int64           `protobuf:"varint,5,opt,name=opt_int64,def=-123456789"`
+	OptionalSint64   *int64           `protobuf:"zigzag64,6,opt,name=opt_sint64,def=-6400"`
+	OptionalUint64   *uint64          `protobuf:"varint,7,opt,name=opt_uint64,def=6400"`
+	OptionalFixed32  *uint32          `protobuf:"fixed32,8,opt,name=opt_fixed32,def=320000"`
+	OptionalSfixed32 *int32           `protobuf:"fixed32,9,opt,name=opt_sfixed32,def=-320000"`
+	OptionalFloat    *float32         `protobuf:"fixed32,10,opt,name=opt_float,def=3.14159"`
+	OptionalFixed64  *uint64          `protobuf:"fixed64,11,opt,name=opt_fixed64,def=640000"`
+	OptionalSfixed64 *int64           `protobuf:"fixed64,12,opt,name=opt_sfixed64,def=-640000"`
+	OptionalDouble   *float64         `protobuf:"fixed64,13,opt,name=opt_double,def=3.14159265359"`
+	OptionalString   *string          `protobuf:"bytes,14,opt,name=opt_string,def=hello, \"world!\"\n"`
+	OptionalBytes    []byte           `protobuf:"bytes,15,opt,name=opt_bytes,def=dead\\336\\255\\276\\357beef"`
+	OptionalEnum     *AberrantEnum    `protobuf:"varint,16,opt,name=opt_enum,enum=google.golang.org.example.AberrantEnum,def=0"`
+	OptionalMessage  *AberrantMessage `protobuf:"bytes,17,opt,name=opt_message"`
+
+	RepeatedBool     []bool             `protobuf:"varint,18,rep,packed,name=rep_bool"`
+	RepeatedInt32    []int32            `protobuf:"varint,19,rep,packed,name=rep_int32"`
+	RepeatedSint32   []int32            `protobuf:"zigzag32,20,rep,packed,name=rep_sint32"`
+	RepeatedUint32   []uint32           `protobuf:"varint,21,rep,packed,name=rep_uint32"`
+	RepeatedInt64    []int64            `protobuf:"varint,22,rep,packed,name=rep_int64"`
+	RepeatedSint64   []int64            `protobuf:"zigzag64,23,rep,packed,name=rep_sint64"`
+	RepeatedUint64   []uint64           `protobuf:"varint,24,rep,packed,name=rep_uint64"`
+	RepeatedFixed32  []uint32           `protobuf:"fixed32,25,rep,packed,name=rep_fixed32"`
+	RepeatedSfixed32 []int32            `protobuf:"fixed32,26,rep,packed,name=rep_sfixed32"`
+	RepeatedFloat    []float32          `protobuf:"fixed32,27,rep,packed,name=rep_float"`
+	RepeatedFixed64  []uint64           `protobuf:"fixed64,28,rep,packed,name=rep_fixed64"`
+	RepeatedSfixed64 []int64            `protobuf:"fixed64,29,rep,packed,name=rep_sfixed64"`
+	RepeatedDouble   []float64          `protobuf:"fixed64,30,rep,packed,name=rep_double"`
+	RepeatedString   []string           `protobuf:"bytes,31,rep,name=rep_string"`
+	RepeatedBytes    [][]byte           `protobuf:"bytes,32,rep,name=rep_bytes"`
+	RepeatedEnum     []AberrantEnum     `protobuf:"varint,33,rep,name=rep_enum,enum=google.golang.org.example.AberrantEnum"`
+	RepeatedMessage  []*AberrantMessage `protobuf:"bytes,34,rep,name=rep_message"`
+
+	MapStringBool     map[string]bool             `protobuf:"bytes,35,rep,name=map_string_bool"     protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
+	MapStringInt32    map[string]int32            `protobuf:"bytes,36,rep,name=map_string_int32"    protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
+	MapStringSint32   map[string]int32            `protobuf:"bytes,37,rep,name=map_string_sint32"   protobuf_key:"bytes,1,opt,name=key" protobuf_val:"zigzag32,2,opt,name=value"`
+	MapStringUint32   map[string]uint32           `protobuf:"bytes,38,rep,name=map_string_uint32"   protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
+	MapStringInt64    map[string]int64            `protobuf:"bytes,39,rep,name=map_string_int64"    protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
+	MapStringSint64   map[string]int64            `protobuf:"bytes,40,rep,name=map_string_sint64"   protobuf_key:"bytes,1,opt,name=key" protobuf_val:"zigzag64,2,opt,name=value"`
+	MapStringUint64   map[string]uint64           `protobuf:"bytes,41,rep,name=map_string_uint64"   protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
+	MapStringFixed32  map[string]uint32           `protobuf:"bytes,42,rep,name=map_string_fixed32"  protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
+	MapStringSfixed32 map[string]int32            `protobuf:"bytes,43,rep,name=map_string_sfixed32" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
+	MapStringFloat    map[string]float32          `protobuf:"bytes,44,rep,name=map_string_float"    protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
+	MapStringFixed64  map[string]uint64           `protobuf:"bytes,45,rep,name=map_string_fixed64"  protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
+	MapStringSfixed64 map[string]int64            `protobuf:"bytes,46,rep,name=map_string_sfixed64" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
+	MapStringDouble   map[string]float64          `protobuf:"bytes,47,rep,name=map_string_double"   protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
+	MapStringString   map[string]string           `protobuf:"bytes,48,rep,name=map_string_string"   protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+	MapStringBytes    map[string][]byte           `protobuf:"bytes,49,rep,name=map_string_bytes"    protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+	MapStringEnum     map[string]AberrantEnum     `protobuf:"bytes,50,rep,name=map_string_enum"     protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=google.golang.org.example.AberrantEnum"`
+	MapStringMessage  map[string]*AberrantMessage `protobuf:"bytes,51,rep,name=map_string_message"  protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+
+	OneofUnion isOneofUnion `protobuf_oneof:"oneof_union"`
+
+	Ignored io.Reader
+}
+
+func (m *AberrantMessage) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return []protoiface.ExtensionRangeV1{{Start: 10, End: 100}}
+}
+
+func (m *AberrantMessage) XXX_OneofFuncs() []interface{} {
+	return []interface{}{
+		(*OneofBool)(nil),
+		(*OneofInt32)(nil),
+		(*OneofSint32)(nil),
+		(*OneofUint32)(nil),
+		(*OneofInt64)(nil),
+		(*OneofSint64)(nil),
+		(*OneofUint64)(nil),
+		(*OneofFixed32)(nil),
+		(*OneofSfixed32)(nil),
+		(*OneofFloat)(nil),
+		(*OneofFixed64)(nil),
+		(*OneofSfixed64)(nil),
+		(*OneofDouble)(nil),
+		(*OneofString)(nil),
+		(*OneofBytes)(nil),
+		(*OneofEnum)(nil),
+		(*OneofMessage)(nil),
+	}
+}
+
+type isOneofUnion interface{ isOneofUnion() }
+
+type OneofBool struct {
+	OneofBool bool `protobuf:"varint,52,opt,name=oneof_bool,oneof,def=1"`
+}
+type OneofInt32 struct {
+	OneofInt32 int32 `protobuf:"varint,53,opt,name=oneof_int32,oneof,def=-12345"`
+}
+type OneofSint32 struct {
+	OneofSint32 int32 `protobuf:"zigzag32,54,opt,name=oneof_sint32,oneof,def=-3200"`
+}
+type OneofUint32 struct {
+	OneofUint32 uint32 `protobuf:"varint,55,opt,name=oneof_uint32,oneof,def=3200"`
+}
+type OneofInt64 struct {
+	OneofInt64 int64 `protobuf:"varint,56,opt,name=oneof_int64,oneof,def=-123456789"`
+}
+type OneofSint64 struct {
+	OneofSint64 int64 `protobuf:"zigzag64,57,opt,name=oneof_sint64,oneof,def=-6400"`
+}
+type OneofUint64 struct {
+	OneofUint64 uint64 `protobuf:"varint,58,opt,name=oneof_uint64,oneof,def=6400"`
+}
+type OneofFixed32 struct {
+	OneofFixed32 uint32 `protobuf:"fixed32,59,opt,name=oneof_fixed32,oneof,def=320000"`
+}
+type OneofSfixed32 struct {
+	OneofSfixed32 int32 `protobuf:"fixed32,60,opt,name=oneof_sfixed32,oneof,def=-320000"`
+}
+type OneofFloat struct {
+	OneofFloat float32 `protobuf:"fixed32,61,opt,name=oneof_float,oneof,def=3.14159"`
+}
+type OneofFixed64 struct {
+	OneofFixed64 uint64 `protobuf:"fixed64,62,opt,name=oneof_fixed64,oneof,def=640000"`
+}
+type OneofSfixed64 struct {
+	OneofSfixed64 int64 `protobuf:"fixed64,63,opt,name=oneof_sfixed64,oneof,def=-640000"`
+}
+type OneofDouble struct {
+	OneofDouble float64 `protobuf:"fixed64,64,opt,name=oneof_double,oneof,def=3.14159265359"`
+}
+type OneofString struct {
+	OneofString string `protobuf:"bytes,65,opt,name=oneof_string,oneof,def=hello, \"world!\"\n"`
+}
+type OneofBytes struct {
+	OneofBytes []byte `protobuf:"bytes,66,opt,name=oneof_bytes,oneof,def=dead\\336\\255\\276\\357beef"`
+}
+type OneofEnum struct {
+	OneofEnum AberrantEnum `protobuf:"varint,67,opt,name=oneof_enum,enum=google.golang.org.example.AberrantEnum,oneof,def=0"`
+}
+type OneofMessage struct {
+	OneofMessage *AberrantMessage `protobuf:"bytes,68,opt,name=oneof_message,oneof"`
+}
+
+func (OneofBool) isOneofUnion()     {}
+func (OneofInt32) isOneofUnion()    {}
+func (OneofSint32) isOneofUnion()   {}
+func (OneofUint32) isOneofUnion()   {}
+func (OneofInt64) isOneofUnion()    {}
+func (OneofSint64) isOneofUnion()   {}
+func (OneofUint64) isOneofUnion()   {}
+func (OneofFixed32) isOneofUnion()  {}
+func (OneofSfixed32) isOneofUnion() {}
+func (OneofFloat) isOneofUnion()    {}
+func (OneofFixed64) isOneofUnion()  {}
+func (OneofSfixed64) isOneofUnion() {}
+func (OneofDouble) isOneofUnion()   {}
+func (OneofString) isOneofUnion()   {}
+func (OneofBytes) isOneofUnion()    {}
+func (OneofEnum) isOneofUnion()     {}
+func (OneofMessage) isOneofUnion()  {}
+
+type AberrantEnum int32
+
+func TestAberrantMessages(t *testing.T) {
+	enumName := impl.AberrantDeriveFullName(reflect.TypeOf(AberrantEnum(0)))
+	messageName := impl.AberrantDeriveFullName(reflect.TypeOf(AberrantMessage{}))
+
+	want := new(descriptorpb.DescriptorProto)
+	if err := prototext.Unmarshal([]byte(`
+		name: "AberrantMessage"
+		field: [
+			{name:"opt_bool"     number:1  label:LABEL_OPTIONAL type:TYPE_BOOL     default_value:"true"},
+			{name:"opt_int32"    number:2  label:LABEL_OPTIONAL type:TYPE_INT32    default_value:"-12345"},
+			{name:"opt_sint32"   number:3  label:LABEL_OPTIONAL type:TYPE_SINT32   default_value:"-3200"},
+			{name:"opt_uint32"   number:4  label:LABEL_OPTIONAL type:TYPE_UINT32   default_value:"3200"},
+			{name:"opt_int64"    number:5  label:LABEL_OPTIONAL type:TYPE_INT64    default_value:"-123456789"},
+			{name:"opt_sint64"   number:6  label:LABEL_OPTIONAL type:TYPE_SINT64   default_value:"-6400"},
+			{name:"opt_uint64"   number:7  label:LABEL_OPTIONAL type:TYPE_UINT64   default_value:"6400"},
+			{name:"opt_fixed32"  number:8  label:LABEL_OPTIONAL type:TYPE_FIXED32  default_value:"320000"},
+			{name:"opt_sfixed32" number:9  label:LABEL_OPTIONAL type:TYPE_SFIXED32 default_value:"-320000"},
+			{name:"opt_float"    number:10 label:LABEL_OPTIONAL type:TYPE_FLOAT    default_value:"3.14159"},
+			{name:"opt_fixed64"  number:11 label:LABEL_OPTIONAL type:TYPE_FIXED64  default_value:"640000"},
+			{name:"opt_sfixed64" number:12 label:LABEL_OPTIONAL type:TYPE_SFIXED64 default_value:"-640000"},
+			{name:"opt_double"   number:13 label:LABEL_OPTIONAL type:TYPE_DOUBLE   default_value:"3.14159265359"},
+			{name:"opt_string"   number:14 label:LABEL_OPTIONAL type:TYPE_STRING   default_value:"hello, \"world!\"\n"},
+			{name:"opt_bytes"    number:15 label:LABEL_OPTIONAL type:TYPE_BYTES    default_value:"dead\\336\\255\\276\\357beef"},
+			{name:"opt_enum"     number:16 label:LABEL_OPTIONAL type:TYPE_ENUM     type_name:".`+enumName+`" default_value:"UNKNOWN_0"},
+			{name:"opt_message"  number:17 label:LABEL_OPTIONAL type:TYPE_MESSAGE  type_name:".`+messageName+`"},
+
+			{name:"rep_bool"     number:18 label:LABEL_REPEATED type:TYPE_BOOL     options:{packed:true}},
+			{name:"rep_int32"    number:19 label:LABEL_REPEATED type:TYPE_INT32    options:{packed:true}},
+			{name:"rep_sint32"   number:20 label:LABEL_REPEATED type:TYPE_SINT32   options:{packed:true}},
+			{name:"rep_uint32"   number:21 label:LABEL_REPEATED type:TYPE_UINT32   options:{packed:true}},
+			{name:"rep_int64"    number:22 label:LABEL_REPEATED type:TYPE_INT64    options:{packed:true}},
+			{name:"rep_sint64"   number:23 label:LABEL_REPEATED type:TYPE_SINT64   options:{packed:true}},
+			{name:"rep_uint64"   number:24 label:LABEL_REPEATED type:TYPE_UINT64   options:{packed:true}},
+			{name:"rep_fixed32"  number:25 label:LABEL_REPEATED type:TYPE_FIXED32  options:{packed:true}},
+			{name:"rep_sfixed32" number:26 label:LABEL_REPEATED type:TYPE_SFIXED32 options:{packed:true}},
+			{name:"rep_float"    number:27 label:LABEL_REPEATED type:TYPE_FLOAT    options:{packed:true}},
+			{name:"rep_fixed64"  number:28 label:LABEL_REPEATED type:TYPE_FIXED64  options:{packed:true}},
+			{name:"rep_sfixed64" number:29 label:LABEL_REPEATED type:TYPE_SFIXED64 options:{packed:true}},
+			{name:"rep_double"   number:30 label:LABEL_REPEATED type:TYPE_DOUBLE   options:{packed:true}},
+			{name:"rep_string"   number:31 label:LABEL_REPEATED type:TYPE_STRING},
+			{name:"rep_bytes"    number:32 label:LABEL_REPEATED type:TYPE_BYTES},
+			{name:"rep_enum"     number:33 label:LABEL_REPEATED type:TYPE_ENUM     type_name:".`+enumName+`"},
+			{name:"rep_message"  number:34 label:LABEL_REPEATED type:TYPE_MESSAGE  type_name:".`+messageName+`"},
+
+			{name:"map_string_bool"     number:35 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".`+messageName+`.MapStringBoolEntry"},
+			{name:"map_string_int32"    number:36 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".`+messageName+`.MapStringInt32Entry"},
+			{name:"map_string_sint32"   number:37 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".`+messageName+`.MapStringSint32Entry"},
+			{name:"map_string_uint32"   number:38 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".`+messageName+`.MapStringUint32Entry"},
+			{name:"map_string_int64"    number:39 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".`+messageName+`.MapStringInt64Entry"},
+			{name:"map_string_sint64"   number:40 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".`+messageName+`.MapStringSint64Entry"},
+			{name:"map_string_uint64"   number:41 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".`+messageName+`.MapStringUint64Entry"},
+			{name:"map_string_fixed32"  number:42 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".`+messageName+`.MapStringFixed32Entry"},
+			{name:"map_string_sfixed32" number:43 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".`+messageName+`.MapStringSfixed32Entry"},
+			{name:"map_string_float"    number:44 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".`+messageName+`.MapStringFloatEntry"},
+			{name:"map_string_fixed64"  number:45 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".`+messageName+`.MapStringFixed64Entry"},
+			{name:"map_string_sfixed64" number:46 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".`+messageName+`.MapStringSfixed64Entry"},
+			{name:"map_string_double"   number:47 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".`+messageName+`.MapStringDoubleEntry"},
+			{name:"map_string_string"   number:48 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".`+messageName+`.MapStringStringEntry"},
+			{name:"map_string_bytes"    number:49 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".`+messageName+`.MapStringBytesEntry"},
+			{name:"map_string_enum"     number:50 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".`+messageName+`.MapStringEnumEntry"},
+			{name:"map_string_message"  number:51 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".`+messageName+`.MapStringMessageEntry"},
+
+			{name:"oneof_bool"     number:52 label:LABEL_OPTIONAL type:TYPE_BOOL     oneof_index:0 default_value:"true"},
+			{name:"oneof_int32"    number:53 label:LABEL_OPTIONAL type:TYPE_INT32    oneof_index:0 default_value:"-12345"},
+			{name:"oneof_sint32"   number:54 label:LABEL_OPTIONAL type:TYPE_SINT32   oneof_index:0 default_value:"-3200"},
+			{name:"oneof_uint32"   number:55 label:LABEL_OPTIONAL type:TYPE_UINT32   oneof_index:0 default_value:"3200"},
+			{name:"oneof_int64"    number:56 label:LABEL_OPTIONAL type:TYPE_INT64    oneof_index:0 default_value:"-123456789"},
+			{name:"oneof_sint64"   number:57 label:LABEL_OPTIONAL type:TYPE_SINT64   oneof_index:0 default_value:"-6400"},
+			{name:"oneof_uint64"   number:58 label:LABEL_OPTIONAL type:TYPE_UINT64   oneof_index:0 default_value:"6400"},
+			{name:"oneof_fixed32"  number:59 label:LABEL_OPTIONAL type:TYPE_FIXED32  oneof_index:0 default_value:"320000"},
+			{name:"oneof_sfixed32" number:60 label:LABEL_OPTIONAL type:TYPE_SFIXED32 oneof_index:0 default_value:"-320000"},
+			{name:"oneof_float"    number:61 label:LABEL_OPTIONAL type:TYPE_FLOAT    oneof_index:0 default_value:"3.14159"},
+			{name:"oneof_fixed64"  number:62 label:LABEL_OPTIONAL type:TYPE_FIXED64  oneof_index:0 default_value:"640000"},
+			{name:"oneof_sfixed64" number:63 label:LABEL_OPTIONAL type:TYPE_SFIXED64 oneof_index:0 default_value:"-640000"},
+			{name:"oneof_double"   number:64 label:LABEL_OPTIONAL type:TYPE_DOUBLE   oneof_index:0 default_value:"3.14159265359"},
+			{name:"oneof_string"   number:65 label:LABEL_OPTIONAL type:TYPE_STRING   oneof_index:0 default_value:"hello, \"world!\"\n"},
+			{name:"oneof_bytes"    number:66 label:LABEL_OPTIONAL type:TYPE_BYTES    oneof_index:0 default_value:"dead\\336\\255\\276\\357beef"},
+			{name:"oneof_enum"     number:67 label:LABEL_OPTIONAL type:TYPE_ENUM     oneof_index:0 type_name:".`+enumName+`" default_value:"UNKNOWN_0"},
+			{name:"oneof_message"  number:68 label:LABEL_OPTIONAL type:TYPE_MESSAGE  oneof_index:0 type_name:".`+messageName+`"}
+		]
+		oneof_decl: [{name:"oneof_union"}]
+		extension_range: [{start:10 end:101}]
+		nested_type: [
+			{name:"MapStringBoolEntry"     field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_BOOL}]     options:{map_entry:true}},
+			{name:"MapStringInt32Entry"    field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_INT32}]    options:{map_entry:true}},
+			{name:"MapStringSint32Entry"   field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_SINT32}]   options:{map_entry:true}},
+			{name:"MapStringUint32Entry"   field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_UINT32}]   options:{map_entry:true}},
+			{name:"MapStringInt64Entry"    field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_INT64}]    options:{map_entry:true}},
+			{name:"MapStringSint64Entry"   field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_SINT64}]   options:{map_entry:true}},
+			{name:"MapStringUint64Entry"   field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_UINT64}]   options:{map_entry:true}},
+			{name:"MapStringFixed32Entry"  field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_FIXED32}]  options:{map_entry:true}},
+			{name:"MapStringSfixed32Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_SFIXED32}] options:{map_entry:true}},
+			{name:"MapStringFloatEntry"    field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_FLOAT}]    options:{map_entry:true}},
+			{name:"MapStringFixed64Entry"  field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_FIXED64}]  options:{map_entry:true}},
+			{name:"MapStringSfixed64Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_SFIXED64}] options:{map_entry:true}},
+			{name:"MapStringDoubleEntry"   field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_DOUBLE}]   options:{map_entry:true}},
+			{name:"MapStringStringEntry"   field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}]   options:{map_entry:true}},
+			{name:"MapStringBytesEntry"    field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_BYTES}]    options:{map_entry:true}},
+			{name:"MapStringEnumEntry"     field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_ENUM    type_name:".`+enumName+`"}] options:{map_entry:true}},
+			{name:"MapStringMessageEntry"  field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_MESSAGE type_name:".`+messageName+`"}]                  options:{map_entry:true}}
+		]
+	`), want); err != nil {
+		t.Fatalf("prototext.Unmarshal() error: %v", err)
+	}
+
+	md := impl.LegacyLoadMessageDesc(reflect.TypeOf(&AberrantMessage{}))
+	got := protodesc.ToDescriptorProto(md)
+	if diff := cmp.Diff(want, got, protocmp.Transform()); diff != "" {
+		t.Errorf("mismatching descriptor (-want +got):\n%s", diff)
+	}
+}
+
+type AberrantMessage1 struct {
+	M *AberrantMessage2 `protobuf:"bytes,1,opt,name=message"`
+}
+
+type AberrantMessage2 struct {
+	M *AberrantMessage1 `protobuf:"bytes,1,opt,name=message"`
+}
+
+func TestAberrantRace(t *testing.T) {
+	var gotMD1, wantMD1, gotMD2, wantMD2 protoreflect.MessageDescriptor
+
+	var wg sync.WaitGroup
+	wg.Add(2)
+	go func() {
+		defer wg.Done()
+		md := impl.LegacyLoadMessageDesc(reflect.TypeOf(&AberrantMessage1{}))
+		wantMD2 = md.Fields().Get(0).Message()
+		gotMD2 = wantMD2.Fields().Get(0).Message().Fields().Get(0).Message()
+	}()
+	go func() {
+		defer wg.Done()
+		md := impl.LegacyLoadMessageDesc(reflect.TypeOf(&AberrantMessage2{}))
+		wantMD1 = md.Fields().Get(0).Message()
+		gotMD1 = wantMD1.Fields().Get(0).Message().Fields().Get(0).Message()
+	}()
+	wg.Wait()
+
+	if gotMD1 != wantMD1 || gotMD2 != wantMD2 {
+		t.Errorf("mismatching exact message descriptors")
+	}
+}
+
+func TestAberrantExtensions(t *testing.T) {
+	tests := []struct {
+		in              *impl.ExtensionInfo
+		wantName        protoreflect.FullName
+		wantNumber      protoreflect.FieldNumber
+		wantPlaceholder bool
+	}{{
+		in:              &impl.ExtensionInfo{Field: 500},
+		wantNumber:      500,
+		wantPlaceholder: true,
+	}, {
+		in:              &impl.ExtensionInfo{Name: "foo.bar.baz"},
+		wantName:        "foo.bar.baz",
+		wantPlaceholder: true,
+	}}
+
+	for _, tt := range tests {
+		t.Run("", func(t *testing.T) {
+			xtd := tt.in.TypeDescriptor()
+			switch {
+			case xtd.FullName() != tt.wantName:
+				t.Errorf("FullName() = %v, want %v", xtd.FullName(), tt.wantName)
+			case xtd.Number() != tt.wantNumber:
+				t.Errorf("Number() = %v, want %v", xtd.Number(), tt.wantNumber)
+			case xtd.IsPlaceholder() != tt.wantPlaceholder:
+				t.Errorf("IsPlaceholder() = %v, want %v", xtd.IsPlaceholder(), tt.wantPlaceholder)
+			}
+		})
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/legacy_enum.go b/vendor/google.golang.org/protobuf/internal/impl/legacy_enum.go
new file mode 100644
index 000000000..f7d7ffb51
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/legacy_enum.go
@@ -0,0 +1,219 @@
+// 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"
+	"reflect"
+	"strings"
+	"sync"
+
+	"google.golang.org/protobuf/internal/filedesc"
+	"google.golang.org/protobuf/internal/strs"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+)
+
+// legacyEnumName returns the name of enums used in legacy code.
+// It is neither the protobuf full name nor the qualified Go name,
+// but rather an odd hybrid of both.
+func legacyEnumName(ed pref.EnumDescriptor) string {
+	var protoPkg string
+	enumName := string(ed.FullName())
+	if fd := ed.ParentFile(); fd != nil {
+		protoPkg = string(fd.Package())
+		enumName = strings.TrimPrefix(enumName, protoPkg+".")
+	}
+	if protoPkg == "" {
+		return strs.GoCamelCase(enumName)
+	}
+	return protoPkg + "." + strs.GoCamelCase(enumName)
+}
+
+// legacyWrapEnum wraps v as a protoreflect.Enum,
+// where v must be a int32 kind and not implement the v2 API already.
+func legacyWrapEnum(v reflect.Value) pref.Enum {
+	et := legacyLoadEnumType(v.Type())
+	return et.New(pref.EnumNumber(v.Int()))
+}
+
+var legacyEnumTypeCache sync.Map // map[reflect.Type]protoreflect.EnumType
+
+// legacyLoadEnumType dynamically loads a protoreflect.EnumType for t,
+// where t must be an int32 kind and not implement the v2 API already.
+func legacyLoadEnumType(t reflect.Type) pref.EnumType {
+	// Fast-path: check if a EnumType is cached for this concrete type.
+	if et, ok := legacyEnumTypeCache.Load(t); ok {
+		return et.(pref.EnumType)
+	}
+
+	// Slow-path: derive enum descriptor and initialize EnumType.
+	var et pref.EnumType
+	ed := LegacyLoadEnumDesc(t)
+	et = &legacyEnumType{
+		desc:   ed,
+		goType: t,
+	}
+	if et, ok := legacyEnumTypeCache.LoadOrStore(t, et); ok {
+		return et.(pref.EnumType)
+	}
+	return et
+}
+
+type legacyEnumType struct {
+	desc   pref.EnumDescriptor
+	goType reflect.Type
+	m      sync.Map // map[protoreflect.EnumNumber]proto.Enum
+}
+
+func (t *legacyEnumType) New(n pref.EnumNumber) pref.Enum {
+	if e, ok := t.m.Load(n); ok {
+		return e.(pref.Enum)
+	}
+	e := &legacyEnumWrapper{num: n, pbTyp: t, goTyp: t.goType}
+	t.m.Store(n, e)
+	return e
+}
+func (t *legacyEnumType) Descriptor() pref.EnumDescriptor {
+	return t.desc
+}
+
+type legacyEnumWrapper struct {
+	num   pref.EnumNumber
+	pbTyp pref.EnumType
+	goTyp reflect.Type
+}
+
+func (e *legacyEnumWrapper) Descriptor() pref.EnumDescriptor {
+	return e.pbTyp.Descriptor()
+}
+func (e *legacyEnumWrapper) Type() pref.EnumType {
+	return e.pbTyp
+}
+func (e *legacyEnumWrapper) Number() pref.EnumNumber {
+	return e.num
+}
+func (e *legacyEnumWrapper) ProtoReflect() pref.Enum {
+	return e
+}
+func (e *legacyEnumWrapper) protoUnwrap() interface{} {
+	v := reflect.New(e.goTyp).Elem()
+	v.SetInt(int64(e.num))
+	return v.Interface()
+}
+
+var (
+	_ pref.Enum = (*legacyEnumWrapper)(nil)
+	_ unwrapper = (*legacyEnumWrapper)(nil)
+)
+
+var legacyEnumDescCache sync.Map // map[reflect.Type]protoreflect.EnumDescriptor
+
+// LegacyLoadEnumDesc returns an EnumDescriptor derived from the Go type,
+// which must be an int32 kind and not implement the v2 API already.
+//
+// This is exported for testing purposes.
+func LegacyLoadEnumDesc(t reflect.Type) pref.EnumDescriptor {
+	// Fast-path: check if an EnumDescriptor is cached for this concrete type.
+	if ed, ok := legacyEnumDescCache.Load(t); ok {
+		return ed.(pref.EnumDescriptor)
+	}
+
+	// Slow-path: initialize EnumDescriptor from the raw descriptor.
+	ev := reflect.Zero(t).Interface()
+	if _, ok := ev.(pref.Enum); ok {
+		panic(fmt.Sprintf("%v already implements proto.Enum", t))
+	}
+	edV1, ok := ev.(enumV1)
+	if !ok {
+		return aberrantLoadEnumDesc(t)
+	}
+	b, idxs := edV1.EnumDescriptor()
+
+	var ed pref.EnumDescriptor
+	if len(idxs) == 1 {
+		ed = legacyLoadFileDesc(b).Enums().Get(idxs[0])
+	} else {
+		md := legacyLoadFileDesc(b).Messages().Get(idxs[0])
+		for _, i := range idxs[1 : len(idxs)-1] {
+			md = md.Messages().Get(i)
+		}
+		ed = md.Enums().Get(idxs[len(idxs)-1])
+	}
+	if ed, ok := legacyEnumDescCache.LoadOrStore(t, ed); ok {
+		return ed.(protoreflect.EnumDescriptor)
+	}
+	return ed
+}
+
+var aberrantEnumDescCache sync.Map // map[reflect.Type]protoreflect.EnumDescriptor
+
+// aberrantLoadEnumDesc returns an EnumDescriptor derived from the Go type,
+// which must not implement protoreflect.Enum or enumV1.
+//
+// If the type does not implement enumV1, 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 protobuf full name, which we also do not know.
+// Thus, this produces some bogus enum descriptor based on the Go type name.
+func aberrantLoadEnumDesc(t reflect.Type) pref.EnumDescriptor {
+	// Fast-path: check if an EnumDescriptor is cached for this concrete type.
+	if ed, ok := aberrantEnumDescCache.Load(t); ok {
+		return ed.(pref.EnumDescriptor)
+	}
+
+	// Slow-path: construct a bogus, but unique EnumDescriptor.
+	ed := &filedesc.Enum{L2: new(filedesc.EnumL2)}
+	ed.L0.FullName = AberrantDeriveFullName(t) // e.g., github_com.user.repo.MyEnum
+	ed.L0.ParentFile = filedesc.SurrogateProto3
+	ed.L2.Values.List = append(ed.L2.Values.List, filedesc.EnumValue{})
+
+	// TODO: Use the presence of a UnmarshalJSON method to determine proto2?
+
+	vd := &ed.L2.Values.List[0]
+	vd.L0.FullName = ed.L0.FullName + "_UNKNOWN" // e.g., github_com.user.repo.MyEnum_UNKNOWN
+	vd.L0.ParentFile = ed.L0.ParentFile
+	vd.L0.Parent = ed
+
+	// TODO: We could use the String method to obtain some enum value names by
+	// starting at 0 and print the enum until it produces invalid identifiers.
+	// An exhaustive query is clearly impractical, but can be best-effort.
+
+	if ed, ok := aberrantEnumDescCache.LoadOrStore(t, ed); ok {
+		return ed.(pref.EnumDescriptor)
+	}
+	return ed
+}
+
+// AberrantDeriveFullName 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.
+//
+// This is exported for testing purposes.
+func AberrantDeriveFullName(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, "."))
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/legacy_export.go b/vendor/google.golang.org/protobuf/internal/impl/legacy_export.go
new file mode 100644
index 000000000..c3d741c2f
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/legacy_export.go
@@ -0,0 +1,92 @@
+// Copyright 2019 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 (
+	"encoding/binary"
+	"encoding/json"
+	"hash/crc32"
+	"math"
+	"reflect"
+
+	"google.golang.org/protobuf/internal/errors"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+	piface "google.golang.org/protobuf/runtime/protoiface"
+)
+
+// These functions exist to support exported APIs in generated protobufs.
+// While these are deprecated, they cannot be removed for compatibility reasons.
+
+// LegacyEnumName returns the name of enums used in legacy code.
+func (Export) LegacyEnumName(ed pref.EnumDescriptor) string {
+	return legacyEnumName(ed)
+}
+
+// LegacyMessageTypeOf returns the protoreflect.MessageType for m,
+// with name used as the message name if necessary.
+func (Export) LegacyMessageTypeOf(m piface.MessageV1, name pref.FullName) pref.MessageType {
+	if mv := (Export{}).protoMessageV2Of(m); mv != nil {
+		return mv.ProtoReflect().Type()
+	}
+	return legacyLoadMessageInfo(reflect.TypeOf(m), name)
+}
+
+// UnmarshalJSONEnum unmarshals an enum from a JSON-encoded input.
+// The input can either be a string representing the enum value by name,
+// or a number representing the enum number itself.
+func (Export) UnmarshalJSONEnum(ed pref.EnumDescriptor, b []byte) (pref.EnumNumber, error) {
+	if b[0] == '"' {
+		var name pref.Name
+		if err := json.Unmarshal(b, &name); err != nil {
+			return 0, errors.New("invalid input for enum %v: %s", ed.FullName(), b)
+		}
+		ev := ed.Values().ByName(name)
+		if ev == nil {
+			return 0, errors.New("invalid value for enum %v: %s", ed.FullName(), name)
+		}
+		return ev.Number(), nil
+	} else {
+		var num pref.EnumNumber
+		if err := json.Unmarshal(b, &num); err != nil {
+			return 0, errors.New("invalid input for enum %v: %s", ed.FullName(), b)
+		}
+		return num, nil
+	}
+}
+
+// CompressGZIP compresses the input as a GZIP-encoded file.
+// The current implementation does no compression.
+func (Export) CompressGZIP(in []byte) (out []byte) {
+	// RFC 1952, section 2.3.1.
+	var gzipHeader = [10]byte{0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff}
+
+	// RFC 1951, section 3.2.4.
+	var blockHeader [5]byte
+	const maxBlockSize = math.MaxUint16
+	numBlocks := 1 + len(in)/maxBlockSize
+
+	// RFC 1952, section 2.3.1.
+	var gzipFooter [8]byte
+	binary.LittleEndian.PutUint32(gzipFooter[0:4], crc32.ChecksumIEEE(in))
+	binary.LittleEndian.PutUint32(gzipFooter[4:8], uint32(len(in)))
+
+	// Encode the input without compression using raw DEFLATE blocks.
+	out = make([]byte, 0, len(gzipHeader)+len(blockHeader)*numBlocks+len(in)+len(gzipFooter))
+	out = append(out, gzipHeader[:]...)
+	for blockHeader[0] == 0 {
+		blockSize := maxBlockSize
+		if blockSize > len(in) {
+			blockHeader[0] = 0x01 // final bit per RFC 1951, section 3.2.3.
+			blockSize = len(in)
+		}
+		binary.LittleEndian.PutUint16(blockHeader[1:3], uint16(blockSize)^0x0000)
+		binary.LittleEndian.PutUint16(blockHeader[3:5], uint16(blockSize)^0xffff)
+		out = append(out, blockHeader[:]...)
+		out = append(out, in[:blockSize]...)
+		in = in[blockSize:]
+	}
+	out = append(out, gzipFooter[:]...)
+	return out
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/legacy_export_test.go b/vendor/google.golang.org/protobuf/internal/impl/legacy_export_test.go
new file mode 100644
index 000000000..e1d2c08b8
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/legacy_export_test.go
@@ -0,0 +1,41 @@
+// Copyright 2019 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"
+	"math"
+	"strings"
+	"testing"
+)
+
+func TestCompressGZIP(t *testing.T) {
+	tests := []string{
+		"",
+		"a",
+		"ab",
+		"abc",
+		strings.Repeat("a", math.MaxUint16-1),
+		strings.Repeat("b", math.MaxUint16),
+		strings.Repeat("c", math.MaxUint16+1),
+		strings.Repeat("abcdefghijklmnopqrstuvwxyz", math.MaxUint16-13),
+	}
+	for _, want := range tests {
+		rb := bytes.NewReader(Export{}.CompressGZIP([]byte(want)))
+		zr, err := gzip.NewReader(rb)
+		if err != nil {
+			t.Errorf("unexpected gzip.NewReader error: %v", err)
+		}
+		b, err := ioutil.ReadAll(zr)
+		if err != nil {
+			t.Errorf("unexpected ioutil.ReadAll error: %v", err)
+		}
+		if got := string(b); got != want {
+			t.Errorf("output mismatch: got %q, want %q", got, want)
+		}
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/legacy_extension.go b/vendor/google.golang.org/protobuf/internal/impl/legacy_extension.go
new file mode 100644
index 000000000..61757ce50
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/legacy_extension.go
@@ -0,0 +1,175 @@
+// 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"
+
+	"google.golang.org/protobuf/internal/descopts"
+	"google.golang.org/protobuf/internal/encoding/messageset"
+	ptag "google.golang.org/protobuf/internal/encoding/tag"
+	"google.golang.org/protobuf/internal/filedesc"
+	"google.golang.org/protobuf/internal/pragma"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+	preg "google.golang.org/protobuf/reflect/protoregistry"
+	piface "google.golang.org/protobuf/runtime/protoiface"
+)
+
+func (xi *ExtensionInfo) initToLegacy() {
+	xd := xi.desc
+	var parent piface.MessageV1
+	messageName := xd.ContainingMessage().FullName()
+	if mt, _ := preg.GlobalTypes.FindMessageByName(messageName); mt != nil {
+		// Create a new parent message and unwrap it if possible.
+		mv := mt.New().Interface()
+		t := reflect.TypeOf(mv)
+		if mv, ok := mv.(unwrapper); ok {
+			t = reflect.TypeOf(mv.protoUnwrap())
+		}
+
+		// Check whether the message implements the legacy v1 Message interface.
+		mz := reflect.Zero(t).Interface()
+		if mz, ok := mz.(piface.MessageV1); ok {
+			parent = mz
+		}
+	}
+
+	// Determine the v1 extension type, which is unfortunately not the same as
+	// the v2 ExtensionType.GoType.
+	extType := xi.goType
+	switch extType.Kind() {
+	case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.String:
+		extType = reflect.PtrTo(extType) // T -> *T for singular scalar fields
+	}
+
+	// Reconstruct the legacy enum full name.
+	var enumName string
+	if xd.Kind() == pref.EnumKind {
+		enumName = legacyEnumName(xd.Enum())
+	}
+
+	// Derive the proto file that the extension was declared within.
+	var filename string
+	if fd := xd.ParentFile(); fd != nil {
+		filename = fd.Path()
+	}
+
+	// For MessageSet extensions, the name used is the parent message.
+	name := xd.FullName()
+	if messageset.IsMessageSetExtension(xd) {
+		name = name.Parent()
+	}
+
+	xi.ExtendedType = parent
+	xi.ExtensionType = reflect.Zero(extType).Interface()
+	xi.Field = int32(xd.Number())
+	xi.Name = string(name)
+	xi.Tag = ptag.Marshal(xd, enumName)
+	xi.Filename = filename
+}
+
+// initFromLegacy initializes an ExtensionInfo from
+// the contents of the deprecated exported fields of the type.
+func (xi *ExtensionInfo) initFromLegacy() {
+	// The v1 API returns "type incomplete" descriptors where only the
+	// field number is specified. In such a case, use a placeholder.
+	if xi.ExtendedType == nil || xi.ExtensionType == nil {
+		xd := placeholderExtension{
+			name:   pref.FullName(xi.Name),
+			number: pref.FieldNumber(xi.Field),
+		}
+		xi.desc = extensionTypeDescriptor{xd, xi}
+		return
+	}
+
+	// Resolve enum or message dependencies.
+	var ed pref.EnumDescriptor
+	var md pref.MessageDescriptor
+	t := reflect.TypeOf(xi.ExtensionType)
+	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()
+	}
+	switch v := reflect.Zero(t).Interface().(type) {
+	case pref.Enum:
+		ed = v.Descriptor()
+	case enumV1:
+		ed = LegacyLoadEnumDesc(t)
+	case pref.ProtoMessage:
+		md = v.ProtoReflect().Descriptor()
+	case messageV1:
+		md = LegacyLoadMessageDesc(t)
+	}
+
+	// Derive basic field information from the struct tag.
+	var evs pref.EnumValueDescriptors
+	if ed != nil {
+		evs = ed.Values()
+	}
+	fd := ptag.Unmarshal(xi.Tag, t, evs).(*filedesc.Field)
+
+	// Construct a v2 ExtensionType.
+	xd := &filedesc.Extension{L2: new(filedesc.ExtensionL2)}
+	xd.L0.ParentFile = filedesc.SurrogateProto2
+	xd.L0.FullName = pref.FullName(xi.Name)
+	xd.L1.Number = pref.FieldNumber(xi.Field)
+	xd.L1.Cardinality = fd.L1.Cardinality
+	xd.L1.Kind = fd.L1.Kind
+	xd.L2.IsPacked = fd.L1.IsPacked
+	xd.L2.Default = fd.L1.Default
+	xd.L1.Extendee = Export{}.MessageDescriptorOf(xi.ExtendedType)
+	xd.L2.Enum = ed
+	xd.L2.Message = md
+
+	// Derive real extension field name for MessageSets.
+	if messageset.IsMessageSet(xd.L1.Extendee) && md.FullName() == xd.L0.FullName {
+		xd.L0.FullName = xd.L0.FullName.Append(messageset.ExtensionName)
+	}
+
+	tt := reflect.TypeOf(xi.ExtensionType)
+	if isOptional {
+		tt = tt.Elem()
+	}
+	xi.goType = tt
+	xi.desc = extensionTypeDescriptor{xd, xi}
+}
+
+type placeholderExtension struct {
+	name   pref.FullName
+	number pref.FieldNumber
+}
+
+func (x placeholderExtension) ParentFile() pref.FileDescriptor            { return nil }
+func (x placeholderExtension) Parent() pref.Descriptor                    { return nil }
+func (x placeholderExtension) Index() int                                 { return 0 }
+func (x placeholderExtension) Syntax() pref.Syntax                        { return 0 }
+func (x placeholderExtension) Name() pref.Name                            { return x.name.Name() }
+func (x placeholderExtension) FullName() pref.FullName                    { return x.name }
+func (x placeholderExtension) IsPlaceholder() bool                        { return true }
+func (x placeholderExtension) Options() pref.ProtoMessage                 { return descopts.Field }
+func (x placeholderExtension) Number() pref.FieldNumber                   { return x.number }
+func (x placeholderExtension) Cardinality() pref.Cardinality              { return 0 }
+func (x placeholderExtension) Kind() pref.Kind                            { return 0 }
+func (x placeholderExtension) HasJSONName() bool                          { return false }
+func (x placeholderExtension) JSONName() string                           { return "" }
+func (x placeholderExtension) HasPresence() bool                          { return false }
+func (x placeholderExtension) HasOptionalKeyword() bool                   { return false }
+func (x placeholderExtension) IsExtension() bool                          { return true }
+func (x placeholderExtension) IsWeak() bool                               { return false }
+func (x placeholderExtension) IsPacked() bool                             { return false }
+func (x placeholderExtension) IsList() bool                               { return false }
+func (x placeholderExtension) IsMap() bool                                { return false }
+func (x placeholderExtension) MapKey() pref.FieldDescriptor               { return nil }
+func (x placeholderExtension) MapValue() pref.FieldDescriptor             { return nil }
+func (x placeholderExtension) HasDefault() bool                           { return false }
+func (x placeholderExtension) Default() pref.Value                        { return pref.Value{} }
+func (x placeholderExtension) DefaultEnumValue() pref.EnumValueDescriptor { return nil }
+func (x placeholderExtension) ContainingOneof() pref.OneofDescriptor      { return nil }
+func (x placeholderExtension) ContainingMessage() pref.MessageDescriptor  { return nil }
+func (x placeholderExtension) Enum() pref.EnumDescriptor                  { return nil }
+func (x placeholderExtension) Message() pref.MessageDescriptor            { return nil }
+func (x placeholderExtension) ProtoType(pref.FieldDescriptor)             { return }
+func (x placeholderExtension) ProtoInternal(pragma.DoNotImplement)        { return }
diff --git a/vendor/google.golang.org/protobuf/internal/impl/legacy_file.go b/vendor/google.golang.org/protobuf/internal/impl/legacy_file.go
new file mode 100644
index 000000000..9ab091086
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/legacy_file.go
@@ -0,0 +1,81 @@
+// 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"
+
+	"google.golang.org/protobuf/internal/filedesc"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/reflect/protoregistry"
+)
+
+// 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 (
+	enumV1 interface {
+		EnumDescriptor() ([]byte, []int)
+	}
+	messageV1 interface {
+		Descriptor() ([]byte, []int)
+	}
+)
+
+var legacyFileDescCache sync.Map // map[*byte]protoreflect.FileDescriptor
+
+// legacyLoadFileDesc 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 legacyLoadFileDesc(b []byte) protoreflect.FileDescriptor {
+	// Fast-path: check whether we already have a cached file descriptor.
+	if fd, ok := legacyFileDescCache.Load(&b[0]); ok {
+		return fd.(protoreflect.FileDescriptor)
+	}
+
+	// Slow-path: decompress and unmarshal the file descriptor proto.
+	zr, err := gzip.NewReader(bytes.NewReader(b))
+	if err != nil {
+		panic(err)
+	}
+	b2, err := ioutil.ReadAll(zr)
+	if err != nil {
+		panic(err)
+	}
+
+	fd := filedesc.Builder{
+		RawDescriptor: b2,
+		FileRegistry:  resolverOnly{protoregistry.GlobalFiles}, // do not register back to global registry
+	}.Build().File
+	if fd, ok := legacyFileDescCache.LoadOrStore(&b[0], fd); ok {
+		return fd.(protoreflect.FileDescriptor)
+	}
+	return fd
+}
+
+type resolverOnly struct {
+	reg *protoregistry.Files
+}
+
+func (r resolverOnly) FindFileByPath(path string) (protoreflect.FileDescriptor, error) {
+	return r.reg.FindFileByPath(path)
+}
+func (r resolverOnly) FindDescriptorByName(name protoreflect.FullName) (protoreflect.Descriptor, error) {
+	return r.reg.FindDescriptorByName(name)
+}
+func (resolverOnly) RegisterFile(protoreflect.FileDescriptor) error {
+	return nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/legacy_file_test.go b/vendor/google.golang.org/protobuf/internal/impl/legacy_file_test.go
new file mode 100644
index 000000000..e59f0a032
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/legacy_file_test.go
@@ -0,0 +1,465 @@
+// 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_test
+
+import (
+	"bytes"
+	"compress/gzip"
+	"io/ioutil"
+	"reflect"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+
+	"google.golang.org/protobuf/internal/impl"
+	"google.golang.org/protobuf/internal/pragma"
+	"google.golang.org/protobuf/proto"
+	pdesc "google.golang.org/protobuf/reflect/protodesc"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+
+	proto2_20160225 "google.golang.org/protobuf/internal/testprotos/legacy/proto2_20160225_2fc053c5"
+	proto2_20160519 "google.golang.org/protobuf/internal/testprotos/legacy/proto2_20160519_a4ab9ec5"
+	proto2_20180125 "google.golang.org/protobuf/internal/testprotos/legacy/proto2_20180125_92554152"
+	proto2_20180430 "google.golang.org/protobuf/internal/testprotos/legacy/proto2_20180430_b4deda09"
+	proto2_20180814 "google.golang.org/protobuf/internal/testprotos/legacy/proto2_20180814_aa810b61"
+	proto2_20190205 "google.golang.org/protobuf/internal/testprotos/legacy/proto2_20190205_c823c79e"
+	proto3_20160225 "google.golang.org/protobuf/internal/testprotos/legacy/proto3_20160225_2fc053c5"
+	proto3_20160519 "google.golang.org/protobuf/internal/testprotos/legacy/proto3_20160519_a4ab9ec5"
+	proto3_20180125 "google.golang.org/protobuf/internal/testprotos/legacy/proto3_20180125_92554152"
+	proto3_20180430 "google.golang.org/protobuf/internal/testprotos/legacy/proto3_20180430_b4deda09"
+	proto3_20180814 "google.golang.org/protobuf/internal/testprotos/legacy/proto3_20180814_aa810b61"
+	proto3_20190205 "google.golang.org/protobuf/internal/testprotos/legacy/proto3_20190205_c823c79e"
+	"google.golang.org/protobuf/types/descriptorpb"
+)
+
+func mustLoadFileDesc(b []byte, _ []int) pref.FileDescriptor {
+	zr, err := gzip.NewReader(bytes.NewReader(b))
+	if err != nil {
+		panic(err)
+	}
+	b, err = ioutil.ReadAll(zr)
+	if err != nil {
+		panic(err)
+	}
+	p := new(descriptorpb.FileDescriptorProto)
+	err = proto.UnmarshalOptions{DiscardUnknown: true}.Unmarshal(b, p)
+	if err != nil {
+		panic(err)
+	}
+	fd, err := pdesc.NewFile(p, nil)
+	if err != nil {
+		panic(err)
+	}
+	return fd
+}
+
+func TestDescriptor(t *testing.T) {
+	var tests []struct{ got, want pref.Descriptor }
+
+	fileDescP2_20160225 := mustLoadFileDesc(new(proto2_20160225.Message).Descriptor())
+	tests = append(tests, []struct{ got, want pref.Descriptor }{{
+		got:  impl.LegacyLoadEnumDesc(reflect.TypeOf(proto2_20160225.SiblingEnum(0))),
+		want: fileDescP2_20160225.Enums().ByName("SiblingEnum"),
+	}, {
+		got:  impl.LegacyLoadEnumDesc(reflect.TypeOf(proto2_20160225.Message_ChildEnum(0))),
+		want: fileDescP2_20160225.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.SiblingMessage))),
+		want: fileDescP2_20160225.Messages().ByName("SiblingMessage"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_ChildMessage))),
+		want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message))),
+		want: fileDescP2_20160225.Messages().ByName("Message"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_NamedGroup))),
+		want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("NamedGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_OptionalGroup))),
+		want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("OptionalGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_RequiredGroup))),
+		want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("RequiredGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_RepeatedGroup))),
+		want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("RepeatedGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_OneofGroup))),
+		want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("OneofGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_ExtensionOptionalGroup))),
+		want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("ExtensionOptionalGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_ExtensionRepeatedGroup))),
+		want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("ExtensionRepeatedGroup"),
+	}}...)
+
+	fileDescP3_20160225 := mustLoadFileDesc(new(proto3_20160225.Message).Descriptor())
+	tests = append(tests, []struct{ got, want pref.Descriptor }{{
+		got:  impl.LegacyLoadEnumDesc(reflect.TypeOf(proto3_20160225.SiblingEnum(0))),
+		want: fileDescP3_20160225.Enums().ByName("SiblingEnum"),
+	}, {
+		got:  impl.LegacyLoadEnumDesc(reflect.TypeOf(proto3_20160225.Message_ChildEnum(0))),
+		want: fileDescP3_20160225.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160225.SiblingMessage))),
+		want: fileDescP3_20160225.Messages().ByName("SiblingMessage"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160225.Message_ChildMessage))),
+		want: fileDescP3_20160225.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160225.Message))),
+		want: fileDescP3_20160225.Messages().ByName("Message"),
+	}}...)
+
+	fileDescP2_20160519 := mustLoadFileDesc(new(proto2_20160519.Message).Descriptor())
+	tests = append(tests, []struct{ got, want pref.Descriptor }{{
+		got:  impl.LegacyLoadEnumDesc(reflect.TypeOf(proto2_20160519.SiblingEnum(0))),
+		want: fileDescP2_20160519.Enums().ByName("SiblingEnum"),
+	}, {
+		got:  impl.LegacyLoadEnumDesc(reflect.TypeOf(proto2_20160519.Message_ChildEnum(0))),
+		want: fileDescP2_20160519.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.SiblingMessage))),
+		want: fileDescP2_20160519.Messages().ByName("SiblingMessage"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_ChildMessage))),
+		want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message))),
+		want: fileDescP2_20160519.Messages().ByName("Message"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_NamedGroup))),
+		want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("NamedGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_OptionalGroup))),
+		want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("OptionalGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_RequiredGroup))),
+		want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("RequiredGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_RepeatedGroup))),
+		want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("RepeatedGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_OneofGroup))),
+		want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("OneofGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_ExtensionOptionalGroup))),
+		want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("ExtensionOptionalGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_ExtensionRepeatedGroup))),
+		want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("ExtensionRepeatedGroup"),
+	}}...)
+
+	fileDescP3_20160519 := mustLoadFileDesc(new(proto3_20160519.Message).Descriptor())
+	tests = append(tests, []struct{ got, want pref.Descriptor }{{
+		got:  impl.LegacyLoadEnumDesc(reflect.TypeOf(proto3_20160519.SiblingEnum(0))),
+		want: fileDescP3_20160519.Enums().ByName("SiblingEnum"),
+	}, {
+		got:  impl.LegacyLoadEnumDesc(reflect.TypeOf(proto3_20160519.Message_ChildEnum(0))),
+		want: fileDescP3_20160519.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160519.SiblingMessage))),
+		want: fileDescP3_20160519.Messages().ByName("SiblingMessage"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160519.Message_ChildMessage))),
+		want: fileDescP3_20160519.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160519.Message))),
+		want: fileDescP3_20160519.Messages().ByName("Message"),
+	}}...)
+
+	fileDescP2_20180125 := mustLoadFileDesc(new(proto2_20180125.Message).Descriptor())
+	tests = append(tests, []struct{ got, want pref.Descriptor }{{
+		got:  impl.LegacyLoadEnumDesc(reflect.TypeOf(proto2_20180125.SiblingEnum(0))),
+		want: fileDescP2_20180125.Enums().ByName("SiblingEnum"),
+	}, {
+		got:  impl.LegacyLoadEnumDesc(reflect.TypeOf(proto2_20180125.Message_ChildEnum(0))),
+		want: fileDescP2_20180125.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.SiblingMessage))),
+		want: fileDescP2_20180125.Messages().ByName("SiblingMessage"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_ChildMessage))),
+		want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message))),
+		want: fileDescP2_20180125.Messages().ByName("Message"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_NamedGroup))),
+		want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("NamedGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_OptionalGroup))),
+		want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("OptionalGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_RequiredGroup))),
+		want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("RequiredGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_RepeatedGroup))),
+		want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("RepeatedGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_OneofGroup))),
+		want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("OneofGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_ExtensionOptionalGroup))),
+		want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("ExtensionOptionalGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_ExtensionRepeatedGroup))),
+		want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("ExtensionRepeatedGroup"),
+	}}...)
+
+	fileDescP3_20180125 := mustLoadFileDesc(new(proto3_20180125.Message).Descriptor())
+	tests = append(tests, []struct{ got, want pref.Descriptor }{{
+		got:  impl.LegacyLoadEnumDesc(reflect.TypeOf(proto3_20180125.SiblingEnum(0))),
+		want: fileDescP3_20180125.Enums().ByName("SiblingEnum"),
+	}, {
+		got:  impl.LegacyLoadEnumDesc(reflect.TypeOf(proto3_20180125.Message_ChildEnum(0))),
+		want: fileDescP3_20180125.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180125.SiblingMessage))),
+		want: fileDescP3_20180125.Messages().ByName("SiblingMessage"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180125.Message_ChildMessage))),
+		want: fileDescP3_20180125.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180125.Message))),
+		want: fileDescP3_20180125.Messages().ByName("Message"),
+	}}...)
+
+	fileDescP2_20180430 := mustLoadFileDesc(new(proto2_20180430.Message).Descriptor())
+	tests = append(tests, []struct{ got, want pref.Descriptor }{{
+		got:  impl.LegacyLoadEnumDesc(reflect.TypeOf(proto2_20180430.SiblingEnum(0))),
+		want: fileDescP2_20180430.Enums().ByName("SiblingEnum"),
+	}, {
+		got:  impl.LegacyLoadEnumDesc(reflect.TypeOf(proto2_20180430.Message_ChildEnum(0))),
+		want: fileDescP2_20180430.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.SiblingMessage))),
+		want: fileDescP2_20180430.Messages().ByName("SiblingMessage"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_ChildMessage))),
+		want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message))),
+		want: fileDescP2_20180430.Messages().ByName("Message"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_NamedGroup))),
+		want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("NamedGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_OptionalGroup))),
+		want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("OptionalGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_RequiredGroup))),
+		want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("RequiredGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_RepeatedGroup))),
+		want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("RepeatedGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_OneofGroup))),
+		want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("OneofGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_ExtensionOptionalGroup))),
+		want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("ExtensionOptionalGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_ExtensionRepeatedGroup))),
+		want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("ExtensionRepeatedGroup"),
+	}}...)
+
+	fileDescP3_20180430 := mustLoadFileDesc(new(proto3_20180430.Message).Descriptor())
+	tests = append(tests, []struct{ got, want pref.Descriptor }{{
+		got:  impl.LegacyLoadEnumDesc(reflect.TypeOf(proto3_20180430.SiblingEnum(0))),
+		want: fileDescP3_20180430.Enums().ByName("SiblingEnum"),
+	}, {
+		got:  impl.LegacyLoadEnumDesc(reflect.TypeOf(proto3_20180430.Message_ChildEnum(0))),
+		want: fileDescP3_20180430.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180430.SiblingMessage))),
+		want: fileDescP3_20180430.Messages().ByName("SiblingMessage"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180430.Message_ChildMessage))),
+		want: fileDescP3_20180430.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180430.Message))),
+		want: fileDescP3_20180430.Messages().ByName("Message"),
+	}}...)
+
+	fileDescP2_20180814 := mustLoadFileDesc(new(proto2_20180814.Message).Descriptor())
+	tests = append(tests, []struct{ got, want pref.Descriptor }{{
+		got:  impl.LegacyLoadEnumDesc(reflect.TypeOf(proto2_20180814.SiblingEnum(0))),
+		want: fileDescP2_20180814.Enums().ByName("SiblingEnum"),
+	}, {
+		got:  impl.LegacyLoadEnumDesc(reflect.TypeOf(proto2_20180814.Message_ChildEnum(0))),
+		want: fileDescP2_20180814.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.SiblingMessage))),
+		want: fileDescP2_20180814.Messages().ByName("SiblingMessage"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_ChildMessage))),
+		want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message))),
+		want: fileDescP2_20180814.Messages().ByName("Message"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_NamedGroup))),
+		want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("NamedGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_OptionalGroup))),
+		want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("OptionalGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_RequiredGroup))),
+		want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("RequiredGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_RepeatedGroup))),
+		want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("RepeatedGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_OneofGroup))),
+		want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("OneofGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_ExtensionOptionalGroup))),
+		want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("ExtensionOptionalGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_ExtensionRepeatedGroup))),
+		want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("ExtensionRepeatedGroup"),
+	}}...)
+
+	fileDescP3_20180814 := mustLoadFileDesc(new(proto3_20180814.Message).Descriptor())
+	tests = append(tests, []struct{ got, want pref.Descriptor }{{
+		got:  impl.LegacyLoadEnumDesc(reflect.TypeOf(proto3_20180814.SiblingEnum(0))),
+		want: fileDescP3_20180814.Enums().ByName("SiblingEnum"),
+	}, {
+		got:  impl.LegacyLoadEnumDesc(reflect.TypeOf(proto3_20180814.Message_ChildEnum(0))),
+		want: fileDescP3_20180814.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180814.SiblingMessage))),
+		want: fileDescP3_20180814.Messages().ByName("SiblingMessage"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180814.Message_ChildMessage))),
+		want: fileDescP3_20180814.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180814.Message))),
+		want: fileDescP3_20180814.Messages().ByName("Message"),
+	}}...)
+
+	fileDescP2_20190205 := mustLoadFileDesc(new(proto2_20190205.Message).Descriptor())
+	tests = append(tests, []struct{ got, want pref.Descriptor }{{
+		got:  impl.LegacyLoadEnumDesc(reflect.TypeOf(proto2_20190205.SiblingEnum(0))),
+		want: fileDescP2_20190205.Enums().ByName("SiblingEnum"),
+	}, {
+		got:  impl.LegacyLoadEnumDesc(reflect.TypeOf(proto2_20190205.Message_ChildEnum(0))),
+		want: fileDescP2_20190205.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20190205.SiblingMessage))),
+		want: fileDescP2_20190205.Messages().ByName("SiblingMessage"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20190205.Message_ChildMessage))),
+		want: fileDescP2_20190205.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20190205.Message))),
+		want: fileDescP2_20190205.Messages().ByName("Message"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20190205.Message_NamedGroup))),
+		want: fileDescP2_20190205.Messages().ByName("Message").Messages().ByName("NamedGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20190205.Message_OptionalGroup))),
+		want: fileDescP2_20190205.Messages().ByName("Message").Messages().ByName("OptionalGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20190205.Message_RequiredGroup))),
+		want: fileDescP2_20190205.Messages().ByName("Message").Messages().ByName("RequiredGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20190205.Message_RepeatedGroup))),
+		want: fileDescP2_20190205.Messages().ByName("Message").Messages().ByName("RepeatedGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20190205.Message_OneofGroup))),
+		want: fileDescP2_20190205.Messages().ByName("Message").Messages().ByName("OneofGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20190205.Message_ExtensionOptionalGroup))),
+		want: fileDescP2_20190205.Messages().ByName("Message").Messages().ByName("ExtensionOptionalGroup"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto2_20190205.Message_ExtensionRepeatedGroup))),
+		want: fileDescP2_20190205.Messages().ByName("Message").Messages().ByName("ExtensionRepeatedGroup"),
+	}}...)
+
+	fileDescP3_20190205 := mustLoadFileDesc(new(proto3_20190205.Message).Descriptor())
+	tests = append(tests, []struct{ got, want pref.Descriptor }{{
+		got:  impl.LegacyLoadEnumDesc(reflect.TypeOf(proto3_20190205.SiblingEnum(0))),
+		want: fileDescP3_20190205.Enums().ByName("SiblingEnum"),
+	}, {
+		got:  impl.LegacyLoadEnumDesc(reflect.TypeOf(proto3_20190205.Message_ChildEnum(0))),
+		want: fileDescP3_20190205.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto3_20190205.SiblingMessage))),
+		want: fileDescP3_20190205.Messages().ByName("SiblingMessage"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto3_20190205.Message_ChildMessage))),
+		want: fileDescP3_20190205.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+	}, {
+		got:  impl.LegacyLoadMessageDesc(reflect.TypeOf(new(proto3_20190205.Message))),
+		want: fileDescP3_20190205.Messages().ByName("Message"),
+	}}...)
+
+	// TODO: We need a test package to compare descriptors.
+	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 "ParentFile", "Parent":
+						// Ignore parents to avoid recursive cycle.
+					case "Index":
+						// Ignore index since legacy descriptors have no parent.
+					case "Options":
+						// Ignore descriptor options since protos are not cmperable.
+					case "Enums", "Messages", "Extensions":
+						// Ignore nested message and enum declarations since
+						// legacy descriptors are all created standalone.
+					case "HasJSONName":
+						// Ignore this since the semantics of the field has
+						// changed across protoc and protoc-gen-go releases.
+					case "ContainingOneof", "ContainingMessage", "Enum", "Message":
+						// 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)
+			}
+		})
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/legacy_message.go b/vendor/google.golang.org/protobuf/internal/impl/legacy_message.go
new file mode 100644
index 000000000..06c68e117
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/legacy_message.go
@@ -0,0 +1,502 @@
+// 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"
+	"reflect"
+	"strings"
+	"sync"
+
+	"google.golang.org/protobuf/internal/descopts"
+	ptag "google.golang.org/protobuf/internal/encoding/tag"
+	"google.golang.org/protobuf/internal/errors"
+	"google.golang.org/protobuf/internal/filedesc"
+	"google.golang.org/protobuf/internal/strs"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/runtime/protoiface"
+	piface "google.golang.org/protobuf/runtime/protoiface"
+)
+
+// legacyWrapMessage wraps v as a protoreflect.Message,
+// where v must be a *struct kind and not implement the v2 API already.
+func legacyWrapMessage(v reflect.Value) pref.Message {
+	typ := v.Type()
+	if typ.Kind() != reflect.Ptr || typ.Elem().Kind() != reflect.Struct {
+		return aberrantMessage{v: v}
+	}
+	mt := legacyLoadMessageInfo(typ, "")
+	return mt.MessageOf(v.Interface())
+}
+
+var legacyMessageTypeCache sync.Map // map[reflect.Type]*MessageInfo
+
+// legacyLoadMessageInfo dynamically loads a *MessageInfo for t,
+// where t must be a *struct kind and not implement the v2 API already.
+// The provided name is used if it cannot be determined from the message.
+func legacyLoadMessageInfo(t reflect.Type, name pref.FullName) *MessageInfo {
+	// Fast-path: check if a MessageInfo is cached for this concrete type.
+	if mt, ok := legacyMessageTypeCache.Load(t); ok {
+		return mt.(*MessageInfo)
+	}
+
+	// Slow-path: derive message descriptor and initialize MessageInfo.
+	mi := &MessageInfo{
+		Desc:          legacyLoadMessageDesc(t, name),
+		GoReflectType: t,
+	}
+
+	v := reflect.Zero(t).Interface()
+	if _, ok := v.(legacyMarshaler); ok {
+		mi.methods.Marshal = legacyMarshal
+
+		// We have no way to tell whether the type's Marshal method
+		// supports deterministic serialization or not, but this
+		// preserves the v1 implementation's behavior of always
+		// calling Marshal methods when present.
+		mi.methods.Flags |= piface.SupportMarshalDeterministic
+	}
+	if _, ok := v.(legacyUnmarshaler); ok {
+		mi.methods.Unmarshal = legacyUnmarshal
+	}
+	if _, ok := v.(legacyMerger); ok {
+		mi.methods.Merge = legacyMerge
+	}
+
+	if mi, ok := legacyMessageTypeCache.LoadOrStore(t, mi); ok {
+		return mi.(*MessageInfo)
+	}
+	return mi
+}
+
+var legacyMessageDescCache sync.Map // map[reflect.Type]protoreflect.MessageDescriptor
+
+// LegacyLoadMessageDesc returns an MessageDescriptor derived from the Go type,
+// which must be a *struct kind and not implement the v2 API already.
+//
+// This is exported for testing purposes.
+func LegacyLoadMessageDesc(t reflect.Type) pref.MessageDescriptor {
+	return legacyLoadMessageDesc(t, "")
+}
+func legacyLoadMessageDesc(t reflect.Type, name pref.FullName) pref.MessageDescriptor {
+	// Fast-path: check if a MessageDescriptor is cached for this concrete type.
+	if mi, ok := legacyMessageDescCache.Load(t); ok {
+		return mi.(pref.MessageDescriptor)
+	}
+
+	// Slow-path: initialize MessageDescriptor from the raw descriptor.
+	mv := reflect.Zero(t).Interface()
+	if _, ok := mv.(pref.ProtoMessage); ok {
+		panic(fmt.Sprintf("%v already implements proto.Message", t))
+	}
+	mdV1, ok := mv.(messageV1)
+	if !ok {
+		return aberrantLoadMessageDesc(t, name)
+	}
+
+	// If this is a dynamic message type where there isn't a 1-1 mapping between
+	// Go and protobuf types, calling the Descriptor method on the zero value of
+	// the message type isn't likely to work. If it panics, swallow the panic and
+	// continue as if the Descriptor method wasn't present.
+	b, idxs := func() ([]byte, []int) {
+		defer func() {
+			recover()
+		}()
+		return mdV1.Descriptor()
+	}()
+	if b == nil {
+		return aberrantLoadMessageDesc(t, name)
+	}
+
+	// If the Go type has no fields, then this might be a proto3 empty message
+	// from before the size cache was added. If there are any fields, check to
+	// see that at least one of them looks like something we generated.
+	if nfield := t.Elem().NumField(); nfield > 0 {
+		hasProtoField := false
+		for i := 0; i < nfield; i++ {
+			f := t.Elem().Field(i)
+			if f.Tag.Get("protobuf") != "" || f.Tag.Get("protobuf_oneof") != "" || strings.HasPrefix(f.Name, "XXX_") {
+				hasProtoField = true
+				break
+			}
+		}
+		if !hasProtoField {
+			return aberrantLoadMessageDesc(t, name)
+		}
+	}
+
+	md := legacyLoadFileDesc(b).Messages().Get(idxs[0])
+	for _, i := range idxs[1:] {
+		md = md.Messages().Get(i)
+	}
+	if name != "" && md.FullName() != name {
+		panic(fmt.Sprintf("mismatching message name: got %v, want %v", md.FullName(), name))
+	}
+	if md, ok := legacyMessageDescCache.LoadOrStore(t, md); ok {
+		return md.(protoreflect.MessageDescriptor)
+	}
+	return md
+}
+
+var (
+	aberrantMessageDescLock  sync.Mutex
+	aberrantMessageDescCache map[reflect.Type]protoreflect.MessageDescriptor
+)
+
+// aberrantLoadMessageDesc returns an MessageDescriptor derived from the Go type,
+// which must not implement protoreflect.ProtoMessage or messageV1.
+//
+// This is a best-effort derivation of the message descriptor using the protobuf
+// tags on the struct fields.
+func aberrantLoadMessageDesc(t reflect.Type, name pref.FullName) pref.MessageDescriptor {
+	aberrantMessageDescLock.Lock()
+	defer aberrantMessageDescLock.Unlock()
+	if aberrantMessageDescCache == nil {
+		aberrantMessageDescCache = make(map[reflect.Type]protoreflect.MessageDescriptor)
+	}
+	return aberrantLoadMessageDescReentrant(t, name)
+}
+func aberrantLoadMessageDescReentrant(t reflect.Type, name pref.FullName) pref.MessageDescriptor {
+	// Fast-path: check if an MessageDescriptor is cached for this concrete type.
+	if md, ok := aberrantMessageDescCache[t]; ok {
+		return md
+	}
+
+	// Slow-path: construct a descriptor from the Go struct type (best-effort).
+	// Cache the MessageDescriptor early on so that we can resolve internal
+	// cyclic references.
+	md := &filedesc.Message{L2: new(filedesc.MessageL2)}
+	md.L0.FullName = aberrantDeriveMessageName(t, name)
+	md.L0.ParentFile = filedesc.SurrogateProto2
+	aberrantMessageDescCache[t] = md
+
+	if t.Kind() != reflect.Ptr || t.Elem().Kind() != reflect.Struct {
+		return md
+	}
+
+	// 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:
+				md.L0.ParentFile = filedesc.SurrogateProto3
+			}
+			for _, s := range strings.Split(tag, ",") {
+				if s == "proto3" {
+					md.L0.ParentFile = filedesc.SurrogateProto3
+				}
+			}
+		}
+	}
+
+	// Obtain a list of oneof wrapper types.
+	var oneofWrappers []reflect.Type
+	for _, method := range []string{"XXX_OneofFuncs", "XXX_OneofWrappers"} {
+		if fn, ok := t.MethodByName(method); ok {
+			for _, v := range fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))}) {
+				if vs, ok := v.Interface().([]interface{}); ok {
+					for _, v := range vs {
+						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)
+			md.L2.ExtensionRanges.List = append(md.L2.ExtensionRanges.List, [2]pref.FieldNumber{
+				pref.FieldNumber(v.FieldByName("Start").Int()),
+				pref.FieldNumber(v.FieldByName("End").Int() + 1),
+			})
+			md.L2.ExtensionRangeOptions = append(md.L2.ExtensionRangeOptions, nil)
+		}
+	}
+
+	// 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")
+			aberrantAppendField(md, f.Type, tag, tagKey, tagVal)
+		}
+		if tag := f.Tag.Get("protobuf_oneof"); tag != "" {
+			n := len(md.L2.Oneofs.List)
+			md.L2.Oneofs.List = append(md.L2.Oneofs.List, filedesc.Oneof{})
+			od := &md.L2.Oneofs.List[n]
+			od.L0.FullName = md.FullName().Append(pref.Name(tag))
+			od.L0.ParentFile = md.L0.ParentFile
+			od.L0.Parent = md
+			od.L0.Index = n
+
+			for _, t := range oneofWrappers {
+				if t.Implements(f.Type) {
+					f := t.Elem().Field(0)
+					if tag := f.Tag.Get("protobuf"); tag != "" {
+						aberrantAppendField(md, f.Type, tag, "", "")
+						fd := &md.L2.Fields.List[len(md.L2.Fields.List)-1]
+						fd.L1.ContainingOneof = od
+						od.L1.Fields.List = append(od.L1.Fields.List, fd)
+					}
+				}
+			}
+		}
+	}
+
+	return md
+}
+
+func aberrantDeriveMessageName(t reflect.Type, name pref.FullName) pref.FullName {
+	if name.IsValid() {
+		return name
+	}
+	func() {
+		defer func() { recover() }() // swallow possible nil panics
+		if m, ok := reflect.Zero(t).Interface().(interface{ XXX_MessageName() string }); ok {
+			name = pref.FullName(m.XXX_MessageName())
+		}
+	}()
+	if name.IsValid() {
+		return name
+	}
+	if t.Kind() == reflect.Ptr {
+		t = t.Elem()
+	}
+	return AberrantDeriveFullName(t)
+}
+
+func aberrantAppendField(md *filedesc.Message, goType reflect.Type, tag, tagKey, tagVal string) {
+	t := goType
+	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()
+	}
+	fd := ptag.Unmarshal(tag, t, placeholderEnumValues{}).(*filedesc.Field)
+
+	// Append field descriptor to the message.
+	n := len(md.L2.Fields.List)
+	md.L2.Fields.List = append(md.L2.Fields.List, *fd)
+	fd = &md.L2.Fields.List[n]
+	fd.L0.FullName = md.FullName().Append(fd.Name())
+	fd.L0.ParentFile = md.L0.ParentFile
+	fd.L0.Parent = md
+	fd.L0.Index = n
+
+	if fd.L1.IsWeak || fd.L1.HasPacked {
+		fd.L1.Options = func() pref.ProtoMessage {
+			opts := descopts.Field.ProtoReflect().New()
+			if fd.L1.IsWeak {
+				opts.Set(opts.Descriptor().Fields().ByName("weak"), protoreflect.ValueOfBool(true))
+			}
+			if fd.L1.HasPacked {
+				opts.Set(opts.Descriptor().Fields().ByName("packed"), protoreflect.ValueOfBool(fd.L1.IsPacked))
+			}
+			return opts.Interface()
+		}
+	}
+
+	// Populate Enum and Message.
+	if fd.Enum() == nil && fd.Kind() == pref.EnumKind {
+		switch v := reflect.Zero(t).Interface().(type) {
+		case pref.Enum:
+			fd.L1.Enum = v.Descriptor()
+		default:
+			fd.L1.Enum = LegacyLoadEnumDesc(t)
+		}
+	}
+	if fd.Message() == nil && (fd.Kind() == pref.MessageKind || fd.Kind() == pref.GroupKind) {
+		switch v := reflect.Zero(t).Interface().(type) {
+		case pref.ProtoMessage:
+			fd.L1.Message = v.ProtoReflect().Descriptor()
+		case messageV1:
+			fd.L1.Message = LegacyLoadMessageDesc(t)
+		default:
+			if t.Kind() == reflect.Map {
+				n := len(md.L1.Messages.List)
+				md.L1.Messages.List = append(md.L1.Messages.List, filedesc.Message{L2: new(filedesc.MessageL2)})
+				md2 := &md.L1.Messages.List[n]
+				md2.L0.FullName = md.FullName().Append(pref.Name(strs.MapEntryName(string(fd.Name()))))
+				md2.L0.ParentFile = md.L0.ParentFile
+				md2.L0.Parent = md
+				md2.L0.Index = n
+
+				md2.L1.IsMapEntry = true
+				md2.L2.Options = func() pref.ProtoMessage {
+					opts := descopts.Message.ProtoReflect().New()
+					opts.Set(opts.Descriptor().Fields().ByName("map_entry"), protoreflect.ValueOfBool(true))
+					return opts.Interface()
+				}
+
+				aberrantAppendField(md2, t.Key(), tagKey, "", "")
+				aberrantAppendField(md2, t.Elem(), tagVal, "", "")
+
+				fd.L1.Message = md2
+				break
+			}
+			fd.L1.Message = aberrantLoadMessageDescReentrant(t, "")
+		}
+	}
+}
+
+type placeholderEnumValues struct {
+	protoreflect.EnumValueDescriptors
+}
+
+func (placeholderEnumValues) ByNumber(n pref.EnumNumber) pref.EnumValueDescriptor {
+	return filedesc.PlaceholderEnumValue(pref.FullName(fmt.Sprintf("UNKNOWN_%d", n)))
+}
+
+// legacyMarshaler is the proto.Marshaler interface superseded by protoiface.Methoder.
+type legacyMarshaler interface {
+	Marshal() ([]byte, error)
+}
+
+// legacyUnmarshaler is the proto.Unmarshaler interface superseded by protoiface.Methoder.
+type legacyUnmarshaler interface {
+	Unmarshal([]byte) error
+}
+
+// legacyMerger is the proto.Merger interface superseded by protoiface.Methoder.
+type legacyMerger interface {
+	Merge(protoiface.MessageV1)
+}
+
+var legacyProtoMethods = &piface.Methods{
+	Marshal:   legacyMarshal,
+	Unmarshal: legacyUnmarshal,
+	Merge:     legacyMerge,
+
+	// We have no way to tell whether the type's Marshal method
+	// supports deterministic serialization or not, but this
+	// preserves the v1 implementation's behavior of always
+	// calling Marshal methods when present.
+	Flags: piface.SupportMarshalDeterministic,
+}
+
+func legacyMarshal(in piface.MarshalInput) (piface.MarshalOutput, error) {
+	v := in.Message.(unwrapper).protoUnwrap()
+	marshaler, ok := v.(legacyMarshaler)
+	if !ok {
+		return piface.MarshalOutput{}, errors.New("%T does not implement Marshal", v)
+	}
+	out, err := marshaler.Marshal()
+	if in.Buf != nil {
+		out = append(in.Buf, out...)
+	}
+	return piface.MarshalOutput{
+		Buf: out,
+	}, err
+}
+
+func legacyUnmarshal(in piface.UnmarshalInput) (piface.UnmarshalOutput, error) {
+	v := in.Message.(unwrapper).protoUnwrap()
+	unmarshaler, ok := v.(legacyUnmarshaler)
+	if !ok {
+		return piface.UnmarshalOutput{}, errors.New("%T does not implement Marshal", v)
+	}
+	return piface.UnmarshalOutput{}, unmarshaler.Unmarshal(in.Buf)
+}
+
+func legacyMerge(in piface.MergeInput) piface.MergeOutput {
+	dstv := in.Destination.(unwrapper).protoUnwrap()
+	merger, ok := dstv.(legacyMerger)
+	if !ok {
+		return piface.MergeOutput{}
+	}
+	merger.Merge(Export{}.ProtoMessageV1Of(in.Source))
+	return piface.MergeOutput{Flags: piface.MergeComplete}
+}
+
+// aberrantMessageType implements MessageType for all types other than pointer-to-struct.
+type aberrantMessageType struct {
+	t reflect.Type
+}
+
+func (mt aberrantMessageType) New() pref.Message {
+	return aberrantMessage{reflect.Zero(mt.t)}
+}
+func (mt aberrantMessageType) Zero() pref.Message {
+	return aberrantMessage{reflect.Zero(mt.t)}
+}
+func (mt aberrantMessageType) GoType() reflect.Type {
+	return mt.t
+}
+func (mt aberrantMessageType) Descriptor() pref.MessageDescriptor {
+	return LegacyLoadMessageDesc(mt.t)
+}
+
+// aberrantMessage implements Message for all types other than pointer-to-struct.
+//
+// When the underlying type implements legacyMarshaler or legacyUnmarshaler,
+// the aberrant Message can be marshaled or unmarshaled. Otherwise, there is
+// not much that can be done with values of this type.
+type aberrantMessage struct {
+	v reflect.Value
+}
+
+func (m aberrantMessage) ProtoReflect() pref.Message {
+	return m
+}
+
+func (m aberrantMessage) Descriptor() pref.MessageDescriptor {
+	return LegacyLoadMessageDesc(m.v.Type())
+}
+func (m aberrantMessage) Type() pref.MessageType {
+	return aberrantMessageType{m.v.Type()}
+}
+func (m aberrantMessage) New() pref.Message {
+	return aberrantMessage{reflect.Zero(m.v.Type())}
+}
+func (m aberrantMessage) Interface() pref.ProtoMessage {
+	return m
+}
+func (m aberrantMessage) Range(f func(pref.FieldDescriptor, pref.Value) bool) {
+}
+func (m aberrantMessage) Has(pref.FieldDescriptor) bool {
+	panic("invalid field descriptor")
+}
+func (m aberrantMessage) Clear(pref.FieldDescriptor) {
+	panic("invalid field descriptor")
+}
+func (m aberrantMessage) Get(pref.FieldDescriptor) pref.Value {
+	panic("invalid field descriptor")
+}
+func (m aberrantMessage) Set(pref.FieldDescriptor, pref.Value) {
+	panic("invalid field descriptor")
+}
+func (m aberrantMessage) Mutable(pref.FieldDescriptor) pref.Value {
+	panic("invalid field descriptor")
+}
+func (m aberrantMessage) NewField(pref.FieldDescriptor) pref.Value {
+	panic("invalid field descriptor")
+}
+func (m aberrantMessage) WhichOneof(pref.OneofDescriptor) pref.FieldDescriptor {
+	panic("invalid oneof descriptor")
+}
+func (m aberrantMessage) GetUnknown() pref.RawFields {
+	return nil
+}
+func (m aberrantMessage) SetUnknown(pref.RawFields) {
+	// SetUnknown discards its input on messages which don't support unknown field storage.
+}
+func (m aberrantMessage) IsValid() bool {
+	// An invalid message is a read-only, empty message. Since we don't know anything
+	// about the alleged contents of this message, we can't say with confidence that
+	// it is invalid in this sense. Therefore, report it as valid.
+	return true
+}
+func (m aberrantMessage) ProtoMethods() *piface.Methods {
+	return legacyProtoMethods
+}
+func (m aberrantMessage) protoUnwrap() interface{} {
+	return m.v.Interface()
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/legacy_test.go b/vendor/google.golang.org/protobuf/internal/impl/legacy_test.go
new file mode 100644
index 000000000..f699568c6
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/legacy_test.go
@@ -0,0 +1,707 @@
+// 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_test
+
+import (
+	"fmt"
+	"reflect"
+	"sync"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/cmpopts"
+
+	"google.golang.org/protobuf/encoding/prototext"
+	pimpl "google.golang.org/protobuf/internal/impl"
+	"google.golang.org/protobuf/internal/pragma"
+	"google.golang.org/protobuf/proto"
+	pdesc "google.golang.org/protobuf/reflect/protodesc"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+	preg "google.golang.org/protobuf/reflect/protoregistry"
+	piface "google.golang.org/protobuf/runtime/protoiface"
+
+	proto2_20180125 "google.golang.org/protobuf/internal/testprotos/legacy/proto2_20180125_92554152"
+	"google.golang.org/protobuf/types/descriptorpb"
+)
+
+type LegacyTestMessage struct {
+	XXX_unrecognized       []byte
+	XXX_InternalExtensions map[int32]pimpl.ExtensionField
+}
+
+func (*LegacyTestMessage) Reset()         {}
+func (*LegacyTestMessage) String() string { return "" }
+func (*LegacyTestMessage) ProtoMessage()  {}
+func (*LegacyTestMessage) ExtensionRangeArray() []piface.ExtensionRangeV1 {
+	return []piface.ExtensionRangeV1{{Start: 10, End: 20}, {Start: 40, End: 80}, {Start: 10000, End: 20000}}
+}
+func (*LegacyTestMessage) Descriptor() ([]byte, []int) { return legacyFD, []int{0} }
+
+var legacyFD = func() []byte {
+	b, _ := proto.Marshal(pdesc.ToFileDescriptorProto(mustMakeFileDesc(`
+		name:   "legacy.proto"
+		syntax: "proto2"
+		message_type: [{
+			name:            "LegacyTestMessage"
+			extension_range: [{start:10 end:20}, {start:40 end:80}, {start:10000 end:20000}]
+		}]
+	`, nil)))
+	return pimpl.Export{}.CompressGZIP(b)
+}()
+
+func init() {
+	mt := pimpl.Export{}.MessageTypeOf((*LegacyTestMessage)(nil))
+	preg.GlobalFiles.RegisterFile(mt.Descriptor().ParentFile())
+	preg.GlobalTypes.RegisterMessage(mt)
+}
+
+func mustMakeExtensionType(fileDesc, extDesc string, t reflect.Type, r pdesc.Resolver) pref.ExtensionType {
+	s := fmt.Sprintf(`name:"test.proto" syntax:"proto2" %s extension:[{%s}]`, fileDesc, extDesc)
+	xd := mustMakeFileDesc(s, r).Extensions().Get(0)
+	xi := &pimpl.ExtensionInfo{}
+	pimpl.InitExtensionInfo(xi, xd, t)
+	return xi
+}
+
+func mustMakeFileDesc(s string, r pdesc.Resolver) pref.FileDescriptor {
+	pb := new(descriptorpb.FileDescriptorProto)
+	if err := prototext.Unmarshal([]byte(s), pb); err != nil {
+		panic(err)
+	}
+	fd, err := pdesc.NewFile(pb, r)
+	if err != nil {
+		panic(err)
+	}
+	return fd
+}
+
+var (
+	testParentDesc    = pimpl.Export{}.MessageDescriptorOf((*LegacyTestMessage)(nil))
+	testEnumV1Desc    = pimpl.Export{}.EnumDescriptorOf(proto2_20180125.Message_ChildEnum(0))
+	testMessageV1Desc = pimpl.Export{}.MessageDescriptorOf((*proto2_20180125.Message_ChildMessage)(nil))
+	testMessageV2Desc = enumMessagesType.Desc
+
+	depReg = newFileRegistry(
+		testParentDesc.ParentFile(),
+		testEnumV1Desc.ParentFile(),
+		testMessageV1Desc.ParentFile(),
+		enumProto2Desc.ParentFile(),
+		testMessageV2Desc.ParentFile(),
+	)
+	extensionTypes = []pref.ExtensionType{
+		mustMakeExtensionType(
+			`package:"fizz.buzz" dependency:"legacy.proto"`,
+			`name:"optional_bool" number:10000 label:LABEL_OPTIONAL type:TYPE_BOOL default_value:"true" extendee:".LegacyTestMessage"`,
+			reflect.TypeOf(false), depReg,
+		),
+		mustMakeExtensionType(
+			`package:"fizz.buzz" dependency:"legacy.proto"`,
+			`name:"optional_int32" number:10001 label:LABEL_OPTIONAL type:TYPE_INT32 default_value:"-12345" extendee:".LegacyTestMessage"`,
+			reflect.TypeOf(int32(0)), depReg,
+		),
+		mustMakeExtensionType(
+			`package:"fizz.buzz" dependency:"legacy.proto"`,
+			`name:"optional_uint32" number:10002 label:LABEL_OPTIONAL type:TYPE_UINT32 default_value:"3200" extendee:".LegacyTestMessage"`,
+			reflect.TypeOf(uint32(0)), depReg,
+		),
+		mustMakeExtensionType(
+			`package:"fizz.buzz" dependency:"legacy.proto"`,
+			`name:"optional_float" number:10003 label:LABEL_OPTIONAL type:TYPE_FLOAT default_value:"3.14159" extendee:".LegacyTestMessage"`,
+			reflect.TypeOf(float32(0)), depReg,
+		),
+		mustMakeExtensionType(
+			`package:"fizz.buzz" dependency:"legacy.proto"`,
+			`name:"optional_string" number:10004 label:LABEL_OPTIONAL type:TYPE_STRING default_value:"hello, \"world!\"\n" extendee:".LegacyTestMessage"`,
+			reflect.TypeOf(""), depReg,
+		),
+		mustMakeExtensionType(
+			`package:"fizz.buzz" dependency:"legacy.proto"`,
+			`name:"optional_bytes" number:10005 label:LABEL_OPTIONAL type:TYPE_BYTES default_value:"dead\\336\\255\\276\\357beef" extendee:".LegacyTestMessage"`,
+			reflect.TypeOf(([]byte)(nil)), depReg,
+		),
+		mustMakeExtensionType(
+			`package:"fizz.buzz" dependency:["legacy.proto", "proto2_20180125_92554152/test.proto"]`,
+			`name:"optional_enum_v1" number:10006 label:LABEL_OPTIONAL type:TYPE_ENUM type_name:".google.golang.org.proto2_20180125.Message.ChildEnum" default_value:"ALPHA" extendee:".LegacyTestMessage"`,
+			reflect.TypeOf(proto2_20180125.Message_ChildEnum(0)), depReg,
+		),
+		mustMakeExtensionType(
+			`package:"fizz.buzz" dependency:["legacy.proto", "proto2_20180125_92554152/test.proto"]`,
+			`name:"optional_message_v1" number:10007 label:LABEL_OPTIONAL type:TYPE_MESSAGE type_name:".google.golang.org.proto2_20180125.Message.ChildMessage" extendee:".LegacyTestMessage"`,
+			reflect.TypeOf((*proto2_20180125.Message_ChildMessage)(nil)), depReg,
+		),
+		mustMakeExtensionType(
+			`package:"fizz.buzz" dependency:["legacy.proto", "enum2.proto"]`,
+			`name:"optional_enum_v2" number:10008 label:LABEL_OPTIONAL type:TYPE_ENUM type_name:".EnumProto2" default_value:"DEAD" extendee:".LegacyTestMessage"`,
+			reflect.TypeOf(EnumProto2(0)), depReg,
+		),
+		mustMakeExtensionType(
+			`package:"fizz.buzz" dependency:["legacy.proto", "enum-messages.proto"]`,
+			`name:"optional_message_v2" number:10009 label:LABEL_OPTIONAL type:TYPE_MESSAGE type_name:".EnumMessages" extendee:".LegacyTestMessage"`,
+			reflect.TypeOf((*EnumMessages)(nil)), depReg,
+		),
+		mustMakeExtensionType(
+			`package:"fizz.buzz" dependency:"legacy.proto"`,
+			`name:"repeated_bool" number:10010 label:LABEL_REPEATED type:TYPE_BOOL extendee:".LegacyTestMessage"`,
+			reflect.TypeOf([]bool(nil)), depReg,
+		),
+		mustMakeExtensionType(
+			`package:"fizz.buzz" dependency:"legacy.proto"`,
+			`name:"repeated_int32" number:10011 label:LABEL_REPEATED type:TYPE_INT32 extendee:".LegacyTestMessage"`,
+			reflect.TypeOf([]int32(nil)), depReg,
+		),
+		mustMakeExtensionType(
+			`package:"fizz.buzz" dependency:"legacy.proto"`,
+			`name:"repeated_uint32" number:10012 label:LABEL_REPEATED type:TYPE_UINT32 extendee:".LegacyTestMessage"`,
+			reflect.TypeOf([]uint32(nil)), depReg,
+		),
+		mustMakeExtensionType(
+			`package:"fizz.buzz" dependency:"legacy.proto"`,
+			`name:"repeated_float" number:10013 label:LABEL_REPEATED type:TYPE_FLOAT extendee:".LegacyTestMessage"`,
+			reflect.TypeOf([]float32(nil)), depReg,
+		),
+		mustMakeExtensionType(
+			`package:"fizz.buzz" dependency:"legacy.proto"`,
+			`name:"repeated_string" number:10014 label:LABEL_REPEATED type:TYPE_STRING extendee:".LegacyTestMessage"`,
+			reflect.TypeOf([]string(nil)), depReg,
+		),
+		mustMakeExtensionType(
+			`package:"fizz.buzz" dependency:"legacy.proto"`,
+			`name:"repeated_bytes" number:10015 label:LABEL_REPEATED type:TYPE_BYTES extendee:".LegacyTestMessage"`,
+			reflect.TypeOf([][]byte(nil)), depReg,
+		),
+		mustMakeExtensionType(
+			`package:"fizz.buzz" dependency:["legacy.proto", "proto2_20180125_92554152/test.proto"]`,
+			`name:"repeated_enum_v1" number:10016 label:LABEL_REPEATED type:TYPE_ENUM type_name:".google.golang.org.proto2_20180125.Message.ChildEnum" extendee:".LegacyTestMessage"`,
+			reflect.TypeOf([]proto2_20180125.Message_ChildEnum(nil)), depReg,
+		),
+		mustMakeExtensionType(
+			`package:"fizz.buzz" dependency:["legacy.proto", "proto2_20180125_92554152/test.proto"]`,
+			`name:"repeated_message_v1" number:10017 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".google.golang.org.proto2_20180125.Message.ChildMessage" extendee:".LegacyTestMessage"`,
+			reflect.TypeOf([]*proto2_20180125.Message_ChildMessage(nil)), depReg,
+		),
+		mustMakeExtensionType(
+			`package:"fizz.buzz" dependency:["legacy.proto", "enum2.proto"]`,
+			`name:"repeated_enum_v2" number:10018 label:LABEL_REPEATED type:TYPE_ENUM type_name:".EnumProto2" extendee:".LegacyTestMessage"`,
+			reflect.TypeOf([]EnumProto2(nil)), depReg,
+		),
+		mustMakeExtensionType(
+			`package:"fizz.buzz" dependency:["legacy.proto", "enum-messages.proto"]`,
+			`name:"repeated_message_v2" number:10019 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".EnumMessages" extendee:".LegacyTestMessage"`,
+			reflect.TypeOf([]*EnumMessages(nil)), depReg,
+		),
+	}
+
+	extensionDescs = []*pimpl.ExtensionInfo{{
+		ExtendedType:  (*LegacyTestMessage)(nil),
+		ExtensionType: (*bool)(nil),
+		Field:         10000,
+		Name:          "fizz.buzz.optional_bool",
+		Tag:           "varint,10000,opt,name=optional_bool,def=1",
+		Filename:      "test.proto",
+	}, {
+		ExtendedType:  (*LegacyTestMessage)(nil),
+		ExtensionType: (*int32)(nil),
+		Field:         10001,
+		Name:          "fizz.buzz.optional_int32",
+		Tag:           "varint,10001,opt,name=optional_int32,def=-12345",
+		Filename:      "test.proto",
+	}, {
+		ExtendedType:  (*LegacyTestMessage)(nil),
+		ExtensionType: (*uint32)(nil),
+		Field:         10002,
+		Name:          "fizz.buzz.optional_uint32",
+		Tag:           "varint,10002,opt,name=optional_uint32,def=3200",
+		Filename:      "test.proto",
+	}, {
+		ExtendedType:  (*LegacyTestMessage)(nil),
+		ExtensionType: (*float32)(nil),
+		Field:         10003,
+		Name:          "fizz.buzz.optional_float",
+		Tag:           "fixed32,10003,opt,name=optional_float,def=3.14159",
+		Filename:      "test.proto",
+	}, {
+		ExtendedType:  (*LegacyTestMessage)(nil),
+		ExtensionType: (*string)(nil),
+		Field:         10004,
+		Name:          "fizz.buzz.optional_string",
+		Tag:           "bytes,10004,opt,name=optional_string,def=hello, \"world!\"\n",
+		Filename:      "test.proto",
+	}, {
+		ExtendedType:  (*LegacyTestMessage)(nil),
+		ExtensionType: ([]byte)(nil),
+		Field:         10005,
+		Name:          "fizz.buzz.optional_bytes",
+		Tag:           "bytes,10005,opt,name=optional_bytes,def=dead\\336\\255\\276\\357beef",
+		Filename:      "test.proto",
+	}, {
+		ExtendedType:  (*LegacyTestMessage)(nil),
+		ExtensionType: (*proto2_20180125.Message_ChildEnum)(nil),
+		Field:         10006,
+		Name:          "fizz.buzz.optional_enum_v1",
+		Tag:           "varint,10006,opt,name=optional_enum_v1,enum=google.golang.org.proto2_20180125.Message_ChildEnum,def=0",
+		Filename:      "test.proto",
+	}, {
+		ExtendedType:  (*LegacyTestMessage)(nil),
+		ExtensionType: (*proto2_20180125.Message_ChildMessage)(nil),
+		Field:         10007,
+		Name:          "fizz.buzz.optional_message_v1",
+		Tag:           "bytes,10007,opt,name=optional_message_v1",
+		Filename:      "test.proto",
+	}, {
+		ExtendedType:  (*LegacyTestMessage)(nil),
+		ExtensionType: (*EnumProto2)(nil),
+		Field:         10008,
+		Name:          "fizz.buzz.optional_enum_v2",
+		Tag:           "varint,10008,opt,name=optional_enum_v2,enum=EnumProto2,def=57005",
+		Filename:      "test.proto",
+	}, {
+		ExtendedType:  (*LegacyTestMessage)(nil),
+		ExtensionType: (*EnumMessages)(nil),
+		Field:         10009,
+		Name:          "fizz.buzz.optional_message_v2",
+		Tag:           "bytes,10009,opt,name=optional_message_v2",
+		Filename:      "test.proto",
+	}, {
+		ExtendedType:  (*LegacyTestMessage)(nil),
+		ExtensionType: ([]bool)(nil),
+		Field:         10010,
+		Name:          "fizz.buzz.repeated_bool",
+		Tag:           "varint,10010,rep,name=repeated_bool",
+		Filename:      "test.proto",
+	}, {
+		ExtendedType:  (*LegacyTestMessage)(nil),
+		ExtensionType: ([]int32)(nil),
+		Field:         10011,
+		Name:          "fizz.buzz.repeated_int32",
+		Tag:           "varint,10011,rep,name=repeated_int32",
+		Filename:      "test.proto",
+	}, {
+		ExtendedType:  (*LegacyTestMessage)(nil),
+		ExtensionType: ([]uint32)(nil),
+		Field:         10012,
+		Name:          "fizz.buzz.repeated_uint32",
+		Tag:           "varint,10012,rep,name=repeated_uint32",
+		Filename:      "test.proto",
+	}, {
+		ExtendedType:  (*LegacyTestMessage)(nil),
+		ExtensionType: ([]float32)(nil),
+		Field:         10013,
+		Name:          "fizz.buzz.repeated_float",
+		Tag:           "fixed32,10013,rep,name=repeated_float",
+		Filename:      "test.proto",
+	}, {
+		ExtendedType:  (*LegacyTestMessage)(nil),
+		ExtensionType: ([]string)(nil),
+		Field:         10014,
+		Name:          "fizz.buzz.repeated_string",
+		Tag:           "bytes,10014,rep,name=repeated_string",
+		Filename:      "test.proto",
+	}, {
+		ExtendedType:  (*LegacyTestMessage)(nil),
+		ExtensionType: ([][]byte)(nil),
+		Field:         10015,
+		Name:          "fizz.buzz.repeated_bytes",
+		Tag:           "bytes,10015,rep,name=repeated_bytes",
+		Filename:      "test.proto",
+	}, {
+		ExtendedType:  (*LegacyTestMessage)(nil),
+		ExtensionType: ([]proto2_20180125.Message_ChildEnum)(nil),
+		Field:         10016,
+		Name:          "fizz.buzz.repeated_enum_v1",
+		Tag:           "varint,10016,rep,name=repeated_enum_v1,enum=google.golang.org.proto2_20180125.Message_ChildEnum",
+		Filename:      "test.proto",
+	}, {
+		ExtendedType:  (*LegacyTestMessage)(nil),
+		ExtensionType: ([]*proto2_20180125.Message_ChildMessage)(nil),
+		Field:         10017,
+		Name:          "fizz.buzz.repeated_message_v1",
+		Tag:           "bytes,10017,rep,name=repeated_message_v1",
+		Filename:      "test.proto",
+	}, {
+		ExtendedType:  (*LegacyTestMessage)(nil),
+		ExtensionType: ([]EnumProto2)(nil),
+		Field:         10018,
+		Name:          "fizz.buzz.repeated_enum_v2",
+		Tag:           "varint,10018,rep,name=repeated_enum_v2,enum=EnumProto2",
+		Filename:      "test.proto",
+	}, {
+		ExtendedType:  (*LegacyTestMessage)(nil),
+		ExtensionType: ([]*EnumMessages)(nil),
+		Field:         10019,
+		Name:          "fizz.buzz.repeated_message_v2",
+		Tag:           "bytes,10019,rep,name=repeated_message_v2",
+		Filename:      "test.proto",
+	}}
+)
+
+func TestLegacyExtensions(t *testing.T) {
+	opts := cmp.Options{cmp.Comparer(func(x, y *proto2_20180125.Message_ChildMessage) bool {
+		return x == y // pointer compare messages for object identity
+	})}
+
+	m := pimpl.Export{}.MessageOf(new(LegacyTestMessage))
+
+	// Check that getting the zero value returns the default value for scalars,
+	// nil for singular messages, and an empty list for repeated fields.
+	defaultValues := map[int]interface{}{
+		0: bool(true),
+		1: int32(-12345),
+		2: uint32(3200),
+		3: float32(3.14159),
+		4: string("hello, \"world!\"\n"),
+		5: []byte("dead\xde\xad\xbe\xefbeef"),
+		6: proto2_20180125.Message_ALPHA,
+		7: nil,
+		8: EnumProto2(0xdead),
+		9: nil,
+	}
+	for i, xt := range extensionTypes {
+		var got interface{}
+		xd := xt.TypeDescriptor()
+		if !(xd.IsList() || xd.IsMap() || xd.Message() != nil) {
+			got = xt.InterfaceOf(m.Get(xd))
+		}
+		want := defaultValues[i]
+		if diff := cmp.Diff(want, got, opts); diff != "" {
+			t.Errorf("Message.Get(%d) mismatch (-want +got):\n%v", xd.Number(), diff)
+		}
+	}
+
+	// All fields should be unpopulated.
+	for _, xt := range extensionTypes {
+		xd := xt.TypeDescriptor()
+		if m.Has(xd) {
+			t.Errorf("Message.Has(%d) = true, want false", xd.Number())
+		}
+	}
+
+	// Set some values and append to values to the lists.
+	m1a := &proto2_20180125.Message_ChildMessage{F1: proto.String("m1a")}
+	m1b := &proto2_20180125.Message_ChildMessage{F1: proto.String("m2b")}
+	m2a := &EnumMessages{EnumP2: EnumProto2(0x1b).Enum()}
+	m2b := &EnumMessages{EnumP2: EnumProto2(0x2b).Enum()}
+	setValues := map[int]interface{}{
+		0:  bool(false),
+		1:  int32(-54321),
+		2:  uint32(6400),
+		3:  float32(2.71828),
+		4:  string("goodbye, \"world!\"\n"),
+		5:  []byte("live\xde\xad\xbe\xefchicken"),
+		6:  proto2_20180125.Message_CHARLIE,
+		7:  m1a,
+		8:  EnumProto2(0xbeef),
+		9:  m2a,
+		10: []bool{true},
+		11: []int32{-1000},
+		12: []uint32{1280},
+		13: []float32{1.6180},
+		14: []string{"zero"},
+		15: [][]byte{[]byte("zero")},
+		16: []proto2_20180125.Message_ChildEnum{proto2_20180125.Message_BRAVO},
+		17: []*proto2_20180125.Message_ChildMessage{m1b},
+		18: []EnumProto2{0xdead},
+		19: []*EnumMessages{m2b},
+	}
+	for i, xt := range extensionTypes {
+		m.Set(xt.TypeDescriptor(), xt.ValueOf(setValues[i]))
+	}
+	for i, xt := range extensionTypes[len(extensionTypes)/2:] {
+		v := extensionTypes[i].ValueOf(setValues[i])
+		m.Get(xt.TypeDescriptor()).List().Append(v)
+	}
+
+	// Get the values and check for equality.
+	getValues := map[int]interface{}{
+		0:  bool(false),
+		1:  int32(-54321),
+		2:  uint32(6400),
+		3:  float32(2.71828),
+		4:  string("goodbye, \"world!\"\n"),
+		5:  []byte("live\xde\xad\xbe\xefchicken"),
+		6:  proto2_20180125.Message_ChildEnum(proto2_20180125.Message_CHARLIE),
+		7:  m1a,
+		8:  EnumProto2(0xbeef),
+		9:  m2a,
+		10: []bool{true, false},
+		11: []int32{-1000, -54321},
+		12: []uint32{1280, 6400},
+		13: []float32{1.6180, 2.71828},
+		14: []string{"zero", "goodbye, \"world!\"\n"},
+		15: [][]byte{[]byte("zero"), []byte("live\xde\xad\xbe\xefchicken")},
+		16: []proto2_20180125.Message_ChildEnum{proto2_20180125.Message_BRAVO, proto2_20180125.Message_CHARLIE},
+		17: []*proto2_20180125.Message_ChildMessage{m1b, m1a},
+		18: []EnumProto2{0xdead, 0xbeef},
+		19: []*EnumMessages{m2b, m2a},
+	}
+	for i, xt := range extensionTypes {
+		xd := xt.TypeDescriptor()
+		got := xt.InterfaceOf(m.Get(xd))
+		want := getValues[i]
+		if diff := cmp.Diff(want, got, opts); diff != "" {
+			t.Errorf("Message.Get(%d) mismatch (-want +got):\n%v", xd.Number(), diff)
+		}
+	}
+
+	// Clear all singular fields and truncate all repeated fields.
+	for _, xt := range extensionTypes[:len(extensionTypes)/2] {
+		m.Clear(xt.TypeDescriptor())
+	}
+	for _, xt := range extensionTypes[len(extensionTypes)/2:] {
+		m.Get(xt.TypeDescriptor()).List().Truncate(0)
+	}
+
+	// Clear all repeated fields.
+	for _, xt := range extensionTypes[len(extensionTypes)/2:] {
+		m.Clear(xt.TypeDescriptor())
+	}
+}
+
+func TestLegacyExtensionConvert(t *testing.T) {
+	for i := range extensionTypes {
+		i := i
+		t.Run("", func(t *testing.T) {
+			t.Parallel()
+
+			wantType := extensionTypes[i]
+			wantDesc := extensionDescs[i]
+			gotType := (pref.ExtensionType)(wantDesc)
+			gotDesc := wantType.(*pimpl.ExtensionInfo)
+
+			// Concurrently call accessors to trigger possible races.
+			for _, xt := range []pref.ExtensionType{wantType, wantDesc} {
+				xt := xt
+				go func() { xt.New() }()
+				go func() { xt.Zero() }()
+				go func() { xt.TypeDescriptor() }()
+			}
+
+			// TODO: We need a test package to compare descriptors.
+			type list interface {
+				Len() int
+				pragma.DoNotImplement
+			}
+			opts := cmp.Options{
+				cmp.Comparer(func(x, y reflect.Type) bool {
+					return x == y
+				}),
+				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 "ParentFile", "Parent":
+							// Ignore parents to avoid recursive cycle.
+							case "Options":
+								// Ignore descriptor options since protos are not cmperable.
+							case "ContainingOneof", "ContainingMessage", "Enum", "Message":
+								// 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()
+								}
+							case "Type":
+								// Ignore ExtensionTypeDescriptor.Type method to avoid cycle.
+							default:
+								out[name] = m.Call(nil)[0].Interface()
+							}
+						}
+					}
+					return out
+				}),
+				cmp.Transformer("", func(xt pref.ExtensionType) map[string]interface{} {
+					return map[string]interface{}{
+						"Descriptor": xt.TypeDescriptor(),
+					}
+				}),
+				cmp.Transformer("", func(v pref.Value) interface{} {
+					return v.Interface()
+				}),
+			}
+			if diff := cmp.Diff(&wantType, &gotType, opts); diff != "" {
+				t.Errorf("ExtensionType mismatch (-want, +got):\n%v", diff)
+			}
+
+			opts = cmp.Options{
+				cmpopts.IgnoreFields(pimpl.ExtensionInfo{}, "ExtensionType"),
+				cmpopts.IgnoreUnexported(pimpl.ExtensionInfo{}),
+			}
+			if diff := cmp.Diff(wantDesc, gotDesc, opts); diff != "" {
+				t.Errorf("ExtensionDesc mismatch (-want, +got):\n%v", diff)
+			}
+		})
+	}
+}
+
+type (
+	MessageA struct {
+		A1 *MessageA `protobuf:"bytes,1,req,name=a1"`
+		A2 *MessageB `protobuf:"bytes,2,req,name=a2"`
+		A3 Enum      `protobuf:"varint,3,opt,name=a3,enum=legacy.Enum"`
+	}
+	MessageB struct {
+		B1 *MessageA `protobuf:"bytes,1,req,name=b1"`
+		B2 *MessageB `protobuf:"bytes,2,req,name=b2"`
+		B3 Enum      `protobuf:"varint,3,opt,name=b3,enum=legacy.Enum"`
+	}
+	Enum int32
+)
+
+func (*MessageA) Reset()                      { panic("not implemented") }
+func (*MessageA) String() string              { panic("not implemented") }
+func (*MessageA) ProtoMessage()               { panic("not implemented") }
+func (*MessageA) Descriptor() ([]byte, []int) { return concurrentFD, []int{0} }
+
+func (*MessageB) Reset()                      { panic("not implemented") }
+func (*MessageB) String() string              { panic("not implemented") }
+func (*MessageB) ProtoMessage()               { panic("not implemented") }
+func (*MessageB) Descriptor() ([]byte, []int) { return concurrentFD, []int{1} }
+
+func (Enum) EnumDescriptor() ([]byte, []int) { return concurrentFD, []int{0} }
+
+var concurrentFD = func() []byte {
+	b, _ := proto.Marshal(pdesc.ToFileDescriptorProto(mustMakeFileDesc(`
+		name:    "concurrent.proto"
+		syntax:  "proto2"
+		package: "legacy"
+		message_type: [{
+			name: "MessageA"
+			field: [
+				{name:"a1" number:1 label:LABEL_REQUIRED type:TYPE_MESSAGE type_name:".legacy.MessageA"},
+				{name:"a2" number:2 label:LABEL_REQUIRED type:TYPE_MESSAGE type_name:".legacy.MessageB"},
+				{name:"a3" number:3 label:LABEL_OPTIONAL type:TYPE_ENUM    type_name:".legacy.Enum"}
+			]
+		}, {
+			name: "MessageB"
+			field: [
+				{name:"a1" number:1 label:LABEL_REQUIRED type:TYPE_MESSAGE type_name:".legacy.MessageA"},
+				{name:"a2" number:2 label:LABEL_REQUIRED type:TYPE_MESSAGE type_name:".legacy.MessageB"},
+				{name:"a3" number:3 label:LABEL_OPTIONAL type:TYPE_ENUM    type_name:".legacy.Enum"}
+			]
+		}]
+		enum_type: [{
+			name:  "Enum"
+			value: [{name:"FOO" number:500}]
+		}]
+	`, nil)))
+	return pimpl.Export{}.CompressGZIP(b)
+}()
+
+// TestLegacyConcurrentInit tests that concurrent wrapping of multiple legacy types
+// results in the exact same descriptor being created.
+func TestLegacyConcurrentInit(t *testing.T) {
+	const numParallel = 5
+	var messageATypes [numParallel]pref.MessageType
+	var messageBTypes [numParallel]pref.MessageType
+	var enumDescs [numParallel]pref.EnumDescriptor
+
+	// Concurrently load message and enum types.
+	var wg sync.WaitGroup
+	for i := 0; i < numParallel; i++ {
+		i := i
+		wg.Add(3)
+		go func() {
+			defer wg.Done()
+			messageATypes[i] = pimpl.Export{}.MessageTypeOf((*MessageA)(nil))
+		}()
+		go func() {
+			defer wg.Done()
+			messageBTypes[i] = pimpl.Export{}.MessageTypeOf((*MessageB)(nil))
+		}()
+		go func() {
+			defer wg.Done()
+			enumDescs[i] = pimpl.Export{}.EnumDescriptorOf(Enum(0))
+		}()
+	}
+	wg.Wait()
+
+	var (
+		wantMTA = messageATypes[0]
+		wantMDA = messageATypes[0].Descriptor().Fields().ByNumber(1).Message()
+		wantMTB = messageBTypes[0]
+		wantMDB = messageBTypes[0].Descriptor().Fields().ByNumber(2).Message()
+		wantED  = messageATypes[0].Descriptor().Fields().ByNumber(3).Enum()
+	)
+
+	for _, gotMT := range messageATypes[1:] {
+		if gotMT != wantMTA {
+			t.Error("MessageType(MessageA) mismatch")
+		}
+		if gotMDA := gotMT.Descriptor().Fields().ByNumber(1).Message(); gotMDA != wantMDA {
+			t.Error("MessageDescriptor(MessageA) mismatch")
+		}
+		if gotMDB := gotMT.Descriptor().Fields().ByNumber(2).Message(); gotMDB != wantMDB {
+			t.Error("MessageDescriptor(MessageB) mismatch")
+		}
+		if gotED := gotMT.Descriptor().Fields().ByNumber(3).Enum(); gotED != wantED {
+			t.Error("EnumDescriptor(Enum) mismatch")
+		}
+	}
+	for _, gotMT := range messageBTypes[1:] {
+		if gotMT != wantMTB {
+			t.Error("MessageType(MessageB) mismatch")
+		}
+		if gotMDA := gotMT.Descriptor().Fields().ByNumber(1).Message(); gotMDA != wantMDA {
+			t.Error("MessageDescriptor(MessageA) mismatch")
+		}
+		if gotMDB := gotMT.Descriptor().Fields().ByNumber(2).Message(); gotMDB != wantMDB {
+			t.Error("MessageDescriptor(MessageB) mismatch")
+		}
+		if gotED := gotMT.Descriptor().Fields().ByNumber(3).Enum(); gotED != wantED {
+			t.Error("EnumDescriptor(Enum) mismatch")
+		}
+	}
+	for _, gotED := range enumDescs[1:] {
+		if gotED != wantED {
+			t.Error("EnumType(Enum) mismatch")
+		}
+	}
+}
+
+type LegacyTestMessageName1 struct{}
+
+func (*LegacyTestMessageName1) Reset()         { panic("not implemented") }
+func (*LegacyTestMessageName1) String() string { panic("not implemented") }
+func (*LegacyTestMessageName1) ProtoMessage()  { panic("not implemented") }
+
+type LegacyTestMessageName2 struct{}
+
+func (*LegacyTestMessageName2) Reset()         { panic("not implemented") }
+func (*LegacyTestMessageName2) String() string { panic("not implemented") }
+func (*LegacyTestMessageName2) ProtoMessage()  { panic("not implemented") }
+func (*LegacyTestMessageName2) XXX_MessageName() string {
+	return "google.golang.org.LegacyTestMessageName2"
+}
+
+func TestLegacyMessageName(t *testing.T) {
+	tests := []struct {
+		in          piface.MessageV1
+		suggestName pref.FullName
+		wantName    pref.FullName
+	}{
+		{new(LegacyTestMessageName1), "google.golang.org.LegacyTestMessageName1", "google.golang.org.LegacyTestMessageName1"},
+		{new(LegacyTestMessageName2), "", "google.golang.org.LegacyTestMessageName2"},
+	}
+
+	for _, tt := range tests {
+		mt := pimpl.Export{}.LegacyMessageTypeOf(tt.in, tt.suggestName)
+		if got := mt.Descriptor().FullName(); got != tt.wantName {
+			t.Errorf("type: %T, name mismatch: got %v, want %v", tt.in, got, tt.wantName)
+		}
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/merge.go b/vendor/google.golang.org/protobuf/internal/impl/merge.go
new file mode 100644
index 000000000..cdc4267df
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/merge.go
@@ -0,0 +1,176 @@
+// Copyright 2020 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"
+	"reflect"
+
+	"google.golang.org/protobuf/proto"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+	piface "google.golang.org/protobuf/runtime/protoiface"
+)
+
+type mergeOptions struct{}
+
+func (o mergeOptions) Merge(dst, src proto.Message) {
+	proto.Merge(dst, src)
+}
+
+// merge is protoreflect.Methods.Merge.
+func (mi *MessageInfo) merge(in piface.MergeInput) piface.MergeOutput {
+	dp, ok := mi.getPointer(in.Destination)
+	if !ok {
+		return piface.MergeOutput{}
+	}
+	sp, ok := mi.getPointer(in.Source)
+	if !ok {
+		return piface.MergeOutput{}
+	}
+	mi.mergePointer(dp, sp, mergeOptions{})
+	return piface.MergeOutput{Flags: piface.MergeComplete}
+}
+
+func (mi *MessageInfo) mergePointer(dst, src pointer, opts mergeOptions) {
+	mi.init()
+	if dst.IsNil() {
+		panic(fmt.Sprintf("invalid value: merging into nil message"))
+	}
+	if src.IsNil() {
+		return
+	}
+	for _, f := range mi.orderedCoderFields {
+		if f.funcs.merge == nil {
+			continue
+		}
+		sfptr := src.Apply(f.offset)
+		if f.isPointer && sfptr.Elem().IsNil() {
+			continue
+		}
+		f.funcs.merge(dst.Apply(f.offset), sfptr, f, opts)
+	}
+	if mi.extensionOffset.IsValid() {
+		sext := src.Apply(mi.extensionOffset).Extensions()
+		dext := dst.Apply(mi.extensionOffset).Extensions()
+		if *dext == nil {
+			*dext = make(map[int32]ExtensionField)
+		}
+		for num, sx := range *sext {
+			xt := sx.Type()
+			xi := getExtensionFieldInfo(xt)
+			if xi.funcs.merge == nil {
+				continue
+			}
+			dx := (*dext)[num]
+			var dv pref.Value
+			if dx.Type() == sx.Type() {
+				dv = dx.Value()
+			}
+			if !dv.IsValid() && xi.unmarshalNeedsValue {
+				dv = xt.New()
+			}
+			dv = xi.funcs.merge(dv, sx.Value(), opts)
+			dx.Set(sx.Type(), dv)
+			(*dext)[num] = dx
+		}
+	}
+	if mi.unknownOffset.IsValid() {
+		du := dst.Apply(mi.unknownOffset).Bytes()
+		su := src.Apply(mi.unknownOffset).Bytes()
+		if len(*su) > 0 {
+			*du = append(*du, *su...)
+		}
+	}
+}
+
+func mergeScalarValue(dst, src pref.Value, opts mergeOptions) pref.Value {
+	return src
+}
+
+func mergeBytesValue(dst, src pref.Value, opts mergeOptions) pref.Value {
+	return pref.ValueOfBytes(append(emptyBuf[:], src.Bytes()...))
+}
+
+func mergeListValue(dst, src pref.Value, opts mergeOptions) pref.Value {
+	dstl := dst.List()
+	srcl := src.List()
+	for i, llen := 0, srcl.Len(); i < llen; i++ {
+		dstl.Append(srcl.Get(i))
+	}
+	return dst
+}
+
+func mergeBytesListValue(dst, src pref.Value, opts mergeOptions) pref.Value {
+	dstl := dst.List()
+	srcl := src.List()
+	for i, llen := 0, srcl.Len(); i < llen; i++ {
+		sb := srcl.Get(i).Bytes()
+		db := append(emptyBuf[:], sb...)
+		dstl.Append(pref.ValueOfBytes(db))
+	}
+	return dst
+}
+
+func mergeMessageListValue(dst, src pref.Value, opts mergeOptions) pref.Value {
+	dstl := dst.List()
+	srcl := src.List()
+	for i, llen := 0, srcl.Len(); i < llen; i++ {
+		sm := srcl.Get(i).Message()
+		dm := proto.Clone(sm.Interface()).ProtoReflect()
+		dstl.Append(pref.ValueOfMessage(dm))
+	}
+	return dst
+}
+
+func mergeMessageValue(dst, src pref.Value, opts mergeOptions) pref.Value {
+	opts.Merge(dst.Message().Interface(), src.Message().Interface())
+	return dst
+}
+
+func mergeMessage(dst, src pointer, f *coderFieldInfo, opts mergeOptions) {
+	if f.mi != nil {
+		if dst.Elem().IsNil() {
+			dst.SetPointer(pointerOfValue(reflect.New(f.mi.GoReflectType.Elem())))
+		}
+		f.mi.mergePointer(dst.Elem(), src.Elem(), opts)
+	} else {
+		dm := dst.AsValueOf(f.ft).Elem()
+		sm := src.AsValueOf(f.ft).Elem()
+		if dm.IsNil() {
+			dm.Set(reflect.New(f.ft.Elem()))
+		}
+		opts.Merge(asMessage(dm), asMessage(sm))
+	}
+}
+
+func mergeMessageSlice(dst, src pointer, f *coderFieldInfo, opts mergeOptions) {
+	for _, sp := range src.PointerSlice() {
+		dm := reflect.New(f.ft.Elem().Elem())
+		if f.mi != nil {
+			f.mi.mergePointer(pointerOfValue(dm), sp, opts)
+		} else {
+			opts.Merge(asMessage(dm), asMessage(sp.AsValueOf(f.ft.Elem().Elem())))
+		}
+		dst.AppendPointerSlice(pointerOfValue(dm))
+	}
+}
+
+func mergeBytes(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	*dst.Bytes() = append(emptyBuf[:], *src.Bytes()...)
+}
+
+func mergeBytesNoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	v := *src.Bytes()
+	if len(v) > 0 {
+		*dst.Bytes() = append(emptyBuf[:], v...)
+	}
+}
+
+func mergeBytesSlice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	ds := dst.BytesSlice()
+	for _, v := range *src.BytesSlice() {
+		*ds = append(*ds, append(emptyBuf[:], v...))
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/merge_gen.go b/vendor/google.golang.org/protobuf/internal/impl/merge_gen.go
new file mode 100644
index 000000000..8816c274d
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/merge_gen.go
@@ -0,0 +1,209 @@
+// 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.
+
+// Code generated by generate-types. DO NOT EDIT.
+
+package impl
+
+import ()
+
+func mergeBool(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	*dst.Bool() = *src.Bool()
+}
+
+func mergeBoolNoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	v := *src.Bool()
+	if v != false {
+		*dst.Bool() = v
+	}
+}
+
+func mergeBoolPtr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	p := *src.BoolPtr()
+	if p != nil {
+		v := *p
+		*dst.BoolPtr() = &v
+	}
+}
+
+func mergeBoolSlice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	ds := dst.BoolSlice()
+	ss := src.BoolSlice()
+	*ds = append(*ds, *ss...)
+}
+
+func mergeInt32(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	*dst.Int32() = *src.Int32()
+}
+
+func mergeInt32NoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	v := *src.Int32()
+	if v != 0 {
+		*dst.Int32() = v
+	}
+}
+
+func mergeInt32Ptr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	p := *src.Int32Ptr()
+	if p != nil {
+		v := *p
+		*dst.Int32Ptr() = &v
+	}
+}
+
+func mergeInt32Slice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	ds := dst.Int32Slice()
+	ss := src.Int32Slice()
+	*ds = append(*ds, *ss...)
+}
+
+func mergeUint32(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	*dst.Uint32() = *src.Uint32()
+}
+
+func mergeUint32NoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	v := *src.Uint32()
+	if v != 0 {
+		*dst.Uint32() = v
+	}
+}
+
+func mergeUint32Ptr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	p := *src.Uint32Ptr()
+	if p != nil {
+		v := *p
+		*dst.Uint32Ptr() = &v
+	}
+}
+
+func mergeUint32Slice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	ds := dst.Uint32Slice()
+	ss := src.Uint32Slice()
+	*ds = append(*ds, *ss...)
+}
+
+func mergeInt64(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	*dst.Int64() = *src.Int64()
+}
+
+func mergeInt64NoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	v := *src.Int64()
+	if v != 0 {
+		*dst.Int64() = v
+	}
+}
+
+func mergeInt64Ptr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	p := *src.Int64Ptr()
+	if p != nil {
+		v := *p
+		*dst.Int64Ptr() = &v
+	}
+}
+
+func mergeInt64Slice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	ds := dst.Int64Slice()
+	ss := src.Int64Slice()
+	*ds = append(*ds, *ss...)
+}
+
+func mergeUint64(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	*dst.Uint64() = *src.Uint64()
+}
+
+func mergeUint64NoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	v := *src.Uint64()
+	if v != 0 {
+		*dst.Uint64() = v
+	}
+}
+
+func mergeUint64Ptr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	p := *src.Uint64Ptr()
+	if p != nil {
+		v := *p
+		*dst.Uint64Ptr() = &v
+	}
+}
+
+func mergeUint64Slice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	ds := dst.Uint64Slice()
+	ss := src.Uint64Slice()
+	*ds = append(*ds, *ss...)
+}
+
+func mergeFloat32(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	*dst.Float32() = *src.Float32()
+}
+
+func mergeFloat32NoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	v := *src.Float32()
+	if v != 0 {
+		*dst.Float32() = v
+	}
+}
+
+func mergeFloat32Ptr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	p := *src.Float32Ptr()
+	if p != nil {
+		v := *p
+		*dst.Float32Ptr() = &v
+	}
+}
+
+func mergeFloat32Slice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	ds := dst.Float32Slice()
+	ss := src.Float32Slice()
+	*ds = append(*ds, *ss...)
+}
+
+func mergeFloat64(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	*dst.Float64() = *src.Float64()
+}
+
+func mergeFloat64NoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	v := *src.Float64()
+	if v != 0 {
+		*dst.Float64() = v
+	}
+}
+
+func mergeFloat64Ptr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	p := *src.Float64Ptr()
+	if p != nil {
+		v := *p
+		*dst.Float64Ptr() = &v
+	}
+}
+
+func mergeFloat64Slice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	ds := dst.Float64Slice()
+	ss := src.Float64Slice()
+	*ds = append(*ds, *ss...)
+}
+
+func mergeString(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	*dst.String() = *src.String()
+}
+
+func mergeStringNoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	v := *src.String()
+	if v != "" {
+		*dst.String() = v
+	}
+}
+
+func mergeStringPtr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	p := *src.StringPtr()
+	if p != nil {
+		v := *p
+		*dst.StringPtr() = &v
+	}
+}
+
+func mergeStringSlice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
+	ds := dst.StringSlice()
+	ss := src.StringSlice()
+	*ds = append(*ds, *ss...)
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/message.go b/vendor/google.golang.org/protobuf/internal/impl/message.go
new file mode 100644
index 000000000..7dd994bd9
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/message.go
@@ -0,0 +1,215 @@
+// 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"
+	"reflect"
+	"strconv"
+	"strings"
+	"sync"
+	"sync/atomic"
+
+	"google.golang.org/protobuf/internal/genname"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+)
+
+// MessageInfo provides protobuf related functionality for a given Go type
+// that represents a message. A given instance of MessageInfo is tied to
+// exactly one Go type, which must be a pointer to a struct type.
+//
+// The exported fields must be populated before any methods are called
+// and cannot be mutated after set.
+type MessageInfo struct {
+	// GoReflectType is the underlying message Go type and must be populated.
+	GoReflectType reflect.Type // pointer to struct
+
+	// Desc is the underlying message descriptor type and must be populated.
+	Desc pref.MessageDescriptor
+
+	// Exporter must be provided in a purego environment in order to provide
+	// access to unexported fields.
+	Exporter exporter
+
+	// OneofWrappers is list of pointers to oneof wrapper struct types.
+	OneofWrappers []interface{}
+
+	initMu   sync.Mutex // protects all unexported fields
+	initDone uint32
+
+	reflectMessageInfo // for reflection implementation
+	coderMessageInfo   // for fast-path method implementations
+}
+
+// exporter is a function that returns a reference to the ith field of v,
+// where v is a pointer to a struct. It returns nil if it does not support
+// exporting the requested field (e.g., already exported).
+type exporter func(v interface{}, i int) interface{}
+
+// getMessageInfo returns the MessageInfo for any message type that
+// is generated by our implementation of protoc-gen-go (for v2 and on).
+// If it is unable to obtain a MessageInfo, it returns nil.
+func getMessageInfo(mt reflect.Type) *MessageInfo {
+	m, ok := reflect.Zero(mt).Interface().(pref.ProtoMessage)
+	if !ok {
+		return nil
+	}
+	mr, ok := m.ProtoReflect().(interface{ ProtoMessageInfo() *MessageInfo })
+	if !ok {
+		return nil
+	}
+	return mr.ProtoMessageInfo()
+}
+
+func (mi *MessageInfo) init() {
+	// This function is called in the hot path. Inline the sync.Once logic,
+	// since allocating a closure for Once.Do is expensive.
+	// Keep init small to ensure that it can be inlined.
+	if atomic.LoadUint32(&mi.initDone) == 0 {
+		mi.initOnce()
+	}
+}
+
+func (mi *MessageInfo) initOnce() {
+	mi.initMu.Lock()
+	defer mi.initMu.Unlock()
+	if mi.initDone == 1 {
+		return
+	}
+
+	t := mi.GoReflectType
+	if t.Kind() != reflect.Ptr && t.Elem().Kind() != reflect.Struct {
+		panic(fmt.Sprintf("got %v, want *struct kind", t))
+	}
+	t = t.Elem()
+
+	si := mi.makeStructInfo(t)
+	mi.makeReflectFuncs(t, si)
+	mi.makeCoderMethods(t, si)
+
+	atomic.StoreUint32(&mi.initDone, 1)
+}
+
+// getPointer returns the pointer for a message, which should be of
+// the type of the MessageInfo. If the message is of a different type,
+// it returns ok==false.
+func (mi *MessageInfo) getPointer(m pref.Message) (p pointer, ok bool) {
+	switch m := m.(type) {
+	case *messageState:
+		return m.pointer(), m.messageInfo() == mi
+	case *messageReflectWrapper:
+		return m.pointer(), m.messageInfo() == mi
+	}
+	return pointer{}, false
+}
+
+type (
+	SizeCache       = int32
+	WeakFields      = map[int32]protoreflect.ProtoMessage
+	UnknownFields   = []byte
+	ExtensionFields = map[int32]ExtensionField
+)
+
+var (
+	sizecacheType       = reflect.TypeOf(SizeCache(0))
+	weakFieldsType      = reflect.TypeOf(WeakFields(nil))
+	unknownFieldsType   = reflect.TypeOf(UnknownFields(nil))
+	extensionFieldsType = reflect.TypeOf(ExtensionFields(nil))
+)
+
+type structInfo struct {
+	sizecacheOffset offset
+	weakOffset      offset
+	unknownOffset   offset
+	extensionOffset offset
+
+	fieldsByNumber        map[pref.FieldNumber]reflect.StructField
+	oneofsByName          map[pref.Name]reflect.StructField
+	oneofWrappersByType   map[reflect.Type]pref.FieldNumber
+	oneofWrappersByNumber map[pref.FieldNumber]reflect.Type
+}
+
+func (mi *MessageInfo) makeStructInfo(t reflect.Type) structInfo {
+	si := structInfo{
+		sizecacheOffset: invalidOffset,
+		weakOffset:      invalidOffset,
+		unknownOffset:   invalidOffset,
+		extensionOffset: invalidOffset,
+
+		fieldsByNumber:        map[pref.FieldNumber]reflect.StructField{},
+		oneofsByName:          map[pref.Name]reflect.StructField{},
+		oneofWrappersByType:   map[reflect.Type]pref.FieldNumber{},
+		oneofWrappersByNumber: map[pref.FieldNumber]reflect.Type{},
+	}
+
+fieldLoop:
+	for i := 0; i < t.NumField(); i++ {
+		switch f := t.Field(i); f.Name {
+		case genname.SizeCache, genname.SizeCacheA:
+			if f.Type == sizecacheType {
+				si.sizecacheOffset = offsetOf(f, mi.Exporter)
+			}
+		case genname.WeakFields, genname.WeakFieldsA:
+			if f.Type == weakFieldsType {
+				si.weakOffset = offsetOf(f, mi.Exporter)
+			}
+		case genname.UnknownFields, genname.UnknownFieldsA:
+			if f.Type == unknownFieldsType {
+				si.unknownOffset = offsetOf(f, mi.Exporter)
+			}
+		case genname.ExtensionFields, genname.ExtensionFieldsA, genname.ExtensionFieldsB:
+			if f.Type == extensionFieldsType {
+				si.extensionOffset = offsetOf(f, mi.Exporter)
+			}
+		default:
+			for _, s := range strings.Split(f.Tag.Get("protobuf"), ",") {
+				if len(s) > 0 && strings.Trim(s, "0123456789") == "" {
+					n, _ := strconv.ParseUint(s, 10, 64)
+					si.fieldsByNumber[pref.FieldNumber(n)] = f
+					continue fieldLoop
+				}
+			}
+			if s := f.Tag.Get("protobuf_oneof"); len(s) > 0 {
+				si.oneofsByName[pref.Name(s)] = f
+				continue fieldLoop
+			}
+		}
+	}
+
+	// Derive a mapping of oneof wrappers to fields.
+	oneofWrappers := mi.OneofWrappers
+	for _, method := range []string{"XXX_OneofFuncs", "XXX_OneofWrappers"} {
+		if fn, ok := reflect.PtrTo(t).MethodByName(method); ok {
+			for _, v := range fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))}) {
+				if vs, ok := v.Interface().([]interface{}); ok {
+					oneofWrappers = vs
+				}
+			}
+		}
+	}
+	for _, v := range oneofWrappers {
+		tf := reflect.TypeOf(v).Elem()
+		f := tf.Field(0)
+		for _, s := range strings.Split(f.Tag.Get("protobuf"), ",") {
+			if len(s) > 0 && strings.Trim(s, "0123456789") == "" {
+				n, _ := strconv.ParseUint(s, 10, 64)
+				si.oneofWrappersByType[tf] = pref.FieldNumber(n)
+				si.oneofWrappersByNumber[pref.FieldNumber(n)] = tf
+				break
+			}
+		}
+	}
+
+	return si
+}
+
+func (mi *MessageInfo) New() protoreflect.Message {
+	return mi.MessageOf(reflect.New(mi.GoReflectType.Elem()).Interface())
+}
+func (mi *MessageInfo) Zero() protoreflect.Message {
+	return mi.MessageOf(reflect.Zero(mi.GoReflectType).Interface())
+}
+func (mi *MessageInfo) Descriptor() protoreflect.MessageDescriptor { return mi.Desc }
diff --git a/vendor/google.golang.org/protobuf/internal/impl/message_reflect.go b/vendor/google.golang.org/protobuf/internal/impl/message_reflect.go
new file mode 100644
index 000000000..0f4b8db76
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/message_reflect.go
@@ -0,0 +1,364 @@
+// Copyright 2019 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"
+	"reflect"
+
+	"google.golang.org/protobuf/internal/pragma"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+)
+
+type reflectMessageInfo struct {
+	fields map[pref.FieldNumber]*fieldInfo
+	oneofs map[pref.Name]*oneofInfo
+
+	// denseFields is a subset of fields where:
+	//	0 < fieldDesc.Number() < len(denseFields)
+	// It provides faster access to the fieldInfo, but may be incomplete.
+	denseFields []*fieldInfo
+
+	// rangeInfos is a list of all fields (not belonging to a oneof) and oneofs.
+	rangeInfos []interface{} // either *fieldInfo or *oneofInfo
+
+	getUnknown   func(pointer) pref.RawFields
+	setUnknown   func(pointer, pref.RawFields)
+	extensionMap func(pointer) *extensionMap
+
+	nilMessage atomicNilMessage
+}
+
+// makeReflectFuncs generates the set of functions to support reflection.
+func (mi *MessageInfo) makeReflectFuncs(t reflect.Type, si structInfo) {
+	mi.makeKnownFieldsFunc(si)
+	mi.makeUnknownFieldsFunc(t, si)
+	mi.makeExtensionFieldsFunc(t, si)
+}
+
+// makeKnownFieldsFunc generates functions for operations that can be performed
+// on each protobuf message field. It takes in a reflect.Type representing the
+// Go struct and matches message fields with struct fields.
+//
+// This code assumes that the struct is well-formed and panics if there are
+// any discrepancies.
+func (mi *MessageInfo) makeKnownFieldsFunc(si structInfo) {
+	mi.fields = map[pref.FieldNumber]*fieldInfo{}
+	md := mi.Desc
+	fds := md.Fields()
+	for i := 0; i < fds.Len(); i++ {
+		fd := fds.Get(i)
+		fs := si.fieldsByNumber[fd.Number()]
+		var fi fieldInfo
+		switch {
+		case fd.ContainingOneof() != nil && !fd.ContainingOneof().IsSynthetic():
+			fi = fieldInfoForOneof(fd, si.oneofsByName[fd.ContainingOneof().Name()], mi.Exporter, si.oneofWrappersByNumber[fd.Number()])
+		case fd.IsMap():
+			fi = fieldInfoForMap(fd, fs, mi.Exporter)
+		case fd.IsList():
+			fi = fieldInfoForList(fd, fs, mi.Exporter)
+		case fd.IsWeak():
+			fi = fieldInfoForWeakMessage(fd, si.weakOffset)
+		case fd.Kind() == pref.MessageKind || fd.Kind() == pref.GroupKind:
+			fi = fieldInfoForMessage(fd, fs, mi.Exporter)
+		default:
+			fi = fieldInfoForScalar(fd, fs, mi.Exporter)
+		}
+		mi.fields[fd.Number()] = &fi
+	}
+
+	mi.oneofs = map[pref.Name]*oneofInfo{}
+	for i := 0; i < md.Oneofs().Len(); i++ {
+		od := md.Oneofs().Get(i)
+		mi.oneofs[od.Name()] = makeOneofInfo(od, si, mi.Exporter)
+	}
+
+	mi.denseFields = make([]*fieldInfo, fds.Len()*2)
+	for i := 0; i < fds.Len(); i++ {
+		if fd := fds.Get(i); int(fd.Number()) < len(mi.denseFields) {
+			mi.denseFields[fd.Number()] = mi.fields[fd.Number()]
+		}
+	}
+
+	for i := 0; i < fds.Len(); {
+		fd := fds.Get(i)
+		if od := fd.ContainingOneof(); od != nil && !od.IsSynthetic() {
+			mi.rangeInfos = append(mi.rangeInfos, mi.oneofs[od.Name()])
+			i += od.Fields().Len()
+		} else {
+			mi.rangeInfos = append(mi.rangeInfos, mi.fields[fd.Number()])
+			i++
+		}
+	}
+}
+
+func (mi *MessageInfo) makeUnknownFieldsFunc(t reflect.Type, si structInfo) {
+	mi.getUnknown = func(pointer) pref.RawFields { return nil }
+	mi.setUnknown = func(pointer, pref.RawFields) { return }
+	if si.unknownOffset.IsValid() {
+		mi.getUnknown = func(p pointer) pref.RawFields {
+			if p.IsNil() {
+				return nil
+			}
+			rv := p.Apply(si.unknownOffset).AsValueOf(unknownFieldsType)
+			return pref.RawFields(*rv.Interface().(*[]byte))
+		}
+		mi.setUnknown = func(p pointer, b pref.RawFields) {
+			if p.IsNil() {
+				panic("invalid SetUnknown on nil Message")
+			}
+			rv := p.Apply(si.unknownOffset).AsValueOf(unknownFieldsType)
+			*rv.Interface().(*[]byte) = []byte(b)
+		}
+	} else {
+		mi.getUnknown = func(pointer) pref.RawFields {
+			return nil
+		}
+		mi.setUnknown = func(p pointer, _ pref.RawFields) {
+			if p.IsNil() {
+				panic("invalid SetUnknown on nil Message")
+			}
+		}
+	}
+}
+
+func (mi *MessageInfo) makeExtensionFieldsFunc(t reflect.Type, si structInfo) {
+	if si.extensionOffset.IsValid() {
+		mi.extensionMap = func(p pointer) *extensionMap {
+			if p.IsNil() {
+				return (*extensionMap)(nil)
+			}
+			v := p.Apply(si.extensionOffset).AsValueOf(extensionFieldsType)
+			return (*extensionMap)(v.Interface().(*map[int32]ExtensionField))
+		}
+	} else {
+		mi.extensionMap = func(pointer) *extensionMap {
+			return (*extensionMap)(nil)
+		}
+	}
+}
+
+type extensionMap map[int32]ExtensionField
+
+func (m *extensionMap) Range(f func(pref.FieldDescriptor, pref.Value) bool) {
+	if m != nil {
+		for _, x := range *m {
+			xd := x.Type().TypeDescriptor()
+			v := x.Value()
+			if xd.IsList() && v.List().Len() == 0 {
+				continue
+			}
+			if !f(xd, v) {
+				return
+			}
+		}
+	}
+}
+func (m *extensionMap) Has(xt pref.ExtensionType) (ok bool) {
+	if m == nil {
+		return false
+	}
+	xd := xt.TypeDescriptor()
+	x, ok := (*m)[int32(xd.Number())]
+	if !ok {
+		return false
+	}
+	switch {
+	case xd.IsList():
+		return x.Value().List().Len() > 0
+	case xd.IsMap():
+		return x.Value().Map().Len() > 0
+	case xd.Message() != nil:
+		return x.Value().Message().IsValid()
+	}
+	return true
+}
+func (m *extensionMap) Clear(xt pref.ExtensionType) {
+	delete(*m, int32(xt.TypeDescriptor().Number()))
+}
+func (m *extensionMap) Get(xt pref.ExtensionType) pref.Value {
+	xd := xt.TypeDescriptor()
+	if m != nil {
+		if x, ok := (*m)[int32(xd.Number())]; ok {
+			return x.Value()
+		}
+	}
+	return xt.Zero()
+}
+func (m *extensionMap) Set(xt pref.ExtensionType, v pref.Value) {
+	xd := xt.TypeDescriptor()
+	isValid := true
+	switch {
+	case !xt.IsValidValue(v):
+		isValid = false
+	case xd.IsList():
+		isValid = v.List().IsValid()
+	case xd.IsMap():
+		isValid = v.Map().IsValid()
+	case xd.Message() != nil:
+		isValid = v.Message().IsValid()
+	}
+	if !isValid {
+		panic(fmt.Sprintf("%v: assigning invalid value", xt.TypeDescriptor().FullName()))
+	}
+
+	if *m == nil {
+		*m = make(map[int32]ExtensionField)
+	}
+	var x ExtensionField
+	x.Set(xt, v)
+	(*m)[int32(xd.Number())] = x
+}
+func (m *extensionMap) Mutable(xt pref.ExtensionType) pref.Value {
+	xd := xt.TypeDescriptor()
+	if xd.Kind() != pref.MessageKind && xd.Kind() != pref.GroupKind && !xd.IsList() && !xd.IsMap() {
+		panic("invalid Mutable on field with non-composite type")
+	}
+	if x, ok := (*m)[int32(xd.Number())]; ok {
+		return x.Value()
+	}
+	v := xt.New()
+	m.Set(xt, v)
+	return v
+}
+
+// MessageState is a data structure that is nested as the first field in a
+// concrete message. It provides a way to implement the ProtoReflect method
+// in an allocation-free way without needing to have a shadow Go type generated
+// for every message type. This technique only works using unsafe.
+//
+//
+// Example generated code:
+//
+//	type M struct {
+//		state protoimpl.MessageState
+//
+//		Field1 int32
+//		Field2 string
+//		Field3 *BarMessage
+//		...
+//	}
+//
+//	func (m *M) ProtoReflect() protoreflect.Message {
+//		mi := &file_fizz_buzz_proto_msgInfos[5]
+//		if protoimpl.UnsafeEnabled && m != nil {
+//			ms := protoimpl.X.MessageStateOf(Pointer(m))
+//			if ms.LoadMessageInfo() == nil {
+//				ms.StoreMessageInfo(mi)
+//			}
+//			return ms
+//		}
+//		return mi.MessageOf(m)
+//	}
+//
+// The MessageState type holds a *MessageInfo, which must be atomically set to
+// the message info associated with a given message instance.
+// By unsafely converting a *M into a *MessageState, the MessageState object
+// has access to all the information needed to implement protobuf reflection.
+// It has access to the message info as its first field, and a pointer to the
+// MessageState is identical to a pointer to the concrete message value.
+//
+//
+// Requirements:
+//	• The type M must implement protoreflect.ProtoMessage.
+//	• The address of m must not be nil.
+//	• The address of m and the address of m.state must be equal,
+//	even though they are different Go types.
+type MessageState struct {
+	pragma.NoUnkeyedLiterals
+	pragma.DoNotCompare
+	pragma.DoNotCopy
+
+	atomicMessageInfo *MessageInfo
+}
+
+type messageState MessageState
+
+var (
+	_ pref.Message = (*messageState)(nil)
+	_ unwrapper    = (*messageState)(nil)
+)
+
+// messageDataType is a tuple of a pointer to the message data and
+// a pointer to the message type. It is a generalized way of providing a
+// reflective view over a message instance. The disadvantage of this approach
+// is the need to allocate this tuple of 16B.
+type messageDataType struct {
+	p  pointer
+	mi *MessageInfo
+}
+
+type (
+	messageReflectWrapper messageDataType
+	messageIfaceWrapper   messageDataType
+)
+
+var (
+	_ pref.Message      = (*messageReflectWrapper)(nil)
+	_ unwrapper         = (*messageReflectWrapper)(nil)
+	_ pref.ProtoMessage = (*messageIfaceWrapper)(nil)
+	_ unwrapper         = (*messageIfaceWrapper)(nil)
+)
+
+// MessageOf returns a reflective view over a message. The input must be a
+// pointer to a named Go struct. If the provided type has a ProtoReflect method,
+// it must be implemented by calling this method.
+func (mi *MessageInfo) MessageOf(m interface{}) pref.Message {
+	// TODO: Switch the input to be an opaque Pointer.
+	if reflect.TypeOf(m) != mi.GoReflectType {
+		panic(fmt.Sprintf("type mismatch: got %T, want %v", m, mi.GoReflectType))
+	}
+	p := pointerOfIface(m)
+	if p.IsNil() {
+		return mi.nilMessage.Init(mi)
+	}
+	return &messageReflectWrapper{p, mi}
+}
+
+func (m *messageReflectWrapper) pointer() pointer          { return m.p }
+func (m *messageReflectWrapper) messageInfo() *MessageInfo { return m.mi }
+
+func (m *messageIfaceWrapper) ProtoReflect() pref.Message {
+	return (*messageReflectWrapper)(m)
+}
+func (m *messageIfaceWrapper) protoUnwrap() interface{} {
+	return m.p.AsIfaceOf(m.mi.GoReflectType.Elem())
+}
+
+// checkField verifies that the provided field descriptor is valid.
+// Exactly one of the returned values is populated.
+func (mi *MessageInfo) checkField(fd pref.FieldDescriptor) (*fieldInfo, pref.ExtensionType) {
+	var fi *fieldInfo
+	if n := fd.Number(); 0 < n && int(n) < len(mi.denseFields) {
+		fi = mi.denseFields[n]
+	} else {
+		fi = mi.fields[n]
+	}
+	if fi != nil {
+		if fi.fieldDesc != fd {
+			if got, want := fd.FullName(), fi.fieldDesc.FullName(); got != want {
+				panic(fmt.Sprintf("mismatching field: got %v, want %v", got, want))
+			}
+			panic(fmt.Sprintf("mismatching field: %v", fd.FullName()))
+		}
+		return fi, nil
+	}
+
+	if fd.IsExtension() {
+		if got, want := fd.ContainingMessage().FullName(), mi.Desc.FullName(); got != want {
+			// TODO: Should this be exact containing message descriptor match?
+			panic(fmt.Sprintf("extension %v has mismatching containing message: got %v, want %v", fd.FullName(), got, want))
+		}
+		if !mi.Desc.ExtensionRanges().Has(fd.Number()) {
+			panic(fmt.Sprintf("extension %v extends %v outside the extension range", fd.FullName(), mi.Desc.FullName()))
+		}
+		xtd, ok := fd.(pref.ExtensionTypeDescriptor)
+		if !ok {
+			panic(fmt.Sprintf("extension %v does not implement protoreflect.ExtensionTypeDescriptor", fd.FullName()))
+		}
+		return nil, xtd.Type()
+	}
+	panic(fmt.Sprintf("field %v is invalid", fd.FullName()))
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/message_reflect_field.go b/vendor/google.golang.org/protobuf/internal/impl/message_reflect_field.go
new file mode 100644
index 000000000..23124a86e
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/message_reflect_field.go
@@ -0,0 +1,466 @@
+// 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"
+
+	"google.golang.org/protobuf/internal/flags"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+	preg "google.golang.org/protobuf/reflect/protoregistry"
+)
+
+type fieldInfo struct {
+	fieldDesc pref.FieldDescriptor
+
+	// These fields are used for protobuf reflection support.
+	has        func(pointer) bool
+	clear      func(pointer)
+	get        func(pointer) pref.Value
+	set        func(pointer, pref.Value)
+	mutable    func(pointer) pref.Value
+	newMessage func() pref.Message
+	newField   func() pref.Value
+}
+
+func fieldInfoForOneof(fd pref.FieldDescriptor, fs reflect.StructField, x exporter, ot reflect.Type) fieldInfo {
+	ft := fs.Type
+	if ft.Kind() != reflect.Interface {
+		panic(fmt.Sprintf("field %v has invalid type: got %v, want interface kind", fd.FullName(), ft))
+	}
+	if ot.Kind() != reflect.Struct {
+		panic(fmt.Sprintf("field %v has invalid type: got %v, want struct kind", fd.FullName(), ot))
+	}
+	if !reflect.PtrTo(ot).Implements(ft) {
+		panic(fmt.Sprintf("field %v has invalid type: %v does not implement %v", fd.FullName(), ot, ft))
+	}
+	conv := NewConverter(ot.Field(0).Type, fd)
+	isMessage := fd.Message() != nil
+
+	// TODO: Implement unsafe fast path?
+	fieldOffset := offsetOf(fs, x)
+	return fieldInfo{
+		// NOTE: The logic below intentionally assumes that oneof fields are
+		// well-formatted. That is, the oneof interface never contains a
+		// typed nil pointer to one of the wrapper structs.
+
+		fieldDesc: fd,
+		has: func(p pointer) bool {
+			if p.IsNil() {
+				return false
+			}
+			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
+			if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
+				return false
+			}
+			return true
+		},
+		clear: func(p pointer) {
+			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
+			if rv.IsNil() || rv.Elem().Type().Elem() != ot {
+				// NOTE: We intentionally don't check for rv.Elem().IsNil()
+				// so that (*OneofWrapperType)(nil) gets cleared to nil.
+				return
+			}
+			rv.Set(reflect.Zero(rv.Type()))
+		},
+		get: func(p pointer) pref.Value {
+			if p.IsNil() {
+				return conv.Zero()
+			}
+			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
+			if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
+				return conv.Zero()
+			}
+			rv = rv.Elem().Elem().Field(0)
+			return conv.PBValueOf(rv)
+		},
+		set: func(p pointer, v pref.Value) {
+			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
+			if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
+				rv.Set(reflect.New(ot))
+			}
+			rv = rv.Elem().Elem().Field(0)
+			rv.Set(conv.GoValueOf(v))
+		},
+		mutable: func(p pointer) pref.Value {
+			if !isMessage {
+				panic(fmt.Sprintf("field %v with invalid Mutable call on field with non-composite type", fd.FullName()))
+			}
+			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
+			if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
+				rv.Set(reflect.New(ot))
+			}
+			rv = rv.Elem().Elem().Field(0)
+			if rv.IsNil() {
+				rv.Set(conv.GoValueOf(pref.ValueOfMessage(conv.New().Message())))
+			}
+			return conv.PBValueOf(rv)
+		},
+		newMessage: func() pref.Message {
+			return conv.New().Message()
+		},
+		newField: func() pref.Value {
+			return conv.New()
+		},
+	}
+}
+
+func fieldInfoForMap(fd pref.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo {
+	ft := fs.Type
+	if ft.Kind() != reflect.Map {
+		panic(fmt.Sprintf("field %v has invalid type: got %v, want map kind", fd.FullName(), ft))
+	}
+	conv := NewConverter(ft, fd)
+
+	// TODO: Implement unsafe fast path?
+	fieldOffset := offsetOf(fs, x)
+	return fieldInfo{
+		fieldDesc: fd,
+		has: func(p pointer) bool {
+			if p.IsNil() {
+				return false
+			}
+			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
+			return rv.Len() > 0
+		},
+		clear: func(p pointer) {
+			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
+			rv.Set(reflect.Zero(rv.Type()))
+		},
+		get: func(p pointer) pref.Value {
+			if p.IsNil() {
+				return conv.Zero()
+			}
+			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
+			if rv.Len() == 0 {
+				return conv.Zero()
+			}
+			return conv.PBValueOf(rv)
+		},
+		set: func(p pointer, v pref.Value) {
+			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
+			pv := conv.GoValueOf(v)
+			if pv.IsNil() {
+				panic(fmt.Sprintf("map field %v cannot be set with read-only value", fd.FullName()))
+			}
+			rv.Set(pv)
+		},
+		mutable: func(p pointer) pref.Value {
+			v := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
+			if v.IsNil() {
+				v.Set(reflect.MakeMap(fs.Type))
+			}
+			return conv.PBValueOf(v)
+		},
+		newField: func() pref.Value {
+			return conv.New()
+		},
+	}
+}
+
+func fieldInfoForList(fd pref.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo {
+	ft := fs.Type
+	if ft.Kind() != reflect.Slice {
+		panic(fmt.Sprintf("field %v has invalid type: got %v, want slice kind", fd.FullName(), ft))
+	}
+	conv := NewConverter(reflect.PtrTo(ft), fd)
+
+	// TODO: Implement unsafe fast path?
+	fieldOffset := offsetOf(fs, x)
+	return fieldInfo{
+		fieldDesc: fd,
+		has: func(p pointer) bool {
+			if p.IsNil() {
+				return false
+			}
+			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
+			return rv.Len() > 0
+		},
+		clear: func(p pointer) {
+			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
+			rv.Set(reflect.Zero(rv.Type()))
+		},
+		get: func(p pointer) pref.Value {
+			if p.IsNil() {
+				return conv.Zero()
+			}
+			rv := p.Apply(fieldOffset).AsValueOf(fs.Type)
+			if rv.Elem().Len() == 0 {
+				return conv.Zero()
+			}
+			return conv.PBValueOf(rv)
+		},
+		set: func(p pointer, v pref.Value) {
+			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
+			pv := conv.GoValueOf(v)
+			if pv.IsNil() {
+				panic(fmt.Sprintf("list field %v cannot be set with read-only value", fd.FullName()))
+			}
+			rv.Set(pv.Elem())
+		},
+		mutable: func(p pointer) pref.Value {
+			v := p.Apply(fieldOffset).AsValueOf(fs.Type)
+			return conv.PBValueOf(v)
+		},
+		newField: func() pref.Value {
+			return conv.New()
+		},
+	}
+}
+
+var (
+	nilBytes   = reflect.ValueOf([]byte(nil))
+	emptyBytes = reflect.ValueOf([]byte{})
+)
+
+func fieldInfoForScalar(fd pref.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo {
+	ft := fs.Type
+	nullable := fd.HasPresence()
+	isBytes := ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8
+	if nullable {
+		if ft.Kind() != reflect.Ptr && ft.Kind() != reflect.Slice {
+			panic(fmt.Sprintf("field %v has invalid type: got %v, want pointer", fd.FullName(), ft))
+		}
+		if ft.Kind() == reflect.Ptr {
+			ft = ft.Elem()
+		}
+	}
+	conv := NewConverter(ft, fd)
+
+	// TODO: Implement unsafe fast path?
+	fieldOffset := offsetOf(fs, x)
+	return fieldInfo{
+		fieldDesc: fd,
+		has: func(p pointer) bool {
+			if p.IsNil() {
+				return false
+			}
+			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
+			if nullable {
+				return !rv.IsNil()
+			}
+			switch rv.Kind() {
+			case reflect.Bool:
+				return rv.Bool()
+			case reflect.Int32, reflect.Int64:
+				return rv.Int() != 0
+			case reflect.Uint32, reflect.Uint64:
+				return rv.Uint() != 0
+			case reflect.Float32, reflect.Float64:
+				return rv.Float() != 0 || math.Signbit(rv.Float())
+			case reflect.String, reflect.Slice:
+				return rv.Len() > 0
+			default:
+				panic(fmt.Sprintf("field %v has invalid type: %v", fd.FullName(), rv.Type())) // should never happen
+			}
+		},
+		clear: func(p pointer) {
+			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
+			rv.Set(reflect.Zero(rv.Type()))
+		},
+		get: func(p pointer) pref.Value {
+			if p.IsNil() {
+				return conv.Zero()
+			}
+			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
+			if nullable {
+				if rv.IsNil() {
+					return conv.Zero()
+				}
+				if rv.Kind() == reflect.Ptr {
+					rv = rv.Elem()
+				}
+			}
+			return conv.PBValueOf(rv)
+		},
+		set: func(p pointer, v pref.Value) {
+			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
+			if nullable && rv.Kind() == reflect.Ptr {
+				if rv.IsNil() {
+					rv.Set(reflect.New(ft))
+				}
+				rv = rv.Elem()
+			}
+			rv.Set(conv.GoValueOf(v))
+			if isBytes && rv.Len() == 0 {
+				if nullable {
+					rv.Set(emptyBytes) // preserve presence
+				} else {
+					rv.Set(nilBytes) // do not preserve presence
+				}
+			}
+		},
+		newField: func() pref.Value {
+			return conv.New()
+		},
+	}
+}
+
+func fieldInfoForWeakMessage(fd pref.FieldDescriptor, weakOffset offset) fieldInfo {
+	if !flags.ProtoLegacy {
+		panic("no support for proto1 weak fields")
+	}
+
+	var once sync.Once
+	var messageType pref.MessageType
+	lazyInit := func() {
+		once.Do(func() {
+			messageName := fd.Message().FullName()
+			messageType, _ = preg.GlobalTypes.FindMessageByName(messageName)
+			if messageType == nil {
+				panic(fmt.Sprintf("weak message %v for field %v is not linked in", messageName, fd.FullName()))
+			}
+		})
+	}
+
+	num := fd.Number()
+	return fieldInfo{
+		fieldDesc: fd,
+		has: func(p pointer) bool {
+			if p.IsNil() {
+				return false
+			}
+			_, ok := p.Apply(weakOffset).WeakFields().get(num)
+			return ok
+		},
+		clear: func(p pointer) {
+			p.Apply(weakOffset).WeakFields().clear(num)
+		},
+		get: func(p pointer) pref.Value {
+			lazyInit()
+			if p.IsNil() {
+				return pref.ValueOfMessage(messageType.Zero())
+			}
+			m, ok := p.Apply(weakOffset).WeakFields().get(num)
+			if !ok {
+				return pref.ValueOfMessage(messageType.Zero())
+			}
+			return pref.ValueOfMessage(m.ProtoReflect())
+		},
+		set: func(p pointer, v pref.Value) {
+			lazyInit()
+			m := v.Message()
+			if m.Descriptor() != messageType.Descriptor() {
+				if got, want := m.Descriptor().FullName(), messageType.Descriptor().FullName(); got != want {
+					panic(fmt.Sprintf("field %v has mismatching message descriptor: got %v, want %v", fd.FullName(), got, want))
+				}
+				panic(fmt.Sprintf("field %v has mismatching message descriptor: %v", fd.FullName(), m.Descriptor().FullName()))
+			}
+			p.Apply(weakOffset).WeakFields().set(num, m.Interface())
+		},
+		mutable: func(p pointer) pref.Value {
+			lazyInit()
+			fs := p.Apply(weakOffset).WeakFields()
+			m, ok := fs.get(num)
+			if !ok {
+				m = messageType.New().Interface()
+				fs.set(num, m)
+			}
+			return pref.ValueOfMessage(m.ProtoReflect())
+		},
+		newMessage: func() pref.Message {
+			lazyInit()
+			return messageType.New()
+		},
+		newField: func() pref.Value {
+			lazyInit()
+			return pref.ValueOfMessage(messageType.New())
+		},
+	}
+}
+
+func fieldInfoForMessage(fd pref.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo {
+	ft := fs.Type
+	conv := NewConverter(ft, fd)
+
+	// TODO: Implement unsafe fast path?
+	fieldOffset := offsetOf(fs, x)
+	return fieldInfo{
+		fieldDesc: fd,
+		has: func(p pointer) bool {
+			if p.IsNil() {
+				return false
+			}
+			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
+			return !rv.IsNil()
+		},
+		clear: func(p pointer) {
+			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
+			rv.Set(reflect.Zero(rv.Type()))
+		},
+		get: func(p pointer) pref.Value {
+			if p.IsNil() {
+				return conv.Zero()
+			}
+			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
+			return conv.PBValueOf(rv)
+		},
+		set: func(p pointer, v pref.Value) {
+			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
+			rv.Set(conv.GoValueOf(v))
+			if rv.IsNil() {
+				panic(fmt.Sprintf("field %v has invalid nil pointer", fd.FullName()))
+			}
+		},
+		mutable: func(p pointer) pref.Value {
+			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
+			if rv.IsNil() {
+				rv.Set(conv.GoValueOf(conv.New()))
+			}
+			return conv.PBValueOf(rv)
+		},
+		newMessage: func() pref.Message {
+			return conv.New().Message()
+		},
+		newField: func() pref.Value {
+			return conv.New()
+		},
+	}
+}
+
+type oneofInfo struct {
+	oneofDesc pref.OneofDescriptor
+	which     func(pointer) pref.FieldNumber
+}
+
+func makeOneofInfo(od pref.OneofDescriptor, si structInfo, x exporter) *oneofInfo {
+	oi := &oneofInfo{oneofDesc: od}
+	if od.IsSynthetic() {
+		fs := si.fieldsByNumber[od.Fields().Get(0).Number()]
+		fieldOffset := offsetOf(fs, x)
+		oi.which = func(p pointer) pref.FieldNumber {
+			if p.IsNil() {
+				return 0
+			}
+			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
+			if rv.IsNil() { // valid on either *T or []byte
+				return 0
+			}
+			return od.Fields().Get(0).Number()
+		}
+	} else {
+		fs := si.oneofsByName[od.Name()]
+		fieldOffset := offsetOf(fs, x)
+		oi.which = func(p pointer) pref.FieldNumber {
+			if p.IsNil() {
+				return 0
+			}
+			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
+			if rv.IsNil() {
+				return 0
+			}
+			rv = rv.Elem()
+			if rv.IsNil() {
+				return 0
+			}
+			return si.oneofWrappersByType[rv.Type().Elem()]
+		}
+	}
+	return oi
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/message_reflect_gen.go b/vendor/google.golang.org/protobuf/internal/impl/message_reflect_gen.go
new file mode 100644
index 000000000..741d6e5b6
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/message_reflect_gen.go
@@ -0,0 +1,249 @@
+// 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.
+
+// Code generated by generate-types. DO NOT EDIT.
+
+package impl
+
+import (
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/runtime/protoiface"
+)
+
+func (m *messageState) Descriptor() protoreflect.MessageDescriptor {
+	return m.messageInfo().Desc
+}
+func (m *messageState) Type() protoreflect.MessageType {
+	return m.messageInfo()
+}
+func (m *messageState) New() protoreflect.Message {
+	return m.messageInfo().New()
+}
+func (m *messageState) Interface() protoreflect.ProtoMessage {
+	return m.protoUnwrap().(protoreflect.ProtoMessage)
+}
+func (m *messageState) protoUnwrap() interface{} {
+	return m.pointer().AsIfaceOf(m.messageInfo().GoReflectType.Elem())
+}
+func (m *messageState) ProtoMethods() *protoiface.Methods {
+	m.messageInfo().init()
+	return &m.messageInfo().methods
+}
+
+// ProtoMessageInfo is a pseudo-internal API for allowing the v1 code
+// to be able to retrieve a v2 MessageInfo struct.
+//
+// WARNING: This method is exempt from the compatibility promise and
+// may be removed in the future without warning.
+func (m *messageState) ProtoMessageInfo() *MessageInfo {
+	return m.messageInfo()
+}
+
+func (m *messageState) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	m.messageInfo().init()
+	for _, ri := range m.messageInfo().rangeInfos {
+		switch ri := ri.(type) {
+		case *fieldInfo:
+			if ri.has(m.pointer()) {
+				if !f(ri.fieldDesc, ri.get(m.pointer())) {
+					return
+				}
+			}
+		case *oneofInfo:
+			if n := ri.which(m.pointer()); n > 0 {
+				fi := m.messageInfo().fields[n]
+				if !f(fi.fieldDesc, fi.get(m.pointer())) {
+					return
+				}
+			}
+		}
+	}
+	m.messageInfo().extensionMap(m.pointer()).Range(f)
+}
+func (m *messageState) Has(fd protoreflect.FieldDescriptor) bool {
+	m.messageInfo().init()
+	if fi, xt := m.messageInfo().checkField(fd); fi != nil {
+		return fi.has(m.pointer())
+	} else {
+		return m.messageInfo().extensionMap(m.pointer()).Has(xt)
+	}
+}
+func (m *messageState) Clear(fd protoreflect.FieldDescriptor) {
+	m.messageInfo().init()
+	if fi, xt := m.messageInfo().checkField(fd); fi != nil {
+		fi.clear(m.pointer())
+	} else {
+		m.messageInfo().extensionMap(m.pointer()).Clear(xt)
+	}
+}
+func (m *messageState) Get(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	m.messageInfo().init()
+	if fi, xt := m.messageInfo().checkField(fd); fi != nil {
+		return fi.get(m.pointer())
+	} else {
+		return m.messageInfo().extensionMap(m.pointer()).Get(xt)
+	}
+}
+func (m *messageState) Set(fd protoreflect.FieldDescriptor, v protoreflect.Value) {
+	m.messageInfo().init()
+	if fi, xt := m.messageInfo().checkField(fd); fi != nil {
+		fi.set(m.pointer(), v)
+	} else {
+		m.messageInfo().extensionMap(m.pointer()).Set(xt, v)
+	}
+}
+func (m *messageState) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	m.messageInfo().init()
+	if fi, xt := m.messageInfo().checkField(fd); fi != nil {
+		return fi.mutable(m.pointer())
+	} else {
+		return m.messageInfo().extensionMap(m.pointer()).Mutable(xt)
+	}
+}
+func (m *messageState) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	m.messageInfo().init()
+	if fi, xt := m.messageInfo().checkField(fd); fi != nil {
+		return fi.newField()
+	} else {
+		return xt.New()
+	}
+}
+func (m *messageState) WhichOneof(od protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	m.messageInfo().init()
+	if oi := m.messageInfo().oneofs[od.Name()]; oi != nil && oi.oneofDesc == od {
+		return od.Fields().ByNumber(oi.which(m.pointer()))
+	}
+	panic("invalid oneof descriptor " + string(od.FullName()) + " for message " + string(m.Descriptor().FullName()))
+}
+func (m *messageState) GetUnknown() protoreflect.RawFields {
+	m.messageInfo().init()
+	return m.messageInfo().getUnknown(m.pointer())
+}
+func (m *messageState) SetUnknown(b protoreflect.RawFields) {
+	m.messageInfo().init()
+	m.messageInfo().setUnknown(m.pointer(), b)
+}
+func (m *messageState) IsValid() bool {
+	return !m.pointer().IsNil()
+}
+
+func (m *messageReflectWrapper) Descriptor() protoreflect.MessageDescriptor {
+	return m.messageInfo().Desc
+}
+func (m *messageReflectWrapper) Type() protoreflect.MessageType {
+	return m.messageInfo()
+}
+func (m *messageReflectWrapper) New() protoreflect.Message {
+	return m.messageInfo().New()
+}
+func (m *messageReflectWrapper) Interface() protoreflect.ProtoMessage {
+	if m, ok := m.protoUnwrap().(protoreflect.ProtoMessage); ok {
+		return m
+	}
+	return (*messageIfaceWrapper)(m)
+}
+func (m *messageReflectWrapper) protoUnwrap() interface{} {
+	return m.pointer().AsIfaceOf(m.messageInfo().GoReflectType.Elem())
+}
+func (m *messageReflectWrapper) ProtoMethods() *protoiface.Methods {
+	m.messageInfo().init()
+	return &m.messageInfo().methods
+}
+
+// ProtoMessageInfo is a pseudo-internal API for allowing the v1 code
+// to be able to retrieve a v2 MessageInfo struct.
+//
+// WARNING: This method is exempt from the compatibility promise and
+// may be removed in the future without warning.
+func (m *messageReflectWrapper) ProtoMessageInfo() *MessageInfo {
+	return m.messageInfo()
+}
+
+func (m *messageReflectWrapper) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	m.messageInfo().init()
+	for _, ri := range m.messageInfo().rangeInfos {
+		switch ri := ri.(type) {
+		case *fieldInfo:
+			if ri.has(m.pointer()) {
+				if !f(ri.fieldDesc, ri.get(m.pointer())) {
+					return
+				}
+			}
+		case *oneofInfo:
+			if n := ri.which(m.pointer()); n > 0 {
+				fi := m.messageInfo().fields[n]
+				if !f(fi.fieldDesc, fi.get(m.pointer())) {
+					return
+				}
+			}
+		}
+	}
+	m.messageInfo().extensionMap(m.pointer()).Range(f)
+}
+func (m *messageReflectWrapper) Has(fd protoreflect.FieldDescriptor) bool {
+	m.messageInfo().init()
+	if fi, xt := m.messageInfo().checkField(fd); fi != nil {
+		return fi.has(m.pointer())
+	} else {
+		return m.messageInfo().extensionMap(m.pointer()).Has(xt)
+	}
+}
+func (m *messageReflectWrapper) Clear(fd protoreflect.FieldDescriptor) {
+	m.messageInfo().init()
+	if fi, xt := m.messageInfo().checkField(fd); fi != nil {
+		fi.clear(m.pointer())
+	} else {
+		m.messageInfo().extensionMap(m.pointer()).Clear(xt)
+	}
+}
+func (m *messageReflectWrapper) Get(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	m.messageInfo().init()
+	if fi, xt := m.messageInfo().checkField(fd); fi != nil {
+		return fi.get(m.pointer())
+	} else {
+		return m.messageInfo().extensionMap(m.pointer()).Get(xt)
+	}
+}
+func (m *messageReflectWrapper) Set(fd protoreflect.FieldDescriptor, v protoreflect.Value) {
+	m.messageInfo().init()
+	if fi, xt := m.messageInfo().checkField(fd); fi != nil {
+		fi.set(m.pointer(), v)
+	} else {
+		m.messageInfo().extensionMap(m.pointer()).Set(xt, v)
+	}
+}
+func (m *messageReflectWrapper) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	m.messageInfo().init()
+	if fi, xt := m.messageInfo().checkField(fd); fi != nil {
+		return fi.mutable(m.pointer())
+	} else {
+		return m.messageInfo().extensionMap(m.pointer()).Mutable(xt)
+	}
+}
+func (m *messageReflectWrapper) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	m.messageInfo().init()
+	if fi, xt := m.messageInfo().checkField(fd); fi != nil {
+		return fi.newField()
+	} else {
+		return xt.New()
+	}
+}
+func (m *messageReflectWrapper) WhichOneof(od protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	m.messageInfo().init()
+	if oi := m.messageInfo().oneofs[od.Name()]; oi != nil && oi.oneofDesc == od {
+		return od.Fields().ByNumber(oi.which(m.pointer()))
+	}
+	panic("invalid oneof descriptor " + string(od.FullName()) + " for message " + string(m.Descriptor().FullName()))
+}
+func (m *messageReflectWrapper) GetUnknown() protoreflect.RawFields {
+	m.messageInfo().init()
+	return m.messageInfo().getUnknown(m.pointer())
+}
+func (m *messageReflectWrapper) SetUnknown(b protoreflect.RawFields) {
+	m.messageInfo().init()
+	m.messageInfo().setUnknown(m.pointer(), b)
+}
+func (m *messageReflectWrapper) IsValid() bool {
+	return !m.pointer().IsNil()
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/message_reflect_test.go b/vendor/google.golang.org/protobuf/internal/impl/message_reflect_test.go
new file mode 100644
index 000000000..66c25361f
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/message_reflect_test.go
@@ -0,0 +1,1568 @@
+// 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_test
+
+import (
+	"fmt"
+	"math"
+	"reflect"
+	"runtime"
+	"strings"
+	"sync"
+	"testing"
+
+	cmp "github.com/google/go-cmp/cmp"
+	cmpopts "github.com/google/go-cmp/cmp/cmpopts"
+
+	"google.golang.org/protobuf/encoding/prototext"
+	pimpl "google.golang.org/protobuf/internal/impl"
+	"google.golang.org/protobuf/proto"
+	pdesc "google.golang.org/protobuf/reflect/protodesc"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/reflect/protoregistry"
+
+	proto2_20180125 "google.golang.org/protobuf/internal/testprotos/legacy/proto2_20180125_92554152"
+	testpb "google.golang.org/protobuf/internal/testprotos/test"
+	"google.golang.org/protobuf/types/descriptorpb"
+)
+
+// List of test operations to perform on messages, lists, or maps.
+type (
+	messageOp  interface{ isMessageOp() }
+	messageOps []messageOp
+
+	listOp  interface{ isListOp() }
+	listOps []listOp
+
+	mapOp  interface{ isMapOp() }
+	mapOps []mapOp
+)
+
+// Test operations performed on a message.
+type (
+	// check that the message contents match
+	equalMessage struct{ pref.Message }
+	// check presence for specific fields in the message
+	hasFields map[pref.FieldNumber]bool
+	// check that specific message fields match
+	getFields map[pref.FieldNumber]pref.Value
+	// set specific message fields
+	setFields map[pref.FieldNumber]pref.Value
+	// clear specific fields in the message
+	clearFields []pref.FieldNumber
+	// check for the presence of specific oneof member fields.
+	whichOneofs map[pref.Name]pref.FieldNumber
+	// apply messageOps on each specified message field
+	messageFields        map[pref.FieldNumber]messageOps
+	messageFieldsMutable map[pref.FieldNumber]messageOps
+	// apply listOps on each specified list field
+	listFields        map[pref.FieldNumber]listOps
+	listFieldsMutable map[pref.FieldNumber]listOps
+	// apply mapOps on each specified map fields
+	mapFields        map[pref.FieldNumber]mapOps
+	mapFieldsMutable map[pref.FieldNumber]mapOps
+	// range through all fields and check that they match
+	rangeFields map[pref.FieldNumber]pref.Value
+)
+
+func (equalMessage) isMessageOp()         {}
+func (hasFields) isMessageOp()            {}
+func (getFields) isMessageOp()            {}
+func (setFields) isMessageOp()            {}
+func (clearFields) isMessageOp()          {}
+func (whichOneofs) isMessageOp()          {}
+func (messageFields) isMessageOp()        {}
+func (messageFieldsMutable) isMessageOp() {}
+func (listFields) isMessageOp()           {}
+func (listFieldsMutable) isMessageOp()    {}
+func (mapFields) isMessageOp()            {}
+func (mapFieldsMutable) isMessageOp()     {}
+func (rangeFields) isMessageOp()          {}
+
+// Test operations performed on a list.
+type (
+	// check that the list contents match
+	equalList struct{ pref.List }
+	// check that list length matches
+	lenList int
+	// check that specific list entries match
+	getList map[int]pref.Value
+	// set specific list entries
+	setList map[int]pref.Value
+	// append entries to the list
+	appendList []pref.Value
+	// apply messageOps on a newly appended message
+	appendMessageList messageOps
+	// truncate the list to the specified length
+	truncList int
+)
+
+func (equalList) isListOp()         {}
+func (lenList) isListOp()           {}
+func (getList) isListOp()           {}
+func (setList) isListOp()           {}
+func (appendList) isListOp()        {}
+func (appendMessageList) isListOp() {}
+func (truncList) isListOp()         {}
+
+// Test operations performed on a map.
+type (
+	// check that the map contents match
+	equalMap struct{ pref.Map }
+	// check that map length matches
+	lenMap int
+	// check presence for specific entries in the map
+	hasMap map[interface{}]bool
+	// check that specific map entries match
+	getMap map[interface{}]pref.Value
+	// set specific map entries
+	setMap map[interface{}]pref.Value
+	// clear specific entries in the map
+	clearMap []interface{}
+	// apply messageOps on each specified message entry
+	messageMap map[interface{}]messageOps
+	// range through all entries and check that they match
+	rangeMap map[interface{}]pref.Value
+)
+
+func (equalMap) isMapOp()   {}
+func (lenMap) isMapOp()     {}
+func (hasMap) isMapOp()     {}
+func (getMap) isMapOp()     {}
+func (setMap) isMapOp()     {}
+func (clearMap) isMapOp()   {}
+func (messageMap) isMapOp() {}
+func (rangeMap) isMapOp()   {}
+
+type ScalarProto2 struct {
+	Bool    *bool    `protobuf:"1"`
+	Int32   *int32   `protobuf:"2"`
+	Int64   *int64   `protobuf:"3"`
+	Uint32  *uint32  `protobuf:"4"`
+	Uint64  *uint64  `protobuf:"5"`
+	Float32 *float32 `protobuf:"6"`
+	Float64 *float64 `protobuf:"7"`
+	String  *string  `protobuf:"8"`
+	StringA []byte   `protobuf:"9"`
+	Bytes   []byte   `protobuf:"10"`
+	BytesA  *string  `protobuf:"11"`
+
+	MyBool    *MyBool    `protobuf:"12"`
+	MyInt32   *MyInt32   `protobuf:"13"`
+	MyInt64   *MyInt64   `protobuf:"14"`
+	MyUint32  *MyUint32  `protobuf:"15"`
+	MyUint64  *MyUint64  `protobuf:"16"`
+	MyFloat32 *MyFloat32 `protobuf:"17"`
+	MyFloat64 *MyFloat64 `protobuf:"18"`
+	MyString  *MyString  `protobuf:"19"`
+	MyStringA MyBytes    `protobuf:"20"`
+	MyBytes   MyBytes    `protobuf:"21"`
+	MyBytesA  *MyString  `protobuf:"22"`
+}
+
+func mustMakeEnumDesc(path string, syntax pref.Syntax, enumDesc string) pref.EnumDescriptor {
+	s := fmt.Sprintf(`name:%q syntax:%q enum_type:[{%s}]`, path, syntax, enumDesc)
+	pb := new(descriptorpb.FileDescriptorProto)
+	if err := prototext.Unmarshal([]byte(s), pb); err != nil {
+		panic(err)
+	}
+	fd, err := pdesc.NewFile(pb, nil)
+	if err != nil {
+		panic(err)
+	}
+	return fd.Enums().Get(0)
+}
+
+func mustMakeMessageDesc(path string, syntax pref.Syntax, fileDesc, msgDesc string, r pdesc.Resolver) pref.MessageDescriptor {
+	s := fmt.Sprintf(`name:%q syntax:%q %s message_type:[{%s}]`, path, syntax, fileDesc, msgDesc)
+	pb := new(descriptorpb.FileDescriptorProto)
+	if err := prototext.Unmarshal([]byte(s), pb); err != nil {
+		panic(err)
+	}
+	fd, err := pdesc.NewFile(pb, r)
+	if err != nil {
+		panic(err)
+	}
+	return fd.Messages().Get(0)
+}
+
+var V = pref.ValueOf
+var VE = func(n pref.EnumNumber) pref.Value { return V(n) }
+
+type (
+	MyBool    bool
+	MyInt32   int32
+	MyInt64   int64
+	MyUint32  uint32
+	MyUint64  uint64
+	MyFloat32 float32
+	MyFloat64 float64
+	MyString  string
+	MyBytes   []byte
+
+	ListStrings []MyString
+	ListBytes   []MyBytes
+
+	MapStrings map[MyString]MyString
+	MapBytes   map[MyString]MyBytes
+)
+
+var scalarProto2Type = pimpl.MessageInfo{GoReflectType: reflect.TypeOf(new(ScalarProto2)), Desc: mustMakeMessageDesc("scalar2.proto", pref.Proto2, "", `
+		name: "ScalarProto2"
+		field: [
+			{name:"f1"  number:1  label:LABEL_OPTIONAL type:TYPE_BOOL   default_value:"true"},
+			{name:"f2"  number:2  label:LABEL_OPTIONAL type:TYPE_INT32  default_value:"2"},
+			{name:"f3"  number:3  label:LABEL_OPTIONAL type:TYPE_INT64  default_value:"3"},
+			{name:"f4"  number:4  label:LABEL_OPTIONAL type:TYPE_UINT32 default_value:"4"},
+			{name:"f5"  number:5  label:LABEL_OPTIONAL type:TYPE_UINT64 default_value:"5"},
+			{name:"f6"  number:6  label:LABEL_OPTIONAL type:TYPE_FLOAT  default_value:"6"},
+			{name:"f7"  number:7  label:LABEL_OPTIONAL type:TYPE_DOUBLE default_value:"7"},
+			{name:"f8"  number:8  label:LABEL_OPTIONAL type:TYPE_STRING default_value:"8"},
+			{name:"f9"  number:9  label:LABEL_OPTIONAL type:TYPE_STRING default_value:"9"},
+			{name:"f10" number:10 label:LABEL_OPTIONAL type:TYPE_BYTES  default_value:"10"},
+			{name:"f11" number:11 label:LABEL_OPTIONAL type:TYPE_BYTES  default_value:"11"},
+
+			{name:"f12" number:12 label:LABEL_OPTIONAL type:TYPE_BOOL   default_value:"true"},
+			{name:"f13" number:13 label:LABEL_OPTIONAL type:TYPE_INT32  default_value:"13"},
+			{name:"f14" number:14 label:LABEL_OPTIONAL type:TYPE_INT64  default_value:"14"},
+			{name:"f15" number:15 label:LABEL_OPTIONAL type:TYPE_UINT32 default_value:"15"},
+			{name:"f16" number:16 label:LABEL_OPTIONAL type:TYPE_UINT64 default_value:"16"},
+			{name:"f17" number:17 label:LABEL_OPTIONAL type:TYPE_FLOAT  default_value:"17"},
+			{name:"f18" number:18 label:LABEL_OPTIONAL type:TYPE_DOUBLE default_value:"18"},
+			{name:"f19" number:19 label:LABEL_OPTIONAL type:TYPE_STRING default_value:"19"},
+			{name:"f20" number:20 label:LABEL_OPTIONAL type:TYPE_STRING default_value:"20"},
+			{name:"f21" number:21 label:LABEL_OPTIONAL type:TYPE_BYTES  default_value:"21"},
+			{name:"f22" number:22 label:LABEL_OPTIONAL type:TYPE_BYTES  default_value:"22"}
+		]
+	`, nil),
+}
+
+func (m *ScalarProto2) ProtoReflect() pref.Message { return scalarProto2Type.MessageOf(m) }
+
+func TestScalarProto2(t *testing.T) {
+	testMessage(t, nil, new(ScalarProto2).ProtoReflect(), messageOps{
+		hasFields{
+			1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false,
+			12: false, 13: false, 14: false, 15: false, 16: false, 17: false, 18: false, 19: false, 20: false, 21: false, 22: false,
+		},
+		getFields{
+			1: V(bool(true)), 2: V(int32(2)), 3: V(int64(3)), 4: V(uint32(4)), 5: V(uint64(5)), 6: V(float32(6)), 7: V(float64(7)), 8: V(string("8")), 9: V(string("9")), 10: V([]byte("10")), 11: V([]byte("11")),
+			12: V(bool(true)), 13: V(int32(13)), 14: V(int64(14)), 15: V(uint32(15)), 16: V(uint64(16)), 17: V(float32(17)), 18: V(float64(18)), 19: V(string("19")), 20: V(string("20")), 21: V([]byte("21")), 22: V([]byte("22")),
+		},
+		setFields{
+			1: V(bool(false)), 2: V(int32(0)), 3: V(int64(0)), 4: V(uint32(0)), 5: V(uint64(0)), 6: V(float32(0)), 7: V(float64(0)), 8: V(string("")), 9: V(string("")), 10: V([]byte(nil)), 11: V([]byte(nil)),
+			12: V(bool(false)), 13: V(int32(0)), 14: V(int64(0)), 15: V(uint32(0)), 16: V(uint64(0)), 17: V(float32(0)), 18: V(float64(0)), 19: V(string("")), 20: V(string("")), 21: V([]byte(nil)), 22: V([]byte(nil)),
+		},
+		hasFields{
+			1: true, 2: true, 3: true, 4: true, 5: true, 6: true, 7: true, 8: true, 9: true, 10: true, 11: true,
+			12: true, 13: true, 14: true, 15: true, 16: true, 17: true, 18: true, 19: true, 20: true, 21: true, 22: true,
+		},
+		equalMessage{(&ScalarProto2{
+			new(bool), new(int32), new(int64), new(uint32), new(uint64), new(float32), new(float64), new(string), []byte{}, []byte{}, new(string),
+			new(MyBool), new(MyInt32), new(MyInt64), new(MyUint32), new(MyUint64), new(MyFloat32), new(MyFloat64), new(MyString), MyBytes{}, MyBytes{}, new(MyString),
+		}).ProtoReflect()},
+		clearFields{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22},
+		equalMessage{new(ScalarProto2).ProtoReflect()},
+
+		// Setting a bytes field nil empty bytes should preserve presence.
+		setFields{10: V([]byte(nil)), 11: V([]byte(nil)), 21: V([]byte(nil)), 22: V([]byte(nil))},
+		getFields{10: V([]byte{}), 11: V([]byte(nil)), 21: V([]byte{}), 22: V([]byte(nil))},
+		hasFields{10: true, 11: true, 21: true, 22: true},
+	})
+
+	// Test read-only operations on nil message.
+	testMessage(t, nil, (*ScalarProto2)(nil).ProtoReflect(), messageOps{
+		hasFields{
+			1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false,
+			12: false, 13: false, 14: false, 15: false, 16: false, 17: false, 18: false, 19: false, 20: false, 21: false, 22: false,
+		},
+		getFields{
+			1: V(bool(true)), 2: V(int32(2)), 3: V(int64(3)), 4: V(uint32(4)), 5: V(uint64(5)), 6: V(float32(6)), 7: V(float64(7)), 8: V(string("8")), 9: V(string("9")), 10: V([]byte("10")), 11: V([]byte("11")),
+			12: V(bool(true)), 13: V(int32(13)), 14: V(int64(14)), 15: V(uint32(15)), 16: V(uint64(16)), 17: V(float32(17)), 18: V(float64(18)), 19: V(string("19")), 20: V(string("20")), 21: V([]byte("21")), 22: V([]byte("22")),
+		},
+	})
+}
+
+type ScalarProto3 struct {
+	Bool    bool    `protobuf:"1"`
+	Int32   int32   `protobuf:"2"`
+	Int64   int64   `protobuf:"3"`
+	Uint32  uint32  `protobuf:"4"`
+	Uint64  uint64  `protobuf:"5"`
+	Float32 float32 `protobuf:"6"`
+	Float64 float64 `protobuf:"7"`
+	String  string  `protobuf:"8"`
+	StringA []byte  `protobuf:"9"`
+	Bytes   []byte  `protobuf:"10"`
+	BytesA  string  `protobuf:"11"`
+
+	MyBool    MyBool    `protobuf:"12"`
+	MyInt32   MyInt32   `protobuf:"13"`
+	MyInt64   MyInt64   `protobuf:"14"`
+	MyUint32  MyUint32  `protobuf:"15"`
+	MyUint64  MyUint64  `protobuf:"16"`
+	MyFloat32 MyFloat32 `protobuf:"17"`
+	MyFloat64 MyFloat64 `protobuf:"18"`
+	MyString  MyString  `protobuf:"19"`
+	MyStringA MyBytes   `protobuf:"20"`
+	MyBytes   MyBytes   `protobuf:"21"`
+	MyBytesA  MyString  `protobuf:"22"`
+}
+
+var scalarProto3Type = pimpl.MessageInfo{GoReflectType: reflect.TypeOf(new(ScalarProto3)), Desc: mustMakeMessageDesc("scalar3.proto", pref.Proto3, "", `
+		name: "ScalarProto3"
+		field: [
+			{name:"f1"  number:1  label:LABEL_OPTIONAL type:TYPE_BOOL},
+			{name:"f2"  number:2  label:LABEL_OPTIONAL type:TYPE_INT32},
+			{name:"f3"  number:3  label:LABEL_OPTIONAL type:TYPE_INT64},
+			{name:"f4"  number:4  label:LABEL_OPTIONAL type:TYPE_UINT32},
+			{name:"f5"  number:5  label:LABEL_OPTIONAL type:TYPE_UINT64},
+			{name:"f6"  number:6  label:LABEL_OPTIONAL type:TYPE_FLOAT},
+			{name:"f7"  number:7  label:LABEL_OPTIONAL type:TYPE_DOUBLE},
+			{name:"f8"  number:8  label:LABEL_OPTIONAL type:TYPE_STRING},
+			{name:"f9"  number:9  label:LABEL_OPTIONAL type:TYPE_STRING},
+			{name:"f10" number:10 label:LABEL_OPTIONAL type:TYPE_BYTES},
+			{name:"f11" number:11 label:LABEL_OPTIONAL type:TYPE_BYTES},
+
+			{name:"f12" number:12 label:LABEL_OPTIONAL type:TYPE_BOOL},
+			{name:"f13" number:13 label:LABEL_OPTIONAL type:TYPE_INT32},
+			{name:"f14" number:14 label:LABEL_OPTIONAL type:TYPE_INT64},
+			{name:"f15" number:15 label:LABEL_OPTIONAL type:TYPE_UINT32},
+			{name:"f16" number:16 label:LABEL_OPTIONAL type:TYPE_UINT64},
+			{name:"f17" number:17 label:LABEL_OPTIONAL type:TYPE_FLOAT},
+			{name:"f18" number:18 label:LABEL_OPTIONAL type:TYPE_DOUBLE},
+			{name:"f19" number:19 label:LABEL_OPTIONAL type:TYPE_STRING},
+			{name:"f20" number:20 label:LABEL_OPTIONAL type:TYPE_STRING},
+			{name:"f21" number:21 label:LABEL_OPTIONAL type:TYPE_BYTES},
+			{name:"f22" number:22 label:LABEL_OPTIONAL type:TYPE_BYTES}
+		]
+	`, nil),
+}
+
+func (m *ScalarProto3) ProtoReflect() pref.Message { return scalarProto3Type.MessageOf(m) }
+
+func TestScalarProto3(t *testing.T) {
+	testMessage(t, nil, new(ScalarProto3).ProtoReflect(), messageOps{
+		hasFields{
+			1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false,
+			12: false, 13: false, 14: false, 15: false, 16: false, 17: false, 18: false, 19: false, 20: false, 21: false, 22: false,
+		},
+		getFields{
+			1: V(bool(false)), 2: V(int32(0)), 3: V(int64(0)), 4: V(uint32(0)), 5: V(uint64(0)), 6: V(float32(0)), 7: V(float64(0)), 8: V(string("")), 9: V(string("")), 10: V([]byte(nil)), 11: V([]byte(nil)),
+			12: V(bool(false)), 13: V(int32(0)), 14: V(int64(0)), 15: V(uint32(0)), 16: V(uint64(0)), 17: V(float32(0)), 18: V(float64(0)), 19: V(string("")), 20: V(string("")), 21: V([]byte(nil)), 22: V([]byte(nil)),
+		},
+		setFields{
+			1: V(bool(false)), 2: V(int32(0)), 3: V(int64(0)), 4: V(uint32(0)), 5: V(uint64(0)), 6: V(float32(0)), 7: V(float64(0)), 8: V(string("")), 9: V(string("")), 10: V([]byte(nil)), 11: V([]byte(nil)),
+			12: V(bool(false)), 13: V(int32(0)), 14: V(int64(0)), 15: V(uint32(0)), 16: V(uint64(0)), 17: V(float32(0)), 18: V(float64(0)), 19: V(string("")), 20: V(string("")), 21: V([]byte(nil)), 22: V([]byte(nil)),
+		},
+		hasFields{
+			1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false,
+			12: false, 13: false, 14: false, 15: false, 16: false, 17: false, 18: false, 19: false, 20: false, 21: false, 22: false,
+		},
+		equalMessage{new(ScalarProto3).ProtoReflect()},
+		setFields{
+			1: V(bool(true)), 2: V(int32(2)), 3: V(int64(3)), 4: V(uint32(4)), 5: V(uint64(5)), 6: V(float32(6)), 7: V(float64(7)), 8: V(string("8")), 9: V(string("9")), 10: V([]byte("10")), 11: V([]byte("11")),
+			12: V(bool(true)), 13: V(int32(13)), 14: V(int64(14)), 15: V(uint32(15)), 16: V(uint64(16)), 17: V(float32(17)), 18: V(float64(18)), 19: V(string("19")), 20: V(string("20")), 21: V([]byte("21")), 22: V([]byte("22")),
+		},
+		hasFields{
+			1: true, 2: true, 3: true, 4: true, 5: true, 6: true, 7: true, 8: true, 9: true, 10: true, 11: true,
+			12: true, 13: true, 14: true, 15: true, 16: true, 17: true, 18: true, 19: true, 20: true, 21: true, 22: true,
+		},
+		equalMessage{(&ScalarProto3{
+			true, 2, 3, 4, 5, 6, 7, "8", []byte("9"), []byte("10"), "11",
+			true, 13, 14, 15, 16, 17, 18, "19", []byte("20"), []byte("21"), "22",
+		}).ProtoReflect()},
+		setFields{
+			2: V(int32(-2)), 3: V(int64(-3)), 6: V(float32(math.Inf(-1))), 7: V(float64(math.NaN())),
+		},
+		hasFields{
+			2: true, 3: true, 6: true, 7: true,
+		},
+		clearFields{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22},
+		equalMessage{new(ScalarProto3).ProtoReflect()},
+
+		// Verify that -0 triggers proper Has behavior.
+		hasFields{6: false, 7: false},
+		setFields{6: V(float32(math.Copysign(0, -1))), 7: V(float64(math.Copysign(0, -1)))},
+		hasFields{6: true, 7: true},
+
+		// Setting a bytes field to non-nil empty bytes should not preserve presence.
+		setFields{10: V([]byte{}), 11: V([]byte{}), 21: V([]byte{}), 22: V([]byte{})},
+		getFields{10: V([]byte(nil)), 11: V([]byte(nil)), 21: V([]byte(nil)), 22: V([]byte(nil))},
+		hasFields{10: false, 11: false, 21: false, 22: false},
+	})
+
+	// Test read-only operations on nil message.
+	testMessage(t, nil, (*ScalarProto3)(nil).ProtoReflect(), messageOps{
+		hasFields{
+			1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false,
+			12: false, 13: false, 14: false, 15: false, 16: false, 17: false, 18: false, 19: false, 20: false, 21: false, 22: false,
+		},
+		getFields{
+			1: V(bool(false)), 2: V(int32(0)), 3: V(int64(0)), 4: V(uint32(0)), 5: V(uint64(0)), 6: V(float32(0)), 7: V(float64(0)), 8: V(string("")), 9: V(string("")), 10: V([]byte(nil)), 11: V([]byte(nil)),
+			12: V(bool(false)), 13: V(int32(0)), 14: V(int64(0)), 15: V(uint32(0)), 16: V(uint64(0)), 17: V(float32(0)), 18: V(float64(0)), 19: V(string("")), 20: V(string("")), 21: V([]byte(nil)), 22: V([]byte(nil)),
+		},
+	})
+}
+
+type ListScalars struct {
+	Bools    []bool    `protobuf:"1"`
+	Int32s   []int32   `protobuf:"2"`
+	Int64s   []int64   `protobuf:"3"`
+	Uint32s  []uint32  `protobuf:"4"`
+	Uint64s  []uint64  `protobuf:"5"`
+	Float32s []float32 `protobuf:"6"`
+	Float64s []float64 `protobuf:"7"`
+	Strings  []string  `protobuf:"8"`
+	StringsA [][]byte  `protobuf:"9"`
+	Bytes    [][]byte  `protobuf:"10"`
+	BytesA   []string  `protobuf:"11"`
+
+	MyStrings1 []MyString `protobuf:"12"`
+	MyStrings2 []MyBytes  `protobuf:"13"`
+	MyBytes1   []MyBytes  `protobuf:"14"`
+	MyBytes2   []MyString `protobuf:"15"`
+
+	MyStrings3 ListStrings `protobuf:"16"`
+	MyStrings4 ListBytes   `protobuf:"17"`
+	MyBytes3   ListBytes   `protobuf:"18"`
+	MyBytes4   ListStrings `protobuf:"19"`
+}
+
+var listScalarsType = pimpl.MessageInfo{GoReflectType: reflect.TypeOf(new(ListScalars)), Desc: mustMakeMessageDesc("list-scalars.proto", pref.Proto2, "", `
+		name: "ListScalars"
+		field: [
+			{name:"f1"  number:1  label:LABEL_REPEATED type:TYPE_BOOL},
+			{name:"f2"  number:2  label:LABEL_REPEATED type:TYPE_INT32},
+			{name:"f3"  number:3  label:LABEL_REPEATED type:TYPE_INT64},
+			{name:"f4"  number:4  label:LABEL_REPEATED type:TYPE_UINT32},
+			{name:"f5"  number:5  label:LABEL_REPEATED type:TYPE_UINT64},
+			{name:"f6"  number:6  label:LABEL_REPEATED type:TYPE_FLOAT},
+			{name:"f7"  number:7  label:LABEL_REPEATED type:TYPE_DOUBLE},
+			{name:"f8"  number:8  label:LABEL_REPEATED type:TYPE_STRING},
+			{name:"f9"  number:9  label:LABEL_REPEATED type:TYPE_STRING},
+			{name:"f10" number:10 label:LABEL_REPEATED type:TYPE_BYTES},
+			{name:"f11" number:11 label:LABEL_REPEATED type:TYPE_BYTES},
+
+			{name:"f12" number:12 label:LABEL_REPEATED type:TYPE_STRING},
+			{name:"f13" number:13 label:LABEL_REPEATED type:TYPE_STRING},
+			{name:"f14" number:14 label:LABEL_REPEATED type:TYPE_BYTES},
+			{name:"f15" number:15 label:LABEL_REPEATED type:TYPE_BYTES},
+
+			{name:"f16" number:16 label:LABEL_REPEATED type:TYPE_STRING},
+			{name:"f17" number:17 label:LABEL_REPEATED type:TYPE_STRING},
+			{name:"f18" number:18 label:LABEL_REPEATED type:TYPE_BYTES},
+			{name:"f19" number:19 label:LABEL_REPEATED type:TYPE_BYTES}
+		]
+	`, nil),
+}
+
+func (m *ListScalars) ProtoReflect() pref.Message { return listScalarsType.MessageOf(m) }
+
+func TestListScalars(t *testing.T) {
+	empty := new(ListScalars).ProtoReflect()
+	want := (&ListScalars{
+		Bools:    []bool{true, false, true},
+		Int32s:   []int32{2, math.MinInt32, math.MaxInt32},
+		Int64s:   []int64{3, math.MinInt64, math.MaxInt64},
+		Uint32s:  []uint32{4, math.MaxUint32 / 2, math.MaxUint32},
+		Uint64s:  []uint64{5, math.MaxUint64 / 2, math.MaxUint64},
+		Float32s: []float32{6, math.SmallestNonzeroFloat32, float32(math.NaN()), math.MaxFloat32},
+		Float64s: []float64{7, math.SmallestNonzeroFloat64, float64(math.NaN()), math.MaxFloat64},
+		Strings:  []string{"8", "", "eight"},
+		StringsA: [][]byte{[]byte("9"), nil, []byte("nine")},
+		Bytes:    [][]byte{[]byte("10"), nil, []byte("ten")},
+		BytesA:   []string{"11", "", "eleven"},
+
+		MyStrings1: []MyString{"12", "", "twelve"},
+		MyStrings2: []MyBytes{[]byte("13"), nil, []byte("thirteen")},
+		MyBytes1:   []MyBytes{[]byte("14"), nil, []byte("fourteen")},
+		MyBytes2:   []MyString{"15", "", "fifteen"},
+
+		MyStrings3: ListStrings{"16", "", "sixteen"},
+		MyStrings4: ListBytes{[]byte("17"), nil, []byte("seventeen")},
+		MyBytes3:   ListBytes{[]byte("18"), nil, []byte("eighteen")},
+		MyBytes4:   ListStrings{"19", "", "nineteen"},
+	}).ProtoReflect()
+
+	testMessage(t, nil, new(ListScalars).ProtoReflect(), messageOps{
+		hasFields{1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false, 12: false, 13: false, 14: false, 15: false, 16: false, 17: false, 18: false, 19: false},
+		getFields{1: getField(empty, 1), 3: getField(empty, 3), 5: getField(empty, 5), 7: getField(empty, 7), 9: getField(empty, 9), 11: getField(empty, 11), 13: getField(empty, 13), 15: getField(empty, 15), 17: getField(empty, 17), 19: getField(empty, 19)},
+		setFields{1: getField(want, 1), 3: getField(want, 3), 5: getField(want, 5), 7: getField(want, 7), 9: getField(want, 9), 11: getField(want, 11), 13: getField(want, 13), 15: getField(want, 15), 17: getField(want, 17), 19: getField(want, 19)},
+		listFieldsMutable{
+			2: {
+				lenList(0),
+				appendList{V(int32(2)), V(int32(math.MinInt32)), V(int32(math.MaxInt32))},
+				getList{0: V(int32(2)), 1: V(int32(math.MinInt32)), 2: V(int32(math.MaxInt32))},
+				equalList{getField(want, 2).List()},
+			},
+			4: {
+				appendList{V(uint32(0)), V(uint32(0)), V(uint32(0))},
+				setList{0: V(uint32(4)), 1: V(uint32(math.MaxUint32 / 2)), 2: V(uint32(math.MaxUint32))},
+				lenList(3),
+			},
+			6: {
+				appendList{V(float32(6)), V(float32(math.SmallestNonzeroFloat32)), V(float32(math.NaN())), V(float32(math.MaxFloat32))},
+				equalList{getField(want, 6).List()},
+			},
+			8: {
+				appendList{V(""), V(""), V(""), V(""), V(""), V("")},
+				lenList(6),
+				setList{0: V("8"), 2: V("eight")},
+				truncList(3),
+				equalList{getField(want, 8).List()},
+			},
+			10: {
+				appendList{V([]byte(nil)), V([]byte(nil))},
+				setList{0: V([]byte("10"))},
+				appendList{V([]byte("wrong"))},
+				setList{2: V([]byte("ten"))},
+				equalList{getField(want, 10).List()},
+			},
+			12: {
+				appendList{V("12"), V("wrong"), V("twelve")},
+				setList{1: V("")},
+				equalList{getField(want, 12).List()},
+			},
+			14: {
+				appendList{V([]byte("14")), V([]byte(nil)), V([]byte("fourteen"))},
+				equalList{getField(want, 14).List()},
+			},
+			16: {
+				appendList{V("16"), V(""), V("sixteen"), V("extra")},
+				truncList(3),
+				equalList{getField(want, 16).List()},
+			},
+			18: {
+				appendList{V([]byte("18")), V([]byte(nil)), V([]byte("eighteen"))},
+				equalList{getField(want, 18).List()},
+			},
+		},
+		hasFields{1: true, 2: true, 3: true, 4: true, 5: true, 6: true, 7: true, 8: true, 9: true, 10: true, 11: true, 12: true, 13: true, 14: true, 15: true, 16: true, 17: true, 18: true, 19: true},
+		equalMessage{want},
+		clearFields{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19},
+		equalMessage{empty},
+	})
+
+	// Test read-only operations on nil message.
+	testMessage(t, nil, (*ListScalars)(nil).ProtoReflect(), messageOps{
+		hasFields{1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false, 12: false, 13: false, 14: false, 15: false, 16: false, 17: false, 18: false, 19: false},
+		listFields{2: {lenList(0)}, 4: {lenList(0)}, 6: {lenList(0)}, 8: {lenList(0)}, 10: {lenList(0)}, 12: {lenList(0)}, 14: {lenList(0)}, 16: {lenList(0)}, 18: {lenList(0)}},
+	})
+}
+
+type MapScalars struct {
+	KeyBools   map[bool]string   `protobuf:"1"`
+	KeyInt32s  map[int32]string  `protobuf:"2"`
+	KeyInt64s  map[int64]string  `protobuf:"3"`
+	KeyUint32s map[uint32]string `protobuf:"4"`
+	KeyUint64s map[uint64]string `protobuf:"5"`
+	KeyStrings map[string]string `protobuf:"6"`
+
+	ValBools    map[string]bool    `protobuf:"7"`
+	ValInt32s   map[string]int32   `protobuf:"8"`
+	ValInt64s   map[string]int64   `protobuf:"9"`
+	ValUint32s  map[string]uint32  `protobuf:"10"`
+	ValUint64s  map[string]uint64  `protobuf:"11"`
+	ValFloat32s map[string]float32 `protobuf:"12"`
+	ValFloat64s map[string]float64 `protobuf:"13"`
+	ValStrings  map[string]string  `protobuf:"14"`
+	ValStringsA map[string][]byte  `protobuf:"15"`
+	ValBytes    map[string][]byte  `protobuf:"16"`
+	ValBytesA   map[string]string  `protobuf:"17"`
+
+	MyStrings1 map[MyString]MyString `protobuf:"18"`
+	MyStrings2 map[MyString]MyBytes  `protobuf:"19"`
+	MyBytes1   map[MyString]MyBytes  `protobuf:"20"`
+	MyBytes2   map[MyString]MyString `protobuf:"21"`
+
+	MyStrings3 MapStrings `protobuf:"22"`
+	MyStrings4 MapBytes   `protobuf:"23"`
+	MyBytes3   MapBytes   `protobuf:"24"`
+	MyBytes4   MapStrings `protobuf:"25"`
+}
+
+var mapScalarsType = pimpl.MessageInfo{GoReflectType: reflect.TypeOf(new(MapScalars)), Desc: mustMakeMessageDesc("map-scalars.proto", pref.Proto2, "", `
+		name: "MapScalars"
+		field: [
+			{name:"f1"  number:1  label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F1Entry"},
+			{name:"f2"  number:2  label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F2Entry"},
+			{name:"f3"  number:3  label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F3Entry"},
+			{name:"f4"  number:4  label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F4Entry"},
+			{name:"f5"  number:5  label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F5Entry"},
+			{name:"f6"  number:6  label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F6Entry"},
+
+			{name:"f7"  number:7  label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F7Entry"},
+			{name:"f8"  number:8  label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F8Entry"},
+			{name:"f9"  number:9  label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F9Entry"},
+			{name:"f10" number:10 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F10Entry"},
+			{name:"f11" number:11 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F11Entry"},
+			{name:"f12" number:12 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F12Entry"},
+			{name:"f13" number:13 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F13Entry"},
+			{name:"f14" number:14 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F14Entry"},
+			{name:"f15" number:15 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F15Entry"},
+			{name:"f16" number:16 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F16Entry"},
+			{name:"f17" number:17 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F17Entry"},
+
+			{name:"f18" number:18 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F18Entry"},
+			{name:"f19" number:19 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F19Entry"},
+			{name:"f20" number:20 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F20Entry"},
+			{name:"f21" number:21 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F21Entry"},
+
+			{name:"f22" number:22 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F22Entry"},
+			{name:"f23" number:23 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F23Entry"},
+			{name:"f24" number:24 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F24Entry"},
+			{name:"f25" number:25 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F25Entry"}
+		]
+		nested_type: [
+			{name:"F1Entry"  field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_BOOL},   {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}},
+			{name:"F2Entry"  field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_INT32},  {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}},
+			{name:"F3Entry"  field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_INT64},  {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}},
+			{name:"F4Entry"  field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_UINT32}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}},
+			{name:"F5Entry"  field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_UINT64}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}},
+			{name:"F6Entry"  field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}},
+
+			{name:"F7Entry"  field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_BOOL}]   options:{map_entry:true}},
+			{name:"F8Entry"  field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_INT32}]  options:{map_entry:true}},
+			{name:"F9Entry"  field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_INT64}]  options:{map_entry:true}},
+			{name:"F10Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_UINT32}] options:{map_entry:true}},
+			{name:"F11Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_UINT64}] options:{map_entry:true}},
+			{name:"F12Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_FLOAT}]  options:{map_entry:true}},
+			{name:"F13Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_DOUBLE}] options:{map_entry:true}},
+			{name:"F14Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}},
+			{name:"F15Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}},
+			{name:"F16Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_BYTES}]  options:{map_entry:true}},
+			{name:"F17Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_BYTES}]  options:{map_entry:true}},
+
+			{name:"F18Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}},
+			{name:"F19Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}},
+			{name:"F20Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_BYTES}]  options:{map_entry:true}},
+			{name:"F21Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_BYTES}]  options:{map_entry:true}},
+
+			{name:"F22Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}},
+			{name:"F23Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}},
+			{name:"F24Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_BYTES}]  options:{map_entry:true}},
+			{name:"F25Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_BYTES}]  options:{map_entry:true}}
+		]
+	`, nil),
+}
+
+func (m *MapScalars) ProtoReflect() pref.Message { return mapScalarsType.MessageOf(m) }
+
+func TestMapScalars(t *testing.T) {
+	empty := new(MapScalars).ProtoReflect()
+	want := (&MapScalars{
+		KeyBools:   map[bool]string{true: "true", false: "false"},
+		KeyInt32s:  map[int32]string{0: "zero", -1: "one", 2: "two"},
+		KeyInt64s:  map[int64]string{0: "zero", -10: "ten", 20: "twenty"},
+		KeyUint32s: map[uint32]string{0: "zero", 1: "one", 2: "two"},
+		KeyUint64s: map[uint64]string{0: "zero", 10: "ten", 20: "twenty"},
+		KeyStrings: map[string]string{"": "", "foo": "bar"},
+
+		ValBools:    map[string]bool{"true": true, "false": false},
+		ValInt32s:   map[string]int32{"one": 1, "two": 2, "three": 3},
+		ValInt64s:   map[string]int64{"ten": 10, "twenty": -20, "thirty": 30},
+		ValUint32s:  map[string]uint32{"0x00": 0x00, "0xff": 0xff, "0xdead": 0xdead},
+		ValUint64s:  map[string]uint64{"0x00": 0x00, "0xff": 0xff, "0xdead": 0xdead},
+		ValFloat32s: map[string]float32{"nan": float32(math.NaN()), "pi": float32(math.Pi)},
+		ValFloat64s: map[string]float64{"nan": float64(math.NaN()), "pi": float64(math.Pi)},
+		ValStrings:  map[string]string{"s1": "s1", "s2": "s2"},
+		ValStringsA: map[string][]byte{"s1": []byte("s1"), "s2": []byte("s2")},
+		ValBytes:    map[string][]byte{"s1": []byte("s1"), "s2": []byte("s2")},
+		ValBytesA:   map[string]string{"s1": "s1", "s2": "s2"},
+
+		MyStrings1: map[MyString]MyString{"s1": "s1", "s2": "s2"},
+		MyStrings2: map[MyString]MyBytes{"s1": []byte("s1"), "s2": []byte("s2")},
+		MyBytes1:   map[MyString]MyBytes{"s1": []byte("s1"), "s2": []byte("s2")},
+		MyBytes2:   map[MyString]MyString{"s1": "s1", "s2": "s2"},
+
+		MyStrings3: MapStrings{"s1": "s1", "s2": "s2"},
+		MyStrings4: MapBytes{"s1": []byte("s1"), "s2": []byte("s2")},
+		MyBytes3:   MapBytes{"s1": []byte("s1"), "s2": []byte("s2")},
+		MyBytes4:   MapStrings{"s1": "s1", "s2": "s2"},
+	}).ProtoReflect()
+
+	testMessage(t, nil, new(MapScalars).ProtoReflect(), messageOps{
+		hasFields{1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false, 12: false, 13: false, 14: false, 15: false, 16: false, 17: false, 18: false, 19: false, 20: false, 21: false, 22: false, 23: false, 24: false, 25: false},
+		getFields{1: getField(empty, 1), 3: getField(empty, 3), 5: getField(empty, 5), 7: getField(empty, 7), 9: getField(empty, 9), 11: getField(empty, 11), 13: getField(empty, 13), 15: getField(empty, 15), 17: getField(empty, 17), 19: getField(empty, 19), 21: getField(empty, 21), 23: getField(empty, 23), 25: getField(empty, 25)},
+		setFields{1: getField(want, 1), 3: getField(want, 3), 5: getField(want, 5), 7: getField(want, 7), 9: getField(want, 9), 11: getField(want, 11), 13: getField(want, 13), 15: getField(want, 15), 17: getField(want, 17), 19: getField(want, 19), 21: getField(want, 21), 23: getField(want, 23), 25: getField(want, 25)},
+		mapFieldsMutable{
+			2: {
+				lenMap(0),
+				hasMap{int32(0): false, int32(-1): false, int32(2): false},
+				setMap{int32(0): V("zero")},
+				lenMap(1),
+				hasMap{int32(0): true, int32(-1): false, int32(2): false},
+				setMap{int32(-1): V("one")},
+				lenMap(2),
+				hasMap{int32(0): true, int32(-1): true, int32(2): false},
+				setMap{int32(2): V("two")},
+				lenMap(3),
+				hasMap{int32(0): true, int32(-1): true, int32(2): true},
+			},
+			4: {
+				setMap{uint32(0): V("zero"), uint32(1): V("one"), uint32(2): V("two")},
+				equalMap{getField(want, 4).Map()},
+			},
+			6: {
+				clearMap{"noexist"},
+				setMap{"foo": V("bar")},
+				setMap{"": V("empty")},
+				getMap{"": V("empty"), "foo": V("bar"), "noexist": V(nil)},
+				setMap{"": V(""), "extra": V("extra")},
+				clearMap{"extra", "noexist"},
+			},
+			8: {
+				equalMap{getField(empty, 8).Map()},
+				setMap{"one": V(int32(1)), "two": V(int32(2)), "three": V(int32(3))},
+			},
+			10: {
+				setMap{"0x00": V(uint32(0x00)), "0xff": V(uint32(0xff)), "0xdead": V(uint32(0xdead))},
+				lenMap(3),
+				equalMap{getField(want, 10).Map()},
+				getMap{"0x00": V(uint32(0x00)), "0xff": V(uint32(0xff)), "0xdead": V(uint32(0xdead)), "0xdeadbeef": V(nil)},
+			},
+			12: {
+				setMap{"nan": V(float32(math.NaN())), "pi": V(float32(math.Pi)), "e": V(float32(math.E))},
+				clearMap{"e", "phi"},
+				rangeMap{"nan": V(float32(math.NaN())), "pi": V(float32(math.Pi))},
+			},
+			14: {
+				equalMap{getField(empty, 14).Map()},
+				setMap{"s1": V("s1"), "s2": V("s2")},
+			},
+			16: {
+				setMap{"s1": V([]byte("s1")), "s2": V([]byte("s2"))},
+				equalMap{getField(want, 16).Map()},
+			},
+			18: {
+				hasMap{"s1": false, "s2": false, "s3": false},
+				setMap{"s1": V("s1"), "s2": V("s2")},
+				hasMap{"s1": true, "s2": true, "s3": false},
+			},
+			20: {
+				equalMap{getField(empty, 20).Map()},
+				setMap{"s1": V([]byte("s1")), "s2": V([]byte("s2"))},
+			},
+			22: {
+				rangeMap{},
+				setMap{"s1": V("s1"), "s2": V("s2")},
+				rangeMap{"s1": V("s1"), "s2": V("s2")},
+				lenMap(2),
+			},
+			24: {
+				setMap{"s1": V([]byte("s1")), "s2": V([]byte("s2"))},
+				equalMap{getField(want, 24).Map()},
+			},
+		},
+		hasFields{1: true, 2: true, 3: true, 4: true, 5: true, 6: true, 7: true, 8: true, 9: true, 10: true, 11: true, 12: true, 13: true, 14: true, 15: true, 16: true, 17: true, 18: true, 19: true, 20: true, 21: true, 22: true, 23: true, 24: true, 25: true},
+		equalMessage{want},
+		clearFields{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25},
+		equalMessage{empty},
+	})
+
+	// Test read-only operations on nil message.
+	testMessage(t, nil, (*MapScalars)(nil).ProtoReflect(), messageOps{
+		hasFields{1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false, 12: false, 13: false, 14: false, 15: false, 16: false, 17: false, 18: false, 19: false, 20: false, 21: false, 22: false, 23: false, 24: false, 25: false},
+		mapFields{2: {lenMap(0)}, 4: {lenMap(0)}, 6: {lenMap(0)}, 8: {lenMap(0)}, 10: {lenMap(0)}, 12: {lenMap(0)}, 14: {lenMap(0)}, 16: {lenMap(0)}, 18: {lenMap(0)}, 20: {lenMap(0)}, 22: {lenMap(0)}, 24: {lenMap(0)}},
+	})
+}
+
+type OneofScalars struct {
+	Union isOneofScalars_Union `protobuf_oneof:"union"`
+}
+
+var oneofScalarsType = pimpl.MessageInfo{GoReflectType: reflect.TypeOf(new(OneofScalars)), Desc: mustMakeMessageDesc("oneof-scalars.proto", pref.Proto2, "", `
+		name: "OneofScalars"
+		field: [
+			{name:"f1"  number:1  label:LABEL_OPTIONAL type:TYPE_BOOL   default_value:"true" oneof_index:0},
+			{name:"f2"  number:2  label:LABEL_OPTIONAL type:TYPE_INT32  default_value:"2"    oneof_index:0},
+			{name:"f3"  number:3  label:LABEL_OPTIONAL type:TYPE_INT64  default_value:"3"    oneof_index:0},
+			{name:"f4"  number:4  label:LABEL_OPTIONAL type:TYPE_UINT32 default_value:"4"    oneof_index:0},
+			{name:"f5"  number:5  label:LABEL_OPTIONAL type:TYPE_UINT64 default_value:"5"    oneof_index:0},
+			{name:"f6"  number:6  label:LABEL_OPTIONAL type:TYPE_FLOAT  default_value:"6"    oneof_index:0},
+			{name:"f7"  number:7  label:LABEL_OPTIONAL type:TYPE_DOUBLE default_value:"7"    oneof_index:0},
+			{name:"f8"  number:8  label:LABEL_OPTIONAL type:TYPE_STRING default_value:"8"    oneof_index:0},
+			{name:"f9"  number:9  label:LABEL_OPTIONAL type:TYPE_STRING default_value:"9"    oneof_index:0},
+			{name:"f10" number:10 label:LABEL_OPTIONAL type:TYPE_STRING default_value:"10"   oneof_index:0},
+			{name:"f11" number:11 label:LABEL_OPTIONAL type:TYPE_BYTES  default_value:"11"   oneof_index:0},
+			{name:"f12" number:12 label:LABEL_OPTIONAL type:TYPE_BYTES  default_value:"12"   oneof_index:0},
+			{name:"f13" number:13 label:LABEL_OPTIONAL type:TYPE_BYTES  default_value:"13"   oneof_index:0}
+		]
+		oneof_decl: [{name:"union"}]
+	`, nil),
+}
+
+func (m *OneofScalars) ProtoReflect() pref.Message { return oneofScalarsType.MessageOf(m) }
+
+func (*OneofScalars) XXX_OneofWrappers() []interface{} {
+	return []interface{}{
+		(*OneofScalars_Bool)(nil),
+		(*OneofScalars_Int32)(nil),
+		(*OneofScalars_Int64)(nil),
+		(*OneofScalars_Uint32)(nil),
+		(*OneofScalars_Uint64)(nil),
+		(*OneofScalars_Float32)(nil),
+		(*OneofScalars_Float64)(nil),
+		(*OneofScalars_String)(nil),
+		(*OneofScalars_StringA)(nil),
+		(*OneofScalars_StringB)(nil),
+		(*OneofScalars_Bytes)(nil),
+		(*OneofScalars_BytesA)(nil),
+		(*OneofScalars_BytesB)(nil),
+	}
+}
+
+type (
+	isOneofScalars_Union interface {
+		isOneofScalars_Union()
+	}
+	OneofScalars_Bool struct {
+		Bool bool `protobuf:"1"`
+	}
+	OneofScalars_Int32 struct {
+		Int32 MyInt32 `protobuf:"2"`
+	}
+	OneofScalars_Int64 struct {
+		Int64 int64 `protobuf:"3"`
+	}
+	OneofScalars_Uint32 struct {
+		Uint32 MyUint32 `protobuf:"4"`
+	}
+	OneofScalars_Uint64 struct {
+		Uint64 uint64 `protobuf:"5"`
+	}
+	OneofScalars_Float32 struct {
+		Float32 MyFloat32 `protobuf:"6"`
+	}
+	OneofScalars_Float64 struct {
+		Float64 float64 `protobuf:"7"`
+	}
+	OneofScalars_String struct {
+		String string `protobuf:"8"`
+	}
+	OneofScalars_StringA struct {
+		StringA []byte `protobuf:"9"`
+	}
+	OneofScalars_StringB struct {
+		StringB MyString `protobuf:"10"`
+	}
+	OneofScalars_Bytes struct {
+		Bytes []byte `protobuf:"11"`
+	}
+	OneofScalars_BytesA struct {
+		BytesA string `protobuf:"12"`
+	}
+	OneofScalars_BytesB struct {
+		BytesB MyBytes `protobuf:"13"`
+	}
+)
+
+func (*OneofScalars_Bool) isOneofScalars_Union()    {}
+func (*OneofScalars_Int32) isOneofScalars_Union()   {}
+func (*OneofScalars_Int64) isOneofScalars_Union()   {}
+func (*OneofScalars_Uint32) isOneofScalars_Union()  {}
+func (*OneofScalars_Uint64) isOneofScalars_Union()  {}
+func (*OneofScalars_Float32) isOneofScalars_Union() {}
+func (*OneofScalars_Float64) isOneofScalars_Union() {}
+func (*OneofScalars_String) isOneofScalars_Union()  {}
+func (*OneofScalars_StringA) isOneofScalars_Union() {}
+func (*OneofScalars_StringB) isOneofScalars_Union() {}
+func (*OneofScalars_Bytes) isOneofScalars_Union()   {}
+func (*OneofScalars_BytesA) isOneofScalars_Union()  {}
+func (*OneofScalars_BytesB) isOneofScalars_Union()  {}
+
+func TestOneofs(t *testing.T) {
+	empty := &OneofScalars{}
+	want1 := &OneofScalars{Union: &OneofScalars_Bool{true}}
+	want2 := &OneofScalars{Union: &OneofScalars_Int32{20}}
+	want3 := &OneofScalars{Union: &OneofScalars_Int64{30}}
+	want4 := &OneofScalars{Union: &OneofScalars_Uint32{40}}
+	want5 := &OneofScalars{Union: &OneofScalars_Uint64{50}}
+	want6 := &OneofScalars{Union: &OneofScalars_Float32{60}}
+	want7 := &OneofScalars{Union: &OneofScalars_Float64{70}}
+	want8 := &OneofScalars{Union: &OneofScalars_String{string("80")}}
+	want9 := &OneofScalars{Union: &OneofScalars_StringA{[]byte("90")}}
+	want10 := &OneofScalars{Union: &OneofScalars_StringB{MyString("100")}}
+	want11 := &OneofScalars{Union: &OneofScalars_Bytes{[]byte("110")}}
+	want12 := &OneofScalars{Union: &OneofScalars_BytesA{string("120")}}
+	want13 := &OneofScalars{Union: &OneofScalars_BytesB{MyBytes("130")}}
+
+	testMessage(t, nil, new(OneofScalars).ProtoReflect(), messageOps{
+		hasFields{1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false, 12: false, 13: false},
+		getFields{1: V(bool(true)), 2: V(int32(2)), 3: V(int64(3)), 4: V(uint32(4)), 5: V(uint64(5)), 6: V(float32(6)), 7: V(float64(7)), 8: V(string("8")), 9: V(string("9")), 10: V(string("10")), 11: V([]byte("11")), 12: V([]byte("12")), 13: V([]byte("13"))},
+		whichOneofs{"union": 0},
+
+		setFields{1: V(bool(true))}, hasFields{1: true}, equalMessage{want1.ProtoReflect()},
+		setFields{2: V(int32(20))}, hasFields{2: true}, equalMessage{want2.ProtoReflect()},
+		setFields{3: V(int64(30))}, hasFields{3: true}, equalMessage{want3.ProtoReflect()},
+		setFields{4: V(uint32(40))}, hasFields{4: true}, equalMessage{want4.ProtoReflect()},
+		setFields{5: V(uint64(50))}, hasFields{5: true}, equalMessage{want5.ProtoReflect()},
+		setFields{6: V(float32(60))}, hasFields{6: true}, equalMessage{want6.ProtoReflect()},
+		setFields{7: V(float64(70))}, hasFields{7: true}, equalMessage{want7.ProtoReflect()},
+
+		hasFields{1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: true, 8: false, 9: false, 10: false, 11: false, 12: false, 13: false},
+		whichOneofs{"union": 7},
+
+		setFields{8: V(string("80"))}, hasFields{8: true}, equalMessage{want8.ProtoReflect()},
+		setFields{9: V(string("90"))}, hasFields{9: true}, equalMessage{want9.ProtoReflect()},
+		setFields{10: V(string("100"))}, hasFields{10: true}, equalMessage{want10.ProtoReflect()},
+		setFields{11: V([]byte("110"))}, hasFields{11: true}, equalMessage{want11.ProtoReflect()},
+		setFields{12: V([]byte("120"))}, hasFields{12: true}, equalMessage{want12.ProtoReflect()},
+		setFields{13: V([]byte("130"))}, hasFields{13: true}, equalMessage{want13.ProtoReflect()},
+
+		hasFields{1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false, 12: false, 13: true},
+		getFields{1: V(bool(true)), 2: V(int32(2)), 3: V(int64(3)), 4: V(uint32(4)), 5: V(uint64(5)), 6: V(float32(6)), 7: V(float64(7)), 8: V(string("8")), 9: V(string("9")), 10: V(string("10")), 11: V([]byte("11")), 12: V([]byte("12")), 13: V([]byte("130"))},
+		clearFields{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12},
+		whichOneofs{"union": 13},
+		equalMessage{want13.ProtoReflect()},
+		clearFields{13},
+		whichOneofs{"union": 0},
+		equalMessage{empty.ProtoReflect()},
+	})
+
+	// Test read-only operations on nil message.
+	testMessage(t, nil, (*OneofScalars)(nil).ProtoReflect(), messageOps{
+		hasFields{1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false, 12: false, 13: false},
+		getFields{1: V(bool(true)), 2: V(int32(2)), 3: V(int64(3)), 4: V(uint32(4)), 5: V(uint64(5)), 6: V(float32(6)), 7: V(float64(7)), 8: V(string("8")), 9: V(string("9")), 10: V(string("10")), 11: V([]byte("11")), 12: V([]byte("12")), 13: V([]byte("13"))},
+	})
+}
+
+type EnumProto2 int32
+
+var enumProto2Desc = mustMakeEnumDesc("enum2.proto", pref.Proto2, `
+	name:  "EnumProto2"
+	value: [{name:"DEAD" number:0xdead}, {name:"BEEF" number:0xbeef}]
+`)
+
+func (e EnumProto2) Descriptor() pref.EnumDescriptor { return enumProto2Desc }
+func (e EnumProto2) Type() pref.EnumType             { return e }
+func (e EnumProto2) Enum() *EnumProto2               { return &e }
+func (e EnumProto2) Number() pref.EnumNumber         { return pref.EnumNumber(e) }
+func (t EnumProto2) New(n pref.EnumNumber) pref.Enum { return EnumProto2(n) }
+
+type EnumProto3 int32
+
+var enumProto3Desc = mustMakeEnumDesc("enum3.proto", pref.Proto3, `
+	name:  "EnumProto3",
+	value: [{name:"ALPHA" number:0}, {name:"BRAVO" number:1}]
+`)
+
+func (e EnumProto3) Descriptor() pref.EnumDescriptor { return enumProto3Desc }
+func (e EnumProto3) Type() pref.EnumType             { return e }
+func (e EnumProto3) Enum() *EnumProto3               { return &e }
+func (e EnumProto3) Number() pref.EnumNumber         { return pref.EnumNumber(e) }
+func (t EnumProto3) New(n pref.EnumNumber) pref.Enum { return EnumProto3(n) }
+
+type EnumMessages struct {
+	EnumP2        *EnumProto2              `protobuf:"1"`
+	EnumP3        *EnumProto3              `protobuf:"2"`
+	MessageLegacy *proto2_20180125.Message `protobuf:"3"`
+	MessageCycle  *EnumMessages            `protobuf:"4"`
+	EnumList      []EnumProto2             `protobuf:"5"`
+	MessageList   []*ScalarProto2          `protobuf:"6"`
+	EnumMap       map[string]EnumProto3    `protobuf:"7"`
+	MessageMap    map[string]*ScalarProto3 `protobuf:"8"`
+	Union         isEnumMessages_Union     `protobuf_oneof:"union"`
+}
+
+var enumMessagesType = pimpl.MessageInfo{GoReflectType: reflect.TypeOf(new(EnumMessages)), Desc: mustMakeMessageDesc("enum-messages.proto", pref.Proto2, `
+		dependency: ["enum2.proto", "enum3.proto", "scalar2.proto", "scalar3.proto", "proto2_20180125_92554152/test.proto"]
+	`, `
+		name: "EnumMessages"
+		field: [
+			{name:"f1"  number:1  label:LABEL_OPTIONAL type:TYPE_ENUM    type_name:".EnumProto2" default_value:"BEEF"},
+			{name:"f2"  number:2  label:LABEL_OPTIONAL type:TYPE_ENUM    type_name:".EnumProto3" default_value:"BRAVO"},
+			{name:"f3"  number:3  label:LABEL_OPTIONAL type:TYPE_MESSAGE type_name:".google.golang.org.proto2_20180125.Message"},
+			{name:"f4"  number:4  label:LABEL_OPTIONAL type:TYPE_MESSAGE type_name:".EnumMessages"},
+			{name:"f5"  number:5  label:LABEL_REPEATED type:TYPE_ENUM    type_name:".EnumProto2"},
+			{name:"f6"  number:6  label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".ScalarProto2"},
+			{name:"f7"  number:7  label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".EnumMessages.F7Entry"},
+			{name:"f8"  number:8  label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".EnumMessages.F8Entry"},
+			{name:"f9"  number:9  label:LABEL_OPTIONAL type:TYPE_ENUM    type_name:".EnumProto2"   oneof_index:0 default_value:"BEEF"},
+			{name:"f10" number:10 label:LABEL_OPTIONAL type:TYPE_ENUM    type_name:".EnumProto3"   oneof_index:0 default_value:"BRAVO"},
+			{name:"f11" number:11 label:LABEL_OPTIONAL type:TYPE_MESSAGE type_name:".ScalarProto2" oneof_index:0},
+			{name:"f12" number:12 label:LABEL_OPTIONAL type:TYPE_MESSAGE type_name:".ScalarProto3" oneof_index:0}
+		]
+		oneof_decl: [{name:"union"}]
+		nested_type: [
+			{name:"F7Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_ENUM    type_name:".EnumProto3"}]   options:{map_entry:true}},
+			{name:"F8Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_MESSAGE type_name:".ScalarProto3"}] options:{map_entry:true}}
+		]
+	`, newFileRegistry(
+	EnumProto2(0).Descriptor().ParentFile(),
+	EnumProto3(0).Descriptor().ParentFile(),
+	((*ScalarProto2)(nil)).ProtoReflect().Descriptor().ParentFile(),
+	((*ScalarProto3)(nil)).ProtoReflect().Descriptor().ParentFile(),
+	pimpl.Export{}.MessageDescriptorOf((*proto2_20180125.Message)(nil)).ParentFile(),
+)),
+}
+
+func newFileRegistry(files ...pref.FileDescriptor) *protoregistry.Files {
+	r := new(protoregistry.Files)
+	for _, file := range files {
+		r.RegisterFile(file)
+	}
+	return r
+}
+
+func (m *EnumMessages) ProtoReflect() pref.Message { return enumMessagesType.MessageOf(m) }
+
+func (*EnumMessages) XXX_OneofWrappers() []interface{} {
+	return []interface{}{
+		(*EnumMessages_OneofE2)(nil),
+		(*EnumMessages_OneofE3)(nil),
+		(*EnumMessages_OneofM2)(nil),
+		(*EnumMessages_OneofM3)(nil),
+	}
+}
+
+type (
+	isEnumMessages_Union interface {
+		isEnumMessages_Union()
+	}
+	EnumMessages_OneofE2 struct {
+		OneofE2 EnumProto2 `protobuf:"9"`
+	}
+	EnumMessages_OneofE3 struct {
+		OneofE3 EnumProto3 `protobuf:"10"`
+	}
+	EnumMessages_OneofM2 struct {
+		OneofM2 *ScalarProto2 `protobuf:"11"`
+	}
+	EnumMessages_OneofM3 struct {
+		OneofM3 *ScalarProto3 `protobuf:"12"`
+	}
+)
+
+func (*EnumMessages_OneofE2) isEnumMessages_Union() {}
+func (*EnumMessages_OneofE3) isEnumMessages_Union() {}
+func (*EnumMessages_OneofM2) isEnumMessages_Union() {}
+func (*EnumMessages_OneofM3) isEnumMessages_Union() {}
+
+func TestEnumMessages(t *testing.T) {
+	emptyL := pimpl.Export{}.MessageOf(new(proto2_20180125.Message))
+	emptyM := new(EnumMessages).ProtoReflect()
+	emptyM2 := new(ScalarProto2).ProtoReflect()
+	emptyM3 := new(ScalarProto3).ProtoReflect()
+
+	wantL := pimpl.Export{}.MessageOf(&proto2_20180125.Message{OptionalFloat: proto.Float32(math.E)})
+	wantM := (&EnumMessages{EnumP2: EnumProto2(1234).Enum()}).ProtoReflect()
+	wantM2a := &ScalarProto2{Float32: proto.Float32(math.Pi)}
+	wantM2b := &ScalarProto2{Float32: proto.Float32(math.Phi)}
+	wantM3a := &ScalarProto3{Float32: math.Pi}
+	wantM3b := &ScalarProto3{Float32: math.Ln2}
+
+	wantList5 := getField((&EnumMessages{EnumList: []EnumProto2{333, 222}}).ProtoReflect(), 5)
+	wantList6 := getField((&EnumMessages{MessageList: []*ScalarProto2{wantM2a, wantM2b}}).ProtoReflect(), 6)
+
+	wantMap7 := getField((&EnumMessages{EnumMap: map[string]EnumProto3{"one": 1, "two": 2}}).ProtoReflect(), 7)
+	wantMap8 := getField((&EnumMessages{MessageMap: map[string]*ScalarProto3{"pi": wantM3a, "ln2": wantM3b}}).ProtoReflect(), 8)
+
+	testMessage(t, nil, new(EnumMessages).ProtoReflect(), messageOps{
+		hasFields{1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false, 12: false},
+		getFields{1: VE(0xbeef), 2: VE(1), 3: V(emptyL), 4: V(emptyM), 9: VE(0xbeef), 10: VE(1)},
+
+		// Test singular enums.
+		setFields{1: VE(0xdead), 2: VE(0)},
+		getFields{1: VE(0xdead), 2: VE(0)},
+		hasFields{1: true, 2: true},
+
+		// Test singular messages.
+		messageFieldsMutable{3: messageOps{setFields{109: V(float32(math.E))}}},
+		messageFieldsMutable{4: messageOps{setFields{1: VE(1234)}}},
+		getFields{3: V(wantL), 4: V(wantM)},
+		clearFields{3, 4},
+		hasFields{3: false, 4: false},
+		setFields{3: V(wantL), 4: V(wantM)},
+		hasFields{3: true, 4: true},
+
+		// Test list of enums and messages.
+		listFieldsMutable{
+			5: listOps{
+				appendList{VE(111), VE(222)},
+				setList{0: VE(333)},
+				getList{0: VE(333), 1: VE(222)},
+				lenList(2),
+			},
+			6: listOps{
+				appendMessageList{setFields{4: V(uint32(1e6))}},
+				appendMessageList{setFields{6: V(float32(math.Phi))}},
+				setList{0: V(wantM2a.ProtoReflect())},
+				getList{0: V(wantM2a.ProtoReflect()), 1: V(wantM2b.ProtoReflect())},
+			},
+		},
+		getFields{5: wantList5, 6: wantList6},
+		hasFields{5: true, 6: true},
+		listFields{5: listOps{truncList(0)}},
+		hasFields{5: false, 6: true},
+
+		// Test maps of enums and messages.
+		mapFieldsMutable{
+			7: mapOps{
+				setMap{"one": VE(1), "two": VE(2)},
+				hasMap{"one": true, "two": true, "three": false},
+				lenMap(2),
+			},
+			8: mapOps{
+				messageMap{"pi": messageOps{setFields{6: V(float32(math.Pi))}}},
+				setMap{"ln2": V(wantM3b.ProtoReflect())},
+				getMap{"pi": V(wantM3a.ProtoReflect()), "ln2": V(wantM3b.ProtoReflect()), "none": V(nil)},
+				lenMap(2),
+			},
+		},
+		getFields{7: wantMap7, 8: wantMap8},
+		hasFields{7: true, 8: true},
+		mapFields{8: mapOps{clearMap{"pi", "ln2", "none"}}},
+		hasFields{7: true, 8: false},
+
+		// Test oneofs of enums and messages.
+		setFields{9: VE(0xdead)},
+		hasFields{1: true, 2: true, 9: true, 10: false, 11: false, 12: false},
+		setFields{10: VE(0)},
+		hasFields{1: true, 2: true, 9: false, 10: true, 11: false, 12: false},
+		messageFieldsMutable{11: messageOps{setFields{6: V(float32(math.Pi))}}},
+		getFields{11: V(wantM2a.ProtoReflect())},
+		hasFields{1: true, 2: true, 9: false, 10: false, 11: true, 12: false},
+		messageFieldsMutable{12: messageOps{setFields{6: V(float32(math.Pi))}}},
+		getFields{12: V(wantM3a.ProtoReflect())},
+		hasFields{1: true, 2: true, 9: false, 10: false, 11: false, 12: true},
+
+		// Check entire message.
+		rangeFields{1: VE(0xdead), 2: VE(0), 3: V(wantL), 4: V(wantM), 6: wantList6, 7: wantMap7, 12: V(wantM3a.ProtoReflect())},
+		equalMessage{(&EnumMessages{
+			EnumP2:        EnumProto2(0xdead).Enum(),
+			EnumP3:        EnumProto3(0).Enum(),
+			MessageLegacy: &proto2_20180125.Message{OptionalFloat: proto.Float32(math.E)},
+			MessageCycle:  wantM.Interface().(*EnumMessages),
+			MessageList:   []*ScalarProto2{wantM2a, wantM2b},
+			EnumMap:       map[string]EnumProto3{"one": 1, "two": 2},
+			Union:         &EnumMessages_OneofM3{wantM3a},
+		}).ProtoReflect()},
+		clearFields{1, 2, 3, 4, 6, 7, 12},
+		equalMessage{new(EnumMessages).ProtoReflect()},
+	})
+
+	// Test read-only operations on nil message.
+	testMessage(t, nil, (*EnumMessages)(nil).ProtoReflect(), messageOps{
+		hasFields{1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false, 12: false},
+		getFields{1: VE(0xbeef), 2: VE(1), 3: V(emptyL), 4: V(emptyM), 9: VE(0xbeef), 10: VE(1), 11: V(emptyM2), 12: V(emptyM3)},
+		listFields{5: {lenList(0)}, 6: {lenList(0)}},
+		mapFields{7: {lenMap(0)}, 8: {lenMap(0)}},
+	})
+}
+
+var cmpOpts = cmp.Options{
+	cmp.Comparer(func(x, y *proto2_20180125.Message) bool {
+		mx := pimpl.Export{}.MessageOf(x).Interface()
+		my := pimpl.Export{}.MessageOf(y).Interface()
+		return proto.Equal(mx, my)
+	}),
+	cmp.Transformer("UnwrapValue", func(pv pref.Value) interface{} {
+		switch v := pv.Interface().(type) {
+		case pref.Message:
+			out := make(map[pref.FieldNumber]pref.Value)
+			v.Range(func(fd pref.FieldDescriptor, v pref.Value) bool {
+				out[fd.Number()] = v
+				return true
+			})
+			return out
+		case pref.List:
+			var out []pref.Value
+			for i := 0; i < v.Len(); i++ {
+				out = append(out, v.Get(i))
+			}
+			return out
+		case pref.Map:
+			out := make(map[interface{}]pref.Value)
+			v.Range(func(k pref.MapKey, v pref.Value) bool {
+				out[k.Interface()] = v
+				return true
+			})
+			return out
+		default:
+			return v
+		}
+	}),
+	cmpopts.EquateNaNs(),
+}
+
+func testMessage(t *testing.T, p path, m pref.Message, tt messageOps) {
+	fieldDescs := m.Descriptor().Fields()
+	oneofDescs := m.Descriptor().Oneofs()
+	for i, op := range tt {
+		p.Push(i)
+		switch op := op.(type) {
+		case equalMessage:
+			if diff := cmp.Diff(V(op.Message), V(m), cmpOpts); diff != "" {
+				t.Errorf("operation %v, message mismatch (-want, +got):\n%s", p, diff)
+			}
+		case hasFields:
+			got := map[pref.FieldNumber]bool{}
+			want := map[pref.FieldNumber]bool(op)
+			for n := range want {
+				fd := fieldDescs.ByNumber(n)
+				got[n] = m.Has(fd)
+			}
+			if diff := cmp.Diff(want, got); diff != "" {
+				t.Errorf("operation %v, Message.Has mismatch (-want, +got):\n%s", p, diff)
+			}
+		case getFields:
+			got := map[pref.FieldNumber]pref.Value{}
+			want := map[pref.FieldNumber]pref.Value(op)
+			for n := range want {
+				fd := fieldDescs.ByNumber(n)
+				got[n] = m.Get(fd)
+			}
+			if diff := cmp.Diff(want, got, cmpOpts); diff != "" {
+				t.Errorf("operation %v, Message.Get mismatch (-want, +got):\n%s", p, diff)
+			}
+		case setFields:
+			for n, v := range op {
+				fd := fieldDescs.ByNumber(n)
+				m.Set(fd, v)
+			}
+		case clearFields:
+			for _, n := range op {
+				fd := fieldDescs.ByNumber(n)
+				m.Clear(fd)
+			}
+		case whichOneofs:
+			got := map[pref.Name]pref.FieldNumber{}
+			want := map[pref.Name]pref.FieldNumber(op)
+			for s := range want {
+				od := oneofDescs.ByName(s)
+				fd := m.WhichOneof(od)
+				if fd == nil {
+					got[s] = 0
+				} else {
+					got[s] = fd.Number()
+				}
+			}
+			if diff := cmp.Diff(want, got); diff != "" {
+				t.Errorf("operation %v, Message.WhichOneof mismatch (-want, +got):\n%s", p, diff)
+			}
+		case messageFields:
+			for n, tt := range op {
+				p.Push(int(n))
+				fd := fieldDescs.ByNumber(n)
+				testMessage(t, p, m.Get(fd).Message(), tt)
+				p.Pop()
+			}
+		case messageFieldsMutable:
+			for n, tt := range op {
+				p.Push(int(n))
+				fd := fieldDescs.ByNumber(n)
+				testMessage(t, p, m.Mutable(fd).Message(), tt)
+				p.Pop()
+			}
+		case listFields:
+			for n, tt := range op {
+				p.Push(int(n))
+				fd := fieldDescs.ByNumber(n)
+				testLists(t, p, m.Get(fd).List(), tt)
+				p.Pop()
+			}
+		case listFieldsMutable:
+			for n, tt := range op {
+				p.Push(int(n))
+				fd := fieldDescs.ByNumber(n)
+				testLists(t, p, m.Mutable(fd).List(), tt)
+				p.Pop()
+			}
+		case mapFields:
+			for n, tt := range op {
+				p.Push(int(n))
+				fd := fieldDescs.ByNumber(n)
+				testMaps(t, p, m.Get(fd).Map(), tt)
+				p.Pop()
+			}
+		case mapFieldsMutable:
+			for n, tt := range op {
+				p.Push(int(n))
+				fd := fieldDescs.ByNumber(n)
+				testMaps(t, p, m.Mutable(fd).Map(), tt)
+				p.Pop()
+			}
+		case rangeFields:
+			got := map[pref.FieldNumber]pref.Value{}
+			want := map[pref.FieldNumber]pref.Value(op)
+			m.Range(func(fd pref.FieldDescriptor, v pref.Value) bool {
+				got[fd.Number()] = v
+				return true
+			})
+			if diff := cmp.Diff(want, got, cmpOpts); diff != "" {
+				t.Errorf("operation %v, Message.Range mismatch (-want, +got):\n%s", p, diff)
+			}
+		default:
+			t.Fatalf("operation %v, invalid operation: %T", p, op)
+		}
+		p.Pop()
+	}
+}
+
+func testLists(t *testing.T, p path, v pref.List, tt listOps) {
+	for i, op := range tt {
+		p.Push(i)
+		switch op := op.(type) {
+		case equalList:
+			if diff := cmp.Diff(V(op.List), V(v), cmpOpts); diff != "" {
+				t.Errorf("operation %v, list mismatch (-want, +got):\n%s", p, diff)
+			}
+		case lenList:
+			if got, want := v.Len(), int(op); got != want {
+				t.Errorf("operation %v, List.Len = %d, want %d", p, got, want)
+			}
+		case getList:
+			got := map[int]pref.Value{}
+			want := map[int]pref.Value(op)
+			for n := range want {
+				got[n] = v.Get(n)
+			}
+			if diff := cmp.Diff(want, got, cmpOpts); diff != "" {
+				t.Errorf("operation %v, List.Get mismatch (-want, +got):\n%s", p, diff)
+			}
+		case setList:
+			for n, e := range op {
+				v.Set(n, e)
+			}
+		case appendList:
+			for _, e := range op {
+				v.Append(e)
+			}
+		case appendMessageList:
+			e := v.NewElement()
+			v.Append(e)
+			testMessage(t, p, e.Message(), messageOps(op))
+		case truncList:
+			v.Truncate(int(op))
+		default:
+			t.Fatalf("operation %v, invalid operation: %T", p, op)
+		}
+		p.Pop()
+	}
+}
+
+func testMaps(t *testing.T, p path, m pref.Map, tt mapOps) {
+	for i, op := range tt {
+		p.Push(i)
+		switch op := op.(type) {
+		case equalMap:
+			if diff := cmp.Diff(V(op.Map), V(m), cmpOpts); diff != "" {
+				t.Errorf("operation %v, map mismatch (-want, +got):\n%s", p, diff)
+			}
+		case lenMap:
+			if got, want := m.Len(), int(op); got != want {
+				t.Errorf("operation %v, Map.Len = %d, want %d", p, got, want)
+			}
+		case hasMap:
+			got := map[interface{}]bool{}
+			want := map[interface{}]bool(op)
+			for k := range want {
+				got[k] = m.Has(V(k).MapKey())
+			}
+			if diff := cmp.Diff(want, got, cmpOpts); diff != "" {
+				t.Errorf("operation %v, Map.Has mismatch (-want, +got):\n%s", p, diff)
+			}
+		case getMap:
+			got := map[interface{}]pref.Value{}
+			want := map[interface{}]pref.Value(op)
+			for k := range want {
+				got[k] = m.Get(V(k).MapKey())
+			}
+			if diff := cmp.Diff(want, got, cmpOpts); diff != "" {
+				t.Errorf("operation %v, Map.Get mismatch (-want, +got):\n%s", p, diff)
+			}
+		case setMap:
+			for k, v := range op {
+				m.Set(V(k).MapKey(), v)
+			}
+		case clearMap:
+			for _, k := range op {
+				m.Clear(V(k).MapKey())
+			}
+		case messageMap:
+			for k, tt := range op {
+				mk := V(k).MapKey()
+				if !m.Has(mk) {
+					m.Set(mk, m.NewValue())
+				}
+				testMessage(t, p, m.Get(mk).Message(), tt)
+			}
+		case rangeMap:
+			got := map[interface{}]pref.Value{}
+			want := map[interface{}]pref.Value(op)
+			m.Range(func(k pref.MapKey, v pref.Value) bool {
+				got[k.Interface()] = v
+				return true
+			})
+			if diff := cmp.Diff(want, got, cmpOpts); diff != "" {
+				t.Errorf("operation %v, Map.Range mismatch (-want, +got):\n%s", p, diff)
+			}
+		default:
+			t.Fatalf("operation %v, invalid operation: %T", p, op)
+		}
+		p.Pop()
+	}
+}
+
+func getField(m pref.Message, n pref.FieldNumber) pref.Value {
+	fd := m.Descriptor().Fields().ByNumber(n)
+	return m.Get(fd)
+}
+
+type path []int
+
+func (p *path) Push(i int) { *p = append(*p, i) }
+func (p *path) Pop()       { *p = (*p)[:len(*p)-1] }
+func (p path) String() string {
+	var ss []string
+	for _, i := range p {
+		ss = append(ss, fmt.Sprint(i))
+	}
+	return strings.Join(ss, ".")
+}
+
+func TestReset(t *testing.T) {
+	mi := new(testpb.TestAllTypes)
+
+	// ProtoReflect is implemented using a messageState cache.
+	m := mi.ProtoReflect()
+
+	// Reset must not clear the messageState cache.
+	mi.Reset()
+
+	// If Reset accidentally cleared the messageState cache, this panics.
+	m.Descriptor()
+}
+
+func TestIsValid(t *testing.T) {
+	var m *testpb.TestAllTypes
+	if got, want := m.ProtoReflect().IsValid(), false; got != want {
+		t.Errorf("((*M)(nil)).ProtoReflect().IsValid() = %v, want %v", got, want)
+	}
+	m = &testpb.TestAllTypes{}
+	if got, want := m.ProtoReflect().IsValid(), true; got != want {
+		t.Errorf("(&M{}).ProtoReflect().IsValid() = %v, want %v", got, want)
+	}
+}
+
+// The MessageState implementation makes the assumption that when a
+// concrete message is unsafe casted as a *MessageState, the Go GC does
+// not reclaim the memory for the remainder of the concrete message.
+func TestUnsafeAssumptions(t *testing.T) {
+	if !pimpl.UnsafeEnabled {
+		t.Skip()
+	}
+
+	var wg sync.WaitGroup
+	for i := 0; i < 10; i++ {
+		wg.Add(1)
+		go func() {
+			var ms [10]pref.Message
+
+			// Store the message only in its reflective form.
+			// Trigger the GC after each iteration.
+			for j := 0; j < 10; j++ {
+				ms[j] = (&testpb.TestAllTypes{
+					OptionalInt32: proto.Int32(int32(j)),
+					OptionalFloat: proto.Float32(float32(j)),
+					RepeatedInt32: []int32{int32(j)},
+					RepeatedFloat: []float32{float32(j)},
+					DefaultInt32:  proto.Int32(int32(j)),
+					DefaultFloat:  proto.Float32(float32(j)),
+				}).ProtoReflect()
+				runtime.GC()
+			}
+
+			// Convert the reflective form back into a concrete form.
+			// Verify that the values written previously are still the same.
+			for j := 0; j < 10; j++ {
+				switch m := ms[j].Interface().(*testpb.TestAllTypes); {
+				case m.GetOptionalInt32() != int32(j):
+				case m.GetOptionalFloat() != float32(j):
+				case m.GetRepeatedInt32()[0] != int32(j):
+				case m.GetRepeatedFloat()[0] != float32(j):
+				case m.GetDefaultInt32() != int32(j):
+				case m.GetDefaultFloat() != float32(j):
+				default:
+					continue
+				}
+				t.Error("memory corrupted detected")
+			}
+			defer wg.Done()
+		}()
+	}
+	wg.Wait()
+}
+
+func BenchmarkName(b *testing.B) {
+	var sink pref.FullName
+	b.Run("Value", func(b *testing.B) {
+		b.ReportAllocs()
+		m := new(descriptorpb.FileDescriptorProto)
+		for i := 0; i < b.N; i++ {
+			sink = m.ProtoReflect().Descriptor().FullName()
+		}
+	})
+	b.Run("Nil", func(b *testing.B) {
+		b.ReportAllocs()
+		m := (*descriptorpb.FileDescriptorProto)(nil)
+		for i := 0; i < b.N; i++ {
+			sink = m.ProtoReflect().Descriptor().FullName()
+		}
+	})
+	runtime.KeepAlive(sink)
+}
+
+func BenchmarkReflect(b *testing.B) {
+	m := new(testpb.TestAllTypes).ProtoReflect()
+	fds := m.Descriptor().Fields()
+	vs := make([]pref.Value, fds.Len())
+	for i := range vs {
+		vs[i] = m.NewField(fds.Get(i))
+	}
+
+	b.Run("Has", func(b *testing.B) {
+		b.ReportAllocs()
+		for i := 0; i < b.N; i++ {
+			for j := 0; j < fds.Len(); j++ {
+				m.Has(fds.Get(j))
+			}
+		}
+	})
+	b.Run("Get", func(b *testing.B) {
+		b.ReportAllocs()
+		for i := 0; i < b.N; i++ {
+			for j := 0; j < fds.Len(); j++ {
+				m.Get(fds.Get(j))
+			}
+		}
+	})
+	b.Run("Set", func(b *testing.B) {
+		b.ReportAllocs()
+		for i := 0; i < b.N; i++ {
+			for j := 0; j < fds.Len(); j++ {
+				m.Set(fds.Get(j), vs[j])
+			}
+		}
+	})
+	b.Run("Clear", func(b *testing.B) {
+		b.ReportAllocs()
+		for i := 0; i < b.N; i++ {
+			for j := 0; j < fds.Len(); j++ {
+				m.Clear(fds.Get(j))
+			}
+		}
+	})
+	b.Run("Range", func(b *testing.B) {
+		b.ReportAllocs()
+		for i := 0; i < b.N; i++ {
+			m.Range(func(pref.FieldDescriptor, pref.Value) bool {
+				return true
+			})
+		}
+	})
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/pointer_reflect.go b/vendor/google.golang.org/protobuf/internal/impl/pointer_reflect.go
new file mode 100644
index 000000000..67b4ede67
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/pointer_reflect.go
@@ -0,0 +1,177 @@
+// 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.
+
+// +build purego appengine
+
+package impl
+
+import (
+	"fmt"
+	"reflect"
+	"sync"
+)
+
+const UnsafeEnabled = false
+
+// Pointer is an opaque pointer type.
+type Pointer interface{}
+
+// offset represents the offset to a struct field, accessible from a pointer.
+// The offset is the field index into a struct.
+type offset struct {
+	index  int
+	export exporter
+}
+
+// offsetOf returns a field offset for the struct field.
+func offsetOf(f reflect.StructField, x exporter) offset {
+	if len(f.Index) != 1 {
+		panic("embedded structs are not supported")
+	}
+	if f.PkgPath == "" {
+		return offset{index: f.Index[0]} // field is already exported
+	}
+	if x == nil {
+		panic("exporter must be provided for unexported field")
+	}
+	return offset{index: f.Index[0], export: x}
+}
+
+// IsValid reports whether the offset is valid.
+func (f offset) IsValid() bool { return f.index >= 0 }
+
+// invalidOffset is an invalid field offset.
+var invalidOffset = offset{index: -1}
+
+// zeroOffset is a noop when calling pointer.Apply.
+var zeroOffset = offset{index: 0}
+
+// pointer is an abstract representation of a pointer to a struct or field.
+type pointer struct{ v reflect.Value }
+
+// pointerOf returns p as a pointer.
+func pointerOf(p Pointer) pointer {
+	return pointerOfIface(p)
+}
+
+// pointerOfValue returns v as a pointer.
+func pointerOfValue(v reflect.Value) pointer {
+	return pointer{v: v}
+}
+
+// pointerOfIface returns the pointer portion of an interface.
+func pointerOfIface(v interface{}) pointer {
+	return pointer{v: reflect.ValueOf(v)}
+}
+
+// IsNil reports whether the pointer is nil.
+func (p pointer) IsNil() bool {
+	return p.v.IsNil()
+}
+
+// Apply adds an offset to the pointer to derive a new pointer
+// to a specified field. The current pointer must be pointing at a struct.
+func (p pointer) Apply(f offset) pointer {
+	if f.export != nil {
+		if v := reflect.ValueOf(f.export(p.v.Interface(), f.index)); v.IsValid() {
+			return pointer{v: v}
+		}
+	}
+	return pointer{v: p.v.Elem().Field(f.index).Addr()}
+}
+
+// AsValueOf treats p as a pointer to an object of type t and returns the value.
+// It is equivalent to reflect.ValueOf(p.AsIfaceOf(t))
+func (p pointer) AsValueOf(t reflect.Type) reflect.Value {
+	if got := p.v.Type().Elem(); got != t {
+		panic(fmt.Sprintf("invalid type: got %v, want %v", got, t))
+	}
+	return p.v
+}
+
+// AsIfaceOf treats p as a pointer to an object of type t and returns the value.
+// It is equivalent to p.AsValueOf(t).Interface()
+func (p pointer) AsIfaceOf(t reflect.Type) interface{} {
+	return p.AsValueOf(t).Interface()
+}
+
+func (p pointer) Bool() *bool              { return p.v.Interface().(*bool) }
+func (p pointer) BoolPtr() **bool          { return p.v.Interface().(**bool) }
+func (p pointer) BoolSlice() *[]bool       { return p.v.Interface().(*[]bool) }
+func (p pointer) Int32() *int32            { return p.v.Interface().(*int32) }
+func (p pointer) Int32Ptr() **int32        { return p.v.Interface().(**int32) }
+func (p pointer) Int32Slice() *[]int32     { return p.v.Interface().(*[]int32) }
+func (p pointer) Int64() *int64            { return p.v.Interface().(*int64) }
+func (p pointer) Int64Ptr() **int64        { return p.v.Interface().(**int64) }
+func (p pointer) Int64Slice() *[]int64     { return p.v.Interface().(*[]int64) }
+func (p pointer) Uint32() *uint32          { return p.v.Interface().(*uint32) }
+func (p pointer) Uint32Ptr() **uint32      { return p.v.Interface().(**uint32) }
+func (p pointer) Uint32Slice() *[]uint32   { return p.v.Interface().(*[]uint32) }
+func (p pointer) Uint64() *uint64          { return p.v.Interface().(*uint64) }
+func (p pointer) Uint64Ptr() **uint64      { return p.v.Interface().(**uint64) }
+func (p pointer) Uint64Slice() *[]uint64   { return p.v.Interface().(*[]uint64) }
+func (p pointer) Float32() *float32        { return p.v.Interface().(*float32) }
+func (p pointer) Float32Ptr() **float32    { return p.v.Interface().(**float32) }
+func (p pointer) Float32Slice() *[]float32 { return p.v.Interface().(*[]float32) }
+func (p pointer) Float64() *float64        { return p.v.Interface().(*float64) }
+func (p pointer) Float64Ptr() **float64    { return p.v.Interface().(**float64) }
+func (p pointer) Float64Slice() *[]float64 { return p.v.Interface().(*[]float64) }
+func (p pointer) String() *string          { return p.v.Interface().(*string) }
+func (p pointer) StringPtr() **string      { return p.v.Interface().(**string) }
+func (p pointer) StringSlice() *[]string   { return p.v.Interface().(*[]string) }
+func (p pointer) Bytes() *[]byte           { return p.v.Interface().(*[]byte) }
+func (p pointer) BytesSlice() *[][]byte    { return p.v.Interface().(*[][]byte) }
+func (p pointer) WeakFields() *weakFields  { return (*weakFields)(p.v.Interface().(*WeakFields)) }
+func (p pointer) Extensions() *map[int32]ExtensionField {
+	return p.v.Interface().(*map[int32]ExtensionField)
+}
+
+func (p pointer) Elem() pointer {
+	return pointer{v: p.v.Elem()}
+}
+
+// PointerSlice copies []*T from p as a new []pointer.
+// This behavior differs from the implementation in pointer_unsafe.go.
+func (p pointer) PointerSlice() []pointer {
+	// TODO: reconsider this
+	if p.v.IsNil() {
+		return nil
+	}
+	n := p.v.Elem().Len()
+	s := make([]pointer, n)
+	for i := 0; i < n; i++ {
+		s[i] = pointer{v: p.v.Elem().Index(i)}
+	}
+	return s
+}
+
+// AppendPointerSlice appends v to p, which must be a []*T.
+func (p pointer) AppendPointerSlice(v pointer) {
+	sp := p.v.Elem()
+	sp.Set(reflect.Append(sp, v.v))
+}
+
+// SetPointer sets *p to v.
+func (p pointer) SetPointer(v pointer) {
+	p.v.Elem().Set(v.v)
+}
+
+func (Export) MessageStateOf(p Pointer) *messageState     { panic("not supported") }
+func (ms *messageState) pointer() pointer                 { panic("not supported") }
+func (ms *messageState) messageInfo() *MessageInfo        { panic("not supported") }
+func (ms *messageState) LoadMessageInfo() *MessageInfo    { panic("not supported") }
+func (ms *messageState) StoreMessageInfo(mi *MessageInfo) { panic("not supported") }
+
+type atomicNilMessage struct {
+	once sync.Once
+	m    messageReflectWrapper
+}
+
+func (m *atomicNilMessage) Init(mi *MessageInfo) *messageReflectWrapper {
+	m.once.Do(func() {
+		m.m.p = pointerOfIface(reflect.Zero(mi.GoReflectType).Interface())
+		m.m.mi = mi
+	})
+	return &m.m
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/pointer_unsafe.go b/vendor/google.golang.org/protobuf/internal/impl/pointer_unsafe.go
new file mode 100644
index 000000000..088aa85d4
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/pointer_unsafe.go
@@ -0,0 +1,173 @@
+// 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.
+
+// +build !purego,!appengine
+
+package impl
+
+import (
+	"reflect"
+	"sync/atomic"
+	"unsafe"
+)
+
+const UnsafeEnabled = true
+
+// Pointer is an opaque pointer type.
+type Pointer unsafe.Pointer
+
+// offset represents the offset to a struct field, accessible from a pointer.
+// The offset is the byte offset to the field from the start of the struct.
+type offset uintptr
+
+// offsetOf returns a field offset for the struct field.
+func offsetOf(f reflect.StructField, x exporter) offset {
+	return offset(f.Offset)
+}
+
+// IsValid reports whether the offset is valid.
+func (f offset) IsValid() bool { return f != invalidOffset }
+
+// invalidOffset is an invalid field offset.
+var invalidOffset = ^offset(0)
+
+// zeroOffset is a noop when calling pointer.Apply.
+var zeroOffset = offset(0)
+
+// pointer is a pointer to a message struct or field.
+type pointer struct{ p unsafe.Pointer }
+
+// pointerOf returns p as a pointer.
+func pointerOf(p Pointer) pointer {
+	return pointer{p: unsafe.Pointer(p)}
+}
+
+// pointerOfValue returns v as a pointer.
+func pointerOfValue(v reflect.Value) pointer {
+	return pointer{p: unsafe.Pointer(v.Pointer())}
+}
+
+// pointerOfIface returns the pointer portion of an interface.
+func pointerOfIface(v interface{}) pointer {
+	type ifaceHeader struct {
+		Type unsafe.Pointer
+		Data unsafe.Pointer
+	}
+	return pointer{p: (*ifaceHeader)(unsafe.Pointer(&v)).Data}
+}
+
+// IsNil reports whether the pointer is nil.
+func (p pointer) IsNil() bool {
+	return p.p == nil
+}
+
+// Apply adds an offset to the pointer to derive a new pointer
+// to a specified field. The pointer must be valid and pointing at a struct.
+func (p pointer) Apply(f offset) pointer {
+	if p.IsNil() {
+		panic("invalid nil pointer")
+	}
+	return pointer{p: unsafe.Pointer(uintptr(p.p) + uintptr(f))}
+}
+
+// AsValueOf treats p as a pointer to an object of type t and returns the value.
+// It is equivalent to reflect.ValueOf(p.AsIfaceOf(t))
+func (p pointer) AsValueOf(t reflect.Type) reflect.Value {
+	return reflect.NewAt(t, p.p)
+}
+
+// AsIfaceOf treats p as a pointer to an object of type t and returns the value.
+// It is equivalent to p.AsValueOf(t).Interface()
+func (p pointer) AsIfaceOf(t reflect.Type) interface{} {
+	// TODO: Use tricky unsafe magic to directly create ifaceHeader.
+	return p.AsValueOf(t).Interface()
+}
+
+func (p pointer) Bool() *bool                           { return (*bool)(p.p) }
+func (p pointer) BoolPtr() **bool                       { return (**bool)(p.p) }
+func (p pointer) BoolSlice() *[]bool                    { return (*[]bool)(p.p) }
+func (p pointer) Int32() *int32                         { return (*int32)(p.p) }
+func (p pointer) Int32Ptr() **int32                     { return (**int32)(p.p) }
+func (p pointer) Int32Slice() *[]int32                  { return (*[]int32)(p.p) }
+func (p pointer) Int64() *int64                         { return (*int64)(p.p) }
+func (p pointer) Int64Ptr() **int64                     { return (**int64)(p.p) }
+func (p pointer) Int64Slice() *[]int64                  { return (*[]int64)(p.p) }
+func (p pointer) Uint32() *uint32                       { return (*uint32)(p.p) }
+func (p pointer) Uint32Ptr() **uint32                   { return (**uint32)(p.p) }
+func (p pointer) Uint32Slice() *[]uint32                { return (*[]uint32)(p.p) }
+func (p pointer) Uint64() *uint64                       { return (*uint64)(p.p) }
+func (p pointer) Uint64Ptr() **uint64                   { return (**uint64)(p.p) }
+func (p pointer) Uint64Slice() *[]uint64                { return (*[]uint64)(p.p) }
+func (p pointer) Float32() *float32                     { return (*float32)(p.p) }
+func (p pointer) Float32Ptr() **float32                 { return (**float32)(p.p) }
+func (p pointer) Float32Slice() *[]float32              { return (*[]float32)(p.p) }
+func (p pointer) Float64() *float64                     { return (*float64)(p.p) }
+func (p pointer) Float64Ptr() **float64                 { return (**float64)(p.p) }
+func (p pointer) Float64Slice() *[]float64              { return (*[]float64)(p.p) }
+func (p pointer) String() *string                       { return (*string)(p.p) }
+func (p pointer) StringPtr() **string                   { return (**string)(p.p) }
+func (p pointer) StringSlice() *[]string                { return (*[]string)(p.p) }
+func (p pointer) Bytes() *[]byte                        { return (*[]byte)(p.p) }
+func (p pointer) BytesSlice() *[][]byte                 { return (*[][]byte)(p.p) }
+func (p pointer) WeakFields() *weakFields               { return (*weakFields)(p.p) }
+func (p pointer) Extensions() *map[int32]ExtensionField { return (*map[int32]ExtensionField)(p.p) }
+
+func (p pointer) Elem() pointer {
+	return pointer{p: *(*unsafe.Pointer)(p.p)}
+}
+
+// PointerSlice loads []*T from p as a []pointer.
+// The value returned is aliased with the original slice.
+// This behavior differs from the implementation in pointer_reflect.go.
+func (p pointer) PointerSlice() []pointer {
+	// Super-tricky - p should point to a []*T where T is a
+	// message type. We load it as []pointer.
+	return *(*[]pointer)(p.p)
+}
+
+// AppendPointerSlice appends v to p, which must be a []*T.
+func (p pointer) AppendPointerSlice(v pointer) {
+	*(*[]pointer)(p.p) = append(*(*[]pointer)(p.p), v)
+}
+
+// SetPointer sets *p to v.
+func (p pointer) SetPointer(v pointer) {
+	*(*unsafe.Pointer)(p.p) = (unsafe.Pointer)(v.p)
+}
+
+// Static check that MessageState does not exceed the size of a pointer.
+const _ = uint(unsafe.Sizeof(unsafe.Pointer(nil)) - unsafe.Sizeof(MessageState{}))
+
+func (Export) MessageStateOf(p Pointer) *messageState {
+	// Super-tricky - see documentation on MessageState.
+	return (*messageState)(unsafe.Pointer(p))
+}
+func (ms *messageState) pointer() pointer {
+	// Super-tricky - see documentation on MessageState.
+	return pointer{p: unsafe.Pointer(ms)}
+}
+func (ms *messageState) messageInfo() *MessageInfo {
+	mi := ms.LoadMessageInfo()
+	if mi == nil {
+		panic("invalid nil message info; this suggests memory corruption due to a race or shallow copy on the message struct")
+	}
+	return mi
+}
+func (ms *messageState) LoadMessageInfo() *MessageInfo {
+	return (*MessageInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(&ms.atomicMessageInfo))))
+}
+func (ms *messageState) StoreMessageInfo(mi *MessageInfo) {
+	atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(&ms.atomicMessageInfo)), unsafe.Pointer(mi))
+}
+
+type atomicNilMessage struct{ p unsafe.Pointer } // p is a *messageReflectWrapper
+
+func (m *atomicNilMessage) Init(mi *MessageInfo) *messageReflectWrapper {
+	if p := atomic.LoadPointer(&m.p); p != nil {
+		return (*messageReflectWrapper)(p)
+	}
+	w := &messageReflectWrapper{mi: mi}
+	atomic.CompareAndSwapPointer(&m.p, nil, (unsafe.Pointer)(w))
+	return (*messageReflectWrapper)(atomic.LoadPointer(&m.p))
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/validate.go b/vendor/google.golang.org/protobuf/internal/impl/validate.go
new file mode 100644
index 000000000..57de9cc85
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/validate.go
@@ -0,0 +1,575 @@
+// Copyright 2019 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"
+	"math/bits"
+	"reflect"
+	"unicode/utf8"
+
+	"google.golang.org/protobuf/encoding/protowire"
+	"google.golang.org/protobuf/internal/encoding/messageset"
+	"google.golang.org/protobuf/internal/flags"
+	"google.golang.org/protobuf/internal/strs"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+	preg "google.golang.org/protobuf/reflect/protoregistry"
+	piface "google.golang.org/protobuf/runtime/protoiface"
+)
+
+// ValidationStatus is the result of validating the wire-format encoding of a message.
+type ValidationStatus int
+
+const (
+	// ValidationUnknown indicates that unmarshaling the message might succeed or fail.
+	// The validator was unable to render a judgement.
+	//
+	// The only causes of this status are an aberrant message type appearing somewhere
+	// in the message or a failure in the extension resolver.
+	ValidationUnknown ValidationStatus = iota + 1
+
+	// ValidationInvalid indicates that unmarshaling the message will fail.
+	ValidationInvalid
+
+	// ValidationValid indicates that unmarshaling the message will succeed.
+	ValidationValid
+)
+
+func (v ValidationStatus) String() string {
+	switch v {
+	case ValidationUnknown:
+		return "ValidationUnknown"
+	case ValidationInvalid:
+		return "ValidationInvalid"
+	case ValidationValid:
+		return "ValidationValid"
+	default:
+		return fmt.Sprintf("ValidationStatus(%d)", int(v))
+	}
+}
+
+// Validate determines whether the contents of the buffer are a valid wire encoding
+// of the message type.
+//
+// This function is exposed for testing.
+func Validate(mt pref.MessageType, in piface.UnmarshalInput) (out piface.UnmarshalOutput, _ ValidationStatus) {
+	mi, ok := mt.(*MessageInfo)
+	if !ok {
+		return out, ValidationUnknown
+	}
+	if in.Resolver == nil {
+		in.Resolver = preg.GlobalTypes
+	}
+	o, st := mi.validate(in.Buf, 0, unmarshalOptions{
+		flags:    in.Flags,
+		resolver: in.Resolver,
+	})
+	if o.initialized {
+		out.Flags |= piface.UnmarshalInitialized
+	}
+	return out, st
+}
+
+type validationInfo struct {
+	mi               *MessageInfo
+	typ              validationType
+	keyType, valType validationType
+
+	// For non-required fields, requiredBit is 0.
+	//
+	// For required fields, requiredBit's nth bit is set, where n is a
+	// unique index in the range [0, MessageInfo.numRequiredFields).
+	//
+	// If there are more than 64 required fields, requiredBit is 0.
+	requiredBit uint64
+}
+
+type validationType uint8
+
+const (
+	validationTypeOther validationType = iota
+	validationTypeMessage
+	validationTypeGroup
+	validationTypeMap
+	validationTypeRepeatedVarint
+	validationTypeRepeatedFixed32
+	validationTypeRepeatedFixed64
+	validationTypeVarint
+	validationTypeFixed32
+	validationTypeFixed64
+	validationTypeBytes
+	validationTypeUTF8String
+	validationTypeMessageSetItem
+)
+
+func newFieldValidationInfo(mi *MessageInfo, si structInfo, fd pref.FieldDescriptor, ft reflect.Type) validationInfo {
+	var vi validationInfo
+	switch {
+	case fd.ContainingOneof() != nil && !fd.ContainingOneof().IsSynthetic():
+		switch fd.Kind() {
+		case pref.MessageKind:
+			vi.typ = validationTypeMessage
+			if ot, ok := si.oneofWrappersByNumber[fd.Number()]; ok {
+				vi.mi = getMessageInfo(ot.Field(0).Type)
+			}
+		case pref.GroupKind:
+			vi.typ = validationTypeGroup
+			if ot, ok := si.oneofWrappersByNumber[fd.Number()]; ok {
+				vi.mi = getMessageInfo(ot.Field(0).Type)
+			}
+		case pref.StringKind:
+			if strs.EnforceUTF8(fd) {
+				vi.typ = validationTypeUTF8String
+			}
+		}
+	default:
+		vi = newValidationInfo(fd, ft)
+	}
+	if fd.Cardinality() == pref.Required {
+		// Avoid overflow. The required field check is done with a 64-bit mask, with
+		// any message containing more than 64 required fields always reported as
+		// potentially uninitialized, so it is not important to get a precise count
+		// of the required fields past 64.
+		if mi.numRequiredFields < math.MaxUint8 {
+			mi.numRequiredFields++
+			vi.requiredBit = 1 << (mi.numRequiredFields - 1)
+		}
+	}
+	return vi
+}
+
+func newValidationInfo(fd pref.FieldDescriptor, ft reflect.Type) validationInfo {
+	var vi validationInfo
+	switch {
+	case fd.IsList():
+		switch fd.Kind() {
+		case pref.MessageKind:
+			vi.typ = validationTypeMessage
+			if ft.Kind() == reflect.Slice {
+				vi.mi = getMessageInfo(ft.Elem())
+			}
+		case pref.GroupKind:
+			vi.typ = validationTypeGroup
+			if ft.Kind() == reflect.Slice {
+				vi.mi = getMessageInfo(ft.Elem())
+			}
+		case pref.StringKind:
+			vi.typ = validationTypeBytes
+			if strs.EnforceUTF8(fd) {
+				vi.typ = validationTypeUTF8String
+			}
+		default:
+			switch wireTypes[fd.Kind()] {
+			case protowire.VarintType:
+				vi.typ = validationTypeRepeatedVarint
+			case protowire.Fixed32Type:
+				vi.typ = validationTypeRepeatedFixed32
+			case protowire.Fixed64Type:
+				vi.typ = validationTypeRepeatedFixed64
+			}
+		}
+	case fd.IsMap():
+		vi.typ = validationTypeMap
+		switch fd.MapKey().Kind() {
+		case pref.StringKind:
+			if strs.EnforceUTF8(fd) {
+				vi.keyType = validationTypeUTF8String
+			}
+		}
+		switch fd.MapValue().Kind() {
+		case pref.MessageKind:
+			vi.valType = validationTypeMessage
+			if ft.Kind() == reflect.Map {
+				vi.mi = getMessageInfo(ft.Elem())
+			}
+		case pref.StringKind:
+			if strs.EnforceUTF8(fd) {
+				vi.valType = validationTypeUTF8String
+			}
+		}
+	default:
+		switch fd.Kind() {
+		case pref.MessageKind:
+			vi.typ = validationTypeMessage
+			if !fd.IsWeak() {
+				vi.mi = getMessageInfo(ft)
+			}
+		case pref.GroupKind:
+			vi.typ = validationTypeGroup
+			vi.mi = getMessageInfo(ft)
+		case pref.StringKind:
+			vi.typ = validationTypeBytes
+			if strs.EnforceUTF8(fd) {
+				vi.typ = validationTypeUTF8String
+			}
+		default:
+			switch wireTypes[fd.Kind()] {
+			case protowire.VarintType:
+				vi.typ = validationTypeVarint
+			case protowire.Fixed32Type:
+				vi.typ = validationTypeFixed32
+			case protowire.Fixed64Type:
+				vi.typ = validationTypeFixed64
+			case protowire.BytesType:
+				vi.typ = validationTypeBytes
+			}
+		}
+	}
+	return vi
+}
+
+func (mi *MessageInfo) validate(b []byte, groupTag protowire.Number, opts unmarshalOptions) (out unmarshalOutput, result ValidationStatus) {
+	mi.init()
+	type validationState struct {
+		typ              validationType
+		keyType, valType validationType
+		endGroup         protowire.Number
+		mi               *MessageInfo
+		tail             []byte
+		requiredMask     uint64
+	}
+
+	// Pre-allocate some slots to avoid repeated slice reallocation.
+	states := make([]validationState, 0, 16)
+	states = append(states, validationState{
+		typ: validationTypeMessage,
+		mi:  mi,
+	})
+	if groupTag > 0 {
+		states[0].typ = validationTypeGroup
+		states[0].endGroup = groupTag
+	}
+	initialized := true
+	start := len(b)
+State:
+	for len(states) > 0 {
+		st := &states[len(states)-1]
+		for len(b) > 0 {
+			// Parse the tag (field number and wire type).
+			var tag uint64
+			if b[0] < 0x80 {
+				tag = uint64(b[0])
+				b = b[1:]
+			} else if len(b) >= 2 && b[1] < 128 {
+				tag = uint64(b[0]&0x7f) + uint64(b[1])<<7
+				b = b[2:]
+			} else {
+				var n int
+				tag, n = protowire.ConsumeVarint(b)
+				if n < 0 {
+					return out, ValidationInvalid
+				}
+				b = b[n:]
+			}
+			var num protowire.Number
+			if n := tag >> 3; n < uint64(protowire.MinValidNumber) || n > uint64(protowire.MaxValidNumber) {
+				return out, ValidationInvalid
+			} else {
+				num = protowire.Number(n)
+			}
+			wtyp := protowire.Type(tag & 7)
+
+			if wtyp == protowire.EndGroupType {
+				if st.endGroup == num {
+					goto PopState
+				}
+				return out, ValidationInvalid
+			}
+			var vi validationInfo
+			switch {
+			case st.typ == validationTypeMap:
+				switch num {
+				case 1:
+					vi.typ = st.keyType
+				case 2:
+					vi.typ = st.valType
+					vi.mi = st.mi
+					vi.requiredBit = 1
+				}
+			case flags.ProtoLegacy && st.mi.isMessageSet:
+				switch num {
+				case messageset.FieldItem:
+					vi.typ = validationTypeMessageSetItem
+				}
+			default:
+				var f *coderFieldInfo
+				if int(num) < len(st.mi.denseCoderFields) {
+					f = st.mi.denseCoderFields[num]
+				} else {
+					f = st.mi.coderFields[num]
+				}
+				if f != nil {
+					vi = f.validation
+					if vi.typ == validationTypeMessage && vi.mi == nil {
+						// Probable weak field.
+						//
+						// TODO: Consider storing the results of this lookup somewhere
+						// rather than recomputing it on every validation.
+						fd := st.mi.Desc.Fields().ByNumber(num)
+						if fd == nil || !fd.IsWeak() {
+							break
+						}
+						messageName := fd.Message().FullName()
+						messageType, err := preg.GlobalTypes.FindMessageByName(messageName)
+						switch err {
+						case nil:
+							vi.mi, _ = messageType.(*MessageInfo)
+						case preg.NotFound:
+							vi.typ = validationTypeBytes
+						default:
+							return out, ValidationUnknown
+						}
+					}
+					break
+				}
+				// Possible extension field.
+				//
+				// TODO: We should return ValidationUnknown when:
+				//   1. The resolver is not frozen. (More extensions may be added to it.)
+				//   2. The resolver returns preg.NotFound.
+				// In this case, a type added to the resolver in the future could cause
+				// unmarshaling to begin failing. Supporting this requires some way to
+				// determine if the resolver is frozen.
+				xt, err := opts.resolver.FindExtensionByNumber(st.mi.Desc.FullName(), num)
+				if err != nil && err != preg.NotFound {
+					return out, ValidationUnknown
+				}
+				if err == nil {
+					vi = getExtensionFieldInfo(xt).validation
+				}
+			}
+			if vi.requiredBit != 0 {
+				// Check that the field has a compatible wire type.
+				// We only need to consider non-repeated field types,
+				// since repeated fields (and maps) can never be required.
+				ok := false
+				switch vi.typ {
+				case validationTypeVarint:
+					ok = wtyp == protowire.VarintType
+				case validationTypeFixed32:
+					ok = wtyp == protowire.Fixed32Type
+				case validationTypeFixed64:
+					ok = wtyp == protowire.Fixed64Type
+				case validationTypeBytes, validationTypeUTF8String, validationTypeMessage:
+					ok = wtyp == protowire.BytesType
+				case validationTypeGroup:
+					ok = wtyp == protowire.StartGroupType
+				}
+				if ok {
+					st.requiredMask |= vi.requiredBit
+				}
+			}
+
+			switch wtyp {
+			case protowire.VarintType:
+				if len(b) >= 10 {
+					switch {
+					case b[0] < 0x80:
+						b = b[1:]
+					case b[1] < 0x80:
+						b = b[2:]
+					case b[2] < 0x80:
+						b = b[3:]
+					case b[3] < 0x80:
+						b = b[4:]
+					case b[4] < 0x80:
+						b = b[5:]
+					case b[5] < 0x80:
+						b = b[6:]
+					case b[6] < 0x80:
+						b = b[7:]
+					case b[7] < 0x80:
+						b = b[8:]
+					case b[8] < 0x80:
+						b = b[9:]
+					case b[9] < 0x80 && b[9] < 2:
+						b = b[10:]
+					default:
+						return out, ValidationInvalid
+					}
+				} else {
+					switch {
+					case len(b) > 0 && b[0] < 0x80:
+						b = b[1:]
+					case len(b) > 1 && b[1] < 0x80:
+						b = b[2:]
+					case len(b) > 2 && b[2] < 0x80:
+						b = b[3:]
+					case len(b) > 3 && b[3] < 0x80:
+						b = b[4:]
+					case len(b) > 4 && b[4] < 0x80:
+						b = b[5:]
+					case len(b) > 5 && b[5] < 0x80:
+						b = b[6:]
+					case len(b) > 6 && b[6] < 0x80:
+						b = b[7:]
+					case len(b) > 7 && b[7] < 0x80:
+						b = b[8:]
+					case len(b) > 8 && b[8] < 0x80:
+						b = b[9:]
+					case len(b) > 9 && b[9] < 2:
+						b = b[10:]
+					default:
+						return out, ValidationInvalid
+					}
+				}
+				continue State
+			case protowire.BytesType:
+				var size uint64
+				if len(b) >= 1 && b[0] < 0x80 {
+					size = uint64(b[0])
+					b = b[1:]
+				} else if len(b) >= 2 && b[1] < 128 {
+					size = uint64(b[0]&0x7f) + uint64(b[1])<<7
+					b = b[2:]
+				} else {
+					var n int
+					size, n = protowire.ConsumeVarint(b)
+					if n < 0 {
+						return out, ValidationInvalid
+					}
+					b = b[n:]
+				}
+				if size > uint64(len(b)) {
+					return out, ValidationInvalid
+				}
+				v := b[:size]
+				b = b[size:]
+				switch vi.typ {
+				case validationTypeMessage:
+					if vi.mi == nil {
+						return out, ValidationUnknown
+					}
+					vi.mi.init()
+					fallthrough
+				case validationTypeMap:
+					if vi.mi != nil {
+						vi.mi.init()
+					}
+					states = append(states, validationState{
+						typ:     vi.typ,
+						keyType: vi.keyType,
+						valType: vi.valType,
+						mi:      vi.mi,
+						tail:    b,
+					})
+					b = v
+					continue State
+				case validationTypeRepeatedVarint:
+					// Packed field.
+					for len(v) > 0 {
+						_, n := protowire.ConsumeVarint(v)
+						if n < 0 {
+							return out, ValidationInvalid
+						}
+						v = v[n:]
+					}
+				case validationTypeRepeatedFixed32:
+					// Packed field.
+					if len(v)%4 != 0 {
+						return out, ValidationInvalid
+					}
+				case validationTypeRepeatedFixed64:
+					// Packed field.
+					if len(v)%8 != 0 {
+						return out, ValidationInvalid
+					}
+				case validationTypeUTF8String:
+					if !utf8.Valid(v) {
+						return out, ValidationInvalid
+					}
+				}
+			case protowire.Fixed32Type:
+				if len(b) < 4 {
+					return out, ValidationInvalid
+				}
+				b = b[4:]
+			case protowire.Fixed64Type:
+				if len(b) < 8 {
+					return out, ValidationInvalid
+				}
+				b = b[8:]
+			case protowire.StartGroupType:
+				switch {
+				case vi.typ == validationTypeGroup:
+					if vi.mi == nil {
+						return out, ValidationUnknown
+					}
+					vi.mi.init()
+					states = append(states, validationState{
+						typ:      validationTypeGroup,
+						mi:       vi.mi,
+						endGroup: num,
+					})
+					continue State
+				case flags.ProtoLegacy && vi.typ == validationTypeMessageSetItem:
+					typeid, v, n, err := messageset.ConsumeFieldValue(b, false)
+					if err != nil {
+						return out, ValidationInvalid
+					}
+					xt, err := opts.resolver.FindExtensionByNumber(st.mi.Desc.FullName(), typeid)
+					switch {
+					case err == preg.NotFound:
+						b = b[n:]
+					case err != nil:
+						return out, ValidationUnknown
+					default:
+						xvi := getExtensionFieldInfo(xt).validation
+						if xvi.mi != nil {
+							xvi.mi.init()
+						}
+						states = append(states, validationState{
+							typ:  xvi.typ,
+							mi:   xvi.mi,
+							tail: b[n:],
+						})
+						b = v
+						continue State
+					}
+				default:
+					n := protowire.ConsumeFieldValue(num, wtyp, b)
+					if n < 0 {
+						return out, ValidationInvalid
+					}
+					b = b[n:]
+				}
+			default:
+				return out, ValidationInvalid
+			}
+		}
+		if st.endGroup != 0 {
+			return out, ValidationInvalid
+		}
+		if len(b) != 0 {
+			return out, ValidationInvalid
+		}
+		b = st.tail
+	PopState:
+		numRequiredFields := 0
+		switch st.typ {
+		case validationTypeMessage, validationTypeGroup:
+			numRequiredFields = int(st.mi.numRequiredFields)
+		case validationTypeMap:
+			// If this is a map field with a message value that contains
+			// required fields, require that the value be present.
+			if st.mi != nil && st.mi.numRequiredFields > 0 {
+				numRequiredFields = 1
+			}
+		}
+		// If there are more than 64 required fields, this check will
+		// always fail and we will report that the message is potentially
+		// uninitialized.
+		if numRequiredFields > 0 && bits.OnesCount64(st.requiredMask) != numRequiredFields {
+			initialized = false
+		}
+		states = states[:len(states)-1]
+	}
+	out.n = start - len(b)
+	if initialized {
+		out.initialized = true
+	}
+	return out, ValidationValid
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/weak.go b/vendor/google.golang.org/protobuf/internal/impl/weak.go
new file mode 100644
index 000000000..009cbefd1
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/weak.go
@@ -0,0 +1,74 @@
+// Copyright 2019 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"
+
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/reflect/protoregistry"
+)
+
+// weakFields adds methods to the exported WeakFields type for internal use.
+//
+// The exported type is an alias to an unnamed type, so methods can't be
+// defined directly on it.
+type weakFields WeakFields
+
+func (w weakFields) get(num pref.FieldNumber) (pref.ProtoMessage, bool) {
+	m, ok := w[int32(num)]
+	return m, ok
+}
+
+func (w *weakFields) set(num pref.FieldNumber, m pref.ProtoMessage) {
+	if *w == nil {
+		*w = make(weakFields)
+	}
+	(*w)[int32(num)] = m
+}
+
+func (w *weakFields) clear(num pref.FieldNumber) {
+	delete(*w, int32(num))
+}
+
+func (Export) HasWeak(w WeakFields, num pref.FieldNumber) bool {
+	_, ok := w[int32(num)]
+	return ok
+}
+
+func (Export) ClearWeak(w *WeakFields, num pref.FieldNumber) {
+	delete(*w, int32(num))
+}
+
+func (Export) GetWeak(w WeakFields, num pref.FieldNumber, name pref.FullName) pref.ProtoMessage {
+	if m, ok := w[int32(num)]; ok {
+		return m
+	}
+	mt, _ := protoregistry.GlobalTypes.FindMessageByName(name)
+	if mt == nil {
+		panic(fmt.Sprintf("message %v for weak field is not linked in", name))
+	}
+	return mt.Zero().Interface()
+}
+
+func (Export) SetWeak(w *WeakFields, num pref.FieldNumber, name pref.FullName, m pref.ProtoMessage) {
+	if m != nil {
+		mt, _ := protoregistry.GlobalTypes.FindMessageByName(name)
+		if mt == nil {
+			panic(fmt.Sprintf("message %v for weak field is not linked in", name))
+		}
+		if mt != m.ProtoReflect().Type() {
+			panic(fmt.Sprintf("invalid message type for weak field: got %T, want %T", m, mt.Zero().Interface()))
+		}
+	}
+	if m == nil || !m.ProtoReflect().IsValid() {
+		delete(*w, int32(num))
+		return
+	}
+	if *w == nil {
+		*w = make(weakFields)
+	}
+	(*w)[int32(num)] = m
+}
diff --git a/vendor/google.golang.org/protobuf/internal/mapsort/mapsort.go b/vendor/google.golang.org/protobuf/internal/mapsort/mapsort.go
new file mode 100644
index 000000000..a3de1cf32
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/mapsort/mapsort.go
@@ -0,0 +1,43 @@
+// Copyright 2019 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 mapsort provides sorted access to maps.
+package mapsort
+
+import (
+	"sort"
+
+	"google.golang.org/protobuf/reflect/protoreflect"
+)
+
+// Range iterates over every map entry in sorted key order,
+// calling f for each key and value encountered.
+func Range(mapv protoreflect.Map, keyKind protoreflect.Kind, f func(protoreflect.MapKey, protoreflect.Value) bool) {
+	var keys []protoreflect.MapKey
+	mapv.Range(func(key protoreflect.MapKey, _ protoreflect.Value) bool {
+		keys = append(keys, key)
+		return true
+	})
+	sort.Slice(keys, func(i, j int) bool {
+		switch keyKind {
+		case protoreflect.BoolKind:
+			return !keys[i].Bool() && keys[j].Bool()
+		case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind,
+			protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
+			return keys[i].Int() < keys[j].Int()
+		case protoreflect.Uint32Kind, protoreflect.Fixed32Kind,
+			protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
+			return keys[i].Uint() < keys[j].Uint()
+		case protoreflect.StringKind:
+			return keys[i].String() < keys[j].String()
+		default:
+			panic("invalid kind: " + keyKind.String())
+		}
+	})
+	for _, key := range keys {
+		if !f(key, mapv.Get(key)) {
+			break
+		}
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/mapsort/mapsort_test.go b/vendor/google.golang.org/protobuf/internal/mapsort/mapsort_test.go
new file mode 100644
index 000000000..6d1794601
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/mapsort/mapsort_test.go
@@ -0,0 +1,69 @@
+// Copyright 2019 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 mapsort_test
+
+import (
+	"strconv"
+	"testing"
+
+	"google.golang.org/protobuf/internal/mapsort"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+
+	testpb "google.golang.org/protobuf/internal/testprotos/test"
+)
+
+func TestRange(t *testing.T) {
+	m := (&testpb.TestAllTypes{
+		MapBoolBool: map[bool]bool{
+			false: false,
+			true:  true,
+		},
+		MapInt32Int32: map[int32]int32{
+			0: 0,
+			1: 1,
+			2: 2,
+		},
+		MapUint64Uint64: map[uint64]uint64{
+			0: 0,
+			1: 1,
+			2: 2,
+		},
+		MapStringString: map[string]string{
+			"0": "0",
+			"1": "1",
+			"2": "2",
+		},
+	}).ProtoReflect()
+	m.Range(func(fd pref.FieldDescriptor, v pref.Value) bool {
+		mapv := v.Map()
+		var got []pref.MapKey
+		mapsort.Range(mapv, fd.MapKey().Kind(), func(key pref.MapKey, _ pref.Value) bool {
+			got = append(got, key)
+			return true
+		})
+		for wanti, key := range got {
+			var goti int
+			switch x := mapv.Get(key).Interface().(type) {
+			case bool:
+				if x {
+					goti = 1
+				}
+			case int32:
+				goti = int(x)
+			case uint64:
+				goti = int(x)
+			case string:
+				goti, _ = strconv.Atoi(x)
+			default:
+				t.Fatalf("unhandled map value type %T", x)
+			}
+			if wanti != goti {
+				t.Errorf("out of order range over map field %v: %v", fd.FullName(), got)
+				break
+			}
+		}
+		return true
+	})
+}
diff --git a/vendor/google.golang.org/protobuf/internal/msgfmt/format.go b/vendor/google.golang.org/protobuf/internal/msgfmt/format.go
new file mode 100644
index 000000000..c2c856fb3
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/msgfmt/format.go
@@ -0,0 +1,267 @@
+// Copyright 2019 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 msgfmt implements a text marshaler combining the desirable features
+// of both the JSON and proto text formats.
+// It is optimized for human readability and has no associated deserializer.
+package msgfmt
+
+import (
+	"bytes"
+	"fmt"
+	"math"
+	"reflect"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"google.golang.org/protobuf/encoding/protowire"
+	"google.golang.org/protobuf/internal/detectknown"
+	"google.golang.org/protobuf/internal/detrand"
+	"google.golang.org/protobuf/internal/mapsort"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/reflect/protoregistry"
+)
+
+// Format returns a formatted string for the message.
+func Format(m proto.Message) string {
+	return string(appendMessage(nil, m.ProtoReflect()))
+}
+
+func appendValue(b []byte, v protoreflect.Value, fd protoreflect.FieldDescriptor) []byte {
+	switch v := v.Interface().(type) {
+	case bool, int32, int64, uint32, uint64, float32, float64:
+		return append(b, fmt.Sprint(v)...)
+	case string:
+		return append(b, strconv.Quote(string(v))...)
+	case []byte:
+		return append(b, strconv.Quote(string(v))...)
+	case protoreflect.EnumNumber:
+		return appendEnum(b, v, fd.Enum())
+	case protoreflect.Message:
+		return appendMessage(b, v)
+	case protoreflect.List:
+		return appendList(b, v, fd)
+	case protoreflect.Map:
+		return appendMap(b, v, fd)
+	default:
+		panic(fmt.Sprintf("invalid type: %T", v))
+	}
+}
+
+func appendEnum(b []byte, v protoreflect.EnumNumber, ed protoreflect.EnumDescriptor) []byte {
+	if ev := ed.Values().ByNumber(v); ev != nil {
+		return append(b, ev.Name()...)
+	}
+	return strconv.AppendInt(b, int64(v), 10)
+}
+
+func appendMessage(b []byte, m protoreflect.Message) []byte {
+	if b2 := appendKnownMessage(b, m); b2 != nil {
+		return b2
+	}
+
+	var fds []protoreflect.FieldDescriptor
+	m.Range(func(fd protoreflect.FieldDescriptor, _ protoreflect.Value) bool {
+		fds = append(fds, fd)
+		return true
+	})
+	sort.Slice(fds, func(i, j int) bool {
+		fdi, fdj := fds[i], fds[j]
+		switch {
+		case !fdi.IsExtension() && !fdj.IsExtension():
+			return fdi.Index() < fdj.Index()
+		case fdi.IsExtension() && fdj.IsExtension():
+			return fdi.FullName() < fdj.FullName()
+		default:
+			return !fdi.IsExtension() && fdj.IsExtension()
+		}
+	})
+
+	b = append(b, '{')
+	for _, fd := range fds {
+		k := string(fd.Name())
+		if fd.IsExtension() {
+			k = string("[" + fd.FullName() + "]")
+		}
+
+		b = append(b, k...)
+		b = append(b, ':')
+		b = appendValue(b, m.Get(fd), fd)
+		b = append(b, delim()...)
+	}
+	b = appendUnknown(b, m.GetUnknown())
+	b = bytes.TrimRight(b, delim())
+	b = append(b, '}')
+	return b
+}
+
+var protocmpMessageType = reflect.TypeOf(map[string]interface{}(nil))
+
+func appendKnownMessage(b []byte, m protoreflect.Message) []byte {
+	md := m.Descriptor()
+	fds := md.Fields()
+	switch detectknown.Which(md.FullName()) {
+	case detectknown.AnyProto:
+		var msgVal protoreflect.Message
+		url := m.Get(fds.ByName("type_url")).String()
+		if v := reflect.ValueOf(m); v.Type().ConvertibleTo(protocmpMessageType) {
+			// For protocmp.Message, directly obtain the sub-message value
+			// which is stored in structured form, rather than as raw bytes.
+			m2 := v.Convert(protocmpMessageType).Interface().(map[string]interface{})
+			v, ok := m2["value"].(proto.Message)
+			if !ok {
+				return nil
+			}
+			msgVal = v.ProtoReflect()
+		} else {
+			val := m.Get(fds.ByName("value")).Bytes()
+			mt, err := protoregistry.GlobalTypes.FindMessageByURL(url)
+			if err != nil {
+				return nil
+			}
+			msgVal = mt.New()
+			err = proto.UnmarshalOptions{AllowPartial: true}.Unmarshal(val, msgVal.Interface())
+			if err != nil {
+				return nil
+			}
+		}
+
+		b = append(b, '{')
+		b = append(b, "["+url+"]"...)
+		b = append(b, ':')
+		b = appendMessage(b, msgVal)
+		b = append(b, '}')
+		return b
+
+	case detectknown.TimestampProto:
+		secs := m.Get(fds.ByName("seconds")).Int()
+		nanos := m.Get(fds.ByName("nanos")).Int()
+		if nanos < 0 || nanos >= 1e9 {
+			return nil
+		}
+		t := time.Unix(secs, nanos).UTC()
+		x := t.Format("2006-01-02T15:04:05.000000000") // RFC 3339
+		x = strings.TrimSuffix(x, "000")
+		x = strings.TrimSuffix(x, "000")
+		x = strings.TrimSuffix(x, ".000")
+		return append(b, x+"Z"...)
+
+	case detectknown.DurationProto:
+		secs := m.Get(fds.ByName("seconds")).Int()
+		nanos := m.Get(fds.ByName("nanos")).Int()
+		if nanos <= -1e9 || nanos >= 1e9 || (secs > 0 && nanos < 0) || (secs < 0 && nanos > 0) {
+			return nil
+		}
+		x := fmt.Sprintf("%d.%09d", secs, int64(math.Abs(float64(nanos))))
+		x = strings.TrimSuffix(x, "000")
+		x = strings.TrimSuffix(x, "000")
+		x = strings.TrimSuffix(x, ".000")
+		return append(b, x+"s"...)
+
+	case detectknown.WrappersProto:
+		fd := fds.ByName("value")
+		return appendValue(b, m.Get(fd), fd)
+	}
+
+	return nil
+}
+
+func appendUnknown(b []byte, raw protoreflect.RawFields) []byte {
+	rs := make(map[protoreflect.FieldNumber][]protoreflect.RawFields)
+	for len(raw) > 0 {
+		num, _, n := protowire.ConsumeField(raw)
+		rs[num] = append(rs[num], raw[:n])
+		raw = raw[n:]
+	}
+
+	var ns []protoreflect.FieldNumber
+	for n := range rs {
+		ns = append(ns, n)
+	}
+	sort.Slice(ns, func(i, j int) bool { return ns[i] < ns[j] })
+
+	for _, n := range ns {
+		var leftBracket, rightBracket string
+		if len(rs[n]) > 1 {
+			leftBracket, rightBracket = "[", "]"
+		}
+
+		b = strconv.AppendInt(b, int64(n), 10)
+		b = append(b, ':')
+		b = append(b, leftBracket...)
+		for _, r := range rs[n] {
+			num, typ, n := protowire.ConsumeTag(r)
+			r = r[n:]
+			switch typ {
+			case protowire.VarintType:
+				v, _ := protowire.ConsumeVarint(r)
+				b = strconv.AppendInt(b, int64(v), 10)
+			case protowire.Fixed32Type:
+				v, _ := protowire.ConsumeFixed32(r)
+				b = append(b, fmt.Sprintf("0x%08x", v)...)
+			case protowire.Fixed64Type:
+				v, _ := protowire.ConsumeFixed64(r)
+				b = append(b, fmt.Sprintf("0x%016x", v)...)
+			case protowire.BytesType:
+				v, _ := protowire.ConsumeBytes(r)
+				b = strconv.AppendQuote(b, string(v))
+			case protowire.StartGroupType:
+				v, _ := protowire.ConsumeGroup(num, r)
+				b = append(b, '{')
+				b = appendUnknown(b, v)
+				b = bytes.TrimRight(b, delim())
+				b = append(b, '}')
+			default:
+				panic(fmt.Sprintf("invalid type: %v", typ))
+			}
+			b = append(b, delim()...)
+		}
+		b = bytes.TrimRight(b, delim())
+		b = append(b, rightBracket...)
+		b = append(b, delim()...)
+	}
+	return b
+}
+
+func appendList(b []byte, v protoreflect.List, fd protoreflect.FieldDescriptor) []byte {
+	b = append(b, '[')
+	for i := 0; i < v.Len(); i++ {
+		b = appendValue(b, v.Get(i), fd)
+		b = append(b, delim()...)
+	}
+	b = bytes.TrimRight(b, delim())
+	b = append(b, ']')
+	return b
+}
+
+func appendMap(b []byte, v protoreflect.Map, fd protoreflect.FieldDescriptor) []byte {
+	var ks []protoreflect.MapKey
+	mapsort.Range(v, fd.MapKey().Kind(), func(k protoreflect.MapKey, _ protoreflect.Value) bool {
+		ks = append(ks, k)
+		return true
+	})
+
+	b = append(b, '{')
+	for _, k := range ks {
+		b = appendValue(b, k.Value(), fd.MapKey())
+		b = append(b, ':')
+		b = appendValue(b, v.Get(k), fd.MapValue())
+		b = append(b, delim()...)
+	}
+	b = bytes.TrimRight(b, delim())
+	b = append(b, '}')
+	return b
+}
+
+func delim() string {
+	// Deliberately introduce instability into the message string to
+	// discourage users from depending on it.
+	if detrand.Bool() {
+		return "  "
+	}
+	return ", "
+}
diff --git a/vendor/google.golang.org/protobuf/internal/msgfmt/format_test.go b/vendor/google.golang.org/protobuf/internal/msgfmt/format_test.go
new file mode 100644
index 000000000..6136d0edd
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/msgfmt/format_test.go
@@ -0,0 +1,249 @@
+// Copyright 2020 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 msgfmt_test
+
+import (
+	"math"
+	"sync"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+
+	"google.golang.org/protobuf/internal/detrand"
+	"google.golang.org/protobuf/internal/msgfmt"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/testing/protocmp"
+	"google.golang.org/protobuf/testing/protopack"
+
+	testpb "google.golang.org/protobuf/internal/testprotos/test"
+	textpb "google.golang.org/protobuf/internal/testprotos/textpb2"
+	dynpb "google.golang.org/protobuf/types/dynamicpb"
+	anypb "google.golang.org/protobuf/types/known/anypb"
+	durpb "google.golang.org/protobuf/types/known/durationpb"
+	tspb "google.golang.org/protobuf/types/known/timestamppb"
+	wpb "google.golang.org/protobuf/types/known/wrapperspb"
+)
+
+func init() {
+	detrand.Disable()
+}
+
+func TestFormat(t *testing.T) {
+	optMsg := &testpb.TestAllTypes{
+		OptionalBool:          proto.Bool(false),
+		OptionalInt32:         proto.Int32(-32),
+		OptionalInt64:         proto.Int64(-64),
+		OptionalUint32:        proto.Uint32(32),
+		OptionalUint64:        proto.Uint64(64),
+		OptionalFloat:         proto.Float32(32.32),
+		OptionalDouble:        proto.Float64(64.64),
+		OptionalString:        proto.String("string"),
+		OptionalBytes:         []byte("bytes"),
+		OptionalNestedEnum:    testpb.TestAllTypes_NEG.Enum(),
+		OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{A: proto.Int32(5)},
+	}
+	repMsg := &testpb.TestAllTypes{
+		RepeatedBool:   []bool{false, true},
+		RepeatedInt32:  []int32{32, -32},
+		RepeatedInt64:  []int64{64, -64},
+		RepeatedUint32: []uint32{0, 32},
+		RepeatedUint64: []uint64{0, 64},
+		RepeatedFloat:  []float32{0, 32.32},
+		RepeatedDouble: []float64{0, 64.64},
+		RepeatedString: []string{"s1", "s2"},
+		RepeatedBytes:  [][]byte{{1}, {2}},
+		RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{
+			testpb.TestAllTypes_FOO,
+			testpb.TestAllTypes_BAR,
+		},
+		RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{
+			{A: proto.Int32(5)},
+			{A: proto.Int32(-5)},
+		},
+	}
+	mapMsg := &testpb.TestAllTypes{
+		MapBoolBool:     map[bool]bool{true: false},
+		MapInt32Int32:   map[int32]int32{-32: 32},
+		MapInt64Int64:   map[int64]int64{-64: 64},
+		MapUint32Uint32: map[uint32]uint32{0: 32},
+		MapUint64Uint64: map[uint64]uint64{0: 64},
+		MapInt32Float:   map[int32]float32{32: 32.32},
+		MapInt32Double:  map[int32]float64{64: 64.64},
+		MapStringString: map[string]string{"k": "v"},
+		MapStringBytes:  map[string][]byte{"k": []byte("v")},
+		MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{
+			"k": testpb.TestAllTypes_FOO,
+		},
+		MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{
+			"k": {A: proto.Int32(5)},
+		},
+	}
+
+	tests := []struct {
+		in   proto.Message
+		want string
+	}{{
+		in:   optMsg,
+		want: `{optional_int32:-32, optional_int64:-64, optional_uint32:32, optional_uint64:64, optional_float:32.32, optional_double:64.64, optional_bool:false, optional_string:"string", optional_bytes:"bytes", optional_nested_message:{a:5}, optional_nested_enum:NEG}`,
+	}, {
+		in:   repMsg,
+		want: `{repeated_int32:[32, -32], repeated_int64:[64, -64], repeated_uint32:[0, 32], repeated_uint64:[0, 64], repeated_float:[0, 32.32], repeated_double:[0, 64.64], repeated_bool:[false, true], repeated_string:["s1", "s2"], repeated_bytes:["\x01", "\x02"], repeated_nested_message:[{a:5}, {a:-5}], repeated_nested_enum:[FOO, BAR]}`,
+	}, {
+		in:   mapMsg,
+		want: `{map_int32_int32:{-32:32}, map_int64_int64:{-64:64}, map_uint32_uint32:{0:32}, map_uint64_uint64:{0:64}, map_int32_float:{32:32.32}, map_int32_double:{64:64.64}, map_bool_bool:{true:false}, map_string_string:{"k":"v"}, map_string_bytes:{"k":"v"}, map_string_nested_message:{"k":{a:5}}, map_string_nested_enum:{"k":FOO}}`,
+	}, {
+		in: func() proto.Message {
+			m := &testpb.TestAllExtensions{}
+			proto.SetExtension(m, testpb.E_OptionalBool, bool(false))
+			proto.SetExtension(m, testpb.E_OptionalInt32, int32(-32))
+			proto.SetExtension(m, testpb.E_OptionalInt64, int64(-64))
+			proto.SetExtension(m, testpb.E_OptionalUint32, uint32(32))
+			proto.SetExtension(m, testpb.E_OptionalUint64, uint64(64))
+			proto.SetExtension(m, testpb.E_OptionalFloat, float32(32.32))
+			proto.SetExtension(m, testpb.E_OptionalDouble, float64(64.64))
+			proto.SetExtension(m, testpb.E_OptionalString, string("string"))
+			proto.SetExtension(m, testpb.E_OptionalBytes, []byte("bytes"))
+			proto.SetExtension(m, testpb.E_OptionalNestedEnum, testpb.TestAllTypes_NEG)
+			proto.SetExtension(m, testpb.E_OptionalNestedMessage, &testpb.TestAllExtensions_NestedMessage{A: proto.Int32(5)})
+			return m
+		}(),
+		want: `{[goproto.proto.test.optional_bool]:false, [goproto.proto.test.optional_bytes]:"bytes", [goproto.proto.test.optional_double]:64.64, [goproto.proto.test.optional_float]:32.32, [goproto.proto.test.optional_int32]:-32, [goproto.proto.test.optional_int64]:-64, [goproto.proto.test.optional_nested_enum]:NEG, [goproto.proto.test.optional_nested_message]:{a:5}, [goproto.proto.test.optional_string]:"string", [goproto.proto.test.optional_uint32]:32, [goproto.proto.test.optional_uint64]:64}`,
+	}, {
+		in: func() proto.Message {
+			m := &testpb.TestAllExtensions{}
+			proto.SetExtension(m, testpb.E_RepeatedBool, []bool{false, true})
+			proto.SetExtension(m, testpb.E_RepeatedInt32, []int32{32, -32})
+			proto.SetExtension(m, testpb.E_RepeatedInt64, []int64{64, -64})
+			proto.SetExtension(m, testpb.E_RepeatedUint32, []uint32{0, 32})
+			proto.SetExtension(m, testpb.E_RepeatedUint64, []uint64{0, 64})
+			proto.SetExtension(m, testpb.E_RepeatedFloat, []float32{0, 32.32})
+			proto.SetExtension(m, testpb.E_RepeatedDouble, []float64{0, 64.64})
+			proto.SetExtension(m, testpb.E_RepeatedString, []string{"s1", "s2"})
+			proto.SetExtension(m, testpb.E_RepeatedBytes, [][]byte{{1}, {2}})
+			proto.SetExtension(m, testpb.E_RepeatedNestedEnum, []testpb.TestAllTypes_NestedEnum{
+				testpb.TestAllTypes_FOO,
+				testpb.TestAllTypes_BAR,
+			})
+			proto.SetExtension(m, testpb.E_RepeatedNestedMessage, []*testpb.TestAllExtensions_NestedMessage{
+				{A: proto.Int32(5)},
+				{A: proto.Int32(-5)},
+			})
+			return m
+		}(),
+		want: `{[goproto.proto.test.repeated_bool]:[false, true], [goproto.proto.test.repeated_bytes]:["\x01", "\x02"], [goproto.proto.test.repeated_double]:[0, 64.64], [goproto.proto.test.repeated_float]:[0, 32.32], [goproto.proto.test.repeated_int32]:[32, -32], [goproto.proto.test.repeated_int64]:[64, -64], [goproto.proto.test.repeated_nested_enum]:[FOO, BAR], [goproto.proto.test.repeated_nested_message]:[{a:5}, {a:-5}], [goproto.proto.test.repeated_string]:["s1", "s2"], [goproto.proto.test.repeated_uint32]:[0, 32], [goproto.proto.test.repeated_uint64]:[0, 64]}`,
+	}, {
+		in: func() proto.Message {
+			m := &testpb.TestAllTypes{}
+			m.ProtoReflect().SetUnknown(protopack.Message{
+				protopack.Tag{Number: 50000, Type: protopack.VarintType}, protopack.Uvarint(100),
+				protopack.Tag{Number: 50001, Type: protopack.Fixed32Type}, protopack.Uint32(200),
+				protopack.Tag{Number: 50002, Type: protopack.Fixed64Type}, protopack.Uint64(300),
+				protopack.Tag{Number: 50003, Type: protopack.BytesType}, protopack.String("hello"),
+				protopack.Message{
+					protopack.Tag{Number: 50004, Type: protopack.StartGroupType},
+					protopack.Tag{Number: 1, Type: protopack.VarintType}, protopack.Uvarint(100),
+					protopack.Tag{Number: 1, Type: protopack.Fixed32Type}, protopack.Uint32(200),
+					protopack.Tag{Number: 1, Type: protopack.Fixed64Type}, protopack.Uint64(300),
+					protopack.Tag{Number: 1, Type: protopack.BytesType}, protopack.String("hello"),
+					protopack.Message{
+						protopack.Tag{Number: 1, Type: protopack.StartGroupType},
+						protopack.Tag{Number: 1, Type: protopack.VarintType}, protopack.Uvarint(100),
+						protopack.Tag{Number: 1, Type: protopack.Fixed32Type}, protopack.Uint32(200),
+						protopack.Tag{Number: 1, Type: protopack.Fixed64Type}, protopack.Uint64(300),
+						protopack.Tag{Number: 1, Type: protopack.BytesType}, protopack.String("hello"),
+						protopack.Tag{Number: 1, Type: protopack.EndGroupType},
+					},
+					protopack.Tag{Number: 50004, Type: protopack.EndGroupType},
+				},
+			}.Marshal())
+			return m
+		}(),
+		want: `{50000:100, 50001:0x000000c8, 50002:0x000000000000012c, 50003:"hello", 50004:{1:[100, 0x000000c8, 0x000000000000012c, "hello", {1:[100, 0x000000c8, 0x000000000000012c, "hello"]}]}}`,
+	}, {
+		in: &textpb.KnownTypes{
+			OptAny: &anypb.Any{
+				TypeUrl: "google.golang.org/goproto.proto.test.TestAllTypes",
+				Value: func() []byte {
+					b1, _ := proto.MarshalOptions{Deterministic: true}.Marshal(optMsg)
+					b2, _ := proto.MarshalOptions{Deterministic: true}.Marshal(repMsg)
+					b3, _ := proto.MarshalOptions{Deterministic: true}.Marshal(mapMsg)
+					return append(append(append([]byte(nil), b1...), b2...), b3...)
+				}(),
+			},
+		},
+		want: `{opt_any:{[google.golang.org/goproto.proto.test.TestAllTypes]:{optional_int32:-32, optional_int64:-64, optional_uint32:32, optional_uint64:64, optional_float:32.32, optional_double:64.64, optional_bool:false, optional_string:"string", optional_bytes:"bytes", optional_nested_message:{a:5}, optional_nested_enum:NEG, repeated_int32:[32, -32], repeated_int64:[64, -64], repeated_uint32:[0, 32], repeated_uint64:[0, 64], repeated_float:[0, 32.32], repeated_double:[0, 64.64], repeated_bool:[false, true], repeated_string:["s1", "s2"], repeated_bytes:["\x01", "\x02"], repeated_nested_message:[{a:5}, {a:-5}], repeated_nested_enum:[FOO, BAR], map_int32_int32:{-32:32}, map_int64_int64:{-64:64}, map_uint32_uint32:{0:32}, map_uint64_uint64:{0:64}, map_int32_float:{32:32.32}, map_int32_double:{64:64.64}, map_bool_bool:{true:false}, map_string_string:{"k":"v"}, map_string_bytes:{"k":"v"}, map_string_nested_message:{"k":{a:5}}, map_string_nested_enum:{"k":FOO}}}}`,
+	}, {
+		in: &textpb.KnownTypes{
+			OptTimestamp: &tspb.Timestamp{Seconds: math.MinInt64, Nanos: math.MaxInt32},
+		},
+		want: `{opt_timestamp:{seconds:-9223372036854775808, nanos:2147483647}}`,
+	}, {
+		in: &textpb.KnownTypes{
+			OptTimestamp: &tspb.Timestamp{Seconds: 1257894123, Nanos: 456789},
+		},
+		want: `{opt_timestamp:2009-11-10T23:02:03.000456789Z}`,
+	}, {
+		in: &textpb.KnownTypes{
+			OptDuration: &durpb.Duration{Seconds: math.MinInt64, Nanos: math.MaxInt32},
+		},
+		want: `{opt_duration:{seconds:-9223372036854775808, nanos:2147483647}}`,
+	}, {
+		in: &textpb.KnownTypes{
+			OptDuration: &durpb.Duration{Seconds: +1257894123, Nanos: +456789},
+		},
+		want: `{opt_duration:1257894123.000456789s}`,
+	}, {
+		in: &textpb.KnownTypes{
+			OptDuration: &durpb.Duration{Seconds: -1257894123, Nanos: -456789},
+		},
+		want: `{opt_duration:-1257894123.000456789s}`,
+	}, {
+		in: &textpb.KnownTypes{
+			OptBool:   &wpb.BoolValue{},
+			OptInt32:  &wpb.Int32Value{},
+			OptInt64:  &wpb.Int64Value{},
+			OptUint32: &wpb.UInt32Value{},
+			OptUint64: &wpb.UInt64Value{},
+			OptFloat:  &wpb.FloatValue{},
+			OptDouble: &wpb.DoubleValue{},
+			OptString: &wpb.StringValue{},
+			OptBytes:  &wpb.BytesValue{},
+		},
+		want: `{opt_bool:false, opt_int32:0, opt_int64:0, opt_uint32:0, opt_uint64:0, opt_float:0, opt_double:0, opt_string:"", opt_bytes:""}`,
+	}}
+	for _, tt := range tests {
+		t.Run("Generated", func(t *testing.T) {
+			got := msgfmt.Format(tt.in)
+			if diff := cmp.Diff(tt.want, got); diff != "" {
+				t.Errorf("Format() mismatch (-want +got):\n%v", diff)
+			}
+		})
+		t.Run("dynamicpb.Message", func(t *testing.T) {
+			m := dynpb.NewMessage(tt.in.ProtoReflect().Descriptor())
+			proto.Merge(m, tt.in)
+			got := msgfmt.Format(m)
+			if diff := cmp.Diff(tt.want, got); diff != "" {
+				t.Errorf("Format() mismatch (-want +got):\n%v", diff)
+			}
+		})
+		t.Run("protocmp.Message", func(t *testing.T) {
+			// This is a roundabout way to obtain a protocmp.Message since there
+			// is no exported API in protocmp to directly transform a message.
+			var m proto.Message
+			var once sync.Once
+			cmp.Equal(tt.in, tt.in, protocmp.Transform(), cmp.FilterPath(func(p cmp.Path) bool {
+				if v, _ := p.Index(1).Values(); v.IsValid() {
+					once.Do(func() { m = v.Interface().(protocmp.Message) })
+				}
+				return false
+			}, cmp.Ignore()))
+
+			got := msgfmt.Format(m)
+			if diff := cmp.Diff(tt.want, got); diff != "" {
+				t.Errorf("Format() mismatch (-want +got):\n%v", diff)
+			}
+		})
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/pragma/pragma.go b/vendor/google.golang.org/protobuf/internal/pragma/pragma.go
new file mode 100644
index 000000000..49dc4fcd9
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/pragma/pragma.go
@@ -0,0 +1,29 @@
+// 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 pragma provides types that can be embedded into a struct to
+// statically enforce or prevent certain language properties.
+package pragma
+
+import "sync"
+
+// NoUnkeyedLiterals can be embedded in a struct to prevent unkeyed literals.
+type NoUnkeyedLiterals struct{}
+
+// DoNotImplement can be embedded in an interface to prevent trivial
+// implementations of the interface.
+//
+// This is useful to prevent unauthorized implementations of an interface
+// so that it can be extended in the future for any protobuf language changes.
+type DoNotImplement interface{ ProtoInternal(DoNotImplement) }
+
+// DoNotCompare can be embedded in a struct to prevent comparability.
+type DoNotCompare [0]func()
+
+// DoNotCopy can be embedded in a struct to help prevent shallow copies.
+// This does not rely on a Go language feature, but rather a special case
+// within the vet checker.
+//
+// See https://golang.org/issues/8005.
+type DoNotCopy [0]sync.Mutex
diff --git a/vendor/google.golang.org/protobuf/internal/protobuild/build.go b/vendor/google.golang.org/protobuf/internal/protobuild/build.go
new file mode 100644
index 000000000..cb2f4a5a0
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/protobuild/build.go
@@ -0,0 +1,150 @@
+// Copyright 2020 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 protobuild constructs messages.
+//
+// This package is used to construct multiple types of message with a similar shape
+// from a common template.
+package protobuild
+
+import (
+	"fmt"
+	"math"
+	"reflect"
+
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/reflect/protoregistry"
+)
+
+// A Value is a value assignable to a field.
+// A Value may be a value accepted by protoreflect.ValueOf. In addition:
+//
+// • An int may be assigned to any numeric field.
+//
+// • A float64 may be assigned to a double field.
+//
+// • Either a string or []byte may be assigned to a string or bytes field.
+//
+// • A string containing the value name may be assigned to an enum field.
+//
+// • A slice may be assigned to a list, and a map may be assigned to a map.
+type Value interface{}
+
+// A Message is a template to apply to a message. Keys are field names, including
+// extension names.
+type Message map[pref.Name]Value
+
+// Unknown is a key associated with the unknown fields of a message.
+// The value should be a []byte.
+const Unknown = "@unknown"
+
+// Build applies the template to a message.
+func (template Message) Build(m pref.Message) {
+	md := m.Descriptor()
+	fields := md.Fields()
+	exts := make(map[pref.Name]pref.FieldDescriptor)
+	protoregistry.GlobalTypes.RangeExtensionsByMessage(md.FullName(), func(xt pref.ExtensionType) bool {
+		xd := xt.TypeDescriptor()
+		exts[xd.Name()] = xd
+		return true
+	})
+	for k, v := range template {
+		if k == Unknown {
+			m.SetUnknown(pref.RawFields(v.([]byte)))
+			continue
+		}
+		fd := fields.ByName(k)
+		if fd == nil {
+			fd = exts[k]
+		}
+		if fd == nil {
+			panic(fmt.Sprintf("%v.%v: not found", md.FullName(), k))
+		}
+		switch {
+		case fd.IsList():
+			list := m.Mutable(fd).List()
+			s := reflect.ValueOf(v)
+			for i := 0; i < s.Len(); i++ {
+				if fd.Message() == nil {
+					list.Append(fieldValue(fd, s.Index(i).Interface()))
+				} else {
+					e := list.NewElement()
+					s.Index(i).Interface().(Message).Build(e.Message())
+					list.Append(e)
+				}
+			}
+		case fd.IsMap():
+			mapv := m.Mutable(fd).Map()
+			rm := reflect.ValueOf(v)
+			for _, k := range rm.MapKeys() {
+				mk := fieldValue(fd.MapKey(), k.Interface()).MapKey()
+				if fd.MapValue().Message() == nil {
+					mv := fieldValue(fd.MapValue(), rm.MapIndex(k).Interface())
+					mapv.Set(mk, mv)
+				} else if mapv.Has(mk) {
+					mv := mapv.Get(mk).Message()
+					rm.MapIndex(k).Interface().(Message).Build(mv)
+				} else {
+					mv := mapv.NewValue()
+					rm.MapIndex(k).Interface().(Message).Build(mv.Message())
+					mapv.Set(mk, mv)
+				}
+			}
+		default:
+			if fd.Message() == nil {
+				m.Set(fd, fieldValue(fd, v))
+			} else {
+				v.(Message).Build(m.Mutable(fd).Message())
+			}
+		}
+	}
+}
+
+func fieldValue(fd pref.FieldDescriptor, v interface{}) pref.Value {
+	switch o := v.(type) {
+	case int:
+		switch fd.Kind() {
+		case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
+			if min, max := math.MinInt32, math.MaxInt32; o < min || o > max {
+				panic(fmt.Sprintf("%v: value %v out of range [%v, %v]", fd.FullName(), o, min, max))
+			}
+			v = int32(o)
+		case pref.Uint32Kind, pref.Fixed32Kind:
+			if min, max := 0, math.MaxUint32; o < min || o > max {
+				panic(fmt.Sprintf("%v: value %v out of range [%v, %v]", fd.FullName(), o, min, max))
+			}
+			v = uint32(o)
+		case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
+			v = int64(o)
+		case pref.Uint64Kind, pref.Fixed64Kind:
+			if o < 0 {
+				panic(fmt.Sprintf("%v: value %v out of range [%v, %v]", fd.FullName(), o, 0, uint64(math.MaxUint64)))
+			}
+			v = uint64(o)
+		case pref.FloatKind:
+			v = float32(o)
+		case pref.DoubleKind:
+			v = float64(o)
+		case pref.EnumKind:
+			v = pref.EnumNumber(o)
+		default:
+			panic(fmt.Sprintf("%v: invalid value type int", fd.FullName()))
+		}
+	case float64:
+		switch fd.Kind() {
+		case pref.FloatKind:
+			v = float32(o)
+		}
+	case string:
+		switch fd.Kind() {
+		case pref.BytesKind:
+			v = []byte(o)
+		case pref.EnumKind:
+			v = fd.Enum().Values().ByName(pref.Name(o)).Number()
+		}
+	case []byte:
+		return pref.ValueOf(append([]byte{}, o...))
+	}
+	return pref.ValueOf(v)
+}
diff --git a/vendor/google.golang.org/protobuf/internal/protolegacy/proto.go b/vendor/google.golang.org/protobuf/internal/protolegacy/proto.go
new file mode 100644
index 000000000..96b44d919
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/protolegacy/proto.go
@@ -0,0 +1,125 @@
+// Copyright 2019 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 protolegacy is a stub version of the v1 proto package
+// to satisfy internal/testprotos/legacy dependencies.
+package protolegacy
+
+import (
+	"bytes"
+	"compress/gzip"
+	"errors"
+	"fmt"
+	"io/ioutil"
+
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/reflect/protoregistry"
+	"google.golang.org/protobuf/runtime/protoiface"
+	"google.golang.org/protobuf/runtime/protoimpl"
+)
+
+const (
+	ProtoPackageIsVersion1 = true
+	ProtoPackageIsVersion2 = true
+	ProtoPackageIsVersion3 = true
+)
+
+const (
+	WireVarint     = 0
+	WireFixed32    = 5
+	WireFixed64    = 1
+	WireBytes      = 2
+	WireStartGroup = 3
+	WireEndGroup   = 4
+)
+
+type (
+	Message                = protoiface.MessageV1
+	ExtensionRange         = protoiface.ExtensionRangeV1
+	ExtensionDesc          = protoimpl.ExtensionInfo
+	Extension              = protoimpl.ExtensionFieldV1
+	XXX_InternalExtensions = protoimpl.ExtensionFields
+)
+
+func RegisterFile(s string, d []byte) {
+	// Decompress the descriptor.
+	zr, err := gzip.NewReader(bytes.NewReader(d))
+	if err != nil {
+		panic(fmt.Sprintf("proto: invalid compressed file descriptor: %v", err))
+	}
+	b, err := ioutil.ReadAll(zr)
+	if err != nil {
+		panic(fmt.Sprintf("proto: invalid compressed file descriptor: %v", err))
+	}
+
+	// Construct a protoreflect.FileDescriptor from the raw descriptor.
+	// Note that DescBuilder.Build automatically registers the constructed
+	// file descriptor with the v2 registry.
+	protoimpl.DescBuilder{RawDescriptor: b}.Build()
+}
+
+func RegisterType(m Message, s string) {
+	mt := protoimpl.X.LegacyMessageTypeOf(m, protoreflect.FullName(s))
+	if err := protoregistry.GlobalTypes.RegisterMessage(mt); err != nil {
+		panic(err)
+	}
+}
+
+func RegisterMapType(interface{}, string) {
+	// Do nothing.
+}
+
+func RegisterEnum(string, map[int32]string, map[string]int32) {
+	// Do nothing.
+}
+
+func RegisterExtension(d *ExtensionDesc) {
+	if err := protoregistry.GlobalTypes.RegisterExtension(d); err != nil {
+		panic(err)
+	}
+}
+
+var ErrInternalBadWireType = errors.New("not implemented")
+
+func Size(Message) int                { panic("not implemented") }
+func Marshal(Message) ([]byte, error) { panic("not implemented") }
+func Unmarshal([]byte, Message) error { panic("not implemented") }
+
+func SizeVarint(uint64) int             { panic("not implemented") }
+func EncodeVarint(uint64) []byte        { panic("not implemented") }
+func DecodeVarint([]byte) (uint64, int) { panic("not implemented") }
+
+func CompactTextString(Message) string                                  { panic("not implemented") }
+func EnumName(map[int32]string, int32) string                           { panic("not implemented") }
+func UnmarshalJSONEnum(map[string]int32, []byte, string) (int32, error) { panic("not implemented") }
+
+type Buffer struct{}
+
+func (*Buffer) DecodeFixed32() (uint64, error)      { panic("not implemented") }
+func (*Buffer) DecodeFixed64() (uint64, error)      { panic("not implemented") }
+func (*Buffer) DecodeGroup(Message) error           { panic("not implemented") }
+func (*Buffer) DecodeMessage(Message) error         { panic("not implemented") }
+func (*Buffer) DecodeRawBytes(bool) ([]byte, error) { panic("not implemented") }
+func (*Buffer) DecodeStringBytes() (string, error)  { panic("not implemented") }
+func (*Buffer) DecodeVarint() (uint64, error)       { panic("not implemented") }
+func (*Buffer) DecodeZigzag32() (uint64, error)     { panic("not implemented") }
+func (*Buffer) DecodeZigzag64() (uint64, error)     { panic("not implemented") }
+func (*Buffer) EncodeFixed32(uint64) error          { panic("not implemented") }
+func (*Buffer) EncodeFixed64(uint64) error          { panic("not implemented") }
+func (*Buffer) EncodeMessage(Message) error         { panic("not implemented") }
+func (*Buffer) EncodeRawBytes([]byte) error         { panic("not implemented") }
+func (*Buffer) EncodeStringBytes(string) error      { panic("not implemented") }
+func (*Buffer) EncodeVarint(uint64) error           { panic("not implemented") }
+func (*Buffer) EncodeZigzag32(uint64) error         { panic("not implemented") }
+func (*Buffer) EncodeZigzag64(uint64) error         { panic("not implemented") }
+func (*Buffer) Marshal(Message) error               { panic("not implemented") }
+func (*Buffer) Unmarshal(Message) error             { panic("not implemented") }
+
+type InternalMessageInfo struct{}
+
+func (*InternalMessageInfo) DiscardUnknown(Message)                        { panic("not implemented") }
+func (*InternalMessageInfo) Marshal([]byte, Message, bool) ([]byte, error) { panic("not implemented") }
+func (*InternalMessageInfo) Merge(Message, Message)                        { panic("not implemented") }
+func (*InternalMessageInfo) Size(Message) int                              { panic("not implemented") }
+func (*InternalMessageInfo) Unmarshal(Message, []byte) error               { panic("not implemented") }
diff --git a/vendor/google.golang.org/protobuf/internal/set/ints.go b/vendor/google.golang.org/protobuf/internal/set/ints.go
new file mode 100644
index 000000000..d3d7f89ab
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/set/ints.go
@@ -0,0 +1,58 @@
+// 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 set provides simple set data structures for uint64s.
+package set
+
+import "math/bits"
+
+// int64s represents a set of integers within the range of 0..63.
+type int64s uint64
+
+func (bs *int64s) Len() int {
+	return bits.OnesCount64(uint64(*bs))
+}
+func (bs *int64s) Has(n uint64) bool {
+	return uint64(*bs)&(uint64(1)<<n) > 0
+}
+func (bs *int64s) Set(n uint64) {
+	*(*uint64)(bs) |= uint64(1) << n
+}
+func (bs *int64s) Clear(n uint64) {
+	*(*uint64)(bs) &^= uint64(1) << n
+}
+
+// Ints represents a set of integers within the range of 0..math.MaxUint64.
+type Ints struct {
+	lo int64s
+	hi map[uint64]struct{}
+}
+
+func (bs *Ints) Len() int {
+	return bs.lo.Len() + len(bs.hi)
+}
+func (bs *Ints) Has(n uint64) bool {
+	if n < 64 {
+		return bs.lo.Has(n)
+	}
+	_, ok := bs.hi[n]
+	return ok
+}
+func (bs *Ints) Set(n uint64) {
+	if n < 64 {
+		bs.lo.Set(n)
+		return
+	}
+	if bs.hi == nil {
+		bs.hi = make(map[uint64]struct{})
+	}
+	bs.hi[n] = struct{}{}
+}
+func (bs *Ints) Clear(n uint64) {
+	if n < 64 {
+		bs.lo.Clear(n)
+		return
+	}
+	delete(bs.hi, n)
+}
diff --git a/vendor/google.golang.org/protobuf/internal/set/ints_test.go b/vendor/google.golang.org/protobuf/internal/set/ints_test.go
new file mode 100644
index 000000000..9dac18bd3
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/set/ints_test.go
@@ -0,0 +1,75 @@
+// 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 set
+
+import (
+	"math/rand"
+	"testing"
+)
+
+const maxLimit = 1024
+
+var toSet, toClear [maxLimit]bool
+
+func init() {
+	r := rand.New(rand.NewSource(0))
+	for i := 0; i < maxLimit; i++ {
+		toSet[i] = r.Intn(2) == 0
+		toClear[i] = r.Intn(2) == 0
+	}
+}
+
+func TestInts(t *testing.T) {
+	ns := new(Ints)
+
+	// Check that set starts empty.
+	wantLen := 0
+	if ns.Len() != wantLen {
+		t.Errorf("init: Len() = %d, want %d", ns.Len(), wantLen)
+	}
+	for i := 0; i < maxLimit; i++ {
+		if ns.Has(uint64(i)) {
+			t.Errorf("init: Has(%d) = true, want false", i)
+		}
+	}
+
+	// Set some numbers.
+	for i, b := range toSet[:maxLimit] {
+		if b {
+			ns.Set(uint64(i))
+			wantLen++
+		}
+	}
+
+	// Check that integers were set.
+	if ns.Len() != wantLen {
+		t.Errorf("after Set: Len() = %d, want %d", ns.Len(), wantLen)
+	}
+	for i := 0; i < maxLimit; i++ {
+		if got := ns.Has(uint64(i)); got != toSet[i] {
+			t.Errorf("after Set: Has(%d) = %v, want %v", i, got, !got)
+		}
+	}
+
+	// Clear some numbers.
+	for i, b := range toClear[:maxLimit] {
+		if b {
+			ns.Clear(uint64(i))
+			if toSet[i] {
+				wantLen--
+			}
+		}
+	}
+
+	// Check that integers were cleared.
+	if ns.Len() != wantLen {
+		t.Errorf("after Clear: Len() = %d, want %d", ns.Len(), wantLen)
+	}
+	for i := 0; i < maxLimit; i++ {
+		if got := ns.Has(uint64(i)); got != toSet[i] && !toClear[i] {
+			t.Errorf("after Clear: Has(%d) = %v, want %v", i, got, !got)
+		}
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/strs/strings.go b/vendor/google.golang.org/protobuf/internal/strs/strings.go
new file mode 100644
index 000000000..0b74e7658
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/strs/strings.go
@@ -0,0 +1,196 @@
+// Copyright 2019 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 strs provides string manipulation functionality specific to protobuf.
+package strs
+
+import (
+	"go/token"
+	"strings"
+	"unicode"
+	"unicode/utf8"
+
+	"google.golang.org/protobuf/internal/flags"
+	"google.golang.org/protobuf/reflect/protoreflect"
+)
+
+// EnforceUTF8 reports whether to enforce strict UTF-8 validation.
+func EnforceUTF8(fd protoreflect.FieldDescriptor) bool {
+	if flags.ProtoLegacy {
+		if fd, ok := fd.(interface{ EnforceUTF8() bool }); ok {
+			return fd.EnforceUTF8()
+		}
+	}
+	return fd.Syntax() == protoreflect.Proto3
+}
+
+// GoCamelCase camel-cases a protobuf name for use as a Go identifier.
+//
+// If there is an interior underscore followed by a lower case letter,
+// drop the underscore and convert the letter to upper case.
+func GoCamelCase(s string) string {
+	// Invariant: if the next letter is lower case, it must be converted
+	// to upper case.
+	// That is, we process a word at a time, where words are marked by _ or
+	// upper case letter. Digits are treated as words.
+	var b []byte
+	for i := 0; i < len(s); i++ {
+		c := s[i]
+		switch {
+		case c == '.' && i+1 < len(s) && isASCIILower(s[i+1]):
+			// Skip over '.' in ".{{lowercase}}".
+		case c == '.':
+			b = append(b, '_') // convert '.' to '_'
+		case c == '_' && (i == 0 || s[i-1] == '.'):
+			// Convert initial '_' to ensure we start with a capital letter.
+			// Do the same for '_' after '.' to match historic behavior.
+			b = append(b, 'X') // convert '_' to 'X'
+		case c == '_' && i+1 < len(s) && isASCIILower(s[i+1]):
+			// Skip over '_' in "_{{lowercase}}".
+		case isASCIIDigit(c):
+			b = append(b, c)
+		default:
+			// Assume we have a letter now - if not, it's a bogus identifier.
+			// The next word is a sequence of characters that must start upper case.
+			if isASCIILower(c) {
+				c -= 'a' - 'A' // convert lowercase to uppercase
+			}
+			b = append(b, c)
+
+			// Accept lower case sequence that follows.
+			for ; i+1 < len(s) && isASCIILower(s[i+1]); i++ {
+				b = append(b, s[i+1])
+			}
+		}
+	}
+	return string(b)
+}
+
+// GoSanitized converts a string to a valid Go identifier.
+func GoSanitized(s string) string {
+	// Sanitize the input to the set of valid characters,
+	// which must be '_' or be in the Unicode L or N categories.
+	s = strings.Map(func(r rune) rune {
+		if unicode.IsLetter(r) || unicode.IsDigit(r) {
+			return r
+		}
+		return '_'
+	}, s)
+
+	// Prepend '_' in the event of a Go keyword conflict or if
+	// the identifier is invalid (does not start in the Unicode L category).
+	r, _ := utf8.DecodeRuneInString(s)
+	if token.Lookup(s).IsKeyword() || !unicode.IsLetter(r) {
+		return "_" + s
+	}
+	return s
+}
+
+// JSONCamelCase converts a snake_case identifier to a camelCase identifier,
+// according to the protobuf JSON specification.
+func JSONCamelCase(s string) string {
+	var b []byte
+	var wasUnderscore bool
+	for i := 0; i < len(s); i++ { // proto identifiers are always ASCII
+		c := s[i]
+		if c != '_' {
+			if wasUnderscore && isASCIILower(c) {
+				c -= 'a' - 'A' // convert to uppercase
+			}
+			b = append(b, c)
+		}
+		wasUnderscore = c == '_'
+	}
+	return string(b)
+}
+
+// JSONSnakeCase converts a camelCase identifier to a snake_case identifier,
+// according to the protobuf JSON specification.
+func JSONSnakeCase(s string) string {
+	var b []byte
+	for i := 0; i < len(s); i++ { // proto identifiers are always ASCII
+		c := s[i]
+		if isASCIIUpper(c) {
+			b = append(b, '_')
+			c += 'a' - 'A' // convert to lowercase
+		}
+		b = append(b, c)
+	}
+	return string(b)
+}
+
+// MapEntryName derives the name of the map entry message given the field name.
+// See protoc v3.8.0: src/google/protobuf/descriptor.cc:254-276,6057
+func MapEntryName(s string) string {
+	var b []byte
+	upperNext := true
+	for _, c := range s {
+		switch {
+		case c == '_':
+			upperNext = true
+		case upperNext:
+			b = append(b, byte(unicode.ToUpper(c)))
+			upperNext = false
+		default:
+			b = append(b, byte(c))
+		}
+	}
+	b = append(b, "Entry"...)
+	return string(b)
+}
+
+// EnumValueName derives the camel-cased enum value name.
+// See protoc v3.8.0: src/google/protobuf/descriptor.cc:297-313
+func EnumValueName(s string) string {
+	var b []byte
+	upperNext := true
+	for _, c := range s {
+		switch {
+		case c == '_':
+			upperNext = true
+		case upperNext:
+			b = append(b, byte(unicode.ToUpper(c)))
+			upperNext = false
+		default:
+			b = append(b, byte(unicode.ToLower(c)))
+			upperNext = false
+		}
+	}
+	return string(b)
+}
+
+// TrimEnumPrefix trims the enum name prefix from an enum value name,
+// where the prefix is all lowercase without underscores.
+// See protoc v3.8.0: src/google/protobuf/descriptor.cc:330-375
+func TrimEnumPrefix(s, prefix string) string {
+	s0 := s // original input
+	for len(s) > 0 && len(prefix) > 0 {
+		if s[0] == '_' {
+			s = s[1:]
+			continue
+		}
+		if unicode.ToLower(rune(s[0])) != rune(prefix[0]) {
+			return s0 // no prefix match
+		}
+		s, prefix = s[1:], prefix[1:]
+	}
+	if len(prefix) > 0 {
+		return s0 // no prefix match
+	}
+	s = strings.TrimLeft(s, "_")
+	if len(s) == 0 {
+		return s0 // avoid returning empty string
+	}
+	return s
+}
+
+func isASCIILower(c byte) bool {
+	return 'a' <= c && c <= 'z'
+}
+func isASCIIUpper(c byte) bool {
+	return 'A' <= c && c <= 'Z'
+}
+func isASCIIDigit(c byte) bool {
+	return '0' <= c && c <= '9'
+}
diff --git a/vendor/google.golang.org/protobuf/internal/strs/strings_pure.go b/vendor/google.golang.org/protobuf/internal/strs/strings_pure.go
new file mode 100644
index 000000000..85e074c97
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/strs/strings_pure.go
@@ -0,0 +1,27 @@
+// 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.
+
+// +build purego appengine
+
+package strs
+
+import pref "google.golang.org/protobuf/reflect/protoreflect"
+
+func UnsafeString(b []byte) string {
+	return string(b)
+}
+
+func UnsafeBytes(s string) []byte {
+	return []byte(s)
+}
+
+type Builder struct{}
+
+func (*Builder) AppendFullName(prefix pref.FullName, name pref.Name) pref.FullName {
+	return prefix.Append(name)
+}
+
+func (*Builder) MakeString(b []byte) string {
+	return string(b)
+}
diff --git a/vendor/google.golang.org/protobuf/internal/strs/strings_test.go b/vendor/google.golang.org/protobuf/internal/strs/strings_test.go
new file mode 100644
index 000000000..0bb894a16
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/strs/strings_test.go
@@ -0,0 +1,163 @@
+// Copyright 2019 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 strs
+
+import (
+	"strconv"
+	"testing"
+)
+
+func TestGoCamelCase(t *testing.T) {
+	tests := []struct {
+		in, want string
+	}{
+		{"", ""},
+		{"one", "One"},
+		{"one_two", "OneTwo"},
+		{"_my_field_name_2", "XMyFieldName_2"},
+		{"Something_Capped", "Something_Capped"},
+		{"my_Name", "My_Name"},
+		{"OneTwo", "OneTwo"},
+		{"_", "X"},
+		{"_a_", "XA_"},
+		{"one.two", "OneTwo"},
+		{"one.Two", "One_Two"},
+		{"one_two.three_four", "OneTwoThreeFour"},
+		{"one_two.Three_four", "OneTwo_ThreeFour"},
+		{"_one._two", "XOne_XTwo"},
+		{"SCREAMING_SNAKE_CASE", "SCREAMING_SNAKE_CASE"},
+		{"double__underscore", "Double_Underscore"},
+		{"camelCase", "CamelCase"},
+		{"go2proto", "Go2Proto"},
+		{"世界", "世界"},
+		{"x世界", "X世界"},
+		{"foo_bar世界", "FooBar世界"},
+	}
+	for _, tc := range tests {
+		if got := GoCamelCase(tc.in); got != tc.want {
+			t.Errorf("GoCamelCase(%q) = %q, want %q", tc.in, got, tc.want)
+		}
+	}
+}
+
+func TestGoSanitized(t *testing.T) {
+	tests := []struct {
+		in, want string
+	}{
+		{"", "_"},
+		{"boo", "boo"},
+		{"Boo", "Boo"},
+		{"ßoo", "ßoo"},
+		{"default", "_default"},
+		{"hello", "hello"},
+		{"hello-world!!", "hello_world__"},
+		{"hello-\xde\xad\xbe\xef\x00", "hello_____"},
+		{"hello 世界", "hello_世界"},
+		{"世界", "世界"},
+	}
+	for _, tc := range tests {
+		if got := GoSanitized(tc.in); got != tc.want {
+			t.Errorf("GoSanitized(%q) = %q, want %q", tc.in, got, tc.want)
+		}
+	}
+}
+
+func TestName(t *testing.T) {
+	tests := []struct {
+		in                string
+		inEnumPrefix      string
+		wantMapEntry      string
+		wantEnumValue     string
+		wantTrimValue     string
+		wantJSONCamelCase string
+		wantJSONSnakeCase string
+	}{{
+		in:                "abc",
+		inEnumPrefix:      "",
+		wantMapEntry:      "AbcEntry",
+		wantEnumValue:     "Abc",
+		wantTrimValue:     "abc",
+		wantJSONCamelCase: "abc",
+		wantJSONSnakeCase: "abc",
+	}, {
+		in:                "foo_baR_",
+		inEnumPrefix:      "foo_bar",
+		wantMapEntry:      "FooBaREntry",
+		wantEnumValue:     "FooBar",
+		wantTrimValue:     "foo_baR_",
+		wantJSONCamelCase: "fooBaR",
+		wantJSONSnakeCase: "foo_ba_r_",
+	}, {
+		in:                "snake_caseCamelCase",
+		inEnumPrefix:      "snakecasecamel",
+		wantMapEntry:      "SnakeCaseCamelCaseEntry",
+		wantEnumValue:     "SnakeCasecamelcase",
+		wantTrimValue:     "Case",
+		wantJSONCamelCase: "snakeCaseCamelCase",
+		wantJSONSnakeCase: "snake_case_camel_case",
+	}, {
+		in:                "FiZz_BuZz",
+		inEnumPrefix:      "fizz",
+		wantMapEntry:      "FiZzBuZzEntry",
+		wantEnumValue:     "FizzBuzz",
+		wantTrimValue:     "BuZz",
+		wantJSONCamelCase: "FiZzBuZz",
+		wantJSONSnakeCase: "_fi_zz__bu_zz",
+	}}
+
+	for _, tt := range tests {
+		if got := MapEntryName(tt.in); got != tt.wantMapEntry {
+			t.Errorf("MapEntryName(%q) = %q, want %q", tt.in, got, tt.wantMapEntry)
+		}
+		if got := EnumValueName(tt.in); got != tt.wantEnumValue {
+			t.Errorf("EnumValueName(%q) = %q, want %q", tt.in, got, tt.wantEnumValue)
+		}
+		if got := TrimEnumPrefix(tt.in, tt.inEnumPrefix); got != tt.wantTrimValue {
+			t.Errorf("ErimEnumPrefix(%q, %q) = %q, want %q", tt.in, tt.inEnumPrefix, got, tt.wantTrimValue)
+		}
+		if got := JSONCamelCase(tt.in); got != tt.wantJSONCamelCase {
+			t.Errorf("JSONCamelCase(%q) = %q, want %q", tt.in, got, tt.wantJSONCamelCase)
+		}
+		if got := JSONSnakeCase(tt.in); got != tt.wantJSONSnakeCase {
+			t.Errorf("JSONSnakeCase(%q) = %q, want %q", tt.in, got, tt.wantJSONSnakeCase)
+		}
+	}
+}
+
+var (
+	srcString = "1234"
+	srcBytes  = []byte(srcString)
+	dst       uint64
+)
+
+func BenchmarkCast(b *testing.B) {
+	b.Run("Ideal", func(b *testing.B) {
+		b.ReportAllocs()
+		for i := 0; i < b.N; i++ {
+			dst, _ = strconv.ParseUint(srcString, 0, 64)
+		}
+		if dst != 1234 {
+			b.Errorf("got %d, want %s", dst, srcString)
+		}
+	})
+	b.Run("Copy", func(b *testing.B) {
+		b.ReportAllocs()
+		for i := 0; i < b.N; i++ {
+			dst, _ = strconv.ParseUint(string(srcBytes), 0, 64)
+		}
+		if dst != 1234 {
+			b.Errorf("got %d, want %s", dst, srcString)
+		}
+	})
+	b.Run("Cast", func(b *testing.B) {
+		b.ReportAllocs()
+		for i := 0; i < b.N; i++ {
+			dst, _ = strconv.ParseUint(UnsafeString(srcBytes), 0, 64)
+		}
+		if dst != 1234 {
+			b.Errorf("got %d, want %s", dst, srcString)
+		}
+	})
+}
diff --git a/vendor/google.golang.org/protobuf/internal/strs/strings_unsafe.go b/vendor/google.golang.org/protobuf/internal/strs/strings_unsafe.go
new file mode 100644
index 000000000..2160c7019
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/strs/strings_unsafe.go
@@ -0,0 +1,94 @@
+// 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.
+
+// +build !purego,!appengine
+
+package strs
+
+import (
+	"unsafe"
+
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+)
+
+type (
+	stringHeader struct {
+		Data unsafe.Pointer
+		Len  int
+	}
+	sliceHeader struct {
+		Data unsafe.Pointer
+		Len  int
+		Cap  int
+	}
+)
+
+// UnsafeString returns an unsafe string reference of b.
+// The caller must treat the input slice as immutable.
+//
+// WARNING: Use carefully. The returned result must not leak to the end user
+// unless the input slice is provably immutable.
+func UnsafeString(b []byte) (s string) {
+	src := (*sliceHeader)(unsafe.Pointer(&b))
+	dst := (*stringHeader)(unsafe.Pointer(&s))
+	dst.Data = src.Data
+	dst.Len = src.Len
+	return s
+}
+
+// UnsafeBytes returns an unsafe bytes slice reference of s.
+// The caller must treat returned slice as immutable.
+//
+// WARNING: Use carefully. The returned result must not leak to the end user.
+func UnsafeBytes(s string) (b []byte) {
+	src := (*stringHeader)(unsafe.Pointer(&s))
+	dst := (*sliceHeader)(unsafe.Pointer(&b))
+	dst.Data = src.Data
+	dst.Len = src.Len
+	dst.Cap = src.Len
+	return b
+}
+
+// Builder builds a set of strings with shared lifetime.
+// This differs from strings.Builder, which is for building a single string.
+type Builder struct {
+	buf []byte
+}
+
+// AppendFullName is equivalent to protoreflect.FullName.Append,
+// but optimized for large batches where each name has a shared lifetime.
+func (sb *Builder) AppendFullName(prefix pref.FullName, name pref.Name) pref.FullName {
+	n := len(prefix) + len(".") + len(name)
+	if len(prefix) == 0 {
+		n -= len(".")
+	}
+	sb.grow(n)
+	sb.buf = append(sb.buf, prefix...)
+	sb.buf = append(sb.buf, '.')
+	sb.buf = append(sb.buf, name...)
+	return pref.FullName(sb.last(n))
+}
+
+// MakeString is equivalent to string(b), but optimized for large batches
+// with a shared lifetime.
+func (sb *Builder) MakeString(b []byte) string {
+	sb.grow(len(b))
+	sb.buf = append(sb.buf, b...)
+	return sb.last(len(b))
+}
+
+func (sb *Builder) grow(n int) {
+	if cap(sb.buf)-len(sb.buf) >= n {
+		return
+	}
+
+	// Unlike strings.Builder, we do not need to copy over the contents
+	// of the old buffer since our builder provides no API for
+	// retrieving previously created strings.
+	sb.buf = make([]byte, 2*(cap(sb.buf)+n))
+}
+
+func (sb *Builder) last(n int) string {
+	return UnsafeString(sb.buf[len(sb.buf)-n:])
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/annotation/annotation.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/annotation/annotation.pb.go
new file mode 100644
index 000000000..f09bc4175
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/annotation/annotation.pb.go
@@ -0,0 +1,94 @@
+// Copyright 2019 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: internal/testprotos/annotation/annotation.proto
+
+package annotation
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	descriptorpb "google.golang.org/protobuf/types/descriptorpb"
+	reflect "reflect"
+)
+
+var file_internal_testprotos_annotation_annotation_proto_extTypes = []protoimpl.ExtensionInfo{
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*bool)(nil),
+		Field:         37383685,
+		Name:          "go_annotation.track_field_use",
+		Tag:           "varint,37383685,opt,name=track_field_use",
+		Filename:      "internal/testprotos/annotation/annotation.proto",
+	},
+}
+
+// Extension fields to descriptorpb.MessageOptions.
+var (
+	// Setting this on a message enables tracking of which fields in the message
+	// a specific binary might access. As a consequence, it also disables the use
+	// of the message accessor methods to satisfy interfaces: they can only be
+	// called directly.
+	//
+	// optional bool track_field_use = 37383685;
+	E_TrackFieldUse = &file_internal_testprotos_annotation_annotation_proto_extTypes[0]
+)
+
+var File_internal_testprotos_annotation_annotation_proto protoreflect.FileDescriptor
+
+var file_internal_testprotos_annotation_annotation_proto_rawDesc = []byte{
+	0x0a, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x12, 0x0d, 0x67, 0x6f, 0x5f, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x1a, 0x20, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x2f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x3a, 0x4a, 0x0a, 0x0f, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x5f, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x5f, 0x75, 0x73, 0x65, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x85, 0xdc, 0xe9, 0x11, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x0d, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x55, 0x73, 0x65, 0x42, 0x3b,
+	0x5a, 0x39, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e,
+	0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x69, 0x6e, 0x74,
+	0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73,
+	0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+}
+
+var file_internal_testprotos_annotation_annotation_proto_goTypes = []interface{}{
+	(*descriptorpb.MessageOptions)(nil), // 0: google.protobuf.MessageOptions
+}
+var file_internal_testprotos_annotation_annotation_proto_depIdxs = []int32{
+	0, // 0: go_annotation.track_field_use:extendee -> google.protobuf.MessageOptions
+	1, // [1:1] is the sub-list for method output_type
+	1, // [1:1] is the sub-list for method input_type
+	1, // [1:1] is the sub-list for extension type_name
+	0, // [0:1] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_internal_testprotos_annotation_annotation_proto_init() }
+func file_internal_testprotos_annotation_annotation_proto_init() {
+	if File_internal_testprotos_annotation_annotation_proto != nil {
+		return
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_internal_testprotos_annotation_annotation_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   0,
+			NumExtensions: 1,
+			NumServices:   0,
+		},
+		GoTypes:           file_internal_testprotos_annotation_annotation_proto_goTypes,
+		DependencyIndexes: file_internal_testprotos_annotation_annotation_proto_depIdxs,
+		ExtensionInfos:    file_internal_testprotos_annotation_annotation_proto_extTypes,
+	}.Build()
+	File_internal_testprotos_annotation_annotation_proto = out.File
+	file_internal_testprotos_annotation_annotation_proto_rawDesc = nil
+	file_internal_testprotos_annotation_annotation_proto_goTypes = nil
+	file_internal_testprotos_annotation_annotation_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/annotation/annotation.proto b/vendor/google.golang.org/protobuf/internal/testprotos/annotation/annotation.proto
new file mode 100644
index 000000000..421631e78
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/annotation/annotation.proto
@@ -0,0 +1,19 @@
+// Copyright 2019 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.
+
+syntax = "proto2";
+
+package go_annotation;
+
+import "google/protobuf/descriptor.proto";
+
+option go_package = "google.golang.org/protobuf/internal/testprotos/annotation";
+
+extend google.protobuf.MessageOptions {
+  // Setting this on a message enables tracking of which fields in the message
+  // a specific binary might access. As a consequence, it also disables the use
+  // of the message accessor methods to satisfy interfaces: they can only be
+  // called directly.
+  optional bool track_field_use = 37383685;
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/benchmarks.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/benchmarks.pb.go
new file mode 100644
index 000000000..c3a987fc0
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/benchmarks.pb.go
@@ -0,0 +1,205 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: benchmarks.proto
+
+package benchmarks
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type BenchmarkDataset struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// Name of the benchmark dataset.  This should be unique across all datasets.
+	// Should only contain word characters: [a-zA-Z0-9_]
+	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
+	// Fully-qualified name of the protobuf message for this dataset.
+	// It will be one of the messages defined benchmark_messages_proto2.proto
+	// or benchmark_messages_proto3.proto.
+	//
+	// Implementations that do not support reflection can implement this with
+	// an explicit "if/else" chain that lists every known message defined
+	// in those files.
+	MessageName string `protobuf:"bytes,2,opt,name=message_name,json=messageName,proto3" json:"message_name,omitempty"`
+	// The payload(s) for this dataset.  They should be parsed or serialized
+	// in sequence, in a loop, ie.
+	//
+	//  while (!benchmarkDone) {  // Benchmark runner decides when to exit.
+	//    for (i = 0; i < benchmark.payload.length; i++) {
+	//      parse(benchmark.payload[i])
+	//    }
+	//  }
+	//
+	// This is intended to let datasets include a variety of data to provide
+	// potentially more realistic results than just parsing the same message
+	// over and over.  A single message parsed repeatedly could yield unusually
+	// good branch prediction performance.
+	Payload [][]byte `protobuf:"bytes,3,rep,name=payload,proto3" json:"payload,omitempty"`
+}
+
+func (x *BenchmarkDataset) Reset() {
+	*x = BenchmarkDataset{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_benchmarks_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *BenchmarkDataset) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BenchmarkDataset) ProtoMessage() {}
+
+func (x *BenchmarkDataset) ProtoReflect() protoreflect.Message {
+	mi := &file_benchmarks_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use BenchmarkDataset.ProtoReflect.Descriptor instead.
+func (*BenchmarkDataset) Descriptor() ([]byte, []int) {
+	return file_benchmarks_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *BenchmarkDataset) GetName() string {
+	if x != nil {
+		return x.Name
+	}
+	return ""
+}
+
+func (x *BenchmarkDataset) GetMessageName() string {
+	if x != nil {
+		return x.MessageName
+	}
+	return ""
+}
+
+func (x *BenchmarkDataset) GetPayload() [][]byte {
+	if x != nil {
+		return x.Payload
+	}
+	return nil
+}
+
+var File_benchmarks_proto protoreflect.FileDescriptor
+
+var file_benchmarks_proto_rawDesc = []byte{
+	0x0a, 0x10, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x12, 0x0a, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x22, 0x63,
+	0x0a, 0x10, 0x42, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x44, 0x61, 0x74, 0x61, 0x73,
+	0x65, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x61, 0x79,
+	0x6c, 0x6f, 0x61, 0x64, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x07, 0x70, 0x61, 0x79, 0x6c,
+	0x6f, 0x61, 0x64, 0x42, 0x20, 0x0a, 0x1e, 0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_benchmarks_proto_rawDescOnce sync.Once
+	file_benchmarks_proto_rawDescData = file_benchmarks_proto_rawDesc
+)
+
+func file_benchmarks_proto_rawDescGZIP() []byte {
+	file_benchmarks_proto_rawDescOnce.Do(func() {
+		file_benchmarks_proto_rawDescData = protoimpl.X.CompressGZIP(file_benchmarks_proto_rawDescData)
+	})
+	return file_benchmarks_proto_rawDescData
+}
+
+var file_benchmarks_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_benchmarks_proto_goTypes = []interface{}{
+	(*BenchmarkDataset)(nil), // 0: benchmarks.BenchmarkDataset
+}
+var file_benchmarks_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_benchmarks_proto_init() }
+func file_benchmarks_proto_init() {
+	if File_benchmarks_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_benchmarks_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*BenchmarkDataset); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_benchmarks_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_benchmarks_proto_goTypes,
+		DependencyIndexes: file_benchmarks_proto_depIdxs,
+		MessageInfos:      file_benchmarks_proto_msgTypes,
+	}.Build()
+	File_benchmarks_proto = out.File
+	file_benchmarks_proto_rawDesc = nil
+	file_benchmarks_proto_goTypes = nil
+	file_benchmarks_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message1/proto2/benchmark_message1_proto2.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message1/proto2/benchmark_message1_proto2.pb.go
new file mode 100644
index 000000000..df9149c76
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message1/proto2/benchmark_message1_proto2.pb.go
@@ -0,0 +1,858 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Benchmark messages for proto2.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: datasets/google_message1/proto2/benchmark_message1_proto2.proto
+
+package proto2
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type GoogleMessage1 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field1   *string                   `protobuf:"bytes,1,req,name=field1" json:"field1,omitempty"`
+	Field9   *string                   `protobuf:"bytes,9,opt,name=field9" json:"field9,omitempty"`
+	Field18  *string                   `protobuf:"bytes,18,opt,name=field18" json:"field18,omitempty"`
+	Field80  *bool                     `protobuf:"varint,80,opt,name=field80,def=0" json:"field80,omitempty"`
+	Field81  *bool                     `protobuf:"varint,81,opt,name=field81,def=1" json:"field81,omitempty"`
+	Field2   *int32                    `protobuf:"varint,2,req,name=field2" json:"field2,omitempty"`
+	Field3   *int32                    `protobuf:"varint,3,req,name=field3" json:"field3,omitempty"`
+	Field280 *int32                    `protobuf:"varint,280,opt,name=field280" json:"field280,omitempty"`
+	Field6   *int32                    `protobuf:"varint,6,opt,name=field6,def=0" json:"field6,omitempty"`
+	Field22  *int64                    `protobuf:"varint,22,opt,name=field22" json:"field22,omitempty"`
+	Field4   *string                   `protobuf:"bytes,4,opt,name=field4" json:"field4,omitempty"`
+	Field5   []uint64                  `protobuf:"fixed64,5,rep,name=field5" json:"field5,omitempty"`
+	Field59  *bool                     `protobuf:"varint,59,opt,name=field59,def=0" json:"field59,omitempty"`
+	Field7   *string                   `protobuf:"bytes,7,opt,name=field7" json:"field7,omitempty"`
+	Field16  *int32                    `protobuf:"varint,16,opt,name=field16" json:"field16,omitempty"`
+	Field130 *int32                    `protobuf:"varint,130,opt,name=field130,def=0" json:"field130,omitempty"`
+	Field12  *bool                     `protobuf:"varint,12,opt,name=field12,def=1" json:"field12,omitempty"`
+	Field17  *bool                     `protobuf:"varint,17,opt,name=field17,def=1" json:"field17,omitempty"`
+	Field13  *bool                     `protobuf:"varint,13,opt,name=field13,def=1" json:"field13,omitempty"`
+	Field14  *bool                     `protobuf:"varint,14,opt,name=field14,def=1" json:"field14,omitempty"`
+	Field104 *int32                    `protobuf:"varint,104,opt,name=field104,def=0" json:"field104,omitempty"`
+	Field100 *int32                    `protobuf:"varint,100,opt,name=field100,def=0" json:"field100,omitempty"`
+	Field101 *int32                    `protobuf:"varint,101,opt,name=field101,def=0" json:"field101,omitempty"`
+	Field102 *string                   `protobuf:"bytes,102,opt,name=field102" json:"field102,omitempty"`
+	Field103 *string                   `protobuf:"bytes,103,opt,name=field103" json:"field103,omitempty"`
+	Field29  *int32                    `protobuf:"varint,29,opt,name=field29,def=0" json:"field29,omitempty"`
+	Field30  *bool                     `protobuf:"varint,30,opt,name=field30,def=0" json:"field30,omitempty"`
+	Field60  *int32                    `protobuf:"varint,60,opt,name=field60,def=-1" json:"field60,omitempty"`
+	Field271 *int32                    `protobuf:"varint,271,opt,name=field271,def=-1" json:"field271,omitempty"`
+	Field272 *int32                    `protobuf:"varint,272,opt,name=field272,def=-1" json:"field272,omitempty"`
+	Field150 *int32                    `protobuf:"varint,150,opt,name=field150" json:"field150,omitempty"`
+	Field23  *int32                    `protobuf:"varint,23,opt,name=field23,def=0" json:"field23,omitempty"`
+	Field24  *bool                     `protobuf:"varint,24,opt,name=field24,def=0" json:"field24,omitempty"`
+	Field25  *int32                    `protobuf:"varint,25,opt,name=field25,def=0" json:"field25,omitempty"`
+	Field15  *GoogleMessage1SubMessage `protobuf:"bytes,15,opt,name=field15" json:"field15,omitempty"`
+	Field78  *bool                     `protobuf:"varint,78,opt,name=field78" json:"field78,omitempty"`
+	Field67  *int32                    `protobuf:"varint,67,opt,name=field67,def=0" json:"field67,omitempty"`
+	Field68  *int32                    `protobuf:"varint,68,opt,name=field68" json:"field68,omitempty"`
+	Field128 *int32                    `protobuf:"varint,128,opt,name=field128,def=0" json:"field128,omitempty"`
+	Field129 *string                   `protobuf:"bytes,129,opt,name=field129,def=xxxxxxxxxxxxxxxxxxxxx" json:"field129,omitempty"`
+	Field131 *int32                    `protobuf:"varint,131,opt,name=field131,def=0" json:"field131,omitempty"`
+}
+
+// Default values for GoogleMessage1 fields.
+const (
+	Default_GoogleMessage1_Field80  = bool(false)
+	Default_GoogleMessage1_Field81  = bool(true)
+	Default_GoogleMessage1_Field6   = int32(0)
+	Default_GoogleMessage1_Field59  = bool(false)
+	Default_GoogleMessage1_Field130 = int32(0)
+	Default_GoogleMessage1_Field12  = bool(true)
+	Default_GoogleMessage1_Field17  = bool(true)
+	Default_GoogleMessage1_Field13  = bool(true)
+	Default_GoogleMessage1_Field14  = bool(true)
+	Default_GoogleMessage1_Field104 = int32(0)
+	Default_GoogleMessage1_Field100 = int32(0)
+	Default_GoogleMessage1_Field101 = int32(0)
+	Default_GoogleMessage1_Field29  = int32(0)
+	Default_GoogleMessage1_Field30  = bool(false)
+	Default_GoogleMessage1_Field60  = int32(-1)
+	Default_GoogleMessage1_Field271 = int32(-1)
+	Default_GoogleMessage1_Field272 = int32(-1)
+	Default_GoogleMessage1_Field23  = int32(0)
+	Default_GoogleMessage1_Field24  = bool(false)
+	Default_GoogleMessage1_Field25  = int32(0)
+	Default_GoogleMessage1_Field67  = int32(0)
+	Default_GoogleMessage1_Field128 = int32(0)
+	Default_GoogleMessage1_Field129 = string("xxxxxxxxxxxxxxxxxxxxx")
+	Default_GoogleMessage1_Field131 = int32(0)
+)
+
+func (x *GoogleMessage1) Reset() {
+	*x = GoogleMessage1{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message1_proto2_benchmark_message1_proto2_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *GoogleMessage1) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GoogleMessage1) ProtoMessage() {}
+
+func (x *GoogleMessage1) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message1_proto2_benchmark_message1_proto2_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use GoogleMessage1.ProtoReflect.Descriptor instead.
+func (*GoogleMessage1) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message1_proto2_benchmark_message1_proto2_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *GoogleMessage1) GetField1() string {
+	if x != nil && x.Field1 != nil {
+		return *x.Field1
+	}
+	return ""
+}
+
+func (x *GoogleMessage1) GetField9() string {
+	if x != nil && x.Field9 != nil {
+		return *x.Field9
+	}
+	return ""
+}
+
+func (x *GoogleMessage1) GetField18() string {
+	if x != nil && x.Field18 != nil {
+		return *x.Field18
+	}
+	return ""
+}
+
+func (x *GoogleMessage1) GetField80() bool {
+	if x != nil && x.Field80 != nil {
+		return *x.Field80
+	}
+	return Default_GoogleMessage1_Field80
+}
+
+func (x *GoogleMessage1) GetField81() bool {
+	if x != nil && x.Field81 != nil {
+		return *x.Field81
+	}
+	return Default_GoogleMessage1_Field81
+}
+
+func (x *GoogleMessage1) GetField2() int32 {
+	if x != nil && x.Field2 != nil {
+		return *x.Field2
+	}
+	return 0
+}
+
+func (x *GoogleMessage1) GetField3() int32 {
+	if x != nil && x.Field3 != nil {
+		return *x.Field3
+	}
+	return 0
+}
+
+func (x *GoogleMessage1) GetField280() int32 {
+	if x != nil && x.Field280 != nil {
+		return *x.Field280
+	}
+	return 0
+}
+
+func (x *GoogleMessage1) GetField6() int32 {
+	if x != nil && x.Field6 != nil {
+		return *x.Field6
+	}
+	return Default_GoogleMessage1_Field6
+}
+
+func (x *GoogleMessage1) GetField22() int64 {
+	if x != nil && x.Field22 != nil {
+		return *x.Field22
+	}
+	return 0
+}
+
+func (x *GoogleMessage1) GetField4() string {
+	if x != nil && x.Field4 != nil {
+		return *x.Field4
+	}
+	return ""
+}
+
+func (x *GoogleMessage1) GetField5() []uint64 {
+	if x != nil {
+		return x.Field5
+	}
+	return nil
+}
+
+func (x *GoogleMessage1) GetField59() bool {
+	if x != nil && x.Field59 != nil {
+		return *x.Field59
+	}
+	return Default_GoogleMessage1_Field59
+}
+
+func (x *GoogleMessage1) GetField7() string {
+	if x != nil && x.Field7 != nil {
+		return *x.Field7
+	}
+	return ""
+}
+
+func (x *GoogleMessage1) GetField16() int32 {
+	if x != nil && x.Field16 != nil {
+		return *x.Field16
+	}
+	return 0
+}
+
+func (x *GoogleMessage1) GetField130() int32 {
+	if x != nil && x.Field130 != nil {
+		return *x.Field130
+	}
+	return Default_GoogleMessage1_Field130
+}
+
+func (x *GoogleMessage1) GetField12() bool {
+	if x != nil && x.Field12 != nil {
+		return *x.Field12
+	}
+	return Default_GoogleMessage1_Field12
+}
+
+func (x *GoogleMessage1) GetField17() bool {
+	if x != nil && x.Field17 != nil {
+		return *x.Field17
+	}
+	return Default_GoogleMessage1_Field17
+}
+
+func (x *GoogleMessage1) GetField13() bool {
+	if x != nil && x.Field13 != nil {
+		return *x.Field13
+	}
+	return Default_GoogleMessage1_Field13
+}
+
+func (x *GoogleMessage1) GetField14() bool {
+	if x != nil && x.Field14 != nil {
+		return *x.Field14
+	}
+	return Default_GoogleMessage1_Field14
+}
+
+func (x *GoogleMessage1) GetField104() int32 {
+	if x != nil && x.Field104 != nil {
+		return *x.Field104
+	}
+	return Default_GoogleMessage1_Field104
+}
+
+func (x *GoogleMessage1) GetField100() int32 {
+	if x != nil && x.Field100 != nil {
+		return *x.Field100
+	}
+	return Default_GoogleMessage1_Field100
+}
+
+func (x *GoogleMessage1) GetField101() int32 {
+	if x != nil && x.Field101 != nil {
+		return *x.Field101
+	}
+	return Default_GoogleMessage1_Field101
+}
+
+func (x *GoogleMessage1) GetField102() string {
+	if x != nil && x.Field102 != nil {
+		return *x.Field102
+	}
+	return ""
+}
+
+func (x *GoogleMessage1) GetField103() string {
+	if x != nil && x.Field103 != nil {
+		return *x.Field103
+	}
+	return ""
+}
+
+func (x *GoogleMessage1) GetField29() int32 {
+	if x != nil && x.Field29 != nil {
+		return *x.Field29
+	}
+	return Default_GoogleMessage1_Field29
+}
+
+func (x *GoogleMessage1) GetField30() bool {
+	if x != nil && x.Field30 != nil {
+		return *x.Field30
+	}
+	return Default_GoogleMessage1_Field30
+}
+
+func (x *GoogleMessage1) GetField60() int32 {
+	if x != nil && x.Field60 != nil {
+		return *x.Field60
+	}
+	return Default_GoogleMessage1_Field60
+}
+
+func (x *GoogleMessage1) GetField271() int32 {
+	if x != nil && x.Field271 != nil {
+		return *x.Field271
+	}
+	return Default_GoogleMessage1_Field271
+}
+
+func (x *GoogleMessage1) GetField272() int32 {
+	if x != nil && x.Field272 != nil {
+		return *x.Field272
+	}
+	return Default_GoogleMessage1_Field272
+}
+
+func (x *GoogleMessage1) GetField150() int32 {
+	if x != nil && x.Field150 != nil {
+		return *x.Field150
+	}
+	return 0
+}
+
+func (x *GoogleMessage1) GetField23() int32 {
+	if x != nil && x.Field23 != nil {
+		return *x.Field23
+	}
+	return Default_GoogleMessage1_Field23
+}
+
+func (x *GoogleMessage1) GetField24() bool {
+	if x != nil && x.Field24 != nil {
+		return *x.Field24
+	}
+	return Default_GoogleMessage1_Field24
+}
+
+func (x *GoogleMessage1) GetField25() int32 {
+	if x != nil && x.Field25 != nil {
+		return *x.Field25
+	}
+	return Default_GoogleMessage1_Field25
+}
+
+func (x *GoogleMessage1) GetField15() *GoogleMessage1SubMessage {
+	if x != nil {
+		return x.Field15
+	}
+	return nil
+}
+
+func (x *GoogleMessage1) GetField78() bool {
+	if x != nil && x.Field78 != nil {
+		return *x.Field78
+	}
+	return false
+}
+
+func (x *GoogleMessage1) GetField67() int32 {
+	if x != nil && x.Field67 != nil {
+		return *x.Field67
+	}
+	return Default_GoogleMessage1_Field67
+}
+
+func (x *GoogleMessage1) GetField68() int32 {
+	if x != nil && x.Field68 != nil {
+		return *x.Field68
+	}
+	return 0
+}
+
+func (x *GoogleMessage1) GetField128() int32 {
+	if x != nil && x.Field128 != nil {
+		return *x.Field128
+	}
+	return Default_GoogleMessage1_Field128
+}
+
+func (x *GoogleMessage1) GetField129() string {
+	if x != nil && x.Field129 != nil {
+		return *x.Field129
+	}
+	return Default_GoogleMessage1_Field129
+}
+
+func (x *GoogleMessage1) GetField131() int32 {
+	if x != nil && x.Field131 != nil {
+		return *x.Field131
+	}
+	return Default_GoogleMessage1_Field131
+}
+
+type GoogleMessage1SubMessage struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field1   *int32  `protobuf:"varint,1,opt,name=field1,def=0" json:"field1,omitempty"`
+	Field2   *int32  `protobuf:"varint,2,opt,name=field2,def=0" json:"field2,omitempty"`
+	Field3   *int32  `protobuf:"varint,3,opt,name=field3,def=0" json:"field3,omitempty"`
+	Field15  *string `protobuf:"bytes,15,opt,name=field15" json:"field15,omitempty"`
+	Field12  *bool   `protobuf:"varint,12,opt,name=field12,def=1" json:"field12,omitempty"`
+	Field13  *int64  `protobuf:"varint,13,opt,name=field13" json:"field13,omitempty"`
+	Field14  *int64  `protobuf:"varint,14,opt,name=field14" json:"field14,omitempty"`
+	Field16  *int32  `protobuf:"varint,16,opt,name=field16" json:"field16,omitempty"`
+	Field19  *int32  `protobuf:"varint,19,opt,name=field19,def=2" json:"field19,omitempty"`
+	Field20  *bool   `protobuf:"varint,20,opt,name=field20,def=1" json:"field20,omitempty"`
+	Field28  *bool   `protobuf:"varint,28,opt,name=field28,def=1" json:"field28,omitempty"`
+	Field21  *uint64 `protobuf:"fixed64,21,opt,name=field21" json:"field21,omitempty"`
+	Field22  *int32  `protobuf:"varint,22,opt,name=field22" json:"field22,omitempty"`
+	Field23  *bool   `protobuf:"varint,23,opt,name=field23,def=0" json:"field23,omitempty"`
+	Field206 *bool   `protobuf:"varint,206,opt,name=field206,def=0" json:"field206,omitempty"`
+	Field203 *uint32 `protobuf:"fixed32,203,opt,name=field203" json:"field203,omitempty"`
+	Field204 *int32  `protobuf:"varint,204,opt,name=field204" json:"field204,omitempty"`
+	Field205 *string `protobuf:"bytes,205,opt,name=field205" json:"field205,omitempty"`
+	Field207 *uint64 `protobuf:"varint,207,opt,name=field207" json:"field207,omitempty"`
+	Field300 *uint64 `protobuf:"varint,300,opt,name=field300" json:"field300,omitempty"`
+}
+
+// Default values for GoogleMessage1SubMessage fields.
+const (
+	Default_GoogleMessage1SubMessage_Field1   = int32(0)
+	Default_GoogleMessage1SubMessage_Field2   = int32(0)
+	Default_GoogleMessage1SubMessage_Field3   = int32(0)
+	Default_GoogleMessage1SubMessage_Field12  = bool(true)
+	Default_GoogleMessage1SubMessage_Field19  = int32(2)
+	Default_GoogleMessage1SubMessage_Field20  = bool(true)
+	Default_GoogleMessage1SubMessage_Field28  = bool(true)
+	Default_GoogleMessage1SubMessage_Field23  = bool(false)
+	Default_GoogleMessage1SubMessage_Field206 = bool(false)
+)
+
+func (x *GoogleMessage1SubMessage) Reset() {
+	*x = GoogleMessage1SubMessage{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message1_proto2_benchmark_message1_proto2_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *GoogleMessage1SubMessage) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GoogleMessage1SubMessage) ProtoMessage() {}
+
+func (x *GoogleMessage1SubMessage) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message1_proto2_benchmark_message1_proto2_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use GoogleMessage1SubMessage.ProtoReflect.Descriptor instead.
+func (*GoogleMessage1SubMessage) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message1_proto2_benchmark_message1_proto2_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *GoogleMessage1SubMessage) GetField1() int32 {
+	if x != nil && x.Field1 != nil {
+		return *x.Field1
+	}
+	return Default_GoogleMessage1SubMessage_Field1
+}
+
+func (x *GoogleMessage1SubMessage) GetField2() int32 {
+	if x != nil && x.Field2 != nil {
+		return *x.Field2
+	}
+	return Default_GoogleMessage1SubMessage_Field2
+}
+
+func (x *GoogleMessage1SubMessage) GetField3() int32 {
+	if x != nil && x.Field3 != nil {
+		return *x.Field3
+	}
+	return Default_GoogleMessage1SubMessage_Field3
+}
+
+func (x *GoogleMessage1SubMessage) GetField15() string {
+	if x != nil && x.Field15 != nil {
+		return *x.Field15
+	}
+	return ""
+}
+
+func (x *GoogleMessage1SubMessage) GetField12() bool {
+	if x != nil && x.Field12 != nil {
+		return *x.Field12
+	}
+	return Default_GoogleMessage1SubMessage_Field12
+}
+
+func (x *GoogleMessage1SubMessage) GetField13() int64 {
+	if x != nil && x.Field13 != nil {
+		return *x.Field13
+	}
+	return 0
+}
+
+func (x *GoogleMessage1SubMessage) GetField14() int64 {
+	if x != nil && x.Field14 != nil {
+		return *x.Field14
+	}
+	return 0
+}
+
+func (x *GoogleMessage1SubMessage) GetField16() int32 {
+	if x != nil && x.Field16 != nil {
+		return *x.Field16
+	}
+	return 0
+}
+
+func (x *GoogleMessage1SubMessage) GetField19() int32 {
+	if x != nil && x.Field19 != nil {
+		return *x.Field19
+	}
+	return Default_GoogleMessage1SubMessage_Field19
+}
+
+func (x *GoogleMessage1SubMessage) GetField20() bool {
+	if x != nil && x.Field20 != nil {
+		return *x.Field20
+	}
+	return Default_GoogleMessage1SubMessage_Field20
+}
+
+func (x *GoogleMessage1SubMessage) GetField28() bool {
+	if x != nil && x.Field28 != nil {
+		return *x.Field28
+	}
+	return Default_GoogleMessage1SubMessage_Field28
+}
+
+func (x *GoogleMessage1SubMessage) GetField21() uint64 {
+	if x != nil && x.Field21 != nil {
+		return *x.Field21
+	}
+	return 0
+}
+
+func (x *GoogleMessage1SubMessage) GetField22() int32 {
+	if x != nil && x.Field22 != nil {
+		return *x.Field22
+	}
+	return 0
+}
+
+func (x *GoogleMessage1SubMessage) GetField23() bool {
+	if x != nil && x.Field23 != nil {
+		return *x.Field23
+	}
+	return Default_GoogleMessage1SubMessage_Field23
+}
+
+func (x *GoogleMessage1SubMessage) GetField206() bool {
+	if x != nil && x.Field206 != nil {
+		return *x.Field206
+	}
+	return Default_GoogleMessage1SubMessage_Field206
+}
+
+func (x *GoogleMessage1SubMessage) GetField203() uint32 {
+	if x != nil && x.Field203 != nil {
+		return *x.Field203
+	}
+	return 0
+}
+
+func (x *GoogleMessage1SubMessage) GetField204() int32 {
+	if x != nil && x.Field204 != nil {
+		return *x.Field204
+	}
+	return 0
+}
+
+func (x *GoogleMessage1SubMessage) GetField205() string {
+	if x != nil && x.Field205 != nil {
+		return *x.Field205
+	}
+	return ""
+}
+
+func (x *GoogleMessage1SubMessage) GetField207() uint64 {
+	if x != nil && x.Field207 != nil {
+		return *x.Field207
+	}
+	return 0
+}
+
+func (x *GoogleMessage1SubMessage) GetField300() uint64 {
+	if x != nil && x.Field300 != nil {
+		return *x.Field300
+	}
+	return 0
+}
+
+var File_datasets_google_message1_proto2_benchmark_message1_proto2_proto protoreflect.FileDescriptor
+
+var file_datasets_google_message1_proto2_benchmark_message1_proto2_proto_rawDesc = []byte{
+	0x0a, 0x3f, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x32, 0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x31, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x12, 0x11, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x32, 0x22, 0xf7, 0x09, 0x0a, 0x0e, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x12, 0x16, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x18, 0x01, 0x20, 0x02, 0x28, 0x09, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x12,
+	0x16, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x38, 0x18, 0x12, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x38, 0x12, 0x1f, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x30, 0x18, 0x50, 0x20, 0x01,
+	0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x30, 0x12, 0x1e, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x18, 0x51, 0x20,
+	0x01, 0x28, 0x08, 0x3a, 0x04, 0x74, 0x72, 0x75, 0x65, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x31, 0x12, 0x16, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x18, 0x02, 0x20, 0x02,
+	0x28, 0x05, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x12, 0x16, 0x0a, 0x06, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x18, 0x03, 0x20, 0x02, 0x28, 0x05, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x12, 0x1b, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x38, 0x30, 0x18, 0x98,
+	0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x38, 0x30, 0x12,
+	0x19, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x3a,
+	0x01, 0x30, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x32, 0x18, 0x16, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x32, 0x32, 0x12, 0x16, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x18, 0x04,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x12, 0x16, 0x0a, 0x06,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x18, 0x05, 0x20, 0x03, 0x28, 0x06, 0x52, 0x06, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x35, 0x12, 0x1f, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x18,
+	0x3b, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x07, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x35, 0x39, 0x12, 0x16, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x18,
+	0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x12, 0x18, 0x0a,
+	0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x18, 0x10, 0x20, 0x01, 0x28, 0x05, 0x52, 0x07,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x12, 0x1e, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x33, 0x30, 0x18, 0x82, 0x01, 0x20, 0x01, 0x28, 0x05, 0x3a, 0x01, 0x30, 0x52, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x30, 0x12, 0x1e, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x04, 0x74, 0x72, 0x75, 0x65, 0x52, 0x07,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x12, 0x1e, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x37, 0x18, 0x11, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x04, 0x74, 0x72, 0x75, 0x65, 0x52, 0x07,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x12, 0x1e, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x33, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x04, 0x74, 0x72, 0x75, 0x65, 0x52, 0x07,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x12, 0x1e, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x34, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x04, 0x74, 0x72, 0x75, 0x65, 0x52, 0x07,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x34, 0x12, 0x1d, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x30, 0x34, 0x18, 0x68, 0x20, 0x01, 0x28, 0x05, 0x3a, 0x01, 0x30, 0x52, 0x08, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x30, 0x34, 0x12, 0x1d, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x30, 0x30, 0x18, 0x64, 0x20, 0x01, 0x28, 0x05, 0x3a, 0x01, 0x30, 0x52, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x30, 0x30, 0x12, 0x1d, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30,
+	0x31, 0x18, 0x65, 0x20, 0x01, 0x28, 0x05, 0x3a, 0x01, 0x30, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x30, 0x31, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32,
+	0x18, 0x66, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32,
+	0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x18, 0x67, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x12, 0x1b, 0x0a, 0x07,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x39, 0x18, 0x1d, 0x20, 0x01, 0x28, 0x05, 0x3a, 0x01, 0x30,
+	0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x39, 0x12, 0x1f, 0x0a, 0x07, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x30, 0x18, 0x1e, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73,
+	0x65, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x30, 0x12, 0x1c, 0x0a, 0x07, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x36, 0x30, 0x18, 0x3c, 0x20, 0x01, 0x28, 0x05, 0x3a, 0x02, 0x2d, 0x31, 0x52,
+	0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x12, 0x1f, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x37, 0x31, 0x18, 0x8f, 0x02, 0x20, 0x01, 0x28, 0x05, 0x3a, 0x02, 0x2d, 0x31, 0x52,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x31, 0x12, 0x1f, 0x0a, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x32, 0x37, 0x32, 0x18, 0x90, 0x02, 0x20, 0x01, 0x28, 0x05, 0x3a, 0x02, 0x2d, 0x31,
+	0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x32, 0x12, 0x1b, 0x0a, 0x08, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x35, 0x30, 0x18, 0x96, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x35, 0x30, 0x12, 0x1b, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x33, 0x18, 0x17, 0x20, 0x01, 0x28, 0x05, 0x3a, 0x01, 0x30, 0x52, 0x07, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x32, 0x33, 0x12, 0x1f, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x18,
+	0x18, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x07, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x34, 0x12, 0x1b, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x35,
+	0x18, 0x19, 0x20, 0x01, 0x28, 0x05, 0x3a, 0x01, 0x30, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x35, 0x12, 0x45, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x35, 0x18, 0x0f, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x53, 0x75, 0x62, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x35, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x37, 0x38, 0x18, 0x4e, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x38, 0x12, 0x1b, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x18, 0x43,
+	0x20, 0x01, 0x28, 0x05, 0x3a, 0x01, 0x30, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37,
+	0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x38, 0x18, 0x44, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x38, 0x12, 0x1e, 0x0a, 0x08, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x18, 0x80, 0x01, 0x20, 0x01, 0x28, 0x05, 0x3a, 0x01, 0x30,
+	0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x12, 0x32, 0x0a, 0x08, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x18, 0x81, 0x01, 0x20, 0x01, 0x28, 0x09, 0x3a, 0x15, 0x78,
+	0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+	0x78, 0x78, 0x78, 0x78, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x12, 0x1e,
+	0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x31, 0x18, 0x83, 0x01, 0x20, 0x01, 0x28,
+	0x05, 0x3a, 0x01, 0x30, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x31, 0x22, 0xda,
+	0x04, 0x0a, 0x18, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x31, 0x53, 0x75, 0x62, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x19, 0x0a, 0x06, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x3a, 0x01, 0x30, 0x52, 0x06,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x12, 0x19, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x3a, 0x01, 0x30, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x12, 0x19, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x18, 0x03, 0x20, 0x01, 0x28,
+	0x05, 0x3a, 0x01, 0x30, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x12, 0x18, 0x0a, 0x07,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x35, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x35, 0x12, 0x1e, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x04, 0x74, 0x72, 0x75, 0x65, 0x52, 0x07, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x33, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33,
+	0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x34, 0x18, 0x0e, 0x20, 0x01, 0x28,
+	0x03, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x34, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x36, 0x18, 0x10, 0x20, 0x01, 0x28, 0x05, 0x52, 0x07, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x36, 0x12, 0x1b, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x39, 0x18,
+	0x13, 0x20, 0x01, 0x28, 0x05, 0x3a, 0x01, 0x32, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x39, 0x12, 0x1e, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x30, 0x18, 0x14, 0x20, 0x01,
+	0x28, 0x08, 0x3a, 0x04, 0x74, 0x72, 0x75, 0x65, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x30, 0x12, 0x1e, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x38, 0x18, 0x1c, 0x20, 0x01,
+	0x28, 0x08, 0x3a, 0x04, 0x74, 0x72, 0x75, 0x65, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x38, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x31, 0x18, 0x15, 0x20, 0x01,
+	0x28, 0x06, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x31, 0x12, 0x18, 0x0a, 0x07, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x32, 0x18, 0x16, 0x20, 0x01, 0x28, 0x05, 0x52, 0x07, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x32, 0x12, 0x1f, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33,
+	0x18, 0x17, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x07, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x12, 0x22, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x30, 0x36, 0x18, 0xce, 0x01, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65,
+	0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x30, 0x36, 0x12, 0x1b, 0x0a, 0x08, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x30, 0x33, 0x18, 0xcb, 0x01, 0x20, 0x01, 0x28, 0x07, 0x52, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x30, 0x33, 0x12, 0x1b, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x30, 0x34, 0x18, 0xcc, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x30, 0x34, 0x12, 0x1b, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x30, 0x35,
+	0x18, 0xcd, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x30,
+	0x35, 0x12, 0x1b, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x30, 0x37, 0x18, 0xcf, 0x01,
+	0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x30, 0x37, 0x12, 0x1b,
+	0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x30, 0x30, 0x18, 0xac, 0x02, 0x20, 0x01, 0x28,
+	0x04, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x30, 0x30, 0x42, 0x25, 0x0a, 0x1e, 0x63,
+	0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
+	0x75, 0x66, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x48, 0x01, 0xf8,
+	0x01, 0x01,
+}
+
+var (
+	file_datasets_google_message1_proto2_benchmark_message1_proto2_proto_rawDescOnce sync.Once
+	file_datasets_google_message1_proto2_benchmark_message1_proto2_proto_rawDescData = file_datasets_google_message1_proto2_benchmark_message1_proto2_proto_rawDesc
+)
+
+func file_datasets_google_message1_proto2_benchmark_message1_proto2_proto_rawDescGZIP() []byte {
+	file_datasets_google_message1_proto2_benchmark_message1_proto2_proto_rawDescOnce.Do(func() {
+		file_datasets_google_message1_proto2_benchmark_message1_proto2_proto_rawDescData = protoimpl.X.CompressGZIP(file_datasets_google_message1_proto2_benchmark_message1_proto2_proto_rawDescData)
+	})
+	return file_datasets_google_message1_proto2_benchmark_message1_proto2_proto_rawDescData
+}
+
+var file_datasets_google_message1_proto2_benchmark_message1_proto2_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
+var file_datasets_google_message1_proto2_benchmark_message1_proto2_proto_goTypes = []interface{}{
+	(*GoogleMessage1)(nil),           // 0: benchmarks.proto2.GoogleMessage1
+	(*GoogleMessage1SubMessage)(nil), // 1: benchmarks.proto2.GoogleMessage1SubMessage
+}
+var file_datasets_google_message1_proto2_benchmark_message1_proto2_proto_depIdxs = []int32{
+	1, // 0: benchmarks.proto2.GoogleMessage1.field15:type_name -> benchmarks.proto2.GoogleMessage1SubMessage
+	1, // [1:1] is the sub-list for method output_type
+	1, // [1:1] is the sub-list for method input_type
+	1, // [1:1] is the sub-list for extension type_name
+	1, // [1:1] is the sub-list for extension extendee
+	0, // [0:1] is the sub-list for field type_name
+}
+
+func init() { file_datasets_google_message1_proto2_benchmark_message1_proto2_proto_init() }
+func file_datasets_google_message1_proto2_benchmark_message1_proto2_proto_init() {
+	if File_datasets_google_message1_proto2_benchmark_message1_proto2_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_datasets_google_message1_proto2_benchmark_message1_proto2_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GoogleMessage1); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message1_proto2_benchmark_message1_proto2_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GoogleMessage1SubMessage); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_datasets_google_message1_proto2_benchmark_message1_proto2_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   2,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_datasets_google_message1_proto2_benchmark_message1_proto2_proto_goTypes,
+		DependencyIndexes: file_datasets_google_message1_proto2_benchmark_message1_proto2_proto_depIdxs,
+		MessageInfos:      file_datasets_google_message1_proto2_benchmark_message1_proto2_proto_msgTypes,
+	}.Build()
+	File_datasets_google_message1_proto2_benchmark_message1_proto2_proto = out.File
+	file_datasets_google_message1_proto2_benchmark_message1_proto2_proto_rawDesc = nil
+	file_datasets_google_message1_proto2_benchmark_message1_proto2_proto_goTypes = nil
+	file_datasets_google_message1_proto2_benchmark_message1_proto2_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message1/proto3/benchmark_message1_proto3.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message1/proto3/benchmark_message1_proto3.pb.go
new file mode 100644
index 000000000..a26489552
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message1/proto3/benchmark_message1_proto3.pb.go
@@ -0,0 +1,806 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Benchmark messages for proto3.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: datasets/google_message1/proto3/benchmark_message1_proto3.proto
+
+package proto3
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type GoogleMessage1 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field1   string                    `protobuf:"bytes,1,opt,name=field1,proto3" json:"field1,omitempty"`
+	Field9   string                    `protobuf:"bytes,9,opt,name=field9,proto3" json:"field9,omitempty"`
+	Field18  string                    `protobuf:"bytes,18,opt,name=field18,proto3" json:"field18,omitempty"`
+	Field80  bool                      `protobuf:"varint,80,opt,name=field80,proto3" json:"field80,omitempty"`
+	Field81  bool                      `protobuf:"varint,81,opt,name=field81,proto3" json:"field81,omitempty"`
+	Field2   int32                     `protobuf:"varint,2,opt,name=field2,proto3" json:"field2,omitempty"`
+	Field3   int32                     `protobuf:"varint,3,opt,name=field3,proto3" json:"field3,omitempty"`
+	Field280 int32                     `protobuf:"varint,280,opt,name=field280,proto3" json:"field280,omitempty"`
+	Field6   int32                     `protobuf:"varint,6,opt,name=field6,proto3" json:"field6,omitempty"`
+	Field22  int64                     `protobuf:"varint,22,opt,name=field22,proto3" json:"field22,omitempty"`
+	Field4   string                    `protobuf:"bytes,4,opt,name=field4,proto3" json:"field4,omitempty"`
+	Field5   []uint64                  `protobuf:"fixed64,5,rep,packed,name=field5,proto3" json:"field5,omitempty"`
+	Field59  bool                      `protobuf:"varint,59,opt,name=field59,proto3" json:"field59,omitempty"`
+	Field7   string                    `protobuf:"bytes,7,opt,name=field7,proto3" json:"field7,omitempty"`
+	Field16  int32                     `protobuf:"varint,16,opt,name=field16,proto3" json:"field16,omitempty"`
+	Field130 int32                     `protobuf:"varint,130,opt,name=field130,proto3" json:"field130,omitempty"`
+	Field12  bool                      `protobuf:"varint,12,opt,name=field12,proto3" json:"field12,omitempty"`
+	Field17  bool                      `protobuf:"varint,17,opt,name=field17,proto3" json:"field17,omitempty"`
+	Field13  bool                      `protobuf:"varint,13,opt,name=field13,proto3" json:"field13,omitempty"`
+	Field14  bool                      `protobuf:"varint,14,opt,name=field14,proto3" json:"field14,omitempty"`
+	Field104 int32                     `protobuf:"varint,104,opt,name=field104,proto3" json:"field104,omitempty"`
+	Field100 int32                     `protobuf:"varint,100,opt,name=field100,proto3" json:"field100,omitempty"`
+	Field101 int32                     `protobuf:"varint,101,opt,name=field101,proto3" json:"field101,omitempty"`
+	Field102 string                    `protobuf:"bytes,102,opt,name=field102,proto3" json:"field102,omitempty"`
+	Field103 string                    `protobuf:"bytes,103,opt,name=field103,proto3" json:"field103,omitempty"`
+	Field29  int32                     `protobuf:"varint,29,opt,name=field29,proto3" json:"field29,omitempty"`
+	Field30  bool                      `protobuf:"varint,30,opt,name=field30,proto3" json:"field30,omitempty"`
+	Field60  int32                     `protobuf:"varint,60,opt,name=field60,proto3" json:"field60,omitempty"`
+	Field271 int32                     `protobuf:"varint,271,opt,name=field271,proto3" json:"field271,omitempty"`
+	Field272 int32                     `protobuf:"varint,272,opt,name=field272,proto3" json:"field272,omitempty"`
+	Field150 int32                     `protobuf:"varint,150,opt,name=field150,proto3" json:"field150,omitempty"`
+	Field23  int32                     `protobuf:"varint,23,opt,name=field23,proto3" json:"field23,omitempty"`
+	Field24  bool                      `protobuf:"varint,24,opt,name=field24,proto3" json:"field24,omitempty"`
+	Field25  int32                     `protobuf:"varint,25,opt,name=field25,proto3" json:"field25,omitempty"`
+	Field15  *GoogleMessage1SubMessage `protobuf:"bytes,15,opt,name=field15,proto3" json:"field15,omitempty"`
+	Field78  bool                      `protobuf:"varint,78,opt,name=field78,proto3" json:"field78,omitempty"`
+	Field67  int32                     `protobuf:"varint,67,opt,name=field67,proto3" json:"field67,omitempty"`
+	Field68  int32                     `protobuf:"varint,68,opt,name=field68,proto3" json:"field68,omitempty"`
+	Field128 int32                     `protobuf:"varint,128,opt,name=field128,proto3" json:"field128,omitempty"`
+	Field129 string                    `protobuf:"bytes,129,opt,name=field129,proto3" json:"field129,omitempty"`
+	Field131 int32                     `protobuf:"varint,131,opt,name=field131,proto3" json:"field131,omitempty"`
+}
+
+func (x *GoogleMessage1) Reset() {
+	*x = GoogleMessage1{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message1_proto3_benchmark_message1_proto3_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *GoogleMessage1) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GoogleMessage1) ProtoMessage() {}
+
+func (x *GoogleMessage1) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message1_proto3_benchmark_message1_proto3_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use GoogleMessage1.ProtoReflect.Descriptor instead.
+func (*GoogleMessage1) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message1_proto3_benchmark_message1_proto3_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *GoogleMessage1) GetField1() string {
+	if x != nil {
+		return x.Field1
+	}
+	return ""
+}
+
+func (x *GoogleMessage1) GetField9() string {
+	if x != nil {
+		return x.Field9
+	}
+	return ""
+}
+
+func (x *GoogleMessage1) GetField18() string {
+	if x != nil {
+		return x.Field18
+	}
+	return ""
+}
+
+func (x *GoogleMessage1) GetField80() bool {
+	if x != nil {
+		return x.Field80
+	}
+	return false
+}
+
+func (x *GoogleMessage1) GetField81() bool {
+	if x != nil {
+		return x.Field81
+	}
+	return false
+}
+
+func (x *GoogleMessage1) GetField2() int32 {
+	if x != nil {
+		return x.Field2
+	}
+	return 0
+}
+
+func (x *GoogleMessage1) GetField3() int32 {
+	if x != nil {
+		return x.Field3
+	}
+	return 0
+}
+
+func (x *GoogleMessage1) GetField280() int32 {
+	if x != nil {
+		return x.Field280
+	}
+	return 0
+}
+
+func (x *GoogleMessage1) GetField6() int32 {
+	if x != nil {
+		return x.Field6
+	}
+	return 0
+}
+
+func (x *GoogleMessage1) GetField22() int64 {
+	if x != nil {
+		return x.Field22
+	}
+	return 0
+}
+
+func (x *GoogleMessage1) GetField4() string {
+	if x != nil {
+		return x.Field4
+	}
+	return ""
+}
+
+func (x *GoogleMessage1) GetField5() []uint64 {
+	if x != nil {
+		return x.Field5
+	}
+	return nil
+}
+
+func (x *GoogleMessage1) GetField59() bool {
+	if x != nil {
+		return x.Field59
+	}
+	return false
+}
+
+func (x *GoogleMessage1) GetField7() string {
+	if x != nil {
+		return x.Field7
+	}
+	return ""
+}
+
+func (x *GoogleMessage1) GetField16() int32 {
+	if x != nil {
+		return x.Field16
+	}
+	return 0
+}
+
+func (x *GoogleMessage1) GetField130() int32 {
+	if x != nil {
+		return x.Field130
+	}
+	return 0
+}
+
+func (x *GoogleMessage1) GetField12() bool {
+	if x != nil {
+		return x.Field12
+	}
+	return false
+}
+
+func (x *GoogleMessage1) GetField17() bool {
+	if x != nil {
+		return x.Field17
+	}
+	return false
+}
+
+func (x *GoogleMessage1) GetField13() bool {
+	if x != nil {
+		return x.Field13
+	}
+	return false
+}
+
+func (x *GoogleMessage1) GetField14() bool {
+	if x != nil {
+		return x.Field14
+	}
+	return false
+}
+
+func (x *GoogleMessage1) GetField104() int32 {
+	if x != nil {
+		return x.Field104
+	}
+	return 0
+}
+
+func (x *GoogleMessage1) GetField100() int32 {
+	if x != nil {
+		return x.Field100
+	}
+	return 0
+}
+
+func (x *GoogleMessage1) GetField101() int32 {
+	if x != nil {
+		return x.Field101
+	}
+	return 0
+}
+
+func (x *GoogleMessage1) GetField102() string {
+	if x != nil {
+		return x.Field102
+	}
+	return ""
+}
+
+func (x *GoogleMessage1) GetField103() string {
+	if x != nil {
+		return x.Field103
+	}
+	return ""
+}
+
+func (x *GoogleMessage1) GetField29() int32 {
+	if x != nil {
+		return x.Field29
+	}
+	return 0
+}
+
+func (x *GoogleMessage1) GetField30() bool {
+	if x != nil {
+		return x.Field30
+	}
+	return false
+}
+
+func (x *GoogleMessage1) GetField60() int32 {
+	if x != nil {
+		return x.Field60
+	}
+	return 0
+}
+
+func (x *GoogleMessage1) GetField271() int32 {
+	if x != nil {
+		return x.Field271
+	}
+	return 0
+}
+
+func (x *GoogleMessage1) GetField272() int32 {
+	if x != nil {
+		return x.Field272
+	}
+	return 0
+}
+
+func (x *GoogleMessage1) GetField150() int32 {
+	if x != nil {
+		return x.Field150
+	}
+	return 0
+}
+
+func (x *GoogleMessage1) GetField23() int32 {
+	if x != nil {
+		return x.Field23
+	}
+	return 0
+}
+
+func (x *GoogleMessage1) GetField24() bool {
+	if x != nil {
+		return x.Field24
+	}
+	return false
+}
+
+func (x *GoogleMessage1) GetField25() int32 {
+	if x != nil {
+		return x.Field25
+	}
+	return 0
+}
+
+func (x *GoogleMessage1) GetField15() *GoogleMessage1SubMessage {
+	if x != nil {
+		return x.Field15
+	}
+	return nil
+}
+
+func (x *GoogleMessage1) GetField78() bool {
+	if x != nil {
+		return x.Field78
+	}
+	return false
+}
+
+func (x *GoogleMessage1) GetField67() int32 {
+	if x != nil {
+		return x.Field67
+	}
+	return 0
+}
+
+func (x *GoogleMessage1) GetField68() int32 {
+	if x != nil {
+		return x.Field68
+	}
+	return 0
+}
+
+func (x *GoogleMessage1) GetField128() int32 {
+	if x != nil {
+		return x.Field128
+	}
+	return 0
+}
+
+func (x *GoogleMessage1) GetField129() string {
+	if x != nil {
+		return x.Field129
+	}
+	return ""
+}
+
+func (x *GoogleMessage1) GetField131() int32 {
+	if x != nil {
+		return x.Field131
+	}
+	return 0
+}
+
+type GoogleMessage1SubMessage struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field1   int32  `protobuf:"varint,1,opt,name=field1,proto3" json:"field1,omitempty"`
+	Field2   int32  `protobuf:"varint,2,opt,name=field2,proto3" json:"field2,omitempty"`
+	Field3   int32  `protobuf:"varint,3,opt,name=field3,proto3" json:"field3,omitempty"`
+	Field15  string `protobuf:"bytes,15,opt,name=field15,proto3" json:"field15,omitempty"`
+	Field12  bool   `protobuf:"varint,12,opt,name=field12,proto3" json:"field12,omitempty"`
+	Field13  int64  `protobuf:"varint,13,opt,name=field13,proto3" json:"field13,omitempty"`
+	Field14  int64  `protobuf:"varint,14,opt,name=field14,proto3" json:"field14,omitempty"`
+	Field16  int32  `protobuf:"varint,16,opt,name=field16,proto3" json:"field16,omitempty"`
+	Field19  int32  `protobuf:"varint,19,opt,name=field19,proto3" json:"field19,omitempty"`
+	Field20  bool   `protobuf:"varint,20,opt,name=field20,proto3" json:"field20,omitempty"`
+	Field28  bool   `protobuf:"varint,28,opt,name=field28,proto3" json:"field28,omitempty"`
+	Field21  uint64 `protobuf:"fixed64,21,opt,name=field21,proto3" json:"field21,omitempty"`
+	Field22  int32  `protobuf:"varint,22,opt,name=field22,proto3" json:"field22,omitempty"`
+	Field23  bool   `protobuf:"varint,23,opt,name=field23,proto3" json:"field23,omitempty"`
+	Field206 bool   `protobuf:"varint,206,opt,name=field206,proto3" json:"field206,omitempty"`
+	Field203 uint32 `protobuf:"fixed32,203,opt,name=field203,proto3" json:"field203,omitempty"`
+	Field204 int32  `protobuf:"varint,204,opt,name=field204,proto3" json:"field204,omitempty"`
+	Field205 string `protobuf:"bytes,205,opt,name=field205,proto3" json:"field205,omitempty"`
+	Field207 uint64 `protobuf:"varint,207,opt,name=field207,proto3" json:"field207,omitempty"`
+	Field300 uint64 `protobuf:"varint,300,opt,name=field300,proto3" json:"field300,omitempty"`
+}
+
+func (x *GoogleMessage1SubMessage) Reset() {
+	*x = GoogleMessage1SubMessage{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message1_proto3_benchmark_message1_proto3_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *GoogleMessage1SubMessage) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GoogleMessage1SubMessage) ProtoMessage() {}
+
+func (x *GoogleMessage1SubMessage) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message1_proto3_benchmark_message1_proto3_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use GoogleMessage1SubMessage.ProtoReflect.Descriptor instead.
+func (*GoogleMessage1SubMessage) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message1_proto3_benchmark_message1_proto3_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *GoogleMessage1SubMessage) GetField1() int32 {
+	if x != nil {
+		return x.Field1
+	}
+	return 0
+}
+
+func (x *GoogleMessage1SubMessage) GetField2() int32 {
+	if x != nil {
+		return x.Field2
+	}
+	return 0
+}
+
+func (x *GoogleMessage1SubMessage) GetField3() int32 {
+	if x != nil {
+		return x.Field3
+	}
+	return 0
+}
+
+func (x *GoogleMessage1SubMessage) GetField15() string {
+	if x != nil {
+		return x.Field15
+	}
+	return ""
+}
+
+func (x *GoogleMessage1SubMessage) GetField12() bool {
+	if x != nil {
+		return x.Field12
+	}
+	return false
+}
+
+func (x *GoogleMessage1SubMessage) GetField13() int64 {
+	if x != nil {
+		return x.Field13
+	}
+	return 0
+}
+
+func (x *GoogleMessage1SubMessage) GetField14() int64 {
+	if x != nil {
+		return x.Field14
+	}
+	return 0
+}
+
+func (x *GoogleMessage1SubMessage) GetField16() int32 {
+	if x != nil {
+		return x.Field16
+	}
+	return 0
+}
+
+func (x *GoogleMessage1SubMessage) GetField19() int32 {
+	if x != nil {
+		return x.Field19
+	}
+	return 0
+}
+
+func (x *GoogleMessage1SubMessage) GetField20() bool {
+	if x != nil {
+		return x.Field20
+	}
+	return false
+}
+
+func (x *GoogleMessage1SubMessage) GetField28() bool {
+	if x != nil {
+		return x.Field28
+	}
+	return false
+}
+
+func (x *GoogleMessage1SubMessage) GetField21() uint64 {
+	if x != nil {
+		return x.Field21
+	}
+	return 0
+}
+
+func (x *GoogleMessage1SubMessage) GetField22() int32 {
+	if x != nil {
+		return x.Field22
+	}
+	return 0
+}
+
+func (x *GoogleMessage1SubMessage) GetField23() bool {
+	if x != nil {
+		return x.Field23
+	}
+	return false
+}
+
+func (x *GoogleMessage1SubMessage) GetField206() bool {
+	if x != nil {
+		return x.Field206
+	}
+	return false
+}
+
+func (x *GoogleMessage1SubMessage) GetField203() uint32 {
+	if x != nil {
+		return x.Field203
+	}
+	return 0
+}
+
+func (x *GoogleMessage1SubMessage) GetField204() int32 {
+	if x != nil {
+		return x.Field204
+	}
+	return 0
+}
+
+func (x *GoogleMessage1SubMessage) GetField205() string {
+	if x != nil {
+		return x.Field205
+	}
+	return ""
+}
+
+func (x *GoogleMessage1SubMessage) GetField207() uint64 {
+	if x != nil {
+		return x.Field207
+	}
+	return 0
+}
+
+func (x *GoogleMessage1SubMessage) GetField300() uint64 {
+	if x != nil {
+		return x.Field300
+	}
+	return 0
+}
+
+var File_datasets_google_message1_proto3_benchmark_message1_proto3_proto protoreflect.FileDescriptor
+
+var file_datasets_google_message1_proto3_benchmark_message1_proto3_proto_rawDesc = []byte{
+	0x0a, 0x3f, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x33, 0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x31, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x12, 0x11, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x33, 0x22, 0xf9, 0x08, 0x0a, 0x0e, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x12, 0x16, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x12,
+	0x16, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x38, 0x18, 0x12, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x38, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x30, 0x18, 0x50, 0x20, 0x01,
+	0x28, 0x08, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x30, 0x12, 0x18, 0x0a, 0x07, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x18, 0x51, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x31, 0x12, 0x16, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x12, 0x16, 0x0a,
+	0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x12, 0x1b, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x38,
+	0x30, 0x18, 0x98, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x38, 0x30, 0x12, 0x16, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x18, 0x06, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x32, 0x18, 0x16, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x32, 0x32, 0x12, 0x16, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x18, 0x04,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x12, 0x16, 0x0a, 0x06,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x18, 0x05, 0x20, 0x03, 0x28, 0x06, 0x52, 0x06, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x35, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x18,
+	0x3b, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x12, 0x16,
+	0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x36, 0x18, 0x10, 0x20, 0x01, 0x28, 0x05, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36,
+	0x12, 0x1b, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x30, 0x18, 0x82, 0x01, 0x20,
+	0x01, 0x28, 0x05, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x30, 0x12, 0x18, 0x0a,
+	0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x37, 0x18, 0x11, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x37, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x18, 0x0d, 0x20, 0x01,
+	0x28, 0x08, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x12, 0x18, 0x0a, 0x07, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x34, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x34, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30,
+	0x34, 0x18, 0x68, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30,
+	0x34, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x30, 0x18, 0x64, 0x20,
+	0x01, 0x28, 0x05, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x30, 0x12, 0x1a, 0x0a,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x31, 0x18, 0x65, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x31, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x30, 0x32, 0x18, 0x66, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x30, 0x32, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30,
+	0x33, 0x18, 0x67, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30,
+	0x33, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x39, 0x18, 0x1d, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x39, 0x12, 0x18, 0x0a, 0x07, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x30, 0x18, 0x1e, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x30, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30,
+	0x18, 0x3c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x12,
+	0x1b, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x31, 0x18, 0x8f, 0x02, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x31, 0x12, 0x1b, 0x0a, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x32, 0x18, 0x90, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x32, 0x12, 0x1b, 0x0a, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x35, 0x30, 0x18, 0x96, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x35, 0x30, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x33, 0x18, 0x17, 0x20, 0x01, 0x28, 0x05, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33,
+	0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x18, 0x18, 0x20, 0x01, 0x28,
+	0x08, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x35, 0x18, 0x19, 0x20, 0x01, 0x28, 0x05, 0x52, 0x07, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x32, 0x35, 0x12, 0x45, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x35, 0x18,
+	0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x53, 0x75, 0x62, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x35, 0x12, 0x18, 0x0a, 0x07, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x18, 0x4e, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x38, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37,
+	0x18, 0x43, 0x20, 0x01, 0x28, 0x05, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x12,
+	0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x38, 0x18, 0x44, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x38, 0x12, 0x1b, 0x0a, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x38, 0x18, 0x80, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x12, 0x1b, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x39, 0x18, 0x81, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x39, 0x12, 0x1b, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x31, 0x18,
+	0x83, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x31,
+	0x22, 0xae, 0x04, 0x0a, 0x18, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x31, 0x53, 0x75, 0x62, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x16, 0x0a,
+	0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x12, 0x16, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x12, 0x16, 0x0a,
+	0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x35,
+	0x18, 0x0f, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x35, 0x12,
+	0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x33, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x33, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x34, 0x18, 0x0e,
+	0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x34, 0x12, 0x18, 0x0a,
+	0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x18, 0x10, 0x20, 0x01, 0x28, 0x05, 0x52, 0x07,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x39, 0x18, 0x13, 0x20, 0x01, 0x28, 0x05, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x39, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x30, 0x18, 0x14, 0x20, 0x01,
+	0x28, 0x08, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x30, 0x12, 0x18, 0x0a, 0x07, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x38, 0x18, 0x1c, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x38, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x31,
+	0x18, 0x15, 0x20, 0x01, 0x28, 0x06, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x31, 0x12,
+	0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x32, 0x18, 0x16, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x32, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x32, 0x33, 0x18, 0x17, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x33, 0x12, 0x1b, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x30, 0x36, 0x18,
+	0xce, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x30, 0x36,
+	0x12, 0x1b, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x30, 0x33, 0x18, 0xcb, 0x01, 0x20,
+	0x01, 0x28, 0x07, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x30, 0x33, 0x12, 0x1b, 0x0a,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x30, 0x34, 0x18, 0xcc, 0x01, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x30, 0x34, 0x12, 0x1b, 0x0a, 0x08, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x30, 0x35, 0x18, 0xcd, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x30, 0x35, 0x12, 0x1b, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x30, 0x37, 0x18, 0xcf, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x30, 0x37, 0x12, 0x1b, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x30, 0x30,
+	0x18, 0xac, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x30,
+	0x30, 0x42, 0x25, 0x0a, 0x1e, 0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x48, 0x01, 0xf8, 0x01, 0x01, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_datasets_google_message1_proto3_benchmark_message1_proto3_proto_rawDescOnce sync.Once
+	file_datasets_google_message1_proto3_benchmark_message1_proto3_proto_rawDescData = file_datasets_google_message1_proto3_benchmark_message1_proto3_proto_rawDesc
+)
+
+func file_datasets_google_message1_proto3_benchmark_message1_proto3_proto_rawDescGZIP() []byte {
+	file_datasets_google_message1_proto3_benchmark_message1_proto3_proto_rawDescOnce.Do(func() {
+		file_datasets_google_message1_proto3_benchmark_message1_proto3_proto_rawDescData = protoimpl.X.CompressGZIP(file_datasets_google_message1_proto3_benchmark_message1_proto3_proto_rawDescData)
+	})
+	return file_datasets_google_message1_proto3_benchmark_message1_proto3_proto_rawDescData
+}
+
+var file_datasets_google_message1_proto3_benchmark_message1_proto3_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
+var file_datasets_google_message1_proto3_benchmark_message1_proto3_proto_goTypes = []interface{}{
+	(*GoogleMessage1)(nil),           // 0: benchmarks.proto3.GoogleMessage1
+	(*GoogleMessage1SubMessage)(nil), // 1: benchmarks.proto3.GoogleMessage1SubMessage
+}
+var file_datasets_google_message1_proto3_benchmark_message1_proto3_proto_depIdxs = []int32{
+	1, // 0: benchmarks.proto3.GoogleMessage1.field15:type_name -> benchmarks.proto3.GoogleMessage1SubMessage
+	1, // [1:1] is the sub-list for method output_type
+	1, // [1:1] is the sub-list for method input_type
+	1, // [1:1] is the sub-list for extension type_name
+	1, // [1:1] is the sub-list for extension extendee
+	0, // [0:1] is the sub-list for field type_name
+}
+
+func init() { file_datasets_google_message1_proto3_benchmark_message1_proto3_proto_init() }
+func file_datasets_google_message1_proto3_benchmark_message1_proto3_proto_init() {
+	if File_datasets_google_message1_proto3_benchmark_message1_proto3_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_datasets_google_message1_proto3_benchmark_message1_proto3_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GoogleMessage1); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message1_proto3_benchmark_message1_proto3_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GoogleMessage1SubMessage); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_datasets_google_message1_proto3_benchmark_message1_proto3_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   2,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_datasets_google_message1_proto3_benchmark_message1_proto3_proto_goTypes,
+		DependencyIndexes: file_datasets_google_message1_proto3_benchmark_message1_proto3_proto_depIdxs,
+		MessageInfos:      file_datasets_google_message1_proto3_benchmark_message1_proto3_proto_msgTypes,
+	}.Build()
+	File_datasets_google_message1_proto3_benchmark_message1_proto3_proto = out.File
+	file_datasets_google_message1_proto3_benchmark_message1_proto3_proto_rawDesc = nil
+	file_datasets_google_message1_proto3_benchmark_message1_proto3_proto_goTypes = nil
+	file_datasets_google_message1_proto3_benchmark_message1_proto3_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message2/benchmark_message2.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message2/benchmark_message2.pb.go
new file mode 100644
index 000000000..d9ad8c785
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message2/benchmark_message2.pb.go
@@ -0,0 +1,861 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// LINT: ALLOW_GROUPS
+
+// Benchmark messages for proto2.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: datasets/google_message2/benchmark_message2.proto
+
+package google_message2
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type GoogleMessage2 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field1   *string                  `protobuf:"bytes,1,opt,name=field1" json:"field1,omitempty"`
+	Field3   *int64                   `protobuf:"varint,3,opt,name=field3" json:"field3,omitempty"`
+	Field4   *int64                   `protobuf:"varint,4,opt,name=field4" json:"field4,omitempty"`
+	Field30  *int64                   `protobuf:"varint,30,opt,name=field30" json:"field30,omitempty"`
+	Field75  *bool                    `protobuf:"varint,75,opt,name=field75,def=0" json:"field75,omitempty"`
+	Field6   *string                  `protobuf:"bytes,6,opt,name=field6" json:"field6,omitempty"`
+	Field2   []byte                   `protobuf:"bytes,2,opt,name=field2" json:"field2,omitempty"`
+	Field21  *int32                   `protobuf:"varint,21,opt,name=field21,def=0" json:"field21,omitempty"`
+	Field71  *int32                   `protobuf:"varint,71,opt,name=field71" json:"field71,omitempty"`
+	Field25  *float32                 `protobuf:"fixed32,25,opt,name=field25" json:"field25,omitempty"`
+	Field109 *int32                   `protobuf:"varint,109,opt,name=field109,def=0" json:"field109,omitempty"`
+	Field210 *int32                   `protobuf:"varint,210,opt,name=field210,def=0" json:"field210,omitempty"`
+	Field211 *int32                   `protobuf:"varint,211,opt,name=field211,def=0" json:"field211,omitempty"`
+	Field212 *int32                   `protobuf:"varint,212,opt,name=field212,def=0" json:"field212,omitempty"`
+	Field213 *int32                   `protobuf:"varint,213,opt,name=field213,def=0" json:"field213,omitempty"`
+	Field216 *int32                   `protobuf:"varint,216,opt,name=field216,def=0" json:"field216,omitempty"`
+	Field217 *int32                   `protobuf:"varint,217,opt,name=field217,def=0" json:"field217,omitempty"`
+	Field218 *int32                   `protobuf:"varint,218,opt,name=field218,def=0" json:"field218,omitempty"`
+	Field220 *int32                   `protobuf:"varint,220,opt,name=field220,def=0" json:"field220,omitempty"`
+	Field221 *int32                   `protobuf:"varint,221,opt,name=field221,def=0" json:"field221,omitempty"`
+	Field222 *float32                 `protobuf:"fixed32,222,opt,name=field222,def=0" json:"field222,omitempty"`
+	Field63  *int32                   `protobuf:"varint,63,opt,name=field63" json:"field63,omitempty"`
+	Group1   []*GoogleMessage2_Group1 `protobuf:"group,10,rep,name=Group1,json=group1" json:"group1,omitempty"`
+	Field128 []string                 `protobuf:"bytes,128,rep,name=field128" json:"field128,omitempty"`
+	Field131 *int64                   `protobuf:"varint,131,opt,name=field131" json:"field131,omitempty"`
+	Field127 []string                 `protobuf:"bytes,127,rep,name=field127" json:"field127,omitempty"`
+	Field129 *int32                   `protobuf:"varint,129,opt,name=field129" json:"field129,omitempty"`
+	Field130 []int64                  `protobuf:"varint,130,rep,name=field130" json:"field130,omitempty"`
+	Field205 *bool                    `protobuf:"varint,205,opt,name=field205,def=0" json:"field205,omitempty"`
+	Field206 *bool                    `protobuf:"varint,206,opt,name=field206,def=0" json:"field206,omitempty"`
+}
+
+// Default values for GoogleMessage2 fields.
+const (
+	Default_GoogleMessage2_Field75  = bool(false)
+	Default_GoogleMessage2_Field21  = int32(0)
+	Default_GoogleMessage2_Field109 = int32(0)
+	Default_GoogleMessage2_Field210 = int32(0)
+	Default_GoogleMessage2_Field211 = int32(0)
+	Default_GoogleMessage2_Field212 = int32(0)
+	Default_GoogleMessage2_Field213 = int32(0)
+	Default_GoogleMessage2_Field216 = int32(0)
+	Default_GoogleMessage2_Field217 = int32(0)
+	Default_GoogleMessage2_Field218 = int32(0)
+	Default_GoogleMessage2_Field220 = int32(0)
+	Default_GoogleMessage2_Field221 = int32(0)
+	Default_GoogleMessage2_Field222 = float32(0)
+	Default_GoogleMessage2_Field205 = bool(false)
+	Default_GoogleMessage2_Field206 = bool(false)
+)
+
+func (x *GoogleMessage2) Reset() {
+	*x = GoogleMessage2{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message2_benchmark_message2_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *GoogleMessage2) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GoogleMessage2) ProtoMessage() {}
+
+func (x *GoogleMessage2) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message2_benchmark_message2_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use GoogleMessage2.ProtoReflect.Descriptor instead.
+func (*GoogleMessage2) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message2_benchmark_message2_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *GoogleMessage2) GetField1() string {
+	if x != nil && x.Field1 != nil {
+		return *x.Field1
+	}
+	return ""
+}
+
+func (x *GoogleMessage2) GetField3() int64 {
+	if x != nil && x.Field3 != nil {
+		return *x.Field3
+	}
+	return 0
+}
+
+func (x *GoogleMessage2) GetField4() int64 {
+	if x != nil && x.Field4 != nil {
+		return *x.Field4
+	}
+	return 0
+}
+
+func (x *GoogleMessage2) GetField30() int64 {
+	if x != nil && x.Field30 != nil {
+		return *x.Field30
+	}
+	return 0
+}
+
+func (x *GoogleMessage2) GetField75() bool {
+	if x != nil && x.Field75 != nil {
+		return *x.Field75
+	}
+	return Default_GoogleMessage2_Field75
+}
+
+func (x *GoogleMessage2) GetField6() string {
+	if x != nil && x.Field6 != nil {
+		return *x.Field6
+	}
+	return ""
+}
+
+func (x *GoogleMessage2) GetField2() []byte {
+	if x != nil {
+		return x.Field2
+	}
+	return nil
+}
+
+func (x *GoogleMessage2) GetField21() int32 {
+	if x != nil && x.Field21 != nil {
+		return *x.Field21
+	}
+	return Default_GoogleMessage2_Field21
+}
+
+func (x *GoogleMessage2) GetField71() int32 {
+	if x != nil && x.Field71 != nil {
+		return *x.Field71
+	}
+	return 0
+}
+
+func (x *GoogleMessage2) GetField25() float32 {
+	if x != nil && x.Field25 != nil {
+		return *x.Field25
+	}
+	return 0
+}
+
+func (x *GoogleMessage2) GetField109() int32 {
+	if x != nil && x.Field109 != nil {
+		return *x.Field109
+	}
+	return Default_GoogleMessage2_Field109
+}
+
+func (x *GoogleMessage2) GetField210() int32 {
+	if x != nil && x.Field210 != nil {
+		return *x.Field210
+	}
+	return Default_GoogleMessage2_Field210
+}
+
+func (x *GoogleMessage2) GetField211() int32 {
+	if x != nil && x.Field211 != nil {
+		return *x.Field211
+	}
+	return Default_GoogleMessage2_Field211
+}
+
+func (x *GoogleMessage2) GetField212() int32 {
+	if x != nil && x.Field212 != nil {
+		return *x.Field212
+	}
+	return Default_GoogleMessage2_Field212
+}
+
+func (x *GoogleMessage2) GetField213() int32 {
+	if x != nil && x.Field213 != nil {
+		return *x.Field213
+	}
+	return Default_GoogleMessage2_Field213
+}
+
+func (x *GoogleMessage2) GetField216() int32 {
+	if x != nil && x.Field216 != nil {
+		return *x.Field216
+	}
+	return Default_GoogleMessage2_Field216
+}
+
+func (x *GoogleMessage2) GetField217() int32 {
+	if x != nil && x.Field217 != nil {
+		return *x.Field217
+	}
+	return Default_GoogleMessage2_Field217
+}
+
+func (x *GoogleMessage2) GetField218() int32 {
+	if x != nil && x.Field218 != nil {
+		return *x.Field218
+	}
+	return Default_GoogleMessage2_Field218
+}
+
+func (x *GoogleMessage2) GetField220() int32 {
+	if x != nil && x.Field220 != nil {
+		return *x.Field220
+	}
+	return Default_GoogleMessage2_Field220
+}
+
+func (x *GoogleMessage2) GetField221() int32 {
+	if x != nil && x.Field221 != nil {
+		return *x.Field221
+	}
+	return Default_GoogleMessage2_Field221
+}
+
+func (x *GoogleMessage2) GetField222() float32 {
+	if x != nil && x.Field222 != nil {
+		return *x.Field222
+	}
+	return Default_GoogleMessage2_Field222
+}
+
+func (x *GoogleMessage2) GetField63() int32 {
+	if x != nil && x.Field63 != nil {
+		return *x.Field63
+	}
+	return 0
+}
+
+func (x *GoogleMessage2) GetGroup1() []*GoogleMessage2_Group1 {
+	if x != nil {
+		return x.Group1
+	}
+	return nil
+}
+
+func (x *GoogleMessage2) GetField128() []string {
+	if x != nil {
+		return x.Field128
+	}
+	return nil
+}
+
+func (x *GoogleMessage2) GetField131() int64 {
+	if x != nil && x.Field131 != nil {
+		return *x.Field131
+	}
+	return 0
+}
+
+func (x *GoogleMessage2) GetField127() []string {
+	if x != nil {
+		return x.Field127
+	}
+	return nil
+}
+
+func (x *GoogleMessage2) GetField129() int32 {
+	if x != nil && x.Field129 != nil {
+		return *x.Field129
+	}
+	return 0
+}
+
+func (x *GoogleMessage2) GetField130() []int64 {
+	if x != nil {
+		return x.Field130
+	}
+	return nil
+}
+
+func (x *GoogleMessage2) GetField205() bool {
+	if x != nil && x.Field205 != nil {
+		return *x.Field205
+	}
+	return Default_GoogleMessage2_Field205
+}
+
+func (x *GoogleMessage2) GetField206() bool {
+	if x != nil && x.Field206 != nil {
+		return *x.Field206
+	}
+	return Default_GoogleMessage2_Field206
+}
+
+type GoogleMessage2GroupedMessage struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field1  *float32 `protobuf:"fixed32,1,opt,name=field1" json:"field1,omitempty"`
+	Field2  *float32 `protobuf:"fixed32,2,opt,name=field2" json:"field2,omitempty"`
+	Field3  *float32 `protobuf:"fixed32,3,opt,name=field3,def=0" json:"field3,omitempty"`
+	Field4  *bool    `protobuf:"varint,4,opt,name=field4" json:"field4,omitempty"`
+	Field5  *bool    `protobuf:"varint,5,opt,name=field5" json:"field5,omitempty"`
+	Field6  *bool    `protobuf:"varint,6,opt,name=field6,def=1" json:"field6,omitempty"`
+	Field7  *bool    `protobuf:"varint,7,opt,name=field7,def=0" json:"field7,omitempty"`
+	Field8  *float32 `protobuf:"fixed32,8,opt,name=field8" json:"field8,omitempty"`
+	Field9  *bool    `protobuf:"varint,9,opt,name=field9" json:"field9,omitempty"`
+	Field10 *float32 `protobuf:"fixed32,10,opt,name=field10" json:"field10,omitempty"`
+	Field11 *int64   `protobuf:"varint,11,opt,name=field11" json:"field11,omitempty"`
+}
+
+// Default values for GoogleMessage2GroupedMessage fields.
+const (
+	Default_GoogleMessage2GroupedMessage_Field3 = float32(0)
+	Default_GoogleMessage2GroupedMessage_Field6 = bool(true)
+	Default_GoogleMessage2GroupedMessage_Field7 = bool(false)
+)
+
+func (x *GoogleMessage2GroupedMessage) Reset() {
+	*x = GoogleMessage2GroupedMessage{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message2_benchmark_message2_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *GoogleMessage2GroupedMessage) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GoogleMessage2GroupedMessage) ProtoMessage() {}
+
+func (x *GoogleMessage2GroupedMessage) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message2_benchmark_message2_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use GoogleMessage2GroupedMessage.ProtoReflect.Descriptor instead.
+func (*GoogleMessage2GroupedMessage) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message2_benchmark_message2_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *GoogleMessage2GroupedMessage) GetField1() float32 {
+	if x != nil && x.Field1 != nil {
+		return *x.Field1
+	}
+	return 0
+}
+
+func (x *GoogleMessage2GroupedMessage) GetField2() float32 {
+	if x != nil && x.Field2 != nil {
+		return *x.Field2
+	}
+	return 0
+}
+
+func (x *GoogleMessage2GroupedMessage) GetField3() float32 {
+	if x != nil && x.Field3 != nil {
+		return *x.Field3
+	}
+	return Default_GoogleMessage2GroupedMessage_Field3
+}
+
+func (x *GoogleMessage2GroupedMessage) GetField4() bool {
+	if x != nil && x.Field4 != nil {
+		return *x.Field4
+	}
+	return false
+}
+
+func (x *GoogleMessage2GroupedMessage) GetField5() bool {
+	if x != nil && x.Field5 != nil {
+		return *x.Field5
+	}
+	return false
+}
+
+func (x *GoogleMessage2GroupedMessage) GetField6() bool {
+	if x != nil && x.Field6 != nil {
+		return *x.Field6
+	}
+	return Default_GoogleMessage2GroupedMessage_Field6
+}
+
+func (x *GoogleMessage2GroupedMessage) GetField7() bool {
+	if x != nil && x.Field7 != nil {
+		return *x.Field7
+	}
+	return Default_GoogleMessage2GroupedMessage_Field7
+}
+
+func (x *GoogleMessage2GroupedMessage) GetField8() float32 {
+	if x != nil && x.Field8 != nil {
+		return *x.Field8
+	}
+	return 0
+}
+
+func (x *GoogleMessage2GroupedMessage) GetField9() bool {
+	if x != nil && x.Field9 != nil {
+		return *x.Field9
+	}
+	return false
+}
+
+func (x *GoogleMessage2GroupedMessage) GetField10() float32 {
+	if x != nil && x.Field10 != nil {
+		return *x.Field10
+	}
+	return 0
+}
+
+func (x *GoogleMessage2GroupedMessage) GetField11() int64 {
+	if x != nil && x.Field11 != nil {
+		return *x.Field11
+	}
+	return 0
+}
+
+type GoogleMessage2_Group1 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field11 *float32                      `protobuf:"fixed32,11,req,name=field11" json:"field11,omitempty"`
+	Field26 *float32                      `protobuf:"fixed32,26,opt,name=field26" json:"field26,omitempty"`
+	Field12 *string                       `protobuf:"bytes,12,opt,name=field12" json:"field12,omitempty"`
+	Field13 *string                       `protobuf:"bytes,13,opt,name=field13" json:"field13,omitempty"`
+	Field14 []string                      `protobuf:"bytes,14,rep,name=field14" json:"field14,omitempty"`
+	Field15 *uint64                       `protobuf:"varint,15,req,name=field15" json:"field15,omitempty"`
+	Field5  *int32                        `protobuf:"varint,5,opt,name=field5" json:"field5,omitempty"`
+	Field27 *string                       `protobuf:"bytes,27,opt,name=field27" json:"field27,omitempty"`
+	Field28 *int32                        `protobuf:"varint,28,opt,name=field28" json:"field28,omitempty"`
+	Field29 *string                       `protobuf:"bytes,29,opt,name=field29" json:"field29,omitempty"`
+	Field16 *string                       `protobuf:"bytes,16,opt,name=field16" json:"field16,omitempty"`
+	Field22 []string                      `protobuf:"bytes,22,rep,name=field22" json:"field22,omitempty"`
+	Field73 []int32                       `protobuf:"varint,73,rep,name=field73" json:"field73,omitempty"`
+	Field20 *int32                        `protobuf:"varint,20,opt,name=field20,def=0" json:"field20,omitempty"`
+	Field24 *string                       `protobuf:"bytes,24,opt,name=field24" json:"field24,omitempty"`
+	Field31 *GoogleMessage2GroupedMessage `protobuf:"bytes,31,opt,name=field31" json:"field31,omitempty"`
+}
+
+// Default values for GoogleMessage2_Group1 fields.
+const (
+	Default_GoogleMessage2_Group1_Field20 = int32(0)
+)
+
+func (x *GoogleMessage2_Group1) Reset() {
+	*x = GoogleMessage2_Group1{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message2_benchmark_message2_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *GoogleMessage2_Group1) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GoogleMessage2_Group1) ProtoMessage() {}
+
+func (x *GoogleMessage2_Group1) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message2_benchmark_message2_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use GoogleMessage2_Group1.ProtoReflect.Descriptor instead.
+func (*GoogleMessage2_Group1) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message2_benchmark_message2_proto_rawDescGZIP(), []int{0, 0}
+}
+
+func (x *GoogleMessage2_Group1) GetField11() float32 {
+	if x != nil && x.Field11 != nil {
+		return *x.Field11
+	}
+	return 0
+}
+
+func (x *GoogleMessage2_Group1) GetField26() float32 {
+	if x != nil && x.Field26 != nil {
+		return *x.Field26
+	}
+	return 0
+}
+
+func (x *GoogleMessage2_Group1) GetField12() string {
+	if x != nil && x.Field12 != nil {
+		return *x.Field12
+	}
+	return ""
+}
+
+func (x *GoogleMessage2_Group1) GetField13() string {
+	if x != nil && x.Field13 != nil {
+		return *x.Field13
+	}
+	return ""
+}
+
+func (x *GoogleMessage2_Group1) GetField14() []string {
+	if x != nil {
+		return x.Field14
+	}
+	return nil
+}
+
+func (x *GoogleMessage2_Group1) GetField15() uint64 {
+	if x != nil && x.Field15 != nil {
+		return *x.Field15
+	}
+	return 0
+}
+
+func (x *GoogleMessage2_Group1) GetField5() int32 {
+	if x != nil && x.Field5 != nil {
+		return *x.Field5
+	}
+	return 0
+}
+
+func (x *GoogleMessage2_Group1) GetField27() string {
+	if x != nil && x.Field27 != nil {
+		return *x.Field27
+	}
+	return ""
+}
+
+func (x *GoogleMessage2_Group1) GetField28() int32 {
+	if x != nil && x.Field28 != nil {
+		return *x.Field28
+	}
+	return 0
+}
+
+func (x *GoogleMessage2_Group1) GetField29() string {
+	if x != nil && x.Field29 != nil {
+		return *x.Field29
+	}
+	return ""
+}
+
+func (x *GoogleMessage2_Group1) GetField16() string {
+	if x != nil && x.Field16 != nil {
+		return *x.Field16
+	}
+	return ""
+}
+
+func (x *GoogleMessage2_Group1) GetField22() []string {
+	if x != nil {
+		return x.Field22
+	}
+	return nil
+}
+
+func (x *GoogleMessage2_Group1) GetField73() []int32 {
+	if x != nil {
+		return x.Field73
+	}
+	return nil
+}
+
+func (x *GoogleMessage2_Group1) GetField20() int32 {
+	if x != nil && x.Field20 != nil {
+		return *x.Field20
+	}
+	return Default_GoogleMessage2_Group1_Field20
+}
+
+func (x *GoogleMessage2_Group1) GetField24() string {
+	if x != nil && x.Field24 != nil {
+		return *x.Field24
+	}
+	return ""
+}
+
+func (x *GoogleMessage2_Group1) GetField31() *GoogleMessage2GroupedMessage {
+	if x != nil {
+		return x.Field31
+	}
+	return nil
+}
+
+var File_datasets_google_message2_benchmark_message2_proto protoreflect.FileDescriptor
+
+var file_datasets_google_message2_benchmark_message2_proto_rawDesc = []byte{
+	0x0a, 0x31, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x12, 0x11, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x22, 0x84, 0x0b, 0x0a, 0x0e, 0x47, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x12, 0x16, 0x0a, 0x06, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x12, 0x16, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x18, 0x03, 0x20, 0x01, 0x28,
+	0x03, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x12, 0x16, 0x0a, 0x06, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x34, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x34, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x30, 0x18, 0x1e, 0x20, 0x01,
+	0x28, 0x03, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x30, 0x12, 0x1f, 0x0a, 0x07, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x37, 0x35, 0x18, 0x4b, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61,
+	0x6c, 0x73, 0x65, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x35, 0x12, 0x16, 0x0a, 0x06,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x36, 0x12, 0x16, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x0c, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x12, 0x1b, 0x0a, 0x07,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x31, 0x18, 0x15, 0x20, 0x01, 0x28, 0x05, 0x3a, 0x01, 0x30,
+	0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x31, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x37, 0x31, 0x18, 0x47, 0x20, 0x01, 0x28, 0x05, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x31, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x35, 0x18, 0x19,
+	0x20, 0x01, 0x28, 0x02, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x35, 0x12, 0x1d, 0x0a,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x39, 0x18, 0x6d, 0x20, 0x01, 0x28, 0x05, 0x3a,
+	0x01, 0x30, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x39, 0x12, 0x1e, 0x0a, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x31, 0x30, 0x18, 0xd2, 0x01, 0x20, 0x01, 0x28, 0x05, 0x3a,
+	0x01, 0x30, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x31, 0x30, 0x12, 0x1e, 0x0a, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x31, 0x31, 0x18, 0xd3, 0x01, 0x20, 0x01, 0x28, 0x05, 0x3a,
+	0x01, 0x30, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x31, 0x31, 0x12, 0x1e, 0x0a, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x31, 0x32, 0x18, 0xd4, 0x01, 0x20, 0x01, 0x28, 0x05, 0x3a,
+	0x01, 0x30, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x31, 0x32, 0x12, 0x1e, 0x0a, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x31, 0x33, 0x18, 0xd5, 0x01, 0x20, 0x01, 0x28, 0x05, 0x3a,
+	0x01, 0x30, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x31, 0x33, 0x12, 0x1e, 0x0a, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x31, 0x36, 0x18, 0xd8, 0x01, 0x20, 0x01, 0x28, 0x05, 0x3a,
+	0x01, 0x30, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x31, 0x36, 0x12, 0x1e, 0x0a, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x31, 0x37, 0x18, 0xd9, 0x01, 0x20, 0x01, 0x28, 0x05, 0x3a,
+	0x01, 0x30, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x31, 0x37, 0x12, 0x1e, 0x0a, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x31, 0x38, 0x18, 0xda, 0x01, 0x20, 0x01, 0x28, 0x05, 0x3a,
+	0x01, 0x30, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x31, 0x38, 0x12, 0x1e, 0x0a, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x32, 0x30, 0x18, 0xdc, 0x01, 0x20, 0x01, 0x28, 0x05, 0x3a,
+	0x01, 0x30, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x32, 0x30, 0x12, 0x1e, 0x0a, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x32, 0x31, 0x18, 0xdd, 0x01, 0x20, 0x01, 0x28, 0x05, 0x3a,
+	0x01, 0x30, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x32, 0x31, 0x12, 0x1e, 0x0a, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x32, 0x32, 0x18, 0xde, 0x01, 0x20, 0x01, 0x28, 0x02, 0x3a,
+	0x01, 0x30, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x32, 0x32, 0x12, 0x18, 0x0a, 0x07,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x33, 0x18, 0x3f, 0x20, 0x01, 0x28, 0x05, 0x52, 0x07, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x36, 0x33, 0x12, 0x40, 0x0a, 0x06, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x31,
+	0x18, 0x0a, 0x20, 0x03, 0x28, 0x0a, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x47, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x31,
+	0x52, 0x06, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x31, 0x12, 0x1b, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x32, 0x38, 0x18, 0x80, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x38, 0x12, 0x1b, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33,
+	0x31, 0x18, 0x83, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x33, 0x31, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x18, 0x7f,
+	0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x12, 0x1b,
+	0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x18, 0x81, 0x01, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x12, 0x1b, 0x0a, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x30, 0x18, 0x82, 0x01, 0x20, 0x03, 0x28, 0x03, 0x52, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x30, 0x12, 0x22, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x30, 0x35, 0x18, 0xcd, 0x01, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c,
+	0x73, 0x65, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x30, 0x35, 0x12, 0x22, 0x0a, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x30, 0x36, 0x18, 0xce, 0x01, 0x20, 0x01, 0x28, 0x08, 0x3a,
+	0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x30, 0x36,
+	0x1a, 0xda, 0x03, 0x0a, 0x06, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x31, 0x12, 0x18, 0x0a, 0x07, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x18, 0x0b, 0x20, 0x02, 0x28, 0x02, 0x52, 0x07, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x31, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x36,
+	0x18, 0x1a, 0x20, 0x01, 0x28, 0x02, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x36, 0x12,
+	0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x33, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x33, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x34, 0x18, 0x0e,
+	0x20, 0x03, 0x28, 0x09, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x34, 0x12, 0x18, 0x0a,
+	0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x35, 0x18, 0x0f, 0x20, 0x02, 0x28, 0x04, 0x52, 0x07,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x35, 0x12, 0x16, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x35, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x12,
+	0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x18, 0x1b, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x32, 0x38, 0x18, 0x1c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x38, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x39, 0x18, 0x1d,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x39, 0x12, 0x18, 0x0a,
+	0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x18, 0x10, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x32, 0x18, 0x16, 0x20, 0x03, 0x28, 0x09, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x32, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x33, 0x18, 0x49, 0x20, 0x03,
+	0x28, 0x05, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x33, 0x12, 0x1b, 0x0a, 0x07, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x30, 0x18, 0x14, 0x20, 0x01, 0x28, 0x05, 0x3a, 0x01, 0x30, 0x52,
+	0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x30, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x34, 0x18, 0x18, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x34, 0x12, 0x49, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x31, 0x18, 0x1f, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x65, 0x64, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x31, 0x22, 0xba, 0x02,
+	0x0a, 0x1c, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32,
+	0x47, 0x72, 0x6f, 0x75, 0x70, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x16,
+	0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x18, 0x01, 0x20, 0x01, 0x28, 0x02, 0x52, 0x06,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x12, 0x16, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x02, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x12, 0x19,
+	0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x18, 0x03, 0x20, 0x01, 0x28, 0x02, 0x3a, 0x01,
+	0x30, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x12, 0x16, 0x0a, 0x06, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x34, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x34, 0x12, 0x16, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x18, 0x05, 0x20, 0x01, 0x28,
+	0x08, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x12, 0x1c, 0x0a, 0x06, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x36, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x04, 0x74, 0x72, 0x75, 0x65, 0x52,
+	0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x12, 0x1d, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x37, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x06,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x12, 0x16, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x18, 0x08, 0x20, 0x01, 0x28, 0x02, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x12, 0x16,
+	0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x18, 0x09, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x30, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x02, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30,
+	0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x18, 0x0b, 0x20, 0x01, 0x28,
+	0x03, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x42, 0x25, 0x0a, 0x1e, 0x63, 0x6f,
+	0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x48, 0x01, 0xf8, 0x01,
+	0x01,
+}
+
+var (
+	file_datasets_google_message2_benchmark_message2_proto_rawDescOnce sync.Once
+	file_datasets_google_message2_benchmark_message2_proto_rawDescData = file_datasets_google_message2_benchmark_message2_proto_rawDesc
+)
+
+func file_datasets_google_message2_benchmark_message2_proto_rawDescGZIP() []byte {
+	file_datasets_google_message2_benchmark_message2_proto_rawDescOnce.Do(func() {
+		file_datasets_google_message2_benchmark_message2_proto_rawDescData = protoimpl.X.CompressGZIP(file_datasets_google_message2_benchmark_message2_proto_rawDescData)
+	})
+	return file_datasets_google_message2_benchmark_message2_proto_rawDescData
+}
+
+var file_datasets_google_message2_benchmark_message2_proto_msgTypes = make([]protoimpl.MessageInfo, 3)
+var file_datasets_google_message2_benchmark_message2_proto_goTypes = []interface{}{
+	(*GoogleMessage2)(nil),               // 0: benchmarks.proto2.GoogleMessage2
+	(*GoogleMessage2GroupedMessage)(nil), // 1: benchmarks.proto2.GoogleMessage2GroupedMessage
+	(*GoogleMessage2_Group1)(nil),        // 2: benchmarks.proto2.GoogleMessage2.Group1
+}
+var file_datasets_google_message2_benchmark_message2_proto_depIdxs = []int32{
+	2, // 0: benchmarks.proto2.GoogleMessage2.group1:type_name -> benchmarks.proto2.GoogleMessage2.Group1
+	1, // 1: benchmarks.proto2.GoogleMessage2.Group1.field31:type_name -> benchmarks.proto2.GoogleMessage2GroupedMessage
+	2, // [2:2] is the sub-list for method output_type
+	2, // [2:2] is the sub-list for method input_type
+	2, // [2:2] is the sub-list for extension type_name
+	2, // [2:2] is the sub-list for extension extendee
+	0, // [0:2] is the sub-list for field type_name
+}
+
+func init() { file_datasets_google_message2_benchmark_message2_proto_init() }
+func file_datasets_google_message2_benchmark_message2_proto_init() {
+	if File_datasets_google_message2_benchmark_message2_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_datasets_google_message2_benchmark_message2_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GoogleMessage2); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message2_benchmark_message2_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GoogleMessage2GroupedMessage); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message2_benchmark_message2_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GoogleMessage2_Group1); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_datasets_google_message2_benchmark_message2_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   3,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_datasets_google_message2_benchmark_message2_proto_goTypes,
+		DependencyIndexes: file_datasets_google_message2_benchmark_message2_proto_depIdxs,
+		MessageInfos:      file_datasets_google_message2_benchmark_message2_proto_msgTypes,
+	}.Build()
+	File_datasets_google_message2_benchmark_message2_proto = out.File
+	file_datasets_google_message2_benchmark_message2_proto_rawDesc = nil
+	file_datasets_google_message2_benchmark_message2_proto_goTypes = nil
+	file_datasets_google_message2_benchmark_message2_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3/benchmark_message3.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3/benchmark_message3.pb.go
new file mode 100644
index 000000000..977fa61be
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3/benchmark_message3.pb.go
@@ -0,0 +1,6748 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// LINT: ALLOW_GROUPS
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: datasets/google_message3/benchmark_message3.proto
+
+package google_message3
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoiface "google.golang.org/protobuf/runtime/protoiface"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type GoogleMessage3 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field37519 *Message37487       `protobuf:"bytes,2,opt,name=field37519" json:"field37519,omitempty"`
+	Field37520 *Message36876       `protobuf:"bytes,3,opt,name=field37520" json:"field37520,omitempty"`
+	Field37521 *Message13062       `protobuf:"bytes,4,opt,name=field37521" json:"field37521,omitempty"`
+	Field37522 *Message952         `protobuf:"bytes,5,opt,name=field37522" json:"field37522,omitempty"`
+	Field37523 *UnusedEmptyMessage `protobuf:"bytes,6,opt,name=field37523" json:"field37523,omitempty"`
+	Field37524 *UnusedEmptyMessage `protobuf:"bytes,7,opt,name=field37524" json:"field37524,omitempty"`
+	Field37525 *UnusedEmptyMessage `protobuf:"bytes,8,opt,name=field37525" json:"field37525,omitempty"`
+	Field37526 *UnusedEmptyMessage `protobuf:"bytes,9,opt,name=field37526" json:"field37526,omitempty"`
+	Field37527 *UnusedEmptyMessage `protobuf:"bytes,10,opt,name=field37527" json:"field37527,omitempty"`
+	Field37528 *UnusedEmptyMessage `protobuf:"bytes,11,opt,name=field37528" json:"field37528,omitempty"`
+	Field37529 *UnusedEmptyMessage `protobuf:"bytes,12,opt,name=field37529" json:"field37529,omitempty"`
+	Field37530 *UnusedEmptyMessage `protobuf:"bytes,13,opt,name=field37530" json:"field37530,omitempty"`
+	Field37531 *UnusedEmptyMessage `protobuf:"bytes,14,opt,name=field37531" json:"field37531,omitempty"`
+	Field37532 *UnusedEmptyMessage `protobuf:"bytes,15,opt,name=field37532" json:"field37532,omitempty"`
+	Field37533 *UnusedEmptyMessage `protobuf:"bytes,16,opt,name=field37533" json:"field37533,omitempty"`
+}
+
+func (x *GoogleMessage3) Reset() {
+	*x = GoogleMessage3{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *GoogleMessage3) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GoogleMessage3) ProtoMessage() {}
+
+func (x *GoogleMessage3) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use GoogleMessage3.ProtoReflect.Descriptor instead.
+func (*GoogleMessage3) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *GoogleMessage3) GetField37519() *Message37487 {
+	if x != nil {
+		return x.Field37519
+	}
+	return nil
+}
+
+func (x *GoogleMessage3) GetField37520() *Message36876 {
+	if x != nil {
+		return x.Field37520
+	}
+	return nil
+}
+
+func (x *GoogleMessage3) GetField37521() *Message13062 {
+	if x != nil {
+		return x.Field37521
+	}
+	return nil
+}
+
+func (x *GoogleMessage3) GetField37522() *Message952 {
+	if x != nil {
+		return x.Field37522
+	}
+	return nil
+}
+
+func (x *GoogleMessage3) GetField37523() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37523
+	}
+	return nil
+}
+
+func (x *GoogleMessage3) GetField37524() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37524
+	}
+	return nil
+}
+
+func (x *GoogleMessage3) GetField37525() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37525
+	}
+	return nil
+}
+
+func (x *GoogleMessage3) GetField37526() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37526
+	}
+	return nil
+}
+
+func (x *GoogleMessage3) GetField37527() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37527
+	}
+	return nil
+}
+
+func (x *GoogleMessage3) GetField37528() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37528
+	}
+	return nil
+}
+
+func (x *GoogleMessage3) GetField37529() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37529
+	}
+	return nil
+}
+
+func (x *GoogleMessage3) GetField37530() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37530
+	}
+	return nil
+}
+
+func (x *GoogleMessage3) GetField37531() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37531
+	}
+	return nil
+}
+
+func (x *GoogleMessage3) GetField37532() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37532
+	}
+	return nil
+}
+
+func (x *GoogleMessage3) GetField37533() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37533
+	}
+	return nil
+}
+
+type Message1327 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field1369 []*UnusedEmptyMessage `protobuf:"bytes,1,rep,name=field1369" json:"field1369,omitempty"`
+	Field1370 []*Message1328        `protobuf:"bytes,3,rep,name=field1370" json:"field1370,omitempty"`
+	Field1371 []*UnusedEmptyMessage `protobuf:"bytes,5,rep,name=field1371" json:"field1371,omitempty"`
+	Field1372 []*UnusedEmptyMessage `protobuf:"bytes,6,rep,name=field1372" json:"field1372,omitempty"`
+}
+
+func (x *Message1327) Reset() {
+	*x = Message1327{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message1327) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message1327) ProtoMessage() {}
+
+func (x *Message1327) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message1327.ProtoReflect.Descriptor instead.
+func (*Message1327) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *Message1327) GetField1369() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field1369
+	}
+	return nil
+}
+
+func (x *Message1327) GetField1370() []*Message1328 {
+	if x != nil {
+		return x.Field1370
+	}
+	return nil
+}
+
+func (x *Message1327) GetField1371() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field1371
+	}
+	return nil
+}
+
+func (x *Message1327) GetField1372() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field1372
+	}
+	return nil
+}
+
+type Message3672 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field3727   *Enum3476                  `protobuf:"varint,1,opt,name=field3727,enum=benchmarks.google_message3.Enum3476" json:"field3727,omitempty"`
+	Field3728   *int32                     `protobuf:"varint,11,opt,name=field3728" json:"field3728,omitempty"`
+	Field3729   *int32                     `protobuf:"varint,2,opt,name=field3729" json:"field3729,omitempty"`
+	Message3673 []*Message3672_Message3673 `protobuf:"group,3,rep,name=Message3673,json=message3673" json:"message3673,omitempty"`
+	Message3674 []*Message3672_Message3674 `protobuf:"group,6,rep,name=Message3674,json=message3674" json:"message3674,omitempty"`
+	Field3732   *bool                      `protobuf:"varint,9,opt,name=field3732" json:"field3732,omitempty"`
+	Field3733   *int32                     `protobuf:"varint,10,opt,name=field3733" json:"field3733,omitempty"`
+	Field3734   *Enum3476                  `protobuf:"varint,20,opt,name=field3734,enum=benchmarks.google_message3.Enum3476" json:"field3734,omitempty"`
+	Field3735   *int32                     `protobuf:"varint,21,opt,name=field3735" json:"field3735,omitempty"`
+	Field3736   *UnusedEmptyMessage        `protobuf:"bytes,50,opt,name=field3736" json:"field3736,omitempty"`
+}
+
+func (x *Message3672) Reset() {
+	*x = Message3672{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message3672) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message3672) ProtoMessage() {}
+
+func (x *Message3672) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message3672.ProtoReflect.Descriptor instead.
+func (*Message3672) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *Message3672) GetField3727() Enum3476 {
+	if x != nil && x.Field3727 != nil {
+		return *x.Field3727
+	}
+	return Enum3476_ENUM_VALUE3477
+}
+
+func (x *Message3672) GetField3728() int32 {
+	if x != nil && x.Field3728 != nil {
+		return *x.Field3728
+	}
+	return 0
+}
+
+func (x *Message3672) GetField3729() int32 {
+	if x != nil && x.Field3729 != nil {
+		return *x.Field3729
+	}
+	return 0
+}
+
+func (x *Message3672) GetMessage3673() []*Message3672_Message3673 {
+	if x != nil {
+		return x.Message3673
+	}
+	return nil
+}
+
+func (x *Message3672) GetMessage3674() []*Message3672_Message3674 {
+	if x != nil {
+		return x.Message3674
+	}
+	return nil
+}
+
+func (x *Message3672) GetField3732() bool {
+	if x != nil && x.Field3732 != nil {
+		return *x.Field3732
+	}
+	return false
+}
+
+func (x *Message3672) GetField3733() int32 {
+	if x != nil && x.Field3733 != nil {
+		return *x.Field3733
+	}
+	return 0
+}
+
+func (x *Message3672) GetField3734() Enum3476 {
+	if x != nil && x.Field3734 != nil {
+		return *x.Field3734
+	}
+	return Enum3476_ENUM_VALUE3477
+}
+
+func (x *Message3672) GetField3735() int32 {
+	if x != nil && x.Field3735 != nil {
+		return *x.Field3735
+	}
+	return 0
+}
+
+func (x *Message3672) GetField3736() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field3736
+	}
+	return nil
+}
+
+type Message3804 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field3818 *int64     `protobuf:"varint,1,req,name=field3818" json:"field3818,omitempty"`
+	Field3819 *bool      `protobuf:"varint,2,req,name=field3819" json:"field3819,omitempty"`
+	Field3820 []Enum3805 `protobuf:"varint,4,rep,name=field3820,enum=benchmarks.google_message3.Enum3805" json:"field3820,omitempty"`
+	Field3821 *int32     `protobuf:"varint,5,opt,name=field3821" json:"field3821,omitempty"`
+	Field3822 *bool      `protobuf:"varint,6,opt,name=field3822" json:"field3822,omitempty"`
+	Field3823 *int64     `protobuf:"varint,7,opt,name=field3823" json:"field3823,omitempty"`
+	Field3824 *Enum3783  `protobuf:"varint,8,opt,name=field3824,enum=benchmarks.google_message3.Enum3783" json:"field3824,omitempty"`
+}
+
+func (x *Message3804) Reset() {
+	*x = Message3804{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message3804) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message3804) ProtoMessage() {}
+
+func (x *Message3804) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message3804.ProtoReflect.Descriptor instead.
+func (*Message3804) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *Message3804) GetField3818() int64 {
+	if x != nil && x.Field3818 != nil {
+		return *x.Field3818
+	}
+	return 0
+}
+
+func (x *Message3804) GetField3819() bool {
+	if x != nil && x.Field3819 != nil {
+		return *x.Field3819
+	}
+	return false
+}
+
+func (x *Message3804) GetField3820() []Enum3805 {
+	if x != nil {
+		return x.Field3820
+	}
+	return nil
+}
+
+func (x *Message3804) GetField3821() int32 {
+	if x != nil && x.Field3821 != nil {
+		return *x.Field3821
+	}
+	return 0
+}
+
+func (x *Message3804) GetField3822() bool {
+	if x != nil && x.Field3822 != nil {
+		return *x.Field3822
+	}
+	return false
+}
+
+func (x *Message3804) GetField3823() int64 {
+	if x != nil && x.Field3823 != nil {
+		return *x.Field3823
+	}
+	return 0
+}
+
+func (x *Message3804) GetField3824() Enum3783 {
+	if x != nil && x.Field3824 != nil {
+		return *x.Field3824
+	}
+	return Enum3783_ENUM_VALUE3784
+}
+
+type Message6849 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field6910 []*Message6850 `protobuf:"bytes,1,rep,name=field6910" json:"field6910,omitempty"`
+}
+
+func (x *Message6849) Reset() {
+	*x = Message6849{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6849) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6849) ProtoMessage() {}
+
+func (x *Message6849) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6849.ProtoReflect.Descriptor instead.
+func (*Message6849) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *Message6849) GetField6910() []*Message6850 {
+	if x != nil {
+		return x.Field6910
+	}
+	return nil
+}
+
+type Message6866 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field6973 []*Message6863 `protobuf:"bytes,1,rep,name=field6973" json:"field6973,omitempty"`
+}
+
+func (x *Message6866) Reset() {
+	*x = Message6866{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[5]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6866) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6866) ProtoMessage() {}
+
+func (x *Message6866) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[5]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6866.ProtoReflect.Descriptor instead.
+func (*Message6866) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *Message6866) GetField6973() []*Message6863 {
+	if x != nil {
+		return x.Field6973
+	}
+	return nil
+}
+
+type Message6870 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field6991 []*Message6871 `protobuf:"bytes,1,rep,name=field6991" json:"field6991,omitempty"`
+}
+
+func (x *Message6870) Reset() {
+	*x = Message6870{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[6]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6870) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6870) ProtoMessage() {}
+
+func (x *Message6870) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[6]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6870.ProtoReflect.Descriptor instead.
+func (*Message6870) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *Message6870) GetField6991() []*Message6871 {
+	if x != nil {
+		return x.Field6991
+	}
+	return nil
+}
+
+type Message7651 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field7685 *string               `protobuf:"bytes,1,opt,name=field7685" json:"field7685,omitempty"`
+	Field7686 *int64                `protobuf:"varint,2,opt,name=field7686" json:"field7686,omitempty"`
+	Field7687 *int64                `protobuf:"varint,3,opt,name=field7687" json:"field7687,omitempty"`
+	Field7688 *int64                `protobuf:"varint,4,opt,name=field7688" json:"field7688,omitempty"`
+	Field7689 *int32                `protobuf:"varint,5,opt,name=field7689" json:"field7689,omitempty"`
+	Field7690 *int32                `protobuf:"varint,6,opt,name=field7690" json:"field7690,omitempty"`
+	Field7691 *int32                `protobuf:"varint,7,opt,name=field7691" json:"field7691,omitempty"`
+	Field7692 *int32                `protobuf:"varint,8,opt,name=field7692" json:"field7692,omitempty"`
+	Field7693 *int32                `protobuf:"varint,9,opt,name=field7693" json:"field7693,omitempty"`
+	Field7694 *int32                `protobuf:"varint,10,opt,name=field7694" json:"field7694,omitempty"`
+	Field7695 *int32                `protobuf:"varint,11,opt,name=field7695" json:"field7695,omitempty"`
+	Field7696 *int32                `protobuf:"varint,12,opt,name=field7696" json:"field7696,omitempty"`
+	Field7697 *int32                `protobuf:"varint,13,opt,name=field7697" json:"field7697,omitempty"`
+	Field7698 *int32                `protobuf:"varint,14,opt,name=field7698" json:"field7698,omitempty"`
+	Field7699 *int32                `protobuf:"varint,15,opt,name=field7699" json:"field7699,omitempty"`
+	Field7700 *int32                `protobuf:"varint,16,opt,name=field7700" json:"field7700,omitempty"`
+	Field7701 *int32                `protobuf:"varint,17,opt,name=field7701" json:"field7701,omitempty"`
+	Field7702 *int32                `protobuf:"varint,18,opt,name=field7702" json:"field7702,omitempty"`
+	Field7703 *bool                 `protobuf:"varint,19,opt,name=field7703" json:"field7703,omitempty"`
+	Field7704 []int32               `protobuf:"varint,20,rep,name=field7704" json:"field7704,omitempty"`
+	Field7705 []int32               `protobuf:"varint,21,rep,name=field7705" json:"field7705,omitempty"`
+	Field7706 []string              `protobuf:"bytes,22,rep,name=field7706" json:"field7706,omitempty"`
+	Field7707 []string              `protobuf:"bytes,23,rep,name=field7707" json:"field7707,omitempty"`
+	Field7708 *UnusedEmptyMessage   `protobuf:"bytes,24,opt,name=field7708" json:"field7708,omitempty"`
+	Field7709 *int32                `protobuf:"varint,25,opt,name=field7709" json:"field7709,omitempty"`
+	Field7710 *int32                `protobuf:"varint,26,opt,name=field7710" json:"field7710,omitempty"`
+	Field7711 *int32                `protobuf:"varint,27,opt,name=field7711" json:"field7711,omitempty"`
+	Field7712 *int32                `protobuf:"varint,43,opt,name=field7712" json:"field7712,omitempty"`
+	Field7713 *int32                `protobuf:"varint,28,opt,name=field7713" json:"field7713,omitempty"`
+	Field7714 *int32                `protobuf:"varint,29,opt,name=field7714" json:"field7714,omitempty"`
+	Field7715 []*Message7547        `protobuf:"bytes,30,rep,name=field7715" json:"field7715,omitempty"`
+	Field7716 []*Message7547        `protobuf:"bytes,31,rep,name=field7716" json:"field7716,omitempty"`
+	Field7717 []*UnusedEmptyMessage `protobuf:"bytes,32,rep,name=field7717" json:"field7717,omitempty"`
+	Field7718 []string              `protobuf:"bytes,33,rep,name=field7718" json:"field7718,omitempty"`
+	Field7719 []string              `protobuf:"bytes,34,rep,name=field7719" json:"field7719,omitempty"`
+	Field7720 []*Message7648        `protobuf:"bytes,35,rep,name=field7720" json:"field7720,omitempty"`
+	Field7721 *bool                 `protobuf:"varint,36,opt,name=field7721" json:"field7721,omitempty"`
+	Field7722 *bool                 `protobuf:"varint,37,opt,name=field7722" json:"field7722,omitempty"`
+	Field7723 *bool                 `protobuf:"varint,38,opt,name=field7723" json:"field7723,omitempty"`
+	Field7724 *bool                 `protobuf:"varint,39,opt,name=field7724" json:"field7724,omitempty"`
+	Field7725 *UnusedEmptyMessage   `protobuf:"bytes,40,opt,name=field7725" json:"field7725,omitempty"`
+	Field7726 *UnusedEnum           `protobuf:"varint,41,opt,name=field7726,enum=benchmarks.google_message3.UnusedEnum" json:"field7726,omitempty"`
+	Field7727 *Enum7654             `protobuf:"varint,42,opt,name=field7727,enum=benchmarks.google_message3.Enum7654" json:"field7727,omitempty"`
+	Field7728 *string               `protobuf:"bytes,44,opt,name=field7728" json:"field7728,omitempty"`
+	Field7729 *UnusedEmptyMessage   `protobuf:"bytes,45,opt,name=field7729" json:"field7729,omitempty"`
+}
+
+func (x *Message7651) Reset() {
+	*x = Message7651{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[7]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message7651) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message7651) ProtoMessage() {}
+
+func (x *Message7651) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[7]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message7651.ProtoReflect.Descriptor instead.
+func (*Message7651) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *Message7651) GetField7685() string {
+	if x != nil && x.Field7685 != nil {
+		return *x.Field7685
+	}
+	return ""
+}
+
+func (x *Message7651) GetField7686() int64 {
+	if x != nil && x.Field7686 != nil {
+		return *x.Field7686
+	}
+	return 0
+}
+
+func (x *Message7651) GetField7687() int64 {
+	if x != nil && x.Field7687 != nil {
+		return *x.Field7687
+	}
+	return 0
+}
+
+func (x *Message7651) GetField7688() int64 {
+	if x != nil && x.Field7688 != nil {
+		return *x.Field7688
+	}
+	return 0
+}
+
+func (x *Message7651) GetField7689() int32 {
+	if x != nil && x.Field7689 != nil {
+		return *x.Field7689
+	}
+	return 0
+}
+
+func (x *Message7651) GetField7690() int32 {
+	if x != nil && x.Field7690 != nil {
+		return *x.Field7690
+	}
+	return 0
+}
+
+func (x *Message7651) GetField7691() int32 {
+	if x != nil && x.Field7691 != nil {
+		return *x.Field7691
+	}
+	return 0
+}
+
+func (x *Message7651) GetField7692() int32 {
+	if x != nil && x.Field7692 != nil {
+		return *x.Field7692
+	}
+	return 0
+}
+
+func (x *Message7651) GetField7693() int32 {
+	if x != nil && x.Field7693 != nil {
+		return *x.Field7693
+	}
+	return 0
+}
+
+func (x *Message7651) GetField7694() int32 {
+	if x != nil && x.Field7694 != nil {
+		return *x.Field7694
+	}
+	return 0
+}
+
+func (x *Message7651) GetField7695() int32 {
+	if x != nil && x.Field7695 != nil {
+		return *x.Field7695
+	}
+	return 0
+}
+
+func (x *Message7651) GetField7696() int32 {
+	if x != nil && x.Field7696 != nil {
+		return *x.Field7696
+	}
+	return 0
+}
+
+func (x *Message7651) GetField7697() int32 {
+	if x != nil && x.Field7697 != nil {
+		return *x.Field7697
+	}
+	return 0
+}
+
+func (x *Message7651) GetField7698() int32 {
+	if x != nil && x.Field7698 != nil {
+		return *x.Field7698
+	}
+	return 0
+}
+
+func (x *Message7651) GetField7699() int32 {
+	if x != nil && x.Field7699 != nil {
+		return *x.Field7699
+	}
+	return 0
+}
+
+func (x *Message7651) GetField7700() int32 {
+	if x != nil && x.Field7700 != nil {
+		return *x.Field7700
+	}
+	return 0
+}
+
+func (x *Message7651) GetField7701() int32 {
+	if x != nil && x.Field7701 != nil {
+		return *x.Field7701
+	}
+	return 0
+}
+
+func (x *Message7651) GetField7702() int32 {
+	if x != nil && x.Field7702 != nil {
+		return *x.Field7702
+	}
+	return 0
+}
+
+func (x *Message7651) GetField7703() bool {
+	if x != nil && x.Field7703 != nil {
+		return *x.Field7703
+	}
+	return false
+}
+
+func (x *Message7651) GetField7704() []int32 {
+	if x != nil {
+		return x.Field7704
+	}
+	return nil
+}
+
+func (x *Message7651) GetField7705() []int32 {
+	if x != nil {
+		return x.Field7705
+	}
+	return nil
+}
+
+func (x *Message7651) GetField7706() []string {
+	if x != nil {
+		return x.Field7706
+	}
+	return nil
+}
+
+func (x *Message7651) GetField7707() []string {
+	if x != nil {
+		return x.Field7707
+	}
+	return nil
+}
+
+func (x *Message7651) GetField7708() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field7708
+	}
+	return nil
+}
+
+func (x *Message7651) GetField7709() int32 {
+	if x != nil && x.Field7709 != nil {
+		return *x.Field7709
+	}
+	return 0
+}
+
+func (x *Message7651) GetField7710() int32 {
+	if x != nil && x.Field7710 != nil {
+		return *x.Field7710
+	}
+	return 0
+}
+
+func (x *Message7651) GetField7711() int32 {
+	if x != nil && x.Field7711 != nil {
+		return *x.Field7711
+	}
+	return 0
+}
+
+func (x *Message7651) GetField7712() int32 {
+	if x != nil && x.Field7712 != nil {
+		return *x.Field7712
+	}
+	return 0
+}
+
+func (x *Message7651) GetField7713() int32 {
+	if x != nil && x.Field7713 != nil {
+		return *x.Field7713
+	}
+	return 0
+}
+
+func (x *Message7651) GetField7714() int32 {
+	if x != nil && x.Field7714 != nil {
+		return *x.Field7714
+	}
+	return 0
+}
+
+func (x *Message7651) GetField7715() []*Message7547 {
+	if x != nil {
+		return x.Field7715
+	}
+	return nil
+}
+
+func (x *Message7651) GetField7716() []*Message7547 {
+	if x != nil {
+		return x.Field7716
+	}
+	return nil
+}
+
+func (x *Message7651) GetField7717() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field7717
+	}
+	return nil
+}
+
+func (x *Message7651) GetField7718() []string {
+	if x != nil {
+		return x.Field7718
+	}
+	return nil
+}
+
+func (x *Message7651) GetField7719() []string {
+	if x != nil {
+		return x.Field7719
+	}
+	return nil
+}
+
+func (x *Message7651) GetField7720() []*Message7648 {
+	if x != nil {
+		return x.Field7720
+	}
+	return nil
+}
+
+func (x *Message7651) GetField7721() bool {
+	if x != nil && x.Field7721 != nil {
+		return *x.Field7721
+	}
+	return false
+}
+
+func (x *Message7651) GetField7722() bool {
+	if x != nil && x.Field7722 != nil {
+		return *x.Field7722
+	}
+	return false
+}
+
+func (x *Message7651) GetField7723() bool {
+	if x != nil && x.Field7723 != nil {
+		return *x.Field7723
+	}
+	return false
+}
+
+func (x *Message7651) GetField7724() bool {
+	if x != nil && x.Field7724 != nil {
+		return *x.Field7724
+	}
+	return false
+}
+
+func (x *Message7651) GetField7725() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field7725
+	}
+	return nil
+}
+
+func (x *Message7651) GetField7726() UnusedEnum {
+	if x != nil && x.Field7726 != nil {
+		return *x.Field7726
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+func (x *Message7651) GetField7727() Enum7654 {
+	if x != nil && x.Field7727 != nil {
+		return *x.Field7727
+	}
+	return Enum7654_ENUM_VALUE7655
+}
+
+func (x *Message7651) GetField7728() string {
+	if x != nil && x.Field7728 != nil {
+		return *x.Field7728
+	}
+	return ""
+}
+
+func (x *Message7651) GetField7729() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field7729
+	}
+	return nil
+}
+
+type Message7864 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field7866 *string               `protobuf:"bytes,1,opt,name=field7866" json:"field7866,omitempty"`
+	Field7867 *string               `protobuf:"bytes,2,opt,name=field7867" json:"field7867,omitempty"`
+	Field7868 []*Message7865        `protobuf:"bytes,5,rep,name=field7868" json:"field7868,omitempty"`
+	Field7869 []*Message7865        `protobuf:"bytes,6,rep,name=field7869" json:"field7869,omitempty"`
+	Field7870 []*Message7865        `protobuf:"bytes,7,rep,name=field7870" json:"field7870,omitempty"`
+	Field7871 []*UnusedEmptyMessage `protobuf:"bytes,8,rep,name=field7871" json:"field7871,omitempty"`
+}
+
+func (x *Message7864) Reset() {
+	*x = Message7864{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[8]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message7864) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message7864) ProtoMessage() {}
+
+func (x *Message7864) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[8]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message7864.ProtoReflect.Descriptor instead.
+func (*Message7864) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *Message7864) GetField7866() string {
+	if x != nil && x.Field7866 != nil {
+		return *x.Field7866
+	}
+	return ""
+}
+
+func (x *Message7864) GetField7867() string {
+	if x != nil && x.Field7867 != nil {
+		return *x.Field7867
+	}
+	return ""
+}
+
+func (x *Message7864) GetField7868() []*Message7865 {
+	if x != nil {
+		return x.Field7868
+	}
+	return nil
+}
+
+func (x *Message7864) GetField7869() []*Message7865 {
+	if x != nil {
+		return x.Field7869
+	}
+	return nil
+}
+
+func (x *Message7864) GetField7870() []*Message7865 {
+	if x != nil {
+		return x.Field7870
+	}
+	return nil
+}
+
+func (x *Message7864) GetField7871() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field7871
+	}
+	return nil
+}
+
+type Message7929 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field7942 *int64                `protobuf:"varint,1,opt,name=field7942" json:"field7942,omitempty"`
+	Field7943 *int64                `protobuf:"varint,4,opt,name=field7943" json:"field7943,omitempty"`
+	Field7944 *int64                `protobuf:"varint,5,opt,name=field7944" json:"field7944,omitempty"`
+	Field7945 *int64                `protobuf:"varint,12,opt,name=field7945" json:"field7945,omitempty"`
+	Field7946 *int64                `protobuf:"varint,13,opt,name=field7946" json:"field7946,omitempty"`
+	Field7947 *int64                `protobuf:"varint,18,opt,name=field7947" json:"field7947,omitempty"`
+	Field7948 *int64                `protobuf:"varint,6,opt,name=field7948" json:"field7948,omitempty"`
+	Field7949 *int64                `protobuf:"varint,7,opt,name=field7949" json:"field7949,omitempty"`
+	Field7950 []*Message7919        `protobuf:"bytes,8,rep,name=field7950" json:"field7950,omitempty"`
+	Field7951 []*UnusedEmptyMessage `protobuf:"bytes,20,rep,name=field7951" json:"field7951,omitempty"`
+	Field7952 []*Message7920        `protobuf:"bytes,14,rep,name=field7952" json:"field7952,omitempty"`
+	Field7953 []*Message7921        `protobuf:"bytes,15,rep,name=field7953" json:"field7953,omitempty"`
+	Field7954 []*Message7928        `protobuf:"bytes,17,rep,name=field7954" json:"field7954,omitempty"`
+	Field7955 *int64                `protobuf:"varint,19,opt,name=field7955" json:"field7955,omitempty"`
+	Field7956 *bool                 `protobuf:"varint,2,opt,name=field7956" json:"field7956,omitempty"`
+	Field7957 *int64                `protobuf:"varint,3,opt,name=field7957" json:"field7957,omitempty"`
+	Field7958 *int64                `protobuf:"varint,9,opt,name=field7958" json:"field7958,omitempty"`
+	Field7959 []*UnusedEmptyMessage `protobuf:"bytes,10,rep,name=field7959" json:"field7959,omitempty"`
+	Field7960 [][]byte              `protobuf:"bytes,11,rep,name=field7960" json:"field7960,omitempty"`
+	Field7961 *int64                `protobuf:"varint,16,opt,name=field7961" json:"field7961,omitempty"`
+}
+
+func (x *Message7929) Reset() {
+	*x = Message7929{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[9]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message7929) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message7929) ProtoMessage() {}
+
+func (x *Message7929) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[9]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message7929.ProtoReflect.Descriptor instead.
+func (*Message7929) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_proto_rawDescGZIP(), []int{9}
+}
+
+func (x *Message7929) GetField7942() int64 {
+	if x != nil && x.Field7942 != nil {
+		return *x.Field7942
+	}
+	return 0
+}
+
+func (x *Message7929) GetField7943() int64 {
+	if x != nil && x.Field7943 != nil {
+		return *x.Field7943
+	}
+	return 0
+}
+
+func (x *Message7929) GetField7944() int64 {
+	if x != nil && x.Field7944 != nil {
+		return *x.Field7944
+	}
+	return 0
+}
+
+func (x *Message7929) GetField7945() int64 {
+	if x != nil && x.Field7945 != nil {
+		return *x.Field7945
+	}
+	return 0
+}
+
+func (x *Message7929) GetField7946() int64 {
+	if x != nil && x.Field7946 != nil {
+		return *x.Field7946
+	}
+	return 0
+}
+
+func (x *Message7929) GetField7947() int64 {
+	if x != nil && x.Field7947 != nil {
+		return *x.Field7947
+	}
+	return 0
+}
+
+func (x *Message7929) GetField7948() int64 {
+	if x != nil && x.Field7948 != nil {
+		return *x.Field7948
+	}
+	return 0
+}
+
+func (x *Message7929) GetField7949() int64 {
+	if x != nil && x.Field7949 != nil {
+		return *x.Field7949
+	}
+	return 0
+}
+
+func (x *Message7929) GetField7950() []*Message7919 {
+	if x != nil {
+		return x.Field7950
+	}
+	return nil
+}
+
+func (x *Message7929) GetField7951() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field7951
+	}
+	return nil
+}
+
+func (x *Message7929) GetField7952() []*Message7920 {
+	if x != nil {
+		return x.Field7952
+	}
+	return nil
+}
+
+func (x *Message7929) GetField7953() []*Message7921 {
+	if x != nil {
+		return x.Field7953
+	}
+	return nil
+}
+
+func (x *Message7929) GetField7954() []*Message7928 {
+	if x != nil {
+		return x.Field7954
+	}
+	return nil
+}
+
+func (x *Message7929) GetField7955() int64 {
+	if x != nil && x.Field7955 != nil {
+		return *x.Field7955
+	}
+	return 0
+}
+
+func (x *Message7929) GetField7956() bool {
+	if x != nil && x.Field7956 != nil {
+		return *x.Field7956
+	}
+	return false
+}
+
+func (x *Message7929) GetField7957() int64 {
+	if x != nil && x.Field7957 != nil {
+		return *x.Field7957
+	}
+	return 0
+}
+
+func (x *Message7929) GetField7958() int64 {
+	if x != nil && x.Field7958 != nil {
+		return *x.Field7958
+	}
+	return 0
+}
+
+func (x *Message7929) GetField7959() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field7959
+	}
+	return nil
+}
+
+func (x *Message7929) GetField7960() [][]byte {
+	if x != nil {
+		return x.Field7960
+	}
+	return nil
+}
+
+func (x *Message7929) GetField7961() int64 {
+	if x != nil && x.Field7961 != nil {
+		return *x.Field7961
+	}
+	return 0
+}
+
+type Message8508 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field8517 []*Message8511        `protobuf:"bytes,8,rep,name=field8517" json:"field8517,omitempty"`
+	Field8518 []*Message8512        `protobuf:"bytes,9,rep,name=field8518" json:"field8518,omitempty"`
+	Field8519 []*Message8513        `protobuf:"bytes,11,rep,name=field8519" json:"field8519,omitempty"`
+	Field8520 *bool                 `protobuf:"varint,13,opt,name=field8520" json:"field8520,omitempty"`
+	Field8521 *Message8514          `protobuf:"bytes,14,opt,name=field8521" json:"field8521,omitempty"`
+	Field8522 []*UnusedEmptyMessage `protobuf:"bytes,15,rep,name=field8522" json:"field8522,omitempty"`
+	Field8523 []*Message8515        `protobuf:"bytes,16,rep,name=field8523" json:"field8523,omitempty"`
+	Field8524 []*UnusedEmptyMessage `protobuf:"bytes,17,rep,name=field8524" json:"field8524,omitempty"`
+	Field8525 *int64                `protobuf:"varint,1,opt,name=field8525" json:"field8525,omitempty"`
+	Field8526 *float32              `protobuf:"fixed32,2,opt,name=field8526" json:"field8526,omitempty"`
+	Field8527 *int64                `protobuf:"varint,3,opt,name=field8527" json:"field8527,omitempty"`
+	Field8528 *int64                `protobuf:"varint,4,opt,name=field8528" json:"field8528,omitempty"`
+	Field8529 *int32                `protobuf:"varint,5,opt,name=field8529" json:"field8529,omitempty"`
+	Field8530 []byte                `protobuf:"bytes,6,opt,name=field8530" json:"field8530,omitempty"`
+	Field8531 [][]byte              `protobuf:"bytes,7,rep,name=field8531" json:"field8531,omitempty"`
+	Field8532 *bool                 `protobuf:"varint,10,opt,name=field8532" json:"field8532,omitempty"`
+	Field8533 []byte                `protobuf:"bytes,12,opt,name=field8533" json:"field8533,omitempty"`
+}
+
+func (x *Message8508) Reset() {
+	*x = Message8508{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[10]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8508) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8508) ProtoMessage() {}
+
+func (x *Message8508) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[10]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8508.ProtoReflect.Descriptor instead.
+func (*Message8508) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_proto_rawDescGZIP(), []int{10}
+}
+
+func (x *Message8508) GetField8517() []*Message8511 {
+	if x != nil {
+		return x.Field8517
+	}
+	return nil
+}
+
+func (x *Message8508) GetField8518() []*Message8512 {
+	if x != nil {
+		return x.Field8518
+	}
+	return nil
+}
+
+func (x *Message8508) GetField8519() []*Message8513 {
+	if x != nil {
+		return x.Field8519
+	}
+	return nil
+}
+
+func (x *Message8508) GetField8520() bool {
+	if x != nil && x.Field8520 != nil {
+		return *x.Field8520
+	}
+	return false
+}
+
+func (x *Message8508) GetField8521() *Message8514 {
+	if x != nil {
+		return x.Field8521
+	}
+	return nil
+}
+
+func (x *Message8508) GetField8522() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8522
+	}
+	return nil
+}
+
+func (x *Message8508) GetField8523() []*Message8515 {
+	if x != nil {
+		return x.Field8523
+	}
+	return nil
+}
+
+func (x *Message8508) GetField8524() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8524
+	}
+	return nil
+}
+
+func (x *Message8508) GetField8525() int64 {
+	if x != nil && x.Field8525 != nil {
+		return *x.Field8525
+	}
+	return 0
+}
+
+func (x *Message8508) GetField8526() float32 {
+	if x != nil && x.Field8526 != nil {
+		return *x.Field8526
+	}
+	return 0
+}
+
+func (x *Message8508) GetField8527() int64 {
+	if x != nil && x.Field8527 != nil {
+		return *x.Field8527
+	}
+	return 0
+}
+
+func (x *Message8508) GetField8528() int64 {
+	if x != nil && x.Field8528 != nil {
+		return *x.Field8528
+	}
+	return 0
+}
+
+func (x *Message8508) GetField8529() int32 {
+	if x != nil && x.Field8529 != nil {
+		return *x.Field8529
+	}
+	return 0
+}
+
+func (x *Message8508) GetField8530() []byte {
+	if x != nil {
+		return x.Field8530
+	}
+	return nil
+}
+
+func (x *Message8508) GetField8531() [][]byte {
+	if x != nil {
+		return x.Field8531
+	}
+	return nil
+}
+
+func (x *Message8508) GetField8532() bool {
+	if x != nil && x.Field8532 != nil {
+		return *x.Field8532
+	}
+	return false
+}
+
+func (x *Message8508) GetField8533() []byte {
+	if x != nil {
+		return x.Field8533
+	}
+	return nil
+}
+
+type Message9122 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field9132 *float32 `protobuf:"fixed32,1,opt,name=field9132" json:"field9132,omitempty"`
+	Field9133 *float32 `protobuf:"fixed32,2,opt,name=field9133" json:"field9133,omitempty"`
+}
+
+func (x *Message9122) Reset() {
+	*x = Message9122{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[11]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message9122) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message9122) ProtoMessage() {}
+
+func (x *Message9122) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[11]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message9122.ProtoReflect.Descriptor instead.
+func (*Message9122) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_proto_rawDescGZIP(), []int{11}
+}
+
+func (x *Message9122) GetField9132() float32 {
+	if x != nil && x.Field9132 != nil {
+		return *x.Field9132
+	}
+	return 0
+}
+
+func (x *Message9122) GetField9133() float32 {
+	if x != nil && x.Field9133 != nil {
+		return *x.Field9133
+	}
+	return 0
+}
+
+type Message10177 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field10270 []*Message10155 `protobuf:"bytes,1,rep,name=field10270" json:"field10270,omitempty"`
+}
+
+func (x *Message10177) Reset() {
+	*x = Message10177{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[12]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message10177) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message10177) ProtoMessage() {}
+
+func (x *Message10177) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[12]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message10177.ProtoReflect.Descriptor instead.
+func (*Message10177) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_proto_rawDescGZIP(), []int{12}
+}
+
+func (x *Message10177) GetField10270() []*Message10155 {
+	if x != nil {
+		return x.Field10270
+	}
+	return nil
+}
+
+type Message10278 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field10286 []int32 `protobuf:"varint,1,rep,packed,name=field10286" json:"field10286,omitempty"`
+	Field10287 []int32 `protobuf:"varint,2,rep,packed,name=field10287" json:"field10287,omitempty"`
+	Field10288 *int32  `protobuf:"varint,3,opt,name=field10288" json:"field10288,omitempty"`
+}
+
+func (x *Message10278) Reset() {
+	*x = Message10278{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[13]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message10278) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message10278) ProtoMessage() {}
+
+func (x *Message10278) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[13]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message10278.ProtoReflect.Descriptor instead.
+func (*Message10278) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_proto_rawDescGZIP(), []int{13}
+}
+
+func (x *Message10278) GetField10286() []int32 {
+	if x != nil {
+		return x.Field10286
+	}
+	return nil
+}
+
+func (x *Message10278) GetField10287() []int32 {
+	if x != nil {
+		return x.Field10287
+	}
+	return nil
+}
+
+func (x *Message10278) GetField10288() int32 {
+	if x != nil && x.Field10288 != nil {
+		return *x.Field10288
+	}
+	return 0
+}
+
+type Message10323 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field10360 []*Message10320 `protobuf:"bytes,1,rep,name=field10360" json:"field10360,omitempty"`
+}
+
+func (x *Message10323) Reset() {
+	*x = Message10323{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[14]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message10323) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message10323) ProtoMessage() {}
+
+func (x *Message10323) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[14]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message10323.ProtoReflect.Descriptor instead.
+func (*Message10323) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_proto_rawDescGZIP(), []int{14}
+}
+
+func (x *Message10323) GetField10360() []*Message10320 {
+	if x != nil {
+		return x.Field10360
+	}
+	return nil
+}
+
+type Message10324 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field10362 []*Message10322 `protobuf:"bytes,1,rep,name=field10362" json:"field10362,omitempty"`
+	Field10363 *Message10321   `protobuf:"bytes,2,opt,name=field10363" json:"field10363,omitempty"`
+}
+
+func (x *Message10324) Reset() {
+	*x = Message10324{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[15]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message10324) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message10324) ProtoMessage() {}
+
+func (x *Message10324) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[15]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message10324.ProtoReflect.Descriptor instead.
+func (*Message10324) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_proto_rawDescGZIP(), []int{15}
+}
+
+func (x *Message10324) GetField10362() []*Message10322 {
+	if x != nil {
+		return x.Field10362
+	}
+	return nil
+}
+
+func (x *Message10324) GetField10363() *Message10321 {
+	if x != nil {
+		return x.Field10363
+	}
+	return nil
+}
+
+type Message11990 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12030 []*Message11988 `protobuf:"bytes,1,rep,name=field12030" json:"field12030,omitempty"`
+}
+
+func (x *Message11990) Reset() {
+	*x = Message11990{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[16]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message11990) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message11990) ProtoMessage() {}
+
+func (x *Message11990) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[16]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message11990.ProtoReflect.Descriptor instead.
+func (*Message11990) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_proto_rawDescGZIP(), []int{16}
+}
+
+func (x *Message11990) GetField12030() []*Message11988 {
+	if x != nil {
+		return x.Field12030
+	}
+	return nil
+}
+
+type Message12691 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12713 *string       `protobuf:"bytes,1,opt,name=field12713" json:"field12713,omitempty"`
+	Field12714 *int32        `protobuf:"varint,2,opt,name=field12714" json:"field12714,omitempty"`
+	Field12715 *Message12668 `protobuf:"bytes,3,opt,name=field12715" json:"field12715,omitempty"`
+}
+
+func (x *Message12691) Reset() {
+	*x = Message12691{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[17]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12691) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12691) ProtoMessage() {}
+
+func (x *Message12691) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[17]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12691.ProtoReflect.Descriptor instead.
+func (*Message12691) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_proto_rawDescGZIP(), []int{17}
+}
+
+func (x *Message12691) GetField12713() string {
+	if x != nil && x.Field12713 != nil {
+		return *x.Field12713
+	}
+	return ""
+}
+
+func (x *Message12691) GetField12714() int32 {
+	if x != nil && x.Field12714 != nil {
+		return *x.Field12714
+	}
+	return 0
+}
+
+func (x *Message12691) GetField12715() *Message12668 {
+	if x != nil {
+		return x.Field12715
+	}
+	return nil
+}
+
+type Message12870 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12879 *int32          `protobuf:"varint,1,req,name=field12879" json:"field12879,omitempty"`
+	Field12880 *int32          `protobuf:"varint,7,opt,name=field12880" json:"field12880,omitempty"`
+	Field12881 *int32          `protobuf:"varint,2,req,name=field12881" json:"field12881,omitempty"`
+	Field12882 *uint64         `protobuf:"varint,3,opt,name=field12882" json:"field12882,omitempty"`
+	Field12883 *string         `protobuf:"bytes,2001,opt,name=field12883" json:"field12883,omitempty"`
+	Field12884 *uint64         `protobuf:"fixed64,4,opt,name=field12884" json:"field12884,omitempty"`
+	Field12885 []uint64        `protobuf:"fixed64,14,rep,name=field12885" json:"field12885,omitempty"`
+	Field12886 *int32          `protobuf:"varint,9,opt,name=field12886" json:"field12886,omitempty"`
+	Field12887 *int64          `protobuf:"varint,18,opt,name=field12887" json:"field12887,omitempty"`
+	Field12888 []*Message12870 `protobuf:"bytes,8,rep,name=field12888" json:"field12888,omitempty"`
+	Field12889 *int32          `protobuf:"varint,5,opt,name=field12889" json:"field12889,omitempty"`
+	Field12890 *uint64         `protobuf:"varint,6,opt,name=field12890" json:"field12890,omitempty"`
+	Field12891 *int32          `protobuf:"varint,10,opt,name=field12891" json:"field12891,omitempty"`
+	Field12892 *int32          `protobuf:"varint,11,opt,name=field12892" json:"field12892,omitempty"`
+	Field12893 *float64        `protobuf:"fixed64,12,opt,name=field12893" json:"field12893,omitempty"`
+	Field12894 *Message12825   `protobuf:"bytes,13,opt,name=field12894" json:"field12894,omitempty"`
+	Field12895 *float64        `protobuf:"fixed64,15,opt,name=field12895" json:"field12895,omitempty"`
+	Field12896 *string         `protobuf:"bytes,16,opt,name=field12896" json:"field12896,omitempty"`
+	Field12897 *Enum12871      `protobuf:"varint,17,opt,name=field12897,enum=benchmarks.google_message3.Enum12871" json:"field12897,omitempty"`
+	Field12898 *int32          `protobuf:"varint,19,opt,name=field12898" json:"field12898,omitempty"`
+}
+
+func (x *Message12870) Reset() {
+	*x = Message12870{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[18]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12870) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12870) ProtoMessage() {}
+
+func (x *Message12870) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[18]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12870.ProtoReflect.Descriptor instead.
+func (*Message12870) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_proto_rawDescGZIP(), []int{18}
+}
+
+func (x *Message12870) GetField12879() int32 {
+	if x != nil && x.Field12879 != nil {
+		return *x.Field12879
+	}
+	return 0
+}
+
+func (x *Message12870) GetField12880() int32 {
+	if x != nil && x.Field12880 != nil {
+		return *x.Field12880
+	}
+	return 0
+}
+
+func (x *Message12870) GetField12881() int32 {
+	if x != nil && x.Field12881 != nil {
+		return *x.Field12881
+	}
+	return 0
+}
+
+func (x *Message12870) GetField12882() uint64 {
+	if x != nil && x.Field12882 != nil {
+		return *x.Field12882
+	}
+	return 0
+}
+
+func (x *Message12870) GetField12883() string {
+	if x != nil && x.Field12883 != nil {
+		return *x.Field12883
+	}
+	return ""
+}
+
+func (x *Message12870) GetField12884() uint64 {
+	if x != nil && x.Field12884 != nil {
+		return *x.Field12884
+	}
+	return 0
+}
+
+func (x *Message12870) GetField12885() []uint64 {
+	if x != nil {
+		return x.Field12885
+	}
+	return nil
+}
+
+func (x *Message12870) GetField12886() int32 {
+	if x != nil && x.Field12886 != nil {
+		return *x.Field12886
+	}
+	return 0
+}
+
+func (x *Message12870) GetField12887() int64 {
+	if x != nil && x.Field12887 != nil {
+		return *x.Field12887
+	}
+	return 0
+}
+
+func (x *Message12870) GetField12888() []*Message12870 {
+	if x != nil {
+		return x.Field12888
+	}
+	return nil
+}
+
+func (x *Message12870) GetField12889() int32 {
+	if x != nil && x.Field12889 != nil {
+		return *x.Field12889
+	}
+	return 0
+}
+
+func (x *Message12870) GetField12890() uint64 {
+	if x != nil && x.Field12890 != nil {
+		return *x.Field12890
+	}
+	return 0
+}
+
+func (x *Message12870) GetField12891() int32 {
+	if x != nil && x.Field12891 != nil {
+		return *x.Field12891
+	}
+	return 0
+}
+
+func (x *Message12870) GetField12892() int32 {
+	if x != nil && x.Field12892 != nil {
+		return *x.Field12892
+	}
+	return 0
+}
+
+func (x *Message12870) GetField12893() float64 {
+	if x != nil && x.Field12893 != nil {
+		return *x.Field12893
+	}
+	return 0
+}
+
+func (x *Message12870) GetField12894() *Message12825 {
+	if x != nil {
+		return x.Field12894
+	}
+	return nil
+}
+
+func (x *Message12870) GetField12895() float64 {
+	if x != nil && x.Field12895 != nil {
+		return *x.Field12895
+	}
+	return 0
+}
+
+func (x *Message12870) GetField12896() string {
+	if x != nil && x.Field12896 != nil {
+		return *x.Field12896
+	}
+	return ""
+}
+
+func (x *Message12870) GetField12897() Enum12871 {
+	if x != nil && x.Field12897 != nil {
+		return *x.Field12897
+	}
+	return Enum12871_ENUM_VALUE12872
+}
+
+func (x *Message12870) GetField12898() int32 {
+	if x != nil && x.Field12898 != nil {
+		return *x.Field12898
+	}
+	return 0
+}
+
+type Message13154 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field13164 *float32 `protobuf:"fixed32,1,req,name=field13164" json:"field13164,omitempty"`
+	Field13165 *float32 `protobuf:"fixed32,2,req,name=field13165" json:"field13165,omitempty"`
+}
+
+func (x *Message13154) Reset() {
+	*x = Message13154{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[19]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message13154) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message13154) ProtoMessage() {}
+
+func (x *Message13154) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[19]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message13154.ProtoReflect.Descriptor instead.
+func (*Message13154) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_proto_rawDescGZIP(), []int{19}
+}
+
+func (x *Message13154) GetField13164() float32 {
+	if x != nil && x.Field13164 != nil {
+		return *x.Field13164
+	}
+	return 0
+}
+
+func (x *Message13154) GetField13165() float32 {
+	if x != nil && x.Field13165 != nil {
+		return *x.Field13165
+	}
+	return 0
+}
+
+type Message16507 struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+
+	Field16510 *bool                 `protobuf:"varint,3,opt,name=field16510" json:"field16510,omitempty"`
+	Field16511 *bool                 `protobuf:"varint,4,opt,name=field16511" json:"field16511,omitempty"`
+	Field16512 *bool                 `protobuf:"varint,14,opt,name=field16512" json:"field16512,omitempty"`
+	Field16513 []string              `protobuf:"bytes,5,rep,name=field16513" json:"field16513,omitempty"`
+	Field16514 []string              `protobuf:"bytes,6,rep,name=field16514" json:"field16514,omitempty"`
+	Field16515 *string               `protobuf:"bytes,8,opt,name=field16515" json:"field16515,omitempty"`
+	Field16516 []int32               `protobuf:"varint,9,rep,name=field16516" json:"field16516,omitempty"`
+	Field16517 []int32               `protobuf:"varint,10,rep,name=field16517" json:"field16517,omitempty"`
+	Field16518 *int32                `protobuf:"varint,7,opt,name=field16518" json:"field16518,omitempty"`
+	Field16519 *string               `protobuf:"bytes,15,opt,name=field16519" json:"field16519,omitempty"`
+	Field16520 []string              `protobuf:"bytes,11,rep,name=field16520" json:"field16520,omitempty"`
+	Field16521 []*UnusedEmptyMessage `protobuf:"bytes,27,rep,name=field16521" json:"field16521,omitempty"`
+	Field16522 []*UnusedEmptyMessage `protobuf:"bytes,22,rep,name=field16522" json:"field16522,omitempty"`
+	Field16523 []*UnusedEmptyMessage `protobuf:"bytes,28,rep,name=field16523" json:"field16523,omitempty"`
+	Field16524 *string               `protobuf:"bytes,18,opt,name=field16524" json:"field16524,omitempty"`
+	Field16525 *int32                `protobuf:"varint,19,opt,name=field16525" json:"field16525,omitempty"`
+	Field16526 *int32                `protobuf:"varint,20,opt,name=field16526" json:"field16526,omitempty"`
+	Field16527 *UnusedEmptyMessage   `protobuf:"bytes,23,opt,name=field16527" json:"field16527,omitempty"`
+	Field16528 *bool                 `protobuf:"varint,24,opt,name=field16528" json:"field16528,omitempty"`
+	Field16529 []string              `protobuf:"bytes,25,rep,name=field16529" json:"field16529,omitempty"`
+	Field16530 *float64              `protobuf:"fixed64,26,opt,name=field16530" json:"field16530,omitempty"`
+	Field16531 *Message16478         `protobuf:"bytes,30,opt,name=field16531" json:"field16531,omitempty"`
+	Field16532 *bool                 `protobuf:"varint,31,opt,name=field16532" json:"field16532,omitempty"`
+	Field16533 *string               `protobuf:"bytes,32,opt,name=field16533" json:"field16533,omitempty"`
+	Field16534 *bool                 `protobuf:"varint,33,opt,name=field16534" json:"field16534,omitempty"`
+	Field16535 *bool                 `protobuf:"varint,35,opt,name=field16535" json:"field16535,omitempty"`
+	Field16536 *bool                 `protobuf:"varint,36,opt,name=field16536" json:"field16536,omitempty"`
+	Field16537 *bool                 `protobuf:"varint,37,opt,name=field16537" json:"field16537,omitempty"`
+	Field16538 *bool                 `protobuf:"varint,38,opt,name=field16538" json:"field16538,omitempty"`
+	Field16539 *bool                 `protobuf:"varint,39,opt,name=field16539" json:"field16539,omitempty"`
+	Field16540 *bool                 `protobuf:"varint,40,opt,name=field16540" json:"field16540,omitempty"`
+	Field16541 []string              `protobuf:"bytes,41,rep,name=field16541" json:"field16541,omitempty"`
+}
+
+func (x *Message16507) Reset() {
+	*x = Message16507{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[20]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message16507) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message16507) ProtoMessage() {}
+
+func (x *Message16507) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[20]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message16507.ProtoReflect.Descriptor instead.
+func (*Message16507) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_proto_rawDescGZIP(), []int{20}
+}
+
+var extRange_Message16507 = []protoiface.ExtensionRangeV1{
+	{Start: 21, End: 21},
+}
+
+// Deprecated: Use Message16507.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*Message16507) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_Message16507
+}
+
+func (x *Message16507) GetField16510() bool {
+	if x != nil && x.Field16510 != nil {
+		return *x.Field16510
+	}
+	return false
+}
+
+func (x *Message16507) GetField16511() bool {
+	if x != nil && x.Field16511 != nil {
+		return *x.Field16511
+	}
+	return false
+}
+
+func (x *Message16507) GetField16512() bool {
+	if x != nil && x.Field16512 != nil {
+		return *x.Field16512
+	}
+	return false
+}
+
+func (x *Message16507) GetField16513() []string {
+	if x != nil {
+		return x.Field16513
+	}
+	return nil
+}
+
+func (x *Message16507) GetField16514() []string {
+	if x != nil {
+		return x.Field16514
+	}
+	return nil
+}
+
+func (x *Message16507) GetField16515() string {
+	if x != nil && x.Field16515 != nil {
+		return *x.Field16515
+	}
+	return ""
+}
+
+func (x *Message16507) GetField16516() []int32 {
+	if x != nil {
+		return x.Field16516
+	}
+	return nil
+}
+
+func (x *Message16507) GetField16517() []int32 {
+	if x != nil {
+		return x.Field16517
+	}
+	return nil
+}
+
+func (x *Message16507) GetField16518() int32 {
+	if x != nil && x.Field16518 != nil {
+		return *x.Field16518
+	}
+	return 0
+}
+
+func (x *Message16507) GetField16519() string {
+	if x != nil && x.Field16519 != nil {
+		return *x.Field16519
+	}
+	return ""
+}
+
+func (x *Message16507) GetField16520() []string {
+	if x != nil {
+		return x.Field16520
+	}
+	return nil
+}
+
+func (x *Message16507) GetField16521() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field16521
+	}
+	return nil
+}
+
+func (x *Message16507) GetField16522() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field16522
+	}
+	return nil
+}
+
+func (x *Message16507) GetField16523() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field16523
+	}
+	return nil
+}
+
+func (x *Message16507) GetField16524() string {
+	if x != nil && x.Field16524 != nil {
+		return *x.Field16524
+	}
+	return ""
+}
+
+func (x *Message16507) GetField16525() int32 {
+	if x != nil && x.Field16525 != nil {
+		return *x.Field16525
+	}
+	return 0
+}
+
+func (x *Message16507) GetField16526() int32 {
+	if x != nil && x.Field16526 != nil {
+		return *x.Field16526
+	}
+	return 0
+}
+
+func (x *Message16507) GetField16527() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field16527
+	}
+	return nil
+}
+
+func (x *Message16507) GetField16528() bool {
+	if x != nil && x.Field16528 != nil {
+		return *x.Field16528
+	}
+	return false
+}
+
+func (x *Message16507) GetField16529() []string {
+	if x != nil {
+		return x.Field16529
+	}
+	return nil
+}
+
+func (x *Message16507) GetField16530() float64 {
+	if x != nil && x.Field16530 != nil {
+		return *x.Field16530
+	}
+	return 0
+}
+
+func (x *Message16507) GetField16531() *Message16478 {
+	if x != nil {
+		return x.Field16531
+	}
+	return nil
+}
+
+func (x *Message16507) GetField16532() bool {
+	if x != nil && x.Field16532 != nil {
+		return *x.Field16532
+	}
+	return false
+}
+
+func (x *Message16507) GetField16533() string {
+	if x != nil && x.Field16533 != nil {
+		return *x.Field16533
+	}
+	return ""
+}
+
+func (x *Message16507) GetField16534() bool {
+	if x != nil && x.Field16534 != nil {
+		return *x.Field16534
+	}
+	return false
+}
+
+func (x *Message16507) GetField16535() bool {
+	if x != nil && x.Field16535 != nil {
+		return *x.Field16535
+	}
+	return false
+}
+
+func (x *Message16507) GetField16536() bool {
+	if x != nil && x.Field16536 != nil {
+		return *x.Field16536
+	}
+	return false
+}
+
+func (x *Message16507) GetField16537() bool {
+	if x != nil && x.Field16537 != nil {
+		return *x.Field16537
+	}
+	return false
+}
+
+func (x *Message16507) GetField16538() bool {
+	if x != nil && x.Field16538 != nil {
+		return *x.Field16538
+	}
+	return false
+}
+
+func (x *Message16507) GetField16539() bool {
+	if x != nil && x.Field16539 != nil {
+		return *x.Field16539
+	}
+	return false
+}
+
+func (x *Message16507) GetField16540() bool {
+	if x != nil && x.Field16540 != nil {
+		return *x.Field16540
+	}
+	return false
+}
+
+func (x *Message16507) GetField16541() []string {
+	if x != nil {
+		return x.Field16541
+	}
+	return nil
+}
+
+type Message16564 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field16568 []*Message16552 `protobuf:"bytes,1,rep,name=field16568" json:"field16568,omitempty"`
+}
+
+func (x *Message16564) Reset() {
+	*x = Message16564{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[21]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message16564) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message16564) ProtoMessage() {}
+
+func (x *Message16564) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[21]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message16564.ProtoReflect.Descriptor instead.
+func (*Message16564) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_proto_rawDescGZIP(), []int{21}
+}
+
+func (x *Message16564) GetField16568() []*Message16552 {
+	if x != nil {
+		return x.Field16568
+	}
+	return nil
+}
+
+type Message16661 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field16671 []*Message16660 `protobuf:"bytes,1,rep,name=field16671" json:"field16671,omitempty"`
+	Field16672 []uint64        `protobuf:"varint,2,rep,name=field16672" json:"field16672,omitempty"`
+}
+
+func (x *Message16661) Reset() {
+	*x = Message16661{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[22]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message16661) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message16661) ProtoMessage() {}
+
+func (x *Message16661) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[22]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message16661.ProtoReflect.Descriptor instead.
+func (*Message16661) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_proto_rawDescGZIP(), []int{22}
+}
+
+func (x *Message16661) GetField16671() []*Message16660 {
+	if x != nil {
+		return x.Field16671
+	}
+	return nil
+}
+
+func (x *Message16661) GetField16672() []uint64 {
+	if x != nil {
+		return x.Field16672
+	}
+	return nil
+}
+
+type Message16746 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field16806 []*Message16727 `protobuf:"bytes,1,rep,name=field16806" json:"field16806,omitempty"`
+	Field16807 *bool           `protobuf:"varint,2,opt,name=field16807" json:"field16807,omitempty"`
+	Field16808 *bool           `protobuf:"varint,3,opt,name=field16808" json:"field16808,omitempty"`
+	Field16809 []*Message16725 `protobuf:"bytes,4,rep,name=field16809" json:"field16809,omitempty"`
+}
+
+func (x *Message16746) Reset() {
+	*x = Message16746{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[23]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message16746) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message16746) ProtoMessage() {}
+
+func (x *Message16746) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[23]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message16746.ProtoReflect.Descriptor instead.
+func (*Message16746) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_proto_rawDescGZIP(), []int{23}
+}
+
+func (x *Message16746) GetField16806() []*Message16727 {
+	if x != nil {
+		return x.Field16806
+	}
+	return nil
+}
+
+func (x *Message16746) GetField16807() bool {
+	if x != nil && x.Field16807 != nil {
+		return *x.Field16807
+	}
+	return false
+}
+
+func (x *Message16746) GetField16808() bool {
+	if x != nil && x.Field16808 != nil {
+		return *x.Field16808
+	}
+	return false
+}
+
+func (x *Message16746) GetField16809() []*Message16725 {
+	if x != nil {
+		return x.Field16809
+	}
+	return nil
+}
+
+type Message17786 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Message17787 []*Message17786_Message17787 `protobuf:"group,1,rep,name=Message17787,json=message17787" json:"message17787,omitempty"`
+	Field18175   []*Message17782              `protobuf:"bytes,20,rep,name=field18175" json:"field18175,omitempty"`
+}
+
+func (x *Message17786) Reset() {
+	*x = Message17786{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[24]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message17786) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message17786) ProtoMessage() {}
+
+func (x *Message17786) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[24]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message17786.ProtoReflect.Descriptor instead.
+func (*Message17786) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_proto_rawDescGZIP(), []int{24}
+}
+
+func (x *Message17786) GetMessage17787() []*Message17786_Message17787 {
+	if x != nil {
+		return x.Message17787
+	}
+	return nil
+}
+
+func (x *Message17786) GetField18175() []*Message17782 {
+	if x != nil {
+		return x.Field18175
+	}
+	return nil
+}
+
+type Message22857 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field22874 []*Message22853 `protobuf:"bytes,1,rep,name=field22874" json:"field22874,omitempty"`
+}
+
+func (x *Message22857) Reset() {
+	*x = Message22857{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[25]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message22857) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message22857) ProtoMessage() {}
+
+func (x *Message22857) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[25]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message22857.ProtoReflect.Descriptor instead.
+func (*Message22857) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_proto_rawDescGZIP(), []int{25}
+}
+
+func (x *Message22857) GetField22874() []*Message22853 {
+	if x != nil {
+		return x.Field22874
+	}
+	return nil
+}
+
+type Message24404 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Message24405 []*Message24404_Message24405 `protobuf:"group,1,rep,name=Message24405,json=message24405" json:"message24405,omitempty"`
+	Field24684   *Message24403                `protobuf:"bytes,30,opt,name=field24684" json:"field24684,omitempty"`
+}
+
+func (x *Message24404) Reset() {
+	*x = Message24404{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[26]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message24404) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message24404) ProtoMessage() {}
+
+func (x *Message24404) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[26]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message24404.ProtoReflect.Descriptor instead.
+func (*Message24404) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_proto_rawDescGZIP(), []int{26}
+}
+
+func (x *Message24404) GetMessage24405() []*Message24404_Message24405 {
+	if x != nil {
+		return x.Message24405
+	}
+	return nil
+}
+
+func (x *Message24404) GetField24684() *Message24403 {
+	if x != nil {
+		return x.Field24684
+	}
+	return nil
+}
+
+type Message27300 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field27302 []*UnusedEmptyMessage `protobuf:"bytes,1,rep,name=field27302" json:"field27302,omitempty"`
+	Field27303 *string               `protobuf:"bytes,2,opt,name=field27303" json:"field27303,omitempty"`
+}
+
+func (x *Message27300) Reset() {
+	*x = Message27300{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[27]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message27300) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message27300) ProtoMessage() {}
+
+func (x *Message27300) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[27]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message27300.ProtoReflect.Descriptor instead.
+func (*Message27300) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_proto_rawDescGZIP(), []int{27}
+}
+
+func (x *Message27300) GetField27302() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field27302
+	}
+	return nil
+}
+
+func (x *Message27300) GetField27303() string {
+	if x != nil && x.Field27303 != nil {
+		return *x.Field27303
+	}
+	return ""
+}
+
+type Message27453 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field27459 *string             `protobuf:"bytes,15,opt,name=field27459" json:"field27459,omitempty"`
+	Field27460 []string            `protobuf:"bytes,1,rep,name=field27460" json:"field27460,omitempty"`
+	Field27461 []float32           `protobuf:"fixed32,6,rep,name=field27461" json:"field27461,omitempty"`
+	Field27462 []int32             `protobuf:"varint,27,rep,name=field27462" json:"field27462,omitempty"`
+	Field27463 []int32             `protobuf:"varint,28,rep,name=field27463" json:"field27463,omitempty"`
+	Field27464 []*Message27454     `protobuf:"bytes,24,rep,name=field27464" json:"field27464,omitempty"`
+	Field27465 []string            `protobuf:"bytes,2,rep,name=field27465" json:"field27465,omitempty"`
+	Field27466 []float32           `protobuf:"fixed32,7,rep,name=field27466" json:"field27466,omitempty"`
+	Field27467 []string            `protobuf:"bytes,22,rep,name=field27467" json:"field27467,omitempty"`
+	Field27468 []string            `protobuf:"bytes,23,rep,name=field27468" json:"field27468,omitempty"`
+	Field27469 *string             `protobuf:"bytes,26,opt,name=field27469" json:"field27469,omitempty"`
+	Field27470 []*Message27357     `protobuf:"bytes,8,rep,name=field27470" json:"field27470,omitempty"`
+	Field27471 *Message27360       `protobuf:"bytes,16,opt,name=field27471" json:"field27471,omitempty"`
+	Field27472 *string             `protobuf:"bytes,25,opt,name=field27472" json:"field27472,omitempty"`
+	Field27473 *string             `protobuf:"bytes,11,opt,name=field27473" json:"field27473,omitempty"`
+	Field27474 *bool               `protobuf:"varint,13,opt,name=field27474" json:"field27474,omitempty"`
+	Field27475 *bool               `protobuf:"varint,14,opt,name=field27475" json:"field27475,omitempty"`
+	Field27476 *bool               `protobuf:"varint,17,opt,name=field27476" json:"field27476,omitempty"`
+	Field27477 *UnusedEmptyMessage `protobuf:"bytes,12,opt,name=field27477" json:"field27477,omitempty"`
+	Field27478 *bool               `protobuf:"varint,34268945,opt,name=field27478" json:"field27478,omitempty"`
+	Field27479 *bool               `protobuf:"varint,20,opt,name=field27479" json:"field27479,omitempty"`
+	Field27480 *string             `protobuf:"bytes,21,opt,name=field27480" json:"field27480,omitempty"`
+	Field27481 *UnusedEmptyMessage `protobuf:"bytes,10,opt,name=field27481" json:"field27481,omitempty"`
+}
+
+func (x *Message27453) Reset() {
+	*x = Message27453{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[28]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message27453) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message27453) ProtoMessage() {}
+
+func (x *Message27453) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[28]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message27453.ProtoReflect.Descriptor instead.
+func (*Message27453) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_proto_rawDescGZIP(), []int{28}
+}
+
+func (x *Message27453) GetField27459() string {
+	if x != nil && x.Field27459 != nil {
+		return *x.Field27459
+	}
+	return ""
+}
+
+func (x *Message27453) GetField27460() []string {
+	if x != nil {
+		return x.Field27460
+	}
+	return nil
+}
+
+func (x *Message27453) GetField27461() []float32 {
+	if x != nil {
+		return x.Field27461
+	}
+	return nil
+}
+
+func (x *Message27453) GetField27462() []int32 {
+	if x != nil {
+		return x.Field27462
+	}
+	return nil
+}
+
+func (x *Message27453) GetField27463() []int32 {
+	if x != nil {
+		return x.Field27463
+	}
+	return nil
+}
+
+func (x *Message27453) GetField27464() []*Message27454 {
+	if x != nil {
+		return x.Field27464
+	}
+	return nil
+}
+
+func (x *Message27453) GetField27465() []string {
+	if x != nil {
+		return x.Field27465
+	}
+	return nil
+}
+
+func (x *Message27453) GetField27466() []float32 {
+	if x != nil {
+		return x.Field27466
+	}
+	return nil
+}
+
+func (x *Message27453) GetField27467() []string {
+	if x != nil {
+		return x.Field27467
+	}
+	return nil
+}
+
+func (x *Message27453) GetField27468() []string {
+	if x != nil {
+		return x.Field27468
+	}
+	return nil
+}
+
+func (x *Message27453) GetField27469() string {
+	if x != nil && x.Field27469 != nil {
+		return *x.Field27469
+	}
+	return ""
+}
+
+func (x *Message27453) GetField27470() []*Message27357 {
+	if x != nil {
+		return x.Field27470
+	}
+	return nil
+}
+
+func (x *Message27453) GetField27471() *Message27360 {
+	if x != nil {
+		return x.Field27471
+	}
+	return nil
+}
+
+func (x *Message27453) GetField27472() string {
+	if x != nil && x.Field27472 != nil {
+		return *x.Field27472
+	}
+	return ""
+}
+
+func (x *Message27453) GetField27473() string {
+	if x != nil && x.Field27473 != nil {
+		return *x.Field27473
+	}
+	return ""
+}
+
+func (x *Message27453) GetField27474() bool {
+	if x != nil && x.Field27474 != nil {
+		return *x.Field27474
+	}
+	return false
+}
+
+func (x *Message27453) GetField27475() bool {
+	if x != nil && x.Field27475 != nil {
+		return *x.Field27475
+	}
+	return false
+}
+
+func (x *Message27453) GetField27476() bool {
+	if x != nil && x.Field27476 != nil {
+		return *x.Field27476
+	}
+	return false
+}
+
+func (x *Message27453) GetField27477() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field27477
+	}
+	return nil
+}
+
+func (x *Message27453) GetField27478() bool {
+	if x != nil && x.Field27478 != nil {
+		return *x.Field27478
+	}
+	return false
+}
+
+func (x *Message27453) GetField27479() bool {
+	if x != nil && x.Field27479 != nil {
+		return *x.Field27479
+	}
+	return false
+}
+
+func (x *Message27453) GetField27480() string {
+	if x != nil && x.Field27480 != nil {
+		return *x.Field27480
+	}
+	return ""
+}
+
+func (x *Message27453) GetField27481() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field27481
+	}
+	return nil
+}
+
+type Message3672_Message3673 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field3738 *Enum3476 `protobuf:"varint,4,req,name=field3738,enum=benchmarks.google_message3.Enum3476" json:"field3738,omitempty"`
+	Field3739 *int32    `protobuf:"varint,5,req,name=field3739" json:"field3739,omitempty"`
+}
+
+func (x *Message3672_Message3673) Reset() {
+	*x = Message3672_Message3673{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[29]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message3672_Message3673) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message3672_Message3673) ProtoMessage() {}
+
+func (x *Message3672_Message3673) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[29]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message3672_Message3673.ProtoReflect.Descriptor instead.
+func (*Message3672_Message3673) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_proto_rawDescGZIP(), []int{2, 0}
+}
+
+func (x *Message3672_Message3673) GetField3738() Enum3476 {
+	if x != nil && x.Field3738 != nil {
+		return *x.Field3738
+	}
+	return Enum3476_ENUM_VALUE3477
+}
+
+func (x *Message3672_Message3673) GetField3739() int32 {
+	if x != nil && x.Field3739 != nil {
+		return *x.Field3739
+	}
+	return 0
+}
+
+type Message3672_Message3674 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field3740 *Enum3476 `protobuf:"varint,7,req,name=field3740,enum=benchmarks.google_message3.Enum3476" json:"field3740,omitempty"`
+	Field3741 *int32    `protobuf:"varint,8,req,name=field3741" json:"field3741,omitempty"`
+}
+
+func (x *Message3672_Message3674) Reset() {
+	*x = Message3672_Message3674{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[30]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message3672_Message3674) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message3672_Message3674) ProtoMessage() {}
+
+func (x *Message3672_Message3674) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[30]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message3672_Message3674.ProtoReflect.Descriptor instead.
+func (*Message3672_Message3674) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_proto_rawDescGZIP(), []int{2, 1}
+}
+
+func (x *Message3672_Message3674) GetField3740() Enum3476 {
+	if x != nil && x.Field3740 != nil {
+		return *x.Field3740
+	}
+	return Enum3476_ENUM_VALUE3477
+}
+
+func (x *Message3672_Message3674) GetField3741() int32 {
+	if x != nil && x.Field3741 != nil {
+		return *x.Field3741
+	}
+	return 0
+}
+
+type Message17786_Message17787 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field18177 *int32                `protobuf:"varint,2,req,name=field18177" json:"field18177,omitempty"`
+	Field18178 *int32                `protobuf:"varint,3,req,name=field18178" json:"field18178,omitempty"`
+	Field18179 *Message17783         `protobuf:"bytes,4,opt,name=field18179" json:"field18179,omitempty"`
+	Field18180 *UnusedEmptyMessage   `protobuf:"bytes,5,opt,name=field18180" json:"field18180,omitempty"`
+	Field18181 *UnusedEmptyMessage   `protobuf:"bytes,6,opt,name=field18181" json:"field18181,omitempty"`
+	Field18182 []*UnusedEmptyMessage `protobuf:"bytes,8,rep,name=field18182" json:"field18182,omitempty"`
+	Field18183 *UnusedEmptyMessage   `protobuf:"bytes,9,opt,name=field18183" json:"field18183,omitempty"`
+	Field18184 *Message17726         `protobuf:"bytes,10,opt,name=field18184" json:"field18184,omitempty"`
+	Field18185 *UnusedEmptyMessage   `protobuf:"bytes,11,opt,name=field18185" json:"field18185,omitempty"`
+	Field18186 *Message16945         `protobuf:"bytes,102,opt,name=field18186" json:"field18186,omitempty"`
+	Field18187 *UnusedEmptyMessage   `protobuf:"bytes,12,opt,name=field18187" json:"field18187,omitempty"`
+	Field18188 *UnusedEmptyMessage   `protobuf:"bytes,13,opt,name=field18188" json:"field18188,omitempty"`
+	Field18189 *UnusedEmptyMessage   `protobuf:"bytes,7,opt,name=field18189" json:"field18189,omitempty"`
+	Field18190 *UnusedEmptyMessage   `protobuf:"bytes,100,opt,name=field18190" json:"field18190,omitempty"`
+	Field18191 *UnusedEmptyMessage   `protobuf:"bytes,101,opt,name=field18191" json:"field18191,omitempty"`
+	Field18192 *UnusedEmptyMessage   `protobuf:"bytes,14,opt,name=field18192" json:"field18192,omitempty"`
+	Field18193 *UnusedEmptyMessage   `protobuf:"bytes,19,opt,name=field18193" json:"field18193,omitempty"`
+	Field18194 *UnusedEmptyMessage   `protobuf:"bytes,22,opt,name=field18194" json:"field18194,omitempty"`
+	Field18195 *UnusedEmptyMessage   `protobuf:"bytes,24,opt,name=field18195" json:"field18195,omitempty"`
+	Field18196 *Enum16925            `protobuf:"varint,21,opt,name=field18196,enum=benchmarks.google_message3.Enum16925" json:"field18196,omitempty"`
+	Field18197 *bool                 `protobuf:"varint,18,opt,name=field18197" json:"field18197,omitempty"`
+	Field18198 []UnusedEnum          `protobuf:"varint,23,rep,name=field18198,enum=benchmarks.google_message3.UnusedEnum" json:"field18198,omitempty"`
+	Field18199 *UnusedEmptyMessage   `protobuf:"bytes,15,opt,name=field18199" json:"field18199,omitempty"`
+	Field18200 *string               `protobuf:"bytes,16,opt,name=field18200" json:"field18200,omitempty"`
+	Field18201 *string               `protobuf:"bytes,17,opt,name=field18201" json:"field18201,omitempty"`
+	Field18202 *bool                 `protobuf:"varint,99,opt,name=field18202" json:"field18202,omitempty"`
+}
+
+func (x *Message17786_Message17787) Reset() {
+	*x = Message17786_Message17787{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[31]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message17786_Message17787) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message17786_Message17787) ProtoMessage() {}
+
+func (x *Message17786_Message17787) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[31]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message17786_Message17787.ProtoReflect.Descriptor instead.
+func (*Message17786_Message17787) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_proto_rawDescGZIP(), []int{24, 0}
+}
+
+func (x *Message17786_Message17787) GetField18177() int32 {
+	if x != nil && x.Field18177 != nil {
+		return *x.Field18177
+	}
+	return 0
+}
+
+func (x *Message17786_Message17787) GetField18178() int32 {
+	if x != nil && x.Field18178 != nil {
+		return *x.Field18178
+	}
+	return 0
+}
+
+func (x *Message17786_Message17787) GetField18179() *Message17783 {
+	if x != nil {
+		return x.Field18179
+	}
+	return nil
+}
+
+func (x *Message17786_Message17787) GetField18180() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18180
+	}
+	return nil
+}
+
+func (x *Message17786_Message17787) GetField18181() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18181
+	}
+	return nil
+}
+
+func (x *Message17786_Message17787) GetField18182() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18182
+	}
+	return nil
+}
+
+func (x *Message17786_Message17787) GetField18183() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18183
+	}
+	return nil
+}
+
+func (x *Message17786_Message17787) GetField18184() *Message17726 {
+	if x != nil {
+		return x.Field18184
+	}
+	return nil
+}
+
+func (x *Message17786_Message17787) GetField18185() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18185
+	}
+	return nil
+}
+
+func (x *Message17786_Message17787) GetField18186() *Message16945 {
+	if x != nil {
+		return x.Field18186
+	}
+	return nil
+}
+
+func (x *Message17786_Message17787) GetField18187() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18187
+	}
+	return nil
+}
+
+func (x *Message17786_Message17787) GetField18188() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18188
+	}
+	return nil
+}
+
+func (x *Message17786_Message17787) GetField18189() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18189
+	}
+	return nil
+}
+
+func (x *Message17786_Message17787) GetField18190() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18190
+	}
+	return nil
+}
+
+func (x *Message17786_Message17787) GetField18191() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18191
+	}
+	return nil
+}
+
+func (x *Message17786_Message17787) GetField18192() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18192
+	}
+	return nil
+}
+
+func (x *Message17786_Message17787) GetField18193() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18193
+	}
+	return nil
+}
+
+func (x *Message17786_Message17787) GetField18194() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18194
+	}
+	return nil
+}
+
+func (x *Message17786_Message17787) GetField18195() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18195
+	}
+	return nil
+}
+
+func (x *Message17786_Message17787) GetField18196() Enum16925 {
+	if x != nil && x.Field18196 != nil {
+		return *x.Field18196
+	}
+	return Enum16925_ENUM_VALUE16926
+}
+
+func (x *Message17786_Message17787) GetField18197() bool {
+	if x != nil && x.Field18197 != nil {
+		return *x.Field18197
+	}
+	return false
+}
+
+func (x *Message17786_Message17787) GetField18198() []UnusedEnum {
+	if x != nil {
+		return x.Field18198
+	}
+	return nil
+}
+
+func (x *Message17786_Message17787) GetField18199() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18199
+	}
+	return nil
+}
+
+func (x *Message17786_Message17787) GetField18200() string {
+	if x != nil && x.Field18200 != nil {
+		return *x.Field18200
+	}
+	return ""
+}
+
+func (x *Message17786_Message17787) GetField18201() string {
+	if x != nil && x.Field18201 != nil {
+		return *x.Field18201
+	}
+	return ""
+}
+
+func (x *Message17786_Message17787) GetField18202() bool {
+	if x != nil && x.Field18202 != nil {
+		return *x.Field18202
+	}
+	return false
+}
+
+type Message24404_Message24405 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field24686 *int32              `protobuf:"varint,2,req,name=field24686" json:"field24686,omitempty"`
+	Field24687 *int32              `protobuf:"varint,3,req,name=field24687" json:"field24687,omitempty"`
+	Field24688 *Message24317       `protobuf:"bytes,4,opt,name=field24688" json:"field24688,omitempty"`
+	Field24689 *UnusedEmptyMessage `protobuf:"bytes,5,opt,name=field24689" json:"field24689,omitempty"`
+	Field24690 *Message24376       `protobuf:"bytes,6,opt,name=field24690" json:"field24690,omitempty"`
+	Field24691 *Message24345       `protobuf:"bytes,7,opt,name=field24691" json:"field24691,omitempty"`
+	Field24692 *UnusedEmptyMessage `protobuf:"bytes,8,opt,name=field24692" json:"field24692,omitempty"`
+	Field24693 *Message24379       `protobuf:"bytes,9,opt,name=field24693" json:"field24693,omitempty"`
+	Field24694 *UnusedEmptyMessage `protobuf:"bytes,10,opt,name=field24694" json:"field24694,omitempty"`
+	Field24695 *UnusedEmptyMessage `protobuf:"bytes,11,opt,name=field24695" json:"field24695,omitempty"`
+	Field24696 *Message24391       `protobuf:"bytes,12,opt,name=field24696" json:"field24696,omitempty"`
+	Field24697 *UnusedEmptyMessage `protobuf:"bytes,13,opt,name=field24697" json:"field24697,omitempty"`
+	Field24698 *UnusedEmptyMessage `protobuf:"bytes,14,opt,name=field24698" json:"field24698,omitempty"`
+	Field24699 *UnusedEmptyMessage `protobuf:"bytes,22,opt,name=field24699" json:"field24699,omitempty"`
+	Field24700 *UnusedEmptyMessage `protobuf:"bytes,23,opt,name=field24700" json:"field24700,omitempty"`
+	Field24701 *UnusedEmptyMessage `protobuf:"bytes,25,opt,name=field24701" json:"field24701,omitempty"`
+	Field24702 *Enum16925          `protobuf:"varint,18,opt,name=field24702,enum=benchmarks.google_message3.Enum16925" json:"field24702,omitempty"`
+	Field24703 *float32            `protobuf:"fixed32,20,opt,name=field24703" json:"field24703,omitempty"`
+	Field24704 *bool               `protobuf:"varint,19,opt,name=field24704" json:"field24704,omitempty"`
+	Field24705 []Enum16891         `protobuf:"varint,24,rep,name=field24705,enum=benchmarks.google_message3.Enum16891" json:"field24705,omitempty"`
+	Field24706 *UnusedEmptyMessage `protobuf:"bytes,15,opt,name=field24706" json:"field24706,omitempty"`
+	Field24707 *string             `protobuf:"bytes,16,opt,name=field24707" json:"field24707,omitempty"`
+	Field24708 *string             `protobuf:"bytes,17,opt,name=field24708" json:"field24708,omitempty"`
+	Field24709 *float32            `protobuf:"fixed32,21,opt,name=field24709" json:"field24709,omitempty"`
+	Field24710 *bool               `protobuf:"varint,26,opt,name=field24710" json:"field24710,omitempty"`
+	Field24711 *UnusedEnum         `protobuf:"varint,27,opt,name=field24711,enum=benchmarks.google_message3.UnusedEnum" json:"field24711,omitempty"`
+	Field24712 *bool               `protobuf:"varint,28,opt,name=field24712" json:"field24712,omitempty"`
+	Field24713 *UnusedEnum         `protobuf:"varint,29,opt,name=field24713,enum=benchmarks.google_message3.UnusedEnum" json:"field24713,omitempty"`
+	Field24714 *bool               `protobuf:"varint,31,opt,name=field24714" json:"field24714,omitempty"`
+	Field24715 *bool               `protobuf:"varint,99,opt,name=field24715" json:"field24715,omitempty"`
+	Field24716 *int64              `protobuf:"varint,32,opt,name=field24716" json:"field24716,omitempty"`
+}
+
+func (x *Message24404_Message24405) Reset() {
+	*x = Message24404_Message24405{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[32]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message24404_Message24405) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message24404_Message24405) ProtoMessage() {}
+
+func (x *Message24404_Message24405) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_proto_msgTypes[32]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message24404_Message24405.ProtoReflect.Descriptor instead.
+func (*Message24404_Message24405) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_proto_rawDescGZIP(), []int{26, 0}
+}
+
+func (x *Message24404_Message24405) GetField24686() int32 {
+	if x != nil && x.Field24686 != nil {
+		return *x.Field24686
+	}
+	return 0
+}
+
+func (x *Message24404_Message24405) GetField24687() int32 {
+	if x != nil && x.Field24687 != nil {
+		return *x.Field24687
+	}
+	return 0
+}
+
+func (x *Message24404_Message24405) GetField24688() *Message24317 {
+	if x != nil {
+		return x.Field24688
+	}
+	return nil
+}
+
+func (x *Message24404_Message24405) GetField24689() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field24689
+	}
+	return nil
+}
+
+func (x *Message24404_Message24405) GetField24690() *Message24376 {
+	if x != nil {
+		return x.Field24690
+	}
+	return nil
+}
+
+func (x *Message24404_Message24405) GetField24691() *Message24345 {
+	if x != nil {
+		return x.Field24691
+	}
+	return nil
+}
+
+func (x *Message24404_Message24405) GetField24692() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field24692
+	}
+	return nil
+}
+
+func (x *Message24404_Message24405) GetField24693() *Message24379 {
+	if x != nil {
+		return x.Field24693
+	}
+	return nil
+}
+
+func (x *Message24404_Message24405) GetField24694() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field24694
+	}
+	return nil
+}
+
+func (x *Message24404_Message24405) GetField24695() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field24695
+	}
+	return nil
+}
+
+func (x *Message24404_Message24405) GetField24696() *Message24391 {
+	if x != nil {
+		return x.Field24696
+	}
+	return nil
+}
+
+func (x *Message24404_Message24405) GetField24697() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field24697
+	}
+	return nil
+}
+
+func (x *Message24404_Message24405) GetField24698() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field24698
+	}
+	return nil
+}
+
+func (x *Message24404_Message24405) GetField24699() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field24699
+	}
+	return nil
+}
+
+func (x *Message24404_Message24405) GetField24700() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field24700
+	}
+	return nil
+}
+
+func (x *Message24404_Message24405) GetField24701() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field24701
+	}
+	return nil
+}
+
+func (x *Message24404_Message24405) GetField24702() Enum16925 {
+	if x != nil && x.Field24702 != nil {
+		return *x.Field24702
+	}
+	return Enum16925_ENUM_VALUE16926
+}
+
+func (x *Message24404_Message24405) GetField24703() float32 {
+	if x != nil && x.Field24703 != nil {
+		return *x.Field24703
+	}
+	return 0
+}
+
+func (x *Message24404_Message24405) GetField24704() bool {
+	if x != nil && x.Field24704 != nil {
+		return *x.Field24704
+	}
+	return false
+}
+
+func (x *Message24404_Message24405) GetField24705() []Enum16891 {
+	if x != nil {
+		return x.Field24705
+	}
+	return nil
+}
+
+func (x *Message24404_Message24405) GetField24706() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field24706
+	}
+	return nil
+}
+
+func (x *Message24404_Message24405) GetField24707() string {
+	if x != nil && x.Field24707 != nil {
+		return *x.Field24707
+	}
+	return ""
+}
+
+func (x *Message24404_Message24405) GetField24708() string {
+	if x != nil && x.Field24708 != nil {
+		return *x.Field24708
+	}
+	return ""
+}
+
+func (x *Message24404_Message24405) GetField24709() float32 {
+	if x != nil && x.Field24709 != nil {
+		return *x.Field24709
+	}
+	return 0
+}
+
+func (x *Message24404_Message24405) GetField24710() bool {
+	if x != nil && x.Field24710 != nil {
+		return *x.Field24710
+	}
+	return false
+}
+
+func (x *Message24404_Message24405) GetField24711() UnusedEnum {
+	if x != nil && x.Field24711 != nil {
+		return *x.Field24711
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+func (x *Message24404_Message24405) GetField24712() bool {
+	if x != nil && x.Field24712 != nil {
+		return *x.Field24712
+	}
+	return false
+}
+
+func (x *Message24404_Message24405) GetField24713() UnusedEnum {
+	if x != nil && x.Field24713 != nil {
+		return *x.Field24713
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+func (x *Message24404_Message24405) GetField24714() bool {
+	if x != nil && x.Field24714 != nil {
+		return *x.Field24714
+	}
+	return false
+}
+
+func (x *Message24404_Message24405) GetField24715() bool {
+	if x != nil && x.Field24715 != nil {
+		return *x.Field24715
+	}
+	return false
+}
+
+func (x *Message24404_Message24405) GetField24716() int64 {
+	if x != nil && x.Field24716 != nil {
+		return *x.Field24716
+	}
+	return 0
+}
+
+var file_datasets_google_message3_benchmark_message3_proto_extTypes = []protoimpl.ExtensionInfo{
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: (*string)(nil),
+		Field:         472,
+		Name:          "benchmarks.google_message3.field17026",
+		Tag:           "bytes,472,opt,name=field17026",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]string)(nil),
+		Field:         818,
+		Name:          "benchmarks.google_message3.field17027",
+		Tag:           "bytes,818,rep,name=field17027",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: (*Message0)(nil),
+		Field:         215,
+		Name:          "benchmarks.google_message3.field17031",
+		Tag:           "bytes,215,opt,name=field17031",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]*Message0)(nil),
+		Field:         292,
+		Name:          "benchmarks.google_message3.field17032",
+		Tag:           "bytes,292,rep,name=field17032",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]*Message0)(nil),
+		Field:         234,
+		Name:          "benchmarks.google_message3.field17038",
+		Tag:           "bytes,234,rep,name=field17038",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]*Message0)(nil),
+		Field:         235,
+		Name:          "benchmarks.google_message3.field17039",
+		Tag:           "bytes,235,rep,name=field17039",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: (*Message0)(nil),
+		Field:         246,
+		Name:          "benchmarks.google_message3.field17042",
+		Tag:           "bytes,246,opt,name=field17042",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: (*string)(nil),
+		Field:         224,
+		Name:          "benchmarks.google_message3.field17043",
+		Tag:           "bytes,224,opt,name=field17043",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: (*string)(nil),
+		Field:         225,
+		Name:          "benchmarks.google_message3.field17044",
+		Tag:           "bytes,225,opt,name=field17044",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]string)(nil),
+		Field:         63,
+		Name:          "benchmarks.google_message3.field17048",
+		Tag:           "bytes,63,rep,name=field17048",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]string)(nil),
+		Field:         64,
+		Name:          "benchmarks.google_message3.field17049",
+		Tag:           "bytes,64,rep,name=field17049",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]*Message0)(nil),
+		Field:         233,
+		Name:          "benchmarks.google_message3.field17052",
+		Tag:           "bytes,233,rep,name=field17052",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]*Message0)(nil),
+		Field:         66,
+		Name:          "benchmarks.google_message3.field17053",
+		Tag:           "bytes,66,rep,name=field17053",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]string)(nil),
+		Field:         275,
+		Name:          "benchmarks.google_message3.field17056",
+		Tag:           "bytes,275,rep,name=field17056",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: (*string)(nil),
+		Field:         226,
+		Name:          "benchmarks.google_message3.field17057",
+		Tag:           "bytes,226,opt,name=field17057",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]*Message0)(nil),
+		Field:         27,
+		Name:          "benchmarks.google_message3.field17060",
+		Tag:           "bytes,27,rep,name=field17060",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]string)(nil),
+		Field:         75,
+		Name:          "benchmarks.google_message3.field17073",
+		Tag:           "bytes,75,rep,name=field17073",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]*Message0)(nil),
+		Field:         77,
+		Name:          "benchmarks.google_message3.field17076",
+		Tag:           "bytes,77,rep,name=field17076",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]string)(nil),
+		Field:         296,
+		Name:          "benchmarks.google_message3.field17078",
+		Tag:           "bytes,296,rep,name=field17078",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]*Message0)(nil),
+		Field:         160,
+		Name:          "benchmarks.google_message3.field17082",
+		Tag:           "bytes,160,rep,name=field17082",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]*Message0)(nil),
+		Field:         585,
+		Name:          "benchmarks.google_message3.field17091",
+		Tag:           "bytes,585,rep,name=field17091",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]*Message0)(nil),
+		Field:         987,
+		Name:          "benchmarks.google_message3.field17098",
+		Tag:           "bytes,987,rep,name=field17098",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]*Message0)(nil),
+		Field:         157,
+		Name:          "benchmarks.google_message3.field17101",
+		Tag:           "bytes,157,rep,name=field17101",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]string)(nil),
+		Field:         158,
+		Name:          "benchmarks.google_message3.field17102",
+		Tag:           "bytes,158,rep,name=field17102",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]string)(nil),
+		Field:         166,
+		Name:          "benchmarks.google_message3.field17107",
+		Tag:           "bytes,166,rep,name=field17107",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]string)(nil),
+		Field:         567,
+		Name:          "benchmarks.google_message3.field17133",
+		Tag:           "bytes,567,rep,name=field17133",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]string)(nil),
+		Field:         572,
+		Name:          "benchmarks.google_message3.field17134",
+		Tag:           "bytes,572,rep,name=field17134",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]string)(nil),
+		Field:         49,
+		Name:          "benchmarks.google_message3.field17160",
+		Tag:           "bytes,49,rep,name=field17160",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]string)(nil),
+		Field:         32,
+		Name:          "benchmarks.google_message3.field17168",
+		Tag:           "bytes,32,rep,name=field17168",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]string)(nil),
+		Field:         34,
+		Name:          "benchmarks.google_message3.field17170",
+		Tag:           "bytes,34,rep,name=field17170",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]*Message0)(nil),
+		Field:         509,
+		Name:          "benchmarks.google_message3.field17172",
+		Tag:           "bytes,509,rep,name=field17172",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]string)(nil),
+		Field:         39,
+		Name:          "benchmarks.google_message3.field17174",
+		Tag:           "bytes,39,rep,name=field17174",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]*Message0)(nil),
+		Field:         40,
+		Name:          "benchmarks.google_message3.field17175",
+		Tag:           "bytes,40,rep,name=field17175",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]*Message0)(nil),
+		Field:         511,
+		Name:          "benchmarks.google_message3.field17178",
+		Tag:           "bytes,511,rep,name=field17178",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]*Message0)(nil),
+		Field:         50,
+		Name:          "benchmarks.google_message3.field17185",
+		Tag:           "bytes,50,rep,name=field17185",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]int32)(nil),
+		Field:         1081,
+		Name:          "benchmarks.google_message3.field17207",
+		Tag:           "varint,1081,rep,name=field17207",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]*Message0)(nil),
+		Field:         184,
+		Name:          "benchmarks.google_message3.field17238",
+		Tag:           "bytes,184,rep,name=field17238",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]*Message0)(nil),
+		Field:         177,
+		Name:          "benchmarks.google_message3.field17289",
+		Tag:           "bytes,177,rep,name=field17289",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]*Message0)(nil),
+		Field:         178,
+		Name:          "benchmarks.google_message3.field17290",
+		Tag:           "bytes,178,rep,name=field17290",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]*Message0)(nil),
+		Field:         474,
+		Name:          "benchmarks.google_message3.field17296",
+		Tag:           "bytes,474,rep,name=field17296",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]string)(nil),
+		Field:         44,
+		Name:          "benchmarks.google_message3.field17298",
+		Tag:           "bytes,44,rep,name=field17298",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]*Message0)(nil),
+		Field:         47,
+		Name:          "benchmarks.google_message3.field17301",
+		Tag:           "bytes,47,rep,name=field17301",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: (*Message0)(nil),
+		Field:         21,
+		Name:          "benchmarks.google_message3.field17412",
+		Tag:           "bytes,21,opt,name=field17412",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]*Message0)(nil),
+		Field:         132,
+		Name:          "benchmarks.google_message3.field17438",
+		Tag:           "bytes,132,rep,name=field17438",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]*Message0)(nil),
+		Field:         512,
+		Name:          "benchmarks.google_message3.field17458",
+		Tag:           "bytes,512,rep,name=field17458",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]string)(nil),
+		Field:         560,
+		Name:          "benchmarks.google_message3.field17460",
+		Tag:           "bytes,560,rep,name=field17460",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]string)(nil),
+		Field:         552,
+		Name:          "benchmarks.google_message3.field17466",
+		Tag:           "bytes,552,rep,name=field17466",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]*Message0)(nil),
+		Field:         1080,
+		Name:          "benchmarks.google_message3.field17617",
+		Tag:           "bytes,1080,rep,name=field17617",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message16945)(nil),
+		ExtensionType: ([]int32)(nil),
+		Field:         1084,
+		Name:          "benchmarks.google_message3.field17618",
+		Tag:           "varint,1084,rep,name=field17618",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message0)(nil),
+		ExtensionType: (*Message1327)(nil),
+		Field:         23104162,
+		Name:          "benchmarks.google_message3.Message1327.field1373",
+		Tag:           "bytes,23104162,opt,name=field1373",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message0)(nil),
+		ExtensionType: (*Message3672)(nil),
+		Field:         3144435,
+		Name:          "benchmarks.google_message3.Message3672.field3737",
+		Tag:           "bytes,3144435,opt,name=field3737",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message0)(nil),
+		ExtensionType: (*Message3804)(nil),
+		Field:         59241828,
+		Name:          "benchmarks.google_message3.Message3804.field3825",
+		Tag:           "bytes,59241828,opt,name=field3825",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message0)(nil),
+		ExtensionType: (*Message6849)(nil),
+		Field:         107558455,
+		Name:          "benchmarks.google_message3.Message6849.field6911",
+		Tag:           "bytes,107558455,opt,name=field6911",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message0)(nil),
+		ExtensionType: (*Message6866)(nil),
+		Field:         22259060,
+		Name:          "benchmarks.google_message3.Message6866.field6974",
+		Tag:           "bytes,22259060,opt,name=field6974",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message0)(nil),
+		ExtensionType: (*Message6870)(nil),
+		Field:         90034652,
+		Name:          "benchmarks.google_message3.Message6870.field6992",
+		Tag:           "bytes,90034652,opt,name=field6992",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message0)(nil),
+		ExtensionType: (*Message7651)(nil),
+		Field:         55876009,
+		Name:          "benchmarks.google_message3.Message7651.field7730",
+		Tag:           "bytes,55876009,opt,name=field7730",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message0)(nil),
+		ExtensionType: (*Message7864)(nil),
+		Field:         44542730,
+		Name:          "benchmarks.google_message3.Message7864.field7872",
+		Tag:           "bytes,44542730,opt,name=field7872",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message0)(nil),
+		ExtensionType: (*Message7929)(nil),
+		Field:         53392238,
+		Name:          "benchmarks.google_message3.Message7929.field7962",
+		Tag:           "bytes,53392238,opt,name=field7962",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message0)(nil),
+		ExtensionType: (*Message8508)(nil),
+		Field:         3811804,
+		Name:          "benchmarks.google_message3.Message8508.field8534",
+		Tag:           "bytes,3811804,opt,name=field8534",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message0)(nil),
+		ExtensionType: (*Message9122)(nil),
+		Field:         120398939,
+		Name:          "benchmarks.google_message3.Message9122.field9134",
+		Tag:           "bytes,120398939,opt,name=field9134",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message0)(nil),
+		ExtensionType: (*Message10177)(nil),
+		Field:         26801105,
+		Name:          "benchmarks.google_message3.Message10177.field10271",
+		Tag:           "bytes,26801105,opt,name=field10271",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message10155)(nil),
+		ExtensionType: (*Message10278)(nil),
+		Field:         29374161,
+		Name:          "benchmarks.google_message3.Message10278.field10289",
+		Tag:           "bytes,29374161,opt,name=field10289",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message10155)(nil),
+		ExtensionType: (*Message10323)(nil),
+		Field:         27922524,
+		Name:          "benchmarks.google_message3.Message10323.field10361",
+		Tag:           "bytes,27922524,opt,name=field10361",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message10155)(nil),
+		ExtensionType: (*Message10324)(nil),
+		Field:         27832297,
+		Name:          "benchmarks.google_message3.Message10324.field10364",
+		Tag:           "bytes,27832297,opt,name=field10364",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message0)(nil),
+		ExtensionType: (*Message11990)(nil),
+		Field:         21265426,
+		Name:          "benchmarks.google_message3.Message11990.field12031",
+		Tag:           "bytes,21265426,opt,name=field12031",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message0)(nil),
+		ExtensionType: (*Message12691)(nil),
+		Field:         28426536,
+		Name:          "benchmarks.google_message3.Message12691.field12716",
+		Tag:           "bytes,28426536,opt,name=field12716",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message0)(nil),
+		ExtensionType: (*Message12870)(nil),
+		Field:         5447656,
+		Name:          "benchmarks.google_message3.Message12870.field12899",
+		Tag:           "bytes,5447656,opt,name=field12899",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message13145)(nil),
+		ExtensionType: (*Message13154)(nil),
+		Field:         47301086,
+		Name:          "benchmarks.google_message3.Message13154.field13166",
+		Tag:           "bytes,47301086,opt,name=field13166",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message0)(nil),
+		ExtensionType: (*Message16507)(nil),
+		Field:         5569941,
+		Name:          "benchmarks.google_message3.Message16507.field16542",
+		Tag:           "bytes,5569941,opt,name=field16542",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message0)(nil),
+		ExtensionType: (*Message16564)(nil),
+		Field:         25830030,
+		Name:          "benchmarks.google_message3.Message16564.field16569",
+		Tag:           "bytes,25830030,opt,name=field16569",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message0)(nil),
+		ExtensionType: (*Message16661)(nil),
+		Field:         31274398,
+		Name:          "benchmarks.google_message3.Message16661.field16673",
+		Tag:           "bytes,31274398,opt,name=field16673",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message0)(nil),
+		ExtensionType: (*Message16746)(nil),
+		Field:         28406765,
+		Name:          "benchmarks.google_message3.Message16746.field16810",
+		Tag:           "bytes,28406765,opt,name=field16810",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message0)(nil),
+		ExtensionType: (*Message17786)(nil),
+		Field:         11823055,
+		Name:          "benchmarks.google_message3.Message17786.field18176",
+		Tag:           "bytes,11823055,opt,name=field18176",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message10155)(nil),
+		ExtensionType: (*Message22857)(nil),
+		Field:         67799715,
+		Name:          "benchmarks.google_message3.Message22857.field22875",
+		Tag:           "bytes,67799715,opt,name=field22875",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message0)(nil),
+		ExtensionType: (*Message24404)(nil),
+		Field:         9129287,
+		Name:          "benchmarks.google_message3.Message24404.field24685",
+		Tag:           "bytes,9129287,opt,name=field24685",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message0)(nil),
+		ExtensionType: (*Message27300)(nil),
+		Field:         24956467,
+		Name:          "benchmarks.google_message3.Message27300.field27304",
+		Tag:           "bytes,24956467,opt,name=field27304",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+	{
+		ExtendedType:  (*Message0)(nil),
+		ExtensionType: (*Message27453)(nil),
+		Field:         8086204,
+		Name:          "benchmarks.google_message3.Message27453.field27482",
+		Tag:           "bytes,8086204,opt,name=field27482",
+		Filename:      "datasets/google_message3/benchmark_message3.proto",
+	},
+}
+
+// Extension fields to Message16945.
+var (
+	// optional string field17026 = 472;
+	E_Field17026 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[0]
+	// repeated string field17027 = 818;
+	E_Field17027 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[1]
+	// optional benchmarks.google_message3.Message0 field17031 = 215;
+	E_Field17031 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[2]
+	// repeated benchmarks.google_message3.Message0 field17032 = 292;
+	E_Field17032 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[3]
+	// repeated benchmarks.google_message3.Message0 field17038 = 234;
+	E_Field17038 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[4]
+	// repeated benchmarks.google_message3.Message0 field17039 = 235;
+	E_Field17039 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[5]
+	// optional benchmarks.google_message3.Message0 field17042 = 246;
+	E_Field17042 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[6]
+	// optional string field17043 = 224;
+	E_Field17043 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[7]
+	// optional string field17044 = 225;
+	E_Field17044 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[8]
+	// repeated string field17048 = 63;
+	E_Field17048 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[9]
+	// repeated string field17049 = 64;
+	E_Field17049 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[10]
+	// repeated benchmarks.google_message3.Message0 field17052 = 233;
+	E_Field17052 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[11]
+	// repeated benchmarks.google_message3.Message0 field17053 = 66;
+	E_Field17053 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[12]
+	// repeated string field17056 = 275;
+	E_Field17056 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[13]
+	// optional string field17057 = 226;
+	E_Field17057 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[14]
+	// repeated benchmarks.google_message3.Message0 field17060 = 27;
+	E_Field17060 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[15]
+	// repeated string field17073 = 75;
+	E_Field17073 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[16]
+	// repeated benchmarks.google_message3.Message0 field17076 = 77;
+	E_Field17076 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[17]
+	// repeated string field17078 = 296;
+	E_Field17078 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[18]
+	// repeated benchmarks.google_message3.Message0 field17082 = 160;
+	E_Field17082 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[19]
+	// repeated benchmarks.google_message3.Message0 field17091 = 585;
+	E_Field17091 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[20]
+	// repeated benchmarks.google_message3.Message0 field17098 = 987;
+	E_Field17098 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[21]
+	// repeated benchmarks.google_message3.Message0 field17101 = 157;
+	E_Field17101 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[22]
+	// repeated string field17102 = 158;
+	E_Field17102 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[23]
+	// repeated string field17107 = 166;
+	E_Field17107 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[24]
+	// repeated string field17133 = 567;
+	E_Field17133 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[25]
+	// repeated string field17134 = 572;
+	E_Field17134 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[26]
+	// repeated string field17160 = 49;
+	E_Field17160 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[27]
+	// repeated string field17168 = 32;
+	E_Field17168 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[28]
+	// repeated string field17170 = 34;
+	E_Field17170 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[29]
+	// repeated benchmarks.google_message3.Message0 field17172 = 509;
+	E_Field17172 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[30]
+	// repeated string field17174 = 39;
+	E_Field17174 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[31]
+	// repeated benchmarks.google_message3.Message0 field17175 = 40;
+	E_Field17175 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[32]
+	// repeated benchmarks.google_message3.Message0 field17178 = 511;
+	E_Field17178 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[33]
+	// repeated benchmarks.google_message3.Message0 field17185 = 50;
+	E_Field17185 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[34]
+	// repeated int32 field17207 = 1081;
+	E_Field17207 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[35]
+	// repeated benchmarks.google_message3.Message0 field17238 = 184;
+	E_Field17238 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[36]
+	// repeated benchmarks.google_message3.Message0 field17289 = 177;
+	E_Field17289 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[37]
+	// repeated benchmarks.google_message3.Message0 field17290 = 178;
+	E_Field17290 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[38]
+	// repeated benchmarks.google_message3.Message0 field17296 = 474;
+	E_Field17296 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[39]
+	// repeated string field17298 = 44;
+	E_Field17298 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[40]
+	// repeated benchmarks.google_message3.Message0 field17301 = 47;
+	E_Field17301 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[41]
+	// optional benchmarks.google_message3.Message0 field17412 = 21;
+	E_Field17412 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[42]
+	// repeated benchmarks.google_message3.Message0 field17438 = 132;
+	E_Field17438 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[43]
+	// repeated benchmarks.google_message3.Message0 field17458 = 512;
+	E_Field17458 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[44]
+	// repeated string field17460 = 560;
+	E_Field17460 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[45]
+	// repeated string field17466 = 552;
+	E_Field17466 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[46]
+	// repeated benchmarks.google_message3.Message0 field17617 = 1080;
+	E_Field17617 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[47]
+	// repeated int32 field17618 = 1084;
+	E_Field17618 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[48]
+)
+
+// Extension fields to Message0.
+var (
+	// optional benchmarks.google_message3.Message1327 field1373 = 23104162;
+	E_Message1327_Field1373 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[49]
+	// optional benchmarks.google_message3.Message3672 field3737 = 3144435;
+	E_Message3672_Field3737 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[50]
+	// optional benchmarks.google_message3.Message3804 field3825 = 59241828;
+	E_Message3804_Field3825 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[51]
+	// optional benchmarks.google_message3.Message6849 field6911 = 107558455;
+	E_Message6849_Field6911 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[52]
+	// optional benchmarks.google_message3.Message6866 field6974 = 22259060;
+	E_Message6866_Field6974 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[53]
+	// optional benchmarks.google_message3.Message6870 field6992 = 90034652;
+	E_Message6870_Field6992 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[54]
+	// optional benchmarks.google_message3.Message7651 field7730 = 55876009;
+	E_Message7651_Field7730 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[55]
+	// optional benchmarks.google_message3.Message7864 field7872 = 44542730;
+	E_Message7864_Field7872 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[56]
+	// optional benchmarks.google_message3.Message7929 field7962 = 53392238;
+	E_Message7929_Field7962 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[57]
+	// optional benchmarks.google_message3.Message8508 field8534 = 3811804;
+	E_Message8508_Field8534 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[58]
+	// optional benchmarks.google_message3.Message9122 field9134 = 120398939;
+	E_Message9122_Field9134 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[59]
+	// optional benchmarks.google_message3.Message10177 field10271 = 26801105;
+	E_Message10177_Field10271 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[60]
+	// optional benchmarks.google_message3.Message11990 field12031 = 21265426;
+	E_Message11990_Field12031 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[64]
+	// optional benchmarks.google_message3.Message12691 field12716 = 28426536;
+	E_Message12691_Field12716 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[65]
+	// optional benchmarks.google_message3.Message12870 field12899 = 5447656;
+	E_Message12870_Field12899 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[66]
+	// optional benchmarks.google_message3.Message16507 field16542 = 5569941;
+	E_Message16507_Field16542 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[68]
+	// optional benchmarks.google_message3.Message16564 field16569 = 25830030;
+	E_Message16564_Field16569 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[69]
+	// optional benchmarks.google_message3.Message16661 field16673 = 31274398;
+	E_Message16661_Field16673 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[70]
+	// optional benchmarks.google_message3.Message16746 field16810 = 28406765;
+	E_Message16746_Field16810 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[71]
+	// optional benchmarks.google_message3.Message17786 field18176 = 11823055;
+	E_Message17786_Field18176 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[72]
+	// optional benchmarks.google_message3.Message24404 field24685 = 9129287;
+	E_Message24404_Field24685 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[74]
+	// optional benchmarks.google_message3.Message27300 field27304 = 24956467;
+	E_Message27300_Field27304 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[75]
+	// optional benchmarks.google_message3.Message27453 field27482 = 8086204;
+	E_Message27453_Field27482 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[76]
+)
+
+// Extension fields to Message10155.
+var (
+	// optional benchmarks.google_message3.Message10278 field10289 = 29374161;
+	E_Message10278_Field10289 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[61]
+	// optional benchmarks.google_message3.Message10323 field10361 = 27922524;
+	E_Message10323_Field10361 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[62]
+	// optional benchmarks.google_message3.Message10324 field10364 = 27832297;
+	E_Message10324_Field10364 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[63]
+	// optional benchmarks.google_message3.Message22857 field22875 = 67799715;
+	E_Message22857_Field22875 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[73]
+)
+
+// Extension fields to Message13145.
+var (
+	// optional benchmarks.google_message3.Message13154 field13166 = 47301086;
+	E_Message13154_Field13166 = &file_datasets_google_message3_benchmark_message3_proto_extTypes[67]
+)
+
+var File_datasets_google_message3_benchmark_message3_proto protoreflect.FileDescriptor
+
+var file_datasets_google_message3_benchmark_message3_proto_rawDesc = []byte{
+	0x0a, 0x31, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x12, 0x1a, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x1a,
+	0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x5f, 0x31, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2f, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x5f, 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73,
+	0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x5f, 0x33, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x33,
+	0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x5f, 0x34, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x1a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2f, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x5f, 0x35, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65,
+	0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x5f, 0x37, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x33, 0x64,
+	0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x5f, 0x38, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x22, 0xa6, 0x09, 0x0a, 0x0e, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37,
+	0x35, 0x31, 0x39, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x37,
+	0x34, 0x38, 0x37, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x31, 0x39, 0x12,
+	0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x32, 0x30, 0x18, 0x03, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x37, 0x36, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x32, 0x30, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x35, 0x32, 0x31, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x31, 0x33, 0x30, 0x36, 0x32, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37,
+	0x35, 0x32, 0x31, 0x12, 0x46, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x32,
+	0x32, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x39, 0x35, 0x32, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x32, 0x32, 0x12, 0x4e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x32, 0x33, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x32, 0x33, 0x12, 0x4e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x32, 0x34, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x32, 0x34, 0x12, 0x4e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x32, 0x35, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x32, 0x35, 0x12, 0x4e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x32, 0x36, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x32, 0x36, 0x12, 0x4e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x32, 0x37, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x32, 0x37, 0x12, 0x4e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x32, 0x38, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x32, 0x38, 0x12, 0x4e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x32, 0x39, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x32, 0x39, 0x12, 0x4e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x33, 0x30, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x33, 0x30, 0x12, 0x4e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x33, 0x31, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x33, 0x31, 0x12, 0x4e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x33, 0x32, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x33, 0x32, 0x12, 0x4e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x33, 0x33, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x33, 0x33, 0x22, 0xae, 0x03, 0x0a, 0x0b,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x32, 0x37, 0x12, 0x4c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x36, 0x39, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73,
+	0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x36, 0x39, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x33, 0x37, 0x30, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x31, 0x33, 0x32, 0x38, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x37, 0x30,
+	0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x37, 0x31, 0x18, 0x05, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x37, 0x31, 0x12, 0x4c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x37, 0x32, 0x18, 0x06, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55,
+	0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x37, 0x32, 0x32, 0x6e, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x37, 0x33, 0x12, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x18,
+	0xa2, 0x95, 0x82, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x32,
+	0x37, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x37, 0x33, 0x22, 0xf9, 0x06, 0x0a,
+	0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x37, 0x32, 0x12, 0x42, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x32, 0x37, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32,
+	0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75,
+	0x6d, 0x33, 0x34, 0x37, 0x36, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x32, 0x37,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x32, 0x38, 0x18, 0x0b, 0x20,
+	0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x32, 0x38, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x32, 0x39, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x32, 0x39, 0x12, 0x55, 0x0a, 0x0b,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x37, 0x33, 0x18, 0x03, 0x20, 0x03, 0x28,
+	0x0a, 0x32, 0x33, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x37, 0x32, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x36, 0x37, 0x33, 0x52, 0x0b, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x36, 0x37, 0x33, 0x12, 0x55, 0x0a, 0x0b, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36,
+	0x37, 0x34, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0a, 0x32, 0x33, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x37,
+	0x32, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x37, 0x34, 0x52, 0x0b, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x37, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x32, 0x18, 0x09, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x37, 0x33, 0x33, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x33, 0x33, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x37, 0x33, 0x34, 0x18, 0x14, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x33, 0x34, 0x37, 0x36, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x35, 0x18, 0x15, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x35, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x37, 0x33, 0x36, 0x18, 0x32, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45,
+	0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x33, 0x36, 0x1a, 0x6f, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x36, 0x37, 0x33, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37,
+	0x33, 0x38, 0x18, 0x04, 0x20, 0x02, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x33, 0x34, 0x37, 0x36, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x33, 0x39, 0x18, 0x05, 0x20, 0x02, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x39, 0x1a, 0x6f, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x36, 0x37, 0x34, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x37, 0x34, 0x30, 0x18, 0x07, 0x20, 0x02, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x33, 0x34, 0x37, 0x36, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x34, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x37, 0x34, 0x31, 0x18, 0x08, 0x20, 0x02, 0x28, 0x05, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x34, 0x31, 0x32, 0x6e, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x37, 0x33, 0x37, 0x12, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x18, 0xf3, 0xf5, 0xbf, 0x01,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x37, 0x32, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x37, 0x22, 0x9b, 0x03, 0x0a, 0x0b, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x38, 0x30, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x38, 0x31, 0x38, 0x18, 0x01, 0x20, 0x02, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x38, 0x31, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x38, 0x31, 0x39, 0x18, 0x02, 0x20, 0x02, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x38, 0x31, 0x39, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x38, 0x32,
+	0x30, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x33, 0x38, 0x30, 0x35, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x38, 0x32, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x38, 0x32, 0x31, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x38, 0x32, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x38, 0x32, 0x32, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x38, 0x32, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x38, 0x32,
+	0x33, 0x18, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x38,
+	0x32, 0x33, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x38, 0x32, 0x34, 0x18,
+	0x08, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x33, 0x37, 0x38, 0x33, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x38, 0x32, 0x34, 0x32, 0x6e, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x38, 0x32, 0x35, 0x12, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x18, 0xe4, 0xea, 0x9f, 0x1c, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x38, 0x30, 0x34, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x38, 0x32, 0x35, 0x22, 0xc4, 0x01, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x36, 0x38, 0x34, 0x39, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36,
+	0x39, 0x31, 0x30, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x38,
+	0x35, 0x30, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x31, 0x30, 0x32, 0x6e, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x31, 0x31, 0x12, 0x24, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30,
+	0x18, 0xb7, 0xec, 0xa4, 0x33, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x38,
+	0x34, 0x39, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x31, 0x31, 0x22, 0xc4, 0x01,
+	0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x38, 0x36, 0x36, 0x12, 0x45, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x37, 0x33, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x38, 0x36, 0x33, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x36, 0x39, 0x37, 0x33, 0x32, 0x6e, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x37,
+	0x34, 0x12, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x18, 0xf4, 0xca, 0xce, 0x0a, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x38, 0x36, 0x36, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x36, 0x39, 0x37, 0x34, 0x22, 0xc4, 0x01, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x36, 0x38, 0x37, 0x30, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x39,
+	0x31, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x38, 0x37, 0x31,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x39, 0x31, 0x32, 0x6e, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x39, 0x32, 0x12, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x18, 0xdc,
+	0xa3, 0xf7, 0x2a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x38, 0x37, 0x30,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x39, 0x32, 0x22, 0xcc, 0x0e, 0x0a, 0x0b,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x36, 0x35, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x38, 0x35, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x38, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x37, 0x36, 0x38, 0x36, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x36, 0x38, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x37, 0x36, 0x38, 0x37, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x36, 0x38, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36,
+	0x38, 0x38, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37,
+	0x36, 0x38, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x38, 0x39,
+	0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x38,
+	0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x39, 0x30, 0x18, 0x06,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x39, 0x30, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x39, 0x31, 0x18, 0x07, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x39, 0x31, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x39, 0x32, 0x18, 0x08, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x39, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x39, 0x33, 0x18, 0x09, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x39, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x37, 0x36, 0x39, 0x34, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x36, 0x39, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x37, 0x36, 0x39, 0x35, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x36, 0x39, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36,
+	0x39, 0x36, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37,
+	0x36, 0x39, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x39, 0x37,
+	0x18, 0x0d, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x39,
+	0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x39, 0x38, 0x18, 0x0e,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x39, 0x38, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x39, 0x39, 0x18, 0x0f, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x39, 0x39, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x30, 0x30, 0x18, 0x10, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x30, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x30, 0x31, 0x18, 0x11, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x30, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x37, 0x37, 0x30, 0x32, 0x18, 0x12, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x37, 0x30, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x37, 0x37, 0x30, 0x33, 0x18, 0x13, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x37, 0x30, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37,
+	0x30, 0x34, 0x18, 0x14, 0x20, 0x03, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37,
+	0x37, 0x30, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x30, 0x35,
+	0x18, 0x15, 0x20, 0x03, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x30,
+	0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x30, 0x36, 0x18, 0x16,
+	0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x30, 0x36, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x30, 0x37, 0x18, 0x17, 0x20, 0x03,
+	0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x30, 0x37, 0x12, 0x4c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x30, 0x38, 0x18, 0x18, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e,
+	0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x30, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x30, 0x39, 0x18, 0x19, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x30, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x37, 0x37, 0x31, 0x30, 0x18, 0x1a, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x37, 0x31, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x37, 0x37, 0x31, 0x31, 0x18, 0x1b, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x37, 0x31, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37,
+	0x31, 0x32, 0x18, 0x2b, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37,
+	0x37, 0x31, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x31, 0x33,
+	0x18, 0x1c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x31,
+	0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x31, 0x34, 0x18, 0x1d,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x31, 0x34, 0x12,
+	0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x31, 0x35, 0x18, 0x1e, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x35, 0x34, 0x37, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x37, 0x37, 0x31, 0x35, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37,
+	0x37, 0x31, 0x36, 0x18, 0x1f, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x35,
+	0x34, 0x37, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x31, 0x36, 0x12, 0x4c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x31, 0x37, 0x18, 0x20, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e,
+	0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x31, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x31, 0x38, 0x18, 0x21, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x31, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x37, 0x37, 0x31, 0x39, 0x18, 0x22, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x37, 0x31, 0x39, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x37, 0x37, 0x32, 0x30, 0x18, 0x23, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37,
+	0x36, 0x34, 0x38, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x32, 0x30, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x32, 0x31, 0x18, 0x24, 0x20, 0x01, 0x28,
+	0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x32, 0x31, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x32, 0x32, 0x18, 0x25, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x32, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x37, 0x32, 0x33, 0x18, 0x26, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x32, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x37, 0x32, 0x34, 0x18, 0x27, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x37, 0x37, 0x32, 0x34, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37,
+	0x37, 0x32, 0x35, 0x18, 0x28, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70,
+	0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x37, 0x37, 0x32, 0x35, 0x12, 0x44, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x32,
+	0x36, 0x18, 0x29, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x32, 0x36, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x37, 0x32, 0x37, 0x18, 0x2a, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x37,
+	0x36, 0x35, 0x34, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x32, 0x37, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x32, 0x38, 0x18, 0x2c, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x32, 0x38, 0x12, 0x4c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x32, 0x39, 0x18, 0x2d, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x32, 0x39, 0x32, 0x6e, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x37, 0x33, 0x30, 0x12, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x18, 0xa9, 0xb3,
+	0xd2, 0x1a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x36, 0x35, 0x31, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x33, 0x30, 0x22, 0xdc, 0x03, 0x0a, 0x0b, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x38, 0x36, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x38, 0x36, 0x36, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x36, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x38, 0x36, 0x37, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x37, 0x38, 0x36, 0x37, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37,
+	0x38, 0x36, 0x38, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x38,
+	0x36, 0x35, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x36, 0x38, 0x12, 0x45, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x36, 0x39, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x38, 0x36, 0x35, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x37, 0x38, 0x36, 0x39, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x37,
+	0x30, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x38, 0x36, 0x35,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x37, 0x30, 0x12, 0x4c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x37, 0x31, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73,
+	0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x37, 0x31, 0x32, 0x6e, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x37, 0x38, 0x37, 0x32, 0x12, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x18, 0x8a, 0xd6, 0x9e,
+	0x15, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x38, 0x36, 0x34, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x37, 0x32, 0x22, 0xd9, 0x07, 0x0a, 0x0b, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x39, 0x32, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x37, 0x39, 0x34, 0x32, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x39, 0x34, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x37, 0x39, 0x34, 0x33, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x39, 0x34, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39,
+	0x34, 0x34, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37,
+	0x39, 0x34, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x34, 0x35,
+	0x18, 0x0c, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x34,
+	0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x34, 0x36, 0x18, 0x0d,
+	0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x34, 0x36, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x34, 0x37, 0x18, 0x12, 0x20, 0x01,
+	0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x34, 0x37, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x34, 0x38, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x34, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x34, 0x39, 0x18, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x34, 0x39, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x37, 0x39, 0x35, 0x30, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x37, 0x39, 0x31, 0x39, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x35, 0x30,
+	0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x35, 0x31, 0x18, 0x14, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x35, 0x31, 0x12, 0x45,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x35, 0x32, 0x18, 0x0e, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x39, 0x32, 0x30, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x39, 0x35, 0x32, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39,
+	0x35, 0x33, 0x18, 0x0f, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x39, 0x32,
+	0x31, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x35, 0x33, 0x12, 0x45, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x35, 0x34, 0x18, 0x11, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x37, 0x39, 0x32, 0x38, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37,
+	0x39, 0x35, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x35, 0x35,
+	0x18, 0x13, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x35,
+	0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x35, 0x36, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x35, 0x36, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x35, 0x37, 0x18, 0x03, 0x20, 0x01,
+	0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x35, 0x37, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x35, 0x38, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x35, 0x38, 0x12, 0x4c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x35, 0x39, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73,
+	0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x35, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x37, 0x39, 0x36, 0x30, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x39, 0x36, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x37, 0x39, 0x36, 0x31, 0x18, 0x10, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x39, 0x36, 0x31, 0x32, 0x6e, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39,
+	0x36, 0x32, 0x12, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x18, 0xee, 0xe6, 0xba, 0x19, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x39, 0x32, 0x39, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x39, 0x36, 0x32, 0x22, 0xa8, 0x07, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x38, 0x35, 0x30, 0x38, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35,
+	0x31, 0x37, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x35, 0x31,
+	0x31, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x31, 0x37, 0x12, 0x45, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x31, 0x38, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x38, 0x35, 0x31, 0x32, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x35, 0x31, 0x38, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x31, 0x39,
+	0x18, 0x0b, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x35, 0x31, 0x33, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x31, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x35, 0x32, 0x30, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x32, 0x30, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x35, 0x32, 0x31, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x38, 0x35, 0x31, 0x34, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x32, 0x31, 0x12,
+	0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x32, 0x32, 0x18, 0x0f, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x32, 0x32, 0x12, 0x45, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x32, 0x33, 0x18, 0x10, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x35, 0x31, 0x35, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x35, 0x32, 0x33, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x32,
+	0x34, 0x18, 0x11, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35,
+	0x32, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x32, 0x35, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x32, 0x35,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x32, 0x36, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x02, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x32, 0x36, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x32, 0x37, 0x18, 0x03, 0x20, 0x01, 0x28,
+	0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x32, 0x37, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x32, 0x38, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x32, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x35, 0x32, 0x39, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x32, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x35, 0x33, 0x30, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x35, 0x33, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x35, 0x33, 0x31, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x35, 0x33, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x33,
+	0x32, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35,
+	0x33, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x33, 0x33, 0x18,
+	0x0c, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x33, 0x33,
+	0x32, 0x6e, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x33, 0x34, 0x12, 0x24, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x30, 0x18, 0xdc, 0xd3, 0xe8, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x38, 0x35, 0x30, 0x38, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x33, 0x34,
+	0x22, 0xb9, 0x01, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x39, 0x31, 0x32, 0x32,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x33, 0x32, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x02, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x33, 0x32, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x33, 0x33, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x02, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x33, 0x33, 0x32, 0x6e, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x33, 0x34, 0x12, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x18,
+	0xdb, 0xc8, 0xb4, 0x39, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x39, 0x31, 0x32,
+	0x32, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x33, 0x34, 0x22, 0xcb, 0x01, 0x0a,
+	0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x31, 0x37, 0x37, 0x12, 0x48, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x37, 0x30, 0x18, 0x01, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x31, 0x35, 0x35, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x30, 0x32, 0x37, 0x30, 0x32, 0x71, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x30, 0x32, 0x37, 0x31, 0x12, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x18, 0xd1, 0xe7, 0xe3, 0x0c,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x31, 0x37, 0x37, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x37, 0x31, 0x22, 0xed, 0x01, 0x0a, 0x0c, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x32, 0x37, 0x38, 0x12, 0x22, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x38, 0x36, 0x18, 0x01, 0x20, 0x03, 0x28, 0x05, 0x42,
+	0x02, 0x10, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x38, 0x36, 0x12,
+	0x22, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x38, 0x37, 0x18, 0x02, 0x20,
+	0x03, 0x28, 0x05, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30,
+	0x32, 0x38, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x38,
+	0x38, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30,
+	0x32, 0x38, 0x38, 0x32, 0x75, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x38,
+	0x39, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x31, 0x35, 0x35, 0x18, 0xd1, 0xed, 0x80, 0x0e,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x32, 0x37, 0x38, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x38, 0x39, 0x22, 0xcf, 0x01, 0x0a, 0x0c, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x33, 0x32, 0x33, 0x12, 0x48, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x36, 0x30, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x33, 0x32, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x30, 0x33, 0x36, 0x30, 0x32, 0x75, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30,
+	0x33, 0x36, 0x31, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x31, 0x35, 0x35, 0x18, 0xdc, 0xa0,
+	0xa8, 0x0d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x33, 0x32, 0x33,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x36, 0x31, 0x22, 0x99, 0x02, 0x0a,
+	0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x33, 0x32, 0x34, 0x12, 0x48, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x36, 0x32, 0x18, 0x01, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x33, 0x32, 0x32, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x30, 0x33, 0x36, 0x32, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x30, 0x33, 0x36, 0x33, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x31, 0x30, 0x33, 0x32, 0x31, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x36,
+	0x33, 0x32, 0x75, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x36, 0x34, 0x12,
+	0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x31, 0x35, 0x35, 0x18, 0xe9, 0xdf, 0xa2, 0x0d, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x33, 0x32, 0x34, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x36, 0x34, 0x22, 0xcb, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x31, 0x31, 0x39, 0x39, 0x30, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x30, 0x33, 0x30, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x31, 0x31, 0x39, 0x38, 0x38, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32,
+	0x30, 0x33, 0x30, 0x32, 0x71, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x30, 0x33,
+	0x31, 0x12, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x18, 0x92, 0xf8, 0x91, 0x0a, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x31, 0x39, 0x39, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x32, 0x30, 0x33, 0x31, 0x22, 0x8b, 0x02, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x31, 0x32, 0x36, 0x39, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x37, 0x31, 0x33, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x37, 0x31, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x37, 0x31, 0x34, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x37, 0x31, 0x34, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x37, 0x31, 0x35, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x31, 0x32, 0x36, 0x36, 0x38, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x31,
+	0x35, 0x32, 0x71, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x31, 0x36, 0x12,
+	0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x30, 0x18, 0xa8, 0x82, 0xc7, 0x0d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x31, 0x32, 0x36, 0x39, 0x31, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x37, 0x31, 0x36, 0x22, 0xfd, 0x06, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x31, 0x32, 0x38, 0x37, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32,
+	0x38, 0x37, 0x39, 0x18, 0x01, 0x20, 0x02, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x38, 0x37, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32,
+	0x38, 0x38, 0x30, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x38, 0x38, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32,
+	0x38, 0x38, 0x31, 0x18, 0x02, 0x20, 0x02, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x38, 0x38, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32,
+	0x38, 0x38, 0x32, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x38, 0x38, 0x32, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32,
+	0x38, 0x38, 0x33, 0x18, 0xd1, 0x0f, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x32, 0x38, 0x38, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x38, 0x38, 0x34, 0x18, 0x04, 0x20, 0x01, 0x28, 0x06, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x32, 0x38, 0x38, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x38, 0x38, 0x35, 0x18, 0x0e, 0x20, 0x03, 0x28, 0x06, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x32, 0x38, 0x38, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x38, 0x38, 0x36, 0x18, 0x09, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x32, 0x38, 0x38, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x38, 0x38, 0x37, 0x18, 0x12, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x32, 0x38, 0x38, 0x37, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x38, 0x38, 0x38, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31,
+	0x32, 0x38, 0x37, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x38, 0x38,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x38, 0x39, 0x18, 0x05,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x38, 0x39,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x39, 0x30, 0x18, 0x06,
+	0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x39, 0x30,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x39, 0x31, 0x18, 0x0a,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x39, 0x31,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x39, 0x32, 0x18, 0x0b,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x39, 0x32,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x39, 0x33, 0x18, 0x0c,
+	0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x39, 0x33,
+	0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x39, 0x34, 0x18, 0x0d,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x38, 0x32, 0x35, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x39, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x39, 0x35, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x39, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x39, 0x36, 0x18, 0x10, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x39, 0x36, 0x12, 0x45, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x39, 0x37, 0x18, 0x11, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d,
+	0x31, 0x32, 0x38, 0x37, 0x31, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x39,
+	0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x39, 0x38, 0x18,
+	0x13, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x39,
+	0x38, 0x32, 0x71, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x39, 0x39, 0x12,
+	0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x30, 0x18, 0xe8, 0xbf, 0xcc, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x31, 0x32, 0x38, 0x37, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x38, 0x39, 0x39, 0x22, 0xc5, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x31, 0x33, 0x31, 0x35, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33,
+	0x31, 0x36, 0x34, 0x18, 0x01, 0x20, 0x02, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x33, 0x31, 0x36, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33,
+	0x31, 0x36, 0x35, 0x18, 0x02, 0x20, 0x02, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x33, 0x31, 0x36, 0x35, 0x32, 0x75, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33,
+	0x31, 0x36, 0x36, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x31, 0x34, 0x35, 0x18, 0xde, 0x83,
+	0xc7, 0x16, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x31, 0x35, 0x34,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x31, 0x36, 0x36, 0x22, 0xf1, 0x0a, 0x0a,
+	0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x35, 0x30, 0x37, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x31, 0x30, 0x18, 0x03, 0x20, 0x01, 0x28,
+	0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x31, 0x30, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x31, 0x31, 0x18, 0x04, 0x20, 0x01, 0x28,
+	0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x31, 0x31, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x31, 0x32, 0x18, 0x0e, 0x20, 0x01, 0x28,
+	0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x31, 0x32, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x31, 0x33, 0x18, 0x05, 0x20, 0x03, 0x28,
+	0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x31, 0x33, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x31, 0x34, 0x18, 0x06, 0x20, 0x03, 0x28,
+	0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x31, 0x34, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x31, 0x35, 0x18, 0x08, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x31, 0x35, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x31, 0x36, 0x18, 0x09, 0x20, 0x03, 0x28,
+	0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x31, 0x36, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x31, 0x37, 0x18, 0x0a, 0x20, 0x03, 0x28,
+	0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x31, 0x37, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x31, 0x38, 0x18, 0x07, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x31, 0x38, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x31, 0x39, 0x18, 0x0f, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x31, 0x39, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x32, 0x30, 0x18, 0x0b, 0x20, 0x03, 0x28,
+	0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x32, 0x30, 0x12, 0x4e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x32, 0x31, 0x18, 0x1b, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55,
+	0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x32, 0x31, 0x12, 0x4e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x32, 0x32, 0x18, 0x16, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55,
+	0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x32, 0x32, 0x12, 0x4e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x32, 0x33, 0x18, 0x1c, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55,
+	0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x32, 0x33, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x32, 0x34, 0x18, 0x12, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x32, 0x34, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x32, 0x35, 0x18, 0x13, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x32, 0x35, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x32, 0x36, 0x18, 0x14, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x32, 0x36, 0x12, 0x4e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x32, 0x37, 0x18, 0x17, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55,
+	0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x32, 0x37, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x32, 0x38, 0x18, 0x18, 0x20, 0x01, 0x28,
+	0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x32, 0x38, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x32, 0x39, 0x18, 0x19, 0x20, 0x03, 0x28,
+	0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x32, 0x39, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x33, 0x30, 0x18, 0x1a, 0x20, 0x01, 0x28,
+	0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x33, 0x30, 0x12, 0x48, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x33, 0x31, 0x18, 0x1e, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x34, 0x37, 0x38, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x36, 0x35, 0x33, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x36, 0x35, 0x33, 0x32, 0x18, 0x1f, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x36, 0x35, 0x33, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x36, 0x35, 0x33, 0x33, 0x18, 0x20, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x36, 0x35, 0x33, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x36, 0x35, 0x33, 0x34, 0x18, 0x21, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x36, 0x35, 0x33, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x36, 0x35, 0x33, 0x35, 0x18, 0x23, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x36, 0x35, 0x33, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x36, 0x35, 0x33, 0x36, 0x18, 0x24, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x36, 0x35, 0x33, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x36, 0x35, 0x33, 0x37, 0x18, 0x25, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x36, 0x35, 0x33, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x36, 0x35, 0x33, 0x38, 0x18, 0x26, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x36, 0x35, 0x33, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x36, 0x35, 0x33, 0x39, 0x18, 0x27, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x36, 0x35, 0x33, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x36, 0x35, 0x34, 0x30, 0x18, 0x28, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x36, 0x35, 0x34, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x36, 0x35, 0x34, 0x31, 0x18, 0x29, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x36, 0x35, 0x34, 0x31, 0x2a, 0x04, 0x08, 0x15, 0x10, 0x16, 0x32, 0x71, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x34, 0x32, 0x12, 0x24, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x30, 0x18, 0x95, 0xfb, 0xd3, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31,
+	0x36, 0x35, 0x30, 0x37, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x34, 0x32,
+	0x22, 0xcb, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x35, 0x36,
+	0x34, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x36, 0x38, 0x18,
+	0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x35, 0x35, 0x32, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x36, 0x38, 0x32, 0x71, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x36, 0x39, 0x12, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x18,
+	0x8e, 0xc5, 0xa8, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x35,
+	0x36, 0x34, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x36, 0x39, 0x22, 0xeb,
+	0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x36, 0x36, 0x31, 0x12,
+	0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x36, 0x37, 0x31, 0x18, 0x01, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x36, 0x36, 0x30, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x36, 0x37, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x36, 0x36, 0x37, 0x32, 0x18, 0x02, 0x20, 0x03, 0x28, 0x04, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x36, 0x37, 0x32, 0x32, 0x71, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x36, 0x36, 0x37, 0x33, 0x12, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x18, 0x9e, 0xeb,
+	0xf4, 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x36, 0x36, 0x31,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x36, 0x37, 0x33, 0x22, 0xd5, 0x02, 0x0a,
+	0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x37, 0x34, 0x36, 0x12, 0x48, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x38, 0x30, 0x36, 0x18, 0x01, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x37, 0x32, 0x37, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x36, 0x38, 0x30, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x36, 0x38, 0x30, 0x37, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x36, 0x38, 0x30, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x36, 0x38, 0x30, 0x38, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x36, 0x38, 0x30, 0x38, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x36, 0x38, 0x30, 0x39, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x31, 0x36, 0x37, 0x32, 0x35, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x38, 0x30,
+	0x39, 0x32, 0x71, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x38, 0x31, 0x30, 0x12,
+	0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x30, 0x18, 0xed, 0xe7, 0xc5, 0x0d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x31, 0x36, 0x37, 0x34, 0x36, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x36, 0x38, 0x31, 0x30, 0x22, 0x94, 0x10, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x31, 0x37, 0x37, 0x38, 0x36, 0x12, 0x59, 0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x31, 0x37, 0x37, 0x38, 0x37, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0a, 0x32, 0x35, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x31, 0x37, 0x37, 0x38, 0x36, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x37, 0x37,
+	0x38, 0x37, 0x52, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x37, 0x37, 0x38, 0x37,
+	0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x37, 0x35, 0x18, 0x14,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x37, 0x37, 0x38, 0x32, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x37, 0x35, 0x1a, 0xeb, 0x0d, 0x0a, 0x0c, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x37, 0x37, 0x38, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x37, 0x37, 0x18, 0x02, 0x20, 0x02, 0x28, 0x05, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x37, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x37, 0x38, 0x18, 0x03, 0x20, 0x02, 0x28, 0x05, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x37, 0x38, 0x12, 0x48, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x37, 0x39, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x31, 0x37, 0x37, 0x38, 0x33, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x38, 0x31, 0x37, 0x39, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x31, 0x38, 0x30, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70,
+	0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x38, 0x31, 0x38, 0x30, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x31, 0x38, 0x31, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70,
+	0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x38, 0x31, 0x38, 0x31, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x31, 0x38, 0x32, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70,
+	0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x38, 0x31, 0x38, 0x32, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x31, 0x38, 0x33, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70,
+	0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x38, 0x31, 0x38, 0x33, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x31, 0x38, 0x34, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x37,
+	0x37, 0x32, 0x36, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x38, 0x34, 0x12,
+	0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x38, 0x35, 0x18, 0x0b, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x38, 0x35, 0x12,
+	0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x38, 0x36, 0x18, 0x66, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39, 0x34, 0x35, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x38, 0x36, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x38, 0x31, 0x38, 0x37, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65,
+	0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x38, 0x37, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x38, 0x31, 0x38, 0x38, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65,
+	0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x38, 0x38, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x38, 0x31, 0x38, 0x39, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65,
+	0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x38, 0x39, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x38, 0x31, 0x39, 0x30, 0x18, 0x64, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65,
+	0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x39, 0x30, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x38, 0x31, 0x39, 0x31, 0x18, 0x65, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65,
+	0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x39, 0x31, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x38, 0x31, 0x39, 0x32, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65,
+	0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x39, 0x32, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x38, 0x31, 0x39, 0x33, 0x18, 0x13, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65,
+	0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x39, 0x33, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x38, 0x31, 0x39, 0x34, 0x18, 0x16, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65,
+	0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x39, 0x34, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x38, 0x31, 0x39, 0x35, 0x18, 0x18, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65,
+	0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x39, 0x35, 0x12, 0x45, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x38, 0x31, 0x39, 0x36, 0x18, 0x15, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x31,
+	0x36, 0x39, 0x32, 0x35, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x39, 0x36,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x39, 0x37, 0x18, 0x12,
+	0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x39, 0x37,
+	0x12, 0x46, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x39, 0x38, 0x18, 0x17,
+	0x20, 0x03, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x39, 0x38, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x38, 0x31, 0x39, 0x39, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64,
+	0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x39, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x38, 0x32, 0x30, 0x30, 0x18, 0x10, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x38, 0x32, 0x30, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x38, 0x32, 0x30, 0x31, 0x18, 0x11, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x38, 0x32, 0x30, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x38, 0x32, 0x30, 0x32, 0x18, 0x63, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x38, 0x32, 0x30, 0x32, 0x32, 0x71, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x38, 0x31, 0x37, 0x36, 0x12, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x18, 0xcf, 0xcf, 0xd1,
+	0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x37, 0x37, 0x38, 0x36, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x37, 0x36, 0x22, 0xcf, 0x01, 0x0a, 0x0c,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x32, 0x38, 0x35, 0x37, 0x12, 0x48, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x32, 0x38, 0x37, 0x34, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x32, 0x38, 0x35, 0x33, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x32, 0x38, 0x37, 0x34, 0x32, 0x75, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x32, 0x38, 0x37, 0x35, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x31, 0x35, 0x35, 0x18, 0xa3,
+	0x95, 0xaa, 0x20, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x32, 0x38, 0x35,
+	0x37, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x32, 0x38, 0x37, 0x35, 0x22, 0xe7, 0x10,
+	0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x34, 0x30, 0x34, 0x12, 0x59,
+	0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x34, 0x30, 0x35, 0x18, 0x01,
+	0x20, 0x03, 0x28, 0x0a, 0x32, 0x35, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x34, 0x30, 0x34, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x34, 0x30, 0x35, 0x52, 0x0c, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x34, 0x30, 0x35, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x32, 0x34, 0x36, 0x38, 0x34, 0x18, 0x1e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x32, 0x34, 0x34, 0x30, 0x33, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34,
+	0x36, 0x38, 0x34, 0x1a, 0xbe, 0x0e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32,
+	0x34, 0x34, 0x30, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36,
+	0x38, 0x36, 0x18, 0x02, 0x20, 0x02, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x36, 0x38, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36,
+	0x38, 0x37, 0x18, 0x03, 0x20, 0x02, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x36, 0x38, 0x37, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36,
+	0x38, 0x38, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x33,
+	0x31, 0x37, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x38, 0x38, 0x12, 0x4e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x38, 0x39, 0x18, 0x05, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x38, 0x39, 0x12, 0x48,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x39, 0x30, 0x18, 0x06, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x33, 0x37, 0x36, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x39, 0x30, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x34, 0x36, 0x39, 0x31, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x32, 0x34, 0x33, 0x34, 0x35, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36,
+	0x39, 0x31, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x39, 0x32,
+	0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36,
+	0x39, 0x32, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x39, 0x33,
+	0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x33, 0x37, 0x39,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x39, 0x33, 0x12, 0x4e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x39, 0x34, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e,
+	0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x39, 0x34, 0x12, 0x4e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x39, 0x35, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e,
+	0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x39, 0x35, 0x12, 0x48, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x39, 0x36, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x33, 0x39, 0x31, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x34, 0x36, 0x39, 0x36, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x36, 0x39, 0x37, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d,
+	0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x34, 0x36, 0x39, 0x37, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x36, 0x39, 0x38, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d,
+	0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x34, 0x36, 0x39, 0x38, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x36, 0x39, 0x39, 0x18, 0x16, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d,
+	0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x34, 0x36, 0x39, 0x39, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x37, 0x30, 0x30, 0x18, 0x17, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d,
+	0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x34, 0x37, 0x30, 0x30, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x37, 0x30, 0x31, 0x18, 0x19, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d,
+	0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x34, 0x37, 0x30, 0x31, 0x12, 0x45, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x37, 0x30, 0x32, 0x18, 0x12, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x36, 0x39, 0x32,
+	0x35, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x37, 0x30, 0x32, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x37, 0x30, 0x33, 0x18, 0x14, 0x20, 0x01, 0x28,
+	0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x37, 0x30, 0x33, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x37, 0x30, 0x34, 0x18, 0x13, 0x20, 0x01, 0x28,
+	0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x37, 0x30, 0x34, 0x12, 0x45, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x37, 0x30, 0x35, 0x18, 0x18, 0x20, 0x03, 0x28,
+	0x0e, 0x32, 0x25, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45,
+	0x6e, 0x75, 0x6d, 0x31, 0x36, 0x38, 0x39, 0x31, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x37, 0x30, 0x35, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x37,
+	0x30, 0x36, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74,
+	0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x37, 0x30, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x37,
+	0x30, 0x37, 0x18, 0x10, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x37, 0x30, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x37,
+	0x30, 0x38, 0x18, 0x11, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x37, 0x30, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x37,
+	0x30, 0x39, 0x18, 0x15, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x37, 0x30, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x37,
+	0x31, 0x30, 0x18, 0x1a, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x37, 0x31, 0x30, 0x12, 0x46, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x37,
+	0x31, 0x31, 0x18, 0x1b, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x37, 0x31, 0x31, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x37, 0x31, 0x32, 0x18, 0x1c, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x37, 0x31, 0x32, 0x12, 0x46, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x37, 0x31, 0x33, 0x18, 0x1d, 0x20, 0x01, 0x28, 0x0e,
+	0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e,
+	0x75, 0x73, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x37, 0x31, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x37,
+	0x31, 0x34, 0x18, 0x1f, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x37, 0x31, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x37,
+	0x31, 0x35, 0x18, 0x63, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x37, 0x31, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x37,
+	0x31, 0x36, 0x18, 0x20, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x37, 0x31, 0x36, 0x32, 0x71, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36,
+	0x38, 0x35, 0x12, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x18, 0xc7, 0x9a, 0xad, 0x04, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x34, 0x30, 0x34, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x32, 0x34, 0x36, 0x38, 0x35, 0x22, 0xf1, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x32, 0x37, 0x33, 0x30, 0x30, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x37, 0x33, 0x30, 0x32, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64,
+	0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x37, 0x33, 0x30, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x37, 0x33, 0x30, 0x33, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x37, 0x33, 0x30, 0x33, 0x32, 0x71, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x37, 0x33, 0x30, 0x34, 0x12, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x18, 0xb3, 0x9c, 0xf3,
+	0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x37, 0x33, 0x30, 0x30, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x33, 0x30, 0x34, 0x22, 0xc2, 0x08, 0x0a, 0x0c,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x37, 0x34, 0x35, 0x33, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x35, 0x39, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x35, 0x39, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x36, 0x30, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x36, 0x30, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x36, 0x31, 0x18, 0x06, 0x20, 0x03, 0x28, 0x02,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x36, 0x31, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x36, 0x32, 0x18, 0x1b, 0x20, 0x03, 0x28, 0x05,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x36, 0x32, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x36, 0x33, 0x18, 0x1c, 0x20, 0x03, 0x28, 0x05,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x36, 0x33, 0x12, 0x48, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x36, 0x34, 0x18, 0x18, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x37, 0x34, 0x35, 0x34, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x37, 0x34, 0x36, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x37, 0x34, 0x36, 0x35, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x37, 0x34, 0x36, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x37, 0x34, 0x36, 0x36, 0x18, 0x07, 0x20, 0x03, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x37, 0x34, 0x36, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x37, 0x34, 0x36, 0x37, 0x18, 0x16, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x37, 0x34, 0x36, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x37, 0x34, 0x36, 0x38, 0x18, 0x17, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x37, 0x34, 0x36, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x37, 0x34, 0x36, 0x39, 0x18, 0x1a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x37, 0x34, 0x36, 0x39, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x37, 0x34, 0x37, 0x30, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32,
+	0x37, 0x33, 0x35, 0x37, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x37, 0x30,
+	0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x37, 0x31, 0x18, 0x10,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x37, 0x33, 0x36, 0x30, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x37, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x37, 0x32, 0x18, 0x19, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x37, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x37, 0x33, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x37, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x37, 0x34, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x37, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x37, 0x35, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x37, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x37, 0x36, 0x18, 0x11, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x37, 0x36, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x37, 0x37, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73,
+	0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x37, 0x37, 0x12, 0x21, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x37, 0x38, 0x18, 0x91, 0xce, 0xab, 0x10, 0x20, 0x01, 0x28,
+	0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x37, 0x38, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x37, 0x39, 0x18, 0x14, 0x20, 0x01, 0x28,
+	0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x37, 0x39, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x38, 0x30, 0x18, 0x15, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x38, 0x30, 0x12, 0x4e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x38, 0x31, 0x18, 0x0a, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55,
+	0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x38, 0x31, 0x32, 0x71, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x38, 0x32, 0x12, 0x24, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x30, 0x18, 0xbc, 0xc5, 0xed, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32,
+	0x37, 0x34, 0x35, 0x33, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x38, 0x32,
+	0x3a, 0x49, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x32, 0x36, 0x12, 0x28,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x31, 0x36, 0x39, 0x34, 0x35, 0x18, 0xd8, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x32, 0x36, 0x3a, 0x49, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x32, 0x37, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36,
+	0x39, 0x34, 0x35, 0x18, 0xb2, 0x06, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x37, 0x30, 0x32, 0x37, 0x3a, 0x6f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x37, 0x30, 0x33, 0x31, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39, 0x34, 0x35, 0x18, 0xd7,
+	0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x37, 0x30, 0x33, 0x31, 0x3a, 0x6f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x37, 0x30, 0x33, 0x32, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39, 0x34, 0x35, 0x18,
+	0xa4, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x33, 0x32, 0x3a, 0x6f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x37, 0x30, 0x33, 0x38, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39, 0x34, 0x35,
+	0x18, 0xea, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x33, 0x38, 0x3a, 0x6f, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x37, 0x30, 0x33, 0x39, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39, 0x34,
+	0x35, 0x18, 0xeb, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x33, 0x39, 0x3a, 0x6f, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x34, 0x32, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39,
+	0x34, 0x35, 0x18, 0xf6, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x34, 0x32, 0x3a, 0x49, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x34, 0x33, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36,
+	0x39, 0x34, 0x35, 0x18, 0xe0, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x37, 0x30, 0x34, 0x33, 0x3a, 0x49, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x37, 0x30, 0x34, 0x34, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39, 0x34, 0x35, 0x18, 0xe1,
+	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x34,
+	0x34, 0x3a, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x34, 0x38, 0x12,
+	0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39, 0x34, 0x35, 0x18, 0x3f, 0x20, 0x03, 0x28, 0x09, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x34, 0x38, 0x3a, 0x48, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x34, 0x39, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36,
+	0x39, 0x34, 0x35, 0x18, 0x40, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x37, 0x30, 0x34, 0x39, 0x3a, 0x6f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37,
+	0x30, 0x35, 0x32, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39, 0x34, 0x35, 0x18, 0xe9, 0x01,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x37, 0x30, 0x35, 0x32, 0x3a, 0x6e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x37, 0x30, 0x35, 0x33, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39, 0x34, 0x35, 0x18, 0x42,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x37, 0x30, 0x35, 0x33, 0x3a, 0x49, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x37, 0x30, 0x35, 0x36, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39, 0x34, 0x35, 0x18, 0x93,
+	0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x35,
+	0x36, 0x3a, 0x49, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x35, 0x37, 0x12,
+	0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39, 0x34, 0x35, 0x18, 0xe2, 0x01, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x35, 0x37, 0x3a, 0x6e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x36, 0x30, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31,
+	0x36, 0x39, 0x34, 0x35, 0x18, 0x1b, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x36, 0x30, 0x3a, 0x48, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x37, 0x33, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31,
+	0x36, 0x39, 0x34, 0x35, 0x18, 0x4b, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x37, 0x30, 0x37, 0x33, 0x3a, 0x6e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x37, 0x30, 0x37, 0x36, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39, 0x34, 0x35, 0x18, 0x4d,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x37, 0x30, 0x37, 0x36, 0x3a, 0x49, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x37, 0x30, 0x37, 0x38, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39, 0x34, 0x35, 0x18, 0xa8,
+	0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x37,
+	0x38, 0x3a, 0x6f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x38, 0x32, 0x12,
+	0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39, 0x34, 0x35, 0x18, 0xa0, 0x01, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30,
+	0x38, 0x32, 0x3a, 0x6f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x39, 0x31,
+	0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39, 0x34, 0x35, 0x18, 0xc9, 0x04, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37,
+	0x30, 0x39, 0x31, 0x3a, 0x6f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x39,
+	0x38, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39, 0x34, 0x35, 0x18, 0xdb, 0x07, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x37, 0x30, 0x39, 0x38, 0x3a, 0x6f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x31,
+	0x30, 0x31, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39, 0x34, 0x35, 0x18, 0x9d, 0x01, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x37, 0x31, 0x30, 0x31, 0x3a, 0x49, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37,
+	0x31, 0x30, 0x32, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39, 0x34, 0x35, 0x18, 0x9e, 0x01,
+	0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x31, 0x30, 0x32,
+	0x3a, 0x49, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x31, 0x30, 0x37, 0x12, 0x28,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x31, 0x36, 0x39, 0x34, 0x35, 0x18, 0xa6, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x31, 0x30, 0x37, 0x3a, 0x49, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x31, 0x33, 0x33, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36,
+	0x39, 0x34, 0x35, 0x18, 0xb7, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x37, 0x31, 0x33, 0x33, 0x3a, 0x49, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x37, 0x31, 0x33, 0x34, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39, 0x34, 0x35, 0x18, 0xbc,
+	0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x31, 0x33,
+	0x34, 0x3a, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x31, 0x36, 0x30, 0x12,
+	0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39, 0x34, 0x35, 0x18, 0x31, 0x20, 0x03, 0x28, 0x09, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x31, 0x36, 0x30, 0x3a, 0x48, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x31, 0x36, 0x38, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36,
+	0x39, 0x34, 0x35, 0x18, 0x20, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x37, 0x31, 0x36, 0x38, 0x3a, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37,
+	0x31, 0x37, 0x30, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39, 0x34, 0x35, 0x18, 0x22, 0x20,
+	0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x31, 0x37, 0x30, 0x3a,
+	0x6f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x31, 0x37, 0x32, 0x12, 0x28, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x31, 0x36, 0x39, 0x34, 0x35, 0x18, 0xfd, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x31, 0x37, 0x32,
+	0x3a, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x31, 0x37, 0x34, 0x12, 0x28,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x31, 0x36, 0x39, 0x34, 0x35, 0x18, 0x27, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x31, 0x37, 0x34, 0x3a, 0x6e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x37, 0x31, 0x37, 0x35, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39,
+	0x34, 0x35, 0x18, 0x28, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x31, 0x37, 0x35, 0x3a, 0x6f, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x37, 0x31, 0x37, 0x38, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39,
+	0x34, 0x35, 0x18, 0xff, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x31, 0x37, 0x38, 0x3a, 0x6e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x31, 0x38, 0x35, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36,
+	0x39, 0x34, 0x35, 0x18, 0x32, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x31, 0x38, 0x35, 0x3a, 0x49, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x32, 0x30, 0x37, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36,
+	0x39, 0x34, 0x35, 0x18, 0xb9, 0x08, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x37, 0x32, 0x30, 0x37, 0x3a, 0x6f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x37, 0x32, 0x33, 0x38, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39, 0x34, 0x35, 0x18, 0xb8,
+	0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x37, 0x32, 0x33, 0x38, 0x3a, 0x6f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x37, 0x32, 0x38, 0x39, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39, 0x34, 0x35, 0x18,
+	0xb1, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x37, 0x32, 0x38, 0x39, 0x3a, 0x6f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x37, 0x32, 0x39, 0x30, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39, 0x34, 0x35,
+	0x18, 0xb2, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x32, 0x39, 0x30, 0x3a, 0x6f, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x37, 0x32, 0x39, 0x36, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39, 0x34,
+	0x35, 0x18, 0xda, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x32, 0x39, 0x36, 0x3a, 0x48, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x37, 0x32, 0x39, 0x38, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39,
+	0x34, 0x35, 0x18, 0x2c, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x37, 0x32, 0x39, 0x38, 0x3a, 0x6e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x33,
+	0x30, 0x31, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39, 0x34, 0x35, 0x18, 0x2f, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x37, 0x33, 0x30, 0x31, 0x3a, 0x6e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x34,
+	0x31, 0x32, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39, 0x34, 0x35, 0x18, 0x15, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x37, 0x34, 0x31, 0x32, 0x3a, 0x6f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x34,
+	0x33, 0x38, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39, 0x34, 0x35, 0x18, 0x84, 0x01, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x37, 0x34, 0x33, 0x38, 0x3a, 0x6f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37,
+	0x34, 0x35, 0x38, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39, 0x34, 0x35, 0x18, 0x80, 0x04,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x37, 0x34, 0x35, 0x38, 0x3a, 0x49, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x37, 0x34, 0x36, 0x30, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39, 0x34, 0x35, 0x18, 0xb0,
+	0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x34, 0x36,
+	0x30, 0x3a, 0x49, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x34, 0x36, 0x36, 0x12,
+	0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39, 0x34, 0x35, 0x18, 0xa8, 0x04, 0x20, 0x03, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x34, 0x36, 0x36, 0x3a, 0x6f, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x36, 0x31, 0x37, 0x12, 0x28, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31,
+	0x36, 0x39, 0x34, 0x35, 0x18, 0xb8, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x36, 0x31, 0x37, 0x3a, 0x49, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x36, 0x31, 0x38, 0x12, 0x28, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x31, 0x36, 0x39, 0x34, 0x35, 0x18, 0xbc, 0x08, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x37, 0x36, 0x31, 0x38, 0x42, 0x23, 0x0a, 0x1e, 0x63, 0x6f, 0x6d, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0xf8, 0x01, 0x01,
+}
+
+var (
+	file_datasets_google_message3_benchmark_message3_proto_rawDescOnce sync.Once
+	file_datasets_google_message3_benchmark_message3_proto_rawDescData = file_datasets_google_message3_benchmark_message3_proto_rawDesc
+)
+
+func file_datasets_google_message3_benchmark_message3_proto_rawDescGZIP() []byte {
+	file_datasets_google_message3_benchmark_message3_proto_rawDescOnce.Do(func() {
+		file_datasets_google_message3_benchmark_message3_proto_rawDescData = protoimpl.X.CompressGZIP(file_datasets_google_message3_benchmark_message3_proto_rawDescData)
+	})
+	return file_datasets_google_message3_benchmark_message3_proto_rawDescData
+}
+
+var file_datasets_google_message3_benchmark_message3_proto_msgTypes = make([]protoimpl.MessageInfo, 33)
+var file_datasets_google_message3_benchmark_message3_proto_goTypes = []interface{}{
+	(*GoogleMessage3)(nil),            // 0: benchmarks.google_message3.GoogleMessage3
+	(*Message1327)(nil),               // 1: benchmarks.google_message3.Message1327
+	(*Message3672)(nil),               // 2: benchmarks.google_message3.Message3672
+	(*Message3804)(nil),               // 3: benchmarks.google_message3.Message3804
+	(*Message6849)(nil),               // 4: benchmarks.google_message3.Message6849
+	(*Message6866)(nil),               // 5: benchmarks.google_message3.Message6866
+	(*Message6870)(nil),               // 6: benchmarks.google_message3.Message6870
+	(*Message7651)(nil),               // 7: benchmarks.google_message3.Message7651
+	(*Message7864)(nil),               // 8: benchmarks.google_message3.Message7864
+	(*Message7929)(nil),               // 9: benchmarks.google_message3.Message7929
+	(*Message8508)(nil),               // 10: benchmarks.google_message3.Message8508
+	(*Message9122)(nil),               // 11: benchmarks.google_message3.Message9122
+	(*Message10177)(nil),              // 12: benchmarks.google_message3.Message10177
+	(*Message10278)(nil),              // 13: benchmarks.google_message3.Message10278
+	(*Message10323)(nil),              // 14: benchmarks.google_message3.Message10323
+	(*Message10324)(nil),              // 15: benchmarks.google_message3.Message10324
+	(*Message11990)(nil),              // 16: benchmarks.google_message3.Message11990
+	(*Message12691)(nil),              // 17: benchmarks.google_message3.Message12691
+	(*Message12870)(nil),              // 18: benchmarks.google_message3.Message12870
+	(*Message13154)(nil),              // 19: benchmarks.google_message3.Message13154
+	(*Message16507)(nil),              // 20: benchmarks.google_message3.Message16507
+	(*Message16564)(nil),              // 21: benchmarks.google_message3.Message16564
+	(*Message16661)(nil),              // 22: benchmarks.google_message3.Message16661
+	(*Message16746)(nil),              // 23: benchmarks.google_message3.Message16746
+	(*Message17786)(nil),              // 24: benchmarks.google_message3.Message17786
+	(*Message22857)(nil),              // 25: benchmarks.google_message3.Message22857
+	(*Message24404)(nil),              // 26: benchmarks.google_message3.Message24404
+	(*Message27300)(nil),              // 27: benchmarks.google_message3.Message27300
+	(*Message27453)(nil),              // 28: benchmarks.google_message3.Message27453
+	(*Message3672_Message3673)(nil),   // 29: benchmarks.google_message3.Message3672.Message3673
+	(*Message3672_Message3674)(nil),   // 30: benchmarks.google_message3.Message3672.Message3674
+	(*Message17786_Message17787)(nil), // 31: benchmarks.google_message3.Message17786.Message17787
+	(*Message24404_Message24405)(nil), // 32: benchmarks.google_message3.Message24404.Message24405
+	(*Message37487)(nil),              // 33: benchmarks.google_message3.Message37487
+	(*Message36876)(nil),              // 34: benchmarks.google_message3.Message36876
+	(*Message13062)(nil),              // 35: benchmarks.google_message3.Message13062
+	(*Message952)(nil),                // 36: benchmarks.google_message3.Message952
+	(*UnusedEmptyMessage)(nil),        // 37: benchmarks.google_message3.UnusedEmptyMessage
+	(*Message1328)(nil),               // 38: benchmarks.google_message3.Message1328
+	(Enum3476)(0),                     // 39: benchmarks.google_message3.Enum3476
+	(Enum3805)(0),                     // 40: benchmarks.google_message3.Enum3805
+	(Enum3783)(0),                     // 41: benchmarks.google_message3.Enum3783
+	(*Message6850)(nil),               // 42: benchmarks.google_message3.Message6850
+	(*Message6863)(nil),               // 43: benchmarks.google_message3.Message6863
+	(*Message6871)(nil),               // 44: benchmarks.google_message3.Message6871
+	(*Message7547)(nil),               // 45: benchmarks.google_message3.Message7547
+	(*Message7648)(nil),               // 46: benchmarks.google_message3.Message7648
+	(UnusedEnum)(0),                   // 47: benchmarks.google_message3.UnusedEnum
+	(Enum7654)(0),                     // 48: benchmarks.google_message3.Enum7654
+	(*Message7865)(nil),               // 49: benchmarks.google_message3.Message7865
+	(*Message7919)(nil),               // 50: benchmarks.google_message3.Message7919
+	(*Message7920)(nil),               // 51: benchmarks.google_message3.Message7920
+	(*Message7921)(nil),               // 52: benchmarks.google_message3.Message7921
+	(*Message7928)(nil),               // 53: benchmarks.google_message3.Message7928
+	(*Message8511)(nil),               // 54: benchmarks.google_message3.Message8511
+	(*Message8512)(nil),               // 55: benchmarks.google_message3.Message8512
+	(*Message8513)(nil),               // 56: benchmarks.google_message3.Message8513
+	(*Message8514)(nil),               // 57: benchmarks.google_message3.Message8514
+	(*Message8515)(nil),               // 58: benchmarks.google_message3.Message8515
+	(*Message10155)(nil),              // 59: benchmarks.google_message3.Message10155
+	(*Message10320)(nil),              // 60: benchmarks.google_message3.Message10320
+	(*Message10322)(nil),              // 61: benchmarks.google_message3.Message10322
+	(*Message10321)(nil),              // 62: benchmarks.google_message3.Message10321
+	(*Message11988)(nil),              // 63: benchmarks.google_message3.Message11988
+	(*Message12668)(nil),              // 64: benchmarks.google_message3.Message12668
+	(*Message12825)(nil),              // 65: benchmarks.google_message3.Message12825
+	(Enum12871)(0),                    // 66: benchmarks.google_message3.Enum12871
+	(*Message16478)(nil),              // 67: benchmarks.google_message3.Message16478
+	(*Message16552)(nil),              // 68: benchmarks.google_message3.Message16552
+	(*Message16660)(nil),              // 69: benchmarks.google_message3.Message16660
+	(*Message16727)(nil),              // 70: benchmarks.google_message3.Message16727
+	(*Message16725)(nil),              // 71: benchmarks.google_message3.Message16725
+	(*Message17782)(nil),              // 72: benchmarks.google_message3.Message17782
+	(*Message22853)(nil),              // 73: benchmarks.google_message3.Message22853
+	(*Message24403)(nil),              // 74: benchmarks.google_message3.Message24403
+	(*Message27454)(nil),              // 75: benchmarks.google_message3.Message27454
+	(*Message27357)(nil),              // 76: benchmarks.google_message3.Message27357
+	(*Message27360)(nil),              // 77: benchmarks.google_message3.Message27360
+	(*Message17783)(nil),              // 78: benchmarks.google_message3.Message17783
+	(*Message17726)(nil),              // 79: benchmarks.google_message3.Message17726
+	(*Message16945)(nil),              // 80: benchmarks.google_message3.Message16945
+	(Enum16925)(0),                    // 81: benchmarks.google_message3.Enum16925
+	(*Message24317)(nil),              // 82: benchmarks.google_message3.Message24317
+	(*Message24376)(nil),              // 83: benchmarks.google_message3.Message24376
+	(*Message24345)(nil),              // 84: benchmarks.google_message3.Message24345
+	(*Message24379)(nil),              // 85: benchmarks.google_message3.Message24379
+	(*Message24391)(nil),              // 86: benchmarks.google_message3.Message24391
+	(Enum16891)(0),                    // 87: benchmarks.google_message3.Enum16891
+	(*Message0)(nil),                  // 88: benchmarks.google_message3.Message0
+	(*Message13145)(nil),              // 89: benchmarks.google_message3.Message13145
+}
+var file_datasets_google_message3_benchmark_message3_proto_depIdxs = []int32{
+	33,  // 0: benchmarks.google_message3.GoogleMessage3.field37519:type_name -> benchmarks.google_message3.Message37487
+	34,  // 1: benchmarks.google_message3.GoogleMessage3.field37520:type_name -> benchmarks.google_message3.Message36876
+	35,  // 2: benchmarks.google_message3.GoogleMessage3.field37521:type_name -> benchmarks.google_message3.Message13062
+	36,  // 3: benchmarks.google_message3.GoogleMessage3.field37522:type_name -> benchmarks.google_message3.Message952
+	37,  // 4: benchmarks.google_message3.GoogleMessage3.field37523:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	37,  // 5: benchmarks.google_message3.GoogleMessage3.field37524:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	37,  // 6: benchmarks.google_message3.GoogleMessage3.field37525:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	37,  // 7: benchmarks.google_message3.GoogleMessage3.field37526:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	37,  // 8: benchmarks.google_message3.GoogleMessage3.field37527:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	37,  // 9: benchmarks.google_message3.GoogleMessage3.field37528:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	37,  // 10: benchmarks.google_message3.GoogleMessage3.field37529:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	37,  // 11: benchmarks.google_message3.GoogleMessage3.field37530:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	37,  // 12: benchmarks.google_message3.GoogleMessage3.field37531:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	37,  // 13: benchmarks.google_message3.GoogleMessage3.field37532:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	37,  // 14: benchmarks.google_message3.GoogleMessage3.field37533:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	37,  // 15: benchmarks.google_message3.Message1327.field1369:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	38,  // 16: benchmarks.google_message3.Message1327.field1370:type_name -> benchmarks.google_message3.Message1328
+	37,  // 17: benchmarks.google_message3.Message1327.field1371:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	37,  // 18: benchmarks.google_message3.Message1327.field1372:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	39,  // 19: benchmarks.google_message3.Message3672.field3727:type_name -> benchmarks.google_message3.Enum3476
+	29,  // 20: benchmarks.google_message3.Message3672.message3673:type_name -> benchmarks.google_message3.Message3672.Message3673
+	30,  // 21: benchmarks.google_message3.Message3672.message3674:type_name -> benchmarks.google_message3.Message3672.Message3674
+	39,  // 22: benchmarks.google_message3.Message3672.field3734:type_name -> benchmarks.google_message3.Enum3476
+	37,  // 23: benchmarks.google_message3.Message3672.field3736:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	40,  // 24: benchmarks.google_message3.Message3804.field3820:type_name -> benchmarks.google_message3.Enum3805
+	41,  // 25: benchmarks.google_message3.Message3804.field3824:type_name -> benchmarks.google_message3.Enum3783
+	42,  // 26: benchmarks.google_message3.Message6849.field6910:type_name -> benchmarks.google_message3.Message6850
+	43,  // 27: benchmarks.google_message3.Message6866.field6973:type_name -> benchmarks.google_message3.Message6863
+	44,  // 28: benchmarks.google_message3.Message6870.field6991:type_name -> benchmarks.google_message3.Message6871
+	37,  // 29: benchmarks.google_message3.Message7651.field7708:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	45,  // 30: benchmarks.google_message3.Message7651.field7715:type_name -> benchmarks.google_message3.Message7547
+	45,  // 31: benchmarks.google_message3.Message7651.field7716:type_name -> benchmarks.google_message3.Message7547
+	37,  // 32: benchmarks.google_message3.Message7651.field7717:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	46,  // 33: benchmarks.google_message3.Message7651.field7720:type_name -> benchmarks.google_message3.Message7648
+	37,  // 34: benchmarks.google_message3.Message7651.field7725:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	47,  // 35: benchmarks.google_message3.Message7651.field7726:type_name -> benchmarks.google_message3.UnusedEnum
+	48,  // 36: benchmarks.google_message3.Message7651.field7727:type_name -> benchmarks.google_message3.Enum7654
+	37,  // 37: benchmarks.google_message3.Message7651.field7729:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	49,  // 38: benchmarks.google_message3.Message7864.field7868:type_name -> benchmarks.google_message3.Message7865
+	49,  // 39: benchmarks.google_message3.Message7864.field7869:type_name -> benchmarks.google_message3.Message7865
+	49,  // 40: benchmarks.google_message3.Message7864.field7870:type_name -> benchmarks.google_message3.Message7865
+	37,  // 41: benchmarks.google_message3.Message7864.field7871:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	50,  // 42: benchmarks.google_message3.Message7929.field7950:type_name -> benchmarks.google_message3.Message7919
+	37,  // 43: benchmarks.google_message3.Message7929.field7951:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	51,  // 44: benchmarks.google_message3.Message7929.field7952:type_name -> benchmarks.google_message3.Message7920
+	52,  // 45: benchmarks.google_message3.Message7929.field7953:type_name -> benchmarks.google_message3.Message7921
+	53,  // 46: benchmarks.google_message3.Message7929.field7954:type_name -> benchmarks.google_message3.Message7928
+	37,  // 47: benchmarks.google_message3.Message7929.field7959:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	54,  // 48: benchmarks.google_message3.Message8508.field8517:type_name -> benchmarks.google_message3.Message8511
+	55,  // 49: benchmarks.google_message3.Message8508.field8518:type_name -> benchmarks.google_message3.Message8512
+	56,  // 50: benchmarks.google_message3.Message8508.field8519:type_name -> benchmarks.google_message3.Message8513
+	57,  // 51: benchmarks.google_message3.Message8508.field8521:type_name -> benchmarks.google_message3.Message8514
+	37,  // 52: benchmarks.google_message3.Message8508.field8522:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	58,  // 53: benchmarks.google_message3.Message8508.field8523:type_name -> benchmarks.google_message3.Message8515
+	37,  // 54: benchmarks.google_message3.Message8508.field8524:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	59,  // 55: benchmarks.google_message3.Message10177.field10270:type_name -> benchmarks.google_message3.Message10155
+	60,  // 56: benchmarks.google_message3.Message10323.field10360:type_name -> benchmarks.google_message3.Message10320
+	61,  // 57: benchmarks.google_message3.Message10324.field10362:type_name -> benchmarks.google_message3.Message10322
+	62,  // 58: benchmarks.google_message3.Message10324.field10363:type_name -> benchmarks.google_message3.Message10321
+	63,  // 59: benchmarks.google_message3.Message11990.field12030:type_name -> benchmarks.google_message3.Message11988
+	64,  // 60: benchmarks.google_message3.Message12691.field12715:type_name -> benchmarks.google_message3.Message12668
+	18,  // 61: benchmarks.google_message3.Message12870.field12888:type_name -> benchmarks.google_message3.Message12870
+	65,  // 62: benchmarks.google_message3.Message12870.field12894:type_name -> benchmarks.google_message3.Message12825
+	66,  // 63: benchmarks.google_message3.Message12870.field12897:type_name -> benchmarks.google_message3.Enum12871
+	37,  // 64: benchmarks.google_message3.Message16507.field16521:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	37,  // 65: benchmarks.google_message3.Message16507.field16522:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	37,  // 66: benchmarks.google_message3.Message16507.field16523:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	37,  // 67: benchmarks.google_message3.Message16507.field16527:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	67,  // 68: benchmarks.google_message3.Message16507.field16531:type_name -> benchmarks.google_message3.Message16478
+	68,  // 69: benchmarks.google_message3.Message16564.field16568:type_name -> benchmarks.google_message3.Message16552
+	69,  // 70: benchmarks.google_message3.Message16661.field16671:type_name -> benchmarks.google_message3.Message16660
+	70,  // 71: benchmarks.google_message3.Message16746.field16806:type_name -> benchmarks.google_message3.Message16727
+	71,  // 72: benchmarks.google_message3.Message16746.field16809:type_name -> benchmarks.google_message3.Message16725
+	31,  // 73: benchmarks.google_message3.Message17786.message17787:type_name -> benchmarks.google_message3.Message17786.Message17787
+	72,  // 74: benchmarks.google_message3.Message17786.field18175:type_name -> benchmarks.google_message3.Message17782
+	73,  // 75: benchmarks.google_message3.Message22857.field22874:type_name -> benchmarks.google_message3.Message22853
+	32,  // 76: benchmarks.google_message3.Message24404.message24405:type_name -> benchmarks.google_message3.Message24404.Message24405
+	74,  // 77: benchmarks.google_message3.Message24404.field24684:type_name -> benchmarks.google_message3.Message24403
+	37,  // 78: benchmarks.google_message3.Message27300.field27302:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	75,  // 79: benchmarks.google_message3.Message27453.field27464:type_name -> benchmarks.google_message3.Message27454
+	76,  // 80: benchmarks.google_message3.Message27453.field27470:type_name -> benchmarks.google_message3.Message27357
+	77,  // 81: benchmarks.google_message3.Message27453.field27471:type_name -> benchmarks.google_message3.Message27360
+	37,  // 82: benchmarks.google_message3.Message27453.field27477:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	37,  // 83: benchmarks.google_message3.Message27453.field27481:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	39,  // 84: benchmarks.google_message3.Message3672.Message3673.field3738:type_name -> benchmarks.google_message3.Enum3476
+	39,  // 85: benchmarks.google_message3.Message3672.Message3674.field3740:type_name -> benchmarks.google_message3.Enum3476
+	78,  // 86: benchmarks.google_message3.Message17786.Message17787.field18179:type_name -> benchmarks.google_message3.Message17783
+	37,  // 87: benchmarks.google_message3.Message17786.Message17787.field18180:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	37,  // 88: benchmarks.google_message3.Message17786.Message17787.field18181:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	37,  // 89: benchmarks.google_message3.Message17786.Message17787.field18182:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	37,  // 90: benchmarks.google_message3.Message17786.Message17787.field18183:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	79,  // 91: benchmarks.google_message3.Message17786.Message17787.field18184:type_name -> benchmarks.google_message3.Message17726
+	37,  // 92: benchmarks.google_message3.Message17786.Message17787.field18185:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	80,  // 93: benchmarks.google_message3.Message17786.Message17787.field18186:type_name -> benchmarks.google_message3.Message16945
+	37,  // 94: benchmarks.google_message3.Message17786.Message17787.field18187:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	37,  // 95: benchmarks.google_message3.Message17786.Message17787.field18188:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	37,  // 96: benchmarks.google_message3.Message17786.Message17787.field18189:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	37,  // 97: benchmarks.google_message3.Message17786.Message17787.field18190:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	37,  // 98: benchmarks.google_message3.Message17786.Message17787.field18191:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	37,  // 99: benchmarks.google_message3.Message17786.Message17787.field18192:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	37,  // 100: benchmarks.google_message3.Message17786.Message17787.field18193:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	37,  // 101: benchmarks.google_message3.Message17786.Message17787.field18194:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	37,  // 102: benchmarks.google_message3.Message17786.Message17787.field18195:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	81,  // 103: benchmarks.google_message3.Message17786.Message17787.field18196:type_name -> benchmarks.google_message3.Enum16925
+	47,  // 104: benchmarks.google_message3.Message17786.Message17787.field18198:type_name -> benchmarks.google_message3.UnusedEnum
+	37,  // 105: benchmarks.google_message3.Message17786.Message17787.field18199:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	82,  // 106: benchmarks.google_message3.Message24404.Message24405.field24688:type_name -> benchmarks.google_message3.Message24317
+	37,  // 107: benchmarks.google_message3.Message24404.Message24405.field24689:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	83,  // 108: benchmarks.google_message3.Message24404.Message24405.field24690:type_name -> benchmarks.google_message3.Message24376
+	84,  // 109: benchmarks.google_message3.Message24404.Message24405.field24691:type_name -> benchmarks.google_message3.Message24345
+	37,  // 110: benchmarks.google_message3.Message24404.Message24405.field24692:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	85,  // 111: benchmarks.google_message3.Message24404.Message24405.field24693:type_name -> benchmarks.google_message3.Message24379
+	37,  // 112: benchmarks.google_message3.Message24404.Message24405.field24694:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	37,  // 113: benchmarks.google_message3.Message24404.Message24405.field24695:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	86,  // 114: benchmarks.google_message3.Message24404.Message24405.field24696:type_name -> benchmarks.google_message3.Message24391
+	37,  // 115: benchmarks.google_message3.Message24404.Message24405.field24697:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	37,  // 116: benchmarks.google_message3.Message24404.Message24405.field24698:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	37,  // 117: benchmarks.google_message3.Message24404.Message24405.field24699:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	37,  // 118: benchmarks.google_message3.Message24404.Message24405.field24700:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	37,  // 119: benchmarks.google_message3.Message24404.Message24405.field24701:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	81,  // 120: benchmarks.google_message3.Message24404.Message24405.field24702:type_name -> benchmarks.google_message3.Enum16925
+	87,  // 121: benchmarks.google_message3.Message24404.Message24405.field24705:type_name -> benchmarks.google_message3.Enum16891
+	37,  // 122: benchmarks.google_message3.Message24404.Message24405.field24706:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	47,  // 123: benchmarks.google_message3.Message24404.Message24405.field24711:type_name -> benchmarks.google_message3.UnusedEnum
+	47,  // 124: benchmarks.google_message3.Message24404.Message24405.field24713:type_name -> benchmarks.google_message3.UnusedEnum
+	80,  // 125: benchmarks.google_message3.field17026:extendee -> benchmarks.google_message3.Message16945
+	80,  // 126: benchmarks.google_message3.field17027:extendee -> benchmarks.google_message3.Message16945
+	80,  // 127: benchmarks.google_message3.field17031:extendee -> benchmarks.google_message3.Message16945
+	80,  // 128: benchmarks.google_message3.field17032:extendee -> benchmarks.google_message3.Message16945
+	80,  // 129: benchmarks.google_message3.field17038:extendee -> benchmarks.google_message3.Message16945
+	80,  // 130: benchmarks.google_message3.field17039:extendee -> benchmarks.google_message3.Message16945
+	80,  // 131: benchmarks.google_message3.field17042:extendee -> benchmarks.google_message3.Message16945
+	80,  // 132: benchmarks.google_message3.field17043:extendee -> benchmarks.google_message3.Message16945
+	80,  // 133: benchmarks.google_message3.field17044:extendee -> benchmarks.google_message3.Message16945
+	80,  // 134: benchmarks.google_message3.field17048:extendee -> benchmarks.google_message3.Message16945
+	80,  // 135: benchmarks.google_message3.field17049:extendee -> benchmarks.google_message3.Message16945
+	80,  // 136: benchmarks.google_message3.field17052:extendee -> benchmarks.google_message3.Message16945
+	80,  // 137: benchmarks.google_message3.field17053:extendee -> benchmarks.google_message3.Message16945
+	80,  // 138: benchmarks.google_message3.field17056:extendee -> benchmarks.google_message3.Message16945
+	80,  // 139: benchmarks.google_message3.field17057:extendee -> benchmarks.google_message3.Message16945
+	80,  // 140: benchmarks.google_message3.field17060:extendee -> benchmarks.google_message3.Message16945
+	80,  // 141: benchmarks.google_message3.field17073:extendee -> benchmarks.google_message3.Message16945
+	80,  // 142: benchmarks.google_message3.field17076:extendee -> benchmarks.google_message3.Message16945
+	80,  // 143: benchmarks.google_message3.field17078:extendee -> benchmarks.google_message3.Message16945
+	80,  // 144: benchmarks.google_message3.field17082:extendee -> benchmarks.google_message3.Message16945
+	80,  // 145: benchmarks.google_message3.field17091:extendee -> benchmarks.google_message3.Message16945
+	80,  // 146: benchmarks.google_message3.field17098:extendee -> benchmarks.google_message3.Message16945
+	80,  // 147: benchmarks.google_message3.field17101:extendee -> benchmarks.google_message3.Message16945
+	80,  // 148: benchmarks.google_message3.field17102:extendee -> benchmarks.google_message3.Message16945
+	80,  // 149: benchmarks.google_message3.field17107:extendee -> benchmarks.google_message3.Message16945
+	80,  // 150: benchmarks.google_message3.field17133:extendee -> benchmarks.google_message3.Message16945
+	80,  // 151: benchmarks.google_message3.field17134:extendee -> benchmarks.google_message3.Message16945
+	80,  // 152: benchmarks.google_message3.field17160:extendee -> benchmarks.google_message3.Message16945
+	80,  // 153: benchmarks.google_message3.field17168:extendee -> benchmarks.google_message3.Message16945
+	80,  // 154: benchmarks.google_message3.field17170:extendee -> benchmarks.google_message3.Message16945
+	80,  // 155: benchmarks.google_message3.field17172:extendee -> benchmarks.google_message3.Message16945
+	80,  // 156: benchmarks.google_message3.field17174:extendee -> benchmarks.google_message3.Message16945
+	80,  // 157: benchmarks.google_message3.field17175:extendee -> benchmarks.google_message3.Message16945
+	80,  // 158: benchmarks.google_message3.field17178:extendee -> benchmarks.google_message3.Message16945
+	80,  // 159: benchmarks.google_message3.field17185:extendee -> benchmarks.google_message3.Message16945
+	80,  // 160: benchmarks.google_message3.field17207:extendee -> benchmarks.google_message3.Message16945
+	80,  // 161: benchmarks.google_message3.field17238:extendee -> benchmarks.google_message3.Message16945
+	80,  // 162: benchmarks.google_message3.field17289:extendee -> benchmarks.google_message3.Message16945
+	80,  // 163: benchmarks.google_message3.field17290:extendee -> benchmarks.google_message3.Message16945
+	80,  // 164: benchmarks.google_message3.field17296:extendee -> benchmarks.google_message3.Message16945
+	80,  // 165: benchmarks.google_message3.field17298:extendee -> benchmarks.google_message3.Message16945
+	80,  // 166: benchmarks.google_message3.field17301:extendee -> benchmarks.google_message3.Message16945
+	80,  // 167: benchmarks.google_message3.field17412:extendee -> benchmarks.google_message3.Message16945
+	80,  // 168: benchmarks.google_message3.field17438:extendee -> benchmarks.google_message3.Message16945
+	80,  // 169: benchmarks.google_message3.field17458:extendee -> benchmarks.google_message3.Message16945
+	80,  // 170: benchmarks.google_message3.field17460:extendee -> benchmarks.google_message3.Message16945
+	80,  // 171: benchmarks.google_message3.field17466:extendee -> benchmarks.google_message3.Message16945
+	80,  // 172: benchmarks.google_message3.field17617:extendee -> benchmarks.google_message3.Message16945
+	80,  // 173: benchmarks.google_message3.field17618:extendee -> benchmarks.google_message3.Message16945
+	88,  // 174: benchmarks.google_message3.Message1327.field1373:extendee -> benchmarks.google_message3.Message0
+	88,  // 175: benchmarks.google_message3.Message3672.field3737:extendee -> benchmarks.google_message3.Message0
+	88,  // 176: benchmarks.google_message3.Message3804.field3825:extendee -> benchmarks.google_message3.Message0
+	88,  // 177: benchmarks.google_message3.Message6849.field6911:extendee -> benchmarks.google_message3.Message0
+	88,  // 178: benchmarks.google_message3.Message6866.field6974:extendee -> benchmarks.google_message3.Message0
+	88,  // 179: benchmarks.google_message3.Message6870.field6992:extendee -> benchmarks.google_message3.Message0
+	88,  // 180: benchmarks.google_message3.Message7651.field7730:extendee -> benchmarks.google_message3.Message0
+	88,  // 181: benchmarks.google_message3.Message7864.field7872:extendee -> benchmarks.google_message3.Message0
+	88,  // 182: benchmarks.google_message3.Message7929.field7962:extendee -> benchmarks.google_message3.Message0
+	88,  // 183: benchmarks.google_message3.Message8508.field8534:extendee -> benchmarks.google_message3.Message0
+	88,  // 184: benchmarks.google_message3.Message9122.field9134:extendee -> benchmarks.google_message3.Message0
+	88,  // 185: benchmarks.google_message3.Message10177.field10271:extendee -> benchmarks.google_message3.Message0
+	59,  // 186: benchmarks.google_message3.Message10278.field10289:extendee -> benchmarks.google_message3.Message10155
+	59,  // 187: benchmarks.google_message3.Message10323.field10361:extendee -> benchmarks.google_message3.Message10155
+	59,  // 188: benchmarks.google_message3.Message10324.field10364:extendee -> benchmarks.google_message3.Message10155
+	88,  // 189: benchmarks.google_message3.Message11990.field12031:extendee -> benchmarks.google_message3.Message0
+	88,  // 190: benchmarks.google_message3.Message12691.field12716:extendee -> benchmarks.google_message3.Message0
+	88,  // 191: benchmarks.google_message3.Message12870.field12899:extendee -> benchmarks.google_message3.Message0
+	89,  // 192: benchmarks.google_message3.Message13154.field13166:extendee -> benchmarks.google_message3.Message13145
+	88,  // 193: benchmarks.google_message3.Message16507.field16542:extendee -> benchmarks.google_message3.Message0
+	88,  // 194: benchmarks.google_message3.Message16564.field16569:extendee -> benchmarks.google_message3.Message0
+	88,  // 195: benchmarks.google_message3.Message16661.field16673:extendee -> benchmarks.google_message3.Message0
+	88,  // 196: benchmarks.google_message3.Message16746.field16810:extendee -> benchmarks.google_message3.Message0
+	88,  // 197: benchmarks.google_message3.Message17786.field18176:extendee -> benchmarks.google_message3.Message0
+	59,  // 198: benchmarks.google_message3.Message22857.field22875:extendee -> benchmarks.google_message3.Message10155
+	88,  // 199: benchmarks.google_message3.Message24404.field24685:extendee -> benchmarks.google_message3.Message0
+	88,  // 200: benchmarks.google_message3.Message27300.field27304:extendee -> benchmarks.google_message3.Message0
+	88,  // 201: benchmarks.google_message3.Message27453.field27482:extendee -> benchmarks.google_message3.Message0
+	88,  // 202: benchmarks.google_message3.field17031:type_name -> benchmarks.google_message3.Message0
+	88,  // 203: benchmarks.google_message3.field17032:type_name -> benchmarks.google_message3.Message0
+	88,  // 204: benchmarks.google_message3.field17038:type_name -> benchmarks.google_message3.Message0
+	88,  // 205: benchmarks.google_message3.field17039:type_name -> benchmarks.google_message3.Message0
+	88,  // 206: benchmarks.google_message3.field17042:type_name -> benchmarks.google_message3.Message0
+	88,  // 207: benchmarks.google_message3.field17052:type_name -> benchmarks.google_message3.Message0
+	88,  // 208: benchmarks.google_message3.field17053:type_name -> benchmarks.google_message3.Message0
+	88,  // 209: benchmarks.google_message3.field17060:type_name -> benchmarks.google_message3.Message0
+	88,  // 210: benchmarks.google_message3.field17076:type_name -> benchmarks.google_message3.Message0
+	88,  // 211: benchmarks.google_message3.field17082:type_name -> benchmarks.google_message3.Message0
+	88,  // 212: benchmarks.google_message3.field17091:type_name -> benchmarks.google_message3.Message0
+	88,  // 213: benchmarks.google_message3.field17098:type_name -> benchmarks.google_message3.Message0
+	88,  // 214: benchmarks.google_message3.field17101:type_name -> benchmarks.google_message3.Message0
+	88,  // 215: benchmarks.google_message3.field17172:type_name -> benchmarks.google_message3.Message0
+	88,  // 216: benchmarks.google_message3.field17175:type_name -> benchmarks.google_message3.Message0
+	88,  // 217: benchmarks.google_message3.field17178:type_name -> benchmarks.google_message3.Message0
+	88,  // 218: benchmarks.google_message3.field17185:type_name -> benchmarks.google_message3.Message0
+	88,  // 219: benchmarks.google_message3.field17238:type_name -> benchmarks.google_message3.Message0
+	88,  // 220: benchmarks.google_message3.field17289:type_name -> benchmarks.google_message3.Message0
+	88,  // 221: benchmarks.google_message3.field17290:type_name -> benchmarks.google_message3.Message0
+	88,  // 222: benchmarks.google_message3.field17296:type_name -> benchmarks.google_message3.Message0
+	88,  // 223: benchmarks.google_message3.field17301:type_name -> benchmarks.google_message3.Message0
+	88,  // 224: benchmarks.google_message3.field17412:type_name -> benchmarks.google_message3.Message0
+	88,  // 225: benchmarks.google_message3.field17438:type_name -> benchmarks.google_message3.Message0
+	88,  // 226: benchmarks.google_message3.field17458:type_name -> benchmarks.google_message3.Message0
+	88,  // 227: benchmarks.google_message3.field17617:type_name -> benchmarks.google_message3.Message0
+	1,   // 228: benchmarks.google_message3.Message1327.field1373:type_name -> benchmarks.google_message3.Message1327
+	2,   // 229: benchmarks.google_message3.Message3672.field3737:type_name -> benchmarks.google_message3.Message3672
+	3,   // 230: benchmarks.google_message3.Message3804.field3825:type_name -> benchmarks.google_message3.Message3804
+	4,   // 231: benchmarks.google_message3.Message6849.field6911:type_name -> benchmarks.google_message3.Message6849
+	5,   // 232: benchmarks.google_message3.Message6866.field6974:type_name -> benchmarks.google_message3.Message6866
+	6,   // 233: benchmarks.google_message3.Message6870.field6992:type_name -> benchmarks.google_message3.Message6870
+	7,   // 234: benchmarks.google_message3.Message7651.field7730:type_name -> benchmarks.google_message3.Message7651
+	8,   // 235: benchmarks.google_message3.Message7864.field7872:type_name -> benchmarks.google_message3.Message7864
+	9,   // 236: benchmarks.google_message3.Message7929.field7962:type_name -> benchmarks.google_message3.Message7929
+	10,  // 237: benchmarks.google_message3.Message8508.field8534:type_name -> benchmarks.google_message3.Message8508
+	11,  // 238: benchmarks.google_message3.Message9122.field9134:type_name -> benchmarks.google_message3.Message9122
+	12,  // 239: benchmarks.google_message3.Message10177.field10271:type_name -> benchmarks.google_message3.Message10177
+	13,  // 240: benchmarks.google_message3.Message10278.field10289:type_name -> benchmarks.google_message3.Message10278
+	14,  // 241: benchmarks.google_message3.Message10323.field10361:type_name -> benchmarks.google_message3.Message10323
+	15,  // 242: benchmarks.google_message3.Message10324.field10364:type_name -> benchmarks.google_message3.Message10324
+	16,  // 243: benchmarks.google_message3.Message11990.field12031:type_name -> benchmarks.google_message3.Message11990
+	17,  // 244: benchmarks.google_message3.Message12691.field12716:type_name -> benchmarks.google_message3.Message12691
+	18,  // 245: benchmarks.google_message3.Message12870.field12899:type_name -> benchmarks.google_message3.Message12870
+	19,  // 246: benchmarks.google_message3.Message13154.field13166:type_name -> benchmarks.google_message3.Message13154
+	20,  // 247: benchmarks.google_message3.Message16507.field16542:type_name -> benchmarks.google_message3.Message16507
+	21,  // 248: benchmarks.google_message3.Message16564.field16569:type_name -> benchmarks.google_message3.Message16564
+	22,  // 249: benchmarks.google_message3.Message16661.field16673:type_name -> benchmarks.google_message3.Message16661
+	23,  // 250: benchmarks.google_message3.Message16746.field16810:type_name -> benchmarks.google_message3.Message16746
+	24,  // 251: benchmarks.google_message3.Message17786.field18176:type_name -> benchmarks.google_message3.Message17786
+	25,  // 252: benchmarks.google_message3.Message22857.field22875:type_name -> benchmarks.google_message3.Message22857
+	26,  // 253: benchmarks.google_message3.Message24404.field24685:type_name -> benchmarks.google_message3.Message24404
+	27,  // 254: benchmarks.google_message3.Message27300.field27304:type_name -> benchmarks.google_message3.Message27300
+	28,  // 255: benchmarks.google_message3.Message27453.field27482:type_name -> benchmarks.google_message3.Message27453
+	256, // [256:256] is the sub-list for method output_type
+	256, // [256:256] is the sub-list for method input_type
+	202, // [202:256] is the sub-list for extension type_name
+	125, // [125:202] is the sub-list for extension extendee
+	0,   // [0:125] is the sub-list for field type_name
+}
+
+func init() { file_datasets_google_message3_benchmark_message3_proto_init() }
+func file_datasets_google_message3_benchmark_message3_proto_init() {
+	if File_datasets_google_message3_benchmark_message3_proto != nil {
+		return
+	}
+	file_datasets_google_message3_benchmark_message3_1_proto_init()
+	file_datasets_google_message3_benchmark_message3_2_proto_init()
+	file_datasets_google_message3_benchmark_message3_3_proto_init()
+	file_datasets_google_message3_benchmark_message3_4_proto_init()
+	file_datasets_google_message3_benchmark_message3_5_proto_init()
+	file_datasets_google_message3_benchmark_message3_7_proto_init()
+	file_datasets_google_message3_benchmark_message3_8_proto_init()
+	if !protoimpl.UnsafeEnabled {
+		file_datasets_google_message3_benchmark_message3_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GoogleMessage3); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message1327); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message3672); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message3804); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6849); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6866); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6870); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message7651); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message7864); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message7929); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8508); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message9122); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message10177); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message10278); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message10323); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message10324); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message11990); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12691); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12870); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message13154); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message16507); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message16564); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message16661); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message16746); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message17786); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message22857); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message24404); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message27300); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message27453); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message3672_Message3673); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message3672_Message3674); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message17786_Message17787); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message24404_Message24405); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_datasets_google_message3_benchmark_message3_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   33,
+			NumExtensions: 77,
+			NumServices:   0,
+		},
+		GoTypes:           file_datasets_google_message3_benchmark_message3_proto_goTypes,
+		DependencyIndexes: file_datasets_google_message3_benchmark_message3_proto_depIdxs,
+		MessageInfos:      file_datasets_google_message3_benchmark_message3_proto_msgTypes,
+		ExtensionInfos:    file_datasets_google_message3_benchmark_message3_proto_extTypes,
+	}.Build()
+	File_datasets_google_message3_benchmark_message3_proto = out.File
+	file_datasets_google_message3_benchmark_message3_proto_rawDesc = nil
+	file_datasets_google_message3_benchmark_message3_proto_goTypes = nil
+	file_datasets_google_message3_benchmark_message3_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3/benchmark_message3_1.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3/benchmark_message3_1.pb.go
new file mode 100644
index 000000000..131f7a650
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3/benchmark_message3_1.pb.go
@@ -0,0 +1,9202 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// LINT: ALLOW_GROUPS
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: datasets/google_message3/benchmark_message3_1.proto
+
+package google_message3
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoiface "google.golang.org/protobuf/runtime/protoiface"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type Message34390 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field34452 []*Message34387 `protobuf:"bytes,1,rep,name=field34452" json:"field34452,omitempty"`
+}
+
+func (x *Message34390) Reset() {
+	*x = Message34390{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message34390) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message34390) ProtoMessage() {}
+
+func (x *Message34390) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message34390.ProtoReflect.Descriptor instead.
+func (*Message34390) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Message34390) GetField34452() []*Message34387 {
+	if x != nil {
+		return x.Field34452
+	}
+	return nil
+}
+
+type Message34624 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field34683 *Message34621 `protobuf:"bytes,1,opt,name=field34683" json:"field34683,omitempty"`
+	Field34684 *Message34621 `protobuf:"bytes,2,opt,name=field34684" json:"field34684,omitempty"`
+}
+
+func (x *Message34624) Reset() {
+	*x = Message34624{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message34624) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message34624) ProtoMessage() {}
+
+func (x *Message34624) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message34624.ProtoReflect.Descriptor instead.
+func (*Message34624) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *Message34624) GetField34683() *Message34621 {
+	if x != nil {
+		return x.Field34683
+	}
+	return nil
+}
+
+func (x *Message34624) GetField34684() *Message34621 {
+	if x != nil {
+		return x.Field34684
+	}
+	return nil
+}
+
+type Message34791 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field34793   *uint64                      `protobuf:"fixed64,1,opt,name=field34793" json:"field34793,omitempty"`
+	Message34792 []*Message34791_Message34792 `protobuf:"group,2,rep,name=Message34792,json=message34792" json:"message34792,omitempty"`
+	Field34795   *int32                       `protobuf:"varint,5,opt,name=field34795" json:"field34795,omitempty"`
+	Field34796   *int32                       `protobuf:"varint,6,opt,name=field34796" json:"field34796,omitempty"`
+	Field34797   *int32                       `protobuf:"varint,7,opt,name=field34797" json:"field34797,omitempty"`
+	Field34798   *int32                       `protobuf:"varint,8,opt,name=field34798" json:"field34798,omitempty"`
+	Field34799   *int32                       `protobuf:"varint,9,opt,name=field34799" json:"field34799,omitempty"`
+	Field34800   *int32                       `protobuf:"varint,10,opt,name=field34800" json:"field34800,omitempty"`
+	Field34801   *bool                        `protobuf:"varint,11,opt,name=field34801" json:"field34801,omitempty"`
+	Field34802   *float32                     `protobuf:"fixed32,12,opt,name=field34802" json:"field34802,omitempty"`
+	Field34803   *int32                       `protobuf:"varint,13,opt,name=field34803" json:"field34803,omitempty"`
+	Field34804   *string                      `protobuf:"bytes,14,opt,name=field34804" json:"field34804,omitempty"`
+	Field34805   *int64                       `protobuf:"varint,15,opt,name=field34805" json:"field34805,omitempty"`
+	Field34806   []uint64                     `protobuf:"fixed64,17,rep,packed,name=field34806" json:"field34806,omitempty"`
+}
+
+func (x *Message34791) Reset() {
+	*x = Message34791{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message34791) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message34791) ProtoMessage() {}
+
+func (x *Message34791) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message34791.ProtoReflect.Descriptor instead.
+func (*Message34791) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *Message34791) GetField34793() uint64 {
+	if x != nil && x.Field34793 != nil {
+		return *x.Field34793
+	}
+	return 0
+}
+
+func (x *Message34791) GetMessage34792() []*Message34791_Message34792 {
+	if x != nil {
+		return x.Message34792
+	}
+	return nil
+}
+
+func (x *Message34791) GetField34795() int32 {
+	if x != nil && x.Field34795 != nil {
+		return *x.Field34795
+	}
+	return 0
+}
+
+func (x *Message34791) GetField34796() int32 {
+	if x != nil && x.Field34796 != nil {
+		return *x.Field34796
+	}
+	return 0
+}
+
+func (x *Message34791) GetField34797() int32 {
+	if x != nil && x.Field34797 != nil {
+		return *x.Field34797
+	}
+	return 0
+}
+
+func (x *Message34791) GetField34798() int32 {
+	if x != nil && x.Field34798 != nil {
+		return *x.Field34798
+	}
+	return 0
+}
+
+func (x *Message34791) GetField34799() int32 {
+	if x != nil && x.Field34799 != nil {
+		return *x.Field34799
+	}
+	return 0
+}
+
+func (x *Message34791) GetField34800() int32 {
+	if x != nil && x.Field34800 != nil {
+		return *x.Field34800
+	}
+	return 0
+}
+
+func (x *Message34791) GetField34801() bool {
+	if x != nil && x.Field34801 != nil {
+		return *x.Field34801
+	}
+	return false
+}
+
+func (x *Message34791) GetField34802() float32 {
+	if x != nil && x.Field34802 != nil {
+		return *x.Field34802
+	}
+	return 0
+}
+
+func (x *Message34791) GetField34803() int32 {
+	if x != nil && x.Field34803 != nil {
+		return *x.Field34803
+	}
+	return 0
+}
+
+func (x *Message34791) GetField34804() string {
+	if x != nil && x.Field34804 != nil {
+		return *x.Field34804
+	}
+	return ""
+}
+
+func (x *Message34791) GetField34805() int64 {
+	if x != nil && x.Field34805 != nil {
+		return *x.Field34805
+	}
+	return 0
+}
+
+func (x *Message34791) GetField34806() []uint64 {
+	if x != nil {
+		return x.Field34806
+	}
+	return nil
+}
+
+type Message35483 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field35499 *int32              `protobuf:"varint,1,opt,name=field35499" json:"field35499,omitempty"`
+	Field35500 *string             `protobuf:"bytes,2,opt,name=field35500" json:"field35500,omitempty"`
+	Field35501 *string             `protobuf:"bytes,3,opt,name=field35501" json:"field35501,omitempty"`
+	Field35502 *string             `protobuf:"bytes,4,opt,name=field35502" json:"field35502,omitempty"`
+	Field35503 []*Message35476     `protobuf:"bytes,5,rep,name=field35503" json:"field35503,omitempty"`
+	Field35504 *UnusedEmptyMessage `protobuf:"bytes,6,opt,name=field35504" json:"field35504,omitempty"`
+}
+
+func (x *Message35483) Reset() {
+	*x = Message35483{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message35483) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message35483) ProtoMessage() {}
+
+func (x *Message35483) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message35483.ProtoReflect.Descriptor instead.
+func (*Message35483) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *Message35483) GetField35499() int32 {
+	if x != nil && x.Field35499 != nil {
+		return *x.Field35499
+	}
+	return 0
+}
+
+func (x *Message35483) GetField35500() string {
+	if x != nil && x.Field35500 != nil {
+		return *x.Field35500
+	}
+	return ""
+}
+
+func (x *Message35483) GetField35501() string {
+	if x != nil && x.Field35501 != nil {
+		return *x.Field35501
+	}
+	return ""
+}
+
+func (x *Message35483) GetField35502() string {
+	if x != nil && x.Field35502 != nil {
+		return *x.Field35502
+	}
+	return ""
+}
+
+func (x *Message35483) GetField35503() []*Message35476 {
+	if x != nil {
+		return x.Field35503
+	}
+	return nil
+}
+
+func (x *Message35483) GetField35504() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field35504
+	}
+	return nil
+}
+
+type Message35807 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field35810 *int32 `protobuf:"varint,1,opt,name=field35810" json:"field35810,omitempty"`
+	Field35811 *int32 `protobuf:"varint,2,opt,name=field35811" json:"field35811,omitempty"`
+	Field35812 *int32 `protobuf:"varint,3,opt,name=field35812" json:"field35812,omitempty"`
+	Field35813 *int32 `protobuf:"varint,4,opt,name=field35813" json:"field35813,omitempty"`
+	Field35814 *int32 `protobuf:"varint,5,opt,name=field35814" json:"field35814,omitempty"`
+	Field35815 *int32 `protobuf:"varint,6,opt,name=field35815" json:"field35815,omitempty"`
+	Field35816 *int32 `protobuf:"varint,7,opt,name=field35816" json:"field35816,omitempty"`
+	Field35817 *int32 `protobuf:"varint,8,opt,name=field35817" json:"field35817,omitempty"`
+}
+
+func (x *Message35807) Reset() {
+	*x = Message35807{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message35807) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message35807) ProtoMessage() {}
+
+func (x *Message35807) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message35807.ProtoReflect.Descriptor instead.
+func (*Message35807) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *Message35807) GetField35810() int32 {
+	if x != nil && x.Field35810 != nil {
+		return *x.Field35810
+	}
+	return 0
+}
+
+func (x *Message35807) GetField35811() int32 {
+	if x != nil && x.Field35811 != nil {
+		return *x.Field35811
+	}
+	return 0
+}
+
+func (x *Message35807) GetField35812() int32 {
+	if x != nil && x.Field35812 != nil {
+		return *x.Field35812
+	}
+	return 0
+}
+
+func (x *Message35807) GetField35813() int32 {
+	if x != nil && x.Field35813 != nil {
+		return *x.Field35813
+	}
+	return 0
+}
+
+func (x *Message35807) GetField35814() int32 {
+	if x != nil && x.Field35814 != nil {
+		return *x.Field35814
+	}
+	return 0
+}
+
+func (x *Message35807) GetField35815() int32 {
+	if x != nil && x.Field35815 != nil {
+		return *x.Field35815
+	}
+	return 0
+}
+
+func (x *Message35807) GetField35816() int32 {
+	if x != nil && x.Field35816 != nil {
+		return *x.Field35816
+	}
+	return 0
+}
+
+func (x *Message35807) GetField35817() int32 {
+	if x != nil && x.Field35817 != nil {
+		return *x.Field35817
+	}
+	return 0
+}
+
+type Message37487 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field37501 []byte `protobuf:"bytes,2,opt,name=field37501" json:"field37501,omitempty"`
+	Field37502 *bool  `protobuf:"varint,3,opt,name=field37502" json:"field37502,omitempty"`
+}
+
+func (x *Message37487) Reset() {
+	*x = Message37487{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[5]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message37487) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message37487) ProtoMessage() {}
+
+func (x *Message37487) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[5]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message37487.ProtoReflect.Descriptor instead.
+func (*Message37487) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *Message37487) GetField37501() []byte {
+	if x != nil {
+		return x.Field37501
+	}
+	return nil
+}
+
+func (x *Message37487) GetField37502() bool {
+	if x != nil && x.Field37502 != nil {
+		return *x.Field37502
+	}
+	return false
+}
+
+type Message13062 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field13075 *int64  `protobuf:"varint,1,opt,name=field13075" json:"field13075,omitempty"`
+	Field13076 *string `protobuf:"bytes,2,opt,name=field13076" json:"field13076,omitempty"`
+	Field13077 *int32  `protobuf:"varint,3,opt,name=field13077" json:"field13077,omitempty"`
+	Field13078 *string `protobuf:"bytes,4,opt,name=field13078" json:"field13078,omitempty"`
+	Field13079 *int32  `protobuf:"varint,5,opt,name=field13079" json:"field13079,omitempty"`
+}
+
+func (x *Message13062) Reset() {
+	*x = Message13062{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[6]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message13062) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message13062) ProtoMessage() {}
+
+func (x *Message13062) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[6]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message13062.ProtoReflect.Descriptor instead.
+func (*Message13062) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *Message13062) GetField13075() int64 {
+	if x != nil && x.Field13075 != nil {
+		return *x.Field13075
+	}
+	return 0
+}
+
+func (x *Message13062) GetField13076() string {
+	if x != nil && x.Field13076 != nil {
+		return *x.Field13076
+	}
+	return ""
+}
+
+func (x *Message13062) GetField13077() int32 {
+	if x != nil && x.Field13077 != nil {
+		return *x.Field13077
+	}
+	return 0
+}
+
+func (x *Message13062) GetField13078() string {
+	if x != nil && x.Field13078 != nil {
+		return *x.Field13078
+	}
+	return ""
+}
+
+func (x *Message13062) GetField13079() int32 {
+	if x != nil && x.Field13079 != nil {
+		return *x.Field13079
+	}
+	return 0
+}
+
+type Message952 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field963 []*Message949 `protobuf:"bytes,1,rep,name=field963" json:"field963,omitempty"`
+}
+
+func (x *Message952) Reset() {
+	*x = Message952{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[7]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message952) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message952) ProtoMessage() {}
+
+func (x *Message952) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[7]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message952.ProtoReflect.Descriptor instead.
+func (*Message952) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *Message952) GetField963() []*Message949 {
+	if x != nil {
+		return x.Field963
+	}
+	return nil
+}
+
+type Message36876 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field36980   *Message2356                 `protobuf:"bytes,1,opt,name=field36980" json:"field36980,omitempty"`
+	Message36877 []*Message36876_Message36877 `protobuf:"group,111,rep,name=Message36877,json=message36877" json:"message36877,omitempty"`
+	Message36878 []*Message36876_Message36878 `protobuf:"group,168,rep,name=Message36878,json=message36878" json:"message36878,omitempty"`
+	Message36879 []*Message36876_Message36879 `protobuf:"group,55,rep,name=Message36879,json=message36879" json:"message36879,omitempty"`
+	Field36984   []*UnusedEmptyMessage        `protobuf:"bytes,78,rep,name=field36984" json:"field36984,omitempty"`
+	Message36880 *Message36876_Message36880   `protobuf:"group,137,opt,name=Message36880,json=message36880" json:"message36880,omitempty"`
+	Field36986   *uint64                      `protobuf:"varint,59,opt,name=field36986" json:"field36986,omitempty"`
+	Field36987   []byte                       `protobuf:"bytes,121,opt,name=field36987" json:"field36987,omitempty"`
+	Field36988   *UnusedEmptyMessage          `protobuf:"bytes,2,opt,name=field36988" json:"field36988,omitempty"`
+	Field36989   *Message7029                 `protobuf:"bytes,118,opt,name=field36989" json:"field36989,omitempty"`
+	Field36990   *Message35573                `protobuf:"bytes,11,opt,name=field36990" json:"field36990,omitempty"`
+	Field36991   *UnusedEmptyMessage          `protobuf:"bytes,21,opt,name=field36991" json:"field36991,omitempty"`
+	Field36992   *UnusedEmptyMessage          `protobuf:"bytes,22,opt,name=field36992" json:"field36992,omitempty"`
+	Field36993   *float32                     `protobuf:"fixed32,13,opt,name=field36993" json:"field36993,omitempty"`
+	Field36994   *int32                       `protobuf:"varint,20,opt,name=field36994" json:"field36994,omitempty"`
+	Field36995   *bool                        `protobuf:"varint,51,opt,name=field36995" json:"field36995,omitempty"`
+	Field36996   *bool                        `protobuf:"varint,57,opt,name=field36996" json:"field36996,omitempty"`
+	Field36997   []*UnusedEmptyMessage        `protobuf:"bytes,100,rep,name=field36997" json:"field36997,omitempty"`
+	Field36998   *int32                       `protobuf:"varint,47,opt,name=field36998" json:"field36998,omitempty"`
+	Field36999   *int32                       `protobuf:"varint,48,opt,name=field36999" json:"field36999,omitempty"`
+	Field37000   *UnusedEmptyMessage          `protobuf:"bytes,68,opt,name=field37000" json:"field37000,omitempty"`
+	Message36881 []*Message36876_Message36881 `protobuf:"group,23,rep,name=Message36881,json=message36881" json:"message36881,omitempty"`
+	Field37002   *Message4144                 `protobuf:"bytes,125,opt,name=field37002" json:"field37002,omitempty"`
+	Message36882 []*Message36876_Message36882 `protobuf:"group,35,rep,name=Message36882,json=message36882" json:"message36882,omitempty"`
+	Field37004   *UnusedEmptyMessage          `protobuf:"bytes,49,opt,name=field37004" json:"field37004,omitempty"`
+	Field37005   *Message18921                `protobuf:"bytes,52,opt,name=field37005" json:"field37005,omitempty"`
+	Field37006   *Message36858                `protobuf:"bytes,46,opt,name=field37006" json:"field37006,omitempty"`
+	Field37007   *Message18831                `protobuf:"bytes,54,opt,name=field37007" json:"field37007,omitempty"`
+	Field37008   *UnusedEmptyMessage          `protobuf:"bytes,58,opt,name=field37008" json:"field37008,omitempty"`
+	Field37009   *Message18283                `protobuf:"bytes,10,opt,name=field37009" json:"field37009,omitempty"`
+	Field37010   *string                      `protobuf:"bytes,44,opt,name=field37010" json:"field37010,omitempty"`
+	Field37011   *string                      `protobuf:"bytes,103,opt,name=field37011" json:"field37011,omitempty"`
+	Field37012   *Message0                    `protobuf:"bytes,43,opt,name=field37012" json:"field37012,omitempty"`
+	Field37013   *Message0                    `protobuf:"bytes,143,opt,name=field37013" json:"field37013,omitempty"`
+	Field37014   *UnusedEmptyMessage          `protobuf:"bytes,53,opt,name=field37014" json:"field37014,omitempty"`
+	Field37015   *Message36869                `protobuf:"bytes,15,opt,name=field37015" json:"field37015,omitempty"`
+	Message36883 *Message36876_Message36883   `protobuf:"group,3,opt,name=Message36883,json=message36883" json:"message36883,omitempty"`
+	Message36884 []*Message36876_Message36884 `protobuf:"group,16,rep,name=Message36884,json=message36884" json:"message36884,omitempty"`
+	Message36885 []*Message36876_Message36885 `protobuf:"group,27,rep,name=Message36885,json=message36885" json:"message36885,omitempty"`
+	Message36886 *Message36876_Message36886   `protobuf:"group,32,opt,name=Message36886,json=message36886" json:"message36886,omitempty"`
+	Field37020   []UnusedEnum                 `protobuf:"varint,71,rep,name=field37020,enum=benchmarks.google_message3.UnusedEnum" json:"field37020,omitempty"`
+	Field37021   []int32                      `protobuf:"varint,70,rep,name=field37021" json:"field37021,omitempty"`
+	Field37022   *UnusedEmptyMessage          `protobuf:"bytes,66,opt,name=field37022" json:"field37022,omitempty"`
+	Field37023   *Message13090                `protobuf:"bytes,67,opt,name=field37023" json:"field37023,omitempty"`
+	Message36887 *Message36876_Message36887   `protobuf:"group,62,opt,name=Message36887,json=message36887" json:"message36887,omitempty"`
+	Field37025   []*Message10155              `protobuf:"bytes,50,rep,name=field37025" json:"field37025,omitempty"`
+	Field37026   []*Message11874              `protobuf:"bytes,151,rep,name=field37026" json:"field37026,omitempty"`
+	Field37027   *string                      `protobuf:"bytes,12,opt,name=field37027" json:"field37027,omitempty"`
+	Field37028   *int64                       `protobuf:"varint,72,opt,name=field37028" json:"field37028,omitempty"`
+	Field37029   *UnusedEmptyMessage          `protobuf:"bytes,73,opt,name=field37029" json:"field37029,omitempty"`
+	Field37030   *Message35546                `protobuf:"bytes,108,opt,name=field37030" json:"field37030,omitempty"`
+	Message36888 *Message36876_Message36888   `protobuf:"group,74,opt,name=Message36888,json=message36888" json:"message36888,omitempty"`
+	Field37032   []*Message19255              `protobuf:"bytes,104,rep,name=field37032" json:"field37032,omitempty"`
+	Field37033   *Message33968                `protobuf:"bytes,105,opt,name=field37033" json:"field37033,omitempty"`
+	Field37034   *bool                        `protobuf:"varint,106,opt,name=field37034" json:"field37034,omitempty"`
+	Field37035   []*UnusedEmptyMessage        `protobuf:"bytes,107,rep,name=field37035" json:"field37035,omitempty"`
+	Field37036   *Message6644                 `protobuf:"bytes,110,opt,name=field37036" json:"field37036,omitempty"`
+	Field37037   []byte                       `protobuf:"bytes,133,opt,name=field37037" json:"field37037,omitempty"`
+	Message36889 *Message36876_Message36889   `protobuf:"group,116,opt,name=Message36889,json=message36889" json:"message36889,omitempty"`
+	Message36910 []*Message36876_Message36910 `protobuf:"group,119,rep,name=Message36910,json=message36910" json:"message36910,omitempty"`
+	Message36911 *Message36876_Message36911   `protobuf:"group,126,opt,name=Message36911,json=message36911" json:"message36911,omitempty"`
+	Message36912 *Message36876_Message36912   `protobuf:"group,152,opt,name=Message36912,json=message36912" json:"message36912,omitempty"`
+	Field37042   *UnusedEmptyMessage          `protobuf:"bytes,155,opt,name=field37042" json:"field37042,omitempty"`
+}
+
+func (x *Message36876) Reset() {
+	*x = Message36876{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[8]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message36876) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message36876) ProtoMessage() {}
+
+func (x *Message36876) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[8]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message36876.ProtoReflect.Descriptor instead.
+func (*Message36876) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *Message36876) GetField36980() *Message2356 {
+	if x != nil {
+		return x.Field36980
+	}
+	return nil
+}
+
+func (x *Message36876) GetMessage36877() []*Message36876_Message36877 {
+	if x != nil {
+		return x.Message36877
+	}
+	return nil
+}
+
+func (x *Message36876) GetMessage36878() []*Message36876_Message36878 {
+	if x != nil {
+		return x.Message36878
+	}
+	return nil
+}
+
+func (x *Message36876) GetMessage36879() []*Message36876_Message36879 {
+	if x != nil {
+		return x.Message36879
+	}
+	return nil
+}
+
+func (x *Message36876) GetField36984() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field36984
+	}
+	return nil
+}
+
+func (x *Message36876) GetMessage36880() *Message36876_Message36880 {
+	if x != nil {
+		return x.Message36880
+	}
+	return nil
+}
+
+func (x *Message36876) GetField36986() uint64 {
+	if x != nil && x.Field36986 != nil {
+		return *x.Field36986
+	}
+	return 0
+}
+
+func (x *Message36876) GetField36987() []byte {
+	if x != nil {
+		return x.Field36987
+	}
+	return nil
+}
+
+func (x *Message36876) GetField36988() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field36988
+	}
+	return nil
+}
+
+func (x *Message36876) GetField36989() *Message7029 {
+	if x != nil {
+		return x.Field36989
+	}
+	return nil
+}
+
+func (x *Message36876) GetField36990() *Message35573 {
+	if x != nil {
+		return x.Field36990
+	}
+	return nil
+}
+
+func (x *Message36876) GetField36991() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field36991
+	}
+	return nil
+}
+
+func (x *Message36876) GetField36992() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field36992
+	}
+	return nil
+}
+
+func (x *Message36876) GetField36993() float32 {
+	if x != nil && x.Field36993 != nil {
+		return *x.Field36993
+	}
+	return 0
+}
+
+func (x *Message36876) GetField36994() int32 {
+	if x != nil && x.Field36994 != nil {
+		return *x.Field36994
+	}
+	return 0
+}
+
+func (x *Message36876) GetField36995() bool {
+	if x != nil && x.Field36995 != nil {
+		return *x.Field36995
+	}
+	return false
+}
+
+func (x *Message36876) GetField36996() bool {
+	if x != nil && x.Field36996 != nil {
+		return *x.Field36996
+	}
+	return false
+}
+
+func (x *Message36876) GetField36997() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field36997
+	}
+	return nil
+}
+
+func (x *Message36876) GetField36998() int32 {
+	if x != nil && x.Field36998 != nil {
+		return *x.Field36998
+	}
+	return 0
+}
+
+func (x *Message36876) GetField36999() int32 {
+	if x != nil && x.Field36999 != nil {
+		return *x.Field36999
+	}
+	return 0
+}
+
+func (x *Message36876) GetField37000() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37000
+	}
+	return nil
+}
+
+func (x *Message36876) GetMessage36881() []*Message36876_Message36881 {
+	if x != nil {
+		return x.Message36881
+	}
+	return nil
+}
+
+func (x *Message36876) GetField37002() *Message4144 {
+	if x != nil {
+		return x.Field37002
+	}
+	return nil
+}
+
+func (x *Message36876) GetMessage36882() []*Message36876_Message36882 {
+	if x != nil {
+		return x.Message36882
+	}
+	return nil
+}
+
+func (x *Message36876) GetField37004() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37004
+	}
+	return nil
+}
+
+func (x *Message36876) GetField37005() *Message18921 {
+	if x != nil {
+		return x.Field37005
+	}
+	return nil
+}
+
+func (x *Message36876) GetField37006() *Message36858 {
+	if x != nil {
+		return x.Field37006
+	}
+	return nil
+}
+
+func (x *Message36876) GetField37007() *Message18831 {
+	if x != nil {
+		return x.Field37007
+	}
+	return nil
+}
+
+func (x *Message36876) GetField37008() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37008
+	}
+	return nil
+}
+
+func (x *Message36876) GetField37009() *Message18283 {
+	if x != nil {
+		return x.Field37009
+	}
+	return nil
+}
+
+func (x *Message36876) GetField37010() string {
+	if x != nil && x.Field37010 != nil {
+		return *x.Field37010
+	}
+	return ""
+}
+
+func (x *Message36876) GetField37011() string {
+	if x != nil && x.Field37011 != nil {
+		return *x.Field37011
+	}
+	return ""
+}
+
+func (x *Message36876) GetField37012() *Message0 {
+	if x != nil {
+		return x.Field37012
+	}
+	return nil
+}
+
+func (x *Message36876) GetField37013() *Message0 {
+	if x != nil {
+		return x.Field37013
+	}
+	return nil
+}
+
+func (x *Message36876) GetField37014() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37014
+	}
+	return nil
+}
+
+func (x *Message36876) GetField37015() *Message36869 {
+	if x != nil {
+		return x.Field37015
+	}
+	return nil
+}
+
+func (x *Message36876) GetMessage36883() *Message36876_Message36883 {
+	if x != nil {
+		return x.Message36883
+	}
+	return nil
+}
+
+func (x *Message36876) GetMessage36884() []*Message36876_Message36884 {
+	if x != nil {
+		return x.Message36884
+	}
+	return nil
+}
+
+func (x *Message36876) GetMessage36885() []*Message36876_Message36885 {
+	if x != nil {
+		return x.Message36885
+	}
+	return nil
+}
+
+func (x *Message36876) GetMessage36886() *Message36876_Message36886 {
+	if x != nil {
+		return x.Message36886
+	}
+	return nil
+}
+
+func (x *Message36876) GetField37020() []UnusedEnum {
+	if x != nil {
+		return x.Field37020
+	}
+	return nil
+}
+
+func (x *Message36876) GetField37021() []int32 {
+	if x != nil {
+		return x.Field37021
+	}
+	return nil
+}
+
+func (x *Message36876) GetField37022() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37022
+	}
+	return nil
+}
+
+func (x *Message36876) GetField37023() *Message13090 {
+	if x != nil {
+		return x.Field37023
+	}
+	return nil
+}
+
+func (x *Message36876) GetMessage36887() *Message36876_Message36887 {
+	if x != nil {
+		return x.Message36887
+	}
+	return nil
+}
+
+func (x *Message36876) GetField37025() []*Message10155 {
+	if x != nil {
+		return x.Field37025
+	}
+	return nil
+}
+
+func (x *Message36876) GetField37026() []*Message11874 {
+	if x != nil {
+		return x.Field37026
+	}
+	return nil
+}
+
+func (x *Message36876) GetField37027() string {
+	if x != nil && x.Field37027 != nil {
+		return *x.Field37027
+	}
+	return ""
+}
+
+func (x *Message36876) GetField37028() int64 {
+	if x != nil && x.Field37028 != nil {
+		return *x.Field37028
+	}
+	return 0
+}
+
+func (x *Message36876) GetField37029() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37029
+	}
+	return nil
+}
+
+func (x *Message36876) GetField37030() *Message35546 {
+	if x != nil {
+		return x.Field37030
+	}
+	return nil
+}
+
+func (x *Message36876) GetMessage36888() *Message36876_Message36888 {
+	if x != nil {
+		return x.Message36888
+	}
+	return nil
+}
+
+func (x *Message36876) GetField37032() []*Message19255 {
+	if x != nil {
+		return x.Field37032
+	}
+	return nil
+}
+
+func (x *Message36876) GetField37033() *Message33968 {
+	if x != nil {
+		return x.Field37033
+	}
+	return nil
+}
+
+func (x *Message36876) GetField37034() bool {
+	if x != nil && x.Field37034 != nil {
+		return *x.Field37034
+	}
+	return false
+}
+
+func (x *Message36876) GetField37035() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37035
+	}
+	return nil
+}
+
+func (x *Message36876) GetField37036() *Message6644 {
+	if x != nil {
+		return x.Field37036
+	}
+	return nil
+}
+
+func (x *Message36876) GetField37037() []byte {
+	if x != nil {
+		return x.Field37037
+	}
+	return nil
+}
+
+func (x *Message36876) GetMessage36889() *Message36876_Message36889 {
+	if x != nil {
+		return x.Message36889
+	}
+	return nil
+}
+
+func (x *Message36876) GetMessage36910() []*Message36876_Message36910 {
+	if x != nil {
+		return x.Message36910
+	}
+	return nil
+}
+
+func (x *Message36876) GetMessage36911() *Message36876_Message36911 {
+	if x != nil {
+		return x.Message36911
+	}
+	return nil
+}
+
+func (x *Message36876) GetMessage36912() *Message36876_Message36912 {
+	if x != nil {
+		return x.Message36912
+	}
+	return nil
+}
+
+func (x *Message36876) GetField37042() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37042
+	}
+	return nil
+}
+
+type Message1328 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message1328) Reset() {
+	*x = Message1328{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[9]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message1328) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message1328) ProtoMessage() {}
+
+func (x *Message1328) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[9]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message1328.ProtoReflect.Descriptor instead.
+func (*Message1328) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{9}
+}
+
+type Message6850 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message6850) Reset() {
+	*x = Message6850{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[10]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6850) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6850) ProtoMessage() {}
+
+func (x *Message6850) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[10]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6850.ProtoReflect.Descriptor instead.
+func (*Message6850) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{10}
+}
+
+type Message6863 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field6931 *Enum6858           `protobuf:"varint,1,opt,name=field6931,enum=benchmarks.google_message3.Enum6858" json:"field6931,omitempty"`
+	Field6932 *Enum6858           `protobuf:"varint,2,opt,name=field6932,enum=benchmarks.google_message3.Enum6858" json:"field6932,omitempty"`
+	Field6933 *UnusedEnum         `protobuf:"varint,36,opt,name=field6933,enum=benchmarks.google_message3.UnusedEnum" json:"field6933,omitempty"`
+	Field6934 *bool               `protobuf:"varint,27,opt,name=field6934" json:"field6934,omitempty"`
+	Field6935 *Message6773        `protobuf:"bytes,26,opt,name=field6935" json:"field6935,omitempty"`
+	Field6936 *int32              `protobuf:"varint,30,opt,name=field6936" json:"field6936,omitempty"`
+	Field6937 *int32              `protobuf:"varint,37,opt,name=field6937" json:"field6937,omitempty"`
+	Field6938 *Enum6815           `protobuf:"varint,31,opt,name=field6938,enum=benchmarks.google_message3.Enum6815" json:"field6938,omitempty"`
+	Field6939 *string             `protobuf:"bytes,3,opt,name=field6939" json:"field6939,omitempty"`
+	Field6940 *int32              `protobuf:"varint,4,opt,name=field6940" json:"field6940,omitempty"`
+	Field6941 *Enum6822           `protobuf:"varint,15,opt,name=field6941,enum=benchmarks.google_message3.Enum6822" json:"field6941,omitempty"`
+	Field6942 *bool               `protobuf:"varint,10,opt,name=field6942" json:"field6942,omitempty"`
+	Field6943 *bool               `protobuf:"varint,17,opt,name=field6943" json:"field6943,omitempty"`
+	Field6944 *float32            `protobuf:"fixed32,18,opt,name=field6944" json:"field6944,omitempty"`
+	Field6945 *float32            `protobuf:"fixed32,19,opt,name=field6945" json:"field6945,omitempty"`
+	Field6946 *int32              `protobuf:"varint,5,opt,name=field6946" json:"field6946,omitempty"`
+	Field6947 *int32              `protobuf:"varint,6,opt,name=field6947" json:"field6947,omitempty"`
+	Field6948 *bool               `protobuf:"varint,7,opt,name=field6948" json:"field6948,omitempty"`
+	Field6949 *int32              `protobuf:"varint,12,opt,name=field6949" json:"field6949,omitempty"`
+	Field6950 *UnusedEmptyMessage `protobuf:"bytes,8,opt,name=field6950" json:"field6950,omitempty"`
+	Field6951 *uint64             `protobuf:"varint,9,opt,name=field6951" json:"field6951,omitempty"`
+	Field6952 *string             `protobuf:"bytes,11,opt,name=field6952" json:"field6952,omitempty"`
+	Field6953 []byte              `protobuf:"bytes,13,opt,name=field6953" json:"field6953,omitempty"`
+	Field6954 *int32              `protobuf:"varint,14,opt,name=field6954" json:"field6954,omitempty"`
+	Field6955 *UnusedEmptyMessage `protobuf:"bytes,16,opt,name=field6955" json:"field6955,omitempty"`
+	Field6956 *UnusedEmptyMessage `protobuf:"bytes,22,opt,name=field6956" json:"field6956,omitempty"`
+	Field6957 *Message3886        `protobuf:"bytes,38,opt,name=field6957" json:"field6957,omitempty"`
+	Field6958 *string             `protobuf:"bytes,20,opt,name=field6958" json:"field6958,omitempty"`
+	Field6959 *uint32             `protobuf:"varint,21,opt,name=field6959" json:"field6959,omitempty"`
+	Field6960 *Message6743        `protobuf:"bytes,23,opt,name=field6960" json:"field6960,omitempty"`
+	Field6961 *UnusedEmptyMessage `protobuf:"bytes,29,opt,name=field6961" json:"field6961,omitempty"`
+	Field6962 *UnusedEmptyMessage `protobuf:"bytes,33,opt,name=field6962" json:"field6962,omitempty"`
+	Field6963 *bool               `protobuf:"varint,34,opt,name=field6963" json:"field6963,omitempty"`
+}
+
+func (x *Message6863) Reset() {
+	*x = Message6863{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[11]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6863) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6863) ProtoMessage() {}
+
+func (x *Message6863) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[11]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6863.ProtoReflect.Descriptor instead.
+func (*Message6863) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{11}
+}
+
+func (x *Message6863) GetField6931() Enum6858 {
+	if x != nil && x.Field6931 != nil {
+		return *x.Field6931
+	}
+	return Enum6858_ENUM_VALUE6859
+}
+
+func (x *Message6863) GetField6932() Enum6858 {
+	if x != nil && x.Field6932 != nil {
+		return *x.Field6932
+	}
+	return Enum6858_ENUM_VALUE6859
+}
+
+func (x *Message6863) GetField6933() UnusedEnum {
+	if x != nil && x.Field6933 != nil {
+		return *x.Field6933
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+func (x *Message6863) GetField6934() bool {
+	if x != nil && x.Field6934 != nil {
+		return *x.Field6934
+	}
+	return false
+}
+
+func (x *Message6863) GetField6935() *Message6773 {
+	if x != nil {
+		return x.Field6935
+	}
+	return nil
+}
+
+func (x *Message6863) GetField6936() int32 {
+	if x != nil && x.Field6936 != nil {
+		return *x.Field6936
+	}
+	return 0
+}
+
+func (x *Message6863) GetField6937() int32 {
+	if x != nil && x.Field6937 != nil {
+		return *x.Field6937
+	}
+	return 0
+}
+
+func (x *Message6863) GetField6938() Enum6815 {
+	if x != nil && x.Field6938 != nil {
+		return *x.Field6938
+	}
+	return Enum6815_ENUM_VALUE6816
+}
+
+func (x *Message6863) GetField6939() string {
+	if x != nil && x.Field6939 != nil {
+		return *x.Field6939
+	}
+	return ""
+}
+
+func (x *Message6863) GetField6940() int32 {
+	if x != nil && x.Field6940 != nil {
+		return *x.Field6940
+	}
+	return 0
+}
+
+func (x *Message6863) GetField6941() Enum6822 {
+	if x != nil && x.Field6941 != nil {
+		return *x.Field6941
+	}
+	return Enum6822_ENUM_VALUE6823
+}
+
+func (x *Message6863) GetField6942() bool {
+	if x != nil && x.Field6942 != nil {
+		return *x.Field6942
+	}
+	return false
+}
+
+func (x *Message6863) GetField6943() bool {
+	if x != nil && x.Field6943 != nil {
+		return *x.Field6943
+	}
+	return false
+}
+
+func (x *Message6863) GetField6944() float32 {
+	if x != nil && x.Field6944 != nil {
+		return *x.Field6944
+	}
+	return 0
+}
+
+func (x *Message6863) GetField6945() float32 {
+	if x != nil && x.Field6945 != nil {
+		return *x.Field6945
+	}
+	return 0
+}
+
+func (x *Message6863) GetField6946() int32 {
+	if x != nil && x.Field6946 != nil {
+		return *x.Field6946
+	}
+	return 0
+}
+
+func (x *Message6863) GetField6947() int32 {
+	if x != nil && x.Field6947 != nil {
+		return *x.Field6947
+	}
+	return 0
+}
+
+func (x *Message6863) GetField6948() bool {
+	if x != nil && x.Field6948 != nil {
+		return *x.Field6948
+	}
+	return false
+}
+
+func (x *Message6863) GetField6949() int32 {
+	if x != nil && x.Field6949 != nil {
+		return *x.Field6949
+	}
+	return 0
+}
+
+func (x *Message6863) GetField6950() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field6950
+	}
+	return nil
+}
+
+func (x *Message6863) GetField6951() uint64 {
+	if x != nil && x.Field6951 != nil {
+		return *x.Field6951
+	}
+	return 0
+}
+
+func (x *Message6863) GetField6952() string {
+	if x != nil && x.Field6952 != nil {
+		return *x.Field6952
+	}
+	return ""
+}
+
+func (x *Message6863) GetField6953() []byte {
+	if x != nil {
+		return x.Field6953
+	}
+	return nil
+}
+
+func (x *Message6863) GetField6954() int32 {
+	if x != nil && x.Field6954 != nil {
+		return *x.Field6954
+	}
+	return 0
+}
+
+func (x *Message6863) GetField6955() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field6955
+	}
+	return nil
+}
+
+func (x *Message6863) GetField6956() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field6956
+	}
+	return nil
+}
+
+func (x *Message6863) GetField6957() *Message3886 {
+	if x != nil {
+		return x.Field6957
+	}
+	return nil
+}
+
+func (x *Message6863) GetField6958() string {
+	if x != nil && x.Field6958 != nil {
+		return *x.Field6958
+	}
+	return ""
+}
+
+func (x *Message6863) GetField6959() uint32 {
+	if x != nil && x.Field6959 != nil {
+		return *x.Field6959
+	}
+	return 0
+}
+
+func (x *Message6863) GetField6960() *Message6743 {
+	if x != nil {
+		return x.Field6960
+	}
+	return nil
+}
+
+func (x *Message6863) GetField6961() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field6961
+	}
+	return nil
+}
+
+func (x *Message6863) GetField6962() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field6962
+	}
+	return nil
+}
+
+func (x *Message6863) GetField6963() bool {
+	if x != nil && x.Field6963 != nil {
+		return *x.Field6963
+	}
+	return false
+}
+
+type Message6871 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message6871) Reset() {
+	*x = Message6871{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[12]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6871) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6871) ProtoMessage() {}
+
+func (x *Message6871) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[12]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6871.ProtoReflect.Descriptor instead.
+func (*Message6871) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{12}
+}
+
+type Message7547 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field7549 []byte `protobuf:"bytes,1,req,name=field7549" json:"field7549,omitempty"`
+	Field7550 *int32 `protobuf:"varint,2,req,name=field7550" json:"field7550,omitempty"`
+}
+
+func (x *Message7547) Reset() {
+	*x = Message7547{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[13]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message7547) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message7547) ProtoMessage() {}
+
+func (x *Message7547) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[13]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message7547.ProtoReflect.Descriptor instead.
+func (*Message7547) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{13}
+}
+
+func (x *Message7547) GetField7549() []byte {
+	if x != nil {
+		return x.Field7549
+	}
+	return nil
+}
+
+func (x *Message7547) GetField7550() int32 {
+	if x != nil && x.Field7550 != nil {
+		return *x.Field7550
+	}
+	return 0
+}
+
+type Message7648 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field7669 *string  `protobuf:"bytes,1,opt,name=field7669" json:"field7669,omitempty"`
+	Field7670 *int32   `protobuf:"varint,2,opt,name=field7670" json:"field7670,omitempty"`
+	Field7671 *int32   `protobuf:"varint,3,opt,name=field7671" json:"field7671,omitempty"`
+	Field7672 *int32   `protobuf:"varint,4,opt,name=field7672" json:"field7672,omitempty"`
+	Field7673 *int32   `protobuf:"varint,5,opt,name=field7673" json:"field7673,omitempty"`
+	Field7674 *int32   `protobuf:"varint,6,opt,name=field7674" json:"field7674,omitempty"`
+	Field7675 *float32 `protobuf:"fixed32,7,opt,name=field7675" json:"field7675,omitempty"`
+	Field7676 *bool    `protobuf:"varint,8,opt,name=field7676" json:"field7676,omitempty"`
+	Field7677 *bool    `protobuf:"varint,9,opt,name=field7677" json:"field7677,omitempty"`
+	Field7678 *bool    `protobuf:"varint,10,opt,name=field7678" json:"field7678,omitempty"`
+	Field7679 *bool    `protobuf:"varint,11,opt,name=field7679" json:"field7679,omitempty"`
+	Field7680 *bool    `protobuf:"varint,12,opt,name=field7680" json:"field7680,omitempty"`
+}
+
+func (x *Message7648) Reset() {
+	*x = Message7648{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[14]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message7648) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message7648) ProtoMessage() {}
+
+func (x *Message7648) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[14]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message7648.ProtoReflect.Descriptor instead.
+func (*Message7648) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{14}
+}
+
+func (x *Message7648) GetField7669() string {
+	if x != nil && x.Field7669 != nil {
+		return *x.Field7669
+	}
+	return ""
+}
+
+func (x *Message7648) GetField7670() int32 {
+	if x != nil && x.Field7670 != nil {
+		return *x.Field7670
+	}
+	return 0
+}
+
+func (x *Message7648) GetField7671() int32 {
+	if x != nil && x.Field7671 != nil {
+		return *x.Field7671
+	}
+	return 0
+}
+
+func (x *Message7648) GetField7672() int32 {
+	if x != nil && x.Field7672 != nil {
+		return *x.Field7672
+	}
+	return 0
+}
+
+func (x *Message7648) GetField7673() int32 {
+	if x != nil && x.Field7673 != nil {
+		return *x.Field7673
+	}
+	return 0
+}
+
+func (x *Message7648) GetField7674() int32 {
+	if x != nil && x.Field7674 != nil {
+		return *x.Field7674
+	}
+	return 0
+}
+
+func (x *Message7648) GetField7675() float32 {
+	if x != nil && x.Field7675 != nil {
+		return *x.Field7675
+	}
+	return 0
+}
+
+func (x *Message7648) GetField7676() bool {
+	if x != nil && x.Field7676 != nil {
+		return *x.Field7676
+	}
+	return false
+}
+
+func (x *Message7648) GetField7677() bool {
+	if x != nil && x.Field7677 != nil {
+		return *x.Field7677
+	}
+	return false
+}
+
+func (x *Message7648) GetField7678() bool {
+	if x != nil && x.Field7678 != nil {
+		return *x.Field7678
+	}
+	return false
+}
+
+func (x *Message7648) GetField7679() bool {
+	if x != nil && x.Field7679 != nil {
+		return *x.Field7679
+	}
+	return false
+}
+
+func (x *Message7648) GetField7680() bool {
+	if x != nil && x.Field7680 != nil {
+		return *x.Field7680
+	}
+	return false
+}
+
+type Message7865 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message7865) Reset() {
+	*x = Message7865{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[15]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message7865) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message7865) ProtoMessage() {}
+
+func (x *Message7865) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[15]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message7865.ProtoReflect.Descriptor instead.
+func (*Message7865) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{15}
+}
+
+type Message7928 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field7940 *string `protobuf:"bytes,1,opt,name=field7940" json:"field7940,omitempty"`
+	Field7941 *int64  `protobuf:"varint,2,opt,name=field7941" json:"field7941,omitempty"`
+}
+
+func (x *Message7928) Reset() {
+	*x = Message7928{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[16]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message7928) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message7928) ProtoMessage() {}
+
+func (x *Message7928) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[16]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message7928.ProtoReflect.Descriptor instead.
+func (*Message7928) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{16}
+}
+
+func (x *Message7928) GetField7940() string {
+	if x != nil && x.Field7940 != nil {
+		return *x.Field7940
+	}
+	return ""
+}
+
+func (x *Message7928) GetField7941() int64 {
+	if x != nil && x.Field7941 != nil {
+		return *x.Field7941
+	}
+	return 0
+}
+
+type Message7919 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field7931 *uint64 `protobuf:"fixed64,1,opt,name=field7931" json:"field7931,omitempty"`
+	Field7932 *int64  `protobuf:"varint,2,opt,name=field7932" json:"field7932,omitempty"`
+	Field7933 []byte  `protobuf:"bytes,3,opt,name=field7933" json:"field7933,omitempty"`
+}
+
+func (x *Message7919) Reset() {
+	*x = Message7919{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[17]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message7919) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message7919) ProtoMessage() {}
+
+func (x *Message7919) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[17]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message7919.ProtoReflect.Descriptor instead.
+func (*Message7919) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{17}
+}
+
+func (x *Message7919) GetField7931() uint64 {
+	if x != nil && x.Field7931 != nil {
+		return *x.Field7931
+	}
+	return 0
+}
+
+func (x *Message7919) GetField7932() int64 {
+	if x != nil && x.Field7932 != nil {
+		return *x.Field7932
+	}
+	return 0
+}
+
+func (x *Message7919) GetField7933() []byte {
+	if x != nil {
+		return x.Field7933
+	}
+	return nil
+}
+
+type Message7920 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field7934 *int64 `protobuf:"varint,1,opt,name=field7934" json:"field7934,omitempty"`
+	Field7935 *int64 `protobuf:"varint,2,opt,name=field7935" json:"field7935,omitempty"`
+}
+
+func (x *Message7920) Reset() {
+	*x = Message7920{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[18]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message7920) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message7920) ProtoMessage() {}
+
+func (x *Message7920) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[18]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message7920.ProtoReflect.Descriptor instead.
+func (*Message7920) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{18}
+}
+
+func (x *Message7920) GetField7934() int64 {
+	if x != nil && x.Field7934 != nil {
+		return *x.Field7934
+	}
+	return 0
+}
+
+func (x *Message7920) GetField7935() int64 {
+	if x != nil && x.Field7935 != nil {
+		return *x.Field7935
+	}
+	return 0
+}
+
+type Message7921 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field7936 *int32      `protobuf:"varint,1,opt,name=field7936" json:"field7936,omitempty"`
+	Field7937 *int64      `protobuf:"varint,2,opt,name=field7937" json:"field7937,omitempty"`
+	Field7938 *float32    `protobuf:"fixed32,3,opt,name=field7938" json:"field7938,omitempty"`
+	Field7939 *UnusedEnum `protobuf:"varint,4,opt,name=field7939,enum=benchmarks.google_message3.UnusedEnum" json:"field7939,omitempty"`
+}
+
+func (x *Message7921) Reset() {
+	*x = Message7921{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[19]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message7921) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message7921) ProtoMessage() {}
+
+func (x *Message7921) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[19]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message7921.ProtoReflect.Descriptor instead.
+func (*Message7921) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{19}
+}
+
+func (x *Message7921) GetField7936() int32 {
+	if x != nil && x.Field7936 != nil {
+		return *x.Field7936
+	}
+	return 0
+}
+
+func (x *Message7921) GetField7937() int64 {
+	if x != nil && x.Field7937 != nil {
+		return *x.Field7937
+	}
+	return 0
+}
+
+func (x *Message7921) GetField7938() float32 {
+	if x != nil && x.Field7938 != nil {
+		return *x.Field7938
+	}
+	return 0
+}
+
+func (x *Message7921) GetField7939() UnusedEnum {
+	if x != nil && x.Field7939 != nil {
+		return *x.Field7939
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+type Message8511 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field8539 *Message8224 `protobuf:"bytes,1,opt,name=field8539" json:"field8539,omitempty"`
+	Field8540 *string      `protobuf:"bytes,2,opt,name=field8540" json:"field8540,omitempty"`
+	Field8541 *bool        `protobuf:"varint,3,opt,name=field8541" json:"field8541,omitempty"`
+	Field8542 *int64       `protobuf:"varint,4,opt,name=field8542" json:"field8542,omitempty"`
+	Field8543 *string      `protobuf:"bytes,5,opt,name=field8543" json:"field8543,omitempty"`
+}
+
+func (x *Message8511) Reset() {
+	*x = Message8511{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[20]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8511) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8511) ProtoMessage() {}
+
+func (x *Message8511) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[20]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8511.ProtoReflect.Descriptor instead.
+func (*Message8511) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{20}
+}
+
+func (x *Message8511) GetField8539() *Message8224 {
+	if x != nil {
+		return x.Field8539
+	}
+	return nil
+}
+
+func (x *Message8511) GetField8540() string {
+	if x != nil && x.Field8540 != nil {
+		return *x.Field8540
+	}
+	return ""
+}
+
+func (x *Message8511) GetField8541() bool {
+	if x != nil && x.Field8541 != nil {
+		return *x.Field8541
+	}
+	return false
+}
+
+func (x *Message8511) GetField8542() int64 {
+	if x != nil && x.Field8542 != nil {
+		return *x.Field8542
+	}
+	return 0
+}
+
+func (x *Message8511) GetField8543() string {
+	if x != nil && x.Field8543 != nil {
+		return *x.Field8543
+	}
+	return ""
+}
+
+type Message8512 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field8544 *Message8301 `protobuf:"bytes,1,opt,name=field8544" json:"field8544,omitempty"`
+	Field8545 *Message8302 `protobuf:"bytes,2,opt,name=field8545" json:"field8545,omitempty"`
+	Field8546 *string      `protobuf:"bytes,3,opt,name=field8546" json:"field8546,omitempty"`
+	Field8547 *bool        `protobuf:"varint,4,opt,name=field8547" json:"field8547,omitempty"`
+	Field8548 *int64       `protobuf:"varint,5,opt,name=field8548" json:"field8548,omitempty"`
+	Field8549 *string      `protobuf:"bytes,6,opt,name=field8549" json:"field8549,omitempty"`
+}
+
+func (x *Message8512) Reset() {
+	*x = Message8512{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[21]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8512) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8512) ProtoMessage() {}
+
+func (x *Message8512) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[21]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8512.ProtoReflect.Descriptor instead.
+func (*Message8512) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{21}
+}
+
+func (x *Message8512) GetField8544() *Message8301 {
+	if x != nil {
+		return x.Field8544
+	}
+	return nil
+}
+
+func (x *Message8512) GetField8545() *Message8302 {
+	if x != nil {
+		return x.Field8545
+	}
+	return nil
+}
+
+func (x *Message8512) GetField8546() string {
+	if x != nil && x.Field8546 != nil {
+		return *x.Field8546
+	}
+	return ""
+}
+
+func (x *Message8512) GetField8547() bool {
+	if x != nil && x.Field8547 != nil {
+		return *x.Field8547
+	}
+	return false
+}
+
+func (x *Message8512) GetField8548() int64 {
+	if x != nil && x.Field8548 != nil {
+		return *x.Field8548
+	}
+	return 0
+}
+
+func (x *Message8512) GetField8549() string {
+	if x != nil && x.Field8549 != nil {
+		return *x.Field8549
+	}
+	return ""
+}
+
+type Message8513 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field8550 []*Message8392 `protobuf:"bytes,1,rep,name=field8550" json:"field8550,omitempty"`
+	Field8551 *string        `protobuf:"bytes,2,opt,name=field8551" json:"field8551,omitempty"`
+	Field8552 *bool          `protobuf:"varint,3,opt,name=field8552" json:"field8552,omitempty"`
+	Field8553 *string        `protobuf:"bytes,4,opt,name=field8553" json:"field8553,omitempty"`
+}
+
+func (x *Message8513) Reset() {
+	*x = Message8513{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[22]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8513) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8513) ProtoMessage() {}
+
+func (x *Message8513) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[22]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8513.ProtoReflect.Descriptor instead.
+func (*Message8513) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{22}
+}
+
+func (x *Message8513) GetField8550() []*Message8392 {
+	if x != nil {
+		return x.Field8550
+	}
+	return nil
+}
+
+func (x *Message8513) GetField8551() string {
+	if x != nil && x.Field8551 != nil {
+		return *x.Field8551
+	}
+	return ""
+}
+
+func (x *Message8513) GetField8552() bool {
+	if x != nil && x.Field8552 != nil {
+		return *x.Field8552
+	}
+	return false
+}
+
+func (x *Message8513) GetField8553() string {
+	if x != nil && x.Field8553 != nil {
+		return *x.Field8553
+	}
+	return ""
+}
+
+type Message8514 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field8554 *string        `protobuf:"bytes,1,opt,name=field8554" json:"field8554,omitempty"`
+	Field8555 *int64         `protobuf:"varint,2,opt,name=field8555" json:"field8555,omitempty"`
+	Field8556 *bool          `protobuf:"varint,3,opt,name=field8556" json:"field8556,omitempty"`
+	Field8557 []*Message8130 `protobuf:"bytes,4,rep,name=field8557" json:"field8557,omitempty"`
+	Field8558 *string        `protobuf:"bytes,5,opt,name=field8558" json:"field8558,omitempty"`
+}
+
+func (x *Message8514) Reset() {
+	*x = Message8514{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[23]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8514) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8514) ProtoMessage() {}
+
+func (x *Message8514) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[23]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8514.ProtoReflect.Descriptor instead.
+func (*Message8514) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{23}
+}
+
+func (x *Message8514) GetField8554() string {
+	if x != nil && x.Field8554 != nil {
+		return *x.Field8554
+	}
+	return ""
+}
+
+func (x *Message8514) GetField8555() int64 {
+	if x != nil && x.Field8555 != nil {
+		return *x.Field8555
+	}
+	return 0
+}
+
+func (x *Message8514) GetField8556() bool {
+	if x != nil && x.Field8556 != nil {
+		return *x.Field8556
+	}
+	return false
+}
+
+func (x *Message8514) GetField8557() []*Message8130 {
+	if x != nil {
+		return x.Field8557
+	}
+	return nil
+}
+
+func (x *Message8514) GetField8558() string {
+	if x != nil && x.Field8558 != nil {
+		return *x.Field8558
+	}
+	return ""
+}
+
+type Message8515 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field8559 *Message8479 `protobuf:"bytes,1,opt,name=field8559" json:"field8559,omitempty"`
+	Field8560 *Message8478 `protobuf:"bytes,2,opt,name=field8560" json:"field8560,omitempty"`
+	Field8561 *string      `protobuf:"bytes,3,opt,name=field8561" json:"field8561,omitempty"`
+}
+
+func (x *Message8515) Reset() {
+	*x = Message8515{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[24]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8515) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8515) ProtoMessage() {}
+
+func (x *Message8515) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[24]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8515.ProtoReflect.Descriptor instead.
+func (*Message8515) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{24}
+}
+
+func (x *Message8515) GetField8559() *Message8479 {
+	if x != nil {
+		return x.Field8559
+	}
+	return nil
+}
+
+func (x *Message8515) GetField8560() *Message8478 {
+	if x != nil {
+		return x.Field8560
+	}
+	return nil
+}
+
+func (x *Message8515) GetField8561() string {
+	if x != nil && x.Field8561 != nil {
+		return *x.Field8561
+	}
+	return ""
+}
+
+type Message10320 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field10347 *Enum10335      `protobuf:"varint,1,opt,name=field10347,enum=benchmarks.google_message3.Enum10335" json:"field10347,omitempty"`
+	Field10348 []*Message10319 `protobuf:"bytes,2,rep,name=field10348" json:"field10348,omitempty"`
+	Field10349 *int32          `protobuf:"varint,3,opt,name=field10349" json:"field10349,omitempty"`
+	Field10350 *int32          `protobuf:"varint,4,opt,name=field10350" json:"field10350,omitempty"`
+	Field10351 *int32          `protobuf:"varint,5,opt,name=field10351" json:"field10351,omitempty"`
+	Field10352 *int32          `protobuf:"varint,6,opt,name=field10352" json:"field10352,omitempty"`
+	Field10353 *Enum10337      `protobuf:"varint,7,opt,name=field10353,enum=benchmarks.google_message3.Enum10337" json:"field10353,omitempty"`
+}
+
+func (x *Message10320) Reset() {
+	*x = Message10320{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[25]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message10320) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message10320) ProtoMessage() {}
+
+func (x *Message10320) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[25]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message10320.ProtoReflect.Descriptor instead.
+func (*Message10320) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{25}
+}
+
+func (x *Message10320) GetField10347() Enum10335 {
+	if x != nil && x.Field10347 != nil {
+		return *x.Field10347
+	}
+	return Enum10335_ENUM_VALUE10336
+}
+
+func (x *Message10320) GetField10348() []*Message10319 {
+	if x != nil {
+		return x.Field10348
+	}
+	return nil
+}
+
+func (x *Message10320) GetField10349() int32 {
+	if x != nil && x.Field10349 != nil {
+		return *x.Field10349
+	}
+	return 0
+}
+
+func (x *Message10320) GetField10350() int32 {
+	if x != nil && x.Field10350 != nil {
+		return *x.Field10350
+	}
+	return 0
+}
+
+func (x *Message10320) GetField10351() int32 {
+	if x != nil && x.Field10351 != nil {
+		return *x.Field10351
+	}
+	return 0
+}
+
+func (x *Message10320) GetField10352() int32 {
+	if x != nil && x.Field10352 != nil {
+		return *x.Field10352
+	}
+	return 0
+}
+
+func (x *Message10320) GetField10353() Enum10337 {
+	if x != nil && x.Field10353 != nil {
+		return *x.Field10353
+	}
+	return Enum10337_ENUM_VALUE10338
+}
+
+type Message10321 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field10354 *int32  `protobuf:"varint,1,opt,name=field10354" json:"field10354,omitempty"`
+	Field10355 *int32  `protobuf:"varint,2,opt,name=field10355" json:"field10355,omitempty"`
+	Field10356 *uint64 `protobuf:"varint,3,opt,name=field10356" json:"field10356,omitempty"`
+}
+
+func (x *Message10321) Reset() {
+	*x = Message10321{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[26]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message10321) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message10321) ProtoMessage() {}
+
+func (x *Message10321) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[26]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message10321.ProtoReflect.Descriptor instead.
+func (*Message10321) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{26}
+}
+
+func (x *Message10321) GetField10354() int32 {
+	if x != nil && x.Field10354 != nil {
+		return *x.Field10354
+	}
+	return 0
+}
+
+func (x *Message10321) GetField10355() int32 {
+	if x != nil && x.Field10355 != nil {
+		return *x.Field10355
+	}
+	return 0
+}
+
+func (x *Message10321) GetField10356() uint64 {
+	if x != nil && x.Field10356 != nil {
+		return *x.Field10356
+	}
+	return 0
+}
+
+type Message10322 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field10357 *Message4016 `protobuf:"bytes,1,opt,name=field10357" json:"field10357,omitempty"`
+	Field10358 *bool        `protobuf:"varint,2,opt,name=field10358" json:"field10358,omitempty"`
+	Field10359 *bool        `protobuf:"varint,3,opt,name=field10359" json:"field10359,omitempty"`
+}
+
+func (x *Message10322) Reset() {
+	*x = Message10322{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[27]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message10322) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message10322) ProtoMessage() {}
+
+func (x *Message10322) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[27]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message10322.ProtoReflect.Descriptor instead.
+func (*Message10322) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{27}
+}
+
+func (x *Message10322) GetField10357() *Message4016 {
+	if x != nil {
+		return x.Field10357
+	}
+	return nil
+}
+
+func (x *Message10322) GetField10358() bool {
+	if x != nil && x.Field10358 != nil {
+		return *x.Field10358
+	}
+	return false
+}
+
+func (x *Message10322) GetField10359() bool {
+	if x != nil && x.Field10359 != nil {
+		return *x.Field10359
+	}
+	return false
+}
+
+type Message11988 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12021 *string             `protobuf:"bytes,1,opt,name=field12021" json:"field12021,omitempty"`
+	Field12022 *string             `protobuf:"bytes,2,opt,name=field12022" json:"field12022,omitempty"`
+	Field12023 *UnusedEmptyMessage `protobuf:"bytes,3,opt,name=field12023" json:"field12023,omitempty"`
+	Field12024 *Message10155       `protobuf:"bytes,4,opt,name=field12024" json:"field12024,omitempty"`
+}
+
+func (x *Message11988) Reset() {
+	*x = Message11988{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[28]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message11988) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message11988) ProtoMessage() {}
+
+func (x *Message11988) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[28]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message11988.ProtoReflect.Descriptor instead.
+func (*Message11988) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{28}
+}
+
+func (x *Message11988) GetField12021() string {
+	if x != nil && x.Field12021 != nil {
+		return *x.Field12021
+	}
+	return ""
+}
+
+func (x *Message11988) GetField12022() string {
+	if x != nil && x.Field12022 != nil {
+		return *x.Field12022
+	}
+	return ""
+}
+
+func (x *Message11988) GetField12023() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field12023
+	}
+	return nil
+}
+
+func (x *Message11988) GetField12024() *Message10155 {
+	if x != nil {
+		return x.Field12024
+	}
+	return nil
+}
+
+type Message12668 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12677 []*Message12669 `protobuf:"bytes,1,rep,name=field12677" json:"field12677,omitempty"`
+	Field12678 *int32          `protobuf:"varint,2,opt,name=field12678" json:"field12678,omitempty"`
+	Field12679 *int32          `protobuf:"varint,3,opt,name=field12679" json:"field12679,omitempty"`
+	Field12680 *int32          `protobuf:"varint,4,opt,name=field12680" json:"field12680,omitempty"`
+}
+
+func (x *Message12668) Reset() {
+	*x = Message12668{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[29]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12668) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12668) ProtoMessage() {}
+
+func (x *Message12668) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[29]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12668.ProtoReflect.Descriptor instead.
+func (*Message12668) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{29}
+}
+
+func (x *Message12668) GetField12677() []*Message12669 {
+	if x != nil {
+		return x.Field12677
+	}
+	return nil
+}
+
+func (x *Message12668) GetField12678() int32 {
+	if x != nil && x.Field12678 != nil {
+		return *x.Field12678
+	}
+	return 0
+}
+
+func (x *Message12668) GetField12679() int32 {
+	if x != nil && x.Field12679 != nil {
+		return *x.Field12679
+	}
+	return 0
+}
+
+func (x *Message12668) GetField12680() int32 {
+	if x != nil && x.Field12680 != nil {
+		return *x.Field12680
+	}
+	return 0
+}
+
+type Message12825 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12862 []*Message12818       `protobuf:"bytes,1,rep,name=field12862" json:"field12862,omitempty"`
+	Field12863 *int32                `protobuf:"varint,2,opt,name=field12863" json:"field12863,omitempty"`
+	Field12864 *Message12819         `protobuf:"bytes,3,opt,name=field12864" json:"field12864,omitempty"`
+	Field12865 *Message12820         `protobuf:"bytes,4,opt,name=field12865" json:"field12865,omitempty"`
+	Field12866 *int32                `protobuf:"varint,5,opt,name=field12866" json:"field12866,omitempty"`
+	Field12867 []*Message12821       `protobuf:"bytes,6,rep,name=field12867" json:"field12867,omitempty"`
+	Field12868 []*UnusedEmptyMessage `protobuf:"bytes,7,rep,name=field12868" json:"field12868,omitempty"`
+}
+
+func (x *Message12825) Reset() {
+	*x = Message12825{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[30]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12825) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12825) ProtoMessage() {}
+
+func (x *Message12825) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[30]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12825.ProtoReflect.Descriptor instead.
+func (*Message12825) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{30}
+}
+
+func (x *Message12825) GetField12862() []*Message12818 {
+	if x != nil {
+		return x.Field12862
+	}
+	return nil
+}
+
+func (x *Message12825) GetField12863() int32 {
+	if x != nil && x.Field12863 != nil {
+		return *x.Field12863
+	}
+	return 0
+}
+
+func (x *Message12825) GetField12864() *Message12819 {
+	if x != nil {
+		return x.Field12864
+	}
+	return nil
+}
+
+func (x *Message12825) GetField12865() *Message12820 {
+	if x != nil {
+		return x.Field12865
+	}
+	return nil
+}
+
+func (x *Message12825) GetField12866() int32 {
+	if x != nil && x.Field12866 != nil {
+		return *x.Field12866
+	}
+	return 0
+}
+
+func (x *Message12825) GetField12867() []*Message12821 {
+	if x != nil {
+		return x.Field12867
+	}
+	return nil
+}
+
+func (x *Message12825) GetField12868() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field12868
+	}
+	return nil
+}
+
+type Message16478 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field16481 []*Message16479 `protobuf:"bytes,1,rep,name=field16481" json:"field16481,omitempty"`
+	Field16482 *bool           `protobuf:"varint,3,opt,name=field16482" json:"field16482,omitempty"`
+	Field16483 *int32          `protobuf:"varint,2,opt,name=field16483" json:"field16483,omitempty"`
+}
+
+func (x *Message16478) Reset() {
+	*x = Message16478{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[31]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message16478) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message16478) ProtoMessage() {}
+
+func (x *Message16478) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[31]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message16478.ProtoReflect.Descriptor instead.
+func (*Message16478) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{31}
+}
+
+func (x *Message16478) GetField16481() []*Message16479 {
+	if x != nil {
+		return x.Field16481
+	}
+	return nil
+}
+
+func (x *Message16478) GetField16482() bool {
+	if x != nil && x.Field16482 != nil {
+		return *x.Field16482
+	}
+	return false
+}
+
+func (x *Message16478) GetField16483() int32 {
+	if x != nil && x.Field16483 != nil {
+		return *x.Field16483
+	}
+	return 0
+}
+
+type Message16552 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field16565 *uint64    `protobuf:"fixed64,1,opt,name=field16565" json:"field16565,omitempty"`
+	Field16566 *int32     `protobuf:"varint,2,opt,name=field16566" json:"field16566,omitempty"`
+	Field16567 *Enum16553 `protobuf:"varint,3,opt,name=field16567,enum=benchmarks.google_message3.Enum16553" json:"field16567,omitempty"`
+}
+
+func (x *Message16552) Reset() {
+	*x = Message16552{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[32]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message16552) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message16552) ProtoMessage() {}
+
+func (x *Message16552) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[32]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message16552.ProtoReflect.Descriptor instead.
+func (*Message16552) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{32}
+}
+
+func (x *Message16552) GetField16565() uint64 {
+	if x != nil && x.Field16565 != nil {
+		return *x.Field16565
+	}
+	return 0
+}
+
+func (x *Message16552) GetField16566() int32 {
+	if x != nil && x.Field16566 != nil {
+		return *x.Field16566
+	}
+	return 0
+}
+
+func (x *Message16552) GetField16567() Enum16553 {
+	if x != nil && x.Field16567 != nil {
+		return *x.Field16567
+	}
+	return Enum16553_ENUM_VALUE16554
+}
+
+type Message16660 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field16668 *string `protobuf:"bytes,1,opt,name=field16668" json:"field16668,omitempty"`
+	Field16669 *string `protobuf:"bytes,2,opt,name=field16669" json:"field16669,omitempty"`
+	Field16670 *int32  `protobuf:"varint,3,opt,name=field16670" json:"field16670,omitempty"`
+}
+
+func (x *Message16660) Reset() {
+	*x = Message16660{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[33]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message16660) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message16660) ProtoMessage() {}
+
+func (x *Message16660) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[33]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message16660.ProtoReflect.Descriptor instead.
+func (*Message16660) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{33}
+}
+
+func (x *Message16660) GetField16668() string {
+	if x != nil && x.Field16668 != nil {
+		return *x.Field16668
+	}
+	return ""
+}
+
+func (x *Message16660) GetField16669() string {
+	if x != nil && x.Field16669 != nil {
+		return *x.Field16669
+	}
+	return ""
+}
+
+func (x *Message16660) GetField16670() int32 {
+	if x != nil && x.Field16670 != nil {
+		return *x.Field16670
+	}
+	return 0
+}
+
+type Message16727 struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+
+	Field16782 *Enum16728          `protobuf:"varint,1,req,name=field16782,enum=benchmarks.google_message3.Enum16728" json:"field16782,omitempty"`
+	Field16783 *string             `protobuf:"bytes,2,req,name=field16783" json:"field16783,omitempty"`
+	Field16784 *string             `protobuf:"bytes,3,opt,name=field16784" json:"field16784,omitempty"`
+	Field16785 *int32              `protobuf:"varint,23,opt,name=field16785" json:"field16785,omitempty"`
+	Field16786 *string             `protobuf:"bytes,4,req,name=field16786" json:"field16786,omitempty"`
+	Field16787 *string             `protobuf:"bytes,5,opt,name=field16787" json:"field16787,omitempty"`
+	Field16788 *string             `protobuf:"bytes,6,opt,name=field16788" json:"field16788,omitempty"`
+	Field16789 *Enum16732          `protobuf:"varint,7,req,name=field16789,enum=benchmarks.google_message3.Enum16732" json:"field16789,omitempty"`
+	Field16790 *string             `protobuf:"bytes,8,opt,name=field16790" json:"field16790,omitempty"`
+	Field16791 *string             `protobuf:"bytes,9,opt,name=field16791" json:"field16791,omitempty"`
+	Field16792 *string             `protobuf:"bytes,10,opt,name=field16792" json:"field16792,omitempty"`
+	Field16793 *Enum16738          `protobuf:"varint,11,opt,name=field16793,enum=benchmarks.google_message3.Enum16738" json:"field16793,omitempty"`
+	Field16794 *int32              `protobuf:"varint,12,opt,name=field16794" json:"field16794,omitempty"`
+	Field16795 []*Message16722     `protobuf:"bytes,13,rep,name=field16795" json:"field16795,omitempty"`
+	Field16796 *bool               `protobuf:"varint,19,opt,name=field16796" json:"field16796,omitempty"`
+	Field16797 *bool               `protobuf:"varint,24,opt,name=field16797" json:"field16797,omitempty"`
+	Field16798 *string             `protobuf:"bytes,14,opt,name=field16798" json:"field16798,omitempty"`
+	Field16799 *int64              `protobuf:"varint,15,opt,name=field16799" json:"field16799,omitempty"`
+	Field16800 *bool               `protobuf:"varint,16,opt,name=field16800" json:"field16800,omitempty"`
+	Field16801 *string             `protobuf:"bytes,17,opt,name=field16801" json:"field16801,omitempty"`
+	Field16802 *Enum16698          `protobuf:"varint,18,opt,name=field16802,enum=benchmarks.google_message3.Enum16698" json:"field16802,omitempty"`
+	Field16803 *Message16724       `protobuf:"bytes,20,opt,name=field16803" json:"field16803,omitempty"`
+	Field16804 *bool               `protobuf:"varint,22,opt,name=field16804" json:"field16804,omitempty"`
+	Field16805 *UnusedEmptyMessage `protobuf:"bytes,25,opt,name=field16805" json:"field16805,omitempty"`
+}
+
+func (x *Message16727) Reset() {
+	*x = Message16727{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[34]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message16727) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message16727) ProtoMessage() {}
+
+func (x *Message16727) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[34]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message16727.ProtoReflect.Descriptor instead.
+func (*Message16727) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{34}
+}
+
+var extRange_Message16727 = []protoiface.ExtensionRangeV1{
+	{Start: 1000, End: 536870911},
+}
+
+// Deprecated: Use Message16727.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*Message16727) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_Message16727
+}
+
+func (x *Message16727) GetField16782() Enum16728 {
+	if x != nil && x.Field16782 != nil {
+		return *x.Field16782
+	}
+	return Enum16728_ENUM_VALUE16729
+}
+
+func (x *Message16727) GetField16783() string {
+	if x != nil && x.Field16783 != nil {
+		return *x.Field16783
+	}
+	return ""
+}
+
+func (x *Message16727) GetField16784() string {
+	if x != nil && x.Field16784 != nil {
+		return *x.Field16784
+	}
+	return ""
+}
+
+func (x *Message16727) GetField16785() int32 {
+	if x != nil && x.Field16785 != nil {
+		return *x.Field16785
+	}
+	return 0
+}
+
+func (x *Message16727) GetField16786() string {
+	if x != nil && x.Field16786 != nil {
+		return *x.Field16786
+	}
+	return ""
+}
+
+func (x *Message16727) GetField16787() string {
+	if x != nil && x.Field16787 != nil {
+		return *x.Field16787
+	}
+	return ""
+}
+
+func (x *Message16727) GetField16788() string {
+	if x != nil && x.Field16788 != nil {
+		return *x.Field16788
+	}
+	return ""
+}
+
+func (x *Message16727) GetField16789() Enum16732 {
+	if x != nil && x.Field16789 != nil {
+		return *x.Field16789
+	}
+	return Enum16732_ENUM_VALUE16733
+}
+
+func (x *Message16727) GetField16790() string {
+	if x != nil && x.Field16790 != nil {
+		return *x.Field16790
+	}
+	return ""
+}
+
+func (x *Message16727) GetField16791() string {
+	if x != nil && x.Field16791 != nil {
+		return *x.Field16791
+	}
+	return ""
+}
+
+func (x *Message16727) GetField16792() string {
+	if x != nil && x.Field16792 != nil {
+		return *x.Field16792
+	}
+	return ""
+}
+
+func (x *Message16727) GetField16793() Enum16738 {
+	if x != nil && x.Field16793 != nil {
+		return *x.Field16793
+	}
+	return Enum16738_ENUM_VALUE16739
+}
+
+func (x *Message16727) GetField16794() int32 {
+	if x != nil && x.Field16794 != nil {
+		return *x.Field16794
+	}
+	return 0
+}
+
+func (x *Message16727) GetField16795() []*Message16722 {
+	if x != nil {
+		return x.Field16795
+	}
+	return nil
+}
+
+func (x *Message16727) GetField16796() bool {
+	if x != nil && x.Field16796 != nil {
+		return *x.Field16796
+	}
+	return false
+}
+
+func (x *Message16727) GetField16797() bool {
+	if x != nil && x.Field16797 != nil {
+		return *x.Field16797
+	}
+	return false
+}
+
+func (x *Message16727) GetField16798() string {
+	if x != nil && x.Field16798 != nil {
+		return *x.Field16798
+	}
+	return ""
+}
+
+func (x *Message16727) GetField16799() int64 {
+	if x != nil && x.Field16799 != nil {
+		return *x.Field16799
+	}
+	return 0
+}
+
+func (x *Message16727) GetField16800() bool {
+	if x != nil && x.Field16800 != nil {
+		return *x.Field16800
+	}
+	return false
+}
+
+func (x *Message16727) GetField16801() string {
+	if x != nil && x.Field16801 != nil {
+		return *x.Field16801
+	}
+	return ""
+}
+
+func (x *Message16727) GetField16802() Enum16698 {
+	if x != nil && x.Field16802 != nil {
+		return *x.Field16802
+	}
+	return Enum16698_ENUM_VALUE16699
+}
+
+func (x *Message16727) GetField16803() *Message16724 {
+	if x != nil {
+		return x.Field16803
+	}
+	return nil
+}
+
+func (x *Message16727) GetField16804() bool {
+	if x != nil && x.Field16804 != nil {
+		return *x.Field16804
+	}
+	return false
+}
+
+func (x *Message16727) GetField16805() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field16805
+	}
+	return nil
+}
+
+type Message16725 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field16774 *Enum16728 `protobuf:"varint,1,opt,name=field16774,enum=benchmarks.google_message3.Enum16728" json:"field16774,omitempty"`
+	Field16775 []string   `protobuf:"bytes,2,rep,name=field16775" json:"field16775,omitempty"`
+}
+
+func (x *Message16725) Reset() {
+	*x = Message16725{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[35]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message16725) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message16725) ProtoMessage() {}
+
+func (x *Message16725) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[35]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message16725.ProtoReflect.Descriptor instead.
+func (*Message16725) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{35}
+}
+
+func (x *Message16725) GetField16774() Enum16728 {
+	if x != nil && x.Field16774 != nil {
+		return *x.Field16774
+	}
+	return Enum16728_ENUM_VALUE16729
+}
+
+func (x *Message16725) GetField16775() []string {
+	if x != nil {
+		return x.Field16775
+	}
+	return nil
+}
+
+type Message17726 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field17801 *string               `protobuf:"bytes,1,opt,name=field17801" json:"field17801,omitempty"`
+	Field17802 []string              `protobuf:"bytes,2,rep,name=field17802" json:"field17802,omitempty"`
+	Field17803 *string               `protobuf:"bytes,3,opt,name=field17803" json:"field17803,omitempty"`
+	Field17804 []string              `protobuf:"bytes,4,rep,name=field17804" json:"field17804,omitempty"`
+	Field17805 *string               `protobuf:"bytes,5,opt,name=field17805" json:"field17805,omitempty"`
+	Field17806 []string              `protobuf:"bytes,6,rep,name=field17806" json:"field17806,omitempty"`
+	Field17807 *string               `protobuf:"bytes,7,opt,name=field17807" json:"field17807,omitempty"`
+	Field17808 *string               `protobuf:"bytes,8,opt,name=field17808" json:"field17808,omitempty"`
+	Field17809 []string              `protobuf:"bytes,15,rep,name=field17809" json:"field17809,omitempty"`
+	Field17810 []string              `protobuf:"bytes,16,rep,name=field17810" json:"field17810,omitempty"`
+	Field17811 []string              `protobuf:"bytes,17,rep,name=field17811" json:"field17811,omitempty"`
+	Field17812 []*UnusedEmptyMessage `protobuf:"bytes,18,rep,name=field17812" json:"field17812,omitempty"`
+	Field17813 *string               `protobuf:"bytes,9,opt,name=field17813" json:"field17813,omitempty"`
+	Field17814 *string               `protobuf:"bytes,10,opt,name=field17814" json:"field17814,omitempty"`
+	Field17815 *string               `protobuf:"bytes,11,opt,name=field17815" json:"field17815,omitempty"`
+	Field17816 *string               `protobuf:"bytes,12,opt,name=field17816" json:"field17816,omitempty"`
+	Field17817 *string               `protobuf:"bytes,13,opt,name=field17817" json:"field17817,omitempty"`
+	Field17818 *string               `protobuf:"bytes,14,opt,name=field17818" json:"field17818,omitempty"`
+	Field17819 *string               `protobuf:"bytes,19,opt,name=field17819" json:"field17819,omitempty"`
+	Field17820 []*Message17728       `protobuf:"bytes,20,rep,name=field17820" json:"field17820,omitempty"`
+	Field17821 []*Message17728       `protobuf:"bytes,21,rep,name=field17821" json:"field17821,omitempty"`
+	Field17822 []*UnusedEmptyMessage `protobuf:"bytes,30,rep,name=field17822" json:"field17822,omitempty"`
+}
+
+func (x *Message17726) Reset() {
+	*x = Message17726{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[36]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message17726) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message17726) ProtoMessage() {}
+
+func (x *Message17726) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[36]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message17726.ProtoReflect.Descriptor instead.
+func (*Message17726) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{36}
+}
+
+func (x *Message17726) GetField17801() string {
+	if x != nil && x.Field17801 != nil {
+		return *x.Field17801
+	}
+	return ""
+}
+
+func (x *Message17726) GetField17802() []string {
+	if x != nil {
+		return x.Field17802
+	}
+	return nil
+}
+
+func (x *Message17726) GetField17803() string {
+	if x != nil && x.Field17803 != nil {
+		return *x.Field17803
+	}
+	return ""
+}
+
+func (x *Message17726) GetField17804() []string {
+	if x != nil {
+		return x.Field17804
+	}
+	return nil
+}
+
+func (x *Message17726) GetField17805() string {
+	if x != nil && x.Field17805 != nil {
+		return *x.Field17805
+	}
+	return ""
+}
+
+func (x *Message17726) GetField17806() []string {
+	if x != nil {
+		return x.Field17806
+	}
+	return nil
+}
+
+func (x *Message17726) GetField17807() string {
+	if x != nil && x.Field17807 != nil {
+		return *x.Field17807
+	}
+	return ""
+}
+
+func (x *Message17726) GetField17808() string {
+	if x != nil && x.Field17808 != nil {
+		return *x.Field17808
+	}
+	return ""
+}
+
+func (x *Message17726) GetField17809() []string {
+	if x != nil {
+		return x.Field17809
+	}
+	return nil
+}
+
+func (x *Message17726) GetField17810() []string {
+	if x != nil {
+		return x.Field17810
+	}
+	return nil
+}
+
+func (x *Message17726) GetField17811() []string {
+	if x != nil {
+		return x.Field17811
+	}
+	return nil
+}
+
+func (x *Message17726) GetField17812() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field17812
+	}
+	return nil
+}
+
+func (x *Message17726) GetField17813() string {
+	if x != nil && x.Field17813 != nil {
+		return *x.Field17813
+	}
+	return ""
+}
+
+func (x *Message17726) GetField17814() string {
+	if x != nil && x.Field17814 != nil {
+		return *x.Field17814
+	}
+	return ""
+}
+
+func (x *Message17726) GetField17815() string {
+	if x != nil && x.Field17815 != nil {
+		return *x.Field17815
+	}
+	return ""
+}
+
+func (x *Message17726) GetField17816() string {
+	if x != nil && x.Field17816 != nil {
+		return *x.Field17816
+	}
+	return ""
+}
+
+func (x *Message17726) GetField17817() string {
+	if x != nil && x.Field17817 != nil {
+		return *x.Field17817
+	}
+	return ""
+}
+
+func (x *Message17726) GetField17818() string {
+	if x != nil && x.Field17818 != nil {
+		return *x.Field17818
+	}
+	return ""
+}
+
+func (x *Message17726) GetField17819() string {
+	if x != nil && x.Field17819 != nil {
+		return *x.Field17819
+	}
+	return ""
+}
+
+func (x *Message17726) GetField17820() []*Message17728 {
+	if x != nil {
+		return x.Field17820
+	}
+	return nil
+}
+
+func (x *Message17726) GetField17821() []*Message17728 {
+	if x != nil {
+		return x.Field17821
+	}
+	return nil
+}
+
+func (x *Message17726) GetField17822() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field17822
+	}
+	return nil
+}
+
+type Message17782 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field18153 *string `protobuf:"bytes,1,opt,name=field18153" json:"field18153,omitempty"`
+	Field18154 *string `protobuf:"bytes,2,opt,name=field18154" json:"field18154,omitempty"`
+}
+
+func (x *Message17782) Reset() {
+	*x = Message17782{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[37]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message17782) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message17782) ProtoMessage() {}
+
+func (x *Message17782) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[37]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message17782.ProtoReflect.Descriptor instead.
+func (*Message17782) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{37}
+}
+
+func (x *Message17782) GetField18153() string {
+	if x != nil && x.Field18153 != nil {
+		return *x.Field18153
+	}
+	return ""
+}
+
+func (x *Message17782) GetField18154() string {
+	if x != nil && x.Field18154 != nil {
+		return *x.Field18154
+	}
+	return ""
+}
+
+type Message17783 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field18155   *string                      `protobuf:"bytes,1,opt,name=field18155" json:"field18155,omitempty"`
+	Field18156   *string                      `protobuf:"bytes,2,opt,name=field18156" json:"field18156,omitempty"`
+	Field18157   *string                      `protobuf:"bytes,3,opt,name=field18157" json:"field18157,omitempty"`
+	Message17784 []*Message17783_Message17784 `protobuf:"group,4,rep,name=Message17784,json=message17784" json:"message17784,omitempty"`
+	Message17785 []*Message17783_Message17785 `protobuf:"group,9,rep,name=Message17785,json=message17785" json:"message17785,omitempty"`
+	Field18160   []string                     `protobuf:"bytes,16,rep,name=field18160" json:"field18160,omitempty"`
+}
+
+func (x *Message17783) Reset() {
+	*x = Message17783{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[38]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message17783) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message17783) ProtoMessage() {}
+
+func (x *Message17783) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[38]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message17783.ProtoReflect.Descriptor instead.
+func (*Message17783) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{38}
+}
+
+func (x *Message17783) GetField18155() string {
+	if x != nil && x.Field18155 != nil {
+		return *x.Field18155
+	}
+	return ""
+}
+
+func (x *Message17783) GetField18156() string {
+	if x != nil && x.Field18156 != nil {
+		return *x.Field18156
+	}
+	return ""
+}
+
+func (x *Message17783) GetField18157() string {
+	if x != nil && x.Field18157 != nil {
+		return *x.Field18157
+	}
+	return ""
+}
+
+func (x *Message17783) GetMessage17784() []*Message17783_Message17784 {
+	if x != nil {
+		return x.Message17784
+	}
+	return nil
+}
+
+func (x *Message17783) GetMessage17785() []*Message17783_Message17785 {
+	if x != nil {
+		return x.Message17785
+	}
+	return nil
+}
+
+func (x *Message17783) GetField18160() []string {
+	if x != nil {
+		return x.Field18160
+	}
+	return nil
+}
+
+type Message16945 struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+
+	Field16946 *string               `protobuf:"bytes,1,opt,name=field16946" json:"field16946,omitempty"`
+	Field16947 *string               `protobuf:"bytes,2,opt,name=field16947" json:"field16947,omitempty"`
+	Field16948 *string               `protobuf:"bytes,3,opt,name=field16948" json:"field16948,omitempty"`
+	Field16949 *string               `protobuf:"bytes,4,opt,name=field16949" json:"field16949,omitempty"`
+	Field16950 *string               `protobuf:"bytes,5,opt,name=field16950" json:"field16950,omitempty"`
+	Field16951 *UnusedEmptyMessage   `protobuf:"bytes,872,opt,name=field16951" json:"field16951,omitempty"`
+	Field16952 []*Message0           `protobuf:"bytes,16,rep,name=field16952" json:"field16952,omitempty"`
+	Field16953 []*UnusedEmptyMessage `protobuf:"bytes,54,rep,name=field16953" json:"field16953,omitempty"`
+	Field16954 []*Message0           `protobuf:"bytes,55,rep,name=field16954" json:"field16954,omitempty"`
+	Field16955 []string              `protobuf:"bytes,58,rep,name=field16955" json:"field16955,omitempty"`
+	Field16956 []string              `protobuf:"bytes,59,rep,name=field16956" json:"field16956,omitempty"`
+	Field16957 []string              `protobuf:"bytes,62,rep,name=field16957" json:"field16957,omitempty"`
+	Field16958 []string              `protobuf:"bytes,37,rep,name=field16958" json:"field16958,omitempty"`
+	Field16959 []string              `protobuf:"bytes,18,rep,name=field16959" json:"field16959,omitempty"`
+	Field16960 []*UnusedEmptyMessage `protobuf:"bytes,38,rep,name=field16960" json:"field16960,omitempty"`
+	Field16961 []*Message0           `protobuf:"bytes,67,rep,name=field16961" json:"field16961,omitempty"`
+	Field16962 []*Message0           `protobuf:"bytes,130,rep,name=field16962" json:"field16962,omitempty"`
+	Field16963 []*UnusedEmptyMessage `protobuf:"bytes,136,rep,name=field16963" json:"field16963,omitempty"`
+	Field16964 []string              `protobuf:"bytes,138,rep,name=field16964" json:"field16964,omitempty"`
+	Field16965 []*UnusedEmptyMessage `protobuf:"bytes,156,rep,name=field16965" json:"field16965,omitempty"`
+	Field16966 []string              `protobuf:"bytes,139,rep,name=field16966" json:"field16966,omitempty"`
+	Field16967 []*UnusedEmptyMessage `protobuf:"bytes,126,rep,name=field16967" json:"field16967,omitempty"`
+	Field16968 []string              `protobuf:"bytes,152,rep,name=field16968" json:"field16968,omitempty"`
+	Field16969 []*Message0           `protobuf:"bytes,183,rep,name=field16969" json:"field16969,omitempty"`
+	Field16970 []string              `protobuf:"bytes,168,rep,name=field16970" json:"field16970,omitempty"`
+	Field16971 []string              `protobuf:"bytes,212,rep,name=field16971" json:"field16971,omitempty"`
+	Field16972 []string              `protobuf:"bytes,213,rep,name=field16972" json:"field16972,omitempty"`
+	Field16973 []*UnusedEmptyMessage `protobuf:"bytes,189,rep,name=field16973" json:"field16973,omitempty"`
+	Field16974 []*UnusedEmptyMessage `protobuf:"bytes,190,rep,name=field16974" json:"field16974,omitempty"`
+	Field16975 []string              `protobuf:"bytes,191,rep,name=field16975" json:"field16975,omitempty"`
+	Field16976 []string              `protobuf:"bytes,192,rep,name=field16976" json:"field16976,omitempty"`
+	Field16977 []*Message0           `protobuf:"bytes,193,rep,name=field16977" json:"field16977,omitempty"`
+	Field16978 []*UnusedEmptyMessage `protobuf:"bytes,194,rep,name=field16978" json:"field16978,omitempty"`
+	Field16979 []*UnusedEmptyMessage `protobuf:"bytes,195,rep,name=field16979" json:"field16979,omitempty"`
+	Field16980 []int32               `protobuf:"varint,196,rep,name=field16980" json:"field16980,omitempty"`
+	Field16981 []*UnusedEmptyMessage `protobuf:"bytes,95,rep,name=field16981" json:"field16981,omitempty"`
+	Field16982 []string              `protobuf:"bytes,96,rep,name=field16982" json:"field16982,omitempty"`
+	Field16983 []*UnusedEmptyMessage `protobuf:"bytes,97,rep,name=field16983" json:"field16983,omitempty"`
+	Field16984 []string              `protobuf:"bytes,1086,rep,name=field16984" json:"field16984,omitempty"`
+	Field16985 []*UnusedEmptyMessage `protobuf:"bytes,98,rep,name=field16985" json:"field16985,omitempty"`
+	Field16986 []string              `protobuf:"bytes,99,rep,name=field16986" json:"field16986,omitempty"`
+	Field16987 []string              `protobuf:"bytes,100,rep,name=field16987" json:"field16987,omitempty"`
+	Field16988 []string              `protobuf:"bytes,48,rep,name=field16988" json:"field16988,omitempty"`
+	Field16989 *string               `protobuf:"bytes,22,opt,name=field16989" json:"field16989,omitempty"`
+	Field16990 []*UnusedEmptyMessage `protobuf:"bytes,51,rep,name=field16990" json:"field16990,omitempty"`
+	Field16991 []string              `protobuf:"bytes,81,rep,name=field16991" json:"field16991,omitempty"`
+	Field16992 []string              `protobuf:"bytes,85,rep,name=field16992" json:"field16992,omitempty"`
+	Field16993 []string              `protobuf:"bytes,169,rep,name=field16993" json:"field16993,omitempty"`
+	Field16994 *UnusedEmptyMessage   `protobuf:"bytes,260,opt,name=field16994" json:"field16994,omitempty"`
+	Field16995 *int32                `protobuf:"varint,198,opt,name=field16995" json:"field16995,omitempty"`
+	Field16996 *int32                `protobuf:"varint,204,opt,name=field16996" json:"field16996,omitempty"`
+	Field16997 *string               `protobuf:"bytes,1087,opt,name=field16997" json:"field16997,omitempty"`
+	Field16998 []string              `protobuf:"bytes,197,rep,name=field16998" json:"field16998,omitempty"`
+	Field16999 []string              `protobuf:"bytes,206,rep,name=field16999" json:"field16999,omitempty"`
+	Field17000 *string               `protobuf:"bytes,211,opt,name=field17000" json:"field17000,omitempty"`
+	Field17001 []string              `protobuf:"bytes,205,rep,name=field17001" json:"field17001,omitempty"`
+	Field17002 []*UnusedEmptyMessage `protobuf:"bytes,68,rep,name=field17002" json:"field17002,omitempty"`
+	Field17003 []*UnusedEmptyMessage `protobuf:"bytes,69,rep,name=field17003" json:"field17003,omitempty"`
+	Field17004 []*UnusedEmptyMessage `protobuf:"bytes,70,rep,name=field17004" json:"field17004,omitempty"`
+	Field17005 []*UnusedEmptyMessage `protobuf:"bytes,71,rep,name=field17005" json:"field17005,omitempty"`
+	Field17006 []*UnusedEmptyMessage `protobuf:"bytes,72,rep,name=field17006" json:"field17006,omitempty"`
+	Field17007 []*UnusedEmptyMessage `protobuf:"bytes,19,rep,name=field17007" json:"field17007,omitempty"`
+	Field17008 []*UnusedEmptyMessage `protobuf:"bytes,24,rep,name=field17008" json:"field17008,omitempty"`
+	Field17009 *UnusedEmptyMessage   `protobuf:"bytes,23,opt,name=field17009" json:"field17009,omitempty"`
+	Field17010 []*Message0           `protobuf:"bytes,131,rep,name=field17010" json:"field17010,omitempty"`
+	Field17011 []string              `protobuf:"bytes,133,rep,name=field17011" json:"field17011,omitempty"`
+	Field17012 []*UnusedEmptyMessage `protobuf:"bytes,142,rep,name=field17012" json:"field17012,omitempty"`
+	Field17013 []string              `protobuf:"bytes,143,rep,name=field17013" json:"field17013,omitempty"`
+	Field17014 []*UnusedEmptyMessage `protobuf:"bytes,153,rep,name=field17014" json:"field17014,omitempty"`
+	Field17015 []*Message0           `protobuf:"bytes,170,rep,name=field17015" json:"field17015,omitempty"`
+	Field17016 []string              `protobuf:"bytes,171,rep,name=field17016" json:"field17016,omitempty"`
+	Field17017 []string              `protobuf:"bytes,172,rep,name=field17017" json:"field17017,omitempty"`
+	Field17018 []string              `protobuf:"bytes,173,rep,name=field17018" json:"field17018,omitempty"`
+	Field17019 []string              `protobuf:"bytes,174,rep,name=field17019" json:"field17019,omitempty"`
+	Field17020 []string              `protobuf:"bytes,175,rep,name=field17020" json:"field17020,omitempty"`
+	Field17021 []string              `protobuf:"bytes,186,rep,name=field17021" json:"field17021,omitempty"`
+	Field17022 []string              `protobuf:"bytes,101,rep,name=field17022" json:"field17022,omitempty"`
+	Field17023 []*Message0           `protobuf:"bytes,102,rep,name=field17023" json:"field17023,omitempty"`
+	Field17024 []string              `protobuf:"bytes,274,rep,name=field17024" json:"field17024,omitempty"`
+}
+
+func (x *Message16945) Reset() {
+	*x = Message16945{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[39]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message16945) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message16945) ProtoMessage() {}
+
+func (x *Message16945) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[39]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message16945.ProtoReflect.Descriptor instead.
+func (*Message16945) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{39}
+}
+
+var extRange_Message16945 = []protoiface.ExtensionRangeV1{
+	{Start: 17, End: 17},
+	{Start: 21, End: 21},
+	{Start: 25, End: 25},
+	{Start: 27, End: 27},
+	{Start: 29, End: 29},
+	{Start: 30, End: 30},
+	{Start: 31, End: 31},
+	{Start: 32, End: 32},
+	{Start: 33, End: 33},
+	{Start: 34, End: 34},
+	{Start: 35, End: 35},
+	{Start: 36, End: 36},
+	{Start: 39, End: 39},
+	{Start: 40, End: 40},
+	{Start: 41, End: 41},
+	{Start: 42, End: 42},
+	{Start: 43, End: 43},
+	{Start: 44, End: 44},
+	{Start: 45, End: 45},
+	{Start: 46, End: 46},
+	{Start: 47, End: 47},
+	{Start: 49, End: 49},
+	{Start: 50, End: 50},
+	{Start: 52, End: 52},
+	{Start: 53, End: 53},
+	{Start: 56, End: 56},
+	{Start: 57, End: 57},
+	{Start: 60, End: 60},
+	{Start: 61, End: 61},
+	{Start: 63, End: 63},
+	{Start: 64, End: 64},
+	{Start: 65, End: 65},
+	{Start: 66, End: 66},
+	{Start: 73, End: 73},
+	{Start: 74, End: 74},
+	{Start: 75, End: 75},
+	{Start: 76, End: 76},
+	{Start: 77, End: 77},
+	{Start: 78, End: 78},
+	{Start: 79, End: 79},
+	{Start: 80, End: 80},
+	{Start: 82, End: 82},
+	{Start: 83, End: 83},
+	{Start: 84, End: 84},
+	{Start: 86, End: 86},
+	{Start: 87, End: 87},
+	{Start: 88, End: 88},
+	{Start: 89, End: 89},
+	{Start: 90, End: 90},
+	{Start: 91, End: 91},
+	{Start: 92, End: 92},
+	{Start: 93, End: 93},
+	{Start: 94, End: 94},
+	{Start: 103, End: 103},
+	{Start: 104, End: 104},
+	{Start: 105, End: 105},
+	{Start: 106, End: 106},
+	{Start: 107, End: 107},
+	{Start: 108, End: 108},
+	{Start: 109, End: 109},
+	{Start: 110, End: 110},
+	{Start: 111, End: 111},
+	{Start: 112, End: 112},
+	{Start: 113, End: 113},
+	{Start: 114, End: 114},
+	{Start: 115, End: 115},
+	{Start: 116, End: 116},
+	{Start: 117, End: 117},
+	{Start: 118, End: 118},
+	{Start: 119, End: 119},
+	{Start: 120, End: 120},
+	{Start: 121, End: 121},
+	{Start: 122, End: 122},
+	{Start: 123, End: 123},
+	{Start: 124, End: 124},
+	{Start: 125, End: 125},
+	{Start: 127, End: 127},
+	{Start: 128, End: 128},
+	{Start: 129, End: 129},
+	{Start: 132, End: 132},
+	{Start: 134, End: 134},
+	{Start: 135, End: 135},
+	{Start: 137, End: 137},
+	{Start: 140, End: 140},
+	{Start: 141, End: 141},
+	{Start: 144, End: 144},
+	{Start: 145, End: 145},
+	{Start: 146, End: 146},
+	{Start: 147, End: 147},
+	{Start: 148, End: 148},
+	{Start: 149, End: 149},
+	{Start: 150, End: 150},
+	{Start: 151, End: 151},
+	{Start: 154, End: 154},
+	{Start: 155, End: 155},
+	{Start: 157, End: 157},
+	{Start: 158, End: 158},
+	{Start: 159, End: 159},
+	{Start: 160, End: 160},
+	{Start: 161, End: 161},
+	{Start: 162, End: 162},
+	{Start: 163, End: 163},
+	{Start: 164, End: 164},
+	{Start: 165, End: 165},
+	{Start: 166, End: 166},
+	{Start: 167, End: 167},
+	{Start: 176, End: 176},
+	{Start: 177, End: 177},
+	{Start: 178, End: 178},
+	{Start: 179, End: 179},
+	{Start: 180, End: 180},
+	{Start: 181, End: 181},
+	{Start: 182, End: 182},
+	{Start: 184, End: 184},
+	{Start: 185, End: 185},
+	{Start: 187, End: 187},
+	{Start: 188, End: 188},
+	{Start: 199, End: 199},
+	{Start: 200, End: 200},
+	{Start: 201, End: 201},
+	{Start: 202, End: 202},
+	{Start: 203, End: 203},
+	{Start: 207, End: 207},
+	{Start: 208, End: 208},
+	{Start: 209, End: 209},
+	{Start: 210, End: 210},
+	{Start: 214, End: 214},
+	{Start: 215, End: 215},
+	{Start: 216, End: 216},
+	{Start: 217, End: 217},
+	{Start: 218, End: 218},
+	{Start: 219, End: 219},
+	{Start: 220, End: 220},
+	{Start: 221, End: 221},
+	{Start: 222, End: 222},
+	{Start: 223, End: 223},
+	{Start: 224, End: 224},
+	{Start: 225, End: 225},
+	{Start: 226, End: 226},
+	{Start: 227, End: 227},
+	{Start: 228, End: 228},
+	{Start: 229, End: 229},
+	{Start: 230, End: 230},
+	{Start: 231, End: 231},
+	{Start: 232, End: 232},
+	{Start: 233, End: 233},
+	{Start: 234, End: 234},
+	{Start: 235, End: 235},
+	{Start: 236, End: 236},
+	{Start: 237, End: 237},
+	{Start: 238, End: 238},
+	{Start: 239, End: 239},
+	{Start: 240, End: 240},
+	{Start: 241, End: 241},
+	{Start: 242, End: 242},
+	{Start: 243, End: 243},
+	{Start: 244, End: 244},
+	{Start: 245, End: 245},
+	{Start: 246, End: 246},
+	{Start: 247, End: 247},
+	{Start: 248, End: 248},
+	{Start: 249, End: 249},
+	{Start: 250, End: 250},
+	{Start: 251, End: 251},
+	{Start: 252, End: 252},
+	{Start: 253, End: 253},
+	{Start: 254, End: 254},
+	{Start: 255, End: 255},
+	{Start: 256, End: 256},
+	{Start: 257, End: 257},
+	{Start: 258, End: 258},
+	{Start: 259, End: 259},
+	{Start: 261, End: 261},
+	{Start: 262, End: 262},
+	{Start: 263, End: 263},
+	{Start: 264, End: 264},
+	{Start: 265, End: 265},
+	{Start: 266, End: 266},
+	{Start: 267, End: 267},
+	{Start: 268, End: 268},
+	{Start: 269, End: 269},
+	{Start: 270, End: 270},
+	{Start: 271, End: 271},
+	{Start: 272, End: 272},
+	{Start: 273, End: 273},
+	{Start: 275, End: 275},
+	{Start: 276, End: 276},
+	{Start: 277, End: 277},
+	{Start: 278, End: 278},
+	{Start: 279, End: 279},
+	{Start: 280, End: 280},
+	{Start: 281, End: 281},
+	{Start: 282, End: 282},
+	{Start: 283, End: 283},
+	{Start: 284, End: 284},
+	{Start: 285, End: 285},
+	{Start: 286, End: 286},
+	{Start: 290, End: 290},
+	{Start: 291, End: 291},
+	{Start: 292, End: 292},
+	{Start: 293, End: 293},
+	{Start: 294, End: 294},
+	{Start: 295, End: 295},
+	{Start: 296, End: 296},
+	{Start: 297, End: 297},
+	{Start: 298, End: 298},
+	{Start: 299, End: 299},
+	{Start: 300, End: 300},
+	{Start: 301, End: 301},
+	{Start: 302, End: 302},
+	{Start: 303, End: 303},
+	{Start: 304, End: 304},
+	{Start: 305, End: 305},
+	{Start: 306, End: 306},
+	{Start: 307, End: 307},
+	{Start: 308, End: 308},
+	{Start: 309, End: 309},
+	{Start: 310, End: 310},
+	{Start: 311, End: 311},
+	{Start: 312, End: 312},
+	{Start: 313, End: 313},
+	{Start: 314, End: 314},
+	{Start: 315, End: 315},
+	{Start: 316, End: 316},
+	{Start: 317, End: 317},
+	{Start: 318, End: 318},
+	{Start: 319, End: 319},
+	{Start: 320, End: 320},
+	{Start: 321, End: 321},
+	{Start: 322, End: 322},
+	{Start: 323, End: 323},
+	{Start: 324, End: 324},
+	{Start: 325, End: 325},
+	{Start: 326, End: 326},
+	{Start: 327, End: 327},
+	{Start: 328, End: 328},
+	{Start: 329, End: 329},
+	{Start: 330, End: 330},
+	{Start: 331, End: 331},
+	{Start: 332, End: 332},
+	{Start: 333, End: 333},
+	{Start: 334, End: 334},
+	{Start: 335, End: 335},
+	{Start: 336, End: 336},
+	{Start: 337, End: 337},
+	{Start: 338, End: 338},
+	{Start: 339, End: 339},
+	{Start: 340, End: 340},
+	{Start: 341, End: 341},
+	{Start: 342, End: 342},
+	{Start: 343, End: 343},
+	{Start: 344, End: 344},
+	{Start: 345, End: 345},
+	{Start: 346, End: 346},
+	{Start: 347, End: 347},
+	{Start: 348, End: 348},
+	{Start: 349, End: 349},
+	{Start: 350, End: 350},
+	{Start: 351, End: 351},
+	{Start: 352, End: 352},
+	{Start: 353, End: 353},
+	{Start: 354, End: 354},
+	{Start: 355, End: 355},
+	{Start: 356, End: 356},
+	{Start: 357, End: 357},
+	{Start: 358, End: 358},
+	{Start: 359, End: 359},
+	{Start: 360, End: 360},
+	{Start: 361, End: 361},
+	{Start: 362, End: 362},
+	{Start: 363, End: 363},
+	{Start: 364, End: 364},
+	{Start: 365, End: 365},
+	{Start: 366, End: 366},
+	{Start: 367, End: 367},
+	{Start: 368, End: 368},
+	{Start: 369, End: 369},
+	{Start: 370, End: 370},
+	{Start: 371, End: 371},
+	{Start: 372, End: 372},
+	{Start: 373, End: 373},
+	{Start: 374, End: 374},
+	{Start: 375, End: 375},
+	{Start: 376, End: 376},
+	{Start: 377, End: 377},
+	{Start: 378, End: 378},
+	{Start: 379, End: 379},
+	{Start: 380, End: 380},
+	{Start: 381, End: 381},
+	{Start: 382, End: 382},
+	{Start: 383, End: 383},
+	{Start: 384, End: 384},
+	{Start: 385, End: 385},
+	{Start: 386, End: 386},
+	{Start: 387, End: 387},
+	{Start: 388, End: 388},
+	{Start: 389, End: 389},
+	{Start: 390, End: 390},
+	{Start: 391, End: 391},
+	{Start: 392, End: 392},
+	{Start: 393, End: 393},
+	{Start: 394, End: 394},
+	{Start: 395, End: 395},
+	{Start: 396, End: 396},
+	{Start: 397, End: 397},
+	{Start: 398, End: 398},
+	{Start: 399, End: 399},
+	{Start: 400, End: 400},
+	{Start: 401, End: 401},
+	{Start: 402, End: 402},
+	{Start: 403, End: 403},
+	{Start: 404, End: 404},
+	{Start: 405, End: 405},
+	{Start: 406, End: 406},
+	{Start: 407, End: 407},
+	{Start: 408, End: 408},
+	{Start: 409, End: 409},
+	{Start: 410, End: 410},
+	{Start: 411, End: 411},
+	{Start: 412, End: 412},
+	{Start: 413, End: 413},
+	{Start: 414, End: 414},
+	{Start: 415, End: 415},
+	{Start: 416, End: 416},
+	{Start: 417, End: 417},
+	{Start: 418, End: 418},
+	{Start: 419, End: 419},
+	{Start: 420, End: 420},
+	{Start: 421, End: 421},
+	{Start: 422, End: 422},
+	{Start: 423, End: 423},
+	{Start: 424, End: 424},
+	{Start: 425, End: 425},
+	{Start: 426, End: 426},
+	{Start: 427, End: 427},
+	{Start: 428, End: 428},
+	{Start: 429, End: 429},
+	{Start: 430, End: 430},
+	{Start: 431, End: 431},
+	{Start: 432, End: 432},
+	{Start: 433, End: 433},
+	{Start: 434, End: 434},
+	{Start: 435, End: 435},
+	{Start: 436, End: 436},
+	{Start: 437, End: 437},
+	{Start: 438, End: 438},
+	{Start: 439, End: 439},
+	{Start: 440, End: 440},
+	{Start: 441, End: 441},
+	{Start: 442, End: 442},
+	{Start: 443, End: 443},
+	{Start: 444, End: 444},
+	{Start: 445, End: 445},
+	{Start: 446, End: 446},
+	{Start: 447, End: 447},
+	{Start: 448, End: 448},
+	{Start: 449, End: 449},
+	{Start: 450, End: 450},
+	{Start: 451, End: 451},
+	{Start: 452, End: 452},
+	{Start: 453, End: 453},
+	{Start: 454, End: 454},
+	{Start: 455, End: 455},
+	{Start: 456, End: 456},
+	{Start: 457, End: 457},
+	{Start: 458, End: 458},
+	{Start: 459, End: 459},
+	{Start: 460, End: 460},
+	{Start: 461, End: 461},
+	{Start: 462, End: 462},
+	{Start: 463, End: 463},
+	{Start: 464, End: 464},
+	{Start: 465, End: 465},
+	{Start: 466, End: 466},
+	{Start: 467, End: 467},
+	{Start: 468, End: 468},
+	{Start: 469, End: 469},
+	{Start: 470, End: 470},
+	{Start: 471, End: 471},
+	{Start: 472, End: 472},
+	{Start: 473, End: 473},
+	{Start: 474, End: 474},
+	{Start: 509, End: 509},
+	{Start: 511, End: 511},
+	{Start: 512, End: 512},
+	{Start: 513, End: 513},
+	{Start: 514, End: 514},
+	{Start: 515, End: 515},
+	{Start: 516, End: 516},
+	{Start: 517, End: 517},
+	{Start: 518, End: 518},
+	{Start: 519, End: 519},
+	{Start: 520, End: 520},
+	{Start: 521, End: 521},
+	{Start: 522, End: 522},
+	{Start: 523, End: 523},
+	{Start: 524, End: 524},
+	{Start: 525, End: 525},
+	{Start: 526, End: 526},
+	{Start: 527, End: 527},
+	{Start: 528, End: 528},
+	{Start: 529, End: 529},
+	{Start: 530, End: 530},
+	{Start: 531, End: 531},
+	{Start: 532, End: 532},
+	{Start: 533, End: 533},
+	{Start: 534, End: 534},
+	{Start: 535, End: 535},
+	{Start: 536, End: 536},
+	{Start: 537, End: 537},
+	{Start: 538, End: 538},
+	{Start: 539, End: 539},
+	{Start: 540, End: 540},
+	{Start: 541, End: 541},
+	{Start: 542, End: 542},
+	{Start: 543, End: 543},
+	{Start: 544, End: 544},
+	{Start: 545, End: 545},
+	{Start: 546, End: 546},
+	{Start: 547, End: 547},
+	{Start: 548, End: 548},
+	{Start: 549, End: 549},
+	{Start: 550, End: 550},
+	{Start: 551, End: 551},
+	{Start: 552, End: 552},
+	{Start: 553, End: 553},
+	{Start: 554, End: 554},
+	{Start: 555, End: 555},
+	{Start: 556, End: 556},
+	{Start: 557, End: 557},
+	{Start: 558, End: 558},
+	{Start: 559, End: 559},
+	{Start: 560, End: 560},
+	{Start: 561, End: 561},
+	{Start: 562, End: 562},
+	{Start: 563, End: 563},
+	{Start: 564, End: 564},
+	{Start: 565, End: 565},
+	{Start: 566, End: 566},
+	{Start: 567, End: 567},
+	{Start: 568, End: 568},
+	{Start: 569, End: 569},
+	{Start: 570, End: 570},
+	{Start: 571, End: 571},
+	{Start: 572, End: 572},
+	{Start: 573, End: 573},
+	{Start: 574, End: 574},
+	{Start: 575, End: 575},
+	{Start: 576, End: 576},
+	{Start: 577, End: 577},
+	{Start: 578, End: 578},
+	{Start: 579, End: 579},
+	{Start: 580, End: 580},
+	{Start: 581, End: 581},
+	{Start: 582, End: 582},
+	{Start: 583, End: 583},
+	{Start: 584, End: 584},
+	{Start: 585, End: 585},
+	{Start: 586, End: 586},
+	{Start: 587, End: 587},
+	{Start: 588, End: 588},
+	{Start: 589, End: 589},
+	{Start: 590, End: 590},
+	{Start: 604, End: 604},
+	{Start: 605, End: 605},
+	{Start: 606, End: 606},
+	{Start: 607, End: 607},
+	{Start: 608, End: 608},
+	{Start: 609, End: 609},
+	{Start: 610, End: 610},
+	{Start: 611, End: 611},
+	{Start: 612, End: 612},
+	{Start: 613, End: 613},
+	{Start: 614, End: 614},
+	{Start: 615, End: 615},
+	{Start: 616, End: 616},
+	{Start: 617, End: 617},
+	{Start: 618, End: 618},
+	{Start: 619, End: 619},
+	{Start: 620, End: 620},
+	{Start: 621, End: 621},
+	{Start: 622, End: 622},
+	{Start: 623, End: 623},
+	{Start: 624, End: 624},
+	{Start: 625, End: 625},
+	{Start: 626, End: 626},
+	{Start: 627, End: 627},
+	{Start: 628, End: 628},
+	{Start: 629, End: 629},
+	{Start: 813, End: 813},
+	{Start: 814, End: 814},
+	{Start: 815, End: 815},
+	{Start: 816, End: 816},
+	{Start: 817, End: 817},
+	{Start: 818, End: 818},
+	{Start: 819, End: 819},
+	{Start: 820, End: 820},
+	{Start: 821, End: 821},
+	{Start: 822, End: 822},
+	{Start: 823, End: 823},
+	{Start: 824, End: 824},
+	{Start: 827, End: 827},
+	{Start: 828, End: 828},
+	{Start: 829, End: 829},
+	{Start: 830, End: 830},
+	{Start: 831, End: 831},
+	{Start: 832, End: 832},
+	{Start: 833, End: 833},
+	{Start: 834, End: 834},
+	{Start: 835, End: 835},
+	{Start: 836, End: 836},
+	{Start: 837, End: 837},
+	{Start: 838, End: 838},
+	{Start: 839, End: 839},
+	{Start: 840, End: 840},
+	{Start: 841, End: 841},
+	{Start: 842, End: 842},
+	{Start: 843, End: 843},
+	{Start: 844, End: 844},
+	{Start: 845, End: 845},
+	{Start: 846, End: 846},
+	{Start: 847, End: 847},
+	{Start: 848, End: 848},
+	{Start: 849, End: 849},
+	{Start: 850, End: 850},
+	{Start: 851, End: 851},
+	{Start: 852, End: 852},
+	{Start: 853, End: 853},
+	{Start: 854, End: 854},
+	{Start: 855, End: 855},
+	{Start: 856, End: 856},
+	{Start: 857, End: 857},
+	{Start: 858, End: 858},
+	{Start: 859, End: 859},
+	{Start: 860, End: 860},
+	{Start: 861, End: 861},
+	{Start: 862, End: 862},
+	{Start: 863, End: 863},
+	{Start: 864, End: 864},
+	{Start: 865, End: 865},
+	{Start: 866, End: 866},
+	{Start: 867, End: 867},
+	{Start: 868, End: 868},
+	{Start: 869, End: 869},
+	{Start: 870, End: 870},
+	{Start: 871, End: 871},
+	{Start: 880, End: 880},
+	{Start: 881, End: 881},
+	{Start: 882, End: 882},
+	{Start: 883, End: 883},
+	{Start: 884, End: 884},
+	{Start: 885, End: 885},
+	{Start: 886, End: 886},
+	{Start: 887, End: 887},
+	{Start: 888, End: 888},
+	{Start: 890, End: 890},
+	{Start: 891, End: 891},
+	{Start: 892, End: 892},
+	{Start: 912, End: 912},
+	{Start: 914, End: 914},
+	{Start: 915, End: 915},
+	{Start: 916, End: 916},
+	{Start: 917, End: 917},
+	{Start: 918, End: 918},
+	{Start: 919, End: 919},
+	{Start: 920, End: 920},
+	{Start: 921, End: 921},
+	{Start: 922, End: 922},
+	{Start: 923, End: 923},
+	{Start: 924, End: 924},
+	{Start: 925, End: 925},
+	{Start: 926, End: 926},
+	{Start: 927, End: 927},
+	{Start: 928, End: 928},
+	{Start: 929, End: 929},
+	{Start: 930, End: 930},
+	{Start: 931, End: 931},
+	{Start: 932, End: 932},
+	{Start: 933, End: 933},
+	{Start: 934, End: 934},
+	{Start: 935, End: 935},
+	{Start: 936, End: 936},
+	{Start: 937, End: 937},
+	{Start: 938, End: 938},
+	{Start: 939, End: 939},
+	{Start: 940, End: 940},
+	{Start: 941, End: 941},
+	{Start: 942, End: 942},
+	{Start: 943, End: 943},
+	{Start: 944, End: 944},
+	{Start: 945, End: 945},
+	{Start: 946, End: 946},
+	{Start: 947, End: 947},
+	{Start: 949, End: 949},
+	{Start: 950, End: 950},
+	{Start: 951, End: 951},
+	{Start: 952, End: 952},
+	{Start: 954, End: 954},
+	{Start: 955, End: 955},
+	{Start: 956, End: 956},
+	{Start: 957, End: 957},
+	{Start: 958, End: 958},
+	{Start: 959, End: 959},
+	{Start: 960, End: 960},
+	{Start: 961, End: 961},
+	{Start: 962, End: 962},
+	{Start: 963, End: 963},
+	{Start: 964, End: 964},
+	{Start: 965, End: 965},
+	{Start: 966, End: 966},
+	{Start: 967, End: 967},
+	{Start: 968, End: 968},
+	{Start: 969, End: 969},
+	{Start: 970, End: 970},
+	{Start: 971, End: 971},
+	{Start: 972, End: 972},
+	{Start: 973, End: 973},
+	{Start: 974, End: 974},
+	{Start: 975, End: 975},
+	{Start: 976, End: 976},
+	{Start: 977, End: 977},
+	{Start: 978, End: 978},
+	{Start: 979, End: 979},
+	{Start: 980, End: 980},
+	{Start: 981, End: 981},
+	{Start: 982, End: 982},
+	{Start: 983, End: 983},
+	{Start: 984, End: 984},
+	{Start: 985, End: 985},
+	{Start: 987, End: 987},
+	{Start: 988, End: 988},
+	{Start: 1000, End: 1000},
+	{Start: 1001, End: 1001},
+	{Start: 1002, End: 1002},
+	{Start: 1003, End: 1003},
+	{Start: 1004, End: 1004},
+	{Start: 1005, End: 1005},
+	{Start: 1006, End: 1006},
+	{Start: 1007, End: 1007},
+	{Start: 1008, End: 1008},
+	{Start: 1009, End: 1009},
+	{Start: 1010, End: 1010},
+	{Start: 1011, End: 1011},
+	{Start: 1012, End: 1012},
+	{Start: 1013, End: 1013},
+	{Start: 1014, End: 1014},
+	{Start: 1015, End: 1015},
+	{Start: 1016, End: 1016},
+	{Start: 1017, End: 1017},
+	{Start: 1018, End: 1018},
+	{Start: 1019, End: 1019},
+	{Start: 1020, End: 1020},
+	{Start: 1021, End: 1021},
+	{Start: 1022, End: 1022},
+	{Start: 1023, End: 1023},
+	{Start: 1024, End: 1024},
+	{Start: 1025, End: 1025},
+	{Start: 1026, End: 1026},
+	{Start: 1027, End: 1027},
+	{Start: 1028, End: 1028},
+	{Start: 1029, End: 1029},
+	{Start: 1030, End: 1030},
+	{Start: 1031, End: 1031},
+	{Start: 1032, End: 1032},
+	{Start: 1033, End: 1033},
+	{Start: 1034, End: 1034},
+	{Start: 1035, End: 1035},
+	{Start: 1036, End: 1036},
+	{Start: 1037, End: 1037},
+	{Start: 1038, End: 1038},
+	{Start: 1039, End: 1039},
+	{Start: 1040, End: 1040},
+	{Start: 1041, End: 1041},
+	{Start: 1042, End: 1042},
+	{Start: 1043, End: 1043},
+	{Start: 1044, End: 1044},
+	{Start: 1045, End: 1045},
+	{Start: 1046, End: 1046},
+	{Start: 1047, End: 1047},
+	{Start: 1048, End: 1048},
+	{Start: 1049, End: 1049},
+	{Start: 1050, End: 1050},
+	{Start: 1051, End: 1051},
+	{Start: 1052, End: 1052},
+	{Start: 1053, End: 1053},
+	{Start: 1054, End: 1054},
+	{Start: 1055, End: 1055},
+	{Start: 1056, End: 1056},
+	{Start: 1057, End: 1057},
+	{Start: 1058, End: 1058},
+	{Start: 1079, End: 1079},
+	{Start: 1080, End: 1080},
+	{Start: 1081, End: 1081},
+	{Start: 1082, End: 1082},
+	{Start: 1083, End: 1083},
+	{Start: 1084, End: 1084},
+	{Start: 1085, End: 1085},
+}
+
+// Deprecated: Use Message16945.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*Message16945) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_Message16945
+}
+
+func (x *Message16945) GetField16946() string {
+	if x != nil && x.Field16946 != nil {
+		return *x.Field16946
+	}
+	return ""
+}
+
+func (x *Message16945) GetField16947() string {
+	if x != nil && x.Field16947 != nil {
+		return *x.Field16947
+	}
+	return ""
+}
+
+func (x *Message16945) GetField16948() string {
+	if x != nil && x.Field16948 != nil {
+		return *x.Field16948
+	}
+	return ""
+}
+
+func (x *Message16945) GetField16949() string {
+	if x != nil && x.Field16949 != nil {
+		return *x.Field16949
+	}
+	return ""
+}
+
+func (x *Message16945) GetField16950() string {
+	if x != nil && x.Field16950 != nil {
+		return *x.Field16950
+	}
+	return ""
+}
+
+func (x *Message16945) GetField16951() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field16951
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16952() []*Message0 {
+	if x != nil {
+		return x.Field16952
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16953() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field16953
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16954() []*Message0 {
+	if x != nil {
+		return x.Field16954
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16955() []string {
+	if x != nil {
+		return x.Field16955
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16956() []string {
+	if x != nil {
+		return x.Field16956
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16957() []string {
+	if x != nil {
+		return x.Field16957
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16958() []string {
+	if x != nil {
+		return x.Field16958
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16959() []string {
+	if x != nil {
+		return x.Field16959
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16960() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field16960
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16961() []*Message0 {
+	if x != nil {
+		return x.Field16961
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16962() []*Message0 {
+	if x != nil {
+		return x.Field16962
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16963() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field16963
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16964() []string {
+	if x != nil {
+		return x.Field16964
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16965() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field16965
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16966() []string {
+	if x != nil {
+		return x.Field16966
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16967() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field16967
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16968() []string {
+	if x != nil {
+		return x.Field16968
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16969() []*Message0 {
+	if x != nil {
+		return x.Field16969
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16970() []string {
+	if x != nil {
+		return x.Field16970
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16971() []string {
+	if x != nil {
+		return x.Field16971
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16972() []string {
+	if x != nil {
+		return x.Field16972
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16973() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field16973
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16974() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field16974
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16975() []string {
+	if x != nil {
+		return x.Field16975
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16976() []string {
+	if x != nil {
+		return x.Field16976
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16977() []*Message0 {
+	if x != nil {
+		return x.Field16977
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16978() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field16978
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16979() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field16979
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16980() []int32 {
+	if x != nil {
+		return x.Field16980
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16981() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field16981
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16982() []string {
+	if x != nil {
+		return x.Field16982
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16983() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field16983
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16984() []string {
+	if x != nil {
+		return x.Field16984
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16985() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field16985
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16986() []string {
+	if x != nil {
+		return x.Field16986
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16987() []string {
+	if x != nil {
+		return x.Field16987
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16988() []string {
+	if x != nil {
+		return x.Field16988
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16989() string {
+	if x != nil && x.Field16989 != nil {
+		return *x.Field16989
+	}
+	return ""
+}
+
+func (x *Message16945) GetField16990() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field16990
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16991() []string {
+	if x != nil {
+		return x.Field16991
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16992() []string {
+	if x != nil {
+		return x.Field16992
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16993() []string {
+	if x != nil {
+		return x.Field16993
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16994() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field16994
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16995() int32 {
+	if x != nil && x.Field16995 != nil {
+		return *x.Field16995
+	}
+	return 0
+}
+
+func (x *Message16945) GetField16996() int32 {
+	if x != nil && x.Field16996 != nil {
+		return *x.Field16996
+	}
+	return 0
+}
+
+func (x *Message16945) GetField16997() string {
+	if x != nil && x.Field16997 != nil {
+		return *x.Field16997
+	}
+	return ""
+}
+
+func (x *Message16945) GetField16998() []string {
+	if x != nil {
+		return x.Field16998
+	}
+	return nil
+}
+
+func (x *Message16945) GetField16999() []string {
+	if x != nil {
+		return x.Field16999
+	}
+	return nil
+}
+
+func (x *Message16945) GetField17000() string {
+	if x != nil && x.Field17000 != nil {
+		return *x.Field17000
+	}
+	return ""
+}
+
+func (x *Message16945) GetField17001() []string {
+	if x != nil {
+		return x.Field17001
+	}
+	return nil
+}
+
+func (x *Message16945) GetField17002() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field17002
+	}
+	return nil
+}
+
+func (x *Message16945) GetField17003() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field17003
+	}
+	return nil
+}
+
+func (x *Message16945) GetField17004() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field17004
+	}
+	return nil
+}
+
+func (x *Message16945) GetField17005() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field17005
+	}
+	return nil
+}
+
+func (x *Message16945) GetField17006() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field17006
+	}
+	return nil
+}
+
+func (x *Message16945) GetField17007() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field17007
+	}
+	return nil
+}
+
+func (x *Message16945) GetField17008() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field17008
+	}
+	return nil
+}
+
+func (x *Message16945) GetField17009() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field17009
+	}
+	return nil
+}
+
+func (x *Message16945) GetField17010() []*Message0 {
+	if x != nil {
+		return x.Field17010
+	}
+	return nil
+}
+
+func (x *Message16945) GetField17011() []string {
+	if x != nil {
+		return x.Field17011
+	}
+	return nil
+}
+
+func (x *Message16945) GetField17012() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field17012
+	}
+	return nil
+}
+
+func (x *Message16945) GetField17013() []string {
+	if x != nil {
+		return x.Field17013
+	}
+	return nil
+}
+
+func (x *Message16945) GetField17014() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field17014
+	}
+	return nil
+}
+
+func (x *Message16945) GetField17015() []*Message0 {
+	if x != nil {
+		return x.Field17015
+	}
+	return nil
+}
+
+func (x *Message16945) GetField17016() []string {
+	if x != nil {
+		return x.Field17016
+	}
+	return nil
+}
+
+func (x *Message16945) GetField17017() []string {
+	if x != nil {
+		return x.Field17017
+	}
+	return nil
+}
+
+func (x *Message16945) GetField17018() []string {
+	if x != nil {
+		return x.Field17018
+	}
+	return nil
+}
+
+func (x *Message16945) GetField17019() []string {
+	if x != nil {
+		return x.Field17019
+	}
+	return nil
+}
+
+func (x *Message16945) GetField17020() []string {
+	if x != nil {
+		return x.Field17020
+	}
+	return nil
+}
+
+func (x *Message16945) GetField17021() []string {
+	if x != nil {
+		return x.Field17021
+	}
+	return nil
+}
+
+func (x *Message16945) GetField17022() []string {
+	if x != nil {
+		return x.Field17022
+	}
+	return nil
+}
+
+func (x *Message16945) GetField17023() []*Message0 {
+	if x != nil {
+		return x.Field17023
+	}
+	return nil
+}
+
+func (x *Message16945) GetField17024() []string {
+	if x != nil {
+		return x.Field17024
+	}
+	return nil
+}
+
+type Message34791_Message34792 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field34808 *string `protobuf:"bytes,3,req,name=field34808" json:"field34808,omitempty"`
+	Field34809 *string `protobuf:"bytes,4,opt,name=field34809" json:"field34809,omitempty"`
+}
+
+func (x *Message34791_Message34792) Reset() {
+	*x = Message34791_Message34792{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[40]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message34791_Message34792) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message34791_Message34792) ProtoMessage() {}
+
+func (x *Message34791_Message34792) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[40]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message34791_Message34792.ProtoReflect.Descriptor instead.
+func (*Message34791_Message34792) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{2, 0}
+}
+
+func (x *Message34791_Message34792) GetField34808() string {
+	if x != nil && x.Field34808 != nil {
+		return *x.Field34808
+	}
+	return ""
+}
+
+func (x *Message34791_Message34792) GetField34809() string {
+	if x != nil && x.Field34809 != nil {
+		return *x.Field34809
+	}
+	return ""
+}
+
+type Message36876_Message36877 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field37044 *string `protobuf:"bytes,112,req,name=field37044" json:"field37044,omitempty"`
+	Field37045 *int32  `protobuf:"varint,113,opt,name=field37045" json:"field37045,omitempty"`
+	Field37046 []byte  `protobuf:"bytes,114,opt,name=field37046" json:"field37046,omitempty"`
+	Field37047 *int32  `protobuf:"varint,115,opt,name=field37047" json:"field37047,omitempty"`
+	Field37048 *int32  `protobuf:"varint,157,opt,name=field37048" json:"field37048,omitempty"`
+}
+
+func (x *Message36876_Message36877) Reset() {
+	*x = Message36876_Message36877{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[41]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message36876_Message36877) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message36876_Message36877) ProtoMessage() {}
+
+func (x *Message36876_Message36877) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[41]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message36876_Message36877.ProtoReflect.Descriptor instead.
+func (*Message36876_Message36877) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{8, 0}
+}
+
+func (x *Message36876_Message36877) GetField37044() string {
+	if x != nil && x.Field37044 != nil {
+		return *x.Field37044
+	}
+	return ""
+}
+
+func (x *Message36876_Message36877) GetField37045() int32 {
+	if x != nil && x.Field37045 != nil {
+		return *x.Field37045
+	}
+	return 0
+}
+
+func (x *Message36876_Message36877) GetField37046() []byte {
+	if x != nil {
+		return x.Field37046
+	}
+	return nil
+}
+
+func (x *Message36876_Message36877) GetField37047() int32 {
+	if x != nil && x.Field37047 != nil {
+		return *x.Field37047
+	}
+	return 0
+}
+
+func (x *Message36876_Message36877) GetField37048() int32 {
+	if x != nil && x.Field37048 != nil {
+		return *x.Field37048
+	}
+	return 0
+}
+
+type Message36876_Message36878 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message36876_Message36878) Reset() {
+	*x = Message36876_Message36878{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[42]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message36876_Message36878) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message36876_Message36878) ProtoMessage() {}
+
+func (x *Message36876_Message36878) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[42]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message36876_Message36878.ProtoReflect.Descriptor instead.
+func (*Message36876_Message36878) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{8, 1}
+}
+
+type Message36876_Message36879 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field37050 *string `protobuf:"bytes,56,req,name=field37050" json:"field37050,omitempty"`
+	Field37051 *int32  `protobuf:"varint,69,opt,name=field37051" json:"field37051,omitempty"`
+}
+
+func (x *Message36876_Message36879) Reset() {
+	*x = Message36876_Message36879{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[43]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message36876_Message36879) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message36876_Message36879) ProtoMessage() {}
+
+func (x *Message36876_Message36879) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[43]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message36876_Message36879.ProtoReflect.Descriptor instead.
+func (*Message36876_Message36879) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{8, 2}
+}
+
+func (x *Message36876_Message36879) GetField37050() string {
+	if x != nil && x.Field37050 != nil {
+		return *x.Field37050
+	}
+	return ""
+}
+
+func (x *Message36876_Message36879) GetField37051() int32 {
+	if x != nil && x.Field37051 != nil {
+		return *x.Field37051
+	}
+	return 0
+}
+
+type Message36876_Message36880 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message36876_Message36880) Reset() {
+	*x = Message36876_Message36880{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[44]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message36876_Message36880) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message36876_Message36880) ProtoMessage() {}
+
+func (x *Message36876_Message36880) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[44]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message36876_Message36880.ProtoReflect.Descriptor instead.
+func (*Message36876_Message36880) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{8, 3}
+}
+
+type Message36876_Message36881 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message36876_Message36881) Reset() {
+	*x = Message36876_Message36881{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[45]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message36876_Message36881) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message36876_Message36881) ProtoMessage() {}
+
+func (x *Message36876_Message36881) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[45]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message36876_Message36881.ProtoReflect.Descriptor instead.
+func (*Message36876_Message36881) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{8, 4}
+}
+
+type Message36876_Message36882 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message36876_Message36882) Reset() {
+	*x = Message36876_Message36882{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[46]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message36876_Message36882) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message36876_Message36882) ProtoMessage() {}
+
+func (x *Message36876_Message36882) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[46]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message36876_Message36882.ProtoReflect.Descriptor instead.
+func (*Message36876_Message36882) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{8, 5}
+}
+
+type Message36876_Message36883 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message36876_Message36883) Reset() {
+	*x = Message36876_Message36883{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[47]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message36876_Message36883) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message36876_Message36883) ProtoMessage() {}
+
+func (x *Message36876_Message36883) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[47]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message36876_Message36883.ProtoReflect.Descriptor instead.
+func (*Message36876_Message36883) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{8, 6}
+}
+
+type Message36876_Message36884 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message36876_Message36884) Reset() {
+	*x = Message36876_Message36884{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[48]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message36876_Message36884) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message36876_Message36884) ProtoMessage() {}
+
+func (x *Message36876_Message36884) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[48]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message36876_Message36884.ProtoReflect.Descriptor instead.
+func (*Message36876_Message36884) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{8, 7}
+}
+
+type Message36876_Message36885 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message36876_Message36885) Reset() {
+	*x = Message36876_Message36885{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[49]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message36876_Message36885) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message36876_Message36885) ProtoMessage() {}
+
+func (x *Message36876_Message36885) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[49]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message36876_Message36885.ProtoReflect.Descriptor instead.
+func (*Message36876_Message36885) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{8, 8}
+}
+
+type Message36876_Message36886 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message36876_Message36886) Reset() {
+	*x = Message36876_Message36886{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[50]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message36876_Message36886) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message36876_Message36886) ProtoMessage() {}
+
+func (x *Message36876_Message36886) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[50]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message36876_Message36886.ProtoReflect.Descriptor instead.
+func (*Message36876_Message36886) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{8, 9}
+}
+
+type Message36876_Message36887 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message36876_Message36887) Reset() {
+	*x = Message36876_Message36887{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[51]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message36876_Message36887) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message36876_Message36887) ProtoMessage() {}
+
+func (x *Message36876_Message36887) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[51]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message36876_Message36887.ProtoReflect.Descriptor instead.
+func (*Message36876_Message36887) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{8, 10}
+}
+
+type Message36876_Message36888 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field37089 *uint64  `protobuf:"varint,75,opt,name=field37089" json:"field37089,omitempty"`
+	Field37090 *bool    `protobuf:"varint,76,opt,name=field37090" json:"field37090,omitempty"`
+	Field37091 *uint64  `protobuf:"varint,165,opt,name=field37091" json:"field37091,omitempty"`
+	Field37092 *float64 `protobuf:"fixed64,166,opt,name=field37092" json:"field37092,omitempty"`
+	Field37093 *uint64  `protobuf:"varint,109,opt,name=field37093" json:"field37093,omitempty"`
+	Field37094 []byte   `protobuf:"bytes,122,opt,name=field37094" json:"field37094,omitempty"`
+}
+
+func (x *Message36876_Message36888) Reset() {
+	*x = Message36876_Message36888{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[52]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message36876_Message36888) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message36876_Message36888) ProtoMessage() {}
+
+func (x *Message36876_Message36888) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[52]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message36876_Message36888.ProtoReflect.Descriptor instead.
+func (*Message36876_Message36888) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{8, 11}
+}
+
+func (x *Message36876_Message36888) GetField37089() uint64 {
+	if x != nil && x.Field37089 != nil {
+		return *x.Field37089
+	}
+	return 0
+}
+
+func (x *Message36876_Message36888) GetField37090() bool {
+	if x != nil && x.Field37090 != nil {
+		return *x.Field37090
+	}
+	return false
+}
+
+func (x *Message36876_Message36888) GetField37091() uint64 {
+	if x != nil && x.Field37091 != nil {
+		return *x.Field37091
+	}
+	return 0
+}
+
+func (x *Message36876_Message36888) GetField37092() float64 {
+	if x != nil && x.Field37092 != nil {
+		return *x.Field37092
+	}
+	return 0
+}
+
+func (x *Message36876_Message36888) GetField37093() uint64 {
+	if x != nil && x.Field37093 != nil {
+		return *x.Field37093
+	}
+	return 0
+}
+
+func (x *Message36876_Message36888) GetField37094() []byte {
+	if x != nil {
+		return x.Field37094
+	}
+	return nil
+}
+
+type Message36876_Message36889 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field37095 *int64              `protobuf:"varint,117,opt,name=field37095" json:"field37095,omitempty"`
+	Field37096 *string             `protobuf:"bytes,145,opt,name=field37096" json:"field37096,omitempty"`
+	Field37097 *int32              `protobuf:"varint,123,opt,name=field37097" json:"field37097,omitempty"`
+	Field37098 *bool               `protobuf:"varint,163,opt,name=field37098" json:"field37098,omitempty"`
+	Field37099 *int32              `protobuf:"varint,164,opt,name=field37099" json:"field37099,omitempty"`
+	Field37100 *int32              `protobuf:"varint,149,opt,name=field37100" json:"field37100,omitempty"`
+	Field37101 *UnusedEmptyMessage `protobuf:"bytes,129,opt,name=field37101" json:"field37101,omitempty"`
+	Field37102 *Message13174       `protobuf:"bytes,124,opt,name=field37102" json:"field37102,omitempty"`
+	Field37103 *Message13169       `protobuf:"bytes,128,opt,name=field37103" json:"field37103,omitempty"`
+	Field37104 *uint64             `protobuf:"varint,132,opt,name=field37104" json:"field37104,omitempty"`
+	Field37105 []Enum36890         `protobuf:"varint,131,rep,name=field37105,enum=benchmarks.google_message3.Enum36890" json:"field37105,omitempty"`
+	Field37106 *bool               `protobuf:"varint,134,opt,name=field37106" json:"field37106,omitempty"`
+	Field37107 *bool               `protobuf:"varint,140,opt,name=field37107" json:"field37107,omitempty"`
+	Field37108 *UnusedEmptyMessage `protobuf:"bytes,135,opt,name=field37108" json:"field37108,omitempty"`
+	Field37109 *float32            `protobuf:"fixed32,136,opt,name=field37109" json:"field37109,omitempty"`
+	Field37110 *float32            `protobuf:"fixed32,156,opt,name=field37110" json:"field37110,omitempty"`
+	Field37111 *bool               `protobuf:"varint,142,opt,name=field37111" json:"field37111,omitempty"`
+	Field37112 *int64              `protobuf:"varint,167,opt,name=field37112" json:"field37112,omitempty"`
+	Field37113 *UnusedEmptyMessage `protobuf:"bytes,146,opt,name=field37113" json:"field37113,omitempty"`
+	Field37114 *bool               `protobuf:"varint,148,opt,name=field37114" json:"field37114,omitempty"`
+	Field37115 *UnusedEmptyMessage `protobuf:"bytes,154,opt,name=field37115" json:"field37115,omitempty"`
+	Field37116 *UnusedEnum         `protobuf:"varint,158,opt,name=field37116,enum=benchmarks.google_message3.UnusedEnum" json:"field37116,omitempty"`
+	Field37117 []UnusedEnum        `protobuf:"varint,159,rep,name=field37117,enum=benchmarks.google_message3.UnusedEnum" json:"field37117,omitempty"`
+	Field37118 *int32              `protobuf:"varint,160,opt,name=field37118" json:"field37118,omitempty"`
+	Field37119 []string            `protobuf:"bytes,161,rep,name=field37119" json:"field37119,omitempty"`
+}
+
+func (x *Message36876_Message36889) Reset() {
+	*x = Message36876_Message36889{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[53]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message36876_Message36889) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message36876_Message36889) ProtoMessage() {}
+
+func (x *Message36876_Message36889) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[53]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message36876_Message36889.ProtoReflect.Descriptor instead.
+func (*Message36876_Message36889) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{8, 12}
+}
+
+func (x *Message36876_Message36889) GetField37095() int64 {
+	if x != nil && x.Field37095 != nil {
+		return *x.Field37095
+	}
+	return 0
+}
+
+func (x *Message36876_Message36889) GetField37096() string {
+	if x != nil && x.Field37096 != nil {
+		return *x.Field37096
+	}
+	return ""
+}
+
+func (x *Message36876_Message36889) GetField37097() int32 {
+	if x != nil && x.Field37097 != nil {
+		return *x.Field37097
+	}
+	return 0
+}
+
+func (x *Message36876_Message36889) GetField37098() bool {
+	if x != nil && x.Field37098 != nil {
+		return *x.Field37098
+	}
+	return false
+}
+
+func (x *Message36876_Message36889) GetField37099() int32 {
+	if x != nil && x.Field37099 != nil {
+		return *x.Field37099
+	}
+	return 0
+}
+
+func (x *Message36876_Message36889) GetField37100() int32 {
+	if x != nil && x.Field37100 != nil {
+		return *x.Field37100
+	}
+	return 0
+}
+
+func (x *Message36876_Message36889) GetField37101() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37101
+	}
+	return nil
+}
+
+func (x *Message36876_Message36889) GetField37102() *Message13174 {
+	if x != nil {
+		return x.Field37102
+	}
+	return nil
+}
+
+func (x *Message36876_Message36889) GetField37103() *Message13169 {
+	if x != nil {
+		return x.Field37103
+	}
+	return nil
+}
+
+func (x *Message36876_Message36889) GetField37104() uint64 {
+	if x != nil && x.Field37104 != nil {
+		return *x.Field37104
+	}
+	return 0
+}
+
+func (x *Message36876_Message36889) GetField37105() []Enum36890 {
+	if x != nil {
+		return x.Field37105
+	}
+	return nil
+}
+
+func (x *Message36876_Message36889) GetField37106() bool {
+	if x != nil && x.Field37106 != nil {
+		return *x.Field37106
+	}
+	return false
+}
+
+func (x *Message36876_Message36889) GetField37107() bool {
+	if x != nil && x.Field37107 != nil {
+		return *x.Field37107
+	}
+	return false
+}
+
+func (x *Message36876_Message36889) GetField37108() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37108
+	}
+	return nil
+}
+
+func (x *Message36876_Message36889) GetField37109() float32 {
+	if x != nil && x.Field37109 != nil {
+		return *x.Field37109
+	}
+	return 0
+}
+
+func (x *Message36876_Message36889) GetField37110() float32 {
+	if x != nil && x.Field37110 != nil {
+		return *x.Field37110
+	}
+	return 0
+}
+
+func (x *Message36876_Message36889) GetField37111() bool {
+	if x != nil && x.Field37111 != nil {
+		return *x.Field37111
+	}
+	return false
+}
+
+func (x *Message36876_Message36889) GetField37112() int64 {
+	if x != nil && x.Field37112 != nil {
+		return *x.Field37112
+	}
+	return 0
+}
+
+func (x *Message36876_Message36889) GetField37113() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37113
+	}
+	return nil
+}
+
+func (x *Message36876_Message36889) GetField37114() bool {
+	if x != nil && x.Field37114 != nil {
+		return *x.Field37114
+	}
+	return false
+}
+
+func (x *Message36876_Message36889) GetField37115() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37115
+	}
+	return nil
+}
+
+func (x *Message36876_Message36889) GetField37116() UnusedEnum {
+	if x != nil && x.Field37116 != nil {
+		return *x.Field37116
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+func (x *Message36876_Message36889) GetField37117() []UnusedEnum {
+	if x != nil {
+		return x.Field37117
+	}
+	return nil
+}
+
+func (x *Message36876_Message36889) GetField37118() int32 {
+	if x != nil && x.Field37118 != nil {
+		return *x.Field37118
+	}
+	return 0
+}
+
+func (x *Message36876_Message36889) GetField37119() []string {
+	if x != nil {
+		return x.Field37119
+	}
+	return nil
+}
+
+type Message36876_Message36910 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message36876_Message36910) Reset() {
+	*x = Message36876_Message36910{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[54]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message36876_Message36910) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message36876_Message36910) ProtoMessage() {}
+
+func (x *Message36876_Message36910) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[54]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message36876_Message36910.ProtoReflect.Descriptor instead.
+func (*Message36876_Message36910) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{8, 13}
+}
+
+type Message36876_Message36911 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field37121 *UnusedEmptyMessage `protobuf:"bytes,127,opt,name=field37121" json:"field37121,omitempty"`
+	Field37122 *Message35538       `protobuf:"bytes,130,opt,name=field37122" json:"field37122,omitempty"`
+	Field37123 *Message35540       `protobuf:"bytes,144,opt,name=field37123" json:"field37123,omitempty"`
+	Field37124 *Message35542       `protobuf:"bytes,150,opt,name=field37124" json:"field37124,omitempty"`
+}
+
+func (x *Message36876_Message36911) Reset() {
+	*x = Message36876_Message36911{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[55]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message36876_Message36911) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message36876_Message36911) ProtoMessage() {}
+
+func (x *Message36876_Message36911) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[55]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message36876_Message36911.ProtoReflect.Descriptor instead.
+func (*Message36876_Message36911) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{8, 14}
+}
+
+func (x *Message36876_Message36911) GetField37121() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37121
+	}
+	return nil
+}
+
+func (x *Message36876_Message36911) GetField37122() *Message35538 {
+	if x != nil {
+		return x.Field37122
+	}
+	return nil
+}
+
+func (x *Message36876_Message36911) GetField37123() *Message35540 {
+	if x != nil {
+		return x.Field37123
+	}
+	return nil
+}
+
+func (x *Message36876_Message36911) GetField37124() *Message35542 {
+	if x != nil {
+		return x.Field37124
+	}
+	return nil
+}
+
+type Message36876_Message36912 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field37125 *Message3901 `protobuf:"bytes,153,opt,name=field37125" json:"field37125,omitempty"`
+	Field37126 *Message3901 `protobuf:"bytes,162,opt,name=field37126" json:"field37126,omitempty"`
+}
+
+func (x *Message36876_Message36912) Reset() {
+	*x = Message36876_Message36912{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[56]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message36876_Message36912) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message36876_Message36912) ProtoMessage() {}
+
+func (x *Message36876_Message36912) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[56]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message36876_Message36912.ProtoReflect.Descriptor instead.
+func (*Message36876_Message36912) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{8, 15}
+}
+
+func (x *Message36876_Message36912) GetField37125() *Message3901 {
+	if x != nil {
+		return x.Field37125
+	}
+	return nil
+}
+
+func (x *Message36876_Message36912) GetField37126() *Message3901 {
+	if x != nil {
+		return x.Field37126
+	}
+	return nil
+}
+
+type Message17783_Message17784 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field18162 *string  `protobuf:"bytes,5,opt,name=field18162" json:"field18162,omitempty"`
+	Field18163 *string  `protobuf:"bytes,6,opt,name=field18163" json:"field18163,omitempty"`
+	Field18164 *string  `protobuf:"bytes,7,opt,name=field18164" json:"field18164,omitempty"`
+	Field18165 []string `protobuf:"bytes,8,rep,name=field18165" json:"field18165,omitempty"`
+	Field18166 *string  `protobuf:"bytes,17,opt,name=field18166" json:"field18166,omitempty"`
+	Field18167 *string  `protobuf:"bytes,18,opt,name=field18167" json:"field18167,omitempty"`
+}
+
+func (x *Message17783_Message17784) Reset() {
+	*x = Message17783_Message17784{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[57]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message17783_Message17784) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message17783_Message17784) ProtoMessage() {}
+
+func (x *Message17783_Message17784) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[57]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message17783_Message17784.ProtoReflect.Descriptor instead.
+func (*Message17783_Message17784) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{38, 0}
+}
+
+func (x *Message17783_Message17784) GetField18162() string {
+	if x != nil && x.Field18162 != nil {
+		return *x.Field18162
+	}
+	return ""
+}
+
+func (x *Message17783_Message17784) GetField18163() string {
+	if x != nil && x.Field18163 != nil {
+		return *x.Field18163
+	}
+	return ""
+}
+
+func (x *Message17783_Message17784) GetField18164() string {
+	if x != nil && x.Field18164 != nil {
+		return *x.Field18164
+	}
+	return ""
+}
+
+func (x *Message17783_Message17784) GetField18165() []string {
+	if x != nil {
+		return x.Field18165
+	}
+	return nil
+}
+
+func (x *Message17783_Message17784) GetField18166() string {
+	if x != nil && x.Field18166 != nil {
+		return *x.Field18166
+	}
+	return ""
+}
+
+func (x *Message17783_Message17784) GetField18167() string {
+	if x != nil && x.Field18167 != nil {
+		return *x.Field18167
+	}
+	return ""
+}
+
+type Message17783_Message17785 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field18168 *string       `protobuf:"bytes,10,opt,name=field18168" json:"field18168,omitempty"`
+	Field18169 *string       `protobuf:"bytes,11,opt,name=field18169" json:"field18169,omitempty"`
+	Field18170 *Message17783 `protobuf:"bytes,12,opt,name=field18170" json:"field18170,omitempty"`
+	Field18171 *string       `protobuf:"bytes,13,opt,name=field18171" json:"field18171,omitempty"`
+	Field18172 *string       `protobuf:"bytes,14,opt,name=field18172" json:"field18172,omitempty"`
+	Field18173 []string      `protobuf:"bytes,15,rep,name=field18173" json:"field18173,omitempty"`
+}
+
+func (x *Message17783_Message17785) Reset() {
+	*x = Message17783_Message17785{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[58]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message17783_Message17785) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message17783_Message17785) ProtoMessage() {}
+
+func (x *Message17783_Message17785) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[58]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message17783_Message17785.ProtoReflect.Descriptor instead.
+func (*Message17783_Message17785) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP(), []int{38, 1}
+}
+
+func (x *Message17783_Message17785) GetField18168() string {
+	if x != nil && x.Field18168 != nil {
+		return *x.Field18168
+	}
+	return ""
+}
+
+func (x *Message17783_Message17785) GetField18169() string {
+	if x != nil && x.Field18169 != nil {
+		return *x.Field18169
+	}
+	return ""
+}
+
+func (x *Message17783_Message17785) GetField18170() *Message17783 {
+	if x != nil {
+		return x.Field18170
+	}
+	return nil
+}
+
+func (x *Message17783_Message17785) GetField18171() string {
+	if x != nil && x.Field18171 != nil {
+		return *x.Field18171
+	}
+	return ""
+}
+
+func (x *Message17783_Message17785) GetField18172() string {
+	if x != nil && x.Field18172 != nil {
+		return *x.Field18172
+	}
+	return ""
+}
+
+func (x *Message17783_Message17785) GetField18173() []string {
+	if x != nil {
+		return x.Field18173
+	}
+	return nil
+}
+
+var file_datasets_google_message3_benchmark_message3_1_proto_extTypes = []protoimpl.ExtensionInfo{
+	{
+		ExtendedType:  (*Message0)(nil),
+		ExtensionType: (*Message34390)(nil),
+		Field:         92144610,
+		Name:          "benchmarks.google_message3.Message34390.field34453",
+		Tag:           "bytes,92144610,opt,name=field34453",
+		Filename:      "datasets/google_message3/benchmark_message3_1.proto",
+	},
+	{
+		ExtendedType:  (*Message0)(nil),
+		ExtensionType: (*Message34624)(nil),
+		Field:         18178548,
+		Name:          "benchmarks.google_message3.Message34624.field34685",
+		Tag:           "bytes,18178548,opt,name=field34685",
+		Filename:      "datasets/google_message3/benchmark_message3_1.proto",
+	},
+	{
+		ExtendedType:  (*Message0)(nil),
+		ExtensionType: (*Message34791)(nil),
+		Field:         6330340,
+		Name:          "benchmarks.google_message3.Message34791.field34807",
+		Tag:           "bytes,6330340,opt,name=field34807",
+		Filename:      "datasets/google_message3/benchmark_message3_1.proto",
+	},
+	{
+		ExtendedType:  (*Message0)(nil),
+		ExtensionType: (*Message35483)(nil),
+		Field:         7913554,
+		Name:          "benchmarks.google_message3.Message35483.field35505",
+		Tag:           "bytes,7913554,opt,name=field35505",
+		Filename:      "datasets/google_message3/benchmark_message3_1.proto",
+	},
+	{
+		ExtendedType:  (*Message0)(nil),
+		ExtensionType: (*Message35807)(nil),
+		Field:         3803299,
+		Name:          "benchmarks.google_message3.Message35807.field35818",
+		Tag:           "bytes,3803299,opt,name=field35818",
+		Filename:      "datasets/google_message3/benchmark_message3_1.proto",
+	},
+	{
+		ExtendedType:  (*Message0)(nil),
+		ExtensionType: (*Message16945)(nil),
+		Field:         22068132,
+		Name:          "benchmarks.google_message3.Message16945.field17025",
+		Tag:           "bytes,22068132,opt,name=field17025",
+		Filename:      "datasets/google_message3/benchmark_message3_1.proto",
+	},
+}
+
+// Extension fields to Message0.
+var (
+	// optional benchmarks.google_message3.Message34390 field34453 = 92144610;
+	E_Message34390_Field34453 = &file_datasets_google_message3_benchmark_message3_1_proto_extTypes[0]
+	// optional benchmarks.google_message3.Message34624 field34685 = 18178548;
+	E_Message34624_Field34685 = &file_datasets_google_message3_benchmark_message3_1_proto_extTypes[1]
+	// optional benchmarks.google_message3.Message34791 field34807 = 6330340;
+	E_Message34791_Field34807 = &file_datasets_google_message3_benchmark_message3_1_proto_extTypes[2]
+	// optional benchmarks.google_message3.Message35483 field35505 = 7913554;
+	E_Message35483_Field35505 = &file_datasets_google_message3_benchmark_message3_1_proto_extTypes[3]
+	// optional benchmarks.google_message3.Message35807 field35818 = 3803299;
+	E_Message35807_Field35818 = &file_datasets_google_message3_benchmark_message3_1_proto_extTypes[4]
+	// optional benchmarks.google_message3.Message16945 field17025 = 22068132;
+	E_Message16945_Field17025 = &file_datasets_google_message3_benchmark_message3_1_proto_extTypes[5]
+)
+
+var File_datasets_google_message3_benchmark_message3_1_proto protoreflect.FileDescriptor
+
+var file_datasets_google_message3_benchmark_message3_1_proto_rawDesc = []byte{
+	0x0a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x5f, 0x31, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1a, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x1a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2f, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x5f, 0x32,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73,
+	0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x5f, 0x33, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x33, 0x64, 0x61, 0x74,
+	0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x5f, 0x35, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x1a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x5f, 0x37, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2f,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x5f, 0x38, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xcb, 0x01, 0x0a, 0x0c, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x34, 0x33, 0x39, 0x30, 0x12, 0x48, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x34, 0x35, 0x32, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x34, 0x33, 0x38, 0x37, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x34, 0x34, 0x35, 0x32, 0x32, 0x71, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34,
+	0x34, 0x35, 0x33, 0x12, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x18, 0xe2, 0x87, 0xf8, 0x2b, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x34, 0x33, 0x39, 0x30, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x34, 0x34, 0x35, 0x33, 0x22, 0x95, 0x02, 0x0a, 0x0c, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x34, 0x36, 0x32, 0x34, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x34, 0x36, 0x38, 0x33, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x34, 0x36, 0x32, 0x31, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34,
+	0x36, 0x38, 0x33, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x38,
+	0x34, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x34, 0x36, 0x32,
+	0x31, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x38, 0x34, 0x32, 0x71, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x38, 0x35, 0x12, 0x24, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x30, 0x18, 0xf4, 0xc3, 0xd5, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x34, 0x36, 0x32, 0x34, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x38, 0x35,
+	0x22, 0xd0, 0x05, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x34, 0x37, 0x39,
+	0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x37, 0x39, 0x33, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x06, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x37, 0x39,
+	0x33, 0x12, 0x59, 0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x34, 0x37, 0x39,
+	0x32, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0a, 0x32, 0x35, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x34, 0x37, 0x39,
+	0x31, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x34, 0x37, 0x39, 0x32, 0x52, 0x0c,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x34, 0x37, 0x39, 0x32, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x37, 0x39, 0x35, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x37, 0x39, 0x35, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x37, 0x39, 0x36, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x37, 0x39, 0x36, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x37, 0x39, 0x37, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x37, 0x39, 0x37, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x37, 0x39, 0x38, 0x18, 0x08, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x37, 0x39, 0x38, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x37, 0x39, 0x39, 0x18, 0x09, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x37, 0x39, 0x39, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x38, 0x30, 0x30, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x38, 0x30, 0x30, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x38, 0x30, 0x31, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x38, 0x30, 0x31, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x38, 0x30, 0x32, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x02,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x38, 0x30, 0x32, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x38, 0x30, 0x33, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x38, 0x30, 0x33, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x38, 0x30, 0x34, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x38, 0x30, 0x34, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x38, 0x30, 0x35, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x03,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x38, 0x30, 0x35, 0x12, 0x22, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x38, 0x30, 0x36, 0x18, 0x11, 0x20, 0x03, 0x28, 0x06,
+	0x42, 0x02, 0x10, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x38, 0x30, 0x36,
+	0x1a, 0x4e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x34, 0x37, 0x39, 0x32,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x38, 0x30, 0x38, 0x18, 0x03,
+	0x20, 0x02, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x38, 0x30, 0x38,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x38, 0x30, 0x39, 0x18, 0x04,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x38, 0x30, 0x39,
+	0x32, 0x71, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x38, 0x30, 0x37, 0x12, 0x24,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x30, 0x18, 0xe4, 0xaf, 0x82, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x34, 0x37, 0x39, 0x31, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34,
+	0x38, 0x30, 0x37, 0x22, 0x9b, 0x03, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x35, 0x34, 0x38, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x34,
+	0x39, 0x39, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x35, 0x34, 0x39, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35,
+	0x30, 0x30, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x35, 0x35, 0x30, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35,
+	0x30, 0x31, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x35, 0x35, 0x30, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35,
+	0x30, 0x32, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x35, 0x35, 0x30, 0x32, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35,
+	0x30, 0x33, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x35, 0x34,
+	0x37, 0x36, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35, 0x30, 0x33, 0x12, 0x4e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35, 0x30, 0x34, 0x18, 0x06, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35, 0x30, 0x34, 0x32, 0x71,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35, 0x30, 0x35, 0x12, 0x24, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x30, 0x18, 0xd2, 0x80, 0xe3, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x35, 0x34, 0x38, 0x33, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35, 0x30,
+	0x35, 0x22, 0x81, 0x03, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x35, 0x38,
+	0x30, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x38, 0x31, 0x30,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x38,
+	0x31, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x38, 0x31, 0x31,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x38,
+	0x31, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x38, 0x31, 0x32,
+	0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x38,
+	0x31, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x38, 0x31, 0x33,
+	0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x38,
+	0x31, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x38, 0x31, 0x34,
+	0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x38,
+	0x31, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x38, 0x31, 0x35,
+	0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x38,
+	0x31, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x38, 0x31, 0x36,
+	0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x38,
+	0x31, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x38, 0x31, 0x37,
+	0x18, 0x08, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x38,
+	0x31, 0x37, 0x32, 0x71, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x38, 0x31, 0x38,
+	0x12, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x18, 0xa3, 0x91, 0xe8, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x35, 0x38, 0x30, 0x37, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x35, 0x38, 0x31, 0x38, 0x22, 0x4e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x37, 0x34, 0x38, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37,
+	0x35, 0x30, 0x31, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x37, 0x35, 0x30, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37,
+	0x35, 0x30, 0x32, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x37, 0x35, 0x30, 0x32, 0x22, 0xae, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x31, 0x33, 0x30, 0x36, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x33, 0x30, 0x37, 0x35, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x33, 0x30, 0x37, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x33, 0x30, 0x37, 0x36, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x33, 0x30, 0x37, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x33, 0x30, 0x37, 0x37, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x33, 0x30, 0x37, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x33, 0x30, 0x37, 0x38, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x33, 0x30, 0x37, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x33, 0x30, 0x37, 0x39, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x33, 0x30, 0x37, 0x39, 0x22, 0x50, 0x0a, 0x0a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x39, 0x35, 0x32, 0x12, 0x42, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x36, 0x33,
+	0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x39, 0x34, 0x39, 0x52, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x36, 0x33, 0x22, 0xd3, 0x34, 0x0a, 0x0c, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x37, 0x36, 0x12, 0x47, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x36, 0x39, 0x38, 0x30, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x32, 0x33, 0x35, 0x36, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39,
+	0x38, 0x30, 0x12, 0x59, 0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38,
+	0x37, 0x37, 0x18, 0x6f, 0x20, 0x03, 0x28, 0x0a, 0x32, 0x35, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38,
+	0x37, 0x36, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x37, 0x37, 0x52,
+	0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x37, 0x37, 0x12, 0x5a, 0x0a,
+	0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x37, 0x38, 0x18, 0xa8, 0x01,
+	0x20, 0x03, 0x28, 0x0a, 0x32, 0x35, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x37, 0x36, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x37, 0x38, 0x52, 0x0c, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x37, 0x38, 0x12, 0x59, 0x0a, 0x0c, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x37, 0x39, 0x18, 0x37, 0x20, 0x03, 0x28, 0x0a, 0x32,
+	0x35, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x37, 0x36, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x36, 0x38, 0x37, 0x39, 0x52, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x36, 0x38, 0x37, 0x39, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39,
+	0x38, 0x34, 0x18, 0x4e, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74,
+	0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x36, 0x39, 0x38, 0x34, 0x12, 0x5a, 0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x36, 0x38, 0x38, 0x30, 0x18, 0x89, 0x01, 0x20, 0x01, 0x28, 0x0a, 0x32, 0x35, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x36, 0x38, 0x37, 0x36, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38,
+	0x38, 0x30, 0x52, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x38, 0x30,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x38, 0x36, 0x18, 0x3b,
+	0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x38, 0x36,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x38, 0x37, 0x18, 0x79,
+	0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x38, 0x37,
+	0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x38, 0x38, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x38, 0x38,
+	0x12, 0x47, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x38, 0x39, 0x18, 0x76,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x30, 0x32, 0x39, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x38, 0x39, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x36, 0x39, 0x39, 0x30, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x35, 0x35, 0x37, 0x33, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36,
+	0x39, 0x39, 0x30, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x39,
+	0x31, 0x18, 0x15, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36,
+	0x39, 0x39, 0x31, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x39,
+	0x32, 0x18, 0x16, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36,
+	0x39, 0x39, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x39,
+	0x33, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36,
+	0x39, 0x39, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x39,
+	0x34, 0x18, 0x14, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36,
+	0x39, 0x39, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x39,
+	0x35, 0x18, 0x33, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36,
+	0x39, 0x39, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x39,
+	0x36, 0x18, 0x39, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36,
+	0x39, 0x39, 0x36, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x39,
+	0x37, 0x18, 0x64, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36,
+	0x39, 0x39, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x39,
+	0x38, 0x18, 0x2f, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36,
+	0x39, 0x39, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x39,
+	0x39, 0x18, 0x30, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36,
+	0x39, 0x39, 0x39, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x30,
+	0x30, 0x18, 0x44, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37,
+	0x30, 0x30, 0x30, 0x12, 0x59, 0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36,
+	0x38, 0x38, 0x31, 0x18, 0x17, 0x20, 0x03, 0x28, 0x0a, 0x32, 0x35, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36,
+	0x38, 0x37, 0x36, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x38, 0x31,
+	0x52, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x38, 0x31, 0x12, 0x47,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x30, 0x32, 0x18, 0x7d, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x31, 0x34, 0x34, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x30, 0x30, 0x32, 0x12, 0x59, 0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x36, 0x38, 0x38, 0x32, 0x18, 0x23, 0x20, 0x03, 0x28, 0x0a, 0x32, 0x35, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x36, 0x38, 0x37, 0x36, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x36, 0x38, 0x38, 0x32, 0x52, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38,
+	0x38, 0x32, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x30, 0x34,
+	0x18, 0x31, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30,
+	0x30, 0x34, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x30, 0x35,
+	0x18, 0x34, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x38, 0x39, 0x32, 0x31,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x30, 0x35, 0x12, 0x48, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x30, 0x36, 0x18, 0x2e, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x35, 0x38, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x37, 0x30, 0x30, 0x36, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x37, 0x30, 0x30, 0x37, 0x18, 0x36, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31,
+	0x38, 0x38, 0x33, 0x31, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x30, 0x37,
+	0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x30, 0x38, 0x18, 0x3a,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x30, 0x38,
+	0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x30, 0x39, 0x18, 0x0a,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x38, 0x32, 0x38, 0x33, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x30, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x31, 0x30, 0x18, 0x2c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x31, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x31, 0x31, 0x18, 0x67, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x31, 0x31, 0x12, 0x44, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x31, 0x32, 0x18, 0x2b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x31, 0x32,
+	0x12, 0x45, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x31, 0x33, 0x18, 0x8f,
+	0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x30, 0x31, 0x33, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x37, 0x30, 0x31, 0x34, 0x18, 0x35, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45,
+	0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x30, 0x31, 0x34, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x37, 0x30, 0x31, 0x35, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x36, 0x38, 0x36, 0x39, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x31,
+	0x35, 0x12, 0x59, 0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x38,
+	0x33, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0a, 0x32, 0x35, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x37,
+	0x36, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x38, 0x33, 0x52, 0x0c,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x38, 0x33, 0x12, 0x59, 0x0a, 0x0c,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x38, 0x34, 0x18, 0x10, 0x20, 0x03,
+	0x28, 0x0a, 0x32, 0x35, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x37, 0x36, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x38, 0x34, 0x52, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x36, 0x38, 0x38, 0x34, 0x12, 0x59, 0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x36, 0x38, 0x38, 0x35, 0x18, 0x1b, 0x20, 0x03, 0x28, 0x0a, 0x32, 0x35, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x36, 0x38, 0x37, 0x36, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x36, 0x38, 0x38, 0x35, 0x52, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38,
+	0x38, 0x35, 0x12, 0x59, 0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38,
+	0x38, 0x36, 0x18, 0x20, 0x20, 0x01, 0x28, 0x0a, 0x32, 0x35, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38,
+	0x37, 0x36, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x38, 0x36, 0x52,
+	0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x38, 0x36, 0x12, 0x46, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x32, 0x30, 0x18, 0x47, 0x20, 0x03, 0x28,
+	0x0e, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55,
+	0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x37, 0x30, 0x32, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37,
+	0x30, 0x32, 0x31, 0x18, 0x46, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x37, 0x30, 0x32, 0x31, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37,
+	0x30, 0x32, 0x32, 0x18, 0x42, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70,
+	0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x37, 0x30, 0x32, 0x32, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37,
+	0x30, 0x32, 0x33, 0x18, 0x43, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33,
+	0x30, 0x39, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x32, 0x33, 0x12,
+	0x59, 0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x38, 0x37, 0x18,
+	0x3e, 0x20, 0x01, 0x28, 0x0a, 0x32, 0x35, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x37, 0x36, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x38, 0x37, 0x52, 0x0c, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x38, 0x37, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x32, 0x35, 0x18, 0x32, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x31, 0x30, 0x31, 0x35, 0x35, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x37, 0x30, 0x32, 0x35, 0x12, 0x49, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30,
+	0x32, 0x36, 0x18, 0x97, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x31,
+	0x38, 0x37, 0x34, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x32, 0x36, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x32, 0x37, 0x18, 0x0c, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x32, 0x37, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x32, 0x38, 0x18, 0x48, 0x20,
+	0x01, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x32, 0x38, 0x12,
+	0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x32, 0x39, 0x18, 0x49, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x32, 0x39, 0x12,
+	0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x33, 0x30, 0x18, 0x6c, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x35, 0x35, 0x34, 0x36, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x33, 0x30, 0x12, 0x59, 0x0a, 0x0c, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x38, 0x38, 0x18, 0x4a, 0x20, 0x01, 0x28, 0x0a, 0x32,
+	0x35, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x37, 0x36, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x36, 0x38, 0x38, 0x38, 0x52, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x36, 0x38, 0x38, 0x38, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30,
+	0x33, 0x32, 0x18, 0x68, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x39, 0x32,
+	0x35, 0x35, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x33, 0x32, 0x12, 0x48,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x33, 0x33, 0x18, 0x69, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x33, 0x39, 0x36, 0x38, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x33, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x37, 0x30, 0x33, 0x34, 0x18, 0x6a, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x33, 0x34, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x37, 0x30, 0x33, 0x35, 0x18, 0x6b, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64,
+	0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x33, 0x35, 0x12, 0x47, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x37, 0x30, 0x33, 0x36, 0x18, 0x6e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x36, 0x36, 0x34, 0x34, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x33,
+	0x36, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x33, 0x37, 0x18,
+	0x85, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30,
+	0x33, 0x37, 0x12, 0x59, 0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38,
+	0x38, 0x39, 0x18, 0x74, 0x20, 0x01, 0x28, 0x0a, 0x32, 0x35, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38,
+	0x37, 0x36, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x38, 0x39, 0x52,
+	0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x38, 0x39, 0x12, 0x59, 0x0a,
+	0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x39, 0x31, 0x30, 0x18, 0x77, 0x20,
+	0x03, 0x28, 0x0a, 0x32, 0x35, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x37, 0x36, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x39, 0x31, 0x30, 0x52, 0x0c, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x36, 0x39, 0x31, 0x30, 0x12, 0x59, 0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x36, 0x39, 0x31, 0x31, 0x18, 0x7e, 0x20, 0x01, 0x28, 0x0a, 0x32, 0x35,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x37, 0x36, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x36, 0x39, 0x31, 0x31, 0x52, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36,
+	0x39, 0x31, 0x31, 0x12, 0x5a, 0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36,
+	0x39, 0x31, 0x32, 0x18, 0x98, 0x01, 0x20, 0x01, 0x28, 0x0a, 0x32, 0x35, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x36, 0x38, 0x37, 0x36, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x39, 0x31,
+	0x32, 0x52, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x39, 0x31, 0x32, 0x12,
+	0x4f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x34, 0x32, 0x18, 0x9b, 0x01,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x34, 0x32,
+	0x1a, 0xaf, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x37,
+	0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x34, 0x34, 0x18,
+	0x70, 0x20, 0x02, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x34,
+	0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x34, 0x35, 0x18,
+	0x71, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x34,
+	0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x34, 0x36, 0x18,
+	0x72, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x34,
+	0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x34, 0x37, 0x18,
+	0x73, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x34,
+	0x37, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x34, 0x38, 0x18,
+	0x9d, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30,
+	0x34, 0x38, 0x1a, 0x0e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38,
+	0x37, 0x38, 0x1a, 0x4e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38,
+	0x37, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x35, 0x30,
+	0x18, 0x38, 0x20, 0x02, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30,
+	0x35, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x35, 0x31,
+	0x18, 0x45, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30,
+	0x35, 0x31, 0x1a, 0x0e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38,
+	0x38, 0x30, 0x1a, 0x0e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38,
+	0x38, 0x31, 0x1a, 0x0e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38,
+	0x38, 0x32, 0x1a, 0x0e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38,
+	0x38, 0x33, 0x1a, 0x0e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38,
+	0x38, 0x34, 0x1a, 0x0e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38,
+	0x38, 0x35, 0x1a, 0x0e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38,
+	0x38, 0x36, 0x1a, 0x0e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38,
+	0x38, 0x37, 0x1a, 0xd0, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36,
+	0x38, 0x38, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x38,
+	0x39, 0x18, 0x4b, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37,
+	0x30, 0x38, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x39,
+	0x30, 0x18, 0x4c, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37,
+	0x30, 0x39, 0x30, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x39,
+	0x31, 0x18, 0xa5, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x37, 0x30, 0x39, 0x31, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30,
+	0x39, 0x32, 0x18, 0xa6, 0x01, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x37, 0x30, 0x39, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37,
+	0x30, 0x39, 0x33, 0x18, 0x6d, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x37, 0x30, 0x39, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37,
+	0x30, 0x39, 0x34, 0x18, 0x7a, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x37, 0x30, 0x39, 0x34, 0x1a, 0xcf, 0x09, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x36, 0x38, 0x38, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x37, 0x30, 0x39, 0x35, 0x18, 0x75, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x37, 0x30, 0x39, 0x35, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x37, 0x30, 0x39, 0x36, 0x18, 0x91, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x30, 0x39, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x37, 0x30, 0x39, 0x37, 0x18, 0x7b, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x30, 0x39, 0x37, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x37, 0x30, 0x39, 0x38, 0x18, 0xa3, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x39, 0x38, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x37, 0x30, 0x39, 0x39, 0x18, 0xa4, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x30, 0x39, 0x39, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x31, 0x30, 0x30, 0x18, 0x95, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x30, 0x30, 0x12, 0x4f, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x30, 0x31, 0x18, 0x81, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x30, 0x31, 0x12, 0x48, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x30, 0x32, 0x18, 0x7c, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x31, 0x37, 0x34, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x37, 0x31, 0x30, 0x32, 0x12, 0x49, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37,
+	0x31, 0x30, 0x33, 0x18, 0x80, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31,
+	0x33, 0x31, 0x36, 0x39, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x30, 0x33,
+	0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x30, 0x34, 0x18, 0x84,
+	0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x30,
+	0x34, 0x12, 0x46, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x30, 0x35, 0x18,
+	0x83, 0x01, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x33, 0x36, 0x38, 0x39, 0x30, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x30, 0x35, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x31, 0x30, 0x36, 0x18, 0x86, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x30, 0x36, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x30, 0x37, 0x18, 0x8c, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x30, 0x37, 0x12, 0x4f, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x30, 0x38, 0x18, 0x87, 0x01, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e,
+	0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x30, 0x38, 0x12, 0x1f, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x30, 0x39, 0x18, 0x88, 0x01, 0x20, 0x01, 0x28,
+	0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x30, 0x39, 0x12, 0x1f, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x31, 0x30, 0x18, 0x9c, 0x01, 0x20, 0x01,
+	0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x31, 0x30, 0x12, 0x1f,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x31, 0x31, 0x18, 0x8e, 0x01, 0x20,
+	0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x31, 0x31, 0x12,
+	0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x31, 0x32, 0x18, 0xa7, 0x01,
+	0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x31, 0x32,
+	0x12, 0x4f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x31, 0x33, 0x18, 0x92,
+	0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x31,
+	0x33, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x31, 0x34, 0x18,
+	0x94, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x31,
+	0x31, 0x34, 0x12, 0x4f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x31, 0x35,
+	0x18, 0x9a, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37,
+	0x31, 0x31, 0x35, 0x12, 0x47, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x31,
+	0x36, 0x18, 0x9e, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x31, 0x36, 0x12, 0x47, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x31, 0x37, 0x18, 0x9f, 0x01, 0x20, 0x03, 0x28,
+	0x0e, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55,
+	0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x37, 0x31, 0x31, 0x37, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37,
+	0x31, 0x31, 0x38, 0x18, 0xa0, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x37, 0x31, 0x31, 0x38, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x37, 0x31, 0x31, 0x39, 0x18, 0xa1, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x31, 0x31, 0x39, 0x1a, 0x0e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x36, 0x39, 0x31, 0x30, 0x1a, 0xbf, 0x02, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x36, 0x39, 0x31, 0x31, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x37, 0x31, 0x32, 0x31, 0x18, 0x7f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64,
+	0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x32, 0x31, 0x12, 0x49, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x37, 0x31, 0x32, 0x32, 0x18, 0x82, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x35, 0x35, 0x33, 0x38, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37,
+	0x31, 0x32, 0x32, 0x12, 0x49, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x32,
+	0x33, 0x18, 0x90, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x35, 0x35,
+	0x34, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x32, 0x33, 0x12, 0x49,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x32, 0x34, 0x18, 0x96, 0x01, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x35, 0x35, 0x34, 0x32, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x32, 0x34, 0x1a, 0xa2, 0x01, 0x0a, 0x0c, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x39, 0x31, 0x32, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x32, 0x35, 0x18, 0x99, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x39, 0x30, 0x31, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x37, 0x31, 0x32, 0x35, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x31,
+	0x32, 0x36, 0x18, 0xa2, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x39,
+	0x30, 0x31, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x31, 0x32, 0x36, 0x22, 0x0d,
+	0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x32, 0x38, 0x22, 0x0d, 0x0a,
+	0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x38, 0x35, 0x30, 0x22, 0x96, 0x0c, 0x0a,
+	0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x38, 0x36, 0x33, 0x12, 0x42, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x33, 0x31, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32,
+	0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75,
+	0x6d, 0x36, 0x38, 0x35, 0x38, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x33, 0x31,
+	0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x33, 0x32, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x36, 0x38, 0x35, 0x38, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x36, 0x39, 0x33, 0x32, 0x12, 0x44, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x33,
+	0x33, 0x18, 0x24, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x33, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x36, 0x39, 0x33, 0x34, 0x18, 0x1b, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x33, 0x34, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x36, 0x39, 0x33, 0x35, 0x18, 0x1a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x36, 0x37, 0x37, 0x33, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x33, 0x35, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x33, 0x36, 0x18, 0x1e, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x33, 0x36, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x33, 0x37, 0x18, 0x25, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x33, 0x37, 0x12, 0x42, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x33, 0x38, 0x18, 0x1f, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d,
+	0x36, 0x38, 0x31, 0x35, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x33, 0x38, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x33, 0x39, 0x18, 0x03, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x33, 0x39, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x34, 0x30, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x34, 0x30, 0x12, 0x42, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x34, 0x31, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d,
+	0x36, 0x38, 0x32, 0x32, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x34, 0x31, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x34, 0x32, 0x18, 0x0a, 0x20, 0x01,
+	0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x34, 0x32, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x34, 0x33, 0x18, 0x11, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x34, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x34, 0x34, 0x18, 0x12, 0x20, 0x01, 0x28, 0x02, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x34, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x36, 0x39, 0x34, 0x35, 0x18, 0x13, 0x20, 0x01, 0x28, 0x02, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x36, 0x39, 0x34, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x36, 0x39, 0x34, 0x36, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x36, 0x39, 0x34, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39,
+	0x34, 0x37, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36,
+	0x39, 0x34, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x34, 0x38,
+	0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x34,
+	0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x34, 0x39, 0x18, 0x0c,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x34, 0x39, 0x12,
+	0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x35, 0x30, 0x18, 0x08, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x35, 0x30, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x35, 0x31, 0x18, 0x09, 0x20, 0x01, 0x28, 0x04,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x35, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x35, 0x32, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x35, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x36, 0x39, 0x35, 0x33, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x36, 0x39, 0x35, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x36, 0x39, 0x35, 0x34, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x36, 0x39, 0x35, 0x34, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39,
+	0x35, 0x35, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74,
+	0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36,
+	0x39, 0x35, 0x35, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x35, 0x36,
+	0x18, 0x16, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x35,
+	0x36, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x35, 0x37, 0x18, 0x26,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x38, 0x38, 0x36, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x35, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x36, 0x39, 0x35, 0x38, 0x18, 0x14, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x36, 0x39, 0x35, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36,
+	0x39, 0x35, 0x39, 0x18, 0x15, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x36, 0x39, 0x35, 0x39, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x36,
+	0x30, 0x18, 0x17, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x37, 0x34, 0x33,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x36, 0x30, 0x12, 0x4c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x36, 0x31, 0x18, 0x1d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73,
+	0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x39, 0x36, 0x31, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x36, 0x39, 0x36, 0x32, 0x18, 0x21, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64,
+	0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x36, 0x39, 0x36, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x36, 0x39, 0x36, 0x33, 0x18, 0x22, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x36, 0x39, 0x36, 0x33, 0x22, 0x0d, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x36, 0x38, 0x37, 0x31, 0x22, 0x49, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37,
+	0x35, 0x34, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x35, 0x34, 0x39,
+	0x18, 0x01, 0x20, 0x02, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x35, 0x34,
+	0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x35, 0x35, 0x30, 0x18, 0x02,
+	0x20, 0x02, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x35, 0x35, 0x30, 0x22,
+	0xf5, 0x02, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x36, 0x34, 0x38, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x36, 0x39, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x36, 0x39, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x37, 0x30, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x37, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x37, 0x31, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x37, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x37, 0x36, 0x37, 0x32, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x36, 0x37, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x37, 0x36, 0x37, 0x33, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x36, 0x37, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36,
+	0x37, 0x34, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37,
+	0x36, 0x37, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x37, 0x35,
+	0x18, 0x07, 0x20, 0x01, 0x28, 0x02, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x37,
+	0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x37, 0x36, 0x18, 0x08,
+	0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x37, 0x36, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x37, 0x37, 0x18, 0x09, 0x20, 0x01,
+	0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x37, 0x37, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x37, 0x38, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x37, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x37, 0x39, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x37, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x37, 0x36, 0x38, 0x30, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x36, 0x38, 0x30, 0x22, 0x0d, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x37, 0x38, 0x36, 0x35, 0x22, 0x49, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x37, 0x39, 0x32, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39,
+	0x34, 0x30, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37,
+	0x39, 0x34, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x34, 0x31,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x34,
+	0x31, 0x22, 0x67, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x39, 0x31, 0x39,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x33, 0x31, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x06, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x33, 0x31, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x33, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x33, 0x32, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x33, 0x33, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x33, 0x33, 0x22, 0x49, 0x0a, 0x0b, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x39, 0x32, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x37, 0x39, 0x33, 0x34, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x39, 0x33, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x37, 0x39, 0x33, 0x35, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x39, 0x33, 0x35, 0x22, 0xad, 0x01, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x37, 0x39, 0x32, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39,
+	0x33, 0x36, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37,
+	0x39, 0x33, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x33, 0x37,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x33,
+	0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x33, 0x38, 0x18, 0x03,
+	0x20, 0x01, 0x28, 0x02, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x33, 0x38, 0x12,
+	0x44, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x33, 0x39, 0x18, 0x04, 0x20, 0x01,
+	0x28, 0x0e, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x39, 0x33, 0x39, 0x22, 0xcc, 0x01, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x38, 0x35, 0x31, 0x31, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35,
+	0x33, 0x39, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x32, 0x32,
+	0x34, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x33, 0x39, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x34, 0x30, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x34, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x35, 0x34, 0x31, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x34, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x35, 0x34, 0x32, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x35, 0x34, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x35, 0x34, 0x33, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x35, 0x34, 0x33, 0x22, 0x93, 0x02, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x38, 0x35, 0x31, 0x32, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x34,
+	0x34, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x33, 0x30, 0x31,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x34, 0x34, 0x12, 0x45, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x34, 0x35, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x38, 0x33, 0x30, 0x32, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35,
+	0x34, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x34, 0x36, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x34, 0x36,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x34, 0x37, 0x18, 0x04, 0x20,
+	0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x34, 0x37, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x34, 0x38, 0x18, 0x05, 0x20, 0x01, 0x28,
+	0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x34, 0x38, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x34, 0x39, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x34, 0x39, 0x22, 0xae, 0x01, 0x0a, 0x0b, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x35, 0x31, 0x33, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x35, 0x35, 0x30, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x38, 0x33, 0x39, 0x32, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x35,
+	0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x35, 0x31, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x35, 0x31, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x35, 0x32, 0x18, 0x03, 0x20, 0x01,
+	0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x35, 0x32, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x35, 0x33, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x35, 0x33, 0x22, 0xcc, 0x01, 0x0a, 0x0b,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x35, 0x31, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x35, 0x34, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x35, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x35, 0x35, 0x35, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x35, 0x35, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x35, 0x35, 0x36, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x35, 0x35, 0x36, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35,
+	0x35, 0x37, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x31, 0x33,
+	0x30, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x35, 0x37, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x35, 0x38, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x35, 0x38, 0x22, 0xb9, 0x01, 0x0a, 0x0b, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x35, 0x31, 0x35, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x35, 0x35, 0x39, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x38, 0x34, 0x37, 0x39, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x35,
+	0x39, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x36, 0x30, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x34, 0x37, 0x38, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x36, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x35, 0x36, 0x31, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x35, 0x36, 0x31, 0x22, 0xe6, 0x02, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x31, 0x30, 0x33, 0x32, 0x30, 0x12, 0x45, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x30, 0x33, 0x34, 0x37, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x30, 0x33,
+	0x33, 0x35, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x37, 0x12, 0x48,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x38, 0x18, 0x02, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x33, 0x31, 0x39, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x30, 0x33, 0x34, 0x39, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x30, 0x33, 0x35, 0x30, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x35, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x30, 0x33, 0x35, 0x31, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x35, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x30, 0x33, 0x35, 0x32, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x35, 0x32, 0x12, 0x45, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x30, 0x33, 0x35, 0x33, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x30,
+	0x33, 0x33, 0x37, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x35, 0x33, 0x22,
+	0x6e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x33, 0x32, 0x31, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x35, 0x34, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x35, 0x34, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x35, 0x35, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x35, 0x35, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x35, 0x36, 0x18, 0x03, 0x20,
+	0x01, 0x28, 0x04, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x35, 0x36, 0x22,
+	0x97, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x33, 0x32, 0x32,
+	0x12, 0x47, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x35, 0x37, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x30, 0x31, 0x36, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x35, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x30, 0x33, 0x35, 0x38, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x35, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x30, 0x33, 0x35, 0x39, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x35, 0x39, 0x22, 0xe8, 0x01, 0x0a, 0x0c, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x31, 0x39, 0x38, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x30, 0x32, 0x31, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x30, 0x32, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x30, 0x32, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x30, 0x32, 0x32, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x30, 0x32, 0x33, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73,
+	0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x30, 0x32, 0x33, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x30, 0x32, 0x34, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x31, 0x30, 0x31, 0x35, 0x35, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x30, 0x32, 0x34, 0x22, 0xb8, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x31, 0x32, 0x36, 0x36, 0x38, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32,
+	0x36, 0x37, 0x37, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32,
+	0x36, 0x36, 0x39, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x36, 0x37, 0x37, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x36, 0x37, 0x38, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x36, 0x37, 0x38, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x36, 0x37, 0x39, 0x18, 0x03, 0x20,
+	0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x36, 0x37, 0x39, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x36, 0x38, 0x30, 0x18, 0x04, 0x20,
+	0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x36, 0x38, 0x30, 0x22,
+	0xc6, 0x03, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x38, 0x32, 0x35,
+	0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x36, 0x32, 0x18, 0x01,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x38, 0x31, 0x38, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x36, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x36, 0x33, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x36, 0x33, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x36, 0x34, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x31, 0x32, 0x38, 0x31, 0x39, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x38, 0x36, 0x34, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38,
+	0x36, 0x35, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x38,
+	0x32, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x36, 0x35, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x36, 0x36, 0x18, 0x05, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x36, 0x36, 0x12, 0x48,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x36, 0x37, 0x18, 0x06, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x38, 0x32, 0x31, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x36, 0x37, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x32, 0x38, 0x36, 0x38, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64,
+	0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x36, 0x38, 0x22, 0x98, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x34, 0x37, 0x38, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x36, 0x34, 0x38, 0x31, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x31, 0x36, 0x34, 0x37, 0x39, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36,
+	0x34, 0x38, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x34, 0x38,
+	0x32, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36,
+	0x34, 0x38, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x34, 0x38,
+	0x33, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36,
+	0x34, 0x38, 0x33, 0x22, 0x95, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31,
+	0x36, 0x35, 0x35, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35,
+	0x36, 0x35, 0x18, 0x01, 0x20, 0x01, 0x28, 0x06, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x36, 0x35, 0x36, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35,
+	0x36, 0x36, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x36, 0x35, 0x36, 0x36, 0x12, 0x45, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35,
+	0x36, 0x37, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x36, 0x35, 0x35, 0x33, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x35, 0x36, 0x37, 0x22, 0x6e, 0x0a, 0x0c, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x36, 0x36, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x36, 0x36, 0x38, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x36, 0x36, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x36, 0x36, 0x39, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x36, 0x36, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x36, 0x37, 0x30, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x36, 0x37, 0x30, 0x22, 0xb9, 0x08, 0x0a, 0x0c,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x37, 0x32, 0x37, 0x12, 0x45, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x38, 0x32, 0x18, 0x01, 0x20, 0x02, 0x28, 0x0e,
+	0x32, 0x25, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e,
+	0x75, 0x6d, 0x31, 0x36, 0x37, 0x32, 0x38, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36,
+	0x37, 0x38, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x38,
+	0x33, 0x18, 0x02, 0x20, 0x02, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36,
+	0x37, 0x38, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x38,
+	0x34, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36,
+	0x37, 0x38, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x38,
+	0x35, 0x18, 0x17, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36,
+	0x37, 0x38, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x38,
+	0x36, 0x18, 0x04, 0x20, 0x02, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36,
+	0x37, 0x38, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x38,
+	0x37, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36,
+	0x37, 0x38, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x38,
+	0x38, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36,
+	0x37, 0x38, 0x38, 0x12, 0x45, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x38,
+	0x39, 0x18, 0x07, 0x20, 0x02, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x36, 0x37, 0x33, 0x32, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x38, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x39, 0x30, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x39, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x39, 0x31, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x39, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x39, 0x32, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x39, 0x32, 0x12, 0x45, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x39, 0x33, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d,
+	0x31, 0x36, 0x37, 0x33, 0x38, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x39,
+	0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x39, 0x34, 0x18,
+	0x0c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x39,
+	0x34, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x39, 0x35, 0x18,
+	0x0d, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x37, 0x32, 0x32, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x39, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x39, 0x36, 0x18, 0x13, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x39, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x39, 0x37, 0x18, 0x18, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x39, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x39, 0x38, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x39, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x39, 0x39, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x03, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x39, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x38, 0x30, 0x30, 0x18, 0x10, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x38, 0x30, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x38, 0x30, 0x31, 0x18, 0x11, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x38, 0x30, 0x31, 0x12, 0x45, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x38, 0x30, 0x32, 0x18, 0x12, 0x20, 0x01, 0x28, 0x0e, 0x32,
+	0x25, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75,
+	0x6d, 0x31, 0x36, 0x36, 0x39, 0x38, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x38,
+	0x30, 0x32, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x38, 0x30, 0x33,
+	0x18, 0x14, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x37, 0x32, 0x34,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x38, 0x30, 0x33, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x38, 0x30, 0x34, 0x18, 0x16, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x38, 0x30, 0x34, 0x12, 0x4e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x38, 0x30, 0x35, 0x18, 0x19, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e,
+	0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x38, 0x30, 0x35, 0x2a, 0x09, 0x08, 0xe8,
+	0x07, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x22, 0x75, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x31, 0x36, 0x37, 0x32, 0x35, 0x12, 0x45, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x36, 0x37, 0x37, 0x34, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x36, 0x37,
+	0x32, 0x38, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x37, 0x34, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x37, 0x35, 0x18, 0x02, 0x20, 0x03,
+	0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x37, 0x35, 0x22, 0x82,
+	0x07, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x37, 0x37, 0x32, 0x36, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x30, 0x31, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x30, 0x31, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x30, 0x32, 0x18, 0x02, 0x20,
+	0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x30, 0x32, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x30, 0x33, 0x18, 0x03, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x30, 0x33, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x30, 0x34, 0x18, 0x04, 0x20,
+	0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x30, 0x34, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x30, 0x35, 0x18, 0x05, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x30, 0x35, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x30, 0x36, 0x18, 0x06, 0x20,
+	0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x30, 0x36, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x30, 0x37, 0x18, 0x07, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x30, 0x37, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x30, 0x38, 0x18, 0x08, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x30, 0x38, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x30, 0x39, 0x18, 0x0f, 0x20,
+	0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x30, 0x39, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x31, 0x30, 0x18, 0x10, 0x20,
+	0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x31, 0x30, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x31, 0x31, 0x18, 0x11, 0x20,
+	0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x31, 0x31, 0x12,
+	0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x31, 0x32, 0x18, 0x12, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x31, 0x32, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x31, 0x33, 0x18, 0x09, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x31, 0x33, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x31, 0x34, 0x18, 0x0a, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x31, 0x34, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x31, 0x35, 0x18, 0x0b, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x31, 0x35, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x31, 0x36, 0x18, 0x0c, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x31, 0x36, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x31, 0x37, 0x18, 0x0d, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x31, 0x37, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x31, 0x38, 0x18, 0x0e, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x31, 0x38, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x31, 0x39, 0x18, 0x13, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x31, 0x39, 0x12,
+	0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x32, 0x30, 0x18, 0x14, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x37, 0x37, 0x32, 0x38, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x32, 0x30, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x37, 0x38, 0x32, 0x31, 0x18, 0x15, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x31, 0x37, 0x37, 0x32, 0x38, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37,
+	0x38, 0x32, 0x31, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x38, 0x32,
+	0x32, 0x18, 0x1e, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37,
+	0x38, 0x32, 0x32, 0x22, 0x4e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x37,
+	0x37, 0x38, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x35,
+	0x33, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x31, 0x35, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x35,
+	0x34, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x31, 0x35, 0x34, 0x22, 0x90, 0x06, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31,
+	0x37, 0x37, 0x38, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31,
+	0x35, 0x35, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x38, 0x31, 0x35, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31,
+	0x35, 0x36, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x38, 0x31, 0x35, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31,
+	0x35, 0x37, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x38, 0x31, 0x35, 0x37, 0x12, 0x59, 0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31,
+	0x37, 0x37, 0x38, 0x34, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0a, 0x32, 0x35, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31,
+	0x37, 0x37, 0x38, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x37, 0x37, 0x38,
+	0x34, 0x52, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x37, 0x37, 0x38, 0x34, 0x12,
+	0x59, 0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x37, 0x37, 0x38, 0x35, 0x18,
+	0x09, 0x20, 0x03, 0x28, 0x0a, 0x32, 0x35, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x37, 0x37, 0x38, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x37, 0x37, 0x38, 0x35, 0x52, 0x0c, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x37, 0x37, 0x38, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x36, 0x30, 0x18, 0x10, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x36, 0x30, 0x1a, 0xce, 0x01, 0x0a, 0x0c, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x37, 0x37, 0x38, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x36, 0x32, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x36, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x36, 0x33, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x36, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x36, 0x34, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x36, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x36, 0x35, 0x18, 0x08, 0x20, 0x03, 0x28, 0x09, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x36, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x36, 0x36, 0x18, 0x11, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x36, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x36, 0x37, 0x18, 0x12, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x36, 0x37, 0x1a, 0xf8, 0x01, 0x0a, 0x0c,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x37, 0x37, 0x38, 0x35, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x36, 0x38, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x36, 0x38, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x36, 0x39, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x36, 0x39, 0x12, 0x48, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x31, 0x37, 0x30, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x37, 0x37, 0x38, 0x33, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x38, 0x31, 0x37, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x38, 0x31, 0x37, 0x31, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x38, 0x31, 0x37, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x38, 0x31, 0x37, 0x32, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x38, 0x31, 0x37, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x38, 0x31, 0x37, 0x33, 0x18, 0x0f, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x38, 0x31, 0x37, 0x33, 0x22, 0xc0, 0x4b, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x31, 0x36, 0x39, 0x34, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x36, 0x39, 0x34, 0x36, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x36, 0x39, 0x34, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x36, 0x39, 0x34, 0x37, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x36, 0x39, 0x34, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x36, 0x39, 0x34, 0x38, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x36, 0x39, 0x34, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x36, 0x39, 0x34, 0x39, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x36, 0x39, 0x34, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x36, 0x39, 0x35, 0x30, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x36, 0x39, 0x35, 0x30, 0x12, 0x4f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x36, 0x39, 0x35, 0x31, 0x18, 0xe8, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64,
+	0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x35, 0x31, 0x12, 0x44, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x36, 0x39, 0x35, 0x32, 0x18, 0x10, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x35, 0x32, 0x12, 0x4e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x35, 0x33, 0x18, 0x36, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x35, 0x33, 0x12, 0x44,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x35, 0x34, 0x18, 0x37, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x36, 0x39, 0x35, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39,
+	0x35, 0x35, 0x18, 0x3a, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x36, 0x39, 0x35, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39,
+	0x35, 0x36, 0x18, 0x3b, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x36, 0x39, 0x35, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39,
+	0x35, 0x37, 0x18, 0x3e, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x36, 0x39, 0x35, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39,
+	0x35, 0x38, 0x18, 0x25, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x36, 0x39, 0x35, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39,
+	0x35, 0x39, 0x18, 0x12, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x36, 0x39, 0x35, 0x39, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39,
+	0x36, 0x30, 0x18, 0x26, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74,
+	0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x36, 0x39, 0x36, 0x30, 0x12, 0x44, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39,
+	0x36, 0x31, 0x18, 0x43, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x36, 0x31, 0x12, 0x45, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x36, 0x32, 0x18, 0x82, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x36,
+	0x32, 0x12, 0x4f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x36, 0x33, 0x18,
+	0x88, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39,
+	0x36, 0x33, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x36, 0x34,
+	0x18, 0x8a, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36,
+	0x39, 0x36, 0x34, 0x12, 0x4f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x36,
+	0x35, 0x18, 0x9c, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74,
+	0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x36, 0x39, 0x36, 0x35, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39,
+	0x36, 0x36, 0x18, 0x8b, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x36, 0x39, 0x36, 0x36, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36,
+	0x39, 0x36, 0x37, 0x18, 0x7e, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70,
+	0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x36, 0x39, 0x36, 0x37, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36,
+	0x39, 0x36, 0x38, 0x18, 0x98, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x36, 0x39, 0x36, 0x38, 0x12, 0x45, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x36, 0x39, 0x36, 0x39, 0x18, 0xb7, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x36, 0x39, 0x12, 0x1f, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x37, 0x30, 0x18, 0xa8, 0x01, 0x20, 0x03,
+	0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x37, 0x30, 0x12, 0x1f,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x37, 0x31, 0x18, 0xd4, 0x01, 0x20,
+	0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x37, 0x31, 0x12,
+	0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x37, 0x32, 0x18, 0xd5, 0x01,
+	0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x37, 0x32,
+	0x12, 0x4f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x37, 0x33, 0x18, 0xbd,
+	0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x37,
+	0x33, 0x12, 0x4f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x37, 0x34, 0x18,
+	0xbe, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39,
+	0x37, 0x34, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x37, 0x35,
+	0x18, 0xbf, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36,
+	0x39, 0x37, 0x35, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x37,
+	0x36, 0x18, 0xc0, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x36, 0x39, 0x37, 0x36, 0x12, 0x45, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39,
+	0x37, 0x37, 0x18, 0xc1, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x37, 0x37, 0x12, 0x4f, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x37, 0x38, 0x18, 0xc2, 0x01, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e,
+	0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x37, 0x38, 0x12, 0x4f, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x37, 0x39, 0x18, 0xc3, 0x01, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55,
+	0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x37, 0x39, 0x12, 0x1f, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x38, 0x30, 0x18, 0xc4, 0x01, 0x20, 0x03,
+	0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x38, 0x30, 0x12, 0x4e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x38, 0x31, 0x18, 0x5f, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x38, 0x31, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x38, 0x32, 0x18, 0x60, 0x20, 0x03,
+	0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x38, 0x32, 0x12, 0x4e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x38, 0x33, 0x18, 0x61, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x38, 0x33, 0x12, 0x1f,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x38, 0x34, 0x18, 0xbe, 0x08, 0x20,
+	0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x38, 0x34, 0x12,
+	0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x38, 0x35, 0x18, 0x62, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x38, 0x35, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x38, 0x36, 0x18, 0x63, 0x20,
+	0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x38, 0x36, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x38, 0x37, 0x18, 0x64, 0x20,
+	0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x38, 0x37, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x38, 0x38, 0x18, 0x30, 0x20,
+	0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x38, 0x38, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x38, 0x39, 0x18, 0x16, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x38, 0x39, 0x12,
+	0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x39, 0x30, 0x18, 0x33, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x39, 0x30, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x39, 0x31, 0x18, 0x51, 0x20,
+	0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x39, 0x31, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x39, 0x32, 0x18, 0x55, 0x20,
+	0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x39, 0x32, 0x12,
+	0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x39, 0x33, 0x18, 0xa9, 0x01,
+	0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x39, 0x33,
+	0x12, 0x4f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x39, 0x34, 0x18, 0x84,
+	0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x39,
+	0x34, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x39, 0x35, 0x18,
+	0xc6, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39,
+	0x39, 0x35, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x39, 0x36,
+	0x18, 0xcc, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36,
+	0x39, 0x39, 0x36, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39, 0x39,
+	0x37, 0x18, 0xbf, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x36, 0x39, 0x39, 0x37, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x39,
+	0x39, 0x38, 0x18, 0xc5, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x36, 0x39, 0x39, 0x38, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36,
+	0x39, 0x39, 0x39, 0x18, 0xce, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x36, 0x39, 0x39, 0x39, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x37, 0x30, 0x30, 0x30, 0x18, 0xd3, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x37, 0x30, 0x30, 0x30, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x37, 0x30, 0x30, 0x31, 0x18, 0xcd, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x30, 0x31, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x37, 0x30, 0x30, 0x32, 0x18, 0x44, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64,
+	0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x30, 0x32, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x37, 0x30, 0x30, 0x33, 0x18, 0x45, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64,
+	0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x30, 0x33, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x37, 0x30, 0x30, 0x34, 0x18, 0x46, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64,
+	0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x30, 0x34, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x37, 0x30, 0x30, 0x35, 0x18, 0x47, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64,
+	0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x30, 0x35, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x37, 0x30, 0x30, 0x36, 0x18, 0x48, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64,
+	0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x30, 0x36, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x37, 0x30, 0x30, 0x37, 0x18, 0x13, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64,
+	0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x30, 0x37, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x37, 0x30, 0x30, 0x38, 0x18, 0x18, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64,
+	0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x30, 0x38, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x37, 0x30, 0x30, 0x39, 0x18, 0x17, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64,
+	0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x30, 0x39, 0x12, 0x45, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x37, 0x30, 0x31, 0x30, 0x18, 0x83, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x31, 0x30, 0x12,
+	0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x31, 0x31, 0x18, 0x85, 0x01,
+	0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x31, 0x31,
+	0x12, 0x4f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x31, 0x32, 0x18, 0x8e,
+	0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x31,
+	0x32, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x31, 0x33, 0x18,
+	0x8f, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30,
+	0x31, 0x33, 0x12, 0x4f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x31, 0x34,
+	0x18, 0x99, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37,
+	0x30, 0x31, 0x34, 0x12, 0x45, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x31,
+	0x35, 0x18, 0xaa, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x31, 0x35, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x31, 0x36, 0x18, 0xab, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x31, 0x36, 0x12, 0x1f, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x31, 0x37, 0x18, 0xac, 0x01, 0x20, 0x03, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x31, 0x37, 0x12, 0x1f, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x31, 0x38, 0x18, 0xad, 0x01, 0x20, 0x03, 0x28,
+	0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x31, 0x38, 0x12, 0x1f, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x31, 0x39, 0x18, 0xae, 0x01, 0x20, 0x03,
+	0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x31, 0x39, 0x12, 0x1f,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x32, 0x30, 0x18, 0xaf, 0x01, 0x20,
+	0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x32, 0x30, 0x12,
+	0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x32, 0x31, 0x18, 0xba, 0x01,
+	0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x32, 0x31,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x32, 0x32, 0x18, 0x65,
+	0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x32, 0x32,
+	0x12, 0x44, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x32, 0x33, 0x18, 0x66,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x37, 0x30, 0x32, 0x33, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x37, 0x30, 0x32, 0x34, 0x18, 0x92, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x37, 0x30, 0x32, 0x34, 0x2a, 0x04, 0x08, 0x11, 0x10, 0x12, 0x2a, 0x04, 0x08,
+	0x15, 0x10, 0x16, 0x2a, 0x04, 0x08, 0x19, 0x10, 0x1a, 0x2a, 0x04, 0x08, 0x1b, 0x10, 0x1c, 0x2a,
+	0x04, 0x08, 0x1d, 0x10, 0x1e, 0x2a, 0x04, 0x08, 0x1e, 0x10, 0x1f, 0x2a, 0x04, 0x08, 0x1f, 0x10,
+	0x20, 0x2a, 0x04, 0x08, 0x20, 0x10, 0x21, 0x2a, 0x04, 0x08, 0x21, 0x10, 0x22, 0x2a, 0x04, 0x08,
+	0x22, 0x10, 0x23, 0x2a, 0x04, 0x08, 0x23, 0x10, 0x24, 0x2a, 0x04, 0x08, 0x24, 0x10, 0x25, 0x2a,
+	0x04, 0x08, 0x27, 0x10, 0x28, 0x2a, 0x04, 0x08, 0x28, 0x10, 0x29, 0x2a, 0x04, 0x08, 0x29, 0x10,
+	0x2a, 0x2a, 0x04, 0x08, 0x2a, 0x10, 0x2b, 0x2a, 0x04, 0x08, 0x2b, 0x10, 0x2c, 0x2a, 0x04, 0x08,
+	0x2c, 0x10, 0x2d, 0x2a, 0x04, 0x08, 0x2d, 0x10, 0x2e, 0x2a, 0x04, 0x08, 0x2e, 0x10, 0x2f, 0x2a,
+	0x04, 0x08, 0x2f, 0x10, 0x30, 0x2a, 0x04, 0x08, 0x31, 0x10, 0x32, 0x2a, 0x04, 0x08, 0x32, 0x10,
+	0x33, 0x2a, 0x04, 0x08, 0x34, 0x10, 0x35, 0x2a, 0x04, 0x08, 0x35, 0x10, 0x36, 0x2a, 0x04, 0x08,
+	0x38, 0x10, 0x39, 0x2a, 0x04, 0x08, 0x39, 0x10, 0x3a, 0x2a, 0x04, 0x08, 0x3c, 0x10, 0x3d, 0x2a,
+	0x04, 0x08, 0x3d, 0x10, 0x3e, 0x2a, 0x04, 0x08, 0x3f, 0x10, 0x40, 0x2a, 0x04, 0x08, 0x40, 0x10,
+	0x41, 0x2a, 0x04, 0x08, 0x41, 0x10, 0x42, 0x2a, 0x04, 0x08, 0x42, 0x10, 0x43, 0x2a, 0x04, 0x08,
+	0x49, 0x10, 0x4a, 0x2a, 0x04, 0x08, 0x4a, 0x10, 0x4b, 0x2a, 0x04, 0x08, 0x4b, 0x10, 0x4c, 0x2a,
+	0x04, 0x08, 0x4c, 0x10, 0x4d, 0x2a, 0x04, 0x08, 0x4d, 0x10, 0x4e, 0x2a, 0x04, 0x08, 0x4e, 0x10,
+	0x4f, 0x2a, 0x04, 0x08, 0x4f, 0x10, 0x50, 0x2a, 0x04, 0x08, 0x50, 0x10, 0x51, 0x2a, 0x04, 0x08,
+	0x52, 0x10, 0x53, 0x2a, 0x04, 0x08, 0x53, 0x10, 0x54, 0x2a, 0x04, 0x08, 0x54, 0x10, 0x55, 0x2a,
+	0x04, 0x08, 0x56, 0x10, 0x57, 0x2a, 0x04, 0x08, 0x57, 0x10, 0x58, 0x2a, 0x04, 0x08, 0x58, 0x10,
+	0x59, 0x2a, 0x04, 0x08, 0x59, 0x10, 0x5a, 0x2a, 0x04, 0x08, 0x5a, 0x10, 0x5b, 0x2a, 0x04, 0x08,
+	0x5b, 0x10, 0x5c, 0x2a, 0x04, 0x08, 0x5c, 0x10, 0x5d, 0x2a, 0x04, 0x08, 0x5d, 0x10, 0x5e, 0x2a,
+	0x04, 0x08, 0x5e, 0x10, 0x5f, 0x2a, 0x04, 0x08, 0x67, 0x10, 0x68, 0x2a, 0x04, 0x08, 0x68, 0x10,
+	0x69, 0x2a, 0x04, 0x08, 0x69, 0x10, 0x6a, 0x2a, 0x04, 0x08, 0x6a, 0x10, 0x6b, 0x2a, 0x04, 0x08,
+	0x6b, 0x10, 0x6c, 0x2a, 0x04, 0x08, 0x6c, 0x10, 0x6d, 0x2a, 0x04, 0x08, 0x6d, 0x10, 0x6e, 0x2a,
+	0x04, 0x08, 0x6e, 0x10, 0x6f, 0x2a, 0x04, 0x08, 0x6f, 0x10, 0x70, 0x2a, 0x04, 0x08, 0x70, 0x10,
+	0x71, 0x2a, 0x04, 0x08, 0x71, 0x10, 0x72, 0x2a, 0x04, 0x08, 0x72, 0x10, 0x73, 0x2a, 0x04, 0x08,
+	0x73, 0x10, 0x74, 0x2a, 0x04, 0x08, 0x74, 0x10, 0x75, 0x2a, 0x04, 0x08, 0x75, 0x10, 0x76, 0x2a,
+	0x04, 0x08, 0x76, 0x10, 0x77, 0x2a, 0x04, 0x08, 0x77, 0x10, 0x78, 0x2a, 0x04, 0x08, 0x78, 0x10,
+	0x79, 0x2a, 0x04, 0x08, 0x79, 0x10, 0x7a, 0x2a, 0x04, 0x08, 0x7a, 0x10, 0x7b, 0x2a, 0x04, 0x08,
+	0x7b, 0x10, 0x7c, 0x2a, 0x04, 0x08, 0x7c, 0x10, 0x7d, 0x2a, 0x04, 0x08, 0x7d, 0x10, 0x7e, 0x2a,
+	0x05, 0x08, 0x7f, 0x10, 0x80, 0x01, 0x2a, 0x06, 0x08, 0x80, 0x01, 0x10, 0x81, 0x01, 0x2a, 0x06,
+	0x08, 0x81, 0x01, 0x10, 0x82, 0x01, 0x2a, 0x06, 0x08, 0x84, 0x01, 0x10, 0x85, 0x01, 0x2a, 0x06,
+	0x08, 0x86, 0x01, 0x10, 0x87, 0x01, 0x2a, 0x06, 0x08, 0x87, 0x01, 0x10, 0x88, 0x01, 0x2a, 0x06,
+	0x08, 0x89, 0x01, 0x10, 0x8a, 0x01, 0x2a, 0x06, 0x08, 0x8c, 0x01, 0x10, 0x8d, 0x01, 0x2a, 0x06,
+	0x08, 0x8d, 0x01, 0x10, 0x8e, 0x01, 0x2a, 0x06, 0x08, 0x90, 0x01, 0x10, 0x91, 0x01, 0x2a, 0x06,
+	0x08, 0x91, 0x01, 0x10, 0x92, 0x01, 0x2a, 0x06, 0x08, 0x92, 0x01, 0x10, 0x93, 0x01, 0x2a, 0x06,
+	0x08, 0x93, 0x01, 0x10, 0x94, 0x01, 0x2a, 0x06, 0x08, 0x94, 0x01, 0x10, 0x95, 0x01, 0x2a, 0x06,
+	0x08, 0x95, 0x01, 0x10, 0x96, 0x01, 0x2a, 0x06, 0x08, 0x96, 0x01, 0x10, 0x97, 0x01, 0x2a, 0x06,
+	0x08, 0x97, 0x01, 0x10, 0x98, 0x01, 0x2a, 0x06, 0x08, 0x9a, 0x01, 0x10, 0x9b, 0x01, 0x2a, 0x06,
+	0x08, 0x9b, 0x01, 0x10, 0x9c, 0x01, 0x2a, 0x06, 0x08, 0x9d, 0x01, 0x10, 0x9e, 0x01, 0x2a, 0x06,
+	0x08, 0x9e, 0x01, 0x10, 0x9f, 0x01, 0x2a, 0x06, 0x08, 0x9f, 0x01, 0x10, 0xa0, 0x01, 0x2a, 0x06,
+	0x08, 0xa0, 0x01, 0x10, 0xa1, 0x01, 0x2a, 0x06, 0x08, 0xa1, 0x01, 0x10, 0xa2, 0x01, 0x2a, 0x06,
+	0x08, 0xa2, 0x01, 0x10, 0xa3, 0x01, 0x2a, 0x06, 0x08, 0xa3, 0x01, 0x10, 0xa4, 0x01, 0x2a, 0x06,
+	0x08, 0xa4, 0x01, 0x10, 0xa5, 0x01, 0x2a, 0x06, 0x08, 0xa5, 0x01, 0x10, 0xa6, 0x01, 0x2a, 0x06,
+	0x08, 0xa6, 0x01, 0x10, 0xa7, 0x01, 0x2a, 0x06, 0x08, 0xa7, 0x01, 0x10, 0xa8, 0x01, 0x2a, 0x06,
+	0x08, 0xb0, 0x01, 0x10, 0xb1, 0x01, 0x2a, 0x06, 0x08, 0xb1, 0x01, 0x10, 0xb2, 0x01, 0x2a, 0x06,
+	0x08, 0xb2, 0x01, 0x10, 0xb3, 0x01, 0x2a, 0x06, 0x08, 0xb3, 0x01, 0x10, 0xb4, 0x01, 0x2a, 0x06,
+	0x08, 0xb4, 0x01, 0x10, 0xb5, 0x01, 0x2a, 0x06, 0x08, 0xb5, 0x01, 0x10, 0xb6, 0x01, 0x2a, 0x06,
+	0x08, 0xb6, 0x01, 0x10, 0xb7, 0x01, 0x2a, 0x06, 0x08, 0xb8, 0x01, 0x10, 0xb9, 0x01, 0x2a, 0x06,
+	0x08, 0xb9, 0x01, 0x10, 0xba, 0x01, 0x2a, 0x06, 0x08, 0xbb, 0x01, 0x10, 0xbc, 0x01, 0x2a, 0x06,
+	0x08, 0xbc, 0x01, 0x10, 0xbd, 0x01, 0x2a, 0x06, 0x08, 0xc7, 0x01, 0x10, 0xc8, 0x01, 0x2a, 0x06,
+	0x08, 0xc8, 0x01, 0x10, 0xc9, 0x01, 0x2a, 0x06, 0x08, 0xc9, 0x01, 0x10, 0xca, 0x01, 0x2a, 0x06,
+	0x08, 0xca, 0x01, 0x10, 0xcb, 0x01, 0x2a, 0x06, 0x08, 0xcb, 0x01, 0x10, 0xcc, 0x01, 0x2a, 0x06,
+	0x08, 0xcf, 0x01, 0x10, 0xd0, 0x01, 0x2a, 0x06, 0x08, 0xd0, 0x01, 0x10, 0xd1, 0x01, 0x2a, 0x06,
+	0x08, 0xd1, 0x01, 0x10, 0xd2, 0x01, 0x2a, 0x06, 0x08, 0xd2, 0x01, 0x10, 0xd3, 0x01, 0x2a, 0x06,
+	0x08, 0xd6, 0x01, 0x10, 0xd7, 0x01, 0x2a, 0x06, 0x08, 0xd7, 0x01, 0x10, 0xd8, 0x01, 0x2a, 0x06,
+	0x08, 0xd8, 0x01, 0x10, 0xd9, 0x01, 0x2a, 0x06, 0x08, 0xd9, 0x01, 0x10, 0xda, 0x01, 0x2a, 0x06,
+	0x08, 0xda, 0x01, 0x10, 0xdb, 0x01, 0x2a, 0x06, 0x08, 0xdb, 0x01, 0x10, 0xdc, 0x01, 0x2a, 0x06,
+	0x08, 0xdc, 0x01, 0x10, 0xdd, 0x01, 0x2a, 0x06, 0x08, 0xdd, 0x01, 0x10, 0xde, 0x01, 0x2a, 0x06,
+	0x08, 0xde, 0x01, 0x10, 0xdf, 0x01, 0x2a, 0x06, 0x08, 0xdf, 0x01, 0x10, 0xe0, 0x01, 0x2a, 0x06,
+	0x08, 0xe0, 0x01, 0x10, 0xe1, 0x01, 0x2a, 0x06, 0x08, 0xe1, 0x01, 0x10, 0xe2, 0x01, 0x2a, 0x06,
+	0x08, 0xe2, 0x01, 0x10, 0xe3, 0x01, 0x2a, 0x06, 0x08, 0xe3, 0x01, 0x10, 0xe4, 0x01, 0x2a, 0x06,
+	0x08, 0xe4, 0x01, 0x10, 0xe5, 0x01, 0x2a, 0x06, 0x08, 0xe5, 0x01, 0x10, 0xe6, 0x01, 0x2a, 0x06,
+	0x08, 0xe6, 0x01, 0x10, 0xe7, 0x01, 0x2a, 0x06, 0x08, 0xe7, 0x01, 0x10, 0xe8, 0x01, 0x2a, 0x06,
+	0x08, 0xe8, 0x01, 0x10, 0xe9, 0x01, 0x2a, 0x06, 0x08, 0xe9, 0x01, 0x10, 0xea, 0x01, 0x2a, 0x06,
+	0x08, 0xea, 0x01, 0x10, 0xeb, 0x01, 0x2a, 0x06, 0x08, 0xeb, 0x01, 0x10, 0xec, 0x01, 0x2a, 0x06,
+	0x08, 0xec, 0x01, 0x10, 0xed, 0x01, 0x2a, 0x06, 0x08, 0xed, 0x01, 0x10, 0xee, 0x01, 0x2a, 0x06,
+	0x08, 0xee, 0x01, 0x10, 0xef, 0x01, 0x2a, 0x06, 0x08, 0xef, 0x01, 0x10, 0xf0, 0x01, 0x2a, 0x06,
+	0x08, 0xf0, 0x01, 0x10, 0xf1, 0x01, 0x2a, 0x06, 0x08, 0xf1, 0x01, 0x10, 0xf2, 0x01, 0x2a, 0x06,
+	0x08, 0xf2, 0x01, 0x10, 0xf3, 0x01, 0x2a, 0x06, 0x08, 0xf3, 0x01, 0x10, 0xf4, 0x01, 0x2a, 0x06,
+	0x08, 0xf4, 0x01, 0x10, 0xf5, 0x01, 0x2a, 0x06, 0x08, 0xf5, 0x01, 0x10, 0xf6, 0x01, 0x2a, 0x06,
+	0x08, 0xf6, 0x01, 0x10, 0xf7, 0x01, 0x2a, 0x06, 0x08, 0xf7, 0x01, 0x10, 0xf8, 0x01, 0x2a, 0x06,
+	0x08, 0xf8, 0x01, 0x10, 0xf9, 0x01, 0x2a, 0x06, 0x08, 0xf9, 0x01, 0x10, 0xfa, 0x01, 0x2a, 0x06,
+	0x08, 0xfa, 0x01, 0x10, 0xfb, 0x01, 0x2a, 0x06, 0x08, 0xfb, 0x01, 0x10, 0xfc, 0x01, 0x2a, 0x06,
+	0x08, 0xfc, 0x01, 0x10, 0xfd, 0x01, 0x2a, 0x06, 0x08, 0xfd, 0x01, 0x10, 0xfe, 0x01, 0x2a, 0x06,
+	0x08, 0xfe, 0x01, 0x10, 0xff, 0x01, 0x2a, 0x06, 0x08, 0xff, 0x01, 0x10, 0x80, 0x02, 0x2a, 0x06,
+	0x08, 0x80, 0x02, 0x10, 0x81, 0x02, 0x2a, 0x06, 0x08, 0x81, 0x02, 0x10, 0x82, 0x02, 0x2a, 0x06,
+	0x08, 0x82, 0x02, 0x10, 0x83, 0x02, 0x2a, 0x06, 0x08, 0x83, 0x02, 0x10, 0x84, 0x02, 0x2a, 0x06,
+	0x08, 0x85, 0x02, 0x10, 0x86, 0x02, 0x2a, 0x06, 0x08, 0x86, 0x02, 0x10, 0x87, 0x02, 0x2a, 0x06,
+	0x08, 0x87, 0x02, 0x10, 0x88, 0x02, 0x2a, 0x06, 0x08, 0x88, 0x02, 0x10, 0x89, 0x02, 0x2a, 0x06,
+	0x08, 0x89, 0x02, 0x10, 0x8a, 0x02, 0x2a, 0x06, 0x08, 0x8a, 0x02, 0x10, 0x8b, 0x02, 0x2a, 0x06,
+	0x08, 0x8b, 0x02, 0x10, 0x8c, 0x02, 0x2a, 0x06, 0x08, 0x8c, 0x02, 0x10, 0x8d, 0x02, 0x2a, 0x06,
+	0x08, 0x8d, 0x02, 0x10, 0x8e, 0x02, 0x2a, 0x06, 0x08, 0x8e, 0x02, 0x10, 0x8f, 0x02, 0x2a, 0x06,
+	0x08, 0x8f, 0x02, 0x10, 0x90, 0x02, 0x2a, 0x06, 0x08, 0x90, 0x02, 0x10, 0x91, 0x02, 0x2a, 0x06,
+	0x08, 0x91, 0x02, 0x10, 0x92, 0x02, 0x2a, 0x06, 0x08, 0x93, 0x02, 0x10, 0x94, 0x02, 0x2a, 0x06,
+	0x08, 0x94, 0x02, 0x10, 0x95, 0x02, 0x2a, 0x06, 0x08, 0x95, 0x02, 0x10, 0x96, 0x02, 0x2a, 0x06,
+	0x08, 0x96, 0x02, 0x10, 0x97, 0x02, 0x2a, 0x06, 0x08, 0x97, 0x02, 0x10, 0x98, 0x02, 0x2a, 0x06,
+	0x08, 0x98, 0x02, 0x10, 0x99, 0x02, 0x2a, 0x06, 0x08, 0x99, 0x02, 0x10, 0x9a, 0x02, 0x2a, 0x06,
+	0x08, 0x9a, 0x02, 0x10, 0x9b, 0x02, 0x2a, 0x06, 0x08, 0x9b, 0x02, 0x10, 0x9c, 0x02, 0x2a, 0x06,
+	0x08, 0x9c, 0x02, 0x10, 0x9d, 0x02, 0x2a, 0x06, 0x08, 0x9d, 0x02, 0x10, 0x9e, 0x02, 0x2a, 0x06,
+	0x08, 0x9e, 0x02, 0x10, 0x9f, 0x02, 0x2a, 0x06, 0x08, 0xa2, 0x02, 0x10, 0xa3, 0x02, 0x2a, 0x06,
+	0x08, 0xa3, 0x02, 0x10, 0xa4, 0x02, 0x2a, 0x06, 0x08, 0xa4, 0x02, 0x10, 0xa5, 0x02, 0x2a, 0x06,
+	0x08, 0xa5, 0x02, 0x10, 0xa6, 0x02, 0x2a, 0x06, 0x08, 0xa6, 0x02, 0x10, 0xa7, 0x02, 0x2a, 0x06,
+	0x08, 0xa7, 0x02, 0x10, 0xa8, 0x02, 0x2a, 0x06, 0x08, 0xa8, 0x02, 0x10, 0xa9, 0x02, 0x2a, 0x06,
+	0x08, 0xa9, 0x02, 0x10, 0xaa, 0x02, 0x2a, 0x06, 0x08, 0xaa, 0x02, 0x10, 0xab, 0x02, 0x2a, 0x06,
+	0x08, 0xab, 0x02, 0x10, 0xac, 0x02, 0x2a, 0x06, 0x08, 0xac, 0x02, 0x10, 0xad, 0x02, 0x2a, 0x06,
+	0x08, 0xad, 0x02, 0x10, 0xae, 0x02, 0x2a, 0x06, 0x08, 0xae, 0x02, 0x10, 0xaf, 0x02, 0x2a, 0x06,
+	0x08, 0xaf, 0x02, 0x10, 0xb0, 0x02, 0x2a, 0x06, 0x08, 0xb0, 0x02, 0x10, 0xb1, 0x02, 0x2a, 0x06,
+	0x08, 0xb1, 0x02, 0x10, 0xb2, 0x02, 0x2a, 0x06, 0x08, 0xb2, 0x02, 0x10, 0xb3, 0x02, 0x2a, 0x06,
+	0x08, 0xb3, 0x02, 0x10, 0xb4, 0x02, 0x2a, 0x06, 0x08, 0xb4, 0x02, 0x10, 0xb5, 0x02, 0x2a, 0x06,
+	0x08, 0xb5, 0x02, 0x10, 0xb6, 0x02, 0x2a, 0x06, 0x08, 0xb6, 0x02, 0x10, 0xb7, 0x02, 0x2a, 0x06,
+	0x08, 0xb7, 0x02, 0x10, 0xb8, 0x02, 0x2a, 0x06, 0x08, 0xb8, 0x02, 0x10, 0xb9, 0x02, 0x2a, 0x06,
+	0x08, 0xb9, 0x02, 0x10, 0xba, 0x02, 0x2a, 0x06, 0x08, 0xba, 0x02, 0x10, 0xbb, 0x02, 0x2a, 0x06,
+	0x08, 0xbb, 0x02, 0x10, 0xbc, 0x02, 0x2a, 0x06, 0x08, 0xbc, 0x02, 0x10, 0xbd, 0x02, 0x2a, 0x06,
+	0x08, 0xbd, 0x02, 0x10, 0xbe, 0x02, 0x2a, 0x06, 0x08, 0xbe, 0x02, 0x10, 0xbf, 0x02, 0x2a, 0x06,
+	0x08, 0xbf, 0x02, 0x10, 0xc0, 0x02, 0x2a, 0x06, 0x08, 0xc0, 0x02, 0x10, 0xc1, 0x02, 0x2a, 0x06,
+	0x08, 0xc1, 0x02, 0x10, 0xc2, 0x02, 0x2a, 0x06, 0x08, 0xc2, 0x02, 0x10, 0xc3, 0x02, 0x2a, 0x06,
+	0x08, 0xc3, 0x02, 0x10, 0xc4, 0x02, 0x2a, 0x06, 0x08, 0xc4, 0x02, 0x10, 0xc5, 0x02, 0x2a, 0x06,
+	0x08, 0xc5, 0x02, 0x10, 0xc6, 0x02, 0x2a, 0x06, 0x08, 0xc6, 0x02, 0x10, 0xc7, 0x02, 0x2a, 0x06,
+	0x08, 0xc7, 0x02, 0x10, 0xc8, 0x02, 0x2a, 0x06, 0x08, 0xc8, 0x02, 0x10, 0xc9, 0x02, 0x2a, 0x06,
+	0x08, 0xc9, 0x02, 0x10, 0xca, 0x02, 0x2a, 0x06, 0x08, 0xca, 0x02, 0x10, 0xcb, 0x02, 0x2a, 0x06,
+	0x08, 0xcb, 0x02, 0x10, 0xcc, 0x02, 0x2a, 0x06, 0x08, 0xcc, 0x02, 0x10, 0xcd, 0x02, 0x2a, 0x06,
+	0x08, 0xcd, 0x02, 0x10, 0xce, 0x02, 0x2a, 0x06, 0x08, 0xce, 0x02, 0x10, 0xcf, 0x02, 0x2a, 0x06,
+	0x08, 0xcf, 0x02, 0x10, 0xd0, 0x02, 0x2a, 0x06, 0x08, 0xd0, 0x02, 0x10, 0xd1, 0x02, 0x2a, 0x06,
+	0x08, 0xd1, 0x02, 0x10, 0xd2, 0x02, 0x2a, 0x06, 0x08, 0xd2, 0x02, 0x10, 0xd3, 0x02, 0x2a, 0x06,
+	0x08, 0xd3, 0x02, 0x10, 0xd4, 0x02, 0x2a, 0x06, 0x08, 0xd4, 0x02, 0x10, 0xd5, 0x02, 0x2a, 0x06,
+	0x08, 0xd5, 0x02, 0x10, 0xd6, 0x02, 0x2a, 0x06, 0x08, 0xd6, 0x02, 0x10, 0xd7, 0x02, 0x2a, 0x06,
+	0x08, 0xd7, 0x02, 0x10, 0xd8, 0x02, 0x2a, 0x06, 0x08, 0xd8, 0x02, 0x10, 0xd9, 0x02, 0x2a, 0x06,
+	0x08, 0xd9, 0x02, 0x10, 0xda, 0x02, 0x2a, 0x06, 0x08, 0xda, 0x02, 0x10, 0xdb, 0x02, 0x2a, 0x06,
+	0x08, 0xdb, 0x02, 0x10, 0xdc, 0x02, 0x2a, 0x06, 0x08, 0xdc, 0x02, 0x10, 0xdd, 0x02, 0x2a, 0x06,
+	0x08, 0xdd, 0x02, 0x10, 0xde, 0x02, 0x2a, 0x06, 0x08, 0xde, 0x02, 0x10, 0xdf, 0x02, 0x2a, 0x06,
+	0x08, 0xdf, 0x02, 0x10, 0xe0, 0x02, 0x2a, 0x06, 0x08, 0xe0, 0x02, 0x10, 0xe1, 0x02, 0x2a, 0x06,
+	0x08, 0xe1, 0x02, 0x10, 0xe2, 0x02, 0x2a, 0x06, 0x08, 0xe2, 0x02, 0x10, 0xe3, 0x02, 0x2a, 0x06,
+	0x08, 0xe3, 0x02, 0x10, 0xe4, 0x02, 0x2a, 0x06, 0x08, 0xe4, 0x02, 0x10, 0xe5, 0x02, 0x2a, 0x06,
+	0x08, 0xe5, 0x02, 0x10, 0xe6, 0x02, 0x2a, 0x06, 0x08, 0xe6, 0x02, 0x10, 0xe7, 0x02, 0x2a, 0x06,
+	0x08, 0xe7, 0x02, 0x10, 0xe8, 0x02, 0x2a, 0x06, 0x08, 0xe8, 0x02, 0x10, 0xe9, 0x02, 0x2a, 0x06,
+	0x08, 0xe9, 0x02, 0x10, 0xea, 0x02, 0x2a, 0x06, 0x08, 0xea, 0x02, 0x10, 0xeb, 0x02, 0x2a, 0x06,
+	0x08, 0xeb, 0x02, 0x10, 0xec, 0x02, 0x2a, 0x06, 0x08, 0xec, 0x02, 0x10, 0xed, 0x02, 0x2a, 0x06,
+	0x08, 0xed, 0x02, 0x10, 0xee, 0x02, 0x2a, 0x06, 0x08, 0xee, 0x02, 0x10, 0xef, 0x02, 0x2a, 0x06,
+	0x08, 0xef, 0x02, 0x10, 0xf0, 0x02, 0x2a, 0x06, 0x08, 0xf0, 0x02, 0x10, 0xf1, 0x02, 0x2a, 0x06,
+	0x08, 0xf1, 0x02, 0x10, 0xf2, 0x02, 0x2a, 0x06, 0x08, 0xf2, 0x02, 0x10, 0xf3, 0x02, 0x2a, 0x06,
+	0x08, 0xf3, 0x02, 0x10, 0xf4, 0x02, 0x2a, 0x06, 0x08, 0xf4, 0x02, 0x10, 0xf5, 0x02, 0x2a, 0x06,
+	0x08, 0xf5, 0x02, 0x10, 0xf6, 0x02, 0x2a, 0x06, 0x08, 0xf6, 0x02, 0x10, 0xf7, 0x02, 0x2a, 0x06,
+	0x08, 0xf7, 0x02, 0x10, 0xf8, 0x02, 0x2a, 0x06, 0x08, 0xf8, 0x02, 0x10, 0xf9, 0x02, 0x2a, 0x06,
+	0x08, 0xf9, 0x02, 0x10, 0xfa, 0x02, 0x2a, 0x06, 0x08, 0xfa, 0x02, 0x10, 0xfb, 0x02, 0x2a, 0x06,
+	0x08, 0xfb, 0x02, 0x10, 0xfc, 0x02, 0x2a, 0x06, 0x08, 0xfc, 0x02, 0x10, 0xfd, 0x02, 0x2a, 0x06,
+	0x08, 0xfd, 0x02, 0x10, 0xfe, 0x02, 0x2a, 0x06, 0x08, 0xfe, 0x02, 0x10, 0xff, 0x02, 0x2a, 0x06,
+	0x08, 0xff, 0x02, 0x10, 0x80, 0x03, 0x2a, 0x06, 0x08, 0x80, 0x03, 0x10, 0x81, 0x03, 0x2a, 0x06,
+	0x08, 0x81, 0x03, 0x10, 0x82, 0x03, 0x2a, 0x06, 0x08, 0x82, 0x03, 0x10, 0x83, 0x03, 0x2a, 0x06,
+	0x08, 0x83, 0x03, 0x10, 0x84, 0x03, 0x2a, 0x06, 0x08, 0x84, 0x03, 0x10, 0x85, 0x03, 0x2a, 0x06,
+	0x08, 0x85, 0x03, 0x10, 0x86, 0x03, 0x2a, 0x06, 0x08, 0x86, 0x03, 0x10, 0x87, 0x03, 0x2a, 0x06,
+	0x08, 0x87, 0x03, 0x10, 0x88, 0x03, 0x2a, 0x06, 0x08, 0x88, 0x03, 0x10, 0x89, 0x03, 0x2a, 0x06,
+	0x08, 0x89, 0x03, 0x10, 0x8a, 0x03, 0x2a, 0x06, 0x08, 0x8a, 0x03, 0x10, 0x8b, 0x03, 0x2a, 0x06,
+	0x08, 0x8b, 0x03, 0x10, 0x8c, 0x03, 0x2a, 0x06, 0x08, 0x8c, 0x03, 0x10, 0x8d, 0x03, 0x2a, 0x06,
+	0x08, 0x8d, 0x03, 0x10, 0x8e, 0x03, 0x2a, 0x06, 0x08, 0x8e, 0x03, 0x10, 0x8f, 0x03, 0x2a, 0x06,
+	0x08, 0x8f, 0x03, 0x10, 0x90, 0x03, 0x2a, 0x06, 0x08, 0x90, 0x03, 0x10, 0x91, 0x03, 0x2a, 0x06,
+	0x08, 0x91, 0x03, 0x10, 0x92, 0x03, 0x2a, 0x06, 0x08, 0x92, 0x03, 0x10, 0x93, 0x03, 0x2a, 0x06,
+	0x08, 0x93, 0x03, 0x10, 0x94, 0x03, 0x2a, 0x06, 0x08, 0x94, 0x03, 0x10, 0x95, 0x03, 0x2a, 0x06,
+	0x08, 0x95, 0x03, 0x10, 0x96, 0x03, 0x2a, 0x06, 0x08, 0x96, 0x03, 0x10, 0x97, 0x03, 0x2a, 0x06,
+	0x08, 0x97, 0x03, 0x10, 0x98, 0x03, 0x2a, 0x06, 0x08, 0x98, 0x03, 0x10, 0x99, 0x03, 0x2a, 0x06,
+	0x08, 0x99, 0x03, 0x10, 0x9a, 0x03, 0x2a, 0x06, 0x08, 0x9a, 0x03, 0x10, 0x9b, 0x03, 0x2a, 0x06,
+	0x08, 0x9b, 0x03, 0x10, 0x9c, 0x03, 0x2a, 0x06, 0x08, 0x9c, 0x03, 0x10, 0x9d, 0x03, 0x2a, 0x06,
+	0x08, 0x9d, 0x03, 0x10, 0x9e, 0x03, 0x2a, 0x06, 0x08, 0x9e, 0x03, 0x10, 0x9f, 0x03, 0x2a, 0x06,
+	0x08, 0x9f, 0x03, 0x10, 0xa0, 0x03, 0x2a, 0x06, 0x08, 0xa0, 0x03, 0x10, 0xa1, 0x03, 0x2a, 0x06,
+	0x08, 0xa1, 0x03, 0x10, 0xa2, 0x03, 0x2a, 0x06, 0x08, 0xa2, 0x03, 0x10, 0xa3, 0x03, 0x2a, 0x06,
+	0x08, 0xa3, 0x03, 0x10, 0xa4, 0x03, 0x2a, 0x06, 0x08, 0xa4, 0x03, 0x10, 0xa5, 0x03, 0x2a, 0x06,
+	0x08, 0xa5, 0x03, 0x10, 0xa6, 0x03, 0x2a, 0x06, 0x08, 0xa6, 0x03, 0x10, 0xa7, 0x03, 0x2a, 0x06,
+	0x08, 0xa7, 0x03, 0x10, 0xa8, 0x03, 0x2a, 0x06, 0x08, 0xa8, 0x03, 0x10, 0xa9, 0x03, 0x2a, 0x06,
+	0x08, 0xa9, 0x03, 0x10, 0xaa, 0x03, 0x2a, 0x06, 0x08, 0xaa, 0x03, 0x10, 0xab, 0x03, 0x2a, 0x06,
+	0x08, 0xab, 0x03, 0x10, 0xac, 0x03, 0x2a, 0x06, 0x08, 0xac, 0x03, 0x10, 0xad, 0x03, 0x2a, 0x06,
+	0x08, 0xad, 0x03, 0x10, 0xae, 0x03, 0x2a, 0x06, 0x08, 0xae, 0x03, 0x10, 0xaf, 0x03, 0x2a, 0x06,
+	0x08, 0xaf, 0x03, 0x10, 0xb0, 0x03, 0x2a, 0x06, 0x08, 0xb0, 0x03, 0x10, 0xb1, 0x03, 0x2a, 0x06,
+	0x08, 0xb1, 0x03, 0x10, 0xb2, 0x03, 0x2a, 0x06, 0x08, 0xb2, 0x03, 0x10, 0xb3, 0x03, 0x2a, 0x06,
+	0x08, 0xb3, 0x03, 0x10, 0xb4, 0x03, 0x2a, 0x06, 0x08, 0xb4, 0x03, 0x10, 0xb5, 0x03, 0x2a, 0x06,
+	0x08, 0xb5, 0x03, 0x10, 0xb6, 0x03, 0x2a, 0x06, 0x08, 0xb6, 0x03, 0x10, 0xb7, 0x03, 0x2a, 0x06,
+	0x08, 0xb7, 0x03, 0x10, 0xb8, 0x03, 0x2a, 0x06, 0x08, 0xb8, 0x03, 0x10, 0xb9, 0x03, 0x2a, 0x06,
+	0x08, 0xb9, 0x03, 0x10, 0xba, 0x03, 0x2a, 0x06, 0x08, 0xba, 0x03, 0x10, 0xbb, 0x03, 0x2a, 0x06,
+	0x08, 0xbb, 0x03, 0x10, 0xbc, 0x03, 0x2a, 0x06, 0x08, 0xbc, 0x03, 0x10, 0xbd, 0x03, 0x2a, 0x06,
+	0x08, 0xbd, 0x03, 0x10, 0xbe, 0x03, 0x2a, 0x06, 0x08, 0xbe, 0x03, 0x10, 0xbf, 0x03, 0x2a, 0x06,
+	0x08, 0xbf, 0x03, 0x10, 0xc0, 0x03, 0x2a, 0x06, 0x08, 0xc0, 0x03, 0x10, 0xc1, 0x03, 0x2a, 0x06,
+	0x08, 0xc1, 0x03, 0x10, 0xc2, 0x03, 0x2a, 0x06, 0x08, 0xc2, 0x03, 0x10, 0xc3, 0x03, 0x2a, 0x06,
+	0x08, 0xc3, 0x03, 0x10, 0xc4, 0x03, 0x2a, 0x06, 0x08, 0xc4, 0x03, 0x10, 0xc5, 0x03, 0x2a, 0x06,
+	0x08, 0xc5, 0x03, 0x10, 0xc6, 0x03, 0x2a, 0x06, 0x08, 0xc6, 0x03, 0x10, 0xc7, 0x03, 0x2a, 0x06,
+	0x08, 0xc7, 0x03, 0x10, 0xc8, 0x03, 0x2a, 0x06, 0x08, 0xc8, 0x03, 0x10, 0xc9, 0x03, 0x2a, 0x06,
+	0x08, 0xc9, 0x03, 0x10, 0xca, 0x03, 0x2a, 0x06, 0x08, 0xca, 0x03, 0x10, 0xcb, 0x03, 0x2a, 0x06,
+	0x08, 0xcb, 0x03, 0x10, 0xcc, 0x03, 0x2a, 0x06, 0x08, 0xcc, 0x03, 0x10, 0xcd, 0x03, 0x2a, 0x06,
+	0x08, 0xcd, 0x03, 0x10, 0xce, 0x03, 0x2a, 0x06, 0x08, 0xce, 0x03, 0x10, 0xcf, 0x03, 0x2a, 0x06,
+	0x08, 0xcf, 0x03, 0x10, 0xd0, 0x03, 0x2a, 0x06, 0x08, 0xd0, 0x03, 0x10, 0xd1, 0x03, 0x2a, 0x06,
+	0x08, 0xd1, 0x03, 0x10, 0xd2, 0x03, 0x2a, 0x06, 0x08, 0xd2, 0x03, 0x10, 0xd3, 0x03, 0x2a, 0x06,
+	0x08, 0xd3, 0x03, 0x10, 0xd4, 0x03, 0x2a, 0x06, 0x08, 0xd4, 0x03, 0x10, 0xd5, 0x03, 0x2a, 0x06,
+	0x08, 0xd5, 0x03, 0x10, 0xd6, 0x03, 0x2a, 0x06, 0x08, 0xd6, 0x03, 0x10, 0xd7, 0x03, 0x2a, 0x06,
+	0x08, 0xd7, 0x03, 0x10, 0xd8, 0x03, 0x2a, 0x06, 0x08, 0xd8, 0x03, 0x10, 0xd9, 0x03, 0x2a, 0x06,
+	0x08, 0xd9, 0x03, 0x10, 0xda, 0x03, 0x2a, 0x06, 0x08, 0xda, 0x03, 0x10, 0xdb, 0x03, 0x2a, 0x06,
+	0x08, 0xfd, 0x03, 0x10, 0xfe, 0x03, 0x2a, 0x06, 0x08, 0xff, 0x03, 0x10, 0x80, 0x04, 0x2a, 0x06,
+	0x08, 0x80, 0x04, 0x10, 0x81, 0x04, 0x2a, 0x06, 0x08, 0x81, 0x04, 0x10, 0x82, 0x04, 0x2a, 0x06,
+	0x08, 0x82, 0x04, 0x10, 0x83, 0x04, 0x2a, 0x06, 0x08, 0x83, 0x04, 0x10, 0x84, 0x04, 0x2a, 0x06,
+	0x08, 0x84, 0x04, 0x10, 0x85, 0x04, 0x2a, 0x06, 0x08, 0x85, 0x04, 0x10, 0x86, 0x04, 0x2a, 0x06,
+	0x08, 0x86, 0x04, 0x10, 0x87, 0x04, 0x2a, 0x06, 0x08, 0x87, 0x04, 0x10, 0x88, 0x04, 0x2a, 0x06,
+	0x08, 0x88, 0x04, 0x10, 0x89, 0x04, 0x2a, 0x06, 0x08, 0x89, 0x04, 0x10, 0x8a, 0x04, 0x2a, 0x06,
+	0x08, 0x8a, 0x04, 0x10, 0x8b, 0x04, 0x2a, 0x06, 0x08, 0x8b, 0x04, 0x10, 0x8c, 0x04, 0x2a, 0x06,
+	0x08, 0x8c, 0x04, 0x10, 0x8d, 0x04, 0x2a, 0x06, 0x08, 0x8d, 0x04, 0x10, 0x8e, 0x04, 0x2a, 0x06,
+	0x08, 0x8e, 0x04, 0x10, 0x8f, 0x04, 0x2a, 0x06, 0x08, 0x8f, 0x04, 0x10, 0x90, 0x04, 0x2a, 0x06,
+	0x08, 0x90, 0x04, 0x10, 0x91, 0x04, 0x2a, 0x06, 0x08, 0x91, 0x04, 0x10, 0x92, 0x04, 0x2a, 0x06,
+	0x08, 0x92, 0x04, 0x10, 0x93, 0x04, 0x2a, 0x06, 0x08, 0x93, 0x04, 0x10, 0x94, 0x04, 0x2a, 0x06,
+	0x08, 0x94, 0x04, 0x10, 0x95, 0x04, 0x2a, 0x06, 0x08, 0x95, 0x04, 0x10, 0x96, 0x04, 0x2a, 0x06,
+	0x08, 0x96, 0x04, 0x10, 0x97, 0x04, 0x2a, 0x06, 0x08, 0x97, 0x04, 0x10, 0x98, 0x04, 0x2a, 0x06,
+	0x08, 0x98, 0x04, 0x10, 0x99, 0x04, 0x2a, 0x06, 0x08, 0x99, 0x04, 0x10, 0x9a, 0x04, 0x2a, 0x06,
+	0x08, 0x9a, 0x04, 0x10, 0x9b, 0x04, 0x2a, 0x06, 0x08, 0x9b, 0x04, 0x10, 0x9c, 0x04, 0x2a, 0x06,
+	0x08, 0x9c, 0x04, 0x10, 0x9d, 0x04, 0x2a, 0x06, 0x08, 0x9d, 0x04, 0x10, 0x9e, 0x04, 0x2a, 0x06,
+	0x08, 0x9e, 0x04, 0x10, 0x9f, 0x04, 0x2a, 0x06, 0x08, 0x9f, 0x04, 0x10, 0xa0, 0x04, 0x2a, 0x06,
+	0x08, 0xa0, 0x04, 0x10, 0xa1, 0x04, 0x2a, 0x06, 0x08, 0xa1, 0x04, 0x10, 0xa2, 0x04, 0x2a, 0x06,
+	0x08, 0xa2, 0x04, 0x10, 0xa3, 0x04, 0x2a, 0x06, 0x08, 0xa3, 0x04, 0x10, 0xa4, 0x04, 0x2a, 0x06,
+	0x08, 0xa4, 0x04, 0x10, 0xa5, 0x04, 0x2a, 0x06, 0x08, 0xa5, 0x04, 0x10, 0xa6, 0x04, 0x2a, 0x06,
+	0x08, 0xa6, 0x04, 0x10, 0xa7, 0x04, 0x2a, 0x06, 0x08, 0xa7, 0x04, 0x10, 0xa8, 0x04, 0x2a, 0x06,
+	0x08, 0xa8, 0x04, 0x10, 0xa9, 0x04, 0x2a, 0x06, 0x08, 0xa9, 0x04, 0x10, 0xaa, 0x04, 0x2a, 0x06,
+	0x08, 0xaa, 0x04, 0x10, 0xab, 0x04, 0x2a, 0x06, 0x08, 0xab, 0x04, 0x10, 0xac, 0x04, 0x2a, 0x06,
+	0x08, 0xac, 0x04, 0x10, 0xad, 0x04, 0x2a, 0x06, 0x08, 0xad, 0x04, 0x10, 0xae, 0x04, 0x2a, 0x06,
+	0x08, 0xae, 0x04, 0x10, 0xaf, 0x04, 0x2a, 0x06, 0x08, 0xaf, 0x04, 0x10, 0xb0, 0x04, 0x2a, 0x06,
+	0x08, 0xb0, 0x04, 0x10, 0xb1, 0x04, 0x2a, 0x06, 0x08, 0xb1, 0x04, 0x10, 0xb2, 0x04, 0x2a, 0x06,
+	0x08, 0xb2, 0x04, 0x10, 0xb3, 0x04, 0x2a, 0x06, 0x08, 0xb3, 0x04, 0x10, 0xb4, 0x04, 0x2a, 0x06,
+	0x08, 0xb4, 0x04, 0x10, 0xb5, 0x04, 0x2a, 0x06, 0x08, 0xb5, 0x04, 0x10, 0xb6, 0x04, 0x2a, 0x06,
+	0x08, 0xb6, 0x04, 0x10, 0xb7, 0x04, 0x2a, 0x06, 0x08, 0xb7, 0x04, 0x10, 0xb8, 0x04, 0x2a, 0x06,
+	0x08, 0xb8, 0x04, 0x10, 0xb9, 0x04, 0x2a, 0x06, 0x08, 0xb9, 0x04, 0x10, 0xba, 0x04, 0x2a, 0x06,
+	0x08, 0xba, 0x04, 0x10, 0xbb, 0x04, 0x2a, 0x06, 0x08, 0xbb, 0x04, 0x10, 0xbc, 0x04, 0x2a, 0x06,
+	0x08, 0xbc, 0x04, 0x10, 0xbd, 0x04, 0x2a, 0x06, 0x08, 0xbd, 0x04, 0x10, 0xbe, 0x04, 0x2a, 0x06,
+	0x08, 0xbe, 0x04, 0x10, 0xbf, 0x04, 0x2a, 0x06, 0x08, 0xbf, 0x04, 0x10, 0xc0, 0x04, 0x2a, 0x06,
+	0x08, 0xc0, 0x04, 0x10, 0xc1, 0x04, 0x2a, 0x06, 0x08, 0xc1, 0x04, 0x10, 0xc2, 0x04, 0x2a, 0x06,
+	0x08, 0xc2, 0x04, 0x10, 0xc3, 0x04, 0x2a, 0x06, 0x08, 0xc3, 0x04, 0x10, 0xc4, 0x04, 0x2a, 0x06,
+	0x08, 0xc4, 0x04, 0x10, 0xc5, 0x04, 0x2a, 0x06, 0x08, 0xc5, 0x04, 0x10, 0xc6, 0x04, 0x2a, 0x06,
+	0x08, 0xc6, 0x04, 0x10, 0xc7, 0x04, 0x2a, 0x06, 0x08, 0xc7, 0x04, 0x10, 0xc8, 0x04, 0x2a, 0x06,
+	0x08, 0xc8, 0x04, 0x10, 0xc9, 0x04, 0x2a, 0x06, 0x08, 0xc9, 0x04, 0x10, 0xca, 0x04, 0x2a, 0x06,
+	0x08, 0xca, 0x04, 0x10, 0xcb, 0x04, 0x2a, 0x06, 0x08, 0xcb, 0x04, 0x10, 0xcc, 0x04, 0x2a, 0x06,
+	0x08, 0xcc, 0x04, 0x10, 0xcd, 0x04, 0x2a, 0x06, 0x08, 0xcd, 0x04, 0x10, 0xce, 0x04, 0x2a, 0x06,
+	0x08, 0xce, 0x04, 0x10, 0xcf, 0x04, 0x2a, 0x06, 0x08, 0xdc, 0x04, 0x10, 0xdd, 0x04, 0x2a, 0x06,
+	0x08, 0xdd, 0x04, 0x10, 0xde, 0x04, 0x2a, 0x06, 0x08, 0xde, 0x04, 0x10, 0xdf, 0x04, 0x2a, 0x06,
+	0x08, 0xdf, 0x04, 0x10, 0xe0, 0x04, 0x2a, 0x06, 0x08, 0xe0, 0x04, 0x10, 0xe1, 0x04, 0x2a, 0x06,
+	0x08, 0xe1, 0x04, 0x10, 0xe2, 0x04, 0x2a, 0x06, 0x08, 0xe2, 0x04, 0x10, 0xe3, 0x04, 0x2a, 0x06,
+	0x08, 0xe3, 0x04, 0x10, 0xe4, 0x04, 0x2a, 0x06, 0x08, 0xe4, 0x04, 0x10, 0xe5, 0x04, 0x2a, 0x06,
+	0x08, 0xe5, 0x04, 0x10, 0xe6, 0x04, 0x2a, 0x06, 0x08, 0xe6, 0x04, 0x10, 0xe7, 0x04, 0x2a, 0x06,
+	0x08, 0xe7, 0x04, 0x10, 0xe8, 0x04, 0x2a, 0x06, 0x08, 0xe8, 0x04, 0x10, 0xe9, 0x04, 0x2a, 0x06,
+	0x08, 0xe9, 0x04, 0x10, 0xea, 0x04, 0x2a, 0x06, 0x08, 0xea, 0x04, 0x10, 0xeb, 0x04, 0x2a, 0x06,
+	0x08, 0xeb, 0x04, 0x10, 0xec, 0x04, 0x2a, 0x06, 0x08, 0xec, 0x04, 0x10, 0xed, 0x04, 0x2a, 0x06,
+	0x08, 0xed, 0x04, 0x10, 0xee, 0x04, 0x2a, 0x06, 0x08, 0xee, 0x04, 0x10, 0xef, 0x04, 0x2a, 0x06,
+	0x08, 0xef, 0x04, 0x10, 0xf0, 0x04, 0x2a, 0x06, 0x08, 0xf0, 0x04, 0x10, 0xf1, 0x04, 0x2a, 0x06,
+	0x08, 0xf1, 0x04, 0x10, 0xf2, 0x04, 0x2a, 0x06, 0x08, 0xf2, 0x04, 0x10, 0xf3, 0x04, 0x2a, 0x06,
+	0x08, 0xf3, 0x04, 0x10, 0xf4, 0x04, 0x2a, 0x06, 0x08, 0xf4, 0x04, 0x10, 0xf5, 0x04, 0x2a, 0x06,
+	0x08, 0xf5, 0x04, 0x10, 0xf6, 0x04, 0x2a, 0x06, 0x08, 0xad, 0x06, 0x10, 0xae, 0x06, 0x2a, 0x06,
+	0x08, 0xae, 0x06, 0x10, 0xaf, 0x06, 0x2a, 0x06, 0x08, 0xaf, 0x06, 0x10, 0xb0, 0x06, 0x2a, 0x06,
+	0x08, 0xb0, 0x06, 0x10, 0xb1, 0x06, 0x2a, 0x06, 0x08, 0xb1, 0x06, 0x10, 0xb2, 0x06, 0x2a, 0x06,
+	0x08, 0xb2, 0x06, 0x10, 0xb3, 0x06, 0x2a, 0x06, 0x08, 0xb3, 0x06, 0x10, 0xb4, 0x06, 0x2a, 0x06,
+	0x08, 0xb4, 0x06, 0x10, 0xb5, 0x06, 0x2a, 0x06, 0x08, 0xb5, 0x06, 0x10, 0xb6, 0x06, 0x2a, 0x06,
+	0x08, 0xb6, 0x06, 0x10, 0xb7, 0x06, 0x2a, 0x06, 0x08, 0xb7, 0x06, 0x10, 0xb8, 0x06, 0x2a, 0x06,
+	0x08, 0xb8, 0x06, 0x10, 0xb9, 0x06, 0x2a, 0x06, 0x08, 0xbb, 0x06, 0x10, 0xbc, 0x06, 0x2a, 0x06,
+	0x08, 0xbc, 0x06, 0x10, 0xbd, 0x06, 0x2a, 0x06, 0x08, 0xbd, 0x06, 0x10, 0xbe, 0x06, 0x2a, 0x06,
+	0x08, 0xbe, 0x06, 0x10, 0xbf, 0x06, 0x2a, 0x06, 0x08, 0xbf, 0x06, 0x10, 0xc0, 0x06, 0x2a, 0x06,
+	0x08, 0xc0, 0x06, 0x10, 0xc1, 0x06, 0x2a, 0x06, 0x08, 0xc1, 0x06, 0x10, 0xc2, 0x06, 0x2a, 0x06,
+	0x08, 0xc2, 0x06, 0x10, 0xc3, 0x06, 0x2a, 0x06, 0x08, 0xc3, 0x06, 0x10, 0xc4, 0x06, 0x2a, 0x06,
+	0x08, 0xc4, 0x06, 0x10, 0xc5, 0x06, 0x2a, 0x06, 0x08, 0xc5, 0x06, 0x10, 0xc6, 0x06, 0x2a, 0x06,
+	0x08, 0xc6, 0x06, 0x10, 0xc7, 0x06, 0x2a, 0x06, 0x08, 0xc7, 0x06, 0x10, 0xc8, 0x06, 0x2a, 0x06,
+	0x08, 0xc8, 0x06, 0x10, 0xc9, 0x06, 0x2a, 0x06, 0x08, 0xc9, 0x06, 0x10, 0xca, 0x06, 0x2a, 0x06,
+	0x08, 0xca, 0x06, 0x10, 0xcb, 0x06, 0x2a, 0x06, 0x08, 0xcb, 0x06, 0x10, 0xcc, 0x06, 0x2a, 0x06,
+	0x08, 0xcc, 0x06, 0x10, 0xcd, 0x06, 0x2a, 0x06, 0x08, 0xcd, 0x06, 0x10, 0xce, 0x06, 0x2a, 0x06,
+	0x08, 0xce, 0x06, 0x10, 0xcf, 0x06, 0x2a, 0x06, 0x08, 0xcf, 0x06, 0x10, 0xd0, 0x06, 0x2a, 0x06,
+	0x08, 0xd0, 0x06, 0x10, 0xd1, 0x06, 0x2a, 0x06, 0x08, 0xd1, 0x06, 0x10, 0xd2, 0x06, 0x2a, 0x06,
+	0x08, 0xd2, 0x06, 0x10, 0xd3, 0x06, 0x2a, 0x06, 0x08, 0xd3, 0x06, 0x10, 0xd4, 0x06, 0x2a, 0x06,
+	0x08, 0xd4, 0x06, 0x10, 0xd5, 0x06, 0x2a, 0x06, 0x08, 0xd5, 0x06, 0x10, 0xd6, 0x06, 0x2a, 0x06,
+	0x08, 0xd6, 0x06, 0x10, 0xd7, 0x06, 0x2a, 0x06, 0x08, 0xd7, 0x06, 0x10, 0xd8, 0x06, 0x2a, 0x06,
+	0x08, 0xd8, 0x06, 0x10, 0xd9, 0x06, 0x2a, 0x06, 0x08, 0xd9, 0x06, 0x10, 0xda, 0x06, 0x2a, 0x06,
+	0x08, 0xda, 0x06, 0x10, 0xdb, 0x06, 0x2a, 0x06, 0x08, 0xdb, 0x06, 0x10, 0xdc, 0x06, 0x2a, 0x06,
+	0x08, 0xdc, 0x06, 0x10, 0xdd, 0x06, 0x2a, 0x06, 0x08, 0xdd, 0x06, 0x10, 0xde, 0x06, 0x2a, 0x06,
+	0x08, 0xde, 0x06, 0x10, 0xdf, 0x06, 0x2a, 0x06, 0x08, 0xdf, 0x06, 0x10, 0xe0, 0x06, 0x2a, 0x06,
+	0x08, 0xe0, 0x06, 0x10, 0xe1, 0x06, 0x2a, 0x06, 0x08, 0xe1, 0x06, 0x10, 0xe2, 0x06, 0x2a, 0x06,
+	0x08, 0xe2, 0x06, 0x10, 0xe3, 0x06, 0x2a, 0x06, 0x08, 0xe3, 0x06, 0x10, 0xe4, 0x06, 0x2a, 0x06,
+	0x08, 0xe4, 0x06, 0x10, 0xe5, 0x06, 0x2a, 0x06, 0x08, 0xe5, 0x06, 0x10, 0xe6, 0x06, 0x2a, 0x06,
+	0x08, 0xe6, 0x06, 0x10, 0xe7, 0x06, 0x2a, 0x06, 0x08, 0xe7, 0x06, 0x10, 0xe8, 0x06, 0x2a, 0x06,
+	0x08, 0xf0, 0x06, 0x10, 0xf1, 0x06, 0x2a, 0x06, 0x08, 0xf1, 0x06, 0x10, 0xf2, 0x06, 0x2a, 0x06,
+	0x08, 0xf2, 0x06, 0x10, 0xf3, 0x06, 0x2a, 0x06, 0x08, 0xf3, 0x06, 0x10, 0xf4, 0x06, 0x2a, 0x06,
+	0x08, 0xf4, 0x06, 0x10, 0xf5, 0x06, 0x2a, 0x06, 0x08, 0xf5, 0x06, 0x10, 0xf6, 0x06, 0x2a, 0x06,
+	0x08, 0xf6, 0x06, 0x10, 0xf7, 0x06, 0x2a, 0x06, 0x08, 0xf7, 0x06, 0x10, 0xf8, 0x06, 0x2a, 0x06,
+	0x08, 0xf8, 0x06, 0x10, 0xf9, 0x06, 0x2a, 0x06, 0x08, 0xfa, 0x06, 0x10, 0xfb, 0x06, 0x2a, 0x06,
+	0x08, 0xfb, 0x06, 0x10, 0xfc, 0x06, 0x2a, 0x06, 0x08, 0xfc, 0x06, 0x10, 0xfd, 0x06, 0x2a, 0x06,
+	0x08, 0x90, 0x07, 0x10, 0x91, 0x07, 0x2a, 0x06, 0x08, 0x92, 0x07, 0x10, 0x93, 0x07, 0x2a, 0x06,
+	0x08, 0x93, 0x07, 0x10, 0x94, 0x07, 0x2a, 0x06, 0x08, 0x94, 0x07, 0x10, 0x95, 0x07, 0x2a, 0x06,
+	0x08, 0x95, 0x07, 0x10, 0x96, 0x07, 0x2a, 0x06, 0x08, 0x96, 0x07, 0x10, 0x97, 0x07, 0x2a, 0x06,
+	0x08, 0x97, 0x07, 0x10, 0x98, 0x07, 0x2a, 0x06, 0x08, 0x98, 0x07, 0x10, 0x99, 0x07, 0x2a, 0x06,
+	0x08, 0x99, 0x07, 0x10, 0x9a, 0x07, 0x2a, 0x06, 0x08, 0x9a, 0x07, 0x10, 0x9b, 0x07, 0x2a, 0x06,
+	0x08, 0x9b, 0x07, 0x10, 0x9c, 0x07, 0x2a, 0x06, 0x08, 0x9c, 0x07, 0x10, 0x9d, 0x07, 0x2a, 0x06,
+	0x08, 0x9d, 0x07, 0x10, 0x9e, 0x07, 0x2a, 0x06, 0x08, 0x9e, 0x07, 0x10, 0x9f, 0x07, 0x2a, 0x06,
+	0x08, 0x9f, 0x07, 0x10, 0xa0, 0x07, 0x2a, 0x06, 0x08, 0xa0, 0x07, 0x10, 0xa1, 0x07, 0x2a, 0x06,
+	0x08, 0xa1, 0x07, 0x10, 0xa2, 0x07, 0x2a, 0x06, 0x08, 0xa2, 0x07, 0x10, 0xa3, 0x07, 0x2a, 0x06,
+	0x08, 0xa3, 0x07, 0x10, 0xa4, 0x07, 0x2a, 0x06, 0x08, 0xa4, 0x07, 0x10, 0xa5, 0x07, 0x2a, 0x06,
+	0x08, 0xa5, 0x07, 0x10, 0xa6, 0x07, 0x2a, 0x06, 0x08, 0xa6, 0x07, 0x10, 0xa7, 0x07, 0x2a, 0x06,
+	0x08, 0xa7, 0x07, 0x10, 0xa8, 0x07, 0x2a, 0x06, 0x08, 0xa8, 0x07, 0x10, 0xa9, 0x07, 0x2a, 0x06,
+	0x08, 0xa9, 0x07, 0x10, 0xaa, 0x07, 0x2a, 0x06, 0x08, 0xaa, 0x07, 0x10, 0xab, 0x07, 0x2a, 0x06,
+	0x08, 0xab, 0x07, 0x10, 0xac, 0x07, 0x2a, 0x06, 0x08, 0xac, 0x07, 0x10, 0xad, 0x07, 0x2a, 0x06,
+	0x08, 0xad, 0x07, 0x10, 0xae, 0x07, 0x2a, 0x06, 0x08, 0xae, 0x07, 0x10, 0xaf, 0x07, 0x2a, 0x06,
+	0x08, 0xaf, 0x07, 0x10, 0xb0, 0x07, 0x2a, 0x06, 0x08, 0xb0, 0x07, 0x10, 0xb1, 0x07, 0x2a, 0x06,
+	0x08, 0xb1, 0x07, 0x10, 0xb2, 0x07, 0x2a, 0x06, 0x08, 0xb2, 0x07, 0x10, 0xb3, 0x07, 0x2a, 0x06,
+	0x08, 0xb3, 0x07, 0x10, 0xb4, 0x07, 0x2a, 0x06, 0x08, 0xb5, 0x07, 0x10, 0xb6, 0x07, 0x2a, 0x06,
+	0x08, 0xb6, 0x07, 0x10, 0xb7, 0x07, 0x2a, 0x06, 0x08, 0xb7, 0x07, 0x10, 0xb8, 0x07, 0x2a, 0x06,
+	0x08, 0xb8, 0x07, 0x10, 0xb9, 0x07, 0x2a, 0x06, 0x08, 0xba, 0x07, 0x10, 0xbb, 0x07, 0x2a, 0x06,
+	0x08, 0xbb, 0x07, 0x10, 0xbc, 0x07, 0x2a, 0x06, 0x08, 0xbc, 0x07, 0x10, 0xbd, 0x07, 0x2a, 0x06,
+	0x08, 0xbd, 0x07, 0x10, 0xbe, 0x07, 0x2a, 0x06, 0x08, 0xbe, 0x07, 0x10, 0xbf, 0x07, 0x2a, 0x06,
+	0x08, 0xbf, 0x07, 0x10, 0xc0, 0x07, 0x2a, 0x06, 0x08, 0xc0, 0x07, 0x10, 0xc1, 0x07, 0x2a, 0x06,
+	0x08, 0xc1, 0x07, 0x10, 0xc2, 0x07, 0x2a, 0x06, 0x08, 0xc2, 0x07, 0x10, 0xc3, 0x07, 0x2a, 0x06,
+	0x08, 0xc3, 0x07, 0x10, 0xc4, 0x07, 0x2a, 0x06, 0x08, 0xc4, 0x07, 0x10, 0xc5, 0x07, 0x2a, 0x06,
+	0x08, 0xc5, 0x07, 0x10, 0xc6, 0x07, 0x2a, 0x06, 0x08, 0xc6, 0x07, 0x10, 0xc7, 0x07, 0x2a, 0x06,
+	0x08, 0xc7, 0x07, 0x10, 0xc8, 0x07, 0x2a, 0x06, 0x08, 0xc8, 0x07, 0x10, 0xc9, 0x07, 0x2a, 0x06,
+	0x08, 0xc9, 0x07, 0x10, 0xca, 0x07, 0x2a, 0x06, 0x08, 0xca, 0x07, 0x10, 0xcb, 0x07, 0x2a, 0x06,
+	0x08, 0xcb, 0x07, 0x10, 0xcc, 0x07, 0x2a, 0x06, 0x08, 0xcc, 0x07, 0x10, 0xcd, 0x07, 0x2a, 0x06,
+	0x08, 0xcd, 0x07, 0x10, 0xce, 0x07, 0x2a, 0x06, 0x08, 0xce, 0x07, 0x10, 0xcf, 0x07, 0x2a, 0x06,
+	0x08, 0xcf, 0x07, 0x10, 0xd0, 0x07, 0x2a, 0x06, 0x08, 0xd0, 0x07, 0x10, 0xd1, 0x07, 0x2a, 0x06,
+	0x08, 0xd1, 0x07, 0x10, 0xd2, 0x07, 0x2a, 0x06, 0x08, 0xd2, 0x07, 0x10, 0xd3, 0x07, 0x2a, 0x06,
+	0x08, 0xd3, 0x07, 0x10, 0xd4, 0x07, 0x2a, 0x06, 0x08, 0xd4, 0x07, 0x10, 0xd5, 0x07, 0x2a, 0x06,
+	0x08, 0xd5, 0x07, 0x10, 0xd6, 0x07, 0x2a, 0x06, 0x08, 0xd6, 0x07, 0x10, 0xd7, 0x07, 0x2a, 0x06,
+	0x08, 0xd7, 0x07, 0x10, 0xd8, 0x07, 0x2a, 0x06, 0x08, 0xd8, 0x07, 0x10, 0xd9, 0x07, 0x2a, 0x06,
+	0x08, 0xd9, 0x07, 0x10, 0xda, 0x07, 0x2a, 0x06, 0x08, 0xdb, 0x07, 0x10, 0xdc, 0x07, 0x2a, 0x06,
+	0x08, 0xdc, 0x07, 0x10, 0xdd, 0x07, 0x2a, 0x06, 0x08, 0xe8, 0x07, 0x10, 0xe9, 0x07, 0x2a, 0x06,
+	0x08, 0xe9, 0x07, 0x10, 0xea, 0x07, 0x2a, 0x06, 0x08, 0xea, 0x07, 0x10, 0xeb, 0x07, 0x2a, 0x06,
+	0x08, 0xeb, 0x07, 0x10, 0xec, 0x07, 0x2a, 0x06, 0x08, 0xec, 0x07, 0x10, 0xed, 0x07, 0x2a, 0x06,
+	0x08, 0xed, 0x07, 0x10, 0xee, 0x07, 0x2a, 0x06, 0x08, 0xee, 0x07, 0x10, 0xef, 0x07, 0x2a, 0x06,
+	0x08, 0xef, 0x07, 0x10, 0xf0, 0x07, 0x2a, 0x06, 0x08, 0xf0, 0x07, 0x10, 0xf1, 0x07, 0x2a, 0x06,
+	0x08, 0xf1, 0x07, 0x10, 0xf2, 0x07, 0x2a, 0x06, 0x08, 0xf2, 0x07, 0x10, 0xf3, 0x07, 0x2a, 0x06,
+	0x08, 0xf3, 0x07, 0x10, 0xf4, 0x07, 0x2a, 0x06, 0x08, 0xf4, 0x07, 0x10, 0xf5, 0x07, 0x2a, 0x06,
+	0x08, 0xf5, 0x07, 0x10, 0xf6, 0x07, 0x2a, 0x06, 0x08, 0xf6, 0x07, 0x10, 0xf7, 0x07, 0x2a, 0x06,
+	0x08, 0xf7, 0x07, 0x10, 0xf8, 0x07, 0x2a, 0x06, 0x08, 0xf8, 0x07, 0x10, 0xf9, 0x07, 0x2a, 0x06,
+	0x08, 0xf9, 0x07, 0x10, 0xfa, 0x07, 0x2a, 0x06, 0x08, 0xfa, 0x07, 0x10, 0xfb, 0x07, 0x2a, 0x06,
+	0x08, 0xfb, 0x07, 0x10, 0xfc, 0x07, 0x2a, 0x06, 0x08, 0xfc, 0x07, 0x10, 0xfd, 0x07, 0x2a, 0x06,
+	0x08, 0xfd, 0x07, 0x10, 0xfe, 0x07, 0x2a, 0x06, 0x08, 0xfe, 0x07, 0x10, 0xff, 0x07, 0x2a, 0x06,
+	0x08, 0xff, 0x07, 0x10, 0x80, 0x08, 0x2a, 0x06, 0x08, 0x80, 0x08, 0x10, 0x81, 0x08, 0x2a, 0x06,
+	0x08, 0x81, 0x08, 0x10, 0x82, 0x08, 0x2a, 0x06, 0x08, 0x82, 0x08, 0x10, 0x83, 0x08, 0x2a, 0x06,
+	0x08, 0x83, 0x08, 0x10, 0x84, 0x08, 0x2a, 0x06, 0x08, 0x84, 0x08, 0x10, 0x85, 0x08, 0x2a, 0x06,
+	0x08, 0x85, 0x08, 0x10, 0x86, 0x08, 0x2a, 0x06, 0x08, 0x86, 0x08, 0x10, 0x87, 0x08, 0x2a, 0x06,
+	0x08, 0x87, 0x08, 0x10, 0x88, 0x08, 0x2a, 0x06, 0x08, 0x88, 0x08, 0x10, 0x89, 0x08, 0x2a, 0x06,
+	0x08, 0x89, 0x08, 0x10, 0x8a, 0x08, 0x2a, 0x06, 0x08, 0x8a, 0x08, 0x10, 0x8b, 0x08, 0x2a, 0x06,
+	0x08, 0x8b, 0x08, 0x10, 0x8c, 0x08, 0x2a, 0x06, 0x08, 0x8c, 0x08, 0x10, 0x8d, 0x08, 0x2a, 0x06,
+	0x08, 0x8d, 0x08, 0x10, 0x8e, 0x08, 0x2a, 0x06, 0x08, 0x8e, 0x08, 0x10, 0x8f, 0x08, 0x2a, 0x06,
+	0x08, 0x8f, 0x08, 0x10, 0x90, 0x08, 0x2a, 0x06, 0x08, 0x90, 0x08, 0x10, 0x91, 0x08, 0x2a, 0x06,
+	0x08, 0x91, 0x08, 0x10, 0x92, 0x08, 0x2a, 0x06, 0x08, 0x92, 0x08, 0x10, 0x93, 0x08, 0x2a, 0x06,
+	0x08, 0x93, 0x08, 0x10, 0x94, 0x08, 0x2a, 0x06, 0x08, 0x94, 0x08, 0x10, 0x95, 0x08, 0x2a, 0x06,
+	0x08, 0x95, 0x08, 0x10, 0x96, 0x08, 0x2a, 0x06, 0x08, 0x96, 0x08, 0x10, 0x97, 0x08, 0x2a, 0x06,
+	0x08, 0x97, 0x08, 0x10, 0x98, 0x08, 0x2a, 0x06, 0x08, 0x98, 0x08, 0x10, 0x99, 0x08, 0x2a, 0x06,
+	0x08, 0x99, 0x08, 0x10, 0x9a, 0x08, 0x2a, 0x06, 0x08, 0x9a, 0x08, 0x10, 0x9b, 0x08, 0x2a, 0x06,
+	0x08, 0x9b, 0x08, 0x10, 0x9c, 0x08, 0x2a, 0x06, 0x08, 0x9c, 0x08, 0x10, 0x9d, 0x08, 0x2a, 0x06,
+	0x08, 0x9d, 0x08, 0x10, 0x9e, 0x08, 0x2a, 0x06, 0x08, 0x9e, 0x08, 0x10, 0x9f, 0x08, 0x2a, 0x06,
+	0x08, 0x9f, 0x08, 0x10, 0xa0, 0x08, 0x2a, 0x06, 0x08, 0xa0, 0x08, 0x10, 0xa1, 0x08, 0x2a, 0x06,
+	0x08, 0xa1, 0x08, 0x10, 0xa2, 0x08, 0x2a, 0x06, 0x08, 0xa2, 0x08, 0x10, 0xa3, 0x08, 0x2a, 0x06,
+	0x08, 0xb7, 0x08, 0x10, 0xb8, 0x08, 0x2a, 0x06, 0x08, 0xb8, 0x08, 0x10, 0xb9, 0x08, 0x2a, 0x06,
+	0x08, 0xb9, 0x08, 0x10, 0xba, 0x08, 0x2a, 0x06, 0x08, 0xba, 0x08, 0x10, 0xbb, 0x08, 0x2a, 0x06,
+	0x08, 0xbb, 0x08, 0x10, 0xbc, 0x08, 0x2a, 0x06, 0x08, 0xbc, 0x08, 0x10, 0xbd, 0x08, 0x2a, 0x06,
+	0x08, 0xbd, 0x08, 0x10, 0xbe, 0x08, 0x32, 0x71, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x37, 0x30, 0x32, 0x35, 0x12, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x18, 0xa4, 0xf7, 0xc2, 0x0a, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x39, 0x34, 0x35, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x37, 0x30, 0x32, 0x35, 0x42, 0x23, 0x0a, 0x1e, 0x63, 0x6f, 0x6d,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0xf8, 0x01, 0x01,
+}
+
+var (
+	file_datasets_google_message3_benchmark_message3_1_proto_rawDescOnce sync.Once
+	file_datasets_google_message3_benchmark_message3_1_proto_rawDescData = file_datasets_google_message3_benchmark_message3_1_proto_rawDesc
+)
+
+func file_datasets_google_message3_benchmark_message3_1_proto_rawDescGZIP() []byte {
+	file_datasets_google_message3_benchmark_message3_1_proto_rawDescOnce.Do(func() {
+		file_datasets_google_message3_benchmark_message3_1_proto_rawDescData = protoimpl.X.CompressGZIP(file_datasets_google_message3_benchmark_message3_1_proto_rawDescData)
+	})
+	return file_datasets_google_message3_benchmark_message3_1_proto_rawDescData
+}
+
+var file_datasets_google_message3_benchmark_message3_1_proto_msgTypes = make([]protoimpl.MessageInfo, 59)
+var file_datasets_google_message3_benchmark_message3_1_proto_goTypes = []interface{}{
+	(*Message34390)(nil),              // 0: benchmarks.google_message3.Message34390
+	(*Message34624)(nil),              // 1: benchmarks.google_message3.Message34624
+	(*Message34791)(nil),              // 2: benchmarks.google_message3.Message34791
+	(*Message35483)(nil),              // 3: benchmarks.google_message3.Message35483
+	(*Message35807)(nil),              // 4: benchmarks.google_message3.Message35807
+	(*Message37487)(nil),              // 5: benchmarks.google_message3.Message37487
+	(*Message13062)(nil),              // 6: benchmarks.google_message3.Message13062
+	(*Message952)(nil),                // 7: benchmarks.google_message3.Message952
+	(*Message36876)(nil),              // 8: benchmarks.google_message3.Message36876
+	(*Message1328)(nil),               // 9: benchmarks.google_message3.Message1328
+	(*Message6850)(nil),               // 10: benchmarks.google_message3.Message6850
+	(*Message6863)(nil),               // 11: benchmarks.google_message3.Message6863
+	(*Message6871)(nil),               // 12: benchmarks.google_message3.Message6871
+	(*Message7547)(nil),               // 13: benchmarks.google_message3.Message7547
+	(*Message7648)(nil),               // 14: benchmarks.google_message3.Message7648
+	(*Message7865)(nil),               // 15: benchmarks.google_message3.Message7865
+	(*Message7928)(nil),               // 16: benchmarks.google_message3.Message7928
+	(*Message7919)(nil),               // 17: benchmarks.google_message3.Message7919
+	(*Message7920)(nil),               // 18: benchmarks.google_message3.Message7920
+	(*Message7921)(nil),               // 19: benchmarks.google_message3.Message7921
+	(*Message8511)(nil),               // 20: benchmarks.google_message3.Message8511
+	(*Message8512)(nil),               // 21: benchmarks.google_message3.Message8512
+	(*Message8513)(nil),               // 22: benchmarks.google_message3.Message8513
+	(*Message8514)(nil),               // 23: benchmarks.google_message3.Message8514
+	(*Message8515)(nil),               // 24: benchmarks.google_message3.Message8515
+	(*Message10320)(nil),              // 25: benchmarks.google_message3.Message10320
+	(*Message10321)(nil),              // 26: benchmarks.google_message3.Message10321
+	(*Message10322)(nil),              // 27: benchmarks.google_message3.Message10322
+	(*Message11988)(nil),              // 28: benchmarks.google_message3.Message11988
+	(*Message12668)(nil),              // 29: benchmarks.google_message3.Message12668
+	(*Message12825)(nil),              // 30: benchmarks.google_message3.Message12825
+	(*Message16478)(nil),              // 31: benchmarks.google_message3.Message16478
+	(*Message16552)(nil),              // 32: benchmarks.google_message3.Message16552
+	(*Message16660)(nil),              // 33: benchmarks.google_message3.Message16660
+	(*Message16727)(nil),              // 34: benchmarks.google_message3.Message16727
+	(*Message16725)(nil),              // 35: benchmarks.google_message3.Message16725
+	(*Message17726)(nil),              // 36: benchmarks.google_message3.Message17726
+	(*Message17782)(nil),              // 37: benchmarks.google_message3.Message17782
+	(*Message17783)(nil),              // 38: benchmarks.google_message3.Message17783
+	(*Message16945)(nil),              // 39: benchmarks.google_message3.Message16945
+	(*Message34791_Message34792)(nil), // 40: benchmarks.google_message3.Message34791.Message34792
+	(*Message36876_Message36877)(nil), // 41: benchmarks.google_message3.Message36876.Message36877
+	(*Message36876_Message36878)(nil), // 42: benchmarks.google_message3.Message36876.Message36878
+	(*Message36876_Message36879)(nil), // 43: benchmarks.google_message3.Message36876.Message36879
+	(*Message36876_Message36880)(nil), // 44: benchmarks.google_message3.Message36876.Message36880
+	(*Message36876_Message36881)(nil), // 45: benchmarks.google_message3.Message36876.Message36881
+	(*Message36876_Message36882)(nil), // 46: benchmarks.google_message3.Message36876.Message36882
+	(*Message36876_Message36883)(nil), // 47: benchmarks.google_message3.Message36876.Message36883
+	(*Message36876_Message36884)(nil), // 48: benchmarks.google_message3.Message36876.Message36884
+	(*Message36876_Message36885)(nil), // 49: benchmarks.google_message3.Message36876.Message36885
+	(*Message36876_Message36886)(nil), // 50: benchmarks.google_message3.Message36876.Message36886
+	(*Message36876_Message36887)(nil), // 51: benchmarks.google_message3.Message36876.Message36887
+	(*Message36876_Message36888)(nil), // 52: benchmarks.google_message3.Message36876.Message36888
+	(*Message36876_Message36889)(nil), // 53: benchmarks.google_message3.Message36876.Message36889
+	(*Message36876_Message36910)(nil), // 54: benchmarks.google_message3.Message36876.Message36910
+	(*Message36876_Message36911)(nil), // 55: benchmarks.google_message3.Message36876.Message36911
+	(*Message36876_Message36912)(nil), // 56: benchmarks.google_message3.Message36876.Message36912
+	(*Message17783_Message17784)(nil), // 57: benchmarks.google_message3.Message17783.Message17784
+	(*Message17783_Message17785)(nil), // 58: benchmarks.google_message3.Message17783.Message17785
+	(*Message34387)(nil),              // 59: benchmarks.google_message3.Message34387
+	(*Message34621)(nil),              // 60: benchmarks.google_message3.Message34621
+	(*Message35476)(nil),              // 61: benchmarks.google_message3.Message35476
+	(*UnusedEmptyMessage)(nil),        // 62: benchmarks.google_message3.UnusedEmptyMessage
+	(*Message949)(nil),                // 63: benchmarks.google_message3.Message949
+	(*Message2356)(nil),               // 64: benchmarks.google_message3.Message2356
+	(*Message7029)(nil),               // 65: benchmarks.google_message3.Message7029
+	(*Message35573)(nil),              // 66: benchmarks.google_message3.Message35573
+	(*Message4144)(nil),               // 67: benchmarks.google_message3.Message4144
+	(*Message18921)(nil),              // 68: benchmarks.google_message3.Message18921
+	(*Message36858)(nil),              // 69: benchmarks.google_message3.Message36858
+	(*Message18831)(nil),              // 70: benchmarks.google_message3.Message18831
+	(*Message18283)(nil),              // 71: benchmarks.google_message3.Message18283
+	(*Message0)(nil),                  // 72: benchmarks.google_message3.Message0
+	(*Message36869)(nil),              // 73: benchmarks.google_message3.Message36869
+	(UnusedEnum)(0),                   // 74: benchmarks.google_message3.UnusedEnum
+	(*Message13090)(nil),              // 75: benchmarks.google_message3.Message13090
+	(*Message10155)(nil),              // 76: benchmarks.google_message3.Message10155
+	(*Message11874)(nil),              // 77: benchmarks.google_message3.Message11874
+	(*Message35546)(nil),              // 78: benchmarks.google_message3.Message35546
+	(*Message19255)(nil),              // 79: benchmarks.google_message3.Message19255
+	(*Message33968)(nil),              // 80: benchmarks.google_message3.Message33968
+	(*Message6644)(nil),               // 81: benchmarks.google_message3.Message6644
+	(Enum6858)(0),                     // 82: benchmarks.google_message3.Enum6858
+	(*Message6773)(nil),               // 83: benchmarks.google_message3.Message6773
+	(Enum6815)(0),                     // 84: benchmarks.google_message3.Enum6815
+	(Enum6822)(0),                     // 85: benchmarks.google_message3.Enum6822
+	(*Message3886)(nil),               // 86: benchmarks.google_message3.Message3886
+	(*Message6743)(nil),               // 87: benchmarks.google_message3.Message6743
+	(*Message8224)(nil),               // 88: benchmarks.google_message3.Message8224
+	(*Message8301)(nil),               // 89: benchmarks.google_message3.Message8301
+	(*Message8302)(nil),               // 90: benchmarks.google_message3.Message8302
+	(*Message8392)(nil),               // 91: benchmarks.google_message3.Message8392
+	(*Message8130)(nil),               // 92: benchmarks.google_message3.Message8130
+	(*Message8479)(nil),               // 93: benchmarks.google_message3.Message8479
+	(*Message8478)(nil),               // 94: benchmarks.google_message3.Message8478
+	(Enum10335)(0),                    // 95: benchmarks.google_message3.Enum10335
+	(*Message10319)(nil),              // 96: benchmarks.google_message3.Message10319
+	(Enum10337)(0),                    // 97: benchmarks.google_message3.Enum10337
+	(*Message4016)(nil),               // 98: benchmarks.google_message3.Message4016
+	(*Message12669)(nil),              // 99: benchmarks.google_message3.Message12669
+	(*Message12818)(nil),              // 100: benchmarks.google_message3.Message12818
+	(*Message12819)(nil),              // 101: benchmarks.google_message3.Message12819
+	(*Message12820)(nil),              // 102: benchmarks.google_message3.Message12820
+	(*Message12821)(nil),              // 103: benchmarks.google_message3.Message12821
+	(*Message16479)(nil),              // 104: benchmarks.google_message3.Message16479
+	(Enum16553)(0),                    // 105: benchmarks.google_message3.Enum16553
+	(Enum16728)(0),                    // 106: benchmarks.google_message3.Enum16728
+	(Enum16732)(0),                    // 107: benchmarks.google_message3.Enum16732
+	(Enum16738)(0),                    // 108: benchmarks.google_message3.Enum16738
+	(*Message16722)(nil),              // 109: benchmarks.google_message3.Message16722
+	(Enum16698)(0),                    // 110: benchmarks.google_message3.Enum16698
+	(*Message16724)(nil),              // 111: benchmarks.google_message3.Message16724
+	(*Message17728)(nil),              // 112: benchmarks.google_message3.Message17728
+	(*Message13174)(nil),              // 113: benchmarks.google_message3.Message13174
+	(*Message13169)(nil),              // 114: benchmarks.google_message3.Message13169
+	(Enum36890)(0),                    // 115: benchmarks.google_message3.Enum36890
+	(*Message35538)(nil),              // 116: benchmarks.google_message3.Message35538
+	(*Message35540)(nil),              // 117: benchmarks.google_message3.Message35540
+	(*Message35542)(nil),              // 118: benchmarks.google_message3.Message35542
+	(*Message3901)(nil),               // 119: benchmarks.google_message3.Message3901
+}
+var file_datasets_google_message3_benchmark_message3_1_proto_depIdxs = []int32{
+	59,  // 0: benchmarks.google_message3.Message34390.field34452:type_name -> benchmarks.google_message3.Message34387
+	60,  // 1: benchmarks.google_message3.Message34624.field34683:type_name -> benchmarks.google_message3.Message34621
+	60,  // 2: benchmarks.google_message3.Message34624.field34684:type_name -> benchmarks.google_message3.Message34621
+	40,  // 3: benchmarks.google_message3.Message34791.message34792:type_name -> benchmarks.google_message3.Message34791.Message34792
+	61,  // 4: benchmarks.google_message3.Message35483.field35503:type_name -> benchmarks.google_message3.Message35476
+	62,  // 5: benchmarks.google_message3.Message35483.field35504:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	63,  // 6: benchmarks.google_message3.Message952.field963:type_name -> benchmarks.google_message3.Message949
+	64,  // 7: benchmarks.google_message3.Message36876.field36980:type_name -> benchmarks.google_message3.Message2356
+	41,  // 8: benchmarks.google_message3.Message36876.message36877:type_name -> benchmarks.google_message3.Message36876.Message36877
+	42,  // 9: benchmarks.google_message3.Message36876.message36878:type_name -> benchmarks.google_message3.Message36876.Message36878
+	43,  // 10: benchmarks.google_message3.Message36876.message36879:type_name -> benchmarks.google_message3.Message36876.Message36879
+	62,  // 11: benchmarks.google_message3.Message36876.field36984:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	44,  // 12: benchmarks.google_message3.Message36876.message36880:type_name -> benchmarks.google_message3.Message36876.Message36880
+	62,  // 13: benchmarks.google_message3.Message36876.field36988:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	65,  // 14: benchmarks.google_message3.Message36876.field36989:type_name -> benchmarks.google_message3.Message7029
+	66,  // 15: benchmarks.google_message3.Message36876.field36990:type_name -> benchmarks.google_message3.Message35573
+	62,  // 16: benchmarks.google_message3.Message36876.field36991:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	62,  // 17: benchmarks.google_message3.Message36876.field36992:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	62,  // 18: benchmarks.google_message3.Message36876.field36997:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	62,  // 19: benchmarks.google_message3.Message36876.field37000:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	45,  // 20: benchmarks.google_message3.Message36876.message36881:type_name -> benchmarks.google_message3.Message36876.Message36881
+	67,  // 21: benchmarks.google_message3.Message36876.field37002:type_name -> benchmarks.google_message3.Message4144
+	46,  // 22: benchmarks.google_message3.Message36876.message36882:type_name -> benchmarks.google_message3.Message36876.Message36882
+	62,  // 23: benchmarks.google_message3.Message36876.field37004:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	68,  // 24: benchmarks.google_message3.Message36876.field37005:type_name -> benchmarks.google_message3.Message18921
+	69,  // 25: benchmarks.google_message3.Message36876.field37006:type_name -> benchmarks.google_message3.Message36858
+	70,  // 26: benchmarks.google_message3.Message36876.field37007:type_name -> benchmarks.google_message3.Message18831
+	62,  // 27: benchmarks.google_message3.Message36876.field37008:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	71,  // 28: benchmarks.google_message3.Message36876.field37009:type_name -> benchmarks.google_message3.Message18283
+	72,  // 29: benchmarks.google_message3.Message36876.field37012:type_name -> benchmarks.google_message3.Message0
+	72,  // 30: benchmarks.google_message3.Message36876.field37013:type_name -> benchmarks.google_message3.Message0
+	62,  // 31: benchmarks.google_message3.Message36876.field37014:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	73,  // 32: benchmarks.google_message3.Message36876.field37015:type_name -> benchmarks.google_message3.Message36869
+	47,  // 33: benchmarks.google_message3.Message36876.message36883:type_name -> benchmarks.google_message3.Message36876.Message36883
+	48,  // 34: benchmarks.google_message3.Message36876.message36884:type_name -> benchmarks.google_message3.Message36876.Message36884
+	49,  // 35: benchmarks.google_message3.Message36876.message36885:type_name -> benchmarks.google_message3.Message36876.Message36885
+	50,  // 36: benchmarks.google_message3.Message36876.message36886:type_name -> benchmarks.google_message3.Message36876.Message36886
+	74,  // 37: benchmarks.google_message3.Message36876.field37020:type_name -> benchmarks.google_message3.UnusedEnum
+	62,  // 38: benchmarks.google_message3.Message36876.field37022:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	75,  // 39: benchmarks.google_message3.Message36876.field37023:type_name -> benchmarks.google_message3.Message13090
+	51,  // 40: benchmarks.google_message3.Message36876.message36887:type_name -> benchmarks.google_message3.Message36876.Message36887
+	76,  // 41: benchmarks.google_message3.Message36876.field37025:type_name -> benchmarks.google_message3.Message10155
+	77,  // 42: benchmarks.google_message3.Message36876.field37026:type_name -> benchmarks.google_message3.Message11874
+	62,  // 43: benchmarks.google_message3.Message36876.field37029:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	78,  // 44: benchmarks.google_message3.Message36876.field37030:type_name -> benchmarks.google_message3.Message35546
+	52,  // 45: benchmarks.google_message3.Message36876.message36888:type_name -> benchmarks.google_message3.Message36876.Message36888
+	79,  // 46: benchmarks.google_message3.Message36876.field37032:type_name -> benchmarks.google_message3.Message19255
+	80,  // 47: benchmarks.google_message3.Message36876.field37033:type_name -> benchmarks.google_message3.Message33968
+	62,  // 48: benchmarks.google_message3.Message36876.field37035:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	81,  // 49: benchmarks.google_message3.Message36876.field37036:type_name -> benchmarks.google_message3.Message6644
+	53,  // 50: benchmarks.google_message3.Message36876.message36889:type_name -> benchmarks.google_message3.Message36876.Message36889
+	54,  // 51: benchmarks.google_message3.Message36876.message36910:type_name -> benchmarks.google_message3.Message36876.Message36910
+	55,  // 52: benchmarks.google_message3.Message36876.message36911:type_name -> benchmarks.google_message3.Message36876.Message36911
+	56,  // 53: benchmarks.google_message3.Message36876.message36912:type_name -> benchmarks.google_message3.Message36876.Message36912
+	62,  // 54: benchmarks.google_message3.Message36876.field37042:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	82,  // 55: benchmarks.google_message3.Message6863.field6931:type_name -> benchmarks.google_message3.Enum6858
+	82,  // 56: benchmarks.google_message3.Message6863.field6932:type_name -> benchmarks.google_message3.Enum6858
+	74,  // 57: benchmarks.google_message3.Message6863.field6933:type_name -> benchmarks.google_message3.UnusedEnum
+	83,  // 58: benchmarks.google_message3.Message6863.field6935:type_name -> benchmarks.google_message3.Message6773
+	84,  // 59: benchmarks.google_message3.Message6863.field6938:type_name -> benchmarks.google_message3.Enum6815
+	85,  // 60: benchmarks.google_message3.Message6863.field6941:type_name -> benchmarks.google_message3.Enum6822
+	62,  // 61: benchmarks.google_message3.Message6863.field6950:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	62,  // 62: benchmarks.google_message3.Message6863.field6955:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	62,  // 63: benchmarks.google_message3.Message6863.field6956:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	86,  // 64: benchmarks.google_message3.Message6863.field6957:type_name -> benchmarks.google_message3.Message3886
+	87,  // 65: benchmarks.google_message3.Message6863.field6960:type_name -> benchmarks.google_message3.Message6743
+	62,  // 66: benchmarks.google_message3.Message6863.field6961:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	62,  // 67: benchmarks.google_message3.Message6863.field6962:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	74,  // 68: benchmarks.google_message3.Message7921.field7939:type_name -> benchmarks.google_message3.UnusedEnum
+	88,  // 69: benchmarks.google_message3.Message8511.field8539:type_name -> benchmarks.google_message3.Message8224
+	89,  // 70: benchmarks.google_message3.Message8512.field8544:type_name -> benchmarks.google_message3.Message8301
+	90,  // 71: benchmarks.google_message3.Message8512.field8545:type_name -> benchmarks.google_message3.Message8302
+	91,  // 72: benchmarks.google_message3.Message8513.field8550:type_name -> benchmarks.google_message3.Message8392
+	92,  // 73: benchmarks.google_message3.Message8514.field8557:type_name -> benchmarks.google_message3.Message8130
+	93,  // 74: benchmarks.google_message3.Message8515.field8559:type_name -> benchmarks.google_message3.Message8479
+	94,  // 75: benchmarks.google_message3.Message8515.field8560:type_name -> benchmarks.google_message3.Message8478
+	95,  // 76: benchmarks.google_message3.Message10320.field10347:type_name -> benchmarks.google_message3.Enum10335
+	96,  // 77: benchmarks.google_message3.Message10320.field10348:type_name -> benchmarks.google_message3.Message10319
+	97,  // 78: benchmarks.google_message3.Message10320.field10353:type_name -> benchmarks.google_message3.Enum10337
+	98,  // 79: benchmarks.google_message3.Message10322.field10357:type_name -> benchmarks.google_message3.Message4016
+	62,  // 80: benchmarks.google_message3.Message11988.field12023:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	76,  // 81: benchmarks.google_message3.Message11988.field12024:type_name -> benchmarks.google_message3.Message10155
+	99,  // 82: benchmarks.google_message3.Message12668.field12677:type_name -> benchmarks.google_message3.Message12669
+	100, // 83: benchmarks.google_message3.Message12825.field12862:type_name -> benchmarks.google_message3.Message12818
+	101, // 84: benchmarks.google_message3.Message12825.field12864:type_name -> benchmarks.google_message3.Message12819
+	102, // 85: benchmarks.google_message3.Message12825.field12865:type_name -> benchmarks.google_message3.Message12820
+	103, // 86: benchmarks.google_message3.Message12825.field12867:type_name -> benchmarks.google_message3.Message12821
+	62,  // 87: benchmarks.google_message3.Message12825.field12868:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	104, // 88: benchmarks.google_message3.Message16478.field16481:type_name -> benchmarks.google_message3.Message16479
+	105, // 89: benchmarks.google_message3.Message16552.field16567:type_name -> benchmarks.google_message3.Enum16553
+	106, // 90: benchmarks.google_message3.Message16727.field16782:type_name -> benchmarks.google_message3.Enum16728
+	107, // 91: benchmarks.google_message3.Message16727.field16789:type_name -> benchmarks.google_message3.Enum16732
+	108, // 92: benchmarks.google_message3.Message16727.field16793:type_name -> benchmarks.google_message3.Enum16738
+	109, // 93: benchmarks.google_message3.Message16727.field16795:type_name -> benchmarks.google_message3.Message16722
+	110, // 94: benchmarks.google_message3.Message16727.field16802:type_name -> benchmarks.google_message3.Enum16698
+	111, // 95: benchmarks.google_message3.Message16727.field16803:type_name -> benchmarks.google_message3.Message16724
+	62,  // 96: benchmarks.google_message3.Message16727.field16805:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	106, // 97: benchmarks.google_message3.Message16725.field16774:type_name -> benchmarks.google_message3.Enum16728
+	62,  // 98: benchmarks.google_message3.Message17726.field17812:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	112, // 99: benchmarks.google_message3.Message17726.field17820:type_name -> benchmarks.google_message3.Message17728
+	112, // 100: benchmarks.google_message3.Message17726.field17821:type_name -> benchmarks.google_message3.Message17728
+	62,  // 101: benchmarks.google_message3.Message17726.field17822:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	57,  // 102: benchmarks.google_message3.Message17783.message17784:type_name -> benchmarks.google_message3.Message17783.Message17784
+	58,  // 103: benchmarks.google_message3.Message17783.message17785:type_name -> benchmarks.google_message3.Message17783.Message17785
+	62,  // 104: benchmarks.google_message3.Message16945.field16951:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	72,  // 105: benchmarks.google_message3.Message16945.field16952:type_name -> benchmarks.google_message3.Message0
+	62,  // 106: benchmarks.google_message3.Message16945.field16953:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	72,  // 107: benchmarks.google_message3.Message16945.field16954:type_name -> benchmarks.google_message3.Message0
+	62,  // 108: benchmarks.google_message3.Message16945.field16960:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	72,  // 109: benchmarks.google_message3.Message16945.field16961:type_name -> benchmarks.google_message3.Message0
+	72,  // 110: benchmarks.google_message3.Message16945.field16962:type_name -> benchmarks.google_message3.Message0
+	62,  // 111: benchmarks.google_message3.Message16945.field16963:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	62,  // 112: benchmarks.google_message3.Message16945.field16965:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	62,  // 113: benchmarks.google_message3.Message16945.field16967:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	72,  // 114: benchmarks.google_message3.Message16945.field16969:type_name -> benchmarks.google_message3.Message0
+	62,  // 115: benchmarks.google_message3.Message16945.field16973:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	62,  // 116: benchmarks.google_message3.Message16945.field16974:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	72,  // 117: benchmarks.google_message3.Message16945.field16977:type_name -> benchmarks.google_message3.Message0
+	62,  // 118: benchmarks.google_message3.Message16945.field16978:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	62,  // 119: benchmarks.google_message3.Message16945.field16979:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	62,  // 120: benchmarks.google_message3.Message16945.field16981:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	62,  // 121: benchmarks.google_message3.Message16945.field16983:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	62,  // 122: benchmarks.google_message3.Message16945.field16985:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	62,  // 123: benchmarks.google_message3.Message16945.field16990:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	62,  // 124: benchmarks.google_message3.Message16945.field16994:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	62,  // 125: benchmarks.google_message3.Message16945.field17002:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	62,  // 126: benchmarks.google_message3.Message16945.field17003:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	62,  // 127: benchmarks.google_message3.Message16945.field17004:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	62,  // 128: benchmarks.google_message3.Message16945.field17005:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	62,  // 129: benchmarks.google_message3.Message16945.field17006:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	62,  // 130: benchmarks.google_message3.Message16945.field17007:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	62,  // 131: benchmarks.google_message3.Message16945.field17008:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	62,  // 132: benchmarks.google_message3.Message16945.field17009:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	72,  // 133: benchmarks.google_message3.Message16945.field17010:type_name -> benchmarks.google_message3.Message0
+	62,  // 134: benchmarks.google_message3.Message16945.field17012:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	62,  // 135: benchmarks.google_message3.Message16945.field17014:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	72,  // 136: benchmarks.google_message3.Message16945.field17015:type_name -> benchmarks.google_message3.Message0
+	72,  // 137: benchmarks.google_message3.Message16945.field17023:type_name -> benchmarks.google_message3.Message0
+	62,  // 138: benchmarks.google_message3.Message36876.Message36889.field37101:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	113, // 139: benchmarks.google_message3.Message36876.Message36889.field37102:type_name -> benchmarks.google_message3.Message13174
+	114, // 140: benchmarks.google_message3.Message36876.Message36889.field37103:type_name -> benchmarks.google_message3.Message13169
+	115, // 141: benchmarks.google_message3.Message36876.Message36889.field37105:type_name -> benchmarks.google_message3.Enum36890
+	62,  // 142: benchmarks.google_message3.Message36876.Message36889.field37108:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	62,  // 143: benchmarks.google_message3.Message36876.Message36889.field37113:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	62,  // 144: benchmarks.google_message3.Message36876.Message36889.field37115:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	74,  // 145: benchmarks.google_message3.Message36876.Message36889.field37116:type_name -> benchmarks.google_message3.UnusedEnum
+	74,  // 146: benchmarks.google_message3.Message36876.Message36889.field37117:type_name -> benchmarks.google_message3.UnusedEnum
+	62,  // 147: benchmarks.google_message3.Message36876.Message36911.field37121:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	116, // 148: benchmarks.google_message3.Message36876.Message36911.field37122:type_name -> benchmarks.google_message3.Message35538
+	117, // 149: benchmarks.google_message3.Message36876.Message36911.field37123:type_name -> benchmarks.google_message3.Message35540
+	118, // 150: benchmarks.google_message3.Message36876.Message36911.field37124:type_name -> benchmarks.google_message3.Message35542
+	119, // 151: benchmarks.google_message3.Message36876.Message36912.field37125:type_name -> benchmarks.google_message3.Message3901
+	119, // 152: benchmarks.google_message3.Message36876.Message36912.field37126:type_name -> benchmarks.google_message3.Message3901
+	38,  // 153: benchmarks.google_message3.Message17783.Message17785.field18170:type_name -> benchmarks.google_message3.Message17783
+	72,  // 154: benchmarks.google_message3.Message34390.field34453:extendee -> benchmarks.google_message3.Message0
+	72,  // 155: benchmarks.google_message3.Message34624.field34685:extendee -> benchmarks.google_message3.Message0
+	72,  // 156: benchmarks.google_message3.Message34791.field34807:extendee -> benchmarks.google_message3.Message0
+	72,  // 157: benchmarks.google_message3.Message35483.field35505:extendee -> benchmarks.google_message3.Message0
+	72,  // 158: benchmarks.google_message3.Message35807.field35818:extendee -> benchmarks.google_message3.Message0
+	72,  // 159: benchmarks.google_message3.Message16945.field17025:extendee -> benchmarks.google_message3.Message0
+	0,   // 160: benchmarks.google_message3.Message34390.field34453:type_name -> benchmarks.google_message3.Message34390
+	1,   // 161: benchmarks.google_message3.Message34624.field34685:type_name -> benchmarks.google_message3.Message34624
+	2,   // 162: benchmarks.google_message3.Message34791.field34807:type_name -> benchmarks.google_message3.Message34791
+	3,   // 163: benchmarks.google_message3.Message35483.field35505:type_name -> benchmarks.google_message3.Message35483
+	4,   // 164: benchmarks.google_message3.Message35807.field35818:type_name -> benchmarks.google_message3.Message35807
+	39,  // 165: benchmarks.google_message3.Message16945.field17025:type_name -> benchmarks.google_message3.Message16945
+	166, // [166:166] is the sub-list for method output_type
+	166, // [166:166] is the sub-list for method input_type
+	160, // [160:166] is the sub-list for extension type_name
+	154, // [154:160] is the sub-list for extension extendee
+	0,   // [0:154] is the sub-list for field type_name
+}
+
+func init() { file_datasets_google_message3_benchmark_message3_1_proto_init() }
+func file_datasets_google_message3_benchmark_message3_1_proto_init() {
+	if File_datasets_google_message3_benchmark_message3_1_proto != nil {
+		return
+	}
+	file_datasets_google_message3_benchmark_message3_2_proto_init()
+	file_datasets_google_message3_benchmark_message3_3_proto_init()
+	file_datasets_google_message3_benchmark_message3_5_proto_init()
+	file_datasets_google_message3_benchmark_message3_7_proto_init()
+	file_datasets_google_message3_benchmark_message3_8_proto_init()
+	if !protoimpl.UnsafeEnabled {
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message34390); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message34624); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message34791); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message35483); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message35807); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message37487); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message13062); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message952); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message36876); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message1328); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6850); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6863); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6871); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message7547); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message7648); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message7865); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message7928); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message7919); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message7920); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message7921); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8511); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8512); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8513); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8514); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8515); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message10320); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message10321); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message10322); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message11988); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12668); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12825); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message16478); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message16552); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message16660); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message16727); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[35].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message16725); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[36].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message17726); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[37].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message17782); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[38].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message17783); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[39].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message16945); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[40].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message34791_Message34792); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[41].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message36876_Message36877); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[42].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message36876_Message36878); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[43].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message36876_Message36879); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[44].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message36876_Message36880); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[45].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message36876_Message36881); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[46].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message36876_Message36882); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[47].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message36876_Message36883); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[48].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message36876_Message36884); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[49].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message36876_Message36885); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[50].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message36876_Message36886); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[51].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message36876_Message36887); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[52].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message36876_Message36888); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[53].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message36876_Message36889); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[54].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message36876_Message36910); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[55].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message36876_Message36911); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[56].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message36876_Message36912); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[57].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message17783_Message17784); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_1_proto_msgTypes[58].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message17783_Message17785); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_datasets_google_message3_benchmark_message3_1_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   59,
+			NumExtensions: 6,
+			NumServices:   0,
+		},
+		GoTypes:           file_datasets_google_message3_benchmark_message3_1_proto_goTypes,
+		DependencyIndexes: file_datasets_google_message3_benchmark_message3_1_proto_depIdxs,
+		MessageInfos:      file_datasets_google_message3_benchmark_message3_1_proto_msgTypes,
+		ExtensionInfos:    file_datasets_google_message3_benchmark_message3_1_proto_extTypes,
+	}.Build()
+	File_datasets_google_message3_benchmark_message3_1_proto = out.File
+	file_datasets_google_message3_benchmark_message3_1_proto_rawDesc = nil
+	file_datasets_google_message3_benchmark_message3_1_proto_goTypes = nil
+	file_datasets_google_message3_benchmark_message3_1_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3/benchmark_message3_2.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3/benchmark_message3_2.pb.go
new file mode 100644
index 000000000..99ed73fd4
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3/benchmark_message3_2.pb.go
@@ -0,0 +1,6354 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// LINT: ALLOW_GROUPS
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: datasets/google_message3/benchmark_message3_2.proto
+
+package google_message3
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoiface "google.golang.org/protobuf/runtime/protoiface"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type Message22853 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field22869 *Enum22854          `protobuf:"varint,1,opt,name=field22869,enum=benchmarks.google_message3.Enum22854" json:"field22869,omitempty"`
+	Field22870 []uint32            `protobuf:"varint,2,rep,packed,name=field22870" json:"field22870,omitempty"`
+	Field22871 []float32           `protobuf:"fixed32,3,rep,packed,name=field22871" json:"field22871,omitempty"`
+	Field22872 []float32           `protobuf:"fixed32,5,rep,packed,name=field22872" json:"field22872,omitempty"`
+	Field22873 *UnusedEmptyMessage `protobuf:"bytes,4,opt,name=field22873" json:"field22873,omitempty"`
+}
+
+func (x *Message22853) Reset() {
+	*x = Message22853{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message22853) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message22853) ProtoMessage() {}
+
+func (x *Message22853) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message22853.ProtoReflect.Descriptor instead.
+func (*Message22853) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_2_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Message22853) GetField22869() Enum22854 {
+	if x != nil && x.Field22869 != nil {
+		return *x.Field22869
+	}
+	return Enum22854_ENUM_VALUE22855
+}
+
+func (x *Message22853) GetField22870() []uint32 {
+	if x != nil {
+		return x.Field22870
+	}
+	return nil
+}
+
+func (x *Message22853) GetField22871() []float32 {
+	if x != nil {
+		return x.Field22871
+	}
+	return nil
+}
+
+func (x *Message22853) GetField22872() []float32 {
+	if x != nil {
+		return x.Field22872
+	}
+	return nil
+}
+
+func (x *Message22853) GetField22873() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field22873
+	}
+	return nil
+}
+
+type Message24345 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field24533 *string             `protobuf:"bytes,1,opt,name=field24533" json:"field24533,omitempty"`
+	Field24534 *UnusedEnum         `protobuf:"varint,22,opt,name=field24534,enum=benchmarks.google_message3.UnusedEnum" json:"field24534,omitempty"`
+	Field24535 *Message24346       `protobuf:"bytes,2,opt,name=field24535" json:"field24535,omitempty"`
+	Field24536 *string             `protobuf:"bytes,3,opt,name=field24536" json:"field24536,omitempty"`
+	Field24537 *string             `protobuf:"bytes,4,opt,name=field24537" json:"field24537,omitempty"`
+	Field24538 *UnusedEnum         `protobuf:"varint,23,opt,name=field24538,enum=benchmarks.google_message3.UnusedEnum" json:"field24538,omitempty"`
+	Field24539 *string             `protobuf:"bytes,5,opt,name=field24539" json:"field24539,omitempty"`
+	Field24540 *string             `protobuf:"bytes,6,req,name=field24540" json:"field24540,omitempty"`
+	Field24541 *string             `protobuf:"bytes,7,opt,name=field24541" json:"field24541,omitempty"`
+	Field24542 *string             `protobuf:"bytes,8,opt,name=field24542" json:"field24542,omitempty"`
+	Field24543 *Message24316       `protobuf:"bytes,9,opt,name=field24543" json:"field24543,omitempty"`
+	Field24544 *Message24376       `protobuf:"bytes,10,opt,name=field24544" json:"field24544,omitempty"`
+	Field24545 *string             `protobuf:"bytes,11,opt,name=field24545" json:"field24545,omitempty"`
+	Field24546 *string             `protobuf:"bytes,19,opt,name=field24546" json:"field24546,omitempty"`
+	Field24547 *string             `protobuf:"bytes,20,opt,name=field24547" json:"field24547,omitempty"`
+	Field24548 *string             `protobuf:"bytes,21,opt,name=field24548" json:"field24548,omitempty"`
+	Field24549 *UnusedEmptyMessage `protobuf:"bytes,12,opt,name=field24549" json:"field24549,omitempty"`
+	Field24550 *UnusedEmptyMessage `protobuf:"bytes,13,opt,name=field24550" json:"field24550,omitempty"`
+	Field24551 []string            `protobuf:"bytes,14,rep,name=field24551" json:"field24551,omitempty"`
+	Field24552 *string             `protobuf:"bytes,15,opt,name=field24552" json:"field24552,omitempty"`
+	Field24553 *int32              `protobuf:"varint,18,opt,name=field24553" json:"field24553,omitempty"`
+	Field24554 *Message24379       `protobuf:"bytes,16,opt,name=field24554" json:"field24554,omitempty"`
+	Field24555 *string             `protobuf:"bytes,17,opt,name=field24555" json:"field24555,omitempty"`
+	Field24556 []*Message24356     `protobuf:"bytes,24,rep,name=field24556" json:"field24556,omitempty"`
+	Field24557 []*Message24366     `protobuf:"bytes,25,rep,name=field24557" json:"field24557,omitempty"`
+}
+
+func (x *Message24345) Reset() {
+	*x = Message24345{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message24345) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message24345) ProtoMessage() {}
+
+func (x *Message24345) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message24345.ProtoReflect.Descriptor instead.
+func (*Message24345) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_2_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *Message24345) GetField24533() string {
+	if x != nil && x.Field24533 != nil {
+		return *x.Field24533
+	}
+	return ""
+}
+
+func (x *Message24345) GetField24534() UnusedEnum {
+	if x != nil && x.Field24534 != nil {
+		return *x.Field24534
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+func (x *Message24345) GetField24535() *Message24346 {
+	if x != nil {
+		return x.Field24535
+	}
+	return nil
+}
+
+func (x *Message24345) GetField24536() string {
+	if x != nil && x.Field24536 != nil {
+		return *x.Field24536
+	}
+	return ""
+}
+
+func (x *Message24345) GetField24537() string {
+	if x != nil && x.Field24537 != nil {
+		return *x.Field24537
+	}
+	return ""
+}
+
+func (x *Message24345) GetField24538() UnusedEnum {
+	if x != nil && x.Field24538 != nil {
+		return *x.Field24538
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+func (x *Message24345) GetField24539() string {
+	if x != nil && x.Field24539 != nil {
+		return *x.Field24539
+	}
+	return ""
+}
+
+func (x *Message24345) GetField24540() string {
+	if x != nil && x.Field24540 != nil {
+		return *x.Field24540
+	}
+	return ""
+}
+
+func (x *Message24345) GetField24541() string {
+	if x != nil && x.Field24541 != nil {
+		return *x.Field24541
+	}
+	return ""
+}
+
+func (x *Message24345) GetField24542() string {
+	if x != nil && x.Field24542 != nil {
+		return *x.Field24542
+	}
+	return ""
+}
+
+func (x *Message24345) GetField24543() *Message24316 {
+	if x != nil {
+		return x.Field24543
+	}
+	return nil
+}
+
+func (x *Message24345) GetField24544() *Message24376 {
+	if x != nil {
+		return x.Field24544
+	}
+	return nil
+}
+
+func (x *Message24345) GetField24545() string {
+	if x != nil && x.Field24545 != nil {
+		return *x.Field24545
+	}
+	return ""
+}
+
+func (x *Message24345) GetField24546() string {
+	if x != nil && x.Field24546 != nil {
+		return *x.Field24546
+	}
+	return ""
+}
+
+func (x *Message24345) GetField24547() string {
+	if x != nil && x.Field24547 != nil {
+		return *x.Field24547
+	}
+	return ""
+}
+
+func (x *Message24345) GetField24548() string {
+	if x != nil && x.Field24548 != nil {
+		return *x.Field24548
+	}
+	return ""
+}
+
+func (x *Message24345) GetField24549() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field24549
+	}
+	return nil
+}
+
+func (x *Message24345) GetField24550() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field24550
+	}
+	return nil
+}
+
+func (x *Message24345) GetField24551() []string {
+	if x != nil {
+		return x.Field24551
+	}
+	return nil
+}
+
+func (x *Message24345) GetField24552() string {
+	if x != nil && x.Field24552 != nil {
+		return *x.Field24552
+	}
+	return ""
+}
+
+func (x *Message24345) GetField24553() int32 {
+	if x != nil && x.Field24553 != nil {
+		return *x.Field24553
+	}
+	return 0
+}
+
+func (x *Message24345) GetField24554() *Message24379 {
+	if x != nil {
+		return x.Field24554
+	}
+	return nil
+}
+
+func (x *Message24345) GetField24555() string {
+	if x != nil && x.Field24555 != nil {
+		return *x.Field24555
+	}
+	return ""
+}
+
+func (x *Message24345) GetField24556() []*Message24356 {
+	if x != nil {
+		return x.Field24556
+	}
+	return nil
+}
+
+func (x *Message24345) GetField24557() []*Message24366 {
+	if x != nil {
+		return x.Field24557
+	}
+	return nil
+}
+
+type Message24403 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field24681 *Message24401 `protobuf:"bytes,1,opt,name=field24681" json:"field24681,omitempty"`
+	Field24682 *Message24402 `protobuf:"bytes,2,opt,name=field24682" json:"field24682,omitempty"`
+}
+
+func (x *Message24403) Reset() {
+	*x = Message24403{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message24403) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message24403) ProtoMessage() {}
+
+func (x *Message24403) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message24403.ProtoReflect.Descriptor instead.
+func (*Message24403) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_2_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *Message24403) GetField24681() *Message24401 {
+	if x != nil {
+		return x.Field24681
+	}
+	return nil
+}
+
+func (x *Message24403) GetField24682() *Message24402 {
+	if x != nil {
+		return x.Field24682
+	}
+	return nil
+}
+
+type Message24391 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field24631 *string               `protobuf:"bytes,1,opt,name=field24631" json:"field24631,omitempty"`
+	Field24632 *string               `protobuf:"bytes,2,opt,name=field24632" json:"field24632,omitempty"`
+	Field24633 []string              `protobuf:"bytes,3,rep,name=field24633" json:"field24633,omitempty"`
+	Field24634 *string               `protobuf:"bytes,4,opt,name=field24634" json:"field24634,omitempty"`
+	Field24635 []string              `protobuf:"bytes,5,rep,name=field24635" json:"field24635,omitempty"`
+	Field24636 []string              `protobuf:"bytes,16,rep,name=field24636" json:"field24636,omitempty"`
+	Field24637 *string               `protobuf:"bytes,17,opt,name=field24637" json:"field24637,omitempty"`
+	Field24638 *UnusedEmptyMessage   `protobuf:"bytes,25,opt,name=field24638" json:"field24638,omitempty"`
+	Field24639 *string               `protobuf:"bytes,7,opt,name=field24639" json:"field24639,omitempty"`
+	Field24640 *string               `protobuf:"bytes,18,opt,name=field24640" json:"field24640,omitempty"`
+	Field24641 *string               `protobuf:"bytes,19,opt,name=field24641" json:"field24641,omitempty"`
+	Field24642 *string               `protobuf:"bytes,20,opt,name=field24642" json:"field24642,omitempty"`
+	Field24643 *int32                `protobuf:"varint,24,opt,name=field24643" json:"field24643,omitempty"`
+	Field24644 *Message24379         `protobuf:"bytes,8,opt,name=field24644" json:"field24644,omitempty"`
+	Field24645 []*UnusedEmptyMessage `protobuf:"bytes,9,rep,name=field24645" json:"field24645,omitempty"`
+	Field24646 *UnusedEmptyMessage   `protobuf:"bytes,10,opt,name=field24646" json:"field24646,omitempty"`
+	Field24647 *UnusedEmptyMessage   `protobuf:"bytes,11,opt,name=field24647" json:"field24647,omitempty"`
+	Field24648 *UnusedEmptyMessage   `protobuf:"bytes,12,opt,name=field24648" json:"field24648,omitempty"`
+	Field24649 []*UnusedEmptyMessage `protobuf:"bytes,13,rep,name=field24649" json:"field24649,omitempty"`
+	Field24650 *UnusedEmptyMessage   `protobuf:"bytes,14,opt,name=field24650" json:"field24650,omitempty"`
+	Field24651 *string               `protobuf:"bytes,21,opt,name=field24651" json:"field24651,omitempty"`
+	Field24652 *int32                `protobuf:"varint,22,opt,name=field24652" json:"field24652,omitempty"`
+	Field24653 *int32                `protobuf:"varint,23,opt,name=field24653" json:"field24653,omitempty"`
+	Field24654 []string              `protobuf:"bytes,15,rep,name=field24654" json:"field24654,omitempty"`
+	Field24655 []string              `protobuf:"bytes,6,rep,name=field24655" json:"field24655,omitempty"`
+}
+
+func (x *Message24391) Reset() {
+	*x = Message24391{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message24391) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message24391) ProtoMessage() {}
+
+func (x *Message24391) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message24391.ProtoReflect.Descriptor instead.
+func (*Message24391) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_2_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *Message24391) GetField24631() string {
+	if x != nil && x.Field24631 != nil {
+		return *x.Field24631
+	}
+	return ""
+}
+
+func (x *Message24391) GetField24632() string {
+	if x != nil && x.Field24632 != nil {
+		return *x.Field24632
+	}
+	return ""
+}
+
+func (x *Message24391) GetField24633() []string {
+	if x != nil {
+		return x.Field24633
+	}
+	return nil
+}
+
+func (x *Message24391) GetField24634() string {
+	if x != nil && x.Field24634 != nil {
+		return *x.Field24634
+	}
+	return ""
+}
+
+func (x *Message24391) GetField24635() []string {
+	if x != nil {
+		return x.Field24635
+	}
+	return nil
+}
+
+func (x *Message24391) GetField24636() []string {
+	if x != nil {
+		return x.Field24636
+	}
+	return nil
+}
+
+func (x *Message24391) GetField24637() string {
+	if x != nil && x.Field24637 != nil {
+		return *x.Field24637
+	}
+	return ""
+}
+
+func (x *Message24391) GetField24638() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field24638
+	}
+	return nil
+}
+
+func (x *Message24391) GetField24639() string {
+	if x != nil && x.Field24639 != nil {
+		return *x.Field24639
+	}
+	return ""
+}
+
+func (x *Message24391) GetField24640() string {
+	if x != nil && x.Field24640 != nil {
+		return *x.Field24640
+	}
+	return ""
+}
+
+func (x *Message24391) GetField24641() string {
+	if x != nil && x.Field24641 != nil {
+		return *x.Field24641
+	}
+	return ""
+}
+
+func (x *Message24391) GetField24642() string {
+	if x != nil && x.Field24642 != nil {
+		return *x.Field24642
+	}
+	return ""
+}
+
+func (x *Message24391) GetField24643() int32 {
+	if x != nil && x.Field24643 != nil {
+		return *x.Field24643
+	}
+	return 0
+}
+
+func (x *Message24391) GetField24644() *Message24379 {
+	if x != nil {
+		return x.Field24644
+	}
+	return nil
+}
+
+func (x *Message24391) GetField24645() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field24645
+	}
+	return nil
+}
+
+func (x *Message24391) GetField24646() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field24646
+	}
+	return nil
+}
+
+func (x *Message24391) GetField24647() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field24647
+	}
+	return nil
+}
+
+func (x *Message24391) GetField24648() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field24648
+	}
+	return nil
+}
+
+func (x *Message24391) GetField24649() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field24649
+	}
+	return nil
+}
+
+func (x *Message24391) GetField24650() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field24650
+	}
+	return nil
+}
+
+func (x *Message24391) GetField24651() string {
+	if x != nil && x.Field24651 != nil {
+		return *x.Field24651
+	}
+	return ""
+}
+
+func (x *Message24391) GetField24652() int32 {
+	if x != nil && x.Field24652 != nil {
+		return *x.Field24652
+	}
+	return 0
+}
+
+func (x *Message24391) GetField24653() int32 {
+	if x != nil && x.Field24653 != nil {
+		return *x.Field24653
+	}
+	return 0
+}
+
+func (x *Message24391) GetField24654() []string {
+	if x != nil {
+		return x.Field24654
+	}
+	return nil
+}
+
+func (x *Message24391) GetField24655() []string {
+	if x != nil {
+		return x.Field24655
+	}
+	return nil
+}
+
+type Message27454 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message27454) Reset() {
+	*x = Message27454{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message27454) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message27454) ProtoMessage() {}
+
+func (x *Message27454) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message27454.ProtoReflect.Descriptor instead.
+func (*Message27454) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_2_proto_rawDescGZIP(), []int{4}
+}
+
+type Message27357 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field27410 *string  `protobuf:"bytes,1,opt,name=field27410" json:"field27410,omitempty"`
+	Field27411 *float32 `protobuf:"fixed32,2,opt,name=field27411" json:"field27411,omitempty"`
+	Field27412 *string  `protobuf:"bytes,3,opt,name=field27412" json:"field27412,omitempty"`
+	Field27413 *bool    `protobuf:"varint,4,opt,name=field27413" json:"field27413,omitempty"`
+	Field27414 *bool    `protobuf:"varint,5,opt,name=field27414" json:"field27414,omitempty"`
+}
+
+func (x *Message27357) Reset() {
+	*x = Message27357{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[5]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message27357) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message27357) ProtoMessage() {}
+
+func (x *Message27357) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[5]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message27357.ProtoReflect.Descriptor instead.
+func (*Message27357) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_2_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *Message27357) GetField27410() string {
+	if x != nil && x.Field27410 != nil {
+		return *x.Field27410
+	}
+	return ""
+}
+
+func (x *Message27357) GetField27411() float32 {
+	if x != nil && x.Field27411 != nil {
+		return *x.Field27411
+	}
+	return 0
+}
+
+func (x *Message27357) GetField27412() string {
+	if x != nil && x.Field27412 != nil {
+		return *x.Field27412
+	}
+	return ""
+}
+
+func (x *Message27357) GetField27413() bool {
+	if x != nil && x.Field27413 != nil {
+		return *x.Field27413
+	}
+	return false
+}
+
+func (x *Message27357) GetField27414() bool {
+	if x != nil && x.Field27414 != nil {
+		return *x.Field27414
+	}
+	return false
+}
+
+type Message27360 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field27426 *Message27358         `protobuf:"bytes,1,opt,name=field27426" json:"field27426,omitempty"`
+	Field27427 *Enum27361            `protobuf:"varint,2,opt,name=field27427,enum=benchmarks.google_message3.Enum27361" json:"field27427,omitempty"`
+	Field27428 *Message27358         `protobuf:"bytes,3,opt,name=field27428" json:"field27428,omitempty"`
+	Field27429 []*UnusedEmptyMessage `protobuf:"bytes,4,rep,name=field27429" json:"field27429,omitempty"`
+}
+
+func (x *Message27360) Reset() {
+	*x = Message27360{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[6]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message27360) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message27360) ProtoMessage() {}
+
+func (x *Message27360) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[6]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message27360.ProtoReflect.Descriptor instead.
+func (*Message27360) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_2_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *Message27360) GetField27426() *Message27358 {
+	if x != nil {
+		return x.Field27426
+	}
+	return nil
+}
+
+func (x *Message27360) GetField27427() Enum27361 {
+	if x != nil && x.Field27427 != nil {
+		return *x.Field27427
+	}
+	return Enum27361_ENUM_VALUE27362
+}
+
+func (x *Message27360) GetField27428() *Message27358 {
+	if x != nil {
+		return x.Field27428
+	}
+	return nil
+}
+
+func (x *Message27360) GetField27429() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field27429
+	}
+	return nil
+}
+
+type Message34387 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field34446 *string         `protobuf:"bytes,1,opt,name=field34446" json:"field34446,omitempty"`
+	Field34447 []*Message34381 `protobuf:"bytes,2,rep,name=field34447" json:"field34447,omitempty"`
+	Field34448 *UnusedEnum     `protobuf:"varint,3,opt,name=field34448,enum=benchmarks.google_message3.UnusedEnum" json:"field34448,omitempty"`
+	Field34449 *Enum34388      `protobuf:"varint,4,opt,name=field34449,enum=benchmarks.google_message3.Enum34388" json:"field34449,omitempty"`
+	Field34450 *int64          `protobuf:"varint,5,opt,name=field34450" json:"field34450,omitempty"`
+}
+
+func (x *Message34387) Reset() {
+	*x = Message34387{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[7]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message34387) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message34387) ProtoMessage() {}
+
+func (x *Message34387) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[7]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message34387.ProtoReflect.Descriptor instead.
+func (*Message34387) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_2_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *Message34387) GetField34446() string {
+	if x != nil && x.Field34446 != nil {
+		return *x.Field34446
+	}
+	return ""
+}
+
+func (x *Message34387) GetField34447() []*Message34381 {
+	if x != nil {
+		return x.Field34447
+	}
+	return nil
+}
+
+func (x *Message34387) GetField34448() UnusedEnum {
+	if x != nil && x.Field34448 != nil {
+		return *x.Field34448
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+func (x *Message34387) GetField34449() Enum34388 {
+	if x != nil && x.Field34449 != nil {
+		return *x.Field34449
+	}
+	return Enum34388_ENUM_VALUE34389
+}
+
+func (x *Message34387) GetField34450() int64 {
+	if x != nil && x.Field34450 != nil {
+		return *x.Field34450
+	}
+	return 0
+}
+
+type Message34621 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field34651 *float64              `protobuf:"fixed64,1,opt,name=field34651" json:"field34651,omitempty"`
+	Field34652 *float64              `protobuf:"fixed64,2,opt,name=field34652" json:"field34652,omitempty"`
+	Field34653 *float64              `protobuf:"fixed64,3,opt,name=field34653" json:"field34653,omitempty"`
+	Field34654 *float64              `protobuf:"fixed64,4,opt,name=field34654" json:"field34654,omitempty"`
+	Field34655 *float64              `protobuf:"fixed64,11,opt,name=field34655" json:"field34655,omitempty"`
+	Field34656 *UnusedEmptyMessage   `protobuf:"bytes,13,opt,name=field34656" json:"field34656,omitempty"`
+	Field34657 *Message34619         `protobuf:"bytes,14,opt,name=field34657" json:"field34657,omitempty"`
+	Field34658 *string               `protobuf:"bytes,5,opt,name=field34658" json:"field34658,omitempty"`
+	Field34659 *string               `protobuf:"bytes,9,opt,name=field34659" json:"field34659,omitempty"`
+	Field34660 *float64              `protobuf:"fixed64,12,opt,name=field34660" json:"field34660,omitempty"`
+	Field34661 []byte                `protobuf:"bytes,19,opt,name=field34661" json:"field34661,omitempty"`
+	Field34662 *string               `protobuf:"bytes,15,opt,name=field34662" json:"field34662,omitempty"`
+	Field34663 *string               `protobuf:"bytes,16,opt,name=field34663" json:"field34663,omitempty"`
+	Field34664 *string               `protobuf:"bytes,17,opt,name=field34664" json:"field34664,omitempty"`
+	Field34665 *UnusedEmptyMessage   `protobuf:"bytes,18,opt,name=field34665" json:"field34665,omitempty"`
+	Field34666 *Message34621         `protobuf:"bytes,20,opt,name=field34666" json:"field34666,omitempty"`
+	Field34667 []*UnusedEmptyMessage `protobuf:"bytes,100,rep,name=field34667" json:"field34667,omitempty"`
+	Field34668 *UnusedEmptyMessage   `protobuf:"bytes,101,opt,name=field34668" json:"field34668,omitempty"`
+}
+
+func (x *Message34621) Reset() {
+	*x = Message34621{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[8]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message34621) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message34621) ProtoMessage() {}
+
+func (x *Message34621) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[8]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message34621.ProtoReflect.Descriptor instead.
+func (*Message34621) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_2_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *Message34621) GetField34651() float64 {
+	if x != nil && x.Field34651 != nil {
+		return *x.Field34651
+	}
+	return 0
+}
+
+func (x *Message34621) GetField34652() float64 {
+	if x != nil && x.Field34652 != nil {
+		return *x.Field34652
+	}
+	return 0
+}
+
+func (x *Message34621) GetField34653() float64 {
+	if x != nil && x.Field34653 != nil {
+		return *x.Field34653
+	}
+	return 0
+}
+
+func (x *Message34621) GetField34654() float64 {
+	if x != nil && x.Field34654 != nil {
+		return *x.Field34654
+	}
+	return 0
+}
+
+func (x *Message34621) GetField34655() float64 {
+	if x != nil && x.Field34655 != nil {
+		return *x.Field34655
+	}
+	return 0
+}
+
+func (x *Message34621) GetField34656() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field34656
+	}
+	return nil
+}
+
+func (x *Message34621) GetField34657() *Message34619 {
+	if x != nil {
+		return x.Field34657
+	}
+	return nil
+}
+
+func (x *Message34621) GetField34658() string {
+	if x != nil && x.Field34658 != nil {
+		return *x.Field34658
+	}
+	return ""
+}
+
+func (x *Message34621) GetField34659() string {
+	if x != nil && x.Field34659 != nil {
+		return *x.Field34659
+	}
+	return ""
+}
+
+func (x *Message34621) GetField34660() float64 {
+	if x != nil && x.Field34660 != nil {
+		return *x.Field34660
+	}
+	return 0
+}
+
+func (x *Message34621) GetField34661() []byte {
+	if x != nil {
+		return x.Field34661
+	}
+	return nil
+}
+
+func (x *Message34621) GetField34662() string {
+	if x != nil && x.Field34662 != nil {
+		return *x.Field34662
+	}
+	return ""
+}
+
+func (x *Message34621) GetField34663() string {
+	if x != nil && x.Field34663 != nil {
+		return *x.Field34663
+	}
+	return ""
+}
+
+func (x *Message34621) GetField34664() string {
+	if x != nil && x.Field34664 != nil {
+		return *x.Field34664
+	}
+	return ""
+}
+
+func (x *Message34621) GetField34665() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field34665
+	}
+	return nil
+}
+
+func (x *Message34621) GetField34666() *Message34621 {
+	if x != nil {
+		return x.Field34666
+	}
+	return nil
+}
+
+func (x *Message34621) GetField34667() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field34667
+	}
+	return nil
+}
+
+func (x *Message34621) GetField34668() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field34668
+	}
+	return nil
+}
+
+type Message35476 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field35484 *string             `protobuf:"bytes,1,opt,name=field35484" json:"field35484,omitempty"`
+	Field35485 *string             `protobuf:"bytes,2,opt,name=field35485" json:"field35485,omitempty"`
+	Field35486 *string             `protobuf:"bytes,3,opt,name=field35486" json:"field35486,omitempty"`
+	Field35487 *Enum35477          `protobuf:"varint,4,opt,name=field35487,enum=benchmarks.google_message3.Enum35477" json:"field35487,omitempty"`
+	Field35488 *float32            `protobuf:"fixed32,5,opt,name=field35488" json:"field35488,omitempty"`
+	Field35489 *float32            `protobuf:"fixed32,6,opt,name=field35489" json:"field35489,omitempty"`
+	Field35490 *float32            `protobuf:"fixed32,7,opt,name=field35490" json:"field35490,omitempty"`
+	Field35491 *float32            `protobuf:"fixed32,8,opt,name=field35491" json:"field35491,omitempty"`
+	Field35492 *UnusedEmptyMessage `protobuf:"bytes,9,opt,name=field35492" json:"field35492,omitempty"`
+	Field35493 *int32              `protobuf:"varint,10,opt,name=field35493" json:"field35493,omitempty"`
+	Field35494 *int32              `protobuf:"varint,11,opt,name=field35494" json:"field35494,omitempty"`
+	Field35495 *int32              `protobuf:"varint,12,opt,name=field35495" json:"field35495,omitempty"`
+	Field35496 *string             `protobuf:"bytes,13,opt,name=field35496" json:"field35496,omitempty"`
+	Field35497 *string             `protobuf:"bytes,14,opt,name=field35497" json:"field35497,omitempty"`
+}
+
+func (x *Message35476) Reset() {
+	*x = Message35476{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[9]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message35476) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message35476) ProtoMessage() {}
+
+func (x *Message35476) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[9]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message35476.ProtoReflect.Descriptor instead.
+func (*Message35476) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_2_proto_rawDescGZIP(), []int{9}
+}
+
+func (x *Message35476) GetField35484() string {
+	if x != nil && x.Field35484 != nil {
+		return *x.Field35484
+	}
+	return ""
+}
+
+func (x *Message35476) GetField35485() string {
+	if x != nil && x.Field35485 != nil {
+		return *x.Field35485
+	}
+	return ""
+}
+
+func (x *Message35476) GetField35486() string {
+	if x != nil && x.Field35486 != nil {
+		return *x.Field35486
+	}
+	return ""
+}
+
+func (x *Message35476) GetField35487() Enum35477 {
+	if x != nil && x.Field35487 != nil {
+		return *x.Field35487
+	}
+	return Enum35477_ENUM_VALUE35478
+}
+
+func (x *Message35476) GetField35488() float32 {
+	if x != nil && x.Field35488 != nil {
+		return *x.Field35488
+	}
+	return 0
+}
+
+func (x *Message35476) GetField35489() float32 {
+	if x != nil && x.Field35489 != nil {
+		return *x.Field35489
+	}
+	return 0
+}
+
+func (x *Message35476) GetField35490() float32 {
+	if x != nil && x.Field35490 != nil {
+		return *x.Field35490
+	}
+	return 0
+}
+
+func (x *Message35476) GetField35491() float32 {
+	if x != nil && x.Field35491 != nil {
+		return *x.Field35491
+	}
+	return 0
+}
+
+func (x *Message35476) GetField35492() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field35492
+	}
+	return nil
+}
+
+func (x *Message35476) GetField35493() int32 {
+	if x != nil && x.Field35493 != nil {
+		return *x.Field35493
+	}
+	return 0
+}
+
+func (x *Message35476) GetField35494() int32 {
+	if x != nil && x.Field35494 != nil {
+		return *x.Field35494
+	}
+	return 0
+}
+
+func (x *Message35476) GetField35495() int32 {
+	if x != nil && x.Field35495 != nil {
+		return *x.Field35495
+	}
+	return 0
+}
+
+func (x *Message35476) GetField35496() string {
+	if x != nil && x.Field35496 != nil {
+		return *x.Field35496
+	}
+	return ""
+}
+
+func (x *Message35476) GetField35497() string {
+	if x != nil && x.Field35497 != nil {
+		return *x.Field35497
+	}
+	return ""
+}
+
+type Message949 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field955 *string     `protobuf:"bytes,1,opt,name=field955" json:"field955,omitempty"`
+	Field956 *int64      `protobuf:"varint,2,opt,name=field956" json:"field956,omitempty"`
+	Field957 *int64      `protobuf:"varint,3,opt,name=field957" json:"field957,omitempty"`
+	Field958 *Message730 `protobuf:"bytes,4,opt,name=field958" json:"field958,omitempty"`
+	Field959 []string    `protobuf:"bytes,5,rep,name=field959" json:"field959,omitempty"`
+	Field960 *string     `protobuf:"bytes,6,opt,name=field960" json:"field960,omitempty"`
+	Field961 *bool       `protobuf:"varint,7,opt,name=field961" json:"field961,omitempty"`
+}
+
+func (x *Message949) Reset() {
+	*x = Message949{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[10]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message949) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message949) ProtoMessage() {}
+
+func (x *Message949) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[10]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message949.ProtoReflect.Descriptor instead.
+func (*Message949) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_2_proto_rawDescGZIP(), []int{10}
+}
+
+func (x *Message949) GetField955() string {
+	if x != nil && x.Field955 != nil {
+		return *x.Field955
+	}
+	return ""
+}
+
+func (x *Message949) GetField956() int64 {
+	if x != nil && x.Field956 != nil {
+		return *x.Field956
+	}
+	return 0
+}
+
+func (x *Message949) GetField957() int64 {
+	if x != nil && x.Field957 != nil {
+		return *x.Field957
+	}
+	return 0
+}
+
+func (x *Message949) GetField958() *Message730 {
+	if x != nil {
+		return x.Field958
+	}
+	return nil
+}
+
+func (x *Message949) GetField959() []string {
+	if x != nil {
+		return x.Field959
+	}
+	return nil
+}
+
+func (x *Message949) GetField960() string {
+	if x != nil && x.Field960 != nil {
+		return *x.Field960
+	}
+	return ""
+}
+
+func (x *Message949) GetField961() bool {
+	if x != nil && x.Field961 != nil {
+		return *x.Field961
+	}
+	return false
+}
+
+type Message36869 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field36970 *int32 `protobuf:"varint,1,opt,name=field36970" json:"field36970,omitempty"`
+	Field36971 *int32 `protobuf:"varint,2,opt,name=field36971" json:"field36971,omitempty"`
+}
+
+func (x *Message36869) Reset() {
+	*x = Message36869{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[11]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message36869) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message36869) ProtoMessage() {}
+
+func (x *Message36869) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[11]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message36869.ProtoReflect.Descriptor instead.
+func (*Message36869) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_2_proto_rawDescGZIP(), []int{11}
+}
+
+func (x *Message36869) GetField36970() int32 {
+	if x != nil && x.Field36970 != nil {
+		return *x.Field36970
+	}
+	return 0
+}
+
+func (x *Message36869) GetField36971() int32 {
+	if x != nil && x.Field36971 != nil {
+		return *x.Field36971
+	}
+	return 0
+}
+
+type Message33968 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Message33969 []*Message33968_Message33969 `protobuf:"group,1,rep,name=Message33969,json=message33969" json:"message33969,omitempty"`
+	Field33989   []*Message33958              `protobuf:"bytes,3,rep,name=field33989" json:"field33989,omitempty"`
+	Field33990   *UnusedEmptyMessage          `protobuf:"bytes,106,opt,name=field33990" json:"field33990,omitempty"`
+	Field33991   *bool                        `protobuf:"varint,108,opt,name=field33991" json:"field33991,omitempty"`
+	Field33992   *UnusedEnum                  `protobuf:"varint,107,opt,name=field33992,enum=benchmarks.google_message3.UnusedEnum" json:"field33992,omitempty"`
+}
+
+func (x *Message33968) Reset() {
+	*x = Message33968{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[12]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message33968) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message33968) ProtoMessage() {}
+
+func (x *Message33968) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[12]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message33968.ProtoReflect.Descriptor instead.
+func (*Message33968) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_2_proto_rawDescGZIP(), []int{12}
+}
+
+func (x *Message33968) GetMessage33969() []*Message33968_Message33969 {
+	if x != nil {
+		return x.Message33969
+	}
+	return nil
+}
+
+func (x *Message33968) GetField33989() []*Message33958 {
+	if x != nil {
+		return x.Field33989
+	}
+	return nil
+}
+
+func (x *Message33968) GetField33990() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field33990
+	}
+	return nil
+}
+
+func (x *Message33968) GetField33991() bool {
+	if x != nil && x.Field33991 != nil {
+		return *x.Field33991
+	}
+	return false
+}
+
+func (x *Message33968) GetField33992() UnusedEnum {
+	if x != nil && x.Field33992 != nil {
+		return *x.Field33992
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+type Message6644 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field6701 *UnusedEmptyMessage `protobuf:"bytes,8,opt,name=field6701" json:"field6701,omitempty"`
+	Field6702 *string             `protobuf:"bytes,1,opt,name=field6702" json:"field6702,omitempty"`
+	Field6703 *float64            `protobuf:"fixed64,2,opt,name=field6703" json:"field6703,omitempty"`
+	Field6704 *UnusedEmptyMessage `protobuf:"bytes,9,opt,name=field6704" json:"field6704,omitempty"`
+	Field6705 []byte              `protobuf:"bytes,3,opt,name=field6705" json:"field6705,omitempty"`
+	Field6706 []byte              `protobuf:"bytes,19,opt,name=field6706" json:"field6706,omitempty"`
+	Field6707 *Message6637        `protobuf:"bytes,4,opt,name=field6707" json:"field6707,omitempty"`
+	Field6708 []*Message6126      `protobuf:"bytes,18,rep,name=field6708" json:"field6708,omitempty"`
+	Field6709 *bool               `protobuf:"varint,6,opt,name=field6709" json:"field6709,omitempty"`
+	Field6710 *Message6643        `protobuf:"bytes,10,opt,name=field6710" json:"field6710,omitempty"`
+	Field6711 *string             `protobuf:"bytes,12,opt,name=field6711" json:"field6711,omitempty"`
+	Field6712 *UnusedEmptyMessage `protobuf:"bytes,14,opt,name=field6712" json:"field6712,omitempty"`
+	Field6713 *UnusedEmptyMessage `protobuf:"bytes,15,opt,name=field6713" json:"field6713,omitempty"`
+	Field6714 *UnusedEmptyMessage `protobuf:"bytes,16,opt,name=field6714" json:"field6714,omitempty"`
+	Field6715 *int32              `protobuf:"varint,17,opt,name=field6715" json:"field6715,omitempty"`
+	Field6716 *UnusedEmptyMessage `protobuf:"bytes,20,opt,name=field6716" json:"field6716,omitempty"`
+}
+
+func (x *Message6644) Reset() {
+	*x = Message6644{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[13]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6644) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6644) ProtoMessage() {}
+
+func (x *Message6644) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[13]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6644.ProtoReflect.Descriptor instead.
+func (*Message6644) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_2_proto_rawDescGZIP(), []int{13}
+}
+
+func (x *Message6644) GetField6701() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field6701
+	}
+	return nil
+}
+
+func (x *Message6644) GetField6702() string {
+	if x != nil && x.Field6702 != nil {
+		return *x.Field6702
+	}
+	return ""
+}
+
+func (x *Message6644) GetField6703() float64 {
+	if x != nil && x.Field6703 != nil {
+		return *x.Field6703
+	}
+	return 0
+}
+
+func (x *Message6644) GetField6704() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field6704
+	}
+	return nil
+}
+
+func (x *Message6644) GetField6705() []byte {
+	if x != nil {
+		return x.Field6705
+	}
+	return nil
+}
+
+func (x *Message6644) GetField6706() []byte {
+	if x != nil {
+		return x.Field6706
+	}
+	return nil
+}
+
+func (x *Message6644) GetField6707() *Message6637 {
+	if x != nil {
+		return x.Field6707
+	}
+	return nil
+}
+
+func (x *Message6644) GetField6708() []*Message6126 {
+	if x != nil {
+		return x.Field6708
+	}
+	return nil
+}
+
+func (x *Message6644) GetField6709() bool {
+	if x != nil && x.Field6709 != nil {
+		return *x.Field6709
+	}
+	return false
+}
+
+func (x *Message6644) GetField6710() *Message6643 {
+	if x != nil {
+		return x.Field6710
+	}
+	return nil
+}
+
+func (x *Message6644) GetField6711() string {
+	if x != nil && x.Field6711 != nil {
+		return *x.Field6711
+	}
+	return ""
+}
+
+func (x *Message6644) GetField6712() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field6712
+	}
+	return nil
+}
+
+func (x *Message6644) GetField6713() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field6713
+	}
+	return nil
+}
+
+func (x *Message6644) GetField6714() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field6714
+	}
+	return nil
+}
+
+func (x *Message6644) GetField6715() int32 {
+	if x != nil && x.Field6715 != nil {
+		return *x.Field6715
+	}
+	return 0
+}
+
+func (x *Message6644) GetField6716() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field6716
+	}
+	return nil
+}
+
+type Message18831 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Message18832 []*Message18831_Message18832 `protobuf:"group,1,rep,name=Message18832,json=message18832" json:"message18832,omitempty"`
+}
+
+func (x *Message18831) Reset() {
+	*x = Message18831{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[14]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message18831) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message18831) ProtoMessage() {}
+
+func (x *Message18831) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[14]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message18831.ProtoReflect.Descriptor instead.
+func (*Message18831) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_2_proto_rawDescGZIP(), []int{14}
+}
+
+func (x *Message18831) GetMessage18832() []*Message18831_Message18832 {
+	if x != nil {
+		return x.Message18832
+	}
+	return nil
+}
+
+type Message13090 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field13141 *Message13083 `protobuf:"bytes,1,opt,name=field13141" json:"field13141,omitempty"`
+	Field13142 *Message13088 `protobuf:"bytes,2,opt,name=field13142" json:"field13142,omitempty"`
+}
+
+func (x *Message13090) Reset() {
+	*x = Message13090{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[15]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message13090) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message13090) ProtoMessage() {}
+
+func (x *Message13090) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[15]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message13090.ProtoReflect.Descriptor instead.
+func (*Message13090) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_2_proto_rawDescGZIP(), []int{15}
+}
+
+func (x *Message13090) GetField13141() *Message13083 {
+	if x != nil {
+		return x.Field13141
+	}
+	return nil
+}
+
+func (x *Message13090) GetField13142() *Message13088 {
+	if x != nil {
+		return x.Field13142
+	}
+	return nil
+}
+
+type Message11874 struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+
+	Field11888 *Message10391 `protobuf:"bytes,3,opt,name=field11888" json:"field11888,omitempty"`
+	Field11889 *string       `protobuf:"bytes,4,opt,name=field11889" json:"field11889,omitempty"`
+	Field11890 *Message11873 `protobuf:"bytes,6,opt,name=field11890" json:"field11890,omitempty"`
+	Field11891 *bool         `protobuf:"varint,7,opt,name=field11891" json:"field11891,omitempty"`
+}
+
+func (x *Message11874) Reset() {
+	*x = Message11874{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[16]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message11874) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message11874) ProtoMessage() {}
+
+func (x *Message11874) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[16]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message11874.ProtoReflect.Descriptor instead.
+func (*Message11874) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_2_proto_rawDescGZIP(), []int{16}
+}
+
+var extRange_Message11874 = []protoiface.ExtensionRangeV1{
+	{Start: 1, End: 1},
+	{Start: 2, End: 2},
+	{Start: 5, End: 5},
+}
+
+// Deprecated: Use Message11874.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*Message11874) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_Message11874
+}
+
+func (x *Message11874) GetField11888() *Message10391 {
+	if x != nil {
+		return x.Field11888
+	}
+	return nil
+}
+
+func (x *Message11874) GetField11889() string {
+	if x != nil && x.Field11889 != nil {
+		return *x.Field11889
+	}
+	return ""
+}
+
+func (x *Message11874) GetField11890() *Message11873 {
+	if x != nil {
+		return x.Field11890
+	}
+	return nil
+}
+
+func (x *Message11874) GetField11891() bool {
+	if x != nil && x.Field11891 != nil {
+		return *x.Field11891
+	}
+	return false
+}
+
+type Message4144 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Message4145 []*Message4144_Message4145 `protobuf:"group,1,rep,name=Message4145,json=message4145" json:"message4145,omitempty"`
+}
+
+func (x *Message4144) Reset() {
+	*x = Message4144{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[17]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message4144) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message4144) ProtoMessage() {}
+
+func (x *Message4144) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[17]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message4144.ProtoReflect.Descriptor instead.
+func (*Message4144) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_2_proto_rawDescGZIP(), []int{17}
+}
+
+func (x *Message4144) GetMessage4145() []*Message4144_Message4145 {
+	if x != nil {
+		return x.Message4145
+	}
+	return nil
+}
+
+type Message35573 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field35695   *uint64                      `protobuf:"fixed64,16,opt,name=field35695" json:"field35695,omitempty"`
+	Field35696   *string                      `protobuf:"bytes,1000,opt,name=field35696" json:"field35696,omitempty"`
+	Field35697   *string                      `protobuf:"bytes,1004,opt,name=field35697" json:"field35697,omitempty"`
+	Field35698   *int32                       `protobuf:"varint,1003,opt,name=field35698" json:"field35698,omitempty"`
+	Message35574 []*Message35573_Message35574 `protobuf:"group,1012,rep,name=Message35574,json=message35574" json:"message35574,omitempty"`
+	Field35700   *int64                       `protobuf:"varint,1011,opt,name=field35700" json:"field35700,omitempty"`
+	Field35701   *int64                       `protobuf:"varint,1005,opt,name=field35701" json:"field35701,omitempty"`
+	Field35702   *int64                       `protobuf:"varint,1006,opt,name=field35702" json:"field35702,omitempty"`
+	Field35703   *int64                       `protobuf:"varint,1007,opt,name=field35703" json:"field35703,omitempty"`
+	Field35704   *int64                       `protobuf:"varint,1008,opt,name=field35704" json:"field35704,omitempty"`
+	Message35575 []*Message35573_Message35575 `protobuf:"group,1,rep,name=Message35575,json=message35575" json:"message35575,omitempty"`
+}
+
+func (x *Message35573) Reset() {
+	*x = Message35573{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[18]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message35573) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message35573) ProtoMessage() {}
+
+func (x *Message35573) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[18]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message35573.ProtoReflect.Descriptor instead.
+func (*Message35573) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_2_proto_rawDescGZIP(), []int{18}
+}
+
+func (x *Message35573) GetField35695() uint64 {
+	if x != nil && x.Field35695 != nil {
+		return *x.Field35695
+	}
+	return 0
+}
+
+func (x *Message35573) GetField35696() string {
+	if x != nil && x.Field35696 != nil {
+		return *x.Field35696
+	}
+	return ""
+}
+
+func (x *Message35573) GetField35697() string {
+	if x != nil && x.Field35697 != nil {
+		return *x.Field35697
+	}
+	return ""
+}
+
+func (x *Message35573) GetField35698() int32 {
+	if x != nil && x.Field35698 != nil {
+		return *x.Field35698
+	}
+	return 0
+}
+
+func (x *Message35573) GetMessage35574() []*Message35573_Message35574 {
+	if x != nil {
+		return x.Message35574
+	}
+	return nil
+}
+
+func (x *Message35573) GetField35700() int64 {
+	if x != nil && x.Field35700 != nil {
+		return *x.Field35700
+	}
+	return 0
+}
+
+func (x *Message35573) GetField35701() int64 {
+	if x != nil && x.Field35701 != nil {
+		return *x.Field35701
+	}
+	return 0
+}
+
+func (x *Message35573) GetField35702() int64 {
+	if x != nil && x.Field35702 != nil {
+		return *x.Field35702
+	}
+	return 0
+}
+
+func (x *Message35573) GetField35703() int64 {
+	if x != nil && x.Field35703 != nil {
+		return *x.Field35703
+	}
+	return 0
+}
+
+func (x *Message35573) GetField35704() int64 {
+	if x != nil && x.Field35704 != nil {
+		return *x.Field35704
+	}
+	return 0
+}
+
+func (x *Message35573) GetMessage35575() []*Message35573_Message35575 {
+	if x != nil {
+		return x.Message35575
+	}
+	return nil
+}
+
+type Message36858 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field36956   []int32                      `protobuf:"varint,1,rep,name=field36956" json:"field36956,omitempty"`
+	Field36957   []string                     `protobuf:"bytes,2,rep,name=field36957" json:"field36957,omitempty"`
+	Field36958   []string                     `protobuf:"bytes,12,rep,name=field36958" json:"field36958,omitempty"`
+	Field36959   *int32                       `protobuf:"varint,3,opt,name=field36959" json:"field36959,omitempty"`
+	Field36960   *int32                       `protobuf:"varint,4,opt,name=field36960" json:"field36960,omitempty"`
+	Field36961   *int32                       `protobuf:"varint,14,opt,name=field36961" json:"field36961,omitempty"`
+	Field36962   *string                      `protobuf:"bytes,11,opt,name=field36962" json:"field36962,omitempty"`
+	Field36963   *bool                        `protobuf:"varint,5,opt,name=field36963" json:"field36963,omitempty"`
+	Field36964   *bool                        `protobuf:"varint,13,opt,name=field36964" json:"field36964,omitempty"`
+	Field36965   *int64                       `protobuf:"varint,6,opt,name=field36965" json:"field36965,omitempty"`
+	Field36966   *Message35506                `protobuf:"bytes,7,opt,name=field36966" json:"field36966,omitempty"`
+	Message36859 []*Message36858_Message36859 `protobuf:"group,8,rep,name=Message36859,json=message36859" json:"message36859,omitempty"`
+}
+
+func (x *Message36858) Reset() {
+	*x = Message36858{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[19]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message36858) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message36858) ProtoMessage() {}
+
+func (x *Message36858) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[19]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message36858.ProtoReflect.Descriptor instead.
+func (*Message36858) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_2_proto_rawDescGZIP(), []int{19}
+}
+
+func (x *Message36858) GetField36956() []int32 {
+	if x != nil {
+		return x.Field36956
+	}
+	return nil
+}
+
+func (x *Message36858) GetField36957() []string {
+	if x != nil {
+		return x.Field36957
+	}
+	return nil
+}
+
+func (x *Message36858) GetField36958() []string {
+	if x != nil {
+		return x.Field36958
+	}
+	return nil
+}
+
+func (x *Message36858) GetField36959() int32 {
+	if x != nil && x.Field36959 != nil {
+		return *x.Field36959
+	}
+	return 0
+}
+
+func (x *Message36858) GetField36960() int32 {
+	if x != nil && x.Field36960 != nil {
+		return *x.Field36960
+	}
+	return 0
+}
+
+func (x *Message36858) GetField36961() int32 {
+	if x != nil && x.Field36961 != nil {
+		return *x.Field36961
+	}
+	return 0
+}
+
+func (x *Message36858) GetField36962() string {
+	if x != nil && x.Field36962 != nil {
+		return *x.Field36962
+	}
+	return ""
+}
+
+func (x *Message36858) GetField36963() bool {
+	if x != nil && x.Field36963 != nil {
+		return *x.Field36963
+	}
+	return false
+}
+
+func (x *Message36858) GetField36964() bool {
+	if x != nil && x.Field36964 != nil {
+		return *x.Field36964
+	}
+	return false
+}
+
+func (x *Message36858) GetField36965() int64 {
+	if x != nil && x.Field36965 != nil {
+		return *x.Field36965
+	}
+	return 0
+}
+
+func (x *Message36858) GetField36966() *Message35506 {
+	if x != nil {
+		return x.Field36966
+	}
+	return nil
+}
+
+func (x *Message36858) GetMessage36859() []*Message36858_Message36859 {
+	if x != nil {
+		return x.Message36859
+	}
+	return nil
+}
+
+type Message13174 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field13237 *int32        `protobuf:"varint,6,req,name=field13237" json:"field13237,omitempty"`
+	Field13238 *int32        `protobuf:"varint,3,opt,name=field13238" json:"field13238,omitempty"`
+	Field13239 *int32        `protobuf:"varint,4,req,name=field13239" json:"field13239,omitempty"`
+	Field13240 *int32        `protobuf:"varint,8,opt,name=field13240" json:"field13240,omitempty"`
+	Field13241 *float64      `protobuf:"fixed64,5,opt,name=field13241" json:"field13241,omitempty"`
+	Field13242 *float64      `protobuf:"fixed64,7,opt,name=field13242" json:"field13242,omitempty"`
+	Field13243 *int32        `protobuf:"varint,17,opt,name=field13243" json:"field13243,omitempty"`
+	Field13244 *int32        `protobuf:"varint,19,opt,name=field13244" json:"field13244,omitempty"`
+	Field13245 *float64      `protobuf:"fixed64,20,opt,name=field13245" json:"field13245,omitempty"`
+	Field13246 *int32        `protobuf:"varint,9,opt,name=field13246" json:"field13246,omitempty"`
+	Field13247 *float64      `protobuf:"fixed64,10,opt,name=field13247" json:"field13247,omitempty"`
+	Field13248 *int32        `protobuf:"varint,11,opt,name=field13248" json:"field13248,omitempty"`
+	Field13249 *Message13151 `protobuf:"bytes,21,opt,name=field13249" json:"field13249,omitempty"`
+	Field13250 *int32        `protobuf:"varint,1,opt,name=field13250" json:"field13250,omitempty"`
+	Field13251 *float64      `protobuf:"fixed64,2,opt,name=field13251" json:"field13251,omitempty"`
+	Field13252 *float64      `protobuf:"fixed64,15,opt,name=field13252" json:"field13252,omitempty"`
+	Field13253 *float64      `protobuf:"fixed64,16,opt,name=field13253" json:"field13253,omitempty"`
+	Field13254 *float64      `protobuf:"fixed64,12,opt,name=field13254" json:"field13254,omitempty"`
+	Field13255 *float64      `protobuf:"fixed64,13,opt,name=field13255" json:"field13255,omitempty"`
+	Field13256 *float64      `protobuf:"fixed64,14,opt,name=field13256" json:"field13256,omitempty"`
+	Field13257 *int32        `protobuf:"varint,18,opt,name=field13257" json:"field13257,omitempty"`
+}
+
+func (x *Message13174) Reset() {
+	*x = Message13174{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[20]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message13174) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message13174) ProtoMessage() {}
+
+func (x *Message13174) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[20]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message13174.ProtoReflect.Descriptor instead.
+func (*Message13174) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_2_proto_rawDescGZIP(), []int{20}
+}
+
+func (x *Message13174) GetField13237() int32 {
+	if x != nil && x.Field13237 != nil {
+		return *x.Field13237
+	}
+	return 0
+}
+
+func (x *Message13174) GetField13238() int32 {
+	if x != nil && x.Field13238 != nil {
+		return *x.Field13238
+	}
+	return 0
+}
+
+func (x *Message13174) GetField13239() int32 {
+	if x != nil && x.Field13239 != nil {
+		return *x.Field13239
+	}
+	return 0
+}
+
+func (x *Message13174) GetField13240() int32 {
+	if x != nil && x.Field13240 != nil {
+		return *x.Field13240
+	}
+	return 0
+}
+
+func (x *Message13174) GetField13241() float64 {
+	if x != nil && x.Field13241 != nil {
+		return *x.Field13241
+	}
+	return 0
+}
+
+func (x *Message13174) GetField13242() float64 {
+	if x != nil && x.Field13242 != nil {
+		return *x.Field13242
+	}
+	return 0
+}
+
+func (x *Message13174) GetField13243() int32 {
+	if x != nil && x.Field13243 != nil {
+		return *x.Field13243
+	}
+	return 0
+}
+
+func (x *Message13174) GetField13244() int32 {
+	if x != nil && x.Field13244 != nil {
+		return *x.Field13244
+	}
+	return 0
+}
+
+func (x *Message13174) GetField13245() float64 {
+	if x != nil && x.Field13245 != nil {
+		return *x.Field13245
+	}
+	return 0
+}
+
+func (x *Message13174) GetField13246() int32 {
+	if x != nil && x.Field13246 != nil {
+		return *x.Field13246
+	}
+	return 0
+}
+
+func (x *Message13174) GetField13247() float64 {
+	if x != nil && x.Field13247 != nil {
+		return *x.Field13247
+	}
+	return 0
+}
+
+func (x *Message13174) GetField13248() int32 {
+	if x != nil && x.Field13248 != nil {
+		return *x.Field13248
+	}
+	return 0
+}
+
+func (x *Message13174) GetField13249() *Message13151 {
+	if x != nil {
+		return x.Field13249
+	}
+	return nil
+}
+
+func (x *Message13174) GetField13250() int32 {
+	if x != nil && x.Field13250 != nil {
+		return *x.Field13250
+	}
+	return 0
+}
+
+func (x *Message13174) GetField13251() float64 {
+	if x != nil && x.Field13251 != nil {
+		return *x.Field13251
+	}
+	return 0
+}
+
+func (x *Message13174) GetField13252() float64 {
+	if x != nil && x.Field13252 != nil {
+		return *x.Field13252
+	}
+	return 0
+}
+
+func (x *Message13174) GetField13253() float64 {
+	if x != nil && x.Field13253 != nil {
+		return *x.Field13253
+	}
+	return 0
+}
+
+func (x *Message13174) GetField13254() float64 {
+	if x != nil && x.Field13254 != nil {
+		return *x.Field13254
+	}
+	return 0
+}
+
+func (x *Message13174) GetField13255() float64 {
+	if x != nil && x.Field13255 != nil {
+		return *x.Field13255
+	}
+	return 0
+}
+
+func (x *Message13174) GetField13256() float64 {
+	if x != nil && x.Field13256 != nil {
+		return *x.Field13256
+	}
+	return 0
+}
+
+func (x *Message13174) GetField13257() int32 {
+	if x != nil && x.Field13257 != nil {
+		return *x.Field13257
+	}
+	return 0
+}
+
+type Message18283 struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+
+	Field18478 *UnusedEmptyMessage   `protobuf:"bytes,1,opt,name=field18478" json:"field18478,omitempty"`
+	Field18479 *int32                `protobuf:"varint,4,opt,name=field18479" json:"field18479,omitempty"`
+	Field18480 *int32                `protobuf:"varint,106,opt,name=field18480" json:"field18480,omitempty"`
+	Field18481 *int32                `protobuf:"varint,107,opt,name=field18481" json:"field18481,omitempty"`
+	Field18482 *int32                `protobuf:"varint,108,opt,name=field18482" json:"field18482,omitempty"`
+	Field18483 *int32                `protobuf:"varint,109,opt,name=field18483" json:"field18483,omitempty"`
+	Field18484 *int32                `protobuf:"varint,105,opt,name=field18484" json:"field18484,omitempty"`
+	Field18485 *int32                `protobuf:"varint,113,opt,name=field18485" json:"field18485,omitempty"`
+	Field18486 *int32                `protobuf:"varint,114,opt,name=field18486" json:"field18486,omitempty"`
+	Field18487 *int32                `protobuf:"varint,124,opt,name=field18487" json:"field18487,omitempty"`
+	Field18488 *int32                `protobuf:"varint,125,opt,name=field18488" json:"field18488,omitempty"`
+	Field18489 *int32                `protobuf:"varint,128,opt,name=field18489" json:"field18489,omitempty"`
+	Field18490 *int32                `protobuf:"varint,135,opt,name=field18490" json:"field18490,omitempty"`
+	Field18491 *bool                 `protobuf:"varint,166,opt,name=field18491" json:"field18491,omitempty"`
+	Field18492 *bool                 `protobuf:"varint,136,opt,name=field18492" json:"field18492,omitempty"`
+	Field18493 *int32                `protobuf:"varint,140,opt,name=field18493" json:"field18493,omitempty"`
+	Field18494 *int32                `protobuf:"varint,171,opt,name=field18494" json:"field18494,omitempty"`
+	Field18495 *int32                `protobuf:"varint,148,opt,name=field18495" json:"field18495,omitempty"`
+	Field18496 *int32                `protobuf:"varint,145,opt,name=field18496" json:"field18496,omitempty"`
+	Field18497 *float32              `protobuf:"fixed32,117,opt,name=field18497" json:"field18497,omitempty"`
+	Field18498 *int32                `protobuf:"varint,146,opt,name=field18498" json:"field18498,omitempty"`
+	Field18499 *string               `protobuf:"bytes,3,opt,name=field18499" json:"field18499,omitempty"`
+	Field18500 *UnusedEmptyMessage   `protobuf:"bytes,5,opt,name=field18500" json:"field18500,omitempty"`
+	Field18501 *UnusedEmptyMessage   `protobuf:"bytes,6,opt,name=field18501" json:"field18501,omitempty"`
+	Field18502 *UnusedEmptyMessage   `protobuf:"bytes,9,opt,name=field18502" json:"field18502,omitempty"`
+	Field18503 *Message18253         `protobuf:"bytes,155,opt,name=field18503" json:"field18503,omitempty"`
+	Field18504 *UnusedEmptyMessage   `protobuf:"bytes,184,opt,name=field18504" json:"field18504,omitempty"`
+	Field18505 *UnusedEmptyMessage   `protobuf:"bytes,163,opt,name=field18505" json:"field18505,omitempty"`
+	Field18506 *UnusedEmptyMessage   `protobuf:"bytes,16,opt,name=field18506" json:"field18506,omitempty"`
+	Field18507 []int32               `protobuf:"varint,20,rep,name=field18507" json:"field18507,omitempty"`
+	Field18508 []int32               `protobuf:"varint,7,rep,name=field18508" json:"field18508,omitempty"`
+	Field18509 []string              `protobuf:"bytes,194,rep,name=field18509" json:"field18509,omitempty"`
+	Field18510 []byte                `protobuf:"bytes,30,opt,name=field18510" json:"field18510,omitempty"`
+	Field18511 *int32                `protobuf:"varint,31,opt,name=field18511" json:"field18511,omitempty"`
+	Field18512 *UnusedEmptyMessage   `protobuf:"bytes,178,opt,name=field18512" json:"field18512,omitempty"`
+	Field18513 *string               `protobuf:"bytes,8,opt,name=field18513" json:"field18513,omitempty"`
+	Field18514 *float32              `protobuf:"fixed32,2,opt,name=field18514" json:"field18514,omitempty"`
+	Field18515 *float32              `protobuf:"fixed32,100,opt,name=field18515" json:"field18515,omitempty"`
+	Field18516 *float32              `protobuf:"fixed32,101,opt,name=field18516" json:"field18516,omitempty"`
+	Field18517 *float32              `protobuf:"fixed32,102,opt,name=field18517" json:"field18517,omitempty"`
+	Field18518 *int32                `protobuf:"varint,103,opt,name=field18518" json:"field18518,omitempty"`
+	Field18519 []*UnusedEmptyMessage `protobuf:"bytes,104,rep,name=field18519" json:"field18519,omitempty"`
+	Field18520 *int32                `protobuf:"varint,110,opt,name=field18520" json:"field18520,omitempty"`
+	Field18521 *int32                `protobuf:"varint,112,opt,name=field18521" json:"field18521,omitempty"`
+	Field18522 *UnusedEmptyMessage   `protobuf:"bytes,111,opt,name=field18522" json:"field18522,omitempty"`
+	Field18523 *UnusedEmptyMessage   `protobuf:"bytes,115,opt,name=field18523" json:"field18523,omitempty"`
+	Field18524 *UnusedEmptyMessage   `protobuf:"bytes,119,opt,name=field18524" json:"field18524,omitempty"`
+	Field18525 *UnusedEmptyMessage   `protobuf:"bytes,127,opt,name=field18525" json:"field18525,omitempty"`
+	Field18526 *UnusedEmptyMessage   `protobuf:"bytes,185,opt,name=field18526" json:"field18526,omitempty"`
+	Field18527 *int32                `protobuf:"varint,120,opt,name=field18527" json:"field18527,omitempty"`
+	Field18528 *int32                `protobuf:"varint,132,opt,name=field18528" json:"field18528,omitempty"`
+	Field18529 *UnusedEmptyMessage   `protobuf:"bytes,126,opt,name=field18529" json:"field18529,omitempty"`
+	Field18530 *UnusedEmptyMessage   `protobuf:"bytes,129,opt,name=field18530" json:"field18530,omitempty"`
+	Field18531 *UnusedEmptyMessage   `protobuf:"bytes,131,opt,name=field18531" json:"field18531,omitempty"`
+	Field18532 *uint64               `protobuf:"fixed64,150,opt,name=field18532" json:"field18532,omitempty"`
+	Field18533 *int32                `protobuf:"varint,133,opt,name=field18533" json:"field18533,omitempty"`
+	Field18534 *int32                `protobuf:"varint,134,opt,name=field18534" json:"field18534,omitempty"`
+	Field18535 *int32                `protobuf:"varint,139,opt,name=field18535" json:"field18535,omitempty"`
+	Field18536 *uint64               `protobuf:"fixed64,137,opt,name=field18536" json:"field18536,omitempty"`
+	Field18537 *uint64               `protobuf:"fixed64,138,opt,name=field18537" json:"field18537,omitempty"`
+	Field18538 *UnusedEmptyMessage   `protobuf:"bytes,141,opt,name=field18538" json:"field18538,omitempty"`
+	Field18539 *int32                `protobuf:"varint,142,opt,name=field18539" json:"field18539,omitempty"`
+	Field18540 *int32                `protobuf:"varint,181,opt,name=field18540" json:"field18540,omitempty"`
+	Field18541 *Message16816         `protobuf:"bytes,143,opt,name=field18541" json:"field18541,omitempty"`
+	Field18542 *Message16685         `protobuf:"bytes,154,opt,name=field18542" json:"field18542,omitempty"`
+	Field18543 *int32                `protobuf:"varint,144,opt,name=field18543" json:"field18543,omitempty"`
+	Field18544 *int64                `protobuf:"varint,147,opt,name=field18544" json:"field18544,omitempty"`
+	Field18545 *int64                `protobuf:"varint,149,opt,name=field18545" json:"field18545,omitempty"`
+	Field18546 *int32                `protobuf:"varint,151,opt,name=field18546" json:"field18546,omitempty"`
+	Field18547 *int32                `protobuf:"varint,152,opt,name=field18547" json:"field18547,omitempty"`
+	Field18548 *int32                `protobuf:"varint,153,opt,name=field18548" json:"field18548,omitempty"`
+	Field18549 *float32              `protobuf:"fixed32,161,opt,name=field18549" json:"field18549,omitempty"`
+	Field18550 *Message0             `protobuf:"bytes,123,opt,name=field18550" json:"field18550,omitempty"`
+	Field18551 []int64               `protobuf:"varint,156,rep,name=field18551" json:"field18551,omitempty"`
+	Field18552 *int32                `protobuf:"varint,157,opt,name=field18552" json:"field18552,omitempty"`
+	Field18553 []uint64              `protobuf:"fixed64,188,rep,name=field18553" json:"field18553,omitempty"`
+	Field18554 *int32                `protobuf:"varint,158,opt,name=field18554" json:"field18554,omitempty"`
+	Field18555 *UnusedEmptyMessage   `protobuf:"bytes,159,opt,name=field18555" json:"field18555,omitempty"`
+	Field18556 *bool                 `protobuf:"varint,160,opt,name=field18556" json:"field18556,omitempty"`
+	Field18557 *uint64               `protobuf:"varint,162,opt,name=field18557" json:"field18557,omitempty"`
+	Field18558 *int32                `protobuf:"varint,164,opt,name=field18558" json:"field18558,omitempty"`
+	Field18559 *UnusedEmptyMessage   `protobuf:"bytes,10,opt,name=field18559" json:"field18559,omitempty"`
+	Field18560 *UnusedEmptyMessage   `protobuf:"bytes,167,opt,name=field18560" json:"field18560,omitempty"`
+	Field18561 *int32                `protobuf:"varint,168,opt,name=field18561" json:"field18561,omitempty"`
+	Field18562 []uint64              `protobuf:"fixed64,169,rep,name=field18562" json:"field18562,omitempty"`
+	Field18563 []string              `protobuf:"bytes,170,rep,name=field18563" json:"field18563,omitempty"`
+	Field18564 *UnusedEmptyMessage   `protobuf:"bytes,172,opt,name=field18564" json:"field18564,omitempty"`
+	Field18565 *int64                `protobuf:"varint,173,opt,name=field18565" json:"field18565,omitempty"`
+	Field18566 *UnusedEmptyMessage   `protobuf:"bytes,174,opt,name=field18566" json:"field18566,omitempty"`
+	Field18567 *int64                `protobuf:"varint,175,opt,name=field18567" json:"field18567,omitempty"`
+	Field18568 *uint32               `protobuf:"varint,189,opt,name=field18568" json:"field18568,omitempty"`
+	Field18569 *UnusedEmptyMessage   `protobuf:"bytes,176,opt,name=field18569" json:"field18569,omitempty"`
+	Field18570 *UnusedEmptyMessage   `protobuf:"bytes,177,opt,name=field18570" json:"field18570,omitempty"`
+	Field18571 *uint32               `protobuf:"varint,179,opt,name=field18571" json:"field18571,omitempty"`
+	Field18572 *uint32               `protobuf:"varint,180,opt,name=field18572" json:"field18572,omitempty"`
+	Field18573 *UnusedEmptyMessage   `protobuf:"bytes,182,opt,name=field18573" json:"field18573,omitempty"`
+	Field18574 *UnusedEmptyMessage   `protobuf:"bytes,183,opt,name=field18574" json:"field18574,omitempty"`
+	Field18575 *UnusedEmptyMessage   `protobuf:"bytes,121,opt,name=field18575" json:"field18575,omitempty"`
+	Field18576 *UnusedEmptyMessage   `protobuf:"bytes,186,opt,name=field18576" json:"field18576,omitempty"`
+	Field18577 *UnusedEmptyMessage   `protobuf:"bytes,187,opt,name=field18577" json:"field18577,omitempty"`
+	Field18578 *UnusedEmptyMessage   `protobuf:"bytes,190,opt,name=field18578" json:"field18578,omitempty"`
+	Field18579 *int32                `protobuf:"varint,191,opt,name=field18579" json:"field18579,omitempty"`
+	Field18580 *float32              `protobuf:"fixed32,192,opt,name=field18580" json:"field18580,omitempty"`
+	Field18581 *bool                 `protobuf:"varint,193,opt,name=field18581" json:"field18581,omitempty"`
+}
+
+func (x *Message18283) Reset() {
+	*x = Message18283{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[21]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message18283) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message18283) ProtoMessage() {}
+
+func (x *Message18283) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[21]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message18283.ProtoReflect.Descriptor instead.
+func (*Message18283) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_2_proto_rawDescGZIP(), []int{21}
+}
+
+var extRange_Message18283 = []protoiface.ExtensionRangeV1{
+	{Start: 116, End: 116},
+	{Start: 118, End: 118},
+	{Start: 130, End: 130},
+	{Start: 165, End: 165},
+}
+
+// Deprecated: Use Message18283.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*Message18283) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_Message18283
+}
+
+func (x *Message18283) GetField18478() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18478
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18479() int32 {
+	if x != nil && x.Field18479 != nil {
+		return *x.Field18479
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18480() int32 {
+	if x != nil && x.Field18480 != nil {
+		return *x.Field18480
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18481() int32 {
+	if x != nil && x.Field18481 != nil {
+		return *x.Field18481
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18482() int32 {
+	if x != nil && x.Field18482 != nil {
+		return *x.Field18482
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18483() int32 {
+	if x != nil && x.Field18483 != nil {
+		return *x.Field18483
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18484() int32 {
+	if x != nil && x.Field18484 != nil {
+		return *x.Field18484
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18485() int32 {
+	if x != nil && x.Field18485 != nil {
+		return *x.Field18485
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18486() int32 {
+	if x != nil && x.Field18486 != nil {
+		return *x.Field18486
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18487() int32 {
+	if x != nil && x.Field18487 != nil {
+		return *x.Field18487
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18488() int32 {
+	if x != nil && x.Field18488 != nil {
+		return *x.Field18488
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18489() int32 {
+	if x != nil && x.Field18489 != nil {
+		return *x.Field18489
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18490() int32 {
+	if x != nil && x.Field18490 != nil {
+		return *x.Field18490
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18491() bool {
+	if x != nil && x.Field18491 != nil {
+		return *x.Field18491
+	}
+	return false
+}
+
+func (x *Message18283) GetField18492() bool {
+	if x != nil && x.Field18492 != nil {
+		return *x.Field18492
+	}
+	return false
+}
+
+func (x *Message18283) GetField18493() int32 {
+	if x != nil && x.Field18493 != nil {
+		return *x.Field18493
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18494() int32 {
+	if x != nil && x.Field18494 != nil {
+		return *x.Field18494
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18495() int32 {
+	if x != nil && x.Field18495 != nil {
+		return *x.Field18495
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18496() int32 {
+	if x != nil && x.Field18496 != nil {
+		return *x.Field18496
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18497() float32 {
+	if x != nil && x.Field18497 != nil {
+		return *x.Field18497
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18498() int32 {
+	if x != nil && x.Field18498 != nil {
+		return *x.Field18498
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18499() string {
+	if x != nil && x.Field18499 != nil {
+		return *x.Field18499
+	}
+	return ""
+}
+
+func (x *Message18283) GetField18500() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18500
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18501() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18501
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18502() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18502
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18503() *Message18253 {
+	if x != nil {
+		return x.Field18503
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18504() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18504
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18505() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18505
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18506() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18506
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18507() []int32 {
+	if x != nil {
+		return x.Field18507
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18508() []int32 {
+	if x != nil {
+		return x.Field18508
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18509() []string {
+	if x != nil {
+		return x.Field18509
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18510() []byte {
+	if x != nil {
+		return x.Field18510
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18511() int32 {
+	if x != nil && x.Field18511 != nil {
+		return *x.Field18511
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18512() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18512
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18513() string {
+	if x != nil && x.Field18513 != nil {
+		return *x.Field18513
+	}
+	return ""
+}
+
+func (x *Message18283) GetField18514() float32 {
+	if x != nil && x.Field18514 != nil {
+		return *x.Field18514
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18515() float32 {
+	if x != nil && x.Field18515 != nil {
+		return *x.Field18515
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18516() float32 {
+	if x != nil && x.Field18516 != nil {
+		return *x.Field18516
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18517() float32 {
+	if x != nil && x.Field18517 != nil {
+		return *x.Field18517
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18518() int32 {
+	if x != nil && x.Field18518 != nil {
+		return *x.Field18518
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18519() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18519
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18520() int32 {
+	if x != nil && x.Field18520 != nil {
+		return *x.Field18520
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18521() int32 {
+	if x != nil && x.Field18521 != nil {
+		return *x.Field18521
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18522() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18522
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18523() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18523
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18524() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18524
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18525() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18525
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18526() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18526
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18527() int32 {
+	if x != nil && x.Field18527 != nil {
+		return *x.Field18527
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18528() int32 {
+	if x != nil && x.Field18528 != nil {
+		return *x.Field18528
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18529() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18529
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18530() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18530
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18531() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18531
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18532() uint64 {
+	if x != nil && x.Field18532 != nil {
+		return *x.Field18532
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18533() int32 {
+	if x != nil && x.Field18533 != nil {
+		return *x.Field18533
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18534() int32 {
+	if x != nil && x.Field18534 != nil {
+		return *x.Field18534
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18535() int32 {
+	if x != nil && x.Field18535 != nil {
+		return *x.Field18535
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18536() uint64 {
+	if x != nil && x.Field18536 != nil {
+		return *x.Field18536
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18537() uint64 {
+	if x != nil && x.Field18537 != nil {
+		return *x.Field18537
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18538() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18538
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18539() int32 {
+	if x != nil && x.Field18539 != nil {
+		return *x.Field18539
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18540() int32 {
+	if x != nil && x.Field18540 != nil {
+		return *x.Field18540
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18541() *Message16816 {
+	if x != nil {
+		return x.Field18541
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18542() *Message16685 {
+	if x != nil {
+		return x.Field18542
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18543() int32 {
+	if x != nil && x.Field18543 != nil {
+		return *x.Field18543
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18544() int64 {
+	if x != nil && x.Field18544 != nil {
+		return *x.Field18544
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18545() int64 {
+	if x != nil && x.Field18545 != nil {
+		return *x.Field18545
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18546() int32 {
+	if x != nil && x.Field18546 != nil {
+		return *x.Field18546
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18547() int32 {
+	if x != nil && x.Field18547 != nil {
+		return *x.Field18547
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18548() int32 {
+	if x != nil && x.Field18548 != nil {
+		return *x.Field18548
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18549() float32 {
+	if x != nil && x.Field18549 != nil {
+		return *x.Field18549
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18550() *Message0 {
+	if x != nil {
+		return x.Field18550
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18551() []int64 {
+	if x != nil {
+		return x.Field18551
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18552() int32 {
+	if x != nil && x.Field18552 != nil {
+		return *x.Field18552
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18553() []uint64 {
+	if x != nil {
+		return x.Field18553
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18554() int32 {
+	if x != nil && x.Field18554 != nil {
+		return *x.Field18554
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18555() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18555
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18556() bool {
+	if x != nil && x.Field18556 != nil {
+		return *x.Field18556
+	}
+	return false
+}
+
+func (x *Message18283) GetField18557() uint64 {
+	if x != nil && x.Field18557 != nil {
+		return *x.Field18557
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18558() int32 {
+	if x != nil && x.Field18558 != nil {
+		return *x.Field18558
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18559() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18559
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18560() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18560
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18561() int32 {
+	if x != nil && x.Field18561 != nil {
+		return *x.Field18561
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18562() []uint64 {
+	if x != nil {
+		return x.Field18562
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18563() []string {
+	if x != nil {
+		return x.Field18563
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18564() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18564
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18565() int64 {
+	if x != nil && x.Field18565 != nil {
+		return *x.Field18565
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18566() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18566
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18567() int64 {
+	if x != nil && x.Field18567 != nil {
+		return *x.Field18567
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18568() uint32 {
+	if x != nil && x.Field18568 != nil {
+		return *x.Field18568
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18569() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18569
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18570() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18570
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18571() uint32 {
+	if x != nil && x.Field18571 != nil {
+		return *x.Field18571
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18572() uint32 {
+	if x != nil && x.Field18572 != nil {
+		return *x.Field18572
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18573() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18573
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18574() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18574
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18575() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18575
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18576() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18576
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18577() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18577
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18578() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18578
+	}
+	return nil
+}
+
+func (x *Message18283) GetField18579() int32 {
+	if x != nil && x.Field18579 != nil {
+		return *x.Field18579
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18580() float32 {
+	if x != nil && x.Field18580 != nil {
+		return *x.Field18580
+	}
+	return 0
+}
+
+func (x *Message18283) GetField18581() bool {
+	if x != nil && x.Field18581 != nil {
+		return *x.Field18581
+	}
+	return false
+}
+
+type Message13169 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field13223 []*Message13168 `protobuf:"bytes,1,rep,name=field13223" json:"field13223,omitempty"`
+	Field13224 *Message13167   `protobuf:"bytes,2,req,name=field13224" json:"field13224,omitempty"`
+	Field13225 *string         `protobuf:"bytes,3,opt,name=field13225" json:"field13225,omitempty"`
+}
+
+func (x *Message13169) Reset() {
+	*x = Message13169{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[22]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message13169) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message13169) ProtoMessage() {}
+
+func (x *Message13169) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[22]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message13169.ProtoReflect.Descriptor instead.
+func (*Message13169) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_2_proto_rawDescGZIP(), []int{22}
+}
+
+func (x *Message13169) GetField13223() []*Message13168 {
+	if x != nil {
+		return x.Field13223
+	}
+	return nil
+}
+
+func (x *Message13169) GetField13224() *Message13167 {
+	if x != nil {
+		return x.Field13224
+	}
+	return nil
+}
+
+func (x *Message13169) GetField13225() string {
+	if x != nil && x.Field13225 != nil {
+		return *x.Field13225
+	}
+	return ""
+}
+
+type Message19255 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field19257 *string `protobuf:"bytes,1,opt,name=field19257" json:"field19257,omitempty"`
+}
+
+func (x *Message19255) Reset() {
+	*x = Message19255{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[23]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message19255) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message19255) ProtoMessage() {}
+
+func (x *Message19255) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[23]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message19255.ProtoReflect.Descriptor instead.
+func (*Message19255) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_2_proto_rawDescGZIP(), []int{23}
+}
+
+func (x *Message19255) GetField19257() string {
+	if x != nil && x.Field19257 != nil {
+		return *x.Field19257
+	}
+	return ""
+}
+
+type Message35542 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field35543 *bool `protobuf:"varint,1,opt,name=field35543" json:"field35543,omitempty"`
+	Field35544 *bool `protobuf:"varint,2,opt,name=field35544" json:"field35544,omitempty"`
+	Field35545 *bool `protobuf:"varint,3,opt,name=field35545" json:"field35545,omitempty"`
+}
+
+func (x *Message35542) Reset() {
+	*x = Message35542{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[24]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message35542) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message35542) ProtoMessage() {}
+
+func (x *Message35542) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[24]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message35542.ProtoReflect.Descriptor instead.
+func (*Message35542) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_2_proto_rawDescGZIP(), []int{24}
+}
+
+func (x *Message35542) GetField35543() bool {
+	if x != nil && x.Field35543 != nil {
+		return *x.Field35543
+	}
+	return false
+}
+
+func (x *Message35542) GetField35544() bool {
+	if x != nil && x.Field35544 != nil {
+		return *x.Field35544
+	}
+	return false
+}
+
+func (x *Message35542) GetField35545() bool {
+	if x != nil && x.Field35545 != nil {
+		return *x.Field35545
+	}
+	return false
+}
+
+type Message3901 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field3990 *int32      `protobuf:"varint,1,opt,name=field3990" json:"field3990,omitempty"`
+	Field3991 *int32      `protobuf:"varint,2,opt,name=field3991" json:"field3991,omitempty"`
+	Field3992 *int32      `protobuf:"varint,3,opt,name=field3992" json:"field3992,omitempty"`
+	Field3993 *int32      `protobuf:"varint,4,opt,name=field3993" json:"field3993,omitempty"`
+	Field3994 *int32      `protobuf:"varint,7,opt,name=field3994" json:"field3994,omitempty"`
+	Field3995 *int32      `protobuf:"varint,8,opt,name=field3995" json:"field3995,omitempty"`
+	Field3996 *int32      `protobuf:"varint,9,opt,name=field3996" json:"field3996,omitempty"`
+	Field3997 *int32      `protobuf:"varint,10,opt,name=field3997" json:"field3997,omitempty"`
+	Field3998 *int32      `protobuf:"varint,11,opt,name=field3998" json:"field3998,omitempty"`
+	Field3999 *int32      `protobuf:"varint,12,opt,name=field3999" json:"field3999,omitempty"`
+	Field4000 *UnusedEnum `protobuf:"varint,6,opt,name=field4000,enum=benchmarks.google_message3.UnusedEnum" json:"field4000,omitempty"`
+	Field4001 *int32      `protobuf:"varint,5,opt,name=field4001" json:"field4001,omitempty"`
+}
+
+func (x *Message3901) Reset() {
+	*x = Message3901{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[25]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message3901) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message3901) ProtoMessage() {}
+
+func (x *Message3901) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[25]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message3901.ProtoReflect.Descriptor instead.
+func (*Message3901) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_2_proto_rawDescGZIP(), []int{25}
+}
+
+func (x *Message3901) GetField3990() int32 {
+	if x != nil && x.Field3990 != nil {
+		return *x.Field3990
+	}
+	return 0
+}
+
+func (x *Message3901) GetField3991() int32 {
+	if x != nil && x.Field3991 != nil {
+		return *x.Field3991
+	}
+	return 0
+}
+
+func (x *Message3901) GetField3992() int32 {
+	if x != nil && x.Field3992 != nil {
+		return *x.Field3992
+	}
+	return 0
+}
+
+func (x *Message3901) GetField3993() int32 {
+	if x != nil && x.Field3993 != nil {
+		return *x.Field3993
+	}
+	return 0
+}
+
+func (x *Message3901) GetField3994() int32 {
+	if x != nil && x.Field3994 != nil {
+		return *x.Field3994
+	}
+	return 0
+}
+
+func (x *Message3901) GetField3995() int32 {
+	if x != nil && x.Field3995 != nil {
+		return *x.Field3995
+	}
+	return 0
+}
+
+func (x *Message3901) GetField3996() int32 {
+	if x != nil && x.Field3996 != nil {
+		return *x.Field3996
+	}
+	return 0
+}
+
+func (x *Message3901) GetField3997() int32 {
+	if x != nil && x.Field3997 != nil {
+		return *x.Field3997
+	}
+	return 0
+}
+
+func (x *Message3901) GetField3998() int32 {
+	if x != nil && x.Field3998 != nil {
+		return *x.Field3998
+	}
+	return 0
+}
+
+func (x *Message3901) GetField3999() int32 {
+	if x != nil && x.Field3999 != nil {
+		return *x.Field3999
+	}
+	return 0
+}
+
+func (x *Message3901) GetField4000() UnusedEnum {
+	if x != nil && x.Field4000 != nil {
+		return *x.Field4000
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+func (x *Message3901) GetField4001() int32 {
+	if x != nil && x.Field4001 != nil {
+		return *x.Field4001
+	}
+	return 0
+}
+
+type Message33968_Message33969 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message33968_Message33969) Reset() {
+	*x = Message33968_Message33969{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[26]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message33968_Message33969) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message33968_Message33969) ProtoMessage() {}
+
+func (x *Message33968_Message33969) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[26]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message33968_Message33969.ProtoReflect.Descriptor instead.
+func (*Message33968_Message33969) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_2_proto_rawDescGZIP(), []int{12, 0}
+}
+
+type Message18831_Message18832 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field18836   *int32                                    `protobuf:"varint,2,opt,name=field18836" json:"field18836,omitempty"`
+	Field18837   *string                                   `protobuf:"bytes,5,opt,name=field18837" json:"field18837,omitempty"`
+	Field18838   *float32                                  `protobuf:"fixed32,3,opt,name=field18838" json:"field18838,omitempty"`
+	Field18839   *float32                                  `protobuf:"fixed32,9,opt,name=field18839" json:"field18839,omitempty"`
+	Field18840   *int32                                    `protobuf:"varint,11,opt,name=field18840" json:"field18840,omitempty"`
+	Field18841   []uint64                                  `protobuf:"varint,4,rep,name=field18841" json:"field18841,omitempty"`
+	Message18833 []*Message18831_Message18832_Message18833 `protobuf:"group,6,rep,name=Message18833,json=message18833" json:"message18833,omitempty"`
+}
+
+func (x *Message18831_Message18832) Reset() {
+	*x = Message18831_Message18832{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[27]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message18831_Message18832) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message18831_Message18832) ProtoMessage() {}
+
+func (x *Message18831_Message18832) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[27]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message18831_Message18832.ProtoReflect.Descriptor instead.
+func (*Message18831_Message18832) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_2_proto_rawDescGZIP(), []int{14, 0}
+}
+
+func (x *Message18831_Message18832) GetField18836() int32 {
+	if x != nil && x.Field18836 != nil {
+		return *x.Field18836
+	}
+	return 0
+}
+
+func (x *Message18831_Message18832) GetField18837() string {
+	if x != nil && x.Field18837 != nil {
+		return *x.Field18837
+	}
+	return ""
+}
+
+func (x *Message18831_Message18832) GetField18838() float32 {
+	if x != nil && x.Field18838 != nil {
+		return *x.Field18838
+	}
+	return 0
+}
+
+func (x *Message18831_Message18832) GetField18839() float32 {
+	if x != nil && x.Field18839 != nil {
+		return *x.Field18839
+	}
+	return 0
+}
+
+func (x *Message18831_Message18832) GetField18840() int32 {
+	if x != nil && x.Field18840 != nil {
+		return *x.Field18840
+	}
+	return 0
+}
+
+func (x *Message18831_Message18832) GetField18841() []uint64 {
+	if x != nil {
+		return x.Field18841
+	}
+	return nil
+}
+
+func (x *Message18831_Message18832) GetMessage18833() []*Message18831_Message18832_Message18833 {
+	if x != nil {
+		return x.Message18833
+	}
+	return nil
+}
+
+type Message18831_Message18832_Message18833 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field18843 *uint64  `protobuf:"varint,7,req,name=field18843" json:"field18843,omitempty"`
+	Field18844 *string  `protobuf:"bytes,8,opt,name=field18844" json:"field18844,omitempty"`
+	Field18845 *float32 `protobuf:"fixed32,10,opt,name=field18845" json:"field18845,omitempty"`
+	Field18846 *int32   `protobuf:"varint,12,opt,name=field18846" json:"field18846,omitempty"`
+	Field18847 *bool    `protobuf:"varint,13,opt,name=field18847" json:"field18847,omitempty"`
+}
+
+func (x *Message18831_Message18832_Message18833) Reset() {
+	*x = Message18831_Message18832_Message18833{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[28]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message18831_Message18832_Message18833) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message18831_Message18832_Message18833) ProtoMessage() {}
+
+func (x *Message18831_Message18832_Message18833) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[28]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message18831_Message18832_Message18833.ProtoReflect.Descriptor instead.
+func (*Message18831_Message18832_Message18833) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_2_proto_rawDescGZIP(), []int{14, 0, 0}
+}
+
+func (x *Message18831_Message18832_Message18833) GetField18843() uint64 {
+	if x != nil && x.Field18843 != nil {
+		return *x.Field18843
+	}
+	return 0
+}
+
+func (x *Message18831_Message18832_Message18833) GetField18844() string {
+	if x != nil && x.Field18844 != nil {
+		return *x.Field18844
+	}
+	return ""
+}
+
+func (x *Message18831_Message18832_Message18833) GetField18845() float32 {
+	if x != nil && x.Field18845 != nil {
+		return *x.Field18845
+	}
+	return 0
+}
+
+func (x *Message18831_Message18832_Message18833) GetField18846() int32 {
+	if x != nil && x.Field18846 != nil {
+		return *x.Field18846
+	}
+	return 0
+}
+
+func (x *Message18831_Message18832_Message18833) GetField18847() bool {
+	if x != nil && x.Field18847 != nil {
+		return *x.Field18847
+	}
+	return false
+}
+
+type Message4144_Message4145 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field4165 *Enum4146 `protobuf:"varint,2,req,name=field4165,enum=benchmarks.google_message3.Enum4146" json:"field4165,omitempty"`
+	Field4166 *int32    `protobuf:"varint,3,req,name=field4166" json:"field4166,omitempty"`
+	Field4167 *Enum4160 `protobuf:"varint,9,opt,name=field4167,enum=benchmarks.google_message3.Enum4160" json:"field4167,omitempty"`
+	Field4168 []byte    `protobuf:"bytes,4,opt,name=field4168" json:"field4168,omitempty"`
+	Field4169 *Enum4152 `protobuf:"varint,5,opt,name=field4169,enum=benchmarks.google_message3.Enum4152" json:"field4169,omitempty"`
+	Field4170 *string   `protobuf:"bytes,6,opt,name=field4170" json:"field4170,omitempty"`
+}
+
+func (x *Message4144_Message4145) Reset() {
+	*x = Message4144_Message4145{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[29]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message4144_Message4145) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message4144_Message4145) ProtoMessage() {}
+
+func (x *Message4144_Message4145) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[29]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message4144_Message4145.ProtoReflect.Descriptor instead.
+func (*Message4144_Message4145) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_2_proto_rawDescGZIP(), []int{17, 0}
+}
+
+func (x *Message4144_Message4145) GetField4165() Enum4146 {
+	if x != nil && x.Field4165 != nil {
+		return *x.Field4165
+	}
+	return Enum4146_ENUM_VALUE4147
+}
+
+func (x *Message4144_Message4145) GetField4166() int32 {
+	if x != nil && x.Field4166 != nil {
+		return *x.Field4166
+	}
+	return 0
+}
+
+func (x *Message4144_Message4145) GetField4167() Enum4160 {
+	if x != nil && x.Field4167 != nil {
+		return *x.Field4167
+	}
+	return Enum4160_ENUM_VALUE4161
+}
+
+func (x *Message4144_Message4145) GetField4168() []byte {
+	if x != nil {
+		return x.Field4168
+	}
+	return nil
+}
+
+func (x *Message4144_Message4145) GetField4169() Enum4152 {
+	if x != nil && x.Field4169 != nil {
+		return *x.Field4169
+	}
+	return Enum4152_ENUM_VALUE4153
+}
+
+func (x *Message4144_Message4145) GetField4170() string {
+	if x != nil && x.Field4170 != nil {
+		return *x.Field4170
+	}
+	return ""
+}
+
+type Message35573_Message35574 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message35573_Message35574) Reset() {
+	*x = Message35573_Message35574{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[30]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message35573_Message35574) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message35573_Message35574) ProtoMessage() {}
+
+func (x *Message35573_Message35574) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[30]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message35573_Message35574.ProtoReflect.Descriptor instead.
+func (*Message35573_Message35574) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_2_proto_rawDescGZIP(), []int{18, 0}
+}
+
+type Message35573_Message35575 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field35709   *int64                                  `protobuf:"varint,2,opt,name=field35709" json:"field35709,omitempty"`
+	Field35710   *string                                 `protobuf:"bytes,3,opt,name=field35710" json:"field35710,omitempty"`
+	Field35711   *string                                 `protobuf:"bytes,19,opt,name=field35711" json:"field35711,omitempty"`
+	Field35712   *int32                                  `protobuf:"varint,20,opt,name=field35712" json:"field35712,omitempty"`
+	Field35713   *int32                                  `protobuf:"varint,21,opt,name=field35713" json:"field35713,omitempty"`
+	Field35714   *int32                                  `protobuf:"varint,22,opt,name=field35714" json:"field35714,omitempty"`
+	Field35715   *bool                                   `protobuf:"varint,23,opt,name=field35715" json:"field35715,omitempty"`
+	Field35716   *int32                                  `protobuf:"varint,47,opt,name=field35716" json:"field35716,omitempty"`
+	Field35717   *int32                                  `protobuf:"varint,48,opt,name=field35717" json:"field35717,omitempty"`
+	Field35718   *bool                                   `protobuf:"varint,24,opt,name=field35718" json:"field35718,omitempty"`
+	Field35719   *uint64                                 `protobuf:"fixed64,25,opt,name=field35719" json:"field35719,omitempty"`
+	Field35720   []byte                                  `protobuf:"bytes,52,opt,name=field35720" json:"field35720,omitempty"`
+	Field35721   *int32                                  `protobuf:"varint,18,opt,name=field35721" json:"field35721,omitempty"`
+	Field35722   *uint32                                 `protobuf:"fixed32,43,opt,name=field35722" json:"field35722,omitempty"`
+	Field35723   *bool                                   `protobuf:"varint,26,opt,name=field35723" json:"field35723,omitempty"`
+	Field35724   *int32                                  `protobuf:"varint,27,opt,name=field35724" json:"field35724,omitempty"`
+	Field35725   *int32                                  `protobuf:"varint,17,opt,name=field35725" json:"field35725,omitempty"`
+	Field35726   *bool                                   `protobuf:"varint,45,opt,name=field35726" json:"field35726,omitempty"`
+	Field35727   []int32                                 `protobuf:"varint,33,rep,name=field35727" json:"field35727,omitempty"`
+	Field35728   []int32                                 `protobuf:"varint,58,rep,name=field35728" json:"field35728,omitempty"`
+	Field35729   *float32                                `protobuf:"fixed32,34,opt,name=field35729" json:"field35729,omitempty"`
+	Field35730   *float32                                `protobuf:"fixed32,1009,opt,name=field35730" json:"field35730,omitempty"`
+	Field35731   *int32                                  `protobuf:"varint,28,opt,name=field35731" json:"field35731,omitempty"`
+	Field35732   []uint64                                `protobuf:"fixed64,1001,rep,name=field35732" json:"field35732,omitempty"`
+	Field35733   []uint64                                `protobuf:"fixed64,1002,rep,name=field35733" json:"field35733,omitempty"`
+	Field35734   *int32                                  `protobuf:"varint,44,opt,name=field35734" json:"field35734,omitempty"`
+	Field35735   *int32                                  `protobuf:"varint,50,opt,name=field35735" json:"field35735,omitempty"`
+	Field35736   *int32                                  `protobuf:"varint,36,opt,name=field35736" json:"field35736,omitempty"`
+	Field35737   *int32                                  `protobuf:"varint,40,opt,name=field35737" json:"field35737,omitempty"`
+	Field35738   *bool                                   `protobuf:"varint,1016,opt,name=field35738" json:"field35738,omitempty"`
+	Field35739   *bool                                   `protobuf:"varint,1010,opt,name=field35739" json:"field35739,omitempty"`
+	Field35740   *int32                                  `protobuf:"varint,37,opt,name=field35740" json:"field35740,omitempty"`
+	Field35741   *int32                                  `protobuf:"varint,38,opt,name=field35741" json:"field35741,omitempty"`
+	Field35742   *string                                 `protobuf:"bytes,46,opt,name=field35742" json:"field35742,omitempty"`
+	Field35743   *uint32                                 `protobuf:"varint,60,opt,name=field35743" json:"field35743,omitempty"`
+	Field35744   [][]byte                                `protobuf:"bytes,56,rep,name=field35744" json:"field35744,omitempty"`
+	Field35745   *Message0                               `protobuf:"bytes,57,opt,name=field35745" json:"field35745,omitempty"`
+	Message35576 *Message35573_Message35575_Message35576 `protobuf:"group,4,req,name=Message35576,json=message35576" json:"message35576,omitempty"`
+}
+
+func (x *Message35573_Message35575) Reset() {
+	*x = Message35573_Message35575{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[31]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message35573_Message35575) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message35573_Message35575) ProtoMessage() {}
+
+func (x *Message35573_Message35575) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[31]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message35573_Message35575.ProtoReflect.Descriptor instead.
+func (*Message35573_Message35575) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_2_proto_rawDescGZIP(), []int{18, 1}
+}
+
+func (x *Message35573_Message35575) GetField35709() int64 {
+	if x != nil && x.Field35709 != nil {
+		return *x.Field35709
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575) GetField35710() string {
+	if x != nil && x.Field35710 != nil {
+		return *x.Field35710
+	}
+	return ""
+}
+
+func (x *Message35573_Message35575) GetField35711() string {
+	if x != nil && x.Field35711 != nil {
+		return *x.Field35711
+	}
+	return ""
+}
+
+func (x *Message35573_Message35575) GetField35712() int32 {
+	if x != nil && x.Field35712 != nil {
+		return *x.Field35712
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575) GetField35713() int32 {
+	if x != nil && x.Field35713 != nil {
+		return *x.Field35713
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575) GetField35714() int32 {
+	if x != nil && x.Field35714 != nil {
+		return *x.Field35714
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575) GetField35715() bool {
+	if x != nil && x.Field35715 != nil {
+		return *x.Field35715
+	}
+	return false
+}
+
+func (x *Message35573_Message35575) GetField35716() int32 {
+	if x != nil && x.Field35716 != nil {
+		return *x.Field35716
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575) GetField35717() int32 {
+	if x != nil && x.Field35717 != nil {
+		return *x.Field35717
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575) GetField35718() bool {
+	if x != nil && x.Field35718 != nil {
+		return *x.Field35718
+	}
+	return false
+}
+
+func (x *Message35573_Message35575) GetField35719() uint64 {
+	if x != nil && x.Field35719 != nil {
+		return *x.Field35719
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575) GetField35720() []byte {
+	if x != nil {
+		return x.Field35720
+	}
+	return nil
+}
+
+func (x *Message35573_Message35575) GetField35721() int32 {
+	if x != nil && x.Field35721 != nil {
+		return *x.Field35721
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575) GetField35722() uint32 {
+	if x != nil && x.Field35722 != nil {
+		return *x.Field35722
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575) GetField35723() bool {
+	if x != nil && x.Field35723 != nil {
+		return *x.Field35723
+	}
+	return false
+}
+
+func (x *Message35573_Message35575) GetField35724() int32 {
+	if x != nil && x.Field35724 != nil {
+		return *x.Field35724
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575) GetField35725() int32 {
+	if x != nil && x.Field35725 != nil {
+		return *x.Field35725
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575) GetField35726() bool {
+	if x != nil && x.Field35726 != nil {
+		return *x.Field35726
+	}
+	return false
+}
+
+func (x *Message35573_Message35575) GetField35727() []int32 {
+	if x != nil {
+		return x.Field35727
+	}
+	return nil
+}
+
+func (x *Message35573_Message35575) GetField35728() []int32 {
+	if x != nil {
+		return x.Field35728
+	}
+	return nil
+}
+
+func (x *Message35573_Message35575) GetField35729() float32 {
+	if x != nil && x.Field35729 != nil {
+		return *x.Field35729
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575) GetField35730() float32 {
+	if x != nil && x.Field35730 != nil {
+		return *x.Field35730
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575) GetField35731() int32 {
+	if x != nil && x.Field35731 != nil {
+		return *x.Field35731
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575) GetField35732() []uint64 {
+	if x != nil {
+		return x.Field35732
+	}
+	return nil
+}
+
+func (x *Message35573_Message35575) GetField35733() []uint64 {
+	if x != nil {
+		return x.Field35733
+	}
+	return nil
+}
+
+func (x *Message35573_Message35575) GetField35734() int32 {
+	if x != nil && x.Field35734 != nil {
+		return *x.Field35734
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575) GetField35735() int32 {
+	if x != nil && x.Field35735 != nil {
+		return *x.Field35735
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575) GetField35736() int32 {
+	if x != nil && x.Field35736 != nil {
+		return *x.Field35736
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575) GetField35737() int32 {
+	if x != nil && x.Field35737 != nil {
+		return *x.Field35737
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575) GetField35738() bool {
+	if x != nil && x.Field35738 != nil {
+		return *x.Field35738
+	}
+	return false
+}
+
+func (x *Message35573_Message35575) GetField35739() bool {
+	if x != nil && x.Field35739 != nil {
+		return *x.Field35739
+	}
+	return false
+}
+
+func (x *Message35573_Message35575) GetField35740() int32 {
+	if x != nil && x.Field35740 != nil {
+		return *x.Field35740
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575) GetField35741() int32 {
+	if x != nil && x.Field35741 != nil {
+		return *x.Field35741
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575) GetField35742() string {
+	if x != nil && x.Field35742 != nil {
+		return *x.Field35742
+	}
+	return ""
+}
+
+func (x *Message35573_Message35575) GetField35743() uint32 {
+	if x != nil && x.Field35743 != nil {
+		return *x.Field35743
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575) GetField35744() [][]byte {
+	if x != nil {
+		return x.Field35744
+	}
+	return nil
+}
+
+func (x *Message35573_Message35575) GetField35745() *Message0 {
+	if x != nil {
+		return x.Field35745
+	}
+	return nil
+}
+
+func (x *Message35573_Message35575) GetMessage35576() *Message35573_Message35575_Message35576 {
+	if x != nil {
+		return x.Message35576
+	}
+	return nil
+}
+
+type Message35573_Message35575_Message35576 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field35747 *uint64   `protobuf:"fixed64,5,opt,name=field35747" json:"field35747,omitempty"`
+	Field35748 *int32    `protobuf:"varint,6,opt,name=field35748" json:"field35748,omitempty"`
+	Field35749 *int32    `protobuf:"varint,49,opt,name=field35749" json:"field35749,omitempty"`
+	Field35750 *int32    `protobuf:"varint,7,opt,name=field35750" json:"field35750,omitempty"`
+	Field35751 *uint32   `protobuf:"varint,59,opt,name=field35751" json:"field35751,omitempty"`
+	Field35752 *int32    `protobuf:"varint,14,opt,name=field35752" json:"field35752,omitempty"`
+	Field35753 *int32    `protobuf:"varint,15,opt,name=field35753" json:"field35753,omitempty"`
+	Field35754 *int32    `protobuf:"varint,35,opt,name=field35754" json:"field35754,omitempty"`
+	Field35755 []byte    `protobuf:"bytes,53,opt,name=field35755" json:"field35755,omitempty"`
+	Field35756 *int32    `protobuf:"varint,8,opt,name=field35756" json:"field35756,omitempty"`
+	Field35757 *string   `protobuf:"bytes,9,opt,name=field35757" json:"field35757,omitempty"`
+	Field35758 *uint64   `protobuf:"fixed64,10,opt,name=field35758" json:"field35758,omitempty"`
+	Field35759 *int32    `protobuf:"varint,11,opt,name=field35759" json:"field35759,omitempty"`
+	Field35760 *int32    `protobuf:"varint,12,opt,name=field35760" json:"field35760,omitempty"`
+	Field35761 *int32    `protobuf:"varint,41,opt,name=field35761" json:"field35761,omitempty"`
+	Field35762 *int32    `protobuf:"varint,30,opt,name=field35762" json:"field35762,omitempty"`
+	Field35763 *int32    `protobuf:"varint,31,opt,name=field35763" json:"field35763,omitempty"`
+	Field35764 *int32    `protobuf:"varint,13,opt,name=field35764" json:"field35764,omitempty"`
+	Field35765 []byte    `protobuf:"bytes,39,opt,name=field35765" json:"field35765,omitempty"`
+	Field35766 *string   `protobuf:"bytes,29,opt,name=field35766" json:"field35766,omitempty"`
+	Field35767 *int32    `protobuf:"varint,42,opt,name=field35767" json:"field35767,omitempty"`
+	Field35768 []int32   `protobuf:"varint,32,rep,name=field35768" json:"field35768,omitempty"`
+	Field35769 []int32   `protobuf:"varint,51,rep,name=field35769" json:"field35769,omitempty"`
+	Field35770 *int64    `protobuf:"varint,54,opt,name=field35770" json:"field35770,omitempty"`
+	Field35771 *Message0 `protobuf:"bytes,55,opt,name=field35771" json:"field35771,omitempty"`
+}
+
+func (x *Message35573_Message35575_Message35576) Reset() {
+	*x = Message35573_Message35575_Message35576{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[32]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message35573_Message35575_Message35576) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message35573_Message35575_Message35576) ProtoMessage() {}
+
+func (x *Message35573_Message35575_Message35576) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[32]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message35573_Message35575_Message35576.ProtoReflect.Descriptor instead.
+func (*Message35573_Message35575_Message35576) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_2_proto_rawDescGZIP(), []int{18, 1, 0}
+}
+
+func (x *Message35573_Message35575_Message35576) GetField35747() uint64 {
+	if x != nil && x.Field35747 != nil {
+		return *x.Field35747
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575_Message35576) GetField35748() int32 {
+	if x != nil && x.Field35748 != nil {
+		return *x.Field35748
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575_Message35576) GetField35749() int32 {
+	if x != nil && x.Field35749 != nil {
+		return *x.Field35749
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575_Message35576) GetField35750() int32 {
+	if x != nil && x.Field35750 != nil {
+		return *x.Field35750
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575_Message35576) GetField35751() uint32 {
+	if x != nil && x.Field35751 != nil {
+		return *x.Field35751
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575_Message35576) GetField35752() int32 {
+	if x != nil && x.Field35752 != nil {
+		return *x.Field35752
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575_Message35576) GetField35753() int32 {
+	if x != nil && x.Field35753 != nil {
+		return *x.Field35753
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575_Message35576) GetField35754() int32 {
+	if x != nil && x.Field35754 != nil {
+		return *x.Field35754
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575_Message35576) GetField35755() []byte {
+	if x != nil {
+		return x.Field35755
+	}
+	return nil
+}
+
+func (x *Message35573_Message35575_Message35576) GetField35756() int32 {
+	if x != nil && x.Field35756 != nil {
+		return *x.Field35756
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575_Message35576) GetField35757() string {
+	if x != nil && x.Field35757 != nil {
+		return *x.Field35757
+	}
+	return ""
+}
+
+func (x *Message35573_Message35575_Message35576) GetField35758() uint64 {
+	if x != nil && x.Field35758 != nil {
+		return *x.Field35758
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575_Message35576) GetField35759() int32 {
+	if x != nil && x.Field35759 != nil {
+		return *x.Field35759
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575_Message35576) GetField35760() int32 {
+	if x != nil && x.Field35760 != nil {
+		return *x.Field35760
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575_Message35576) GetField35761() int32 {
+	if x != nil && x.Field35761 != nil {
+		return *x.Field35761
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575_Message35576) GetField35762() int32 {
+	if x != nil && x.Field35762 != nil {
+		return *x.Field35762
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575_Message35576) GetField35763() int32 {
+	if x != nil && x.Field35763 != nil {
+		return *x.Field35763
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575_Message35576) GetField35764() int32 {
+	if x != nil && x.Field35764 != nil {
+		return *x.Field35764
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575_Message35576) GetField35765() []byte {
+	if x != nil {
+		return x.Field35765
+	}
+	return nil
+}
+
+func (x *Message35573_Message35575_Message35576) GetField35766() string {
+	if x != nil && x.Field35766 != nil {
+		return *x.Field35766
+	}
+	return ""
+}
+
+func (x *Message35573_Message35575_Message35576) GetField35767() int32 {
+	if x != nil && x.Field35767 != nil {
+		return *x.Field35767
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575_Message35576) GetField35768() []int32 {
+	if x != nil {
+		return x.Field35768
+	}
+	return nil
+}
+
+func (x *Message35573_Message35575_Message35576) GetField35769() []int32 {
+	if x != nil {
+		return x.Field35769
+	}
+	return nil
+}
+
+func (x *Message35573_Message35575_Message35576) GetField35770() int64 {
+	if x != nil && x.Field35770 != nil {
+		return *x.Field35770
+	}
+	return 0
+}
+
+func (x *Message35573_Message35575_Message35576) GetField35771() *Message0 {
+	if x != nil {
+		return x.Field35771
+	}
+	return nil
+}
+
+type Message36858_Message36859 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field36968 *Enum36860 `protobuf:"varint,9,req,name=field36968,enum=benchmarks.google_message3.Enum36860" json:"field36968,omitempty"`
+	Field36969 *float32   `protobuf:"fixed32,10,opt,name=field36969" json:"field36969,omitempty"`
+}
+
+func (x *Message36858_Message36859) Reset() {
+	*x = Message36858_Message36859{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[33]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message36858_Message36859) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message36858_Message36859) ProtoMessage() {}
+
+func (x *Message36858_Message36859) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[33]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message36858_Message36859.ProtoReflect.Descriptor instead.
+func (*Message36858_Message36859) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_2_proto_rawDescGZIP(), []int{19, 0}
+}
+
+func (x *Message36858_Message36859) GetField36968() Enum36860 {
+	if x != nil && x.Field36968 != nil {
+		return *x.Field36968
+	}
+	return Enum36860_ENUM_VALUE36861
+}
+
+func (x *Message36858_Message36859) GetField36969() float32 {
+	if x != nil && x.Field36969 != nil {
+		return *x.Field36969
+	}
+	return 0
+}
+
+var file_datasets_google_message3_benchmark_message3_2_proto_extTypes = []protoimpl.ExtensionInfo{
+	{
+		ExtendedType:  (*Message0)(nil),
+		ExtensionType: (*Message34621)(nil),
+		Field:         17562023,
+		Name:          "benchmarks.google_message3.Message34621.field34669",
+		Tag:           "bytes,17562023,opt,name=field34669",
+		Filename:      "datasets/google_message3/benchmark_message3_2.proto",
+	},
+}
+
+// Extension fields to Message0.
+var (
+	// optional benchmarks.google_message3.Message34621 field34669 = 17562023;
+	E_Message34621_Field34669 = &file_datasets_google_message3_benchmark_message3_2_proto_extTypes[0]
+)
+
+var File_datasets_google_message3_benchmark_message3_2_proto protoreflect.FileDescriptor
+
+var file_datasets_google_message3_benchmark_message3_2_proto_rawDesc = []byte{
+	0x0a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x5f, 0x32, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1a, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x1a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2f, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x5f, 0x33,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73,
+	0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x5f, 0x34, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x33, 0x64, 0x61, 0x74,
+	0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x5f, 0x35, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x1a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x5f, 0x37, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2f,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x5f, 0x38, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x91, 0x02, 0x0a, 0x0c, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x32, 0x38, 0x35, 0x33, 0x12, 0x45, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x32, 0x38, 0x36, 0x39, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32,
+	0x25, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75,
+	0x6d, 0x32, 0x32, 0x38, 0x35, 0x34, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x32, 0x38,
+	0x36, 0x39, 0x12, 0x22, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x32, 0x38, 0x37, 0x30,
+	0x18, 0x02, 0x20, 0x03, 0x28, 0x0d, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x32, 0x38, 0x37, 0x30, 0x12, 0x22, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x32, 0x38, 0x37, 0x31, 0x18, 0x03, 0x20, 0x03, 0x28, 0x02, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x32, 0x38, 0x37, 0x31, 0x12, 0x22, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x32, 0x38, 0x37, 0x32, 0x18, 0x05, 0x20, 0x03, 0x28, 0x02, 0x42, 0x02,
+	0x10, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x32, 0x38, 0x37, 0x32, 0x12, 0x4e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x32, 0x38, 0x37, 0x33, 0x18, 0x04, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x32, 0x38, 0x37, 0x33, 0x22, 0xda,
+	0x09, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x33, 0x34, 0x35, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x33, 0x33, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x33, 0x33, 0x12,
+	0x46, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x33, 0x34, 0x18, 0x16, 0x20,
+	0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x32, 0x34, 0x35, 0x33, 0x34, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x34, 0x35, 0x33, 0x35, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x32, 0x34, 0x33, 0x34, 0x36, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x33,
+	0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x33, 0x36, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x33,
+	0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x33, 0x37, 0x18,
+	0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x33,
+	0x37, 0x12, 0x46, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x33, 0x38, 0x18,
+	0x17, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x33, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x32, 0x34, 0x35, 0x33, 0x39, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x33, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x32, 0x34, 0x35, 0x34, 0x30, 0x18, 0x06, 0x20, 0x02, 0x28, 0x09, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x34, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x32, 0x34, 0x35, 0x34, 0x31, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x34, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x32, 0x34, 0x35, 0x34, 0x32, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x34, 0x32, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x32, 0x34, 0x35, 0x34, 0x33, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x32, 0x34, 0x33, 0x31, 0x36, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34,
+	0x35, 0x34, 0x33, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x34,
+	0x34, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x33, 0x37,
+	0x36, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x34, 0x34, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x34, 0x35, 0x18, 0x0b, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x34, 0x35, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x34, 0x36, 0x18, 0x13, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x34, 0x36, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x34, 0x37, 0x18, 0x14, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x34, 0x37, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x34, 0x38, 0x18, 0x15, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x34, 0x38, 0x12, 0x4e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x34, 0x39, 0x18, 0x0c, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55,
+	0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x34, 0x39, 0x12, 0x4e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x35, 0x30, 0x18, 0x0d, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55,
+	0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x35, 0x30, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x35, 0x31, 0x18, 0x0e, 0x20, 0x03, 0x28,
+	0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x35, 0x31, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x35, 0x32, 0x18, 0x0f, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x35, 0x32, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x35, 0x33, 0x18, 0x12, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x35, 0x33, 0x12, 0x48, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x35, 0x34, 0x18, 0x10, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x33, 0x37, 0x39, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x32, 0x34, 0x35, 0x35, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x34, 0x35, 0x35, 0x35, 0x18, 0x11, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x32, 0x34, 0x35, 0x35, 0x35, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x34, 0x35, 0x35, 0x36, 0x18, 0x18, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x32, 0x34, 0x33, 0x35, 0x36, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x35,
+	0x36, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x35, 0x37, 0x18,
+	0x19, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x33, 0x36, 0x36, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x35, 0x37, 0x22, 0xa2, 0x01, 0x0a, 0x0c,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x34, 0x30, 0x33, 0x12, 0x48, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x38, 0x31, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x34, 0x30, 0x31, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x34, 0x36, 0x38, 0x31, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x36, 0x38, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32,
+	0x34, 0x34, 0x30, 0x32, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x38, 0x32,
+	0x22, 0xa8, 0x09, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x33, 0x39,
+	0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x33, 0x31, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x33,
+	0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x33, 0x32, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x33,
+	0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x33, 0x33, 0x18,
+	0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x33,
+	0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x33, 0x34, 0x18,
+	0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x33,
+	0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x33, 0x35, 0x18,
+	0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x33,
+	0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x33, 0x36, 0x18,
+	0x10, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x33,
+	0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x33, 0x37, 0x18,
+	0x11, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x33,
+	0x37, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x33, 0x38, 0x18,
+	0x19, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x33,
+	0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x33, 0x39, 0x18,
+	0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x33,
+	0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x34, 0x30, 0x18,
+	0x12, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x34,
+	0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x34, 0x31, 0x18,
+	0x13, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x34,
+	0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x34, 0x32, 0x18,
+	0x14, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x34,
+	0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x34, 0x33, 0x18,
+	0x18, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x34,
+	0x33, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x34, 0x34, 0x18,
+	0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x33, 0x37, 0x39, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x34, 0x34, 0x12, 0x4e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x34, 0x35, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x34, 0x35, 0x12, 0x4e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x34, 0x36, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x34, 0x36, 0x12, 0x4e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x34, 0x37, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x34, 0x37, 0x12, 0x4e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x34, 0x38, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x34, 0x38, 0x12, 0x4e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x34, 0x39, 0x18, 0x0d, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x34, 0x39, 0x12, 0x4e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x35, 0x30, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x35, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x35, 0x31, 0x18, 0x15, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x35, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x35, 0x32, 0x18, 0x16, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x35, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x35, 0x33, 0x18, 0x17, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x35, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x35, 0x34, 0x18, 0x0f, 0x20, 0x03, 0x28, 0x09, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x35, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x35, 0x35, 0x18, 0x06, 0x20, 0x03, 0x28, 0x09, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x35, 0x35, 0x22, 0x0e, 0x0a, 0x0c, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x37, 0x34, 0x35, 0x34, 0x22, 0xae, 0x01, 0x0a, 0x0c,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x37, 0x33, 0x35, 0x37, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x31, 0x30, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x31, 0x30, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x31, 0x31, 0x18, 0x02, 0x20, 0x01, 0x28, 0x02,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x31, 0x31, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x31, 0x32, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x31, 0x32, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x31, 0x33, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x31, 0x33, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x31, 0x34, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x31, 0x34, 0x22, 0xb9, 0x02, 0x0a,
+	0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x37, 0x33, 0x36, 0x30, 0x12, 0x48, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x32, 0x36, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x37, 0x33, 0x35, 0x38, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x32, 0x37, 0x34, 0x32, 0x36, 0x12, 0x45, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x37, 0x34, 0x32, 0x37, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x32, 0x37, 0x33,
+	0x36, 0x31, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x32, 0x37, 0x12, 0x48,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x32, 0x38, 0x18, 0x03, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x37, 0x33, 0x35, 0x38, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x32, 0x38, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x37, 0x34, 0x32, 0x39, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64,
+	0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x32, 0x39, 0x22, 0xa7, 0x02, 0x0a, 0x0c, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x34, 0x33, 0x38, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x34, 0x34, 0x34, 0x36, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x34, 0x34, 0x36, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x34, 0x34, 0x34, 0x37, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x34, 0x33, 0x38, 0x31, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34,
+	0x34, 0x34, 0x37, 0x12, 0x46, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x34, 0x34,
+	0x38, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x34, 0x34, 0x38, 0x12, 0x45, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x34, 0x34, 0x39, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32,
+	0x25, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75,
+	0x6d, 0x33, 0x34, 0x33, 0x38, 0x38, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x34,
+	0x34, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x34, 0x35, 0x30,
+	0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x34,
+	0x35, 0x30, 0x22, 0xd5, 0x07, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x34,
+	0x36, 0x32, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x35,
+	0x31, 0x18, 0x01, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34,
+	0x36, 0x35, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x35,
+	0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34,
+	0x36, 0x35, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x35,
+	0x33, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34,
+	0x36, 0x35, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x35,
+	0x34, 0x18, 0x04, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34,
+	0x36, 0x35, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x35,
+	0x35, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34,
+	0x36, 0x35, 0x35, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x35,
+	0x36, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34,
+	0x36, 0x35, 0x36, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x35,
+	0x37, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x34, 0x36, 0x31,
+	0x39, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x35, 0x37, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x35, 0x38, 0x18, 0x05, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x35, 0x38, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x35, 0x39, 0x18, 0x09, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x35, 0x39, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x36, 0x30, 0x18, 0x0c, 0x20, 0x01, 0x28,
+	0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x36, 0x30, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x36, 0x31, 0x18, 0x13, 0x20, 0x01, 0x28,
+	0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x36, 0x31, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x36, 0x32, 0x18, 0x0f, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x36, 0x32, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x36, 0x33, 0x18, 0x10, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x36, 0x33, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x36, 0x34, 0x18, 0x11, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x36, 0x34, 0x12, 0x4e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x36, 0x35, 0x18, 0x12, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55,
+	0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x36, 0x35, 0x12, 0x48, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x36, 0x36, 0x18, 0x14, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x34, 0x36, 0x32, 0x31, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x34, 0x36, 0x36, 0x36, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x34, 0x36, 0x36, 0x37, 0x18, 0x64, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45,
+	0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x34, 0x36, 0x36, 0x37, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x34, 0x36, 0x36, 0x38, 0x18, 0x65, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45,
+	0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x34, 0x36, 0x36, 0x38, 0x32, 0x71, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x34, 0x36, 0x36, 0x39, 0x12, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x18, 0xa7, 0xf3, 0xaf, 0x08,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x34, 0x36, 0x32, 0x31, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x36, 0x39, 0x22, 0xa5, 0x04, 0x0a, 0x0c, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x35, 0x34, 0x37, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x34, 0x38, 0x34, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x34, 0x38, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x34, 0x38, 0x35, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x34, 0x38, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x34, 0x38, 0x36, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x34, 0x38, 0x36, 0x12, 0x45, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x34, 0x38, 0x37, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32,
+	0x25, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75,
+	0x6d, 0x33, 0x35, 0x34, 0x37, 0x37, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x34,
+	0x38, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x34, 0x38, 0x38,
+	0x18, 0x05, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x34,
+	0x38, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x34, 0x38, 0x39,
+	0x18, 0x06, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x34,
+	0x38, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x34, 0x39, 0x30,
+	0x18, 0x07, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x34,
+	0x39, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x34, 0x39, 0x31,
+	0x18, 0x08, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x34,
+	0x39, 0x31, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x34, 0x39, 0x32,
+	0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x34,
+	0x39, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x34, 0x39, 0x33,
+	0x18, 0x0a, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x34,
+	0x39, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x34, 0x39, 0x34,
+	0x18, 0x0b, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x34,
+	0x39, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x34, 0x39, 0x35,
+	0x18, 0x0c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x34,
+	0x39, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x34, 0x39, 0x36,
+	0x18, 0x0d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x34,
+	0x39, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x34, 0x39, 0x37,
+	0x18, 0x0e, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x34,
+	0x39, 0x37, 0x22, 0xf8, 0x01, 0x0a, 0x0a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x39, 0x34,
+	0x39, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x35, 0x35, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x35, 0x35, 0x12, 0x1a, 0x0a,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x35, 0x36, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x35, 0x36, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x39, 0x35, 0x37, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x39, 0x35, 0x37, 0x12, 0x42, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x35,
+	0x38, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x33, 0x30, 0x52,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x35, 0x38, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x39, 0x35, 0x39, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x39, 0x35, 0x39, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x36,
+	0x30, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x36,
+	0x30, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x36, 0x31, 0x18, 0x07, 0x20,
+	0x01, 0x28, 0x08, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x36, 0x31, 0x22, 0x4e, 0x0a,
+	0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x36, 0x39, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x37, 0x30, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x37, 0x30, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x37, 0x31, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x37, 0x31, 0x22, 0xfb, 0x02,
+	0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x33, 0x39, 0x36, 0x38, 0x12, 0x59,
+	0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x33, 0x39, 0x36, 0x39, 0x18, 0x01,
+	0x20, 0x03, 0x28, 0x0a, 0x32, 0x35, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x33, 0x39, 0x36, 0x38, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x33, 0x39, 0x36, 0x39, 0x52, 0x0c, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x33, 0x39, 0x36, 0x39, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x33, 0x39, 0x38, 0x39, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x33, 0x39, 0x35, 0x38, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33,
+	0x39, 0x38, 0x39, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x39, 0x39,
+	0x30, 0x18, 0x6a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33,
+	0x39, 0x39, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x39, 0x39,
+	0x31, 0x18, 0x6c, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33,
+	0x39, 0x39, 0x31, 0x12, 0x46, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x39, 0x39,
+	0x32, 0x18, 0x6b, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x39, 0x39, 0x32, 0x1a, 0x0e, 0x0a, 0x0c, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x33, 0x39, 0x36, 0x39, 0x22, 0x88, 0x07, 0x0a, 0x0b,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x36, 0x34, 0x34, 0x12, 0x4c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x30, 0x31, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73,
+	0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x30, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x36, 0x37, 0x30, 0x32, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x36, 0x37, 0x30, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x36, 0x37, 0x30, 0x33, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x36, 0x37, 0x30, 0x33, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37,
+	0x30, 0x34, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74,
+	0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36,
+	0x37, 0x30, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x30, 0x35,
+	0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x30,
+	0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x30, 0x36, 0x18, 0x13,
+	0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x30, 0x36, 0x12,
+	0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x30, 0x37, 0x18, 0x04, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x36, 0x33, 0x37, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x36, 0x37, 0x30, 0x37, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36,
+	0x37, 0x30, 0x38, 0x18, 0x12, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x31,
+	0x32, 0x36, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x30, 0x38, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x30, 0x39, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x30, 0x39, 0x12, 0x45, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x31, 0x30, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x36, 0x36, 0x34, 0x33, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37,
+	0x31, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x31, 0x31, 0x18,
+	0x0c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x31, 0x31,
+	0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x31, 0x32, 0x18, 0x0e, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x31, 0x32, 0x12, 0x4c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x31, 0x33, 0x18, 0x0f, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55,
+	0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x31, 0x33, 0x12, 0x4c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x31, 0x34, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x31, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x36, 0x37, 0x31, 0x35, 0x18, 0x11, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x31, 0x35, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x36, 0x37, 0x31, 0x36, 0x18, 0x14, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45,
+	0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x36, 0x37, 0x31, 0x36, 0x22, 0xd3, 0x04, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x31, 0x38, 0x38, 0x33, 0x31, 0x12, 0x59, 0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x31, 0x38, 0x38, 0x33, 0x32, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0a, 0x32, 0x35, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x31, 0x38, 0x38, 0x33, 0x31, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31,
+	0x38, 0x38, 0x33, 0x32, 0x52, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x38, 0x38,
+	0x33, 0x32, 0x1a, 0xe7, 0x03, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x38,
+	0x38, 0x33, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x33,
+	0x36, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x38, 0x33, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x33,
+	0x37, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x38, 0x33, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x33,
+	0x38, 0x18, 0x03, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x38, 0x33, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x33,
+	0x39, 0x18, 0x09, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x38, 0x33, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x34,
+	0x30, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x38, 0x34, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x34,
+	0x31, 0x18, 0x04, 0x20, 0x03, 0x28, 0x04, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x38, 0x34, 0x31, 0x12, 0x66, 0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x38,
+	0x38, 0x33, 0x33, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0a, 0x32, 0x42, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x38,
+	0x38, 0x33, 0x31, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x38, 0x38, 0x33, 0x32,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x38, 0x38, 0x33, 0x33, 0x52, 0x0c, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x38, 0x38, 0x33, 0x33, 0x1a, 0xae, 0x01, 0x0a, 0x0c,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x38, 0x38, 0x33, 0x33, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x34, 0x33, 0x18, 0x07, 0x20, 0x02, 0x28, 0x04,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x34, 0x33, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x34, 0x34, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x34, 0x34, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x34, 0x35, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x02,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x34, 0x35, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x34, 0x36, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x34, 0x36, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x34, 0x37, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x34, 0x37, 0x22, 0xa2, 0x01, 0x0a,
+	0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x30, 0x39, 0x30, 0x12, 0x48, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x31, 0x34, 0x31, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x30, 0x38, 0x33, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x33, 0x31, 0x34, 0x31, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x33, 0x31, 0x34, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x31, 0x33, 0x30, 0x38, 0x38, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x31, 0x34,
+	0x32, 0x22, 0xf4, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x31, 0x38,
+	0x37, 0x34, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x38, 0x38,
+	0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x33, 0x39, 0x31,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x38, 0x38, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x38, 0x39, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x38, 0x39, 0x12, 0x48, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x39, 0x30, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x31, 0x38, 0x37, 0x33, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x31, 0x38, 0x39, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x31, 0x38, 0x39, 0x31, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x31, 0x38, 0x39, 0x31, 0x2a, 0x04, 0x08, 0x01, 0x10, 0x02, 0x2a, 0x04, 0x08, 0x02,
+	0x10, 0x03, 0x2a, 0x04, 0x08, 0x05, 0x10, 0x06, 0x22, 0x9a, 0x03, 0x0a, 0x0b, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x34, 0x31, 0x34, 0x34, 0x12, 0x55, 0x0a, 0x0b, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x34, 0x31, 0x34, 0x35, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0a, 0x32, 0x33, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x34, 0x31, 0x34, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x31,
+	0x34, 0x35, 0x52, 0x0b, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x31, 0x34, 0x35, 0x1a,
+	0xb3, 0x02, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x31, 0x34, 0x35, 0x12,
+	0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x31, 0x36, 0x35, 0x18, 0x02, 0x20, 0x02,
+	0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x45, 0x6e, 0x75, 0x6d, 0x34, 0x31, 0x34, 0x36, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34,
+	0x31, 0x36, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x31, 0x36, 0x36,
+	0x18, 0x03, 0x20, 0x02, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x31, 0x36,
+	0x36, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x31, 0x36, 0x37, 0x18, 0x09,
+	0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x34, 0x31, 0x36, 0x30, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x34, 0x31, 0x36, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x31,
+	0x36, 0x38, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34,
+	0x31, 0x36, 0x38, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x31, 0x36, 0x39,
+	0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x34, 0x31, 0x35, 0x32, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x34, 0x31, 0x36, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x34, 0x31, 0x37, 0x30, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x34, 0x31, 0x37, 0x30, 0x22, 0x98, 0x15, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x35, 0x35, 0x37, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x35, 0x36, 0x39, 0x35, 0x18, 0x10, 0x20, 0x01, 0x28, 0x06, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x35, 0x36, 0x39, 0x35, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x35, 0x36, 0x39, 0x36, 0x18, 0xe8, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x35, 0x36, 0x39, 0x36, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x35, 0x36, 0x39, 0x37, 0x18, 0xec, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x35, 0x36, 0x39, 0x37, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x35, 0x36, 0x39, 0x38, 0x18, 0xeb, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x36, 0x39, 0x38, 0x12, 0x5a, 0x0a, 0x0c, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x35, 0x35, 0x37, 0x34, 0x18, 0xf4, 0x07, 0x20, 0x03, 0x28, 0x0a,
+	0x32, 0x35, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x35, 0x35, 0x37, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x35, 0x35, 0x37, 0x34, 0x52, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x35, 0x35, 0x37, 0x34, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35,
+	0x37, 0x30, 0x30, 0x18, 0xf3, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x35, 0x37, 0x30, 0x30, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x35, 0x37, 0x30, 0x31, 0x18, 0xed, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x35, 0x37, 0x30, 0x31, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x35, 0x37, 0x30, 0x32, 0x18, 0xee, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x30, 0x32, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x35, 0x37, 0x30, 0x33, 0x18, 0xef, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x30, 0x33, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x35, 0x37, 0x30, 0x34, 0x18, 0xf0, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x30, 0x34, 0x12, 0x59, 0x0a, 0x0c, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x35, 0x35, 0x37, 0x35, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0a,
+	0x32, 0x35, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x35, 0x35, 0x37, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x35, 0x35, 0x37, 0x35, 0x52, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x35, 0x35, 0x37, 0x35, 0x1a, 0x0e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x35, 0x35, 0x37, 0x34, 0x1a, 0x98, 0x11, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x35, 0x35, 0x37, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x35, 0x37, 0x30, 0x39, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x35, 0x37, 0x30, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x35, 0x37, 0x31, 0x30, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x35, 0x37, 0x31, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x35, 0x37, 0x31, 0x31, 0x18, 0x13, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x35, 0x37, 0x31, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x35, 0x37, 0x31, 0x32, 0x18, 0x14, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x35, 0x37, 0x31, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x35, 0x37, 0x31, 0x33, 0x18, 0x15, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x35, 0x37, 0x31, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x35, 0x37, 0x31, 0x34, 0x18, 0x16, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x35, 0x37, 0x31, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x35, 0x37, 0x31, 0x35, 0x18, 0x17, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x35, 0x37, 0x31, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x35, 0x37, 0x31, 0x36, 0x18, 0x2f, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x35, 0x37, 0x31, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x35, 0x37, 0x31, 0x37, 0x18, 0x30, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x35, 0x37, 0x31, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x35, 0x37, 0x31, 0x38, 0x18, 0x18, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x35, 0x37, 0x31, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x35, 0x37, 0x31, 0x39, 0x18, 0x19, 0x20, 0x01, 0x28, 0x06, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x35, 0x37, 0x31, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x35, 0x37, 0x32, 0x30, 0x18, 0x34, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x35, 0x37, 0x32, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x35, 0x37, 0x32, 0x31, 0x18, 0x12, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x35, 0x37, 0x32, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x35, 0x37, 0x32, 0x32, 0x18, 0x2b, 0x20, 0x01, 0x28, 0x07, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x35, 0x37, 0x32, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x35, 0x37, 0x32, 0x33, 0x18, 0x1a, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x35, 0x37, 0x32, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x35, 0x37, 0x32, 0x34, 0x18, 0x1b, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x35, 0x37, 0x32, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x35, 0x37, 0x32, 0x35, 0x18, 0x11, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x35, 0x37, 0x32, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x35, 0x37, 0x32, 0x36, 0x18, 0x2d, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x35, 0x37, 0x32, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x35, 0x37, 0x32, 0x37, 0x18, 0x21, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x35, 0x37, 0x32, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x35, 0x37, 0x32, 0x38, 0x18, 0x3a, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x35, 0x37, 0x32, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x35, 0x37, 0x32, 0x39, 0x18, 0x22, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x35, 0x37, 0x32, 0x39, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x35, 0x37, 0x33, 0x30, 0x18, 0xf1, 0x07, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x35, 0x37, 0x33, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x35, 0x37, 0x33, 0x31, 0x18, 0x1c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x35, 0x37, 0x33, 0x31, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x35, 0x37, 0x33, 0x32, 0x18, 0xe9, 0x07, 0x20, 0x03, 0x28, 0x06, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x33, 0x32, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x35, 0x37, 0x33, 0x33, 0x18, 0xea, 0x07, 0x20, 0x03, 0x28, 0x06, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x33, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x35, 0x37, 0x33, 0x34, 0x18, 0x2c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x33, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x35, 0x37, 0x33, 0x35, 0x18, 0x32, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x33, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x35, 0x37, 0x33, 0x36, 0x18, 0x24, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x33, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x35, 0x37, 0x33, 0x37, 0x18, 0x28, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x33, 0x37, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x35, 0x37, 0x33, 0x38, 0x18, 0xf8, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x33, 0x38, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x33, 0x39, 0x18, 0xf2, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x33, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x34, 0x30, 0x18, 0x25, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x34, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x34, 0x31, 0x18, 0x26, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x34, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x34, 0x32, 0x18, 0x2e, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x34, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x34, 0x33, 0x18, 0x3c, 0x20, 0x01, 0x28, 0x0d, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x34, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x34, 0x34, 0x18, 0x38, 0x20, 0x03, 0x28, 0x0c, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x34, 0x34, 0x12, 0x44, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x34, 0x35, 0x18, 0x39, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x34,
+	0x35, 0x12, 0x66, 0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x35, 0x35, 0x37,
+	0x36, 0x18, 0x04, 0x20, 0x02, 0x28, 0x0a, 0x32, 0x42, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x35, 0x35, 0x37,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x35, 0x35, 0x37, 0x35, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x35, 0x35, 0x37, 0x36, 0x52, 0x0c, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x35, 0x35, 0x37, 0x36, 0x1a, 0xd4, 0x06, 0x0a, 0x0c, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x35, 0x35, 0x37, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x34, 0x37, 0x18, 0x05, 0x20, 0x01, 0x28, 0x06, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x34, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x34, 0x38, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x34, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x34, 0x39, 0x18, 0x31, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x34, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x35, 0x30, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x35, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x35, 0x31, 0x18, 0x3b, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x35, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x35, 0x32, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x35, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x35, 0x33, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x35, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x35, 0x34, 0x18, 0x23, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x35, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x35, 0x35, 0x18, 0x35, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x35, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x35, 0x36, 0x18, 0x08, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x35, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x35, 0x37, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x35, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x35, 0x38, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x06, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x35, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x35, 0x39, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x35, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x36, 0x30, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x36, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x36, 0x31, 0x18, 0x29, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x36, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x36, 0x32, 0x18, 0x1e, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x36, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x36, 0x33, 0x18, 0x1f, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x36, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x36, 0x34, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x36, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x36, 0x35, 0x18, 0x27, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x36, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x36, 0x36, 0x18, 0x1d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x36, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x36, 0x37, 0x18, 0x2a, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x36, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x36, 0x38, 0x18, 0x20, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x36, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x36, 0x39, 0x18, 0x33, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x36, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x37, 0x30, 0x18, 0x36, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x37, 0x30, 0x12, 0x44, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x37, 0x31, 0x18, 0x37, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x37, 0x37, 0x31,
+	0x22, 0xea, 0x04, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x35,
+	0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x35, 0x36, 0x18,
+	0x01, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x35,
+	0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x35, 0x37, 0x18,
+	0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x35,
+	0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x35, 0x38, 0x18,
+	0x0c, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x35,
+	0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x35, 0x39, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x35,
+	0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x36, 0x30, 0x18,
+	0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x36,
+	0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x36, 0x31, 0x18,
+	0x0e, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x36,
+	0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x36, 0x32, 0x18,
+	0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x36,
+	0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x36, 0x33, 0x18,
+	0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x36,
+	0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x36, 0x34, 0x18,
+	0x0d, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x36,
+	0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x36, 0x35, 0x18,
+	0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x36,
+	0x35, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x36, 0x36, 0x18,
+	0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x35, 0x35, 0x30, 0x36, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x36, 0x36, 0x12, 0x59, 0x0a, 0x0c, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x35, 0x39, 0x18, 0x08, 0x20, 0x03, 0x28,
+	0x0a, 0x32, 0x35, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x35, 0x38, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x36, 0x38, 0x35, 0x39, 0x52, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x36, 0x38, 0x35, 0x39, 0x1a, 0x75, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x36, 0x38, 0x35, 0x39, 0x12, 0x45, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x36, 0x39, 0x36, 0x38, 0x18, 0x09, 0x20, 0x02, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x33, 0x36, 0x38, 0x36,
+	0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x36, 0x38, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x36, 0x39, 0x18, 0x0a, 0x20, 0x01, 0x28,
+	0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x36, 0x39, 0x36, 0x39, 0x22, 0xd8, 0x05,
+	0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x31, 0x37, 0x34, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x33, 0x37, 0x18, 0x06, 0x20, 0x02,
+	0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x33, 0x37, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x33, 0x38, 0x18, 0x03, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x33, 0x38, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x33, 0x39, 0x18, 0x04, 0x20, 0x02,
+	0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x33, 0x39, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x34, 0x30, 0x18, 0x08, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x34, 0x30, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x34, 0x31, 0x18, 0x05, 0x20, 0x01,
+	0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x34, 0x31, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x34, 0x32, 0x18, 0x07, 0x20, 0x01,
+	0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x34, 0x32, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x34, 0x33, 0x18, 0x11, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x34, 0x33, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x34, 0x34, 0x18, 0x13, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x34, 0x34, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x34, 0x35, 0x18, 0x14, 0x20, 0x01,
+	0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x34, 0x35, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x34, 0x36, 0x18, 0x09, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x34, 0x36, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x34, 0x37, 0x18, 0x0a, 0x20, 0x01,
+	0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x34, 0x37, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x34, 0x38, 0x18, 0x0b, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x34, 0x38, 0x12, 0x48,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x34, 0x39, 0x18, 0x15, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x31, 0x35, 0x31, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x34, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x33, 0x32, 0x35, 0x30, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x35, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x33, 0x32, 0x35, 0x31, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x35, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x33, 0x32, 0x35, 0x32, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x35, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x33, 0x32, 0x35, 0x33, 0x18, 0x10, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x35, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x33, 0x32, 0x35, 0x34, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x35, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x33, 0x32, 0x35, 0x35, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x35, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x33, 0x32, 0x35, 0x36, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x35, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x33, 0x32, 0x35, 0x37, 0x18, 0x12, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x35, 0x37, 0x22, 0xdf, 0x27, 0x0a, 0x0c, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x31, 0x38, 0x32, 0x38, 0x33, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x38, 0x34, 0x37, 0x38, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65,
+	0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x34, 0x37, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x38, 0x34, 0x37, 0x39, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x34, 0x37, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x38, 0x34, 0x38, 0x30, 0x18, 0x6a, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x34, 0x38, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x38, 0x34, 0x38, 0x31, 0x18, 0x6b, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x34, 0x38, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x38, 0x34, 0x38, 0x32, 0x18, 0x6c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x34, 0x38, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x38, 0x34, 0x38, 0x33, 0x18, 0x6d, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x34, 0x38, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x38, 0x34, 0x38, 0x34, 0x18, 0x69, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x34, 0x38, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x38, 0x34, 0x38, 0x35, 0x18, 0x71, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x34, 0x38, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x38, 0x34, 0x38, 0x36, 0x18, 0x72, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x34, 0x38, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x38, 0x34, 0x38, 0x37, 0x18, 0x7c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x34, 0x38, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x38, 0x34, 0x38, 0x38, 0x18, 0x7d, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x34, 0x38, 0x38, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x38, 0x34, 0x38, 0x39, 0x18, 0x80, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x34, 0x38, 0x39, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x38, 0x34, 0x39, 0x30, 0x18, 0x87, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x34, 0x39, 0x30, 0x12, 0x1f, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x34, 0x39, 0x31, 0x18, 0xa6, 0x01, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x34, 0x39, 0x31, 0x12, 0x1f, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x34, 0x39, 0x32, 0x18, 0x88, 0x01, 0x20, 0x01, 0x28,
+	0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x34, 0x39, 0x32, 0x12, 0x1f, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x34, 0x39, 0x33, 0x18, 0x8c, 0x01, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x34, 0x39, 0x33, 0x12, 0x1f,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x34, 0x39, 0x34, 0x18, 0xab, 0x01, 0x20,
+	0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x34, 0x39, 0x34, 0x12,
+	0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x34, 0x39, 0x35, 0x18, 0x94, 0x01,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x34, 0x39, 0x35,
+	0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x34, 0x39, 0x36, 0x18, 0x91,
+	0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x34, 0x39,
+	0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x34, 0x39, 0x37, 0x18,
+	0x75, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x34, 0x39,
+	0x37, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x34, 0x39, 0x38, 0x18,
+	0x92, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x34,
+	0x39, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x34, 0x39, 0x39,
+	0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x34,
+	0x39, 0x39, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x30, 0x30,
+	0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35,
+	0x30, 0x30, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x30, 0x31,
+	0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35,
+	0x30, 0x31, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x30, 0x32,
+	0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35,
+	0x30, 0x32, 0x12, 0x49, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x30, 0x33,
+	0x18, 0x9b, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x38, 0x32, 0x35,
+	0x33, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x30, 0x33, 0x12, 0x4f, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x30, 0x34, 0x18, 0xb8, 0x01, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x30, 0x34, 0x12, 0x4f,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x30, 0x35, 0x18, 0xa3, 0x01, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x30, 0x35, 0x12,
+	0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x30, 0x36, 0x18, 0x10, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x30, 0x36, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x30, 0x37, 0x18, 0x14, 0x20,
+	0x03, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x30, 0x37, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x30, 0x38, 0x18, 0x07, 0x20,
+	0x03, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x30, 0x38, 0x12,
+	0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x30, 0x39, 0x18, 0xc2, 0x01,
+	0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x30, 0x39,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x31, 0x30, 0x18, 0x1e,
+	0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x31, 0x30,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x31, 0x31, 0x18, 0x1f,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x31, 0x31,
+	0x12, 0x4f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x31, 0x32, 0x18, 0xb2,
+	0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x31,
+	0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x31, 0x33, 0x18,
+	0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x31,
+	0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x31, 0x34, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x31,
+	0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x31, 0x35, 0x18,
+	0x64, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x31,
+	0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x31, 0x36, 0x18,
+	0x65, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x31,
+	0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x31, 0x37, 0x18,
+	0x66, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x31,
+	0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x31, 0x38, 0x18,
+	0x67, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x31,
+	0x38, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x31, 0x39, 0x18,
+	0x68, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x31,
+	0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x32, 0x30, 0x18,
+	0x6e, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x32,
+	0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x32, 0x31, 0x18,
+	0x70, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x32,
+	0x31, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x32, 0x32, 0x18,
+	0x6f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x32,
+	0x32, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x32, 0x33, 0x18,
+	0x73, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x32,
+	0x33, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x32, 0x34, 0x18,
+	0x77, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x32,
+	0x34, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x32, 0x35, 0x18,
+	0x7f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x32,
+	0x35, 0x12, 0x4f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x32, 0x36, 0x18,
+	0xb9, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35,
+	0x32, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x32, 0x37,
+	0x18, 0x78, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35,
+	0x32, 0x37, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x32, 0x38,
+	0x18, 0x84, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x35, 0x32, 0x38, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x32,
+	0x39, 0x18, 0x7e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x35, 0x32, 0x39, 0x12, 0x4f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x33,
+	0x30, 0x18, 0x81, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74,
+	0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x38, 0x35, 0x33, 0x30, 0x12, 0x4f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35,
+	0x33, 0x31, 0x18, 0x83, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70,
+	0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x38, 0x35, 0x33, 0x31, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x35, 0x33, 0x32, 0x18, 0x96, 0x01, 0x20, 0x01, 0x28, 0x06, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x38, 0x35, 0x33, 0x32, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x38, 0x35, 0x33, 0x33, 0x18, 0x85, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x38, 0x35, 0x33, 0x33, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x38, 0x35, 0x33, 0x34, 0x18, 0x86, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x33, 0x34, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x38, 0x35, 0x33, 0x35, 0x18, 0x8b, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x33, 0x35, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x38, 0x35, 0x33, 0x36, 0x18, 0x89, 0x01, 0x20, 0x01, 0x28, 0x06, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x33, 0x36, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x33, 0x37, 0x18, 0x8a, 0x01, 0x20, 0x01, 0x28, 0x06, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x33, 0x37, 0x12, 0x4f, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x33, 0x38, 0x18, 0x8d, 0x01, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e,
+	0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x33, 0x38, 0x12, 0x1f, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x33, 0x39, 0x18, 0x8e, 0x01, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x33, 0x39, 0x12, 0x1f, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x34, 0x30, 0x18, 0xb5, 0x01, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x34, 0x30, 0x12, 0x49,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x34, 0x31, 0x18, 0x8f, 0x01, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x38, 0x31, 0x36, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x34, 0x31, 0x12, 0x49, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x38, 0x35, 0x34, 0x32, 0x18, 0x9a, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x31, 0x36, 0x36, 0x38, 0x35, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x38, 0x35, 0x34, 0x32, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35,
+	0x34, 0x33, 0x18, 0x90, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x38, 0x35, 0x34, 0x33, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x35, 0x34, 0x34, 0x18, 0x93, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x38, 0x35, 0x34, 0x34, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x38, 0x35, 0x34, 0x35, 0x18, 0x95, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x38, 0x35, 0x34, 0x35, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x38, 0x35, 0x34, 0x36, 0x18, 0x97, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x34, 0x36, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x38, 0x35, 0x34, 0x37, 0x18, 0x98, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x34, 0x37, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x38, 0x35, 0x34, 0x38, 0x18, 0x99, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x34, 0x38, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x34, 0x39, 0x18, 0xa1, 0x01, 0x20, 0x01, 0x28, 0x02, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x34, 0x39, 0x12, 0x44, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x35, 0x30, 0x18, 0x7b, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x35,
+	0x30, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x35, 0x31, 0x18,
+	0x9c, 0x01, 0x20, 0x03, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35,
+	0x35, 0x31, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x35, 0x32,
+	0x18, 0x9d, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x35, 0x35, 0x32, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x35,
+	0x33, 0x18, 0xbc, 0x01, 0x20, 0x03, 0x28, 0x06, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x38, 0x35, 0x35, 0x33, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35,
+	0x35, 0x34, 0x18, 0x9e, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x38, 0x35, 0x35, 0x34, 0x12, 0x4f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x35, 0x35, 0x35, 0x18, 0x9f, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d,
+	0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x38, 0x35, 0x35, 0x35, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x38, 0x35, 0x35, 0x36, 0x18, 0xa0, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x38, 0x35, 0x35, 0x36, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x38, 0x35, 0x35, 0x37, 0x18, 0xa2, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x35, 0x37, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x38, 0x35, 0x35, 0x38, 0x18, 0xa4, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x35, 0x38, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x38, 0x35, 0x35, 0x39, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65,
+	0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x35, 0x39, 0x12, 0x4f, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x38, 0x35, 0x36, 0x30, 0x18, 0xa7, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73,
+	0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x36, 0x30, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x36, 0x31, 0x18, 0xa8, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x36, 0x31, 0x12, 0x1f, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x36, 0x32, 0x18, 0xa9, 0x01, 0x20, 0x03, 0x28, 0x06,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x36, 0x32, 0x12, 0x1f, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x36, 0x33, 0x18, 0xaa, 0x01, 0x20, 0x03, 0x28,
+	0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x36, 0x33, 0x12, 0x4f, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x36, 0x34, 0x18, 0xac, 0x01, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x36, 0x34, 0x12, 0x1f,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x36, 0x35, 0x18, 0xad, 0x01, 0x20,
+	0x01, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x36, 0x35, 0x12,
+	0x4f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x36, 0x36, 0x18, 0xae, 0x01,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x36, 0x36,
+	0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x36, 0x37, 0x18, 0xaf,
+	0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x36,
+	0x37, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x36, 0x38, 0x18,
+	0xbd, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35,
+	0x36, 0x38, 0x12, 0x4f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x36, 0x39,
+	0x18, 0xb0, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x35, 0x36, 0x39, 0x12, 0x4f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x37,
+	0x30, 0x18, 0xb1, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74,
+	0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x38, 0x35, 0x37, 0x30, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35,
+	0x37, 0x31, 0x18, 0xb3, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x38, 0x35, 0x37, 0x31, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x35, 0x37, 0x32, 0x18, 0xb4, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x38, 0x35, 0x37, 0x32, 0x12, 0x4f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x38, 0x35, 0x37, 0x33, 0x18, 0xb6, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45,
+	0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x38, 0x35, 0x37, 0x33, 0x12, 0x4f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x38, 0x35, 0x37, 0x34, 0x18, 0xb7, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64,
+	0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x37, 0x34, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x38, 0x35, 0x37, 0x35, 0x18, 0x79, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64,
+	0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x37, 0x35, 0x12, 0x4f, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x38, 0x35, 0x37, 0x36, 0x18, 0xba, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65,
+	0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x37, 0x36, 0x12, 0x4f, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x38, 0x35, 0x37, 0x37, 0x18, 0xbb, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73,
+	0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x37, 0x37, 0x12, 0x4f, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x37, 0x38, 0x18, 0xbe, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x37, 0x38, 0x12, 0x1f, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x37, 0x39, 0x18, 0xbf, 0x01, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x37, 0x39, 0x12, 0x1f, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x38, 0x30, 0x18, 0xc0, 0x01, 0x20, 0x01, 0x28,
+	0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x38, 0x30, 0x12, 0x1f, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x38, 0x31, 0x18, 0xc1, 0x01, 0x20, 0x01,
+	0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x35, 0x38, 0x31, 0x2a, 0x04,
+	0x08, 0x74, 0x10, 0x75, 0x2a, 0x04, 0x08, 0x76, 0x10, 0x77, 0x2a, 0x06, 0x08, 0x82, 0x01, 0x10,
+	0x83, 0x01, 0x2a, 0x06, 0x08, 0xa5, 0x01, 0x10, 0xa6, 0x01, 0x22, 0xc2, 0x01, 0x0a, 0x0c, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x31, 0x36, 0x39, 0x12, 0x48, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x32, 0x33, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x31, 0x36, 0x38, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x33, 0x32, 0x32, 0x33, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33,
+	0x32, 0x32, 0x34, 0x18, 0x02, 0x20, 0x02, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33,
+	0x31, 0x36, 0x37, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x32, 0x34, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x32, 0x35, 0x18, 0x03, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x32, 0x35, 0x22,
+	0x2e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x39, 0x32, 0x35, 0x35, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x39, 0x32, 0x35, 0x37, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x39, 0x32, 0x35, 0x37, 0x22,
+	0x6e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x35, 0x35, 0x34, 0x32, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35, 0x34, 0x33, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35, 0x34, 0x33, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35, 0x34, 0x34, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35, 0x34, 0x34, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35, 0x34, 0x35, 0x18, 0x03, 0x20,
+	0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35, 0x34, 0x35, 0x22,
+	0x9d, 0x03, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x39, 0x30, 0x31, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x39, 0x30, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x39, 0x30, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x39, 0x31, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x39, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x39, 0x32, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x39, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x39, 0x39, 0x33, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x39, 0x39, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x39, 0x39, 0x34, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x39, 0x39, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39,
+	0x39, 0x35, 0x18, 0x08, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x39, 0x39, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x39, 0x36,
+	0x18, 0x09, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x39,
+	0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x39, 0x37, 0x18, 0x0a,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x39, 0x37, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x39, 0x38, 0x18, 0x0b, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x39, 0x38, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x39, 0x39, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x39, 0x39, 0x12, 0x44, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x34, 0x30, 0x30, 0x30, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73,
+	0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x30, 0x30,
+	0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x30, 0x30, 0x31, 0x18, 0x05,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x30, 0x30, 0x31, 0x42,
+	0x23, 0x0a, 0x1e, 0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0xf8, 0x01, 0x01,
+}
+
+var (
+	file_datasets_google_message3_benchmark_message3_2_proto_rawDescOnce sync.Once
+	file_datasets_google_message3_benchmark_message3_2_proto_rawDescData = file_datasets_google_message3_benchmark_message3_2_proto_rawDesc
+)
+
+func file_datasets_google_message3_benchmark_message3_2_proto_rawDescGZIP() []byte {
+	file_datasets_google_message3_benchmark_message3_2_proto_rawDescOnce.Do(func() {
+		file_datasets_google_message3_benchmark_message3_2_proto_rawDescData = protoimpl.X.CompressGZIP(file_datasets_google_message3_benchmark_message3_2_proto_rawDescData)
+	})
+	return file_datasets_google_message3_benchmark_message3_2_proto_rawDescData
+}
+
+var file_datasets_google_message3_benchmark_message3_2_proto_msgTypes = make([]protoimpl.MessageInfo, 34)
+var file_datasets_google_message3_benchmark_message3_2_proto_goTypes = []interface{}{
+	(*Message22853)(nil),                           // 0: benchmarks.google_message3.Message22853
+	(*Message24345)(nil),                           // 1: benchmarks.google_message3.Message24345
+	(*Message24403)(nil),                           // 2: benchmarks.google_message3.Message24403
+	(*Message24391)(nil),                           // 3: benchmarks.google_message3.Message24391
+	(*Message27454)(nil),                           // 4: benchmarks.google_message3.Message27454
+	(*Message27357)(nil),                           // 5: benchmarks.google_message3.Message27357
+	(*Message27360)(nil),                           // 6: benchmarks.google_message3.Message27360
+	(*Message34387)(nil),                           // 7: benchmarks.google_message3.Message34387
+	(*Message34621)(nil),                           // 8: benchmarks.google_message3.Message34621
+	(*Message35476)(nil),                           // 9: benchmarks.google_message3.Message35476
+	(*Message949)(nil),                             // 10: benchmarks.google_message3.Message949
+	(*Message36869)(nil),                           // 11: benchmarks.google_message3.Message36869
+	(*Message33968)(nil),                           // 12: benchmarks.google_message3.Message33968
+	(*Message6644)(nil),                            // 13: benchmarks.google_message3.Message6644
+	(*Message18831)(nil),                           // 14: benchmarks.google_message3.Message18831
+	(*Message13090)(nil),                           // 15: benchmarks.google_message3.Message13090
+	(*Message11874)(nil),                           // 16: benchmarks.google_message3.Message11874
+	(*Message4144)(nil),                            // 17: benchmarks.google_message3.Message4144
+	(*Message35573)(nil),                           // 18: benchmarks.google_message3.Message35573
+	(*Message36858)(nil),                           // 19: benchmarks.google_message3.Message36858
+	(*Message13174)(nil),                           // 20: benchmarks.google_message3.Message13174
+	(*Message18283)(nil),                           // 21: benchmarks.google_message3.Message18283
+	(*Message13169)(nil),                           // 22: benchmarks.google_message3.Message13169
+	(*Message19255)(nil),                           // 23: benchmarks.google_message3.Message19255
+	(*Message35542)(nil),                           // 24: benchmarks.google_message3.Message35542
+	(*Message3901)(nil),                            // 25: benchmarks.google_message3.Message3901
+	(*Message33968_Message33969)(nil),              // 26: benchmarks.google_message3.Message33968.Message33969
+	(*Message18831_Message18832)(nil),              // 27: benchmarks.google_message3.Message18831.Message18832
+	(*Message18831_Message18832_Message18833)(nil), // 28: benchmarks.google_message3.Message18831.Message18832.Message18833
+	(*Message4144_Message4145)(nil),                // 29: benchmarks.google_message3.Message4144.Message4145
+	(*Message35573_Message35574)(nil),              // 30: benchmarks.google_message3.Message35573.Message35574
+	(*Message35573_Message35575)(nil),              // 31: benchmarks.google_message3.Message35573.Message35575
+	(*Message35573_Message35575_Message35576)(nil), // 32: benchmarks.google_message3.Message35573.Message35575.Message35576
+	(*Message36858_Message36859)(nil),              // 33: benchmarks.google_message3.Message36858.Message36859
+	(Enum22854)(0),                                 // 34: benchmarks.google_message3.Enum22854
+	(*UnusedEmptyMessage)(nil),                     // 35: benchmarks.google_message3.UnusedEmptyMessage
+	(UnusedEnum)(0),                                // 36: benchmarks.google_message3.UnusedEnum
+	(*Message24346)(nil),                           // 37: benchmarks.google_message3.Message24346
+	(*Message24316)(nil),                           // 38: benchmarks.google_message3.Message24316
+	(*Message24376)(nil),                           // 39: benchmarks.google_message3.Message24376
+	(*Message24379)(nil),                           // 40: benchmarks.google_message3.Message24379
+	(*Message24356)(nil),                           // 41: benchmarks.google_message3.Message24356
+	(*Message24366)(nil),                           // 42: benchmarks.google_message3.Message24366
+	(*Message24401)(nil),                           // 43: benchmarks.google_message3.Message24401
+	(*Message24402)(nil),                           // 44: benchmarks.google_message3.Message24402
+	(*Message27358)(nil),                           // 45: benchmarks.google_message3.Message27358
+	(Enum27361)(0),                                 // 46: benchmarks.google_message3.Enum27361
+	(*Message34381)(nil),                           // 47: benchmarks.google_message3.Message34381
+	(Enum34388)(0),                                 // 48: benchmarks.google_message3.Enum34388
+	(*Message34619)(nil),                           // 49: benchmarks.google_message3.Message34619
+	(Enum35477)(0),                                 // 50: benchmarks.google_message3.Enum35477
+	(*Message730)(nil),                             // 51: benchmarks.google_message3.Message730
+	(*Message33958)(nil),                           // 52: benchmarks.google_message3.Message33958
+	(*Message6637)(nil),                            // 53: benchmarks.google_message3.Message6637
+	(*Message6126)(nil),                            // 54: benchmarks.google_message3.Message6126
+	(*Message6643)(nil),                            // 55: benchmarks.google_message3.Message6643
+	(*Message13083)(nil),                           // 56: benchmarks.google_message3.Message13083
+	(*Message13088)(nil),                           // 57: benchmarks.google_message3.Message13088
+	(*Message10391)(nil),                           // 58: benchmarks.google_message3.Message10391
+	(*Message11873)(nil),                           // 59: benchmarks.google_message3.Message11873
+	(*Message35506)(nil),                           // 60: benchmarks.google_message3.Message35506
+	(*Message13151)(nil),                           // 61: benchmarks.google_message3.Message13151
+	(*Message18253)(nil),                           // 62: benchmarks.google_message3.Message18253
+	(*Message16816)(nil),                           // 63: benchmarks.google_message3.Message16816
+	(*Message16685)(nil),                           // 64: benchmarks.google_message3.Message16685
+	(*Message0)(nil),                               // 65: benchmarks.google_message3.Message0
+	(*Message13168)(nil),                           // 66: benchmarks.google_message3.Message13168
+	(*Message13167)(nil),                           // 67: benchmarks.google_message3.Message13167
+	(Enum4146)(0),                                  // 68: benchmarks.google_message3.Enum4146
+	(Enum4160)(0),                                  // 69: benchmarks.google_message3.Enum4160
+	(Enum4152)(0),                                  // 70: benchmarks.google_message3.Enum4152
+	(Enum36860)(0),                                 // 71: benchmarks.google_message3.Enum36860
+}
+var file_datasets_google_message3_benchmark_message3_2_proto_depIdxs = []int32{
+	34,  // 0: benchmarks.google_message3.Message22853.field22869:type_name -> benchmarks.google_message3.Enum22854
+	35,  // 1: benchmarks.google_message3.Message22853.field22873:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	36,  // 2: benchmarks.google_message3.Message24345.field24534:type_name -> benchmarks.google_message3.UnusedEnum
+	37,  // 3: benchmarks.google_message3.Message24345.field24535:type_name -> benchmarks.google_message3.Message24346
+	36,  // 4: benchmarks.google_message3.Message24345.field24538:type_name -> benchmarks.google_message3.UnusedEnum
+	38,  // 5: benchmarks.google_message3.Message24345.field24543:type_name -> benchmarks.google_message3.Message24316
+	39,  // 6: benchmarks.google_message3.Message24345.field24544:type_name -> benchmarks.google_message3.Message24376
+	35,  // 7: benchmarks.google_message3.Message24345.field24549:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 8: benchmarks.google_message3.Message24345.field24550:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	40,  // 9: benchmarks.google_message3.Message24345.field24554:type_name -> benchmarks.google_message3.Message24379
+	41,  // 10: benchmarks.google_message3.Message24345.field24556:type_name -> benchmarks.google_message3.Message24356
+	42,  // 11: benchmarks.google_message3.Message24345.field24557:type_name -> benchmarks.google_message3.Message24366
+	43,  // 12: benchmarks.google_message3.Message24403.field24681:type_name -> benchmarks.google_message3.Message24401
+	44,  // 13: benchmarks.google_message3.Message24403.field24682:type_name -> benchmarks.google_message3.Message24402
+	35,  // 14: benchmarks.google_message3.Message24391.field24638:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	40,  // 15: benchmarks.google_message3.Message24391.field24644:type_name -> benchmarks.google_message3.Message24379
+	35,  // 16: benchmarks.google_message3.Message24391.field24645:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 17: benchmarks.google_message3.Message24391.field24646:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 18: benchmarks.google_message3.Message24391.field24647:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 19: benchmarks.google_message3.Message24391.field24648:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 20: benchmarks.google_message3.Message24391.field24649:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 21: benchmarks.google_message3.Message24391.field24650:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	45,  // 22: benchmarks.google_message3.Message27360.field27426:type_name -> benchmarks.google_message3.Message27358
+	46,  // 23: benchmarks.google_message3.Message27360.field27427:type_name -> benchmarks.google_message3.Enum27361
+	45,  // 24: benchmarks.google_message3.Message27360.field27428:type_name -> benchmarks.google_message3.Message27358
+	35,  // 25: benchmarks.google_message3.Message27360.field27429:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	47,  // 26: benchmarks.google_message3.Message34387.field34447:type_name -> benchmarks.google_message3.Message34381
+	36,  // 27: benchmarks.google_message3.Message34387.field34448:type_name -> benchmarks.google_message3.UnusedEnum
+	48,  // 28: benchmarks.google_message3.Message34387.field34449:type_name -> benchmarks.google_message3.Enum34388
+	35,  // 29: benchmarks.google_message3.Message34621.field34656:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	49,  // 30: benchmarks.google_message3.Message34621.field34657:type_name -> benchmarks.google_message3.Message34619
+	35,  // 31: benchmarks.google_message3.Message34621.field34665:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	8,   // 32: benchmarks.google_message3.Message34621.field34666:type_name -> benchmarks.google_message3.Message34621
+	35,  // 33: benchmarks.google_message3.Message34621.field34667:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 34: benchmarks.google_message3.Message34621.field34668:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	50,  // 35: benchmarks.google_message3.Message35476.field35487:type_name -> benchmarks.google_message3.Enum35477
+	35,  // 36: benchmarks.google_message3.Message35476.field35492:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	51,  // 37: benchmarks.google_message3.Message949.field958:type_name -> benchmarks.google_message3.Message730
+	26,  // 38: benchmarks.google_message3.Message33968.message33969:type_name -> benchmarks.google_message3.Message33968.Message33969
+	52,  // 39: benchmarks.google_message3.Message33968.field33989:type_name -> benchmarks.google_message3.Message33958
+	35,  // 40: benchmarks.google_message3.Message33968.field33990:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	36,  // 41: benchmarks.google_message3.Message33968.field33992:type_name -> benchmarks.google_message3.UnusedEnum
+	35,  // 42: benchmarks.google_message3.Message6644.field6701:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 43: benchmarks.google_message3.Message6644.field6704:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	53,  // 44: benchmarks.google_message3.Message6644.field6707:type_name -> benchmarks.google_message3.Message6637
+	54,  // 45: benchmarks.google_message3.Message6644.field6708:type_name -> benchmarks.google_message3.Message6126
+	55,  // 46: benchmarks.google_message3.Message6644.field6710:type_name -> benchmarks.google_message3.Message6643
+	35,  // 47: benchmarks.google_message3.Message6644.field6712:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 48: benchmarks.google_message3.Message6644.field6713:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 49: benchmarks.google_message3.Message6644.field6714:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 50: benchmarks.google_message3.Message6644.field6716:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	27,  // 51: benchmarks.google_message3.Message18831.message18832:type_name -> benchmarks.google_message3.Message18831.Message18832
+	56,  // 52: benchmarks.google_message3.Message13090.field13141:type_name -> benchmarks.google_message3.Message13083
+	57,  // 53: benchmarks.google_message3.Message13090.field13142:type_name -> benchmarks.google_message3.Message13088
+	58,  // 54: benchmarks.google_message3.Message11874.field11888:type_name -> benchmarks.google_message3.Message10391
+	59,  // 55: benchmarks.google_message3.Message11874.field11890:type_name -> benchmarks.google_message3.Message11873
+	29,  // 56: benchmarks.google_message3.Message4144.message4145:type_name -> benchmarks.google_message3.Message4144.Message4145
+	30,  // 57: benchmarks.google_message3.Message35573.message35574:type_name -> benchmarks.google_message3.Message35573.Message35574
+	31,  // 58: benchmarks.google_message3.Message35573.message35575:type_name -> benchmarks.google_message3.Message35573.Message35575
+	60,  // 59: benchmarks.google_message3.Message36858.field36966:type_name -> benchmarks.google_message3.Message35506
+	33,  // 60: benchmarks.google_message3.Message36858.message36859:type_name -> benchmarks.google_message3.Message36858.Message36859
+	61,  // 61: benchmarks.google_message3.Message13174.field13249:type_name -> benchmarks.google_message3.Message13151
+	35,  // 62: benchmarks.google_message3.Message18283.field18478:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 63: benchmarks.google_message3.Message18283.field18500:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 64: benchmarks.google_message3.Message18283.field18501:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 65: benchmarks.google_message3.Message18283.field18502:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	62,  // 66: benchmarks.google_message3.Message18283.field18503:type_name -> benchmarks.google_message3.Message18253
+	35,  // 67: benchmarks.google_message3.Message18283.field18504:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 68: benchmarks.google_message3.Message18283.field18505:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 69: benchmarks.google_message3.Message18283.field18506:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 70: benchmarks.google_message3.Message18283.field18512:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 71: benchmarks.google_message3.Message18283.field18519:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 72: benchmarks.google_message3.Message18283.field18522:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 73: benchmarks.google_message3.Message18283.field18523:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 74: benchmarks.google_message3.Message18283.field18524:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 75: benchmarks.google_message3.Message18283.field18525:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 76: benchmarks.google_message3.Message18283.field18526:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 77: benchmarks.google_message3.Message18283.field18529:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 78: benchmarks.google_message3.Message18283.field18530:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 79: benchmarks.google_message3.Message18283.field18531:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 80: benchmarks.google_message3.Message18283.field18538:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	63,  // 81: benchmarks.google_message3.Message18283.field18541:type_name -> benchmarks.google_message3.Message16816
+	64,  // 82: benchmarks.google_message3.Message18283.field18542:type_name -> benchmarks.google_message3.Message16685
+	65,  // 83: benchmarks.google_message3.Message18283.field18550:type_name -> benchmarks.google_message3.Message0
+	35,  // 84: benchmarks.google_message3.Message18283.field18555:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 85: benchmarks.google_message3.Message18283.field18559:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 86: benchmarks.google_message3.Message18283.field18560:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 87: benchmarks.google_message3.Message18283.field18564:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 88: benchmarks.google_message3.Message18283.field18566:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 89: benchmarks.google_message3.Message18283.field18569:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 90: benchmarks.google_message3.Message18283.field18570:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 91: benchmarks.google_message3.Message18283.field18573:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 92: benchmarks.google_message3.Message18283.field18574:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 93: benchmarks.google_message3.Message18283.field18575:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 94: benchmarks.google_message3.Message18283.field18576:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 95: benchmarks.google_message3.Message18283.field18577:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35,  // 96: benchmarks.google_message3.Message18283.field18578:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	66,  // 97: benchmarks.google_message3.Message13169.field13223:type_name -> benchmarks.google_message3.Message13168
+	67,  // 98: benchmarks.google_message3.Message13169.field13224:type_name -> benchmarks.google_message3.Message13167
+	36,  // 99: benchmarks.google_message3.Message3901.field4000:type_name -> benchmarks.google_message3.UnusedEnum
+	28,  // 100: benchmarks.google_message3.Message18831.Message18832.message18833:type_name -> benchmarks.google_message3.Message18831.Message18832.Message18833
+	68,  // 101: benchmarks.google_message3.Message4144.Message4145.field4165:type_name -> benchmarks.google_message3.Enum4146
+	69,  // 102: benchmarks.google_message3.Message4144.Message4145.field4167:type_name -> benchmarks.google_message3.Enum4160
+	70,  // 103: benchmarks.google_message3.Message4144.Message4145.field4169:type_name -> benchmarks.google_message3.Enum4152
+	65,  // 104: benchmarks.google_message3.Message35573.Message35575.field35745:type_name -> benchmarks.google_message3.Message0
+	32,  // 105: benchmarks.google_message3.Message35573.Message35575.message35576:type_name -> benchmarks.google_message3.Message35573.Message35575.Message35576
+	65,  // 106: benchmarks.google_message3.Message35573.Message35575.Message35576.field35771:type_name -> benchmarks.google_message3.Message0
+	71,  // 107: benchmarks.google_message3.Message36858.Message36859.field36968:type_name -> benchmarks.google_message3.Enum36860
+	65,  // 108: benchmarks.google_message3.Message34621.field34669:extendee -> benchmarks.google_message3.Message0
+	8,   // 109: benchmarks.google_message3.Message34621.field34669:type_name -> benchmarks.google_message3.Message34621
+	110, // [110:110] is the sub-list for method output_type
+	110, // [110:110] is the sub-list for method input_type
+	109, // [109:110] is the sub-list for extension type_name
+	108, // [108:109] is the sub-list for extension extendee
+	0,   // [0:108] is the sub-list for field type_name
+}
+
+func init() { file_datasets_google_message3_benchmark_message3_2_proto_init() }
+func file_datasets_google_message3_benchmark_message3_2_proto_init() {
+	if File_datasets_google_message3_benchmark_message3_2_proto != nil {
+		return
+	}
+	file_datasets_google_message3_benchmark_message3_3_proto_init()
+	file_datasets_google_message3_benchmark_message3_4_proto_init()
+	file_datasets_google_message3_benchmark_message3_5_proto_init()
+	file_datasets_google_message3_benchmark_message3_7_proto_init()
+	file_datasets_google_message3_benchmark_message3_8_proto_init()
+	if !protoimpl.UnsafeEnabled {
+		file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message22853); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message24345); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message24403); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message24391); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message27454); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message27357); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message27360); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message34387); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message34621); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message35476); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message949); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message36869); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message33968); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6644); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message18831); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message13090); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message11874); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message4144); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message35573); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message36858); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message13174); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message18283); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message13169); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message19255); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message35542); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message3901); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message33968_Message33969); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message18831_Message18832); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message18831_Message18832_Message18833); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message4144_Message4145); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message35573_Message35574); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message35573_Message35575); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message35573_Message35575_Message35576); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_2_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message36858_Message36859); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_datasets_google_message3_benchmark_message3_2_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   34,
+			NumExtensions: 1,
+			NumServices:   0,
+		},
+		GoTypes:           file_datasets_google_message3_benchmark_message3_2_proto_goTypes,
+		DependencyIndexes: file_datasets_google_message3_benchmark_message3_2_proto_depIdxs,
+		MessageInfos:      file_datasets_google_message3_benchmark_message3_2_proto_msgTypes,
+		ExtensionInfos:    file_datasets_google_message3_benchmark_message3_2_proto_extTypes,
+	}.Build()
+	File_datasets_google_message3_benchmark_message3_2_proto = out.File
+	file_datasets_google_message3_benchmark_message3_2_proto_rawDesc = nil
+	file_datasets_google_message3_benchmark_message3_2_proto_goTypes = nil
+	file_datasets_google_message3_benchmark_message3_2_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3/benchmark_message3_3.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3/benchmark_message3_3.pb.go
new file mode 100644
index 000000000..fe4ff23e0
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3/benchmark_message3_3.pb.go
@@ -0,0 +1,6051 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// LINT: ALLOW_GROUPS
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: datasets/google_message3/benchmark_message3_3.proto
+
+package google_message3
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type Message35546 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field35556   *int64                     `protobuf:"varint,1,opt,name=field35556" json:"field35556,omitempty"`
+	Field35557   *int32                     `protobuf:"varint,2,opt,name=field35557" json:"field35557,omitempty"`
+	Field35558   *bool                      `protobuf:"varint,3,opt,name=field35558" json:"field35558,omitempty"`
+	Field35559   *int64                     `protobuf:"varint,13,opt,name=field35559" json:"field35559,omitempty"`
+	Message35547 *Message35546_Message35547 `protobuf:"group,4,opt,name=Message35547,json=message35547" json:"message35547,omitempty"`
+	Message35548 *Message35546_Message35548 `protobuf:"group,10,opt,name=Message35548,json=message35548" json:"message35548,omitempty"`
+	Field35562   *bool                      `protobuf:"varint,14,opt,name=field35562" json:"field35562,omitempty"`
+	Field35563   *bool                      `protobuf:"varint,15,opt,name=field35563" json:"field35563,omitempty"`
+	Field35564   *int32                     `protobuf:"varint,16,opt,name=field35564" json:"field35564,omitempty"`
+	Field35565   *bool                      `protobuf:"varint,17,opt,name=field35565" json:"field35565,omitempty"`
+	Field35566   *bool                      `protobuf:"varint,18,opt,name=field35566" json:"field35566,omitempty"`
+	Field35567   *string                    `protobuf:"bytes,100,opt,name=field35567" json:"field35567,omitempty"`
+}
+
+func (x *Message35546) Reset() {
+	*x = Message35546{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message35546) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message35546) ProtoMessage() {}
+
+func (x *Message35546) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message35546.ProtoReflect.Descriptor instead.
+func (*Message35546) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Message35546) GetField35556() int64 {
+	if x != nil && x.Field35556 != nil {
+		return *x.Field35556
+	}
+	return 0
+}
+
+func (x *Message35546) GetField35557() int32 {
+	if x != nil && x.Field35557 != nil {
+		return *x.Field35557
+	}
+	return 0
+}
+
+func (x *Message35546) GetField35558() bool {
+	if x != nil && x.Field35558 != nil {
+		return *x.Field35558
+	}
+	return false
+}
+
+func (x *Message35546) GetField35559() int64 {
+	if x != nil && x.Field35559 != nil {
+		return *x.Field35559
+	}
+	return 0
+}
+
+func (x *Message35546) GetMessage35547() *Message35546_Message35547 {
+	if x != nil {
+		return x.Message35547
+	}
+	return nil
+}
+
+func (x *Message35546) GetMessage35548() *Message35546_Message35548 {
+	if x != nil {
+		return x.Message35548
+	}
+	return nil
+}
+
+func (x *Message35546) GetField35562() bool {
+	if x != nil && x.Field35562 != nil {
+		return *x.Field35562
+	}
+	return false
+}
+
+func (x *Message35546) GetField35563() bool {
+	if x != nil && x.Field35563 != nil {
+		return *x.Field35563
+	}
+	return false
+}
+
+func (x *Message35546) GetField35564() int32 {
+	if x != nil && x.Field35564 != nil {
+		return *x.Field35564
+	}
+	return 0
+}
+
+func (x *Message35546) GetField35565() bool {
+	if x != nil && x.Field35565 != nil {
+		return *x.Field35565
+	}
+	return false
+}
+
+func (x *Message35546) GetField35566() bool {
+	if x != nil && x.Field35566 != nil {
+		return *x.Field35566
+	}
+	return false
+}
+
+func (x *Message35546) GetField35567() string {
+	if x != nil && x.Field35567 != nil {
+		return *x.Field35567
+	}
+	return ""
+}
+
+type Message2356 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field2368   *Message1374               `protobuf:"bytes,121,opt,name=field2368" json:"field2368,omitempty"`
+	Field2369   *uint64                    `protobuf:"varint,1,opt,name=field2369" json:"field2369,omitempty"`
+	Field2370   *int32                     `protobuf:"varint,2,opt,name=field2370" json:"field2370,omitempty"`
+	Field2371   *int32                     `protobuf:"varint,17,opt,name=field2371" json:"field2371,omitempty"`
+	Field2372   *string                    `protobuf:"bytes,3,req,name=field2372" json:"field2372,omitempty"`
+	Field2373   *int32                     `protobuf:"varint,7,opt,name=field2373" json:"field2373,omitempty"`
+	Field2374   []byte                     `protobuf:"bytes,8,opt,name=field2374" json:"field2374,omitempty"`
+	Field2375   *string                    `protobuf:"bytes,4,opt,name=field2375" json:"field2375,omitempty"`
+	Field2376   *string                    `protobuf:"bytes,101,opt,name=field2376" json:"field2376,omitempty"`
+	Field2377   *int32                     `protobuf:"varint,102,opt,name=field2377" json:"field2377,omitempty"`
+	Field2378   *int32                     `protobuf:"varint,103,opt,name=field2378" json:"field2378,omitempty"`
+	Field2379   *int32                     `protobuf:"varint,104,opt,name=field2379" json:"field2379,omitempty"`
+	Field2380   *int32                     `protobuf:"varint,113,opt,name=field2380" json:"field2380,omitempty"`
+	Field2381   *int32                     `protobuf:"varint,114,opt,name=field2381" json:"field2381,omitempty"`
+	Field2382   *int32                     `protobuf:"varint,115,opt,name=field2382" json:"field2382,omitempty"`
+	Field2383   *int32                     `protobuf:"varint,117,opt,name=field2383" json:"field2383,omitempty"`
+	Field2384   *int32                     `protobuf:"varint,118,opt,name=field2384" json:"field2384,omitempty"`
+	Field2385   *int32                     `protobuf:"varint,119,opt,name=field2385" json:"field2385,omitempty"`
+	Field2386   *int32                     `protobuf:"varint,105,opt,name=field2386" json:"field2386,omitempty"`
+	Field2387   []byte                     `protobuf:"bytes,5,opt,name=field2387" json:"field2387,omitempty"`
+	Message2357 *Message2356_Message2357   `protobuf:"group,6,opt,name=Message2357,json=message2357" json:"message2357,omitempty"`
+	Field2389   *string                    `protobuf:"bytes,120,opt,name=field2389" json:"field2389,omitempty"`
+	Message2358 *Message2356_Message2358   `protobuf:"group,107,opt,name=Message2358,json=message2358" json:"message2358,omitempty"`
+	Message2359 []*Message2356_Message2359 `protobuf:"group,40,rep,name=Message2359,json=message2359" json:"message2359,omitempty"`
+	Field2392   *int32                     `protobuf:"varint,50,opt,name=field2392" json:"field2392,omitempty"`
+	Field2393   *UnusedEmptyMessage        `protobuf:"bytes,60,opt,name=field2393" json:"field2393,omitempty"`
+	Field2394   *UnusedEmptyMessage        `protobuf:"bytes,70,opt,name=field2394" json:"field2394,omitempty"`
+	Field2395   *UnusedEmptyMessage        `protobuf:"bytes,80,opt,name=field2395" json:"field2395,omitempty"`
+	Field2396   *UnusedEmptyMessage        `protobuf:"bytes,90,opt,name=field2396" json:"field2396,omitempty"`
+	Field2397   *string                    `protobuf:"bytes,100,opt,name=field2397" json:"field2397,omitempty"`
+	Field2398   *string                    `protobuf:"bytes,123,opt,name=field2398" json:"field2398,omitempty"`
+}
+
+func (x *Message2356) Reset() {
+	*x = Message2356{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message2356) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message2356) ProtoMessage() {}
+
+func (x *Message2356) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message2356.ProtoReflect.Descriptor instead.
+func (*Message2356) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *Message2356) GetField2368() *Message1374 {
+	if x != nil {
+		return x.Field2368
+	}
+	return nil
+}
+
+func (x *Message2356) GetField2369() uint64 {
+	if x != nil && x.Field2369 != nil {
+		return *x.Field2369
+	}
+	return 0
+}
+
+func (x *Message2356) GetField2370() int32 {
+	if x != nil && x.Field2370 != nil {
+		return *x.Field2370
+	}
+	return 0
+}
+
+func (x *Message2356) GetField2371() int32 {
+	if x != nil && x.Field2371 != nil {
+		return *x.Field2371
+	}
+	return 0
+}
+
+func (x *Message2356) GetField2372() string {
+	if x != nil && x.Field2372 != nil {
+		return *x.Field2372
+	}
+	return ""
+}
+
+func (x *Message2356) GetField2373() int32 {
+	if x != nil && x.Field2373 != nil {
+		return *x.Field2373
+	}
+	return 0
+}
+
+func (x *Message2356) GetField2374() []byte {
+	if x != nil {
+		return x.Field2374
+	}
+	return nil
+}
+
+func (x *Message2356) GetField2375() string {
+	if x != nil && x.Field2375 != nil {
+		return *x.Field2375
+	}
+	return ""
+}
+
+func (x *Message2356) GetField2376() string {
+	if x != nil && x.Field2376 != nil {
+		return *x.Field2376
+	}
+	return ""
+}
+
+func (x *Message2356) GetField2377() int32 {
+	if x != nil && x.Field2377 != nil {
+		return *x.Field2377
+	}
+	return 0
+}
+
+func (x *Message2356) GetField2378() int32 {
+	if x != nil && x.Field2378 != nil {
+		return *x.Field2378
+	}
+	return 0
+}
+
+func (x *Message2356) GetField2379() int32 {
+	if x != nil && x.Field2379 != nil {
+		return *x.Field2379
+	}
+	return 0
+}
+
+func (x *Message2356) GetField2380() int32 {
+	if x != nil && x.Field2380 != nil {
+		return *x.Field2380
+	}
+	return 0
+}
+
+func (x *Message2356) GetField2381() int32 {
+	if x != nil && x.Field2381 != nil {
+		return *x.Field2381
+	}
+	return 0
+}
+
+func (x *Message2356) GetField2382() int32 {
+	if x != nil && x.Field2382 != nil {
+		return *x.Field2382
+	}
+	return 0
+}
+
+func (x *Message2356) GetField2383() int32 {
+	if x != nil && x.Field2383 != nil {
+		return *x.Field2383
+	}
+	return 0
+}
+
+func (x *Message2356) GetField2384() int32 {
+	if x != nil && x.Field2384 != nil {
+		return *x.Field2384
+	}
+	return 0
+}
+
+func (x *Message2356) GetField2385() int32 {
+	if x != nil && x.Field2385 != nil {
+		return *x.Field2385
+	}
+	return 0
+}
+
+func (x *Message2356) GetField2386() int32 {
+	if x != nil && x.Field2386 != nil {
+		return *x.Field2386
+	}
+	return 0
+}
+
+func (x *Message2356) GetField2387() []byte {
+	if x != nil {
+		return x.Field2387
+	}
+	return nil
+}
+
+func (x *Message2356) GetMessage2357() *Message2356_Message2357 {
+	if x != nil {
+		return x.Message2357
+	}
+	return nil
+}
+
+func (x *Message2356) GetField2389() string {
+	if x != nil && x.Field2389 != nil {
+		return *x.Field2389
+	}
+	return ""
+}
+
+func (x *Message2356) GetMessage2358() *Message2356_Message2358 {
+	if x != nil {
+		return x.Message2358
+	}
+	return nil
+}
+
+func (x *Message2356) GetMessage2359() []*Message2356_Message2359 {
+	if x != nil {
+		return x.Message2359
+	}
+	return nil
+}
+
+func (x *Message2356) GetField2392() int32 {
+	if x != nil && x.Field2392 != nil {
+		return *x.Field2392
+	}
+	return 0
+}
+
+func (x *Message2356) GetField2393() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field2393
+	}
+	return nil
+}
+
+func (x *Message2356) GetField2394() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field2394
+	}
+	return nil
+}
+
+func (x *Message2356) GetField2395() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field2395
+	}
+	return nil
+}
+
+func (x *Message2356) GetField2396() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field2396
+	}
+	return nil
+}
+
+func (x *Message2356) GetField2397() string {
+	if x != nil && x.Field2397 != nil {
+		return *x.Field2397
+	}
+	return ""
+}
+
+func (x *Message2356) GetField2398() string {
+	if x != nil && x.Field2398 != nil {
+		return *x.Field2398
+	}
+	return ""
+}
+
+type Message7029 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field7183   *int32                     `protobuf:"varint,1,req,name=field7183" json:"field7183,omitempty"`
+	Field7184   *int32                     `protobuf:"varint,2,opt,name=field7184" json:"field7184,omitempty"`
+	Field7185   *int32                     `protobuf:"varint,3,opt,name=field7185" json:"field7185,omitempty"`
+	Field7186   *int32                     `protobuf:"varint,4,opt,name=field7186" json:"field7186,omitempty"`
+	Field7187   *int32                     `protobuf:"varint,5,opt,name=field7187" json:"field7187,omitempty"`
+	Field7188   *int32                     `protobuf:"varint,6,opt,name=field7188" json:"field7188,omitempty"`
+	Field7189   *int32                     `protobuf:"varint,17,opt,name=field7189" json:"field7189,omitempty"`
+	Field7190   *int32                     `protobuf:"varint,18,opt,name=field7190" json:"field7190,omitempty"`
+	Field7191   *int32                     `protobuf:"varint,49,opt,name=field7191" json:"field7191,omitempty"`
+	Field7192   *int32                     `protobuf:"varint,28,opt,name=field7192" json:"field7192,omitempty"`
+	Field7193   *int32                     `protobuf:"varint,33,opt,name=field7193" json:"field7193,omitempty"`
+	Field7194   *int32                     `protobuf:"varint,25,opt,name=field7194" json:"field7194,omitempty"`
+	Field7195   *int32                     `protobuf:"varint,26,opt,name=field7195" json:"field7195,omitempty"`
+	Field7196   *int32                     `protobuf:"varint,40,opt,name=field7196" json:"field7196,omitempty"`
+	Field7197   *int32                     `protobuf:"varint,41,opt,name=field7197" json:"field7197,omitempty"`
+	Field7198   *int32                     `protobuf:"varint,42,opt,name=field7198" json:"field7198,omitempty"`
+	Field7199   *int32                     `protobuf:"varint,43,opt,name=field7199" json:"field7199,omitempty"`
+	Field7200   *int32                     `protobuf:"varint,19,opt,name=field7200" json:"field7200,omitempty"`
+	Field7201   *int32                     `protobuf:"varint,7,opt,name=field7201" json:"field7201,omitempty"`
+	Field7202   *int32                     `protobuf:"varint,8,opt,name=field7202" json:"field7202,omitempty"`
+	Field7203   *int32                     `protobuf:"varint,9,opt,name=field7203" json:"field7203,omitempty"`
+	Field7204   *int32                     `protobuf:"varint,10,opt,name=field7204" json:"field7204,omitempty"`
+	Field7205   *int32                     `protobuf:"varint,11,opt,name=field7205" json:"field7205,omitempty"`
+	Field7206   *int32                     `protobuf:"varint,12,opt,name=field7206" json:"field7206,omitempty"`
+	Message7030 []*Message7029_Message7030 `protobuf:"group,13,rep,name=Message7030,json=message7030" json:"message7030,omitempty"`
+	Message7031 []*Message7029_Message7031 `protobuf:"group,21,rep,name=Message7031,json=message7031" json:"message7031,omitempty"`
+	Field7209   *int32                     `protobuf:"varint,20,opt,name=field7209" json:"field7209,omitempty"`
+	Field7210   *float32                   `protobuf:"fixed32,27,opt,name=field7210" json:"field7210,omitempty"`
+	Field7211   *int32                     `protobuf:"varint,29,opt,name=field7211" json:"field7211,omitempty"`
+	Field7212   *int32                     `protobuf:"varint,32,opt,name=field7212" json:"field7212,omitempty"`
+	Field7213   *string                    `protobuf:"bytes,48,opt,name=field7213" json:"field7213,omitempty"`
+	Field7214   *bool                      `protobuf:"varint,34,opt,name=field7214" json:"field7214,omitempty"`
+	Field7215   *int32                     `protobuf:"varint,36,opt,name=field7215" json:"field7215,omitempty"`
+	Field7216   *float32                   `protobuf:"fixed32,37,opt,name=field7216" json:"field7216,omitempty"`
+	Field7217   *bool                      `protobuf:"varint,38,opt,name=field7217" json:"field7217,omitempty"`
+	Field7218   *bool                      `protobuf:"varint,39,opt,name=field7218" json:"field7218,omitempty"`
+	Field7219   *UnusedEmptyMessage        `protobuf:"bytes,44,opt,name=field7219" json:"field7219,omitempty"`
+	Field7220   *int32                     `protobuf:"varint,45,opt,name=field7220" json:"field7220,omitempty"`
+	Field7221   *int32                     `protobuf:"varint,46,opt,name=field7221" json:"field7221,omitempty"`
+	Field7222   *int32                     `protobuf:"varint,47,opt,name=field7222" json:"field7222,omitempty"`
+	Field7223   *UnusedEmptyMessage        `protobuf:"bytes,50,opt,name=field7223" json:"field7223,omitempty"`
+	Field7224   *int32                     `protobuf:"varint,51,opt,name=field7224" json:"field7224,omitempty"`
+}
+
+func (x *Message7029) Reset() {
+	*x = Message7029{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message7029) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message7029) ProtoMessage() {}
+
+func (x *Message7029) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message7029.ProtoReflect.Descriptor instead.
+func (*Message7029) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *Message7029) GetField7183() int32 {
+	if x != nil && x.Field7183 != nil {
+		return *x.Field7183
+	}
+	return 0
+}
+
+func (x *Message7029) GetField7184() int32 {
+	if x != nil && x.Field7184 != nil {
+		return *x.Field7184
+	}
+	return 0
+}
+
+func (x *Message7029) GetField7185() int32 {
+	if x != nil && x.Field7185 != nil {
+		return *x.Field7185
+	}
+	return 0
+}
+
+func (x *Message7029) GetField7186() int32 {
+	if x != nil && x.Field7186 != nil {
+		return *x.Field7186
+	}
+	return 0
+}
+
+func (x *Message7029) GetField7187() int32 {
+	if x != nil && x.Field7187 != nil {
+		return *x.Field7187
+	}
+	return 0
+}
+
+func (x *Message7029) GetField7188() int32 {
+	if x != nil && x.Field7188 != nil {
+		return *x.Field7188
+	}
+	return 0
+}
+
+func (x *Message7029) GetField7189() int32 {
+	if x != nil && x.Field7189 != nil {
+		return *x.Field7189
+	}
+	return 0
+}
+
+func (x *Message7029) GetField7190() int32 {
+	if x != nil && x.Field7190 != nil {
+		return *x.Field7190
+	}
+	return 0
+}
+
+func (x *Message7029) GetField7191() int32 {
+	if x != nil && x.Field7191 != nil {
+		return *x.Field7191
+	}
+	return 0
+}
+
+func (x *Message7029) GetField7192() int32 {
+	if x != nil && x.Field7192 != nil {
+		return *x.Field7192
+	}
+	return 0
+}
+
+func (x *Message7029) GetField7193() int32 {
+	if x != nil && x.Field7193 != nil {
+		return *x.Field7193
+	}
+	return 0
+}
+
+func (x *Message7029) GetField7194() int32 {
+	if x != nil && x.Field7194 != nil {
+		return *x.Field7194
+	}
+	return 0
+}
+
+func (x *Message7029) GetField7195() int32 {
+	if x != nil && x.Field7195 != nil {
+		return *x.Field7195
+	}
+	return 0
+}
+
+func (x *Message7029) GetField7196() int32 {
+	if x != nil && x.Field7196 != nil {
+		return *x.Field7196
+	}
+	return 0
+}
+
+func (x *Message7029) GetField7197() int32 {
+	if x != nil && x.Field7197 != nil {
+		return *x.Field7197
+	}
+	return 0
+}
+
+func (x *Message7029) GetField7198() int32 {
+	if x != nil && x.Field7198 != nil {
+		return *x.Field7198
+	}
+	return 0
+}
+
+func (x *Message7029) GetField7199() int32 {
+	if x != nil && x.Field7199 != nil {
+		return *x.Field7199
+	}
+	return 0
+}
+
+func (x *Message7029) GetField7200() int32 {
+	if x != nil && x.Field7200 != nil {
+		return *x.Field7200
+	}
+	return 0
+}
+
+func (x *Message7029) GetField7201() int32 {
+	if x != nil && x.Field7201 != nil {
+		return *x.Field7201
+	}
+	return 0
+}
+
+func (x *Message7029) GetField7202() int32 {
+	if x != nil && x.Field7202 != nil {
+		return *x.Field7202
+	}
+	return 0
+}
+
+func (x *Message7029) GetField7203() int32 {
+	if x != nil && x.Field7203 != nil {
+		return *x.Field7203
+	}
+	return 0
+}
+
+func (x *Message7029) GetField7204() int32 {
+	if x != nil && x.Field7204 != nil {
+		return *x.Field7204
+	}
+	return 0
+}
+
+func (x *Message7029) GetField7205() int32 {
+	if x != nil && x.Field7205 != nil {
+		return *x.Field7205
+	}
+	return 0
+}
+
+func (x *Message7029) GetField7206() int32 {
+	if x != nil && x.Field7206 != nil {
+		return *x.Field7206
+	}
+	return 0
+}
+
+func (x *Message7029) GetMessage7030() []*Message7029_Message7030 {
+	if x != nil {
+		return x.Message7030
+	}
+	return nil
+}
+
+func (x *Message7029) GetMessage7031() []*Message7029_Message7031 {
+	if x != nil {
+		return x.Message7031
+	}
+	return nil
+}
+
+func (x *Message7029) GetField7209() int32 {
+	if x != nil && x.Field7209 != nil {
+		return *x.Field7209
+	}
+	return 0
+}
+
+func (x *Message7029) GetField7210() float32 {
+	if x != nil && x.Field7210 != nil {
+		return *x.Field7210
+	}
+	return 0
+}
+
+func (x *Message7029) GetField7211() int32 {
+	if x != nil && x.Field7211 != nil {
+		return *x.Field7211
+	}
+	return 0
+}
+
+func (x *Message7029) GetField7212() int32 {
+	if x != nil && x.Field7212 != nil {
+		return *x.Field7212
+	}
+	return 0
+}
+
+func (x *Message7029) GetField7213() string {
+	if x != nil && x.Field7213 != nil {
+		return *x.Field7213
+	}
+	return ""
+}
+
+func (x *Message7029) GetField7214() bool {
+	if x != nil && x.Field7214 != nil {
+		return *x.Field7214
+	}
+	return false
+}
+
+func (x *Message7029) GetField7215() int32 {
+	if x != nil && x.Field7215 != nil {
+		return *x.Field7215
+	}
+	return 0
+}
+
+func (x *Message7029) GetField7216() float32 {
+	if x != nil && x.Field7216 != nil {
+		return *x.Field7216
+	}
+	return 0
+}
+
+func (x *Message7029) GetField7217() bool {
+	if x != nil && x.Field7217 != nil {
+		return *x.Field7217
+	}
+	return false
+}
+
+func (x *Message7029) GetField7218() bool {
+	if x != nil && x.Field7218 != nil {
+		return *x.Field7218
+	}
+	return false
+}
+
+func (x *Message7029) GetField7219() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field7219
+	}
+	return nil
+}
+
+func (x *Message7029) GetField7220() int32 {
+	if x != nil && x.Field7220 != nil {
+		return *x.Field7220
+	}
+	return 0
+}
+
+func (x *Message7029) GetField7221() int32 {
+	if x != nil && x.Field7221 != nil {
+		return *x.Field7221
+	}
+	return 0
+}
+
+func (x *Message7029) GetField7222() int32 {
+	if x != nil && x.Field7222 != nil {
+		return *x.Field7222
+	}
+	return 0
+}
+
+func (x *Message7029) GetField7223() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field7223
+	}
+	return nil
+}
+
+func (x *Message7029) GetField7224() int32 {
+	if x != nil && x.Field7224 != nil {
+		return *x.Field7224
+	}
+	return 0
+}
+
+type Message35538 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field35539 *int64 `protobuf:"varint,1,req,name=field35539" json:"field35539,omitempty"`
+}
+
+func (x *Message35538) Reset() {
+	*x = Message35538{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message35538) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message35538) ProtoMessage() {}
+
+func (x *Message35538) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message35538.ProtoReflect.Descriptor instead.
+func (*Message35538) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *Message35538) GetField35539() int64 {
+	if x != nil && x.Field35539 != nil {
+		return *x.Field35539
+	}
+	return 0
+}
+
+type Message18921 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field18946   *string                      `protobuf:"bytes,1,opt,name=field18946" json:"field18946,omitempty"`
+	Field18947   *uint64                      `protobuf:"fixed64,2,opt,name=field18947" json:"field18947,omitempty"`
+	Field18948   *int32                       `protobuf:"varint,3,opt,name=field18948" json:"field18948,omitempty"`
+	Field18949   *float64                     `protobuf:"fixed64,4,opt,name=field18949" json:"field18949,omitempty"`
+	Field18950   *bool                        `protobuf:"varint,17,opt,name=field18950" json:"field18950,omitempty"`
+	Field18951   *bool                        `protobuf:"varint,23,opt,name=field18951" json:"field18951,omitempty"`
+	Field18952   *UnusedEmptyMessage          `protobuf:"bytes,24,opt,name=field18952" json:"field18952,omitempty"`
+	Message18922 []*Message18921_Message18922 `protobuf:"group,5,rep,name=Message18922,json=message18922" json:"message18922,omitempty"`
+	Field18954   []*UnusedEmptyMessage        `protobuf:"bytes,29,rep,name=field18954" json:"field18954,omitempty"`
+	Field18955   []*Message18943              `protobuf:"bytes,30,rep,name=field18955" json:"field18955,omitempty"`
+	Field18956   []*Message18944              `protobuf:"bytes,31,rep,name=field18956" json:"field18956,omitempty"`
+	Field18957   []*UnusedEmptyMessage        `protobuf:"bytes,32,rep,name=field18957" json:"field18957,omitempty"`
+}
+
+func (x *Message18921) Reset() {
+	*x = Message18921{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message18921) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message18921) ProtoMessage() {}
+
+func (x *Message18921) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message18921.ProtoReflect.Descriptor instead.
+func (*Message18921) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *Message18921) GetField18946() string {
+	if x != nil && x.Field18946 != nil {
+		return *x.Field18946
+	}
+	return ""
+}
+
+func (x *Message18921) GetField18947() uint64 {
+	if x != nil && x.Field18947 != nil {
+		return *x.Field18947
+	}
+	return 0
+}
+
+func (x *Message18921) GetField18948() int32 {
+	if x != nil && x.Field18948 != nil {
+		return *x.Field18948
+	}
+	return 0
+}
+
+func (x *Message18921) GetField18949() float64 {
+	if x != nil && x.Field18949 != nil {
+		return *x.Field18949
+	}
+	return 0
+}
+
+func (x *Message18921) GetField18950() bool {
+	if x != nil && x.Field18950 != nil {
+		return *x.Field18950
+	}
+	return false
+}
+
+func (x *Message18921) GetField18951() bool {
+	if x != nil && x.Field18951 != nil {
+		return *x.Field18951
+	}
+	return false
+}
+
+func (x *Message18921) GetField18952() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18952
+	}
+	return nil
+}
+
+func (x *Message18921) GetMessage18922() []*Message18921_Message18922 {
+	if x != nil {
+		return x.Message18922
+	}
+	return nil
+}
+
+func (x *Message18921) GetField18954() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18954
+	}
+	return nil
+}
+
+func (x *Message18921) GetField18955() []*Message18943 {
+	if x != nil {
+		return x.Field18955
+	}
+	return nil
+}
+
+func (x *Message18921) GetField18956() []*Message18944 {
+	if x != nil {
+		return x.Field18956
+	}
+	return nil
+}
+
+func (x *Message18921) GetField18957() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18957
+	}
+	return nil
+}
+
+type Message35540 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field35541 *bool `protobuf:"varint,1,opt,name=field35541" json:"field35541,omitempty"`
+}
+
+func (x *Message35540) Reset() {
+	*x = Message35540{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[5]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message35540) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message35540) ProtoMessage() {}
+
+func (x *Message35540) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[5]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message35540.ProtoReflect.Descriptor instead.
+func (*Message35540) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *Message35540) GetField35541() bool {
+	if x != nil && x.Field35541 != nil {
+		return *x.Field35541
+	}
+	return false
+}
+
+type Message3886 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Message3887 []*Message3886_Message3887 `protobuf:"group,1,rep,name=Message3887,json=message3887" json:"message3887,omitempty"`
+}
+
+func (x *Message3886) Reset() {
+	*x = Message3886{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[6]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message3886) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message3886) ProtoMessage() {}
+
+func (x *Message3886) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[6]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message3886.ProtoReflect.Descriptor instead.
+func (*Message3886) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *Message3886) GetMessage3887() []*Message3886_Message3887 {
+	if x != nil {
+		return x.Message3887
+	}
+	return nil
+}
+
+type Message6743 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field6759 *Message6721 `protobuf:"bytes,1,opt,name=field6759" json:"field6759,omitempty"`
+	Field6760 *Message6723 `protobuf:"bytes,2,opt,name=field6760" json:"field6760,omitempty"`
+	Field6761 *Message6723 `protobuf:"bytes,8,opt,name=field6761" json:"field6761,omitempty"`
+	Field6762 *Message6725 `protobuf:"bytes,3,opt,name=field6762" json:"field6762,omitempty"`
+	Field6763 *Message6726 `protobuf:"bytes,4,opt,name=field6763" json:"field6763,omitempty"`
+	Field6764 *Message6733 `protobuf:"bytes,5,opt,name=field6764" json:"field6764,omitempty"`
+	Field6765 *Message6734 `protobuf:"bytes,6,opt,name=field6765" json:"field6765,omitempty"`
+	Field6766 *Message6742 `protobuf:"bytes,7,opt,name=field6766" json:"field6766,omitempty"`
+}
+
+func (x *Message6743) Reset() {
+	*x = Message6743{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[7]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6743) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6743) ProtoMessage() {}
+
+func (x *Message6743) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[7]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6743.ProtoReflect.Descriptor instead.
+func (*Message6743) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *Message6743) GetField6759() *Message6721 {
+	if x != nil {
+		return x.Field6759
+	}
+	return nil
+}
+
+func (x *Message6743) GetField6760() *Message6723 {
+	if x != nil {
+		return x.Field6760
+	}
+	return nil
+}
+
+func (x *Message6743) GetField6761() *Message6723 {
+	if x != nil {
+		return x.Field6761
+	}
+	return nil
+}
+
+func (x *Message6743) GetField6762() *Message6725 {
+	if x != nil {
+		return x.Field6762
+	}
+	return nil
+}
+
+func (x *Message6743) GetField6763() *Message6726 {
+	if x != nil {
+		return x.Field6763
+	}
+	return nil
+}
+
+func (x *Message6743) GetField6764() *Message6733 {
+	if x != nil {
+		return x.Field6764
+	}
+	return nil
+}
+
+func (x *Message6743) GetField6765() *Message6734 {
+	if x != nil {
+		return x.Field6765
+	}
+	return nil
+}
+
+func (x *Message6743) GetField6766() *Message6742 {
+	if x != nil {
+		return x.Field6766
+	}
+	return nil
+}
+
+type Message6773 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field6794 *Enum6769   `protobuf:"varint,1,opt,name=field6794,enum=benchmarks.google_message3.Enum6769" json:"field6794,omitempty"`
+	Field6795 *int32      `protobuf:"varint,9,opt,name=field6795" json:"field6795,omitempty"`
+	Field6796 *UnusedEnum `protobuf:"varint,10,opt,name=field6796,enum=benchmarks.google_message3.UnusedEnum" json:"field6796,omitempty"`
+	Field6797 *int32      `protobuf:"varint,11,opt,name=field6797" json:"field6797,omitempty"`
+	Field6798 *int32      `protobuf:"varint,2,opt,name=field6798" json:"field6798,omitempty"`
+	Field6799 *Enum6774   `protobuf:"varint,3,opt,name=field6799,enum=benchmarks.google_message3.Enum6774" json:"field6799,omitempty"`
+	Field6800 *float64    `protobuf:"fixed64,5,opt,name=field6800" json:"field6800,omitempty"`
+	Field6801 *float64    `protobuf:"fixed64,7,opt,name=field6801" json:"field6801,omitempty"`
+	Field6802 *float64    `protobuf:"fixed64,8,opt,name=field6802" json:"field6802,omitempty"`
+	Field6803 *Enum6782   `protobuf:"varint,6,opt,name=field6803,enum=benchmarks.google_message3.Enum6782" json:"field6803,omitempty"`
+}
+
+func (x *Message6773) Reset() {
+	*x = Message6773{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[8]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6773) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6773) ProtoMessage() {}
+
+func (x *Message6773) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[8]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6773.ProtoReflect.Descriptor instead.
+func (*Message6773) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *Message6773) GetField6794() Enum6769 {
+	if x != nil && x.Field6794 != nil {
+		return *x.Field6794
+	}
+	return Enum6769_ENUM_VALUE6770
+}
+
+func (x *Message6773) GetField6795() int32 {
+	if x != nil && x.Field6795 != nil {
+		return *x.Field6795
+	}
+	return 0
+}
+
+func (x *Message6773) GetField6796() UnusedEnum {
+	if x != nil && x.Field6796 != nil {
+		return *x.Field6796
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+func (x *Message6773) GetField6797() int32 {
+	if x != nil && x.Field6797 != nil {
+		return *x.Field6797
+	}
+	return 0
+}
+
+func (x *Message6773) GetField6798() int32 {
+	if x != nil && x.Field6798 != nil {
+		return *x.Field6798
+	}
+	return 0
+}
+
+func (x *Message6773) GetField6799() Enum6774 {
+	if x != nil && x.Field6799 != nil {
+		return *x.Field6799
+	}
+	return Enum6774_ENUM_VALUE6775
+}
+
+func (x *Message6773) GetField6800() float64 {
+	if x != nil && x.Field6800 != nil {
+		return *x.Field6800
+	}
+	return 0
+}
+
+func (x *Message6773) GetField6801() float64 {
+	if x != nil && x.Field6801 != nil {
+		return *x.Field6801
+	}
+	return 0
+}
+
+func (x *Message6773) GetField6802() float64 {
+	if x != nil && x.Field6802 != nil {
+		return *x.Field6802
+	}
+	return 0
+}
+
+func (x *Message6773) GetField6803() Enum6782 {
+	if x != nil && x.Field6803 != nil {
+		return *x.Field6803
+	}
+	return Enum6782_ENUM_VALUE6783
+}
+
+type Message8224 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field8255 *UnusedEmptyMessage   `protobuf:"bytes,1,opt,name=field8255" json:"field8255,omitempty"`
+	Field8256 *Message8184          `protobuf:"bytes,2,opt,name=field8256" json:"field8256,omitempty"`
+	Field8257 *Message7966          `protobuf:"bytes,3,opt,name=field8257" json:"field8257,omitempty"`
+	Field8258 *string               `protobuf:"bytes,4,opt,name=field8258" json:"field8258,omitempty"`
+	Field8259 *string               `protobuf:"bytes,5,opt,name=field8259" json:"field8259,omitempty"`
+	Field8260 *bool                 `protobuf:"varint,6,opt,name=field8260" json:"field8260,omitempty"`
+	Field8261 *int64                `protobuf:"varint,7,opt,name=field8261" json:"field8261,omitempty"`
+	Field8262 *string               `protobuf:"bytes,8,opt,name=field8262" json:"field8262,omitempty"`
+	Field8263 *int64                `protobuf:"varint,9,opt,name=field8263" json:"field8263,omitempty"`
+	Field8264 *float64              `protobuf:"fixed64,10,opt,name=field8264" json:"field8264,omitempty"`
+	Field8265 *int64                `protobuf:"varint,11,opt,name=field8265" json:"field8265,omitempty"`
+	Field8266 []string              `protobuf:"bytes,12,rep,name=field8266" json:"field8266,omitempty"`
+	Field8267 *int64                `protobuf:"varint,13,opt,name=field8267" json:"field8267,omitempty"`
+	Field8268 *int32                `protobuf:"varint,14,opt,name=field8268" json:"field8268,omitempty"`
+	Field8269 *int32                `protobuf:"varint,15,opt,name=field8269" json:"field8269,omitempty"`
+	Field8270 *int64                `protobuf:"varint,16,opt,name=field8270" json:"field8270,omitempty"`
+	Field8271 *float64              `protobuf:"fixed64,17,opt,name=field8271" json:"field8271,omitempty"`
+	Field8272 *UnusedEmptyMessage   `protobuf:"bytes,18,opt,name=field8272" json:"field8272,omitempty"`
+	Field8273 *UnusedEmptyMessage   `protobuf:"bytes,19,opt,name=field8273" json:"field8273,omitempty"`
+	Field8274 []*UnusedEmptyMessage `protobuf:"bytes,20,rep,name=field8274" json:"field8274,omitempty"`
+	Field8275 *bool                 `protobuf:"varint,21,opt,name=field8275" json:"field8275,omitempty"`
+	Field8276 *UnusedEmptyMessage   `protobuf:"bytes,22,opt,name=field8276" json:"field8276,omitempty"`
+	Field8277 *UnusedEmptyMessage   `protobuf:"bytes,23,opt,name=field8277" json:"field8277,omitempty"`
+	Field8278 []*UnusedEmptyMessage `protobuf:"bytes,24,rep,name=field8278" json:"field8278,omitempty"`
+	Field8279 *UnusedEmptyMessage   `protobuf:"bytes,25,opt,name=field8279" json:"field8279,omitempty"`
+	Field8280 *bool                 `protobuf:"varint,26,opt,name=field8280" json:"field8280,omitempty"`
+	Field8281 []*UnusedEmptyMessage `protobuf:"bytes,27,rep,name=field8281" json:"field8281,omitempty"`
+}
+
+func (x *Message8224) Reset() {
+	*x = Message8224{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[9]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8224) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8224) ProtoMessage() {}
+
+func (x *Message8224) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[9]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8224.ProtoReflect.Descriptor instead.
+func (*Message8224) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{9}
+}
+
+func (x *Message8224) GetField8255() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8255
+	}
+	return nil
+}
+
+func (x *Message8224) GetField8256() *Message8184 {
+	if x != nil {
+		return x.Field8256
+	}
+	return nil
+}
+
+func (x *Message8224) GetField8257() *Message7966 {
+	if x != nil {
+		return x.Field8257
+	}
+	return nil
+}
+
+func (x *Message8224) GetField8258() string {
+	if x != nil && x.Field8258 != nil {
+		return *x.Field8258
+	}
+	return ""
+}
+
+func (x *Message8224) GetField8259() string {
+	if x != nil && x.Field8259 != nil {
+		return *x.Field8259
+	}
+	return ""
+}
+
+func (x *Message8224) GetField8260() bool {
+	if x != nil && x.Field8260 != nil {
+		return *x.Field8260
+	}
+	return false
+}
+
+func (x *Message8224) GetField8261() int64 {
+	if x != nil && x.Field8261 != nil {
+		return *x.Field8261
+	}
+	return 0
+}
+
+func (x *Message8224) GetField8262() string {
+	if x != nil && x.Field8262 != nil {
+		return *x.Field8262
+	}
+	return ""
+}
+
+func (x *Message8224) GetField8263() int64 {
+	if x != nil && x.Field8263 != nil {
+		return *x.Field8263
+	}
+	return 0
+}
+
+func (x *Message8224) GetField8264() float64 {
+	if x != nil && x.Field8264 != nil {
+		return *x.Field8264
+	}
+	return 0
+}
+
+func (x *Message8224) GetField8265() int64 {
+	if x != nil && x.Field8265 != nil {
+		return *x.Field8265
+	}
+	return 0
+}
+
+func (x *Message8224) GetField8266() []string {
+	if x != nil {
+		return x.Field8266
+	}
+	return nil
+}
+
+func (x *Message8224) GetField8267() int64 {
+	if x != nil && x.Field8267 != nil {
+		return *x.Field8267
+	}
+	return 0
+}
+
+func (x *Message8224) GetField8268() int32 {
+	if x != nil && x.Field8268 != nil {
+		return *x.Field8268
+	}
+	return 0
+}
+
+func (x *Message8224) GetField8269() int32 {
+	if x != nil && x.Field8269 != nil {
+		return *x.Field8269
+	}
+	return 0
+}
+
+func (x *Message8224) GetField8270() int64 {
+	if x != nil && x.Field8270 != nil {
+		return *x.Field8270
+	}
+	return 0
+}
+
+func (x *Message8224) GetField8271() float64 {
+	if x != nil && x.Field8271 != nil {
+		return *x.Field8271
+	}
+	return 0
+}
+
+func (x *Message8224) GetField8272() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8272
+	}
+	return nil
+}
+
+func (x *Message8224) GetField8273() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8273
+	}
+	return nil
+}
+
+func (x *Message8224) GetField8274() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8274
+	}
+	return nil
+}
+
+func (x *Message8224) GetField8275() bool {
+	if x != nil && x.Field8275 != nil {
+		return *x.Field8275
+	}
+	return false
+}
+
+func (x *Message8224) GetField8276() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8276
+	}
+	return nil
+}
+
+func (x *Message8224) GetField8277() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8277
+	}
+	return nil
+}
+
+func (x *Message8224) GetField8278() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8278
+	}
+	return nil
+}
+
+func (x *Message8224) GetField8279() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8279
+	}
+	return nil
+}
+
+func (x *Message8224) GetField8280() bool {
+	if x != nil && x.Field8280 != nil {
+		return *x.Field8280
+	}
+	return false
+}
+
+func (x *Message8224) GetField8281() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8281
+	}
+	return nil
+}
+
+type Message8392 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field8395 *string      `protobuf:"bytes,1,opt,name=field8395" json:"field8395,omitempty"`
+	Field8396 *string      `protobuf:"bytes,2,opt,name=field8396" json:"field8396,omitempty"`
+	Field8397 *Message7966 `protobuf:"bytes,3,opt,name=field8397" json:"field8397,omitempty"`
+	Field8398 *string      `protobuf:"bytes,4,opt,name=field8398" json:"field8398,omitempty"`
+	Field8399 *string      `protobuf:"bytes,5,opt,name=field8399" json:"field8399,omitempty"`
+	Field8400 *string      `protobuf:"bytes,6,opt,name=field8400" json:"field8400,omitempty"`
+	Field8401 *string      `protobuf:"bytes,7,opt,name=field8401" json:"field8401,omitempty"`
+	Field8402 *string      `protobuf:"bytes,8,opt,name=field8402" json:"field8402,omitempty"`
+	Field8403 *string      `protobuf:"bytes,9,opt,name=field8403" json:"field8403,omitempty"`
+}
+
+func (x *Message8392) Reset() {
+	*x = Message8392{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[10]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8392) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8392) ProtoMessage() {}
+
+func (x *Message8392) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[10]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8392.ProtoReflect.Descriptor instead.
+func (*Message8392) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{10}
+}
+
+func (x *Message8392) GetField8395() string {
+	if x != nil && x.Field8395 != nil {
+		return *x.Field8395
+	}
+	return ""
+}
+
+func (x *Message8392) GetField8396() string {
+	if x != nil && x.Field8396 != nil {
+		return *x.Field8396
+	}
+	return ""
+}
+
+func (x *Message8392) GetField8397() *Message7966 {
+	if x != nil {
+		return x.Field8397
+	}
+	return nil
+}
+
+func (x *Message8392) GetField8398() string {
+	if x != nil && x.Field8398 != nil {
+		return *x.Field8398
+	}
+	return ""
+}
+
+func (x *Message8392) GetField8399() string {
+	if x != nil && x.Field8399 != nil {
+		return *x.Field8399
+	}
+	return ""
+}
+
+func (x *Message8392) GetField8400() string {
+	if x != nil && x.Field8400 != nil {
+		return *x.Field8400
+	}
+	return ""
+}
+
+func (x *Message8392) GetField8401() string {
+	if x != nil && x.Field8401 != nil {
+		return *x.Field8401
+	}
+	return ""
+}
+
+func (x *Message8392) GetField8402() string {
+	if x != nil && x.Field8402 != nil {
+		return *x.Field8402
+	}
+	return ""
+}
+
+func (x *Message8392) GetField8403() string {
+	if x != nil && x.Field8403 != nil {
+		return *x.Field8403
+	}
+	return ""
+}
+
+type Message8130 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field8156 *string               `protobuf:"bytes,1,opt,name=field8156" json:"field8156,omitempty"`
+	Field8157 *string               `protobuf:"bytes,2,opt,name=field8157" json:"field8157,omitempty"`
+	Field8158 *string               `protobuf:"bytes,4,opt,name=field8158" json:"field8158,omitempty"`
+	Field8159 *UnusedEmptyMessage   `protobuf:"bytes,6,opt,name=field8159" json:"field8159,omitempty"`
+	Field8160 []string              `protobuf:"bytes,7,rep,name=field8160" json:"field8160,omitempty"`
+	Field8161 *int64                `protobuf:"varint,8,opt,name=field8161" json:"field8161,omitempty"`
+	Field8162 *UnusedEmptyMessage   `protobuf:"bytes,9,opt,name=field8162" json:"field8162,omitempty"`
+	Field8163 *string               `protobuf:"bytes,10,opt,name=field8163" json:"field8163,omitempty"`
+	Field8164 *string               `protobuf:"bytes,11,opt,name=field8164" json:"field8164,omitempty"`
+	Field8165 *string               `protobuf:"bytes,12,opt,name=field8165" json:"field8165,omitempty"`
+	Field8166 *string               `protobuf:"bytes,13,opt,name=field8166" json:"field8166,omitempty"`
+	Field8167 *UnusedEmptyMessage   `protobuf:"bytes,14,opt,name=field8167" json:"field8167,omitempty"`
+	Field8168 *UnusedEmptyMessage   `protobuf:"bytes,15,opt,name=field8168" json:"field8168,omitempty"`
+	Field8169 *string               `protobuf:"bytes,16,opt,name=field8169" json:"field8169,omitempty"`
+	Field8170 *UnusedEnum           `protobuf:"varint,17,opt,name=field8170,enum=benchmarks.google_message3.UnusedEnum" json:"field8170,omitempty"`
+	Field8171 *UnusedEnum           `protobuf:"varint,18,opt,name=field8171,enum=benchmarks.google_message3.UnusedEnum" json:"field8171,omitempty"`
+	Field8172 *bool                 `protobuf:"varint,19,opt,name=field8172" json:"field8172,omitempty"`
+	Field8173 *bool                 `protobuf:"varint,20,opt,name=field8173" json:"field8173,omitempty"`
+	Field8174 *float64              `protobuf:"fixed64,21,opt,name=field8174" json:"field8174,omitempty"`
+	Field8175 *int32                `protobuf:"varint,22,opt,name=field8175" json:"field8175,omitempty"`
+	Field8176 *int32                `protobuf:"varint,23,opt,name=field8176" json:"field8176,omitempty"`
+	Field8177 *UnusedEmptyMessage   `protobuf:"bytes,24,opt,name=field8177" json:"field8177,omitempty"`
+	Field8178 []*UnusedEmptyMessage `protobuf:"bytes,25,rep,name=field8178" json:"field8178,omitempty"`
+	Field8179 []*UnusedEmptyMessage `protobuf:"bytes,26,rep,name=field8179" json:"field8179,omitempty"`
+}
+
+func (x *Message8130) Reset() {
+	*x = Message8130{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[11]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8130) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8130) ProtoMessage() {}
+
+func (x *Message8130) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[11]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8130.ProtoReflect.Descriptor instead.
+func (*Message8130) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{11}
+}
+
+func (x *Message8130) GetField8156() string {
+	if x != nil && x.Field8156 != nil {
+		return *x.Field8156
+	}
+	return ""
+}
+
+func (x *Message8130) GetField8157() string {
+	if x != nil && x.Field8157 != nil {
+		return *x.Field8157
+	}
+	return ""
+}
+
+func (x *Message8130) GetField8158() string {
+	if x != nil && x.Field8158 != nil {
+		return *x.Field8158
+	}
+	return ""
+}
+
+func (x *Message8130) GetField8159() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8159
+	}
+	return nil
+}
+
+func (x *Message8130) GetField8160() []string {
+	if x != nil {
+		return x.Field8160
+	}
+	return nil
+}
+
+func (x *Message8130) GetField8161() int64 {
+	if x != nil && x.Field8161 != nil {
+		return *x.Field8161
+	}
+	return 0
+}
+
+func (x *Message8130) GetField8162() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8162
+	}
+	return nil
+}
+
+func (x *Message8130) GetField8163() string {
+	if x != nil && x.Field8163 != nil {
+		return *x.Field8163
+	}
+	return ""
+}
+
+func (x *Message8130) GetField8164() string {
+	if x != nil && x.Field8164 != nil {
+		return *x.Field8164
+	}
+	return ""
+}
+
+func (x *Message8130) GetField8165() string {
+	if x != nil && x.Field8165 != nil {
+		return *x.Field8165
+	}
+	return ""
+}
+
+func (x *Message8130) GetField8166() string {
+	if x != nil && x.Field8166 != nil {
+		return *x.Field8166
+	}
+	return ""
+}
+
+func (x *Message8130) GetField8167() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8167
+	}
+	return nil
+}
+
+func (x *Message8130) GetField8168() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8168
+	}
+	return nil
+}
+
+func (x *Message8130) GetField8169() string {
+	if x != nil && x.Field8169 != nil {
+		return *x.Field8169
+	}
+	return ""
+}
+
+func (x *Message8130) GetField8170() UnusedEnum {
+	if x != nil && x.Field8170 != nil {
+		return *x.Field8170
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+func (x *Message8130) GetField8171() UnusedEnum {
+	if x != nil && x.Field8171 != nil {
+		return *x.Field8171
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+func (x *Message8130) GetField8172() bool {
+	if x != nil && x.Field8172 != nil {
+		return *x.Field8172
+	}
+	return false
+}
+
+func (x *Message8130) GetField8173() bool {
+	if x != nil && x.Field8173 != nil {
+		return *x.Field8173
+	}
+	return false
+}
+
+func (x *Message8130) GetField8174() float64 {
+	if x != nil && x.Field8174 != nil {
+		return *x.Field8174
+	}
+	return 0
+}
+
+func (x *Message8130) GetField8175() int32 {
+	if x != nil && x.Field8175 != nil {
+		return *x.Field8175
+	}
+	return 0
+}
+
+func (x *Message8130) GetField8176() int32 {
+	if x != nil && x.Field8176 != nil {
+		return *x.Field8176
+	}
+	return 0
+}
+
+func (x *Message8130) GetField8177() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8177
+	}
+	return nil
+}
+
+func (x *Message8130) GetField8178() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8178
+	}
+	return nil
+}
+
+func (x *Message8130) GetField8179() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8179
+	}
+	return nil
+}
+
+type Message8478 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field8489 *string             `protobuf:"bytes,7,opt,name=field8489" json:"field8489,omitempty"`
+	Field8490 *Message7966        `protobuf:"bytes,1,opt,name=field8490" json:"field8490,omitempty"`
+	Field8491 *Message8476        `protobuf:"bytes,2,opt,name=field8491" json:"field8491,omitempty"`
+	Field8492 *int64              `protobuf:"varint,3,opt,name=field8492" json:"field8492,omitempty"`
+	Field8493 *Message8476        `protobuf:"bytes,4,opt,name=field8493" json:"field8493,omitempty"`
+	Field8494 []*Message8477      `protobuf:"bytes,5,rep,name=field8494" json:"field8494,omitempty"`
+	Field8495 *Message8454        `protobuf:"bytes,6,opt,name=field8495" json:"field8495,omitempty"`
+	Field8496 *UnusedEmptyMessage `protobuf:"bytes,8,opt,name=field8496" json:"field8496,omitempty"`
+}
+
+func (x *Message8478) Reset() {
+	*x = Message8478{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[12]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8478) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8478) ProtoMessage() {}
+
+func (x *Message8478) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[12]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8478.ProtoReflect.Descriptor instead.
+func (*Message8478) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{12}
+}
+
+func (x *Message8478) GetField8489() string {
+	if x != nil && x.Field8489 != nil {
+		return *x.Field8489
+	}
+	return ""
+}
+
+func (x *Message8478) GetField8490() *Message7966 {
+	if x != nil {
+		return x.Field8490
+	}
+	return nil
+}
+
+func (x *Message8478) GetField8491() *Message8476 {
+	if x != nil {
+		return x.Field8491
+	}
+	return nil
+}
+
+func (x *Message8478) GetField8492() int64 {
+	if x != nil && x.Field8492 != nil {
+		return *x.Field8492
+	}
+	return 0
+}
+
+func (x *Message8478) GetField8493() *Message8476 {
+	if x != nil {
+		return x.Field8493
+	}
+	return nil
+}
+
+func (x *Message8478) GetField8494() []*Message8477 {
+	if x != nil {
+		return x.Field8494
+	}
+	return nil
+}
+
+func (x *Message8478) GetField8495() *Message8454 {
+	if x != nil {
+		return x.Field8495
+	}
+	return nil
+}
+
+func (x *Message8478) GetField8496() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8496
+	}
+	return nil
+}
+
+type Message8479 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field8497 *Message8475        `protobuf:"bytes,1,opt,name=field8497" json:"field8497,omitempty"`
+	Field8498 *Message7966        `protobuf:"bytes,2,opt,name=field8498" json:"field8498,omitempty"`
+	Field8499 *Message8476        `protobuf:"bytes,3,opt,name=field8499" json:"field8499,omitempty"`
+	Field8500 *Message8476        `protobuf:"bytes,4,opt,name=field8500" json:"field8500,omitempty"`
+	Field8501 *string             `protobuf:"bytes,6,opt,name=field8501" json:"field8501,omitempty"`
+	Field8502 *string             `protobuf:"bytes,7,opt,name=field8502" json:"field8502,omitempty"`
+	Field8503 *Message7966        `protobuf:"bytes,8,opt,name=field8503" json:"field8503,omitempty"`
+	Field8504 *Message8455        `protobuf:"bytes,5,opt,name=field8504" json:"field8504,omitempty"`
+	Field8505 *UnusedEmptyMessage `protobuf:"bytes,9,opt,name=field8505" json:"field8505,omitempty"`
+}
+
+func (x *Message8479) Reset() {
+	*x = Message8479{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[13]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8479) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8479) ProtoMessage() {}
+
+func (x *Message8479) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[13]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8479.ProtoReflect.Descriptor instead.
+func (*Message8479) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{13}
+}
+
+func (x *Message8479) GetField8497() *Message8475 {
+	if x != nil {
+		return x.Field8497
+	}
+	return nil
+}
+
+func (x *Message8479) GetField8498() *Message7966 {
+	if x != nil {
+		return x.Field8498
+	}
+	return nil
+}
+
+func (x *Message8479) GetField8499() *Message8476 {
+	if x != nil {
+		return x.Field8499
+	}
+	return nil
+}
+
+func (x *Message8479) GetField8500() *Message8476 {
+	if x != nil {
+		return x.Field8500
+	}
+	return nil
+}
+
+func (x *Message8479) GetField8501() string {
+	if x != nil && x.Field8501 != nil {
+		return *x.Field8501
+	}
+	return ""
+}
+
+func (x *Message8479) GetField8502() string {
+	if x != nil && x.Field8502 != nil {
+		return *x.Field8502
+	}
+	return ""
+}
+
+func (x *Message8479) GetField8503() *Message7966 {
+	if x != nil {
+		return x.Field8503
+	}
+	return nil
+}
+
+func (x *Message8479) GetField8504() *Message8455 {
+	if x != nil {
+		return x.Field8504
+	}
+	return nil
+}
+
+func (x *Message8479) GetField8505() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8505
+	}
+	return nil
+}
+
+type Message10319 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field10340 *Enum10325 `protobuf:"varint,1,opt,name=field10340,enum=benchmarks.google_message3.Enum10325" json:"field10340,omitempty"`
+	Field10341 *int32     `protobuf:"varint,4,opt,name=field10341" json:"field10341,omitempty"`
+	Field10342 *int32     `protobuf:"varint,5,opt,name=field10342" json:"field10342,omitempty"`
+	Field10343 []byte     `protobuf:"bytes,3,opt,name=field10343" json:"field10343,omitempty"`
+	Field10344 *string    `protobuf:"bytes,2,opt,name=field10344" json:"field10344,omitempty"`
+	Field10345 *string    `protobuf:"bytes,6,opt,name=field10345" json:"field10345,omitempty"`
+	Field10346 *string    `protobuf:"bytes,7,opt,name=field10346" json:"field10346,omitempty"`
+}
+
+func (x *Message10319) Reset() {
+	*x = Message10319{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[14]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message10319) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message10319) ProtoMessage() {}
+
+func (x *Message10319) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[14]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message10319.ProtoReflect.Descriptor instead.
+func (*Message10319) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{14}
+}
+
+func (x *Message10319) GetField10340() Enum10325 {
+	if x != nil && x.Field10340 != nil {
+		return *x.Field10340
+	}
+	return Enum10325_ENUM_VALUE10326
+}
+
+func (x *Message10319) GetField10341() int32 {
+	if x != nil && x.Field10341 != nil {
+		return *x.Field10341
+	}
+	return 0
+}
+
+func (x *Message10319) GetField10342() int32 {
+	if x != nil && x.Field10342 != nil {
+		return *x.Field10342
+	}
+	return 0
+}
+
+func (x *Message10319) GetField10343() []byte {
+	if x != nil {
+		return x.Field10343
+	}
+	return nil
+}
+
+func (x *Message10319) GetField10344() string {
+	if x != nil && x.Field10344 != nil {
+		return *x.Field10344
+	}
+	return ""
+}
+
+func (x *Message10319) GetField10345() string {
+	if x != nil && x.Field10345 != nil {
+		return *x.Field10345
+	}
+	return ""
+}
+
+func (x *Message10319) GetField10346() string {
+	if x != nil && x.Field10346 != nil {
+		return *x.Field10346
+	}
+	return ""
+}
+
+type Message4016 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field4017 *int32 `protobuf:"varint,1,req,name=field4017" json:"field4017,omitempty"`
+	Field4018 *int32 `protobuf:"varint,2,req,name=field4018" json:"field4018,omitempty"`
+	Field4019 *int32 `protobuf:"varint,3,req,name=field4019" json:"field4019,omitempty"`
+	Field4020 *int32 `protobuf:"varint,4,req,name=field4020" json:"field4020,omitempty"`
+}
+
+func (x *Message4016) Reset() {
+	*x = Message4016{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[15]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message4016) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message4016) ProtoMessage() {}
+
+func (x *Message4016) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[15]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message4016.ProtoReflect.Descriptor instead.
+func (*Message4016) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{15}
+}
+
+func (x *Message4016) GetField4017() int32 {
+	if x != nil && x.Field4017 != nil {
+		return *x.Field4017
+	}
+	return 0
+}
+
+func (x *Message4016) GetField4018() int32 {
+	if x != nil && x.Field4018 != nil {
+		return *x.Field4018
+	}
+	return 0
+}
+
+func (x *Message4016) GetField4019() int32 {
+	if x != nil && x.Field4019 != nil {
+		return *x.Field4019
+	}
+	return 0
+}
+
+func (x *Message4016) GetField4020() int32 {
+	if x != nil && x.Field4020 != nil {
+		return *x.Field4020
+	}
+	return 0
+}
+
+type Message12669 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12681 *Message12559 `protobuf:"bytes,1,opt,name=field12681" json:"field12681,omitempty"`
+	Field12682 *float32      `protobuf:"fixed32,2,opt,name=field12682" json:"field12682,omitempty"`
+	Field12683 *bool         `protobuf:"varint,3,opt,name=field12683" json:"field12683,omitempty"`
+	Field12684 *Enum12670    `protobuf:"varint,4,opt,name=field12684,enum=benchmarks.google_message3.Enum12670" json:"field12684,omitempty"`
+}
+
+func (x *Message12669) Reset() {
+	*x = Message12669{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[16]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12669) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12669) ProtoMessage() {}
+
+func (x *Message12669) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[16]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12669.ProtoReflect.Descriptor instead.
+func (*Message12669) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{16}
+}
+
+func (x *Message12669) GetField12681() *Message12559 {
+	if x != nil {
+		return x.Field12681
+	}
+	return nil
+}
+
+func (x *Message12669) GetField12682() float32 {
+	if x != nil && x.Field12682 != nil {
+		return *x.Field12682
+	}
+	return 0
+}
+
+func (x *Message12669) GetField12683() bool {
+	if x != nil && x.Field12683 != nil {
+		return *x.Field12683
+	}
+	return false
+}
+
+func (x *Message12669) GetField12684() Enum12670 {
+	if x != nil && x.Field12684 != nil {
+		return *x.Field12684
+	}
+	return Enum12670_ENUM_VALUE12671
+}
+
+type Message12819 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12834 *float64 `protobuf:"fixed64,1,opt,name=field12834" json:"field12834,omitempty"`
+	Field12835 *float64 `protobuf:"fixed64,2,opt,name=field12835" json:"field12835,omitempty"`
+	Field12836 *float64 `protobuf:"fixed64,3,opt,name=field12836" json:"field12836,omitempty"`
+	Field12837 *float64 `protobuf:"fixed64,4,opt,name=field12837" json:"field12837,omitempty"`
+	Field12838 *float64 `protobuf:"fixed64,5,opt,name=field12838" json:"field12838,omitempty"`
+	Field12839 *float64 `protobuf:"fixed64,6,opt,name=field12839" json:"field12839,omitempty"`
+}
+
+func (x *Message12819) Reset() {
+	*x = Message12819{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[17]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12819) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12819) ProtoMessage() {}
+
+func (x *Message12819) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[17]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12819.ProtoReflect.Descriptor instead.
+func (*Message12819) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{17}
+}
+
+func (x *Message12819) GetField12834() float64 {
+	if x != nil && x.Field12834 != nil {
+		return *x.Field12834
+	}
+	return 0
+}
+
+func (x *Message12819) GetField12835() float64 {
+	if x != nil && x.Field12835 != nil {
+		return *x.Field12835
+	}
+	return 0
+}
+
+func (x *Message12819) GetField12836() float64 {
+	if x != nil && x.Field12836 != nil {
+		return *x.Field12836
+	}
+	return 0
+}
+
+func (x *Message12819) GetField12837() float64 {
+	if x != nil && x.Field12837 != nil {
+		return *x.Field12837
+	}
+	return 0
+}
+
+func (x *Message12819) GetField12838() float64 {
+	if x != nil && x.Field12838 != nil {
+		return *x.Field12838
+	}
+	return 0
+}
+
+func (x *Message12819) GetField12839() float64 {
+	if x != nil && x.Field12839 != nil {
+		return *x.Field12839
+	}
+	return 0
+}
+
+type Message12820 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12840 *int32 `protobuf:"varint,1,opt,name=field12840" json:"field12840,omitempty"`
+	Field12841 *int32 `protobuf:"varint,2,opt,name=field12841" json:"field12841,omitempty"`
+	Field12842 *int32 `protobuf:"varint,3,opt,name=field12842" json:"field12842,omitempty"`
+	Field12843 *int32 `protobuf:"varint,8,opt,name=field12843" json:"field12843,omitempty"`
+	Field12844 *int32 `protobuf:"varint,4,opt,name=field12844" json:"field12844,omitempty"`
+	Field12845 *int32 `protobuf:"varint,5,opt,name=field12845" json:"field12845,omitempty"`
+	Field12846 *int32 `protobuf:"varint,6,opt,name=field12846" json:"field12846,omitempty"`
+	Field12847 *int32 `protobuf:"varint,7,opt,name=field12847" json:"field12847,omitempty"`
+}
+
+func (x *Message12820) Reset() {
+	*x = Message12820{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[18]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12820) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12820) ProtoMessage() {}
+
+func (x *Message12820) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[18]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12820.ProtoReflect.Descriptor instead.
+func (*Message12820) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{18}
+}
+
+func (x *Message12820) GetField12840() int32 {
+	if x != nil && x.Field12840 != nil {
+		return *x.Field12840
+	}
+	return 0
+}
+
+func (x *Message12820) GetField12841() int32 {
+	if x != nil && x.Field12841 != nil {
+		return *x.Field12841
+	}
+	return 0
+}
+
+func (x *Message12820) GetField12842() int32 {
+	if x != nil && x.Field12842 != nil {
+		return *x.Field12842
+	}
+	return 0
+}
+
+func (x *Message12820) GetField12843() int32 {
+	if x != nil && x.Field12843 != nil {
+		return *x.Field12843
+	}
+	return 0
+}
+
+func (x *Message12820) GetField12844() int32 {
+	if x != nil && x.Field12844 != nil {
+		return *x.Field12844
+	}
+	return 0
+}
+
+func (x *Message12820) GetField12845() int32 {
+	if x != nil && x.Field12845 != nil {
+		return *x.Field12845
+	}
+	return 0
+}
+
+func (x *Message12820) GetField12846() int32 {
+	if x != nil && x.Field12846 != nil {
+		return *x.Field12846
+	}
+	return 0
+}
+
+func (x *Message12820) GetField12847() int32 {
+	if x != nil && x.Field12847 != nil {
+		return *x.Field12847
+	}
+	return 0
+}
+
+type Message12821 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12848 *int32 `protobuf:"varint,1,opt,name=field12848" json:"field12848,omitempty"`
+	Field12849 *int32 `protobuf:"varint,2,opt,name=field12849" json:"field12849,omitempty"`
+	Field12850 *int32 `protobuf:"varint,3,opt,name=field12850" json:"field12850,omitempty"`
+	Field12851 *int32 `protobuf:"varint,4,opt,name=field12851" json:"field12851,omitempty"`
+	Field12852 *int32 `protobuf:"varint,5,opt,name=field12852" json:"field12852,omitempty"`
+}
+
+func (x *Message12821) Reset() {
+	*x = Message12821{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[19]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12821) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12821) ProtoMessage() {}
+
+func (x *Message12821) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[19]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12821.ProtoReflect.Descriptor instead.
+func (*Message12821) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{19}
+}
+
+func (x *Message12821) GetField12848() int32 {
+	if x != nil && x.Field12848 != nil {
+		return *x.Field12848
+	}
+	return 0
+}
+
+func (x *Message12821) GetField12849() int32 {
+	if x != nil && x.Field12849 != nil {
+		return *x.Field12849
+	}
+	return 0
+}
+
+func (x *Message12821) GetField12850() int32 {
+	if x != nil && x.Field12850 != nil {
+		return *x.Field12850
+	}
+	return 0
+}
+
+func (x *Message12821) GetField12851() int32 {
+	if x != nil && x.Field12851 != nil {
+		return *x.Field12851
+	}
+	return 0
+}
+
+func (x *Message12821) GetField12852() int32 {
+	if x != nil && x.Field12852 != nil {
+		return *x.Field12852
+	}
+	return 0
+}
+
+type Message12818 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12829 *uint64         `protobuf:"varint,1,opt,name=field12829" json:"field12829,omitempty"`
+	Field12830 *int32          `protobuf:"varint,2,opt,name=field12830" json:"field12830,omitempty"`
+	Field12831 *int32          `protobuf:"varint,3,opt,name=field12831" json:"field12831,omitempty"`
+	Field12832 *int32          `protobuf:"varint,5,opt,name=field12832" json:"field12832,omitempty"`
+	Field12833 []*Message12817 `protobuf:"bytes,4,rep,name=field12833" json:"field12833,omitempty"`
+}
+
+func (x *Message12818) Reset() {
+	*x = Message12818{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[20]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12818) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12818) ProtoMessage() {}
+
+func (x *Message12818) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[20]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12818.ProtoReflect.Descriptor instead.
+func (*Message12818) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{20}
+}
+
+func (x *Message12818) GetField12829() uint64 {
+	if x != nil && x.Field12829 != nil {
+		return *x.Field12829
+	}
+	return 0
+}
+
+func (x *Message12818) GetField12830() int32 {
+	if x != nil && x.Field12830 != nil {
+		return *x.Field12830
+	}
+	return 0
+}
+
+func (x *Message12818) GetField12831() int32 {
+	if x != nil && x.Field12831 != nil {
+		return *x.Field12831
+	}
+	return 0
+}
+
+func (x *Message12818) GetField12832() int32 {
+	if x != nil && x.Field12832 != nil {
+		return *x.Field12832
+	}
+	return 0
+}
+
+func (x *Message12818) GetField12833() []*Message12817 {
+	if x != nil {
+		return x.Field12833
+	}
+	return nil
+}
+
+type Message16479 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field16484 *Message16480 `protobuf:"bytes,1,opt,name=field16484" json:"field16484,omitempty"`
+	Field16485 *int32        `protobuf:"varint,5,opt,name=field16485" json:"field16485,omitempty"`
+	Field16486 *float32      `protobuf:"fixed32,2,opt,name=field16486" json:"field16486,omitempty"`
+	Field16487 *uint32       `protobuf:"varint,4,opt,name=field16487" json:"field16487,omitempty"`
+	Field16488 *bool         `protobuf:"varint,3,opt,name=field16488" json:"field16488,omitempty"`
+	Field16489 *uint32       `protobuf:"varint,6,opt,name=field16489" json:"field16489,omitempty"`
+}
+
+func (x *Message16479) Reset() {
+	*x = Message16479{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[21]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message16479) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message16479) ProtoMessage() {}
+
+func (x *Message16479) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[21]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message16479.ProtoReflect.Descriptor instead.
+func (*Message16479) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{21}
+}
+
+func (x *Message16479) GetField16484() *Message16480 {
+	if x != nil {
+		return x.Field16484
+	}
+	return nil
+}
+
+func (x *Message16479) GetField16485() int32 {
+	if x != nil && x.Field16485 != nil {
+		return *x.Field16485
+	}
+	return 0
+}
+
+func (x *Message16479) GetField16486() float32 {
+	if x != nil && x.Field16486 != nil {
+		return *x.Field16486
+	}
+	return 0
+}
+
+func (x *Message16479) GetField16487() uint32 {
+	if x != nil && x.Field16487 != nil {
+		return *x.Field16487
+	}
+	return 0
+}
+
+func (x *Message16479) GetField16488() bool {
+	if x != nil && x.Field16488 != nil {
+		return *x.Field16488
+	}
+	return false
+}
+
+func (x *Message16479) GetField16489() uint32 {
+	if x != nil && x.Field16489 != nil {
+		return *x.Field16489
+	}
+	return 0
+}
+
+type Message16722 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field16752 *string `protobuf:"bytes,1,opt,name=field16752" json:"field16752,omitempty"`
+	Field16753 *string `protobuf:"bytes,2,opt,name=field16753" json:"field16753,omitempty"`
+	Field16754 *string `protobuf:"bytes,3,opt,name=field16754" json:"field16754,omitempty"`
+	Field16755 *int32  `protobuf:"varint,5,opt,name=field16755" json:"field16755,omitempty"`
+	Field16756 *string `protobuf:"bytes,4,opt,name=field16756" json:"field16756,omitempty"`
+}
+
+func (x *Message16722) Reset() {
+	*x = Message16722{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[22]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message16722) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message16722) ProtoMessage() {}
+
+func (x *Message16722) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[22]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message16722.ProtoReflect.Descriptor instead.
+func (*Message16722) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{22}
+}
+
+func (x *Message16722) GetField16752() string {
+	if x != nil && x.Field16752 != nil {
+		return *x.Field16752
+	}
+	return ""
+}
+
+func (x *Message16722) GetField16753() string {
+	if x != nil && x.Field16753 != nil {
+		return *x.Field16753
+	}
+	return ""
+}
+
+func (x *Message16722) GetField16754() string {
+	if x != nil && x.Field16754 != nil {
+		return *x.Field16754
+	}
+	return ""
+}
+
+func (x *Message16722) GetField16755() int32 {
+	if x != nil && x.Field16755 != nil {
+		return *x.Field16755
+	}
+	return 0
+}
+
+func (x *Message16722) GetField16756() string {
+	if x != nil && x.Field16756 != nil {
+		return *x.Field16756
+	}
+	return ""
+}
+
+type Message16724 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field16761 *int64              `protobuf:"varint,1,opt,name=field16761" json:"field16761,omitempty"`
+	Field16762 *float32            `protobuf:"fixed32,2,opt,name=field16762" json:"field16762,omitempty"`
+	Field16763 *int64              `protobuf:"varint,3,opt,name=field16763" json:"field16763,omitempty"`
+	Field16764 *int64              `protobuf:"varint,4,opt,name=field16764" json:"field16764,omitempty"`
+	Field16765 *bool               `protobuf:"varint,5,opt,name=field16765" json:"field16765,omitempty"`
+	Field16766 []string            `protobuf:"bytes,6,rep,name=field16766" json:"field16766,omitempty"`
+	Field16767 []string            `protobuf:"bytes,7,rep,name=field16767" json:"field16767,omitempty"`
+	Field16768 *UnusedEmptyMessage `protobuf:"bytes,8,opt,name=field16768" json:"field16768,omitempty"`
+	Field16769 *bool               `protobuf:"varint,9,opt,name=field16769" json:"field16769,omitempty"`
+	Field16770 *uint32             `protobuf:"varint,10,opt,name=field16770" json:"field16770,omitempty"`
+	Field16771 *Enum16728          `protobuf:"varint,11,opt,name=field16771,enum=benchmarks.google_message3.Enum16728" json:"field16771,omitempty"`
+	Field16772 []int32             `protobuf:"varint,12,rep,name=field16772" json:"field16772,omitempty"`
+	Field16773 *bool               `protobuf:"varint,13,opt,name=field16773" json:"field16773,omitempty"`
+}
+
+func (x *Message16724) Reset() {
+	*x = Message16724{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[23]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message16724) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message16724) ProtoMessage() {}
+
+func (x *Message16724) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[23]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message16724.ProtoReflect.Descriptor instead.
+func (*Message16724) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{23}
+}
+
+func (x *Message16724) GetField16761() int64 {
+	if x != nil && x.Field16761 != nil {
+		return *x.Field16761
+	}
+	return 0
+}
+
+func (x *Message16724) GetField16762() float32 {
+	if x != nil && x.Field16762 != nil {
+		return *x.Field16762
+	}
+	return 0
+}
+
+func (x *Message16724) GetField16763() int64 {
+	if x != nil && x.Field16763 != nil {
+		return *x.Field16763
+	}
+	return 0
+}
+
+func (x *Message16724) GetField16764() int64 {
+	if x != nil && x.Field16764 != nil {
+		return *x.Field16764
+	}
+	return 0
+}
+
+func (x *Message16724) GetField16765() bool {
+	if x != nil && x.Field16765 != nil {
+		return *x.Field16765
+	}
+	return false
+}
+
+func (x *Message16724) GetField16766() []string {
+	if x != nil {
+		return x.Field16766
+	}
+	return nil
+}
+
+func (x *Message16724) GetField16767() []string {
+	if x != nil {
+		return x.Field16767
+	}
+	return nil
+}
+
+func (x *Message16724) GetField16768() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field16768
+	}
+	return nil
+}
+
+func (x *Message16724) GetField16769() bool {
+	if x != nil && x.Field16769 != nil {
+		return *x.Field16769
+	}
+	return false
+}
+
+func (x *Message16724) GetField16770() uint32 {
+	if x != nil && x.Field16770 != nil {
+		return *x.Field16770
+	}
+	return 0
+}
+
+func (x *Message16724) GetField16771() Enum16728 {
+	if x != nil && x.Field16771 != nil {
+		return *x.Field16771
+	}
+	return Enum16728_ENUM_VALUE16729
+}
+
+func (x *Message16724) GetField16772() []int32 {
+	if x != nil {
+		return x.Field16772
+	}
+	return nil
+}
+
+func (x *Message16724) GetField16773() bool {
+	if x != nil && x.Field16773 != nil {
+		return *x.Field16773
+	}
+	return false
+}
+
+type Message17728 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message17728) Reset() {
+	*x = Message17728{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[24]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message17728) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message17728) ProtoMessage() {}
+
+func (x *Message17728) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[24]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message17728.ProtoReflect.Descriptor instead.
+func (*Message17728) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{24}
+}
+
+type Message24356 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field24559 *string               `protobuf:"bytes,1,opt,name=field24559" json:"field24559,omitempty"`
+	Field24560 *string               `protobuf:"bytes,2,opt,name=field24560" json:"field24560,omitempty"`
+	Field24561 *int32                `protobuf:"varint,14,opt,name=field24561" json:"field24561,omitempty"`
+	Field24562 *string               `protobuf:"bytes,3,opt,name=field24562" json:"field24562,omitempty"`
+	Field24563 *string               `protobuf:"bytes,4,opt,name=field24563" json:"field24563,omitempty"`
+	Field24564 *string               `protobuf:"bytes,5,opt,name=field24564" json:"field24564,omitempty"`
+	Field24565 *UnusedEnum           `protobuf:"varint,13,opt,name=field24565,enum=benchmarks.google_message3.UnusedEnum" json:"field24565,omitempty"`
+	Field24566 *string               `protobuf:"bytes,6,opt,name=field24566" json:"field24566,omitempty"`
+	Field24567 *Enum24361            `protobuf:"varint,12,opt,name=field24567,enum=benchmarks.google_message3.Enum24361" json:"field24567,omitempty"`
+	Field24568 *string               `protobuf:"bytes,7,opt,name=field24568" json:"field24568,omitempty"`
+	Field24569 *string               `protobuf:"bytes,8,opt,name=field24569" json:"field24569,omitempty"`
+	Field24570 *string               `protobuf:"bytes,9,opt,name=field24570" json:"field24570,omitempty"`
+	Field24571 []*UnusedEmptyMessage `protobuf:"bytes,10,rep,name=field24571" json:"field24571,omitempty"`
+	Field24572 []string              `protobuf:"bytes,11,rep,name=field24572" json:"field24572,omitempty"`
+	Field24573 []string              `protobuf:"bytes,15,rep,name=field24573" json:"field24573,omitempty"`
+}
+
+func (x *Message24356) Reset() {
+	*x = Message24356{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[25]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message24356) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message24356) ProtoMessage() {}
+
+func (x *Message24356) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[25]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message24356.ProtoReflect.Descriptor instead.
+func (*Message24356) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{25}
+}
+
+func (x *Message24356) GetField24559() string {
+	if x != nil && x.Field24559 != nil {
+		return *x.Field24559
+	}
+	return ""
+}
+
+func (x *Message24356) GetField24560() string {
+	if x != nil && x.Field24560 != nil {
+		return *x.Field24560
+	}
+	return ""
+}
+
+func (x *Message24356) GetField24561() int32 {
+	if x != nil && x.Field24561 != nil {
+		return *x.Field24561
+	}
+	return 0
+}
+
+func (x *Message24356) GetField24562() string {
+	if x != nil && x.Field24562 != nil {
+		return *x.Field24562
+	}
+	return ""
+}
+
+func (x *Message24356) GetField24563() string {
+	if x != nil && x.Field24563 != nil {
+		return *x.Field24563
+	}
+	return ""
+}
+
+func (x *Message24356) GetField24564() string {
+	if x != nil && x.Field24564 != nil {
+		return *x.Field24564
+	}
+	return ""
+}
+
+func (x *Message24356) GetField24565() UnusedEnum {
+	if x != nil && x.Field24565 != nil {
+		return *x.Field24565
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+func (x *Message24356) GetField24566() string {
+	if x != nil && x.Field24566 != nil {
+		return *x.Field24566
+	}
+	return ""
+}
+
+func (x *Message24356) GetField24567() Enum24361 {
+	if x != nil && x.Field24567 != nil {
+		return *x.Field24567
+	}
+	return Enum24361_ENUM_VALUE24362
+}
+
+func (x *Message24356) GetField24568() string {
+	if x != nil && x.Field24568 != nil {
+		return *x.Field24568
+	}
+	return ""
+}
+
+func (x *Message24356) GetField24569() string {
+	if x != nil && x.Field24569 != nil {
+		return *x.Field24569
+	}
+	return ""
+}
+
+func (x *Message24356) GetField24570() string {
+	if x != nil && x.Field24570 != nil {
+		return *x.Field24570
+	}
+	return ""
+}
+
+func (x *Message24356) GetField24571() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field24571
+	}
+	return nil
+}
+
+func (x *Message24356) GetField24572() []string {
+	if x != nil {
+		return x.Field24572
+	}
+	return nil
+}
+
+func (x *Message24356) GetField24573() []string {
+	if x != nil {
+		return x.Field24573
+	}
+	return nil
+}
+
+type Message24376 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field24589 *string               `protobuf:"bytes,1,opt,name=field24589" json:"field24589,omitempty"`
+	Field24590 *string               `protobuf:"bytes,2,opt,name=field24590" json:"field24590,omitempty"`
+	Field24591 *string               `protobuf:"bytes,3,opt,name=field24591" json:"field24591,omitempty"`
+	Field24592 *Message24377         `protobuf:"bytes,4,req,name=field24592" json:"field24592,omitempty"`
+	Field24593 *Message24317         `protobuf:"bytes,5,opt,name=field24593" json:"field24593,omitempty"`
+	Field24594 *string               `protobuf:"bytes,6,opt,name=field24594" json:"field24594,omitempty"`
+	Field24595 *Message24378         `protobuf:"bytes,7,opt,name=field24595" json:"field24595,omitempty"`
+	Field24596 []string              `protobuf:"bytes,8,rep,name=field24596" json:"field24596,omitempty"`
+	Field24597 []*UnusedEmptyMessage `protobuf:"bytes,14,rep,name=field24597" json:"field24597,omitempty"`
+	Field24598 []string              `protobuf:"bytes,9,rep,name=field24598" json:"field24598,omitempty"`
+	Field24599 []string              `protobuf:"bytes,10,rep,name=field24599" json:"field24599,omitempty"`
+	Field24600 []string              `protobuf:"bytes,11,rep,name=field24600" json:"field24600,omitempty"`
+	Field24601 *string               `protobuf:"bytes,12,opt,name=field24601" json:"field24601,omitempty"`
+	Field24602 []string              `protobuf:"bytes,13,rep,name=field24602" json:"field24602,omitempty"`
+}
+
+func (x *Message24376) Reset() {
+	*x = Message24376{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[26]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message24376) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message24376) ProtoMessage() {}
+
+func (x *Message24376) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[26]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message24376.ProtoReflect.Descriptor instead.
+func (*Message24376) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{26}
+}
+
+func (x *Message24376) GetField24589() string {
+	if x != nil && x.Field24589 != nil {
+		return *x.Field24589
+	}
+	return ""
+}
+
+func (x *Message24376) GetField24590() string {
+	if x != nil && x.Field24590 != nil {
+		return *x.Field24590
+	}
+	return ""
+}
+
+func (x *Message24376) GetField24591() string {
+	if x != nil && x.Field24591 != nil {
+		return *x.Field24591
+	}
+	return ""
+}
+
+func (x *Message24376) GetField24592() *Message24377 {
+	if x != nil {
+		return x.Field24592
+	}
+	return nil
+}
+
+func (x *Message24376) GetField24593() *Message24317 {
+	if x != nil {
+		return x.Field24593
+	}
+	return nil
+}
+
+func (x *Message24376) GetField24594() string {
+	if x != nil && x.Field24594 != nil {
+		return *x.Field24594
+	}
+	return ""
+}
+
+func (x *Message24376) GetField24595() *Message24378 {
+	if x != nil {
+		return x.Field24595
+	}
+	return nil
+}
+
+func (x *Message24376) GetField24596() []string {
+	if x != nil {
+		return x.Field24596
+	}
+	return nil
+}
+
+func (x *Message24376) GetField24597() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field24597
+	}
+	return nil
+}
+
+func (x *Message24376) GetField24598() []string {
+	if x != nil {
+		return x.Field24598
+	}
+	return nil
+}
+
+func (x *Message24376) GetField24599() []string {
+	if x != nil {
+		return x.Field24599
+	}
+	return nil
+}
+
+func (x *Message24376) GetField24600() []string {
+	if x != nil {
+		return x.Field24600
+	}
+	return nil
+}
+
+func (x *Message24376) GetField24601() string {
+	if x != nil && x.Field24601 != nil {
+		return *x.Field24601
+	}
+	return ""
+}
+
+func (x *Message24376) GetField24602() []string {
+	if x != nil {
+		return x.Field24602
+	}
+	return nil
+}
+
+type Message24366 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field24574 *string               `protobuf:"bytes,1,opt,name=field24574" json:"field24574,omitempty"`
+	Field24575 *string               `protobuf:"bytes,2,opt,name=field24575" json:"field24575,omitempty"`
+	Field24576 *string               `protobuf:"bytes,3,opt,name=field24576" json:"field24576,omitempty"`
+	Field24577 *int32                `protobuf:"varint,10,opt,name=field24577" json:"field24577,omitempty"`
+	Field24578 *string               `protobuf:"bytes,13,opt,name=field24578" json:"field24578,omitempty"`
+	Field24579 *string               `protobuf:"bytes,4,opt,name=field24579" json:"field24579,omitempty"`
+	Field24580 *string               `protobuf:"bytes,5,opt,name=field24580" json:"field24580,omitempty"`
+	Field24581 *UnusedEnum           `protobuf:"varint,9,opt,name=field24581,enum=benchmarks.google_message3.UnusedEnum" json:"field24581,omitempty"`
+	Field24582 *string               `protobuf:"bytes,14,opt,name=field24582" json:"field24582,omitempty"`
+	Field24583 *UnusedEnum           `protobuf:"varint,15,opt,name=field24583,enum=benchmarks.google_message3.UnusedEnum" json:"field24583,omitempty"`
+	Field24584 *string               `protobuf:"bytes,6,opt,name=field24584" json:"field24584,omitempty"`
+	Field24585 *string               `protobuf:"bytes,12,opt,name=field24585" json:"field24585,omitempty"`
+	Field24586 []*UnusedEmptyMessage `protobuf:"bytes,7,rep,name=field24586" json:"field24586,omitempty"`
+	Field24587 []string              `protobuf:"bytes,8,rep,name=field24587" json:"field24587,omitempty"`
+	Field24588 []string              `protobuf:"bytes,11,rep,name=field24588" json:"field24588,omitempty"`
+}
+
+func (x *Message24366) Reset() {
+	*x = Message24366{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[27]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message24366) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message24366) ProtoMessage() {}
+
+func (x *Message24366) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[27]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message24366.ProtoReflect.Descriptor instead.
+func (*Message24366) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{27}
+}
+
+func (x *Message24366) GetField24574() string {
+	if x != nil && x.Field24574 != nil {
+		return *x.Field24574
+	}
+	return ""
+}
+
+func (x *Message24366) GetField24575() string {
+	if x != nil && x.Field24575 != nil {
+		return *x.Field24575
+	}
+	return ""
+}
+
+func (x *Message24366) GetField24576() string {
+	if x != nil && x.Field24576 != nil {
+		return *x.Field24576
+	}
+	return ""
+}
+
+func (x *Message24366) GetField24577() int32 {
+	if x != nil && x.Field24577 != nil {
+		return *x.Field24577
+	}
+	return 0
+}
+
+func (x *Message24366) GetField24578() string {
+	if x != nil && x.Field24578 != nil {
+		return *x.Field24578
+	}
+	return ""
+}
+
+func (x *Message24366) GetField24579() string {
+	if x != nil && x.Field24579 != nil {
+		return *x.Field24579
+	}
+	return ""
+}
+
+func (x *Message24366) GetField24580() string {
+	if x != nil && x.Field24580 != nil {
+		return *x.Field24580
+	}
+	return ""
+}
+
+func (x *Message24366) GetField24581() UnusedEnum {
+	if x != nil && x.Field24581 != nil {
+		return *x.Field24581
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+func (x *Message24366) GetField24582() string {
+	if x != nil && x.Field24582 != nil {
+		return *x.Field24582
+	}
+	return ""
+}
+
+func (x *Message24366) GetField24583() UnusedEnum {
+	if x != nil && x.Field24583 != nil {
+		return *x.Field24583
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+func (x *Message24366) GetField24584() string {
+	if x != nil && x.Field24584 != nil {
+		return *x.Field24584
+	}
+	return ""
+}
+
+func (x *Message24366) GetField24585() string {
+	if x != nil && x.Field24585 != nil {
+		return *x.Field24585
+	}
+	return ""
+}
+
+func (x *Message24366) GetField24586() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field24586
+	}
+	return nil
+}
+
+func (x *Message24366) GetField24587() []string {
+	if x != nil {
+		return x.Field24587
+	}
+	return nil
+}
+
+func (x *Message24366) GetField24588() []string {
+	if x != nil {
+		return x.Field24588
+	}
+	return nil
+}
+
+type Message35546_Message35547 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field35569 *int32 `protobuf:"varint,5,req,name=field35569" json:"field35569,omitempty"`
+	Field35570 *int32 `protobuf:"varint,6,req,name=field35570" json:"field35570,omitempty"`
+}
+
+func (x *Message35546_Message35547) Reset() {
+	*x = Message35546_Message35547{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[28]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message35546_Message35547) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message35546_Message35547) ProtoMessage() {}
+
+func (x *Message35546_Message35547) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[28]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message35546_Message35547.ProtoReflect.Descriptor instead.
+func (*Message35546_Message35547) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{0, 0}
+}
+
+func (x *Message35546_Message35547) GetField35569() int32 {
+	if x != nil && x.Field35569 != nil {
+		return *x.Field35569
+	}
+	return 0
+}
+
+func (x *Message35546_Message35547) GetField35570() int32 {
+	if x != nil && x.Field35570 != nil {
+		return *x.Field35570
+	}
+	return 0
+}
+
+type Message35546_Message35548 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field35571 *int64 `protobuf:"varint,11,req,name=field35571" json:"field35571,omitempty"`
+	Field35572 *int64 `protobuf:"varint,12,req,name=field35572" json:"field35572,omitempty"`
+}
+
+func (x *Message35546_Message35548) Reset() {
+	*x = Message35546_Message35548{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[29]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message35546_Message35548) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message35546_Message35548) ProtoMessage() {}
+
+func (x *Message35546_Message35548) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[29]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message35546_Message35548.ProtoReflect.Descriptor instead.
+func (*Message35546_Message35548) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{0, 1}
+}
+
+func (x *Message35546_Message35548) GetField35571() int64 {
+	if x != nil && x.Field35571 != nil {
+		return *x.Field35571
+	}
+	return 0
+}
+
+func (x *Message35546_Message35548) GetField35572() int64 {
+	if x != nil && x.Field35572 != nil {
+		return *x.Field35572
+	}
+	return 0
+}
+
+type Message2356_Message2357 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field2399 *int64 `protobuf:"varint,9,opt,name=field2399" json:"field2399,omitempty"`
+	Field2400 *int32 `protobuf:"varint,10,opt,name=field2400" json:"field2400,omitempty"`
+	Field2401 *int32 `protobuf:"varint,11,opt,name=field2401" json:"field2401,omitempty"`
+	Field2402 *int32 `protobuf:"varint,12,opt,name=field2402" json:"field2402,omitempty"`
+	Field2403 *int32 `protobuf:"varint,13,opt,name=field2403" json:"field2403,omitempty"`
+	Field2404 *int32 `protobuf:"varint,116,opt,name=field2404" json:"field2404,omitempty"`
+	Field2405 *int32 `protobuf:"varint,106,opt,name=field2405" json:"field2405,omitempty"`
+	Field2406 []byte `protobuf:"bytes,14,req,name=field2406" json:"field2406,omitempty"`
+	Field2407 *int32 `protobuf:"varint,45,opt,name=field2407" json:"field2407,omitempty"`
+	Field2408 *int32 `protobuf:"varint,112,opt,name=field2408" json:"field2408,omitempty"`
+	Field2409 *bool  `protobuf:"varint,122,opt,name=field2409" json:"field2409,omitempty"`
+	Field2410 []byte `protobuf:"bytes,124,opt,name=field2410" json:"field2410,omitempty"`
+}
+
+func (x *Message2356_Message2357) Reset() {
+	*x = Message2356_Message2357{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[30]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message2356_Message2357) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message2356_Message2357) ProtoMessage() {}
+
+func (x *Message2356_Message2357) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[30]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message2356_Message2357.ProtoReflect.Descriptor instead.
+func (*Message2356_Message2357) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{1, 0}
+}
+
+func (x *Message2356_Message2357) GetField2399() int64 {
+	if x != nil && x.Field2399 != nil {
+		return *x.Field2399
+	}
+	return 0
+}
+
+func (x *Message2356_Message2357) GetField2400() int32 {
+	if x != nil && x.Field2400 != nil {
+		return *x.Field2400
+	}
+	return 0
+}
+
+func (x *Message2356_Message2357) GetField2401() int32 {
+	if x != nil && x.Field2401 != nil {
+		return *x.Field2401
+	}
+	return 0
+}
+
+func (x *Message2356_Message2357) GetField2402() int32 {
+	if x != nil && x.Field2402 != nil {
+		return *x.Field2402
+	}
+	return 0
+}
+
+func (x *Message2356_Message2357) GetField2403() int32 {
+	if x != nil && x.Field2403 != nil {
+		return *x.Field2403
+	}
+	return 0
+}
+
+func (x *Message2356_Message2357) GetField2404() int32 {
+	if x != nil && x.Field2404 != nil {
+		return *x.Field2404
+	}
+	return 0
+}
+
+func (x *Message2356_Message2357) GetField2405() int32 {
+	if x != nil && x.Field2405 != nil {
+		return *x.Field2405
+	}
+	return 0
+}
+
+func (x *Message2356_Message2357) GetField2406() []byte {
+	if x != nil {
+		return x.Field2406
+	}
+	return nil
+}
+
+func (x *Message2356_Message2357) GetField2407() int32 {
+	if x != nil && x.Field2407 != nil {
+		return *x.Field2407
+	}
+	return 0
+}
+
+func (x *Message2356_Message2357) GetField2408() int32 {
+	if x != nil && x.Field2408 != nil {
+		return *x.Field2408
+	}
+	return 0
+}
+
+func (x *Message2356_Message2357) GetField2409() bool {
+	if x != nil && x.Field2409 != nil {
+		return *x.Field2409
+	}
+	return false
+}
+
+func (x *Message2356_Message2357) GetField2410() []byte {
+	if x != nil {
+		return x.Field2410
+	}
+	return nil
+}
+
+type Message2356_Message2358 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message2356_Message2358) Reset() {
+	*x = Message2356_Message2358{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[31]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message2356_Message2358) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message2356_Message2358) ProtoMessage() {}
+
+func (x *Message2356_Message2358) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[31]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message2356_Message2358.ProtoReflect.Descriptor instead.
+func (*Message2356_Message2358) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{1, 1}
+}
+
+type Message2356_Message2359 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field2413 *string  `protobuf:"bytes,41,opt,name=field2413" json:"field2413,omitempty"`
+	Field2414 *string  `protobuf:"bytes,42,opt,name=field2414" json:"field2414,omitempty"`
+	Field2415 *string  `protobuf:"bytes,43,opt,name=field2415" json:"field2415,omitempty"`
+	Field2416 *string  `protobuf:"bytes,44,opt,name=field2416" json:"field2416,omitempty"`
+	Field2417 *int32   `protobuf:"varint,46,opt,name=field2417" json:"field2417,omitempty"`
+	Field2418 *string  `protobuf:"bytes,47,opt,name=field2418" json:"field2418,omitempty"`
+	Field2419 *float32 `protobuf:"fixed32,110,opt,name=field2419" json:"field2419,omitempty"`
+	Field2420 *float32 `protobuf:"fixed32,111,opt,name=field2420" json:"field2420,omitempty"`
+}
+
+func (x *Message2356_Message2359) Reset() {
+	*x = Message2356_Message2359{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[32]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message2356_Message2359) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message2356_Message2359) ProtoMessage() {}
+
+func (x *Message2356_Message2359) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[32]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message2356_Message2359.ProtoReflect.Descriptor instead.
+func (*Message2356_Message2359) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{1, 2}
+}
+
+func (x *Message2356_Message2359) GetField2413() string {
+	if x != nil && x.Field2413 != nil {
+		return *x.Field2413
+	}
+	return ""
+}
+
+func (x *Message2356_Message2359) GetField2414() string {
+	if x != nil && x.Field2414 != nil {
+		return *x.Field2414
+	}
+	return ""
+}
+
+func (x *Message2356_Message2359) GetField2415() string {
+	if x != nil && x.Field2415 != nil {
+		return *x.Field2415
+	}
+	return ""
+}
+
+func (x *Message2356_Message2359) GetField2416() string {
+	if x != nil && x.Field2416 != nil {
+		return *x.Field2416
+	}
+	return ""
+}
+
+func (x *Message2356_Message2359) GetField2417() int32 {
+	if x != nil && x.Field2417 != nil {
+		return *x.Field2417
+	}
+	return 0
+}
+
+func (x *Message2356_Message2359) GetField2418() string {
+	if x != nil && x.Field2418 != nil {
+		return *x.Field2418
+	}
+	return ""
+}
+
+func (x *Message2356_Message2359) GetField2419() float32 {
+	if x != nil && x.Field2419 != nil {
+		return *x.Field2419
+	}
+	return 0
+}
+
+func (x *Message2356_Message2359) GetField2420() float32 {
+	if x != nil && x.Field2420 != nil {
+		return *x.Field2420
+	}
+	return 0
+}
+
+type Message7029_Message7030 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field7226 *string `protobuf:"bytes,14,opt,name=field7226" json:"field7226,omitempty"`
+	Field7227 *string `protobuf:"bytes,15,opt,name=field7227" json:"field7227,omitempty"`
+	Field7228 *int64  `protobuf:"varint,16,opt,name=field7228" json:"field7228,omitempty"`
+}
+
+func (x *Message7029_Message7030) Reset() {
+	*x = Message7029_Message7030{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[33]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message7029_Message7030) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message7029_Message7030) ProtoMessage() {}
+
+func (x *Message7029_Message7030) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[33]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message7029_Message7030.ProtoReflect.Descriptor instead.
+func (*Message7029_Message7030) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{2, 0}
+}
+
+func (x *Message7029_Message7030) GetField7226() string {
+	if x != nil && x.Field7226 != nil {
+		return *x.Field7226
+	}
+	return ""
+}
+
+func (x *Message7029_Message7030) GetField7227() string {
+	if x != nil && x.Field7227 != nil {
+		return *x.Field7227
+	}
+	return ""
+}
+
+func (x *Message7029_Message7030) GetField7228() int64 {
+	if x != nil && x.Field7228 != nil {
+		return *x.Field7228
+	}
+	return 0
+}
+
+type Message7029_Message7031 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field7229 *string `protobuf:"bytes,22,opt,name=field7229" json:"field7229,omitempty"`
+	Field7230 *int32  `protobuf:"varint,23,opt,name=field7230" json:"field7230,omitempty"`
+	Field7231 *int32  `protobuf:"varint,24,opt,name=field7231" json:"field7231,omitempty"`
+	Field7232 *int32  `protobuf:"varint,30,opt,name=field7232" json:"field7232,omitempty"`
+	Field7233 *int32  `protobuf:"varint,31,opt,name=field7233" json:"field7233,omitempty"`
+	Field7234 *int32  `protobuf:"varint,35,opt,name=field7234" json:"field7234,omitempty"`
+}
+
+func (x *Message7029_Message7031) Reset() {
+	*x = Message7029_Message7031{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[34]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message7029_Message7031) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message7029_Message7031) ProtoMessage() {}
+
+func (x *Message7029_Message7031) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[34]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message7029_Message7031.ProtoReflect.Descriptor instead.
+func (*Message7029_Message7031) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{2, 1}
+}
+
+func (x *Message7029_Message7031) GetField7229() string {
+	if x != nil && x.Field7229 != nil {
+		return *x.Field7229
+	}
+	return ""
+}
+
+func (x *Message7029_Message7031) GetField7230() int32 {
+	if x != nil && x.Field7230 != nil {
+		return *x.Field7230
+	}
+	return 0
+}
+
+func (x *Message7029_Message7031) GetField7231() int32 {
+	if x != nil && x.Field7231 != nil {
+		return *x.Field7231
+	}
+	return 0
+}
+
+func (x *Message7029_Message7031) GetField7232() int32 {
+	if x != nil && x.Field7232 != nil {
+		return *x.Field7232
+	}
+	return 0
+}
+
+func (x *Message7029_Message7031) GetField7233() int32 {
+	if x != nil && x.Field7233 != nil {
+		return *x.Field7233
+	}
+	return 0
+}
+
+func (x *Message7029_Message7031) GetField7234() int32 {
+	if x != nil && x.Field7234 != nil {
+		return *x.Field7234
+	}
+	return 0
+}
+
+type Message18921_Message18922 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field18959 *uint64             `protobuf:"varint,6,opt,name=field18959" json:"field18959,omitempty"`
+	Field18960 *string             `protobuf:"bytes,13,opt,name=field18960" json:"field18960,omitempty"`
+	Field18961 *bool               `protobuf:"varint,21,opt,name=field18961" json:"field18961,omitempty"`
+	Field18962 *bool               `protobuf:"varint,33,opt,name=field18962" json:"field18962,omitempty"`
+	Field18963 *int32              `protobuf:"varint,7,opt,name=field18963" json:"field18963,omitempty"`
+	Field18964 *int32              `protobuf:"varint,8,opt,name=field18964" json:"field18964,omitempty"`
+	Field18965 *string             `protobuf:"bytes,9,opt,name=field18965" json:"field18965,omitempty"`
+	Field18966 *Message18856       `protobuf:"bytes,10,opt,name=field18966" json:"field18966,omitempty"`
+	Field18967 *uint64             `protobuf:"varint,34,opt,name=field18967" json:"field18967,omitempty"`
+	Field18968 *UnusedEmptyMessage `protobuf:"bytes,11,opt,name=field18968" json:"field18968,omitempty"`
+	Field18969 *uint64             `protobuf:"varint,35,opt,name=field18969" json:"field18969,omitempty"`
+	Field18970 *float32            `protobuf:"fixed32,12,opt,name=field18970" json:"field18970,omitempty"`
+	Field18971 []string            `protobuf:"bytes,14,rep,name=field18971" json:"field18971,omitempty"`
+	Field18972 *bool               `protobuf:"varint,15,opt,name=field18972" json:"field18972,omitempty"`
+	Field18973 *bool               `protobuf:"varint,16,opt,name=field18973" json:"field18973,omitempty"`
+	Field18974 *float32            `protobuf:"fixed32,22,opt,name=field18974" json:"field18974,omitempty"`
+	Field18975 *int32              `protobuf:"varint,18,opt,name=field18975" json:"field18975,omitempty"`
+	Field18976 *int32              `protobuf:"varint,19,opt,name=field18976" json:"field18976,omitempty"`
+	Field18977 *int32              `protobuf:"varint,20,opt,name=field18977" json:"field18977,omitempty"`
+	Field18978 *UnusedEmptyMessage `protobuf:"bytes,25,opt,name=field18978" json:"field18978,omitempty"`
+	Field18979 *UnusedEnum         `protobuf:"varint,26,opt,name=field18979,enum=benchmarks.google_message3.UnusedEnum" json:"field18979,omitempty"`
+	Field18980 []string            `protobuf:"bytes,27,rep,name=field18980" json:"field18980,omitempty"`
+	Field18981 *float32            `protobuf:"fixed32,28,opt,name=field18981" json:"field18981,omitempty"`
+}
+
+func (x *Message18921_Message18922) Reset() {
+	*x = Message18921_Message18922{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[35]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message18921_Message18922) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message18921_Message18922) ProtoMessage() {}
+
+func (x *Message18921_Message18922) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[35]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message18921_Message18922.ProtoReflect.Descriptor instead.
+func (*Message18921_Message18922) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{4, 0}
+}
+
+func (x *Message18921_Message18922) GetField18959() uint64 {
+	if x != nil && x.Field18959 != nil {
+		return *x.Field18959
+	}
+	return 0
+}
+
+func (x *Message18921_Message18922) GetField18960() string {
+	if x != nil && x.Field18960 != nil {
+		return *x.Field18960
+	}
+	return ""
+}
+
+func (x *Message18921_Message18922) GetField18961() bool {
+	if x != nil && x.Field18961 != nil {
+		return *x.Field18961
+	}
+	return false
+}
+
+func (x *Message18921_Message18922) GetField18962() bool {
+	if x != nil && x.Field18962 != nil {
+		return *x.Field18962
+	}
+	return false
+}
+
+func (x *Message18921_Message18922) GetField18963() int32 {
+	if x != nil && x.Field18963 != nil {
+		return *x.Field18963
+	}
+	return 0
+}
+
+func (x *Message18921_Message18922) GetField18964() int32 {
+	if x != nil && x.Field18964 != nil {
+		return *x.Field18964
+	}
+	return 0
+}
+
+func (x *Message18921_Message18922) GetField18965() string {
+	if x != nil && x.Field18965 != nil {
+		return *x.Field18965
+	}
+	return ""
+}
+
+func (x *Message18921_Message18922) GetField18966() *Message18856 {
+	if x != nil {
+		return x.Field18966
+	}
+	return nil
+}
+
+func (x *Message18921_Message18922) GetField18967() uint64 {
+	if x != nil && x.Field18967 != nil {
+		return *x.Field18967
+	}
+	return 0
+}
+
+func (x *Message18921_Message18922) GetField18968() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18968
+	}
+	return nil
+}
+
+func (x *Message18921_Message18922) GetField18969() uint64 {
+	if x != nil && x.Field18969 != nil {
+		return *x.Field18969
+	}
+	return 0
+}
+
+func (x *Message18921_Message18922) GetField18970() float32 {
+	if x != nil && x.Field18970 != nil {
+		return *x.Field18970
+	}
+	return 0
+}
+
+func (x *Message18921_Message18922) GetField18971() []string {
+	if x != nil {
+		return x.Field18971
+	}
+	return nil
+}
+
+func (x *Message18921_Message18922) GetField18972() bool {
+	if x != nil && x.Field18972 != nil {
+		return *x.Field18972
+	}
+	return false
+}
+
+func (x *Message18921_Message18922) GetField18973() bool {
+	if x != nil && x.Field18973 != nil {
+		return *x.Field18973
+	}
+	return false
+}
+
+func (x *Message18921_Message18922) GetField18974() float32 {
+	if x != nil && x.Field18974 != nil {
+		return *x.Field18974
+	}
+	return 0
+}
+
+func (x *Message18921_Message18922) GetField18975() int32 {
+	if x != nil && x.Field18975 != nil {
+		return *x.Field18975
+	}
+	return 0
+}
+
+func (x *Message18921_Message18922) GetField18976() int32 {
+	if x != nil && x.Field18976 != nil {
+		return *x.Field18976
+	}
+	return 0
+}
+
+func (x *Message18921_Message18922) GetField18977() int32 {
+	if x != nil && x.Field18977 != nil {
+		return *x.Field18977
+	}
+	return 0
+}
+
+func (x *Message18921_Message18922) GetField18978() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field18978
+	}
+	return nil
+}
+
+func (x *Message18921_Message18922) GetField18979() UnusedEnum {
+	if x != nil && x.Field18979 != nil {
+		return *x.Field18979
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+func (x *Message18921_Message18922) GetField18980() []string {
+	if x != nil {
+		return x.Field18980
+	}
+	return nil
+}
+
+func (x *Message18921_Message18922) GetField18981() float32 {
+	if x != nil && x.Field18981 != nil {
+		return *x.Field18981
+	}
+	return 0
+}
+
+type Message3886_Message3887 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field3932 *string      `protobuf:"bytes,2,req,name=field3932" json:"field3932,omitempty"`
+	Field3933 *string      `protobuf:"bytes,9,opt,name=field3933" json:"field3933,omitempty"`
+	Field3934 *Message3850 `protobuf:"bytes,3,opt,name=field3934" json:"field3934,omitempty"`
+	Field3935 []byte       `protobuf:"bytes,8,opt,name=field3935" json:"field3935,omitempty"`
+}
+
+func (x *Message3886_Message3887) Reset() {
+	*x = Message3886_Message3887{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[36]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message3886_Message3887) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message3886_Message3887) ProtoMessage() {}
+
+func (x *Message3886_Message3887) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[36]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message3886_Message3887.ProtoReflect.Descriptor instead.
+func (*Message3886_Message3887) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP(), []int{6, 0}
+}
+
+func (x *Message3886_Message3887) GetField3932() string {
+	if x != nil && x.Field3932 != nil {
+		return *x.Field3932
+	}
+	return ""
+}
+
+func (x *Message3886_Message3887) GetField3933() string {
+	if x != nil && x.Field3933 != nil {
+		return *x.Field3933
+	}
+	return ""
+}
+
+func (x *Message3886_Message3887) GetField3934() *Message3850 {
+	if x != nil {
+		return x.Field3934
+	}
+	return nil
+}
+
+func (x *Message3886_Message3887) GetField3935() []byte {
+	if x != nil {
+		return x.Field3935
+	}
+	return nil
+}
+
+var File_datasets_google_message3_benchmark_message3_3_proto protoreflect.FileDescriptor
+
+var file_datasets_google_message3_benchmark_message3_3_proto_rawDesc = []byte{
+	0x0a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x5f, 0x33, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1a, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x1a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2f, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x5f, 0x34,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73,
+	0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x5f, 0x35, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x33, 0x64, 0x61, 0x74,
+	0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x5f, 0x37, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x1a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x5f, 0x38, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xa4, 0x05, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x35, 0x35, 0x34, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x35, 0x35, 0x35, 0x36, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x35, 0x35, 0x35, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x35, 0x35, 0x35, 0x37, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x35, 0x35, 0x35, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x35, 0x35, 0x35, 0x38, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x35, 0x35, 0x35, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x35, 0x35, 0x35, 0x39, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x35, 0x35, 0x35, 0x39, 0x12, 0x59, 0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x35, 0x35, 0x34, 0x37, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0a, 0x32, 0x35, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x35, 0x35, 0x34, 0x36, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x35,
+	0x35, 0x34, 0x37, 0x52, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x35, 0x35, 0x34,
+	0x37, 0x12, 0x59, 0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x35, 0x35, 0x34,
+	0x38, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0a, 0x32, 0x35, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x35, 0x35, 0x34,
+	0x36, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x35, 0x35, 0x34, 0x38, 0x52, 0x0c,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x35, 0x35, 0x34, 0x38, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35, 0x36, 0x32, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35, 0x36, 0x32, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35, 0x36, 0x33, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35, 0x36, 0x33, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35, 0x36, 0x34, 0x18, 0x10, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35, 0x36, 0x34, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35, 0x36, 0x35, 0x18, 0x11, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35, 0x36, 0x35, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35, 0x36, 0x36, 0x18, 0x12, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35, 0x36, 0x36, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35, 0x36, 0x37, 0x18, 0x64, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35, 0x36, 0x37, 0x1a, 0x4e, 0x0a, 0x0c,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x35, 0x35, 0x34, 0x37, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35, 0x36, 0x39, 0x18, 0x05, 0x20, 0x02, 0x28, 0x05,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35, 0x36, 0x39, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35, 0x37, 0x30, 0x18, 0x06, 0x20, 0x02, 0x28, 0x05,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35, 0x37, 0x30, 0x1a, 0x4e, 0x0a, 0x0c,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x35, 0x35, 0x34, 0x38, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35, 0x37, 0x31, 0x18, 0x0b, 0x20, 0x02, 0x28, 0x03,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35, 0x37, 0x31, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35, 0x37, 0x32, 0x18, 0x0c, 0x20, 0x02, 0x28, 0x03,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35, 0x37, 0x32, 0x22, 0xca, 0x0f, 0x0a,
+	0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x33, 0x35, 0x36, 0x12, 0x45, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x36, 0x38, 0x18, 0x79, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x37, 0x34, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x33, 0x36, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x36, 0x39,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x36,
+	0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x37, 0x30, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x37, 0x30, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x37, 0x31, 0x18, 0x11, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x37, 0x31, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x37, 0x32, 0x18, 0x03, 0x20, 0x02, 0x28, 0x09,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x37, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x37, 0x33, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x37, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x32, 0x33, 0x37, 0x34, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x33, 0x37, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x33, 0x37, 0x35, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x33, 0x37, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33,
+	0x37, 0x36, 0x18, 0x65, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x33, 0x37, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x37, 0x37,
+	0x18, 0x66, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x37,
+	0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x37, 0x38, 0x18, 0x67,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x37, 0x38, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x37, 0x39, 0x18, 0x68, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x37, 0x39, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x38, 0x30, 0x18, 0x71, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x38, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x38, 0x31, 0x18, 0x72, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x38, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x32, 0x33, 0x38, 0x32, 0x18, 0x73, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x33, 0x38, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x33, 0x38, 0x33, 0x18, 0x75, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x33, 0x38, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33,
+	0x38, 0x34, 0x18, 0x76, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x33, 0x38, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x38, 0x35,
+	0x18, 0x77, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x38,
+	0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x38, 0x36, 0x18, 0x69,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x38, 0x36, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x38, 0x37, 0x18, 0x05, 0x20, 0x01,
+	0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x38, 0x37, 0x12, 0x55, 0x0a,
+	0x0b, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x33, 0x35, 0x37, 0x18, 0x06, 0x20, 0x01,
+	0x28, 0x0a, 0x32, 0x33, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x33, 0x35, 0x36, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x32, 0x33, 0x35, 0x37, 0x52, 0x0b, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x32, 0x33, 0x35, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x38,
+	0x39, 0x18, 0x78, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33,
+	0x38, 0x39, 0x12, 0x55, 0x0a, 0x0b, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x33, 0x35,
+	0x38, 0x18, 0x6b, 0x20, 0x01, 0x28, 0x0a, 0x32, 0x33, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x33, 0x35, 0x36,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x33, 0x35, 0x38, 0x52, 0x0b, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x33, 0x35, 0x38, 0x12, 0x55, 0x0a, 0x0b, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x32, 0x33, 0x35, 0x39, 0x18, 0x28, 0x20, 0x03, 0x28, 0x0a, 0x32, 0x33,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x32, 0x33, 0x35, 0x36, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32,
+	0x33, 0x35, 0x39, 0x52, 0x0b, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x33, 0x35, 0x39,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x39, 0x32, 0x18, 0x32, 0x20,
+	0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x39, 0x32, 0x12, 0x4c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x39, 0x33, 0x18, 0x3c, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55,
+	0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x39, 0x33, 0x12, 0x4c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x39, 0x34, 0x18, 0x46, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x39, 0x34, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x33, 0x39, 0x35, 0x18, 0x50, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65,
+	0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x39, 0x35, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x33, 0x39, 0x36, 0x18, 0x5a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45,
+	0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x32, 0x33, 0x39, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x33, 0x39, 0x37, 0x18, 0x64, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x33, 0x39, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x39,
+	0x38, 0x18, 0x7b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33,
+	0x39, 0x38, 0x1a, 0xf5, 0x02, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x33,
+	0x35, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x39, 0x39, 0x18,
+	0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x39, 0x39,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x30, 0x30, 0x18, 0x0a, 0x20,
+	0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x30, 0x30, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x30, 0x31, 0x18, 0x0b, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x30, 0x31, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x30, 0x32, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x30, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x34, 0x30, 0x33, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x30, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x34, 0x30, 0x34, 0x18, 0x74, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x32, 0x34, 0x30, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x30, 0x35, 0x18, 0x6a, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x34, 0x30, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x30,
+	0x36, 0x18, 0x0e, 0x20, 0x02, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34,
+	0x30, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x30, 0x37, 0x18,
+	0x2d, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x30, 0x37,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x30, 0x38, 0x18, 0x70, 0x20,
+	0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x30, 0x38, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x30, 0x39, 0x18, 0x7a, 0x20, 0x01, 0x28,
+	0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x30, 0x39, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x31, 0x30, 0x18, 0x7c, 0x20, 0x01, 0x28, 0x0c, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x31, 0x30, 0x1a, 0x0d, 0x0a, 0x0b, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x33, 0x35, 0x38, 0x1a, 0xfd, 0x01, 0x0a, 0x0b, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x33, 0x35, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x32, 0x34, 0x31, 0x33, 0x18, 0x29, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x34, 0x31, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x34, 0x31, 0x34, 0x18, 0x2a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x34, 0x31, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34,
+	0x31, 0x35, 0x18, 0x2b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x31, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x31, 0x36,
+	0x18, 0x2c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x31,
+	0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x31, 0x37, 0x18, 0x2e,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x31, 0x37, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x31, 0x38, 0x18, 0x2f, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x31, 0x38, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x31, 0x39, 0x18, 0x6e, 0x20, 0x01, 0x28, 0x02,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x31, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x32, 0x30, 0x18, 0x6f, 0x20, 0x01, 0x28, 0x02, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x32, 0x30, 0x22, 0xf8, 0x0d, 0x0a, 0x0b, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x30, 0x32, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x37, 0x31, 0x38, 0x33, 0x18, 0x01, 0x20, 0x02, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x31, 0x38, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x37, 0x31, 0x38, 0x34, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x31, 0x38, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x31,
+	0x38, 0x35, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37,
+	0x31, 0x38, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x31, 0x38, 0x36,
+	0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x31, 0x38,
+	0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x31, 0x38, 0x37, 0x18, 0x05,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x31, 0x38, 0x37, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x31, 0x38, 0x38, 0x18, 0x06, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x31, 0x38, 0x38, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x31, 0x38, 0x39, 0x18, 0x11, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x31, 0x38, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x37, 0x31, 0x39, 0x30, 0x18, 0x12, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x31, 0x39, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x37, 0x31, 0x39, 0x31, 0x18, 0x31, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x31, 0x39, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x37, 0x31, 0x39, 0x32, 0x18, 0x1c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x31, 0x39, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x31,
+	0x39, 0x33, 0x18, 0x21, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37,
+	0x31, 0x39, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x31, 0x39, 0x34,
+	0x18, 0x19, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x31, 0x39,
+	0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x31, 0x39, 0x35, 0x18, 0x1a,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x31, 0x39, 0x35, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x31, 0x39, 0x36, 0x18, 0x28, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x31, 0x39, 0x36, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x31, 0x39, 0x37, 0x18, 0x29, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x31, 0x39, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x37, 0x31, 0x39, 0x38, 0x18, 0x2a, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x31, 0x39, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x37, 0x31, 0x39, 0x39, 0x18, 0x2b, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x31, 0x39, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x37, 0x32, 0x30, 0x30, 0x18, 0x13, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x32, 0x30, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32,
+	0x30, 0x31, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37,
+	0x32, 0x30, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x30, 0x32,
+	0x18, 0x08, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x30,
+	0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x30, 0x33, 0x18, 0x09,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x30, 0x33, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x30, 0x34, 0x18, 0x0a, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x30, 0x34, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x30, 0x35, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x30, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x30, 0x36, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x30, 0x36, 0x12, 0x55, 0x0a, 0x0b, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x37, 0x30, 0x33, 0x30, 0x18, 0x0d, 0x20, 0x03, 0x28, 0x0a, 0x32, 0x33,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x37, 0x30, 0x32, 0x39, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37,
+	0x30, 0x33, 0x30, 0x52, 0x0b, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x30, 0x33, 0x30,
+	0x12, 0x55, 0x0a, 0x0b, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x30, 0x33, 0x31, 0x18,
+	0x15, 0x20, 0x03, 0x28, 0x0a, 0x32, 0x33, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x30, 0x32, 0x39, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x30, 0x33, 0x31, 0x52, 0x0b, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x37, 0x30, 0x33, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x37, 0x32, 0x30, 0x39, 0x18, 0x14, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x32, 0x30, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32,
+	0x31, 0x30, 0x18, 0x1b, 0x20, 0x01, 0x28, 0x02, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37,
+	0x32, 0x31, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x31, 0x31,
+	0x18, 0x1d, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x31,
+	0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x31, 0x32, 0x18, 0x20,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x31, 0x32, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x31, 0x33, 0x18, 0x30, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x31, 0x33, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x31, 0x34, 0x18, 0x22, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x31, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x31, 0x35, 0x18, 0x24, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x31, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x37, 0x32, 0x31, 0x36, 0x18, 0x25, 0x20, 0x01, 0x28, 0x02, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x32, 0x31, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x37, 0x32, 0x31, 0x37, 0x18, 0x26, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x32, 0x31, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32,
+	0x31, 0x38, 0x18, 0x27, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37,
+	0x32, 0x31, 0x38, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x31, 0x39,
+	0x18, 0x2c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x31,
+	0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x32, 0x30, 0x18, 0x2d,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x32, 0x30, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x32, 0x31, 0x18, 0x2e, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x32, 0x31, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x32, 0x32, 0x18, 0x2f, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x32, 0x32, 0x12, 0x4c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x32, 0x33, 0x18, 0x32, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73,
+	0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x32, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x37, 0x32, 0x32, 0x34, 0x18, 0x33, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x32, 0x32, 0x34, 0x1a, 0x67, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x37, 0x30, 0x33, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37,
+	0x32, 0x32, 0x36, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x37, 0x32, 0x32, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x32,
+	0x37, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32,
+	0x32, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x32, 0x38, 0x18,
+	0x10, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x32, 0x38,
+	0x1a, 0xc1, 0x01, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x30, 0x33, 0x31,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x32, 0x39, 0x18, 0x16, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x32, 0x39, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x33, 0x30, 0x18, 0x17, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x33, 0x30, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x33, 0x31, 0x18, 0x18, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x33, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x32, 0x33, 0x32, 0x18, 0x1e, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x37, 0x32, 0x33, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x32, 0x33, 0x33, 0x18, 0x1f, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x37, 0x32, 0x33, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37,
+	0x32, 0x33, 0x34, 0x18, 0x23, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x37, 0x32, 0x33, 0x34, 0x22, 0x2e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x35, 0x35, 0x33, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35,
+	0x33, 0x39, 0x18, 0x01, 0x20, 0x02, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x35, 0x35, 0x33, 0x39, 0x22, 0xd0, 0x0c, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x31, 0x38, 0x39, 0x32, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x39, 0x34, 0x36, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x38, 0x39, 0x34, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x39, 0x34, 0x37, 0x18, 0x02, 0x20, 0x01, 0x28, 0x06, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x38, 0x39, 0x34, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x39, 0x34, 0x38, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x38, 0x39, 0x34, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x39, 0x34, 0x39, 0x18, 0x04, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x38, 0x39, 0x34, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x39, 0x35, 0x30, 0x18, 0x11, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x38, 0x39, 0x35, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x39, 0x35, 0x31, 0x18, 0x17, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x38, 0x39, 0x35, 0x31, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x39, 0x35, 0x32, 0x18, 0x18, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70,
+	0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x38, 0x39, 0x35, 0x32, 0x12, 0x59, 0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x31, 0x38, 0x39, 0x32, 0x32, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0a, 0x32, 0x35, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x31, 0x38, 0x39, 0x32, 0x31, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x38, 0x39,
+	0x32, 0x32, 0x52, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x38, 0x39, 0x32, 0x32,
+	0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x39, 0x35, 0x34, 0x18, 0x1d,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x39, 0x35, 0x34,
+	0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x39, 0x35, 0x35, 0x18, 0x1e,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x38, 0x39, 0x34, 0x33, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x39, 0x35, 0x35, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x38, 0x39, 0x35, 0x36, 0x18, 0x1f, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x31, 0x38, 0x39, 0x34, 0x34, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x38, 0x39, 0x35, 0x36, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x39,
+	0x35, 0x37, 0x18, 0x20, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74,
+	0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x38, 0x39, 0x35, 0x37, 0x1a, 0xa0, 0x07, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x31, 0x38, 0x39, 0x32, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x39, 0x35, 0x39, 0x18, 0x06, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x38, 0x39, 0x35, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x39, 0x36, 0x30, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x38, 0x39, 0x36, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x39, 0x36, 0x31, 0x18, 0x15, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x38, 0x39, 0x36, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x39, 0x36, 0x32, 0x18, 0x21, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x38, 0x39, 0x36, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x39, 0x36, 0x33, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x38, 0x39, 0x36, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x39, 0x36, 0x34, 0x18, 0x08, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x38, 0x39, 0x36, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x39, 0x36, 0x35, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x38, 0x39, 0x36, 0x35, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38,
+	0x39, 0x36, 0x36, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x38,
+	0x38, 0x35, 0x36, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x39, 0x36, 0x36, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x39, 0x36, 0x37, 0x18, 0x22, 0x20,
+	0x01, 0x28, 0x04, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x39, 0x36, 0x37, 0x12,
+	0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x39, 0x36, 0x38, 0x18, 0x0b, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x39, 0x36, 0x38, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x39, 0x36, 0x39, 0x18, 0x23, 0x20,
+	0x01, 0x28, 0x04, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x39, 0x36, 0x39, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x39, 0x37, 0x30, 0x18, 0x0c, 0x20,
+	0x01, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x39, 0x37, 0x30, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x39, 0x37, 0x31, 0x18, 0x0e, 0x20,
+	0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x39, 0x37, 0x31, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x39, 0x37, 0x32, 0x18, 0x0f, 0x20,
+	0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x39, 0x37, 0x32, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x39, 0x37, 0x33, 0x18, 0x10, 0x20,
+	0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x39, 0x37, 0x33, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x39, 0x37, 0x34, 0x18, 0x16, 0x20,
+	0x01, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x39, 0x37, 0x34, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x39, 0x37, 0x35, 0x18, 0x12, 0x20,
+	0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x39, 0x37, 0x35, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x39, 0x37, 0x36, 0x18, 0x13, 0x20,
+	0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x39, 0x37, 0x36, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x39, 0x37, 0x37, 0x18, 0x14, 0x20,
+	0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x39, 0x37, 0x37, 0x12,
+	0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x39, 0x37, 0x38, 0x18, 0x19, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x39, 0x37, 0x38, 0x12,
+	0x46, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x39, 0x37, 0x39, 0x18, 0x1a, 0x20,
+	0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x38, 0x39, 0x37, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x38, 0x39, 0x38, 0x30, 0x18, 0x1b, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x38, 0x39, 0x38, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x38, 0x39, 0x38, 0x31, 0x18, 0x1c, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x38, 0x39, 0x38, 0x31, 0x22, 0x2e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x35, 0x35, 0x34, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x35, 0x35, 0x34, 0x31, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x35, 0x35, 0x34, 0x31, 0x22, 0x95, 0x02, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x38, 0x38, 0x36, 0x12, 0x55, 0x0a, 0x0b, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x38, 0x38, 0x37, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0a, 0x32, 0x33, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x38, 0x38, 0x36, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x38, 0x38,
+	0x37, 0x52, 0x0b, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x38, 0x38, 0x37, 0x1a, 0xae,
+	0x01, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x38, 0x38, 0x37, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x33, 0x32, 0x18, 0x02, 0x20, 0x02, 0x28,
+	0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x33, 0x32, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x33, 0x33, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x33, 0x33, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x39, 0x33, 0x34, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x38, 0x35, 0x30, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x33,
+	0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x33, 0x35, 0x18, 0x08,
+	0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x33, 0x35, 0x22,
+	0xc5, 0x04, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x37, 0x34, 0x33, 0x12,
+	0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x35, 0x39, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x37, 0x32, 0x31, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x36, 0x37, 0x35, 0x39, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36,
+	0x37, 0x36, 0x30, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x37,
+	0x32, 0x33, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x36, 0x30, 0x12, 0x45, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x36, 0x31, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x37, 0x32, 0x33, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x36, 0x37, 0x36, 0x31, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x36,
+	0x32, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x37, 0x32, 0x35,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x36, 0x32, 0x12, 0x45, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x36, 0x33, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x36, 0x37, 0x32, 0x36, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37,
+	0x36, 0x33, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x36, 0x34, 0x18,
+	0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x37, 0x33, 0x33, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x36, 0x34, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x36, 0x37, 0x36, 0x35, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x36, 0x37, 0x33, 0x34, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x36, 0x35,
+	0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x36, 0x36, 0x18, 0x07, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x37, 0x34, 0x32, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x36, 0x37, 0x36, 0x36, 0x22, 0xd3, 0x03, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x36, 0x37, 0x37, 0x33, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x36, 0x37, 0x39, 0x34, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x36, 0x37, 0x36, 0x39,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x39, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x39, 0x35, 0x18, 0x09, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x39, 0x35, 0x12, 0x44, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x36, 0x37, 0x39, 0x36, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64,
+	0x45, 0x6e, 0x75, 0x6d, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x39, 0x36, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x39, 0x37, 0x18, 0x0b, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x39, 0x37, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x39, 0x38, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x39, 0x38, 0x12, 0x42, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x39, 0x39, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d,
+	0x36, 0x37, 0x37, 0x34, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x39, 0x39, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x38, 0x30, 0x30, 0x18, 0x05, 0x20, 0x01,
+	0x28, 0x01, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x38, 0x30, 0x30, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x38, 0x30, 0x31, 0x18, 0x07, 0x20, 0x01, 0x28, 0x01,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x38, 0x30, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x36, 0x38, 0x30, 0x32, 0x18, 0x08, 0x20, 0x01, 0x28, 0x01, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x38, 0x30, 0x32, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x36, 0x38, 0x30, 0x33, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x36, 0x37,
+	0x38, 0x32, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x38, 0x30, 0x33, 0x22, 0xb9, 0x0a,
+	0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x32, 0x32, 0x34, 0x12, 0x4c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x35, 0x35, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e,
+	0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x35, 0x35, 0x12, 0x45, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x35, 0x36, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x38, 0x31, 0x38, 0x34, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32,
+	0x35, 0x36, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x35, 0x37, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x39, 0x36, 0x36, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x35, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x32, 0x35, 0x38, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x32, 0x35, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x32, 0x35, 0x39, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x32, 0x35, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32,
+	0x36, 0x30, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x32, 0x36, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x36, 0x31,
+	0x18, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x36,
+	0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x36, 0x32, 0x18, 0x08,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x36, 0x32, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x36, 0x33, 0x18, 0x09, 0x20, 0x01,
+	0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x36, 0x33, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x36, 0x34, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x01,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x36, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x36, 0x35, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x36, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x32, 0x36, 0x36, 0x18, 0x0c, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x32, 0x36, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x32, 0x36, 0x37, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x32, 0x36, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32,
+	0x36, 0x38, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x32, 0x36, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x36, 0x39,
+	0x18, 0x0f, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x36,
+	0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x37, 0x30, 0x18, 0x10,
+	0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x37, 0x30, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x37, 0x31, 0x18, 0x11, 0x20, 0x01,
+	0x28, 0x01, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x37, 0x31, 0x12, 0x4c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x37, 0x32, 0x18, 0x12, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e,
+	0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x37, 0x32, 0x12, 0x4c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x37, 0x33, 0x18, 0x13, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73,
+	0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x37, 0x33, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x32, 0x37, 0x34, 0x18, 0x14, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64,
+	0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x32, 0x37, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x32, 0x37, 0x35, 0x18, 0x15, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x32, 0x37, 0x35, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32,
+	0x37, 0x36, 0x18, 0x16, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74,
+	0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x32, 0x37, 0x36, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x37, 0x37,
+	0x18, 0x17, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x37,
+	0x37, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x37, 0x38, 0x18, 0x18,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x37, 0x38, 0x12,
+	0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x37, 0x39, 0x18, 0x19, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x37, 0x39, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x38, 0x30, 0x18, 0x1a, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x38, 0x30, 0x12, 0x4c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x38, 0x31, 0x18, 0x1b, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73,
+	0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x38, 0x31, 0x22, 0xc4, 0x02, 0x0a, 0x0b, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x33, 0x39, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x33, 0x39, 0x35, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x33, 0x39, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x33, 0x39, 0x36, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x33, 0x39, 0x36, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33,
+	0x39, 0x37, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x39, 0x36,
+	0x36, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x39, 0x37, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x39, 0x38, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x39, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x33, 0x39, 0x39, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x39, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x34, 0x30, 0x30, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x34, 0x30, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x34, 0x30, 0x31, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x34, 0x30, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x30,
+	0x32, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34,
+	0x30, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x30, 0x33, 0x18,
+	0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x30, 0x33,
+	0x22, 0xfd, 0x08, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x31, 0x33, 0x30,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x35, 0x36, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x35, 0x36, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x35, 0x37, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x35, 0x37, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x35, 0x38, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x35, 0x38, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x31, 0x35, 0x39, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65,
+	0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x35, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x31, 0x36, 0x30, 0x18, 0x07, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x31, 0x36, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x31, 0x36, 0x31, 0x18, 0x08, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x31, 0x36, 0x31, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x36,
+	0x32, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31,
+	0x36, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x36, 0x33, 0x18,
+	0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x36, 0x33,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x36, 0x34, 0x18, 0x0b, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x36, 0x34, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x36, 0x35, 0x18, 0x0c, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x36, 0x35, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x36, 0x36, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x36, 0x36, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x31, 0x36, 0x37, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65,
+	0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x36, 0x37, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x31, 0x36, 0x38, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45,
+	0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x31, 0x36, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x31, 0x36, 0x39, 0x18, 0x10, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x31, 0x36, 0x39, 0x12, 0x44, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x37,
+	0x30, 0x18, 0x11, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x37, 0x30, 0x12, 0x44, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x31, 0x37, 0x31, 0x18, 0x12, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65,
+	0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x37, 0x31,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x37, 0x32, 0x18, 0x13, 0x20,
+	0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x37, 0x32, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x37, 0x33, 0x18, 0x14, 0x20, 0x01, 0x28,
+	0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x37, 0x33, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x37, 0x34, 0x18, 0x15, 0x20, 0x01, 0x28, 0x01, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x37, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x31, 0x37, 0x35, 0x18, 0x16, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x37, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x31, 0x37, 0x36, 0x18, 0x17, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x31, 0x37, 0x36, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x31, 0x37, 0x37, 0x18, 0x18, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70,
+	0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x31, 0x37, 0x37, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x37,
+	0x38, 0x18, 0x19, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31,
+	0x37, 0x38, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x37, 0x39, 0x18,
+	0x1a, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x37, 0x39,
+	0x22, 0xfa, 0x03, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x34, 0x37, 0x38,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x38, 0x39, 0x18, 0x07, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x38, 0x39, 0x12, 0x45,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x39, 0x30, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x39, 0x36, 0x36, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x34, 0x39, 0x30, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34,
+	0x39, 0x31, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x34, 0x37,
+	0x36, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x39, 0x31, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x39, 0x32, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x39, 0x32, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x34, 0x39, 0x33, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x38, 0x34, 0x37, 0x36, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x39,
+	0x33, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x39, 0x34, 0x18, 0x05,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x34, 0x37, 0x37, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x39, 0x34, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x34, 0x39, 0x35, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x38, 0x34, 0x35, 0x34, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x39, 0x35, 0x12,
+	0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x39, 0x36, 0x18, 0x08, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x39, 0x36, 0x22, 0xc1, 0x04,
+	0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x34, 0x37, 0x39, 0x12, 0x45, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x39, 0x37, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x34, 0x37, 0x35, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x34, 0x39, 0x37, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x39,
+	0x38, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x39, 0x36, 0x36,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x39, 0x38, 0x12, 0x45, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x39, 0x39, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x38, 0x34, 0x37, 0x36, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34,
+	0x39, 0x39, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x30, 0x30, 0x18,
+	0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x34, 0x37, 0x36, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x30, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x35, 0x30, 0x31, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x35, 0x30, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x35, 0x30, 0x32, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x35, 0x30, 0x32, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35,
+	0x30, 0x33, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x39, 0x36,
+	0x36, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x30, 0x33, 0x12, 0x45, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x30, 0x34, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x38, 0x34, 0x35, 0x35, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x35, 0x30, 0x34, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x30, 0x35,
+	0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x30,
+	0x35, 0x22, 0x95, 0x02, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x33,
+	0x31, 0x39, 0x12, 0x45, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x30,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x30, 0x33, 0x32, 0x35, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x31, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x32, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x33, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x34, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x35, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x36, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x36, 0x22, 0x85, 0x01, 0x0a, 0x0b, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x30, 0x31, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x34, 0x30, 0x31, 0x37, 0x18, 0x01, 0x20, 0x02, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x34, 0x30, 0x31, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x34, 0x30, 0x31, 0x38, 0x18, 0x02, 0x20, 0x02, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x34, 0x30, 0x31, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x30,
+	0x31, 0x39, 0x18, 0x03, 0x20, 0x02, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34,
+	0x30, 0x31, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x30, 0x32, 0x30,
+	0x18, 0x04, 0x20, 0x02, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x30, 0x32,
+	0x30, 0x22, 0xdf, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x36,
+	0x36, 0x39, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x36, 0x38, 0x31,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x35, 0x35, 0x39,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x36, 0x38, 0x31, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x36, 0x38, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x02,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x36, 0x38, 0x32, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x36, 0x38, 0x33, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x36, 0x38, 0x33, 0x12, 0x45, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x36, 0x38, 0x34, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e,
+	0x32, 0x25, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e,
+	0x75, 0x6d, 0x31, 0x32, 0x36, 0x37, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32,
+	0x36, 0x38, 0x34, 0x22, 0xce, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31,
+	0x32, 0x38, 0x31, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38,
+	0x33, 0x34, 0x18, 0x01, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x38, 0x33, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38,
+	0x33, 0x35, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x38, 0x33, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38,
+	0x33, 0x36, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x38, 0x33, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38,
+	0x33, 0x37, 0x18, 0x04, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x38, 0x33, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38,
+	0x33, 0x38, 0x18, 0x05, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x38, 0x33, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38,
+	0x33, 0x39, 0x18, 0x06, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x38, 0x33, 0x39, 0x22, 0x8e, 0x02, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x31, 0x32, 0x38, 0x32, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32,
+	0x38, 0x34, 0x30, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x38, 0x34, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32,
+	0x38, 0x34, 0x31, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x38, 0x34, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32,
+	0x38, 0x34, 0x32, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x38, 0x34, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32,
+	0x38, 0x34, 0x33, 0x18, 0x08, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x38, 0x34, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32,
+	0x38, 0x34, 0x34, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x38, 0x34, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32,
+	0x38, 0x34, 0x35, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x38, 0x34, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32,
+	0x38, 0x34, 0x36, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x38, 0x34, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32,
+	0x38, 0x34, 0x37, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x38, 0x34, 0x37, 0x22, 0xae, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x31, 0x32, 0x38, 0x32, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x38, 0x34, 0x38, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x32, 0x38, 0x34, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x38, 0x34, 0x39, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x32, 0x38, 0x34, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x38, 0x35, 0x30, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x32, 0x38, 0x35, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x38, 0x35, 0x31, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x32, 0x38, 0x35, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x38, 0x35, 0x32, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x32, 0x38, 0x35, 0x32, 0x22, 0xd8, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x31, 0x32, 0x38, 0x31, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x38, 0x32, 0x39, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x38, 0x32, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x38, 0x33, 0x30, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x38, 0x33, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x38, 0x33, 0x31, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x38, 0x33, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x38, 0x33, 0x32, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x38, 0x33, 0x32, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x38, 0x33, 0x33, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x31, 0x32, 0x38, 0x31, 0x37, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x33,
+	0x33, 0x22, 0xf8, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x34,
+	0x37, 0x39, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x34, 0x38, 0x34,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x34, 0x38, 0x30,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x34, 0x38, 0x34, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x34, 0x38, 0x35, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x34, 0x38, 0x35, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x34, 0x38, 0x36, 0x18, 0x02, 0x20, 0x01, 0x28, 0x02,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x34, 0x38, 0x36, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x34, 0x38, 0x37, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x34, 0x38, 0x37, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x34, 0x38, 0x38, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x34, 0x38, 0x38, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x34, 0x38, 0x39, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x34, 0x38, 0x39, 0x22, 0xae, 0x01, 0x0a,
+	0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x37, 0x32, 0x32, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x35, 0x32, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x35, 0x32, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x35, 0x33, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x35, 0x33, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x35, 0x34, 0x18, 0x03, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x35, 0x34, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x35, 0x35, 0x18, 0x05, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x35, 0x35, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x35, 0x36, 0x18, 0x04, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x35, 0x36, 0x22, 0x85, 0x04,
+	0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x37, 0x32, 0x34, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x36, 0x31, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x36, 0x31, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x36, 0x32, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x36, 0x32, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x36, 0x33, 0x18, 0x03, 0x20, 0x01,
+	0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x36, 0x33, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x36, 0x34, 0x18, 0x04, 0x20, 0x01,
+	0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x36, 0x34, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x36, 0x35, 0x18, 0x05, 0x20, 0x01,
+	0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x36, 0x35, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x36, 0x36, 0x18, 0x06, 0x20, 0x03,
+	0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x36, 0x36, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x36, 0x37, 0x18, 0x07, 0x20, 0x03,
+	0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x36, 0x37, 0x12, 0x4e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x36, 0x38, 0x18, 0x08, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x36, 0x38, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x36, 0x39, 0x18, 0x09, 0x20, 0x01,
+	0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x36, 0x39, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x37, 0x30, 0x18, 0x0a, 0x20, 0x01,
+	0x28, 0x0d, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x37, 0x30, 0x12, 0x45,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x37, 0x37, 0x31, 0x18, 0x0b, 0x20, 0x01,
+	0x28, 0x0e, 0x32, 0x25, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x45, 0x6e, 0x75, 0x6d, 0x31, 0x36, 0x37, 0x32, 0x38, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x36, 0x37, 0x37, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36,
+	0x37, 0x37, 0x32, 0x18, 0x0c, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x36, 0x37, 0x37, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36,
+	0x37, 0x37, 0x33, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x36, 0x37, 0x37, 0x33, 0x22, 0x0e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x31, 0x37, 0x37, 0x32, 0x38, 0x22, 0xed, 0x04, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x32, 0x34, 0x33, 0x35, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x35, 0x35, 0x39, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x34, 0x35, 0x35, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x35, 0x36, 0x30, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x34, 0x35, 0x36, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x35, 0x36, 0x31, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x34, 0x35, 0x36, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x35, 0x36, 0x32, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x34, 0x35, 0x36, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x35, 0x36, 0x33, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x34, 0x35, 0x36, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x35, 0x36, 0x34, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x34, 0x35, 0x36, 0x34, 0x12, 0x46, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x35, 0x36, 0x35, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6e,
+	0x75, 0x6d, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x36, 0x35, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x36, 0x36, 0x18, 0x06, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x36, 0x36, 0x12, 0x45,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x36, 0x37, 0x18, 0x0c, 0x20, 0x01,
+	0x28, 0x0e, 0x32, 0x25, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x45, 0x6e, 0x75, 0x6d, 0x32, 0x34, 0x33, 0x36, 0x31, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x34, 0x35, 0x36, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34,
+	0x35, 0x36, 0x38, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x34, 0x35, 0x36, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34,
+	0x35, 0x36, 0x39, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x34, 0x35, 0x36, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34,
+	0x35, 0x37, 0x30, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x34, 0x35, 0x37, 0x30, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34,
+	0x35, 0x37, 0x31, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70,
+	0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x34, 0x35, 0x37, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34,
+	0x35, 0x37, 0x32, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x34, 0x35, 0x37, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34,
+	0x35, 0x37, 0x33, 0x18, 0x0f, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x34, 0x35, 0x37, 0x33, 0x22, 0xfc, 0x04, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x32, 0x34, 0x33, 0x37, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x35, 0x38, 0x39, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x34, 0x35, 0x38, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x35, 0x39, 0x30, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x34, 0x35, 0x39, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x35, 0x39, 0x31, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x34, 0x35, 0x39, 0x31, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x35, 0x39, 0x32, 0x18, 0x04, 0x20, 0x02, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32,
+	0x34, 0x33, 0x37, 0x37, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x39, 0x32,
+	0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x39, 0x33, 0x18, 0x05,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x33, 0x31, 0x37, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x39, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x39, 0x34, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x39, 0x34, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x39, 0x35, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x32, 0x34, 0x33, 0x37, 0x38, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x35, 0x39, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35,
+	0x39, 0x36, 0x18, 0x08, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x35, 0x39, 0x36, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35,
+	0x39, 0x37, 0x18, 0x0e, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74,
+	0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x35, 0x39, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35,
+	0x39, 0x38, 0x18, 0x09, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x35, 0x39, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35,
+	0x39, 0x39, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x35, 0x39, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36,
+	0x30, 0x30, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x36, 0x30, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36,
+	0x30, 0x31, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x36, 0x30, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36,
+	0x30, 0x32, 0x18, 0x0d, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x36, 0x30, 0x32, 0x22, 0xee, 0x04, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x32, 0x34, 0x33, 0x36, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34,
+	0x35, 0x37, 0x34, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x34, 0x35, 0x37, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34,
+	0x35, 0x37, 0x35, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x34, 0x35, 0x37, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34,
+	0x35, 0x37, 0x36, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x34, 0x35, 0x37, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34,
+	0x35, 0x37, 0x37, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x34, 0x35, 0x37, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34,
+	0x35, 0x37, 0x38, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x34, 0x35, 0x37, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34,
+	0x35, 0x37, 0x39, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x34, 0x35, 0x37, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34,
+	0x35, 0x38, 0x30, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x34, 0x35, 0x38, 0x30, 0x12, 0x46, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34,
+	0x35, 0x38, 0x31, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6e, 0x75,
+	0x6d, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x38, 0x31, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x38, 0x32, 0x18, 0x0e, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x38, 0x32, 0x12, 0x46, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x35, 0x38, 0x33, 0x18, 0x0f, 0x20, 0x01, 0x28,
+	0x0e, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55,
+	0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x34, 0x35, 0x38, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34,
+	0x35, 0x38, 0x34, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x34, 0x35, 0x38, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34,
+	0x35, 0x38, 0x35, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x34, 0x35, 0x38, 0x35, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34,
+	0x35, 0x38, 0x36, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70,
+	0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x34, 0x35, 0x38, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34,
+	0x35, 0x38, 0x37, 0x18, 0x08, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x34, 0x35, 0x38, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34,
+	0x35, 0x38, 0x38, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x34, 0x35, 0x38, 0x38, 0x42, 0x23, 0x0a, 0x1e, 0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0xf8, 0x01, 0x01,
+}
+
+var (
+	file_datasets_google_message3_benchmark_message3_3_proto_rawDescOnce sync.Once
+	file_datasets_google_message3_benchmark_message3_3_proto_rawDescData = file_datasets_google_message3_benchmark_message3_3_proto_rawDesc
+)
+
+func file_datasets_google_message3_benchmark_message3_3_proto_rawDescGZIP() []byte {
+	file_datasets_google_message3_benchmark_message3_3_proto_rawDescOnce.Do(func() {
+		file_datasets_google_message3_benchmark_message3_3_proto_rawDescData = protoimpl.X.CompressGZIP(file_datasets_google_message3_benchmark_message3_3_proto_rawDescData)
+	})
+	return file_datasets_google_message3_benchmark_message3_3_proto_rawDescData
+}
+
+var file_datasets_google_message3_benchmark_message3_3_proto_msgTypes = make([]protoimpl.MessageInfo, 37)
+var file_datasets_google_message3_benchmark_message3_3_proto_goTypes = []interface{}{
+	(*Message35546)(nil),              // 0: benchmarks.google_message3.Message35546
+	(*Message2356)(nil),               // 1: benchmarks.google_message3.Message2356
+	(*Message7029)(nil),               // 2: benchmarks.google_message3.Message7029
+	(*Message35538)(nil),              // 3: benchmarks.google_message3.Message35538
+	(*Message18921)(nil),              // 4: benchmarks.google_message3.Message18921
+	(*Message35540)(nil),              // 5: benchmarks.google_message3.Message35540
+	(*Message3886)(nil),               // 6: benchmarks.google_message3.Message3886
+	(*Message6743)(nil),               // 7: benchmarks.google_message3.Message6743
+	(*Message6773)(nil),               // 8: benchmarks.google_message3.Message6773
+	(*Message8224)(nil),               // 9: benchmarks.google_message3.Message8224
+	(*Message8392)(nil),               // 10: benchmarks.google_message3.Message8392
+	(*Message8130)(nil),               // 11: benchmarks.google_message3.Message8130
+	(*Message8478)(nil),               // 12: benchmarks.google_message3.Message8478
+	(*Message8479)(nil),               // 13: benchmarks.google_message3.Message8479
+	(*Message10319)(nil),              // 14: benchmarks.google_message3.Message10319
+	(*Message4016)(nil),               // 15: benchmarks.google_message3.Message4016
+	(*Message12669)(nil),              // 16: benchmarks.google_message3.Message12669
+	(*Message12819)(nil),              // 17: benchmarks.google_message3.Message12819
+	(*Message12820)(nil),              // 18: benchmarks.google_message3.Message12820
+	(*Message12821)(nil),              // 19: benchmarks.google_message3.Message12821
+	(*Message12818)(nil),              // 20: benchmarks.google_message3.Message12818
+	(*Message16479)(nil),              // 21: benchmarks.google_message3.Message16479
+	(*Message16722)(nil),              // 22: benchmarks.google_message3.Message16722
+	(*Message16724)(nil),              // 23: benchmarks.google_message3.Message16724
+	(*Message17728)(nil),              // 24: benchmarks.google_message3.Message17728
+	(*Message24356)(nil),              // 25: benchmarks.google_message3.Message24356
+	(*Message24376)(nil),              // 26: benchmarks.google_message3.Message24376
+	(*Message24366)(nil),              // 27: benchmarks.google_message3.Message24366
+	(*Message35546_Message35547)(nil), // 28: benchmarks.google_message3.Message35546.Message35547
+	(*Message35546_Message35548)(nil), // 29: benchmarks.google_message3.Message35546.Message35548
+	(*Message2356_Message2357)(nil),   // 30: benchmarks.google_message3.Message2356.Message2357
+	(*Message2356_Message2358)(nil),   // 31: benchmarks.google_message3.Message2356.Message2358
+	(*Message2356_Message2359)(nil),   // 32: benchmarks.google_message3.Message2356.Message2359
+	(*Message7029_Message7030)(nil),   // 33: benchmarks.google_message3.Message7029.Message7030
+	(*Message7029_Message7031)(nil),   // 34: benchmarks.google_message3.Message7029.Message7031
+	(*Message18921_Message18922)(nil), // 35: benchmarks.google_message3.Message18921.Message18922
+	(*Message3886_Message3887)(nil),   // 36: benchmarks.google_message3.Message3886.Message3887
+	(*Message1374)(nil),               // 37: benchmarks.google_message3.Message1374
+	(*UnusedEmptyMessage)(nil),        // 38: benchmarks.google_message3.UnusedEmptyMessage
+	(*Message18943)(nil),              // 39: benchmarks.google_message3.Message18943
+	(*Message18944)(nil),              // 40: benchmarks.google_message3.Message18944
+	(*Message6721)(nil),               // 41: benchmarks.google_message3.Message6721
+	(*Message6723)(nil),               // 42: benchmarks.google_message3.Message6723
+	(*Message6725)(nil),               // 43: benchmarks.google_message3.Message6725
+	(*Message6726)(nil),               // 44: benchmarks.google_message3.Message6726
+	(*Message6733)(nil),               // 45: benchmarks.google_message3.Message6733
+	(*Message6734)(nil),               // 46: benchmarks.google_message3.Message6734
+	(*Message6742)(nil),               // 47: benchmarks.google_message3.Message6742
+	(Enum6769)(0),                     // 48: benchmarks.google_message3.Enum6769
+	(UnusedEnum)(0),                   // 49: benchmarks.google_message3.UnusedEnum
+	(Enum6774)(0),                     // 50: benchmarks.google_message3.Enum6774
+	(Enum6782)(0),                     // 51: benchmarks.google_message3.Enum6782
+	(*Message8184)(nil),               // 52: benchmarks.google_message3.Message8184
+	(*Message7966)(nil),               // 53: benchmarks.google_message3.Message7966
+	(*Message8476)(nil),               // 54: benchmarks.google_message3.Message8476
+	(*Message8477)(nil),               // 55: benchmarks.google_message3.Message8477
+	(*Message8454)(nil),               // 56: benchmarks.google_message3.Message8454
+	(*Message8475)(nil),               // 57: benchmarks.google_message3.Message8475
+	(*Message8455)(nil),               // 58: benchmarks.google_message3.Message8455
+	(Enum10325)(0),                    // 59: benchmarks.google_message3.Enum10325
+	(*Message12559)(nil),              // 60: benchmarks.google_message3.Message12559
+	(Enum12670)(0),                    // 61: benchmarks.google_message3.Enum12670
+	(*Message12817)(nil),              // 62: benchmarks.google_message3.Message12817
+	(*Message16480)(nil),              // 63: benchmarks.google_message3.Message16480
+	(Enum16728)(0),                    // 64: benchmarks.google_message3.Enum16728
+	(Enum24361)(0),                    // 65: benchmarks.google_message3.Enum24361
+	(*Message24377)(nil),              // 66: benchmarks.google_message3.Message24377
+	(*Message24317)(nil),              // 67: benchmarks.google_message3.Message24317
+	(*Message24378)(nil),              // 68: benchmarks.google_message3.Message24378
+	(*Message18856)(nil),              // 69: benchmarks.google_message3.Message18856
+	(*Message3850)(nil),               // 70: benchmarks.google_message3.Message3850
+}
+var file_datasets_google_message3_benchmark_message3_3_proto_depIdxs = []int32{
+	28, // 0: benchmarks.google_message3.Message35546.message35547:type_name -> benchmarks.google_message3.Message35546.Message35547
+	29, // 1: benchmarks.google_message3.Message35546.message35548:type_name -> benchmarks.google_message3.Message35546.Message35548
+	37, // 2: benchmarks.google_message3.Message2356.field2368:type_name -> benchmarks.google_message3.Message1374
+	30, // 3: benchmarks.google_message3.Message2356.message2357:type_name -> benchmarks.google_message3.Message2356.Message2357
+	31, // 4: benchmarks.google_message3.Message2356.message2358:type_name -> benchmarks.google_message3.Message2356.Message2358
+	32, // 5: benchmarks.google_message3.Message2356.message2359:type_name -> benchmarks.google_message3.Message2356.Message2359
+	38, // 6: benchmarks.google_message3.Message2356.field2393:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	38, // 7: benchmarks.google_message3.Message2356.field2394:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	38, // 8: benchmarks.google_message3.Message2356.field2395:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	38, // 9: benchmarks.google_message3.Message2356.field2396:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	33, // 10: benchmarks.google_message3.Message7029.message7030:type_name -> benchmarks.google_message3.Message7029.Message7030
+	34, // 11: benchmarks.google_message3.Message7029.message7031:type_name -> benchmarks.google_message3.Message7029.Message7031
+	38, // 12: benchmarks.google_message3.Message7029.field7219:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	38, // 13: benchmarks.google_message3.Message7029.field7223:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	38, // 14: benchmarks.google_message3.Message18921.field18952:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	35, // 15: benchmarks.google_message3.Message18921.message18922:type_name -> benchmarks.google_message3.Message18921.Message18922
+	38, // 16: benchmarks.google_message3.Message18921.field18954:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	39, // 17: benchmarks.google_message3.Message18921.field18955:type_name -> benchmarks.google_message3.Message18943
+	40, // 18: benchmarks.google_message3.Message18921.field18956:type_name -> benchmarks.google_message3.Message18944
+	38, // 19: benchmarks.google_message3.Message18921.field18957:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	36, // 20: benchmarks.google_message3.Message3886.message3887:type_name -> benchmarks.google_message3.Message3886.Message3887
+	41, // 21: benchmarks.google_message3.Message6743.field6759:type_name -> benchmarks.google_message3.Message6721
+	42, // 22: benchmarks.google_message3.Message6743.field6760:type_name -> benchmarks.google_message3.Message6723
+	42, // 23: benchmarks.google_message3.Message6743.field6761:type_name -> benchmarks.google_message3.Message6723
+	43, // 24: benchmarks.google_message3.Message6743.field6762:type_name -> benchmarks.google_message3.Message6725
+	44, // 25: benchmarks.google_message3.Message6743.field6763:type_name -> benchmarks.google_message3.Message6726
+	45, // 26: benchmarks.google_message3.Message6743.field6764:type_name -> benchmarks.google_message3.Message6733
+	46, // 27: benchmarks.google_message3.Message6743.field6765:type_name -> benchmarks.google_message3.Message6734
+	47, // 28: benchmarks.google_message3.Message6743.field6766:type_name -> benchmarks.google_message3.Message6742
+	48, // 29: benchmarks.google_message3.Message6773.field6794:type_name -> benchmarks.google_message3.Enum6769
+	49, // 30: benchmarks.google_message3.Message6773.field6796:type_name -> benchmarks.google_message3.UnusedEnum
+	50, // 31: benchmarks.google_message3.Message6773.field6799:type_name -> benchmarks.google_message3.Enum6774
+	51, // 32: benchmarks.google_message3.Message6773.field6803:type_name -> benchmarks.google_message3.Enum6782
+	38, // 33: benchmarks.google_message3.Message8224.field8255:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	52, // 34: benchmarks.google_message3.Message8224.field8256:type_name -> benchmarks.google_message3.Message8184
+	53, // 35: benchmarks.google_message3.Message8224.field8257:type_name -> benchmarks.google_message3.Message7966
+	38, // 36: benchmarks.google_message3.Message8224.field8272:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	38, // 37: benchmarks.google_message3.Message8224.field8273:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	38, // 38: benchmarks.google_message3.Message8224.field8274:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	38, // 39: benchmarks.google_message3.Message8224.field8276:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	38, // 40: benchmarks.google_message3.Message8224.field8277:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	38, // 41: benchmarks.google_message3.Message8224.field8278:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	38, // 42: benchmarks.google_message3.Message8224.field8279:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	38, // 43: benchmarks.google_message3.Message8224.field8281:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	53, // 44: benchmarks.google_message3.Message8392.field8397:type_name -> benchmarks.google_message3.Message7966
+	38, // 45: benchmarks.google_message3.Message8130.field8159:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	38, // 46: benchmarks.google_message3.Message8130.field8162:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	38, // 47: benchmarks.google_message3.Message8130.field8167:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	38, // 48: benchmarks.google_message3.Message8130.field8168:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	49, // 49: benchmarks.google_message3.Message8130.field8170:type_name -> benchmarks.google_message3.UnusedEnum
+	49, // 50: benchmarks.google_message3.Message8130.field8171:type_name -> benchmarks.google_message3.UnusedEnum
+	38, // 51: benchmarks.google_message3.Message8130.field8177:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	38, // 52: benchmarks.google_message3.Message8130.field8178:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	38, // 53: benchmarks.google_message3.Message8130.field8179:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	53, // 54: benchmarks.google_message3.Message8478.field8490:type_name -> benchmarks.google_message3.Message7966
+	54, // 55: benchmarks.google_message3.Message8478.field8491:type_name -> benchmarks.google_message3.Message8476
+	54, // 56: benchmarks.google_message3.Message8478.field8493:type_name -> benchmarks.google_message3.Message8476
+	55, // 57: benchmarks.google_message3.Message8478.field8494:type_name -> benchmarks.google_message3.Message8477
+	56, // 58: benchmarks.google_message3.Message8478.field8495:type_name -> benchmarks.google_message3.Message8454
+	38, // 59: benchmarks.google_message3.Message8478.field8496:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	57, // 60: benchmarks.google_message3.Message8479.field8497:type_name -> benchmarks.google_message3.Message8475
+	53, // 61: benchmarks.google_message3.Message8479.field8498:type_name -> benchmarks.google_message3.Message7966
+	54, // 62: benchmarks.google_message3.Message8479.field8499:type_name -> benchmarks.google_message3.Message8476
+	54, // 63: benchmarks.google_message3.Message8479.field8500:type_name -> benchmarks.google_message3.Message8476
+	53, // 64: benchmarks.google_message3.Message8479.field8503:type_name -> benchmarks.google_message3.Message7966
+	58, // 65: benchmarks.google_message3.Message8479.field8504:type_name -> benchmarks.google_message3.Message8455
+	38, // 66: benchmarks.google_message3.Message8479.field8505:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	59, // 67: benchmarks.google_message3.Message10319.field10340:type_name -> benchmarks.google_message3.Enum10325
+	60, // 68: benchmarks.google_message3.Message12669.field12681:type_name -> benchmarks.google_message3.Message12559
+	61, // 69: benchmarks.google_message3.Message12669.field12684:type_name -> benchmarks.google_message3.Enum12670
+	62, // 70: benchmarks.google_message3.Message12818.field12833:type_name -> benchmarks.google_message3.Message12817
+	63, // 71: benchmarks.google_message3.Message16479.field16484:type_name -> benchmarks.google_message3.Message16480
+	38, // 72: benchmarks.google_message3.Message16724.field16768:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	64, // 73: benchmarks.google_message3.Message16724.field16771:type_name -> benchmarks.google_message3.Enum16728
+	49, // 74: benchmarks.google_message3.Message24356.field24565:type_name -> benchmarks.google_message3.UnusedEnum
+	65, // 75: benchmarks.google_message3.Message24356.field24567:type_name -> benchmarks.google_message3.Enum24361
+	38, // 76: benchmarks.google_message3.Message24356.field24571:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	66, // 77: benchmarks.google_message3.Message24376.field24592:type_name -> benchmarks.google_message3.Message24377
+	67, // 78: benchmarks.google_message3.Message24376.field24593:type_name -> benchmarks.google_message3.Message24317
+	68, // 79: benchmarks.google_message3.Message24376.field24595:type_name -> benchmarks.google_message3.Message24378
+	38, // 80: benchmarks.google_message3.Message24376.field24597:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	49, // 81: benchmarks.google_message3.Message24366.field24581:type_name -> benchmarks.google_message3.UnusedEnum
+	49, // 82: benchmarks.google_message3.Message24366.field24583:type_name -> benchmarks.google_message3.UnusedEnum
+	38, // 83: benchmarks.google_message3.Message24366.field24586:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	69, // 84: benchmarks.google_message3.Message18921.Message18922.field18966:type_name -> benchmarks.google_message3.Message18856
+	38, // 85: benchmarks.google_message3.Message18921.Message18922.field18968:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	38, // 86: benchmarks.google_message3.Message18921.Message18922.field18978:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	49, // 87: benchmarks.google_message3.Message18921.Message18922.field18979:type_name -> benchmarks.google_message3.UnusedEnum
+	70, // 88: benchmarks.google_message3.Message3886.Message3887.field3934:type_name -> benchmarks.google_message3.Message3850
+	89, // [89:89] is the sub-list for method output_type
+	89, // [89:89] is the sub-list for method input_type
+	89, // [89:89] is the sub-list for extension type_name
+	89, // [89:89] is the sub-list for extension extendee
+	0,  // [0:89] is the sub-list for field type_name
+}
+
+func init() { file_datasets_google_message3_benchmark_message3_3_proto_init() }
+func file_datasets_google_message3_benchmark_message3_3_proto_init() {
+	if File_datasets_google_message3_benchmark_message3_3_proto != nil {
+		return
+	}
+	file_datasets_google_message3_benchmark_message3_4_proto_init()
+	file_datasets_google_message3_benchmark_message3_5_proto_init()
+	file_datasets_google_message3_benchmark_message3_7_proto_init()
+	file_datasets_google_message3_benchmark_message3_8_proto_init()
+	if !protoimpl.UnsafeEnabled {
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message35546); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message2356); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message7029); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message35538); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message18921); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message35540); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message3886); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6743); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6773); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8224); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8392); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8130); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8478); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8479); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message10319); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message4016); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12669); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12819); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12820); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12821); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12818); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message16479); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message16722); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message16724); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message17728); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message24356); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message24376); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message24366); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message35546_Message35547); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message35546_Message35548); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message2356_Message2357); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message2356_Message2358); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message2356_Message2359); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message7029_Message7030); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message7029_Message7031); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[35].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message18921_Message18922); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_3_proto_msgTypes[36].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message3886_Message3887); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_datasets_google_message3_benchmark_message3_3_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   37,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_datasets_google_message3_benchmark_message3_3_proto_goTypes,
+		DependencyIndexes: file_datasets_google_message3_benchmark_message3_3_proto_depIdxs,
+		MessageInfos:      file_datasets_google_message3_benchmark_message3_3_proto_msgTypes,
+	}.Build()
+	File_datasets_google_message3_benchmark_message3_3_proto = out.File
+	file_datasets_google_message3_benchmark_message3_3_proto_rawDesc = nil
+	file_datasets_google_message3_benchmark_message3_3_proto_goTypes = nil
+	file_datasets_google_message3_benchmark_message3_3_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3/benchmark_message3_4.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3/benchmark_message3_4.pb.go
new file mode 100644
index 000000000..b23548a81
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3/benchmark_message3_4.pb.go
@@ -0,0 +1,6716 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// LINT: ALLOW_GROUPS
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: datasets/google_message3/benchmark_message3_4.proto
+
+package google_message3
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoiface "google.golang.org/protobuf/runtime/protoiface"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type Message24346 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message24346) Reset() {
+	*x = Message24346{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message24346) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message24346) ProtoMessage() {}
+
+func (x *Message24346) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message24346.ProtoReflect.Descriptor instead.
+func (*Message24346) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{0}
+}
+
+type Message24401 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field24679 *Message24400 `protobuf:"bytes,1,opt,name=field24679" json:"field24679,omitempty"`
+}
+
+func (x *Message24401) Reset() {
+	*x = Message24401{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message24401) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message24401) ProtoMessage() {}
+
+func (x *Message24401) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message24401.ProtoReflect.Descriptor instead.
+func (*Message24401) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *Message24401) GetField24679() *Message24400 {
+	if x != nil {
+		return x.Field24679
+	}
+	return nil
+}
+
+type Message24402 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field24680 *Message24400 `protobuf:"bytes,1,opt,name=field24680" json:"field24680,omitempty"`
+}
+
+func (x *Message24402) Reset() {
+	*x = Message24402{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message24402) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message24402) ProtoMessage() {}
+
+func (x *Message24402) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message24402.ProtoReflect.Descriptor instead.
+func (*Message24402) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *Message24402) GetField24680() *Message24400 {
+	if x != nil {
+		return x.Field24680
+	}
+	return nil
+}
+
+type Message24379 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field24603 *string               `protobuf:"bytes,1,opt,name=field24603" json:"field24603,omitempty"`
+	Field24604 *string               `protobuf:"bytes,2,opt,name=field24604" json:"field24604,omitempty"`
+	Field24605 *string               `protobuf:"bytes,3,opt,name=field24605" json:"field24605,omitempty"`
+	Field24606 *Message24380         `protobuf:"bytes,4,req,name=field24606" json:"field24606,omitempty"`
+	Field24607 *UnusedEmptyMessage   `protobuf:"bytes,5,opt,name=field24607" json:"field24607,omitempty"`
+	Field24608 *string               `protobuf:"bytes,6,opt,name=field24608" json:"field24608,omitempty"`
+	Field24609 *Message24381         `protobuf:"bytes,7,opt,name=field24609" json:"field24609,omitempty"`
+	Field24610 []string              `protobuf:"bytes,8,rep,name=field24610" json:"field24610,omitempty"`
+	Field24611 []*UnusedEmptyMessage `protobuf:"bytes,17,rep,name=field24611" json:"field24611,omitempty"`
+	Field24612 []string              `protobuf:"bytes,9,rep,name=field24612" json:"field24612,omitempty"`
+	Field24613 []string              `protobuf:"bytes,10,rep,name=field24613" json:"field24613,omitempty"`
+	Field24614 []string              `protobuf:"bytes,11,rep,name=field24614" json:"field24614,omitempty"`
+	Field24615 *string               `protobuf:"bytes,14,opt,name=field24615" json:"field24615,omitempty"`
+	Field24616 *string               `protobuf:"bytes,12,opt,name=field24616" json:"field24616,omitempty"`
+	Field24617 *string               `protobuf:"bytes,16,opt,name=field24617" json:"field24617,omitempty"`
+	Field24618 []*UnusedEmptyMessage `protobuf:"bytes,13,rep,name=field24618" json:"field24618,omitempty"`
+	Field24619 []string              `protobuf:"bytes,15,rep,name=field24619" json:"field24619,omitempty"`
+	Field24620 []string              `protobuf:"bytes,18,rep,name=field24620" json:"field24620,omitempty"`
+}
+
+func (x *Message24379) Reset() {
+	*x = Message24379{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message24379) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message24379) ProtoMessage() {}
+
+func (x *Message24379) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message24379.ProtoReflect.Descriptor instead.
+func (*Message24379) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *Message24379) GetField24603() string {
+	if x != nil && x.Field24603 != nil {
+		return *x.Field24603
+	}
+	return ""
+}
+
+func (x *Message24379) GetField24604() string {
+	if x != nil && x.Field24604 != nil {
+		return *x.Field24604
+	}
+	return ""
+}
+
+func (x *Message24379) GetField24605() string {
+	if x != nil && x.Field24605 != nil {
+		return *x.Field24605
+	}
+	return ""
+}
+
+func (x *Message24379) GetField24606() *Message24380 {
+	if x != nil {
+		return x.Field24606
+	}
+	return nil
+}
+
+func (x *Message24379) GetField24607() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field24607
+	}
+	return nil
+}
+
+func (x *Message24379) GetField24608() string {
+	if x != nil && x.Field24608 != nil {
+		return *x.Field24608
+	}
+	return ""
+}
+
+func (x *Message24379) GetField24609() *Message24381 {
+	if x != nil {
+		return x.Field24609
+	}
+	return nil
+}
+
+func (x *Message24379) GetField24610() []string {
+	if x != nil {
+		return x.Field24610
+	}
+	return nil
+}
+
+func (x *Message24379) GetField24611() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field24611
+	}
+	return nil
+}
+
+func (x *Message24379) GetField24612() []string {
+	if x != nil {
+		return x.Field24612
+	}
+	return nil
+}
+
+func (x *Message24379) GetField24613() []string {
+	if x != nil {
+		return x.Field24613
+	}
+	return nil
+}
+
+func (x *Message24379) GetField24614() []string {
+	if x != nil {
+		return x.Field24614
+	}
+	return nil
+}
+
+func (x *Message24379) GetField24615() string {
+	if x != nil && x.Field24615 != nil {
+		return *x.Field24615
+	}
+	return ""
+}
+
+func (x *Message24379) GetField24616() string {
+	if x != nil && x.Field24616 != nil {
+		return *x.Field24616
+	}
+	return ""
+}
+
+func (x *Message24379) GetField24617() string {
+	if x != nil && x.Field24617 != nil {
+		return *x.Field24617
+	}
+	return ""
+}
+
+func (x *Message24379) GetField24618() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field24618
+	}
+	return nil
+}
+
+func (x *Message24379) GetField24619() []string {
+	if x != nil {
+		return x.Field24619
+	}
+	return nil
+}
+
+func (x *Message24379) GetField24620() []string {
+	if x != nil {
+		return x.Field24620
+	}
+	return nil
+}
+
+type Message27358 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field27415 *int32 `protobuf:"varint,1,opt,name=field27415" json:"field27415,omitempty"`
+	Field27416 *int32 `protobuf:"varint,2,opt,name=field27416" json:"field27416,omitempty"`
+}
+
+func (x *Message27358) Reset() {
+	*x = Message27358{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message27358) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message27358) ProtoMessage() {}
+
+func (x *Message27358) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message27358.ProtoReflect.Descriptor instead.
+func (*Message27358) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *Message27358) GetField27415() int32 {
+	if x != nil && x.Field27415 != nil {
+		return *x.Field27415
+	}
+	return 0
+}
+
+func (x *Message27358) GetField27416() int32 {
+	if x != nil && x.Field27416 != nil {
+		return *x.Field27416
+	}
+	return 0
+}
+
+type Message34381 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field34398 *string             `protobuf:"bytes,1,opt,name=field34398" json:"field34398,omitempty"`
+	Field34399 *UnusedEmptyMessage `protobuf:"bytes,2,opt,name=field34399" json:"field34399,omitempty"`
+	Field34400 *UnusedEmptyMessage `protobuf:"bytes,3,opt,name=field34400" json:"field34400,omitempty"`
+	Field34401 *UnusedEmptyMessage `protobuf:"bytes,4,opt,name=field34401" json:"field34401,omitempty"`
+	Field34402 *UnusedEmptyMessage `protobuf:"bytes,5,opt,name=field34402" json:"field34402,omitempty"`
+	Field34403 *bool               `protobuf:"varint,6,opt,name=field34403" json:"field34403,omitempty"`
+	Field34404 *bool               `protobuf:"varint,7,opt,name=field34404" json:"field34404,omitempty"`
+	Field34405 *UnusedEmptyMessage `protobuf:"bytes,8,opt,name=field34405" json:"field34405,omitempty"`
+	Field34406 *bool               `protobuf:"varint,9,opt,name=field34406" json:"field34406,omitempty"`
+	Field34407 *UnusedEmptyMessage `protobuf:"bytes,10,opt,name=field34407" json:"field34407,omitempty"`
+}
+
+func (x *Message34381) Reset() {
+	*x = Message34381{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[5]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message34381) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message34381) ProtoMessage() {}
+
+func (x *Message34381) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[5]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message34381.ProtoReflect.Descriptor instead.
+func (*Message34381) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *Message34381) GetField34398() string {
+	if x != nil && x.Field34398 != nil {
+		return *x.Field34398
+	}
+	return ""
+}
+
+func (x *Message34381) GetField34399() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field34399
+	}
+	return nil
+}
+
+func (x *Message34381) GetField34400() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field34400
+	}
+	return nil
+}
+
+func (x *Message34381) GetField34401() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field34401
+	}
+	return nil
+}
+
+func (x *Message34381) GetField34402() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field34402
+	}
+	return nil
+}
+
+func (x *Message34381) GetField34403() bool {
+	if x != nil && x.Field34403 != nil {
+		return *x.Field34403
+	}
+	return false
+}
+
+func (x *Message34381) GetField34404() bool {
+	if x != nil && x.Field34404 != nil {
+		return *x.Field34404
+	}
+	return false
+}
+
+func (x *Message34381) GetField34405() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field34405
+	}
+	return nil
+}
+
+func (x *Message34381) GetField34406() bool {
+	if x != nil && x.Field34406 != nil {
+		return *x.Field34406
+	}
+	return false
+}
+
+func (x *Message34381) GetField34407() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field34407
+	}
+	return nil
+}
+
+type Message34619 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field34641 *float64            `protobuf:"fixed64,1,opt,name=field34641" json:"field34641,omitempty"`
+	Field34642 *float64            `protobuf:"fixed64,2,opt,name=field34642" json:"field34642,omitempty"`
+	Field34643 *float64            `protobuf:"fixed64,3,opt,name=field34643" json:"field34643,omitempty"`
+	Field34644 *float64            `protobuf:"fixed64,4,opt,name=field34644" json:"field34644,omitempty"`
+	Field34645 *float64            `protobuf:"fixed64,11,opt,name=field34645" json:"field34645,omitempty"`
+	Field34646 *float64            `protobuf:"fixed64,5,opt,name=field34646" json:"field34646,omitempty"`
+	Field34647 *UnusedEmptyMessage `protobuf:"bytes,100,opt,name=field34647" json:"field34647,omitempty"`
+}
+
+func (x *Message34619) Reset() {
+	*x = Message34619{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[6]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message34619) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message34619) ProtoMessage() {}
+
+func (x *Message34619) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[6]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message34619.ProtoReflect.Descriptor instead.
+func (*Message34619) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *Message34619) GetField34641() float64 {
+	if x != nil && x.Field34641 != nil {
+		return *x.Field34641
+	}
+	return 0
+}
+
+func (x *Message34619) GetField34642() float64 {
+	if x != nil && x.Field34642 != nil {
+		return *x.Field34642
+	}
+	return 0
+}
+
+func (x *Message34619) GetField34643() float64 {
+	if x != nil && x.Field34643 != nil {
+		return *x.Field34643
+	}
+	return 0
+}
+
+func (x *Message34619) GetField34644() float64 {
+	if x != nil && x.Field34644 != nil {
+		return *x.Field34644
+	}
+	return 0
+}
+
+func (x *Message34619) GetField34645() float64 {
+	if x != nil && x.Field34645 != nil {
+		return *x.Field34645
+	}
+	return 0
+}
+
+func (x *Message34619) GetField34646() float64 {
+	if x != nil && x.Field34646 != nil {
+		return *x.Field34646
+	}
+	return 0
+}
+
+func (x *Message34619) GetField34647() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field34647
+	}
+	return nil
+}
+
+type Message730 struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+
+	Field897 *string               `protobuf:"bytes,19,opt,name=field897" json:"field897,omitempty"`
+	Field898 []string              `protobuf:"bytes,27,rep,name=field898" json:"field898,omitempty"`
+	Field899 []string              `protobuf:"bytes,28,rep,name=field899" json:"field899,omitempty"`
+	Field900 []string              `protobuf:"bytes,21,rep,name=field900" json:"field900,omitempty"`
+	Field901 *string               `protobuf:"bytes,30,opt,name=field901" json:"field901,omitempty"`
+	Field902 []uint32              `protobuf:"varint,20,rep,name=field902" json:"field902,omitempty"`
+	Field903 []uint32              `protobuf:"varint,32,rep,name=field903" json:"field903,omitempty"`
+	Field904 []string              `protobuf:"bytes,16,rep,name=field904" json:"field904,omitempty"`
+	Field905 []*Message697         `protobuf:"bytes,6,rep,name=field905" json:"field905,omitempty"`
+	Field906 []*Message704         `protobuf:"bytes,7,rep,name=field906" json:"field906,omitempty"`
+	Field907 []string              `protobuf:"bytes,18,rep,name=field907" json:"field907,omitempty"`
+	Field908 []*Message703         `protobuf:"bytes,8,rep,name=field908" json:"field908,omitempty"`
+	Field909 []string              `protobuf:"bytes,9,rep,name=field909" json:"field909,omitempty"`
+	Field910 *Message716           `protobuf:"bytes,10,opt,name=field910" json:"field910,omitempty"`
+	Field911 *Message718           `protobuf:"bytes,11,opt,name=field911" json:"field911,omitempty"`
+	Field912 *bool                 `protobuf:"varint,14,opt,name=field912" json:"field912,omitempty"`
+	Field913 []*Message715         `protobuf:"bytes,4,rep,name=field913" json:"field913,omitempty"`
+	Field914 []string              `protobuf:"bytes,17,rep,name=field914" json:"field914,omitempty"`
+	Field915 []string              `protobuf:"bytes,23,rep,name=field915" json:"field915,omitempty"`
+	Field916 []*Message719         `protobuf:"bytes,24,rep,name=field916" json:"field916,omitempty"`
+	Field917 []*Message728         `protobuf:"bytes,26,rep,name=field917" json:"field917,omitempty"`
+	Field918 []*Message702         `protobuf:"bytes,35,rep,name=field918" json:"field918,omitempty"`
+	Field919 *string               `protobuf:"bytes,36,opt,name=field919" json:"field919,omitempty"`
+	Field920 []string              `protobuf:"bytes,37,rep,name=field920" json:"field920,omitempty"`
+	Field921 *int64                `protobuf:"varint,38,opt,name=field921" json:"field921,omitempty"`
+	Field922 []*UnusedEmptyMessage `protobuf:"bytes,39,rep,name=field922" json:"field922,omitempty"`
+	Field923 []*UnusedEmptyMessage `protobuf:"bytes,1,rep,name=field923" json:"field923,omitempty"`
+	Field924 *UnusedEmptyMessage   `protobuf:"bytes,2,opt,name=field924" json:"field924,omitempty"`
+	Field925 *UnusedEmptyMessage   `protobuf:"bytes,3,opt,name=field925" json:"field925,omitempty"`
+	Field926 *UnusedEmptyMessage   `protobuf:"bytes,5,opt,name=field926" json:"field926,omitempty"`
+	Field927 *UnusedEmptyMessage   `protobuf:"bytes,13,opt,name=field927" json:"field927,omitempty"`
+	Field928 []string              `protobuf:"bytes,22,rep,name=field928" json:"field928,omitempty"`
+	Field929 []byte                `protobuf:"bytes,31,opt,name=field929" json:"field929,omitempty"`
+}
+
+func (x *Message730) Reset() {
+	*x = Message730{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[7]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message730) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message730) ProtoMessage() {}
+
+func (x *Message730) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[7]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message730.ProtoReflect.Descriptor instead.
+func (*Message730) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{7}
+}
+
+var extRange_Message730 = []protoiface.ExtensionRangeV1{
+	{Start: 25, End: 25},
+	{Start: 29, End: 29},
+	{Start: 34, End: 34},
+	{Start: 15, End: 15},
+}
+
+// Deprecated: Use Message730.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*Message730) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_Message730
+}
+
+func (x *Message730) GetField897() string {
+	if x != nil && x.Field897 != nil {
+		return *x.Field897
+	}
+	return ""
+}
+
+func (x *Message730) GetField898() []string {
+	if x != nil {
+		return x.Field898
+	}
+	return nil
+}
+
+func (x *Message730) GetField899() []string {
+	if x != nil {
+		return x.Field899
+	}
+	return nil
+}
+
+func (x *Message730) GetField900() []string {
+	if x != nil {
+		return x.Field900
+	}
+	return nil
+}
+
+func (x *Message730) GetField901() string {
+	if x != nil && x.Field901 != nil {
+		return *x.Field901
+	}
+	return ""
+}
+
+func (x *Message730) GetField902() []uint32 {
+	if x != nil {
+		return x.Field902
+	}
+	return nil
+}
+
+func (x *Message730) GetField903() []uint32 {
+	if x != nil {
+		return x.Field903
+	}
+	return nil
+}
+
+func (x *Message730) GetField904() []string {
+	if x != nil {
+		return x.Field904
+	}
+	return nil
+}
+
+func (x *Message730) GetField905() []*Message697 {
+	if x != nil {
+		return x.Field905
+	}
+	return nil
+}
+
+func (x *Message730) GetField906() []*Message704 {
+	if x != nil {
+		return x.Field906
+	}
+	return nil
+}
+
+func (x *Message730) GetField907() []string {
+	if x != nil {
+		return x.Field907
+	}
+	return nil
+}
+
+func (x *Message730) GetField908() []*Message703 {
+	if x != nil {
+		return x.Field908
+	}
+	return nil
+}
+
+func (x *Message730) GetField909() []string {
+	if x != nil {
+		return x.Field909
+	}
+	return nil
+}
+
+func (x *Message730) GetField910() *Message716 {
+	if x != nil {
+		return x.Field910
+	}
+	return nil
+}
+
+func (x *Message730) GetField911() *Message718 {
+	if x != nil {
+		return x.Field911
+	}
+	return nil
+}
+
+func (x *Message730) GetField912() bool {
+	if x != nil && x.Field912 != nil {
+		return *x.Field912
+	}
+	return false
+}
+
+func (x *Message730) GetField913() []*Message715 {
+	if x != nil {
+		return x.Field913
+	}
+	return nil
+}
+
+func (x *Message730) GetField914() []string {
+	if x != nil {
+		return x.Field914
+	}
+	return nil
+}
+
+func (x *Message730) GetField915() []string {
+	if x != nil {
+		return x.Field915
+	}
+	return nil
+}
+
+func (x *Message730) GetField916() []*Message719 {
+	if x != nil {
+		return x.Field916
+	}
+	return nil
+}
+
+func (x *Message730) GetField917() []*Message728 {
+	if x != nil {
+		return x.Field917
+	}
+	return nil
+}
+
+func (x *Message730) GetField918() []*Message702 {
+	if x != nil {
+		return x.Field918
+	}
+	return nil
+}
+
+func (x *Message730) GetField919() string {
+	if x != nil && x.Field919 != nil {
+		return *x.Field919
+	}
+	return ""
+}
+
+func (x *Message730) GetField920() []string {
+	if x != nil {
+		return x.Field920
+	}
+	return nil
+}
+
+func (x *Message730) GetField921() int64 {
+	if x != nil && x.Field921 != nil {
+		return *x.Field921
+	}
+	return 0
+}
+
+func (x *Message730) GetField922() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field922
+	}
+	return nil
+}
+
+func (x *Message730) GetField923() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field923
+	}
+	return nil
+}
+
+func (x *Message730) GetField924() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field924
+	}
+	return nil
+}
+
+func (x *Message730) GetField925() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field925
+	}
+	return nil
+}
+
+func (x *Message730) GetField926() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field926
+	}
+	return nil
+}
+
+func (x *Message730) GetField927() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field927
+	}
+	return nil
+}
+
+func (x *Message730) GetField928() []string {
+	if x != nil {
+		return x.Field928
+	}
+	return nil
+}
+
+func (x *Message730) GetField929() []byte {
+	if x != nil {
+		return x.Field929
+	}
+	return nil
+}
+
+type Message33958 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field33977   *string                      `protobuf:"bytes,1,opt,name=field33977" json:"field33977,omitempty"`
+	Field33978   *string                      `protobuf:"bytes,9,opt,name=field33978" json:"field33978,omitempty"`
+	Message33959 []*Message33958_Message33959 `protobuf:"group,2,rep,name=Message33959,json=message33959" json:"message33959,omitempty"`
+	Field33980   *Enum33960                   `protobuf:"varint,7,opt,name=field33980,enum=benchmarks.google_message3.Enum33960" json:"field33980,omitempty"`
+}
+
+func (x *Message33958) Reset() {
+	*x = Message33958{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[8]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message33958) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message33958) ProtoMessage() {}
+
+func (x *Message33958) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[8]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message33958.ProtoReflect.Descriptor instead.
+func (*Message33958) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *Message33958) GetField33977() string {
+	if x != nil && x.Field33977 != nil {
+		return *x.Field33977
+	}
+	return ""
+}
+
+func (x *Message33958) GetField33978() string {
+	if x != nil && x.Field33978 != nil {
+		return *x.Field33978
+	}
+	return ""
+}
+
+func (x *Message33958) GetMessage33959() []*Message33958_Message33959 {
+	if x != nil {
+		return x.Message33959
+	}
+	return nil
+}
+
+func (x *Message33958) GetField33980() Enum33960 {
+	if x != nil && x.Field33980 != nil {
+		return *x.Field33980
+	}
+	return Enum33960_ENUM_VALUE33961
+}
+
+type Message6637 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field6670 *UnusedEmptyMessage   `protobuf:"bytes,2,opt,name=field6670" json:"field6670,omitempty"`
+	Field6671 []*UnusedEmptyMessage `protobuf:"bytes,1,rep,name=field6671" json:"field6671,omitempty"`
+	Field6672 *int32                `protobuf:"varint,3,opt,name=field6672" json:"field6672,omitempty"`
+	Field6673 []string              `protobuf:"bytes,4,rep,name=field6673" json:"field6673,omitempty"`
+	Field6674 *UnusedEmptyMessage   `protobuf:"bytes,5,opt,name=field6674" json:"field6674,omitempty"`
+}
+
+func (x *Message6637) Reset() {
+	*x = Message6637{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[9]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6637) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6637) ProtoMessage() {}
+
+func (x *Message6637) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[9]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6637.ProtoReflect.Descriptor instead.
+func (*Message6637) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{9}
+}
+
+func (x *Message6637) GetField6670() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field6670
+	}
+	return nil
+}
+
+func (x *Message6637) GetField6671() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field6671
+	}
+	return nil
+}
+
+func (x *Message6637) GetField6672() int32 {
+	if x != nil && x.Field6672 != nil {
+		return *x.Field6672
+	}
+	return 0
+}
+
+func (x *Message6637) GetField6673() []string {
+	if x != nil {
+		return x.Field6673
+	}
+	return nil
+}
+
+func (x *Message6637) GetField6674() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field6674
+	}
+	return nil
+}
+
+type Message6643 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field6683 *UnusedEmptyMessage   `protobuf:"bytes,3,opt,name=field6683" json:"field6683,omitempty"`
+	Field6684 *UnusedEmptyMessage   `protobuf:"bytes,4,opt,name=field6684" json:"field6684,omitempty"`
+	Field6685 *float64              `protobuf:"fixed64,5,opt,name=field6685" json:"field6685,omitempty"`
+	Field6686 *float64              `protobuf:"fixed64,6,opt,name=field6686" json:"field6686,omitempty"`
+	Field6687 *int32                `protobuf:"varint,1,opt,name=field6687" json:"field6687,omitempty"`
+	Field6688 *int32                `protobuf:"varint,2,opt,name=field6688" json:"field6688,omitempty"`
+	Field6689 *float64              `protobuf:"fixed64,9,opt,name=field6689" json:"field6689,omitempty"`
+	Field6690 []byte                `protobuf:"bytes,10,opt,name=field6690" json:"field6690,omitempty"`
+	Field6691 *int32                `protobuf:"varint,11,opt,name=field6691" json:"field6691,omitempty"`
+	Field6692 *bool                 `protobuf:"varint,12,opt,name=field6692" json:"field6692,omitempty"`
+	Field6693 *bool                 `protobuf:"varint,13,opt,name=field6693" json:"field6693,omitempty"`
+	Field6694 *Message6578          `protobuf:"bytes,15,opt,name=field6694" json:"field6694,omitempty"`
+	Field6695 *UnusedEnum           `protobuf:"varint,16,opt,name=field6695,enum=benchmarks.google_message3.UnusedEnum" json:"field6695,omitempty"`
+	Field6696 *int64                `protobuf:"varint,17,opt,name=field6696" json:"field6696,omitempty"`
+	Field6697 []*UnusedEmptyMessage `protobuf:"bytes,22,rep,name=field6697" json:"field6697,omitempty"`
+	Field6698 *UnusedEmptyMessage   `protobuf:"bytes,19,opt,name=field6698" json:"field6698,omitempty"`
+	Field6699 *UnusedEmptyMessage   `protobuf:"bytes,20,opt,name=field6699" json:"field6699,omitempty"`
+	Field6700 *int32                `protobuf:"varint,21,opt,name=field6700" json:"field6700,omitempty"`
+}
+
+func (x *Message6643) Reset() {
+	*x = Message6643{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[10]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6643) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6643) ProtoMessage() {}
+
+func (x *Message6643) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[10]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6643.ProtoReflect.Descriptor instead.
+func (*Message6643) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{10}
+}
+
+func (x *Message6643) GetField6683() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field6683
+	}
+	return nil
+}
+
+func (x *Message6643) GetField6684() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field6684
+	}
+	return nil
+}
+
+func (x *Message6643) GetField6685() float64 {
+	if x != nil && x.Field6685 != nil {
+		return *x.Field6685
+	}
+	return 0
+}
+
+func (x *Message6643) GetField6686() float64 {
+	if x != nil && x.Field6686 != nil {
+		return *x.Field6686
+	}
+	return 0
+}
+
+func (x *Message6643) GetField6687() int32 {
+	if x != nil && x.Field6687 != nil {
+		return *x.Field6687
+	}
+	return 0
+}
+
+func (x *Message6643) GetField6688() int32 {
+	if x != nil && x.Field6688 != nil {
+		return *x.Field6688
+	}
+	return 0
+}
+
+func (x *Message6643) GetField6689() float64 {
+	if x != nil && x.Field6689 != nil {
+		return *x.Field6689
+	}
+	return 0
+}
+
+func (x *Message6643) GetField6690() []byte {
+	if x != nil {
+		return x.Field6690
+	}
+	return nil
+}
+
+func (x *Message6643) GetField6691() int32 {
+	if x != nil && x.Field6691 != nil {
+		return *x.Field6691
+	}
+	return 0
+}
+
+func (x *Message6643) GetField6692() bool {
+	if x != nil && x.Field6692 != nil {
+		return *x.Field6692
+	}
+	return false
+}
+
+func (x *Message6643) GetField6693() bool {
+	if x != nil && x.Field6693 != nil {
+		return *x.Field6693
+	}
+	return false
+}
+
+func (x *Message6643) GetField6694() *Message6578 {
+	if x != nil {
+		return x.Field6694
+	}
+	return nil
+}
+
+func (x *Message6643) GetField6695() UnusedEnum {
+	if x != nil && x.Field6695 != nil {
+		return *x.Field6695
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+func (x *Message6643) GetField6696() int64 {
+	if x != nil && x.Field6696 != nil {
+		return *x.Field6696
+	}
+	return 0
+}
+
+func (x *Message6643) GetField6697() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field6697
+	}
+	return nil
+}
+
+func (x *Message6643) GetField6698() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field6698
+	}
+	return nil
+}
+
+func (x *Message6643) GetField6699() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field6699
+	}
+	return nil
+}
+
+func (x *Message6643) GetField6700() int32 {
+	if x != nil && x.Field6700 != nil {
+		return *x.Field6700
+	}
+	return 0
+}
+
+type Message6126 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field6152 *string               `protobuf:"bytes,1,req,name=field6152" json:"field6152,omitempty"`
+	Field6153 []*UnusedEmptyMessage `protobuf:"bytes,9,rep,name=field6153" json:"field6153,omitempty"`
+	Field6154 *int32                `protobuf:"varint,14,opt,name=field6154" json:"field6154,omitempty"`
+	Field6155 []byte                `protobuf:"bytes,10,opt,name=field6155" json:"field6155,omitempty"`
+	Field6156 *Message6024          `protobuf:"bytes,12,opt,name=field6156" json:"field6156,omitempty"`
+	Field6157 *int32                `protobuf:"varint,4,opt,name=field6157" json:"field6157,omitempty"`
+	Field6158 *string               `protobuf:"bytes,5,opt,name=field6158" json:"field6158,omitempty"`
+	Field6159 *int32                `protobuf:"varint,6,opt,name=field6159" json:"field6159,omitempty"`
+	Field6160 []int32               `protobuf:"varint,2,rep,name=field6160" json:"field6160,omitempty"`
+	Field6161 []int32               `protobuf:"varint,3,rep,name=field6161" json:"field6161,omitempty"`
+	Field6162 []*Message6052        `protobuf:"bytes,7,rep,name=field6162" json:"field6162,omitempty"`
+	Field6163 []*UnusedEmptyMessage `protobuf:"bytes,11,rep,name=field6163" json:"field6163,omitempty"`
+	Field6164 *Enum6065             `protobuf:"varint,15,opt,name=field6164,enum=benchmarks.google_message3.Enum6065" json:"field6164,omitempty"`
+	Field6165 []*UnusedEmptyMessage `protobuf:"bytes,8,rep,name=field6165" json:"field6165,omitempty"`
+	Field6166 *bool                 `protobuf:"varint,13,opt,name=field6166" json:"field6166,omitempty"`
+	Field6167 *bool                 `protobuf:"varint,16,opt,name=field6167" json:"field6167,omitempty"`
+	Field6168 *bool                 `protobuf:"varint,18,opt,name=field6168" json:"field6168,omitempty"`
+	Field6169 []*Message6054        `protobuf:"bytes,17,rep,name=field6169" json:"field6169,omitempty"`
+	Field6170 *int32                `protobuf:"varint,19,opt,name=field6170" json:"field6170,omitempty"`
+}
+
+func (x *Message6126) Reset() {
+	*x = Message6126{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[11]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6126) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6126) ProtoMessage() {}
+
+func (x *Message6126) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[11]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6126.ProtoReflect.Descriptor instead.
+func (*Message6126) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{11}
+}
+
+func (x *Message6126) GetField6152() string {
+	if x != nil && x.Field6152 != nil {
+		return *x.Field6152
+	}
+	return ""
+}
+
+func (x *Message6126) GetField6153() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field6153
+	}
+	return nil
+}
+
+func (x *Message6126) GetField6154() int32 {
+	if x != nil && x.Field6154 != nil {
+		return *x.Field6154
+	}
+	return 0
+}
+
+func (x *Message6126) GetField6155() []byte {
+	if x != nil {
+		return x.Field6155
+	}
+	return nil
+}
+
+func (x *Message6126) GetField6156() *Message6024 {
+	if x != nil {
+		return x.Field6156
+	}
+	return nil
+}
+
+func (x *Message6126) GetField6157() int32 {
+	if x != nil && x.Field6157 != nil {
+		return *x.Field6157
+	}
+	return 0
+}
+
+func (x *Message6126) GetField6158() string {
+	if x != nil && x.Field6158 != nil {
+		return *x.Field6158
+	}
+	return ""
+}
+
+func (x *Message6126) GetField6159() int32 {
+	if x != nil && x.Field6159 != nil {
+		return *x.Field6159
+	}
+	return 0
+}
+
+func (x *Message6126) GetField6160() []int32 {
+	if x != nil {
+		return x.Field6160
+	}
+	return nil
+}
+
+func (x *Message6126) GetField6161() []int32 {
+	if x != nil {
+		return x.Field6161
+	}
+	return nil
+}
+
+func (x *Message6126) GetField6162() []*Message6052 {
+	if x != nil {
+		return x.Field6162
+	}
+	return nil
+}
+
+func (x *Message6126) GetField6163() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field6163
+	}
+	return nil
+}
+
+func (x *Message6126) GetField6164() Enum6065 {
+	if x != nil && x.Field6164 != nil {
+		return *x.Field6164
+	}
+	return Enum6065_ENUM_VALUE6066
+}
+
+func (x *Message6126) GetField6165() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field6165
+	}
+	return nil
+}
+
+func (x *Message6126) GetField6166() bool {
+	if x != nil && x.Field6166 != nil {
+		return *x.Field6166
+	}
+	return false
+}
+
+func (x *Message6126) GetField6167() bool {
+	if x != nil && x.Field6167 != nil {
+		return *x.Field6167
+	}
+	return false
+}
+
+func (x *Message6126) GetField6168() bool {
+	if x != nil && x.Field6168 != nil {
+		return *x.Field6168
+	}
+	return false
+}
+
+func (x *Message6126) GetField6169() []*Message6054 {
+	if x != nil {
+		return x.Field6169
+	}
+	return nil
+}
+
+func (x *Message6126) GetField6170() int32 {
+	if x != nil && x.Field6170 != nil {
+		return *x.Field6170
+	}
+	return 0
+}
+
+type Message13083 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field13096   *float32                     `protobuf:"fixed32,1,opt,name=field13096" json:"field13096,omitempty"`
+	Message13084 []*Message13083_Message13084 `protobuf:"group,2,rep,name=Message13084,json=message13084" json:"message13084,omitempty"`
+	Field13098   *float32                     `protobuf:"fixed32,44,opt,name=field13098" json:"field13098,omitempty"`
+	Field13099   *float32                     `protobuf:"fixed32,45,opt,name=field13099" json:"field13099,omitempty"`
+	Field13100   *uint64                      `protobuf:"varint,46,opt,name=field13100" json:"field13100,omitempty"`
+	Field13101   *float32                     `protobuf:"fixed32,47,opt,name=field13101" json:"field13101,omitempty"`
+	Message13085 *Message13083_Message13085   `protobuf:"group,16,opt,name=Message13085,json=message13085" json:"message13085,omitempty"`
+	Message13086 []*Message13083_Message13086 `protobuf:"group,23,rep,name=Message13086,json=message13086" json:"message13086,omitempty"`
+	Message13087 []*Message13083_Message13087 `protobuf:"group,29,rep,name=Message13087,json=message13087" json:"message13087,omitempty"`
+	Field13105   *UnusedEmptyMessage          `protobuf:"bytes,43,opt,name=field13105" json:"field13105,omitempty"`
+}
+
+func (x *Message13083) Reset() {
+	*x = Message13083{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[12]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message13083) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message13083) ProtoMessage() {}
+
+func (x *Message13083) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[12]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message13083.ProtoReflect.Descriptor instead.
+func (*Message13083) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{12}
+}
+
+func (x *Message13083) GetField13096() float32 {
+	if x != nil && x.Field13096 != nil {
+		return *x.Field13096
+	}
+	return 0
+}
+
+func (x *Message13083) GetMessage13084() []*Message13083_Message13084 {
+	if x != nil {
+		return x.Message13084
+	}
+	return nil
+}
+
+func (x *Message13083) GetField13098() float32 {
+	if x != nil && x.Field13098 != nil {
+		return *x.Field13098
+	}
+	return 0
+}
+
+func (x *Message13083) GetField13099() float32 {
+	if x != nil && x.Field13099 != nil {
+		return *x.Field13099
+	}
+	return 0
+}
+
+func (x *Message13083) GetField13100() uint64 {
+	if x != nil && x.Field13100 != nil {
+		return *x.Field13100
+	}
+	return 0
+}
+
+func (x *Message13083) GetField13101() float32 {
+	if x != nil && x.Field13101 != nil {
+		return *x.Field13101
+	}
+	return 0
+}
+
+func (x *Message13083) GetMessage13085() *Message13083_Message13085 {
+	if x != nil {
+		return x.Message13085
+	}
+	return nil
+}
+
+func (x *Message13083) GetMessage13086() []*Message13083_Message13086 {
+	if x != nil {
+		return x.Message13086
+	}
+	return nil
+}
+
+func (x *Message13083) GetMessage13087() []*Message13083_Message13087 {
+	if x != nil {
+		return x.Message13087
+	}
+	return nil
+}
+
+func (x *Message13083) GetField13105() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field13105
+	}
+	return nil
+}
+
+type Message13088 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Message13089 []*Message13088_Message13089 `protobuf:"group,1,rep,name=Message13089,json=message13089" json:"message13089,omitempty"`
+	Field13136   *int64                       `protobuf:"varint,4,opt,name=field13136" json:"field13136,omitempty"`
+	Field13137   *bool                        `protobuf:"varint,5,opt,name=field13137" json:"field13137,omitempty"`
+}
+
+func (x *Message13088) Reset() {
+	*x = Message13088{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[13]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message13088) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message13088) ProtoMessage() {}
+
+func (x *Message13088) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[13]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message13088.ProtoReflect.Descriptor instead.
+func (*Message13088) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{13}
+}
+
+func (x *Message13088) GetMessage13089() []*Message13088_Message13089 {
+	if x != nil {
+		return x.Message13089
+	}
+	return nil
+}
+
+func (x *Message13088) GetField13136() int64 {
+	if x != nil && x.Field13136 != nil {
+		return *x.Field13136
+	}
+	return 0
+}
+
+func (x *Message13088) GetField13137() bool {
+	if x != nil && x.Field13137 != nil {
+		return *x.Field13137
+	}
+	return false
+}
+
+type Message10391 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field10411 *Enum10392          `protobuf:"varint,1,opt,name=field10411,enum=benchmarks.google_message3.Enum10392" json:"field10411,omitempty"`
+	Field10412 *UnusedEnum         `protobuf:"varint,2,opt,name=field10412,enum=benchmarks.google_message3.UnusedEnum" json:"field10412,omitempty"`
+	Field10413 *int64              `protobuf:"varint,3,opt,name=field10413" json:"field10413,omitempty"`
+	Field10414 *string             `protobuf:"bytes,4,opt,name=field10414" json:"field10414,omitempty"`
+	Field10415 *string             `protobuf:"bytes,5,opt,name=field10415" json:"field10415,omitempty"`
+	Field10416 []byte              `protobuf:"bytes,6,opt,name=field10416" json:"field10416,omitempty"`
+	Field10417 *bool               `protobuf:"varint,8,opt,name=field10417" json:"field10417,omitempty"`
+	Field10418 *UnusedEmptyMessage `protobuf:"bytes,9,opt,name=field10418" json:"field10418,omitempty"`
+	Field10419 *bool               `protobuf:"varint,10,opt,name=field10419" json:"field10419,omitempty"`
+}
+
+func (x *Message10391) Reset() {
+	*x = Message10391{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[14]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message10391) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message10391) ProtoMessage() {}
+
+func (x *Message10391) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[14]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message10391.ProtoReflect.Descriptor instead.
+func (*Message10391) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{14}
+}
+
+func (x *Message10391) GetField10411() Enum10392 {
+	if x != nil && x.Field10411 != nil {
+		return *x.Field10411
+	}
+	return Enum10392_ENUM_VALUE10393
+}
+
+func (x *Message10391) GetField10412() UnusedEnum {
+	if x != nil && x.Field10412 != nil {
+		return *x.Field10412
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+func (x *Message10391) GetField10413() int64 {
+	if x != nil && x.Field10413 != nil {
+		return *x.Field10413
+	}
+	return 0
+}
+
+func (x *Message10391) GetField10414() string {
+	if x != nil && x.Field10414 != nil {
+		return *x.Field10414
+	}
+	return ""
+}
+
+func (x *Message10391) GetField10415() string {
+	if x != nil && x.Field10415 != nil {
+		return *x.Field10415
+	}
+	return ""
+}
+
+func (x *Message10391) GetField10416() []byte {
+	if x != nil {
+		return x.Field10416
+	}
+	return nil
+}
+
+func (x *Message10391) GetField10417() bool {
+	if x != nil && x.Field10417 != nil {
+		return *x.Field10417
+	}
+	return false
+}
+
+func (x *Message10391) GetField10418() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field10418
+	}
+	return nil
+}
+
+func (x *Message10391) GetField10419() bool {
+	if x != nil && x.Field10419 != nil {
+		return *x.Field10419
+	}
+	return false
+}
+
+type Message11873 struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+
+	Field11876 *string             `protobuf:"bytes,1,opt,name=field11876" json:"field11876,omitempty"`
+	Field11877 *string             `protobuf:"bytes,4,opt,name=field11877" json:"field11877,omitempty"`
+	Field11878 *Message10573       `protobuf:"bytes,5,opt,name=field11878" json:"field11878,omitempty"`
+	Field11879 *Message10582       `protobuf:"bytes,6,opt,name=field11879" json:"field11879,omitempty"`
+	Field11880 *Message10824       `protobuf:"bytes,7,opt,name=field11880" json:"field11880,omitempty"`
+	Field11881 *Message10773       `protobuf:"bytes,12,opt,name=field11881" json:"field11881,omitempty"`
+	Field11882 *Message11866       `protobuf:"bytes,8,opt,name=field11882" json:"field11882,omitempty"`
+	Field11883 *Message10818       `protobuf:"bytes,13,opt,name=field11883" json:"field11883,omitempty"`
+	Field11884 *UnusedEmptyMessage `protobuf:"bytes,16,opt,name=field11884" json:"field11884,omitempty"`
+	Field11885 *Message10155       `protobuf:"bytes,11,opt,name=field11885" json:"field11885,omitempty"`
+	Field11886 *Message10469       `protobuf:"bytes,14,opt,name=field11886" json:"field11886,omitempty"`
+	Field11887 *UnusedEmptyMessage `protobuf:"bytes,15,opt,name=field11887" json:"field11887,omitempty"`
+}
+
+func (x *Message11873) Reset() {
+	*x = Message11873{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[15]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message11873) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message11873) ProtoMessage() {}
+
+func (x *Message11873) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[15]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message11873.ProtoReflect.Descriptor instead.
+func (*Message11873) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{15}
+}
+
+var extRange_Message11873 = []protoiface.ExtensionRangeV1{
+	{Start: 9, End: 9},
+	{Start: 10, End: 10},
+}
+
+// Deprecated: Use Message11873.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*Message11873) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_Message11873
+}
+
+func (x *Message11873) GetField11876() string {
+	if x != nil && x.Field11876 != nil {
+		return *x.Field11876
+	}
+	return ""
+}
+
+func (x *Message11873) GetField11877() string {
+	if x != nil && x.Field11877 != nil {
+		return *x.Field11877
+	}
+	return ""
+}
+
+func (x *Message11873) GetField11878() *Message10573 {
+	if x != nil {
+		return x.Field11878
+	}
+	return nil
+}
+
+func (x *Message11873) GetField11879() *Message10582 {
+	if x != nil {
+		return x.Field11879
+	}
+	return nil
+}
+
+func (x *Message11873) GetField11880() *Message10824 {
+	if x != nil {
+		return x.Field11880
+	}
+	return nil
+}
+
+func (x *Message11873) GetField11881() *Message10773 {
+	if x != nil {
+		return x.Field11881
+	}
+	return nil
+}
+
+func (x *Message11873) GetField11882() *Message11866 {
+	if x != nil {
+		return x.Field11882
+	}
+	return nil
+}
+
+func (x *Message11873) GetField11883() *Message10818 {
+	if x != nil {
+		return x.Field11883
+	}
+	return nil
+}
+
+func (x *Message11873) GetField11884() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field11884
+	}
+	return nil
+}
+
+func (x *Message11873) GetField11885() *Message10155 {
+	if x != nil {
+		return x.Field11885
+	}
+	return nil
+}
+
+func (x *Message11873) GetField11886() *Message10469 {
+	if x != nil {
+		return x.Field11886
+	}
+	return nil
+}
+
+func (x *Message11873) GetField11887() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field11887
+	}
+	return nil
+}
+
+type Message35506 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field35524 *int32                `protobuf:"varint,1,opt,name=field35524" json:"field35524,omitempty"`
+	Field35525 *string               `protobuf:"bytes,2,opt,name=field35525" json:"field35525,omitempty"`
+	Field35526 *Enum35507            `protobuf:"varint,3,opt,name=field35526,enum=benchmarks.google_message3.Enum35507" json:"field35526,omitempty"`
+	Field35527 []*UnusedEmptyMessage `protobuf:"bytes,4,rep,name=field35527" json:"field35527,omitempty"`
+}
+
+func (x *Message35506) Reset() {
+	*x = Message35506{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[16]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message35506) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message35506) ProtoMessage() {}
+
+func (x *Message35506) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[16]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message35506.ProtoReflect.Descriptor instead.
+func (*Message35506) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{16}
+}
+
+func (x *Message35506) GetField35524() int32 {
+	if x != nil && x.Field35524 != nil {
+		return *x.Field35524
+	}
+	return 0
+}
+
+func (x *Message35506) GetField35525() string {
+	if x != nil && x.Field35525 != nil {
+		return *x.Field35525
+	}
+	return ""
+}
+
+func (x *Message35506) GetField35526() Enum35507 {
+	if x != nil && x.Field35526 != nil {
+		return *x.Field35526
+	}
+	return Enum35507_ENUM_VALUE35508
+}
+
+func (x *Message35506) GetField35527() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field35527
+	}
+	return nil
+}
+
+type Message13151 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field13158 []*Message13145 `protobuf:"bytes,1,rep,name=field13158" json:"field13158,omitempty"`
+}
+
+func (x *Message13151) Reset() {
+	*x = Message13151{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[17]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message13151) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message13151) ProtoMessage() {}
+
+func (x *Message13151) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[17]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message13151.ProtoReflect.Descriptor instead.
+func (*Message13151) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{17}
+}
+
+func (x *Message13151) GetField13158() []*Message13145 {
+	if x != nil {
+		return x.Field13158
+	}
+	return nil
+}
+
+type Message18253 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Message18254 []*Message18253_Message18254 `protobuf:"group,1,rep,name=Message18254,json=message18254" json:"message18254,omitempty"`
+}
+
+func (x *Message18253) Reset() {
+	*x = Message18253{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[18]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message18253) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message18253) ProtoMessage() {}
+
+func (x *Message18253) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[18]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message18253.ProtoReflect.Descriptor instead.
+func (*Message18253) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{18}
+}
+
+func (x *Message18253) GetMessage18254() []*Message18253_Message18254 {
+	if x != nil {
+		return x.Message18254
+	}
+	return nil
+}
+
+type Message16685 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field16694 []*Message16686 `protobuf:"bytes,2,rep,name=field16694" json:"field16694,omitempty"`
+}
+
+func (x *Message16685) Reset() {
+	*x = Message16685{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[19]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message16685) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message16685) ProtoMessage() {}
+
+func (x *Message16685) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[19]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message16685.ProtoReflect.Descriptor instead.
+func (*Message16685) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{19}
+}
+
+func (x *Message16685) GetField16694() []*Message16686 {
+	if x != nil {
+		return x.Field16694
+	}
+	return nil
+}
+
+type Message16816 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field16826   *float32                     `protobuf:"fixed32,1,opt,name=field16826" json:"field16826,omitempty"`
+	Field16827   *Enum16819                   `protobuf:"varint,2,opt,name=field16827,enum=benchmarks.google_message3.Enum16819" json:"field16827,omitempty"`
+	Field16828   *float32                     `protobuf:"fixed32,3,opt,name=field16828" json:"field16828,omitempty"`
+	Message16817 []*Message16816_Message16817 `protobuf:"group,4,rep,name=Message16817,json=message16817" json:"message16817,omitempty"`
+	Field16830   *bool                        `protobuf:"varint,7,opt,name=field16830" json:"field16830,omitempty"`
+	Field16831   *bool                        `protobuf:"varint,8,opt,name=field16831" json:"field16831,omitempty"`
+	Message16818 []*Message16816_Message16818 `protobuf:"group,12,rep,name=Message16818,json=message16818" json:"message16818,omitempty"`
+	Field16833   *string                      `protobuf:"bytes,10,opt,name=field16833" json:"field16833,omitempty"`
+	Field16834   *bool                        `protobuf:"varint,13,opt,name=field16834" json:"field16834,omitempty"`
+	Field16835   *bool                        `protobuf:"varint,14,opt,name=field16835" json:"field16835,omitempty"`
+}
+
+func (x *Message16816) Reset() {
+	*x = Message16816{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[20]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message16816) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message16816) ProtoMessage() {}
+
+func (x *Message16816) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[20]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message16816.ProtoReflect.Descriptor instead.
+func (*Message16816) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{20}
+}
+
+func (x *Message16816) GetField16826() float32 {
+	if x != nil && x.Field16826 != nil {
+		return *x.Field16826
+	}
+	return 0
+}
+
+func (x *Message16816) GetField16827() Enum16819 {
+	if x != nil && x.Field16827 != nil {
+		return *x.Field16827
+	}
+	return Enum16819_ENUM_VALUE16820
+}
+
+func (x *Message16816) GetField16828() float32 {
+	if x != nil && x.Field16828 != nil {
+		return *x.Field16828
+	}
+	return 0
+}
+
+func (x *Message16816) GetMessage16817() []*Message16816_Message16817 {
+	if x != nil {
+		return x.Message16817
+	}
+	return nil
+}
+
+func (x *Message16816) GetField16830() bool {
+	if x != nil && x.Field16830 != nil {
+		return *x.Field16830
+	}
+	return false
+}
+
+func (x *Message16816) GetField16831() bool {
+	if x != nil && x.Field16831 != nil {
+		return *x.Field16831
+	}
+	return false
+}
+
+func (x *Message16816) GetMessage16818() []*Message16816_Message16818 {
+	if x != nil {
+		return x.Message16818
+	}
+	return nil
+}
+
+func (x *Message16816) GetField16833() string {
+	if x != nil && x.Field16833 != nil {
+		return *x.Field16833
+	}
+	return ""
+}
+
+func (x *Message16816) GetField16834() bool {
+	if x != nil && x.Field16834 != nil {
+		return *x.Field16834
+	}
+	return false
+}
+
+func (x *Message16816) GetField16835() bool {
+	if x != nil && x.Field16835 != nil {
+		return *x.Field16835
+	}
+	return false
+}
+
+type Message13168 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field13212 *int32        `protobuf:"varint,1,req,name=field13212" json:"field13212,omitempty"`
+	Field13213 *uint64       `protobuf:"fixed64,7,opt,name=field13213" json:"field13213,omitempty"`
+	Field13214 *bool         `protobuf:"varint,8,opt,name=field13214" json:"field13214,omitempty"`
+	Field13215 *uint64       `protobuf:"fixed64,10,opt,name=field13215" json:"field13215,omitempty"`
+	Field13216 *bool         `protobuf:"varint,11,opt,name=field13216" json:"field13216,omitempty"`
+	Field13217 *Message12796 `protobuf:"bytes,9,opt,name=field13217" json:"field13217,omitempty"`
+	Field13218 *float64      `protobuf:"fixed64,2,req,name=field13218" json:"field13218,omitempty"`
+	Field13219 *bool         `protobuf:"varint,3,req,name=field13219" json:"field13219,omitempty"`
+	Field13220 *int32        `protobuf:"varint,4,opt,name=field13220" json:"field13220,omitempty"`
+	Field13221 *bool         `protobuf:"varint,5,req,name=field13221" json:"field13221,omitempty"`
+	Field13222 *int32        `protobuf:"varint,6,opt,name=field13222" json:"field13222,omitempty"`
+}
+
+func (x *Message13168) Reset() {
+	*x = Message13168{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[21]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message13168) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message13168) ProtoMessage() {}
+
+func (x *Message13168) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[21]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message13168.ProtoReflect.Descriptor instead.
+func (*Message13168) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{21}
+}
+
+func (x *Message13168) GetField13212() int32 {
+	if x != nil && x.Field13212 != nil {
+		return *x.Field13212
+	}
+	return 0
+}
+
+func (x *Message13168) GetField13213() uint64 {
+	if x != nil && x.Field13213 != nil {
+		return *x.Field13213
+	}
+	return 0
+}
+
+func (x *Message13168) GetField13214() bool {
+	if x != nil && x.Field13214 != nil {
+		return *x.Field13214
+	}
+	return false
+}
+
+func (x *Message13168) GetField13215() uint64 {
+	if x != nil && x.Field13215 != nil {
+		return *x.Field13215
+	}
+	return 0
+}
+
+func (x *Message13168) GetField13216() bool {
+	if x != nil && x.Field13216 != nil {
+		return *x.Field13216
+	}
+	return false
+}
+
+func (x *Message13168) GetField13217() *Message12796 {
+	if x != nil {
+		return x.Field13217
+	}
+	return nil
+}
+
+func (x *Message13168) GetField13218() float64 {
+	if x != nil && x.Field13218 != nil {
+		return *x.Field13218
+	}
+	return 0
+}
+
+func (x *Message13168) GetField13219() bool {
+	if x != nil && x.Field13219 != nil {
+		return *x.Field13219
+	}
+	return false
+}
+
+func (x *Message13168) GetField13220() int32 {
+	if x != nil && x.Field13220 != nil {
+		return *x.Field13220
+	}
+	return 0
+}
+
+func (x *Message13168) GetField13221() bool {
+	if x != nil && x.Field13221 != nil {
+		return *x.Field13221
+	}
+	return false
+}
+
+func (x *Message13168) GetField13222() int32 {
+	if x != nil && x.Field13222 != nil {
+		return *x.Field13222
+	}
+	return 0
+}
+
+type Message13167 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field13199 *int32        `protobuf:"varint,1,req,name=field13199" json:"field13199,omitempty"`
+	Field13200 *int32        `protobuf:"varint,2,opt,name=field13200" json:"field13200,omitempty"`
+	Field13201 *int32        `protobuf:"varint,3,opt,name=field13201" json:"field13201,omitempty"`
+	Field13202 *bool         `protobuf:"varint,8,opt,name=field13202" json:"field13202,omitempty"`
+	Field13203 *uint64       `protobuf:"fixed64,12,opt,name=field13203" json:"field13203,omitempty"`
+	Field13204 *bool         `protobuf:"varint,13,opt,name=field13204" json:"field13204,omitempty"`
+	Field13205 *Message12796 `protobuf:"bytes,11,opt,name=field13205" json:"field13205,omitempty"`
+	Field13206 *uint64       `protobuf:"fixed64,9,opt,name=field13206" json:"field13206,omitempty"`
+	Field13207 *bool         `protobuf:"varint,10,opt,name=field13207" json:"field13207,omitempty"`
+	Field13208 []int32       `protobuf:"varint,4,rep,name=field13208" json:"field13208,omitempty"`
+	Field13209 *int32        `protobuf:"varint,5,opt,name=field13209" json:"field13209,omitempty"`
+	Field13210 *int32        `protobuf:"varint,6,opt,name=field13210" json:"field13210,omitempty"`
+	Field13211 *int32        `protobuf:"varint,7,opt,name=field13211" json:"field13211,omitempty"`
+}
+
+func (x *Message13167) Reset() {
+	*x = Message13167{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[22]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message13167) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message13167) ProtoMessage() {}
+
+func (x *Message13167) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[22]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message13167.ProtoReflect.Descriptor instead.
+func (*Message13167) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{22}
+}
+
+func (x *Message13167) GetField13199() int32 {
+	if x != nil && x.Field13199 != nil {
+		return *x.Field13199
+	}
+	return 0
+}
+
+func (x *Message13167) GetField13200() int32 {
+	if x != nil && x.Field13200 != nil {
+		return *x.Field13200
+	}
+	return 0
+}
+
+func (x *Message13167) GetField13201() int32 {
+	if x != nil && x.Field13201 != nil {
+		return *x.Field13201
+	}
+	return 0
+}
+
+func (x *Message13167) GetField13202() bool {
+	if x != nil && x.Field13202 != nil {
+		return *x.Field13202
+	}
+	return false
+}
+
+func (x *Message13167) GetField13203() uint64 {
+	if x != nil && x.Field13203 != nil {
+		return *x.Field13203
+	}
+	return 0
+}
+
+func (x *Message13167) GetField13204() bool {
+	if x != nil && x.Field13204 != nil {
+		return *x.Field13204
+	}
+	return false
+}
+
+func (x *Message13167) GetField13205() *Message12796 {
+	if x != nil {
+		return x.Field13205
+	}
+	return nil
+}
+
+func (x *Message13167) GetField13206() uint64 {
+	if x != nil && x.Field13206 != nil {
+		return *x.Field13206
+	}
+	return 0
+}
+
+func (x *Message13167) GetField13207() bool {
+	if x != nil && x.Field13207 != nil {
+		return *x.Field13207
+	}
+	return false
+}
+
+func (x *Message13167) GetField13208() []int32 {
+	if x != nil {
+		return x.Field13208
+	}
+	return nil
+}
+
+func (x *Message13167) GetField13209() int32 {
+	if x != nil && x.Field13209 != nil {
+		return *x.Field13209
+	}
+	return 0
+}
+
+func (x *Message13167) GetField13210() int32 {
+	if x != nil && x.Field13210 != nil {
+		return *x.Field13210
+	}
+	return 0
+}
+
+func (x *Message13167) GetField13211() int32 {
+	if x != nil && x.Field13211 != nil {
+		return *x.Field13211
+	}
+	return 0
+}
+
+type Message1374 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field1375 *string `protobuf:"bytes,1,req,name=field1375" json:"field1375,omitempty"`
+	Field1376 *string `protobuf:"bytes,2,opt,name=field1376" json:"field1376,omitempty"`
+}
+
+func (x *Message1374) Reset() {
+	*x = Message1374{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[23]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message1374) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message1374) ProtoMessage() {}
+
+func (x *Message1374) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[23]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message1374.ProtoReflect.Descriptor instead.
+func (*Message1374) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{23}
+}
+
+func (x *Message1374) GetField1375() string {
+	if x != nil && x.Field1375 != nil {
+		return *x.Field1375
+	}
+	return ""
+}
+
+func (x *Message1374) GetField1376() string {
+	if x != nil && x.Field1376 != nil {
+		return *x.Field1376
+	}
+	return ""
+}
+
+type Message18943 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message18943) Reset() {
+	*x = Message18943{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[24]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message18943) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message18943) ProtoMessage() {}
+
+func (x *Message18943) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[24]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message18943.ProtoReflect.Descriptor instead.
+func (*Message18943) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{24}
+}
+
+type Message18944 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message18944) Reset() {
+	*x = Message18944{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[25]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message18944) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message18944) ProtoMessage() {}
+
+func (x *Message18944) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[25]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message18944.ProtoReflect.Descriptor instead.
+func (*Message18944) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{25}
+}
+
+type Message18856 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field18857 *string  `protobuf:"bytes,1,opt,name=field18857" json:"field18857,omitempty"`
+	Field18858 *string  `protobuf:"bytes,2,opt,name=field18858" json:"field18858,omitempty"`
+	Field18859 *bool    `protobuf:"varint,31,opt,name=field18859" json:"field18859,omitempty"`
+	Field18860 *string  `protobuf:"bytes,26,opt,name=field18860" json:"field18860,omitempty"`
+	Field18861 *string  `protobuf:"bytes,3,opt,name=field18861" json:"field18861,omitempty"`
+	Field18862 *string  `protobuf:"bytes,4,opt,name=field18862" json:"field18862,omitempty"`
+	Field18863 *string  `protobuf:"bytes,5,opt,name=field18863" json:"field18863,omitempty"`
+	Field18864 *string  `protobuf:"bytes,17,opt,name=field18864" json:"field18864,omitempty"`
+	Field18865 *string  `protobuf:"bytes,6,opt,name=field18865" json:"field18865,omitempty"`
+	Field18866 *string  `protobuf:"bytes,7,opt,name=field18866" json:"field18866,omitempty"`
+	Field18867 *string  `protobuf:"bytes,8,opt,name=field18867" json:"field18867,omitempty"`
+	Field18868 *string  `protobuf:"bytes,9,opt,name=field18868" json:"field18868,omitempty"`
+	Field18869 *string  `protobuf:"bytes,10,opt,name=field18869" json:"field18869,omitempty"`
+	Field18870 *string  `protobuf:"bytes,11,opt,name=field18870" json:"field18870,omitempty"`
+	Field18871 *string  `protobuf:"bytes,21,opt,name=field18871" json:"field18871,omitempty"`
+	Field18872 *string  `protobuf:"bytes,18,opt,name=field18872" json:"field18872,omitempty"`
+	Field18873 *string  `protobuf:"bytes,19,opt,name=field18873" json:"field18873,omitempty"`
+	Field18874 *string  `protobuf:"bytes,20,opt,name=field18874" json:"field18874,omitempty"`
+	Field18875 *string  `protobuf:"bytes,22,opt,name=field18875" json:"field18875,omitempty"`
+	Field18876 *string  `protobuf:"bytes,23,opt,name=field18876" json:"field18876,omitempty"`
+	Field18877 *string  `protobuf:"bytes,24,opt,name=field18877" json:"field18877,omitempty"`
+	Field18878 *string  `protobuf:"bytes,25,opt,name=field18878" json:"field18878,omitempty"`
+	Field18879 *string  `protobuf:"bytes,12,opt,name=field18879" json:"field18879,omitempty"`
+	Field18880 *string  `protobuf:"bytes,13,opt,name=field18880" json:"field18880,omitempty"`
+	Field18881 *string  `protobuf:"bytes,29,opt,name=field18881" json:"field18881,omitempty"`
+	Field18882 *string  `protobuf:"bytes,30,opt,name=field18882" json:"field18882,omitempty"`
+	Field18883 *string  `protobuf:"bytes,15,opt,name=field18883" json:"field18883,omitempty"`
+	Field18884 *string  `protobuf:"bytes,16,opt,name=field18884" json:"field18884,omitempty"`
+	Field18885 []string `protobuf:"bytes,14,rep,name=field18885" json:"field18885,omitempty"`
+	Field18886 *string  `protobuf:"bytes,27,opt,name=field18886" json:"field18886,omitempty"`
+	Field18887 *string  `protobuf:"bytes,28,opt,name=field18887" json:"field18887,omitempty"`
+}
+
+func (x *Message18856) Reset() {
+	*x = Message18856{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[26]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message18856) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message18856) ProtoMessage() {}
+
+func (x *Message18856) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[26]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message18856.ProtoReflect.Descriptor instead.
+func (*Message18856) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{26}
+}
+
+func (x *Message18856) GetField18857() string {
+	if x != nil && x.Field18857 != nil {
+		return *x.Field18857
+	}
+	return ""
+}
+
+func (x *Message18856) GetField18858() string {
+	if x != nil && x.Field18858 != nil {
+		return *x.Field18858
+	}
+	return ""
+}
+
+func (x *Message18856) GetField18859() bool {
+	if x != nil && x.Field18859 != nil {
+		return *x.Field18859
+	}
+	return false
+}
+
+func (x *Message18856) GetField18860() string {
+	if x != nil && x.Field18860 != nil {
+		return *x.Field18860
+	}
+	return ""
+}
+
+func (x *Message18856) GetField18861() string {
+	if x != nil && x.Field18861 != nil {
+		return *x.Field18861
+	}
+	return ""
+}
+
+func (x *Message18856) GetField18862() string {
+	if x != nil && x.Field18862 != nil {
+		return *x.Field18862
+	}
+	return ""
+}
+
+func (x *Message18856) GetField18863() string {
+	if x != nil && x.Field18863 != nil {
+		return *x.Field18863
+	}
+	return ""
+}
+
+func (x *Message18856) GetField18864() string {
+	if x != nil && x.Field18864 != nil {
+		return *x.Field18864
+	}
+	return ""
+}
+
+func (x *Message18856) GetField18865() string {
+	if x != nil && x.Field18865 != nil {
+		return *x.Field18865
+	}
+	return ""
+}
+
+func (x *Message18856) GetField18866() string {
+	if x != nil && x.Field18866 != nil {
+		return *x.Field18866
+	}
+	return ""
+}
+
+func (x *Message18856) GetField18867() string {
+	if x != nil && x.Field18867 != nil {
+		return *x.Field18867
+	}
+	return ""
+}
+
+func (x *Message18856) GetField18868() string {
+	if x != nil && x.Field18868 != nil {
+		return *x.Field18868
+	}
+	return ""
+}
+
+func (x *Message18856) GetField18869() string {
+	if x != nil && x.Field18869 != nil {
+		return *x.Field18869
+	}
+	return ""
+}
+
+func (x *Message18856) GetField18870() string {
+	if x != nil && x.Field18870 != nil {
+		return *x.Field18870
+	}
+	return ""
+}
+
+func (x *Message18856) GetField18871() string {
+	if x != nil && x.Field18871 != nil {
+		return *x.Field18871
+	}
+	return ""
+}
+
+func (x *Message18856) GetField18872() string {
+	if x != nil && x.Field18872 != nil {
+		return *x.Field18872
+	}
+	return ""
+}
+
+func (x *Message18856) GetField18873() string {
+	if x != nil && x.Field18873 != nil {
+		return *x.Field18873
+	}
+	return ""
+}
+
+func (x *Message18856) GetField18874() string {
+	if x != nil && x.Field18874 != nil {
+		return *x.Field18874
+	}
+	return ""
+}
+
+func (x *Message18856) GetField18875() string {
+	if x != nil && x.Field18875 != nil {
+		return *x.Field18875
+	}
+	return ""
+}
+
+func (x *Message18856) GetField18876() string {
+	if x != nil && x.Field18876 != nil {
+		return *x.Field18876
+	}
+	return ""
+}
+
+func (x *Message18856) GetField18877() string {
+	if x != nil && x.Field18877 != nil {
+		return *x.Field18877
+	}
+	return ""
+}
+
+func (x *Message18856) GetField18878() string {
+	if x != nil && x.Field18878 != nil {
+		return *x.Field18878
+	}
+	return ""
+}
+
+func (x *Message18856) GetField18879() string {
+	if x != nil && x.Field18879 != nil {
+		return *x.Field18879
+	}
+	return ""
+}
+
+func (x *Message18856) GetField18880() string {
+	if x != nil && x.Field18880 != nil {
+		return *x.Field18880
+	}
+	return ""
+}
+
+func (x *Message18856) GetField18881() string {
+	if x != nil && x.Field18881 != nil {
+		return *x.Field18881
+	}
+	return ""
+}
+
+func (x *Message18856) GetField18882() string {
+	if x != nil && x.Field18882 != nil {
+		return *x.Field18882
+	}
+	return ""
+}
+
+func (x *Message18856) GetField18883() string {
+	if x != nil && x.Field18883 != nil {
+		return *x.Field18883
+	}
+	return ""
+}
+
+func (x *Message18856) GetField18884() string {
+	if x != nil && x.Field18884 != nil {
+		return *x.Field18884
+	}
+	return ""
+}
+
+func (x *Message18856) GetField18885() []string {
+	if x != nil {
+		return x.Field18885
+	}
+	return nil
+}
+
+func (x *Message18856) GetField18886() string {
+	if x != nil && x.Field18886 != nil {
+		return *x.Field18886
+	}
+	return ""
+}
+
+func (x *Message18856) GetField18887() string {
+	if x != nil && x.Field18887 != nil {
+		return *x.Field18887
+	}
+	return ""
+}
+
+type Message3850 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field3924 *Enum3851 `protobuf:"varint,2,opt,name=field3924,enum=benchmarks.google_message3.Enum3851" json:"field3924,omitempty"`
+	Field3925 *bool     `protobuf:"varint,12,opt,name=field3925" json:"field3925,omitempty"`
+	Field3926 *int32    `protobuf:"varint,4,opt,name=field3926" json:"field3926,omitempty"`
+	Field3927 *bool     `protobuf:"varint,10,opt,name=field3927" json:"field3927,omitempty"`
+	Field3928 *bool     `protobuf:"varint,13,opt,name=field3928" json:"field3928,omitempty"`
+	Field3929 *bool     `protobuf:"varint,14,opt,name=field3929" json:"field3929,omitempty"`
+}
+
+func (x *Message3850) Reset() {
+	*x = Message3850{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[27]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message3850) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message3850) ProtoMessage() {}
+
+func (x *Message3850) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[27]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message3850.ProtoReflect.Descriptor instead.
+func (*Message3850) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{27}
+}
+
+func (x *Message3850) GetField3924() Enum3851 {
+	if x != nil && x.Field3924 != nil {
+		return *x.Field3924
+	}
+	return Enum3851_ENUM_VALUE3852
+}
+
+func (x *Message3850) GetField3925() bool {
+	if x != nil && x.Field3925 != nil {
+		return *x.Field3925
+	}
+	return false
+}
+
+func (x *Message3850) GetField3926() int32 {
+	if x != nil && x.Field3926 != nil {
+		return *x.Field3926
+	}
+	return 0
+}
+
+func (x *Message3850) GetField3927() bool {
+	if x != nil && x.Field3927 != nil {
+		return *x.Field3927
+	}
+	return false
+}
+
+func (x *Message3850) GetField3928() bool {
+	if x != nil && x.Field3928 != nil {
+		return *x.Field3928
+	}
+	return false
+}
+
+func (x *Message3850) GetField3929() bool {
+	if x != nil && x.Field3929 != nil {
+		return *x.Field3929
+	}
+	return false
+}
+
+type Message6721 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field6744 *Message6722 `protobuf:"bytes,1,opt,name=field6744" json:"field6744,omitempty"`
+	Field6745 *bool        `protobuf:"varint,2,opt,name=field6745" json:"field6745,omitempty"`
+	Field6746 *bool        `protobuf:"varint,3,opt,name=field6746" json:"field6746,omitempty"`
+	Field6747 *bool        `protobuf:"varint,4,opt,name=field6747" json:"field6747,omitempty"`
+}
+
+func (x *Message6721) Reset() {
+	*x = Message6721{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[28]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6721) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6721) ProtoMessage() {}
+
+func (x *Message6721) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[28]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6721.ProtoReflect.Descriptor instead.
+func (*Message6721) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{28}
+}
+
+func (x *Message6721) GetField6744() *Message6722 {
+	if x != nil {
+		return x.Field6744
+	}
+	return nil
+}
+
+func (x *Message6721) GetField6745() bool {
+	if x != nil && x.Field6745 != nil {
+		return *x.Field6745
+	}
+	return false
+}
+
+func (x *Message6721) GetField6746() bool {
+	if x != nil && x.Field6746 != nil {
+		return *x.Field6746
+	}
+	return false
+}
+
+func (x *Message6721) GetField6747() bool {
+	if x != nil && x.Field6747 != nil {
+		return *x.Field6747
+	}
+	return false
+}
+
+type Message6742 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field6758 *bool `protobuf:"varint,1,opt,name=field6758" json:"field6758,omitempty"`
+}
+
+func (x *Message6742) Reset() {
+	*x = Message6742{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[29]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6742) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6742) ProtoMessage() {}
+
+func (x *Message6742) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[29]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6742.ProtoReflect.Descriptor instead.
+func (*Message6742) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{29}
+}
+
+func (x *Message6742) GetField6758() bool {
+	if x != nil && x.Field6758 != nil {
+		return *x.Field6758
+	}
+	return false
+}
+
+type Message6726 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field6752 *int64         `protobuf:"varint,1,opt,name=field6752" json:"field6752,omitempty"`
+	Field6753 []*Message6727 `protobuf:"bytes,2,rep,name=field6753" json:"field6753,omitempty"`
+}
+
+func (x *Message6726) Reset() {
+	*x = Message6726{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[30]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6726) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6726) ProtoMessage() {}
+
+func (x *Message6726) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[30]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6726.ProtoReflect.Descriptor instead.
+func (*Message6726) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{30}
+}
+
+func (x *Message6726) GetField6752() int64 {
+	if x != nil && x.Field6752 != nil {
+		return *x.Field6752
+	}
+	return 0
+}
+
+func (x *Message6726) GetField6753() []*Message6727 {
+	if x != nil {
+		return x.Field6753
+	}
+	return nil
+}
+
+type Message6733 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field6754 *int64 `protobuf:"varint,1,opt,name=field6754" json:"field6754,omitempty"`
+	Field6755 *int64 `protobuf:"varint,2,opt,name=field6755" json:"field6755,omitempty"`
+	Field6756 *bool  `protobuf:"varint,3,opt,name=field6756" json:"field6756,omitempty"`
+}
+
+func (x *Message6733) Reset() {
+	*x = Message6733{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[31]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6733) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6733) ProtoMessage() {}
+
+func (x *Message6733) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[31]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6733.ProtoReflect.Descriptor instead.
+func (*Message6733) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{31}
+}
+
+func (x *Message6733) GetField6754() int64 {
+	if x != nil && x.Field6754 != nil {
+		return *x.Field6754
+	}
+	return 0
+}
+
+func (x *Message6733) GetField6755() int64 {
+	if x != nil && x.Field6755 != nil {
+		return *x.Field6755
+	}
+	return 0
+}
+
+func (x *Message6733) GetField6756() bool {
+	if x != nil && x.Field6756 != nil {
+		return *x.Field6756
+	}
+	return false
+}
+
+type Message6723 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field6748 *int64         `protobuf:"varint,1,opt,name=field6748" json:"field6748,omitempty"`
+	Field6749 []*Message6724 `protobuf:"bytes,2,rep,name=field6749" json:"field6749,omitempty"`
+}
+
+func (x *Message6723) Reset() {
+	*x = Message6723{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[32]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6723) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6723) ProtoMessage() {}
+
+func (x *Message6723) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[32]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6723.ProtoReflect.Descriptor instead.
+func (*Message6723) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{32}
+}
+
+func (x *Message6723) GetField6748() int64 {
+	if x != nil && x.Field6748 != nil {
+		return *x.Field6748
+	}
+	return 0
+}
+
+func (x *Message6723) GetField6749() []*Message6724 {
+	if x != nil {
+		return x.Field6749
+	}
+	return nil
+}
+
+type Message6725 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field6750 *int32 `protobuf:"varint,1,opt,name=field6750" json:"field6750,omitempty"`
+	Field6751 *int32 `protobuf:"varint,2,opt,name=field6751" json:"field6751,omitempty"`
+}
+
+func (x *Message6725) Reset() {
+	*x = Message6725{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[33]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6725) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6725) ProtoMessage() {}
+
+func (x *Message6725) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[33]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6725.ProtoReflect.Descriptor instead.
+func (*Message6725) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{33}
+}
+
+func (x *Message6725) GetField6750() int32 {
+	if x != nil && x.Field6750 != nil {
+		return *x.Field6750
+	}
+	return 0
+}
+
+func (x *Message6725) GetField6751() int32 {
+	if x != nil && x.Field6751 != nil {
+		return *x.Field6751
+	}
+	return 0
+}
+
+type Message6734 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field6757 []*Message6735 `protobuf:"bytes,1,rep,name=field6757" json:"field6757,omitempty"`
+}
+
+func (x *Message6734) Reset() {
+	*x = Message6734{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[34]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6734) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6734) ProtoMessage() {}
+
+func (x *Message6734) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[34]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6734.ProtoReflect.Descriptor instead.
+func (*Message6734) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{34}
+}
+
+func (x *Message6734) GetField6757() []*Message6735 {
+	if x != nil {
+		return x.Field6757
+	}
+	return nil
+}
+
+type Message8184 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field8228 *Message7966   `protobuf:"bytes,1,opt,name=field8228" json:"field8228,omitempty"`
+	Field8229 *bool          `protobuf:"varint,2,opt,name=field8229" json:"field8229,omitempty"`
+	Field8230 []*Message8183 `protobuf:"bytes,3,rep,name=field8230" json:"field8230,omitempty"`
+}
+
+func (x *Message8184) Reset() {
+	*x = Message8184{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[35]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8184) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8184) ProtoMessage() {}
+
+func (x *Message8184) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[35]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8184.ProtoReflect.Descriptor instead.
+func (*Message8184) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{35}
+}
+
+func (x *Message8184) GetField8228() *Message7966 {
+	if x != nil {
+		return x.Field8228
+	}
+	return nil
+}
+
+func (x *Message8184) GetField8229() bool {
+	if x != nil && x.Field8229 != nil {
+		return *x.Field8229
+	}
+	return false
+}
+
+func (x *Message8184) GetField8230() []*Message8183 {
+	if x != nil {
+		return x.Field8230
+	}
+	return nil
+}
+
+type Message8477 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field8486 *Message7966 `protobuf:"bytes,1,opt,name=field8486" json:"field8486,omitempty"`
+	Field8487 *int64       `protobuf:"varint,2,opt,name=field8487" json:"field8487,omitempty"`
+	Field8488 *string      `protobuf:"bytes,3,opt,name=field8488" json:"field8488,omitempty"`
+}
+
+func (x *Message8477) Reset() {
+	*x = Message8477{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[36]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8477) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8477) ProtoMessage() {}
+
+func (x *Message8477) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[36]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8477.ProtoReflect.Descriptor instead.
+func (*Message8477) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{36}
+}
+
+func (x *Message8477) GetField8486() *Message7966 {
+	if x != nil {
+		return x.Field8486
+	}
+	return nil
+}
+
+func (x *Message8477) GetField8487() int64 {
+	if x != nil && x.Field8487 != nil {
+		return *x.Field8487
+	}
+	return 0
+}
+
+func (x *Message8477) GetField8488() string {
+	if x != nil && x.Field8488 != nil {
+		return *x.Field8488
+	}
+	return ""
+}
+
+type Message8454 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field8465 *Message8449 `protobuf:"bytes,1,opt,name=field8465" json:"field8465,omitempty"`
+	Field8466 *int64       `protobuf:"varint,3,opt,name=field8466" json:"field8466,omitempty"`
+	Field8467 *int32       `protobuf:"varint,4,opt,name=field8467" json:"field8467,omitempty"`
+	Field8468 *bool        `protobuf:"varint,5,opt,name=field8468" json:"field8468,omitempty"`
+}
+
+func (x *Message8454) Reset() {
+	*x = Message8454{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[37]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8454) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8454) ProtoMessage() {}
+
+func (x *Message8454) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[37]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8454.ProtoReflect.Descriptor instead.
+func (*Message8454) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{37}
+}
+
+func (x *Message8454) GetField8465() *Message8449 {
+	if x != nil {
+		return x.Field8465
+	}
+	return nil
+}
+
+func (x *Message8454) GetField8466() int64 {
+	if x != nil && x.Field8466 != nil {
+		return *x.Field8466
+	}
+	return 0
+}
+
+func (x *Message8454) GetField8467() int32 {
+	if x != nil && x.Field8467 != nil {
+		return *x.Field8467
+	}
+	return 0
+}
+
+func (x *Message8454) GetField8468() bool {
+	if x != nil && x.Field8468 != nil {
+		return *x.Field8468
+	}
+	return false
+}
+
+type Message8476 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field8483 *string `protobuf:"bytes,1,opt,name=field8483" json:"field8483,omitempty"`
+	Field8484 *string `protobuf:"bytes,2,opt,name=field8484" json:"field8484,omitempty"`
+	Field8485 *string `protobuf:"bytes,3,opt,name=field8485" json:"field8485,omitempty"`
+}
+
+func (x *Message8476) Reset() {
+	*x = Message8476{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[38]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8476) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8476) ProtoMessage() {}
+
+func (x *Message8476) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[38]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8476.ProtoReflect.Descriptor instead.
+func (*Message8476) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{38}
+}
+
+func (x *Message8476) GetField8483() string {
+	if x != nil && x.Field8483 != nil {
+		return *x.Field8483
+	}
+	return ""
+}
+
+func (x *Message8476) GetField8484() string {
+	if x != nil && x.Field8484 != nil {
+		return *x.Field8484
+	}
+	return ""
+}
+
+func (x *Message8476) GetField8485() string {
+	if x != nil && x.Field8485 != nil {
+		return *x.Field8485
+	}
+	return ""
+}
+
+type Message8455 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field8470 *Message8449        `protobuf:"bytes,1,opt,name=field8470" json:"field8470,omitempty"`
+	Field8471 []*Message8456      `protobuf:"bytes,2,rep,name=field8471" json:"field8471,omitempty"`
+	Field8472 *Message8457        `protobuf:"bytes,5,opt,name=field8472" json:"field8472,omitempty"`
+	Field8473 *UnusedEmptyMessage `protobuf:"bytes,6,opt,name=field8473" json:"field8473,omitempty"`
+}
+
+func (x *Message8455) Reset() {
+	*x = Message8455{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[39]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8455) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8455) ProtoMessage() {}
+
+func (x *Message8455) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[39]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8455.ProtoReflect.Descriptor instead.
+func (*Message8455) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{39}
+}
+
+func (x *Message8455) GetField8470() *Message8449 {
+	if x != nil {
+		return x.Field8470
+	}
+	return nil
+}
+
+func (x *Message8455) GetField8471() []*Message8456 {
+	if x != nil {
+		return x.Field8471
+	}
+	return nil
+}
+
+func (x *Message8455) GetField8472() *Message8457 {
+	if x != nil {
+		return x.Field8472
+	}
+	return nil
+}
+
+func (x *Message8455) GetField8473() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8473
+	}
+	return nil
+}
+
+type Message8475 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field8481 *string `protobuf:"bytes,1,opt,name=field8481" json:"field8481,omitempty"`
+	Field8482 *int64  `protobuf:"varint,2,opt,name=field8482" json:"field8482,omitempty"`
+}
+
+func (x *Message8475) Reset() {
+	*x = Message8475{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[40]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8475) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8475) ProtoMessage() {}
+
+func (x *Message8475) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[40]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8475.ProtoReflect.Descriptor instead.
+func (*Message8475) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{40}
+}
+
+func (x *Message8475) GetField8481() string {
+	if x != nil && x.Field8481 != nil {
+		return *x.Field8481
+	}
+	return ""
+}
+
+func (x *Message8475) GetField8482() int64 {
+	if x != nil && x.Field8482 != nil {
+		return *x.Field8482
+	}
+	return 0
+}
+
+type Message12559 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message12559) Reset() {
+	*x = Message12559{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[41]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12559) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12559) ProtoMessage() {}
+
+func (x *Message12559) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[41]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12559.ProtoReflect.Descriptor instead.
+func (*Message12559) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{41}
+}
+
+type Message12817 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12826 *int32 `protobuf:"varint,1,opt,name=field12826" json:"field12826,omitempty"`
+	Field12827 *int32 `protobuf:"varint,2,opt,name=field12827" json:"field12827,omitempty"`
+	Field12828 *int32 `protobuf:"varint,3,opt,name=field12828" json:"field12828,omitempty"`
+}
+
+func (x *Message12817) Reset() {
+	*x = Message12817{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[42]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12817) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12817) ProtoMessage() {}
+
+func (x *Message12817) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[42]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12817.ProtoReflect.Descriptor instead.
+func (*Message12817) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{42}
+}
+
+func (x *Message12817) GetField12826() int32 {
+	if x != nil && x.Field12826 != nil {
+		return *x.Field12826
+	}
+	return 0
+}
+
+func (x *Message12817) GetField12827() int32 {
+	if x != nil && x.Field12827 != nil {
+		return *x.Field12827
+	}
+	return 0
+}
+
+func (x *Message12817) GetField12828() int32 {
+	if x != nil && x.Field12828 != nil {
+		return *x.Field12828
+	}
+	return 0
+}
+
+type Message16480 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field16490 *Message13358 `protobuf:"bytes,1,opt,name=field16490" json:"field16490,omitempty"`
+	Field16491 *Enum16042    `protobuf:"varint,2,opt,name=field16491,enum=benchmarks.google_message3.Enum16042" json:"field16491,omitempty"`
+	Field16492 *Message13912 `protobuf:"bytes,3,opt,name=field16492" json:"field16492,omitempty"`
+	Field16493 *string       `protobuf:"bytes,4,opt,name=field16493" json:"field16493,omitempty"`
+	Field16494 *string       `protobuf:"bytes,5,opt,name=field16494" json:"field16494,omitempty"`
+	Field16495 *string       `protobuf:"bytes,6,opt,name=field16495" json:"field16495,omitempty"`
+	Field16496 *string       `protobuf:"bytes,7,opt,name=field16496" json:"field16496,omitempty"`
+	Field16497 *Message13358 `protobuf:"bytes,8,opt,name=field16497" json:"field16497,omitempty"`
+	Field16498 *uint32       `protobuf:"fixed32,9,opt,name=field16498" json:"field16498,omitempty"`
+}
+
+func (x *Message16480) Reset() {
+	*x = Message16480{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[43]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message16480) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message16480) ProtoMessage() {}
+
+func (x *Message16480) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[43]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message16480.ProtoReflect.Descriptor instead.
+func (*Message16480) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{43}
+}
+
+func (x *Message16480) GetField16490() *Message13358 {
+	if x != nil {
+		return x.Field16490
+	}
+	return nil
+}
+
+func (x *Message16480) GetField16491() Enum16042 {
+	if x != nil && x.Field16491 != nil {
+		return *x.Field16491
+	}
+	return Enum16042_ENUM_VALUE16043
+}
+
+func (x *Message16480) GetField16492() *Message13912 {
+	if x != nil {
+		return x.Field16492
+	}
+	return nil
+}
+
+func (x *Message16480) GetField16493() string {
+	if x != nil && x.Field16493 != nil {
+		return *x.Field16493
+	}
+	return ""
+}
+
+func (x *Message16480) GetField16494() string {
+	if x != nil && x.Field16494 != nil {
+		return *x.Field16494
+	}
+	return ""
+}
+
+func (x *Message16480) GetField16495() string {
+	if x != nil && x.Field16495 != nil {
+		return *x.Field16495
+	}
+	return ""
+}
+
+func (x *Message16480) GetField16496() string {
+	if x != nil && x.Field16496 != nil {
+		return *x.Field16496
+	}
+	return ""
+}
+
+func (x *Message16480) GetField16497() *Message13358 {
+	if x != nil {
+		return x.Field16497
+	}
+	return nil
+}
+
+func (x *Message16480) GetField16498() uint32 {
+	if x != nil && x.Field16498 != nil {
+		return *x.Field16498
+	}
+	return 0
+}
+
+type Message24317 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field24446 *string               `protobuf:"bytes,1,opt,name=field24446" json:"field24446,omitempty"`
+	Field24447 *Message24312         `protobuf:"bytes,2,opt,name=field24447" json:"field24447,omitempty"`
+	Field24448 []*Message24315       `protobuf:"bytes,3,rep,name=field24448" json:"field24448,omitempty"`
+	Field24449 []*Message24313       `protobuf:"bytes,4,rep,name=field24449" json:"field24449,omitempty"`
+	Field24450 []*Message24316       `protobuf:"bytes,5,rep,name=field24450" json:"field24450,omitempty"`
+	Field24451 []*UnusedEmptyMessage `protobuf:"bytes,6,rep,name=field24451" json:"field24451,omitempty"`
+	Field24452 *UnusedEmptyMessage   `protobuf:"bytes,7,opt,name=field24452" json:"field24452,omitempty"`
+	Field24453 []string              `protobuf:"bytes,8,rep,name=field24453" json:"field24453,omitempty"`
+	Field24454 []string              `protobuf:"bytes,9,rep,name=field24454" json:"field24454,omitempty"`
+	Field24455 []string              `protobuf:"bytes,10,rep,name=field24455" json:"field24455,omitempty"`
+	Field24456 []string              `protobuf:"bytes,28,rep,name=field24456" json:"field24456,omitempty"`
+	Field24457 *string               `protobuf:"bytes,11,opt,name=field24457" json:"field24457,omitempty"`
+	Field24458 *string               `protobuf:"bytes,12,opt,name=field24458" json:"field24458,omitempty"`
+	Field24459 *string               `protobuf:"bytes,13,opt,name=field24459" json:"field24459,omitempty"`
+	Field24460 *string               `protobuf:"bytes,14,opt,name=field24460" json:"field24460,omitempty"`
+	Field24461 []string              `protobuf:"bytes,15,rep,name=field24461" json:"field24461,omitempty"`
+	Field24462 *string               `protobuf:"bytes,16,opt,name=field24462" json:"field24462,omitempty"`
+	Field24463 []string              `protobuf:"bytes,17,rep,name=field24463" json:"field24463,omitempty"`
+	Field24464 []string              `protobuf:"bytes,18,rep,name=field24464" json:"field24464,omitempty"`
+	Field24465 []string              `protobuf:"bytes,19,rep,name=field24465" json:"field24465,omitempty"`
+	Field24466 []string              `protobuf:"bytes,20,rep,name=field24466" json:"field24466,omitempty"`
+	Field24467 []string              `protobuf:"bytes,21,rep,name=field24467" json:"field24467,omitempty"`
+	Field24468 []string              `protobuf:"bytes,22,rep,name=field24468" json:"field24468,omitempty"`
+	Field24469 []string              `protobuf:"bytes,23,rep,name=field24469" json:"field24469,omitempty"`
+	Field24470 []string              `protobuf:"bytes,24,rep,name=field24470" json:"field24470,omitempty"`
+	Field24471 *string               `protobuf:"bytes,25,opt,name=field24471" json:"field24471,omitempty"`
+	Field24472 *string               `protobuf:"bytes,26,opt,name=field24472" json:"field24472,omitempty"`
+	Field24473 []string              `protobuf:"bytes,27,rep,name=field24473" json:"field24473,omitempty"`
+	Field24474 *bool                 `protobuf:"varint,40,opt,name=field24474" json:"field24474,omitempty"`
+}
+
+func (x *Message24317) Reset() {
+	*x = Message24317{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[44]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message24317) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message24317) ProtoMessage() {}
+
+func (x *Message24317) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[44]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message24317.ProtoReflect.Descriptor instead.
+func (*Message24317) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{44}
+}
+
+func (x *Message24317) GetField24446() string {
+	if x != nil && x.Field24446 != nil {
+		return *x.Field24446
+	}
+	return ""
+}
+
+func (x *Message24317) GetField24447() *Message24312 {
+	if x != nil {
+		return x.Field24447
+	}
+	return nil
+}
+
+func (x *Message24317) GetField24448() []*Message24315 {
+	if x != nil {
+		return x.Field24448
+	}
+	return nil
+}
+
+func (x *Message24317) GetField24449() []*Message24313 {
+	if x != nil {
+		return x.Field24449
+	}
+	return nil
+}
+
+func (x *Message24317) GetField24450() []*Message24316 {
+	if x != nil {
+		return x.Field24450
+	}
+	return nil
+}
+
+func (x *Message24317) GetField24451() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field24451
+	}
+	return nil
+}
+
+func (x *Message24317) GetField24452() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field24452
+	}
+	return nil
+}
+
+func (x *Message24317) GetField24453() []string {
+	if x != nil {
+		return x.Field24453
+	}
+	return nil
+}
+
+func (x *Message24317) GetField24454() []string {
+	if x != nil {
+		return x.Field24454
+	}
+	return nil
+}
+
+func (x *Message24317) GetField24455() []string {
+	if x != nil {
+		return x.Field24455
+	}
+	return nil
+}
+
+func (x *Message24317) GetField24456() []string {
+	if x != nil {
+		return x.Field24456
+	}
+	return nil
+}
+
+func (x *Message24317) GetField24457() string {
+	if x != nil && x.Field24457 != nil {
+		return *x.Field24457
+	}
+	return ""
+}
+
+func (x *Message24317) GetField24458() string {
+	if x != nil && x.Field24458 != nil {
+		return *x.Field24458
+	}
+	return ""
+}
+
+func (x *Message24317) GetField24459() string {
+	if x != nil && x.Field24459 != nil {
+		return *x.Field24459
+	}
+	return ""
+}
+
+func (x *Message24317) GetField24460() string {
+	if x != nil && x.Field24460 != nil {
+		return *x.Field24460
+	}
+	return ""
+}
+
+func (x *Message24317) GetField24461() []string {
+	if x != nil {
+		return x.Field24461
+	}
+	return nil
+}
+
+func (x *Message24317) GetField24462() string {
+	if x != nil && x.Field24462 != nil {
+		return *x.Field24462
+	}
+	return ""
+}
+
+func (x *Message24317) GetField24463() []string {
+	if x != nil {
+		return x.Field24463
+	}
+	return nil
+}
+
+func (x *Message24317) GetField24464() []string {
+	if x != nil {
+		return x.Field24464
+	}
+	return nil
+}
+
+func (x *Message24317) GetField24465() []string {
+	if x != nil {
+		return x.Field24465
+	}
+	return nil
+}
+
+func (x *Message24317) GetField24466() []string {
+	if x != nil {
+		return x.Field24466
+	}
+	return nil
+}
+
+func (x *Message24317) GetField24467() []string {
+	if x != nil {
+		return x.Field24467
+	}
+	return nil
+}
+
+func (x *Message24317) GetField24468() []string {
+	if x != nil {
+		return x.Field24468
+	}
+	return nil
+}
+
+func (x *Message24317) GetField24469() []string {
+	if x != nil {
+		return x.Field24469
+	}
+	return nil
+}
+
+func (x *Message24317) GetField24470() []string {
+	if x != nil {
+		return x.Field24470
+	}
+	return nil
+}
+
+func (x *Message24317) GetField24471() string {
+	if x != nil && x.Field24471 != nil {
+		return *x.Field24471
+	}
+	return ""
+}
+
+func (x *Message24317) GetField24472() string {
+	if x != nil && x.Field24472 != nil {
+		return *x.Field24472
+	}
+	return ""
+}
+
+func (x *Message24317) GetField24473() []string {
+	if x != nil {
+		return x.Field24473
+	}
+	return nil
+}
+
+func (x *Message24317) GetField24474() bool {
+	if x != nil && x.Field24474 != nil {
+		return *x.Field24474
+	}
+	return false
+}
+
+type Message33958_Message33959 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field33982 *string   `protobuf:"bytes,3,req,name=field33982" json:"field33982,omitempty"`
+	Field33983 *string   `protobuf:"bytes,4,opt,name=field33983" json:"field33983,omitempty"`
+	Field33984 *string   `protobuf:"bytes,5,opt,name=field33984" json:"field33984,omitempty"`
+	Field33985 *uint64   `protobuf:"fixed64,8,opt,name=field33985" json:"field33985,omitempty"`
+	Field33986 *bool     `protobuf:"varint,10,opt,name=field33986" json:"field33986,omitempty"`
+	Field33987 *Message0 `protobuf:"bytes,6,opt,name=field33987" json:"field33987,omitempty"`
+}
+
+func (x *Message33958_Message33959) Reset() {
+	*x = Message33958_Message33959{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[45]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message33958_Message33959) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message33958_Message33959) ProtoMessage() {}
+
+func (x *Message33958_Message33959) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[45]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message33958_Message33959.ProtoReflect.Descriptor instead.
+func (*Message33958_Message33959) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{8, 0}
+}
+
+func (x *Message33958_Message33959) GetField33982() string {
+	if x != nil && x.Field33982 != nil {
+		return *x.Field33982
+	}
+	return ""
+}
+
+func (x *Message33958_Message33959) GetField33983() string {
+	if x != nil && x.Field33983 != nil {
+		return *x.Field33983
+	}
+	return ""
+}
+
+func (x *Message33958_Message33959) GetField33984() string {
+	if x != nil && x.Field33984 != nil {
+		return *x.Field33984
+	}
+	return ""
+}
+
+func (x *Message33958_Message33959) GetField33985() uint64 {
+	if x != nil && x.Field33985 != nil {
+		return *x.Field33985
+	}
+	return 0
+}
+
+func (x *Message33958_Message33959) GetField33986() bool {
+	if x != nil && x.Field33986 != nil {
+		return *x.Field33986
+	}
+	return false
+}
+
+func (x *Message33958_Message33959) GetField33987() *Message0 {
+	if x != nil {
+		return x.Field33987
+	}
+	return nil
+}
+
+type Message13083_Message13084 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field13107 *float32    `protobuf:"fixed32,3,req,name=field13107" json:"field13107,omitempty"`
+	Field13108 *int32      `protobuf:"varint,4,req,name=field13108" json:"field13108,omitempty"`
+	Field13109 *float32    `protobuf:"fixed32,5,opt,name=field13109" json:"field13109,omitempty"`
+	Field13110 []Enum13092 `protobuf:"varint,6,rep,name=field13110,enum=benchmarks.google_message3.Enum13092" json:"field13110,omitempty"`
+}
+
+func (x *Message13083_Message13084) Reset() {
+	*x = Message13083_Message13084{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[46]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message13083_Message13084) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message13083_Message13084) ProtoMessage() {}
+
+func (x *Message13083_Message13084) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[46]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message13083_Message13084.ProtoReflect.Descriptor instead.
+func (*Message13083_Message13084) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{12, 0}
+}
+
+func (x *Message13083_Message13084) GetField13107() float32 {
+	if x != nil && x.Field13107 != nil {
+		return *x.Field13107
+	}
+	return 0
+}
+
+func (x *Message13083_Message13084) GetField13108() int32 {
+	if x != nil && x.Field13108 != nil {
+		return *x.Field13108
+	}
+	return 0
+}
+
+func (x *Message13083_Message13084) GetField13109() float32 {
+	if x != nil && x.Field13109 != nil {
+		return *x.Field13109
+	}
+	return 0
+}
+
+func (x *Message13083_Message13084) GetField13110() []Enum13092 {
+	if x != nil {
+		return x.Field13110
+	}
+	return nil
+}
+
+type Message13083_Message13085 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message13083_Message13085) Reset() {
+	*x = Message13083_Message13085{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[47]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message13083_Message13085) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message13083_Message13085) ProtoMessage() {}
+
+func (x *Message13083_Message13085) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[47]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message13083_Message13085.ProtoReflect.Descriptor instead.
+func (*Message13083_Message13085) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{12, 1}
+}
+
+type Message13083_Message13086 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message13083_Message13086) Reset() {
+	*x = Message13083_Message13086{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[48]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message13083_Message13086) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message13083_Message13086) ProtoMessage() {}
+
+func (x *Message13083_Message13086) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[48]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message13083_Message13086.ProtoReflect.Descriptor instead.
+func (*Message13083_Message13086) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{12, 2}
+}
+
+type Message13083_Message13087 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message13083_Message13087) Reset() {
+	*x = Message13083_Message13087{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[49]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message13083_Message13087) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message13083_Message13087) ProtoMessage() {}
+
+func (x *Message13083_Message13087) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[49]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message13083_Message13087.ProtoReflect.Descriptor instead.
+func (*Message13083_Message13087) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{12, 3}
+}
+
+type Message13088_Message13089 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field13139 *string  `protobuf:"bytes,2,req,name=field13139" json:"field13139,omitempty"`
+	Field13140 *float32 `protobuf:"fixed32,3,opt,name=field13140" json:"field13140,omitempty"`
+}
+
+func (x *Message13088_Message13089) Reset() {
+	*x = Message13088_Message13089{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[50]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message13088_Message13089) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message13088_Message13089) ProtoMessage() {}
+
+func (x *Message13088_Message13089) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[50]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message13088_Message13089.ProtoReflect.Descriptor instead.
+func (*Message13088_Message13089) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{13, 0}
+}
+
+func (x *Message13088_Message13089) GetField13139() string {
+	if x != nil && x.Field13139 != nil {
+		return *x.Field13139
+	}
+	return ""
+}
+
+func (x *Message13088_Message13089) GetField13140() float32 {
+	if x != nil && x.Field13140 != nil {
+		return *x.Field13140
+	}
+	return 0
+}
+
+type Message18253_Message18254 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field18362 *uint64  `protobuf:"fixed64,2,req,name=field18362" json:"field18362,omitempty"`
+	Field18363 *float64 `protobuf:"fixed64,3,req,name=field18363" json:"field18363,omitempty"`
+}
+
+func (x *Message18253_Message18254) Reset() {
+	*x = Message18253_Message18254{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[51]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message18253_Message18254) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message18253_Message18254) ProtoMessage() {}
+
+func (x *Message18253_Message18254) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[51]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message18253_Message18254.ProtoReflect.Descriptor instead.
+func (*Message18253_Message18254) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{18, 0}
+}
+
+func (x *Message18253_Message18254) GetField18362() uint64 {
+	if x != nil && x.Field18362 != nil {
+		return *x.Field18362
+	}
+	return 0
+}
+
+func (x *Message18253_Message18254) GetField18363() float64 {
+	if x != nil && x.Field18363 != nil {
+		return *x.Field18363
+	}
+	return 0
+}
+
+type Message16816_Message16817 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message16816_Message16817) Reset() {
+	*x = Message16816_Message16817{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[52]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message16816_Message16817) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message16816_Message16817) ProtoMessage() {}
+
+func (x *Message16816_Message16817) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[52]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message16816_Message16817.ProtoReflect.Descriptor instead.
+func (*Message16816_Message16817) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{20, 0}
+}
+
+type Message16816_Message16818 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message16816_Message16818) Reset() {
+	*x = Message16816_Message16818{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[53]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message16816_Message16818) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message16816_Message16818) ProtoMessage() {}
+
+func (x *Message16816_Message16818) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[53]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message16816_Message16818.ProtoReflect.Descriptor instead.
+func (*Message16816_Message16818) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP(), []int{20, 1}
+}
+
+var file_datasets_google_message3_benchmark_message3_4_proto_extTypes = []protoimpl.ExtensionInfo{
+	{
+		ExtendedType:  (*Message0)(nil),
+		ExtensionType: (*Message33958)(nil),
+		Field:         10747482,
+		Name:          "benchmarks.google_message3.Message33958.field33981",
+		Tag:           "bytes,10747482,opt,name=field33981",
+		Filename:      "datasets/google_message3/benchmark_message3_4.proto",
+	},
+	{
+		ExtendedType:  (*Message8301)(nil),
+		ExtensionType: (*Message8454)(nil),
+		Field:         66,
+		Name:          "benchmarks.google_message3.Message8454.field8469",
+		Tag:           "bytes,66,opt,name=field8469",
+		Filename:      "datasets/google_message3/benchmark_message3_4.proto",
+	},
+	{
+		ExtendedType:  (*Message8302)(nil),
+		ExtensionType: (*Message8455)(nil),
+		Field:         66,
+		Name:          "benchmarks.google_message3.Message8455.field8474",
+		Tag:           "bytes,66,opt,name=field8474",
+		Filename:      "datasets/google_message3/benchmark_message3_4.proto",
+	},
+}
+
+// Extension fields to Message0.
+var (
+	// optional benchmarks.google_message3.Message33958 field33981 = 10747482;
+	E_Message33958_Field33981 = &file_datasets_google_message3_benchmark_message3_4_proto_extTypes[0]
+)
+
+// Extension fields to Message8301.
+var (
+	// optional benchmarks.google_message3.Message8454 field8469 = 66;
+	E_Message8454_Field8469 = &file_datasets_google_message3_benchmark_message3_4_proto_extTypes[1]
+)
+
+// Extension fields to Message8302.
+var (
+	// optional benchmarks.google_message3.Message8455 field8474 = 66;
+	E_Message8455_Field8474 = &file_datasets_google_message3_benchmark_message3_4_proto_extTypes[2]
+)
+
+var File_datasets_google_message3_benchmark_message3_4_proto protoreflect.FileDescriptor
+
+var file_datasets_google_message3_benchmark_message3_4_proto_rawDesc = []byte{
+	0x0a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x5f, 0x34, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1a, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x1a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2f, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x5f, 0x35,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73,
+	0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x5f, 0x36, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x33, 0x64, 0x61, 0x74,
+	0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x5f, 0x37, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x1a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x5f, 0x38, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x0e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x32, 0x34, 0x33, 0x34, 0x36, 0x22, 0x58, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x32, 0x34, 0x34, 0x30, 0x31, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34,
+	0x36, 0x37, 0x39, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34,
+	0x34, 0x30, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x37, 0x39, 0x22,
+	0x58, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x34, 0x30, 0x32, 0x12,
+	0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x38, 0x30, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x34, 0x30, 0x30, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x38, 0x30, 0x22, 0xb2, 0x06, 0x0a, 0x0c, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x33, 0x37, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x30, 0x33, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x30, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x30, 0x34, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x30, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x30, 0x35, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x30, 0x35, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x30, 0x36, 0x18, 0x04, 0x20, 0x02, 0x28, 0x0b, 0x32, 0x28,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x32, 0x34, 0x33, 0x38, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x36, 0x30, 0x36, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36,
+	0x30, 0x37, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74,
+	0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x36, 0x30, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36,
+	0x30, 0x38, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x36, 0x30, 0x38, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36,
+	0x30, 0x39, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x33,
+	0x38, 0x31, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x30, 0x39, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x31, 0x30, 0x18, 0x08, 0x20, 0x03,
+	0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x31, 0x30, 0x12, 0x4e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x31, 0x31, 0x18, 0x11, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x31, 0x31, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x31, 0x32, 0x18, 0x09, 0x20, 0x03,
+	0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x31, 0x32, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x31, 0x33, 0x18, 0x0a, 0x20, 0x03,
+	0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x31, 0x33, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x31, 0x34, 0x18, 0x0b, 0x20, 0x03,
+	0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x31, 0x34, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x31, 0x35, 0x18, 0x0e, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x31, 0x35, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x31, 0x36, 0x18, 0x0c, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x31, 0x36, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x31, 0x37, 0x18, 0x10, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x31, 0x37, 0x12, 0x4e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x31, 0x38, 0x18, 0x0d, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x31, 0x38, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x31, 0x39, 0x18, 0x0f, 0x20, 0x03,
+	0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x31, 0x39, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x32, 0x30, 0x18, 0x12, 0x20, 0x03,
+	0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x32, 0x30, 0x22, 0x4e,
+	0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x37, 0x33, 0x35, 0x38, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x31, 0x35, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x31, 0x35, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x31, 0x36, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x34, 0x31, 0x36, 0x22, 0xee,
+	0x04, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x34, 0x33, 0x38, 0x31, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x33, 0x39, 0x38, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x33, 0x39, 0x38, 0x12,
+	0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x33, 0x39, 0x39, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x33, 0x39, 0x39, 0x12,
+	0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x34, 0x30, 0x30, 0x18, 0x03, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x34, 0x30, 0x30, 0x12,
+	0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x34, 0x30, 0x31, 0x18, 0x04, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x34, 0x30, 0x31, 0x12,
+	0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x34, 0x30, 0x32, 0x18, 0x05, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x34, 0x30, 0x32, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x34, 0x30, 0x33, 0x18, 0x06, 0x20,
+	0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x34, 0x30, 0x33, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x34, 0x30, 0x34, 0x18, 0x07, 0x20,
+	0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x34, 0x30, 0x34, 0x12,
+	0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x34, 0x30, 0x35, 0x18, 0x08, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x34, 0x30, 0x35, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x34, 0x30, 0x36, 0x18, 0x09, 0x20,
+	0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x34, 0x30, 0x36, 0x12,
+	0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x34, 0x30, 0x37, 0x18, 0x0a, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x34, 0x30, 0x37, 0x22,
+	0x9e, 0x02, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x34, 0x36, 0x31, 0x39,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x34, 0x31, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x34, 0x31,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x34, 0x32, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x34, 0x32,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x34, 0x33, 0x18, 0x03,
+	0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x34, 0x33,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x34, 0x34, 0x18, 0x04,
+	0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x34, 0x34,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x34, 0x35, 0x18, 0x0b,
+	0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x34, 0x35,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x34, 0x36, 0x18, 0x05,
+	0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x34, 0x36,
+	0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x34, 0x37, 0x18, 0x64,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x34, 0x36, 0x34, 0x37,
+	0x22, 0xc8, 0x0c, 0x0a, 0x0a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x33, 0x30, 0x12,
+	0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x39, 0x37, 0x18, 0x13, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x39, 0x37, 0x12, 0x1a, 0x0a, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x39, 0x38, 0x18, 0x1b, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x39, 0x38, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x39, 0x39, 0x18, 0x1c, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x39, 0x39, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x30, 0x18,
+	0x15, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x30, 0x12,
+	0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x31, 0x18, 0x1e, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x31, 0x12, 0x1a, 0x0a, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x32, 0x18, 0x14, 0x20, 0x03, 0x28, 0x0d, 0x52, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x32, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x30, 0x33, 0x18, 0x20, 0x20, 0x03, 0x28, 0x0d, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x30, 0x33, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x34, 0x18,
+	0x10, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x34, 0x12,
+	0x42, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x35, 0x18, 0x06, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x39, 0x37, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x30, 0x35, 0x12, 0x42, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x36, 0x18,
+	0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x30, 0x34, 0x52, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x36, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x30, 0x37, 0x18, 0x12, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x30, 0x37, 0x12, 0x42, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x38, 0x18,
+	0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x30, 0x33, 0x52, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x38, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x30, 0x39, 0x18, 0x09, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x30, 0x39, 0x12, 0x42, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x30, 0x18,
+	0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x31, 0x36, 0x52, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x30, 0x12, 0x42, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x31, 0x31, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x31,
+	0x38, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x31, 0x12, 0x1a, 0x0a, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x32, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x32, 0x12, 0x42, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x31, 0x33, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x31,
+	0x35, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x33, 0x12, 0x1a, 0x0a, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x34, 0x18, 0x11, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x34, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x31, 0x35, 0x18, 0x17, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x31, 0x35, 0x12, 0x42, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x36, 0x18,
+	0x18, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x31, 0x39, 0x52, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x36, 0x12, 0x42, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x31, 0x37, 0x18, 0x1a, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x32,
+	0x38, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x37, 0x12, 0x42, 0x0a, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x38, 0x18, 0x23, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x37, 0x30, 0x32, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x38, 0x12,
+	0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x39, 0x18, 0x24, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x39, 0x12, 0x1a, 0x0a, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x30, 0x18, 0x25, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x30, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x32, 0x31, 0x18, 0x26, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x32, 0x31, 0x12, 0x4a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x32, 0x18,
+	0x27, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x32, 0x12,
+	0x4a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x33, 0x18, 0x01, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55,
+	0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x33, 0x12, 0x4a, 0x0a, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x34, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65,
+	0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x34, 0x12, 0x4a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x32, 0x35, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70,
+	0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x32, 0x35, 0x12, 0x4a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x36, 0x18,
+	0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x36, 0x12,
+	0x4a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x37, 0x18, 0x0d, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55,
+	0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x37, 0x12, 0x1a, 0x0a, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x38, 0x18, 0x16, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x38, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x32, 0x39, 0x18, 0x1f, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x32, 0x39, 0x2a, 0x04, 0x08, 0x19, 0x10, 0x1a, 0x2a, 0x04, 0x08, 0x1d, 0x10, 0x1e, 0x2a,
+	0x04, 0x08, 0x22, 0x10, 0x23, 0x2a, 0x04, 0x08, 0x0f, 0x10, 0x10, 0x22, 0xda, 0x04, 0x0a, 0x0c,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x33, 0x39, 0x35, 0x38, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x39, 0x37, 0x37, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x39, 0x37, 0x37, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x39, 0x37, 0x38, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x39, 0x37, 0x38, 0x12, 0x59, 0x0a, 0x0c,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x33, 0x39, 0x35, 0x39, 0x18, 0x02, 0x20, 0x03,
+	0x28, 0x0a, 0x32, 0x35, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x33, 0x39, 0x35, 0x38, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x33, 0x39, 0x35, 0x39, 0x52, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x33, 0x39, 0x35, 0x39, 0x12, 0x45, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x33, 0x39, 0x38, 0x30, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x33, 0x33, 0x39,
+	0x36, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x39, 0x38, 0x30, 0x1a, 0xf4,
+	0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x33, 0x39, 0x35, 0x39, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x39, 0x38, 0x32, 0x18, 0x03, 0x20,
+	0x02, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x39, 0x38, 0x32, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x39, 0x38, 0x33, 0x18, 0x04, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x39, 0x38, 0x33, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x39, 0x38, 0x34, 0x18, 0x05, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x39, 0x38, 0x34, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x39, 0x38, 0x35, 0x18, 0x08, 0x20,
+	0x01, 0x28, 0x06, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x39, 0x38, 0x35, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x39, 0x38, 0x36, 0x18, 0x0a, 0x20,
+	0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x39, 0x38, 0x36, 0x12,
+	0x44, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x39, 0x38, 0x37, 0x18, 0x06, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x33, 0x39, 0x38, 0x37, 0x32, 0x71, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33,
+	0x39, 0x38, 0x31, 0x12, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x18, 0xda, 0xfc, 0x8f, 0x05, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x33, 0x39, 0x35, 0x38, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x33, 0x39, 0x38, 0x31, 0x22, 0xb3, 0x02, 0x0a, 0x0b, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x36, 0x36, 0x33, 0x37, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x36, 0x36, 0x37, 0x30, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45,
+	0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x36, 0x36, 0x37, 0x30, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36,
+	0x36, 0x37, 0x31, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70,
+	0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x36, 0x36, 0x37, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x37,
+	0x32, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36,
+	0x37, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x37, 0x33, 0x18,
+	0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x37, 0x33,
+	0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x37, 0x34, 0x18, 0x05, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x37, 0x34, 0x22, 0xea,
+	0x06, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x36, 0x34, 0x33, 0x12, 0x4c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x38, 0x33, 0x18, 0x03, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55,
+	0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x38, 0x33, 0x12, 0x4c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x38, 0x34, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x38, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x36, 0x36, 0x38, 0x35, 0x18, 0x05, 0x20, 0x01, 0x28, 0x01, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x38, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x36, 0x36, 0x38, 0x36, 0x18, 0x06, 0x20, 0x01, 0x28, 0x01, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x36, 0x36, 0x38, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36,
+	0x36, 0x38, 0x37, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x36, 0x36, 0x38, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x38,
+	0x38, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36,
+	0x38, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x38, 0x39, 0x18,
+	0x09, 0x20, 0x01, 0x28, 0x01, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x38, 0x39,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x39, 0x30, 0x18, 0x0a, 0x20,
+	0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x39, 0x30, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x39, 0x31, 0x18, 0x0b, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x39, 0x31, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x39, 0x32, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x39, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x36, 0x36, 0x39, 0x33, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x39, 0x33, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x36, 0x36, 0x39, 0x34, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x36, 0x35, 0x37, 0x38, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x39, 0x34, 0x12,
+	0x44, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x39, 0x35, 0x18, 0x10, 0x20, 0x01,
+	0x28, 0x0e, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x36, 0x36, 0x39, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36,
+	0x39, 0x36, 0x18, 0x11, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36,
+	0x36, 0x39, 0x36, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x39, 0x37,
+	0x18, 0x16, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x39,
+	0x37, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x39, 0x38, 0x18, 0x13,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x39, 0x38, 0x12,
+	0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x39, 0x39, 0x18, 0x14, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x39, 0x39, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x30, 0x30, 0x18, 0x15, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x30, 0x30, 0x22, 0xf8, 0x06, 0x0a, 0x0b,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x31, 0x32, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x35, 0x32, 0x18, 0x01, 0x20, 0x02, 0x28, 0x09, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x35, 0x32, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x36, 0x31, 0x35, 0x33, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64,
+	0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x36, 0x31, 0x35, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x36, 0x31, 0x35, 0x34, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x36, 0x31, 0x35, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31,
+	0x35, 0x35, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36,
+	0x31, 0x35, 0x35, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x35, 0x36,
+	0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x30, 0x32, 0x34, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x35, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x36, 0x31, 0x35, 0x37, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x35, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x36, 0x31, 0x35, 0x38, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x36, 0x31, 0x35, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36,
+	0x31, 0x35, 0x39, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x36, 0x31, 0x35, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x36,
+	0x30, 0x18, 0x02, 0x20, 0x03, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31,
+	0x36, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x36, 0x31, 0x18,
+	0x03, 0x20, 0x03, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x36, 0x31,
+	0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x36, 0x32, 0x18, 0x07, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x30, 0x35, 0x32, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x36, 0x31, 0x36, 0x32, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x36, 0x31, 0x36, 0x33, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d,
+	0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x36, 0x31, 0x36, 0x33, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31,
+	0x36, 0x34, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x36, 0x30, 0x36, 0x35, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x36, 0x34, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x36, 0x31, 0x36, 0x35, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64,
+	0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x36, 0x31, 0x36, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x36, 0x31, 0x36, 0x36, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x36, 0x31, 0x36, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31,
+	0x36, 0x37, 0x18, 0x10, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36,
+	0x31, 0x36, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x36, 0x38,
+	0x18, 0x12, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x36,
+	0x38, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x36, 0x39, 0x18, 0x11,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x30, 0x35, 0x34, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x36, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x36, 0x31, 0x37, 0x30, 0x18, 0x13, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x36, 0x31, 0x37, 0x30, 0x22, 0xd2, 0x06, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x31, 0x33, 0x30, 0x38, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x33, 0x30, 0x39, 0x36, 0x18, 0x01, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x33, 0x30, 0x39, 0x36, 0x12, 0x59, 0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x31, 0x33, 0x30, 0x38, 0x34, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0a, 0x32, 0x35, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x31, 0x33, 0x30, 0x38, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31,
+	0x33, 0x30, 0x38, 0x34, 0x52, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x30,
+	0x38, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x30, 0x39, 0x38,
+	0x18, 0x2c, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x30,
+	0x39, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x30, 0x39, 0x39,
+	0x18, 0x2d, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x30,
+	0x39, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x31, 0x30, 0x30,
+	0x18, 0x2e, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x31,
+	0x30, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x31, 0x30, 0x31,
+	0x18, 0x2f, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x31,
+	0x30, 0x31, 0x12, 0x59, 0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x30,
+	0x38, 0x35, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0a, 0x32, 0x35, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x30,
+	0x38, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x30, 0x38, 0x35, 0x52,
+	0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x30, 0x38, 0x35, 0x12, 0x59, 0x0a,
+	0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x30, 0x38, 0x36, 0x18, 0x17, 0x20,
+	0x03, 0x28, 0x0a, 0x32, 0x35, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x30, 0x38, 0x33, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x30, 0x38, 0x36, 0x52, 0x0c, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x31, 0x33, 0x30, 0x38, 0x36, 0x12, 0x59, 0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x31, 0x33, 0x30, 0x38, 0x37, 0x18, 0x1d, 0x20, 0x03, 0x28, 0x0a, 0x32, 0x35,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x31, 0x33, 0x30, 0x38, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x31, 0x33, 0x30, 0x38, 0x37, 0x52, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33,
+	0x30, 0x38, 0x37, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x31, 0x30,
+	0x35, 0x18, 0x2b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33,
+	0x31, 0x30, 0x35, 0x1a, 0xb5, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31,
+	0x33, 0x30, 0x38, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x31,
+	0x30, 0x37, 0x18, 0x03, 0x20, 0x02, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x33, 0x31, 0x30, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x31,
+	0x30, 0x38, 0x18, 0x04, 0x20, 0x02, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x33, 0x31, 0x30, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x31,
+	0x30, 0x39, 0x18, 0x05, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x33, 0x31, 0x30, 0x39, 0x12, 0x45, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x31,
+	0x31, 0x30, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x33, 0x30, 0x39, 0x32, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x31, 0x31, 0x30, 0x1a, 0x0e, 0x0a, 0x0c, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x30, 0x38, 0x35, 0x1a, 0x0e, 0x0a, 0x0c, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x30, 0x38, 0x36, 0x1a, 0x0e, 0x0a, 0x0c, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x30, 0x38, 0x37, 0x22, 0xf9, 0x01, 0x0a, 0x0c,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x30, 0x38, 0x38, 0x12, 0x59, 0x0a, 0x0c,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x30, 0x38, 0x39, 0x18, 0x01, 0x20, 0x03,
+	0x28, 0x0a, 0x32, 0x35, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x30, 0x38, 0x38, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x30, 0x38, 0x39, 0x52, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x31, 0x33, 0x30, 0x38, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x33, 0x31, 0x33, 0x36, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x33, 0x31, 0x33, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x33, 0x31, 0x33, 0x37, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x33, 0x31, 0x33, 0x37, 0x1a, 0x4e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x31, 0x33, 0x30, 0x38, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x33, 0x31, 0x33, 0x39, 0x18, 0x02, 0x20, 0x02, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x33, 0x31, 0x33, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x33, 0x31, 0x34, 0x30, 0x18, 0x03, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x33, 0x31, 0x34, 0x30, 0x22, 0xad, 0x03, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x31, 0x30, 0x33, 0x39, 0x31, 0x12, 0x45, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x30, 0x34, 0x31, 0x31, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x30,
+	0x33, 0x39, 0x32, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x34, 0x31, 0x31, 0x12,
+	0x46, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x34, 0x31, 0x32, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x30, 0x34, 0x31, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x30, 0x34, 0x31, 0x33, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x30, 0x34, 0x31, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x30, 0x34, 0x31, 0x34, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x30, 0x34, 0x31, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x30, 0x34, 0x31, 0x35, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x30, 0x34, 0x31, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x30, 0x34, 0x31, 0x36, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x30, 0x34, 0x31, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x30, 0x34, 0x31, 0x37, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x30, 0x34, 0x31, 0x37, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x30, 0x34, 0x31, 0x38, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45,
+	0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x30, 0x34, 0x31, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x30, 0x34, 0x31, 0x39, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x30, 0x34, 0x31, 0x39, 0x22, 0xca, 0x06, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x31, 0x31, 0x38, 0x37, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x31, 0x38, 0x37, 0x36, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x37, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x31, 0x38, 0x37, 0x37, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x37, 0x37, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x31, 0x38, 0x37, 0x38, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x31, 0x30, 0x35, 0x37, 0x33, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38,
+	0x37, 0x38, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x37, 0x39,
+	0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x35, 0x38, 0x32,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x37, 0x39, 0x12, 0x48, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x38, 0x30, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x38, 0x32, 0x34, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x31, 0x38, 0x38, 0x30, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x31, 0x38, 0x38, 0x31, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31,
+	0x30, 0x37, 0x37, 0x33, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x38, 0x31,
+	0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x38, 0x32, 0x18, 0x08,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x31, 0x38, 0x36, 0x36, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x38, 0x32, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x38, 0x33, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x31, 0x30, 0x38, 0x31, 0x38, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x31, 0x38, 0x38, 0x33, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38,
+	0x38, 0x34, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74,
+	0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x31, 0x38, 0x38, 0x34, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38,
+	0x38, 0x35, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x31,
+	0x35, 0x35, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x38, 0x35, 0x12, 0x48,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x38, 0x36, 0x18, 0x0e, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x34, 0x36, 0x39, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x38, 0x36, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x31, 0x38, 0x38, 0x37, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64,
+	0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x38, 0x37, 0x2a, 0x04, 0x08, 0x09, 0x10, 0x0a, 0x2a, 0x04,
+	0x08, 0x0a, 0x10, 0x0b, 0x22, 0xe5, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x35, 0x35, 0x30, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35,
+	0x35, 0x32, 0x34, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x35, 0x35, 0x32, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35,
+	0x35, 0x32, 0x35, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x35, 0x35, 0x32, 0x35, 0x12, 0x45, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35,
+	0x35, 0x32, 0x36, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x33, 0x35, 0x35, 0x30, 0x37,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35, 0x32, 0x36, 0x12, 0x4e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35, 0x32, 0x37, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e,
+	0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x35, 0x35, 0x32, 0x37, 0x22, 0x58, 0x0a, 0x0c,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x31, 0x35, 0x31, 0x12, 0x48, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x31, 0x35, 0x38, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x31, 0x34, 0x35, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x33, 0x31, 0x35, 0x38, 0x22, 0xb9, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x31, 0x38, 0x32, 0x35, 0x33, 0x12, 0x59, 0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x31, 0x38, 0x32, 0x35, 0x34, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0a, 0x32, 0x35, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x31, 0x38, 0x32, 0x35, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31,
+	0x38, 0x32, 0x35, 0x34, 0x52, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x38, 0x32,
+	0x35, 0x34, 0x1a, 0x4e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x38, 0x32,
+	0x35, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x33, 0x36, 0x32,
+	0x18, 0x02, 0x20, 0x02, 0x28, 0x06, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x33,
+	0x36, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x33, 0x36, 0x33,
+	0x18, 0x03, 0x20, 0x02, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x33,
+	0x36, 0x33, 0x22, 0x58, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x36,
+	0x38, 0x35, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x36, 0x39, 0x34,
+	0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x36, 0x38, 0x36,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x36, 0x39, 0x34, 0x22, 0x8b, 0x04, 0x0a,
+	0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x38, 0x31, 0x36, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x38, 0x32, 0x36, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x38, 0x32, 0x36, 0x12, 0x45, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x38, 0x32, 0x37, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x0e, 0x32, 0x25, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45,
+	0x6e, 0x75, 0x6d, 0x31, 0x36, 0x38, 0x31, 0x39, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x36, 0x38, 0x32, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x38,
+	0x32, 0x38, 0x18, 0x03, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x36, 0x38, 0x32, 0x38, 0x12, 0x59, 0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31,
+	0x36, 0x38, 0x31, 0x37, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0a, 0x32, 0x35, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31,
+	0x36, 0x38, 0x31, 0x36, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x38, 0x31,
+	0x37, 0x52, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x38, 0x31, 0x37, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x38, 0x33, 0x30, 0x18, 0x07, 0x20,
+	0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x38, 0x33, 0x30, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x38, 0x33, 0x31, 0x18, 0x08, 0x20,
+	0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x38, 0x33, 0x31, 0x12,
+	0x59, 0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x38, 0x31, 0x38, 0x18,
+	0x0c, 0x20, 0x03, 0x28, 0x0a, 0x32, 0x35, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x38, 0x31, 0x36, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x38, 0x31, 0x38, 0x52, 0x0c, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x38, 0x31, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x36, 0x38, 0x33, 0x33, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x38, 0x33, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x36, 0x38, 0x33, 0x34, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x38, 0x33, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x36, 0x38, 0x33, 0x35, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x38, 0x33, 0x35, 0x1a, 0x0e, 0x0a, 0x0c, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x38, 0x31, 0x37, 0x1a, 0x0e, 0x0a, 0x0c, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x38, 0x31, 0x38, 0x22, 0x98, 0x03, 0x0a, 0x0c, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x31, 0x36, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x31, 0x32, 0x18, 0x01, 0x20, 0x02, 0x28, 0x05, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x31, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x31, 0x33, 0x18, 0x07, 0x20, 0x01, 0x28, 0x06, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x31, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x31, 0x34, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x31, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x31, 0x35, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x06, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x31, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x31, 0x36, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x31, 0x36, 0x12, 0x48, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x31, 0x37, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x37, 0x39, 0x36, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x33, 0x32, 0x31, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33,
+	0x32, 0x31, 0x38, 0x18, 0x02, 0x20, 0x02, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x33, 0x32, 0x31, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33,
+	0x32, 0x31, 0x39, 0x18, 0x03, 0x20, 0x02, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x33, 0x32, 0x31, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33,
+	0x32, 0x32, 0x30, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x33, 0x32, 0x32, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33,
+	0x32, 0x32, 0x31, 0x18, 0x05, 0x20, 0x02, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x33, 0x32, 0x32, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33,
+	0x32, 0x32, 0x32, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x33, 0x32, 0x32, 0x32, 0x22, 0xd8, 0x03, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x31, 0x33, 0x31, 0x36, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x33, 0x31, 0x39, 0x39, 0x18, 0x01, 0x20, 0x02, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x33, 0x31, 0x39, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x33, 0x32, 0x30, 0x30, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x33, 0x32, 0x30, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x33, 0x32, 0x30, 0x31, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x33, 0x32, 0x30, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x33, 0x32, 0x30, 0x32, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x33, 0x32, 0x30, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x33, 0x32, 0x30, 0x33, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x06, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x33, 0x32, 0x30, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x33, 0x32, 0x30, 0x34, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x33, 0x32, 0x30, 0x34, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x33, 0x32, 0x30, 0x35, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31,
+	0x32, 0x37, 0x39, 0x36, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x30, 0x35,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x30, 0x36, 0x18, 0x09,
+	0x20, 0x01, 0x28, 0x06, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x30, 0x36,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x30, 0x37, 0x18, 0x0a,
+	0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x30, 0x37,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x30, 0x38, 0x18, 0x04,
+	0x20, 0x03, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x30, 0x38,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x30, 0x39, 0x18, 0x05,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x30, 0x39,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x31, 0x30, 0x18, 0x06,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x31, 0x30,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x31, 0x31, 0x18, 0x07,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x32, 0x31, 0x31,
+	0x22, 0x49, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x37, 0x34, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x37, 0x35, 0x18, 0x01, 0x20, 0x02,
+	0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x37, 0x35, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x37, 0x36, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x37, 0x36, 0x22, 0x0e, 0x0a, 0x0c, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x38, 0x39, 0x34, 0x33, 0x22, 0x0e, 0x0a, 0x0c, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x38, 0x39, 0x34, 0x34, 0x22, 0xee, 0x07, 0x0a, 0x0c,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x38, 0x38, 0x35, 0x36, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x35, 0x37, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x35, 0x37, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x35, 0x38, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x35, 0x38, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x35, 0x39, 0x18, 0x1f, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x35, 0x39, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x36, 0x30, 0x18, 0x1a, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x36, 0x30, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x36, 0x31, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x36, 0x31, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x36, 0x32, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x36, 0x32, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x36, 0x33, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x36, 0x33, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x36, 0x34, 0x18, 0x11, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x36, 0x34, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x36, 0x35, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x36, 0x35, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x36, 0x36, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x36, 0x36, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x36, 0x37, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x36, 0x37, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x36, 0x38, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x36, 0x38, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x36, 0x39, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x36, 0x39, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x37, 0x30, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x37, 0x30, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x37, 0x31, 0x18, 0x15, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x37, 0x31, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x37, 0x32, 0x18, 0x12, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x37, 0x32, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x37, 0x33, 0x18, 0x13, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x37, 0x33, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x37, 0x34, 0x18, 0x14, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x37, 0x34, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x37, 0x35, 0x18, 0x16, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x37, 0x35, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x37, 0x36, 0x18, 0x17, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x37, 0x36, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x37, 0x37, 0x18, 0x18, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x37, 0x37, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x37, 0x38, 0x18, 0x19, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x37, 0x38, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x37, 0x39, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x37, 0x39, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x38, 0x30, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x38, 0x30, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x38, 0x31, 0x18, 0x1d, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x38, 0x31, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x38, 0x32, 0x18, 0x1e, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x38, 0x32, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x38, 0x33, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x38, 0x33, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x38, 0x34, 0x18, 0x10, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x38, 0x34, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x38, 0x35, 0x18, 0x0e, 0x20, 0x03, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x38, 0x35, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x38, 0x36, 0x18, 0x1b, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x38, 0x36, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x38, 0x37, 0x18, 0x1c, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x38, 0x38, 0x38, 0x37, 0x22, 0xe7, 0x01, 0x0a,
+	0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x38, 0x35, 0x30, 0x12, 0x42, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x32, 0x34, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32,
+	0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75,
+	0x6d, 0x33, 0x38, 0x35, 0x31, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x32, 0x34,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x32, 0x35, 0x18, 0x0c, 0x20,
+	0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x32, 0x35, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x32, 0x36, 0x18, 0x04, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x32, 0x36, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x32, 0x37, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x32, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x39, 0x32, 0x38, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x32, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x39, 0x32, 0x39, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x39, 0x32, 0x39, 0x22, 0xae, 0x01, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x36, 0x37, 0x32, 0x31, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36,
+	0x37, 0x34, 0x34, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x37,
+	0x32, 0x32, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x34, 0x34, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x34, 0x35, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x34, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x34, 0x36, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x34, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x36, 0x37, 0x34, 0x37, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x36, 0x37, 0x34, 0x37, 0x22, 0x2b, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x36, 0x37, 0x34, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36,
+	0x37, 0x35, 0x38, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x36, 0x37, 0x35, 0x38, 0x22, 0x72, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36,
+	0x37, 0x32, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x35, 0x32,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x35,
+	0x32, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x35, 0x33, 0x18, 0x02,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x37, 0x32, 0x37, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x35, 0x33, 0x22, 0x67, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x36, 0x37, 0x33, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x36, 0x37, 0x35, 0x34, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x36, 0x37, 0x35, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37,
+	0x35, 0x35, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36,
+	0x37, 0x35, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x35, 0x36,
+	0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x35,
+	0x36, 0x22, 0x72, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x37, 0x32, 0x33,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x34, 0x38, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x34, 0x38, 0x12, 0x45,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x34, 0x39, 0x18, 0x02, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x37, 0x32, 0x34, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x36, 0x37, 0x34, 0x39, 0x22, 0x49, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x36, 0x37, 0x32, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x35,
+	0x30, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37,
+	0x35, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x35, 0x31, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x35, 0x31,
+	0x22, 0x54, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x37, 0x33, 0x34, 0x12,
+	0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x35, 0x37, 0x18, 0x01, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x37, 0x33, 0x35, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x36, 0x37, 0x35, 0x37, 0x22, 0xb9, 0x01, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x38, 0x31, 0x38, 0x34, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x32, 0x32, 0x38, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x39,
+	0x36, 0x36, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x32, 0x38, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x32, 0x39, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x32, 0x39, 0x12, 0x45, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x33, 0x30, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x38, 0x31, 0x38, 0x33, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32,
+	0x33, 0x30, 0x22, 0x90, 0x01, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x34,
+	0x37, 0x37, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x38, 0x36, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x39, 0x36, 0x36, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x38, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x34, 0x38, 0x37, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x34, 0x38, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x34, 0x38, 0x38, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x34, 0x38, 0x38, 0x22, 0x9e, 0x02, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x38, 0x34, 0x35, 0x34, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34,
+	0x36, 0x35, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x34, 0x34,
+	0x39, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x36, 0x35, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x36, 0x36, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x36, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x34, 0x36, 0x37, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x36, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x34, 0x36, 0x38, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x34, 0x36, 0x38, 0x32, 0x6e, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x34, 0x36, 0x39, 0x12, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x33, 0x30, 0x31, 0x18, 0x42, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x34, 0x35, 0x34, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x34, 0x36, 0x39, 0x22, 0x67, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x38, 0x34, 0x37, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34,
+	0x38, 0x33, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x34, 0x38, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x38, 0x34,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x38,
+	0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x38, 0x35, 0x18, 0x03,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x38, 0x35, 0x22,
+	0xa0, 0x03, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x34, 0x35, 0x35, 0x12,
+	0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x37, 0x30, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x34, 0x34, 0x39, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x34, 0x37, 0x30, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x34, 0x37, 0x31, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x34,
+	0x35, 0x36, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x37, 0x31, 0x12, 0x45, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x37, 0x32, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x34, 0x35, 0x37, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x34, 0x37, 0x32, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x37,
+	0x33, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34,
+	0x37, 0x33, 0x32, 0x6e, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x37, 0x34, 0x12,
+	0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x38, 0x33, 0x30, 0x32, 0x18, 0x42, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x38, 0x34, 0x35, 0x35, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34,
+	0x37, 0x34, 0x22, 0x49, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x34, 0x37,
+	0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x38, 0x31, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x38, 0x31, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x38, 0x32, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x38, 0x32, 0x22, 0x0e, 0x0a,
+	0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x35, 0x35, 0x39, 0x22, 0x6e, 0x0a,
+	0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x38, 0x31, 0x37, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x32, 0x36, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x32, 0x36, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x32, 0x37, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x32, 0x37, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x32, 0x38, 0x18, 0x03, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x32, 0x38, 0x22, 0xd3, 0x03,
+	0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x34, 0x38, 0x30, 0x12, 0x48,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x34, 0x39, 0x30, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x33, 0x35, 0x38, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x36, 0x34, 0x39, 0x30, 0x12, 0x45, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x36, 0x34, 0x39, 0x31, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x36,
+	0x30, 0x34, 0x32, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x34, 0x39, 0x31, 0x12,
+	0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x34, 0x39, 0x32, 0x18, 0x03, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x39, 0x31, 0x32, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x34, 0x39, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x36, 0x34, 0x39, 0x33, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x34, 0x39, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x36, 0x34, 0x39, 0x34, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x34, 0x39, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x36, 0x34, 0x39, 0x35, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x34, 0x39, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x36, 0x34, 0x39, 0x36, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x34, 0x39, 0x36, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x36, 0x34, 0x39, 0x37, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x31, 0x33, 0x33, 0x35, 0x38, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36,
+	0x34, 0x39, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36, 0x34, 0x39,
+	0x38, 0x18, 0x09, 0x20, 0x01, 0x28, 0x07, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x36,
+	0x34, 0x39, 0x38, 0x22, 0xb6, 0x09, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32,
+	0x34, 0x33, 0x31, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34,
+	0x34, 0x36, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x34, 0x34, 0x36, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34,
+	0x34, 0x37, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x33,
+	0x31, 0x32, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x34, 0x37, 0x12, 0x48,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x34, 0x38, 0x18, 0x03, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x33, 0x31, 0x35, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x34, 0x38, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x34, 0x34, 0x34, 0x39, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x32, 0x34, 0x33, 0x31, 0x33, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34,
+	0x34, 0x39, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x35, 0x30,
+	0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x33, 0x31, 0x36,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x35, 0x30, 0x12, 0x4e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x35, 0x31, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e,
+	0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x35, 0x31, 0x12, 0x4e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x35, 0x32, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e,
+	0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x35, 0x32, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x35, 0x33, 0x18, 0x08, 0x20, 0x03, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x35, 0x33, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x35, 0x34, 0x18, 0x09, 0x20, 0x03, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x35, 0x34, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x35, 0x35, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x35, 0x35, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x35, 0x36, 0x18, 0x1c, 0x20, 0x03, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x35, 0x36, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x35, 0x37, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x35, 0x37, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x35, 0x38, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x35, 0x38, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x35, 0x39, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x35, 0x39, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x36, 0x30, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x36, 0x30, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x36, 0x31, 0x18, 0x0f, 0x20, 0x03, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x36, 0x31, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x36, 0x32, 0x18, 0x10, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x36, 0x32, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x36, 0x33, 0x18, 0x11, 0x20, 0x03, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x36, 0x33, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x36, 0x34, 0x18, 0x12, 0x20, 0x03, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x36, 0x34, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x36, 0x35, 0x18, 0x13, 0x20, 0x03, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x36, 0x35, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x36, 0x36, 0x18, 0x14, 0x20, 0x03, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x36, 0x36, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x36, 0x37, 0x18, 0x15, 0x20, 0x03, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x36, 0x37, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x36, 0x38, 0x18, 0x16, 0x20, 0x03, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x36, 0x38, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x36, 0x39, 0x18, 0x17, 0x20, 0x03, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x36, 0x39, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x37, 0x30, 0x18, 0x18, 0x20, 0x03, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x37, 0x30, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x37, 0x31, 0x18, 0x19, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x37, 0x31, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x37, 0x32, 0x18, 0x1a, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x37, 0x32, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x37, 0x33, 0x18, 0x1b, 0x20, 0x03, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x37, 0x33, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x37, 0x34, 0x18, 0x28, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x37, 0x34, 0x42, 0x23, 0x0a, 0x1e,
+	0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x62, 0x75, 0x66, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0xf8, 0x01,
+	0x01,
+}
+
+var (
+	file_datasets_google_message3_benchmark_message3_4_proto_rawDescOnce sync.Once
+	file_datasets_google_message3_benchmark_message3_4_proto_rawDescData = file_datasets_google_message3_benchmark_message3_4_proto_rawDesc
+)
+
+func file_datasets_google_message3_benchmark_message3_4_proto_rawDescGZIP() []byte {
+	file_datasets_google_message3_benchmark_message3_4_proto_rawDescOnce.Do(func() {
+		file_datasets_google_message3_benchmark_message3_4_proto_rawDescData = protoimpl.X.CompressGZIP(file_datasets_google_message3_benchmark_message3_4_proto_rawDescData)
+	})
+	return file_datasets_google_message3_benchmark_message3_4_proto_rawDescData
+}
+
+var file_datasets_google_message3_benchmark_message3_4_proto_msgTypes = make([]protoimpl.MessageInfo, 54)
+var file_datasets_google_message3_benchmark_message3_4_proto_goTypes = []interface{}{
+	(*Message24346)(nil),              // 0: benchmarks.google_message3.Message24346
+	(*Message24401)(nil),              // 1: benchmarks.google_message3.Message24401
+	(*Message24402)(nil),              // 2: benchmarks.google_message3.Message24402
+	(*Message24379)(nil),              // 3: benchmarks.google_message3.Message24379
+	(*Message27358)(nil),              // 4: benchmarks.google_message3.Message27358
+	(*Message34381)(nil),              // 5: benchmarks.google_message3.Message34381
+	(*Message34619)(nil),              // 6: benchmarks.google_message3.Message34619
+	(*Message730)(nil),                // 7: benchmarks.google_message3.Message730
+	(*Message33958)(nil),              // 8: benchmarks.google_message3.Message33958
+	(*Message6637)(nil),               // 9: benchmarks.google_message3.Message6637
+	(*Message6643)(nil),               // 10: benchmarks.google_message3.Message6643
+	(*Message6126)(nil),               // 11: benchmarks.google_message3.Message6126
+	(*Message13083)(nil),              // 12: benchmarks.google_message3.Message13083
+	(*Message13088)(nil),              // 13: benchmarks.google_message3.Message13088
+	(*Message10391)(nil),              // 14: benchmarks.google_message3.Message10391
+	(*Message11873)(nil),              // 15: benchmarks.google_message3.Message11873
+	(*Message35506)(nil),              // 16: benchmarks.google_message3.Message35506
+	(*Message13151)(nil),              // 17: benchmarks.google_message3.Message13151
+	(*Message18253)(nil),              // 18: benchmarks.google_message3.Message18253
+	(*Message16685)(nil),              // 19: benchmarks.google_message3.Message16685
+	(*Message16816)(nil),              // 20: benchmarks.google_message3.Message16816
+	(*Message13168)(nil),              // 21: benchmarks.google_message3.Message13168
+	(*Message13167)(nil),              // 22: benchmarks.google_message3.Message13167
+	(*Message1374)(nil),               // 23: benchmarks.google_message3.Message1374
+	(*Message18943)(nil),              // 24: benchmarks.google_message3.Message18943
+	(*Message18944)(nil),              // 25: benchmarks.google_message3.Message18944
+	(*Message18856)(nil),              // 26: benchmarks.google_message3.Message18856
+	(*Message3850)(nil),               // 27: benchmarks.google_message3.Message3850
+	(*Message6721)(nil),               // 28: benchmarks.google_message3.Message6721
+	(*Message6742)(nil),               // 29: benchmarks.google_message3.Message6742
+	(*Message6726)(nil),               // 30: benchmarks.google_message3.Message6726
+	(*Message6733)(nil),               // 31: benchmarks.google_message3.Message6733
+	(*Message6723)(nil),               // 32: benchmarks.google_message3.Message6723
+	(*Message6725)(nil),               // 33: benchmarks.google_message3.Message6725
+	(*Message6734)(nil),               // 34: benchmarks.google_message3.Message6734
+	(*Message8184)(nil),               // 35: benchmarks.google_message3.Message8184
+	(*Message8477)(nil),               // 36: benchmarks.google_message3.Message8477
+	(*Message8454)(nil),               // 37: benchmarks.google_message3.Message8454
+	(*Message8476)(nil),               // 38: benchmarks.google_message3.Message8476
+	(*Message8455)(nil),               // 39: benchmarks.google_message3.Message8455
+	(*Message8475)(nil),               // 40: benchmarks.google_message3.Message8475
+	(*Message12559)(nil),              // 41: benchmarks.google_message3.Message12559
+	(*Message12817)(nil),              // 42: benchmarks.google_message3.Message12817
+	(*Message16480)(nil),              // 43: benchmarks.google_message3.Message16480
+	(*Message24317)(nil),              // 44: benchmarks.google_message3.Message24317
+	(*Message33958_Message33959)(nil), // 45: benchmarks.google_message3.Message33958.Message33959
+	(*Message13083_Message13084)(nil), // 46: benchmarks.google_message3.Message13083.Message13084
+	(*Message13083_Message13085)(nil), // 47: benchmarks.google_message3.Message13083.Message13085
+	(*Message13083_Message13086)(nil), // 48: benchmarks.google_message3.Message13083.Message13086
+	(*Message13083_Message13087)(nil), // 49: benchmarks.google_message3.Message13083.Message13087
+	(*Message13088_Message13089)(nil), // 50: benchmarks.google_message3.Message13088.Message13089
+	(*Message18253_Message18254)(nil), // 51: benchmarks.google_message3.Message18253.Message18254
+	(*Message16816_Message16817)(nil), // 52: benchmarks.google_message3.Message16816.Message16817
+	(*Message16816_Message16818)(nil), // 53: benchmarks.google_message3.Message16816.Message16818
+	(*Message24400)(nil),              // 54: benchmarks.google_message3.Message24400
+	(*Message24380)(nil),              // 55: benchmarks.google_message3.Message24380
+	(*UnusedEmptyMessage)(nil),        // 56: benchmarks.google_message3.UnusedEmptyMessage
+	(*Message24381)(nil),              // 57: benchmarks.google_message3.Message24381
+	(*Message697)(nil),                // 58: benchmarks.google_message3.Message697
+	(*Message704)(nil),                // 59: benchmarks.google_message3.Message704
+	(*Message703)(nil),                // 60: benchmarks.google_message3.Message703
+	(*Message716)(nil),                // 61: benchmarks.google_message3.Message716
+	(*Message718)(nil),                // 62: benchmarks.google_message3.Message718
+	(*Message715)(nil),                // 63: benchmarks.google_message3.Message715
+	(*Message719)(nil),                // 64: benchmarks.google_message3.Message719
+	(*Message728)(nil),                // 65: benchmarks.google_message3.Message728
+	(*Message702)(nil),                // 66: benchmarks.google_message3.Message702
+	(Enum33960)(0),                    // 67: benchmarks.google_message3.Enum33960
+	(*Message6578)(nil),               // 68: benchmarks.google_message3.Message6578
+	(UnusedEnum)(0),                   // 69: benchmarks.google_message3.UnusedEnum
+	(*Message6024)(nil),               // 70: benchmarks.google_message3.Message6024
+	(*Message6052)(nil),               // 71: benchmarks.google_message3.Message6052
+	(Enum6065)(0),                     // 72: benchmarks.google_message3.Enum6065
+	(*Message6054)(nil),               // 73: benchmarks.google_message3.Message6054
+	(Enum10392)(0),                    // 74: benchmarks.google_message3.Enum10392
+	(*Message10573)(nil),              // 75: benchmarks.google_message3.Message10573
+	(*Message10582)(nil),              // 76: benchmarks.google_message3.Message10582
+	(*Message10824)(nil),              // 77: benchmarks.google_message3.Message10824
+	(*Message10773)(nil),              // 78: benchmarks.google_message3.Message10773
+	(*Message11866)(nil),              // 79: benchmarks.google_message3.Message11866
+	(*Message10818)(nil),              // 80: benchmarks.google_message3.Message10818
+	(*Message10155)(nil),              // 81: benchmarks.google_message3.Message10155
+	(*Message10469)(nil),              // 82: benchmarks.google_message3.Message10469
+	(Enum35507)(0),                    // 83: benchmarks.google_message3.Enum35507
+	(*Message13145)(nil),              // 84: benchmarks.google_message3.Message13145
+	(*Message16686)(nil),              // 85: benchmarks.google_message3.Message16686
+	(Enum16819)(0),                    // 86: benchmarks.google_message3.Enum16819
+	(*Message12796)(nil),              // 87: benchmarks.google_message3.Message12796
+	(Enum3851)(0),                     // 88: benchmarks.google_message3.Enum3851
+	(*Message6722)(nil),               // 89: benchmarks.google_message3.Message6722
+	(*Message6727)(nil),               // 90: benchmarks.google_message3.Message6727
+	(*Message6724)(nil),               // 91: benchmarks.google_message3.Message6724
+	(*Message6735)(nil),               // 92: benchmarks.google_message3.Message6735
+	(*Message7966)(nil),               // 93: benchmarks.google_message3.Message7966
+	(*Message8183)(nil),               // 94: benchmarks.google_message3.Message8183
+	(*Message8449)(nil),               // 95: benchmarks.google_message3.Message8449
+	(*Message8456)(nil),               // 96: benchmarks.google_message3.Message8456
+	(*Message8457)(nil),               // 97: benchmarks.google_message3.Message8457
+	(*Message13358)(nil),              // 98: benchmarks.google_message3.Message13358
+	(Enum16042)(0),                    // 99: benchmarks.google_message3.Enum16042
+	(*Message13912)(nil),              // 100: benchmarks.google_message3.Message13912
+	(*Message24312)(nil),              // 101: benchmarks.google_message3.Message24312
+	(*Message24315)(nil),              // 102: benchmarks.google_message3.Message24315
+	(*Message24313)(nil),              // 103: benchmarks.google_message3.Message24313
+	(*Message24316)(nil),              // 104: benchmarks.google_message3.Message24316
+	(*Message0)(nil),                  // 105: benchmarks.google_message3.Message0
+	(Enum13092)(0),                    // 106: benchmarks.google_message3.Enum13092
+	(*Message8301)(nil),               // 107: benchmarks.google_message3.Message8301
+	(*Message8302)(nil),               // 108: benchmarks.google_message3.Message8302
+}
+var file_datasets_google_message3_benchmark_message3_4_proto_depIdxs = []int32{
+	54,  // 0: benchmarks.google_message3.Message24401.field24679:type_name -> benchmarks.google_message3.Message24400
+	54,  // 1: benchmarks.google_message3.Message24402.field24680:type_name -> benchmarks.google_message3.Message24400
+	55,  // 2: benchmarks.google_message3.Message24379.field24606:type_name -> benchmarks.google_message3.Message24380
+	56,  // 3: benchmarks.google_message3.Message24379.field24607:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	57,  // 4: benchmarks.google_message3.Message24379.field24609:type_name -> benchmarks.google_message3.Message24381
+	56,  // 5: benchmarks.google_message3.Message24379.field24611:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	56,  // 6: benchmarks.google_message3.Message24379.field24618:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	56,  // 7: benchmarks.google_message3.Message34381.field34399:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	56,  // 8: benchmarks.google_message3.Message34381.field34400:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	56,  // 9: benchmarks.google_message3.Message34381.field34401:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	56,  // 10: benchmarks.google_message3.Message34381.field34402:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	56,  // 11: benchmarks.google_message3.Message34381.field34405:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	56,  // 12: benchmarks.google_message3.Message34381.field34407:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	56,  // 13: benchmarks.google_message3.Message34619.field34647:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	58,  // 14: benchmarks.google_message3.Message730.field905:type_name -> benchmarks.google_message3.Message697
+	59,  // 15: benchmarks.google_message3.Message730.field906:type_name -> benchmarks.google_message3.Message704
+	60,  // 16: benchmarks.google_message3.Message730.field908:type_name -> benchmarks.google_message3.Message703
+	61,  // 17: benchmarks.google_message3.Message730.field910:type_name -> benchmarks.google_message3.Message716
+	62,  // 18: benchmarks.google_message3.Message730.field911:type_name -> benchmarks.google_message3.Message718
+	63,  // 19: benchmarks.google_message3.Message730.field913:type_name -> benchmarks.google_message3.Message715
+	64,  // 20: benchmarks.google_message3.Message730.field916:type_name -> benchmarks.google_message3.Message719
+	65,  // 21: benchmarks.google_message3.Message730.field917:type_name -> benchmarks.google_message3.Message728
+	66,  // 22: benchmarks.google_message3.Message730.field918:type_name -> benchmarks.google_message3.Message702
+	56,  // 23: benchmarks.google_message3.Message730.field922:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	56,  // 24: benchmarks.google_message3.Message730.field923:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	56,  // 25: benchmarks.google_message3.Message730.field924:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	56,  // 26: benchmarks.google_message3.Message730.field925:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	56,  // 27: benchmarks.google_message3.Message730.field926:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	56,  // 28: benchmarks.google_message3.Message730.field927:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	45,  // 29: benchmarks.google_message3.Message33958.message33959:type_name -> benchmarks.google_message3.Message33958.Message33959
+	67,  // 30: benchmarks.google_message3.Message33958.field33980:type_name -> benchmarks.google_message3.Enum33960
+	56,  // 31: benchmarks.google_message3.Message6637.field6670:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	56,  // 32: benchmarks.google_message3.Message6637.field6671:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	56,  // 33: benchmarks.google_message3.Message6637.field6674:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	56,  // 34: benchmarks.google_message3.Message6643.field6683:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	56,  // 35: benchmarks.google_message3.Message6643.field6684:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	68,  // 36: benchmarks.google_message3.Message6643.field6694:type_name -> benchmarks.google_message3.Message6578
+	69,  // 37: benchmarks.google_message3.Message6643.field6695:type_name -> benchmarks.google_message3.UnusedEnum
+	56,  // 38: benchmarks.google_message3.Message6643.field6697:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	56,  // 39: benchmarks.google_message3.Message6643.field6698:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	56,  // 40: benchmarks.google_message3.Message6643.field6699:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	56,  // 41: benchmarks.google_message3.Message6126.field6153:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	70,  // 42: benchmarks.google_message3.Message6126.field6156:type_name -> benchmarks.google_message3.Message6024
+	71,  // 43: benchmarks.google_message3.Message6126.field6162:type_name -> benchmarks.google_message3.Message6052
+	56,  // 44: benchmarks.google_message3.Message6126.field6163:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	72,  // 45: benchmarks.google_message3.Message6126.field6164:type_name -> benchmarks.google_message3.Enum6065
+	56,  // 46: benchmarks.google_message3.Message6126.field6165:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	73,  // 47: benchmarks.google_message3.Message6126.field6169:type_name -> benchmarks.google_message3.Message6054
+	46,  // 48: benchmarks.google_message3.Message13083.message13084:type_name -> benchmarks.google_message3.Message13083.Message13084
+	47,  // 49: benchmarks.google_message3.Message13083.message13085:type_name -> benchmarks.google_message3.Message13083.Message13085
+	48,  // 50: benchmarks.google_message3.Message13083.message13086:type_name -> benchmarks.google_message3.Message13083.Message13086
+	49,  // 51: benchmarks.google_message3.Message13083.message13087:type_name -> benchmarks.google_message3.Message13083.Message13087
+	56,  // 52: benchmarks.google_message3.Message13083.field13105:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	50,  // 53: benchmarks.google_message3.Message13088.message13089:type_name -> benchmarks.google_message3.Message13088.Message13089
+	74,  // 54: benchmarks.google_message3.Message10391.field10411:type_name -> benchmarks.google_message3.Enum10392
+	69,  // 55: benchmarks.google_message3.Message10391.field10412:type_name -> benchmarks.google_message3.UnusedEnum
+	56,  // 56: benchmarks.google_message3.Message10391.field10418:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	75,  // 57: benchmarks.google_message3.Message11873.field11878:type_name -> benchmarks.google_message3.Message10573
+	76,  // 58: benchmarks.google_message3.Message11873.field11879:type_name -> benchmarks.google_message3.Message10582
+	77,  // 59: benchmarks.google_message3.Message11873.field11880:type_name -> benchmarks.google_message3.Message10824
+	78,  // 60: benchmarks.google_message3.Message11873.field11881:type_name -> benchmarks.google_message3.Message10773
+	79,  // 61: benchmarks.google_message3.Message11873.field11882:type_name -> benchmarks.google_message3.Message11866
+	80,  // 62: benchmarks.google_message3.Message11873.field11883:type_name -> benchmarks.google_message3.Message10818
+	56,  // 63: benchmarks.google_message3.Message11873.field11884:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	81,  // 64: benchmarks.google_message3.Message11873.field11885:type_name -> benchmarks.google_message3.Message10155
+	82,  // 65: benchmarks.google_message3.Message11873.field11886:type_name -> benchmarks.google_message3.Message10469
+	56,  // 66: benchmarks.google_message3.Message11873.field11887:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	83,  // 67: benchmarks.google_message3.Message35506.field35526:type_name -> benchmarks.google_message3.Enum35507
+	56,  // 68: benchmarks.google_message3.Message35506.field35527:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	84,  // 69: benchmarks.google_message3.Message13151.field13158:type_name -> benchmarks.google_message3.Message13145
+	51,  // 70: benchmarks.google_message3.Message18253.message18254:type_name -> benchmarks.google_message3.Message18253.Message18254
+	85,  // 71: benchmarks.google_message3.Message16685.field16694:type_name -> benchmarks.google_message3.Message16686
+	86,  // 72: benchmarks.google_message3.Message16816.field16827:type_name -> benchmarks.google_message3.Enum16819
+	52,  // 73: benchmarks.google_message3.Message16816.message16817:type_name -> benchmarks.google_message3.Message16816.Message16817
+	53,  // 74: benchmarks.google_message3.Message16816.message16818:type_name -> benchmarks.google_message3.Message16816.Message16818
+	87,  // 75: benchmarks.google_message3.Message13168.field13217:type_name -> benchmarks.google_message3.Message12796
+	87,  // 76: benchmarks.google_message3.Message13167.field13205:type_name -> benchmarks.google_message3.Message12796
+	88,  // 77: benchmarks.google_message3.Message3850.field3924:type_name -> benchmarks.google_message3.Enum3851
+	89,  // 78: benchmarks.google_message3.Message6721.field6744:type_name -> benchmarks.google_message3.Message6722
+	90,  // 79: benchmarks.google_message3.Message6726.field6753:type_name -> benchmarks.google_message3.Message6727
+	91,  // 80: benchmarks.google_message3.Message6723.field6749:type_name -> benchmarks.google_message3.Message6724
+	92,  // 81: benchmarks.google_message3.Message6734.field6757:type_name -> benchmarks.google_message3.Message6735
+	93,  // 82: benchmarks.google_message3.Message8184.field8228:type_name -> benchmarks.google_message3.Message7966
+	94,  // 83: benchmarks.google_message3.Message8184.field8230:type_name -> benchmarks.google_message3.Message8183
+	93,  // 84: benchmarks.google_message3.Message8477.field8486:type_name -> benchmarks.google_message3.Message7966
+	95,  // 85: benchmarks.google_message3.Message8454.field8465:type_name -> benchmarks.google_message3.Message8449
+	95,  // 86: benchmarks.google_message3.Message8455.field8470:type_name -> benchmarks.google_message3.Message8449
+	96,  // 87: benchmarks.google_message3.Message8455.field8471:type_name -> benchmarks.google_message3.Message8456
+	97,  // 88: benchmarks.google_message3.Message8455.field8472:type_name -> benchmarks.google_message3.Message8457
+	56,  // 89: benchmarks.google_message3.Message8455.field8473:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	98,  // 90: benchmarks.google_message3.Message16480.field16490:type_name -> benchmarks.google_message3.Message13358
+	99,  // 91: benchmarks.google_message3.Message16480.field16491:type_name -> benchmarks.google_message3.Enum16042
+	100, // 92: benchmarks.google_message3.Message16480.field16492:type_name -> benchmarks.google_message3.Message13912
+	98,  // 93: benchmarks.google_message3.Message16480.field16497:type_name -> benchmarks.google_message3.Message13358
+	101, // 94: benchmarks.google_message3.Message24317.field24447:type_name -> benchmarks.google_message3.Message24312
+	102, // 95: benchmarks.google_message3.Message24317.field24448:type_name -> benchmarks.google_message3.Message24315
+	103, // 96: benchmarks.google_message3.Message24317.field24449:type_name -> benchmarks.google_message3.Message24313
+	104, // 97: benchmarks.google_message3.Message24317.field24450:type_name -> benchmarks.google_message3.Message24316
+	56,  // 98: benchmarks.google_message3.Message24317.field24451:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	56,  // 99: benchmarks.google_message3.Message24317.field24452:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	105, // 100: benchmarks.google_message3.Message33958.Message33959.field33987:type_name -> benchmarks.google_message3.Message0
+	106, // 101: benchmarks.google_message3.Message13083.Message13084.field13110:type_name -> benchmarks.google_message3.Enum13092
+	105, // 102: benchmarks.google_message3.Message33958.field33981:extendee -> benchmarks.google_message3.Message0
+	107, // 103: benchmarks.google_message3.Message8454.field8469:extendee -> benchmarks.google_message3.Message8301
+	108, // 104: benchmarks.google_message3.Message8455.field8474:extendee -> benchmarks.google_message3.Message8302
+	8,   // 105: benchmarks.google_message3.Message33958.field33981:type_name -> benchmarks.google_message3.Message33958
+	37,  // 106: benchmarks.google_message3.Message8454.field8469:type_name -> benchmarks.google_message3.Message8454
+	39,  // 107: benchmarks.google_message3.Message8455.field8474:type_name -> benchmarks.google_message3.Message8455
+	108, // [108:108] is the sub-list for method output_type
+	108, // [108:108] is the sub-list for method input_type
+	105, // [105:108] is the sub-list for extension type_name
+	102, // [102:105] is the sub-list for extension extendee
+	0,   // [0:102] is the sub-list for field type_name
+}
+
+func init() { file_datasets_google_message3_benchmark_message3_4_proto_init() }
+func file_datasets_google_message3_benchmark_message3_4_proto_init() {
+	if File_datasets_google_message3_benchmark_message3_4_proto != nil {
+		return
+	}
+	file_datasets_google_message3_benchmark_message3_5_proto_init()
+	file_datasets_google_message3_benchmark_message3_6_proto_init()
+	file_datasets_google_message3_benchmark_message3_7_proto_init()
+	file_datasets_google_message3_benchmark_message3_8_proto_init()
+	if !protoimpl.UnsafeEnabled {
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message24346); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message24401); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message24402); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message24379); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message27358); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message34381); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message34619); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message730); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message33958); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6637); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6643); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6126); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message13083); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message13088); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message10391); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message11873); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message35506); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message13151); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message18253); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message16685); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message16816); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message13168); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message13167); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message1374); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message18943); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message18944); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message18856); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message3850); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6721); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6742); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6726); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6733); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6723); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6725); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6734); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[35].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8184); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[36].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8477); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[37].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8454); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[38].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8476); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[39].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8455); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[40].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8475); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[41].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12559); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[42].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12817); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[43].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message16480); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[44].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message24317); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[45].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message33958_Message33959); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[46].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message13083_Message13084); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[47].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message13083_Message13085); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[48].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message13083_Message13086); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[49].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message13083_Message13087); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[50].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message13088_Message13089); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[51].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message18253_Message18254); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[52].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message16816_Message16817); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_4_proto_msgTypes[53].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message16816_Message16818); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_datasets_google_message3_benchmark_message3_4_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   54,
+			NumExtensions: 3,
+			NumServices:   0,
+		},
+		GoTypes:           file_datasets_google_message3_benchmark_message3_4_proto_goTypes,
+		DependencyIndexes: file_datasets_google_message3_benchmark_message3_4_proto_depIdxs,
+		MessageInfos:      file_datasets_google_message3_benchmark_message3_4_proto_msgTypes,
+		ExtensionInfos:    file_datasets_google_message3_benchmark_message3_4_proto_extTypes,
+	}.Build()
+	File_datasets_google_message3_benchmark_message3_4_proto = out.File
+	file_datasets_google_message3_benchmark_message3_4_proto_rawDesc = nil
+	file_datasets_google_message3_benchmark_message3_4_proto_goTypes = nil
+	file_datasets_google_message3_benchmark_message3_4_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3/benchmark_message3_5.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3/benchmark_message3_5.pb.go
new file mode 100644
index 000000000..789650c19
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3/benchmark_message3_5.pb.go
@@ -0,0 +1,6133 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// LINT: ALLOW_GROUPS
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: datasets/google_message3/benchmark_message3_5.proto
+
+package google_message3
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoiface "google.golang.org/protobuf/runtime/protoiface"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type Message24377 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message24377) Reset() {
+	*x = Message24377{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message24377) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message24377) ProtoMessage() {}
+
+func (x *Message24377) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message24377.ProtoReflect.Descriptor instead.
+func (*Message24377) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{0}
+}
+
+type Message24378 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message24378) Reset() {
+	*x = Message24378{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message24378) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message24378) ProtoMessage() {}
+
+func (x *Message24378) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message24378.ProtoReflect.Descriptor instead.
+func (*Message24378) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{1}
+}
+
+type Message24400 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field24674 *int32 `protobuf:"varint,1,opt,name=field24674" json:"field24674,omitempty"`
+	Field24675 *int32 `protobuf:"varint,2,opt,name=field24675" json:"field24675,omitempty"`
+	Field24676 *int32 `protobuf:"varint,3,opt,name=field24676" json:"field24676,omitempty"`
+	Field24677 *int32 `protobuf:"varint,4,opt,name=field24677" json:"field24677,omitempty"`
+	Field24678 *int32 `protobuf:"varint,5,opt,name=field24678" json:"field24678,omitempty"`
+}
+
+func (x *Message24400) Reset() {
+	*x = Message24400{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message24400) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message24400) ProtoMessage() {}
+
+func (x *Message24400) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message24400.ProtoReflect.Descriptor instead.
+func (*Message24400) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *Message24400) GetField24674() int32 {
+	if x != nil && x.Field24674 != nil {
+		return *x.Field24674
+	}
+	return 0
+}
+
+func (x *Message24400) GetField24675() int32 {
+	if x != nil && x.Field24675 != nil {
+		return *x.Field24675
+	}
+	return 0
+}
+
+func (x *Message24400) GetField24676() int32 {
+	if x != nil && x.Field24676 != nil {
+		return *x.Field24676
+	}
+	return 0
+}
+
+func (x *Message24400) GetField24677() int32 {
+	if x != nil && x.Field24677 != nil {
+		return *x.Field24677
+	}
+	return 0
+}
+
+func (x *Message24400) GetField24678() int32 {
+	if x != nil && x.Field24678 != nil {
+		return *x.Field24678
+	}
+	return 0
+}
+
+type Message24380 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message24380) Reset() {
+	*x = Message24380{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message24380) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message24380) ProtoMessage() {}
+
+func (x *Message24380) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message24380.ProtoReflect.Descriptor instead.
+func (*Message24380) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{3}
+}
+
+type Message24381 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message24381) Reset() {
+	*x = Message24381{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message24381) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message24381) ProtoMessage() {}
+
+func (x *Message24381) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message24381.ProtoReflect.Descriptor instead.
+func (*Message24381) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{4}
+}
+
+type Message719 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field881 []string `protobuf:"bytes,1,rep,name=field881" json:"field881,omitempty"`
+	Field882 []string `protobuf:"bytes,2,rep,name=field882" json:"field882,omitempty"`
+	Field883 []string `protobuf:"bytes,3,rep,name=field883" json:"field883,omitempty"`
+	Field884 *Enum720 `protobuf:"varint,4,opt,name=field884,enum=benchmarks.google_message3.Enum720" json:"field884,omitempty"`
+}
+
+func (x *Message719) Reset() {
+	*x = Message719{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[5]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message719) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message719) ProtoMessage() {}
+
+func (x *Message719) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[5]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message719.ProtoReflect.Descriptor instead.
+func (*Message719) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *Message719) GetField881() []string {
+	if x != nil {
+		return x.Field881
+	}
+	return nil
+}
+
+func (x *Message719) GetField882() []string {
+	if x != nil {
+		return x.Field882
+	}
+	return nil
+}
+
+func (x *Message719) GetField883() []string {
+	if x != nil {
+		return x.Field883
+	}
+	return nil
+}
+
+func (x *Message719) GetField884() Enum720 {
+	if x != nil && x.Field884 != nil {
+		return *x.Field884
+	}
+	return Enum720_ENUM_VALUE721
+}
+
+type Message728 struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+
+	Field887 *string       `protobuf:"bytes,1,req,name=field887" json:"field887,omitempty"`
+	Field888 []string      `protobuf:"bytes,2,rep,name=field888" json:"field888,omitempty"`
+	Field889 []*Message703 `protobuf:"bytes,3,rep,name=field889" json:"field889,omitempty"`
+	Field890 []*Message715 `protobuf:"bytes,4,rep,name=field890" json:"field890,omitempty"`
+	Field891 []string      `protobuf:"bytes,5,rep,name=field891" json:"field891,omitempty"`
+	Field892 []string      `protobuf:"bytes,6,rep,name=field892" json:"field892,omitempty"`
+	Field893 *Message718   `protobuf:"bytes,7,opt,name=field893" json:"field893,omitempty"`
+	Field894 *Message716   `protobuf:"bytes,8,opt,name=field894" json:"field894,omitempty"`
+	Field895 []string      `protobuf:"bytes,9,rep,name=field895" json:"field895,omitempty"`
+}
+
+func (x *Message728) Reset() {
+	*x = Message728{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[6]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message728) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message728) ProtoMessage() {}
+
+func (x *Message728) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[6]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message728.ProtoReflect.Descriptor instead.
+func (*Message728) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{6}
+}
+
+var extRange_Message728 = []protoiface.ExtensionRangeV1{
+	{Start: 10, End: 10},
+	{Start: 11, End: 11},
+	{Start: 12, End: 12},
+}
+
+// Deprecated: Use Message728.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*Message728) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_Message728
+}
+
+func (x *Message728) GetField887() string {
+	if x != nil && x.Field887 != nil {
+		return *x.Field887
+	}
+	return ""
+}
+
+func (x *Message728) GetField888() []string {
+	if x != nil {
+		return x.Field888
+	}
+	return nil
+}
+
+func (x *Message728) GetField889() []*Message703 {
+	if x != nil {
+		return x.Field889
+	}
+	return nil
+}
+
+func (x *Message728) GetField890() []*Message715 {
+	if x != nil {
+		return x.Field890
+	}
+	return nil
+}
+
+func (x *Message728) GetField891() []string {
+	if x != nil {
+		return x.Field891
+	}
+	return nil
+}
+
+func (x *Message728) GetField892() []string {
+	if x != nil {
+		return x.Field892
+	}
+	return nil
+}
+
+func (x *Message728) GetField893() *Message718 {
+	if x != nil {
+		return x.Field893
+	}
+	return nil
+}
+
+func (x *Message728) GetField894() *Message716 {
+	if x != nil {
+		return x.Field894
+	}
+	return nil
+}
+
+func (x *Message728) GetField895() []string {
+	if x != nil {
+		return x.Field895
+	}
+	return nil
+}
+
+type Message704 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field800 *string             `protobuf:"bytes,1,opt,name=field800" json:"field800,omitempty"`
+	Field801 *string             `protobuf:"bytes,7,opt,name=field801" json:"field801,omitempty"`
+	Field802 *string             `protobuf:"bytes,2,opt,name=field802" json:"field802,omitempty"`
+	Field803 *string             `protobuf:"bytes,3,opt,name=field803" json:"field803,omitempty"`
+	Field804 *string             `protobuf:"bytes,4,opt,name=field804" json:"field804,omitempty"`
+	Field805 *string             `protobuf:"bytes,5,opt,name=field805" json:"field805,omitempty"`
+	Field806 *UnusedEmptyMessage `protobuf:"bytes,6,opt,name=field806" json:"field806,omitempty"`
+}
+
+func (x *Message704) Reset() {
+	*x = Message704{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[7]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message704) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message704) ProtoMessage() {}
+
+func (x *Message704) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[7]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message704.ProtoReflect.Descriptor instead.
+func (*Message704) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *Message704) GetField800() string {
+	if x != nil && x.Field800 != nil {
+		return *x.Field800
+	}
+	return ""
+}
+
+func (x *Message704) GetField801() string {
+	if x != nil && x.Field801 != nil {
+		return *x.Field801
+	}
+	return ""
+}
+
+func (x *Message704) GetField802() string {
+	if x != nil && x.Field802 != nil {
+		return *x.Field802
+	}
+	return ""
+}
+
+func (x *Message704) GetField803() string {
+	if x != nil && x.Field803 != nil {
+		return *x.Field803
+	}
+	return ""
+}
+
+func (x *Message704) GetField804() string {
+	if x != nil && x.Field804 != nil {
+		return *x.Field804
+	}
+	return ""
+}
+
+func (x *Message704) GetField805() string {
+	if x != nil && x.Field805 != nil {
+		return *x.Field805
+	}
+	return ""
+}
+
+func (x *Message704) GetField806() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field806
+	}
+	return nil
+}
+
+type Message697 struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+
+	Field743 *string       `protobuf:"bytes,7,opt,name=field743" json:"field743,omitempty"`
+	Field744 []string      `protobuf:"bytes,1,rep,name=field744" json:"field744,omitempty"`
+	Field745 []string      `protobuf:"bytes,2,rep,name=field745" json:"field745,omitempty"`
+	Field746 []string      `protobuf:"bytes,33,rep,name=field746" json:"field746,omitempty"`
+	Field747 []string      `protobuf:"bytes,29,rep,name=field747" json:"field747,omitempty"`
+	Field748 []string      `protobuf:"bytes,30,rep,name=field748" json:"field748,omitempty"`
+	Field749 []string      `protobuf:"bytes,31,rep,name=field749" json:"field749,omitempty"`
+	Field750 []string      `protobuf:"bytes,32,rep,name=field750" json:"field750,omitempty"`
+	Field751 []string      `protobuf:"bytes,13,rep,name=field751" json:"field751,omitempty"`
+	Field752 []string      `protobuf:"bytes,6,rep,name=field752" json:"field752,omitempty"`
+	Field753 []string      `protobuf:"bytes,3,rep,name=field753" json:"field753,omitempty"`
+	Field754 []string      `protobuf:"bytes,14,rep,name=field754" json:"field754,omitempty"`
+	Field755 []string      `protobuf:"bytes,15,rep,name=field755" json:"field755,omitempty"`
+	Field756 []string      `protobuf:"bytes,16,rep,name=field756" json:"field756,omitempty"`
+	Field757 []string      `protobuf:"bytes,4,rep,name=field757" json:"field757,omitempty"`
+	Field758 []string      `protobuf:"bytes,34,rep,name=field758" json:"field758,omitempty"`
+	Field759 []string      `protobuf:"bytes,35,rep,name=field759" json:"field759,omitempty"`
+	Field760 []string      `protobuf:"bytes,5,rep,name=field760" json:"field760,omitempty"`
+	Field761 []string      `protobuf:"bytes,17,rep,name=field761" json:"field761,omitempty"`
+	Field762 []string      `protobuf:"bytes,18,rep,name=field762" json:"field762,omitempty"`
+	Field763 []string      `protobuf:"bytes,19,rep,name=field763" json:"field763,omitempty"`
+	Field764 *bool         `protobuf:"varint,36,opt,name=field764" json:"field764,omitempty"`
+	Field765 []string      `protobuf:"bytes,8,rep,name=field765" json:"field765,omitempty"`
+	Field766 []string      `protobuf:"bytes,9,rep,name=field766" json:"field766,omitempty"`
+	Field767 *string       `protobuf:"bytes,27,opt,name=field767" json:"field767,omitempty"`
+	Field768 *bool         `protobuf:"varint,25,opt,name=field768" json:"field768,omitempty"`
+	Field769 *Message700   `protobuf:"bytes,10,opt,name=field769" json:"field769,omitempty"`
+	Field770 *bool         `protobuf:"varint,11,opt,name=field770" json:"field770,omitempty"`
+	Field771 *bool         `protobuf:"varint,24,opt,name=field771" json:"field771,omitempty"`
+	Field772 []string      `protobuf:"bytes,12,rep,name=field772" json:"field772,omitempty"`
+	Field773 []string      `protobuf:"bytes,20,rep,name=field773" json:"field773,omitempty"`
+	Field774 []string      `protobuf:"bytes,21,rep,name=field774" json:"field774,omitempty"`
+	Field775 []string      `protobuf:"bytes,22,rep,name=field775" json:"field775,omitempty"`
+	Field776 []*Message699 `protobuf:"bytes,23,rep,name=field776" json:"field776,omitempty"`
+	Field777 []*Message698 `protobuf:"bytes,37,rep,name=field777" json:"field777,omitempty"`
+	Field778 *int64        `protobuf:"varint,38,opt,name=field778" json:"field778,omitempty"`
+}
+
+func (x *Message697) Reset() {
+	*x = Message697{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[8]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message697) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message697) ProtoMessage() {}
+
+func (x *Message697) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[8]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message697.ProtoReflect.Descriptor instead.
+func (*Message697) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{8}
+}
+
+var extRange_Message697 = []protoiface.ExtensionRangeV1{
+	{Start: 28, End: 28},
+	{Start: 26, End: 26},
+}
+
+// Deprecated: Use Message697.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*Message697) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_Message697
+}
+
+func (x *Message697) GetField743() string {
+	if x != nil && x.Field743 != nil {
+		return *x.Field743
+	}
+	return ""
+}
+
+func (x *Message697) GetField744() []string {
+	if x != nil {
+		return x.Field744
+	}
+	return nil
+}
+
+func (x *Message697) GetField745() []string {
+	if x != nil {
+		return x.Field745
+	}
+	return nil
+}
+
+func (x *Message697) GetField746() []string {
+	if x != nil {
+		return x.Field746
+	}
+	return nil
+}
+
+func (x *Message697) GetField747() []string {
+	if x != nil {
+		return x.Field747
+	}
+	return nil
+}
+
+func (x *Message697) GetField748() []string {
+	if x != nil {
+		return x.Field748
+	}
+	return nil
+}
+
+func (x *Message697) GetField749() []string {
+	if x != nil {
+		return x.Field749
+	}
+	return nil
+}
+
+func (x *Message697) GetField750() []string {
+	if x != nil {
+		return x.Field750
+	}
+	return nil
+}
+
+func (x *Message697) GetField751() []string {
+	if x != nil {
+		return x.Field751
+	}
+	return nil
+}
+
+func (x *Message697) GetField752() []string {
+	if x != nil {
+		return x.Field752
+	}
+	return nil
+}
+
+func (x *Message697) GetField753() []string {
+	if x != nil {
+		return x.Field753
+	}
+	return nil
+}
+
+func (x *Message697) GetField754() []string {
+	if x != nil {
+		return x.Field754
+	}
+	return nil
+}
+
+func (x *Message697) GetField755() []string {
+	if x != nil {
+		return x.Field755
+	}
+	return nil
+}
+
+func (x *Message697) GetField756() []string {
+	if x != nil {
+		return x.Field756
+	}
+	return nil
+}
+
+func (x *Message697) GetField757() []string {
+	if x != nil {
+		return x.Field757
+	}
+	return nil
+}
+
+func (x *Message697) GetField758() []string {
+	if x != nil {
+		return x.Field758
+	}
+	return nil
+}
+
+func (x *Message697) GetField759() []string {
+	if x != nil {
+		return x.Field759
+	}
+	return nil
+}
+
+func (x *Message697) GetField760() []string {
+	if x != nil {
+		return x.Field760
+	}
+	return nil
+}
+
+func (x *Message697) GetField761() []string {
+	if x != nil {
+		return x.Field761
+	}
+	return nil
+}
+
+func (x *Message697) GetField762() []string {
+	if x != nil {
+		return x.Field762
+	}
+	return nil
+}
+
+func (x *Message697) GetField763() []string {
+	if x != nil {
+		return x.Field763
+	}
+	return nil
+}
+
+func (x *Message697) GetField764() bool {
+	if x != nil && x.Field764 != nil {
+		return *x.Field764
+	}
+	return false
+}
+
+func (x *Message697) GetField765() []string {
+	if x != nil {
+		return x.Field765
+	}
+	return nil
+}
+
+func (x *Message697) GetField766() []string {
+	if x != nil {
+		return x.Field766
+	}
+	return nil
+}
+
+func (x *Message697) GetField767() string {
+	if x != nil && x.Field767 != nil {
+		return *x.Field767
+	}
+	return ""
+}
+
+func (x *Message697) GetField768() bool {
+	if x != nil && x.Field768 != nil {
+		return *x.Field768
+	}
+	return false
+}
+
+func (x *Message697) GetField769() *Message700 {
+	if x != nil {
+		return x.Field769
+	}
+	return nil
+}
+
+func (x *Message697) GetField770() bool {
+	if x != nil && x.Field770 != nil {
+		return *x.Field770
+	}
+	return false
+}
+
+func (x *Message697) GetField771() bool {
+	if x != nil && x.Field771 != nil {
+		return *x.Field771
+	}
+	return false
+}
+
+func (x *Message697) GetField772() []string {
+	if x != nil {
+		return x.Field772
+	}
+	return nil
+}
+
+func (x *Message697) GetField773() []string {
+	if x != nil {
+		return x.Field773
+	}
+	return nil
+}
+
+func (x *Message697) GetField774() []string {
+	if x != nil {
+		return x.Field774
+	}
+	return nil
+}
+
+func (x *Message697) GetField775() []string {
+	if x != nil {
+		return x.Field775
+	}
+	return nil
+}
+
+func (x *Message697) GetField776() []*Message699 {
+	if x != nil {
+		return x.Field776
+	}
+	return nil
+}
+
+func (x *Message697) GetField777() []*Message698 {
+	if x != nil {
+		return x.Field777
+	}
+	return nil
+}
+
+func (x *Message697) GetField778() int64 {
+	if x != nil && x.Field778 != nil {
+		return *x.Field778
+	}
+	return 0
+}
+
+type Message0 struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+}
+
+func (x *Message0) Reset() {
+	*x = Message0{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[9]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message0) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message0) ProtoMessage() {}
+
+func (x *Message0) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[9]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message0.ProtoReflect.Descriptor instead.
+func (*Message0) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{9}
+}
+
+var extRange_Message0 = []protoiface.ExtensionRangeV1{
+	{Start: 4, End: 2147483646},
+}
+
+// Deprecated: Use Message0.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*Message0) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_Message0
+}
+
+type Message6578 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field6632 *Enum6579 `protobuf:"varint,1,opt,name=field6632,enum=benchmarks.google_message3.Enum6579" json:"field6632,omitempty"`
+	Field6633 *Enum6588 `protobuf:"varint,2,opt,name=field6633,enum=benchmarks.google_message3.Enum6588" json:"field6633,omitempty"`
+}
+
+func (x *Message6578) Reset() {
+	*x = Message6578{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[10]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6578) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6578) ProtoMessage() {}
+
+func (x *Message6578) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[10]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6578.ProtoReflect.Descriptor instead.
+func (*Message6578) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{10}
+}
+
+func (x *Message6578) GetField6632() Enum6579 {
+	if x != nil && x.Field6632 != nil {
+		return *x.Field6632
+	}
+	return Enum6579_ENUM_VALUE6580
+}
+
+func (x *Message6578) GetField6633() Enum6588 {
+	if x != nil && x.Field6633 != nil {
+		return *x.Field6633
+	}
+	return Enum6588_ENUM_VALUE6589
+}
+
+type Message6024 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field6048 *Enum6025           `protobuf:"varint,1,opt,name=field6048,enum=benchmarks.google_message3.Enum6025" json:"field6048,omitempty"`
+	Field6049 *string             `protobuf:"bytes,2,opt,name=field6049" json:"field6049,omitempty"`
+	Field6050 *UnusedEmptyMessage `protobuf:"bytes,3,opt,name=field6050" json:"field6050,omitempty"`
+}
+
+func (x *Message6024) Reset() {
+	*x = Message6024{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[11]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6024) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6024) ProtoMessage() {}
+
+func (x *Message6024) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[11]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6024.ProtoReflect.Descriptor instead.
+func (*Message6024) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{11}
+}
+
+func (x *Message6024) GetField6048() Enum6025 {
+	if x != nil && x.Field6048 != nil {
+		return *x.Field6048
+	}
+	return Enum6025_ENUM_VALUE6026
+}
+
+func (x *Message6024) GetField6049() string {
+	if x != nil && x.Field6049 != nil {
+		return *x.Field6049
+	}
+	return ""
+}
+
+func (x *Message6024) GetField6050() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field6050
+	}
+	return nil
+}
+
+type Message6052 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field6084 *string `protobuf:"bytes,1,req,name=field6084" json:"field6084,omitempty"`
+	Field6085 []byte  `protobuf:"bytes,2,req,name=field6085" json:"field6085,omitempty"`
+}
+
+func (x *Message6052) Reset() {
+	*x = Message6052{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[12]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6052) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6052) ProtoMessage() {}
+
+func (x *Message6052) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[12]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6052.ProtoReflect.Descriptor instead.
+func (*Message6052) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{12}
+}
+
+func (x *Message6052) GetField6084() string {
+	if x != nil && x.Field6084 != nil {
+		return *x.Field6084
+	}
+	return ""
+}
+
+func (x *Message6052) GetField6085() []byte {
+	if x != nil {
+		return x.Field6085
+	}
+	return nil
+}
+
+type Message6054 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field6089 *string `protobuf:"bytes,1,req,name=field6089" json:"field6089,omitempty"`
+	Field6090 *string `protobuf:"bytes,2,opt,name=field6090" json:"field6090,omitempty"`
+}
+
+func (x *Message6054) Reset() {
+	*x = Message6054{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[13]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6054) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6054) ProtoMessage() {}
+
+func (x *Message6054) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[13]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6054.ProtoReflect.Descriptor instead.
+func (*Message6054) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{13}
+}
+
+func (x *Message6054) GetField6089() string {
+	if x != nil && x.Field6089 != nil {
+		return *x.Field6089
+	}
+	return ""
+}
+
+func (x *Message6054) GetField6090() string {
+	if x != nil && x.Field6090 != nil {
+		return *x.Field6090
+	}
+	return ""
+}
+
+type Message10573 struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+
+	Field10580 []*Message10576 `protobuf:"bytes,1,rep,name=field10580" json:"field10580,omitempty"`
+	Field10581 *string         `protobuf:"bytes,2,opt,name=field10581" json:"field10581,omitempty"`
+}
+
+func (x *Message10573) Reset() {
+	*x = Message10573{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[14]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message10573) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message10573) ProtoMessage() {}
+
+func (x *Message10573) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[14]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message10573.ProtoReflect.Descriptor instead.
+func (*Message10573) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{14}
+}
+
+var extRange_Message10573 = []protoiface.ExtensionRangeV1{
+	{Start: 10000, End: 536870911},
+}
+
+// Deprecated: Use Message10573.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*Message10573) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_Message10573
+}
+
+func (x *Message10573) GetField10580() []*Message10576 {
+	if x != nil {
+		return x.Field10580
+	}
+	return nil
+}
+
+func (x *Message10573) GetField10581() string {
+	if x != nil && x.Field10581 != nil {
+		return *x.Field10581
+	}
+	return ""
+}
+
+type Message10824 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field10825 *string `protobuf:"bytes,1,req,name=field10825" json:"field10825,omitempty"`
+	Field10826 *int32  `protobuf:"varint,2,opt,name=field10826" json:"field10826,omitempty"`
+}
+
+func (x *Message10824) Reset() {
+	*x = Message10824{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[15]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message10824) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message10824) ProtoMessage() {}
+
+func (x *Message10824) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[15]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message10824.ProtoReflect.Descriptor instead.
+func (*Message10824) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{15}
+}
+
+func (x *Message10824) GetField10825() string {
+	if x != nil && x.Field10825 != nil {
+		return *x.Field10825
+	}
+	return ""
+}
+
+func (x *Message10824) GetField10826() int32 {
+	if x != nil && x.Field10826 != nil {
+		return *x.Field10826
+	}
+	return 0
+}
+
+type Message10582 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field10583 *bool    `protobuf:"varint,1,req,name=field10583" json:"field10583,omitempty"`
+	Field10584 *float64 `protobuf:"fixed64,2,req,name=field10584" json:"field10584,omitempty"`
+	Field10585 *bool    `protobuf:"varint,3,opt,name=field10585" json:"field10585,omitempty"`
+	Field10586 *float64 `protobuf:"fixed64,4,opt,name=field10586" json:"field10586,omitempty"`
+	Field10587 *float64 `protobuf:"fixed64,5,opt,name=field10587" json:"field10587,omitempty"`
+	Field10588 *bool    `protobuf:"varint,6,opt,name=field10588" json:"field10588,omitempty"`
+}
+
+func (x *Message10582) Reset() {
+	*x = Message10582{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[16]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message10582) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message10582) ProtoMessage() {}
+
+func (x *Message10582) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[16]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message10582.ProtoReflect.Descriptor instead.
+func (*Message10582) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{16}
+}
+
+func (x *Message10582) GetField10583() bool {
+	if x != nil && x.Field10583 != nil {
+		return *x.Field10583
+	}
+	return false
+}
+
+func (x *Message10582) GetField10584() float64 {
+	if x != nil && x.Field10584 != nil {
+		return *x.Field10584
+	}
+	return 0
+}
+
+func (x *Message10582) GetField10585() bool {
+	if x != nil && x.Field10585 != nil {
+		return *x.Field10585
+	}
+	return false
+}
+
+func (x *Message10582) GetField10586() float64 {
+	if x != nil && x.Field10586 != nil {
+		return *x.Field10586
+	}
+	return 0
+}
+
+func (x *Message10582) GetField10587() float64 {
+	if x != nil && x.Field10587 != nil {
+		return *x.Field10587
+	}
+	return 0
+}
+
+func (x *Message10582) GetField10588() bool {
+	if x != nil && x.Field10588 != nil {
+		return *x.Field10588
+	}
+	return false
+}
+
+type Message10155 struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+
+	Field10195   *int32                       `protobuf:"varint,1,req,name=field10195" json:"field10195,omitempty"`
+	Field10196   *int32                       `protobuf:"varint,2,req,name=field10196" json:"field10196,omitempty"`
+	Field10197   *Enum10157                   `protobuf:"varint,59,opt,name=field10197,enum=benchmarks.google_message3.Enum10157" json:"field10197,omitempty"`
+	Field10198   *int32                       `protobuf:"varint,18,opt,name=field10198" json:"field10198,omitempty"`
+	Field10199   *int32                       `protobuf:"varint,19,opt,name=field10199" json:"field10199,omitempty"`
+	Field10200   *int32                       `protobuf:"varint,21,opt,name=field10200" json:"field10200,omitempty"`
+	Message10156 []*Message10155_Message10156 `protobuf:"group,50,rep,name=Message10156,json=message10156" json:"message10156,omitempty"`
+	Field10202   *int32                       `protobuf:"varint,3,opt,name=field10202" json:"field10202,omitempty"`
+	Field10203   *int32                       `protobuf:"varint,4,opt,name=field10203" json:"field10203,omitempty"`
+	Field10204   *int32                       `protobuf:"varint,5,opt,name=field10204" json:"field10204,omitempty"`
+	Field10205   *bool                        `protobuf:"varint,84,opt,name=field10205" json:"field10205,omitempty"`
+	Field10206   *bool                        `protobuf:"varint,33,opt,name=field10206" json:"field10206,omitempty"`
+	Field10207   *int32                       `protobuf:"varint,75,opt,name=field10207" json:"field10207,omitempty"`
+	Field10208   *float32                     `protobuf:"fixed32,26,opt,name=field10208" json:"field10208,omitempty"`
+	Field10209   *int32                       `protobuf:"varint,27,opt,name=field10209" json:"field10209,omitempty"`
+	Field10210   *int32                       `protobuf:"varint,49,opt,name=field10210" json:"field10210,omitempty"`
+	Field10211   *int32                       `protobuf:"varint,10,opt,name=field10211" json:"field10211,omitempty"`
+	Field10212   *float32                     `protobuf:"fixed32,78,opt,name=field10212" json:"field10212,omitempty"`
+	Field10213   *Message9151                 `protobuf:"bytes,91,opt,name=field10213" json:"field10213,omitempty"`
+	Field10214   *int32                       `protobuf:"varint,11,opt,name=field10214" json:"field10214,omitempty"`
+	Field10215   *int32                       `protobuf:"varint,12,opt,name=field10215" json:"field10215,omitempty"`
+	Field10216   *float32                     `protobuf:"fixed32,41,opt,name=field10216" json:"field10216,omitempty"`
+	Field10217   *Message10154                `protobuf:"bytes,61,opt,name=field10217" json:"field10217,omitempty"`
+	Field10218   *int32                       `protobuf:"varint,23,opt,name=field10218" json:"field10218,omitempty"`
+	Field10219   []byte                       `protobuf:"bytes,24,opt,name=field10219" json:"field10219,omitempty"`
+	Field10220   *int32                       `protobuf:"varint,65,opt,name=field10220" json:"field10220,omitempty"`
+	Field10221   [][]byte                     `protobuf:"bytes,66,rep,name=field10221" json:"field10221,omitempty"`
+	Field10222   *int32                       `protobuf:"varint,70,opt,name=field10222" json:"field10222,omitempty"`
+	Field10223   []byte                       `protobuf:"bytes,71,opt,name=field10223" json:"field10223,omitempty"`
+	Field10224   []uint64                     `protobuf:"fixed64,73,rep,name=field10224" json:"field10224,omitempty"`
+	Field10225   *float32                     `protobuf:"fixed32,29,opt,name=field10225" json:"field10225,omitempty"`
+	Field10226   *int32                       `protobuf:"varint,30,opt,name=field10226" json:"field10226,omitempty"`
+	Field10227   *float32                     `protobuf:"fixed32,31,opt,name=field10227" json:"field10227,omitempty"`
+	Field10228   *int32                       `protobuf:"varint,32,opt,name=field10228" json:"field10228,omitempty"`
+	Field10229   *float32                     `protobuf:"fixed32,34,opt,name=field10229" json:"field10229,omitempty"`
+	Field10230   *int32                       `protobuf:"varint,35,opt,name=field10230" json:"field10230,omitempty"`
+	Field10231   *string                      `protobuf:"bytes,22,opt,name=field10231" json:"field10231,omitempty"`
+	Field10232   *uint64                      `protobuf:"fixed64,13,opt,name=field10232" json:"field10232,omitempty"`
+	Field10233   *uint64                      `protobuf:"fixed64,20,opt,name=field10233" json:"field10233,omitempty"`
+	Field10234   *bool                        `protobuf:"varint,79,opt,name=field10234" json:"field10234,omitempty"`
+	Field10235   []Enum10167                  `protobuf:"varint,80,rep,packed,name=field10235,enum=benchmarks.google_message3.Enum10167" json:"field10235,omitempty"`
+	Field10236   *int32                       `protobuf:"varint,14,opt,name=field10236" json:"field10236,omitempty"`
+	Field10237   *int32                       `protobuf:"varint,15,opt,name=field10237" json:"field10237,omitempty"`
+	Field10238   *int32                       `protobuf:"varint,28,opt,name=field10238" json:"field10238,omitempty"`
+	Field10239   []string                     `protobuf:"bytes,16,rep,name=field10239" json:"field10239,omitempty"`
+	Field10240   *Message9182                 `protobuf:"bytes,17,opt,name=field10240" json:"field10240,omitempty"`
+	Field10241   *int32                       `protobuf:"varint,63,opt,name=field10241" json:"field10241,omitempty"`
+	Field10242   *float32                     `protobuf:"fixed32,64,opt,name=field10242" json:"field10242,omitempty"`
+	Field10243   *float32                     `protobuf:"fixed32,37,opt,name=field10243" json:"field10243,omitempty"`
+	Field10244   []float32                    `protobuf:"fixed32,43,rep,name=field10244" json:"field10244,omitempty"`
+	Field10245   *int32                       `protobuf:"varint,44,opt,name=field10245" json:"field10245,omitempty"`
+	Field10246   *Message9242                 `protobuf:"bytes,45,opt,name=field10246" json:"field10246,omitempty"`
+	Field10247   *UnusedEmptyMessage          `protobuf:"bytes,46,opt,name=field10247" json:"field10247,omitempty"`
+	Field10248   *UnusedEmptyMessage          `protobuf:"bytes,62,opt,name=field10248" json:"field10248,omitempty"`
+	Field10249   *Message8944                 `protobuf:"bytes,48,opt,name=field10249" json:"field10249,omitempty"`
+	Field10250   *UnusedEmptyMessage          `protobuf:"bytes,87,opt,name=field10250" json:"field10250,omitempty"`
+	Field10251   *int32                       `protobuf:"varint,58,opt,name=field10251" json:"field10251,omitempty"`
+	Field10252   *int32                       `protobuf:"varint,92,opt,name=field10252" json:"field10252,omitempty"`
+	Field10253   *Message9123                 `protobuf:"bytes,93,opt,name=field10253" json:"field10253,omitempty"`
+	Field10254   *Message9160                 `protobuf:"bytes,60,opt,name=field10254" json:"field10254,omitempty"`
+	Field10255   *Message8890                 `protobuf:"bytes,67,opt,name=field10255" json:"field10255,omitempty"`
+	Field10256   *string                      `protobuf:"bytes,69,opt,name=field10256" json:"field10256,omitempty"`
+	Field10257   *int64                       `protobuf:"varint,74,opt,name=field10257" json:"field10257,omitempty"`
+	Field10258   *float32                     `protobuf:"fixed32,82,opt,name=field10258" json:"field10258,omitempty"`
+	Field10259   *float32                     `protobuf:"fixed32,85,opt,name=field10259" json:"field10259,omitempty"`
+	Field10260   *float32                     `protobuf:"fixed32,86,opt,name=field10260" json:"field10260,omitempty"`
+	Field10261   *int64                       `protobuf:"varint,83,opt,name=field10261" json:"field10261,omitempty"`
+	Field10262   *string                      `protobuf:"bytes,77,opt,name=field10262" json:"field10262,omitempty"`
+	Field10263   *bool                        `protobuf:"varint,88,opt,name=field10263" json:"field10263,omitempty"`
+	Field10264   []*Message9628               `protobuf:"bytes,94,rep,name=field10264" json:"field10264,omitempty"`
+}
+
+func (x *Message10155) Reset() {
+	*x = Message10155{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[17]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message10155) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message10155) ProtoMessage() {}
+
+func (x *Message10155) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[17]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message10155.ProtoReflect.Descriptor instead.
+func (*Message10155) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{17}
+}
+
+var extRange_Message10155 = []protoiface.ExtensionRangeV1{
+	{Start: 57, End: 57},
+	{Start: 1000, End: 536870911},
+}
+
+// Deprecated: Use Message10155.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*Message10155) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_Message10155
+}
+
+func (x *Message10155) GetField10195() int32 {
+	if x != nil && x.Field10195 != nil {
+		return *x.Field10195
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10196() int32 {
+	if x != nil && x.Field10196 != nil {
+		return *x.Field10196
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10197() Enum10157 {
+	if x != nil && x.Field10197 != nil {
+		return *x.Field10197
+	}
+	return Enum10157_ENUM_VALUE10158
+}
+
+func (x *Message10155) GetField10198() int32 {
+	if x != nil && x.Field10198 != nil {
+		return *x.Field10198
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10199() int32 {
+	if x != nil && x.Field10199 != nil {
+		return *x.Field10199
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10200() int32 {
+	if x != nil && x.Field10200 != nil {
+		return *x.Field10200
+	}
+	return 0
+}
+
+func (x *Message10155) GetMessage10156() []*Message10155_Message10156 {
+	if x != nil {
+		return x.Message10156
+	}
+	return nil
+}
+
+func (x *Message10155) GetField10202() int32 {
+	if x != nil && x.Field10202 != nil {
+		return *x.Field10202
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10203() int32 {
+	if x != nil && x.Field10203 != nil {
+		return *x.Field10203
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10204() int32 {
+	if x != nil && x.Field10204 != nil {
+		return *x.Field10204
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10205() bool {
+	if x != nil && x.Field10205 != nil {
+		return *x.Field10205
+	}
+	return false
+}
+
+func (x *Message10155) GetField10206() bool {
+	if x != nil && x.Field10206 != nil {
+		return *x.Field10206
+	}
+	return false
+}
+
+func (x *Message10155) GetField10207() int32 {
+	if x != nil && x.Field10207 != nil {
+		return *x.Field10207
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10208() float32 {
+	if x != nil && x.Field10208 != nil {
+		return *x.Field10208
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10209() int32 {
+	if x != nil && x.Field10209 != nil {
+		return *x.Field10209
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10210() int32 {
+	if x != nil && x.Field10210 != nil {
+		return *x.Field10210
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10211() int32 {
+	if x != nil && x.Field10211 != nil {
+		return *x.Field10211
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10212() float32 {
+	if x != nil && x.Field10212 != nil {
+		return *x.Field10212
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10213() *Message9151 {
+	if x != nil {
+		return x.Field10213
+	}
+	return nil
+}
+
+func (x *Message10155) GetField10214() int32 {
+	if x != nil && x.Field10214 != nil {
+		return *x.Field10214
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10215() int32 {
+	if x != nil && x.Field10215 != nil {
+		return *x.Field10215
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10216() float32 {
+	if x != nil && x.Field10216 != nil {
+		return *x.Field10216
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10217() *Message10154 {
+	if x != nil {
+		return x.Field10217
+	}
+	return nil
+}
+
+func (x *Message10155) GetField10218() int32 {
+	if x != nil && x.Field10218 != nil {
+		return *x.Field10218
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10219() []byte {
+	if x != nil {
+		return x.Field10219
+	}
+	return nil
+}
+
+func (x *Message10155) GetField10220() int32 {
+	if x != nil && x.Field10220 != nil {
+		return *x.Field10220
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10221() [][]byte {
+	if x != nil {
+		return x.Field10221
+	}
+	return nil
+}
+
+func (x *Message10155) GetField10222() int32 {
+	if x != nil && x.Field10222 != nil {
+		return *x.Field10222
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10223() []byte {
+	if x != nil {
+		return x.Field10223
+	}
+	return nil
+}
+
+func (x *Message10155) GetField10224() []uint64 {
+	if x != nil {
+		return x.Field10224
+	}
+	return nil
+}
+
+func (x *Message10155) GetField10225() float32 {
+	if x != nil && x.Field10225 != nil {
+		return *x.Field10225
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10226() int32 {
+	if x != nil && x.Field10226 != nil {
+		return *x.Field10226
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10227() float32 {
+	if x != nil && x.Field10227 != nil {
+		return *x.Field10227
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10228() int32 {
+	if x != nil && x.Field10228 != nil {
+		return *x.Field10228
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10229() float32 {
+	if x != nil && x.Field10229 != nil {
+		return *x.Field10229
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10230() int32 {
+	if x != nil && x.Field10230 != nil {
+		return *x.Field10230
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10231() string {
+	if x != nil && x.Field10231 != nil {
+		return *x.Field10231
+	}
+	return ""
+}
+
+func (x *Message10155) GetField10232() uint64 {
+	if x != nil && x.Field10232 != nil {
+		return *x.Field10232
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10233() uint64 {
+	if x != nil && x.Field10233 != nil {
+		return *x.Field10233
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10234() bool {
+	if x != nil && x.Field10234 != nil {
+		return *x.Field10234
+	}
+	return false
+}
+
+func (x *Message10155) GetField10235() []Enum10167 {
+	if x != nil {
+		return x.Field10235
+	}
+	return nil
+}
+
+func (x *Message10155) GetField10236() int32 {
+	if x != nil && x.Field10236 != nil {
+		return *x.Field10236
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10237() int32 {
+	if x != nil && x.Field10237 != nil {
+		return *x.Field10237
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10238() int32 {
+	if x != nil && x.Field10238 != nil {
+		return *x.Field10238
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10239() []string {
+	if x != nil {
+		return x.Field10239
+	}
+	return nil
+}
+
+func (x *Message10155) GetField10240() *Message9182 {
+	if x != nil {
+		return x.Field10240
+	}
+	return nil
+}
+
+func (x *Message10155) GetField10241() int32 {
+	if x != nil && x.Field10241 != nil {
+		return *x.Field10241
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10242() float32 {
+	if x != nil && x.Field10242 != nil {
+		return *x.Field10242
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10243() float32 {
+	if x != nil && x.Field10243 != nil {
+		return *x.Field10243
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10244() []float32 {
+	if x != nil {
+		return x.Field10244
+	}
+	return nil
+}
+
+func (x *Message10155) GetField10245() int32 {
+	if x != nil && x.Field10245 != nil {
+		return *x.Field10245
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10246() *Message9242 {
+	if x != nil {
+		return x.Field10246
+	}
+	return nil
+}
+
+func (x *Message10155) GetField10247() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field10247
+	}
+	return nil
+}
+
+func (x *Message10155) GetField10248() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field10248
+	}
+	return nil
+}
+
+func (x *Message10155) GetField10249() *Message8944 {
+	if x != nil {
+		return x.Field10249
+	}
+	return nil
+}
+
+func (x *Message10155) GetField10250() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field10250
+	}
+	return nil
+}
+
+func (x *Message10155) GetField10251() int32 {
+	if x != nil && x.Field10251 != nil {
+		return *x.Field10251
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10252() int32 {
+	if x != nil && x.Field10252 != nil {
+		return *x.Field10252
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10253() *Message9123 {
+	if x != nil {
+		return x.Field10253
+	}
+	return nil
+}
+
+func (x *Message10155) GetField10254() *Message9160 {
+	if x != nil {
+		return x.Field10254
+	}
+	return nil
+}
+
+func (x *Message10155) GetField10255() *Message8890 {
+	if x != nil {
+		return x.Field10255
+	}
+	return nil
+}
+
+func (x *Message10155) GetField10256() string {
+	if x != nil && x.Field10256 != nil {
+		return *x.Field10256
+	}
+	return ""
+}
+
+func (x *Message10155) GetField10257() int64 {
+	if x != nil && x.Field10257 != nil {
+		return *x.Field10257
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10258() float32 {
+	if x != nil && x.Field10258 != nil {
+		return *x.Field10258
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10259() float32 {
+	if x != nil && x.Field10259 != nil {
+		return *x.Field10259
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10260() float32 {
+	if x != nil && x.Field10260 != nil {
+		return *x.Field10260
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10261() int64 {
+	if x != nil && x.Field10261 != nil {
+		return *x.Field10261
+	}
+	return 0
+}
+
+func (x *Message10155) GetField10262() string {
+	if x != nil && x.Field10262 != nil {
+		return *x.Field10262
+	}
+	return ""
+}
+
+func (x *Message10155) GetField10263() bool {
+	if x != nil && x.Field10263 != nil {
+		return *x.Field10263
+	}
+	return false
+}
+
+func (x *Message10155) GetField10264() []*Message9628 {
+	if x != nil {
+		return x.Field10264
+	}
+	return nil
+}
+
+type Message11866 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field11868 *Message11014         `protobuf:"bytes,1,req,name=field11868" json:"field11868,omitempty"`
+	Field11869 *bool                 `protobuf:"varint,2,opt,name=field11869" json:"field11869,omitempty"`
+	Field11870 *float64              `protobuf:"fixed64,3,opt,name=field11870" json:"field11870,omitempty"`
+	Field11871 *float64              `protobuf:"fixed64,4,opt,name=field11871" json:"field11871,omitempty"`
+	Field11872 []*UnusedEmptyMessage `protobuf:"bytes,5,rep,name=field11872" json:"field11872,omitempty"`
+}
+
+func (x *Message11866) Reset() {
+	*x = Message11866{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[18]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message11866) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message11866) ProtoMessage() {}
+
+func (x *Message11866) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[18]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message11866.ProtoReflect.Descriptor instead.
+func (*Message11866) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{18}
+}
+
+func (x *Message11866) GetField11868() *Message11014 {
+	if x != nil {
+		return x.Field11868
+	}
+	return nil
+}
+
+func (x *Message11866) GetField11869() bool {
+	if x != nil && x.Field11869 != nil {
+		return *x.Field11869
+	}
+	return false
+}
+
+func (x *Message11866) GetField11870() float64 {
+	if x != nil && x.Field11870 != nil {
+		return *x.Field11870
+	}
+	return 0
+}
+
+func (x *Message11866) GetField11871() float64 {
+	if x != nil && x.Field11871 != nil {
+		return *x.Field11871
+	}
+	return 0
+}
+
+func (x *Message11866) GetField11872() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field11872
+	}
+	return nil
+}
+
+type Message10469 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field10473 *string  `protobuf:"bytes,1,opt,name=field10473" json:"field10473,omitempty"`
+	Field10474 *float32 `protobuf:"fixed32,2,opt,name=field10474" json:"field10474,omitempty"`
+	Field10475 *int32   `protobuf:"varint,3,opt,name=field10475" json:"field10475,omitempty"`
+	Field10476 *int32   `protobuf:"varint,4,opt,name=field10476" json:"field10476,omitempty"`
+	Field10477 *int32   `protobuf:"varint,5,opt,name=field10477" json:"field10477,omitempty"`
+	Field10478 *bool    `protobuf:"varint,6,opt,name=field10478" json:"field10478,omitempty"`
+	Field10479 *bool    `protobuf:"varint,7,opt,name=field10479" json:"field10479,omitempty"`
+	Field10480 *int32   `protobuf:"varint,8,opt,name=field10480" json:"field10480,omitempty"`
+	Field10481 *float32 `protobuf:"fixed32,9,opt,name=field10481" json:"field10481,omitempty"`
+}
+
+func (x *Message10469) Reset() {
+	*x = Message10469{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[19]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message10469) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message10469) ProtoMessage() {}
+
+func (x *Message10469) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[19]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message10469.ProtoReflect.Descriptor instead.
+func (*Message10469) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{19}
+}
+
+func (x *Message10469) GetField10473() string {
+	if x != nil && x.Field10473 != nil {
+		return *x.Field10473
+	}
+	return ""
+}
+
+func (x *Message10469) GetField10474() float32 {
+	if x != nil && x.Field10474 != nil {
+		return *x.Field10474
+	}
+	return 0
+}
+
+func (x *Message10469) GetField10475() int32 {
+	if x != nil && x.Field10475 != nil {
+		return *x.Field10475
+	}
+	return 0
+}
+
+func (x *Message10469) GetField10476() int32 {
+	if x != nil && x.Field10476 != nil {
+		return *x.Field10476
+	}
+	return 0
+}
+
+func (x *Message10469) GetField10477() int32 {
+	if x != nil && x.Field10477 != nil {
+		return *x.Field10477
+	}
+	return 0
+}
+
+func (x *Message10469) GetField10478() bool {
+	if x != nil && x.Field10478 != nil {
+		return *x.Field10478
+	}
+	return false
+}
+
+func (x *Message10469) GetField10479() bool {
+	if x != nil && x.Field10479 != nil {
+		return *x.Field10479
+	}
+	return false
+}
+
+func (x *Message10469) GetField10480() int32 {
+	if x != nil && x.Field10480 != nil {
+		return *x.Field10480
+	}
+	return 0
+}
+
+func (x *Message10469) GetField10481() float32 {
+	if x != nil && x.Field10481 != nil {
+		return *x.Field10481
+	}
+	return 0
+}
+
+type Message10818 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field10819 *Message10800 `protobuf:"bytes,1,opt,name=field10819" json:"field10819,omitempty"`
+	Field10820 *Message10801 `protobuf:"bytes,2,opt,name=field10820" json:"field10820,omitempty"`
+}
+
+func (x *Message10818) Reset() {
+	*x = Message10818{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[20]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message10818) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message10818) ProtoMessage() {}
+
+func (x *Message10818) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[20]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message10818.ProtoReflect.Descriptor instead.
+func (*Message10818) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{20}
+}
+
+func (x *Message10818) GetField10819() *Message10800 {
+	if x != nil {
+		return x.Field10819
+	}
+	return nil
+}
+
+func (x *Message10818) GetField10820() *Message10801 {
+	if x != nil {
+		return x.Field10820
+	}
+	return nil
+}
+
+type Message10773 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field10774 *bool                 `protobuf:"varint,9,opt,name=field10774" json:"field10774,omitempty"`
+	Field10775 *bool                 `protobuf:"varint,1,opt,name=field10775" json:"field10775,omitempty"`
+	Field10776 *bool                 `protobuf:"varint,23,opt,name=field10776" json:"field10776,omitempty"`
+	Field10777 *bool                 `protobuf:"varint,2,opt,name=field10777" json:"field10777,omitempty"`
+	Field10778 *bool                 `protobuf:"varint,3,opt,name=field10778" json:"field10778,omitempty"`
+	Field10779 *int32                `protobuf:"varint,4,opt,name=field10779" json:"field10779,omitempty"`
+	Field10780 *int32                `protobuf:"varint,5,opt,name=field10780" json:"field10780,omitempty"`
+	Field10781 *int32                `protobuf:"varint,6,opt,name=field10781" json:"field10781,omitempty"`
+	Field10782 *int32                `protobuf:"varint,7,opt,name=field10782" json:"field10782,omitempty"`
+	Field10783 *int32                `protobuf:"varint,8,opt,name=field10783" json:"field10783,omitempty"`
+	Field10784 *int32                `protobuf:"varint,10,opt,name=field10784" json:"field10784,omitempty"`
+	Field10785 *Message10749         `protobuf:"bytes,11,opt,name=field10785" json:"field10785,omitempty"`
+	Field10786 []*UnusedEmptyMessage `protobuf:"bytes,12,rep,name=field10786" json:"field10786,omitempty"`
+	Field10787 *bool                 `protobuf:"varint,13,opt,name=field10787" json:"field10787,omitempty"`
+	Field10788 *bool                 `protobuf:"varint,15,opt,name=field10788" json:"field10788,omitempty"`
+	Field10789 *bool                 `protobuf:"varint,16,opt,name=field10789" json:"field10789,omitempty"`
+	Field10790 *int32                `protobuf:"varint,17,opt,name=field10790" json:"field10790,omitempty"`
+	Field10791 *int32                `protobuf:"varint,18,opt,name=field10791" json:"field10791,omitempty"`
+	Field10792 *bool                 `protobuf:"varint,19,opt,name=field10792" json:"field10792,omitempty"`
+	Field10793 *bool                 `protobuf:"varint,20,opt,name=field10793" json:"field10793,omitempty"`
+	Field10794 *bool                 `protobuf:"varint,21,opt,name=field10794" json:"field10794,omitempty"`
+	Field10795 *UnusedEnum           `protobuf:"varint,14,opt,name=field10795,enum=benchmarks.google_message3.UnusedEnum" json:"field10795,omitempty"`
+	Field10796 *UnusedEnum           `protobuf:"varint,22,opt,name=field10796,enum=benchmarks.google_message3.UnusedEnum" json:"field10796,omitempty"`
+}
+
+func (x *Message10773) Reset() {
+	*x = Message10773{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[21]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message10773) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message10773) ProtoMessage() {}
+
+func (x *Message10773) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[21]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message10773.ProtoReflect.Descriptor instead.
+func (*Message10773) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{21}
+}
+
+func (x *Message10773) GetField10774() bool {
+	if x != nil && x.Field10774 != nil {
+		return *x.Field10774
+	}
+	return false
+}
+
+func (x *Message10773) GetField10775() bool {
+	if x != nil && x.Field10775 != nil {
+		return *x.Field10775
+	}
+	return false
+}
+
+func (x *Message10773) GetField10776() bool {
+	if x != nil && x.Field10776 != nil {
+		return *x.Field10776
+	}
+	return false
+}
+
+func (x *Message10773) GetField10777() bool {
+	if x != nil && x.Field10777 != nil {
+		return *x.Field10777
+	}
+	return false
+}
+
+func (x *Message10773) GetField10778() bool {
+	if x != nil && x.Field10778 != nil {
+		return *x.Field10778
+	}
+	return false
+}
+
+func (x *Message10773) GetField10779() int32 {
+	if x != nil && x.Field10779 != nil {
+		return *x.Field10779
+	}
+	return 0
+}
+
+func (x *Message10773) GetField10780() int32 {
+	if x != nil && x.Field10780 != nil {
+		return *x.Field10780
+	}
+	return 0
+}
+
+func (x *Message10773) GetField10781() int32 {
+	if x != nil && x.Field10781 != nil {
+		return *x.Field10781
+	}
+	return 0
+}
+
+func (x *Message10773) GetField10782() int32 {
+	if x != nil && x.Field10782 != nil {
+		return *x.Field10782
+	}
+	return 0
+}
+
+func (x *Message10773) GetField10783() int32 {
+	if x != nil && x.Field10783 != nil {
+		return *x.Field10783
+	}
+	return 0
+}
+
+func (x *Message10773) GetField10784() int32 {
+	if x != nil && x.Field10784 != nil {
+		return *x.Field10784
+	}
+	return 0
+}
+
+func (x *Message10773) GetField10785() *Message10749 {
+	if x != nil {
+		return x.Field10785
+	}
+	return nil
+}
+
+func (x *Message10773) GetField10786() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field10786
+	}
+	return nil
+}
+
+func (x *Message10773) GetField10787() bool {
+	if x != nil && x.Field10787 != nil {
+		return *x.Field10787
+	}
+	return false
+}
+
+func (x *Message10773) GetField10788() bool {
+	if x != nil && x.Field10788 != nil {
+		return *x.Field10788
+	}
+	return false
+}
+
+func (x *Message10773) GetField10789() bool {
+	if x != nil && x.Field10789 != nil {
+		return *x.Field10789
+	}
+	return false
+}
+
+func (x *Message10773) GetField10790() int32 {
+	if x != nil && x.Field10790 != nil {
+		return *x.Field10790
+	}
+	return 0
+}
+
+func (x *Message10773) GetField10791() int32 {
+	if x != nil && x.Field10791 != nil {
+		return *x.Field10791
+	}
+	return 0
+}
+
+func (x *Message10773) GetField10792() bool {
+	if x != nil && x.Field10792 != nil {
+		return *x.Field10792
+	}
+	return false
+}
+
+func (x *Message10773) GetField10793() bool {
+	if x != nil && x.Field10793 != nil {
+		return *x.Field10793
+	}
+	return false
+}
+
+func (x *Message10773) GetField10794() bool {
+	if x != nil && x.Field10794 != nil {
+		return *x.Field10794
+	}
+	return false
+}
+
+func (x *Message10773) GetField10795() UnusedEnum {
+	if x != nil && x.Field10795 != nil {
+		return *x.Field10795
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+func (x *Message10773) GetField10796() UnusedEnum {
+	if x != nil && x.Field10796 != nil {
+		return *x.Field10796
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+type Message13145 struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+
+	Field13155 *Enum13146 `protobuf:"varint,1,req,name=field13155,enum=benchmarks.google_message3.Enum13146" json:"field13155,omitempty"`
+	Field13156 *float32   `protobuf:"fixed32,2,opt,name=field13156" json:"field13156,omitempty"`
+	Field13157 *float32   `protobuf:"fixed32,3,opt,name=field13157" json:"field13157,omitempty"`
+}
+
+func (x *Message13145) Reset() {
+	*x = Message13145{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[22]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message13145) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message13145) ProtoMessage() {}
+
+func (x *Message13145) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[22]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message13145.ProtoReflect.Descriptor instead.
+func (*Message13145) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{22}
+}
+
+var extRange_Message13145 = []protoiface.ExtensionRangeV1{
+	{Start: 1000, End: 536870911},
+}
+
+// Deprecated: Use Message13145.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*Message13145) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_Message13145
+}
+
+func (x *Message13145) GetField13155() Enum13146 {
+	if x != nil && x.Field13155 != nil {
+		return *x.Field13155
+	}
+	return Enum13146_ENUM_VALUE13147
+}
+
+func (x *Message13145) GetField13156() float32 {
+	if x != nil && x.Field13156 != nil {
+		return *x.Field13156
+	}
+	return 0
+}
+
+func (x *Message13145) GetField13157() float32 {
+	if x != nil && x.Field13157 != nil {
+		return *x.Field13157
+	}
+	return 0
+}
+
+type Message16686 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message16686) Reset() {
+	*x = Message16686{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[23]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message16686) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message16686) ProtoMessage() {}
+
+func (x *Message16686) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[23]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message16686.ProtoReflect.Descriptor instead.
+func (*Message16686) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{23}
+}
+
+type Message12796 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12800 []uint64 `protobuf:"fixed64,1,rep,name=field12800" json:"field12800,omitempty"`
+	Field12801 *uint64  `protobuf:"varint,2,opt,name=field12801" json:"field12801,omitempty"`
+}
+
+func (x *Message12796) Reset() {
+	*x = Message12796{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[24]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12796) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12796) ProtoMessage() {}
+
+func (x *Message12796) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[24]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12796.ProtoReflect.Descriptor instead.
+func (*Message12796) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{24}
+}
+
+func (x *Message12796) GetField12800() []uint64 {
+	if x != nil {
+		return x.Field12800
+	}
+	return nil
+}
+
+func (x *Message12796) GetField12801() uint64 {
+	if x != nil && x.Field12801 != nil {
+		return *x.Field12801
+	}
+	return 0
+}
+
+type Message6722 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message6722) Reset() {
+	*x = Message6722{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[25]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6722) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6722) ProtoMessage() {}
+
+func (x *Message6722) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[25]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6722.ProtoReflect.Descriptor instead.
+func (*Message6722) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{25}
+}
+
+type Message6727 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message6727) Reset() {
+	*x = Message6727{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[26]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6727) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6727) ProtoMessage() {}
+
+func (x *Message6727) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[26]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6727.ProtoReflect.Descriptor instead.
+func (*Message6727) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{26}
+}
+
+type Message6724 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message6724) Reset() {
+	*x = Message6724{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[27]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6724) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6724) ProtoMessage() {}
+
+func (x *Message6724) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[27]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6724.ProtoReflect.Descriptor instead.
+func (*Message6724) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{27}
+}
+
+type Message6735 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message6735) Reset() {
+	*x = Message6735{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[28]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6735) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6735) ProtoMessage() {}
+
+func (x *Message6735) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[28]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6735.ProtoReflect.Descriptor instead.
+func (*Message6735) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{28}
+}
+
+type Message8183 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field8226 *string `protobuf:"bytes,1,opt,name=field8226" json:"field8226,omitempty"`
+	Field8227 *string `protobuf:"bytes,2,opt,name=field8227" json:"field8227,omitempty"`
+}
+
+func (x *Message8183) Reset() {
+	*x = Message8183{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[29]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8183) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8183) ProtoMessage() {}
+
+func (x *Message8183) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[29]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8183.ProtoReflect.Descriptor instead.
+func (*Message8183) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{29}
+}
+
+func (x *Message8183) GetField8226() string {
+	if x != nil && x.Field8226 != nil {
+		return *x.Field8226
+	}
+	return ""
+}
+
+func (x *Message8183) GetField8227() string {
+	if x != nil && x.Field8227 != nil {
+		return *x.Field8227
+	}
+	return ""
+}
+
+type Message8301 struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+
+	Field8328 *string             `protobuf:"bytes,1,opt,name=field8328" json:"field8328,omitempty"`
+	Field8329 *Message7966        `protobuf:"bytes,2,opt,name=field8329" json:"field8329,omitempty"`
+	Field8330 *string             `protobuf:"bytes,3,opt,name=field8330" json:"field8330,omitempty"`
+	Field8331 *string             `protobuf:"bytes,4,opt,name=field8331" json:"field8331,omitempty"`
+	Field8332 []*Message8290      `protobuf:"bytes,5,rep,name=field8332" json:"field8332,omitempty"`
+	Field8333 *Message7966        `protobuf:"bytes,6,opt,name=field8333" json:"field8333,omitempty"`
+	Field8334 []*Message8298      `protobuf:"bytes,7,rep,name=field8334" json:"field8334,omitempty"`
+	Field8335 *Message8300        `protobuf:"bytes,8,opt,name=field8335" json:"field8335,omitempty"`
+	Field8336 *int64              `protobuf:"varint,9,opt,name=field8336" json:"field8336,omitempty"`
+	Field8337 *UnusedEmptyMessage `protobuf:"bytes,10,opt,name=field8337" json:"field8337,omitempty"`
+	Field8338 *Message7965        `protobuf:"bytes,11,opt,name=field8338" json:"field8338,omitempty"`
+}
+
+func (x *Message8301) Reset() {
+	*x = Message8301{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[30]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8301) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8301) ProtoMessage() {}
+
+func (x *Message8301) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[30]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8301.ProtoReflect.Descriptor instead.
+func (*Message8301) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{30}
+}
+
+var extRange_Message8301 = []protoiface.ExtensionRangeV1{
+	{Start: 64, End: 536870911},
+}
+
+// Deprecated: Use Message8301.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*Message8301) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_Message8301
+}
+
+func (x *Message8301) GetField8328() string {
+	if x != nil && x.Field8328 != nil {
+		return *x.Field8328
+	}
+	return ""
+}
+
+func (x *Message8301) GetField8329() *Message7966 {
+	if x != nil {
+		return x.Field8329
+	}
+	return nil
+}
+
+func (x *Message8301) GetField8330() string {
+	if x != nil && x.Field8330 != nil {
+		return *x.Field8330
+	}
+	return ""
+}
+
+func (x *Message8301) GetField8331() string {
+	if x != nil && x.Field8331 != nil {
+		return *x.Field8331
+	}
+	return ""
+}
+
+func (x *Message8301) GetField8332() []*Message8290 {
+	if x != nil {
+		return x.Field8332
+	}
+	return nil
+}
+
+func (x *Message8301) GetField8333() *Message7966 {
+	if x != nil {
+		return x.Field8333
+	}
+	return nil
+}
+
+func (x *Message8301) GetField8334() []*Message8298 {
+	if x != nil {
+		return x.Field8334
+	}
+	return nil
+}
+
+func (x *Message8301) GetField8335() *Message8300 {
+	if x != nil {
+		return x.Field8335
+	}
+	return nil
+}
+
+func (x *Message8301) GetField8336() int64 {
+	if x != nil && x.Field8336 != nil {
+		return *x.Field8336
+	}
+	return 0
+}
+
+func (x *Message8301) GetField8337() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8337
+	}
+	return nil
+}
+
+func (x *Message8301) GetField8338() *Message7965 {
+	if x != nil {
+		return x.Field8338
+	}
+	return nil
+}
+
+type Message8456 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message8456) Reset() {
+	*x = Message8456{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[31]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8456) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8456) ProtoMessage() {}
+
+func (x *Message8456) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[31]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8456.ProtoReflect.Descriptor instead.
+func (*Message8456) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{31}
+}
+
+type Message8302 struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+
+	Field8339 *string               `protobuf:"bytes,1,opt,name=field8339" json:"field8339,omitempty"`
+	Field8340 *Message7966          `protobuf:"bytes,2,opt,name=field8340" json:"field8340,omitempty"`
+	Field8341 *string               `protobuf:"bytes,3,opt,name=field8341" json:"field8341,omitempty"`
+	Field8342 *string               `protobuf:"bytes,4,opt,name=field8342" json:"field8342,omitempty"`
+	Field8343 *string               `protobuf:"bytes,5,opt,name=field8343" json:"field8343,omitempty"`
+	Field8344 *string               `protobuf:"bytes,6,opt,name=field8344" json:"field8344,omitempty"`
+	Field8345 *string               `protobuf:"bytes,7,opt,name=field8345" json:"field8345,omitempty"`
+	Field8346 *int64                `protobuf:"varint,8,opt,name=field8346" json:"field8346,omitempty"`
+	Field8347 *int64                `protobuf:"varint,9,opt,name=field8347" json:"field8347,omitempty"`
+	Field8348 []*Message8290        `protobuf:"bytes,10,rep,name=field8348" json:"field8348,omitempty"`
+	Field8349 *string               `protobuf:"bytes,11,opt,name=field8349" json:"field8349,omitempty"`
+	Field8350 *UnusedEmptyMessage   `protobuf:"bytes,12,opt,name=field8350" json:"field8350,omitempty"`
+	Field8351 *Message8291          `protobuf:"bytes,13,opt,name=field8351" json:"field8351,omitempty"`
+	Field8352 *int64                `protobuf:"varint,14,opt,name=field8352" json:"field8352,omitempty"`
+	Field8353 *Message8296          `protobuf:"bytes,15,opt,name=field8353" json:"field8353,omitempty"`
+	Field8354 *string               `protobuf:"bytes,16,opt,name=field8354" json:"field8354,omitempty"`
+	Field8355 *UnusedEmptyMessage   `protobuf:"bytes,17,opt,name=field8355" json:"field8355,omitempty"`
+	Field8356 []int32               `protobuf:"varint,18,rep,name=field8356" json:"field8356,omitempty"`
+	Field8357 []int32               `protobuf:"varint,19,rep,name=field8357" json:"field8357,omitempty"`
+	Field8358 []*UnusedEmptyMessage `protobuf:"bytes,20,rep,name=field8358" json:"field8358,omitempty"`
+	Field8359 *Message7965          `protobuf:"bytes,21,opt,name=field8359" json:"field8359,omitempty"`
+}
+
+func (x *Message8302) Reset() {
+	*x = Message8302{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[32]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8302) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8302) ProtoMessage() {}
+
+func (x *Message8302) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[32]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8302.ProtoReflect.Descriptor instead.
+func (*Message8302) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{32}
+}
+
+var extRange_Message8302 = []protoiface.ExtensionRangeV1{
+	{Start: 64, End: 536870911},
+}
+
+// Deprecated: Use Message8302.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*Message8302) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_Message8302
+}
+
+func (x *Message8302) GetField8339() string {
+	if x != nil && x.Field8339 != nil {
+		return *x.Field8339
+	}
+	return ""
+}
+
+func (x *Message8302) GetField8340() *Message7966 {
+	if x != nil {
+		return x.Field8340
+	}
+	return nil
+}
+
+func (x *Message8302) GetField8341() string {
+	if x != nil && x.Field8341 != nil {
+		return *x.Field8341
+	}
+	return ""
+}
+
+func (x *Message8302) GetField8342() string {
+	if x != nil && x.Field8342 != nil {
+		return *x.Field8342
+	}
+	return ""
+}
+
+func (x *Message8302) GetField8343() string {
+	if x != nil && x.Field8343 != nil {
+		return *x.Field8343
+	}
+	return ""
+}
+
+func (x *Message8302) GetField8344() string {
+	if x != nil && x.Field8344 != nil {
+		return *x.Field8344
+	}
+	return ""
+}
+
+func (x *Message8302) GetField8345() string {
+	if x != nil && x.Field8345 != nil {
+		return *x.Field8345
+	}
+	return ""
+}
+
+func (x *Message8302) GetField8346() int64 {
+	if x != nil && x.Field8346 != nil {
+		return *x.Field8346
+	}
+	return 0
+}
+
+func (x *Message8302) GetField8347() int64 {
+	if x != nil && x.Field8347 != nil {
+		return *x.Field8347
+	}
+	return 0
+}
+
+func (x *Message8302) GetField8348() []*Message8290 {
+	if x != nil {
+		return x.Field8348
+	}
+	return nil
+}
+
+func (x *Message8302) GetField8349() string {
+	if x != nil && x.Field8349 != nil {
+		return *x.Field8349
+	}
+	return ""
+}
+
+func (x *Message8302) GetField8350() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8350
+	}
+	return nil
+}
+
+func (x *Message8302) GetField8351() *Message8291 {
+	if x != nil {
+		return x.Field8351
+	}
+	return nil
+}
+
+func (x *Message8302) GetField8352() int64 {
+	if x != nil && x.Field8352 != nil {
+		return *x.Field8352
+	}
+	return 0
+}
+
+func (x *Message8302) GetField8353() *Message8296 {
+	if x != nil {
+		return x.Field8353
+	}
+	return nil
+}
+
+func (x *Message8302) GetField8354() string {
+	if x != nil && x.Field8354 != nil {
+		return *x.Field8354
+	}
+	return ""
+}
+
+func (x *Message8302) GetField8355() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8355
+	}
+	return nil
+}
+
+func (x *Message8302) GetField8356() []int32 {
+	if x != nil {
+		return x.Field8356
+	}
+	return nil
+}
+
+func (x *Message8302) GetField8357() []int32 {
+	if x != nil {
+		return x.Field8357
+	}
+	return nil
+}
+
+func (x *Message8302) GetField8358() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8358
+	}
+	return nil
+}
+
+func (x *Message8302) GetField8359() *Message7965 {
+	if x != nil {
+		return x.Field8359
+	}
+	return nil
+}
+
+type Message8457 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message8457) Reset() {
+	*x = Message8457{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[33]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8457) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8457) ProtoMessage() {}
+
+func (x *Message8457) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[33]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8457.ProtoReflect.Descriptor instead.
+func (*Message8457) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{33}
+}
+
+type Message8449 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field8458 *string      `protobuf:"bytes,1,opt,name=field8458" json:"field8458,omitempty"`
+	Field8459 *bool        `protobuf:"varint,2,opt,name=field8459" json:"field8459,omitempty"`
+	Field8460 *Enum8450    `protobuf:"varint,3,opt,name=field8460,enum=benchmarks.google_message3.Enum8450" json:"field8460,omitempty"`
+	Field8461 []string     `protobuf:"bytes,4,rep,name=field8461" json:"field8461,omitempty"`
+	Field8462 *string      `protobuf:"bytes,5,opt,name=field8462" json:"field8462,omitempty"`
+	Field8463 *string      `protobuf:"bytes,6,opt,name=field8463" json:"field8463,omitempty"`
+	Field8464 *Message7966 `protobuf:"bytes,7,opt,name=field8464" json:"field8464,omitempty"`
+}
+
+func (x *Message8449) Reset() {
+	*x = Message8449{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[34]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8449) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8449) ProtoMessage() {}
+
+func (x *Message8449) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[34]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8449.ProtoReflect.Descriptor instead.
+func (*Message8449) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{34}
+}
+
+func (x *Message8449) GetField8458() string {
+	if x != nil && x.Field8458 != nil {
+		return *x.Field8458
+	}
+	return ""
+}
+
+func (x *Message8449) GetField8459() bool {
+	if x != nil && x.Field8459 != nil {
+		return *x.Field8459
+	}
+	return false
+}
+
+func (x *Message8449) GetField8460() Enum8450 {
+	if x != nil && x.Field8460 != nil {
+		return *x.Field8460
+	}
+	return Enum8450_ENUM_VALUE8451
+}
+
+func (x *Message8449) GetField8461() []string {
+	if x != nil {
+		return x.Field8461
+	}
+	return nil
+}
+
+func (x *Message8449) GetField8462() string {
+	if x != nil && x.Field8462 != nil {
+		return *x.Field8462
+	}
+	return ""
+}
+
+func (x *Message8449) GetField8463() string {
+	if x != nil && x.Field8463 != nil {
+		return *x.Field8463
+	}
+	return ""
+}
+
+func (x *Message8449) GetField8464() *Message7966 {
+	if x != nil {
+		return x.Field8464
+	}
+	return nil
+}
+
+type Message13358 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field13359 *uint64             `protobuf:"fixed64,1,req,name=field13359" json:"field13359,omitempty"`
+	Field13360 *uint64             `protobuf:"fixed64,2,req,name=field13360" json:"field13360,omitempty"`
+	Field13361 *UnusedEmptyMessage `protobuf:"bytes,3,opt,name=field13361" json:"field13361,omitempty"`
+}
+
+func (x *Message13358) Reset() {
+	*x = Message13358{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[35]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message13358) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message13358) ProtoMessage() {}
+
+func (x *Message13358) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[35]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message13358.ProtoReflect.Descriptor instead.
+func (*Message13358) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{35}
+}
+
+func (x *Message13358) GetField13359() uint64 {
+	if x != nil && x.Field13359 != nil {
+		return *x.Field13359
+	}
+	return 0
+}
+
+func (x *Message13358) GetField13360() uint64 {
+	if x != nil && x.Field13360 != nil {
+		return *x.Field13360
+	}
+	return 0
+}
+
+func (x *Message13358) GetField13361() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field13361
+	}
+	return nil
+}
+
+type Message13912 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field13913 *uint32             `protobuf:"fixed32,1,req,name=field13913" json:"field13913,omitempty"`
+	Field13914 *uint32             `protobuf:"fixed32,2,req,name=field13914" json:"field13914,omitempty"`
+	Field13915 *UnusedEmptyMessage `protobuf:"bytes,500,opt,name=field13915" json:"field13915,omitempty"`
+	Field13916 *UnusedEmptyMessage `protobuf:"bytes,15,opt,name=field13916" json:"field13916,omitempty"`
+}
+
+func (x *Message13912) Reset() {
+	*x = Message13912{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[36]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message13912) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message13912) ProtoMessage() {}
+
+func (x *Message13912) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[36]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message13912.ProtoReflect.Descriptor instead.
+func (*Message13912) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{36}
+}
+
+func (x *Message13912) GetField13913() uint32 {
+	if x != nil && x.Field13913 != nil {
+		return *x.Field13913
+	}
+	return 0
+}
+
+func (x *Message13912) GetField13914() uint32 {
+	if x != nil && x.Field13914 != nil {
+		return *x.Field13914
+	}
+	return 0
+}
+
+func (x *Message13912) GetField13915() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field13915
+	}
+	return nil
+}
+
+func (x *Message13912) GetField13916() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field13916
+	}
+	return nil
+}
+
+type Message24316 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field24443 []string `protobuf:"bytes,1,rep,name=field24443" json:"field24443,omitempty"`
+	Field24444 []string `protobuf:"bytes,2,rep,name=field24444" json:"field24444,omitempty"`
+	Field24445 []string `protobuf:"bytes,3,rep,name=field24445" json:"field24445,omitempty"`
+}
+
+func (x *Message24316) Reset() {
+	*x = Message24316{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[37]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message24316) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message24316) ProtoMessage() {}
+
+func (x *Message24316) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[37]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message24316.ProtoReflect.Descriptor instead.
+func (*Message24316) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{37}
+}
+
+func (x *Message24316) GetField24443() []string {
+	if x != nil {
+		return x.Field24443
+	}
+	return nil
+}
+
+func (x *Message24316) GetField24444() []string {
+	if x != nil {
+		return x.Field24444
+	}
+	return nil
+}
+
+func (x *Message24316) GetField24445() []string {
+	if x != nil {
+		return x.Field24445
+	}
+	return nil
+}
+
+type Message24312 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field24421 *string  `protobuf:"bytes,1,opt,name=field24421" json:"field24421,omitempty"`
+	Field24422 *string  `protobuf:"bytes,2,opt,name=field24422" json:"field24422,omitempty"`
+	Field24423 []string `protobuf:"bytes,3,rep,name=field24423" json:"field24423,omitempty"`
+	Field24424 []string `protobuf:"bytes,4,rep,name=field24424" json:"field24424,omitempty"`
+	Field24425 []string `protobuf:"bytes,5,rep,name=field24425" json:"field24425,omitempty"`
+	Field24426 []string `protobuf:"bytes,6,rep,name=field24426" json:"field24426,omitempty"`
+}
+
+func (x *Message24312) Reset() {
+	*x = Message24312{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[38]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message24312) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message24312) ProtoMessage() {}
+
+func (x *Message24312) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[38]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message24312.ProtoReflect.Descriptor instead.
+func (*Message24312) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{38}
+}
+
+func (x *Message24312) GetField24421() string {
+	if x != nil && x.Field24421 != nil {
+		return *x.Field24421
+	}
+	return ""
+}
+
+func (x *Message24312) GetField24422() string {
+	if x != nil && x.Field24422 != nil {
+		return *x.Field24422
+	}
+	return ""
+}
+
+func (x *Message24312) GetField24423() []string {
+	if x != nil {
+		return x.Field24423
+	}
+	return nil
+}
+
+func (x *Message24312) GetField24424() []string {
+	if x != nil {
+		return x.Field24424
+	}
+	return nil
+}
+
+func (x *Message24312) GetField24425() []string {
+	if x != nil {
+		return x.Field24425
+	}
+	return nil
+}
+
+func (x *Message24312) GetField24426() []string {
+	if x != nil {
+		return x.Field24426
+	}
+	return nil
+}
+
+type Message24313 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field24427 *string  `protobuf:"bytes,1,opt,name=field24427" json:"field24427,omitempty"`
+	Field24428 *string  `protobuf:"bytes,2,opt,name=field24428" json:"field24428,omitempty"`
+	Field24429 []string `protobuf:"bytes,3,rep,name=field24429" json:"field24429,omitempty"`
+	Field24430 *string  `protobuf:"bytes,4,opt,name=field24430" json:"field24430,omitempty"`
+	Field24431 *string  `protobuf:"bytes,5,opt,name=field24431" json:"field24431,omitempty"`
+	Field24432 *string  `protobuf:"bytes,6,opt,name=field24432" json:"field24432,omitempty"`
+	Field24433 *string  `protobuf:"bytes,7,opt,name=field24433" json:"field24433,omitempty"`
+	Field24434 []string `protobuf:"bytes,8,rep,name=field24434" json:"field24434,omitempty"`
+	Field24435 *string  `protobuf:"bytes,9,opt,name=field24435" json:"field24435,omitempty"`
+	Field24436 []string `protobuf:"bytes,10,rep,name=field24436" json:"field24436,omitempty"`
+}
+
+func (x *Message24313) Reset() {
+	*x = Message24313{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[39]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message24313) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message24313) ProtoMessage() {}
+
+func (x *Message24313) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[39]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message24313.ProtoReflect.Descriptor instead.
+func (*Message24313) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{39}
+}
+
+func (x *Message24313) GetField24427() string {
+	if x != nil && x.Field24427 != nil {
+		return *x.Field24427
+	}
+	return ""
+}
+
+func (x *Message24313) GetField24428() string {
+	if x != nil && x.Field24428 != nil {
+		return *x.Field24428
+	}
+	return ""
+}
+
+func (x *Message24313) GetField24429() []string {
+	if x != nil {
+		return x.Field24429
+	}
+	return nil
+}
+
+func (x *Message24313) GetField24430() string {
+	if x != nil && x.Field24430 != nil {
+		return *x.Field24430
+	}
+	return ""
+}
+
+func (x *Message24313) GetField24431() string {
+	if x != nil && x.Field24431 != nil {
+		return *x.Field24431
+	}
+	return ""
+}
+
+func (x *Message24313) GetField24432() string {
+	if x != nil && x.Field24432 != nil {
+		return *x.Field24432
+	}
+	return ""
+}
+
+func (x *Message24313) GetField24433() string {
+	if x != nil && x.Field24433 != nil {
+		return *x.Field24433
+	}
+	return ""
+}
+
+func (x *Message24313) GetField24434() []string {
+	if x != nil {
+		return x.Field24434
+	}
+	return nil
+}
+
+func (x *Message24313) GetField24435() string {
+	if x != nil && x.Field24435 != nil {
+		return *x.Field24435
+	}
+	return ""
+}
+
+func (x *Message24313) GetField24436() []string {
+	if x != nil {
+		return x.Field24436
+	}
+	return nil
+}
+
+type Message24315 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field24440 *string  `protobuf:"bytes,1,req,name=field24440" json:"field24440,omitempty"`
+	Field24441 []string `protobuf:"bytes,2,rep,name=field24441" json:"field24441,omitempty"`
+	Field24442 []string `protobuf:"bytes,3,rep,name=field24442" json:"field24442,omitempty"`
+}
+
+func (x *Message24315) Reset() {
+	*x = Message24315{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[40]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message24315) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message24315) ProtoMessage() {}
+
+func (x *Message24315) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[40]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message24315.ProtoReflect.Descriptor instead.
+func (*Message24315) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{40}
+}
+
+func (x *Message24315) GetField24440() string {
+	if x != nil && x.Field24440 != nil {
+		return *x.Field24440
+	}
+	return ""
+}
+
+func (x *Message24315) GetField24441() []string {
+	if x != nil {
+		return x.Field24441
+	}
+	return nil
+}
+
+func (x *Message24315) GetField24442() []string {
+	if x != nil {
+		return x.Field24442
+	}
+	return nil
+}
+
+type Message716 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field872 *string     `protobuf:"bytes,1,req,name=field872" json:"field872,omitempty"`
+	Field873 *int32      `protobuf:"varint,2,req,name=field873" json:"field873,omitempty"`
+	Field874 *bool       `protobuf:"varint,3,opt,name=field874" json:"field874,omitempty"`
+	Field875 *Message717 `protobuf:"bytes,4,opt,name=field875" json:"field875,omitempty"`
+}
+
+func (x *Message716) Reset() {
+	*x = Message716{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[41]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message716) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message716) ProtoMessage() {}
+
+func (x *Message716) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[41]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message716.ProtoReflect.Descriptor instead.
+func (*Message716) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{41}
+}
+
+func (x *Message716) GetField872() string {
+	if x != nil && x.Field872 != nil {
+		return *x.Field872
+	}
+	return ""
+}
+
+func (x *Message716) GetField873() int32 {
+	if x != nil && x.Field873 != nil {
+		return *x.Field873
+	}
+	return 0
+}
+
+func (x *Message716) GetField874() bool {
+	if x != nil && x.Field874 != nil {
+		return *x.Field874
+	}
+	return false
+}
+
+func (x *Message716) GetField875() *Message717 {
+	if x != nil {
+		return x.Field875
+	}
+	return nil
+}
+
+type Message718 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field878 []string `protobuf:"bytes,1,rep,name=field878" json:"field878,omitempty"`
+	Field879 []string `protobuf:"bytes,2,rep,name=field879" json:"field879,omitempty"`
+	Field880 *string  `protobuf:"bytes,3,opt,name=field880" json:"field880,omitempty"`
+}
+
+func (x *Message718) Reset() {
+	*x = Message718{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[42]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message718) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message718) ProtoMessage() {}
+
+func (x *Message718) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[42]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message718.ProtoReflect.Descriptor instead.
+func (*Message718) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{42}
+}
+
+func (x *Message718) GetField878() []string {
+	if x != nil {
+		return x.Field878
+	}
+	return nil
+}
+
+func (x *Message718) GetField879() []string {
+	if x != nil {
+		return x.Field879
+	}
+	return nil
+}
+
+func (x *Message718) GetField880() string {
+	if x != nil && x.Field880 != nil {
+		return *x.Field880
+	}
+	return ""
+}
+
+type Message703 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field795 *string  `protobuf:"bytes,1,req,name=field795" json:"field795,omitempty"`
+	Field796 []string `protobuf:"bytes,2,rep,name=field796" json:"field796,omitempty"`
+	Field797 []string `protobuf:"bytes,3,rep,name=field797" json:"field797,omitempty"`
+	Field798 *string  `protobuf:"bytes,4,opt,name=field798" json:"field798,omitempty"`
+	Field799 []string `protobuf:"bytes,5,rep,name=field799" json:"field799,omitempty"`
+}
+
+func (x *Message703) Reset() {
+	*x = Message703{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[43]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message703) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message703) ProtoMessage() {}
+
+func (x *Message703) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[43]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message703.ProtoReflect.Descriptor instead.
+func (*Message703) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{43}
+}
+
+func (x *Message703) GetField795() string {
+	if x != nil && x.Field795 != nil {
+		return *x.Field795
+	}
+	return ""
+}
+
+func (x *Message703) GetField796() []string {
+	if x != nil {
+		return x.Field796
+	}
+	return nil
+}
+
+func (x *Message703) GetField797() []string {
+	if x != nil {
+		return x.Field797
+	}
+	return nil
+}
+
+func (x *Message703) GetField798() string {
+	if x != nil && x.Field798 != nil {
+		return *x.Field798
+	}
+	return ""
+}
+
+func (x *Message703) GetField799() []string {
+	if x != nil {
+		return x.Field799
+	}
+	return nil
+}
+
+type Message715 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field859 *string       `protobuf:"bytes,1,req,name=field859" json:"field859,omitempty"`
+	Field860 *string       `protobuf:"bytes,7,opt,name=field860" json:"field860,omitempty"`
+	Field861 []*Message707 `protobuf:"bytes,2,rep,name=field861" json:"field861,omitempty"`
+	Field862 []*Message708 `protobuf:"bytes,3,rep,name=field862" json:"field862,omitempty"`
+	Field863 []*Message711 `protobuf:"bytes,4,rep,name=field863" json:"field863,omitempty"`
+	Field864 []*Message712 `protobuf:"bytes,5,rep,name=field864" json:"field864,omitempty"`
+	Field865 []*Message713 `protobuf:"bytes,6,rep,name=field865" json:"field865,omitempty"`
+	Field866 []*Message714 `protobuf:"bytes,8,rep,name=field866" json:"field866,omitempty"`
+	Field867 []*Message710 `protobuf:"bytes,9,rep,name=field867" json:"field867,omitempty"`
+	Field868 []*Message709 `protobuf:"bytes,10,rep,name=field868" json:"field868,omitempty"`
+	Field869 []*Message705 `protobuf:"bytes,11,rep,name=field869" json:"field869,omitempty"`
+	Field870 []*Message702 `protobuf:"bytes,12,rep,name=field870" json:"field870,omitempty"`
+	Field871 []*Message706 `protobuf:"bytes,13,rep,name=field871" json:"field871,omitempty"`
+}
+
+func (x *Message715) Reset() {
+	*x = Message715{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[44]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message715) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message715) ProtoMessage() {}
+
+func (x *Message715) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[44]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message715.ProtoReflect.Descriptor instead.
+func (*Message715) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{44}
+}
+
+func (x *Message715) GetField859() string {
+	if x != nil && x.Field859 != nil {
+		return *x.Field859
+	}
+	return ""
+}
+
+func (x *Message715) GetField860() string {
+	if x != nil && x.Field860 != nil {
+		return *x.Field860
+	}
+	return ""
+}
+
+func (x *Message715) GetField861() []*Message707 {
+	if x != nil {
+		return x.Field861
+	}
+	return nil
+}
+
+func (x *Message715) GetField862() []*Message708 {
+	if x != nil {
+		return x.Field862
+	}
+	return nil
+}
+
+func (x *Message715) GetField863() []*Message711 {
+	if x != nil {
+		return x.Field863
+	}
+	return nil
+}
+
+func (x *Message715) GetField864() []*Message712 {
+	if x != nil {
+		return x.Field864
+	}
+	return nil
+}
+
+func (x *Message715) GetField865() []*Message713 {
+	if x != nil {
+		return x.Field865
+	}
+	return nil
+}
+
+func (x *Message715) GetField866() []*Message714 {
+	if x != nil {
+		return x.Field866
+	}
+	return nil
+}
+
+func (x *Message715) GetField867() []*Message710 {
+	if x != nil {
+		return x.Field867
+	}
+	return nil
+}
+
+func (x *Message715) GetField868() []*Message709 {
+	if x != nil {
+		return x.Field868
+	}
+	return nil
+}
+
+func (x *Message715) GetField869() []*Message705 {
+	if x != nil {
+		return x.Field869
+	}
+	return nil
+}
+
+func (x *Message715) GetField870() []*Message702 {
+	if x != nil {
+		return x.Field870
+	}
+	return nil
+}
+
+func (x *Message715) GetField871() []*Message706 {
+	if x != nil {
+		return x.Field871
+	}
+	return nil
+}
+
+type Message700 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field789 []string `protobuf:"bytes,1,rep,name=field789" json:"field789,omitempty"`
+	Field790 []string `protobuf:"bytes,2,rep,name=field790" json:"field790,omitempty"`
+}
+
+func (x *Message700) Reset() {
+	*x = Message700{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[45]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message700) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message700) ProtoMessage() {}
+
+func (x *Message700) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[45]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message700.ProtoReflect.Descriptor instead.
+func (*Message700) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{45}
+}
+
+func (x *Message700) GetField789() []string {
+	if x != nil {
+		return x.Field789
+	}
+	return nil
+}
+
+func (x *Message700) GetField790() []string {
+	if x != nil {
+		return x.Field790
+	}
+	return nil
+}
+
+type Message699 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field787 *string  `protobuf:"bytes,1,req,name=field787" json:"field787,omitempty"`
+	Field788 []string `protobuf:"bytes,2,rep,name=field788" json:"field788,omitempty"`
+}
+
+func (x *Message699) Reset() {
+	*x = Message699{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[46]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message699) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message699) ProtoMessage() {}
+
+func (x *Message699) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[46]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message699.ProtoReflect.Descriptor instead.
+func (*Message699) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{46}
+}
+
+func (x *Message699) GetField787() string {
+	if x != nil && x.Field787 != nil {
+		return *x.Field787
+	}
+	return ""
+}
+
+func (x *Message699) GetField788() []string {
+	if x != nil {
+		return x.Field788
+	}
+	return nil
+}
+
+type Message698 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field779 *string  `protobuf:"bytes,1,opt,name=field779" json:"field779,omitempty"`
+	Field780 *string  `protobuf:"bytes,2,opt,name=field780" json:"field780,omitempty"`
+	Field781 *string  `protobuf:"bytes,3,opt,name=field781" json:"field781,omitempty"`
+	Field782 *string  `protobuf:"bytes,4,opt,name=field782" json:"field782,omitempty"`
+	Field783 *uint64  `protobuf:"varint,5,opt,name=field783" json:"field783,omitempty"`
+	Field784 *uint32  `protobuf:"varint,6,opt,name=field784" json:"field784,omitempty"`
+	Field785 *int64   `protobuf:"varint,7,opt,name=field785" json:"field785,omitempty"`
+	Field786 []string `protobuf:"bytes,8,rep,name=field786" json:"field786,omitempty"`
+}
+
+func (x *Message698) Reset() {
+	*x = Message698{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[47]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message698) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message698) ProtoMessage() {}
+
+func (x *Message698) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[47]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message698.ProtoReflect.Descriptor instead.
+func (*Message698) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{47}
+}
+
+func (x *Message698) GetField779() string {
+	if x != nil && x.Field779 != nil {
+		return *x.Field779
+	}
+	return ""
+}
+
+func (x *Message698) GetField780() string {
+	if x != nil && x.Field780 != nil {
+		return *x.Field780
+	}
+	return ""
+}
+
+func (x *Message698) GetField781() string {
+	if x != nil && x.Field781 != nil {
+		return *x.Field781
+	}
+	return ""
+}
+
+func (x *Message698) GetField782() string {
+	if x != nil && x.Field782 != nil {
+		return *x.Field782
+	}
+	return ""
+}
+
+func (x *Message698) GetField783() uint64 {
+	if x != nil && x.Field783 != nil {
+		return *x.Field783
+	}
+	return 0
+}
+
+func (x *Message698) GetField784() uint32 {
+	if x != nil && x.Field784 != nil {
+		return *x.Field784
+	}
+	return 0
+}
+
+func (x *Message698) GetField785() int64 {
+	if x != nil && x.Field785 != nil {
+		return *x.Field785
+	}
+	return 0
+}
+
+func (x *Message698) GetField786() []string {
+	if x != nil {
+		return x.Field786
+	}
+	return nil
+}
+
+type Message10155_Message10156 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field10266 *Enum8862 `protobuf:"varint,51,opt,name=field10266,enum=benchmarks.google_message3.Enum8862" json:"field10266,omitempty"`
+	Field10267 *int32    `protobuf:"varint,52,opt,name=field10267" json:"field10267,omitempty"`
+	Field10268 *int32    `protobuf:"varint,53,opt,name=field10268" json:"field10268,omitempty"`
+	Field10269 *int32    `protobuf:"varint,54,opt,name=field10269" json:"field10269,omitempty"`
+}
+
+func (x *Message10155_Message10156) Reset() {
+	*x = Message10155_Message10156{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[48]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message10155_Message10156) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message10155_Message10156) ProtoMessage() {}
+
+func (x *Message10155_Message10156) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[48]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message10155_Message10156.ProtoReflect.Descriptor instead.
+func (*Message10155_Message10156) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP(), []int{17, 0}
+}
+
+func (x *Message10155_Message10156) GetField10266() Enum8862 {
+	if x != nil && x.Field10266 != nil {
+		return *x.Field10266
+	}
+	return Enum8862_ENUM_VALUE8863
+}
+
+func (x *Message10155_Message10156) GetField10267() int32 {
+	if x != nil && x.Field10267 != nil {
+		return *x.Field10267
+	}
+	return 0
+}
+
+func (x *Message10155_Message10156) GetField10268() int32 {
+	if x != nil && x.Field10268 != nil {
+		return *x.Field10268
+	}
+	return 0
+}
+
+func (x *Message10155_Message10156) GetField10269() int32 {
+	if x != nil && x.Field10269 != nil {
+		return *x.Field10269
+	}
+	return 0
+}
+
+var File_datasets_google_message3_benchmark_message3_5_proto protoreflect.FileDescriptor
+
+var file_datasets_google_message3_benchmark_message3_5_proto_rawDesc = []byte{
+	0x0a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x5f, 0x35, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1a, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x1a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2f, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x5f, 0x36,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73,
+	0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x5f, 0x37, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x33, 0x64, 0x61, 0x74,
+	0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x5f, 0x38, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x22, 0x0e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x33, 0x37, 0x37,
+	0x22, 0x0e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x33, 0x37, 0x38,
+	0x22, 0xae, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x34, 0x30,
+	0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x37, 0x34, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x37,
+	0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x37, 0x35, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x37,
+	0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x37, 0x36, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x37,
+	0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x37, 0x37, 0x18,
+	0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x37,
+	0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x37, 0x38, 0x18,
+	0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x36, 0x37,
+	0x38, 0x22, 0x0e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x33, 0x38,
+	0x30, 0x22, 0x0e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x33, 0x38,
+	0x31, 0x22, 0xa1, 0x01, 0x0a, 0x0a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x31, 0x39,
+	0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x31, 0x18, 0x01, 0x20, 0x03,
+	0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x31, 0x12, 0x1a, 0x0a, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x32, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x32, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x38, 0x33, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x38, 0x33, 0x12, 0x3f, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x34,
+	0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x23, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x37, 0x32, 0x30, 0x52, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x38, 0x34, 0x22, 0xba, 0x03, 0x0a, 0x0a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x37, 0x32, 0x38, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x37,
+	0x18, 0x01, 0x20, 0x02, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x37,
+	0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x38, 0x18, 0x02, 0x20, 0x03,
+	0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x38, 0x12, 0x42, 0x0a, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x39, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x37, 0x30, 0x33, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x39,
+	0x12, 0x42, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x39, 0x30, 0x18, 0x04, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x31, 0x35, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x39, 0x30, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x39, 0x31,
+	0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x39, 0x31,
+	0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x39, 0x32, 0x18, 0x06, 0x20, 0x03,
+	0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x39, 0x32, 0x12, 0x42, 0x0a, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x39, 0x33, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x37, 0x31, 0x38, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x39, 0x33,
+	0x12, 0x42, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x39, 0x34, 0x18, 0x08, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x31, 0x36, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x39, 0x34, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x39, 0x35,
+	0x18, 0x09, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x39, 0x35,
+	0x2a, 0x04, 0x08, 0x0a, 0x10, 0x0b, 0x2a, 0x04, 0x08, 0x0b, 0x10, 0x0c, 0x2a, 0x04, 0x08, 0x0c,
+	0x10, 0x0d, 0x22, 0x80, 0x02, 0x0a, 0x0a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x30,
+	0x34, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x30, 0x30, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x30, 0x30, 0x12, 0x1a, 0x0a,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x30, 0x31, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x30, 0x31, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x30, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x30, 0x32, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x30,
+	0x33, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x30,
+	0x33, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x30, 0x34, 0x18, 0x04, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x30, 0x34, 0x12, 0x1a, 0x0a,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x30, 0x35, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x30, 0x35, 0x12, 0x4a, 0x0a, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x30, 0x36, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45,
+	0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x30, 0x36, 0x22, 0x80, 0x09, 0x0a, 0x0a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x36, 0x39, 0x37, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x34, 0x33,
+	0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x34, 0x33,
+	0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x34, 0x34, 0x18, 0x01, 0x20, 0x03,
+	0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x34, 0x34, 0x12, 0x1a, 0x0a, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x34, 0x35, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x34, 0x35, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x34, 0x36, 0x18, 0x21, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x34, 0x36, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x34, 0x37,
+	0x18, 0x1d, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x34, 0x37,
+	0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x34, 0x38, 0x18, 0x1e, 0x20, 0x03,
+	0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x34, 0x38, 0x12, 0x1a, 0x0a, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x34, 0x39, 0x18, 0x1f, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x34, 0x39, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x35, 0x30, 0x18, 0x20, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x35, 0x30, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x35, 0x31,
+	0x18, 0x0d, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x35, 0x31,
+	0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x35, 0x32, 0x18, 0x06, 0x20, 0x03,
+	0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x35, 0x32, 0x12, 0x1a, 0x0a, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x35, 0x33, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x35, 0x33, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x35, 0x34, 0x18, 0x0e, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x35, 0x34, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x35, 0x35,
+	0x18, 0x0f, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x35, 0x35,
+	0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x35, 0x36, 0x18, 0x10, 0x20, 0x03,
+	0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x35, 0x36, 0x12, 0x1a, 0x0a, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x35, 0x37, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x35, 0x37, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x35, 0x38, 0x18, 0x22, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x35, 0x38, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x35, 0x39,
+	0x18, 0x23, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x35, 0x39,
+	0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x30, 0x18, 0x05, 0x20, 0x03,
+	0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x30, 0x12, 0x1a, 0x0a, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x31, 0x18, 0x11, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x31, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x36, 0x32, 0x18, 0x12, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x36, 0x32, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x33,
+	0x18, 0x13, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x33,
+	0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x34, 0x18, 0x24, 0x20, 0x01,
+	0x28, 0x08, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x34, 0x12, 0x1a, 0x0a, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x35, 0x18, 0x08, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x35, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x36, 0x36, 0x18, 0x09, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x36, 0x36, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x37,
+	0x18, 0x1b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x37,
+	0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x38, 0x18, 0x19, 0x20, 0x01,
+	0x28, 0x08, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x38, 0x12, 0x42, 0x0a, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x39, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x37, 0x30, 0x30, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x36, 0x39,
+	0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x30, 0x18, 0x0b, 0x20, 0x01,
+	0x28, 0x08, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x30, 0x12, 0x1a, 0x0a, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x31, 0x18, 0x18, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x31, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x37, 0x32, 0x18, 0x0c, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x37, 0x32, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x33,
+	0x18, 0x14, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x33,
+	0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x34, 0x18, 0x15, 0x20, 0x03,
+	0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x34, 0x12, 0x1a, 0x0a, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x35, 0x18, 0x16, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x35, 0x12, 0x42, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x37, 0x36, 0x18, 0x17, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36,
+	0x39, 0x39, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x36, 0x12, 0x42, 0x0a, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x37, 0x18, 0x25, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x36, 0x39, 0x38, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x37,
+	0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x38, 0x18, 0x26, 0x20, 0x01,
+	0x28, 0x03, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x38, 0x2a, 0x04, 0x08, 0x1c,
+	0x10, 0x1d, 0x2a, 0x04, 0x08, 0x1a, 0x10, 0x1b, 0x22, 0x18, 0x0a, 0x08, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x30, 0x2a, 0x08, 0x08, 0x04, 0x10, 0xff, 0xff, 0xff, 0xff, 0x07, 0x3a, 0x02,
+	0x08, 0x01, 0x22, 0x95, 0x01, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x35,
+	0x37, 0x38, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x33, 0x32, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x36, 0x35, 0x37, 0x39, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x36, 0x36, 0x33, 0x32, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36,
+	0x36, 0x33, 0x33, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x36, 0x35, 0x38, 0x38, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x33, 0x33, 0x22, 0xbd, 0x01, 0x0a, 0x0b, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x30, 0x32, 0x34, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x36, 0x30, 0x34, 0x38, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x36,
+	0x30, 0x32, 0x35, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x34, 0x38, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x34, 0x39, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x34, 0x39, 0x12, 0x4c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x35, 0x30, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x35, 0x30, 0x22, 0x49, 0x0a, 0x0b, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x30, 0x35, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x36, 0x30, 0x38, 0x34, 0x18, 0x01, 0x20, 0x02, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x36, 0x30, 0x38, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x36, 0x30, 0x38, 0x35, 0x18, 0x02, 0x20, 0x02, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x36, 0x30, 0x38, 0x35, 0x22, 0x49, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x36, 0x30, 0x35, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x38,
+	0x39, 0x18, 0x01, 0x20, 0x02, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30,
+	0x38, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x39, 0x30, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x39, 0x30,
+	0x22, 0x83, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x35, 0x37,
+	0x33, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x35, 0x38, 0x30, 0x18,
+	0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x35, 0x37, 0x36, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x35, 0x38, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x35, 0x38, 0x31, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x35, 0x38, 0x31, 0x2a, 0x09, 0x08, 0x90, 0x4e,
+	0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x22, 0x4e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x31, 0x30, 0x38, 0x32, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x30, 0x38, 0x32, 0x35, 0x18, 0x01, 0x20, 0x02, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x30, 0x38, 0x32, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x30, 0x38, 0x32, 0x36, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x30, 0x38, 0x32, 0x36, 0x22, 0xce, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x31, 0x30, 0x35, 0x38, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x30, 0x35, 0x38, 0x33, 0x18, 0x01, 0x20, 0x02, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x30, 0x35, 0x38, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x30, 0x35, 0x38, 0x34, 0x18, 0x02, 0x20, 0x02, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x30, 0x35, 0x38, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x30, 0x35, 0x38, 0x35, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x30, 0x35, 0x38, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x30, 0x35, 0x38, 0x36, 0x18, 0x04, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x30, 0x35, 0x38, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x30, 0x35, 0x38, 0x37, 0x18, 0x05, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x30, 0x35, 0x38, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x30, 0x35, 0x38, 0x38, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x30, 0x35, 0x38, 0x38, 0x22, 0xa5, 0x18, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x31, 0x30, 0x31, 0x35, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x30, 0x31, 0x39, 0x35, 0x18, 0x01, 0x20, 0x02, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x30, 0x31, 0x39, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x30, 0x31, 0x39, 0x36, 0x18, 0x02, 0x20, 0x02, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x30, 0x31, 0x39, 0x36, 0x12, 0x45, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x30, 0x31, 0x39, 0x37, 0x18, 0x3b, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x30,
+	0x31, 0x35, 0x37, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x31, 0x39, 0x37, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x31, 0x39, 0x38, 0x18, 0x12, 0x20,
+	0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x31, 0x39, 0x38, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x31, 0x39, 0x39, 0x18, 0x13, 0x20,
+	0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x31, 0x39, 0x39, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x30, 0x30, 0x18, 0x15, 0x20,
+	0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x30, 0x30, 0x12,
+	0x59, 0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x31, 0x35, 0x36, 0x18,
+	0x32, 0x20, 0x03, 0x28, 0x0a, 0x32, 0x35, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x31, 0x35, 0x35, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x31, 0x35, 0x36, 0x52, 0x0c, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x31, 0x35, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x30, 0x32, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x30, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x30, 0x33, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x30, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x30, 0x34, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x30, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x30, 0x35, 0x18, 0x54, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x30, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x30, 0x36, 0x18, 0x21, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x30, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x30, 0x37, 0x18, 0x4b, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x30, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x30, 0x38, 0x18, 0x1a, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x30, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x30, 0x39, 0x18, 0x1b, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x30, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x31, 0x30, 0x18, 0x31, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x31, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x31, 0x31, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x31, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x31, 0x32, 0x18, 0x4e, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x31, 0x32, 0x12, 0x47, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x31, 0x33, 0x18, 0x5b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x39, 0x31, 0x35, 0x31, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30,
+	0x32, 0x31, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x31,
+	0x34, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30,
+	0x32, 0x31, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x31,
+	0x35, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30,
+	0x32, 0x31, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x31,
+	0x36, 0x18, 0x29, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30,
+	0x32, 0x31, 0x36, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x31,
+	0x37, 0x18, 0x3d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x31, 0x35,
+	0x34, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x31, 0x37, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x31, 0x38, 0x18, 0x17, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x31, 0x38, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x31, 0x39, 0x18, 0x18, 0x20, 0x01, 0x28,
+	0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x31, 0x39, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x32, 0x30, 0x18, 0x41, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x32, 0x30, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x32, 0x31, 0x18, 0x42, 0x20, 0x03, 0x28,
+	0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x32, 0x31, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x32, 0x32, 0x18, 0x46, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x32, 0x32, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x32, 0x33, 0x18, 0x47, 0x20, 0x01, 0x28,
+	0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x32, 0x33, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x32, 0x34, 0x18, 0x49, 0x20, 0x03, 0x28,
+	0x06, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x32, 0x34, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x32, 0x35, 0x18, 0x1d, 0x20, 0x01, 0x28,
+	0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x32, 0x35, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x32, 0x36, 0x18, 0x1e, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x32, 0x36, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x32, 0x37, 0x18, 0x1f, 0x20, 0x01, 0x28,
+	0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x32, 0x37, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x32, 0x38, 0x18, 0x20, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x32, 0x38, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x32, 0x39, 0x18, 0x22, 0x20, 0x01, 0x28,
+	0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x32, 0x39, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x33, 0x30, 0x18, 0x23, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x33, 0x30, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x33, 0x31, 0x18, 0x16, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x33, 0x31, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x33, 0x32, 0x18, 0x0d, 0x20, 0x01, 0x28,
+	0x06, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x33, 0x32, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x33, 0x33, 0x18, 0x14, 0x20, 0x01, 0x28,
+	0x06, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x33, 0x33, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x33, 0x34, 0x18, 0x4f, 0x20, 0x01, 0x28,
+	0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x33, 0x34, 0x12, 0x49, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x33, 0x35, 0x18, 0x50, 0x20, 0x03, 0x28,
+	0x0e, 0x32, 0x25, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45,
+	0x6e, 0x75, 0x6d, 0x31, 0x30, 0x31, 0x36, 0x37, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x33, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x30, 0x32, 0x33, 0x36, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x33, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x30, 0x32, 0x33, 0x37, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x33, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x30, 0x32, 0x33, 0x38, 0x18, 0x1c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x33, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x30, 0x32, 0x33, 0x39, 0x18, 0x10, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x33, 0x39, 0x12, 0x47, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x30, 0x32, 0x34, 0x30, 0x18, 0x11, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x39, 0x31, 0x38, 0x32, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x34,
+	0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x34, 0x31, 0x18,
+	0x3f, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x34,
+	0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x34, 0x32, 0x18,
+	0x40, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x34,
+	0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x34, 0x33, 0x18,
+	0x25, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x34,
+	0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x34, 0x34, 0x18,
+	0x2b, 0x20, 0x03, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x34,
+	0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x34, 0x35, 0x18,
+	0x2c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x34,
+	0x35, 0x12, 0x47, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x34, 0x36, 0x18,
+	0x2d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x39, 0x32, 0x34, 0x32, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x34, 0x36, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x34, 0x37, 0x18, 0x2e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73,
+	0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x34, 0x37, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x34, 0x38, 0x18, 0x3e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73,
+	0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x34, 0x38, 0x12, 0x47, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x34, 0x39, 0x18, 0x30, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x38, 0x39, 0x34, 0x34, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30,
+	0x32, 0x34, 0x39, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x35,
+	0x30, 0x18, 0x57, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30,
+	0x32, 0x35, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x35,
+	0x31, 0x18, 0x3a, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30,
+	0x32, 0x35, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x35,
+	0x32, 0x18, 0x5c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30,
+	0x32, 0x35, 0x32, 0x12, 0x47, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x35,
+	0x33, 0x18, 0x5d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x39, 0x31, 0x32, 0x33,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x35, 0x33, 0x12, 0x47, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x35, 0x34, 0x18, 0x3c, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x39, 0x31, 0x36, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x30, 0x32, 0x35, 0x34, 0x12, 0x47, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30,
+	0x32, 0x35, 0x35, 0x18, 0x43, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x38,
+	0x39, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x35, 0x35, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x35, 0x36, 0x18, 0x45, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x35, 0x36, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x35, 0x37, 0x18, 0x4a, 0x20, 0x01,
+	0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x35, 0x37, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x35, 0x38, 0x18, 0x52, 0x20, 0x01,
+	0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x35, 0x38, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x35, 0x39, 0x18, 0x55, 0x20, 0x01,
+	0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x35, 0x39, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x36, 0x30, 0x18, 0x56, 0x20, 0x01,
+	0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x36, 0x30, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x36, 0x31, 0x18, 0x53, 0x20, 0x01,
+	0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x36, 0x31, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x36, 0x32, 0x18, 0x4d, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x36, 0x32, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x36, 0x33, 0x18, 0x58, 0x20, 0x01,
+	0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x36, 0x33, 0x12, 0x47,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x36, 0x34, 0x18, 0x5e, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x39, 0x36, 0x32, 0x38, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x30, 0x32, 0x36, 0x34, 0x1a, 0xb4, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x31, 0x30, 0x31, 0x35, 0x36, 0x12, 0x44, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x30, 0x32, 0x36, 0x36, 0x18, 0x33, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x38, 0x38,
+	0x36, 0x32, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x36, 0x36, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x36, 0x37, 0x18, 0x34, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x36, 0x37, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x36, 0x38, 0x18, 0x35, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x36, 0x38, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x36, 0x39, 0x18, 0x36, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x36, 0x39, 0x2a, 0x04,
+	0x08, 0x39, 0x10, 0x3a, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x22,
+	0x88, 0x02, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x31, 0x38, 0x36, 0x36,
+	0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x36, 0x38, 0x18, 0x01,
+	0x20, 0x02, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x31, 0x30, 0x31, 0x34, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x36, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x36, 0x39, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x36, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x37, 0x30, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x37, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x37, 0x31, 0x18, 0x04, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x37, 0x31, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x37, 0x32, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73,
+	0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x37, 0x32, 0x22, 0xae, 0x02, 0x0a, 0x0c, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x34, 0x36, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x34, 0x37, 0x33, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x34, 0x37, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x34, 0x37, 0x34, 0x18, 0x02, 0x20, 0x01, 0x28, 0x02, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x34, 0x37, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x34, 0x37, 0x35, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x34, 0x37, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x34, 0x37, 0x36, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x34, 0x37, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x34, 0x37, 0x37, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x34, 0x37, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x34, 0x37, 0x38, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x34, 0x37, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x34, 0x37, 0x39, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x34, 0x37, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x34, 0x38, 0x30, 0x18, 0x08, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x34, 0x38, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x34, 0x38, 0x31, 0x18, 0x09, 0x20, 0x01, 0x28, 0x02, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x34, 0x38, 0x31, 0x22, 0xa2, 0x01, 0x0a, 0x0c,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x38, 0x31, 0x38, 0x12, 0x48, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x38, 0x31, 0x39, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x38, 0x30, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x30, 0x38, 0x31, 0x39, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x30, 0x38, 0x32, 0x30, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31,
+	0x30, 0x38, 0x30, 0x31, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x38, 0x32, 0x30,
+	0x22, 0x98, 0x07, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x37, 0x37,
+	0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x37, 0x34, 0x18,
+	0x09, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x37,
+	0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x37, 0x35, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x37,
+	0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x37, 0x36, 0x18,
+	0x17, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x37,
+	0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x37, 0x37, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x37,
+	0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x37, 0x38, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x37,
+	0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x37, 0x39, 0x18,
+	0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x37,
+	0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x38, 0x30, 0x18,
+	0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x38,
+	0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x38, 0x31, 0x18,
+	0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x38,
+	0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x38, 0x32, 0x18,
+	0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x38,
+	0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x38, 0x33, 0x18,
+	0x08, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x38,
+	0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x38, 0x34, 0x18,
+	0x0a, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x38,
+	0x34, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x38, 0x35, 0x18,
+	0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x37, 0x34, 0x39, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x38, 0x35, 0x12, 0x4e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x38, 0x36, 0x18, 0x0c, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x38, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x38, 0x37, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x38, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x38, 0x38, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x38, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x38, 0x39, 0x18, 0x10, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x38, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x39, 0x30, 0x18, 0x11, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x39, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x39, 0x31, 0x18, 0x12, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x39, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x39, 0x32, 0x18, 0x13, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x39, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x39, 0x33, 0x18, 0x14, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x39, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x39, 0x34, 0x18, 0x15, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x39, 0x34, 0x12, 0x46, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x39, 0x35, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0e, 0x32,
+	0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30,
+	0x37, 0x39, 0x35, 0x12, 0x46, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x39,
+	0x36, 0x18, 0x16, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x39, 0x36, 0x22, 0xa0, 0x01, 0x0a, 0x0c,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x31, 0x34, 0x35, 0x12, 0x45, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x31, 0x35, 0x35, 0x18, 0x01, 0x20, 0x02, 0x28, 0x0e,
+	0x32, 0x25, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e,
+	0x75, 0x6d, 0x31, 0x33, 0x31, 0x34, 0x36, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33,
+	0x31, 0x35, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x31, 0x35,
+	0x36, 0x18, 0x02, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33,
+	0x31, 0x35, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x31, 0x35,
+	0x37, 0x18, 0x03, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33,
+	0x31, 0x35, 0x37, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x22, 0x0e,
+	0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x36, 0x36, 0x38, 0x36, 0x22, 0x4e,
+	0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x37, 0x39, 0x36, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x30, 0x30, 0x18, 0x01, 0x20, 0x03,
+	0x28, 0x06, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x30, 0x30, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x30, 0x31, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x04, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x30, 0x31, 0x22, 0x0d,
+	0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x37, 0x32, 0x32, 0x22, 0x0d, 0x0a,
+	0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x37, 0x32, 0x37, 0x22, 0x0d, 0x0a, 0x0b,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x37, 0x32, 0x34, 0x22, 0x0d, 0x0a, 0x0b, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x37, 0x33, 0x35, 0x22, 0x49, 0x0a, 0x0b, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x31, 0x38, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x32, 0x32, 0x36, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x32, 0x32, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x32, 0x32, 0x37, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x32, 0x32, 0x37, 0x22, 0x87, 0x05, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x38, 0x33, 0x30, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33,
+	0x32, 0x38, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x33, 0x32, 0x38, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x32, 0x39,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x39, 0x36, 0x36, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x32, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x33, 0x33, 0x30, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x33, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x33, 0x33, 0x31, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x33, 0x33, 0x31, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x33, 0x33, 0x32, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x32,
+	0x39, 0x30, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x33, 0x32, 0x12, 0x45, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x33, 0x33, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x39, 0x36, 0x36, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x33, 0x33, 0x33, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x33,
+	0x34, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x32, 0x39, 0x38,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x33, 0x34, 0x12, 0x45, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x33, 0x35, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x38, 0x33, 0x30, 0x30, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33,
+	0x33, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x33, 0x36, 0x18,
+	0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x33, 0x36,
+	0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x33, 0x37, 0x18, 0x0a, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x33, 0x37, 0x12, 0x45,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x33, 0x38, 0x18, 0x0b, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x39, 0x36, 0x35, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x33, 0x33, 0x38, 0x2a, 0x08, 0x08, 0x40, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x22,
+	0x0d, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x34, 0x35, 0x36, 0x22, 0xea,
+	0x07, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x33, 0x30, 0x32, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x33, 0x39, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x33, 0x39, 0x12, 0x45, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x34, 0x30, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x37, 0x39, 0x36, 0x36, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x33, 0x34, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x34, 0x31,
+	0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x34,
+	0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x34, 0x32, 0x18, 0x04,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x34, 0x32, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x34, 0x33, 0x18, 0x05, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x34, 0x33, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x34, 0x34, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x34, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x34, 0x35, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x34, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x33, 0x34, 0x36, 0x18, 0x08, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x33, 0x34, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x33, 0x34, 0x37, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x33, 0x34, 0x37, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33,
+	0x34, 0x38, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x32, 0x39,
+	0x30, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x34, 0x38, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x34, 0x39, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x34, 0x39, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x33, 0x35, 0x30, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65,
+	0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x35, 0x30, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x33, 0x35, 0x31, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x38, 0x32, 0x39, 0x31, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x35, 0x31, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x35, 0x32, 0x18, 0x0e, 0x20, 0x01,
+	0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x35, 0x32, 0x12, 0x45, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x35, 0x33, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x32, 0x39, 0x36, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x33, 0x35, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x35,
+	0x34, 0x18, 0x10, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33,
+	0x35, 0x34, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x35, 0x35, 0x18,
+	0x11, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x35, 0x35,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x35, 0x36, 0x18, 0x12, 0x20,
+	0x03, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x35, 0x36, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x35, 0x37, 0x18, 0x13, 0x20, 0x03, 0x28,
+	0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x35, 0x37, 0x12, 0x4c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x35, 0x38, 0x18, 0x14, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x35, 0x38, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x33, 0x35, 0x39, 0x18, 0x15, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x37, 0x39, 0x36, 0x35, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x35,
+	0x39, 0x2a, 0x08, 0x08, 0x40, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x22, 0x0d, 0x0a, 0x0b, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x34, 0x35, 0x37, 0x22, 0xae, 0x02, 0x0a, 0x0b, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x34, 0x34, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x34, 0x35, 0x38, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x35, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x34, 0x35, 0x39, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x34, 0x35, 0x39, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x34, 0x36, 0x30, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x38, 0x34, 0x35, 0x30, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x36, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x34, 0x36, 0x31, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x36, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x34, 0x36, 0x32, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x34, 0x36, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x34, 0x36, 0x33, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x34, 0x36, 0x33, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x36,
+	0x34, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x39, 0x36, 0x36,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x36, 0x34, 0x22, 0x9e, 0x01, 0x0a, 0x0c,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x33, 0x35, 0x38, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x33, 0x35, 0x39, 0x18, 0x01, 0x20, 0x02, 0x28, 0x06,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x33, 0x35, 0x39, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x33, 0x36, 0x30, 0x18, 0x02, 0x20, 0x02, 0x28, 0x06,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x33, 0x36, 0x30, 0x12, 0x4e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x33, 0x36, 0x31, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e,
+	0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x33, 0x36, 0x31, 0x22, 0xef, 0x01, 0x0a,
+	0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x39, 0x31, 0x32, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x39, 0x31, 0x33, 0x18, 0x01, 0x20, 0x02, 0x28,
+	0x07, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x39, 0x31, 0x33, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x39, 0x31, 0x34, 0x18, 0x02, 0x20, 0x02, 0x28,
+	0x07, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x39, 0x31, 0x34, 0x12, 0x4f, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x39, 0x31, 0x35, 0x18, 0xf4, 0x03, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x39, 0x31, 0x35, 0x12, 0x4e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x39, 0x31, 0x36, 0x18, 0x0f, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x39, 0x31, 0x36, 0x22, 0x6e,
+	0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x33, 0x31, 0x36, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x34, 0x33, 0x18, 0x01, 0x20, 0x03,
+	0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x34, 0x33, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x34, 0x34, 0x18, 0x02, 0x20, 0x03,
+	0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x34, 0x34, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x34, 0x35, 0x18, 0x03, 0x20, 0x03,
+	0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x34, 0x35, 0x22, 0xce,
+	0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x33, 0x31, 0x32, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x32, 0x31, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x32, 0x31, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x32, 0x32, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x32, 0x32, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x32, 0x33, 0x18, 0x03, 0x20,
+	0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x32, 0x33, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x32, 0x34, 0x18, 0x04, 0x20,
+	0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x32, 0x34, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x32, 0x35, 0x18, 0x05, 0x20,
+	0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x32, 0x35, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x32, 0x36, 0x18, 0x06, 0x20,
+	0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x32, 0x36, 0x22,
+	0xce, 0x02, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x33, 0x31, 0x33,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x32, 0x37, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x32, 0x37,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x32, 0x38, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x32, 0x38,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x32, 0x39, 0x18, 0x03,
+	0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x32, 0x39,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x33, 0x30, 0x18, 0x04,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x33, 0x30,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x33, 0x31, 0x18, 0x05,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x33, 0x31,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x33, 0x32, 0x18, 0x06,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x33, 0x32,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x33, 0x33, 0x18, 0x07,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x33, 0x33,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x33, 0x34, 0x18, 0x08,
+	0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x33, 0x34,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x33, 0x35, 0x18, 0x09,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x33, 0x35,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x33, 0x36, 0x18, 0x0a,
+	0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x33, 0x36,
+	0x22, 0x6e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x33, 0x31, 0x35,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x34, 0x30, 0x18, 0x01,
+	0x20, 0x02, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x34, 0x30,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x34, 0x31, 0x18, 0x02,
+	0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x34, 0x31,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x34, 0x32, 0x18, 0x03,
+	0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x34, 0x34, 0x32,
+	0x22, 0xa4, 0x01, 0x0a, 0x0a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x31, 0x36, 0x12,
+	0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x37, 0x32, 0x18, 0x01, 0x20, 0x02, 0x28,
+	0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x37, 0x32, 0x12, 0x1a, 0x0a, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x37, 0x33, 0x18, 0x02, 0x20, 0x02, 0x28, 0x05, 0x52, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x37, 0x33, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x37, 0x34, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x37, 0x34, 0x12, 0x42, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x37, 0x35, 0x18,
+	0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x31, 0x37, 0x52, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x37, 0x35, 0x22, 0x60, 0x0a, 0x0a, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x37, 0x31, 0x38, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x37,
+	0x38, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x37,
+	0x38, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x37, 0x39, 0x18, 0x02, 0x20,
+	0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x37, 0x39, 0x12, 0x1a, 0x0a,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x30, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x30, 0x22, 0x98, 0x01, 0x0a, 0x0a, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x30, 0x33, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x39, 0x35, 0x18, 0x01, 0x20, 0x02, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x39, 0x35, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x36,
+	0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x36,
+	0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x37, 0x18, 0x03, 0x20, 0x03,
+	0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x37, 0x12, 0x1a, 0x0a, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x38, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x38, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x39, 0x39, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x39, 0x39, 0x22, 0xb0, 0x06, 0x0a, 0x0a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x37, 0x31, 0x35, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x39, 0x18,
+	0x01, 0x20, 0x02, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x39, 0x12,
+	0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x30, 0x18, 0x07, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x30, 0x12, 0x42, 0x0a, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x31, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x37, 0x30, 0x37, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x31, 0x12,
+	0x42, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x32, 0x18, 0x03, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x30, 0x38, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x36, 0x32, 0x12, 0x42, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x33, 0x18,
+	0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x31, 0x31, 0x52, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x33, 0x12, 0x42, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x36, 0x34, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x31,
+	0x32, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x34, 0x12, 0x42, 0x0a, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x35, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x37, 0x31, 0x33, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x35, 0x12,
+	0x42, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x36, 0x18, 0x08, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x31, 0x34, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x36, 0x36, 0x12, 0x42, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x37, 0x18,
+	0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x31, 0x30, 0x52, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x37, 0x12, 0x42, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x36, 0x38, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x30,
+	0x39, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x38, 0x12, 0x42, 0x0a, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x39, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x37, 0x30, 0x35, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x39, 0x12,
+	0x42, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x37, 0x30, 0x18, 0x0c, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x30, 0x32, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x37, 0x30, 0x12, 0x42, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x37, 0x31, 0x18,
+	0x0d, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x30, 0x36, 0x52, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x37, 0x31, 0x22, 0x44, 0x0a, 0x0a, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x37, 0x30, 0x30, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38,
+	0x39, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38,
+	0x39, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x30, 0x18, 0x02, 0x20,
+	0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x30, 0x22, 0x44, 0x0a,
+	0x0a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x39, 0x39, 0x12, 0x1a, 0x0a, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x37, 0x18, 0x01, 0x20, 0x02, 0x28, 0x09, 0x52, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x37, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x37, 0x38, 0x38, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x37, 0x38, 0x38, 0x22, 0xec, 0x01, 0x0a, 0x0a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36,
+	0x39, 0x38, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x39, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x37, 0x39, 0x12, 0x1a,
+	0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x30, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x30, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x38, 0x31, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x38, 0x31, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37,
+	0x38, 0x32, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37,
+	0x38, 0x32, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x33, 0x18, 0x05,
+	0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x33, 0x12, 0x1a,
+	0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x34, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d,
+	0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x34, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x38, 0x35, 0x18, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x38, 0x35, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37,
+	0x38, 0x36, 0x18, 0x08, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37,
+	0x38, 0x36, 0x42, 0x23, 0x0a, 0x1e, 0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0xf8, 0x01, 0x01,
+}
+
+var (
+	file_datasets_google_message3_benchmark_message3_5_proto_rawDescOnce sync.Once
+	file_datasets_google_message3_benchmark_message3_5_proto_rawDescData = file_datasets_google_message3_benchmark_message3_5_proto_rawDesc
+)
+
+func file_datasets_google_message3_benchmark_message3_5_proto_rawDescGZIP() []byte {
+	file_datasets_google_message3_benchmark_message3_5_proto_rawDescOnce.Do(func() {
+		file_datasets_google_message3_benchmark_message3_5_proto_rawDescData = protoimpl.X.CompressGZIP(file_datasets_google_message3_benchmark_message3_5_proto_rawDescData)
+	})
+	return file_datasets_google_message3_benchmark_message3_5_proto_rawDescData
+}
+
+var file_datasets_google_message3_benchmark_message3_5_proto_msgTypes = make([]protoimpl.MessageInfo, 49)
+var file_datasets_google_message3_benchmark_message3_5_proto_goTypes = []interface{}{
+	(*Message24377)(nil),              // 0: benchmarks.google_message3.Message24377
+	(*Message24378)(nil),              // 1: benchmarks.google_message3.Message24378
+	(*Message24400)(nil),              // 2: benchmarks.google_message3.Message24400
+	(*Message24380)(nil),              // 3: benchmarks.google_message3.Message24380
+	(*Message24381)(nil),              // 4: benchmarks.google_message3.Message24381
+	(*Message719)(nil),                // 5: benchmarks.google_message3.Message719
+	(*Message728)(nil),                // 6: benchmarks.google_message3.Message728
+	(*Message704)(nil),                // 7: benchmarks.google_message3.Message704
+	(*Message697)(nil),                // 8: benchmarks.google_message3.Message697
+	(*Message0)(nil),                  // 9: benchmarks.google_message3.Message0
+	(*Message6578)(nil),               // 10: benchmarks.google_message3.Message6578
+	(*Message6024)(nil),               // 11: benchmarks.google_message3.Message6024
+	(*Message6052)(nil),               // 12: benchmarks.google_message3.Message6052
+	(*Message6054)(nil),               // 13: benchmarks.google_message3.Message6054
+	(*Message10573)(nil),              // 14: benchmarks.google_message3.Message10573
+	(*Message10824)(nil),              // 15: benchmarks.google_message3.Message10824
+	(*Message10582)(nil),              // 16: benchmarks.google_message3.Message10582
+	(*Message10155)(nil),              // 17: benchmarks.google_message3.Message10155
+	(*Message11866)(nil),              // 18: benchmarks.google_message3.Message11866
+	(*Message10469)(nil),              // 19: benchmarks.google_message3.Message10469
+	(*Message10818)(nil),              // 20: benchmarks.google_message3.Message10818
+	(*Message10773)(nil),              // 21: benchmarks.google_message3.Message10773
+	(*Message13145)(nil),              // 22: benchmarks.google_message3.Message13145
+	(*Message16686)(nil),              // 23: benchmarks.google_message3.Message16686
+	(*Message12796)(nil),              // 24: benchmarks.google_message3.Message12796
+	(*Message6722)(nil),               // 25: benchmarks.google_message3.Message6722
+	(*Message6727)(nil),               // 26: benchmarks.google_message3.Message6727
+	(*Message6724)(nil),               // 27: benchmarks.google_message3.Message6724
+	(*Message6735)(nil),               // 28: benchmarks.google_message3.Message6735
+	(*Message8183)(nil),               // 29: benchmarks.google_message3.Message8183
+	(*Message8301)(nil),               // 30: benchmarks.google_message3.Message8301
+	(*Message8456)(nil),               // 31: benchmarks.google_message3.Message8456
+	(*Message8302)(nil),               // 32: benchmarks.google_message3.Message8302
+	(*Message8457)(nil),               // 33: benchmarks.google_message3.Message8457
+	(*Message8449)(nil),               // 34: benchmarks.google_message3.Message8449
+	(*Message13358)(nil),              // 35: benchmarks.google_message3.Message13358
+	(*Message13912)(nil),              // 36: benchmarks.google_message3.Message13912
+	(*Message24316)(nil),              // 37: benchmarks.google_message3.Message24316
+	(*Message24312)(nil),              // 38: benchmarks.google_message3.Message24312
+	(*Message24313)(nil),              // 39: benchmarks.google_message3.Message24313
+	(*Message24315)(nil),              // 40: benchmarks.google_message3.Message24315
+	(*Message716)(nil),                // 41: benchmarks.google_message3.Message716
+	(*Message718)(nil),                // 42: benchmarks.google_message3.Message718
+	(*Message703)(nil),                // 43: benchmarks.google_message3.Message703
+	(*Message715)(nil),                // 44: benchmarks.google_message3.Message715
+	(*Message700)(nil),                // 45: benchmarks.google_message3.Message700
+	(*Message699)(nil),                // 46: benchmarks.google_message3.Message699
+	(*Message698)(nil),                // 47: benchmarks.google_message3.Message698
+	(*Message10155_Message10156)(nil), // 48: benchmarks.google_message3.Message10155.Message10156
+	(Enum720)(0),                      // 49: benchmarks.google_message3.Enum720
+	(*UnusedEmptyMessage)(nil),        // 50: benchmarks.google_message3.UnusedEmptyMessage
+	(Enum6579)(0),                     // 51: benchmarks.google_message3.Enum6579
+	(Enum6588)(0),                     // 52: benchmarks.google_message3.Enum6588
+	(Enum6025)(0),                     // 53: benchmarks.google_message3.Enum6025
+	(*Message10576)(nil),              // 54: benchmarks.google_message3.Message10576
+	(Enum10157)(0),                    // 55: benchmarks.google_message3.Enum10157
+	(*Message9151)(nil),               // 56: benchmarks.google_message3.Message9151
+	(*Message10154)(nil),              // 57: benchmarks.google_message3.Message10154
+	(Enum10167)(0),                    // 58: benchmarks.google_message3.Enum10167
+	(*Message9182)(nil),               // 59: benchmarks.google_message3.Message9182
+	(*Message9242)(nil),               // 60: benchmarks.google_message3.Message9242
+	(*Message8944)(nil),               // 61: benchmarks.google_message3.Message8944
+	(*Message9123)(nil),               // 62: benchmarks.google_message3.Message9123
+	(*Message9160)(nil),               // 63: benchmarks.google_message3.Message9160
+	(*Message8890)(nil),               // 64: benchmarks.google_message3.Message8890
+	(*Message9628)(nil),               // 65: benchmarks.google_message3.Message9628
+	(*Message11014)(nil),              // 66: benchmarks.google_message3.Message11014
+	(*Message10800)(nil),              // 67: benchmarks.google_message3.Message10800
+	(*Message10801)(nil),              // 68: benchmarks.google_message3.Message10801
+	(*Message10749)(nil),              // 69: benchmarks.google_message3.Message10749
+	(UnusedEnum)(0),                   // 70: benchmarks.google_message3.UnusedEnum
+	(Enum13146)(0),                    // 71: benchmarks.google_message3.Enum13146
+	(*Message7966)(nil),               // 72: benchmarks.google_message3.Message7966
+	(*Message8290)(nil),               // 73: benchmarks.google_message3.Message8290
+	(*Message8298)(nil),               // 74: benchmarks.google_message3.Message8298
+	(*Message8300)(nil),               // 75: benchmarks.google_message3.Message8300
+	(*Message7965)(nil),               // 76: benchmarks.google_message3.Message7965
+	(*Message8291)(nil),               // 77: benchmarks.google_message3.Message8291
+	(*Message8296)(nil),               // 78: benchmarks.google_message3.Message8296
+	(Enum8450)(0),                     // 79: benchmarks.google_message3.Enum8450
+	(*Message717)(nil),                // 80: benchmarks.google_message3.Message717
+	(*Message707)(nil),                // 81: benchmarks.google_message3.Message707
+	(*Message708)(nil),                // 82: benchmarks.google_message3.Message708
+	(*Message711)(nil),                // 83: benchmarks.google_message3.Message711
+	(*Message712)(nil),                // 84: benchmarks.google_message3.Message712
+	(*Message713)(nil),                // 85: benchmarks.google_message3.Message713
+	(*Message714)(nil),                // 86: benchmarks.google_message3.Message714
+	(*Message710)(nil),                // 87: benchmarks.google_message3.Message710
+	(*Message709)(nil),                // 88: benchmarks.google_message3.Message709
+	(*Message705)(nil),                // 89: benchmarks.google_message3.Message705
+	(*Message702)(nil),                // 90: benchmarks.google_message3.Message702
+	(*Message706)(nil),                // 91: benchmarks.google_message3.Message706
+	(Enum8862)(0),                     // 92: benchmarks.google_message3.Enum8862
+}
+var file_datasets_google_message3_benchmark_message3_5_proto_depIdxs = []int32{
+	49, // 0: benchmarks.google_message3.Message719.field884:type_name -> benchmarks.google_message3.Enum720
+	43, // 1: benchmarks.google_message3.Message728.field889:type_name -> benchmarks.google_message3.Message703
+	44, // 2: benchmarks.google_message3.Message728.field890:type_name -> benchmarks.google_message3.Message715
+	42, // 3: benchmarks.google_message3.Message728.field893:type_name -> benchmarks.google_message3.Message718
+	41, // 4: benchmarks.google_message3.Message728.field894:type_name -> benchmarks.google_message3.Message716
+	50, // 5: benchmarks.google_message3.Message704.field806:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	45, // 6: benchmarks.google_message3.Message697.field769:type_name -> benchmarks.google_message3.Message700
+	46, // 7: benchmarks.google_message3.Message697.field776:type_name -> benchmarks.google_message3.Message699
+	47, // 8: benchmarks.google_message3.Message697.field777:type_name -> benchmarks.google_message3.Message698
+	51, // 9: benchmarks.google_message3.Message6578.field6632:type_name -> benchmarks.google_message3.Enum6579
+	52, // 10: benchmarks.google_message3.Message6578.field6633:type_name -> benchmarks.google_message3.Enum6588
+	53, // 11: benchmarks.google_message3.Message6024.field6048:type_name -> benchmarks.google_message3.Enum6025
+	50, // 12: benchmarks.google_message3.Message6024.field6050:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	54, // 13: benchmarks.google_message3.Message10573.field10580:type_name -> benchmarks.google_message3.Message10576
+	55, // 14: benchmarks.google_message3.Message10155.field10197:type_name -> benchmarks.google_message3.Enum10157
+	48, // 15: benchmarks.google_message3.Message10155.message10156:type_name -> benchmarks.google_message3.Message10155.Message10156
+	56, // 16: benchmarks.google_message3.Message10155.field10213:type_name -> benchmarks.google_message3.Message9151
+	57, // 17: benchmarks.google_message3.Message10155.field10217:type_name -> benchmarks.google_message3.Message10154
+	58, // 18: benchmarks.google_message3.Message10155.field10235:type_name -> benchmarks.google_message3.Enum10167
+	59, // 19: benchmarks.google_message3.Message10155.field10240:type_name -> benchmarks.google_message3.Message9182
+	60, // 20: benchmarks.google_message3.Message10155.field10246:type_name -> benchmarks.google_message3.Message9242
+	50, // 21: benchmarks.google_message3.Message10155.field10247:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	50, // 22: benchmarks.google_message3.Message10155.field10248:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	61, // 23: benchmarks.google_message3.Message10155.field10249:type_name -> benchmarks.google_message3.Message8944
+	50, // 24: benchmarks.google_message3.Message10155.field10250:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	62, // 25: benchmarks.google_message3.Message10155.field10253:type_name -> benchmarks.google_message3.Message9123
+	63, // 26: benchmarks.google_message3.Message10155.field10254:type_name -> benchmarks.google_message3.Message9160
+	64, // 27: benchmarks.google_message3.Message10155.field10255:type_name -> benchmarks.google_message3.Message8890
+	65, // 28: benchmarks.google_message3.Message10155.field10264:type_name -> benchmarks.google_message3.Message9628
+	66, // 29: benchmarks.google_message3.Message11866.field11868:type_name -> benchmarks.google_message3.Message11014
+	50, // 30: benchmarks.google_message3.Message11866.field11872:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	67, // 31: benchmarks.google_message3.Message10818.field10819:type_name -> benchmarks.google_message3.Message10800
+	68, // 32: benchmarks.google_message3.Message10818.field10820:type_name -> benchmarks.google_message3.Message10801
+	69, // 33: benchmarks.google_message3.Message10773.field10785:type_name -> benchmarks.google_message3.Message10749
+	50, // 34: benchmarks.google_message3.Message10773.field10786:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	70, // 35: benchmarks.google_message3.Message10773.field10795:type_name -> benchmarks.google_message3.UnusedEnum
+	70, // 36: benchmarks.google_message3.Message10773.field10796:type_name -> benchmarks.google_message3.UnusedEnum
+	71, // 37: benchmarks.google_message3.Message13145.field13155:type_name -> benchmarks.google_message3.Enum13146
+	72, // 38: benchmarks.google_message3.Message8301.field8329:type_name -> benchmarks.google_message3.Message7966
+	73, // 39: benchmarks.google_message3.Message8301.field8332:type_name -> benchmarks.google_message3.Message8290
+	72, // 40: benchmarks.google_message3.Message8301.field8333:type_name -> benchmarks.google_message3.Message7966
+	74, // 41: benchmarks.google_message3.Message8301.field8334:type_name -> benchmarks.google_message3.Message8298
+	75, // 42: benchmarks.google_message3.Message8301.field8335:type_name -> benchmarks.google_message3.Message8300
+	50, // 43: benchmarks.google_message3.Message8301.field8337:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	76, // 44: benchmarks.google_message3.Message8301.field8338:type_name -> benchmarks.google_message3.Message7965
+	72, // 45: benchmarks.google_message3.Message8302.field8340:type_name -> benchmarks.google_message3.Message7966
+	73, // 46: benchmarks.google_message3.Message8302.field8348:type_name -> benchmarks.google_message3.Message8290
+	50, // 47: benchmarks.google_message3.Message8302.field8350:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	77, // 48: benchmarks.google_message3.Message8302.field8351:type_name -> benchmarks.google_message3.Message8291
+	78, // 49: benchmarks.google_message3.Message8302.field8353:type_name -> benchmarks.google_message3.Message8296
+	50, // 50: benchmarks.google_message3.Message8302.field8355:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	50, // 51: benchmarks.google_message3.Message8302.field8358:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	76, // 52: benchmarks.google_message3.Message8302.field8359:type_name -> benchmarks.google_message3.Message7965
+	79, // 53: benchmarks.google_message3.Message8449.field8460:type_name -> benchmarks.google_message3.Enum8450
+	72, // 54: benchmarks.google_message3.Message8449.field8464:type_name -> benchmarks.google_message3.Message7966
+	50, // 55: benchmarks.google_message3.Message13358.field13361:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	50, // 56: benchmarks.google_message3.Message13912.field13915:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	50, // 57: benchmarks.google_message3.Message13912.field13916:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	80, // 58: benchmarks.google_message3.Message716.field875:type_name -> benchmarks.google_message3.Message717
+	81, // 59: benchmarks.google_message3.Message715.field861:type_name -> benchmarks.google_message3.Message707
+	82, // 60: benchmarks.google_message3.Message715.field862:type_name -> benchmarks.google_message3.Message708
+	83, // 61: benchmarks.google_message3.Message715.field863:type_name -> benchmarks.google_message3.Message711
+	84, // 62: benchmarks.google_message3.Message715.field864:type_name -> benchmarks.google_message3.Message712
+	85, // 63: benchmarks.google_message3.Message715.field865:type_name -> benchmarks.google_message3.Message713
+	86, // 64: benchmarks.google_message3.Message715.field866:type_name -> benchmarks.google_message3.Message714
+	87, // 65: benchmarks.google_message3.Message715.field867:type_name -> benchmarks.google_message3.Message710
+	88, // 66: benchmarks.google_message3.Message715.field868:type_name -> benchmarks.google_message3.Message709
+	89, // 67: benchmarks.google_message3.Message715.field869:type_name -> benchmarks.google_message3.Message705
+	90, // 68: benchmarks.google_message3.Message715.field870:type_name -> benchmarks.google_message3.Message702
+	91, // 69: benchmarks.google_message3.Message715.field871:type_name -> benchmarks.google_message3.Message706
+	92, // 70: benchmarks.google_message3.Message10155.Message10156.field10266:type_name -> benchmarks.google_message3.Enum8862
+	71, // [71:71] is the sub-list for method output_type
+	71, // [71:71] is the sub-list for method input_type
+	71, // [71:71] is the sub-list for extension type_name
+	71, // [71:71] is the sub-list for extension extendee
+	0,  // [0:71] is the sub-list for field type_name
+}
+
+func init() { file_datasets_google_message3_benchmark_message3_5_proto_init() }
+func file_datasets_google_message3_benchmark_message3_5_proto_init() {
+	if File_datasets_google_message3_benchmark_message3_5_proto != nil {
+		return
+	}
+	file_datasets_google_message3_benchmark_message3_6_proto_init()
+	file_datasets_google_message3_benchmark_message3_7_proto_init()
+	file_datasets_google_message3_benchmark_message3_8_proto_init()
+	if !protoimpl.UnsafeEnabled {
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message24377); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message24378); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message24400); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message24380); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message24381); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message719); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message728); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message704); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message697); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message0); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6578); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6024); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6052); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6054); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message10573); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message10824); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message10582); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message10155); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message11866); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message10469); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message10818); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message10773); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message13145); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message16686); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12796); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6722); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6727); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6724); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6735); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8183); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8301); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8456); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8302); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8457); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8449); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[35].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message13358); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[36].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message13912); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[37].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message24316); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[38].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message24312); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[39].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message24313); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[40].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message24315); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[41].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message716); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[42].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message718); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[43].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message703); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[44].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message715); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[45].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message700); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[46].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message699); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[47].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message698); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_5_proto_msgTypes[48].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message10155_Message10156); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_datasets_google_message3_benchmark_message3_5_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   49,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_datasets_google_message3_benchmark_message3_5_proto_goTypes,
+		DependencyIndexes: file_datasets_google_message3_benchmark_message3_5_proto_depIdxs,
+		MessageInfos:      file_datasets_google_message3_benchmark_message3_5_proto_msgTypes,
+	}.Build()
+	File_datasets_google_message3_benchmark_message3_5_proto = out.File
+	file_datasets_google_message3_benchmark_message3_5_proto_rawDesc = nil
+	file_datasets_google_message3_benchmark_message3_5_proto_goTypes = nil
+	file_datasets_google_message3_benchmark_message3_5_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3/benchmark_message3_6.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3/benchmark_message3_6.pb.go
new file mode 100644
index 000000000..f0f9740f9
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3/benchmark_message3_6.pb.go
@@ -0,0 +1,5715 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// LINT: ALLOW_GROUPS
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: datasets/google_message3/benchmark_message3_6.proto
+
+package google_message3
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoiface "google.golang.org/protobuf/runtime/protoiface"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type Message10576 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message10576) Reset() {
+	*x = Message10576{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message10576) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message10576) ProtoMessage() {}
+
+func (x *Message10576) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message10576.ProtoReflect.Descriptor instead.
+func (*Message10576) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{0}
+}
+
+type Message10154 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field10192 []byte `protobuf:"bytes,1,opt,name=field10192" json:"field10192,omitempty"`
+	Field10193 *int32 `protobuf:"varint,2,opt,name=field10193" json:"field10193,omitempty"`
+}
+
+func (x *Message10154) Reset() {
+	*x = Message10154{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message10154) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message10154) ProtoMessage() {}
+
+func (x *Message10154) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message10154.ProtoReflect.Descriptor instead.
+func (*Message10154) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *Message10154) GetField10192() []byte {
+	if x != nil {
+		return x.Field10192
+	}
+	return nil
+}
+
+func (x *Message10154) GetField10193() int32 {
+	if x != nil && x.Field10193 != nil {
+		return *x.Field10193
+	}
+	return 0
+}
+
+type Message8944 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field9045 *string      `protobuf:"bytes,2,opt,name=field9045" json:"field9045,omitempty"`
+	Field9046 *string      `protobuf:"bytes,3,opt,name=field9046" json:"field9046,omitempty"`
+	Field9047 *string      `protobuf:"bytes,23,opt,name=field9047" json:"field9047,omitempty"`
+	Field9048 *string      `protobuf:"bytes,52,opt,name=field9048" json:"field9048,omitempty"`
+	Field9049 *int32       `protobuf:"varint,53,opt,name=field9049" json:"field9049,omitempty"`
+	Field9050 *int32       `protobuf:"varint,54,opt,name=field9050" json:"field9050,omitempty"`
+	Field9051 *float32     `protobuf:"fixed32,55,opt,name=field9051" json:"field9051,omitempty"`
+	Field9052 *float32     `protobuf:"fixed32,56,opt,name=field9052" json:"field9052,omitempty"`
+	Field9053 *string      `protobuf:"bytes,57,opt,name=field9053" json:"field9053,omitempty"`
+	Field9054 *int64       `protobuf:"varint,1,opt,name=field9054" json:"field9054,omitempty"`
+	Field9055 *bool        `protobuf:"varint,4,opt,name=field9055" json:"field9055,omitempty"`
+	Field9056 *int32       `protobuf:"varint,5,opt,name=field9056" json:"field9056,omitempty"`
+	Field9057 *int32       `protobuf:"varint,6,opt,name=field9057" json:"field9057,omitempty"`
+	Field9058 *int32       `protobuf:"varint,7,opt,name=field9058" json:"field9058,omitempty"`
+	Field9059 *float32     `protobuf:"fixed32,8,opt,name=field9059" json:"field9059,omitempty"`
+	Field9060 *float32     `protobuf:"fixed32,11,opt,name=field9060" json:"field9060,omitempty"`
+	Field9061 *float32     `protobuf:"fixed32,9,opt,name=field9061" json:"field9061,omitempty"`
+	Field9062 *float32     `protobuf:"fixed32,10,opt,name=field9062" json:"field9062,omitempty"`
+	Field9063 *float32     `protobuf:"fixed32,13,opt,name=field9063" json:"field9063,omitempty"`
+	Field9064 *bool        `protobuf:"varint,14,opt,name=field9064" json:"field9064,omitempty"`
+	Field9065 *float32     `protobuf:"fixed32,70,opt,name=field9065" json:"field9065,omitempty"`
+	Field9066 *int32       `protobuf:"varint,71,opt,name=field9066" json:"field9066,omitempty"`
+	Field9067 *Enum8945    `protobuf:"varint,15,opt,name=field9067,enum=benchmarks.google_message3.Enum8945" json:"field9067,omitempty"`
+	Field9068 *int32       `protobuf:"varint,16,opt,name=field9068" json:"field9068,omitempty"`
+	Field9069 *int32       `protobuf:"varint,17,opt,name=field9069" json:"field9069,omitempty"`
+	Field9070 *float32     `protobuf:"fixed32,18,opt,name=field9070" json:"field9070,omitempty"`
+	Field9071 *float32     `protobuf:"fixed32,19,opt,name=field9071" json:"field9071,omitempty"`
+	Field9072 *int32       `protobuf:"varint,28,opt,name=field9072" json:"field9072,omitempty"`
+	Field9073 *int32       `protobuf:"varint,29,opt,name=field9073" json:"field9073,omitempty"`
+	Field9074 *float32     `protobuf:"fixed32,60,opt,name=field9074" json:"field9074,omitempty"`
+	Field9075 *float32     `protobuf:"fixed32,61,opt,name=field9075" json:"field9075,omitempty"`
+	Field9076 *int32       `protobuf:"varint,72,opt,name=field9076" json:"field9076,omitempty"`
+	Field9077 *int32       `protobuf:"varint,73,opt,name=field9077" json:"field9077,omitempty"`
+	Field9078 *Enum8951    `protobuf:"varint,62,opt,name=field9078,enum=benchmarks.google_message3.Enum8951" json:"field9078,omitempty"`
+	Field9079 *string      `protobuf:"bytes,20,opt,name=field9079" json:"field9079,omitempty"`
+	Field9080 *string      `protobuf:"bytes,21,opt,name=field9080" json:"field9080,omitempty"`
+	Field9081 *string      `protobuf:"bytes,22,opt,name=field9081" json:"field9081,omitempty"`
+	Field9082 *float64     `protobuf:"fixed64,31,opt,name=field9082" json:"field9082,omitempty"`
+	Field9083 *float64     `protobuf:"fixed64,32,opt,name=field9083" json:"field9083,omitempty"`
+	Field9084 *float64     `protobuf:"fixed64,33,opt,name=field9084" json:"field9084,omitempty"`
+	Field9085 *float64     `protobuf:"fixed64,36,opt,name=field9085" json:"field9085,omitempty"`
+	Field9086 *UnusedEnum  `protobuf:"varint,37,opt,name=field9086,enum=benchmarks.google_message3.UnusedEnum" json:"field9086,omitempty"`
+	Field9087 *float64     `protobuf:"fixed64,38,opt,name=field9087" json:"field9087,omitempty"`
+	Field9088 *float64     `protobuf:"fixed64,39,opt,name=field9088" json:"field9088,omitempty"`
+	Field9089 *float64     `protobuf:"fixed64,63,opt,name=field9089" json:"field9089,omitempty"`
+	Field9090 *float64     `protobuf:"fixed64,64,opt,name=field9090" json:"field9090,omitempty"`
+	Field9091 *float64     `protobuf:"fixed64,65,opt,name=field9091" json:"field9091,omitempty"`
+	Field9092 *float64     `protobuf:"fixed64,34,opt,name=field9092" json:"field9092,omitempty"`
+	Field9093 *UnusedEnum  `protobuf:"varint,35,opt,name=field9093,enum=benchmarks.google_message3.UnusedEnum" json:"field9093,omitempty"`
+	Field9094 *UnusedEnum  `protobuf:"varint,66,opt,name=field9094,enum=benchmarks.google_message3.UnusedEnum" json:"field9094,omitempty"`
+	Field9095 *string      `protobuf:"bytes,40,opt,name=field9095" json:"field9095,omitempty"`
+	Field9096 *string      `protobuf:"bytes,41,opt,name=field9096" json:"field9096,omitempty"`
+	Field9097 *string      `protobuf:"bytes,42,opt,name=field9097" json:"field9097,omitempty"`
+	Field9098 *string      `protobuf:"bytes,43,opt,name=field9098" json:"field9098,omitempty"`
+	Field9099 *string      `protobuf:"bytes,44,opt,name=field9099" json:"field9099,omitempty"`
+	Field9100 *string      `protobuf:"bytes,45,opt,name=field9100" json:"field9100,omitempty"`
+	Field9101 *string      `protobuf:"bytes,46,opt,name=field9101" json:"field9101,omitempty"`
+	Field9102 *string      `protobuf:"bytes,47,opt,name=field9102" json:"field9102,omitempty"`
+	Field9103 *string      `protobuf:"bytes,48,opt,name=field9103" json:"field9103,omitempty"`
+	Field9104 *string      `protobuf:"bytes,49,opt,name=field9104" json:"field9104,omitempty"`
+	Field9105 *Message8939 `protobuf:"bytes,100,opt,name=field9105" json:"field9105,omitempty"`
+	Field9106 *int64       `protobuf:"varint,101,opt,name=field9106" json:"field9106,omitempty"`
+}
+
+func (x *Message8944) Reset() {
+	*x = Message8944{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8944) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8944) ProtoMessage() {}
+
+func (x *Message8944) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8944.ProtoReflect.Descriptor instead.
+func (*Message8944) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *Message8944) GetField9045() string {
+	if x != nil && x.Field9045 != nil {
+		return *x.Field9045
+	}
+	return ""
+}
+
+func (x *Message8944) GetField9046() string {
+	if x != nil && x.Field9046 != nil {
+		return *x.Field9046
+	}
+	return ""
+}
+
+func (x *Message8944) GetField9047() string {
+	if x != nil && x.Field9047 != nil {
+		return *x.Field9047
+	}
+	return ""
+}
+
+func (x *Message8944) GetField9048() string {
+	if x != nil && x.Field9048 != nil {
+		return *x.Field9048
+	}
+	return ""
+}
+
+func (x *Message8944) GetField9049() int32 {
+	if x != nil && x.Field9049 != nil {
+		return *x.Field9049
+	}
+	return 0
+}
+
+func (x *Message8944) GetField9050() int32 {
+	if x != nil && x.Field9050 != nil {
+		return *x.Field9050
+	}
+	return 0
+}
+
+func (x *Message8944) GetField9051() float32 {
+	if x != nil && x.Field9051 != nil {
+		return *x.Field9051
+	}
+	return 0
+}
+
+func (x *Message8944) GetField9052() float32 {
+	if x != nil && x.Field9052 != nil {
+		return *x.Field9052
+	}
+	return 0
+}
+
+func (x *Message8944) GetField9053() string {
+	if x != nil && x.Field9053 != nil {
+		return *x.Field9053
+	}
+	return ""
+}
+
+func (x *Message8944) GetField9054() int64 {
+	if x != nil && x.Field9054 != nil {
+		return *x.Field9054
+	}
+	return 0
+}
+
+func (x *Message8944) GetField9055() bool {
+	if x != nil && x.Field9055 != nil {
+		return *x.Field9055
+	}
+	return false
+}
+
+func (x *Message8944) GetField9056() int32 {
+	if x != nil && x.Field9056 != nil {
+		return *x.Field9056
+	}
+	return 0
+}
+
+func (x *Message8944) GetField9057() int32 {
+	if x != nil && x.Field9057 != nil {
+		return *x.Field9057
+	}
+	return 0
+}
+
+func (x *Message8944) GetField9058() int32 {
+	if x != nil && x.Field9058 != nil {
+		return *x.Field9058
+	}
+	return 0
+}
+
+func (x *Message8944) GetField9059() float32 {
+	if x != nil && x.Field9059 != nil {
+		return *x.Field9059
+	}
+	return 0
+}
+
+func (x *Message8944) GetField9060() float32 {
+	if x != nil && x.Field9060 != nil {
+		return *x.Field9060
+	}
+	return 0
+}
+
+func (x *Message8944) GetField9061() float32 {
+	if x != nil && x.Field9061 != nil {
+		return *x.Field9061
+	}
+	return 0
+}
+
+func (x *Message8944) GetField9062() float32 {
+	if x != nil && x.Field9062 != nil {
+		return *x.Field9062
+	}
+	return 0
+}
+
+func (x *Message8944) GetField9063() float32 {
+	if x != nil && x.Field9063 != nil {
+		return *x.Field9063
+	}
+	return 0
+}
+
+func (x *Message8944) GetField9064() bool {
+	if x != nil && x.Field9064 != nil {
+		return *x.Field9064
+	}
+	return false
+}
+
+func (x *Message8944) GetField9065() float32 {
+	if x != nil && x.Field9065 != nil {
+		return *x.Field9065
+	}
+	return 0
+}
+
+func (x *Message8944) GetField9066() int32 {
+	if x != nil && x.Field9066 != nil {
+		return *x.Field9066
+	}
+	return 0
+}
+
+func (x *Message8944) GetField9067() Enum8945 {
+	if x != nil && x.Field9067 != nil {
+		return *x.Field9067
+	}
+	return Enum8945_ENUM_VALUE8946
+}
+
+func (x *Message8944) GetField9068() int32 {
+	if x != nil && x.Field9068 != nil {
+		return *x.Field9068
+	}
+	return 0
+}
+
+func (x *Message8944) GetField9069() int32 {
+	if x != nil && x.Field9069 != nil {
+		return *x.Field9069
+	}
+	return 0
+}
+
+func (x *Message8944) GetField9070() float32 {
+	if x != nil && x.Field9070 != nil {
+		return *x.Field9070
+	}
+	return 0
+}
+
+func (x *Message8944) GetField9071() float32 {
+	if x != nil && x.Field9071 != nil {
+		return *x.Field9071
+	}
+	return 0
+}
+
+func (x *Message8944) GetField9072() int32 {
+	if x != nil && x.Field9072 != nil {
+		return *x.Field9072
+	}
+	return 0
+}
+
+func (x *Message8944) GetField9073() int32 {
+	if x != nil && x.Field9073 != nil {
+		return *x.Field9073
+	}
+	return 0
+}
+
+func (x *Message8944) GetField9074() float32 {
+	if x != nil && x.Field9074 != nil {
+		return *x.Field9074
+	}
+	return 0
+}
+
+func (x *Message8944) GetField9075() float32 {
+	if x != nil && x.Field9075 != nil {
+		return *x.Field9075
+	}
+	return 0
+}
+
+func (x *Message8944) GetField9076() int32 {
+	if x != nil && x.Field9076 != nil {
+		return *x.Field9076
+	}
+	return 0
+}
+
+func (x *Message8944) GetField9077() int32 {
+	if x != nil && x.Field9077 != nil {
+		return *x.Field9077
+	}
+	return 0
+}
+
+func (x *Message8944) GetField9078() Enum8951 {
+	if x != nil && x.Field9078 != nil {
+		return *x.Field9078
+	}
+	return Enum8951_ENUM_VALUE8952
+}
+
+func (x *Message8944) GetField9079() string {
+	if x != nil && x.Field9079 != nil {
+		return *x.Field9079
+	}
+	return ""
+}
+
+func (x *Message8944) GetField9080() string {
+	if x != nil && x.Field9080 != nil {
+		return *x.Field9080
+	}
+	return ""
+}
+
+func (x *Message8944) GetField9081() string {
+	if x != nil && x.Field9081 != nil {
+		return *x.Field9081
+	}
+	return ""
+}
+
+func (x *Message8944) GetField9082() float64 {
+	if x != nil && x.Field9082 != nil {
+		return *x.Field9082
+	}
+	return 0
+}
+
+func (x *Message8944) GetField9083() float64 {
+	if x != nil && x.Field9083 != nil {
+		return *x.Field9083
+	}
+	return 0
+}
+
+func (x *Message8944) GetField9084() float64 {
+	if x != nil && x.Field9084 != nil {
+		return *x.Field9084
+	}
+	return 0
+}
+
+func (x *Message8944) GetField9085() float64 {
+	if x != nil && x.Field9085 != nil {
+		return *x.Field9085
+	}
+	return 0
+}
+
+func (x *Message8944) GetField9086() UnusedEnum {
+	if x != nil && x.Field9086 != nil {
+		return *x.Field9086
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+func (x *Message8944) GetField9087() float64 {
+	if x != nil && x.Field9087 != nil {
+		return *x.Field9087
+	}
+	return 0
+}
+
+func (x *Message8944) GetField9088() float64 {
+	if x != nil && x.Field9088 != nil {
+		return *x.Field9088
+	}
+	return 0
+}
+
+func (x *Message8944) GetField9089() float64 {
+	if x != nil && x.Field9089 != nil {
+		return *x.Field9089
+	}
+	return 0
+}
+
+func (x *Message8944) GetField9090() float64 {
+	if x != nil && x.Field9090 != nil {
+		return *x.Field9090
+	}
+	return 0
+}
+
+func (x *Message8944) GetField9091() float64 {
+	if x != nil && x.Field9091 != nil {
+		return *x.Field9091
+	}
+	return 0
+}
+
+func (x *Message8944) GetField9092() float64 {
+	if x != nil && x.Field9092 != nil {
+		return *x.Field9092
+	}
+	return 0
+}
+
+func (x *Message8944) GetField9093() UnusedEnum {
+	if x != nil && x.Field9093 != nil {
+		return *x.Field9093
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+func (x *Message8944) GetField9094() UnusedEnum {
+	if x != nil && x.Field9094 != nil {
+		return *x.Field9094
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+func (x *Message8944) GetField9095() string {
+	if x != nil && x.Field9095 != nil {
+		return *x.Field9095
+	}
+	return ""
+}
+
+func (x *Message8944) GetField9096() string {
+	if x != nil && x.Field9096 != nil {
+		return *x.Field9096
+	}
+	return ""
+}
+
+func (x *Message8944) GetField9097() string {
+	if x != nil && x.Field9097 != nil {
+		return *x.Field9097
+	}
+	return ""
+}
+
+func (x *Message8944) GetField9098() string {
+	if x != nil && x.Field9098 != nil {
+		return *x.Field9098
+	}
+	return ""
+}
+
+func (x *Message8944) GetField9099() string {
+	if x != nil && x.Field9099 != nil {
+		return *x.Field9099
+	}
+	return ""
+}
+
+func (x *Message8944) GetField9100() string {
+	if x != nil && x.Field9100 != nil {
+		return *x.Field9100
+	}
+	return ""
+}
+
+func (x *Message8944) GetField9101() string {
+	if x != nil && x.Field9101 != nil {
+		return *x.Field9101
+	}
+	return ""
+}
+
+func (x *Message8944) GetField9102() string {
+	if x != nil && x.Field9102 != nil {
+		return *x.Field9102
+	}
+	return ""
+}
+
+func (x *Message8944) GetField9103() string {
+	if x != nil && x.Field9103 != nil {
+		return *x.Field9103
+	}
+	return ""
+}
+
+func (x *Message8944) GetField9104() string {
+	if x != nil && x.Field9104 != nil {
+		return *x.Field9104
+	}
+	return ""
+}
+
+func (x *Message8944) GetField9105() *Message8939 {
+	if x != nil {
+		return x.Field9105
+	}
+	return nil
+}
+
+func (x *Message8944) GetField9106() int64 {
+	if x != nil && x.Field9106 != nil {
+		return *x.Field9106
+	}
+	return 0
+}
+
+type Message9182 struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+
+	Field9205 *string               `protobuf:"bytes,1,opt,name=field9205" json:"field9205,omitempty"`
+	Field9206 *string               `protobuf:"bytes,2,opt,name=field9206" json:"field9206,omitempty"`
+	Field9207 *float32              `protobuf:"fixed32,16,opt,name=field9207" json:"field9207,omitempty"`
+	Field9208 *int32                `protobuf:"varint,17,opt,name=field9208" json:"field9208,omitempty"`
+	Field9209 *int32                `protobuf:"varint,27,opt,name=field9209" json:"field9209,omitempty"`
+	Field9210 *int32                `protobuf:"varint,7,opt,name=field9210" json:"field9210,omitempty"`
+	Field9211 *int32                `protobuf:"varint,8,opt,name=field9211" json:"field9211,omitempty"`
+	Field9212 *float32              `protobuf:"fixed32,26,opt,name=field9212" json:"field9212,omitempty"`
+	Field9213 *float32              `protobuf:"fixed32,22,opt,name=field9213" json:"field9213,omitempty"`
+	Field9214 *bool                 `protobuf:"varint,28,opt,name=field9214" json:"field9214,omitempty"`
+	Field9215 []*UnusedEmptyMessage `protobuf:"bytes,21,rep,name=field9215" json:"field9215,omitempty"`
+	Field9216 []*UnusedEmptyMessage `protobuf:"bytes,25,rep,name=field9216" json:"field9216,omitempty"`
+	Field9217 []*Message9181        `protobuf:"bytes,29,rep,name=field9217" json:"field9217,omitempty"`
+	Field9218 *bool                 `protobuf:"varint,18,opt,name=field9218" json:"field9218,omitempty"`
+	Field9219 *bool                 `protobuf:"varint,19,opt,name=field9219" json:"field9219,omitempty"`
+	Field9220 *bool                 `protobuf:"varint,20,opt,name=field9220" json:"field9220,omitempty"`
+	Field9221 *Message9164          `protobuf:"bytes,30,opt,name=field9221" json:"field9221,omitempty"`
+	Field9222 *Message9165          `protobuf:"bytes,31,opt,name=field9222" json:"field9222,omitempty"`
+	Field9223 *Message9166          `protobuf:"bytes,32,opt,name=field9223" json:"field9223,omitempty"`
+	Field9224 *float32              `protobuf:"fixed32,33,opt,name=field9224" json:"field9224,omitempty"`
+	Field9225 *Message9151          `protobuf:"bytes,34,opt,name=field9225" json:"field9225,omitempty"`
+	Field9226 *float32              `protobuf:"fixed32,35,opt,name=field9226" json:"field9226,omitempty"`
+	Field9227 *float32              `protobuf:"fixed32,36,opt,name=field9227" json:"field9227,omitempty"`
+	Field9228 *float32              `protobuf:"fixed32,37,opt,name=field9228" json:"field9228,omitempty"`
+	Field9229 *float32              `protobuf:"fixed32,38,opt,name=field9229" json:"field9229,omitempty"`
+	Field9230 *float32              `protobuf:"fixed32,39,opt,name=field9230" json:"field9230,omitempty"`
+}
+
+func (x *Message9182) Reset() {
+	*x = Message9182{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message9182) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message9182) ProtoMessage() {}
+
+func (x *Message9182) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message9182.ProtoReflect.Descriptor instead.
+func (*Message9182) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{3}
+}
+
+var extRange_Message9182 = []protoiface.ExtensionRangeV1{
+	{Start: 3, End: 6},
+	{Start: 9, End: 15},
+	{Start: 23, End: 23},
+	{Start: 24, End: 24},
+	{Start: 1000, End: 536870911},
+}
+
+// Deprecated: Use Message9182.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*Message9182) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_Message9182
+}
+
+func (x *Message9182) GetField9205() string {
+	if x != nil && x.Field9205 != nil {
+		return *x.Field9205
+	}
+	return ""
+}
+
+func (x *Message9182) GetField9206() string {
+	if x != nil && x.Field9206 != nil {
+		return *x.Field9206
+	}
+	return ""
+}
+
+func (x *Message9182) GetField9207() float32 {
+	if x != nil && x.Field9207 != nil {
+		return *x.Field9207
+	}
+	return 0
+}
+
+func (x *Message9182) GetField9208() int32 {
+	if x != nil && x.Field9208 != nil {
+		return *x.Field9208
+	}
+	return 0
+}
+
+func (x *Message9182) GetField9209() int32 {
+	if x != nil && x.Field9209 != nil {
+		return *x.Field9209
+	}
+	return 0
+}
+
+func (x *Message9182) GetField9210() int32 {
+	if x != nil && x.Field9210 != nil {
+		return *x.Field9210
+	}
+	return 0
+}
+
+func (x *Message9182) GetField9211() int32 {
+	if x != nil && x.Field9211 != nil {
+		return *x.Field9211
+	}
+	return 0
+}
+
+func (x *Message9182) GetField9212() float32 {
+	if x != nil && x.Field9212 != nil {
+		return *x.Field9212
+	}
+	return 0
+}
+
+func (x *Message9182) GetField9213() float32 {
+	if x != nil && x.Field9213 != nil {
+		return *x.Field9213
+	}
+	return 0
+}
+
+func (x *Message9182) GetField9214() bool {
+	if x != nil && x.Field9214 != nil {
+		return *x.Field9214
+	}
+	return false
+}
+
+func (x *Message9182) GetField9215() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field9215
+	}
+	return nil
+}
+
+func (x *Message9182) GetField9216() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field9216
+	}
+	return nil
+}
+
+func (x *Message9182) GetField9217() []*Message9181 {
+	if x != nil {
+		return x.Field9217
+	}
+	return nil
+}
+
+func (x *Message9182) GetField9218() bool {
+	if x != nil && x.Field9218 != nil {
+		return *x.Field9218
+	}
+	return false
+}
+
+func (x *Message9182) GetField9219() bool {
+	if x != nil && x.Field9219 != nil {
+		return *x.Field9219
+	}
+	return false
+}
+
+func (x *Message9182) GetField9220() bool {
+	if x != nil && x.Field9220 != nil {
+		return *x.Field9220
+	}
+	return false
+}
+
+func (x *Message9182) GetField9221() *Message9164 {
+	if x != nil {
+		return x.Field9221
+	}
+	return nil
+}
+
+func (x *Message9182) GetField9222() *Message9165 {
+	if x != nil {
+		return x.Field9222
+	}
+	return nil
+}
+
+func (x *Message9182) GetField9223() *Message9166 {
+	if x != nil {
+		return x.Field9223
+	}
+	return nil
+}
+
+func (x *Message9182) GetField9224() float32 {
+	if x != nil && x.Field9224 != nil {
+		return *x.Field9224
+	}
+	return 0
+}
+
+func (x *Message9182) GetField9225() *Message9151 {
+	if x != nil {
+		return x.Field9225
+	}
+	return nil
+}
+
+func (x *Message9182) GetField9226() float32 {
+	if x != nil && x.Field9226 != nil {
+		return *x.Field9226
+	}
+	return 0
+}
+
+func (x *Message9182) GetField9227() float32 {
+	if x != nil && x.Field9227 != nil {
+		return *x.Field9227
+	}
+	return 0
+}
+
+func (x *Message9182) GetField9228() float32 {
+	if x != nil && x.Field9228 != nil {
+		return *x.Field9228
+	}
+	return 0
+}
+
+func (x *Message9182) GetField9229() float32 {
+	if x != nil && x.Field9229 != nil {
+		return *x.Field9229
+	}
+	return 0
+}
+
+func (x *Message9182) GetField9230() float32 {
+	if x != nil && x.Field9230 != nil {
+		return *x.Field9230
+	}
+	return 0
+}
+
+type Message9160 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field9161 *int32 `protobuf:"varint,1,opt,name=field9161" json:"field9161,omitempty"`
+	Field9162 []byte `protobuf:"bytes,2,opt,name=field9162" json:"field9162,omitempty"`
+}
+
+func (x *Message9160) Reset() {
+	*x = Message9160{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message9160) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message9160) ProtoMessage() {}
+
+func (x *Message9160) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message9160.ProtoReflect.Descriptor instead.
+func (*Message9160) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *Message9160) GetField9161() int32 {
+	if x != nil && x.Field9161 != nil {
+		return *x.Field9161
+	}
+	return 0
+}
+
+func (x *Message9160) GetField9162() []byte {
+	if x != nil {
+		return x.Field9162
+	}
+	return nil
+}
+
+type Message9242 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field9327 []Enum9243 `protobuf:"varint,1,rep,name=field9327,enum=benchmarks.google_message3.Enum9243" json:"field9327,omitempty"`
+}
+
+func (x *Message9242) Reset() {
+	*x = Message9242{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[5]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message9242) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message9242) ProtoMessage() {}
+
+func (x *Message9242) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[5]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message9242.ProtoReflect.Descriptor instead.
+func (*Message9242) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *Message9242) GetField9327() []Enum9243 {
+	if x != nil {
+		return x.Field9327
+	}
+	return nil
+}
+
+type Message8890 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field8916 []*Message8888 `protobuf:"bytes,1,rep,name=field8916" json:"field8916,omitempty"`
+}
+
+func (x *Message8890) Reset() {
+	*x = Message8890{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[6]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8890) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8890) ProtoMessage() {}
+
+func (x *Message8890) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[6]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8890.ProtoReflect.Descriptor instead.
+func (*Message8890) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *Message8890) GetField8916() []*Message8888 {
+	if x != nil {
+		return x.Field8916
+	}
+	return nil
+}
+
+type Message9123 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field9135 *float32 `protobuf:"fixed32,1,opt,name=field9135" json:"field9135,omitempty"`
+}
+
+func (x *Message9123) Reset() {
+	*x = Message9123{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[7]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message9123) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message9123) ProtoMessage() {}
+
+func (x *Message9123) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[7]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message9123.ProtoReflect.Descriptor instead.
+func (*Message9123) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *Message9123) GetField9135() float32 {
+	if x != nil && x.Field9135 != nil {
+		return *x.Field9135
+	}
+	return 0
+}
+
+type Message9628 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field9673 *Message9627 `protobuf:"bytes,1,opt,name=field9673" json:"field9673,omitempty"`
+	Field9674 *string      `protobuf:"bytes,2,opt,name=field9674" json:"field9674,omitempty"`
+	Field9675 []int32      `protobuf:"varint,3,rep,name=field9675" json:"field9675,omitempty"`
+	Field9676 *int32       `protobuf:"varint,4,opt,name=field9676" json:"field9676,omitempty"`
+}
+
+func (x *Message9628) Reset() {
+	*x = Message9628{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[8]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message9628) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message9628) ProtoMessage() {}
+
+func (x *Message9628) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[8]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message9628.ProtoReflect.Descriptor instead.
+func (*Message9628) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *Message9628) GetField9673() *Message9627 {
+	if x != nil {
+		return x.Field9673
+	}
+	return nil
+}
+
+func (x *Message9628) GetField9674() string {
+	if x != nil && x.Field9674 != nil {
+		return *x.Field9674
+	}
+	return ""
+}
+
+func (x *Message9628) GetField9675() []int32 {
+	if x != nil {
+		return x.Field9675
+	}
+	return nil
+}
+
+func (x *Message9628) GetField9676() int32 {
+	if x != nil && x.Field9676 != nil {
+		return *x.Field9676
+	}
+	return 0
+}
+
+type Message11014 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field11780 *int32                `protobuf:"varint,40,opt,name=field11780" json:"field11780,omitempty"`
+	Field11781 *string               `protobuf:"bytes,46,opt,name=field11781" json:"field11781,omitempty"`
+	Field11782 *bool                 `protobuf:"varint,47,opt,name=field11782" json:"field11782,omitempty"`
+	Field11783 *Enum11107            `protobuf:"varint,1,opt,name=field11783,enum=benchmarks.google_message3.Enum11107" json:"field11783,omitempty"`
+	Field11784 *int32                `protobuf:"varint,2,opt,name=field11784" json:"field11784,omitempty"`
+	Field11785 *float64              `protobuf:"fixed64,4,opt,name=field11785" json:"field11785,omitempty"`
+	Field11786 *int32                `protobuf:"varint,5,opt,name=field11786" json:"field11786,omitempty"`
+	Field11787 *int32                `protobuf:"varint,6,opt,name=field11787" json:"field11787,omitempty"`
+	Field11788 *float64              `protobuf:"fixed64,7,opt,name=field11788" json:"field11788,omitempty"`
+	Field11789 *float64              `protobuf:"fixed64,8,opt,name=field11789" json:"field11789,omitempty"`
+	Field11790 *int64                `protobuf:"varint,9,opt,name=field11790" json:"field11790,omitempty"`
+	Field11791 *bool                 `protobuf:"varint,10,opt,name=field11791" json:"field11791,omitempty"`
+	Field11792 *int64                `protobuf:"varint,28,opt,name=field11792" json:"field11792,omitempty"`
+	Field11793 *bool                 `protobuf:"varint,37,opt,name=field11793" json:"field11793,omitempty"`
+	Field11794 *Enum11541            `protobuf:"varint,44,opt,name=field11794,enum=benchmarks.google_message3.Enum11541" json:"field11794,omitempty"`
+	Field11795 *float64              `protobuf:"fixed64,49,opt,name=field11795" json:"field11795,omitempty"`
+	Field11796 *float64              `protobuf:"fixed64,51,opt,name=field11796" json:"field11796,omitempty"`
+	Field11797 *int64                `protobuf:"varint,54,opt,name=field11797" json:"field11797,omitempty"`
+	Field11798 *int64                `protobuf:"varint,55,opt,name=field11798" json:"field11798,omitempty"`
+	Field11799 *UnusedEnum           `protobuf:"varint,57,opt,name=field11799,enum=benchmarks.google_message3.UnusedEnum" json:"field11799,omitempty"`
+	Field11800 *Enum11468            `protobuf:"varint,58,opt,name=field11800,enum=benchmarks.google_message3.Enum11468" json:"field11800,omitempty"`
+	Field11801 *int32                `protobuf:"varint,59,opt,name=field11801" json:"field11801,omitempty"`
+	Field11802 *UnusedEnum           `protobuf:"varint,60,opt,name=field11802,enum=benchmarks.google_message3.UnusedEnum" json:"field11802,omitempty"`
+	Field11803 *int32                `protobuf:"varint,61,opt,name=field11803" json:"field11803,omitempty"`
+	Field11804 *int32                `protobuf:"varint,62,opt,name=field11804" json:"field11804,omitempty"`
+	Field11805 *int32                `protobuf:"varint,69,opt,name=field11805" json:"field11805,omitempty"`
+	Field11806 *UnusedEmptyMessage   `protobuf:"bytes,68,opt,name=field11806" json:"field11806,omitempty"`
+	Field11807 []*Message11018       `protobuf:"bytes,71,rep,name=field11807" json:"field11807,omitempty"`
+	Field11808 *bool                 `protobuf:"varint,50,opt,name=field11808" json:"field11808,omitempty"`
+	Field11809 *bool                 `protobuf:"varint,56,opt,name=field11809" json:"field11809,omitempty"`
+	Field11810 *bool                 `protobuf:"varint,66,opt,name=field11810" json:"field11810,omitempty"`
+	Field11811 *bool                 `protobuf:"varint,63,opt,name=field11811" json:"field11811,omitempty"`
+	Field11812 *bool                 `protobuf:"varint,64,opt,name=field11812" json:"field11812,omitempty"`
+	Field11813 *bool                 `protobuf:"varint,65,opt,name=field11813" json:"field11813,omitempty"`
+	Field11814 *bool                 `protobuf:"varint,67,opt,name=field11814" json:"field11814,omitempty"`
+	Field11815 *Enum11107            `protobuf:"varint,15,opt,name=field11815,enum=benchmarks.google_message3.Enum11107" json:"field11815,omitempty"`
+	Field11816 *int64                `protobuf:"varint,16,opt,name=field11816" json:"field11816,omitempty"`
+	Field11817 *float64              `protobuf:"fixed64,17,opt,name=field11817" json:"field11817,omitempty"`
+	Field11818 *int64                `protobuf:"varint,18,opt,name=field11818" json:"field11818,omitempty"`
+	Field11819 *int32                `protobuf:"varint,19,opt,name=field11819" json:"field11819,omitempty"`
+	Field11820 *int64                `protobuf:"varint,20,opt,name=field11820" json:"field11820,omitempty"`
+	Field11821 *int32                `protobuf:"varint,42,opt,name=field11821" json:"field11821,omitempty"`
+	Field11822 *int64                `protobuf:"varint,52,opt,name=field11822" json:"field11822,omitempty"`
+	Field11823 *int64                `protobuf:"varint,53,opt,name=field11823" json:"field11823,omitempty"`
+	Field11824 *int64                `protobuf:"varint,41,opt,name=field11824" json:"field11824,omitempty"`
+	Field11825 *float64              `protobuf:"fixed64,48,opt,name=field11825" json:"field11825,omitempty"`
+	Field11826 []*Message11020       `protobuf:"bytes,70,rep,name=field11826" json:"field11826,omitempty"`
+	Field11827 []*UnusedEmptyMessage `protobuf:"bytes,72,rep,name=field11827" json:"field11827,omitempty"`
+	Field11828 *float64              `protobuf:"fixed64,25,opt,name=field11828" json:"field11828,omitempty"`
+	Field11829 *string               `protobuf:"bytes,26,opt,name=field11829" json:"field11829,omitempty"`
+	Field11830 *int64                `protobuf:"varint,27,opt,name=field11830" json:"field11830,omitempty"`
+	Field11831 *int64                `protobuf:"varint,32,opt,name=field11831" json:"field11831,omitempty"`
+	Field11832 *uint64               `protobuf:"varint,33,opt,name=field11832" json:"field11832,omitempty"`
+	Field11833 *bool                 `protobuf:"varint,29,opt,name=field11833" json:"field11833,omitempty"`
+	Field11834 *bool                 `protobuf:"varint,34,opt,name=field11834" json:"field11834,omitempty"`
+	Field11835 *string               `protobuf:"bytes,30,opt,name=field11835" json:"field11835,omitempty"`
+	Field11836 *int32                `protobuf:"varint,3,opt,name=field11836" json:"field11836,omitempty"`
+	Field11837 *int32                `protobuf:"varint,31,opt,name=field11837" json:"field11837,omitempty"`
+	Field11838 *int32                `protobuf:"varint,73,opt,name=field11838" json:"field11838,omitempty"`
+	Field11839 *int32                `protobuf:"varint,35,opt,name=field11839" json:"field11839,omitempty"`
+	Field11840 *Enum11022            `protobuf:"varint,36,opt,name=field11840,enum=benchmarks.google_message3.Enum11022" json:"field11840,omitempty"`
+	Field11841 *Message11013         `protobuf:"bytes,38,opt,name=field11841" json:"field11841,omitempty"`
+	Field11842 *float64              `protobuf:"fixed64,39,opt,name=field11842" json:"field11842,omitempty"`
+	Field11843 *int32                `protobuf:"varint,45,opt,name=field11843" json:"field11843,omitempty"`
+	Field11844 *bool                 `protobuf:"varint,74,opt,name=field11844" json:"field11844,omitempty"`
+}
+
+func (x *Message11014) Reset() {
+	*x = Message11014{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[9]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message11014) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message11014) ProtoMessage() {}
+
+func (x *Message11014) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[9]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message11014.ProtoReflect.Descriptor instead.
+func (*Message11014) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{9}
+}
+
+func (x *Message11014) GetField11780() int32 {
+	if x != nil && x.Field11780 != nil {
+		return *x.Field11780
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11781() string {
+	if x != nil && x.Field11781 != nil {
+		return *x.Field11781
+	}
+	return ""
+}
+
+func (x *Message11014) GetField11782() bool {
+	if x != nil && x.Field11782 != nil {
+		return *x.Field11782
+	}
+	return false
+}
+
+func (x *Message11014) GetField11783() Enum11107 {
+	if x != nil && x.Field11783 != nil {
+		return *x.Field11783
+	}
+	return Enum11107_ENUM_VALUE11108
+}
+
+func (x *Message11014) GetField11784() int32 {
+	if x != nil && x.Field11784 != nil {
+		return *x.Field11784
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11785() float64 {
+	if x != nil && x.Field11785 != nil {
+		return *x.Field11785
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11786() int32 {
+	if x != nil && x.Field11786 != nil {
+		return *x.Field11786
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11787() int32 {
+	if x != nil && x.Field11787 != nil {
+		return *x.Field11787
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11788() float64 {
+	if x != nil && x.Field11788 != nil {
+		return *x.Field11788
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11789() float64 {
+	if x != nil && x.Field11789 != nil {
+		return *x.Field11789
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11790() int64 {
+	if x != nil && x.Field11790 != nil {
+		return *x.Field11790
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11791() bool {
+	if x != nil && x.Field11791 != nil {
+		return *x.Field11791
+	}
+	return false
+}
+
+func (x *Message11014) GetField11792() int64 {
+	if x != nil && x.Field11792 != nil {
+		return *x.Field11792
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11793() bool {
+	if x != nil && x.Field11793 != nil {
+		return *x.Field11793
+	}
+	return false
+}
+
+func (x *Message11014) GetField11794() Enum11541 {
+	if x != nil && x.Field11794 != nil {
+		return *x.Field11794
+	}
+	return Enum11541_ENUM_VALUE11542
+}
+
+func (x *Message11014) GetField11795() float64 {
+	if x != nil && x.Field11795 != nil {
+		return *x.Field11795
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11796() float64 {
+	if x != nil && x.Field11796 != nil {
+		return *x.Field11796
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11797() int64 {
+	if x != nil && x.Field11797 != nil {
+		return *x.Field11797
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11798() int64 {
+	if x != nil && x.Field11798 != nil {
+		return *x.Field11798
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11799() UnusedEnum {
+	if x != nil && x.Field11799 != nil {
+		return *x.Field11799
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+func (x *Message11014) GetField11800() Enum11468 {
+	if x != nil && x.Field11800 != nil {
+		return *x.Field11800
+	}
+	return Enum11468_ENUM_VALUE11469
+}
+
+func (x *Message11014) GetField11801() int32 {
+	if x != nil && x.Field11801 != nil {
+		return *x.Field11801
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11802() UnusedEnum {
+	if x != nil && x.Field11802 != nil {
+		return *x.Field11802
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+func (x *Message11014) GetField11803() int32 {
+	if x != nil && x.Field11803 != nil {
+		return *x.Field11803
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11804() int32 {
+	if x != nil && x.Field11804 != nil {
+		return *x.Field11804
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11805() int32 {
+	if x != nil && x.Field11805 != nil {
+		return *x.Field11805
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11806() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field11806
+	}
+	return nil
+}
+
+func (x *Message11014) GetField11807() []*Message11018 {
+	if x != nil {
+		return x.Field11807
+	}
+	return nil
+}
+
+func (x *Message11014) GetField11808() bool {
+	if x != nil && x.Field11808 != nil {
+		return *x.Field11808
+	}
+	return false
+}
+
+func (x *Message11014) GetField11809() bool {
+	if x != nil && x.Field11809 != nil {
+		return *x.Field11809
+	}
+	return false
+}
+
+func (x *Message11014) GetField11810() bool {
+	if x != nil && x.Field11810 != nil {
+		return *x.Field11810
+	}
+	return false
+}
+
+func (x *Message11014) GetField11811() bool {
+	if x != nil && x.Field11811 != nil {
+		return *x.Field11811
+	}
+	return false
+}
+
+func (x *Message11014) GetField11812() bool {
+	if x != nil && x.Field11812 != nil {
+		return *x.Field11812
+	}
+	return false
+}
+
+func (x *Message11014) GetField11813() bool {
+	if x != nil && x.Field11813 != nil {
+		return *x.Field11813
+	}
+	return false
+}
+
+func (x *Message11014) GetField11814() bool {
+	if x != nil && x.Field11814 != nil {
+		return *x.Field11814
+	}
+	return false
+}
+
+func (x *Message11014) GetField11815() Enum11107 {
+	if x != nil && x.Field11815 != nil {
+		return *x.Field11815
+	}
+	return Enum11107_ENUM_VALUE11108
+}
+
+func (x *Message11014) GetField11816() int64 {
+	if x != nil && x.Field11816 != nil {
+		return *x.Field11816
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11817() float64 {
+	if x != nil && x.Field11817 != nil {
+		return *x.Field11817
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11818() int64 {
+	if x != nil && x.Field11818 != nil {
+		return *x.Field11818
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11819() int32 {
+	if x != nil && x.Field11819 != nil {
+		return *x.Field11819
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11820() int64 {
+	if x != nil && x.Field11820 != nil {
+		return *x.Field11820
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11821() int32 {
+	if x != nil && x.Field11821 != nil {
+		return *x.Field11821
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11822() int64 {
+	if x != nil && x.Field11822 != nil {
+		return *x.Field11822
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11823() int64 {
+	if x != nil && x.Field11823 != nil {
+		return *x.Field11823
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11824() int64 {
+	if x != nil && x.Field11824 != nil {
+		return *x.Field11824
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11825() float64 {
+	if x != nil && x.Field11825 != nil {
+		return *x.Field11825
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11826() []*Message11020 {
+	if x != nil {
+		return x.Field11826
+	}
+	return nil
+}
+
+func (x *Message11014) GetField11827() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field11827
+	}
+	return nil
+}
+
+func (x *Message11014) GetField11828() float64 {
+	if x != nil && x.Field11828 != nil {
+		return *x.Field11828
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11829() string {
+	if x != nil && x.Field11829 != nil {
+		return *x.Field11829
+	}
+	return ""
+}
+
+func (x *Message11014) GetField11830() int64 {
+	if x != nil && x.Field11830 != nil {
+		return *x.Field11830
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11831() int64 {
+	if x != nil && x.Field11831 != nil {
+		return *x.Field11831
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11832() uint64 {
+	if x != nil && x.Field11832 != nil {
+		return *x.Field11832
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11833() bool {
+	if x != nil && x.Field11833 != nil {
+		return *x.Field11833
+	}
+	return false
+}
+
+func (x *Message11014) GetField11834() bool {
+	if x != nil && x.Field11834 != nil {
+		return *x.Field11834
+	}
+	return false
+}
+
+func (x *Message11014) GetField11835() string {
+	if x != nil && x.Field11835 != nil {
+		return *x.Field11835
+	}
+	return ""
+}
+
+func (x *Message11014) GetField11836() int32 {
+	if x != nil && x.Field11836 != nil {
+		return *x.Field11836
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11837() int32 {
+	if x != nil && x.Field11837 != nil {
+		return *x.Field11837
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11838() int32 {
+	if x != nil && x.Field11838 != nil {
+		return *x.Field11838
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11839() int32 {
+	if x != nil && x.Field11839 != nil {
+		return *x.Field11839
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11840() Enum11022 {
+	if x != nil && x.Field11840 != nil {
+		return *x.Field11840
+	}
+	return Enum11022_ENUM_VALUE11023
+}
+
+func (x *Message11014) GetField11841() *Message11013 {
+	if x != nil {
+		return x.Field11841
+	}
+	return nil
+}
+
+func (x *Message11014) GetField11842() float64 {
+	if x != nil && x.Field11842 != nil {
+		return *x.Field11842
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11843() int32 {
+	if x != nil && x.Field11843 != nil {
+		return *x.Field11843
+	}
+	return 0
+}
+
+func (x *Message11014) GetField11844() bool {
+	if x != nil && x.Field11844 != nil {
+		return *x.Field11844
+	}
+	return false
+}
+
+type Message10801 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field10812 *Message10800   `protobuf:"bytes,1,opt,name=field10812" json:"field10812,omitempty"`
+	Field10813 []*Message10802 `protobuf:"bytes,2,rep,name=field10813" json:"field10813,omitempty"`
+	Field10814 *int32          `protobuf:"varint,3,opt,name=field10814" json:"field10814,omitempty"`
+}
+
+func (x *Message10801) Reset() {
+	*x = Message10801{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[10]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message10801) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message10801) ProtoMessage() {}
+
+func (x *Message10801) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[10]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message10801.ProtoReflect.Descriptor instead.
+func (*Message10801) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{10}
+}
+
+func (x *Message10801) GetField10812() *Message10800 {
+	if x != nil {
+		return x.Field10812
+	}
+	return nil
+}
+
+func (x *Message10801) GetField10813() []*Message10802 {
+	if x != nil {
+		return x.Field10813
+	}
+	return nil
+}
+
+func (x *Message10801) GetField10814() int32 {
+	if x != nil && x.Field10814 != nil {
+		return *x.Field10814
+	}
+	return 0
+}
+
+type Message10749 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field10754 []*Message10748 `protobuf:"bytes,1,rep,name=field10754" json:"field10754,omitempty"`
+}
+
+func (x *Message10749) Reset() {
+	*x = Message10749{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[11]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message10749) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message10749) ProtoMessage() {}
+
+func (x *Message10749) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[11]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message10749.ProtoReflect.Descriptor instead.
+func (*Message10749) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{11}
+}
+
+func (x *Message10749) GetField10754() []*Message10748 {
+	if x != nil {
+		return x.Field10754
+	}
+	return nil
+}
+
+type Message8298 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field8321 *Message7966 `protobuf:"bytes,1,opt,name=field8321" json:"field8321,omitempty"`
+	Field8322 *int64       `protobuf:"varint,2,opt,name=field8322" json:"field8322,omitempty"`
+	Field8323 *string      `protobuf:"bytes,3,opt,name=field8323" json:"field8323,omitempty"`
+}
+
+func (x *Message8298) Reset() {
+	*x = Message8298{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[12]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8298) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8298) ProtoMessage() {}
+
+func (x *Message8298) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[12]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8298.ProtoReflect.Descriptor instead.
+func (*Message8298) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{12}
+}
+
+func (x *Message8298) GetField8321() *Message7966 {
+	if x != nil {
+		return x.Field8321
+	}
+	return nil
+}
+
+func (x *Message8298) GetField8322() int64 {
+	if x != nil && x.Field8322 != nil {
+		return *x.Field8322
+	}
+	return 0
+}
+
+func (x *Message8298) GetField8323() string {
+	if x != nil && x.Field8323 != nil {
+		return *x.Field8323
+	}
+	return ""
+}
+
+type Message8300 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field8326 *string      `protobuf:"bytes,1,opt,name=field8326" json:"field8326,omitempty"`
+	Field8327 *Message7966 `protobuf:"bytes,2,opt,name=field8327" json:"field8327,omitempty"`
+}
+
+func (x *Message8300) Reset() {
+	*x = Message8300{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[13]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8300) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8300) ProtoMessage() {}
+
+func (x *Message8300) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[13]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8300.ProtoReflect.Descriptor instead.
+func (*Message8300) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{13}
+}
+
+func (x *Message8300) GetField8326() string {
+	if x != nil && x.Field8326 != nil {
+		return *x.Field8326
+	}
+	return ""
+}
+
+func (x *Message8300) GetField8327() *Message7966 {
+	if x != nil {
+		return x.Field8327
+	}
+	return nil
+}
+
+type Message8291 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field8306 *string   `protobuf:"bytes,1,opt,name=field8306" json:"field8306,omitempty"`
+	Field8307 *int32    `protobuf:"varint,2,opt,name=field8307" json:"field8307,omitempty"`
+	Field8308 *string   `protobuf:"bytes,3,opt,name=field8308" json:"field8308,omitempty"`
+	Field8309 *string   `protobuf:"bytes,4,opt,name=field8309" json:"field8309,omitempty"`
+	Field8310 *Enum8292 `protobuf:"varint,5,opt,name=field8310,enum=benchmarks.google_message3.Enum8292" json:"field8310,omitempty"`
+}
+
+func (x *Message8291) Reset() {
+	*x = Message8291{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[14]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8291) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8291) ProtoMessage() {}
+
+func (x *Message8291) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[14]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8291.ProtoReflect.Descriptor instead.
+func (*Message8291) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{14}
+}
+
+func (x *Message8291) GetField8306() string {
+	if x != nil && x.Field8306 != nil {
+		return *x.Field8306
+	}
+	return ""
+}
+
+func (x *Message8291) GetField8307() int32 {
+	if x != nil && x.Field8307 != nil {
+		return *x.Field8307
+	}
+	return 0
+}
+
+func (x *Message8291) GetField8308() string {
+	if x != nil && x.Field8308 != nil {
+		return *x.Field8308
+	}
+	return ""
+}
+
+func (x *Message8291) GetField8309() string {
+	if x != nil && x.Field8309 != nil {
+		return *x.Field8309
+	}
+	return ""
+}
+
+func (x *Message8291) GetField8310() Enum8292 {
+	if x != nil && x.Field8310 != nil {
+		return *x.Field8310
+	}
+	return Enum8292_ENUM_VALUE8293
+}
+
+type Message8296 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field8311 *Message7966 `protobuf:"bytes,1,opt,name=field8311" json:"field8311,omitempty"`
+	Field8312 *string      `protobuf:"bytes,2,opt,name=field8312" json:"field8312,omitempty"`
+	Field8313 *Message7966 `protobuf:"bytes,3,opt,name=field8313" json:"field8313,omitempty"`
+	Field8314 *int32       `protobuf:"varint,4,opt,name=field8314" json:"field8314,omitempty"`
+	Field8315 *int32       `protobuf:"varint,5,opt,name=field8315" json:"field8315,omitempty"`
+	Field8316 *string      `protobuf:"bytes,6,opt,name=field8316" json:"field8316,omitempty"`
+}
+
+func (x *Message8296) Reset() {
+	*x = Message8296{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[15]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8296) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8296) ProtoMessage() {}
+
+func (x *Message8296) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[15]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8296.ProtoReflect.Descriptor instead.
+func (*Message8296) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{15}
+}
+
+func (x *Message8296) GetField8311() *Message7966 {
+	if x != nil {
+		return x.Field8311
+	}
+	return nil
+}
+
+func (x *Message8296) GetField8312() string {
+	if x != nil && x.Field8312 != nil {
+		return *x.Field8312
+	}
+	return ""
+}
+
+func (x *Message8296) GetField8313() *Message7966 {
+	if x != nil {
+		return x.Field8313
+	}
+	return nil
+}
+
+func (x *Message8296) GetField8314() int32 {
+	if x != nil && x.Field8314 != nil {
+		return *x.Field8314
+	}
+	return 0
+}
+
+func (x *Message8296) GetField8315() int32 {
+	if x != nil && x.Field8315 != nil {
+		return *x.Field8315
+	}
+	return 0
+}
+
+func (x *Message8296) GetField8316() string {
+	if x != nil && x.Field8316 != nil {
+		return *x.Field8316
+	}
+	return ""
+}
+
+type Message7965 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field7967 *int32 `protobuf:"varint,1,opt,name=field7967" json:"field7967,omitempty"`
+	Field7968 *int32 `protobuf:"varint,2,opt,name=field7968" json:"field7968,omitempty"`
+}
+
+func (x *Message7965) Reset() {
+	*x = Message7965{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[16]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message7965) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message7965) ProtoMessage() {}
+
+func (x *Message7965) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[16]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message7965.ProtoReflect.Descriptor instead.
+func (*Message7965) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{16}
+}
+
+func (x *Message7965) GetField7967() int32 {
+	if x != nil && x.Field7967 != nil {
+		return *x.Field7967
+	}
+	return 0
+}
+
+func (x *Message7965) GetField7968() int32 {
+	if x != nil && x.Field7968 != nil {
+		return *x.Field7968
+	}
+	return 0
+}
+
+type Message8290 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field8304 *string `protobuf:"bytes,1,opt,name=field8304" json:"field8304,omitempty"`
+	Field8305 *string `protobuf:"bytes,2,opt,name=field8305" json:"field8305,omitempty"`
+}
+
+func (x *Message8290) Reset() {
+	*x = Message8290{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[17]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8290) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8290) ProtoMessage() {}
+
+func (x *Message8290) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[17]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8290.ProtoReflect.Descriptor instead.
+func (*Message8290) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{17}
+}
+
+func (x *Message8290) GetField8304() string {
+	if x != nil && x.Field8304 != nil {
+		return *x.Field8304
+	}
+	return ""
+}
+
+func (x *Message8290) GetField8305() string {
+	if x != nil && x.Field8305 != nil {
+		return *x.Field8305
+	}
+	return ""
+}
+
+type Message717 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field876 []string `protobuf:"bytes,1,rep,name=field876" json:"field876,omitempty"`
+	Field877 *float64 `protobuf:"fixed64,2,opt,name=field877" json:"field877,omitempty"`
+}
+
+func (x *Message717) Reset() {
+	*x = Message717{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[18]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message717) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message717) ProtoMessage() {}
+
+func (x *Message717) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[18]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message717.ProtoReflect.Descriptor instead.
+func (*Message717) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{18}
+}
+
+func (x *Message717) GetField876() []string {
+	if x != nil {
+		return x.Field876
+	}
+	return nil
+}
+
+func (x *Message717) GetField877() float64 {
+	if x != nil && x.Field877 != nil {
+		return *x.Field877
+	}
+	return 0
+}
+
+type Message713 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field852 *Message708 `protobuf:"bytes,1,req,name=field852" json:"field852,omitempty"`
+	Field853 []string    `protobuf:"bytes,2,rep,name=field853" json:"field853,omitempty"`
+}
+
+func (x *Message713) Reset() {
+	*x = Message713{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[19]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message713) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message713) ProtoMessage() {}
+
+func (x *Message713) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[19]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message713.ProtoReflect.Descriptor instead.
+func (*Message713) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{19}
+}
+
+func (x *Message713) GetField852() *Message708 {
+	if x != nil {
+		return x.Field852
+	}
+	return nil
+}
+
+func (x *Message713) GetField853() []string {
+	if x != nil {
+		return x.Field853
+	}
+	return nil
+}
+
+type Message705 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field807 *string  `protobuf:"bytes,1,req,name=field807" json:"field807,omitempty"`
+	Field808 *string  `protobuf:"bytes,2,opt,name=field808" json:"field808,omitempty"`
+	Field809 *string  `protobuf:"bytes,3,opt,name=field809" json:"field809,omitempty"`
+	Field810 *bool    `protobuf:"varint,4,opt,name=field810" json:"field810,omitempty"`
+	Field811 *string  `protobuf:"bytes,5,opt,name=field811" json:"field811,omitempty"`
+	Field812 *string  `protobuf:"bytes,6,opt,name=field812" json:"field812,omitempty"`
+	Field813 []string `protobuf:"bytes,7,rep,name=field813" json:"field813,omitempty"`
+}
+
+func (x *Message705) Reset() {
+	*x = Message705{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[20]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message705) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message705) ProtoMessage() {}
+
+func (x *Message705) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[20]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message705.ProtoReflect.Descriptor instead.
+func (*Message705) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{20}
+}
+
+func (x *Message705) GetField807() string {
+	if x != nil && x.Field807 != nil {
+		return *x.Field807
+	}
+	return ""
+}
+
+func (x *Message705) GetField808() string {
+	if x != nil && x.Field808 != nil {
+		return *x.Field808
+	}
+	return ""
+}
+
+func (x *Message705) GetField809() string {
+	if x != nil && x.Field809 != nil {
+		return *x.Field809
+	}
+	return ""
+}
+
+func (x *Message705) GetField810() bool {
+	if x != nil && x.Field810 != nil {
+		return *x.Field810
+	}
+	return false
+}
+
+func (x *Message705) GetField811() string {
+	if x != nil && x.Field811 != nil {
+		return *x.Field811
+	}
+	return ""
+}
+
+func (x *Message705) GetField812() string {
+	if x != nil && x.Field812 != nil {
+		return *x.Field812
+	}
+	return ""
+}
+
+func (x *Message705) GetField813() []string {
+	if x != nil {
+		return x.Field813
+	}
+	return nil
+}
+
+type Message709 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field829 []string `protobuf:"bytes,1,rep,name=field829" json:"field829,omitempty"`
+	Field830 []string `protobuf:"bytes,2,rep,name=field830" json:"field830,omitempty"`
+	Field831 []string `protobuf:"bytes,3,rep,name=field831" json:"field831,omitempty"`
+	Field832 []string `protobuf:"bytes,4,rep,name=field832" json:"field832,omitempty"`
+	Field833 []string `protobuf:"bytes,5,rep,name=field833" json:"field833,omitempty"`
+}
+
+func (x *Message709) Reset() {
+	*x = Message709{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[21]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message709) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message709) ProtoMessage() {}
+
+func (x *Message709) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[21]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message709.ProtoReflect.Descriptor instead.
+func (*Message709) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{21}
+}
+
+func (x *Message709) GetField829() []string {
+	if x != nil {
+		return x.Field829
+	}
+	return nil
+}
+
+func (x *Message709) GetField830() []string {
+	if x != nil {
+		return x.Field830
+	}
+	return nil
+}
+
+func (x *Message709) GetField831() []string {
+	if x != nil {
+		return x.Field831
+	}
+	return nil
+}
+
+func (x *Message709) GetField832() []string {
+	if x != nil {
+		return x.Field832
+	}
+	return nil
+}
+
+func (x *Message709) GetField833() []string {
+	if x != nil {
+		return x.Field833
+	}
+	return nil
+}
+
+type Message702 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field793 *string `protobuf:"bytes,1,opt,name=field793" json:"field793,omitempty"`
+	Field794 *string `protobuf:"bytes,2,opt,name=field794" json:"field794,omitempty"`
+}
+
+func (x *Message702) Reset() {
+	*x = Message702{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[22]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message702) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message702) ProtoMessage() {}
+
+func (x *Message702) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[22]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message702.ProtoReflect.Descriptor instead.
+func (*Message702) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{22}
+}
+
+func (x *Message702) GetField793() string {
+	if x != nil && x.Field793 != nil {
+		return *x.Field793
+	}
+	return ""
+}
+
+func (x *Message702) GetField794() string {
+	if x != nil && x.Field794 != nil {
+		return *x.Field794
+	}
+	return ""
+}
+
+type Message714 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field854 *string `protobuf:"bytes,1,opt,name=field854" json:"field854,omitempty"`
+	Field855 *string `protobuf:"bytes,2,opt,name=field855" json:"field855,omitempty"`
+	Field856 *string `protobuf:"bytes,3,opt,name=field856" json:"field856,omitempty"`
+	Field857 *string `protobuf:"bytes,4,opt,name=field857" json:"field857,omitempty"`
+	Field858 *uint32 `protobuf:"varint,5,opt,name=field858" json:"field858,omitempty"`
+}
+
+func (x *Message714) Reset() {
+	*x = Message714{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[23]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message714) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message714) ProtoMessage() {}
+
+func (x *Message714) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[23]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message714.ProtoReflect.Descriptor instead.
+func (*Message714) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{23}
+}
+
+func (x *Message714) GetField854() string {
+	if x != nil && x.Field854 != nil {
+		return *x.Field854
+	}
+	return ""
+}
+
+func (x *Message714) GetField855() string {
+	if x != nil && x.Field855 != nil {
+		return *x.Field855
+	}
+	return ""
+}
+
+func (x *Message714) GetField856() string {
+	if x != nil && x.Field856 != nil {
+		return *x.Field856
+	}
+	return ""
+}
+
+func (x *Message714) GetField857() string {
+	if x != nil && x.Field857 != nil {
+		return *x.Field857
+	}
+	return ""
+}
+
+func (x *Message714) GetField858() uint32 {
+	if x != nil && x.Field858 != nil {
+		return *x.Field858
+	}
+	return 0
+}
+
+type Message710 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field834 []string `protobuf:"bytes,1,rep,name=field834" json:"field834,omitempty"`
+	Field835 *string  `protobuf:"bytes,2,opt,name=field835" json:"field835,omitempty"`
+	Field836 *string  `protobuf:"bytes,3,opt,name=field836" json:"field836,omitempty"`
+	Field837 []string `protobuf:"bytes,4,rep,name=field837" json:"field837,omitempty"`
+	Field838 []string `protobuf:"bytes,5,rep,name=field838" json:"field838,omitempty"`
+}
+
+func (x *Message710) Reset() {
+	*x = Message710{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[24]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message710) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message710) ProtoMessage() {}
+
+func (x *Message710) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[24]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message710.ProtoReflect.Descriptor instead.
+func (*Message710) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{24}
+}
+
+func (x *Message710) GetField834() []string {
+	if x != nil {
+		return x.Field834
+	}
+	return nil
+}
+
+func (x *Message710) GetField835() string {
+	if x != nil && x.Field835 != nil {
+		return *x.Field835
+	}
+	return ""
+}
+
+func (x *Message710) GetField836() string {
+	if x != nil && x.Field836 != nil {
+		return *x.Field836
+	}
+	return ""
+}
+
+func (x *Message710) GetField837() []string {
+	if x != nil {
+		return x.Field837
+	}
+	return nil
+}
+
+func (x *Message710) GetField838() []string {
+	if x != nil {
+		return x.Field838
+	}
+	return nil
+}
+
+type Message706 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field814 []string `protobuf:"bytes,1,rep,name=field814" json:"field814,omitempty"`
+	Field815 *string  `protobuf:"bytes,2,opt,name=field815" json:"field815,omitempty"`
+	Field816 []string `protobuf:"bytes,3,rep,name=field816" json:"field816,omitempty"`
+	Field817 []string `protobuf:"bytes,4,rep,name=field817" json:"field817,omitempty"`
+}
+
+func (x *Message706) Reset() {
+	*x = Message706{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[25]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message706) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message706) ProtoMessage() {}
+
+func (x *Message706) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[25]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message706.ProtoReflect.Descriptor instead.
+func (*Message706) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{25}
+}
+
+func (x *Message706) GetField814() []string {
+	if x != nil {
+		return x.Field814
+	}
+	return nil
+}
+
+func (x *Message706) GetField815() string {
+	if x != nil && x.Field815 != nil {
+		return *x.Field815
+	}
+	return ""
+}
+
+func (x *Message706) GetField816() []string {
+	if x != nil {
+		return x.Field816
+	}
+	return nil
+}
+
+func (x *Message706) GetField817() []string {
+	if x != nil {
+		return x.Field817
+	}
+	return nil
+}
+
+type Message707 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field818 *string  `protobuf:"bytes,1,req,name=field818" json:"field818,omitempty"`
+	Field819 *string  `protobuf:"bytes,2,req,name=field819" json:"field819,omitempty"`
+	Field820 *string  `protobuf:"bytes,3,req,name=field820" json:"field820,omitempty"`
+	Field821 *bool    `protobuf:"varint,4,opt,name=field821" json:"field821,omitempty"`
+	Field822 []string `protobuf:"bytes,5,rep,name=field822" json:"field822,omitempty"`
+}
+
+func (x *Message707) Reset() {
+	*x = Message707{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[26]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message707) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message707) ProtoMessage() {}
+
+func (x *Message707) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[26]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message707.ProtoReflect.Descriptor instead.
+func (*Message707) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{26}
+}
+
+func (x *Message707) GetField818() string {
+	if x != nil && x.Field818 != nil {
+		return *x.Field818
+	}
+	return ""
+}
+
+func (x *Message707) GetField819() string {
+	if x != nil && x.Field819 != nil {
+		return *x.Field819
+	}
+	return ""
+}
+
+func (x *Message707) GetField820() string {
+	if x != nil && x.Field820 != nil {
+		return *x.Field820
+	}
+	return ""
+}
+
+func (x *Message707) GetField821() bool {
+	if x != nil && x.Field821 != nil {
+		return *x.Field821
+	}
+	return false
+}
+
+func (x *Message707) GetField822() []string {
+	if x != nil {
+		return x.Field822
+	}
+	return nil
+}
+
+type Message711 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field839 *UnusedEmptyMessage `protobuf:"bytes,1,opt,name=field839" json:"field839,omitempty"`
+	Field840 []string            `protobuf:"bytes,4,rep,name=field840" json:"field840,omitempty"`
+	Field841 []string            `protobuf:"bytes,2,rep,name=field841" json:"field841,omitempty"`
+	Field842 []string            `protobuf:"bytes,3,rep,name=field842" json:"field842,omitempty"`
+}
+
+func (x *Message711) Reset() {
+	*x = Message711{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[27]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message711) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message711) ProtoMessage() {}
+
+func (x *Message711) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[27]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message711.ProtoReflect.Descriptor instead.
+func (*Message711) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{27}
+}
+
+func (x *Message711) GetField839() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field839
+	}
+	return nil
+}
+
+func (x *Message711) GetField840() []string {
+	if x != nil {
+		return x.Field840
+	}
+	return nil
+}
+
+func (x *Message711) GetField841() []string {
+	if x != nil {
+		return x.Field841
+	}
+	return nil
+}
+
+func (x *Message711) GetField842() []string {
+	if x != nil {
+		return x.Field842
+	}
+	return nil
+}
+
+type Message712 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field843 []string `protobuf:"bytes,1,rep,name=field843" json:"field843,omitempty"`
+	Field844 *string  `protobuf:"bytes,2,req,name=field844" json:"field844,omitempty"`
+	Field845 *string  `protobuf:"bytes,3,opt,name=field845" json:"field845,omitempty"`
+	Field846 []string `protobuf:"bytes,4,rep,name=field846" json:"field846,omitempty"`
+	Field847 []string `protobuf:"bytes,5,rep,name=field847" json:"field847,omitempty"`
+	Field848 *string  `protobuf:"bytes,6,opt,name=field848" json:"field848,omitempty"`
+	Field849 []string `protobuf:"bytes,7,rep,name=field849" json:"field849,omitempty"`
+	Field850 *string  `protobuf:"bytes,8,opt,name=field850" json:"field850,omitempty"`
+	Field851 *string  `protobuf:"bytes,9,opt,name=field851" json:"field851,omitempty"`
+}
+
+func (x *Message712) Reset() {
+	*x = Message712{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[28]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message712) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message712) ProtoMessage() {}
+
+func (x *Message712) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[28]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message712.ProtoReflect.Descriptor instead.
+func (*Message712) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{28}
+}
+
+func (x *Message712) GetField843() []string {
+	if x != nil {
+		return x.Field843
+	}
+	return nil
+}
+
+func (x *Message712) GetField844() string {
+	if x != nil && x.Field844 != nil {
+		return *x.Field844
+	}
+	return ""
+}
+
+func (x *Message712) GetField845() string {
+	if x != nil && x.Field845 != nil {
+		return *x.Field845
+	}
+	return ""
+}
+
+func (x *Message712) GetField846() []string {
+	if x != nil {
+		return x.Field846
+	}
+	return nil
+}
+
+func (x *Message712) GetField847() []string {
+	if x != nil {
+		return x.Field847
+	}
+	return nil
+}
+
+func (x *Message712) GetField848() string {
+	if x != nil && x.Field848 != nil {
+		return *x.Field848
+	}
+	return ""
+}
+
+func (x *Message712) GetField849() []string {
+	if x != nil {
+		return x.Field849
+	}
+	return nil
+}
+
+func (x *Message712) GetField850() string {
+	if x != nil && x.Field850 != nil {
+		return *x.Field850
+	}
+	return ""
+}
+
+func (x *Message712) GetField851() string {
+	if x != nil && x.Field851 != nil {
+		return *x.Field851
+	}
+	return ""
+}
+
+type Message8939 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field9010   *string                    `protobuf:"bytes,1,opt,name=field9010" json:"field9010,omitempty"`
+	Field9011   *string                    `protobuf:"bytes,2,opt,name=field9011" json:"field9011,omitempty"`
+	Field9012   *string                    `protobuf:"bytes,3,opt,name=field9012" json:"field9012,omitempty"`
+	Field9013   []string                   `protobuf:"bytes,4,rep,name=field9013" json:"field9013,omitempty"`
+	Field9014   *string                    `protobuf:"bytes,5,opt,name=field9014" json:"field9014,omitempty"`
+	Message8940 []*Message8939_Message8940 `protobuf:"group,11,rep,name=Message8940,json=message8940" json:"message8940,omitempty"`
+	Field9016   *int64                     `protobuf:"varint,21,opt,name=field9016" json:"field9016,omitempty"`
+	Field9017   *int64                     `protobuf:"varint,22,opt,name=field9017" json:"field9017,omitempty"`
+	Field9018   *int64                     `protobuf:"varint,23,opt,name=field9018" json:"field9018,omitempty"`
+	Message8941 *Message8939_Message8941   `protobuf:"group,31,opt,name=Message8941,json=message8941" json:"message8941,omitempty"`
+	Field9020   *Message8942               `protobuf:"bytes,38,opt,name=field9020" json:"field9020,omitempty"`
+	Field9021   []*UnusedEmptyMessage      `protobuf:"bytes,39,rep,name=field9021" json:"field9021,omitempty"`
+	Field9022   []string                   `protobuf:"bytes,41,rep,name=field9022" json:"field9022,omitempty"`
+	Field9023   *string                    `protobuf:"bytes,42,opt,name=field9023" json:"field9023,omitempty"`
+	Field9024   *string                    `protobuf:"bytes,43,opt,name=field9024" json:"field9024,omitempty"`
+	Field9025   *string                    `protobuf:"bytes,44,opt,name=field9025" json:"field9025,omitempty"`
+	Field9026   *string                    `protobuf:"bytes,45,opt,name=field9026" json:"field9026,omitempty"`
+	Field9027   *string                    `protobuf:"bytes,46,opt,name=field9027" json:"field9027,omitempty"`
+	Field9028   *string                    `protobuf:"bytes,47,opt,name=field9028" json:"field9028,omitempty"`
+	Field9029   *UnusedEnum                `protobuf:"varint,48,opt,name=field9029,enum=benchmarks.google_message3.UnusedEnum" json:"field9029,omitempty"`
+	Field9030   *UnusedEnum                `protobuf:"varint,49,opt,name=field9030,enum=benchmarks.google_message3.UnusedEnum" json:"field9030,omitempty"`
+	Message8943 *Message8939_Message8943   `protobuf:"group,51,opt,name=Message8943,json=message8943" json:"message8943,omitempty"`
+}
+
+func (x *Message8939) Reset() {
+	*x = Message8939{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[29]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8939) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8939) ProtoMessage() {}
+
+func (x *Message8939) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[29]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8939.ProtoReflect.Descriptor instead.
+func (*Message8939) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{29}
+}
+
+func (x *Message8939) GetField9010() string {
+	if x != nil && x.Field9010 != nil {
+		return *x.Field9010
+	}
+	return ""
+}
+
+func (x *Message8939) GetField9011() string {
+	if x != nil && x.Field9011 != nil {
+		return *x.Field9011
+	}
+	return ""
+}
+
+func (x *Message8939) GetField9012() string {
+	if x != nil && x.Field9012 != nil {
+		return *x.Field9012
+	}
+	return ""
+}
+
+func (x *Message8939) GetField9013() []string {
+	if x != nil {
+		return x.Field9013
+	}
+	return nil
+}
+
+func (x *Message8939) GetField9014() string {
+	if x != nil && x.Field9014 != nil {
+		return *x.Field9014
+	}
+	return ""
+}
+
+func (x *Message8939) GetMessage8940() []*Message8939_Message8940 {
+	if x != nil {
+		return x.Message8940
+	}
+	return nil
+}
+
+func (x *Message8939) GetField9016() int64 {
+	if x != nil && x.Field9016 != nil {
+		return *x.Field9016
+	}
+	return 0
+}
+
+func (x *Message8939) GetField9017() int64 {
+	if x != nil && x.Field9017 != nil {
+		return *x.Field9017
+	}
+	return 0
+}
+
+func (x *Message8939) GetField9018() int64 {
+	if x != nil && x.Field9018 != nil {
+		return *x.Field9018
+	}
+	return 0
+}
+
+func (x *Message8939) GetMessage8941() *Message8939_Message8941 {
+	if x != nil {
+		return x.Message8941
+	}
+	return nil
+}
+
+func (x *Message8939) GetField9020() *Message8942 {
+	if x != nil {
+		return x.Field9020
+	}
+	return nil
+}
+
+func (x *Message8939) GetField9021() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field9021
+	}
+	return nil
+}
+
+func (x *Message8939) GetField9022() []string {
+	if x != nil {
+		return x.Field9022
+	}
+	return nil
+}
+
+func (x *Message8939) GetField9023() string {
+	if x != nil && x.Field9023 != nil {
+		return *x.Field9023
+	}
+	return ""
+}
+
+func (x *Message8939) GetField9024() string {
+	if x != nil && x.Field9024 != nil {
+		return *x.Field9024
+	}
+	return ""
+}
+
+func (x *Message8939) GetField9025() string {
+	if x != nil && x.Field9025 != nil {
+		return *x.Field9025
+	}
+	return ""
+}
+
+func (x *Message8939) GetField9026() string {
+	if x != nil && x.Field9026 != nil {
+		return *x.Field9026
+	}
+	return ""
+}
+
+func (x *Message8939) GetField9027() string {
+	if x != nil && x.Field9027 != nil {
+		return *x.Field9027
+	}
+	return ""
+}
+
+func (x *Message8939) GetField9028() string {
+	if x != nil && x.Field9028 != nil {
+		return *x.Field9028
+	}
+	return ""
+}
+
+func (x *Message8939) GetField9029() UnusedEnum {
+	if x != nil && x.Field9029 != nil {
+		return *x.Field9029
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+func (x *Message8939) GetField9030() UnusedEnum {
+	if x != nil && x.Field9030 != nil {
+		return *x.Field9030
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+func (x *Message8939) GetMessage8943() *Message8939_Message8943 {
+	if x != nil {
+		return x.Message8943
+	}
+	return nil
+}
+
+type Message9181 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field9204 *string `protobuf:"bytes,1,opt,name=field9204" json:"field9204,omitempty"`
+}
+
+func (x *Message9181) Reset() {
+	*x = Message9181{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[30]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message9181) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message9181) ProtoMessage() {}
+
+func (x *Message9181) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[30]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message9181.ProtoReflect.Descriptor instead.
+func (*Message9181) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{30}
+}
+
+func (x *Message9181) GetField9204() string {
+	if x != nil && x.Field9204 != nil {
+		return *x.Field9204
+	}
+	return ""
+}
+
+type Message9164 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field9168 *int32 `protobuf:"varint,1,opt,name=field9168" json:"field9168,omitempty"`
+	Field9169 *int32 `protobuf:"varint,2,opt,name=field9169" json:"field9169,omitempty"`
+	Field9170 *int32 `protobuf:"varint,3,opt,name=field9170" json:"field9170,omitempty"`
+}
+
+func (x *Message9164) Reset() {
+	*x = Message9164{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[31]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message9164) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message9164) ProtoMessage() {}
+
+func (x *Message9164) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[31]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message9164.ProtoReflect.Descriptor instead.
+func (*Message9164) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{31}
+}
+
+func (x *Message9164) GetField9168() int32 {
+	if x != nil && x.Field9168 != nil {
+		return *x.Field9168
+	}
+	return 0
+}
+
+func (x *Message9164) GetField9169() int32 {
+	if x != nil && x.Field9169 != nil {
+		return *x.Field9169
+	}
+	return 0
+}
+
+func (x *Message9164) GetField9170() int32 {
+	if x != nil && x.Field9170 != nil {
+		return *x.Field9170
+	}
+	return 0
+}
+
+type Message9165 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field9171 *float32 `protobuf:"fixed32,1,opt,name=field9171" json:"field9171,omitempty"`
+	Field9172 *float32 `protobuf:"fixed32,2,opt,name=field9172" json:"field9172,omitempty"`
+}
+
+func (x *Message9165) Reset() {
+	*x = Message9165{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[32]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message9165) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message9165) ProtoMessage() {}
+
+func (x *Message9165) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[32]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message9165.ProtoReflect.Descriptor instead.
+func (*Message9165) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{32}
+}
+
+func (x *Message9165) GetField9171() float32 {
+	if x != nil && x.Field9171 != nil {
+		return *x.Field9171
+	}
+	return 0
+}
+
+func (x *Message9165) GetField9172() float32 {
+	if x != nil && x.Field9172 != nil {
+		return *x.Field9172
+	}
+	return 0
+}
+
+type Message9166 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field9173 *float32 `protobuf:"fixed32,1,opt,name=field9173" json:"field9173,omitempty"`
+	Field9174 *int32   `protobuf:"varint,2,opt,name=field9174" json:"field9174,omitempty"`
+}
+
+func (x *Message9166) Reset() {
+	*x = Message9166{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[33]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message9166) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message9166) ProtoMessage() {}
+
+func (x *Message9166) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[33]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message9166.ProtoReflect.Descriptor instead.
+func (*Message9166) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{33}
+}
+
+func (x *Message9166) GetField9173() float32 {
+	if x != nil && x.Field9173 != nil {
+		return *x.Field9173
+	}
+	return 0
+}
+
+func (x *Message9166) GetField9174() int32 {
+	if x != nil && x.Field9174 != nil {
+		return *x.Field9174
+	}
+	return 0
+}
+
+type Message9151 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field9152 *float64 `protobuf:"fixed64,1,opt,name=field9152" json:"field9152,omitempty"`
+	Field9153 *float64 `protobuf:"fixed64,2,opt,name=field9153" json:"field9153,omitempty"`
+	Field9154 *float32 `protobuf:"fixed32,3,opt,name=field9154" json:"field9154,omitempty"`
+	Field9155 *float32 `protobuf:"fixed32,4,opt,name=field9155" json:"field9155,omitempty"`
+	Field9156 *float32 `protobuf:"fixed32,5,opt,name=field9156" json:"field9156,omitempty"`
+	Field9157 *float32 `protobuf:"fixed32,6,opt,name=field9157" json:"field9157,omitempty"`
+	Field9158 *float32 `protobuf:"fixed32,7,opt,name=field9158" json:"field9158,omitempty"`
+	Field9159 *float32 `protobuf:"fixed32,8,opt,name=field9159" json:"field9159,omitempty"`
+}
+
+func (x *Message9151) Reset() {
+	*x = Message9151{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[34]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message9151) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message9151) ProtoMessage() {}
+
+func (x *Message9151) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[34]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message9151.ProtoReflect.Descriptor instead.
+func (*Message9151) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{34}
+}
+
+func (x *Message9151) GetField9152() float64 {
+	if x != nil && x.Field9152 != nil {
+		return *x.Field9152
+	}
+	return 0
+}
+
+func (x *Message9151) GetField9153() float64 {
+	if x != nil && x.Field9153 != nil {
+		return *x.Field9153
+	}
+	return 0
+}
+
+func (x *Message9151) GetField9154() float32 {
+	if x != nil && x.Field9154 != nil {
+		return *x.Field9154
+	}
+	return 0
+}
+
+func (x *Message9151) GetField9155() float32 {
+	if x != nil && x.Field9155 != nil {
+		return *x.Field9155
+	}
+	return 0
+}
+
+func (x *Message9151) GetField9156() float32 {
+	if x != nil && x.Field9156 != nil {
+		return *x.Field9156
+	}
+	return 0
+}
+
+func (x *Message9151) GetField9157() float32 {
+	if x != nil && x.Field9157 != nil {
+		return *x.Field9157
+	}
+	return 0
+}
+
+func (x *Message9151) GetField9158() float32 {
+	if x != nil && x.Field9158 != nil {
+		return *x.Field9158
+	}
+	return 0
+}
+
+func (x *Message9151) GetField9159() float32 {
+	if x != nil && x.Field9159 != nil {
+		return *x.Field9159
+	}
+	return 0
+}
+
+type Message8888 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field8908 *int32    `protobuf:"varint,1,opt,name=field8908" json:"field8908,omitempty"`
+	Field8909 *Enum8900 `protobuf:"varint,4,opt,name=field8909,enum=benchmarks.google_message3.Enum8900" json:"field8909,omitempty"`
+	Field8910 []int32   `protobuf:"varint,2,rep,packed,name=field8910" json:"field8910,omitempty"`
+	Field8911 []byte    `protobuf:"bytes,3,opt,name=field8911" json:"field8911,omitempty"`
+}
+
+func (x *Message8888) Reset() {
+	*x = Message8888{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[35]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8888) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8888) ProtoMessage() {}
+
+func (x *Message8888) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[35]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8888.ProtoReflect.Descriptor instead.
+func (*Message8888) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{35}
+}
+
+func (x *Message8888) GetField8908() int32 {
+	if x != nil && x.Field8908 != nil {
+		return *x.Field8908
+	}
+	return 0
+}
+
+func (x *Message8888) GetField8909() Enum8900 {
+	if x != nil && x.Field8909 != nil {
+		return *x.Field8909
+	}
+	return Enum8900_ENUM_VALUE8901
+}
+
+func (x *Message8888) GetField8910() []int32 {
+	if x != nil {
+		return x.Field8910
+	}
+	return nil
+}
+
+func (x *Message8888) GetField8911() []byte {
+	if x != nil {
+		return x.Field8911
+	}
+	return nil
+}
+
+type Message9627 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field9668 *int32   `protobuf:"varint,1,req,name=field9668" json:"field9668,omitempty"`
+	Field9669 *int32   `protobuf:"varint,2,req,name=field9669" json:"field9669,omitempty"`
+	Field9670 *int32   `protobuf:"varint,3,req,name=field9670" json:"field9670,omitempty"`
+	Field9671 *int32   `protobuf:"varint,4,req,name=field9671" json:"field9671,omitempty"`
+	Field9672 *float32 `protobuf:"fixed32,5,opt,name=field9672" json:"field9672,omitempty"`
+}
+
+func (x *Message9627) Reset() {
+	*x = Message9627{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[36]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message9627) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message9627) ProtoMessage() {}
+
+func (x *Message9627) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[36]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message9627.ProtoReflect.Descriptor instead.
+func (*Message9627) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{36}
+}
+
+func (x *Message9627) GetField9668() int32 {
+	if x != nil && x.Field9668 != nil {
+		return *x.Field9668
+	}
+	return 0
+}
+
+func (x *Message9627) GetField9669() int32 {
+	if x != nil && x.Field9669 != nil {
+		return *x.Field9669
+	}
+	return 0
+}
+
+func (x *Message9627) GetField9670() int32 {
+	if x != nil && x.Field9670 != nil {
+		return *x.Field9670
+	}
+	return 0
+}
+
+func (x *Message9627) GetField9671() int32 {
+	if x != nil && x.Field9671 != nil {
+		return *x.Field9671
+	}
+	return 0
+}
+
+func (x *Message9627) GetField9672() float32 {
+	if x != nil && x.Field9672 != nil {
+		return *x.Field9672
+	}
+	return 0
+}
+
+type Message11020 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message11020) Reset() {
+	*x = Message11020{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[37]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message11020) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message11020) ProtoMessage() {}
+
+func (x *Message11020) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[37]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message11020.ProtoReflect.Descriptor instead.
+func (*Message11020) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{37}
+}
+
+type Message11013 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field11757 []byte              `protobuf:"bytes,19,opt,name=field11757" json:"field11757,omitempty"`
+	Field11758 []byte              `protobuf:"bytes,1,opt,name=field11758" json:"field11758,omitempty"`
+	Field11759 []byte              `protobuf:"bytes,2,opt,name=field11759" json:"field11759,omitempty"`
+	Field11760 []byte              `protobuf:"bytes,3,opt,name=field11760" json:"field11760,omitempty"`
+	Field11761 []byte              `protobuf:"bytes,4,opt,name=field11761" json:"field11761,omitempty"`
+	Field11762 []byte              `protobuf:"bytes,5,opt,name=field11762" json:"field11762,omitempty"`
+	Field11763 []byte              `protobuf:"bytes,6,opt,name=field11763" json:"field11763,omitempty"`
+	Field11764 []byte              `protobuf:"bytes,7,opt,name=field11764" json:"field11764,omitempty"`
+	Field11765 []byte              `protobuf:"bytes,8,opt,name=field11765" json:"field11765,omitempty"`
+	Field11766 []byte              `protobuf:"bytes,9,opt,name=field11766" json:"field11766,omitempty"`
+	Field11767 []byte              `protobuf:"bytes,10,opt,name=field11767" json:"field11767,omitempty"`
+	Field11768 []byte              `protobuf:"bytes,11,opt,name=field11768" json:"field11768,omitempty"`
+	Field11769 []byte              `protobuf:"bytes,12,opt,name=field11769" json:"field11769,omitempty"`
+	Field11770 []byte              `protobuf:"bytes,13,opt,name=field11770" json:"field11770,omitempty"`
+	Field11771 []byte              `protobuf:"bytes,14,opt,name=field11771" json:"field11771,omitempty"`
+	Field11772 []byte              `protobuf:"bytes,15,opt,name=field11772" json:"field11772,omitempty"`
+	Field11773 []byte              `protobuf:"bytes,16,opt,name=field11773" json:"field11773,omitempty"`
+	Field11774 []byte              `protobuf:"bytes,17,opt,name=field11774" json:"field11774,omitempty"`
+	Field11775 []byte              `protobuf:"bytes,18,opt,name=field11775" json:"field11775,omitempty"`
+	Field11776 []byte              `protobuf:"bytes,20,opt,name=field11776" json:"field11776,omitempty"`
+	Field11777 []byte              `protobuf:"bytes,21,opt,name=field11777" json:"field11777,omitempty"`
+	Field11778 *UnusedEmptyMessage `protobuf:"bytes,23,opt,name=field11778" json:"field11778,omitempty"`
+	Field11779 []*Message11011     `protobuf:"bytes,22,rep,name=field11779" json:"field11779,omitempty"`
+}
+
+func (x *Message11013) Reset() {
+	*x = Message11013{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[38]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message11013) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message11013) ProtoMessage() {}
+
+func (x *Message11013) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[38]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message11013.ProtoReflect.Descriptor instead.
+func (*Message11013) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{38}
+}
+
+func (x *Message11013) GetField11757() []byte {
+	if x != nil {
+		return x.Field11757
+	}
+	return nil
+}
+
+func (x *Message11013) GetField11758() []byte {
+	if x != nil {
+		return x.Field11758
+	}
+	return nil
+}
+
+func (x *Message11013) GetField11759() []byte {
+	if x != nil {
+		return x.Field11759
+	}
+	return nil
+}
+
+func (x *Message11013) GetField11760() []byte {
+	if x != nil {
+		return x.Field11760
+	}
+	return nil
+}
+
+func (x *Message11013) GetField11761() []byte {
+	if x != nil {
+		return x.Field11761
+	}
+	return nil
+}
+
+func (x *Message11013) GetField11762() []byte {
+	if x != nil {
+		return x.Field11762
+	}
+	return nil
+}
+
+func (x *Message11013) GetField11763() []byte {
+	if x != nil {
+		return x.Field11763
+	}
+	return nil
+}
+
+func (x *Message11013) GetField11764() []byte {
+	if x != nil {
+		return x.Field11764
+	}
+	return nil
+}
+
+func (x *Message11013) GetField11765() []byte {
+	if x != nil {
+		return x.Field11765
+	}
+	return nil
+}
+
+func (x *Message11013) GetField11766() []byte {
+	if x != nil {
+		return x.Field11766
+	}
+	return nil
+}
+
+func (x *Message11013) GetField11767() []byte {
+	if x != nil {
+		return x.Field11767
+	}
+	return nil
+}
+
+func (x *Message11013) GetField11768() []byte {
+	if x != nil {
+		return x.Field11768
+	}
+	return nil
+}
+
+func (x *Message11013) GetField11769() []byte {
+	if x != nil {
+		return x.Field11769
+	}
+	return nil
+}
+
+func (x *Message11013) GetField11770() []byte {
+	if x != nil {
+		return x.Field11770
+	}
+	return nil
+}
+
+func (x *Message11013) GetField11771() []byte {
+	if x != nil {
+		return x.Field11771
+	}
+	return nil
+}
+
+func (x *Message11013) GetField11772() []byte {
+	if x != nil {
+		return x.Field11772
+	}
+	return nil
+}
+
+func (x *Message11013) GetField11773() []byte {
+	if x != nil {
+		return x.Field11773
+	}
+	return nil
+}
+
+func (x *Message11013) GetField11774() []byte {
+	if x != nil {
+		return x.Field11774
+	}
+	return nil
+}
+
+func (x *Message11013) GetField11775() []byte {
+	if x != nil {
+		return x.Field11775
+	}
+	return nil
+}
+
+func (x *Message11013) GetField11776() []byte {
+	if x != nil {
+		return x.Field11776
+	}
+	return nil
+}
+
+func (x *Message11013) GetField11777() []byte {
+	if x != nil {
+		return x.Field11777
+	}
+	return nil
+}
+
+func (x *Message11013) GetField11778() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field11778
+	}
+	return nil
+}
+
+func (x *Message11013) GetField11779() []*Message11011 {
+	if x != nil {
+		return x.Field11779
+	}
+	return nil
+}
+
+type Message8939_Message8940 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message8939_Message8940) Reset() {
+	*x = Message8939_Message8940{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[39]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8939_Message8940) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8939_Message8940) ProtoMessage() {}
+
+func (x *Message8939_Message8940) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[39]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8939_Message8940.ProtoReflect.Descriptor instead.
+func (*Message8939_Message8940) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{29, 0}
+}
+
+type Message8939_Message8941 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field9033 *string `protobuf:"bytes,32,opt,name=field9033" json:"field9033,omitempty"`
+	Field9034 *string `protobuf:"bytes,33,opt,name=field9034" json:"field9034,omitempty"`
+	Field9035 *string `protobuf:"bytes,34,opt,name=field9035" json:"field9035,omitempty"`
+	Field9036 *string `protobuf:"bytes,35,opt,name=field9036" json:"field9036,omitempty"`
+	Field9037 *string `protobuf:"bytes,36,opt,name=field9037" json:"field9037,omitempty"`
+	Field9038 *string `protobuf:"bytes,37,opt,name=field9038" json:"field9038,omitempty"`
+}
+
+func (x *Message8939_Message8941) Reset() {
+	*x = Message8939_Message8941{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[40]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8939_Message8941) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8939_Message8941) ProtoMessage() {}
+
+func (x *Message8939_Message8941) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[40]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8939_Message8941.ProtoReflect.Descriptor instead.
+func (*Message8939_Message8941) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{29, 1}
+}
+
+func (x *Message8939_Message8941) GetField9033() string {
+	if x != nil && x.Field9033 != nil {
+		return *x.Field9033
+	}
+	return ""
+}
+
+func (x *Message8939_Message8941) GetField9034() string {
+	if x != nil && x.Field9034 != nil {
+		return *x.Field9034
+	}
+	return ""
+}
+
+func (x *Message8939_Message8941) GetField9035() string {
+	if x != nil && x.Field9035 != nil {
+		return *x.Field9035
+	}
+	return ""
+}
+
+func (x *Message8939_Message8941) GetField9036() string {
+	if x != nil && x.Field9036 != nil {
+		return *x.Field9036
+	}
+	return ""
+}
+
+func (x *Message8939_Message8941) GetField9037() string {
+	if x != nil && x.Field9037 != nil {
+		return *x.Field9037
+	}
+	return ""
+}
+
+func (x *Message8939_Message8941) GetField9038() string {
+	if x != nil && x.Field9038 != nil {
+		return *x.Field9038
+	}
+	return ""
+}
+
+type Message8939_Message8943 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field9039 *string `protobuf:"bytes,1,opt,name=field9039" json:"field9039,omitempty"`
+	Field9040 *string `protobuf:"bytes,2,opt,name=field9040" json:"field9040,omitempty"`
+	Field9041 *string `protobuf:"bytes,3,opt,name=field9041" json:"field9041,omitempty"`
+	Field9042 *string `protobuf:"bytes,4,opt,name=field9042" json:"field9042,omitempty"`
+	Field9043 *string `protobuf:"bytes,5,opt,name=field9043" json:"field9043,omitempty"`
+	Field9044 *string `protobuf:"bytes,6,opt,name=field9044" json:"field9044,omitempty"`
+}
+
+func (x *Message8939_Message8943) Reset() {
+	*x = Message8939_Message8943{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[41]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8939_Message8943) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8939_Message8943) ProtoMessage() {}
+
+func (x *Message8939_Message8943) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[41]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8939_Message8943.ProtoReflect.Descriptor instead.
+func (*Message8939_Message8943) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP(), []int{29, 2}
+}
+
+func (x *Message8939_Message8943) GetField9039() string {
+	if x != nil && x.Field9039 != nil {
+		return *x.Field9039
+	}
+	return ""
+}
+
+func (x *Message8939_Message8943) GetField9040() string {
+	if x != nil && x.Field9040 != nil {
+		return *x.Field9040
+	}
+	return ""
+}
+
+func (x *Message8939_Message8943) GetField9041() string {
+	if x != nil && x.Field9041 != nil {
+		return *x.Field9041
+	}
+	return ""
+}
+
+func (x *Message8939_Message8943) GetField9042() string {
+	if x != nil && x.Field9042 != nil {
+		return *x.Field9042
+	}
+	return ""
+}
+
+func (x *Message8939_Message8943) GetField9043() string {
+	if x != nil && x.Field9043 != nil {
+		return *x.Field9043
+	}
+	return ""
+}
+
+func (x *Message8939_Message8943) GetField9044() string {
+	if x != nil && x.Field9044 != nil {
+		return *x.Field9044
+	}
+	return ""
+}
+
+var File_datasets_google_message3_benchmark_message3_6_proto protoreflect.FileDescriptor
+
+var file_datasets_google_message3_benchmark_message3_6_proto_rawDesc = []byte{
+	0x0a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x5f, 0x36, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1a, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x1a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2f, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x5f, 0x37,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73,
+	0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x5f, 0x38, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x0e, 0x0a, 0x0c, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x35, 0x37, 0x36, 0x22, 0x4e, 0x0a, 0x0c, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x31, 0x35, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x31, 0x39, 0x32, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x31, 0x39, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x31, 0x39, 0x33, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x31, 0x39, 0x33, 0x22, 0xbe, 0x10, 0x0a, 0x0b,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x39, 0x34, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x34, 0x35, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x34, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x39, 0x30, 0x34, 0x36, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x39, 0x30, 0x34, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x30, 0x34, 0x37, 0x18, 0x17, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x39, 0x30, 0x34, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30,
+	0x34, 0x38, 0x18, 0x34, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39,
+	0x30, 0x34, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x34, 0x39,
+	0x18, 0x35, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x34,
+	0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x35, 0x30, 0x18, 0x36,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x35, 0x30, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x35, 0x31, 0x18, 0x37, 0x20, 0x01,
+	0x28, 0x02, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x35, 0x31, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x35, 0x32, 0x18, 0x38, 0x20, 0x01, 0x28, 0x02,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x35, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x35, 0x33, 0x18, 0x39, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x35, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x39, 0x30, 0x35, 0x34, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x39, 0x30, 0x35, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x30, 0x35, 0x35, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x39, 0x30, 0x35, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30,
+	0x35, 0x36, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39,
+	0x30, 0x35, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x35, 0x37,
+	0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x35,
+	0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x35, 0x38, 0x18, 0x07,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x35, 0x38, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x35, 0x39, 0x18, 0x08, 0x20, 0x01,
+	0x28, 0x02, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x35, 0x39, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x36, 0x30, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x02,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x36, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x36, 0x31, 0x18, 0x09, 0x20, 0x01, 0x28, 0x02, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x36, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x39, 0x30, 0x36, 0x32, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x02, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x39, 0x30, 0x36, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x30, 0x36, 0x33, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x02, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x39, 0x30, 0x36, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30,
+	0x36, 0x34, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39,
+	0x30, 0x36, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x36, 0x35,
+	0x18, 0x46, 0x20, 0x01, 0x28, 0x02, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x36,
+	0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x36, 0x36, 0x18, 0x47,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x36, 0x36, 0x12,
+	0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x36, 0x37, 0x18, 0x0f, 0x20, 0x01,
+	0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x45, 0x6e, 0x75, 0x6d, 0x38, 0x39, 0x34, 0x35, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39,
+	0x30, 0x36, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x36, 0x38,
+	0x18, 0x10, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x36,
+	0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x36, 0x39, 0x18, 0x11,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x36, 0x39, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x37, 0x30, 0x18, 0x12, 0x20, 0x01,
+	0x28, 0x02, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x37, 0x30, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x37, 0x31, 0x18, 0x13, 0x20, 0x01, 0x28, 0x02,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x37, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x37, 0x32, 0x18, 0x1c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x37, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x39, 0x30, 0x37, 0x33, 0x18, 0x1d, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x39, 0x30, 0x37, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x30, 0x37, 0x34, 0x18, 0x3c, 0x20, 0x01, 0x28, 0x02, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x39, 0x30, 0x37, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30,
+	0x37, 0x35, 0x18, 0x3d, 0x20, 0x01, 0x28, 0x02, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39,
+	0x30, 0x37, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x37, 0x36,
+	0x18, 0x48, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x37,
+	0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x37, 0x37, 0x18, 0x49,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x37, 0x37, 0x12,
+	0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x37, 0x38, 0x18, 0x3e, 0x20, 0x01,
+	0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x45, 0x6e, 0x75, 0x6d, 0x38, 0x39, 0x35, 0x31, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39,
+	0x30, 0x37, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x37, 0x39,
+	0x18, 0x14, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x37,
+	0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x38, 0x30, 0x18, 0x15,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x38, 0x30, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x38, 0x31, 0x18, 0x16, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x38, 0x31, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x38, 0x32, 0x18, 0x1f, 0x20, 0x01, 0x28, 0x01,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x38, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x38, 0x33, 0x18, 0x20, 0x20, 0x01, 0x28, 0x01, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x38, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x39, 0x30, 0x38, 0x34, 0x18, 0x21, 0x20, 0x01, 0x28, 0x01, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x39, 0x30, 0x38, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x30, 0x38, 0x35, 0x18, 0x24, 0x20, 0x01, 0x28, 0x01, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x39, 0x30, 0x38, 0x35, 0x12, 0x44, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30,
+	0x38, 0x36, 0x18, 0x25, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x38, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x38, 0x37, 0x18, 0x26, 0x20, 0x01, 0x28, 0x01, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x38, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x39, 0x30, 0x38, 0x38, 0x18, 0x27, 0x20, 0x01, 0x28, 0x01, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x39, 0x30, 0x38, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x30, 0x38, 0x39, 0x18, 0x3f, 0x20, 0x01, 0x28, 0x01, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x39, 0x30, 0x38, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30,
+	0x39, 0x30, 0x18, 0x40, 0x20, 0x01, 0x28, 0x01, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39,
+	0x30, 0x39, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x39, 0x31,
+	0x18, 0x41, 0x20, 0x01, 0x28, 0x01, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x39,
+	0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x39, 0x32, 0x18, 0x22,
+	0x20, 0x01, 0x28, 0x01, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x39, 0x32, 0x12,
+	0x44, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x39, 0x33, 0x18, 0x23, 0x20, 0x01,
+	0x28, 0x0e, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x39, 0x30, 0x39, 0x33, 0x12, 0x44, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30,
+	0x39, 0x34, 0x18, 0x42, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x39, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x39, 0x35, 0x18, 0x28, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x39, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x39, 0x30, 0x39, 0x36, 0x18, 0x29, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x39, 0x30, 0x39, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x30, 0x39, 0x37, 0x18, 0x2a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x39, 0x30, 0x39, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30,
+	0x39, 0x38, 0x18, 0x2b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39,
+	0x30, 0x39, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x39, 0x39,
+	0x18, 0x2c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x39,
+	0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x30, 0x30, 0x18, 0x2d,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x30, 0x30, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x30, 0x31, 0x18, 0x2e, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x30, 0x31, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x30, 0x32, 0x18, 0x2f, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x30, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x30, 0x33, 0x18, 0x30, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x30, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x39, 0x31, 0x30, 0x34, 0x18, 0x31, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x39, 0x31, 0x30, 0x34, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x31, 0x30, 0x35, 0x18, 0x64, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38,
+	0x39, 0x33, 0x39, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x30, 0x35, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x30, 0x36, 0x18, 0x65, 0x20, 0x01, 0x28,
+	0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x30, 0x36, 0x22, 0xe9, 0x08, 0x0a,
+	0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x39, 0x31, 0x38, 0x32, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x30, 0x35, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x30, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x39, 0x32, 0x30, 0x36, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x30, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x39, 0x32, 0x30, 0x37, 0x18, 0x10, 0x20, 0x01, 0x28, 0x02, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x39, 0x32, 0x30, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39,
+	0x32, 0x30, 0x38, 0x18, 0x11, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x32, 0x30, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x30,
+	0x39, 0x18, 0x1b, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x32,
+	0x30, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x31, 0x30, 0x18,
+	0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x31, 0x30,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x31, 0x31, 0x18, 0x08, 0x20,
+	0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x31, 0x31, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x31, 0x32, 0x18, 0x1a, 0x20, 0x01, 0x28,
+	0x02, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x31, 0x32, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x31, 0x33, 0x18, 0x16, 0x20, 0x01, 0x28, 0x02, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x31, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x39, 0x32, 0x31, 0x34, 0x18, 0x1c, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x31, 0x34, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x39, 0x32, 0x31, 0x35, 0x18, 0x15, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45,
+	0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x39, 0x32, 0x31, 0x35, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39,
+	0x32, 0x31, 0x36, 0x18, 0x19, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70,
+	0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x32, 0x31, 0x36, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x31,
+	0x37, 0x18, 0x1d, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x39, 0x31, 0x38, 0x31,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x31, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x31, 0x38, 0x18, 0x12, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x31, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x39, 0x32, 0x31, 0x39, 0x18, 0x13, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x39, 0x32, 0x31, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x32, 0x32, 0x30, 0x18, 0x14, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x39, 0x32, 0x32, 0x30, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x32,
+	0x32, 0x31, 0x18, 0x1e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x39, 0x31, 0x36,
+	0x34, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x32, 0x31, 0x12, 0x45, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x32, 0x32, 0x18, 0x1f, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x39, 0x31, 0x36, 0x35, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39,
+	0x32, 0x32, 0x32, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x32, 0x33,
+	0x18, 0x20, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x39, 0x31, 0x36, 0x36, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x32, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x39, 0x32, 0x32, 0x34, 0x18, 0x21, 0x20, 0x01, 0x28, 0x02, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x32, 0x34, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x39, 0x32, 0x32, 0x35, 0x18, 0x22, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x39, 0x31, 0x35, 0x31, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x32, 0x35, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x32, 0x36, 0x18, 0x23, 0x20, 0x01,
+	0x28, 0x02, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x32, 0x36, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x32, 0x37, 0x18, 0x24, 0x20, 0x01, 0x28, 0x02,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x32, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x32, 0x38, 0x18, 0x25, 0x20, 0x01, 0x28, 0x02, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x32, 0x32, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x39, 0x32, 0x32, 0x39, 0x18, 0x26, 0x20, 0x01, 0x28, 0x02, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x39, 0x32, 0x32, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x32, 0x33, 0x30, 0x18, 0x27, 0x20, 0x01, 0x28, 0x02, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x39, 0x32, 0x33, 0x30, 0x2a, 0x04, 0x08, 0x03, 0x10, 0x07, 0x2a, 0x04, 0x08, 0x09, 0x10,
+	0x10, 0x2a, 0x04, 0x08, 0x17, 0x10, 0x18, 0x2a, 0x04, 0x08, 0x18, 0x10, 0x19, 0x2a, 0x09, 0x08,
+	0xe8, 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x22, 0x49, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x39, 0x31, 0x36, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x31, 0x36, 0x31, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x39, 0x31, 0x36, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31,
+	0x36, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39,
+	0x31, 0x36, 0x32, 0x22, 0x51, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x39, 0x32,
+	0x34, 0x32, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x33, 0x32, 0x37, 0x18,
+	0x01, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x39, 0x32, 0x34, 0x33, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x39, 0x33, 0x32, 0x37, 0x22, 0x54, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x38, 0x38, 0x39, 0x30, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x39,
+	0x31, 0x36, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x38, 0x38,
+	0x38, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x39, 0x31, 0x36, 0x22, 0x2b, 0x0a, 0x0b,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x39, 0x31, 0x32, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x33, 0x35, 0x18, 0x01, 0x20, 0x01, 0x28, 0x02, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x33, 0x35, 0x22, 0xae, 0x01, 0x0a, 0x0b, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x39, 0x36, 0x32, 0x38, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x39, 0x36, 0x37, 0x33, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x39, 0x36, 0x32, 0x37, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x36, 0x37, 0x33,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x36, 0x37, 0x34, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x36, 0x37, 0x34, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x36, 0x37, 0x35, 0x18, 0x03, 0x20, 0x03, 0x28,
+	0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x36, 0x37, 0x35, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x36, 0x37, 0x36, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x36, 0x37, 0x36, 0x22, 0x9f, 0x14, 0x0a, 0x0c, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x31, 0x30, 0x31, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x38, 0x30, 0x18, 0x28, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x38, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x38, 0x31, 0x18, 0x2e, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x38, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x38, 0x32, 0x18, 0x2f, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x38, 0x32, 0x12, 0x45, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x38, 0x33, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32,
+	0x25, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75,
+	0x6d, 0x31, 0x31, 0x31, 0x30, 0x37, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37,
+	0x38, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x38, 0x34,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37,
+	0x38, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x38, 0x35,
+	0x18, 0x04, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37,
+	0x38, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x38, 0x36,
+	0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37,
+	0x38, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x38, 0x37,
+	0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37,
+	0x38, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x38, 0x38,
+	0x18, 0x07, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37,
+	0x38, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x38, 0x39,
+	0x18, 0x08, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37,
+	0x38, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x39, 0x30,
+	0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37,
+	0x39, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x39, 0x31,
+	0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37,
+	0x39, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x39, 0x32,
+	0x18, 0x1c, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37,
+	0x39, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x39, 0x33,
+	0x18, 0x25, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37,
+	0x39, 0x33, 0x12, 0x45, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x39, 0x34,
+	0x18, 0x2c, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x31, 0x35, 0x34, 0x31, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x39, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x31, 0x37, 0x39, 0x35, 0x18, 0x31, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x39, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x31, 0x37, 0x39, 0x36, 0x18, 0x33, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x39, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x31, 0x37, 0x39, 0x37, 0x18, 0x36, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x39, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x31, 0x37, 0x39, 0x38, 0x18, 0x37, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x39, 0x38, 0x12, 0x46, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x31, 0x37, 0x39, 0x39, 0x18, 0x39, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65,
+	0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x39,
+	0x39, 0x12, 0x45, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x30, 0x30, 0x18,
+	0x3a, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x31, 0x34, 0x36, 0x38, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x30, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x31, 0x38, 0x30, 0x31, 0x18, 0x3b, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x30, 0x31, 0x12, 0x46, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x31, 0x38, 0x30, 0x32, 0x18, 0x3c, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64,
+	0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x30, 0x32,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x30, 0x33, 0x18, 0x3d,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x30, 0x33,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x30, 0x34, 0x18, 0x3e,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x30, 0x34,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x30, 0x35, 0x18, 0x45,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x30, 0x35,
+	0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x30, 0x36, 0x18, 0x44,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x30, 0x36,
+	0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x30, 0x37, 0x18, 0x47,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x31, 0x30, 0x31, 0x38, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x30, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x30, 0x38, 0x18, 0x32, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x30, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x30, 0x39, 0x18, 0x38, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x30, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x31, 0x30, 0x18, 0x42, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x31, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x31, 0x31, 0x18, 0x3f, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x31, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x31, 0x32, 0x18, 0x40, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x31, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x31, 0x33, 0x18, 0x41, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x31, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x31, 0x34, 0x18, 0x43, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x31, 0x34, 0x12, 0x45, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x31, 0x35, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d,
+	0x31, 0x31, 0x31, 0x30, 0x37, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x31,
+	0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x31, 0x36, 0x18,
+	0x10, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x31,
+	0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x31, 0x37, 0x18,
+	0x11, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x31,
+	0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x31, 0x38, 0x18,
+	0x12, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x31,
+	0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x31, 0x39, 0x18,
+	0x13, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x31,
+	0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x32, 0x30, 0x18,
+	0x14, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x32,
+	0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x32, 0x31, 0x18,
+	0x2a, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x32,
+	0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x32, 0x32, 0x18,
+	0x34, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x32,
+	0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x32, 0x33, 0x18,
+	0x35, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x32,
+	0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x32, 0x34, 0x18,
+	0x29, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x32,
+	0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x32, 0x35, 0x18,
+	0x30, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x32,
+	0x35, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x32, 0x36, 0x18,
+	0x46, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x31, 0x30, 0x32, 0x30, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x32, 0x36, 0x12, 0x4e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x32, 0x37, 0x18, 0x48, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x32, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x32, 0x38, 0x18, 0x19, 0x20, 0x01, 0x28, 0x01, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x32, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x32, 0x39, 0x18, 0x1a, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x32, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x33, 0x30, 0x18, 0x1b, 0x20, 0x01, 0x28, 0x03, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x33, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x33, 0x31, 0x18, 0x20, 0x20, 0x01, 0x28, 0x03, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x33, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x33, 0x32, 0x18, 0x21, 0x20, 0x01, 0x28, 0x04, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x33, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x33, 0x33, 0x18, 0x1d, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x33, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x33, 0x34, 0x18, 0x22, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x33, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x33, 0x35, 0x18, 0x1e, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x33, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x33, 0x36, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x33, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x33, 0x37, 0x18, 0x1f, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x33, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x33, 0x38, 0x18, 0x49, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x33, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x33, 0x39, 0x18, 0x23, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x33, 0x39, 0x12, 0x45, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x34, 0x30, 0x18, 0x24, 0x20, 0x01, 0x28, 0x0e, 0x32,
+	0x25, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75,
+	0x6d, 0x31, 0x31, 0x30, 0x32, 0x32, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38,
+	0x34, 0x30, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x34, 0x31,
+	0x18, 0x26, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x31, 0x30, 0x31, 0x33,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x34, 0x31, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x34, 0x32, 0x18, 0x27, 0x20, 0x01, 0x28, 0x01,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x34, 0x32, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x34, 0x33, 0x18, 0x2d, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x34, 0x33, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x34, 0x34, 0x18, 0x4a, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x38, 0x34, 0x34, 0x22, 0xc2, 0x01, 0x0a,
+	0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x38, 0x30, 0x31, 0x12, 0x48, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x38, 0x31, 0x32, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x38, 0x30, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x30, 0x38, 0x31, 0x32, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x30, 0x38, 0x31, 0x33, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x31, 0x30, 0x38, 0x30, 0x32, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x38, 0x31,
+	0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x38, 0x31, 0x34, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x38, 0x31,
+	0x34, 0x22, 0x58, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x37, 0x34,
+	0x39, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x35, 0x34, 0x18,
+	0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x37, 0x34, 0x38, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x35, 0x34, 0x22, 0x90, 0x01, 0x0a, 0x0b,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x32, 0x39, 0x38, 0x12, 0x45, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x32, 0x31, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x37, 0x39, 0x36, 0x36, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33,
+	0x32, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x32, 0x32, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x32, 0x32,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x32, 0x33, 0x18, 0x03, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x32, 0x33, 0x22, 0x72,
+	0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x33, 0x30, 0x30, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x32, 0x36, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x32, 0x36, 0x12, 0x45, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x32, 0x37, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x37, 0x39, 0x36, 0x36, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33,
+	0x32, 0x37, 0x22, 0xc9, 0x01, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x32,
+	0x39, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x30, 0x36, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x30, 0x36,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x30, 0x37, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x30, 0x37, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x30, 0x38, 0x18, 0x03, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x30, 0x38, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x30, 0x39, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x30, 0x39, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x33, 0x31, 0x30, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x38,
+	0x32, 0x39, 0x32, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x31, 0x30, 0x22, 0x93,
+	0x02, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x32, 0x39, 0x36, 0x12, 0x45,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x31, 0x31, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x39, 0x36, 0x36, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x33, 0x31, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33,
+	0x31, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x33, 0x31, 0x32, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x31, 0x33,
+	0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x39, 0x36, 0x36, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x31, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x33, 0x31, 0x34, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x31, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x33, 0x31, 0x35, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x33, 0x31, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x33, 0x31, 0x36, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x33, 0x31, 0x36, 0x22, 0x49, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37,
+	0x39, 0x36, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x36, 0x37,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x36,
+	0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x36, 0x38, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x36, 0x38, 0x22,
+	0x49, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x32, 0x39, 0x30, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x30, 0x34, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x30, 0x34, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x30, 0x35, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x30, 0x35, 0x22, 0x44, 0x0a, 0x0a, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x31, 0x37, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x37, 0x36, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x37, 0x36, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x37, 0x37,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x37, 0x37,
+	0x22, 0x6c, 0x0a, 0x0a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x31, 0x33, 0x12, 0x42,
+	0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x32, 0x18, 0x01, 0x20, 0x02, 0x28, 0x0b,
+	0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x30, 0x38, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x35, 0x32, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x33, 0x18, 0x02,
+	0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x33, 0x22, 0xd0,
+	0x01, 0x0a, 0x0a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x30, 0x35, 0x12, 0x1a, 0x0a,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x30, 0x37, 0x18, 0x01, 0x20, 0x02, 0x28, 0x09, 0x52,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x30, 0x37, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x30, 0x38, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x30, 0x38, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x30,
+	0x39, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x30,
+	0x39, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x30, 0x18, 0x04, 0x20,
+	0x01, 0x28, 0x08, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x30, 0x12, 0x1a, 0x0a,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x31, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x31, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x31, 0x32, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x31, 0x32, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31,
+	0x33, 0x18, 0x07, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31,
+	0x33, 0x22, 0x98, 0x01, 0x0a, 0x0a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x30, 0x39,
+	0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x39, 0x18, 0x01, 0x20, 0x03,
+	0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x39, 0x12, 0x1a, 0x0a, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x30, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x30, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x33, 0x31, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x33, 0x31, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x32,
+	0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x32,
+	0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x33, 0x18, 0x05, 0x20, 0x03,
+	0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x33, 0x22, 0x44, 0x0a, 0x0a,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x30, 0x32, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x39, 0x33, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x39, 0x33, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37,
+	0x39, 0x34, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37,
+	0x39, 0x34, 0x22, 0x98, 0x01, 0x0a, 0x0a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x31,
+	0x34, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x34, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x34, 0x12, 0x1a, 0x0a,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x35, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x35, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x35, 0x36, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x35, 0x36, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35,
+	0x37, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35,
+	0x37, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x38, 0x18, 0x05, 0x20,
+	0x01, 0x28, 0x0d, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x38, 0x22, 0x98, 0x01,
+	0x0a, 0x0a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x31, 0x30, 0x12, 0x1a, 0x0a, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x34, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x34, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x33, 0x35, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x33, 0x35, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x36,
+	0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x36,
+	0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x37, 0x18, 0x04, 0x20, 0x03,
+	0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x37, 0x12, 0x1a, 0x0a, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x38, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x38, 0x22, 0x7c, 0x0a, 0x0a, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x37, 0x30, 0x36, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x31, 0x34, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x31, 0x34, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x35, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x35, 0x12, 0x1a,
+	0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x36, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09,
+	0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x36, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x31, 0x37, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x31, 0x37, 0x22, 0x98, 0x01, 0x0a, 0x0a, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x37, 0x30, 0x37, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31,
+	0x38, 0x18, 0x01, 0x20, 0x02, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31,
+	0x38, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x39, 0x18, 0x02, 0x20,
+	0x02, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x31, 0x39, 0x12, 0x1a, 0x0a,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x30, 0x18, 0x03, 0x20, 0x02, 0x28, 0x09, 0x52,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x30, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x32, 0x31, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x32, 0x31, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32,
+	0x32, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32,
+	0x32, 0x22, 0xac, 0x01, 0x0a, 0x0a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x31, 0x31,
+	0x12, 0x4a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x39, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e,
+	0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x33, 0x39, 0x12, 0x1a, 0x0a, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x30, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x30, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x34, 0x31, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x34, 0x31, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x32,
+	0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x32,
+	0x22, 0x88, 0x02, 0x0a, 0x0a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x31, 0x32, 0x12,
+	0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x33, 0x18, 0x01, 0x20, 0x03, 0x28,
+	0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x33, 0x12, 0x1a, 0x0a, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x34, 0x18, 0x02, 0x20, 0x02, 0x28, 0x09, 0x52, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x34, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x34, 0x35, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x34, 0x35, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x36, 0x18,
+	0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x36, 0x12,
+	0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x37, 0x18, 0x05, 0x20, 0x03, 0x28,
+	0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x37, 0x12, 0x1a, 0x0a, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x38, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x34, 0x38, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x34, 0x39, 0x18, 0x07, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x34, 0x39, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x30, 0x18,
+	0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x30, 0x12,
+	0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x31, 0x18, 0x09, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x35, 0x31, 0x22, 0x8c, 0x0b, 0x0a, 0x0b,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x39, 0x33, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x31, 0x30, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x31, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x39, 0x30, 0x31, 0x31, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x39, 0x30, 0x31, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x30, 0x31, 0x32, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x39, 0x30, 0x31, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30,
+	0x31, 0x33, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39,
+	0x30, 0x31, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x31, 0x34,
+	0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x31,
+	0x34, 0x12, 0x55, 0x0a, 0x0b, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x39, 0x34, 0x30,
+	0x18, 0x0b, 0x20, 0x03, 0x28, 0x0a, 0x32, 0x33, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x39, 0x33, 0x39, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x39, 0x34, 0x30, 0x52, 0x0b, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x38, 0x39, 0x34, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x39, 0x30, 0x31, 0x36, 0x18, 0x15, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x39, 0x30, 0x31, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39,
+	0x30, 0x31, 0x37, 0x18, 0x16, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x30, 0x31, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x31,
+	0x38, 0x18, 0x17, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30,
+	0x31, 0x38, 0x12, 0x55, 0x0a, 0x0b, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x39, 0x34,
+	0x31, 0x18, 0x1f, 0x20, 0x01, 0x28, 0x0a, 0x32, 0x33, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x39, 0x33, 0x39,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x39, 0x34, 0x31, 0x52, 0x0b, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x39, 0x34, 0x31, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x39, 0x30, 0x32, 0x30, 0x18, 0x26, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x38, 0x39, 0x34, 0x32, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x32, 0x30,
+	0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x32, 0x31, 0x18, 0x27, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x32, 0x31, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x32, 0x32, 0x18, 0x29, 0x20, 0x03, 0x28,
+	0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x32, 0x32, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x32, 0x33, 0x18, 0x2a, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x32, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x39, 0x30, 0x32, 0x34, 0x18, 0x2b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x32, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x39, 0x30, 0x32, 0x35, 0x18, 0x2c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x39, 0x30, 0x32, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39,
+	0x30, 0x32, 0x36, 0x18, 0x2d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x30, 0x32, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x32,
+	0x37, 0x18, 0x2e, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30,
+	0x32, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x32, 0x38, 0x18,
+	0x2f, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x32, 0x38,
+	0x12, 0x44, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x32, 0x39, 0x18, 0x30, 0x20,
+	0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x39, 0x30, 0x32, 0x39, 0x12, 0x44, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39,
+	0x30, 0x33, 0x30, 0x18, 0x31, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6e, 0x75,
+	0x6d, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x33, 0x30, 0x12, 0x55, 0x0a, 0x0b,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x39, 0x34, 0x33, 0x18, 0x33, 0x20, 0x01, 0x28,
+	0x0a, 0x32, 0x33, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x39, 0x33, 0x39, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x38, 0x39, 0x34, 0x33, 0x52, 0x0b, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38,
+	0x39, 0x34, 0x33, 0x1a, 0x0d, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x39,
+	0x34, 0x30, 0x1a, 0xc1, 0x01, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x39,
+	0x34, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x33, 0x33, 0x18,
+	0x20, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x33, 0x33,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x33, 0x34, 0x18, 0x21, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x33, 0x34, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x33, 0x35, 0x18, 0x22, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x33, 0x35, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x33, 0x36, 0x18, 0x23, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x33, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x39, 0x30, 0x33, 0x37, 0x18, 0x24, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x33, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x39, 0x30, 0x33, 0x38, 0x18, 0x25, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x39, 0x30, 0x33, 0x38, 0x1a, 0xc1, 0x01, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x38, 0x39, 0x34, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39,
+	0x30, 0x33, 0x39, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x30, 0x33, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x34,
+	0x30, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30,
+	0x34, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x34, 0x31, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x34, 0x31,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x34, 0x32, 0x18, 0x04, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x34, 0x32, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x34, 0x33, 0x18, 0x05, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x34, 0x33, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x34, 0x34, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x30, 0x34, 0x34, 0x22, 0x2b, 0x0a, 0x0b, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x39, 0x31, 0x38, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x39, 0x32, 0x30, 0x34, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x39, 0x32, 0x30, 0x34, 0x22, 0x67, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x39, 0x31, 0x36, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39,
+	0x31, 0x36, 0x38, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x31, 0x36, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x36,
+	0x39, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31,
+	0x36, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x37, 0x30, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x37, 0x30,
+	0x22, 0x49, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x39, 0x31, 0x36, 0x35, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x37, 0x31, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x02, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x37, 0x31, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x37, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x02,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x37, 0x32, 0x22, 0x49, 0x0a, 0x0b, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x39, 0x31, 0x36, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x39, 0x31, 0x37, 0x33, 0x18, 0x01, 0x20, 0x01, 0x28, 0x02, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x37, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x39, 0x31, 0x37, 0x34, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x39, 0x31, 0x37, 0x34, 0x22, 0xfd, 0x01, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x39, 0x31, 0x35, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39,
+	0x31, 0x35, 0x32, 0x18, 0x01, 0x20, 0x01, 0x28, 0x01, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x31, 0x35, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x35,
+	0x33, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31,
+	0x35, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x35, 0x34, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x02, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x35, 0x34,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x35, 0x35, 0x18, 0x04, 0x20,
+	0x01, 0x28, 0x02, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x35, 0x35, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x35, 0x36, 0x18, 0x05, 0x20, 0x01, 0x28,
+	0x02, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x35, 0x36, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x35, 0x37, 0x18, 0x06, 0x20, 0x01, 0x28, 0x02, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x35, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x39, 0x31, 0x35, 0x38, 0x18, 0x07, 0x20, 0x01, 0x28, 0x02, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x39, 0x31, 0x35, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x39, 0x31, 0x35, 0x39, 0x18, 0x08, 0x20, 0x01, 0x28, 0x02, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x39, 0x31, 0x35, 0x39, 0x22, 0xaf, 0x01, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x38, 0x38, 0x38, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x39, 0x30, 0x38, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x39, 0x30, 0x38, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x39, 0x30,
+	0x39, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x38, 0x39, 0x30, 0x30, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x39, 0x30, 0x39, 0x12, 0x20, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x39, 0x31, 0x30, 0x18, 0x02, 0x20, 0x03, 0x28, 0x05, 0x42, 0x02, 0x10, 0x01, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x39, 0x31, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x39, 0x31, 0x31, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x39, 0x31, 0x31, 0x22, 0xa3, 0x01, 0x0a, 0x0b, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x39, 0x36, 0x32, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x39, 0x36, 0x36, 0x38, 0x18, 0x01, 0x20, 0x02, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x39, 0x36, 0x36, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39,
+	0x36, 0x36, 0x39, 0x18, 0x02, 0x20, 0x02, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x39, 0x36, 0x36, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x36, 0x37,
+	0x30, 0x18, 0x03, 0x20, 0x02, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x36,
+	0x37, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x36, 0x37, 0x31, 0x18,
+	0x04, 0x20, 0x02, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x36, 0x37, 0x31,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x36, 0x37, 0x32, 0x18, 0x05, 0x20,
+	0x01, 0x28, 0x02, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x36, 0x37, 0x32, 0x22, 0x0e,
+	0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x31, 0x30, 0x32, 0x30, 0x22, 0xc8,
+	0x06, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x31, 0x30, 0x31, 0x33, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x35, 0x37, 0x18, 0x13, 0x20,
+	0x01, 0x28, 0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x35, 0x37, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x35, 0x38, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x35, 0x38, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x35, 0x39, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x35, 0x39, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x36, 0x30, 0x18, 0x03, 0x20,
+	0x01, 0x28, 0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x36, 0x30, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x36, 0x31, 0x18, 0x04, 0x20,
+	0x01, 0x28, 0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x36, 0x31, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x36, 0x32, 0x18, 0x05, 0x20,
+	0x01, 0x28, 0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x36, 0x32, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x36, 0x33, 0x18, 0x06, 0x20,
+	0x01, 0x28, 0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x36, 0x33, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x36, 0x34, 0x18, 0x07, 0x20,
+	0x01, 0x28, 0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x36, 0x34, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x36, 0x35, 0x18, 0x08, 0x20,
+	0x01, 0x28, 0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x36, 0x35, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x36, 0x36, 0x18, 0x09, 0x20,
+	0x01, 0x28, 0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x36, 0x36, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x36, 0x37, 0x18, 0x0a, 0x20,
+	0x01, 0x28, 0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x36, 0x37, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x36, 0x38, 0x18, 0x0b, 0x20,
+	0x01, 0x28, 0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x36, 0x38, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x36, 0x39, 0x18, 0x0c, 0x20,
+	0x01, 0x28, 0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x36, 0x39, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x37, 0x30, 0x18, 0x0d, 0x20,
+	0x01, 0x28, 0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x37, 0x30, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x37, 0x31, 0x18, 0x0e, 0x20,
+	0x01, 0x28, 0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x37, 0x31, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x37, 0x32, 0x18, 0x0f, 0x20,
+	0x01, 0x28, 0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x37, 0x32, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x37, 0x33, 0x18, 0x10, 0x20,
+	0x01, 0x28, 0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x37, 0x33, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x37, 0x34, 0x18, 0x11, 0x20,
+	0x01, 0x28, 0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x37, 0x34, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x37, 0x35, 0x18, 0x12, 0x20,
+	0x01, 0x28, 0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x37, 0x35, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x37, 0x36, 0x18, 0x14, 0x20,
+	0x01, 0x28, 0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x37, 0x36, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x37, 0x37, 0x18, 0x15, 0x20,
+	0x01, 0x28, 0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x37, 0x37, 0x12,
+	0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x37, 0x38, 0x18, 0x17, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x37, 0x38, 0x12,
+	0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x37, 0x39, 0x18, 0x16, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x31, 0x30, 0x31, 0x31, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x37, 0x39, 0x42, 0x23, 0x0a, 0x1e, 0x63, 0x6f, 0x6d,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0xf8, 0x01, 0x01,
+}
+
+var (
+	file_datasets_google_message3_benchmark_message3_6_proto_rawDescOnce sync.Once
+	file_datasets_google_message3_benchmark_message3_6_proto_rawDescData = file_datasets_google_message3_benchmark_message3_6_proto_rawDesc
+)
+
+func file_datasets_google_message3_benchmark_message3_6_proto_rawDescGZIP() []byte {
+	file_datasets_google_message3_benchmark_message3_6_proto_rawDescOnce.Do(func() {
+		file_datasets_google_message3_benchmark_message3_6_proto_rawDescData = protoimpl.X.CompressGZIP(file_datasets_google_message3_benchmark_message3_6_proto_rawDescData)
+	})
+	return file_datasets_google_message3_benchmark_message3_6_proto_rawDescData
+}
+
+var file_datasets_google_message3_benchmark_message3_6_proto_msgTypes = make([]protoimpl.MessageInfo, 42)
+var file_datasets_google_message3_benchmark_message3_6_proto_goTypes = []interface{}{
+	(*Message10576)(nil),            // 0: benchmarks.google_message3.Message10576
+	(*Message10154)(nil),            // 1: benchmarks.google_message3.Message10154
+	(*Message8944)(nil),             // 2: benchmarks.google_message3.Message8944
+	(*Message9182)(nil),             // 3: benchmarks.google_message3.Message9182
+	(*Message9160)(nil),             // 4: benchmarks.google_message3.Message9160
+	(*Message9242)(nil),             // 5: benchmarks.google_message3.Message9242
+	(*Message8890)(nil),             // 6: benchmarks.google_message3.Message8890
+	(*Message9123)(nil),             // 7: benchmarks.google_message3.Message9123
+	(*Message9628)(nil),             // 8: benchmarks.google_message3.Message9628
+	(*Message11014)(nil),            // 9: benchmarks.google_message3.Message11014
+	(*Message10801)(nil),            // 10: benchmarks.google_message3.Message10801
+	(*Message10749)(nil),            // 11: benchmarks.google_message3.Message10749
+	(*Message8298)(nil),             // 12: benchmarks.google_message3.Message8298
+	(*Message8300)(nil),             // 13: benchmarks.google_message3.Message8300
+	(*Message8291)(nil),             // 14: benchmarks.google_message3.Message8291
+	(*Message8296)(nil),             // 15: benchmarks.google_message3.Message8296
+	(*Message7965)(nil),             // 16: benchmarks.google_message3.Message7965
+	(*Message8290)(nil),             // 17: benchmarks.google_message3.Message8290
+	(*Message717)(nil),              // 18: benchmarks.google_message3.Message717
+	(*Message713)(nil),              // 19: benchmarks.google_message3.Message713
+	(*Message705)(nil),              // 20: benchmarks.google_message3.Message705
+	(*Message709)(nil),              // 21: benchmarks.google_message3.Message709
+	(*Message702)(nil),              // 22: benchmarks.google_message3.Message702
+	(*Message714)(nil),              // 23: benchmarks.google_message3.Message714
+	(*Message710)(nil),              // 24: benchmarks.google_message3.Message710
+	(*Message706)(nil),              // 25: benchmarks.google_message3.Message706
+	(*Message707)(nil),              // 26: benchmarks.google_message3.Message707
+	(*Message711)(nil),              // 27: benchmarks.google_message3.Message711
+	(*Message712)(nil),              // 28: benchmarks.google_message3.Message712
+	(*Message8939)(nil),             // 29: benchmarks.google_message3.Message8939
+	(*Message9181)(nil),             // 30: benchmarks.google_message3.Message9181
+	(*Message9164)(nil),             // 31: benchmarks.google_message3.Message9164
+	(*Message9165)(nil),             // 32: benchmarks.google_message3.Message9165
+	(*Message9166)(nil),             // 33: benchmarks.google_message3.Message9166
+	(*Message9151)(nil),             // 34: benchmarks.google_message3.Message9151
+	(*Message8888)(nil),             // 35: benchmarks.google_message3.Message8888
+	(*Message9627)(nil),             // 36: benchmarks.google_message3.Message9627
+	(*Message11020)(nil),            // 37: benchmarks.google_message3.Message11020
+	(*Message11013)(nil),            // 38: benchmarks.google_message3.Message11013
+	(*Message8939_Message8940)(nil), // 39: benchmarks.google_message3.Message8939.Message8940
+	(*Message8939_Message8941)(nil), // 40: benchmarks.google_message3.Message8939.Message8941
+	(*Message8939_Message8943)(nil), // 41: benchmarks.google_message3.Message8939.Message8943
+	(Enum8945)(0),                   // 42: benchmarks.google_message3.Enum8945
+	(Enum8951)(0),                   // 43: benchmarks.google_message3.Enum8951
+	(UnusedEnum)(0),                 // 44: benchmarks.google_message3.UnusedEnum
+	(*UnusedEmptyMessage)(nil),      // 45: benchmarks.google_message3.UnusedEmptyMessage
+	(Enum9243)(0),                   // 46: benchmarks.google_message3.Enum9243
+	(Enum11107)(0),                  // 47: benchmarks.google_message3.Enum11107
+	(Enum11541)(0),                  // 48: benchmarks.google_message3.Enum11541
+	(Enum11468)(0),                  // 49: benchmarks.google_message3.Enum11468
+	(*Message11018)(nil),            // 50: benchmarks.google_message3.Message11018
+	(Enum11022)(0),                  // 51: benchmarks.google_message3.Enum11022
+	(*Message10800)(nil),            // 52: benchmarks.google_message3.Message10800
+	(*Message10802)(nil),            // 53: benchmarks.google_message3.Message10802
+	(*Message10748)(nil),            // 54: benchmarks.google_message3.Message10748
+	(*Message7966)(nil),             // 55: benchmarks.google_message3.Message7966
+	(Enum8292)(0),                   // 56: benchmarks.google_message3.Enum8292
+	(*Message708)(nil),              // 57: benchmarks.google_message3.Message708
+	(*Message8942)(nil),             // 58: benchmarks.google_message3.Message8942
+	(Enum8900)(0),                   // 59: benchmarks.google_message3.Enum8900
+	(*Message11011)(nil),            // 60: benchmarks.google_message3.Message11011
+}
+var file_datasets_google_message3_benchmark_message3_6_proto_depIdxs = []int32{
+	42, // 0: benchmarks.google_message3.Message8944.field9067:type_name -> benchmarks.google_message3.Enum8945
+	43, // 1: benchmarks.google_message3.Message8944.field9078:type_name -> benchmarks.google_message3.Enum8951
+	44, // 2: benchmarks.google_message3.Message8944.field9086:type_name -> benchmarks.google_message3.UnusedEnum
+	44, // 3: benchmarks.google_message3.Message8944.field9093:type_name -> benchmarks.google_message3.UnusedEnum
+	44, // 4: benchmarks.google_message3.Message8944.field9094:type_name -> benchmarks.google_message3.UnusedEnum
+	29, // 5: benchmarks.google_message3.Message8944.field9105:type_name -> benchmarks.google_message3.Message8939
+	45, // 6: benchmarks.google_message3.Message9182.field9215:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	45, // 7: benchmarks.google_message3.Message9182.field9216:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	30, // 8: benchmarks.google_message3.Message9182.field9217:type_name -> benchmarks.google_message3.Message9181
+	31, // 9: benchmarks.google_message3.Message9182.field9221:type_name -> benchmarks.google_message3.Message9164
+	32, // 10: benchmarks.google_message3.Message9182.field9222:type_name -> benchmarks.google_message3.Message9165
+	33, // 11: benchmarks.google_message3.Message9182.field9223:type_name -> benchmarks.google_message3.Message9166
+	34, // 12: benchmarks.google_message3.Message9182.field9225:type_name -> benchmarks.google_message3.Message9151
+	46, // 13: benchmarks.google_message3.Message9242.field9327:type_name -> benchmarks.google_message3.Enum9243
+	35, // 14: benchmarks.google_message3.Message8890.field8916:type_name -> benchmarks.google_message3.Message8888
+	36, // 15: benchmarks.google_message3.Message9628.field9673:type_name -> benchmarks.google_message3.Message9627
+	47, // 16: benchmarks.google_message3.Message11014.field11783:type_name -> benchmarks.google_message3.Enum11107
+	48, // 17: benchmarks.google_message3.Message11014.field11794:type_name -> benchmarks.google_message3.Enum11541
+	44, // 18: benchmarks.google_message3.Message11014.field11799:type_name -> benchmarks.google_message3.UnusedEnum
+	49, // 19: benchmarks.google_message3.Message11014.field11800:type_name -> benchmarks.google_message3.Enum11468
+	44, // 20: benchmarks.google_message3.Message11014.field11802:type_name -> benchmarks.google_message3.UnusedEnum
+	45, // 21: benchmarks.google_message3.Message11014.field11806:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	50, // 22: benchmarks.google_message3.Message11014.field11807:type_name -> benchmarks.google_message3.Message11018
+	47, // 23: benchmarks.google_message3.Message11014.field11815:type_name -> benchmarks.google_message3.Enum11107
+	37, // 24: benchmarks.google_message3.Message11014.field11826:type_name -> benchmarks.google_message3.Message11020
+	45, // 25: benchmarks.google_message3.Message11014.field11827:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	51, // 26: benchmarks.google_message3.Message11014.field11840:type_name -> benchmarks.google_message3.Enum11022
+	38, // 27: benchmarks.google_message3.Message11014.field11841:type_name -> benchmarks.google_message3.Message11013
+	52, // 28: benchmarks.google_message3.Message10801.field10812:type_name -> benchmarks.google_message3.Message10800
+	53, // 29: benchmarks.google_message3.Message10801.field10813:type_name -> benchmarks.google_message3.Message10802
+	54, // 30: benchmarks.google_message3.Message10749.field10754:type_name -> benchmarks.google_message3.Message10748
+	55, // 31: benchmarks.google_message3.Message8298.field8321:type_name -> benchmarks.google_message3.Message7966
+	55, // 32: benchmarks.google_message3.Message8300.field8327:type_name -> benchmarks.google_message3.Message7966
+	56, // 33: benchmarks.google_message3.Message8291.field8310:type_name -> benchmarks.google_message3.Enum8292
+	55, // 34: benchmarks.google_message3.Message8296.field8311:type_name -> benchmarks.google_message3.Message7966
+	55, // 35: benchmarks.google_message3.Message8296.field8313:type_name -> benchmarks.google_message3.Message7966
+	57, // 36: benchmarks.google_message3.Message713.field852:type_name -> benchmarks.google_message3.Message708
+	45, // 37: benchmarks.google_message3.Message711.field839:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	39, // 38: benchmarks.google_message3.Message8939.message8940:type_name -> benchmarks.google_message3.Message8939.Message8940
+	40, // 39: benchmarks.google_message3.Message8939.message8941:type_name -> benchmarks.google_message3.Message8939.Message8941
+	58, // 40: benchmarks.google_message3.Message8939.field9020:type_name -> benchmarks.google_message3.Message8942
+	45, // 41: benchmarks.google_message3.Message8939.field9021:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	44, // 42: benchmarks.google_message3.Message8939.field9029:type_name -> benchmarks.google_message3.UnusedEnum
+	44, // 43: benchmarks.google_message3.Message8939.field9030:type_name -> benchmarks.google_message3.UnusedEnum
+	41, // 44: benchmarks.google_message3.Message8939.message8943:type_name -> benchmarks.google_message3.Message8939.Message8943
+	59, // 45: benchmarks.google_message3.Message8888.field8909:type_name -> benchmarks.google_message3.Enum8900
+	45, // 46: benchmarks.google_message3.Message11013.field11778:type_name -> benchmarks.google_message3.UnusedEmptyMessage
+	60, // 47: benchmarks.google_message3.Message11013.field11779:type_name -> benchmarks.google_message3.Message11011
+	48, // [48:48] is the sub-list for method output_type
+	48, // [48:48] is the sub-list for method input_type
+	48, // [48:48] is the sub-list for extension type_name
+	48, // [48:48] is the sub-list for extension extendee
+	0,  // [0:48] is the sub-list for field type_name
+}
+
+func init() { file_datasets_google_message3_benchmark_message3_6_proto_init() }
+func file_datasets_google_message3_benchmark_message3_6_proto_init() {
+	if File_datasets_google_message3_benchmark_message3_6_proto != nil {
+		return
+	}
+	file_datasets_google_message3_benchmark_message3_7_proto_init()
+	file_datasets_google_message3_benchmark_message3_8_proto_init()
+	if !protoimpl.UnsafeEnabled {
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message10576); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message10154); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8944); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message9182); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message9160); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message9242); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8890); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message9123); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message9628); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message11014); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message10801); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message10749); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8298); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8300); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8291); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8296); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message7965); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8290); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message717); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message713); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message705); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message709); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message702); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message714); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message710); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message706); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message707); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message711); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message712); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8939); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message9181); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message9164); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message9165); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message9166); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message9151); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[35].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8888); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[36].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message9627); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[37].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message11020); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[38].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message11013); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[39].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8939_Message8940); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[40].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8939_Message8941); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_6_proto_msgTypes[41].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8939_Message8943); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_datasets_google_message3_benchmark_message3_6_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   42,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_datasets_google_message3_benchmark_message3_6_proto_goTypes,
+		DependencyIndexes: file_datasets_google_message3_benchmark_message3_6_proto_depIdxs,
+		MessageInfos:      file_datasets_google_message3_benchmark_message3_6_proto_msgTypes,
+	}.Build()
+	File_datasets_google_message3_benchmark_message3_6_proto = out.File
+	file_datasets_google_message3_benchmark_message3_6_proto_rawDesc = nil
+	file_datasets_google_message3_benchmark_message3_6_proto_goTypes = nil
+	file_datasets_google_message3_benchmark_message3_6_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3/benchmark_message3_7.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3/benchmark_message3_7.pb.go
new file mode 100644
index 000000000..758392f2f
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3/benchmark_message3_7.pb.go
@@ -0,0 +1,822 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: datasets/google_message3/benchmark_message3_7.proto
+
+package google_message3
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type Message11018 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message11018) Reset() {
+	*x = Message11018{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_7_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message11018) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message11018) ProtoMessage() {}
+
+func (x *Message11018) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_7_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message11018.ProtoReflect.Descriptor instead.
+func (*Message11018) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_7_proto_rawDescGZIP(), []int{0}
+}
+
+type Message10800 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field10808 *string  `protobuf:"bytes,1,opt,name=field10808" json:"field10808,omitempty"`
+	Field10809 *int64   `protobuf:"varint,2,opt,name=field10809" json:"field10809,omitempty"`
+	Field10810 *bool    `protobuf:"varint,3,opt,name=field10810" json:"field10810,omitempty"`
+	Field10811 *float32 `protobuf:"fixed32,4,opt,name=field10811" json:"field10811,omitempty"`
+}
+
+func (x *Message10800) Reset() {
+	*x = Message10800{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_7_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message10800) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message10800) ProtoMessage() {}
+
+func (x *Message10800) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_7_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message10800.ProtoReflect.Descriptor instead.
+func (*Message10800) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_7_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *Message10800) GetField10808() string {
+	if x != nil && x.Field10808 != nil {
+		return *x.Field10808
+	}
+	return ""
+}
+
+func (x *Message10800) GetField10809() int64 {
+	if x != nil && x.Field10809 != nil {
+		return *x.Field10809
+	}
+	return 0
+}
+
+func (x *Message10800) GetField10810() bool {
+	if x != nil && x.Field10810 != nil {
+		return *x.Field10810
+	}
+	return false
+}
+
+func (x *Message10800) GetField10811() float32 {
+	if x != nil && x.Field10811 != nil {
+		return *x.Field10811
+	}
+	return 0
+}
+
+type Message10802 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message10802) Reset() {
+	*x = Message10802{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_7_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message10802) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message10802) ProtoMessage() {}
+
+func (x *Message10802) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_7_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message10802.ProtoReflect.Descriptor instead.
+func (*Message10802) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_7_proto_rawDescGZIP(), []int{2}
+}
+
+type Message10748 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field10750 *string `protobuf:"bytes,1,opt,name=field10750" json:"field10750,omitempty"`
+	Field10751 *int32  `protobuf:"varint,2,opt,name=field10751" json:"field10751,omitempty"`
+	Field10752 *int32  `protobuf:"varint,3,opt,name=field10752" json:"field10752,omitempty"`
+	Field10753 *int32  `protobuf:"varint,4,opt,name=field10753" json:"field10753,omitempty"`
+}
+
+func (x *Message10748) Reset() {
+	*x = Message10748{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_7_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message10748) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message10748) ProtoMessage() {}
+
+func (x *Message10748) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_7_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message10748.ProtoReflect.Descriptor instead.
+func (*Message10748) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_7_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *Message10748) GetField10750() string {
+	if x != nil && x.Field10750 != nil {
+		return *x.Field10750
+	}
+	return ""
+}
+
+func (x *Message10748) GetField10751() int32 {
+	if x != nil && x.Field10751 != nil {
+		return *x.Field10751
+	}
+	return 0
+}
+
+func (x *Message10748) GetField10752() int32 {
+	if x != nil && x.Field10752 != nil {
+		return *x.Field10752
+	}
+	return 0
+}
+
+func (x *Message10748) GetField10753() int32 {
+	if x != nil && x.Field10753 != nil {
+		return *x.Field10753
+	}
+	return 0
+}
+
+type Message7966 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field7969 *string `protobuf:"bytes,1,opt,name=field7969" json:"field7969,omitempty"`
+	Field7970 *bool   `protobuf:"varint,2,opt,name=field7970" json:"field7970,omitempty"`
+}
+
+func (x *Message7966) Reset() {
+	*x = Message7966{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_7_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message7966) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message7966) ProtoMessage() {}
+
+func (x *Message7966) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_7_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message7966.ProtoReflect.Descriptor instead.
+func (*Message7966) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_7_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *Message7966) GetField7969() string {
+	if x != nil && x.Field7969 != nil {
+		return *x.Field7969
+	}
+	return ""
+}
+
+func (x *Message7966) GetField7970() bool {
+	if x != nil && x.Field7970 != nil {
+		return *x.Field7970
+	}
+	return false
+}
+
+type Message708 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field823 *Message741 `protobuf:"bytes,1,opt,name=field823" json:"field823,omitempty"`
+	Field824 []string    `protobuf:"bytes,6,rep,name=field824" json:"field824,omitempty"`
+	Field825 *string     `protobuf:"bytes,2,opt,name=field825" json:"field825,omitempty"`
+	Field826 *string     `protobuf:"bytes,3,opt,name=field826" json:"field826,omitempty"`
+	Field827 []string    `protobuf:"bytes,4,rep,name=field827" json:"field827,omitempty"`
+	Field828 []string    `protobuf:"bytes,5,rep,name=field828" json:"field828,omitempty"`
+}
+
+func (x *Message708) Reset() {
+	*x = Message708{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_7_proto_msgTypes[5]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message708) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message708) ProtoMessage() {}
+
+func (x *Message708) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_7_proto_msgTypes[5]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message708.ProtoReflect.Descriptor instead.
+func (*Message708) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_7_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *Message708) GetField823() *Message741 {
+	if x != nil {
+		return x.Field823
+	}
+	return nil
+}
+
+func (x *Message708) GetField824() []string {
+	if x != nil {
+		return x.Field824
+	}
+	return nil
+}
+
+func (x *Message708) GetField825() string {
+	if x != nil && x.Field825 != nil {
+		return *x.Field825
+	}
+	return ""
+}
+
+func (x *Message708) GetField826() string {
+	if x != nil && x.Field826 != nil {
+		return *x.Field826
+	}
+	return ""
+}
+
+func (x *Message708) GetField827() []string {
+	if x != nil {
+		return x.Field827
+	}
+	return nil
+}
+
+func (x *Message708) GetField828() []string {
+	if x != nil {
+		return x.Field828
+	}
+	return nil
+}
+
+type Message8942 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message8942) Reset() {
+	*x = Message8942{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_7_proto_msgTypes[6]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8942) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8942) ProtoMessage() {}
+
+func (x *Message8942) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_7_proto_msgTypes[6]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8942.ProtoReflect.Descriptor instead.
+func (*Message8942) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_7_proto_rawDescGZIP(), []int{6}
+}
+
+type Message11011 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field11752 []byte `protobuf:"bytes,1,req,name=field11752" json:"field11752,omitempty"`
+	Field11753 []byte `protobuf:"bytes,2,req,name=field11753" json:"field11753,omitempty"`
+}
+
+func (x *Message11011) Reset() {
+	*x = Message11011{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_7_proto_msgTypes[7]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message11011) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message11011) ProtoMessage() {}
+
+func (x *Message11011) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_7_proto_msgTypes[7]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message11011.ProtoReflect.Descriptor instead.
+func (*Message11011) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_7_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *Message11011) GetField11752() []byte {
+	if x != nil {
+		return x.Field11752
+	}
+	return nil
+}
+
+func (x *Message11011) GetField11753() []byte {
+	if x != nil {
+		return x.Field11753
+	}
+	return nil
+}
+
+type UnusedEmptyMessage struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *UnusedEmptyMessage) Reset() {
+	*x = UnusedEmptyMessage{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_7_proto_msgTypes[8]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *UnusedEmptyMessage) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*UnusedEmptyMessage) ProtoMessage() {}
+
+func (x *UnusedEmptyMessage) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_7_proto_msgTypes[8]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use UnusedEmptyMessage.ProtoReflect.Descriptor instead.
+func (*UnusedEmptyMessage) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_7_proto_rawDescGZIP(), []int{8}
+}
+
+type Message741 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field936 []string `protobuf:"bytes,1,rep,name=field936" json:"field936,omitempty"`
+}
+
+func (x *Message741) Reset() {
+	*x = Message741{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message3_benchmark_message3_7_proto_msgTypes[9]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message741) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message741) ProtoMessage() {}
+
+func (x *Message741) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message3_benchmark_message3_7_proto_msgTypes[9]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message741.ProtoReflect.Descriptor instead.
+func (*Message741) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_7_proto_rawDescGZIP(), []int{9}
+}
+
+func (x *Message741) GetField936() []string {
+	if x != nil {
+		return x.Field936
+	}
+	return nil
+}
+
+var File_datasets_google_message3_benchmark_message3_7_proto protoreflect.FileDescriptor
+
+var file_datasets_google_message3_benchmark_message3_7_proto_rawDesc = []byte{
+	0x0a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x5f, 0x37, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1a, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x22, 0x0e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x31, 0x30, 0x31,
+	0x38, 0x22, 0x8e, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x38,
+	0x30, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x38, 0x30, 0x38,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x38,
+	0x30, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x38, 0x30, 0x39,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x38,
+	0x30, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x38, 0x31, 0x30,
+	0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x38,
+	0x31, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x38, 0x31, 0x31,
+	0x18, 0x04, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x38,
+	0x31, 0x31, 0x22, 0x0e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x38,
+	0x30, 0x32, 0x22, 0x8e, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30,
+	0x37, 0x34, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x35,
+	0x30, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30,
+	0x37, 0x35, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x35,
+	0x31, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30,
+	0x37, 0x35, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x35,
+	0x32, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30,
+	0x37, 0x35, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x37, 0x35,
+	0x33, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30,
+	0x37, 0x35, 0x33, 0x22, 0x49, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x39,
+	0x36, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x36, 0x39, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x36, 0x39,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x37, 0x30, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x37, 0x30, 0x22, 0xdc,
+	0x01, 0x0a, 0x0a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x30, 0x38, 0x12, 0x42, 0x0a,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x33, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x37, 0x34, 0x31, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32,
+	0x33, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x34, 0x18, 0x06, 0x20,
+	0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x34, 0x12, 0x1a, 0x0a,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x35, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x35, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x32, 0x36, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x32, 0x36, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32,
+	0x37, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32,
+	0x37, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x38, 0x18, 0x05, 0x20,
+	0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x32, 0x38, 0x22, 0x0d, 0x0a,
+	0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x39, 0x34, 0x32, 0x22, 0x4e, 0x0a, 0x0c,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x31, 0x30, 0x31, 0x31, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x35, 0x32, 0x18, 0x01, 0x20, 0x02, 0x28, 0x0c,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x35, 0x32, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x35, 0x33, 0x18, 0x02, 0x20, 0x02, 0x28, 0x0c,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x37, 0x35, 0x33, 0x22, 0x14, 0x0a, 0x12,
+	0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x22, 0x28, 0x0a, 0x0a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x34, 0x31,
+	0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x33, 0x36, 0x18, 0x01, 0x20, 0x03,
+	0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x33, 0x36, 0x42, 0x23, 0x0a, 0x1e,
+	0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x62, 0x75, 0x66, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0xf8, 0x01,
+	0x01,
+}
+
+var (
+	file_datasets_google_message3_benchmark_message3_7_proto_rawDescOnce sync.Once
+	file_datasets_google_message3_benchmark_message3_7_proto_rawDescData = file_datasets_google_message3_benchmark_message3_7_proto_rawDesc
+)
+
+func file_datasets_google_message3_benchmark_message3_7_proto_rawDescGZIP() []byte {
+	file_datasets_google_message3_benchmark_message3_7_proto_rawDescOnce.Do(func() {
+		file_datasets_google_message3_benchmark_message3_7_proto_rawDescData = protoimpl.X.CompressGZIP(file_datasets_google_message3_benchmark_message3_7_proto_rawDescData)
+	})
+	return file_datasets_google_message3_benchmark_message3_7_proto_rawDescData
+}
+
+var file_datasets_google_message3_benchmark_message3_7_proto_msgTypes = make([]protoimpl.MessageInfo, 10)
+var file_datasets_google_message3_benchmark_message3_7_proto_goTypes = []interface{}{
+	(*Message11018)(nil),       // 0: benchmarks.google_message3.Message11018
+	(*Message10800)(nil),       // 1: benchmarks.google_message3.Message10800
+	(*Message10802)(nil),       // 2: benchmarks.google_message3.Message10802
+	(*Message10748)(nil),       // 3: benchmarks.google_message3.Message10748
+	(*Message7966)(nil),        // 4: benchmarks.google_message3.Message7966
+	(*Message708)(nil),         // 5: benchmarks.google_message3.Message708
+	(*Message8942)(nil),        // 6: benchmarks.google_message3.Message8942
+	(*Message11011)(nil),       // 7: benchmarks.google_message3.Message11011
+	(*UnusedEmptyMessage)(nil), // 8: benchmarks.google_message3.UnusedEmptyMessage
+	(*Message741)(nil),         // 9: benchmarks.google_message3.Message741
+}
+var file_datasets_google_message3_benchmark_message3_7_proto_depIdxs = []int32{
+	9, // 0: benchmarks.google_message3.Message708.field823:type_name -> benchmarks.google_message3.Message741
+	1, // [1:1] is the sub-list for method output_type
+	1, // [1:1] is the sub-list for method input_type
+	1, // [1:1] is the sub-list for extension type_name
+	1, // [1:1] is the sub-list for extension extendee
+	0, // [0:1] is the sub-list for field type_name
+}
+
+func init() { file_datasets_google_message3_benchmark_message3_7_proto_init() }
+func file_datasets_google_message3_benchmark_message3_7_proto_init() {
+	if File_datasets_google_message3_benchmark_message3_7_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_datasets_google_message3_benchmark_message3_7_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message11018); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_7_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message10800); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_7_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message10802); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_7_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message10748); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_7_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message7966); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_7_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message708); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_7_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8942); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_7_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message11011); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_7_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*UnusedEmptyMessage); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message3_benchmark_message3_7_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message741); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_datasets_google_message3_benchmark_message3_7_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   10,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_datasets_google_message3_benchmark_message3_7_proto_goTypes,
+		DependencyIndexes: file_datasets_google_message3_benchmark_message3_7_proto_depIdxs,
+		MessageInfos:      file_datasets_google_message3_benchmark_message3_7_proto_msgTypes,
+	}.Build()
+	File_datasets_google_message3_benchmark_message3_7_proto = out.File
+	file_datasets_google_message3_benchmark_message3_7_proto_rawDesc = nil
+	file_datasets_google_message3_benchmark_message3_7_proto_goTypes = nil
+	file_datasets_google_message3_benchmark_message3_7_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3/benchmark_message3_8.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3/benchmark_message3_8.pb.go
new file mode 100644
index 000000000..5fbb6b8c1
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message3/benchmark_message3_8.pb.go
@@ -0,0 +1,10591 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: datasets/google_message3/benchmark_message3_8.proto
+
+package google_message3
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type Enum720 int32
+
+const (
+	Enum720_ENUM_VALUE721 Enum720 = 1
+	Enum720_ENUM_VALUE722 Enum720 = 2
+)
+
+// Enum value maps for Enum720.
+var (
+	Enum720_name = map[int32]string{
+		1: "ENUM_VALUE721",
+		2: "ENUM_VALUE722",
+	}
+	Enum720_value = map[string]int32{
+		"ENUM_VALUE721": 1,
+		"ENUM_VALUE722": 2,
+	}
+)
+
+func (x Enum720) Enum() *Enum720 {
+	p := new(Enum720)
+	*p = x
+	return p
+}
+
+func (x Enum720) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum720) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[0].Descriptor()
+}
+
+func (Enum720) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[0]
+}
+
+func (x Enum720) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum720) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum720(num)
+	return nil
+}
+
+// Deprecated: Use Enum720.Descriptor instead.
+func (Enum720) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{0}
+}
+
+type Enum3476 int32
+
+const (
+	Enum3476_ENUM_VALUE3477 Enum3476 = 0
+	Enum3476_ENUM_VALUE3478 Enum3476 = 1
+	Enum3476_ENUM_VALUE3479 Enum3476 = 2
+	Enum3476_ENUM_VALUE3480 Enum3476 = 3
+	Enum3476_ENUM_VALUE3481 Enum3476 = 4
+	Enum3476_ENUM_VALUE3482 Enum3476 = 5
+	Enum3476_ENUM_VALUE3483 Enum3476 = 6
+	Enum3476_ENUM_VALUE3484 Enum3476 = 7
+	Enum3476_ENUM_VALUE3485 Enum3476 = 8
+	Enum3476_ENUM_VALUE3486 Enum3476 = 9
+	Enum3476_ENUM_VALUE3487 Enum3476 = 10
+	Enum3476_ENUM_VALUE3488 Enum3476 = 11
+	Enum3476_ENUM_VALUE3489 Enum3476 = 12
+	Enum3476_ENUM_VALUE3490 Enum3476 = 13
+	Enum3476_ENUM_VALUE3491 Enum3476 = 14
+	Enum3476_ENUM_VALUE3492 Enum3476 = 15
+	Enum3476_ENUM_VALUE3493 Enum3476 = 16
+	Enum3476_ENUM_VALUE3494 Enum3476 = 17
+	Enum3476_ENUM_VALUE3495 Enum3476 = 18
+	Enum3476_ENUM_VALUE3496 Enum3476 = 19
+	Enum3476_ENUM_VALUE3497 Enum3476 = 20
+	Enum3476_ENUM_VALUE3498 Enum3476 = 21
+	Enum3476_ENUM_VALUE3499 Enum3476 = 22
+	Enum3476_ENUM_VALUE3500 Enum3476 = 23
+	Enum3476_ENUM_VALUE3501 Enum3476 = 24
+	Enum3476_ENUM_VALUE3502 Enum3476 = 25
+	Enum3476_ENUM_VALUE3503 Enum3476 = 26
+	Enum3476_ENUM_VALUE3504 Enum3476 = 27
+	Enum3476_ENUM_VALUE3505 Enum3476 = 28
+	Enum3476_ENUM_VALUE3506 Enum3476 = 29
+	Enum3476_ENUM_VALUE3507 Enum3476 = 30
+	Enum3476_ENUM_VALUE3508 Enum3476 = 31
+	Enum3476_ENUM_VALUE3509 Enum3476 = 32
+	Enum3476_ENUM_VALUE3510 Enum3476 = 33
+	Enum3476_ENUM_VALUE3511 Enum3476 = 34
+	Enum3476_ENUM_VALUE3512 Enum3476 = 35
+	Enum3476_ENUM_VALUE3513 Enum3476 = 36
+	Enum3476_ENUM_VALUE3514 Enum3476 = 37
+	Enum3476_ENUM_VALUE3515 Enum3476 = 38
+	Enum3476_ENUM_VALUE3516 Enum3476 = 39
+	Enum3476_ENUM_VALUE3517 Enum3476 = 40
+	Enum3476_ENUM_VALUE3518 Enum3476 = 41
+	Enum3476_ENUM_VALUE3519 Enum3476 = 42
+	Enum3476_ENUM_VALUE3520 Enum3476 = 43
+	Enum3476_ENUM_VALUE3521 Enum3476 = 44
+	Enum3476_ENUM_VALUE3522 Enum3476 = 45
+	Enum3476_ENUM_VALUE3523 Enum3476 = 46
+	Enum3476_ENUM_VALUE3524 Enum3476 = 47
+	Enum3476_ENUM_VALUE3525 Enum3476 = 48
+	Enum3476_ENUM_VALUE3526 Enum3476 = 49
+	Enum3476_ENUM_VALUE3527 Enum3476 = 50
+	Enum3476_ENUM_VALUE3528 Enum3476 = 51
+	Enum3476_ENUM_VALUE3529 Enum3476 = 52
+	Enum3476_ENUM_VALUE3530 Enum3476 = 53
+	Enum3476_ENUM_VALUE3531 Enum3476 = 54
+	Enum3476_ENUM_VALUE3532 Enum3476 = 55
+	Enum3476_ENUM_VALUE3533 Enum3476 = 56
+	Enum3476_ENUM_VALUE3534 Enum3476 = 57
+	Enum3476_ENUM_VALUE3535 Enum3476 = 58
+	Enum3476_ENUM_VALUE3536 Enum3476 = 59
+	Enum3476_ENUM_VALUE3537 Enum3476 = 60
+	Enum3476_ENUM_VALUE3538 Enum3476 = 61
+	Enum3476_ENUM_VALUE3539 Enum3476 = 62
+	Enum3476_ENUM_VALUE3540 Enum3476 = 63
+	Enum3476_ENUM_VALUE3541 Enum3476 = 64
+	Enum3476_ENUM_VALUE3542 Enum3476 = 65
+	Enum3476_ENUM_VALUE3543 Enum3476 = 66
+	Enum3476_ENUM_VALUE3544 Enum3476 = 67
+	Enum3476_ENUM_VALUE3545 Enum3476 = 68
+	Enum3476_ENUM_VALUE3546 Enum3476 = 69
+	Enum3476_ENUM_VALUE3547 Enum3476 = 70
+	Enum3476_ENUM_VALUE3548 Enum3476 = 71
+	Enum3476_ENUM_VALUE3549 Enum3476 = 72
+	Enum3476_ENUM_VALUE3550 Enum3476 = 73
+	Enum3476_ENUM_VALUE3551 Enum3476 = 74
+	Enum3476_ENUM_VALUE3552 Enum3476 = 75
+	Enum3476_ENUM_VALUE3553 Enum3476 = 76
+	Enum3476_ENUM_VALUE3554 Enum3476 = 77
+	Enum3476_ENUM_VALUE3555 Enum3476 = 78
+	Enum3476_ENUM_VALUE3556 Enum3476 = 79
+	Enum3476_ENUM_VALUE3557 Enum3476 = 80
+	Enum3476_ENUM_VALUE3558 Enum3476 = 81
+	Enum3476_ENUM_VALUE3559 Enum3476 = 82
+	Enum3476_ENUM_VALUE3560 Enum3476 = 83
+	Enum3476_ENUM_VALUE3561 Enum3476 = 84
+	Enum3476_ENUM_VALUE3562 Enum3476 = 85
+	Enum3476_ENUM_VALUE3563 Enum3476 = 86
+	Enum3476_ENUM_VALUE3564 Enum3476 = 87
+	Enum3476_ENUM_VALUE3565 Enum3476 = 88
+	Enum3476_ENUM_VALUE3566 Enum3476 = 89
+	Enum3476_ENUM_VALUE3567 Enum3476 = 90
+	Enum3476_ENUM_VALUE3568 Enum3476 = 91
+	Enum3476_ENUM_VALUE3569 Enum3476 = 92
+	Enum3476_ENUM_VALUE3570 Enum3476 = 93
+	Enum3476_ENUM_VALUE3571 Enum3476 = 94
+	Enum3476_ENUM_VALUE3572 Enum3476 = 95
+	Enum3476_ENUM_VALUE3573 Enum3476 = 96
+	Enum3476_ENUM_VALUE3574 Enum3476 = 97
+	Enum3476_ENUM_VALUE3575 Enum3476 = 98
+	Enum3476_ENUM_VALUE3576 Enum3476 = 99
+	Enum3476_ENUM_VALUE3577 Enum3476 = 100
+	Enum3476_ENUM_VALUE3578 Enum3476 = 101
+	Enum3476_ENUM_VALUE3579 Enum3476 = 102
+	Enum3476_ENUM_VALUE3580 Enum3476 = 103
+	Enum3476_ENUM_VALUE3581 Enum3476 = 104
+	Enum3476_ENUM_VALUE3582 Enum3476 = 105
+	Enum3476_ENUM_VALUE3583 Enum3476 = 106
+	Enum3476_ENUM_VALUE3584 Enum3476 = 107
+	Enum3476_ENUM_VALUE3585 Enum3476 = 108
+	Enum3476_ENUM_VALUE3586 Enum3476 = 109
+	Enum3476_ENUM_VALUE3587 Enum3476 = 110
+	Enum3476_ENUM_VALUE3588 Enum3476 = 111
+	Enum3476_ENUM_VALUE3589 Enum3476 = 112
+	Enum3476_ENUM_VALUE3590 Enum3476 = 113
+	Enum3476_ENUM_VALUE3591 Enum3476 = 114
+	Enum3476_ENUM_VALUE3592 Enum3476 = 115
+	Enum3476_ENUM_VALUE3593 Enum3476 = 116
+	Enum3476_ENUM_VALUE3594 Enum3476 = 117
+	Enum3476_ENUM_VALUE3595 Enum3476 = 118
+	Enum3476_ENUM_VALUE3596 Enum3476 = 119
+	Enum3476_ENUM_VALUE3597 Enum3476 = 120
+	Enum3476_ENUM_VALUE3598 Enum3476 = 121
+	Enum3476_ENUM_VALUE3599 Enum3476 = 122
+	Enum3476_ENUM_VALUE3600 Enum3476 = 123
+	Enum3476_ENUM_VALUE3601 Enum3476 = 124
+	Enum3476_ENUM_VALUE3602 Enum3476 = 125
+	Enum3476_ENUM_VALUE3603 Enum3476 = 126
+	Enum3476_ENUM_VALUE3604 Enum3476 = 127
+	Enum3476_ENUM_VALUE3605 Enum3476 = 128
+	Enum3476_ENUM_VALUE3606 Enum3476 = 129
+	Enum3476_ENUM_VALUE3607 Enum3476 = 130
+	Enum3476_ENUM_VALUE3608 Enum3476 = 131
+	Enum3476_ENUM_VALUE3609 Enum3476 = 132
+	Enum3476_ENUM_VALUE3610 Enum3476 = 133
+	Enum3476_ENUM_VALUE3611 Enum3476 = 134
+	Enum3476_ENUM_VALUE3612 Enum3476 = 135
+	Enum3476_ENUM_VALUE3613 Enum3476 = 136
+	Enum3476_ENUM_VALUE3614 Enum3476 = 137
+	Enum3476_ENUM_VALUE3615 Enum3476 = 138
+	Enum3476_ENUM_VALUE3616 Enum3476 = 139
+	Enum3476_ENUM_VALUE3617 Enum3476 = 140
+	Enum3476_ENUM_VALUE3618 Enum3476 = 141
+	Enum3476_ENUM_VALUE3619 Enum3476 = 142
+	Enum3476_ENUM_VALUE3620 Enum3476 = 143
+	Enum3476_ENUM_VALUE3621 Enum3476 = 144
+	Enum3476_ENUM_VALUE3622 Enum3476 = 145
+	Enum3476_ENUM_VALUE3623 Enum3476 = 146
+	Enum3476_ENUM_VALUE3624 Enum3476 = 147
+	Enum3476_ENUM_VALUE3625 Enum3476 = 148
+	Enum3476_ENUM_VALUE3626 Enum3476 = 149
+	Enum3476_ENUM_VALUE3627 Enum3476 = 150
+	Enum3476_ENUM_VALUE3628 Enum3476 = 151
+	Enum3476_ENUM_VALUE3629 Enum3476 = 152
+	Enum3476_ENUM_VALUE3630 Enum3476 = 153
+	Enum3476_ENUM_VALUE3631 Enum3476 = 154
+	Enum3476_ENUM_VALUE3632 Enum3476 = 155
+	Enum3476_ENUM_VALUE3633 Enum3476 = 156
+	Enum3476_ENUM_VALUE3634 Enum3476 = 157
+	Enum3476_ENUM_VALUE3635 Enum3476 = 158
+	Enum3476_ENUM_VALUE3636 Enum3476 = 159
+	Enum3476_ENUM_VALUE3637 Enum3476 = 160
+	Enum3476_ENUM_VALUE3638 Enum3476 = 161
+	Enum3476_ENUM_VALUE3639 Enum3476 = 162
+	Enum3476_ENUM_VALUE3640 Enum3476 = 163
+	Enum3476_ENUM_VALUE3641 Enum3476 = 164
+	Enum3476_ENUM_VALUE3642 Enum3476 = 165
+	Enum3476_ENUM_VALUE3643 Enum3476 = 166
+	Enum3476_ENUM_VALUE3644 Enum3476 = 167
+	Enum3476_ENUM_VALUE3645 Enum3476 = 168
+	Enum3476_ENUM_VALUE3646 Enum3476 = 169
+	Enum3476_ENUM_VALUE3647 Enum3476 = 170
+	Enum3476_ENUM_VALUE3648 Enum3476 = 171
+	Enum3476_ENUM_VALUE3649 Enum3476 = 172
+	Enum3476_ENUM_VALUE3650 Enum3476 = 173
+	Enum3476_ENUM_VALUE3651 Enum3476 = 174
+	Enum3476_ENUM_VALUE3652 Enum3476 = 175
+	Enum3476_ENUM_VALUE3653 Enum3476 = 176
+	Enum3476_ENUM_VALUE3654 Enum3476 = 177
+	Enum3476_ENUM_VALUE3655 Enum3476 = 178
+	Enum3476_ENUM_VALUE3656 Enum3476 = 179
+	Enum3476_ENUM_VALUE3657 Enum3476 = 180
+	Enum3476_ENUM_VALUE3658 Enum3476 = 181
+	Enum3476_ENUM_VALUE3659 Enum3476 = 182
+	Enum3476_ENUM_VALUE3660 Enum3476 = 183
+)
+
+// Enum value maps for Enum3476.
+var (
+	Enum3476_name = map[int32]string{
+		0:   "ENUM_VALUE3477",
+		1:   "ENUM_VALUE3478",
+		2:   "ENUM_VALUE3479",
+		3:   "ENUM_VALUE3480",
+		4:   "ENUM_VALUE3481",
+		5:   "ENUM_VALUE3482",
+		6:   "ENUM_VALUE3483",
+		7:   "ENUM_VALUE3484",
+		8:   "ENUM_VALUE3485",
+		9:   "ENUM_VALUE3486",
+		10:  "ENUM_VALUE3487",
+		11:  "ENUM_VALUE3488",
+		12:  "ENUM_VALUE3489",
+		13:  "ENUM_VALUE3490",
+		14:  "ENUM_VALUE3491",
+		15:  "ENUM_VALUE3492",
+		16:  "ENUM_VALUE3493",
+		17:  "ENUM_VALUE3494",
+		18:  "ENUM_VALUE3495",
+		19:  "ENUM_VALUE3496",
+		20:  "ENUM_VALUE3497",
+		21:  "ENUM_VALUE3498",
+		22:  "ENUM_VALUE3499",
+		23:  "ENUM_VALUE3500",
+		24:  "ENUM_VALUE3501",
+		25:  "ENUM_VALUE3502",
+		26:  "ENUM_VALUE3503",
+		27:  "ENUM_VALUE3504",
+		28:  "ENUM_VALUE3505",
+		29:  "ENUM_VALUE3506",
+		30:  "ENUM_VALUE3507",
+		31:  "ENUM_VALUE3508",
+		32:  "ENUM_VALUE3509",
+		33:  "ENUM_VALUE3510",
+		34:  "ENUM_VALUE3511",
+		35:  "ENUM_VALUE3512",
+		36:  "ENUM_VALUE3513",
+		37:  "ENUM_VALUE3514",
+		38:  "ENUM_VALUE3515",
+		39:  "ENUM_VALUE3516",
+		40:  "ENUM_VALUE3517",
+		41:  "ENUM_VALUE3518",
+		42:  "ENUM_VALUE3519",
+		43:  "ENUM_VALUE3520",
+		44:  "ENUM_VALUE3521",
+		45:  "ENUM_VALUE3522",
+		46:  "ENUM_VALUE3523",
+		47:  "ENUM_VALUE3524",
+		48:  "ENUM_VALUE3525",
+		49:  "ENUM_VALUE3526",
+		50:  "ENUM_VALUE3527",
+		51:  "ENUM_VALUE3528",
+		52:  "ENUM_VALUE3529",
+		53:  "ENUM_VALUE3530",
+		54:  "ENUM_VALUE3531",
+		55:  "ENUM_VALUE3532",
+		56:  "ENUM_VALUE3533",
+		57:  "ENUM_VALUE3534",
+		58:  "ENUM_VALUE3535",
+		59:  "ENUM_VALUE3536",
+		60:  "ENUM_VALUE3537",
+		61:  "ENUM_VALUE3538",
+		62:  "ENUM_VALUE3539",
+		63:  "ENUM_VALUE3540",
+		64:  "ENUM_VALUE3541",
+		65:  "ENUM_VALUE3542",
+		66:  "ENUM_VALUE3543",
+		67:  "ENUM_VALUE3544",
+		68:  "ENUM_VALUE3545",
+		69:  "ENUM_VALUE3546",
+		70:  "ENUM_VALUE3547",
+		71:  "ENUM_VALUE3548",
+		72:  "ENUM_VALUE3549",
+		73:  "ENUM_VALUE3550",
+		74:  "ENUM_VALUE3551",
+		75:  "ENUM_VALUE3552",
+		76:  "ENUM_VALUE3553",
+		77:  "ENUM_VALUE3554",
+		78:  "ENUM_VALUE3555",
+		79:  "ENUM_VALUE3556",
+		80:  "ENUM_VALUE3557",
+		81:  "ENUM_VALUE3558",
+		82:  "ENUM_VALUE3559",
+		83:  "ENUM_VALUE3560",
+		84:  "ENUM_VALUE3561",
+		85:  "ENUM_VALUE3562",
+		86:  "ENUM_VALUE3563",
+		87:  "ENUM_VALUE3564",
+		88:  "ENUM_VALUE3565",
+		89:  "ENUM_VALUE3566",
+		90:  "ENUM_VALUE3567",
+		91:  "ENUM_VALUE3568",
+		92:  "ENUM_VALUE3569",
+		93:  "ENUM_VALUE3570",
+		94:  "ENUM_VALUE3571",
+		95:  "ENUM_VALUE3572",
+		96:  "ENUM_VALUE3573",
+		97:  "ENUM_VALUE3574",
+		98:  "ENUM_VALUE3575",
+		99:  "ENUM_VALUE3576",
+		100: "ENUM_VALUE3577",
+		101: "ENUM_VALUE3578",
+		102: "ENUM_VALUE3579",
+		103: "ENUM_VALUE3580",
+		104: "ENUM_VALUE3581",
+		105: "ENUM_VALUE3582",
+		106: "ENUM_VALUE3583",
+		107: "ENUM_VALUE3584",
+		108: "ENUM_VALUE3585",
+		109: "ENUM_VALUE3586",
+		110: "ENUM_VALUE3587",
+		111: "ENUM_VALUE3588",
+		112: "ENUM_VALUE3589",
+		113: "ENUM_VALUE3590",
+		114: "ENUM_VALUE3591",
+		115: "ENUM_VALUE3592",
+		116: "ENUM_VALUE3593",
+		117: "ENUM_VALUE3594",
+		118: "ENUM_VALUE3595",
+		119: "ENUM_VALUE3596",
+		120: "ENUM_VALUE3597",
+		121: "ENUM_VALUE3598",
+		122: "ENUM_VALUE3599",
+		123: "ENUM_VALUE3600",
+		124: "ENUM_VALUE3601",
+		125: "ENUM_VALUE3602",
+		126: "ENUM_VALUE3603",
+		127: "ENUM_VALUE3604",
+		128: "ENUM_VALUE3605",
+		129: "ENUM_VALUE3606",
+		130: "ENUM_VALUE3607",
+		131: "ENUM_VALUE3608",
+		132: "ENUM_VALUE3609",
+		133: "ENUM_VALUE3610",
+		134: "ENUM_VALUE3611",
+		135: "ENUM_VALUE3612",
+		136: "ENUM_VALUE3613",
+		137: "ENUM_VALUE3614",
+		138: "ENUM_VALUE3615",
+		139: "ENUM_VALUE3616",
+		140: "ENUM_VALUE3617",
+		141: "ENUM_VALUE3618",
+		142: "ENUM_VALUE3619",
+		143: "ENUM_VALUE3620",
+		144: "ENUM_VALUE3621",
+		145: "ENUM_VALUE3622",
+		146: "ENUM_VALUE3623",
+		147: "ENUM_VALUE3624",
+		148: "ENUM_VALUE3625",
+		149: "ENUM_VALUE3626",
+		150: "ENUM_VALUE3627",
+		151: "ENUM_VALUE3628",
+		152: "ENUM_VALUE3629",
+		153: "ENUM_VALUE3630",
+		154: "ENUM_VALUE3631",
+		155: "ENUM_VALUE3632",
+		156: "ENUM_VALUE3633",
+		157: "ENUM_VALUE3634",
+		158: "ENUM_VALUE3635",
+		159: "ENUM_VALUE3636",
+		160: "ENUM_VALUE3637",
+		161: "ENUM_VALUE3638",
+		162: "ENUM_VALUE3639",
+		163: "ENUM_VALUE3640",
+		164: "ENUM_VALUE3641",
+		165: "ENUM_VALUE3642",
+		166: "ENUM_VALUE3643",
+		167: "ENUM_VALUE3644",
+		168: "ENUM_VALUE3645",
+		169: "ENUM_VALUE3646",
+		170: "ENUM_VALUE3647",
+		171: "ENUM_VALUE3648",
+		172: "ENUM_VALUE3649",
+		173: "ENUM_VALUE3650",
+		174: "ENUM_VALUE3651",
+		175: "ENUM_VALUE3652",
+		176: "ENUM_VALUE3653",
+		177: "ENUM_VALUE3654",
+		178: "ENUM_VALUE3655",
+		179: "ENUM_VALUE3656",
+		180: "ENUM_VALUE3657",
+		181: "ENUM_VALUE3658",
+		182: "ENUM_VALUE3659",
+		183: "ENUM_VALUE3660",
+	}
+	Enum3476_value = map[string]int32{
+		"ENUM_VALUE3477": 0,
+		"ENUM_VALUE3478": 1,
+		"ENUM_VALUE3479": 2,
+		"ENUM_VALUE3480": 3,
+		"ENUM_VALUE3481": 4,
+		"ENUM_VALUE3482": 5,
+		"ENUM_VALUE3483": 6,
+		"ENUM_VALUE3484": 7,
+		"ENUM_VALUE3485": 8,
+		"ENUM_VALUE3486": 9,
+		"ENUM_VALUE3487": 10,
+		"ENUM_VALUE3488": 11,
+		"ENUM_VALUE3489": 12,
+		"ENUM_VALUE3490": 13,
+		"ENUM_VALUE3491": 14,
+		"ENUM_VALUE3492": 15,
+		"ENUM_VALUE3493": 16,
+		"ENUM_VALUE3494": 17,
+		"ENUM_VALUE3495": 18,
+		"ENUM_VALUE3496": 19,
+		"ENUM_VALUE3497": 20,
+		"ENUM_VALUE3498": 21,
+		"ENUM_VALUE3499": 22,
+		"ENUM_VALUE3500": 23,
+		"ENUM_VALUE3501": 24,
+		"ENUM_VALUE3502": 25,
+		"ENUM_VALUE3503": 26,
+		"ENUM_VALUE3504": 27,
+		"ENUM_VALUE3505": 28,
+		"ENUM_VALUE3506": 29,
+		"ENUM_VALUE3507": 30,
+		"ENUM_VALUE3508": 31,
+		"ENUM_VALUE3509": 32,
+		"ENUM_VALUE3510": 33,
+		"ENUM_VALUE3511": 34,
+		"ENUM_VALUE3512": 35,
+		"ENUM_VALUE3513": 36,
+		"ENUM_VALUE3514": 37,
+		"ENUM_VALUE3515": 38,
+		"ENUM_VALUE3516": 39,
+		"ENUM_VALUE3517": 40,
+		"ENUM_VALUE3518": 41,
+		"ENUM_VALUE3519": 42,
+		"ENUM_VALUE3520": 43,
+		"ENUM_VALUE3521": 44,
+		"ENUM_VALUE3522": 45,
+		"ENUM_VALUE3523": 46,
+		"ENUM_VALUE3524": 47,
+		"ENUM_VALUE3525": 48,
+		"ENUM_VALUE3526": 49,
+		"ENUM_VALUE3527": 50,
+		"ENUM_VALUE3528": 51,
+		"ENUM_VALUE3529": 52,
+		"ENUM_VALUE3530": 53,
+		"ENUM_VALUE3531": 54,
+		"ENUM_VALUE3532": 55,
+		"ENUM_VALUE3533": 56,
+		"ENUM_VALUE3534": 57,
+		"ENUM_VALUE3535": 58,
+		"ENUM_VALUE3536": 59,
+		"ENUM_VALUE3537": 60,
+		"ENUM_VALUE3538": 61,
+		"ENUM_VALUE3539": 62,
+		"ENUM_VALUE3540": 63,
+		"ENUM_VALUE3541": 64,
+		"ENUM_VALUE3542": 65,
+		"ENUM_VALUE3543": 66,
+		"ENUM_VALUE3544": 67,
+		"ENUM_VALUE3545": 68,
+		"ENUM_VALUE3546": 69,
+		"ENUM_VALUE3547": 70,
+		"ENUM_VALUE3548": 71,
+		"ENUM_VALUE3549": 72,
+		"ENUM_VALUE3550": 73,
+		"ENUM_VALUE3551": 74,
+		"ENUM_VALUE3552": 75,
+		"ENUM_VALUE3553": 76,
+		"ENUM_VALUE3554": 77,
+		"ENUM_VALUE3555": 78,
+		"ENUM_VALUE3556": 79,
+		"ENUM_VALUE3557": 80,
+		"ENUM_VALUE3558": 81,
+		"ENUM_VALUE3559": 82,
+		"ENUM_VALUE3560": 83,
+		"ENUM_VALUE3561": 84,
+		"ENUM_VALUE3562": 85,
+		"ENUM_VALUE3563": 86,
+		"ENUM_VALUE3564": 87,
+		"ENUM_VALUE3565": 88,
+		"ENUM_VALUE3566": 89,
+		"ENUM_VALUE3567": 90,
+		"ENUM_VALUE3568": 91,
+		"ENUM_VALUE3569": 92,
+		"ENUM_VALUE3570": 93,
+		"ENUM_VALUE3571": 94,
+		"ENUM_VALUE3572": 95,
+		"ENUM_VALUE3573": 96,
+		"ENUM_VALUE3574": 97,
+		"ENUM_VALUE3575": 98,
+		"ENUM_VALUE3576": 99,
+		"ENUM_VALUE3577": 100,
+		"ENUM_VALUE3578": 101,
+		"ENUM_VALUE3579": 102,
+		"ENUM_VALUE3580": 103,
+		"ENUM_VALUE3581": 104,
+		"ENUM_VALUE3582": 105,
+		"ENUM_VALUE3583": 106,
+		"ENUM_VALUE3584": 107,
+		"ENUM_VALUE3585": 108,
+		"ENUM_VALUE3586": 109,
+		"ENUM_VALUE3587": 110,
+		"ENUM_VALUE3588": 111,
+		"ENUM_VALUE3589": 112,
+		"ENUM_VALUE3590": 113,
+		"ENUM_VALUE3591": 114,
+		"ENUM_VALUE3592": 115,
+		"ENUM_VALUE3593": 116,
+		"ENUM_VALUE3594": 117,
+		"ENUM_VALUE3595": 118,
+		"ENUM_VALUE3596": 119,
+		"ENUM_VALUE3597": 120,
+		"ENUM_VALUE3598": 121,
+		"ENUM_VALUE3599": 122,
+		"ENUM_VALUE3600": 123,
+		"ENUM_VALUE3601": 124,
+		"ENUM_VALUE3602": 125,
+		"ENUM_VALUE3603": 126,
+		"ENUM_VALUE3604": 127,
+		"ENUM_VALUE3605": 128,
+		"ENUM_VALUE3606": 129,
+		"ENUM_VALUE3607": 130,
+		"ENUM_VALUE3608": 131,
+		"ENUM_VALUE3609": 132,
+		"ENUM_VALUE3610": 133,
+		"ENUM_VALUE3611": 134,
+		"ENUM_VALUE3612": 135,
+		"ENUM_VALUE3613": 136,
+		"ENUM_VALUE3614": 137,
+		"ENUM_VALUE3615": 138,
+		"ENUM_VALUE3616": 139,
+		"ENUM_VALUE3617": 140,
+		"ENUM_VALUE3618": 141,
+		"ENUM_VALUE3619": 142,
+		"ENUM_VALUE3620": 143,
+		"ENUM_VALUE3621": 144,
+		"ENUM_VALUE3622": 145,
+		"ENUM_VALUE3623": 146,
+		"ENUM_VALUE3624": 147,
+		"ENUM_VALUE3625": 148,
+		"ENUM_VALUE3626": 149,
+		"ENUM_VALUE3627": 150,
+		"ENUM_VALUE3628": 151,
+		"ENUM_VALUE3629": 152,
+		"ENUM_VALUE3630": 153,
+		"ENUM_VALUE3631": 154,
+		"ENUM_VALUE3632": 155,
+		"ENUM_VALUE3633": 156,
+		"ENUM_VALUE3634": 157,
+		"ENUM_VALUE3635": 158,
+		"ENUM_VALUE3636": 159,
+		"ENUM_VALUE3637": 160,
+		"ENUM_VALUE3638": 161,
+		"ENUM_VALUE3639": 162,
+		"ENUM_VALUE3640": 163,
+		"ENUM_VALUE3641": 164,
+		"ENUM_VALUE3642": 165,
+		"ENUM_VALUE3643": 166,
+		"ENUM_VALUE3644": 167,
+		"ENUM_VALUE3645": 168,
+		"ENUM_VALUE3646": 169,
+		"ENUM_VALUE3647": 170,
+		"ENUM_VALUE3648": 171,
+		"ENUM_VALUE3649": 172,
+		"ENUM_VALUE3650": 173,
+		"ENUM_VALUE3651": 174,
+		"ENUM_VALUE3652": 175,
+		"ENUM_VALUE3653": 176,
+		"ENUM_VALUE3654": 177,
+		"ENUM_VALUE3655": 178,
+		"ENUM_VALUE3656": 179,
+		"ENUM_VALUE3657": 180,
+		"ENUM_VALUE3658": 181,
+		"ENUM_VALUE3659": 182,
+		"ENUM_VALUE3660": 183,
+	}
+)
+
+func (x Enum3476) Enum() *Enum3476 {
+	p := new(Enum3476)
+	*p = x
+	return p
+}
+
+func (x Enum3476) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum3476) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[1].Descriptor()
+}
+
+func (Enum3476) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[1]
+}
+
+func (x Enum3476) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum3476) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum3476(num)
+	return nil
+}
+
+// Deprecated: Use Enum3476.Descriptor instead.
+func (Enum3476) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{1}
+}
+
+type Enum3805 int32
+
+const (
+	Enum3805_ENUM_VALUE3806 Enum3805 = 0
+	Enum3805_ENUM_VALUE3807 Enum3805 = 1
+	Enum3805_ENUM_VALUE3808 Enum3805 = 2
+	Enum3805_ENUM_VALUE3809 Enum3805 = 3
+	Enum3805_ENUM_VALUE3810 Enum3805 = 4
+	Enum3805_ENUM_VALUE3811 Enum3805 = 5
+	Enum3805_ENUM_VALUE3812 Enum3805 = 6
+	Enum3805_ENUM_VALUE3813 Enum3805 = 7
+	Enum3805_ENUM_VALUE3814 Enum3805 = 8
+	Enum3805_ENUM_VALUE3815 Enum3805 = 9
+	Enum3805_ENUM_VALUE3816 Enum3805 = 11
+	Enum3805_ENUM_VALUE3817 Enum3805 = 10
+)
+
+// Enum value maps for Enum3805.
+var (
+	Enum3805_name = map[int32]string{
+		0:  "ENUM_VALUE3806",
+		1:  "ENUM_VALUE3807",
+		2:  "ENUM_VALUE3808",
+		3:  "ENUM_VALUE3809",
+		4:  "ENUM_VALUE3810",
+		5:  "ENUM_VALUE3811",
+		6:  "ENUM_VALUE3812",
+		7:  "ENUM_VALUE3813",
+		8:  "ENUM_VALUE3814",
+		9:  "ENUM_VALUE3815",
+		11: "ENUM_VALUE3816",
+		10: "ENUM_VALUE3817",
+	}
+	Enum3805_value = map[string]int32{
+		"ENUM_VALUE3806": 0,
+		"ENUM_VALUE3807": 1,
+		"ENUM_VALUE3808": 2,
+		"ENUM_VALUE3809": 3,
+		"ENUM_VALUE3810": 4,
+		"ENUM_VALUE3811": 5,
+		"ENUM_VALUE3812": 6,
+		"ENUM_VALUE3813": 7,
+		"ENUM_VALUE3814": 8,
+		"ENUM_VALUE3815": 9,
+		"ENUM_VALUE3816": 11,
+		"ENUM_VALUE3817": 10,
+	}
+)
+
+func (x Enum3805) Enum() *Enum3805 {
+	p := new(Enum3805)
+	*p = x
+	return p
+}
+
+func (x Enum3805) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum3805) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[2].Descriptor()
+}
+
+func (Enum3805) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[2]
+}
+
+func (x Enum3805) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum3805) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum3805(num)
+	return nil
+}
+
+// Deprecated: Use Enum3805.Descriptor instead.
+func (Enum3805) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{2}
+}
+
+type Enum3783 int32
+
+const (
+	Enum3783_ENUM_VALUE3784 Enum3783 = 0
+	Enum3783_ENUM_VALUE3785 Enum3783 = 1
+	Enum3783_ENUM_VALUE3786 Enum3783 = 2
+	Enum3783_ENUM_VALUE3787 Enum3783 = 3
+	Enum3783_ENUM_VALUE3788 Enum3783 = 4
+	Enum3783_ENUM_VALUE3789 Enum3783 = 5
+	Enum3783_ENUM_VALUE3790 Enum3783 = 6
+	Enum3783_ENUM_VALUE3791 Enum3783 = 7
+	Enum3783_ENUM_VALUE3792 Enum3783 = 8
+	Enum3783_ENUM_VALUE3793 Enum3783 = 9
+	Enum3783_ENUM_VALUE3794 Enum3783 = 10
+	Enum3783_ENUM_VALUE3795 Enum3783 = 11
+	Enum3783_ENUM_VALUE3796 Enum3783 = 12
+	Enum3783_ENUM_VALUE3797 Enum3783 = 13
+	Enum3783_ENUM_VALUE3798 Enum3783 = 14
+	Enum3783_ENUM_VALUE3799 Enum3783 = 15
+	Enum3783_ENUM_VALUE3800 Enum3783 = 16
+	Enum3783_ENUM_VALUE3801 Enum3783 = 20
+	Enum3783_ENUM_VALUE3802 Enum3783 = 21
+	Enum3783_ENUM_VALUE3803 Enum3783 = 50
+)
+
+// Enum value maps for Enum3783.
+var (
+	Enum3783_name = map[int32]string{
+		0:  "ENUM_VALUE3784",
+		1:  "ENUM_VALUE3785",
+		2:  "ENUM_VALUE3786",
+		3:  "ENUM_VALUE3787",
+		4:  "ENUM_VALUE3788",
+		5:  "ENUM_VALUE3789",
+		6:  "ENUM_VALUE3790",
+		7:  "ENUM_VALUE3791",
+		8:  "ENUM_VALUE3792",
+		9:  "ENUM_VALUE3793",
+		10: "ENUM_VALUE3794",
+		11: "ENUM_VALUE3795",
+		12: "ENUM_VALUE3796",
+		13: "ENUM_VALUE3797",
+		14: "ENUM_VALUE3798",
+		15: "ENUM_VALUE3799",
+		16: "ENUM_VALUE3800",
+		20: "ENUM_VALUE3801",
+		21: "ENUM_VALUE3802",
+		50: "ENUM_VALUE3803",
+	}
+	Enum3783_value = map[string]int32{
+		"ENUM_VALUE3784": 0,
+		"ENUM_VALUE3785": 1,
+		"ENUM_VALUE3786": 2,
+		"ENUM_VALUE3787": 3,
+		"ENUM_VALUE3788": 4,
+		"ENUM_VALUE3789": 5,
+		"ENUM_VALUE3790": 6,
+		"ENUM_VALUE3791": 7,
+		"ENUM_VALUE3792": 8,
+		"ENUM_VALUE3793": 9,
+		"ENUM_VALUE3794": 10,
+		"ENUM_VALUE3795": 11,
+		"ENUM_VALUE3796": 12,
+		"ENUM_VALUE3797": 13,
+		"ENUM_VALUE3798": 14,
+		"ENUM_VALUE3799": 15,
+		"ENUM_VALUE3800": 16,
+		"ENUM_VALUE3801": 20,
+		"ENUM_VALUE3802": 21,
+		"ENUM_VALUE3803": 50,
+	}
+)
+
+func (x Enum3783) Enum() *Enum3783 {
+	p := new(Enum3783)
+	*p = x
+	return p
+}
+
+func (x Enum3783) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum3783) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[3].Descriptor()
+}
+
+func (Enum3783) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[3]
+}
+
+func (x Enum3783) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum3783) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum3783(num)
+	return nil
+}
+
+// Deprecated: Use Enum3783.Descriptor instead.
+func (Enum3783) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{3}
+}
+
+type Enum3851 int32
+
+const (
+	Enum3851_ENUM_VALUE3852 Enum3851 = 0
+	Enum3851_ENUM_VALUE3853 Enum3851 = 1
+	Enum3851_ENUM_VALUE3854 Enum3851 = 2
+	Enum3851_ENUM_VALUE3855 Enum3851 = 3
+	Enum3851_ENUM_VALUE3856 Enum3851 = 4
+	Enum3851_ENUM_VALUE3857 Enum3851 = 5
+	Enum3851_ENUM_VALUE3858 Enum3851 = 6
+	Enum3851_ENUM_VALUE3859 Enum3851 = 7
+	Enum3851_ENUM_VALUE3860 Enum3851 = 8
+	Enum3851_ENUM_VALUE3861 Enum3851 = 9
+	Enum3851_ENUM_VALUE3862 Enum3851 = 10
+	Enum3851_ENUM_VALUE3863 Enum3851 = 11
+	Enum3851_ENUM_VALUE3864 Enum3851 = 12
+	Enum3851_ENUM_VALUE3865 Enum3851 = 13
+	Enum3851_ENUM_VALUE3866 Enum3851 = 14
+	Enum3851_ENUM_VALUE3867 Enum3851 = 15
+	Enum3851_ENUM_VALUE3868 Enum3851 = 16
+	Enum3851_ENUM_VALUE3869 Enum3851 = 17
+)
+
+// Enum value maps for Enum3851.
+var (
+	Enum3851_name = map[int32]string{
+		0:  "ENUM_VALUE3852",
+		1:  "ENUM_VALUE3853",
+		2:  "ENUM_VALUE3854",
+		3:  "ENUM_VALUE3855",
+		4:  "ENUM_VALUE3856",
+		5:  "ENUM_VALUE3857",
+		6:  "ENUM_VALUE3858",
+		7:  "ENUM_VALUE3859",
+		8:  "ENUM_VALUE3860",
+		9:  "ENUM_VALUE3861",
+		10: "ENUM_VALUE3862",
+		11: "ENUM_VALUE3863",
+		12: "ENUM_VALUE3864",
+		13: "ENUM_VALUE3865",
+		14: "ENUM_VALUE3866",
+		15: "ENUM_VALUE3867",
+		16: "ENUM_VALUE3868",
+		17: "ENUM_VALUE3869",
+	}
+	Enum3851_value = map[string]int32{
+		"ENUM_VALUE3852": 0,
+		"ENUM_VALUE3853": 1,
+		"ENUM_VALUE3854": 2,
+		"ENUM_VALUE3855": 3,
+		"ENUM_VALUE3856": 4,
+		"ENUM_VALUE3857": 5,
+		"ENUM_VALUE3858": 6,
+		"ENUM_VALUE3859": 7,
+		"ENUM_VALUE3860": 8,
+		"ENUM_VALUE3861": 9,
+		"ENUM_VALUE3862": 10,
+		"ENUM_VALUE3863": 11,
+		"ENUM_VALUE3864": 12,
+		"ENUM_VALUE3865": 13,
+		"ENUM_VALUE3866": 14,
+		"ENUM_VALUE3867": 15,
+		"ENUM_VALUE3868": 16,
+		"ENUM_VALUE3869": 17,
+	}
+)
+
+func (x Enum3851) Enum() *Enum3851 {
+	p := new(Enum3851)
+	*p = x
+	return p
+}
+
+func (x Enum3851) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum3851) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[4].Descriptor()
+}
+
+func (Enum3851) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[4]
+}
+
+func (x Enum3851) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum3851) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum3851(num)
+	return nil
+}
+
+// Deprecated: Use Enum3851.Descriptor instead.
+func (Enum3851) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{4}
+}
+
+type UnusedEnum int32
+
+const (
+	UnusedEnum_UNUSED_ENUM_VALUE1 UnusedEnum = 0
+	UnusedEnum_UNUSED_ENUM_VALUE2 UnusedEnum = 1
+)
+
+// Enum value maps for UnusedEnum.
+var (
+	UnusedEnum_name = map[int32]string{
+		0: "UNUSED_ENUM_VALUE1",
+		1: "UNUSED_ENUM_VALUE2",
+	}
+	UnusedEnum_value = map[string]int32{
+		"UNUSED_ENUM_VALUE1": 0,
+		"UNUSED_ENUM_VALUE2": 1,
+	}
+)
+
+func (x UnusedEnum) Enum() *UnusedEnum {
+	p := new(UnusedEnum)
+	*p = x
+	return p
+}
+
+func (x UnusedEnum) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (UnusedEnum) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[5].Descriptor()
+}
+
+func (UnusedEnum) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[5]
+}
+
+func (x UnusedEnum) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *UnusedEnum) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = UnusedEnum(num)
+	return nil
+}
+
+// Deprecated: Use UnusedEnum.Descriptor instead.
+func (UnusedEnum) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{5}
+}
+
+type Enum4146 int32
+
+const (
+	Enum4146_ENUM_VALUE4147 Enum4146 = 0
+	Enum4146_ENUM_VALUE4148 Enum4146 = 1
+	Enum4146_ENUM_VALUE4149 Enum4146 = 2
+	Enum4146_ENUM_VALUE4150 Enum4146 = 3
+	Enum4146_ENUM_VALUE4151 Enum4146 = 4
+)
+
+// Enum value maps for Enum4146.
+var (
+	Enum4146_name = map[int32]string{
+		0: "ENUM_VALUE4147",
+		1: "ENUM_VALUE4148",
+		2: "ENUM_VALUE4149",
+		3: "ENUM_VALUE4150",
+		4: "ENUM_VALUE4151",
+	}
+	Enum4146_value = map[string]int32{
+		"ENUM_VALUE4147": 0,
+		"ENUM_VALUE4148": 1,
+		"ENUM_VALUE4149": 2,
+		"ENUM_VALUE4150": 3,
+		"ENUM_VALUE4151": 4,
+	}
+)
+
+func (x Enum4146) Enum() *Enum4146 {
+	p := new(Enum4146)
+	*p = x
+	return p
+}
+
+func (x Enum4146) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum4146) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[6].Descriptor()
+}
+
+func (Enum4146) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[6]
+}
+
+func (x Enum4146) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum4146) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum4146(num)
+	return nil
+}
+
+// Deprecated: Use Enum4146.Descriptor instead.
+func (Enum4146) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{6}
+}
+
+type Enum4160 int32
+
+const (
+	Enum4160_ENUM_VALUE4161 Enum4160 = 0
+	Enum4160_ENUM_VALUE4162 Enum4160 = 1
+)
+
+// Enum value maps for Enum4160.
+var (
+	Enum4160_name = map[int32]string{
+		0: "ENUM_VALUE4161",
+		1: "ENUM_VALUE4162",
+	}
+	Enum4160_value = map[string]int32{
+		"ENUM_VALUE4161": 0,
+		"ENUM_VALUE4162": 1,
+	}
+)
+
+func (x Enum4160) Enum() *Enum4160 {
+	p := new(Enum4160)
+	*p = x
+	return p
+}
+
+func (x Enum4160) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum4160) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[7].Descriptor()
+}
+
+func (Enum4160) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[7]
+}
+
+func (x Enum4160) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum4160) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum4160(num)
+	return nil
+}
+
+// Deprecated: Use Enum4160.Descriptor instead.
+func (Enum4160) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{7}
+}
+
+type Enum4152 int32
+
+const (
+	Enum4152_ENUM_VALUE4153 Enum4152 = 0
+	Enum4152_ENUM_VALUE4154 Enum4152 = 1
+	Enum4152_ENUM_VALUE4155 Enum4152 = 2
+	Enum4152_ENUM_VALUE4156 Enum4152 = 3
+	Enum4152_ENUM_VALUE4157 Enum4152 = 4
+	Enum4152_ENUM_VALUE4158 Enum4152 = 5
+	Enum4152_ENUM_VALUE4159 Enum4152 = 6
+)
+
+// Enum value maps for Enum4152.
+var (
+	Enum4152_name = map[int32]string{
+		0: "ENUM_VALUE4153",
+		1: "ENUM_VALUE4154",
+		2: "ENUM_VALUE4155",
+		3: "ENUM_VALUE4156",
+		4: "ENUM_VALUE4157",
+		5: "ENUM_VALUE4158",
+		6: "ENUM_VALUE4159",
+	}
+	Enum4152_value = map[string]int32{
+		"ENUM_VALUE4153": 0,
+		"ENUM_VALUE4154": 1,
+		"ENUM_VALUE4155": 2,
+		"ENUM_VALUE4156": 3,
+		"ENUM_VALUE4157": 4,
+		"ENUM_VALUE4158": 5,
+		"ENUM_VALUE4159": 6,
+	}
+)
+
+func (x Enum4152) Enum() *Enum4152 {
+	p := new(Enum4152)
+	*p = x
+	return p
+}
+
+func (x Enum4152) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum4152) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[8].Descriptor()
+}
+
+func (Enum4152) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[8]
+}
+
+func (x Enum4152) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum4152) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum4152(num)
+	return nil
+}
+
+// Deprecated: Use Enum4152.Descriptor instead.
+func (Enum4152) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{8}
+}
+
+type Enum6025 int32
+
+const (
+	Enum6025_ENUM_VALUE6026 Enum6025 = 0
+	Enum6025_ENUM_VALUE6027 Enum6025 = 1
+	Enum6025_ENUM_VALUE6028 Enum6025 = 2
+	Enum6025_ENUM_VALUE6029 Enum6025 = 3
+	Enum6025_ENUM_VALUE6030 Enum6025 = 4
+	Enum6025_ENUM_VALUE6031 Enum6025 = 5
+	Enum6025_ENUM_VALUE6032 Enum6025 = 6
+	Enum6025_ENUM_VALUE6033 Enum6025 = 7
+	Enum6025_ENUM_VALUE6034 Enum6025 = 8
+	Enum6025_ENUM_VALUE6035 Enum6025 = 9
+	Enum6025_ENUM_VALUE6036 Enum6025 = 10
+	Enum6025_ENUM_VALUE6037 Enum6025 = 11
+	Enum6025_ENUM_VALUE6038 Enum6025 = 12
+	Enum6025_ENUM_VALUE6039 Enum6025 = 13
+	Enum6025_ENUM_VALUE6040 Enum6025 = 14
+	Enum6025_ENUM_VALUE6041 Enum6025 = 15
+	Enum6025_ENUM_VALUE6042 Enum6025 = 16
+	Enum6025_ENUM_VALUE6043 Enum6025 = 17
+	Enum6025_ENUM_VALUE6044 Enum6025 = 18
+	Enum6025_ENUM_VALUE6045 Enum6025 = 19
+	Enum6025_ENUM_VALUE6046 Enum6025 = 20
+	Enum6025_ENUM_VALUE6047 Enum6025 = 21
+)
+
+// Enum value maps for Enum6025.
+var (
+	Enum6025_name = map[int32]string{
+		0:  "ENUM_VALUE6026",
+		1:  "ENUM_VALUE6027",
+		2:  "ENUM_VALUE6028",
+		3:  "ENUM_VALUE6029",
+		4:  "ENUM_VALUE6030",
+		5:  "ENUM_VALUE6031",
+		6:  "ENUM_VALUE6032",
+		7:  "ENUM_VALUE6033",
+		8:  "ENUM_VALUE6034",
+		9:  "ENUM_VALUE6035",
+		10: "ENUM_VALUE6036",
+		11: "ENUM_VALUE6037",
+		12: "ENUM_VALUE6038",
+		13: "ENUM_VALUE6039",
+		14: "ENUM_VALUE6040",
+		15: "ENUM_VALUE6041",
+		16: "ENUM_VALUE6042",
+		17: "ENUM_VALUE6043",
+		18: "ENUM_VALUE6044",
+		19: "ENUM_VALUE6045",
+		20: "ENUM_VALUE6046",
+		21: "ENUM_VALUE6047",
+	}
+	Enum6025_value = map[string]int32{
+		"ENUM_VALUE6026": 0,
+		"ENUM_VALUE6027": 1,
+		"ENUM_VALUE6028": 2,
+		"ENUM_VALUE6029": 3,
+		"ENUM_VALUE6030": 4,
+		"ENUM_VALUE6031": 5,
+		"ENUM_VALUE6032": 6,
+		"ENUM_VALUE6033": 7,
+		"ENUM_VALUE6034": 8,
+		"ENUM_VALUE6035": 9,
+		"ENUM_VALUE6036": 10,
+		"ENUM_VALUE6037": 11,
+		"ENUM_VALUE6038": 12,
+		"ENUM_VALUE6039": 13,
+		"ENUM_VALUE6040": 14,
+		"ENUM_VALUE6041": 15,
+		"ENUM_VALUE6042": 16,
+		"ENUM_VALUE6043": 17,
+		"ENUM_VALUE6044": 18,
+		"ENUM_VALUE6045": 19,
+		"ENUM_VALUE6046": 20,
+		"ENUM_VALUE6047": 21,
+	}
+)
+
+func (x Enum6025) Enum() *Enum6025 {
+	p := new(Enum6025)
+	*p = x
+	return p
+}
+
+func (x Enum6025) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum6025) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[9].Descriptor()
+}
+
+func (Enum6025) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[9]
+}
+
+func (x Enum6025) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum6025) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum6025(num)
+	return nil
+}
+
+// Deprecated: Use Enum6025.Descriptor instead.
+func (Enum6025) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{9}
+}
+
+type Enum6065 int32
+
+const (
+	Enum6065_ENUM_VALUE6066 Enum6065 = 0
+	Enum6065_ENUM_VALUE6067 Enum6065 = 1
+	Enum6065_ENUM_VALUE6068 Enum6065 = 2
+	Enum6065_ENUM_VALUE6069 Enum6065 = 3
+	Enum6065_ENUM_VALUE6070 Enum6065 = 4
+	Enum6065_ENUM_VALUE6071 Enum6065 = 5
+	Enum6065_ENUM_VALUE6072 Enum6065 = 6
+	Enum6065_ENUM_VALUE6073 Enum6065 = 7
+	Enum6065_ENUM_VALUE6074 Enum6065 = 8
+	Enum6065_ENUM_VALUE6075 Enum6065 = 9
+	Enum6065_ENUM_VALUE6076 Enum6065 = 10
+	Enum6065_ENUM_VALUE6077 Enum6065 = 11
+	Enum6065_ENUM_VALUE6078 Enum6065 = 12
+	Enum6065_ENUM_VALUE6079 Enum6065 = 13
+	Enum6065_ENUM_VALUE6080 Enum6065 = 14
+)
+
+// Enum value maps for Enum6065.
+var (
+	Enum6065_name = map[int32]string{
+		0:  "ENUM_VALUE6066",
+		1:  "ENUM_VALUE6067",
+		2:  "ENUM_VALUE6068",
+		3:  "ENUM_VALUE6069",
+		4:  "ENUM_VALUE6070",
+		5:  "ENUM_VALUE6071",
+		6:  "ENUM_VALUE6072",
+		7:  "ENUM_VALUE6073",
+		8:  "ENUM_VALUE6074",
+		9:  "ENUM_VALUE6075",
+		10: "ENUM_VALUE6076",
+		11: "ENUM_VALUE6077",
+		12: "ENUM_VALUE6078",
+		13: "ENUM_VALUE6079",
+		14: "ENUM_VALUE6080",
+	}
+	Enum6065_value = map[string]int32{
+		"ENUM_VALUE6066": 0,
+		"ENUM_VALUE6067": 1,
+		"ENUM_VALUE6068": 2,
+		"ENUM_VALUE6069": 3,
+		"ENUM_VALUE6070": 4,
+		"ENUM_VALUE6071": 5,
+		"ENUM_VALUE6072": 6,
+		"ENUM_VALUE6073": 7,
+		"ENUM_VALUE6074": 8,
+		"ENUM_VALUE6075": 9,
+		"ENUM_VALUE6076": 10,
+		"ENUM_VALUE6077": 11,
+		"ENUM_VALUE6078": 12,
+		"ENUM_VALUE6079": 13,
+		"ENUM_VALUE6080": 14,
+	}
+)
+
+func (x Enum6065) Enum() *Enum6065 {
+	p := new(Enum6065)
+	*p = x
+	return p
+}
+
+func (x Enum6065) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum6065) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[10].Descriptor()
+}
+
+func (Enum6065) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[10]
+}
+
+func (x Enum6065) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum6065) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum6065(num)
+	return nil
+}
+
+// Deprecated: Use Enum6065.Descriptor instead.
+func (Enum6065) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{10}
+}
+
+type Enum6579 int32
+
+const (
+	Enum6579_ENUM_VALUE6580 Enum6579 = 0
+	Enum6579_ENUM_VALUE6581 Enum6579 = 2
+	Enum6579_ENUM_VALUE6582 Enum6579 = 3
+	Enum6579_ENUM_VALUE6583 Enum6579 = 5
+	Enum6579_ENUM_VALUE6584 Enum6579 = 10
+	Enum6579_ENUM_VALUE6585 Enum6579 = 15
+	Enum6579_ENUM_VALUE6586 Enum6579 = 25
+	Enum6579_ENUM_VALUE6587 Enum6579 = 30
+)
+
+// Enum value maps for Enum6579.
+var (
+	Enum6579_name = map[int32]string{
+		0:  "ENUM_VALUE6580",
+		2:  "ENUM_VALUE6581",
+		3:  "ENUM_VALUE6582",
+		5:  "ENUM_VALUE6583",
+		10: "ENUM_VALUE6584",
+		15: "ENUM_VALUE6585",
+		25: "ENUM_VALUE6586",
+		30: "ENUM_VALUE6587",
+	}
+	Enum6579_value = map[string]int32{
+		"ENUM_VALUE6580": 0,
+		"ENUM_VALUE6581": 2,
+		"ENUM_VALUE6582": 3,
+		"ENUM_VALUE6583": 5,
+		"ENUM_VALUE6584": 10,
+		"ENUM_VALUE6585": 15,
+		"ENUM_VALUE6586": 25,
+		"ENUM_VALUE6587": 30,
+	}
+)
+
+func (x Enum6579) Enum() *Enum6579 {
+	p := new(Enum6579)
+	*p = x
+	return p
+}
+
+func (x Enum6579) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum6579) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[11].Descriptor()
+}
+
+func (Enum6579) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[11]
+}
+
+func (x Enum6579) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum6579) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum6579(num)
+	return nil
+}
+
+// Deprecated: Use Enum6579.Descriptor instead.
+func (Enum6579) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{11}
+}
+
+type Enum6588 int32
+
+const (
+	Enum6588_ENUM_VALUE6589 Enum6588 = 0
+	Enum6588_ENUM_VALUE6590 Enum6588 = 1
+	Enum6588_ENUM_VALUE6591 Enum6588 = 2
+	Enum6588_ENUM_VALUE6592 Enum6588 = 3
+	Enum6588_ENUM_VALUE6593 Enum6588 = 4
+	Enum6588_ENUM_VALUE6594 Enum6588 = 5
+	Enum6588_ENUM_VALUE6595 Enum6588 = 6
+	Enum6588_ENUM_VALUE6596 Enum6588 = 7
+	Enum6588_ENUM_VALUE6597 Enum6588 = 8
+	Enum6588_ENUM_VALUE6598 Enum6588 = 9
+	Enum6588_ENUM_VALUE6599 Enum6588 = 10
+	Enum6588_ENUM_VALUE6600 Enum6588 = 11
+	Enum6588_ENUM_VALUE6601 Enum6588 = 12
+	Enum6588_ENUM_VALUE6602 Enum6588 = 13
+	Enum6588_ENUM_VALUE6603 Enum6588 = 14
+	Enum6588_ENUM_VALUE6604 Enum6588 = 15
+	Enum6588_ENUM_VALUE6605 Enum6588 = 16
+	Enum6588_ENUM_VALUE6606 Enum6588 = 17
+	Enum6588_ENUM_VALUE6607 Enum6588 = 19
+	Enum6588_ENUM_VALUE6608 Enum6588 = 20
+	Enum6588_ENUM_VALUE6609 Enum6588 = 21
+	Enum6588_ENUM_VALUE6610 Enum6588 = 22
+	Enum6588_ENUM_VALUE6611 Enum6588 = 23
+	Enum6588_ENUM_VALUE6612 Enum6588 = 24
+	Enum6588_ENUM_VALUE6613 Enum6588 = 25
+	Enum6588_ENUM_VALUE6614 Enum6588 = 26
+	Enum6588_ENUM_VALUE6615 Enum6588 = 27
+	Enum6588_ENUM_VALUE6616 Enum6588 = 28
+	Enum6588_ENUM_VALUE6617 Enum6588 = 29
+	Enum6588_ENUM_VALUE6618 Enum6588 = 30
+	Enum6588_ENUM_VALUE6619 Enum6588 = 31
+	Enum6588_ENUM_VALUE6620 Enum6588 = 32
+	Enum6588_ENUM_VALUE6621 Enum6588 = 33
+	Enum6588_ENUM_VALUE6622 Enum6588 = 34
+)
+
+// Enum value maps for Enum6588.
+var (
+	Enum6588_name = map[int32]string{
+		0:  "ENUM_VALUE6589",
+		1:  "ENUM_VALUE6590",
+		2:  "ENUM_VALUE6591",
+		3:  "ENUM_VALUE6592",
+		4:  "ENUM_VALUE6593",
+		5:  "ENUM_VALUE6594",
+		6:  "ENUM_VALUE6595",
+		7:  "ENUM_VALUE6596",
+		8:  "ENUM_VALUE6597",
+		9:  "ENUM_VALUE6598",
+		10: "ENUM_VALUE6599",
+		11: "ENUM_VALUE6600",
+		12: "ENUM_VALUE6601",
+		13: "ENUM_VALUE6602",
+		14: "ENUM_VALUE6603",
+		15: "ENUM_VALUE6604",
+		16: "ENUM_VALUE6605",
+		17: "ENUM_VALUE6606",
+		19: "ENUM_VALUE6607",
+		20: "ENUM_VALUE6608",
+		21: "ENUM_VALUE6609",
+		22: "ENUM_VALUE6610",
+		23: "ENUM_VALUE6611",
+		24: "ENUM_VALUE6612",
+		25: "ENUM_VALUE6613",
+		26: "ENUM_VALUE6614",
+		27: "ENUM_VALUE6615",
+		28: "ENUM_VALUE6616",
+		29: "ENUM_VALUE6617",
+		30: "ENUM_VALUE6618",
+		31: "ENUM_VALUE6619",
+		32: "ENUM_VALUE6620",
+		33: "ENUM_VALUE6621",
+		34: "ENUM_VALUE6622",
+	}
+	Enum6588_value = map[string]int32{
+		"ENUM_VALUE6589": 0,
+		"ENUM_VALUE6590": 1,
+		"ENUM_VALUE6591": 2,
+		"ENUM_VALUE6592": 3,
+		"ENUM_VALUE6593": 4,
+		"ENUM_VALUE6594": 5,
+		"ENUM_VALUE6595": 6,
+		"ENUM_VALUE6596": 7,
+		"ENUM_VALUE6597": 8,
+		"ENUM_VALUE6598": 9,
+		"ENUM_VALUE6599": 10,
+		"ENUM_VALUE6600": 11,
+		"ENUM_VALUE6601": 12,
+		"ENUM_VALUE6602": 13,
+		"ENUM_VALUE6603": 14,
+		"ENUM_VALUE6604": 15,
+		"ENUM_VALUE6605": 16,
+		"ENUM_VALUE6606": 17,
+		"ENUM_VALUE6607": 19,
+		"ENUM_VALUE6608": 20,
+		"ENUM_VALUE6609": 21,
+		"ENUM_VALUE6610": 22,
+		"ENUM_VALUE6611": 23,
+		"ENUM_VALUE6612": 24,
+		"ENUM_VALUE6613": 25,
+		"ENUM_VALUE6614": 26,
+		"ENUM_VALUE6615": 27,
+		"ENUM_VALUE6616": 28,
+		"ENUM_VALUE6617": 29,
+		"ENUM_VALUE6618": 30,
+		"ENUM_VALUE6619": 31,
+		"ENUM_VALUE6620": 32,
+		"ENUM_VALUE6621": 33,
+		"ENUM_VALUE6622": 34,
+	}
+)
+
+func (x Enum6588) Enum() *Enum6588 {
+	p := new(Enum6588)
+	*p = x
+	return p
+}
+
+func (x Enum6588) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum6588) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[12].Descriptor()
+}
+
+func (Enum6588) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[12]
+}
+
+func (x Enum6588) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum6588) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum6588(num)
+	return nil
+}
+
+// Deprecated: Use Enum6588.Descriptor instead.
+func (Enum6588) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{12}
+}
+
+type Enum6769 int32
+
+const (
+	Enum6769_ENUM_VALUE6770 Enum6769 = 0
+	Enum6769_ENUM_VALUE6771 Enum6769 = 1
+	Enum6769_ENUM_VALUE6772 Enum6769 = 2
+)
+
+// Enum value maps for Enum6769.
+var (
+	Enum6769_name = map[int32]string{
+		0: "ENUM_VALUE6770",
+		1: "ENUM_VALUE6771",
+		2: "ENUM_VALUE6772",
+	}
+	Enum6769_value = map[string]int32{
+		"ENUM_VALUE6770": 0,
+		"ENUM_VALUE6771": 1,
+		"ENUM_VALUE6772": 2,
+	}
+)
+
+func (x Enum6769) Enum() *Enum6769 {
+	p := new(Enum6769)
+	*p = x
+	return p
+}
+
+func (x Enum6769) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum6769) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[13].Descriptor()
+}
+
+func (Enum6769) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[13]
+}
+
+func (x Enum6769) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum6769) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum6769(num)
+	return nil
+}
+
+// Deprecated: Use Enum6769.Descriptor instead.
+func (Enum6769) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{13}
+}
+
+type Enum6774 int32
+
+const (
+	Enum6774_ENUM_VALUE6775 Enum6774 = 0
+	Enum6774_ENUM_VALUE6776 Enum6774 = 1
+	Enum6774_ENUM_VALUE6777 Enum6774 = 2
+	Enum6774_ENUM_VALUE6778 Enum6774 = 3
+	Enum6774_ENUM_VALUE6779 Enum6774 = 4
+	Enum6774_ENUM_VALUE6780 Enum6774 = 5
+	Enum6774_ENUM_VALUE6781 Enum6774 = 6
+)
+
+// Enum value maps for Enum6774.
+var (
+	Enum6774_name = map[int32]string{
+		0: "ENUM_VALUE6775",
+		1: "ENUM_VALUE6776",
+		2: "ENUM_VALUE6777",
+		3: "ENUM_VALUE6778",
+		4: "ENUM_VALUE6779",
+		5: "ENUM_VALUE6780",
+		6: "ENUM_VALUE6781",
+	}
+	Enum6774_value = map[string]int32{
+		"ENUM_VALUE6775": 0,
+		"ENUM_VALUE6776": 1,
+		"ENUM_VALUE6777": 2,
+		"ENUM_VALUE6778": 3,
+		"ENUM_VALUE6779": 4,
+		"ENUM_VALUE6780": 5,
+		"ENUM_VALUE6781": 6,
+	}
+)
+
+func (x Enum6774) Enum() *Enum6774 {
+	p := new(Enum6774)
+	*p = x
+	return p
+}
+
+func (x Enum6774) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum6774) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[14].Descriptor()
+}
+
+func (Enum6774) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[14]
+}
+
+func (x Enum6774) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum6774) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum6774(num)
+	return nil
+}
+
+// Deprecated: Use Enum6774.Descriptor instead.
+func (Enum6774) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{14}
+}
+
+type Enum6782 int32
+
+const (
+	Enum6782_ENUM_VALUE6783 Enum6782 = 0
+	Enum6782_ENUM_VALUE6784 Enum6782 = 1
+	Enum6782_ENUM_VALUE6785 Enum6782 = 2
+	Enum6782_ENUM_VALUE6786 Enum6782 = 3
+	Enum6782_ENUM_VALUE6787 Enum6782 = 4
+	Enum6782_ENUM_VALUE6788 Enum6782 = 5
+)
+
+// Enum value maps for Enum6782.
+var (
+	Enum6782_name = map[int32]string{
+		0: "ENUM_VALUE6783",
+		1: "ENUM_VALUE6784",
+		2: "ENUM_VALUE6785",
+		3: "ENUM_VALUE6786",
+		4: "ENUM_VALUE6787",
+		5: "ENUM_VALUE6788",
+	}
+	Enum6782_value = map[string]int32{
+		"ENUM_VALUE6783": 0,
+		"ENUM_VALUE6784": 1,
+		"ENUM_VALUE6785": 2,
+		"ENUM_VALUE6786": 3,
+		"ENUM_VALUE6787": 4,
+		"ENUM_VALUE6788": 5,
+	}
+)
+
+func (x Enum6782) Enum() *Enum6782 {
+	p := new(Enum6782)
+	*p = x
+	return p
+}
+
+func (x Enum6782) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum6782) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[15].Descriptor()
+}
+
+func (Enum6782) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[15]
+}
+
+func (x Enum6782) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum6782) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum6782(num)
+	return nil
+}
+
+// Deprecated: Use Enum6782.Descriptor instead.
+func (Enum6782) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{15}
+}
+
+type Enum6858 int32
+
+const (
+	Enum6858_ENUM_VALUE6859 Enum6858 = 1
+	Enum6858_ENUM_VALUE6860 Enum6858 = 2
+	Enum6858_ENUM_VALUE6861 Enum6858 = 3
+	Enum6858_ENUM_VALUE6862 Enum6858 = 4
+)
+
+// Enum value maps for Enum6858.
+var (
+	Enum6858_name = map[int32]string{
+		1: "ENUM_VALUE6859",
+		2: "ENUM_VALUE6860",
+		3: "ENUM_VALUE6861",
+		4: "ENUM_VALUE6862",
+	}
+	Enum6858_value = map[string]int32{
+		"ENUM_VALUE6859": 1,
+		"ENUM_VALUE6860": 2,
+		"ENUM_VALUE6861": 3,
+		"ENUM_VALUE6862": 4,
+	}
+)
+
+func (x Enum6858) Enum() *Enum6858 {
+	p := new(Enum6858)
+	*p = x
+	return p
+}
+
+func (x Enum6858) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum6858) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[16].Descriptor()
+}
+
+func (Enum6858) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[16]
+}
+
+func (x Enum6858) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum6858) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum6858(num)
+	return nil
+}
+
+// Deprecated: Use Enum6858.Descriptor instead.
+func (Enum6858) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{16}
+}
+
+type Enum6815 int32
+
+const (
+	Enum6815_ENUM_VALUE6816 Enum6815 = 0
+	Enum6815_ENUM_VALUE6817 Enum6815 = 1
+	Enum6815_ENUM_VALUE6818 Enum6815 = 2
+	Enum6815_ENUM_VALUE6819 Enum6815 = 3
+	Enum6815_ENUM_VALUE6820 Enum6815 = 4
+	Enum6815_ENUM_VALUE6821 Enum6815 = 5
+)
+
+// Enum value maps for Enum6815.
+var (
+	Enum6815_name = map[int32]string{
+		0: "ENUM_VALUE6816",
+		1: "ENUM_VALUE6817",
+		2: "ENUM_VALUE6818",
+		3: "ENUM_VALUE6819",
+		4: "ENUM_VALUE6820",
+		5: "ENUM_VALUE6821",
+	}
+	Enum6815_value = map[string]int32{
+		"ENUM_VALUE6816": 0,
+		"ENUM_VALUE6817": 1,
+		"ENUM_VALUE6818": 2,
+		"ENUM_VALUE6819": 3,
+		"ENUM_VALUE6820": 4,
+		"ENUM_VALUE6821": 5,
+	}
+)
+
+func (x Enum6815) Enum() *Enum6815 {
+	p := new(Enum6815)
+	*p = x
+	return p
+}
+
+func (x Enum6815) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum6815) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[17].Descriptor()
+}
+
+func (Enum6815) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[17]
+}
+
+func (x Enum6815) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum6815) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum6815(num)
+	return nil
+}
+
+// Deprecated: Use Enum6815.Descriptor instead.
+func (Enum6815) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{17}
+}
+
+type Enum6822 int32
+
+const (
+	Enum6822_ENUM_VALUE6823 Enum6822 = 0
+	Enum6822_ENUM_VALUE6824 Enum6822 = 1
+	Enum6822_ENUM_VALUE6825 Enum6822 = 2
+	Enum6822_ENUM_VALUE6826 Enum6822 = 3
+)
+
+// Enum value maps for Enum6822.
+var (
+	Enum6822_name = map[int32]string{
+		0: "ENUM_VALUE6823",
+		1: "ENUM_VALUE6824",
+		2: "ENUM_VALUE6825",
+		3: "ENUM_VALUE6826",
+	}
+	Enum6822_value = map[string]int32{
+		"ENUM_VALUE6823": 0,
+		"ENUM_VALUE6824": 1,
+		"ENUM_VALUE6825": 2,
+		"ENUM_VALUE6826": 3,
+	}
+)
+
+func (x Enum6822) Enum() *Enum6822 {
+	p := new(Enum6822)
+	*p = x
+	return p
+}
+
+func (x Enum6822) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum6822) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[18].Descriptor()
+}
+
+func (Enum6822) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[18]
+}
+
+func (x Enum6822) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum6822) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum6822(num)
+	return nil
+}
+
+// Deprecated: Use Enum6822.Descriptor instead.
+func (Enum6822) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{18}
+}
+
+type Enum7654 int32
+
+const (
+	Enum7654_ENUM_VALUE7655 Enum7654 = 1
+	Enum7654_ENUM_VALUE7656 Enum7654 = 2
+	Enum7654_ENUM_VALUE7657 Enum7654 = 3
+)
+
+// Enum value maps for Enum7654.
+var (
+	Enum7654_name = map[int32]string{
+		1: "ENUM_VALUE7655",
+		2: "ENUM_VALUE7656",
+		3: "ENUM_VALUE7657",
+	}
+	Enum7654_value = map[string]int32{
+		"ENUM_VALUE7655": 1,
+		"ENUM_VALUE7656": 2,
+		"ENUM_VALUE7657": 3,
+	}
+)
+
+func (x Enum7654) Enum() *Enum7654 {
+	p := new(Enum7654)
+	*p = x
+	return p
+}
+
+func (x Enum7654) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum7654) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[19].Descriptor()
+}
+
+func (Enum7654) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[19]
+}
+
+func (x Enum7654) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum7654) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum7654(num)
+	return nil
+}
+
+// Deprecated: Use Enum7654.Descriptor instead.
+func (Enum7654) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{19}
+}
+
+type Enum8292 int32
+
+const (
+	Enum8292_ENUM_VALUE8293 Enum8292 = 0
+	Enum8292_ENUM_VALUE8294 Enum8292 = 1
+	Enum8292_ENUM_VALUE8295 Enum8292 = 2
+)
+
+// Enum value maps for Enum8292.
+var (
+	Enum8292_name = map[int32]string{
+		0: "ENUM_VALUE8293",
+		1: "ENUM_VALUE8294",
+		2: "ENUM_VALUE8295",
+	}
+	Enum8292_value = map[string]int32{
+		"ENUM_VALUE8293": 0,
+		"ENUM_VALUE8294": 1,
+		"ENUM_VALUE8295": 2,
+	}
+)
+
+func (x Enum8292) Enum() *Enum8292 {
+	p := new(Enum8292)
+	*p = x
+	return p
+}
+
+func (x Enum8292) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum8292) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[20].Descriptor()
+}
+
+func (Enum8292) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[20]
+}
+
+func (x Enum8292) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum8292) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum8292(num)
+	return nil
+}
+
+// Deprecated: Use Enum8292.Descriptor instead.
+func (Enum8292) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{20}
+}
+
+type Enum8450 int32
+
+const (
+	Enum8450_ENUM_VALUE8451 Enum8450 = 0
+	Enum8450_ENUM_VALUE8452 Enum8450 = 1
+	Enum8450_ENUM_VALUE8453 Enum8450 = 2
+)
+
+// Enum value maps for Enum8450.
+var (
+	Enum8450_name = map[int32]string{
+		0: "ENUM_VALUE8451",
+		1: "ENUM_VALUE8452",
+		2: "ENUM_VALUE8453",
+	}
+	Enum8450_value = map[string]int32{
+		"ENUM_VALUE8451": 0,
+		"ENUM_VALUE8452": 1,
+		"ENUM_VALUE8453": 2,
+	}
+)
+
+func (x Enum8450) Enum() *Enum8450 {
+	p := new(Enum8450)
+	*p = x
+	return p
+}
+
+func (x Enum8450) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum8450) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[21].Descriptor()
+}
+
+func (Enum8450) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[21]
+}
+
+func (x Enum8450) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum8450) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum8450(num)
+	return nil
+}
+
+// Deprecated: Use Enum8450.Descriptor instead.
+func (Enum8450) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{21}
+}
+
+type Enum8900 int32
+
+const (
+	Enum8900_ENUM_VALUE8901 Enum8900 = 0
+	Enum8900_ENUM_VALUE8902 Enum8900 = 1
+	Enum8900_ENUM_VALUE8903 Enum8900 = 2
+	Enum8900_ENUM_VALUE8904 Enum8900 = 3
+	Enum8900_ENUM_VALUE8905 Enum8900 = 4
+)
+
+// Enum value maps for Enum8900.
+var (
+	Enum8900_name = map[int32]string{
+		0: "ENUM_VALUE8901",
+		1: "ENUM_VALUE8902",
+		2: "ENUM_VALUE8903",
+		3: "ENUM_VALUE8904",
+		4: "ENUM_VALUE8905",
+	}
+	Enum8900_value = map[string]int32{
+		"ENUM_VALUE8901": 0,
+		"ENUM_VALUE8902": 1,
+		"ENUM_VALUE8903": 2,
+		"ENUM_VALUE8904": 3,
+		"ENUM_VALUE8905": 4,
+	}
+)
+
+func (x Enum8900) Enum() *Enum8900 {
+	p := new(Enum8900)
+	*p = x
+	return p
+}
+
+func (x Enum8900) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum8900) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[22].Descriptor()
+}
+
+func (Enum8900) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[22]
+}
+
+func (x Enum8900) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum8900) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum8900(num)
+	return nil
+}
+
+// Deprecated: Use Enum8900.Descriptor instead.
+func (Enum8900) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{22}
+}
+
+type Enum8945 int32
+
+const (
+	Enum8945_ENUM_VALUE8946 Enum8945 = 0
+	Enum8945_ENUM_VALUE8947 Enum8945 = 1
+	Enum8945_ENUM_VALUE8948 Enum8945 = 2
+	Enum8945_ENUM_VALUE8949 Enum8945 = 3
+	Enum8945_ENUM_VALUE8950 Enum8945 = 4
+)
+
+// Enum value maps for Enum8945.
+var (
+	Enum8945_name = map[int32]string{
+		0: "ENUM_VALUE8946",
+		1: "ENUM_VALUE8947",
+		2: "ENUM_VALUE8948",
+		3: "ENUM_VALUE8949",
+		4: "ENUM_VALUE8950",
+	}
+	Enum8945_value = map[string]int32{
+		"ENUM_VALUE8946": 0,
+		"ENUM_VALUE8947": 1,
+		"ENUM_VALUE8948": 2,
+		"ENUM_VALUE8949": 3,
+		"ENUM_VALUE8950": 4,
+	}
+)
+
+func (x Enum8945) Enum() *Enum8945 {
+	p := new(Enum8945)
+	*p = x
+	return p
+}
+
+func (x Enum8945) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum8945) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[23].Descriptor()
+}
+
+func (Enum8945) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[23]
+}
+
+func (x Enum8945) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum8945) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum8945(num)
+	return nil
+}
+
+// Deprecated: Use Enum8945.Descriptor instead.
+func (Enum8945) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{23}
+}
+
+type Enum8951 int32
+
+const (
+	Enum8951_ENUM_VALUE8952 Enum8951 = 1
+	Enum8951_ENUM_VALUE8953 Enum8951 = 2
+	Enum8951_ENUM_VALUE8954 Enum8951 = 3
+	Enum8951_ENUM_VALUE8955 Enum8951 = 4
+	Enum8951_ENUM_VALUE8956 Enum8951 = 5
+	Enum8951_ENUM_VALUE8957 Enum8951 = 6
+	Enum8951_ENUM_VALUE8958 Enum8951 = 7
+	Enum8951_ENUM_VALUE8959 Enum8951 = 8
+)
+
+// Enum value maps for Enum8951.
+var (
+	Enum8951_name = map[int32]string{
+		1: "ENUM_VALUE8952",
+		2: "ENUM_VALUE8953",
+		3: "ENUM_VALUE8954",
+		4: "ENUM_VALUE8955",
+		5: "ENUM_VALUE8956",
+		6: "ENUM_VALUE8957",
+		7: "ENUM_VALUE8958",
+		8: "ENUM_VALUE8959",
+	}
+	Enum8951_value = map[string]int32{
+		"ENUM_VALUE8952": 1,
+		"ENUM_VALUE8953": 2,
+		"ENUM_VALUE8954": 3,
+		"ENUM_VALUE8955": 4,
+		"ENUM_VALUE8956": 5,
+		"ENUM_VALUE8957": 6,
+		"ENUM_VALUE8958": 7,
+		"ENUM_VALUE8959": 8,
+	}
+)
+
+func (x Enum8951) Enum() *Enum8951 {
+	p := new(Enum8951)
+	*p = x
+	return p
+}
+
+func (x Enum8951) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum8951) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[24].Descriptor()
+}
+
+func (Enum8951) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[24]
+}
+
+func (x Enum8951) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum8951) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum8951(num)
+	return nil
+}
+
+// Deprecated: Use Enum8951.Descriptor instead.
+func (Enum8951) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{24}
+}
+
+type Enum9243 int32
+
+const (
+	Enum9243_ENUM_VALUE9244 Enum9243 = -1
+	Enum9243_ENUM_VALUE9245 Enum9243 = 0
+	Enum9243_ENUM_VALUE9246 Enum9243 = 1
+	Enum9243_ENUM_VALUE9247 Enum9243 = 2
+	Enum9243_ENUM_VALUE9248 Enum9243 = 3
+	Enum9243_ENUM_VALUE9249 Enum9243 = 4
+	Enum9243_ENUM_VALUE9250 Enum9243 = 5
+	Enum9243_ENUM_VALUE9251 Enum9243 = 6
+	Enum9243_ENUM_VALUE9252 Enum9243 = 7
+	Enum9243_ENUM_VALUE9253 Enum9243 = 8
+	Enum9243_ENUM_VALUE9254 Enum9243 = 9
+	Enum9243_ENUM_VALUE9255 Enum9243 = 10
+	Enum9243_ENUM_VALUE9256 Enum9243 = 11
+	Enum9243_ENUM_VALUE9257 Enum9243 = 12
+	Enum9243_ENUM_VALUE9258 Enum9243 = 13
+	Enum9243_ENUM_VALUE9259 Enum9243 = 14
+	Enum9243_ENUM_VALUE9260 Enum9243 = 15
+	Enum9243_ENUM_VALUE9261 Enum9243 = 16
+	Enum9243_ENUM_VALUE9262 Enum9243 = 17
+	Enum9243_ENUM_VALUE9263 Enum9243 = 71
+	Enum9243_ENUM_VALUE9264 Enum9243 = 72
+	Enum9243_ENUM_VALUE9265 Enum9243 = 73
+	Enum9243_ENUM_VALUE9266 Enum9243 = 74
+	Enum9243_ENUM_VALUE9267 Enum9243 = 18
+	Enum9243_ENUM_VALUE9268 Enum9243 = 20
+	Enum9243_ENUM_VALUE9269 Enum9243 = 21
+	Enum9243_ENUM_VALUE9270 Enum9243 = 22
+	Enum9243_ENUM_VALUE9271 Enum9243 = 23
+	Enum9243_ENUM_VALUE9272 Enum9243 = 61
+	Enum9243_ENUM_VALUE9273 Enum9243 = 62
+	Enum9243_ENUM_VALUE9274 Enum9243 = 63
+	Enum9243_ENUM_VALUE9275 Enum9243 = 64
+	Enum9243_ENUM_VALUE9276 Enum9243 = 66
+	Enum9243_ENUM_VALUE9277 Enum9243 = 67
+	Enum9243_ENUM_VALUE9278 Enum9243 = 24
+	Enum9243_ENUM_VALUE9279 Enum9243 = 25
+	Enum9243_ENUM_VALUE9280 Enum9243 = 26
+	Enum9243_ENUM_VALUE9281 Enum9243 = 27
+	Enum9243_ENUM_VALUE9282 Enum9243 = 28
+	Enum9243_ENUM_VALUE9283 Enum9243 = 29
+	Enum9243_ENUM_VALUE9284 Enum9243 = 30
+	Enum9243_ENUM_VALUE9285 Enum9243 = 31
+	Enum9243_ENUM_VALUE9286 Enum9243 = 32
+	Enum9243_ENUM_VALUE9287 Enum9243 = 33
+	Enum9243_ENUM_VALUE9288 Enum9243 = 34
+	Enum9243_ENUM_VALUE9289 Enum9243 = 35
+	Enum9243_ENUM_VALUE9290 Enum9243 = 36
+	Enum9243_ENUM_VALUE9291 Enum9243 = 37
+	Enum9243_ENUM_VALUE9292 Enum9243 = 38
+	Enum9243_ENUM_VALUE9293 Enum9243 = 39
+	Enum9243_ENUM_VALUE9294 Enum9243 = 40
+	Enum9243_ENUM_VALUE9295 Enum9243 = 41
+	Enum9243_ENUM_VALUE9296 Enum9243 = 42
+	Enum9243_ENUM_VALUE9297 Enum9243 = 43
+	Enum9243_ENUM_VALUE9298 Enum9243 = 44
+	Enum9243_ENUM_VALUE9299 Enum9243 = 45
+	Enum9243_ENUM_VALUE9300 Enum9243 = 46
+	Enum9243_ENUM_VALUE9301 Enum9243 = 47
+	Enum9243_ENUM_VALUE9302 Enum9243 = 48
+	Enum9243_ENUM_VALUE9303 Enum9243 = 49
+	Enum9243_ENUM_VALUE9304 Enum9243 = 50
+	Enum9243_ENUM_VALUE9305 Enum9243 = 51
+	Enum9243_ENUM_VALUE9306 Enum9243 = 52
+	Enum9243_ENUM_VALUE9307 Enum9243 = 53
+	Enum9243_ENUM_VALUE9308 Enum9243 = 54
+	Enum9243_ENUM_VALUE9309 Enum9243 = 55
+	Enum9243_ENUM_VALUE9310 Enum9243 = 56
+	Enum9243_ENUM_VALUE9311 Enum9243 = 57
+	Enum9243_ENUM_VALUE9312 Enum9243 = 58
+	Enum9243_ENUM_VALUE9313 Enum9243 = 59
+	Enum9243_ENUM_VALUE9314 Enum9243 = 60
+	Enum9243_ENUM_VALUE9315 Enum9243 = 68
+	Enum9243_ENUM_VALUE9316 Enum9243 = 69
+	Enum9243_ENUM_VALUE9317 Enum9243 = 70
+	Enum9243_ENUM_VALUE9318 Enum9243 = 1000
+	Enum9243_ENUM_VALUE9319 Enum9243 = 1001
+	Enum9243_ENUM_VALUE9320 Enum9243 = 1002
+	Enum9243_ENUM_VALUE9321 Enum9243 = 1003
+	Enum9243_ENUM_VALUE9322 Enum9243 = 1004
+	Enum9243_ENUM_VALUE9323 Enum9243 = 1005
+	Enum9243_ENUM_VALUE9324 Enum9243 = 1006
+	Enum9243_ENUM_VALUE9325 Enum9243 = 1007
+	Enum9243_ENUM_VALUE9326 Enum9243 = 65
+)
+
+// Enum value maps for Enum9243.
+var (
+	Enum9243_name = map[int32]string{
+		-1:   "ENUM_VALUE9244",
+		0:    "ENUM_VALUE9245",
+		1:    "ENUM_VALUE9246",
+		2:    "ENUM_VALUE9247",
+		3:    "ENUM_VALUE9248",
+		4:    "ENUM_VALUE9249",
+		5:    "ENUM_VALUE9250",
+		6:    "ENUM_VALUE9251",
+		7:    "ENUM_VALUE9252",
+		8:    "ENUM_VALUE9253",
+		9:    "ENUM_VALUE9254",
+		10:   "ENUM_VALUE9255",
+		11:   "ENUM_VALUE9256",
+		12:   "ENUM_VALUE9257",
+		13:   "ENUM_VALUE9258",
+		14:   "ENUM_VALUE9259",
+		15:   "ENUM_VALUE9260",
+		16:   "ENUM_VALUE9261",
+		17:   "ENUM_VALUE9262",
+		71:   "ENUM_VALUE9263",
+		72:   "ENUM_VALUE9264",
+		73:   "ENUM_VALUE9265",
+		74:   "ENUM_VALUE9266",
+		18:   "ENUM_VALUE9267",
+		20:   "ENUM_VALUE9268",
+		21:   "ENUM_VALUE9269",
+		22:   "ENUM_VALUE9270",
+		23:   "ENUM_VALUE9271",
+		61:   "ENUM_VALUE9272",
+		62:   "ENUM_VALUE9273",
+		63:   "ENUM_VALUE9274",
+		64:   "ENUM_VALUE9275",
+		66:   "ENUM_VALUE9276",
+		67:   "ENUM_VALUE9277",
+		24:   "ENUM_VALUE9278",
+		25:   "ENUM_VALUE9279",
+		26:   "ENUM_VALUE9280",
+		27:   "ENUM_VALUE9281",
+		28:   "ENUM_VALUE9282",
+		29:   "ENUM_VALUE9283",
+		30:   "ENUM_VALUE9284",
+		31:   "ENUM_VALUE9285",
+		32:   "ENUM_VALUE9286",
+		33:   "ENUM_VALUE9287",
+		34:   "ENUM_VALUE9288",
+		35:   "ENUM_VALUE9289",
+		36:   "ENUM_VALUE9290",
+		37:   "ENUM_VALUE9291",
+		38:   "ENUM_VALUE9292",
+		39:   "ENUM_VALUE9293",
+		40:   "ENUM_VALUE9294",
+		41:   "ENUM_VALUE9295",
+		42:   "ENUM_VALUE9296",
+		43:   "ENUM_VALUE9297",
+		44:   "ENUM_VALUE9298",
+		45:   "ENUM_VALUE9299",
+		46:   "ENUM_VALUE9300",
+		47:   "ENUM_VALUE9301",
+		48:   "ENUM_VALUE9302",
+		49:   "ENUM_VALUE9303",
+		50:   "ENUM_VALUE9304",
+		51:   "ENUM_VALUE9305",
+		52:   "ENUM_VALUE9306",
+		53:   "ENUM_VALUE9307",
+		54:   "ENUM_VALUE9308",
+		55:   "ENUM_VALUE9309",
+		56:   "ENUM_VALUE9310",
+		57:   "ENUM_VALUE9311",
+		58:   "ENUM_VALUE9312",
+		59:   "ENUM_VALUE9313",
+		60:   "ENUM_VALUE9314",
+		68:   "ENUM_VALUE9315",
+		69:   "ENUM_VALUE9316",
+		70:   "ENUM_VALUE9317",
+		1000: "ENUM_VALUE9318",
+		1001: "ENUM_VALUE9319",
+		1002: "ENUM_VALUE9320",
+		1003: "ENUM_VALUE9321",
+		1004: "ENUM_VALUE9322",
+		1005: "ENUM_VALUE9323",
+		1006: "ENUM_VALUE9324",
+		1007: "ENUM_VALUE9325",
+		65:   "ENUM_VALUE9326",
+	}
+	Enum9243_value = map[string]int32{
+		"ENUM_VALUE9244": -1,
+		"ENUM_VALUE9245": 0,
+		"ENUM_VALUE9246": 1,
+		"ENUM_VALUE9247": 2,
+		"ENUM_VALUE9248": 3,
+		"ENUM_VALUE9249": 4,
+		"ENUM_VALUE9250": 5,
+		"ENUM_VALUE9251": 6,
+		"ENUM_VALUE9252": 7,
+		"ENUM_VALUE9253": 8,
+		"ENUM_VALUE9254": 9,
+		"ENUM_VALUE9255": 10,
+		"ENUM_VALUE9256": 11,
+		"ENUM_VALUE9257": 12,
+		"ENUM_VALUE9258": 13,
+		"ENUM_VALUE9259": 14,
+		"ENUM_VALUE9260": 15,
+		"ENUM_VALUE9261": 16,
+		"ENUM_VALUE9262": 17,
+		"ENUM_VALUE9263": 71,
+		"ENUM_VALUE9264": 72,
+		"ENUM_VALUE9265": 73,
+		"ENUM_VALUE9266": 74,
+		"ENUM_VALUE9267": 18,
+		"ENUM_VALUE9268": 20,
+		"ENUM_VALUE9269": 21,
+		"ENUM_VALUE9270": 22,
+		"ENUM_VALUE9271": 23,
+		"ENUM_VALUE9272": 61,
+		"ENUM_VALUE9273": 62,
+		"ENUM_VALUE9274": 63,
+		"ENUM_VALUE9275": 64,
+		"ENUM_VALUE9276": 66,
+		"ENUM_VALUE9277": 67,
+		"ENUM_VALUE9278": 24,
+		"ENUM_VALUE9279": 25,
+		"ENUM_VALUE9280": 26,
+		"ENUM_VALUE9281": 27,
+		"ENUM_VALUE9282": 28,
+		"ENUM_VALUE9283": 29,
+		"ENUM_VALUE9284": 30,
+		"ENUM_VALUE9285": 31,
+		"ENUM_VALUE9286": 32,
+		"ENUM_VALUE9287": 33,
+		"ENUM_VALUE9288": 34,
+		"ENUM_VALUE9289": 35,
+		"ENUM_VALUE9290": 36,
+		"ENUM_VALUE9291": 37,
+		"ENUM_VALUE9292": 38,
+		"ENUM_VALUE9293": 39,
+		"ENUM_VALUE9294": 40,
+		"ENUM_VALUE9295": 41,
+		"ENUM_VALUE9296": 42,
+		"ENUM_VALUE9297": 43,
+		"ENUM_VALUE9298": 44,
+		"ENUM_VALUE9299": 45,
+		"ENUM_VALUE9300": 46,
+		"ENUM_VALUE9301": 47,
+		"ENUM_VALUE9302": 48,
+		"ENUM_VALUE9303": 49,
+		"ENUM_VALUE9304": 50,
+		"ENUM_VALUE9305": 51,
+		"ENUM_VALUE9306": 52,
+		"ENUM_VALUE9307": 53,
+		"ENUM_VALUE9308": 54,
+		"ENUM_VALUE9309": 55,
+		"ENUM_VALUE9310": 56,
+		"ENUM_VALUE9311": 57,
+		"ENUM_VALUE9312": 58,
+		"ENUM_VALUE9313": 59,
+		"ENUM_VALUE9314": 60,
+		"ENUM_VALUE9315": 68,
+		"ENUM_VALUE9316": 69,
+		"ENUM_VALUE9317": 70,
+		"ENUM_VALUE9318": 1000,
+		"ENUM_VALUE9319": 1001,
+		"ENUM_VALUE9320": 1002,
+		"ENUM_VALUE9321": 1003,
+		"ENUM_VALUE9322": 1004,
+		"ENUM_VALUE9323": 1005,
+		"ENUM_VALUE9324": 1006,
+		"ENUM_VALUE9325": 1007,
+		"ENUM_VALUE9326": 65,
+	}
+)
+
+func (x Enum9243) Enum() *Enum9243 {
+	p := new(Enum9243)
+	*p = x
+	return p
+}
+
+func (x Enum9243) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum9243) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[25].Descriptor()
+}
+
+func (Enum9243) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[25]
+}
+
+func (x Enum9243) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum9243) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum9243(num)
+	return nil
+}
+
+// Deprecated: Use Enum9243.Descriptor instead.
+func (Enum9243) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{25}
+}
+
+type Enum10157 int32
+
+const (
+	Enum10157_ENUM_VALUE10158 Enum10157 = 0
+	Enum10157_ENUM_VALUE10159 Enum10157 = 1
+	Enum10157_ENUM_VALUE10160 Enum10157 = 2
+	Enum10157_ENUM_VALUE10161 Enum10157 = 3
+	Enum10157_ENUM_VALUE10162 Enum10157 = 4
+	Enum10157_ENUM_VALUE10163 Enum10157 = 5
+	Enum10157_ENUM_VALUE10164 Enum10157 = 6
+	Enum10157_ENUM_VALUE10165 Enum10157 = 7
+	Enum10157_ENUM_VALUE10166 Enum10157 = 8
+)
+
+// Enum value maps for Enum10157.
+var (
+	Enum10157_name = map[int32]string{
+		0: "ENUM_VALUE10158",
+		1: "ENUM_VALUE10159",
+		2: "ENUM_VALUE10160",
+		3: "ENUM_VALUE10161",
+		4: "ENUM_VALUE10162",
+		5: "ENUM_VALUE10163",
+		6: "ENUM_VALUE10164",
+		7: "ENUM_VALUE10165",
+		8: "ENUM_VALUE10166",
+	}
+	Enum10157_value = map[string]int32{
+		"ENUM_VALUE10158": 0,
+		"ENUM_VALUE10159": 1,
+		"ENUM_VALUE10160": 2,
+		"ENUM_VALUE10161": 3,
+		"ENUM_VALUE10162": 4,
+		"ENUM_VALUE10163": 5,
+		"ENUM_VALUE10164": 6,
+		"ENUM_VALUE10165": 7,
+		"ENUM_VALUE10166": 8,
+	}
+)
+
+func (x Enum10157) Enum() *Enum10157 {
+	p := new(Enum10157)
+	*p = x
+	return p
+}
+
+func (x Enum10157) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum10157) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[26].Descriptor()
+}
+
+func (Enum10157) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[26]
+}
+
+func (x Enum10157) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum10157) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum10157(num)
+	return nil
+}
+
+// Deprecated: Use Enum10157.Descriptor instead.
+func (Enum10157) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{26}
+}
+
+type Enum10167 int32
+
+const (
+	Enum10167_ENUM_VALUE10168 Enum10167 = 0
+	Enum10167_ENUM_VALUE10169 Enum10167 = 1
+	Enum10167_ENUM_VALUE10170 Enum10167 = 2
+	Enum10167_ENUM_VALUE10171 Enum10167 = 3
+	Enum10167_ENUM_VALUE10172 Enum10167 = 4
+	Enum10167_ENUM_VALUE10173 Enum10167 = 5
+	Enum10167_ENUM_VALUE10174 Enum10167 = 6
+	Enum10167_ENUM_VALUE10175 Enum10167 = 7
+	Enum10167_ENUM_VALUE10176 Enum10167 = 8
+)
+
+// Enum value maps for Enum10167.
+var (
+	Enum10167_name = map[int32]string{
+		0: "ENUM_VALUE10168",
+		1: "ENUM_VALUE10169",
+		2: "ENUM_VALUE10170",
+		3: "ENUM_VALUE10171",
+		4: "ENUM_VALUE10172",
+		5: "ENUM_VALUE10173",
+		6: "ENUM_VALUE10174",
+		7: "ENUM_VALUE10175",
+		8: "ENUM_VALUE10176",
+	}
+	Enum10167_value = map[string]int32{
+		"ENUM_VALUE10168": 0,
+		"ENUM_VALUE10169": 1,
+		"ENUM_VALUE10170": 2,
+		"ENUM_VALUE10171": 3,
+		"ENUM_VALUE10172": 4,
+		"ENUM_VALUE10173": 5,
+		"ENUM_VALUE10174": 6,
+		"ENUM_VALUE10175": 7,
+		"ENUM_VALUE10176": 8,
+	}
+)
+
+func (x Enum10167) Enum() *Enum10167 {
+	p := new(Enum10167)
+	*p = x
+	return p
+}
+
+func (x Enum10167) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum10167) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[27].Descriptor()
+}
+
+func (Enum10167) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[27]
+}
+
+func (x Enum10167) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum10167) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum10167(num)
+	return nil
+}
+
+// Deprecated: Use Enum10167.Descriptor instead.
+func (Enum10167) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{27}
+}
+
+type Enum8862 int32
+
+const (
+	Enum8862_ENUM_VALUE8863 Enum8862 = 0
+	Enum8862_ENUM_VALUE8864 Enum8862 = 1
+	Enum8862_ENUM_VALUE8865 Enum8862 = 2
+	Enum8862_ENUM_VALUE8866 Enum8862 = 3
+	Enum8862_ENUM_VALUE8867 Enum8862 = 4
+	Enum8862_ENUM_VALUE8868 Enum8862 = 5
+	Enum8862_ENUM_VALUE8869 Enum8862 = 6
+	Enum8862_ENUM_VALUE8870 Enum8862 = 7
+	Enum8862_ENUM_VALUE8871 Enum8862 = 13
+	Enum8862_ENUM_VALUE8872 Enum8862 = 14
+	Enum8862_ENUM_VALUE8873 Enum8862 = 8
+	Enum8862_ENUM_VALUE8874 Enum8862 = 9
+	Enum8862_ENUM_VALUE8875 Enum8862 = 10
+	Enum8862_ENUM_VALUE8876 Enum8862 = 11
+	Enum8862_ENUM_VALUE8877 Enum8862 = 12
+	Enum8862_ENUM_VALUE8878 Enum8862 = 15
+)
+
+// Enum value maps for Enum8862.
+var (
+	Enum8862_name = map[int32]string{
+		0:  "ENUM_VALUE8863",
+		1:  "ENUM_VALUE8864",
+		2:  "ENUM_VALUE8865",
+		3:  "ENUM_VALUE8866",
+		4:  "ENUM_VALUE8867",
+		5:  "ENUM_VALUE8868",
+		6:  "ENUM_VALUE8869",
+		7:  "ENUM_VALUE8870",
+		13: "ENUM_VALUE8871",
+		14: "ENUM_VALUE8872",
+		8:  "ENUM_VALUE8873",
+		9:  "ENUM_VALUE8874",
+		10: "ENUM_VALUE8875",
+		11: "ENUM_VALUE8876",
+		12: "ENUM_VALUE8877",
+		15: "ENUM_VALUE8878",
+	}
+	Enum8862_value = map[string]int32{
+		"ENUM_VALUE8863": 0,
+		"ENUM_VALUE8864": 1,
+		"ENUM_VALUE8865": 2,
+		"ENUM_VALUE8866": 3,
+		"ENUM_VALUE8867": 4,
+		"ENUM_VALUE8868": 5,
+		"ENUM_VALUE8869": 6,
+		"ENUM_VALUE8870": 7,
+		"ENUM_VALUE8871": 13,
+		"ENUM_VALUE8872": 14,
+		"ENUM_VALUE8873": 8,
+		"ENUM_VALUE8874": 9,
+		"ENUM_VALUE8875": 10,
+		"ENUM_VALUE8876": 11,
+		"ENUM_VALUE8877": 12,
+		"ENUM_VALUE8878": 15,
+	}
+)
+
+func (x Enum8862) Enum() *Enum8862 {
+	p := new(Enum8862)
+	*p = x
+	return p
+}
+
+func (x Enum8862) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum8862) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[28].Descriptor()
+}
+
+func (Enum8862) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[28]
+}
+
+func (x Enum8862) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum8862) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum8862(num)
+	return nil
+}
+
+// Deprecated: Use Enum8862.Descriptor instead.
+func (Enum8862) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{28}
+}
+
+type Enum10325 int32
+
+const (
+	Enum10325_ENUM_VALUE10326 Enum10325 = 0
+	Enum10325_ENUM_VALUE10327 Enum10325 = 1
+	Enum10325_ENUM_VALUE10328 Enum10325 = 2
+	Enum10325_ENUM_VALUE10329 Enum10325 = 3
+	Enum10325_ENUM_VALUE10330 Enum10325 = 4
+	Enum10325_ENUM_VALUE10331 Enum10325 = 5
+	Enum10325_ENUM_VALUE10332 Enum10325 = 6
+	Enum10325_ENUM_VALUE10333 Enum10325 = 7
+	Enum10325_ENUM_VALUE10334 Enum10325 = 8
+)
+
+// Enum value maps for Enum10325.
+var (
+	Enum10325_name = map[int32]string{
+		0: "ENUM_VALUE10326",
+		1: "ENUM_VALUE10327",
+		2: "ENUM_VALUE10328",
+		3: "ENUM_VALUE10329",
+		4: "ENUM_VALUE10330",
+		5: "ENUM_VALUE10331",
+		6: "ENUM_VALUE10332",
+		7: "ENUM_VALUE10333",
+		8: "ENUM_VALUE10334",
+	}
+	Enum10325_value = map[string]int32{
+		"ENUM_VALUE10326": 0,
+		"ENUM_VALUE10327": 1,
+		"ENUM_VALUE10328": 2,
+		"ENUM_VALUE10329": 3,
+		"ENUM_VALUE10330": 4,
+		"ENUM_VALUE10331": 5,
+		"ENUM_VALUE10332": 6,
+		"ENUM_VALUE10333": 7,
+		"ENUM_VALUE10334": 8,
+	}
+)
+
+func (x Enum10325) Enum() *Enum10325 {
+	p := new(Enum10325)
+	*p = x
+	return p
+}
+
+func (x Enum10325) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum10325) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[29].Descriptor()
+}
+
+func (Enum10325) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[29]
+}
+
+func (x Enum10325) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum10325) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum10325(num)
+	return nil
+}
+
+// Deprecated: Use Enum10325.Descriptor instead.
+func (Enum10325) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{29}
+}
+
+type Enum10335 int32
+
+const (
+	Enum10335_ENUM_VALUE10336 Enum10335 = 0
+)
+
+// Enum value maps for Enum10335.
+var (
+	Enum10335_name = map[int32]string{
+		0: "ENUM_VALUE10336",
+	}
+	Enum10335_value = map[string]int32{
+		"ENUM_VALUE10336": 0,
+	}
+)
+
+func (x Enum10335) Enum() *Enum10335 {
+	p := new(Enum10335)
+	*p = x
+	return p
+}
+
+func (x Enum10335) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum10335) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[30].Descriptor()
+}
+
+func (Enum10335) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[30]
+}
+
+func (x Enum10335) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum10335) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum10335(num)
+	return nil
+}
+
+// Deprecated: Use Enum10335.Descriptor instead.
+func (Enum10335) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{30}
+}
+
+type Enum10337 int32
+
+const (
+	Enum10337_ENUM_VALUE10338 Enum10337 = 0
+	Enum10337_ENUM_VALUE10339 Enum10337 = 1
+)
+
+// Enum value maps for Enum10337.
+var (
+	Enum10337_name = map[int32]string{
+		0: "ENUM_VALUE10338",
+		1: "ENUM_VALUE10339",
+	}
+	Enum10337_value = map[string]int32{
+		"ENUM_VALUE10338": 0,
+		"ENUM_VALUE10339": 1,
+	}
+)
+
+func (x Enum10337) Enum() *Enum10337 {
+	p := new(Enum10337)
+	*p = x
+	return p
+}
+
+func (x Enum10337) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum10337) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[31].Descriptor()
+}
+
+func (Enum10337) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[31]
+}
+
+func (x Enum10337) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum10337) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum10337(num)
+	return nil
+}
+
+// Deprecated: Use Enum10337.Descriptor instead.
+func (Enum10337) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{31}
+}
+
+type Enum10392 int32
+
+const (
+	Enum10392_ENUM_VALUE10393 Enum10392 = 0
+	Enum10392_ENUM_VALUE10394 Enum10392 = 1
+	Enum10392_ENUM_VALUE10395 Enum10392 = 2
+	Enum10392_ENUM_VALUE10396 Enum10392 = 3
+	Enum10392_ENUM_VALUE10397 Enum10392 = 4
+	Enum10392_ENUM_VALUE10398 Enum10392 = 5
+	Enum10392_ENUM_VALUE10399 Enum10392 = 6
+	Enum10392_ENUM_VALUE10400 Enum10392 = 7
+	Enum10392_ENUM_VALUE10401 Enum10392 = 8
+	Enum10392_ENUM_VALUE10402 Enum10392 = 15
+	Enum10392_ENUM_VALUE10403 Enum10392 = 9
+	Enum10392_ENUM_VALUE10404 Enum10392 = 10
+	Enum10392_ENUM_VALUE10405 Enum10392 = 11
+	Enum10392_ENUM_VALUE10406 Enum10392 = 12
+	Enum10392_ENUM_VALUE10407 Enum10392 = 13
+	Enum10392_ENUM_VALUE10408 Enum10392 = 14
+	Enum10392_ENUM_VALUE10409 Enum10392 = 101
+	Enum10392_ENUM_VALUE10410 Enum10392 = 102
+)
+
+// Enum value maps for Enum10392.
+var (
+	Enum10392_name = map[int32]string{
+		0:   "ENUM_VALUE10393",
+		1:   "ENUM_VALUE10394",
+		2:   "ENUM_VALUE10395",
+		3:   "ENUM_VALUE10396",
+		4:   "ENUM_VALUE10397",
+		5:   "ENUM_VALUE10398",
+		6:   "ENUM_VALUE10399",
+		7:   "ENUM_VALUE10400",
+		8:   "ENUM_VALUE10401",
+		15:  "ENUM_VALUE10402",
+		9:   "ENUM_VALUE10403",
+		10:  "ENUM_VALUE10404",
+		11:  "ENUM_VALUE10405",
+		12:  "ENUM_VALUE10406",
+		13:  "ENUM_VALUE10407",
+		14:  "ENUM_VALUE10408",
+		101: "ENUM_VALUE10409",
+		102: "ENUM_VALUE10410",
+	}
+	Enum10392_value = map[string]int32{
+		"ENUM_VALUE10393": 0,
+		"ENUM_VALUE10394": 1,
+		"ENUM_VALUE10395": 2,
+		"ENUM_VALUE10396": 3,
+		"ENUM_VALUE10397": 4,
+		"ENUM_VALUE10398": 5,
+		"ENUM_VALUE10399": 6,
+		"ENUM_VALUE10400": 7,
+		"ENUM_VALUE10401": 8,
+		"ENUM_VALUE10402": 15,
+		"ENUM_VALUE10403": 9,
+		"ENUM_VALUE10404": 10,
+		"ENUM_VALUE10405": 11,
+		"ENUM_VALUE10406": 12,
+		"ENUM_VALUE10407": 13,
+		"ENUM_VALUE10408": 14,
+		"ENUM_VALUE10409": 101,
+		"ENUM_VALUE10410": 102,
+	}
+)
+
+func (x Enum10392) Enum() *Enum10392 {
+	p := new(Enum10392)
+	*p = x
+	return p
+}
+
+func (x Enum10392) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum10392) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[32].Descriptor()
+}
+
+func (Enum10392) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[32]
+}
+
+func (x Enum10392) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum10392) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum10392(num)
+	return nil
+}
+
+// Deprecated: Use Enum10392.Descriptor instead.
+func (Enum10392) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{32}
+}
+
+type Enum11107 int32
+
+const (
+	Enum11107_ENUM_VALUE11108 Enum11107 = 0
+	Enum11107_ENUM_VALUE11109 Enum11107 = 1
+	Enum11107_ENUM_VALUE11110 Enum11107 = 2
+	Enum11107_ENUM_VALUE11111 Enum11107 = 3
+	Enum11107_ENUM_VALUE11112 Enum11107 = 4
+	Enum11107_ENUM_VALUE11113 Enum11107 = 5
+	Enum11107_ENUM_VALUE11114 Enum11107 = 6
+	Enum11107_ENUM_VALUE11115 Enum11107 = 7
+	Enum11107_ENUM_VALUE11116 Enum11107 = 8
+	Enum11107_ENUM_VALUE11117 Enum11107 = 9
+	Enum11107_ENUM_VALUE11118 Enum11107 = 10
+	Enum11107_ENUM_VALUE11119 Enum11107 = 11
+	Enum11107_ENUM_VALUE11120 Enum11107 = 12
+	Enum11107_ENUM_VALUE11121 Enum11107 = 13
+	Enum11107_ENUM_VALUE11122 Enum11107 = 14
+	Enum11107_ENUM_VALUE11123 Enum11107 = 15
+	Enum11107_ENUM_VALUE11124 Enum11107 = 16
+	Enum11107_ENUM_VALUE11125 Enum11107 = 17
+	Enum11107_ENUM_VALUE11126 Enum11107 = 18
+	Enum11107_ENUM_VALUE11127 Enum11107 = 19
+	Enum11107_ENUM_VALUE11128 Enum11107 = 20
+	Enum11107_ENUM_VALUE11129 Enum11107 = 21
+	Enum11107_ENUM_VALUE11130 Enum11107 = 22
+	Enum11107_ENUM_VALUE11131 Enum11107 = 23
+	Enum11107_ENUM_VALUE11132 Enum11107 = 24
+	Enum11107_ENUM_VALUE11133 Enum11107 = 25
+	Enum11107_ENUM_VALUE11134 Enum11107 = 26
+	Enum11107_ENUM_VALUE11135 Enum11107 = 27
+	Enum11107_ENUM_VALUE11136 Enum11107 = 28
+	Enum11107_ENUM_VALUE11137 Enum11107 = 29
+	Enum11107_ENUM_VALUE11138 Enum11107 = 30
+	Enum11107_ENUM_VALUE11139 Enum11107 = 31
+	Enum11107_ENUM_VALUE11140 Enum11107 = 32
+	Enum11107_ENUM_VALUE11141 Enum11107 = 33
+	Enum11107_ENUM_VALUE11142 Enum11107 = 34
+	Enum11107_ENUM_VALUE11143 Enum11107 = 35
+	Enum11107_ENUM_VALUE11144 Enum11107 = 36
+	Enum11107_ENUM_VALUE11145 Enum11107 = 37
+	Enum11107_ENUM_VALUE11146 Enum11107 = 38
+	Enum11107_ENUM_VALUE11147 Enum11107 = 39
+	Enum11107_ENUM_VALUE11148 Enum11107 = 40
+	Enum11107_ENUM_VALUE11149 Enum11107 = 41
+	Enum11107_ENUM_VALUE11150 Enum11107 = 42
+	Enum11107_ENUM_VALUE11151 Enum11107 = 43
+	Enum11107_ENUM_VALUE11152 Enum11107 = 44
+	Enum11107_ENUM_VALUE11153 Enum11107 = 45
+	Enum11107_ENUM_VALUE11154 Enum11107 = 46
+	Enum11107_ENUM_VALUE11155 Enum11107 = 47
+	Enum11107_ENUM_VALUE11156 Enum11107 = 48
+	Enum11107_ENUM_VALUE11157 Enum11107 = 49
+	Enum11107_ENUM_VALUE11158 Enum11107 = 50
+	Enum11107_ENUM_VALUE11159 Enum11107 = 51
+	Enum11107_ENUM_VALUE11160 Enum11107 = 52
+	Enum11107_ENUM_VALUE11161 Enum11107 = 53
+	Enum11107_ENUM_VALUE11162 Enum11107 = 54
+	Enum11107_ENUM_VALUE11163 Enum11107 = 55
+	Enum11107_ENUM_VALUE11164 Enum11107 = 56
+	Enum11107_ENUM_VALUE11165 Enum11107 = 57
+	Enum11107_ENUM_VALUE11166 Enum11107 = 58
+	Enum11107_ENUM_VALUE11167 Enum11107 = 59
+	Enum11107_ENUM_VALUE11168 Enum11107 = 60
+	Enum11107_ENUM_VALUE11169 Enum11107 = 61
+	Enum11107_ENUM_VALUE11170 Enum11107 = 62
+	Enum11107_ENUM_VALUE11171 Enum11107 = 63
+	Enum11107_ENUM_VALUE11172 Enum11107 = 64
+	Enum11107_ENUM_VALUE11173 Enum11107 = 65
+	Enum11107_ENUM_VALUE11174 Enum11107 = 66
+	Enum11107_ENUM_VALUE11175 Enum11107 = 67
+	Enum11107_ENUM_VALUE11176 Enum11107 = 68
+	Enum11107_ENUM_VALUE11177 Enum11107 = 69
+	Enum11107_ENUM_VALUE11178 Enum11107 = 70
+	Enum11107_ENUM_VALUE11179 Enum11107 = 71
+	Enum11107_ENUM_VALUE11180 Enum11107 = 72
+	Enum11107_ENUM_VALUE11181 Enum11107 = 73
+	Enum11107_ENUM_VALUE11182 Enum11107 = 74
+	Enum11107_ENUM_VALUE11183 Enum11107 = 75
+	Enum11107_ENUM_VALUE11184 Enum11107 = 76
+	Enum11107_ENUM_VALUE11185 Enum11107 = 77
+	Enum11107_ENUM_VALUE11186 Enum11107 = 78
+	Enum11107_ENUM_VALUE11187 Enum11107 = 79
+	Enum11107_ENUM_VALUE11188 Enum11107 = 80
+	Enum11107_ENUM_VALUE11189 Enum11107 = 81
+	Enum11107_ENUM_VALUE11190 Enum11107 = 82
+	Enum11107_ENUM_VALUE11191 Enum11107 = 83
+	Enum11107_ENUM_VALUE11192 Enum11107 = 84
+	Enum11107_ENUM_VALUE11193 Enum11107 = 85
+	Enum11107_ENUM_VALUE11194 Enum11107 = 86
+	Enum11107_ENUM_VALUE11195 Enum11107 = 87
+	Enum11107_ENUM_VALUE11196 Enum11107 = 88
+	Enum11107_ENUM_VALUE11197 Enum11107 = 89
+	Enum11107_ENUM_VALUE11198 Enum11107 = 90
+	Enum11107_ENUM_VALUE11199 Enum11107 = 91
+	Enum11107_ENUM_VALUE11200 Enum11107 = 92
+	Enum11107_ENUM_VALUE11201 Enum11107 = 93
+	Enum11107_ENUM_VALUE11202 Enum11107 = 94
+	Enum11107_ENUM_VALUE11203 Enum11107 = 95
+	Enum11107_ENUM_VALUE11204 Enum11107 = 96
+	Enum11107_ENUM_VALUE11205 Enum11107 = 97
+	Enum11107_ENUM_VALUE11206 Enum11107 = 98
+	Enum11107_ENUM_VALUE11207 Enum11107 = 99
+	Enum11107_ENUM_VALUE11208 Enum11107 = 100
+	Enum11107_ENUM_VALUE11209 Enum11107 = 101
+	Enum11107_ENUM_VALUE11210 Enum11107 = 102
+	Enum11107_ENUM_VALUE11211 Enum11107 = 103
+	Enum11107_ENUM_VALUE11212 Enum11107 = 104
+	Enum11107_ENUM_VALUE11213 Enum11107 = 105
+	Enum11107_ENUM_VALUE11214 Enum11107 = 106
+	Enum11107_ENUM_VALUE11215 Enum11107 = 107
+	Enum11107_ENUM_VALUE11216 Enum11107 = 108
+	Enum11107_ENUM_VALUE11217 Enum11107 = 109
+	Enum11107_ENUM_VALUE11218 Enum11107 = 110
+	Enum11107_ENUM_VALUE11219 Enum11107 = 111
+	Enum11107_ENUM_VALUE11220 Enum11107 = 112
+	Enum11107_ENUM_VALUE11221 Enum11107 = 113
+	Enum11107_ENUM_VALUE11222 Enum11107 = 114
+	Enum11107_ENUM_VALUE11223 Enum11107 = 115
+	Enum11107_ENUM_VALUE11224 Enum11107 = 116
+	Enum11107_ENUM_VALUE11225 Enum11107 = 117
+	Enum11107_ENUM_VALUE11226 Enum11107 = 118
+	Enum11107_ENUM_VALUE11227 Enum11107 = 119
+	Enum11107_ENUM_VALUE11228 Enum11107 = 120
+	Enum11107_ENUM_VALUE11229 Enum11107 = 121
+	Enum11107_ENUM_VALUE11230 Enum11107 = 122
+	Enum11107_ENUM_VALUE11231 Enum11107 = 123
+	Enum11107_ENUM_VALUE11232 Enum11107 = 124
+	Enum11107_ENUM_VALUE11233 Enum11107 = 125
+	Enum11107_ENUM_VALUE11234 Enum11107 = 126
+	Enum11107_ENUM_VALUE11235 Enum11107 = 127
+	Enum11107_ENUM_VALUE11236 Enum11107 = 128
+	Enum11107_ENUM_VALUE11237 Enum11107 = 129
+	Enum11107_ENUM_VALUE11238 Enum11107 = 130
+	Enum11107_ENUM_VALUE11239 Enum11107 = 131
+	Enum11107_ENUM_VALUE11240 Enum11107 = 132
+	Enum11107_ENUM_VALUE11241 Enum11107 = 133
+	Enum11107_ENUM_VALUE11242 Enum11107 = 134
+	Enum11107_ENUM_VALUE11243 Enum11107 = 135
+	Enum11107_ENUM_VALUE11244 Enum11107 = 136
+	Enum11107_ENUM_VALUE11245 Enum11107 = 137
+	Enum11107_ENUM_VALUE11246 Enum11107 = 138
+	Enum11107_ENUM_VALUE11247 Enum11107 = 139
+	Enum11107_ENUM_VALUE11248 Enum11107 = 140
+	Enum11107_ENUM_VALUE11249 Enum11107 = 141
+	Enum11107_ENUM_VALUE11250 Enum11107 = 142
+	Enum11107_ENUM_VALUE11251 Enum11107 = 143
+	Enum11107_ENUM_VALUE11252 Enum11107 = 144
+	Enum11107_ENUM_VALUE11253 Enum11107 = 145
+	Enum11107_ENUM_VALUE11254 Enum11107 = 146
+	Enum11107_ENUM_VALUE11255 Enum11107 = 147
+	Enum11107_ENUM_VALUE11256 Enum11107 = 148
+	Enum11107_ENUM_VALUE11257 Enum11107 = 149
+	Enum11107_ENUM_VALUE11258 Enum11107 = 150
+	Enum11107_ENUM_VALUE11259 Enum11107 = 151
+	Enum11107_ENUM_VALUE11260 Enum11107 = 152
+	Enum11107_ENUM_VALUE11261 Enum11107 = 153
+	Enum11107_ENUM_VALUE11262 Enum11107 = 154
+	Enum11107_ENUM_VALUE11263 Enum11107 = 155
+	Enum11107_ENUM_VALUE11264 Enum11107 = 156
+	Enum11107_ENUM_VALUE11265 Enum11107 = 157
+	Enum11107_ENUM_VALUE11266 Enum11107 = 158
+	Enum11107_ENUM_VALUE11267 Enum11107 = 159
+	Enum11107_ENUM_VALUE11268 Enum11107 = 160
+	Enum11107_ENUM_VALUE11269 Enum11107 = 161
+	Enum11107_ENUM_VALUE11270 Enum11107 = 163
+	Enum11107_ENUM_VALUE11271 Enum11107 = 164
+	Enum11107_ENUM_VALUE11272 Enum11107 = 165
+	Enum11107_ENUM_VALUE11273 Enum11107 = 166
+	Enum11107_ENUM_VALUE11274 Enum11107 = 167
+	Enum11107_ENUM_VALUE11275 Enum11107 = 168
+	Enum11107_ENUM_VALUE11276 Enum11107 = 169
+	Enum11107_ENUM_VALUE11277 Enum11107 = 170
+	Enum11107_ENUM_VALUE11278 Enum11107 = 171
+	Enum11107_ENUM_VALUE11279 Enum11107 = 172
+	Enum11107_ENUM_VALUE11280 Enum11107 = 173
+	Enum11107_ENUM_VALUE11281 Enum11107 = 174
+	Enum11107_ENUM_VALUE11282 Enum11107 = 175
+	Enum11107_ENUM_VALUE11283 Enum11107 = 176
+	Enum11107_ENUM_VALUE11284 Enum11107 = 177
+	Enum11107_ENUM_VALUE11285 Enum11107 = 178
+	Enum11107_ENUM_VALUE11286 Enum11107 = 179
+	Enum11107_ENUM_VALUE11287 Enum11107 = 180
+	Enum11107_ENUM_VALUE11288 Enum11107 = 181
+	Enum11107_ENUM_VALUE11289 Enum11107 = 182
+	Enum11107_ENUM_VALUE11290 Enum11107 = 183
+	Enum11107_ENUM_VALUE11291 Enum11107 = 184
+	Enum11107_ENUM_VALUE11292 Enum11107 = 185
+	Enum11107_ENUM_VALUE11293 Enum11107 = 187
+	Enum11107_ENUM_VALUE11294 Enum11107 = 188
+	Enum11107_ENUM_VALUE11295 Enum11107 = 189
+	Enum11107_ENUM_VALUE11296 Enum11107 = 190
+	Enum11107_ENUM_VALUE11297 Enum11107 = 191
+	Enum11107_ENUM_VALUE11298 Enum11107 = 192
+	Enum11107_ENUM_VALUE11299 Enum11107 = 193
+	Enum11107_ENUM_VALUE11300 Enum11107 = 194
+	Enum11107_ENUM_VALUE11301 Enum11107 = 195
+	Enum11107_ENUM_VALUE11302 Enum11107 = 196
+	Enum11107_ENUM_VALUE11303 Enum11107 = 197
+	Enum11107_ENUM_VALUE11304 Enum11107 = 198
+	Enum11107_ENUM_VALUE11305 Enum11107 = 65535
+	Enum11107_ENUM_VALUE11306 Enum11107 = 65536
+	Enum11107_ENUM_VALUE11307 Enum11107 = 65537
+	Enum11107_ENUM_VALUE11308 Enum11107 = 65538
+	Enum11107_ENUM_VALUE11309 Enum11107 = 65539
+	Enum11107_ENUM_VALUE11310 Enum11107 = 65540
+	Enum11107_ENUM_VALUE11311 Enum11107 = 65541
+	Enum11107_ENUM_VALUE11312 Enum11107 = 65542
+	Enum11107_ENUM_VALUE11313 Enum11107 = 65543
+	Enum11107_ENUM_VALUE11314 Enum11107 = 65544
+	Enum11107_ENUM_VALUE11315 Enum11107 = 65545
+	Enum11107_ENUM_VALUE11316 Enum11107 = 65546
+	Enum11107_ENUM_VALUE11317 Enum11107 = 65547
+	Enum11107_ENUM_VALUE11318 Enum11107 = 65548
+	Enum11107_ENUM_VALUE11319 Enum11107 = 65549
+	Enum11107_ENUM_VALUE11320 Enum11107 = 65550
+	Enum11107_ENUM_VALUE11321 Enum11107 = 65551
+	Enum11107_ENUM_VALUE11322 Enum11107 = 65552
+	Enum11107_ENUM_VALUE11323 Enum11107 = 65553
+	Enum11107_ENUM_VALUE11324 Enum11107 = 65554
+	Enum11107_ENUM_VALUE11325 Enum11107 = 65555
+	Enum11107_ENUM_VALUE11326 Enum11107 = 65556
+	Enum11107_ENUM_VALUE11327 Enum11107 = 65557
+	Enum11107_ENUM_VALUE11328 Enum11107 = 65558
+	Enum11107_ENUM_VALUE11329 Enum11107 = 65559
+	Enum11107_ENUM_VALUE11330 Enum11107 = 65560
+	Enum11107_ENUM_VALUE11331 Enum11107 = 65561
+	Enum11107_ENUM_VALUE11332 Enum11107 = 65562
+	Enum11107_ENUM_VALUE11333 Enum11107 = 65563
+	Enum11107_ENUM_VALUE11334 Enum11107 = 69632
+	Enum11107_ENUM_VALUE11335 Enum11107 = 69633
+	Enum11107_ENUM_VALUE11336 Enum11107 = 69634
+	Enum11107_ENUM_VALUE11337 Enum11107 = 69635
+	Enum11107_ENUM_VALUE11338 Enum11107 = 69636
+	Enum11107_ENUM_VALUE11339 Enum11107 = 69637
+	Enum11107_ENUM_VALUE11340 Enum11107 = 69638
+	Enum11107_ENUM_VALUE11341 Enum11107 = 69639
+	Enum11107_ENUM_VALUE11342 Enum11107 = 69640
+	Enum11107_ENUM_VALUE11343 Enum11107 = 69641
+	Enum11107_ENUM_VALUE11344 Enum11107 = 69642
+	Enum11107_ENUM_VALUE11345 Enum11107 = 69643
+	Enum11107_ENUM_VALUE11346 Enum11107 = 69644
+	Enum11107_ENUM_VALUE11347 Enum11107 = 69645
+	Enum11107_ENUM_VALUE11348 Enum11107 = 69646
+	Enum11107_ENUM_VALUE11349 Enum11107 = 69647
+	Enum11107_ENUM_VALUE11350 Enum11107 = 69648
+	Enum11107_ENUM_VALUE11351 Enum11107 = 69649
+	Enum11107_ENUM_VALUE11352 Enum11107 = 69650
+	Enum11107_ENUM_VALUE11353 Enum11107 = 69651
+	Enum11107_ENUM_VALUE11354 Enum11107 = 69652
+	Enum11107_ENUM_VALUE11355 Enum11107 = 69653
+	Enum11107_ENUM_VALUE11356 Enum11107 = 69654
+	Enum11107_ENUM_VALUE11357 Enum11107 = 69655
+	Enum11107_ENUM_VALUE11358 Enum11107 = 69656
+	Enum11107_ENUM_VALUE11359 Enum11107 = 69657
+	Enum11107_ENUM_VALUE11360 Enum11107 = 69658
+	Enum11107_ENUM_VALUE11361 Enum11107 = 69659
+	Enum11107_ENUM_VALUE11362 Enum11107 = 69660
+	Enum11107_ENUM_VALUE11363 Enum11107 = 69661
+	Enum11107_ENUM_VALUE11364 Enum11107 = 69662
+	Enum11107_ENUM_VALUE11365 Enum11107 = 73728
+	Enum11107_ENUM_VALUE11366 Enum11107 = 73729
+	Enum11107_ENUM_VALUE11367 Enum11107 = 77824
+	Enum11107_ENUM_VALUE11368 Enum11107 = 77825
+	Enum11107_ENUM_VALUE11369 Enum11107 = 81920
+	Enum11107_ENUM_VALUE11370 Enum11107 = 81921
+	Enum11107_ENUM_VALUE11371 Enum11107 = 81922
+	Enum11107_ENUM_VALUE11372 Enum11107 = 81923
+	Enum11107_ENUM_VALUE11373 Enum11107 = 86016
+	Enum11107_ENUM_VALUE11374 Enum11107 = 86017
+	Enum11107_ENUM_VALUE11375 Enum11107 = 86018
+	Enum11107_ENUM_VALUE11376 Enum11107 = 86019
+	Enum11107_ENUM_VALUE11377 Enum11107 = 86020
+	Enum11107_ENUM_VALUE11378 Enum11107 = 86021
+	Enum11107_ENUM_VALUE11379 Enum11107 = 86022
+	Enum11107_ENUM_VALUE11380 Enum11107 = 86023
+	Enum11107_ENUM_VALUE11381 Enum11107 = 86024
+	Enum11107_ENUM_VALUE11382 Enum11107 = 86025
+	Enum11107_ENUM_VALUE11383 Enum11107 = 86026
+	Enum11107_ENUM_VALUE11384 Enum11107 = 86027
+	Enum11107_ENUM_VALUE11385 Enum11107 = 86028
+	Enum11107_ENUM_VALUE11386 Enum11107 = 86029
+	Enum11107_ENUM_VALUE11387 Enum11107 = 86030
+	Enum11107_ENUM_VALUE11388 Enum11107 = 86031
+	Enum11107_ENUM_VALUE11389 Enum11107 = 86032
+	Enum11107_ENUM_VALUE11390 Enum11107 = 86033
+	Enum11107_ENUM_VALUE11391 Enum11107 = 86034
+	Enum11107_ENUM_VALUE11392 Enum11107 = 86035
+	Enum11107_ENUM_VALUE11393 Enum11107 = 86036
+	Enum11107_ENUM_VALUE11394 Enum11107 = 86037
+	Enum11107_ENUM_VALUE11395 Enum11107 = 86038
+	Enum11107_ENUM_VALUE11396 Enum11107 = 86039
+	Enum11107_ENUM_VALUE11397 Enum11107 = 86040
+	Enum11107_ENUM_VALUE11398 Enum11107 = 86041
+	Enum11107_ENUM_VALUE11399 Enum11107 = 86042
+	Enum11107_ENUM_VALUE11400 Enum11107 = 86043
+	Enum11107_ENUM_VALUE11401 Enum11107 = 86044
+	Enum11107_ENUM_VALUE11402 Enum11107 = 86045
+	Enum11107_ENUM_VALUE11403 Enum11107 = 86046
+	Enum11107_ENUM_VALUE11404 Enum11107 = 86047
+	Enum11107_ENUM_VALUE11405 Enum11107 = 86048
+	Enum11107_ENUM_VALUE11406 Enum11107 = 86049
+	Enum11107_ENUM_VALUE11407 Enum11107 = 86050
+	Enum11107_ENUM_VALUE11408 Enum11107 = 86051
+	Enum11107_ENUM_VALUE11409 Enum11107 = 86052
+	Enum11107_ENUM_VALUE11410 Enum11107 = 86053
+	Enum11107_ENUM_VALUE11411 Enum11107 = 86054
+	Enum11107_ENUM_VALUE11412 Enum11107 = 86055
+	Enum11107_ENUM_VALUE11413 Enum11107 = 86056
+	Enum11107_ENUM_VALUE11414 Enum11107 = 86057
+	Enum11107_ENUM_VALUE11415 Enum11107 = 86058
+	Enum11107_ENUM_VALUE11416 Enum11107 = 86059
+	Enum11107_ENUM_VALUE11417 Enum11107 = 86060
+	Enum11107_ENUM_VALUE11418 Enum11107 = 86061
+	Enum11107_ENUM_VALUE11419 Enum11107 = 86062
+	Enum11107_ENUM_VALUE11420 Enum11107 = 86063
+	Enum11107_ENUM_VALUE11421 Enum11107 = 86064
+	Enum11107_ENUM_VALUE11422 Enum11107 = 86065
+	Enum11107_ENUM_VALUE11423 Enum11107 = 86066
+	Enum11107_ENUM_VALUE11424 Enum11107 = 86067
+	Enum11107_ENUM_VALUE11425 Enum11107 = 86068
+	Enum11107_ENUM_VALUE11426 Enum11107 = 86069
+	Enum11107_ENUM_VALUE11427 Enum11107 = 86070
+	Enum11107_ENUM_VALUE11428 Enum11107 = 86071
+	Enum11107_ENUM_VALUE11429 Enum11107 = 86072
+	Enum11107_ENUM_VALUE11430 Enum11107 = 86073
+	Enum11107_ENUM_VALUE11431 Enum11107 = 86074
+	Enum11107_ENUM_VALUE11432 Enum11107 = 86077
+	Enum11107_ENUM_VALUE11433 Enum11107 = 86078
+	Enum11107_ENUM_VALUE11434 Enum11107 = 86079
+	Enum11107_ENUM_VALUE11435 Enum11107 = 86080
+	Enum11107_ENUM_VALUE11436 Enum11107 = 86081
+	Enum11107_ENUM_VALUE11437 Enum11107 = 86082
+	Enum11107_ENUM_VALUE11438 Enum11107 = 86083
+	Enum11107_ENUM_VALUE11439 Enum11107 = 86084
+	Enum11107_ENUM_VALUE11440 Enum11107 = 90112
+	Enum11107_ENUM_VALUE11441 Enum11107 = 94208
+	Enum11107_ENUM_VALUE11442 Enum11107 = 94209
+	Enum11107_ENUM_VALUE11443 Enum11107 = 94210
+	Enum11107_ENUM_VALUE11444 Enum11107 = 94211
+	Enum11107_ENUM_VALUE11445 Enum11107 = 94212
+	Enum11107_ENUM_VALUE11446 Enum11107 = 94213
+	Enum11107_ENUM_VALUE11447 Enum11107 = 94214
+	Enum11107_ENUM_VALUE11448 Enum11107 = 94215
+	Enum11107_ENUM_VALUE11449 Enum11107 = 94216
+	Enum11107_ENUM_VALUE11450 Enum11107 = 94217
+	Enum11107_ENUM_VALUE11451 Enum11107 = 94218
+	Enum11107_ENUM_VALUE11452 Enum11107 = 94219
+	Enum11107_ENUM_VALUE11453 Enum11107 = 94220
+	Enum11107_ENUM_VALUE11454 Enum11107 = 94221
+	Enum11107_ENUM_VALUE11455 Enum11107 = 94222
+	Enum11107_ENUM_VALUE11456 Enum11107 = 94223
+	Enum11107_ENUM_VALUE11457 Enum11107 = 94224
+	Enum11107_ENUM_VALUE11458 Enum11107 = 98304
+	Enum11107_ENUM_VALUE11459 Enum11107 = 98305
+	Enum11107_ENUM_VALUE11460 Enum11107 = 98306
+	Enum11107_ENUM_VALUE11461 Enum11107 = 98307
+	Enum11107_ENUM_VALUE11462 Enum11107 = 98308
+	Enum11107_ENUM_VALUE11463 Enum11107 = 102400
+	Enum11107_ENUM_VALUE11464 Enum11107 = 131072
+	Enum11107_ENUM_VALUE11465 Enum11107 = 131073
+	Enum11107_ENUM_VALUE11466 Enum11107 = 135168
+	Enum11107_ENUM_VALUE11467 Enum11107 = 9439507
+)
+
+// Enum value maps for Enum11107.
+var (
+	Enum11107_name = map[int32]string{
+		0:       "ENUM_VALUE11108",
+		1:       "ENUM_VALUE11109",
+		2:       "ENUM_VALUE11110",
+		3:       "ENUM_VALUE11111",
+		4:       "ENUM_VALUE11112",
+		5:       "ENUM_VALUE11113",
+		6:       "ENUM_VALUE11114",
+		7:       "ENUM_VALUE11115",
+		8:       "ENUM_VALUE11116",
+		9:       "ENUM_VALUE11117",
+		10:      "ENUM_VALUE11118",
+		11:      "ENUM_VALUE11119",
+		12:      "ENUM_VALUE11120",
+		13:      "ENUM_VALUE11121",
+		14:      "ENUM_VALUE11122",
+		15:      "ENUM_VALUE11123",
+		16:      "ENUM_VALUE11124",
+		17:      "ENUM_VALUE11125",
+		18:      "ENUM_VALUE11126",
+		19:      "ENUM_VALUE11127",
+		20:      "ENUM_VALUE11128",
+		21:      "ENUM_VALUE11129",
+		22:      "ENUM_VALUE11130",
+		23:      "ENUM_VALUE11131",
+		24:      "ENUM_VALUE11132",
+		25:      "ENUM_VALUE11133",
+		26:      "ENUM_VALUE11134",
+		27:      "ENUM_VALUE11135",
+		28:      "ENUM_VALUE11136",
+		29:      "ENUM_VALUE11137",
+		30:      "ENUM_VALUE11138",
+		31:      "ENUM_VALUE11139",
+		32:      "ENUM_VALUE11140",
+		33:      "ENUM_VALUE11141",
+		34:      "ENUM_VALUE11142",
+		35:      "ENUM_VALUE11143",
+		36:      "ENUM_VALUE11144",
+		37:      "ENUM_VALUE11145",
+		38:      "ENUM_VALUE11146",
+		39:      "ENUM_VALUE11147",
+		40:      "ENUM_VALUE11148",
+		41:      "ENUM_VALUE11149",
+		42:      "ENUM_VALUE11150",
+		43:      "ENUM_VALUE11151",
+		44:      "ENUM_VALUE11152",
+		45:      "ENUM_VALUE11153",
+		46:      "ENUM_VALUE11154",
+		47:      "ENUM_VALUE11155",
+		48:      "ENUM_VALUE11156",
+		49:      "ENUM_VALUE11157",
+		50:      "ENUM_VALUE11158",
+		51:      "ENUM_VALUE11159",
+		52:      "ENUM_VALUE11160",
+		53:      "ENUM_VALUE11161",
+		54:      "ENUM_VALUE11162",
+		55:      "ENUM_VALUE11163",
+		56:      "ENUM_VALUE11164",
+		57:      "ENUM_VALUE11165",
+		58:      "ENUM_VALUE11166",
+		59:      "ENUM_VALUE11167",
+		60:      "ENUM_VALUE11168",
+		61:      "ENUM_VALUE11169",
+		62:      "ENUM_VALUE11170",
+		63:      "ENUM_VALUE11171",
+		64:      "ENUM_VALUE11172",
+		65:      "ENUM_VALUE11173",
+		66:      "ENUM_VALUE11174",
+		67:      "ENUM_VALUE11175",
+		68:      "ENUM_VALUE11176",
+		69:      "ENUM_VALUE11177",
+		70:      "ENUM_VALUE11178",
+		71:      "ENUM_VALUE11179",
+		72:      "ENUM_VALUE11180",
+		73:      "ENUM_VALUE11181",
+		74:      "ENUM_VALUE11182",
+		75:      "ENUM_VALUE11183",
+		76:      "ENUM_VALUE11184",
+		77:      "ENUM_VALUE11185",
+		78:      "ENUM_VALUE11186",
+		79:      "ENUM_VALUE11187",
+		80:      "ENUM_VALUE11188",
+		81:      "ENUM_VALUE11189",
+		82:      "ENUM_VALUE11190",
+		83:      "ENUM_VALUE11191",
+		84:      "ENUM_VALUE11192",
+		85:      "ENUM_VALUE11193",
+		86:      "ENUM_VALUE11194",
+		87:      "ENUM_VALUE11195",
+		88:      "ENUM_VALUE11196",
+		89:      "ENUM_VALUE11197",
+		90:      "ENUM_VALUE11198",
+		91:      "ENUM_VALUE11199",
+		92:      "ENUM_VALUE11200",
+		93:      "ENUM_VALUE11201",
+		94:      "ENUM_VALUE11202",
+		95:      "ENUM_VALUE11203",
+		96:      "ENUM_VALUE11204",
+		97:      "ENUM_VALUE11205",
+		98:      "ENUM_VALUE11206",
+		99:      "ENUM_VALUE11207",
+		100:     "ENUM_VALUE11208",
+		101:     "ENUM_VALUE11209",
+		102:     "ENUM_VALUE11210",
+		103:     "ENUM_VALUE11211",
+		104:     "ENUM_VALUE11212",
+		105:     "ENUM_VALUE11213",
+		106:     "ENUM_VALUE11214",
+		107:     "ENUM_VALUE11215",
+		108:     "ENUM_VALUE11216",
+		109:     "ENUM_VALUE11217",
+		110:     "ENUM_VALUE11218",
+		111:     "ENUM_VALUE11219",
+		112:     "ENUM_VALUE11220",
+		113:     "ENUM_VALUE11221",
+		114:     "ENUM_VALUE11222",
+		115:     "ENUM_VALUE11223",
+		116:     "ENUM_VALUE11224",
+		117:     "ENUM_VALUE11225",
+		118:     "ENUM_VALUE11226",
+		119:     "ENUM_VALUE11227",
+		120:     "ENUM_VALUE11228",
+		121:     "ENUM_VALUE11229",
+		122:     "ENUM_VALUE11230",
+		123:     "ENUM_VALUE11231",
+		124:     "ENUM_VALUE11232",
+		125:     "ENUM_VALUE11233",
+		126:     "ENUM_VALUE11234",
+		127:     "ENUM_VALUE11235",
+		128:     "ENUM_VALUE11236",
+		129:     "ENUM_VALUE11237",
+		130:     "ENUM_VALUE11238",
+		131:     "ENUM_VALUE11239",
+		132:     "ENUM_VALUE11240",
+		133:     "ENUM_VALUE11241",
+		134:     "ENUM_VALUE11242",
+		135:     "ENUM_VALUE11243",
+		136:     "ENUM_VALUE11244",
+		137:     "ENUM_VALUE11245",
+		138:     "ENUM_VALUE11246",
+		139:     "ENUM_VALUE11247",
+		140:     "ENUM_VALUE11248",
+		141:     "ENUM_VALUE11249",
+		142:     "ENUM_VALUE11250",
+		143:     "ENUM_VALUE11251",
+		144:     "ENUM_VALUE11252",
+		145:     "ENUM_VALUE11253",
+		146:     "ENUM_VALUE11254",
+		147:     "ENUM_VALUE11255",
+		148:     "ENUM_VALUE11256",
+		149:     "ENUM_VALUE11257",
+		150:     "ENUM_VALUE11258",
+		151:     "ENUM_VALUE11259",
+		152:     "ENUM_VALUE11260",
+		153:     "ENUM_VALUE11261",
+		154:     "ENUM_VALUE11262",
+		155:     "ENUM_VALUE11263",
+		156:     "ENUM_VALUE11264",
+		157:     "ENUM_VALUE11265",
+		158:     "ENUM_VALUE11266",
+		159:     "ENUM_VALUE11267",
+		160:     "ENUM_VALUE11268",
+		161:     "ENUM_VALUE11269",
+		163:     "ENUM_VALUE11270",
+		164:     "ENUM_VALUE11271",
+		165:     "ENUM_VALUE11272",
+		166:     "ENUM_VALUE11273",
+		167:     "ENUM_VALUE11274",
+		168:     "ENUM_VALUE11275",
+		169:     "ENUM_VALUE11276",
+		170:     "ENUM_VALUE11277",
+		171:     "ENUM_VALUE11278",
+		172:     "ENUM_VALUE11279",
+		173:     "ENUM_VALUE11280",
+		174:     "ENUM_VALUE11281",
+		175:     "ENUM_VALUE11282",
+		176:     "ENUM_VALUE11283",
+		177:     "ENUM_VALUE11284",
+		178:     "ENUM_VALUE11285",
+		179:     "ENUM_VALUE11286",
+		180:     "ENUM_VALUE11287",
+		181:     "ENUM_VALUE11288",
+		182:     "ENUM_VALUE11289",
+		183:     "ENUM_VALUE11290",
+		184:     "ENUM_VALUE11291",
+		185:     "ENUM_VALUE11292",
+		187:     "ENUM_VALUE11293",
+		188:     "ENUM_VALUE11294",
+		189:     "ENUM_VALUE11295",
+		190:     "ENUM_VALUE11296",
+		191:     "ENUM_VALUE11297",
+		192:     "ENUM_VALUE11298",
+		193:     "ENUM_VALUE11299",
+		194:     "ENUM_VALUE11300",
+		195:     "ENUM_VALUE11301",
+		196:     "ENUM_VALUE11302",
+		197:     "ENUM_VALUE11303",
+		198:     "ENUM_VALUE11304",
+		65535:   "ENUM_VALUE11305",
+		65536:   "ENUM_VALUE11306",
+		65537:   "ENUM_VALUE11307",
+		65538:   "ENUM_VALUE11308",
+		65539:   "ENUM_VALUE11309",
+		65540:   "ENUM_VALUE11310",
+		65541:   "ENUM_VALUE11311",
+		65542:   "ENUM_VALUE11312",
+		65543:   "ENUM_VALUE11313",
+		65544:   "ENUM_VALUE11314",
+		65545:   "ENUM_VALUE11315",
+		65546:   "ENUM_VALUE11316",
+		65547:   "ENUM_VALUE11317",
+		65548:   "ENUM_VALUE11318",
+		65549:   "ENUM_VALUE11319",
+		65550:   "ENUM_VALUE11320",
+		65551:   "ENUM_VALUE11321",
+		65552:   "ENUM_VALUE11322",
+		65553:   "ENUM_VALUE11323",
+		65554:   "ENUM_VALUE11324",
+		65555:   "ENUM_VALUE11325",
+		65556:   "ENUM_VALUE11326",
+		65557:   "ENUM_VALUE11327",
+		65558:   "ENUM_VALUE11328",
+		65559:   "ENUM_VALUE11329",
+		65560:   "ENUM_VALUE11330",
+		65561:   "ENUM_VALUE11331",
+		65562:   "ENUM_VALUE11332",
+		65563:   "ENUM_VALUE11333",
+		69632:   "ENUM_VALUE11334",
+		69633:   "ENUM_VALUE11335",
+		69634:   "ENUM_VALUE11336",
+		69635:   "ENUM_VALUE11337",
+		69636:   "ENUM_VALUE11338",
+		69637:   "ENUM_VALUE11339",
+		69638:   "ENUM_VALUE11340",
+		69639:   "ENUM_VALUE11341",
+		69640:   "ENUM_VALUE11342",
+		69641:   "ENUM_VALUE11343",
+		69642:   "ENUM_VALUE11344",
+		69643:   "ENUM_VALUE11345",
+		69644:   "ENUM_VALUE11346",
+		69645:   "ENUM_VALUE11347",
+		69646:   "ENUM_VALUE11348",
+		69647:   "ENUM_VALUE11349",
+		69648:   "ENUM_VALUE11350",
+		69649:   "ENUM_VALUE11351",
+		69650:   "ENUM_VALUE11352",
+		69651:   "ENUM_VALUE11353",
+		69652:   "ENUM_VALUE11354",
+		69653:   "ENUM_VALUE11355",
+		69654:   "ENUM_VALUE11356",
+		69655:   "ENUM_VALUE11357",
+		69656:   "ENUM_VALUE11358",
+		69657:   "ENUM_VALUE11359",
+		69658:   "ENUM_VALUE11360",
+		69659:   "ENUM_VALUE11361",
+		69660:   "ENUM_VALUE11362",
+		69661:   "ENUM_VALUE11363",
+		69662:   "ENUM_VALUE11364",
+		73728:   "ENUM_VALUE11365",
+		73729:   "ENUM_VALUE11366",
+		77824:   "ENUM_VALUE11367",
+		77825:   "ENUM_VALUE11368",
+		81920:   "ENUM_VALUE11369",
+		81921:   "ENUM_VALUE11370",
+		81922:   "ENUM_VALUE11371",
+		81923:   "ENUM_VALUE11372",
+		86016:   "ENUM_VALUE11373",
+		86017:   "ENUM_VALUE11374",
+		86018:   "ENUM_VALUE11375",
+		86019:   "ENUM_VALUE11376",
+		86020:   "ENUM_VALUE11377",
+		86021:   "ENUM_VALUE11378",
+		86022:   "ENUM_VALUE11379",
+		86023:   "ENUM_VALUE11380",
+		86024:   "ENUM_VALUE11381",
+		86025:   "ENUM_VALUE11382",
+		86026:   "ENUM_VALUE11383",
+		86027:   "ENUM_VALUE11384",
+		86028:   "ENUM_VALUE11385",
+		86029:   "ENUM_VALUE11386",
+		86030:   "ENUM_VALUE11387",
+		86031:   "ENUM_VALUE11388",
+		86032:   "ENUM_VALUE11389",
+		86033:   "ENUM_VALUE11390",
+		86034:   "ENUM_VALUE11391",
+		86035:   "ENUM_VALUE11392",
+		86036:   "ENUM_VALUE11393",
+		86037:   "ENUM_VALUE11394",
+		86038:   "ENUM_VALUE11395",
+		86039:   "ENUM_VALUE11396",
+		86040:   "ENUM_VALUE11397",
+		86041:   "ENUM_VALUE11398",
+		86042:   "ENUM_VALUE11399",
+		86043:   "ENUM_VALUE11400",
+		86044:   "ENUM_VALUE11401",
+		86045:   "ENUM_VALUE11402",
+		86046:   "ENUM_VALUE11403",
+		86047:   "ENUM_VALUE11404",
+		86048:   "ENUM_VALUE11405",
+		86049:   "ENUM_VALUE11406",
+		86050:   "ENUM_VALUE11407",
+		86051:   "ENUM_VALUE11408",
+		86052:   "ENUM_VALUE11409",
+		86053:   "ENUM_VALUE11410",
+		86054:   "ENUM_VALUE11411",
+		86055:   "ENUM_VALUE11412",
+		86056:   "ENUM_VALUE11413",
+		86057:   "ENUM_VALUE11414",
+		86058:   "ENUM_VALUE11415",
+		86059:   "ENUM_VALUE11416",
+		86060:   "ENUM_VALUE11417",
+		86061:   "ENUM_VALUE11418",
+		86062:   "ENUM_VALUE11419",
+		86063:   "ENUM_VALUE11420",
+		86064:   "ENUM_VALUE11421",
+		86065:   "ENUM_VALUE11422",
+		86066:   "ENUM_VALUE11423",
+		86067:   "ENUM_VALUE11424",
+		86068:   "ENUM_VALUE11425",
+		86069:   "ENUM_VALUE11426",
+		86070:   "ENUM_VALUE11427",
+		86071:   "ENUM_VALUE11428",
+		86072:   "ENUM_VALUE11429",
+		86073:   "ENUM_VALUE11430",
+		86074:   "ENUM_VALUE11431",
+		86077:   "ENUM_VALUE11432",
+		86078:   "ENUM_VALUE11433",
+		86079:   "ENUM_VALUE11434",
+		86080:   "ENUM_VALUE11435",
+		86081:   "ENUM_VALUE11436",
+		86082:   "ENUM_VALUE11437",
+		86083:   "ENUM_VALUE11438",
+		86084:   "ENUM_VALUE11439",
+		90112:   "ENUM_VALUE11440",
+		94208:   "ENUM_VALUE11441",
+		94209:   "ENUM_VALUE11442",
+		94210:   "ENUM_VALUE11443",
+		94211:   "ENUM_VALUE11444",
+		94212:   "ENUM_VALUE11445",
+		94213:   "ENUM_VALUE11446",
+		94214:   "ENUM_VALUE11447",
+		94215:   "ENUM_VALUE11448",
+		94216:   "ENUM_VALUE11449",
+		94217:   "ENUM_VALUE11450",
+		94218:   "ENUM_VALUE11451",
+		94219:   "ENUM_VALUE11452",
+		94220:   "ENUM_VALUE11453",
+		94221:   "ENUM_VALUE11454",
+		94222:   "ENUM_VALUE11455",
+		94223:   "ENUM_VALUE11456",
+		94224:   "ENUM_VALUE11457",
+		98304:   "ENUM_VALUE11458",
+		98305:   "ENUM_VALUE11459",
+		98306:   "ENUM_VALUE11460",
+		98307:   "ENUM_VALUE11461",
+		98308:   "ENUM_VALUE11462",
+		102400:  "ENUM_VALUE11463",
+		131072:  "ENUM_VALUE11464",
+		131073:  "ENUM_VALUE11465",
+		135168:  "ENUM_VALUE11466",
+		9439507: "ENUM_VALUE11467",
+	}
+	Enum11107_value = map[string]int32{
+		"ENUM_VALUE11108": 0,
+		"ENUM_VALUE11109": 1,
+		"ENUM_VALUE11110": 2,
+		"ENUM_VALUE11111": 3,
+		"ENUM_VALUE11112": 4,
+		"ENUM_VALUE11113": 5,
+		"ENUM_VALUE11114": 6,
+		"ENUM_VALUE11115": 7,
+		"ENUM_VALUE11116": 8,
+		"ENUM_VALUE11117": 9,
+		"ENUM_VALUE11118": 10,
+		"ENUM_VALUE11119": 11,
+		"ENUM_VALUE11120": 12,
+		"ENUM_VALUE11121": 13,
+		"ENUM_VALUE11122": 14,
+		"ENUM_VALUE11123": 15,
+		"ENUM_VALUE11124": 16,
+		"ENUM_VALUE11125": 17,
+		"ENUM_VALUE11126": 18,
+		"ENUM_VALUE11127": 19,
+		"ENUM_VALUE11128": 20,
+		"ENUM_VALUE11129": 21,
+		"ENUM_VALUE11130": 22,
+		"ENUM_VALUE11131": 23,
+		"ENUM_VALUE11132": 24,
+		"ENUM_VALUE11133": 25,
+		"ENUM_VALUE11134": 26,
+		"ENUM_VALUE11135": 27,
+		"ENUM_VALUE11136": 28,
+		"ENUM_VALUE11137": 29,
+		"ENUM_VALUE11138": 30,
+		"ENUM_VALUE11139": 31,
+		"ENUM_VALUE11140": 32,
+		"ENUM_VALUE11141": 33,
+		"ENUM_VALUE11142": 34,
+		"ENUM_VALUE11143": 35,
+		"ENUM_VALUE11144": 36,
+		"ENUM_VALUE11145": 37,
+		"ENUM_VALUE11146": 38,
+		"ENUM_VALUE11147": 39,
+		"ENUM_VALUE11148": 40,
+		"ENUM_VALUE11149": 41,
+		"ENUM_VALUE11150": 42,
+		"ENUM_VALUE11151": 43,
+		"ENUM_VALUE11152": 44,
+		"ENUM_VALUE11153": 45,
+		"ENUM_VALUE11154": 46,
+		"ENUM_VALUE11155": 47,
+		"ENUM_VALUE11156": 48,
+		"ENUM_VALUE11157": 49,
+		"ENUM_VALUE11158": 50,
+		"ENUM_VALUE11159": 51,
+		"ENUM_VALUE11160": 52,
+		"ENUM_VALUE11161": 53,
+		"ENUM_VALUE11162": 54,
+		"ENUM_VALUE11163": 55,
+		"ENUM_VALUE11164": 56,
+		"ENUM_VALUE11165": 57,
+		"ENUM_VALUE11166": 58,
+		"ENUM_VALUE11167": 59,
+		"ENUM_VALUE11168": 60,
+		"ENUM_VALUE11169": 61,
+		"ENUM_VALUE11170": 62,
+		"ENUM_VALUE11171": 63,
+		"ENUM_VALUE11172": 64,
+		"ENUM_VALUE11173": 65,
+		"ENUM_VALUE11174": 66,
+		"ENUM_VALUE11175": 67,
+		"ENUM_VALUE11176": 68,
+		"ENUM_VALUE11177": 69,
+		"ENUM_VALUE11178": 70,
+		"ENUM_VALUE11179": 71,
+		"ENUM_VALUE11180": 72,
+		"ENUM_VALUE11181": 73,
+		"ENUM_VALUE11182": 74,
+		"ENUM_VALUE11183": 75,
+		"ENUM_VALUE11184": 76,
+		"ENUM_VALUE11185": 77,
+		"ENUM_VALUE11186": 78,
+		"ENUM_VALUE11187": 79,
+		"ENUM_VALUE11188": 80,
+		"ENUM_VALUE11189": 81,
+		"ENUM_VALUE11190": 82,
+		"ENUM_VALUE11191": 83,
+		"ENUM_VALUE11192": 84,
+		"ENUM_VALUE11193": 85,
+		"ENUM_VALUE11194": 86,
+		"ENUM_VALUE11195": 87,
+		"ENUM_VALUE11196": 88,
+		"ENUM_VALUE11197": 89,
+		"ENUM_VALUE11198": 90,
+		"ENUM_VALUE11199": 91,
+		"ENUM_VALUE11200": 92,
+		"ENUM_VALUE11201": 93,
+		"ENUM_VALUE11202": 94,
+		"ENUM_VALUE11203": 95,
+		"ENUM_VALUE11204": 96,
+		"ENUM_VALUE11205": 97,
+		"ENUM_VALUE11206": 98,
+		"ENUM_VALUE11207": 99,
+		"ENUM_VALUE11208": 100,
+		"ENUM_VALUE11209": 101,
+		"ENUM_VALUE11210": 102,
+		"ENUM_VALUE11211": 103,
+		"ENUM_VALUE11212": 104,
+		"ENUM_VALUE11213": 105,
+		"ENUM_VALUE11214": 106,
+		"ENUM_VALUE11215": 107,
+		"ENUM_VALUE11216": 108,
+		"ENUM_VALUE11217": 109,
+		"ENUM_VALUE11218": 110,
+		"ENUM_VALUE11219": 111,
+		"ENUM_VALUE11220": 112,
+		"ENUM_VALUE11221": 113,
+		"ENUM_VALUE11222": 114,
+		"ENUM_VALUE11223": 115,
+		"ENUM_VALUE11224": 116,
+		"ENUM_VALUE11225": 117,
+		"ENUM_VALUE11226": 118,
+		"ENUM_VALUE11227": 119,
+		"ENUM_VALUE11228": 120,
+		"ENUM_VALUE11229": 121,
+		"ENUM_VALUE11230": 122,
+		"ENUM_VALUE11231": 123,
+		"ENUM_VALUE11232": 124,
+		"ENUM_VALUE11233": 125,
+		"ENUM_VALUE11234": 126,
+		"ENUM_VALUE11235": 127,
+		"ENUM_VALUE11236": 128,
+		"ENUM_VALUE11237": 129,
+		"ENUM_VALUE11238": 130,
+		"ENUM_VALUE11239": 131,
+		"ENUM_VALUE11240": 132,
+		"ENUM_VALUE11241": 133,
+		"ENUM_VALUE11242": 134,
+		"ENUM_VALUE11243": 135,
+		"ENUM_VALUE11244": 136,
+		"ENUM_VALUE11245": 137,
+		"ENUM_VALUE11246": 138,
+		"ENUM_VALUE11247": 139,
+		"ENUM_VALUE11248": 140,
+		"ENUM_VALUE11249": 141,
+		"ENUM_VALUE11250": 142,
+		"ENUM_VALUE11251": 143,
+		"ENUM_VALUE11252": 144,
+		"ENUM_VALUE11253": 145,
+		"ENUM_VALUE11254": 146,
+		"ENUM_VALUE11255": 147,
+		"ENUM_VALUE11256": 148,
+		"ENUM_VALUE11257": 149,
+		"ENUM_VALUE11258": 150,
+		"ENUM_VALUE11259": 151,
+		"ENUM_VALUE11260": 152,
+		"ENUM_VALUE11261": 153,
+		"ENUM_VALUE11262": 154,
+		"ENUM_VALUE11263": 155,
+		"ENUM_VALUE11264": 156,
+		"ENUM_VALUE11265": 157,
+		"ENUM_VALUE11266": 158,
+		"ENUM_VALUE11267": 159,
+		"ENUM_VALUE11268": 160,
+		"ENUM_VALUE11269": 161,
+		"ENUM_VALUE11270": 163,
+		"ENUM_VALUE11271": 164,
+		"ENUM_VALUE11272": 165,
+		"ENUM_VALUE11273": 166,
+		"ENUM_VALUE11274": 167,
+		"ENUM_VALUE11275": 168,
+		"ENUM_VALUE11276": 169,
+		"ENUM_VALUE11277": 170,
+		"ENUM_VALUE11278": 171,
+		"ENUM_VALUE11279": 172,
+		"ENUM_VALUE11280": 173,
+		"ENUM_VALUE11281": 174,
+		"ENUM_VALUE11282": 175,
+		"ENUM_VALUE11283": 176,
+		"ENUM_VALUE11284": 177,
+		"ENUM_VALUE11285": 178,
+		"ENUM_VALUE11286": 179,
+		"ENUM_VALUE11287": 180,
+		"ENUM_VALUE11288": 181,
+		"ENUM_VALUE11289": 182,
+		"ENUM_VALUE11290": 183,
+		"ENUM_VALUE11291": 184,
+		"ENUM_VALUE11292": 185,
+		"ENUM_VALUE11293": 187,
+		"ENUM_VALUE11294": 188,
+		"ENUM_VALUE11295": 189,
+		"ENUM_VALUE11296": 190,
+		"ENUM_VALUE11297": 191,
+		"ENUM_VALUE11298": 192,
+		"ENUM_VALUE11299": 193,
+		"ENUM_VALUE11300": 194,
+		"ENUM_VALUE11301": 195,
+		"ENUM_VALUE11302": 196,
+		"ENUM_VALUE11303": 197,
+		"ENUM_VALUE11304": 198,
+		"ENUM_VALUE11305": 65535,
+		"ENUM_VALUE11306": 65536,
+		"ENUM_VALUE11307": 65537,
+		"ENUM_VALUE11308": 65538,
+		"ENUM_VALUE11309": 65539,
+		"ENUM_VALUE11310": 65540,
+		"ENUM_VALUE11311": 65541,
+		"ENUM_VALUE11312": 65542,
+		"ENUM_VALUE11313": 65543,
+		"ENUM_VALUE11314": 65544,
+		"ENUM_VALUE11315": 65545,
+		"ENUM_VALUE11316": 65546,
+		"ENUM_VALUE11317": 65547,
+		"ENUM_VALUE11318": 65548,
+		"ENUM_VALUE11319": 65549,
+		"ENUM_VALUE11320": 65550,
+		"ENUM_VALUE11321": 65551,
+		"ENUM_VALUE11322": 65552,
+		"ENUM_VALUE11323": 65553,
+		"ENUM_VALUE11324": 65554,
+		"ENUM_VALUE11325": 65555,
+		"ENUM_VALUE11326": 65556,
+		"ENUM_VALUE11327": 65557,
+		"ENUM_VALUE11328": 65558,
+		"ENUM_VALUE11329": 65559,
+		"ENUM_VALUE11330": 65560,
+		"ENUM_VALUE11331": 65561,
+		"ENUM_VALUE11332": 65562,
+		"ENUM_VALUE11333": 65563,
+		"ENUM_VALUE11334": 69632,
+		"ENUM_VALUE11335": 69633,
+		"ENUM_VALUE11336": 69634,
+		"ENUM_VALUE11337": 69635,
+		"ENUM_VALUE11338": 69636,
+		"ENUM_VALUE11339": 69637,
+		"ENUM_VALUE11340": 69638,
+		"ENUM_VALUE11341": 69639,
+		"ENUM_VALUE11342": 69640,
+		"ENUM_VALUE11343": 69641,
+		"ENUM_VALUE11344": 69642,
+		"ENUM_VALUE11345": 69643,
+		"ENUM_VALUE11346": 69644,
+		"ENUM_VALUE11347": 69645,
+		"ENUM_VALUE11348": 69646,
+		"ENUM_VALUE11349": 69647,
+		"ENUM_VALUE11350": 69648,
+		"ENUM_VALUE11351": 69649,
+		"ENUM_VALUE11352": 69650,
+		"ENUM_VALUE11353": 69651,
+		"ENUM_VALUE11354": 69652,
+		"ENUM_VALUE11355": 69653,
+		"ENUM_VALUE11356": 69654,
+		"ENUM_VALUE11357": 69655,
+		"ENUM_VALUE11358": 69656,
+		"ENUM_VALUE11359": 69657,
+		"ENUM_VALUE11360": 69658,
+		"ENUM_VALUE11361": 69659,
+		"ENUM_VALUE11362": 69660,
+		"ENUM_VALUE11363": 69661,
+		"ENUM_VALUE11364": 69662,
+		"ENUM_VALUE11365": 73728,
+		"ENUM_VALUE11366": 73729,
+		"ENUM_VALUE11367": 77824,
+		"ENUM_VALUE11368": 77825,
+		"ENUM_VALUE11369": 81920,
+		"ENUM_VALUE11370": 81921,
+		"ENUM_VALUE11371": 81922,
+		"ENUM_VALUE11372": 81923,
+		"ENUM_VALUE11373": 86016,
+		"ENUM_VALUE11374": 86017,
+		"ENUM_VALUE11375": 86018,
+		"ENUM_VALUE11376": 86019,
+		"ENUM_VALUE11377": 86020,
+		"ENUM_VALUE11378": 86021,
+		"ENUM_VALUE11379": 86022,
+		"ENUM_VALUE11380": 86023,
+		"ENUM_VALUE11381": 86024,
+		"ENUM_VALUE11382": 86025,
+		"ENUM_VALUE11383": 86026,
+		"ENUM_VALUE11384": 86027,
+		"ENUM_VALUE11385": 86028,
+		"ENUM_VALUE11386": 86029,
+		"ENUM_VALUE11387": 86030,
+		"ENUM_VALUE11388": 86031,
+		"ENUM_VALUE11389": 86032,
+		"ENUM_VALUE11390": 86033,
+		"ENUM_VALUE11391": 86034,
+		"ENUM_VALUE11392": 86035,
+		"ENUM_VALUE11393": 86036,
+		"ENUM_VALUE11394": 86037,
+		"ENUM_VALUE11395": 86038,
+		"ENUM_VALUE11396": 86039,
+		"ENUM_VALUE11397": 86040,
+		"ENUM_VALUE11398": 86041,
+		"ENUM_VALUE11399": 86042,
+		"ENUM_VALUE11400": 86043,
+		"ENUM_VALUE11401": 86044,
+		"ENUM_VALUE11402": 86045,
+		"ENUM_VALUE11403": 86046,
+		"ENUM_VALUE11404": 86047,
+		"ENUM_VALUE11405": 86048,
+		"ENUM_VALUE11406": 86049,
+		"ENUM_VALUE11407": 86050,
+		"ENUM_VALUE11408": 86051,
+		"ENUM_VALUE11409": 86052,
+		"ENUM_VALUE11410": 86053,
+		"ENUM_VALUE11411": 86054,
+		"ENUM_VALUE11412": 86055,
+		"ENUM_VALUE11413": 86056,
+		"ENUM_VALUE11414": 86057,
+		"ENUM_VALUE11415": 86058,
+		"ENUM_VALUE11416": 86059,
+		"ENUM_VALUE11417": 86060,
+		"ENUM_VALUE11418": 86061,
+		"ENUM_VALUE11419": 86062,
+		"ENUM_VALUE11420": 86063,
+		"ENUM_VALUE11421": 86064,
+		"ENUM_VALUE11422": 86065,
+		"ENUM_VALUE11423": 86066,
+		"ENUM_VALUE11424": 86067,
+		"ENUM_VALUE11425": 86068,
+		"ENUM_VALUE11426": 86069,
+		"ENUM_VALUE11427": 86070,
+		"ENUM_VALUE11428": 86071,
+		"ENUM_VALUE11429": 86072,
+		"ENUM_VALUE11430": 86073,
+		"ENUM_VALUE11431": 86074,
+		"ENUM_VALUE11432": 86077,
+		"ENUM_VALUE11433": 86078,
+		"ENUM_VALUE11434": 86079,
+		"ENUM_VALUE11435": 86080,
+		"ENUM_VALUE11436": 86081,
+		"ENUM_VALUE11437": 86082,
+		"ENUM_VALUE11438": 86083,
+		"ENUM_VALUE11439": 86084,
+		"ENUM_VALUE11440": 90112,
+		"ENUM_VALUE11441": 94208,
+		"ENUM_VALUE11442": 94209,
+		"ENUM_VALUE11443": 94210,
+		"ENUM_VALUE11444": 94211,
+		"ENUM_VALUE11445": 94212,
+		"ENUM_VALUE11446": 94213,
+		"ENUM_VALUE11447": 94214,
+		"ENUM_VALUE11448": 94215,
+		"ENUM_VALUE11449": 94216,
+		"ENUM_VALUE11450": 94217,
+		"ENUM_VALUE11451": 94218,
+		"ENUM_VALUE11452": 94219,
+		"ENUM_VALUE11453": 94220,
+		"ENUM_VALUE11454": 94221,
+		"ENUM_VALUE11455": 94222,
+		"ENUM_VALUE11456": 94223,
+		"ENUM_VALUE11457": 94224,
+		"ENUM_VALUE11458": 98304,
+		"ENUM_VALUE11459": 98305,
+		"ENUM_VALUE11460": 98306,
+		"ENUM_VALUE11461": 98307,
+		"ENUM_VALUE11462": 98308,
+		"ENUM_VALUE11463": 102400,
+		"ENUM_VALUE11464": 131072,
+		"ENUM_VALUE11465": 131073,
+		"ENUM_VALUE11466": 135168,
+		"ENUM_VALUE11467": 9439507,
+	}
+)
+
+func (x Enum11107) Enum() *Enum11107 {
+	p := new(Enum11107)
+	*p = x
+	return p
+}
+
+func (x Enum11107) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum11107) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[33].Descriptor()
+}
+
+func (Enum11107) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[33]
+}
+
+func (x Enum11107) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum11107) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum11107(num)
+	return nil
+}
+
+// Deprecated: Use Enum11107.Descriptor instead.
+func (Enum11107) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{33}
+}
+
+type Enum11541 int32
+
+const (
+	Enum11541_ENUM_VALUE11542 Enum11541 = -1
+	Enum11541_ENUM_VALUE11543 Enum11541 = 0
+	Enum11541_ENUM_VALUE11544 Enum11541 = 1
+	Enum11541_ENUM_VALUE11545 Enum11541 = 2
+	Enum11541_ENUM_VALUE11546 Enum11541 = 3
+	Enum11541_ENUM_VALUE11547 Enum11541 = 4
+	Enum11541_ENUM_VALUE11548 Enum11541 = 5
+	Enum11541_ENUM_VALUE11549 Enum11541 = 6
+	Enum11541_ENUM_VALUE11550 Enum11541 = 7
+	Enum11541_ENUM_VALUE11551 Enum11541 = 8
+	Enum11541_ENUM_VALUE11552 Enum11541 = 9
+	Enum11541_ENUM_VALUE11553 Enum11541 = 10
+	Enum11541_ENUM_VALUE11554 Enum11541 = 11
+	Enum11541_ENUM_VALUE11555 Enum11541 = 12
+	Enum11541_ENUM_VALUE11556 Enum11541 = 13
+	Enum11541_ENUM_VALUE11557 Enum11541 = 14
+	Enum11541_ENUM_VALUE11558 Enum11541 = 15
+	Enum11541_ENUM_VALUE11559 Enum11541 = 16
+	Enum11541_ENUM_VALUE11560 Enum11541 = 17
+	Enum11541_ENUM_VALUE11561 Enum11541 = 18
+	Enum11541_ENUM_VALUE11562 Enum11541 = 19
+	Enum11541_ENUM_VALUE11563 Enum11541 = 20
+	Enum11541_ENUM_VALUE11564 Enum11541 = 21
+	Enum11541_ENUM_VALUE11565 Enum11541 = 22
+	Enum11541_ENUM_VALUE11566 Enum11541 = 23
+	Enum11541_ENUM_VALUE11567 Enum11541 = 24
+	Enum11541_ENUM_VALUE11568 Enum11541 = 25
+	Enum11541_ENUM_VALUE11569 Enum11541 = 26
+	Enum11541_ENUM_VALUE11570 Enum11541 = 27
+	Enum11541_ENUM_VALUE11571 Enum11541 = 28
+	Enum11541_ENUM_VALUE11572 Enum11541 = 29
+	Enum11541_ENUM_VALUE11573 Enum11541 = 30
+	Enum11541_ENUM_VALUE11574 Enum11541 = 31
+	Enum11541_ENUM_VALUE11575 Enum11541 = 32
+	Enum11541_ENUM_VALUE11576 Enum11541 = 33
+	Enum11541_ENUM_VALUE11577 Enum11541 = 34
+	Enum11541_ENUM_VALUE11578 Enum11541 = 35
+	Enum11541_ENUM_VALUE11579 Enum11541 = 36
+	Enum11541_ENUM_VALUE11580 Enum11541 = 37
+	Enum11541_ENUM_VALUE11581 Enum11541 = 38
+	Enum11541_ENUM_VALUE11582 Enum11541 = 39
+	Enum11541_ENUM_VALUE11583 Enum11541 = 40
+	Enum11541_ENUM_VALUE11584 Enum11541 = 41
+	Enum11541_ENUM_VALUE11585 Enum11541 = 42
+	Enum11541_ENUM_VALUE11586 Enum11541 = 43
+	Enum11541_ENUM_VALUE11587 Enum11541 = 44
+	Enum11541_ENUM_VALUE11588 Enum11541 = 45
+	Enum11541_ENUM_VALUE11589 Enum11541 = 46
+	Enum11541_ENUM_VALUE11590 Enum11541 = 47
+	Enum11541_ENUM_VALUE11591 Enum11541 = 48
+	Enum11541_ENUM_VALUE11592 Enum11541 = 49
+	Enum11541_ENUM_VALUE11593 Enum11541 = 50
+	Enum11541_ENUM_VALUE11594 Enum11541 = 51
+	Enum11541_ENUM_VALUE11595 Enum11541 = 52
+	Enum11541_ENUM_VALUE11596 Enum11541 = 53
+	Enum11541_ENUM_VALUE11597 Enum11541 = 54
+	Enum11541_ENUM_VALUE11598 Enum11541 = 55
+	Enum11541_ENUM_VALUE11599 Enum11541 = 56
+	Enum11541_ENUM_VALUE11600 Enum11541 = 57
+	Enum11541_ENUM_VALUE11601 Enum11541 = 58
+	Enum11541_ENUM_VALUE11602 Enum11541 = 59
+	Enum11541_ENUM_VALUE11603 Enum11541 = 60
+	Enum11541_ENUM_VALUE11604 Enum11541 = 61
+	Enum11541_ENUM_VALUE11605 Enum11541 = 62
+	Enum11541_ENUM_VALUE11606 Enum11541 = 63
+	Enum11541_ENUM_VALUE11607 Enum11541 = 64
+	Enum11541_ENUM_VALUE11608 Enum11541 = 65
+	Enum11541_ENUM_VALUE11609 Enum11541 = 66
+	Enum11541_ENUM_VALUE11610 Enum11541 = 67
+	Enum11541_ENUM_VALUE11611 Enum11541 = 68
+	Enum11541_ENUM_VALUE11612 Enum11541 = 69
+	Enum11541_ENUM_VALUE11613 Enum11541 = 70
+	Enum11541_ENUM_VALUE11614 Enum11541 = 71
+	Enum11541_ENUM_VALUE11615 Enum11541 = 72
+	Enum11541_ENUM_VALUE11616 Enum11541 = 73
+	Enum11541_ENUM_VALUE11617 Enum11541 = 74
+	Enum11541_ENUM_VALUE11618 Enum11541 = 75
+	Enum11541_ENUM_VALUE11619 Enum11541 = 76
+	Enum11541_ENUM_VALUE11620 Enum11541 = 77
+	Enum11541_ENUM_VALUE11621 Enum11541 = 78
+	Enum11541_ENUM_VALUE11622 Enum11541 = 79
+	Enum11541_ENUM_VALUE11623 Enum11541 = 80
+	Enum11541_ENUM_VALUE11624 Enum11541 = 81
+	Enum11541_ENUM_VALUE11625 Enum11541 = 82
+	Enum11541_ENUM_VALUE11626 Enum11541 = 83
+	Enum11541_ENUM_VALUE11627 Enum11541 = 84
+	Enum11541_ENUM_VALUE11628 Enum11541 = 85
+	Enum11541_ENUM_VALUE11629 Enum11541 = 86
+	Enum11541_ENUM_VALUE11630 Enum11541 = 87
+	Enum11541_ENUM_VALUE11631 Enum11541 = 88
+	Enum11541_ENUM_VALUE11632 Enum11541 = 89
+	Enum11541_ENUM_VALUE11633 Enum11541 = 90
+	Enum11541_ENUM_VALUE11634 Enum11541 = 91
+	Enum11541_ENUM_VALUE11635 Enum11541 = 92
+	Enum11541_ENUM_VALUE11636 Enum11541 = 93
+	Enum11541_ENUM_VALUE11637 Enum11541 = 94
+	Enum11541_ENUM_VALUE11638 Enum11541 = 95
+	Enum11541_ENUM_VALUE11639 Enum11541 = 96
+	Enum11541_ENUM_VALUE11640 Enum11541 = 97
+	Enum11541_ENUM_VALUE11641 Enum11541 = 98
+	Enum11541_ENUM_VALUE11642 Enum11541 = 99
+	Enum11541_ENUM_VALUE11643 Enum11541 = 100
+	Enum11541_ENUM_VALUE11644 Enum11541 = 101
+	Enum11541_ENUM_VALUE11645 Enum11541 = 102
+	Enum11541_ENUM_VALUE11646 Enum11541 = 103
+	Enum11541_ENUM_VALUE11647 Enum11541 = 104
+	Enum11541_ENUM_VALUE11648 Enum11541 = 105
+	Enum11541_ENUM_VALUE11649 Enum11541 = 106
+	Enum11541_ENUM_VALUE11650 Enum11541 = 107
+	Enum11541_ENUM_VALUE11651 Enum11541 = 108
+	Enum11541_ENUM_VALUE11652 Enum11541 = 109
+	Enum11541_ENUM_VALUE11653 Enum11541 = 110
+	Enum11541_ENUM_VALUE11654 Enum11541 = 111
+	Enum11541_ENUM_VALUE11655 Enum11541 = 112
+	Enum11541_ENUM_VALUE11656 Enum11541 = 113
+	Enum11541_ENUM_VALUE11657 Enum11541 = 114
+	Enum11541_ENUM_VALUE11658 Enum11541 = 115
+	Enum11541_ENUM_VALUE11659 Enum11541 = 116
+	Enum11541_ENUM_VALUE11660 Enum11541 = 117
+	Enum11541_ENUM_VALUE11661 Enum11541 = 118
+	Enum11541_ENUM_VALUE11662 Enum11541 = 119
+	Enum11541_ENUM_VALUE11663 Enum11541 = 120
+	Enum11541_ENUM_VALUE11664 Enum11541 = 121
+	Enum11541_ENUM_VALUE11665 Enum11541 = 122
+	Enum11541_ENUM_VALUE11666 Enum11541 = 123
+	Enum11541_ENUM_VALUE11667 Enum11541 = 124
+	Enum11541_ENUM_VALUE11668 Enum11541 = 125
+	Enum11541_ENUM_VALUE11669 Enum11541 = 126
+	Enum11541_ENUM_VALUE11670 Enum11541 = 127
+	Enum11541_ENUM_VALUE11671 Enum11541 = 128
+	Enum11541_ENUM_VALUE11672 Enum11541 = 129
+	Enum11541_ENUM_VALUE11673 Enum11541 = 130
+	Enum11541_ENUM_VALUE11674 Enum11541 = 131
+	Enum11541_ENUM_VALUE11675 Enum11541 = 132
+	Enum11541_ENUM_VALUE11676 Enum11541 = 133
+	Enum11541_ENUM_VALUE11677 Enum11541 = 134
+	Enum11541_ENUM_VALUE11678 Enum11541 = 135
+	Enum11541_ENUM_VALUE11679 Enum11541 = 136
+	Enum11541_ENUM_VALUE11680 Enum11541 = 137
+	Enum11541_ENUM_VALUE11681 Enum11541 = 138
+	Enum11541_ENUM_VALUE11682 Enum11541 = 139
+	Enum11541_ENUM_VALUE11683 Enum11541 = 140
+	Enum11541_ENUM_VALUE11684 Enum11541 = 141
+	Enum11541_ENUM_VALUE11685 Enum11541 = 142
+	Enum11541_ENUM_VALUE11686 Enum11541 = 143
+	Enum11541_ENUM_VALUE11687 Enum11541 = 144
+	Enum11541_ENUM_VALUE11688 Enum11541 = 145
+	Enum11541_ENUM_VALUE11689 Enum11541 = 146
+	Enum11541_ENUM_VALUE11690 Enum11541 = 147
+	Enum11541_ENUM_VALUE11691 Enum11541 = 148
+	Enum11541_ENUM_VALUE11692 Enum11541 = 149
+	Enum11541_ENUM_VALUE11693 Enum11541 = 150
+	Enum11541_ENUM_VALUE11694 Enum11541 = 151
+	Enum11541_ENUM_VALUE11695 Enum11541 = 152
+	Enum11541_ENUM_VALUE11696 Enum11541 = 153
+	Enum11541_ENUM_VALUE11697 Enum11541 = 154
+	Enum11541_ENUM_VALUE11698 Enum11541 = 155
+	Enum11541_ENUM_VALUE11699 Enum11541 = 156
+	Enum11541_ENUM_VALUE11700 Enum11541 = 157
+	Enum11541_ENUM_VALUE11701 Enum11541 = 158
+	Enum11541_ENUM_VALUE11702 Enum11541 = 159
+	Enum11541_ENUM_VALUE11703 Enum11541 = 160
+	Enum11541_ENUM_VALUE11704 Enum11541 = 161
+	Enum11541_ENUM_VALUE11705 Enum11541 = 162
+	Enum11541_ENUM_VALUE11706 Enum11541 = 163
+	Enum11541_ENUM_VALUE11707 Enum11541 = 164
+	Enum11541_ENUM_VALUE11708 Enum11541 = 165
+	Enum11541_ENUM_VALUE11709 Enum11541 = 166
+	Enum11541_ENUM_VALUE11710 Enum11541 = 167
+	Enum11541_ENUM_VALUE11711 Enum11541 = 168
+	Enum11541_ENUM_VALUE11712 Enum11541 = 169
+	Enum11541_ENUM_VALUE11713 Enum11541 = 170
+	Enum11541_ENUM_VALUE11714 Enum11541 = 171
+	Enum11541_ENUM_VALUE11715 Enum11541 = 172
+	Enum11541_ENUM_VALUE11716 Enum11541 = 173
+	Enum11541_ENUM_VALUE11717 Enum11541 = 174
+	Enum11541_ENUM_VALUE11718 Enum11541 = 175
+	Enum11541_ENUM_VALUE11719 Enum11541 = 176
+	Enum11541_ENUM_VALUE11720 Enum11541 = 177
+	Enum11541_ENUM_VALUE11721 Enum11541 = 178
+	Enum11541_ENUM_VALUE11722 Enum11541 = 179
+	Enum11541_ENUM_VALUE11723 Enum11541 = 180
+	Enum11541_ENUM_VALUE11724 Enum11541 = 181
+	Enum11541_ENUM_VALUE11725 Enum11541 = 182
+	Enum11541_ENUM_VALUE11726 Enum11541 = 183
+	Enum11541_ENUM_VALUE11727 Enum11541 = 184
+	Enum11541_ENUM_VALUE11728 Enum11541 = 185
+	Enum11541_ENUM_VALUE11729 Enum11541 = 186
+	Enum11541_ENUM_VALUE11730 Enum11541 = 187
+	Enum11541_ENUM_VALUE11731 Enum11541 = 188
+	Enum11541_ENUM_VALUE11732 Enum11541 = 16777215
+)
+
+// Enum value maps for Enum11541.
+var (
+	Enum11541_name = map[int32]string{
+		-1:       "ENUM_VALUE11542",
+		0:        "ENUM_VALUE11543",
+		1:        "ENUM_VALUE11544",
+		2:        "ENUM_VALUE11545",
+		3:        "ENUM_VALUE11546",
+		4:        "ENUM_VALUE11547",
+		5:        "ENUM_VALUE11548",
+		6:        "ENUM_VALUE11549",
+		7:        "ENUM_VALUE11550",
+		8:        "ENUM_VALUE11551",
+		9:        "ENUM_VALUE11552",
+		10:       "ENUM_VALUE11553",
+		11:       "ENUM_VALUE11554",
+		12:       "ENUM_VALUE11555",
+		13:       "ENUM_VALUE11556",
+		14:       "ENUM_VALUE11557",
+		15:       "ENUM_VALUE11558",
+		16:       "ENUM_VALUE11559",
+		17:       "ENUM_VALUE11560",
+		18:       "ENUM_VALUE11561",
+		19:       "ENUM_VALUE11562",
+		20:       "ENUM_VALUE11563",
+		21:       "ENUM_VALUE11564",
+		22:       "ENUM_VALUE11565",
+		23:       "ENUM_VALUE11566",
+		24:       "ENUM_VALUE11567",
+		25:       "ENUM_VALUE11568",
+		26:       "ENUM_VALUE11569",
+		27:       "ENUM_VALUE11570",
+		28:       "ENUM_VALUE11571",
+		29:       "ENUM_VALUE11572",
+		30:       "ENUM_VALUE11573",
+		31:       "ENUM_VALUE11574",
+		32:       "ENUM_VALUE11575",
+		33:       "ENUM_VALUE11576",
+		34:       "ENUM_VALUE11577",
+		35:       "ENUM_VALUE11578",
+		36:       "ENUM_VALUE11579",
+		37:       "ENUM_VALUE11580",
+		38:       "ENUM_VALUE11581",
+		39:       "ENUM_VALUE11582",
+		40:       "ENUM_VALUE11583",
+		41:       "ENUM_VALUE11584",
+		42:       "ENUM_VALUE11585",
+		43:       "ENUM_VALUE11586",
+		44:       "ENUM_VALUE11587",
+		45:       "ENUM_VALUE11588",
+		46:       "ENUM_VALUE11589",
+		47:       "ENUM_VALUE11590",
+		48:       "ENUM_VALUE11591",
+		49:       "ENUM_VALUE11592",
+		50:       "ENUM_VALUE11593",
+		51:       "ENUM_VALUE11594",
+		52:       "ENUM_VALUE11595",
+		53:       "ENUM_VALUE11596",
+		54:       "ENUM_VALUE11597",
+		55:       "ENUM_VALUE11598",
+		56:       "ENUM_VALUE11599",
+		57:       "ENUM_VALUE11600",
+		58:       "ENUM_VALUE11601",
+		59:       "ENUM_VALUE11602",
+		60:       "ENUM_VALUE11603",
+		61:       "ENUM_VALUE11604",
+		62:       "ENUM_VALUE11605",
+		63:       "ENUM_VALUE11606",
+		64:       "ENUM_VALUE11607",
+		65:       "ENUM_VALUE11608",
+		66:       "ENUM_VALUE11609",
+		67:       "ENUM_VALUE11610",
+		68:       "ENUM_VALUE11611",
+		69:       "ENUM_VALUE11612",
+		70:       "ENUM_VALUE11613",
+		71:       "ENUM_VALUE11614",
+		72:       "ENUM_VALUE11615",
+		73:       "ENUM_VALUE11616",
+		74:       "ENUM_VALUE11617",
+		75:       "ENUM_VALUE11618",
+		76:       "ENUM_VALUE11619",
+		77:       "ENUM_VALUE11620",
+		78:       "ENUM_VALUE11621",
+		79:       "ENUM_VALUE11622",
+		80:       "ENUM_VALUE11623",
+		81:       "ENUM_VALUE11624",
+		82:       "ENUM_VALUE11625",
+		83:       "ENUM_VALUE11626",
+		84:       "ENUM_VALUE11627",
+		85:       "ENUM_VALUE11628",
+		86:       "ENUM_VALUE11629",
+		87:       "ENUM_VALUE11630",
+		88:       "ENUM_VALUE11631",
+		89:       "ENUM_VALUE11632",
+		90:       "ENUM_VALUE11633",
+		91:       "ENUM_VALUE11634",
+		92:       "ENUM_VALUE11635",
+		93:       "ENUM_VALUE11636",
+		94:       "ENUM_VALUE11637",
+		95:       "ENUM_VALUE11638",
+		96:       "ENUM_VALUE11639",
+		97:       "ENUM_VALUE11640",
+		98:       "ENUM_VALUE11641",
+		99:       "ENUM_VALUE11642",
+		100:      "ENUM_VALUE11643",
+		101:      "ENUM_VALUE11644",
+		102:      "ENUM_VALUE11645",
+		103:      "ENUM_VALUE11646",
+		104:      "ENUM_VALUE11647",
+		105:      "ENUM_VALUE11648",
+		106:      "ENUM_VALUE11649",
+		107:      "ENUM_VALUE11650",
+		108:      "ENUM_VALUE11651",
+		109:      "ENUM_VALUE11652",
+		110:      "ENUM_VALUE11653",
+		111:      "ENUM_VALUE11654",
+		112:      "ENUM_VALUE11655",
+		113:      "ENUM_VALUE11656",
+		114:      "ENUM_VALUE11657",
+		115:      "ENUM_VALUE11658",
+		116:      "ENUM_VALUE11659",
+		117:      "ENUM_VALUE11660",
+		118:      "ENUM_VALUE11661",
+		119:      "ENUM_VALUE11662",
+		120:      "ENUM_VALUE11663",
+		121:      "ENUM_VALUE11664",
+		122:      "ENUM_VALUE11665",
+		123:      "ENUM_VALUE11666",
+		124:      "ENUM_VALUE11667",
+		125:      "ENUM_VALUE11668",
+		126:      "ENUM_VALUE11669",
+		127:      "ENUM_VALUE11670",
+		128:      "ENUM_VALUE11671",
+		129:      "ENUM_VALUE11672",
+		130:      "ENUM_VALUE11673",
+		131:      "ENUM_VALUE11674",
+		132:      "ENUM_VALUE11675",
+		133:      "ENUM_VALUE11676",
+		134:      "ENUM_VALUE11677",
+		135:      "ENUM_VALUE11678",
+		136:      "ENUM_VALUE11679",
+		137:      "ENUM_VALUE11680",
+		138:      "ENUM_VALUE11681",
+		139:      "ENUM_VALUE11682",
+		140:      "ENUM_VALUE11683",
+		141:      "ENUM_VALUE11684",
+		142:      "ENUM_VALUE11685",
+		143:      "ENUM_VALUE11686",
+		144:      "ENUM_VALUE11687",
+		145:      "ENUM_VALUE11688",
+		146:      "ENUM_VALUE11689",
+		147:      "ENUM_VALUE11690",
+		148:      "ENUM_VALUE11691",
+		149:      "ENUM_VALUE11692",
+		150:      "ENUM_VALUE11693",
+		151:      "ENUM_VALUE11694",
+		152:      "ENUM_VALUE11695",
+		153:      "ENUM_VALUE11696",
+		154:      "ENUM_VALUE11697",
+		155:      "ENUM_VALUE11698",
+		156:      "ENUM_VALUE11699",
+		157:      "ENUM_VALUE11700",
+		158:      "ENUM_VALUE11701",
+		159:      "ENUM_VALUE11702",
+		160:      "ENUM_VALUE11703",
+		161:      "ENUM_VALUE11704",
+		162:      "ENUM_VALUE11705",
+		163:      "ENUM_VALUE11706",
+		164:      "ENUM_VALUE11707",
+		165:      "ENUM_VALUE11708",
+		166:      "ENUM_VALUE11709",
+		167:      "ENUM_VALUE11710",
+		168:      "ENUM_VALUE11711",
+		169:      "ENUM_VALUE11712",
+		170:      "ENUM_VALUE11713",
+		171:      "ENUM_VALUE11714",
+		172:      "ENUM_VALUE11715",
+		173:      "ENUM_VALUE11716",
+		174:      "ENUM_VALUE11717",
+		175:      "ENUM_VALUE11718",
+		176:      "ENUM_VALUE11719",
+		177:      "ENUM_VALUE11720",
+		178:      "ENUM_VALUE11721",
+		179:      "ENUM_VALUE11722",
+		180:      "ENUM_VALUE11723",
+		181:      "ENUM_VALUE11724",
+		182:      "ENUM_VALUE11725",
+		183:      "ENUM_VALUE11726",
+		184:      "ENUM_VALUE11727",
+		185:      "ENUM_VALUE11728",
+		186:      "ENUM_VALUE11729",
+		187:      "ENUM_VALUE11730",
+		188:      "ENUM_VALUE11731",
+		16777215: "ENUM_VALUE11732",
+	}
+	Enum11541_value = map[string]int32{
+		"ENUM_VALUE11542": -1,
+		"ENUM_VALUE11543": 0,
+		"ENUM_VALUE11544": 1,
+		"ENUM_VALUE11545": 2,
+		"ENUM_VALUE11546": 3,
+		"ENUM_VALUE11547": 4,
+		"ENUM_VALUE11548": 5,
+		"ENUM_VALUE11549": 6,
+		"ENUM_VALUE11550": 7,
+		"ENUM_VALUE11551": 8,
+		"ENUM_VALUE11552": 9,
+		"ENUM_VALUE11553": 10,
+		"ENUM_VALUE11554": 11,
+		"ENUM_VALUE11555": 12,
+		"ENUM_VALUE11556": 13,
+		"ENUM_VALUE11557": 14,
+		"ENUM_VALUE11558": 15,
+		"ENUM_VALUE11559": 16,
+		"ENUM_VALUE11560": 17,
+		"ENUM_VALUE11561": 18,
+		"ENUM_VALUE11562": 19,
+		"ENUM_VALUE11563": 20,
+		"ENUM_VALUE11564": 21,
+		"ENUM_VALUE11565": 22,
+		"ENUM_VALUE11566": 23,
+		"ENUM_VALUE11567": 24,
+		"ENUM_VALUE11568": 25,
+		"ENUM_VALUE11569": 26,
+		"ENUM_VALUE11570": 27,
+		"ENUM_VALUE11571": 28,
+		"ENUM_VALUE11572": 29,
+		"ENUM_VALUE11573": 30,
+		"ENUM_VALUE11574": 31,
+		"ENUM_VALUE11575": 32,
+		"ENUM_VALUE11576": 33,
+		"ENUM_VALUE11577": 34,
+		"ENUM_VALUE11578": 35,
+		"ENUM_VALUE11579": 36,
+		"ENUM_VALUE11580": 37,
+		"ENUM_VALUE11581": 38,
+		"ENUM_VALUE11582": 39,
+		"ENUM_VALUE11583": 40,
+		"ENUM_VALUE11584": 41,
+		"ENUM_VALUE11585": 42,
+		"ENUM_VALUE11586": 43,
+		"ENUM_VALUE11587": 44,
+		"ENUM_VALUE11588": 45,
+		"ENUM_VALUE11589": 46,
+		"ENUM_VALUE11590": 47,
+		"ENUM_VALUE11591": 48,
+		"ENUM_VALUE11592": 49,
+		"ENUM_VALUE11593": 50,
+		"ENUM_VALUE11594": 51,
+		"ENUM_VALUE11595": 52,
+		"ENUM_VALUE11596": 53,
+		"ENUM_VALUE11597": 54,
+		"ENUM_VALUE11598": 55,
+		"ENUM_VALUE11599": 56,
+		"ENUM_VALUE11600": 57,
+		"ENUM_VALUE11601": 58,
+		"ENUM_VALUE11602": 59,
+		"ENUM_VALUE11603": 60,
+		"ENUM_VALUE11604": 61,
+		"ENUM_VALUE11605": 62,
+		"ENUM_VALUE11606": 63,
+		"ENUM_VALUE11607": 64,
+		"ENUM_VALUE11608": 65,
+		"ENUM_VALUE11609": 66,
+		"ENUM_VALUE11610": 67,
+		"ENUM_VALUE11611": 68,
+		"ENUM_VALUE11612": 69,
+		"ENUM_VALUE11613": 70,
+		"ENUM_VALUE11614": 71,
+		"ENUM_VALUE11615": 72,
+		"ENUM_VALUE11616": 73,
+		"ENUM_VALUE11617": 74,
+		"ENUM_VALUE11618": 75,
+		"ENUM_VALUE11619": 76,
+		"ENUM_VALUE11620": 77,
+		"ENUM_VALUE11621": 78,
+		"ENUM_VALUE11622": 79,
+		"ENUM_VALUE11623": 80,
+		"ENUM_VALUE11624": 81,
+		"ENUM_VALUE11625": 82,
+		"ENUM_VALUE11626": 83,
+		"ENUM_VALUE11627": 84,
+		"ENUM_VALUE11628": 85,
+		"ENUM_VALUE11629": 86,
+		"ENUM_VALUE11630": 87,
+		"ENUM_VALUE11631": 88,
+		"ENUM_VALUE11632": 89,
+		"ENUM_VALUE11633": 90,
+		"ENUM_VALUE11634": 91,
+		"ENUM_VALUE11635": 92,
+		"ENUM_VALUE11636": 93,
+		"ENUM_VALUE11637": 94,
+		"ENUM_VALUE11638": 95,
+		"ENUM_VALUE11639": 96,
+		"ENUM_VALUE11640": 97,
+		"ENUM_VALUE11641": 98,
+		"ENUM_VALUE11642": 99,
+		"ENUM_VALUE11643": 100,
+		"ENUM_VALUE11644": 101,
+		"ENUM_VALUE11645": 102,
+		"ENUM_VALUE11646": 103,
+		"ENUM_VALUE11647": 104,
+		"ENUM_VALUE11648": 105,
+		"ENUM_VALUE11649": 106,
+		"ENUM_VALUE11650": 107,
+		"ENUM_VALUE11651": 108,
+		"ENUM_VALUE11652": 109,
+		"ENUM_VALUE11653": 110,
+		"ENUM_VALUE11654": 111,
+		"ENUM_VALUE11655": 112,
+		"ENUM_VALUE11656": 113,
+		"ENUM_VALUE11657": 114,
+		"ENUM_VALUE11658": 115,
+		"ENUM_VALUE11659": 116,
+		"ENUM_VALUE11660": 117,
+		"ENUM_VALUE11661": 118,
+		"ENUM_VALUE11662": 119,
+		"ENUM_VALUE11663": 120,
+		"ENUM_VALUE11664": 121,
+		"ENUM_VALUE11665": 122,
+		"ENUM_VALUE11666": 123,
+		"ENUM_VALUE11667": 124,
+		"ENUM_VALUE11668": 125,
+		"ENUM_VALUE11669": 126,
+		"ENUM_VALUE11670": 127,
+		"ENUM_VALUE11671": 128,
+		"ENUM_VALUE11672": 129,
+		"ENUM_VALUE11673": 130,
+		"ENUM_VALUE11674": 131,
+		"ENUM_VALUE11675": 132,
+		"ENUM_VALUE11676": 133,
+		"ENUM_VALUE11677": 134,
+		"ENUM_VALUE11678": 135,
+		"ENUM_VALUE11679": 136,
+		"ENUM_VALUE11680": 137,
+		"ENUM_VALUE11681": 138,
+		"ENUM_VALUE11682": 139,
+		"ENUM_VALUE11683": 140,
+		"ENUM_VALUE11684": 141,
+		"ENUM_VALUE11685": 142,
+		"ENUM_VALUE11686": 143,
+		"ENUM_VALUE11687": 144,
+		"ENUM_VALUE11688": 145,
+		"ENUM_VALUE11689": 146,
+		"ENUM_VALUE11690": 147,
+		"ENUM_VALUE11691": 148,
+		"ENUM_VALUE11692": 149,
+		"ENUM_VALUE11693": 150,
+		"ENUM_VALUE11694": 151,
+		"ENUM_VALUE11695": 152,
+		"ENUM_VALUE11696": 153,
+		"ENUM_VALUE11697": 154,
+		"ENUM_VALUE11698": 155,
+		"ENUM_VALUE11699": 156,
+		"ENUM_VALUE11700": 157,
+		"ENUM_VALUE11701": 158,
+		"ENUM_VALUE11702": 159,
+		"ENUM_VALUE11703": 160,
+		"ENUM_VALUE11704": 161,
+		"ENUM_VALUE11705": 162,
+		"ENUM_VALUE11706": 163,
+		"ENUM_VALUE11707": 164,
+		"ENUM_VALUE11708": 165,
+		"ENUM_VALUE11709": 166,
+		"ENUM_VALUE11710": 167,
+		"ENUM_VALUE11711": 168,
+		"ENUM_VALUE11712": 169,
+		"ENUM_VALUE11713": 170,
+		"ENUM_VALUE11714": 171,
+		"ENUM_VALUE11715": 172,
+		"ENUM_VALUE11716": 173,
+		"ENUM_VALUE11717": 174,
+		"ENUM_VALUE11718": 175,
+		"ENUM_VALUE11719": 176,
+		"ENUM_VALUE11720": 177,
+		"ENUM_VALUE11721": 178,
+		"ENUM_VALUE11722": 179,
+		"ENUM_VALUE11723": 180,
+		"ENUM_VALUE11724": 181,
+		"ENUM_VALUE11725": 182,
+		"ENUM_VALUE11726": 183,
+		"ENUM_VALUE11727": 184,
+		"ENUM_VALUE11728": 185,
+		"ENUM_VALUE11729": 186,
+		"ENUM_VALUE11730": 187,
+		"ENUM_VALUE11731": 188,
+		"ENUM_VALUE11732": 16777215,
+	}
+)
+
+func (x Enum11541) Enum() *Enum11541 {
+	p := new(Enum11541)
+	*p = x
+	return p
+}
+
+func (x Enum11541) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum11541) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[34].Descriptor()
+}
+
+func (Enum11541) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[34]
+}
+
+func (x Enum11541) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum11541) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum11541(num)
+	return nil
+}
+
+// Deprecated: Use Enum11541.Descriptor instead.
+func (Enum11541) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{34}
+}
+
+type Enum11468 int32
+
+const (
+	Enum11468_ENUM_VALUE11469 Enum11468 = -99
+	Enum11468_ENUM_VALUE11470 Enum11468 = 0
+	Enum11468_ENUM_VALUE11471 Enum11468 = 1
+	Enum11468_ENUM_VALUE11472 Enum11468 = 2
+	Enum11468_ENUM_VALUE11473 Enum11468 = 3
+	Enum11468_ENUM_VALUE11474 Enum11468 = 4
+	Enum11468_ENUM_VALUE11475 Enum11468 = 28
+	Enum11468_ENUM_VALUE11476 Enum11468 = 22
+	Enum11468_ENUM_VALUE11477 Enum11468 = 38
+	Enum11468_ENUM_VALUE11478 Enum11468 = 512
+	Enum11468_ENUM_VALUE11479 Enum11468 = 2048
+	Enum11468_ENUM_VALUE11480 Enum11468 = 66
+	Enum11468_ENUM_VALUE11481 Enum11468 = 578
+	Enum11468_ENUM_VALUE11482 Enum11468 = 77
+	Enum11468_ENUM_VALUE11483 Enum11468 = 88
+	Enum11468_ENUM_VALUE11484 Enum11468 = 100
+	Enum11468_ENUM_VALUE11485 Enum11468 = 110
+	Enum11468_ENUM_VALUE11486 Enum11468 = 2158
+	Enum11468_ENUM_VALUE11487 Enum11468 = 122
+	Enum11468_ENUM_VALUE11488 Enum11468 = 2170
+	Enum11468_ENUM_VALUE11489 Enum11468 = 144
+	Enum11468_ENUM_VALUE11490 Enum11468 = 244
+	Enum11468_ENUM_VALUE11491 Enum11468 = 2292
+	Enum11468_ENUM_VALUE11492 Enum11468 = 44
+)
+
+// Enum value maps for Enum11468.
+var (
+	Enum11468_name = map[int32]string{
+		-99:  "ENUM_VALUE11469",
+		0:    "ENUM_VALUE11470",
+		1:    "ENUM_VALUE11471",
+		2:    "ENUM_VALUE11472",
+		3:    "ENUM_VALUE11473",
+		4:    "ENUM_VALUE11474",
+		28:   "ENUM_VALUE11475",
+		22:   "ENUM_VALUE11476",
+		38:   "ENUM_VALUE11477",
+		512:  "ENUM_VALUE11478",
+		2048: "ENUM_VALUE11479",
+		66:   "ENUM_VALUE11480",
+		578:  "ENUM_VALUE11481",
+		77:   "ENUM_VALUE11482",
+		88:   "ENUM_VALUE11483",
+		100:  "ENUM_VALUE11484",
+		110:  "ENUM_VALUE11485",
+		2158: "ENUM_VALUE11486",
+		122:  "ENUM_VALUE11487",
+		2170: "ENUM_VALUE11488",
+		144:  "ENUM_VALUE11489",
+		244:  "ENUM_VALUE11490",
+		2292: "ENUM_VALUE11491",
+		44:   "ENUM_VALUE11492",
+	}
+	Enum11468_value = map[string]int32{
+		"ENUM_VALUE11469": -99,
+		"ENUM_VALUE11470": 0,
+		"ENUM_VALUE11471": 1,
+		"ENUM_VALUE11472": 2,
+		"ENUM_VALUE11473": 3,
+		"ENUM_VALUE11474": 4,
+		"ENUM_VALUE11475": 28,
+		"ENUM_VALUE11476": 22,
+		"ENUM_VALUE11477": 38,
+		"ENUM_VALUE11478": 512,
+		"ENUM_VALUE11479": 2048,
+		"ENUM_VALUE11480": 66,
+		"ENUM_VALUE11481": 578,
+		"ENUM_VALUE11482": 77,
+		"ENUM_VALUE11483": 88,
+		"ENUM_VALUE11484": 100,
+		"ENUM_VALUE11485": 110,
+		"ENUM_VALUE11486": 2158,
+		"ENUM_VALUE11487": 122,
+		"ENUM_VALUE11488": 2170,
+		"ENUM_VALUE11489": 144,
+		"ENUM_VALUE11490": 244,
+		"ENUM_VALUE11491": 2292,
+		"ENUM_VALUE11492": 44,
+	}
+)
+
+func (x Enum11468) Enum() *Enum11468 {
+	p := new(Enum11468)
+	*p = x
+	return p
+}
+
+func (x Enum11468) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum11468) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[35].Descriptor()
+}
+
+func (Enum11468) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[35]
+}
+
+func (x Enum11468) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum11468) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum11468(num)
+	return nil
+}
+
+// Deprecated: Use Enum11468.Descriptor instead.
+func (Enum11468) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{35}
+}
+
+type Enum11022 int32
+
+const (
+	Enum11022_ENUM_VALUE11023 Enum11022 = 0
+	Enum11022_ENUM_VALUE11024 Enum11022 = 1
+	Enum11022_ENUM_VALUE11025 Enum11022 = 2
+	Enum11022_ENUM_VALUE11026 Enum11022 = 3
+	Enum11022_ENUM_VALUE11027 Enum11022 = 4
+	Enum11022_ENUM_VALUE11028 Enum11022 = 5
+	Enum11022_ENUM_VALUE11029 Enum11022 = 6
+	Enum11022_ENUM_VALUE11030 Enum11022 = 7
+	Enum11022_ENUM_VALUE11031 Enum11022 = 8
+	Enum11022_ENUM_VALUE11032 Enum11022 = 9
+	Enum11022_ENUM_VALUE11033 Enum11022 = 10
+	Enum11022_ENUM_VALUE11034 Enum11022 = 11
+	Enum11022_ENUM_VALUE11035 Enum11022 = 12
+	Enum11022_ENUM_VALUE11036 Enum11022 = 13
+	Enum11022_ENUM_VALUE11037 Enum11022 = 14
+	Enum11022_ENUM_VALUE11038 Enum11022 = 15
+	Enum11022_ENUM_VALUE11039 Enum11022 = 16
+	Enum11022_ENUM_VALUE11040 Enum11022 = 17
+	Enum11022_ENUM_VALUE11041 Enum11022 = 18
+	Enum11022_ENUM_VALUE11042 Enum11022 = 19
+	Enum11022_ENUM_VALUE11043 Enum11022 = 20
+	Enum11022_ENUM_VALUE11044 Enum11022 = 21
+	Enum11022_ENUM_VALUE11045 Enum11022 = 22
+	Enum11022_ENUM_VALUE11046 Enum11022 = 23
+	Enum11022_ENUM_VALUE11047 Enum11022 = 24
+	Enum11022_ENUM_VALUE11048 Enum11022 = 25
+	Enum11022_ENUM_VALUE11049 Enum11022 = 26
+	Enum11022_ENUM_VALUE11050 Enum11022 = 27
+	Enum11022_ENUM_VALUE11051 Enum11022 = 28
+	Enum11022_ENUM_VALUE11052 Enum11022 = 29
+	Enum11022_ENUM_VALUE11053 Enum11022 = 30
+	Enum11022_ENUM_VALUE11054 Enum11022 = 31
+	Enum11022_ENUM_VALUE11055 Enum11022 = 32
+	Enum11022_ENUM_VALUE11056 Enum11022 = 33
+	Enum11022_ENUM_VALUE11057 Enum11022 = 34
+	Enum11022_ENUM_VALUE11058 Enum11022 = 35
+	Enum11022_ENUM_VALUE11059 Enum11022 = 36
+	Enum11022_ENUM_VALUE11060 Enum11022 = 37
+	Enum11022_ENUM_VALUE11061 Enum11022 = 38
+	Enum11022_ENUM_VALUE11062 Enum11022 = 39
+	Enum11022_ENUM_VALUE11063 Enum11022 = 40
+	Enum11022_ENUM_VALUE11064 Enum11022 = 41
+	Enum11022_ENUM_VALUE11065 Enum11022 = 42
+	Enum11022_ENUM_VALUE11066 Enum11022 = 43
+	Enum11022_ENUM_VALUE11067 Enum11022 = 44
+	Enum11022_ENUM_VALUE11068 Enum11022 = 45
+	Enum11022_ENUM_VALUE11069 Enum11022 = 46
+	Enum11022_ENUM_VALUE11070 Enum11022 = 47
+	Enum11022_ENUM_VALUE11071 Enum11022 = 48
+	Enum11022_ENUM_VALUE11072 Enum11022 = 49
+	Enum11022_ENUM_VALUE11073 Enum11022 = 50
+	Enum11022_ENUM_VALUE11074 Enum11022 = 51
+	Enum11022_ENUM_VALUE11075 Enum11022 = 52
+	Enum11022_ENUM_VALUE11076 Enum11022 = 53
+	Enum11022_ENUM_VALUE11077 Enum11022 = 54
+	Enum11022_ENUM_VALUE11078 Enum11022 = 55
+	Enum11022_ENUM_VALUE11079 Enum11022 = 56
+	Enum11022_ENUM_VALUE11080 Enum11022 = 57
+	Enum11022_ENUM_VALUE11081 Enum11022 = 58
+	Enum11022_ENUM_VALUE11082 Enum11022 = 59
+	Enum11022_ENUM_VALUE11083 Enum11022 = 60
+	Enum11022_ENUM_VALUE11084 Enum11022 = 61
+	Enum11022_ENUM_VALUE11085 Enum11022 = 62
+	Enum11022_ENUM_VALUE11086 Enum11022 = 63
+	Enum11022_ENUM_VALUE11087 Enum11022 = 64
+	Enum11022_ENUM_VALUE11088 Enum11022 = 65
+	Enum11022_ENUM_VALUE11089 Enum11022 = 66
+	Enum11022_ENUM_VALUE11090 Enum11022 = 67
+	Enum11022_ENUM_VALUE11091 Enum11022 = 68
+	Enum11022_ENUM_VALUE11092 Enum11022 = 69
+	Enum11022_ENUM_VALUE11093 Enum11022 = 70
+	Enum11022_ENUM_VALUE11094 Enum11022 = 71
+	Enum11022_ENUM_VALUE11095 Enum11022 = 72
+	Enum11022_ENUM_VALUE11096 Enum11022 = 73
+	Enum11022_ENUM_VALUE11097 Enum11022 = 74
+	Enum11022_ENUM_VALUE11098 Enum11022 = 75
+	Enum11022_ENUM_VALUE11099 Enum11022 = 76
+	Enum11022_ENUM_VALUE11100 Enum11022 = 77
+	Enum11022_ENUM_VALUE11101 Enum11022 = 78
+	Enum11022_ENUM_VALUE11102 Enum11022 = 79
+	Enum11022_ENUM_VALUE11103 Enum11022 = 80
+	Enum11022_ENUM_VALUE11104 Enum11022 = 81
+	Enum11022_ENUM_VALUE11105 Enum11022 = 82
+	Enum11022_ENUM_VALUE11106 Enum11022 = 83
+)
+
+// Enum value maps for Enum11022.
+var (
+	Enum11022_name = map[int32]string{
+		0:  "ENUM_VALUE11023",
+		1:  "ENUM_VALUE11024",
+		2:  "ENUM_VALUE11025",
+		3:  "ENUM_VALUE11026",
+		4:  "ENUM_VALUE11027",
+		5:  "ENUM_VALUE11028",
+		6:  "ENUM_VALUE11029",
+		7:  "ENUM_VALUE11030",
+		8:  "ENUM_VALUE11031",
+		9:  "ENUM_VALUE11032",
+		10: "ENUM_VALUE11033",
+		11: "ENUM_VALUE11034",
+		12: "ENUM_VALUE11035",
+		13: "ENUM_VALUE11036",
+		14: "ENUM_VALUE11037",
+		15: "ENUM_VALUE11038",
+		16: "ENUM_VALUE11039",
+		17: "ENUM_VALUE11040",
+		18: "ENUM_VALUE11041",
+		19: "ENUM_VALUE11042",
+		20: "ENUM_VALUE11043",
+		21: "ENUM_VALUE11044",
+		22: "ENUM_VALUE11045",
+		23: "ENUM_VALUE11046",
+		24: "ENUM_VALUE11047",
+		25: "ENUM_VALUE11048",
+		26: "ENUM_VALUE11049",
+		27: "ENUM_VALUE11050",
+		28: "ENUM_VALUE11051",
+		29: "ENUM_VALUE11052",
+		30: "ENUM_VALUE11053",
+		31: "ENUM_VALUE11054",
+		32: "ENUM_VALUE11055",
+		33: "ENUM_VALUE11056",
+		34: "ENUM_VALUE11057",
+		35: "ENUM_VALUE11058",
+		36: "ENUM_VALUE11059",
+		37: "ENUM_VALUE11060",
+		38: "ENUM_VALUE11061",
+		39: "ENUM_VALUE11062",
+		40: "ENUM_VALUE11063",
+		41: "ENUM_VALUE11064",
+		42: "ENUM_VALUE11065",
+		43: "ENUM_VALUE11066",
+		44: "ENUM_VALUE11067",
+		45: "ENUM_VALUE11068",
+		46: "ENUM_VALUE11069",
+		47: "ENUM_VALUE11070",
+		48: "ENUM_VALUE11071",
+		49: "ENUM_VALUE11072",
+		50: "ENUM_VALUE11073",
+		51: "ENUM_VALUE11074",
+		52: "ENUM_VALUE11075",
+		53: "ENUM_VALUE11076",
+		54: "ENUM_VALUE11077",
+		55: "ENUM_VALUE11078",
+		56: "ENUM_VALUE11079",
+		57: "ENUM_VALUE11080",
+		58: "ENUM_VALUE11081",
+		59: "ENUM_VALUE11082",
+		60: "ENUM_VALUE11083",
+		61: "ENUM_VALUE11084",
+		62: "ENUM_VALUE11085",
+		63: "ENUM_VALUE11086",
+		64: "ENUM_VALUE11087",
+		65: "ENUM_VALUE11088",
+		66: "ENUM_VALUE11089",
+		67: "ENUM_VALUE11090",
+		68: "ENUM_VALUE11091",
+		69: "ENUM_VALUE11092",
+		70: "ENUM_VALUE11093",
+		71: "ENUM_VALUE11094",
+		72: "ENUM_VALUE11095",
+		73: "ENUM_VALUE11096",
+		74: "ENUM_VALUE11097",
+		75: "ENUM_VALUE11098",
+		76: "ENUM_VALUE11099",
+		77: "ENUM_VALUE11100",
+		78: "ENUM_VALUE11101",
+		79: "ENUM_VALUE11102",
+		80: "ENUM_VALUE11103",
+		81: "ENUM_VALUE11104",
+		82: "ENUM_VALUE11105",
+		83: "ENUM_VALUE11106",
+	}
+	Enum11022_value = map[string]int32{
+		"ENUM_VALUE11023": 0,
+		"ENUM_VALUE11024": 1,
+		"ENUM_VALUE11025": 2,
+		"ENUM_VALUE11026": 3,
+		"ENUM_VALUE11027": 4,
+		"ENUM_VALUE11028": 5,
+		"ENUM_VALUE11029": 6,
+		"ENUM_VALUE11030": 7,
+		"ENUM_VALUE11031": 8,
+		"ENUM_VALUE11032": 9,
+		"ENUM_VALUE11033": 10,
+		"ENUM_VALUE11034": 11,
+		"ENUM_VALUE11035": 12,
+		"ENUM_VALUE11036": 13,
+		"ENUM_VALUE11037": 14,
+		"ENUM_VALUE11038": 15,
+		"ENUM_VALUE11039": 16,
+		"ENUM_VALUE11040": 17,
+		"ENUM_VALUE11041": 18,
+		"ENUM_VALUE11042": 19,
+		"ENUM_VALUE11043": 20,
+		"ENUM_VALUE11044": 21,
+		"ENUM_VALUE11045": 22,
+		"ENUM_VALUE11046": 23,
+		"ENUM_VALUE11047": 24,
+		"ENUM_VALUE11048": 25,
+		"ENUM_VALUE11049": 26,
+		"ENUM_VALUE11050": 27,
+		"ENUM_VALUE11051": 28,
+		"ENUM_VALUE11052": 29,
+		"ENUM_VALUE11053": 30,
+		"ENUM_VALUE11054": 31,
+		"ENUM_VALUE11055": 32,
+		"ENUM_VALUE11056": 33,
+		"ENUM_VALUE11057": 34,
+		"ENUM_VALUE11058": 35,
+		"ENUM_VALUE11059": 36,
+		"ENUM_VALUE11060": 37,
+		"ENUM_VALUE11061": 38,
+		"ENUM_VALUE11062": 39,
+		"ENUM_VALUE11063": 40,
+		"ENUM_VALUE11064": 41,
+		"ENUM_VALUE11065": 42,
+		"ENUM_VALUE11066": 43,
+		"ENUM_VALUE11067": 44,
+		"ENUM_VALUE11068": 45,
+		"ENUM_VALUE11069": 46,
+		"ENUM_VALUE11070": 47,
+		"ENUM_VALUE11071": 48,
+		"ENUM_VALUE11072": 49,
+		"ENUM_VALUE11073": 50,
+		"ENUM_VALUE11074": 51,
+		"ENUM_VALUE11075": 52,
+		"ENUM_VALUE11076": 53,
+		"ENUM_VALUE11077": 54,
+		"ENUM_VALUE11078": 55,
+		"ENUM_VALUE11079": 56,
+		"ENUM_VALUE11080": 57,
+		"ENUM_VALUE11081": 58,
+		"ENUM_VALUE11082": 59,
+		"ENUM_VALUE11083": 60,
+		"ENUM_VALUE11084": 61,
+		"ENUM_VALUE11085": 62,
+		"ENUM_VALUE11086": 63,
+		"ENUM_VALUE11087": 64,
+		"ENUM_VALUE11088": 65,
+		"ENUM_VALUE11089": 66,
+		"ENUM_VALUE11090": 67,
+		"ENUM_VALUE11091": 68,
+		"ENUM_VALUE11092": 69,
+		"ENUM_VALUE11093": 70,
+		"ENUM_VALUE11094": 71,
+		"ENUM_VALUE11095": 72,
+		"ENUM_VALUE11096": 73,
+		"ENUM_VALUE11097": 74,
+		"ENUM_VALUE11098": 75,
+		"ENUM_VALUE11099": 76,
+		"ENUM_VALUE11100": 77,
+		"ENUM_VALUE11101": 78,
+		"ENUM_VALUE11102": 79,
+		"ENUM_VALUE11103": 80,
+		"ENUM_VALUE11104": 81,
+		"ENUM_VALUE11105": 82,
+		"ENUM_VALUE11106": 83,
+	}
+)
+
+func (x Enum11022) Enum() *Enum11022 {
+	p := new(Enum11022)
+	*p = x
+	return p
+}
+
+func (x Enum11022) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum11022) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[36].Descriptor()
+}
+
+func (Enum11022) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[36]
+}
+
+func (x Enum11022) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum11022) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum11022(num)
+	return nil
+}
+
+// Deprecated: Use Enum11022.Descriptor instead.
+func (Enum11022) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{36}
+}
+
+type Enum12670 int32
+
+const (
+	Enum12670_ENUM_VALUE12671 Enum12670 = 0
+	Enum12670_ENUM_VALUE12672 Enum12670 = 1
+	Enum12670_ENUM_VALUE12673 Enum12670 = 2
+)
+
+// Enum value maps for Enum12670.
+var (
+	Enum12670_name = map[int32]string{
+		0: "ENUM_VALUE12671",
+		1: "ENUM_VALUE12672",
+		2: "ENUM_VALUE12673",
+	}
+	Enum12670_value = map[string]int32{
+		"ENUM_VALUE12671": 0,
+		"ENUM_VALUE12672": 1,
+		"ENUM_VALUE12673": 2,
+	}
+)
+
+func (x Enum12670) Enum() *Enum12670 {
+	p := new(Enum12670)
+	*p = x
+	return p
+}
+
+func (x Enum12670) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum12670) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[37].Descriptor()
+}
+
+func (Enum12670) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[37]
+}
+
+func (x Enum12670) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum12670) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum12670(num)
+	return nil
+}
+
+// Deprecated: Use Enum12670.Descriptor instead.
+func (Enum12670) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{37}
+}
+
+type Enum12871 int32
+
+const (
+	Enum12871_ENUM_VALUE12872 Enum12871 = 1
+	Enum12871_ENUM_VALUE12873 Enum12871 = 2
+	Enum12871_ENUM_VALUE12874 Enum12871 = 3
+	Enum12871_ENUM_VALUE12875 Enum12871 = 4
+	Enum12871_ENUM_VALUE12876 Enum12871 = 5
+	Enum12871_ENUM_VALUE12877 Enum12871 = 6
+)
+
+// Enum value maps for Enum12871.
+var (
+	Enum12871_name = map[int32]string{
+		1: "ENUM_VALUE12872",
+		2: "ENUM_VALUE12873",
+		3: "ENUM_VALUE12874",
+		4: "ENUM_VALUE12875",
+		5: "ENUM_VALUE12876",
+		6: "ENUM_VALUE12877",
+	}
+	Enum12871_value = map[string]int32{
+		"ENUM_VALUE12872": 1,
+		"ENUM_VALUE12873": 2,
+		"ENUM_VALUE12874": 3,
+		"ENUM_VALUE12875": 4,
+		"ENUM_VALUE12876": 5,
+		"ENUM_VALUE12877": 6,
+	}
+)
+
+func (x Enum12871) Enum() *Enum12871 {
+	p := new(Enum12871)
+	*p = x
+	return p
+}
+
+func (x Enum12871) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum12871) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[38].Descriptor()
+}
+
+func (Enum12871) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[38]
+}
+
+func (x Enum12871) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum12871) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum12871(num)
+	return nil
+}
+
+// Deprecated: Use Enum12871.Descriptor instead.
+func (Enum12871) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{38}
+}
+
+type Enum13092 int32
+
+const (
+	Enum13092_ENUM_VALUE13093 Enum13092 = 1
+	Enum13092_ENUM_VALUE13094 Enum13092 = 2
+	Enum13092_ENUM_VALUE13095 Enum13092 = 3
+)
+
+// Enum value maps for Enum13092.
+var (
+	Enum13092_name = map[int32]string{
+		1: "ENUM_VALUE13093",
+		2: "ENUM_VALUE13094",
+		3: "ENUM_VALUE13095",
+	}
+	Enum13092_value = map[string]int32{
+		"ENUM_VALUE13093": 1,
+		"ENUM_VALUE13094": 2,
+		"ENUM_VALUE13095": 3,
+	}
+)
+
+func (x Enum13092) Enum() *Enum13092 {
+	p := new(Enum13092)
+	*p = x
+	return p
+}
+
+func (x Enum13092) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum13092) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[39].Descriptor()
+}
+
+func (Enum13092) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[39]
+}
+
+func (x Enum13092) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum13092) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum13092(num)
+	return nil
+}
+
+// Deprecated: Use Enum13092.Descriptor instead.
+func (Enum13092) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{39}
+}
+
+type Enum13146 int32
+
+const (
+	Enum13146_ENUM_VALUE13147 Enum13146 = 0
+	Enum13146_ENUM_VALUE13148 Enum13146 = 1
+	Enum13146_ENUM_VALUE13149 Enum13146 = 2
+	Enum13146_ENUM_VALUE13150 Enum13146 = 3
+)
+
+// Enum value maps for Enum13146.
+var (
+	Enum13146_name = map[int32]string{
+		0: "ENUM_VALUE13147",
+		1: "ENUM_VALUE13148",
+		2: "ENUM_VALUE13149",
+		3: "ENUM_VALUE13150",
+	}
+	Enum13146_value = map[string]int32{
+		"ENUM_VALUE13147": 0,
+		"ENUM_VALUE13148": 1,
+		"ENUM_VALUE13149": 2,
+		"ENUM_VALUE13150": 3,
+	}
+)
+
+func (x Enum13146) Enum() *Enum13146 {
+	p := new(Enum13146)
+	*p = x
+	return p
+}
+
+func (x Enum13146) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum13146) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[40].Descriptor()
+}
+
+func (Enum13146) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[40]
+}
+
+func (x Enum13146) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum13146) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum13146(num)
+	return nil
+}
+
+// Deprecated: Use Enum13146.Descriptor instead.
+func (Enum13146) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{40}
+}
+
+type Enum16042 int32
+
+const (
+	Enum16042_ENUM_VALUE16043 Enum16042 = 0
+	Enum16042_ENUM_VALUE16044 Enum16042 = 1
+	Enum16042_ENUM_VALUE16045 Enum16042 = 17
+	Enum16042_ENUM_VALUE16046 Enum16042 = 273
+	Enum16042_ENUM_VALUE16047 Enum16042 = 274
+	Enum16042_ENUM_VALUE16048 Enum16042 = 4385
+	Enum16042_ENUM_VALUE16049 Enum16042 = 4386
+	Enum16042_ENUM_VALUE16050 Enum16042 = 4387
+	Enum16042_ENUM_VALUE16051 Enum16042 = 4388
+	Enum16042_ENUM_VALUE16052 Enum16042 = 4389
+	Enum16042_ENUM_VALUE16053 Enum16042 = 4390
+	Enum16042_ENUM_VALUE16054 Enum16042 = 4391
+	Enum16042_ENUM_VALUE16055 Enum16042 = 4392
+	Enum16042_ENUM_VALUE16056 Enum16042 = 4393
+	Enum16042_ENUM_VALUE16057 Enum16042 = 276
+	Enum16042_ENUM_VALUE16058 Enum16042 = 277
+	Enum16042_ENUM_VALUE16059 Enum16042 = 18
+	Enum16042_ENUM_VALUE16060 Enum16042 = 289
+	Enum16042_ENUM_VALUE16061 Enum16042 = 291
+	Enum16042_ENUM_VALUE16062 Enum16042 = 4657
+	Enum16042_ENUM_VALUE16063 Enum16042 = 74513
+	Enum16042_ENUM_VALUE16064 Enum16042 = 4658
+	Enum16042_ENUM_VALUE16065 Enum16042 = 4659
+	Enum16042_ENUM_VALUE16066 Enum16042 = 4660
+	Enum16042_ENUM_VALUE16067 Enum16042 = 4661
+	Enum16042_ENUM_VALUE16068 Enum16042 = 4662
+	Enum16042_ENUM_VALUE16069 Enum16042 = 4663
+	Enum16042_ENUM_VALUE16070 Enum16042 = 4664
+	Enum16042_ENUM_VALUE16071 Enum16042 = 292
+	Enum16042_ENUM_VALUE16072 Enum16042 = 4673
+	Enum16042_ENUM_VALUE16073 Enum16042 = 4674
+	Enum16042_ENUM_VALUE16074 Enum16042 = 293
+	Enum16042_ENUM_VALUE16075 Enum16042 = 19
+	Enum16042_ENUM_VALUE16076 Enum16042 = 20
+	Enum16042_ENUM_VALUE16077 Enum16042 = 321
+	Enum16042_ENUM_VALUE16078 Enum16042 = 5137
+	Enum16042_ENUM_VALUE16079 Enum16042 = 5138
+	Enum16042_ENUM_VALUE16080 Enum16042 = 5139
+	Enum16042_ENUM_VALUE16081 Enum16042 = 5140
+	Enum16042_ENUM_VALUE16082 Enum16042 = 5141
+	Enum16042_ENUM_VALUE16083 Enum16042 = 5142
+	Enum16042_ENUM_VALUE16084 Enum16042 = 82273
+	Enum16042_ENUM_VALUE16085 Enum16042 = 82274
+	Enum16042_ENUM_VALUE16086 Enum16042 = 82275
+	Enum16042_ENUM_VALUE16087 Enum16042 = 82276
+	Enum16042_ENUM_VALUE16088 Enum16042 = 82277
+	Enum16042_ENUM_VALUE16089 Enum16042 = 82278
+	Enum16042_ENUM_VALUE16090 Enum16042 = 5143
+	Enum16042_ENUM_VALUE16091 Enum16042 = 5144
+	Enum16042_ENUM_VALUE16092 Enum16042 = 5145
+	Enum16042_ENUM_VALUE16093 Enum16042 = 5146
+	Enum16042_ENUM_VALUE16094 Enum16042 = 82337
+	Enum16042_ENUM_VALUE16095 Enum16042 = 5147
+	Enum16042_ENUM_VALUE16096 Enum16042 = 5148
+	Enum16042_ENUM_VALUE16097 Enum16042 = 322
+	Enum16042_ENUM_VALUE16098 Enum16042 = 323
+	Enum16042_ENUM_VALUE16099 Enum16042 = 324
+	Enum16042_ENUM_VALUE16100 Enum16042 = 325
+	Enum16042_ENUM_VALUE16101 Enum16042 = 326
+	Enum16042_ENUM_VALUE16102 Enum16042 = 327
+	Enum16042_ENUM_VALUE16103 Enum16042 = 328
+	Enum16042_ENUM_VALUE16104 Enum16042 = 21
+	Enum16042_ENUM_VALUE16105 Enum16042 = 337
+	Enum16042_ENUM_VALUE16106 Enum16042 = 22
+	Enum16042_ENUM_VALUE16107 Enum16042 = 23
+	Enum16042_ENUM_VALUE16108 Enum16042 = 24
+	Enum16042_ENUM_VALUE16109 Enum16042 = 2
+	Enum16042_ENUM_VALUE16110 Enum16042 = 33
+	Enum16042_ENUM_VALUE16111 Enum16042 = 34
+	Enum16042_ENUM_VALUE16112 Enum16042 = 545
+	Enum16042_ENUM_VALUE16113 Enum16042 = 8721
+	Enum16042_ENUM_VALUE16114 Enum16042 = 8723
+	Enum16042_ENUM_VALUE16115 Enum16042 = 8724
+	Enum16042_ENUM_VALUE16116 Enum16042 = 546
+	Enum16042_ENUM_VALUE16117 Enum16042 = 8739
+	Enum16042_ENUM_VALUE16118 Enum16042 = 8740
+	Enum16042_ENUM_VALUE16119 Enum16042 = 547
+	Enum16042_ENUM_VALUE16120 Enum16042 = 548
+	Enum16042_ENUM_VALUE16121 Enum16042 = 549
+	Enum16042_ENUM_VALUE16122 Enum16042 = 550
+	Enum16042_ENUM_VALUE16123 Enum16042 = 551
+	Enum16042_ENUM_VALUE16124 Enum16042 = 552
+	Enum16042_ENUM_VALUE16125 Enum16042 = 553
+	Enum16042_ENUM_VALUE16126 Enum16042 = 35
+	Enum16042_ENUM_VALUE16127 Enum16042 = 36
+	Enum16042_ENUM_VALUE16128 Enum16042 = 37
+	Enum16042_ENUM_VALUE16129 Enum16042 = 593
+	Enum16042_ENUM_VALUE16130 Enum16042 = 594
+	Enum16042_ENUM_VALUE16131 Enum16042 = 595
+	Enum16042_ENUM_VALUE16132 Enum16042 = 596
+	Enum16042_ENUM_VALUE16133 Enum16042 = 597
+	Enum16042_ENUM_VALUE16134 Enum16042 = 38
+	Enum16042_ENUM_VALUE16135 Enum16042 = 609
+	Enum16042_ENUM_VALUE16136 Enum16042 = 610
+	Enum16042_ENUM_VALUE16137 Enum16042 = 617
+	Enum16042_ENUM_VALUE16138 Enum16042 = 614
+	Enum16042_ENUM_VALUE16139 Enum16042 = 615
+	Enum16042_ENUM_VALUE16140 Enum16042 = 616
+	Enum16042_ENUM_VALUE16141 Enum16042 = 618
+	Enum16042_ENUM_VALUE16142 Enum16042 = 620
+	Enum16042_ENUM_VALUE16143 Enum16042 = 9937
+	Enum16042_ENUM_VALUE16144 Enum16042 = 9938
+	Enum16042_ENUM_VALUE16145 Enum16042 = 9939
+	Enum16042_ENUM_VALUE16146 Enum16042 = 9940
+	Enum16042_ENUM_VALUE16147 Enum16042 = 9941
+	Enum16042_ENUM_VALUE16148 Enum16042 = 39
+	Enum16042_ENUM_VALUE16149 Enum16042 = 40
+	Enum16042_ENUM_VALUE16150 Enum16042 = 41
+	Enum16042_ENUM_VALUE16151 Enum16042 = 42
+	Enum16042_ENUM_VALUE16152 Enum16042 = 43
+	Enum16042_ENUM_VALUE16153 Enum16042 = 44
+	Enum16042_ENUM_VALUE16154 Enum16042 = 45
+	Enum16042_ENUM_VALUE16155 Enum16042 = 11793
+	Enum16042_ENUM_VALUE16156 Enum16042 = 3
+	Enum16042_ENUM_VALUE16157 Enum16042 = 49
+	Enum16042_ENUM_VALUE16158 Enum16042 = 50
+	Enum16042_ENUM_VALUE16159 Enum16042 = 51
+	Enum16042_ENUM_VALUE16160 Enum16042 = 817
+	Enum16042_ENUM_VALUE16161 Enum16042 = 818
+	Enum16042_ENUM_VALUE16162 Enum16042 = 819
+	Enum16042_ENUM_VALUE16163 Enum16042 = 52
+	Enum16042_ENUM_VALUE16164 Enum16042 = 833
+	Enum16042_ENUM_VALUE16165 Enum16042 = 53
+	Enum16042_ENUM_VALUE16166 Enum16042 = 54
+	Enum16042_ENUM_VALUE16167 Enum16042 = 4
+	Enum16042_ENUM_VALUE16168 Enum16042 = 1041
+	Enum16042_ENUM_VALUE16169 Enum16042 = 16657
+	Enum16042_ENUM_VALUE16170 Enum16042 = 16658
+	Enum16042_ENUM_VALUE16171 Enum16042 = 16659
+	Enum16042_ENUM_VALUE16172 Enum16042 = 16660
+	Enum16042_ENUM_VALUE16173 Enum16042 = 16661
+	Enum16042_ENUM_VALUE16174 Enum16042 = 1042
+	Enum16042_ENUM_VALUE16175 Enum16042 = 16673
+	Enum16042_ENUM_VALUE16176 Enum16042 = 1043
+	Enum16042_ENUM_VALUE16177 Enum16042 = 16689
+	Enum16042_ENUM_VALUE16178 Enum16042 = 16690
+	Enum16042_ENUM_VALUE16179 Enum16042 = 16691
+	Enum16042_ENUM_VALUE16180 Enum16042 = 16692
+	Enum16042_ENUM_VALUE16181 Enum16042 = 16693
+	Enum16042_ENUM_VALUE16182 Enum16042 = 16694
+	Enum16042_ENUM_VALUE16183 Enum16042 = 16695
+	Enum16042_ENUM_VALUE16184 Enum16042 = 1044
+	Enum16042_ENUM_VALUE16185 Enum16042 = 16705
+	Enum16042_ENUM_VALUE16186 Enum16042 = 16706
+	Enum16042_ENUM_VALUE16187 Enum16042 = 16707
+	Enum16042_ENUM_VALUE16188 Enum16042 = 16708
+	Enum16042_ENUM_VALUE16189 Enum16042 = 16709
+	Enum16042_ENUM_VALUE16190 Enum16042 = 16710
+	Enum16042_ENUM_VALUE16191 Enum16042 = 16711
+	Enum16042_ENUM_VALUE16192 Enum16042 = 16712
+	Enum16042_ENUM_VALUE16193 Enum16042 = 16713
+	Enum16042_ENUM_VALUE16194 Enum16042 = 1046
+	Enum16042_ENUM_VALUE16195 Enum16042 = 16737
+	Enum16042_ENUM_VALUE16196 Enum16042 = 1047
+	Enum16042_ENUM_VALUE16197 Enum16042 = 16753
+	Enum16042_ENUM_VALUE16198 Enum16042 = 268049
+	Enum16042_ENUM_VALUE16199 Enum16042 = 268050
+	Enum16042_ENUM_VALUE16200 Enum16042 = 268051
+	Enum16042_ENUM_VALUE16201 Enum16042 = 268052
+	Enum16042_ENUM_VALUE16202 Enum16042 = 1048
+	Enum16042_ENUM_VALUE16203 Enum16042 = 16769
+	Enum16042_ENUM_VALUE16204 Enum16042 = 16770
+	Enum16042_ENUM_VALUE16205 Enum16042 = 16771
+	Enum16042_ENUM_VALUE16206 Enum16042 = 16772
+	Enum16042_ENUM_VALUE16207 Enum16042 = 16773
+	Enum16042_ENUM_VALUE16208 Enum16042 = 1049
+	Enum16042_ENUM_VALUE16209 Enum16042 = 1056
+	Enum16042_ENUM_VALUE16210 Enum16042 = 1058
+	Enum16042_ENUM_VALUE16211 Enum16042 = 1059
+	Enum16042_ENUM_VALUE16212 Enum16042 = 1060
+	Enum16042_ENUM_VALUE16213 Enum16042 = 1061
+	Enum16042_ENUM_VALUE16214 Enum16042 = 5
+	Enum16042_ENUM_VALUE16215 Enum16042 = 6
+	Enum16042_ENUM_VALUE16216 Enum16042 = 97
+	Enum16042_ENUM_VALUE16217 Enum16042 = 98
+	Enum16042_ENUM_VALUE16218 Enum16042 = 99
+	Enum16042_ENUM_VALUE16219 Enum16042 = 100
+	Enum16042_ENUM_VALUE16220 Enum16042 = 101
+	Enum16042_ENUM_VALUE16221 Enum16042 = 102
+	Enum16042_ENUM_VALUE16222 Enum16042 = 103
+	Enum16042_ENUM_VALUE16223 Enum16042 = 104
+	Enum16042_ENUM_VALUE16224 Enum16042 = 105
+	Enum16042_ENUM_VALUE16225 Enum16042 = 106
+	Enum16042_ENUM_VALUE16226 Enum16042 = 108
+	Enum16042_ENUM_VALUE16227 Enum16042 = 1729
+	Enum16042_ENUM_VALUE16228 Enum16042 = 1730
+	Enum16042_ENUM_VALUE16229 Enum16042 = 1731
+	Enum16042_ENUM_VALUE16230 Enum16042 = 7
+	Enum16042_ENUM_VALUE16231 Enum16042 = 8
+	Enum16042_ENUM_VALUE16232 Enum16042 = 9
+	Enum16042_ENUM_VALUE16233 Enum16042 = 10
+	Enum16042_ENUM_VALUE16234 Enum16042 = 161
+	Enum16042_ENUM_VALUE16235 Enum16042 = 2577
+	Enum16042_ENUM_VALUE16236 Enum16042 = 41233
+	Enum16042_ENUM_VALUE16237 Enum16042 = 41234
+	Enum16042_ENUM_VALUE16238 Enum16042 = 2578
+	Enum16042_ENUM_VALUE16239 Enum16042 = 2579
+	Enum16042_ENUM_VALUE16240 Enum16042 = 41265
+	Enum16042_ENUM_VALUE16241 Enum16042 = 2580
+	Enum16042_ENUM_VALUE16242 Enum16042 = 2581
+	Enum16042_ENUM_VALUE16243 Enum16042 = 41297
+	Enum16042_ENUM_VALUE16244 Enum16042 = 41298
+	Enum16042_ENUM_VALUE16245 Enum16042 = 41299
+	Enum16042_ENUM_VALUE16246 Enum16042 = 41300
+	Enum16042_ENUM_VALUE16247 Enum16042 = 2582
+	Enum16042_ENUM_VALUE16248 Enum16042 = 2583
+	Enum16042_ENUM_VALUE16249 Enum16042 = 2584
+	Enum16042_ENUM_VALUE16250 Enum16042 = 162
+	Enum16042_ENUM_VALUE16251 Enum16042 = 2593
+	Enum16042_ENUM_VALUE16252 Enum16042 = 41489
+	Enum16042_ENUM_VALUE16253 Enum16042 = 663825
+	Enum16042_ENUM_VALUE16254 Enum16042 = 663826
+	Enum16042_ENUM_VALUE16255 Enum16042 = 41490
+	Enum16042_ENUM_VALUE16256 Enum16042 = 41491
+	Enum16042_ENUM_VALUE16257 Enum16042 = 41492
+	Enum16042_ENUM_VALUE16258 Enum16042 = 663873
+	Enum16042_ENUM_VALUE16259 Enum16042 = 2594
+	Enum16042_ENUM_VALUE16260 Enum16042 = 41505
+	Enum16042_ENUM_VALUE16261 Enum16042 = 41506
+	Enum16042_ENUM_VALUE16262 Enum16042 = 41507
+	Enum16042_ENUM_VALUE16263 Enum16042 = 2595
+	Enum16042_ENUM_VALUE16264 Enum16042 = 41521
+	Enum16042_ENUM_VALUE16265 Enum16042 = 41522
+	Enum16042_ENUM_VALUE16266 Enum16042 = 41523
+	Enum16042_ENUM_VALUE16267 Enum16042 = 41524
+	Enum16042_ENUM_VALUE16268 Enum16042 = 41525
+	Enum16042_ENUM_VALUE16269 Enum16042 = 664401
+	Enum16042_ENUM_VALUE16270 Enum16042 = 664402
+	Enum16042_ENUM_VALUE16271 Enum16042 = 41526
+	Enum16042_ENUM_VALUE16272 Enum16042 = 41527
+	Enum16042_ENUM_VALUE16273 Enum16042 = 2596
+	Enum16042_ENUM_VALUE16274 Enum16042 = 2597
+	Enum16042_ENUM_VALUE16275 Enum16042 = 2598
+	Enum16042_ENUM_VALUE16276 Enum16042 = 41569
+	Enum16042_ENUM_VALUE16277 Enum16042 = 41570
+	Enum16042_ENUM_VALUE16278 Enum16042 = 41571
+	Enum16042_ENUM_VALUE16279 Enum16042 = 41572
+	Enum16042_ENUM_VALUE16280 Enum16042 = 41573
+	Enum16042_ENUM_VALUE16281 Enum16042 = 665169
+	Enum16042_ENUM_VALUE16282 Enum16042 = 665170
+	Enum16042_ENUM_VALUE16283 Enum16042 = 665171
+	Enum16042_ENUM_VALUE16284 Enum16042 = 665172
+	Enum16042_ENUM_VALUE16285 Enum16042 = 2599
+	Enum16042_ENUM_VALUE16286 Enum16042 = 2600
+	Enum16042_ENUM_VALUE16287 Enum16042 = 2601
+	Enum16042_ENUM_VALUE16288 Enum16042 = 2603
+	Enum16042_ENUM_VALUE16289 Enum16042 = 2604
+	Enum16042_ENUM_VALUE16290 Enum16042 = 163
+	Enum16042_ENUM_VALUE16291 Enum16042 = 2608
+	Enum16042_ENUM_VALUE16292 Enum16042 = 2609
+	Enum16042_ENUM_VALUE16293 Enum16042 = 2610
+	Enum16042_ENUM_VALUE16294 Enum16042 = 2611
+	Enum16042_ENUM_VALUE16295 Enum16042 = 2612
+	Enum16042_ENUM_VALUE16296 Enum16042 = 164
+	Enum16042_ENUM_VALUE16297 Enum16042 = 2625
+	Enum16042_ENUM_VALUE16298 Enum16042 = 2626
+	Enum16042_ENUM_VALUE16299 Enum16042 = 42017
+	Enum16042_ENUM_VALUE16300 Enum16042 = 42018
+	Enum16042_ENUM_VALUE16301 Enum16042 = 42019
+	Enum16042_ENUM_VALUE16302 Enum16042 = 2627
+	Enum16042_ENUM_VALUE16303 Enum16042 = 2628
+	Enum16042_ENUM_VALUE16304 Enum16042 = 165
+	Enum16042_ENUM_VALUE16305 Enum16042 = 2641
+	Enum16042_ENUM_VALUE16306 Enum16042 = 42257
+	Enum16042_ENUM_VALUE16307 Enum16042 = 42258
+	Enum16042_ENUM_VALUE16308 Enum16042 = 2642
+	Enum16042_ENUM_VALUE16309 Enum16042 = 2643
+	Enum16042_ENUM_VALUE16310 Enum16042 = 2644
+	Enum16042_ENUM_VALUE16311 Enum16042 = 2646
+	Enum16042_ENUM_VALUE16312 Enum16042 = 2647
+	Enum16042_ENUM_VALUE16313 Enum16042 = 42353
+	Enum16042_ENUM_VALUE16314 Enum16042 = 2648
+	Enum16042_ENUM_VALUE16315 Enum16042 = 2649
+	Enum16042_ENUM_VALUE16316 Enum16042 = 2650
+	Enum16042_ENUM_VALUE16317 Enum16042 = 2651
+	Enum16042_ENUM_VALUE16318 Enum16042 = 2652
+	Enum16042_ENUM_VALUE16319 Enum16042 = 2653
+	Enum16042_ENUM_VALUE16320 Enum16042 = 2654
+	Enum16042_ENUM_VALUE16321 Enum16042 = 42481
+	Enum16042_ENUM_VALUE16322 Enum16042 = 42482
+	Enum16042_ENUM_VALUE16323 Enum16042 = 42483
+	Enum16042_ENUM_VALUE16324 Enum16042 = 166
+	Enum16042_ENUM_VALUE16325 Enum16042 = 2657
+	Enum16042_ENUM_VALUE16326 Enum16042 = 2658
+	Enum16042_ENUM_VALUE16327 Enum16042 = 42529
+	Enum16042_ENUM_VALUE16328 Enum16042 = 2659
+	Enum16042_ENUM_VALUE16329 Enum16042 = 2660
+	Enum16042_ENUM_VALUE16330 Enum16042 = 2661
+	Enum16042_ENUM_VALUE16331 Enum16042 = 2662
+	Enum16042_ENUM_VALUE16332 Enum16042 = 2663
+	Enum16042_ENUM_VALUE16333 Enum16042 = 42609
+	Enum16042_ENUM_VALUE16334 Enum16042 = 2664
+	Enum16042_ENUM_VALUE16335 Enum16042 = 2665
+	Enum16042_ENUM_VALUE16336 Enum16042 = 42753
+	Enum16042_ENUM_VALUE16337 Enum16042 = 42754
+	Enum16042_ENUM_VALUE16338 Enum16042 = 42755
+	Enum16042_ENUM_VALUE16339 Enum16042 = 11
+	Enum16042_ENUM_VALUE16340 Enum16042 = 177
+	Enum16042_ENUM_VALUE16341 Enum16042 = 2833
+	Enum16042_ENUM_VALUE16342 Enum16042 = 179
+	Enum16042_ENUM_VALUE16343 Enum16042 = 180
+	Enum16042_ENUM_VALUE16344 Enum16042 = 2881
+	Enum16042_ENUM_VALUE16345 Enum16042 = 182
+	Enum16042_ENUM_VALUE16346 Enum16042 = 183
+	Enum16042_ENUM_VALUE16347 Enum16042 = 12
+	Enum16042_ENUM_VALUE16348 Enum16042 = 3089
+	Enum16042_ENUM_VALUE16349 Enum16042 = 194
+	Enum16042_ENUM_VALUE16350 Enum16042 = 195
+	Enum16042_ENUM_VALUE16351 Enum16042 = 196
+	Enum16042_ENUM_VALUE16352 Enum16042 = 198
+	Enum16042_ENUM_VALUE16353 Enum16042 = 3169
+	Enum16042_ENUM_VALUE16354 Enum16042 = 199
+	Enum16042_ENUM_VALUE16355 Enum16042 = 200
+	Enum16042_ENUM_VALUE16356 Enum16042 = 208
+	Enum16042_ENUM_VALUE16357 Enum16042 = 3329
+	Enum16042_ENUM_VALUE16358 Enum16042 = 3330
+	Enum16042_ENUM_VALUE16359 Enum16042 = 3331
+	Enum16042_ENUM_VALUE16360 Enum16042 = 209
+	Enum16042_ENUM_VALUE16361 Enum16042 = 210
+	Enum16042_ENUM_VALUE16362 Enum16042 = 211
+	Enum16042_ENUM_VALUE16363 Enum16042 = 3377
+	Enum16042_ENUM_VALUE16364 Enum16042 = 3378
+	Enum16042_ENUM_VALUE16365 Enum16042 = 3379
+	Enum16042_ENUM_VALUE16366 Enum16042 = 3380
+	Enum16042_ENUM_VALUE16367 Enum16042 = 3381
+	Enum16042_ENUM_VALUE16368 Enum16042 = 865809
+	Enum16042_ENUM_VALUE16369 Enum16042 = 865810
+	Enum16042_ENUM_VALUE16370 Enum16042 = 865811
+	Enum16042_ENUM_VALUE16371 Enum16042 = 865812
+	Enum16042_ENUM_VALUE16372 Enum16042 = 865813
+	Enum16042_ENUM_VALUE16373 Enum16042 = 865814
+	Enum16042_ENUM_VALUE16374 Enum16042 = 865815
+	Enum16042_ENUM_VALUE16375 Enum16042 = 865816
+	Enum16042_ENUM_VALUE16376 Enum16042 = 865817
+	Enum16042_ENUM_VALUE16377 Enum16042 = 865818
+	Enum16042_ENUM_VALUE16378 Enum16042 = 865819
+	Enum16042_ENUM_VALUE16379 Enum16042 = 865820
+	Enum16042_ENUM_VALUE16380 Enum16042 = 865821
+	Enum16042_ENUM_VALUE16381 Enum16042 = 865822
+	Enum16042_ENUM_VALUE16382 Enum16042 = 865823
+	Enum16042_ENUM_VALUE16383 Enum16042 = 865824
+	Enum16042_ENUM_VALUE16384 Enum16042 = 865825
+	Enum16042_ENUM_VALUE16385 Enum16042 = 865826
+	Enum16042_ENUM_VALUE16386 Enum16042 = 865827
+	Enum16042_ENUM_VALUE16387 Enum16042 = 865828
+	Enum16042_ENUM_VALUE16388 Enum16042 = 865829
+	Enum16042_ENUM_VALUE16389 Enum16042 = 212
+	Enum16042_ENUM_VALUE16390 Enum16042 = 3393
+	Enum16042_ENUM_VALUE16391 Enum16042 = 3394
+	Enum16042_ENUM_VALUE16392 Enum16042 = 3395
+	Enum16042_ENUM_VALUE16393 Enum16042 = 213
+	Enum16042_ENUM_VALUE16394 Enum16042 = 214
+	Enum16042_ENUM_VALUE16395 Enum16042 = 215
+	Enum16042_ENUM_VALUE16396 Enum16042 = 3441
+	Enum16042_ENUM_VALUE16397 Enum16042 = 3442
+	Enum16042_ENUM_VALUE16398 Enum16042 = 216
+	Enum16042_ENUM_VALUE16399 Enum16042 = 217
+	Enum16042_ENUM_VALUE16400 Enum16042 = 3473
+	Enum16042_ENUM_VALUE16401 Enum16042 = 3474
+	Enum16042_ENUM_VALUE16402 Enum16042 = 3475
+	Enum16042_ENUM_VALUE16403 Enum16042 = 254
+	Enum16042_ENUM_VALUE16404 Enum16042 = 255
+)
+
+// Enum value maps for Enum16042.
+var (
+	Enum16042_name = map[int32]string{
+		0:      "ENUM_VALUE16043",
+		1:      "ENUM_VALUE16044",
+		17:     "ENUM_VALUE16045",
+		273:    "ENUM_VALUE16046",
+		274:    "ENUM_VALUE16047",
+		4385:   "ENUM_VALUE16048",
+		4386:   "ENUM_VALUE16049",
+		4387:   "ENUM_VALUE16050",
+		4388:   "ENUM_VALUE16051",
+		4389:   "ENUM_VALUE16052",
+		4390:   "ENUM_VALUE16053",
+		4391:   "ENUM_VALUE16054",
+		4392:   "ENUM_VALUE16055",
+		4393:   "ENUM_VALUE16056",
+		276:    "ENUM_VALUE16057",
+		277:    "ENUM_VALUE16058",
+		18:     "ENUM_VALUE16059",
+		289:    "ENUM_VALUE16060",
+		291:    "ENUM_VALUE16061",
+		4657:   "ENUM_VALUE16062",
+		74513:  "ENUM_VALUE16063",
+		4658:   "ENUM_VALUE16064",
+		4659:   "ENUM_VALUE16065",
+		4660:   "ENUM_VALUE16066",
+		4661:   "ENUM_VALUE16067",
+		4662:   "ENUM_VALUE16068",
+		4663:   "ENUM_VALUE16069",
+		4664:   "ENUM_VALUE16070",
+		292:    "ENUM_VALUE16071",
+		4673:   "ENUM_VALUE16072",
+		4674:   "ENUM_VALUE16073",
+		293:    "ENUM_VALUE16074",
+		19:     "ENUM_VALUE16075",
+		20:     "ENUM_VALUE16076",
+		321:    "ENUM_VALUE16077",
+		5137:   "ENUM_VALUE16078",
+		5138:   "ENUM_VALUE16079",
+		5139:   "ENUM_VALUE16080",
+		5140:   "ENUM_VALUE16081",
+		5141:   "ENUM_VALUE16082",
+		5142:   "ENUM_VALUE16083",
+		82273:  "ENUM_VALUE16084",
+		82274:  "ENUM_VALUE16085",
+		82275:  "ENUM_VALUE16086",
+		82276:  "ENUM_VALUE16087",
+		82277:  "ENUM_VALUE16088",
+		82278:  "ENUM_VALUE16089",
+		5143:   "ENUM_VALUE16090",
+		5144:   "ENUM_VALUE16091",
+		5145:   "ENUM_VALUE16092",
+		5146:   "ENUM_VALUE16093",
+		82337:  "ENUM_VALUE16094",
+		5147:   "ENUM_VALUE16095",
+		5148:   "ENUM_VALUE16096",
+		322:    "ENUM_VALUE16097",
+		323:    "ENUM_VALUE16098",
+		324:    "ENUM_VALUE16099",
+		325:    "ENUM_VALUE16100",
+		326:    "ENUM_VALUE16101",
+		327:    "ENUM_VALUE16102",
+		328:    "ENUM_VALUE16103",
+		21:     "ENUM_VALUE16104",
+		337:    "ENUM_VALUE16105",
+		22:     "ENUM_VALUE16106",
+		23:     "ENUM_VALUE16107",
+		24:     "ENUM_VALUE16108",
+		2:      "ENUM_VALUE16109",
+		33:     "ENUM_VALUE16110",
+		34:     "ENUM_VALUE16111",
+		545:    "ENUM_VALUE16112",
+		8721:   "ENUM_VALUE16113",
+		8723:   "ENUM_VALUE16114",
+		8724:   "ENUM_VALUE16115",
+		546:    "ENUM_VALUE16116",
+		8739:   "ENUM_VALUE16117",
+		8740:   "ENUM_VALUE16118",
+		547:    "ENUM_VALUE16119",
+		548:    "ENUM_VALUE16120",
+		549:    "ENUM_VALUE16121",
+		550:    "ENUM_VALUE16122",
+		551:    "ENUM_VALUE16123",
+		552:    "ENUM_VALUE16124",
+		553:    "ENUM_VALUE16125",
+		35:     "ENUM_VALUE16126",
+		36:     "ENUM_VALUE16127",
+		37:     "ENUM_VALUE16128",
+		593:    "ENUM_VALUE16129",
+		594:    "ENUM_VALUE16130",
+		595:    "ENUM_VALUE16131",
+		596:    "ENUM_VALUE16132",
+		597:    "ENUM_VALUE16133",
+		38:     "ENUM_VALUE16134",
+		609:    "ENUM_VALUE16135",
+		610:    "ENUM_VALUE16136",
+		617:    "ENUM_VALUE16137",
+		614:    "ENUM_VALUE16138",
+		615:    "ENUM_VALUE16139",
+		616:    "ENUM_VALUE16140",
+		618:    "ENUM_VALUE16141",
+		620:    "ENUM_VALUE16142",
+		9937:   "ENUM_VALUE16143",
+		9938:   "ENUM_VALUE16144",
+		9939:   "ENUM_VALUE16145",
+		9940:   "ENUM_VALUE16146",
+		9941:   "ENUM_VALUE16147",
+		39:     "ENUM_VALUE16148",
+		40:     "ENUM_VALUE16149",
+		41:     "ENUM_VALUE16150",
+		42:     "ENUM_VALUE16151",
+		43:     "ENUM_VALUE16152",
+		44:     "ENUM_VALUE16153",
+		45:     "ENUM_VALUE16154",
+		11793:  "ENUM_VALUE16155",
+		3:      "ENUM_VALUE16156",
+		49:     "ENUM_VALUE16157",
+		50:     "ENUM_VALUE16158",
+		51:     "ENUM_VALUE16159",
+		817:    "ENUM_VALUE16160",
+		818:    "ENUM_VALUE16161",
+		819:    "ENUM_VALUE16162",
+		52:     "ENUM_VALUE16163",
+		833:    "ENUM_VALUE16164",
+		53:     "ENUM_VALUE16165",
+		54:     "ENUM_VALUE16166",
+		4:      "ENUM_VALUE16167",
+		1041:   "ENUM_VALUE16168",
+		16657:  "ENUM_VALUE16169",
+		16658:  "ENUM_VALUE16170",
+		16659:  "ENUM_VALUE16171",
+		16660:  "ENUM_VALUE16172",
+		16661:  "ENUM_VALUE16173",
+		1042:   "ENUM_VALUE16174",
+		16673:  "ENUM_VALUE16175",
+		1043:   "ENUM_VALUE16176",
+		16689:  "ENUM_VALUE16177",
+		16690:  "ENUM_VALUE16178",
+		16691:  "ENUM_VALUE16179",
+		16692:  "ENUM_VALUE16180",
+		16693:  "ENUM_VALUE16181",
+		16694:  "ENUM_VALUE16182",
+		16695:  "ENUM_VALUE16183",
+		1044:   "ENUM_VALUE16184",
+		16705:  "ENUM_VALUE16185",
+		16706:  "ENUM_VALUE16186",
+		16707:  "ENUM_VALUE16187",
+		16708:  "ENUM_VALUE16188",
+		16709:  "ENUM_VALUE16189",
+		16710:  "ENUM_VALUE16190",
+		16711:  "ENUM_VALUE16191",
+		16712:  "ENUM_VALUE16192",
+		16713:  "ENUM_VALUE16193",
+		1046:   "ENUM_VALUE16194",
+		16737:  "ENUM_VALUE16195",
+		1047:   "ENUM_VALUE16196",
+		16753:  "ENUM_VALUE16197",
+		268049: "ENUM_VALUE16198",
+		268050: "ENUM_VALUE16199",
+		268051: "ENUM_VALUE16200",
+		268052: "ENUM_VALUE16201",
+		1048:   "ENUM_VALUE16202",
+		16769:  "ENUM_VALUE16203",
+		16770:  "ENUM_VALUE16204",
+		16771:  "ENUM_VALUE16205",
+		16772:  "ENUM_VALUE16206",
+		16773:  "ENUM_VALUE16207",
+		1049:   "ENUM_VALUE16208",
+		1056:   "ENUM_VALUE16209",
+		1058:   "ENUM_VALUE16210",
+		1059:   "ENUM_VALUE16211",
+		1060:   "ENUM_VALUE16212",
+		1061:   "ENUM_VALUE16213",
+		5:      "ENUM_VALUE16214",
+		6:      "ENUM_VALUE16215",
+		97:     "ENUM_VALUE16216",
+		98:     "ENUM_VALUE16217",
+		99:     "ENUM_VALUE16218",
+		100:    "ENUM_VALUE16219",
+		101:    "ENUM_VALUE16220",
+		102:    "ENUM_VALUE16221",
+		103:    "ENUM_VALUE16222",
+		104:    "ENUM_VALUE16223",
+		105:    "ENUM_VALUE16224",
+		106:    "ENUM_VALUE16225",
+		108:    "ENUM_VALUE16226",
+		1729:   "ENUM_VALUE16227",
+		1730:   "ENUM_VALUE16228",
+		1731:   "ENUM_VALUE16229",
+		7:      "ENUM_VALUE16230",
+		8:      "ENUM_VALUE16231",
+		9:      "ENUM_VALUE16232",
+		10:     "ENUM_VALUE16233",
+		161:    "ENUM_VALUE16234",
+		2577:   "ENUM_VALUE16235",
+		41233:  "ENUM_VALUE16236",
+		41234:  "ENUM_VALUE16237",
+		2578:   "ENUM_VALUE16238",
+		2579:   "ENUM_VALUE16239",
+		41265:  "ENUM_VALUE16240",
+		2580:   "ENUM_VALUE16241",
+		2581:   "ENUM_VALUE16242",
+		41297:  "ENUM_VALUE16243",
+		41298:  "ENUM_VALUE16244",
+		41299:  "ENUM_VALUE16245",
+		41300:  "ENUM_VALUE16246",
+		2582:   "ENUM_VALUE16247",
+		2583:   "ENUM_VALUE16248",
+		2584:   "ENUM_VALUE16249",
+		162:    "ENUM_VALUE16250",
+		2593:   "ENUM_VALUE16251",
+		41489:  "ENUM_VALUE16252",
+		663825: "ENUM_VALUE16253",
+		663826: "ENUM_VALUE16254",
+		41490:  "ENUM_VALUE16255",
+		41491:  "ENUM_VALUE16256",
+		41492:  "ENUM_VALUE16257",
+		663873: "ENUM_VALUE16258",
+		2594:   "ENUM_VALUE16259",
+		41505:  "ENUM_VALUE16260",
+		41506:  "ENUM_VALUE16261",
+		41507:  "ENUM_VALUE16262",
+		2595:   "ENUM_VALUE16263",
+		41521:  "ENUM_VALUE16264",
+		41522:  "ENUM_VALUE16265",
+		41523:  "ENUM_VALUE16266",
+		41524:  "ENUM_VALUE16267",
+		41525:  "ENUM_VALUE16268",
+		664401: "ENUM_VALUE16269",
+		664402: "ENUM_VALUE16270",
+		41526:  "ENUM_VALUE16271",
+		41527:  "ENUM_VALUE16272",
+		2596:   "ENUM_VALUE16273",
+		2597:   "ENUM_VALUE16274",
+		2598:   "ENUM_VALUE16275",
+		41569:  "ENUM_VALUE16276",
+		41570:  "ENUM_VALUE16277",
+		41571:  "ENUM_VALUE16278",
+		41572:  "ENUM_VALUE16279",
+		41573:  "ENUM_VALUE16280",
+		665169: "ENUM_VALUE16281",
+		665170: "ENUM_VALUE16282",
+		665171: "ENUM_VALUE16283",
+		665172: "ENUM_VALUE16284",
+		2599:   "ENUM_VALUE16285",
+		2600:   "ENUM_VALUE16286",
+		2601:   "ENUM_VALUE16287",
+		2603:   "ENUM_VALUE16288",
+		2604:   "ENUM_VALUE16289",
+		163:    "ENUM_VALUE16290",
+		2608:   "ENUM_VALUE16291",
+		2609:   "ENUM_VALUE16292",
+		2610:   "ENUM_VALUE16293",
+		2611:   "ENUM_VALUE16294",
+		2612:   "ENUM_VALUE16295",
+		164:    "ENUM_VALUE16296",
+		2625:   "ENUM_VALUE16297",
+		2626:   "ENUM_VALUE16298",
+		42017:  "ENUM_VALUE16299",
+		42018:  "ENUM_VALUE16300",
+		42019:  "ENUM_VALUE16301",
+		2627:   "ENUM_VALUE16302",
+		2628:   "ENUM_VALUE16303",
+		165:    "ENUM_VALUE16304",
+		2641:   "ENUM_VALUE16305",
+		42257:  "ENUM_VALUE16306",
+		42258:  "ENUM_VALUE16307",
+		2642:   "ENUM_VALUE16308",
+		2643:   "ENUM_VALUE16309",
+		2644:   "ENUM_VALUE16310",
+		2646:   "ENUM_VALUE16311",
+		2647:   "ENUM_VALUE16312",
+		42353:  "ENUM_VALUE16313",
+		2648:   "ENUM_VALUE16314",
+		2649:   "ENUM_VALUE16315",
+		2650:   "ENUM_VALUE16316",
+		2651:   "ENUM_VALUE16317",
+		2652:   "ENUM_VALUE16318",
+		2653:   "ENUM_VALUE16319",
+		2654:   "ENUM_VALUE16320",
+		42481:  "ENUM_VALUE16321",
+		42482:  "ENUM_VALUE16322",
+		42483:  "ENUM_VALUE16323",
+		166:    "ENUM_VALUE16324",
+		2657:   "ENUM_VALUE16325",
+		2658:   "ENUM_VALUE16326",
+		42529:  "ENUM_VALUE16327",
+		2659:   "ENUM_VALUE16328",
+		2660:   "ENUM_VALUE16329",
+		2661:   "ENUM_VALUE16330",
+		2662:   "ENUM_VALUE16331",
+		2663:   "ENUM_VALUE16332",
+		42609:  "ENUM_VALUE16333",
+		2664:   "ENUM_VALUE16334",
+		2665:   "ENUM_VALUE16335",
+		42753:  "ENUM_VALUE16336",
+		42754:  "ENUM_VALUE16337",
+		42755:  "ENUM_VALUE16338",
+		11:     "ENUM_VALUE16339",
+		177:    "ENUM_VALUE16340",
+		2833:   "ENUM_VALUE16341",
+		179:    "ENUM_VALUE16342",
+		180:    "ENUM_VALUE16343",
+		2881:   "ENUM_VALUE16344",
+		182:    "ENUM_VALUE16345",
+		183:    "ENUM_VALUE16346",
+		12:     "ENUM_VALUE16347",
+		3089:   "ENUM_VALUE16348",
+		194:    "ENUM_VALUE16349",
+		195:    "ENUM_VALUE16350",
+		196:    "ENUM_VALUE16351",
+		198:    "ENUM_VALUE16352",
+		3169:   "ENUM_VALUE16353",
+		199:    "ENUM_VALUE16354",
+		200:    "ENUM_VALUE16355",
+		208:    "ENUM_VALUE16356",
+		3329:   "ENUM_VALUE16357",
+		3330:   "ENUM_VALUE16358",
+		3331:   "ENUM_VALUE16359",
+		209:    "ENUM_VALUE16360",
+		210:    "ENUM_VALUE16361",
+		211:    "ENUM_VALUE16362",
+		3377:   "ENUM_VALUE16363",
+		3378:   "ENUM_VALUE16364",
+		3379:   "ENUM_VALUE16365",
+		3380:   "ENUM_VALUE16366",
+		3381:   "ENUM_VALUE16367",
+		865809: "ENUM_VALUE16368",
+		865810: "ENUM_VALUE16369",
+		865811: "ENUM_VALUE16370",
+		865812: "ENUM_VALUE16371",
+		865813: "ENUM_VALUE16372",
+		865814: "ENUM_VALUE16373",
+		865815: "ENUM_VALUE16374",
+		865816: "ENUM_VALUE16375",
+		865817: "ENUM_VALUE16376",
+		865818: "ENUM_VALUE16377",
+		865819: "ENUM_VALUE16378",
+		865820: "ENUM_VALUE16379",
+		865821: "ENUM_VALUE16380",
+		865822: "ENUM_VALUE16381",
+		865823: "ENUM_VALUE16382",
+		865824: "ENUM_VALUE16383",
+		865825: "ENUM_VALUE16384",
+		865826: "ENUM_VALUE16385",
+		865827: "ENUM_VALUE16386",
+		865828: "ENUM_VALUE16387",
+		865829: "ENUM_VALUE16388",
+		212:    "ENUM_VALUE16389",
+		3393:   "ENUM_VALUE16390",
+		3394:   "ENUM_VALUE16391",
+		3395:   "ENUM_VALUE16392",
+		213:    "ENUM_VALUE16393",
+		214:    "ENUM_VALUE16394",
+		215:    "ENUM_VALUE16395",
+		3441:   "ENUM_VALUE16396",
+		3442:   "ENUM_VALUE16397",
+		216:    "ENUM_VALUE16398",
+		217:    "ENUM_VALUE16399",
+		3473:   "ENUM_VALUE16400",
+		3474:   "ENUM_VALUE16401",
+		3475:   "ENUM_VALUE16402",
+		254:    "ENUM_VALUE16403",
+		255:    "ENUM_VALUE16404",
+	}
+	Enum16042_value = map[string]int32{
+		"ENUM_VALUE16043": 0,
+		"ENUM_VALUE16044": 1,
+		"ENUM_VALUE16045": 17,
+		"ENUM_VALUE16046": 273,
+		"ENUM_VALUE16047": 274,
+		"ENUM_VALUE16048": 4385,
+		"ENUM_VALUE16049": 4386,
+		"ENUM_VALUE16050": 4387,
+		"ENUM_VALUE16051": 4388,
+		"ENUM_VALUE16052": 4389,
+		"ENUM_VALUE16053": 4390,
+		"ENUM_VALUE16054": 4391,
+		"ENUM_VALUE16055": 4392,
+		"ENUM_VALUE16056": 4393,
+		"ENUM_VALUE16057": 276,
+		"ENUM_VALUE16058": 277,
+		"ENUM_VALUE16059": 18,
+		"ENUM_VALUE16060": 289,
+		"ENUM_VALUE16061": 291,
+		"ENUM_VALUE16062": 4657,
+		"ENUM_VALUE16063": 74513,
+		"ENUM_VALUE16064": 4658,
+		"ENUM_VALUE16065": 4659,
+		"ENUM_VALUE16066": 4660,
+		"ENUM_VALUE16067": 4661,
+		"ENUM_VALUE16068": 4662,
+		"ENUM_VALUE16069": 4663,
+		"ENUM_VALUE16070": 4664,
+		"ENUM_VALUE16071": 292,
+		"ENUM_VALUE16072": 4673,
+		"ENUM_VALUE16073": 4674,
+		"ENUM_VALUE16074": 293,
+		"ENUM_VALUE16075": 19,
+		"ENUM_VALUE16076": 20,
+		"ENUM_VALUE16077": 321,
+		"ENUM_VALUE16078": 5137,
+		"ENUM_VALUE16079": 5138,
+		"ENUM_VALUE16080": 5139,
+		"ENUM_VALUE16081": 5140,
+		"ENUM_VALUE16082": 5141,
+		"ENUM_VALUE16083": 5142,
+		"ENUM_VALUE16084": 82273,
+		"ENUM_VALUE16085": 82274,
+		"ENUM_VALUE16086": 82275,
+		"ENUM_VALUE16087": 82276,
+		"ENUM_VALUE16088": 82277,
+		"ENUM_VALUE16089": 82278,
+		"ENUM_VALUE16090": 5143,
+		"ENUM_VALUE16091": 5144,
+		"ENUM_VALUE16092": 5145,
+		"ENUM_VALUE16093": 5146,
+		"ENUM_VALUE16094": 82337,
+		"ENUM_VALUE16095": 5147,
+		"ENUM_VALUE16096": 5148,
+		"ENUM_VALUE16097": 322,
+		"ENUM_VALUE16098": 323,
+		"ENUM_VALUE16099": 324,
+		"ENUM_VALUE16100": 325,
+		"ENUM_VALUE16101": 326,
+		"ENUM_VALUE16102": 327,
+		"ENUM_VALUE16103": 328,
+		"ENUM_VALUE16104": 21,
+		"ENUM_VALUE16105": 337,
+		"ENUM_VALUE16106": 22,
+		"ENUM_VALUE16107": 23,
+		"ENUM_VALUE16108": 24,
+		"ENUM_VALUE16109": 2,
+		"ENUM_VALUE16110": 33,
+		"ENUM_VALUE16111": 34,
+		"ENUM_VALUE16112": 545,
+		"ENUM_VALUE16113": 8721,
+		"ENUM_VALUE16114": 8723,
+		"ENUM_VALUE16115": 8724,
+		"ENUM_VALUE16116": 546,
+		"ENUM_VALUE16117": 8739,
+		"ENUM_VALUE16118": 8740,
+		"ENUM_VALUE16119": 547,
+		"ENUM_VALUE16120": 548,
+		"ENUM_VALUE16121": 549,
+		"ENUM_VALUE16122": 550,
+		"ENUM_VALUE16123": 551,
+		"ENUM_VALUE16124": 552,
+		"ENUM_VALUE16125": 553,
+		"ENUM_VALUE16126": 35,
+		"ENUM_VALUE16127": 36,
+		"ENUM_VALUE16128": 37,
+		"ENUM_VALUE16129": 593,
+		"ENUM_VALUE16130": 594,
+		"ENUM_VALUE16131": 595,
+		"ENUM_VALUE16132": 596,
+		"ENUM_VALUE16133": 597,
+		"ENUM_VALUE16134": 38,
+		"ENUM_VALUE16135": 609,
+		"ENUM_VALUE16136": 610,
+		"ENUM_VALUE16137": 617,
+		"ENUM_VALUE16138": 614,
+		"ENUM_VALUE16139": 615,
+		"ENUM_VALUE16140": 616,
+		"ENUM_VALUE16141": 618,
+		"ENUM_VALUE16142": 620,
+		"ENUM_VALUE16143": 9937,
+		"ENUM_VALUE16144": 9938,
+		"ENUM_VALUE16145": 9939,
+		"ENUM_VALUE16146": 9940,
+		"ENUM_VALUE16147": 9941,
+		"ENUM_VALUE16148": 39,
+		"ENUM_VALUE16149": 40,
+		"ENUM_VALUE16150": 41,
+		"ENUM_VALUE16151": 42,
+		"ENUM_VALUE16152": 43,
+		"ENUM_VALUE16153": 44,
+		"ENUM_VALUE16154": 45,
+		"ENUM_VALUE16155": 11793,
+		"ENUM_VALUE16156": 3,
+		"ENUM_VALUE16157": 49,
+		"ENUM_VALUE16158": 50,
+		"ENUM_VALUE16159": 51,
+		"ENUM_VALUE16160": 817,
+		"ENUM_VALUE16161": 818,
+		"ENUM_VALUE16162": 819,
+		"ENUM_VALUE16163": 52,
+		"ENUM_VALUE16164": 833,
+		"ENUM_VALUE16165": 53,
+		"ENUM_VALUE16166": 54,
+		"ENUM_VALUE16167": 4,
+		"ENUM_VALUE16168": 1041,
+		"ENUM_VALUE16169": 16657,
+		"ENUM_VALUE16170": 16658,
+		"ENUM_VALUE16171": 16659,
+		"ENUM_VALUE16172": 16660,
+		"ENUM_VALUE16173": 16661,
+		"ENUM_VALUE16174": 1042,
+		"ENUM_VALUE16175": 16673,
+		"ENUM_VALUE16176": 1043,
+		"ENUM_VALUE16177": 16689,
+		"ENUM_VALUE16178": 16690,
+		"ENUM_VALUE16179": 16691,
+		"ENUM_VALUE16180": 16692,
+		"ENUM_VALUE16181": 16693,
+		"ENUM_VALUE16182": 16694,
+		"ENUM_VALUE16183": 16695,
+		"ENUM_VALUE16184": 1044,
+		"ENUM_VALUE16185": 16705,
+		"ENUM_VALUE16186": 16706,
+		"ENUM_VALUE16187": 16707,
+		"ENUM_VALUE16188": 16708,
+		"ENUM_VALUE16189": 16709,
+		"ENUM_VALUE16190": 16710,
+		"ENUM_VALUE16191": 16711,
+		"ENUM_VALUE16192": 16712,
+		"ENUM_VALUE16193": 16713,
+		"ENUM_VALUE16194": 1046,
+		"ENUM_VALUE16195": 16737,
+		"ENUM_VALUE16196": 1047,
+		"ENUM_VALUE16197": 16753,
+		"ENUM_VALUE16198": 268049,
+		"ENUM_VALUE16199": 268050,
+		"ENUM_VALUE16200": 268051,
+		"ENUM_VALUE16201": 268052,
+		"ENUM_VALUE16202": 1048,
+		"ENUM_VALUE16203": 16769,
+		"ENUM_VALUE16204": 16770,
+		"ENUM_VALUE16205": 16771,
+		"ENUM_VALUE16206": 16772,
+		"ENUM_VALUE16207": 16773,
+		"ENUM_VALUE16208": 1049,
+		"ENUM_VALUE16209": 1056,
+		"ENUM_VALUE16210": 1058,
+		"ENUM_VALUE16211": 1059,
+		"ENUM_VALUE16212": 1060,
+		"ENUM_VALUE16213": 1061,
+		"ENUM_VALUE16214": 5,
+		"ENUM_VALUE16215": 6,
+		"ENUM_VALUE16216": 97,
+		"ENUM_VALUE16217": 98,
+		"ENUM_VALUE16218": 99,
+		"ENUM_VALUE16219": 100,
+		"ENUM_VALUE16220": 101,
+		"ENUM_VALUE16221": 102,
+		"ENUM_VALUE16222": 103,
+		"ENUM_VALUE16223": 104,
+		"ENUM_VALUE16224": 105,
+		"ENUM_VALUE16225": 106,
+		"ENUM_VALUE16226": 108,
+		"ENUM_VALUE16227": 1729,
+		"ENUM_VALUE16228": 1730,
+		"ENUM_VALUE16229": 1731,
+		"ENUM_VALUE16230": 7,
+		"ENUM_VALUE16231": 8,
+		"ENUM_VALUE16232": 9,
+		"ENUM_VALUE16233": 10,
+		"ENUM_VALUE16234": 161,
+		"ENUM_VALUE16235": 2577,
+		"ENUM_VALUE16236": 41233,
+		"ENUM_VALUE16237": 41234,
+		"ENUM_VALUE16238": 2578,
+		"ENUM_VALUE16239": 2579,
+		"ENUM_VALUE16240": 41265,
+		"ENUM_VALUE16241": 2580,
+		"ENUM_VALUE16242": 2581,
+		"ENUM_VALUE16243": 41297,
+		"ENUM_VALUE16244": 41298,
+		"ENUM_VALUE16245": 41299,
+		"ENUM_VALUE16246": 41300,
+		"ENUM_VALUE16247": 2582,
+		"ENUM_VALUE16248": 2583,
+		"ENUM_VALUE16249": 2584,
+		"ENUM_VALUE16250": 162,
+		"ENUM_VALUE16251": 2593,
+		"ENUM_VALUE16252": 41489,
+		"ENUM_VALUE16253": 663825,
+		"ENUM_VALUE16254": 663826,
+		"ENUM_VALUE16255": 41490,
+		"ENUM_VALUE16256": 41491,
+		"ENUM_VALUE16257": 41492,
+		"ENUM_VALUE16258": 663873,
+		"ENUM_VALUE16259": 2594,
+		"ENUM_VALUE16260": 41505,
+		"ENUM_VALUE16261": 41506,
+		"ENUM_VALUE16262": 41507,
+		"ENUM_VALUE16263": 2595,
+		"ENUM_VALUE16264": 41521,
+		"ENUM_VALUE16265": 41522,
+		"ENUM_VALUE16266": 41523,
+		"ENUM_VALUE16267": 41524,
+		"ENUM_VALUE16268": 41525,
+		"ENUM_VALUE16269": 664401,
+		"ENUM_VALUE16270": 664402,
+		"ENUM_VALUE16271": 41526,
+		"ENUM_VALUE16272": 41527,
+		"ENUM_VALUE16273": 2596,
+		"ENUM_VALUE16274": 2597,
+		"ENUM_VALUE16275": 2598,
+		"ENUM_VALUE16276": 41569,
+		"ENUM_VALUE16277": 41570,
+		"ENUM_VALUE16278": 41571,
+		"ENUM_VALUE16279": 41572,
+		"ENUM_VALUE16280": 41573,
+		"ENUM_VALUE16281": 665169,
+		"ENUM_VALUE16282": 665170,
+		"ENUM_VALUE16283": 665171,
+		"ENUM_VALUE16284": 665172,
+		"ENUM_VALUE16285": 2599,
+		"ENUM_VALUE16286": 2600,
+		"ENUM_VALUE16287": 2601,
+		"ENUM_VALUE16288": 2603,
+		"ENUM_VALUE16289": 2604,
+		"ENUM_VALUE16290": 163,
+		"ENUM_VALUE16291": 2608,
+		"ENUM_VALUE16292": 2609,
+		"ENUM_VALUE16293": 2610,
+		"ENUM_VALUE16294": 2611,
+		"ENUM_VALUE16295": 2612,
+		"ENUM_VALUE16296": 164,
+		"ENUM_VALUE16297": 2625,
+		"ENUM_VALUE16298": 2626,
+		"ENUM_VALUE16299": 42017,
+		"ENUM_VALUE16300": 42018,
+		"ENUM_VALUE16301": 42019,
+		"ENUM_VALUE16302": 2627,
+		"ENUM_VALUE16303": 2628,
+		"ENUM_VALUE16304": 165,
+		"ENUM_VALUE16305": 2641,
+		"ENUM_VALUE16306": 42257,
+		"ENUM_VALUE16307": 42258,
+		"ENUM_VALUE16308": 2642,
+		"ENUM_VALUE16309": 2643,
+		"ENUM_VALUE16310": 2644,
+		"ENUM_VALUE16311": 2646,
+		"ENUM_VALUE16312": 2647,
+		"ENUM_VALUE16313": 42353,
+		"ENUM_VALUE16314": 2648,
+		"ENUM_VALUE16315": 2649,
+		"ENUM_VALUE16316": 2650,
+		"ENUM_VALUE16317": 2651,
+		"ENUM_VALUE16318": 2652,
+		"ENUM_VALUE16319": 2653,
+		"ENUM_VALUE16320": 2654,
+		"ENUM_VALUE16321": 42481,
+		"ENUM_VALUE16322": 42482,
+		"ENUM_VALUE16323": 42483,
+		"ENUM_VALUE16324": 166,
+		"ENUM_VALUE16325": 2657,
+		"ENUM_VALUE16326": 2658,
+		"ENUM_VALUE16327": 42529,
+		"ENUM_VALUE16328": 2659,
+		"ENUM_VALUE16329": 2660,
+		"ENUM_VALUE16330": 2661,
+		"ENUM_VALUE16331": 2662,
+		"ENUM_VALUE16332": 2663,
+		"ENUM_VALUE16333": 42609,
+		"ENUM_VALUE16334": 2664,
+		"ENUM_VALUE16335": 2665,
+		"ENUM_VALUE16336": 42753,
+		"ENUM_VALUE16337": 42754,
+		"ENUM_VALUE16338": 42755,
+		"ENUM_VALUE16339": 11,
+		"ENUM_VALUE16340": 177,
+		"ENUM_VALUE16341": 2833,
+		"ENUM_VALUE16342": 179,
+		"ENUM_VALUE16343": 180,
+		"ENUM_VALUE16344": 2881,
+		"ENUM_VALUE16345": 182,
+		"ENUM_VALUE16346": 183,
+		"ENUM_VALUE16347": 12,
+		"ENUM_VALUE16348": 3089,
+		"ENUM_VALUE16349": 194,
+		"ENUM_VALUE16350": 195,
+		"ENUM_VALUE16351": 196,
+		"ENUM_VALUE16352": 198,
+		"ENUM_VALUE16353": 3169,
+		"ENUM_VALUE16354": 199,
+		"ENUM_VALUE16355": 200,
+		"ENUM_VALUE16356": 208,
+		"ENUM_VALUE16357": 3329,
+		"ENUM_VALUE16358": 3330,
+		"ENUM_VALUE16359": 3331,
+		"ENUM_VALUE16360": 209,
+		"ENUM_VALUE16361": 210,
+		"ENUM_VALUE16362": 211,
+		"ENUM_VALUE16363": 3377,
+		"ENUM_VALUE16364": 3378,
+		"ENUM_VALUE16365": 3379,
+		"ENUM_VALUE16366": 3380,
+		"ENUM_VALUE16367": 3381,
+		"ENUM_VALUE16368": 865809,
+		"ENUM_VALUE16369": 865810,
+		"ENUM_VALUE16370": 865811,
+		"ENUM_VALUE16371": 865812,
+		"ENUM_VALUE16372": 865813,
+		"ENUM_VALUE16373": 865814,
+		"ENUM_VALUE16374": 865815,
+		"ENUM_VALUE16375": 865816,
+		"ENUM_VALUE16376": 865817,
+		"ENUM_VALUE16377": 865818,
+		"ENUM_VALUE16378": 865819,
+		"ENUM_VALUE16379": 865820,
+		"ENUM_VALUE16380": 865821,
+		"ENUM_VALUE16381": 865822,
+		"ENUM_VALUE16382": 865823,
+		"ENUM_VALUE16383": 865824,
+		"ENUM_VALUE16384": 865825,
+		"ENUM_VALUE16385": 865826,
+		"ENUM_VALUE16386": 865827,
+		"ENUM_VALUE16387": 865828,
+		"ENUM_VALUE16388": 865829,
+		"ENUM_VALUE16389": 212,
+		"ENUM_VALUE16390": 3393,
+		"ENUM_VALUE16391": 3394,
+		"ENUM_VALUE16392": 3395,
+		"ENUM_VALUE16393": 213,
+		"ENUM_VALUE16394": 214,
+		"ENUM_VALUE16395": 215,
+		"ENUM_VALUE16396": 3441,
+		"ENUM_VALUE16397": 3442,
+		"ENUM_VALUE16398": 216,
+		"ENUM_VALUE16399": 217,
+		"ENUM_VALUE16400": 3473,
+		"ENUM_VALUE16401": 3474,
+		"ENUM_VALUE16402": 3475,
+		"ENUM_VALUE16403": 254,
+		"ENUM_VALUE16404": 255,
+	}
+)
+
+func (x Enum16042) Enum() *Enum16042 {
+	p := new(Enum16042)
+	*p = x
+	return p
+}
+
+func (x Enum16042) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum16042) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[41].Descriptor()
+}
+
+func (Enum16042) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[41]
+}
+
+func (x Enum16042) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum16042) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum16042(num)
+	return nil
+}
+
+// Deprecated: Use Enum16042.Descriptor instead.
+func (Enum16042) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{41}
+}
+
+type Enum16553 int32
+
+const (
+	Enum16553_ENUM_VALUE16554 Enum16553 = 0
+	Enum16553_ENUM_VALUE16555 Enum16553 = 1
+	Enum16553_ENUM_VALUE16556 Enum16553 = 2
+	Enum16553_ENUM_VALUE16557 Enum16553 = 3
+	Enum16553_ENUM_VALUE16558 Enum16553 = 4
+	Enum16553_ENUM_VALUE16559 Enum16553 = 5
+	Enum16553_ENUM_VALUE16560 Enum16553 = 6
+	Enum16553_ENUM_VALUE16561 Enum16553 = 7
+	Enum16553_ENUM_VALUE16562 Enum16553 = 8
+	Enum16553_ENUM_VALUE16563 Enum16553 = 9
+)
+
+// Enum value maps for Enum16553.
+var (
+	Enum16553_name = map[int32]string{
+		0: "ENUM_VALUE16554",
+		1: "ENUM_VALUE16555",
+		2: "ENUM_VALUE16556",
+		3: "ENUM_VALUE16557",
+		4: "ENUM_VALUE16558",
+		5: "ENUM_VALUE16559",
+		6: "ENUM_VALUE16560",
+		7: "ENUM_VALUE16561",
+		8: "ENUM_VALUE16562",
+		9: "ENUM_VALUE16563",
+	}
+	Enum16553_value = map[string]int32{
+		"ENUM_VALUE16554": 0,
+		"ENUM_VALUE16555": 1,
+		"ENUM_VALUE16556": 2,
+		"ENUM_VALUE16557": 3,
+		"ENUM_VALUE16558": 4,
+		"ENUM_VALUE16559": 5,
+		"ENUM_VALUE16560": 6,
+		"ENUM_VALUE16561": 7,
+		"ENUM_VALUE16562": 8,
+		"ENUM_VALUE16563": 9,
+	}
+)
+
+func (x Enum16553) Enum() *Enum16553 {
+	p := new(Enum16553)
+	*p = x
+	return p
+}
+
+func (x Enum16553) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum16553) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[42].Descriptor()
+}
+
+func (Enum16553) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[42]
+}
+
+func (x Enum16553) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum16553) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum16553(num)
+	return nil
+}
+
+// Deprecated: Use Enum16553.Descriptor instead.
+func (Enum16553) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{42}
+}
+
+type Enum16728 int32
+
+const (
+	Enum16728_ENUM_VALUE16729 Enum16728 = 1
+	Enum16728_ENUM_VALUE16730 Enum16728 = 2
+	Enum16728_ENUM_VALUE16731 Enum16728 = 3
+)
+
+// Enum value maps for Enum16728.
+var (
+	Enum16728_name = map[int32]string{
+		1: "ENUM_VALUE16729",
+		2: "ENUM_VALUE16730",
+		3: "ENUM_VALUE16731",
+	}
+	Enum16728_value = map[string]int32{
+		"ENUM_VALUE16729": 1,
+		"ENUM_VALUE16730": 2,
+		"ENUM_VALUE16731": 3,
+	}
+)
+
+func (x Enum16728) Enum() *Enum16728 {
+	p := new(Enum16728)
+	*p = x
+	return p
+}
+
+func (x Enum16728) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum16728) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[43].Descriptor()
+}
+
+func (Enum16728) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[43]
+}
+
+func (x Enum16728) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum16728) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum16728(num)
+	return nil
+}
+
+// Deprecated: Use Enum16728.Descriptor instead.
+func (Enum16728) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{43}
+}
+
+type Enum16732 int32
+
+const (
+	Enum16732_ENUM_VALUE16733 Enum16732 = 1
+	Enum16732_ENUM_VALUE16734 Enum16732 = 2
+	Enum16732_ENUM_VALUE16735 Enum16732 = 3
+	Enum16732_ENUM_VALUE16736 Enum16732 = 4
+	Enum16732_ENUM_VALUE16737 Enum16732 = 5
+)
+
+// Enum value maps for Enum16732.
+var (
+	Enum16732_name = map[int32]string{
+		1: "ENUM_VALUE16733",
+		2: "ENUM_VALUE16734",
+		3: "ENUM_VALUE16735",
+		4: "ENUM_VALUE16736",
+		5: "ENUM_VALUE16737",
+	}
+	Enum16732_value = map[string]int32{
+		"ENUM_VALUE16733": 1,
+		"ENUM_VALUE16734": 2,
+		"ENUM_VALUE16735": 3,
+		"ENUM_VALUE16736": 4,
+		"ENUM_VALUE16737": 5,
+	}
+)
+
+func (x Enum16732) Enum() *Enum16732 {
+	p := new(Enum16732)
+	*p = x
+	return p
+}
+
+func (x Enum16732) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum16732) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[44].Descriptor()
+}
+
+func (Enum16732) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[44]
+}
+
+func (x Enum16732) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum16732) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum16732(num)
+	return nil
+}
+
+// Deprecated: Use Enum16732.Descriptor instead.
+func (Enum16732) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{44}
+}
+
+type Enum16738 int32
+
+const (
+	Enum16738_ENUM_VALUE16739 Enum16738 = 1
+	Enum16738_ENUM_VALUE16740 Enum16738 = 2
+	Enum16738_ENUM_VALUE16741 Enum16738 = 3
+	Enum16738_ENUM_VALUE16742 Enum16738 = 4
+	Enum16738_ENUM_VALUE16743 Enum16738 = 5
+	Enum16738_ENUM_VALUE16744 Enum16738 = 6
+	Enum16738_ENUM_VALUE16745 Enum16738 = 7
+)
+
+// Enum value maps for Enum16738.
+var (
+	Enum16738_name = map[int32]string{
+		1: "ENUM_VALUE16739",
+		2: "ENUM_VALUE16740",
+		3: "ENUM_VALUE16741",
+		4: "ENUM_VALUE16742",
+		5: "ENUM_VALUE16743",
+		6: "ENUM_VALUE16744",
+		7: "ENUM_VALUE16745",
+	}
+	Enum16738_value = map[string]int32{
+		"ENUM_VALUE16739": 1,
+		"ENUM_VALUE16740": 2,
+		"ENUM_VALUE16741": 3,
+		"ENUM_VALUE16742": 4,
+		"ENUM_VALUE16743": 5,
+		"ENUM_VALUE16744": 6,
+		"ENUM_VALUE16745": 7,
+	}
+)
+
+func (x Enum16738) Enum() *Enum16738 {
+	p := new(Enum16738)
+	*p = x
+	return p
+}
+
+func (x Enum16738) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum16738) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[45].Descriptor()
+}
+
+func (Enum16738) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[45]
+}
+
+func (x Enum16738) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum16738) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum16738(num)
+	return nil
+}
+
+// Deprecated: Use Enum16738.Descriptor instead.
+func (Enum16738) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{45}
+}
+
+type Enum16698 int32
+
+const (
+	Enum16698_ENUM_VALUE16699 Enum16698 = -1
+	Enum16698_ENUM_VALUE16700 Enum16698 = 100
+	Enum16698_ENUM_VALUE16701 Enum16698 = 2
+	Enum16698_ENUM_VALUE16702 Enum16698 = 0
+	Enum16698_ENUM_VALUE16703 Enum16698 = 1
+	Enum16698_ENUM_VALUE16704 Enum16698 = 4
+	Enum16698_ENUM_VALUE16705 Enum16698 = 11
+	Enum16698_ENUM_VALUE16706 Enum16698 = 12
+	Enum16698_ENUM_VALUE16707 Enum16698 = 3
+	Enum16698_ENUM_VALUE16708 Enum16698 = 5
+	Enum16698_ENUM_VALUE16709 Enum16698 = 6
+	Enum16698_ENUM_VALUE16710 Enum16698 = 7
+	Enum16698_ENUM_VALUE16711 Enum16698 = 8
+	Enum16698_ENUM_VALUE16712 Enum16698 = 9
+	Enum16698_ENUM_VALUE16713 Enum16698 = 10
+	Enum16698_ENUM_VALUE16714 Enum16698 = 13
+	Enum16698_ENUM_VALUE16715 Enum16698 = 14
+	Enum16698_ENUM_VALUE16716 Enum16698 = 15
+	Enum16698_ENUM_VALUE16717 Enum16698 = 16
+	Enum16698_ENUM_VALUE16718 Enum16698 = 18
+	Enum16698_ENUM_VALUE16719 Enum16698 = 17
+	Enum16698_ENUM_VALUE16720 Enum16698 = 19
+	Enum16698_ENUM_VALUE16721 Enum16698 = 20
+)
+
+// Enum value maps for Enum16698.
+var (
+	Enum16698_name = map[int32]string{
+		-1:  "ENUM_VALUE16699",
+		100: "ENUM_VALUE16700",
+		2:   "ENUM_VALUE16701",
+		0:   "ENUM_VALUE16702",
+		1:   "ENUM_VALUE16703",
+		4:   "ENUM_VALUE16704",
+		11:  "ENUM_VALUE16705",
+		12:  "ENUM_VALUE16706",
+		3:   "ENUM_VALUE16707",
+		5:   "ENUM_VALUE16708",
+		6:   "ENUM_VALUE16709",
+		7:   "ENUM_VALUE16710",
+		8:   "ENUM_VALUE16711",
+		9:   "ENUM_VALUE16712",
+		10:  "ENUM_VALUE16713",
+		13:  "ENUM_VALUE16714",
+		14:  "ENUM_VALUE16715",
+		15:  "ENUM_VALUE16716",
+		16:  "ENUM_VALUE16717",
+		18:  "ENUM_VALUE16718",
+		17:  "ENUM_VALUE16719",
+		19:  "ENUM_VALUE16720",
+		20:  "ENUM_VALUE16721",
+	}
+	Enum16698_value = map[string]int32{
+		"ENUM_VALUE16699": -1,
+		"ENUM_VALUE16700": 100,
+		"ENUM_VALUE16701": 2,
+		"ENUM_VALUE16702": 0,
+		"ENUM_VALUE16703": 1,
+		"ENUM_VALUE16704": 4,
+		"ENUM_VALUE16705": 11,
+		"ENUM_VALUE16706": 12,
+		"ENUM_VALUE16707": 3,
+		"ENUM_VALUE16708": 5,
+		"ENUM_VALUE16709": 6,
+		"ENUM_VALUE16710": 7,
+		"ENUM_VALUE16711": 8,
+		"ENUM_VALUE16712": 9,
+		"ENUM_VALUE16713": 10,
+		"ENUM_VALUE16714": 13,
+		"ENUM_VALUE16715": 14,
+		"ENUM_VALUE16716": 15,
+		"ENUM_VALUE16717": 16,
+		"ENUM_VALUE16718": 18,
+		"ENUM_VALUE16719": 17,
+		"ENUM_VALUE16720": 19,
+		"ENUM_VALUE16721": 20,
+	}
+)
+
+func (x Enum16698) Enum() *Enum16698 {
+	p := new(Enum16698)
+	*p = x
+	return p
+}
+
+func (x Enum16698) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum16698) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[46].Descriptor()
+}
+
+func (Enum16698) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[46]
+}
+
+func (x Enum16698) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum16698) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum16698(num)
+	return nil
+}
+
+// Deprecated: Use Enum16698.Descriptor instead.
+func (Enum16698) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{46}
+}
+
+type Enum16819 int32
+
+const (
+	Enum16819_ENUM_VALUE16820 Enum16819 = 0
+	Enum16819_ENUM_VALUE16821 Enum16819 = 1
+	Enum16819_ENUM_VALUE16822 Enum16819 = 2
+	Enum16819_ENUM_VALUE16823 Enum16819 = 3
+	Enum16819_ENUM_VALUE16824 Enum16819 = 4
+	Enum16819_ENUM_VALUE16825 Enum16819 = 5
+)
+
+// Enum value maps for Enum16819.
+var (
+	Enum16819_name = map[int32]string{
+		0: "ENUM_VALUE16820",
+		1: "ENUM_VALUE16821",
+		2: "ENUM_VALUE16822",
+		3: "ENUM_VALUE16823",
+		4: "ENUM_VALUE16824",
+		5: "ENUM_VALUE16825",
+	}
+	Enum16819_value = map[string]int32{
+		"ENUM_VALUE16820": 0,
+		"ENUM_VALUE16821": 1,
+		"ENUM_VALUE16822": 2,
+		"ENUM_VALUE16823": 3,
+		"ENUM_VALUE16824": 4,
+		"ENUM_VALUE16825": 5,
+	}
+)
+
+func (x Enum16819) Enum() *Enum16819 {
+	p := new(Enum16819)
+	*p = x
+	return p
+}
+
+func (x Enum16819) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum16819) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[47].Descriptor()
+}
+
+func (Enum16819) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[47]
+}
+
+func (x Enum16819) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum16819) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum16819(num)
+	return nil
+}
+
+// Deprecated: Use Enum16819.Descriptor instead.
+func (Enum16819) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{47}
+}
+
+type Enum16925 int32
+
+const (
+	Enum16925_ENUM_VALUE16926 Enum16925 = 0
+	Enum16925_ENUM_VALUE16927 Enum16925 = 1
+	Enum16925_ENUM_VALUE16928 Enum16925 = 2
+	Enum16925_ENUM_VALUE16929 Enum16925 = 3
+	Enum16925_ENUM_VALUE16930 Enum16925 = 4
+	Enum16925_ENUM_VALUE16931 Enum16925 = 5
+	Enum16925_ENUM_VALUE16932 Enum16925 = 6
+	Enum16925_ENUM_VALUE16933 Enum16925 = 7
+	Enum16925_ENUM_VALUE16934 Enum16925 = 8
+	Enum16925_ENUM_VALUE16935 Enum16925 = 9
+	Enum16925_ENUM_VALUE16936 Enum16925 = 10
+	Enum16925_ENUM_VALUE16937 Enum16925 = 11
+	Enum16925_ENUM_VALUE16938 Enum16925 = 12
+	Enum16925_ENUM_VALUE16939 Enum16925 = 13
+)
+
+// Enum value maps for Enum16925.
+var (
+	Enum16925_name = map[int32]string{
+		0:  "ENUM_VALUE16926",
+		1:  "ENUM_VALUE16927",
+		2:  "ENUM_VALUE16928",
+		3:  "ENUM_VALUE16929",
+		4:  "ENUM_VALUE16930",
+		5:  "ENUM_VALUE16931",
+		6:  "ENUM_VALUE16932",
+		7:  "ENUM_VALUE16933",
+		8:  "ENUM_VALUE16934",
+		9:  "ENUM_VALUE16935",
+		10: "ENUM_VALUE16936",
+		11: "ENUM_VALUE16937",
+		12: "ENUM_VALUE16938",
+		13: "ENUM_VALUE16939",
+	}
+	Enum16925_value = map[string]int32{
+		"ENUM_VALUE16926": 0,
+		"ENUM_VALUE16927": 1,
+		"ENUM_VALUE16928": 2,
+		"ENUM_VALUE16929": 3,
+		"ENUM_VALUE16930": 4,
+		"ENUM_VALUE16931": 5,
+		"ENUM_VALUE16932": 6,
+		"ENUM_VALUE16933": 7,
+		"ENUM_VALUE16934": 8,
+		"ENUM_VALUE16935": 9,
+		"ENUM_VALUE16936": 10,
+		"ENUM_VALUE16937": 11,
+		"ENUM_VALUE16938": 12,
+		"ENUM_VALUE16939": 13,
+	}
+)
+
+func (x Enum16925) Enum() *Enum16925 {
+	p := new(Enum16925)
+	*p = x
+	return p
+}
+
+func (x Enum16925) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum16925) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[48].Descriptor()
+}
+
+func (Enum16925) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[48]
+}
+
+func (x Enum16925) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum16925) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum16925(num)
+	return nil
+}
+
+// Deprecated: Use Enum16925.Descriptor instead.
+func (Enum16925) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{48}
+}
+
+type Enum22854 int32
+
+const (
+	Enum22854_ENUM_VALUE22855 Enum22854 = 0
+	Enum22854_ENUM_VALUE22856 Enum22854 = 1
+)
+
+// Enum value maps for Enum22854.
+var (
+	Enum22854_name = map[int32]string{
+		0: "ENUM_VALUE22855",
+		1: "ENUM_VALUE22856",
+	}
+	Enum22854_value = map[string]int32{
+		"ENUM_VALUE22855": 0,
+		"ENUM_VALUE22856": 1,
+	}
+)
+
+func (x Enum22854) Enum() *Enum22854 {
+	p := new(Enum22854)
+	*p = x
+	return p
+}
+
+func (x Enum22854) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum22854) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[49].Descriptor()
+}
+
+func (Enum22854) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[49]
+}
+
+func (x Enum22854) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum22854) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum22854(num)
+	return nil
+}
+
+// Deprecated: Use Enum22854.Descriptor instead.
+func (Enum22854) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{49}
+}
+
+type Enum24361 int32
+
+const (
+	Enum24361_ENUM_VALUE24362 Enum24361 = 0
+	Enum24361_ENUM_VALUE24363 Enum24361 = 1
+	Enum24361_ENUM_VALUE24364 Enum24361 = 2
+	Enum24361_ENUM_VALUE24365 Enum24361 = 3
+)
+
+// Enum value maps for Enum24361.
+var (
+	Enum24361_name = map[int32]string{
+		0: "ENUM_VALUE24362",
+		1: "ENUM_VALUE24363",
+		2: "ENUM_VALUE24364",
+		3: "ENUM_VALUE24365",
+	}
+	Enum24361_value = map[string]int32{
+		"ENUM_VALUE24362": 0,
+		"ENUM_VALUE24363": 1,
+		"ENUM_VALUE24364": 2,
+		"ENUM_VALUE24365": 3,
+	}
+)
+
+func (x Enum24361) Enum() *Enum24361 {
+	p := new(Enum24361)
+	*p = x
+	return p
+}
+
+func (x Enum24361) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum24361) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[50].Descriptor()
+}
+
+func (Enum24361) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[50]
+}
+
+func (x Enum24361) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum24361) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum24361(num)
+	return nil
+}
+
+// Deprecated: Use Enum24361.Descriptor instead.
+func (Enum24361) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{50}
+}
+
+type Enum16891 int32
+
+const (
+	Enum16891_ENUM_VALUE16892 Enum16891 = 0
+	Enum16891_ENUM_VALUE16893 Enum16891 = 1
+	Enum16891_ENUM_VALUE16894 Enum16891 = 2
+	Enum16891_ENUM_VALUE16895 Enum16891 = 3
+	Enum16891_ENUM_VALUE16896 Enum16891 = 4
+	Enum16891_ENUM_VALUE16897 Enum16891 = 5
+	Enum16891_ENUM_VALUE16898 Enum16891 = 6
+	Enum16891_ENUM_VALUE16899 Enum16891 = 7
+	Enum16891_ENUM_VALUE16900 Enum16891 = 8
+	Enum16891_ENUM_VALUE16901 Enum16891 = 9
+	Enum16891_ENUM_VALUE16902 Enum16891 = 10
+	Enum16891_ENUM_VALUE16903 Enum16891 = 11
+	Enum16891_ENUM_VALUE16904 Enum16891 = 12
+	Enum16891_ENUM_VALUE16905 Enum16891 = 13
+	Enum16891_ENUM_VALUE16906 Enum16891 = 14
+	Enum16891_ENUM_VALUE16907 Enum16891 = 15
+	Enum16891_ENUM_VALUE16908 Enum16891 = 16
+	Enum16891_ENUM_VALUE16909 Enum16891 = 17
+	Enum16891_ENUM_VALUE16910 Enum16891 = 18
+	Enum16891_ENUM_VALUE16911 Enum16891 = 19
+	Enum16891_ENUM_VALUE16912 Enum16891 = 20
+	Enum16891_ENUM_VALUE16913 Enum16891 = 21
+	Enum16891_ENUM_VALUE16914 Enum16891 = 22
+	Enum16891_ENUM_VALUE16915 Enum16891 = 23
+	Enum16891_ENUM_VALUE16916 Enum16891 = 24
+	Enum16891_ENUM_VALUE16917 Enum16891 = 25
+	Enum16891_ENUM_VALUE16918 Enum16891 = 26
+	Enum16891_ENUM_VALUE16919 Enum16891 = 27
+	Enum16891_ENUM_VALUE16920 Enum16891 = 28
+	Enum16891_ENUM_VALUE16921 Enum16891 = 29
+	Enum16891_ENUM_VALUE16922 Enum16891 = 30
+	Enum16891_ENUM_VALUE16923 Enum16891 = 31
+)
+
+// Enum value maps for Enum16891.
+var (
+	Enum16891_name = map[int32]string{
+		0:  "ENUM_VALUE16892",
+		1:  "ENUM_VALUE16893",
+		2:  "ENUM_VALUE16894",
+		3:  "ENUM_VALUE16895",
+		4:  "ENUM_VALUE16896",
+		5:  "ENUM_VALUE16897",
+		6:  "ENUM_VALUE16898",
+		7:  "ENUM_VALUE16899",
+		8:  "ENUM_VALUE16900",
+		9:  "ENUM_VALUE16901",
+		10: "ENUM_VALUE16902",
+		11: "ENUM_VALUE16903",
+		12: "ENUM_VALUE16904",
+		13: "ENUM_VALUE16905",
+		14: "ENUM_VALUE16906",
+		15: "ENUM_VALUE16907",
+		16: "ENUM_VALUE16908",
+		17: "ENUM_VALUE16909",
+		18: "ENUM_VALUE16910",
+		19: "ENUM_VALUE16911",
+		20: "ENUM_VALUE16912",
+		21: "ENUM_VALUE16913",
+		22: "ENUM_VALUE16914",
+		23: "ENUM_VALUE16915",
+		24: "ENUM_VALUE16916",
+		25: "ENUM_VALUE16917",
+		26: "ENUM_VALUE16918",
+		27: "ENUM_VALUE16919",
+		28: "ENUM_VALUE16920",
+		29: "ENUM_VALUE16921",
+		30: "ENUM_VALUE16922",
+		31: "ENUM_VALUE16923",
+	}
+	Enum16891_value = map[string]int32{
+		"ENUM_VALUE16892": 0,
+		"ENUM_VALUE16893": 1,
+		"ENUM_VALUE16894": 2,
+		"ENUM_VALUE16895": 3,
+		"ENUM_VALUE16896": 4,
+		"ENUM_VALUE16897": 5,
+		"ENUM_VALUE16898": 6,
+		"ENUM_VALUE16899": 7,
+		"ENUM_VALUE16900": 8,
+		"ENUM_VALUE16901": 9,
+		"ENUM_VALUE16902": 10,
+		"ENUM_VALUE16903": 11,
+		"ENUM_VALUE16904": 12,
+		"ENUM_VALUE16905": 13,
+		"ENUM_VALUE16906": 14,
+		"ENUM_VALUE16907": 15,
+		"ENUM_VALUE16908": 16,
+		"ENUM_VALUE16909": 17,
+		"ENUM_VALUE16910": 18,
+		"ENUM_VALUE16911": 19,
+		"ENUM_VALUE16912": 20,
+		"ENUM_VALUE16913": 21,
+		"ENUM_VALUE16914": 22,
+		"ENUM_VALUE16915": 23,
+		"ENUM_VALUE16916": 24,
+		"ENUM_VALUE16917": 25,
+		"ENUM_VALUE16918": 26,
+		"ENUM_VALUE16919": 27,
+		"ENUM_VALUE16920": 28,
+		"ENUM_VALUE16921": 29,
+		"ENUM_VALUE16922": 30,
+		"ENUM_VALUE16923": 31,
+	}
+)
+
+func (x Enum16891) Enum() *Enum16891 {
+	p := new(Enum16891)
+	*p = x
+	return p
+}
+
+func (x Enum16891) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum16891) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[51].Descriptor()
+}
+
+func (Enum16891) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[51]
+}
+
+func (x Enum16891) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum16891) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum16891(num)
+	return nil
+}
+
+// Deprecated: Use Enum16891.Descriptor instead.
+func (Enum16891) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{51}
+}
+
+type Enum27361 int32
+
+const (
+	Enum27361_ENUM_VALUE27362 Enum27361 = 0
+	Enum27361_ENUM_VALUE27363 Enum27361 = 1
+	Enum27361_ENUM_VALUE27364 Enum27361 = 2
+	Enum27361_ENUM_VALUE27365 Enum27361 = 3
+	Enum27361_ENUM_VALUE27366 Enum27361 = 4
+)
+
+// Enum value maps for Enum27361.
+var (
+	Enum27361_name = map[int32]string{
+		0: "ENUM_VALUE27362",
+		1: "ENUM_VALUE27363",
+		2: "ENUM_VALUE27364",
+		3: "ENUM_VALUE27365",
+		4: "ENUM_VALUE27366",
+	}
+	Enum27361_value = map[string]int32{
+		"ENUM_VALUE27362": 0,
+		"ENUM_VALUE27363": 1,
+		"ENUM_VALUE27364": 2,
+		"ENUM_VALUE27365": 3,
+		"ENUM_VALUE27366": 4,
+	}
+)
+
+func (x Enum27361) Enum() *Enum27361 {
+	p := new(Enum27361)
+	*p = x
+	return p
+}
+
+func (x Enum27361) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum27361) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[52].Descriptor()
+}
+
+func (Enum27361) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[52]
+}
+
+func (x Enum27361) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum27361) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum27361(num)
+	return nil
+}
+
+// Deprecated: Use Enum27361.Descriptor instead.
+func (Enum27361) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{52}
+}
+
+type Enum33960 int32
+
+const (
+	Enum33960_ENUM_VALUE33961 Enum33960 = 0
+	Enum33960_ENUM_VALUE33962 Enum33960 = 1
+	Enum33960_ENUM_VALUE33963 Enum33960 = 2
+	Enum33960_ENUM_VALUE33964 Enum33960 = 3
+	Enum33960_ENUM_VALUE33965 Enum33960 = 4
+	Enum33960_ENUM_VALUE33966 Enum33960 = 5
+	Enum33960_ENUM_VALUE33967 Enum33960 = 6
+)
+
+// Enum value maps for Enum33960.
+var (
+	Enum33960_name = map[int32]string{
+		0: "ENUM_VALUE33961",
+		1: "ENUM_VALUE33962",
+		2: "ENUM_VALUE33963",
+		3: "ENUM_VALUE33964",
+		4: "ENUM_VALUE33965",
+		5: "ENUM_VALUE33966",
+		6: "ENUM_VALUE33967",
+	}
+	Enum33960_value = map[string]int32{
+		"ENUM_VALUE33961": 0,
+		"ENUM_VALUE33962": 1,
+		"ENUM_VALUE33963": 2,
+		"ENUM_VALUE33964": 3,
+		"ENUM_VALUE33965": 4,
+		"ENUM_VALUE33966": 5,
+		"ENUM_VALUE33967": 6,
+	}
+)
+
+func (x Enum33960) Enum() *Enum33960 {
+	p := new(Enum33960)
+	*p = x
+	return p
+}
+
+func (x Enum33960) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum33960) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[53].Descriptor()
+}
+
+func (Enum33960) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[53]
+}
+
+func (x Enum33960) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum33960) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum33960(num)
+	return nil
+}
+
+// Deprecated: Use Enum33960.Descriptor instead.
+func (Enum33960) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{53}
+}
+
+type Enum34388 int32
+
+const (
+	Enum34388_ENUM_VALUE34389 Enum34388 = 1
+)
+
+// Enum value maps for Enum34388.
+var (
+	Enum34388_name = map[int32]string{
+		1: "ENUM_VALUE34389",
+	}
+	Enum34388_value = map[string]int32{
+		"ENUM_VALUE34389": 1,
+	}
+)
+
+func (x Enum34388) Enum() *Enum34388 {
+	p := new(Enum34388)
+	*p = x
+	return p
+}
+
+func (x Enum34388) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum34388) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[54].Descriptor()
+}
+
+func (Enum34388) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[54]
+}
+
+func (x Enum34388) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum34388) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum34388(num)
+	return nil
+}
+
+// Deprecated: Use Enum34388.Descriptor instead.
+func (Enum34388) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{54}
+}
+
+type Enum35477 int32
+
+const (
+	Enum35477_ENUM_VALUE35478 Enum35477 = 4
+	Enum35477_ENUM_VALUE35479 Enum35477 = 3
+	Enum35477_ENUM_VALUE35480 Enum35477 = 2
+	Enum35477_ENUM_VALUE35481 Enum35477 = 1
+	Enum35477_ENUM_VALUE35482 Enum35477 = 0
+)
+
+// Enum value maps for Enum35477.
+var (
+	Enum35477_name = map[int32]string{
+		4: "ENUM_VALUE35478",
+		3: "ENUM_VALUE35479",
+		2: "ENUM_VALUE35480",
+		1: "ENUM_VALUE35481",
+		0: "ENUM_VALUE35482",
+	}
+	Enum35477_value = map[string]int32{
+		"ENUM_VALUE35478": 4,
+		"ENUM_VALUE35479": 3,
+		"ENUM_VALUE35480": 2,
+		"ENUM_VALUE35481": 1,
+		"ENUM_VALUE35482": 0,
+	}
+)
+
+func (x Enum35477) Enum() *Enum35477 {
+	p := new(Enum35477)
+	*p = x
+	return p
+}
+
+func (x Enum35477) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum35477) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[55].Descriptor()
+}
+
+func (Enum35477) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[55]
+}
+
+func (x Enum35477) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum35477) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum35477(num)
+	return nil
+}
+
+// Deprecated: Use Enum35477.Descriptor instead.
+func (Enum35477) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{55}
+}
+
+type Enum35507 int32
+
+const (
+	Enum35507_ENUM_VALUE35508 Enum35507 = 0
+	Enum35507_ENUM_VALUE35509 Enum35507 = 1
+	Enum35507_ENUM_VALUE35510 Enum35507 = 2
+	Enum35507_ENUM_VALUE35511 Enum35507 = 3
+	Enum35507_ENUM_VALUE35512 Enum35507 = 4
+	Enum35507_ENUM_VALUE35513 Enum35507 = 5
+	Enum35507_ENUM_VALUE35514 Enum35507 = 6
+	Enum35507_ENUM_VALUE35515 Enum35507 = 7
+	Enum35507_ENUM_VALUE35516 Enum35507 = 8
+	Enum35507_ENUM_VALUE35517 Enum35507 = 9
+)
+
+// Enum value maps for Enum35507.
+var (
+	Enum35507_name = map[int32]string{
+		0: "ENUM_VALUE35508",
+		1: "ENUM_VALUE35509",
+		2: "ENUM_VALUE35510",
+		3: "ENUM_VALUE35511",
+		4: "ENUM_VALUE35512",
+		5: "ENUM_VALUE35513",
+		6: "ENUM_VALUE35514",
+		7: "ENUM_VALUE35515",
+		8: "ENUM_VALUE35516",
+		9: "ENUM_VALUE35517",
+	}
+	Enum35507_value = map[string]int32{
+		"ENUM_VALUE35508": 0,
+		"ENUM_VALUE35509": 1,
+		"ENUM_VALUE35510": 2,
+		"ENUM_VALUE35511": 3,
+		"ENUM_VALUE35512": 4,
+		"ENUM_VALUE35513": 5,
+		"ENUM_VALUE35514": 6,
+		"ENUM_VALUE35515": 7,
+		"ENUM_VALUE35516": 8,
+		"ENUM_VALUE35517": 9,
+	}
+)
+
+func (x Enum35507) Enum() *Enum35507 {
+	p := new(Enum35507)
+	*p = x
+	return p
+}
+
+func (x Enum35507) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum35507) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[56].Descriptor()
+}
+
+func (Enum35507) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[56]
+}
+
+func (x Enum35507) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum35507) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum35507(num)
+	return nil
+}
+
+// Deprecated: Use Enum35507.Descriptor instead.
+func (Enum35507) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{56}
+}
+
+type Enum36860 int32
+
+const (
+	Enum36860_ENUM_VALUE36861 Enum36860 = 0
+	Enum36860_ENUM_VALUE36862 Enum36860 = 1
+	Enum36860_ENUM_VALUE36863 Enum36860 = 2
+	Enum36860_ENUM_VALUE36864 Enum36860 = 3
+	Enum36860_ENUM_VALUE36865 Enum36860 = 4
+	Enum36860_ENUM_VALUE36866 Enum36860 = 5
+	Enum36860_ENUM_VALUE36867 Enum36860 = 6
+	Enum36860_ENUM_VALUE36868 Enum36860 = 7
+)
+
+// Enum value maps for Enum36860.
+var (
+	Enum36860_name = map[int32]string{
+		0: "ENUM_VALUE36861",
+		1: "ENUM_VALUE36862",
+		2: "ENUM_VALUE36863",
+		3: "ENUM_VALUE36864",
+		4: "ENUM_VALUE36865",
+		5: "ENUM_VALUE36866",
+		6: "ENUM_VALUE36867",
+		7: "ENUM_VALUE36868",
+	}
+	Enum36860_value = map[string]int32{
+		"ENUM_VALUE36861": 0,
+		"ENUM_VALUE36862": 1,
+		"ENUM_VALUE36863": 2,
+		"ENUM_VALUE36864": 3,
+		"ENUM_VALUE36865": 4,
+		"ENUM_VALUE36866": 5,
+		"ENUM_VALUE36867": 6,
+		"ENUM_VALUE36868": 7,
+	}
+)
+
+func (x Enum36860) Enum() *Enum36860 {
+	p := new(Enum36860)
+	*p = x
+	return p
+}
+
+func (x Enum36860) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum36860) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[57].Descriptor()
+}
+
+func (Enum36860) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[57]
+}
+
+func (x Enum36860) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum36860) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum36860(num)
+	return nil
+}
+
+// Deprecated: Use Enum36860.Descriptor instead.
+func (Enum36860) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{57}
+}
+
+type Enum36890 int32
+
+const (
+	Enum36890_ENUM_VALUE36891 Enum36890 = 0
+	Enum36890_ENUM_VALUE36892 Enum36890 = 1
+)
+
+// Enum value maps for Enum36890.
+var (
+	Enum36890_name = map[int32]string{
+		0: "ENUM_VALUE36891",
+		1: "ENUM_VALUE36892",
+	}
+	Enum36890_value = map[string]int32{
+		"ENUM_VALUE36891": 0,
+		"ENUM_VALUE36892": 1,
+	}
+)
+
+func (x Enum36890) Enum() *Enum36890 {
+	p := new(Enum36890)
+	*p = x
+	return p
+}
+
+func (x Enum36890) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum36890) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[58].Descriptor()
+}
+
+func (Enum36890) Type() protoreflect.EnumType {
+	return &file_datasets_google_message3_benchmark_message3_8_proto_enumTypes[58]
+}
+
+func (x Enum36890) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum36890) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum36890(num)
+	return nil
+}
+
+// Deprecated: Use Enum36890.Descriptor instead.
+func (Enum36890) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP(), []int{58}
+}
+
+var File_datasets_google_message3_benchmark_message3_8_proto protoreflect.FileDescriptor
+
+var file_datasets_google_message3_benchmark_message3_8_proto_rawDesc = []byte{
+	0x0a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x5f, 0x38, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1a, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x2a, 0x2f, 0x0a, 0x07, 0x45, 0x6e, 0x75, 0x6d, 0x37, 0x32, 0x30, 0x12, 0x11, 0x0a, 0x0d,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x37, 0x32, 0x31, 0x10, 0x01, 0x12,
+	0x11, 0x0a, 0x0d, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x37, 0x32, 0x32,
+	0x10, 0x02, 0x2a, 0xa2, 0x1d, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x33, 0x34, 0x37, 0x36, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x34, 0x37,
+	0x37, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x34, 0x37, 0x38, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x34, 0x37, 0x39, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x34, 0x38, 0x30, 0x10, 0x03, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x34, 0x38,
+	0x31, 0x10, 0x04, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x34, 0x38, 0x32, 0x10, 0x05, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x34, 0x38, 0x33, 0x10, 0x06, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x34, 0x38, 0x34, 0x10, 0x07, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x34, 0x38,
+	0x35, 0x10, 0x08, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x34, 0x38, 0x36, 0x10, 0x09, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x34, 0x38, 0x37, 0x10, 0x0a, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x34, 0x38, 0x38, 0x10, 0x0b, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x34, 0x38,
+	0x39, 0x10, 0x0c, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x34, 0x39, 0x30, 0x10, 0x0d, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x34, 0x39, 0x31, 0x10, 0x0e, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x34, 0x39, 0x32, 0x10, 0x0f, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x34, 0x39,
+	0x33, 0x10, 0x10, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x34, 0x39, 0x34, 0x10, 0x11, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x34, 0x39, 0x35, 0x10, 0x12, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x34, 0x39, 0x36, 0x10, 0x13, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x34, 0x39,
+	0x37, 0x10, 0x14, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x34, 0x39, 0x38, 0x10, 0x15, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x34, 0x39, 0x39, 0x10, 0x16, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x30, 0x30, 0x10, 0x17, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x30,
+	0x31, 0x10, 0x18, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x35, 0x30, 0x32, 0x10, 0x19, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x30, 0x33, 0x10, 0x1a, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x30, 0x34, 0x10, 0x1b, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x30,
+	0x35, 0x10, 0x1c, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x35, 0x30, 0x36, 0x10, 0x1d, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x30, 0x37, 0x10, 0x1e, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x30, 0x38, 0x10, 0x1f, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x30,
+	0x39, 0x10, 0x20, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x35, 0x31, 0x30, 0x10, 0x21, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x31, 0x31, 0x10, 0x22, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x31, 0x32, 0x10, 0x23, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x31,
+	0x33, 0x10, 0x24, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x35, 0x31, 0x34, 0x10, 0x25, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x31, 0x35, 0x10, 0x26, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x31, 0x36, 0x10, 0x27, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x31,
+	0x37, 0x10, 0x28, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x35, 0x31, 0x38, 0x10, 0x29, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x31, 0x39, 0x10, 0x2a, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x32, 0x30, 0x10, 0x2b, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x32,
+	0x31, 0x10, 0x2c, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x35, 0x32, 0x32, 0x10, 0x2d, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x32, 0x33, 0x10, 0x2e, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x32, 0x34, 0x10, 0x2f, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x32,
+	0x35, 0x10, 0x30, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x35, 0x32, 0x36, 0x10, 0x31, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x32, 0x37, 0x10, 0x32, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x32, 0x38, 0x10, 0x33, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x32,
+	0x39, 0x10, 0x34, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x35, 0x33, 0x30, 0x10, 0x35, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x33, 0x31, 0x10, 0x36, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x33, 0x32, 0x10, 0x37, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x33,
+	0x33, 0x10, 0x38, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x35, 0x33, 0x34, 0x10, 0x39, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x33, 0x35, 0x10, 0x3a, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x33, 0x36, 0x10, 0x3b, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x33,
+	0x37, 0x10, 0x3c, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x35, 0x33, 0x38, 0x10, 0x3d, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x33, 0x39, 0x10, 0x3e, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x34, 0x30, 0x10, 0x3f, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x34,
+	0x31, 0x10, 0x40, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x35, 0x34, 0x32, 0x10, 0x41, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x34, 0x33, 0x10, 0x42, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x34, 0x34, 0x10, 0x43, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x34,
+	0x35, 0x10, 0x44, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x35, 0x34, 0x36, 0x10, 0x45, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x34, 0x37, 0x10, 0x46, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x34, 0x38, 0x10, 0x47, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x34,
+	0x39, 0x10, 0x48, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x35, 0x35, 0x30, 0x10, 0x49, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x35, 0x31, 0x10, 0x4a, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x35, 0x32, 0x10, 0x4b, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x35,
+	0x33, 0x10, 0x4c, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x35, 0x35, 0x34, 0x10, 0x4d, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x35, 0x35, 0x10, 0x4e, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x35, 0x36, 0x10, 0x4f, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x35,
+	0x37, 0x10, 0x50, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x35, 0x35, 0x38, 0x10, 0x51, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x35, 0x39, 0x10, 0x52, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x36, 0x30, 0x10, 0x53, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x36,
+	0x31, 0x10, 0x54, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x35, 0x36, 0x32, 0x10, 0x55, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x36, 0x33, 0x10, 0x56, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x36, 0x34, 0x10, 0x57, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x36,
+	0x35, 0x10, 0x58, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x35, 0x36, 0x36, 0x10, 0x59, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x36, 0x37, 0x10, 0x5a, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x36, 0x38, 0x10, 0x5b, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x36,
+	0x39, 0x10, 0x5c, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x35, 0x37, 0x30, 0x10, 0x5d, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x37, 0x31, 0x10, 0x5e, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x37, 0x32, 0x10, 0x5f, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x37,
+	0x33, 0x10, 0x60, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x35, 0x37, 0x34, 0x10, 0x61, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x37, 0x35, 0x10, 0x62, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x37, 0x36, 0x10, 0x63, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x37,
+	0x37, 0x10, 0x64, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x35, 0x37, 0x38, 0x10, 0x65, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x37, 0x39, 0x10, 0x66, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x38, 0x30, 0x10, 0x67, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x38,
+	0x31, 0x10, 0x68, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x35, 0x38, 0x32, 0x10, 0x69, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x38, 0x33, 0x10, 0x6a, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x38, 0x34, 0x10, 0x6b, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x38,
+	0x35, 0x10, 0x6c, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x35, 0x38, 0x36, 0x10, 0x6d, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x38, 0x37, 0x10, 0x6e, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x38, 0x38, 0x10, 0x6f, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x38,
+	0x39, 0x10, 0x70, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x35, 0x39, 0x30, 0x10, 0x71, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x39, 0x31, 0x10, 0x72, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x39, 0x32, 0x10, 0x73, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x39,
+	0x33, 0x10, 0x74, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x35, 0x39, 0x34, 0x10, 0x75, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x39, 0x35, 0x10, 0x76, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x39, 0x36, 0x10, 0x77, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x39,
+	0x37, 0x10, 0x78, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x35, 0x39, 0x38, 0x10, 0x79, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x39, 0x39, 0x10, 0x7a, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x30, 0x30, 0x10, 0x7b, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x30,
+	0x31, 0x10, 0x7c, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x36, 0x30, 0x32, 0x10, 0x7d, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x30, 0x33, 0x10, 0x7e, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x30, 0x34, 0x10, 0x7f, 0x12,
+	0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x30,
+	0x35, 0x10, 0x80, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x36, 0x30, 0x36, 0x10, 0x81, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x30, 0x37, 0x10, 0x82, 0x01, 0x12, 0x13,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x30, 0x38,
+	0x10, 0x83, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x36, 0x30, 0x39, 0x10, 0x84, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x31, 0x30, 0x10, 0x85, 0x01, 0x12, 0x13, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x31, 0x31, 0x10,
+	0x86, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x33, 0x36, 0x31, 0x32, 0x10, 0x87, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x31, 0x33, 0x10, 0x88, 0x01, 0x12, 0x13, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x31, 0x34, 0x10, 0x89,
+	0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33,
+	0x36, 0x31, 0x35, 0x10, 0x8a, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x31, 0x36, 0x10, 0x8b, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x31, 0x37, 0x10, 0x8c, 0x01,
+	0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36,
+	0x31, 0x38, 0x10, 0x8d, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x33, 0x36, 0x31, 0x39, 0x10, 0x8e, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x32, 0x30, 0x10, 0x8f, 0x01, 0x12,
+	0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x32,
+	0x31, 0x10, 0x90, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x36, 0x32, 0x32, 0x10, 0x91, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x32, 0x33, 0x10, 0x92, 0x01, 0x12, 0x13,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x32, 0x34,
+	0x10, 0x93, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x36, 0x32, 0x35, 0x10, 0x94, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x32, 0x36, 0x10, 0x95, 0x01, 0x12, 0x13, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x32, 0x37, 0x10,
+	0x96, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x33, 0x36, 0x32, 0x38, 0x10, 0x97, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x32, 0x39, 0x10, 0x98, 0x01, 0x12, 0x13, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x33, 0x30, 0x10, 0x99,
+	0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33,
+	0x36, 0x33, 0x31, 0x10, 0x9a, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x33, 0x32, 0x10, 0x9b, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x33, 0x33, 0x10, 0x9c, 0x01,
+	0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36,
+	0x33, 0x34, 0x10, 0x9d, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x33, 0x36, 0x33, 0x35, 0x10, 0x9e, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x33, 0x36, 0x10, 0x9f, 0x01, 0x12,
+	0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x33,
+	0x37, 0x10, 0xa0, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x36, 0x33, 0x38, 0x10, 0xa1, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x33, 0x39, 0x10, 0xa2, 0x01, 0x12, 0x13,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x34, 0x30,
+	0x10, 0xa3, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x36, 0x34, 0x31, 0x10, 0xa4, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x34, 0x32, 0x10, 0xa5, 0x01, 0x12, 0x13, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x34, 0x33, 0x10,
+	0xa6, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x33, 0x36, 0x34, 0x34, 0x10, 0xa7, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x34, 0x35, 0x10, 0xa8, 0x01, 0x12, 0x13, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x34, 0x36, 0x10, 0xa9,
+	0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33,
+	0x36, 0x34, 0x37, 0x10, 0xaa, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x34, 0x38, 0x10, 0xab, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x34, 0x39, 0x10, 0xac, 0x01,
+	0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36,
+	0x35, 0x30, 0x10, 0xad, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x33, 0x36, 0x35, 0x31, 0x10, 0xae, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x35, 0x32, 0x10, 0xaf, 0x01, 0x12,
+	0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x35,
+	0x33, 0x10, 0xb0, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x36, 0x35, 0x34, 0x10, 0xb1, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x35, 0x35, 0x10, 0xb2, 0x01, 0x12, 0x13,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x35, 0x36,
+	0x10, 0xb3, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x36, 0x35, 0x37, 0x10, 0xb4, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x35, 0x38, 0x10, 0xb5, 0x01, 0x12, 0x13, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x35, 0x39, 0x10,
+	0xb6, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x33, 0x36, 0x36, 0x30, 0x10, 0xb7, 0x01, 0x2a, 0xfa, 0x01, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d,
+	0x33, 0x38, 0x30, 0x35, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x38, 0x30, 0x36, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x30, 0x37, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x30, 0x38, 0x10, 0x02,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38,
+	0x30, 0x39, 0x10, 0x03, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x38, 0x31, 0x30, 0x10, 0x04, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x31, 0x31, 0x10, 0x05, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x31, 0x32, 0x10, 0x06,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38,
+	0x31, 0x33, 0x10, 0x07, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x38, 0x31, 0x34, 0x10, 0x08, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x31, 0x35, 0x10, 0x09, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x31, 0x36, 0x10, 0x0b,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38,
+	0x31, 0x37, 0x10, 0x0a, 0x2a, 0x9a, 0x03, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x33, 0x37, 0x38,
+	0x33, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33,
+	0x37, 0x38, 0x34, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x33, 0x37, 0x38, 0x35, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x37, 0x38, 0x36, 0x10, 0x02, 0x12, 0x12, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x37, 0x38, 0x37, 0x10,
+	0x03, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33,
+	0x37, 0x38, 0x38, 0x10, 0x04, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x33, 0x37, 0x38, 0x39, 0x10, 0x05, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x37, 0x39, 0x30, 0x10, 0x06, 0x12, 0x12, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x37, 0x39, 0x31, 0x10,
+	0x07, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33,
+	0x37, 0x39, 0x32, 0x10, 0x08, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x33, 0x37, 0x39, 0x33, 0x10, 0x09, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x37, 0x39, 0x34, 0x10, 0x0a, 0x12, 0x12, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x37, 0x39, 0x35, 0x10,
+	0x0b, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33,
+	0x37, 0x39, 0x36, 0x10, 0x0c, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x33, 0x37, 0x39, 0x37, 0x10, 0x0d, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x37, 0x39, 0x38, 0x10, 0x0e, 0x12, 0x12, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x37, 0x39, 0x39, 0x10,
+	0x0f, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33,
+	0x38, 0x30, 0x30, 0x10, 0x10, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x33, 0x38, 0x30, 0x31, 0x10, 0x14, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x30, 0x32, 0x10, 0x15, 0x12, 0x12, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x30, 0x33, 0x10,
+	0x32, 0x2a, 0xf2, 0x02, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x33, 0x38, 0x35, 0x31, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x35, 0x32,
+	0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x33, 0x38, 0x35, 0x33, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x35, 0x34, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x35, 0x35, 0x10, 0x03, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x35, 0x36,
+	0x10, 0x04, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x33, 0x38, 0x35, 0x37, 0x10, 0x05, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x35, 0x38, 0x10, 0x06, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x35, 0x39, 0x10, 0x07, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x36, 0x30,
+	0x10, 0x08, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x33, 0x38, 0x36, 0x31, 0x10, 0x09, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x36, 0x32, 0x10, 0x0a, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x36, 0x33, 0x10, 0x0b, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x36, 0x34,
+	0x10, 0x0c, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x33, 0x38, 0x36, 0x35, 0x10, 0x0d, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x36, 0x36, 0x10, 0x0e, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x36, 0x37, 0x10, 0x0f, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x36, 0x38,
+	0x10, 0x10, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x33, 0x38, 0x36, 0x39, 0x10, 0x11, 0x2a, 0x3c, 0x0a, 0x0a, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64,
+	0x45, 0x6e, 0x75, 0x6d, 0x12, 0x16, 0x0a, 0x12, 0x55, 0x4e, 0x55, 0x53, 0x45, 0x44, 0x5f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x10, 0x00, 0x12, 0x16, 0x0a, 0x12,
+	0x55, 0x4e, 0x55, 0x53, 0x45, 0x44, 0x5f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x32, 0x10, 0x01, 0x2a, 0x6e, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x34, 0x31, 0x34, 0x36,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x34, 0x31,
+	0x34, 0x37, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x34, 0x31, 0x34, 0x38, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x34, 0x31, 0x34, 0x39, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x34, 0x31, 0x35, 0x30, 0x10, 0x03,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x34, 0x31,
+	0x35, 0x31, 0x10, 0x04, 0x2a, 0x32, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x34, 0x31, 0x36, 0x30,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x34, 0x31,
+	0x36, 0x31, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x34, 0x31, 0x36, 0x32, 0x10, 0x01, 0x2a, 0x96, 0x01, 0x0a, 0x08, 0x45, 0x6e, 0x75,
+	0x6d, 0x34, 0x31, 0x35, 0x32, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x34, 0x31, 0x35, 0x33, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x34, 0x31, 0x35, 0x34, 0x10, 0x01, 0x12, 0x12, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x34, 0x31, 0x35, 0x35, 0x10,
+	0x02, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x34,
+	0x31, 0x35, 0x36, 0x10, 0x03, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x34, 0x31, 0x35, 0x37, 0x10, 0x04, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x34, 0x31, 0x35, 0x38, 0x10, 0x05, 0x12, 0x12, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x34, 0x31, 0x35, 0x39, 0x10,
+	0x06, 0x2a, 0xc2, 0x03, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x36, 0x30, 0x32, 0x35, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x32, 0x36,
+	0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x36, 0x30, 0x32, 0x37, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x32, 0x38, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x32, 0x39, 0x10, 0x03, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x33, 0x30,
+	0x10, 0x04, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x36, 0x30, 0x33, 0x31, 0x10, 0x05, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x33, 0x32, 0x10, 0x06, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x33, 0x33, 0x10, 0x07, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x33, 0x34,
+	0x10, 0x08, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x36, 0x30, 0x33, 0x35, 0x10, 0x09, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x33, 0x36, 0x10, 0x0a, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x33, 0x37, 0x10, 0x0b, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x33, 0x38,
+	0x10, 0x0c, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x36, 0x30, 0x33, 0x39, 0x10, 0x0d, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x34, 0x30, 0x10, 0x0e, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x34, 0x31, 0x10, 0x0f, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x34, 0x32,
+	0x10, 0x10, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x36, 0x30, 0x34, 0x33, 0x10, 0x11, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x34, 0x34, 0x10, 0x12, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x34, 0x35, 0x10, 0x13, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x34, 0x36,
+	0x10, 0x14, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x36, 0x30, 0x34, 0x37, 0x10, 0x15, 0x2a, 0xb6, 0x02, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x36,
+	0x30, 0x36, 0x35, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x36, 0x30, 0x36, 0x36, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x36, 0x37, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x36, 0x38, 0x10, 0x02, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x36,
+	0x39, 0x10, 0x03, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x36, 0x30, 0x37, 0x30, 0x10, 0x04, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x37, 0x31, 0x10, 0x05, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x37, 0x32, 0x10, 0x06, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x37,
+	0x33, 0x10, 0x07, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x36, 0x30, 0x37, 0x34, 0x10, 0x08, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x37, 0x35, 0x10, 0x09, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x37, 0x36, 0x10, 0x0a, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x37,
+	0x37, 0x10, 0x0b, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x36, 0x30, 0x37, 0x38, 0x10, 0x0c, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x37, 0x39, 0x10, 0x0d, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x38, 0x30, 0x10, 0x0e, 0x2a,
+	0xaa, 0x01, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x36, 0x35, 0x37, 0x39, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x35, 0x38, 0x30, 0x10, 0x00,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x35,
+	0x38, 0x31, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x36, 0x35, 0x38, 0x32, 0x10, 0x03, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x35, 0x38, 0x33, 0x10, 0x05, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x35, 0x38, 0x34, 0x10, 0x0a,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x35,
+	0x38, 0x35, 0x10, 0x0f, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x36, 0x35, 0x38, 0x36, 0x10, 0x19, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x35, 0x38, 0x37, 0x10, 0x1e, 0x2a, 0xb2, 0x05, 0x0a,
+	0x08, 0x45, 0x6e, 0x75, 0x6d, 0x36, 0x35, 0x38, 0x38, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x35, 0x38, 0x39, 0x10, 0x00, 0x12, 0x12, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x35, 0x39, 0x30, 0x10,
+	0x01, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36,
+	0x35, 0x39, 0x31, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x36, 0x35, 0x39, 0x32, 0x10, 0x03, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x35, 0x39, 0x33, 0x10, 0x04, 0x12, 0x12, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x35, 0x39, 0x34, 0x10,
+	0x05, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36,
+	0x35, 0x39, 0x35, 0x10, 0x06, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x36, 0x35, 0x39, 0x36, 0x10, 0x07, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x35, 0x39, 0x37, 0x10, 0x08, 0x12, 0x12, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x35, 0x39, 0x38, 0x10,
+	0x09, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36,
+	0x35, 0x39, 0x39, 0x10, 0x0a, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x36, 0x36, 0x30, 0x30, 0x10, 0x0b, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x36, 0x30, 0x31, 0x10, 0x0c, 0x12, 0x12, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x36, 0x30, 0x32, 0x10,
+	0x0d, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36,
+	0x36, 0x30, 0x33, 0x10, 0x0e, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x36, 0x36, 0x30, 0x34, 0x10, 0x0f, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x36, 0x30, 0x35, 0x10, 0x10, 0x12, 0x12, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x36, 0x30, 0x36, 0x10,
+	0x11, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36,
+	0x36, 0x30, 0x37, 0x10, 0x13, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x36, 0x36, 0x30, 0x38, 0x10, 0x14, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x36, 0x30, 0x39, 0x10, 0x15, 0x12, 0x12, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x36, 0x31, 0x30, 0x10,
+	0x16, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36,
+	0x36, 0x31, 0x31, 0x10, 0x17, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x36, 0x36, 0x31, 0x32, 0x10, 0x18, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x36, 0x31, 0x33, 0x10, 0x19, 0x12, 0x12, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x36, 0x31, 0x34, 0x10,
+	0x1a, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36,
+	0x36, 0x31, 0x35, 0x10, 0x1b, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x36, 0x36, 0x31, 0x36, 0x10, 0x1c, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x36, 0x31, 0x37, 0x10, 0x1d, 0x12, 0x12, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x36, 0x31, 0x38, 0x10,
+	0x1e, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36,
+	0x36, 0x31, 0x39, 0x10, 0x1f, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x36, 0x36, 0x32, 0x30, 0x10, 0x20, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x36, 0x32, 0x31, 0x10, 0x21, 0x12, 0x12, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x36, 0x32, 0x32, 0x10,
+	0x22, 0x2a, 0x46, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x36, 0x37, 0x36, 0x39, 0x12, 0x12, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x37, 0x37, 0x30, 0x10,
+	0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36,
+	0x37, 0x37, 0x31, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x36, 0x37, 0x37, 0x32, 0x10, 0x02, 0x2a, 0x96, 0x01, 0x0a, 0x08, 0x45, 0x6e,
+	0x75, 0x6d, 0x36, 0x37, 0x37, 0x34, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x36, 0x37, 0x37, 0x35, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x37, 0x37, 0x36, 0x10, 0x01, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x37, 0x37, 0x37,
+	0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x36, 0x37, 0x37, 0x38, 0x10, 0x03, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x36, 0x37, 0x37, 0x39, 0x10, 0x04, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x37, 0x38, 0x30, 0x10, 0x05, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x37, 0x38, 0x31,
+	0x10, 0x06, 0x2a, 0x82, 0x01, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x36, 0x37, 0x38, 0x32, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x37, 0x38,
+	0x33, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x36, 0x37, 0x38, 0x34, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x37, 0x38, 0x35, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x37, 0x38, 0x36, 0x10, 0x03, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x37, 0x38,
+	0x37, 0x10, 0x04, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x36, 0x37, 0x38, 0x38, 0x10, 0x05, 0x2a, 0x5a, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x36,
+	0x38, 0x35, 0x38, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x36, 0x38, 0x35, 0x39, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x38, 0x36, 0x30, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x38, 0x36, 0x31, 0x10, 0x03, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x38, 0x36,
+	0x32, 0x10, 0x04, 0x2a, 0x82, 0x01, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x36, 0x38, 0x31, 0x35,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x38,
+	0x31, 0x36, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x36, 0x38, 0x31, 0x37, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x38, 0x31, 0x38, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x38, 0x31, 0x39, 0x10, 0x03,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x38,
+	0x32, 0x30, 0x10, 0x04, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x36, 0x38, 0x32, 0x31, 0x10, 0x05, 0x2a, 0x5a, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d,
+	0x36, 0x38, 0x32, 0x32, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x36, 0x38, 0x32, 0x33, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x38, 0x32, 0x34, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x38, 0x32, 0x35, 0x10, 0x02,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x38,
+	0x32, 0x36, 0x10, 0x03, 0x2a, 0x46, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x37, 0x36, 0x35, 0x34,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x37, 0x36,
+	0x35, 0x35, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x37, 0x36, 0x35, 0x36, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x37, 0x36, 0x35, 0x37, 0x10, 0x03, 0x2a, 0x46, 0x0a, 0x08,
+	0x45, 0x6e, 0x75, 0x6d, 0x38, 0x32, 0x39, 0x32, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x38, 0x32, 0x39, 0x33, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x38, 0x32, 0x39, 0x34, 0x10, 0x01,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x38, 0x32,
+	0x39, 0x35, 0x10, 0x02, 0x2a, 0x46, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x38, 0x34, 0x35, 0x30,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x38, 0x34,
+	0x35, 0x31, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x38, 0x34, 0x35, 0x32, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x38, 0x34, 0x35, 0x33, 0x10, 0x02, 0x2a, 0x6e, 0x0a, 0x08,
+	0x45, 0x6e, 0x75, 0x6d, 0x38, 0x39, 0x30, 0x30, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x38, 0x39, 0x30, 0x31, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x38, 0x39, 0x30, 0x32, 0x10, 0x01,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x38, 0x39,
+	0x30, 0x33, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x38, 0x39, 0x30, 0x34, 0x10, 0x03, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x38, 0x39, 0x30, 0x35, 0x10, 0x04, 0x2a, 0x6e, 0x0a, 0x08,
+	0x45, 0x6e, 0x75, 0x6d, 0x38, 0x39, 0x34, 0x35, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x38, 0x39, 0x34, 0x36, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x38, 0x39, 0x34, 0x37, 0x10, 0x01,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x38, 0x39,
+	0x34, 0x38, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x38, 0x39, 0x34, 0x39, 0x10, 0x03, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x38, 0x39, 0x35, 0x30, 0x10, 0x04, 0x2a, 0xaa, 0x01, 0x0a,
+	0x08, 0x45, 0x6e, 0x75, 0x6d, 0x38, 0x39, 0x35, 0x31, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x38, 0x39, 0x35, 0x32, 0x10, 0x01, 0x12, 0x12, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x38, 0x39, 0x35, 0x33, 0x10,
+	0x02, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x38,
+	0x39, 0x35, 0x34, 0x10, 0x03, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x38, 0x39, 0x35, 0x35, 0x10, 0x04, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x38, 0x39, 0x35, 0x36, 0x10, 0x05, 0x12, 0x12, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x38, 0x39, 0x35, 0x37, 0x10,
+	0x06, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x38,
+	0x39, 0x35, 0x38, 0x10, 0x07, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x38, 0x39, 0x35, 0x39, 0x10, 0x08, 0x2a, 0x97, 0x0d, 0x0a, 0x08, 0x45, 0x6e,
+	0x75, 0x6d, 0x39, 0x32, 0x34, 0x33, 0x12, 0x1b, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x34, 0x34, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+	0xff, 0xff, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x39, 0x32, 0x34, 0x35, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x34, 0x36, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x34, 0x37, 0x10, 0x02, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x34,
+	0x38, 0x10, 0x03, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x39, 0x32, 0x34, 0x39, 0x10, 0x04, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x35, 0x30, 0x10, 0x05, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x35, 0x31, 0x10, 0x06, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x35,
+	0x32, 0x10, 0x07, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x39, 0x32, 0x35, 0x33, 0x10, 0x08, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x35, 0x34, 0x10, 0x09, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x35, 0x35, 0x10, 0x0a, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x35,
+	0x36, 0x10, 0x0b, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x39, 0x32, 0x35, 0x37, 0x10, 0x0c, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x35, 0x38, 0x10, 0x0d, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x35, 0x39, 0x10, 0x0e, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x36,
+	0x30, 0x10, 0x0f, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x39, 0x32, 0x36, 0x31, 0x10, 0x10, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x36, 0x32, 0x10, 0x11, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x36, 0x33, 0x10, 0x47, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x36,
+	0x34, 0x10, 0x48, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x39, 0x32, 0x36, 0x35, 0x10, 0x49, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x36, 0x36, 0x10, 0x4a, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x36, 0x37, 0x10, 0x12, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x36,
+	0x38, 0x10, 0x14, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x39, 0x32, 0x36, 0x39, 0x10, 0x15, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x37, 0x30, 0x10, 0x16, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x37, 0x31, 0x10, 0x17, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x37,
+	0x32, 0x10, 0x3d, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x39, 0x32, 0x37, 0x33, 0x10, 0x3e, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x37, 0x34, 0x10, 0x3f, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x37, 0x35, 0x10, 0x40, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x37,
+	0x36, 0x10, 0x42, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x39, 0x32, 0x37, 0x37, 0x10, 0x43, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x37, 0x38, 0x10, 0x18, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x37, 0x39, 0x10, 0x19, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x38,
+	0x30, 0x10, 0x1a, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x39, 0x32, 0x38, 0x31, 0x10, 0x1b, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x38, 0x32, 0x10, 0x1c, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x38, 0x33, 0x10, 0x1d, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x38,
+	0x34, 0x10, 0x1e, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x39, 0x32, 0x38, 0x35, 0x10, 0x1f, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x38, 0x36, 0x10, 0x20, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x38, 0x37, 0x10, 0x21, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x38,
+	0x38, 0x10, 0x22, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x39, 0x32, 0x38, 0x39, 0x10, 0x23, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x39, 0x30, 0x10, 0x24, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x39, 0x31, 0x10, 0x25, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x39,
+	0x32, 0x10, 0x26, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x39, 0x32, 0x39, 0x33, 0x10, 0x27, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x39, 0x34, 0x10, 0x28, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x39, 0x35, 0x10, 0x29, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x39,
+	0x36, 0x10, 0x2a, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x39, 0x32, 0x39, 0x37, 0x10, 0x2b, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x39, 0x38, 0x10, 0x2c, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x32, 0x39, 0x39, 0x10, 0x2d, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x33, 0x30,
+	0x30, 0x10, 0x2e, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x39, 0x33, 0x30, 0x31, 0x10, 0x2f, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x33, 0x30, 0x32, 0x10, 0x30, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x33, 0x30, 0x33, 0x10, 0x31, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x33, 0x30,
+	0x34, 0x10, 0x32, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x39, 0x33, 0x30, 0x35, 0x10, 0x33, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x33, 0x30, 0x36, 0x10, 0x34, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x33, 0x30, 0x37, 0x10, 0x35, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x33, 0x30,
+	0x38, 0x10, 0x36, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x39, 0x33, 0x30, 0x39, 0x10, 0x37, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x33, 0x31, 0x30, 0x10, 0x38, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x33, 0x31, 0x31, 0x10, 0x39, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x33, 0x31,
+	0x32, 0x10, 0x3a, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x39, 0x33, 0x31, 0x33, 0x10, 0x3b, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x33, 0x31, 0x34, 0x10, 0x3c, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x33, 0x31, 0x35, 0x10, 0x44, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x33, 0x31,
+	0x36, 0x10, 0x45, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x39, 0x33, 0x31, 0x37, 0x10, 0x46, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x33, 0x31, 0x38, 0x10, 0xe8, 0x07, 0x12, 0x13, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x33, 0x31, 0x39, 0x10, 0xe9,
+	0x07, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39,
+	0x33, 0x32, 0x30, 0x10, 0xea, 0x07, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x39, 0x33, 0x32, 0x31, 0x10, 0xeb, 0x07, 0x12, 0x13, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x33, 0x32, 0x32, 0x10, 0xec, 0x07,
+	0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x33,
+	0x32, 0x33, 0x10, 0xed, 0x07, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x39, 0x33, 0x32, 0x34, 0x10, 0xee, 0x07, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x33, 0x32, 0x35, 0x10, 0xef, 0x07, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x39, 0x33, 0x32,
+	0x36, 0x10, 0x41, 0x2a, 0xc8, 0x01, 0x0a, 0x09, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x30, 0x31, 0x35,
+	0x37, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x30, 0x31, 0x35, 0x38, 0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x31, 0x35, 0x39, 0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x31, 0x36, 0x30, 0x10, 0x02,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30,
+	0x31, 0x36, 0x31, 0x10, 0x03, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x30, 0x31, 0x36, 0x32, 0x10, 0x04, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x31, 0x36, 0x33, 0x10, 0x05, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x31,
+	0x36, 0x34, 0x10, 0x06, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x30, 0x31, 0x36, 0x35, 0x10, 0x07, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x31, 0x36, 0x36, 0x10, 0x08, 0x2a, 0xc8,
+	0x01, 0x0a, 0x09, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x30, 0x31, 0x36, 0x37, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x31, 0x36, 0x38, 0x10,
+	0x00, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x30, 0x31, 0x36, 0x39, 0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x31, 0x37, 0x30, 0x10, 0x02, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x31, 0x37, 0x31, 0x10, 0x03,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30,
+	0x31, 0x37, 0x32, 0x10, 0x04, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x30, 0x31, 0x37, 0x33, 0x10, 0x05, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x31, 0x37, 0x34, 0x10, 0x06, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x31,
+	0x37, 0x35, 0x10, 0x07, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x30, 0x31, 0x37, 0x36, 0x10, 0x08, 0x2a, 0xca, 0x02, 0x0a, 0x08, 0x45, 0x6e,
+	0x75, 0x6d, 0x38, 0x38, 0x36, 0x32, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x38, 0x38, 0x36, 0x33, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x38, 0x38, 0x36, 0x34, 0x10, 0x01, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x38, 0x38, 0x36, 0x35,
+	0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x38, 0x38, 0x36, 0x36, 0x10, 0x03, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x38, 0x38, 0x36, 0x37, 0x10, 0x04, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x38, 0x38, 0x36, 0x38, 0x10, 0x05, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x38, 0x38, 0x36, 0x39,
+	0x10, 0x06, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x38, 0x38, 0x37, 0x30, 0x10, 0x07, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x38, 0x38, 0x37, 0x31, 0x10, 0x0d, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x38, 0x38, 0x37, 0x32, 0x10, 0x0e, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x38, 0x38, 0x37, 0x33,
+	0x10, 0x08, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x38, 0x38, 0x37, 0x34, 0x10, 0x09, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x38, 0x38, 0x37, 0x35, 0x10, 0x0a, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x38, 0x38, 0x37, 0x36, 0x10, 0x0b, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x38, 0x38, 0x37, 0x37,
+	0x10, 0x0c, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x38, 0x38, 0x37, 0x38, 0x10, 0x0f, 0x2a, 0xc8, 0x01, 0x0a, 0x09, 0x45, 0x6e, 0x75, 0x6d, 0x31,
+	0x30, 0x33, 0x32, 0x35, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x30, 0x33, 0x32, 0x36, 0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x33, 0x32, 0x37, 0x10, 0x01, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x33, 0x32,
+	0x38, 0x10, 0x02, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x30, 0x33, 0x32, 0x39, 0x10, 0x03, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x33, 0x33, 0x30, 0x10, 0x04, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x33, 0x33, 0x31,
+	0x10, 0x05, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x30, 0x33, 0x33, 0x32, 0x10, 0x06, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x33, 0x33, 0x33, 0x10, 0x07, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x33, 0x33, 0x34, 0x10,
+	0x08, 0x2a, 0x20, 0x0a, 0x09, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x30, 0x33, 0x33, 0x35, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x33, 0x33,
+	0x36, 0x10, 0x00, 0x2a, 0x35, 0x0a, 0x09, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x30, 0x33, 0x33, 0x37,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30,
+	0x33, 0x33, 0x38, 0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x30, 0x33, 0x33, 0x39, 0x10, 0x01, 0x2a, 0x85, 0x03, 0x0a, 0x09, 0x45,
+	0x6e, 0x75, 0x6d, 0x31, 0x30, 0x33, 0x39, 0x32, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x33, 0x39, 0x33, 0x10, 0x00, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x33, 0x39, 0x34,
+	0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x30, 0x33, 0x39, 0x35, 0x10, 0x02, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x33, 0x39, 0x36, 0x10, 0x03, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x33, 0x39, 0x37, 0x10,
+	0x04, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x30, 0x33, 0x39, 0x38, 0x10, 0x05, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x33, 0x39, 0x39, 0x10, 0x06, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x34, 0x30, 0x30, 0x10, 0x07,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30,
+	0x34, 0x30, 0x31, 0x10, 0x08, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x30, 0x34, 0x30, 0x32, 0x10, 0x0f, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x34, 0x30, 0x33, 0x10, 0x09, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x34,
+	0x30, 0x34, 0x10, 0x0a, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x30, 0x34, 0x30, 0x35, 0x10, 0x0b, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x34, 0x30, 0x36, 0x10, 0x0c, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x34, 0x30,
+	0x37, 0x10, 0x0d, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x30, 0x34, 0x30, 0x38, 0x10, 0x0e, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x34, 0x30, 0x39, 0x10, 0x65, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x34, 0x31, 0x30,
+	0x10, 0x66, 0x2a, 0x9f, 0x3e, 0x0a, 0x09, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x31, 0x31, 0x30, 0x37,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x31, 0x30, 0x38, 0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x30, 0x39, 0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x31, 0x30, 0x10, 0x02, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31,
+	0x31, 0x31, 0x10, 0x03, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x31, 0x31, 0x32, 0x10, 0x04, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x31, 0x33, 0x10, 0x05, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x31,
+	0x34, 0x10, 0x06, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x31, 0x31, 0x31, 0x35, 0x10, 0x07, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x31, 0x36, 0x10, 0x08, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x31, 0x37,
+	0x10, 0x09, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x31, 0x31, 0x38, 0x10, 0x0a, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x31, 0x39, 0x10, 0x0b, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x32, 0x30, 0x10,
+	0x0c, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x31, 0x31, 0x32, 0x31, 0x10, 0x0d, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x32, 0x32, 0x10, 0x0e, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x32, 0x33, 0x10, 0x0f,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x31, 0x32, 0x34, 0x10, 0x10, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x32, 0x35, 0x10, 0x11, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x32, 0x36, 0x10, 0x12, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31,
+	0x32, 0x37, 0x10, 0x13, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x31, 0x32, 0x38, 0x10, 0x14, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x32, 0x39, 0x10, 0x15, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x33,
+	0x30, 0x10, 0x16, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x31, 0x31, 0x33, 0x31, 0x10, 0x17, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x33, 0x32, 0x10, 0x18, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x33, 0x33,
+	0x10, 0x19, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x31, 0x33, 0x34, 0x10, 0x1a, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x33, 0x35, 0x10, 0x1b, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x33, 0x36, 0x10,
+	0x1c, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x31, 0x31, 0x33, 0x37, 0x10, 0x1d, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x33, 0x38, 0x10, 0x1e, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x33, 0x39, 0x10, 0x1f,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x31, 0x34, 0x30, 0x10, 0x20, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x34, 0x31, 0x10, 0x21, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x34, 0x32, 0x10, 0x22, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31,
+	0x34, 0x33, 0x10, 0x23, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x31, 0x34, 0x34, 0x10, 0x24, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x34, 0x35, 0x10, 0x25, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x34,
+	0x36, 0x10, 0x26, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x31, 0x31, 0x34, 0x37, 0x10, 0x27, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x34, 0x38, 0x10, 0x28, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x34, 0x39,
+	0x10, 0x29, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x31, 0x35, 0x30, 0x10, 0x2a, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x35, 0x31, 0x10, 0x2b, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x35, 0x32, 0x10,
+	0x2c, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x31, 0x31, 0x35, 0x33, 0x10, 0x2d, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x35, 0x34, 0x10, 0x2e, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x35, 0x35, 0x10, 0x2f,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x31, 0x35, 0x36, 0x10, 0x30, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x35, 0x37, 0x10, 0x31, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x35, 0x38, 0x10, 0x32, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31,
+	0x35, 0x39, 0x10, 0x33, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x31, 0x36, 0x30, 0x10, 0x34, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x36, 0x31, 0x10, 0x35, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x36,
+	0x32, 0x10, 0x36, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x31, 0x31, 0x36, 0x33, 0x10, 0x37, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x36, 0x34, 0x10, 0x38, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x36, 0x35,
+	0x10, 0x39, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x31, 0x36, 0x36, 0x10, 0x3a, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x36, 0x37, 0x10, 0x3b, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x36, 0x38, 0x10,
+	0x3c, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x31, 0x31, 0x36, 0x39, 0x10, 0x3d, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x37, 0x30, 0x10, 0x3e, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x37, 0x31, 0x10, 0x3f,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x31, 0x37, 0x32, 0x10, 0x40, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x37, 0x33, 0x10, 0x41, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x37, 0x34, 0x10, 0x42, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31,
+	0x37, 0x35, 0x10, 0x43, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x31, 0x37, 0x36, 0x10, 0x44, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x37, 0x37, 0x10, 0x45, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x37,
+	0x38, 0x10, 0x46, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x31, 0x31, 0x37, 0x39, 0x10, 0x47, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x38, 0x30, 0x10, 0x48, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x38, 0x31,
+	0x10, 0x49, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x31, 0x38, 0x32, 0x10, 0x4a, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x38, 0x33, 0x10, 0x4b, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x38, 0x34, 0x10,
+	0x4c, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x31, 0x31, 0x38, 0x35, 0x10, 0x4d, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x38, 0x36, 0x10, 0x4e, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x38, 0x37, 0x10, 0x4f,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x31, 0x38, 0x38, 0x10, 0x50, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x38, 0x39, 0x10, 0x51, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x39, 0x30, 0x10, 0x52, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31,
+	0x39, 0x31, 0x10, 0x53, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x31, 0x39, 0x32, 0x10, 0x54, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x39, 0x33, 0x10, 0x55, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x39,
+	0x34, 0x10, 0x56, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x31, 0x31, 0x39, 0x35, 0x10, 0x57, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x39, 0x36, 0x10, 0x58, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x39, 0x37,
+	0x10, 0x59, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x31, 0x39, 0x38, 0x10, 0x5a, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x39, 0x39, 0x10, 0x5b, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x30, 0x30, 0x10,
+	0x5c, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x31, 0x32, 0x30, 0x31, 0x10, 0x5d, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x30, 0x32, 0x10, 0x5e, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x30, 0x33, 0x10, 0x5f,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x32, 0x30, 0x34, 0x10, 0x60, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x30, 0x35, 0x10, 0x61, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x30, 0x36, 0x10, 0x62, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32,
+	0x30, 0x37, 0x10, 0x63, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x32, 0x30, 0x38, 0x10, 0x64, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x30, 0x39, 0x10, 0x65, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x31,
+	0x30, 0x10, 0x66, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x31, 0x32, 0x31, 0x31, 0x10, 0x67, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x31, 0x32, 0x10, 0x68, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x31, 0x33,
+	0x10, 0x69, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x32, 0x31, 0x34, 0x10, 0x6a, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x31, 0x35, 0x10, 0x6b, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x31, 0x36, 0x10,
+	0x6c, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x31, 0x32, 0x31, 0x37, 0x10, 0x6d, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x31, 0x38, 0x10, 0x6e, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x31, 0x39, 0x10, 0x6f,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x32, 0x32, 0x30, 0x10, 0x70, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x32, 0x31, 0x10, 0x71, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x32, 0x32, 0x10, 0x72, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32,
+	0x32, 0x33, 0x10, 0x73, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x32, 0x32, 0x34, 0x10, 0x74, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x32, 0x35, 0x10, 0x75, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x32,
+	0x36, 0x10, 0x76, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x31, 0x32, 0x32, 0x37, 0x10, 0x77, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x32, 0x38, 0x10, 0x78, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x32, 0x39,
+	0x10, 0x79, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x32, 0x33, 0x30, 0x10, 0x7a, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x33, 0x31, 0x10, 0x7b, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x33, 0x32, 0x10,
+	0x7c, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x31, 0x32, 0x33, 0x33, 0x10, 0x7d, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x33, 0x34, 0x10, 0x7e, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x33, 0x35, 0x10, 0x7f,
+	0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x32, 0x33, 0x36, 0x10, 0x80, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x33, 0x37, 0x10, 0x81, 0x01, 0x12, 0x14, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x33, 0x38, 0x10,
+	0x82, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x32, 0x33, 0x39, 0x10, 0x83, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x34, 0x30, 0x10, 0x84, 0x01, 0x12, 0x14,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x34,
+	0x31, 0x10, 0x85, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x32, 0x34, 0x32, 0x10, 0x86, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x34, 0x33, 0x10, 0x87, 0x01,
+	0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x32, 0x34, 0x34, 0x10, 0x88, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x34, 0x35, 0x10, 0x89, 0x01, 0x12, 0x14, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x34, 0x36, 0x10,
+	0x8a, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x32, 0x34, 0x37, 0x10, 0x8b, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x34, 0x38, 0x10, 0x8c, 0x01, 0x12, 0x14,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x34,
+	0x39, 0x10, 0x8d, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x32, 0x35, 0x30, 0x10, 0x8e, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x35, 0x31, 0x10, 0x8f, 0x01,
+	0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x32, 0x35, 0x32, 0x10, 0x90, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x35, 0x33, 0x10, 0x91, 0x01, 0x12, 0x14, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x35, 0x34, 0x10,
+	0x92, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x32, 0x35, 0x35, 0x10, 0x93, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x35, 0x36, 0x10, 0x94, 0x01, 0x12, 0x14,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x35,
+	0x37, 0x10, 0x95, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x32, 0x35, 0x38, 0x10, 0x96, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x35, 0x39, 0x10, 0x97, 0x01,
+	0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x32, 0x36, 0x30, 0x10, 0x98, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x36, 0x31, 0x10, 0x99, 0x01, 0x12, 0x14, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x36, 0x32, 0x10,
+	0x9a, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x32, 0x36, 0x33, 0x10, 0x9b, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x36, 0x34, 0x10, 0x9c, 0x01, 0x12, 0x14,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x36,
+	0x35, 0x10, 0x9d, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x32, 0x36, 0x36, 0x10, 0x9e, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x36, 0x37, 0x10, 0x9f, 0x01,
+	0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x32, 0x36, 0x38, 0x10, 0xa0, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x36, 0x39, 0x10, 0xa1, 0x01, 0x12, 0x14, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x37, 0x30, 0x10,
+	0xa3, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x32, 0x37, 0x31, 0x10, 0xa4, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x37, 0x32, 0x10, 0xa5, 0x01, 0x12, 0x14,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x37,
+	0x33, 0x10, 0xa6, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x32, 0x37, 0x34, 0x10, 0xa7, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x37, 0x35, 0x10, 0xa8, 0x01,
+	0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x32, 0x37, 0x36, 0x10, 0xa9, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x37, 0x37, 0x10, 0xaa, 0x01, 0x12, 0x14, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x37, 0x38, 0x10,
+	0xab, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x32, 0x37, 0x39, 0x10, 0xac, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x38, 0x30, 0x10, 0xad, 0x01, 0x12, 0x14,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x38,
+	0x31, 0x10, 0xae, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x32, 0x38, 0x32, 0x10, 0xaf, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x38, 0x33, 0x10, 0xb0, 0x01,
+	0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x32, 0x38, 0x34, 0x10, 0xb1, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x38, 0x35, 0x10, 0xb2, 0x01, 0x12, 0x14, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x38, 0x36, 0x10,
+	0xb3, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x32, 0x38, 0x37, 0x10, 0xb4, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x38, 0x38, 0x10, 0xb5, 0x01, 0x12, 0x14,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x38,
+	0x39, 0x10, 0xb6, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x32, 0x39, 0x30, 0x10, 0xb7, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x39, 0x31, 0x10, 0xb8, 0x01,
+	0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x32, 0x39, 0x32, 0x10, 0xb9, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x39, 0x33, 0x10, 0xbb, 0x01, 0x12, 0x14, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x39, 0x34, 0x10,
+	0xbc, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x32, 0x39, 0x35, 0x10, 0xbd, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x39, 0x36, 0x10, 0xbe, 0x01, 0x12, 0x14,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x39,
+	0x37, 0x10, 0xbf, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x32, 0x39, 0x38, 0x10, 0xc0, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x32, 0x39, 0x39, 0x10, 0xc1, 0x01,
+	0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x33, 0x30, 0x30, 0x10, 0xc2, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x30, 0x31, 0x10, 0xc3, 0x01, 0x12, 0x14, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x30, 0x32, 0x10,
+	0xc4, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x33, 0x30, 0x33, 0x10, 0xc5, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x30, 0x34, 0x10, 0xc6, 0x01, 0x12, 0x15,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x30,
+	0x35, 0x10, 0xff, 0xff, 0x03, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x30, 0x36, 0x10, 0x80, 0x80, 0x04, 0x12, 0x15, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x30, 0x37, 0x10,
+	0x81, 0x80, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x31, 0x33, 0x30, 0x38, 0x10, 0x82, 0x80, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x30, 0x39, 0x10, 0x83, 0x80,
+	0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x31, 0x33, 0x31, 0x30, 0x10, 0x84, 0x80, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x31, 0x31, 0x10, 0x85, 0x80, 0x04, 0x12,
+	0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33,
+	0x31, 0x32, 0x10, 0x86, 0x80, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x31, 0x33, 0x10, 0x87, 0x80, 0x04, 0x12, 0x15, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x31, 0x34,
+	0x10, 0x88, 0x80, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x33, 0x31, 0x35, 0x10, 0x89, 0x80, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x31, 0x36, 0x10, 0x8a,
+	0x80, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x33, 0x31, 0x37, 0x10, 0x8b, 0x80, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x31, 0x38, 0x10, 0x8c, 0x80, 0x04,
+	0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x33, 0x31, 0x39, 0x10, 0x8d, 0x80, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x32, 0x30, 0x10, 0x8e, 0x80, 0x04, 0x12, 0x15,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x32,
+	0x31, 0x10, 0x8f, 0x80, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x32, 0x32, 0x10, 0x90, 0x80, 0x04, 0x12, 0x15, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x32, 0x33, 0x10,
+	0x91, 0x80, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x31, 0x33, 0x32, 0x34, 0x10, 0x92, 0x80, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x32, 0x35, 0x10, 0x93, 0x80,
+	0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x31, 0x33, 0x32, 0x36, 0x10, 0x94, 0x80, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x32, 0x37, 0x10, 0x95, 0x80, 0x04, 0x12,
+	0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33,
+	0x32, 0x38, 0x10, 0x96, 0x80, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x32, 0x39, 0x10, 0x97, 0x80, 0x04, 0x12, 0x15, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x33, 0x30,
+	0x10, 0x98, 0x80, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x33, 0x33, 0x31, 0x10, 0x99, 0x80, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x33, 0x32, 0x10, 0x9a,
+	0x80, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x33, 0x33, 0x33, 0x10, 0x9b, 0x80, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x33, 0x34, 0x10, 0x80, 0xa0, 0x04,
+	0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x33, 0x33, 0x35, 0x10, 0x81, 0xa0, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x33, 0x36, 0x10, 0x82, 0xa0, 0x04, 0x12, 0x15,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x33,
+	0x37, 0x10, 0x83, 0xa0, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x33, 0x38, 0x10, 0x84, 0xa0, 0x04, 0x12, 0x15, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x33, 0x39, 0x10,
+	0x85, 0xa0, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x31, 0x33, 0x34, 0x30, 0x10, 0x86, 0xa0, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x34, 0x31, 0x10, 0x87, 0xa0,
+	0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x31, 0x33, 0x34, 0x32, 0x10, 0x88, 0xa0, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x34, 0x33, 0x10, 0x89, 0xa0, 0x04, 0x12,
+	0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33,
+	0x34, 0x34, 0x10, 0x8a, 0xa0, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x34, 0x35, 0x10, 0x8b, 0xa0, 0x04, 0x12, 0x15, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x34, 0x36,
+	0x10, 0x8c, 0xa0, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x33, 0x34, 0x37, 0x10, 0x8d, 0xa0, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x34, 0x38, 0x10, 0x8e,
+	0xa0, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x33, 0x34, 0x39, 0x10, 0x8f, 0xa0, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x35, 0x30, 0x10, 0x90, 0xa0, 0x04,
+	0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x33, 0x35, 0x31, 0x10, 0x91, 0xa0, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x35, 0x32, 0x10, 0x92, 0xa0, 0x04, 0x12, 0x15,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x35,
+	0x33, 0x10, 0x93, 0xa0, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x35, 0x34, 0x10, 0x94, 0xa0, 0x04, 0x12, 0x15, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x35, 0x35, 0x10,
+	0x95, 0xa0, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x31, 0x33, 0x35, 0x36, 0x10, 0x96, 0xa0, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x35, 0x37, 0x10, 0x97, 0xa0,
+	0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x31, 0x33, 0x35, 0x38, 0x10, 0x98, 0xa0, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x35, 0x39, 0x10, 0x99, 0xa0, 0x04, 0x12,
+	0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33,
+	0x36, 0x30, 0x10, 0x9a, 0xa0, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x36, 0x31, 0x10, 0x9b, 0xa0, 0x04, 0x12, 0x15, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x36, 0x32,
+	0x10, 0x9c, 0xa0, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x33, 0x36, 0x33, 0x10, 0x9d, 0xa0, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x36, 0x34, 0x10, 0x9e,
+	0xa0, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x33, 0x36, 0x35, 0x10, 0x80, 0xc0, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x36, 0x36, 0x10, 0x81, 0xc0, 0x04,
+	0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x33, 0x36, 0x37, 0x10, 0x80, 0xe0, 0x04, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x36, 0x38, 0x10, 0x81, 0xe0, 0x04, 0x12, 0x15,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x36,
+	0x39, 0x10, 0x80, 0x80, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x37, 0x30, 0x10, 0x81, 0x80, 0x05, 0x12, 0x15, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x37, 0x31, 0x10,
+	0x82, 0x80, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x31, 0x33, 0x37, 0x32, 0x10, 0x83, 0x80, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x37, 0x33, 0x10, 0x80, 0xa0,
+	0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x31, 0x33, 0x37, 0x34, 0x10, 0x81, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x37, 0x35, 0x10, 0x82, 0xa0, 0x05, 0x12,
+	0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33,
+	0x37, 0x36, 0x10, 0x83, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x37, 0x37, 0x10, 0x84, 0xa0, 0x05, 0x12, 0x15, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x37, 0x38,
+	0x10, 0x85, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x33, 0x37, 0x39, 0x10, 0x86, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x38, 0x30, 0x10, 0x87,
+	0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x33, 0x38, 0x31, 0x10, 0x88, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x38, 0x32, 0x10, 0x89, 0xa0, 0x05,
+	0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x33, 0x38, 0x33, 0x10, 0x8a, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x38, 0x34, 0x10, 0x8b, 0xa0, 0x05, 0x12, 0x15,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x38,
+	0x35, 0x10, 0x8c, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x38, 0x36, 0x10, 0x8d, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x38, 0x37, 0x10,
+	0x8e, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x31, 0x33, 0x38, 0x38, 0x10, 0x8f, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x38, 0x39, 0x10, 0x90, 0xa0,
+	0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x31, 0x33, 0x39, 0x30, 0x10, 0x91, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x39, 0x31, 0x10, 0x92, 0xa0, 0x05, 0x12,
+	0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33,
+	0x39, 0x32, 0x10, 0x93, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x39, 0x33, 0x10, 0x94, 0xa0, 0x05, 0x12, 0x15, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x39, 0x34,
+	0x10, 0x95, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x33, 0x39, 0x35, 0x10, 0x96, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x39, 0x36, 0x10, 0x97,
+	0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x33, 0x39, 0x37, 0x10, 0x98, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x33, 0x39, 0x38, 0x10, 0x99, 0xa0, 0x05,
+	0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x33, 0x39, 0x39, 0x10, 0x9a, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x30, 0x30, 0x10, 0x9b, 0xa0, 0x05, 0x12, 0x15,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x30,
+	0x31, 0x10, 0x9c, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x30, 0x32, 0x10, 0x9d, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x30, 0x33, 0x10,
+	0x9e, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x31, 0x34, 0x30, 0x34, 0x10, 0x9f, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x30, 0x35, 0x10, 0xa0, 0xa0,
+	0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x31, 0x34, 0x30, 0x36, 0x10, 0xa1, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x30, 0x37, 0x10, 0xa2, 0xa0, 0x05, 0x12,
+	0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34,
+	0x30, 0x38, 0x10, 0xa3, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x30, 0x39, 0x10, 0xa4, 0xa0, 0x05, 0x12, 0x15, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x31, 0x30,
+	0x10, 0xa5, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x34, 0x31, 0x31, 0x10, 0xa6, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x31, 0x32, 0x10, 0xa7,
+	0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x34, 0x31, 0x33, 0x10, 0xa8, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x31, 0x34, 0x10, 0xa9, 0xa0, 0x05,
+	0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x34, 0x31, 0x35, 0x10, 0xaa, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x31, 0x36, 0x10, 0xab, 0xa0, 0x05, 0x12, 0x15,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x31,
+	0x37, 0x10, 0xac, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x31, 0x38, 0x10, 0xad, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x31, 0x39, 0x10,
+	0xae, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x31, 0x34, 0x32, 0x30, 0x10, 0xaf, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x32, 0x31, 0x10, 0xb0, 0xa0,
+	0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x31, 0x34, 0x32, 0x32, 0x10, 0xb1, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x32, 0x33, 0x10, 0xb2, 0xa0, 0x05, 0x12,
+	0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34,
+	0x32, 0x34, 0x10, 0xb3, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x32, 0x35, 0x10, 0xb4, 0xa0, 0x05, 0x12, 0x15, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x32, 0x36,
+	0x10, 0xb5, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x34, 0x32, 0x37, 0x10, 0xb6, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x32, 0x38, 0x10, 0xb7,
+	0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x34, 0x32, 0x39, 0x10, 0xb8, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x33, 0x30, 0x10, 0xb9, 0xa0, 0x05,
+	0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x34, 0x33, 0x31, 0x10, 0xba, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x33, 0x32, 0x10, 0xbd, 0xa0, 0x05, 0x12, 0x15,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x33,
+	0x33, 0x10, 0xbe, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x33, 0x34, 0x10, 0xbf, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x33, 0x35, 0x10,
+	0xc0, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x31, 0x34, 0x33, 0x36, 0x10, 0xc1, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x33, 0x37, 0x10, 0xc2, 0xa0,
+	0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x31, 0x34, 0x33, 0x38, 0x10, 0xc3, 0xa0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x33, 0x39, 0x10, 0xc4, 0xa0, 0x05, 0x12,
+	0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34,
+	0x34, 0x30, 0x10, 0x80, 0xc0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x34, 0x31, 0x10, 0x80, 0xe0, 0x05, 0x12, 0x15, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x34, 0x32,
+	0x10, 0x81, 0xe0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x34, 0x34, 0x33, 0x10, 0x82, 0xe0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x34, 0x34, 0x10, 0x83,
+	0xe0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x34, 0x34, 0x35, 0x10, 0x84, 0xe0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x34, 0x36, 0x10, 0x85, 0xe0, 0x05,
+	0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x34, 0x34, 0x37, 0x10, 0x86, 0xe0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x34, 0x38, 0x10, 0x87, 0xe0, 0x05, 0x12, 0x15,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x34,
+	0x39, 0x10, 0x88, 0xe0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x35, 0x30, 0x10, 0x89, 0xe0, 0x05, 0x12, 0x15, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x35, 0x31, 0x10,
+	0x8a, 0xe0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x31, 0x34, 0x35, 0x32, 0x10, 0x8b, 0xe0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x35, 0x33, 0x10, 0x8c, 0xe0,
+	0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x31, 0x34, 0x35, 0x34, 0x10, 0x8d, 0xe0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x35, 0x35, 0x10, 0x8e, 0xe0, 0x05, 0x12,
+	0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34,
+	0x35, 0x36, 0x10, 0x8f, 0xe0, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x35, 0x37, 0x10, 0x90, 0xe0, 0x05, 0x12, 0x15, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x35, 0x38,
+	0x10, 0x80, 0x80, 0x06, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x34, 0x35, 0x39, 0x10, 0x81, 0x80, 0x06, 0x12, 0x15, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x36, 0x30, 0x10, 0x82,
+	0x80, 0x06, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x34, 0x36, 0x31, 0x10, 0x83, 0x80, 0x06, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x36, 0x32, 0x10, 0x84, 0x80, 0x06,
+	0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x34, 0x36, 0x33, 0x10, 0x80, 0xa0, 0x06, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x36, 0x34, 0x10, 0x80, 0x80, 0x08, 0x12, 0x15,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x36,
+	0x35, 0x10, 0x81, 0x80, 0x08, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x36, 0x36, 0x10, 0x80, 0xa0, 0x08, 0x12, 0x16, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x36, 0x37, 0x10,
+	0x93, 0x92, 0xc0, 0x04, 0x2a, 0xff, 0x1f, 0x0a, 0x09, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x31, 0x35,
+	0x34, 0x31, 0x12, 0x1c, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x35, 0x34, 0x32, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x35, 0x34, 0x33, 0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x35, 0x34, 0x34, 0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x35, 0x34, 0x35, 0x10, 0x02, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x35,
+	0x34, 0x36, 0x10, 0x03, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x35, 0x34, 0x37, 0x10, 0x04, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x35, 0x34, 0x38, 0x10, 0x05, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x35, 0x34,
+	0x39, 0x10, 0x06, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x31, 0x35, 0x35, 0x30, 0x10, 0x07, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x35, 0x35, 0x31, 0x10, 0x08, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x35, 0x35, 0x32,
+	0x10, 0x09, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x35, 0x35, 0x33, 0x10, 0x0a, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x35, 0x35, 0x34, 0x10, 0x0b, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x35, 0x35, 0x35, 0x10,
+	0x0c, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x31, 0x35, 0x35, 0x36, 0x10, 0x0d, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x35, 0x35, 0x37, 0x10, 0x0e, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x35, 0x35, 0x38, 0x10, 0x0f,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x35, 0x35, 0x39, 0x10, 0x10, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x35, 0x36, 0x30, 0x10, 0x11, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x35, 0x36, 0x31, 0x10, 0x12, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x35,
+	0x36, 0x32, 0x10, 0x13, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x35, 0x36, 0x33, 0x10, 0x14, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x35, 0x36, 0x34, 0x10, 0x15, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x35, 0x36,
+	0x35, 0x10, 0x16, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x31, 0x35, 0x36, 0x36, 0x10, 0x17, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x35, 0x36, 0x37, 0x10, 0x18, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x35, 0x36, 0x38,
+	0x10, 0x19, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x35, 0x36, 0x39, 0x10, 0x1a, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x35, 0x37, 0x30, 0x10, 0x1b, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x35, 0x37, 0x31, 0x10,
+	0x1c, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x31, 0x35, 0x37, 0x32, 0x10, 0x1d, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x35, 0x37, 0x33, 0x10, 0x1e, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x35, 0x37, 0x34, 0x10, 0x1f,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x35, 0x37, 0x35, 0x10, 0x20, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x35, 0x37, 0x36, 0x10, 0x21, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x35, 0x37, 0x37, 0x10, 0x22, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x35,
+	0x37, 0x38, 0x10, 0x23, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x35, 0x37, 0x39, 0x10, 0x24, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x35, 0x38, 0x30, 0x10, 0x25, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x35, 0x38,
+	0x31, 0x10, 0x26, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x31, 0x35, 0x38, 0x32, 0x10, 0x27, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x35, 0x38, 0x33, 0x10, 0x28, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x35, 0x38, 0x34,
+	0x10, 0x29, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x35, 0x38, 0x35, 0x10, 0x2a, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x35, 0x38, 0x36, 0x10, 0x2b, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x35, 0x38, 0x37, 0x10,
+	0x2c, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x31, 0x35, 0x38, 0x38, 0x10, 0x2d, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x35, 0x38, 0x39, 0x10, 0x2e, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x35, 0x39, 0x30, 0x10, 0x2f,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x35, 0x39, 0x31, 0x10, 0x30, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x35, 0x39, 0x32, 0x10, 0x31, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x35, 0x39, 0x33, 0x10, 0x32, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x35,
+	0x39, 0x34, 0x10, 0x33, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x35, 0x39, 0x35, 0x10, 0x34, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x35, 0x39, 0x36, 0x10, 0x35, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x35, 0x39,
+	0x37, 0x10, 0x36, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x31, 0x35, 0x39, 0x38, 0x10, 0x37, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x35, 0x39, 0x39, 0x10, 0x38, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x30, 0x30,
+	0x10, 0x39, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x36, 0x30, 0x31, 0x10, 0x3a, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x30, 0x32, 0x10, 0x3b, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x30, 0x33, 0x10,
+	0x3c, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x31, 0x36, 0x30, 0x34, 0x10, 0x3d, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x30, 0x35, 0x10, 0x3e, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x30, 0x36, 0x10, 0x3f,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x36, 0x30, 0x37, 0x10, 0x40, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x30, 0x38, 0x10, 0x41, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x30, 0x39, 0x10, 0x42, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36,
+	0x31, 0x30, 0x10, 0x43, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x36, 0x31, 0x31, 0x10, 0x44, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x31, 0x32, 0x10, 0x45, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x31,
+	0x33, 0x10, 0x46, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x31, 0x36, 0x31, 0x34, 0x10, 0x47, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x31, 0x35, 0x10, 0x48, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x31, 0x36,
+	0x10, 0x49, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x36, 0x31, 0x37, 0x10, 0x4a, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x31, 0x38, 0x10, 0x4b, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x31, 0x39, 0x10,
+	0x4c, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x31, 0x36, 0x32, 0x30, 0x10, 0x4d, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x32, 0x31, 0x10, 0x4e, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x32, 0x32, 0x10, 0x4f,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x36, 0x32, 0x33, 0x10, 0x50, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x32, 0x34, 0x10, 0x51, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x32, 0x35, 0x10, 0x52, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36,
+	0x32, 0x36, 0x10, 0x53, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x36, 0x32, 0x37, 0x10, 0x54, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x32, 0x38, 0x10, 0x55, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x32,
+	0x39, 0x10, 0x56, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x31, 0x36, 0x33, 0x30, 0x10, 0x57, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x33, 0x31, 0x10, 0x58, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x33, 0x32,
+	0x10, 0x59, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x36, 0x33, 0x33, 0x10, 0x5a, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x33, 0x34, 0x10, 0x5b, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x33, 0x35, 0x10,
+	0x5c, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x31, 0x36, 0x33, 0x36, 0x10, 0x5d, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x33, 0x37, 0x10, 0x5e, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x33, 0x38, 0x10, 0x5f,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x36, 0x33, 0x39, 0x10, 0x60, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x34, 0x30, 0x10, 0x61, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x34, 0x31, 0x10, 0x62, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36,
+	0x34, 0x32, 0x10, 0x63, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x36, 0x34, 0x33, 0x10, 0x64, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x34, 0x34, 0x10, 0x65, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x34,
+	0x35, 0x10, 0x66, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x31, 0x36, 0x34, 0x36, 0x10, 0x67, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x34, 0x37, 0x10, 0x68, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x34, 0x38,
+	0x10, 0x69, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x36, 0x34, 0x39, 0x10, 0x6a, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x35, 0x30, 0x10, 0x6b, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x35, 0x31, 0x10,
+	0x6c, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x31, 0x36, 0x35, 0x32, 0x10, 0x6d, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x35, 0x33, 0x10, 0x6e, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x35, 0x34, 0x10, 0x6f,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x36, 0x35, 0x35, 0x10, 0x70, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x35, 0x36, 0x10, 0x71, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x35, 0x37, 0x10, 0x72, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36,
+	0x35, 0x38, 0x10, 0x73, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x36, 0x35, 0x39, 0x10, 0x74, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x36, 0x30, 0x10, 0x75, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x36,
+	0x31, 0x10, 0x76, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x31, 0x36, 0x36, 0x32, 0x10, 0x77, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x36, 0x33, 0x10, 0x78, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x36, 0x34,
+	0x10, 0x79, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x36, 0x36, 0x35, 0x10, 0x7a, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x36, 0x36, 0x10, 0x7b, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x36, 0x37, 0x10,
+	0x7c, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x31, 0x36, 0x36, 0x38, 0x10, 0x7d, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x36, 0x39, 0x10, 0x7e, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x37, 0x30, 0x10, 0x7f,
+	0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x36, 0x37, 0x31, 0x10, 0x80, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x37, 0x32, 0x10, 0x81, 0x01, 0x12, 0x14, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x37, 0x33, 0x10,
+	0x82, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x36, 0x37, 0x34, 0x10, 0x83, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x37, 0x35, 0x10, 0x84, 0x01, 0x12, 0x14,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x37,
+	0x36, 0x10, 0x85, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x36, 0x37, 0x37, 0x10, 0x86, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x37, 0x38, 0x10, 0x87, 0x01,
+	0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x36, 0x37, 0x39, 0x10, 0x88, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x38, 0x30, 0x10, 0x89, 0x01, 0x12, 0x14, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x38, 0x31, 0x10,
+	0x8a, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x36, 0x38, 0x32, 0x10, 0x8b, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x38, 0x33, 0x10, 0x8c, 0x01, 0x12, 0x14,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x38,
+	0x34, 0x10, 0x8d, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x36, 0x38, 0x35, 0x10, 0x8e, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x38, 0x36, 0x10, 0x8f, 0x01,
+	0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x36, 0x38, 0x37, 0x10, 0x90, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x38, 0x38, 0x10, 0x91, 0x01, 0x12, 0x14, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x38, 0x39, 0x10,
+	0x92, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x36, 0x39, 0x30, 0x10, 0x93, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x39, 0x31, 0x10, 0x94, 0x01, 0x12, 0x14,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x39,
+	0x32, 0x10, 0x95, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x36, 0x39, 0x33, 0x10, 0x96, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x39, 0x34, 0x10, 0x97, 0x01,
+	0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x36, 0x39, 0x35, 0x10, 0x98, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x39, 0x36, 0x10, 0x99, 0x01, 0x12, 0x14, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x39, 0x37, 0x10,
+	0x9a, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x36, 0x39, 0x38, 0x10, 0x9b, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x36, 0x39, 0x39, 0x10, 0x9c, 0x01, 0x12, 0x14,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x37, 0x30,
+	0x30, 0x10, 0x9d, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x37, 0x30, 0x31, 0x10, 0x9e, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x37, 0x30, 0x32, 0x10, 0x9f, 0x01,
+	0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x37, 0x30, 0x33, 0x10, 0xa0, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x37, 0x30, 0x34, 0x10, 0xa1, 0x01, 0x12, 0x14, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x37, 0x30, 0x35, 0x10,
+	0xa2, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x37, 0x30, 0x36, 0x10, 0xa3, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x37, 0x30, 0x37, 0x10, 0xa4, 0x01, 0x12, 0x14,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x37, 0x30,
+	0x38, 0x10, 0xa5, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x37, 0x30, 0x39, 0x10, 0xa6, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x37, 0x31, 0x30, 0x10, 0xa7, 0x01,
+	0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x37, 0x31, 0x31, 0x10, 0xa8, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x37, 0x31, 0x32, 0x10, 0xa9, 0x01, 0x12, 0x14, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x37, 0x31, 0x33, 0x10,
+	0xaa, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x37, 0x31, 0x34, 0x10, 0xab, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x37, 0x31, 0x35, 0x10, 0xac, 0x01, 0x12, 0x14,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x37, 0x31,
+	0x36, 0x10, 0xad, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x37, 0x31, 0x37, 0x10, 0xae, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x37, 0x31, 0x38, 0x10, 0xaf, 0x01,
+	0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x37, 0x31, 0x39, 0x10, 0xb0, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x37, 0x32, 0x30, 0x10, 0xb1, 0x01, 0x12, 0x14, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x37, 0x32, 0x31, 0x10,
+	0xb2, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x37, 0x32, 0x32, 0x10, 0xb3, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x37, 0x32, 0x33, 0x10, 0xb4, 0x01, 0x12, 0x14,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x37, 0x32,
+	0x34, 0x10, 0xb5, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x37, 0x32, 0x35, 0x10, 0xb6, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x37, 0x32, 0x36, 0x10, 0xb7, 0x01,
+	0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x37, 0x32, 0x37, 0x10, 0xb8, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x37, 0x32, 0x38, 0x10, 0xb9, 0x01, 0x12, 0x14, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x37, 0x32, 0x39, 0x10,
+	0xba, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x37, 0x33, 0x30, 0x10, 0xbb, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x37, 0x33, 0x31, 0x10, 0xbc, 0x01, 0x12, 0x16,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x37, 0x33,
+	0x32, 0x10, 0xff, 0xff, 0xff, 0x07, 0x2a, 0x94, 0x04, 0x0a, 0x09, 0x45, 0x6e, 0x75, 0x6d, 0x31,
+	0x31, 0x34, 0x36, 0x38, 0x12, 0x1c, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x34, 0x36, 0x39, 0x10, 0x9d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+	0xff, 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x34, 0x37, 0x30, 0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x37, 0x31, 0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x37, 0x32, 0x10,
+	0x02, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x31, 0x34, 0x37, 0x33, 0x10, 0x03, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x37, 0x34, 0x10, 0x04, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x37, 0x35, 0x10, 0x1c,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x34, 0x37, 0x36, 0x10, 0x16, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x37, 0x37, 0x10, 0x26, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x37, 0x38, 0x10, 0x80, 0x04,
+	0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x34, 0x37, 0x39, 0x10, 0x80, 0x10, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x38, 0x30, 0x10, 0x42, 0x12, 0x14, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x38, 0x31, 0x10, 0xc2,
+	0x04, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x31, 0x34, 0x38, 0x32, 0x10, 0x4d, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x38, 0x33, 0x10, 0x58, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x38, 0x34, 0x10, 0x64,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x34, 0x38, 0x35, 0x10, 0x6e, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x38, 0x36, 0x10, 0xee, 0x10, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x38, 0x37, 0x10, 0x7a,
+	0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x34, 0x38, 0x38, 0x10, 0xfa, 0x10, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x38, 0x39, 0x10, 0x90, 0x01, 0x12, 0x14, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x39, 0x30, 0x10,
+	0xf4, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x34, 0x39, 0x31, 0x10, 0xf4, 0x11, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x34, 0x39, 0x32, 0x10, 0x2c, 0x2a, 0xef, 0x0d,
+	0x0a, 0x09, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x31, 0x30, 0x32, 0x32, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x32, 0x33, 0x10, 0x00,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x30, 0x32, 0x34, 0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x32, 0x35, 0x10, 0x02, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x32, 0x36, 0x10, 0x03, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30,
+	0x32, 0x37, 0x10, 0x04, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x30, 0x32, 0x38, 0x10, 0x05, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x32, 0x39, 0x10, 0x06, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x33,
+	0x30, 0x10, 0x07, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x31, 0x30, 0x33, 0x31, 0x10, 0x08, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x33, 0x32, 0x10, 0x09, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x33, 0x33,
+	0x10, 0x0a, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x30, 0x33, 0x34, 0x10, 0x0b, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x33, 0x35, 0x10, 0x0c, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x33, 0x36, 0x10,
+	0x0d, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x31, 0x30, 0x33, 0x37, 0x10, 0x0e, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x33, 0x38, 0x10, 0x0f, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x33, 0x39, 0x10, 0x10,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x30, 0x34, 0x30, 0x10, 0x11, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x34, 0x31, 0x10, 0x12, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x34, 0x32, 0x10, 0x13, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30,
+	0x34, 0x33, 0x10, 0x14, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x30, 0x34, 0x34, 0x10, 0x15, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x34, 0x35, 0x10, 0x16, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x34,
+	0x36, 0x10, 0x17, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x31, 0x30, 0x34, 0x37, 0x10, 0x18, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x34, 0x38, 0x10, 0x19, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x34, 0x39,
+	0x10, 0x1a, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x30, 0x35, 0x30, 0x10, 0x1b, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x35, 0x31, 0x10, 0x1c, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x35, 0x32, 0x10,
+	0x1d, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x31, 0x30, 0x35, 0x33, 0x10, 0x1e, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x35, 0x34, 0x10, 0x1f, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x35, 0x35, 0x10, 0x20,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x30, 0x35, 0x36, 0x10, 0x21, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x35, 0x37, 0x10, 0x22, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x35, 0x38, 0x10, 0x23, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30,
+	0x35, 0x39, 0x10, 0x24, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x30, 0x36, 0x30, 0x10, 0x25, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x36, 0x31, 0x10, 0x26, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x36,
+	0x32, 0x10, 0x27, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x31, 0x30, 0x36, 0x33, 0x10, 0x28, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x36, 0x34, 0x10, 0x29, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x36, 0x35,
+	0x10, 0x2a, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x30, 0x36, 0x36, 0x10, 0x2b, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x36, 0x37, 0x10, 0x2c, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x36, 0x38, 0x10,
+	0x2d, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x31, 0x30, 0x36, 0x39, 0x10, 0x2e, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x37, 0x30, 0x10, 0x2f, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x37, 0x31, 0x10, 0x30,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x30, 0x37, 0x32, 0x10, 0x31, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x37, 0x33, 0x10, 0x32, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x37, 0x34, 0x10, 0x33, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30,
+	0x37, 0x35, 0x10, 0x34, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x30, 0x37, 0x36, 0x10, 0x35, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x37, 0x37, 0x10, 0x36, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x37,
+	0x38, 0x10, 0x37, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x31, 0x30, 0x37, 0x39, 0x10, 0x38, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x38, 0x30, 0x10, 0x39, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x38, 0x31,
+	0x10, 0x3a, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x30, 0x38, 0x32, 0x10, 0x3b, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x38, 0x33, 0x10, 0x3c, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x38, 0x34, 0x10,
+	0x3d, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x31, 0x30, 0x38, 0x35, 0x10, 0x3e, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x38, 0x36, 0x10, 0x3f, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x38, 0x37, 0x10, 0x40,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x30, 0x38, 0x38, 0x10, 0x41, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x38, 0x39, 0x10, 0x42, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x39, 0x30, 0x10, 0x43, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30,
+	0x39, 0x31, 0x10, 0x44, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x30, 0x39, 0x32, 0x10, 0x45, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x39, 0x33, 0x10, 0x46, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x39,
+	0x34, 0x10, 0x47, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x31, 0x30, 0x39, 0x35, 0x10, 0x48, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x39, 0x36, 0x10, 0x49, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x39, 0x37,
+	0x10, 0x4a, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x31, 0x30, 0x39, 0x38, 0x10, 0x4b, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x30, 0x39, 0x39, 0x10, 0x4c, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x30, 0x30, 0x10,
+	0x4d, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x31, 0x31, 0x30, 0x31, 0x10, 0x4e, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x30, 0x32, 0x10, 0x4f, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x30, 0x33, 0x10, 0x50,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31,
+	0x31, 0x30, 0x34, 0x10, 0x51, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x30, 0x35, 0x10, 0x52, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x31, 0x30, 0x36, 0x10, 0x53, 0x2a,
+	0x4a, 0x0a, 0x09, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x32, 0x36, 0x37, 0x30, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x32, 0x36, 0x37, 0x31, 0x10,
+	0x00, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x32, 0x36, 0x37, 0x32, 0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x32, 0x36, 0x37, 0x33, 0x10, 0x02, 0x2a, 0x89, 0x01, 0x0a, 0x09,
+	0x45, 0x6e, 0x75, 0x6d, 0x31, 0x32, 0x38, 0x37, 0x31, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x32, 0x38, 0x37, 0x32, 0x10, 0x01, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x32, 0x38, 0x37,
+	0x33, 0x10, 0x02, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x32, 0x38, 0x37, 0x34, 0x10, 0x03, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x32, 0x38, 0x37, 0x35, 0x10, 0x04, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x32, 0x38, 0x37, 0x36,
+	0x10, 0x05, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x32, 0x38, 0x37, 0x37, 0x10, 0x06, 0x2a, 0x4a, 0x0a, 0x09, 0x45, 0x6e, 0x75, 0x6d, 0x31,
+	0x33, 0x30, 0x39, 0x32, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x33, 0x30, 0x39, 0x33, 0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x33, 0x30, 0x39, 0x34, 0x10, 0x02, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x33, 0x30, 0x39,
+	0x35, 0x10, 0x03, 0x2a, 0x5f, 0x0a, 0x09, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x33, 0x31, 0x34, 0x36,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x33,
+	0x31, 0x34, 0x37, 0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x33, 0x31, 0x34, 0x38, 0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x33, 0x31, 0x34, 0x39, 0x10, 0x02, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x33, 0x31,
+	0x35, 0x30, 0x10, 0x03, 0x2a, 0xe3, 0x3e, 0x0a, 0x09, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x36, 0x30,
+	0x34, 0x32, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x36, 0x30, 0x34, 0x33, 0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30, 0x34, 0x34, 0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30, 0x34, 0x35, 0x10,
+	0x11, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x36, 0x30, 0x34, 0x36, 0x10, 0x91, 0x02, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30, 0x34, 0x37, 0x10, 0x92, 0x02, 0x12, 0x14, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30, 0x34, 0x38,
+	0x10, 0xa1, 0x22, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x36, 0x30, 0x34, 0x39, 0x10, 0xa2, 0x22, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30, 0x35, 0x30, 0x10, 0xa3, 0x22, 0x12,
+	0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30,
+	0x35, 0x31, 0x10, 0xa4, 0x22, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x36, 0x30, 0x35, 0x32, 0x10, 0xa5, 0x22, 0x12, 0x14, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30, 0x35, 0x33, 0x10, 0xa6,
+	0x22, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x36, 0x30, 0x35, 0x34, 0x10, 0xa7, 0x22, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30, 0x35, 0x35, 0x10, 0xa8, 0x22, 0x12, 0x14, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30, 0x35, 0x36,
+	0x10, 0xa9, 0x22, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x36, 0x30, 0x35, 0x37, 0x10, 0x94, 0x02, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30, 0x35, 0x38, 0x10, 0x95, 0x02, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30,
+	0x35, 0x39, 0x10, 0x12, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x36, 0x30, 0x36, 0x30, 0x10, 0xa1, 0x02, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30, 0x36, 0x31, 0x10, 0xa3, 0x02,
+	0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36,
+	0x30, 0x36, 0x32, 0x10, 0xb1, 0x24, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30, 0x36, 0x33, 0x10, 0x91, 0xc6, 0x04, 0x12, 0x14, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30, 0x36, 0x34,
+	0x10, 0xb2, 0x24, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x36, 0x30, 0x36, 0x35, 0x10, 0xb3, 0x24, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30, 0x36, 0x36, 0x10, 0xb4, 0x24, 0x12,
+	0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30,
+	0x36, 0x37, 0x10, 0xb5, 0x24, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x36, 0x30, 0x36, 0x38, 0x10, 0xb6, 0x24, 0x12, 0x14, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30, 0x36, 0x39, 0x10, 0xb7,
+	0x24, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x36, 0x30, 0x37, 0x30, 0x10, 0xb8, 0x24, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30, 0x37, 0x31, 0x10, 0xa4, 0x02, 0x12, 0x14, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30, 0x37, 0x32,
+	0x10, 0xc1, 0x24, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x36, 0x30, 0x37, 0x33, 0x10, 0xc2, 0x24, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30, 0x37, 0x34, 0x10, 0xa5, 0x02, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30,
+	0x37, 0x35, 0x10, 0x13, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x36, 0x30, 0x37, 0x36, 0x10, 0x14, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30, 0x37, 0x37, 0x10, 0xc1, 0x02, 0x12,
+	0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30,
+	0x37, 0x38, 0x10, 0x91, 0x28, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x36, 0x30, 0x37, 0x39, 0x10, 0x92, 0x28, 0x12, 0x14, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30, 0x38, 0x30, 0x10, 0x93,
+	0x28, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x36, 0x30, 0x38, 0x31, 0x10, 0x94, 0x28, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30, 0x38, 0x32, 0x10, 0x95, 0x28, 0x12, 0x14, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30, 0x38, 0x33,
+	0x10, 0x96, 0x28, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x36, 0x30, 0x38, 0x34, 0x10, 0xe1, 0x82, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30, 0x38, 0x35, 0x10, 0xe2, 0x82,
+	0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x36, 0x30, 0x38, 0x36, 0x10, 0xe3, 0x82, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30, 0x38, 0x37, 0x10, 0xe4, 0x82, 0x05, 0x12,
+	0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30,
+	0x38, 0x38, 0x10, 0xe5, 0x82, 0x05, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30, 0x38, 0x39, 0x10, 0xe6, 0x82, 0x05, 0x12, 0x14, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30, 0x39, 0x30,
+	0x10, 0x97, 0x28, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x36, 0x30, 0x39, 0x31, 0x10, 0x98, 0x28, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30, 0x39, 0x32, 0x10, 0x99, 0x28, 0x12,
+	0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30,
+	0x39, 0x33, 0x10, 0x9a, 0x28, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x36, 0x30, 0x39, 0x34, 0x10, 0xa1, 0x83, 0x05, 0x12, 0x14, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30, 0x39, 0x35, 0x10,
+	0x9b, 0x28, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x36, 0x30, 0x39, 0x36, 0x10, 0x9c, 0x28, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30, 0x39, 0x37, 0x10, 0xc2, 0x02, 0x12, 0x14,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x30, 0x39,
+	0x38, 0x10, 0xc3, 0x02, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x36, 0x30, 0x39, 0x39, 0x10, 0xc4, 0x02, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x30, 0x30, 0x10, 0xc5, 0x02,
+	0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36,
+	0x31, 0x30, 0x31, 0x10, 0xc6, 0x02, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x30, 0x32, 0x10, 0xc7, 0x02, 0x12, 0x14, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x30, 0x33, 0x10,
+	0xc8, 0x02, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x36, 0x31, 0x30, 0x34, 0x10, 0x15, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x30, 0x35, 0x10, 0xd1, 0x02, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x30, 0x36,
+	0x10, 0x16, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x36, 0x31, 0x30, 0x37, 0x10, 0x17, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x30, 0x38, 0x10, 0x18, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x30, 0x39, 0x10,
+	0x02, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x36, 0x31, 0x31, 0x30, 0x10, 0x21, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x31, 0x31, 0x10, 0x22, 0x12, 0x14, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x31, 0x32, 0x10, 0xa1,
+	0x04, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x36, 0x31, 0x31, 0x33, 0x10, 0x91, 0x44, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x31, 0x34, 0x10, 0x93, 0x44, 0x12, 0x14, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x31, 0x35,
+	0x10, 0x94, 0x44, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x36, 0x31, 0x31, 0x36, 0x10, 0xa2, 0x04, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x31, 0x37, 0x10, 0xa3, 0x44, 0x12,
+	0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31,
+	0x31, 0x38, 0x10, 0xa4, 0x44, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x31, 0x39, 0x10, 0xa3, 0x04, 0x12, 0x14, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x32, 0x30, 0x10, 0xa4,
+	0x04, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x36, 0x31, 0x32, 0x31, 0x10, 0xa5, 0x04, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x32, 0x32, 0x10, 0xa6, 0x04, 0x12, 0x14, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x32, 0x33,
+	0x10, 0xa7, 0x04, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x36, 0x31, 0x32, 0x34, 0x10, 0xa8, 0x04, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x32, 0x35, 0x10, 0xa9, 0x04, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31,
+	0x32, 0x36, 0x10, 0x23, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x36, 0x31, 0x32, 0x37, 0x10, 0x24, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x32, 0x38, 0x10, 0x25, 0x12, 0x14,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x32,
+	0x39, 0x10, 0xd1, 0x04, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x36, 0x31, 0x33, 0x30, 0x10, 0xd2, 0x04, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x33, 0x31, 0x10, 0xd3, 0x04,
+	0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36,
+	0x31, 0x33, 0x32, 0x10, 0xd4, 0x04, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x33, 0x33, 0x10, 0xd5, 0x04, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x33, 0x34, 0x10,
+	0x26, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x36, 0x31, 0x33, 0x35, 0x10, 0xe1, 0x04, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x33, 0x36, 0x10, 0xe2, 0x04, 0x12, 0x14, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x33, 0x37,
+	0x10, 0xe9, 0x04, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x36, 0x31, 0x33, 0x38, 0x10, 0xe6, 0x04, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x33, 0x39, 0x10, 0xe7, 0x04, 0x12,
+	0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31,
+	0x34, 0x30, 0x10, 0xe8, 0x04, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x34, 0x31, 0x10, 0xea, 0x04, 0x12, 0x14, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x34, 0x32, 0x10, 0xec,
+	0x04, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x36, 0x31, 0x34, 0x33, 0x10, 0xd1, 0x4d, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x34, 0x34, 0x10, 0xd2, 0x4d, 0x12, 0x14, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x34, 0x35,
+	0x10, 0xd3, 0x4d, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x36, 0x31, 0x34, 0x36, 0x10, 0xd4, 0x4d, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x34, 0x37, 0x10, 0xd5, 0x4d, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31,
+	0x34, 0x38, 0x10, 0x27, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x36, 0x31, 0x34, 0x39, 0x10, 0x28, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x35, 0x30, 0x10, 0x29, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x35,
+	0x31, 0x10, 0x2a, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x36, 0x31, 0x35, 0x32, 0x10, 0x2b, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x35, 0x33, 0x10, 0x2c, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x35, 0x34,
+	0x10, 0x2d, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x36, 0x31, 0x35, 0x35, 0x10, 0x91, 0x5c, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x35, 0x36, 0x10, 0x03, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x35, 0x37,
+	0x10, 0x31, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x36, 0x31, 0x35, 0x38, 0x10, 0x32, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x35, 0x39, 0x10, 0x33, 0x12, 0x14, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x36, 0x30, 0x10,
+	0xb1, 0x06, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x36, 0x31, 0x36, 0x31, 0x10, 0xb2, 0x06, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x36, 0x32, 0x10, 0xb3, 0x06, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x36,
+	0x33, 0x10, 0x34, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x36, 0x31, 0x36, 0x34, 0x10, 0xc1, 0x06, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x36, 0x35, 0x10, 0x35, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x36,
+	0x36, 0x10, 0x36, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x36, 0x31, 0x36, 0x37, 0x10, 0x04, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x36, 0x38, 0x10, 0x91, 0x08, 0x12, 0x15,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x36,
+	0x39, 0x10, 0x91, 0x82, 0x01, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x37, 0x30, 0x10, 0x92, 0x82, 0x01, 0x12, 0x15, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x37, 0x31, 0x10,
+	0x93, 0x82, 0x01, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x36, 0x31, 0x37, 0x32, 0x10, 0x94, 0x82, 0x01, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x37, 0x33, 0x10, 0x95, 0x82,
+	0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x36, 0x31, 0x37, 0x34, 0x10, 0x92, 0x08, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x37, 0x35, 0x10, 0xa1, 0x82, 0x01, 0x12, 0x14,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x37,
+	0x36, 0x10, 0x93, 0x08, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x36, 0x31, 0x37, 0x37, 0x10, 0xb1, 0x82, 0x01, 0x12, 0x15, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x37, 0x38, 0x10, 0xb2,
+	0x82, 0x01, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x36, 0x31, 0x37, 0x39, 0x10, 0xb3, 0x82, 0x01, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x38, 0x30, 0x10, 0xb4, 0x82, 0x01,
+	0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36,
+	0x31, 0x38, 0x31, 0x10, 0xb5, 0x82, 0x01, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x38, 0x32, 0x10, 0xb6, 0x82, 0x01, 0x12, 0x15,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x38,
+	0x33, 0x10, 0xb7, 0x82, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x38, 0x34, 0x10, 0x94, 0x08, 0x12, 0x15, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x38, 0x35, 0x10, 0xc1,
+	0x82, 0x01, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x36, 0x31, 0x38, 0x36, 0x10, 0xc2, 0x82, 0x01, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x38, 0x37, 0x10, 0xc3, 0x82, 0x01,
+	0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36,
+	0x31, 0x38, 0x38, 0x10, 0xc4, 0x82, 0x01, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x38, 0x39, 0x10, 0xc5, 0x82, 0x01, 0x12, 0x15,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x39,
+	0x30, 0x10, 0xc6, 0x82, 0x01, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x39, 0x31, 0x10, 0xc7, 0x82, 0x01, 0x12, 0x15, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x39, 0x32, 0x10,
+	0xc8, 0x82, 0x01, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x36, 0x31, 0x39, 0x33, 0x10, 0xc9, 0x82, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x39, 0x34, 0x10, 0x96, 0x08,
+	0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36,
+	0x31, 0x39, 0x35, 0x10, 0xe1, 0x82, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x39, 0x36, 0x10, 0x97, 0x08, 0x12, 0x15, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x39, 0x37,
+	0x10, 0xf1, 0x82, 0x01, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x36, 0x31, 0x39, 0x38, 0x10, 0x91, 0xae, 0x10, 0x12, 0x15, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x31, 0x39, 0x39, 0x10, 0x92,
+	0xae, 0x10, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x36, 0x32, 0x30, 0x30, 0x10, 0x93, 0xae, 0x10, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x30, 0x31, 0x10, 0x94, 0xae, 0x10,
+	0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36,
+	0x32, 0x30, 0x32, 0x10, 0x98, 0x08, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x30, 0x33, 0x10, 0x81, 0x83, 0x01, 0x12, 0x15, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x30, 0x34,
+	0x10, 0x82, 0x83, 0x01, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x36, 0x32, 0x30, 0x35, 0x10, 0x83, 0x83, 0x01, 0x12, 0x15, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x30, 0x36, 0x10, 0x84,
+	0x83, 0x01, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x36, 0x32, 0x30, 0x37, 0x10, 0x85, 0x83, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x30, 0x38, 0x10, 0x99, 0x08, 0x12,
+	0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32,
+	0x30, 0x39, 0x10, 0xa0, 0x08, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x31, 0x30, 0x10, 0xa2, 0x08, 0x12, 0x14, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x31, 0x31, 0x10, 0xa3,
+	0x08, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x36, 0x32, 0x31, 0x32, 0x10, 0xa4, 0x08, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x31, 0x33, 0x10, 0xa5, 0x08, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x31, 0x34,
+	0x10, 0x05, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x36, 0x32, 0x31, 0x35, 0x10, 0x06, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x31, 0x36, 0x10, 0x61, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x31, 0x37, 0x10,
+	0x62, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x36, 0x32, 0x31, 0x38, 0x10, 0x63, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x31, 0x39, 0x10, 0x64, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x32, 0x30, 0x10, 0x65,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36,
+	0x32, 0x32, 0x31, 0x10, 0x66, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x32, 0x32, 0x10, 0x67, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x32, 0x33, 0x10, 0x68, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32,
+	0x32, 0x34, 0x10, 0x69, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x36, 0x32, 0x32, 0x35, 0x10, 0x6a, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x32, 0x36, 0x10, 0x6c, 0x12, 0x14,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x32,
+	0x37, 0x10, 0xc1, 0x0d, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x36, 0x32, 0x32, 0x38, 0x10, 0xc2, 0x0d, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x32, 0x39, 0x10, 0xc3, 0x0d,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36,
+	0x32, 0x33, 0x30, 0x10, 0x07, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x33, 0x31, 0x10, 0x08, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x33, 0x32, 0x10, 0x09, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32,
+	0x33, 0x33, 0x10, 0x0a, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x36, 0x32, 0x33, 0x34, 0x10, 0xa1, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x33, 0x35, 0x10, 0x91, 0x14,
+	0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36,
+	0x32, 0x33, 0x36, 0x10, 0x91, 0xc2, 0x02, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x33, 0x37, 0x10, 0x92, 0xc2, 0x02, 0x12, 0x14,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x33,
+	0x38, 0x10, 0x92, 0x14, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x36, 0x32, 0x33, 0x39, 0x10, 0x93, 0x14, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x34, 0x30, 0x10, 0xb1, 0xc2,
+	0x02, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x36, 0x32, 0x34, 0x31, 0x10, 0x94, 0x14, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x34, 0x32, 0x10, 0x95, 0x14, 0x12, 0x15, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x34, 0x33,
+	0x10, 0xd1, 0xc2, 0x02, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x36, 0x32, 0x34, 0x34, 0x10, 0xd2, 0xc2, 0x02, 0x12, 0x15, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x34, 0x35, 0x10, 0xd3,
+	0xc2, 0x02, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x36, 0x32, 0x34, 0x36, 0x10, 0xd4, 0xc2, 0x02, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x34, 0x37, 0x10, 0x96, 0x14, 0x12,
+	0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32,
+	0x34, 0x38, 0x10, 0x97, 0x14, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x34, 0x39, 0x10, 0x98, 0x14, 0x12, 0x14, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x35, 0x30, 0x10, 0xa2,
+	0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x36, 0x32, 0x35, 0x31, 0x10, 0xa1, 0x14, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x35, 0x32, 0x10, 0x91, 0xc4, 0x02, 0x12, 0x15,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x35,
+	0x33, 0x10, 0x91, 0xc2, 0x28, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x35, 0x34, 0x10, 0x92, 0xc2, 0x28, 0x12, 0x15, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x35, 0x35, 0x10,
+	0x92, 0xc4, 0x02, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x36, 0x32, 0x35, 0x36, 0x10, 0x93, 0xc4, 0x02, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x35, 0x37, 0x10, 0x94, 0xc4,
+	0x02, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x36, 0x32, 0x35, 0x38, 0x10, 0xc1, 0xc2, 0x28, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x35, 0x39, 0x10, 0xa2, 0x14, 0x12, 0x15,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x36,
+	0x30, 0x10, 0xa1, 0xc4, 0x02, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x36, 0x31, 0x10, 0xa2, 0xc4, 0x02, 0x12, 0x15, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x36, 0x32, 0x10,
+	0xa3, 0xc4, 0x02, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x36, 0x32, 0x36, 0x33, 0x10, 0xa3, 0x14, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x36, 0x34, 0x10, 0xb1, 0xc4, 0x02,
+	0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36,
+	0x32, 0x36, 0x35, 0x10, 0xb2, 0xc4, 0x02, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x36, 0x36, 0x10, 0xb3, 0xc4, 0x02, 0x12, 0x15,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x36,
+	0x37, 0x10, 0xb4, 0xc4, 0x02, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x36, 0x38, 0x10, 0xb5, 0xc4, 0x02, 0x12, 0x15, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x36, 0x39, 0x10,
+	0xd1, 0xc6, 0x28, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x36, 0x32, 0x37, 0x30, 0x10, 0xd2, 0xc6, 0x28, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x37, 0x31, 0x10, 0xb6, 0xc4,
+	0x02, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x36, 0x32, 0x37, 0x32, 0x10, 0xb7, 0xc4, 0x02, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x37, 0x33, 0x10, 0xa4, 0x14, 0x12, 0x14,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x37,
+	0x34, 0x10, 0xa5, 0x14, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x36, 0x32, 0x37, 0x35, 0x10, 0xa6, 0x14, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x37, 0x36, 0x10, 0xe1, 0xc4,
+	0x02, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x36, 0x32, 0x37, 0x37, 0x10, 0xe2, 0xc4, 0x02, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x37, 0x38, 0x10, 0xe3, 0xc4, 0x02, 0x12,
+	0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32,
+	0x37, 0x39, 0x10, 0xe4, 0xc4, 0x02, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x38, 0x30, 0x10, 0xe5, 0xc4, 0x02, 0x12, 0x15, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x38, 0x31,
+	0x10, 0xd1, 0xcc, 0x28, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x36, 0x32, 0x38, 0x32, 0x10, 0xd2, 0xcc, 0x28, 0x12, 0x15, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x38, 0x33, 0x10, 0xd3,
+	0xcc, 0x28, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x36, 0x32, 0x38, 0x34, 0x10, 0xd4, 0xcc, 0x28, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x38, 0x35, 0x10, 0xa7, 0x14, 0x12,
+	0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32,
+	0x38, 0x36, 0x10, 0xa8, 0x14, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x38, 0x37, 0x10, 0xa9, 0x14, 0x12, 0x14, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x38, 0x38, 0x10, 0xab,
+	0x14, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x36, 0x32, 0x38, 0x39, 0x10, 0xac, 0x14, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x39, 0x30, 0x10, 0xa3, 0x01, 0x12, 0x14, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x39, 0x31,
+	0x10, 0xb0, 0x14, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x36, 0x32, 0x39, 0x32, 0x10, 0xb1, 0x14, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x39, 0x33, 0x10, 0xb2, 0x14, 0x12,
+	0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32,
+	0x39, 0x34, 0x10, 0xb3, 0x14, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x39, 0x35, 0x10, 0xb4, 0x14, 0x12, 0x14, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x39, 0x36, 0x10, 0xa4,
+	0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x36, 0x32, 0x39, 0x37, 0x10, 0xc1, 0x14, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x39, 0x38, 0x10, 0xc2, 0x14, 0x12, 0x15, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x32, 0x39, 0x39,
+	0x10, 0xa1, 0xc8, 0x02, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x36, 0x33, 0x30, 0x30, 0x10, 0xa2, 0xc8, 0x02, 0x12, 0x15, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x30, 0x31, 0x10, 0xa3,
+	0xc8, 0x02, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x36, 0x33, 0x30, 0x32, 0x10, 0xc3, 0x14, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x30, 0x33, 0x10, 0xc4, 0x14, 0x12, 0x14,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x30,
+	0x34, 0x10, 0xa5, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x36, 0x33, 0x30, 0x35, 0x10, 0xd1, 0x14, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x30, 0x36, 0x10, 0x91, 0xca,
+	0x02, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x36, 0x33, 0x30, 0x37, 0x10, 0x92, 0xca, 0x02, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x30, 0x38, 0x10, 0xd2, 0x14, 0x12, 0x14,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x30,
+	0x39, 0x10, 0xd3, 0x14, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x36, 0x33, 0x31, 0x30, 0x10, 0xd4, 0x14, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x31, 0x31, 0x10, 0xd6, 0x14,
+	0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36,
+	0x33, 0x31, 0x32, 0x10, 0xd7, 0x14, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x31, 0x33, 0x10, 0xf1, 0xca, 0x02, 0x12, 0x14, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x31, 0x34,
+	0x10, 0xd8, 0x14, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x36, 0x33, 0x31, 0x35, 0x10, 0xd9, 0x14, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x31, 0x36, 0x10, 0xda, 0x14, 0x12,
+	0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33,
+	0x31, 0x37, 0x10, 0xdb, 0x14, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x31, 0x38, 0x10, 0xdc, 0x14, 0x12, 0x14, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x31, 0x39, 0x10, 0xdd,
+	0x14, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x36, 0x33, 0x32, 0x30, 0x10, 0xde, 0x14, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x32, 0x31, 0x10, 0xf1, 0xcb, 0x02, 0x12, 0x15,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x32,
+	0x32, 0x10, 0xf2, 0xcb, 0x02, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x32, 0x33, 0x10, 0xf3, 0xcb, 0x02, 0x12, 0x14, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x32, 0x34, 0x10,
+	0xa6, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x36, 0x33, 0x32, 0x35, 0x10, 0xe1, 0x14, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x32, 0x36, 0x10, 0xe2, 0x14, 0x12, 0x15,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x32,
+	0x37, 0x10, 0xa1, 0xcc, 0x02, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x32, 0x38, 0x10, 0xe3, 0x14, 0x12, 0x14, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x32, 0x39, 0x10, 0xe4,
+	0x14, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x36, 0x33, 0x33, 0x30, 0x10, 0xe5, 0x14, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x33, 0x31, 0x10, 0xe6, 0x14, 0x12, 0x14, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x33, 0x32,
+	0x10, 0xe7, 0x14, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x36, 0x33, 0x33, 0x33, 0x10, 0xf1, 0xcc, 0x02, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x33, 0x34, 0x10, 0xe8, 0x14,
+	0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36,
+	0x33, 0x33, 0x35, 0x10, 0xe9, 0x14, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x33, 0x36, 0x10, 0x81, 0xce, 0x02, 0x12, 0x15, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x33, 0x37,
+	0x10, 0x82, 0xce, 0x02, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x36, 0x33, 0x33, 0x38, 0x10, 0x83, 0xce, 0x02, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x33, 0x39, 0x10, 0x0b,
+	0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36,
+	0x33, 0x34, 0x30, 0x10, 0xb1, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x34, 0x31, 0x10, 0x91, 0x16, 0x12, 0x14, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x34, 0x32, 0x10,
+	0xb3, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x36, 0x33, 0x34, 0x33, 0x10, 0xb4, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x34, 0x34, 0x10, 0xc1, 0x16, 0x12, 0x14,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x34,
+	0x35, 0x10, 0xb6, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x36, 0x33, 0x34, 0x36, 0x10, 0xb7, 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x34, 0x37, 0x10, 0x0c, 0x12,
+	0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33,
+	0x34, 0x38, 0x10, 0x91, 0x18, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x34, 0x39, 0x10, 0xc2, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x35, 0x30, 0x10, 0xc3,
+	0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x36, 0x33, 0x35, 0x31, 0x10, 0xc4, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x35, 0x32, 0x10, 0xc6, 0x01, 0x12, 0x14, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x35, 0x33,
+	0x10, 0xe1, 0x18, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x36, 0x33, 0x35, 0x34, 0x10, 0xc7, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x35, 0x35, 0x10, 0xc8, 0x01, 0x12,
+	0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33,
+	0x35, 0x36, 0x10, 0xd0, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x35, 0x37, 0x10, 0x81, 0x1a, 0x12, 0x14, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x35, 0x38, 0x10, 0x82,
+	0x1a, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x36, 0x33, 0x35, 0x39, 0x10, 0x83, 0x1a, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x36, 0x30, 0x10, 0xd1, 0x01, 0x12, 0x14, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x36, 0x31,
+	0x10, 0xd2, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x36, 0x33, 0x36, 0x32, 0x10, 0xd3, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x36, 0x33, 0x10, 0xb1, 0x1a, 0x12,
+	0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33,
+	0x36, 0x34, 0x10, 0xb2, 0x1a, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x36, 0x35, 0x10, 0xb3, 0x1a, 0x12, 0x14, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x36, 0x36, 0x10, 0xb4,
+	0x1a, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x36, 0x33, 0x36, 0x37, 0x10, 0xb5, 0x1a, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x36, 0x38, 0x10, 0x91, 0xec, 0x34, 0x12, 0x15,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x36,
+	0x39, 0x10, 0x92, 0xec, 0x34, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x37, 0x30, 0x10, 0x93, 0xec, 0x34, 0x12, 0x15, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x37, 0x31, 0x10,
+	0x94, 0xec, 0x34, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x36, 0x33, 0x37, 0x32, 0x10, 0x95, 0xec, 0x34, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x37, 0x33, 0x10, 0x96, 0xec,
+	0x34, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x36, 0x33, 0x37, 0x34, 0x10, 0x97, 0xec, 0x34, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x37, 0x35, 0x10, 0x98, 0xec, 0x34, 0x12,
+	0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33,
+	0x37, 0x36, 0x10, 0x99, 0xec, 0x34, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x37, 0x37, 0x10, 0x9a, 0xec, 0x34, 0x12, 0x15, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x37, 0x38,
+	0x10, 0x9b, 0xec, 0x34, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x36, 0x33, 0x37, 0x39, 0x10, 0x9c, 0xec, 0x34, 0x12, 0x15, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x38, 0x30, 0x10, 0x9d,
+	0xec, 0x34, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x36, 0x33, 0x38, 0x31, 0x10, 0x9e, 0xec, 0x34, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x38, 0x32, 0x10, 0x9f, 0xec, 0x34,
+	0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36,
+	0x33, 0x38, 0x33, 0x10, 0xa0, 0xec, 0x34, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x38, 0x34, 0x10, 0xa1, 0xec, 0x34, 0x12, 0x15,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x38,
+	0x35, 0x10, 0xa2, 0xec, 0x34, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x38, 0x36, 0x10, 0xa3, 0xec, 0x34, 0x12, 0x15, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x38, 0x37, 0x10,
+	0xa4, 0xec, 0x34, 0x12, 0x15, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x36, 0x33, 0x38, 0x38, 0x10, 0xa5, 0xec, 0x34, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x38, 0x39, 0x10, 0xd4, 0x01,
+	0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36,
+	0x33, 0x39, 0x30, 0x10, 0xc1, 0x1a, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x39, 0x31, 0x10, 0xc2, 0x1a, 0x12, 0x14, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x39, 0x32, 0x10,
+	0xc3, 0x1a, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x36, 0x33, 0x39, 0x33, 0x10, 0xd5, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x39, 0x34, 0x10, 0xd6, 0x01, 0x12, 0x14,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x39,
+	0x35, 0x10, 0xd7, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x36, 0x33, 0x39, 0x36, 0x10, 0xf1, 0x1a, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x39, 0x37, 0x10, 0xf2, 0x1a,
+	0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36,
+	0x33, 0x39, 0x38, 0x10, 0xd8, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x33, 0x39, 0x39, 0x10, 0xd9, 0x01, 0x12, 0x14, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x34, 0x30, 0x30, 0x10,
+	0x91, 0x1b, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x36, 0x34, 0x30, 0x31, 0x10, 0x92, 0x1b, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x34, 0x30, 0x32, 0x10, 0x93, 0x1b, 0x12, 0x14,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x34, 0x30,
+	0x33, 0x10, 0xfe, 0x01, 0x12, 0x14, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x36, 0x34, 0x30, 0x34, 0x10, 0xff, 0x01, 0x2a, 0xdd, 0x01, 0x0a, 0x09, 0x45,
+	0x6e, 0x75, 0x6d, 0x31, 0x36, 0x35, 0x35, 0x33, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x35, 0x35, 0x34, 0x10, 0x00, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x35, 0x35, 0x35,
+	0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x36, 0x35, 0x35, 0x36, 0x10, 0x02, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x35, 0x35, 0x37, 0x10, 0x03, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x35, 0x35, 0x38, 0x10,
+	0x04, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x36, 0x35, 0x35, 0x39, 0x10, 0x05, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x35, 0x36, 0x30, 0x10, 0x06, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x35, 0x36, 0x31, 0x10, 0x07,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36,
+	0x35, 0x36, 0x32, 0x10, 0x08, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x36, 0x35, 0x36, 0x33, 0x10, 0x09, 0x2a, 0x4a, 0x0a, 0x09, 0x45, 0x6e,
+	0x75, 0x6d, 0x31, 0x36, 0x37, 0x32, 0x38, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x37, 0x32, 0x39, 0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x37, 0x33, 0x30, 0x10,
+	0x02, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x36, 0x37, 0x33, 0x31, 0x10, 0x03, 0x2a, 0x74, 0x0a, 0x09, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x36,
+	0x37, 0x33, 0x32, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x36, 0x37, 0x33, 0x33, 0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x37, 0x33, 0x34, 0x10, 0x02, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x37, 0x33, 0x35,
+	0x10, 0x03, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x36, 0x37, 0x33, 0x36, 0x10, 0x04, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x37, 0x33, 0x37, 0x10, 0x05, 0x2a, 0x9e, 0x01, 0x0a,
+	0x09, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x36, 0x37, 0x33, 0x38, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x37, 0x33, 0x39, 0x10, 0x01, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x37,
+	0x34, 0x30, 0x10, 0x02, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x36, 0x37, 0x34, 0x31, 0x10, 0x03, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x37, 0x34, 0x32, 0x10, 0x04, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x37, 0x34,
+	0x33, 0x10, 0x05, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x36, 0x37, 0x34, 0x34, 0x10, 0x06, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x37, 0x34, 0x35, 0x10, 0x07, 0x2a, 0xf7, 0x03,
+	0x0a, 0x09, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x36, 0x36, 0x39, 0x38, 0x12, 0x1c, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x36, 0x39, 0x39, 0x10, 0xff,
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x37, 0x30, 0x30, 0x10, 0x64, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x37, 0x30,
+	0x31, 0x10, 0x02, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x36, 0x37, 0x30, 0x32, 0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x37, 0x30, 0x33, 0x10, 0x01, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x37, 0x30, 0x34,
+	0x10, 0x04, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x36, 0x37, 0x30, 0x35, 0x10, 0x0b, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x37, 0x30, 0x36, 0x10, 0x0c, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x37, 0x30, 0x37, 0x10,
+	0x03, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x36, 0x37, 0x30, 0x38, 0x10, 0x05, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x37, 0x30, 0x39, 0x10, 0x06, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x37, 0x31, 0x30, 0x10, 0x07,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36,
+	0x37, 0x31, 0x31, 0x10, 0x08, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x36, 0x37, 0x31, 0x32, 0x10, 0x09, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x37, 0x31, 0x33, 0x10, 0x0a, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x37,
+	0x31, 0x34, 0x10, 0x0d, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x36, 0x37, 0x31, 0x35, 0x10, 0x0e, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x37, 0x31, 0x36, 0x10, 0x0f, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x37, 0x31,
+	0x37, 0x10, 0x10, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x36, 0x37, 0x31, 0x38, 0x10, 0x12, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x37, 0x31, 0x39, 0x10, 0x11, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x37, 0x32, 0x30,
+	0x10, 0x13, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x36, 0x37, 0x32, 0x31, 0x10, 0x14, 0x2a, 0x89, 0x01, 0x0a, 0x09, 0x45, 0x6e, 0x75, 0x6d,
+	0x31, 0x36, 0x38, 0x31, 0x39, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x36, 0x38, 0x32, 0x30, 0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x38, 0x32, 0x31, 0x10, 0x01, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x38,
+	0x32, 0x32, 0x10, 0x02, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x36, 0x38, 0x32, 0x33, 0x10, 0x03, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x38, 0x32, 0x34, 0x10, 0x04, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x38, 0x32,
+	0x35, 0x10, 0x05, 0x2a, 0xb1, 0x02, 0x0a, 0x09, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x36, 0x39, 0x32,
+	0x35, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x36, 0x39, 0x32, 0x36, 0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x39, 0x32, 0x37, 0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x39, 0x32, 0x38, 0x10, 0x02,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36,
+	0x39, 0x32, 0x39, 0x10, 0x03, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x36, 0x39, 0x33, 0x30, 0x10, 0x04, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x39, 0x33, 0x31, 0x10, 0x05, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x39,
+	0x33, 0x32, 0x10, 0x06, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x36, 0x39, 0x33, 0x33, 0x10, 0x07, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x39, 0x33, 0x34, 0x10, 0x08, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x39, 0x33,
+	0x35, 0x10, 0x09, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x36, 0x39, 0x33, 0x36, 0x10, 0x0a, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x39, 0x33, 0x37, 0x10, 0x0b, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x39, 0x33, 0x38,
+	0x10, 0x0c, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x36, 0x39, 0x33, 0x39, 0x10, 0x0d, 0x2a, 0x35, 0x0a, 0x09, 0x45, 0x6e, 0x75, 0x6d, 0x32,
+	0x32, 0x38, 0x35, 0x34, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x32, 0x32, 0x38, 0x35, 0x35, 0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x32, 0x38, 0x35, 0x36, 0x10, 0x01, 0x2a, 0x5f,
+	0x0a, 0x09, 0x45, 0x6e, 0x75, 0x6d, 0x32, 0x34, 0x33, 0x36, 0x31, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x34, 0x33, 0x36, 0x32, 0x10, 0x00,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x34,
+	0x33, 0x36, 0x33, 0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x32, 0x34, 0x33, 0x36, 0x34, 0x10, 0x02, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x34, 0x33, 0x36, 0x35, 0x10, 0x03, 0x2a,
+	0xab, 0x05, 0x0a, 0x09, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x36, 0x38, 0x39, 0x31, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x38, 0x39, 0x32,
+	0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x36, 0x38, 0x39, 0x33, 0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x38, 0x39, 0x34, 0x10, 0x02, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x38, 0x39, 0x35, 0x10,
+	0x03, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x36, 0x38, 0x39, 0x36, 0x10, 0x04, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x38, 0x39, 0x37, 0x10, 0x05, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x38, 0x39, 0x38, 0x10, 0x06,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36,
+	0x38, 0x39, 0x39, 0x10, 0x07, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x36, 0x39, 0x30, 0x30, 0x10, 0x08, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x39, 0x30, 0x31, 0x10, 0x09, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x39,
+	0x30, 0x32, 0x10, 0x0a, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x36, 0x39, 0x30, 0x33, 0x10, 0x0b, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x39, 0x30, 0x34, 0x10, 0x0c, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x39, 0x30,
+	0x35, 0x10, 0x0d, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x36, 0x39, 0x30, 0x36, 0x10, 0x0e, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x39, 0x30, 0x37, 0x10, 0x0f, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x39, 0x30, 0x38,
+	0x10, 0x10, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x36, 0x39, 0x30, 0x39, 0x10, 0x11, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x39, 0x31, 0x30, 0x10, 0x12, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x39, 0x31, 0x31, 0x10,
+	0x13, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x36, 0x39, 0x31, 0x32, 0x10, 0x14, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x39, 0x31, 0x33, 0x10, 0x15, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x39, 0x31, 0x34, 0x10, 0x16,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36,
+	0x39, 0x31, 0x35, 0x10, 0x17, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x36, 0x39, 0x31, 0x36, 0x10, 0x18, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x39, 0x31, 0x37, 0x10, 0x19, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x39,
+	0x31, 0x38, 0x10, 0x1a, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x36, 0x39, 0x31, 0x39, 0x10, 0x1b, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x39, 0x32, 0x30, 0x10, 0x1c, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x39, 0x32,
+	0x31, 0x10, 0x1d, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x36, 0x39, 0x32, 0x32, 0x10, 0x1e, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x36, 0x39, 0x32, 0x33, 0x10, 0x1f, 0x2a, 0x74, 0x0a,
+	0x09, 0x45, 0x6e, 0x75, 0x6d, 0x32, 0x37, 0x33, 0x36, 0x31, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x37, 0x33, 0x36, 0x32, 0x10, 0x00, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x37, 0x33,
+	0x36, 0x33, 0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x32, 0x37, 0x33, 0x36, 0x34, 0x10, 0x02, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x37, 0x33, 0x36, 0x35, 0x10, 0x03, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x37, 0x33, 0x36,
+	0x36, 0x10, 0x04, 0x2a, 0x9e, 0x01, 0x0a, 0x09, 0x45, 0x6e, 0x75, 0x6d, 0x33, 0x33, 0x39, 0x36,
+	0x30, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33,
+	0x33, 0x39, 0x36, 0x31, 0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x33, 0x33, 0x39, 0x36, 0x32, 0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x33, 0x39, 0x36, 0x33, 0x10, 0x02,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x33,
+	0x39, 0x36, 0x34, 0x10, 0x03, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x33, 0x33, 0x39, 0x36, 0x35, 0x10, 0x04, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x33, 0x39, 0x36, 0x36, 0x10, 0x05, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x33, 0x39,
+	0x36, 0x37, 0x10, 0x06, 0x2a, 0x20, 0x0a, 0x09, 0x45, 0x6e, 0x75, 0x6d, 0x33, 0x34, 0x33, 0x38,
+	0x38, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33,
+	0x34, 0x33, 0x38, 0x39, 0x10, 0x01, 0x2a, 0x74, 0x0a, 0x09, 0x45, 0x6e, 0x75, 0x6d, 0x33, 0x35,
+	0x34, 0x37, 0x37, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x35, 0x34, 0x37, 0x38, 0x10, 0x04, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x34, 0x37, 0x39, 0x10, 0x03, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x34, 0x38, 0x30,
+	0x10, 0x02, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x33, 0x35, 0x34, 0x38, 0x31, 0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x34, 0x38, 0x32, 0x10, 0x00, 0x2a, 0xdd, 0x01, 0x0a,
+	0x09, 0x45, 0x6e, 0x75, 0x6d, 0x33, 0x35, 0x35, 0x30, 0x37, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x35, 0x30, 0x38, 0x10, 0x00, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x35,
+	0x30, 0x39, 0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x35, 0x35, 0x31, 0x30, 0x10, 0x02, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x35, 0x31, 0x31, 0x10, 0x03, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x35, 0x31,
+	0x32, 0x10, 0x04, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x35, 0x35, 0x31, 0x33, 0x10, 0x05, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x35, 0x31, 0x34, 0x10, 0x06, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x35, 0x31, 0x35,
+	0x10, 0x07, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x33, 0x35, 0x35, 0x31, 0x36, 0x10, 0x08, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x35, 0x31, 0x37, 0x10, 0x09, 0x2a, 0xb3, 0x01, 0x0a,
+	0x09, 0x45, 0x6e, 0x75, 0x6d, 0x33, 0x36, 0x38, 0x36, 0x30, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x38, 0x36, 0x31, 0x10, 0x00, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x38,
+	0x36, 0x32, 0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x36, 0x38, 0x36, 0x33, 0x10, 0x02, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x38, 0x36, 0x34, 0x10, 0x03, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x38, 0x36,
+	0x35, 0x10, 0x04, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x36, 0x38, 0x36, 0x36, 0x10, 0x05, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x38, 0x36, 0x37, 0x10, 0x06, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x38, 0x36, 0x38,
+	0x10, 0x07, 0x2a, 0x35, 0x0a, 0x09, 0x45, 0x6e, 0x75, 0x6d, 0x33, 0x36, 0x38, 0x39, 0x30, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x38,
+	0x39, 0x31, 0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x36, 0x38, 0x39, 0x32, 0x10, 0x01, 0x42, 0x23, 0x0a, 0x1e, 0x63, 0x6f, 0x6d,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0xf8, 0x01, 0x01,
+}
+
+var (
+	file_datasets_google_message3_benchmark_message3_8_proto_rawDescOnce sync.Once
+	file_datasets_google_message3_benchmark_message3_8_proto_rawDescData = file_datasets_google_message3_benchmark_message3_8_proto_rawDesc
+)
+
+func file_datasets_google_message3_benchmark_message3_8_proto_rawDescGZIP() []byte {
+	file_datasets_google_message3_benchmark_message3_8_proto_rawDescOnce.Do(func() {
+		file_datasets_google_message3_benchmark_message3_8_proto_rawDescData = protoimpl.X.CompressGZIP(file_datasets_google_message3_benchmark_message3_8_proto_rawDescData)
+	})
+	return file_datasets_google_message3_benchmark_message3_8_proto_rawDescData
+}
+
+var file_datasets_google_message3_benchmark_message3_8_proto_enumTypes = make([]protoimpl.EnumInfo, 59)
+var file_datasets_google_message3_benchmark_message3_8_proto_goTypes = []interface{}{
+	(Enum720)(0),    // 0: benchmarks.google_message3.Enum720
+	(Enum3476)(0),   // 1: benchmarks.google_message3.Enum3476
+	(Enum3805)(0),   // 2: benchmarks.google_message3.Enum3805
+	(Enum3783)(0),   // 3: benchmarks.google_message3.Enum3783
+	(Enum3851)(0),   // 4: benchmarks.google_message3.Enum3851
+	(UnusedEnum)(0), // 5: benchmarks.google_message3.UnusedEnum
+	(Enum4146)(0),   // 6: benchmarks.google_message3.Enum4146
+	(Enum4160)(0),   // 7: benchmarks.google_message3.Enum4160
+	(Enum4152)(0),   // 8: benchmarks.google_message3.Enum4152
+	(Enum6025)(0),   // 9: benchmarks.google_message3.Enum6025
+	(Enum6065)(0),   // 10: benchmarks.google_message3.Enum6065
+	(Enum6579)(0),   // 11: benchmarks.google_message3.Enum6579
+	(Enum6588)(0),   // 12: benchmarks.google_message3.Enum6588
+	(Enum6769)(0),   // 13: benchmarks.google_message3.Enum6769
+	(Enum6774)(0),   // 14: benchmarks.google_message3.Enum6774
+	(Enum6782)(0),   // 15: benchmarks.google_message3.Enum6782
+	(Enum6858)(0),   // 16: benchmarks.google_message3.Enum6858
+	(Enum6815)(0),   // 17: benchmarks.google_message3.Enum6815
+	(Enum6822)(0),   // 18: benchmarks.google_message3.Enum6822
+	(Enum7654)(0),   // 19: benchmarks.google_message3.Enum7654
+	(Enum8292)(0),   // 20: benchmarks.google_message3.Enum8292
+	(Enum8450)(0),   // 21: benchmarks.google_message3.Enum8450
+	(Enum8900)(0),   // 22: benchmarks.google_message3.Enum8900
+	(Enum8945)(0),   // 23: benchmarks.google_message3.Enum8945
+	(Enum8951)(0),   // 24: benchmarks.google_message3.Enum8951
+	(Enum9243)(0),   // 25: benchmarks.google_message3.Enum9243
+	(Enum10157)(0),  // 26: benchmarks.google_message3.Enum10157
+	(Enum10167)(0),  // 27: benchmarks.google_message3.Enum10167
+	(Enum8862)(0),   // 28: benchmarks.google_message3.Enum8862
+	(Enum10325)(0),  // 29: benchmarks.google_message3.Enum10325
+	(Enum10335)(0),  // 30: benchmarks.google_message3.Enum10335
+	(Enum10337)(0),  // 31: benchmarks.google_message3.Enum10337
+	(Enum10392)(0),  // 32: benchmarks.google_message3.Enum10392
+	(Enum11107)(0),  // 33: benchmarks.google_message3.Enum11107
+	(Enum11541)(0),  // 34: benchmarks.google_message3.Enum11541
+	(Enum11468)(0),  // 35: benchmarks.google_message3.Enum11468
+	(Enum11022)(0),  // 36: benchmarks.google_message3.Enum11022
+	(Enum12670)(0),  // 37: benchmarks.google_message3.Enum12670
+	(Enum12871)(0),  // 38: benchmarks.google_message3.Enum12871
+	(Enum13092)(0),  // 39: benchmarks.google_message3.Enum13092
+	(Enum13146)(0),  // 40: benchmarks.google_message3.Enum13146
+	(Enum16042)(0),  // 41: benchmarks.google_message3.Enum16042
+	(Enum16553)(0),  // 42: benchmarks.google_message3.Enum16553
+	(Enum16728)(0),  // 43: benchmarks.google_message3.Enum16728
+	(Enum16732)(0),  // 44: benchmarks.google_message3.Enum16732
+	(Enum16738)(0),  // 45: benchmarks.google_message3.Enum16738
+	(Enum16698)(0),  // 46: benchmarks.google_message3.Enum16698
+	(Enum16819)(0),  // 47: benchmarks.google_message3.Enum16819
+	(Enum16925)(0),  // 48: benchmarks.google_message3.Enum16925
+	(Enum22854)(0),  // 49: benchmarks.google_message3.Enum22854
+	(Enum24361)(0),  // 50: benchmarks.google_message3.Enum24361
+	(Enum16891)(0),  // 51: benchmarks.google_message3.Enum16891
+	(Enum27361)(0),  // 52: benchmarks.google_message3.Enum27361
+	(Enum33960)(0),  // 53: benchmarks.google_message3.Enum33960
+	(Enum34388)(0),  // 54: benchmarks.google_message3.Enum34388
+	(Enum35477)(0),  // 55: benchmarks.google_message3.Enum35477
+	(Enum35507)(0),  // 56: benchmarks.google_message3.Enum35507
+	(Enum36860)(0),  // 57: benchmarks.google_message3.Enum36860
+	(Enum36890)(0),  // 58: benchmarks.google_message3.Enum36890
+}
+var file_datasets_google_message3_benchmark_message3_8_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_datasets_google_message3_benchmark_message3_8_proto_init() }
+func file_datasets_google_message3_benchmark_message3_8_proto_init() {
+	if File_datasets_google_message3_benchmark_message3_8_proto != nil {
+		return
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_datasets_google_message3_benchmark_message3_8_proto_rawDesc,
+			NumEnums:      59,
+			NumMessages:   0,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_datasets_google_message3_benchmark_message3_8_proto_goTypes,
+		DependencyIndexes: file_datasets_google_message3_benchmark_message3_8_proto_depIdxs,
+		EnumInfos:         file_datasets_google_message3_benchmark_message3_8_proto_enumTypes,
+	}.Build()
+	File_datasets_google_message3_benchmark_message3_8_proto = out.File
+	file_datasets_google_message3_benchmark_message3_8_proto_rawDesc = nil
+	file_datasets_google_message3_benchmark_message3_8_proto_goTypes = nil
+	file_datasets_google_message3_benchmark_message3_8_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message4/benchmark_message4.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message4/benchmark_message4.pb.go
new file mode 100644
index 000000000..4d6ef262e
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message4/benchmark_message4.pb.go
@@ -0,0 +1,6196 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// LINT: ALLOW_GROUPS
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: datasets/google_message4/benchmark_message4.proto
+
+package google_message4
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoiface "google.golang.org/protobuf/runtime/protoiface"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type GoogleMessage4 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field37503 *int32              `protobuf:"varint,1,opt,name=field37503" json:"field37503,omitempty"`
+	Field37504 *UnusedEmptyMessage `protobuf:"bytes,2,opt,name=field37504" json:"field37504,omitempty"`
+	Field37505 *UnusedEmptyMessage `protobuf:"bytes,3,opt,name=field37505" json:"field37505,omitempty"`
+	Field37506 *UnusedEmptyMessage `protobuf:"bytes,4,opt,name=field37506" json:"field37506,omitempty"`
+	Field37507 *UnusedEmptyMessage `protobuf:"bytes,5,opt,name=field37507" json:"field37507,omitempty"`
+	Field37508 *Message37489       `protobuf:"bytes,6,opt,name=field37508" json:"field37508,omitempty"`
+	Field37509 *UnusedEmptyMessage `protobuf:"bytes,7,opt,name=field37509" json:"field37509,omitempty"`
+	Field37510 *UnusedEmptyMessage `protobuf:"bytes,8,opt,name=field37510" json:"field37510,omitempty"`
+	Field37511 *UnusedEmptyMessage `protobuf:"bytes,9,opt,name=field37511" json:"field37511,omitempty"`
+	Field37512 *UnusedEmptyMessage `protobuf:"bytes,10,opt,name=field37512" json:"field37512,omitempty"`
+	Field37513 *UnusedEmptyMessage `protobuf:"bytes,11,opt,name=field37513" json:"field37513,omitempty"`
+	Field37514 *UnusedEmptyMessage `protobuf:"bytes,12,opt,name=field37514" json:"field37514,omitempty"`
+	Field37515 *UnusedEmptyMessage `protobuf:"bytes,13,opt,name=field37515" json:"field37515,omitempty"`
+	Field37516 *UnusedEmptyMessage `protobuf:"bytes,14,opt,name=field37516" json:"field37516,omitempty"`
+	Field37517 *UnusedEmptyMessage `protobuf:"bytes,15,opt,name=field37517" json:"field37517,omitempty"`
+	Field37518 *UnusedEmptyMessage `protobuf:"bytes,16,opt,name=field37518" json:"field37518,omitempty"`
+}
+
+func (x *GoogleMessage4) Reset() {
+	*x = GoogleMessage4{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *GoogleMessage4) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GoogleMessage4) ProtoMessage() {}
+
+func (x *GoogleMessage4) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use GoogleMessage4.ProtoReflect.Descriptor instead.
+func (*GoogleMessage4) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *GoogleMessage4) GetField37503() int32 {
+	if x != nil && x.Field37503 != nil {
+		return *x.Field37503
+	}
+	return 0
+}
+
+func (x *GoogleMessage4) GetField37504() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37504
+	}
+	return nil
+}
+
+func (x *GoogleMessage4) GetField37505() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37505
+	}
+	return nil
+}
+
+func (x *GoogleMessage4) GetField37506() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37506
+	}
+	return nil
+}
+
+func (x *GoogleMessage4) GetField37507() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37507
+	}
+	return nil
+}
+
+func (x *GoogleMessage4) GetField37508() *Message37489 {
+	if x != nil {
+		return x.Field37508
+	}
+	return nil
+}
+
+func (x *GoogleMessage4) GetField37509() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37509
+	}
+	return nil
+}
+
+func (x *GoogleMessage4) GetField37510() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37510
+	}
+	return nil
+}
+
+func (x *GoogleMessage4) GetField37511() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37511
+	}
+	return nil
+}
+
+func (x *GoogleMessage4) GetField37512() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37512
+	}
+	return nil
+}
+
+func (x *GoogleMessage4) GetField37513() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37513
+	}
+	return nil
+}
+
+func (x *GoogleMessage4) GetField37514() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37514
+	}
+	return nil
+}
+
+func (x *GoogleMessage4) GetField37515() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37515
+	}
+	return nil
+}
+
+func (x *GoogleMessage4) GetField37516() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37516
+	}
+	return nil
+}
+
+func (x *GoogleMessage4) GetField37517() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37517
+	}
+	return nil
+}
+
+func (x *GoogleMessage4) GetField37518() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37518
+	}
+	return nil
+}
+
+type Message37489 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field37534 *Message2517  `protobuf:"bytes,3,opt,name=field37534" json:"field37534,omitempty"`
+	Field37535 *Message7330  `protobuf:"bytes,4,opt,name=field37535" json:"field37535,omitempty"`
+	Field37536 *Message8815  `protobuf:"bytes,6,opt,name=field37536" json:"field37536,omitempty"`
+	Field37537 *Message8817  `protobuf:"bytes,7,opt,name=field37537" json:"field37537,omitempty"`
+	Field37538 *Message8835  `protobuf:"bytes,8,opt,name=field37538" json:"field37538,omitempty"`
+	Field37539 *Message8848  `protobuf:"bytes,9,opt,name=field37539" json:"field37539,omitempty"`
+	Field37540 *Message8856  `protobuf:"bytes,11,opt,name=field37540" json:"field37540,omitempty"`
+	Field37541 *Message12717 `protobuf:"bytes,15,opt,name=field37541" json:"field37541,omitempty"`
+	Field37542 *Message12748 `protobuf:"bytes,20,opt,name=field37542" json:"field37542,omitempty"`
+	Field37543 *Message7319  `protobuf:"bytes,22,opt,name=field37543" json:"field37543,omitempty"`
+	Field37544 *Message12908 `protobuf:"bytes,24,opt,name=field37544" json:"field37544,omitempty"`
+	Field37545 *Message12910 `protobuf:"bytes,25,opt,name=field37545" json:"field37545,omitempty"`
+	Field37546 *Message12960 `protobuf:"bytes,30,opt,name=field37546" json:"field37546,omitempty"`
+	Field37547 *Message176   `protobuf:"bytes,33,opt,name=field37547" json:"field37547,omitempty"`
+	Field37548 *Message13000 `protobuf:"bytes,34,opt,name=field37548" json:"field37548,omitempty"`
+	Field37549 *Message13035 `protobuf:"bytes,35,opt,name=field37549" json:"field37549,omitempty"`
+	Field37550 *Message37331 `protobuf:"bytes,36,opt,name=field37550" json:"field37550,omitempty"`
+	Field37551 *Message37329 `protobuf:"bytes,37,opt,name=field37551" json:"field37551,omitempty"`
+	Field37552 *Message37327 `protobuf:"bytes,38,opt,name=field37552" json:"field37552,omitempty"`
+	Field37553 *Message37333 `protobuf:"bytes,39,opt,name=field37553" json:"field37553,omitempty"`
+	Field37554 *Message37335 `protobuf:"bytes,40,opt,name=field37554" json:"field37554,omitempty"`
+}
+
+func (x *Message37489) Reset() {
+	*x = Message37489{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message37489) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message37489) ProtoMessage() {}
+
+func (x *Message37489) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message37489.ProtoReflect.Descriptor instead.
+func (*Message37489) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *Message37489) GetField37534() *Message2517 {
+	if x != nil {
+		return x.Field37534
+	}
+	return nil
+}
+
+func (x *Message37489) GetField37535() *Message7330 {
+	if x != nil {
+		return x.Field37535
+	}
+	return nil
+}
+
+func (x *Message37489) GetField37536() *Message8815 {
+	if x != nil {
+		return x.Field37536
+	}
+	return nil
+}
+
+func (x *Message37489) GetField37537() *Message8817 {
+	if x != nil {
+		return x.Field37537
+	}
+	return nil
+}
+
+func (x *Message37489) GetField37538() *Message8835 {
+	if x != nil {
+		return x.Field37538
+	}
+	return nil
+}
+
+func (x *Message37489) GetField37539() *Message8848 {
+	if x != nil {
+		return x.Field37539
+	}
+	return nil
+}
+
+func (x *Message37489) GetField37540() *Message8856 {
+	if x != nil {
+		return x.Field37540
+	}
+	return nil
+}
+
+func (x *Message37489) GetField37541() *Message12717 {
+	if x != nil {
+		return x.Field37541
+	}
+	return nil
+}
+
+func (x *Message37489) GetField37542() *Message12748 {
+	if x != nil {
+		return x.Field37542
+	}
+	return nil
+}
+
+func (x *Message37489) GetField37543() *Message7319 {
+	if x != nil {
+		return x.Field37543
+	}
+	return nil
+}
+
+func (x *Message37489) GetField37544() *Message12908 {
+	if x != nil {
+		return x.Field37544
+	}
+	return nil
+}
+
+func (x *Message37489) GetField37545() *Message12910 {
+	if x != nil {
+		return x.Field37545
+	}
+	return nil
+}
+
+func (x *Message37489) GetField37546() *Message12960 {
+	if x != nil {
+		return x.Field37546
+	}
+	return nil
+}
+
+func (x *Message37489) GetField37547() *Message176 {
+	if x != nil {
+		return x.Field37547
+	}
+	return nil
+}
+
+func (x *Message37489) GetField37548() *Message13000 {
+	if x != nil {
+		return x.Field37548
+	}
+	return nil
+}
+
+func (x *Message37489) GetField37549() *Message13035 {
+	if x != nil {
+		return x.Field37549
+	}
+	return nil
+}
+
+func (x *Message37489) GetField37550() *Message37331 {
+	if x != nil {
+		return x.Field37550
+	}
+	return nil
+}
+
+func (x *Message37489) GetField37551() *Message37329 {
+	if x != nil {
+		return x.Field37551
+	}
+	return nil
+}
+
+func (x *Message37489) GetField37552() *Message37327 {
+	if x != nil {
+		return x.Field37552
+	}
+	return nil
+}
+
+func (x *Message37489) GetField37553() *Message37333 {
+	if x != nil {
+		return x.Field37553
+	}
+	return nil
+}
+
+func (x *Message37489) GetField37554() *Message37335 {
+	if x != nil {
+		return x.Field37554
+	}
+	return nil
+}
+
+type Message7319 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field7321 *UnusedEmptyMessage `protobuf:"bytes,1,opt,name=field7321" json:"field7321,omitempty"`
+	Field7322 *UnusedEmptyMessage `protobuf:"bytes,7,opt,name=field7322" json:"field7322,omitempty"`
+}
+
+func (x *Message7319) Reset() {
+	*x = Message7319{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message7319) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message7319) ProtoMessage() {}
+
+func (x *Message7319) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message7319.ProtoReflect.Descriptor instead.
+func (*Message7319) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *Message7319) GetField7321() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field7321
+	}
+	return nil
+}
+
+func (x *Message7319) GetField7322() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field7322
+	}
+	return nil
+}
+
+type Message12717 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12719 *UnusedEmptyMessage `protobuf:"bytes,1,opt,name=field12719" json:"field12719,omitempty"`
+	Field12720 *string             `protobuf:"bytes,2,opt,name=field12720" json:"field12720,omitempty"`
+	Field12721 *uint32             `protobuf:"varint,3,opt,name=field12721" json:"field12721,omitempty"`
+	Field12722 *Message11976       `protobuf:"bytes,4,opt,name=field12722" json:"field12722,omitempty"`
+	Field12723 []*Message11948     `protobuf:"bytes,5,rep,name=field12723" json:"field12723,omitempty"`
+	Field12724 *Message11947       `protobuf:"bytes,6,opt,name=field12724" json:"field12724,omitempty"`
+	Field12725 *Message12687       `protobuf:"bytes,7,opt,name=field12725" json:"field12725,omitempty"`
+	Field12726 []*Message11948     `protobuf:"bytes,8,rep,name=field12726" json:"field12726,omitempty"`
+	Field12727 *int64              `protobuf:"varint,9,opt,name=field12727" json:"field12727,omitempty"`
+}
+
+func (x *Message12717) Reset() {
+	*x = Message12717{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12717) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12717) ProtoMessage() {}
+
+func (x *Message12717) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12717.ProtoReflect.Descriptor instead.
+func (*Message12717) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *Message12717) GetField12719() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field12719
+	}
+	return nil
+}
+
+func (x *Message12717) GetField12720() string {
+	if x != nil && x.Field12720 != nil {
+		return *x.Field12720
+	}
+	return ""
+}
+
+func (x *Message12717) GetField12721() uint32 {
+	if x != nil && x.Field12721 != nil {
+		return *x.Field12721
+	}
+	return 0
+}
+
+func (x *Message12717) GetField12722() *Message11976 {
+	if x != nil {
+		return x.Field12722
+	}
+	return nil
+}
+
+func (x *Message12717) GetField12723() []*Message11948 {
+	if x != nil {
+		return x.Field12723
+	}
+	return nil
+}
+
+func (x *Message12717) GetField12724() *Message11947 {
+	if x != nil {
+		return x.Field12724
+	}
+	return nil
+}
+
+func (x *Message12717) GetField12725() *Message12687 {
+	if x != nil {
+		return x.Field12725
+	}
+	return nil
+}
+
+func (x *Message12717) GetField12726() []*Message11948 {
+	if x != nil {
+		return x.Field12726
+	}
+	return nil
+}
+
+func (x *Message12717) GetField12727() int64 {
+	if x != nil && x.Field12727 != nil {
+		return *x.Field12727
+	}
+	return 0
+}
+
+type Message37331 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field37367 *UnusedEmptyMessage `protobuf:"bytes,4,opt,name=field37367" json:"field37367,omitempty"`
+	Field37368 *Message37326       `protobuf:"bytes,1,req,name=field37368" json:"field37368,omitempty"`
+	Field37369 *int64              `protobuf:"varint,2,req,name=field37369" json:"field37369,omitempty"`
+	Field37370 []byte              `protobuf:"bytes,3,req,name=field37370" json:"field37370,omitempty"`
+}
+
+func (x *Message37331) Reset() {
+	*x = Message37331{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message37331) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message37331) ProtoMessage() {}
+
+func (x *Message37331) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message37331.ProtoReflect.Descriptor instead.
+func (*Message37331) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *Message37331) GetField37367() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37367
+	}
+	return nil
+}
+
+func (x *Message37331) GetField37368() *Message37326 {
+	if x != nil {
+		return x.Field37368
+	}
+	return nil
+}
+
+func (x *Message37331) GetField37369() int64 {
+	if x != nil && x.Field37369 != nil {
+		return *x.Field37369
+	}
+	return 0
+}
+
+func (x *Message37331) GetField37370() []byte {
+	if x != nil {
+		return x.Field37370
+	}
+	return nil
+}
+
+type Message8815 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field8819 *UnusedEmptyMessage `protobuf:"bytes,1,opt,name=field8819" json:"field8819,omitempty"`
+	Field8820 []*Message8768      `protobuf:"bytes,2,rep,name=field8820" json:"field8820,omitempty"`
+	Field8821 *bool               `protobuf:"varint,3,opt,name=field8821" json:"field8821,omitempty"`
+}
+
+func (x *Message8815) Reset() {
+	*x = Message8815{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[5]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8815) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8815) ProtoMessage() {}
+
+func (x *Message8815) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[5]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8815.ProtoReflect.Descriptor instead.
+func (*Message8815) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *Message8815) GetField8819() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8819
+	}
+	return nil
+}
+
+func (x *Message8815) GetField8820() []*Message8768 {
+	if x != nil {
+		return x.Field8820
+	}
+	return nil
+}
+
+func (x *Message8815) GetField8821() bool {
+	if x != nil && x.Field8821 != nil {
+		return *x.Field8821
+	}
+	return false
+}
+
+type Message7330 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field7332 *UnusedEmptyMessage `protobuf:"bytes,1,opt,name=field7332" json:"field7332,omitempty"`
+	Field7333 *Message3069        `protobuf:"bytes,2,opt,name=field7333" json:"field7333,omitempty"`
+	Field7334 *Message7320        `protobuf:"bytes,3,opt,name=field7334" json:"field7334,omitempty"`
+	Field7335 *UnusedEmptyMessage `protobuf:"bytes,4,opt,name=field7335" json:"field7335,omitempty"`
+	Field7336 *bool               `protobuf:"varint,5,opt,name=field7336" json:"field7336,omitempty"`
+	Field7337 *int64              `protobuf:"varint,6,opt,name=field7337" json:"field7337,omitempty"`
+}
+
+func (x *Message7330) Reset() {
+	*x = Message7330{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[6]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message7330) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message7330) ProtoMessage() {}
+
+func (x *Message7330) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[6]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message7330.ProtoReflect.Descriptor instead.
+func (*Message7330) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *Message7330) GetField7332() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field7332
+	}
+	return nil
+}
+
+func (x *Message7330) GetField7333() *Message3069 {
+	if x != nil {
+		return x.Field7333
+	}
+	return nil
+}
+
+func (x *Message7330) GetField7334() *Message7320 {
+	if x != nil {
+		return x.Field7334
+	}
+	return nil
+}
+
+func (x *Message7330) GetField7335() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field7335
+	}
+	return nil
+}
+
+func (x *Message7330) GetField7336() bool {
+	if x != nil && x.Field7336 != nil {
+		return *x.Field7336
+	}
+	return false
+}
+
+func (x *Message7330) GetField7337() int64 {
+	if x != nil && x.Field7337 != nil {
+		return *x.Field7337
+	}
+	return 0
+}
+
+type Message12960 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12962 *UnusedEmptyMessage `protobuf:"bytes,1,opt,name=field12962" json:"field12962,omitempty"`
+	Field12963 *Message12948       `protobuf:"bytes,2,opt,name=field12963" json:"field12963,omitempty"`
+}
+
+func (x *Message12960) Reset() {
+	*x = Message12960{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[7]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12960) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12960) ProtoMessage() {}
+
+func (x *Message12960) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[7]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12960.ProtoReflect.Descriptor instead.
+func (*Message12960) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *Message12960) GetField12962() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field12962
+	}
+	return nil
+}
+
+func (x *Message12960) GetField12963() *Message12948 {
+	if x != nil {
+		return x.Field12963
+	}
+	return nil
+}
+
+type Message176 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field408   *string                  `protobuf:"bytes,1,req,name=field408" json:"field408,omitempty"`
+	Field409   *int32                   `protobuf:"varint,4,opt,name=field409" json:"field409,omitempty"`
+	Field410   *string                  `protobuf:"bytes,50,opt,name=field410" json:"field410,omitempty"`
+	Field411   *int32                   `protobuf:"varint,2,opt,name=field411" json:"field411,omitempty"`
+	Field412   *uint64                  `protobuf:"varint,47,opt,name=field412" json:"field412,omitempty"`
+	Field413   *string                  `protobuf:"bytes,56,opt,name=field413" json:"field413,omitempty"`
+	Field414   *int32                   `protobuf:"varint,24,opt,name=field414" json:"field414,omitempty"`
+	Field415   *string                  `protobuf:"bytes,21,opt,name=field415" json:"field415,omitempty"`
+	Field416   []byte                   `protobuf:"bytes,3,opt,name=field416" json:"field416,omitempty"`
+	Field417   *string                  `protobuf:"bytes,57,opt,name=field417" json:"field417,omitempty"`
+	Field418   *int32                   `protobuf:"varint,51,opt,name=field418" json:"field418,omitempty"`
+	Field419   *float32                 `protobuf:"fixed32,7,opt,name=field419" json:"field419,omitempty"`
+	Field420   *bool                    `protobuf:"varint,5,opt,name=field420" json:"field420,omitempty"`
+	Field421   *bool                    `protobuf:"varint,28,opt,name=field421" json:"field421,omitempty"`
+	Field422   *int32                   `protobuf:"varint,6,opt,name=field422" json:"field422,omitempty"`
+	Field423   []int32                  `protobuf:"varint,40,rep,name=field423" json:"field423,omitempty"`
+	Field424   *UnusedEmptyMessage      `protobuf:"bytes,41,opt,name=field424" json:"field424,omitempty"`
+	Field425   *bool                    `protobuf:"varint,25,opt,name=field425" json:"field425,omitempty"`
+	Field426   *uint64                  `protobuf:"varint,26,opt,name=field426" json:"field426,omitempty"`
+	Field427   *int32                   `protobuf:"varint,38,opt,name=field427" json:"field427,omitempty"`
+	Field428   []byte                   `protobuf:"bytes,15,opt,name=field428" json:"field428,omitempty"`
+	Field429   []byte                   `protobuf:"bytes,55,opt,name=field429" json:"field429,omitempty"`
+	Field430   []byte                   `protobuf:"bytes,16,opt,name=field430" json:"field430,omitempty"`
+	Field431   []byte                   `protobuf:"bytes,23,opt,name=field431" json:"field431,omitempty"`
+	Field432   *bool                    `protobuf:"varint,33,opt,name=field432" json:"field432,omitempty"`
+	Field433   []byte                   `protobuf:"bytes,31,opt,name=field433" json:"field433,omitempty"`
+	Field434   []byte                   `protobuf:"bytes,32,opt,name=field434" json:"field434,omitempty"`
+	Field435   *int32                   `protobuf:"varint,36,opt,name=field435" json:"field435,omitempty"`
+	Field436   *uint64                  `protobuf:"varint,17,opt,name=field436" json:"field436,omitempty"`
+	Field437   *int32                   `protobuf:"varint,45,opt,name=field437" json:"field437,omitempty"`
+	Field438   *uint64                  `protobuf:"varint,18,opt,name=field438" json:"field438,omitempty"`
+	Field439   *string                  `protobuf:"bytes,46,opt,name=field439" json:"field439,omitempty"`
+	Field440   *UnusedEmptyMessage      `protobuf:"bytes,64,opt,name=field440" json:"field440,omitempty"`
+	Field441   *int32                   `protobuf:"varint,39,opt,name=field441" json:"field441,omitempty"`
+	Field442   *uint64                  `protobuf:"varint,48,opt,name=field442" json:"field442,omitempty"`
+	Field443   []byte                   `protobuf:"bytes,19,opt,name=field443" json:"field443,omitempty"`
+	Field444   []byte                   `protobuf:"bytes,42,opt,name=field444" json:"field444,omitempty"`
+	Field445   []byte                   `protobuf:"bytes,43,opt,name=field445" json:"field445,omitempty"`
+	Field446   *string                  `protobuf:"bytes,44,opt,name=field446" json:"field446,omitempty"`
+	Field447   *string                  `protobuf:"bytes,49,opt,name=field447" json:"field447,omitempty"`
+	Field448   *int64                   `protobuf:"varint,20,opt,name=field448" json:"field448,omitempty"`
+	Field449   *bool                    `protobuf:"varint,53,opt,name=field449" json:"field449,omitempty"`
+	Field450   *UnusedEmptyMessage      `protobuf:"bytes,54,opt,name=field450" json:"field450,omitempty"`
+	Field451   []*UnusedEmptyMessage    `protobuf:"bytes,22,rep,name=field451" json:"field451,omitempty"`
+	Field452   *UnusedEnum              `protobuf:"varint,27,opt,name=field452,enum=benchmarks.google_message4.UnusedEnum" json:"field452,omitempty"`
+	Field453   *int32                   `protobuf:"varint,29,opt,name=field453" json:"field453,omitempty"`
+	Field454   *int32                   `protobuf:"varint,30,opt,name=field454" json:"field454,omitempty"`
+	Field455   *UnusedEnum              `protobuf:"varint,37,opt,name=field455,enum=benchmarks.google_message4.UnusedEnum" json:"field455,omitempty"`
+	Field456   *UnusedEnum              `protobuf:"varint,34,opt,name=field456,enum=benchmarks.google_message4.UnusedEnum" json:"field456,omitempty"`
+	Field457   *int32                   `protobuf:"varint,35,opt,name=field457" json:"field457,omitempty"`
+	Message178 []*Message176_Message178 `protobuf:"group,101,rep,name=Message178,json=message178" json:"message178,omitempty"`
+	Field459   *bool                    `protobuf:"varint,52,opt,name=field459" json:"field459,omitempty"`
+	Field460   *uint64                  `protobuf:"varint,58,opt,name=field460" json:"field460,omitempty"`
+	Field461   *uint64                  `protobuf:"varint,59,opt,name=field461" json:"field461,omitempty"`
+	Field462   *UnusedEmptyMessage      `protobuf:"bytes,60,opt,name=field462" json:"field462,omitempty"`
+	Field463   *UnusedEmptyMessage      `protobuf:"bytes,61,opt,name=field463" json:"field463,omitempty"`
+	Field464   *UnusedEnum              `protobuf:"varint,62,opt,name=field464,enum=benchmarks.google_message4.UnusedEnum" json:"field464,omitempty"`
+	Field465   []string                 `protobuf:"bytes,63,rep,name=field465" json:"field465,omitempty"`
+	Field466   *UnusedEmptyMessage      `protobuf:"bytes,65,opt,name=field466" json:"field466,omitempty"`
+}
+
+func (x *Message176) Reset() {
+	*x = Message176{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[8]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message176) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message176) ProtoMessage() {}
+
+func (x *Message176) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[8]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message176.ProtoReflect.Descriptor instead.
+func (*Message176) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *Message176) GetField408() string {
+	if x != nil && x.Field408 != nil {
+		return *x.Field408
+	}
+	return ""
+}
+
+func (x *Message176) GetField409() int32 {
+	if x != nil && x.Field409 != nil {
+		return *x.Field409
+	}
+	return 0
+}
+
+func (x *Message176) GetField410() string {
+	if x != nil && x.Field410 != nil {
+		return *x.Field410
+	}
+	return ""
+}
+
+func (x *Message176) GetField411() int32 {
+	if x != nil && x.Field411 != nil {
+		return *x.Field411
+	}
+	return 0
+}
+
+func (x *Message176) GetField412() uint64 {
+	if x != nil && x.Field412 != nil {
+		return *x.Field412
+	}
+	return 0
+}
+
+func (x *Message176) GetField413() string {
+	if x != nil && x.Field413 != nil {
+		return *x.Field413
+	}
+	return ""
+}
+
+func (x *Message176) GetField414() int32 {
+	if x != nil && x.Field414 != nil {
+		return *x.Field414
+	}
+	return 0
+}
+
+func (x *Message176) GetField415() string {
+	if x != nil && x.Field415 != nil {
+		return *x.Field415
+	}
+	return ""
+}
+
+func (x *Message176) GetField416() []byte {
+	if x != nil {
+		return x.Field416
+	}
+	return nil
+}
+
+func (x *Message176) GetField417() string {
+	if x != nil && x.Field417 != nil {
+		return *x.Field417
+	}
+	return ""
+}
+
+func (x *Message176) GetField418() int32 {
+	if x != nil && x.Field418 != nil {
+		return *x.Field418
+	}
+	return 0
+}
+
+func (x *Message176) GetField419() float32 {
+	if x != nil && x.Field419 != nil {
+		return *x.Field419
+	}
+	return 0
+}
+
+func (x *Message176) GetField420() bool {
+	if x != nil && x.Field420 != nil {
+		return *x.Field420
+	}
+	return false
+}
+
+func (x *Message176) GetField421() bool {
+	if x != nil && x.Field421 != nil {
+		return *x.Field421
+	}
+	return false
+}
+
+func (x *Message176) GetField422() int32 {
+	if x != nil && x.Field422 != nil {
+		return *x.Field422
+	}
+	return 0
+}
+
+func (x *Message176) GetField423() []int32 {
+	if x != nil {
+		return x.Field423
+	}
+	return nil
+}
+
+func (x *Message176) GetField424() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field424
+	}
+	return nil
+}
+
+func (x *Message176) GetField425() bool {
+	if x != nil && x.Field425 != nil {
+		return *x.Field425
+	}
+	return false
+}
+
+func (x *Message176) GetField426() uint64 {
+	if x != nil && x.Field426 != nil {
+		return *x.Field426
+	}
+	return 0
+}
+
+func (x *Message176) GetField427() int32 {
+	if x != nil && x.Field427 != nil {
+		return *x.Field427
+	}
+	return 0
+}
+
+func (x *Message176) GetField428() []byte {
+	if x != nil {
+		return x.Field428
+	}
+	return nil
+}
+
+func (x *Message176) GetField429() []byte {
+	if x != nil {
+		return x.Field429
+	}
+	return nil
+}
+
+func (x *Message176) GetField430() []byte {
+	if x != nil {
+		return x.Field430
+	}
+	return nil
+}
+
+func (x *Message176) GetField431() []byte {
+	if x != nil {
+		return x.Field431
+	}
+	return nil
+}
+
+func (x *Message176) GetField432() bool {
+	if x != nil && x.Field432 != nil {
+		return *x.Field432
+	}
+	return false
+}
+
+func (x *Message176) GetField433() []byte {
+	if x != nil {
+		return x.Field433
+	}
+	return nil
+}
+
+func (x *Message176) GetField434() []byte {
+	if x != nil {
+		return x.Field434
+	}
+	return nil
+}
+
+func (x *Message176) GetField435() int32 {
+	if x != nil && x.Field435 != nil {
+		return *x.Field435
+	}
+	return 0
+}
+
+func (x *Message176) GetField436() uint64 {
+	if x != nil && x.Field436 != nil {
+		return *x.Field436
+	}
+	return 0
+}
+
+func (x *Message176) GetField437() int32 {
+	if x != nil && x.Field437 != nil {
+		return *x.Field437
+	}
+	return 0
+}
+
+func (x *Message176) GetField438() uint64 {
+	if x != nil && x.Field438 != nil {
+		return *x.Field438
+	}
+	return 0
+}
+
+func (x *Message176) GetField439() string {
+	if x != nil && x.Field439 != nil {
+		return *x.Field439
+	}
+	return ""
+}
+
+func (x *Message176) GetField440() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field440
+	}
+	return nil
+}
+
+func (x *Message176) GetField441() int32 {
+	if x != nil && x.Field441 != nil {
+		return *x.Field441
+	}
+	return 0
+}
+
+func (x *Message176) GetField442() uint64 {
+	if x != nil && x.Field442 != nil {
+		return *x.Field442
+	}
+	return 0
+}
+
+func (x *Message176) GetField443() []byte {
+	if x != nil {
+		return x.Field443
+	}
+	return nil
+}
+
+func (x *Message176) GetField444() []byte {
+	if x != nil {
+		return x.Field444
+	}
+	return nil
+}
+
+func (x *Message176) GetField445() []byte {
+	if x != nil {
+		return x.Field445
+	}
+	return nil
+}
+
+func (x *Message176) GetField446() string {
+	if x != nil && x.Field446 != nil {
+		return *x.Field446
+	}
+	return ""
+}
+
+func (x *Message176) GetField447() string {
+	if x != nil && x.Field447 != nil {
+		return *x.Field447
+	}
+	return ""
+}
+
+func (x *Message176) GetField448() int64 {
+	if x != nil && x.Field448 != nil {
+		return *x.Field448
+	}
+	return 0
+}
+
+func (x *Message176) GetField449() bool {
+	if x != nil && x.Field449 != nil {
+		return *x.Field449
+	}
+	return false
+}
+
+func (x *Message176) GetField450() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field450
+	}
+	return nil
+}
+
+func (x *Message176) GetField451() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field451
+	}
+	return nil
+}
+
+func (x *Message176) GetField452() UnusedEnum {
+	if x != nil && x.Field452 != nil {
+		return *x.Field452
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+func (x *Message176) GetField453() int32 {
+	if x != nil && x.Field453 != nil {
+		return *x.Field453
+	}
+	return 0
+}
+
+func (x *Message176) GetField454() int32 {
+	if x != nil && x.Field454 != nil {
+		return *x.Field454
+	}
+	return 0
+}
+
+func (x *Message176) GetField455() UnusedEnum {
+	if x != nil && x.Field455 != nil {
+		return *x.Field455
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+func (x *Message176) GetField456() UnusedEnum {
+	if x != nil && x.Field456 != nil {
+		return *x.Field456
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+func (x *Message176) GetField457() int32 {
+	if x != nil && x.Field457 != nil {
+		return *x.Field457
+	}
+	return 0
+}
+
+func (x *Message176) GetMessage178() []*Message176_Message178 {
+	if x != nil {
+		return x.Message178
+	}
+	return nil
+}
+
+func (x *Message176) GetField459() bool {
+	if x != nil && x.Field459 != nil {
+		return *x.Field459
+	}
+	return false
+}
+
+func (x *Message176) GetField460() uint64 {
+	if x != nil && x.Field460 != nil {
+		return *x.Field460
+	}
+	return 0
+}
+
+func (x *Message176) GetField461() uint64 {
+	if x != nil && x.Field461 != nil {
+		return *x.Field461
+	}
+	return 0
+}
+
+func (x *Message176) GetField462() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field462
+	}
+	return nil
+}
+
+func (x *Message176) GetField463() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field463
+	}
+	return nil
+}
+
+func (x *Message176) GetField464() UnusedEnum {
+	if x != nil && x.Field464 != nil {
+		return *x.Field464
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+func (x *Message176) GetField465() []string {
+	if x != nil {
+		return x.Field465
+	}
+	return nil
+}
+
+func (x *Message176) GetField466() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field466
+	}
+	return nil
+}
+
+type Message8817 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field8825 *UnusedEmptyMessage `protobuf:"bytes,1,opt,name=field8825" json:"field8825,omitempty"`
+	Field8826 []*Message8768      `protobuf:"bytes,2,rep,name=field8826" json:"field8826,omitempty"`
+	Field8827 *string             `protobuf:"bytes,3,opt,name=field8827" json:"field8827,omitempty"`
+}
+
+func (x *Message8817) Reset() {
+	*x = Message8817{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[9]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8817) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8817) ProtoMessage() {}
+
+func (x *Message8817) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[9]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8817.ProtoReflect.Descriptor instead.
+func (*Message8817) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{9}
+}
+
+func (x *Message8817) GetField8825() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8825
+	}
+	return nil
+}
+
+func (x *Message8817) GetField8826() []*Message8768 {
+	if x != nil {
+		return x.Field8826
+	}
+	return nil
+}
+
+func (x *Message8817) GetField8827() string {
+	if x != nil && x.Field8827 != nil {
+		return *x.Field8827
+	}
+	return ""
+}
+
+type Message8835 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field8837 *UnusedEmptyMessage `protobuf:"bytes,1,opt,name=field8837" json:"field8837,omitempty"`
+	Field8838 []string            `protobuf:"bytes,2,rep,name=field8838" json:"field8838,omitempty"`
+	Field8839 *UnusedEnum         `protobuf:"varint,3,opt,name=field8839,enum=benchmarks.google_message4.UnusedEnum" json:"field8839,omitempty"`
+}
+
+func (x *Message8835) Reset() {
+	*x = Message8835{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[10]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8835) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8835) ProtoMessage() {}
+
+func (x *Message8835) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[10]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8835.ProtoReflect.Descriptor instead.
+func (*Message8835) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{10}
+}
+
+func (x *Message8835) GetField8837() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8837
+	}
+	return nil
+}
+
+func (x *Message8835) GetField8838() []string {
+	if x != nil {
+		return x.Field8838
+	}
+	return nil
+}
+
+func (x *Message8835) GetField8839() UnusedEnum {
+	if x != nil && x.Field8839 != nil {
+		return *x.Field8839
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+type Message37333 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field37372 *UnusedEmptyMessage `protobuf:"bytes,3,opt,name=field37372" json:"field37372,omitempty"`
+	Field37373 *Message37326       `protobuf:"bytes,1,req,name=field37373" json:"field37373,omitempty"`
+	Field37374 *uint64             `protobuf:"varint,2,opt,name=field37374" json:"field37374,omitempty"`
+}
+
+func (x *Message37333) Reset() {
+	*x = Message37333{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[11]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message37333) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message37333) ProtoMessage() {}
+
+func (x *Message37333) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[11]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message37333.ProtoReflect.Descriptor instead.
+func (*Message37333) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{11}
+}
+
+func (x *Message37333) GetField37372() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37372
+	}
+	return nil
+}
+
+func (x *Message37333) GetField37373() *Message37326 {
+	if x != nil {
+		return x.Field37373
+	}
+	return nil
+}
+
+func (x *Message37333) GetField37374() uint64 {
+	if x != nil && x.Field37374 != nil {
+		return *x.Field37374
+	}
+	return 0
+}
+
+type Message13000 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field13015 *int64          `protobuf:"varint,1,opt,name=field13015" json:"field13015,omitempty"`
+	Field13016 []*Message12979 `protobuf:"bytes,2,rep,name=field13016" json:"field13016,omitempty"`
+}
+
+func (x *Message13000) Reset() {
+	*x = Message13000{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[12]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message13000) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message13000) ProtoMessage() {}
+
+func (x *Message13000) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[12]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message13000.ProtoReflect.Descriptor instead.
+func (*Message13000) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{12}
+}
+
+func (x *Message13000) GetField13015() int64 {
+	if x != nil && x.Field13015 != nil {
+		return *x.Field13015
+	}
+	return 0
+}
+
+func (x *Message13000) GetField13016() []*Message12979 {
+	if x != nil {
+		return x.Field13016
+	}
+	return nil
+}
+
+type Message37335 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field37376 *UnusedEmptyMessage `protobuf:"bytes,4,opt,name=field37376" json:"field37376,omitempty"`
+	Field37377 *Message37326       `protobuf:"bytes,1,req,name=field37377" json:"field37377,omitempty"`
+	Field37378 *Message37173       `protobuf:"bytes,2,req,name=field37378" json:"field37378,omitempty"`
+	Field37379 *uint64             `protobuf:"varint,3,opt,name=field37379" json:"field37379,omitempty"`
+}
+
+func (x *Message37335) Reset() {
+	*x = Message37335{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[13]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message37335) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message37335) ProtoMessage() {}
+
+func (x *Message37335) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[13]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message37335.ProtoReflect.Descriptor instead.
+func (*Message37335) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{13}
+}
+
+func (x *Message37335) GetField37376() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37376
+	}
+	return nil
+}
+
+func (x *Message37335) GetField37377() *Message37326 {
+	if x != nil {
+		return x.Field37377
+	}
+	return nil
+}
+
+func (x *Message37335) GetField37378() *Message37173 {
+	if x != nil {
+		return x.Field37378
+	}
+	return nil
+}
+
+func (x *Message37335) GetField37379() uint64 {
+	if x != nil && x.Field37379 != nil {
+		return *x.Field37379
+	}
+	return 0
+}
+
+type Message8848 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field8850 *UnusedEmptyMessage `protobuf:"bytes,1,opt,name=field8850" json:"field8850,omitempty"`
+	Field8851 *string             `protobuf:"bytes,2,opt,name=field8851" json:"field8851,omitempty"`
+	Field8852 []byte              `protobuf:"bytes,3,opt,name=field8852" json:"field8852,omitempty"`
+}
+
+func (x *Message8848) Reset() {
+	*x = Message8848{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[14]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8848) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8848) ProtoMessage() {}
+
+func (x *Message8848) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[14]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8848.ProtoReflect.Descriptor instead.
+func (*Message8848) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{14}
+}
+
+func (x *Message8848) GetField8850() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8850
+	}
+	return nil
+}
+
+func (x *Message8848) GetField8851() string {
+	if x != nil && x.Field8851 != nil {
+		return *x.Field8851
+	}
+	return ""
+}
+
+func (x *Message8848) GetField8852() []byte {
+	if x != nil {
+		return x.Field8852
+	}
+	return nil
+}
+
+type Message13035 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field13058 *int64  `protobuf:"varint,1,opt,name=field13058" json:"field13058,omitempty"`
+	Field13059 []int64 `protobuf:"varint,2,rep,name=field13059" json:"field13059,omitempty"`
+}
+
+func (x *Message13035) Reset() {
+	*x = Message13035{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[15]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message13035) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message13035) ProtoMessage() {}
+
+func (x *Message13035) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[15]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message13035.ProtoReflect.Descriptor instead.
+func (*Message13035) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{15}
+}
+
+func (x *Message13035) GetField13058() int64 {
+	if x != nil && x.Field13058 != nil {
+		return *x.Field13058
+	}
+	return 0
+}
+
+func (x *Message13035) GetField13059() []int64 {
+	if x != nil {
+		return x.Field13059
+	}
+	return nil
+}
+
+type Message8856 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field8858 *UnusedEmptyMessage `protobuf:"bytes,1,opt,name=field8858" json:"field8858,omitempty"`
+	Field8859 *string             `protobuf:"bytes,2,opt,name=field8859" json:"field8859,omitempty"`
+}
+
+func (x *Message8856) Reset() {
+	*x = Message8856{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[16]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8856) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8856) ProtoMessage() {}
+
+func (x *Message8856) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[16]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8856.ProtoReflect.Descriptor instead.
+func (*Message8856) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{16}
+}
+
+func (x *Message8856) GetField8858() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8858
+	}
+	return nil
+}
+
+func (x *Message8856) GetField8859() string {
+	if x != nil && x.Field8859 != nil {
+		return *x.Field8859
+	}
+	return ""
+}
+
+type Message12908 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12912 *UnusedEmptyMessage `protobuf:"bytes,1,opt,name=field12912" json:"field12912,omitempty"`
+	Field12913 *string             `protobuf:"bytes,2,opt,name=field12913" json:"field12913,omitempty"`
+	Field12914 *Message12799       `protobuf:"bytes,3,opt,name=field12914" json:"field12914,omitempty"`
+	Field12915 *int64              `protobuf:"varint,4,opt,name=field12915" json:"field12915,omitempty"`
+	Field12916 *Message3804        `protobuf:"bytes,5,opt,name=field12916" json:"field12916,omitempty"`
+	Field12917 *Message12870       `protobuf:"bytes,6,opt,name=field12917" json:"field12917,omitempty"`
+}
+
+func (x *Message12908) Reset() {
+	*x = Message12908{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[17]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12908) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12908) ProtoMessage() {}
+
+func (x *Message12908) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[17]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12908.ProtoReflect.Descriptor instead.
+func (*Message12908) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{17}
+}
+
+func (x *Message12908) GetField12912() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field12912
+	}
+	return nil
+}
+
+func (x *Message12908) GetField12913() string {
+	if x != nil && x.Field12913 != nil {
+		return *x.Field12913
+	}
+	return ""
+}
+
+func (x *Message12908) GetField12914() *Message12799 {
+	if x != nil {
+		return x.Field12914
+	}
+	return nil
+}
+
+func (x *Message12908) GetField12915() int64 {
+	if x != nil && x.Field12915 != nil {
+		return *x.Field12915
+	}
+	return 0
+}
+
+func (x *Message12908) GetField12916() *Message3804 {
+	if x != nil {
+		return x.Field12916
+	}
+	return nil
+}
+
+func (x *Message12908) GetField12917() *Message12870 {
+	if x != nil {
+		return x.Field12917
+	}
+	return nil
+}
+
+type Message12910 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12920 *UnusedEmptyMessage `protobuf:"bytes,1,opt,name=field12920" json:"field12920,omitempty"`
+	Field12921 *Message12818       `protobuf:"bytes,2,opt,name=field12921" json:"field12921,omitempty"`
+	Field12922 []*Message12903     `protobuf:"bytes,3,rep,name=field12922" json:"field12922,omitempty"`
+}
+
+func (x *Message12910) Reset() {
+	*x = Message12910{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[18]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12910) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12910) ProtoMessage() {}
+
+func (x *Message12910) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[18]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12910.ProtoReflect.Descriptor instead.
+func (*Message12910) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{18}
+}
+
+func (x *Message12910) GetField12920() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field12920
+	}
+	return nil
+}
+
+func (x *Message12910) GetField12921() *Message12818 {
+	if x != nil {
+		return x.Field12921
+	}
+	return nil
+}
+
+func (x *Message12910) GetField12922() []*Message12903 {
+	if x != nil {
+		return x.Field12922
+	}
+	return nil
+}
+
+type Message37327 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field37347 *UnusedEmptyMessage `protobuf:"bytes,11,opt,name=field37347" json:"field37347,omitempty"`
+	Field37348 *Message37326       `protobuf:"bytes,1,req,name=field37348" json:"field37348,omitempty"`
+	Field37349 *bool               `protobuf:"varint,2,opt,name=field37349" json:"field37349,omitempty"`
+	Field37350 *bool               `protobuf:"varint,3,opt,name=field37350" json:"field37350,omitempty"`
+	Field37351 *bool               `protobuf:"varint,4,opt,name=field37351" json:"field37351,omitempty"`
+	Field37352 *bool               `protobuf:"varint,5,opt,name=field37352" json:"field37352,omitempty"`
+	Field37353 *bool               `protobuf:"varint,6,opt,name=field37353" json:"field37353,omitempty"`
+	Field37354 *UnusedEmptyMessage `protobuf:"bytes,7,opt,name=field37354" json:"field37354,omitempty"`
+	Field37355 *uint64             `protobuf:"varint,8,opt,name=field37355" json:"field37355,omitempty"`
+	Field37356 *bool               `protobuf:"varint,9,opt,name=field37356" json:"field37356,omitempty"`
+	Field37357 *bool               `protobuf:"varint,10,opt,name=field37357" json:"field37357,omitempty"`
+}
+
+func (x *Message37327) Reset() {
+	*x = Message37327{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[19]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message37327) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message37327) ProtoMessage() {}
+
+func (x *Message37327) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[19]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message37327.ProtoReflect.Descriptor instead.
+func (*Message37327) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{19}
+}
+
+func (x *Message37327) GetField37347() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37347
+	}
+	return nil
+}
+
+func (x *Message37327) GetField37348() *Message37326 {
+	if x != nil {
+		return x.Field37348
+	}
+	return nil
+}
+
+func (x *Message37327) GetField37349() bool {
+	if x != nil && x.Field37349 != nil {
+		return *x.Field37349
+	}
+	return false
+}
+
+func (x *Message37327) GetField37350() bool {
+	if x != nil && x.Field37350 != nil {
+		return *x.Field37350
+	}
+	return false
+}
+
+func (x *Message37327) GetField37351() bool {
+	if x != nil && x.Field37351 != nil {
+		return *x.Field37351
+	}
+	return false
+}
+
+func (x *Message37327) GetField37352() bool {
+	if x != nil && x.Field37352 != nil {
+		return *x.Field37352
+	}
+	return false
+}
+
+func (x *Message37327) GetField37353() bool {
+	if x != nil && x.Field37353 != nil {
+		return *x.Field37353
+	}
+	return false
+}
+
+func (x *Message37327) GetField37354() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37354
+	}
+	return nil
+}
+
+func (x *Message37327) GetField37355() uint64 {
+	if x != nil && x.Field37355 != nil {
+		return *x.Field37355
+	}
+	return 0
+}
+
+func (x *Message37327) GetField37356() bool {
+	if x != nil && x.Field37356 != nil {
+		return *x.Field37356
+	}
+	return false
+}
+
+func (x *Message37327) GetField37357() bool {
+	if x != nil && x.Field37357 != nil {
+		return *x.Field37357
+	}
+	return false
+}
+
+type Message37329 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field37359 *UnusedEmptyMessage `protobuf:"bytes,6,opt,name=field37359" json:"field37359,omitempty"`
+	Field37360 *Message37326       `protobuf:"bytes,1,req,name=field37360" json:"field37360,omitempty"`
+	Field37361 *int64              `protobuf:"varint,2,req,name=field37361" json:"field37361,omitempty"`
+	Field37362 *int64              `protobuf:"varint,3,req,name=field37362" json:"field37362,omitempty"`
+	Field37363 *bool               `protobuf:"varint,4,opt,name=field37363" json:"field37363,omitempty"`
+}
+
+func (x *Message37329) Reset() {
+	*x = Message37329{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[20]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message37329) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message37329) ProtoMessage() {}
+
+func (x *Message37329) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[20]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message37329.ProtoReflect.Descriptor instead.
+func (*Message37329) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{20}
+}
+
+func (x *Message37329) GetField37359() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37359
+	}
+	return nil
+}
+
+func (x *Message37329) GetField37360() *Message37326 {
+	if x != nil {
+		return x.Field37360
+	}
+	return nil
+}
+
+func (x *Message37329) GetField37361() int64 {
+	if x != nil && x.Field37361 != nil {
+		return *x.Field37361
+	}
+	return 0
+}
+
+func (x *Message37329) GetField37362() int64 {
+	if x != nil && x.Field37362 != nil {
+		return *x.Field37362
+	}
+	return 0
+}
+
+func (x *Message37329) GetField37363() bool {
+	if x != nil && x.Field37363 != nil {
+		return *x.Field37363
+	}
+	return false
+}
+
+type Message2517 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field2519 *UnusedEmptyMessage `protobuf:"bytes,1,opt,name=field2519" json:"field2519,omitempty"`
+	Field2520 *Message2356        `protobuf:"bytes,2,opt,name=field2520" json:"field2520,omitempty"`
+	Field2521 *Message0           `protobuf:"bytes,3,opt,name=field2521" json:"field2521,omitempty"`
+	Field2522 *Message2463        `protobuf:"bytes,4,opt,name=field2522" json:"field2522,omitempty"`
+	Field2523 []*Message971       `protobuf:"bytes,5,rep,name=field2523" json:"field2523,omitempty"`
+}
+
+func (x *Message2517) Reset() {
+	*x = Message2517{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[21]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message2517) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message2517) ProtoMessage() {}
+
+func (x *Message2517) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[21]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message2517.ProtoReflect.Descriptor instead.
+func (*Message2517) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{21}
+}
+
+func (x *Message2517) GetField2519() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field2519
+	}
+	return nil
+}
+
+func (x *Message2517) GetField2520() *Message2356 {
+	if x != nil {
+		return x.Field2520
+	}
+	return nil
+}
+
+func (x *Message2517) GetField2521() *Message0 {
+	if x != nil {
+		return x.Field2521
+	}
+	return nil
+}
+
+func (x *Message2517) GetField2522() *Message2463 {
+	if x != nil {
+		return x.Field2522
+	}
+	return nil
+}
+
+func (x *Message2517) GetField2523() []*Message971 {
+	if x != nil {
+		return x.Field2523
+	}
+	return nil
+}
+
+type Message12748 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12754 *UnusedEmptyMessage `protobuf:"bytes,1,opt,name=field12754" json:"field12754,omitempty"`
+	Field12755 *string             `protobuf:"bytes,2,opt,name=field12755" json:"field12755,omitempty"`
+	Field12756 *string             `protobuf:"bytes,3,opt,name=field12756" json:"field12756,omitempty"`
+	Field12757 *Enum12735          `protobuf:"varint,4,opt,name=field12757,enum=benchmarks.google_message4.Enum12735" json:"field12757,omitempty"`
+}
+
+func (x *Message12748) Reset() {
+	*x = Message12748{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[22]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12748) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12748) ProtoMessage() {}
+
+func (x *Message12748) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[22]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12748.ProtoReflect.Descriptor instead.
+func (*Message12748) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{22}
+}
+
+func (x *Message12748) GetField12754() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field12754
+	}
+	return nil
+}
+
+func (x *Message12748) GetField12755() string {
+	if x != nil && x.Field12755 != nil {
+		return *x.Field12755
+	}
+	return ""
+}
+
+func (x *Message12748) GetField12756() string {
+	if x != nil && x.Field12756 != nil {
+		return *x.Field12756
+	}
+	return ""
+}
+
+func (x *Message12748) GetField12757() Enum12735 {
+	if x != nil && x.Field12757 != nil {
+		return *x.Field12757
+	}
+	return Enum12735_ENUM_VALUE12736
+}
+
+type Message12687 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12701 []*Message12686 `protobuf:"bytes,1,rep,name=field12701" json:"field12701,omitempty"`
+}
+
+func (x *Message12687) Reset() {
+	*x = Message12687{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[23]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12687) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12687) ProtoMessage() {}
+
+func (x *Message12687) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[23]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12687.ProtoReflect.Descriptor instead.
+func (*Message12687) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{23}
+}
+
+func (x *Message12687) GetField12701() []*Message12686 {
+	if x != nil {
+		return x.Field12701
+	}
+	return nil
+}
+
+type Message11948 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field11954 *string         `protobuf:"bytes,1,opt,name=field11954" json:"field11954,omitempty"`
+	Field11955 []*Message11949 `protobuf:"bytes,2,rep,name=field11955" json:"field11955,omitempty"`
+	Field11956 *bool           `protobuf:"varint,3,opt,name=field11956" json:"field11956,omitempty"`
+}
+
+func (x *Message11948) Reset() {
+	*x = Message11948{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[24]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message11948) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message11948) ProtoMessage() {}
+
+func (x *Message11948) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[24]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message11948.ProtoReflect.Descriptor instead.
+func (*Message11948) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{24}
+}
+
+func (x *Message11948) GetField11954() string {
+	if x != nil && x.Field11954 != nil {
+		return *x.Field11954
+	}
+	return ""
+}
+
+func (x *Message11948) GetField11955() []*Message11949 {
+	if x != nil {
+		return x.Field11955
+	}
+	return nil
+}
+
+func (x *Message11948) GetField11956() bool {
+	if x != nil && x.Field11956 != nil {
+		return *x.Field11956
+	}
+	return false
+}
+
+type Message11976 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12002 []*Message11975 `protobuf:"bytes,1,rep,name=field12002" json:"field12002,omitempty"`
+}
+
+func (x *Message11976) Reset() {
+	*x = Message11976{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[25]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message11976) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message11976) ProtoMessage() {}
+
+func (x *Message11976) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[25]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message11976.ProtoReflect.Descriptor instead.
+func (*Message11976) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{25}
+}
+
+func (x *Message11976) GetField12002() []*Message11975 {
+	if x != nil {
+		return x.Field12002
+	}
+	return nil
+}
+
+type Message7320 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field7323 *UnusedEmptyMessage `protobuf:"bytes,1,opt,name=field7323" json:"field7323,omitempty"`
+	Field7324 *Message7287        `protobuf:"bytes,8,opt,name=field7324" json:"field7324,omitempty"`
+}
+
+func (x *Message7320) Reset() {
+	*x = Message7320{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[26]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message7320) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message7320) ProtoMessage() {}
+
+func (x *Message7320) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[26]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message7320.ProtoReflect.Descriptor instead.
+func (*Message7320) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{26}
+}
+
+func (x *Message7320) GetField7323() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field7323
+	}
+	return nil
+}
+
+func (x *Message7320) GetField7324() *Message7287 {
+	if x != nil {
+		return x.Field7324
+	}
+	return nil
+}
+
+type Message3069 struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+
+	Field3374   *Message3061               `protobuf:"bytes,1,opt,name=field3374" json:"field3374,omitempty"`
+	Field3375   []byte                     `protobuf:"bytes,2,opt,name=field3375" json:"field3375,omitempty"`
+	Message3070 []*Message3069_Message3070 `protobuf:"group,3,rep,name=Message3070,json=message3070" json:"message3070,omitempty"`
+}
+
+func (x *Message3069) Reset() {
+	*x = Message3069{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[27]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message3069) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message3069) ProtoMessage() {}
+
+func (x *Message3069) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[27]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message3069.ProtoReflect.Descriptor instead.
+func (*Message3069) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{27}
+}
+
+var extRange_Message3069 = []protoiface.ExtensionRangeV1{
+	{Start: 10000, End: 536870911},
+}
+
+// Deprecated: Use Message3069.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*Message3069) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_Message3069
+}
+
+func (x *Message3069) GetField3374() *Message3061 {
+	if x != nil {
+		return x.Field3374
+	}
+	return nil
+}
+
+func (x *Message3069) GetField3375() []byte {
+	if x != nil {
+		return x.Field3375
+	}
+	return nil
+}
+
+func (x *Message3069) GetMessage3070() []*Message3069_Message3070 {
+	if x != nil {
+		return x.Message3070
+	}
+	return nil
+}
+
+type Message12948 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12958 []*Message12949 `protobuf:"bytes,1,rep,name=field12958" json:"field12958,omitempty"`
+}
+
+func (x *Message12948) Reset() {
+	*x = Message12948{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[28]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12948) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12948) ProtoMessage() {}
+
+func (x *Message12948) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[28]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12948.ProtoReflect.Descriptor instead.
+func (*Message12948) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{28}
+}
+
+func (x *Message12948) GetField12958() []*Message12949 {
+	if x != nil {
+		return x.Field12958
+	}
+	return nil
+}
+
+type Message8768 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field8782 *string             `protobuf:"bytes,1,opt,name=field8782" json:"field8782,omitempty"`
+	Field8783 *Message8572        `protobuf:"bytes,2,opt,name=field8783" json:"field8783,omitempty"`
+	Field8784 *bool               `protobuf:"varint,3,opt,name=field8784" json:"field8784,omitempty"`
+	Field8785 []*Message8774      `protobuf:"bytes,4,rep,name=field8785" json:"field8785,omitempty"`
+	Field8786 *int64              `protobuf:"varint,5,opt,name=field8786" json:"field8786,omitempty"`
+	Field8787 *UnusedEmptyMessage `protobuf:"bytes,6,opt,name=field8787" json:"field8787,omitempty"`
+	Field8788 *string             `protobuf:"bytes,7,opt,name=field8788" json:"field8788,omitempty"`
+}
+
+func (x *Message8768) Reset() {
+	*x = Message8768{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[29]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8768) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8768) ProtoMessage() {}
+
+func (x *Message8768) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[29]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8768.ProtoReflect.Descriptor instead.
+func (*Message8768) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{29}
+}
+
+func (x *Message8768) GetField8782() string {
+	if x != nil && x.Field8782 != nil {
+		return *x.Field8782
+	}
+	return ""
+}
+
+func (x *Message8768) GetField8783() *Message8572 {
+	if x != nil {
+		return x.Field8783
+	}
+	return nil
+}
+
+func (x *Message8768) GetField8784() bool {
+	if x != nil && x.Field8784 != nil {
+		return *x.Field8784
+	}
+	return false
+}
+
+func (x *Message8768) GetField8785() []*Message8774 {
+	if x != nil {
+		return x.Field8785
+	}
+	return nil
+}
+
+func (x *Message8768) GetField8786() int64 {
+	if x != nil && x.Field8786 != nil {
+		return *x.Field8786
+	}
+	return 0
+}
+
+func (x *Message8768) GetField8787() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8787
+	}
+	return nil
+}
+
+func (x *Message8768) GetField8788() string {
+	if x != nil && x.Field8788 != nil {
+		return *x.Field8788
+	}
+	return ""
+}
+
+type Message12979 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12981 []byte              `protobuf:"bytes,1,req,name=field12981" json:"field12981,omitempty"`
+	Field12982 []string            `protobuf:"bytes,2,rep,name=field12982" json:"field12982,omitempty"`
+	Field12983 *UnusedEmptyMessage `protobuf:"bytes,3,opt,name=field12983" json:"field12983,omitempty"`
+	Field12984 *int64              `protobuf:"varint,4,opt,name=field12984" json:"field12984,omitempty"`
+	Field12985 *string             `protobuf:"bytes,5,opt,name=field12985" json:"field12985,omitempty"`
+	Field12986 *int32              `protobuf:"varint,6,opt,name=field12986" json:"field12986,omitempty"`
+	Field12987 *UnusedEmptyMessage `protobuf:"bytes,7,opt,name=field12987" json:"field12987,omitempty"`
+}
+
+func (x *Message12979) Reset() {
+	*x = Message12979{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[30]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12979) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12979) ProtoMessage() {}
+
+func (x *Message12979) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[30]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12979.ProtoReflect.Descriptor instead.
+func (*Message12979) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{30}
+}
+
+func (x *Message12979) GetField12981() []byte {
+	if x != nil {
+		return x.Field12981
+	}
+	return nil
+}
+
+func (x *Message12979) GetField12982() []string {
+	if x != nil {
+		return x.Field12982
+	}
+	return nil
+}
+
+func (x *Message12979) GetField12983() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field12983
+	}
+	return nil
+}
+
+func (x *Message12979) GetField12984() int64 {
+	if x != nil && x.Field12984 != nil {
+		return *x.Field12984
+	}
+	return 0
+}
+
+func (x *Message12979) GetField12985() string {
+	if x != nil && x.Field12985 != nil {
+		return *x.Field12985
+	}
+	return ""
+}
+
+func (x *Message12979) GetField12986() int32 {
+	if x != nil && x.Field12986 != nil {
+		return *x.Field12986
+	}
+	return 0
+}
+
+func (x *Message12979) GetField12987() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field12987
+	}
+	return nil
+}
+
+type Message37173 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field37252 *string             `protobuf:"bytes,1,opt,name=field37252" json:"field37252,omitempty"`
+	Field37253 *int64              `protobuf:"varint,2,opt,name=field37253" json:"field37253,omitempty"`
+	Field37254 *UnusedEnum         `protobuf:"varint,4,opt,name=field37254,enum=benchmarks.google_message4.UnusedEnum" json:"field37254,omitempty"`
+	Field37255 *bool               `protobuf:"varint,5,opt,name=field37255" json:"field37255,omitempty"`
+	Field37256 *bool               `protobuf:"varint,6,opt,name=field37256" json:"field37256,omitempty"`
+	Field37257 *bool               `protobuf:"varint,7,opt,name=field37257" json:"field37257,omitempty"`
+	Field37258 *string             `protobuf:"bytes,8,opt,name=field37258" json:"field37258,omitempty"`
+	Field37259 *string             `protobuf:"bytes,9,opt,name=field37259" json:"field37259,omitempty"`
+	Field37260 *uint32             `protobuf:"varint,10,opt,name=field37260" json:"field37260,omitempty"`
+	Field37261 *uint32             `protobuf:"fixed32,11,opt,name=field37261" json:"field37261,omitempty"`
+	Field37262 *string             `protobuf:"bytes,12,opt,name=field37262" json:"field37262,omitempty"`
+	Field37263 *string             `protobuf:"bytes,13,opt,name=field37263" json:"field37263,omitempty"`
+	Field37264 *string             `protobuf:"bytes,14,opt,name=field37264" json:"field37264,omitempty"`
+	Field37265 *int32              `protobuf:"varint,15,opt,name=field37265" json:"field37265,omitempty"`
+	Field37266 *int64              `protobuf:"varint,16,opt,name=field37266" json:"field37266,omitempty"`
+	Field37267 *int64              `protobuf:"varint,17,opt,name=field37267" json:"field37267,omitempty"`
+	Field37268 *int32              `protobuf:"varint,18,opt,name=field37268" json:"field37268,omitempty"`
+	Field37269 *int32              `protobuf:"varint,19,opt,name=field37269" json:"field37269,omitempty"`
+	Field37270 *UnusedEmptyMessage `protobuf:"bytes,20,opt,name=field37270" json:"field37270,omitempty"`
+	Field37271 *UnusedEmptyMessage `protobuf:"bytes,21,opt,name=field37271" json:"field37271,omitempty"`
+	Field37272 *UnusedEmptyMessage `protobuf:"bytes,22,opt,name=field37272" json:"field37272,omitempty"`
+	Field37273 *UnusedEmptyMessage `protobuf:"bytes,23,opt,name=field37273" json:"field37273,omitempty"`
+	Field37274 *UnusedEmptyMessage `protobuf:"bytes,24,opt,name=field37274" json:"field37274,omitempty"`
+	Field37275 *string             `protobuf:"bytes,25,opt,name=field37275" json:"field37275,omitempty"`
+	Field37276 *bool               `protobuf:"varint,26,opt,name=field37276" json:"field37276,omitempty"`
+}
+
+func (x *Message37173) Reset() {
+	*x = Message37173{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[31]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message37173) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message37173) ProtoMessage() {}
+
+func (x *Message37173) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[31]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message37173.ProtoReflect.Descriptor instead.
+func (*Message37173) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{31}
+}
+
+func (x *Message37173) GetField37252() string {
+	if x != nil && x.Field37252 != nil {
+		return *x.Field37252
+	}
+	return ""
+}
+
+func (x *Message37173) GetField37253() int64 {
+	if x != nil && x.Field37253 != nil {
+		return *x.Field37253
+	}
+	return 0
+}
+
+func (x *Message37173) GetField37254() UnusedEnum {
+	if x != nil && x.Field37254 != nil {
+		return *x.Field37254
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+func (x *Message37173) GetField37255() bool {
+	if x != nil && x.Field37255 != nil {
+		return *x.Field37255
+	}
+	return false
+}
+
+func (x *Message37173) GetField37256() bool {
+	if x != nil && x.Field37256 != nil {
+		return *x.Field37256
+	}
+	return false
+}
+
+func (x *Message37173) GetField37257() bool {
+	if x != nil && x.Field37257 != nil {
+		return *x.Field37257
+	}
+	return false
+}
+
+func (x *Message37173) GetField37258() string {
+	if x != nil && x.Field37258 != nil {
+		return *x.Field37258
+	}
+	return ""
+}
+
+func (x *Message37173) GetField37259() string {
+	if x != nil && x.Field37259 != nil {
+		return *x.Field37259
+	}
+	return ""
+}
+
+func (x *Message37173) GetField37260() uint32 {
+	if x != nil && x.Field37260 != nil {
+		return *x.Field37260
+	}
+	return 0
+}
+
+func (x *Message37173) GetField37261() uint32 {
+	if x != nil && x.Field37261 != nil {
+		return *x.Field37261
+	}
+	return 0
+}
+
+func (x *Message37173) GetField37262() string {
+	if x != nil && x.Field37262 != nil {
+		return *x.Field37262
+	}
+	return ""
+}
+
+func (x *Message37173) GetField37263() string {
+	if x != nil && x.Field37263 != nil {
+		return *x.Field37263
+	}
+	return ""
+}
+
+func (x *Message37173) GetField37264() string {
+	if x != nil && x.Field37264 != nil {
+		return *x.Field37264
+	}
+	return ""
+}
+
+func (x *Message37173) GetField37265() int32 {
+	if x != nil && x.Field37265 != nil {
+		return *x.Field37265
+	}
+	return 0
+}
+
+func (x *Message37173) GetField37266() int64 {
+	if x != nil && x.Field37266 != nil {
+		return *x.Field37266
+	}
+	return 0
+}
+
+func (x *Message37173) GetField37267() int64 {
+	if x != nil && x.Field37267 != nil {
+		return *x.Field37267
+	}
+	return 0
+}
+
+func (x *Message37173) GetField37268() int32 {
+	if x != nil && x.Field37268 != nil {
+		return *x.Field37268
+	}
+	return 0
+}
+
+func (x *Message37173) GetField37269() int32 {
+	if x != nil && x.Field37269 != nil {
+		return *x.Field37269
+	}
+	return 0
+}
+
+func (x *Message37173) GetField37270() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37270
+	}
+	return nil
+}
+
+func (x *Message37173) GetField37271() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37271
+	}
+	return nil
+}
+
+func (x *Message37173) GetField37272() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37272
+	}
+	return nil
+}
+
+func (x *Message37173) GetField37273() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37273
+	}
+	return nil
+}
+
+func (x *Message37173) GetField37274() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field37274
+	}
+	return nil
+}
+
+func (x *Message37173) GetField37275() string {
+	if x != nil && x.Field37275 != nil {
+		return *x.Field37275
+	}
+	return ""
+}
+
+func (x *Message37173) GetField37276() bool {
+	if x != nil && x.Field37276 != nil {
+		return *x.Field37276
+	}
+	return false
+}
+
+type Message12799 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12809 *string         `protobuf:"bytes,1,req,name=field12809" json:"field12809,omitempty"`
+	Field12810 []uint64        `protobuf:"fixed64,2,rep,name=field12810" json:"field12810,omitempty"`
+	Field12811 []*Message12776 `protobuf:"bytes,8,rep,name=field12811" json:"field12811,omitempty"`
+	Field12812 []int32         `protobuf:"varint,4,rep,name=field12812" json:"field12812,omitempty"`
+	Field12813 []*Message12798 `protobuf:"bytes,5,rep,name=field12813" json:"field12813,omitempty"`
+	Field12814 *int32          `protobuf:"varint,3,req,name=field12814" json:"field12814,omitempty"`
+	Field12815 *int32          `protobuf:"varint,6,opt,name=field12815" json:"field12815,omitempty"`
+	Field12816 *Message12797   `protobuf:"bytes,7,opt,name=field12816" json:"field12816,omitempty"`
+}
+
+func (x *Message12799) Reset() {
+	*x = Message12799{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[32]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12799) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12799) ProtoMessage() {}
+
+func (x *Message12799) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[32]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12799.ProtoReflect.Descriptor instead.
+func (*Message12799) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{32}
+}
+
+func (x *Message12799) GetField12809() string {
+	if x != nil && x.Field12809 != nil {
+		return *x.Field12809
+	}
+	return ""
+}
+
+func (x *Message12799) GetField12810() []uint64 {
+	if x != nil {
+		return x.Field12810
+	}
+	return nil
+}
+
+func (x *Message12799) GetField12811() []*Message12776 {
+	if x != nil {
+		return x.Field12811
+	}
+	return nil
+}
+
+func (x *Message12799) GetField12812() []int32 {
+	if x != nil {
+		return x.Field12812
+	}
+	return nil
+}
+
+func (x *Message12799) GetField12813() []*Message12798 {
+	if x != nil {
+		return x.Field12813
+	}
+	return nil
+}
+
+func (x *Message12799) GetField12814() int32 {
+	if x != nil && x.Field12814 != nil {
+		return *x.Field12814
+	}
+	return 0
+}
+
+func (x *Message12799) GetField12815() int32 {
+	if x != nil && x.Field12815 != nil {
+		return *x.Field12815
+	}
+	return 0
+}
+
+func (x *Message12799) GetField12816() *Message12797 {
+	if x != nil {
+		return x.Field12816
+	}
+	return nil
+}
+
+type Message12870 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12879 *int32          `protobuf:"varint,1,req,name=field12879" json:"field12879,omitempty"`
+	Field12880 *int32          `protobuf:"varint,7,opt,name=field12880" json:"field12880,omitempty"`
+	Field12881 *int32          `protobuf:"varint,2,req,name=field12881" json:"field12881,omitempty"`
+	Field12882 *uint64         `protobuf:"varint,3,opt,name=field12882" json:"field12882,omitempty"`
+	Field12883 *string         `protobuf:"bytes,2001,opt,name=field12883" json:"field12883,omitempty"`
+	Field12884 *uint64         `protobuf:"fixed64,4,opt,name=field12884" json:"field12884,omitempty"`
+	Field12885 []uint64        `protobuf:"fixed64,14,rep,name=field12885" json:"field12885,omitempty"`
+	Field12886 *int32          `protobuf:"varint,9,opt,name=field12886" json:"field12886,omitempty"`
+	Field12887 *int64          `protobuf:"varint,18,opt,name=field12887" json:"field12887,omitempty"`
+	Field12888 []*Message12870 `protobuf:"bytes,8,rep,name=field12888" json:"field12888,omitempty"`
+	Field12889 *int32          `protobuf:"varint,5,opt,name=field12889" json:"field12889,omitempty"`
+	Field12890 *uint64         `protobuf:"varint,6,opt,name=field12890" json:"field12890,omitempty"`
+	Field12891 *int32          `protobuf:"varint,10,opt,name=field12891" json:"field12891,omitempty"`
+	Field12892 *int32          `protobuf:"varint,11,opt,name=field12892" json:"field12892,omitempty"`
+	Field12893 *float64        `protobuf:"fixed64,12,opt,name=field12893" json:"field12893,omitempty"`
+	Field12894 *Message12825   `protobuf:"bytes,13,opt,name=field12894" json:"field12894,omitempty"`
+	Field12895 *float64        `protobuf:"fixed64,15,opt,name=field12895" json:"field12895,omitempty"`
+	Field12896 *string         `protobuf:"bytes,16,opt,name=field12896" json:"field12896,omitempty"`
+	Field12897 *Enum12871      `protobuf:"varint,17,opt,name=field12897,enum=benchmarks.google_message4.Enum12871" json:"field12897,omitempty"`
+	Field12898 *int32          `protobuf:"varint,19,opt,name=field12898" json:"field12898,omitempty"`
+}
+
+func (x *Message12870) Reset() {
+	*x = Message12870{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[33]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12870) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12870) ProtoMessage() {}
+
+func (x *Message12870) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[33]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12870.ProtoReflect.Descriptor instead.
+func (*Message12870) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{33}
+}
+
+func (x *Message12870) GetField12879() int32 {
+	if x != nil && x.Field12879 != nil {
+		return *x.Field12879
+	}
+	return 0
+}
+
+func (x *Message12870) GetField12880() int32 {
+	if x != nil && x.Field12880 != nil {
+		return *x.Field12880
+	}
+	return 0
+}
+
+func (x *Message12870) GetField12881() int32 {
+	if x != nil && x.Field12881 != nil {
+		return *x.Field12881
+	}
+	return 0
+}
+
+func (x *Message12870) GetField12882() uint64 {
+	if x != nil && x.Field12882 != nil {
+		return *x.Field12882
+	}
+	return 0
+}
+
+func (x *Message12870) GetField12883() string {
+	if x != nil && x.Field12883 != nil {
+		return *x.Field12883
+	}
+	return ""
+}
+
+func (x *Message12870) GetField12884() uint64 {
+	if x != nil && x.Field12884 != nil {
+		return *x.Field12884
+	}
+	return 0
+}
+
+func (x *Message12870) GetField12885() []uint64 {
+	if x != nil {
+		return x.Field12885
+	}
+	return nil
+}
+
+func (x *Message12870) GetField12886() int32 {
+	if x != nil && x.Field12886 != nil {
+		return *x.Field12886
+	}
+	return 0
+}
+
+func (x *Message12870) GetField12887() int64 {
+	if x != nil && x.Field12887 != nil {
+		return *x.Field12887
+	}
+	return 0
+}
+
+func (x *Message12870) GetField12888() []*Message12870 {
+	if x != nil {
+		return x.Field12888
+	}
+	return nil
+}
+
+func (x *Message12870) GetField12889() int32 {
+	if x != nil && x.Field12889 != nil {
+		return *x.Field12889
+	}
+	return 0
+}
+
+func (x *Message12870) GetField12890() uint64 {
+	if x != nil && x.Field12890 != nil {
+		return *x.Field12890
+	}
+	return 0
+}
+
+func (x *Message12870) GetField12891() int32 {
+	if x != nil && x.Field12891 != nil {
+		return *x.Field12891
+	}
+	return 0
+}
+
+func (x *Message12870) GetField12892() int32 {
+	if x != nil && x.Field12892 != nil {
+		return *x.Field12892
+	}
+	return 0
+}
+
+func (x *Message12870) GetField12893() float64 {
+	if x != nil && x.Field12893 != nil {
+		return *x.Field12893
+	}
+	return 0
+}
+
+func (x *Message12870) GetField12894() *Message12825 {
+	if x != nil {
+		return x.Field12894
+	}
+	return nil
+}
+
+func (x *Message12870) GetField12895() float64 {
+	if x != nil && x.Field12895 != nil {
+		return *x.Field12895
+	}
+	return 0
+}
+
+func (x *Message12870) GetField12896() string {
+	if x != nil && x.Field12896 != nil {
+		return *x.Field12896
+	}
+	return ""
+}
+
+func (x *Message12870) GetField12897() Enum12871 {
+	if x != nil && x.Field12897 != nil {
+		return *x.Field12897
+	}
+	return Enum12871_ENUM_VALUE12872
+}
+
+func (x *Message12870) GetField12898() int32 {
+	if x != nil && x.Field12898 != nil {
+		return *x.Field12898
+	}
+	return 0
+}
+
+type Message3804 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field3818 *int64     `protobuf:"varint,1,req,name=field3818" json:"field3818,omitempty"`
+	Field3819 *bool      `protobuf:"varint,2,req,name=field3819" json:"field3819,omitempty"`
+	Field3820 []Enum3805 `protobuf:"varint,4,rep,name=field3820,enum=benchmarks.google_message4.Enum3805" json:"field3820,omitempty"`
+	Field3821 *int32     `protobuf:"varint,5,opt,name=field3821" json:"field3821,omitempty"`
+	Field3822 *bool      `protobuf:"varint,6,opt,name=field3822" json:"field3822,omitempty"`
+	Field3823 *int64     `protobuf:"varint,7,opt,name=field3823" json:"field3823,omitempty"`
+	Field3824 *Enum3783  `protobuf:"varint,8,opt,name=field3824,enum=benchmarks.google_message4.Enum3783" json:"field3824,omitempty"`
+}
+
+func (x *Message3804) Reset() {
+	*x = Message3804{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[34]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message3804) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message3804) ProtoMessage() {}
+
+func (x *Message3804) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[34]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message3804.ProtoReflect.Descriptor instead.
+func (*Message3804) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{34}
+}
+
+func (x *Message3804) GetField3818() int64 {
+	if x != nil && x.Field3818 != nil {
+		return *x.Field3818
+	}
+	return 0
+}
+
+func (x *Message3804) GetField3819() bool {
+	if x != nil && x.Field3819 != nil {
+		return *x.Field3819
+	}
+	return false
+}
+
+func (x *Message3804) GetField3820() []Enum3805 {
+	if x != nil {
+		return x.Field3820
+	}
+	return nil
+}
+
+func (x *Message3804) GetField3821() int32 {
+	if x != nil && x.Field3821 != nil {
+		return *x.Field3821
+	}
+	return 0
+}
+
+func (x *Message3804) GetField3822() bool {
+	if x != nil && x.Field3822 != nil {
+		return *x.Field3822
+	}
+	return false
+}
+
+func (x *Message3804) GetField3823() int64 {
+	if x != nil && x.Field3823 != nil {
+		return *x.Field3823
+	}
+	return 0
+}
+
+func (x *Message3804) GetField3824() Enum3783 {
+	if x != nil && x.Field3824 != nil {
+		return *x.Field3824
+	}
+	return Enum3783_ENUM_VALUE3784
+}
+
+type Message12903 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12905 *string        `protobuf:"bytes,1,opt,name=field12905" json:"field12905,omitempty"`
+	Field12906 *Message8587   `protobuf:"bytes,2,opt,name=field12906" json:"field12906,omitempty"`
+	Field12907 []*Message8590 `protobuf:"bytes,3,rep,name=field12907" json:"field12907,omitempty"`
+}
+
+func (x *Message12903) Reset() {
+	*x = Message12903{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[35]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12903) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12903) ProtoMessage() {}
+
+func (x *Message12903) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[35]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12903.ProtoReflect.Descriptor instead.
+func (*Message12903) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{35}
+}
+
+func (x *Message12903) GetField12905() string {
+	if x != nil && x.Field12905 != nil {
+		return *x.Field12905
+	}
+	return ""
+}
+
+func (x *Message12903) GetField12906() *Message8587 {
+	if x != nil {
+		return x.Field12906
+	}
+	return nil
+}
+
+func (x *Message12903) GetField12907() []*Message8590 {
+	if x != nil {
+		return x.Field12907
+	}
+	return nil
+}
+
+type Message37326 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field37345 *string `protobuf:"bytes,1,req,name=field37345" json:"field37345,omitempty"`
+	Field37346 *string `protobuf:"bytes,2,opt,name=field37346" json:"field37346,omitempty"`
+}
+
+func (x *Message37326) Reset() {
+	*x = Message37326{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[36]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message37326) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message37326) ProtoMessage() {}
+
+func (x *Message37326) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[36]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message37326.ProtoReflect.Descriptor instead.
+func (*Message37326) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{36}
+}
+
+func (x *Message37326) GetField37345() string {
+	if x != nil && x.Field37345 != nil {
+		return *x.Field37345
+	}
+	return ""
+}
+
+func (x *Message37326) GetField37346() string {
+	if x != nil && x.Field37346 != nil {
+		return *x.Field37346
+	}
+	return ""
+}
+
+type Message2356 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field2368   *Message1374               `protobuf:"bytes,121,opt,name=field2368" json:"field2368,omitempty"`
+	Field2369   *uint64                    `protobuf:"varint,1,opt,name=field2369" json:"field2369,omitempty"`
+	Field2370   *int32                     `protobuf:"varint,2,opt,name=field2370" json:"field2370,omitempty"`
+	Field2371   *int32                     `protobuf:"varint,17,opt,name=field2371" json:"field2371,omitempty"`
+	Field2372   *string                    `protobuf:"bytes,3,req,name=field2372" json:"field2372,omitempty"`
+	Field2373   *int32                     `protobuf:"varint,7,opt,name=field2373" json:"field2373,omitempty"`
+	Field2374   []byte                     `protobuf:"bytes,8,opt,name=field2374" json:"field2374,omitempty"`
+	Field2375   *string                    `protobuf:"bytes,4,opt,name=field2375" json:"field2375,omitempty"`
+	Field2376   *string                    `protobuf:"bytes,101,opt,name=field2376" json:"field2376,omitempty"`
+	Field2377   *int32                     `protobuf:"varint,102,opt,name=field2377" json:"field2377,omitempty"`
+	Field2378   *int32                     `protobuf:"varint,103,opt,name=field2378" json:"field2378,omitempty"`
+	Field2379   *int32                     `protobuf:"varint,104,opt,name=field2379" json:"field2379,omitempty"`
+	Field2380   *int32                     `protobuf:"varint,113,opt,name=field2380" json:"field2380,omitempty"`
+	Field2381   *int32                     `protobuf:"varint,114,opt,name=field2381" json:"field2381,omitempty"`
+	Field2382   *int32                     `protobuf:"varint,115,opt,name=field2382" json:"field2382,omitempty"`
+	Field2383   *int32                     `protobuf:"varint,117,opt,name=field2383" json:"field2383,omitempty"`
+	Field2384   *int32                     `protobuf:"varint,118,opt,name=field2384" json:"field2384,omitempty"`
+	Field2385   *int32                     `protobuf:"varint,119,opt,name=field2385" json:"field2385,omitempty"`
+	Field2386   *int32                     `protobuf:"varint,105,opt,name=field2386" json:"field2386,omitempty"`
+	Field2387   []byte                     `protobuf:"bytes,5,opt,name=field2387" json:"field2387,omitempty"`
+	Message2357 *Message2356_Message2357   `protobuf:"group,6,opt,name=Message2357,json=message2357" json:"message2357,omitempty"`
+	Field2389   *string                    `protobuf:"bytes,120,opt,name=field2389" json:"field2389,omitempty"`
+	Message2358 *Message2356_Message2358   `protobuf:"group,107,opt,name=Message2358,json=message2358" json:"message2358,omitempty"`
+	Message2359 []*Message2356_Message2359 `protobuf:"group,40,rep,name=Message2359,json=message2359" json:"message2359,omitempty"`
+	Field2392   *int32                     `protobuf:"varint,50,opt,name=field2392" json:"field2392,omitempty"`
+	Field2393   *UnusedEmptyMessage        `protobuf:"bytes,60,opt,name=field2393" json:"field2393,omitempty"`
+	Field2394   *UnusedEmptyMessage        `protobuf:"bytes,70,opt,name=field2394" json:"field2394,omitempty"`
+	Field2395   *UnusedEmptyMessage        `protobuf:"bytes,80,opt,name=field2395" json:"field2395,omitempty"`
+	Field2396   *UnusedEmptyMessage        `protobuf:"bytes,90,opt,name=field2396" json:"field2396,omitempty"`
+	Field2397   *string                    `protobuf:"bytes,100,opt,name=field2397" json:"field2397,omitempty"`
+	Field2398   *string                    `protobuf:"bytes,123,opt,name=field2398" json:"field2398,omitempty"`
+}
+
+func (x *Message2356) Reset() {
+	*x = Message2356{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[37]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message2356) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message2356) ProtoMessage() {}
+
+func (x *Message2356) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[37]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message2356.ProtoReflect.Descriptor instead.
+func (*Message2356) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{37}
+}
+
+func (x *Message2356) GetField2368() *Message1374 {
+	if x != nil {
+		return x.Field2368
+	}
+	return nil
+}
+
+func (x *Message2356) GetField2369() uint64 {
+	if x != nil && x.Field2369 != nil {
+		return *x.Field2369
+	}
+	return 0
+}
+
+func (x *Message2356) GetField2370() int32 {
+	if x != nil && x.Field2370 != nil {
+		return *x.Field2370
+	}
+	return 0
+}
+
+func (x *Message2356) GetField2371() int32 {
+	if x != nil && x.Field2371 != nil {
+		return *x.Field2371
+	}
+	return 0
+}
+
+func (x *Message2356) GetField2372() string {
+	if x != nil && x.Field2372 != nil {
+		return *x.Field2372
+	}
+	return ""
+}
+
+func (x *Message2356) GetField2373() int32 {
+	if x != nil && x.Field2373 != nil {
+		return *x.Field2373
+	}
+	return 0
+}
+
+func (x *Message2356) GetField2374() []byte {
+	if x != nil {
+		return x.Field2374
+	}
+	return nil
+}
+
+func (x *Message2356) GetField2375() string {
+	if x != nil && x.Field2375 != nil {
+		return *x.Field2375
+	}
+	return ""
+}
+
+func (x *Message2356) GetField2376() string {
+	if x != nil && x.Field2376 != nil {
+		return *x.Field2376
+	}
+	return ""
+}
+
+func (x *Message2356) GetField2377() int32 {
+	if x != nil && x.Field2377 != nil {
+		return *x.Field2377
+	}
+	return 0
+}
+
+func (x *Message2356) GetField2378() int32 {
+	if x != nil && x.Field2378 != nil {
+		return *x.Field2378
+	}
+	return 0
+}
+
+func (x *Message2356) GetField2379() int32 {
+	if x != nil && x.Field2379 != nil {
+		return *x.Field2379
+	}
+	return 0
+}
+
+func (x *Message2356) GetField2380() int32 {
+	if x != nil && x.Field2380 != nil {
+		return *x.Field2380
+	}
+	return 0
+}
+
+func (x *Message2356) GetField2381() int32 {
+	if x != nil && x.Field2381 != nil {
+		return *x.Field2381
+	}
+	return 0
+}
+
+func (x *Message2356) GetField2382() int32 {
+	if x != nil && x.Field2382 != nil {
+		return *x.Field2382
+	}
+	return 0
+}
+
+func (x *Message2356) GetField2383() int32 {
+	if x != nil && x.Field2383 != nil {
+		return *x.Field2383
+	}
+	return 0
+}
+
+func (x *Message2356) GetField2384() int32 {
+	if x != nil && x.Field2384 != nil {
+		return *x.Field2384
+	}
+	return 0
+}
+
+func (x *Message2356) GetField2385() int32 {
+	if x != nil && x.Field2385 != nil {
+		return *x.Field2385
+	}
+	return 0
+}
+
+func (x *Message2356) GetField2386() int32 {
+	if x != nil && x.Field2386 != nil {
+		return *x.Field2386
+	}
+	return 0
+}
+
+func (x *Message2356) GetField2387() []byte {
+	if x != nil {
+		return x.Field2387
+	}
+	return nil
+}
+
+func (x *Message2356) GetMessage2357() *Message2356_Message2357 {
+	if x != nil {
+		return x.Message2357
+	}
+	return nil
+}
+
+func (x *Message2356) GetField2389() string {
+	if x != nil && x.Field2389 != nil {
+		return *x.Field2389
+	}
+	return ""
+}
+
+func (x *Message2356) GetMessage2358() *Message2356_Message2358 {
+	if x != nil {
+		return x.Message2358
+	}
+	return nil
+}
+
+func (x *Message2356) GetMessage2359() []*Message2356_Message2359 {
+	if x != nil {
+		return x.Message2359
+	}
+	return nil
+}
+
+func (x *Message2356) GetField2392() int32 {
+	if x != nil && x.Field2392 != nil {
+		return *x.Field2392
+	}
+	return 0
+}
+
+func (x *Message2356) GetField2393() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field2393
+	}
+	return nil
+}
+
+func (x *Message2356) GetField2394() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field2394
+	}
+	return nil
+}
+
+func (x *Message2356) GetField2395() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field2395
+	}
+	return nil
+}
+
+func (x *Message2356) GetField2396() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field2396
+	}
+	return nil
+}
+
+func (x *Message2356) GetField2397() string {
+	if x != nil && x.Field2397 != nil {
+		return *x.Field2397
+	}
+	return ""
+}
+
+func (x *Message2356) GetField2398() string {
+	if x != nil && x.Field2398 != nil {
+		return *x.Field2398
+	}
+	return ""
+}
+
+type Message0 struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+}
+
+func (x *Message0) Reset() {
+	*x = Message0{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[38]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message0) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message0) ProtoMessage() {}
+
+func (x *Message0) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[38]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message0.ProtoReflect.Descriptor instead.
+func (*Message0) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{38}
+}
+
+var extRange_Message0 = []protoiface.ExtensionRangeV1{
+	{Start: 4, End: 2147483646},
+}
+
+// Deprecated: Use Message0.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*Message0) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_Message0
+}
+
+type Message971 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field972 *string `protobuf:"bytes,1,opt,name=field972" json:"field972,omitempty"`
+	Field973 *int32  `protobuf:"varint,2,opt,name=field973" json:"field973,omitempty"`
+	Field974 *bool   `protobuf:"varint,3,opt,name=field974" json:"field974,omitempty"`
+}
+
+func (x *Message971) Reset() {
+	*x = Message971{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[39]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message971) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message971) ProtoMessage() {}
+
+func (x *Message971) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[39]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message971.ProtoReflect.Descriptor instead.
+func (*Message971) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{39}
+}
+
+func (x *Message971) GetField972() string {
+	if x != nil && x.Field972 != nil {
+		return *x.Field972
+	}
+	return ""
+}
+
+func (x *Message971) GetField973() int32 {
+	if x != nil && x.Field973 != nil {
+		return *x.Field973
+	}
+	return 0
+}
+
+func (x *Message971) GetField974() bool {
+	if x != nil && x.Field974 != nil {
+		return *x.Field974
+	}
+	return false
+}
+
+type Message176_Message178 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message176_Message178) Reset() {
+	*x = Message176_Message178{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[40]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message176_Message178) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message176_Message178) ProtoMessage() {}
+
+func (x *Message176_Message178) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[40]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message176_Message178.ProtoReflect.Descriptor instead.
+func (*Message176_Message178) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{8, 0}
+}
+
+type Message3069_Message3070 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field3378 *Enum3071 `protobuf:"varint,4,req,name=field3378,enum=benchmarks.google_message4.Enum3071" json:"field3378,omitempty"`
+	Field3379 []byte    `protobuf:"bytes,5,req,name=field3379" json:"field3379,omitempty"`
+}
+
+func (x *Message3069_Message3070) Reset() {
+	*x = Message3069_Message3070{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[41]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message3069_Message3070) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message3069_Message3070) ProtoMessage() {}
+
+func (x *Message3069_Message3070) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[41]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message3069_Message3070.ProtoReflect.Descriptor instead.
+func (*Message3069_Message3070) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{27, 0}
+}
+
+func (x *Message3069_Message3070) GetField3378() Enum3071 {
+	if x != nil && x.Field3378 != nil {
+		return *x.Field3378
+	}
+	return Enum3071_ENUM_VALUE3072
+}
+
+func (x *Message3069_Message3070) GetField3379() []byte {
+	if x != nil {
+		return x.Field3379
+	}
+	return nil
+}
+
+type Message2356_Message2357 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field2399 *int64 `protobuf:"varint,9,opt,name=field2399" json:"field2399,omitempty"`
+	Field2400 *int32 `protobuf:"varint,10,opt,name=field2400" json:"field2400,omitempty"`
+	Field2401 *int32 `protobuf:"varint,11,opt,name=field2401" json:"field2401,omitempty"`
+	Field2402 *int32 `protobuf:"varint,12,opt,name=field2402" json:"field2402,omitempty"`
+	Field2403 *int32 `protobuf:"varint,13,opt,name=field2403" json:"field2403,omitempty"`
+	Field2404 *int32 `protobuf:"varint,116,opt,name=field2404" json:"field2404,omitempty"`
+	Field2405 *int32 `protobuf:"varint,106,opt,name=field2405" json:"field2405,omitempty"`
+	Field2406 []byte `protobuf:"bytes,14,req,name=field2406" json:"field2406,omitempty"`
+	Field2407 *int32 `protobuf:"varint,45,opt,name=field2407" json:"field2407,omitempty"`
+	Field2408 *int32 `protobuf:"varint,112,opt,name=field2408" json:"field2408,omitempty"`
+	Field2409 *bool  `protobuf:"varint,122,opt,name=field2409" json:"field2409,omitempty"`
+	Field2410 []byte `protobuf:"bytes,124,opt,name=field2410" json:"field2410,omitempty"`
+}
+
+func (x *Message2356_Message2357) Reset() {
+	*x = Message2356_Message2357{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[42]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message2356_Message2357) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message2356_Message2357) ProtoMessage() {}
+
+func (x *Message2356_Message2357) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[42]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message2356_Message2357.ProtoReflect.Descriptor instead.
+func (*Message2356_Message2357) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{37, 0}
+}
+
+func (x *Message2356_Message2357) GetField2399() int64 {
+	if x != nil && x.Field2399 != nil {
+		return *x.Field2399
+	}
+	return 0
+}
+
+func (x *Message2356_Message2357) GetField2400() int32 {
+	if x != nil && x.Field2400 != nil {
+		return *x.Field2400
+	}
+	return 0
+}
+
+func (x *Message2356_Message2357) GetField2401() int32 {
+	if x != nil && x.Field2401 != nil {
+		return *x.Field2401
+	}
+	return 0
+}
+
+func (x *Message2356_Message2357) GetField2402() int32 {
+	if x != nil && x.Field2402 != nil {
+		return *x.Field2402
+	}
+	return 0
+}
+
+func (x *Message2356_Message2357) GetField2403() int32 {
+	if x != nil && x.Field2403 != nil {
+		return *x.Field2403
+	}
+	return 0
+}
+
+func (x *Message2356_Message2357) GetField2404() int32 {
+	if x != nil && x.Field2404 != nil {
+		return *x.Field2404
+	}
+	return 0
+}
+
+func (x *Message2356_Message2357) GetField2405() int32 {
+	if x != nil && x.Field2405 != nil {
+		return *x.Field2405
+	}
+	return 0
+}
+
+func (x *Message2356_Message2357) GetField2406() []byte {
+	if x != nil {
+		return x.Field2406
+	}
+	return nil
+}
+
+func (x *Message2356_Message2357) GetField2407() int32 {
+	if x != nil && x.Field2407 != nil {
+		return *x.Field2407
+	}
+	return 0
+}
+
+func (x *Message2356_Message2357) GetField2408() int32 {
+	if x != nil && x.Field2408 != nil {
+		return *x.Field2408
+	}
+	return 0
+}
+
+func (x *Message2356_Message2357) GetField2409() bool {
+	if x != nil && x.Field2409 != nil {
+		return *x.Field2409
+	}
+	return false
+}
+
+func (x *Message2356_Message2357) GetField2410() []byte {
+	if x != nil {
+		return x.Field2410
+	}
+	return nil
+}
+
+type Message2356_Message2358 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message2356_Message2358) Reset() {
+	*x = Message2356_Message2358{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[43]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message2356_Message2358) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message2356_Message2358) ProtoMessage() {}
+
+func (x *Message2356_Message2358) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[43]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message2356_Message2358.ProtoReflect.Descriptor instead.
+func (*Message2356_Message2358) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{37, 1}
+}
+
+type Message2356_Message2359 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message2356_Message2359) Reset() {
+	*x = Message2356_Message2359{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[44]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message2356_Message2359) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message2356_Message2359) ProtoMessage() {}
+
+func (x *Message2356_Message2359) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_proto_msgTypes[44]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message2356_Message2359.ProtoReflect.Descriptor instead.
+func (*Message2356_Message2359) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP(), []int{37, 2}
+}
+
+var File_datasets_google_message4_benchmark_message4_proto protoreflect.FileDescriptor
+
+var file_datasets_google_message4_benchmark_message4_proto_rawDesc = []byte{
+	0x0a, 0x31, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x12, 0x1a, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x1a,
+	0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x5f, 0x31, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2f, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x34, 0x5f, 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73,
+	0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x34, 0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x5f, 0x33, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xda,
+	0x09, 0x0a, 0x0e, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x30, 0x33, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x30,
+	0x33, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x30, 0x34, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x30,
+	0x34, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x30, 0x35, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x30,
+	0x35, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x30, 0x36, 0x18,
+	0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x30,
+	0x36, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x30, 0x37, 0x18,
+	0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x30,
+	0x37, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x30, 0x38, 0x18,
+	0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x37, 0x34, 0x38, 0x39, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x30, 0x38, 0x12, 0x4e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x30, 0x39, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x30, 0x39, 0x12, 0x4e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x31, 0x30, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x31, 0x30, 0x12, 0x4e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x31, 0x31, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x31, 0x31, 0x12, 0x4e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x31, 0x32, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x31, 0x32, 0x12, 0x4e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x31, 0x33, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x31, 0x33, 0x12, 0x4e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x31, 0x34, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x31, 0x34, 0x12, 0x4e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x31, 0x35, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x31, 0x35, 0x12, 0x4e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x31, 0x36, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x31, 0x36, 0x12, 0x4e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x31, 0x37, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x31, 0x37, 0x12, 0x4e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x31, 0x38, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x31, 0x38, 0x22, 0x96, 0x0c, 0x0a, 0x0c,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x37, 0x34, 0x38, 0x39, 0x12, 0x47, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x33, 0x34, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x35, 0x31, 0x37, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x37, 0x35, 0x33, 0x34, 0x12, 0x47, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37,
+	0x35, 0x33, 0x35, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x33,
+	0x33, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x33, 0x35, 0x12, 0x47,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x33, 0x36, 0x18, 0x06, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x38, 0x31, 0x35, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x35, 0x33, 0x36, 0x12, 0x47, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x37, 0x35, 0x33, 0x37, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x38, 0x38, 0x31, 0x37, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x33, 0x37,
+	0x12, 0x47, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x33, 0x38, 0x18, 0x08,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x38, 0x33, 0x35, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x33, 0x38, 0x12, 0x47, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x35, 0x33, 0x39, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x38, 0x38, 0x34, 0x38, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35,
+	0x33, 0x39, 0x12, 0x47, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x34, 0x30,
+	0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x38, 0x35, 0x36, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x34, 0x30, 0x12, 0x48, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x34, 0x31, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x37, 0x31, 0x37, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x37, 0x35, 0x34, 0x31, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37,
+	0x35, 0x34, 0x32, 0x18, 0x14, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32,
+	0x37, 0x34, 0x38, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x34, 0x32, 0x12,
+	0x47, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x34, 0x33, 0x18, 0x16, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x33, 0x31, 0x39, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x34, 0x33, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x37, 0x35, 0x34, 0x34, 0x18, 0x18, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x31, 0x32, 0x39, 0x30, 0x38, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35,
+	0x34, 0x34, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x34, 0x35,
+	0x18, 0x19, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x39, 0x31, 0x30,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x34, 0x35, 0x12, 0x48, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x34, 0x36, 0x18, 0x1e, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x39, 0x36, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x37, 0x35, 0x34, 0x36, 0x12, 0x46, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x37, 0x35, 0x34, 0x37, 0x18, 0x21, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31,
+	0x37, 0x36, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x34, 0x37, 0x12, 0x48,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x34, 0x38, 0x18, 0x22, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x30, 0x30, 0x30, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x34, 0x38, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x37, 0x35, 0x34, 0x39, 0x18, 0x23, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x31, 0x33, 0x30, 0x33, 0x35, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35,
+	0x34, 0x39, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x35, 0x30,
+	0x18, 0x24, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x37, 0x33, 0x33, 0x31,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x35, 0x30, 0x12, 0x48, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x35, 0x31, 0x18, 0x25, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x37, 0x33, 0x32, 0x39, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x37, 0x35, 0x35, 0x31, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x37, 0x35, 0x35, 0x32, 0x18, 0x26, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x37, 0x33, 0x32, 0x37, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x35, 0x32,
+	0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x35, 0x33, 0x18, 0x27,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x37, 0x33, 0x33, 0x33, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x35, 0x33, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x37, 0x35, 0x35, 0x34, 0x18, 0x28, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x37, 0x33, 0x33, 0x35, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x37, 0x35, 0x35, 0x34, 0x22, 0xa9, 0x01, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x37, 0x33, 0x31, 0x39, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x33, 0x32,
+	0x31, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x33,
+	0x32, 0x31, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x33, 0x32, 0x32, 0x18,
+	0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x33, 0x32, 0x32,
+	0x22, 0xb0, 0x04, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x37, 0x31,
+	0x37, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x31, 0x39, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x31,
+	0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x32, 0x30, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x32,
+	0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x32, 0x31, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x32,
+	0x31, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x32, 0x32, 0x18,
+	0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x31, 0x39, 0x37, 0x36, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x32, 0x32, 0x12, 0x48, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x32, 0x33, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x31, 0x31, 0x39, 0x34, 0x38, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x37, 0x32, 0x33, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32,
+	0x37, 0x32, 0x34, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x31,
+	0x39, 0x34, 0x37, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x32, 0x34, 0x12,
+	0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x32, 0x35, 0x18, 0x07, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x36, 0x38, 0x37, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x32, 0x35, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x37, 0x32, 0x36, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x31, 0x31, 0x39, 0x34, 0x38, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32,
+	0x37, 0x32, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x32,
+	0x37, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32,
+	0x37, 0x32, 0x37, 0x22, 0xe8, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x37, 0x33, 0x33, 0x31, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33,
+	0x36, 0x37, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74,
+	0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x37, 0x33, 0x36, 0x37, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33,
+	0x36, 0x38, 0x18, 0x01, 0x20, 0x02, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x37, 0x33,
+	0x32, 0x36, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x36, 0x38, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x36, 0x39, 0x18, 0x02, 0x20, 0x02,
+	0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x36, 0x39, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x37, 0x30, 0x18, 0x03, 0x20, 0x02,
+	0x28, 0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x37, 0x30, 0x22, 0xc0,
+	0x01, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x38, 0x31, 0x35, 0x12, 0x4c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x31, 0x39, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55,
+	0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x31, 0x39, 0x12, 0x45, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x32, 0x30, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x38, 0x37, 0x36, 0x38, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x38, 0x32, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x32, 0x31,
+	0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x32,
+	0x31, 0x22, 0xf3, 0x02, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x33, 0x33,
+	0x30, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x33, 0x33, 0x32, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x33, 0x33, 0x32, 0x12,
+	0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x33, 0x33, 0x33, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x30, 0x36, 0x39, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x37, 0x33, 0x33, 0x33, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37,
+	0x33, 0x33, 0x34, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x33,
+	0x32, 0x30, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x33, 0x33, 0x34, 0x12, 0x4c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x33, 0x33, 0x35, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e,
+	0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x33, 0x33, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x37, 0x33, 0x33, 0x36, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x33, 0x33, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x37, 0x33, 0x33, 0x37, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x33, 0x33, 0x37, 0x22, 0xa8, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x31, 0x32, 0x39, 0x36, 0x30, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x32, 0x39, 0x36, 0x32, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64,
+	0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x36, 0x32, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x32, 0x39, 0x36, 0x33, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x31, 0x32, 0x39, 0x34, 0x38, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39,
+	0x36, 0x33, 0x22, 0xb5, 0x11, 0x0a, 0x0a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x37,
+	0x36, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x30, 0x38, 0x18, 0x01, 0x20,
+	0x02, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x30, 0x38, 0x12, 0x1a, 0x0a,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x30, 0x39, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x30, 0x39, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x34, 0x31, 0x30, 0x18, 0x32, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x34, 0x31, 0x30, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x31,
+	0x31, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x31,
+	0x31, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x31, 0x32, 0x18, 0x2f, 0x20,
+	0x01, 0x28, 0x04, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x31, 0x32, 0x12, 0x1a, 0x0a,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x31, 0x33, 0x18, 0x38, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x31, 0x33, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x34, 0x31, 0x34, 0x18, 0x18, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x34, 0x31, 0x34, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x31,
+	0x35, 0x18, 0x15, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x31,
+	0x35, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x31, 0x36, 0x18, 0x03, 0x20,
+	0x01, 0x28, 0x0c, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x31, 0x36, 0x12, 0x1a, 0x0a,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x31, 0x37, 0x18, 0x39, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x31, 0x37, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x34, 0x31, 0x38, 0x18, 0x33, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x34, 0x31, 0x38, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x31,
+	0x39, 0x18, 0x07, 0x20, 0x01, 0x28, 0x02, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x31,
+	0x39, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x32, 0x30, 0x18, 0x05, 0x20,
+	0x01, 0x28, 0x08, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x32, 0x30, 0x12, 0x1a, 0x0a,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x32, 0x31, 0x18, 0x1c, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x32, 0x31, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x34, 0x32, 0x32, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x34, 0x32, 0x32, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x32,
+	0x33, 0x18, 0x28, 0x20, 0x03, 0x28, 0x05, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x32,
+	0x33, 0x12, 0x4a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x32, 0x34, 0x18, 0x29, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34,
+	0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x32, 0x34, 0x12, 0x1a, 0x0a,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x32, 0x35, 0x18, 0x19, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x32, 0x35, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x34, 0x32, 0x36, 0x18, 0x1a, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x34, 0x32, 0x36, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x32,
+	0x37, 0x18, 0x26, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x32,
+	0x37, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x32, 0x38, 0x18, 0x0f, 0x20,
+	0x01, 0x28, 0x0c, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x32, 0x38, 0x12, 0x1a, 0x0a,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x32, 0x39, 0x18, 0x37, 0x20, 0x01, 0x28, 0x0c, 0x52,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x32, 0x39, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x34, 0x33, 0x30, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x34, 0x33, 0x30, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x33,
+	0x31, 0x18, 0x17, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x33,
+	0x31, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x33, 0x32, 0x18, 0x21, 0x20,
+	0x01, 0x28, 0x08, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x33, 0x32, 0x12, 0x1a, 0x0a,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x33, 0x33, 0x18, 0x1f, 0x20, 0x01, 0x28, 0x0c, 0x52,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x33, 0x33, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x34, 0x33, 0x34, 0x18, 0x20, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x34, 0x33, 0x34, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x33,
+	0x35, 0x18, 0x24, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x33,
+	0x35, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x33, 0x36, 0x18, 0x11, 0x20,
+	0x01, 0x28, 0x04, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x33, 0x36, 0x12, 0x1a, 0x0a,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x33, 0x37, 0x18, 0x2d, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x33, 0x37, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x34, 0x33, 0x38, 0x18, 0x12, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x34, 0x33, 0x38, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x33,
+	0x39, 0x18, 0x2e, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x33,
+	0x39, 0x12, 0x4a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x34, 0x30, 0x18, 0x40, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34,
+	0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x34, 0x30, 0x12, 0x1a, 0x0a,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x34, 0x31, 0x18, 0x27, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x34, 0x31, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x34, 0x34, 0x32, 0x18, 0x30, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x34, 0x34, 0x32, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x34,
+	0x33, 0x18, 0x13, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x34,
+	0x33, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x34, 0x34, 0x18, 0x2a, 0x20,
+	0x01, 0x28, 0x0c, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x34, 0x34, 0x12, 0x1a, 0x0a,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x34, 0x35, 0x18, 0x2b, 0x20, 0x01, 0x28, 0x0c, 0x52,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x34, 0x35, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x34, 0x34, 0x36, 0x18, 0x2c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x34, 0x34, 0x36, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x34,
+	0x37, 0x18, 0x31, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x34,
+	0x37, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x34, 0x38, 0x18, 0x14, 0x20,
+	0x01, 0x28, 0x03, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x34, 0x38, 0x12, 0x1a, 0x0a,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x34, 0x39, 0x18, 0x35, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x34, 0x39, 0x12, 0x4a, 0x0a, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x34, 0x35, 0x30, 0x18, 0x36, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45,
+	0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x34, 0x35, 0x30, 0x12, 0x4a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x35,
+	0x31, 0x18, 0x16, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x35,
+	0x31, 0x12, 0x42, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x35, 0x32, 0x18, 0x1b, 0x20,
+	0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34,
+	0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x34, 0x35, 0x32, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x35,
+	0x33, 0x18, 0x1d, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x35,
+	0x33, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x35, 0x34, 0x18, 0x1e, 0x20,
+	0x01, 0x28, 0x05, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x35, 0x34, 0x12, 0x42, 0x0a,
+	0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x35, 0x35, 0x18, 0x25, 0x20, 0x01, 0x28, 0x0e, 0x32,
+	0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x35,
+	0x35, 0x12, 0x42, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x35, 0x36, 0x18, 0x22, 0x20,
+	0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34,
+	0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x08, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x34, 0x35, 0x36, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x35,
+	0x37, 0x18, 0x23, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x35,
+	0x37, 0x12, 0x51, 0x0a, 0x0a, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x37, 0x38, 0x18,
+	0x65, 0x20, 0x03, 0x28, 0x0a, 0x32, 0x31, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x37, 0x36, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x37, 0x38, 0x52, 0x0a, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x31, 0x37, 0x38, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x35, 0x39,
+	0x18, 0x34, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x35, 0x39,
+	0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x36, 0x30, 0x18, 0x3a, 0x20, 0x01,
+	0x28, 0x04, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x36, 0x30, 0x12, 0x1a, 0x0a, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x36, 0x31, 0x18, 0x3b, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x36, 0x31, 0x12, 0x4a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x34, 0x36, 0x32, 0x18, 0x3c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d,
+	0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x34, 0x36, 0x32, 0x12, 0x4a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x36, 0x33,
+	0x18, 0x3d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x36, 0x33,
+	0x12, 0x42, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x36, 0x34, 0x18, 0x3e, 0x20, 0x01,
+	0x28, 0x0e, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e,
+	0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x34, 0x36, 0x34, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x36, 0x35,
+	0x18, 0x3f, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x36, 0x35,
+	0x12, 0x4a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x36, 0x36, 0x18, 0x41, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e,
+	0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x36, 0x36, 0x1a, 0x0c, 0x0a, 0x0a,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x37, 0x38, 0x22, 0xc0, 0x01, 0x0a, 0x0b, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x38, 0x31, 0x37, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x38, 0x32, 0x35, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65,
+	0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x32, 0x35, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x38, 0x32, 0x36, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x38, 0x37, 0x36, 0x38, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x32, 0x36, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x32, 0x37, 0x18, 0x03, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x32, 0x37, 0x22, 0xbf, 0x01,
+	0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x38, 0x33, 0x35, 0x12, 0x4c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x33, 0x37, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e,
+	0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x33, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x33, 0x38, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x33, 0x38, 0x12, 0x44, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x38, 0x33, 0x39, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64,
+	0x45, 0x6e, 0x75, 0x6d, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x33, 0x39, 0x22,
+	0xc8, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x37, 0x33, 0x33, 0x33,
+	0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x37, 0x32, 0x18, 0x03,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x37, 0x32,
+	0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x37, 0x33, 0x18, 0x01,
+	0x20, 0x02, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x37, 0x33, 0x32, 0x36, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x37, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x37, 0x34, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x37, 0x34, 0x22, 0x78, 0x0a, 0x0c, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x30, 0x30, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x33, 0x30, 0x31, 0x35, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x30, 0x31, 0x35, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x33, 0x30, 0x31, 0x36, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x31, 0x32, 0x39, 0x37, 0x39, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x33, 0x30, 0x31, 0x36, 0x22, 0x92, 0x02, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x37, 0x33, 0x33, 0x35, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37,
+	0x33, 0x37, 0x36, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70,
+	0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x37, 0x33, 0x37, 0x36, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37,
+	0x33, 0x37, 0x37, 0x18, 0x01, 0x20, 0x02, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x37,
+	0x33, 0x32, 0x36, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x37, 0x37, 0x12,
+	0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x37, 0x38, 0x18, 0x02, 0x20,
+	0x02, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x37, 0x31, 0x37, 0x33, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x37, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x33, 0x37, 0x39, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x37, 0x39, 0x22, 0x97, 0x01, 0x0a, 0x0b, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x38, 0x34, 0x38, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x38, 0x35, 0x30, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64,
+	0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x38, 0x35, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x38, 0x35, 0x31, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x38, 0x35, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38,
+	0x35, 0x32, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x38, 0x35, 0x32, 0x22, 0x4e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33,
+	0x30, 0x33, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x30, 0x35,
+	0x38, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33,
+	0x30, 0x35, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x30, 0x35,
+	0x39, 0x18, 0x02, 0x20, 0x03, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33,
+	0x30, 0x35, 0x39, 0x22, 0x79, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x38,
+	0x35, 0x36, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x35, 0x38, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x35, 0x38,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x35, 0x39, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x35, 0x39, 0x22, 0xfb,
+	0x02, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x39, 0x30, 0x38, 0x12,
+	0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x31, 0x32, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34,
+	0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x31, 0x32, 0x12,
+	0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x31, 0x33, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x31, 0x33, 0x12,
+	0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x31, 0x34, 0x18, 0x03, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x37, 0x39, 0x39, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x31, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x39, 0x31, 0x35, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x31, 0x35, 0x12, 0x47, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x39, 0x31, 0x36, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x38, 0x30, 0x34, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39,
+	0x31, 0x36, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x31, 0x37,
+	0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x38, 0x37, 0x30,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x31, 0x37, 0x22, 0xf2, 0x01, 0x0a,
+	0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x39, 0x31, 0x30, 0x12, 0x4e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x32, 0x30, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55,
+	0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x32, 0x30, 0x12, 0x48, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x32, 0x31, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x38, 0x31, 0x38, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x39, 0x32, 0x31, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x39, 0x32, 0x32, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x31, 0x32, 0x39, 0x30, 0x33, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x32,
+	0x32, 0x22, 0xf8, 0x03, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x37, 0x33,
+	0x32, 0x37, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x34, 0x37,
+	0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33,
+	0x34, 0x37, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x34, 0x38,
+	0x18, 0x01, 0x20, 0x02, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x37, 0x33, 0x32, 0x36,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x34, 0x38, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x34, 0x39, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x34, 0x39, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x35, 0x30, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x35, 0x30, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x35, 0x31, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x35, 0x31, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x35, 0x32, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x35, 0x32, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x35, 0x33, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x35, 0x33, 0x12, 0x4e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x35, 0x34, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e,
+	0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x35, 0x34, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x35, 0x35, 0x18, 0x08, 0x20, 0x01, 0x28, 0x04,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x35, 0x35, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x35, 0x36, 0x18, 0x09, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x35, 0x36, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x35, 0x37, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x35, 0x37, 0x22, 0x88, 0x02, 0x0a,
+	0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x37, 0x33, 0x32, 0x39, 0x12, 0x4e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x35, 0x39, 0x18, 0x06, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55,
+	0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x35, 0x39, 0x12, 0x48, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x33, 0x36, 0x30, 0x18, 0x01, 0x20, 0x02, 0x28,
+	0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x37, 0x33, 0x32, 0x36, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x33, 0x36, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x37, 0x33, 0x36, 0x31, 0x18, 0x02, 0x20, 0x02, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x33, 0x36, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x37, 0x33, 0x36, 0x32, 0x18, 0x03, 0x20, 0x02, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x33, 0x36, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x37, 0x33, 0x36, 0x33, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x33, 0x36, 0x33, 0x22, 0xf3, 0x02, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x32, 0x35, 0x31, 0x37, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x35, 0x31, 0x39, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d,
+	0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x35, 0x31, 0x39, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x35,
+	0x32, 0x30, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x33, 0x35,
+	0x36, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x35, 0x32, 0x30, 0x12, 0x42, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x35, 0x32, 0x31, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x30, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x35, 0x32, 0x31,
+	0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x35, 0x32, 0x32, 0x18, 0x04, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x36, 0x33, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x35, 0x32, 0x32, 0x12, 0x44, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x35, 0x32, 0x33, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x39,
+	0x37, 0x31, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x35, 0x32, 0x33, 0x22, 0xe5, 0x01,
+	0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x37, 0x34, 0x38, 0x12, 0x4e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x35, 0x34, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e,
+	0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x35, 0x34, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x35, 0x35, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x35, 0x35, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x35, 0x36, 0x18, 0x03, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x35, 0x36, 0x12, 0x45,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x35, 0x37, 0x18, 0x04, 0x20, 0x01,
+	0x28, 0x0e, 0x32, 0x25, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e,
+	0x45, 0x6e, 0x75, 0x6d, 0x31, 0x32, 0x37, 0x33, 0x35, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x37, 0x35, 0x37, 0x22, 0x58, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x31, 0x32, 0x36, 0x38, 0x37, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32,
+	0x37, 0x30, 0x31, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32,
+	0x36, 0x38, 0x36, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x30, 0x31, 0x22,
+	0x98, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x31, 0x39, 0x34, 0x38,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x39, 0x35, 0x34, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x39, 0x35, 0x34,
+	0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x39, 0x35, 0x35, 0x18, 0x02,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x31, 0x39, 0x34, 0x39, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x39, 0x35, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x31, 0x39, 0x35, 0x36, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x39, 0x35, 0x36, 0x22, 0x58, 0x0a, 0x0c, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x31, 0x39, 0x37, 0x36, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x30, 0x30, 0x32, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x31, 0x31, 0x39, 0x37, 0x35, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x30, 0x30, 0x32, 0x22, 0xa2, 0x01, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x37, 0x33, 0x32, 0x30, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x33, 0x32,
+	0x33, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x33,
+	0x32, 0x33, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x33, 0x32, 0x34, 0x18,
+	0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x32, 0x38, 0x37, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x33, 0x32, 0x34, 0x22, 0xc5, 0x02, 0x0a, 0x0b, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x30, 0x36, 0x39, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x33, 0x37, 0x34, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x30, 0x36, 0x31, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x37, 0x34,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x37, 0x35, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x37, 0x35, 0x12, 0x55,
+	0x0a, 0x0b, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x30, 0x37, 0x30, 0x18, 0x03, 0x20,
+	0x03, 0x28, 0x0a, 0x32, 0x33, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x30, 0x36, 0x39, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x30, 0x37, 0x30, 0x52, 0x0b, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x30, 0x37, 0x30, 0x1a, 0x6f, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x30, 0x37, 0x30, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x37,
+	0x38, 0x18, 0x04, 0x20, 0x02, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x33, 0x30, 0x37, 0x31, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x37, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x33, 0x37, 0x39, 0x18, 0x05, 0x20, 0x02, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x33, 0x37, 0x39, 0x2a, 0x09, 0x08, 0x90, 0x4e, 0x10, 0x80, 0x80, 0x80, 0x80,
+	0x02, 0x22, 0x58, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x39, 0x34,
+	0x38, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x35, 0x38, 0x18,
+	0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x39, 0x34, 0x39, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x35, 0x38, 0x22, 0xe1, 0x02, 0x0a, 0x0b,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x37, 0x36, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x37, 0x38, 0x32, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x37, 0x38, 0x32, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x37, 0x38, 0x33, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x38, 0x35, 0x37, 0x32, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x37, 0x38, 0x33,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x37, 0x38, 0x34, 0x18, 0x03, 0x20,
+	0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x37, 0x38, 0x34, 0x12, 0x45,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x37, 0x38, 0x35, 0x18, 0x04, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x37, 0x37, 0x34, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x37, 0x38, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x37,
+	0x38, 0x36, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x37, 0x38, 0x36, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x37, 0x38, 0x37,
+	0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x37, 0x38,
+	0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x37, 0x38, 0x38, 0x18, 0x07,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x37, 0x38, 0x38, 0x22,
+	0xce, 0x02, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x39, 0x37, 0x39,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x38, 0x31, 0x18, 0x01,
+	0x20, 0x02, 0x28, 0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x38, 0x31,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x38, 0x32, 0x18, 0x02,
+	0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x38, 0x32,
+	0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x38, 0x33, 0x18, 0x03,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x38, 0x33,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x38, 0x34, 0x18, 0x04,
+	0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x38, 0x34,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x38, 0x35, 0x18, 0x05,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x38, 0x35,
+	0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x38, 0x36, 0x18, 0x06,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x38, 0x36,
+	0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x38, 0x37, 0x18, 0x07,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x38, 0x37,
+	0x22, 0xc6, 0x08, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x37, 0x31, 0x37,
+	0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x32, 0x35, 0x32, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x32, 0x35,
+	0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x32, 0x35, 0x33, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x32, 0x35,
+	0x33, 0x12, 0x46, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x32, 0x35, 0x34, 0x18,
+	0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x32, 0x35, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x32, 0x35, 0x35, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x32, 0x35, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x32, 0x35, 0x36, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x32, 0x35, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x32, 0x35, 0x37, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x32, 0x35, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x32, 0x35, 0x38, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x32, 0x35, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x32, 0x35, 0x39, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x32, 0x35, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x32, 0x36, 0x30, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x32, 0x36, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x32, 0x36, 0x31, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x07, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x32, 0x36, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x32, 0x36, 0x32, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x32, 0x36, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x32, 0x36, 0x33, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x32, 0x36, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x32, 0x36, 0x34, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x32, 0x36, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x32, 0x36, 0x35, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x32, 0x36, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x32, 0x36, 0x36, 0x18, 0x10, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x32, 0x36, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x32, 0x36, 0x37, 0x18, 0x11, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x32, 0x36, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x32, 0x36, 0x38, 0x18, 0x12, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x32, 0x36, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x32, 0x36, 0x39, 0x18, 0x13, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x32, 0x36, 0x39, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x32, 0x37, 0x30, 0x18, 0x14, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65,
+	0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x32, 0x37, 0x30, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x32, 0x37, 0x31, 0x18, 0x15, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65,
+	0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x32, 0x37, 0x31, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x32, 0x37, 0x32, 0x18, 0x16, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65,
+	0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x32, 0x37, 0x32, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x32, 0x37, 0x33, 0x18, 0x17, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65,
+	0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x32, 0x37, 0x33, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x32, 0x37, 0x34, 0x18, 0x18, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65,
+	0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x32, 0x37, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x32, 0x37, 0x35, 0x18, 0x19, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x32, 0x37, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x37, 0x32, 0x37, 0x36, 0x18, 0x1a, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x37, 0x32, 0x37, 0x36, 0x22, 0x8c, 0x03, 0x0a, 0x0c, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x37, 0x39, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x30, 0x39, 0x18, 0x01, 0x20, 0x02, 0x28, 0x09, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x30, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x31, 0x30, 0x18, 0x02, 0x20, 0x03, 0x28, 0x06, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x31, 0x30, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x31, 0x31, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x31, 0x32, 0x37, 0x37, 0x36, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x38, 0x31, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38,
+	0x31, 0x32, 0x18, 0x04, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x38, 0x31, 0x32, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38,
+	0x31, 0x33, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x37,
+	0x39, 0x38, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x31, 0x33, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x31, 0x34, 0x18, 0x03, 0x20, 0x02,
+	0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x31, 0x34, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x31, 0x35, 0x18, 0x06, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x31, 0x35, 0x12, 0x48,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x31, 0x36, 0x18, 0x07, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x37, 0x39, 0x37, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x31, 0x36, 0x22, 0x8a, 0x06, 0x0a, 0x0c, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x38, 0x37, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x38, 0x37, 0x39, 0x18, 0x01, 0x20, 0x02, 0x28, 0x05, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x37, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x38, 0x38, 0x30, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x38, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x38, 0x38, 0x31, 0x18, 0x02, 0x20, 0x02, 0x28, 0x05, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x38, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x38, 0x38, 0x32, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x38, 0x32, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x38, 0x38, 0x33, 0x18, 0xd1, 0x0f, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x38, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x38, 0x34, 0x18, 0x04, 0x20, 0x01, 0x28, 0x06, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x38, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x38, 0x35, 0x18, 0x0e, 0x20, 0x03, 0x28, 0x06, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x38, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x38, 0x36, 0x18, 0x09, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x38, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x38, 0x37, 0x18, 0x12, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x38, 0x37, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x38, 0x38, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x31, 0x32, 0x38, 0x37, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x38, 0x38, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38,
+	0x38, 0x39, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x38, 0x38, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38,
+	0x39, 0x30, 0x18, 0x06, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x38, 0x39, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38,
+	0x39, 0x31, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x38, 0x39, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38,
+	0x39, 0x32, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x38, 0x39, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38,
+	0x39, 0x33, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x38, 0x39, 0x33, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38,
+	0x39, 0x34, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x38,
+	0x32, 0x35, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x39, 0x34, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x39, 0x35, 0x18, 0x0f, 0x20, 0x01,
+	0x28, 0x01, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x39, 0x35, 0x12, 0x1e,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x39, 0x36, 0x18, 0x10, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x39, 0x36, 0x12, 0x45,
+	0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x39, 0x37, 0x18, 0x11, 0x20, 0x01,
+	0x28, 0x0e, 0x32, 0x25, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e,
+	0x45, 0x6e, 0x75, 0x6d, 0x31, 0x32, 0x38, 0x37, 0x31, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x38, 0x39, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32,
+	0x38, 0x39, 0x38, 0x18, 0x13, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x38, 0x39, 0x38, 0x22, 0xab, 0x02, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x38, 0x30, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x38,
+	0x31, 0x38, 0x18, 0x01, 0x20, 0x02, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x38, 0x31, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x38, 0x31, 0x39,
+	0x18, 0x02, 0x20, 0x02, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x38, 0x31,
+	0x39, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x38, 0x32, 0x30, 0x18, 0x04,
+	0x20, 0x03, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x34, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x33, 0x38, 0x30, 0x35, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x38, 0x32, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x38,
+	0x32, 0x31, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x38, 0x32, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x38, 0x32, 0x32,
+	0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x38, 0x32,
+	0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x38, 0x32, 0x33, 0x18, 0x07,
+	0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x38, 0x32, 0x33, 0x12,
+	0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x38, 0x32, 0x34, 0x18, 0x08, 0x20, 0x01,
+	0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e,
+	0x45, 0x6e, 0x75, 0x6d, 0x33, 0x37, 0x38, 0x33, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x38, 0x32, 0x34, 0x22, 0xc0, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31,
+	0x32, 0x39, 0x30, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39,
+	0x30, 0x35, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x39, 0x30, 0x35, 0x12, 0x47, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39,
+	0x30, 0x36, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x35, 0x38,
+	0x37, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x30, 0x36, 0x12, 0x47, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x39, 0x30, 0x37, 0x18, 0x03, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x35, 0x39, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x32, 0x39, 0x30, 0x37, 0x22, 0x4e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x37, 0x33, 0x32, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x37, 0x33, 0x34, 0x35, 0x18, 0x01, 0x20, 0x02, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x37, 0x33, 0x34, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x37, 0x33, 0x34, 0x36, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x37, 0x33, 0x34, 0x36, 0x22, 0xd9, 0x0d, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x32, 0x33, 0x35, 0x36, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x33, 0x36, 0x38, 0x18, 0x79, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33,
+	0x37, 0x34, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x36, 0x38, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x36, 0x39, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x36, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x37, 0x30, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x37, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x32, 0x33, 0x37, 0x31, 0x18, 0x11, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x33, 0x37, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x33, 0x37, 0x32, 0x18, 0x03, 0x20, 0x02, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x33, 0x37, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33,
+	0x37, 0x33, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x33, 0x37, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x37, 0x34,
+	0x18, 0x08, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x37,
+	0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x37, 0x35, 0x18, 0x04,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x37, 0x35, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x37, 0x36, 0x18, 0x65, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x37, 0x36, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x37, 0x37, 0x18, 0x66, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x37, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x37, 0x38, 0x18, 0x67, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x37, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x32, 0x33, 0x37, 0x39, 0x18, 0x68, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x33, 0x37, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x33, 0x38, 0x30, 0x18, 0x71, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x33, 0x38, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33,
+	0x38, 0x31, 0x18, 0x72, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x33, 0x38, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x38, 0x32,
+	0x18, 0x73, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x38,
+	0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x38, 0x33, 0x18, 0x75,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x38, 0x33, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x38, 0x34, 0x18, 0x76, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x38, 0x34, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x38, 0x35, 0x18, 0x77, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x38, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x38, 0x36, 0x18, 0x69, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x38, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x32, 0x33, 0x38, 0x37, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x33, 0x38, 0x37, 0x12, 0x55, 0x0a, 0x0b, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x32, 0x33, 0x35, 0x37, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0a, 0x32, 0x33, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x32, 0x33, 0x35, 0x36, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x33, 0x35,
+	0x37, 0x52, 0x0b, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x33, 0x35, 0x37, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x38, 0x39, 0x18, 0x78, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x38, 0x39, 0x12, 0x55, 0x0a, 0x0b,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x33, 0x35, 0x38, 0x18, 0x6b, 0x20, 0x01, 0x28,
+	0x0a, 0x32, 0x33, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x33, 0x35, 0x36, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x32, 0x33, 0x35, 0x38, 0x52, 0x0b, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32,
+	0x33, 0x35, 0x38, 0x12, 0x55, 0x0a, 0x0b, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x33,
+	0x35, 0x39, 0x18, 0x28, 0x20, 0x03, 0x28, 0x0a, 0x32, 0x33, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x33, 0x35,
+	0x36, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x33, 0x35, 0x39, 0x52, 0x0b, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x33, 0x35, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x33, 0x39, 0x32, 0x18, 0x32, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x39, 0x32, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x33, 0x39, 0x33, 0x18, 0x3c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45,
+	0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x32, 0x33, 0x39, 0x33, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x33, 0x39, 0x34, 0x18, 0x46, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70,
+	0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x33, 0x39, 0x34, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x39,
+	0x35, 0x18, 0x50, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33,
+	0x39, 0x35, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x39, 0x36, 0x18,
+	0x5a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x39, 0x36,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x39, 0x37, 0x18, 0x64, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x39, 0x37, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x39, 0x38, 0x18, 0x7b, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x39, 0x38, 0x1a, 0xf5, 0x02, 0x0a,
+	0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x33, 0x35, 0x37, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x39, 0x39, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x33, 0x39, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x34, 0x30, 0x30, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x30, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x34, 0x30, 0x31, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x32, 0x34, 0x30, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x30, 0x32, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x34, 0x30, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x30,
+	0x33, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34,
+	0x30, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x30, 0x34, 0x18,
+	0x74, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x30, 0x34,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x30, 0x35, 0x18, 0x6a, 0x20,
+	0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x30, 0x35, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x30, 0x36, 0x18, 0x0e, 0x20, 0x02, 0x28,
+	0x0c, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x30, 0x36, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x30, 0x37, 0x18, 0x2d, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x30, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x34, 0x30, 0x38, 0x18, 0x70, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x30, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x32, 0x34, 0x30, 0x39, 0x18, 0x7a, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x32, 0x34, 0x30, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x34, 0x31, 0x30, 0x18, 0x7c, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x34, 0x31, 0x30, 0x1a, 0x0d, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32,
+	0x33, 0x35, 0x38, 0x1a, 0x0d, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x33,
+	0x35, 0x39, 0x22, 0x18, 0x0a, 0x08, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x2a, 0x08,
+	0x08, 0x04, 0x10, 0xff, 0xff, 0xff, 0xff, 0x07, 0x3a, 0x02, 0x08, 0x01, 0x22, 0x60, 0x0a, 0x0a,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x39, 0x37, 0x31, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x39, 0x37, 0x32, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x39, 0x37, 0x32, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39,
+	0x37, 0x33, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39,
+	0x37, 0x33, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x37, 0x34, 0x18, 0x03,
+	0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x39, 0x37, 0x34, 0x42, 0x23,
+	0x0a, 0x1e, 0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0xf8, 0x01, 0x01,
+}
+
+var (
+	file_datasets_google_message4_benchmark_message4_proto_rawDescOnce sync.Once
+	file_datasets_google_message4_benchmark_message4_proto_rawDescData = file_datasets_google_message4_benchmark_message4_proto_rawDesc
+)
+
+func file_datasets_google_message4_benchmark_message4_proto_rawDescGZIP() []byte {
+	file_datasets_google_message4_benchmark_message4_proto_rawDescOnce.Do(func() {
+		file_datasets_google_message4_benchmark_message4_proto_rawDescData = protoimpl.X.CompressGZIP(file_datasets_google_message4_benchmark_message4_proto_rawDescData)
+	})
+	return file_datasets_google_message4_benchmark_message4_proto_rawDescData
+}
+
+var file_datasets_google_message4_benchmark_message4_proto_msgTypes = make([]protoimpl.MessageInfo, 45)
+var file_datasets_google_message4_benchmark_message4_proto_goTypes = []interface{}{
+	(*GoogleMessage4)(nil),          // 0: benchmarks.google_message4.GoogleMessage4
+	(*Message37489)(nil),            // 1: benchmarks.google_message4.Message37489
+	(*Message7319)(nil),             // 2: benchmarks.google_message4.Message7319
+	(*Message12717)(nil),            // 3: benchmarks.google_message4.Message12717
+	(*Message37331)(nil),            // 4: benchmarks.google_message4.Message37331
+	(*Message8815)(nil),             // 5: benchmarks.google_message4.Message8815
+	(*Message7330)(nil),             // 6: benchmarks.google_message4.Message7330
+	(*Message12960)(nil),            // 7: benchmarks.google_message4.Message12960
+	(*Message176)(nil),              // 8: benchmarks.google_message4.Message176
+	(*Message8817)(nil),             // 9: benchmarks.google_message4.Message8817
+	(*Message8835)(nil),             // 10: benchmarks.google_message4.Message8835
+	(*Message37333)(nil),            // 11: benchmarks.google_message4.Message37333
+	(*Message13000)(nil),            // 12: benchmarks.google_message4.Message13000
+	(*Message37335)(nil),            // 13: benchmarks.google_message4.Message37335
+	(*Message8848)(nil),             // 14: benchmarks.google_message4.Message8848
+	(*Message13035)(nil),            // 15: benchmarks.google_message4.Message13035
+	(*Message8856)(nil),             // 16: benchmarks.google_message4.Message8856
+	(*Message12908)(nil),            // 17: benchmarks.google_message4.Message12908
+	(*Message12910)(nil),            // 18: benchmarks.google_message4.Message12910
+	(*Message37327)(nil),            // 19: benchmarks.google_message4.Message37327
+	(*Message37329)(nil),            // 20: benchmarks.google_message4.Message37329
+	(*Message2517)(nil),             // 21: benchmarks.google_message4.Message2517
+	(*Message12748)(nil),            // 22: benchmarks.google_message4.Message12748
+	(*Message12687)(nil),            // 23: benchmarks.google_message4.Message12687
+	(*Message11948)(nil),            // 24: benchmarks.google_message4.Message11948
+	(*Message11976)(nil),            // 25: benchmarks.google_message4.Message11976
+	(*Message7320)(nil),             // 26: benchmarks.google_message4.Message7320
+	(*Message3069)(nil),             // 27: benchmarks.google_message4.Message3069
+	(*Message12948)(nil),            // 28: benchmarks.google_message4.Message12948
+	(*Message8768)(nil),             // 29: benchmarks.google_message4.Message8768
+	(*Message12979)(nil),            // 30: benchmarks.google_message4.Message12979
+	(*Message37173)(nil),            // 31: benchmarks.google_message4.Message37173
+	(*Message12799)(nil),            // 32: benchmarks.google_message4.Message12799
+	(*Message12870)(nil),            // 33: benchmarks.google_message4.Message12870
+	(*Message3804)(nil),             // 34: benchmarks.google_message4.Message3804
+	(*Message12903)(nil),            // 35: benchmarks.google_message4.Message12903
+	(*Message37326)(nil),            // 36: benchmarks.google_message4.Message37326
+	(*Message2356)(nil),             // 37: benchmarks.google_message4.Message2356
+	(*Message0)(nil),                // 38: benchmarks.google_message4.Message0
+	(*Message971)(nil),              // 39: benchmarks.google_message4.Message971
+	(*Message176_Message178)(nil),   // 40: benchmarks.google_message4.Message176.Message178
+	(*Message3069_Message3070)(nil), // 41: benchmarks.google_message4.Message3069.Message3070
+	(*Message2356_Message2357)(nil), // 42: benchmarks.google_message4.Message2356.Message2357
+	(*Message2356_Message2358)(nil), // 43: benchmarks.google_message4.Message2356.Message2358
+	(*Message2356_Message2359)(nil), // 44: benchmarks.google_message4.Message2356.Message2359
+	(*UnusedEmptyMessage)(nil),      // 45: benchmarks.google_message4.UnusedEmptyMessage
+	(*Message11947)(nil),            // 46: benchmarks.google_message4.Message11947
+	(UnusedEnum)(0),                 // 47: benchmarks.google_message4.UnusedEnum
+	(*Message12818)(nil),            // 48: benchmarks.google_message4.Message12818
+	(*Message2463)(nil),             // 49: benchmarks.google_message4.Message2463
+	(Enum12735)(0),                  // 50: benchmarks.google_message4.Enum12735
+	(*Message12686)(nil),            // 51: benchmarks.google_message4.Message12686
+	(*Message11949)(nil),            // 52: benchmarks.google_message4.Message11949
+	(*Message11975)(nil),            // 53: benchmarks.google_message4.Message11975
+	(*Message7287)(nil),             // 54: benchmarks.google_message4.Message7287
+	(*Message3061)(nil),             // 55: benchmarks.google_message4.Message3061
+	(*Message12949)(nil),            // 56: benchmarks.google_message4.Message12949
+	(*Message8572)(nil),             // 57: benchmarks.google_message4.Message8572
+	(*Message8774)(nil),             // 58: benchmarks.google_message4.Message8774
+	(*Message12776)(nil),            // 59: benchmarks.google_message4.Message12776
+	(*Message12798)(nil),            // 60: benchmarks.google_message4.Message12798
+	(*Message12797)(nil),            // 61: benchmarks.google_message4.Message12797
+	(*Message12825)(nil),            // 62: benchmarks.google_message4.Message12825
+	(Enum12871)(0),                  // 63: benchmarks.google_message4.Enum12871
+	(Enum3805)(0),                   // 64: benchmarks.google_message4.Enum3805
+	(Enum3783)(0),                   // 65: benchmarks.google_message4.Enum3783
+	(*Message8587)(nil),             // 66: benchmarks.google_message4.Message8587
+	(*Message8590)(nil),             // 67: benchmarks.google_message4.Message8590
+	(*Message1374)(nil),             // 68: benchmarks.google_message4.Message1374
+	(Enum3071)(0),                   // 69: benchmarks.google_message4.Enum3071
+}
+var file_datasets_google_message4_benchmark_message4_proto_depIdxs = []int32{
+	45,  // 0: benchmarks.google_message4.GoogleMessage4.field37504:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 1: benchmarks.google_message4.GoogleMessage4.field37505:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 2: benchmarks.google_message4.GoogleMessage4.field37506:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 3: benchmarks.google_message4.GoogleMessage4.field37507:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	1,   // 4: benchmarks.google_message4.GoogleMessage4.field37508:type_name -> benchmarks.google_message4.Message37489
+	45,  // 5: benchmarks.google_message4.GoogleMessage4.field37509:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 6: benchmarks.google_message4.GoogleMessage4.field37510:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 7: benchmarks.google_message4.GoogleMessage4.field37511:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 8: benchmarks.google_message4.GoogleMessage4.field37512:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 9: benchmarks.google_message4.GoogleMessage4.field37513:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 10: benchmarks.google_message4.GoogleMessage4.field37514:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 11: benchmarks.google_message4.GoogleMessage4.field37515:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 12: benchmarks.google_message4.GoogleMessage4.field37516:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 13: benchmarks.google_message4.GoogleMessage4.field37517:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 14: benchmarks.google_message4.GoogleMessage4.field37518:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	21,  // 15: benchmarks.google_message4.Message37489.field37534:type_name -> benchmarks.google_message4.Message2517
+	6,   // 16: benchmarks.google_message4.Message37489.field37535:type_name -> benchmarks.google_message4.Message7330
+	5,   // 17: benchmarks.google_message4.Message37489.field37536:type_name -> benchmarks.google_message4.Message8815
+	9,   // 18: benchmarks.google_message4.Message37489.field37537:type_name -> benchmarks.google_message4.Message8817
+	10,  // 19: benchmarks.google_message4.Message37489.field37538:type_name -> benchmarks.google_message4.Message8835
+	14,  // 20: benchmarks.google_message4.Message37489.field37539:type_name -> benchmarks.google_message4.Message8848
+	16,  // 21: benchmarks.google_message4.Message37489.field37540:type_name -> benchmarks.google_message4.Message8856
+	3,   // 22: benchmarks.google_message4.Message37489.field37541:type_name -> benchmarks.google_message4.Message12717
+	22,  // 23: benchmarks.google_message4.Message37489.field37542:type_name -> benchmarks.google_message4.Message12748
+	2,   // 24: benchmarks.google_message4.Message37489.field37543:type_name -> benchmarks.google_message4.Message7319
+	17,  // 25: benchmarks.google_message4.Message37489.field37544:type_name -> benchmarks.google_message4.Message12908
+	18,  // 26: benchmarks.google_message4.Message37489.field37545:type_name -> benchmarks.google_message4.Message12910
+	7,   // 27: benchmarks.google_message4.Message37489.field37546:type_name -> benchmarks.google_message4.Message12960
+	8,   // 28: benchmarks.google_message4.Message37489.field37547:type_name -> benchmarks.google_message4.Message176
+	12,  // 29: benchmarks.google_message4.Message37489.field37548:type_name -> benchmarks.google_message4.Message13000
+	15,  // 30: benchmarks.google_message4.Message37489.field37549:type_name -> benchmarks.google_message4.Message13035
+	4,   // 31: benchmarks.google_message4.Message37489.field37550:type_name -> benchmarks.google_message4.Message37331
+	20,  // 32: benchmarks.google_message4.Message37489.field37551:type_name -> benchmarks.google_message4.Message37329
+	19,  // 33: benchmarks.google_message4.Message37489.field37552:type_name -> benchmarks.google_message4.Message37327
+	11,  // 34: benchmarks.google_message4.Message37489.field37553:type_name -> benchmarks.google_message4.Message37333
+	13,  // 35: benchmarks.google_message4.Message37489.field37554:type_name -> benchmarks.google_message4.Message37335
+	45,  // 36: benchmarks.google_message4.Message7319.field7321:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 37: benchmarks.google_message4.Message7319.field7322:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 38: benchmarks.google_message4.Message12717.field12719:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	25,  // 39: benchmarks.google_message4.Message12717.field12722:type_name -> benchmarks.google_message4.Message11976
+	24,  // 40: benchmarks.google_message4.Message12717.field12723:type_name -> benchmarks.google_message4.Message11948
+	46,  // 41: benchmarks.google_message4.Message12717.field12724:type_name -> benchmarks.google_message4.Message11947
+	23,  // 42: benchmarks.google_message4.Message12717.field12725:type_name -> benchmarks.google_message4.Message12687
+	24,  // 43: benchmarks.google_message4.Message12717.field12726:type_name -> benchmarks.google_message4.Message11948
+	45,  // 44: benchmarks.google_message4.Message37331.field37367:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	36,  // 45: benchmarks.google_message4.Message37331.field37368:type_name -> benchmarks.google_message4.Message37326
+	45,  // 46: benchmarks.google_message4.Message8815.field8819:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	29,  // 47: benchmarks.google_message4.Message8815.field8820:type_name -> benchmarks.google_message4.Message8768
+	45,  // 48: benchmarks.google_message4.Message7330.field7332:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	27,  // 49: benchmarks.google_message4.Message7330.field7333:type_name -> benchmarks.google_message4.Message3069
+	26,  // 50: benchmarks.google_message4.Message7330.field7334:type_name -> benchmarks.google_message4.Message7320
+	45,  // 51: benchmarks.google_message4.Message7330.field7335:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 52: benchmarks.google_message4.Message12960.field12962:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	28,  // 53: benchmarks.google_message4.Message12960.field12963:type_name -> benchmarks.google_message4.Message12948
+	45,  // 54: benchmarks.google_message4.Message176.field424:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 55: benchmarks.google_message4.Message176.field440:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 56: benchmarks.google_message4.Message176.field450:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 57: benchmarks.google_message4.Message176.field451:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	47,  // 58: benchmarks.google_message4.Message176.field452:type_name -> benchmarks.google_message4.UnusedEnum
+	47,  // 59: benchmarks.google_message4.Message176.field455:type_name -> benchmarks.google_message4.UnusedEnum
+	47,  // 60: benchmarks.google_message4.Message176.field456:type_name -> benchmarks.google_message4.UnusedEnum
+	40,  // 61: benchmarks.google_message4.Message176.message178:type_name -> benchmarks.google_message4.Message176.Message178
+	45,  // 62: benchmarks.google_message4.Message176.field462:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 63: benchmarks.google_message4.Message176.field463:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	47,  // 64: benchmarks.google_message4.Message176.field464:type_name -> benchmarks.google_message4.UnusedEnum
+	45,  // 65: benchmarks.google_message4.Message176.field466:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 66: benchmarks.google_message4.Message8817.field8825:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	29,  // 67: benchmarks.google_message4.Message8817.field8826:type_name -> benchmarks.google_message4.Message8768
+	45,  // 68: benchmarks.google_message4.Message8835.field8837:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	47,  // 69: benchmarks.google_message4.Message8835.field8839:type_name -> benchmarks.google_message4.UnusedEnum
+	45,  // 70: benchmarks.google_message4.Message37333.field37372:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	36,  // 71: benchmarks.google_message4.Message37333.field37373:type_name -> benchmarks.google_message4.Message37326
+	30,  // 72: benchmarks.google_message4.Message13000.field13016:type_name -> benchmarks.google_message4.Message12979
+	45,  // 73: benchmarks.google_message4.Message37335.field37376:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	36,  // 74: benchmarks.google_message4.Message37335.field37377:type_name -> benchmarks.google_message4.Message37326
+	31,  // 75: benchmarks.google_message4.Message37335.field37378:type_name -> benchmarks.google_message4.Message37173
+	45,  // 76: benchmarks.google_message4.Message8848.field8850:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 77: benchmarks.google_message4.Message8856.field8858:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 78: benchmarks.google_message4.Message12908.field12912:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	32,  // 79: benchmarks.google_message4.Message12908.field12914:type_name -> benchmarks.google_message4.Message12799
+	34,  // 80: benchmarks.google_message4.Message12908.field12916:type_name -> benchmarks.google_message4.Message3804
+	33,  // 81: benchmarks.google_message4.Message12908.field12917:type_name -> benchmarks.google_message4.Message12870
+	45,  // 82: benchmarks.google_message4.Message12910.field12920:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	48,  // 83: benchmarks.google_message4.Message12910.field12921:type_name -> benchmarks.google_message4.Message12818
+	35,  // 84: benchmarks.google_message4.Message12910.field12922:type_name -> benchmarks.google_message4.Message12903
+	45,  // 85: benchmarks.google_message4.Message37327.field37347:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	36,  // 86: benchmarks.google_message4.Message37327.field37348:type_name -> benchmarks.google_message4.Message37326
+	45,  // 87: benchmarks.google_message4.Message37327.field37354:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 88: benchmarks.google_message4.Message37329.field37359:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	36,  // 89: benchmarks.google_message4.Message37329.field37360:type_name -> benchmarks.google_message4.Message37326
+	45,  // 90: benchmarks.google_message4.Message2517.field2519:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	37,  // 91: benchmarks.google_message4.Message2517.field2520:type_name -> benchmarks.google_message4.Message2356
+	38,  // 92: benchmarks.google_message4.Message2517.field2521:type_name -> benchmarks.google_message4.Message0
+	49,  // 93: benchmarks.google_message4.Message2517.field2522:type_name -> benchmarks.google_message4.Message2463
+	39,  // 94: benchmarks.google_message4.Message2517.field2523:type_name -> benchmarks.google_message4.Message971
+	45,  // 95: benchmarks.google_message4.Message12748.field12754:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	50,  // 96: benchmarks.google_message4.Message12748.field12757:type_name -> benchmarks.google_message4.Enum12735
+	51,  // 97: benchmarks.google_message4.Message12687.field12701:type_name -> benchmarks.google_message4.Message12686
+	52,  // 98: benchmarks.google_message4.Message11948.field11955:type_name -> benchmarks.google_message4.Message11949
+	53,  // 99: benchmarks.google_message4.Message11976.field12002:type_name -> benchmarks.google_message4.Message11975
+	45,  // 100: benchmarks.google_message4.Message7320.field7323:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	54,  // 101: benchmarks.google_message4.Message7320.field7324:type_name -> benchmarks.google_message4.Message7287
+	55,  // 102: benchmarks.google_message4.Message3069.field3374:type_name -> benchmarks.google_message4.Message3061
+	41,  // 103: benchmarks.google_message4.Message3069.message3070:type_name -> benchmarks.google_message4.Message3069.Message3070
+	56,  // 104: benchmarks.google_message4.Message12948.field12958:type_name -> benchmarks.google_message4.Message12949
+	57,  // 105: benchmarks.google_message4.Message8768.field8783:type_name -> benchmarks.google_message4.Message8572
+	58,  // 106: benchmarks.google_message4.Message8768.field8785:type_name -> benchmarks.google_message4.Message8774
+	45,  // 107: benchmarks.google_message4.Message8768.field8787:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 108: benchmarks.google_message4.Message12979.field12983:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 109: benchmarks.google_message4.Message12979.field12987:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	47,  // 110: benchmarks.google_message4.Message37173.field37254:type_name -> benchmarks.google_message4.UnusedEnum
+	45,  // 111: benchmarks.google_message4.Message37173.field37270:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 112: benchmarks.google_message4.Message37173.field37271:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 113: benchmarks.google_message4.Message37173.field37272:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 114: benchmarks.google_message4.Message37173.field37273:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 115: benchmarks.google_message4.Message37173.field37274:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	59,  // 116: benchmarks.google_message4.Message12799.field12811:type_name -> benchmarks.google_message4.Message12776
+	60,  // 117: benchmarks.google_message4.Message12799.field12813:type_name -> benchmarks.google_message4.Message12798
+	61,  // 118: benchmarks.google_message4.Message12799.field12816:type_name -> benchmarks.google_message4.Message12797
+	33,  // 119: benchmarks.google_message4.Message12870.field12888:type_name -> benchmarks.google_message4.Message12870
+	62,  // 120: benchmarks.google_message4.Message12870.field12894:type_name -> benchmarks.google_message4.Message12825
+	63,  // 121: benchmarks.google_message4.Message12870.field12897:type_name -> benchmarks.google_message4.Enum12871
+	64,  // 122: benchmarks.google_message4.Message3804.field3820:type_name -> benchmarks.google_message4.Enum3805
+	65,  // 123: benchmarks.google_message4.Message3804.field3824:type_name -> benchmarks.google_message4.Enum3783
+	66,  // 124: benchmarks.google_message4.Message12903.field12906:type_name -> benchmarks.google_message4.Message8587
+	67,  // 125: benchmarks.google_message4.Message12903.field12907:type_name -> benchmarks.google_message4.Message8590
+	68,  // 126: benchmarks.google_message4.Message2356.field2368:type_name -> benchmarks.google_message4.Message1374
+	42,  // 127: benchmarks.google_message4.Message2356.message2357:type_name -> benchmarks.google_message4.Message2356.Message2357
+	43,  // 128: benchmarks.google_message4.Message2356.message2358:type_name -> benchmarks.google_message4.Message2356.Message2358
+	44,  // 129: benchmarks.google_message4.Message2356.message2359:type_name -> benchmarks.google_message4.Message2356.Message2359
+	45,  // 130: benchmarks.google_message4.Message2356.field2393:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 131: benchmarks.google_message4.Message2356.field2394:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 132: benchmarks.google_message4.Message2356.field2395:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 133: benchmarks.google_message4.Message2356.field2396:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	69,  // 134: benchmarks.google_message4.Message3069.Message3070.field3378:type_name -> benchmarks.google_message4.Enum3071
+	135, // [135:135] is the sub-list for method output_type
+	135, // [135:135] is the sub-list for method input_type
+	135, // [135:135] is the sub-list for extension type_name
+	135, // [135:135] is the sub-list for extension extendee
+	0,   // [0:135] is the sub-list for field type_name
+}
+
+func init() { file_datasets_google_message4_benchmark_message4_proto_init() }
+func file_datasets_google_message4_benchmark_message4_proto_init() {
+	if File_datasets_google_message4_benchmark_message4_proto != nil {
+		return
+	}
+	file_datasets_google_message4_benchmark_message4_1_proto_init()
+	file_datasets_google_message4_benchmark_message4_2_proto_init()
+	file_datasets_google_message4_benchmark_message4_3_proto_init()
+	if !protoimpl.UnsafeEnabled {
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GoogleMessage4); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message37489); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message7319); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12717); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message37331); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8815); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message7330); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12960); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message176); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8817); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8835); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message37333); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message13000); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message37335); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8848); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message13035); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8856); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12908); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12910); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message37327); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message37329); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message2517); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12748); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12687); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message11948); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message11976); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message7320); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message3069); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12948); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8768); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12979); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message37173); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12799); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12870); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message3804); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[35].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12903); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[36].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message37326); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[37].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message2356); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[38].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message0); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[39].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message971); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[40].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message176_Message178); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[41].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message3069_Message3070); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[42].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message2356_Message2357); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[43].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message2356_Message2358); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_proto_msgTypes[44].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message2356_Message2359); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_datasets_google_message4_benchmark_message4_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   45,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_datasets_google_message4_benchmark_message4_proto_goTypes,
+		DependencyIndexes: file_datasets_google_message4_benchmark_message4_proto_depIdxs,
+		MessageInfos:      file_datasets_google_message4_benchmark_message4_proto_msgTypes,
+	}.Build()
+	File_datasets_google_message4_benchmark_message4_proto = out.File
+	file_datasets_google_message4_benchmark_message4_proto_rawDesc = nil
+	file_datasets_google_message4_benchmark_message4_proto_goTypes = nil
+	file_datasets_google_message4_benchmark_message4_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message4/benchmark_message4_1.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message4/benchmark_message4_1.pb.go
new file mode 100644
index 000000000..c57dd6872
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message4/benchmark_message4_1.pb.go
@@ -0,0 +1,6291 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// LINT: ALLOW_GROUPS
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: datasets/google_message4/benchmark_message4_1.proto
+
+package google_message4
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoiface "google.golang.org/protobuf/runtime/protoiface"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type Message2463 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field2498 []*Message2462 `protobuf:"bytes,1,rep,name=field2498" json:"field2498,omitempty"`
+}
+
+func (x *Message2463) Reset() {
+	*x = Message2463{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message2463) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message2463) ProtoMessage() {}
+
+func (x *Message2463) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message2463.ProtoReflect.Descriptor instead.
+func (*Message2463) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Message2463) GetField2498() []*Message2462 {
+	if x != nil {
+		return x.Field2498
+	}
+	return nil
+}
+
+type Message12686 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12699 *string       `protobuf:"bytes,1,opt,name=field12699" json:"field12699,omitempty"`
+	Field12700 *Message12685 `protobuf:"bytes,2,opt,name=field12700" json:"field12700,omitempty"`
+}
+
+func (x *Message12686) Reset() {
+	*x = Message12686{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12686) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12686) ProtoMessage() {}
+
+func (x *Message12686) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12686.ProtoReflect.Descriptor instead.
+func (*Message12686) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *Message12686) GetField12699() string {
+	if x != nil && x.Field12699 != nil {
+		return *x.Field12699
+	}
+	return ""
+}
+
+func (x *Message12686) GetField12700() *Message12685 {
+	if x != nil {
+		return x.Field12700
+	}
+	return nil
+}
+
+type Message11949 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message11949) Reset() {
+	*x = Message11949{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message11949) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message11949) ProtoMessage() {}
+
+func (x *Message11949) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message11949.ProtoReflect.Descriptor instead.
+func (*Message11949) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{2}
+}
+
+type Message11975 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field11992 *string         `protobuf:"bytes,1,opt,name=field11992" json:"field11992,omitempty"`
+	Field11993 *int32          `protobuf:"varint,2,opt,name=field11993" json:"field11993,omitempty"`
+	Field11994 []*Message10320 `protobuf:"bytes,3,rep,name=field11994" json:"field11994,omitempty"`
+	Field11995 *Message11947   `protobuf:"bytes,4,opt,name=field11995" json:"field11995,omitempty"`
+	Field11996 *Message11920   `protobuf:"bytes,5,opt,name=field11996" json:"field11996,omitempty"`
+	Field11997 *bool           `protobuf:"varint,6,opt,name=field11997" json:"field11997,omitempty"`
+	Field11998 []string        `protobuf:"bytes,7,rep,name=field11998" json:"field11998,omitempty"`
+	Field11999 *float32        `protobuf:"fixed32,8,opt,name=field11999" json:"field11999,omitempty"`
+	Field12000 []UnusedEnum    `protobuf:"varint,9,rep,name=field12000,enum=benchmarks.google_message4.UnusedEnum" json:"field12000,omitempty"`
+	Field12001 *int32          `protobuf:"varint,11,opt,name=field12001" json:"field12001,omitempty"`
+}
+
+func (x *Message11975) Reset() {
+	*x = Message11975{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message11975) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message11975) ProtoMessage() {}
+
+func (x *Message11975) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message11975.ProtoReflect.Descriptor instead.
+func (*Message11975) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *Message11975) GetField11992() string {
+	if x != nil && x.Field11992 != nil {
+		return *x.Field11992
+	}
+	return ""
+}
+
+func (x *Message11975) GetField11993() int32 {
+	if x != nil && x.Field11993 != nil {
+		return *x.Field11993
+	}
+	return 0
+}
+
+func (x *Message11975) GetField11994() []*Message10320 {
+	if x != nil {
+		return x.Field11994
+	}
+	return nil
+}
+
+func (x *Message11975) GetField11995() *Message11947 {
+	if x != nil {
+		return x.Field11995
+	}
+	return nil
+}
+
+func (x *Message11975) GetField11996() *Message11920 {
+	if x != nil {
+		return x.Field11996
+	}
+	return nil
+}
+
+func (x *Message11975) GetField11997() bool {
+	if x != nil && x.Field11997 != nil {
+		return *x.Field11997
+	}
+	return false
+}
+
+func (x *Message11975) GetField11998() []string {
+	if x != nil {
+		return x.Field11998
+	}
+	return nil
+}
+
+func (x *Message11975) GetField11999() float32 {
+	if x != nil && x.Field11999 != nil {
+		return *x.Field11999
+	}
+	return 0
+}
+
+func (x *Message11975) GetField12000() []UnusedEnum {
+	if x != nil {
+		return x.Field12000
+	}
+	return nil
+}
+
+func (x *Message11975) GetField12001() int32 {
+	if x != nil && x.Field12001 != nil {
+		return *x.Field12001
+	}
+	return 0
+}
+
+type Message7287 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field7311 *Message6133        `protobuf:"bytes,1,opt,name=field7311" json:"field7311,omitempty"`
+	Field7312 *UnusedEmptyMessage `protobuf:"bytes,8,opt,name=field7312" json:"field7312,omitempty"`
+	Field7313 *string             `protobuf:"bytes,3,opt,name=field7313" json:"field7313,omitempty"`
+	Field7314 *Message6643        `protobuf:"bytes,4,opt,name=field7314" json:"field7314,omitempty"`
+	Field7315 *Enum7288           `protobuf:"varint,5,opt,name=field7315,enum=benchmarks.google_message4.Enum7288" json:"field7315,omitempty"`
+	Field7316 []byte              `protobuf:"bytes,6,opt,name=field7316" json:"field7316,omitempty"`
+	Field7317 *UnusedEmptyMessage `protobuf:"bytes,7,opt,name=field7317" json:"field7317,omitempty"`
+	Field7318 *UnusedEmptyMessage `protobuf:"bytes,9,opt,name=field7318" json:"field7318,omitempty"`
+}
+
+func (x *Message7287) Reset() {
+	*x = Message7287{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message7287) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message7287) ProtoMessage() {}
+
+func (x *Message7287) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message7287.ProtoReflect.Descriptor instead.
+func (*Message7287) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *Message7287) GetField7311() *Message6133 {
+	if x != nil {
+		return x.Field7311
+	}
+	return nil
+}
+
+func (x *Message7287) GetField7312() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field7312
+	}
+	return nil
+}
+
+func (x *Message7287) GetField7313() string {
+	if x != nil && x.Field7313 != nil {
+		return *x.Field7313
+	}
+	return ""
+}
+
+func (x *Message7287) GetField7314() *Message6643 {
+	if x != nil {
+		return x.Field7314
+	}
+	return nil
+}
+
+func (x *Message7287) GetField7315() Enum7288 {
+	if x != nil && x.Field7315 != nil {
+		return *x.Field7315
+	}
+	return Enum7288_ENUM_VALUE7289
+}
+
+func (x *Message7287) GetField7316() []byte {
+	if x != nil {
+		return x.Field7316
+	}
+	return nil
+}
+
+func (x *Message7287) GetField7317() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field7317
+	}
+	return nil
+}
+
+func (x *Message7287) GetField7318() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field7318
+	}
+	return nil
+}
+
+type Message3061 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field3286   *string                    `protobuf:"bytes,2,opt,name=field3286" json:"field3286,omitempty"`
+	Field3287   *int32                     `protobuf:"varint,77,opt,name=field3287" json:"field3287,omitempty"`
+	Field3288   *string                    `protobuf:"bytes,49,opt,name=field3288" json:"field3288,omitempty"`
+	Field3289   *Message3046               `protobuf:"bytes,3,req,name=field3289" json:"field3289,omitempty"`
+	Field3290   *Message3046               `protobuf:"bytes,58,opt,name=field3290" json:"field3290,omitempty"`
+	Message3062 *Message3061_Message3062   `protobuf:"group,4,opt,name=Message3062,json=message3062" json:"message3062,omitempty"`
+	Field3292   *Message3060               `protobuf:"bytes,104,opt,name=field3292" json:"field3292,omitempty"`
+	Field3293   *int64                     `protobuf:"varint,32,opt,name=field3293" json:"field3293,omitempty"`
+	Field3294   *int32                     `protobuf:"varint,41,opt,name=field3294" json:"field3294,omitempty"`
+	Message3063 *Message3061_Message3063   `protobuf:"group,13,opt,name=Message3063,json=message3063" json:"message3063,omitempty"`
+	Field3296   *Enum2834                  `protobuf:"varint,94,opt,name=field3296,enum=benchmarks.google_message4.Enum2834" json:"field3296,omitempty"`
+	Field3297   *bool                      `protobuf:"varint,25,opt,name=field3297" json:"field3297,omitempty"`
+	Field3298   *bool                      `protobuf:"varint,50,opt,name=field3298" json:"field3298,omitempty"`
+	Field3299   *string                    `protobuf:"bytes,89,opt,name=field3299" json:"field3299,omitempty"`
+	Field3300   *string                    `protobuf:"bytes,91,opt,name=field3300" json:"field3300,omitempty"`
+	Field3301   *string                    `protobuf:"bytes,105,opt,name=field3301" json:"field3301,omitempty"`
+	Field3302   *Message3050               `protobuf:"bytes,53,opt,name=field3302" json:"field3302,omitempty"`
+	Field3303   *uint64                    `protobuf:"fixed64,51,opt,name=field3303" json:"field3303,omitempty"`
+	Field3304   *uint64                    `protobuf:"fixed64,106,opt,name=field3304" json:"field3304,omitempty"`
+	Field3305   *int32                     `protobuf:"varint,60,opt,name=field3305" json:"field3305,omitempty"`
+	Field3306   *string                    `protobuf:"bytes,44,opt,name=field3306" json:"field3306,omitempty"`
+	Field3307   []byte                     `protobuf:"bytes,81,opt,name=field3307" json:"field3307,omitempty"`
+	Field3308   *string                    `protobuf:"bytes,70,opt,name=field3308" json:"field3308,omitempty"`
+	Field3309   []byte                     `protobuf:"bytes,45,opt,name=field3309" json:"field3309,omitempty"`
+	Field3310   *Enum2806                  `protobuf:"varint,71,opt,name=field3310,enum=benchmarks.google_message4.Enum2806" json:"field3310,omitempty"`
+	Field3311   *int32                     `protobuf:"varint,72,opt,name=field3311" json:"field3311,omitempty"`
+	Field3312   []byte                     `protobuf:"bytes,78,opt,name=field3312" json:"field3312,omitempty"`
+	Field3313   *int32                     `protobuf:"varint,20,opt,name=field3313" json:"field3313,omitempty"`
+	Message3064 []*Message3061_Message3064 `protobuf:"group,8,rep,name=Message3064,json=message3064" json:"message3064,omitempty"`
+	Field3315   *UnusedEmptyMessage        `protobuf:"bytes,39,opt,name=field3315" json:"field3315,omitempty"`
+	Field3316   *int32                     `protobuf:"varint,76,opt,name=field3316" json:"field3316,omitempty"`
+	Message3065 *Message3061_Message3065   `protobuf:"group,63,opt,name=Message3065,json=message3065" json:"message3065,omitempty"`
+	Field3318   *Enum2806                  `protobuf:"varint,54,opt,name=field3318,enum=benchmarks.google_message4.Enum2806" json:"field3318,omitempty"`
+	Field3319   *int32                     `protobuf:"varint,46,opt,name=field3319" json:"field3319,omitempty"`
+	Field3320   []string                   `protobuf:"bytes,24,rep,name=field3320" json:"field3320,omitempty"`
+	Field3321   *uint32                    `protobuf:"fixed32,38,opt,name=field3321" json:"field3321,omitempty"`
+	Field3322   []byte                     `protobuf:"bytes,99,opt,name=field3322" json:"field3322,omitempty"`
+	Field3323   *uint64                    `protobuf:"fixed64,1,opt,name=field3323" json:"field3323,omitempty"`
+	Field3324   *uint64                    `protobuf:"fixed64,97,opt,name=field3324" json:"field3324,omitempty"`
+	Field3325   []*Message3040             `protobuf:"bytes,16,rep,name=field3325" json:"field3325,omitempty"`
+	Field3326   []*Message3041             `protobuf:"bytes,61,rep,name=field3326" json:"field3326,omitempty"`
+	Message3066 *Message3061_Message3066   `protobuf:"group,21,opt,name=Message3066,json=message3066" json:"message3066,omitempty"`
+	Field3328   *UnusedEmptyMessage        `protobuf:"bytes,47,opt,name=field3328" json:"field3328,omitempty"`
+	Field3329   *UnusedEmptyMessage        `protobuf:"bytes,48,opt,name=field3329" json:"field3329,omitempty"`
+	Field3330   *uint64                    `protobuf:"fixed64,40,opt,name=field3330" json:"field3330,omitempty"`
+	Field3331   *UnusedEmptyMessage        `protobuf:"bytes,86,opt,name=field3331" json:"field3331,omitempty"`
+	Field3332   *UnusedEmptyMessage        `protobuf:"bytes,59,opt,name=field3332" json:"field3332,omitempty"`
+	Field3333   *int32                     `protobuf:"varint,17,opt,name=field3333" json:"field3333,omitempty"`
+}
+
+func (x *Message3061) Reset() {
+	*x = Message3061{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[5]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message3061) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message3061) ProtoMessage() {}
+
+func (x *Message3061) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[5]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message3061.ProtoReflect.Descriptor instead.
+func (*Message3061) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *Message3061) GetField3286() string {
+	if x != nil && x.Field3286 != nil {
+		return *x.Field3286
+	}
+	return ""
+}
+
+func (x *Message3061) GetField3287() int32 {
+	if x != nil && x.Field3287 != nil {
+		return *x.Field3287
+	}
+	return 0
+}
+
+func (x *Message3061) GetField3288() string {
+	if x != nil && x.Field3288 != nil {
+		return *x.Field3288
+	}
+	return ""
+}
+
+func (x *Message3061) GetField3289() *Message3046 {
+	if x != nil {
+		return x.Field3289
+	}
+	return nil
+}
+
+func (x *Message3061) GetField3290() *Message3046 {
+	if x != nil {
+		return x.Field3290
+	}
+	return nil
+}
+
+func (x *Message3061) GetMessage3062() *Message3061_Message3062 {
+	if x != nil {
+		return x.Message3062
+	}
+	return nil
+}
+
+func (x *Message3061) GetField3292() *Message3060 {
+	if x != nil {
+		return x.Field3292
+	}
+	return nil
+}
+
+func (x *Message3061) GetField3293() int64 {
+	if x != nil && x.Field3293 != nil {
+		return *x.Field3293
+	}
+	return 0
+}
+
+func (x *Message3061) GetField3294() int32 {
+	if x != nil && x.Field3294 != nil {
+		return *x.Field3294
+	}
+	return 0
+}
+
+func (x *Message3061) GetMessage3063() *Message3061_Message3063 {
+	if x != nil {
+		return x.Message3063
+	}
+	return nil
+}
+
+func (x *Message3061) GetField3296() Enum2834 {
+	if x != nil && x.Field3296 != nil {
+		return *x.Field3296
+	}
+	return Enum2834_ENUM_VALUE2835
+}
+
+func (x *Message3061) GetField3297() bool {
+	if x != nil && x.Field3297 != nil {
+		return *x.Field3297
+	}
+	return false
+}
+
+func (x *Message3061) GetField3298() bool {
+	if x != nil && x.Field3298 != nil {
+		return *x.Field3298
+	}
+	return false
+}
+
+func (x *Message3061) GetField3299() string {
+	if x != nil && x.Field3299 != nil {
+		return *x.Field3299
+	}
+	return ""
+}
+
+func (x *Message3061) GetField3300() string {
+	if x != nil && x.Field3300 != nil {
+		return *x.Field3300
+	}
+	return ""
+}
+
+func (x *Message3061) GetField3301() string {
+	if x != nil && x.Field3301 != nil {
+		return *x.Field3301
+	}
+	return ""
+}
+
+func (x *Message3061) GetField3302() *Message3050 {
+	if x != nil {
+		return x.Field3302
+	}
+	return nil
+}
+
+func (x *Message3061) GetField3303() uint64 {
+	if x != nil && x.Field3303 != nil {
+		return *x.Field3303
+	}
+	return 0
+}
+
+func (x *Message3061) GetField3304() uint64 {
+	if x != nil && x.Field3304 != nil {
+		return *x.Field3304
+	}
+	return 0
+}
+
+func (x *Message3061) GetField3305() int32 {
+	if x != nil && x.Field3305 != nil {
+		return *x.Field3305
+	}
+	return 0
+}
+
+func (x *Message3061) GetField3306() string {
+	if x != nil && x.Field3306 != nil {
+		return *x.Field3306
+	}
+	return ""
+}
+
+func (x *Message3061) GetField3307() []byte {
+	if x != nil {
+		return x.Field3307
+	}
+	return nil
+}
+
+func (x *Message3061) GetField3308() string {
+	if x != nil && x.Field3308 != nil {
+		return *x.Field3308
+	}
+	return ""
+}
+
+func (x *Message3061) GetField3309() []byte {
+	if x != nil {
+		return x.Field3309
+	}
+	return nil
+}
+
+func (x *Message3061) GetField3310() Enum2806 {
+	if x != nil && x.Field3310 != nil {
+		return *x.Field3310
+	}
+	return Enum2806_ENUM_VALUE2807
+}
+
+func (x *Message3061) GetField3311() int32 {
+	if x != nil && x.Field3311 != nil {
+		return *x.Field3311
+	}
+	return 0
+}
+
+func (x *Message3061) GetField3312() []byte {
+	if x != nil {
+		return x.Field3312
+	}
+	return nil
+}
+
+func (x *Message3061) GetField3313() int32 {
+	if x != nil && x.Field3313 != nil {
+		return *x.Field3313
+	}
+	return 0
+}
+
+func (x *Message3061) GetMessage3064() []*Message3061_Message3064 {
+	if x != nil {
+		return x.Message3064
+	}
+	return nil
+}
+
+func (x *Message3061) GetField3315() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field3315
+	}
+	return nil
+}
+
+func (x *Message3061) GetField3316() int32 {
+	if x != nil && x.Field3316 != nil {
+		return *x.Field3316
+	}
+	return 0
+}
+
+func (x *Message3061) GetMessage3065() *Message3061_Message3065 {
+	if x != nil {
+		return x.Message3065
+	}
+	return nil
+}
+
+func (x *Message3061) GetField3318() Enum2806 {
+	if x != nil && x.Field3318 != nil {
+		return *x.Field3318
+	}
+	return Enum2806_ENUM_VALUE2807
+}
+
+func (x *Message3061) GetField3319() int32 {
+	if x != nil && x.Field3319 != nil {
+		return *x.Field3319
+	}
+	return 0
+}
+
+func (x *Message3061) GetField3320() []string {
+	if x != nil {
+		return x.Field3320
+	}
+	return nil
+}
+
+func (x *Message3061) GetField3321() uint32 {
+	if x != nil && x.Field3321 != nil {
+		return *x.Field3321
+	}
+	return 0
+}
+
+func (x *Message3061) GetField3322() []byte {
+	if x != nil {
+		return x.Field3322
+	}
+	return nil
+}
+
+func (x *Message3061) GetField3323() uint64 {
+	if x != nil && x.Field3323 != nil {
+		return *x.Field3323
+	}
+	return 0
+}
+
+func (x *Message3061) GetField3324() uint64 {
+	if x != nil && x.Field3324 != nil {
+		return *x.Field3324
+	}
+	return 0
+}
+
+func (x *Message3061) GetField3325() []*Message3040 {
+	if x != nil {
+		return x.Field3325
+	}
+	return nil
+}
+
+func (x *Message3061) GetField3326() []*Message3041 {
+	if x != nil {
+		return x.Field3326
+	}
+	return nil
+}
+
+func (x *Message3061) GetMessage3066() *Message3061_Message3066 {
+	if x != nil {
+		return x.Message3066
+	}
+	return nil
+}
+
+func (x *Message3061) GetField3328() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field3328
+	}
+	return nil
+}
+
+func (x *Message3061) GetField3329() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field3329
+	}
+	return nil
+}
+
+func (x *Message3061) GetField3330() uint64 {
+	if x != nil && x.Field3330 != nil {
+		return *x.Field3330
+	}
+	return 0
+}
+
+func (x *Message3061) GetField3331() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field3331
+	}
+	return nil
+}
+
+func (x *Message3061) GetField3332() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field3332
+	}
+	return nil
+}
+
+func (x *Message3061) GetField3333() int32 {
+	if x != nil && x.Field3333 != nil {
+		return *x.Field3333
+	}
+	return 0
+}
+
+type Message12949 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message12949) Reset() {
+	*x = Message12949{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[6]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12949) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12949) ProtoMessage() {}
+
+func (x *Message12949) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[6]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12949.ProtoReflect.Descriptor instead.
+func (*Message12949) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{6}
+}
+
+type Message8572 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field8647 []byte              `protobuf:"bytes,1,opt,name=field8647" json:"field8647,omitempty"`
+	Field8648 []byte              `protobuf:"bytes,3,opt,name=field8648" json:"field8648,omitempty"`
+	Field8649 *Message3886        `protobuf:"bytes,4,opt,name=field8649" json:"field8649,omitempty"`
+	Field8650 *Message3919        `protobuf:"bytes,57,opt,name=field8650" json:"field8650,omitempty"`
+	Field8651 *bool               `protobuf:"varint,5,opt,name=field8651" json:"field8651,omitempty"`
+	Field8652 *int32              `protobuf:"varint,6,opt,name=field8652" json:"field8652,omitempty"`
+	Field8653 *int32              `protobuf:"varint,49,opt,name=field8653" json:"field8653,omitempty"`
+	Field8654 *Message7905        `protobuf:"bytes,7,opt,name=field8654" json:"field8654,omitempty"`
+	Field8655 *int32              `protobuf:"varint,10,opt,name=field8655" json:"field8655,omitempty"`
+	Field8656 *UnusedEmptyMessage `protobuf:"bytes,11,opt,name=field8656" json:"field8656,omitempty"`
+	Field8657 *bool               `protobuf:"varint,35,opt,name=field8657" json:"field8657,omitempty"`
+	Field8658 []byte              `protobuf:"bytes,12,opt,name=field8658" json:"field8658,omitempty"`
+	Field8659 *string             `protobuf:"bytes,14,opt,name=field8659" json:"field8659,omitempty"`
+	Field8660 *UnusedEmptyMessage `protobuf:"bytes,13,opt,name=field8660" json:"field8660,omitempty"`
+	Field8661 []byte              `protobuf:"bytes,15,opt,name=field8661" json:"field8661,omitempty"`
+	Field8662 *UnusedEmptyMessage `protobuf:"bytes,17,opt,name=field8662" json:"field8662,omitempty"`
+	Field8663 *int32              `protobuf:"varint,18,opt,name=field8663" json:"field8663,omitempty"`
+	Field8664 *int32              `protobuf:"varint,19,opt,name=field8664" json:"field8664,omitempty"`
+	Field8665 *bool               `protobuf:"varint,20,opt,name=field8665" json:"field8665,omitempty"`
+	Field8666 *Enum3476           `protobuf:"varint,31,opt,name=field8666,enum=benchmarks.google_message4.Enum3476" json:"field8666,omitempty"`
+	Field8667 *bool               `protobuf:"varint,36,opt,name=field8667" json:"field8667,omitempty"`
+	Field8668 *UnusedEmptyMessage `protobuf:"bytes,39,opt,name=field8668" json:"field8668,omitempty"`
+	Field8669 []byte              `protobuf:"bytes,22,opt,name=field8669" json:"field8669,omitempty"`
+	Field8670 *int32              `protobuf:"varint,24,opt,name=field8670" json:"field8670,omitempty"`
+	Field8671 *Message3052        `protobuf:"bytes,25,opt,name=field8671" json:"field8671,omitempty"`
+	Field8672 []byte              `protobuf:"bytes,26,opt,name=field8672" json:"field8672,omitempty"`
+	Field8673 []byte              `protobuf:"bytes,28,opt,name=field8673" json:"field8673,omitempty"`
+	Field8674 *int32              `protobuf:"varint,29,opt,name=field8674" json:"field8674,omitempty"`
+	Field8675 []byte              `protobuf:"bytes,30,opt,name=field8675" json:"field8675,omitempty"`
+	Field8676 []byte              `protobuf:"bytes,32,opt,name=field8676" json:"field8676,omitempty"`
+	Field8677 *string             `protobuf:"bytes,33,opt,name=field8677" json:"field8677,omitempty"`
+	Field8678 *int32              `protobuf:"varint,34,opt,name=field8678" json:"field8678,omitempty"`
+	Field8679 *int32              `protobuf:"varint,37,opt,name=field8679" json:"field8679,omitempty"`
+	Field8680 *float64            `protobuf:"fixed64,38,opt,name=field8680" json:"field8680,omitempty"`
+	Field8681 *float64            `protobuf:"fixed64,42,opt,name=field8681" json:"field8681,omitempty"`
+	Field8682 *Message3922        `protobuf:"bytes,40,opt,name=field8682" json:"field8682,omitempty"`
+	Field8683 *UnusedEmptyMessage `protobuf:"bytes,43,opt,name=field8683" json:"field8683,omitempty"`
+	Field8684 *int64              `protobuf:"varint,44,opt,name=field8684" json:"field8684,omitempty"`
+	Field8685 *Message7929        `protobuf:"bytes,45,opt,name=field8685" json:"field8685,omitempty"`
+	Field8686 *uint64             `protobuf:"varint,46,opt,name=field8686" json:"field8686,omitempty"`
+	Field8687 *uint32             `protobuf:"varint,48,opt,name=field8687" json:"field8687,omitempty"`
+	Field8688 *Message7843        `protobuf:"bytes,47,opt,name=field8688" json:"field8688,omitempty"`
+	Field8689 *Message7864        `protobuf:"bytes,50,opt,name=field8689" json:"field8689,omitempty"`
+	Field8690 *UnusedEmptyMessage `protobuf:"bytes,52,opt,name=field8690" json:"field8690,omitempty"`
+	Field8691 *bool               `protobuf:"varint,58,opt,name=field8691" json:"field8691,omitempty"`
+	Field8692 *bool               `protobuf:"varint,54,opt,name=field8692" json:"field8692,omitempty"`
+	Field8693 *string             `protobuf:"bytes,55,opt,name=field8693" json:"field8693,omitempty"`
+	Field8694 *UnusedEmptyMessage `protobuf:"bytes,41,opt,name=field8694" json:"field8694,omitempty"`
+	Field8695 *UnusedEmptyMessage `protobuf:"bytes,53,opt,name=field8695" json:"field8695,omitempty"`
+	Field8696 *Message8575        `protobuf:"bytes,61,opt,name=field8696" json:"field8696,omitempty"`
+}
+
+func (x *Message8572) Reset() {
+	*x = Message8572{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[7]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8572) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8572) ProtoMessage() {}
+
+func (x *Message8572) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[7]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8572.ProtoReflect.Descriptor instead.
+func (*Message8572) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *Message8572) GetField8647() []byte {
+	if x != nil {
+		return x.Field8647
+	}
+	return nil
+}
+
+func (x *Message8572) GetField8648() []byte {
+	if x != nil {
+		return x.Field8648
+	}
+	return nil
+}
+
+func (x *Message8572) GetField8649() *Message3886 {
+	if x != nil {
+		return x.Field8649
+	}
+	return nil
+}
+
+func (x *Message8572) GetField8650() *Message3919 {
+	if x != nil {
+		return x.Field8650
+	}
+	return nil
+}
+
+func (x *Message8572) GetField8651() bool {
+	if x != nil && x.Field8651 != nil {
+		return *x.Field8651
+	}
+	return false
+}
+
+func (x *Message8572) GetField8652() int32 {
+	if x != nil && x.Field8652 != nil {
+		return *x.Field8652
+	}
+	return 0
+}
+
+func (x *Message8572) GetField8653() int32 {
+	if x != nil && x.Field8653 != nil {
+		return *x.Field8653
+	}
+	return 0
+}
+
+func (x *Message8572) GetField8654() *Message7905 {
+	if x != nil {
+		return x.Field8654
+	}
+	return nil
+}
+
+func (x *Message8572) GetField8655() int32 {
+	if x != nil && x.Field8655 != nil {
+		return *x.Field8655
+	}
+	return 0
+}
+
+func (x *Message8572) GetField8656() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8656
+	}
+	return nil
+}
+
+func (x *Message8572) GetField8657() bool {
+	if x != nil && x.Field8657 != nil {
+		return *x.Field8657
+	}
+	return false
+}
+
+func (x *Message8572) GetField8658() []byte {
+	if x != nil {
+		return x.Field8658
+	}
+	return nil
+}
+
+func (x *Message8572) GetField8659() string {
+	if x != nil && x.Field8659 != nil {
+		return *x.Field8659
+	}
+	return ""
+}
+
+func (x *Message8572) GetField8660() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8660
+	}
+	return nil
+}
+
+func (x *Message8572) GetField8661() []byte {
+	if x != nil {
+		return x.Field8661
+	}
+	return nil
+}
+
+func (x *Message8572) GetField8662() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8662
+	}
+	return nil
+}
+
+func (x *Message8572) GetField8663() int32 {
+	if x != nil && x.Field8663 != nil {
+		return *x.Field8663
+	}
+	return 0
+}
+
+func (x *Message8572) GetField8664() int32 {
+	if x != nil && x.Field8664 != nil {
+		return *x.Field8664
+	}
+	return 0
+}
+
+func (x *Message8572) GetField8665() bool {
+	if x != nil && x.Field8665 != nil {
+		return *x.Field8665
+	}
+	return false
+}
+
+func (x *Message8572) GetField8666() Enum3476 {
+	if x != nil && x.Field8666 != nil {
+		return *x.Field8666
+	}
+	return Enum3476_ENUM_VALUE3477
+}
+
+func (x *Message8572) GetField8667() bool {
+	if x != nil && x.Field8667 != nil {
+		return *x.Field8667
+	}
+	return false
+}
+
+func (x *Message8572) GetField8668() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8668
+	}
+	return nil
+}
+
+func (x *Message8572) GetField8669() []byte {
+	if x != nil {
+		return x.Field8669
+	}
+	return nil
+}
+
+func (x *Message8572) GetField8670() int32 {
+	if x != nil && x.Field8670 != nil {
+		return *x.Field8670
+	}
+	return 0
+}
+
+func (x *Message8572) GetField8671() *Message3052 {
+	if x != nil {
+		return x.Field8671
+	}
+	return nil
+}
+
+func (x *Message8572) GetField8672() []byte {
+	if x != nil {
+		return x.Field8672
+	}
+	return nil
+}
+
+func (x *Message8572) GetField8673() []byte {
+	if x != nil {
+		return x.Field8673
+	}
+	return nil
+}
+
+func (x *Message8572) GetField8674() int32 {
+	if x != nil && x.Field8674 != nil {
+		return *x.Field8674
+	}
+	return 0
+}
+
+func (x *Message8572) GetField8675() []byte {
+	if x != nil {
+		return x.Field8675
+	}
+	return nil
+}
+
+func (x *Message8572) GetField8676() []byte {
+	if x != nil {
+		return x.Field8676
+	}
+	return nil
+}
+
+func (x *Message8572) GetField8677() string {
+	if x != nil && x.Field8677 != nil {
+		return *x.Field8677
+	}
+	return ""
+}
+
+func (x *Message8572) GetField8678() int32 {
+	if x != nil && x.Field8678 != nil {
+		return *x.Field8678
+	}
+	return 0
+}
+
+func (x *Message8572) GetField8679() int32 {
+	if x != nil && x.Field8679 != nil {
+		return *x.Field8679
+	}
+	return 0
+}
+
+func (x *Message8572) GetField8680() float64 {
+	if x != nil && x.Field8680 != nil {
+		return *x.Field8680
+	}
+	return 0
+}
+
+func (x *Message8572) GetField8681() float64 {
+	if x != nil && x.Field8681 != nil {
+		return *x.Field8681
+	}
+	return 0
+}
+
+func (x *Message8572) GetField8682() *Message3922 {
+	if x != nil {
+		return x.Field8682
+	}
+	return nil
+}
+
+func (x *Message8572) GetField8683() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8683
+	}
+	return nil
+}
+
+func (x *Message8572) GetField8684() int64 {
+	if x != nil && x.Field8684 != nil {
+		return *x.Field8684
+	}
+	return 0
+}
+
+func (x *Message8572) GetField8685() *Message7929 {
+	if x != nil {
+		return x.Field8685
+	}
+	return nil
+}
+
+func (x *Message8572) GetField8686() uint64 {
+	if x != nil && x.Field8686 != nil {
+		return *x.Field8686
+	}
+	return 0
+}
+
+func (x *Message8572) GetField8687() uint32 {
+	if x != nil && x.Field8687 != nil {
+		return *x.Field8687
+	}
+	return 0
+}
+
+func (x *Message8572) GetField8688() *Message7843 {
+	if x != nil {
+		return x.Field8688
+	}
+	return nil
+}
+
+func (x *Message8572) GetField8689() *Message7864 {
+	if x != nil {
+		return x.Field8689
+	}
+	return nil
+}
+
+func (x *Message8572) GetField8690() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8690
+	}
+	return nil
+}
+
+func (x *Message8572) GetField8691() bool {
+	if x != nil && x.Field8691 != nil {
+		return *x.Field8691
+	}
+	return false
+}
+
+func (x *Message8572) GetField8692() bool {
+	if x != nil && x.Field8692 != nil {
+		return *x.Field8692
+	}
+	return false
+}
+
+func (x *Message8572) GetField8693() string {
+	if x != nil && x.Field8693 != nil {
+		return *x.Field8693
+	}
+	return ""
+}
+
+func (x *Message8572) GetField8694() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8694
+	}
+	return nil
+}
+
+func (x *Message8572) GetField8695() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field8695
+	}
+	return nil
+}
+
+func (x *Message8572) GetField8696() *Message8575 {
+	if x != nil {
+		return x.Field8696
+	}
+	return nil
+}
+
+type Message8774 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field8810 *string `protobuf:"bytes,1,opt,name=field8810" json:"field8810,omitempty"`
+	Field8811 *string `protobuf:"bytes,2,opt,name=field8811" json:"field8811,omitempty"`
+	Field8812 *string `protobuf:"bytes,3,opt,name=field8812" json:"field8812,omitempty"`
+	Field8813 *string `protobuf:"bytes,4,opt,name=field8813" json:"field8813,omitempty"`
+	Field8814 *string `protobuf:"bytes,5,opt,name=field8814" json:"field8814,omitempty"`
+}
+
+func (x *Message8774) Reset() {
+	*x = Message8774{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[8]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8774) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8774) ProtoMessage() {}
+
+func (x *Message8774) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[8]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8774.ProtoReflect.Descriptor instead.
+func (*Message8774) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *Message8774) GetField8810() string {
+	if x != nil && x.Field8810 != nil {
+		return *x.Field8810
+	}
+	return ""
+}
+
+func (x *Message8774) GetField8811() string {
+	if x != nil && x.Field8811 != nil {
+		return *x.Field8811
+	}
+	return ""
+}
+
+func (x *Message8774) GetField8812() string {
+	if x != nil && x.Field8812 != nil {
+		return *x.Field8812
+	}
+	return ""
+}
+
+func (x *Message8774) GetField8813() string {
+	if x != nil && x.Field8813 != nil {
+		return *x.Field8813
+	}
+	return ""
+}
+
+func (x *Message8774) GetField8814() string {
+	if x != nil && x.Field8814 != nil {
+		return *x.Field8814
+	}
+	return ""
+}
+
+type Message12776 struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+
+	Field12786 *string             `protobuf:"bytes,1,opt,name=field12786" json:"field12786,omitempty"`
+	Field12787 *uint64             `protobuf:"fixed64,11,opt,name=field12787" json:"field12787,omitempty"`
+	Field12788 *int32              `protobuf:"varint,6,opt,name=field12788" json:"field12788,omitempty"`
+	Field12789 *int32              `protobuf:"varint,13,opt,name=field12789" json:"field12789,omitempty"`
+	Field12790 *int32              `protobuf:"varint,14,opt,name=field12790" json:"field12790,omitempty"`
+	Field12791 *int32              `protobuf:"varint,15,opt,name=field12791" json:"field12791,omitempty"`
+	Field12792 *int32              `protobuf:"varint,16,opt,name=field12792" json:"field12792,omitempty"`
+	Field12793 *UnusedEmptyMessage `protobuf:"bytes,8,opt,name=field12793" json:"field12793,omitempty"`
+	Field12794 *Message12774       `protobuf:"bytes,10,opt,name=field12794" json:"field12794,omitempty"`
+	Field12795 *UnusedEmptyMessage `protobuf:"bytes,12,opt,name=field12795" json:"field12795,omitempty"`
+}
+
+func (x *Message12776) Reset() {
+	*x = Message12776{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[9]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12776) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12776) ProtoMessage() {}
+
+func (x *Message12776) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[9]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12776.ProtoReflect.Descriptor instead.
+func (*Message12776) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{9}
+}
+
+var extRange_Message12776 = []protoiface.ExtensionRangeV1{
+	{Start: 2, End: 2},
+	{Start: 3, End: 3},
+	{Start: 4, End: 4},
+	{Start: 5, End: 5},
+	{Start: 7, End: 7},
+	{Start: 9, End: 9},
+}
+
+// Deprecated: Use Message12776.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*Message12776) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_Message12776
+}
+
+func (x *Message12776) GetField12786() string {
+	if x != nil && x.Field12786 != nil {
+		return *x.Field12786
+	}
+	return ""
+}
+
+func (x *Message12776) GetField12787() uint64 {
+	if x != nil && x.Field12787 != nil {
+		return *x.Field12787
+	}
+	return 0
+}
+
+func (x *Message12776) GetField12788() int32 {
+	if x != nil && x.Field12788 != nil {
+		return *x.Field12788
+	}
+	return 0
+}
+
+func (x *Message12776) GetField12789() int32 {
+	if x != nil && x.Field12789 != nil {
+		return *x.Field12789
+	}
+	return 0
+}
+
+func (x *Message12776) GetField12790() int32 {
+	if x != nil && x.Field12790 != nil {
+		return *x.Field12790
+	}
+	return 0
+}
+
+func (x *Message12776) GetField12791() int32 {
+	if x != nil && x.Field12791 != nil {
+		return *x.Field12791
+	}
+	return 0
+}
+
+func (x *Message12776) GetField12792() int32 {
+	if x != nil && x.Field12792 != nil {
+		return *x.Field12792
+	}
+	return 0
+}
+
+func (x *Message12776) GetField12793() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field12793
+	}
+	return nil
+}
+
+func (x *Message12776) GetField12794() *Message12774 {
+	if x != nil {
+		return x.Field12794
+	}
+	return nil
+}
+
+func (x *Message12776) GetField12795() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field12795
+	}
+	return nil
+}
+
+type Message12798 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12805 *int32        `protobuf:"varint,1,opt,name=field12805" json:"field12805,omitempty"`
+	Field12806 *int32        `protobuf:"varint,2,opt,name=field12806" json:"field12806,omitempty"`
+	Field12807 *Message12774 `protobuf:"bytes,6,opt,name=field12807" json:"field12807,omitempty"`
+	Field12808 *bool         `protobuf:"varint,7,opt,name=field12808" json:"field12808,omitempty"`
+}
+
+func (x *Message12798) Reset() {
+	*x = Message12798{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[10]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12798) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12798) ProtoMessage() {}
+
+func (x *Message12798) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[10]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12798.ProtoReflect.Descriptor instead.
+func (*Message12798) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{10}
+}
+
+func (x *Message12798) GetField12805() int32 {
+	if x != nil && x.Field12805 != nil {
+		return *x.Field12805
+	}
+	return 0
+}
+
+func (x *Message12798) GetField12806() int32 {
+	if x != nil && x.Field12806 != nil {
+		return *x.Field12806
+	}
+	return 0
+}
+
+func (x *Message12798) GetField12807() *Message12774 {
+	if x != nil {
+		return x.Field12807
+	}
+	return nil
+}
+
+func (x *Message12798) GetField12808() bool {
+	if x != nil && x.Field12808 != nil {
+		return *x.Field12808
+	}
+	return false
+}
+
+type Message12797 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12802 *Message12796   `protobuf:"bytes,1,opt,name=field12802" json:"field12802,omitempty"`
+	Field12803 []*Message12796 `protobuf:"bytes,2,rep,name=field12803" json:"field12803,omitempty"`
+	Field12804 *string         `protobuf:"bytes,3,opt,name=field12804" json:"field12804,omitempty"`
+}
+
+func (x *Message12797) Reset() {
+	*x = Message12797{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[11]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12797) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12797) ProtoMessage() {}
+
+func (x *Message12797) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[11]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12797.ProtoReflect.Descriptor instead.
+func (*Message12797) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{11}
+}
+
+func (x *Message12797) GetField12802() *Message12796 {
+	if x != nil {
+		return x.Field12802
+	}
+	return nil
+}
+
+func (x *Message12797) GetField12803() []*Message12796 {
+	if x != nil {
+		return x.Field12803
+	}
+	return nil
+}
+
+func (x *Message12797) GetField12804() string {
+	if x != nil && x.Field12804 != nil {
+		return *x.Field12804
+	}
+	return ""
+}
+
+type Message12825 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12862 []*Message12818       `protobuf:"bytes,1,rep,name=field12862" json:"field12862,omitempty"`
+	Field12863 *int32                `protobuf:"varint,2,opt,name=field12863" json:"field12863,omitempty"`
+	Field12864 *Message12819         `protobuf:"bytes,3,opt,name=field12864" json:"field12864,omitempty"`
+	Field12865 *Message12820         `protobuf:"bytes,4,opt,name=field12865" json:"field12865,omitempty"`
+	Field12866 *int32                `protobuf:"varint,5,opt,name=field12866" json:"field12866,omitempty"`
+	Field12867 []*Message12821       `protobuf:"bytes,6,rep,name=field12867" json:"field12867,omitempty"`
+	Field12868 []*UnusedEmptyMessage `protobuf:"bytes,7,rep,name=field12868" json:"field12868,omitempty"`
+}
+
+func (x *Message12825) Reset() {
+	*x = Message12825{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[12]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12825) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12825) ProtoMessage() {}
+
+func (x *Message12825) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[12]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12825.ProtoReflect.Descriptor instead.
+func (*Message12825) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{12}
+}
+
+func (x *Message12825) GetField12862() []*Message12818 {
+	if x != nil {
+		return x.Field12862
+	}
+	return nil
+}
+
+func (x *Message12825) GetField12863() int32 {
+	if x != nil && x.Field12863 != nil {
+		return *x.Field12863
+	}
+	return 0
+}
+
+func (x *Message12825) GetField12864() *Message12819 {
+	if x != nil {
+		return x.Field12864
+	}
+	return nil
+}
+
+func (x *Message12825) GetField12865() *Message12820 {
+	if x != nil {
+		return x.Field12865
+	}
+	return nil
+}
+
+func (x *Message12825) GetField12866() int32 {
+	if x != nil && x.Field12866 != nil {
+		return *x.Field12866
+	}
+	return 0
+}
+
+func (x *Message12825) GetField12867() []*Message12821 {
+	if x != nil {
+		return x.Field12867
+	}
+	return nil
+}
+
+func (x *Message12825) GetField12868() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field12868
+	}
+	return nil
+}
+
+type Message8590 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message8590) Reset() {
+	*x = Message8590{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[13]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8590) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8590) ProtoMessage() {}
+
+func (x *Message8590) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[13]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8590.ProtoReflect.Descriptor instead.
+func (*Message8590) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{13}
+}
+
+type Message8587 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message8587) Reset() {
+	*x = Message8587{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[14]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8587) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8587) ProtoMessage() {}
+
+func (x *Message8587) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[14]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8587.ProtoReflect.Descriptor instead.
+func (*Message8587) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{14}
+}
+
+type Message1374 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field1375 *string `protobuf:"bytes,1,req,name=field1375" json:"field1375,omitempty"`
+	Field1376 *string `protobuf:"bytes,2,opt,name=field1376" json:"field1376,omitempty"`
+}
+
+func (x *Message1374) Reset() {
+	*x = Message1374{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[15]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message1374) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message1374) ProtoMessage() {}
+
+func (x *Message1374) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[15]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message1374.ProtoReflect.Descriptor instead.
+func (*Message1374) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{15}
+}
+
+func (x *Message1374) GetField1375() string {
+	if x != nil && x.Field1375 != nil {
+		return *x.Field1375
+	}
+	return ""
+}
+
+func (x *Message1374) GetField1376() string {
+	if x != nil && x.Field1376 != nil {
+		return *x.Field1376
+	}
+	return ""
+}
+
+type Message2462 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field2496 []byte   `protobuf:"bytes,1,req,name=field2496" json:"field2496,omitempty"`
+	Field2497 *float64 `protobuf:"fixed64,2,req,name=field2497" json:"field2497,omitempty"`
+}
+
+func (x *Message2462) Reset() {
+	*x = Message2462{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[16]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message2462) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message2462) ProtoMessage() {}
+
+func (x *Message2462) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[16]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message2462.ProtoReflect.Descriptor instead.
+func (*Message2462) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{16}
+}
+
+func (x *Message2462) GetField2496() []byte {
+	if x != nil {
+		return x.Field2496
+	}
+	return nil
+}
+
+func (x *Message2462) GetField2497() float64 {
+	if x != nil && x.Field2497 != nil {
+		return *x.Field2497
+	}
+	return 0
+}
+
+type Message12685 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12692 []string `protobuf:"bytes,1,rep,name=field12692" json:"field12692,omitempty"`
+	Field12693 []string `protobuf:"bytes,2,rep,name=field12693" json:"field12693,omitempty"`
+	Field12694 *int64   `protobuf:"varint,3,opt,name=field12694" json:"field12694,omitempty"`
+	Field12695 *uint32  `protobuf:"varint,4,opt,name=field12695" json:"field12695,omitempty"`
+	Field12696 []string `protobuf:"bytes,5,rep,name=field12696" json:"field12696,omitempty"`
+	Field12697 *string  `protobuf:"bytes,6,opt,name=field12697" json:"field12697,omitempty"`
+	Field12698 *string  `protobuf:"bytes,7,opt,name=field12698" json:"field12698,omitempty"`
+}
+
+func (x *Message12685) Reset() {
+	*x = Message12685{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[17]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12685) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12685) ProtoMessage() {}
+
+func (x *Message12685) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[17]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12685.ProtoReflect.Descriptor instead.
+func (*Message12685) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{17}
+}
+
+func (x *Message12685) GetField12692() []string {
+	if x != nil {
+		return x.Field12692
+	}
+	return nil
+}
+
+func (x *Message12685) GetField12693() []string {
+	if x != nil {
+		return x.Field12693
+	}
+	return nil
+}
+
+func (x *Message12685) GetField12694() int64 {
+	if x != nil && x.Field12694 != nil {
+		return *x.Field12694
+	}
+	return 0
+}
+
+func (x *Message12685) GetField12695() uint32 {
+	if x != nil && x.Field12695 != nil {
+		return *x.Field12695
+	}
+	return 0
+}
+
+func (x *Message12685) GetField12696() []string {
+	if x != nil {
+		return x.Field12696
+	}
+	return nil
+}
+
+func (x *Message12685) GetField12697() string {
+	if x != nil && x.Field12697 != nil {
+		return *x.Field12697
+	}
+	return ""
+}
+
+func (x *Message12685) GetField12698() string {
+	if x != nil && x.Field12698 != nil {
+		return *x.Field12698
+	}
+	return ""
+}
+
+type Message10320 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field10347 *Enum10335      `protobuf:"varint,1,opt,name=field10347,enum=benchmarks.google_message4.Enum10335" json:"field10347,omitempty"`
+	Field10348 []*Message10319 `protobuf:"bytes,2,rep,name=field10348" json:"field10348,omitempty"`
+	Field10349 *int32          `protobuf:"varint,3,opt,name=field10349" json:"field10349,omitempty"`
+	Field10350 *int32          `protobuf:"varint,4,opt,name=field10350" json:"field10350,omitempty"`
+	Field10351 *int32          `protobuf:"varint,5,opt,name=field10351" json:"field10351,omitempty"`
+	Field10352 *int32          `protobuf:"varint,6,opt,name=field10352" json:"field10352,omitempty"`
+	Field10353 *Enum10337      `protobuf:"varint,7,opt,name=field10353,enum=benchmarks.google_message4.Enum10337" json:"field10353,omitempty"`
+}
+
+func (x *Message10320) Reset() {
+	*x = Message10320{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[18]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message10320) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message10320) ProtoMessage() {}
+
+func (x *Message10320) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[18]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message10320.ProtoReflect.Descriptor instead.
+func (*Message10320) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{18}
+}
+
+func (x *Message10320) GetField10347() Enum10335 {
+	if x != nil && x.Field10347 != nil {
+		return *x.Field10347
+	}
+	return Enum10335_ENUM_VALUE10336
+}
+
+func (x *Message10320) GetField10348() []*Message10319 {
+	if x != nil {
+		return x.Field10348
+	}
+	return nil
+}
+
+func (x *Message10320) GetField10349() int32 {
+	if x != nil && x.Field10349 != nil {
+		return *x.Field10349
+	}
+	return 0
+}
+
+func (x *Message10320) GetField10350() int32 {
+	if x != nil && x.Field10350 != nil {
+		return *x.Field10350
+	}
+	return 0
+}
+
+func (x *Message10320) GetField10351() int32 {
+	if x != nil && x.Field10351 != nil {
+		return *x.Field10351
+	}
+	return 0
+}
+
+func (x *Message10320) GetField10352() int32 {
+	if x != nil && x.Field10352 != nil {
+		return *x.Field10352
+	}
+	return 0
+}
+
+func (x *Message10320) GetField10353() Enum10337 {
+	if x != nil && x.Field10353 != nil {
+		return *x.Field10353
+	}
+	return Enum10337_ENUM_VALUE10338
+}
+
+type Message11947 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field11951 *uint32 `protobuf:"varint,1,opt,name=field11951" json:"field11951,omitempty"`
+	Field11952 *bool   `protobuf:"varint,2,opt,name=field11952" json:"field11952,omitempty"`
+	Field11953 *int32  `protobuf:"varint,3,opt,name=field11953" json:"field11953,omitempty"`
+}
+
+func (x *Message11947) Reset() {
+	*x = Message11947{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[19]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message11947) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message11947) ProtoMessage() {}
+
+func (x *Message11947) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[19]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message11947.ProtoReflect.Descriptor instead.
+func (*Message11947) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{19}
+}
+
+func (x *Message11947) GetField11951() uint32 {
+	if x != nil && x.Field11951 != nil {
+		return *x.Field11951
+	}
+	return 0
+}
+
+func (x *Message11947) GetField11952() bool {
+	if x != nil && x.Field11952 != nil {
+		return *x.Field11952
+	}
+	return false
+}
+
+func (x *Message11947) GetField11953() int32 {
+	if x != nil && x.Field11953 != nil {
+		return *x.Field11953
+	}
+	return 0
+}
+
+type Message11920 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field11945 *Enum11901  `protobuf:"varint,1,opt,name=field11945,enum=benchmarks.google_message4.Enum11901" json:"field11945,omitempty"`
+	Field11946 *UnusedEnum `protobuf:"varint,2,opt,name=field11946,enum=benchmarks.google_message4.UnusedEnum" json:"field11946,omitempty"`
+}
+
+func (x *Message11920) Reset() {
+	*x = Message11920{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[20]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message11920) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message11920) ProtoMessage() {}
+
+func (x *Message11920) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[20]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message11920.ProtoReflect.Descriptor instead.
+func (*Message11920) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{20}
+}
+
+func (x *Message11920) GetField11945() Enum11901 {
+	if x != nil && x.Field11945 != nil {
+		return *x.Field11945
+	}
+	return Enum11901_ENUM_VALUE11902
+}
+
+func (x *Message11920) GetField11946() UnusedEnum {
+	if x != nil && x.Field11946 != nil {
+		return *x.Field11946
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+type Message6643 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field6683 *UnusedEmptyMessage   `protobuf:"bytes,3,opt,name=field6683" json:"field6683,omitempty"`
+	Field6684 *UnusedEmptyMessage   `protobuf:"bytes,4,opt,name=field6684" json:"field6684,omitempty"`
+	Field6685 *float64              `protobuf:"fixed64,5,opt,name=field6685" json:"field6685,omitempty"`
+	Field6686 *float64              `protobuf:"fixed64,6,opt,name=field6686" json:"field6686,omitempty"`
+	Field6687 *int32                `protobuf:"varint,1,opt,name=field6687" json:"field6687,omitempty"`
+	Field6688 *int32                `protobuf:"varint,2,opt,name=field6688" json:"field6688,omitempty"`
+	Field6689 *float64              `protobuf:"fixed64,9,opt,name=field6689" json:"field6689,omitempty"`
+	Field6690 []byte                `protobuf:"bytes,10,opt,name=field6690" json:"field6690,omitempty"`
+	Field6691 *int32                `protobuf:"varint,11,opt,name=field6691" json:"field6691,omitempty"`
+	Field6692 *bool                 `protobuf:"varint,12,opt,name=field6692" json:"field6692,omitempty"`
+	Field6693 *bool                 `protobuf:"varint,13,opt,name=field6693" json:"field6693,omitempty"`
+	Field6694 *Message6578          `protobuf:"bytes,15,opt,name=field6694" json:"field6694,omitempty"`
+	Field6695 *UnusedEnum           `protobuf:"varint,16,opt,name=field6695,enum=benchmarks.google_message4.UnusedEnum" json:"field6695,omitempty"`
+	Field6696 *int64                `protobuf:"varint,17,opt,name=field6696" json:"field6696,omitempty"`
+	Field6697 []*UnusedEmptyMessage `protobuf:"bytes,22,rep,name=field6697" json:"field6697,omitempty"`
+	Field6698 *UnusedEmptyMessage   `protobuf:"bytes,19,opt,name=field6698" json:"field6698,omitempty"`
+	Field6699 *UnusedEmptyMessage   `protobuf:"bytes,20,opt,name=field6699" json:"field6699,omitempty"`
+	Field6700 *int32                `protobuf:"varint,21,opt,name=field6700" json:"field6700,omitempty"`
+}
+
+func (x *Message6643) Reset() {
+	*x = Message6643{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[21]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6643) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6643) ProtoMessage() {}
+
+func (x *Message6643) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[21]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6643.ProtoReflect.Descriptor instead.
+func (*Message6643) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{21}
+}
+
+func (x *Message6643) GetField6683() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field6683
+	}
+	return nil
+}
+
+func (x *Message6643) GetField6684() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field6684
+	}
+	return nil
+}
+
+func (x *Message6643) GetField6685() float64 {
+	if x != nil && x.Field6685 != nil {
+		return *x.Field6685
+	}
+	return 0
+}
+
+func (x *Message6643) GetField6686() float64 {
+	if x != nil && x.Field6686 != nil {
+		return *x.Field6686
+	}
+	return 0
+}
+
+func (x *Message6643) GetField6687() int32 {
+	if x != nil && x.Field6687 != nil {
+		return *x.Field6687
+	}
+	return 0
+}
+
+func (x *Message6643) GetField6688() int32 {
+	if x != nil && x.Field6688 != nil {
+		return *x.Field6688
+	}
+	return 0
+}
+
+func (x *Message6643) GetField6689() float64 {
+	if x != nil && x.Field6689 != nil {
+		return *x.Field6689
+	}
+	return 0
+}
+
+func (x *Message6643) GetField6690() []byte {
+	if x != nil {
+		return x.Field6690
+	}
+	return nil
+}
+
+func (x *Message6643) GetField6691() int32 {
+	if x != nil && x.Field6691 != nil {
+		return *x.Field6691
+	}
+	return 0
+}
+
+func (x *Message6643) GetField6692() bool {
+	if x != nil && x.Field6692 != nil {
+		return *x.Field6692
+	}
+	return false
+}
+
+func (x *Message6643) GetField6693() bool {
+	if x != nil && x.Field6693 != nil {
+		return *x.Field6693
+	}
+	return false
+}
+
+func (x *Message6643) GetField6694() *Message6578 {
+	if x != nil {
+		return x.Field6694
+	}
+	return nil
+}
+
+func (x *Message6643) GetField6695() UnusedEnum {
+	if x != nil && x.Field6695 != nil {
+		return *x.Field6695
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+func (x *Message6643) GetField6696() int64 {
+	if x != nil && x.Field6696 != nil {
+		return *x.Field6696
+	}
+	return 0
+}
+
+func (x *Message6643) GetField6697() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field6697
+	}
+	return nil
+}
+
+func (x *Message6643) GetField6698() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field6698
+	}
+	return nil
+}
+
+func (x *Message6643) GetField6699() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field6699
+	}
+	return nil
+}
+
+func (x *Message6643) GetField6700() int32 {
+	if x != nil && x.Field6700 != nil {
+		return *x.Field6700
+	}
+	return 0
+}
+
+type Message6133 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field6173 *Message4016   `protobuf:"bytes,12,opt,name=field6173" json:"field6173,omitempty"`
+	Field6174 *float64       `protobuf:"fixed64,16,opt,name=field6174" json:"field6174,omitempty"`
+	Field6175 *string        `protobuf:"bytes,1,req,name=field6175" json:"field6175,omitempty"`
+	Field6176 *string        `protobuf:"bytes,2,req,name=field6176" json:"field6176,omitempty"`
+	Field6177 *string        `protobuf:"bytes,3,req,name=field6177" json:"field6177,omitempty"`
+	Field6178 *string        `protobuf:"bytes,4,opt,name=field6178" json:"field6178,omitempty"`
+	Field6179 *string        `protobuf:"bytes,8,opt,name=field6179" json:"field6179,omitempty"`
+	Field6180 []*Message6109 `protobuf:"bytes,5,rep,name=field6180" json:"field6180,omitempty"`
+	Field6181 []*Message5908 `protobuf:"bytes,13,rep,name=field6181" json:"field6181,omitempty"`
+	Field6182 []*Message6107 `protobuf:"bytes,7,rep,name=field6182" json:"field6182,omitempty"`
+	Field6183 []*Message6126 `protobuf:"bytes,9,rep,name=field6183" json:"field6183,omitempty"`
+	Field6184 []*Message6129 `protobuf:"bytes,15,rep,name=field6184" json:"field6184,omitempty"`
+	Field6185 *int32         `protobuf:"varint,10,opt,name=field6185" json:"field6185,omitempty"`
+	Field6186 *int32         `protobuf:"varint,11,opt,name=field6186" json:"field6186,omitempty"`
+	Field6187 *Message4016   `protobuf:"bytes,17,opt,name=field6187" json:"field6187,omitempty"`
+	Field6188 *float64       `protobuf:"fixed64,14,opt,name=field6188" json:"field6188,omitempty"`
+	Field6189 *float64       `protobuf:"fixed64,18,opt,name=field6189" json:"field6189,omitempty"`
+	Field6190 *string        `protobuf:"bytes,19,opt,name=field6190" json:"field6190,omitempty"`
+	Field6191 *string        `protobuf:"bytes,20,opt,name=field6191" json:"field6191,omitempty"`
+	Field6192 []*Message5881 `protobuf:"bytes,21,rep,name=field6192" json:"field6192,omitempty"`
+}
+
+func (x *Message6133) Reset() {
+	*x = Message6133{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[22]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6133) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6133) ProtoMessage() {}
+
+func (x *Message6133) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[22]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6133.ProtoReflect.Descriptor instead.
+func (*Message6133) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{22}
+}
+
+func (x *Message6133) GetField6173() *Message4016 {
+	if x != nil {
+		return x.Field6173
+	}
+	return nil
+}
+
+func (x *Message6133) GetField6174() float64 {
+	if x != nil && x.Field6174 != nil {
+		return *x.Field6174
+	}
+	return 0
+}
+
+func (x *Message6133) GetField6175() string {
+	if x != nil && x.Field6175 != nil {
+		return *x.Field6175
+	}
+	return ""
+}
+
+func (x *Message6133) GetField6176() string {
+	if x != nil && x.Field6176 != nil {
+		return *x.Field6176
+	}
+	return ""
+}
+
+func (x *Message6133) GetField6177() string {
+	if x != nil && x.Field6177 != nil {
+		return *x.Field6177
+	}
+	return ""
+}
+
+func (x *Message6133) GetField6178() string {
+	if x != nil && x.Field6178 != nil {
+		return *x.Field6178
+	}
+	return ""
+}
+
+func (x *Message6133) GetField6179() string {
+	if x != nil && x.Field6179 != nil {
+		return *x.Field6179
+	}
+	return ""
+}
+
+func (x *Message6133) GetField6180() []*Message6109 {
+	if x != nil {
+		return x.Field6180
+	}
+	return nil
+}
+
+func (x *Message6133) GetField6181() []*Message5908 {
+	if x != nil {
+		return x.Field6181
+	}
+	return nil
+}
+
+func (x *Message6133) GetField6182() []*Message6107 {
+	if x != nil {
+		return x.Field6182
+	}
+	return nil
+}
+
+func (x *Message6133) GetField6183() []*Message6126 {
+	if x != nil {
+		return x.Field6183
+	}
+	return nil
+}
+
+func (x *Message6133) GetField6184() []*Message6129 {
+	if x != nil {
+		return x.Field6184
+	}
+	return nil
+}
+
+func (x *Message6133) GetField6185() int32 {
+	if x != nil && x.Field6185 != nil {
+		return *x.Field6185
+	}
+	return 0
+}
+
+func (x *Message6133) GetField6186() int32 {
+	if x != nil && x.Field6186 != nil {
+		return *x.Field6186
+	}
+	return 0
+}
+
+func (x *Message6133) GetField6187() *Message4016 {
+	if x != nil {
+		return x.Field6187
+	}
+	return nil
+}
+
+func (x *Message6133) GetField6188() float64 {
+	if x != nil && x.Field6188 != nil {
+		return *x.Field6188
+	}
+	return 0
+}
+
+func (x *Message6133) GetField6189() float64 {
+	if x != nil && x.Field6189 != nil {
+		return *x.Field6189
+	}
+	return 0
+}
+
+func (x *Message6133) GetField6190() string {
+	if x != nil && x.Field6190 != nil {
+		return *x.Field6190
+	}
+	return ""
+}
+
+func (x *Message6133) GetField6191() string {
+	if x != nil && x.Field6191 != nil {
+		return *x.Field6191
+	}
+	return ""
+}
+
+func (x *Message6133) GetField6192() []*Message5881 {
+	if x != nil {
+		return x.Field6192
+	}
+	return nil
+}
+
+type Message6109 struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+
+	Field6140 *string        `protobuf:"bytes,1,opt,name=field6140" json:"field6140,omitempty"`
+	Field6141 *Enum6111      `protobuf:"varint,2,req,name=field6141,enum=benchmarks.google_message4.Enum6111" json:"field6141,omitempty"`
+	Field6142 *int32         `protobuf:"varint,9,opt,name=field6142" json:"field6142,omitempty"`
+	Field6143 *string        `protobuf:"bytes,3,opt,name=field6143" json:"field6143,omitempty"`
+	Field6144 []*Message6110 `protobuf:"bytes,4,rep,name=field6144" json:"field6144,omitempty"`
+	Field6145 []int32        `protobuf:"varint,7,rep,name=field6145" json:"field6145,omitempty"`
+	Field6146 []int32        `protobuf:"varint,8,rep,name=field6146" json:"field6146,omitempty"`
+	Field6147 *Message6133   `protobuf:"bytes,10,opt,name=field6147" json:"field6147,omitempty"`
+	Field6148 []int32        `protobuf:"varint,11,rep,name=field6148" json:"field6148,omitempty"`
+	Field6149 *string        `protobuf:"bytes,12,opt,name=field6149" json:"field6149,omitempty"`
+	Field6150 *string        `protobuf:"bytes,13,opt,name=field6150" json:"field6150,omitempty"`
+	Field6151 *bool          `protobuf:"varint,14,opt,name=field6151" json:"field6151,omitempty"`
+}
+
+func (x *Message6109) Reset() {
+	*x = Message6109{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[23]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6109) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6109) ProtoMessage() {}
+
+func (x *Message6109) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[23]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6109.ProtoReflect.Descriptor instead.
+func (*Message6109) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{23}
+}
+
+var extRange_Message6109 = []protoiface.ExtensionRangeV1{
+	{Start: 1000, End: 536870911},
+}
+
+// Deprecated: Use Message6109.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*Message6109) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_Message6109
+}
+
+func (x *Message6109) GetField6140() string {
+	if x != nil && x.Field6140 != nil {
+		return *x.Field6140
+	}
+	return ""
+}
+
+func (x *Message6109) GetField6141() Enum6111 {
+	if x != nil && x.Field6141 != nil {
+		return *x.Field6141
+	}
+	return Enum6111_ENUM_VALUE6112
+}
+
+func (x *Message6109) GetField6142() int32 {
+	if x != nil && x.Field6142 != nil {
+		return *x.Field6142
+	}
+	return 0
+}
+
+func (x *Message6109) GetField6143() string {
+	if x != nil && x.Field6143 != nil {
+		return *x.Field6143
+	}
+	return ""
+}
+
+func (x *Message6109) GetField6144() []*Message6110 {
+	if x != nil {
+		return x.Field6144
+	}
+	return nil
+}
+
+func (x *Message6109) GetField6145() []int32 {
+	if x != nil {
+		return x.Field6145
+	}
+	return nil
+}
+
+func (x *Message6109) GetField6146() []int32 {
+	if x != nil {
+		return x.Field6146
+	}
+	return nil
+}
+
+func (x *Message6109) GetField6147() *Message6133 {
+	if x != nil {
+		return x.Field6147
+	}
+	return nil
+}
+
+func (x *Message6109) GetField6148() []int32 {
+	if x != nil {
+		return x.Field6148
+	}
+	return nil
+}
+
+func (x *Message6109) GetField6149() string {
+	if x != nil && x.Field6149 != nil {
+		return *x.Field6149
+	}
+	return ""
+}
+
+func (x *Message6109) GetField6150() string {
+	if x != nil && x.Field6150 != nil {
+		return *x.Field6150
+	}
+	return ""
+}
+
+func (x *Message6109) GetField6151() bool {
+	if x != nil && x.Field6151 != nil {
+		return *x.Field6151
+	}
+	return false
+}
+
+type Message3046 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field3222 *Enum2593 `protobuf:"varint,1,req,name=field3222,enum=benchmarks.google_message4.Enum2593" json:"field3222,omitempty"`
+	Field3223 *int32    `protobuf:"varint,4,opt,name=field3223" json:"field3223,omitempty"`
+}
+
+func (x *Message3046) Reset() {
+	*x = Message3046{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[24]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message3046) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message3046) ProtoMessage() {}
+
+func (x *Message3046) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[24]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message3046.ProtoReflect.Descriptor instead.
+func (*Message3046) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{24}
+}
+
+func (x *Message3046) GetField3222() Enum2593 {
+	if x != nil && x.Field3222 != nil {
+		return *x.Field3222
+	}
+	return Enum2593_ENUM_VALUE2594
+}
+
+func (x *Message3046) GetField3223() int32 {
+	if x != nil && x.Field3223 != nil {
+		return *x.Field3223
+	}
+	return 0
+}
+
+type Message3060 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field3283 *int64 `protobuf:"varint,1,opt,name=field3283" json:"field3283,omitempty"`
+	Field3284 *int64 `protobuf:"varint,2,opt,name=field3284" json:"field3284,omitempty"`
+	Field3285 *int64 `protobuf:"varint,3,opt,name=field3285" json:"field3285,omitempty"`
+}
+
+func (x *Message3060) Reset() {
+	*x = Message3060{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[25]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message3060) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message3060) ProtoMessage() {}
+
+func (x *Message3060) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[25]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message3060.ProtoReflect.Descriptor instead.
+func (*Message3060) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{25}
+}
+
+func (x *Message3060) GetField3283() int64 {
+	if x != nil && x.Field3283 != nil {
+		return *x.Field3283
+	}
+	return 0
+}
+
+func (x *Message3060) GetField3284() int64 {
+	if x != nil && x.Field3284 != nil {
+		return *x.Field3284
+	}
+	return 0
+}
+
+func (x *Message3060) GetField3285() int64 {
+	if x != nil && x.Field3285 != nil {
+		return *x.Field3285
+	}
+	return 0
+}
+
+type Message3041 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field3214 *string `protobuf:"bytes,1,opt,name=field3214" json:"field3214,omitempty"`
+	Field3215 *int32  `protobuf:"varint,2,opt,name=field3215" json:"field3215,omitempty"`
+}
+
+func (x *Message3041) Reset() {
+	*x = Message3041{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[26]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message3041) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message3041) ProtoMessage() {}
+
+func (x *Message3041) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[26]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message3041.ProtoReflect.Descriptor instead.
+func (*Message3041) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{26}
+}
+
+func (x *Message3041) GetField3214() string {
+	if x != nil && x.Field3214 != nil {
+		return *x.Field3214
+	}
+	return ""
+}
+
+func (x *Message3041) GetField3215() int32 {
+	if x != nil && x.Field3215 != nil {
+		return *x.Field3215
+	}
+	return 0
+}
+
+type Message3040 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field3209 *uint64  `protobuf:"fixed64,1,req,name=field3209" json:"field3209,omitempty"`
+	Field3210 []uint64 `protobuf:"fixed64,4,rep,name=field3210" json:"field3210,omitempty"`
+	Field3211 *int32   `protobuf:"varint,5,opt,name=field3211" json:"field3211,omitempty"`
+	Field3212 *uint64  `protobuf:"fixed64,2,opt,name=field3212" json:"field3212,omitempty"`
+	Field3213 *string  `protobuf:"bytes,3,req,name=field3213" json:"field3213,omitempty"`
+}
+
+func (x *Message3040) Reset() {
+	*x = Message3040{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[27]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message3040) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message3040) ProtoMessage() {}
+
+func (x *Message3040) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[27]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message3040.ProtoReflect.Descriptor instead.
+func (*Message3040) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{27}
+}
+
+func (x *Message3040) GetField3209() uint64 {
+	if x != nil && x.Field3209 != nil {
+		return *x.Field3209
+	}
+	return 0
+}
+
+func (x *Message3040) GetField3210() []uint64 {
+	if x != nil {
+		return x.Field3210
+	}
+	return nil
+}
+
+func (x *Message3040) GetField3211() int32 {
+	if x != nil && x.Field3211 != nil {
+		return *x.Field3211
+	}
+	return 0
+}
+
+func (x *Message3040) GetField3212() uint64 {
+	if x != nil && x.Field3212 != nil {
+		return *x.Field3212
+	}
+	return 0
+}
+
+func (x *Message3040) GetField3213() string {
+	if x != nil && x.Field3213 != nil {
+		return *x.Field3213
+	}
+	return ""
+}
+
+type Message3050 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field3245 []byte  `protobuf:"bytes,5,opt,name=field3245" json:"field3245,omitempty"`
+	Field3246 *int32  `protobuf:"varint,2,opt,name=field3246" json:"field3246,omitempty"`
+	Field3247 []byte  `protobuf:"bytes,6,opt,name=field3247" json:"field3247,omitempty"`
+	Field3248 *int32  `protobuf:"varint,4,opt,name=field3248" json:"field3248,omitempty"`
+	Field3249 *uint32 `protobuf:"fixed32,1,opt,name=field3249" json:"field3249,omitempty"`
+	Field3250 *uint32 `protobuf:"fixed32,3,opt,name=field3250" json:"field3250,omitempty"`
+}
+
+func (x *Message3050) Reset() {
+	*x = Message3050{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[28]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message3050) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message3050) ProtoMessage() {}
+
+func (x *Message3050) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[28]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message3050.ProtoReflect.Descriptor instead.
+func (*Message3050) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{28}
+}
+
+func (x *Message3050) GetField3245() []byte {
+	if x != nil {
+		return x.Field3245
+	}
+	return nil
+}
+
+func (x *Message3050) GetField3246() int32 {
+	if x != nil && x.Field3246 != nil {
+		return *x.Field3246
+	}
+	return 0
+}
+
+func (x *Message3050) GetField3247() []byte {
+	if x != nil {
+		return x.Field3247
+	}
+	return nil
+}
+
+func (x *Message3050) GetField3248() int32 {
+	if x != nil && x.Field3248 != nil {
+		return *x.Field3248
+	}
+	return 0
+}
+
+func (x *Message3050) GetField3249() uint32 {
+	if x != nil && x.Field3249 != nil {
+		return *x.Field3249
+	}
+	return 0
+}
+
+func (x *Message3050) GetField3250() uint32 {
+	if x != nil && x.Field3250 != nil {
+		return *x.Field3250
+	}
+	return 0
+}
+
+type Message7905 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field7911 *int32 `protobuf:"varint,1,opt,name=field7911" json:"field7911,omitempty"`
+	Field7912 *bool  `protobuf:"varint,2,opt,name=field7912" json:"field7912,omitempty"`
+	Field7913 []byte `protobuf:"bytes,3,opt,name=field7913" json:"field7913,omitempty"`
+	Field7914 *int32 `protobuf:"varint,4,opt,name=field7914" json:"field7914,omitempty"`
+	Field7915 *int32 `protobuf:"varint,5,opt,name=field7915" json:"field7915,omitempty"`
+	Field7916 []byte `protobuf:"bytes,6,opt,name=field7916" json:"field7916,omitempty"`
+	Field7917 *int32 `protobuf:"varint,7,opt,name=field7917" json:"field7917,omitempty"`
+}
+
+func (x *Message7905) Reset() {
+	*x = Message7905{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[29]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message7905) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message7905) ProtoMessage() {}
+
+func (x *Message7905) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[29]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message7905.ProtoReflect.Descriptor instead.
+func (*Message7905) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{29}
+}
+
+func (x *Message7905) GetField7911() int32 {
+	if x != nil && x.Field7911 != nil {
+		return *x.Field7911
+	}
+	return 0
+}
+
+func (x *Message7905) GetField7912() bool {
+	if x != nil && x.Field7912 != nil {
+		return *x.Field7912
+	}
+	return false
+}
+
+func (x *Message7905) GetField7913() []byte {
+	if x != nil {
+		return x.Field7913
+	}
+	return nil
+}
+
+func (x *Message7905) GetField7914() int32 {
+	if x != nil && x.Field7914 != nil {
+		return *x.Field7914
+	}
+	return 0
+}
+
+func (x *Message7905) GetField7915() int32 {
+	if x != nil && x.Field7915 != nil {
+		return *x.Field7915
+	}
+	return 0
+}
+
+func (x *Message7905) GetField7916() []byte {
+	if x != nil {
+		return x.Field7916
+	}
+	return nil
+}
+
+func (x *Message7905) GetField7917() int32 {
+	if x != nil && x.Field7917 != nil {
+		return *x.Field7917
+	}
+	return 0
+}
+
+type Message3886 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Message3887 []*Message3886_Message3887 `protobuf:"group,1,rep,name=Message3887,json=message3887" json:"message3887,omitempty"`
+}
+
+func (x *Message3886) Reset() {
+	*x = Message3886{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[30]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message3886) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message3886) ProtoMessage() {}
+
+func (x *Message3886) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[30]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message3886.ProtoReflect.Descriptor instead.
+func (*Message3886) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{30}
+}
+
+func (x *Message3886) GetMessage3887() []*Message3886_Message3887 {
+	if x != nil {
+		return x.Message3887
+	}
+	return nil
+}
+
+type Message7864 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field7866 *string               `protobuf:"bytes,1,opt,name=field7866" json:"field7866,omitempty"`
+	Field7867 *string               `protobuf:"bytes,2,opt,name=field7867" json:"field7867,omitempty"`
+	Field7868 []*Message7865        `protobuf:"bytes,5,rep,name=field7868" json:"field7868,omitempty"`
+	Field7869 []*Message7865        `protobuf:"bytes,6,rep,name=field7869" json:"field7869,omitempty"`
+	Field7870 []*Message7865        `protobuf:"bytes,7,rep,name=field7870" json:"field7870,omitempty"`
+	Field7871 []*UnusedEmptyMessage `protobuf:"bytes,8,rep,name=field7871" json:"field7871,omitempty"`
+}
+
+func (x *Message7864) Reset() {
+	*x = Message7864{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[31]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message7864) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message7864) ProtoMessage() {}
+
+func (x *Message7864) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[31]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message7864.ProtoReflect.Descriptor instead.
+func (*Message7864) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{31}
+}
+
+func (x *Message7864) GetField7866() string {
+	if x != nil && x.Field7866 != nil {
+		return *x.Field7866
+	}
+	return ""
+}
+
+func (x *Message7864) GetField7867() string {
+	if x != nil && x.Field7867 != nil {
+		return *x.Field7867
+	}
+	return ""
+}
+
+func (x *Message7864) GetField7868() []*Message7865 {
+	if x != nil {
+		return x.Field7868
+	}
+	return nil
+}
+
+func (x *Message7864) GetField7869() []*Message7865 {
+	if x != nil {
+		return x.Field7869
+	}
+	return nil
+}
+
+func (x *Message7864) GetField7870() []*Message7865 {
+	if x != nil {
+		return x.Field7870
+	}
+	return nil
+}
+
+func (x *Message7864) GetField7871() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field7871
+	}
+	return nil
+}
+
+type Message3922 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field4012 *uint64 `protobuf:"varint,1,opt,name=field4012" json:"field4012,omitempty"`
+}
+
+func (x *Message3922) Reset() {
+	*x = Message3922{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[32]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message3922) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message3922) ProtoMessage() {}
+
+func (x *Message3922) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[32]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message3922.ProtoReflect.Descriptor instead.
+func (*Message3922) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{32}
+}
+
+func (x *Message3922) GetField4012() uint64 {
+	if x != nil && x.Field4012 != nil {
+		return *x.Field4012
+	}
+	return 0
+}
+
+type Message3052 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field3254 []string `protobuf:"bytes,1,rep,name=field3254" json:"field3254,omitempty"`
+	Field3255 []string `protobuf:"bytes,2,rep,name=field3255" json:"field3255,omitempty"`
+	Field3256 [][]byte `protobuf:"bytes,3,rep,name=field3256" json:"field3256,omitempty"`
+	Field3257 []string `protobuf:"bytes,4,rep,name=field3257" json:"field3257,omitempty"`
+	Field3258 *bool    `protobuf:"varint,5,opt,name=field3258" json:"field3258,omitempty"`
+	Field3259 *int32   `protobuf:"varint,6,opt,name=field3259" json:"field3259,omitempty"`
+	Field3260 *int32   `protobuf:"varint,7,opt,name=field3260" json:"field3260,omitempty"`
+	Field3261 *string  `protobuf:"bytes,8,opt,name=field3261" json:"field3261,omitempty"`
+	Field3262 *string  `protobuf:"bytes,9,opt,name=field3262" json:"field3262,omitempty"`
+}
+
+func (x *Message3052) Reset() {
+	*x = Message3052{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[33]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message3052) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message3052) ProtoMessage() {}
+
+func (x *Message3052) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[33]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message3052.ProtoReflect.Descriptor instead.
+func (*Message3052) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{33}
+}
+
+func (x *Message3052) GetField3254() []string {
+	if x != nil {
+		return x.Field3254
+	}
+	return nil
+}
+
+func (x *Message3052) GetField3255() []string {
+	if x != nil {
+		return x.Field3255
+	}
+	return nil
+}
+
+func (x *Message3052) GetField3256() [][]byte {
+	if x != nil {
+		return x.Field3256
+	}
+	return nil
+}
+
+func (x *Message3052) GetField3257() []string {
+	if x != nil {
+		return x.Field3257
+	}
+	return nil
+}
+
+func (x *Message3052) GetField3258() bool {
+	if x != nil && x.Field3258 != nil {
+		return *x.Field3258
+	}
+	return false
+}
+
+func (x *Message3052) GetField3259() int32 {
+	if x != nil && x.Field3259 != nil {
+		return *x.Field3259
+	}
+	return 0
+}
+
+func (x *Message3052) GetField3260() int32 {
+	if x != nil && x.Field3260 != nil {
+		return *x.Field3260
+	}
+	return 0
+}
+
+func (x *Message3052) GetField3261() string {
+	if x != nil && x.Field3261 != nil {
+		return *x.Field3261
+	}
+	return ""
+}
+
+func (x *Message3052) GetField3262() string {
+	if x != nil && x.Field3262 != nil {
+		return *x.Field3262
+	}
+	return ""
+}
+
+type Message8575 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message8575) Reset() {
+	*x = Message8575{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[34]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message8575) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message8575) ProtoMessage() {}
+
+func (x *Message8575) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[34]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message8575.ProtoReflect.Descriptor instead.
+func (*Message8575) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{34}
+}
+
+type Message7843 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field7844 *bool               `protobuf:"varint,5,opt,name=field7844" json:"field7844,omitempty"`
+	Field7845 *int32              `protobuf:"varint,1,opt,name=field7845" json:"field7845,omitempty"`
+	Field7846 *UnusedEmptyMessage `protobuf:"bytes,22,opt,name=field7846" json:"field7846,omitempty"`
+	Field7847 []int32             `protobuf:"varint,3,rep,name=field7847" json:"field7847,omitempty"`
+	Field7848 []string            `protobuf:"bytes,11,rep,name=field7848" json:"field7848,omitempty"`
+	Field7849 *UnusedEnum         `protobuf:"varint,15,opt,name=field7849,enum=benchmarks.google_message4.UnusedEnum" json:"field7849,omitempty"`
+	Field7850 *UnusedEmptyMessage `protobuf:"bytes,6,opt,name=field7850" json:"field7850,omitempty"`
+	Field7851 *UnusedEmptyMessage `protobuf:"bytes,14,opt,name=field7851" json:"field7851,omitempty"`
+	Field7852 *UnusedEmptyMessage `protobuf:"bytes,10,opt,name=field7852" json:"field7852,omitempty"`
+	Field7853 *Message7511        `protobuf:"bytes,13,opt,name=field7853" json:"field7853,omitempty"`
+	Field7854 *UnusedEmptyMessage `protobuf:"bytes,16,opt,name=field7854" json:"field7854,omitempty"`
+	Field7855 *UnusedEmptyMessage `protobuf:"bytes,17,opt,name=field7855" json:"field7855,omitempty"`
+	Field7856 *UnusedEmptyMessage `protobuf:"bytes,19,opt,name=field7856" json:"field7856,omitempty"`
+	Field7857 *UnusedEmptyMessage `protobuf:"bytes,18,opt,name=field7857" json:"field7857,omitempty"`
+	Field7858 *UnusedEnum         `protobuf:"varint,20,opt,name=field7858,enum=benchmarks.google_message4.UnusedEnum" json:"field7858,omitempty"`
+	Field7859 *int32              `protobuf:"varint,2,opt,name=field7859" json:"field7859,omitempty"`
+}
+
+func (x *Message7843) Reset() {
+	*x = Message7843{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[35]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message7843) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message7843) ProtoMessage() {}
+
+func (x *Message7843) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[35]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message7843.ProtoReflect.Descriptor instead.
+func (*Message7843) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{35}
+}
+
+func (x *Message7843) GetField7844() bool {
+	if x != nil && x.Field7844 != nil {
+		return *x.Field7844
+	}
+	return false
+}
+
+func (x *Message7843) GetField7845() int32 {
+	if x != nil && x.Field7845 != nil {
+		return *x.Field7845
+	}
+	return 0
+}
+
+func (x *Message7843) GetField7846() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field7846
+	}
+	return nil
+}
+
+func (x *Message7843) GetField7847() []int32 {
+	if x != nil {
+		return x.Field7847
+	}
+	return nil
+}
+
+func (x *Message7843) GetField7848() []string {
+	if x != nil {
+		return x.Field7848
+	}
+	return nil
+}
+
+func (x *Message7843) GetField7849() UnusedEnum {
+	if x != nil && x.Field7849 != nil {
+		return *x.Field7849
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+func (x *Message7843) GetField7850() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field7850
+	}
+	return nil
+}
+
+func (x *Message7843) GetField7851() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field7851
+	}
+	return nil
+}
+
+func (x *Message7843) GetField7852() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field7852
+	}
+	return nil
+}
+
+func (x *Message7843) GetField7853() *Message7511 {
+	if x != nil {
+		return x.Field7853
+	}
+	return nil
+}
+
+func (x *Message7843) GetField7854() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field7854
+	}
+	return nil
+}
+
+func (x *Message7843) GetField7855() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field7855
+	}
+	return nil
+}
+
+func (x *Message7843) GetField7856() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field7856
+	}
+	return nil
+}
+
+func (x *Message7843) GetField7857() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field7857
+	}
+	return nil
+}
+
+func (x *Message7843) GetField7858() UnusedEnum {
+	if x != nil && x.Field7858 != nil {
+		return *x.Field7858
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+func (x *Message7843) GetField7859() int32 {
+	if x != nil && x.Field7859 != nil {
+		return *x.Field7859
+	}
+	return 0
+}
+
+type Message3919 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field4009 []*Message3920 `protobuf:"bytes,1,rep,name=field4009" json:"field4009,omitempty"`
+}
+
+func (x *Message3919) Reset() {
+	*x = Message3919{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[36]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message3919) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message3919) ProtoMessage() {}
+
+func (x *Message3919) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[36]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message3919.ProtoReflect.Descriptor instead.
+func (*Message3919) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{36}
+}
+
+func (x *Message3919) GetField4009() []*Message3920 {
+	if x != nil {
+		return x.Field4009
+	}
+	return nil
+}
+
+type Message7929 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field7942 *int64                `protobuf:"varint,1,opt,name=field7942" json:"field7942,omitempty"`
+	Field7943 *int64                `protobuf:"varint,4,opt,name=field7943" json:"field7943,omitempty"`
+	Field7944 *int64                `protobuf:"varint,5,opt,name=field7944" json:"field7944,omitempty"`
+	Field7945 *int64                `protobuf:"varint,12,opt,name=field7945" json:"field7945,omitempty"`
+	Field7946 *int64                `protobuf:"varint,13,opt,name=field7946" json:"field7946,omitempty"`
+	Field7947 *int64                `protobuf:"varint,18,opt,name=field7947" json:"field7947,omitempty"`
+	Field7948 *int64                `protobuf:"varint,6,opt,name=field7948" json:"field7948,omitempty"`
+	Field7949 *int64                `protobuf:"varint,7,opt,name=field7949" json:"field7949,omitempty"`
+	Field7950 []*Message7919        `protobuf:"bytes,8,rep,name=field7950" json:"field7950,omitempty"`
+	Field7951 []*UnusedEmptyMessage `protobuf:"bytes,20,rep,name=field7951" json:"field7951,omitempty"`
+	Field7952 []*Message7920        `protobuf:"bytes,14,rep,name=field7952" json:"field7952,omitempty"`
+	Field7953 []*Message7921        `protobuf:"bytes,15,rep,name=field7953" json:"field7953,omitempty"`
+	Field7954 []*Message7928        `protobuf:"bytes,17,rep,name=field7954" json:"field7954,omitempty"`
+	Field7955 *int64                `protobuf:"varint,19,opt,name=field7955" json:"field7955,omitempty"`
+	Field7956 *bool                 `protobuf:"varint,2,opt,name=field7956" json:"field7956,omitempty"`
+	Field7957 *int64                `protobuf:"varint,3,opt,name=field7957" json:"field7957,omitempty"`
+	Field7958 *int64                `protobuf:"varint,9,opt,name=field7958" json:"field7958,omitempty"`
+	Field7959 []*UnusedEmptyMessage `protobuf:"bytes,10,rep,name=field7959" json:"field7959,omitempty"`
+	Field7960 [][]byte              `protobuf:"bytes,11,rep,name=field7960" json:"field7960,omitempty"`
+	Field7961 *int64                `protobuf:"varint,16,opt,name=field7961" json:"field7961,omitempty"`
+}
+
+func (x *Message7929) Reset() {
+	*x = Message7929{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[37]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message7929) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message7929) ProtoMessage() {}
+
+func (x *Message7929) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[37]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message7929.ProtoReflect.Descriptor instead.
+func (*Message7929) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{37}
+}
+
+func (x *Message7929) GetField7942() int64 {
+	if x != nil && x.Field7942 != nil {
+		return *x.Field7942
+	}
+	return 0
+}
+
+func (x *Message7929) GetField7943() int64 {
+	if x != nil && x.Field7943 != nil {
+		return *x.Field7943
+	}
+	return 0
+}
+
+func (x *Message7929) GetField7944() int64 {
+	if x != nil && x.Field7944 != nil {
+		return *x.Field7944
+	}
+	return 0
+}
+
+func (x *Message7929) GetField7945() int64 {
+	if x != nil && x.Field7945 != nil {
+		return *x.Field7945
+	}
+	return 0
+}
+
+func (x *Message7929) GetField7946() int64 {
+	if x != nil && x.Field7946 != nil {
+		return *x.Field7946
+	}
+	return 0
+}
+
+func (x *Message7929) GetField7947() int64 {
+	if x != nil && x.Field7947 != nil {
+		return *x.Field7947
+	}
+	return 0
+}
+
+func (x *Message7929) GetField7948() int64 {
+	if x != nil && x.Field7948 != nil {
+		return *x.Field7948
+	}
+	return 0
+}
+
+func (x *Message7929) GetField7949() int64 {
+	if x != nil && x.Field7949 != nil {
+		return *x.Field7949
+	}
+	return 0
+}
+
+func (x *Message7929) GetField7950() []*Message7919 {
+	if x != nil {
+		return x.Field7950
+	}
+	return nil
+}
+
+func (x *Message7929) GetField7951() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field7951
+	}
+	return nil
+}
+
+func (x *Message7929) GetField7952() []*Message7920 {
+	if x != nil {
+		return x.Field7952
+	}
+	return nil
+}
+
+func (x *Message7929) GetField7953() []*Message7921 {
+	if x != nil {
+		return x.Field7953
+	}
+	return nil
+}
+
+func (x *Message7929) GetField7954() []*Message7928 {
+	if x != nil {
+		return x.Field7954
+	}
+	return nil
+}
+
+func (x *Message7929) GetField7955() int64 {
+	if x != nil && x.Field7955 != nil {
+		return *x.Field7955
+	}
+	return 0
+}
+
+func (x *Message7929) GetField7956() bool {
+	if x != nil && x.Field7956 != nil {
+		return *x.Field7956
+	}
+	return false
+}
+
+func (x *Message7929) GetField7957() int64 {
+	if x != nil && x.Field7957 != nil {
+		return *x.Field7957
+	}
+	return 0
+}
+
+func (x *Message7929) GetField7958() int64 {
+	if x != nil && x.Field7958 != nil {
+		return *x.Field7958
+	}
+	return 0
+}
+
+func (x *Message7929) GetField7959() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field7959
+	}
+	return nil
+}
+
+func (x *Message7929) GetField7960() [][]byte {
+	if x != nil {
+		return x.Field7960
+	}
+	return nil
+}
+
+func (x *Message7929) GetField7961() int64 {
+	if x != nil && x.Field7961 != nil {
+		return *x.Field7961
+	}
+	return 0
+}
+
+type Message3061_Message3062 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field3335 *int32 `protobuf:"varint,5,req,name=field3335" json:"field3335,omitempty"`
+	Field3336 *int32 `protobuf:"varint,6,opt,name=field3336" json:"field3336,omitempty"`
+	Field3337 *int32 `protobuf:"varint,7,opt,name=field3337" json:"field3337,omitempty"`
+}
+
+func (x *Message3061_Message3062) Reset() {
+	*x = Message3061_Message3062{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[38]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message3061_Message3062) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message3061_Message3062) ProtoMessage() {}
+
+func (x *Message3061_Message3062) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[38]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message3061_Message3062.ProtoReflect.Descriptor instead.
+func (*Message3061_Message3062) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{5, 0}
+}
+
+func (x *Message3061_Message3062) GetField3335() int32 {
+	if x != nil && x.Field3335 != nil {
+		return *x.Field3335
+	}
+	return 0
+}
+
+func (x *Message3061_Message3062) GetField3336() int32 {
+	if x != nil && x.Field3336 != nil {
+		return *x.Field3336
+	}
+	return 0
+}
+
+func (x *Message3061_Message3062) GetField3337() int32 {
+	if x != nil && x.Field3337 != nil {
+		return *x.Field3337
+	}
+	return 0
+}
+
+type Message3061_Message3063 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field3338 *int32    `protobuf:"varint,14,req,name=field3338" json:"field3338,omitempty"`
+	Field3339 *Enum2851 `protobuf:"varint,18,opt,name=field3339,enum=benchmarks.google_message4.Enum2851" json:"field3339,omitempty"`
+	Field3340 *int64    `protobuf:"varint,15,opt,name=field3340" json:"field3340,omitempty"`
+	Field3341 *int64    `protobuf:"varint,23,opt,name=field3341" json:"field3341,omitempty"`
+}
+
+func (x *Message3061_Message3063) Reset() {
+	*x = Message3061_Message3063{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[39]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message3061_Message3063) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message3061_Message3063) ProtoMessage() {}
+
+func (x *Message3061_Message3063) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[39]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message3061_Message3063.ProtoReflect.Descriptor instead.
+func (*Message3061_Message3063) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{5, 1}
+}
+
+func (x *Message3061_Message3063) GetField3338() int32 {
+	if x != nil && x.Field3338 != nil {
+		return *x.Field3338
+	}
+	return 0
+}
+
+func (x *Message3061_Message3063) GetField3339() Enum2851 {
+	if x != nil && x.Field3339 != nil {
+		return *x.Field3339
+	}
+	return Enum2851_ENUM_VALUE2852
+}
+
+func (x *Message3061_Message3063) GetField3340() int64 {
+	if x != nil && x.Field3340 != nil {
+		return *x.Field3340
+	}
+	return 0
+}
+
+func (x *Message3061_Message3063) GetField3341() int64 {
+	if x != nil && x.Field3341 != nil {
+		return *x.Field3341
+	}
+	return 0
+}
+
+type Message3061_Message3064 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field3342 *Enum2602           `protobuf:"varint,9,req,name=field3342,enum=benchmarks.google_message4.Enum2602" json:"field3342,omitempty"`
+	Field3343 *int32              `protobuf:"varint,92,opt,name=field3343" json:"field3343,omitempty"`
+	Field3344 *string             `protobuf:"bytes,10,opt,name=field3344" json:"field3344,omitempty"`
+	Field3345 []byte              `protobuf:"bytes,11,opt,name=field3345" json:"field3345,omitempty"`
+	Field3346 *int32              `protobuf:"varint,12,opt,name=field3346" json:"field3346,omitempty"`
+	Field3347 *Message3060        `protobuf:"bytes,98,opt,name=field3347" json:"field3347,omitempty"`
+	Field3348 *UnusedEmptyMessage `protobuf:"bytes,82,opt,name=field3348" json:"field3348,omitempty"`
+	Field3349 *Message3050        `protobuf:"bytes,80,opt,name=field3349" json:"field3349,omitempty"`
+	Field3350 *uint64             `protobuf:"fixed64,52,opt,name=field3350" json:"field3350,omitempty"`
+	Field3351 *int32              `protobuf:"varint,33,opt,name=field3351" json:"field3351,omitempty"`
+	Field3352 *string             `protobuf:"bytes,42,opt,name=field3352" json:"field3352,omitempty"`
+	Field3353 *string             `protobuf:"bytes,69,opt,name=field3353" json:"field3353,omitempty"`
+	Field3354 []byte              `protobuf:"bytes,43,opt,name=field3354" json:"field3354,omitempty"`
+	Field3355 *Enum2806           `protobuf:"varint,73,opt,name=field3355,enum=benchmarks.google_message4.Enum2806" json:"field3355,omitempty"`
+	Field3356 *int32              `protobuf:"varint,74,opt,name=field3356" json:"field3356,omitempty"`
+	Field3357 *int32              `protobuf:"varint,90,opt,name=field3357" json:"field3357,omitempty"`
+	Field3358 []byte              `protobuf:"bytes,79,opt,name=field3358" json:"field3358,omitempty"`
+	Field3359 *int32              `protobuf:"varint,19,opt,name=field3359" json:"field3359,omitempty"`
+	Field3360 *Enum2834           `protobuf:"varint,95,opt,name=field3360,enum=benchmarks.google_message4.Enum2834" json:"field3360,omitempty"`
+}
+
+func (x *Message3061_Message3064) Reset() {
+	*x = Message3061_Message3064{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[40]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message3061_Message3064) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message3061_Message3064) ProtoMessage() {}
+
+func (x *Message3061_Message3064) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[40]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message3061_Message3064.ProtoReflect.Descriptor instead.
+func (*Message3061_Message3064) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{5, 2}
+}
+
+func (x *Message3061_Message3064) GetField3342() Enum2602 {
+	if x != nil && x.Field3342 != nil {
+		return *x.Field3342
+	}
+	return Enum2602_ENUM_VALUE2603
+}
+
+func (x *Message3061_Message3064) GetField3343() int32 {
+	if x != nil && x.Field3343 != nil {
+		return *x.Field3343
+	}
+	return 0
+}
+
+func (x *Message3061_Message3064) GetField3344() string {
+	if x != nil && x.Field3344 != nil {
+		return *x.Field3344
+	}
+	return ""
+}
+
+func (x *Message3061_Message3064) GetField3345() []byte {
+	if x != nil {
+		return x.Field3345
+	}
+	return nil
+}
+
+func (x *Message3061_Message3064) GetField3346() int32 {
+	if x != nil && x.Field3346 != nil {
+		return *x.Field3346
+	}
+	return 0
+}
+
+func (x *Message3061_Message3064) GetField3347() *Message3060 {
+	if x != nil {
+		return x.Field3347
+	}
+	return nil
+}
+
+func (x *Message3061_Message3064) GetField3348() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field3348
+	}
+	return nil
+}
+
+func (x *Message3061_Message3064) GetField3349() *Message3050 {
+	if x != nil {
+		return x.Field3349
+	}
+	return nil
+}
+
+func (x *Message3061_Message3064) GetField3350() uint64 {
+	if x != nil && x.Field3350 != nil {
+		return *x.Field3350
+	}
+	return 0
+}
+
+func (x *Message3061_Message3064) GetField3351() int32 {
+	if x != nil && x.Field3351 != nil {
+		return *x.Field3351
+	}
+	return 0
+}
+
+func (x *Message3061_Message3064) GetField3352() string {
+	if x != nil && x.Field3352 != nil {
+		return *x.Field3352
+	}
+	return ""
+}
+
+func (x *Message3061_Message3064) GetField3353() string {
+	if x != nil && x.Field3353 != nil {
+		return *x.Field3353
+	}
+	return ""
+}
+
+func (x *Message3061_Message3064) GetField3354() []byte {
+	if x != nil {
+		return x.Field3354
+	}
+	return nil
+}
+
+func (x *Message3061_Message3064) GetField3355() Enum2806 {
+	if x != nil && x.Field3355 != nil {
+		return *x.Field3355
+	}
+	return Enum2806_ENUM_VALUE2807
+}
+
+func (x *Message3061_Message3064) GetField3356() int32 {
+	if x != nil && x.Field3356 != nil {
+		return *x.Field3356
+	}
+	return 0
+}
+
+func (x *Message3061_Message3064) GetField3357() int32 {
+	if x != nil && x.Field3357 != nil {
+		return *x.Field3357
+	}
+	return 0
+}
+
+func (x *Message3061_Message3064) GetField3358() []byte {
+	if x != nil {
+		return x.Field3358
+	}
+	return nil
+}
+
+func (x *Message3061_Message3064) GetField3359() int32 {
+	if x != nil && x.Field3359 != nil {
+		return *x.Field3359
+	}
+	return 0
+}
+
+func (x *Message3061_Message3064) GetField3360() Enum2834 {
+	if x != nil && x.Field3360 != nil {
+		return *x.Field3360
+	}
+	return Enum2834_ENUM_VALUE2835
+}
+
+type Message3061_Message3065 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message3061_Message3065) Reset() {
+	*x = Message3061_Message3065{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[41]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message3061_Message3065) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message3061_Message3065) ProtoMessage() {}
+
+func (x *Message3061_Message3065) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[41]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message3061_Message3065.ProtoReflect.Descriptor instead.
+func (*Message3061_Message3065) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{5, 3}
+}
+
+type Message3061_Message3066 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field3366 *int32              `protobuf:"varint,22,opt,name=field3366" json:"field3366,omitempty"`
+	Field3367 *int32              `protobuf:"varint,55,opt,name=field3367" json:"field3367,omitempty"`
+	Field3368 *int32              `protobuf:"varint,88,opt,name=field3368" json:"field3368,omitempty"`
+	Field3369 *int32              `protobuf:"varint,56,opt,name=field3369" json:"field3369,omitempty"`
+	Field3370 *int32              `protobuf:"varint,75,opt,name=field3370" json:"field3370,omitempty"`
+	Field3371 *int32              `protobuf:"varint,57,opt,name=field3371" json:"field3371,omitempty"`
+	Field3372 *UnusedEmptyMessage `protobuf:"bytes,85,opt,name=field3372" json:"field3372,omitempty"`
+	Field3373 *UnusedEmptyMessage `protobuf:"bytes,96,opt,name=field3373" json:"field3373,omitempty"`
+}
+
+func (x *Message3061_Message3066) Reset() {
+	*x = Message3061_Message3066{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[42]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message3061_Message3066) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message3061_Message3066) ProtoMessage() {}
+
+func (x *Message3061_Message3066) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[42]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message3061_Message3066.ProtoReflect.Descriptor instead.
+func (*Message3061_Message3066) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{5, 4}
+}
+
+func (x *Message3061_Message3066) GetField3366() int32 {
+	if x != nil && x.Field3366 != nil {
+		return *x.Field3366
+	}
+	return 0
+}
+
+func (x *Message3061_Message3066) GetField3367() int32 {
+	if x != nil && x.Field3367 != nil {
+		return *x.Field3367
+	}
+	return 0
+}
+
+func (x *Message3061_Message3066) GetField3368() int32 {
+	if x != nil && x.Field3368 != nil {
+		return *x.Field3368
+	}
+	return 0
+}
+
+func (x *Message3061_Message3066) GetField3369() int32 {
+	if x != nil && x.Field3369 != nil {
+		return *x.Field3369
+	}
+	return 0
+}
+
+func (x *Message3061_Message3066) GetField3370() int32 {
+	if x != nil && x.Field3370 != nil {
+		return *x.Field3370
+	}
+	return 0
+}
+
+func (x *Message3061_Message3066) GetField3371() int32 {
+	if x != nil && x.Field3371 != nil {
+		return *x.Field3371
+	}
+	return 0
+}
+
+func (x *Message3061_Message3066) GetField3372() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field3372
+	}
+	return nil
+}
+
+func (x *Message3061_Message3066) GetField3373() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field3373
+	}
+	return nil
+}
+
+type Message3886_Message3887 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field3932 *string      `protobuf:"bytes,2,req,name=field3932" json:"field3932,omitempty"`
+	Field3933 *string      `protobuf:"bytes,9,opt,name=field3933" json:"field3933,omitempty"`
+	Field3934 *Message3850 `protobuf:"bytes,3,opt,name=field3934" json:"field3934,omitempty"`
+	Field3935 []byte       `protobuf:"bytes,8,opt,name=field3935" json:"field3935,omitempty"`
+}
+
+func (x *Message3886_Message3887) Reset() {
+	*x = Message3886_Message3887{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[43]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message3886_Message3887) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message3886_Message3887) ProtoMessage() {}
+
+func (x *Message3886_Message3887) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[43]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message3886_Message3887.ProtoReflect.Descriptor instead.
+func (*Message3886_Message3887) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP(), []int{30, 0}
+}
+
+func (x *Message3886_Message3887) GetField3932() string {
+	if x != nil && x.Field3932 != nil {
+		return *x.Field3932
+	}
+	return ""
+}
+
+func (x *Message3886_Message3887) GetField3933() string {
+	if x != nil && x.Field3933 != nil {
+		return *x.Field3933
+	}
+	return ""
+}
+
+func (x *Message3886_Message3887) GetField3934() *Message3850 {
+	if x != nil {
+		return x.Field3934
+	}
+	return nil
+}
+
+func (x *Message3886_Message3887) GetField3935() []byte {
+	if x != nil {
+		return x.Field3935
+	}
+	return nil
+}
+
+var File_datasets_google_message4_benchmark_message4_1_proto protoreflect.FileDescriptor
+
+var file_datasets_google_message4_benchmark_message4_1_proto_rawDesc = []byte{
+	0x0a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x5f, 0x31, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1a, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x34, 0x1a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2f, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x5f, 0x32,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73,
+	0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34,
+	0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x34, 0x5f, 0x33, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x54, 0x0a, 0x0b, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x36, 0x33, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x34, 0x39, 0x38, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x32, 0x34, 0x36, 0x32, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x39,
+	0x38, 0x22, 0x78, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x36, 0x38,
+	0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x36, 0x39, 0x39, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x36, 0x39,
+	0x39, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x30, 0x30, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x36, 0x38, 0x35, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x30, 0x30, 0x22, 0x0e, 0x0a, 0x0c, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x31, 0x39, 0x34, 0x39, 0x22, 0xf4, 0x03, 0x0a, 0x0c,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x31, 0x39, 0x37, 0x35, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x39, 0x39, 0x32, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x39, 0x39, 0x32, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x39, 0x39, 0x33, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x39, 0x39, 0x33, 0x12, 0x48, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x39, 0x39, 0x34, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x33, 0x32, 0x30, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x31, 0x39, 0x39, 0x34, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x31, 0x39, 0x39, 0x35, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31,
+	0x31, 0x39, 0x34, 0x37, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x39, 0x39, 0x35,
+	0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x39, 0x39, 0x36, 0x18, 0x05,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x31, 0x39, 0x32, 0x30, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x39, 0x39, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x31, 0x39, 0x39, 0x37, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x39, 0x39, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x31, 0x39, 0x39, 0x38, 0x18, 0x07, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x39, 0x39, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x31, 0x39, 0x39, 0x39, 0x18, 0x08, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x39, 0x39, 0x39, 0x12, 0x46, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x30, 0x30, 0x30, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x26,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73,
+	0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x30,
+	0x30, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x30, 0x30, 0x31,
+	0x18, 0x0b, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x30,
+	0x30, 0x31, 0x22, 0x85, 0x04, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x32,
+	0x38, 0x37, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x33, 0x31, 0x31, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x31, 0x33, 0x33, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x33, 0x31, 0x31, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x37, 0x33, 0x31, 0x32, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64,
+	0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x33, 0x31, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x37, 0x33, 0x31, 0x33, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x33, 0x31, 0x33, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x33,
+	0x31, 0x34, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x36, 0x34,
+	0x33, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x33, 0x31, 0x34, 0x12, 0x42, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x33, 0x31, 0x35, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32,
+	0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e, 0x75,
+	0x6d, 0x37, 0x32, 0x38, 0x38, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x33, 0x31, 0x35,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x33, 0x31, 0x36, 0x18, 0x06, 0x20,
+	0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x33, 0x31, 0x36, 0x12, 0x4c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x33, 0x31, 0x37, 0x18, 0x07, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55,
+	0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x33, 0x31, 0x37, 0x12, 0x4c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x33, 0x31, 0x38, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x33, 0x31, 0x38, 0x22, 0xe6, 0x1d, 0x0a, 0x0b, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x30, 0x36, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x32, 0x38, 0x36, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x38, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x32, 0x38, 0x37, 0x18, 0x4d, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x32, 0x38, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x32, 0x38, 0x38, 0x18, 0x31, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x32, 0x38, 0x38, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x38,
+	0x39, 0x18, 0x03, 0x20, 0x02, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x30, 0x34, 0x36,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x38, 0x39, 0x12, 0x45, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x39, 0x30, 0x18, 0x3a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x33, 0x30, 0x34, 0x36, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32,
+	0x39, 0x30, 0x12, 0x55, 0x0a, 0x0b, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x30, 0x36,
+	0x32, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0a, 0x32, 0x33, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x30, 0x36, 0x31,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x30, 0x36, 0x32, 0x52, 0x0b, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x30, 0x36, 0x32, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x32, 0x39, 0x32, 0x18, 0x68, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x30, 0x36, 0x30, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x39, 0x32,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x39, 0x33, 0x18, 0x20, 0x20,
+	0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x39, 0x33, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x39, 0x34, 0x18, 0x29, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x39, 0x34, 0x12, 0x55, 0x0a, 0x0b,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x30, 0x36, 0x33, 0x18, 0x0d, 0x20, 0x01, 0x28,
+	0x0a, 0x32, 0x33, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x30, 0x36, 0x31, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x30, 0x36, 0x33, 0x52, 0x0b, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x30, 0x36, 0x33, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x39, 0x36,
+	0x18, 0x5e, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x32, 0x38, 0x33, 0x34, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x32, 0x39, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x32, 0x39, 0x37, 0x18, 0x19, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x32, 0x39, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32,
+	0x39, 0x38, 0x18, 0x32, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x32, 0x39, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x39, 0x39,
+	0x18, 0x59, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x39,
+	0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x30, 0x30, 0x18, 0x5b,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x30, 0x30, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x30, 0x31, 0x18, 0x69, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x30, 0x31, 0x12, 0x45, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x30, 0x32, 0x18, 0x35, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x30, 0x35, 0x30, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x33, 0x30, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x30,
+	0x33, 0x18, 0x33, 0x20, 0x01, 0x28, 0x06, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33,
+	0x30, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x30, 0x34, 0x18,
+	0x6a, 0x20, 0x01, 0x28, 0x06, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x30, 0x34,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x30, 0x35, 0x18, 0x3c, 0x20,
+	0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x30, 0x35, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x30, 0x36, 0x18, 0x2c, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x30, 0x36, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x30, 0x37, 0x18, 0x51, 0x20, 0x01, 0x28, 0x0c, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x30, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x33, 0x30, 0x38, 0x18, 0x46, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x30, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x33, 0x30, 0x39, 0x18, 0x2d, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x33, 0x30, 0x39, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x33, 0x31, 0x30, 0x18, 0x47, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x32, 0x38, 0x30, 0x36, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x31, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x33, 0x31, 0x31, 0x18, 0x48, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x31, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x33, 0x31, 0x32, 0x18, 0x4e, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x33, 0x31, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x33, 0x31, 0x33, 0x18, 0x14, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x33, 0x31, 0x33, 0x12, 0x55, 0x0a, 0x0b, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x30, 0x36, 0x34, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0a, 0x32, 0x33, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x30,
+	0x36, 0x31, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x30, 0x36, 0x34, 0x52, 0x0b,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x30, 0x36, 0x34, 0x12, 0x4c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x31, 0x35, 0x18, 0x27, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73,
+	0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x31, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x33, 0x31, 0x36, 0x18, 0x4c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x33, 0x31, 0x36, 0x12, 0x55, 0x0a, 0x0b, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x30, 0x36, 0x35, 0x18, 0x3f, 0x20, 0x01, 0x28, 0x0a, 0x32, 0x33, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x30, 0x36, 0x31, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x30, 0x36,
+	0x35, 0x52, 0x0b, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x30, 0x36, 0x35, 0x12, 0x42,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x31, 0x38, 0x18, 0x36, 0x20, 0x01, 0x28,
+	0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x45,
+	0x6e, 0x75, 0x6d, 0x32, 0x38, 0x30, 0x36, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33,
+	0x31, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x31, 0x39, 0x18,
+	0x2e, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x31, 0x39,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x32, 0x30, 0x18, 0x18, 0x20,
+	0x03, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x32, 0x30, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x32, 0x31, 0x18, 0x26, 0x20, 0x01, 0x28,
+	0x07, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x32, 0x31, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x32, 0x32, 0x18, 0x63, 0x20, 0x01, 0x28, 0x0c, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x32, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x33, 0x32, 0x33, 0x18, 0x01, 0x20, 0x01, 0x28, 0x06, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x32, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x33, 0x32, 0x34, 0x18, 0x61, 0x20, 0x01, 0x28, 0x06, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x33, 0x32, 0x34, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x33, 0x32, 0x35, 0x18, 0x10, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x30,
+	0x34, 0x30, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x32, 0x35, 0x12, 0x45, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x32, 0x36, 0x18, 0x3d, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x30, 0x34, 0x31, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x33, 0x32, 0x36, 0x12, 0x55, 0x0a, 0x0b, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x30, 0x36, 0x36, 0x18, 0x15, 0x20, 0x01, 0x28, 0x0a, 0x32, 0x33, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x30,
+	0x36, 0x31, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x30, 0x36, 0x36, 0x52, 0x0b,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x30, 0x36, 0x36, 0x12, 0x4c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x32, 0x38, 0x18, 0x2f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73,
+	0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x32, 0x38, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x33, 0x32, 0x39, 0x18, 0x30, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64,
+	0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x33, 0x32, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x33, 0x33, 0x30, 0x18, 0x28, 0x20, 0x01, 0x28, 0x06, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x33, 0x33, 0x30, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33,
+	0x33, 0x31, 0x18, 0x56, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74,
+	0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x33, 0x33, 0x31, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x33, 0x32,
+	0x18, 0x3b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x33,
+	0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x33, 0x33, 0x18, 0x11,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x33, 0x33, 0x1a,
+	0x67, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x30, 0x36, 0x32, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x33, 0x35, 0x18, 0x05, 0x20, 0x02, 0x28,
+	0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x33, 0x35, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x33, 0x36, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x33, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x33, 0x33, 0x37, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x33, 0x37, 0x1a, 0xab, 0x01, 0x0a, 0x0b, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x30, 0x36, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x33, 0x33, 0x38, 0x18, 0x0e, 0x20, 0x02, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x33, 0x33, 0x38, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x33, 0x33, 0x39, 0x18, 0x12, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x32, 0x38, 0x35, 0x31, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x33, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x33, 0x34, 0x30, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x34, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x33, 0x34, 0x31, 0x18, 0x17, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x33, 0x34, 0x31, 0x1a, 0xbb, 0x06, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x30, 0x36, 0x34, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x33, 0x34, 0x32, 0x18, 0x09, 0x20, 0x02, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x32, 0x36, 0x30, 0x32, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x34, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x33, 0x34, 0x33, 0x18, 0x5c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x34, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x33, 0x34, 0x34, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x33, 0x34, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x33, 0x34, 0x35, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x33, 0x34, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x34,
+	0x36, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33,
+	0x34, 0x36, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x34, 0x37, 0x18,
+	0x62, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x30, 0x36, 0x30, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x34, 0x37, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x33, 0x34, 0x38, 0x18, 0x52, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64,
+	0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x33, 0x34, 0x38, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x33, 0x34, 0x39, 0x18, 0x50, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x30, 0x35, 0x30, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x34, 0x39, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x35, 0x30, 0x18, 0x34, 0x20, 0x01, 0x28,
+	0x06, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x35, 0x30, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x35, 0x31, 0x18, 0x21, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x35, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x33, 0x35, 0x32, 0x18, 0x2a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x35, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x33, 0x35, 0x33, 0x18, 0x45, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x33, 0x35, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x33, 0x35, 0x34, 0x18, 0x2b, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x33, 0x35, 0x34, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x35,
+	0x35, 0x18, 0x49, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x32, 0x38, 0x30, 0x36, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x35, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x33, 0x35, 0x36, 0x18, 0x4a, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x33, 0x35, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x33, 0x35, 0x37, 0x18, 0x5a, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x33, 0x35, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x35,
+	0x38, 0x18, 0x4f, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33,
+	0x35, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x35, 0x39, 0x18,
+	0x13, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x35, 0x39,
+	0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x36, 0x30, 0x18, 0x5f, 0x20,
+	0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34,
+	0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x32, 0x38, 0x33, 0x34, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x33, 0x36, 0x30, 0x1a, 0x0d, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x30, 0x36, 0x35, 0x1a, 0xdd, 0x02, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x30, 0x36, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x36, 0x36,
+	0x18, 0x16, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x36,
+	0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x36, 0x37, 0x18, 0x37,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x36, 0x37, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x36, 0x38, 0x18, 0x58, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x36, 0x38, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x36, 0x39, 0x18, 0x38, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x36, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x37, 0x30, 0x18, 0x4b, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33, 0x37, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x33, 0x37, 0x31, 0x18, 0x39, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x33, 0x37, 0x31, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x33, 0x37, 0x32, 0x18, 0x55, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d,
+	0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x33, 0x37, 0x32, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x33,
+	0x37, 0x33, 0x18, 0x60, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74,
+	0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x33, 0x37, 0x33, 0x22, 0x0e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32,
+	0x39, 0x34, 0x39, 0x22, 0x80, 0x12, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38,
+	0x35, 0x37, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x34, 0x37,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x34,
+	0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x34, 0x38, 0x18, 0x03,
+	0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x34, 0x38, 0x12,
+	0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x34, 0x39, 0x18, 0x04, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x38, 0x38, 0x36, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x36, 0x34, 0x39, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x36, 0x35, 0x30, 0x18, 0x39, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x39,
+	0x31, 0x39, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x35, 0x30, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x35, 0x31, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x35, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x35, 0x32, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x35, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x36, 0x35, 0x33, 0x18, 0x31, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x36, 0x35, 0x33, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x36, 0x35, 0x34, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37,
+	0x39, 0x30, 0x35, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x35, 0x34, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x35, 0x35, 0x18, 0x0a, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x35, 0x35, 0x12, 0x4c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x35, 0x36, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x35, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x36, 0x35, 0x37, 0x18, 0x23, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x35, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x36, 0x35, 0x38, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x36, 0x35, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x36, 0x35, 0x39, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x36, 0x35, 0x39, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x36,
+	0x30, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36,
+	0x36, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x36, 0x31, 0x18,
+	0x0f, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x36, 0x31,
+	0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x36, 0x32, 0x18, 0x11, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34,
+	0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x36, 0x32, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x36, 0x33, 0x18, 0x12, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x36, 0x33, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x36, 0x34, 0x18, 0x13, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x36, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x36, 0x36, 0x35, 0x18, 0x14, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x36, 0x35, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x36, 0x36, 0x36, 0x18, 0x1f, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x33, 0x34, 0x37,
+	0x36, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x36, 0x36, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x36, 0x37, 0x18, 0x24, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x36, 0x37, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x36, 0x36, 0x38, 0x18, 0x27, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65,
+	0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x36, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x36, 0x36, 0x39, 0x18, 0x16, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x36, 0x36, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x36, 0x37, 0x30, 0x18, 0x18, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x36, 0x37, 0x30, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x37,
+	0x31, 0x18, 0x19, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x30, 0x35, 0x32,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x37, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x37, 0x32, 0x18, 0x1a, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x37, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x36, 0x37, 0x33, 0x18, 0x1c, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x36, 0x37, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x36, 0x37, 0x34, 0x18, 0x1d, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x36, 0x37, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36,
+	0x37, 0x35, 0x18, 0x1e, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x36, 0x37, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x37, 0x36,
+	0x18, 0x20, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x37,
+	0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x37, 0x37, 0x18, 0x21,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x37, 0x37, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x37, 0x38, 0x18, 0x22, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x37, 0x38, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x37, 0x39, 0x18, 0x25, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x37, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x38, 0x30, 0x18, 0x26, 0x20, 0x01, 0x28, 0x01, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x38, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x36, 0x38, 0x31, 0x18, 0x2a, 0x20, 0x01, 0x28, 0x01, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x36, 0x38, 0x31, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x36, 0x38, 0x32, 0x18, 0x28, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x39, 0x32, 0x32, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x38, 0x32, 0x12, 0x4c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x38, 0x33, 0x18, 0x2b, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55,
+	0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x38, 0x33, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x38, 0x34, 0x18, 0x2c, 0x20, 0x01, 0x28, 0x03, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x38, 0x34, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x36, 0x38, 0x35, 0x18, 0x2d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x37, 0x39, 0x32, 0x39, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x38,
+	0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x38, 0x36, 0x18, 0x2e,
+	0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x38, 0x36, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x38, 0x37, 0x18, 0x30, 0x20, 0x01,
+	0x28, 0x0d, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x38, 0x37, 0x12, 0x45, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x38, 0x38, 0x18, 0x2f, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x38, 0x34, 0x33, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x36, 0x38, 0x38, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x38,
+	0x39, 0x18, 0x32, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x38, 0x36, 0x34,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x38, 0x39, 0x12, 0x4c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x39, 0x30, 0x18, 0x34, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73,
+	0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x39, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x36, 0x39, 0x31, 0x18, 0x3a, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x38, 0x36, 0x39, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x36, 0x39, 0x32, 0x18, 0x36, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x38, 0x36, 0x39, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36,
+	0x39, 0x33, 0x18, 0x37, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x36, 0x39, 0x33, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x39, 0x34,
+	0x18, 0x29, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x39,
+	0x34, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x39, 0x35, 0x18, 0x35,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x39, 0x35, 0x12,
+	0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x36, 0x39, 0x36, 0x18, 0x3d, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x35, 0x37, 0x35, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x38, 0x36, 0x39, 0x36, 0x22, 0xa3, 0x01, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x38, 0x37, 0x37, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38,
+	0x38, 0x31, 0x30, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x38, 0x38, 0x31, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x31,
+	0x31, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38,
+	0x31, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x31, 0x32, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x31, 0x32,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x31, 0x33, 0x18, 0x04, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x31, 0x33, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x31, 0x34, 0x18, 0x05, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x38, 0x38, 0x31, 0x34, 0x22, 0xfc, 0x03, 0x0a,
+	0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x37, 0x37, 0x36, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x38, 0x36, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x38, 0x36, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x38, 0x37, 0x18, 0x0b, 0x20, 0x01, 0x28,
+	0x06, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x38, 0x37, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x38, 0x38, 0x18, 0x06, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x38, 0x38, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x38, 0x39, 0x18, 0x0d, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x38, 0x39, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x39, 0x30, 0x18, 0x0e, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x39, 0x30, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x39, 0x31, 0x18, 0x0f, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x39, 0x31, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x39, 0x32, 0x18, 0x10, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x39, 0x32, 0x12, 0x4e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x39, 0x33, 0x18, 0x08, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55,
+	0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x39, 0x33, 0x12, 0x48, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x37, 0x39, 0x34, 0x18, 0x0a, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x37, 0x37, 0x34, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x37, 0x39, 0x34, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x37, 0x39, 0x35, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45,
+	0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x37, 0x39, 0x35, 0x2a, 0x04, 0x08, 0x02, 0x10, 0x03, 0x2a, 0x04, 0x08,
+	0x03, 0x10, 0x04, 0x2a, 0x04, 0x08, 0x04, 0x10, 0x05, 0x2a, 0x04, 0x08, 0x05, 0x10, 0x06, 0x2a,
+	0x04, 0x08, 0x07, 0x10, 0x08, 0x2a, 0x04, 0x08, 0x09, 0x10, 0x0a, 0x22, 0xb8, 0x01, 0x0a, 0x0c,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x37, 0x39, 0x38, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x30, 0x35, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x30, 0x35, 0x12, 0x1e, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x30, 0x36, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x30, 0x36, 0x12, 0x48, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x30, 0x37, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x37, 0x37, 0x34, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x32, 0x38, 0x30, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x38, 0x30, 0x38, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x32, 0x38, 0x30, 0x38, 0x22, 0xc2, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x31, 0x32, 0x37, 0x39, 0x37, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x38, 0x30, 0x32, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x31, 0x32, 0x37, 0x39, 0x36, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x30,
+	0x32, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x30, 0x33, 0x18,
+	0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x37, 0x39, 0x36, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x30, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x30, 0x34, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x30, 0x34, 0x22, 0xc6, 0x03, 0x0a, 0x0c,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x38, 0x32, 0x35, 0x12, 0x48, 0x0a, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x36, 0x32, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x38, 0x31, 0x38, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x32, 0x38, 0x36, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x38, 0x36, 0x33, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x32, 0x38, 0x36, 0x33, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x38, 0x36, 0x34, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31,
+	0x32, 0x38, 0x31, 0x39, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x36, 0x34,
+	0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x36, 0x35, 0x18, 0x04,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x38, 0x32, 0x30, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x36, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x36, 0x36, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x36, 0x36, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x36, 0x37, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x31, 0x32, 0x38, 0x32, 0x31, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x38, 0x36, 0x37, 0x12, 0x4e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38,
+	0x36, 0x38, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74,
+	0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x32, 0x38, 0x36, 0x38, 0x22, 0x0d, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38,
+	0x35, 0x39, 0x30, 0x22, 0x0d, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x35,
+	0x38, 0x37, 0x22, 0x49, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x33, 0x37,
+	0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x37, 0x35, 0x18, 0x01,
+	0x20, 0x02, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x37, 0x35, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x37, 0x36, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x37, 0x36, 0x22, 0x49, 0x0a,
+	0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x34, 0x36, 0x32, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x39, 0x36, 0x18, 0x01, 0x20, 0x02, 0x28, 0x0c, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x39, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x32, 0x34, 0x39, 0x37, 0x18, 0x02, 0x20, 0x02, 0x28, 0x01, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x32, 0x34, 0x39, 0x37, 0x22, 0xee, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x36, 0x38, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x36, 0x39, 0x32, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x36, 0x39, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x36, 0x39, 0x33, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x36, 0x39, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x36, 0x39, 0x34, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x36, 0x39, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x36, 0x39, 0x35, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x36, 0x39, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x36, 0x39, 0x36, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x36, 0x39, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x36, 0x39, 0x37, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x36, 0x39, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x36, 0x39, 0x38, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x36, 0x39, 0x38, 0x22, 0xe6, 0x02, 0x0a, 0x0c, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x33, 0x32, 0x30, 0x12, 0x45, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x37, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e, 0x75, 0x6d,
+	0x31, 0x30, 0x33, 0x33, 0x35, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x34,
+	0x37, 0x12, 0x48, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x38, 0x18,
+	0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x30, 0x33, 0x31, 0x39, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x39, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x35, 0x30, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x35, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x35, 0x31, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x35, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x35, 0x32, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x35, 0x32, 0x12, 0x45, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x35, 0x33, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0e, 0x32,
+	0x25, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e, 0x75,
+	0x6d, 0x31, 0x30, 0x33, 0x33, 0x37, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33,
+	0x35, 0x33, 0x22, 0x6e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x31, 0x39,
+	0x34, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x39, 0x35, 0x31,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x39,
+	0x35, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x39, 0x35, 0x32,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x39,
+	0x35, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x39, 0x35, 0x33,
+	0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x39,
+	0x35, 0x33, 0x22, 0x9d, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x31,
+	0x39, 0x32, 0x30, 0x12, 0x45, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x39, 0x34,
+	0x35, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x31, 0x39, 0x30, 0x31, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x39, 0x34, 0x35, 0x12, 0x46, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x31, 0x39, 0x34, 0x36, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73,
+	0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x31, 0x39,
+	0x34, 0x36, 0x22, 0xea, 0x06, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x36,
+	0x34, 0x33, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x38, 0x33, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x38, 0x33,
+	0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x38, 0x34, 0x18, 0x04, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34,
+	0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x38, 0x34, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x38, 0x35, 0x18, 0x05, 0x20, 0x01, 0x28,
+	0x01, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x38, 0x35, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x38, 0x36, 0x18, 0x06, 0x20, 0x01, 0x28, 0x01, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x38, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x36, 0x36, 0x38, 0x37, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x38, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x36, 0x36, 0x38, 0x38, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x36, 0x36, 0x38, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36,
+	0x36, 0x38, 0x39, 0x18, 0x09, 0x20, 0x01, 0x28, 0x01, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x36, 0x36, 0x38, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x39,
+	0x30, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36,
+	0x39, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x39, 0x31, 0x18,
+	0x0b, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x39, 0x31,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x39, 0x32, 0x18, 0x0c, 0x20,
+	0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x39, 0x32, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x39, 0x33, 0x18, 0x0d, 0x20, 0x01, 0x28,
+	0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x39, 0x33, 0x12, 0x45, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x39, 0x34, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x36, 0x35, 0x37, 0x38, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36,
+	0x36, 0x39, 0x34, 0x12, 0x44, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x39, 0x35,
+	0x18, 0x10, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x39, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x36, 0x36, 0x39, 0x36, 0x18, 0x11, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x36, 0x36, 0x39, 0x36, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x36, 0x36, 0x39, 0x37, 0x18, 0x16, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d,
+	0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x36, 0x36, 0x39, 0x37, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36,
+	0x39, 0x38, 0x18, 0x13, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74,
+	0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36,
+	0x36, 0x39, 0x38, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x39, 0x39,
+	0x18, 0x14, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x39,
+	0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x30, 0x30, 0x18, 0x15,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x37, 0x30, 0x30, 0x22,
+	0xad, 0x07, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x31, 0x33, 0x33, 0x12,
+	0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x37, 0x33, 0x18, 0x0c, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x30, 0x31, 0x36, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x36, 0x31, 0x37, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36,
+	0x31, 0x37, 0x34, 0x18, 0x10, 0x20, 0x01, 0x28, 0x01, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x36, 0x31, 0x37, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x37,
+	0x35, 0x18, 0x01, 0x20, 0x02, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31,
+	0x37, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x37, 0x36, 0x18,
+	0x02, 0x20, 0x02, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x37, 0x36,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x37, 0x37, 0x18, 0x03, 0x20,
+	0x02, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x37, 0x37, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x37, 0x38, 0x18, 0x04, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x37, 0x38, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x37, 0x39, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x37, 0x39, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x36, 0x31, 0x38, 0x30, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x36, 0x31, 0x30, 0x39, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x38,
+	0x30, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x38, 0x31, 0x18, 0x0d,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x35, 0x39, 0x30, 0x38, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x38, 0x31, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x36, 0x31, 0x38, 0x32, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x36, 0x31, 0x30, 0x37, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x38, 0x32, 0x12,
+	0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x38, 0x33, 0x18, 0x09, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x31, 0x32, 0x36, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x36, 0x31, 0x38, 0x33, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36,
+	0x31, 0x38, 0x34, 0x18, 0x0f, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x31,
+	0x32, 0x39, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x38, 0x34, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x38, 0x35, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x38, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x38, 0x36, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x38, 0x36, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x36, 0x31, 0x38, 0x37, 0x18, 0x11, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x34, 0x30, 0x31, 0x36, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x38, 0x37,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x38, 0x38, 0x18, 0x0e, 0x20,
+	0x01, 0x28, 0x01, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x38, 0x38, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x38, 0x39, 0x18, 0x12, 0x20, 0x01, 0x28,
+	0x01, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x38, 0x39, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x39, 0x30, 0x18, 0x13, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x39, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x36, 0x31, 0x39, 0x31, 0x18, 0x14, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x39, 0x31, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x36, 0x31, 0x39, 0x32, 0x18, 0x15, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x35, 0x38, 0x38, 0x31, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x39, 0x32, 0x22,
+	0xf8, 0x03, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x31, 0x30, 0x39, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x34, 0x30, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x34, 0x30, 0x12, 0x42, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x34, 0x31, 0x18, 0x02, 0x20, 0x02, 0x28, 0x0e,
+	0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e,
+	0x75, 0x6d, 0x36, 0x31, 0x31, 0x31, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x34,
+	0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x34, 0x32, 0x18, 0x09,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x34, 0x32, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x34, 0x33, 0x18, 0x03, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x34, 0x33, 0x12, 0x45, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x34, 0x34, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x31, 0x31, 0x30, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x36, 0x31, 0x34, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x34,
+	0x35, 0x18, 0x07, 0x20, 0x03, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31,
+	0x34, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x34, 0x36, 0x18,
+	0x08, 0x20, 0x03, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x34, 0x36,
+	0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x34, 0x37, 0x18, 0x0a, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x31, 0x33, 0x33, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x36, 0x31, 0x34, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x36, 0x31, 0x34, 0x38, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x36, 0x31, 0x34, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31,
+	0x34, 0x39, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36,
+	0x31, 0x34, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x35, 0x30,
+	0x18, 0x0d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x35,
+	0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x35, 0x31, 0x18, 0x0e,
+	0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x35, 0x31, 0x2a,
+	0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x22, 0x6f, 0x0a, 0x0b, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x30, 0x34, 0x36, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x32, 0x32, 0x32, 0x18, 0x01, 0x20, 0x02, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x32, 0x35,
+	0x39, 0x33, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x32, 0x32, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x32, 0x33, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x32, 0x33, 0x22, 0x67, 0x0a, 0x0b, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x30, 0x36, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x32, 0x38, 0x33, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x38, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x32, 0x38, 0x34, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x32, 0x38, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x32, 0x38, 0x35, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x32, 0x38, 0x35, 0x22, 0x49, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33,
+	0x30, 0x34, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x31, 0x34,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x31,
+	0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x31, 0x35, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x31, 0x35, 0x22,
+	0xa3, 0x01, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x30, 0x34, 0x30, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x30, 0x39, 0x18, 0x01, 0x20, 0x02,
+	0x28, 0x06, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x30, 0x39, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x31, 0x30, 0x18, 0x04, 0x20, 0x03, 0x28, 0x06,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x31, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x31, 0x31, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x31, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x32, 0x31, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x06, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x32, 0x31, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x32, 0x31, 0x33, 0x18, 0x03, 0x20, 0x02, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x32, 0x31, 0x33, 0x22, 0xc1, 0x01, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x30, 0x35, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32,
+	0x34, 0x35, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x32, 0x34, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x34, 0x36,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x34,
+	0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x34, 0x37, 0x18, 0x06,
+	0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x34, 0x37, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x34, 0x38, 0x18, 0x04, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x34, 0x38, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x34, 0x39, 0x18, 0x01, 0x20, 0x01, 0x28, 0x07,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x34, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x35, 0x30, 0x18, 0x03, 0x20, 0x01, 0x28, 0x07, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x35, 0x30, 0x22, 0xdf, 0x01, 0x0a, 0x0b, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x39, 0x30, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x37, 0x39, 0x31, 0x31, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x39, 0x31, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x37, 0x39, 0x31, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x39, 0x31, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39,
+	0x31, 0x33, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37,
+	0x39, 0x31, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x31, 0x34,
+	0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x31,
+	0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x31, 0x35, 0x18, 0x05,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x31, 0x35, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x31, 0x36, 0x18, 0x06, 0x20, 0x01,
+	0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x31, 0x36, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x31, 0x37, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x31, 0x37, 0x22, 0x95, 0x02, 0x0a, 0x0b,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x38, 0x38, 0x36, 0x12, 0x55, 0x0a, 0x0b, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x38, 0x38, 0x37, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0a,
+	0x32, 0x33, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x38, 0x38, 0x36, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x33, 0x38, 0x38, 0x37, 0x52, 0x0b, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x38,
+	0x38, 0x37, 0x1a, 0xae, 0x01, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x38,
+	0x38, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x33, 0x32, 0x18,
+	0x02, 0x20, 0x02, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x33, 0x32,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x33, 0x33, 0x18, 0x09, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x33, 0x33, 0x12, 0x45,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x33, 0x34, 0x18, 0x03, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x38, 0x35, 0x30, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x39, 0x33, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39,
+	0x33, 0x35, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x39, 0x33, 0x35, 0x22, 0xec, 0x02, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37,
+	0x38, 0x36, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x36, 0x36,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x36,
+	0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x36, 0x37, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x36, 0x37, 0x12,
+	0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x36, 0x38, 0x18, 0x05, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x38, 0x36, 0x35, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x37, 0x38, 0x36, 0x38, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37,
+	0x38, 0x36, 0x39, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x38,
+	0x36, 0x35, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x36, 0x39, 0x12, 0x45, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x37, 0x30, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x38, 0x36, 0x35, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x37, 0x38, 0x37, 0x30, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x37,
+	0x31, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38,
+	0x37, 0x31, 0x22, 0x2b, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x39, 0x32,
+	0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x30, 0x31, 0x32, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x30, 0x31, 0x32, 0x22,
+	0x9b, 0x02, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x30, 0x35, 0x32, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x35, 0x34, 0x18, 0x01, 0x20, 0x03,
+	0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x35, 0x34, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x35, 0x35, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x35, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x35, 0x36, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x35, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x32, 0x35, 0x37, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x32, 0x35, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x32, 0x35, 0x38, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x32, 0x35, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32,
+	0x35, 0x39, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x32, 0x35, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x36, 0x30,
+	0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x36,
+	0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x36, 0x31, 0x18, 0x08,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x36, 0x31, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x36, 0x32, 0x18, 0x09, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x36, 0x32, 0x22, 0x0d, 0x0a,
+	0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x38, 0x35, 0x37, 0x35, 0x22, 0xe6, 0x07, 0x0a,
+	0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x38, 0x34, 0x33, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x34, 0x34, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x34, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x38, 0x34, 0x35, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x34, 0x35, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x38, 0x34, 0x36, 0x18, 0x16, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45,
+	0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x37, 0x38, 0x34, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37,
+	0x38, 0x34, 0x37, 0x18, 0x03, 0x20, 0x03, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x37, 0x38, 0x34, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x34,
+	0x38, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38,
+	0x34, 0x38, 0x12, 0x44, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x34, 0x39, 0x18,
+	0x0f, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x34, 0x39, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x38, 0x35, 0x30, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45,
+	0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x37, 0x38, 0x35, 0x30, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37,
+	0x38, 0x35, 0x31, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70,
+	0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x37, 0x38, 0x35, 0x31, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x35,
+	0x32, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38,
+	0x35, 0x32, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x35, 0x33, 0x18,
+	0x0d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x35, 0x31, 0x31, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x35, 0x33, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x37, 0x38, 0x35, 0x34, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64,
+	0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x38, 0x35, 0x34, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x37, 0x38, 0x35, 0x35, 0x18, 0x11, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d,
+	0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x38, 0x35, 0x35, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38,
+	0x35, 0x36, 0x18, 0x13, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74,
+	0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37,
+	0x38, 0x35, 0x36, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x35, 0x37,
+	0x18, 0x12, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x35,
+	0x37, 0x12, 0x44, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x38, 0x35, 0x38, 0x18, 0x14,
+	0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x38, 0x35, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x37, 0x38, 0x35, 0x39, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x38, 0x35, 0x39, 0x22, 0x54, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x33, 0x39, 0x31, 0x39, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x30, 0x30,
+	0x39, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x33, 0x39, 0x32, 0x30,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x30, 0x30, 0x39, 0x22, 0xe9, 0x06, 0x0a, 0x0b,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x39, 0x32, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x34, 0x32, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x34, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x37, 0x39, 0x34, 0x33, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x39, 0x34, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x37, 0x39, 0x34, 0x34, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x39, 0x34, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39,
+	0x34, 0x35, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37,
+	0x39, 0x34, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x34, 0x36,
+	0x18, 0x0d, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x34,
+	0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x34, 0x37, 0x18, 0x12,
+	0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x34, 0x37, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x34, 0x38, 0x18, 0x06, 0x20, 0x01,
+	0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x34, 0x38, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x34, 0x39, 0x18, 0x07, 0x20, 0x01, 0x28, 0x03,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x34, 0x39, 0x12, 0x45, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x35, 0x30, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x37, 0x39, 0x31, 0x39, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39,
+	0x35, 0x30, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x35, 0x31, 0x18,
+	0x14, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x35, 0x31,
+	0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x35, 0x32, 0x18, 0x0e, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x39, 0x32, 0x30, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x39, 0x35, 0x32, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x37, 0x39, 0x35, 0x33, 0x18, 0x0f, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37,
+	0x39, 0x32, 0x31, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x35, 0x33, 0x12, 0x45,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x35, 0x34, 0x18, 0x11, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x39, 0x32, 0x38, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x39, 0x35, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39,
+	0x35, 0x35, 0x18, 0x13, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37,
+	0x39, 0x35, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x35, 0x36,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x35,
+	0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x35, 0x37, 0x18, 0x03,
+	0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x35, 0x37, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x35, 0x38, 0x18, 0x09, 0x20, 0x01,
+	0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x35, 0x38, 0x12, 0x4c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x35, 0x39, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e,
+	0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x35, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x36, 0x30, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x36, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x37, 0x39, 0x36, 0x31, 0x18, 0x10, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x39, 0x36, 0x31, 0x42, 0x23, 0x0a, 0x1e, 0x63, 0x6f, 0x6d, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0xf8, 0x01, 0x01,
+}
+
+var (
+	file_datasets_google_message4_benchmark_message4_1_proto_rawDescOnce sync.Once
+	file_datasets_google_message4_benchmark_message4_1_proto_rawDescData = file_datasets_google_message4_benchmark_message4_1_proto_rawDesc
+)
+
+func file_datasets_google_message4_benchmark_message4_1_proto_rawDescGZIP() []byte {
+	file_datasets_google_message4_benchmark_message4_1_proto_rawDescOnce.Do(func() {
+		file_datasets_google_message4_benchmark_message4_1_proto_rawDescData = protoimpl.X.CompressGZIP(file_datasets_google_message4_benchmark_message4_1_proto_rawDescData)
+	})
+	return file_datasets_google_message4_benchmark_message4_1_proto_rawDescData
+}
+
+var file_datasets_google_message4_benchmark_message4_1_proto_msgTypes = make([]protoimpl.MessageInfo, 44)
+var file_datasets_google_message4_benchmark_message4_1_proto_goTypes = []interface{}{
+	(*Message2463)(nil),             // 0: benchmarks.google_message4.Message2463
+	(*Message12686)(nil),            // 1: benchmarks.google_message4.Message12686
+	(*Message11949)(nil),            // 2: benchmarks.google_message4.Message11949
+	(*Message11975)(nil),            // 3: benchmarks.google_message4.Message11975
+	(*Message7287)(nil),             // 4: benchmarks.google_message4.Message7287
+	(*Message3061)(nil),             // 5: benchmarks.google_message4.Message3061
+	(*Message12949)(nil),            // 6: benchmarks.google_message4.Message12949
+	(*Message8572)(nil),             // 7: benchmarks.google_message4.Message8572
+	(*Message8774)(nil),             // 8: benchmarks.google_message4.Message8774
+	(*Message12776)(nil),            // 9: benchmarks.google_message4.Message12776
+	(*Message12798)(nil),            // 10: benchmarks.google_message4.Message12798
+	(*Message12797)(nil),            // 11: benchmarks.google_message4.Message12797
+	(*Message12825)(nil),            // 12: benchmarks.google_message4.Message12825
+	(*Message8590)(nil),             // 13: benchmarks.google_message4.Message8590
+	(*Message8587)(nil),             // 14: benchmarks.google_message4.Message8587
+	(*Message1374)(nil),             // 15: benchmarks.google_message4.Message1374
+	(*Message2462)(nil),             // 16: benchmarks.google_message4.Message2462
+	(*Message12685)(nil),            // 17: benchmarks.google_message4.Message12685
+	(*Message10320)(nil),            // 18: benchmarks.google_message4.Message10320
+	(*Message11947)(nil),            // 19: benchmarks.google_message4.Message11947
+	(*Message11920)(nil),            // 20: benchmarks.google_message4.Message11920
+	(*Message6643)(nil),             // 21: benchmarks.google_message4.Message6643
+	(*Message6133)(nil),             // 22: benchmarks.google_message4.Message6133
+	(*Message6109)(nil),             // 23: benchmarks.google_message4.Message6109
+	(*Message3046)(nil),             // 24: benchmarks.google_message4.Message3046
+	(*Message3060)(nil),             // 25: benchmarks.google_message4.Message3060
+	(*Message3041)(nil),             // 26: benchmarks.google_message4.Message3041
+	(*Message3040)(nil),             // 27: benchmarks.google_message4.Message3040
+	(*Message3050)(nil),             // 28: benchmarks.google_message4.Message3050
+	(*Message7905)(nil),             // 29: benchmarks.google_message4.Message7905
+	(*Message3886)(nil),             // 30: benchmarks.google_message4.Message3886
+	(*Message7864)(nil),             // 31: benchmarks.google_message4.Message7864
+	(*Message3922)(nil),             // 32: benchmarks.google_message4.Message3922
+	(*Message3052)(nil),             // 33: benchmarks.google_message4.Message3052
+	(*Message8575)(nil),             // 34: benchmarks.google_message4.Message8575
+	(*Message7843)(nil),             // 35: benchmarks.google_message4.Message7843
+	(*Message3919)(nil),             // 36: benchmarks.google_message4.Message3919
+	(*Message7929)(nil),             // 37: benchmarks.google_message4.Message7929
+	(*Message3061_Message3062)(nil), // 38: benchmarks.google_message4.Message3061.Message3062
+	(*Message3061_Message3063)(nil), // 39: benchmarks.google_message4.Message3061.Message3063
+	(*Message3061_Message3064)(nil), // 40: benchmarks.google_message4.Message3061.Message3064
+	(*Message3061_Message3065)(nil), // 41: benchmarks.google_message4.Message3061.Message3065
+	(*Message3061_Message3066)(nil), // 42: benchmarks.google_message4.Message3061.Message3066
+	(*Message3886_Message3887)(nil), // 43: benchmarks.google_message4.Message3886.Message3887
+	(UnusedEnum)(0),                 // 44: benchmarks.google_message4.UnusedEnum
+	(*UnusedEmptyMessage)(nil),      // 45: benchmarks.google_message4.UnusedEmptyMessage
+	(Enum7288)(0),                   // 46: benchmarks.google_message4.Enum7288
+	(Enum2834)(0),                   // 47: benchmarks.google_message4.Enum2834
+	(Enum2806)(0),                   // 48: benchmarks.google_message4.Enum2806
+	(Enum3476)(0),                   // 49: benchmarks.google_message4.Enum3476
+	(*Message12774)(nil),            // 50: benchmarks.google_message4.Message12774
+	(*Message12796)(nil),            // 51: benchmarks.google_message4.Message12796
+	(*Message12818)(nil),            // 52: benchmarks.google_message4.Message12818
+	(*Message12819)(nil),            // 53: benchmarks.google_message4.Message12819
+	(*Message12820)(nil),            // 54: benchmarks.google_message4.Message12820
+	(*Message12821)(nil),            // 55: benchmarks.google_message4.Message12821
+	(Enum10335)(0),                  // 56: benchmarks.google_message4.Enum10335
+	(*Message10319)(nil),            // 57: benchmarks.google_message4.Message10319
+	(Enum10337)(0),                  // 58: benchmarks.google_message4.Enum10337
+	(Enum11901)(0),                  // 59: benchmarks.google_message4.Enum11901
+	(*Message6578)(nil),             // 60: benchmarks.google_message4.Message6578
+	(*Message4016)(nil),             // 61: benchmarks.google_message4.Message4016
+	(*Message5908)(nil),             // 62: benchmarks.google_message4.Message5908
+	(*Message6107)(nil),             // 63: benchmarks.google_message4.Message6107
+	(*Message6126)(nil),             // 64: benchmarks.google_message4.Message6126
+	(*Message6129)(nil),             // 65: benchmarks.google_message4.Message6129
+	(*Message5881)(nil),             // 66: benchmarks.google_message4.Message5881
+	(Enum6111)(0),                   // 67: benchmarks.google_message4.Enum6111
+	(*Message6110)(nil),             // 68: benchmarks.google_message4.Message6110
+	(Enum2593)(0),                   // 69: benchmarks.google_message4.Enum2593
+	(*Message7865)(nil),             // 70: benchmarks.google_message4.Message7865
+	(*Message7511)(nil),             // 71: benchmarks.google_message4.Message7511
+	(*Message3920)(nil),             // 72: benchmarks.google_message4.Message3920
+	(*Message7919)(nil),             // 73: benchmarks.google_message4.Message7919
+	(*Message7920)(nil),             // 74: benchmarks.google_message4.Message7920
+	(*Message7921)(nil),             // 75: benchmarks.google_message4.Message7921
+	(*Message7928)(nil),             // 76: benchmarks.google_message4.Message7928
+	(Enum2851)(0),                   // 77: benchmarks.google_message4.Enum2851
+	(Enum2602)(0),                   // 78: benchmarks.google_message4.Enum2602
+	(*Message3850)(nil),             // 79: benchmarks.google_message4.Message3850
+}
+var file_datasets_google_message4_benchmark_message4_1_proto_depIdxs = []int32{
+	16,  // 0: benchmarks.google_message4.Message2463.field2498:type_name -> benchmarks.google_message4.Message2462
+	17,  // 1: benchmarks.google_message4.Message12686.field12700:type_name -> benchmarks.google_message4.Message12685
+	18,  // 2: benchmarks.google_message4.Message11975.field11994:type_name -> benchmarks.google_message4.Message10320
+	19,  // 3: benchmarks.google_message4.Message11975.field11995:type_name -> benchmarks.google_message4.Message11947
+	20,  // 4: benchmarks.google_message4.Message11975.field11996:type_name -> benchmarks.google_message4.Message11920
+	44,  // 5: benchmarks.google_message4.Message11975.field12000:type_name -> benchmarks.google_message4.UnusedEnum
+	22,  // 6: benchmarks.google_message4.Message7287.field7311:type_name -> benchmarks.google_message4.Message6133
+	45,  // 7: benchmarks.google_message4.Message7287.field7312:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	21,  // 8: benchmarks.google_message4.Message7287.field7314:type_name -> benchmarks.google_message4.Message6643
+	46,  // 9: benchmarks.google_message4.Message7287.field7315:type_name -> benchmarks.google_message4.Enum7288
+	45,  // 10: benchmarks.google_message4.Message7287.field7317:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 11: benchmarks.google_message4.Message7287.field7318:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	24,  // 12: benchmarks.google_message4.Message3061.field3289:type_name -> benchmarks.google_message4.Message3046
+	24,  // 13: benchmarks.google_message4.Message3061.field3290:type_name -> benchmarks.google_message4.Message3046
+	38,  // 14: benchmarks.google_message4.Message3061.message3062:type_name -> benchmarks.google_message4.Message3061.Message3062
+	25,  // 15: benchmarks.google_message4.Message3061.field3292:type_name -> benchmarks.google_message4.Message3060
+	39,  // 16: benchmarks.google_message4.Message3061.message3063:type_name -> benchmarks.google_message4.Message3061.Message3063
+	47,  // 17: benchmarks.google_message4.Message3061.field3296:type_name -> benchmarks.google_message4.Enum2834
+	28,  // 18: benchmarks.google_message4.Message3061.field3302:type_name -> benchmarks.google_message4.Message3050
+	48,  // 19: benchmarks.google_message4.Message3061.field3310:type_name -> benchmarks.google_message4.Enum2806
+	40,  // 20: benchmarks.google_message4.Message3061.message3064:type_name -> benchmarks.google_message4.Message3061.Message3064
+	45,  // 21: benchmarks.google_message4.Message3061.field3315:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	41,  // 22: benchmarks.google_message4.Message3061.message3065:type_name -> benchmarks.google_message4.Message3061.Message3065
+	48,  // 23: benchmarks.google_message4.Message3061.field3318:type_name -> benchmarks.google_message4.Enum2806
+	27,  // 24: benchmarks.google_message4.Message3061.field3325:type_name -> benchmarks.google_message4.Message3040
+	26,  // 25: benchmarks.google_message4.Message3061.field3326:type_name -> benchmarks.google_message4.Message3041
+	42,  // 26: benchmarks.google_message4.Message3061.message3066:type_name -> benchmarks.google_message4.Message3061.Message3066
+	45,  // 27: benchmarks.google_message4.Message3061.field3328:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 28: benchmarks.google_message4.Message3061.field3329:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 29: benchmarks.google_message4.Message3061.field3331:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 30: benchmarks.google_message4.Message3061.field3332:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	30,  // 31: benchmarks.google_message4.Message8572.field8649:type_name -> benchmarks.google_message4.Message3886
+	36,  // 32: benchmarks.google_message4.Message8572.field8650:type_name -> benchmarks.google_message4.Message3919
+	29,  // 33: benchmarks.google_message4.Message8572.field8654:type_name -> benchmarks.google_message4.Message7905
+	45,  // 34: benchmarks.google_message4.Message8572.field8656:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 35: benchmarks.google_message4.Message8572.field8660:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 36: benchmarks.google_message4.Message8572.field8662:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	49,  // 37: benchmarks.google_message4.Message8572.field8666:type_name -> benchmarks.google_message4.Enum3476
+	45,  // 38: benchmarks.google_message4.Message8572.field8668:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	33,  // 39: benchmarks.google_message4.Message8572.field8671:type_name -> benchmarks.google_message4.Message3052
+	32,  // 40: benchmarks.google_message4.Message8572.field8682:type_name -> benchmarks.google_message4.Message3922
+	45,  // 41: benchmarks.google_message4.Message8572.field8683:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	37,  // 42: benchmarks.google_message4.Message8572.field8685:type_name -> benchmarks.google_message4.Message7929
+	35,  // 43: benchmarks.google_message4.Message8572.field8688:type_name -> benchmarks.google_message4.Message7843
+	31,  // 44: benchmarks.google_message4.Message8572.field8689:type_name -> benchmarks.google_message4.Message7864
+	45,  // 45: benchmarks.google_message4.Message8572.field8690:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 46: benchmarks.google_message4.Message8572.field8694:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 47: benchmarks.google_message4.Message8572.field8695:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	34,  // 48: benchmarks.google_message4.Message8572.field8696:type_name -> benchmarks.google_message4.Message8575
+	45,  // 49: benchmarks.google_message4.Message12776.field12793:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	50,  // 50: benchmarks.google_message4.Message12776.field12794:type_name -> benchmarks.google_message4.Message12774
+	45,  // 51: benchmarks.google_message4.Message12776.field12795:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	50,  // 52: benchmarks.google_message4.Message12798.field12807:type_name -> benchmarks.google_message4.Message12774
+	51,  // 53: benchmarks.google_message4.Message12797.field12802:type_name -> benchmarks.google_message4.Message12796
+	51,  // 54: benchmarks.google_message4.Message12797.field12803:type_name -> benchmarks.google_message4.Message12796
+	52,  // 55: benchmarks.google_message4.Message12825.field12862:type_name -> benchmarks.google_message4.Message12818
+	53,  // 56: benchmarks.google_message4.Message12825.field12864:type_name -> benchmarks.google_message4.Message12819
+	54,  // 57: benchmarks.google_message4.Message12825.field12865:type_name -> benchmarks.google_message4.Message12820
+	55,  // 58: benchmarks.google_message4.Message12825.field12867:type_name -> benchmarks.google_message4.Message12821
+	45,  // 59: benchmarks.google_message4.Message12825.field12868:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	56,  // 60: benchmarks.google_message4.Message10320.field10347:type_name -> benchmarks.google_message4.Enum10335
+	57,  // 61: benchmarks.google_message4.Message10320.field10348:type_name -> benchmarks.google_message4.Message10319
+	58,  // 62: benchmarks.google_message4.Message10320.field10353:type_name -> benchmarks.google_message4.Enum10337
+	59,  // 63: benchmarks.google_message4.Message11920.field11945:type_name -> benchmarks.google_message4.Enum11901
+	44,  // 64: benchmarks.google_message4.Message11920.field11946:type_name -> benchmarks.google_message4.UnusedEnum
+	45,  // 65: benchmarks.google_message4.Message6643.field6683:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 66: benchmarks.google_message4.Message6643.field6684:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	60,  // 67: benchmarks.google_message4.Message6643.field6694:type_name -> benchmarks.google_message4.Message6578
+	44,  // 68: benchmarks.google_message4.Message6643.field6695:type_name -> benchmarks.google_message4.UnusedEnum
+	45,  // 69: benchmarks.google_message4.Message6643.field6697:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 70: benchmarks.google_message4.Message6643.field6698:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 71: benchmarks.google_message4.Message6643.field6699:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	61,  // 72: benchmarks.google_message4.Message6133.field6173:type_name -> benchmarks.google_message4.Message4016
+	23,  // 73: benchmarks.google_message4.Message6133.field6180:type_name -> benchmarks.google_message4.Message6109
+	62,  // 74: benchmarks.google_message4.Message6133.field6181:type_name -> benchmarks.google_message4.Message5908
+	63,  // 75: benchmarks.google_message4.Message6133.field6182:type_name -> benchmarks.google_message4.Message6107
+	64,  // 76: benchmarks.google_message4.Message6133.field6183:type_name -> benchmarks.google_message4.Message6126
+	65,  // 77: benchmarks.google_message4.Message6133.field6184:type_name -> benchmarks.google_message4.Message6129
+	61,  // 78: benchmarks.google_message4.Message6133.field6187:type_name -> benchmarks.google_message4.Message4016
+	66,  // 79: benchmarks.google_message4.Message6133.field6192:type_name -> benchmarks.google_message4.Message5881
+	67,  // 80: benchmarks.google_message4.Message6109.field6141:type_name -> benchmarks.google_message4.Enum6111
+	68,  // 81: benchmarks.google_message4.Message6109.field6144:type_name -> benchmarks.google_message4.Message6110
+	22,  // 82: benchmarks.google_message4.Message6109.field6147:type_name -> benchmarks.google_message4.Message6133
+	69,  // 83: benchmarks.google_message4.Message3046.field3222:type_name -> benchmarks.google_message4.Enum2593
+	43,  // 84: benchmarks.google_message4.Message3886.message3887:type_name -> benchmarks.google_message4.Message3886.Message3887
+	70,  // 85: benchmarks.google_message4.Message7864.field7868:type_name -> benchmarks.google_message4.Message7865
+	70,  // 86: benchmarks.google_message4.Message7864.field7869:type_name -> benchmarks.google_message4.Message7865
+	70,  // 87: benchmarks.google_message4.Message7864.field7870:type_name -> benchmarks.google_message4.Message7865
+	45,  // 88: benchmarks.google_message4.Message7864.field7871:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 89: benchmarks.google_message4.Message7843.field7846:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	44,  // 90: benchmarks.google_message4.Message7843.field7849:type_name -> benchmarks.google_message4.UnusedEnum
+	45,  // 91: benchmarks.google_message4.Message7843.field7850:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 92: benchmarks.google_message4.Message7843.field7851:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 93: benchmarks.google_message4.Message7843.field7852:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	71,  // 94: benchmarks.google_message4.Message7843.field7853:type_name -> benchmarks.google_message4.Message7511
+	45,  // 95: benchmarks.google_message4.Message7843.field7854:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 96: benchmarks.google_message4.Message7843.field7855:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 97: benchmarks.google_message4.Message7843.field7856:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 98: benchmarks.google_message4.Message7843.field7857:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	44,  // 99: benchmarks.google_message4.Message7843.field7858:type_name -> benchmarks.google_message4.UnusedEnum
+	72,  // 100: benchmarks.google_message4.Message3919.field4009:type_name -> benchmarks.google_message4.Message3920
+	73,  // 101: benchmarks.google_message4.Message7929.field7950:type_name -> benchmarks.google_message4.Message7919
+	45,  // 102: benchmarks.google_message4.Message7929.field7951:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	74,  // 103: benchmarks.google_message4.Message7929.field7952:type_name -> benchmarks.google_message4.Message7920
+	75,  // 104: benchmarks.google_message4.Message7929.field7953:type_name -> benchmarks.google_message4.Message7921
+	76,  // 105: benchmarks.google_message4.Message7929.field7954:type_name -> benchmarks.google_message4.Message7928
+	45,  // 106: benchmarks.google_message4.Message7929.field7959:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	77,  // 107: benchmarks.google_message4.Message3061.Message3063.field3339:type_name -> benchmarks.google_message4.Enum2851
+	78,  // 108: benchmarks.google_message4.Message3061.Message3064.field3342:type_name -> benchmarks.google_message4.Enum2602
+	25,  // 109: benchmarks.google_message4.Message3061.Message3064.field3347:type_name -> benchmarks.google_message4.Message3060
+	45,  // 110: benchmarks.google_message4.Message3061.Message3064.field3348:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	28,  // 111: benchmarks.google_message4.Message3061.Message3064.field3349:type_name -> benchmarks.google_message4.Message3050
+	48,  // 112: benchmarks.google_message4.Message3061.Message3064.field3355:type_name -> benchmarks.google_message4.Enum2806
+	47,  // 113: benchmarks.google_message4.Message3061.Message3064.field3360:type_name -> benchmarks.google_message4.Enum2834
+	45,  // 114: benchmarks.google_message4.Message3061.Message3066.field3372:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	45,  // 115: benchmarks.google_message4.Message3061.Message3066.field3373:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	79,  // 116: benchmarks.google_message4.Message3886.Message3887.field3934:type_name -> benchmarks.google_message4.Message3850
+	117, // [117:117] is the sub-list for method output_type
+	117, // [117:117] is the sub-list for method input_type
+	117, // [117:117] is the sub-list for extension type_name
+	117, // [117:117] is the sub-list for extension extendee
+	0,   // [0:117] is the sub-list for field type_name
+}
+
+func init() { file_datasets_google_message4_benchmark_message4_1_proto_init() }
+func file_datasets_google_message4_benchmark_message4_1_proto_init() {
+	if File_datasets_google_message4_benchmark_message4_1_proto != nil {
+		return
+	}
+	file_datasets_google_message4_benchmark_message4_2_proto_init()
+	file_datasets_google_message4_benchmark_message4_3_proto_init()
+	if !protoimpl.UnsafeEnabled {
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message2463); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12686); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message11949); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message11975); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message7287); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message3061); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12949); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8572); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8774); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12776); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12798); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12797); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12825); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8590); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8587); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message1374); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message2462); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12685); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message10320); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message11947); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message11920); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6643); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6133); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6109); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message3046); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message3060); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message3041); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message3040); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message3050); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message7905); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message3886); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message7864); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message3922); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message3052); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message8575); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[35].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message7843); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[36].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message3919); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[37].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message7929); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[38].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message3061_Message3062); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[39].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message3061_Message3063); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[40].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message3061_Message3064); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[41].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message3061_Message3065); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[42].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message3061_Message3066); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_1_proto_msgTypes[43].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message3886_Message3887); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_datasets_google_message4_benchmark_message4_1_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   44,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_datasets_google_message4_benchmark_message4_1_proto_goTypes,
+		DependencyIndexes: file_datasets_google_message4_benchmark_message4_1_proto_depIdxs,
+		MessageInfos:      file_datasets_google_message4_benchmark_message4_1_proto_msgTypes,
+	}.Build()
+	File_datasets_google_message4_benchmark_message4_1_proto = out.File
+	file_datasets_google_message4_benchmark_message4_1_proto_rawDesc = nil
+	file_datasets_google_message4_benchmark_message4_1_proto_goTypes = nil
+	file_datasets_google_message4_benchmark_message4_1_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message4/benchmark_message4_2.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message4/benchmark_message4_2.pb.go
new file mode 100644
index 000000000..dde28c0e5
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message4/benchmark_message4_2.pb.go
@@ -0,0 +1,3969 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: datasets/google_message4/benchmark_message4_2.proto
+
+package google_message4
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type Message12774 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12777 *uint32 `protobuf:"varint,1,opt,name=field12777" json:"field12777,omitempty"`
+	Field12778 *uint32 `protobuf:"varint,2,opt,name=field12778" json:"field12778,omitempty"`
+	Field12779 *uint32 `protobuf:"varint,3,opt,name=field12779" json:"field12779,omitempty"`
+	Field12780 *uint32 `protobuf:"varint,4,opt,name=field12780" json:"field12780,omitempty"`
+	Field12781 *uint32 `protobuf:"varint,5,opt,name=field12781" json:"field12781,omitempty"`
+	Field12782 *bool   `protobuf:"varint,6,opt,name=field12782" json:"field12782,omitempty"`
+}
+
+func (x *Message12774) Reset() {
+	*x = Message12774{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12774) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12774) ProtoMessage() {}
+
+func (x *Message12774) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12774.ProtoReflect.Descriptor instead.
+func (*Message12774) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Message12774) GetField12777() uint32 {
+	if x != nil && x.Field12777 != nil {
+		return *x.Field12777
+	}
+	return 0
+}
+
+func (x *Message12774) GetField12778() uint32 {
+	if x != nil && x.Field12778 != nil {
+		return *x.Field12778
+	}
+	return 0
+}
+
+func (x *Message12774) GetField12779() uint32 {
+	if x != nil && x.Field12779 != nil {
+		return *x.Field12779
+	}
+	return 0
+}
+
+func (x *Message12774) GetField12780() uint32 {
+	if x != nil && x.Field12780 != nil {
+		return *x.Field12780
+	}
+	return 0
+}
+
+func (x *Message12774) GetField12781() uint32 {
+	if x != nil && x.Field12781 != nil {
+		return *x.Field12781
+	}
+	return 0
+}
+
+func (x *Message12774) GetField12782() bool {
+	if x != nil && x.Field12782 != nil {
+		return *x.Field12782
+	}
+	return false
+}
+
+type Message12796 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12800 []uint64 `protobuf:"fixed64,1,rep,name=field12800" json:"field12800,omitempty"`
+	Field12801 *uint64  `protobuf:"varint,2,opt,name=field12801" json:"field12801,omitempty"`
+}
+
+func (x *Message12796) Reset() {
+	*x = Message12796{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12796) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12796) ProtoMessage() {}
+
+func (x *Message12796) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12796.ProtoReflect.Descriptor instead.
+func (*Message12796) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *Message12796) GetField12800() []uint64 {
+	if x != nil {
+		return x.Field12800
+	}
+	return nil
+}
+
+func (x *Message12796) GetField12801() uint64 {
+	if x != nil && x.Field12801 != nil {
+		return *x.Field12801
+	}
+	return 0
+}
+
+type Message12821 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12848 *int32 `protobuf:"varint,1,opt,name=field12848" json:"field12848,omitempty"`
+	Field12849 *int32 `protobuf:"varint,2,opt,name=field12849" json:"field12849,omitempty"`
+	Field12850 *int32 `protobuf:"varint,3,opt,name=field12850" json:"field12850,omitempty"`
+	Field12851 *int32 `protobuf:"varint,4,opt,name=field12851" json:"field12851,omitempty"`
+	Field12852 *int32 `protobuf:"varint,5,opt,name=field12852" json:"field12852,omitempty"`
+}
+
+func (x *Message12821) Reset() {
+	*x = Message12821{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12821) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12821) ProtoMessage() {}
+
+func (x *Message12821) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12821.ProtoReflect.Descriptor instead.
+func (*Message12821) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *Message12821) GetField12848() int32 {
+	if x != nil && x.Field12848 != nil {
+		return *x.Field12848
+	}
+	return 0
+}
+
+func (x *Message12821) GetField12849() int32 {
+	if x != nil && x.Field12849 != nil {
+		return *x.Field12849
+	}
+	return 0
+}
+
+func (x *Message12821) GetField12850() int32 {
+	if x != nil && x.Field12850 != nil {
+		return *x.Field12850
+	}
+	return 0
+}
+
+func (x *Message12821) GetField12851() int32 {
+	if x != nil && x.Field12851 != nil {
+		return *x.Field12851
+	}
+	return 0
+}
+
+func (x *Message12821) GetField12852() int32 {
+	if x != nil && x.Field12852 != nil {
+		return *x.Field12852
+	}
+	return 0
+}
+
+type Message12820 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12840 *int32 `protobuf:"varint,1,opt,name=field12840" json:"field12840,omitempty"`
+	Field12841 *int32 `protobuf:"varint,2,opt,name=field12841" json:"field12841,omitempty"`
+	Field12842 *int32 `protobuf:"varint,3,opt,name=field12842" json:"field12842,omitempty"`
+	Field12843 *int32 `protobuf:"varint,8,opt,name=field12843" json:"field12843,omitempty"`
+	Field12844 *int32 `protobuf:"varint,4,opt,name=field12844" json:"field12844,omitempty"`
+	Field12845 *int32 `protobuf:"varint,5,opt,name=field12845" json:"field12845,omitempty"`
+	Field12846 *int32 `protobuf:"varint,6,opt,name=field12846" json:"field12846,omitempty"`
+	Field12847 *int32 `protobuf:"varint,7,opt,name=field12847" json:"field12847,omitempty"`
+}
+
+func (x *Message12820) Reset() {
+	*x = Message12820{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12820) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12820) ProtoMessage() {}
+
+func (x *Message12820) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12820.ProtoReflect.Descriptor instead.
+func (*Message12820) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *Message12820) GetField12840() int32 {
+	if x != nil && x.Field12840 != nil {
+		return *x.Field12840
+	}
+	return 0
+}
+
+func (x *Message12820) GetField12841() int32 {
+	if x != nil && x.Field12841 != nil {
+		return *x.Field12841
+	}
+	return 0
+}
+
+func (x *Message12820) GetField12842() int32 {
+	if x != nil && x.Field12842 != nil {
+		return *x.Field12842
+	}
+	return 0
+}
+
+func (x *Message12820) GetField12843() int32 {
+	if x != nil && x.Field12843 != nil {
+		return *x.Field12843
+	}
+	return 0
+}
+
+func (x *Message12820) GetField12844() int32 {
+	if x != nil && x.Field12844 != nil {
+		return *x.Field12844
+	}
+	return 0
+}
+
+func (x *Message12820) GetField12845() int32 {
+	if x != nil && x.Field12845 != nil {
+		return *x.Field12845
+	}
+	return 0
+}
+
+func (x *Message12820) GetField12846() int32 {
+	if x != nil && x.Field12846 != nil {
+		return *x.Field12846
+	}
+	return 0
+}
+
+func (x *Message12820) GetField12847() int32 {
+	if x != nil && x.Field12847 != nil {
+		return *x.Field12847
+	}
+	return 0
+}
+
+type Message12819 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12834 *float64 `protobuf:"fixed64,1,opt,name=field12834" json:"field12834,omitempty"`
+	Field12835 *float64 `protobuf:"fixed64,2,opt,name=field12835" json:"field12835,omitempty"`
+	Field12836 *float64 `protobuf:"fixed64,3,opt,name=field12836" json:"field12836,omitempty"`
+	Field12837 *float64 `protobuf:"fixed64,4,opt,name=field12837" json:"field12837,omitempty"`
+	Field12838 *float64 `protobuf:"fixed64,5,opt,name=field12838" json:"field12838,omitempty"`
+	Field12839 *float64 `protobuf:"fixed64,6,opt,name=field12839" json:"field12839,omitempty"`
+}
+
+func (x *Message12819) Reset() {
+	*x = Message12819{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12819) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12819) ProtoMessage() {}
+
+func (x *Message12819) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12819.ProtoReflect.Descriptor instead.
+func (*Message12819) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *Message12819) GetField12834() float64 {
+	if x != nil && x.Field12834 != nil {
+		return *x.Field12834
+	}
+	return 0
+}
+
+func (x *Message12819) GetField12835() float64 {
+	if x != nil && x.Field12835 != nil {
+		return *x.Field12835
+	}
+	return 0
+}
+
+func (x *Message12819) GetField12836() float64 {
+	if x != nil && x.Field12836 != nil {
+		return *x.Field12836
+	}
+	return 0
+}
+
+func (x *Message12819) GetField12837() float64 {
+	if x != nil && x.Field12837 != nil {
+		return *x.Field12837
+	}
+	return 0
+}
+
+func (x *Message12819) GetField12838() float64 {
+	if x != nil && x.Field12838 != nil {
+		return *x.Field12838
+	}
+	return 0
+}
+
+func (x *Message12819) GetField12839() float64 {
+	if x != nil && x.Field12839 != nil {
+		return *x.Field12839
+	}
+	return 0
+}
+
+type Message12818 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12829 *uint64         `protobuf:"varint,1,opt,name=field12829" json:"field12829,omitempty"`
+	Field12830 *int32          `protobuf:"varint,2,opt,name=field12830" json:"field12830,omitempty"`
+	Field12831 *int32          `protobuf:"varint,3,opt,name=field12831" json:"field12831,omitempty"`
+	Field12832 *int32          `protobuf:"varint,5,opt,name=field12832" json:"field12832,omitempty"`
+	Field12833 []*Message12817 `protobuf:"bytes,4,rep,name=field12833" json:"field12833,omitempty"`
+}
+
+func (x *Message12818) Reset() {
+	*x = Message12818{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[5]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12818) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12818) ProtoMessage() {}
+
+func (x *Message12818) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[5]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12818.ProtoReflect.Descriptor instead.
+func (*Message12818) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *Message12818) GetField12829() uint64 {
+	if x != nil && x.Field12829 != nil {
+		return *x.Field12829
+	}
+	return 0
+}
+
+func (x *Message12818) GetField12830() int32 {
+	if x != nil && x.Field12830 != nil {
+		return *x.Field12830
+	}
+	return 0
+}
+
+func (x *Message12818) GetField12831() int32 {
+	if x != nil && x.Field12831 != nil {
+		return *x.Field12831
+	}
+	return 0
+}
+
+func (x *Message12818) GetField12832() int32 {
+	if x != nil && x.Field12832 != nil {
+		return *x.Field12832
+	}
+	return 0
+}
+
+func (x *Message12818) GetField12833() []*Message12817 {
+	if x != nil {
+		return x.Field12833
+	}
+	return nil
+}
+
+type Message10319 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field10340 *Enum10325 `protobuf:"varint,1,opt,name=field10340,enum=benchmarks.google_message4.Enum10325" json:"field10340,omitempty"`
+	Field10341 *int32     `protobuf:"varint,4,opt,name=field10341" json:"field10341,omitempty"`
+	Field10342 *int32     `protobuf:"varint,5,opt,name=field10342" json:"field10342,omitempty"`
+	Field10343 []byte     `protobuf:"bytes,3,opt,name=field10343" json:"field10343,omitempty"`
+	Field10344 *string    `protobuf:"bytes,2,opt,name=field10344" json:"field10344,omitempty"`
+	Field10345 *string    `protobuf:"bytes,6,opt,name=field10345" json:"field10345,omitempty"`
+	Field10346 *string    `protobuf:"bytes,7,opt,name=field10346" json:"field10346,omitempty"`
+}
+
+func (x *Message10319) Reset() {
+	*x = Message10319{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[6]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message10319) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message10319) ProtoMessage() {}
+
+func (x *Message10319) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[6]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message10319.ProtoReflect.Descriptor instead.
+func (*Message10319) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *Message10319) GetField10340() Enum10325 {
+	if x != nil && x.Field10340 != nil {
+		return *x.Field10340
+	}
+	return Enum10325_ENUM_VALUE10326
+}
+
+func (x *Message10319) GetField10341() int32 {
+	if x != nil && x.Field10341 != nil {
+		return *x.Field10341
+	}
+	return 0
+}
+
+func (x *Message10319) GetField10342() int32 {
+	if x != nil && x.Field10342 != nil {
+		return *x.Field10342
+	}
+	return 0
+}
+
+func (x *Message10319) GetField10343() []byte {
+	if x != nil {
+		return x.Field10343
+	}
+	return nil
+}
+
+func (x *Message10319) GetField10344() string {
+	if x != nil && x.Field10344 != nil {
+		return *x.Field10344
+	}
+	return ""
+}
+
+func (x *Message10319) GetField10345() string {
+	if x != nil && x.Field10345 != nil {
+		return *x.Field10345
+	}
+	return ""
+}
+
+func (x *Message10319) GetField10346() string {
+	if x != nil && x.Field10346 != nil {
+		return *x.Field10346
+	}
+	return ""
+}
+
+type Message6578 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field6632 *Enum6579 `protobuf:"varint,1,opt,name=field6632,enum=benchmarks.google_message4.Enum6579" json:"field6632,omitempty"`
+	Field6633 *Enum6588 `protobuf:"varint,2,opt,name=field6633,enum=benchmarks.google_message4.Enum6588" json:"field6633,omitempty"`
+}
+
+func (x *Message6578) Reset() {
+	*x = Message6578{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[7]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6578) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6578) ProtoMessage() {}
+
+func (x *Message6578) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[7]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6578.ProtoReflect.Descriptor instead.
+func (*Message6578) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *Message6578) GetField6632() Enum6579 {
+	if x != nil && x.Field6632 != nil {
+		return *x.Field6632
+	}
+	return Enum6579_ENUM_VALUE6580
+}
+
+func (x *Message6578) GetField6633() Enum6588 {
+	if x != nil && x.Field6633 != nil {
+		return *x.Field6633
+	}
+	return Enum6588_ENUM_VALUE6589
+}
+
+type Message6126 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field6152 *string               `protobuf:"bytes,1,req,name=field6152" json:"field6152,omitempty"`
+	Field6153 []*Message6127        `protobuf:"bytes,9,rep,name=field6153" json:"field6153,omitempty"`
+	Field6154 *int32                `protobuf:"varint,14,opt,name=field6154" json:"field6154,omitempty"`
+	Field6155 []byte                `protobuf:"bytes,10,opt,name=field6155" json:"field6155,omitempty"`
+	Field6156 *Message6024          `protobuf:"bytes,12,opt,name=field6156" json:"field6156,omitempty"`
+	Field6157 *int32                `protobuf:"varint,4,opt,name=field6157" json:"field6157,omitempty"`
+	Field6158 *string               `protobuf:"bytes,5,opt,name=field6158" json:"field6158,omitempty"`
+	Field6159 *int32                `protobuf:"varint,6,opt,name=field6159" json:"field6159,omitempty"`
+	Field6160 []int32               `protobuf:"varint,2,rep,name=field6160" json:"field6160,omitempty"`
+	Field6161 []int32               `protobuf:"varint,3,rep,name=field6161" json:"field6161,omitempty"`
+	Field6162 []*Message6052        `protobuf:"bytes,7,rep,name=field6162" json:"field6162,omitempty"`
+	Field6163 []*UnusedEmptyMessage `protobuf:"bytes,11,rep,name=field6163" json:"field6163,omitempty"`
+	Field6164 *Enum6065             `protobuf:"varint,15,opt,name=field6164,enum=benchmarks.google_message4.Enum6065" json:"field6164,omitempty"`
+	Field6165 []*Message6127        `protobuf:"bytes,8,rep,name=field6165" json:"field6165,omitempty"`
+	Field6166 *bool                 `protobuf:"varint,13,opt,name=field6166" json:"field6166,omitempty"`
+	Field6167 *bool                 `protobuf:"varint,16,opt,name=field6167" json:"field6167,omitempty"`
+	Field6168 *bool                 `protobuf:"varint,18,opt,name=field6168" json:"field6168,omitempty"`
+	Field6169 []*Message6054        `protobuf:"bytes,17,rep,name=field6169" json:"field6169,omitempty"`
+	Field6170 *int32                `protobuf:"varint,19,opt,name=field6170" json:"field6170,omitempty"`
+}
+
+func (x *Message6126) Reset() {
+	*x = Message6126{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[8]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6126) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6126) ProtoMessage() {}
+
+func (x *Message6126) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[8]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6126.ProtoReflect.Descriptor instead.
+func (*Message6126) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *Message6126) GetField6152() string {
+	if x != nil && x.Field6152 != nil {
+		return *x.Field6152
+	}
+	return ""
+}
+
+func (x *Message6126) GetField6153() []*Message6127 {
+	if x != nil {
+		return x.Field6153
+	}
+	return nil
+}
+
+func (x *Message6126) GetField6154() int32 {
+	if x != nil && x.Field6154 != nil {
+		return *x.Field6154
+	}
+	return 0
+}
+
+func (x *Message6126) GetField6155() []byte {
+	if x != nil {
+		return x.Field6155
+	}
+	return nil
+}
+
+func (x *Message6126) GetField6156() *Message6024 {
+	if x != nil {
+		return x.Field6156
+	}
+	return nil
+}
+
+func (x *Message6126) GetField6157() int32 {
+	if x != nil && x.Field6157 != nil {
+		return *x.Field6157
+	}
+	return 0
+}
+
+func (x *Message6126) GetField6158() string {
+	if x != nil && x.Field6158 != nil {
+		return *x.Field6158
+	}
+	return ""
+}
+
+func (x *Message6126) GetField6159() int32 {
+	if x != nil && x.Field6159 != nil {
+		return *x.Field6159
+	}
+	return 0
+}
+
+func (x *Message6126) GetField6160() []int32 {
+	if x != nil {
+		return x.Field6160
+	}
+	return nil
+}
+
+func (x *Message6126) GetField6161() []int32 {
+	if x != nil {
+		return x.Field6161
+	}
+	return nil
+}
+
+func (x *Message6126) GetField6162() []*Message6052 {
+	if x != nil {
+		return x.Field6162
+	}
+	return nil
+}
+
+func (x *Message6126) GetField6163() []*UnusedEmptyMessage {
+	if x != nil {
+		return x.Field6163
+	}
+	return nil
+}
+
+func (x *Message6126) GetField6164() Enum6065 {
+	if x != nil && x.Field6164 != nil {
+		return *x.Field6164
+	}
+	return Enum6065_ENUM_VALUE6066
+}
+
+func (x *Message6126) GetField6165() []*Message6127 {
+	if x != nil {
+		return x.Field6165
+	}
+	return nil
+}
+
+func (x *Message6126) GetField6166() bool {
+	if x != nil && x.Field6166 != nil {
+		return *x.Field6166
+	}
+	return false
+}
+
+func (x *Message6126) GetField6167() bool {
+	if x != nil && x.Field6167 != nil {
+		return *x.Field6167
+	}
+	return false
+}
+
+func (x *Message6126) GetField6168() bool {
+	if x != nil && x.Field6168 != nil {
+		return *x.Field6168
+	}
+	return false
+}
+
+func (x *Message6126) GetField6169() []*Message6054 {
+	if x != nil {
+		return x.Field6169
+	}
+	return nil
+}
+
+func (x *Message6126) GetField6170() int32 {
+	if x != nil && x.Field6170 != nil {
+		return *x.Field6170
+	}
+	return 0
+}
+
+type Message5881 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field5897 *float64            `protobuf:"fixed64,1,req,name=field5897" json:"field5897,omitempty"`
+	Field5898 *string             `protobuf:"bytes,5,opt,name=field5898" json:"field5898,omitempty"`
+	Field5899 *Message5861        `protobuf:"bytes,2,opt,name=field5899" json:"field5899,omitempty"`
+	Field5900 *UnusedEmptyMessage `protobuf:"bytes,3,opt,name=field5900" json:"field5900,omitempty"`
+	Field5901 *Message5867        `protobuf:"bytes,4,opt,name=field5901" json:"field5901,omitempty"`
+	Field5902 *Message5880        `protobuf:"bytes,6,opt,name=field5902" json:"field5902,omitempty"`
+}
+
+func (x *Message5881) Reset() {
+	*x = Message5881{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[9]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message5881) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message5881) ProtoMessage() {}
+
+func (x *Message5881) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[9]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message5881.ProtoReflect.Descriptor instead.
+func (*Message5881) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP(), []int{9}
+}
+
+func (x *Message5881) GetField5897() float64 {
+	if x != nil && x.Field5897 != nil {
+		return *x.Field5897
+	}
+	return 0
+}
+
+func (x *Message5881) GetField5898() string {
+	if x != nil && x.Field5898 != nil {
+		return *x.Field5898
+	}
+	return ""
+}
+
+func (x *Message5881) GetField5899() *Message5861 {
+	if x != nil {
+		return x.Field5899
+	}
+	return nil
+}
+
+func (x *Message5881) GetField5900() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field5900
+	}
+	return nil
+}
+
+func (x *Message5881) GetField5901() *Message5867 {
+	if x != nil {
+		return x.Field5901
+	}
+	return nil
+}
+
+func (x *Message5881) GetField5902() *Message5880 {
+	if x != nil {
+		return x.Field5902
+	}
+	return nil
+}
+
+type Message6110 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message6110) Reset() {
+	*x = Message6110{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[10]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6110) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6110) ProtoMessage() {}
+
+func (x *Message6110) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[10]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6110.ProtoReflect.Descriptor instead.
+func (*Message6110) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP(), []int{10}
+}
+
+type Message6107 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field6134 *Message4016   `protobuf:"bytes,1,opt,name=field6134" json:"field6134,omitempty"`
+	Field6135 *int32         `protobuf:"varint,2,opt,name=field6135" json:"field6135,omitempty"`
+	Field6136 *string        `protobuf:"bytes,3,opt,name=field6136" json:"field6136,omitempty"`
+	Field6137 []int32        `protobuf:"varint,4,rep,name=field6137" json:"field6137,omitempty"`
+	Field6138 *int32         `protobuf:"varint,5,opt,name=field6138" json:"field6138,omitempty"`
+	Field6139 []*Message6108 `protobuf:"bytes,6,rep,name=field6139" json:"field6139,omitempty"`
+}
+
+func (x *Message6107) Reset() {
+	*x = Message6107{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[11]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6107) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6107) ProtoMessage() {}
+
+func (x *Message6107) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[11]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6107.ProtoReflect.Descriptor instead.
+func (*Message6107) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP(), []int{11}
+}
+
+func (x *Message6107) GetField6134() *Message4016 {
+	if x != nil {
+		return x.Field6134
+	}
+	return nil
+}
+
+func (x *Message6107) GetField6135() int32 {
+	if x != nil && x.Field6135 != nil {
+		return *x.Field6135
+	}
+	return 0
+}
+
+func (x *Message6107) GetField6136() string {
+	if x != nil && x.Field6136 != nil {
+		return *x.Field6136
+	}
+	return ""
+}
+
+func (x *Message6107) GetField6137() []int32 {
+	if x != nil {
+		return x.Field6137
+	}
+	return nil
+}
+
+func (x *Message6107) GetField6138() int32 {
+	if x != nil && x.Field6138 != nil {
+		return *x.Field6138
+	}
+	return 0
+}
+
+func (x *Message6107) GetField6139() []*Message6108 {
+	if x != nil {
+		return x.Field6139
+	}
+	return nil
+}
+
+type Message6129 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field6171 *Enum6130 `protobuf:"varint,1,req,name=field6171,enum=benchmarks.google_message4.Enum6130" json:"field6171,omitempty"`
+	Field6172 *string   `protobuf:"bytes,2,req,name=field6172" json:"field6172,omitempty"`
+}
+
+func (x *Message6129) Reset() {
+	*x = Message6129{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[12]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6129) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6129) ProtoMessage() {}
+
+func (x *Message6129) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[12]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6129.ProtoReflect.Descriptor instead.
+func (*Message6129) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP(), []int{12}
+}
+
+func (x *Message6129) GetField6171() Enum6130 {
+	if x != nil && x.Field6171 != nil {
+		return *x.Field6171
+	}
+	return Enum6130_ENUM_VALUE6131
+}
+
+func (x *Message6129) GetField6172() string {
+	if x != nil && x.Field6172 != nil {
+		return *x.Field6172
+	}
+	return ""
+}
+
+type Message5908 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field5971 *string      `protobuf:"bytes,1,opt,name=field5971" json:"field5971,omitempty"`
+	Field5972 *int32       `protobuf:"varint,2,opt,name=field5972" json:"field5972,omitempty"`
+	Field5973 *int32       `protobuf:"varint,3,opt,name=field5973" json:"field5973,omitempty"`
+	Field5974 *Enum5909    `protobuf:"varint,45,opt,name=field5974,enum=benchmarks.google_message4.Enum5909" json:"field5974,omitempty"`
+	Field5975 *Enum5912    `protobuf:"varint,4,opt,name=field5975,enum=benchmarks.google_message4.Enum5912" json:"field5975,omitempty"`
+	Field5976 *uint32      `protobuf:"fixed32,50,opt,name=field5976" json:"field5976,omitempty"`
+	Field5977 *uint32      `protobuf:"fixed32,5,opt,name=field5977" json:"field5977,omitempty"`
+	Field5978 *uint32      `protobuf:"fixed32,6,opt,name=field5978" json:"field5978,omitempty"`
+	Field5979 *string      `protobuf:"bytes,7,opt,name=field5979" json:"field5979,omitempty"`
+	Field5980 *Enum5915    `protobuf:"varint,8,opt,name=field5980,enum=benchmarks.google_message4.Enum5915" json:"field5980,omitempty"`
+	Field5981 *Message5903 `protobuf:"bytes,9,opt,name=field5981" json:"field5981,omitempty"`
+	Field5982 *Message5903 `protobuf:"bytes,10,opt,name=field5982" json:"field5982,omitempty"`
+	Field5983 *Enum5920    `protobuf:"varint,11,opt,name=field5983,enum=benchmarks.google_message4.Enum5920" json:"field5983,omitempty"`
+	Field5984 *Enum5923    `protobuf:"varint,40,opt,name=field5984,enum=benchmarks.google_message4.Enum5923" json:"field5984,omitempty"`
+	Field5985 *Message5903 `protobuf:"bytes,41,opt,name=field5985" json:"field5985,omitempty"`
+	Field5986 *Message5903 `protobuf:"bytes,42,opt,name=field5986" json:"field5986,omitempty"`
+	Field5987 *Enum5928    `protobuf:"varint,47,opt,name=field5987,enum=benchmarks.google_message4.Enum5928" json:"field5987,omitempty"`
+	Field5988 *bool        `protobuf:"varint,48,opt,name=field5988" json:"field5988,omitempty"`
+	Field5989 []uint32     `protobuf:"fixed32,49,rep,name=field5989" json:"field5989,omitempty"`
+	Field5990 *string      `protobuf:"bytes,12,opt,name=field5990" json:"field5990,omitempty"`
+	Field5991 *Message5903 `protobuf:"bytes,13,opt,name=field5991" json:"field5991,omitempty"`
+	Field5992 *Message5903 `protobuf:"bytes,14,opt,name=field5992" json:"field5992,omitempty"`
+	Field5993 *Message5903 `protobuf:"bytes,15,opt,name=field5993" json:"field5993,omitempty"`
+	Field5994 *Message5903 `protobuf:"bytes,16,opt,name=field5994" json:"field5994,omitempty"`
+	Field5995 *Message5903 `protobuf:"bytes,32,opt,name=field5995" json:"field5995,omitempty"`
+	Field5996 *Message5903 `protobuf:"bytes,33,opt,name=field5996" json:"field5996,omitempty"`
+	Field5997 *Message5903 `protobuf:"bytes,34,opt,name=field5997" json:"field5997,omitempty"`
+	Field5998 *Message5903 `protobuf:"bytes,35,opt,name=field5998" json:"field5998,omitempty"`
+	Field5999 *Enum5931    `protobuf:"varint,17,opt,name=field5999,enum=benchmarks.google_message4.Enum5931" json:"field5999,omitempty"`
+	Field6000 *Enum5935    `protobuf:"varint,18,opt,name=field6000,enum=benchmarks.google_message4.Enum5935" json:"field6000,omitempty"`
+	Field6001 *Enum5939    `protobuf:"varint,36,opt,name=field6001,enum=benchmarks.google_message4.Enum5939" json:"field6001,omitempty"`
+	Field6002 *Enum5939    `protobuf:"varint,37,opt,name=field6002,enum=benchmarks.google_message4.Enum5939" json:"field6002,omitempty"`
+	Field6003 []int32      `protobuf:"varint,19,rep,name=field6003" json:"field6003,omitempty"`
+	Field6004 *uint32      `protobuf:"varint,20,opt,name=field6004" json:"field6004,omitempty"`
+	Field6005 *uint32      `protobuf:"varint,21,opt,name=field6005" json:"field6005,omitempty"`
+	Field6006 *uint32      `protobuf:"varint,22,opt,name=field6006" json:"field6006,omitempty"`
+	Field6007 *uint32      `protobuf:"varint,23,opt,name=field6007" json:"field6007,omitempty"`
+	Field6008 *Enum5946    `protobuf:"varint,24,opt,name=field6008,enum=benchmarks.google_message4.Enum5946" json:"field6008,omitempty"`
+	Field6009 *Enum5946    `protobuf:"varint,25,opt,name=field6009,enum=benchmarks.google_message4.Enum5946" json:"field6009,omitempty"`
+	Field6010 *Enum5946    `protobuf:"varint,26,opt,name=field6010,enum=benchmarks.google_message4.Enum5946" json:"field6010,omitempty"`
+	Field6011 *Enum5946    `protobuf:"varint,27,opt,name=field6011,enum=benchmarks.google_message4.Enum5946" json:"field6011,omitempty"`
+	Field6012 *uint32      `protobuf:"fixed32,28,opt,name=field6012" json:"field6012,omitempty"`
+	Field6013 *uint32      `protobuf:"fixed32,29,opt,name=field6013" json:"field6013,omitempty"`
+	Field6014 *uint32      `protobuf:"fixed32,30,opt,name=field6014" json:"field6014,omitempty"`
+	Field6015 *uint32      `protobuf:"fixed32,31,opt,name=field6015" json:"field6015,omitempty"`
+	Field6016 *int32       `protobuf:"varint,38,opt,name=field6016" json:"field6016,omitempty"`
+	Field6017 *float32     `protobuf:"fixed32,39,opt,name=field6017" json:"field6017,omitempty"`
+	Field6018 *Enum5957    `protobuf:"varint,43,opt,name=field6018,enum=benchmarks.google_message4.Enum5957" json:"field6018,omitempty"`
+	Field6019 *Message5907 `protobuf:"bytes,44,opt,name=field6019" json:"field6019,omitempty"`
+	Field6020 *Enum5962    `protobuf:"varint,46,opt,name=field6020,enum=benchmarks.google_message4.Enum5962" json:"field6020,omitempty"`
+}
+
+func (x *Message5908) Reset() {
+	*x = Message5908{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[13]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message5908) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message5908) ProtoMessage() {}
+
+func (x *Message5908) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[13]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message5908.ProtoReflect.Descriptor instead.
+func (*Message5908) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP(), []int{13}
+}
+
+func (x *Message5908) GetField5971() string {
+	if x != nil && x.Field5971 != nil {
+		return *x.Field5971
+	}
+	return ""
+}
+
+func (x *Message5908) GetField5972() int32 {
+	if x != nil && x.Field5972 != nil {
+		return *x.Field5972
+	}
+	return 0
+}
+
+func (x *Message5908) GetField5973() int32 {
+	if x != nil && x.Field5973 != nil {
+		return *x.Field5973
+	}
+	return 0
+}
+
+func (x *Message5908) GetField5974() Enum5909 {
+	if x != nil && x.Field5974 != nil {
+		return *x.Field5974
+	}
+	return Enum5909_ENUM_VALUE5910
+}
+
+func (x *Message5908) GetField5975() Enum5912 {
+	if x != nil && x.Field5975 != nil {
+		return *x.Field5975
+	}
+	return Enum5912_ENUM_VALUE5913
+}
+
+func (x *Message5908) GetField5976() uint32 {
+	if x != nil && x.Field5976 != nil {
+		return *x.Field5976
+	}
+	return 0
+}
+
+func (x *Message5908) GetField5977() uint32 {
+	if x != nil && x.Field5977 != nil {
+		return *x.Field5977
+	}
+	return 0
+}
+
+func (x *Message5908) GetField5978() uint32 {
+	if x != nil && x.Field5978 != nil {
+		return *x.Field5978
+	}
+	return 0
+}
+
+func (x *Message5908) GetField5979() string {
+	if x != nil && x.Field5979 != nil {
+		return *x.Field5979
+	}
+	return ""
+}
+
+func (x *Message5908) GetField5980() Enum5915 {
+	if x != nil && x.Field5980 != nil {
+		return *x.Field5980
+	}
+	return Enum5915_ENUM_VALUE5916
+}
+
+func (x *Message5908) GetField5981() *Message5903 {
+	if x != nil {
+		return x.Field5981
+	}
+	return nil
+}
+
+func (x *Message5908) GetField5982() *Message5903 {
+	if x != nil {
+		return x.Field5982
+	}
+	return nil
+}
+
+func (x *Message5908) GetField5983() Enum5920 {
+	if x != nil && x.Field5983 != nil {
+		return *x.Field5983
+	}
+	return Enum5920_ENUM_VALUE5921
+}
+
+func (x *Message5908) GetField5984() Enum5923 {
+	if x != nil && x.Field5984 != nil {
+		return *x.Field5984
+	}
+	return Enum5923_ENUM_VALUE5924
+}
+
+func (x *Message5908) GetField5985() *Message5903 {
+	if x != nil {
+		return x.Field5985
+	}
+	return nil
+}
+
+func (x *Message5908) GetField5986() *Message5903 {
+	if x != nil {
+		return x.Field5986
+	}
+	return nil
+}
+
+func (x *Message5908) GetField5987() Enum5928 {
+	if x != nil && x.Field5987 != nil {
+		return *x.Field5987
+	}
+	return Enum5928_ENUM_VALUE5929
+}
+
+func (x *Message5908) GetField5988() bool {
+	if x != nil && x.Field5988 != nil {
+		return *x.Field5988
+	}
+	return false
+}
+
+func (x *Message5908) GetField5989() []uint32 {
+	if x != nil {
+		return x.Field5989
+	}
+	return nil
+}
+
+func (x *Message5908) GetField5990() string {
+	if x != nil && x.Field5990 != nil {
+		return *x.Field5990
+	}
+	return ""
+}
+
+func (x *Message5908) GetField5991() *Message5903 {
+	if x != nil {
+		return x.Field5991
+	}
+	return nil
+}
+
+func (x *Message5908) GetField5992() *Message5903 {
+	if x != nil {
+		return x.Field5992
+	}
+	return nil
+}
+
+func (x *Message5908) GetField5993() *Message5903 {
+	if x != nil {
+		return x.Field5993
+	}
+	return nil
+}
+
+func (x *Message5908) GetField5994() *Message5903 {
+	if x != nil {
+		return x.Field5994
+	}
+	return nil
+}
+
+func (x *Message5908) GetField5995() *Message5903 {
+	if x != nil {
+		return x.Field5995
+	}
+	return nil
+}
+
+func (x *Message5908) GetField5996() *Message5903 {
+	if x != nil {
+		return x.Field5996
+	}
+	return nil
+}
+
+func (x *Message5908) GetField5997() *Message5903 {
+	if x != nil {
+		return x.Field5997
+	}
+	return nil
+}
+
+func (x *Message5908) GetField5998() *Message5903 {
+	if x != nil {
+		return x.Field5998
+	}
+	return nil
+}
+
+func (x *Message5908) GetField5999() Enum5931 {
+	if x != nil && x.Field5999 != nil {
+		return *x.Field5999
+	}
+	return Enum5931_ENUM_VALUE5932
+}
+
+func (x *Message5908) GetField6000() Enum5935 {
+	if x != nil && x.Field6000 != nil {
+		return *x.Field6000
+	}
+	return Enum5935_ENUM_VALUE5936
+}
+
+func (x *Message5908) GetField6001() Enum5939 {
+	if x != nil && x.Field6001 != nil {
+		return *x.Field6001
+	}
+	return Enum5939_ENUM_VALUE5940
+}
+
+func (x *Message5908) GetField6002() Enum5939 {
+	if x != nil && x.Field6002 != nil {
+		return *x.Field6002
+	}
+	return Enum5939_ENUM_VALUE5940
+}
+
+func (x *Message5908) GetField6003() []int32 {
+	if x != nil {
+		return x.Field6003
+	}
+	return nil
+}
+
+func (x *Message5908) GetField6004() uint32 {
+	if x != nil && x.Field6004 != nil {
+		return *x.Field6004
+	}
+	return 0
+}
+
+func (x *Message5908) GetField6005() uint32 {
+	if x != nil && x.Field6005 != nil {
+		return *x.Field6005
+	}
+	return 0
+}
+
+func (x *Message5908) GetField6006() uint32 {
+	if x != nil && x.Field6006 != nil {
+		return *x.Field6006
+	}
+	return 0
+}
+
+func (x *Message5908) GetField6007() uint32 {
+	if x != nil && x.Field6007 != nil {
+		return *x.Field6007
+	}
+	return 0
+}
+
+func (x *Message5908) GetField6008() Enum5946 {
+	if x != nil && x.Field6008 != nil {
+		return *x.Field6008
+	}
+	return Enum5946_ENUM_VALUE5947
+}
+
+func (x *Message5908) GetField6009() Enum5946 {
+	if x != nil && x.Field6009 != nil {
+		return *x.Field6009
+	}
+	return Enum5946_ENUM_VALUE5947
+}
+
+func (x *Message5908) GetField6010() Enum5946 {
+	if x != nil && x.Field6010 != nil {
+		return *x.Field6010
+	}
+	return Enum5946_ENUM_VALUE5947
+}
+
+func (x *Message5908) GetField6011() Enum5946 {
+	if x != nil && x.Field6011 != nil {
+		return *x.Field6011
+	}
+	return Enum5946_ENUM_VALUE5947
+}
+
+func (x *Message5908) GetField6012() uint32 {
+	if x != nil && x.Field6012 != nil {
+		return *x.Field6012
+	}
+	return 0
+}
+
+func (x *Message5908) GetField6013() uint32 {
+	if x != nil && x.Field6013 != nil {
+		return *x.Field6013
+	}
+	return 0
+}
+
+func (x *Message5908) GetField6014() uint32 {
+	if x != nil && x.Field6014 != nil {
+		return *x.Field6014
+	}
+	return 0
+}
+
+func (x *Message5908) GetField6015() uint32 {
+	if x != nil && x.Field6015 != nil {
+		return *x.Field6015
+	}
+	return 0
+}
+
+func (x *Message5908) GetField6016() int32 {
+	if x != nil && x.Field6016 != nil {
+		return *x.Field6016
+	}
+	return 0
+}
+
+func (x *Message5908) GetField6017() float32 {
+	if x != nil && x.Field6017 != nil {
+		return *x.Field6017
+	}
+	return 0
+}
+
+func (x *Message5908) GetField6018() Enum5957 {
+	if x != nil && x.Field6018 != nil {
+		return *x.Field6018
+	}
+	return Enum5957_ENUM_VALUE5958
+}
+
+func (x *Message5908) GetField6019() *Message5907 {
+	if x != nil {
+		return x.Field6019
+	}
+	return nil
+}
+
+func (x *Message5908) GetField6020() Enum5962 {
+	if x != nil && x.Field6020 != nil {
+		return *x.Field6020
+	}
+	return Enum5962_ENUM_VALUE5963
+}
+
+type Message3850 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field3924 *Enum3851 `protobuf:"varint,2,opt,name=field3924,enum=benchmarks.google_message4.Enum3851" json:"field3924,omitempty"`
+	Field3925 *bool     `protobuf:"varint,12,opt,name=field3925" json:"field3925,omitempty"`
+	Field3926 *int32    `protobuf:"varint,4,opt,name=field3926" json:"field3926,omitempty"`
+	Field3927 *bool     `protobuf:"varint,10,opt,name=field3927" json:"field3927,omitempty"`
+	Field3928 *bool     `protobuf:"varint,13,opt,name=field3928" json:"field3928,omitempty"`
+	Field3929 *bool     `protobuf:"varint,14,opt,name=field3929" json:"field3929,omitempty"`
+}
+
+func (x *Message3850) Reset() {
+	*x = Message3850{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[14]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message3850) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message3850) ProtoMessage() {}
+
+func (x *Message3850) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[14]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message3850.ProtoReflect.Descriptor instead.
+func (*Message3850) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP(), []int{14}
+}
+
+func (x *Message3850) GetField3924() Enum3851 {
+	if x != nil && x.Field3924 != nil {
+		return *x.Field3924
+	}
+	return Enum3851_ENUM_VALUE3852
+}
+
+func (x *Message3850) GetField3925() bool {
+	if x != nil && x.Field3925 != nil {
+		return *x.Field3925
+	}
+	return false
+}
+
+func (x *Message3850) GetField3926() int32 {
+	if x != nil && x.Field3926 != nil {
+		return *x.Field3926
+	}
+	return 0
+}
+
+func (x *Message3850) GetField3927() bool {
+	if x != nil && x.Field3927 != nil {
+		return *x.Field3927
+	}
+	return false
+}
+
+func (x *Message3850) GetField3928() bool {
+	if x != nil && x.Field3928 != nil {
+		return *x.Field3928
+	}
+	return false
+}
+
+func (x *Message3850) GetField3929() bool {
+	if x != nil && x.Field3929 != nil {
+		return *x.Field3929
+	}
+	return false
+}
+
+type Message7865 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message7865) Reset() {
+	*x = Message7865{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[15]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message7865) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message7865) ProtoMessage() {}
+
+func (x *Message7865) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[15]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message7865.ProtoReflect.Descriptor instead.
+func (*Message7865) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP(), []int{15}
+}
+
+type Message7511 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field7523 *bool     `protobuf:"varint,1,opt,name=field7523" json:"field7523,omitempty"`
+	Field7524 *Enum7512 `protobuf:"varint,2,opt,name=field7524,enum=benchmarks.google_message4.Enum7512" json:"field7524,omitempty"`
+	Field7525 *int32    `protobuf:"varint,3,opt,name=field7525" json:"field7525,omitempty"`
+	Field7526 *int32    `protobuf:"varint,4,opt,name=field7526" json:"field7526,omitempty"`
+	Field7527 *bool     `protobuf:"varint,5,opt,name=field7527" json:"field7527,omitempty"`
+	Field7528 *int32    `protobuf:"varint,6,opt,name=field7528" json:"field7528,omitempty"`
+	Field7529 *int32    `protobuf:"varint,7,opt,name=field7529" json:"field7529,omitempty"`
+}
+
+func (x *Message7511) Reset() {
+	*x = Message7511{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[16]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message7511) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message7511) ProtoMessage() {}
+
+func (x *Message7511) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[16]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message7511.ProtoReflect.Descriptor instead.
+func (*Message7511) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP(), []int{16}
+}
+
+func (x *Message7511) GetField7523() bool {
+	if x != nil && x.Field7523 != nil {
+		return *x.Field7523
+	}
+	return false
+}
+
+func (x *Message7511) GetField7524() Enum7512 {
+	if x != nil && x.Field7524 != nil {
+		return *x.Field7524
+	}
+	return Enum7512_ENUM_VALUE7513
+}
+
+func (x *Message7511) GetField7525() int32 {
+	if x != nil && x.Field7525 != nil {
+		return *x.Field7525
+	}
+	return 0
+}
+
+func (x *Message7511) GetField7526() int32 {
+	if x != nil && x.Field7526 != nil {
+		return *x.Field7526
+	}
+	return 0
+}
+
+func (x *Message7511) GetField7527() bool {
+	if x != nil && x.Field7527 != nil {
+		return *x.Field7527
+	}
+	return false
+}
+
+func (x *Message7511) GetField7528() int32 {
+	if x != nil && x.Field7528 != nil {
+		return *x.Field7528
+	}
+	return 0
+}
+
+func (x *Message7511) GetField7529() int32 {
+	if x != nil && x.Field7529 != nil {
+		return *x.Field7529
+	}
+	return 0
+}
+
+type Message3920 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message3920) Reset() {
+	*x = Message3920{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[17]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message3920) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message3920) ProtoMessage() {}
+
+func (x *Message3920) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[17]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message3920.ProtoReflect.Descriptor instead.
+func (*Message3920) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP(), []int{17}
+}
+
+type Message7928 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field7940 *string `protobuf:"bytes,1,opt,name=field7940" json:"field7940,omitempty"`
+	Field7941 *int64  `protobuf:"varint,2,opt,name=field7941" json:"field7941,omitempty"`
+}
+
+func (x *Message7928) Reset() {
+	*x = Message7928{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[18]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message7928) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message7928) ProtoMessage() {}
+
+func (x *Message7928) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[18]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message7928.ProtoReflect.Descriptor instead.
+func (*Message7928) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP(), []int{18}
+}
+
+func (x *Message7928) GetField7940() string {
+	if x != nil && x.Field7940 != nil {
+		return *x.Field7940
+	}
+	return ""
+}
+
+func (x *Message7928) GetField7941() int64 {
+	if x != nil && x.Field7941 != nil {
+		return *x.Field7941
+	}
+	return 0
+}
+
+type Message7921 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field7936 *int32    `protobuf:"varint,1,opt,name=field7936" json:"field7936,omitempty"`
+	Field7937 *int64    `protobuf:"varint,2,opt,name=field7937" json:"field7937,omitempty"`
+	Field7938 *float32  `protobuf:"fixed32,3,opt,name=field7938" json:"field7938,omitempty"`
+	Field7939 *Enum7922 `protobuf:"varint,4,opt,name=field7939,enum=benchmarks.google_message4.Enum7922" json:"field7939,omitempty"`
+}
+
+func (x *Message7921) Reset() {
+	*x = Message7921{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[19]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message7921) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message7921) ProtoMessage() {}
+
+func (x *Message7921) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[19]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message7921.ProtoReflect.Descriptor instead.
+func (*Message7921) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP(), []int{19}
+}
+
+func (x *Message7921) GetField7936() int32 {
+	if x != nil && x.Field7936 != nil {
+		return *x.Field7936
+	}
+	return 0
+}
+
+func (x *Message7921) GetField7937() int64 {
+	if x != nil && x.Field7937 != nil {
+		return *x.Field7937
+	}
+	return 0
+}
+
+func (x *Message7921) GetField7938() float32 {
+	if x != nil && x.Field7938 != nil {
+		return *x.Field7938
+	}
+	return 0
+}
+
+func (x *Message7921) GetField7939() Enum7922 {
+	if x != nil && x.Field7939 != nil {
+		return *x.Field7939
+	}
+	return Enum7922_ENUM_VALUE7923
+}
+
+type Message7920 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field7934 *int64 `protobuf:"varint,1,opt,name=field7934" json:"field7934,omitempty"`
+	Field7935 *int64 `protobuf:"varint,2,opt,name=field7935" json:"field7935,omitempty"`
+}
+
+func (x *Message7920) Reset() {
+	*x = Message7920{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[20]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message7920) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message7920) ProtoMessage() {}
+
+func (x *Message7920) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[20]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message7920.ProtoReflect.Descriptor instead.
+func (*Message7920) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP(), []int{20}
+}
+
+func (x *Message7920) GetField7934() int64 {
+	if x != nil && x.Field7934 != nil {
+		return *x.Field7934
+	}
+	return 0
+}
+
+func (x *Message7920) GetField7935() int64 {
+	if x != nil && x.Field7935 != nil {
+		return *x.Field7935
+	}
+	return 0
+}
+
+type Message7919 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field7931 *uint64 `protobuf:"fixed64,1,opt,name=field7931" json:"field7931,omitempty"`
+	Field7932 *int64  `protobuf:"varint,2,opt,name=field7932" json:"field7932,omitempty"`
+	Field7933 []byte  `protobuf:"bytes,3,opt,name=field7933" json:"field7933,omitempty"`
+}
+
+func (x *Message7919) Reset() {
+	*x = Message7919{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[21]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message7919) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message7919) ProtoMessage() {}
+
+func (x *Message7919) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[21]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message7919.ProtoReflect.Descriptor instead.
+func (*Message7919) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP(), []int{21}
+}
+
+func (x *Message7919) GetField7931() uint64 {
+	if x != nil && x.Field7931 != nil {
+		return *x.Field7931
+	}
+	return 0
+}
+
+func (x *Message7919) GetField7932() int64 {
+	if x != nil && x.Field7932 != nil {
+		return *x.Field7932
+	}
+	return 0
+}
+
+func (x *Message7919) GetField7933() []byte {
+	if x != nil {
+		return x.Field7933
+	}
+	return nil
+}
+
+type Message12817 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field12826 *int32 `protobuf:"varint,1,opt,name=field12826" json:"field12826,omitempty"`
+	Field12827 *int32 `protobuf:"varint,2,opt,name=field12827" json:"field12827,omitempty"`
+	Field12828 *int32 `protobuf:"varint,3,opt,name=field12828" json:"field12828,omitempty"`
+}
+
+func (x *Message12817) Reset() {
+	*x = Message12817{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[22]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message12817) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message12817) ProtoMessage() {}
+
+func (x *Message12817) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[22]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message12817.ProtoReflect.Descriptor instead.
+func (*Message12817) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP(), []int{22}
+}
+
+func (x *Message12817) GetField12826() int32 {
+	if x != nil && x.Field12826 != nil {
+		return *x.Field12826
+	}
+	return 0
+}
+
+func (x *Message12817) GetField12827() int32 {
+	if x != nil && x.Field12827 != nil {
+		return *x.Field12827
+	}
+	return 0
+}
+
+func (x *Message12817) GetField12828() int32 {
+	if x != nil && x.Field12828 != nil {
+		return *x.Field12828
+	}
+	return 0
+}
+
+type Message6054 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field6089 *string `protobuf:"bytes,1,req,name=field6089" json:"field6089,omitempty"`
+	Field6090 *string `protobuf:"bytes,2,opt,name=field6090" json:"field6090,omitempty"`
+}
+
+func (x *Message6054) Reset() {
+	*x = Message6054{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[23]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6054) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6054) ProtoMessage() {}
+
+func (x *Message6054) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[23]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6054.ProtoReflect.Descriptor instead.
+func (*Message6054) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP(), []int{23}
+}
+
+func (x *Message6054) GetField6089() string {
+	if x != nil && x.Field6089 != nil {
+		return *x.Field6089
+	}
+	return ""
+}
+
+func (x *Message6054) GetField6090() string {
+	if x != nil && x.Field6090 != nil {
+		return *x.Field6090
+	}
+	return ""
+}
+
+type Message6127 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message6127) Reset() {
+	*x = Message6127{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[24]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6127) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6127) ProtoMessage() {}
+
+func (x *Message6127) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[24]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6127.ProtoReflect.Descriptor instead.
+func (*Message6127) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP(), []int{24}
+}
+
+type Message6052 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field6084 *string `protobuf:"bytes,1,req,name=field6084" json:"field6084,omitempty"`
+	Field6085 []byte  `protobuf:"bytes,2,req,name=field6085" json:"field6085,omitempty"`
+}
+
+func (x *Message6052) Reset() {
+	*x = Message6052{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[25]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6052) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6052) ProtoMessage() {}
+
+func (x *Message6052) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[25]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6052.ProtoReflect.Descriptor instead.
+func (*Message6052) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP(), []int{25}
+}
+
+func (x *Message6052) GetField6084() string {
+	if x != nil && x.Field6084 != nil {
+		return *x.Field6084
+	}
+	return ""
+}
+
+func (x *Message6052) GetField6085() []byte {
+	if x != nil {
+		return x.Field6085
+	}
+	return nil
+}
+
+type Message6024 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field6048 *Enum6025           `protobuf:"varint,1,opt,name=field6048,enum=benchmarks.google_message4.Enum6025" json:"field6048,omitempty"`
+	Field6049 *string             `protobuf:"bytes,2,opt,name=field6049" json:"field6049,omitempty"`
+	Field6050 *UnusedEmptyMessage `protobuf:"bytes,3,opt,name=field6050" json:"field6050,omitempty"`
+}
+
+func (x *Message6024) Reset() {
+	*x = Message6024{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[26]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6024) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6024) ProtoMessage() {}
+
+func (x *Message6024) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[26]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6024.ProtoReflect.Descriptor instead.
+func (*Message6024) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP(), []int{26}
+}
+
+func (x *Message6024) GetField6048() Enum6025 {
+	if x != nil && x.Field6048 != nil {
+		return *x.Field6048
+	}
+	return Enum6025_ENUM_VALUE6026
+}
+
+func (x *Message6024) GetField6049() string {
+	if x != nil && x.Field6049 != nil {
+		return *x.Field6049
+	}
+	return ""
+}
+
+func (x *Message6024) GetField6050() *UnusedEmptyMessage {
+	if x != nil {
+		return x.Field6050
+	}
+	return nil
+}
+
+type Message5861 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field5882 *Enum5862 `protobuf:"varint,1,req,name=field5882,enum=benchmarks.google_message4.Enum5862" json:"field5882,omitempty"`
+	Field5883 *string   `protobuf:"bytes,2,req,name=field5883" json:"field5883,omitempty"`
+	Field5884 *bool     `protobuf:"varint,3,opt,name=field5884" json:"field5884,omitempty"`
+	Field5885 *string   `protobuf:"bytes,4,opt,name=field5885" json:"field5885,omitempty"`
+}
+
+func (x *Message5861) Reset() {
+	*x = Message5861{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[27]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message5861) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message5861) ProtoMessage() {}
+
+func (x *Message5861) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[27]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message5861.ProtoReflect.Descriptor instead.
+func (*Message5861) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP(), []int{27}
+}
+
+func (x *Message5861) GetField5882() Enum5862 {
+	if x != nil && x.Field5882 != nil {
+		return *x.Field5882
+	}
+	return Enum5862_ENUM_VALUE5863
+}
+
+func (x *Message5861) GetField5883() string {
+	if x != nil && x.Field5883 != nil {
+		return *x.Field5883
+	}
+	return ""
+}
+
+func (x *Message5861) GetField5884() bool {
+	if x != nil && x.Field5884 != nil {
+		return *x.Field5884
+	}
+	return false
+}
+
+func (x *Message5861) GetField5885() string {
+	if x != nil && x.Field5885 != nil {
+		return *x.Field5885
+	}
+	return ""
+}
+
+type Message5880 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field5896 *string `protobuf:"bytes,1,opt,name=field5896" json:"field5896,omitempty"`
+}
+
+func (x *Message5880) Reset() {
+	*x = Message5880{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[28]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message5880) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message5880) ProtoMessage() {}
+
+func (x *Message5880) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[28]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message5880.ProtoReflect.Descriptor instead.
+func (*Message5880) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP(), []int{28}
+}
+
+func (x *Message5880) GetField5896() string {
+	if x != nil && x.Field5896 != nil {
+		return *x.Field5896
+	}
+	return ""
+}
+
+type Message5867 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field5890 *Enum5868   `protobuf:"varint,1,opt,name=field5890,enum=benchmarks.google_message4.Enum5868" json:"field5890,omitempty"`
+	Field5891 *string     `protobuf:"bytes,2,opt,name=field5891" json:"field5891,omitempty"`
+	Field5892 *Enum5873   `protobuf:"varint,3,opt,name=field5892,enum=benchmarks.google_message4.Enum5873" json:"field5892,omitempty"`
+	Field5893 *int32      `protobuf:"varint,4,opt,name=field5893" json:"field5893,omitempty"`
+	Field5894 *UnusedEnum `protobuf:"varint,5,opt,name=field5894,enum=benchmarks.google_message4.UnusedEnum" json:"field5894,omitempty"`
+	Field5895 *bool       `protobuf:"varint,6,opt,name=field5895" json:"field5895,omitempty"`
+}
+
+func (x *Message5867) Reset() {
+	*x = Message5867{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[29]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message5867) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message5867) ProtoMessage() {}
+
+func (x *Message5867) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[29]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message5867.ProtoReflect.Descriptor instead.
+func (*Message5867) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP(), []int{29}
+}
+
+func (x *Message5867) GetField5890() Enum5868 {
+	if x != nil && x.Field5890 != nil {
+		return *x.Field5890
+	}
+	return Enum5868_ENUM_VALUE5869
+}
+
+func (x *Message5867) GetField5891() string {
+	if x != nil && x.Field5891 != nil {
+		return *x.Field5891
+	}
+	return ""
+}
+
+func (x *Message5867) GetField5892() Enum5873 {
+	if x != nil && x.Field5892 != nil {
+		return *x.Field5892
+	}
+	return Enum5873_ENUM_VALUE5874
+}
+
+func (x *Message5867) GetField5893() int32 {
+	if x != nil && x.Field5893 != nil {
+		return *x.Field5893
+	}
+	return 0
+}
+
+func (x *Message5867) GetField5894() UnusedEnum {
+	if x != nil && x.Field5894 != nil {
+		return *x.Field5894
+	}
+	return UnusedEnum_UNUSED_ENUM_VALUE1
+}
+
+func (x *Message5867) GetField5895() bool {
+	if x != nil && x.Field5895 != nil {
+		return *x.Field5895
+	}
+	return false
+}
+
+type Message4016 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field4017 *int32 `protobuf:"varint,1,req,name=field4017" json:"field4017,omitempty"`
+	Field4018 *int32 `protobuf:"varint,2,req,name=field4018" json:"field4018,omitempty"`
+	Field4019 *int32 `protobuf:"varint,3,req,name=field4019" json:"field4019,omitempty"`
+	Field4020 *int32 `protobuf:"varint,4,req,name=field4020" json:"field4020,omitempty"`
+}
+
+func (x *Message4016) Reset() {
+	*x = Message4016{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[30]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message4016) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message4016) ProtoMessage() {}
+
+func (x *Message4016) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[30]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message4016.ProtoReflect.Descriptor instead.
+func (*Message4016) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP(), []int{30}
+}
+
+func (x *Message4016) GetField4017() int32 {
+	if x != nil && x.Field4017 != nil {
+		return *x.Field4017
+	}
+	return 0
+}
+
+func (x *Message4016) GetField4018() int32 {
+	if x != nil && x.Field4018 != nil {
+		return *x.Field4018
+	}
+	return 0
+}
+
+func (x *Message4016) GetField4019() int32 {
+	if x != nil && x.Field4019 != nil {
+		return *x.Field4019
+	}
+	return 0
+}
+
+func (x *Message4016) GetField4020() int32 {
+	if x != nil && x.Field4020 != nil {
+		return *x.Field4020
+	}
+	return 0
+}
+
+type Message6108 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message6108) Reset() {
+	*x = Message6108{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[31]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message6108) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message6108) ProtoMessage() {}
+
+func (x *Message6108) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[31]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message6108.ProtoReflect.Descriptor instead.
+func (*Message6108) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP(), []int{31}
+}
+
+type Message5907 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field5967 *Message5903 `protobuf:"bytes,1,opt,name=field5967" json:"field5967,omitempty"`
+	Field5968 *Message5903 `protobuf:"bytes,2,opt,name=field5968" json:"field5968,omitempty"`
+	Field5969 *Message5903 `protobuf:"bytes,3,opt,name=field5969" json:"field5969,omitempty"`
+	Field5970 *Message5903 `protobuf:"bytes,4,opt,name=field5970" json:"field5970,omitempty"`
+}
+
+func (x *Message5907) Reset() {
+	*x = Message5907{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[32]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message5907) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message5907) ProtoMessage() {}
+
+func (x *Message5907) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[32]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message5907.ProtoReflect.Descriptor instead.
+func (*Message5907) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP(), []int{32}
+}
+
+func (x *Message5907) GetField5967() *Message5903 {
+	if x != nil {
+		return x.Field5967
+	}
+	return nil
+}
+
+func (x *Message5907) GetField5968() *Message5903 {
+	if x != nil {
+		return x.Field5968
+	}
+	return nil
+}
+
+func (x *Message5907) GetField5969() *Message5903 {
+	if x != nil {
+		return x.Field5969
+	}
+	return nil
+}
+
+func (x *Message5907) GetField5970() *Message5903 {
+	if x != nil {
+		return x.Field5970
+	}
+	return nil
+}
+
+type UnusedEmptyMessage struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *UnusedEmptyMessage) Reset() {
+	*x = UnusedEmptyMessage{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[33]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *UnusedEmptyMessage) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*UnusedEmptyMessage) ProtoMessage() {}
+
+func (x *UnusedEmptyMessage) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[33]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use UnusedEmptyMessage.ProtoReflect.Descriptor instead.
+func (*UnusedEmptyMessage) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP(), []int{33}
+}
+
+type Message5903 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Field5965 *int32    `protobuf:"varint,1,req,name=field5965" json:"field5965,omitempty"`
+	Field5966 *Enum5904 `protobuf:"varint,2,opt,name=field5966,enum=benchmarks.google_message4.Enum5904" json:"field5966,omitempty"`
+}
+
+func (x *Message5903) Reset() {
+	*x = Message5903{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[34]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message5903) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message5903) ProtoMessage() {}
+
+func (x *Message5903) ProtoReflect() protoreflect.Message {
+	mi := &file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[34]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message5903.ProtoReflect.Descriptor instead.
+func (*Message5903) Descriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP(), []int{34}
+}
+
+func (x *Message5903) GetField5965() int32 {
+	if x != nil && x.Field5965 != nil {
+		return *x.Field5965
+	}
+	return 0
+}
+
+func (x *Message5903) GetField5966() Enum5904 {
+	if x != nil && x.Field5966 != nil {
+		return *x.Field5966
+	}
+	return Enum5904_ENUM_VALUE5905
+}
+
+var File_datasets_google_message4_benchmark_message4_2_proto protoreflect.FileDescriptor
+
+var file_datasets_google_message4_benchmark_message4_2_proto_rawDesc = []byte{
+	0x0a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x5f, 0x32, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1a, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x34, 0x1a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2f, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x5f, 0x33,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xce, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x31, 0x32, 0x37, 0x37, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x37, 0x37, 0x37, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x37, 0x37, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x37, 0x37, 0x38, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x37, 0x37, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x37, 0x37, 0x39, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x37, 0x37, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x37, 0x38, 0x30, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x37, 0x38, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x37, 0x38, 0x31, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x37, 0x38, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x37, 0x38, 0x32, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x37, 0x38, 0x32, 0x22, 0x4e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x31, 0x32, 0x37, 0x39, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x38, 0x30, 0x30, 0x18, 0x01, 0x20, 0x03, 0x28, 0x06, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x38, 0x30, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x38, 0x30, 0x31, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x38, 0x30, 0x31, 0x22, 0xae, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x31, 0x32, 0x38, 0x32, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x32, 0x38, 0x34, 0x38, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x34, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x32, 0x38, 0x34, 0x39, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x34, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x32, 0x38, 0x35, 0x30, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x35, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x32, 0x38, 0x35, 0x31, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x35, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x31, 0x32, 0x38, 0x35, 0x32, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x35, 0x32, 0x22, 0x8e, 0x02, 0x0a, 0x0c, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x38, 0x32, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x38, 0x34, 0x30, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x34, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x38, 0x34, 0x31, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x34, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x38, 0x34, 0x32, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x34, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x38, 0x34, 0x33, 0x18, 0x08, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x34, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x38, 0x34, 0x34, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x34, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x38, 0x34, 0x35, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x34, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x38, 0x34, 0x36, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x34, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x38, 0x34, 0x37, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x34, 0x37, 0x22, 0xce, 0x01, 0x0a, 0x0c, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x38, 0x31, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x33, 0x34, 0x18, 0x01, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x33, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x33, 0x35, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x33, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x33, 0x36, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x33, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x33, 0x37, 0x18, 0x04, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x33, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x33, 0x38, 0x18, 0x05, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x33, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x33, 0x39, 0x18, 0x06, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x33, 0x39, 0x22, 0xd8, 0x01, 0x0a, 0x0c, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x38, 0x31, 0x38, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x32, 0x39, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x32, 0x39, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x33, 0x30, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x33, 0x30, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x33, 0x31, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x33, 0x31, 0x12, 0x1e, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x33, 0x32, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x33, 0x32, 0x12, 0x48, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x38, 0x33, 0x33, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x28, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x31, 0x32, 0x38, 0x31, 0x37, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x38, 0x33, 0x33, 0x22, 0x95, 0x02, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x31, 0x30, 0x33, 0x31, 0x39, 0x12, 0x45, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31,
+	0x30, 0x33, 0x34, 0x30, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x30, 0x33, 0x32,
+	0x35, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x30, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x31, 0x18, 0x04, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x31, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x32, 0x18, 0x05, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x32, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x33, 0x18, 0x03, 0x20, 0x01, 0x28,
+	0x0c, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x33, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x34, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x34, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x35, 0x18, 0x06, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x35, 0x12, 0x1e, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x36, 0x18, 0x07, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x33, 0x34, 0x36, 0x22, 0x95, 0x01,
+	0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x35, 0x37, 0x38, 0x12, 0x42, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x33, 0x32, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e,
+	0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e,
+	0x75, 0x6d, 0x36, 0x35, 0x37, 0x39, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x33,
+	0x32, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x36, 0x33, 0x33, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x34, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x36, 0x35, 0x38, 0x38, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x36, 0x36, 0x33, 0x33, 0x22, 0xea, 0x06, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x36, 0x31, 0x32, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31,
+	0x35, 0x32, 0x18, 0x01, 0x20, 0x02, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36,
+	0x31, 0x35, 0x32, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x35, 0x33,
+	0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x31, 0x32, 0x37, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x35, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x36, 0x31, 0x35, 0x34, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x35, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x36, 0x31, 0x35, 0x35, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x36, 0x31, 0x35, 0x35, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36,
+	0x31, 0x35, 0x36, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63,
+	0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x30,
+	0x32, 0x34, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x35, 0x36, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x35, 0x37, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x35, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x35, 0x38, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x35, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x36, 0x31, 0x35, 0x39, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x36, 0x31, 0x35, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x36, 0x31, 0x36, 0x30, 0x18, 0x02, 0x20, 0x03, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x36, 0x31, 0x36, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31,
+	0x36, 0x31, 0x18, 0x03, 0x20, 0x03, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36,
+	0x31, 0x36, 0x31, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x36, 0x32,
+	0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x30, 0x35, 0x32, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x36, 0x32, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x36, 0x31, 0x36, 0x33, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65,
+	0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x36, 0x33, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x36, 0x31, 0x36, 0x34, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x36, 0x30, 0x36,
+	0x35, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x36, 0x34, 0x12, 0x45, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x36, 0x35, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x36, 0x31, 0x32, 0x37, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36,
+	0x31, 0x36, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x36, 0x36,
+	0x18, 0x0d, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x36,
+	0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x36, 0x37, 0x18, 0x10,
+	0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x36, 0x37, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x36, 0x38, 0x18, 0x12, 0x20, 0x01,
+	0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x36, 0x38, 0x12, 0x45, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x36, 0x39, 0x18, 0x11, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x30, 0x35, 0x34, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x36, 0x31, 0x36, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x37,
+	0x30, 0x18, 0x13, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31,
+	0x37, 0x30, 0x22, 0xec, 0x02, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x35, 0x38,
+	0x38, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x38, 0x39, 0x37, 0x18,
+	0x01, 0x20, 0x02, 0x28, 0x01, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x38, 0x39, 0x37,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x38, 0x39, 0x38, 0x18, 0x05, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x38, 0x39, 0x38, 0x12, 0x45,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x38, 0x39, 0x39, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x35, 0x38, 0x36, 0x31, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x35, 0x38, 0x39, 0x39, 0x12, 0x4c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39,
+	0x30, 0x30, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74,
+	0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35,
+	0x39, 0x30, 0x30, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x30, 0x31,
+	0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x35, 0x38, 0x36, 0x37, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x30, 0x31, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x35, 0x39, 0x30, 0x32, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x35, 0x38, 0x38, 0x30, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x30,
+	0x32, 0x22, 0x0d, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x31, 0x31, 0x30,
+	0x22, 0x93, 0x02, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x31, 0x30, 0x37,
+	0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x33, 0x34, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x30, 0x31, 0x36, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x36, 0x31, 0x33, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x36, 0x31, 0x33, 0x35, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x36, 0x31, 0x33, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31,
+	0x33, 0x36, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36,
+	0x31, 0x33, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x33, 0x37,
+	0x18, 0x04, 0x20, 0x03, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x33,
+	0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x33, 0x38, 0x18, 0x05,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x33, 0x38, 0x12,
+	0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x33, 0x39, 0x18, 0x06, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x31, 0x30, 0x38, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x36, 0x31, 0x33, 0x39, 0x22, 0x6f, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x36, 0x31, 0x32, 0x39, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31,
+	0x37, 0x31, 0x18, 0x01, 0x20, 0x02, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x36, 0x31, 0x33, 0x30, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x31, 0x37, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x36, 0x31, 0x37, 0x32, 0x18, 0x02, 0x20, 0x02, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x36, 0x31, 0x37, 0x32, 0x22, 0xde, 0x14, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x35, 0x39, 0x30, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x35, 0x39, 0x37, 0x31, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x35, 0x39, 0x37, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39,
+	0x37, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35,
+	0x39, 0x37, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x37, 0x33,
+	0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x37,
+	0x33, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x37, 0x34, 0x18, 0x2d,
+	0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x34, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x35, 0x39, 0x30, 0x39, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x35, 0x39, 0x37, 0x34, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39,
+	0x37, 0x35, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x35, 0x39, 0x31, 0x32, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x37, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x35, 0x39, 0x37, 0x36, 0x18, 0x32, 0x20, 0x01, 0x28, 0x07, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x35, 0x39, 0x37, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x35, 0x39, 0x37, 0x37, 0x18, 0x05, 0x20, 0x01, 0x28, 0x07, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x35, 0x39, 0x37, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39,
+	0x37, 0x38, 0x18, 0x06, 0x20, 0x01, 0x28, 0x07, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35,
+	0x39, 0x37, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x37, 0x39,
+	0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x37,
+	0x39, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x38, 0x30, 0x18, 0x08,
+	0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x34, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x35, 0x39, 0x31, 0x35, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x35, 0x39, 0x38, 0x30, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39,
+	0x38, 0x31, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x35, 0x39, 0x30,
+	0x33, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x38, 0x31, 0x12, 0x45, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x38, 0x32, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x35, 0x39, 0x30, 0x33, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35,
+	0x39, 0x38, 0x32, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x38, 0x33,
+	0x18, 0x0b, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x35, 0x39, 0x32, 0x30, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x35, 0x39, 0x38, 0x33, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x35, 0x39, 0x38, 0x34, 0x18, 0x28, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x35, 0x39, 0x32, 0x33,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x38, 0x34, 0x12, 0x45, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x38, 0x35, 0x18, 0x29, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x35, 0x39, 0x30, 0x33, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39,
+	0x38, 0x35, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x38, 0x36, 0x18,
+	0x2a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x35, 0x39, 0x30, 0x33, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x38, 0x36, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x35, 0x39, 0x38, 0x37, 0x18, 0x2f, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x35, 0x39,
+	0x32, 0x38, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x38, 0x37, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x38, 0x38, 0x18, 0x30, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x38, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x38, 0x39, 0x18, 0x31, 0x20, 0x03, 0x28, 0x07, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x38, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x35, 0x39, 0x39, 0x30, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x35, 0x39, 0x39, 0x30, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x35, 0x39, 0x39, 0x31, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x35,
+	0x39, 0x30, 0x33, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x39, 0x31, 0x12, 0x45,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x39, 0x32, 0x18, 0x0e, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x35, 0x39, 0x30, 0x33, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x35, 0x39, 0x39, 0x32, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39,
+	0x39, 0x33, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x35, 0x39, 0x30,
+	0x33, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x39, 0x33, 0x12, 0x45, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x39, 0x34, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x35, 0x39, 0x30, 0x33, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35,
+	0x39, 0x39, 0x34, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x39, 0x35,
+	0x18, 0x20, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x35, 0x39, 0x30, 0x33, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x39, 0x35, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x35, 0x39, 0x39, 0x36, 0x18, 0x21, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x35, 0x39, 0x30, 0x33, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x39,
+	0x36, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x39, 0x37, 0x18, 0x22,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x35, 0x39, 0x30, 0x33, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x39, 0x37, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x35, 0x39, 0x39, 0x38, 0x18, 0x23, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x35, 0x39, 0x30, 0x33, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x39, 0x38, 0x12,
+	0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x39, 0x39, 0x18, 0x11, 0x20, 0x01,
+	0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e,
+	0x45, 0x6e, 0x75, 0x6d, 0x35, 0x39, 0x33, 0x31, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35,
+	0x39, 0x39, 0x39, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x30, 0x30,
+	0x18, 0x12, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x35, 0x39, 0x33, 0x35, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x36, 0x30, 0x30, 0x30, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x36, 0x30, 0x30, 0x31, 0x18, 0x24, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x35, 0x39, 0x33, 0x39,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x30, 0x31, 0x12, 0x42, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x30, 0x32, 0x18, 0x25, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e, 0x75, 0x6d,
+	0x35, 0x39, 0x33, 0x39, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x30, 0x32, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x30, 0x33, 0x18, 0x13, 0x20, 0x03,
+	0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x30, 0x33, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x30, 0x34, 0x18, 0x14, 0x20, 0x01, 0x28, 0x0d,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x30, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x30, 0x35, 0x18, 0x15, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x30, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x36, 0x30, 0x30, 0x36, 0x18, 0x16, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x36, 0x30, 0x30, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x36, 0x30, 0x30, 0x37, 0x18, 0x17, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x36, 0x30, 0x30, 0x37, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30,
+	0x30, 0x38, 0x18, 0x18, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x35, 0x39, 0x34, 0x36, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x30, 0x38, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x36, 0x30, 0x30, 0x39, 0x18, 0x19, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x35, 0x39,
+	0x34, 0x36, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x30, 0x39, 0x12, 0x42, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x31, 0x30, 0x18, 0x1a, 0x20, 0x01, 0x28, 0x0e,
+	0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e,
+	0x75, 0x6d, 0x35, 0x39, 0x34, 0x36, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x31,
+	0x30, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x31, 0x31, 0x18, 0x1b,
+	0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x34, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x35, 0x39, 0x34, 0x36, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x36, 0x30, 0x31, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30,
+	0x31, 0x32, 0x18, 0x1c, 0x20, 0x01, 0x28, 0x07, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36,
+	0x30, 0x31, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x31, 0x33,
+	0x18, 0x1d, 0x20, 0x01, 0x28, 0x07, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x31,
+	0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x31, 0x34, 0x18, 0x1e,
+	0x20, 0x01, 0x28, 0x07, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x31, 0x34, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x31, 0x35, 0x18, 0x1f, 0x20, 0x01,
+	0x28, 0x07, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x31, 0x35, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x31, 0x36, 0x18, 0x26, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x31, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x31, 0x37, 0x18, 0x27, 0x20, 0x01, 0x28, 0x02, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x31, 0x37, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x36, 0x30, 0x31, 0x38, 0x18, 0x2b, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x35, 0x39,
+	0x35, 0x37, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x31, 0x38, 0x12, 0x45, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x31, 0x39, 0x18, 0x2c, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x35, 0x39, 0x30, 0x37, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x36, 0x30, 0x31, 0x39, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x32,
+	0x30, 0x18, 0x2e, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x35, 0x39, 0x36, 0x32, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x32, 0x30, 0x22, 0xe7, 0x01, 0x0a, 0x0b, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x38, 0x35, 0x30, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x39, 0x32, 0x34, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x33, 0x38, 0x35,
+	0x31, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x32, 0x34, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x32, 0x35, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x32, 0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x39, 0x32, 0x36, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x32, 0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x33, 0x39, 0x32, 0x37, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x33, 0x39, 0x32, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33,
+	0x39, 0x32, 0x38, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x33, 0x39, 0x32, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39, 0x32,
+	0x39, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x39,
+	0x32, 0x39, 0x22, 0x0d, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x38, 0x36,
+	0x35, 0x22, 0x85, 0x02, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x35, 0x31,
+	0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x35, 0x32, 0x33, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x35, 0x32, 0x33, 0x12,
+	0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x35, 0x32, 0x34, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e,
+	0x45, 0x6e, 0x75, 0x6d, 0x37, 0x35, 0x31, 0x32, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37,
+	0x35, 0x32, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x35, 0x32, 0x35,
+	0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x35, 0x32,
+	0x35, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x35, 0x32, 0x36, 0x18, 0x04,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x35, 0x32, 0x36, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x35, 0x32, 0x37, 0x18, 0x05, 0x20, 0x01,
+	0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x35, 0x32, 0x37, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x35, 0x32, 0x38, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x35, 0x32, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x37, 0x35, 0x32, 0x39, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x35, 0x32, 0x39, 0x22, 0x0d, 0x0a, 0x0b, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x33, 0x39, 0x32, 0x30, 0x22, 0x49, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x37, 0x39, 0x32, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x37, 0x39, 0x34, 0x30, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x39, 0x34, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39,
+	0x34, 0x31, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37,
+	0x39, 0x34, 0x31, 0x22, 0xab, 0x01, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37,
+	0x39, 0x32, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x33, 0x36,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x33,
+	0x36, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x33, 0x37, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x33, 0x37, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x33, 0x38, 0x18, 0x03, 0x20, 0x01,
+	0x28, 0x02, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x33, 0x38, 0x12, 0x42, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x33, 0x39, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e,
+	0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e,
+	0x75, 0x6d, 0x37, 0x39, 0x32, 0x32, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x33,
+	0x39, 0x22, 0x49, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x39, 0x32, 0x30,
+	0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x33, 0x34, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x33, 0x34, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x33, 0x35, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x03, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x33, 0x35, 0x22, 0x67, 0x0a, 0x0b,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x37, 0x39, 0x31, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x33, 0x31, 0x18, 0x01, 0x20, 0x01, 0x28, 0x06, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x37, 0x39, 0x33, 0x31, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x37, 0x39, 0x33, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x37, 0x39, 0x33, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x37, 0x39, 0x33, 0x33, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x37, 0x39, 0x33, 0x33, 0x22, 0x6e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x31, 0x32, 0x38, 0x31, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32,
+	0x38, 0x32, 0x36, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x38, 0x32, 0x36, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32,
+	0x38, 0x32, 0x37, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x38, 0x32, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32,
+	0x38, 0x32, 0x38, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x32, 0x38, 0x32, 0x38, 0x22, 0x49, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x36, 0x30, 0x35, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x38,
+	0x39, 0x18, 0x01, 0x20, 0x02, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30,
+	0x38, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x39, 0x30, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x39, 0x30,
+	0x22, 0x0d, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x31, 0x32, 0x37, 0x22,
+	0x49, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x30, 0x35, 0x32, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x38, 0x34, 0x18, 0x01, 0x20, 0x02, 0x28,
+	0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x38, 0x34, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x38, 0x35, 0x18, 0x02, 0x20, 0x02, 0x28, 0x0c, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x38, 0x35, 0x22, 0xbd, 0x01, 0x0a, 0x0b, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x36, 0x30, 0x32, 0x34, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x36, 0x30, 0x34, 0x38, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x36,
+	0x30, 0x32, 0x35, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x34, 0x38, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x34, 0x39, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x34, 0x39, 0x12, 0x4c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x35, 0x30, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2e, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75,
+	0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x30, 0x35, 0x30, 0x22, 0xab, 0x01, 0x0a, 0x0b, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x35, 0x38, 0x36, 0x31, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x35, 0x38, 0x38, 0x32, 0x18, 0x01, 0x20, 0x02, 0x28, 0x0e, 0x32, 0x24, 0x2e,
+	0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x35,
+	0x38, 0x36, 0x32, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x38, 0x38, 0x32, 0x12, 0x1c,
+	0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x38, 0x38, 0x33, 0x18, 0x02, 0x20, 0x02, 0x28,
+	0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x38, 0x38, 0x33, 0x12, 0x1c, 0x0a, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x38, 0x38, 0x34, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x38, 0x38, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x35, 0x38, 0x38, 0x35, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x35, 0x38, 0x38, 0x35, 0x22, 0x2b, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x35, 0x38, 0x38, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x35, 0x38, 0x39, 0x36, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x35, 0x38, 0x39, 0x36, 0x22, 0xb5, 0x02, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x35, 0x38, 0x36, 0x37, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x38,
+	0x39, 0x30, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x35, 0x38, 0x36, 0x38, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x38, 0x39, 0x30, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x35, 0x38, 0x39, 0x31, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x35, 0x38, 0x39, 0x31, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x35, 0x38, 0x39, 0x32, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e,
+	0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x35, 0x38, 0x37, 0x33,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x38, 0x39, 0x32, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x35, 0x38, 0x39, 0x33, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x38, 0x39, 0x33, 0x12, 0x44, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x35, 0x38, 0x39, 0x34, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64,
+	0x45, 0x6e, 0x75, 0x6d, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x38, 0x39, 0x34, 0x12,
+	0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x38, 0x39, 0x35, 0x18, 0x06, 0x20, 0x01,
+	0x28, 0x08, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x38, 0x39, 0x35, 0x22, 0x85, 0x01,
+	0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x30, 0x31, 0x36, 0x12, 0x1c, 0x0a,
+	0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x30, 0x31, 0x37, 0x18, 0x01, 0x20, 0x02, 0x28, 0x05,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x30, 0x31, 0x37, 0x12, 0x1c, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x34, 0x30, 0x31, 0x38, 0x18, 0x02, 0x20, 0x02, 0x28, 0x05, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x30, 0x31, 0x38, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x34, 0x30, 0x31, 0x39, 0x18, 0x03, 0x20, 0x02, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x34, 0x30, 0x31, 0x39, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x34, 0x30, 0x32, 0x30, 0x18, 0x04, 0x20, 0x02, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x34, 0x30, 0x32, 0x30, 0x22, 0x0d, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x36, 0x31, 0x30, 0x38, 0x22, 0xa9, 0x02, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x35, 0x39, 0x30, 0x37, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x36,
+	0x37, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d,
+	0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x35, 0x39, 0x30, 0x33,
+	0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x36, 0x37, 0x12, 0x45, 0x0a, 0x09, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x36, 0x38, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27,
+	0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x35, 0x39, 0x30, 0x33, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39,
+	0x36, 0x38, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x36, 0x39, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x35, 0x39, 0x30, 0x33, 0x52, 0x09,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x36, 0x39, 0x12, 0x45, 0x0a, 0x09, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x35, 0x39, 0x37, 0x30, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x35, 0x39, 0x30, 0x33, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x37, 0x30,
+	0x22, 0x14, 0x0a, 0x12, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x6f, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x35, 0x39, 0x30, 0x33, 0x12, 0x1c, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39,
+	0x36, 0x35, 0x18, 0x01, 0x20, 0x02, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35,
+	0x39, 0x36, 0x35, 0x12, 0x42, 0x0a, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x39, 0x36, 0x36,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61,
+	0x72, 0x6b, 0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x34, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x35, 0x39, 0x30, 0x34, 0x52, 0x09, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x35, 0x39, 0x36, 0x36, 0x42, 0x23, 0x0a, 0x1e, 0x63, 0x6f, 0x6d, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x62,
+	0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0xf8, 0x01, 0x01,
+}
+
+var (
+	file_datasets_google_message4_benchmark_message4_2_proto_rawDescOnce sync.Once
+	file_datasets_google_message4_benchmark_message4_2_proto_rawDescData = file_datasets_google_message4_benchmark_message4_2_proto_rawDesc
+)
+
+func file_datasets_google_message4_benchmark_message4_2_proto_rawDescGZIP() []byte {
+	file_datasets_google_message4_benchmark_message4_2_proto_rawDescOnce.Do(func() {
+		file_datasets_google_message4_benchmark_message4_2_proto_rawDescData = protoimpl.X.CompressGZIP(file_datasets_google_message4_benchmark_message4_2_proto_rawDescData)
+	})
+	return file_datasets_google_message4_benchmark_message4_2_proto_rawDescData
+}
+
+var file_datasets_google_message4_benchmark_message4_2_proto_msgTypes = make([]protoimpl.MessageInfo, 35)
+var file_datasets_google_message4_benchmark_message4_2_proto_goTypes = []interface{}{
+	(*Message12774)(nil),       // 0: benchmarks.google_message4.Message12774
+	(*Message12796)(nil),       // 1: benchmarks.google_message4.Message12796
+	(*Message12821)(nil),       // 2: benchmarks.google_message4.Message12821
+	(*Message12820)(nil),       // 3: benchmarks.google_message4.Message12820
+	(*Message12819)(nil),       // 4: benchmarks.google_message4.Message12819
+	(*Message12818)(nil),       // 5: benchmarks.google_message4.Message12818
+	(*Message10319)(nil),       // 6: benchmarks.google_message4.Message10319
+	(*Message6578)(nil),        // 7: benchmarks.google_message4.Message6578
+	(*Message6126)(nil),        // 8: benchmarks.google_message4.Message6126
+	(*Message5881)(nil),        // 9: benchmarks.google_message4.Message5881
+	(*Message6110)(nil),        // 10: benchmarks.google_message4.Message6110
+	(*Message6107)(nil),        // 11: benchmarks.google_message4.Message6107
+	(*Message6129)(nil),        // 12: benchmarks.google_message4.Message6129
+	(*Message5908)(nil),        // 13: benchmarks.google_message4.Message5908
+	(*Message3850)(nil),        // 14: benchmarks.google_message4.Message3850
+	(*Message7865)(nil),        // 15: benchmarks.google_message4.Message7865
+	(*Message7511)(nil),        // 16: benchmarks.google_message4.Message7511
+	(*Message3920)(nil),        // 17: benchmarks.google_message4.Message3920
+	(*Message7928)(nil),        // 18: benchmarks.google_message4.Message7928
+	(*Message7921)(nil),        // 19: benchmarks.google_message4.Message7921
+	(*Message7920)(nil),        // 20: benchmarks.google_message4.Message7920
+	(*Message7919)(nil),        // 21: benchmarks.google_message4.Message7919
+	(*Message12817)(nil),       // 22: benchmarks.google_message4.Message12817
+	(*Message6054)(nil),        // 23: benchmarks.google_message4.Message6054
+	(*Message6127)(nil),        // 24: benchmarks.google_message4.Message6127
+	(*Message6052)(nil),        // 25: benchmarks.google_message4.Message6052
+	(*Message6024)(nil),        // 26: benchmarks.google_message4.Message6024
+	(*Message5861)(nil),        // 27: benchmarks.google_message4.Message5861
+	(*Message5880)(nil),        // 28: benchmarks.google_message4.Message5880
+	(*Message5867)(nil),        // 29: benchmarks.google_message4.Message5867
+	(*Message4016)(nil),        // 30: benchmarks.google_message4.Message4016
+	(*Message6108)(nil),        // 31: benchmarks.google_message4.Message6108
+	(*Message5907)(nil),        // 32: benchmarks.google_message4.Message5907
+	(*UnusedEmptyMessage)(nil), // 33: benchmarks.google_message4.UnusedEmptyMessage
+	(*Message5903)(nil),        // 34: benchmarks.google_message4.Message5903
+	(Enum10325)(0),             // 35: benchmarks.google_message4.Enum10325
+	(Enum6579)(0),              // 36: benchmarks.google_message4.Enum6579
+	(Enum6588)(0),              // 37: benchmarks.google_message4.Enum6588
+	(Enum6065)(0),              // 38: benchmarks.google_message4.Enum6065
+	(Enum6130)(0),              // 39: benchmarks.google_message4.Enum6130
+	(Enum5909)(0),              // 40: benchmarks.google_message4.Enum5909
+	(Enum5912)(0),              // 41: benchmarks.google_message4.Enum5912
+	(Enum5915)(0),              // 42: benchmarks.google_message4.Enum5915
+	(Enum5920)(0),              // 43: benchmarks.google_message4.Enum5920
+	(Enum5923)(0),              // 44: benchmarks.google_message4.Enum5923
+	(Enum5928)(0),              // 45: benchmarks.google_message4.Enum5928
+	(Enum5931)(0),              // 46: benchmarks.google_message4.Enum5931
+	(Enum5935)(0),              // 47: benchmarks.google_message4.Enum5935
+	(Enum5939)(0),              // 48: benchmarks.google_message4.Enum5939
+	(Enum5946)(0),              // 49: benchmarks.google_message4.Enum5946
+	(Enum5957)(0),              // 50: benchmarks.google_message4.Enum5957
+	(Enum5962)(0),              // 51: benchmarks.google_message4.Enum5962
+	(Enum3851)(0),              // 52: benchmarks.google_message4.Enum3851
+	(Enum7512)(0),              // 53: benchmarks.google_message4.Enum7512
+	(Enum7922)(0),              // 54: benchmarks.google_message4.Enum7922
+	(Enum6025)(0),              // 55: benchmarks.google_message4.Enum6025
+	(Enum5862)(0),              // 56: benchmarks.google_message4.Enum5862
+	(Enum5868)(0),              // 57: benchmarks.google_message4.Enum5868
+	(Enum5873)(0),              // 58: benchmarks.google_message4.Enum5873
+	(UnusedEnum)(0),            // 59: benchmarks.google_message4.UnusedEnum
+	(Enum5904)(0),              // 60: benchmarks.google_message4.Enum5904
+}
+var file_datasets_google_message4_benchmark_message4_2_proto_depIdxs = []int32{
+	22, // 0: benchmarks.google_message4.Message12818.field12833:type_name -> benchmarks.google_message4.Message12817
+	35, // 1: benchmarks.google_message4.Message10319.field10340:type_name -> benchmarks.google_message4.Enum10325
+	36, // 2: benchmarks.google_message4.Message6578.field6632:type_name -> benchmarks.google_message4.Enum6579
+	37, // 3: benchmarks.google_message4.Message6578.field6633:type_name -> benchmarks.google_message4.Enum6588
+	24, // 4: benchmarks.google_message4.Message6126.field6153:type_name -> benchmarks.google_message4.Message6127
+	26, // 5: benchmarks.google_message4.Message6126.field6156:type_name -> benchmarks.google_message4.Message6024
+	25, // 6: benchmarks.google_message4.Message6126.field6162:type_name -> benchmarks.google_message4.Message6052
+	33, // 7: benchmarks.google_message4.Message6126.field6163:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	38, // 8: benchmarks.google_message4.Message6126.field6164:type_name -> benchmarks.google_message4.Enum6065
+	24, // 9: benchmarks.google_message4.Message6126.field6165:type_name -> benchmarks.google_message4.Message6127
+	23, // 10: benchmarks.google_message4.Message6126.field6169:type_name -> benchmarks.google_message4.Message6054
+	27, // 11: benchmarks.google_message4.Message5881.field5899:type_name -> benchmarks.google_message4.Message5861
+	33, // 12: benchmarks.google_message4.Message5881.field5900:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	29, // 13: benchmarks.google_message4.Message5881.field5901:type_name -> benchmarks.google_message4.Message5867
+	28, // 14: benchmarks.google_message4.Message5881.field5902:type_name -> benchmarks.google_message4.Message5880
+	30, // 15: benchmarks.google_message4.Message6107.field6134:type_name -> benchmarks.google_message4.Message4016
+	31, // 16: benchmarks.google_message4.Message6107.field6139:type_name -> benchmarks.google_message4.Message6108
+	39, // 17: benchmarks.google_message4.Message6129.field6171:type_name -> benchmarks.google_message4.Enum6130
+	40, // 18: benchmarks.google_message4.Message5908.field5974:type_name -> benchmarks.google_message4.Enum5909
+	41, // 19: benchmarks.google_message4.Message5908.field5975:type_name -> benchmarks.google_message4.Enum5912
+	42, // 20: benchmarks.google_message4.Message5908.field5980:type_name -> benchmarks.google_message4.Enum5915
+	34, // 21: benchmarks.google_message4.Message5908.field5981:type_name -> benchmarks.google_message4.Message5903
+	34, // 22: benchmarks.google_message4.Message5908.field5982:type_name -> benchmarks.google_message4.Message5903
+	43, // 23: benchmarks.google_message4.Message5908.field5983:type_name -> benchmarks.google_message4.Enum5920
+	44, // 24: benchmarks.google_message4.Message5908.field5984:type_name -> benchmarks.google_message4.Enum5923
+	34, // 25: benchmarks.google_message4.Message5908.field5985:type_name -> benchmarks.google_message4.Message5903
+	34, // 26: benchmarks.google_message4.Message5908.field5986:type_name -> benchmarks.google_message4.Message5903
+	45, // 27: benchmarks.google_message4.Message5908.field5987:type_name -> benchmarks.google_message4.Enum5928
+	34, // 28: benchmarks.google_message4.Message5908.field5991:type_name -> benchmarks.google_message4.Message5903
+	34, // 29: benchmarks.google_message4.Message5908.field5992:type_name -> benchmarks.google_message4.Message5903
+	34, // 30: benchmarks.google_message4.Message5908.field5993:type_name -> benchmarks.google_message4.Message5903
+	34, // 31: benchmarks.google_message4.Message5908.field5994:type_name -> benchmarks.google_message4.Message5903
+	34, // 32: benchmarks.google_message4.Message5908.field5995:type_name -> benchmarks.google_message4.Message5903
+	34, // 33: benchmarks.google_message4.Message5908.field5996:type_name -> benchmarks.google_message4.Message5903
+	34, // 34: benchmarks.google_message4.Message5908.field5997:type_name -> benchmarks.google_message4.Message5903
+	34, // 35: benchmarks.google_message4.Message5908.field5998:type_name -> benchmarks.google_message4.Message5903
+	46, // 36: benchmarks.google_message4.Message5908.field5999:type_name -> benchmarks.google_message4.Enum5931
+	47, // 37: benchmarks.google_message4.Message5908.field6000:type_name -> benchmarks.google_message4.Enum5935
+	48, // 38: benchmarks.google_message4.Message5908.field6001:type_name -> benchmarks.google_message4.Enum5939
+	48, // 39: benchmarks.google_message4.Message5908.field6002:type_name -> benchmarks.google_message4.Enum5939
+	49, // 40: benchmarks.google_message4.Message5908.field6008:type_name -> benchmarks.google_message4.Enum5946
+	49, // 41: benchmarks.google_message4.Message5908.field6009:type_name -> benchmarks.google_message4.Enum5946
+	49, // 42: benchmarks.google_message4.Message5908.field6010:type_name -> benchmarks.google_message4.Enum5946
+	49, // 43: benchmarks.google_message4.Message5908.field6011:type_name -> benchmarks.google_message4.Enum5946
+	50, // 44: benchmarks.google_message4.Message5908.field6018:type_name -> benchmarks.google_message4.Enum5957
+	32, // 45: benchmarks.google_message4.Message5908.field6019:type_name -> benchmarks.google_message4.Message5907
+	51, // 46: benchmarks.google_message4.Message5908.field6020:type_name -> benchmarks.google_message4.Enum5962
+	52, // 47: benchmarks.google_message4.Message3850.field3924:type_name -> benchmarks.google_message4.Enum3851
+	53, // 48: benchmarks.google_message4.Message7511.field7524:type_name -> benchmarks.google_message4.Enum7512
+	54, // 49: benchmarks.google_message4.Message7921.field7939:type_name -> benchmarks.google_message4.Enum7922
+	55, // 50: benchmarks.google_message4.Message6024.field6048:type_name -> benchmarks.google_message4.Enum6025
+	33, // 51: benchmarks.google_message4.Message6024.field6050:type_name -> benchmarks.google_message4.UnusedEmptyMessage
+	56, // 52: benchmarks.google_message4.Message5861.field5882:type_name -> benchmarks.google_message4.Enum5862
+	57, // 53: benchmarks.google_message4.Message5867.field5890:type_name -> benchmarks.google_message4.Enum5868
+	58, // 54: benchmarks.google_message4.Message5867.field5892:type_name -> benchmarks.google_message4.Enum5873
+	59, // 55: benchmarks.google_message4.Message5867.field5894:type_name -> benchmarks.google_message4.UnusedEnum
+	34, // 56: benchmarks.google_message4.Message5907.field5967:type_name -> benchmarks.google_message4.Message5903
+	34, // 57: benchmarks.google_message4.Message5907.field5968:type_name -> benchmarks.google_message4.Message5903
+	34, // 58: benchmarks.google_message4.Message5907.field5969:type_name -> benchmarks.google_message4.Message5903
+	34, // 59: benchmarks.google_message4.Message5907.field5970:type_name -> benchmarks.google_message4.Message5903
+	60, // 60: benchmarks.google_message4.Message5903.field5966:type_name -> benchmarks.google_message4.Enum5904
+	61, // [61:61] is the sub-list for method output_type
+	61, // [61:61] is the sub-list for method input_type
+	61, // [61:61] is the sub-list for extension type_name
+	61, // [61:61] is the sub-list for extension extendee
+	0,  // [0:61] is the sub-list for field type_name
+}
+
+func init() { file_datasets_google_message4_benchmark_message4_2_proto_init() }
+func file_datasets_google_message4_benchmark_message4_2_proto_init() {
+	if File_datasets_google_message4_benchmark_message4_2_proto != nil {
+		return
+	}
+	file_datasets_google_message4_benchmark_message4_3_proto_init()
+	if !protoimpl.UnsafeEnabled {
+		file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12774); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12796); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12821); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12820); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12819); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12818); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message10319); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6578); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6126); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message5881); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6110); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6107); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6129); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message5908); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message3850); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message7865); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message7511); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message3920); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message7928); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message7921); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message7920); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message7919); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message12817); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6054); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6127); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6052); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6024); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message5861); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message5880); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message5867); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message4016); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message6108); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message5907); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*UnusedEmptyMessage); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_datasets_google_message4_benchmark_message4_2_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message5903); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_datasets_google_message4_benchmark_message4_2_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   35,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_datasets_google_message4_benchmark_message4_2_proto_goTypes,
+		DependencyIndexes: file_datasets_google_message4_benchmark_message4_2_proto_depIdxs,
+		MessageInfos:      file_datasets_google_message4_benchmark_message4_2_proto_msgTypes,
+	}.Build()
+	File_datasets_google_message4_benchmark_message4_2_proto = out.File
+	file_datasets_google_message4_benchmark_message4_2_proto_rawDesc = nil
+	file_datasets_google_message4_benchmark_message4_2_proto_goTypes = nil
+	file_datasets_google_message4_benchmark_message4_2_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message4/benchmark_message4_3.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message4/benchmark_message4_3.pb.go
new file mode 100644
index 000000000..0bf6b283a
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/datasets/google_message4/benchmark_message4_3.pb.go
@@ -0,0 +1,4905 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: datasets/google_message4/benchmark_message4_3.proto
+
+package google_message4
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type UnusedEnum int32
+
+const (
+	UnusedEnum_UNUSED_ENUM_VALUE1 UnusedEnum = 0
+	UnusedEnum_UNUSED_ENUM_VALUE2 UnusedEnum = 1
+)
+
+// Enum value maps for UnusedEnum.
+var (
+	UnusedEnum_name = map[int32]string{
+		0: "UNUSED_ENUM_VALUE1",
+		1: "UNUSED_ENUM_VALUE2",
+	}
+	UnusedEnum_value = map[string]int32{
+		"UNUSED_ENUM_VALUE1": 0,
+		"UNUSED_ENUM_VALUE2": 1,
+	}
+)
+
+func (x UnusedEnum) Enum() *UnusedEnum {
+	p := new(UnusedEnum)
+	*p = x
+	return p
+}
+
+func (x UnusedEnum) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (UnusedEnum) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[0].Descriptor()
+}
+
+func (UnusedEnum) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[0]
+}
+
+func (x UnusedEnum) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *UnusedEnum) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = UnusedEnum(num)
+	return nil
+}
+
+// Deprecated: Use UnusedEnum.Descriptor instead.
+func (UnusedEnum) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{0}
+}
+
+type Enum2593 int32
+
+const (
+	Enum2593_ENUM_VALUE2594 Enum2593 = 0
+	Enum2593_ENUM_VALUE2595 Enum2593 = 1
+	Enum2593_ENUM_VALUE2596 Enum2593 = 2
+	Enum2593_ENUM_VALUE2597 Enum2593 = 3
+	Enum2593_ENUM_VALUE2598 Enum2593 = 4
+	Enum2593_ENUM_VALUE2599 Enum2593 = 5
+	Enum2593_ENUM_VALUE2600 Enum2593 = 6
+	Enum2593_ENUM_VALUE2601 Enum2593 = 7
+)
+
+// Enum value maps for Enum2593.
+var (
+	Enum2593_name = map[int32]string{
+		0: "ENUM_VALUE2594",
+		1: "ENUM_VALUE2595",
+		2: "ENUM_VALUE2596",
+		3: "ENUM_VALUE2597",
+		4: "ENUM_VALUE2598",
+		5: "ENUM_VALUE2599",
+		6: "ENUM_VALUE2600",
+		7: "ENUM_VALUE2601",
+	}
+	Enum2593_value = map[string]int32{
+		"ENUM_VALUE2594": 0,
+		"ENUM_VALUE2595": 1,
+		"ENUM_VALUE2596": 2,
+		"ENUM_VALUE2597": 3,
+		"ENUM_VALUE2598": 4,
+		"ENUM_VALUE2599": 5,
+		"ENUM_VALUE2600": 6,
+		"ENUM_VALUE2601": 7,
+	}
+)
+
+func (x Enum2593) Enum() *Enum2593 {
+	p := new(Enum2593)
+	*p = x
+	return p
+}
+
+func (x Enum2593) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum2593) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[1].Descriptor()
+}
+
+func (Enum2593) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[1]
+}
+
+func (x Enum2593) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum2593) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum2593(num)
+	return nil
+}
+
+// Deprecated: Use Enum2593.Descriptor instead.
+func (Enum2593) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{1}
+}
+
+type Enum2834 int32
+
+const (
+	Enum2834_ENUM_VALUE2835 Enum2834 = 0
+	Enum2834_ENUM_VALUE2836 Enum2834 = 1
+	Enum2834_ENUM_VALUE2837 Enum2834 = 2
+)
+
+// Enum value maps for Enum2834.
+var (
+	Enum2834_name = map[int32]string{
+		0: "ENUM_VALUE2835",
+		1: "ENUM_VALUE2836",
+		2: "ENUM_VALUE2837",
+	}
+	Enum2834_value = map[string]int32{
+		"ENUM_VALUE2835": 0,
+		"ENUM_VALUE2836": 1,
+		"ENUM_VALUE2837": 2,
+	}
+)
+
+func (x Enum2834) Enum() *Enum2834 {
+	p := new(Enum2834)
+	*p = x
+	return p
+}
+
+func (x Enum2834) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum2834) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[2].Descriptor()
+}
+
+func (Enum2834) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[2]
+}
+
+func (x Enum2834) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum2834) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum2834(num)
+	return nil
+}
+
+// Deprecated: Use Enum2834.Descriptor instead.
+func (Enum2834) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{2}
+}
+
+type Enum2806 int32
+
+const (
+	Enum2806_ENUM_VALUE2807 Enum2806 = 0
+	Enum2806_ENUM_VALUE2808 Enum2806 = 1
+	Enum2806_ENUM_VALUE2809 Enum2806 = 2
+	Enum2806_ENUM_VALUE2810 Enum2806 = 3
+	Enum2806_ENUM_VALUE2811 Enum2806 = 4
+	Enum2806_ENUM_VALUE2812 Enum2806 = 5
+	Enum2806_ENUM_VALUE2813 Enum2806 = 6
+	Enum2806_ENUM_VALUE2814 Enum2806 = 7
+	Enum2806_ENUM_VALUE2815 Enum2806 = 8
+	Enum2806_ENUM_VALUE2816 Enum2806 = 9
+	Enum2806_ENUM_VALUE2817 Enum2806 = 10
+	Enum2806_ENUM_VALUE2818 Enum2806 = 11
+	Enum2806_ENUM_VALUE2819 Enum2806 = 12
+	Enum2806_ENUM_VALUE2820 Enum2806 = 13
+	Enum2806_ENUM_VALUE2821 Enum2806 = 14
+)
+
+// Enum value maps for Enum2806.
+var (
+	Enum2806_name = map[int32]string{
+		0:  "ENUM_VALUE2807",
+		1:  "ENUM_VALUE2808",
+		2:  "ENUM_VALUE2809",
+		3:  "ENUM_VALUE2810",
+		4:  "ENUM_VALUE2811",
+		5:  "ENUM_VALUE2812",
+		6:  "ENUM_VALUE2813",
+		7:  "ENUM_VALUE2814",
+		8:  "ENUM_VALUE2815",
+		9:  "ENUM_VALUE2816",
+		10: "ENUM_VALUE2817",
+		11: "ENUM_VALUE2818",
+		12: "ENUM_VALUE2819",
+		13: "ENUM_VALUE2820",
+		14: "ENUM_VALUE2821",
+	}
+	Enum2806_value = map[string]int32{
+		"ENUM_VALUE2807": 0,
+		"ENUM_VALUE2808": 1,
+		"ENUM_VALUE2809": 2,
+		"ENUM_VALUE2810": 3,
+		"ENUM_VALUE2811": 4,
+		"ENUM_VALUE2812": 5,
+		"ENUM_VALUE2813": 6,
+		"ENUM_VALUE2814": 7,
+		"ENUM_VALUE2815": 8,
+		"ENUM_VALUE2816": 9,
+		"ENUM_VALUE2817": 10,
+		"ENUM_VALUE2818": 11,
+		"ENUM_VALUE2819": 12,
+		"ENUM_VALUE2820": 13,
+		"ENUM_VALUE2821": 14,
+	}
+)
+
+func (x Enum2806) Enum() *Enum2806 {
+	p := new(Enum2806)
+	*p = x
+	return p
+}
+
+func (x Enum2806) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum2806) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[3].Descriptor()
+}
+
+func (Enum2806) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[3]
+}
+
+func (x Enum2806) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum2806) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum2806(num)
+	return nil
+}
+
+// Deprecated: Use Enum2806.Descriptor instead.
+func (Enum2806) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{3}
+}
+
+type Enum2851 int32
+
+const (
+	Enum2851_ENUM_VALUE2852 Enum2851 = 0
+	Enum2851_ENUM_VALUE2853 Enum2851 = 0
+	Enum2851_ENUM_VALUE2854 Enum2851 = 1
+	Enum2851_ENUM_VALUE2855 Enum2851 = 2
+	Enum2851_ENUM_VALUE2856 Enum2851 = 3
+	Enum2851_ENUM_VALUE2857 Enum2851 = 4
+	Enum2851_ENUM_VALUE2858 Enum2851 = 5
+	Enum2851_ENUM_VALUE2859 Enum2851 = 6
+	Enum2851_ENUM_VALUE2860 Enum2851 = 7
+	Enum2851_ENUM_VALUE2861 Enum2851 = 8
+	Enum2851_ENUM_VALUE2862 Enum2851 = 9
+	Enum2851_ENUM_VALUE2863 Enum2851 = 10
+	Enum2851_ENUM_VALUE2864 Enum2851 = 11
+	Enum2851_ENUM_VALUE2865 Enum2851 = 12
+	Enum2851_ENUM_VALUE2866 Enum2851 = 13
+	Enum2851_ENUM_VALUE2867 Enum2851 = 14
+	Enum2851_ENUM_VALUE2868 Enum2851 = 15
+	Enum2851_ENUM_VALUE2869 Enum2851 = 16
+	Enum2851_ENUM_VALUE2870 Enum2851 = 17
+	Enum2851_ENUM_VALUE2871 Enum2851 = 18
+	Enum2851_ENUM_VALUE2872 Enum2851 = 19
+	Enum2851_ENUM_VALUE2873 Enum2851 = 20
+	Enum2851_ENUM_VALUE2874 Enum2851 = 21
+	Enum2851_ENUM_VALUE2875 Enum2851 = 22
+	Enum2851_ENUM_VALUE2876 Enum2851 = 23
+	Enum2851_ENUM_VALUE2877 Enum2851 = 24
+	Enum2851_ENUM_VALUE2878 Enum2851 = 25
+	Enum2851_ENUM_VALUE2879 Enum2851 = 26
+	Enum2851_ENUM_VALUE2880 Enum2851 = 27
+	Enum2851_ENUM_VALUE2881 Enum2851 = 28
+	Enum2851_ENUM_VALUE2882 Enum2851 = 29
+	Enum2851_ENUM_VALUE2883 Enum2851 = 30
+	Enum2851_ENUM_VALUE2884 Enum2851 = 31
+	Enum2851_ENUM_VALUE2885 Enum2851 = 32
+	Enum2851_ENUM_VALUE2886 Enum2851 = 33
+	Enum2851_ENUM_VALUE2887 Enum2851 = 34
+	Enum2851_ENUM_VALUE2888 Enum2851 = 35
+	Enum2851_ENUM_VALUE2889 Enum2851 = 36
+	Enum2851_ENUM_VALUE2890 Enum2851 = 37
+	Enum2851_ENUM_VALUE2891 Enum2851 = 38
+	Enum2851_ENUM_VALUE2892 Enum2851 = 39
+	Enum2851_ENUM_VALUE2893 Enum2851 = 40
+	Enum2851_ENUM_VALUE2894 Enum2851 = 41
+	Enum2851_ENUM_VALUE2895 Enum2851 = 42
+	Enum2851_ENUM_VALUE2896 Enum2851 = 43
+	Enum2851_ENUM_VALUE2897 Enum2851 = 44
+	Enum2851_ENUM_VALUE2898 Enum2851 = 45
+	Enum2851_ENUM_VALUE2899 Enum2851 = 46
+	Enum2851_ENUM_VALUE2900 Enum2851 = 47
+	Enum2851_ENUM_VALUE2901 Enum2851 = 48
+	Enum2851_ENUM_VALUE2902 Enum2851 = 49
+	Enum2851_ENUM_VALUE2903 Enum2851 = 50
+	Enum2851_ENUM_VALUE2904 Enum2851 = 51
+	Enum2851_ENUM_VALUE2905 Enum2851 = 52
+	Enum2851_ENUM_VALUE2906 Enum2851 = 53
+	Enum2851_ENUM_VALUE2907 Enum2851 = 54
+	Enum2851_ENUM_VALUE2908 Enum2851 = 55
+	Enum2851_ENUM_VALUE2909 Enum2851 = 56
+	Enum2851_ENUM_VALUE2910 Enum2851 = 57
+	Enum2851_ENUM_VALUE2911 Enum2851 = 58
+	Enum2851_ENUM_VALUE2912 Enum2851 = 59
+	Enum2851_ENUM_VALUE2913 Enum2851 = 60
+	Enum2851_ENUM_VALUE2914 Enum2851 = 61
+	Enum2851_ENUM_VALUE2915 Enum2851 = 62
+	Enum2851_ENUM_VALUE2916 Enum2851 = 63
+	Enum2851_ENUM_VALUE2917 Enum2851 = 64
+	Enum2851_ENUM_VALUE2918 Enum2851 = 65
+	Enum2851_ENUM_VALUE2919 Enum2851 = 66
+	Enum2851_ENUM_VALUE2920 Enum2851 = 67
+	Enum2851_ENUM_VALUE2921 Enum2851 = 68
+	Enum2851_ENUM_VALUE2922 Enum2851 = 69
+	Enum2851_ENUM_VALUE2923 Enum2851 = 70
+	Enum2851_ENUM_VALUE2924 Enum2851 = 71
+	Enum2851_ENUM_VALUE2925 Enum2851 = 72
+	Enum2851_ENUM_VALUE2926 Enum2851 = 73
+	Enum2851_ENUM_VALUE2927 Enum2851 = 74
+	Enum2851_ENUM_VALUE2928 Enum2851 = 75
+	Enum2851_ENUM_VALUE2929 Enum2851 = 76
+	Enum2851_ENUM_VALUE2930 Enum2851 = 77
+	Enum2851_ENUM_VALUE2931 Enum2851 = 78
+	Enum2851_ENUM_VALUE2932 Enum2851 = 79
+	Enum2851_ENUM_VALUE2933 Enum2851 = 80
+	Enum2851_ENUM_VALUE2934 Enum2851 = 81
+	Enum2851_ENUM_VALUE2935 Enum2851 = 82
+	Enum2851_ENUM_VALUE2936 Enum2851 = 83
+	Enum2851_ENUM_VALUE2937 Enum2851 = 84
+	Enum2851_ENUM_VALUE2938 Enum2851 = 85
+	Enum2851_ENUM_VALUE2939 Enum2851 = 86
+	Enum2851_ENUM_VALUE2940 Enum2851 = 87
+	Enum2851_ENUM_VALUE2941 Enum2851 = 88
+	Enum2851_ENUM_VALUE2942 Enum2851 = 89
+	Enum2851_ENUM_VALUE2943 Enum2851 = 90
+	Enum2851_ENUM_VALUE2944 Enum2851 = 91
+	Enum2851_ENUM_VALUE2945 Enum2851 = 92
+	Enum2851_ENUM_VALUE2946 Enum2851 = 93
+	Enum2851_ENUM_VALUE2947 Enum2851 = 94
+	Enum2851_ENUM_VALUE2948 Enum2851 = 95
+	Enum2851_ENUM_VALUE2949 Enum2851 = 96
+	Enum2851_ENUM_VALUE2950 Enum2851 = 97
+	Enum2851_ENUM_VALUE2951 Enum2851 = 98
+	Enum2851_ENUM_VALUE2952 Enum2851 = 99
+	Enum2851_ENUM_VALUE2953 Enum2851 = 100
+	Enum2851_ENUM_VALUE2954 Enum2851 = 101
+	Enum2851_ENUM_VALUE2955 Enum2851 = 102
+	Enum2851_ENUM_VALUE2956 Enum2851 = 103
+	Enum2851_ENUM_VALUE2957 Enum2851 = 104
+	Enum2851_ENUM_VALUE2958 Enum2851 = 105
+	Enum2851_ENUM_VALUE2959 Enum2851 = 106
+	Enum2851_ENUM_VALUE2960 Enum2851 = 107
+	Enum2851_ENUM_VALUE2961 Enum2851 = 108
+	Enum2851_ENUM_VALUE2962 Enum2851 = 109
+	Enum2851_ENUM_VALUE2963 Enum2851 = 110
+	Enum2851_ENUM_VALUE2964 Enum2851 = 111
+	Enum2851_ENUM_VALUE2965 Enum2851 = 112
+	Enum2851_ENUM_VALUE2966 Enum2851 = 113
+	Enum2851_ENUM_VALUE2967 Enum2851 = 114
+	Enum2851_ENUM_VALUE2968 Enum2851 = 115
+	Enum2851_ENUM_VALUE2969 Enum2851 = 116
+	Enum2851_ENUM_VALUE2970 Enum2851 = 117
+	Enum2851_ENUM_VALUE2971 Enum2851 = 118
+	Enum2851_ENUM_VALUE2972 Enum2851 = 119
+)
+
+// Enum value maps for Enum2851.
+var (
+	Enum2851_name = map[int32]string{
+		0: "ENUM_VALUE2852",
+		// Duplicate value: 0: "ENUM_VALUE2853",
+		1:   "ENUM_VALUE2854",
+		2:   "ENUM_VALUE2855",
+		3:   "ENUM_VALUE2856",
+		4:   "ENUM_VALUE2857",
+		5:   "ENUM_VALUE2858",
+		6:   "ENUM_VALUE2859",
+		7:   "ENUM_VALUE2860",
+		8:   "ENUM_VALUE2861",
+		9:   "ENUM_VALUE2862",
+		10:  "ENUM_VALUE2863",
+		11:  "ENUM_VALUE2864",
+		12:  "ENUM_VALUE2865",
+		13:  "ENUM_VALUE2866",
+		14:  "ENUM_VALUE2867",
+		15:  "ENUM_VALUE2868",
+		16:  "ENUM_VALUE2869",
+		17:  "ENUM_VALUE2870",
+		18:  "ENUM_VALUE2871",
+		19:  "ENUM_VALUE2872",
+		20:  "ENUM_VALUE2873",
+		21:  "ENUM_VALUE2874",
+		22:  "ENUM_VALUE2875",
+		23:  "ENUM_VALUE2876",
+		24:  "ENUM_VALUE2877",
+		25:  "ENUM_VALUE2878",
+		26:  "ENUM_VALUE2879",
+		27:  "ENUM_VALUE2880",
+		28:  "ENUM_VALUE2881",
+		29:  "ENUM_VALUE2882",
+		30:  "ENUM_VALUE2883",
+		31:  "ENUM_VALUE2884",
+		32:  "ENUM_VALUE2885",
+		33:  "ENUM_VALUE2886",
+		34:  "ENUM_VALUE2887",
+		35:  "ENUM_VALUE2888",
+		36:  "ENUM_VALUE2889",
+		37:  "ENUM_VALUE2890",
+		38:  "ENUM_VALUE2891",
+		39:  "ENUM_VALUE2892",
+		40:  "ENUM_VALUE2893",
+		41:  "ENUM_VALUE2894",
+		42:  "ENUM_VALUE2895",
+		43:  "ENUM_VALUE2896",
+		44:  "ENUM_VALUE2897",
+		45:  "ENUM_VALUE2898",
+		46:  "ENUM_VALUE2899",
+		47:  "ENUM_VALUE2900",
+		48:  "ENUM_VALUE2901",
+		49:  "ENUM_VALUE2902",
+		50:  "ENUM_VALUE2903",
+		51:  "ENUM_VALUE2904",
+		52:  "ENUM_VALUE2905",
+		53:  "ENUM_VALUE2906",
+		54:  "ENUM_VALUE2907",
+		55:  "ENUM_VALUE2908",
+		56:  "ENUM_VALUE2909",
+		57:  "ENUM_VALUE2910",
+		58:  "ENUM_VALUE2911",
+		59:  "ENUM_VALUE2912",
+		60:  "ENUM_VALUE2913",
+		61:  "ENUM_VALUE2914",
+		62:  "ENUM_VALUE2915",
+		63:  "ENUM_VALUE2916",
+		64:  "ENUM_VALUE2917",
+		65:  "ENUM_VALUE2918",
+		66:  "ENUM_VALUE2919",
+		67:  "ENUM_VALUE2920",
+		68:  "ENUM_VALUE2921",
+		69:  "ENUM_VALUE2922",
+		70:  "ENUM_VALUE2923",
+		71:  "ENUM_VALUE2924",
+		72:  "ENUM_VALUE2925",
+		73:  "ENUM_VALUE2926",
+		74:  "ENUM_VALUE2927",
+		75:  "ENUM_VALUE2928",
+		76:  "ENUM_VALUE2929",
+		77:  "ENUM_VALUE2930",
+		78:  "ENUM_VALUE2931",
+		79:  "ENUM_VALUE2932",
+		80:  "ENUM_VALUE2933",
+		81:  "ENUM_VALUE2934",
+		82:  "ENUM_VALUE2935",
+		83:  "ENUM_VALUE2936",
+		84:  "ENUM_VALUE2937",
+		85:  "ENUM_VALUE2938",
+		86:  "ENUM_VALUE2939",
+		87:  "ENUM_VALUE2940",
+		88:  "ENUM_VALUE2941",
+		89:  "ENUM_VALUE2942",
+		90:  "ENUM_VALUE2943",
+		91:  "ENUM_VALUE2944",
+		92:  "ENUM_VALUE2945",
+		93:  "ENUM_VALUE2946",
+		94:  "ENUM_VALUE2947",
+		95:  "ENUM_VALUE2948",
+		96:  "ENUM_VALUE2949",
+		97:  "ENUM_VALUE2950",
+		98:  "ENUM_VALUE2951",
+		99:  "ENUM_VALUE2952",
+		100: "ENUM_VALUE2953",
+		101: "ENUM_VALUE2954",
+		102: "ENUM_VALUE2955",
+		103: "ENUM_VALUE2956",
+		104: "ENUM_VALUE2957",
+		105: "ENUM_VALUE2958",
+		106: "ENUM_VALUE2959",
+		107: "ENUM_VALUE2960",
+		108: "ENUM_VALUE2961",
+		109: "ENUM_VALUE2962",
+		110: "ENUM_VALUE2963",
+		111: "ENUM_VALUE2964",
+		112: "ENUM_VALUE2965",
+		113: "ENUM_VALUE2966",
+		114: "ENUM_VALUE2967",
+		115: "ENUM_VALUE2968",
+		116: "ENUM_VALUE2969",
+		117: "ENUM_VALUE2970",
+		118: "ENUM_VALUE2971",
+		119: "ENUM_VALUE2972",
+	}
+	Enum2851_value = map[string]int32{
+		"ENUM_VALUE2852": 0,
+		"ENUM_VALUE2853": 0,
+		"ENUM_VALUE2854": 1,
+		"ENUM_VALUE2855": 2,
+		"ENUM_VALUE2856": 3,
+		"ENUM_VALUE2857": 4,
+		"ENUM_VALUE2858": 5,
+		"ENUM_VALUE2859": 6,
+		"ENUM_VALUE2860": 7,
+		"ENUM_VALUE2861": 8,
+		"ENUM_VALUE2862": 9,
+		"ENUM_VALUE2863": 10,
+		"ENUM_VALUE2864": 11,
+		"ENUM_VALUE2865": 12,
+		"ENUM_VALUE2866": 13,
+		"ENUM_VALUE2867": 14,
+		"ENUM_VALUE2868": 15,
+		"ENUM_VALUE2869": 16,
+		"ENUM_VALUE2870": 17,
+		"ENUM_VALUE2871": 18,
+		"ENUM_VALUE2872": 19,
+		"ENUM_VALUE2873": 20,
+		"ENUM_VALUE2874": 21,
+		"ENUM_VALUE2875": 22,
+		"ENUM_VALUE2876": 23,
+		"ENUM_VALUE2877": 24,
+		"ENUM_VALUE2878": 25,
+		"ENUM_VALUE2879": 26,
+		"ENUM_VALUE2880": 27,
+		"ENUM_VALUE2881": 28,
+		"ENUM_VALUE2882": 29,
+		"ENUM_VALUE2883": 30,
+		"ENUM_VALUE2884": 31,
+		"ENUM_VALUE2885": 32,
+		"ENUM_VALUE2886": 33,
+		"ENUM_VALUE2887": 34,
+		"ENUM_VALUE2888": 35,
+		"ENUM_VALUE2889": 36,
+		"ENUM_VALUE2890": 37,
+		"ENUM_VALUE2891": 38,
+		"ENUM_VALUE2892": 39,
+		"ENUM_VALUE2893": 40,
+		"ENUM_VALUE2894": 41,
+		"ENUM_VALUE2895": 42,
+		"ENUM_VALUE2896": 43,
+		"ENUM_VALUE2897": 44,
+		"ENUM_VALUE2898": 45,
+		"ENUM_VALUE2899": 46,
+		"ENUM_VALUE2900": 47,
+		"ENUM_VALUE2901": 48,
+		"ENUM_VALUE2902": 49,
+		"ENUM_VALUE2903": 50,
+		"ENUM_VALUE2904": 51,
+		"ENUM_VALUE2905": 52,
+		"ENUM_VALUE2906": 53,
+		"ENUM_VALUE2907": 54,
+		"ENUM_VALUE2908": 55,
+		"ENUM_VALUE2909": 56,
+		"ENUM_VALUE2910": 57,
+		"ENUM_VALUE2911": 58,
+		"ENUM_VALUE2912": 59,
+		"ENUM_VALUE2913": 60,
+		"ENUM_VALUE2914": 61,
+		"ENUM_VALUE2915": 62,
+		"ENUM_VALUE2916": 63,
+		"ENUM_VALUE2917": 64,
+		"ENUM_VALUE2918": 65,
+		"ENUM_VALUE2919": 66,
+		"ENUM_VALUE2920": 67,
+		"ENUM_VALUE2921": 68,
+		"ENUM_VALUE2922": 69,
+		"ENUM_VALUE2923": 70,
+		"ENUM_VALUE2924": 71,
+		"ENUM_VALUE2925": 72,
+		"ENUM_VALUE2926": 73,
+		"ENUM_VALUE2927": 74,
+		"ENUM_VALUE2928": 75,
+		"ENUM_VALUE2929": 76,
+		"ENUM_VALUE2930": 77,
+		"ENUM_VALUE2931": 78,
+		"ENUM_VALUE2932": 79,
+		"ENUM_VALUE2933": 80,
+		"ENUM_VALUE2934": 81,
+		"ENUM_VALUE2935": 82,
+		"ENUM_VALUE2936": 83,
+		"ENUM_VALUE2937": 84,
+		"ENUM_VALUE2938": 85,
+		"ENUM_VALUE2939": 86,
+		"ENUM_VALUE2940": 87,
+		"ENUM_VALUE2941": 88,
+		"ENUM_VALUE2942": 89,
+		"ENUM_VALUE2943": 90,
+		"ENUM_VALUE2944": 91,
+		"ENUM_VALUE2945": 92,
+		"ENUM_VALUE2946": 93,
+		"ENUM_VALUE2947": 94,
+		"ENUM_VALUE2948": 95,
+		"ENUM_VALUE2949": 96,
+		"ENUM_VALUE2950": 97,
+		"ENUM_VALUE2951": 98,
+		"ENUM_VALUE2952": 99,
+		"ENUM_VALUE2953": 100,
+		"ENUM_VALUE2954": 101,
+		"ENUM_VALUE2955": 102,
+		"ENUM_VALUE2956": 103,
+		"ENUM_VALUE2957": 104,
+		"ENUM_VALUE2958": 105,
+		"ENUM_VALUE2959": 106,
+		"ENUM_VALUE2960": 107,
+		"ENUM_VALUE2961": 108,
+		"ENUM_VALUE2962": 109,
+		"ENUM_VALUE2963": 110,
+		"ENUM_VALUE2964": 111,
+		"ENUM_VALUE2965": 112,
+		"ENUM_VALUE2966": 113,
+		"ENUM_VALUE2967": 114,
+		"ENUM_VALUE2968": 115,
+		"ENUM_VALUE2969": 116,
+		"ENUM_VALUE2970": 117,
+		"ENUM_VALUE2971": 118,
+		"ENUM_VALUE2972": 119,
+	}
+)
+
+func (x Enum2851) Enum() *Enum2851 {
+	p := new(Enum2851)
+	*p = x
+	return p
+}
+
+func (x Enum2851) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum2851) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[4].Descriptor()
+}
+
+func (Enum2851) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[4]
+}
+
+func (x Enum2851) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum2851) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum2851(num)
+	return nil
+}
+
+// Deprecated: Use Enum2851.Descriptor instead.
+func (Enum2851) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{4}
+}
+
+type Enum2602 int32
+
+const (
+	Enum2602_ENUM_VALUE2603 Enum2602 = 0
+	Enum2602_ENUM_VALUE2604 Enum2602 = 1
+	Enum2602_ENUM_VALUE2605 Enum2602 = 2
+	Enum2602_ENUM_VALUE2606 Enum2602 = 3
+	Enum2602_ENUM_VALUE2607 Enum2602 = 4
+	Enum2602_ENUM_VALUE2608 Enum2602 = 5
+	Enum2602_ENUM_VALUE2609 Enum2602 = 6
+	Enum2602_ENUM_VALUE2610 Enum2602 = 7
+	Enum2602_ENUM_VALUE2611 Enum2602 = 8
+	Enum2602_ENUM_VALUE2612 Enum2602 = 9
+	Enum2602_ENUM_VALUE2613 Enum2602 = 10
+	Enum2602_ENUM_VALUE2614 Enum2602 = 11
+)
+
+// Enum value maps for Enum2602.
+var (
+	Enum2602_name = map[int32]string{
+		0:  "ENUM_VALUE2603",
+		1:  "ENUM_VALUE2604",
+		2:  "ENUM_VALUE2605",
+		3:  "ENUM_VALUE2606",
+		4:  "ENUM_VALUE2607",
+		5:  "ENUM_VALUE2608",
+		6:  "ENUM_VALUE2609",
+		7:  "ENUM_VALUE2610",
+		8:  "ENUM_VALUE2611",
+		9:  "ENUM_VALUE2612",
+		10: "ENUM_VALUE2613",
+		11: "ENUM_VALUE2614",
+	}
+	Enum2602_value = map[string]int32{
+		"ENUM_VALUE2603": 0,
+		"ENUM_VALUE2604": 1,
+		"ENUM_VALUE2605": 2,
+		"ENUM_VALUE2606": 3,
+		"ENUM_VALUE2607": 4,
+		"ENUM_VALUE2608": 5,
+		"ENUM_VALUE2609": 6,
+		"ENUM_VALUE2610": 7,
+		"ENUM_VALUE2611": 8,
+		"ENUM_VALUE2612": 9,
+		"ENUM_VALUE2613": 10,
+		"ENUM_VALUE2614": 11,
+	}
+)
+
+func (x Enum2602) Enum() *Enum2602 {
+	p := new(Enum2602)
+	*p = x
+	return p
+}
+
+func (x Enum2602) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum2602) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[5].Descriptor()
+}
+
+func (Enum2602) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[5]
+}
+
+func (x Enum2602) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum2602) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum2602(num)
+	return nil
+}
+
+// Deprecated: Use Enum2602.Descriptor instead.
+func (Enum2602) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{5}
+}
+
+type Enum3071 int32
+
+const (
+	Enum3071_ENUM_VALUE3072 Enum3071 = 1
+	Enum3071_ENUM_VALUE3073 Enum3071 = 2
+	Enum3071_ENUM_VALUE3074 Enum3071 = 3
+	Enum3071_ENUM_VALUE3075 Enum3071 = 4
+	Enum3071_ENUM_VALUE3076 Enum3071 = 5
+	Enum3071_ENUM_VALUE3077 Enum3071 = 6
+	Enum3071_ENUM_VALUE3078 Enum3071 = 7
+	Enum3071_ENUM_VALUE3079 Enum3071 = 8
+	Enum3071_ENUM_VALUE3080 Enum3071 = 9
+	Enum3071_ENUM_VALUE3081 Enum3071 = 10
+	Enum3071_ENUM_VALUE3082 Enum3071 = 11
+	Enum3071_ENUM_VALUE3083 Enum3071 = 12
+	Enum3071_ENUM_VALUE3084 Enum3071 = 13
+	Enum3071_ENUM_VALUE3085 Enum3071 = 14
+	Enum3071_ENUM_VALUE3086 Enum3071 = 15
+	Enum3071_ENUM_VALUE3087 Enum3071 = 16
+	Enum3071_ENUM_VALUE3088 Enum3071 = 17
+	Enum3071_ENUM_VALUE3089 Enum3071 = 18
+	Enum3071_ENUM_VALUE3090 Enum3071 = 19
+	Enum3071_ENUM_VALUE3091 Enum3071 = 20
+	Enum3071_ENUM_VALUE3092 Enum3071 = 21
+	Enum3071_ENUM_VALUE3093 Enum3071 = 22
+	Enum3071_ENUM_VALUE3094 Enum3071 = 23
+	Enum3071_ENUM_VALUE3095 Enum3071 = 24
+	Enum3071_ENUM_VALUE3096 Enum3071 = 25
+	Enum3071_ENUM_VALUE3097 Enum3071 = 26
+	Enum3071_ENUM_VALUE3098 Enum3071 = 27
+	Enum3071_ENUM_VALUE3099 Enum3071 = 28
+)
+
+// Enum value maps for Enum3071.
+var (
+	Enum3071_name = map[int32]string{
+		1:  "ENUM_VALUE3072",
+		2:  "ENUM_VALUE3073",
+		3:  "ENUM_VALUE3074",
+		4:  "ENUM_VALUE3075",
+		5:  "ENUM_VALUE3076",
+		6:  "ENUM_VALUE3077",
+		7:  "ENUM_VALUE3078",
+		8:  "ENUM_VALUE3079",
+		9:  "ENUM_VALUE3080",
+		10: "ENUM_VALUE3081",
+		11: "ENUM_VALUE3082",
+		12: "ENUM_VALUE3083",
+		13: "ENUM_VALUE3084",
+		14: "ENUM_VALUE3085",
+		15: "ENUM_VALUE3086",
+		16: "ENUM_VALUE3087",
+		17: "ENUM_VALUE3088",
+		18: "ENUM_VALUE3089",
+		19: "ENUM_VALUE3090",
+		20: "ENUM_VALUE3091",
+		21: "ENUM_VALUE3092",
+		22: "ENUM_VALUE3093",
+		23: "ENUM_VALUE3094",
+		24: "ENUM_VALUE3095",
+		25: "ENUM_VALUE3096",
+		26: "ENUM_VALUE3097",
+		27: "ENUM_VALUE3098",
+		28: "ENUM_VALUE3099",
+	}
+	Enum3071_value = map[string]int32{
+		"ENUM_VALUE3072": 1,
+		"ENUM_VALUE3073": 2,
+		"ENUM_VALUE3074": 3,
+		"ENUM_VALUE3075": 4,
+		"ENUM_VALUE3076": 5,
+		"ENUM_VALUE3077": 6,
+		"ENUM_VALUE3078": 7,
+		"ENUM_VALUE3079": 8,
+		"ENUM_VALUE3080": 9,
+		"ENUM_VALUE3081": 10,
+		"ENUM_VALUE3082": 11,
+		"ENUM_VALUE3083": 12,
+		"ENUM_VALUE3084": 13,
+		"ENUM_VALUE3085": 14,
+		"ENUM_VALUE3086": 15,
+		"ENUM_VALUE3087": 16,
+		"ENUM_VALUE3088": 17,
+		"ENUM_VALUE3089": 18,
+		"ENUM_VALUE3090": 19,
+		"ENUM_VALUE3091": 20,
+		"ENUM_VALUE3092": 21,
+		"ENUM_VALUE3093": 22,
+		"ENUM_VALUE3094": 23,
+		"ENUM_VALUE3095": 24,
+		"ENUM_VALUE3096": 25,
+		"ENUM_VALUE3097": 26,
+		"ENUM_VALUE3098": 27,
+		"ENUM_VALUE3099": 28,
+	}
+)
+
+func (x Enum3071) Enum() *Enum3071 {
+	p := new(Enum3071)
+	*p = x
+	return p
+}
+
+func (x Enum3071) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum3071) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[6].Descriptor()
+}
+
+func (Enum3071) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[6]
+}
+
+func (x Enum3071) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum3071) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum3071(num)
+	return nil
+}
+
+// Deprecated: Use Enum3071.Descriptor instead.
+func (Enum3071) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{6}
+}
+
+type Enum3805 int32
+
+const (
+	Enum3805_ENUM_VALUE3806 Enum3805 = 0
+	Enum3805_ENUM_VALUE3807 Enum3805 = 1
+	Enum3805_ENUM_VALUE3808 Enum3805 = 2
+	Enum3805_ENUM_VALUE3809 Enum3805 = 3
+	Enum3805_ENUM_VALUE3810 Enum3805 = 4
+	Enum3805_ENUM_VALUE3811 Enum3805 = 5
+	Enum3805_ENUM_VALUE3812 Enum3805 = 6
+	Enum3805_ENUM_VALUE3813 Enum3805 = 7
+	Enum3805_ENUM_VALUE3814 Enum3805 = 8
+	Enum3805_ENUM_VALUE3815 Enum3805 = 9
+	Enum3805_ENUM_VALUE3816 Enum3805 = 11
+	Enum3805_ENUM_VALUE3817 Enum3805 = 10
+)
+
+// Enum value maps for Enum3805.
+var (
+	Enum3805_name = map[int32]string{
+		0:  "ENUM_VALUE3806",
+		1:  "ENUM_VALUE3807",
+		2:  "ENUM_VALUE3808",
+		3:  "ENUM_VALUE3809",
+		4:  "ENUM_VALUE3810",
+		5:  "ENUM_VALUE3811",
+		6:  "ENUM_VALUE3812",
+		7:  "ENUM_VALUE3813",
+		8:  "ENUM_VALUE3814",
+		9:  "ENUM_VALUE3815",
+		11: "ENUM_VALUE3816",
+		10: "ENUM_VALUE3817",
+	}
+	Enum3805_value = map[string]int32{
+		"ENUM_VALUE3806": 0,
+		"ENUM_VALUE3807": 1,
+		"ENUM_VALUE3808": 2,
+		"ENUM_VALUE3809": 3,
+		"ENUM_VALUE3810": 4,
+		"ENUM_VALUE3811": 5,
+		"ENUM_VALUE3812": 6,
+		"ENUM_VALUE3813": 7,
+		"ENUM_VALUE3814": 8,
+		"ENUM_VALUE3815": 9,
+		"ENUM_VALUE3816": 11,
+		"ENUM_VALUE3817": 10,
+	}
+)
+
+func (x Enum3805) Enum() *Enum3805 {
+	p := new(Enum3805)
+	*p = x
+	return p
+}
+
+func (x Enum3805) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum3805) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[7].Descriptor()
+}
+
+func (Enum3805) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[7]
+}
+
+func (x Enum3805) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum3805) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum3805(num)
+	return nil
+}
+
+// Deprecated: Use Enum3805.Descriptor instead.
+func (Enum3805) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{7}
+}
+
+type Enum3783 int32
+
+const (
+	Enum3783_ENUM_VALUE3784 Enum3783 = 0
+	Enum3783_ENUM_VALUE3785 Enum3783 = 1
+	Enum3783_ENUM_VALUE3786 Enum3783 = 2
+	Enum3783_ENUM_VALUE3787 Enum3783 = 3
+	Enum3783_ENUM_VALUE3788 Enum3783 = 4
+	Enum3783_ENUM_VALUE3789 Enum3783 = 5
+	Enum3783_ENUM_VALUE3790 Enum3783 = 6
+	Enum3783_ENUM_VALUE3791 Enum3783 = 7
+	Enum3783_ENUM_VALUE3792 Enum3783 = 8
+	Enum3783_ENUM_VALUE3793 Enum3783 = 9
+	Enum3783_ENUM_VALUE3794 Enum3783 = 10
+	Enum3783_ENUM_VALUE3795 Enum3783 = 11
+	Enum3783_ENUM_VALUE3796 Enum3783 = 12
+	Enum3783_ENUM_VALUE3797 Enum3783 = 13
+	Enum3783_ENUM_VALUE3798 Enum3783 = 14
+	Enum3783_ENUM_VALUE3799 Enum3783 = 15
+	Enum3783_ENUM_VALUE3800 Enum3783 = 16
+	Enum3783_ENUM_VALUE3801 Enum3783 = 20
+	Enum3783_ENUM_VALUE3802 Enum3783 = 21
+	Enum3783_ENUM_VALUE3803 Enum3783 = 50
+)
+
+// Enum value maps for Enum3783.
+var (
+	Enum3783_name = map[int32]string{
+		0:  "ENUM_VALUE3784",
+		1:  "ENUM_VALUE3785",
+		2:  "ENUM_VALUE3786",
+		3:  "ENUM_VALUE3787",
+		4:  "ENUM_VALUE3788",
+		5:  "ENUM_VALUE3789",
+		6:  "ENUM_VALUE3790",
+		7:  "ENUM_VALUE3791",
+		8:  "ENUM_VALUE3792",
+		9:  "ENUM_VALUE3793",
+		10: "ENUM_VALUE3794",
+		11: "ENUM_VALUE3795",
+		12: "ENUM_VALUE3796",
+		13: "ENUM_VALUE3797",
+		14: "ENUM_VALUE3798",
+		15: "ENUM_VALUE3799",
+		16: "ENUM_VALUE3800",
+		20: "ENUM_VALUE3801",
+		21: "ENUM_VALUE3802",
+		50: "ENUM_VALUE3803",
+	}
+	Enum3783_value = map[string]int32{
+		"ENUM_VALUE3784": 0,
+		"ENUM_VALUE3785": 1,
+		"ENUM_VALUE3786": 2,
+		"ENUM_VALUE3787": 3,
+		"ENUM_VALUE3788": 4,
+		"ENUM_VALUE3789": 5,
+		"ENUM_VALUE3790": 6,
+		"ENUM_VALUE3791": 7,
+		"ENUM_VALUE3792": 8,
+		"ENUM_VALUE3793": 9,
+		"ENUM_VALUE3794": 10,
+		"ENUM_VALUE3795": 11,
+		"ENUM_VALUE3796": 12,
+		"ENUM_VALUE3797": 13,
+		"ENUM_VALUE3798": 14,
+		"ENUM_VALUE3799": 15,
+		"ENUM_VALUE3800": 16,
+		"ENUM_VALUE3801": 20,
+		"ENUM_VALUE3802": 21,
+		"ENUM_VALUE3803": 50,
+	}
+)
+
+func (x Enum3783) Enum() *Enum3783 {
+	p := new(Enum3783)
+	*p = x
+	return p
+}
+
+func (x Enum3783) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum3783) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[8].Descriptor()
+}
+
+func (Enum3783) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[8]
+}
+
+func (x Enum3783) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum3783) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum3783(num)
+	return nil
+}
+
+// Deprecated: Use Enum3783.Descriptor instead.
+func (Enum3783) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{8}
+}
+
+type Enum3851 int32
+
+const (
+	Enum3851_ENUM_VALUE3852 Enum3851 = 0
+	Enum3851_ENUM_VALUE3853 Enum3851 = 1
+	Enum3851_ENUM_VALUE3854 Enum3851 = 2
+	Enum3851_ENUM_VALUE3855 Enum3851 = 3
+	Enum3851_ENUM_VALUE3856 Enum3851 = 4
+	Enum3851_ENUM_VALUE3857 Enum3851 = 5
+	Enum3851_ENUM_VALUE3858 Enum3851 = 6
+	Enum3851_ENUM_VALUE3859 Enum3851 = 7
+	Enum3851_ENUM_VALUE3860 Enum3851 = 8
+	Enum3851_ENUM_VALUE3861 Enum3851 = 9
+	Enum3851_ENUM_VALUE3862 Enum3851 = 10
+	Enum3851_ENUM_VALUE3863 Enum3851 = 11
+	Enum3851_ENUM_VALUE3864 Enum3851 = 12
+	Enum3851_ENUM_VALUE3865 Enum3851 = 13
+	Enum3851_ENUM_VALUE3866 Enum3851 = 14
+	Enum3851_ENUM_VALUE3867 Enum3851 = 15
+	Enum3851_ENUM_VALUE3868 Enum3851 = 16
+	Enum3851_ENUM_VALUE3869 Enum3851 = 17
+)
+
+// Enum value maps for Enum3851.
+var (
+	Enum3851_name = map[int32]string{
+		0:  "ENUM_VALUE3852",
+		1:  "ENUM_VALUE3853",
+		2:  "ENUM_VALUE3854",
+		3:  "ENUM_VALUE3855",
+		4:  "ENUM_VALUE3856",
+		5:  "ENUM_VALUE3857",
+		6:  "ENUM_VALUE3858",
+		7:  "ENUM_VALUE3859",
+		8:  "ENUM_VALUE3860",
+		9:  "ENUM_VALUE3861",
+		10: "ENUM_VALUE3862",
+		11: "ENUM_VALUE3863",
+		12: "ENUM_VALUE3864",
+		13: "ENUM_VALUE3865",
+		14: "ENUM_VALUE3866",
+		15: "ENUM_VALUE3867",
+		16: "ENUM_VALUE3868",
+		17: "ENUM_VALUE3869",
+	}
+	Enum3851_value = map[string]int32{
+		"ENUM_VALUE3852": 0,
+		"ENUM_VALUE3853": 1,
+		"ENUM_VALUE3854": 2,
+		"ENUM_VALUE3855": 3,
+		"ENUM_VALUE3856": 4,
+		"ENUM_VALUE3857": 5,
+		"ENUM_VALUE3858": 6,
+		"ENUM_VALUE3859": 7,
+		"ENUM_VALUE3860": 8,
+		"ENUM_VALUE3861": 9,
+		"ENUM_VALUE3862": 10,
+		"ENUM_VALUE3863": 11,
+		"ENUM_VALUE3864": 12,
+		"ENUM_VALUE3865": 13,
+		"ENUM_VALUE3866": 14,
+		"ENUM_VALUE3867": 15,
+		"ENUM_VALUE3868": 16,
+		"ENUM_VALUE3869": 17,
+	}
+)
+
+func (x Enum3851) Enum() *Enum3851 {
+	p := new(Enum3851)
+	*p = x
+	return p
+}
+
+func (x Enum3851) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum3851) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[9].Descriptor()
+}
+
+func (Enum3851) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[9]
+}
+
+func (x Enum3851) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum3851) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum3851(num)
+	return nil
+}
+
+// Deprecated: Use Enum3851.Descriptor instead.
+func (Enum3851) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{9}
+}
+
+type Enum5862 int32
+
+const (
+	Enum5862_ENUM_VALUE5863 Enum5862 = 1
+	Enum5862_ENUM_VALUE5864 Enum5862 = 2
+	Enum5862_ENUM_VALUE5865 Enum5862 = 3
+)
+
+// Enum value maps for Enum5862.
+var (
+	Enum5862_name = map[int32]string{
+		1: "ENUM_VALUE5863",
+		2: "ENUM_VALUE5864",
+		3: "ENUM_VALUE5865",
+	}
+	Enum5862_value = map[string]int32{
+		"ENUM_VALUE5863": 1,
+		"ENUM_VALUE5864": 2,
+		"ENUM_VALUE5865": 3,
+	}
+)
+
+func (x Enum5862) Enum() *Enum5862 {
+	p := new(Enum5862)
+	*p = x
+	return p
+}
+
+func (x Enum5862) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum5862) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[10].Descriptor()
+}
+
+func (Enum5862) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[10]
+}
+
+func (x Enum5862) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum5862) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum5862(num)
+	return nil
+}
+
+// Deprecated: Use Enum5862.Descriptor instead.
+func (Enum5862) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{10}
+}
+
+type Enum5868 int32
+
+const (
+	Enum5868_ENUM_VALUE5869 Enum5868 = 0
+	Enum5868_ENUM_VALUE5870 Enum5868 = 1
+	Enum5868_ENUM_VALUE5871 Enum5868 = 2
+	Enum5868_ENUM_VALUE5872 Enum5868 = 3
+)
+
+// Enum value maps for Enum5868.
+var (
+	Enum5868_name = map[int32]string{
+		0: "ENUM_VALUE5869",
+		1: "ENUM_VALUE5870",
+		2: "ENUM_VALUE5871",
+		3: "ENUM_VALUE5872",
+	}
+	Enum5868_value = map[string]int32{
+		"ENUM_VALUE5869": 0,
+		"ENUM_VALUE5870": 1,
+		"ENUM_VALUE5871": 2,
+		"ENUM_VALUE5872": 3,
+	}
+)
+
+func (x Enum5868) Enum() *Enum5868 {
+	p := new(Enum5868)
+	*p = x
+	return p
+}
+
+func (x Enum5868) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum5868) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[11].Descriptor()
+}
+
+func (Enum5868) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[11]
+}
+
+func (x Enum5868) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum5868) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum5868(num)
+	return nil
+}
+
+// Deprecated: Use Enum5868.Descriptor instead.
+func (Enum5868) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{11}
+}
+
+type Enum5873 int32
+
+const (
+	Enum5873_ENUM_VALUE5874 Enum5873 = 0
+	Enum5873_ENUM_VALUE5875 Enum5873 = 1
+	Enum5873_ENUM_VALUE5876 Enum5873 = 2
+)
+
+// Enum value maps for Enum5873.
+var (
+	Enum5873_name = map[int32]string{
+		0: "ENUM_VALUE5874",
+		1: "ENUM_VALUE5875",
+		2: "ENUM_VALUE5876",
+	}
+	Enum5873_value = map[string]int32{
+		"ENUM_VALUE5874": 0,
+		"ENUM_VALUE5875": 1,
+		"ENUM_VALUE5876": 2,
+	}
+)
+
+func (x Enum5873) Enum() *Enum5873 {
+	p := new(Enum5873)
+	*p = x
+	return p
+}
+
+func (x Enum5873) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum5873) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[12].Descriptor()
+}
+
+func (Enum5873) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[12]
+}
+
+func (x Enum5873) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum5873) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum5873(num)
+	return nil
+}
+
+// Deprecated: Use Enum5873.Descriptor instead.
+func (Enum5873) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{12}
+}
+
+type Enum5904 int32
+
+const (
+	Enum5904_ENUM_VALUE5905 Enum5904 = 0
+	Enum5904_ENUM_VALUE5906 Enum5904 = 1
+)
+
+// Enum value maps for Enum5904.
+var (
+	Enum5904_name = map[int32]string{
+		0: "ENUM_VALUE5905",
+		1: "ENUM_VALUE5906",
+	}
+	Enum5904_value = map[string]int32{
+		"ENUM_VALUE5905": 0,
+		"ENUM_VALUE5906": 1,
+	}
+)
+
+func (x Enum5904) Enum() *Enum5904 {
+	p := new(Enum5904)
+	*p = x
+	return p
+}
+
+func (x Enum5904) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum5904) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[13].Descriptor()
+}
+
+func (Enum5904) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[13]
+}
+
+func (x Enum5904) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum5904) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum5904(num)
+	return nil
+}
+
+// Deprecated: Use Enum5904.Descriptor instead.
+func (Enum5904) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{13}
+}
+
+type Enum5909 int32
+
+const (
+	Enum5909_ENUM_VALUE5910 Enum5909 = 0
+	Enum5909_ENUM_VALUE5911 Enum5909 = 1
+)
+
+// Enum value maps for Enum5909.
+var (
+	Enum5909_name = map[int32]string{
+		0: "ENUM_VALUE5910",
+		1: "ENUM_VALUE5911",
+	}
+	Enum5909_value = map[string]int32{
+		"ENUM_VALUE5910": 0,
+		"ENUM_VALUE5911": 1,
+	}
+)
+
+func (x Enum5909) Enum() *Enum5909 {
+	p := new(Enum5909)
+	*p = x
+	return p
+}
+
+func (x Enum5909) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum5909) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[14].Descriptor()
+}
+
+func (Enum5909) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[14]
+}
+
+func (x Enum5909) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum5909) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum5909(num)
+	return nil
+}
+
+// Deprecated: Use Enum5909.Descriptor instead.
+func (Enum5909) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{14}
+}
+
+type Enum5912 int32
+
+const (
+	Enum5912_ENUM_VALUE5913 Enum5912 = 0
+	Enum5912_ENUM_VALUE5914 Enum5912 = 1
+)
+
+// Enum value maps for Enum5912.
+var (
+	Enum5912_name = map[int32]string{
+		0: "ENUM_VALUE5913",
+		1: "ENUM_VALUE5914",
+	}
+	Enum5912_value = map[string]int32{
+		"ENUM_VALUE5913": 0,
+		"ENUM_VALUE5914": 1,
+	}
+)
+
+func (x Enum5912) Enum() *Enum5912 {
+	p := new(Enum5912)
+	*p = x
+	return p
+}
+
+func (x Enum5912) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum5912) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[15].Descriptor()
+}
+
+func (Enum5912) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[15]
+}
+
+func (x Enum5912) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum5912) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum5912(num)
+	return nil
+}
+
+// Deprecated: Use Enum5912.Descriptor instead.
+func (Enum5912) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{15}
+}
+
+type Enum5915 int32
+
+const (
+	Enum5915_ENUM_VALUE5916 Enum5915 = 0
+	Enum5915_ENUM_VALUE5917 Enum5915 = 1
+	Enum5915_ENUM_VALUE5918 Enum5915 = 2
+	Enum5915_ENUM_VALUE5919 Enum5915 = 3
+)
+
+// Enum value maps for Enum5915.
+var (
+	Enum5915_name = map[int32]string{
+		0: "ENUM_VALUE5916",
+		1: "ENUM_VALUE5917",
+		2: "ENUM_VALUE5918",
+		3: "ENUM_VALUE5919",
+	}
+	Enum5915_value = map[string]int32{
+		"ENUM_VALUE5916": 0,
+		"ENUM_VALUE5917": 1,
+		"ENUM_VALUE5918": 2,
+		"ENUM_VALUE5919": 3,
+	}
+)
+
+func (x Enum5915) Enum() *Enum5915 {
+	p := new(Enum5915)
+	*p = x
+	return p
+}
+
+func (x Enum5915) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum5915) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[16].Descriptor()
+}
+
+func (Enum5915) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[16]
+}
+
+func (x Enum5915) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum5915) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum5915(num)
+	return nil
+}
+
+// Deprecated: Use Enum5915.Descriptor instead.
+func (Enum5915) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{16}
+}
+
+type Enum5920 int32
+
+const (
+	Enum5920_ENUM_VALUE5921 Enum5920 = 0
+	Enum5920_ENUM_VALUE5922 Enum5920 = 1
+)
+
+// Enum value maps for Enum5920.
+var (
+	Enum5920_name = map[int32]string{
+		0: "ENUM_VALUE5921",
+		1: "ENUM_VALUE5922",
+	}
+	Enum5920_value = map[string]int32{
+		"ENUM_VALUE5921": 0,
+		"ENUM_VALUE5922": 1,
+	}
+)
+
+func (x Enum5920) Enum() *Enum5920 {
+	p := new(Enum5920)
+	*p = x
+	return p
+}
+
+func (x Enum5920) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum5920) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[17].Descriptor()
+}
+
+func (Enum5920) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[17]
+}
+
+func (x Enum5920) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum5920) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum5920(num)
+	return nil
+}
+
+// Deprecated: Use Enum5920.Descriptor instead.
+func (Enum5920) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{17}
+}
+
+type Enum5923 int32
+
+const (
+	Enum5923_ENUM_VALUE5924 Enum5923 = 0
+	Enum5923_ENUM_VALUE5925 Enum5923 = 1
+	Enum5923_ENUM_VALUE5926 Enum5923 = 2
+	Enum5923_ENUM_VALUE5927 Enum5923 = 3
+)
+
+// Enum value maps for Enum5923.
+var (
+	Enum5923_name = map[int32]string{
+		0: "ENUM_VALUE5924",
+		1: "ENUM_VALUE5925",
+		2: "ENUM_VALUE5926",
+		3: "ENUM_VALUE5927",
+	}
+	Enum5923_value = map[string]int32{
+		"ENUM_VALUE5924": 0,
+		"ENUM_VALUE5925": 1,
+		"ENUM_VALUE5926": 2,
+		"ENUM_VALUE5927": 3,
+	}
+)
+
+func (x Enum5923) Enum() *Enum5923 {
+	p := new(Enum5923)
+	*p = x
+	return p
+}
+
+func (x Enum5923) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum5923) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[18].Descriptor()
+}
+
+func (Enum5923) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[18]
+}
+
+func (x Enum5923) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum5923) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum5923(num)
+	return nil
+}
+
+// Deprecated: Use Enum5923.Descriptor instead.
+func (Enum5923) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{18}
+}
+
+type Enum5928 int32
+
+const (
+	Enum5928_ENUM_VALUE5929 Enum5928 = 0
+	Enum5928_ENUM_VALUE5930 Enum5928 = 1
+)
+
+// Enum value maps for Enum5928.
+var (
+	Enum5928_name = map[int32]string{
+		0: "ENUM_VALUE5929",
+		1: "ENUM_VALUE5930",
+	}
+	Enum5928_value = map[string]int32{
+		"ENUM_VALUE5929": 0,
+		"ENUM_VALUE5930": 1,
+	}
+)
+
+func (x Enum5928) Enum() *Enum5928 {
+	p := new(Enum5928)
+	*p = x
+	return p
+}
+
+func (x Enum5928) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum5928) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[19].Descriptor()
+}
+
+func (Enum5928) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[19]
+}
+
+func (x Enum5928) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum5928) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum5928(num)
+	return nil
+}
+
+// Deprecated: Use Enum5928.Descriptor instead.
+func (Enum5928) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{19}
+}
+
+type Enum5931 int32
+
+const (
+	Enum5931_ENUM_VALUE5932 Enum5931 = 0
+	Enum5931_ENUM_VALUE5933 Enum5931 = 1
+	Enum5931_ENUM_VALUE5934 Enum5931 = 2
+)
+
+// Enum value maps for Enum5931.
+var (
+	Enum5931_name = map[int32]string{
+		0: "ENUM_VALUE5932",
+		1: "ENUM_VALUE5933",
+		2: "ENUM_VALUE5934",
+	}
+	Enum5931_value = map[string]int32{
+		"ENUM_VALUE5932": 0,
+		"ENUM_VALUE5933": 1,
+		"ENUM_VALUE5934": 2,
+	}
+)
+
+func (x Enum5931) Enum() *Enum5931 {
+	p := new(Enum5931)
+	*p = x
+	return p
+}
+
+func (x Enum5931) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum5931) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[20].Descriptor()
+}
+
+func (Enum5931) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[20]
+}
+
+func (x Enum5931) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum5931) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum5931(num)
+	return nil
+}
+
+// Deprecated: Use Enum5931.Descriptor instead.
+func (Enum5931) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{20}
+}
+
+type Enum5935 int32
+
+const (
+	Enum5935_ENUM_VALUE5936 Enum5935 = 0
+	Enum5935_ENUM_VALUE5937 Enum5935 = 1
+	Enum5935_ENUM_VALUE5938 Enum5935 = 2
+)
+
+// Enum value maps for Enum5935.
+var (
+	Enum5935_name = map[int32]string{
+		0: "ENUM_VALUE5936",
+		1: "ENUM_VALUE5937",
+		2: "ENUM_VALUE5938",
+	}
+	Enum5935_value = map[string]int32{
+		"ENUM_VALUE5936": 0,
+		"ENUM_VALUE5937": 1,
+		"ENUM_VALUE5938": 2,
+	}
+)
+
+func (x Enum5935) Enum() *Enum5935 {
+	p := new(Enum5935)
+	*p = x
+	return p
+}
+
+func (x Enum5935) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum5935) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[21].Descriptor()
+}
+
+func (Enum5935) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[21]
+}
+
+func (x Enum5935) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum5935) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum5935(num)
+	return nil
+}
+
+// Deprecated: Use Enum5935.Descriptor instead.
+func (Enum5935) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{21}
+}
+
+type Enum5939 int32
+
+const (
+	Enum5939_ENUM_VALUE5940 Enum5939 = 0
+	Enum5939_ENUM_VALUE5941 Enum5939 = 1
+	Enum5939_ENUM_VALUE5942 Enum5939 = 2
+	Enum5939_ENUM_VALUE5943 Enum5939 = 3
+	Enum5939_ENUM_VALUE5944 Enum5939 = 4
+	Enum5939_ENUM_VALUE5945 Enum5939 = 5
+)
+
+// Enum value maps for Enum5939.
+var (
+	Enum5939_name = map[int32]string{
+		0: "ENUM_VALUE5940",
+		1: "ENUM_VALUE5941",
+		2: "ENUM_VALUE5942",
+		3: "ENUM_VALUE5943",
+		4: "ENUM_VALUE5944",
+		5: "ENUM_VALUE5945",
+	}
+	Enum5939_value = map[string]int32{
+		"ENUM_VALUE5940": 0,
+		"ENUM_VALUE5941": 1,
+		"ENUM_VALUE5942": 2,
+		"ENUM_VALUE5943": 3,
+		"ENUM_VALUE5944": 4,
+		"ENUM_VALUE5945": 5,
+	}
+)
+
+func (x Enum5939) Enum() *Enum5939 {
+	p := new(Enum5939)
+	*p = x
+	return p
+}
+
+func (x Enum5939) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum5939) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[22].Descriptor()
+}
+
+func (Enum5939) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[22]
+}
+
+func (x Enum5939) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum5939) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum5939(num)
+	return nil
+}
+
+// Deprecated: Use Enum5939.Descriptor instead.
+func (Enum5939) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{22}
+}
+
+type Enum5946 int32
+
+const (
+	Enum5946_ENUM_VALUE5947 Enum5946 = 0
+	Enum5946_ENUM_VALUE5948 Enum5946 = 1
+	Enum5946_ENUM_VALUE5949 Enum5946 = 2
+	Enum5946_ENUM_VALUE5950 Enum5946 = 3
+	Enum5946_ENUM_VALUE5951 Enum5946 = 4
+	Enum5946_ENUM_VALUE5952 Enum5946 = 5
+	Enum5946_ENUM_VALUE5953 Enum5946 = 6
+	Enum5946_ENUM_VALUE5954 Enum5946 = 7
+	Enum5946_ENUM_VALUE5955 Enum5946 = 8
+	Enum5946_ENUM_VALUE5956 Enum5946 = 9
+)
+
+// Enum value maps for Enum5946.
+var (
+	Enum5946_name = map[int32]string{
+		0: "ENUM_VALUE5947",
+		1: "ENUM_VALUE5948",
+		2: "ENUM_VALUE5949",
+		3: "ENUM_VALUE5950",
+		4: "ENUM_VALUE5951",
+		5: "ENUM_VALUE5952",
+		6: "ENUM_VALUE5953",
+		7: "ENUM_VALUE5954",
+		8: "ENUM_VALUE5955",
+		9: "ENUM_VALUE5956",
+	}
+	Enum5946_value = map[string]int32{
+		"ENUM_VALUE5947": 0,
+		"ENUM_VALUE5948": 1,
+		"ENUM_VALUE5949": 2,
+		"ENUM_VALUE5950": 3,
+		"ENUM_VALUE5951": 4,
+		"ENUM_VALUE5952": 5,
+		"ENUM_VALUE5953": 6,
+		"ENUM_VALUE5954": 7,
+		"ENUM_VALUE5955": 8,
+		"ENUM_VALUE5956": 9,
+	}
+)
+
+func (x Enum5946) Enum() *Enum5946 {
+	p := new(Enum5946)
+	*p = x
+	return p
+}
+
+func (x Enum5946) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum5946) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[23].Descriptor()
+}
+
+func (Enum5946) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[23]
+}
+
+func (x Enum5946) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum5946) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum5946(num)
+	return nil
+}
+
+// Deprecated: Use Enum5946.Descriptor instead.
+func (Enum5946) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{23}
+}
+
+type Enum5957 int32
+
+const (
+	Enum5957_ENUM_VALUE5958 Enum5957 = 0
+	Enum5957_ENUM_VALUE5959 Enum5957 = 1
+	Enum5957_ENUM_VALUE5960 Enum5957 = 2
+	Enum5957_ENUM_VALUE5961 Enum5957 = 3
+)
+
+// Enum value maps for Enum5957.
+var (
+	Enum5957_name = map[int32]string{
+		0: "ENUM_VALUE5958",
+		1: "ENUM_VALUE5959",
+		2: "ENUM_VALUE5960",
+		3: "ENUM_VALUE5961",
+	}
+	Enum5957_value = map[string]int32{
+		"ENUM_VALUE5958": 0,
+		"ENUM_VALUE5959": 1,
+		"ENUM_VALUE5960": 2,
+		"ENUM_VALUE5961": 3,
+	}
+)
+
+func (x Enum5957) Enum() *Enum5957 {
+	p := new(Enum5957)
+	*p = x
+	return p
+}
+
+func (x Enum5957) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum5957) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[24].Descriptor()
+}
+
+func (Enum5957) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[24]
+}
+
+func (x Enum5957) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum5957) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum5957(num)
+	return nil
+}
+
+// Deprecated: Use Enum5957.Descriptor instead.
+func (Enum5957) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{24}
+}
+
+type Enum5962 int32
+
+const (
+	Enum5962_ENUM_VALUE5963 Enum5962 = 0
+	Enum5962_ENUM_VALUE5964 Enum5962 = 1
+)
+
+// Enum value maps for Enum5962.
+var (
+	Enum5962_name = map[int32]string{
+		0: "ENUM_VALUE5963",
+		1: "ENUM_VALUE5964",
+	}
+	Enum5962_value = map[string]int32{
+		"ENUM_VALUE5963": 0,
+		"ENUM_VALUE5964": 1,
+	}
+)
+
+func (x Enum5962) Enum() *Enum5962 {
+	p := new(Enum5962)
+	*p = x
+	return p
+}
+
+func (x Enum5962) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum5962) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[25].Descriptor()
+}
+
+func (Enum5962) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[25]
+}
+
+func (x Enum5962) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum5962) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum5962(num)
+	return nil
+}
+
+// Deprecated: Use Enum5962.Descriptor instead.
+func (Enum5962) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{25}
+}
+
+type Enum6025 int32
+
+const (
+	Enum6025_ENUM_VALUE6026 Enum6025 = 0
+	Enum6025_ENUM_VALUE6027 Enum6025 = 1
+	Enum6025_ENUM_VALUE6028 Enum6025 = 2
+	Enum6025_ENUM_VALUE6029 Enum6025 = 3
+	Enum6025_ENUM_VALUE6030 Enum6025 = 4
+	Enum6025_ENUM_VALUE6031 Enum6025 = 5
+	Enum6025_ENUM_VALUE6032 Enum6025 = 6
+	Enum6025_ENUM_VALUE6033 Enum6025 = 7
+	Enum6025_ENUM_VALUE6034 Enum6025 = 8
+	Enum6025_ENUM_VALUE6035 Enum6025 = 9
+	Enum6025_ENUM_VALUE6036 Enum6025 = 10
+	Enum6025_ENUM_VALUE6037 Enum6025 = 11
+	Enum6025_ENUM_VALUE6038 Enum6025 = 12
+	Enum6025_ENUM_VALUE6039 Enum6025 = 13
+	Enum6025_ENUM_VALUE6040 Enum6025 = 14
+	Enum6025_ENUM_VALUE6041 Enum6025 = 15
+	Enum6025_ENUM_VALUE6042 Enum6025 = 16
+	Enum6025_ENUM_VALUE6043 Enum6025 = 17
+	Enum6025_ENUM_VALUE6044 Enum6025 = 18
+	Enum6025_ENUM_VALUE6045 Enum6025 = 19
+	Enum6025_ENUM_VALUE6046 Enum6025 = 20
+	Enum6025_ENUM_VALUE6047 Enum6025 = 21
+)
+
+// Enum value maps for Enum6025.
+var (
+	Enum6025_name = map[int32]string{
+		0:  "ENUM_VALUE6026",
+		1:  "ENUM_VALUE6027",
+		2:  "ENUM_VALUE6028",
+		3:  "ENUM_VALUE6029",
+		4:  "ENUM_VALUE6030",
+		5:  "ENUM_VALUE6031",
+		6:  "ENUM_VALUE6032",
+		7:  "ENUM_VALUE6033",
+		8:  "ENUM_VALUE6034",
+		9:  "ENUM_VALUE6035",
+		10: "ENUM_VALUE6036",
+		11: "ENUM_VALUE6037",
+		12: "ENUM_VALUE6038",
+		13: "ENUM_VALUE6039",
+		14: "ENUM_VALUE6040",
+		15: "ENUM_VALUE6041",
+		16: "ENUM_VALUE6042",
+		17: "ENUM_VALUE6043",
+		18: "ENUM_VALUE6044",
+		19: "ENUM_VALUE6045",
+		20: "ENUM_VALUE6046",
+		21: "ENUM_VALUE6047",
+	}
+	Enum6025_value = map[string]int32{
+		"ENUM_VALUE6026": 0,
+		"ENUM_VALUE6027": 1,
+		"ENUM_VALUE6028": 2,
+		"ENUM_VALUE6029": 3,
+		"ENUM_VALUE6030": 4,
+		"ENUM_VALUE6031": 5,
+		"ENUM_VALUE6032": 6,
+		"ENUM_VALUE6033": 7,
+		"ENUM_VALUE6034": 8,
+		"ENUM_VALUE6035": 9,
+		"ENUM_VALUE6036": 10,
+		"ENUM_VALUE6037": 11,
+		"ENUM_VALUE6038": 12,
+		"ENUM_VALUE6039": 13,
+		"ENUM_VALUE6040": 14,
+		"ENUM_VALUE6041": 15,
+		"ENUM_VALUE6042": 16,
+		"ENUM_VALUE6043": 17,
+		"ENUM_VALUE6044": 18,
+		"ENUM_VALUE6045": 19,
+		"ENUM_VALUE6046": 20,
+		"ENUM_VALUE6047": 21,
+	}
+)
+
+func (x Enum6025) Enum() *Enum6025 {
+	p := new(Enum6025)
+	*p = x
+	return p
+}
+
+func (x Enum6025) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum6025) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[26].Descriptor()
+}
+
+func (Enum6025) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[26]
+}
+
+func (x Enum6025) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum6025) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum6025(num)
+	return nil
+}
+
+// Deprecated: Use Enum6025.Descriptor instead.
+func (Enum6025) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{26}
+}
+
+type Enum6111 int32
+
+const (
+	Enum6111_ENUM_VALUE6112 Enum6111 = 1
+	Enum6111_ENUM_VALUE6113 Enum6111 = 2
+	Enum6111_ENUM_VALUE6114 Enum6111 = 3
+	Enum6111_ENUM_VALUE6115 Enum6111 = 4
+	Enum6111_ENUM_VALUE6116 Enum6111 = 5
+	Enum6111_ENUM_VALUE6117 Enum6111 = 6
+	Enum6111_ENUM_VALUE6118 Enum6111 = 7
+	Enum6111_ENUM_VALUE6119 Enum6111 = 8
+	Enum6111_ENUM_VALUE6120 Enum6111 = 9
+	Enum6111_ENUM_VALUE6121 Enum6111 = 10
+	Enum6111_ENUM_VALUE6122 Enum6111 = 11
+	Enum6111_ENUM_VALUE6123 Enum6111 = 12
+	Enum6111_ENUM_VALUE6124 Enum6111 = 13
+	Enum6111_ENUM_VALUE6125 Enum6111 = 14
+)
+
+// Enum value maps for Enum6111.
+var (
+	Enum6111_name = map[int32]string{
+		1:  "ENUM_VALUE6112",
+		2:  "ENUM_VALUE6113",
+		3:  "ENUM_VALUE6114",
+		4:  "ENUM_VALUE6115",
+		5:  "ENUM_VALUE6116",
+		6:  "ENUM_VALUE6117",
+		7:  "ENUM_VALUE6118",
+		8:  "ENUM_VALUE6119",
+		9:  "ENUM_VALUE6120",
+		10: "ENUM_VALUE6121",
+		11: "ENUM_VALUE6122",
+		12: "ENUM_VALUE6123",
+		13: "ENUM_VALUE6124",
+		14: "ENUM_VALUE6125",
+	}
+	Enum6111_value = map[string]int32{
+		"ENUM_VALUE6112": 1,
+		"ENUM_VALUE6113": 2,
+		"ENUM_VALUE6114": 3,
+		"ENUM_VALUE6115": 4,
+		"ENUM_VALUE6116": 5,
+		"ENUM_VALUE6117": 6,
+		"ENUM_VALUE6118": 7,
+		"ENUM_VALUE6119": 8,
+		"ENUM_VALUE6120": 9,
+		"ENUM_VALUE6121": 10,
+		"ENUM_VALUE6122": 11,
+		"ENUM_VALUE6123": 12,
+		"ENUM_VALUE6124": 13,
+		"ENUM_VALUE6125": 14,
+	}
+)
+
+func (x Enum6111) Enum() *Enum6111 {
+	p := new(Enum6111)
+	*p = x
+	return p
+}
+
+func (x Enum6111) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum6111) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[27].Descriptor()
+}
+
+func (Enum6111) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[27]
+}
+
+func (x Enum6111) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum6111) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum6111(num)
+	return nil
+}
+
+// Deprecated: Use Enum6111.Descriptor instead.
+func (Enum6111) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{27}
+}
+
+type Enum6065 int32
+
+const (
+	Enum6065_ENUM_VALUE6066 Enum6065 = 0
+	Enum6065_ENUM_VALUE6067 Enum6065 = 1
+	Enum6065_ENUM_VALUE6068 Enum6065 = 2
+	Enum6065_ENUM_VALUE6069 Enum6065 = 3
+	Enum6065_ENUM_VALUE6070 Enum6065 = 4
+	Enum6065_ENUM_VALUE6071 Enum6065 = 5
+	Enum6065_ENUM_VALUE6072 Enum6065 = 6
+	Enum6065_ENUM_VALUE6073 Enum6065 = 7
+	Enum6065_ENUM_VALUE6074 Enum6065 = 8
+	Enum6065_ENUM_VALUE6075 Enum6065 = 9
+	Enum6065_ENUM_VALUE6076 Enum6065 = 10
+	Enum6065_ENUM_VALUE6077 Enum6065 = 11
+	Enum6065_ENUM_VALUE6078 Enum6065 = 12
+	Enum6065_ENUM_VALUE6079 Enum6065 = 13
+	Enum6065_ENUM_VALUE6080 Enum6065 = 14
+)
+
+// Enum value maps for Enum6065.
+var (
+	Enum6065_name = map[int32]string{
+		0:  "ENUM_VALUE6066",
+		1:  "ENUM_VALUE6067",
+		2:  "ENUM_VALUE6068",
+		3:  "ENUM_VALUE6069",
+		4:  "ENUM_VALUE6070",
+		5:  "ENUM_VALUE6071",
+		6:  "ENUM_VALUE6072",
+		7:  "ENUM_VALUE6073",
+		8:  "ENUM_VALUE6074",
+		9:  "ENUM_VALUE6075",
+		10: "ENUM_VALUE6076",
+		11: "ENUM_VALUE6077",
+		12: "ENUM_VALUE6078",
+		13: "ENUM_VALUE6079",
+		14: "ENUM_VALUE6080",
+	}
+	Enum6065_value = map[string]int32{
+		"ENUM_VALUE6066": 0,
+		"ENUM_VALUE6067": 1,
+		"ENUM_VALUE6068": 2,
+		"ENUM_VALUE6069": 3,
+		"ENUM_VALUE6070": 4,
+		"ENUM_VALUE6071": 5,
+		"ENUM_VALUE6072": 6,
+		"ENUM_VALUE6073": 7,
+		"ENUM_VALUE6074": 8,
+		"ENUM_VALUE6075": 9,
+		"ENUM_VALUE6076": 10,
+		"ENUM_VALUE6077": 11,
+		"ENUM_VALUE6078": 12,
+		"ENUM_VALUE6079": 13,
+		"ENUM_VALUE6080": 14,
+	}
+)
+
+func (x Enum6065) Enum() *Enum6065 {
+	p := new(Enum6065)
+	*p = x
+	return p
+}
+
+func (x Enum6065) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum6065) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[28].Descriptor()
+}
+
+func (Enum6065) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[28]
+}
+
+func (x Enum6065) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum6065) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum6065(num)
+	return nil
+}
+
+// Deprecated: Use Enum6065.Descriptor instead.
+func (Enum6065) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{28}
+}
+
+type Enum6130 int32
+
+const (
+	Enum6130_ENUM_VALUE6131 Enum6130 = 0
+	Enum6130_ENUM_VALUE6132 Enum6130 = 1
+)
+
+// Enum value maps for Enum6130.
+var (
+	Enum6130_name = map[int32]string{
+		0: "ENUM_VALUE6131",
+		1: "ENUM_VALUE6132",
+	}
+	Enum6130_value = map[string]int32{
+		"ENUM_VALUE6131": 0,
+		"ENUM_VALUE6132": 1,
+	}
+)
+
+func (x Enum6130) Enum() *Enum6130 {
+	p := new(Enum6130)
+	*p = x
+	return p
+}
+
+func (x Enum6130) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum6130) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[29].Descriptor()
+}
+
+func (Enum6130) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[29]
+}
+
+func (x Enum6130) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum6130) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum6130(num)
+	return nil
+}
+
+// Deprecated: Use Enum6130.Descriptor instead.
+func (Enum6130) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{29}
+}
+
+type Enum6579 int32
+
+const (
+	Enum6579_ENUM_VALUE6580 Enum6579 = 0
+	Enum6579_ENUM_VALUE6581 Enum6579 = 2
+	Enum6579_ENUM_VALUE6582 Enum6579 = 3
+	Enum6579_ENUM_VALUE6583 Enum6579 = 5
+	Enum6579_ENUM_VALUE6584 Enum6579 = 10
+	Enum6579_ENUM_VALUE6585 Enum6579 = 15
+	Enum6579_ENUM_VALUE6586 Enum6579 = 25
+	Enum6579_ENUM_VALUE6587 Enum6579 = 30
+)
+
+// Enum value maps for Enum6579.
+var (
+	Enum6579_name = map[int32]string{
+		0:  "ENUM_VALUE6580",
+		2:  "ENUM_VALUE6581",
+		3:  "ENUM_VALUE6582",
+		5:  "ENUM_VALUE6583",
+		10: "ENUM_VALUE6584",
+		15: "ENUM_VALUE6585",
+		25: "ENUM_VALUE6586",
+		30: "ENUM_VALUE6587",
+	}
+	Enum6579_value = map[string]int32{
+		"ENUM_VALUE6580": 0,
+		"ENUM_VALUE6581": 2,
+		"ENUM_VALUE6582": 3,
+		"ENUM_VALUE6583": 5,
+		"ENUM_VALUE6584": 10,
+		"ENUM_VALUE6585": 15,
+		"ENUM_VALUE6586": 25,
+		"ENUM_VALUE6587": 30,
+	}
+)
+
+func (x Enum6579) Enum() *Enum6579 {
+	p := new(Enum6579)
+	*p = x
+	return p
+}
+
+func (x Enum6579) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum6579) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[30].Descriptor()
+}
+
+func (Enum6579) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[30]
+}
+
+func (x Enum6579) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum6579) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum6579(num)
+	return nil
+}
+
+// Deprecated: Use Enum6579.Descriptor instead.
+func (Enum6579) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{30}
+}
+
+type Enum6588 int32
+
+const (
+	Enum6588_ENUM_VALUE6589 Enum6588 = 0
+	Enum6588_ENUM_VALUE6590 Enum6588 = 1
+	Enum6588_ENUM_VALUE6591 Enum6588 = 2
+	Enum6588_ENUM_VALUE6592 Enum6588 = 3
+	Enum6588_ENUM_VALUE6593 Enum6588 = 4
+	Enum6588_ENUM_VALUE6594 Enum6588 = 5
+	Enum6588_ENUM_VALUE6595 Enum6588 = 6
+	Enum6588_ENUM_VALUE6596 Enum6588 = 7
+	Enum6588_ENUM_VALUE6597 Enum6588 = 8
+	Enum6588_ENUM_VALUE6598 Enum6588 = 9
+	Enum6588_ENUM_VALUE6599 Enum6588 = 10
+	Enum6588_ENUM_VALUE6600 Enum6588 = 11
+	Enum6588_ENUM_VALUE6601 Enum6588 = 12
+	Enum6588_ENUM_VALUE6602 Enum6588 = 13
+	Enum6588_ENUM_VALUE6603 Enum6588 = 14
+	Enum6588_ENUM_VALUE6604 Enum6588 = 15
+	Enum6588_ENUM_VALUE6605 Enum6588 = 16
+	Enum6588_ENUM_VALUE6606 Enum6588 = 17
+	Enum6588_ENUM_VALUE6607 Enum6588 = 19
+	Enum6588_ENUM_VALUE6608 Enum6588 = 20
+	Enum6588_ENUM_VALUE6609 Enum6588 = 21
+	Enum6588_ENUM_VALUE6610 Enum6588 = 22
+	Enum6588_ENUM_VALUE6611 Enum6588 = 23
+	Enum6588_ENUM_VALUE6612 Enum6588 = 24
+	Enum6588_ENUM_VALUE6613 Enum6588 = 25
+	Enum6588_ENUM_VALUE6614 Enum6588 = 26
+	Enum6588_ENUM_VALUE6615 Enum6588 = 27
+	Enum6588_ENUM_VALUE6616 Enum6588 = 28
+	Enum6588_ENUM_VALUE6617 Enum6588 = 29
+	Enum6588_ENUM_VALUE6618 Enum6588 = 30
+	Enum6588_ENUM_VALUE6619 Enum6588 = 31
+	Enum6588_ENUM_VALUE6620 Enum6588 = 32
+	Enum6588_ENUM_VALUE6621 Enum6588 = 33
+	Enum6588_ENUM_VALUE6622 Enum6588 = 34
+)
+
+// Enum value maps for Enum6588.
+var (
+	Enum6588_name = map[int32]string{
+		0:  "ENUM_VALUE6589",
+		1:  "ENUM_VALUE6590",
+		2:  "ENUM_VALUE6591",
+		3:  "ENUM_VALUE6592",
+		4:  "ENUM_VALUE6593",
+		5:  "ENUM_VALUE6594",
+		6:  "ENUM_VALUE6595",
+		7:  "ENUM_VALUE6596",
+		8:  "ENUM_VALUE6597",
+		9:  "ENUM_VALUE6598",
+		10: "ENUM_VALUE6599",
+		11: "ENUM_VALUE6600",
+		12: "ENUM_VALUE6601",
+		13: "ENUM_VALUE6602",
+		14: "ENUM_VALUE6603",
+		15: "ENUM_VALUE6604",
+		16: "ENUM_VALUE6605",
+		17: "ENUM_VALUE6606",
+		19: "ENUM_VALUE6607",
+		20: "ENUM_VALUE6608",
+		21: "ENUM_VALUE6609",
+		22: "ENUM_VALUE6610",
+		23: "ENUM_VALUE6611",
+		24: "ENUM_VALUE6612",
+		25: "ENUM_VALUE6613",
+		26: "ENUM_VALUE6614",
+		27: "ENUM_VALUE6615",
+		28: "ENUM_VALUE6616",
+		29: "ENUM_VALUE6617",
+		30: "ENUM_VALUE6618",
+		31: "ENUM_VALUE6619",
+		32: "ENUM_VALUE6620",
+		33: "ENUM_VALUE6621",
+		34: "ENUM_VALUE6622",
+	}
+	Enum6588_value = map[string]int32{
+		"ENUM_VALUE6589": 0,
+		"ENUM_VALUE6590": 1,
+		"ENUM_VALUE6591": 2,
+		"ENUM_VALUE6592": 3,
+		"ENUM_VALUE6593": 4,
+		"ENUM_VALUE6594": 5,
+		"ENUM_VALUE6595": 6,
+		"ENUM_VALUE6596": 7,
+		"ENUM_VALUE6597": 8,
+		"ENUM_VALUE6598": 9,
+		"ENUM_VALUE6599": 10,
+		"ENUM_VALUE6600": 11,
+		"ENUM_VALUE6601": 12,
+		"ENUM_VALUE6602": 13,
+		"ENUM_VALUE6603": 14,
+		"ENUM_VALUE6604": 15,
+		"ENUM_VALUE6605": 16,
+		"ENUM_VALUE6606": 17,
+		"ENUM_VALUE6607": 19,
+		"ENUM_VALUE6608": 20,
+		"ENUM_VALUE6609": 21,
+		"ENUM_VALUE6610": 22,
+		"ENUM_VALUE6611": 23,
+		"ENUM_VALUE6612": 24,
+		"ENUM_VALUE6613": 25,
+		"ENUM_VALUE6614": 26,
+		"ENUM_VALUE6615": 27,
+		"ENUM_VALUE6616": 28,
+		"ENUM_VALUE6617": 29,
+		"ENUM_VALUE6618": 30,
+		"ENUM_VALUE6619": 31,
+		"ENUM_VALUE6620": 32,
+		"ENUM_VALUE6621": 33,
+		"ENUM_VALUE6622": 34,
+	}
+)
+
+func (x Enum6588) Enum() *Enum6588 {
+	p := new(Enum6588)
+	*p = x
+	return p
+}
+
+func (x Enum6588) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum6588) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[31].Descriptor()
+}
+
+func (Enum6588) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[31]
+}
+
+func (x Enum6588) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum6588) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum6588(num)
+	return nil
+}
+
+// Deprecated: Use Enum6588.Descriptor instead.
+func (Enum6588) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{31}
+}
+
+type Enum7288 int32
+
+const (
+	Enum7288_ENUM_VALUE7289 Enum7288 = 0
+	Enum7288_ENUM_VALUE7290 Enum7288 = 1
+	Enum7288_ENUM_VALUE7291 Enum7288 = 2
+	Enum7288_ENUM_VALUE7292 Enum7288 = 3
+)
+
+// Enum value maps for Enum7288.
+var (
+	Enum7288_name = map[int32]string{
+		0: "ENUM_VALUE7289",
+		1: "ENUM_VALUE7290",
+		2: "ENUM_VALUE7291",
+		3: "ENUM_VALUE7292",
+	}
+	Enum7288_value = map[string]int32{
+		"ENUM_VALUE7289": 0,
+		"ENUM_VALUE7290": 1,
+		"ENUM_VALUE7291": 2,
+		"ENUM_VALUE7292": 3,
+	}
+)
+
+func (x Enum7288) Enum() *Enum7288 {
+	p := new(Enum7288)
+	*p = x
+	return p
+}
+
+func (x Enum7288) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum7288) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[32].Descriptor()
+}
+
+func (Enum7288) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[32]
+}
+
+func (x Enum7288) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum7288) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum7288(num)
+	return nil
+}
+
+// Deprecated: Use Enum7288.Descriptor instead.
+func (Enum7288) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{32}
+}
+
+type Enum7512 int32
+
+const (
+	Enum7512_ENUM_VALUE7513 Enum7512 = 0
+	Enum7512_ENUM_VALUE7514 Enum7512 = 1
+	Enum7512_ENUM_VALUE7515 Enum7512 = 2
+	Enum7512_ENUM_VALUE7516 Enum7512 = 3
+	Enum7512_ENUM_VALUE7517 Enum7512 = 4
+	Enum7512_ENUM_VALUE7518 Enum7512 = 5
+	Enum7512_ENUM_VALUE7519 Enum7512 = 6
+	Enum7512_ENUM_VALUE7520 Enum7512 = 7
+)
+
+// Enum value maps for Enum7512.
+var (
+	Enum7512_name = map[int32]string{
+		0: "ENUM_VALUE7513",
+		1: "ENUM_VALUE7514",
+		2: "ENUM_VALUE7515",
+		3: "ENUM_VALUE7516",
+		4: "ENUM_VALUE7517",
+		5: "ENUM_VALUE7518",
+		6: "ENUM_VALUE7519",
+		7: "ENUM_VALUE7520",
+	}
+	Enum7512_value = map[string]int32{
+		"ENUM_VALUE7513": 0,
+		"ENUM_VALUE7514": 1,
+		"ENUM_VALUE7515": 2,
+		"ENUM_VALUE7516": 3,
+		"ENUM_VALUE7517": 4,
+		"ENUM_VALUE7518": 5,
+		"ENUM_VALUE7519": 6,
+		"ENUM_VALUE7520": 7,
+	}
+)
+
+func (x Enum7512) Enum() *Enum7512 {
+	p := new(Enum7512)
+	*p = x
+	return p
+}
+
+func (x Enum7512) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum7512) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[33].Descriptor()
+}
+
+func (Enum7512) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[33]
+}
+
+func (x Enum7512) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum7512) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum7512(num)
+	return nil
+}
+
+// Deprecated: Use Enum7512.Descriptor instead.
+func (Enum7512) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{33}
+}
+
+type Enum7922 int32
+
+const (
+	Enum7922_ENUM_VALUE7923 Enum7922 = 1
+	Enum7922_ENUM_VALUE7924 Enum7922 = 2
+	Enum7922_ENUM_VALUE7925 Enum7922 = 3
+	Enum7922_ENUM_VALUE7926 Enum7922 = 4
+	Enum7922_ENUM_VALUE7927 Enum7922 = 5
+)
+
+// Enum value maps for Enum7922.
+var (
+	Enum7922_name = map[int32]string{
+		1: "ENUM_VALUE7923",
+		2: "ENUM_VALUE7924",
+		3: "ENUM_VALUE7925",
+		4: "ENUM_VALUE7926",
+		5: "ENUM_VALUE7927",
+	}
+	Enum7922_value = map[string]int32{
+		"ENUM_VALUE7923": 1,
+		"ENUM_VALUE7924": 2,
+		"ENUM_VALUE7925": 3,
+		"ENUM_VALUE7926": 4,
+		"ENUM_VALUE7927": 5,
+	}
+)
+
+func (x Enum7922) Enum() *Enum7922 {
+	p := new(Enum7922)
+	*p = x
+	return p
+}
+
+func (x Enum7922) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum7922) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[34].Descriptor()
+}
+
+func (Enum7922) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[34]
+}
+
+func (x Enum7922) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum7922) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum7922(num)
+	return nil
+}
+
+// Deprecated: Use Enum7922.Descriptor instead.
+func (Enum7922) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{34}
+}
+
+type Enum3476 int32
+
+const (
+	Enum3476_ENUM_VALUE3477 Enum3476 = 0
+	Enum3476_ENUM_VALUE3478 Enum3476 = 1
+	Enum3476_ENUM_VALUE3479 Enum3476 = 2
+	Enum3476_ENUM_VALUE3480 Enum3476 = 3
+	Enum3476_ENUM_VALUE3481 Enum3476 = 4
+	Enum3476_ENUM_VALUE3482 Enum3476 = 5
+	Enum3476_ENUM_VALUE3483 Enum3476 = 6
+	Enum3476_ENUM_VALUE3484 Enum3476 = 7
+	Enum3476_ENUM_VALUE3485 Enum3476 = 8
+	Enum3476_ENUM_VALUE3486 Enum3476 = 9
+	Enum3476_ENUM_VALUE3487 Enum3476 = 10
+	Enum3476_ENUM_VALUE3488 Enum3476 = 11
+	Enum3476_ENUM_VALUE3489 Enum3476 = 12
+	Enum3476_ENUM_VALUE3490 Enum3476 = 13
+	Enum3476_ENUM_VALUE3491 Enum3476 = 14
+	Enum3476_ENUM_VALUE3492 Enum3476 = 15
+	Enum3476_ENUM_VALUE3493 Enum3476 = 16
+	Enum3476_ENUM_VALUE3494 Enum3476 = 17
+	Enum3476_ENUM_VALUE3495 Enum3476 = 18
+	Enum3476_ENUM_VALUE3496 Enum3476 = 19
+	Enum3476_ENUM_VALUE3497 Enum3476 = 20
+	Enum3476_ENUM_VALUE3498 Enum3476 = 21
+	Enum3476_ENUM_VALUE3499 Enum3476 = 22
+	Enum3476_ENUM_VALUE3500 Enum3476 = 23
+	Enum3476_ENUM_VALUE3501 Enum3476 = 24
+	Enum3476_ENUM_VALUE3502 Enum3476 = 25
+	Enum3476_ENUM_VALUE3503 Enum3476 = 26
+	Enum3476_ENUM_VALUE3504 Enum3476 = 27
+	Enum3476_ENUM_VALUE3505 Enum3476 = 28
+	Enum3476_ENUM_VALUE3506 Enum3476 = 29
+	Enum3476_ENUM_VALUE3507 Enum3476 = 30
+	Enum3476_ENUM_VALUE3508 Enum3476 = 31
+	Enum3476_ENUM_VALUE3509 Enum3476 = 32
+	Enum3476_ENUM_VALUE3510 Enum3476 = 33
+	Enum3476_ENUM_VALUE3511 Enum3476 = 34
+	Enum3476_ENUM_VALUE3512 Enum3476 = 35
+	Enum3476_ENUM_VALUE3513 Enum3476 = 36
+	Enum3476_ENUM_VALUE3514 Enum3476 = 37
+	Enum3476_ENUM_VALUE3515 Enum3476 = 38
+	Enum3476_ENUM_VALUE3516 Enum3476 = 39
+	Enum3476_ENUM_VALUE3517 Enum3476 = 40
+	Enum3476_ENUM_VALUE3518 Enum3476 = 41
+	Enum3476_ENUM_VALUE3519 Enum3476 = 42
+	Enum3476_ENUM_VALUE3520 Enum3476 = 43
+	Enum3476_ENUM_VALUE3521 Enum3476 = 44
+	Enum3476_ENUM_VALUE3522 Enum3476 = 45
+	Enum3476_ENUM_VALUE3523 Enum3476 = 46
+	Enum3476_ENUM_VALUE3524 Enum3476 = 47
+	Enum3476_ENUM_VALUE3525 Enum3476 = 48
+	Enum3476_ENUM_VALUE3526 Enum3476 = 49
+	Enum3476_ENUM_VALUE3527 Enum3476 = 50
+	Enum3476_ENUM_VALUE3528 Enum3476 = 51
+	Enum3476_ENUM_VALUE3529 Enum3476 = 52
+	Enum3476_ENUM_VALUE3530 Enum3476 = 53
+	Enum3476_ENUM_VALUE3531 Enum3476 = 54
+	Enum3476_ENUM_VALUE3532 Enum3476 = 55
+	Enum3476_ENUM_VALUE3533 Enum3476 = 56
+	Enum3476_ENUM_VALUE3534 Enum3476 = 57
+	Enum3476_ENUM_VALUE3535 Enum3476 = 58
+	Enum3476_ENUM_VALUE3536 Enum3476 = 59
+	Enum3476_ENUM_VALUE3537 Enum3476 = 60
+	Enum3476_ENUM_VALUE3538 Enum3476 = 61
+	Enum3476_ENUM_VALUE3539 Enum3476 = 62
+	Enum3476_ENUM_VALUE3540 Enum3476 = 63
+	Enum3476_ENUM_VALUE3541 Enum3476 = 64
+	Enum3476_ENUM_VALUE3542 Enum3476 = 65
+	Enum3476_ENUM_VALUE3543 Enum3476 = 66
+	Enum3476_ENUM_VALUE3544 Enum3476 = 67
+	Enum3476_ENUM_VALUE3545 Enum3476 = 68
+	Enum3476_ENUM_VALUE3546 Enum3476 = 69
+	Enum3476_ENUM_VALUE3547 Enum3476 = 70
+	Enum3476_ENUM_VALUE3548 Enum3476 = 71
+	Enum3476_ENUM_VALUE3549 Enum3476 = 72
+	Enum3476_ENUM_VALUE3550 Enum3476 = 73
+	Enum3476_ENUM_VALUE3551 Enum3476 = 74
+	Enum3476_ENUM_VALUE3552 Enum3476 = 75
+	Enum3476_ENUM_VALUE3553 Enum3476 = 76
+	Enum3476_ENUM_VALUE3554 Enum3476 = 77
+	Enum3476_ENUM_VALUE3555 Enum3476 = 78
+	Enum3476_ENUM_VALUE3556 Enum3476 = 79
+	Enum3476_ENUM_VALUE3557 Enum3476 = 80
+	Enum3476_ENUM_VALUE3558 Enum3476 = 81
+	Enum3476_ENUM_VALUE3559 Enum3476 = 82
+	Enum3476_ENUM_VALUE3560 Enum3476 = 83
+	Enum3476_ENUM_VALUE3561 Enum3476 = 84
+	Enum3476_ENUM_VALUE3562 Enum3476 = 85
+	Enum3476_ENUM_VALUE3563 Enum3476 = 86
+	Enum3476_ENUM_VALUE3564 Enum3476 = 87
+	Enum3476_ENUM_VALUE3565 Enum3476 = 88
+	Enum3476_ENUM_VALUE3566 Enum3476 = 89
+	Enum3476_ENUM_VALUE3567 Enum3476 = 90
+	Enum3476_ENUM_VALUE3568 Enum3476 = 91
+	Enum3476_ENUM_VALUE3569 Enum3476 = 92
+	Enum3476_ENUM_VALUE3570 Enum3476 = 93
+	Enum3476_ENUM_VALUE3571 Enum3476 = 94
+	Enum3476_ENUM_VALUE3572 Enum3476 = 95
+	Enum3476_ENUM_VALUE3573 Enum3476 = 96
+	Enum3476_ENUM_VALUE3574 Enum3476 = 97
+	Enum3476_ENUM_VALUE3575 Enum3476 = 98
+	Enum3476_ENUM_VALUE3576 Enum3476 = 99
+	Enum3476_ENUM_VALUE3577 Enum3476 = 100
+	Enum3476_ENUM_VALUE3578 Enum3476 = 101
+	Enum3476_ENUM_VALUE3579 Enum3476 = 102
+	Enum3476_ENUM_VALUE3580 Enum3476 = 103
+	Enum3476_ENUM_VALUE3581 Enum3476 = 104
+	Enum3476_ENUM_VALUE3582 Enum3476 = 105
+	Enum3476_ENUM_VALUE3583 Enum3476 = 106
+	Enum3476_ENUM_VALUE3584 Enum3476 = 107
+	Enum3476_ENUM_VALUE3585 Enum3476 = 108
+	Enum3476_ENUM_VALUE3586 Enum3476 = 109
+	Enum3476_ENUM_VALUE3587 Enum3476 = 110
+	Enum3476_ENUM_VALUE3588 Enum3476 = 111
+	Enum3476_ENUM_VALUE3589 Enum3476 = 112
+	Enum3476_ENUM_VALUE3590 Enum3476 = 113
+	Enum3476_ENUM_VALUE3591 Enum3476 = 114
+	Enum3476_ENUM_VALUE3592 Enum3476 = 115
+	Enum3476_ENUM_VALUE3593 Enum3476 = 116
+	Enum3476_ENUM_VALUE3594 Enum3476 = 117
+	Enum3476_ENUM_VALUE3595 Enum3476 = 118
+	Enum3476_ENUM_VALUE3596 Enum3476 = 119
+	Enum3476_ENUM_VALUE3597 Enum3476 = 120
+	Enum3476_ENUM_VALUE3598 Enum3476 = 121
+	Enum3476_ENUM_VALUE3599 Enum3476 = 122
+	Enum3476_ENUM_VALUE3600 Enum3476 = 123
+	Enum3476_ENUM_VALUE3601 Enum3476 = 124
+	Enum3476_ENUM_VALUE3602 Enum3476 = 125
+	Enum3476_ENUM_VALUE3603 Enum3476 = 126
+	Enum3476_ENUM_VALUE3604 Enum3476 = 127
+	Enum3476_ENUM_VALUE3605 Enum3476 = 128
+	Enum3476_ENUM_VALUE3606 Enum3476 = 129
+	Enum3476_ENUM_VALUE3607 Enum3476 = 130
+	Enum3476_ENUM_VALUE3608 Enum3476 = 131
+	Enum3476_ENUM_VALUE3609 Enum3476 = 132
+	Enum3476_ENUM_VALUE3610 Enum3476 = 133
+	Enum3476_ENUM_VALUE3611 Enum3476 = 134
+	Enum3476_ENUM_VALUE3612 Enum3476 = 135
+	Enum3476_ENUM_VALUE3613 Enum3476 = 136
+	Enum3476_ENUM_VALUE3614 Enum3476 = 137
+	Enum3476_ENUM_VALUE3615 Enum3476 = 138
+	Enum3476_ENUM_VALUE3616 Enum3476 = 139
+	Enum3476_ENUM_VALUE3617 Enum3476 = 140
+	Enum3476_ENUM_VALUE3618 Enum3476 = 141
+	Enum3476_ENUM_VALUE3619 Enum3476 = 142
+	Enum3476_ENUM_VALUE3620 Enum3476 = 143
+	Enum3476_ENUM_VALUE3621 Enum3476 = 144
+	Enum3476_ENUM_VALUE3622 Enum3476 = 145
+	Enum3476_ENUM_VALUE3623 Enum3476 = 146
+	Enum3476_ENUM_VALUE3624 Enum3476 = 147
+	Enum3476_ENUM_VALUE3625 Enum3476 = 148
+	Enum3476_ENUM_VALUE3626 Enum3476 = 149
+	Enum3476_ENUM_VALUE3627 Enum3476 = 150
+	Enum3476_ENUM_VALUE3628 Enum3476 = 151
+	Enum3476_ENUM_VALUE3629 Enum3476 = 152
+	Enum3476_ENUM_VALUE3630 Enum3476 = 153
+	Enum3476_ENUM_VALUE3631 Enum3476 = 154
+	Enum3476_ENUM_VALUE3632 Enum3476 = 155
+	Enum3476_ENUM_VALUE3633 Enum3476 = 156
+	Enum3476_ENUM_VALUE3634 Enum3476 = 157
+	Enum3476_ENUM_VALUE3635 Enum3476 = 158
+	Enum3476_ENUM_VALUE3636 Enum3476 = 159
+	Enum3476_ENUM_VALUE3637 Enum3476 = 160
+	Enum3476_ENUM_VALUE3638 Enum3476 = 161
+	Enum3476_ENUM_VALUE3639 Enum3476 = 162
+	Enum3476_ENUM_VALUE3640 Enum3476 = 163
+	Enum3476_ENUM_VALUE3641 Enum3476 = 164
+	Enum3476_ENUM_VALUE3642 Enum3476 = 165
+	Enum3476_ENUM_VALUE3643 Enum3476 = 166
+	Enum3476_ENUM_VALUE3644 Enum3476 = 167
+	Enum3476_ENUM_VALUE3645 Enum3476 = 168
+	Enum3476_ENUM_VALUE3646 Enum3476 = 169
+	Enum3476_ENUM_VALUE3647 Enum3476 = 170
+	Enum3476_ENUM_VALUE3648 Enum3476 = 171
+	Enum3476_ENUM_VALUE3649 Enum3476 = 172
+	Enum3476_ENUM_VALUE3650 Enum3476 = 173
+	Enum3476_ENUM_VALUE3651 Enum3476 = 174
+	Enum3476_ENUM_VALUE3652 Enum3476 = 175
+	Enum3476_ENUM_VALUE3653 Enum3476 = 176
+	Enum3476_ENUM_VALUE3654 Enum3476 = 177
+	Enum3476_ENUM_VALUE3655 Enum3476 = 178
+	Enum3476_ENUM_VALUE3656 Enum3476 = 179
+	Enum3476_ENUM_VALUE3657 Enum3476 = 180
+	Enum3476_ENUM_VALUE3658 Enum3476 = 181
+	Enum3476_ENUM_VALUE3659 Enum3476 = 182
+	Enum3476_ENUM_VALUE3660 Enum3476 = 183
+)
+
+// Enum value maps for Enum3476.
+var (
+	Enum3476_name = map[int32]string{
+		0:   "ENUM_VALUE3477",
+		1:   "ENUM_VALUE3478",
+		2:   "ENUM_VALUE3479",
+		3:   "ENUM_VALUE3480",
+		4:   "ENUM_VALUE3481",
+		5:   "ENUM_VALUE3482",
+		6:   "ENUM_VALUE3483",
+		7:   "ENUM_VALUE3484",
+		8:   "ENUM_VALUE3485",
+		9:   "ENUM_VALUE3486",
+		10:  "ENUM_VALUE3487",
+		11:  "ENUM_VALUE3488",
+		12:  "ENUM_VALUE3489",
+		13:  "ENUM_VALUE3490",
+		14:  "ENUM_VALUE3491",
+		15:  "ENUM_VALUE3492",
+		16:  "ENUM_VALUE3493",
+		17:  "ENUM_VALUE3494",
+		18:  "ENUM_VALUE3495",
+		19:  "ENUM_VALUE3496",
+		20:  "ENUM_VALUE3497",
+		21:  "ENUM_VALUE3498",
+		22:  "ENUM_VALUE3499",
+		23:  "ENUM_VALUE3500",
+		24:  "ENUM_VALUE3501",
+		25:  "ENUM_VALUE3502",
+		26:  "ENUM_VALUE3503",
+		27:  "ENUM_VALUE3504",
+		28:  "ENUM_VALUE3505",
+		29:  "ENUM_VALUE3506",
+		30:  "ENUM_VALUE3507",
+		31:  "ENUM_VALUE3508",
+		32:  "ENUM_VALUE3509",
+		33:  "ENUM_VALUE3510",
+		34:  "ENUM_VALUE3511",
+		35:  "ENUM_VALUE3512",
+		36:  "ENUM_VALUE3513",
+		37:  "ENUM_VALUE3514",
+		38:  "ENUM_VALUE3515",
+		39:  "ENUM_VALUE3516",
+		40:  "ENUM_VALUE3517",
+		41:  "ENUM_VALUE3518",
+		42:  "ENUM_VALUE3519",
+		43:  "ENUM_VALUE3520",
+		44:  "ENUM_VALUE3521",
+		45:  "ENUM_VALUE3522",
+		46:  "ENUM_VALUE3523",
+		47:  "ENUM_VALUE3524",
+		48:  "ENUM_VALUE3525",
+		49:  "ENUM_VALUE3526",
+		50:  "ENUM_VALUE3527",
+		51:  "ENUM_VALUE3528",
+		52:  "ENUM_VALUE3529",
+		53:  "ENUM_VALUE3530",
+		54:  "ENUM_VALUE3531",
+		55:  "ENUM_VALUE3532",
+		56:  "ENUM_VALUE3533",
+		57:  "ENUM_VALUE3534",
+		58:  "ENUM_VALUE3535",
+		59:  "ENUM_VALUE3536",
+		60:  "ENUM_VALUE3537",
+		61:  "ENUM_VALUE3538",
+		62:  "ENUM_VALUE3539",
+		63:  "ENUM_VALUE3540",
+		64:  "ENUM_VALUE3541",
+		65:  "ENUM_VALUE3542",
+		66:  "ENUM_VALUE3543",
+		67:  "ENUM_VALUE3544",
+		68:  "ENUM_VALUE3545",
+		69:  "ENUM_VALUE3546",
+		70:  "ENUM_VALUE3547",
+		71:  "ENUM_VALUE3548",
+		72:  "ENUM_VALUE3549",
+		73:  "ENUM_VALUE3550",
+		74:  "ENUM_VALUE3551",
+		75:  "ENUM_VALUE3552",
+		76:  "ENUM_VALUE3553",
+		77:  "ENUM_VALUE3554",
+		78:  "ENUM_VALUE3555",
+		79:  "ENUM_VALUE3556",
+		80:  "ENUM_VALUE3557",
+		81:  "ENUM_VALUE3558",
+		82:  "ENUM_VALUE3559",
+		83:  "ENUM_VALUE3560",
+		84:  "ENUM_VALUE3561",
+		85:  "ENUM_VALUE3562",
+		86:  "ENUM_VALUE3563",
+		87:  "ENUM_VALUE3564",
+		88:  "ENUM_VALUE3565",
+		89:  "ENUM_VALUE3566",
+		90:  "ENUM_VALUE3567",
+		91:  "ENUM_VALUE3568",
+		92:  "ENUM_VALUE3569",
+		93:  "ENUM_VALUE3570",
+		94:  "ENUM_VALUE3571",
+		95:  "ENUM_VALUE3572",
+		96:  "ENUM_VALUE3573",
+		97:  "ENUM_VALUE3574",
+		98:  "ENUM_VALUE3575",
+		99:  "ENUM_VALUE3576",
+		100: "ENUM_VALUE3577",
+		101: "ENUM_VALUE3578",
+		102: "ENUM_VALUE3579",
+		103: "ENUM_VALUE3580",
+		104: "ENUM_VALUE3581",
+		105: "ENUM_VALUE3582",
+		106: "ENUM_VALUE3583",
+		107: "ENUM_VALUE3584",
+		108: "ENUM_VALUE3585",
+		109: "ENUM_VALUE3586",
+		110: "ENUM_VALUE3587",
+		111: "ENUM_VALUE3588",
+		112: "ENUM_VALUE3589",
+		113: "ENUM_VALUE3590",
+		114: "ENUM_VALUE3591",
+		115: "ENUM_VALUE3592",
+		116: "ENUM_VALUE3593",
+		117: "ENUM_VALUE3594",
+		118: "ENUM_VALUE3595",
+		119: "ENUM_VALUE3596",
+		120: "ENUM_VALUE3597",
+		121: "ENUM_VALUE3598",
+		122: "ENUM_VALUE3599",
+		123: "ENUM_VALUE3600",
+		124: "ENUM_VALUE3601",
+		125: "ENUM_VALUE3602",
+		126: "ENUM_VALUE3603",
+		127: "ENUM_VALUE3604",
+		128: "ENUM_VALUE3605",
+		129: "ENUM_VALUE3606",
+		130: "ENUM_VALUE3607",
+		131: "ENUM_VALUE3608",
+		132: "ENUM_VALUE3609",
+		133: "ENUM_VALUE3610",
+		134: "ENUM_VALUE3611",
+		135: "ENUM_VALUE3612",
+		136: "ENUM_VALUE3613",
+		137: "ENUM_VALUE3614",
+		138: "ENUM_VALUE3615",
+		139: "ENUM_VALUE3616",
+		140: "ENUM_VALUE3617",
+		141: "ENUM_VALUE3618",
+		142: "ENUM_VALUE3619",
+		143: "ENUM_VALUE3620",
+		144: "ENUM_VALUE3621",
+		145: "ENUM_VALUE3622",
+		146: "ENUM_VALUE3623",
+		147: "ENUM_VALUE3624",
+		148: "ENUM_VALUE3625",
+		149: "ENUM_VALUE3626",
+		150: "ENUM_VALUE3627",
+		151: "ENUM_VALUE3628",
+		152: "ENUM_VALUE3629",
+		153: "ENUM_VALUE3630",
+		154: "ENUM_VALUE3631",
+		155: "ENUM_VALUE3632",
+		156: "ENUM_VALUE3633",
+		157: "ENUM_VALUE3634",
+		158: "ENUM_VALUE3635",
+		159: "ENUM_VALUE3636",
+		160: "ENUM_VALUE3637",
+		161: "ENUM_VALUE3638",
+		162: "ENUM_VALUE3639",
+		163: "ENUM_VALUE3640",
+		164: "ENUM_VALUE3641",
+		165: "ENUM_VALUE3642",
+		166: "ENUM_VALUE3643",
+		167: "ENUM_VALUE3644",
+		168: "ENUM_VALUE3645",
+		169: "ENUM_VALUE3646",
+		170: "ENUM_VALUE3647",
+		171: "ENUM_VALUE3648",
+		172: "ENUM_VALUE3649",
+		173: "ENUM_VALUE3650",
+		174: "ENUM_VALUE3651",
+		175: "ENUM_VALUE3652",
+		176: "ENUM_VALUE3653",
+		177: "ENUM_VALUE3654",
+		178: "ENUM_VALUE3655",
+		179: "ENUM_VALUE3656",
+		180: "ENUM_VALUE3657",
+		181: "ENUM_VALUE3658",
+		182: "ENUM_VALUE3659",
+		183: "ENUM_VALUE3660",
+	}
+	Enum3476_value = map[string]int32{
+		"ENUM_VALUE3477": 0,
+		"ENUM_VALUE3478": 1,
+		"ENUM_VALUE3479": 2,
+		"ENUM_VALUE3480": 3,
+		"ENUM_VALUE3481": 4,
+		"ENUM_VALUE3482": 5,
+		"ENUM_VALUE3483": 6,
+		"ENUM_VALUE3484": 7,
+		"ENUM_VALUE3485": 8,
+		"ENUM_VALUE3486": 9,
+		"ENUM_VALUE3487": 10,
+		"ENUM_VALUE3488": 11,
+		"ENUM_VALUE3489": 12,
+		"ENUM_VALUE3490": 13,
+		"ENUM_VALUE3491": 14,
+		"ENUM_VALUE3492": 15,
+		"ENUM_VALUE3493": 16,
+		"ENUM_VALUE3494": 17,
+		"ENUM_VALUE3495": 18,
+		"ENUM_VALUE3496": 19,
+		"ENUM_VALUE3497": 20,
+		"ENUM_VALUE3498": 21,
+		"ENUM_VALUE3499": 22,
+		"ENUM_VALUE3500": 23,
+		"ENUM_VALUE3501": 24,
+		"ENUM_VALUE3502": 25,
+		"ENUM_VALUE3503": 26,
+		"ENUM_VALUE3504": 27,
+		"ENUM_VALUE3505": 28,
+		"ENUM_VALUE3506": 29,
+		"ENUM_VALUE3507": 30,
+		"ENUM_VALUE3508": 31,
+		"ENUM_VALUE3509": 32,
+		"ENUM_VALUE3510": 33,
+		"ENUM_VALUE3511": 34,
+		"ENUM_VALUE3512": 35,
+		"ENUM_VALUE3513": 36,
+		"ENUM_VALUE3514": 37,
+		"ENUM_VALUE3515": 38,
+		"ENUM_VALUE3516": 39,
+		"ENUM_VALUE3517": 40,
+		"ENUM_VALUE3518": 41,
+		"ENUM_VALUE3519": 42,
+		"ENUM_VALUE3520": 43,
+		"ENUM_VALUE3521": 44,
+		"ENUM_VALUE3522": 45,
+		"ENUM_VALUE3523": 46,
+		"ENUM_VALUE3524": 47,
+		"ENUM_VALUE3525": 48,
+		"ENUM_VALUE3526": 49,
+		"ENUM_VALUE3527": 50,
+		"ENUM_VALUE3528": 51,
+		"ENUM_VALUE3529": 52,
+		"ENUM_VALUE3530": 53,
+		"ENUM_VALUE3531": 54,
+		"ENUM_VALUE3532": 55,
+		"ENUM_VALUE3533": 56,
+		"ENUM_VALUE3534": 57,
+		"ENUM_VALUE3535": 58,
+		"ENUM_VALUE3536": 59,
+		"ENUM_VALUE3537": 60,
+		"ENUM_VALUE3538": 61,
+		"ENUM_VALUE3539": 62,
+		"ENUM_VALUE3540": 63,
+		"ENUM_VALUE3541": 64,
+		"ENUM_VALUE3542": 65,
+		"ENUM_VALUE3543": 66,
+		"ENUM_VALUE3544": 67,
+		"ENUM_VALUE3545": 68,
+		"ENUM_VALUE3546": 69,
+		"ENUM_VALUE3547": 70,
+		"ENUM_VALUE3548": 71,
+		"ENUM_VALUE3549": 72,
+		"ENUM_VALUE3550": 73,
+		"ENUM_VALUE3551": 74,
+		"ENUM_VALUE3552": 75,
+		"ENUM_VALUE3553": 76,
+		"ENUM_VALUE3554": 77,
+		"ENUM_VALUE3555": 78,
+		"ENUM_VALUE3556": 79,
+		"ENUM_VALUE3557": 80,
+		"ENUM_VALUE3558": 81,
+		"ENUM_VALUE3559": 82,
+		"ENUM_VALUE3560": 83,
+		"ENUM_VALUE3561": 84,
+		"ENUM_VALUE3562": 85,
+		"ENUM_VALUE3563": 86,
+		"ENUM_VALUE3564": 87,
+		"ENUM_VALUE3565": 88,
+		"ENUM_VALUE3566": 89,
+		"ENUM_VALUE3567": 90,
+		"ENUM_VALUE3568": 91,
+		"ENUM_VALUE3569": 92,
+		"ENUM_VALUE3570": 93,
+		"ENUM_VALUE3571": 94,
+		"ENUM_VALUE3572": 95,
+		"ENUM_VALUE3573": 96,
+		"ENUM_VALUE3574": 97,
+		"ENUM_VALUE3575": 98,
+		"ENUM_VALUE3576": 99,
+		"ENUM_VALUE3577": 100,
+		"ENUM_VALUE3578": 101,
+		"ENUM_VALUE3579": 102,
+		"ENUM_VALUE3580": 103,
+		"ENUM_VALUE3581": 104,
+		"ENUM_VALUE3582": 105,
+		"ENUM_VALUE3583": 106,
+		"ENUM_VALUE3584": 107,
+		"ENUM_VALUE3585": 108,
+		"ENUM_VALUE3586": 109,
+		"ENUM_VALUE3587": 110,
+		"ENUM_VALUE3588": 111,
+		"ENUM_VALUE3589": 112,
+		"ENUM_VALUE3590": 113,
+		"ENUM_VALUE3591": 114,
+		"ENUM_VALUE3592": 115,
+		"ENUM_VALUE3593": 116,
+		"ENUM_VALUE3594": 117,
+		"ENUM_VALUE3595": 118,
+		"ENUM_VALUE3596": 119,
+		"ENUM_VALUE3597": 120,
+		"ENUM_VALUE3598": 121,
+		"ENUM_VALUE3599": 122,
+		"ENUM_VALUE3600": 123,
+		"ENUM_VALUE3601": 124,
+		"ENUM_VALUE3602": 125,
+		"ENUM_VALUE3603": 126,
+		"ENUM_VALUE3604": 127,
+		"ENUM_VALUE3605": 128,
+		"ENUM_VALUE3606": 129,
+		"ENUM_VALUE3607": 130,
+		"ENUM_VALUE3608": 131,
+		"ENUM_VALUE3609": 132,
+		"ENUM_VALUE3610": 133,
+		"ENUM_VALUE3611": 134,
+		"ENUM_VALUE3612": 135,
+		"ENUM_VALUE3613": 136,
+		"ENUM_VALUE3614": 137,
+		"ENUM_VALUE3615": 138,
+		"ENUM_VALUE3616": 139,
+		"ENUM_VALUE3617": 140,
+		"ENUM_VALUE3618": 141,
+		"ENUM_VALUE3619": 142,
+		"ENUM_VALUE3620": 143,
+		"ENUM_VALUE3621": 144,
+		"ENUM_VALUE3622": 145,
+		"ENUM_VALUE3623": 146,
+		"ENUM_VALUE3624": 147,
+		"ENUM_VALUE3625": 148,
+		"ENUM_VALUE3626": 149,
+		"ENUM_VALUE3627": 150,
+		"ENUM_VALUE3628": 151,
+		"ENUM_VALUE3629": 152,
+		"ENUM_VALUE3630": 153,
+		"ENUM_VALUE3631": 154,
+		"ENUM_VALUE3632": 155,
+		"ENUM_VALUE3633": 156,
+		"ENUM_VALUE3634": 157,
+		"ENUM_VALUE3635": 158,
+		"ENUM_VALUE3636": 159,
+		"ENUM_VALUE3637": 160,
+		"ENUM_VALUE3638": 161,
+		"ENUM_VALUE3639": 162,
+		"ENUM_VALUE3640": 163,
+		"ENUM_VALUE3641": 164,
+		"ENUM_VALUE3642": 165,
+		"ENUM_VALUE3643": 166,
+		"ENUM_VALUE3644": 167,
+		"ENUM_VALUE3645": 168,
+		"ENUM_VALUE3646": 169,
+		"ENUM_VALUE3647": 170,
+		"ENUM_VALUE3648": 171,
+		"ENUM_VALUE3649": 172,
+		"ENUM_VALUE3650": 173,
+		"ENUM_VALUE3651": 174,
+		"ENUM_VALUE3652": 175,
+		"ENUM_VALUE3653": 176,
+		"ENUM_VALUE3654": 177,
+		"ENUM_VALUE3655": 178,
+		"ENUM_VALUE3656": 179,
+		"ENUM_VALUE3657": 180,
+		"ENUM_VALUE3658": 181,
+		"ENUM_VALUE3659": 182,
+		"ENUM_VALUE3660": 183,
+	}
+)
+
+func (x Enum3476) Enum() *Enum3476 {
+	p := new(Enum3476)
+	*p = x
+	return p
+}
+
+func (x Enum3476) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum3476) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[35].Descriptor()
+}
+
+func (Enum3476) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[35]
+}
+
+func (x Enum3476) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum3476) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum3476(num)
+	return nil
+}
+
+// Deprecated: Use Enum3476.Descriptor instead.
+func (Enum3476) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{35}
+}
+
+type Enum10325 int32
+
+const (
+	Enum10325_ENUM_VALUE10326 Enum10325 = 0
+	Enum10325_ENUM_VALUE10327 Enum10325 = 1
+	Enum10325_ENUM_VALUE10328 Enum10325 = 2
+	Enum10325_ENUM_VALUE10329 Enum10325 = 3
+	Enum10325_ENUM_VALUE10330 Enum10325 = 4
+	Enum10325_ENUM_VALUE10331 Enum10325 = 5
+	Enum10325_ENUM_VALUE10332 Enum10325 = 6
+	Enum10325_ENUM_VALUE10333 Enum10325 = 7
+	Enum10325_ENUM_VALUE10334 Enum10325 = 8
+)
+
+// Enum value maps for Enum10325.
+var (
+	Enum10325_name = map[int32]string{
+		0: "ENUM_VALUE10326",
+		1: "ENUM_VALUE10327",
+		2: "ENUM_VALUE10328",
+		3: "ENUM_VALUE10329",
+		4: "ENUM_VALUE10330",
+		5: "ENUM_VALUE10331",
+		6: "ENUM_VALUE10332",
+		7: "ENUM_VALUE10333",
+		8: "ENUM_VALUE10334",
+	}
+	Enum10325_value = map[string]int32{
+		"ENUM_VALUE10326": 0,
+		"ENUM_VALUE10327": 1,
+		"ENUM_VALUE10328": 2,
+		"ENUM_VALUE10329": 3,
+		"ENUM_VALUE10330": 4,
+		"ENUM_VALUE10331": 5,
+		"ENUM_VALUE10332": 6,
+		"ENUM_VALUE10333": 7,
+		"ENUM_VALUE10334": 8,
+	}
+)
+
+func (x Enum10325) Enum() *Enum10325 {
+	p := new(Enum10325)
+	*p = x
+	return p
+}
+
+func (x Enum10325) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum10325) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[36].Descriptor()
+}
+
+func (Enum10325) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[36]
+}
+
+func (x Enum10325) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum10325) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum10325(num)
+	return nil
+}
+
+// Deprecated: Use Enum10325.Descriptor instead.
+func (Enum10325) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{36}
+}
+
+type Enum10335 int32
+
+const (
+	Enum10335_ENUM_VALUE10336 Enum10335 = 0
+)
+
+// Enum value maps for Enum10335.
+var (
+	Enum10335_name = map[int32]string{
+		0: "ENUM_VALUE10336",
+	}
+	Enum10335_value = map[string]int32{
+		"ENUM_VALUE10336": 0,
+	}
+)
+
+func (x Enum10335) Enum() *Enum10335 {
+	p := new(Enum10335)
+	*p = x
+	return p
+}
+
+func (x Enum10335) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum10335) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[37].Descriptor()
+}
+
+func (Enum10335) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[37]
+}
+
+func (x Enum10335) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum10335) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum10335(num)
+	return nil
+}
+
+// Deprecated: Use Enum10335.Descriptor instead.
+func (Enum10335) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{37}
+}
+
+type Enum10337 int32
+
+const (
+	Enum10337_ENUM_VALUE10338 Enum10337 = 0
+	Enum10337_ENUM_VALUE10339 Enum10337 = 1
+)
+
+// Enum value maps for Enum10337.
+var (
+	Enum10337_name = map[int32]string{
+		0: "ENUM_VALUE10338",
+		1: "ENUM_VALUE10339",
+	}
+	Enum10337_value = map[string]int32{
+		"ENUM_VALUE10338": 0,
+		"ENUM_VALUE10339": 1,
+	}
+)
+
+func (x Enum10337) Enum() *Enum10337 {
+	p := new(Enum10337)
+	*p = x
+	return p
+}
+
+func (x Enum10337) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum10337) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[38].Descriptor()
+}
+
+func (Enum10337) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[38]
+}
+
+func (x Enum10337) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum10337) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum10337(num)
+	return nil
+}
+
+// Deprecated: Use Enum10337.Descriptor instead.
+func (Enum10337) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{38}
+}
+
+type Enum11901 int32
+
+const (
+	Enum11901_ENUM_VALUE11902 Enum11901 = 0
+	Enum11901_ENUM_VALUE11903 Enum11901 = 1
+	Enum11901_ENUM_VALUE11904 Enum11901 = 2
+	Enum11901_ENUM_VALUE11905 Enum11901 = 3
+)
+
+// Enum value maps for Enum11901.
+var (
+	Enum11901_name = map[int32]string{
+		0: "ENUM_VALUE11902",
+		1: "ENUM_VALUE11903",
+		2: "ENUM_VALUE11904",
+		3: "ENUM_VALUE11905",
+	}
+	Enum11901_value = map[string]int32{
+		"ENUM_VALUE11902": 0,
+		"ENUM_VALUE11903": 1,
+		"ENUM_VALUE11904": 2,
+		"ENUM_VALUE11905": 3,
+	}
+)
+
+func (x Enum11901) Enum() *Enum11901 {
+	p := new(Enum11901)
+	*p = x
+	return p
+}
+
+func (x Enum11901) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum11901) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[39].Descriptor()
+}
+
+func (Enum11901) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[39]
+}
+
+func (x Enum11901) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum11901) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum11901(num)
+	return nil
+}
+
+// Deprecated: Use Enum11901.Descriptor instead.
+func (Enum11901) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{39}
+}
+
+type Enum12735 int32
+
+const (
+	Enum12735_ENUM_VALUE12736 Enum12735 = 0
+	Enum12735_ENUM_VALUE12737 Enum12735 = 1
+	Enum12735_ENUM_VALUE12738 Enum12735 = 2
+	Enum12735_ENUM_VALUE12739 Enum12735 = 3
+)
+
+// Enum value maps for Enum12735.
+var (
+	Enum12735_name = map[int32]string{
+		0: "ENUM_VALUE12736",
+		1: "ENUM_VALUE12737",
+		2: "ENUM_VALUE12738",
+		3: "ENUM_VALUE12739",
+	}
+	Enum12735_value = map[string]int32{
+		"ENUM_VALUE12736": 0,
+		"ENUM_VALUE12737": 1,
+		"ENUM_VALUE12738": 2,
+		"ENUM_VALUE12739": 3,
+	}
+)
+
+func (x Enum12735) Enum() *Enum12735 {
+	p := new(Enum12735)
+	*p = x
+	return p
+}
+
+func (x Enum12735) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum12735) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[40].Descriptor()
+}
+
+func (Enum12735) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[40]
+}
+
+func (x Enum12735) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum12735) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum12735(num)
+	return nil
+}
+
+// Deprecated: Use Enum12735.Descriptor instead.
+func (Enum12735) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{40}
+}
+
+type Enum12871 int32
+
+const (
+	Enum12871_ENUM_VALUE12872 Enum12871 = 1
+	Enum12871_ENUM_VALUE12873 Enum12871 = 2
+	Enum12871_ENUM_VALUE12874 Enum12871 = 3
+	Enum12871_ENUM_VALUE12875 Enum12871 = 4
+	Enum12871_ENUM_VALUE12876 Enum12871 = 5
+	Enum12871_ENUM_VALUE12877 Enum12871 = 6
+)
+
+// Enum value maps for Enum12871.
+var (
+	Enum12871_name = map[int32]string{
+		1: "ENUM_VALUE12872",
+		2: "ENUM_VALUE12873",
+		3: "ENUM_VALUE12874",
+		4: "ENUM_VALUE12875",
+		5: "ENUM_VALUE12876",
+		6: "ENUM_VALUE12877",
+	}
+	Enum12871_value = map[string]int32{
+		"ENUM_VALUE12872": 1,
+		"ENUM_VALUE12873": 2,
+		"ENUM_VALUE12874": 3,
+		"ENUM_VALUE12875": 4,
+		"ENUM_VALUE12876": 5,
+		"ENUM_VALUE12877": 6,
+	}
+)
+
+func (x Enum12871) Enum() *Enum12871 {
+	p := new(Enum12871)
+	*p = x
+	return p
+}
+
+func (x Enum12871) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum12871) Descriptor() protoreflect.EnumDescriptor {
+	return file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[41].Descriptor()
+}
+
+func (Enum12871) Type() protoreflect.EnumType {
+	return &file_datasets_google_message4_benchmark_message4_3_proto_enumTypes[41]
+}
+
+func (x Enum12871) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum12871) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum12871(num)
+	return nil
+}
+
+// Deprecated: Use Enum12871.Descriptor instead.
+func (Enum12871) EnumDescriptor() ([]byte, []int) {
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP(), []int{41}
+}
+
+var File_datasets_google_message4_benchmark_message4_3_proto protoreflect.FileDescriptor
+
+var file_datasets_google_message4_benchmark_message4_3_proto_rawDesc = []byte{
+	0x0a, 0x33, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68,
+	0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34, 0x5f, 0x33, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1a, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b,
+	0x73, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x34, 0x2a, 0x3c, 0x0a, 0x0a, 0x55, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x12,
+	0x16, 0x0a, 0x12, 0x55, 0x4e, 0x55, 0x53, 0x45, 0x44, 0x5f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x10, 0x00, 0x12, 0x16, 0x0a, 0x12, 0x55, 0x4e, 0x55, 0x53, 0x45,
+	0x44, 0x5f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x10, 0x01, 0x2a,
+	0xaa, 0x01, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x32, 0x35, 0x39, 0x33, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x35, 0x39, 0x34, 0x10, 0x00,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x35,
+	0x39, 0x35, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x32, 0x35, 0x39, 0x36, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x35, 0x39, 0x37, 0x10, 0x03, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x35, 0x39, 0x38, 0x10, 0x04,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x35,
+	0x39, 0x39, 0x10, 0x05, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x32, 0x36, 0x30, 0x30, 0x10, 0x06, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x36, 0x30, 0x31, 0x10, 0x07, 0x2a, 0x46, 0x0a, 0x08,
+	0x45, 0x6e, 0x75, 0x6d, 0x32, 0x38, 0x33, 0x34, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x33, 0x35, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x33, 0x36, 0x10, 0x01,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x38,
+	0x33, 0x37, 0x10, 0x02, 0x2a, 0xb6, 0x02, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x32, 0x38, 0x30,
+	0x36, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32,
+	0x38, 0x30, 0x37, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x32, 0x38, 0x30, 0x38, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x30, 0x39, 0x10, 0x02, 0x12, 0x12, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x31, 0x30, 0x10,
+	0x03, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32,
+	0x38, 0x31, 0x31, 0x10, 0x04, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x32, 0x38, 0x31, 0x32, 0x10, 0x05, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x31, 0x33, 0x10, 0x06, 0x12, 0x12, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x31, 0x34, 0x10,
+	0x07, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32,
+	0x38, 0x31, 0x35, 0x10, 0x08, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x32, 0x38, 0x31, 0x36, 0x10, 0x09, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x31, 0x37, 0x10, 0x0a, 0x12, 0x12, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x31, 0x38, 0x10,
+	0x0b, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32,
+	0x38, 0x31, 0x39, 0x10, 0x0c, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x32, 0x38, 0x32, 0x30, 0x10, 0x0d, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x32, 0x31, 0x10, 0x0e, 0x2a, 0x82, 0x13,
+	0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x32, 0x38, 0x35, 0x31, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x35, 0x32, 0x10, 0x00, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x35, 0x33,
+	0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x32, 0x38, 0x35, 0x34, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x35, 0x35, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x35, 0x36, 0x10, 0x03, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x35, 0x37,
+	0x10, 0x04, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x32, 0x38, 0x35, 0x38, 0x10, 0x05, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x35, 0x39, 0x10, 0x06, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x36, 0x30, 0x10, 0x07, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x36, 0x31,
+	0x10, 0x08, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x32, 0x38, 0x36, 0x32, 0x10, 0x09, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x36, 0x33, 0x10, 0x0a, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x36, 0x34, 0x10, 0x0b, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x36, 0x35,
+	0x10, 0x0c, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x32, 0x38, 0x36, 0x36, 0x10, 0x0d, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x36, 0x37, 0x10, 0x0e, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x36, 0x38, 0x10, 0x0f, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x36, 0x39,
+	0x10, 0x10, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x32, 0x38, 0x37, 0x30, 0x10, 0x11, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x37, 0x31, 0x10, 0x12, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x37, 0x32, 0x10, 0x13, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x37, 0x33,
+	0x10, 0x14, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x32, 0x38, 0x37, 0x34, 0x10, 0x15, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x37, 0x35, 0x10, 0x16, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x37, 0x36, 0x10, 0x17, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x37, 0x37,
+	0x10, 0x18, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x32, 0x38, 0x37, 0x38, 0x10, 0x19, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x37, 0x39, 0x10, 0x1a, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x38, 0x30, 0x10, 0x1b, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x38, 0x31,
+	0x10, 0x1c, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x32, 0x38, 0x38, 0x32, 0x10, 0x1d, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x38, 0x33, 0x10, 0x1e, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x38, 0x34, 0x10, 0x1f, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x38, 0x35,
+	0x10, 0x20, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x32, 0x38, 0x38, 0x36, 0x10, 0x21, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x38, 0x37, 0x10, 0x22, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x38, 0x38, 0x10, 0x23, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x38, 0x39,
+	0x10, 0x24, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x32, 0x38, 0x39, 0x30, 0x10, 0x25, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x39, 0x31, 0x10, 0x26, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x39, 0x32, 0x10, 0x27, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x39, 0x33,
+	0x10, 0x28, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x32, 0x38, 0x39, 0x34, 0x10, 0x29, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x39, 0x35, 0x10, 0x2a, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x39, 0x36, 0x10, 0x2b, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x39, 0x37,
+	0x10, 0x2c, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x32, 0x38, 0x39, 0x38, 0x10, 0x2d, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x32, 0x38, 0x39, 0x39, 0x10, 0x2e, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x30, 0x30, 0x10, 0x2f, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x30, 0x31,
+	0x10, 0x30, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x32, 0x39, 0x30, 0x32, 0x10, 0x31, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x30, 0x33, 0x10, 0x32, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x30, 0x34, 0x10, 0x33, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x30, 0x35,
+	0x10, 0x34, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x32, 0x39, 0x30, 0x36, 0x10, 0x35, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x30, 0x37, 0x10, 0x36, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x30, 0x38, 0x10, 0x37, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x30, 0x39,
+	0x10, 0x38, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x32, 0x39, 0x31, 0x30, 0x10, 0x39, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x31, 0x31, 0x10, 0x3a, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x31, 0x32, 0x10, 0x3b, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x31, 0x33,
+	0x10, 0x3c, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x32, 0x39, 0x31, 0x34, 0x10, 0x3d, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x31, 0x35, 0x10, 0x3e, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x31, 0x36, 0x10, 0x3f, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x31, 0x37,
+	0x10, 0x40, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x32, 0x39, 0x31, 0x38, 0x10, 0x41, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x31, 0x39, 0x10, 0x42, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x32, 0x30, 0x10, 0x43, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x32, 0x31,
+	0x10, 0x44, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x32, 0x39, 0x32, 0x32, 0x10, 0x45, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x32, 0x33, 0x10, 0x46, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x32, 0x34, 0x10, 0x47, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x32, 0x35,
+	0x10, 0x48, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x32, 0x39, 0x32, 0x36, 0x10, 0x49, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x32, 0x37, 0x10, 0x4a, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x32, 0x38, 0x10, 0x4b, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x32, 0x39,
+	0x10, 0x4c, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x32, 0x39, 0x33, 0x30, 0x10, 0x4d, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x33, 0x31, 0x10, 0x4e, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x33, 0x32, 0x10, 0x4f, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x33, 0x33,
+	0x10, 0x50, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x32, 0x39, 0x33, 0x34, 0x10, 0x51, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x33, 0x35, 0x10, 0x52, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x33, 0x36, 0x10, 0x53, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x33, 0x37,
+	0x10, 0x54, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x32, 0x39, 0x33, 0x38, 0x10, 0x55, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x33, 0x39, 0x10, 0x56, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x34, 0x30, 0x10, 0x57, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x34, 0x31,
+	0x10, 0x58, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x32, 0x39, 0x34, 0x32, 0x10, 0x59, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x34, 0x33, 0x10, 0x5a, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x34, 0x34, 0x10, 0x5b, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x34, 0x35,
+	0x10, 0x5c, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x32, 0x39, 0x34, 0x36, 0x10, 0x5d, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x34, 0x37, 0x10, 0x5e, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x34, 0x38, 0x10, 0x5f, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x34, 0x39,
+	0x10, 0x60, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x32, 0x39, 0x35, 0x30, 0x10, 0x61, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x35, 0x31, 0x10, 0x62, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x35, 0x32, 0x10, 0x63, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x35, 0x33,
+	0x10, 0x64, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x32, 0x39, 0x35, 0x34, 0x10, 0x65, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x35, 0x35, 0x10, 0x66, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x35, 0x36, 0x10, 0x67, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x35, 0x37,
+	0x10, 0x68, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x32, 0x39, 0x35, 0x38, 0x10, 0x69, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x35, 0x39, 0x10, 0x6a, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x36, 0x30, 0x10, 0x6b, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x36, 0x31,
+	0x10, 0x6c, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x32, 0x39, 0x36, 0x32, 0x10, 0x6d, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x36, 0x33, 0x10, 0x6e, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x36, 0x34, 0x10, 0x6f, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x36, 0x35,
+	0x10, 0x70, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x32, 0x39, 0x36, 0x36, 0x10, 0x71, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x36, 0x37, 0x10, 0x72, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x36, 0x38, 0x10, 0x73, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x36, 0x39,
+	0x10, 0x74, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x32, 0x39, 0x37, 0x30, 0x10, 0x75, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x37, 0x31, 0x10, 0x76, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x39, 0x37, 0x32, 0x10, 0x77, 0x1a, 0x02,
+	0x10, 0x01, 0x2a, 0xfa, 0x01, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x32, 0x36, 0x30, 0x32, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x36, 0x30,
+	0x33, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x32, 0x36, 0x30, 0x34, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x36, 0x30, 0x35, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x36, 0x30, 0x36, 0x10, 0x03, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x36, 0x30,
+	0x37, 0x10, 0x04, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x32, 0x36, 0x30, 0x38, 0x10, 0x05, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x36, 0x30, 0x39, 0x10, 0x06, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x36, 0x31, 0x30, 0x10, 0x07, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x36, 0x31,
+	0x31, 0x10, 0x08, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x32, 0x36, 0x31, 0x32, 0x10, 0x09, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x36, 0x31, 0x33, 0x10, 0x0a, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x32, 0x36, 0x31, 0x34, 0x10, 0x0b, 0x2a,
+	0xba, 0x04, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x33, 0x30, 0x37, 0x31, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x30, 0x37, 0x32, 0x10, 0x01,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x30,
+	0x37, 0x33, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x30, 0x37, 0x34, 0x10, 0x03, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x30, 0x37, 0x35, 0x10, 0x04, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x30, 0x37, 0x36, 0x10, 0x05,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x30,
+	0x37, 0x37, 0x10, 0x06, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x30, 0x37, 0x38, 0x10, 0x07, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x30, 0x37, 0x39, 0x10, 0x08, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x30, 0x38, 0x30, 0x10, 0x09,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x30,
+	0x38, 0x31, 0x10, 0x0a, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x30, 0x38, 0x32, 0x10, 0x0b, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x30, 0x38, 0x33, 0x10, 0x0c, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x30, 0x38, 0x34, 0x10, 0x0d,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x30,
+	0x38, 0x35, 0x10, 0x0e, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x30, 0x38, 0x36, 0x10, 0x0f, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x30, 0x38, 0x37, 0x10, 0x10, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x30, 0x38, 0x38, 0x10, 0x11,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x30,
+	0x38, 0x39, 0x10, 0x12, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x30, 0x39, 0x30, 0x10, 0x13, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x30, 0x39, 0x31, 0x10, 0x14, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x30, 0x39, 0x32, 0x10, 0x15,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x30,
+	0x39, 0x33, 0x10, 0x16, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x30, 0x39, 0x34, 0x10, 0x17, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x30, 0x39, 0x35, 0x10, 0x18, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x30, 0x39, 0x36, 0x10, 0x19,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x30,
+	0x39, 0x37, 0x10, 0x1a, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x30, 0x39, 0x38, 0x10, 0x1b, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x30, 0x39, 0x39, 0x10, 0x1c, 0x2a, 0xfa, 0x01, 0x0a,
+	0x08, 0x45, 0x6e, 0x75, 0x6d, 0x33, 0x38, 0x30, 0x35, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x30, 0x36, 0x10, 0x00, 0x12, 0x12, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x30, 0x37, 0x10,
+	0x01, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33,
+	0x38, 0x30, 0x38, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x33, 0x38, 0x30, 0x39, 0x10, 0x03, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x31, 0x30, 0x10, 0x04, 0x12, 0x12, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x31, 0x31, 0x10,
+	0x05, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33,
+	0x38, 0x31, 0x32, 0x10, 0x06, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x33, 0x38, 0x31, 0x33, 0x10, 0x07, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x31, 0x34, 0x10, 0x08, 0x12, 0x12, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x31, 0x35, 0x10,
+	0x09, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33,
+	0x38, 0x31, 0x36, 0x10, 0x0b, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x33, 0x38, 0x31, 0x37, 0x10, 0x0a, 0x2a, 0x9a, 0x03, 0x0a, 0x08, 0x45, 0x6e,
+	0x75, 0x6d, 0x33, 0x37, 0x38, 0x33, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x33, 0x37, 0x38, 0x34, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x37, 0x38, 0x35, 0x10, 0x01, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x37, 0x38, 0x36,
+	0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x33, 0x37, 0x38, 0x37, 0x10, 0x03, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x33, 0x37, 0x38, 0x38, 0x10, 0x04, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x37, 0x38, 0x39, 0x10, 0x05, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x37, 0x39, 0x30,
+	0x10, 0x06, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x33, 0x37, 0x39, 0x31, 0x10, 0x07, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x33, 0x37, 0x39, 0x32, 0x10, 0x08, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x37, 0x39, 0x33, 0x10, 0x09, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x37, 0x39, 0x34,
+	0x10, 0x0a, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x33, 0x37, 0x39, 0x35, 0x10, 0x0b, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x33, 0x37, 0x39, 0x36, 0x10, 0x0c, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x37, 0x39, 0x37, 0x10, 0x0d, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x37, 0x39, 0x38,
+	0x10, 0x0e, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x33, 0x37, 0x39, 0x39, 0x10, 0x0f, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x30, 0x30, 0x10, 0x10, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x30, 0x31, 0x10, 0x14, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x30, 0x32,
+	0x10, 0x15, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x33, 0x38, 0x30, 0x33, 0x10, 0x32, 0x2a, 0xf2, 0x02, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x33,
+	0x38, 0x35, 0x31, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x38, 0x35, 0x32, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x35, 0x33, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x35, 0x34, 0x10, 0x02, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x35,
+	0x35, 0x10, 0x03, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x38, 0x35, 0x36, 0x10, 0x04, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x35, 0x37, 0x10, 0x05, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x35, 0x38, 0x10, 0x06, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x35,
+	0x39, 0x10, 0x07, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x38, 0x36, 0x30, 0x10, 0x08, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x36, 0x31, 0x10, 0x09, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x36, 0x32, 0x10, 0x0a, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x36,
+	0x33, 0x10, 0x0b, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x38, 0x36, 0x34, 0x10, 0x0c, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x36, 0x35, 0x10, 0x0d, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x36, 0x36, 0x10, 0x0e, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x36,
+	0x37, 0x10, 0x0f, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x38, 0x36, 0x38, 0x10, 0x10, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x38, 0x36, 0x39, 0x10, 0x11, 0x2a, 0x46, 0x0a, 0x08, 0x45,
+	0x6e, 0x75, 0x6d, 0x35, 0x38, 0x36, 0x32, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x38, 0x36, 0x33, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x38, 0x36, 0x34, 0x10, 0x02, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x38, 0x36,
+	0x35, 0x10, 0x03, 0x2a, 0x5a, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x35, 0x38, 0x36, 0x38, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x38, 0x36,
+	0x39, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x35, 0x38, 0x37, 0x30, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x38, 0x37, 0x31, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x38, 0x37, 0x32, 0x10, 0x03, 0x2a,
+	0x46, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x35, 0x38, 0x37, 0x33, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x38, 0x37, 0x34, 0x10, 0x00, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x38, 0x37,
+	0x35, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x35, 0x38, 0x37, 0x36, 0x10, 0x02, 0x2a, 0x32, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x35,
+	0x39, 0x30, 0x34, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x35, 0x39, 0x30, 0x35, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x39, 0x30, 0x36, 0x10, 0x01, 0x2a, 0x32, 0x0a, 0x08, 0x45,
+	0x6e, 0x75, 0x6d, 0x35, 0x39, 0x30, 0x39, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x39, 0x31, 0x30, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x39, 0x31, 0x31, 0x10, 0x01, 0x2a,
+	0x32, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x35, 0x39, 0x31, 0x32, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x39, 0x31, 0x33, 0x10, 0x00, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x39, 0x31,
+	0x34, 0x10, 0x01, 0x2a, 0x5a, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x35, 0x39, 0x31, 0x35, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x39, 0x31,
+	0x36, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x35, 0x39, 0x31, 0x37, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x39, 0x31, 0x38, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x39, 0x31, 0x39, 0x10, 0x03, 0x2a,
+	0x32, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x35, 0x39, 0x32, 0x30, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x39, 0x32, 0x31, 0x10, 0x00, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x39, 0x32,
+	0x32, 0x10, 0x01, 0x2a, 0x5a, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x35, 0x39, 0x32, 0x33, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x39, 0x32,
+	0x34, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x35, 0x39, 0x32, 0x35, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x39, 0x32, 0x36, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x39, 0x32, 0x37, 0x10, 0x03, 0x2a,
+	0x32, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x35, 0x39, 0x32, 0x38, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x39, 0x32, 0x39, 0x10, 0x00, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x39, 0x33,
+	0x30, 0x10, 0x01, 0x2a, 0x46, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x35, 0x39, 0x33, 0x31, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x39, 0x33,
+	0x32, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x35, 0x39, 0x33, 0x33, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x39, 0x33, 0x34, 0x10, 0x02, 0x2a, 0x46, 0x0a, 0x08, 0x45,
+	0x6e, 0x75, 0x6d, 0x35, 0x39, 0x33, 0x35, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x39, 0x33, 0x36, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x39, 0x33, 0x37, 0x10, 0x01, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x39, 0x33,
+	0x38, 0x10, 0x02, 0x2a, 0x82, 0x01, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x35, 0x39, 0x33, 0x39,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x39,
+	0x34, 0x30, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x35, 0x39, 0x34, 0x31, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x39, 0x34, 0x32, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x39, 0x34, 0x33, 0x10, 0x03,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x39,
+	0x34, 0x34, 0x10, 0x04, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x35, 0x39, 0x34, 0x35, 0x10, 0x05, 0x2a, 0xd2, 0x01, 0x0a, 0x08, 0x45, 0x6e, 0x75,
+	0x6d, 0x35, 0x39, 0x34, 0x36, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x35, 0x39, 0x34, 0x37, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x39, 0x34, 0x38, 0x10, 0x01, 0x12, 0x12, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x39, 0x34, 0x39, 0x10,
+	0x02, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x35,
+	0x39, 0x35, 0x30, 0x10, 0x03, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x35, 0x39, 0x35, 0x31, 0x10, 0x04, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x39, 0x35, 0x32, 0x10, 0x05, 0x12, 0x12, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x39, 0x35, 0x33, 0x10,
+	0x06, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x35,
+	0x39, 0x35, 0x34, 0x10, 0x07, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x35, 0x39, 0x35, 0x35, 0x10, 0x08, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x39, 0x35, 0x36, 0x10, 0x09, 0x2a, 0x5a, 0x0a,
+	0x08, 0x45, 0x6e, 0x75, 0x6d, 0x35, 0x39, 0x35, 0x37, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x39, 0x35, 0x38, 0x10, 0x00, 0x12, 0x12, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x39, 0x35, 0x39, 0x10,
+	0x01, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x35,
+	0x39, 0x36, 0x30, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x35, 0x39, 0x36, 0x31, 0x10, 0x03, 0x2a, 0x32, 0x0a, 0x08, 0x45, 0x6e, 0x75,
+	0x6d, 0x35, 0x39, 0x36, 0x32, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x35, 0x39, 0x36, 0x33, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x35, 0x39, 0x36, 0x34, 0x10, 0x01, 0x2a, 0xc2, 0x03,
+	0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x36, 0x30, 0x32, 0x35, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x32, 0x36, 0x10, 0x00, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x32, 0x37,
+	0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x36, 0x30, 0x32, 0x38, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x32, 0x39, 0x10, 0x03, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x33, 0x30, 0x10, 0x04, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x33, 0x31,
+	0x10, 0x05, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x36, 0x30, 0x33, 0x32, 0x10, 0x06, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x33, 0x33, 0x10, 0x07, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x33, 0x34, 0x10, 0x08, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x33, 0x35,
+	0x10, 0x09, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x36, 0x30, 0x33, 0x36, 0x10, 0x0a, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x33, 0x37, 0x10, 0x0b, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x33, 0x38, 0x10, 0x0c, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x33, 0x39,
+	0x10, 0x0d, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x36, 0x30, 0x34, 0x30, 0x10, 0x0e, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x34, 0x31, 0x10, 0x0f, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x34, 0x32, 0x10, 0x10, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x34, 0x33,
+	0x10, 0x11, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x36, 0x30, 0x34, 0x34, 0x10, 0x12, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x34, 0x35, 0x10, 0x13, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x34, 0x36, 0x10, 0x14, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x34, 0x37,
+	0x10, 0x15, 0x2a, 0xa2, 0x02, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x36, 0x31, 0x31, 0x31, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x31, 0x31,
+	0x32, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x36, 0x31, 0x31, 0x33, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x31, 0x31, 0x34, 0x10, 0x03, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x31, 0x31, 0x35, 0x10, 0x04, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x31, 0x31,
+	0x36, 0x10, 0x05, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x36, 0x31, 0x31, 0x37, 0x10, 0x06, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x31, 0x31, 0x38, 0x10, 0x07, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x31, 0x31, 0x39, 0x10, 0x08, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x31, 0x32,
+	0x30, 0x10, 0x09, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x36, 0x31, 0x32, 0x31, 0x10, 0x0a, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x31, 0x32, 0x32, 0x10, 0x0b, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x31, 0x32, 0x33, 0x10, 0x0c, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x31, 0x32,
+	0x34, 0x10, 0x0d, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x36, 0x31, 0x32, 0x35, 0x10, 0x0e, 0x2a, 0xb6, 0x02, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d,
+	0x36, 0x30, 0x36, 0x35, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x36, 0x30, 0x36, 0x36, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x36, 0x37, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x36, 0x38, 0x10, 0x02,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30,
+	0x36, 0x39, 0x10, 0x03, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x36, 0x30, 0x37, 0x30, 0x10, 0x04, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x37, 0x31, 0x10, 0x05, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x37, 0x32, 0x10, 0x06,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30,
+	0x37, 0x33, 0x10, 0x07, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x36, 0x30, 0x37, 0x34, 0x10, 0x08, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x37, 0x35, 0x10, 0x09, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x37, 0x36, 0x10, 0x0a,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30,
+	0x37, 0x37, 0x10, 0x0b, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x36, 0x30, 0x37, 0x38, 0x10, 0x0c, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x37, 0x39, 0x10, 0x0d, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x30, 0x38, 0x30, 0x10, 0x0e,
+	0x2a, 0x32, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x36, 0x31, 0x33, 0x30, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x31, 0x33, 0x31, 0x10, 0x00,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x31,
+	0x33, 0x32, 0x10, 0x01, 0x2a, 0xaa, 0x01, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x36, 0x35, 0x37,
+	0x39, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36,
+	0x35, 0x38, 0x30, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x36, 0x35, 0x38, 0x31, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x35, 0x38, 0x32, 0x10, 0x03, 0x12, 0x12, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x35, 0x38, 0x33, 0x10,
+	0x05, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36,
+	0x35, 0x38, 0x34, 0x10, 0x0a, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x36, 0x35, 0x38, 0x35, 0x10, 0x0f, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x35, 0x38, 0x36, 0x10, 0x19, 0x12, 0x12, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x35, 0x38, 0x37, 0x10,
+	0x1e, 0x2a, 0xb2, 0x05, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x36, 0x35, 0x38, 0x38, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x35, 0x38, 0x39,
+	0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x36, 0x35, 0x39, 0x30, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x36, 0x35, 0x39, 0x31, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x35, 0x39, 0x32, 0x10, 0x03, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x35, 0x39, 0x33,
+	0x10, 0x04, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x36, 0x35, 0x39, 0x34, 0x10, 0x05, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x36, 0x35, 0x39, 0x35, 0x10, 0x06, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x35, 0x39, 0x36, 0x10, 0x07, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x35, 0x39, 0x37,
+	0x10, 0x08, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x36, 0x35, 0x39, 0x38, 0x10, 0x09, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x36, 0x35, 0x39, 0x39, 0x10, 0x0a, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x36, 0x30, 0x30, 0x10, 0x0b, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x36, 0x30, 0x31,
+	0x10, 0x0c, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x36, 0x36, 0x30, 0x32, 0x10, 0x0d, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x36, 0x36, 0x30, 0x33, 0x10, 0x0e, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x36, 0x30, 0x34, 0x10, 0x0f, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x36, 0x30, 0x35,
+	0x10, 0x10, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x36, 0x36, 0x30, 0x36, 0x10, 0x11, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x36, 0x36, 0x30, 0x37, 0x10, 0x13, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x36, 0x30, 0x38, 0x10, 0x14, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x36, 0x30, 0x39,
+	0x10, 0x15, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x36, 0x36, 0x31, 0x30, 0x10, 0x16, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x36, 0x36, 0x31, 0x31, 0x10, 0x17, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x36, 0x31, 0x32, 0x10, 0x18, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x36, 0x31, 0x33,
+	0x10, 0x19, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x36, 0x36, 0x31, 0x34, 0x10, 0x1a, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x36, 0x36, 0x31, 0x35, 0x10, 0x1b, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x36, 0x31, 0x36, 0x10, 0x1c, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x36, 0x31, 0x37,
+	0x10, 0x1d, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x36, 0x36, 0x31, 0x38, 0x10, 0x1e, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x36, 0x36, 0x31, 0x39, 0x10, 0x1f, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x36, 0x32, 0x30, 0x10, 0x20, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x36, 0x36, 0x32, 0x31,
+	0x10, 0x21, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x36, 0x36, 0x32, 0x32, 0x10, 0x22, 0x2a, 0x5a, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x37, 0x32,
+	0x38, 0x38, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x37, 0x32, 0x38, 0x39, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x37, 0x32, 0x39, 0x30, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x37, 0x32, 0x39, 0x31, 0x10, 0x02, 0x12, 0x12,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x37, 0x32, 0x39, 0x32,
+	0x10, 0x03, 0x2a, 0xaa, 0x01, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x37, 0x35, 0x31, 0x32, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x37, 0x35, 0x31,
+	0x33, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x37, 0x35, 0x31, 0x34, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x37, 0x35, 0x31, 0x35, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x37, 0x35, 0x31, 0x36, 0x10, 0x03, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x37, 0x35, 0x31,
+	0x37, 0x10, 0x04, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x37, 0x35, 0x31, 0x38, 0x10, 0x05, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x37, 0x35, 0x31, 0x39, 0x10, 0x06, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x37, 0x35, 0x32, 0x30, 0x10, 0x07, 0x2a,
+	0x6e, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x37, 0x39, 0x32, 0x32, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x37, 0x39, 0x32, 0x33, 0x10, 0x01, 0x12,
+	0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x37, 0x39, 0x32,
+	0x34, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x37, 0x39, 0x32, 0x35, 0x10, 0x03, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x37, 0x39, 0x32, 0x36, 0x10, 0x04, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x37, 0x39, 0x32, 0x37, 0x10, 0x05, 0x2a,
+	0xa2, 0x1d, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x33, 0x34, 0x37, 0x36, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x34, 0x37, 0x37, 0x10, 0x00,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x34,
+	0x37, 0x38, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x34, 0x37, 0x39, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x34, 0x38, 0x30, 0x10, 0x03, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x34, 0x38, 0x31, 0x10, 0x04,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x34,
+	0x38, 0x32, 0x10, 0x05, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x34, 0x38, 0x33, 0x10, 0x06, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x34, 0x38, 0x34, 0x10, 0x07, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x34, 0x38, 0x35, 0x10, 0x08,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x34,
+	0x38, 0x36, 0x10, 0x09, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x34, 0x38, 0x37, 0x10, 0x0a, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x34, 0x38, 0x38, 0x10, 0x0b, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x34, 0x38, 0x39, 0x10, 0x0c,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x34,
+	0x39, 0x30, 0x10, 0x0d, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x34, 0x39, 0x31, 0x10, 0x0e, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x34, 0x39, 0x32, 0x10, 0x0f, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x34, 0x39, 0x33, 0x10, 0x10,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x34,
+	0x39, 0x34, 0x10, 0x11, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x34, 0x39, 0x35, 0x10, 0x12, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x34, 0x39, 0x36, 0x10, 0x13, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x34, 0x39, 0x37, 0x10, 0x14,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x34,
+	0x39, 0x38, 0x10, 0x15, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x34, 0x39, 0x39, 0x10, 0x16, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x30, 0x30, 0x10, 0x17, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x30, 0x31, 0x10, 0x18,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35,
+	0x30, 0x32, 0x10, 0x19, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x35, 0x30, 0x33, 0x10, 0x1a, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x30, 0x34, 0x10, 0x1b, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x30, 0x35, 0x10, 0x1c,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35,
+	0x30, 0x36, 0x10, 0x1d, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x35, 0x30, 0x37, 0x10, 0x1e, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x30, 0x38, 0x10, 0x1f, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x30, 0x39, 0x10, 0x20,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35,
+	0x31, 0x30, 0x10, 0x21, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x35, 0x31, 0x31, 0x10, 0x22, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x31, 0x32, 0x10, 0x23, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x31, 0x33, 0x10, 0x24,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35,
+	0x31, 0x34, 0x10, 0x25, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x35, 0x31, 0x35, 0x10, 0x26, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x31, 0x36, 0x10, 0x27, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x31, 0x37, 0x10, 0x28,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35,
+	0x31, 0x38, 0x10, 0x29, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x35, 0x31, 0x39, 0x10, 0x2a, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x32, 0x30, 0x10, 0x2b, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x32, 0x31, 0x10, 0x2c,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35,
+	0x32, 0x32, 0x10, 0x2d, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x35, 0x32, 0x33, 0x10, 0x2e, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x32, 0x34, 0x10, 0x2f, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x32, 0x35, 0x10, 0x30,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35,
+	0x32, 0x36, 0x10, 0x31, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x35, 0x32, 0x37, 0x10, 0x32, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x32, 0x38, 0x10, 0x33, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x32, 0x39, 0x10, 0x34,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35,
+	0x33, 0x30, 0x10, 0x35, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x35, 0x33, 0x31, 0x10, 0x36, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x33, 0x32, 0x10, 0x37, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x33, 0x33, 0x10, 0x38,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35,
+	0x33, 0x34, 0x10, 0x39, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x35, 0x33, 0x35, 0x10, 0x3a, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x33, 0x36, 0x10, 0x3b, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x33, 0x37, 0x10, 0x3c,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35,
+	0x33, 0x38, 0x10, 0x3d, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x35, 0x33, 0x39, 0x10, 0x3e, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x34, 0x30, 0x10, 0x3f, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x34, 0x31, 0x10, 0x40,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35,
+	0x34, 0x32, 0x10, 0x41, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x35, 0x34, 0x33, 0x10, 0x42, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x34, 0x34, 0x10, 0x43, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x34, 0x35, 0x10, 0x44,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35,
+	0x34, 0x36, 0x10, 0x45, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x35, 0x34, 0x37, 0x10, 0x46, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x34, 0x38, 0x10, 0x47, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x34, 0x39, 0x10, 0x48,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35,
+	0x35, 0x30, 0x10, 0x49, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x35, 0x35, 0x31, 0x10, 0x4a, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x35, 0x32, 0x10, 0x4b, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x35, 0x33, 0x10, 0x4c,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35,
+	0x35, 0x34, 0x10, 0x4d, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x35, 0x35, 0x35, 0x10, 0x4e, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x35, 0x36, 0x10, 0x4f, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x35, 0x37, 0x10, 0x50,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35,
+	0x35, 0x38, 0x10, 0x51, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x35, 0x35, 0x39, 0x10, 0x52, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x36, 0x30, 0x10, 0x53, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x36, 0x31, 0x10, 0x54,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35,
+	0x36, 0x32, 0x10, 0x55, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x35, 0x36, 0x33, 0x10, 0x56, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x36, 0x34, 0x10, 0x57, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x36, 0x35, 0x10, 0x58,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35,
+	0x36, 0x36, 0x10, 0x59, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x35, 0x36, 0x37, 0x10, 0x5a, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x36, 0x38, 0x10, 0x5b, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x36, 0x39, 0x10, 0x5c,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35,
+	0x37, 0x30, 0x10, 0x5d, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x35, 0x37, 0x31, 0x10, 0x5e, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x37, 0x32, 0x10, 0x5f, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x37, 0x33, 0x10, 0x60,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35,
+	0x37, 0x34, 0x10, 0x61, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x35, 0x37, 0x35, 0x10, 0x62, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x37, 0x36, 0x10, 0x63, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x37, 0x37, 0x10, 0x64,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35,
+	0x37, 0x38, 0x10, 0x65, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x35, 0x37, 0x39, 0x10, 0x66, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x38, 0x30, 0x10, 0x67, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x38, 0x31, 0x10, 0x68,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35,
+	0x38, 0x32, 0x10, 0x69, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x35, 0x38, 0x33, 0x10, 0x6a, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x38, 0x34, 0x10, 0x6b, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x38, 0x35, 0x10, 0x6c,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35,
+	0x38, 0x36, 0x10, 0x6d, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x35, 0x38, 0x37, 0x10, 0x6e, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x38, 0x38, 0x10, 0x6f, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x38, 0x39, 0x10, 0x70,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35,
+	0x39, 0x30, 0x10, 0x71, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x35, 0x39, 0x31, 0x10, 0x72, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x39, 0x32, 0x10, 0x73, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x39, 0x33, 0x10, 0x74,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35,
+	0x39, 0x34, 0x10, 0x75, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x35, 0x39, 0x35, 0x10, 0x76, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x39, 0x36, 0x10, 0x77, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35, 0x39, 0x37, 0x10, 0x78,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x35,
+	0x39, 0x38, 0x10, 0x79, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x35, 0x39, 0x39, 0x10, 0x7a, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x30, 0x30, 0x10, 0x7b, 0x12, 0x12, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x30, 0x31, 0x10, 0x7c,
+	0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36,
+	0x30, 0x32, 0x10, 0x7d, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x36, 0x30, 0x33, 0x10, 0x7e, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x30, 0x34, 0x10, 0x7f, 0x12, 0x13, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x30, 0x35, 0x10, 0x80,
+	0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33,
+	0x36, 0x30, 0x36, 0x10, 0x81, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x30, 0x37, 0x10, 0x82, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x30, 0x38, 0x10, 0x83, 0x01,
+	0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36,
+	0x30, 0x39, 0x10, 0x84, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x33, 0x36, 0x31, 0x30, 0x10, 0x85, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x31, 0x31, 0x10, 0x86, 0x01, 0x12,
+	0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x31,
+	0x32, 0x10, 0x87, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x36, 0x31, 0x33, 0x10, 0x88, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x31, 0x34, 0x10, 0x89, 0x01, 0x12, 0x13,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x31, 0x35,
+	0x10, 0x8a, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x36, 0x31, 0x36, 0x10, 0x8b, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x31, 0x37, 0x10, 0x8c, 0x01, 0x12, 0x13, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x31, 0x38, 0x10,
+	0x8d, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x33, 0x36, 0x31, 0x39, 0x10, 0x8e, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x32, 0x30, 0x10, 0x8f, 0x01, 0x12, 0x13, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x32, 0x31, 0x10, 0x90,
+	0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33,
+	0x36, 0x32, 0x32, 0x10, 0x91, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x32, 0x33, 0x10, 0x92, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x32, 0x34, 0x10, 0x93, 0x01,
+	0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36,
+	0x32, 0x35, 0x10, 0x94, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x33, 0x36, 0x32, 0x36, 0x10, 0x95, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x32, 0x37, 0x10, 0x96, 0x01, 0x12,
+	0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x32,
+	0x38, 0x10, 0x97, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x36, 0x32, 0x39, 0x10, 0x98, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x33, 0x30, 0x10, 0x99, 0x01, 0x12, 0x13,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x33, 0x31,
+	0x10, 0x9a, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x36, 0x33, 0x32, 0x10, 0x9b, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x33, 0x33, 0x10, 0x9c, 0x01, 0x12, 0x13, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x33, 0x34, 0x10,
+	0x9d, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x33, 0x36, 0x33, 0x35, 0x10, 0x9e, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x33, 0x36, 0x10, 0x9f, 0x01, 0x12, 0x13, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x33, 0x37, 0x10, 0xa0,
+	0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33,
+	0x36, 0x33, 0x38, 0x10, 0xa1, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x33, 0x39, 0x10, 0xa2, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x34, 0x30, 0x10, 0xa3, 0x01,
+	0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36,
+	0x34, 0x31, 0x10, 0xa4, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x33, 0x36, 0x34, 0x32, 0x10, 0xa5, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x34, 0x33, 0x10, 0xa6, 0x01, 0x12,
+	0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x34,
+	0x34, 0x10, 0xa7, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x33, 0x36, 0x34, 0x35, 0x10, 0xa8, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55,
+	0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x34, 0x36, 0x10, 0xa9, 0x01, 0x12, 0x13,
+	0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x34, 0x37,
+	0x10, 0xaa, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x33, 0x36, 0x34, 0x38, 0x10, 0xab, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x34, 0x39, 0x10, 0xac, 0x01, 0x12, 0x13, 0x0a,
+	0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x35, 0x30, 0x10,
+	0xad, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x33, 0x36, 0x35, 0x31, 0x10, 0xae, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x35, 0x32, 0x10, 0xaf, 0x01, 0x12, 0x13, 0x0a, 0x0e,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x35, 0x33, 0x10, 0xb0,
+	0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33,
+	0x36, 0x35, 0x34, 0x10, 0xb1, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x35, 0x35, 0x10, 0xb2, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x35, 0x36, 0x10, 0xb3, 0x01,
+	0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36,
+	0x35, 0x37, 0x10, 0xb4, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x33, 0x36, 0x35, 0x38, 0x10, 0xb5, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x35, 0x39, 0x10, 0xb6, 0x01, 0x12,
+	0x13, 0x0a, 0x0e, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x33, 0x36, 0x36,
+	0x30, 0x10, 0xb7, 0x01, 0x2a, 0xc8, 0x01, 0x0a, 0x09, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x30, 0x33,
+	0x32, 0x35, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x30, 0x33, 0x32, 0x36, 0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x33, 0x32, 0x37, 0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x33, 0x32, 0x38, 0x10,
+	0x02, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x30, 0x33, 0x32, 0x39, 0x10, 0x03, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x33, 0x33, 0x30, 0x10, 0x04, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x33, 0x33, 0x31, 0x10, 0x05,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30,
+	0x33, 0x33, 0x32, 0x10, 0x06, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x30, 0x33, 0x33, 0x33, 0x10, 0x07, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x33, 0x33, 0x34, 0x10, 0x08, 0x2a,
+	0x20, 0x0a, 0x09, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x30, 0x33, 0x33, 0x35, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x33, 0x33, 0x36, 0x10,
+	0x00, 0x2a, 0x35, 0x0a, 0x09, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x30, 0x33, 0x33, 0x37, 0x12, 0x13,
+	0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x30, 0x33, 0x33,
+	0x38, 0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55,
+	0x45, 0x31, 0x30, 0x33, 0x33, 0x39, 0x10, 0x01, 0x2a, 0x5f, 0x0a, 0x09, 0x45, 0x6e, 0x75, 0x6d,
+	0x31, 0x31, 0x39, 0x30, 0x31, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x31, 0x39, 0x30, 0x32, 0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e,
+	0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x39, 0x30, 0x33, 0x10, 0x01, 0x12,
+	0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x31, 0x39,
+	0x30, 0x34, 0x10, 0x02, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c,
+	0x55, 0x45, 0x31, 0x31, 0x39, 0x30, 0x35, 0x10, 0x03, 0x2a, 0x5f, 0x0a, 0x09, 0x45, 0x6e, 0x75,
+	0x6d, 0x31, 0x32, 0x37, 0x33, 0x35, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56,
+	0x41, 0x4c, 0x55, 0x45, 0x31, 0x32, 0x37, 0x33, 0x36, 0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x45,
+	0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x32, 0x37, 0x33, 0x37, 0x10, 0x01,
+	0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x32,
+	0x37, 0x33, 0x38, 0x10, 0x02, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41,
+	0x4c, 0x55, 0x45, 0x31, 0x32, 0x37, 0x33, 0x39, 0x10, 0x03, 0x2a, 0x89, 0x01, 0x0a, 0x09, 0x45,
+	0x6e, 0x75, 0x6d, 0x31, 0x32, 0x38, 0x37, 0x31, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d,
+	0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x32, 0x38, 0x37, 0x32, 0x10, 0x01, 0x12, 0x13, 0x0a,
+	0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x32, 0x38, 0x37, 0x33,
+	0x10, 0x02, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45,
+	0x31, 0x32, 0x38, 0x37, 0x34, 0x10, 0x03, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f,
+	0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x32, 0x38, 0x37, 0x35, 0x10, 0x04, 0x12, 0x13, 0x0a, 0x0f,
+	0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31, 0x32, 0x38, 0x37, 0x36, 0x10,
+	0x05, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x31,
+	0x32, 0x38, 0x37, 0x37, 0x10, 0x06, 0x42, 0x23, 0x0a, 0x1e, 0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x62, 0x65,
+	0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0xf8, 0x01, 0x01,
+}
+
+var (
+	file_datasets_google_message4_benchmark_message4_3_proto_rawDescOnce sync.Once
+	file_datasets_google_message4_benchmark_message4_3_proto_rawDescData = file_datasets_google_message4_benchmark_message4_3_proto_rawDesc
+)
+
+func file_datasets_google_message4_benchmark_message4_3_proto_rawDescGZIP() []byte {
+	file_datasets_google_message4_benchmark_message4_3_proto_rawDescOnce.Do(func() {
+		file_datasets_google_message4_benchmark_message4_3_proto_rawDescData = protoimpl.X.CompressGZIP(file_datasets_google_message4_benchmark_message4_3_proto_rawDescData)
+	})
+	return file_datasets_google_message4_benchmark_message4_3_proto_rawDescData
+}
+
+var file_datasets_google_message4_benchmark_message4_3_proto_enumTypes = make([]protoimpl.EnumInfo, 42)
+var file_datasets_google_message4_benchmark_message4_3_proto_goTypes = []interface{}{
+	(UnusedEnum)(0), // 0: benchmarks.google_message4.UnusedEnum
+	(Enum2593)(0),   // 1: benchmarks.google_message4.Enum2593
+	(Enum2834)(0),   // 2: benchmarks.google_message4.Enum2834
+	(Enum2806)(0),   // 3: benchmarks.google_message4.Enum2806
+	(Enum2851)(0),   // 4: benchmarks.google_message4.Enum2851
+	(Enum2602)(0),   // 5: benchmarks.google_message4.Enum2602
+	(Enum3071)(0),   // 6: benchmarks.google_message4.Enum3071
+	(Enum3805)(0),   // 7: benchmarks.google_message4.Enum3805
+	(Enum3783)(0),   // 8: benchmarks.google_message4.Enum3783
+	(Enum3851)(0),   // 9: benchmarks.google_message4.Enum3851
+	(Enum5862)(0),   // 10: benchmarks.google_message4.Enum5862
+	(Enum5868)(0),   // 11: benchmarks.google_message4.Enum5868
+	(Enum5873)(0),   // 12: benchmarks.google_message4.Enum5873
+	(Enum5904)(0),   // 13: benchmarks.google_message4.Enum5904
+	(Enum5909)(0),   // 14: benchmarks.google_message4.Enum5909
+	(Enum5912)(0),   // 15: benchmarks.google_message4.Enum5912
+	(Enum5915)(0),   // 16: benchmarks.google_message4.Enum5915
+	(Enum5920)(0),   // 17: benchmarks.google_message4.Enum5920
+	(Enum5923)(0),   // 18: benchmarks.google_message4.Enum5923
+	(Enum5928)(0),   // 19: benchmarks.google_message4.Enum5928
+	(Enum5931)(0),   // 20: benchmarks.google_message4.Enum5931
+	(Enum5935)(0),   // 21: benchmarks.google_message4.Enum5935
+	(Enum5939)(0),   // 22: benchmarks.google_message4.Enum5939
+	(Enum5946)(0),   // 23: benchmarks.google_message4.Enum5946
+	(Enum5957)(0),   // 24: benchmarks.google_message4.Enum5957
+	(Enum5962)(0),   // 25: benchmarks.google_message4.Enum5962
+	(Enum6025)(0),   // 26: benchmarks.google_message4.Enum6025
+	(Enum6111)(0),   // 27: benchmarks.google_message4.Enum6111
+	(Enum6065)(0),   // 28: benchmarks.google_message4.Enum6065
+	(Enum6130)(0),   // 29: benchmarks.google_message4.Enum6130
+	(Enum6579)(0),   // 30: benchmarks.google_message4.Enum6579
+	(Enum6588)(0),   // 31: benchmarks.google_message4.Enum6588
+	(Enum7288)(0),   // 32: benchmarks.google_message4.Enum7288
+	(Enum7512)(0),   // 33: benchmarks.google_message4.Enum7512
+	(Enum7922)(0),   // 34: benchmarks.google_message4.Enum7922
+	(Enum3476)(0),   // 35: benchmarks.google_message4.Enum3476
+	(Enum10325)(0),  // 36: benchmarks.google_message4.Enum10325
+	(Enum10335)(0),  // 37: benchmarks.google_message4.Enum10335
+	(Enum10337)(0),  // 38: benchmarks.google_message4.Enum10337
+	(Enum11901)(0),  // 39: benchmarks.google_message4.Enum11901
+	(Enum12735)(0),  // 40: benchmarks.google_message4.Enum12735
+	(Enum12871)(0),  // 41: benchmarks.google_message4.Enum12871
+}
+var file_datasets_google_message4_benchmark_message4_3_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_datasets_google_message4_benchmark_message4_3_proto_init() }
+func file_datasets_google_message4_benchmark_message4_3_proto_init() {
+	if File_datasets_google_message4_benchmark_message4_3_proto != nil {
+		return
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_datasets_google_message4_benchmark_message4_3_proto_rawDesc,
+			NumEnums:      42,
+			NumMessages:   0,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_datasets_google_message4_benchmark_message4_3_proto_goTypes,
+		DependencyIndexes: file_datasets_google_message4_benchmark_message4_3_proto_depIdxs,
+		EnumInfos:         file_datasets_google_message4_benchmark_message4_3_proto_enumTypes,
+	}.Build()
+	File_datasets_google_message4_benchmark_message4_3_proto = out.File
+	file_datasets_google_message4_benchmark_message4_3_proto_rawDesc = nil
+	file_datasets_google_message4_benchmark_message4_3_proto_goTypes = nil
+	file_datasets_google_message4_benchmark_message4_3_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/micro/micro.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/micro/micro.pb.go
new file mode 100644
index 000000000..591b8e639
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/micro/micro.pb.go
@@ -0,0 +1,278 @@
+// Copyright 2020 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: internal/testprotos/benchmarks/micro/micro.proto
+
+package micro
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type SixteenRequired struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	F1  *int32 `protobuf:"varint,1,req,name=f1" json:"f1,omitempty"`
+	F2  *int32 `protobuf:"varint,2,req,name=f2" json:"f2,omitempty"`
+	F3  *int32 `protobuf:"varint,3,req,name=f3" json:"f3,omitempty"`
+	F4  *int32 `protobuf:"varint,4,req,name=f4" json:"f4,omitempty"`
+	F5  *int32 `protobuf:"varint,5,req,name=f5" json:"f5,omitempty"`
+	F6  *int32 `protobuf:"varint,6,req,name=f6" json:"f6,omitempty"`
+	F7  *int32 `protobuf:"varint,7,req,name=f7" json:"f7,omitempty"`
+	F8  *int32 `protobuf:"varint,8,req,name=f8" json:"f8,omitempty"`
+	F9  *int32 `protobuf:"varint,9,req,name=f9" json:"f9,omitempty"`
+	F10 *int32 `protobuf:"varint,10,req,name=f10" json:"f10,omitempty"`
+	F11 *int32 `protobuf:"varint,11,req,name=f11" json:"f11,omitempty"`
+	F12 *int32 `protobuf:"varint,12,req,name=f12" json:"f12,omitempty"`
+	F13 *int32 `protobuf:"varint,13,req,name=f13" json:"f13,omitempty"`
+	F14 *int32 `protobuf:"varint,14,req,name=f14" json:"f14,omitempty"`
+	F15 *int32 `protobuf:"varint,15,req,name=f15" json:"f15,omitempty"`
+	F16 *int32 `protobuf:"varint,16,req,name=f16" json:"f16,omitempty"`
+}
+
+func (x *SixteenRequired) Reset() {
+	*x = SixteenRequired{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_benchmarks_micro_micro_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *SixteenRequired) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*SixteenRequired) ProtoMessage() {}
+
+func (x *SixteenRequired) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_benchmarks_micro_micro_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use SixteenRequired.ProtoReflect.Descriptor instead.
+func (*SixteenRequired) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_benchmarks_micro_micro_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *SixteenRequired) GetF1() int32 {
+	if x != nil && x.F1 != nil {
+		return *x.F1
+	}
+	return 0
+}
+
+func (x *SixteenRequired) GetF2() int32 {
+	if x != nil && x.F2 != nil {
+		return *x.F2
+	}
+	return 0
+}
+
+func (x *SixteenRequired) GetF3() int32 {
+	if x != nil && x.F3 != nil {
+		return *x.F3
+	}
+	return 0
+}
+
+func (x *SixteenRequired) GetF4() int32 {
+	if x != nil && x.F4 != nil {
+		return *x.F4
+	}
+	return 0
+}
+
+func (x *SixteenRequired) GetF5() int32 {
+	if x != nil && x.F5 != nil {
+		return *x.F5
+	}
+	return 0
+}
+
+func (x *SixteenRequired) GetF6() int32 {
+	if x != nil && x.F6 != nil {
+		return *x.F6
+	}
+	return 0
+}
+
+func (x *SixteenRequired) GetF7() int32 {
+	if x != nil && x.F7 != nil {
+		return *x.F7
+	}
+	return 0
+}
+
+func (x *SixteenRequired) GetF8() int32 {
+	if x != nil && x.F8 != nil {
+		return *x.F8
+	}
+	return 0
+}
+
+func (x *SixteenRequired) GetF9() int32 {
+	if x != nil && x.F9 != nil {
+		return *x.F9
+	}
+	return 0
+}
+
+func (x *SixteenRequired) GetF10() int32 {
+	if x != nil && x.F10 != nil {
+		return *x.F10
+	}
+	return 0
+}
+
+func (x *SixteenRequired) GetF11() int32 {
+	if x != nil && x.F11 != nil {
+		return *x.F11
+	}
+	return 0
+}
+
+func (x *SixteenRequired) GetF12() int32 {
+	if x != nil && x.F12 != nil {
+		return *x.F12
+	}
+	return 0
+}
+
+func (x *SixteenRequired) GetF13() int32 {
+	if x != nil && x.F13 != nil {
+		return *x.F13
+	}
+	return 0
+}
+
+func (x *SixteenRequired) GetF14() int32 {
+	if x != nil && x.F14 != nil {
+		return *x.F14
+	}
+	return 0
+}
+
+func (x *SixteenRequired) GetF15() int32 {
+	if x != nil && x.F15 != nil {
+		return *x.F15
+	}
+	return 0
+}
+
+func (x *SixteenRequired) GetF16() int32 {
+	if x != nil && x.F16 != nil {
+		return *x.F16
+	}
+	return 0
+}
+
+var File_internal_testprotos_benchmarks_micro_micro_proto protoreflect.FileDescriptor
+
+var file_internal_testprotos_benchmarks_micro_micro_proto_rawDesc = []byte{
+	0x0a, 0x30, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73,
+	0x2f, 0x6d, 0x69, 0x63, 0x72, 0x6f, 0x2f, 0x6d, 0x69, 0x63, 0x72, 0x6f, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x12, 0x1f, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x2e, 0x6d, 0x69, 0x63,
+	0x72, 0x6f, 0x74, 0x22, 0x9f, 0x02, 0x0a, 0x0f, 0x53, 0x69, 0x78, 0x74, 0x65, 0x65, 0x6e, 0x52,
+	0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x12, 0x0e, 0x0a, 0x02, 0x66, 0x31, 0x18, 0x01, 0x20,
+	0x02, 0x28, 0x05, 0x52, 0x02, 0x66, 0x31, 0x12, 0x0e, 0x0a, 0x02, 0x66, 0x32, 0x18, 0x02, 0x20,
+	0x02, 0x28, 0x05, 0x52, 0x02, 0x66, 0x32, 0x12, 0x0e, 0x0a, 0x02, 0x66, 0x33, 0x18, 0x03, 0x20,
+	0x02, 0x28, 0x05, 0x52, 0x02, 0x66, 0x33, 0x12, 0x0e, 0x0a, 0x02, 0x66, 0x34, 0x18, 0x04, 0x20,
+	0x02, 0x28, 0x05, 0x52, 0x02, 0x66, 0x34, 0x12, 0x0e, 0x0a, 0x02, 0x66, 0x35, 0x18, 0x05, 0x20,
+	0x02, 0x28, 0x05, 0x52, 0x02, 0x66, 0x35, 0x12, 0x0e, 0x0a, 0x02, 0x66, 0x36, 0x18, 0x06, 0x20,
+	0x02, 0x28, 0x05, 0x52, 0x02, 0x66, 0x36, 0x12, 0x0e, 0x0a, 0x02, 0x66, 0x37, 0x18, 0x07, 0x20,
+	0x02, 0x28, 0x05, 0x52, 0x02, 0x66, 0x37, 0x12, 0x0e, 0x0a, 0x02, 0x66, 0x38, 0x18, 0x08, 0x20,
+	0x02, 0x28, 0x05, 0x52, 0x02, 0x66, 0x38, 0x12, 0x0e, 0x0a, 0x02, 0x66, 0x39, 0x18, 0x09, 0x20,
+	0x02, 0x28, 0x05, 0x52, 0x02, 0x66, 0x39, 0x12, 0x10, 0x0a, 0x03, 0x66, 0x31, 0x30, 0x18, 0x0a,
+	0x20, 0x02, 0x28, 0x05, 0x52, 0x03, 0x66, 0x31, 0x30, 0x12, 0x10, 0x0a, 0x03, 0x66, 0x31, 0x31,
+	0x18, 0x0b, 0x20, 0x02, 0x28, 0x05, 0x52, 0x03, 0x66, 0x31, 0x31, 0x12, 0x10, 0x0a, 0x03, 0x66,
+	0x31, 0x32, 0x18, 0x0c, 0x20, 0x02, 0x28, 0x05, 0x52, 0x03, 0x66, 0x31, 0x32, 0x12, 0x10, 0x0a,
+	0x03, 0x66, 0x31, 0x33, 0x18, 0x0d, 0x20, 0x02, 0x28, 0x05, 0x52, 0x03, 0x66, 0x31, 0x33, 0x12,
+	0x10, 0x0a, 0x03, 0x66, 0x31, 0x34, 0x18, 0x0e, 0x20, 0x02, 0x28, 0x05, 0x52, 0x03, 0x66, 0x31,
+	0x34, 0x12, 0x10, 0x0a, 0x03, 0x66, 0x31, 0x35, 0x18, 0x0f, 0x20, 0x02, 0x28, 0x05, 0x52, 0x03,
+	0x66, 0x31, 0x35, 0x12, 0x10, 0x0a, 0x03, 0x66, 0x31, 0x36, 0x18, 0x10, 0x20, 0x02, 0x28, 0x05,
+	0x52, 0x03, 0x66, 0x31, 0x36, 0x42, 0x41, 0x5a, 0x3f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
+	0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x62, 0x75, 0x66, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73,
+	0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x62, 0x65, 0x6e, 0x63, 0x68, 0x6d, 0x61, 0x72,
+	0x6b, 0x73, 0x2f, 0x6d, 0x69, 0x63, 0x72, 0x6f,
+}
+
+var (
+	file_internal_testprotos_benchmarks_micro_micro_proto_rawDescOnce sync.Once
+	file_internal_testprotos_benchmarks_micro_micro_proto_rawDescData = file_internal_testprotos_benchmarks_micro_micro_proto_rawDesc
+)
+
+func file_internal_testprotos_benchmarks_micro_micro_proto_rawDescGZIP() []byte {
+	file_internal_testprotos_benchmarks_micro_micro_proto_rawDescOnce.Do(func() {
+		file_internal_testprotos_benchmarks_micro_micro_proto_rawDescData = protoimpl.X.CompressGZIP(file_internal_testprotos_benchmarks_micro_micro_proto_rawDescData)
+	})
+	return file_internal_testprotos_benchmarks_micro_micro_proto_rawDescData
+}
+
+var file_internal_testprotos_benchmarks_micro_micro_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_internal_testprotos_benchmarks_micro_micro_proto_goTypes = []interface{}{
+	(*SixteenRequired)(nil), // 0: goproto.proto.benchmarks.microt.SixteenRequired
+}
+var file_internal_testprotos_benchmarks_micro_micro_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_internal_testprotos_benchmarks_micro_micro_proto_init() }
+func file_internal_testprotos_benchmarks_micro_micro_proto_init() {
+	if File_internal_testprotos_benchmarks_micro_micro_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_internal_testprotos_benchmarks_micro_micro_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*SixteenRequired); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_internal_testprotos_benchmarks_micro_micro_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_internal_testprotos_benchmarks_micro_micro_proto_goTypes,
+		DependencyIndexes: file_internal_testprotos_benchmarks_micro_micro_proto_depIdxs,
+		MessageInfos:      file_internal_testprotos_benchmarks_micro_micro_proto_msgTypes,
+	}.Build()
+	File_internal_testprotos_benchmarks_micro_micro_proto = out.File
+	file_internal_testprotos_benchmarks_micro_micro_proto_rawDesc = nil
+	file_internal_testprotos_benchmarks_micro_micro_proto_goTypes = nil
+	file_internal_testprotos_benchmarks_micro_micro_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/micro/micro.proto b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/micro/micro.proto
new file mode 100644
index 000000000..a0303c14d
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/benchmarks/micro/micro.proto
@@ -0,0 +1,28 @@
+// Copyright 2020 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.
+
+syntax = "proto2";
+
+package goproto.proto.benchmarks.microt;
+
+option go_package = "google.golang.org/protobuf/internal/testprotos/benchmarks/micro";
+
+message SixteenRequired {
+  required int32 f1 = 1;
+  required int32 f2 = 2;
+  required int32 f3 = 3;
+  required int32 f4 = 4;
+  required int32 f5 = 5;
+  required int32 f6 = 6;
+  required int32 f7 = 7;
+  required int32 f8 = 8;
+  required int32 f9 = 9;
+  required int32 f10 = 10;
+  required int32 f11 = 11;
+  required int32 f12 = 12;
+  required int32 f13 = 13;
+  required int32 f14 = 14;
+  required int32 f15 = 15;
+  required int32 f16 = 16;
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/conformance/conformance.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/conformance/conformance.pb.go
new file mode 100644
index 000000000..9922a85ab
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/conformance/conformance.pb.go
@@ -0,0 +1,830 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: conformance/conformance.proto
+
+package conformance
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type WireFormat int32
+
+const (
+	WireFormat_UNSPECIFIED WireFormat = 0
+	WireFormat_PROTOBUF    WireFormat = 1
+	WireFormat_JSON        WireFormat = 2
+	WireFormat_JSPB        WireFormat = 3 // Google internal only. Opensource testees just skip it.
+	WireFormat_TEXT_FORMAT WireFormat = 4
+)
+
+// Enum value maps for WireFormat.
+var (
+	WireFormat_name = map[int32]string{
+		0: "UNSPECIFIED",
+		1: "PROTOBUF",
+		2: "JSON",
+		3: "JSPB",
+		4: "TEXT_FORMAT",
+	}
+	WireFormat_value = map[string]int32{
+		"UNSPECIFIED": 0,
+		"PROTOBUF":    1,
+		"JSON":        2,
+		"JSPB":        3,
+		"TEXT_FORMAT": 4,
+	}
+)
+
+func (x WireFormat) Enum() *WireFormat {
+	p := new(WireFormat)
+	*p = x
+	return p
+}
+
+func (x WireFormat) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (WireFormat) Descriptor() protoreflect.EnumDescriptor {
+	return file_conformance_conformance_proto_enumTypes[0].Descriptor()
+}
+
+func (WireFormat) Type() protoreflect.EnumType {
+	return &file_conformance_conformance_proto_enumTypes[0]
+}
+
+func (x WireFormat) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use WireFormat.Descriptor instead.
+func (WireFormat) EnumDescriptor() ([]byte, []int) {
+	return file_conformance_conformance_proto_rawDescGZIP(), []int{0}
+}
+
+type TestCategory int32
+
+const (
+	TestCategory_UNSPECIFIED_TEST TestCategory = 0
+	TestCategory_BINARY_TEST      TestCategory = 1 // Test binary wire format.
+	TestCategory_JSON_TEST        TestCategory = 2 // Test json wire format.
+	// Similar to JSON_TEST. However, during parsing json, testee should ignore
+	// unknown fields. This feature is optional. Each implementation can descide
+	// whether to support it.  See
+	// https://developers.google.com/protocol-buffers/docs/proto3#json_options
+	// for more detail.
+	TestCategory_JSON_IGNORE_UNKNOWN_PARSING_TEST TestCategory = 3
+	// Test jspb wire format. Google internal only. Opensource testees just skip it.
+	TestCategory_JSPB_TEST TestCategory = 4
+	// Test text format. For cpp, java and python, testees can already deal with
+	// this type. Testees of other languages can simply skip it.
+	TestCategory_TEXT_FORMAT_TEST TestCategory = 5
+)
+
+// Enum value maps for TestCategory.
+var (
+	TestCategory_name = map[int32]string{
+		0: "UNSPECIFIED_TEST",
+		1: "BINARY_TEST",
+		2: "JSON_TEST",
+		3: "JSON_IGNORE_UNKNOWN_PARSING_TEST",
+		4: "JSPB_TEST",
+		5: "TEXT_FORMAT_TEST",
+	}
+	TestCategory_value = map[string]int32{
+		"UNSPECIFIED_TEST":                 0,
+		"BINARY_TEST":                      1,
+		"JSON_TEST":                        2,
+		"JSON_IGNORE_UNKNOWN_PARSING_TEST": 3,
+		"JSPB_TEST":                        4,
+		"TEXT_FORMAT_TEST":                 5,
+	}
+)
+
+func (x TestCategory) Enum() *TestCategory {
+	p := new(TestCategory)
+	*p = x
+	return p
+}
+
+func (x TestCategory) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (TestCategory) Descriptor() protoreflect.EnumDescriptor {
+	return file_conformance_conformance_proto_enumTypes[1].Descriptor()
+}
+
+func (TestCategory) Type() protoreflect.EnumType {
+	return &file_conformance_conformance_proto_enumTypes[1]
+}
+
+func (x TestCategory) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use TestCategory.Descriptor instead.
+func (TestCategory) EnumDescriptor() ([]byte, []int) {
+	return file_conformance_conformance_proto_rawDescGZIP(), []int{1}
+}
+
+// The conformance runner will request a list of failures as the first request.
+// This will be known by message_type == "conformance.FailureSet", a conformance
+// test should return a serialized FailureSet in protobuf_payload.
+type FailureSet struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Failure []string `protobuf:"bytes,1,rep,name=failure,proto3" json:"failure,omitempty"`
+}
+
+func (x *FailureSet) Reset() {
+	*x = FailureSet{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_conformance_conformance_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *FailureSet) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*FailureSet) ProtoMessage() {}
+
+func (x *FailureSet) ProtoReflect() protoreflect.Message {
+	mi := &file_conformance_conformance_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use FailureSet.ProtoReflect.Descriptor instead.
+func (*FailureSet) Descriptor() ([]byte, []int) {
+	return file_conformance_conformance_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *FailureSet) GetFailure() []string {
+	if x != nil {
+		return x.Failure
+	}
+	return nil
+}
+
+// Represents a single test case's input.  The testee should:
+//
+//   1. parse this proto (which should always succeed)
+//   2. parse the protobuf or JSON payload in "payload" (which may fail)
+//   3. if the parse succeeded, serialize the message in the requested format.
+type ConformanceRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// The payload (whether protobuf of JSON) is always for a
+	// protobuf_test_messages.proto3.TestAllTypes proto (as defined in
+	// src/google/protobuf/proto3_test_messages.proto).
+	//
+	// TODO(haberman): if/when we expand the conformance tests to support proto2,
+	// we will want to include a field that lets the payload/response be a
+	// protobuf_test_messages.proto2.TestAllTypes message instead.
+	//
+	// Types that are assignable to Payload:
+	//	*ConformanceRequest_ProtobufPayload
+	//	*ConformanceRequest_JsonPayload
+	//	*ConformanceRequest_JspbPayload
+	//	*ConformanceRequest_TextPayload
+	Payload isConformanceRequest_Payload `protobuf_oneof:"payload"`
+	// Which format should the testee serialize its message to?
+	RequestedOutputFormat WireFormat `protobuf:"varint,3,opt,name=requested_output_format,json=requestedOutputFormat,proto3,enum=conformance.WireFormat" json:"requested_output_format,omitempty"`
+	// The full name for the test message to use; for the moment, either:
+	// protobuf_test_messages.proto3.TestAllTypesProto3 or
+	// protobuf_test_messages.proto2.TestAllTypesProto2.
+	MessageType string `protobuf:"bytes,4,opt,name=message_type,json=messageType,proto3" json:"message_type,omitempty"`
+	// Each test is given a specific test category. Some category may need
+	// spedific support in testee programs. Refer to the definition of TestCategory
+	// for more information.
+	TestCategory TestCategory `protobuf:"varint,5,opt,name=test_category,json=testCategory,proto3,enum=conformance.TestCategory" json:"test_category,omitempty"`
+	// Specify details for how to encode jspb.
+	JspbEncodingOptions *JspbEncodingConfig `protobuf:"bytes,6,opt,name=jspb_encoding_options,json=jspbEncodingOptions,proto3" json:"jspb_encoding_options,omitempty"`
+	// This can be used in json and text format. If true, testee should print
+	// unknown fields instead of ignore. This feature is optional.
+	PrintUnknownFields bool `protobuf:"varint,9,opt,name=print_unknown_fields,json=printUnknownFields,proto3" json:"print_unknown_fields,omitempty"`
+}
+
+func (x *ConformanceRequest) Reset() {
+	*x = ConformanceRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_conformance_conformance_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *ConformanceRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ConformanceRequest) ProtoMessage() {}
+
+func (x *ConformanceRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_conformance_conformance_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ConformanceRequest.ProtoReflect.Descriptor instead.
+func (*ConformanceRequest) Descriptor() ([]byte, []int) {
+	return file_conformance_conformance_proto_rawDescGZIP(), []int{1}
+}
+
+func (m *ConformanceRequest) GetPayload() isConformanceRequest_Payload {
+	if m != nil {
+		return m.Payload
+	}
+	return nil
+}
+
+func (x *ConformanceRequest) GetProtobufPayload() []byte {
+	if x, ok := x.GetPayload().(*ConformanceRequest_ProtobufPayload); ok {
+		return x.ProtobufPayload
+	}
+	return nil
+}
+
+func (x *ConformanceRequest) GetJsonPayload() string {
+	if x, ok := x.GetPayload().(*ConformanceRequest_JsonPayload); ok {
+		return x.JsonPayload
+	}
+	return ""
+}
+
+func (x *ConformanceRequest) GetJspbPayload() string {
+	if x, ok := x.GetPayload().(*ConformanceRequest_JspbPayload); ok {
+		return x.JspbPayload
+	}
+	return ""
+}
+
+func (x *ConformanceRequest) GetTextPayload() string {
+	if x, ok := x.GetPayload().(*ConformanceRequest_TextPayload); ok {
+		return x.TextPayload
+	}
+	return ""
+}
+
+func (x *ConformanceRequest) GetRequestedOutputFormat() WireFormat {
+	if x != nil {
+		return x.RequestedOutputFormat
+	}
+	return WireFormat_UNSPECIFIED
+}
+
+func (x *ConformanceRequest) GetMessageType() string {
+	if x != nil {
+		return x.MessageType
+	}
+	return ""
+}
+
+func (x *ConformanceRequest) GetTestCategory() TestCategory {
+	if x != nil {
+		return x.TestCategory
+	}
+	return TestCategory_UNSPECIFIED_TEST
+}
+
+func (x *ConformanceRequest) GetJspbEncodingOptions() *JspbEncodingConfig {
+	if x != nil {
+		return x.JspbEncodingOptions
+	}
+	return nil
+}
+
+func (x *ConformanceRequest) GetPrintUnknownFields() bool {
+	if x != nil {
+		return x.PrintUnknownFields
+	}
+	return false
+}
+
+type isConformanceRequest_Payload interface {
+	isConformanceRequest_Payload()
+}
+
+type ConformanceRequest_ProtobufPayload struct {
+	ProtobufPayload []byte `protobuf:"bytes,1,opt,name=protobuf_payload,json=protobufPayload,proto3,oneof"`
+}
+
+type ConformanceRequest_JsonPayload struct {
+	JsonPayload string `protobuf:"bytes,2,opt,name=json_payload,json=jsonPayload,proto3,oneof"`
+}
+
+type ConformanceRequest_JspbPayload struct {
+	// Google internal only.  Opensource testees just skip it.
+	JspbPayload string `protobuf:"bytes,7,opt,name=jspb_payload,json=jspbPayload,proto3,oneof"`
+}
+
+type ConformanceRequest_TextPayload struct {
+	TextPayload string `protobuf:"bytes,8,opt,name=text_payload,json=textPayload,proto3,oneof"`
+}
+
+func (*ConformanceRequest_ProtobufPayload) isConformanceRequest_Payload() {}
+
+func (*ConformanceRequest_JsonPayload) isConformanceRequest_Payload() {}
+
+func (*ConformanceRequest_JspbPayload) isConformanceRequest_Payload() {}
+
+func (*ConformanceRequest_TextPayload) isConformanceRequest_Payload() {}
+
+// Represents a single test case's output.
+type ConformanceResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// Types that are assignable to Result:
+	//	*ConformanceResponse_ParseError
+	//	*ConformanceResponse_SerializeError
+	//	*ConformanceResponse_RuntimeError
+	//	*ConformanceResponse_ProtobufPayload
+	//	*ConformanceResponse_JsonPayload
+	//	*ConformanceResponse_Skipped
+	//	*ConformanceResponse_JspbPayload
+	//	*ConformanceResponse_TextPayload
+	Result isConformanceResponse_Result `protobuf_oneof:"result"`
+}
+
+func (x *ConformanceResponse) Reset() {
+	*x = ConformanceResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_conformance_conformance_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *ConformanceResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ConformanceResponse) ProtoMessage() {}
+
+func (x *ConformanceResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_conformance_conformance_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ConformanceResponse.ProtoReflect.Descriptor instead.
+func (*ConformanceResponse) Descriptor() ([]byte, []int) {
+	return file_conformance_conformance_proto_rawDescGZIP(), []int{2}
+}
+
+func (m *ConformanceResponse) GetResult() isConformanceResponse_Result {
+	if m != nil {
+		return m.Result
+	}
+	return nil
+}
+
+func (x *ConformanceResponse) GetParseError() string {
+	if x, ok := x.GetResult().(*ConformanceResponse_ParseError); ok {
+		return x.ParseError
+	}
+	return ""
+}
+
+func (x *ConformanceResponse) GetSerializeError() string {
+	if x, ok := x.GetResult().(*ConformanceResponse_SerializeError); ok {
+		return x.SerializeError
+	}
+	return ""
+}
+
+func (x *ConformanceResponse) GetRuntimeError() string {
+	if x, ok := x.GetResult().(*ConformanceResponse_RuntimeError); ok {
+		return x.RuntimeError
+	}
+	return ""
+}
+
+func (x *ConformanceResponse) GetProtobufPayload() []byte {
+	if x, ok := x.GetResult().(*ConformanceResponse_ProtobufPayload); ok {
+		return x.ProtobufPayload
+	}
+	return nil
+}
+
+func (x *ConformanceResponse) GetJsonPayload() string {
+	if x, ok := x.GetResult().(*ConformanceResponse_JsonPayload); ok {
+		return x.JsonPayload
+	}
+	return ""
+}
+
+func (x *ConformanceResponse) GetSkipped() string {
+	if x, ok := x.GetResult().(*ConformanceResponse_Skipped); ok {
+		return x.Skipped
+	}
+	return ""
+}
+
+func (x *ConformanceResponse) GetJspbPayload() string {
+	if x, ok := x.GetResult().(*ConformanceResponse_JspbPayload); ok {
+		return x.JspbPayload
+	}
+	return ""
+}
+
+func (x *ConformanceResponse) GetTextPayload() string {
+	if x, ok := x.GetResult().(*ConformanceResponse_TextPayload); ok {
+		return x.TextPayload
+	}
+	return ""
+}
+
+type isConformanceResponse_Result interface {
+	isConformanceResponse_Result()
+}
+
+type ConformanceResponse_ParseError struct {
+	// This string should be set to indicate parsing failed.  The string can
+	// provide more information about the parse error if it is available.
+	//
+	// Setting this string does not necessarily mean the testee failed the
+	// test.  Some of the test cases are intentionally invalid input.
+	ParseError string `protobuf:"bytes,1,opt,name=parse_error,json=parseError,proto3,oneof"`
+}
+
+type ConformanceResponse_SerializeError struct {
+	// If the input was successfully parsed but errors occurred when
+	// serializing it to the requested output format, set the error message in
+	// this field.
+	SerializeError string `protobuf:"bytes,6,opt,name=serialize_error,json=serializeError,proto3,oneof"`
+}
+
+type ConformanceResponse_RuntimeError struct {
+	// This should be set if some other error occurred.  This will always
+	// indicate that the test failed.  The string can provide more information
+	// about the failure.
+	RuntimeError string `protobuf:"bytes,2,opt,name=runtime_error,json=runtimeError,proto3,oneof"`
+}
+
+type ConformanceResponse_ProtobufPayload struct {
+	// If the input was successfully parsed and the requested output was
+	// protobuf, serialize it to protobuf and set it in this field.
+	ProtobufPayload []byte `protobuf:"bytes,3,opt,name=protobuf_payload,json=protobufPayload,proto3,oneof"`
+}
+
+type ConformanceResponse_JsonPayload struct {
+	// If the input was successfully parsed and the requested output was JSON,
+	// serialize to JSON and set it in this field.
+	JsonPayload string `protobuf:"bytes,4,opt,name=json_payload,json=jsonPayload,proto3,oneof"`
+}
+
+type ConformanceResponse_Skipped struct {
+	// For when the testee skipped the test, likely because a certain feature
+	// wasn't supported, like JSON input/output.
+	Skipped string `protobuf:"bytes,5,opt,name=skipped,proto3,oneof"`
+}
+
+type ConformanceResponse_JspbPayload struct {
+	// If the input was successfully parsed and the requested output was JSPB,
+	// serialize to JSPB and set it in this field. JSPB is google internal only
+	// format. Opensource testees can just skip it.
+	JspbPayload string `protobuf:"bytes,7,opt,name=jspb_payload,json=jspbPayload,proto3,oneof"`
+}
+
+type ConformanceResponse_TextPayload struct {
+	// If the input was successfully parsed and the requested output was
+	// TEXT_FORMAT, serialize to TEXT_FORMAT and set it in this field.
+	TextPayload string `protobuf:"bytes,8,opt,name=text_payload,json=textPayload,proto3,oneof"`
+}
+
+func (*ConformanceResponse_ParseError) isConformanceResponse_Result() {}
+
+func (*ConformanceResponse_SerializeError) isConformanceResponse_Result() {}
+
+func (*ConformanceResponse_RuntimeError) isConformanceResponse_Result() {}
+
+func (*ConformanceResponse_ProtobufPayload) isConformanceResponse_Result() {}
+
+func (*ConformanceResponse_JsonPayload) isConformanceResponse_Result() {}
+
+func (*ConformanceResponse_Skipped) isConformanceResponse_Result() {}
+
+func (*ConformanceResponse_JspbPayload) isConformanceResponse_Result() {}
+
+func (*ConformanceResponse_TextPayload) isConformanceResponse_Result() {}
+
+// Encoding options for jspb format.
+type JspbEncodingConfig struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// Encode the value field of Any as jspb array if true, otherwise binary.
+	UseJspbArrayAnyFormat bool `protobuf:"varint,1,opt,name=use_jspb_array_any_format,json=useJspbArrayAnyFormat,proto3" json:"use_jspb_array_any_format,omitempty"`
+}
+
+func (x *JspbEncodingConfig) Reset() {
+	*x = JspbEncodingConfig{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_conformance_conformance_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *JspbEncodingConfig) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*JspbEncodingConfig) ProtoMessage() {}
+
+func (x *JspbEncodingConfig) ProtoReflect() protoreflect.Message {
+	mi := &file_conformance_conformance_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use JspbEncodingConfig.ProtoReflect.Descriptor instead.
+func (*JspbEncodingConfig) Descriptor() ([]byte, []int) {
+	return file_conformance_conformance_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *JspbEncodingConfig) GetUseJspbArrayAnyFormat() bool {
+	if x != nil {
+		return x.UseJspbArrayAnyFormat
+	}
+	return false
+}
+
+var File_conformance_conformance_proto protoreflect.FileDescriptor
+
+var file_conformance_conformance_proto_rawDesc = []byte{
+	0x0a, 0x1d, 0x63, 0x6f, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x2f, 0x63, 0x6f,
+	0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12,
+	0x0b, 0x63, 0x6f, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x26, 0x0a, 0x0a,
+	0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x53, 0x65, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x61,
+	0x69, 0x6c, 0x75, 0x72, 0x65, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x07, 0x66, 0x61, 0x69,
+	0x6c, 0x75, 0x72, 0x65, 0x22, 0xf6, 0x03, 0x0a, 0x12, 0x43, 0x6f, 0x6e, 0x66, 0x6f, 0x72, 0x6d,
+	0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2b, 0x0a, 0x10, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x0f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x23, 0x0a, 0x0c, 0x6a, 0x73, 0x6f, 0x6e,
+	0x5f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00,
+	0x52, 0x0b, 0x6a, 0x73, 0x6f, 0x6e, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x23, 0x0a,
+	0x0c, 0x6a, 0x73, 0x70, 0x62, 0x5f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x07, 0x20,
+	0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b, 0x6a, 0x73, 0x70, 0x62, 0x50, 0x61, 0x79, 0x6c, 0x6f,
+	0x61, 0x64, 0x12, 0x23, 0x0a, 0x0c, 0x74, 0x65, 0x78, 0x74, 0x5f, 0x70, 0x61, 0x79, 0x6c, 0x6f,
+	0x61, 0x64, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b, 0x74, 0x65, 0x78, 0x74,
+	0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x4f, 0x0a, 0x17, 0x72, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x66, 0x6f, 0x72, 0x6d,
+	0x61, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x17, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x6f,
+	0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x2e, 0x57, 0x69, 0x72, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61,
+	0x74, 0x52, 0x15, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4f, 0x75, 0x74, 0x70,
+	0x75, 0x74, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x3e, 0x0a, 0x0d, 0x74,
+	0x65, 0x73, 0x74, 0x5f, 0x63, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x18, 0x05, 0x20, 0x01,
+	0x28, 0x0e, 0x32, 0x19, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65,
+	0x2e, 0x54, 0x65, 0x73, 0x74, 0x43, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x52, 0x0c, 0x74,
+	0x65, 0x73, 0x74, 0x43, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x12, 0x53, 0x0a, 0x15, 0x6a,
+	0x73, 0x70, 0x62, 0x5f, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x63, 0x6f, 0x6e,
+	0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x2e, 0x4a, 0x73, 0x70, 0x62, 0x45, 0x6e, 0x63,
+	0x6f, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x13, 0x6a, 0x73, 0x70,
+	0x62, 0x45, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73,
+	0x12, 0x30, 0x0a, 0x14, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x5f, 0x75, 0x6e, 0x6b, 0x6e, 0x6f, 0x77,
+	0x6e, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x08, 0x52, 0x12,
+	0x70, 0x72, 0x69, 0x6e, 0x74, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x46, 0x69, 0x65, 0x6c,
+	0x64, 0x73, 0x42, 0x09, 0x0a, 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0xcc, 0x02,
+	0x0a, 0x13, 0x43, 0x6f, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x21, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x73, 0x65, 0x5f, 0x65,
+	0x72, 0x72, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0a, 0x70, 0x61,
+	0x72, 0x73, 0x65, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x29, 0x0a, 0x0f, 0x73, 0x65, 0x72, 0x69,
+	0x61, 0x6c, 0x69, 0x7a, 0x65, 0x5f, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x06, 0x20, 0x01, 0x28,
+	0x09, 0x48, 0x00, 0x52, 0x0e, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x45, 0x72,
+	0x72, 0x6f, 0x72, 0x12, 0x25, 0x0a, 0x0d, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x65,
+	0x72, 0x72, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0c, 0x72, 0x75,
+	0x6e, 0x74, 0x69, 0x6d, 0x65, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x2b, 0x0a, 0x10, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x03,
+	0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x0f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
+	0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x23, 0x0a, 0x0c, 0x6a, 0x73, 0x6f, 0x6e, 0x5f,
+	0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52,
+	0x0b, 0x6a, 0x73, 0x6f, 0x6e, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x1a, 0x0a, 0x07,
+	0x73, 0x6b, 0x69, 0x70, 0x70, 0x65, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52,
+	0x07, 0x73, 0x6b, 0x69, 0x70, 0x70, 0x65, 0x64, 0x12, 0x23, 0x0a, 0x0c, 0x6a, 0x73, 0x70, 0x62,
+	0x5f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00,
+	0x52, 0x0b, 0x6a, 0x73, 0x70, 0x62, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x23, 0x0a,
+	0x0c, 0x74, 0x65, 0x78, 0x74, 0x5f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x08, 0x20,
+	0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b, 0x74, 0x65, 0x78, 0x74, 0x50, 0x61, 0x79, 0x6c, 0x6f,
+	0x61, 0x64, 0x42, 0x08, 0x0a, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x4e, 0x0a, 0x12,
+	0x4a, 0x73, 0x70, 0x62, 0x45, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6e, 0x66,
+	0x69, 0x67, 0x12, 0x38, 0x0a, 0x19, 0x75, 0x73, 0x65, 0x5f, 0x6a, 0x73, 0x70, 0x62, 0x5f, 0x61,
+	0x72, 0x72, 0x61, 0x79, 0x5f, 0x61, 0x6e, 0x79, 0x5f, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x15, 0x75, 0x73, 0x65, 0x4a, 0x73, 0x70, 0x62, 0x41, 0x72,
+	0x72, 0x61, 0x79, 0x41, 0x6e, 0x79, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x2a, 0x50, 0x0a, 0x0a,
+	0x57, 0x69, 0x72, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x12, 0x0f, 0x0a, 0x0b, 0x55, 0x4e,
+	0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x0c, 0x0a, 0x08, 0x50,
+	0x52, 0x4f, 0x54, 0x4f, 0x42, 0x55, 0x46, 0x10, 0x01, 0x12, 0x08, 0x0a, 0x04, 0x4a, 0x53, 0x4f,
+	0x4e, 0x10, 0x02, 0x12, 0x08, 0x0a, 0x04, 0x4a, 0x53, 0x50, 0x42, 0x10, 0x03, 0x12, 0x0f, 0x0a,
+	0x0b, 0x54, 0x45, 0x58, 0x54, 0x5f, 0x46, 0x4f, 0x52, 0x4d, 0x41, 0x54, 0x10, 0x04, 0x2a, 0x8f,
+	0x01, 0x0a, 0x0c, 0x54, 0x65, 0x73, 0x74, 0x43, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x12,
+	0x14, 0x0a, 0x10, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x5f, 0x54,
+	0x45, 0x53, 0x54, 0x10, 0x00, 0x12, 0x0f, 0x0a, 0x0b, 0x42, 0x49, 0x4e, 0x41, 0x52, 0x59, 0x5f,
+	0x54, 0x45, 0x53, 0x54, 0x10, 0x01, 0x12, 0x0d, 0x0a, 0x09, 0x4a, 0x53, 0x4f, 0x4e, 0x5f, 0x54,
+	0x45, 0x53, 0x54, 0x10, 0x02, 0x12, 0x24, 0x0a, 0x20, 0x4a, 0x53, 0x4f, 0x4e, 0x5f, 0x49, 0x47,
+	0x4e, 0x4f, 0x52, 0x45, 0x5f, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x5f, 0x50, 0x41, 0x52,
+	0x53, 0x49, 0x4e, 0x47, 0x5f, 0x54, 0x45, 0x53, 0x54, 0x10, 0x03, 0x12, 0x0d, 0x0a, 0x09, 0x4a,
+	0x53, 0x50, 0x42, 0x5f, 0x54, 0x45, 0x53, 0x54, 0x10, 0x04, 0x12, 0x14, 0x0a, 0x10, 0x54, 0x45,
+	0x58, 0x54, 0x5f, 0x46, 0x4f, 0x52, 0x4d, 0x41, 0x54, 0x5f, 0x54, 0x45, 0x53, 0x54, 0x10, 0x05,
+	0x42, 0x21, 0x0a, 0x1f, 0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61,
+	0x6e, 0x63, 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_conformance_conformance_proto_rawDescOnce sync.Once
+	file_conformance_conformance_proto_rawDescData = file_conformance_conformance_proto_rawDesc
+)
+
+func file_conformance_conformance_proto_rawDescGZIP() []byte {
+	file_conformance_conformance_proto_rawDescOnce.Do(func() {
+		file_conformance_conformance_proto_rawDescData = protoimpl.X.CompressGZIP(file_conformance_conformance_proto_rawDescData)
+	})
+	return file_conformance_conformance_proto_rawDescData
+}
+
+var file_conformance_conformance_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
+var file_conformance_conformance_proto_msgTypes = make([]protoimpl.MessageInfo, 4)
+var file_conformance_conformance_proto_goTypes = []interface{}{
+	(WireFormat)(0),             // 0: conformance.WireFormat
+	(TestCategory)(0),           // 1: conformance.TestCategory
+	(*FailureSet)(nil),          // 2: conformance.FailureSet
+	(*ConformanceRequest)(nil),  // 3: conformance.ConformanceRequest
+	(*ConformanceResponse)(nil), // 4: conformance.ConformanceResponse
+	(*JspbEncodingConfig)(nil),  // 5: conformance.JspbEncodingConfig
+}
+var file_conformance_conformance_proto_depIdxs = []int32{
+	0, // 0: conformance.ConformanceRequest.requested_output_format:type_name -> conformance.WireFormat
+	1, // 1: conformance.ConformanceRequest.test_category:type_name -> conformance.TestCategory
+	5, // 2: conformance.ConformanceRequest.jspb_encoding_options:type_name -> conformance.JspbEncodingConfig
+	3, // [3:3] is the sub-list for method output_type
+	3, // [3:3] is the sub-list for method input_type
+	3, // [3:3] is the sub-list for extension type_name
+	3, // [3:3] is the sub-list for extension extendee
+	0, // [0:3] is the sub-list for field type_name
+}
+
+func init() { file_conformance_conformance_proto_init() }
+func file_conformance_conformance_proto_init() {
+	if File_conformance_conformance_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_conformance_conformance_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*FailureSet); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_conformance_conformance_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ConformanceRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_conformance_conformance_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ConformanceResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_conformance_conformance_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*JspbEncodingConfig); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	file_conformance_conformance_proto_msgTypes[1].OneofWrappers = []interface{}{
+		(*ConformanceRequest_ProtobufPayload)(nil),
+		(*ConformanceRequest_JsonPayload)(nil),
+		(*ConformanceRequest_JspbPayload)(nil),
+		(*ConformanceRequest_TextPayload)(nil),
+	}
+	file_conformance_conformance_proto_msgTypes[2].OneofWrappers = []interface{}{
+		(*ConformanceResponse_ParseError)(nil),
+		(*ConformanceResponse_SerializeError)(nil),
+		(*ConformanceResponse_RuntimeError)(nil),
+		(*ConformanceResponse_ProtobufPayload)(nil),
+		(*ConformanceResponse_JsonPayload)(nil),
+		(*ConformanceResponse_Skipped)(nil),
+		(*ConformanceResponse_JspbPayload)(nil),
+		(*ConformanceResponse_TextPayload)(nil),
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_conformance_conformance_proto_rawDesc,
+			NumEnums:      2,
+			NumMessages:   4,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_conformance_conformance_proto_goTypes,
+		DependencyIndexes: file_conformance_conformance_proto_depIdxs,
+		EnumInfos:         file_conformance_conformance_proto_enumTypes,
+		MessageInfos:      file_conformance_conformance_proto_msgTypes,
+	}.Build()
+	File_conformance_conformance_proto = out.File
+	file_conformance_conformance_proto_rawDesc = nil
+	file_conformance_conformance_proto_goTypes = nil
+	file_conformance_conformance_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/conformance/test_messages_proto2.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/conformance/test_messages_proto2.pb.go
new file mode 100644
index 000000000..dafcc8470
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/conformance/test_messages_proto2.pb.go
@@ -0,0 +1,2624 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Test schema for proto2 messages.  This test schema is used by:
+//
+// - conformance tests
+//
+
+// LINT: ALLOW_GROUPS
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google/protobuf/test_messages_proto2.proto
+
+package conformance
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoiface "google.golang.org/protobuf/runtime/protoiface"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type ForeignEnumProto2 int32
+
+const (
+	ForeignEnumProto2_FOREIGN_FOO ForeignEnumProto2 = 0
+	ForeignEnumProto2_FOREIGN_BAR ForeignEnumProto2 = 1
+	ForeignEnumProto2_FOREIGN_BAZ ForeignEnumProto2 = 2
+)
+
+// Enum value maps for ForeignEnumProto2.
+var (
+	ForeignEnumProto2_name = map[int32]string{
+		0: "FOREIGN_FOO",
+		1: "FOREIGN_BAR",
+		2: "FOREIGN_BAZ",
+	}
+	ForeignEnumProto2_value = map[string]int32{
+		"FOREIGN_FOO": 0,
+		"FOREIGN_BAR": 1,
+		"FOREIGN_BAZ": 2,
+	}
+)
+
+func (x ForeignEnumProto2) Enum() *ForeignEnumProto2 {
+	p := new(ForeignEnumProto2)
+	*p = x
+	return p
+}
+
+func (x ForeignEnumProto2) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (ForeignEnumProto2) Descriptor() protoreflect.EnumDescriptor {
+	return file_google_protobuf_test_messages_proto2_proto_enumTypes[0].Descriptor()
+}
+
+func (ForeignEnumProto2) Type() protoreflect.EnumType {
+	return &file_google_protobuf_test_messages_proto2_proto_enumTypes[0]
+}
+
+func (x ForeignEnumProto2) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *ForeignEnumProto2) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = ForeignEnumProto2(num)
+	return nil
+}
+
+// Deprecated: Use ForeignEnumProto2.Descriptor instead.
+func (ForeignEnumProto2) EnumDescriptor() ([]byte, []int) {
+	return file_google_protobuf_test_messages_proto2_proto_rawDescGZIP(), []int{0}
+}
+
+type TestAllTypesProto2_NestedEnum int32
+
+const (
+	TestAllTypesProto2_FOO TestAllTypesProto2_NestedEnum = 0
+	TestAllTypesProto2_BAR TestAllTypesProto2_NestedEnum = 1
+	TestAllTypesProto2_BAZ TestAllTypesProto2_NestedEnum = 2
+	TestAllTypesProto2_NEG TestAllTypesProto2_NestedEnum = -1 // Intentionally negative.
+)
+
+// Enum value maps for TestAllTypesProto2_NestedEnum.
+var (
+	TestAllTypesProto2_NestedEnum_name = map[int32]string{
+		0:  "FOO",
+		1:  "BAR",
+		2:  "BAZ",
+		-1: "NEG",
+	}
+	TestAllTypesProto2_NestedEnum_value = map[string]int32{
+		"FOO": 0,
+		"BAR": 1,
+		"BAZ": 2,
+		"NEG": -1,
+	}
+)
+
+func (x TestAllTypesProto2_NestedEnum) Enum() *TestAllTypesProto2_NestedEnum {
+	p := new(TestAllTypesProto2_NestedEnum)
+	*p = x
+	return p
+}
+
+func (x TestAllTypesProto2_NestedEnum) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (TestAllTypesProto2_NestedEnum) Descriptor() protoreflect.EnumDescriptor {
+	return file_google_protobuf_test_messages_proto2_proto_enumTypes[1].Descriptor()
+}
+
+func (TestAllTypesProto2_NestedEnum) Type() protoreflect.EnumType {
+	return &file_google_protobuf_test_messages_proto2_proto_enumTypes[1]
+}
+
+func (x TestAllTypesProto2_NestedEnum) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *TestAllTypesProto2_NestedEnum) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = TestAllTypesProto2_NestedEnum(num)
+	return nil
+}
+
+// Deprecated: Use TestAllTypesProto2_NestedEnum.Descriptor instead.
+func (TestAllTypesProto2_NestedEnum) EnumDescriptor() ([]byte, []int) {
+	return file_google_protobuf_test_messages_proto2_proto_rawDescGZIP(), []int{0, 0}
+}
+
+// This proto includes every type of field in both singular and repeated
+// forms.
+//
+// Also, crucially, all messages and enums in this file are eventually
+// submessages of this message.  So for example, a fuzz test of TestAllTypes
+// could trigger bugs that occur in any message type in this file.  We verify
+// this stays true in a unit test.
+type TestAllTypesProto2 struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+
+	// Singular
+	OptionalInt32          *int32                            `protobuf:"varint,1,opt,name=optional_int32,json=optionalInt32" json:"optional_int32,omitempty"`
+	OptionalInt64          *int64                            `protobuf:"varint,2,opt,name=optional_int64,json=optionalInt64" json:"optional_int64,omitempty"`
+	OptionalUint32         *uint32                           `protobuf:"varint,3,opt,name=optional_uint32,json=optionalUint32" json:"optional_uint32,omitempty"`
+	OptionalUint64         *uint64                           `protobuf:"varint,4,opt,name=optional_uint64,json=optionalUint64" json:"optional_uint64,omitempty"`
+	OptionalSint32         *int32                            `protobuf:"zigzag32,5,opt,name=optional_sint32,json=optionalSint32" json:"optional_sint32,omitempty"`
+	OptionalSint64         *int64                            `protobuf:"zigzag64,6,opt,name=optional_sint64,json=optionalSint64" json:"optional_sint64,omitempty"`
+	OptionalFixed32        *uint32                           `protobuf:"fixed32,7,opt,name=optional_fixed32,json=optionalFixed32" json:"optional_fixed32,omitempty"`
+	OptionalFixed64        *uint64                           `protobuf:"fixed64,8,opt,name=optional_fixed64,json=optionalFixed64" json:"optional_fixed64,omitempty"`
+	OptionalSfixed32       *int32                            `protobuf:"fixed32,9,opt,name=optional_sfixed32,json=optionalSfixed32" json:"optional_sfixed32,omitempty"`
+	OptionalSfixed64       *int64                            `protobuf:"fixed64,10,opt,name=optional_sfixed64,json=optionalSfixed64" json:"optional_sfixed64,omitempty"`
+	OptionalFloat          *float32                          `protobuf:"fixed32,11,opt,name=optional_float,json=optionalFloat" json:"optional_float,omitempty"`
+	OptionalDouble         *float64                          `protobuf:"fixed64,12,opt,name=optional_double,json=optionalDouble" json:"optional_double,omitempty"`
+	OptionalBool           *bool                             `protobuf:"varint,13,opt,name=optional_bool,json=optionalBool" json:"optional_bool,omitempty"`
+	OptionalString         *string                           `protobuf:"bytes,14,opt,name=optional_string,json=optionalString" json:"optional_string,omitempty"`
+	OptionalBytes          []byte                            `protobuf:"bytes,15,opt,name=optional_bytes,json=optionalBytes" json:"optional_bytes,omitempty"`
+	OptionalNestedMessage  *TestAllTypesProto2_NestedMessage `protobuf:"bytes,18,opt,name=optional_nested_message,json=optionalNestedMessage" json:"optional_nested_message,omitempty"`
+	OptionalForeignMessage *ForeignMessageProto2             `protobuf:"bytes,19,opt,name=optional_foreign_message,json=optionalForeignMessage" json:"optional_foreign_message,omitempty"`
+	OptionalNestedEnum     *TestAllTypesProto2_NestedEnum    `protobuf:"varint,21,opt,name=optional_nested_enum,json=optionalNestedEnum,enum=protobuf_test_messages.proto2.TestAllTypesProto2_NestedEnum" json:"optional_nested_enum,omitempty"`
+	OptionalForeignEnum    *ForeignEnumProto2                `protobuf:"varint,22,opt,name=optional_foreign_enum,json=optionalForeignEnum,enum=protobuf_test_messages.proto2.ForeignEnumProto2" json:"optional_foreign_enum,omitempty"`
+	OptionalStringPiece    *string                           `protobuf:"bytes,24,opt,name=optional_string_piece,json=optionalStringPiece" json:"optional_string_piece,omitempty"`
+	OptionalCord           *string                           `protobuf:"bytes,25,opt,name=optional_cord,json=optionalCord" json:"optional_cord,omitempty"`
+	RecursiveMessage       *TestAllTypesProto2               `protobuf:"bytes,27,opt,name=recursive_message,json=recursiveMessage" json:"recursive_message,omitempty"`
+	// Repeated
+	RepeatedInt32          []int32                             `protobuf:"varint,31,rep,name=repeated_int32,json=repeatedInt32" json:"repeated_int32,omitempty"`
+	RepeatedInt64          []int64                             `protobuf:"varint,32,rep,name=repeated_int64,json=repeatedInt64" json:"repeated_int64,omitempty"`
+	RepeatedUint32         []uint32                            `protobuf:"varint,33,rep,name=repeated_uint32,json=repeatedUint32" json:"repeated_uint32,omitempty"`
+	RepeatedUint64         []uint64                            `protobuf:"varint,34,rep,name=repeated_uint64,json=repeatedUint64" json:"repeated_uint64,omitempty"`
+	RepeatedSint32         []int32                             `protobuf:"zigzag32,35,rep,name=repeated_sint32,json=repeatedSint32" json:"repeated_sint32,omitempty"`
+	RepeatedSint64         []int64                             `protobuf:"zigzag64,36,rep,name=repeated_sint64,json=repeatedSint64" json:"repeated_sint64,omitempty"`
+	RepeatedFixed32        []uint32                            `protobuf:"fixed32,37,rep,name=repeated_fixed32,json=repeatedFixed32" json:"repeated_fixed32,omitempty"`
+	RepeatedFixed64        []uint64                            `protobuf:"fixed64,38,rep,name=repeated_fixed64,json=repeatedFixed64" json:"repeated_fixed64,omitempty"`
+	RepeatedSfixed32       []int32                             `protobuf:"fixed32,39,rep,name=repeated_sfixed32,json=repeatedSfixed32" json:"repeated_sfixed32,omitempty"`
+	RepeatedSfixed64       []int64                             `protobuf:"fixed64,40,rep,name=repeated_sfixed64,json=repeatedSfixed64" json:"repeated_sfixed64,omitempty"`
+	RepeatedFloat          []float32                           `protobuf:"fixed32,41,rep,name=repeated_float,json=repeatedFloat" json:"repeated_float,omitempty"`
+	RepeatedDouble         []float64                           `protobuf:"fixed64,42,rep,name=repeated_double,json=repeatedDouble" json:"repeated_double,omitempty"`
+	RepeatedBool           []bool                              `protobuf:"varint,43,rep,name=repeated_bool,json=repeatedBool" json:"repeated_bool,omitempty"`
+	RepeatedString         []string                            `protobuf:"bytes,44,rep,name=repeated_string,json=repeatedString" json:"repeated_string,omitempty"`
+	RepeatedBytes          [][]byte                            `protobuf:"bytes,45,rep,name=repeated_bytes,json=repeatedBytes" json:"repeated_bytes,omitempty"`
+	RepeatedNestedMessage  []*TestAllTypesProto2_NestedMessage `protobuf:"bytes,48,rep,name=repeated_nested_message,json=repeatedNestedMessage" json:"repeated_nested_message,omitempty"`
+	RepeatedForeignMessage []*ForeignMessageProto2             `protobuf:"bytes,49,rep,name=repeated_foreign_message,json=repeatedForeignMessage" json:"repeated_foreign_message,omitempty"`
+	RepeatedNestedEnum     []TestAllTypesProto2_NestedEnum     `protobuf:"varint,51,rep,name=repeated_nested_enum,json=repeatedNestedEnum,enum=protobuf_test_messages.proto2.TestAllTypesProto2_NestedEnum" json:"repeated_nested_enum,omitempty"`
+	RepeatedForeignEnum    []ForeignEnumProto2                 `protobuf:"varint,52,rep,name=repeated_foreign_enum,json=repeatedForeignEnum,enum=protobuf_test_messages.proto2.ForeignEnumProto2" json:"repeated_foreign_enum,omitempty"`
+	RepeatedStringPiece    []string                            `protobuf:"bytes,54,rep,name=repeated_string_piece,json=repeatedStringPiece" json:"repeated_string_piece,omitempty"`
+	RepeatedCord           []string                            `protobuf:"bytes,55,rep,name=repeated_cord,json=repeatedCord" json:"repeated_cord,omitempty"`
+	// Packed
+	PackedInt32      []int32                         `protobuf:"varint,75,rep,packed,name=packed_int32,json=packedInt32" json:"packed_int32,omitempty"`
+	PackedInt64      []int64                         `protobuf:"varint,76,rep,packed,name=packed_int64,json=packedInt64" json:"packed_int64,omitempty"`
+	PackedUint32     []uint32                        `protobuf:"varint,77,rep,packed,name=packed_uint32,json=packedUint32" json:"packed_uint32,omitempty"`
+	PackedUint64     []uint64                        `protobuf:"varint,78,rep,packed,name=packed_uint64,json=packedUint64" json:"packed_uint64,omitempty"`
+	PackedSint32     []int32                         `protobuf:"zigzag32,79,rep,packed,name=packed_sint32,json=packedSint32" json:"packed_sint32,omitempty"`
+	PackedSint64     []int64                         `protobuf:"zigzag64,80,rep,packed,name=packed_sint64,json=packedSint64" json:"packed_sint64,omitempty"`
+	PackedFixed32    []uint32                        `protobuf:"fixed32,81,rep,packed,name=packed_fixed32,json=packedFixed32" json:"packed_fixed32,omitempty"`
+	PackedFixed64    []uint64                        `protobuf:"fixed64,82,rep,packed,name=packed_fixed64,json=packedFixed64" json:"packed_fixed64,omitempty"`
+	PackedSfixed32   []int32                         `protobuf:"fixed32,83,rep,packed,name=packed_sfixed32,json=packedSfixed32" json:"packed_sfixed32,omitempty"`
+	PackedSfixed64   []int64                         `protobuf:"fixed64,84,rep,packed,name=packed_sfixed64,json=packedSfixed64" json:"packed_sfixed64,omitempty"`
+	PackedFloat      []float32                       `protobuf:"fixed32,85,rep,packed,name=packed_float,json=packedFloat" json:"packed_float,omitempty"`
+	PackedDouble     []float64                       `protobuf:"fixed64,86,rep,packed,name=packed_double,json=packedDouble" json:"packed_double,omitempty"`
+	PackedBool       []bool                          `protobuf:"varint,87,rep,packed,name=packed_bool,json=packedBool" json:"packed_bool,omitempty"`
+	PackedNestedEnum []TestAllTypesProto2_NestedEnum `protobuf:"varint,88,rep,packed,name=packed_nested_enum,json=packedNestedEnum,enum=protobuf_test_messages.proto2.TestAllTypesProto2_NestedEnum" json:"packed_nested_enum,omitempty"`
+	// Unpacked
+	UnpackedInt32      []int32                         `protobuf:"varint,89,rep,name=unpacked_int32,json=unpackedInt32" json:"unpacked_int32,omitempty"`
+	UnpackedInt64      []int64                         `protobuf:"varint,90,rep,name=unpacked_int64,json=unpackedInt64" json:"unpacked_int64,omitempty"`
+	UnpackedUint32     []uint32                        `protobuf:"varint,91,rep,name=unpacked_uint32,json=unpackedUint32" json:"unpacked_uint32,omitempty"`
+	UnpackedUint64     []uint64                        `protobuf:"varint,92,rep,name=unpacked_uint64,json=unpackedUint64" json:"unpacked_uint64,omitempty"`
+	UnpackedSint32     []int32                         `protobuf:"zigzag32,93,rep,name=unpacked_sint32,json=unpackedSint32" json:"unpacked_sint32,omitempty"`
+	UnpackedSint64     []int64                         `protobuf:"zigzag64,94,rep,name=unpacked_sint64,json=unpackedSint64" json:"unpacked_sint64,omitempty"`
+	UnpackedFixed32    []uint32                        `protobuf:"fixed32,95,rep,name=unpacked_fixed32,json=unpackedFixed32" json:"unpacked_fixed32,omitempty"`
+	UnpackedFixed64    []uint64                        `protobuf:"fixed64,96,rep,name=unpacked_fixed64,json=unpackedFixed64" json:"unpacked_fixed64,omitempty"`
+	UnpackedSfixed32   []int32                         `protobuf:"fixed32,97,rep,name=unpacked_sfixed32,json=unpackedSfixed32" json:"unpacked_sfixed32,omitempty"`
+	UnpackedSfixed64   []int64                         `protobuf:"fixed64,98,rep,name=unpacked_sfixed64,json=unpackedSfixed64" json:"unpacked_sfixed64,omitempty"`
+	UnpackedFloat      []float32                       `protobuf:"fixed32,99,rep,name=unpacked_float,json=unpackedFloat" json:"unpacked_float,omitempty"`
+	UnpackedDouble     []float64                       `protobuf:"fixed64,100,rep,name=unpacked_double,json=unpackedDouble" json:"unpacked_double,omitempty"`
+	UnpackedBool       []bool                          `protobuf:"varint,101,rep,name=unpacked_bool,json=unpackedBool" json:"unpacked_bool,omitempty"`
+	UnpackedNestedEnum []TestAllTypesProto2_NestedEnum `protobuf:"varint,102,rep,name=unpacked_nested_enum,json=unpackedNestedEnum,enum=protobuf_test_messages.proto2.TestAllTypesProto2_NestedEnum" json:"unpacked_nested_enum,omitempty"`
+	// Map
+	MapInt32Int32           map[int32]int32                              `protobuf:"bytes,56,rep,name=map_int32_int32,json=mapInt32Int32" json:"map_int32_int32,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
+	MapInt64Int64           map[int64]int64                              `protobuf:"bytes,57,rep,name=map_int64_int64,json=mapInt64Int64" json:"map_int64_int64,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
+	MapUint32Uint32         map[uint32]uint32                            `protobuf:"bytes,58,rep,name=map_uint32_uint32,json=mapUint32Uint32" json:"map_uint32_uint32,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
+	MapUint64Uint64         map[uint64]uint64                            `protobuf:"bytes,59,rep,name=map_uint64_uint64,json=mapUint64Uint64" json:"map_uint64_uint64,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
+	MapSint32Sint32         map[int32]int32                              `protobuf:"bytes,60,rep,name=map_sint32_sint32,json=mapSint32Sint32" json:"map_sint32_sint32,omitempty" protobuf_key:"zigzag32,1,opt,name=key" protobuf_val:"zigzag32,2,opt,name=value"`
+	MapSint64Sint64         map[int64]int64                              `protobuf:"bytes,61,rep,name=map_sint64_sint64,json=mapSint64Sint64" json:"map_sint64_sint64,omitempty" protobuf_key:"zigzag64,1,opt,name=key" protobuf_val:"zigzag64,2,opt,name=value"`
+	MapFixed32Fixed32       map[uint32]uint32                            `protobuf:"bytes,62,rep,name=map_fixed32_fixed32,json=mapFixed32Fixed32" json:"map_fixed32_fixed32,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
+	MapFixed64Fixed64       map[uint64]uint64                            `protobuf:"bytes,63,rep,name=map_fixed64_fixed64,json=mapFixed64Fixed64" json:"map_fixed64_fixed64,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
+	MapSfixed32Sfixed32     map[int32]int32                              `protobuf:"bytes,64,rep,name=map_sfixed32_sfixed32,json=mapSfixed32Sfixed32" json:"map_sfixed32_sfixed32,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
+	MapSfixed64Sfixed64     map[int64]int64                              `protobuf:"bytes,65,rep,name=map_sfixed64_sfixed64,json=mapSfixed64Sfixed64" json:"map_sfixed64_sfixed64,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
+	MapInt32Float           map[int32]float32                            `protobuf:"bytes,66,rep,name=map_int32_float,json=mapInt32Float" json:"map_int32_float,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
+	MapInt32Double          map[int32]float64                            `protobuf:"bytes,67,rep,name=map_int32_double,json=mapInt32Double" json:"map_int32_double,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
+	MapBoolBool             map[bool]bool                                `protobuf:"bytes,68,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"`
+	MapStringString         map[string]string                            `protobuf:"bytes,69,rep,name=map_string_string,json=mapStringString" json:"map_string_string,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+	MapStringBytes          map[string][]byte                            `protobuf:"bytes,70,rep,name=map_string_bytes,json=mapStringBytes" json:"map_string_bytes,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+	MapStringNestedMessage  map[string]*TestAllTypesProto2_NestedMessage `protobuf:"bytes,71,rep,name=map_string_nested_message,json=mapStringNestedMessage" json:"map_string_nested_message,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+	MapStringForeignMessage map[string]*ForeignMessageProto2             `protobuf:"bytes,72,rep,name=map_string_foreign_message,json=mapStringForeignMessage" json:"map_string_foreign_message,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+	MapStringNestedEnum     map[string]TestAllTypesProto2_NestedEnum     `protobuf:"bytes,73,rep,name=map_string_nested_enum,json=mapStringNestedEnum" json:"map_string_nested_enum,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=protobuf_test_messages.proto2.TestAllTypesProto2_NestedEnum"`
+	MapStringForeignEnum    map[string]ForeignEnumProto2                 `protobuf:"bytes,74,rep,name=map_string_foreign_enum,json=mapStringForeignEnum" json:"map_string_foreign_enum,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=protobuf_test_messages.proto2.ForeignEnumProto2"`
+	// Types that are assignable to OneofField:
+	//	*TestAllTypesProto2_OneofUint32
+	//	*TestAllTypesProto2_OneofNestedMessage
+	//	*TestAllTypesProto2_OneofString
+	//	*TestAllTypesProto2_OneofBytes
+	//	*TestAllTypesProto2_OneofBool
+	//	*TestAllTypesProto2_OneofUint64
+	//	*TestAllTypesProto2_OneofFloat
+	//	*TestAllTypesProto2_OneofDouble
+	//	*TestAllTypesProto2_OneofEnum
+	OneofField isTestAllTypesProto2_OneofField `protobuf_oneof:"oneof_field"`
+	Data       *TestAllTypesProto2_Data        `protobuf:"group,201,opt,name=Data,json=data" json:"data,omitempty"`
+	// Test field-name-to-JSON-name convention.
+	// (protobuf says names can be any valid C/C++ identifier.)
+	Fieldname1    *int32 `protobuf:"varint,401,opt,name=fieldname1" json:"fieldname1,omitempty"`
+	FieldName2    *int32 `protobuf:"varint,402,opt,name=field_name2,json=fieldName2" json:"field_name2,omitempty"`
+	XFieldName3   *int32 `protobuf:"varint,403,opt,name=_field_name3,json=FieldName3" json:"_field_name3,omitempty"`
+	Field_Name4_  *int32 `protobuf:"varint,404,opt,name=field__name4_,json=fieldName4" json:"field__name4_,omitempty"`
+	Field0Name5   *int32 `protobuf:"varint,405,opt,name=field0name5" json:"field0name5,omitempty"`
+	Field_0Name6  *int32 `protobuf:"varint,406,opt,name=field_0_name6,json=field0Name6" json:"field_0_name6,omitempty"`
+	FieldName7    *int32 `protobuf:"varint,407,opt,name=fieldName7" json:"fieldName7,omitempty"`
+	FieldName8    *int32 `protobuf:"varint,408,opt,name=FieldName8" json:"FieldName8,omitempty"`
+	Field_Name9   *int32 `protobuf:"varint,409,opt,name=field_Name9,json=fieldName9" json:"field_Name9,omitempty"`
+	Field_Name10  *int32 `protobuf:"varint,410,opt,name=Field_Name10,json=FieldName10" json:"Field_Name10,omitempty"`
+	FIELD_NAME11  *int32 `protobuf:"varint,411,opt,name=FIELD_NAME11,json=FIELDNAME11" json:"FIELD_NAME11,omitempty"`
+	FIELDName12   *int32 `protobuf:"varint,412,opt,name=FIELD_name12,json=FIELDName12" json:"FIELD_name12,omitempty"`
+	XFieldName13  *int32 `protobuf:"varint,413,opt,name=__field_name13,json=FieldName13" json:"__field_name13,omitempty"`
+	X_FieldName14 *int32 `protobuf:"varint,414,opt,name=__Field_name14,json=FieldName14" json:"__Field_name14,omitempty"`
+	Field_Name15  *int32 `protobuf:"varint,415,opt,name=field__name15,json=fieldName15" json:"field__name15,omitempty"`
+	Field__Name16 *int32 `protobuf:"varint,416,opt,name=field__Name16,json=fieldName16" json:"field__Name16,omitempty"`
+	FieldName17__ *int32 `protobuf:"varint,417,opt,name=field_name17__,json=fieldName17" json:"field_name17__,omitempty"`
+	FieldName18__ *int32 `protobuf:"varint,418,opt,name=Field_name18__,json=FieldName18" json:"Field_name18__,omitempty"`
+}
+
+func (x *TestAllTypesProto2) Reset() {
+	*x = TestAllTypesProto2{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_test_messages_proto2_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *TestAllTypesProto2) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TestAllTypesProto2) ProtoMessage() {}
+
+func (x *TestAllTypesProto2) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_test_messages_proto2_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TestAllTypesProto2.ProtoReflect.Descriptor instead.
+func (*TestAllTypesProto2) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_test_messages_proto2_proto_rawDescGZIP(), []int{0}
+}
+
+var extRange_TestAllTypesProto2 = []protoiface.ExtensionRangeV1{
+	{Start: 120, End: 200},
+}
+
+// Deprecated: Use TestAllTypesProto2.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*TestAllTypesProto2) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_TestAllTypesProto2
+}
+
+func (x *TestAllTypesProto2) GetOptionalInt32() int32 {
+	if x != nil && x.OptionalInt32 != nil {
+		return *x.OptionalInt32
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto2) GetOptionalInt64() int64 {
+	if x != nil && x.OptionalInt64 != nil {
+		return *x.OptionalInt64
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto2) GetOptionalUint32() uint32 {
+	if x != nil && x.OptionalUint32 != nil {
+		return *x.OptionalUint32
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto2) GetOptionalUint64() uint64 {
+	if x != nil && x.OptionalUint64 != nil {
+		return *x.OptionalUint64
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto2) GetOptionalSint32() int32 {
+	if x != nil && x.OptionalSint32 != nil {
+		return *x.OptionalSint32
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto2) GetOptionalSint64() int64 {
+	if x != nil && x.OptionalSint64 != nil {
+		return *x.OptionalSint64
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto2) GetOptionalFixed32() uint32 {
+	if x != nil && x.OptionalFixed32 != nil {
+		return *x.OptionalFixed32
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto2) GetOptionalFixed64() uint64 {
+	if x != nil && x.OptionalFixed64 != nil {
+		return *x.OptionalFixed64
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto2) GetOptionalSfixed32() int32 {
+	if x != nil && x.OptionalSfixed32 != nil {
+		return *x.OptionalSfixed32
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto2) GetOptionalSfixed64() int64 {
+	if x != nil && x.OptionalSfixed64 != nil {
+		return *x.OptionalSfixed64
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto2) GetOptionalFloat() float32 {
+	if x != nil && x.OptionalFloat != nil {
+		return *x.OptionalFloat
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto2) GetOptionalDouble() float64 {
+	if x != nil && x.OptionalDouble != nil {
+		return *x.OptionalDouble
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto2) GetOptionalBool() bool {
+	if x != nil && x.OptionalBool != nil {
+		return *x.OptionalBool
+	}
+	return false
+}
+
+func (x *TestAllTypesProto2) GetOptionalString() string {
+	if x != nil && x.OptionalString != nil {
+		return *x.OptionalString
+	}
+	return ""
+}
+
+func (x *TestAllTypesProto2) GetOptionalBytes() []byte {
+	if x != nil {
+		return x.OptionalBytes
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetOptionalNestedMessage() *TestAllTypesProto2_NestedMessage {
+	if x != nil {
+		return x.OptionalNestedMessage
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetOptionalForeignMessage() *ForeignMessageProto2 {
+	if x != nil {
+		return x.OptionalForeignMessage
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetOptionalNestedEnum() TestAllTypesProto2_NestedEnum {
+	if x != nil && x.OptionalNestedEnum != nil {
+		return *x.OptionalNestedEnum
+	}
+	return TestAllTypesProto2_FOO
+}
+
+func (x *TestAllTypesProto2) GetOptionalForeignEnum() ForeignEnumProto2 {
+	if x != nil && x.OptionalForeignEnum != nil {
+		return *x.OptionalForeignEnum
+	}
+	return ForeignEnumProto2_FOREIGN_FOO
+}
+
+func (x *TestAllTypesProto2) GetOptionalStringPiece() string {
+	if x != nil && x.OptionalStringPiece != nil {
+		return *x.OptionalStringPiece
+	}
+	return ""
+}
+
+func (x *TestAllTypesProto2) GetOptionalCord() string {
+	if x != nil && x.OptionalCord != nil {
+		return *x.OptionalCord
+	}
+	return ""
+}
+
+func (x *TestAllTypesProto2) GetRecursiveMessage() *TestAllTypesProto2 {
+	if x != nil {
+		return x.RecursiveMessage
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetRepeatedInt32() []int32 {
+	if x != nil {
+		return x.RepeatedInt32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetRepeatedInt64() []int64 {
+	if x != nil {
+		return x.RepeatedInt64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetRepeatedUint32() []uint32 {
+	if x != nil {
+		return x.RepeatedUint32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetRepeatedUint64() []uint64 {
+	if x != nil {
+		return x.RepeatedUint64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetRepeatedSint32() []int32 {
+	if x != nil {
+		return x.RepeatedSint32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetRepeatedSint64() []int64 {
+	if x != nil {
+		return x.RepeatedSint64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetRepeatedFixed32() []uint32 {
+	if x != nil {
+		return x.RepeatedFixed32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetRepeatedFixed64() []uint64 {
+	if x != nil {
+		return x.RepeatedFixed64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetRepeatedSfixed32() []int32 {
+	if x != nil {
+		return x.RepeatedSfixed32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetRepeatedSfixed64() []int64 {
+	if x != nil {
+		return x.RepeatedSfixed64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetRepeatedFloat() []float32 {
+	if x != nil {
+		return x.RepeatedFloat
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetRepeatedDouble() []float64 {
+	if x != nil {
+		return x.RepeatedDouble
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetRepeatedBool() []bool {
+	if x != nil {
+		return x.RepeatedBool
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetRepeatedString() []string {
+	if x != nil {
+		return x.RepeatedString
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetRepeatedBytes() [][]byte {
+	if x != nil {
+		return x.RepeatedBytes
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetRepeatedNestedMessage() []*TestAllTypesProto2_NestedMessage {
+	if x != nil {
+		return x.RepeatedNestedMessage
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetRepeatedForeignMessage() []*ForeignMessageProto2 {
+	if x != nil {
+		return x.RepeatedForeignMessage
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetRepeatedNestedEnum() []TestAllTypesProto2_NestedEnum {
+	if x != nil {
+		return x.RepeatedNestedEnum
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetRepeatedForeignEnum() []ForeignEnumProto2 {
+	if x != nil {
+		return x.RepeatedForeignEnum
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetRepeatedStringPiece() []string {
+	if x != nil {
+		return x.RepeatedStringPiece
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetRepeatedCord() []string {
+	if x != nil {
+		return x.RepeatedCord
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetPackedInt32() []int32 {
+	if x != nil {
+		return x.PackedInt32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetPackedInt64() []int64 {
+	if x != nil {
+		return x.PackedInt64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetPackedUint32() []uint32 {
+	if x != nil {
+		return x.PackedUint32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetPackedUint64() []uint64 {
+	if x != nil {
+		return x.PackedUint64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetPackedSint32() []int32 {
+	if x != nil {
+		return x.PackedSint32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetPackedSint64() []int64 {
+	if x != nil {
+		return x.PackedSint64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetPackedFixed32() []uint32 {
+	if x != nil {
+		return x.PackedFixed32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetPackedFixed64() []uint64 {
+	if x != nil {
+		return x.PackedFixed64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetPackedSfixed32() []int32 {
+	if x != nil {
+		return x.PackedSfixed32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetPackedSfixed64() []int64 {
+	if x != nil {
+		return x.PackedSfixed64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetPackedFloat() []float32 {
+	if x != nil {
+		return x.PackedFloat
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetPackedDouble() []float64 {
+	if x != nil {
+		return x.PackedDouble
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetPackedBool() []bool {
+	if x != nil {
+		return x.PackedBool
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetPackedNestedEnum() []TestAllTypesProto2_NestedEnum {
+	if x != nil {
+		return x.PackedNestedEnum
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetUnpackedInt32() []int32 {
+	if x != nil {
+		return x.UnpackedInt32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetUnpackedInt64() []int64 {
+	if x != nil {
+		return x.UnpackedInt64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetUnpackedUint32() []uint32 {
+	if x != nil {
+		return x.UnpackedUint32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetUnpackedUint64() []uint64 {
+	if x != nil {
+		return x.UnpackedUint64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetUnpackedSint32() []int32 {
+	if x != nil {
+		return x.UnpackedSint32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetUnpackedSint64() []int64 {
+	if x != nil {
+		return x.UnpackedSint64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetUnpackedFixed32() []uint32 {
+	if x != nil {
+		return x.UnpackedFixed32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetUnpackedFixed64() []uint64 {
+	if x != nil {
+		return x.UnpackedFixed64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetUnpackedSfixed32() []int32 {
+	if x != nil {
+		return x.UnpackedSfixed32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetUnpackedSfixed64() []int64 {
+	if x != nil {
+		return x.UnpackedSfixed64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetUnpackedFloat() []float32 {
+	if x != nil {
+		return x.UnpackedFloat
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetUnpackedDouble() []float64 {
+	if x != nil {
+		return x.UnpackedDouble
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetUnpackedBool() []bool {
+	if x != nil {
+		return x.UnpackedBool
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetUnpackedNestedEnum() []TestAllTypesProto2_NestedEnum {
+	if x != nil {
+		return x.UnpackedNestedEnum
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetMapInt32Int32() map[int32]int32 {
+	if x != nil {
+		return x.MapInt32Int32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetMapInt64Int64() map[int64]int64 {
+	if x != nil {
+		return x.MapInt64Int64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetMapUint32Uint32() map[uint32]uint32 {
+	if x != nil {
+		return x.MapUint32Uint32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetMapUint64Uint64() map[uint64]uint64 {
+	if x != nil {
+		return x.MapUint64Uint64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetMapSint32Sint32() map[int32]int32 {
+	if x != nil {
+		return x.MapSint32Sint32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetMapSint64Sint64() map[int64]int64 {
+	if x != nil {
+		return x.MapSint64Sint64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetMapFixed32Fixed32() map[uint32]uint32 {
+	if x != nil {
+		return x.MapFixed32Fixed32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetMapFixed64Fixed64() map[uint64]uint64 {
+	if x != nil {
+		return x.MapFixed64Fixed64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetMapSfixed32Sfixed32() map[int32]int32 {
+	if x != nil {
+		return x.MapSfixed32Sfixed32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetMapSfixed64Sfixed64() map[int64]int64 {
+	if x != nil {
+		return x.MapSfixed64Sfixed64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetMapInt32Float() map[int32]float32 {
+	if x != nil {
+		return x.MapInt32Float
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetMapInt32Double() map[int32]float64 {
+	if x != nil {
+		return x.MapInt32Double
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetMapBoolBool() map[bool]bool {
+	if x != nil {
+		return x.MapBoolBool
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetMapStringString() map[string]string {
+	if x != nil {
+		return x.MapStringString
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetMapStringBytes() map[string][]byte {
+	if x != nil {
+		return x.MapStringBytes
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetMapStringNestedMessage() map[string]*TestAllTypesProto2_NestedMessage {
+	if x != nil {
+		return x.MapStringNestedMessage
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetMapStringForeignMessage() map[string]*ForeignMessageProto2 {
+	if x != nil {
+		return x.MapStringForeignMessage
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetMapStringNestedEnum() map[string]TestAllTypesProto2_NestedEnum {
+	if x != nil {
+		return x.MapStringNestedEnum
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetMapStringForeignEnum() map[string]ForeignEnumProto2 {
+	if x != nil {
+		return x.MapStringForeignEnum
+	}
+	return nil
+}
+
+func (m *TestAllTypesProto2) GetOneofField() isTestAllTypesProto2_OneofField {
+	if m != nil {
+		return m.OneofField
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetOneofUint32() uint32 {
+	if x, ok := x.GetOneofField().(*TestAllTypesProto2_OneofUint32); ok {
+		return x.OneofUint32
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto2) GetOneofNestedMessage() *TestAllTypesProto2_NestedMessage {
+	if x, ok := x.GetOneofField().(*TestAllTypesProto2_OneofNestedMessage); ok {
+		return x.OneofNestedMessage
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetOneofString() string {
+	if x, ok := x.GetOneofField().(*TestAllTypesProto2_OneofString); ok {
+		return x.OneofString
+	}
+	return ""
+}
+
+func (x *TestAllTypesProto2) GetOneofBytes() []byte {
+	if x, ok := x.GetOneofField().(*TestAllTypesProto2_OneofBytes); ok {
+		return x.OneofBytes
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetOneofBool() bool {
+	if x, ok := x.GetOneofField().(*TestAllTypesProto2_OneofBool); ok {
+		return x.OneofBool
+	}
+	return false
+}
+
+func (x *TestAllTypesProto2) GetOneofUint64() uint64 {
+	if x, ok := x.GetOneofField().(*TestAllTypesProto2_OneofUint64); ok {
+		return x.OneofUint64
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto2) GetOneofFloat() float32 {
+	if x, ok := x.GetOneofField().(*TestAllTypesProto2_OneofFloat); ok {
+		return x.OneofFloat
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto2) GetOneofDouble() float64 {
+	if x, ok := x.GetOneofField().(*TestAllTypesProto2_OneofDouble); ok {
+		return x.OneofDouble
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto2) GetOneofEnum() TestAllTypesProto2_NestedEnum {
+	if x, ok := x.GetOneofField().(*TestAllTypesProto2_OneofEnum); ok {
+		return x.OneofEnum
+	}
+	return TestAllTypesProto2_FOO
+}
+
+func (x *TestAllTypesProto2) GetData() *TestAllTypesProto2_Data {
+	if x != nil {
+		return x.Data
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto2) GetFieldname1() int32 {
+	if x != nil && x.Fieldname1 != nil {
+		return *x.Fieldname1
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto2) GetFieldName2() int32 {
+	if x != nil && x.FieldName2 != nil {
+		return *x.FieldName2
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto2) GetXFieldName3() int32 {
+	if x != nil && x.XFieldName3 != nil {
+		return *x.XFieldName3
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto2) GetField_Name4_() int32 {
+	if x != nil && x.Field_Name4_ != nil {
+		return *x.Field_Name4_
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto2) GetField0Name5() int32 {
+	if x != nil && x.Field0Name5 != nil {
+		return *x.Field0Name5
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto2) GetField_0Name6() int32 {
+	if x != nil && x.Field_0Name6 != nil {
+		return *x.Field_0Name6
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto2) GetFieldName7() int32 {
+	if x != nil && x.FieldName7 != nil {
+		return *x.FieldName7
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto2) GetFieldName8() int32 {
+	if x != nil && x.FieldName8 != nil {
+		return *x.FieldName8
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto2) GetField_Name9() int32 {
+	if x != nil && x.Field_Name9 != nil {
+		return *x.Field_Name9
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto2) GetField_Name10() int32 {
+	if x != nil && x.Field_Name10 != nil {
+		return *x.Field_Name10
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto2) GetFIELD_NAME11() int32 {
+	if x != nil && x.FIELD_NAME11 != nil {
+		return *x.FIELD_NAME11
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto2) GetFIELDName12() int32 {
+	if x != nil && x.FIELDName12 != nil {
+		return *x.FIELDName12
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto2) GetXFieldName13() int32 {
+	if x != nil && x.XFieldName13 != nil {
+		return *x.XFieldName13
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto2) GetX_FieldName14() int32 {
+	if x != nil && x.X_FieldName14 != nil {
+		return *x.X_FieldName14
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto2) GetField_Name15() int32 {
+	if x != nil && x.Field_Name15 != nil {
+		return *x.Field_Name15
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto2) GetField__Name16() int32 {
+	if x != nil && x.Field__Name16 != nil {
+		return *x.Field__Name16
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto2) GetFieldName17__() int32 {
+	if x != nil && x.FieldName17__ != nil {
+		return *x.FieldName17__
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto2) GetFieldName18__() int32 {
+	if x != nil && x.FieldName18__ != nil {
+		return *x.FieldName18__
+	}
+	return 0
+}
+
+type isTestAllTypesProto2_OneofField interface {
+	isTestAllTypesProto2_OneofField()
+}
+
+type TestAllTypesProto2_OneofUint32 struct {
+	OneofUint32 uint32 `protobuf:"varint,111,opt,name=oneof_uint32,json=oneofUint32,oneof"`
+}
+
+type TestAllTypesProto2_OneofNestedMessage struct {
+	OneofNestedMessage *TestAllTypesProto2_NestedMessage `protobuf:"bytes,112,opt,name=oneof_nested_message,json=oneofNestedMessage,oneof"`
+}
+
+type TestAllTypesProto2_OneofString struct {
+	OneofString string `protobuf:"bytes,113,opt,name=oneof_string,json=oneofString,oneof"`
+}
+
+type TestAllTypesProto2_OneofBytes struct {
+	OneofBytes []byte `protobuf:"bytes,114,opt,name=oneof_bytes,json=oneofBytes,oneof"`
+}
+
+type TestAllTypesProto2_OneofBool struct {
+	OneofBool bool `protobuf:"varint,115,opt,name=oneof_bool,json=oneofBool,oneof"`
+}
+
+type TestAllTypesProto2_OneofUint64 struct {
+	OneofUint64 uint64 `protobuf:"varint,116,opt,name=oneof_uint64,json=oneofUint64,oneof"`
+}
+
+type TestAllTypesProto2_OneofFloat struct {
+	OneofFloat float32 `protobuf:"fixed32,117,opt,name=oneof_float,json=oneofFloat,oneof"`
+}
+
+type TestAllTypesProto2_OneofDouble struct {
+	OneofDouble float64 `protobuf:"fixed64,118,opt,name=oneof_double,json=oneofDouble,oneof"`
+}
+
+type TestAllTypesProto2_OneofEnum struct {
+	OneofEnum TestAllTypesProto2_NestedEnum `protobuf:"varint,119,opt,name=oneof_enum,json=oneofEnum,enum=protobuf_test_messages.proto2.TestAllTypesProto2_NestedEnum,oneof"`
+}
+
+func (*TestAllTypesProto2_OneofUint32) isTestAllTypesProto2_OneofField() {}
+
+func (*TestAllTypesProto2_OneofNestedMessage) isTestAllTypesProto2_OneofField() {}
+
+func (*TestAllTypesProto2_OneofString) isTestAllTypesProto2_OneofField() {}
+
+func (*TestAllTypesProto2_OneofBytes) isTestAllTypesProto2_OneofField() {}
+
+func (*TestAllTypesProto2_OneofBool) isTestAllTypesProto2_OneofField() {}
+
+func (*TestAllTypesProto2_OneofUint64) isTestAllTypesProto2_OneofField() {}
+
+func (*TestAllTypesProto2_OneofFloat) isTestAllTypesProto2_OneofField() {}
+
+func (*TestAllTypesProto2_OneofDouble) isTestAllTypesProto2_OneofField() {}
+
+func (*TestAllTypesProto2_OneofEnum) isTestAllTypesProto2_OneofField() {}
+
+type ForeignMessageProto2 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	C *int32 `protobuf:"varint,1,opt,name=c" json:"c,omitempty"`
+}
+
+func (x *ForeignMessageProto2) Reset() {
+	*x = ForeignMessageProto2{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_test_messages_proto2_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *ForeignMessageProto2) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ForeignMessageProto2) ProtoMessage() {}
+
+func (x *ForeignMessageProto2) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_test_messages_proto2_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ForeignMessageProto2.ProtoReflect.Descriptor instead.
+func (*ForeignMessageProto2) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_test_messages_proto2_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *ForeignMessageProto2) GetC() int32 {
+	if x != nil && x.C != nil {
+		return *x.C
+	}
+	return 0
+}
+
+type UnknownToTestAllTypes struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	OptionalInt32  *int32                               `protobuf:"varint,1001,opt,name=optional_int32,json=optionalInt32" json:"optional_int32,omitempty"`
+	OptionalString *string                              `protobuf:"bytes,1002,opt,name=optional_string,json=optionalString" json:"optional_string,omitempty"`
+	NestedMessage  *ForeignMessageProto2                `protobuf:"bytes,1003,opt,name=nested_message,json=nestedMessage" json:"nested_message,omitempty"`
+	Optionalgroup  *UnknownToTestAllTypes_OptionalGroup `protobuf:"group,1004,opt,name=OptionalGroup,json=optionalgroup" json:"optionalgroup,omitempty"`
+	OptionalBool   *bool                                `protobuf:"varint,1006,opt,name=optional_bool,json=optionalBool" json:"optional_bool,omitempty"`
+	RepeatedInt32  []int32                              `protobuf:"varint,1011,rep,name=repeated_int32,json=repeatedInt32" json:"repeated_int32,omitempty"`
+}
+
+func (x *UnknownToTestAllTypes) Reset() {
+	*x = UnknownToTestAllTypes{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_test_messages_proto2_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *UnknownToTestAllTypes) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*UnknownToTestAllTypes) ProtoMessage() {}
+
+func (x *UnknownToTestAllTypes) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_test_messages_proto2_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use UnknownToTestAllTypes.ProtoReflect.Descriptor instead.
+func (*UnknownToTestAllTypes) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_test_messages_proto2_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *UnknownToTestAllTypes) GetOptionalInt32() int32 {
+	if x != nil && x.OptionalInt32 != nil {
+		return *x.OptionalInt32
+	}
+	return 0
+}
+
+func (x *UnknownToTestAllTypes) GetOptionalString() string {
+	if x != nil && x.OptionalString != nil {
+		return *x.OptionalString
+	}
+	return ""
+}
+
+func (x *UnknownToTestAllTypes) GetNestedMessage() *ForeignMessageProto2 {
+	if x != nil {
+		return x.NestedMessage
+	}
+	return nil
+}
+
+func (x *UnknownToTestAllTypes) GetOptionalgroup() *UnknownToTestAllTypes_OptionalGroup {
+	if x != nil {
+		return x.Optionalgroup
+	}
+	return nil
+}
+
+func (x *UnknownToTestAllTypes) GetOptionalBool() bool {
+	if x != nil && x.OptionalBool != nil {
+		return *x.OptionalBool
+	}
+	return false
+}
+
+func (x *UnknownToTestAllTypes) GetRepeatedInt32() []int32 {
+	if x != nil {
+		return x.RepeatedInt32
+	}
+	return nil
+}
+
+type TestAllTypesProto2_NestedMessage struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	A           *int32              `protobuf:"varint,1,opt,name=a" json:"a,omitempty"`
+	Corecursive *TestAllTypesProto2 `protobuf:"bytes,2,opt,name=corecursive" json:"corecursive,omitempty"`
+}
+
+func (x *TestAllTypesProto2_NestedMessage) Reset() {
+	*x = TestAllTypesProto2_NestedMessage{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_test_messages_proto2_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *TestAllTypesProto2_NestedMessage) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TestAllTypesProto2_NestedMessage) ProtoMessage() {}
+
+func (x *TestAllTypesProto2_NestedMessage) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_test_messages_proto2_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TestAllTypesProto2_NestedMessage.ProtoReflect.Descriptor instead.
+func (*TestAllTypesProto2_NestedMessage) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_test_messages_proto2_proto_rawDescGZIP(), []int{0, 0}
+}
+
+func (x *TestAllTypesProto2_NestedMessage) GetA() int32 {
+	if x != nil && x.A != nil {
+		return *x.A
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto2_NestedMessage) GetCorecursive() *TestAllTypesProto2 {
+	if x != nil {
+		return x.Corecursive
+	}
+	return nil
+}
+
+// groups
+type TestAllTypesProto2_Data struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	GroupInt32  *int32  `protobuf:"varint,202,opt,name=group_int32,json=groupInt32" json:"group_int32,omitempty"`
+	GroupUint32 *uint32 `protobuf:"varint,203,opt,name=group_uint32,json=groupUint32" json:"group_uint32,omitempty"`
+}
+
+func (x *TestAllTypesProto2_Data) Reset() {
+	*x = TestAllTypesProto2_Data{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_test_messages_proto2_proto_msgTypes[23]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *TestAllTypesProto2_Data) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TestAllTypesProto2_Data) ProtoMessage() {}
+
+func (x *TestAllTypesProto2_Data) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_test_messages_proto2_proto_msgTypes[23]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TestAllTypesProto2_Data.ProtoReflect.Descriptor instead.
+func (*TestAllTypesProto2_Data) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_test_messages_proto2_proto_rawDescGZIP(), []int{0, 20}
+}
+
+func (x *TestAllTypesProto2_Data) GetGroupInt32() int32 {
+	if x != nil && x.GroupInt32 != nil {
+		return *x.GroupInt32
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto2_Data) GetGroupUint32() uint32 {
+	if x != nil && x.GroupUint32 != nil {
+		return *x.GroupUint32
+	}
+	return 0
+}
+
+// message_set test case.
+type TestAllTypesProto2_MessageSetCorrect struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+}
+
+func (x *TestAllTypesProto2_MessageSetCorrect) Reset() {
+	*x = TestAllTypesProto2_MessageSetCorrect{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_test_messages_proto2_proto_msgTypes[24]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *TestAllTypesProto2_MessageSetCorrect) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TestAllTypesProto2_MessageSetCorrect) ProtoMessage() {}
+
+func (x *TestAllTypesProto2_MessageSetCorrect) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_test_messages_proto2_proto_msgTypes[24]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TestAllTypesProto2_MessageSetCorrect.ProtoReflect.Descriptor instead.
+func (*TestAllTypesProto2_MessageSetCorrect) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_test_messages_proto2_proto_rawDescGZIP(), []int{0, 21}
+}
+
+var extRange_TestAllTypesProto2_MessageSetCorrect = []protoiface.ExtensionRangeV1{
+	{Start: 4, End: 2147483646},
+}
+
+// Deprecated: Use TestAllTypesProto2_MessageSetCorrect.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*TestAllTypesProto2_MessageSetCorrect) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_TestAllTypesProto2_MessageSetCorrect
+}
+
+type TestAllTypesProto2_MessageSetCorrectExtension1 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Str *string `protobuf:"bytes,25,opt,name=str" json:"str,omitempty"`
+}
+
+func (x *TestAllTypesProto2_MessageSetCorrectExtension1) Reset() {
+	*x = TestAllTypesProto2_MessageSetCorrectExtension1{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_test_messages_proto2_proto_msgTypes[25]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *TestAllTypesProto2_MessageSetCorrectExtension1) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TestAllTypesProto2_MessageSetCorrectExtension1) ProtoMessage() {}
+
+func (x *TestAllTypesProto2_MessageSetCorrectExtension1) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_test_messages_proto2_proto_msgTypes[25]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TestAllTypesProto2_MessageSetCorrectExtension1.ProtoReflect.Descriptor instead.
+func (*TestAllTypesProto2_MessageSetCorrectExtension1) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_test_messages_proto2_proto_rawDescGZIP(), []int{0, 22}
+}
+
+func (x *TestAllTypesProto2_MessageSetCorrectExtension1) GetStr() string {
+	if x != nil && x.Str != nil {
+		return *x.Str
+	}
+	return ""
+}
+
+type TestAllTypesProto2_MessageSetCorrectExtension2 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	I *int32 `protobuf:"varint,9,opt,name=i" json:"i,omitempty"`
+}
+
+func (x *TestAllTypesProto2_MessageSetCorrectExtension2) Reset() {
+	*x = TestAllTypesProto2_MessageSetCorrectExtension2{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_test_messages_proto2_proto_msgTypes[26]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *TestAllTypesProto2_MessageSetCorrectExtension2) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TestAllTypesProto2_MessageSetCorrectExtension2) ProtoMessage() {}
+
+func (x *TestAllTypesProto2_MessageSetCorrectExtension2) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_test_messages_proto2_proto_msgTypes[26]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TestAllTypesProto2_MessageSetCorrectExtension2.ProtoReflect.Descriptor instead.
+func (*TestAllTypesProto2_MessageSetCorrectExtension2) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_test_messages_proto2_proto_rawDescGZIP(), []int{0, 23}
+}
+
+func (x *TestAllTypesProto2_MessageSetCorrectExtension2) GetI() int32 {
+	if x != nil && x.I != nil {
+		return *x.I
+	}
+	return 0
+}
+
+type UnknownToTestAllTypes_OptionalGroup struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	A *int32 `protobuf:"varint,1,opt,name=a" json:"a,omitempty"`
+}
+
+func (x *UnknownToTestAllTypes_OptionalGroup) Reset() {
+	*x = UnknownToTestAllTypes_OptionalGroup{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_test_messages_proto2_proto_msgTypes[27]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *UnknownToTestAllTypes_OptionalGroup) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*UnknownToTestAllTypes_OptionalGroup) ProtoMessage() {}
+
+func (x *UnknownToTestAllTypes_OptionalGroup) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_test_messages_proto2_proto_msgTypes[27]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use UnknownToTestAllTypes_OptionalGroup.ProtoReflect.Descriptor instead.
+func (*UnknownToTestAllTypes_OptionalGroup) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_test_messages_proto2_proto_rawDescGZIP(), []int{2, 0}
+}
+
+func (x *UnknownToTestAllTypes_OptionalGroup) GetA() int32 {
+	if x != nil && x.A != nil {
+		return *x.A
+	}
+	return 0
+}
+
+var file_google_protobuf_test_messages_proto2_proto_extTypes = []protoimpl.ExtensionInfo{
+	{
+		ExtendedType:  (*TestAllTypesProto2)(nil),
+		ExtensionType: (*int32)(nil),
+		Field:         120,
+		Name:          "protobuf_test_messages.proto2.extension_int32",
+		Tag:           "varint,120,opt,name=extension_int32",
+		Filename:      "google/protobuf/test_messages_proto2.proto",
+	},
+	{
+		ExtendedType:  (*TestAllTypesProto2_MessageSetCorrect)(nil),
+		ExtensionType: (*TestAllTypesProto2_MessageSetCorrectExtension1)(nil),
+		Field:         1547769,
+		Name:          "protobuf_test_messages.proto2.TestAllTypesProto2.MessageSetCorrectExtension1",
+		Tag:           "bytes,1547769,opt,name=message_set_extension",
+		Filename:      "google/protobuf/test_messages_proto2.proto",
+	},
+	{
+		ExtendedType:  (*TestAllTypesProto2_MessageSetCorrect)(nil),
+		ExtensionType: (*TestAllTypesProto2_MessageSetCorrectExtension2)(nil),
+		Field:         4135312,
+		Name:          "protobuf_test_messages.proto2.TestAllTypesProto2.MessageSetCorrectExtension2",
+		Tag:           "bytes,4135312,opt,name=message_set_extension",
+		Filename:      "google/protobuf/test_messages_proto2.proto",
+	},
+}
+
+// Extension fields to TestAllTypesProto2.
+var (
+	// optional int32 extension_int32 = 120;
+	E_ExtensionInt32 = &file_google_protobuf_test_messages_proto2_proto_extTypes[0]
+)
+
+// Extension fields to TestAllTypesProto2_MessageSetCorrect.
+var (
+	// optional protobuf_test_messages.proto2.TestAllTypesProto2.MessageSetCorrectExtension1 message_set_extension = 1547769;
+	E_TestAllTypesProto2_MessageSetCorrectExtension1_MessageSetExtension = &file_google_protobuf_test_messages_proto2_proto_extTypes[1]
+	// optional protobuf_test_messages.proto2.TestAllTypesProto2.MessageSetCorrectExtension2 message_set_extension = 4135312;
+	E_TestAllTypesProto2_MessageSetCorrectExtension2_MessageSetExtension = &file_google_protobuf_test_messages_proto2_proto_extTypes[2]
+)
+
+var File_google_protobuf_test_messages_proto2_proto protoreflect.FileDescriptor
+
+var file_google_protobuf_test_messages_proto2_proto_rawDesc = []byte{
+	0x0a, 0x2a, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x5f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1d, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x22, 0x92, 0x4b, 0x0a, 0x12,
+	0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74,
+	0x6f, 0x32, 0x12, 0x25, 0x0a, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x69,
+	0x6e, 0x74, 0x33, 0x32, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x61, 0x6c, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x25, 0x0a, 0x0e, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x03, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x49, 0x6e, 0x74, 0x36, 0x34,
+	0x12, 0x27, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x75, 0x69, 0x6e,
+	0x74, 0x33, 0x32, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x27, 0x0a, 0x0f, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x04, 0x20, 0x01,
+	0x28, 0x04, 0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x55, 0x69, 0x6e, 0x74,
+	0x36, 0x34, 0x12, 0x27, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x73,
+	0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x05, 0x20, 0x01, 0x28, 0x11, 0x52, 0x0e, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x27, 0x0a, 0x0f, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x06,
+	0x20, 0x01, 0x28, 0x12, 0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x69,
+	0x6e, 0x74, 0x36, 0x34, 0x12, 0x29, 0x0a, 0x10, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x07, 0x20, 0x01, 0x28, 0x07, 0x52, 0x0f,
+	0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12,
+	0x29, 0x0a, 0x10, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x66, 0x69, 0x78, 0x65,
+	0x64, 0x36, 0x34, 0x18, 0x08, 0x20, 0x01, 0x28, 0x06, 0x52, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x2b, 0x0a, 0x11, 0x6f, 0x70,
+	0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18,
+	0x09, 0x20, 0x01, 0x28, 0x0f, 0x52, 0x10, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53,
+	0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x2b, 0x0a, 0x11, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x0a, 0x20, 0x01,
+	0x28, 0x10, 0x52, 0x10, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x66, 0x69, 0x78,
+	0x65, 0x64, 0x36, 0x34, 0x12, 0x25, 0x0a, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0d, 0x6f, 0x70,
+	0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0x0c,
+	0x20, 0x01, 0x28, 0x01, 0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x44, 0x6f,
+	0x75, 0x62, 0x6c, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x27, 0x0a, 0x0f, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x0e, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x74, 0x72, 0x69,
+	0x6e, 0x67, 0x12, 0x25, 0x0a, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x62,
+	0x79, 0x74, 0x65, 0x73, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x61, 0x6c, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x77, 0x0a, 0x17, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x18, 0x12, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x3f, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41,
+	0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x4e, 0x65,
+	0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x15, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x12, 0x6d, 0x0a, 0x18, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x66,
+	0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x13,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x33, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f,
+	0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x52, 0x16, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x12, 0x6e, 0x0a, 0x14, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x6e, 0x65,
+	0x73, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x15, 0x20, 0x01, 0x28, 0x0e, 0x32,
+	0x3c, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e,
+	0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74,
+	0x6f, 0x32, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x12, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75,
+	0x6d, 0x12, 0x64, 0x0a, 0x15, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x66, 0x6f,
+	0x72, 0x65, 0x69, 0x67, 0x6e, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x16, 0x20, 0x01, 0x28, 0x0e,
+	0x32, 0x30, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32,
+	0x2e, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x45, 0x6e, 0x75, 0x6d, 0x50, 0x72, 0x6f, 0x74,
+	0x6f, 0x32, 0x52, 0x13, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x46, 0x6f, 0x72, 0x65,
+	0x69, 0x67, 0x6e, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x36, 0x0a, 0x15, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x69, 0x65, 0x63, 0x65,
+	0x18, 0x18, 0x20, 0x01, 0x28, 0x09, 0x42, 0x02, 0x08, 0x02, 0x52, 0x13, 0x6f, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x50, 0x69, 0x65, 0x63, 0x65, 0x12,
+	0x27, 0x0a, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x63, 0x6f, 0x72, 0x64,
+	0x18, 0x19, 0x20, 0x01, 0x28, 0x09, 0x42, 0x02, 0x08, 0x01, 0x52, 0x0c, 0x6f, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x61, 0x6c, 0x43, 0x6f, 0x72, 0x64, 0x12, 0x5e, 0x0a, 0x11, 0x72, 0x65, 0x63, 0x75,
+	0x72, 0x73, 0x69, 0x76, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x1b, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74,
+	0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x32, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73,
+	0x50, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x52, 0x10, 0x72, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x76,
+	0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x70, 0x65,
+	0x61, 0x74, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x1f, 0x20, 0x03, 0x28, 0x05,
+	0x52, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12,
+	0x25, 0x0a, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x74, 0x36,
+	0x34, 0x18, 0x20, 0x20, 0x03, 0x28, 0x03, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65,
+	0x64, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74,
+	0x65, 0x64, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x21, 0x20, 0x03, 0x28, 0x0d, 0x52,
+	0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12,
+	0x27, 0x0a, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x75, 0x69, 0x6e, 0x74,
+	0x36, 0x34, 0x18, 0x22, 0x20, 0x03, 0x28, 0x04, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74,
+	0x65, 0x64, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x70, 0x65,
+	0x61, 0x74, 0x65, 0x64, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x23, 0x20, 0x03, 0x28,
+	0x11, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x53, 0x69, 0x6e, 0x74, 0x33,
+	0x32, 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x73, 0x69,
+	0x6e, 0x74, 0x36, 0x34, 0x18, 0x24, 0x20, 0x03, 0x28, 0x12, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65,
+	0x61, 0x74, 0x65, 0x64, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x29, 0x0a, 0x10, 0x72, 0x65,
+	0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x25,
+	0x20, 0x03, 0x28, 0x07, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x46, 0x69,
+	0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x29, 0x0a, 0x10, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65,
+	0x64, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x26, 0x20, 0x03, 0x28, 0x06, 0x52,
+	0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34,
+	0x12, 0x2b, 0x0a, 0x11, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x73, 0x66, 0x69,
+	0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x27, 0x20, 0x03, 0x28, 0x0f, 0x52, 0x10, 0x72, 0x65, 0x70,
+	0x65, 0x61, 0x74, 0x65, 0x64, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x2b, 0x0a,
+	0x11, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64,
+	0x36, 0x34, 0x18, 0x28, 0x20, 0x03, 0x28, 0x10, 0x52, 0x10, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74,
+	0x65, 0x64, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65,
+	0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x18, 0x29, 0x20, 0x03,
+	0x28, 0x02, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x46, 0x6c, 0x6f, 0x61,
+	0x74, 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x64, 0x6f,
+	0x75, 0x62, 0x6c, 0x65, 0x18, 0x2a, 0x20, 0x03, 0x28, 0x01, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65,
+	0x61, 0x74, 0x65, 0x64, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65,
+	0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18, 0x2b, 0x20, 0x03, 0x28,
+	0x08, 0x52, 0x0c, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x42, 0x6f, 0x6f, 0x6c, 0x12,
+	0x27, 0x0a, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x73, 0x74, 0x72, 0x69,
+	0x6e, 0x67, 0x18, 0x2c, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74,
+	0x65, 0x64, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x70, 0x65,
+	0x61, 0x74, 0x65, 0x64, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x2d, 0x20, 0x03, 0x28, 0x0c,
+	0x52, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12,
+	0x77, 0x0a, 0x17, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x6e, 0x65, 0x73, 0x74,
+	0x65, 0x64, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x30, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x3f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32,
+	0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f,
+	0x74, 0x6f, 0x32, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x52, 0x15, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x4e, 0x65, 0x73, 0x74, 0x65,
+	0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x6d, 0x0a, 0x18, 0x72, 0x65, 0x70, 0x65,
+	0x61, 0x74, 0x65, 0x64, 0x5f, 0x66, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x18, 0x31, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x33, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x46, 0x6f, 0x72, 0x65, 0x69,
+	0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x52,
+	0x16, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x6e, 0x0a, 0x14, 0x72, 0x65, 0x70, 0x65, 0x61,
+	0x74, 0x65, 0x64, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18,
+	0x33, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x3c, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
+	0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70,
+	0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45,
+	0x6e, 0x75, 0x6d, 0x52, 0x12, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x4e, 0x65, 0x73,
+	0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x64, 0x0a, 0x15, 0x72, 0x65, 0x70, 0x65, 0x61,
+	0x74, 0x65, 0x64, 0x5f, 0x66, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x5f, 0x65, 0x6e, 0x75, 0x6d,
+	0x18, 0x34, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x30, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x45, 0x6e,
+	0x75, 0x6d, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x52, 0x13, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74,
+	0x65, 0x64, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x36, 0x0a,
+	0x15, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67,
+	0x5f, 0x70, 0x69, 0x65, 0x63, 0x65, 0x18, 0x36, 0x20, 0x03, 0x28, 0x09, 0x42, 0x02, 0x08, 0x02,
+	0x52, 0x13, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67,
+	0x50, 0x69, 0x65, 0x63, 0x65, 0x12, 0x27, 0x0a, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65,
+	0x64, 0x5f, 0x63, 0x6f, 0x72, 0x64, 0x18, 0x37, 0x20, 0x03, 0x28, 0x09, 0x42, 0x02, 0x08, 0x01,
+	0x52, 0x0c, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x43, 0x6f, 0x72, 0x64, 0x12, 0x25,
+	0x0a, 0x0c, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x4b,
+	0x20, 0x03, 0x28, 0x05, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0b, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64,
+	0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x25, 0x0a, 0x0c, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f,
+	0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x4c, 0x20, 0x03, 0x28, 0x03, 0x42, 0x02, 0x10, 0x01, 0x52,
+	0x0b, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x27, 0x0a, 0x0d,
+	0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x4d, 0x20,
+	0x03, 0x28, 0x0d, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0c, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x55,
+	0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x27, 0x0a, 0x0d, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f,
+	0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x4e, 0x20, 0x03, 0x28, 0x04, 0x42, 0x02, 0x10, 0x01,
+	0x52, 0x0c, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x27,
+	0x0a, 0x0d, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18,
+	0x4f, 0x20, 0x03, 0x28, 0x11, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0c, 0x70, 0x61, 0x63, 0x6b, 0x65,
+	0x64, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x27, 0x0a, 0x0d, 0x70, 0x61, 0x63, 0x6b, 0x65,
+	0x64, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x50, 0x20, 0x03, 0x28, 0x12, 0x42, 0x02,
+	0x10, 0x01, 0x52, 0x0c, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34,
+	0x12, 0x29, 0x0a, 0x0e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64,
+	0x33, 0x32, 0x18, 0x51, 0x20, 0x03, 0x28, 0x07, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0d, 0x70, 0x61,
+	0x63, 0x6b, 0x65, 0x64, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x29, 0x0a, 0x0e, 0x70,
+	0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x52, 0x20,
+	0x03, 0x28, 0x06, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0d, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x46,
+	0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x2b, 0x0a, 0x0f, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64,
+	0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x53, 0x20, 0x03, 0x28, 0x0f, 0x42,
+	0x02, 0x10, 0x01, 0x52, 0x0e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x53, 0x66, 0x69, 0x78, 0x65,
+	0x64, 0x33, 0x32, 0x12, 0x2b, 0x0a, 0x0f, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x73, 0x66,
+	0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x54, 0x20, 0x03, 0x28, 0x10, 0x42, 0x02, 0x10, 0x01,
+	0x52, 0x0e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34,
+	0x12, 0x25, 0x0a, 0x0c, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74,
+	0x18, 0x55, 0x20, 0x03, 0x28, 0x02, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0b, 0x70, 0x61, 0x63, 0x6b,
+	0x65, 0x64, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x27, 0x0a, 0x0d, 0x70, 0x61, 0x63, 0x6b, 0x65,
+	0x64, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0x56, 0x20, 0x03, 0x28, 0x01, 0x42, 0x02,
+	0x10, 0x01, 0x52, 0x0c, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65,
+	0x12, 0x23, 0x0a, 0x0b, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18,
+	0x57, 0x20, 0x03, 0x28, 0x08, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0a, 0x70, 0x61, 0x63, 0x6b, 0x65,
+	0x64, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x6e, 0x0a, 0x12, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f,
+	0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x58, 0x20, 0x03, 0x28,
+	0x0e, 0x32, 0x3c, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73,
+	0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x32, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72,
+	0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x42,
+	0x02, 0x10, 0x01, 0x52, 0x10, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x4e, 0x65, 0x73, 0x74, 0x65,
+	0x64, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x29, 0x0a, 0x0e, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65,
+	0x64, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x59, 0x20, 0x03, 0x28, 0x05, 0x42, 0x02, 0x10,
+	0x00, 0x52, 0x0d, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x49, 0x6e, 0x74, 0x33, 0x32,
+	0x12, 0x29, 0x0a, 0x0e, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x74,
+	0x36, 0x34, 0x18, 0x5a, 0x20, 0x03, 0x28, 0x03, 0x42, 0x02, 0x10, 0x00, 0x52, 0x0d, 0x75, 0x6e,
+	0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x2b, 0x0a, 0x0f, 0x75,
+	0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x5b,
+	0x20, 0x03, 0x28, 0x0d, 0x42, 0x02, 0x10, 0x00, 0x52, 0x0e, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b,
+	0x65, 0x64, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x2b, 0x0a, 0x0f, 0x75, 0x6e, 0x70, 0x61,
+	0x63, 0x6b, 0x65, 0x64, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x5c, 0x20, 0x03, 0x28,
+	0x04, 0x42, 0x02, 0x10, 0x00, 0x52, 0x0e, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x55,
+	0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x2b, 0x0a, 0x0f, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65,
+	0x64, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x5d, 0x20, 0x03, 0x28, 0x11, 0x42, 0x02,
+	0x10, 0x00, 0x52, 0x0e, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x53, 0x69, 0x6e, 0x74,
+	0x33, 0x32, 0x12, 0x2b, 0x0a, 0x0f, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x73,
+	0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x5e, 0x20, 0x03, 0x28, 0x12, 0x42, 0x02, 0x10, 0x00, 0x52,
+	0x0e, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12,
+	0x2d, 0x0a, 0x10, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x66, 0x69, 0x78, 0x65,
+	0x64, 0x33, 0x32, 0x18, 0x5f, 0x20, 0x03, 0x28, 0x07, 0x42, 0x02, 0x10, 0x00, 0x52, 0x0f, 0x75,
+	0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x2d,
+	0x0a, 0x10, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64,
+	0x36, 0x34, 0x18, 0x60, 0x20, 0x03, 0x28, 0x06, 0x42, 0x02, 0x10, 0x00, 0x52, 0x0f, 0x75, 0x6e,
+	0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x2f, 0x0a,
+	0x11, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64,
+	0x33, 0x32, 0x18, 0x61, 0x20, 0x03, 0x28, 0x0f, 0x42, 0x02, 0x10, 0x00, 0x52, 0x10, 0x75, 0x6e,
+	0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x2f,
+	0x0a, 0x11, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65,
+	0x64, 0x36, 0x34, 0x18, 0x62, 0x20, 0x03, 0x28, 0x10, 0x42, 0x02, 0x10, 0x00, 0x52, 0x10, 0x75,
+	0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12,
+	0x29, 0x0a, 0x0e, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x66, 0x6c, 0x6f, 0x61,
+	0x74, 0x18, 0x63, 0x20, 0x03, 0x28, 0x02, 0x42, 0x02, 0x10, 0x00, 0x52, 0x0d, 0x75, 0x6e, 0x70,
+	0x61, 0x63, 0x6b, 0x65, 0x64, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x2b, 0x0a, 0x0f, 0x75, 0x6e,
+	0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0x64, 0x20,
+	0x03, 0x28, 0x01, 0x42, 0x02, 0x10, 0x00, 0x52, 0x0e, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65,
+	0x64, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x27, 0x0a, 0x0d, 0x75, 0x6e, 0x70, 0x61, 0x63,
+	0x6b, 0x65, 0x64, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18, 0x65, 0x20, 0x03, 0x28, 0x08, 0x42, 0x02,
+	0x10, 0x00, 0x52, 0x0c, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x42, 0x6f, 0x6f, 0x6c,
+	0x12, 0x72, 0x0a, 0x14, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x6e, 0x65, 0x73,
+	0x74, 0x65, 0x64, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x66, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x3c,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x54,
+	0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f,
+	0x32, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x42, 0x02, 0x10, 0x00,
+	0x52, 0x12, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64,
+	0x45, 0x6e, 0x75, 0x6d, 0x12, 0x6c, 0x0a, 0x0f, 0x6d, 0x61, 0x70, 0x5f, 0x69, 0x6e, 0x74, 0x33,
+	0x32, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x38, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x44, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x54, 0x65,
+	0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x32,
+	0x2e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x45, 0x6e,
+	0x74, 0x72, 0x79, 0x52, 0x0d, 0x6d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x49, 0x6e, 0x74,
+	0x33, 0x32, 0x12, 0x6c, 0x0a, 0x0f, 0x6d, 0x61, 0x70, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x5f,
+	0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x39, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x44, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x54, 0x65, 0x73, 0x74,
+	0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x4d,
+	0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72,
+	0x79, 0x52, 0x0d, 0x6d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x49, 0x6e, 0x74, 0x36, 0x34,
+	0x12, 0x72, 0x0a, 0x11, 0x6d, 0x61, 0x70, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x75,
+	0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x3a, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x46, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x54, 0x65, 0x73, 0x74,
+	0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x4d,
+	0x61, 0x70, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x45, 0x6e,
+	0x74, 0x72, 0x79, 0x52, 0x0f, 0x6d, 0x61, 0x70, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x55, 0x69,
+	0x6e, 0x74, 0x33, 0x32, 0x12, 0x72, 0x0a, 0x11, 0x6d, 0x61, 0x70, 0x5f, 0x75, 0x69, 0x6e, 0x74,
+	0x36, 0x34, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x3b, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x46, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e,
+	0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74,
+	0x6f, 0x32, 0x2e, 0x4d, 0x61, 0x70, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x55, 0x69, 0x6e, 0x74,
+	0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x6d, 0x61, 0x70, 0x55, 0x69, 0x6e, 0x74,
+	0x36, 0x34, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x72, 0x0a, 0x11, 0x6d, 0x61, 0x70, 0x5f,
+	0x73, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x3c, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x46, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74,
+	0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x32, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73,
+	0x50, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32,
+	0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x6d, 0x61, 0x70,
+	0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x72, 0x0a, 0x11,
+	0x6d, 0x61, 0x70, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x36,
+	0x34, 0x18, 0x3d, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x46, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
+	0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54,
+	0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x69,
+	0x6e, 0x74, 0x36, 0x34, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52,
+	0x0f, 0x6d, 0x61, 0x70, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34,
+	0x12, 0x78, 0x0a, 0x13, 0x6d, 0x61, 0x70, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x5f,
+	0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x3e, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x48, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x54, 0x65,
+	0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x32,
+	0x2e, 0x4d, 0x61, 0x70, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x46, 0x69, 0x78, 0x65, 0x64,
+	0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x11, 0x6d, 0x61, 0x70, 0x46, 0x69, 0x78, 0x65,
+	0x64, 0x33, 0x32, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x78, 0x0a, 0x13, 0x6d, 0x61,
+	0x70, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36,
+	0x34, 0x18, 0x3f, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x48, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
+	0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54,
+	0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x4d, 0x61, 0x70, 0x46, 0x69,
+	0x78, 0x65, 0x64, 0x36, 0x34, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72,
+	0x79, 0x52, 0x11, 0x6d, 0x61, 0x70, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x46, 0x69, 0x78,
+	0x65, 0x64, 0x36, 0x34, 0x12, 0x7e, 0x0a, 0x15, 0x6d, 0x61, 0x70, 0x5f, 0x73, 0x66, 0x69, 0x78,
+	0x65, 0x64, 0x33, 0x32, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x40, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x4a, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74,
+	0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x32, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73,
+	0x50, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64,
+	0x33, 0x32, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52,
+	0x13, 0x6d, 0x61, 0x70, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x53, 0x66, 0x69, 0x78,
+	0x65, 0x64, 0x33, 0x32, 0x12, 0x7e, 0x0a, 0x15, 0x6d, 0x61, 0x70, 0x5f, 0x73, 0x66, 0x69, 0x78,
+	0x65, 0x64, 0x36, 0x34, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x41, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x4a, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74,
+	0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x32, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73,
+	0x50, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64,
+	0x36, 0x34, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52,
+	0x13, 0x6d, 0x61, 0x70, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x53, 0x66, 0x69, 0x78,
+	0x65, 0x64, 0x36, 0x34, 0x12, 0x6c, 0x0a, 0x0f, 0x6d, 0x61, 0x70, 0x5f, 0x69, 0x6e, 0x74, 0x33,
+	0x32, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x18, 0x42, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x44, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x54, 0x65,
+	0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x32,
+	0x2e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x45, 0x6e,
+	0x74, 0x72, 0x79, 0x52, 0x0d, 0x6d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x46, 0x6c, 0x6f,
+	0x61, 0x74, 0x12, 0x6f, 0x0a, 0x10, 0x6d, 0x61, 0x70, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f,
+	0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0x43, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x45, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x54, 0x65, 0x73,
+	0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e,
+	0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x45, 0x6e,
+	0x74, 0x72, 0x79, 0x52, 0x0e, 0x6d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x44, 0x6f, 0x75,
+	0x62, 0x6c, 0x65, 0x12, 0x66, 0x0a, 0x0d, 0x6d, 0x61, 0x70, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x5f,
+	0x62, 0x6f, 0x6f, 0x6c, 0x18, 0x44, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x42, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41,
+	0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x4d, 0x61,
+	0x70, 0x42, 0x6f, 0x6f, 0x6c, 0x42, 0x6f, 0x6f, 0x6c, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0b,
+	0x6d, 0x61, 0x70, 0x42, 0x6f, 0x6f, 0x6c, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x72, 0x0a, 0x11, 0x6d,
+	0x61, 0x70, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67,
+	0x18, 0x45, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x46, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79,
+	0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72,
+	0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f,
+	0x6d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12,
+	0x6f, 0x0a, 0x10, 0x6d, 0x61, 0x70, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x62, 0x79,
+	0x74, 0x65, 0x73, 0x18, 0x46, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x45, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c,
+	0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x4d, 0x61, 0x70,
+	0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x79, 0x74, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79,
+	0x52, 0x0e, 0x6d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x79, 0x74, 0x65, 0x73,
+	0x12, 0x88, 0x01, 0x0a, 0x19, 0x6d, 0x61, 0x70, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f,
+	0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x47,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x4d, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f,
+	0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65,
+	0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e,
+	0x67, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x45, 0x6e,
+	0x74, 0x72, 0x79, 0x52, 0x16, 0x6d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x4e, 0x65,
+	0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x8b, 0x01, 0x0a, 0x1a,
+	0x6d, 0x61, 0x70, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x66, 0x6f, 0x72, 0x65, 0x69,
+	0x67, 0x6e, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x48, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x4e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32,
+	0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f,
+	0x74, 0x6f, 0x32, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x46, 0x6f, 0x72,
+	0x65, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79,
+	0x52, 0x17, 0x6d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x46, 0x6f, 0x72, 0x65, 0x69,
+	0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x7f, 0x0a, 0x16, 0x6d, 0x61, 0x70,
+	0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x65,
+	0x6e, 0x75, 0x6d, 0x18, 0x49, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x4a, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c,
+	0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x4d, 0x61, 0x70,
+	0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d,
+	0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x13, 0x6d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67,
+	0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x82, 0x01, 0x0a, 0x17, 0x6d,
+	0x61, 0x70, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x66, 0x6f, 0x72, 0x65, 0x69, 0x67,
+	0x6e, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x4a, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x4b, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x54, 0x65, 0x73,
+	0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e,
+	0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e,
+	0x45, 0x6e, 0x75, 0x6d, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x14, 0x6d, 0x61, 0x70, 0x53, 0x74,
+	0x72, 0x69, 0x6e, 0x67, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x45, 0x6e, 0x75, 0x6d, 0x12,
+	0x23, 0x0a, 0x0c, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18,
+	0x6f, 0x20, 0x01, 0x28, 0x0d, 0x48, 0x00, 0x52, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x55, 0x69,
+	0x6e, 0x74, 0x33, 0x32, 0x12, 0x73, 0x0a, 0x14, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x6e, 0x65,
+	0x73, 0x74, 0x65, 0x64, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x70, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x3f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65,
+	0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x32, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50,
+	0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x48, 0x00, 0x52, 0x12, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x4e, 0x65, 0x73, 0x74,
+	0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x23, 0x0a, 0x0c, 0x6f, 0x6e, 0x65,
+	0x6f, 0x66, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x71, 0x20, 0x01, 0x28, 0x09, 0x48,
+	0x00, 0x52, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x21,
+	0x0a, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x72, 0x20,
+	0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x0a, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x42, 0x79, 0x74, 0x65,
+	0x73, 0x12, 0x1f, 0x0a, 0x0a, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18,
+	0x73, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x09, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x42, 0x6f,
+	0x6f, 0x6c, 0x12, 0x23, 0x0a, 0x0c, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x75, 0x69, 0x6e, 0x74,
+	0x36, 0x34, 0x18, 0x74, 0x20, 0x01, 0x28, 0x04, 0x48, 0x00, 0x52, 0x0b, 0x6f, 0x6e, 0x65, 0x6f,
+	0x66, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x21, 0x0a, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66,
+	0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x18, 0x75, 0x20, 0x01, 0x28, 0x02, 0x48, 0x00, 0x52, 0x0a,
+	0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x23, 0x0a, 0x0c, 0x6f, 0x6e,
+	0x65, 0x6f, 0x66, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0x76, 0x20, 0x01, 0x28, 0x01,
+	0x48, 0x00, 0x52, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12,
+	0x5d, 0x0a, 0x0a, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x77, 0x20,
+	0x01, 0x28, 0x0e, 0x32, 0x3c, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74,
+	0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x32, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73,
+	0x50, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75,
+	0x6d, 0x48, 0x00, 0x52, 0x09, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x4b,
+	0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0xc9, 0x01, 0x20, 0x01, 0x28, 0x0a, 0x32, 0x36, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x54, 0x65,
+	0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x32,
+	0x2e, 0x44, 0x61, 0x74, 0x61, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x12, 0x1f, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x6e, 0x61, 0x6d, 0x65, 0x31, 0x18, 0x91, 0x03, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x6e, 0x61, 0x6d, 0x65, 0x31, 0x12, 0x20, 0x0a, 0x0b,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x32, 0x18, 0x92, 0x03, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x32, 0x12, 0x21,
+	0x0a, 0x0c, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x33, 0x18, 0x93,
+	0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e, 0x61, 0x6d, 0x65,
+	0x33, 0x12, 0x22, 0x0a, 0x0d, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x5f, 0x6e, 0x61, 0x6d, 0x65,
+	0x34, 0x5f, 0x18, 0x94, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x4e, 0x61, 0x6d, 0x65, 0x34, 0x12, 0x21, 0x0a, 0x0b, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x30, 0x6e,
+	0x61, 0x6d, 0x65, 0x35, 0x18, 0x95, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x30, 0x6e, 0x61, 0x6d, 0x65, 0x35, 0x12, 0x23, 0x0a, 0x0d, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x5f, 0x30, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x36, 0x18, 0x96, 0x03, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x0b, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x30, 0x4e, 0x61, 0x6d, 0x65, 0x36, 0x12, 0x1f, 0x0a,
+	0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x37, 0x18, 0x97, 0x03, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x37, 0x12, 0x1f,
+	0x0a, 0x0a, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x38, 0x18, 0x98, 0x03, 0x20,
+	0x01, 0x28, 0x05, 0x52, 0x0a, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x38, 0x12,
+	0x20, 0x0a, 0x0b, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x4e, 0x61, 0x6d, 0x65, 0x39, 0x18, 0x99,
+	0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x4e, 0x61, 0x6d, 0x65,
+	0x39, 0x12, 0x22, 0x0a, 0x0c, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x4e, 0x61, 0x6d, 0x65, 0x31,
+	0x30, 0x18, 0x9a, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e,
+	0x61, 0x6d, 0x65, 0x31, 0x30, 0x12, 0x22, 0x0a, 0x0c, 0x46, 0x49, 0x45, 0x4c, 0x44, 0x5f, 0x4e,
+	0x41, 0x4d, 0x45, 0x31, 0x31, 0x18, 0x9b, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x46, 0x49,
+	0x45, 0x4c, 0x44, 0x4e, 0x41, 0x4d, 0x45, 0x31, 0x31, 0x12, 0x22, 0x0a, 0x0c, 0x46, 0x49, 0x45,
+	0x4c, 0x44, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x31, 0x32, 0x18, 0x9c, 0x03, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x0b, 0x46, 0x49, 0x45, 0x4c, 0x44, 0x4e, 0x61, 0x6d, 0x65, 0x31, 0x32, 0x12, 0x24, 0x0a,
+	0x0e, 0x5f, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x31, 0x33, 0x18,
+	0x9d, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e, 0x61, 0x6d,
+	0x65, 0x31, 0x33, 0x12, 0x24, 0x0a, 0x0e, 0x5f, 0x5f, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x6e,
+	0x61, 0x6d, 0x65, 0x31, 0x34, 0x18, 0x9e, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x46, 0x69,
+	0x65, 0x6c, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x31, 0x34, 0x12, 0x23, 0x0a, 0x0d, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x5f, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x31, 0x35, 0x18, 0x9f, 0x03, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x0b, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x31, 0x35, 0x12, 0x23,
+	0x0a, 0x0d, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x5f, 0x4e, 0x61, 0x6d, 0x65, 0x31, 0x36, 0x18,
+	0xa0, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x4e, 0x61, 0x6d,
+	0x65, 0x31, 0x36, 0x12, 0x24, 0x0a, 0x0e, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x6e, 0x61, 0x6d,
+	0x65, 0x31, 0x37, 0x5f, 0x5f, 0x18, 0xa1, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x31, 0x37, 0x12, 0x24, 0x0a, 0x0e, 0x46, 0x69, 0x65,
+	0x6c, 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x31, 0x38, 0x5f, 0x5f, 0x18, 0xa2, 0x03, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x0b, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x31, 0x38, 0x1a,
+	0x72, 0x0a, 0x0d, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x12, 0x0c, 0x0a, 0x01, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x01, 0x61, 0x12, 0x53,
+	0x0a, 0x0b, 0x63, 0x6f, 0x72, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x76, 0x65, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74,
+	0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x32, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73,
+	0x50, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x52, 0x0b, 0x63, 0x6f, 0x72, 0x65, 0x63, 0x75, 0x72, 0x73,
+	0x69, 0x76, 0x65, 0x1a, 0x40, 0x0a, 0x12, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x49,
+	0x6e, 0x74, 0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76,
+	0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75,
+	0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x40, 0x0a, 0x12, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36,
+	0x34, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b,
+	0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a,
+	0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, 0x61,
+	0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x42, 0x0a, 0x14, 0x4d, 0x61, 0x70, 0x55, 0x69,
+	0x6e, 0x74, 0x33, 0x32, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12,
+	0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x03, 0x6b, 0x65,
+	0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d,
+	0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x42, 0x0a, 0x14, 0x4d,
+	0x61, 0x70, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x45, 0x6e,
+	0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04,
+	0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a,
+	0x42, 0x0a, 0x14, 0x4d, 0x61, 0x70, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x53, 0x69, 0x6e, 0x74,
+	0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x11, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c,
+	0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x11, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a,
+	0x02, 0x38, 0x01, 0x1a, 0x42, 0x0a, 0x14, 0x4d, 0x61, 0x70, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34,
+	0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b,
+	0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x12, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a,
+	0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x12, 0x52, 0x05, 0x76, 0x61,
+	0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x44, 0x0a, 0x16, 0x4d, 0x61, 0x70, 0x46, 0x69,
+	0x78, 0x65, 0x64, 0x33, 0x32, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x45, 0x6e, 0x74, 0x72,
+	0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x07, 0x52, 0x03,
+	0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x07, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x44, 0x0a,
+	0x16, 0x4d, 0x61, 0x70, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x46, 0x69, 0x78, 0x65, 0x64,
+	0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x06, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c,
+	0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x06, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a,
+	0x02, 0x38, 0x01, 0x1a, 0x46, 0x0a, 0x18, 0x4d, 0x61, 0x70, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64,
+	0x33, 0x32, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12,
+	0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0f, 0x52, 0x03, 0x6b, 0x65,
+	0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0f,
+	0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x46, 0x0a, 0x18, 0x4d,
+	0x61, 0x70, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64,
+	0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x10, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c,
+	0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x10, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a,
+	0x02, 0x38, 0x01, 0x1a, 0x40, 0x0a, 0x12, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x46,
+	0x6c, 0x6f, 0x61, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76,
+	0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x02, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75,
+	0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x41, 0x0a, 0x13, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x33,
+	0x32, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03,
+	0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14,
+	0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x05, 0x76,
+	0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x3e, 0x0a, 0x10, 0x4d, 0x61, 0x70, 0x42,
+	0x6f, 0x6f, 0x6c, 0x42, 0x6f, 0x6f, 0x6c, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03,
+	0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14,
+	0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x76,
+	0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x42, 0x0a, 0x14, 0x4d, 0x61, 0x70, 0x53,
+	0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79,
+	0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b,
+	0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x41, 0x0a, 0x13,
+	0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x79, 0x74, 0x65, 0x73, 0x45, 0x6e,
+	0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a,
+	0x8a, 0x01, 0x0a, 0x1b, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x4e, 0x65, 0x73,
+	0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12,
+	0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65,
+	0x79, 0x12, 0x55, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x3f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32,
+	0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f,
+	0x74, 0x6f, 0x32, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x7f, 0x0a, 0x1c,
+	0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03,
+	0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x49,
+	0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x33, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x46, 0x6f,
+	0x72, 0x65, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x50, 0x72, 0x6f, 0x74,
+	0x6f, 0x32, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x84, 0x01,
+	0x0a, 0x18, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x4e, 0x65, 0x73, 0x74, 0x65,
+	0x64, 0x45, 0x6e, 0x75, 0x6d, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65,
+	0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x52, 0x0a, 0x05,
+	0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x3c, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x54, 0x65, 0x73, 0x74,
+	0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x4e,
+	0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
+	0x3a, 0x02, 0x38, 0x01, 0x1a, 0x79, 0x0a, 0x19, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e,
+	0x67, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x45, 0x6e, 0x75, 0x6d, 0x45, 0x6e, 0x74, 0x72,
+	0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03,
+	0x6b, 0x65, 0x79, 0x12, 0x46, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x0e, 0x32, 0x30, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65,
+	0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x32, 0x2e, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x45, 0x6e, 0x75, 0x6d, 0x50, 0x72,
+	0x6f, 0x74, 0x6f, 0x32, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a,
+	0x4c, 0x0a, 0x04, 0x44, 0x61, 0x74, 0x61, 0x12, 0x20, 0x0a, 0x0b, 0x67, 0x72, 0x6f, 0x75, 0x70,
+	0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0xca, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x67,
+	0x72, 0x6f, 0x75, 0x70, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x22, 0x0a, 0x0c, 0x67, 0x72, 0x6f,
+	0x75, 0x70, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0xcb, 0x01, 0x20, 0x01, 0x28, 0x0d,
+	0x52, 0x0b, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x1a, 0x21, 0x0a,
+	0x11, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x43, 0x6f, 0x72, 0x72, 0x65,
+	0x63, 0x74, 0x2a, 0x08, 0x08, 0x04, 0x10, 0xff, 0xff, 0xff, 0xff, 0x07, 0x3a, 0x02, 0x08, 0x01,
+	0x1a, 0xfa, 0x01, 0x0a, 0x1b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x43,
+	0x6f, 0x72, 0x72, 0x65, 0x63, 0x74, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x31,
+	0x12, 0x10, 0x0a, 0x03, 0x73, 0x74, 0x72, 0x18, 0x19, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x73,
+	0x74, 0x72, 0x32, 0xc8, 0x01, 0x0a, 0x15, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x73,
+	0x65, 0x74, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x43, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x54, 0x65, 0x73,
+	0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x43, 0x6f, 0x72, 0x72, 0x65, 0x63,
+	0x74, 0x18, 0xf9, 0xbb, 0x5e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x4d, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c,
+	0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x43, 0x6f, 0x72, 0x72, 0x65, 0x63, 0x74, 0x45, 0x78,
+	0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x31, 0x52, 0x13, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x53, 0x65, 0x74, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x1a, 0xf7, 0x01,
+	0x0a, 0x1b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x43, 0x6f, 0x72, 0x72,
+	0x65, 0x63, 0x74, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x32, 0x12, 0x0c, 0x0a,
+	0x01, 0x69, 0x18, 0x09, 0x20, 0x01, 0x28, 0x05, 0x52, 0x01, 0x69, 0x32, 0xc9, 0x01, 0x0a, 0x15,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x65, 0x74, 0x5f, 0x65, 0x78, 0x74, 0x65,
+	0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x43, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
+	0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70,
+	0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x53, 0x65, 0x74, 0x43, 0x6f, 0x72, 0x72, 0x65, 0x63, 0x74, 0x18, 0x90, 0xb3, 0xfc, 0x01, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x4d, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74,
+	0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x32, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73,
+	0x50, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65,
+	0x74, 0x43, 0x6f, 0x72, 0x72, 0x65, 0x63, 0x74, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f,
+	0x6e, 0x32, 0x52, 0x13, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x45, 0x78,
+	0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x39, 0x0a, 0x0a, 0x4e, 0x65, 0x73, 0x74, 0x65,
+	0x64, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x07, 0x0a, 0x03, 0x46, 0x4f, 0x4f, 0x10, 0x00, 0x12, 0x07,
+	0x0a, 0x03, 0x42, 0x41, 0x52, 0x10, 0x01, 0x12, 0x07, 0x0a, 0x03, 0x42, 0x41, 0x5a, 0x10, 0x02,
+	0x12, 0x10, 0x0a, 0x03, 0x4e, 0x45, 0x47, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+	0xff, 0x01, 0x2a, 0x05, 0x08, 0x78, 0x10, 0xc9, 0x01, 0x42, 0x0d, 0x0a, 0x0b, 0x6f, 0x6e, 0x65,
+	0x6f, 0x66, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x4a, 0x06, 0x08, 0xe8, 0x07, 0x10, 0x90, 0x4e,
+	0x22, 0x24, 0x0a, 0x14, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x12, 0x0c, 0x0a, 0x01, 0x63, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x05, 0x52, 0x01, 0x63, 0x22, 0x9e, 0x03, 0x0a, 0x15, 0x55, 0x6e, 0x6b, 0x6e, 0x6f,
+	0x77, 0x6e, 0x54, 0x6f, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73,
+	0x12, 0x26, 0x0a, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x69, 0x6e, 0x74,
+	0x33, 0x32, 0x18, 0xe9, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x28, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0xea, 0x07, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x74, 0x72, 0x69,
+	0x6e, 0x67, 0x12, 0x5b, 0x0a, 0x0e, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x18, 0xeb, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x33, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x46, 0x6f, 0x72, 0x65,
+	0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x32,
+	0x52, 0x0d, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12,
+	0x69, 0x0a, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x67, 0x72, 0x6f, 0x75, 0x70,
+	0x18, 0xec, 0x07, 0x20, 0x01, 0x28, 0x0a, 0x32, 0x42, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
+	0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x54,
+	0x6f, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4f, 0x70,
+	0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x0d, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x24, 0x0a, 0x0d, 0x6f, 0x70,
+	0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18, 0xee, 0x07, 0x20, 0x01,
+	0x28, 0x08, 0x52, 0x0c, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x42, 0x6f, 0x6f, 0x6c,
+	0x12, 0x26, 0x0a, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x74,
+	0x33, 0x32, 0x18, 0xf3, 0x07, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61,
+	0x74, 0x65, 0x64, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x1a, 0x1d, 0x0a, 0x0d, 0x4f, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x61, 0x6c, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x0c, 0x0a, 0x01, 0x61, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x01, 0x61, 0x2a, 0x46, 0x0a, 0x11, 0x46, 0x6f, 0x72, 0x65, 0x69,
+	0x67, 0x6e, 0x45, 0x6e, 0x75, 0x6d, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x12, 0x0f, 0x0a, 0x0b,
+	0x46, 0x4f, 0x52, 0x45, 0x49, 0x47, 0x4e, 0x5f, 0x46, 0x4f, 0x4f, 0x10, 0x00, 0x12, 0x0f, 0x0a,
+	0x0b, 0x46, 0x4f, 0x52, 0x45, 0x49, 0x47, 0x4e, 0x5f, 0x42, 0x41, 0x52, 0x10, 0x01, 0x12, 0x0f,
+	0x0a, 0x0b, 0x46, 0x4f, 0x52, 0x45, 0x49, 0x47, 0x4e, 0x5f, 0x42, 0x41, 0x5a, 0x10, 0x02, 0x3a,
+	0x5a, 0x0a, 0x0f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x74,
+	0x33, 0x32, 0x12, 0x31, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65,
+	0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x32, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50,
+	0x72, 0x6f, 0x74, 0x6f, 0x32, 0x18, 0x78, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, 0x65, 0x78, 0x74,
+	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x42, 0x2f, 0x0a, 0x28, 0x63,
+	0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
+	0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x48, 0x01, 0xf8, 0x01, 0x01,
+}
+
+var (
+	file_google_protobuf_test_messages_proto2_proto_rawDescOnce sync.Once
+	file_google_protobuf_test_messages_proto2_proto_rawDescData = file_google_protobuf_test_messages_proto2_proto_rawDesc
+)
+
+func file_google_protobuf_test_messages_proto2_proto_rawDescGZIP() []byte {
+	file_google_protobuf_test_messages_proto2_proto_rawDescOnce.Do(func() {
+		file_google_protobuf_test_messages_proto2_proto_rawDescData = protoimpl.X.CompressGZIP(file_google_protobuf_test_messages_proto2_proto_rawDescData)
+	})
+	return file_google_protobuf_test_messages_proto2_proto_rawDescData
+}
+
+var file_google_protobuf_test_messages_proto2_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
+var file_google_protobuf_test_messages_proto2_proto_msgTypes = make([]protoimpl.MessageInfo, 28)
+var file_google_protobuf_test_messages_proto2_proto_goTypes = []interface{}{
+	(ForeignEnumProto2)(0),                   // 0: protobuf_test_messages.proto2.ForeignEnumProto2
+	(TestAllTypesProto2_NestedEnum)(0),       // 1: protobuf_test_messages.proto2.TestAllTypesProto2.NestedEnum
+	(*TestAllTypesProto2)(nil),               // 2: protobuf_test_messages.proto2.TestAllTypesProto2
+	(*ForeignMessageProto2)(nil),             // 3: protobuf_test_messages.proto2.ForeignMessageProto2
+	(*UnknownToTestAllTypes)(nil),            // 4: protobuf_test_messages.proto2.UnknownToTestAllTypes
+	(*TestAllTypesProto2_NestedMessage)(nil), // 5: protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage
+	nil,                                      // 6: protobuf_test_messages.proto2.TestAllTypesProto2.MapInt32Int32Entry
+	nil,                                      // 7: protobuf_test_messages.proto2.TestAllTypesProto2.MapInt64Int64Entry
+	nil,                                      // 8: protobuf_test_messages.proto2.TestAllTypesProto2.MapUint32Uint32Entry
+	nil,                                      // 9: protobuf_test_messages.proto2.TestAllTypesProto2.MapUint64Uint64Entry
+	nil,                                      // 10: protobuf_test_messages.proto2.TestAllTypesProto2.MapSint32Sint32Entry
+	nil,                                      // 11: protobuf_test_messages.proto2.TestAllTypesProto2.MapSint64Sint64Entry
+	nil,                                      // 12: protobuf_test_messages.proto2.TestAllTypesProto2.MapFixed32Fixed32Entry
+	nil,                                      // 13: protobuf_test_messages.proto2.TestAllTypesProto2.MapFixed64Fixed64Entry
+	nil,                                      // 14: protobuf_test_messages.proto2.TestAllTypesProto2.MapSfixed32Sfixed32Entry
+	nil,                                      // 15: protobuf_test_messages.proto2.TestAllTypesProto2.MapSfixed64Sfixed64Entry
+	nil,                                      // 16: protobuf_test_messages.proto2.TestAllTypesProto2.MapInt32FloatEntry
+	nil,                                      // 17: protobuf_test_messages.proto2.TestAllTypesProto2.MapInt32DoubleEntry
+	nil,                                      // 18: protobuf_test_messages.proto2.TestAllTypesProto2.MapBoolBoolEntry
+	nil,                                      // 19: protobuf_test_messages.proto2.TestAllTypesProto2.MapStringStringEntry
+	nil,                                      // 20: protobuf_test_messages.proto2.TestAllTypesProto2.MapStringBytesEntry
+	nil,                                      // 21: protobuf_test_messages.proto2.TestAllTypesProto2.MapStringNestedMessageEntry
+	nil,                                      // 22: protobuf_test_messages.proto2.TestAllTypesProto2.MapStringForeignMessageEntry
+	nil,                                      // 23: protobuf_test_messages.proto2.TestAllTypesProto2.MapStringNestedEnumEntry
+	nil,                                      // 24: protobuf_test_messages.proto2.TestAllTypesProto2.MapStringForeignEnumEntry
+	(*TestAllTypesProto2_Data)(nil),          // 25: protobuf_test_messages.proto2.TestAllTypesProto2.Data
+	(*TestAllTypesProto2_MessageSetCorrect)(nil),           // 26: protobuf_test_messages.proto2.TestAllTypesProto2.MessageSetCorrect
+	(*TestAllTypesProto2_MessageSetCorrectExtension1)(nil), // 27: protobuf_test_messages.proto2.TestAllTypesProto2.MessageSetCorrectExtension1
+	(*TestAllTypesProto2_MessageSetCorrectExtension2)(nil), // 28: protobuf_test_messages.proto2.TestAllTypesProto2.MessageSetCorrectExtension2
+	(*UnknownToTestAllTypes_OptionalGroup)(nil),            // 29: protobuf_test_messages.proto2.UnknownToTestAllTypes.OptionalGroup
+}
+var file_google_protobuf_test_messages_proto2_proto_depIdxs = []int32{
+	5,  // 0: protobuf_test_messages.proto2.TestAllTypesProto2.optional_nested_message:type_name -> protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage
+	3,  // 1: protobuf_test_messages.proto2.TestAllTypesProto2.optional_foreign_message:type_name -> protobuf_test_messages.proto2.ForeignMessageProto2
+	1,  // 2: protobuf_test_messages.proto2.TestAllTypesProto2.optional_nested_enum:type_name -> protobuf_test_messages.proto2.TestAllTypesProto2.NestedEnum
+	0,  // 3: protobuf_test_messages.proto2.TestAllTypesProto2.optional_foreign_enum:type_name -> protobuf_test_messages.proto2.ForeignEnumProto2
+	2,  // 4: protobuf_test_messages.proto2.TestAllTypesProto2.recursive_message:type_name -> protobuf_test_messages.proto2.TestAllTypesProto2
+	5,  // 5: protobuf_test_messages.proto2.TestAllTypesProto2.repeated_nested_message:type_name -> protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage
+	3,  // 6: protobuf_test_messages.proto2.TestAllTypesProto2.repeated_foreign_message:type_name -> protobuf_test_messages.proto2.ForeignMessageProto2
+	1,  // 7: protobuf_test_messages.proto2.TestAllTypesProto2.repeated_nested_enum:type_name -> protobuf_test_messages.proto2.TestAllTypesProto2.NestedEnum
+	0,  // 8: protobuf_test_messages.proto2.TestAllTypesProto2.repeated_foreign_enum:type_name -> protobuf_test_messages.proto2.ForeignEnumProto2
+	1,  // 9: protobuf_test_messages.proto2.TestAllTypesProto2.packed_nested_enum:type_name -> protobuf_test_messages.proto2.TestAllTypesProto2.NestedEnum
+	1,  // 10: protobuf_test_messages.proto2.TestAllTypesProto2.unpacked_nested_enum:type_name -> protobuf_test_messages.proto2.TestAllTypesProto2.NestedEnum
+	6,  // 11: protobuf_test_messages.proto2.TestAllTypesProto2.map_int32_int32:type_name -> protobuf_test_messages.proto2.TestAllTypesProto2.MapInt32Int32Entry
+	7,  // 12: protobuf_test_messages.proto2.TestAllTypesProto2.map_int64_int64:type_name -> protobuf_test_messages.proto2.TestAllTypesProto2.MapInt64Int64Entry
+	8,  // 13: protobuf_test_messages.proto2.TestAllTypesProto2.map_uint32_uint32:type_name -> protobuf_test_messages.proto2.TestAllTypesProto2.MapUint32Uint32Entry
+	9,  // 14: protobuf_test_messages.proto2.TestAllTypesProto2.map_uint64_uint64:type_name -> protobuf_test_messages.proto2.TestAllTypesProto2.MapUint64Uint64Entry
+	10, // 15: protobuf_test_messages.proto2.TestAllTypesProto2.map_sint32_sint32:type_name -> protobuf_test_messages.proto2.TestAllTypesProto2.MapSint32Sint32Entry
+	11, // 16: protobuf_test_messages.proto2.TestAllTypesProto2.map_sint64_sint64:type_name -> protobuf_test_messages.proto2.TestAllTypesProto2.MapSint64Sint64Entry
+	12, // 17: protobuf_test_messages.proto2.TestAllTypesProto2.map_fixed32_fixed32:type_name -> protobuf_test_messages.proto2.TestAllTypesProto2.MapFixed32Fixed32Entry
+	13, // 18: protobuf_test_messages.proto2.TestAllTypesProto2.map_fixed64_fixed64:type_name -> protobuf_test_messages.proto2.TestAllTypesProto2.MapFixed64Fixed64Entry
+	14, // 19: protobuf_test_messages.proto2.TestAllTypesProto2.map_sfixed32_sfixed32:type_name -> protobuf_test_messages.proto2.TestAllTypesProto2.MapSfixed32Sfixed32Entry
+	15, // 20: protobuf_test_messages.proto2.TestAllTypesProto2.map_sfixed64_sfixed64:type_name -> protobuf_test_messages.proto2.TestAllTypesProto2.MapSfixed64Sfixed64Entry
+	16, // 21: protobuf_test_messages.proto2.TestAllTypesProto2.map_int32_float:type_name -> protobuf_test_messages.proto2.TestAllTypesProto2.MapInt32FloatEntry
+	17, // 22: protobuf_test_messages.proto2.TestAllTypesProto2.map_int32_double:type_name -> protobuf_test_messages.proto2.TestAllTypesProto2.MapInt32DoubleEntry
+	18, // 23: protobuf_test_messages.proto2.TestAllTypesProto2.map_bool_bool:type_name -> protobuf_test_messages.proto2.TestAllTypesProto2.MapBoolBoolEntry
+	19, // 24: protobuf_test_messages.proto2.TestAllTypesProto2.map_string_string:type_name -> protobuf_test_messages.proto2.TestAllTypesProto2.MapStringStringEntry
+	20, // 25: protobuf_test_messages.proto2.TestAllTypesProto2.map_string_bytes:type_name -> protobuf_test_messages.proto2.TestAllTypesProto2.MapStringBytesEntry
+	21, // 26: protobuf_test_messages.proto2.TestAllTypesProto2.map_string_nested_message:type_name -> protobuf_test_messages.proto2.TestAllTypesProto2.MapStringNestedMessageEntry
+	22, // 27: protobuf_test_messages.proto2.TestAllTypesProto2.map_string_foreign_message:type_name -> protobuf_test_messages.proto2.TestAllTypesProto2.MapStringForeignMessageEntry
+	23, // 28: protobuf_test_messages.proto2.TestAllTypesProto2.map_string_nested_enum:type_name -> protobuf_test_messages.proto2.TestAllTypesProto2.MapStringNestedEnumEntry
+	24, // 29: protobuf_test_messages.proto2.TestAllTypesProto2.map_string_foreign_enum:type_name -> protobuf_test_messages.proto2.TestAllTypesProto2.MapStringForeignEnumEntry
+	5,  // 30: protobuf_test_messages.proto2.TestAllTypesProto2.oneof_nested_message:type_name -> protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage
+	1,  // 31: protobuf_test_messages.proto2.TestAllTypesProto2.oneof_enum:type_name -> protobuf_test_messages.proto2.TestAllTypesProto2.NestedEnum
+	25, // 32: protobuf_test_messages.proto2.TestAllTypesProto2.data:type_name -> protobuf_test_messages.proto2.TestAllTypesProto2.Data
+	3,  // 33: protobuf_test_messages.proto2.UnknownToTestAllTypes.nested_message:type_name -> protobuf_test_messages.proto2.ForeignMessageProto2
+	29, // 34: protobuf_test_messages.proto2.UnknownToTestAllTypes.optionalgroup:type_name -> protobuf_test_messages.proto2.UnknownToTestAllTypes.OptionalGroup
+	2,  // 35: protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage.corecursive:type_name -> protobuf_test_messages.proto2.TestAllTypesProto2
+	5,  // 36: protobuf_test_messages.proto2.TestAllTypesProto2.MapStringNestedMessageEntry.value:type_name -> protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage
+	3,  // 37: protobuf_test_messages.proto2.TestAllTypesProto2.MapStringForeignMessageEntry.value:type_name -> protobuf_test_messages.proto2.ForeignMessageProto2
+	1,  // 38: protobuf_test_messages.proto2.TestAllTypesProto2.MapStringNestedEnumEntry.value:type_name -> protobuf_test_messages.proto2.TestAllTypesProto2.NestedEnum
+	0,  // 39: protobuf_test_messages.proto2.TestAllTypesProto2.MapStringForeignEnumEntry.value:type_name -> protobuf_test_messages.proto2.ForeignEnumProto2
+	2,  // 40: protobuf_test_messages.proto2.extension_int32:extendee -> protobuf_test_messages.proto2.TestAllTypesProto2
+	26, // 41: protobuf_test_messages.proto2.TestAllTypesProto2.MessageSetCorrectExtension1.message_set_extension:extendee -> protobuf_test_messages.proto2.TestAllTypesProto2.MessageSetCorrect
+	26, // 42: protobuf_test_messages.proto2.TestAllTypesProto2.MessageSetCorrectExtension2.message_set_extension:extendee -> protobuf_test_messages.proto2.TestAllTypesProto2.MessageSetCorrect
+	27, // 43: protobuf_test_messages.proto2.TestAllTypesProto2.MessageSetCorrectExtension1.message_set_extension:type_name -> protobuf_test_messages.proto2.TestAllTypesProto2.MessageSetCorrectExtension1
+	28, // 44: protobuf_test_messages.proto2.TestAllTypesProto2.MessageSetCorrectExtension2.message_set_extension:type_name -> protobuf_test_messages.proto2.TestAllTypesProto2.MessageSetCorrectExtension2
+	45, // [45:45] is the sub-list for method output_type
+	45, // [45:45] is the sub-list for method input_type
+	43, // [43:45] is the sub-list for extension type_name
+	40, // [40:43] is the sub-list for extension extendee
+	0,  // [0:40] is the sub-list for field type_name
+}
+
+func init() { file_google_protobuf_test_messages_proto2_proto_init() }
+func file_google_protobuf_test_messages_proto2_proto_init() {
+	if File_google_protobuf_test_messages_proto2_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_google_protobuf_test_messages_proto2_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*TestAllTypesProto2); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_test_messages_proto2_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ForeignMessageProto2); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_test_messages_proto2_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*UnknownToTestAllTypes); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_test_messages_proto2_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*TestAllTypesProto2_NestedMessage); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_test_messages_proto2_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*TestAllTypesProto2_Data); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_test_messages_proto2_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*TestAllTypesProto2_MessageSetCorrect); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_test_messages_proto2_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*TestAllTypesProto2_MessageSetCorrectExtension1); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_test_messages_proto2_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*TestAllTypesProto2_MessageSetCorrectExtension2); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_test_messages_proto2_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*UnknownToTestAllTypes_OptionalGroup); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	file_google_protobuf_test_messages_proto2_proto_msgTypes[0].OneofWrappers = []interface{}{
+		(*TestAllTypesProto2_OneofUint32)(nil),
+		(*TestAllTypesProto2_OneofNestedMessage)(nil),
+		(*TestAllTypesProto2_OneofString)(nil),
+		(*TestAllTypesProto2_OneofBytes)(nil),
+		(*TestAllTypesProto2_OneofBool)(nil),
+		(*TestAllTypesProto2_OneofUint64)(nil),
+		(*TestAllTypesProto2_OneofFloat)(nil),
+		(*TestAllTypesProto2_OneofDouble)(nil),
+		(*TestAllTypesProto2_OneofEnum)(nil),
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_google_protobuf_test_messages_proto2_proto_rawDesc,
+			NumEnums:      2,
+			NumMessages:   28,
+			NumExtensions: 3,
+			NumServices:   0,
+		},
+		GoTypes:           file_google_protobuf_test_messages_proto2_proto_goTypes,
+		DependencyIndexes: file_google_protobuf_test_messages_proto2_proto_depIdxs,
+		EnumInfos:         file_google_protobuf_test_messages_proto2_proto_enumTypes,
+		MessageInfos:      file_google_protobuf_test_messages_proto2_proto_msgTypes,
+		ExtensionInfos:    file_google_protobuf_test_messages_proto2_proto_extTypes,
+	}.Build()
+	File_google_protobuf_test_messages_proto2_proto = out.File
+	file_google_protobuf_test_messages_proto2_proto_rawDesc = nil
+	file_google_protobuf_test_messages_proto2_proto_goTypes = nil
+	file_google_protobuf_test_messages_proto2_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/conformance/test_messages_proto3.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/conformance/test_messages_proto3.pb.go
new file mode 100644
index 000000000..b356b5b8c
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/conformance/test_messages_proto3.pb.go
@@ -0,0 +1,2590 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Test schema for proto3 messages.  This test schema is used by:
+//
+// - benchmarks
+// - fuzz tests
+// - conformance tests
+//
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google/protobuf/test_messages_proto3.proto
+
+package conformance
+
+import (
+	fieldmaskpb "google.golang.org/protobuf/internal/testprotos/fieldmaskpb"
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	anypb "google.golang.org/protobuf/types/known/anypb"
+	durationpb "google.golang.org/protobuf/types/known/durationpb"
+	structpb "google.golang.org/protobuf/types/known/structpb"
+	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
+	wrapperspb "google.golang.org/protobuf/types/known/wrapperspb"
+	reflect "reflect"
+	sync "sync"
+)
+
+type ForeignEnum int32
+
+const (
+	ForeignEnum_FOREIGN_FOO ForeignEnum = 0
+	ForeignEnum_FOREIGN_BAR ForeignEnum = 1
+	ForeignEnum_FOREIGN_BAZ ForeignEnum = 2
+)
+
+// Enum value maps for ForeignEnum.
+var (
+	ForeignEnum_name = map[int32]string{
+		0: "FOREIGN_FOO",
+		1: "FOREIGN_BAR",
+		2: "FOREIGN_BAZ",
+	}
+	ForeignEnum_value = map[string]int32{
+		"FOREIGN_FOO": 0,
+		"FOREIGN_BAR": 1,
+		"FOREIGN_BAZ": 2,
+	}
+)
+
+func (x ForeignEnum) Enum() *ForeignEnum {
+	p := new(ForeignEnum)
+	*p = x
+	return p
+}
+
+func (x ForeignEnum) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (ForeignEnum) Descriptor() protoreflect.EnumDescriptor {
+	return file_google_protobuf_test_messages_proto3_proto_enumTypes[0].Descriptor()
+}
+
+func (ForeignEnum) Type() protoreflect.EnumType {
+	return &file_google_protobuf_test_messages_proto3_proto_enumTypes[0]
+}
+
+func (x ForeignEnum) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use ForeignEnum.Descriptor instead.
+func (ForeignEnum) EnumDescriptor() ([]byte, []int) {
+	return file_google_protobuf_test_messages_proto3_proto_rawDescGZIP(), []int{0}
+}
+
+type TestAllTypesProto3_NestedEnum int32
+
+const (
+	TestAllTypesProto3_FOO TestAllTypesProto3_NestedEnum = 0
+	TestAllTypesProto3_BAR TestAllTypesProto3_NestedEnum = 1
+	TestAllTypesProto3_BAZ TestAllTypesProto3_NestedEnum = 2
+	TestAllTypesProto3_NEG TestAllTypesProto3_NestedEnum = -1 // Intentionally negative.
+)
+
+// Enum value maps for TestAllTypesProto3_NestedEnum.
+var (
+	TestAllTypesProto3_NestedEnum_name = map[int32]string{
+		0:  "FOO",
+		1:  "BAR",
+		2:  "BAZ",
+		-1: "NEG",
+	}
+	TestAllTypesProto3_NestedEnum_value = map[string]int32{
+		"FOO": 0,
+		"BAR": 1,
+		"BAZ": 2,
+		"NEG": -1,
+	}
+)
+
+func (x TestAllTypesProto3_NestedEnum) Enum() *TestAllTypesProto3_NestedEnum {
+	p := new(TestAllTypesProto3_NestedEnum)
+	*p = x
+	return p
+}
+
+func (x TestAllTypesProto3_NestedEnum) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (TestAllTypesProto3_NestedEnum) Descriptor() protoreflect.EnumDescriptor {
+	return file_google_protobuf_test_messages_proto3_proto_enumTypes[1].Descriptor()
+}
+
+func (TestAllTypesProto3_NestedEnum) Type() protoreflect.EnumType {
+	return &file_google_protobuf_test_messages_proto3_proto_enumTypes[1]
+}
+
+func (x TestAllTypesProto3_NestedEnum) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use TestAllTypesProto3_NestedEnum.Descriptor instead.
+func (TestAllTypesProto3_NestedEnum) EnumDescriptor() ([]byte, []int) {
+	return file_google_protobuf_test_messages_proto3_proto_rawDescGZIP(), []int{0, 0}
+}
+
+type TestAllTypesProto3_AliasedEnum int32
+
+const (
+	TestAllTypesProto3_ALIAS_FOO TestAllTypesProto3_AliasedEnum = 0
+	TestAllTypesProto3_ALIAS_BAR TestAllTypesProto3_AliasedEnum = 1
+	TestAllTypesProto3_ALIAS_BAZ TestAllTypesProto3_AliasedEnum = 2
+	TestAllTypesProto3_QUX       TestAllTypesProto3_AliasedEnum = 2
+	TestAllTypesProto3_qux       TestAllTypesProto3_AliasedEnum = 2
+	TestAllTypesProto3_bAz       TestAllTypesProto3_AliasedEnum = 2
+)
+
+// Enum value maps for TestAllTypesProto3_AliasedEnum.
+var (
+	TestAllTypesProto3_AliasedEnum_name = map[int32]string{
+		0: "ALIAS_FOO",
+		1: "ALIAS_BAR",
+		2: "ALIAS_BAZ",
+		// Duplicate value: 2: "QUX",
+		// Duplicate value: 2: "qux",
+		// Duplicate value: 2: "bAz",
+	}
+	TestAllTypesProto3_AliasedEnum_value = map[string]int32{
+		"ALIAS_FOO": 0,
+		"ALIAS_BAR": 1,
+		"ALIAS_BAZ": 2,
+		"QUX":       2,
+		"qux":       2,
+		"bAz":       2,
+	}
+)
+
+func (x TestAllTypesProto3_AliasedEnum) Enum() *TestAllTypesProto3_AliasedEnum {
+	p := new(TestAllTypesProto3_AliasedEnum)
+	*p = x
+	return p
+}
+
+func (x TestAllTypesProto3_AliasedEnum) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (TestAllTypesProto3_AliasedEnum) Descriptor() protoreflect.EnumDescriptor {
+	return file_google_protobuf_test_messages_proto3_proto_enumTypes[2].Descriptor()
+}
+
+func (TestAllTypesProto3_AliasedEnum) Type() protoreflect.EnumType {
+	return &file_google_protobuf_test_messages_proto3_proto_enumTypes[2]
+}
+
+func (x TestAllTypesProto3_AliasedEnum) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use TestAllTypesProto3_AliasedEnum.Descriptor instead.
+func (TestAllTypesProto3_AliasedEnum) EnumDescriptor() ([]byte, []int) {
+	return file_google_protobuf_test_messages_proto3_proto_rawDescGZIP(), []int{0, 1}
+}
+
+// This proto includes every type of field in both singular and repeated
+// forms.
+//
+// Also, crucially, all messages and enums in this file are eventually
+// submessages of this message.  So for example, a fuzz test of TestAllTypes
+// could trigger bugs that occur in any message type in this file.  We verify
+// this stays true in a unit test.
+type TestAllTypesProto3 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// Singular
+	OptionalInt32          int32                             `protobuf:"varint,1,opt,name=optional_int32,json=optionalInt32,proto3" json:"optional_int32,omitempty"`
+	OptionalInt64          int64                             `protobuf:"varint,2,opt,name=optional_int64,json=optionalInt64,proto3" json:"optional_int64,omitempty"`
+	OptionalUint32         uint32                            `protobuf:"varint,3,opt,name=optional_uint32,json=optionalUint32,proto3" json:"optional_uint32,omitempty"`
+	OptionalUint64         uint64                            `protobuf:"varint,4,opt,name=optional_uint64,json=optionalUint64,proto3" json:"optional_uint64,omitempty"`
+	OptionalSint32         int32                             `protobuf:"zigzag32,5,opt,name=optional_sint32,json=optionalSint32,proto3" json:"optional_sint32,omitempty"`
+	OptionalSint64         int64                             `protobuf:"zigzag64,6,opt,name=optional_sint64,json=optionalSint64,proto3" json:"optional_sint64,omitempty"`
+	OptionalFixed32        uint32                            `protobuf:"fixed32,7,opt,name=optional_fixed32,json=optionalFixed32,proto3" json:"optional_fixed32,omitempty"`
+	OptionalFixed64        uint64                            `protobuf:"fixed64,8,opt,name=optional_fixed64,json=optionalFixed64,proto3" json:"optional_fixed64,omitempty"`
+	OptionalSfixed32       int32                             `protobuf:"fixed32,9,opt,name=optional_sfixed32,json=optionalSfixed32,proto3" json:"optional_sfixed32,omitempty"`
+	OptionalSfixed64       int64                             `protobuf:"fixed64,10,opt,name=optional_sfixed64,json=optionalSfixed64,proto3" json:"optional_sfixed64,omitempty"`
+	OptionalFloat          float32                           `protobuf:"fixed32,11,opt,name=optional_float,json=optionalFloat,proto3" json:"optional_float,omitempty"`
+	OptionalDouble         float64                           `protobuf:"fixed64,12,opt,name=optional_double,json=optionalDouble,proto3" json:"optional_double,omitempty"`
+	OptionalBool           bool                              `protobuf:"varint,13,opt,name=optional_bool,json=optionalBool,proto3" json:"optional_bool,omitempty"`
+	OptionalString         string                            `protobuf:"bytes,14,opt,name=optional_string,json=optionalString,proto3" json:"optional_string,omitempty"`
+	OptionalBytes          []byte                            `protobuf:"bytes,15,opt,name=optional_bytes,json=optionalBytes,proto3" json:"optional_bytes,omitempty"`
+	OptionalNestedMessage  *TestAllTypesProto3_NestedMessage `protobuf:"bytes,18,opt,name=optional_nested_message,json=optionalNestedMessage,proto3" json:"optional_nested_message,omitempty"`
+	OptionalForeignMessage *ForeignMessage                   `protobuf:"bytes,19,opt,name=optional_foreign_message,json=optionalForeignMessage,proto3" json:"optional_foreign_message,omitempty"`
+	OptionalNestedEnum     TestAllTypesProto3_NestedEnum     `protobuf:"varint,21,opt,name=optional_nested_enum,json=optionalNestedEnum,proto3,enum=protobuf_test_messages.proto3.TestAllTypesProto3_NestedEnum" json:"optional_nested_enum,omitempty"`
+	OptionalForeignEnum    ForeignEnum                       `protobuf:"varint,22,opt,name=optional_foreign_enum,json=optionalForeignEnum,proto3,enum=protobuf_test_messages.proto3.ForeignEnum" json:"optional_foreign_enum,omitempty"`
+	OptionalAliasedEnum    TestAllTypesProto3_AliasedEnum    `protobuf:"varint,23,opt,name=optional_aliased_enum,json=optionalAliasedEnum,proto3,enum=protobuf_test_messages.proto3.TestAllTypesProto3_AliasedEnum" json:"optional_aliased_enum,omitempty"`
+	OptionalStringPiece    string                            `protobuf:"bytes,24,opt,name=optional_string_piece,json=optionalStringPiece,proto3" json:"optional_string_piece,omitempty"`
+	OptionalCord           string                            `protobuf:"bytes,25,opt,name=optional_cord,json=optionalCord,proto3" json:"optional_cord,omitempty"`
+	RecursiveMessage       *TestAllTypesProto3               `protobuf:"bytes,27,opt,name=recursive_message,json=recursiveMessage,proto3" json:"recursive_message,omitempty"`
+	// Repeated
+	RepeatedInt32          []int32                             `protobuf:"varint,31,rep,packed,name=repeated_int32,json=repeatedInt32,proto3" json:"repeated_int32,omitempty"`
+	RepeatedInt64          []int64                             `protobuf:"varint,32,rep,packed,name=repeated_int64,json=repeatedInt64,proto3" json:"repeated_int64,omitempty"`
+	RepeatedUint32         []uint32                            `protobuf:"varint,33,rep,packed,name=repeated_uint32,json=repeatedUint32,proto3" json:"repeated_uint32,omitempty"`
+	RepeatedUint64         []uint64                            `protobuf:"varint,34,rep,packed,name=repeated_uint64,json=repeatedUint64,proto3" json:"repeated_uint64,omitempty"`
+	RepeatedSint32         []int32                             `protobuf:"zigzag32,35,rep,packed,name=repeated_sint32,json=repeatedSint32,proto3" json:"repeated_sint32,omitempty"`
+	RepeatedSint64         []int64                             `protobuf:"zigzag64,36,rep,packed,name=repeated_sint64,json=repeatedSint64,proto3" json:"repeated_sint64,omitempty"`
+	RepeatedFixed32        []uint32                            `protobuf:"fixed32,37,rep,packed,name=repeated_fixed32,json=repeatedFixed32,proto3" json:"repeated_fixed32,omitempty"`
+	RepeatedFixed64        []uint64                            `protobuf:"fixed64,38,rep,packed,name=repeated_fixed64,json=repeatedFixed64,proto3" json:"repeated_fixed64,omitempty"`
+	RepeatedSfixed32       []int32                             `protobuf:"fixed32,39,rep,packed,name=repeated_sfixed32,json=repeatedSfixed32,proto3" json:"repeated_sfixed32,omitempty"`
+	RepeatedSfixed64       []int64                             `protobuf:"fixed64,40,rep,packed,name=repeated_sfixed64,json=repeatedSfixed64,proto3" json:"repeated_sfixed64,omitempty"`
+	RepeatedFloat          []float32                           `protobuf:"fixed32,41,rep,packed,name=repeated_float,json=repeatedFloat,proto3" json:"repeated_float,omitempty"`
+	RepeatedDouble         []float64                           `protobuf:"fixed64,42,rep,packed,name=repeated_double,json=repeatedDouble,proto3" json:"repeated_double,omitempty"`
+	RepeatedBool           []bool                              `protobuf:"varint,43,rep,packed,name=repeated_bool,json=repeatedBool,proto3" json:"repeated_bool,omitempty"`
+	RepeatedString         []string                            `protobuf:"bytes,44,rep,name=repeated_string,json=repeatedString,proto3" json:"repeated_string,omitempty"`
+	RepeatedBytes          [][]byte                            `protobuf:"bytes,45,rep,name=repeated_bytes,json=repeatedBytes,proto3" json:"repeated_bytes,omitempty"`
+	RepeatedNestedMessage  []*TestAllTypesProto3_NestedMessage `protobuf:"bytes,48,rep,name=repeated_nested_message,json=repeatedNestedMessage,proto3" json:"repeated_nested_message,omitempty"`
+	RepeatedForeignMessage []*ForeignMessage                   `protobuf:"bytes,49,rep,name=repeated_foreign_message,json=repeatedForeignMessage,proto3" json:"repeated_foreign_message,omitempty"`
+	RepeatedNestedEnum     []TestAllTypesProto3_NestedEnum     `protobuf:"varint,51,rep,packed,name=repeated_nested_enum,json=repeatedNestedEnum,proto3,enum=protobuf_test_messages.proto3.TestAllTypesProto3_NestedEnum" json:"repeated_nested_enum,omitempty"`
+	RepeatedForeignEnum    []ForeignEnum                       `protobuf:"varint,52,rep,packed,name=repeated_foreign_enum,json=repeatedForeignEnum,proto3,enum=protobuf_test_messages.proto3.ForeignEnum" json:"repeated_foreign_enum,omitempty"`
+	RepeatedStringPiece    []string                            `protobuf:"bytes,54,rep,name=repeated_string_piece,json=repeatedStringPiece,proto3" json:"repeated_string_piece,omitempty"`
+	RepeatedCord           []string                            `protobuf:"bytes,55,rep,name=repeated_cord,json=repeatedCord,proto3" json:"repeated_cord,omitempty"`
+	// Packed
+	PackedInt32      []int32                         `protobuf:"varint,75,rep,packed,name=packed_int32,json=packedInt32,proto3" json:"packed_int32,omitempty"`
+	PackedInt64      []int64                         `protobuf:"varint,76,rep,packed,name=packed_int64,json=packedInt64,proto3" json:"packed_int64,omitempty"`
+	PackedUint32     []uint32                        `protobuf:"varint,77,rep,packed,name=packed_uint32,json=packedUint32,proto3" json:"packed_uint32,omitempty"`
+	PackedUint64     []uint64                        `protobuf:"varint,78,rep,packed,name=packed_uint64,json=packedUint64,proto3" json:"packed_uint64,omitempty"`
+	PackedSint32     []int32                         `protobuf:"zigzag32,79,rep,packed,name=packed_sint32,json=packedSint32,proto3" json:"packed_sint32,omitempty"`
+	PackedSint64     []int64                         `protobuf:"zigzag64,80,rep,packed,name=packed_sint64,json=packedSint64,proto3" json:"packed_sint64,omitempty"`
+	PackedFixed32    []uint32                        `protobuf:"fixed32,81,rep,packed,name=packed_fixed32,json=packedFixed32,proto3" json:"packed_fixed32,omitempty"`
+	PackedFixed64    []uint64                        `protobuf:"fixed64,82,rep,packed,name=packed_fixed64,json=packedFixed64,proto3" json:"packed_fixed64,omitempty"`
+	PackedSfixed32   []int32                         `protobuf:"fixed32,83,rep,packed,name=packed_sfixed32,json=packedSfixed32,proto3" json:"packed_sfixed32,omitempty"`
+	PackedSfixed64   []int64                         `protobuf:"fixed64,84,rep,packed,name=packed_sfixed64,json=packedSfixed64,proto3" json:"packed_sfixed64,omitempty"`
+	PackedFloat      []float32                       `protobuf:"fixed32,85,rep,packed,name=packed_float,json=packedFloat,proto3" json:"packed_float,omitempty"`
+	PackedDouble     []float64                       `protobuf:"fixed64,86,rep,packed,name=packed_double,json=packedDouble,proto3" json:"packed_double,omitempty"`
+	PackedBool       []bool                          `protobuf:"varint,87,rep,packed,name=packed_bool,json=packedBool,proto3" json:"packed_bool,omitempty"`
+	PackedNestedEnum []TestAllTypesProto3_NestedEnum `protobuf:"varint,88,rep,packed,name=packed_nested_enum,json=packedNestedEnum,proto3,enum=protobuf_test_messages.proto3.TestAllTypesProto3_NestedEnum" json:"packed_nested_enum,omitempty"`
+	// Unpacked
+	UnpackedInt32      []int32                         `protobuf:"varint,89,rep,name=unpacked_int32,json=unpackedInt32,proto3" json:"unpacked_int32,omitempty"`
+	UnpackedInt64      []int64                         `protobuf:"varint,90,rep,name=unpacked_int64,json=unpackedInt64,proto3" json:"unpacked_int64,omitempty"`
+	UnpackedUint32     []uint32                        `protobuf:"varint,91,rep,name=unpacked_uint32,json=unpackedUint32,proto3" json:"unpacked_uint32,omitempty"`
+	UnpackedUint64     []uint64                        `protobuf:"varint,92,rep,name=unpacked_uint64,json=unpackedUint64,proto3" json:"unpacked_uint64,omitempty"`
+	UnpackedSint32     []int32                         `protobuf:"zigzag32,93,rep,name=unpacked_sint32,json=unpackedSint32,proto3" json:"unpacked_sint32,omitempty"`
+	UnpackedSint64     []int64                         `protobuf:"zigzag64,94,rep,name=unpacked_sint64,json=unpackedSint64,proto3" json:"unpacked_sint64,omitempty"`
+	UnpackedFixed32    []uint32                        `protobuf:"fixed32,95,rep,name=unpacked_fixed32,json=unpackedFixed32,proto3" json:"unpacked_fixed32,omitempty"`
+	UnpackedFixed64    []uint64                        `protobuf:"fixed64,96,rep,name=unpacked_fixed64,json=unpackedFixed64,proto3" json:"unpacked_fixed64,omitempty"`
+	UnpackedSfixed32   []int32                         `protobuf:"fixed32,97,rep,name=unpacked_sfixed32,json=unpackedSfixed32,proto3" json:"unpacked_sfixed32,omitempty"`
+	UnpackedSfixed64   []int64                         `protobuf:"fixed64,98,rep,name=unpacked_sfixed64,json=unpackedSfixed64,proto3" json:"unpacked_sfixed64,omitempty"`
+	UnpackedFloat      []float32                       `protobuf:"fixed32,99,rep,name=unpacked_float,json=unpackedFloat,proto3" json:"unpacked_float,omitempty"`
+	UnpackedDouble     []float64                       `protobuf:"fixed64,100,rep,name=unpacked_double,json=unpackedDouble,proto3" json:"unpacked_double,omitempty"`
+	UnpackedBool       []bool                          `protobuf:"varint,101,rep,name=unpacked_bool,json=unpackedBool,proto3" json:"unpacked_bool,omitempty"`
+	UnpackedNestedEnum []TestAllTypesProto3_NestedEnum `protobuf:"varint,102,rep,name=unpacked_nested_enum,json=unpackedNestedEnum,proto3,enum=protobuf_test_messages.proto3.TestAllTypesProto3_NestedEnum" json:"unpacked_nested_enum,omitempty"`
+	// Map
+	MapInt32Int32           map[int32]int32                              `protobuf:"bytes,56,rep,name=map_int32_int32,json=mapInt32Int32,proto3" json:"map_int32_int32,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+	MapInt64Int64           map[int64]int64                              `protobuf:"bytes,57,rep,name=map_int64_int64,json=mapInt64Int64,proto3" json:"map_int64_int64,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+	MapUint32Uint32         map[uint32]uint32                            `protobuf:"bytes,58,rep,name=map_uint32_uint32,json=mapUint32Uint32,proto3" json:"map_uint32_uint32,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+	MapUint64Uint64         map[uint64]uint64                            `protobuf:"bytes,59,rep,name=map_uint64_uint64,json=mapUint64Uint64,proto3" json:"map_uint64_uint64,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+	MapSint32Sint32         map[int32]int32                              `protobuf:"bytes,60,rep,name=map_sint32_sint32,json=mapSint32Sint32,proto3" json:"map_sint32_sint32,omitempty" protobuf_key:"zigzag32,1,opt,name=key,proto3" protobuf_val:"zigzag32,2,opt,name=value,proto3"`
+	MapSint64Sint64         map[int64]int64                              `protobuf:"bytes,61,rep,name=map_sint64_sint64,json=mapSint64Sint64,proto3" json:"map_sint64_sint64,omitempty" protobuf_key:"zigzag64,1,opt,name=key,proto3" protobuf_val:"zigzag64,2,opt,name=value,proto3"`
+	MapFixed32Fixed32       map[uint32]uint32                            `protobuf:"bytes,62,rep,name=map_fixed32_fixed32,json=mapFixed32Fixed32,proto3" json:"map_fixed32_fixed32,omitempty" protobuf_key:"fixed32,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"`
+	MapFixed64Fixed64       map[uint64]uint64                            `protobuf:"bytes,63,rep,name=map_fixed64_fixed64,json=mapFixed64Fixed64,proto3" json:"map_fixed64_fixed64,omitempty" protobuf_key:"fixed64,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"`
+	MapSfixed32Sfixed32     map[int32]int32                              `protobuf:"bytes,64,rep,name=map_sfixed32_sfixed32,json=mapSfixed32Sfixed32,proto3" json:"map_sfixed32_sfixed32,omitempty" protobuf_key:"fixed32,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"`
+	MapSfixed64Sfixed64     map[int64]int64                              `protobuf:"bytes,65,rep,name=map_sfixed64_sfixed64,json=mapSfixed64Sfixed64,proto3" json:"map_sfixed64_sfixed64,omitempty" protobuf_key:"fixed64,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"`
+	MapInt32Float           map[int32]float32                            `protobuf:"bytes,66,rep,name=map_int32_float,json=mapInt32Float,proto3" json:"map_int32_float,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"`
+	MapInt32Double          map[int32]float64                            `protobuf:"bytes,67,rep,name=map_int32_double,json=mapInt32Double,proto3" json:"map_int32_double,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"`
+	MapBoolBool             map[bool]bool                                `protobuf:"bytes,68,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"`
+	MapStringString         map[string]string                            `protobuf:"bytes,69,rep,name=map_string_string,json=mapStringString,proto3" json:"map_string_string,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	MapStringBytes          map[string][]byte                            `protobuf:"bytes,70,rep,name=map_string_bytes,json=mapStringBytes,proto3" json:"map_string_bytes,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	MapStringNestedMessage  map[string]*TestAllTypesProto3_NestedMessage `protobuf:"bytes,71,rep,name=map_string_nested_message,json=mapStringNestedMessage,proto3" json:"map_string_nested_message,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	MapStringForeignMessage map[string]*ForeignMessage                   `protobuf:"bytes,72,rep,name=map_string_foreign_message,json=mapStringForeignMessage,proto3" json:"map_string_foreign_message,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	MapStringNestedEnum     map[string]TestAllTypesProto3_NestedEnum     `protobuf:"bytes,73,rep,name=map_string_nested_enum,json=mapStringNestedEnum,proto3" json:"map_string_nested_enum,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3,enum=protobuf_test_messages.proto3.TestAllTypesProto3_NestedEnum"`
+	MapStringForeignEnum    map[string]ForeignEnum                       `protobuf:"bytes,74,rep,name=map_string_foreign_enum,json=mapStringForeignEnum,proto3" json:"map_string_foreign_enum,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3,enum=protobuf_test_messages.proto3.ForeignEnum"`
+	// Types that are assignable to OneofField:
+	//	*TestAllTypesProto3_OneofUint32
+	//	*TestAllTypesProto3_OneofNestedMessage
+	//	*TestAllTypesProto3_OneofString
+	//	*TestAllTypesProto3_OneofBytes
+	//	*TestAllTypesProto3_OneofBool
+	//	*TestAllTypesProto3_OneofUint64
+	//	*TestAllTypesProto3_OneofFloat
+	//	*TestAllTypesProto3_OneofDouble
+	//	*TestAllTypesProto3_OneofEnum
+	OneofField isTestAllTypesProto3_OneofField `protobuf_oneof:"oneof_field"`
+	// Well-known types
+	OptionalBoolWrapper   *wrapperspb.BoolValue     `protobuf:"bytes,201,opt,name=optional_bool_wrapper,json=optionalBoolWrapper,proto3" json:"optional_bool_wrapper,omitempty"`
+	OptionalInt32Wrapper  *wrapperspb.Int32Value    `protobuf:"bytes,202,opt,name=optional_int32_wrapper,json=optionalInt32Wrapper,proto3" json:"optional_int32_wrapper,omitempty"`
+	OptionalInt64Wrapper  *wrapperspb.Int64Value    `protobuf:"bytes,203,opt,name=optional_int64_wrapper,json=optionalInt64Wrapper,proto3" json:"optional_int64_wrapper,omitempty"`
+	OptionalUint32Wrapper *wrapperspb.UInt32Value   `protobuf:"bytes,204,opt,name=optional_uint32_wrapper,json=optionalUint32Wrapper,proto3" json:"optional_uint32_wrapper,omitempty"`
+	OptionalUint64Wrapper *wrapperspb.UInt64Value   `protobuf:"bytes,205,opt,name=optional_uint64_wrapper,json=optionalUint64Wrapper,proto3" json:"optional_uint64_wrapper,omitempty"`
+	OptionalFloatWrapper  *wrapperspb.FloatValue    `protobuf:"bytes,206,opt,name=optional_float_wrapper,json=optionalFloatWrapper,proto3" json:"optional_float_wrapper,omitempty"`
+	OptionalDoubleWrapper *wrapperspb.DoubleValue   `protobuf:"bytes,207,opt,name=optional_double_wrapper,json=optionalDoubleWrapper,proto3" json:"optional_double_wrapper,omitempty"`
+	OptionalStringWrapper *wrapperspb.StringValue   `protobuf:"bytes,208,opt,name=optional_string_wrapper,json=optionalStringWrapper,proto3" json:"optional_string_wrapper,omitempty"`
+	OptionalBytesWrapper  *wrapperspb.BytesValue    `protobuf:"bytes,209,opt,name=optional_bytes_wrapper,json=optionalBytesWrapper,proto3" json:"optional_bytes_wrapper,omitempty"`
+	RepeatedBoolWrapper   []*wrapperspb.BoolValue   `protobuf:"bytes,211,rep,name=repeated_bool_wrapper,json=repeatedBoolWrapper,proto3" json:"repeated_bool_wrapper,omitempty"`
+	RepeatedInt32Wrapper  []*wrapperspb.Int32Value  `protobuf:"bytes,212,rep,name=repeated_int32_wrapper,json=repeatedInt32Wrapper,proto3" json:"repeated_int32_wrapper,omitempty"`
+	RepeatedInt64Wrapper  []*wrapperspb.Int64Value  `protobuf:"bytes,213,rep,name=repeated_int64_wrapper,json=repeatedInt64Wrapper,proto3" json:"repeated_int64_wrapper,omitempty"`
+	RepeatedUint32Wrapper []*wrapperspb.UInt32Value `protobuf:"bytes,214,rep,name=repeated_uint32_wrapper,json=repeatedUint32Wrapper,proto3" json:"repeated_uint32_wrapper,omitempty"`
+	RepeatedUint64Wrapper []*wrapperspb.UInt64Value `protobuf:"bytes,215,rep,name=repeated_uint64_wrapper,json=repeatedUint64Wrapper,proto3" json:"repeated_uint64_wrapper,omitempty"`
+	RepeatedFloatWrapper  []*wrapperspb.FloatValue  `protobuf:"bytes,216,rep,name=repeated_float_wrapper,json=repeatedFloatWrapper,proto3" json:"repeated_float_wrapper,omitempty"`
+	RepeatedDoubleWrapper []*wrapperspb.DoubleValue `protobuf:"bytes,217,rep,name=repeated_double_wrapper,json=repeatedDoubleWrapper,proto3" json:"repeated_double_wrapper,omitempty"`
+	RepeatedStringWrapper []*wrapperspb.StringValue `protobuf:"bytes,218,rep,name=repeated_string_wrapper,json=repeatedStringWrapper,proto3" json:"repeated_string_wrapper,omitempty"`
+	RepeatedBytesWrapper  []*wrapperspb.BytesValue  `protobuf:"bytes,219,rep,name=repeated_bytes_wrapper,json=repeatedBytesWrapper,proto3" json:"repeated_bytes_wrapper,omitempty"`
+	OptionalDuration      *durationpb.Duration      `protobuf:"bytes,301,opt,name=optional_duration,json=optionalDuration,proto3" json:"optional_duration,omitempty"`
+	OptionalTimestamp     *timestamppb.Timestamp    `protobuf:"bytes,302,opt,name=optional_timestamp,json=optionalTimestamp,proto3" json:"optional_timestamp,omitempty"`
+	OptionalFieldMask     *fieldmaskpb.FieldMask    `protobuf:"bytes,303,opt,name=optional_field_mask,json=optionalFieldMask,proto3" json:"optional_field_mask,omitempty"`
+	OptionalStruct        *structpb.Struct          `protobuf:"bytes,304,opt,name=optional_struct,json=optionalStruct,proto3" json:"optional_struct,omitempty"`
+	OptionalAny           *anypb.Any                `protobuf:"bytes,305,opt,name=optional_any,json=optionalAny,proto3" json:"optional_any,omitempty"`
+	OptionalValue         *structpb.Value           `protobuf:"bytes,306,opt,name=optional_value,json=optionalValue,proto3" json:"optional_value,omitempty"`
+	RepeatedDuration      []*durationpb.Duration    `protobuf:"bytes,311,rep,name=repeated_duration,json=repeatedDuration,proto3" json:"repeated_duration,omitempty"`
+	RepeatedTimestamp     []*timestamppb.Timestamp  `protobuf:"bytes,312,rep,name=repeated_timestamp,json=repeatedTimestamp,proto3" json:"repeated_timestamp,omitempty"`
+	RepeatedFieldmask     []*fieldmaskpb.FieldMask  `protobuf:"bytes,313,rep,name=repeated_fieldmask,json=repeatedFieldmask,proto3" json:"repeated_fieldmask,omitempty"`
+	RepeatedStruct        []*structpb.Struct        `protobuf:"bytes,324,rep,name=repeated_struct,json=repeatedStruct,proto3" json:"repeated_struct,omitempty"`
+	RepeatedAny           []*anypb.Any              `protobuf:"bytes,315,rep,name=repeated_any,json=repeatedAny,proto3" json:"repeated_any,omitempty"`
+	RepeatedValue         []*structpb.Value         `protobuf:"bytes,316,rep,name=repeated_value,json=repeatedValue,proto3" json:"repeated_value,omitempty"`
+	RepeatedListValue     []*structpb.ListValue     `protobuf:"bytes,317,rep,name=repeated_list_value,json=repeatedListValue,proto3" json:"repeated_list_value,omitempty"`
+	// Test field-name-to-JSON-name convention.
+	// (protobuf says names can be any valid C/C++ identifier.)
+	Fieldname1    int32 `protobuf:"varint,401,opt,name=fieldname1,proto3" json:"fieldname1,omitempty"`
+	FieldName2    int32 `protobuf:"varint,402,opt,name=field_name2,json=fieldName2,proto3" json:"field_name2,omitempty"`
+	XFieldName3   int32 `protobuf:"varint,403,opt,name=_field_name3,json=FieldName3,proto3" json:"_field_name3,omitempty"`
+	Field_Name4_  int32 `protobuf:"varint,404,opt,name=field__name4_,json=fieldName4,proto3" json:"field__name4_,omitempty"`
+	Field0Name5   int32 `protobuf:"varint,405,opt,name=field0name5,proto3" json:"field0name5,omitempty"`
+	Field_0Name6  int32 `protobuf:"varint,406,opt,name=field_0_name6,json=field0Name6,proto3" json:"field_0_name6,omitempty"`
+	FieldName7    int32 `protobuf:"varint,407,opt,name=fieldName7,proto3" json:"fieldName7,omitempty"`
+	FieldName8    int32 `protobuf:"varint,408,opt,name=FieldName8,proto3" json:"FieldName8,omitempty"`
+	Field_Name9   int32 `protobuf:"varint,409,opt,name=field_Name9,json=fieldName9,proto3" json:"field_Name9,omitempty"`
+	Field_Name10  int32 `protobuf:"varint,410,opt,name=Field_Name10,json=FieldName10,proto3" json:"Field_Name10,omitempty"`
+	FIELD_NAME11  int32 `protobuf:"varint,411,opt,name=FIELD_NAME11,json=FIELDNAME11,proto3" json:"FIELD_NAME11,omitempty"`
+	FIELDName12   int32 `protobuf:"varint,412,opt,name=FIELD_name12,json=FIELDName12,proto3" json:"FIELD_name12,omitempty"`
+	XFieldName13  int32 `protobuf:"varint,413,opt,name=__field_name13,json=FieldName13,proto3" json:"__field_name13,omitempty"`
+	X_FieldName14 int32 `protobuf:"varint,414,opt,name=__Field_name14,json=FieldName14,proto3" json:"__Field_name14,omitempty"`
+	Field_Name15  int32 `protobuf:"varint,415,opt,name=field__name15,json=fieldName15,proto3" json:"field__name15,omitempty"`
+	Field__Name16 int32 `protobuf:"varint,416,opt,name=field__Name16,json=fieldName16,proto3" json:"field__Name16,omitempty"`
+	FieldName17__ int32 `protobuf:"varint,417,opt,name=field_name17__,json=fieldName17,proto3" json:"field_name17__,omitempty"`
+	FieldName18__ int32 `protobuf:"varint,418,opt,name=Field_name18__,json=FieldName18,proto3" json:"Field_name18__,omitempty"`
+}
+
+func (x *TestAllTypesProto3) Reset() {
+	*x = TestAllTypesProto3{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_test_messages_proto3_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *TestAllTypesProto3) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TestAllTypesProto3) ProtoMessage() {}
+
+func (x *TestAllTypesProto3) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_test_messages_proto3_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TestAllTypesProto3.ProtoReflect.Descriptor instead.
+func (*TestAllTypesProto3) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_test_messages_proto3_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *TestAllTypesProto3) GetOptionalInt32() int32 {
+	if x != nil {
+		return x.OptionalInt32
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto3) GetOptionalInt64() int64 {
+	if x != nil {
+		return x.OptionalInt64
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto3) GetOptionalUint32() uint32 {
+	if x != nil {
+		return x.OptionalUint32
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto3) GetOptionalUint64() uint64 {
+	if x != nil {
+		return x.OptionalUint64
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto3) GetOptionalSint32() int32 {
+	if x != nil {
+		return x.OptionalSint32
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto3) GetOptionalSint64() int64 {
+	if x != nil {
+		return x.OptionalSint64
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto3) GetOptionalFixed32() uint32 {
+	if x != nil {
+		return x.OptionalFixed32
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto3) GetOptionalFixed64() uint64 {
+	if x != nil {
+		return x.OptionalFixed64
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto3) GetOptionalSfixed32() int32 {
+	if x != nil {
+		return x.OptionalSfixed32
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto3) GetOptionalSfixed64() int64 {
+	if x != nil {
+		return x.OptionalSfixed64
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto3) GetOptionalFloat() float32 {
+	if x != nil {
+		return x.OptionalFloat
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto3) GetOptionalDouble() float64 {
+	if x != nil {
+		return x.OptionalDouble
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto3) GetOptionalBool() bool {
+	if x != nil {
+		return x.OptionalBool
+	}
+	return false
+}
+
+func (x *TestAllTypesProto3) GetOptionalString() string {
+	if x != nil {
+		return x.OptionalString
+	}
+	return ""
+}
+
+func (x *TestAllTypesProto3) GetOptionalBytes() []byte {
+	if x != nil {
+		return x.OptionalBytes
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetOptionalNestedMessage() *TestAllTypesProto3_NestedMessage {
+	if x != nil {
+		return x.OptionalNestedMessage
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetOptionalForeignMessage() *ForeignMessage {
+	if x != nil {
+		return x.OptionalForeignMessage
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetOptionalNestedEnum() TestAllTypesProto3_NestedEnum {
+	if x != nil {
+		return x.OptionalNestedEnum
+	}
+	return TestAllTypesProto3_FOO
+}
+
+func (x *TestAllTypesProto3) GetOptionalForeignEnum() ForeignEnum {
+	if x != nil {
+		return x.OptionalForeignEnum
+	}
+	return ForeignEnum_FOREIGN_FOO
+}
+
+func (x *TestAllTypesProto3) GetOptionalAliasedEnum() TestAllTypesProto3_AliasedEnum {
+	if x != nil {
+		return x.OptionalAliasedEnum
+	}
+	return TestAllTypesProto3_ALIAS_FOO
+}
+
+func (x *TestAllTypesProto3) GetOptionalStringPiece() string {
+	if x != nil {
+		return x.OptionalStringPiece
+	}
+	return ""
+}
+
+func (x *TestAllTypesProto3) GetOptionalCord() string {
+	if x != nil {
+		return x.OptionalCord
+	}
+	return ""
+}
+
+func (x *TestAllTypesProto3) GetRecursiveMessage() *TestAllTypesProto3 {
+	if x != nil {
+		return x.RecursiveMessage
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedInt32() []int32 {
+	if x != nil {
+		return x.RepeatedInt32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedInt64() []int64 {
+	if x != nil {
+		return x.RepeatedInt64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedUint32() []uint32 {
+	if x != nil {
+		return x.RepeatedUint32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedUint64() []uint64 {
+	if x != nil {
+		return x.RepeatedUint64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedSint32() []int32 {
+	if x != nil {
+		return x.RepeatedSint32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedSint64() []int64 {
+	if x != nil {
+		return x.RepeatedSint64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedFixed32() []uint32 {
+	if x != nil {
+		return x.RepeatedFixed32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedFixed64() []uint64 {
+	if x != nil {
+		return x.RepeatedFixed64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedSfixed32() []int32 {
+	if x != nil {
+		return x.RepeatedSfixed32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedSfixed64() []int64 {
+	if x != nil {
+		return x.RepeatedSfixed64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedFloat() []float32 {
+	if x != nil {
+		return x.RepeatedFloat
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedDouble() []float64 {
+	if x != nil {
+		return x.RepeatedDouble
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedBool() []bool {
+	if x != nil {
+		return x.RepeatedBool
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedString() []string {
+	if x != nil {
+		return x.RepeatedString
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedBytes() [][]byte {
+	if x != nil {
+		return x.RepeatedBytes
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedNestedMessage() []*TestAllTypesProto3_NestedMessage {
+	if x != nil {
+		return x.RepeatedNestedMessage
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedForeignMessage() []*ForeignMessage {
+	if x != nil {
+		return x.RepeatedForeignMessage
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedNestedEnum() []TestAllTypesProto3_NestedEnum {
+	if x != nil {
+		return x.RepeatedNestedEnum
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedForeignEnum() []ForeignEnum {
+	if x != nil {
+		return x.RepeatedForeignEnum
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedStringPiece() []string {
+	if x != nil {
+		return x.RepeatedStringPiece
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedCord() []string {
+	if x != nil {
+		return x.RepeatedCord
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetPackedInt32() []int32 {
+	if x != nil {
+		return x.PackedInt32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetPackedInt64() []int64 {
+	if x != nil {
+		return x.PackedInt64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetPackedUint32() []uint32 {
+	if x != nil {
+		return x.PackedUint32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetPackedUint64() []uint64 {
+	if x != nil {
+		return x.PackedUint64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetPackedSint32() []int32 {
+	if x != nil {
+		return x.PackedSint32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetPackedSint64() []int64 {
+	if x != nil {
+		return x.PackedSint64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetPackedFixed32() []uint32 {
+	if x != nil {
+		return x.PackedFixed32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetPackedFixed64() []uint64 {
+	if x != nil {
+		return x.PackedFixed64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetPackedSfixed32() []int32 {
+	if x != nil {
+		return x.PackedSfixed32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetPackedSfixed64() []int64 {
+	if x != nil {
+		return x.PackedSfixed64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetPackedFloat() []float32 {
+	if x != nil {
+		return x.PackedFloat
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetPackedDouble() []float64 {
+	if x != nil {
+		return x.PackedDouble
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetPackedBool() []bool {
+	if x != nil {
+		return x.PackedBool
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetPackedNestedEnum() []TestAllTypesProto3_NestedEnum {
+	if x != nil {
+		return x.PackedNestedEnum
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetUnpackedInt32() []int32 {
+	if x != nil {
+		return x.UnpackedInt32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetUnpackedInt64() []int64 {
+	if x != nil {
+		return x.UnpackedInt64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetUnpackedUint32() []uint32 {
+	if x != nil {
+		return x.UnpackedUint32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetUnpackedUint64() []uint64 {
+	if x != nil {
+		return x.UnpackedUint64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetUnpackedSint32() []int32 {
+	if x != nil {
+		return x.UnpackedSint32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetUnpackedSint64() []int64 {
+	if x != nil {
+		return x.UnpackedSint64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetUnpackedFixed32() []uint32 {
+	if x != nil {
+		return x.UnpackedFixed32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetUnpackedFixed64() []uint64 {
+	if x != nil {
+		return x.UnpackedFixed64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetUnpackedSfixed32() []int32 {
+	if x != nil {
+		return x.UnpackedSfixed32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetUnpackedSfixed64() []int64 {
+	if x != nil {
+		return x.UnpackedSfixed64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetUnpackedFloat() []float32 {
+	if x != nil {
+		return x.UnpackedFloat
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetUnpackedDouble() []float64 {
+	if x != nil {
+		return x.UnpackedDouble
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetUnpackedBool() []bool {
+	if x != nil {
+		return x.UnpackedBool
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetUnpackedNestedEnum() []TestAllTypesProto3_NestedEnum {
+	if x != nil {
+		return x.UnpackedNestedEnum
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetMapInt32Int32() map[int32]int32 {
+	if x != nil {
+		return x.MapInt32Int32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetMapInt64Int64() map[int64]int64 {
+	if x != nil {
+		return x.MapInt64Int64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetMapUint32Uint32() map[uint32]uint32 {
+	if x != nil {
+		return x.MapUint32Uint32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetMapUint64Uint64() map[uint64]uint64 {
+	if x != nil {
+		return x.MapUint64Uint64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetMapSint32Sint32() map[int32]int32 {
+	if x != nil {
+		return x.MapSint32Sint32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetMapSint64Sint64() map[int64]int64 {
+	if x != nil {
+		return x.MapSint64Sint64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetMapFixed32Fixed32() map[uint32]uint32 {
+	if x != nil {
+		return x.MapFixed32Fixed32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetMapFixed64Fixed64() map[uint64]uint64 {
+	if x != nil {
+		return x.MapFixed64Fixed64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetMapSfixed32Sfixed32() map[int32]int32 {
+	if x != nil {
+		return x.MapSfixed32Sfixed32
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetMapSfixed64Sfixed64() map[int64]int64 {
+	if x != nil {
+		return x.MapSfixed64Sfixed64
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetMapInt32Float() map[int32]float32 {
+	if x != nil {
+		return x.MapInt32Float
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetMapInt32Double() map[int32]float64 {
+	if x != nil {
+		return x.MapInt32Double
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetMapBoolBool() map[bool]bool {
+	if x != nil {
+		return x.MapBoolBool
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetMapStringString() map[string]string {
+	if x != nil {
+		return x.MapStringString
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetMapStringBytes() map[string][]byte {
+	if x != nil {
+		return x.MapStringBytes
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetMapStringNestedMessage() map[string]*TestAllTypesProto3_NestedMessage {
+	if x != nil {
+		return x.MapStringNestedMessage
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetMapStringForeignMessage() map[string]*ForeignMessage {
+	if x != nil {
+		return x.MapStringForeignMessage
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetMapStringNestedEnum() map[string]TestAllTypesProto3_NestedEnum {
+	if x != nil {
+		return x.MapStringNestedEnum
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetMapStringForeignEnum() map[string]ForeignEnum {
+	if x != nil {
+		return x.MapStringForeignEnum
+	}
+	return nil
+}
+
+func (m *TestAllTypesProto3) GetOneofField() isTestAllTypesProto3_OneofField {
+	if m != nil {
+		return m.OneofField
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetOneofUint32() uint32 {
+	if x, ok := x.GetOneofField().(*TestAllTypesProto3_OneofUint32); ok {
+		return x.OneofUint32
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto3) GetOneofNestedMessage() *TestAllTypesProto3_NestedMessage {
+	if x, ok := x.GetOneofField().(*TestAllTypesProto3_OneofNestedMessage); ok {
+		return x.OneofNestedMessage
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetOneofString() string {
+	if x, ok := x.GetOneofField().(*TestAllTypesProto3_OneofString); ok {
+		return x.OneofString
+	}
+	return ""
+}
+
+func (x *TestAllTypesProto3) GetOneofBytes() []byte {
+	if x, ok := x.GetOneofField().(*TestAllTypesProto3_OneofBytes); ok {
+		return x.OneofBytes
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetOneofBool() bool {
+	if x, ok := x.GetOneofField().(*TestAllTypesProto3_OneofBool); ok {
+		return x.OneofBool
+	}
+	return false
+}
+
+func (x *TestAllTypesProto3) GetOneofUint64() uint64 {
+	if x, ok := x.GetOneofField().(*TestAllTypesProto3_OneofUint64); ok {
+		return x.OneofUint64
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto3) GetOneofFloat() float32 {
+	if x, ok := x.GetOneofField().(*TestAllTypesProto3_OneofFloat); ok {
+		return x.OneofFloat
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto3) GetOneofDouble() float64 {
+	if x, ok := x.GetOneofField().(*TestAllTypesProto3_OneofDouble); ok {
+		return x.OneofDouble
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto3) GetOneofEnum() TestAllTypesProto3_NestedEnum {
+	if x, ok := x.GetOneofField().(*TestAllTypesProto3_OneofEnum); ok {
+		return x.OneofEnum
+	}
+	return TestAllTypesProto3_FOO
+}
+
+func (x *TestAllTypesProto3) GetOptionalBoolWrapper() *wrapperspb.BoolValue {
+	if x != nil {
+		return x.OptionalBoolWrapper
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetOptionalInt32Wrapper() *wrapperspb.Int32Value {
+	if x != nil {
+		return x.OptionalInt32Wrapper
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetOptionalInt64Wrapper() *wrapperspb.Int64Value {
+	if x != nil {
+		return x.OptionalInt64Wrapper
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetOptionalUint32Wrapper() *wrapperspb.UInt32Value {
+	if x != nil {
+		return x.OptionalUint32Wrapper
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetOptionalUint64Wrapper() *wrapperspb.UInt64Value {
+	if x != nil {
+		return x.OptionalUint64Wrapper
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetOptionalFloatWrapper() *wrapperspb.FloatValue {
+	if x != nil {
+		return x.OptionalFloatWrapper
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetOptionalDoubleWrapper() *wrapperspb.DoubleValue {
+	if x != nil {
+		return x.OptionalDoubleWrapper
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetOptionalStringWrapper() *wrapperspb.StringValue {
+	if x != nil {
+		return x.OptionalStringWrapper
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetOptionalBytesWrapper() *wrapperspb.BytesValue {
+	if x != nil {
+		return x.OptionalBytesWrapper
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedBoolWrapper() []*wrapperspb.BoolValue {
+	if x != nil {
+		return x.RepeatedBoolWrapper
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedInt32Wrapper() []*wrapperspb.Int32Value {
+	if x != nil {
+		return x.RepeatedInt32Wrapper
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedInt64Wrapper() []*wrapperspb.Int64Value {
+	if x != nil {
+		return x.RepeatedInt64Wrapper
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedUint32Wrapper() []*wrapperspb.UInt32Value {
+	if x != nil {
+		return x.RepeatedUint32Wrapper
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedUint64Wrapper() []*wrapperspb.UInt64Value {
+	if x != nil {
+		return x.RepeatedUint64Wrapper
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedFloatWrapper() []*wrapperspb.FloatValue {
+	if x != nil {
+		return x.RepeatedFloatWrapper
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedDoubleWrapper() []*wrapperspb.DoubleValue {
+	if x != nil {
+		return x.RepeatedDoubleWrapper
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedStringWrapper() []*wrapperspb.StringValue {
+	if x != nil {
+		return x.RepeatedStringWrapper
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedBytesWrapper() []*wrapperspb.BytesValue {
+	if x != nil {
+		return x.RepeatedBytesWrapper
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetOptionalDuration() *durationpb.Duration {
+	if x != nil {
+		return x.OptionalDuration
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetOptionalTimestamp() *timestamppb.Timestamp {
+	if x != nil {
+		return x.OptionalTimestamp
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetOptionalFieldMask() *fieldmaskpb.FieldMask {
+	if x != nil {
+		return x.OptionalFieldMask
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetOptionalStruct() *structpb.Struct {
+	if x != nil {
+		return x.OptionalStruct
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetOptionalAny() *anypb.Any {
+	if x != nil {
+		return x.OptionalAny
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetOptionalValue() *structpb.Value {
+	if x != nil {
+		return x.OptionalValue
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedDuration() []*durationpb.Duration {
+	if x != nil {
+		return x.RepeatedDuration
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedTimestamp() []*timestamppb.Timestamp {
+	if x != nil {
+		return x.RepeatedTimestamp
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedFieldmask() []*fieldmaskpb.FieldMask {
+	if x != nil {
+		return x.RepeatedFieldmask
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedStruct() []*structpb.Struct {
+	if x != nil {
+		return x.RepeatedStruct
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedAny() []*anypb.Any {
+	if x != nil {
+		return x.RepeatedAny
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedValue() []*structpb.Value {
+	if x != nil {
+		return x.RepeatedValue
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetRepeatedListValue() []*structpb.ListValue {
+	if x != nil {
+		return x.RepeatedListValue
+	}
+	return nil
+}
+
+func (x *TestAllTypesProto3) GetFieldname1() int32 {
+	if x != nil {
+		return x.Fieldname1
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto3) GetFieldName2() int32 {
+	if x != nil {
+		return x.FieldName2
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto3) GetXFieldName3() int32 {
+	if x != nil {
+		return x.XFieldName3
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto3) GetField_Name4_() int32 {
+	if x != nil {
+		return x.Field_Name4_
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto3) GetField0Name5() int32 {
+	if x != nil {
+		return x.Field0Name5
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto3) GetField_0Name6() int32 {
+	if x != nil {
+		return x.Field_0Name6
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto3) GetFieldName7() int32 {
+	if x != nil {
+		return x.FieldName7
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto3) GetFieldName8() int32 {
+	if x != nil {
+		return x.FieldName8
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto3) GetField_Name9() int32 {
+	if x != nil {
+		return x.Field_Name9
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto3) GetField_Name10() int32 {
+	if x != nil {
+		return x.Field_Name10
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto3) GetFIELD_NAME11() int32 {
+	if x != nil {
+		return x.FIELD_NAME11
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto3) GetFIELDName12() int32 {
+	if x != nil {
+		return x.FIELDName12
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto3) GetXFieldName13() int32 {
+	if x != nil {
+		return x.XFieldName13
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto3) GetX_FieldName14() int32 {
+	if x != nil {
+		return x.X_FieldName14
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto3) GetField_Name15() int32 {
+	if x != nil {
+		return x.Field_Name15
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto3) GetField__Name16() int32 {
+	if x != nil {
+		return x.Field__Name16
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto3) GetFieldName17__() int32 {
+	if x != nil {
+		return x.FieldName17__
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto3) GetFieldName18__() int32 {
+	if x != nil {
+		return x.FieldName18__
+	}
+	return 0
+}
+
+type isTestAllTypesProto3_OneofField interface {
+	isTestAllTypesProto3_OneofField()
+}
+
+type TestAllTypesProto3_OneofUint32 struct {
+	OneofUint32 uint32 `protobuf:"varint,111,opt,name=oneof_uint32,json=oneofUint32,proto3,oneof"`
+}
+
+type TestAllTypesProto3_OneofNestedMessage struct {
+	OneofNestedMessage *TestAllTypesProto3_NestedMessage `protobuf:"bytes,112,opt,name=oneof_nested_message,json=oneofNestedMessage,proto3,oneof"`
+}
+
+type TestAllTypesProto3_OneofString struct {
+	OneofString string `protobuf:"bytes,113,opt,name=oneof_string,json=oneofString,proto3,oneof"`
+}
+
+type TestAllTypesProto3_OneofBytes struct {
+	OneofBytes []byte `protobuf:"bytes,114,opt,name=oneof_bytes,json=oneofBytes,proto3,oneof"`
+}
+
+type TestAllTypesProto3_OneofBool struct {
+	OneofBool bool `protobuf:"varint,115,opt,name=oneof_bool,json=oneofBool,proto3,oneof"`
+}
+
+type TestAllTypesProto3_OneofUint64 struct {
+	OneofUint64 uint64 `protobuf:"varint,116,opt,name=oneof_uint64,json=oneofUint64,proto3,oneof"`
+}
+
+type TestAllTypesProto3_OneofFloat struct {
+	OneofFloat float32 `protobuf:"fixed32,117,opt,name=oneof_float,json=oneofFloat,proto3,oneof"`
+}
+
+type TestAllTypesProto3_OneofDouble struct {
+	OneofDouble float64 `protobuf:"fixed64,118,opt,name=oneof_double,json=oneofDouble,proto3,oneof"`
+}
+
+type TestAllTypesProto3_OneofEnum struct {
+	OneofEnum TestAllTypesProto3_NestedEnum `protobuf:"varint,119,opt,name=oneof_enum,json=oneofEnum,proto3,enum=protobuf_test_messages.proto3.TestAllTypesProto3_NestedEnum,oneof"`
+}
+
+func (*TestAllTypesProto3_OneofUint32) isTestAllTypesProto3_OneofField() {}
+
+func (*TestAllTypesProto3_OneofNestedMessage) isTestAllTypesProto3_OneofField() {}
+
+func (*TestAllTypesProto3_OneofString) isTestAllTypesProto3_OneofField() {}
+
+func (*TestAllTypesProto3_OneofBytes) isTestAllTypesProto3_OneofField() {}
+
+func (*TestAllTypesProto3_OneofBool) isTestAllTypesProto3_OneofField() {}
+
+func (*TestAllTypesProto3_OneofUint64) isTestAllTypesProto3_OneofField() {}
+
+func (*TestAllTypesProto3_OneofFloat) isTestAllTypesProto3_OneofField() {}
+
+func (*TestAllTypesProto3_OneofDouble) isTestAllTypesProto3_OneofField() {}
+
+func (*TestAllTypesProto3_OneofEnum) isTestAllTypesProto3_OneofField() {}
+
+type ForeignMessage struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	C int32 `protobuf:"varint,1,opt,name=c,proto3" json:"c,omitempty"`
+}
+
+func (x *ForeignMessage) Reset() {
+	*x = ForeignMessage{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_test_messages_proto3_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *ForeignMessage) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ForeignMessage) ProtoMessage() {}
+
+func (x *ForeignMessage) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_test_messages_proto3_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ForeignMessage.ProtoReflect.Descriptor instead.
+func (*ForeignMessage) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_test_messages_proto3_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *ForeignMessage) GetC() int32 {
+	if x != nil {
+		return x.C
+	}
+	return 0
+}
+
+type TestAllTypesProto3_NestedMessage struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	A           int32               `protobuf:"varint,1,opt,name=a,proto3" json:"a,omitempty"`
+	Corecursive *TestAllTypesProto3 `protobuf:"bytes,2,opt,name=corecursive,proto3" json:"corecursive,omitempty"`
+}
+
+func (x *TestAllTypesProto3_NestedMessage) Reset() {
+	*x = TestAllTypesProto3_NestedMessage{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_test_messages_proto3_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *TestAllTypesProto3_NestedMessage) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TestAllTypesProto3_NestedMessage) ProtoMessage() {}
+
+func (x *TestAllTypesProto3_NestedMessage) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_test_messages_proto3_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TestAllTypesProto3_NestedMessage.ProtoReflect.Descriptor instead.
+func (*TestAllTypesProto3_NestedMessage) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_test_messages_proto3_proto_rawDescGZIP(), []int{0, 0}
+}
+
+func (x *TestAllTypesProto3_NestedMessage) GetA() int32 {
+	if x != nil {
+		return x.A
+	}
+	return 0
+}
+
+func (x *TestAllTypesProto3_NestedMessage) GetCorecursive() *TestAllTypesProto3 {
+	if x != nil {
+		return x.Corecursive
+	}
+	return nil
+}
+
+var File_google_protobuf_test_messages_proto3_proto protoreflect.FileDescriptor
+
+var file_google_protobuf_test_messages_proto3_proto_rawDesc = []byte{
+	0x0a, 0x2a, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x5f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1d, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x1a, 0x19, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x61, 0x6e, 0x79,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x20, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x6d, 0x61,
+	0x73, 0x6b, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d,
+	0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72,
+	0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x84, 0x5a, 0x0a, 0x12, 0x54, 0x65, 0x73, 0x74,
+	0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x12, 0x25,
+	0x0a, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x25, 0x0a, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x27, 0x0a, 0x0f,
+	0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x55,
+	0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x27, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e,
+	0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x27,
+	0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x33,
+	0x32, 0x18, 0x05, 0x20, 0x01, 0x28, 0x11, 0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x27, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x06, 0x20, 0x01, 0x28, 0x12,
+	0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34,
+	0x12, 0x29, 0x0a, 0x10, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x66, 0x69, 0x78,
+	0x65, 0x64, 0x33, 0x32, 0x18, 0x07, 0x20, 0x01, 0x28, 0x07, 0x52, 0x0f, 0x6f, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x61, 0x6c, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x29, 0x0a, 0x10, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18,
+	0x08, 0x20, 0x01, 0x28, 0x06, 0x52, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x46,
+	0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x2b, 0x0a, 0x11, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+	0x61, 0x6c, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x09, 0x20, 0x01, 0x28,
+	0x0f, 0x52, 0x10, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x66, 0x69, 0x78, 0x65,
+	0x64, 0x33, 0x32, 0x12, 0x2b, 0x0a, 0x11, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f,
+	0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x10, 0x52, 0x10,
+	0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34,
+	0x12, 0x25, 0x0a, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x66, 0x6c, 0x6f,
+	0x61, 0x74, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+	0x61, 0x6c, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x01,
+	0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65,
+	0x12, 0x23, 0x0a, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x62, 0x6f, 0x6f,
+	0x6c, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x27, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e,
+	0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x25,
+	0x0a, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73,
+	0x18, 0x0f, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x77, 0x0a, 0x17, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x18, 0x12, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x3f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79,
+	0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x15, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x67,
+	0x0a, 0x18, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x66, 0x6f, 0x72, 0x65, 0x69,
+	0x67, 0x6e, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x13, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x2d, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x2e, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x16, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x6e, 0x0a, 0x14, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18,
+	0x15, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x3c, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
+	0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70,
+	0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45,
+	0x6e, 0x75, 0x6d, 0x52, 0x12, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x4e, 0x65, 0x73,
+	0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x5e, 0x0a, 0x15, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x5f, 0x66, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x5f, 0x65, 0x6e, 0x75, 0x6d,
+	0x18, 0x16, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2a, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x45, 0x6e,
+	0x75, 0x6d, 0x52, 0x13, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x46, 0x6f, 0x72, 0x65,
+	0x69, 0x67, 0x6e, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x71, 0x0a, 0x15, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x65, 0x64, 0x5f, 0x65, 0x6e, 0x75, 0x6d,
+	0x18, 0x17, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x3d, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79,
+	0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x65,
+	0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x13, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x41,
+	0x6c, 0x69, 0x61, 0x73, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x36, 0x0a, 0x15, 0x6f, 0x70,
+	0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x69,
+	0x65, 0x63, 0x65, 0x18, 0x18, 0x20, 0x01, 0x28, 0x09, 0x42, 0x02, 0x08, 0x02, 0x52, 0x13, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x50, 0x69, 0x65,
+	0x63, 0x65, 0x12, 0x27, 0x0a, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x63,
+	0x6f, 0x72, 0x64, 0x18, 0x19, 0x20, 0x01, 0x28, 0x09, 0x42, 0x02, 0x08, 0x01, 0x52, 0x0c, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x43, 0x6f, 0x72, 0x64, 0x12, 0x5e, 0x0a, 0x11, 0x72,
+	0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x76, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x18, 0x1b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79,
+	0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x52, 0x10, 0x72, 0x65, 0x63, 0x75, 0x72,
+	0x73, 0x69, 0x76, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x72,
+	0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x1f, 0x20,
+	0x03, 0x28, 0x05, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x49, 0x6e, 0x74,
+	0x33, 0x32, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x69,
+	0x6e, 0x74, 0x36, 0x34, 0x18, 0x20, 0x20, 0x03, 0x28, 0x03, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x65,
+	0x61, 0x74, 0x65, 0x64, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x70,
+	0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x21, 0x20, 0x03,
+	0x28, 0x0d, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x55, 0x69, 0x6e, 0x74,
+	0x33, 0x32, 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x75,
+	0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x22, 0x20, 0x03, 0x28, 0x04, 0x52, 0x0e, 0x72, 0x65, 0x70,
+	0x65, 0x61, 0x74, 0x65, 0x64, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x27, 0x0a, 0x0f, 0x72,
+	0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x23,
+	0x20, 0x03, 0x28, 0x11, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x53, 0x69,
+	0x6e, 0x74, 0x33, 0x32, 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
+	0x5f, 0x73, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x24, 0x20, 0x03, 0x28, 0x12, 0x52, 0x0e, 0x72,
+	0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x29, 0x0a,
+	0x10, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33,
+	0x32, 0x18, 0x25, 0x20, 0x03, 0x28, 0x07, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65,
+	0x64, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x29, 0x0a, 0x10, 0x72, 0x65, 0x70, 0x65,
+	0x61, 0x74, 0x65, 0x64, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x26, 0x20, 0x03,
+	0x28, 0x06, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x46, 0x69, 0x78, 0x65,
+	0x64, 0x36, 0x34, 0x12, 0x2b, 0x0a, 0x11, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f,
+	0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x27, 0x20, 0x03, 0x28, 0x0f, 0x52, 0x10,
+	0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32,
+	0x12, 0x2b, 0x0a, 0x11, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x73, 0x66, 0x69,
+	0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x28, 0x20, 0x03, 0x28, 0x10, 0x52, 0x10, 0x72, 0x65, 0x70,
+	0x65, 0x61, 0x74, 0x65, 0x64, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x25, 0x0a,
+	0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x18,
+	0x29, 0x20, 0x03, 0x28, 0x02, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x46,
+	0x6c, 0x6f, 0x61, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
+	0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0x2a, 0x20, 0x03, 0x28, 0x01, 0x52, 0x0e, 0x72,
+	0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x23, 0x0a,
+	0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18, 0x2b,
+	0x20, 0x03, 0x28, 0x08, 0x52, 0x0c, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x42, 0x6f,
+	0x6f, 0x6c, 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x73,
+	0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x2c, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0e, 0x72, 0x65, 0x70,
+	0x65, 0x61, 0x74, 0x65, 0x64, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x25, 0x0a, 0x0e, 0x72,
+	0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x2d, 0x20,
+	0x03, 0x28, 0x0c, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x42, 0x79, 0x74,
+	0x65, 0x73, 0x12, 0x77, 0x0a, 0x17, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x6e,
+	0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x30, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x3f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74,
+	0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73,
+	0x50, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x52, 0x15, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x4e, 0x65,
+	0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x67, 0x0a, 0x18, 0x72,
+	0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x66, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x31, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2d, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x46, 0x6f,
+	0x72, 0x65, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x16, 0x72, 0x65,
+	0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x12, 0x6e, 0x0a, 0x14, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
+	0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x33, 0x20, 0x03,
+	0x28, 0x0e, 0x32, 0x3c, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65,
+	0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50,
+	0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d,
+	0x52, 0x12, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64,
+	0x45, 0x6e, 0x75, 0x6d, 0x12, 0x5e, 0x0a, 0x15, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
+	0x5f, 0x66, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x34, 0x20,
+	0x03, 0x28, 0x0e, 0x32, 0x2a, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74,
+	0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x33, 0x2e, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x45, 0x6e, 0x75, 0x6d, 0x52,
+	0x13, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e,
+	0x45, 0x6e, 0x75, 0x6d, 0x12, 0x36, 0x0a, 0x15, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
+	0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x69, 0x65, 0x63, 0x65, 0x18, 0x36, 0x20,
+	0x03, 0x28, 0x09, 0x42, 0x02, 0x08, 0x02, 0x52, 0x13, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65,
+	0x64, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x50, 0x69, 0x65, 0x63, 0x65, 0x12, 0x27, 0x0a, 0x0d,
+	0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x63, 0x6f, 0x72, 0x64, 0x18, 0x37, 0x20,
+	0x03, 0x28, 0x09, 0x42, 0x02, 0x08, 0x01, 0x52, 0x0c, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65,
+	0x64, 0x43, 0x6f, 0x72, 0x64, 0x12, 0x25, 0x0a, 0x0c, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f,
+	0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x4b, 0x20, 0x03, 0x28, 0x05, 0x42, 0x02, 0x10, 0x01, 0x52,
+	0x0b, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x25, 0x0a, 0x0c,
+	0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x4c, 0x20, 0x03,
+	0x28, 0x03, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0b, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x49, 0x6e,
+	0x74, 0x36, 0x34, 0x12, 0x27, 0x0a, 0x0d, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x75, 0x69,
+	0x6e, 0x74, 0x33, 0x32, 0x18, 0x4d, 0x20, 0x03, 0x28, 0x0d, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0c,
+	0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x27, 0x0a, 0x0d,
+	0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x4e, 0x20,
+	0x03, 0x28, 0x04, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0c, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x55,
+	0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x27, 0x0a, 0x0d, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f,
+	0x73, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x4f, 0x20, 0x03, 0x28, 0x11, 0x42, 0x02, 0x10, 0x01,
+	0x52, 0x0c, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x27,
+	0x0a, 0x0d, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18,
+	0x50, 0x20, 0x03, 0x28, 0x12, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0c, 0x70, 0x61, 0x63, 0x6b, 0x65,
+	0x64, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x29, 0x0a, 0x0e, 0x70, 0x61, 0x63, 0x6b, 0x65,
+	0x64, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x51, 0x20, 0x03, 0x28, 0x07, 0x42,
+	0x02, 0x10, 0x01, 0x52, 0x0d, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x46, 0x69, 0x78, 0x65, 0x64,
+	0x33, 0x32, 0x12, 0x29, 0x0a, 0x0e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x66, 0x69, 0x78,
+	0x65, 0x64, 0x36, 0x34, 0x18, 0x52, 0x20, 0x03, 0x28, 0x06, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0d,
+	0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x2b, 0x0a,
+	0x0f, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32,
+	0x18, 0x53, 0x20, 0x03, 0x28, 0x0f, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0e, 0x70, 0x61, 0x63, 0x6b,
+	0x65, 0x64, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x2b, 0x0a, 0x0f, 0x70, 0x61,
+	0x63, 0x6b, 0x65, 0x64, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x54, 0x20,
+	0x03, 0x28, 0x10, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x53,
+	0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x25, 0x0a, 0x0c, 0x70, 0x61, 0x63, 0x6b, 0x65,
+	0x64, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x18, 0x55, 0x20, 0x03, 0x28, 0x02, 0x42, 0x02, 0x10,
+	0x01, 0x52, 0x0b, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x27,
+	0x0a, 0x0d, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18,
+	0x56, 0x20, 0x03, 0x28, 0x01, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0c, 0x70, 0x61, 0x63, 0x6b, 0x65,
+	0x64, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x23, 0x0a, 0x0b, 0x70, 0x61, 0x63, 0x6b, 0x65,
+	0x64, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18, 0x57, 0x20, 0x03, 0x28, 0x08, 0x42, 0x02, 0x10, 0x01,
+	0x52, 0x0a, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x6e, 0x0a, 0x12,
+	0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x6e,
+	0x75, 0x6d, 0x18, 0x58, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x3c, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c,
+	0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x4e, 0x65, 0x73, 0x74,
+	0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x42, 0x02, 0x10, 0x01, 0x52, 0x10, 0x70, 0x61, 0x63, 0x6b,
+	0x65, 0x64, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x29, 0x0a, 0x0e,
+	0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x59,
+	0x20, 0x03, 0x28, 0x05, 0x42, 0x02, 0x10, 0x00, 0x52, 0x0d, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b,
+	0x65, 0x64, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x29, 0x0a, 0x0e, 0x75, 0x6e, 0x70, 0x61, 0x63,
+	0x6b, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x5a, 0x20, 0x03, 0x28, 0x03, 0x42,
+	0x02, 0x10, 0x00, 0x52, 0x0d, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x49, 0x6e, 0x74,
+	0x36, 0x34, 0x12, 0x2b, 0x0a, 0x0f, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x75,
+	0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x5b, 0x20, 0x03, 0x28, 0x0d, 0x42, 0x02, 0x10, 0x00, 0x52,
+	0x0e, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12,
+	0x2b, 0x0a, 0x0f, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x75, 0x69, 0x6e, 0x74,
+	0x36, 0x34, 0x18, 0x5c, 0x20, 0x03, 0x28, 0x04, 0x42, 0x02, 0x10, 0x00, 0x52, 0x0e, 0x75, 0x6e,
+	0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x2b, 0x0a, 0x0f,
+	0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18,
+	0x5d, 0x20, 0x03, 0x28, 0x11, 0x42, 0x02, 0x10, 0x00, 0x52, 0x0e, 0x75, 0x6e, 0x70, 0x61, 0x63,
+	0x6b, 0x65, 0x64, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x2b, 0x0a, 0x0f, 0x75, 0x6e, 0x70,
+	0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x5e, 0x20, 0x03,
+	0x28, 0x12, 0x42, 0x02, 0x10, 0x00, 0x52, 0x0e, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64,
+	0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x2d, 0x0a, 0x10, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b,
+	0x65, 0x64, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x5f, 0x20, 0x03, 0x28, 0x07,
+	0x42, 0x02, 0x10, 0x00, 0x52, 0x0f, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x46, 0x69,
+	0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x2d, 0x0a, 0x10, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65,
+	0x64, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x60, 0x20, 0x03, 0x28, 0x06, 0x42,
+	0x02, 0x10, 0x00, 0x52, 0x0f, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x46, 0x69, 0x78,
+	0x65, 0x64, 0x36, 0x34, 0x12, 0x2f, 0x0a, 0x11, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64,
+	0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x61, 0x20, 0x03, 0x28, 0x0f, 0x42,
+	0x02, 0x10, 0x00, 0x52, 0x10, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x53, 0x66, 0x69,
+	0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x2f, 0x0a, 0x11, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65,
+	0x64, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x62, 0x20, 0x03, 0x28, 0x10,
+	0x42, 0x02, 0x10, 0x00, 0x52, 0x10, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x53, 0x66,
+	0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x29, 0x0a, 0x0e, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b,
+	0x65, 0x64, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x18, 0x63, 0x20, 0x03, 0x28, 0x02, 0x42, 0x02,
+	0x10, 0x00, 0x52, 0x0d, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x46, 0x6c, 0x6f, 0x61,
+	0x74, 0x12, 0x2b, 0x0a, 0x0f, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x64, 0x6f,
+	0x75, 0x62, 0x6c, 0x65, 0x18, 0x64, 0x20, 0x03, 0x28, 0x01, 0x42, 0x02, 0x10, 0x00, 0x52, 0x0e,
+	0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x27,
+	0x0a, 0x0d, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18,
+	0x65, 0x20, 0x03, 0x28, 0x08, 0x42, 0x02, 0x10, 0x00, 0x52, 0x0c, 0x75, 0x6e, 0x70, 0x61, 0x63,
+	0x6b, 0x65, 0x64, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x72, 0x0a, 0x14, 0x75, 0x6e, 0x70, 0x61, 0x63,
+	0x6b, 0x65, 0x64, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18,
+	0x66, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x3c, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
+	0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70,
+	0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45,
+	0x6e, 0x75, 0x6d, 0x42, 0x02, 0x10, 0x00, 0x52, 0x12, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65,
+	0x64, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x6c, 0x0a, 0x0f, 0x6d,
+	0x61, 0x70, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x38,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x44, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f,
+	0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65,
+	0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x33, 0x32,
+	0x49, 0x6e, 0x74, 0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0d, 0x6d, 0x61, 0x70, 0x49,
+	0x6e, 0x74, 0x33, 0x32, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x6c, 0x0a, 0x0f, 0x6d, 0x61, 0x70,
+	0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x39, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x44, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65,
+	0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50,
+	0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x49, 0x6e,
+	0x74, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0d, 0x6d, 0x61, 0x70, 0x49, 0x6e, 0x74,
+	0x36, 0x34, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x72, 0x0a, 0x11, 0x6d, 0x61, 0x70, 0x5f, 0x75,
+	0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x3a, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x46, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65,
+	0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50,
+	0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x4d, 0x61, 0x70, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x55,
+	0x69, 0x6e, 0x74, 0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x6d, 0x61, 0x70, 0x55,
+	0x69, 0x6e, 0x74, 0x33, 0x32, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x72, 0x0a, 0x11, 0x6d,
+	0x61, 0x70, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34,
+	0x18, 0x3b, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x46, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79,
+	0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x4d, 0x61, 0x70, 0x55, 0x69, 0x6e,
+	0x74, 0x36, 0x34, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f,
+	0x6d, 0x61, 0x70, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12,
+	0x72, 0x0a, 0x11, 0x6d, 0x61, 0x70, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x73, 0x69,
+	0x6e, 0x74, 0x33, 0x32, 0x18, 0x3c, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x46, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41,
+	0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x4d, 0x61,
+	0x70, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x45, 0x6e, 0x74,
+	0x72, 0x79, 0x52, 0x0f, 0x6d, 0x61, 0x70, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x53, 0x69, 0x6e,
+	0x74, 0x33, 0x32, 0x12, 0x72, 0x0a, 0x11, 0x6d, 0x61, 0x70, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x36,
+	0x34, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x3d, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x46,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x54,
+	0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f,
+	0x33, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x53, 0x69, 0x6e, 0x74, 0x36,
+	0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x6d, 0x61, 0x70, 0x53, 0x69, 0x6e, 0x74, 0x36,
+	0x34, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x78, 0x0a, 0x13, 0x6d, 0x61, 0x70, 0x5f, 0x66,
+	0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x3e,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x48, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f,
+	0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65,
+	0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x4d, 0x61, 0x70, 0x46, 0x69, 0x78, 0x65, 0x64,
+	0x33, 0x32, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x11,
+	0x6d, 0x61, 0x70, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33,
+	0x32, 0x12, 0x78, 0x0a, 0x13, 0x6d, 0x61, 0x70, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34,
+	0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x3f, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x48,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x54,
+	0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f,
+	0x33, 0x2e, 0x4d, 0x61, 0x70, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x46, 0x69, 0x78, 0x65,
+	0x64, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x11, 0x6d, 0x61, 0x70, 0x46, 0x69, 0x78,
+	0x65, 0x64, 0x36, 0x34, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x7e, 0x0a, 0x15, 0x6d,
+	0x61, 0x70, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x5f, 0x73, 0x66, 0x69, 0x78,
+	0x65, 0x64, 0x33, 0x32, 0x18, 0x40, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x4a, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41,
+	0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x4d, 0x61,
+	0x70, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33,
+	0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x13, 0x6d, 0x61, 0x70, 0x53, 0x66, 0x69, 0x78, 0x65,
+	0x64, 0x33, 0x32, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x7e, 0x0a, 0x15, 0x6d,
+	0x61, 0x70, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x5f, 0x73, 0x66, 0x69, 0x78,
+	0x65, 0x64, 0x36, 0x34, 0x18, 0x41, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x4a, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41,
+	0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x4d, 0x61,
+	0x70, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36,
+	0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x13, 0x6d, 0x61, 0x70, 0x53, 0x66, 0x69, 0x78, 0x65,
+	0x64, 0x36, 0x34, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x6c, 0x0a, 0x0f, 0x6d,
+	0x61, 0x70, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x18, 0x42,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x44, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f,
+	0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65,
+	0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x33, 0x32,
+	0x46, 0x6c, 0x6f, 0x61, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0d, 0x6d, 0x61, 0x70, 0x49,
+	0x6e, 0x74, 0x33, 0x32, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x6f, 0x0a, 0x10, 0x6d, 0x61, 0x70,
+	0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0x43, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x45, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74,
+	0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73,
+	0x50, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x44,
+	0x6f, 0x75, 0x62, 0x6c, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, 0x6d, 0x61, 0x70, 0x49,
+	0x6e, 0x74, 0x33, 0x32, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x66, 0x0a, 0x0d, 0x6d, 0x61,
+	0x70, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18, 0x44, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x42, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73,
+	0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72,
+	0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x4d, 0x61, 0x70, 0x42, 0x6f, 0x6f, 0x6c, 0x42, 0x6f, 0x6f, 0x6c,
+	0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0b, 0x6d, 0x61, 0x70, 0x42, 0x6f, 0x6f, 0x6c, 0x42, 0x6f,
+	0x6f, 0x6c, 0x12, 0x72, 0x0a, 0x11, 0x6d, 0x61, 0x70, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67,
+	0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x45, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x46, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x54, 0x65,
+	0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67,
+	0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x6d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67,
+	0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x6f, 0x0a, 0x10, 0x6d, 0x61, 0x70, 0x5f, 0x73, 0x74,
+	0x72, 0x69, 0x6e, 0x67, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x46, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x45, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f,
+	0x74, 0x6f, 0x33, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x79, 0x74,
+	0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, 0x6d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69,
+	0x6e, 0x67, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x88, 0x01, 0x0a, 0x19, 0x6d, 0x61, 0x70, 0x5f,
+	0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x47, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x4d, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74,
+	0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x4d,
+	0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x16, 0x6d, 0x61, 0x70, 0x53,
+	0x74, 0x72, 0x69, 0x6e, 0x67, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x12, 0x8b, 0x01, 0x0a, 0x1a, 0x6d, 0x61, 0x70, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e,
+	0x67, 0x5f, 0x66, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x18, 0x48, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x4e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
+	0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54,
+	0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74,
+	0x72, 0x69, 0x6e, 0x67, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x17, 0x6d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69,
+	0x6e, 0x67, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x12, 0x7f, 0x0a, 0x16, 0x6d, 0x61, 0x70, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x6e,
+	0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x49, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x4a, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f,
+	0x74, 0x6f, 0x33, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x4e, 0x65, 0x73,
+	0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x13, 0x6d, 0x61,
+	0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75,
+	0x6d, 0x12, 0x82, 0x01, 0x0a, 0x17, 0x6d, 0x61, 0x70, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67,
+	0x5f, 0x66, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x4a, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x4b, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74,
+	0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73,
+	0x50, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67,
+	0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x45, 0x6e, 0x75, 0x6d, 0x45, 0x6e, 0x74, 0x72, 0x79,
+	0x52, 0x14, 0x6d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x46, 0x6f, 0x72, 0x65, 0x69,
+	0x67, 0x6e, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x23, 0x0a, 0x0c, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f,
+	0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x6f, 0x20, 0x01, 0x28, 0x0d, 0x48, 0x00, 0x52, 0x0b,
+	0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x73, 0x0a, 0x14, 0x6f,
+	0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x18, 0x70, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x3f, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c,
+	0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x4e, 0x65, 0x73,
+	0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x48, 0x00, 0x52, 0x12, 0x6f, 0x6e,
+	0x65, 0x6f, 0x66, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x12, 0x23, 0x0a, 0x0c, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67,
+	0x18, 0x71, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x53,
+	0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x21, 0x0a, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x62,
+	0x79, 0x74, 0x65, 0x73, 0x18, 0x72, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x0a, 0x6f, 0x6e,
+	0x65, 0x6f, 0x66, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x1f, 0x0a, 0x0a, 0x6f, 0x6e, 0x65, 0x6f,
+	0x66, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18, 0x73, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x09,
+	0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x23, 0x0a, 0x0c, 0x6f, 0x6e, 0x65,
+	0x6f, 0x66, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x74, 0x20, 0x01, 0x28, 0x04, 0x48,
+	0x00, 0x52, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x21,
+	0x0a, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x18, 0x75, 0x20,
+	0x01, 0x28, 0x02, 0x48, 0x00, 0x52, 0x0a, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x46, 0x6c, 0x6f, 0x61,
+	0x74, 0x12, 0x23, 0x0a, 0x0c, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c,
+	0x65, 0x18, 0x76, 0x20, 0x01, 0x28, 0x01, 0x48, 0x00, 0x52, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66,
+	0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x5d, 0x0a, 0x0a, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f,
+	0x65, 0x6e, 0x75, 0x6d, 0x18, 0x77, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x3c, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41,
+	0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x4e, 0x65,
+	0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x48, 0x00, 0x52, 0x09, 0x6f, 0x6e, 0x65, 0x6f,
+	0x66, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x4f, 0x0a, 0x15, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x18, 0xc9,
+	0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x42, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75,
+	0x65, 0x52, 0x13, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x42, 0x6f, 0x6f, 0x6c, 0x57,
+	0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x12, 0x52, 0x0a, 0x16, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+	0x61, 0x6c, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72,
+	0x18, 0xca, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x56,
+	0x61, 0x6c, 0x75, 0x65, 0x52, 0x14, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x49, 0x6e,
+	0x74, 0x33, 0x32, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x12, 0x52, 0x0a, 0x16, 0x6f, 0x70,
+	0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x5f, 0x77, 0x72, 0x61,
+	0x70, 0x70, 0x65, 0x72, 0x18, 0xcb, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x49, 0x6e,
+	0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x14, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+	0x61, 0x6c, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x12, 0x55,
+	0x0a, 0x17, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33,
+	0x32, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x18, 0xcc, 0x01, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
+	0x75, 0x66, 0x2e, 0x55, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x15,
+	0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x57, 0x72,
+	0x61, 0x70, 0x70, 0x65, 0x72, 0x12, 0x55, 0x0a, 0x17, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72,
+	0x18, 0xcd, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x49, 0x6e, 0x74, 0x36, 0x34,
+	0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x15, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x55,
+	0x69, 0x6e, 0x74, 0x36, 0x34, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x12, 0x52, 0x0a, 0x16,
+	0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x5f, 0x77,
+	0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x18, 0xce, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
+	0x46, 0x6c, 0x6f, 0x61, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x14, 0x6f, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x61, 0x6c, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72,
+	0x12, 0x55, 0x0a, 0x17, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x64, 0x6f, 0x75,
+	0x62, 0x6c, 0x65, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x18, 0xcf, 0x01, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
+	0x52, 0x15, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65,
+	0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x12, 0x55, 0x0a, 0x17, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x70,
+	0x65, 0x72, 0x18, 0xd0, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, 0x69,
+	0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x15, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x12, 0x52,
+	0x0a, 0x16, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73,
+	0x5f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x18, 0xd1, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x1b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x2e, 0x42, 0x79, 0x74, 0x65, 0x73, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x14, 0x6f, 0x70,
+	0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x42, 0x79, 0x74, 0x65, 0x73, 0x57, 0x72, 0x61, 0x70, 0x70,
+	0x65, 0x72, 0x12, 0x4f, 0x0a, 0x15, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x62,
+	0x6f, 0x6f, 0x6c, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x18, 0xd3, 0x01, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x62, 0x75, 0x66, 0x2e, 0x42, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x13,
+	0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x42, 0x6f, 0x6f, 0x6c, 0x57, 0x72, 0x61, 0x70,
+	0x70, 0x65, 0x72, 0x12, 0x52, 0x0a, 0x16, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f,
+	0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x18, 0xd4, 0x01,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75,
+	0x65, 0x52, 0x14, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x49, 0x6e, 0x74, 0x33, 0x32,
+	0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x12, 0x52, 0x0a, 0x16, 0x72, 0x65, 0x70, 0x65, 0x61,
+	0x74, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65,
+	0x72, 0x18, 0xd5, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x49, 0x6e, 0x74, 0x36, 0x34,
+	0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x14, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x49,
+	0x6e, 0x74, 0x36, 0x34, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x12, 0x55, 0x0a, 0x17, 0x72,
+	0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x77,
+	0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x18, 0xd6, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
+	0x55, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x15, 0x72, 0x65, 0x70,
+	0x65, 0x61, 0x74, 0x65, 0x64, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x57, 0x72, 0x61, 0x70, 0x70,
+	0x65, 0x72, 0x12, 0x55, 0x0a, 0x17, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x75,
+	0x69, 0x6e, 0x74, 0x36, 0x34, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x18, 0xd7, 0x01,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c,
+	0x75, 0x65, 0x52, 0x15, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x55, 0x69, 0x6e, 0x74,
+	0x36, 0x34, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x12, 0x52, 0x0a, 0x16, 0x72, 0x65, 0x70,
+	0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x5f, 0x77, 0x72, 0x61, 0x70,
+	0x70, 0x65, 0x72, 0x18, 0xd8, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x6c, 0x6f,
+	0x61, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x14, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65,
+	0x64, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x12, 0x55, 0x0a,
+	0x17, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65,
+	0x5f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x18, 0xd9, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x2e, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x15, 0x72,
+	0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x57, 0x72, 0x61,
+	0x70, 0x70, 0x65, 0x72, 0x12, 0x55, 0x0a, 0x17, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
+	0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x18,
+	0xda, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56,
+	0x61, 0x6c, 0x75, 0x65, 0x52, 0x15, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x53, 0x74,
+	0x72, 0x69, 0x6e, 0x67, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x12, 0x52, 0x0a, 0x16, 0x72,
+	0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x5f, 0x77, 0x72,
+	0x61, 0x70, 0x70, 0x65, 0x72, 0x18, 0xdb, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x42,
+	0x79, 0x74, 0x65, 0x73, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x14, 0x72, 0x65, 0x70, 0x65, 0x61,
+	0x74, 0x65, 0x64, 0x42, 0x79, 0x74, 0x65, 0x73, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x12,
+	0x47, 0x0a, 0x11, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x64, 0x75, 0x72, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x18, 0xad, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75,
+	0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x10, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x4a, 0x0a, 0x12, 0x6f, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0xae,
+	0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d,
+	0x70, 0x52, 0x11, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x54, 0x69, 0x6d, 0x65, 0x73,
+	0x74, 0x61, 0x6d, 0x70, 0x12, 0x4b, 0x0a, 0x13, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x6d, 0x61, 0x73, 0x6b, 0x18, 0xaf, 0x02, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d, 0x61, 0x73, 0x6b, 0x52, 0x11,
+	0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d, 0x61, 0x73,
+	0x6b, 0x12, 0x41, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x74,
+	0x72, 0x75, 0x63, 0x74, 0x18, 0xb0, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74,
+	0x72, 0x75, 0x63, 0x74, 0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x74,
+	0x72, 0x75, 0x63, 0x74, 0x12, 0x38, 0x0a, 0x0c, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x5f, 0x61, 0x6e, 0x79, 0x18, 0xb1, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x41, 0x6e,
+	0x79, 0x52, 0x0b, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x41, 0x6e, 0x79, 0x12, 0x3e,
+	0x0a, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65,
+	0x18, 0xb2, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52,
+	0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x47,
+	0x0a, 0x11, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x64, 0x75, 0x72, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x18, 0xb7, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x10, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x44,
+	0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x4a, 0x0a, 0x12, 0x72, 0x65, 0x70, 0x65, 0x61,
+	0x74, 0x65, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0xb8, 0x02,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70,
+	0x52, 0x11, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74,
+	0x61, 0x6d, 0x70, 0x12, 0x4a, 0x0a, 0x12, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x6d, 0x61, 0x73, 0x6b, 0x18, 0xb9, 0x02, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
+	0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d, 0x61, 0x73, 0x6b, 0x52, 0x11, 0x72, 0x65,
+	0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x6d, 0x61, 0x73, 0x6b, 0x12,
+	0x41, 0x0a, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x73, 0x74, 0x72, 0x75,
+	0x63, 0x74, 0x18, 0xc4, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, 0x75,
+	0x63, 0x74, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x53, 0x74, 0x72, 0x75,
+	0x63, 0x74, 0x12, 0x38, 0x0a, 0x0c, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61,
+	0x6e, 0x79, 0x18, 0xbb, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x52,
+	0x0b, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x6e, 0x79, 0x12, 0x3e, 0x0a, 0x0e,
+	0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0xbc,
+	0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x0d, 0x72,
+	0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x4b, 0x0a, 0x13,
+	0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x6c, 0x69, 0x73, 0x74, 0x5f, 0x76, 0x61,
+	0x6c, 0x75, 0x65, 0x18, 0xbd, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4c, 0x69, 0x73,
+	0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x11, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
+	0x4c, 0x69, 0x73, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x65,
+	0x6c, 0x64, 0x6e, 0x61, 0x6d, 0x65, 0x31, 0x18, 0x91, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x6e, 0x61, 0x6d, 0x65, 0x31, 0x12, 0x20, 0x0a, 0x0b, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x32, 0x18, 0x92, 0x03, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x32, 0x12, 0x21, 0x0a, 0x0c,
+	0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x33, 0x18, 0x93, 0x03, 0x20,
+	0x01, 0x28, 0x05, 0x52, 0x0a, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x33, 0x12,
+	0x22, 0x0a, 0x0d, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x34, 0x5f,
+	0x18, 0x94, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x4e, 0x61,
+	0x6d, 0x65, 0x34, 0x12, 0x21, 0x0a, 0x0b, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x30, 0x6e, 0x61, 0x6d,
+	0x65, 0x35, 0x18, 0x95, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x30, 0x6e, 0x61, 0x6d, 0x65, 0x35, 0x12, 0x23, 0x0a, 0x0d, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f,
+	0x30, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x36, 0x18, 0x96, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x30, 0x4e, 0x61, 0x6d, 0x65, 0x36, 0x12, 0x1f, 0x0a, 0x0a, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x37, 0x18, 0x97, 0x03, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x37, 0x12, 0x1f, 0x0a, 0x0a,
+	0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x38, 0x18, 0x98, 0x03, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x0a, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x38, 0x12, 0x20, 0x0a,
+	0x0b, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x4e, 0x61, 0x6d, 0x65, 0x39, 0x18, 0x99, 0x03, 0x20,
+	0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x39, 0x12,
+	0x22, 0x0a, 0x0c, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x4e, 0x61, 0x6d, 0x65, 0x31, 0x30, 0x18,
+	0x9a, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e, 0x61, 0x6d,
+	0x65, 0x31, 0x30, 0x12, 0x22, 0x0a, 0x0c, 0x46, 0x49, 0x45, 0x4c, 0x44, 0x5f, 0x4e, 0x41, 0x4d,
+	0x45, 0x31, 0x31, 0x18, 0x9b, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x46, 0x49, 0x45, 0x4c,
+	0x44, 0x4e, 0x41, 0x4d, 0x45, 0x31, 0x31, 0x12, 0x22, 0x0a, 0x0c, 0x46, 0x49, 0x45, 0x4c, 0x44,
+	0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x31, 0x32, 0x18, 0x9c, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b,
+	0x46, 0x49, 0x45, 0x4c, 0x44, 0x4e, 0x61, 0x6d, 0x65, 0x31, 0x32, 0x12, 0x24, 0x0a, 0x0e, 0x5f,
+	0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x31, 0x33, 0x18, 0x9d, 0x03,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x31,
+	0x33, 0x12, 0x24, 0x0a, 0x0e, 0x5f, 0x5f, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x6e, 0x61, 0x6d,
+	0x65, 0x31, 0x34, 0x18, 0x9e, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x46, 0x69, 0x65, 0x6c,
+	0x64, 0x4e, 0x61, 0x6d, 0x65, 0x31, 0x34, 0x12, 0x23, 0x0a, 0x0d, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x5f, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x31, 0x35, 0x18, 0x9f, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x0b, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x31, 0x35, 0x12, 0x23, 0x0a, 0x0d,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x5f, 0x4e, 0x61, 0x6d, 0x65, 0x31, 0x36, 0x18, 0xa0, 0x03,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x31,
+	0x36, 0x12, 0x24, 0x0a, 0x0e, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x31,
+	0x37, 0x5f, 0x5f, 0x18, 0xa1, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x4e, 0x61, 0x6d, 0x65, 0x31, 0x37, 0x12, 0x24, 0x0a, 0x0e, 0x46, 0x69, 0x65, 0x6c, 0x64,
+	0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x31, 0x38, 0x5f, 0x5f, 0x18, 0xa2, 0x03, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x0b, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x31, 0x38, 0x1a, 0x72, 0x0a,
+	0x0d, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x0c,
+	0x0a, 0x01, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x01, 0x61, 0x12, 0x53, 0x0a, 0x0b,
+	0x63, 0x6f, 0x72, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x76, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x31, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73,
+	0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72,
+	0x6f, 0x74, 0x6f, 0x33, 0x52, 0x0b, 0x63, 0x6f, 0x72, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x76,
+	0x65, 0x1a, 0x40, 0x0a, 0x12, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x49, 0x6e, 0x74,
+	0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c,
+	0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a,
+	0x02, 0x38, 0x01, 0x1a, 0x40, 0x0a, 0x12, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x49,
+	0x6e, 0x74, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76,
+	0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75,
+	0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x42, 0x0a, 0x14, 0x4d, 0x61, 0x70, 0x55, 0x69, 0x6e, 0x74,
+	0x33, 0x32, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a,
+	0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12,
+	0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05,
+	0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x42, 0x0a, 0x14, 0x4d, 0x61, 0x70,
+	0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72,
+	0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x03,
+	0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x04, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x42, 0x0a,
+	0x14, 0x4d, 0x61, 0x70, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32,
+	0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x11, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x11, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38,
+	0x01, 0x1a, 0x42, 0x0a, 0x14, 0x4d, 0x61, 0x70, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x53, 0x69,
+	0x6e, 0x74, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x12, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76,
+	0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x12, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75,
+	0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x44, 0x0a, 0x16, 0x4d, 0x61, 0x70, 0x46, 0x69, 0x78, 0x65,
+	0x64, 0x33, 0x32, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12,
+	0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x07, 0x52, 0x03, 0x6b, 0x65,
+	0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x07,
+	0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x44, 0x0a, 0x16, 0x4d,
+	0x61, 0x70, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34,
+	0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x06, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x06, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38,
+	0x01, 0x1a, 0x46, 0x0a, 0x18, 0x4d, 0x61, 0x70, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32,
+	0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a,
+	0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0f, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12,
+	0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0f, 0x52, 0x05,
+	0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x46, 0x0a, 0x18, 0x4d, 0x61, 0x70,
+	0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34,
+	0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x10, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x10, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38,
+	0x01, 0x1a, 0x40, 0x0a, 0x12, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x46, 0x6c, 0x6f,
+	0x61, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c,
+	0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x02, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a,
+	0x02, 0x38, 0x01, 0x1a, 0x41, 0x0a, 0x13, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x44,
+	0x6f, 0x75, 0x62, 0x6c, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65,
+	0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05,
+	0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x05, 0x76, 0x61, 0x6c,
+	0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x3e, 0x0a, 0x10, 0x4d, 0x61, 0x70, 0x42, 0x6f, 0x6f,
+	0x6c, 0x42, 0x6f, 0x6f, 0x6c, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65,
+	0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05,
+	0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x76, 0x61, 0x6c,
+	0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x42, 0x0a, 0x14, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72,
+	0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10,
+	0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79,
+	0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x41, 0x0a, 0x13, 0x4d, 0x61,
+	0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x79, 0x74, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72,
+	0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03,
+	0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x0c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x8a, 0x01,
+	0x0a, 0x1b, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x4e, 0x65, 0x73, 0x74, 0x65,
+	0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a,
+	0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12,
+	0x55, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x3f,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x54,
+	0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f,
+	0x33, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x79, 0x0a, 0x1c, 0x4d, 0x61,
+	0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65,
+	0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x43, 0x0a, 0x05,
+	0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x46, 0x6f, 0x72, 0x65,
+	0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75,
+	0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x84, 0x01, 0x0a, 0x18, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72,
+	0x69, 0x6e, 0x67, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x45, 0x6e, 0x74,
+	0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x03, 0x6b, 0x65, 0x79, 0x12, 0x52, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x0e, 0x32, 0x3c, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74,
+	0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73,
+	0x50, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75,
+	0x6d, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x73, 0x0a, 0x19,
+	0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e,
+	0x45, 0x6e, 0x75, 0x6d, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x40, 0x0a, 0x05, 0x76,
+	0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2a, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x2e, 0x46, 0x6f, 0x72, 0x65, 0x69,
+	0x67, 0x6e, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38,
+	0x01, 0x22, 0x39, 0x0a, 0x0a, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x12,
+	0x07, 0x0a, 0x03, 0x46, 0x4f, 0x4f, 0x10, 0x00, 0x12, 0x07, 0x0a, 0x03, 0x42, 0x41, 0x52, 0x10,
+	0x01, 0x12, 0x07, 0x0a, 0x03, 0x42, 0x41, 0x5a, 0x10, 0x02, 0x12, 0x10, 0x0a, 0x03, 0x4e, 0x45,
+	0x47, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x22, 0x59, 0x0a, 0x0b,
+	0x41, 0x6c, 0x69, 0x61, 0x73, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x0d, 0x0a, 0x09, 0x41,
+	0x4c, 0x49, 0x41, 0x53, 0x5f, 0x46, 0x4f, 0x4f, 0x10, 0x00, 0x12, 0x0d, 0x0a, 0x09, 0x41, 0x4c,
+	0x49, 0x41, 0x53, 0x5f, 0x42, 0x41, 0x52, 0x10, 0x01, 0x12, 0x0d, 0x0a, 0x09, 0x41, 0x4c, 0x49,
+	0x41, 0x53, 0x5f, 0x42, 0x41, 0x5a, 0x10, 0x02, 0x12, 0x07, 0x0a, 0x03, 0x51, 0x55, 0x58, 0x10,
+	0x02, 0x12, 0x07, 0x0a, 0x03, 0x71, 0x75, 0x78, 0x10, 0x02, 0x12, 0x07, 0x0a, 0x03, 0x62, 0x41,
+	0x7a, 0x10, 0x02, 0x1a, 0x02, 0x10, 0x01, 0x42, 0x0d, 0x0a, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66,
+	0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x4a, 0x06, 0x08, 0xf5, 0x03, 0x10, 0xff, 0x03, 0x22, 0x1e,
+	0x0a, 0x0e, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x12, 0x0c, 0x0a, 0x01, 0x63, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x01, 0x63, 0x2a, 0x40,
+	0x0a, 0x0b, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x0f, 0x0a,
+	0x0b, 0x46, 0x4f, 0x52, 0x45, 0x49, 0x47, 0x4e, 0x5f, 0x46, 0x4f, 0x4f, 0x10, 0x00, 0x12, 0x0f,
+	0x0a, 0x0b, 0x46, 0x4f, 0x52, 0x45, 0x49, 0x47, 0x4e, 0x5f, 0x42, 0x41, 0x52, 0x10, 0x01, 0x12,
+	0x0f, 0x0a, 0x0b, 0x46, 0x4f, 0x52, 0x45, 0x49, 0x47, 0x4e, 0x5f, 0x42, 0x41, 0x5a, 0x10, 0x02,
+	0x42, 0x38, 0x0a, 0x28, 0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x48, 0x01, 0xf8, 0x01,
+	0x01, 0xa2, 0x02, 0x06, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x33,
+}
+
+var (
+	file_google_protobuf_test_messages_proto3_proto_rawDescOnce sync.Once
+	file_google_protobuf_test_messages_proto3_proto_rawDescData = file_google_protobuf_test_messages_proto3_proto_rawDesc
+)
+
+func file_google_protobuf_test_messages_proto3_proto_rawDescGZIP() []byte {
+	file_google_protobuf_test_messages_proto3_proto_rawDescOnce.Do(func() {
+		file_google_protobuf_test_messages_proto3_proto_rawDescData = protoimpl.X.CompressGZIP(file_google_protobuf_test_messages_proto3_proto_rawDescData)
+	})
+	return file_google_protobuf_test_messages_proto3_proto_rawDescData
+}
+
+var file_google_protobuf_test_messages_proto3_proto_enumTypes = make([]protoimpl.EnumInfo, 3)
+var file_google_protobuf_test_messages_proto3_proto_msgTypes = make([]protoimpl.MessageInfo, 22)
+var file_google_protobuf_test_messages_proto3_proto_goTypes = []interface{}{
+	(ForeignEnum)(0),                         // 0: protobuf_test_messages.proto3.ForeignEnum
+	(TestAllTypesProto3_NestedEnum)(0),       // 1: protobuf_test_messages.proto3.TestAllTypesProto3.NestedEnum
+	(TestAllTypesProto3_AliasedEnum)(0),      // 2: protobuf_test_messages.proto3.TestAllTypesProto3.AliasedEnum
+	(*TestAllTypesProto3)(nil),               // 3: protobuf_test_messages.proto3.TestAllTypesProto3
+	(*ForeignMessage)(nil),                   // 4: protobuf_test_messages.proto3.ForeignMessage
+	(*TestAllTypesProto3_NestedMessage)(nil), // 5: protobuf_test_messages.proto3.TestAllTypesProto3.NestedMessage
+	nil,                                      // 6: protobuf_test_messages.proto3.TestAllTypesProto3.MapInt32Int32Entry
+	nil,                                      // 7: protobuf_test_messages.proto3.TestAllTypesProto3.MapInt64Int64Entry
+	nil,                                      // 8: protobuf_test_messages.proto3.TestAllTypesProto3.MapUint32Uint32Entry
+	nil,                                      // 9: protobuf_test_messages.proto3.TestAllTypesProto3.MapUint64Uint64Entry
+	nil,                                      // 10: protobuf_test_messages.proto3.TestAllTypesProto3.MapSint32Sint32Entry
+	nil,                                      // 11: protobuf_test_messages.proto3.TestAllTypesProto3.MapSint64Sint64Entry
+	nil,                                      // 12: protobuf_test_messages.proto3.TestAllTypesProto3.MapFixed32Fixed32Entry
+	nil,                                      // 13: protobuf_test_messages.proto3.TestAllTypesProto3.MapFixed64Fixed64Entry
+	nil,                                      // 14: protobuf_test_messages.proto3.TestAllTypesProto3.MapSfixed32Sfixed32Entry
+	nil,                                      // 15: protobuf_test_messages.proto3.TestAllTypesProto3.MapSfixed64Sfixed64Entry
+	nil,                                      // 16: protobuf_test_messages.proto3.TestAllTypesProto3.MapInt32FloatEntry
+	nil,                                      // 17: protobuf_test_messages.proto3.TestAllTypesProto3.MapInt32DoubleEntry
+	nil,                                      // 18: protobuf_test_messages.proto3.TestAllTypesProto3.MapBoolBoolEntry
+	nil,                                      // 19: protobuf_test_messages.proto3.TestAllTypesProto3.MapStringStringEntry
+	nil,                                      // 20: protobuf_test_messages.proto3.TestAllTypesProto3.MapStringBytesEntry
+	nil,                                      // 21: protobuf_test_messages.proto3.TestAllTypesProto3.MapStringNestedMessageEntry
+	nil,                                      // 22: protobuf_test_messages.proto3.TestAllTypesProto3.MapStringForeignMessageEntry
+	nil,                                      // 23: protobuf_test_messages.proto3.TestAllTypesProto3.MapStringNestedEnumEntry
+	nil,                                      // 24: protobuf_test_messages.proto3.TestAllTypesProto3.MapStringForeignEnumEntry
+	(*wrapperspb.BoolValue)(nil),             // 25: google.protobuf.BoolValue
+	(*wrapperspb.Int32Value)(nil),            // 26: google.protobuf.Int32Value
+	(*wrapperspb.Int64Value)(nil),            // 27: google.protobuf.Int64Value
+	(*wrapperspb.UInt32Value)(nil),           // 28: google.protobuf.UInt32Value
+	(*wrapperspb.UInt64Value)(nil),           // 29: google.protobuf.UInt64Value
+	(*wrapperspb.FloatValue)(nil),            // 30: google.protobuf.FloatValue
+	(*wrapperspb.DoubleValue)(nil),           // 31: google.protobuf.DoubleValue
+	(*wrapperspb.StringValue)(nil),           // 32: google.protobuf.StringValue
+	(*wrapperspb.BytesValue)(nil),            // 33: google.protobuf.BytesValue
+	(*durationpb.Duration)(nil),              // 34: google.protobuf.Duration
+	(*timestamppb.Timestamp)(nil),            // 35: google.protobuf.Timestamp
+	(*fieldmaskpb.FieldMask)(nil),            // 36: google.protobuf.FieldMask
+	(*structpb.Struct)(nil),                  // 37: google.protobuf.Struct
+	(*anypb.Any)(nil),                        // 38: google.protobuf.Any
+	(*structpb.Value)(nil),                   // 39: google.protobuf.Value
+	(*structpb.ListValue)(nil),               // 40: google.protobuf.ListValue
+}
+var file_google_protobuf_test_messages_proto3_proto_depIdxs = []int32{
+	5,  // 0: protobuf_test_messages.proto3.TestAllTypesProto3.optional_nested_message:type_name -> protobuf_test_messages.proto3.TestAllTypesProto3.NestedMessage
+	4,  // 1: protobuf_test_messages.proto3.TestAllTypesProto3.optional_foreign_message:type_name -> protobuf_test_messages.proto3.ForeignMessage
+	1,  // 2: protobuf_test_messages.proto3.TestAllTypesProto3.optional_nested_enum:type_name -> protobuf_test_messages.proto3.TestAllTypesProto3.NestedEnum
+	0,  // 3: protobuf_test_messages.proto3.TestAllTypesProto3.optional_foreign_enum:type_name -> protobuf_test_messages.proto3.ForeignEnum
+	2,  // 4: protobuf_test_messages.proto3.TestAllTypesProto3.optional_aliased_enum:type_name -> protobuf_test_messages.proto3.TestAllTypesProto3.AliasedEnum
+	3,  // 5: protobuf_test_messages.proto3.TestAllTypesProto3.recursive_message:type_name -> protobuf_test_messages.proto3.TestAllTypesProto3
+	5,  // 6: protobuf_test_messages.proto3.TestAllTypesProto3.repeated_nested_message:type_name -> protobuf_test_messages.proto3.TestAllTypesProto3.NestedMessage
+	4,  // 7: protobuf_test_messages.proto3.TestAllTypesProto3.repeated_foreign_message:type_name -> protobuf_test_messages.proto3.ForeignMessage
+	1,  // 8: protobuf_test_messages.proto3.TestAllTypesProto3.repeated_nested_enum:type_name -> protobuf_test_messages.proto3.TestAllTypesProto3.NestedEnum
+	0,  // 9: protobuf_test_messages.proto3.TestAllTypesProto3.repeated_foreign_enum:type_name -> protobuf_test_messages.proto3.ForeignEnum
+	1,  // 10: protobuf_test_messages.proto3.TestAllTypesProto3.packed_nested_enum:type_name -> protobuf_test_messages.proto3.TestAllTypesProto3.NestedEnum
+	1,  // 11: protobuf_test_messages.proto3.TestAllTypesProto3.unpacked_nested_enum:type_name -> protobuf_test_messages.proto3.TestAllTypesProto3.NestedEnum
+	6,  // 12: protobuf_test_messages.proto3.TestAllTypesProto3.map_int32_int32:type_name -> protobuf_test_messages.proto3.TestAllTypesProto3.MapInt32Int32Entry
+	7,  // 13: protobuf_test_messages.proto3.TestAllTypesProto3.map_int64_int64:type_name -> protobuf_test_messages.proto3.TestAllTypesProto3.MapInt64Int64Entry
+	8,  // 14: protobuf_test_messages.proto3.TestAllTypesProto3.map_uint32_uint32:type_name -> protobuf_test_messages.proto3.TestAllTypesProto3.MapUint32Uint32Entry
+	9,  // 15: protobuf_test_messages.proto3.TestAllTypesProto3.map_uint64_uint64:type_name -> protobuf_test_messages.proto3.TestAllTypesProto3.MapUint64Uint64Entry
+	10, // 16: protobuf_test_messages.proto3.TestAllTypesProto3.map_sint32_sint32:type_name -> protobuf_test_messages.proto3.TestAllTypesProto3.MapSint32Sint32Entry
+	11, // 17: protobuf_test_messages.proto3.TestAllTypesProto3.map_sint64_sint64:type_name -> protobuf_test_messages.proto3.TestAllTypesProto3.MapSint64Sint64Entry
+	12, // 18: protobuf_test_messages.proto3.TestAllTypesProto3.map_fixed32_fixed32:type_name -> protobuf_test_messages.proto3.TestAllTypesProto3.MapFixed32Fixed32Entry
+	13, // 19: protobuf_test_messages.proto3.TestAllTypesProto3.map_fixed64_fixed64:type_name -> protobuf_test_messages.proto3.TestAllTypesProto3.MapFixed64Fixed64Entry
+	14, // 20: protobuf_test_messages.proto3.TestAllTypesProto3.map_sfixed32_sfixed32:type_name -> protobuf_test_messages.proto3.TestAllTypesProto3.MapSfixed32Sfixed32Entry
+	15, // 21: protobuf_test_messages.proto3.TestAllTypesProto3.map_sfixed64_sfixed64:type_name -> protobuf_test_messages.proto3.TestAllTypesProto3.MapSfixed64Sfixed64Entry
+	16, // 22: protobuf_test_messages.proto3.TestAllTypesProto3.map_int32_float:type_name -> protobuf_test_messages.proto3.TestAllTypesProto3.MapInt32FloatEntry
+	17, // 23: protobuf_test_messages.proto3.TestAllTypesProto3.map_int32_double:type_name -> protobuf_test_messages.proto3.TestAllTypesProto3.MapInt32DoubleEntry
+	18, // 24: protobuf_test_messages.proto3.TestAllTypesProto3.map_bool_bool:type_name -> protobuf_test_messages.proto3.TestAllTypesProto3.MapBoolBoolEntry
+	19, // 25: protobuf_test_messages.proto3.TestAllTypesProto3.map_string_string:type_name -> protobuf_test_messages.proto3.TestAllTypesProto3.MapStringStringEntry
+	20, // 26: protobuf_test_messages.proto3.TestAllTypesProto3.map_string_bytes:type_name -> protobuf_test_messages.proto3.TestAllTypesProto3.MapStringBytesEntry
+	21, // 27: protobuf_test_messages.proto3.TestAllTypesProto3.map_string_nested_message:type_name -> protobuf_test_messages.proto3.TestAllTypesProto3.MapStringNestedMessageEntry
+	22, // 28: protobuf_test_messages.proto3.TestAllTypesProto3.map_string_foreign_message:type_name -> protobuf_test_messages.proto3.TestAllTypesProto3.MapStringForeignMessageEntry
+	23, // 29: protobuf_test_messages.proto3.TestAllTypesProto3.map_string_nested_enum:type_name -> protobuf_test_messages.proto3.TestAllTypesProto3.MapStringNestedEnumEntry
+	24, // 30: protobuf_test_messages.proto3.TestAllTypesProto3.map_string_foreign_enum:type_name -> protobuf_test_messages.proto3.TestAllTypesProto3.MapStringForeignEnumEntry
+	5,  // 31: protobuf_test_messages.proto3.TestAllTypesProto3.oneof_nested_message:type_name -> protobuf_test_messages.proto3.TestAllTypesProto3.NestedMessage
+	1,  // 32: protobuf_test_messages.proto3.TestAllTypesProto3.oneof_enum:type_name -> protobuf_test_messages.proto3.TestAllTypesProto3.NestedEnum
+	25, // 33: protobuf_test_messages.proto3.TestAllTypesProto3.optional_bool_wrapper:type_name -> google.protobuf.BoolValue
+	26, // 34: protobuf_test_messages.proto3.TestAllTypesProto3.optional_int32_wrapper:type_name -> google.protobuf.Int32Value
+	27, // 35: protobuf_test_messages.proto3.TestAllTypesProto3.optional_int64_wrapper:type_name -> google.protobuf.Int64Value
+	28, // 36: protobuf_test_messages.proto3.TestAllTypesProto3.optional_uint32_wrapper:type_name -> google.protobuf.UInt32Value
+	29, // 37: protobuf_test_messages.proto3.TestAllTypesProto3.optional_uint64_wrapper:type_name -> google.protobuf.UInt64Value
+	30, // 38: protobuf_test_messages.proto3.TestAllTypesProto3.optional_float_wrapper:type_name -> google.protobuf.FloatValue
+	31, // 39: protobuf_test_messages.proto3.TestAllTypesProto3.optional_double_wrapper:type_name -> google.protobuf.DoubleValue
+	32, // 40: protobuf_test_messages.proto3.TestAllTypesProto3.optional_string_wrapper:type_name -> google.protobuf.StringValue
+	33, // 41: protobuf_test_messages.proto3.TestAllTypesProto3.optional_bytes_wrapper:type_name -> google.protobuf.BytesValue
+	25, // 42: protobuf_test_messages.proto3.TestAllTypesProto3.repeated_bool_wrapper:type_name -> google.protobuf.BoolValue
+	26, // 43: protobuf_test_messages.proto3.TestAllTypesProto3.repeated_int32_wrapper:type_name -> google.protobuf.Int32Value
+	27, // 44: protobuf_test_messages.proto3.TestAllTypesProto3.repeated_int64_wrapper:type_name -> google.protobuf.Int64Value
+	28, // 45: protobuf_test_messages.proto3.TestAllTypesProto3.repeated_uint32_wrapper:type_name -> google.protobuf.UInt32Value
+	29, // 46: protobuf_test_messages.proto3.TestAllTypesProto3.repeated_uint64_wrapper:type_name -> google.protobuf.UInt64Value
+	30, // 47: protobuf_test_messages.proto3.TestAllTypesProto3.repeated_float_wrapper:type_name -> google.protobuf.FloatValue
+	31, // 48: protobuf_test_messages.proto3.TestAllTypesProto3.repeated_double_wrapper:type_name -> google.protobuf.DoubleValue
+	32, // 49: protobuf_test_messages.proto3.TestAllTypesProto3.repeated_string_wrapper:type_name -> google.protobuf.StringValue
+	33, // 50: protobuf_test_messages.proto3.TestAllTypesProto3.repeated_bytes_wrapper:type_name -> google.protobuf.BytesValue
+	34, // 51: protobuf_test_messages.proto3.TestAllTypesProto3.optional_duration:type_name -> google.protobuf.Duration
+	35, // 52: protobuf_test_messages.proto3.TestAllTypesProto3.optional_timestamp:type_name -> google.protobuf.Timestamp
+	36, // 53: protobuf_test_messages.proto3.TestAllTypesProto3.optional_field_mask:type_name -> google.protobuf.FieldMask
+	37, // 54: protobuf_test_messages.proto3.TestAllTypesProto3.optional_struct:type_name -> google.protobuf.Struct
+	38, // 55: protobuf_test_messages.proto3.TestAllTypesProto3.optional_any:type_name -> google.protobuf.Any
+	39, // 56: protobuf_test_messages.proto3.TestAllTypesProto3.optional_value:type_name -> google.protobuf.Value
+	34, // 57: protobuf_test_messages.proto3.TestAllTypesProto3.repeated_duration:type_name -> google.protobuf.Duration
+	35, // 58: protobuf_test_messages.proto3.TestAllTypesProto3.repeated_timestamp:type_name -> google.protobuf.Timestamp
+	36, // 59: protobuf_test_messages.proto3.TestAllTypesProto3.repeated_fieldmask:type_name -> google.protobuf.FieldMask
+	37, // 60: protobuf_test_messages.proto3.TestAllTypesProto3.repeated_struct:type_name -> google.protobuf.Struct
+	38, // 61: protobuf_test_messages.proto3.TestAllTypesProto3.repeated_any:type_name -> google.protobuf.Any
+	39, // 62: protobuf_test_messages.proto3.TestAllTypesProto3.repeated_value:type_name -> google.protobuf.Value
+	40, // 63: protobuf_test_messages.proto3.TestAllTypesProto3.repeated_list_value:type_name -> google.protobuf.ListValue
+	3,  // 64: protobuf_test_messages.proto3.TestAllTypesProto3.NestedMessage.corecursive:type_name -> protobuf_test_messages.proto3.TestAllTypesProto3
+	5,  // 65: protobuf_test_messages.proto3.TestAllTypesProto3.MapStringNestedMessageEntry.value:type_name -> protobuf_test_messages.proto3.TestAllTypesProto3.NestedMessage
+	4,  // 66: protobuf_test_messages.proto3.TestAllTypesProto3.MapStringForeignMessageEntry.value:type_name -> protobuf_test_messages.proto3.ForeignMessage
+	1,  // 67: protobuf_test_messages.proto3.TestAllTypesProto3.MapStringNestedEnumEntry.value:type_name -> protobuf_test_messages.proto3.TestAllTypesProto3.NestedEnum
+	0,  // 68: protobuf_test_messages.proto3.TestAllTypesProto3.MapStringForeignEnumEntry.value:type_name -> protobuf_test_messages.proto3.ForeignEnum
+	69, // [69:69] is the sub-list for method output_type
+	69, // [69:69] is the sub-list for method input_type
+	69, // [69:69] is the sub-list for extension type_name
+	69, // [69:69] is the sub-list for extension extendee
+	0,  // [0:69] is the sub-list for field type_name
+}
+
+func init() { file_google_protobuf_test_messages_proto3_proto_init() }
+func file_google_protobuf_test_messages_proto3_proto_init() {
+	if File_google_protobuf_test_messages_proto3_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_google_protobuf_test_messages_proto3_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*TestAllTypesProto3); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_test_messages_proto3_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ForeignMessage); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_test_messages_proto3_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*TestAllTypesProto3_NestedMessage); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	file_google_protobuf_test_messages_proto3_proto_msgTypes[0].OneofWrappers = []interface{}{
+		(*TestAllTypesProto3_OneofUint32)(nil),
+		(*TestAllTypesProto3_OneofNestedMessage)(nil),
+		(*TestAllTypesProto3_OneofString)(nil),
+		(*TestAllTypesProto3_OneofBytes)(nil),
+		(*TestAllTypesProto3_OneofBool)(nil),
+		(*TestAllTypesProto3_OneofUint64)(nil),
+		(*TestAllTypesProto3_OneofFloat)(nil),
+		(*TestAllTypesProto3_OneofDouble)(nil),
+		(*TestAllTypesProto3_OneofEnum)(nil),
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_google_protobuf_test_messages_proto3_proto_rawDesc,
+			NumEnums:      3,
+			NumMessages:   22,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_google_protobuf_test_messages_proto3_proto_goTypes,
+		DependencyIndexes: file_google_protobuf_test_messages_proto3_proto_depIdxs,
+		EnumInfos:         file_google_protobuf_test_messages_proto3_proto_enumTypes,
+		MessageInfos:      file_google_protobuf_test_messages_proto3_proto_msgTypes,
+	}.Build()
+	File_google_protobuf_test_messages_proto3_proto = out.File
+	file_google_protobuf_test_messages_proto3_proto_rawDesc = nil
+	file_google_protobuf_test_messages_proto3_proto_goTypes = nil
+	file_google_protobuf_test_messages_proto3_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/fieldmaskpb/field_mask.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/fieldmaskpb/field_mask.pb.go
new file mode 100644
index 000000000..b9bc13060
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/fieldmaskpb/field_mask.pb.go
@@ -0,0 +1,371 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google/protobuf/field_mask.proto
+
+package field_mask
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+// `FieldMask` represents a set of symbolic field paths, for example:
+//
+//     paths: "f.a"
+//     paths: "f.b.d"
+//
+// Here `f` represents a field in some root message, `a` and `b`
+// fields in the message found in `f`, and `d` a field found in the
+// message in `f.b`.
+//
+// Field masks are used to specify a subset of fields that should be
+// returned by a get operation or modified by an update operation.
+// Field masks also have a custom JSON encoding (see below).
+//
+// # Field Masks in Projections
+//
+// When used in the context of a projection, a response message or
+// sub-message is filtered by the API to only contain those fields as
+// specified in the mask. For example, if the mask in the previous
+// example is applied to a response message as follows:
+//
+//     f {
+//       a : 22
+//       b {
+//         d : 1
+//         x : 2
+//       }
+//       y : 13
+//     }
+//     z: 8
+//
+// The result will not contain specific values for fields x,y and z
+// (their value will be set to the default, and omitted in proto text
+// output):
+//
+//
+//     f {
+//       a : 22
+//       b {
+//         d : 1
+//       }
+//     }
+//
+// A repeated field is not allowed except at the last position of a
+// paths string.
+//
+// If a FieldMask object is not present in a get operation, the
+// operation applies to all fields (as if a FieldMask of all fields
+// had been specified).
+//
+// Note that a field mask does not necessarily apply to the
+// top-level response message. In case of a REST get operation, the
+// field mask applies directly to the response, but in case of a REST
+// list operation, the mask instead applies to each individual message
+// in the returned resource list. In case of a REST custom method,
+// other definitions may be used. Where the mask applies will be
+// clearly documented together with its declaration in the API.  In
+// any case, the effect on the returned resource/resources is required
+// behavior for APIs.
+//
+// # Field Masks in Update Operations
+//
+// A field mask in update operations specifies which fields of the
+// targeted resource are going to be updated. The API is required
+// to only change the values of the fields as specified in the mask
+// and leave the others untouched. If a resource is passed in to
+// describe the updated values, the API ignores the values of all
+// fields not covered by the mask.
+//
+// If a repeated field is specified for an update operation, new values will
+// be appended to the existing repeated field in the target resource. Note that
+// a repeated field is only allowed in the last position of a `paths` string.
+//
+// If a sub-message is specified in the last position of the field mask for an
+// update operation, then new value will be merged into the existing sub-message
+// in the target resource.
+//
+// For example, given the target message:
+//
+//     f {
+//       b {
+//         d: 1
+//         x: 2
+//       }
+//       c: [1]
+//     }
+//
+// And an update message:
+//
+//     f {
+//       b {
+//         d: 10
+//       }
+//       c: [2]
+//     }
+//
+// then if the field mask is:
+//
+//  paths: ["f.b", "f.c"]
+//
+// then the result will be:
+//
+//     f {
+//       b {
+//         d: 10
+//         x: 2
+//       }
+//       c: [1, 2]
+//     }
+//
+// An implementation may provide options to override this default behavior for
+// repeated and message fields.
+//
+// In order to reset a field's value to the default, the field must
+// be in the mask and set to the default value in the provided resource.
+// Hence, in order to reset all fields of a resource, provide a default
+// instance of the resource and set all fields in the mask, or do
+// not provide a mask as described below.
+//
+// If a field mask is not present on update, the operation applies to
+// all fields (as if a field mask of all fields has been specified).
+// Note that in the presence of schema evolution, this may mean that
+// fields the client does not know and has therefore not filled into
+// the request will be reset to their default. If this is unwanted
+// behavior, a specific service may require a client to always specify
+// a field mask, producing an error if not.
+//
+// As with get operations, the location of the resource which
+// describes the updated values in the request message depends on the
+// operation kind. In any case, the effect of the field mask is
+// required to be honored by the API.
+//
+// ## Considerations for HTTP REST
+//
+// The HTTP kind of an update operation which uses a field mask must
+// be set to PATCH instead of PUT in order to satisfy HTTP semantics
+// (PUT must only be used for full updates).
+//
+// # JSON Encoding of Field Masks
+//
+// In JSON, a field mask is encoded as a single string where paths are
+// separated by a comma. Fields name in each path are converted
+// to/from lower-camel naming conventions.
+//
+// As an example, consider the following message declarations:
+//
+//     message Profile {
+//       User user = 1;
+//       Photo photo = 2;
+//     }
+//     message User {
+//       string display_name = 1;
+//       string address = 2;
+//     }
+//
+// In proto a field mask for `Profile` may look as such:
+//
+//     mask {
+//       paths: "user.display_name"
+//       paths: "photo"
+//     }
+//
+// In JSON, the same mask is represented as below:
+//
+//     {
+//       mask: "user.displayName,photo"
+//     }
+//
+// # Field Masks and Oneof Fields
+//
+// Field masks treat fields in oneofs just as regular fields. Consider the
+// following message:
+//
+//     message SampleMessage {
+//       oneof test_oneof {
+//         string name = 4;
+//         SubMessage sub_message = 9;
+//       }
+//     }
+//
+// The field mask can be:
+//
+//     mask {
+//       paths: "name"
+//     }
+//
+// Or:
+//
+//     mask {
+//       paths: "sub_message"
+//     }
+//
+// Note that oneof type names ("test_oneof" in this case) cannot be used in
+// paths.
+//
+// ## Field Mask Verification
+//
+// The implementation of any API method which has a FieldMask type field in the
+// request should verify the included field paths, and return an
+// `INVALID_ARGUMENT` error if any path is unmappable.
+type FieldMask struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// The set of field mask paths.
+	Paths []string `protobuf:"bytes,1,rep,name=paths,proto3" json:"paths,omitempty"`
+}
+
+func (x *FieldMask) Reset() {
+	*x = FieldMask{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_field_mask_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *FieldMask) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*FieldMask) ProtoMessage() {}
+
+func (x *FieldMask) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_field_mask_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use FieldMask.ProtoReflect.Descriptor instead.
+func (*FieldMask) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_field_mask_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *FieldMask) GetPaths() []string {
+	if x != nil {
+		return x.Paths
+	}
+	return nil
+}
+
+var File_google_protobuf_field_mask_proto protoreflect.FileDescriptor
+
+var file_google_protobuf_field_mask_proto_rawDesc = []byte{
+	0x0a, 0x20, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x2f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x6d, 0x61, 0x73, 0x6b, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x12, 0x0f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x62, 0x75, 0x66, 0x22, 0x21, 0x0a, 0x09, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d, 0x61, 0x73, 0x6b,
+	0x12, 0x14, 0x0a, 0x05, 0x70, 0x61, 0x74, 0x68, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52,
+	0x05, 0x70, 0x61, 0x74, 0x68, 0x73, 0x42, 0x8c, 0x01, 0x0a, 0x13, 0x63, 0x6f, 0x6d, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x42, 0x0e,
+	0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d, 0x61, 0x73, 0x6b, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01,
+	0x5a, 0x39, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e,
+	0x6f, 0x72, 0x67, 0x2f, 0x67, 0x65, 0x6e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x6d, 0x61, 0x73, 0x6b,
+	0x3b, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x6d, 0x61, 0x73, 0x6b, 0xf8, 0x01, 0x01, 0xa2, 0x02,
+	0x03, 0x47, 0x50, 0x42, 0xaa, 0x02, 0x1e, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x50, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x57, 0x65, 0x6c, 0x6c, 0x4b, 0x6e, 0x6f, 0x77, 0x6e,
+	0x54, 0x79, 0x70, 0x65, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_google_protobuf_field_mask_proto_rawDescOnce sync.Once
+	file_google_protobuf_field_mask_proto_rawDescData = file_google_protobuf_field_mask_proto_rawDesc
+)
+
+func file_google_protobuf_field_mask_proto_rawDescGZIP() []byte {
+	file_google_protobuf_field_mask_proto_rawDescOnce.Do(func() {
+		file_google_protobuf_field_mask_proto_rawDescData = protoimpl.X.CompressGZIP(file_google_protobuf_field_mask_proto_rawDescData)
+	})
+	return file_google_protobuf_field_mask_proto_rawDescData
+}
+
+var file_google_protobuf_field_mask_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_google_protobuf_field_mask_proto_goTypes = []interface{}{
+	(*FieldMask)(nil), // 0: google.protobuf.FieldMask
+}
+var file_google_protobuf_field_mask_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_google_protobuf_field_mask_proto_init() }
+func file_google_protobuf_field_mask_proto_init() {
+	if File_google_protobuf_field_mask_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_google_protobuf_field_mask_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*FieldMask); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_google_protobuf_field_mask_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_google_protobuf_field_mask_proto_goTypes,
+		DependencyIndexes: file_google_protobuf_field_mask_proto_depIdxs,
+		MessageInfos:      file_google_protobuf_field_mask_proto_msgTypes,
+	}.Build()
+	File_google_protobuf_field_mask_proto = out.File
+	file_google_protobuf_field_mask_proto_rawDesc = nil
+	file_google_protobuf_field_mask_proto_goTypes = nil
+	file_google_protobuf_field_mask_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/fieldtrack/fieldtrack.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/fieldtrack/fieldtrack.pb.go
new file mode 100644
index 000000000..1e2c806e9
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/fieldtrack/fieldtrack.pb.go
@@ -0,0 +1,1042 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: internal/testprotos/fieldtrack/fieldtrack.proto
+
+package fieldtrack
+
+import (
+	_ "google.golang.org/protobuf/internal/testprotos/annotation"
+	test "google.golang.org/protobuf/internal/testprotos/test"
+	proto "google.golang.org/protobuf/proto"
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type TestFieldTrack struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	weakFields    protoimpl.WeakFields
+	unknownFields protoimpl.UnknownFields
+
+	OptionalInt32         *int32                                      `protobuf:"varint,1,opt,name=optional_int32,json=optionalInt32" json:"optional_int32,omitempty" go:"track"`
+	OptionalInt64         *int64                                      `protobuf:"varint,2,opt,name=optional_int64,json=optionalInt64" json:"optional_int64,omitempty" go:"track"`
+	OptionalUint32        *uint32                                     `protobuf:"varint,3,opt,name=optional_uint32,json=optionalUint32" json:"optional_uint32,omitempty" go:"track"`
+	OptionalUint64        *uint64                                     `protobuf:"varint,4,opt,name=optional_uint64,json=optionalUint64" json:"optional_uint64,omitempty" go:"track"`
+	OptionalSint32        *int32                                      `protobuf:"zigzag32,5,opt,name=optional_sint32,json=optionalSint32" json:"optional_sint32,omitempty" go:"track"`
+	OptionalSint64        *int64                                      `protobuf:"zigzag64,6,opt,name=optional_sint64,json=optionalSint64" json:"optional_sint64,omitempty" go:"track"`
+	OptionalFixed32       *uint32                                     `protobuf:"fixed32,7,opt,name=optional_fixed32,json=optionalFixed32" json:"optional_fixed32,omitempty" go:"track"`
+	OptionalFixed64       *uint64                                     `protobuf:"fixed64,8,opt,name=optional_fixed64,json=optionalFixed64" json:"optional_fixed64,omitempty" go:"track"`
+	OptionalSfixed32      *int32                                      `protobuf:"fixed32,9,opt,name=optional_sfixed32,json=optionalSfixed32" json:"optional_sfixed32,omitempty" go:"track"`
+	OptionalSfixed64      *int64                                      `protobuf:"fixed64,10,opt,name=optional_sfixed64,json=optionalSfixed64" json:"optional_sfixed64,omitempty" go:"track"`
+	OptionalFloat         *float32                                    `protobuf:"fixed32,11,opt,name=optional_float,json=optionalFloat" json:"optional_float,omitempty" go:"track"`
+	OptionalDouble        *float64                                    `protobuf:"fixed64,12,opt,name=optional_double,json=optionalDouble" json:"optional_double,omitempty" go:"track"`
+	OptionalBool          *bool                                       `protobuf:"varint,13,opt,name=optional_bool,json=optionalBool" json:"optional_bool,omitempty" go:"track"`
+	OptionalString        *string                                     `protobuf:"bytes,14,opt,name=optional_string,json=optionalString" json:"optional_string,omitempty" go:"track"`
+	OptionalBytes         []byte                                      `protobuf:"bytes,15,opt,name=optional_bytes,json=optionalBytes" json:"optional_bytes,omitempty" go:"track"`
+	OptionalEnum          *test.TestAllTypes_NestedEnum               `protobuf:"varint,16,opt,name=optional_enum,json=optionalEnum,enum=goproto.proto.test.TestAllTypes_NestedEnum" json:"optional_enum,omitempty" go:"track"`
+	OptionalMessage       *test.TestAllTypes_NestedMessage            `protobuf:"bytes,17,opt,name=optional_message,json=optionalMessage" json:"optional_message,omitempty" go:"track"`
+	RepeatedInt32         []int32                                     `protobuf:"varint,21,rep,name=repeated_int32,json=repeatedInt32" json:"repeated_int32,omitempty" go:"track"`
+	RepeatedInt64         []int64                                     `protobuf:"varint,22,rep,name=repeated_int64,json=repeatedInt64" json:"repeated_int64,omitempty" go:"track"`
+	RepeatedUint32        []uint32                                    `protobuf:"varint,23,rep,name=repeated_uint32,json=repeatedUint32" json:"repeated_uint32,omitempty" go:"track"`
+	RepeatedUint64        []uint64                                    `protobuf:"varint,24,rep,name=repeated_uint64,json=repeatedUint64" json:"repeated_uint64,omitempty" go:"track"`
+	RepeatedSint32        []int32                                     `protobuf:"zigzag32,25,rep,name=repeated_sint32,json=repeatedSint32" json:"repeated_sint32,omitempty" go:"track"`
+	RepeatedSint64        []int64                                     `protobuf:"zigzag64,26,rep,name=repeated_sint64,json=repeatedSint64" json:"repeated_sint64,omitempty" go:"track"`
+	RepeatedFixed32       []uint32                                    `protobuf:"fixed32,27,rep,name=repeated_fixed32,json=repeatedFixed32" json:"repeated_fixed32,omitempty" go:"track"`
+	RepeatedFixed64       []uint64                                    `protobuf:"fixed64,28,rep,name=repeated_fixed64,json=repeatedFixed64" json:"repeated_fixed64,omitempty" go:"track"`
+	RepeatedSfixed32      []int32                                     `protobuf:"fixed32,29,rep,name=repeated_sfixed32,json=repeatedSfixed32" json:"repeated_sfixed32,omitempty" go:"track"`
+	RepeatedSfixed64      []int64                                     `protobuf:"fixed64,30,rep,name=repeated_sfixed64,json=repeatedSfixed64" json:"repeated_sfixed64,omitempty" go:"track"`
+	RepeatedFloat         []float32                                   `protobuf:"fixed32,31,rep,name=repeated_float,json=repeatedFloat" json:"repeated_float,omitempty" go:"track"`
+	RepeatedDouble        []float64                                   `protobuf:"fixed64,32,rep,name=repeated_double,json=repeatedDouble" json:"repeated_double,omitempty" go:"track"`
+	RepeatedBool          []bool                                      `protobuf:"varint,33,rep,name=repeated_bool,json=repeatedBool" json:"repeated_bool,omitempty" go:"track"`
+	RepeatedString        []string                                    `protobuf:"bytes,34,rep,name=repeated_string,json=repeatedString" json:"repeated_string,omitempty" go:"track"`
+	RepeatedBytes         [][]byte                                    `protobuf:"bytes,35,rep,name=repeated_bytes,json=repeatedBytes" json:"repeated_bytes,omitempty" go:"track"`
+	RepeatedEnum          []test.TestAllTypes_NestedEnum              `protobuf:"varint,36,rep,name=repeated_enum,json=repeatedEnum,enum=goproto.proto.test.TestAllTypes_NestedEnum" json:"repeated_enum,omitempty" go:"track"`
+	RepeatedMessage       []*test.TestAllTypes_NestedMessage          `protobuf:"bytes,37,rep,name=repeated_message,json=repeatedMessage" json:"repeated_message,omitempty" go:"track"`
+	MapStringInt32        map[string]int32                            `protobuf:"bytes,41,rep,name=map_string_int32,json=mapStringInt32" json:"map_string_int32,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value" go:"track"`
+	MapStringInt64        map[string]int64                            `protobuf:"bytes,42,rep,name=map_string_int64,json=mapStringInt64" json:"map_string_int64,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value" go:"track"`
+	MapStringUint32       map[string]uint32                           `protobuf:"bytes,43,rep,name=map_string_uint32,json=mapStringUint32" json:"map_string_uint32,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value" go:"track"`
+	MapStringUint64       map[string]uint64                           `protobuf:"bytes,44,rep,name=map_string_uint64,json=mapStringUint64" json:"map_string_uint64,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value" go:"track"`
+	MapStringSint32       map[string]int32                            `protobuf:"bytes,45,rep,name=map_string_sint32,json=mapStringSint32" json:"map_string_sint32,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"zigzag32,2,opt,name=value" go:"track"`
+	MapStringSint64       map[string]int64                            `protobuf:"bytes,46,rep,name=map_string_sint64,json=mapStringSint64" json:"map_string_sint64,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"zigzag64,2,opt,name=value" go:"track"`
+	MapStringFixed32      map[string]uint32                           `protobuf:"bytes,47,rep,name=map_string_fixed32,json=mapStringFixed32" json:"map_string_fixed32,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value" go:"track"`
+	MapStringFixed64      map[string]uint64                           `protobuf:"bytes,48,rep,name=map_string_fixed64,json=mapStringFixed64" json:"map_string_fixed64,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value" go:"track"`
+	MapStringSfixed32     map[string]int32                            `protobuf:"bytes,49,rep,name=map_string_sfixed32,json=mapStringSfixed32" json:"map_string_sfixed32,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value" go:"track"`
+	MapStringSfixed64     map[string]int64                            `protobuf:"bytes,50,rep,name=map_string_sfixed64,json=mapStringSfixed64" json:"map_string_sfixed64,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value" go:"track"`
+	MapStringFloat        map[string]float32                          `protobuf:"bytes,51,rep,name=map_string_float,json=mapStringFloat" json:"map_string_float,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value" go:"track"`
+	MapStringDouble       map[string]float64                          `protobuf:"bytes,52,rep,name=map_string_double,json=mapStringDouble" json:"map_string_double,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value" go:"track"`
+	MapStringBool         map[string]bool                             `protobuf:"bytes,53,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" go:"track"`
+	MapStringString       map[string]string                           `protobuf:"bytes,54,rep,name=map_string_string,json=mapStringString" json:"map_string_string,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value" go:"track"`
+	MapStringBytes        map[string][]byte                           `protobuf:"bytes,55,rep,name=map_string_bytes,json=mapStringBytes" json:"map_string_bytes,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value" go:"track"`
+	MapStringEnum         map[string]test.TestAllTypes_NestedEnum     `protobuf:"bytes,56,rep,name=map_string_enum,json=mapStringEnum" json:"map_string_enum,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=goproto.proto.test.TestAllTypes_NestedEnum" go:"track"`
+	MapStringMessage      map[string]*test.TestAllTypes_NestedMessage `protobuf:"bytes,57,rep,name=map_string_message,json=mapStringMessage" json:"map_string_message,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value" go:"track"`
+	XXX_weak_WeakMessage1 struct{}                                    `protobuf:"bytes,100,opt,name=weak_message1,json=weakMessage1,weak=goproto.proto.test.weak.WeakImportMessage1" json:"weak_message1,omitempty" go:"track"`
+	XXX_weak_WeakMessage2 struct{}                                    `protobuf:"bytes,101,opt,name=weak_message2,json=weakMessage2,weak=goproto.proto.test.weak.WeakImportMessage2" json:"weak_message2,omitempty" go:"track"`
+}
+
+func (x *TestFieldTrack) Reset() {
+	*x = TestFieldTrack{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_fieldtrack_fieldtrack_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *TestFieldTrack) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TestFieldTrack) ProtoMessage() {}
+
+func (x *TestFieldTrack) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_fieldtrack_fieldtrack_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TestFieldTrack.ProtoReflect.Descriptor instead.
+func (*TestFieldTrack) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_fieldtrack_fieldtrack_proto_rawDescGZIP(), []int{0}
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetOptionalInt32() int32 {
+	if x != nil && x.OptionalInt32 != nil {
+		return *x.OptionalInt32
+	}
+	return 0
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetOptionalInt64() int64 {
+	if x != nil && x.OptionalInt64 != nil {
+		return *x.OptionalInt64
+	}
+	return 0
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetOptionalUint32() uint32 {
+	if x != nil && x.OptionalUint32 != nil {
+		return *x.OptionalUint32
+	}
+	return 0
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetOptionalUint64() uint64 {
+	if x != nil && x.OptionalUint64 != nil {
+		return *x.OptionalUint64
+	}
+	return 0
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetOptionalSint32() int32 {
+	if x != nil && x.OptionalSint32 != nil {
+		return *x.OptionalSint32
+	}
+	return 0
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetOptionalSint64() int64 {
+	if x != nil && x.OptionalSint64 != nil {
+		return *x.OptionalSint64
+	}
+	return 0
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetOptionalFixed32() uint32 {
+	if x != nil && x.OptionalFixed32 != nil {
+		return *x.OptionalFixed32
+	}
+	return 0
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetOptionalFixed64() uint64 {
+	if x != nil && x.OptionalFixed64 != nil {
+		return *x.OptionalFixed64
+	}
+	return 0
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetOptionalSfixed32() int32 {
+	if x != nil && x.OptionalSfixed32 != nil {
+		return *x.OptionalSfixed32
+	}
+	return 0
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetOptionalSfixed64() int64 {
+	if x != nil && x.OptionalSfixed64 != nil {
+		return *x.OptionalSfixed64
+	}
+	return 0
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetOptionalFloat() float32 {
+	if x != nil && x.OptionalFloat != nil {
+		return *x.OptionalFloat
+	}
+	return 0
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetOptionalDouble() float64 {
+	if x != nil && x.OptionalDouble != nil {
+		return *x.OptionalDouble
+	}
+	return 0
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetOptionalBool() bool {
+	if x != nil && x.OptionalBool != nil {
+		return *x.OptionalBool
+	}
+	return false
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetOptionalString() string {
+	if x != nil && x.OptionalString != nil {
+		return *x.OptionalString
+	}
+	return ""
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetOptionalBytes() []byte {
+	if x != nil {
+		return x.OptionalBytes
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetOptionalEnum() test.TestAllTypes_NestedEnum {
+	if x != nil && x.OptionalEnum != nil {
+		return *x.OptionalEnum
+	}
+	return test.TestAllTypes_FOO
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetOptionalMessage() *test.TestAllTypes_NestedMessage {
+	if x != nil {
+		return x.OptionalMessage
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetRepeatedInt32() []int32 {
+	if x != nil {
+		return x.RepeatedInt32
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetRepeatedInt64() []int64 {
+	if x != nil {
+		return x.RepeatedInt64
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetRepeatedUint32() []uint32 {
+	if x != nil {
+		return x.RepeatedUint32
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetRepeatedUint64() []uint64 {
+	if x != nil {
+		return x.RepeatedUint64
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetRepeatedSint32() []int32 {
+	if x != nil {
+		return x.RepeatedSint32
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetRepeatedSint64() []int64 {
+	if x != nil {
+		return x.RepeatedSint64
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetRepeatedFixed32() []uint32 {
+	if x != nil {
+		return x.RepeatedFixed32
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetRepeatedFixed64() []uint64 {
+	if x != nil {
+		return x.RepeatedFixed64
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetRepeatedSfixed32() []int32 {
+	if x != nil {
+		return x.RepeatedSfixed32
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetRepeatedSfixed64() []int64 {
+	if x != nil {
+		return x.RepeatedSfixed64
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetRepeatedFloat() []float32 {
+	if x != nil {
+		return x.RepeatedFloat
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetRepeatedDouble() []float64 {
+	if x != nil {
+		return x.RepeatedDouble
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetRepeatedBool() []bool {
+	if x != nil {
+		return x.RepeatedBool
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetRepeatedString() []string {
+	if x != nil {
+		return x.RepeatedString
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetRepeatedBytes() [][]byte {
+	if x != nil {
+		return x.RepeatedBytes
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetRepeatedEnum() []test.TestAllTypes_NestedEnum {
+	if x != nil {
+		return x.RepeatedEnum
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetRepeatedMessage() []*test.TestAllTypes_NestedMessage {
+	if x != nil {
+		return x.RepeatedMessage
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetMapStringInt32() map[string]int32 {
+	if x != nil {
+		return x.MapStringInt32
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetMapStringInt64() map[string]int64 {
+	if x != nil {
+		return x.MapStringInt64
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetMapStringUint32() map[string]uint32 {
+	if x != nil {
+		return x.MapStringUint32
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetMapStringUint64() map[string]uint64 {
+	if x != nil {
+		return x.MapStringUint64
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetMapStringSint32() map[string]int32 {
+	if x != nil {
+		return x.MapStringSint32
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetMapStringSint64() map[string]int64 {
+	if x != nil {
+		return x.MapStringSint64
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetMapStringFixed32() map[string]uint32 {
+	if x != nil {
+		return x.MapStringFixed32
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetMapStringFixed64() map[string]uint64 {
+	if x != nil {
+		return x.MapStringFixed64
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetMapStringSfixed32() map[string]int32 {
+	if x != nil {
+		return x.MapStringSfixed32
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetMapStringSfixed64() map[string]int64 {
+	if x != nil {
+		return x.MapStringSfixed64
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetMapStringFloat() map[string]float32 {
+	if x != nil {
+		return x.MapStringFloat
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetMapStringDouble() map[string]float64 {
+	if x != nil {
+		return x.MapStringDouble
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetMapStringBool() map[string]bool {
+	if x != nil {
+		return x.MapStringBool
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetMapStringString() map[string]string {
+	if x != nil {
+		return x.MapStringString
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetMapStringBytes() map[string][]byte {
+	if x != nil {
+		return x.MapStringBytes
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetMapStringEnum() map[string]test.TestAllTypes_NestedEnum {
+	if x != nil {
+		return x.MapStringEnum
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetMapStringMessage() map[string]*test.TestAllTypes_NestedMessage {
+	if x != nil {
+		return x.MapStringMessage
+	}
+	return nil
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetWeakMessage1() proto.Message {
+	var w protoimpl.WeakFields
+	if x != nil {
+		w = x.weakFields
+		_ = x.XXX_weak_WeakMessage1
+	}
+	return protoimpl.X.GetWeak(w, 100, "goproto.proto.test.weak.WeakImportMessage1")
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) GetWeakMessage2() proto.Message {
+	var w protoimpl.WeakFields
+	if x != nil {
+		w = x.weakFields
+		_ = x.XXX_weak_WeakMessage2
+	}
+	return protoimpl.X.GetWeak(w, 101, "goproto.proto.test.weak.WeakImportMessage2")
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) SetWeakMessage1(v proto.Message) {
+	var w *protoimpl.WeakFields
+	if x != nil {
+		w = &x.weakFields
+		_ = x.XXX_weak_WeakMessage1
+	}
+	protoimpl.X.SetWeak(w, 100, "goproto.proto.test.weak.WeakImportMessage1", v)
+}
+
+//go:nointerface
+
+func (x *TestFieldTrack) SetWeakMessage2(v proto.Message) {
+	var w *protoimpl.WeakFields
+	if x != nil {
+		w = &x.weakFields
+		_ = x.XXX_weak_WeakMessage2
+	}
+	protoimpl.X.SetWeak(w, 101, "goproto.proto.test.weak.WeakImportMessage2", v)
+}
+
+var File_internal_testprotos_fieldtrack_fieldtrack_proto protoreflect.FileDescriptor
+
+var file_internal_testprotos_fieldtrack_fieldtrack_proto_rawDesc = []byte{
+	0x0a, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x74, 0x72, 0x61, 0x63, 0x6b,
+	0x2f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x12, 0x12, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x74, 0x65, 0x73, 0x74, 0x1a, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f,
+	0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x74,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x23, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c,
+	0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74,
+	0x2f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x2e, 0x69, 0x6e, 0x74,
+	0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73,
+	0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x77, 0x65, 0x61, 0x6b, 0x31, 0x2f, 0x74, 0x65, 0x73, 0x74,
+	0x5f, 0x77, 0x65, 0x61, 0x6b, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x2e, 0x69, 0x6e, 0x74,
+	0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73,
+	0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x77, 0x65, 0x61, 0x6b, 0x32, 0x2f, 0x74, 0x65, 0x73, 0x74,
+	0x5f, 0x77, 0x65, 0x61, 0x6b, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xfe, 0x24, 0x0a, 0x0e,
+	0x54, 0x65, 0x73, 0x74, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x12, 0x25,
+	0x0a, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x25, 0x0a, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x27, 0x0a, 0x0f,
+	0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x55,
+	0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x27, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e,
+	0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x27,
+	0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x33,
+	0x32, 0x18, 0x05, 0x20, 0x01, 0x28, 0x11, 0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x27, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x06, 0x20, 0x01, 0x28, 0x12,
+	0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34,
+	0x12, 0x29, 0x0a, 0x10, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x66, 0x69, 0x78,
+	0x65, 0x64, 0x33, 0x32, 0x18, 0x07, 0x20, 0x01, 0x28, 0x07, 0x52, 0x0f, 0x6f, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x61, 0x6c, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x29, 0x0a, 0x10, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18,
+	0x08, 0x20, 0x01, 0x28, 0x06, 0x52, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x46,
+	0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x2b, 0x0a, 0x11, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+	0x61, 0x6c, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x09, 0x20, 0x01, 0x28,
+	0x0f, 0x52, 0x10, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x66, 0x69, 0x78, 0x65,
+	0x64, 0x33, 0x32, 0x12, 0x2b, 0x0a, 0x11, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f,
+	0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x10, 0x52, 0x10,
+	0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34,
+	0x12, 0x25, 0x0a, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x66, 0x6c, 0x6f,
+	0x61, 0x74, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+	0x61, 0x6c, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x01,
+	0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65,
+	0x12, 0x23, 0x0a, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x62, 0x6f, 0x6f,
+	0x6c, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x27, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e,
+	0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x25,
+	0x0a, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73,
+	0x18, 0x0f, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x50, 0x0a, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2b, 0x2e, 0x67,
+	0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73,
+	0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4e,
+	0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0c, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x59, 0x0a, 0x10, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x11, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x2e, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79,
+	0x70, 0x65, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x52, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x69,
+	0x6e, 0x74, 0x33, 0x32, 0x18, 0x15, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x65,
+	0x61, 0x74, 0x65, 0x64, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x70,
+	0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x16, 0x20, 0x03, 0x28,
+	0x03, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x49, 0x6e, 0x74, 0x36, 0x34,
+	0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x75, 0x69, 0x6e,
+	0x74, 0x33, 0x32, 0x18, 0x17, 0x20, 0x03, 0x28, 0x0d, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61,
+	0x74, 0x65, 0x64, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x70,
+	0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x18, 0x20, 0x03,
+	0x28, 0x04, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x55, 0x69, 0x6e, 0x74,
+	0x36, 0x34, 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x73,
+	0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x19, 0x20, 0x03, 0x28, 0x11, 0x52, 0x0e, 0x72, 0x65, 0x70,
+	0x65, 0x61, 0x74, 0x65, 0x64, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x27, 0x0a, 0x0f, 0x72,
+	0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x1a,
+	0x20, 0x03, 0x28, 0x12, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x53, 0x69,
+	0x6e, 0x74, 0x36, 0x34, 0x12, 0x29, 0x0a, 0x10, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
+	0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x1b, 0x20, 0x03, 0x28, 0x07, 0x52, 0x0f,
+	0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12,
+	0x29, 0x0a, 0x10, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x66, 0x69, 0x78, 0x65,
+	0x64, 0x36, 0x34, 0x18, 0x1c, 0x20, 0x03, 0x28, 0x06, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61,
+	0x74, 0x65, 0x64, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x2b, 0x0a, 0x11, 0x72, 0x65,
+	0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18,
+	0x1d, 0x20, 0x03, 0x28, 0x0f, 0x52, 0x10, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x53,
+	0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x2b, 0x0a, 0x11, 0x72, 0x65, 0x70, 0x65, 0x61,
+	0x74, 0x65, 0x64, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x1e, 0x20, 0x03,
+	0x28, 0x10, 0x52, 0x10, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x53, 0x66, 0x69, 0x78,
+	0x65, 0x64, 0x36, 0x34, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
+	0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x18, 0x1f, 0x20, 0x03, 0x28, 0x02, 0x52, 0x0d, 0x72, 0x65,
+	0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x72,
+	0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0x20,
+	0x20, 0x03, 0x28, 0x01, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x44, 0x6f,
+	0x75, 0x62, 0x6c, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
+	0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18, 0x21, 0x20, 0x03, 0x28, 0x08, 0x52, 0x0c, 0x72, 0x65, 0x70,
+	0x65, 0x61, 0x74, 0x65, 0x64, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x70,
+	0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x22, 0x20, 0x03,
+	0x28, 0x09, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x53, 0x74, 0x72, 0x69,
+	0x6e, 0x67, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x62,
+	0x79, 0x74, 0x65, 0x73, 0x18, 0x23, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x65,
+	0x61, 0x74, 0x65, 0x64, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x50, 0x0a, 0x0d, 0x72, 0x65, 0x70,
+	0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x24, 0x20, 0x03, 0x28, 0x0e,
+	0x32, 0x2b, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70,
+	0x65, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0c, 0x72,
+	0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x59, 0x0a, 0x10, 0x72,
+	0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18,
+	0x25, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41,
+	0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x60, 0x0a, 0x10, 0x6d, 0x61, 0x70, 0x5f, 0x73, 0x74,
+	0x72, 0x69, 0x6e, 0x67, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x29, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x36, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x54,
+	0x72, 0x61, 0x63, 0x6b, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x49, 0x6e,
+	0x74, 0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, 0x6d, 0x61, 0x70, 0x53, 0x74, 0x72,
+	0x69, 0x6e, 0x67, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x60, 0x0a, 0x10, 0x6d, 0x61, 0x70, 0x5f,
+	0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x2a, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x36, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x46, 0x69, 0x65, 0x6c,
+	0x64, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67,
+	0x49, 0x6e, 0x74, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, 0x6d, 0x61, 0x70, 0x53,
+	0x74, 0x72, 0x69, 0x6e, 0x67, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x63, 0x0a, 0x11, 0x6d, 0x61,
+	0x70, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18,
+	0x2b, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x37, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x46,
+	0x69, 0x65, 0x6c, 0x64, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72,
+	0x69, 0x6e, 0x67, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f,
+	0x6d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12,
+	0x63, 0x0a, 0x11, 0x6d, 0x61, 0x70, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x75, 0x69,
+	0x6e, 0x74, 0x36, 0x34, 0x18, 0x2c, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x37, 0x2e, 0x67, 0x6f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e,
+	0x54, 0x65, 0x73, 0x74, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x2e, 0x4d,
+	0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x45, 0x6e,
+	0x74, 0x72, 0x79, 0x52, 0x0f, 0x6d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x55, 0x69,
+	0x6e, 0x74, 0x36, 0x34, 0x12, 0x63, 0x0a, 0x11, 0x6d, 0x61, 0x70, 0x5f, 0x73, 0x74, 0x72, 0x69,
+	0x6e, 0x67, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x2d, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x37, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x54, 0x72,
+	0x61, 0x63, 0x6b, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x69, 0x6e,
+	0x74, 0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x6d, 0x61, 0x70, 0x53, 0x74, 0x72,
+	0x69, 0x6e, 0x67, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x63, 0x0a, 0x11, 0x6d, 0x61, 0x70,
+	0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x2e,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x37, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x46, 0x69,
+	0x65, 0x6c, 0x64, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69,
+	0x6e, 0x67, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x6d,
+	0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x66,
+	0x0a, 0x12, 0x6d, 0x61, 0x70, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x66, 0x69, 0x78,
+	0x65, 0x64, 0x33, 0x32, 0x18, 0x2f, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x38, 0x2e, 0x67, 0x6f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e,
+	0x54, 0x65, 0x73, 0x74, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x2e, 0x4d,
+	0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x45,
+	0x6e, 0x74, 0x72, 0x79, 0x52, 0x10, 0x6d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x46,
+	0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x66, 0x0a, 0x12, 0x6d, 0x61, 0x70, 0x5f, 0x73, 0x74,
+	0x72, 0x69, 0x6e, 0x67, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x30, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x38, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x46, 0x69, 0x65, 0x6c,
+	0x64, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67,
+	0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x10, 0x6d, 0x61,
+	0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x69,
+	0x0a, 0x13, 0x6d, 0x61, 0x70, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x66, 0x69,
+	0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x31, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x39, 0x2e, 0x67, 0x6f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74,
+	0x2e, 0x54, 0x65, 0x73, 0x74, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x2e,
+	0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33,
+	0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x11, 0x6d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e,
+	0x67, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x69, 0x0a, 0x13, 0x6d, 0x61, 0x70,
+	0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34,
+	0x18, 0x32, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x39, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74,
+	0x46, 0x69, 0x65, 0x6c, 0x64, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74,
+	0x72, 0x69, 0x6e, 0x67, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72,
+	0x79, 0x52, 0x11, 0x6d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x66, 0x69, 0x78,
+	0x65, 0x64, 0x36, 0x34, 0x12, 0x60, 0x0a, 0x10, 0x6d, 0x61, 0x70, 0x5f, 0x73, 0x74, 0x72, 0x69,
+	0x6e, 0x67, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x18, 0x33, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x36,
+	0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74,
+	0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x54, 0x72, 0x61,
+	0x63, 0x6b, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x46, 0x6c, 0x6f, 0x61,
+	0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, 0x6d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e,
+	0x67, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x63, 0x0a, 0x11, 0x6d, 0x61, 0x70, 0x5f, 0x73, 0x74,
+	0x72, 0x69, 0x6e, 0x67, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0x34, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x37, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x46, 0x69, 0x65, 0x6c, 0x64,
+	0x54, 0x72, 0x61, 0x63, 0x6b, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x44,
+	0x6f, 0x75, 0x62, 0x6c, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x6d, 0x61, 0x70, 0x53,
+	0x74, 0x72, 0x69, 0x6e, 0x67, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x5d, 0x0a, 0x0f, 0x6d,
+	0x61, 0x70, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18, 0x35,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x46, 0x69,
+	0x65, 0x6c, 0x64, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69,
+	0x6e, 0x67, 0x42, 0x6f, 0x6f, 0x6c, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0d, 0x6d, 0x61, 0x70,
+	0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x63, 0x0a, 0x11, 0x6d, 0x61,
+	0x70, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18,
+	0x36, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x37, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x46,
+	0x69, 0x65, 0x6c, 0x64, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72,
+	0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f,
+	0x6d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12,
+	0x60, 0x0a, 0x10, 0x6d, 0x61, 0x70, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x62, 0x79,
+	0x74, 0x65, 0x73, 0x18, 0x37, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x67, 0x6f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54,
+	0x65, 0x73, 0x74, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x2e, 0x4d, 0x61,
+	0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x79, 0x74, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72,
+	0x79, 0x52, 0x0e, 0x6d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x79, 0x74, 0x65,
+	0x73, 0x12, 0x5d, 0x0a, 0x0f, 0x6d, 0x61, 0x70, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f,
+	0x65, 0x6e, 0x75, 0x6d, 0x18, 0x38, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x67, 0x6f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e,
+	0x54, 0x65, 0x73, 0x74, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x2e, 0x4d,
+	0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x75, 0x6d, 0x45, 0x6e, 0x74, 0x72,
+	0x79, 0x52, 0x0d, 0x6d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x75, 0x6d,
+	0x12, 0x66, 0x0a, 0x12, 0x6d, 0x61, 0x70, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x39, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x38, 0x2e, 0x67,
+	0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73,
+	0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x54, 0x72, 0x61, 0x63, 0x6b,
+	0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x10, 0x6d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e,
+	0x67, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x54, 0x0a, 0x0d, 0x77, 0x65, 0x61, 0x6b,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x18, 0x64, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2b, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x74, 0x65, 0x73, 0x74, 0x2e, 0x77, 0x65, 0x61, 0x6b, 0x2e, 0x57, 0x65, 0x61, 0x6b, 0x49, 0x6d,
+	0x70, 0x6f, 0x72, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x42, 0x02, 0x50, 0x01,
+	0x52, 0x0c, 0x77, 0x65, 0x61, 0x6b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x12, 0x54,
+	0x0a, 0x0d, 0x77, 0x65, 0x61, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x18,
+	0x65, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x77, 0x65, 0x61, 0x6b, 0x2e,
+	0x57, 0x65, 0x61, 0x6b, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x32, 0x42, 0x02, 0x50, 0x01, 0x52, 0x0c, 0x77, 0x65, 0x61, 0x6b, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x32, 0x1a, 0x41, 0x0a, 0x13, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e,
+	0x67, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b,
+	0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a,
+	0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x76, 0x61,
+	0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x41, 0x0a, 0x13, 0x4d, 0x61, 0x70, 0x53, 0x74,
+	0x72, 0x69, 0x6e, 0x67, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10,
+	0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79,
+	0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52,
+	0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x42, 0x0a, 0x14, 0x4d, 0x61,
+	0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x45, 0x6e, 0x74,
+	0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x0d, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x42,
+	0x0a, 0x14, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x55, 0x69, 0x6e, 0x74, 0x36,
+	0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75,
+	0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02,
+	0x38, 0x01, 0x1a, 0x42, 0x0a, 0x14, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53,
+	0x69, 0x6e, 0x74, 0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65,
+	0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05,
+	0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x11, 0x52, 0x05, 0x76, 0x61, 0x6c,
+	0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x42, 0x0a, 0x14, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72,
+	0x69, 0x6e, 0x67, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10,
+	0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79,
+	0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x12, 0x52,
+	0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x43, 0x0a, 0x15, 0x4d, 0x61,
+	0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x45, 0x6e,
+	0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x07, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a,
+	0x43, 0x0a, 0x15, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x46, 0x69, 0x78, 0x65,
+	0x64, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61,
+	0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x06, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
+	0x3a, 0x02, 0x38, 0x01, 0x1a, 0x44, 0x0a, 0x16, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e,
+	0x67, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10,
+	0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79,
+	0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0f, 0x52,
+	0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x44, 0x0a, 0x16, 0x4d, 0x61,
+	0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x45,
+	0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x10, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01,
+	0x1a, 0x41, 0x0a, 0x13, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x46, 0x6c, 0x6f,
+	0x61, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c,
+	0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x02, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a,
+	0x02, 0x38, 0x01, 0x1a, 0x42, 0x0a, 0x14, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67,
+	0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b,
+	0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a,
+	0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x05, 0x76, 0x61,
+	0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x40, 0x0a, 0x12, 0x4d, 0x61, 0x70, 0x53, 0x74,
+	0x72, 0x69, 0x6e, 0x67, 0x42, 0x6f, 0x6f, 0x6c, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a,
+	0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12,
+	0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05,
+	0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x42, 0x0a, 0x14, 0x4d, 0x61, 0x70,
+	0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72,
+	0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03,
+	0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x41, 0x0a,
+	0x13, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x79, 0x74, 0x65, 0x73, 0x45,
+	0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01,
+	0x1a, 0x6d, 0x0a, 0x12, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x75,
+	0x6d, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x41, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75,
+	0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2b, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73,
+	0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64,
+	0x45, 0x6e, 0x75, 0x6d, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a,
+	0x73, 0x0a, 0x15, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x44, 0x0a, 0x05, 0x76, 0x61,
+	0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x67, 0x6f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54,
+	0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74,
+	0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
+	0x3a, 0x02, 0x38, 0x01, 0x3a, 0x06, 0xa8, 0xe0, 0xcd, 0x8e, 0x01, 0x01, 0x42, 0x3b, 0x5a, 0x39,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72,
+	0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72,
+	0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x66,
+	0x69, 0x65, 0x6c, 0x64, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x58, 0x02, 0x58, 0x03,
+}
+
+var (
+	file_internal_testprotos_fieldtrack_fieldtrack_proto_rawDescOnce sync.Once
+	file_internal_testprotos_fieldtrack_fieldtrack_proto_rawDescData = file_internal_testprotos_fieldtrack_fieldtrack_proto_rawDesc
+)
+
+func file_internal_testprotos_fieldtrack_fieldtrack_proto_rawDescGZIP() []byte {
+	file_internal_testprotos_fieldtrack_fieldtrack_proto_rawDescOnce.Do(func() {
+		file_internal_testprotos_fieldtrack_fieldtrack_proto_rawDescData = protoimpl.X.CompressGZIP(file_internal_testprotos_fieldtrack_fieldtrack_proto_rawDescData)
+	})
+	return file_internal_testprotos_fieldtrack_fieldtrack_proto_rawDescData
+}
+
+var file_internal_testprotos_fieldtrack_fieldtrack_proto_msgTypes = make([]protoimpl.MessageInfo, 18)
+var file_internal_testprotos_fieldtrack_fieldtrack_proto_goTypes = []interface{}{
+	(*TestFieldTrack)(nil),                  // 0: goproto.proto.test.TestFieldTrack
+	nil,                                     // 1: goproto.proto.test.TestFieldTrack.MapStringInt32Entry
+	nil,                                     // 2: goproto.proto.test.TestFieldTrack.MapStringInt64Entry
+	nil,                                     // 3: goproto.proto.test.TestFieldTrack.MapStringUint32Entry
+	nil,                                     // 4: goproto.proto.test.TestFieldTrack.MapStringUint64Entry
+	nil,                                     // 5: goproto.proto.test.TestFieldTrack.MapStringSint32Entry
+	nil,                                     // 6: goproto.proto.test.TestFieldTrack.MapStringSint64Entry
+	nil,                                     // 7: goproto.proto.test.TestFieldTrack.MapStringFixed32Entry
+	nil,                                     // 8: goproto.proto.test.TestFieldTrack.MapStringFixed64Entry
+	nil,                                     // 9: goproto.proto.test.TestFieldTrack.MapStringSfixed32Entry
+	nil,                                     // 10: goproto.proto.test.TestFieldTrack.MapStringSfixed64Entry
+	nil,                                     // 11: goproto.proto.test.TestFieldTrack.MapStringFloatEntry
+	nil,                                     // 12: goproto.proto.test.TestFieldTrack.MapStringDoubleEntry
+	nil,                                     // 13: goproto.proto.test.TestFieldTrack.MapStringBoolEntry
+	nil,                                     // 14: goproto.proto.test.TestFieldTrack.MapStringStringEntry
+	nil,                                     // 15: goproto.proto.test.TestFieldTrack.MapStringBytesEntry
+	nil,                                     // 16: goproto.proto.test.TestFieldTrack.MapStringEnumEntry
+	nil,                                     // 17: goproto.proto.test.TestFieldTrack.MapStringMessageEntry
+	(test.TestAllTypes_NestedEnum)(0),       // 18: goproto.proto.test.TestAllTypes.NestedEnum
+	(*test.TestAllTypes_NestedMessage)(nil), // 19: goproto.proto.test.TestAllTypes.NestedMessage
+}
+var file_internal_testprotos_fieldtrack_fieldtrack_proto_depIdxs = []int32{
+	18, // 0: goproto.proto.test.TestFieldTrack.optional_enum:type_name -> goproto.proto.test.TestAllTypes.NestedEnum
+	19, // 1: goproto.proto.test.TestFieldTrack.optional_message:type_name -> goproto.proto.test.TestAllTypes.NestedMessage
+	18, // 2: goproto.proto.test.TestFieldTrack.repeated_enum:type_name -> goproto.proto.test.TestAllTypes.NestedEnum
+	19, // 3: goproto.proto.test.TestFieldTrack.repeated_message:type_name -> goproto.proto.test.TestAllTypes.NestedMessage
+	1,  // 4: goproto.proto.test.TestFieldTrack.map_string_int32:type_name -> goproto.proto.test.TestFieldTrack.MapStringInt32Entry
+	2,  // 5: goproto.proto.test.TestFieldTrack.map_string_int64:type_name -> goproto.proto.test.TestFieldTrack.MapStringInt64Entry
+	3,  // 6: goproto.proto.test.TestFieldTrack.map_string_uint32:type_name -> goproto.proto.test.TestFieldTrack.MapStringUint32Entry
+	4,  // 7: goproto.proto.test.TestFieldTrack.map_string_uint64:type_name -> goproto.proto.test.TestFieldTrack.MapStringUint64Entry
+	5,  // 8: goproto.proto.test.TestFieldTrack.map_string_sint32:type_name -> goproto.proto.test.TestFieldTrack.MapStringSint32Entry
+	6,  // 9: goproto.proto.test.TestFieldTrack.map_string_sint64:type_name -> goproto.proto.test.TestFieldTrack.MapStringSint64Entry
+	7,  // 10: goproto.proto.test.TestFieldTrack.map_string_fixed32:type_name -> goproto.proto.test.TestFieldTrack.MapStringFixed32Entry
+	8,  // 11: goproto.proto.test.TestFieldTrack.map_string_fixed64:type_name -> goproto.proto.test.TestFieldTrack.MapStringFixed64Entry
+	9,  // 12: goproto.proto.test.TestFieldTrack.map_string_sfixed32:type_name -> goproto.proto.test.TestFieldTrack.MapStringSfixed32Entry
+	10, // 13: goproto.proto.test.TestFieldTrack.map_string_sfixed64:type_name -> goproto.proto.test.TestFieldTrack.MapStringSfixed64Entry
+	11, // 14: goproto.proto.test.TestFieldTrack.map_string_float:type_name -> goproto.proto.test.TestFieldTrack.MapStringFloatEntry
+	12, // 15: goproto.proto.test.TestFieldTrack.map_string_double:type_name -> goproto.proto.test.TestFieldTrack.MapStringDoubleEntry
+	13, // 16: goproto.proto.test.TestFieldTrack.map_string_bool:type_name -> goproto.proto.test.TestFieldTrack.MapStringBoolEntry
+	14, // 17: goproto.proto.test.TestFieldTrack.map_string_string:type_name -> goproto.proto.test.TestFieldTrack.MapStringStringEntry
+	15, // 18: goproto.proto.test.TestFieldTrack.map_string_bytes:type_name -> goproto.proto.test.TestFieldTrack.MapStringBytesEntry
+	16, // 19: goproto.proto.test.TestFieldTrack.map_string_enum:type_name -> goproto.proto.test.TestFieldTrack.MapStringEnumEntry
+	17, // 20: goproto.proto.test.TestFieldTrack.map_string_message:type_name -> goproto.proto.test.TestFieldTrack.MapStringMessageEntry
+	18, // 21: goproto.proto.test.TestFieldTrack.MapStringEnumEntry.value:type_name -> goproto.proto.test.TestAllTypes.NestedEnum
+	19, // 22: goproto.proto.test.TestFieldTrack.MapStringMessageEntry.value:type_name -> goproto.proto.test.TestAllTypes.NestedMessage
+	23, // [23:23] is the sub-list for method output_type
+	23, // [23:23] is the sub-list for method input_type
+	23, // [23:23] is the sub-list for extension type_name
+	23, // [23:23] is the sub-list for extension extendee
+	0,  // [0:23] is the sub-list for field type_name
+}
+
+func init() { file_internal_testprotos_fieldtrack_fieldtrack_proto_init() }
+func file_internal_testprotos_fieldtrack_fieldtrack_proto_init() {
+	if File_internal_testprotos_fieldtrack_fieldtrack_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_internal_testprotos_fieldtrack_fieldtrack_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*TestFieldTrack); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.weakFields
+			case 3:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_internal_testprotos_fieldtrack_fieldtrack_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   18,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_internal_testprotos_fieldtrack_fieldtrack_proto_goTypes,
+		DependencyIndexes: file_internal_testprotos_fieldtrack_fieldtrack_proto_depIdxs,
+		MessageInfos:      file_internal_testprotos_fieldtrack_fieldtrack_proto_msgTypes,
+	}.Build()
+	File_internal_testprotos_fieldtrack_fieldtrack_proto = out.File
+	file_internal_testprotos_fieldtrack_fieldtrack_proto_rawDesc = nil
+	file_internal_testprotos_fieldtrack_fieldtrack_proto_goTypes = nil
+	file_internal_testprotos_fieldtrack_fieldtrack_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/fieldtrack/fieldtrack.proto b/vendor/google.golang.org/protobuf/internal/testprotos/fieldtrack/fieldtrack.proto
new file mode 100644
index 000000000..4e727e643
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/fieldtrack/fieldtrack.proto
@@ -0,0 +1,75 @@
+// 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.
+
+syntax = "proto2";
+
+package goproto.proto.test;
+
+import "internal/testprotos/annotation/annotation.proto";
+import "internal/testprotos/test/test.proto";
+import weak "internal/testprotos/test/weak1/test_weak.proto";
+import weak "internal/testprotos/test/weak2/test_weak.proto";
+
+option go_package = "google.golang.org/protobuf/internal/testprotos/fieldtrack";
+
+message TestFieldTrack {
+  option (go_annotation.track_field_use) = true;
+
+  optional int32    optional_int32    =  1;
+  optional int64    optional_int64    =  2;
+  optional uint32   optional_uint32   =  3;
+  optional uint64   optional_uint64   =  4;
+  optional sint32   optional_sint32   =  5;
+  optional sint64   optional_sint64   =  6;
+  optional fixed32  optional_fixed32  =  7;
+  optional fixed64  optional_fixed64  =  8;
+  optional sfixed32 optional_sfixed32 =  9;
+  optional sfixed64 optional_sfixed64 = 10;
+  optional float    optional_float    = 11;
+  optional double   optional_double   = 12;
+  optional bool     optional_bool     = 13;
+  optional string   optional_string   = 14;
+  optional bytes    optional_bytes    = 15;
+  optional goproto.proto.test.TestAllTypes.NestedEnum    optional_enum    = 16;
+  optional goproto.proto.test.TestAllTypes.NestedMessage optional_message = 17;
+
+  repeated int32    repeated_int32    = 21;
+  repeated int64    repeated_int64    = 22;
+  repeated uint32   repeated_uint32   = 23;
+  repeated uint64   repeated_uint64   = 24;
+  repeated sint32   repeated_sint32   = 25;
+  repeated sint64   repeated_sint64   = 26;
+  repeated fixed32  repeated_fixed32  = 27;
+  repeated fixed64  repeated_fixed64  = 28;
+  repeated sfixed32 repeated_sfixed32 = 29;
+  repeated sfixed64 repeated_sfixed64 = 30;
+  repeated float    repeated_float    = 31;
+  repeated double   repeated_double   = 32;
+  repeated bool     repeated_bool     = 33;
+  repeated string   repeated_string   = 34;
+  repeated bytes    repeated_bytes    = 35;
+  repeated goproto.proto.test.TestAllTypes.NestedEnum    repeated_enum    = 36;
+  repeated goproto.proto.test.TestAllTypes.NestedMessage repeated_message = 37;
+
+  map <string, int32>    map_string_int32    = 41;
+  map <string, int64>    map_string_int64    = 42;
+  map <string, uint32>   map_string_uint32   = 43;
+  map <string, uint64>   map_string_uint64   = 44;
+  map <string, sint32>   map_string_sint32   = 45;
+  map <string, sint64>   map_string_sint64   = 46;
+  map <string, fixed32>  map_string_fixed32  = 47;
+  map <string, fixed64>  map_string_fixed64  = 48;
+  map <string, sfixed32> map_string_sfixed32 = 49;
+  map <string, sfixed64> map_string_sfixed64 = 50;
+  map <string, float>    map_string_float    = 51;
+  map <string, double>   map_string_double   = 52;
+  map <string, bool>     map_string_bool     = 53;
+  map <string, string>   map_string_string   = 54;
+  map <string, bytes>    map_string_bytes    = 55;
+  map <string, goproto.proto.test.TestAllTypes.NestedEnum>    map_string_enum    = 56;
+  map <string, goproto.proto.test.TestAllTypes.NestedMessage> map_string_message = 57;
+
+  optional goproto.proto.test.weak.WeakImportMessage1 weak_message1 = 100 [weak=true];
+  optional goproto.proto.test.weak.WeakImportMessage2 weak_message2 = 101 [weak=true];
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/fuzz/fuzz.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/fuzz/fuzz.pb.go
new file mode 100644
index 000000000..e677f97f5
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/fuzz/fuzz.pb.go
@@ -0,0 +1,260 @@
+// Copyright 2019 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: internal/testprotos/fuzz/fuzz.proto
+
+package fuzz
+
+import (
+	test "google.golang.org/protobuf/internal/testprotos/test"
+	test3 "google.golang.org/protobuf/internal/testprotos/test3"
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+// Fuzz is a container for every message we want to make available to the fuzzer.
+type Fuzz struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	TestAllTypes            *test.TestAllTypes            `protobuf:"bytes,1,opt,name=test_all_types,json=testAllTypes" json:"test_all_types,omitempty"`
+	TestAllExtensions       *test.TestAllExtensions       `protobuf:"bytes,2,opt,name=test_all_extensions,json=testAllExtensions" json:"test_all_extensions,omitempty"`
+	TestRequired            *test.TestRequired            `protobuf:"bytes,3,opt,name=test_required,json=testRequired" json:"test_required,omitempty"`
+	TestRequiredForeign     *test.TestRequiredForeign     `protobuf:"bytes,4,opt,name=test_required_foreign,json=testRequiredForeign" json:"test_required_foreign,omitempty"`
+	TestRequiredGroupFields *test.TestRequiredGroupFields `protobuf:"bytes,5,opt,name=test_required_group_fields,json=testRequiredGroupFields" json:"test_required_group_fields,omitempty"`
+	TestPackedTypes         *test.TestPackedTypes         `protobuf:"bytes,6,opt,name=test_packed_types,json=testPackedTypes" json:"test_packed_types,omitempty"`
+	TestPackedExtensions    *test.TestPackedExtensions    `protobuf:"bytes,7,opt,name=test_packed_extensions,json=testPackedExtensions" json:"test_packed_extensions,omitempty"`
+	TestAllTypes3           *test3.TestAllTypes           `protobuf:"bytes,8,opt,name=test_all_types3,json=testAllTypes3" json:"test_all_types3,omitempty"`
+}
+
+func (x *Fuzz) Reset() {
+	*x = Fuzz{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_fuzz_fuzz_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Fuzz) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Fuzz) ProtoMessage() {}
+
+func (x *Fuzz) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_fuzz_fuzz_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Fuzz.ProtoReflect.Descriptor instead.
+func (*Fuzz) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_fuzz_fuzz_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Fuzz) GetTestAllTypes() *test.TestAllTypes {
+	if x != nil {
+		return x.TestAllTypes
+	}
+	return nil
+}
+
+func (x *Fuzz) GetTestAllExtensions() *test.TestAllExtensions {
+	if x != nil {
+		return x.TestAllExtensions
+	}
+	return nil
+}
+
+func (x *Fuzz) GetTestRequired() *test.TestRequired {
+	if x != nil {
+		return x.TestRequired
+	}
+	return nil
+}
+
+func (x *Fuzz) GetTestRequiredForeign() *test.TestRequiredForeign {
+	if x != nil {
+		return x.TestRequiredForeign
+	}
+	return nil
+}
+
+func (x *Fuzz) GetTestRequiredGroupFields() *test.TestRequiredGroupFields {
+	if x != nil {
+		return x.TestRequiredGroupFields
+	}
+	return nil
+}
+
+func (x *Fuzz) GetTestPackedTypes() *test.TestPackedTypes {
+	if x != nil {
+		return x.TestPackedTypes
+	}
+	return nil
+}
+
+func (x *Fuzz) GetTestPackedExtensions() *test.TestPackedExtensions {
+	if x != nil {
+		return x.TestPackedExtensions
+	}
+	return nil
+}
+
+func (x *Fuzz) GetTestAllTypes3() *test3.TestAllTypes {
+	if x != nil {
+		return x.TestAllTypes3
+	}
+	return nil
+}
+
+var File_internal_testprotos_fuzz_fuzz_proto protoreflect.FileDescriptor
+
+var file_internal_testprotos_fuzz_fuzz_proto_rawDesc = []byte{
+	0x0a, 0x23, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x66, 0x75, 0x7a, 0x7a, 0x2f, 0x66, 0x75, 0x7a, 0x7a, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x66, 0x75, 0x7a, 0x7a, 0x1a, 0x23, 0x69, 0x6e, 0x74, 0x65, 0x72,
+	0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x74,
+	0x65, 0x73, 0x74, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x24,
+	0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x22, 0xaf, 0x05, 0x0a, 0x04, 0x46, 0x75, 0x7a, 0x7a, 0x12, 0x46, 0x0a,
+	0x0e, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x6c, 0x6c, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41,
+	0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x52, 0x0c, 0x74, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c,
+	0x54, 0x79, 0x70, 0x65, 0x73, 0x12, 0x55, 0x0a, 0x13, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x6c,
+	0x6c, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45,
+	0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x11, 0x74, 0x65, 0x73, 0x74, 0x41,
+	0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x45, 0x0a, 0x0d,
+	0x74, 0x65, 0x73, 0x74, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x18, 0x03, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x52, 0x65, 0x71,
+	0x75, 0x69, 0x72, 0x65, 0x64, 0x52, 0x0c, 0x74, 0x65, 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x69,
+	0x72, 0x65, 0x64, 0x12, 0x5b, 0x0a, 0x15, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x72, 0x65, 0x71, 0x75,
+	0x69, 0x72, 0x65, 0x64, 0x5f, 0x66, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x18, 0x04, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x27, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x52, 0x65, 0x71, 0x75,
+	0x69, 0x72, 0x65, 0x64, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x52, 0x13, 0x74, 0x65, 0x73,
+	0x74, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e,
+	0x12, 0x68, 0x0a, 0x1a, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65,
+	0x64, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x18, 0x05,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x52, 0x65,
+	0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x46, 0x69, 0x65, 0x6c, 0x64,
+	0x73, 0x52, 0x17, 0x74, 0x65, 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x47,
+	0x72, 0x6f, 0x75, 0x70, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x12, 0x4f, 0x0a, 0x11, 0x74, 0x65,
+	0x73, 0x74, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x18,
+	0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x50,
+	0x61, 0x63, 0x6b, 0x65, 0x64, 0x54, 0x79, 0x70, 0x65, 0x73, 0x52, 0x0f, 0x74, 0x65, 0x73, 0x74,
+	0x50, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x54, 0x79, 0x70, 0x65, 0x73, 0x12, 0x5e, 0x0a, 0x16, 0x74,
+	0x65, 0x73, 0x74, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x6e,
+	0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x67, 0x6f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74,
+	0x2e, 0x54, 0x65, 0x73, 0x74, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x45, 0x78, 0x74, 0x65, 0x6e,
+	0x73, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x14, 0x74, 0x65, 0x73, 0x74, 0x50, 0x61, 0x63, 0x6b, 0x65,
+	0x64, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x49, 0x0a, 0x0f, 0x74,
+	0x65, 0x73, 0x74, 0x5f, 0x61, 0x6c, 0x6c, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x33, 0x18, 0x08,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41,
+	0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x52, 0x0d, 0x74, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c,
+	0x54, 0x79, 0x70, 0x65, 0x73, 0x33, 0x42, 0x35, 0x5a, 0x33, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x62, 0x75, 0x66, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65,
+	0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x66, 0x75, 0x7a, 0x7a,
+}
+
+var (
+	file_internal_testprotos_fuzz_fuzz_proto_rawDescOnce sync.Once
+	file_internal_testprotos_fuzz_fuzz_proto_rawDescData = file_internal_testprotos_fuzz_fuzz_proto_rawDesc
+)
+
+func file_internal_testprotos_fuzz_fuzz_proto_rawDescGZIP() []byte {
+	file_internal_testprotos_fuzz_fuzz_proto_rawDescOnce.Do(func() {
+		file_internal_testprotos_fuzz_fuzz_proto_rawDescData = protoimpl.X.CompressGZIP(file_internal_testprotos_fuzz_fuzz_proto_rawDescData)
+	})
+	return file_internal_testprotos_fuzz_fuzz_proto_rawDescData
+}
+
+var file_internal_testprotos_fuzz_fuzz_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_internal_testprotos_fuzz_fuzz_proto_goTypes = []interface{}{
+	(*Fuzz)(nil),                         // 0: goproto.proto.fuzz.Fuzz
+	(*test.TestAllTypes)(nil),            // 1: goproto.proto.test.TestAllTypes
+	(*test.TestAllExtensions)(nil),       // 2: goproto.proto.test.TestAllExtensions
+	(*test.TestRequired)(nil),            // 3: goproto.proto.test.TestRequired
+	(*test.TestRequiredForeign)(nil),     // 4: goproto.proto.test.TestRequiredForeign
+	(*test.TestRequiredGroupFields)(nil), // 5: goproto.proto.test.TestRequiredGroupFields
+	(*test.TestPackedTypes)(nil),         // 6: goproto.proto.test.TestPackedTypes
+	(*test.TestPackedExtensions)(nil),    // 7: goproto.proto.test.TestPackedExtensions
+	(*test3.TestAllTypes)(nil),           // 8: goproto.proto.test3.TestAllTypes
+}
+var file_internal_testprotos_fuzz_fuzz_proto_depIdxs = []int32{
+	1, // 0: goproto.proto.fuzz.Fuzz.test_all_types:type_name -> goproto.proto.test.TestAllTypes
+	2, // 1: goproto.proto.fuzz.Fuzz.test_all_extensions:type_name -> goproto.proto.test.TestAllExtensions
+	3, // 2: goproto.proto.fuzz.Fuzz.test_required:type_name -> goproto.proto.test.TestRequired
+	4, // 3: goproto.proto.fuzz.Fuzz.test_required_foreign:type_name -> goproto.proto.test.TestRequiredForeign
+	5, // 4: goproto.proto.fuzz.Fuzz.test_required_group_fields:type_name -> goproto.proto.test.TestRequiredGroupFields
+	6, // 5: goproto.proto.fuzz.Fuzz.test_packed_types:type_name -> goproto.proto.test.TestPackedTypes
+	7, // 6: goproto.proto.fuzz.Fuzz.test_packed_extensions:type_name -> goproto.proto.test.TestPackedExtensions
+	8, // 7: goproto.proto.fuzz.Fuzz.test_all_types3:type_name -> goproto.proto.test3.TestAllTypes
+	8, // [8:8] is the sub-list for method output_type
+	8, // [8:8] is the sub-list for method input_type
+	8, // [8:8] is the sub-list for extension type_name
+	8, // [8:8] is the sub-list for extension extendee
+	0, // [0:8] is the sub-list for field type_name
+}
+
+func init() { file_internal_testprotos_fuzz_fuzz_proto_init() }
+func file_internal_testprotos_fuzz_fuzz_proto_init() {
+	if File_internal_testprotos_fuzz_fuzz_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_internal_testprotos_fuzz_fuzz_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Fuzz); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_internal_testprotos_fuzz_fuzz_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_internal_testprotos_fuzz_fuzz_proto_goTypes,
+		DependencyIndexes: file_internal_testprotos_fuzz_fuzz_proto_depIdxs,
+		MessageInfos:      file_internal_testprotos_fuzz_fuzz_proto_msgTypes,
+	}.Build()
+	File_internal_testprotos_fuzz_fuzz_proto = out.File
+	file_internal_testprotos_fuzz_fuzz_proto_rawDesc = nil
+	file_internal_testprotos_fuzz_fuzz_proto_goTypes = nil
+	file_internal_testprotos_fuzz_fuzz_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/fuzz/fuzz.proto b/vendor/google.golang.org/protobuf/internal/testprotos/fuzz/fuzz.proto
new file mode 100644
index 000000000..3b3ffe1d8
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/fuzz/fuzz.proto
@@ -0,0 +1,24 @@
+// Copyright 2019 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.
+
+syntax = "proto2";
+
+package goproto.proto.fuzz;
+
+import "internal/testprotos/test/test.proto";
+import "internal/testprotos/test3/test.proto";
+
+option go_package = "google.golang.org/protobuf/internal/testprotos/fuzz";
+
+// Fuzz is a container for every message we want to make available to the fuzzer.
+message Fuzz {
+  optional goproto.proto.test.TestAllTypes test_all_types = 1;
+  optional goproto.proto.test.TestAllExtensions test_all_extensions = 2;
+  optional goproto.proto.test.TestRequired test_required = 3;
+  optional goproto.proto.test.TestRequiredForeign test_required_foreign = 4;
+  optional goproto.proto.test.TestRequiredGroupFields test_required_group_fields = 5;
+  optional goproto.proto.test.TestPackedTypes test_packed_types = 6;
+  optional goproto.proto.test.TestPackedExtensions test_packed_extensions = 7;
+  optional goproto.proto.test3.TestAllTypes test_all_types3 = 8;
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/irregular/irregular.go b/vendor/google.golang.org/protobuf/internal/testprotos/irregular/irregular.go
new file mode 100644
index 000000000..a663e87d4
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/irregular/irregular.go
@@ -0,0 +1,129 @@
+// Copyright 2019 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 irregular
+
+import (
+	"google.golang.org/protobuf/encoding/prototext"
+	"google.golang.org/protobuf/reflect/protodesc"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/runtime/protoiface"
+
+	"google.golang.org/protobuf/types/descriptorpb"
+)
+
+type IrregularMessage struct {
+	set   bool
+	value string
+}
+
+func (m *IrregularMessage) ProtoReflect() pref.Message { return (*message)(m) }
+
+type message IrregularMessage
+
+func (m *message) Descriptor() pref.MessageDescriptor { return fileDesc.Messages().Get(0) }
+func (m *message) Type() pref.MessageType             { return m }
+func (m *message) New() pref.Message                  { return &message{} }
+func (m *message) Zero() pref.Message                 { return (*message)(nil) }
+func (m *message) Interface() pref.ProtoMessage       { return (*IrregularMessage)(m) }
+func (m *message) ProtoMethods() *protoiface.Methods  { return nil }
+
+var fieldDescS = fileDesc.Messages().Get(0).Fields().Get(0)
+
+func (m *message) Range(f func(pref.FieldDescriptor, pref.Value) bool) {
+	if m.set {
+		f(fieldDescS, pref.ValueOf(m.value))
+	}
+}
+
+func (m *message) Has(fd pref.FieldDescriptor) bool {
+	if fd == fieldDescS {
+		return m.set
+	}
+	panic("invalid field descriptor")
+}
+
+func (m *message) Clear(fd pref.FieldDescriptor) {
+	if fd == fieldDescS {
+		m.value = ""
+		m.set = false
+		return
+	}
+	panic("invalid field descriptor")
+}
+
+func (m *message) Get(fd pref.FieldDescriptor) pref.Value {
+	if fd == fieldDescS {
+		return pref.ValueOf(m.value)
+	}
+	panic("invalid field descriptor")
+}
+
+func (m *message) Set(fd pref.FieldDescriptor, v pref.Value) {
+	if fd == fieldDescS {
+		m.value = v.String()
+		m.set = true
+		return
+	}
+	panic("invalid field descriptor")
+}
+
+func (m *message) Mutable(pref.FieldDescriptor) pref.Value {
+	panic("invalid field descriptor")
+}
+
+func (m *message) NewField(pref.FieldDescriptor) pref.Value {
+	panic("invalid field descriptor")
+}
+
+func (m *message) WhichOneof(pref.OneofDescriptor) pref.FieldDescriptor {
+	panic("invalid oneof descriptor")
+}
+
+func (m *message) GetUnknown() pref.RawFields { return nil }
+func (m *message) SetUnknown(pref.RawFields)  { return }
+
+func (m *message) IsValid() bool {
+	return m != nil
+}
+
+var fileDesc = func() pref.FileDescriptor {
+	p := &descriptorpb.FileDescriptorProto{}
+	if err := prototext.Unmarshal([]byte(descriptorText), p); err != nil {
+		panic(err)
+	}
+	file, err := protodesc.NewFile(p, nil)
+	if err != nil {
+		panic(err)
+	}
+	return file
+}()
+
+func file_internal_testprotos_irregular_irregular_proto_init() { _ = fileDesc }
+
+const descriptorText = `
+  name: "internal/testprotos/irregular/irregular.proto"
+  package: "goproto.proto.thirdparty"
+  message_type {
+    name: "IrregularMessage"
+    field {
+      name: "s"
+      number: 1
+      label: LABEL_OPTIONAL
+      type: TYPE_STRING
+      json_name: "s"
+    }
+  }
+  options {
+    go_package: "google.golang.org/protobuf/internal/testprotos/irregular"
+  }
+`
+
+type AberrantMessage int
+
+func (m AberrantMessage) ProtoMessage()            {}
+func (m AberrantMessage) Reset()                   {}
+func (m AberrantMessage) String() string           { return "" }
+func (m AberrantMessage) Marshal() ([]byte, error) { return nil, nil }
+func (m AberrantMessage) Unmarshal([]byte) error   { return nil }
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/irregular/irregular.proto b/vendor/google.golang.org/protobuf/internal/testprotos/irregular/irregular.proto
new file mode 100644
index 000000000..949316b0f
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/irregular/irregular.proto
@@ -0,0 +1,19 @@
+// Copyright 2019 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.
+
+syntax = "proto2";
+
+package goproto.proto.irregular;
+
+option go_package = "google.golang.org/protobuf/internal/testprotos/irregular";
+
+// IrregularMessage is a message with an implementation that does not match the
+// usual structure of a generated message.
+message IrregularMessage {
+  optional string s = 1;
+}
+
+// AberrantMessage is a message with an implementation with a non-struct underlying type.
+message AberrantMessage {
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/irregular/test.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/irregular/test.pb.go
new file mode 100644
index 000000000..6a323a45b
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/irregular/test.pb.go
@@ -0,0 +1,337 @@
+// Copyright 2019 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.
+
+// This file contains a message which references a message that implements the
+// proto.Message interface but does not have the structure of a normal generated
+// message.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: internal/testprotos/irregular/test.proto
+
+package irregular
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type Message struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	OptionalMessage *IrregularMessage            `protobuf:"bytes,1,opt,name=optional_message,json=optionalMessage" json:"optional_message,omitempty"`
+	RepeatedMessage []*IrregularMessage          `protobuf:"bytes,2,rep,name=repeated_message,json=repeatedMessage" json:"repeated_message,omitempty"`
+	RequiredMessage *IrregularMessage            `protobuf:"bytes,3,req,name=required_message,json=requiredMessage" json:"required_message,omitempty"`
+	MapMessage      map[string]*IrregularMessage `protobuf:"bytes,4,rep,name=map_message,json=mapMessage" json:"map_message,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+	// Types that are assignable to Union:
+	//	*Message_OneofMessage
+	//	*Message_OneofAberrantMessage
+	Union                   isMessage_Union             `protobuf_oneof:"union"`
+	OptionalAberrantMessage *AberrantMessage            `protobuf:"bytes,7,opt,name=optional_aberrant_message,json=optionalAberrantMessage" json:"optional_aberrant_message,omitempty"`
+	RepeatedAberrantMessage []*AberrantMessage          `protobuf:"bytes,8,rep,name=repeated_aberrant_message,json=repeatedAberrantMessage" json:"repeated_aberrant_message,omitempty"`
+	RequiredAberrantMessage *AberrantMessage            `protobuf:"bytes,9,req,name=required_aberrant_message,json=requiredAberrantMessage" json:"required_aberrant_message,omitempty"`
+	MapAberrantMessage      map[string]*AberrantMessage `protobuf:"bytes,10,rep,name=map_aberrant_message,json=mapAberrantMessage" json:"map_aberrant_message,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+}
+
+func (x *Message) Reset() {
+	*x = Message{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_irregular_test_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message) ProtoMessage() {}
+
+func (x *Message) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_irregular_test_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message.ProtoReflect.Descriptor instead.
+func (*Message) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_irregular_test_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Message) GetOptionalMessage() *IrregularMessage {
+	if x != nil {
+		return x.OptionalMessage
+	}
+	return nil
+}
+
+func (x *Message) GetRepeatedMessage() []*IrregularMessage {
+	if x != nil {
+		return x.RepeatedMessage
+	}
+	return nil
+}
+
+func (x *Message) GetRequiredMessage() *IrregularMessage {
+	if x != nil {
+		return x.RequiredMessage
+	}
+	return nil
+}
+
+func (x *Message) GetMapMessage() map[string]*IrregularMessage {
+	if x != nil {
+		return x.MapMessage
+	}
+	return nil
+}
+
+func (m *Message) GetUnion() isMessage_Union {
+	if m != nil {
+		return m.Union
+	}
+	return nil
+}
+
+func (x *Message) GetOneofMessage() *IrregularMessage {
+	if x, ok := x.GetUnion().(*Message_OneofMessage); ok {
+		return x.OneofMessage
+	}
+	return nil
+}
+
+func (x *Message) GetOneofAberrantMessage() *AberrantMessage {
+	if x, ok := x.GetUnion().(*Message_OneofAberrantMessage); ok {
+		return x.OneofAberrantMessage
+	}
+	return nil
+}
+
+func (x *Message) GetOptionalAberrantMessage() *AberrantMessage {
+	if x != nil {
+		return x.OptionalAberrantMessage
+	}
+	return nil
+}
+
+func (x *Message) GetRepeatedAberrantMessage() []*AberrantMessage {
+	if x != nil {
+		return x.RepeatedAberrantMessage
+	}
+	return nil
+}
+
+func (x *Message) GetRequiredAberrantMessage() *AberrantMessage {
+	if x != nil {
+		return x.RequiredAberrantMessage
+	}
+	return nil
+}
+
+func (x *Message) GetMapAberrantMessage() map[string]*AberrantMessage {
+	if x != nil {
+		return x.MapAberrantMessage
+	}
+	return nil
+}
+
+type isMessage_Union interface {
+	isMessage_Union()
+}
+
+type Message_OneofMessage struct {
+	OneofMessage *IrregularMessage `protobuf:"bytes,5,opt,name=oneof_message,json=oneofMessage,oneof"`
+}
+
+type Message_OneofAberrantMessage struct {
+	OneofAberrantMessage *AberrantMessage `protobuf:"bytes,6,opt,name=oneof_aberrant_message,json=oneofAberrantMessage,oneof"`
+}
+
+func (*Message_OneofMessage) isMessage_Union() {}
+
+func (*Message_OneofAberrantMessage) isMessage_Union() {}
+
+var File_internal_testprotos_irregular_test_proto protoreflect.FileDescriptor
+
+var file_internal_testprotos_irregular_test_proto_rawDesc = []byte{
+	0x0a, 0x28, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x69, 0x72, 0x72, 0x65, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x2f,
+	0x74, 0x65, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x17, 0x67, 0x6f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x72, 0x72, 0x65, 0x67, 0x75,
+	0x6c, 0x61, 0x72, 0x1a, 0x2d, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65,
+	0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x69, 0x72, 0x72, 0x65, 0x67, 0x75, 0x6c,
+	0x61, 0x72, 0x2f, 0x69, 0x72, 0x72, 0x65, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x22, 0x94, 0x09, 0x0a, 0x07, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x54,
+	0x0a, 0x10, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x72, 0x72, 0x65, 0x67, 0x75, 0x6c,
+	0x61, 0x72, 0x2e, 0x49, 0x72, 0x72, 0x65, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x52, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x12, 0x54, 0x0a, 0x10, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
+	0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x29,
+	0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69,
+	0x72, 0x72, 0x65, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x2e, 0x49, 0x72, 0x72, 0x65, 0x67, 0x75, 0x6c,
+	0x61, 0x72, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61,
+	0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x54, 0x0a, 0x10, 0x72, 0x65,
+	0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x03,
+	0x20, 0x02, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x72, 0x72, 0x65, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x2e, 0x49,
+	0x72, 0x72, 0x65, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x0f, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x12, 0x51, 0x0a, 0x0b, 0x6d, 0x61, 0x70, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18,
+	0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x30, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x72, 0x72, 0x65, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x4d, 0x61, 0x70, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0a, 0x6d, 0x61, 0x70, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x12, 0x50, 0x0a, 0x0d, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x67, 0x6f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x72, 0x72, 0x65, 0x67,
+	0x75, 0x6c, 0x61, 0x72, 0x2e, 0x49, 0x72, 0x72, 0x65, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x48, 0x00, 0x52, 0x0c, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x60, 0x0a, 0x16, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x61,
+	0x62, 0x65, 0x72, 0x72, 0x61, 0x6e, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18,
+	0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x72, 0x72, 0x65, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x2e,
+	0x41, 0x62, 0x65, 0x72, 0x72, 0x61, 0x6e, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x48,
+	0x00, 0x52, 0x14, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x41, 0x62, 0x65, 0x72, 0x72, 0x61, 0x6e, 0x74,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x64, 0x0a, 0x19, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x5f, 0x61, 0x62, 0x65, 0x72, 0x72, 0x61, 0x6e, 0x74, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x67, 0x6f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x72, 0x72, 0x65, 0x67,
+	0x75, 0x6c, 0x61, 0x72, 0x2e, 0x41, 0x62, 0x65, 0x72, 0x72, 0x61, 0x6e, 0x74, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x52, 0x17, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x41, 0x62,
+	0x65, 0x72, 0x72, 0x61, 0x6e, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x64, 0x0a,
+	0x19, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x62, 0x65, 0x72, 0x72, 0x61,
+	0x6e, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x28, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x69, 0x72, 0x72, 0x65, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x2e, 0x41, 0x62, 0x65, 0x72, 0x72,
+	0x61, 0x6e, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x17, 0x72, 0x65, 0x70, 0x65,
+	0x61, 0x74, 0x65, 0x64, 0x41, 0x62, 0x65, 0x72, 0x72, 0x61, 0x6e, 0x74, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x12, 0x64, 0x0a, 0x19, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x5f,
+	0x61, 0x62, 0x65, 0x72, 0x72, 0x61, 0x6e, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x18, 0x09, 0x20, 0x02, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x72, 0x72, 0x65, 0x67, 0x75, 0x6c, 0x61, 0x72,
+	0x2e, 0x41, 0x62, 0x65, 0x72, 0x72, 0x61, 0x6e, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x52, 0x17, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x41, 0x62, 0x65, 0x72, 0x72, 0x61,
+	0x6e, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x6a, 0x0a, 0x14, 0x6d, 0x61, 0x70,
+	0x5f, 0x61, 0x62, 0x65, 0x72, 0x72, 0x61, 0x6e, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x38, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x72, 0x72, 0x65, 0x67, 0x75, 0x6c, 0x61,
+	0x72, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x4d, 0x61, 0x70, 0x41, 0x62, 0x65,
+	0x72, 0x72, 0x61, 0x6e, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x45, 0x6e, 0x74, 0x72,
+	0x79, 0x52, 0x12, 0x6d, 0x61, 0x70, 0x41, 0x62, 0x65, 0x72, 0x72, 0x61, 0x6e, 0x74, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x1a, 0x68, 0x0a, 0x0f, 0x4d, 0x61, 0x70, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x3f, 0x0a, 0x05, 0x76, 0x61,
+	0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x67, 0x6f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x72, 0x72, 0x65, 0x67, 0x75,
+	0x6c, 0x61, 0x72, 0x2e, 0x49, 0x72, 0x72, 0x65, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a,
+	0x6f, 0x0a, 0x17, 0x4d, 0x61, 0x70, 0x41, 0x62, 0x65, 0x72, 0x72, 0x61, 0x6e, 0x74, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65,
+	0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x3e, 0x0a, 0x05,
+	0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x67, 0x6f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x72, 0x72, 0x65,
+	0x67, 0x75, 0x6c, 0x61, 0x72, 0x2e, 0x41, 0x62, 0x65, 0x72, 0x72, 0x61, 0x6e, 0x74, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01,
+	0x42, 0x07, 0x0a, 0x05, 0x75, 0x6e, 0x69, 0x6f, 0x6e, 0x42, 0x3a, 0x5a, 0x38, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c,
+	0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x69, 0x72, 0x72, 0x65,
+	0x67, 0x75, 0x6c, 0x61, 0x72,
+}
+
+var (
+	file_internal_testprotos_irregular_test_proto_rawDescOnce sync.Once
+	file_internal_testprotos_irregular_test_proto_rawDescData = file_internal_testprotos_irregular_test_proto_rawDesc
+)
+
+func file_internal_testprotos_irregular_test_proto_rawDescGZIP() []byte {
+	file_internal_testprotos_irregular_test_proto_rawDescOnce.Do(func() {
+		file_internal_testprotos_irregular_test_proto_rawDescData = protoimpl.X.CompressGZIP(file_internal_testprotos_irregular_test_proto_rawDescData)
+	})
+	return file_internal_testprotos_irregular_test_proto_rawDescData
+}
+
+var file_internal_testprotos_irregular_test_proto_msgTypes = make([]protoimpl.MessageInfo, 3)
+var file_internal_testprotos_irregular_test_proto_goTypes = []interface{}{
+	(*Message)(nil),          // 0: goproto.proto.irregular.Message
+	nil,                      // 1: goproto.proto.irregular.Message.MapMessageEntry
+	nil,                      // 2: goproto.proto.irregular.Message.MapAberrantMessageEntry
+	(*IrregularMessage)(nil), // 3: goproto.proto.irregular.IrregularMessage
+	(*AberrantMessage)(nil),  // 4: goproto.proto.irregular.AberrantMessage
+}
+var file_internal_testprotos_irregular_test_proto_depIdxs = []int32{
+	3,  // 0: goproto.proto.irregular.Message.optional_message:type_name -> goproto.proto.irregular.IrregularMessage
+	3,  // 1: goproto.proto.irregular.Message.repeated_message:type_name -> goproto.proto.irregular.IrregularMessage
+	3,  // 2: goproto.proto.irregular.Message.required_message:type_name -> goproto.proto.irregular.IrregularMessage
+	1,  // 3: goproto.proto.irregular.Message.map_message:type_name -> goproto.proto.irregular.Message.MapMessageEntry
+	3,  // 4: goproto.proto.irregular.Message.oneof_message:type_name -> goproto.proto.irregular.IrregularMessage
+	4,  // 5: goproto.proto.irregular.Message.oneof_aberrant_message:type_name -> goproto.proto.irregular.AberrantMessage
+	4,  // 6: goproto.proto.irregular.Message.optional_aberrant_message:type_name -> goproto.proto.irregular.AberrantMessage
+	4,  // 7: goproto.proto.irregular.Message.repeated_aberrant_message:type_name -> goproto.proto.irregular.AberrantMessage
+	4,  // 8: goproto.proto.irregular.Message.required_aberrant_message:type_name -> goproto.proto.irregular.AberrantMessage
+	2,  // 9: goproto.proto.irregular.Message.map_aberrant_message:type_name -> goproto.proto.irregular.Message.MapAberrantMessageEntry
+	3,  // 10: goproto.proto.irregular.Message.MapMessageEntry.value:type_name -> goproto.proto.irregular.IrregularMessage
+	4,  // 11: goproto.proto.irregular.Message.MapAberrantMessageEntry.value:type_name -> goproto.proto.irregular.AberrantMessage
+	12, // [12:12] is the sub-list for method output_type
+	12, // [12:12] is the sub-list for method input_type
+	12, // [12:12] is the sub-list for extension type_name
+	12, // [12:12] is the sub-list for extension extendee
+	0,  // [0:12] is the sub-list for field type_name
+}
+
+func init() { file_internal_testprotos_irregular_test_proto_init() }
+func file_internal_testprotos_irregular_test_proto_init() {
+	if File_internal_testprotos_irregular_test_proto != nil {
+		return
+	}
+	file_internal_testprotos_irregular_irregular_proto_init()
+	if !protoimpl.UnsafeEnabled {
+		file_internal_testprotos_irregular_test_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	file_internal_testprotos_irregular_test_proto_msgTypes[0].OneofWrappers = []interface{}{
+		(*Message_OneofMessage)(nil),
+		(*Message_OneofAberrantMessage)(nil),
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_internal_testprotos_irregular_test_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   3,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_internal_testprotos_irregular_test_proto_goTypes,
+		DependencyIndexes: file_internal_testprotos_irregular_test_proto_depIdxs,
+		MessageInfos:      file_internal_testprotos_irregular_test_proto_msgTypes,
+	}.Build()
+	File_internal_testprotos_irregular_test_proto = out.File
+	file_internal_testprotos_irregular_test_proto_rawDesc = nil
+	file_internal_testprotos_irregular_test_proto_goTypes = nil
+	file_internal_testprotos_irregular_test_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/irregular/test.proto b/vendor/google.golang.org/protobuf/internal/testprotos/irregular/test.proto
new file mode 100644
index 000000000..b128f7e63
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/irregular/test.proto
@@ -0,0 +1,31 @@
+// Copyright 2019 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.
+
+// This file contains a message which references a message that implements the
+// proto.Message interface but does not have the structure of a normal generated
+// message.
+
+syntax = "proto2";
+
+package goproto.proto.irregular;
+
+import "internal/testprotos/irregular/irregular.proto";
+
+option go_package = "google.golang.org/protobuf/internal/testprotos/irregular";
+
+message Message {
+  optional IrregularMessage optional_message = 1;
+  repeated IrregularMessage repeated_message = 2;
+  required IrregularMessage required_message = 3;
+  map<string,IrregularMessage> map_message = 4;
+  oneof union {
+    IrregularMessage oneof_message = 5;
+    AberrantMessage oneof_aberrant_message = 6;
+  }
+
+  optional AberrantMessage optional_aberrant_message = 7;
+  repeated AberrantMessage repeated_aberrant_message = 8;
+  required AberrantMessage required_aberrant_message = 9;
+  map<string,AberrantMessage> map_aberrant_message = 10;
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/legacy/bug1052/bug1052.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/bug1052/bug1052.pb.go
new file mode 100644
index 000000000..8906a8c17
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/bug1052/bug1052.pb.go
@@ -0,0 +1,99 @@
+// Copyright 2020 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: internal/testprotos/legacy/bug1052/bug1052.proto
+
+package bug1052
+
+import (
+	fmt "fmt"
+	math "math"
+
+	proto "google.golang.org/protobuf/internal/protolegacy"
+	descriptor "google.golang.org/protobuf/types/descriptorpb"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
+
+type Enum int32
+
+const (
+	Enum_ZERO Enum = 0
+)
+
+var Enum_name = map[int32]string{
+	0: "ZERO",
+}
+
+var Enum_value = map[string]int32{
+	"ZERO": 0,
+}
+
+func (x Enum) Enum() *Enum {
+	p := new(Enum)
+	*p = x
+	return p
+}
+
+func (x Enum) String() string {
+	return proto.EnumName(Enum_name, int32(x))
+}
+
+func (x *Enum) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(Enum_value, data, "Enum")
+	if err != nil {
+		return err
+	}
+	*x = Enum(value)
+	return nil
+}
+
+func (Enum) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_2d34d4f47c51af27, []int{0}
+}
+
+var E_ExtensionEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*descriptor.MethodOptions)(nil),
+	ExtensionType: (*Enum)(nil),
+	Field:         5000,
+	Name:          "goproto.proto.legacy.extension_enum",
+	Tag:           "varint,5000,opt,name=extension_enum,enum=goproto.proto.legacy.Enum",
+	Filename:      "internal/testprotos/legacy/bug1052/bug1052.proto",
+}
+
+func init() {
+	proto.RegisterEnum("goproto.proto.legacy.Enum", Enum_name, Enum_value)
+	proto.RegisterExtension(E_ExtensionEnum)
+}
+
+func init() {
+	proto.RegisterFile("internal/testprotos/legacy/bug1052/bug1052.proto", fileDescriptor_2d34d4f47c51af27)
+}
+
+var fileDescriptor_2d34d4f47c51af27 = []byte{
+	// 200 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x32, 0xc8, 0xcc, 0x2b, 0x49,
+	0x2d, 0xca, 0x4b, 0xcc, 0xd1, 0x2f, 0x49, 0x2d, 0x2e, 0x29, 0x28, 0xca, 0x2f, 0xc9, 0x2f, 0xd6,
+	0xcf, 0x49, 0x4d, 0x4f, 0x4c, 0xae, 0xd4, 0x4f, 0x2a, 0x4d, 0x37, 0x34, 0x30, 0x35, 0x82, 0xd1,
+	0x7a, 0x60, 0x59, 0x21, 0x91, 0xf4, 0x7c, 0x30, 0x03, 0xc2, 0xd5, 0x83, 0xa8, 0x95, 0x52, 0x48,
+	0xcf, 0xcf, 0x4f, 0xcf, 0x49, 0xd5, 0x07, 0x0b, 0x26, 0x95, 0xa6, 0xe9, 0xa7, 0xa4, 0x16, 0x27,
+	0x17, 0x65, 0x16, 0x94, 0xe4, 0x17, 0x41, 0x14, 0x6a, 0x09, 0x70, 0xb1, 0xb8, 0xe6, 0x95, 0xe6,
+	0x0a, 0x71, 0x70, 0xb1, 0x44, 0xb9, 0x06, 0xf9, 0x0b, 0x30, 0x58, 0x25, 0x71, 0xf1, 0xa5, 0x56,
+	0x94, 0xa4, 0xe6, 0x15, 0x67, 0xe6, 0xe7, 0xc5, 0xa7, 0x82, 0xe4, 0xe4, 0xf4, 0x20, 0xc6, 0xe8,
+	0xc1, 0x8c, 0xd1, 0xf3, 0x4d, 0x2d, 0xc9, 0xc8, 0x4f, 0xf1, 0x2f, 0x28, 0xc9, 0xcc, 0xcf, 0x2b,
+	0x96, 0xe8, 0x50, 0x57, 0x60, 0xd4, 0xe0, 0x33, 0x92, 0xd2, 0xc3, 0xe6, 0x06, 0x3d, 0x90, 0xf1,
+	0x41, 0xbc, 0x70, 0x23, 0x41, 0x5c, 0x27, 0xfb, 0x28, 0x5b, 0xa8, 0x91, 0xe9, 0xf9, 0x39, 0x89,
+	0x79, 0xe9, 0x7a, 0xf9, 0x45, 0xe9, 0x08, 0x47, 0x12, 0xf6, 0x3c, 0x20, 0x00, 0x00, 0xff, 0xff,
+	0x1d, 0x9e, 0x09, 0x6e, 0x21, 0x01, 0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/legacy/bug1052/bug1052.proto b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/bug1052/bug1052.proto
new file mode 100644
index 000000000..adcb118a3
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/bug1052/bug1052.proto
@@ -0,0 +1,26 @@
+// Copyright 2020 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.
+
+// This file exercises a deadlock in registation of legacy extensions:
+// https://github.com/golang/protobuf/issues/1052
+//
+// The corresponding .pb.go file was generated with protoc 3.11.3 and
+// protoc-gen-go 1.3.3.
+
+syntax = "proto2";
+
+package goproto.proto.legacy;
+
+import "google/protobuf/descriptor.proto";
+
+option go_package = "google.golang.org/protobuf/internal/testprotos/legacy/bug1052";
+
+enum Enum {
+  ZERO = 0;
+}
+
+extend google.protobuf.MethodOptions {
+  optional Enum extension_enum = 5000;
+}
+
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/legacy/bug1052/bug1052_test.go b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/bug1052/bug1052_test.go
new file mode 100644
index 000000000..eb0881c8b
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/bug1052/bug1052_test.go
@@ -0,0 +1,9 @@
+// Copyright 2020 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 bug1052_test
+
+import (
+	_ "google.golang.org/protobuf/internal/testprotos/legacy/bug1052"
+)
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/legacy/legacy.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/legacy.pb.go
new file mode 100644
index 000000000..d486d3b7c
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/legacy.pb.go
@@ -0,0 +1,356 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: internal/testprotos/legacy/legacy.proto
+
+package legacy
+
+import (
+	proto2_20160225_2fc053c5 "google.golang.org/protobuf/internal/testprotos/legacy/proto2_20160225_2fc053c5"
+	proto2_20160519_a4ab9ec5 "google.golang.org/protobuf/internal/testprotos/legacy/proto2_20160519_a4ab9ec5"
+	proto2_20180125_92554152 "google.golang.org/protobuf/internal/testprotos/legacy/proto2_20180125_92554152"
+	proto2_20180430_b4deda09 "google.golang.org/protobuf/internal/testprotos/legacy/proto2_20180430_b4deda09"
+	proto2_20180814_aa810b61 "google.golang.org/protobuf/internal/testprotos/legacy/proto2_20180814_aa810b61"
+	proto2_20190205_c823c79e "google.golang.org/protobuf/internal/testprotos/legacy/proto2_20190205_c823c79e"
+	proto3_20160225_2fc053c5 "google.golang.org/protobuf/internal/testprotos/legacy/proto3_20160225_2fc053c5"
+	proto3_20160519_a4ab9ec5 "google.golang.org/protobuf/internal/testprotos/legacy/proto3_20160519_a4ab9ec5"
+	proto3_20180125_92554152 "google.golang.org/protobuf/internal/testprotos/legacy/proto3_20180125_92554152"
+	proto3_20180430_b4deda09 "google.golang.org/protobuf/internal/testprotos/legacy/proto3_20180430_b4deda09"
+	proto3_20180814_aa810b61 "google.golang.org/protobuf/internal/testprotos/legacy/proto3_20180814_aa810b61"
+	proto3_20190205_c823c79e "google.golang.org/protobuf/internal/testprotos/legacy/proto3_20190205_c823c79e"
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type Legacy struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	F1  *proto2_20160225_2fc053c5.Message `protobuf:"bytes,1,opt,name=f1,proto3" json:"f1,omitempty"`
+	F2  *proto3_20160225_2fc053c5.Message `protobuf:"bytes,2,opt,name=f2,proto3" json:"f2,omitempty"`
+	F3  *proto2_20160519_a4ab9ec5.Message `protobuf:"bytes,3,opt,name=f3,proto3" json:"f3,omitempty"`
+	F4  *proto3_20160519_a4ab9ec5.Message `protobuf:"bytes,4,opt,name=f4,proto3" json:"f4,omitempty"`
+	F5  *proto2_20180125_92554152.Message `protobuf:"bytes,5,opt,name=f5,proto3" json:"f5,omitempty"`
+	F6  *proto3_20180125_92554152.Message `protobuf:"bytes,6,opt,name=f6,proto3" json:"f6,omitempty"`
+	F7  *proto2_20180430_b4deda09.Message `protobuf:"bytes,7,opt,name=f7,proto3" json:"f7,omitempty"`
+	F8  *proto3_20180430_b4deda09.Message `protobuf:"bytes,8,opt,name=f8,proto3" json:"f8,omitempty"`
+	F9  *proto2_20180814_aa810b61.Message `protobuf:"bytes,9,opt,name=f9,proto3" json:"f9,omitempty"`
+	F10 *proto3_20180814_aa810b61.Message `protobuf:"bytes,10,opt,name=f10,proto3" json:"f10,omitempty"`
+	F11 *proto2_20190205_c823c79e.Message `protobuf:"bytes,11,opt,name=f11,proto3" json:"f11,omitempty"`
+	F12 *proto3_20190205_c823c79e.Message `protobuf:"bytes,12,opt,name=f12,proto3" json:"f12,omitempty"`
+}
+
+func (x *Legacy) Reset() {
+	*x = Legacy{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_legacy_legacy_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Legacy) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Legacy) ProtoMessage() {}
+
+func (x *Legacy) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_legacy_legacy_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Legacy.ProtoReflect.Descriptor instead.
+func (*Legacy) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_legacy_legacy_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Legacy) GetF1() *proto2_20160225_2fc053c5.Message {
+	if x != nil {
+		return x.F1
+	}
+	return nil
+}
+
+func (x *Legacy) GetF2() *proto3_20160225_2fc053c5.Message {
+	if x != nil {
+		return x.F2
+	}
+	return nil
+}
+
+func (x *Legacy) GetF3() *proto2_20160519_a4ab9ec5.Message {
+	if x != nil {
+		return x.F3
+	}
+	return nil
+}
+
+func (x *Legacy) GetF4() *proto3_20160519_a4ab9ec5.Message {
+	if x != nil {
+		return x.F4
+	}
+	return nil
+}
+
+func (x *Legacy) GetF5() *proto2_20180125_92554152.Message {
+	if x != nil {
+		return x.F5
+	}
+	return nil
+}
+
+func (x *Legacy) GetF6() *proto3_20180125_92554152.Message {
+	if x != nil {
+		return x.F6
+	}
+	return nil
+}
+
+func (x *Legacy) GetF7() *proto2_20180430_b4deda09.Message {
+	if x != nil {
+		return x.F7
+	}
+	return nil
+}
+
+func (x *Legacy) GetF8() *proto3_20180430_b4deda09.Message {
+	if x != nil {
+		return x.F8
+	}
+	return nil
+}
+
+func (x *Legacy) GetF9() *proto2_20180814_aa810b61.Message {
+	if x != nil {
+		return x.F9
+	}
+	return nil
+}
+
+func (x *Legacy) GetF10() *proto3_20180814_aa810b61.Message {
+	if x != nil {
+		return x.F10
+	}
+	return nil
+}
+
+func (x *Legacy) GetF11() *proto2_20190205_c823c79e.Message {
+	if x != nil {
+		return x.F11
+	}
+	return nil
+}
+
+func (x *Legacy) GetF12() *proto3_20190205_c823c79e.Message {
+	if x != nil {
+		return x.F12
+	}
+	return nil
+}
+
+var File_internal_testprotos_legacy_legacy_proto protoreflect.FileDescriptor
+
+var file_internal_testprotos_legacy_legacy_proto_rawDesc = []byte{
+	0x0a, 0x27, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x6c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x2f, 0x6c, 0x65, 0x67,
+	0x61, 0x63, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x11, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x1a, 0x3e, 0x69, 0x6e,
+	0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x73, 0x2f, 0x6c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x5f,
+	0x32, 0x30, 0x31, 0x36, 0x30, 0x32, 0x32, 0x35, 0x5f, 0x32, 0x66, 0x63, 0x30, 0x35, 0x33, 0x63,
+	0x35, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x3e, 0x69, 0x6e,
+	0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x73, 0x2f, 0x6c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x5f,
+	0x32, 0x30, 0x31, 0x36, 0x30, 0x32, 0x32, 0x35, 0x5f, 0x32, 0x66, 0x63, 0x30, 0x35, 0x33, 0x63,
+	0x35, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x3e, 0x69, 0x6e,
+	0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x73, 0x2f, 0x6c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x5f,
+	0x32, 0x30, 0x31, 0x36, 0x30, 0x35, 0x31, 0x39, 0x5f, 0x61, 0x34, 0x61, 0x62, 0x39, 0x65, 0x63,
+	0x35, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x3e, 0x69, 0x6e,
+	0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x73, 0x2f, 0x6c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x5f,
+	0x32, 0x30, 0x31, 0x36, 0x30, 0x35, 0x31, 0x39, 0x5f, 0x61, 0x34, 0x61, 0x62, 0x39, 0x65, 0x63,
+	0x35, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x3e, 0x69, 0x6e,
+	0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x73, 0x2f, 0x6c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x5f,
+	0x32, 0x30, 0x31, 0x38, 0x30, 0x31, 0x32, 0x35, 0x5f, 0x39, 0x32, 0x35, 0x35, 0x34, 0x31, 0x35,
+	0x32, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x3e, 0x69, 0x6e,
+	0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x73, 0x2f, 0x6c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x5f,
+	0x32, 0x30, 0x31, 0x38, 0x30, 0x31, 0x32, 0x35, 0x5f, 0x39, 0x32, 0x35, 0x35, 0x34, 0x31, 0x35,
+	0x32, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x3e, 0x69, 0x6e,
+	0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x73, 0x2f, 0x6c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x5f,
+	0x32, 0x30, 0x31, 0x38, 0x30, 0x34, 0x33, 0x30, 0x5f, 0x62, 0x34, 0x64, 0x65, 0x64, 0x61, 0x30,
+	0x39, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x3e, 0x69, 0x6e,
+	0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x73, 0x2f, 0x6c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x5f,
+	0x32, 0x30, 0x31, 0x38, 0x30, 0x34, 0x33, 0x30, 0x5f, 0x62, 0x34, 0x64, 0x65, 0x64, 0x61, 0x30,
+	0x39, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x3e, 0x69, 0x6e,
+	0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x73, 0x2f, 0x6c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x5f,
+	0x32, 0x30, 0x31, 0x38, 0x30, 0x38, 0x31, 0x34, 0x5f, 0x61, 0x61, 0x38, 0x31, 0x30, 0x62, 0x36,
+	0x31, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x3e, 0x69, 0x6e,
+	0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x73, 0x2f, 0x6c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x5f,
+	0x32, 0x30, 0x31, 0x38, 0x30, 0x38, 0x31, 0x34, 0x5f, 0x61, 0x61, 0x38, 0x31, 0x30, 0x62, 0x36,
+	0x31, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x3e, 0x69, 0x6e,
+	0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x73, 0x2f, 0x6c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x5f,
+	0x32, 0x30, 0x31, 0x39, 0x30, 0x32, 0x30, 0x35, 0x5f, 0x63, 0x38, 0x32, 0x33, 0x63, 0x37, 0x39,
+	0x65, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x3e, 0x69, 0x6e,
+	0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x73, 0x2f, 0x6c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x5f,
+	0x32, 0x30, 0x31, 0x39, 0x30, 0x32, 0x30, 0x35, 0x5f, 0x63, 0x38, 0x32, 0x33, 0x63, 0x37, 0x39,
+	0x65, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xde, 0x05, 0x0a,
+	0x06, 0x4c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x12, 0x3a, 0x0a, 0x02, 0x66, 0x31, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c,
+	0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x5f, 0x32,
+	0x30, 0x31, 0x36, 0x30, 0x32, 0x32, 0x35, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x02, 0x66, 0x31, 0x12, 0x3a, 0x0a, 0x02, 0x66, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e,
+	0x6f, 0x72, 0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x5f, 0x32, 0x30, 0x31, 0x36, 0x30,
+	0x32, 0x32, 0x35, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x02, 0x66, 0x32, 0x12,
+	0x3a, 0x0a, 0x02, 0x66, 0x33, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x5f, 0x32, 0x30, 0x31, 0x36, 0x30, 0x35, 0x31, 0x39, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x02, 0x66, 0x33, 0x12, 0x3a, 0x0a, 0x02, 0x66,
+	0x34, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x33, 0x5f, 0x32, 0x30, 0x31, 0x36, 0x30, 0x35, 0x31, 0x39, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x52, 0x02, 0x66, 0x34, 0x12, 0x3a, 0x0a, 0x02, 0x66, 0x35, 0x18, 0x05, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c,
+	0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x5f, 0x32,
+	0x30, 0x31, 0x38, 0x30, 0x31, 0x32, 0x35, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x02, 0x66, 0x35, 0x12, 0x3a, 0x0a, 0x02, 0x66, 0x36, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e,
+	0x6f, 0x72, 0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x5f, 0x32, 0x30, 0x31, 0x38, 0x30,
+	0x31, 0x32, 0x35, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x02, 0x66, 0x36, 0x12,
+	0x3a, 0x0a, 0x02, 0x66, 0x37, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x5f, 0x32, 0x30, 0x31, 0x38, 0x30, 0x34, 0x33, 0x30, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x02, 0x66, 0x37, 0x12, 0x3a, 0x0a, 0x02, 0x66,
+	0x38, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x33, 0x5f, 0x32, 0x30, 0x31, 0x38, 0x30, 0x34, 0x33, 0x30, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x52, 0x02, 0x66, 0x38, 0x12, 0x3a, 0x0a, 0x02, 0x66, 0x39, 0x18, 0x09, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c,
+	0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x5f, 0x32,
+	0x30, 0x31, 0x38, 0x30, 0x38, 0x31, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x02, 0x66, 0x39, 0x12, 0x3c, 0x0a, 0x03, 0x66, 0x31, 0x30, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x2a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67,
+	0x2e, 0x6f, 0x72, 0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x5f, 0x32, 0x30, 0x31, 0x38,
+	0x30, 0x38, 0x31, 0x34, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x03, 0x66, 0x31,
+	0x30, 0x12, 0x3c, 0x0a, 0x03, 0x66, 0x31, 0x31, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f,
+	0x72, 0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x5f, 0x32, 0x30, 0x31, 0x39, 0x30, 0x32,
+	0x30, 0x35, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x03, 0x66, 0x31, 0x31, 0x12,
+	0x3c, 0x0a, 0x03, 0x66, 0x31, 0x32, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x5f, 0x32, 0x30, 0x31, 0x39, 0x30, 0x32, 0x30, 0x35,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x03, 0x66, 0x31, 0x32, 0x42, 0x37, 0x5a,
+	0x35, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f,
+	0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x69, 0x6e, 0x74, 0x65,
+	0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f,
+	0x6c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_internal_testprotos_legacy_legacy_proto_rawDescOnce sync.Once
+	file_internal_testprotos_legacy_legacy_proto_rawDescData = file_internal_testprotos_legacy_legacy_proto_rawDesc
+)
+
+func file_internal_testprotos_legacy_legacy_proto_rawDescGZIP() []byte {
+	file_internal_testprotos_legacy_legacy_proto_rawDescOnce.Do(func() {
+		file_internal_testprotos_legacy_legacy_proto_rawDescData = protoimpl.X.CompressGZIP(file_internal_testprotos_legacy_legacy_proto_rawDescData)
+	})
+	return file_internal_testprotos_legacy_legacy_proto_rawDescData
+}
+
+var file_internal_testprotos_legacy_legacy_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_internal_testprotos_legacy_legacy_proto_goTypes = []interface{}{
+	(*Legacy)(nil),                           // 0: google.golang.org.Legacy
+	(*proto2_20160225_2fc053c5.Message)(nil), // 1: google.golang.org.proto2_20160225.Message
+	(*proto3_20160225_2fc053c5.Message)(nil), // 2: google.golang.org.proto3_20160225.Message
+	(*proto2_20160519_a4ab9ec5.Message)(nil), // 3: google.golang.org.proto2_20160519.Message
+	(*proto3_20160519_a4ab9ec5.Message)(nil), // 4: google.golang.org.proto3_20160519.Message
+	(*proto2_20180125_92554152.Message)(nil), // 5: google.golang.org.proto2_20180125.Message
+	(*proto3_20180125_92554152.Message)(nil), // 6: google.golang.org.proto3_20180125.Message
+	(*proto2_20180430_b4deda09.Message)(nil), // 7: google.golang.org.proto2_20180430.Message
+	(*proto3_20180430_b4deda09.Message)(nil), // 8: google.golang.org.proto3_20180430.Message
+	(*proto2_20180814_aa810b61.Message)(nil), // 9: google.golang.org.proto2_20180814.Message
+	(*proto3_20180814_aa810b61.Message)(nil), // 10: google.golang.org.proto3_20180814.Message
+	(*proto2_20190205_c823c79e.Message)(nil), // 11: google.golang.org.proto2_20190205.Message
+	(*proto3_20190205_c823c79e.Message)(nil), // 12: google.golang.org.proto3_20190205.Message
+}
+var file_internal_testprotos_legacy_legacy_proto_depIdxs = []int32{
+	1,  // 0: google.golang.org.Legacy.f1:type_name -> google.golang.org.proto2_20160225.Message
+	2,  // 1: google.golang.org.Legacy.f2:type_name -> google.golang.org.proto3_20160225.Message
+	3,  // 2: google.golang.org.Legacy.f3:type_name -> google.golang.org.proto2_20160519.Message
+	4,  // 3: google.golang.org.Legacy.f4:type_name -> google.golang.org.proto3_20160519.Message
+	5,  // 4: google.golang.org.Legacy.f5:type_name -> google.golang.org.proto2_20180125.Message
+	6,  // 5: google.golang.org.Legacy.f6:type_name -> google.golang.org.proto3_20180125.Message
+	7,  // 6: google.golang.org.Legacy.f7:type_name -> google.golang.org.proto2_20180430.Message
+	8,  // 7: google.golang.org.Legacy.f8:type_name -> google.golang.org.proto3_20180430.Message
+	9,  // 8: google.golang.org.Legacy.f9:type_name -> google.golang.org.proto2_20180814.Message
+	10, // 9: google.golang.org.Legacy.f10:type_name -> google.golang.org.proto3_20180814.Message
+	11, // 10: google.golang.org.Legacy.f11:type_name -> google.golang.org.proto2_20190205.Message
+	12, // 11: google.golang.org.Legacy.f12:type_name -> google.golang.org.proto3_20190205.Message
+	12, // [12:12] is the sub-list for method output_type
+	12, // [12:12] is the sub-list for method input_type
+	12, // [12:12] is the sub-list for extension type_name
+	12, // [12:12] is the sub-list for extension extendee
+	0,  // [0:12] is the sub-list for field type_name
+}
+
+func init() { file_internal_testprotos_legacy_legacy_proto_init() }
+func file_internal_testprotos_legacy_legacy_proto_init() {
+	if File_internal_testprotos_legacy_legacy_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_internal_testprotos_legacy_legacy_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Legacy); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_internal_testprotos_legacy_legacy_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_internal_testprotos_legacy_legacy_proto_goTypes,
+		DependencyIndexes: file_internal_testprotos_legacy_legacy_proto_depIdxs,
+		MessageInfos:      file_internal_testprotos_legacy_legacy_proto_msgTypes,
+	}.Build()
+	File_internal_testprotos_legacy_legacy_proto = out.File
+	file_internal_testprotos_legacy_legacy_proto_rawDesc = nil
+	file_internal_testprotos_legacy_legacy_proto_goTypes = nil
+	file_internal_testprotos_legacy_legacy_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/legacy/legacy.proto b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/legacy.proto
new file mode 100644
index 000000000..7f59ebca0
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/legacy.proto
@@ -0,0 +1,76 @@
+// 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.
+
+syntax = "proto3";
+
+package google.golang.org;
+option go_package = "google.golang.org/protobuf/internal/testprotos/legacy";
+
+// This file imports other files generated from a build of protoc-gen-go
+// locked to a specific version. For all imports, they were built using
+// Go v1.13 and protoc v3.11.12. This package is used to test compatibility with
+// checked in generated code that cannot easily change.
+// As such, there should never be a need to update these generated files.
+//
+// The specific version of protoc-gen-go used is encoded in the file path:
+//	${NAME}_${COMMIT_DATE}_${COMMIT_HASH}/test.proto
+//
+// To avoid a dependency on the v1 module, we perform the following
+// import path replacement to all generated .pb.go files:
+//	"github.com/golang/protobuf/proto" => "google.golang.org/protobuf/internal/protolegacy"
+
+// The oldest supported version of protoc-gen-go is 2fc053c5,
+// which finished adding descriptor methods to all protobuf types.
+import "internal/testprotos/legacy/proto2_20160225_2fc053c5/test.proto"; // v0.0.0
+import "internal/testprotos/legacy/proto3_20160225_2fc053c5/test.proto"; // v0.0.0
+// Changes from 20160225 to 20160519:
+//	* Nothing noteworthy to generated code
+import "internal/testprotos/legacy/proto2_20160519_a4ab9ec5/test.proto"; // v0.0.0
+import "internal/testprotos/legacy/proto3_20160519_a4ab9ec5/test.proto"; // v0.0.0
+// Changes from 20160519 to 20180125:
+//	* Removed ExtensionMap method and XXX_extensions field from messages
+//	* Added embedded proto.XXX_InternalExtensions field to messages
+//	* Added proto.ExtensionDesc.Filename field
+//	* Added registration for file descriptor
+//	* Added Get accessor methods for all fields in proto3 messages
+//	* Proto3 repeated primitives are packed by default
+import "internal/testprotos/legacy/proto2_20180125_92554152/test.proto"; // v1.0.0
+import "internal/testprotos/legacy/proto3_20180125_92554152/test.proto"; // v1.0.0
+// Changes from 20180125 to 20180430:
+//	* Added XXX_unrecognized field to proto3 messages
+//	* Added XXX_NoUnkeyedLiteral field to messages
+//	* Added XXX_sizecache field to messages
+//	* Added XXX_Unmarshal method to messages
+//	* Added XXX_Marshal method to messages
+//	* Added XXX_Merge method to messages
+//	* Added XXX_Size method to messages
+//	* Added XXX_DiscardUnknown method to messages
+//	* Added dependency on proto.InternalMessageInfo for table-driven logic
+//	* Added registration for map types
+import "internal/testprotos/legacy/proto2_20180430_b4deda09/test.proto"; // v1.1.0
+import "internal/testprotos/legacy/proto3_20180430_b4deda09/test.proto"; // v1.1.0
+// Changes from 20180430 to 20180814:
+//	* Added "proto3" struct tag to all fields in proto3 messages
+import "internal/testprotos/legacy/proto2_20180814_aa810b61/test.proto"; // v1.2.0
+import "internal/testprotos/legacy/proto3_20180814_aa810b61/test.proto"; // v1.2.0
+// Changes from 20180814 to 20190205:
+//	* Changed the XXX_OneofFuncs method to XXX_OneofWrappers
+//	* Various syntactical changes to make the output more consistent
+import "internal/testprotos/legacy/proto2_20190205_c823c79e/test.proto"; // v1.3.0
+import "internal/testprotos/legacy/proto3_20190205_c823c79e/test.proto"; // v1.3.0
+
+message Legacy {
+	google.golang.org.proto2_20160225.Message f1 = 1;
+	google.golang.org.proto3_20160225.Message f2 = 2;
+	google.golang.org.proto2_20160519.Message f3 = 3;
+	google.golang.org.proto3_20160519.Message f4 = 4;
+	google.golang.org.proto2_20180125.Message f5 = 5;
+	google.golang.org.proto3_20180125.Message f6 = 6;
+	google.golang.org.proto2_20180430.Message f7 = 7;
+	google.golang.org.proto3_20180430.Message f8 = 8;
+	google.golang.org.proto2_20180814.Message f9 = 9;
+	google.golang.org.proto3_20180814.Message f10 = 10;
+	google.golang.org.proto2_20190205.Message f11 = 11;
+	google.golang.org.proto3_20190205.Message f12 = 12;
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20160225_2fc053c5/test.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20160225_2fc053c5/test.pb.go
new file mode 100644
index 000000000..8e0835e43
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20160225_2fc053c5/test.pb.go
@@ -0,0 +1,3532 @@
+// 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.
+
+// Code generated by protoc-gen-go.
+// source: proto2_20160225_2fc053c5/test.proto
+// DO NOT EDIT!
+
+/*
+Package proto2_20160225_2fc053c5 is a generated protocol buffer package.
+
+It is generated from these files:
+	proto2_20160225_2fc053c5/test.proto
+
+It has these top-level messages:
+	SiblingMessage
+	Message
+*/
+package proto2_20160225_2fc053c5
+
+import proto "google.golang.org/protobuf/internal/protolegacy"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+const _ = proto.ProtoPackageIsVersion1
+
+type SiblingEnum int32
+
+const (
+	SiblingEnum_ALPHA   SiblingEnum = 0
+	SiblingEnum_BRAVO   SiblingEnum = 10
+	SiblingEnum_CHARLIE SiblingEnum = 200
+)
+
+var SiblingEnum_name = map[int32]string{
+	0:   "ALPHA",
+	10:  "BRAVO",
+	200: "CHARLIE",
+}
+var SiblingEnum_value = map[string]int32{
+	"ALPHA":   0,
+	"BRAVO":   10,
+	"CHARLIE": 200,
+}
+
+func (x SiblingEnum) Enum() *SiblingEnum {
+	p := new(SiblingEnum)
+	*p = x
+	return p
+}
+func (x SiblingEnum) String() string {
+	return proto.EnumName(SiblingEnum_name, int32(x))
+}
+func (x *SiblingEnum) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(SiblingEnum_value, data, "SiblingEnum")
+	if err != nil {
+		return err
+	}
+	*x = SiblingEnum(value)
+	return nil
+}
+func (SiblingEnum) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+type Message_ChildEnum int32
+
+const (
+	Message_ALPHA   Message_ChildEnum = 0
+	Message_BRAVO   Message_ChildEnum = 1
+	Message_CHARLIE Message_ChildEnum = 2
+)
+
+var Message_ChildEnum_name = map[int32]string{
+	0: "ALPHA",
+	1: "BRAVO",
+	2: "CHARLIE",
+}
+var Message_ChildEnum_value = map[string]int32{
+	"ALPHA":   0,
+	"BRAVO":   1,
+	"CHARLIE": 2,
+}
+
+func (x Message_ChildEnum) Enum() *Message_ChildEnum {
+	p := new(Message_ChildEnum)
+	*p = x
+	return p
+}
+func (x Message_ChildEnum) String() string {
+	return proto.EnumName(Message_ChildEnum_name, int32(x))
+}
+func (x *Message_ChildEnum) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(Message_ChildEnum_value, data, "Message_ChildEnum")
+	if err != nil {
+		return err
+	}
+	*x = Message_ChildEnum(value)
+	return nil
+}
+func (Message_ChildEnum) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{1, 0} }
+
+type SiblingMessage 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"`
+	F4               *Message `protobuf:"bytes,4,opt,name=f4" json:"f4,omitempty"`
+	XXX_unrecognized []byte   `json:"-"`
+}
+
+func (m *SiblingMessage) Reset()                    { *m = SiblingMessage{} }
+func (m *SiblingMessage) String() string            { return proto.CompactTextString(m) }
+func (*SiblingMessage) ProtoMessage()               {}
+func (*SiblingMessage) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *SiblingMessage) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *SiblingMessage) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *SiblingMessage) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+func (m *SiblingMessage) GetF4() *Message {
+	if m != nil {
+		return m.F4
+	}
+	return nil
+}
+
+type Message struct {
+	Namedgroup *Message_NamedGroup `protobuf:"group,1,opt,name=NamedGroup,json=namedgroup" json:"namedgroup,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      *Message_ChildEnum     `protobuf:"varint,115,opt,name=optional_child_enum,json=optionalChildEnum,enum=google.golang.org.proto2_20160225.Message_ChildEnum" json:"optional_child_enum,omitempty"`
+	OptionalChildMessage   *Message_ChildMessage  `protobuf:"bytes,116,opt,name=optional_child_message,json=optionalChildMessage" json:"optional_child_message,omitempty"`
+	OptionalNamedGroup     *Message_NamedGroup    `protobuf:"bytes,117,opt,name=optional_named_group,json=optionalNamedGroup" json:"optional_named_group,omitempty"`
+	OptionalSiblingEnum    *SiblingEnum           `protobuf:"varint,118,opt,name=optional_sibling_enum,json=optionalSiblingEnum,enum=google.golang.org.proto2_20160225.SiblingEnum" json:"optional_sibling_enum,omitempty"`
+	OptionalSiblingMessage *SiblingMessage        `protobuf:"bytes,119,opt,name=optional_sibling_message,json=optionalSiblingMessage" json:"optional_sibling_message,omitempty"`
+	Optionalgroup          *Message_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   *Message_ChildEnum `protobuf:"varint,215,opt,name=defaulted_child_enum,json=defaultedChildEnum,enum=google.golang.org.proto2_20160225.Message_ChildEnum,def=0" json:"defaulted_child_enum,omitempty"`
+	DefaultedSiblingEnum *SiblingEnum       `protobuf:"varint,216,opt,name=defaulted_sibling_enum,json=defaultedSiblingEnum,enum=google.golang.org.proto2_20160225.SiblingEnum,def=0" 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      *Message_ChildEnum     `protobuf:"varint,315,req,name=required_child_enum,json=requiredChildEnum,enum=google.golang.org.proto2_20160225.Message_ChildEnum" json:"required_child_enum,omitempty"`
+	RequiredChildMessage   *Message_ChildMessage  `protobuf:"bytes,316,req,name=required_child_message,json=requiredChildMessage" json:"required_child_message,omitempty"`
+	RequiredNamedGroup     *Message_NamedGroup    `protobuf:"bytes,317,req,name=required_named_group,json=requiredNamedGroup" json:"required_named_group,omitempty"`
+	RequiredSiblingEnum    *SiblingEnum           `protobuf:"varint,318,req,name=required_sibling_enum,json=requiredSiblingEnum,enum=google.golang.org.proto2_20160225.SiblingEnum" json:"required_sibling_enum,omitempty"`
+	RequiredSiblingMessage *SiblingMessage        `protobuf:"bytes,319,req,name=required_sibling_message,json=requiredSiblingMessage" json:"required_sibling_message,omitempty"`
+	Requiredgroup          *Message_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   *Message_ChildEnum `protobuf:"varint,415,req,name=required_defaulted_child_enum,json=requiredDefaultedChildEnum,enum=google.golang.org.proto2_20160225.Message_ChildEnum,def=0" json:"required_defaulted_child_enum,omitempty"`
+	RequiredDefaultedSiblingEnum *SiblingEnum       `protobuf:"varint,416,req,name=required_defaulted_sibling_enum,json=requiredDefaultedSiblingEnum,enum=google.golang.org.proto2_20160225.SiblingEnum,def=0" 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      []Message_ChildEnum      `protobuf:"varint,515,rep,name=repeated_child_enum,json=repeatedChildEnum,enum=google.golang.org.proto2_20160225.Message_ChildEnum" json:"repeated_child_enum,omitempty"`
+	RepeatedChildMessage   []*Message_ChildMessage  `protobuf:"bytes,516,rep,name=repeated_child_message,json=repeatedChildMessage" json:"repeated_child_message,omitempty"`
+	RepeatedNamedGroup     []*Message_NamedGroup    `protobuf:"bytes,517,rep,name=repeated_named_group,json=repeatedNamedGroup" json:"repeated_named_group,omitempty"`
+	RepeatedSiblingEnum    []SiblingEnum            `protobuf:"varint,518,rep,name=repeated_sibling_enum,json=repeatedSiblingEnum,enum=google.golang.org.proto2_20160225.SiblingEnum" json:"repeated_sibling_enum,omitempty"`
+	RepeatedSiblingMessage []*SiblingMessage        `protobuf:"bytes,519,rep,name=repeated_sibling_message,json=repeatedSiblingMessage" json:"repeated_sibling_message,omitempty"`
+	Repeatedgroup          []*Message_RepeatedGroup `protobuf:"group,520,rep,name=RepeatedGroup,json=repeatedgroup" json:"repeatedgroup,omitempty"`
+	// Map fields.
+	MapBoolBool           map[bool]bool                  `protobuf:"bytes,600,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,601,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,602,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,603,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,604,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,605,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,606,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,607,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,608,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,609,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,610,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,611,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,612,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,613,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,614,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"`
+	MapBoolChildEnum      map[bool]Message_ChildEnum     `protobuf:"bytes,615,rep,name=map_bool_child_enum,json=mapBoolChildEnum" json:"map_bool_child_enum,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=google.golang.org.proto2_20160225.Message_ChildEnum"`
+	MapBoolChildMessage   map[bool]*Message_ChildMessage `protobuf:"bytes,616,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"`
+	MapBoolNamedGroup     map[bool]*Message_NamedGroup   `protobuf:"bytes,617,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"`
+	MapBoolSiblingEnum    map[bool]SiblingEnum           `protobuf:"bytes,618,rep,name=map_bool_sibling_enum,json=mapBoolSiblingEnum" json:"map_bool_sibling_enum,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=google.golang.org.proto2_20160225.SiblingEnum"`
+	MapBoolSiblingMessage map[bool]*SiblingMessage       `protobuf:"bytes,619,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"`
+	MapInt32Bool          map[int32]bool                 `protobuf:"bytes,620,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,621,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,622,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,623,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,624,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,625,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,626,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,627,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.
+	//
+	// Types that are valid to be assigned to OneofUnion:
+	//	*Message_OneofBool
+	//	*Message_OneofInt32
+	//	*Message_OneofSint32
+	//	*Message_OneofUint32
+	//	*Message_OneofInt64
+	//	*Message_OneofSint64
+	//	*Message_OneofUint64
+	//	*Message_OneofFixed32
+	//	*Message_OneofSfixed32
+	//	*Message_OneofFloat
+	//	*Message_OneofFixed64
+	//	*Message_OneofSfixed64
+	//	*Message_OneofDouble
+	//	*Message_OneofString
+	//	*Message_OneofBytes
+	//	*Message_OneofChildEnum
+	//	*Message_OneofChildMessage
+	//	*Message_OneofNamedGroup
+	//	*Message_OneofSiblingEnum
+	//	*Message_OneofSiblingMessage
+	//	*Message_Oneofgroup
+	//	*Message_OneofString1
+	//	*Message_OneofString2
+	//	*Message_OneofString3
+	OneofUnion isMessage_OneofUnion `protobuf_oneof:"oneof_union"`
+	// Oneof default fields.
+	//
+	// Types that are valid to be assigned to OneofDefaultedUnion:
+	//	*Message_OneofDefaultedBool
+	//	*Message_OneofDefaultedInt32
+	//	*Message_OneofDefaultedSint32
+	//	*Message_OneofDefaultedUint32
+	//	*Message_OneofDefaultedInt64
+	//	*Message_OneofDefaultedSint64
+	//	*Message_OneofDefaultedUint64
+	//	*Message_OneofDefaultedFixed32
+	//	*Message_OneofDefaultedSfixed32
+	//	*Message_OneofDefaultedFloat
+	//	*Message_OneofDefaultedFixed64
+	//	*Message_OneofDefaultedSfixed64
+	//	*Message_OneofDefaultedDouble
+	//	*Message_OneofDefaultedString
+	//	*Message_OneofDefaultedBytes
+	//	*Message_OneofDefaultedChildEnum
+	//	*Message_OneofDefaultedSiblingEnum
+	OneofDefaultedUnion isMessage_OneofDefaultedUnion `protobuf_oneof:"oneof_defaulted_union"`
+	XXX_extensions      map[int32]proto.Extension     `json:"-"`
+	XXX_unrecognized    []byte                        `json:"-"`
+}
+
+func (m *Message) Reset()                    { *m = Message{} }
+func (m *Message) String() string            { return proto.CompactTextString(m) }
+func (*Message) ProtoMessage()               {}
+func (*Message) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+var extRange_Message = []proto.ExtensionRange{
+	{10000, 536870911},
+}
+
+func (*Message) ExtensionRangeArray() []proto.ExtensionRange {
+	return extRange_Message
+}
+func (m *Message) ExtensionMap() map[int32]proto.Extension {
+	if m.XXX_extensions == nil {
+		m.XXX_extensions = make(map[int32]proto.Extension)
+	}
+	return m.XXX_extensions
+}
+
+const Default_Message_DefaultedBool bool = true
+const Default_Message_DefaultedInt32 int32 = -12345
+const Default_Message_DefaultedSint32 int32 = -3200
+const Default_Message_DefaultedUint32 uint32 = 3200
+const Default_Message_DefaultedInt64 int64 = -123456789
+const Default_Message_DefaultedSint64 int64 = -6400
+const Default_Message_DefaultedUint64 uint64 = 6400
+const Default_Message_DefaultedFixed32 uint32 = 320000
+const Default_Message_DefaultedSfixed32 int32 = -320000
+const Default_Message_DefaultedFloat float32 = 3.14159
+const Default_Message_DefaultedFixed64 uint64 = 640000
+const Default_Message_DefaultedSfixed64 int64 = -640000
+const Default_Message_DefaultedDouble float64 = 3.14159265359
+const Default_Message_DefaultedString string = "hello, \"world!\"\n"
+
+var Default_Message_DefaultedBytes []byte = []byte("dead\\336\\255\\276\\357beef")
+
+const Default_Message_DefaultedChildEnum Message_ChildEnum = Message_ALPHA
+const Default_Message_DefaultedSiblingEnum SiblingEnum = SiblingEnum_ALPHA
+const Default_Message_RequiredDefaultedBool bool = true
+const Default_Message_RequiredDefaultedInt32 int32 = -12345
+const Default_Message_RequiredDefaultedSint32 int32 = -3200
+const Default_Message_RequiredDefaultedUint32 uint32 = 3200
+const Default_Message_RequiredDefaultedInt64 int64 = -123456789
+const Default_Message_RequiredDefaultedSint64 int64 = -6400
+const Default_Message_RequiredDefaultedUint64 uint64 = 6400
+const Default_Message_RequiredDefaultedFixed32 uint32 = 320000
+const Default_Message_RequiredDefaultedSfixed32 int32 = -320000
+const Default_Message_RequiredDefaultedFloat float32 = 3.14159
+const Default_Message_RequiredDefaultedFixed64 uint64 = 640000
+const Default_Message_RequiredDefaultedSfixed64 int64 = -640000
+const Default_Message_RequiredDefaultedDouble float64 = 3.14159265359
+const Default_Message_RequiredDefaultedString string = "hello, \"world!\"\n"
+
+var Default_Message_RequiredDefaultedBytes []byte = []byte("dead\\336\\255\\276\\357beef")
+
+const Default_Message_RequiredDefaultedChildEnum Message_ChildEnum = Message_ALPHA
+const Default_Message_RequiredDefaultedSiblingEnum SiblingEnum = SiblingEnum_ALPHA
+const Default_Message_OneofDefaultedBool bool = true
+const Default_Message_OneofDefaultedInt32 int32 = -12345
+const Default_Message_OneofDefaultedSint32 int32 = -3200
+const Default_Message_OneofDefaultedUint32 uint32 = 3200
+const Default_Message_OneofDefaultedInt64 int64 = -123456789
+const Default_Message_OneofDefaultedSint64 int64 = -6400
+const Default_Message_OneofDefaultedUint64 uint64 = 6400
+const Default_Message_OneofDefaultedFixed32 uint32 = 320000
+const Default_Message_OneofDefaultedSfixed32 int32 = -320000
+const Default_Message_OneofDefaultedFloat float32 = 3.14159
+const Default_Message_OneofDefaultedFixed64 uint64 = 640000
+const Default_Message_OneofDefaultedSfixed64 int64 = -640000
+const Default_Message_OneofDefaultedDouble float64 = 3.14159265359
+const Default_Message_OneofDefaultedString string = "hello, \"world!\"\n"
+
+var Default_Message_OneofDefaultedBytes []byte = []byte("dead\\336\\255\\276\\357beef")
+
+const Default_Message_OneofDefaultedChildEnum Message_ChildEnum = Message_ALPHA
+const Default_Message_OneofDefaultedSiblingEnum SiblingEnum = SiblingEnum_ALPHA
+
+type isMessage_OneofUnion interface{ isMessage_OneofUnion() }
+type isMessage_OneofDefaultedUnion interface{ isMessage_OneofDefaultedUnion() }
+
+type Message_OneofBool struct {
+	OneofBool bool `protobuf:"varint,700,opt,name=oneof_bool,json=oneofBool,oneof"`
+}
+type Message_OneofInt32 struct {
+	OneofInt32 int32 `protobuf:"varint,701,opt,name=oneof_int32,json=oneofInt32,oneof"`
+}
+type Message_OneofSint32 struct {
+	OneofSint32 int32 `protobuf:"zigzag32,702,opt,name=oneof_sint32,json=oneofSint32,oneof"`
+}
+type Message_OneofUint32 struct {
+	OneofUint32 uint32 `protobuf:"varint,703,opt,name=oneof_uint32,json=oneofUint32,oneof"`
+}
+type Message_OneofInt64 struct {
+	OneofInt64 int64 `protobuf:"varint,704,opt,name=oneof_int64,json=oneofInt64,oneof"`
+}
+type Message_OneofSint64 struct {
+	OneofSint64 int64 `protobuf:"zigzag64,705,opt,name=oneof_sint64,json=oneofSint64,oneof"`
+}
+type Message_OneofUint64 struct {
+	OneofUint64 uint64 `protobuf:"varint,706,opt,name=oneof_uint64,json=oneofUint64,oneof"`
+}
+type Message_OneofFixed32 struct {
+	OneofFixed32 uint32 `protobuf:"fixed32,707,opt,name=oneof_fixed32,json=oneofFixed32,oneof"`
+}
+type Message_OneofSfixed32 struct {
+	OneofSfixed32 int32 `protobuf:"fixed32,708,opt,name=oneof_sfixed32,json=oneofSfixed32,oneof"`
+}
+type Message_OneofFloat struct {
+	OneofFloat float32 `protobuf:"fixed32,709,opt,name=oneof_float,json=oneofFloat,oneof"`
+}
+type Message_OneofFixed64 struct {
+	OneofFixed64 uint64 `protobuf:"fixed64,710,opt,name=oneof_fixed64,json=oneofFixed64,oneof"`
+}
+type Message_OneofSfixed64 struct {
+	OneofSfixed64 int64 `protobuf:"fixed64,711,opt,name=oneof_sfixed64,json=oneofSfixed64,oneof"`
+}
+type Message_OneofDouble struct {
+	OneofDouble float64 `protobuf:"fixed64,712,opt,name=oneof_double,json=oneofDouble,oneof"`
+}
+type Message_OneofString struct {
+	OneofString string `protobuf:"bytes,713,opt,name=oneof_string,json=oneofString,oneof"`
+}
+type Message_OneofBytes struct {
+	OneofBytes []byte `protobuf:"bytes,714,opt,name=oneof_bytes,json=oneofBytes,oneof"`
+}
+type Message_OneofChildEnum struct {
+	OneofChildEnum Message_ChildEnum `protobuf:"varint,715,opt,name=oneof_child_enum,json=oneofChildEnum,enum=google.golang.org.proto2_20160225.Message_ChildEnum,oneof"`
+}
+type Message_OneofChildMessage struct {
+	OneofChildMessage *Message_ChildMessage `protobuf:"bytes,716,opt,name=oneof_child_message,json=oneofChildMessage,oneof"`
+}
+type Message_OneofNamedGroup struct {
+	OneofNamedGroup *Message_NamedGroup `protobuf:"bytes,717,opt,name=oneof_named_group,json=oneofNamedGroup,oneof"`
+}
+type Message_OneofSiblingEnum struct {
+	OneofSiblingEnum SiblingEnum `protobuf:"varint,718,opt,name=oneof_sibling_enum,json=oneofSiblingEnum,enum=google.golang.org.proto2_20160225.SiblingEnum,oneof"`
+}
+type Message_OneofSiblingMessage struct {
+	OneofSiblingMessage *SiblingMessage `protobuf:"bytes,719,opt,name=oneof_sibling_message,json=oneofSiblingMessage,oneof"`
+}
+type Message_Oneofgroup struct {
+	Oneofgroup *Message_OneofGroup `protobuf:"group,720,opt,name=OneofGroup,json=oneofgroup,oneof"`
+}
+type Message_OneofString1 struct {
+	OneofString1 string `protobuf:"bytes,721,opt,name=oneof_string1,json=oneofString1,oneof"`
+}
+type Message_OneofString2 struct {
+	OneofString2 string `protobuf:"bytes,722,opt,name=oneof_string2,json=oneofString2,oneof"`
+}
+type Message_OneofString3 struct {
+	OneofString3 string `protobuf:"bytes,723,opt,name=oneof_string3,json=oneofString3,oneof"`
+}
+type Message_OneofDefaultedBool struct {
+	OneofDefaultedBool bool `protobuf:"varint,800,opt,name=oneof_defaulted_bool,json=oneofDefaultedBool,oneof,def=1"`
+}
+type Message_OneofDefaultedInt32 struct {
+	OneofDefaultedInt32 int32 `protobuf:"varint,801,opt,name=oneof_defaulted_int32,json=oneofDefaultedInt32,oneof,def=-12345"`
+}
+type Message_OneofDefaultedSint32 struct {
+	OneofDefaultedSint32 int32 `protobuf:"zigzag32,802,opt,name=oneof_defaulted_sint32,json=oneofDefaultedSint32,oneof,def=-3200"`
+}
+type Message_OneofDefaultedUint32 struct {
+	OneofDefaultedUint32 uint32 `protobuf:"varint,803,opt,name=oneof_defaulted_uint32,json=oneofDefaultedUint32,oneof,def=3200"`
+}
+type Message_OneofDefaultedInt64 struct {
+	OneofDefaultedInt64 int64 `protobuf:"varint,804,opt,name=oneof_defaulted_int64,json=oneofDefaultedInt64,oneof,def=-123456789"`
+}
+type Message_OneofDefaultedSint64 struct {
+	OneofDefaultedSint64 int64 `protobuf:"zigzag64,805,opt,name=oneof_defaulted_sint64,json=oneofDefaultedSint64,oneof,def=-6400"`
+}
+type Message_OneofDefaultedUint64 struct {
+	OneofDefaultedUint64 uint64 `protobuf:"varint,806,opt,name=oneof_defaulted_uint64,json=oneofDefaultedUint64,oneof,def=6400"`
+}
+type Message_OneofDefaultedFixed32 struct {
+	OneofDefaultedFixed32 uint32 `protobuf:"fixed32,807,opt,name=oneof_defaulted_fixed32,json=oneofDefaultedFixed32,oneof,def=320000"`
+}
+type Message_OneofDefaultedSfixed32 struct {
+	OneofDefaultedSfixed32 int32 `protobuf:"fixed32,808,opt,name=oneof_defaulted_sfixed32,json=oneofDefaultedSfixed32,oneof,def=-320000"`
+}
+type Message_OneofDefaultedFloat struct {
+	OneofDefaultedFloat float32 `protobuf:"fixed32,809,opt,name=oneof_defaulted_float,json=oneofDefaultedFloat,oneof,def=3.14159"`
+}
+type Message_OneofDefaultedFixed64 struct {
+	OneofDefaultedFixed64 uint64 `protobuf:"fixed64,810,opt,name=oneof_defaulted_fixed64,json=oneofDefaultedFixed64,oneof,def=640000"`
+}
+type Message_OneofDefaultedSfixed64 struct {
+	OneofDefaultedSfixed64 int64 `protobuf:"fixed64,811,opt,name=oneof_defaulted_sfixed64,json=oneofDefaultedSfixed64,oneof,def=-640000"`
+}
+type Message_OneofDefaultedDouble struct {
+	OneofDefaultedDouble float64 `protobuf:"fixed64,812,opt,name=oneof_defaulted_double,json=oneofDefaultedDouble,oneof,def=3.14159265359"`
+}
+type Message_OneofDefaultedString struct {
+	OneofDefaultedString string `protobuf:"bytes,813,opt,name=oneof_defaulted_string,json=oneofDefaultedString,oneof,def=hello, \"world!\"\n"`
+}
+type Message_OneofDefaultedBytes struct {
+	OneofDefaultedBytes []byte `protobuf:"bytes,814,opt,name=oneof_defaulted_bytes,json=oneofDefaultedBytes,oneof,def=dead\\336\\255\\276\\357beef"`
+}
+type Message_OneofDefaultedChildEnum struct {
+	OneofDefaultedChildEnum Message_ChildEnum `protobuf:"varint,815,opt,name=oneof_defaulted_child_enum,json=oneofDefaultedChildEnum,enum=google.golang.org.proto2_20160225.Message_ChildEnum,oneof,def=0"`
+}
+type Message_OneofDefaultedSiblingEnum struct {
+	OneofDefaultedSiblingEnum SiblingEnum `protobuf:"varint,816,opt,name=oneof_defaulted_sibling_enum,json=oneofDefaultedSiblingEnum,enum=google.golang.org.proto2_20160225.SiblingEnum,oneof,def=0"`
+}
+
+func (*Message_OneofBool) isMessage_OneofUnion()                          {}
+func (*Message_OneofInt32) isMessage_OneofUnion()                         {}
+func (*Message_OneofSint32) isMessage_OneofUnion()                        {}
+func (*Message_OneofUint32) isMessage_OneofUnion()                        {}
+func (*Message_OneofInt64) isMessage_OneofUnion()                         {}
+func (*Message_OneofSint64) isMessage_OneofUnion()                        {}
+func (*Message_OneofUint64) isMessage_OneofUnion()                        {}
+func (*Message_OneofFixed32) isMessage_OneofUnion()                       {}
+func (*Message_OneofSfixed32) isMessage_OneofUnion()                      {}
+func (*Message_OneofFloat) isMessage_OneofUnion()                         {}
+func (*Message_OneofFixed64) isMessage_OneofUnion()                       {}
+func (*Message_OneofSfixed64) isMessage_OneofUnion()                      {}
+func (*Message_OneofDouble) isMessage_OneofUnion()                        {}
+func (*Message_OneofString) isMessage_OneofUnion()                        {}
+func (*Message_OneofBytes) isMessage_OneofUnion()                         {}
+func (*Message_OneofChildEnum) isMessage_OneofUnion()                     {}
+func (*Message_OneofChildMessage) isMessage_OneofUnion()                  {}
+func (*Message_OneofNamedGroup) isMessage_OneofUnion()                    {}
+func (*Message_OneofSiblingEnum) isMessage_OneofUnion()                   {}
+func (*Message_OneofSiblingMessage) isMessage_OneofUnion()                {}
+func (*Message_Oneofgroup) isMessage_OneofUnion()                         {}
+func (*Message_OneofString1) isMessage_OneofUnion()                       {}
+func (*Message_OneofString2) isMessage_OneofUnion()                       {}
+func (*Message_OneofString3) isMessage_OneofUnion()                       {}
+func (*Message_OneofDefaultedBool) isMessage_OneofDefaultedUnion()        {}
+func (*Message_OneofDefaultedInt32) isMessage_OneofDefaultedUnion()       {}
+func (*Message_OneofDefaultedSint32) isMessage_OneofDefaultedUnion()      {}
+func (*Message_OneofDefaultedUint32) isMessage_OneofDefaultedUnion()      {}
+func (*Message_OneofDefaultedInt64) isMessage_OneofDefaultedUnion()       {}
+func (*Message_OneofDefaultedSint64) isMessage_OneofDefaultedUnion()      {}
+func (*Message_OneofDefaultedUint64) isMessage_OneofDefaultedUnion()      {}
+func (*Message_OneofDefaultedFixed32) isMessage_OneofDefaultedUnion()     {}
+func (*Message_OneofDefaultedSfixed32) isMessage_OneofDefaultedUnion()    {}
+func (*Message_OneofDefaultedFloat) isMessage_OneofDefaultedUnion()       {}
+func (*Message_OneofDefaultedFixed64) isMessage_OneofDefaultedUnion()     {}
+func (*Message_OneofDefaultedSfixed64) isMessage_OneofDefaultedUnion()    {}
+func (*Message_OneofDefaultedDouble) isMessage_OneofDefaultedUnion()      {}
+func (*Message_OneofDefaultedString) isMessage_OneofDefaultedUnion()      {}
+func (*Message_OneofDefaultedBytes) isMessage_OneofDefaultedUnion()       {}
+func (*Message_OneofDefaultedChildEnum) isMessage_OneofDefaultedUnion()   {}
+func (*Message_OneofDefaultedSiblingEnum) isMessage_OneofDefaultedUnion() {}
+
+func (m *Message) GetOneofUnion() isMessage_OneofUnion {
+	if m != nil {
+		return m.OneofUnion
+	}
+	return nil
+}
+func (m *Message) GetOneofDefaultedUnion() isMessage_OneofDefaultedUnion {
+	if m != nil {
+		return m.OneofDefaultedUnion
+	}
+	return nil
+}
+
+func (m *Message) GetNamedgroup() *Message_NamedGroup {
+	if m != nil {
+		return m.Namedgroup
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalBool() bool {
+	if m != nil && m.OptionalBool != nil {
+		return *m.OptionalBool
+	}
+	return false
+}
+
+func (m *Message) GetOptionalInt32() int32 {
+	if m != nil && m.OptionalInt32 != nil {
+		return *m.OptionalInt32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSint32() int32 {
+	if m != nil && m.OptionalSint32 != nil {
+		return *m.OptionalSint32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalUint32() uint32 {
+	if m != nil && m.OptionalUint32 != nil {
+		return *m.OptionalUint32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalInt64() int64 {
+	if m != nil && m.OptionalInt64 != nil {
+		return *m.OptionalInt64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSint64() int64 {
+	if m != nil && m.OptionalSint64 != nil {
+		return *m.OptionalSint64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalUint64() uint64 {
+	if m != nil && m.OptionalUint64 != nil {
+		return *m.OptionalUint64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalFixed32() uint32 {
+	if m != nil && m.OptionalFixed32 != nil {
+		return *m.OptionalFixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSfixed32() int32 {
+	if m != nil && m.OptionalSfixed32 != nil {
+		return *m.OptionalSfixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalFloat() float32 {
+	if m != nil && m.OptionalFloat != nil {
+		return *m.OptionalFloat
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalFixed64() uint64 {
+	if m != nil && m.OptionalFixed64 != nil {
+		return *m.OptionalFixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSfixed64() int64 {
+	if m != nil && m.OptionalSfixed64 != nil {
+		return *m.OptionalSfixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalDouble() float64 {
+	if m != nil && m.OptionalDouble != nil {
+		return *m.OptionalDouble
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalString() string {
+	if m != nil && m.OptionalString != nil {
+		return *m.OptionalString
+	}
+	return ""
+}
+
+func (m *Message) GetOptionalBytes() []byte {
+	if m != nil {
+		return m.OptionalBytes
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalChildEnum() Message_ChildEnum {
+	if m != nil && m.OptionalChildEnum != nil {
+		return *m.OptionalChildEnum
+	}
+	return Message_ALPHA
+}
+
+func (m *Message) GetOptionalChildMessage() *Message_ChildMessage {
+	if m != nil {
+		return m.OptionalChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalNamedGroup() *Message_NamedGroup {
+	if m != nil {
+		return m.OptionalNamedGroup
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalSiblingEnum() SiblingEnum {
+	if m != nil && m.OptionalSiblingEnum != nil {
+		return *m.OptionalSiblingEnum
+	}
+	return SiblingEnum_ALPHA
+}
+
+func (m *Message) GetOptionalSiblingMessage() *SiblingMessage {
+	if m != nil {
+		return m.OptionalSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalgroup() *Message_OptionalGroup {
+	if m != nil {
+		return m.Optionalgroup
+	}
+	return nil
+}
+
+func (m *Message) GetDefaultedBool() bool {
+	if m != nil && m.DefaultedBool != nil {
+		return *m.DefaultedBool
+	}
+	return Default_Message_DefaultedBool
+}
+
+func (m *Message) GetDefaultedInt32() int32 {
+	if m != nil && m.DefaultedInt32 != nil {
+		return *m.DefaultedInt32
+	}
+	return Default_Message_DefaultedInt32
+}
+
+func (m *Message) GetDefaultedSint32() int32 {
+	if m != nil && m.DefaultedSint32 != nil {
+		return *m.DefaultedSint32
+	}
+	return Default_Message_DefaultedSint32
+}
+
+func (m *Message) GetDefaultedUint32() uint32 {
+	if m != nil && m.DefaultedUint32 != nil {
+		return *m.DefaultedUint32
+	}
+	return Default_Message_DefaultedUint32
+}
+
+func (m *Message) GetDefaultedInt64() int64 {
+	if m != nil && m.DefaultedInt64 != nil {
+		return *m.DefaultedInt64
+	}
+	return Default_Message_DefaultedInt64
+}
+
+func (m *Message) GetDefaultedSint64() int64 {
+	if m != nil && m.DefaultedSint64 != nil {
+		return *m.DefaultedSint64
+	}
+	return Default_Message_DefaultedSint64
+}
+
+func (m *Message) GetDefaultedUint64() uint64 {
+	if m != nil && m.DefaultedUint64 != nil {
+		return *m.DefaultedUint64
+	}
+	return Default_Message_DefaultedUint64
+}
+
+func (m *Message) GetDefaultedFixed32() uint32 {
+	if m != nil && m.DefaultedFixed32 != nil {
+		return *m.DefaultedFixed32
+	}
+	return Default_Message_DefaultedFixed32
+}
+
+func (m *Message) GetDefaultedSfixed32() int32 {
+	if m != nil && m.DefaultedSfixed32 != nil {
+		return *m.DefaultedSfixed32
+	}
+	return Default_Message_DefaultedSfixed32
+}
+
+func (m *Message) GetDefaultedFloat() float32 {
+	if m != nil && m.DefaultedFloat != nil {
+		return *m.DefaultedFloat
+	}
+	return Default_Message_DefaultedFloat
+}
+
+func (m *Message) GetDefaultedFixed64() uint64 {
+	if m != nil && m.DefaultedFixed64 != nil {
+		return *m.DefaultedFixed64
+	}
+	return Default_Message_DefaultedFixed64
+}
+
+func (m *Message) GetDefaultedSfixed64() int64 {
+	if m != nil && m.DefaultedSfixed64 != nil {
+		return *m.DefaultedSfixed64
+	}
+	return Default_Message_DefaultedSfixed64
+}
+
+func (m *Message) GetDefaultedDouble() float64 {
+	if m != nil && m.DefaultedDouble != nil {
+		return *m.DefaultedDouble
+	}
+	return Default_Message_DefaultedDouble
+}
+
+func (m *Message) GetDefaultedString() string {
+	if m != nil && m.DefaultedString != nil {
+		return *m.DefaultedString
+	}
+	return Default_Message_DefaultedString
+}
+
+func (m *Message) GetDefaultedBytes() []byte {
+	if m != nil && m.DefaultedBytes != nil {
+		return m.DefaultedBytes
+	}
+	return append([]byte(nil), Default_Message_DefaultedBytes...)
+}
+
+func (m *Message) GetDefaultedChildEnum() Message_ChildEnum {
+	if m != nil && m.DefaultedChildEnum != nil {
+		return *m.DefaultedChildEnum
+	}
+	return Default_Message_DefaultedChildEnum
+}
+
+func (m *Message) GetDefaultedSiblingEnum() SiblingEnum {
+	if m != nil && m.DefaultedSiblingEnum != nil {
+		return *m.DefaultedSiblingEnum
+	}
+	return Default_Message_DefaultedSiblingEnum
+}
+
+func (m *Message) GetRequiredBool() bool {
+	if m != nil && m.RequiredBool != nil {
+		return *m.RequiredBool
+	}
+	return false
+}
+
+func (m *Message) GetRequiredInt32() int32 {
+	if m != nil && m.RequiredInt32 != nil {
+		return *m.RequiredInt32
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredSint32() int32 {
+	if m != nil && m.RequiredSint32 != nil {
+		return *m.RequiredSint32
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredUint32() uint32 {
+	if m != nil && m.RequiredUint32 != nil {
+		return *m.RequiredUint32
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredInt64() int64 {
+	if m != nil && m.RequiredInt64 != nil {
+		return *m.RequiredInt64
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredSint64() int64 {
+	if m != nil && m.RequiredSint64 != nil {
+		return *m.RequiredSint64
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredUint64() uint64 {
+	if m != nil && m.RequiredUint64 != nil {
+		return *m.RequiredUint64
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredFixed32() uint32 {
+	if m != nil && m.RequiredFixed32 != nil {
+		return *m.RequiredFixed32
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredSfixed32() int32 {
+	if m != nil && m.RequiredSfixed32 != nil {
+		return *m.RequiredSfixed32
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredFloat() float32 {
+	if m != nil && m.RequiredFloat != nil {
+		return *m.RequiredFloat
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredFixed64() uint64 {
+	if m != nil && m.RequiredFixed64 != nil {
+		return *m.RequiredFixed64
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredSfixed64() int64 {
+	if m != nil && m.RequiredSfixed64 != nil {
+		return *m.RequiredSfixed64
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredDouble() float64 {
+	if m != nil && m.RequiredDouble != nil {
+		return *m.RequiredDouble
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredString() string {
+	if m != nil && m.RequiredString != nil {
+		return *m.RequiredString
+	}
+	return ""
+}
+
+func (m *Message) GetRequiredBytes() []byte {
+	if m != nil {
+		return m.RequiredBytes
+	}
+	return nil
+}
+
+func (m *Message) GetRequiredChildEnum() Message_ChildEnum {
+	if m != nil && m.RequiredChildEnum != nil {
+		return *m.RequiredChildEnum
+	}
+	return Message_ALPHA
+}
+
+func (m *Message) GetRequiredChildMessage() *Message_ChildMessage {
+	if m != nil {
+		return m.RequiredChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRequiredNamedGroup() *Message_NamedGroup {
+	if m != nil {
+		return m.RequiredNamedGroup
+	}
+	return nil
+}
+
+func (m *Message) GetRequiredSiblingEnum() SiblingEnum {
+	if m != nil && m.RequiredSiblingEnum != nil {
+		return *m.RequiredSiblingEnum
+	}
+	return SiblingEnum_ALPHA
+}
+
+func (m *Message) GetRequiredSiblingMessage() *SiblingMessage {
+	if m != nil {
+		return m.RequiredSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRequiredgroup() *Message_RequiredGroup {
+	if m != nil {
+		return m.Requiredgroup
+	}
+	return nil
+}
+
+func (m *Message) GetRequiredDefaultedBool() bool {
+	if m != nil && m.RequiredDefaultedBool != nil {
+		return *m.RequiredDefaultedBool
+	}
+	return Default_Message_RequiredDefaultedBool
+}
+
+func (m *Message) GetRequiredDefaultedInt32() int32 {
+	if m != nil && m.RequiredDefaultedInt32 != nil {
+		return *m.RequiredDefaultedInt32
+	}
+	return Default_Message_RequiredDefaultedInt32
+}
+
+func (m *Message) GetRequiredDefaultedSint32() int32 {
+	if m != nil && m.RequiredDefaultedSint32 != nil {
+		return *m.RequiredDefaultedSint32
+	}
+	return Default_Message_RequiredDefaultedSint32
+}
+
+func (m *Message) GetRequiredDefaultedUint32() uint32 {
+	if m != nil && m.RequiredDefaultedUint32 != nil {
+		return *m.RequiredDefaultedUint32
+	}
+	return Default_Message_RequiredDefaultedUint32
+}
+
+func (m *Message) GetRequiredDefaultedInt64() int64 {
+	if m != nil && m.RequiredDefaultedInt64 != nil {
+		return *m.RequiredDefaultedInt64
+	}
+	return Default_Message_RequiredDefaultedInt64
+}
+
+func (m *Message) GetRequiredDefaultedSint64() int64 {
+	if m != nil && m.RequiredDefaultedSint64 != nil {
+		return *m.RequiredDefaultedSint64
+	}
+	return Default_Message_RequiredDefaultedSint64
+}
+
+func (m *Message) GetRequiredDefaultedUint64() uint64 {
+	if m != nil && m.RequiredDefaultedUint64 != nil {
+		return *m.RequiredDefaultedUint64
+	}
+	return Default_Message_RequiredDefaultedUint64
+}
+
+func (m *Message) GetRequiredDefaultedFixed32() uint32 {
+	if m != nil && m.RequiredDefaultedFixed32 != nil {
+		return *m.RequiredDefaultedFixed32
+	}
+	return Default_Message_RequiredDefaultedFixed32
+}
+
+func (m *Message) GetRequiredDefaultedSfixed32() int32 {
+	if m != nil && m.RequiredDefaultedSfixed32 != nil {
+		return *m.RequiredDefaultedSfixed32
+	}
+	return Default_Message_RequiredDefaultedSfixed32
+}
+
+func (m *Message) GetRequiredDefaultedFloat() float32 {
+	if m != nil && m.RequiredDefaultedFloat != nil {
+		return *m.RequiredDefaultedFloat
+	}
+	return Default_Message_RequiredDefaultedFloat
+}
+
+func (m *Message) GetRequiredDefaultedFixed64() uint64 {
+	if m != nil && m.RequiredDefaultedFixed64 != nil {
+		return *m.RequiredDefaultedFixed64
+	}
+	return Default_Message_RequiredDefaultedFixed64
+}
+
+func (m *Message) GetRequiredDefaultedSfixed64() int64 {
+	if m != nil && m.RequiredDefaultedSfixed64 != nil {
+		return *m.RequiredDefaultedSfixed64
+	}
+	return Default_Message_RequiredDefaultedSfixed64
+}
+
+func (m *Message) GetRequiredDefaultedDouble() float64 {
+	if m != nil && m.RequiredDefaultedDouble != nil {
+		return *m.RequiredDefaultedDouble
+	}
+	return Default_Message_RequiredDefaultedDouble
+}
+
+func (m *Message) GetRequiredDefaultedString() string {
+	if m != nil && m.RequiredDefaultedString != nil {
+		return *m.RequiredDefaultedString
+	}
+	return Default_Message_RequiredDefaultedString
+}
+
+func (m *Message) GetRequiredDefaultedBytes() []byte {
+	if m != nil && m.RequiredDefaultedBytes != nil {
+		return m.RequiredDefaultedBytes
+	}
+	return append([]byte(nil), Default_Message_RequiredDefaultedBytes...)
+}
+
+func (m *Message) GetRequiredDefaultedChildEnum() Message_ChildEnum {
+	if m != nil && m.RequiredDefaultedChildEnum != nil {
+		return *m.RequiredDefaultedChildEnum
+	}
+	return Default_Message_RequiredDefaultedChildEnum
+}
+
+func (m *Message) GetRequiredDefaultedSiblingEnum() SiblingEnum {
+	if m != nil && m.RequiredDefaultedSiblingEnum != nil {
+		return *m.RequiredDefaultedSiblingEnum
+	}
+	return Default_Message_RequiredDefaultedSiblingEnum
+}
+
+func (m *Message) GetRepeatedBool() []bool {
+	if m != nil {
+		return m.RepeatedBool
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedInt32() []int32 {
+	if m != nil {
+		return m.RepeatedInt32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSint32() []int32 {
+	if m != nil {
+		return m.RepeatedSint32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedUint32() []uint32 {
+	if m != nil {
+		return m.RepeatedUint32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedInt64() []int64 {
+	if m != nil {
+		return m.RepeatedInt64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSint64() []int64 {
+	if m != nil {
+		return m.RepeatedSint64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedUint64() []uint64 {
+	if m != nil {
+		return m.RepeatedUint64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedFixed32() []uint32 {
+	if m != nil {
+		return m.RepeatedFixed32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSfixed32() []int32 {
+	if m != nil {
+		return m.RepeatedSfixed32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedFloat() []float32 {
+	if m != nil {
+		return m.RepeatedFloat
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedFixed64() []uint64 {
+	if m != nil {
+		return m.RepeatedFixed64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSfixed64() []int64 {
+	if m != nil {
+		return m.RepeatedSfixed64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedDouble() []float64 {
+	if m != nil {
+		return m.RepeatedDouble
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedString() []string {
+	if m != nil {
+		return m.RepeatedString
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedBytes() [][]byte {
+	if m != nil {
+		return m.RepeatedBytes
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedChildEnum() []Message_ChildEnum {
+	if m != nil {
+		return m.RepeatedChildEnum
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedChildMessage() []*Message_ChildMessage {
+	if m != nil {
+		return m.RepeatedChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedNamedGroup() []*Message_NamedGroup {
+	if m != nil {
+		return m.RepeatedNamedGroup
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSiblingEnum() []SiblingEnum {
+	if m != nil {
+		return m.RepeatedSiblingEnum
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSiblingMessage() []*SiblingMessage {
+	if m != nil {
+		return m.RepeatedSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedgroup() []*Message_RepeatedGroup {
+	if m != nil {
+		return m.Repeatedgroup
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolBool() map[bool]bool {
+	if m != nil {
+		return m.MapBoolBool
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolInt32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolInt32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSint32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolSint32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolUint32() map[bool]uint32 {
+	if m != nil {
+		return m.MapBoolUint32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolInt64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolInt64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSint64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolSint64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolUint64() map[bool]uint64 {
+	if m != nil {
+		return m.MapBoolUint64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFixed32() map[bool]uint32 {
+	if m != nil {
+		return m.MapBoolFixed32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSfixed32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolSfixed32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFloat() map[bool]float32 {
+	if m != nil {
+		return m.MapBoolFloat
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFixed64() map[bool]uint64 {
+	if m != nil {
+		return m.MapBoolFixed64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSfixed64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolSfixed64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolDouble() map[bool]float64 {
+	if m != nil {
+		return m.MapBoolDouble
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolString() map[bool]string {
+	if m != nil {
+		return m.MapBoolString
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolBytes() map[bool][]byte {
+	if m != nil {
+		return m.MapBoolBytes
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolChildEnum() map[bool]Message_ChildEnum {
+	if m != nil {
+		return m.MapBoolChildEnum
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolChildMessage() map[bool]*Message_ChildMessage {
+	if m != nil {
+		return m.MapBoolChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolNamedGroup() map[bool]*Message_NamedGroup {
+	if m != nil {
+		return m.MapBoolNamedGroup
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSiblingEnum() map[bool]SiblingEnum {
+	if m != nil {
+		return m.MapBoolSiblingEnum
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSiblingMessage() map[bool]*SiblingMessage {
+	if m != nil {
+		return m.MapBoolSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetMapInt32Bool() map[int32]bool {
+	if m != nil {
+		return m.MapInt32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapSint32Bool() map[int32]bool {
+	if m != nil {
+		return m.MapSint32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapUint32Bool() map[uint32]bool {
+	if m != nil {
+		return m.MapUint32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapInt64Bool() map[int64]bool {
+	if m != nil {
+		return m.MapInt64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapSint64Bool() map[int64]bool {
+	if m != nil {
+		return m.MapSint64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapUint64Bool() map[uint64]bool {
+	if m != nil {
+		return m.MapUint64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapFixed32Bool() map[uint32]bool {
+	if m != nil {
+		return m.MapFixed32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapStringBool() map[string]bool {
+	if m != nil {
+		return m.MapStringBool
+	}
+	return nil
+}
+
+func (m *Message) GetOneofBool() bool {
+	if x, ok := m.GetOneofUnion().(*Message_OneofBool); ok {
+		return x.OneofBool
+	}
+	return false
+}
+
+func (m *Message) GetOneofInt32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofInt32); ok {
+		return x.OneofInt32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSint32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSint32); ok {
+		return x.OneofSint32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofUint32() uint32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofUint32); ok {
+		return x.OneofUint32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofInt64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofInt64); ok {
+		return x.OneofInt64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSint64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSint64); ok {
+		return x.OneofSint64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofUint64() uint64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofUint64); ok {
+		return x.OneofUint64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFixed32() uint32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFixed32); ok {
+		return x.OneofFixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSfixed32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSfixed32); ok {
+		return x.OneofSfixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFloat() float32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFloat); ok {
+		return x.OneofFloat
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFixed64() uint64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFixed64); ok {
+		return x.OneofFixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSfixed64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSfixed64); ok {
+		return x.OneofSfixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofDouble() float64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofDouble); ok {
+		return x.OneofDouble
+	}
+	return 0
+}
+
+func (m *Message) GetOneofString() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString); ok {
+		return x.OneofString
+	}
+	return ""
+}
+
+func (m *Message) GetOneofBytes() []byte {
+	if x, ok := m.GetOneofUnion().(*Message_OneofBytes); ok {
+		return x.OneofBytes
+	}
+	return nil
+}
+
+func (m *Message) GetOneofChildEnum() Message_ChildEnum {
+	if x, ok := m.GetOneofUnion().(*Message_OneofChildEnum); ok {
+		return x.OneofChildEnum
+	}
+	return Message_ALPHA
+}
+
+func (m *Message) GetOneofChildMessage() *Message_ChildMessage {
+	if x, ok := m.GetOneofUnion().(*Message_OneofChildMessage); ok {
+		return x.OneofChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOneofNamedGroup() *Message_NamedGroup {
+	if x, ok := m.GetOneofUnion().(*Message_OneofNamedGroup); ok {
+		return x.OneofNamedGroup
+	}
+	return nil
+}
+
+func (m *Message) GetOneofSiblingEnum() SiblingEnum {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSiblingEnum); ok {
+		return x.OneofSiblingEnum
+	}
+	return SiblingEnum_ALPHA
+}
+
+func (m *Message) GetOneofSiblingMessage() *SiblingMessage {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSiblingMessage); ok {
+		return x.OneofSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOneofgroup() *Message_OneofGroup {
+	if x, ok := m.GetOneofUnion().(*Message_Oneofgroup); ok {
+		return x.Oneofgroup
+	}
+	return nil
+}
+
+func (m *Message) GetOneofString1() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString1); ok {
+		return x.OneofString1
+	}
+	return ""
+}
+
+func (m *Message) GetOneofString2() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString2); ok {
+		return x.OneofString2
+	}
+	return ""
+}
+
+func (m *Message) GetOneofString3() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString3); ok {
+		return x.OneofString3
+	}
+	return ""
+}
+
+func (m *Message) GetOneofDefaultedBool() bool {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedBool); ok {
+		return x.OneofDefaultedBool
+	}
+	return Default_Message_OneofDefaultedBool
+}
+
+func (m *Message) GetOneofDefaultedInt32() int32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedInt32); ok {
+		return x.OneofDefaultedInt32
+	}
+	return Default_Message_OneofDefaultedInt32
+}
+
+func (m *Message) GetOneofDefaultedSint32() int32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedSint32); ok {
+		return x.OneofDefaultedSint32
+	}
+	return Default_Message_OneofDefaultedSint32
+}
+
+func (m *Message) GetOneofDefaultedUint32() uint32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedUint32); ok {
+		return x.OneofDefaultedUint32
+	}
+	return Default_Message_OneofDefaultedUint32
+}
+
+func (m *Message) GetOneofDefaultedInt64() int64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedInt64); ok {
+		return x.OneofDefaultedInt64
+	}
+	return Default_Message_OneofDefaultedInt64
+}
+
+func (m *Message) GetOneofDefaultedSint64() int64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedSint64); ok {
+		return x.OneofDefaultedSint64
+	}
+	return Default_Message_OneofDefaultedSint64
+}
+
+func (m *Message) GetOneofDefaultedUint64() uint64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedUint64); ok {
+		return x.OneofDefaultedUint64
+	}
+	return Default_Message_OneofDefaultedUint64
+}
+
+func (m *Message) GetOneofDefaultedFixed32() uint32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedFixed32); ok {
+		return x.OneofDefaultedFixed32
+	}
+	return Default_Message_OneofDefaultedFixed32
+}
+
+func (m *Message) GetOneofDefaultedSfixed32() int32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedSfixed32); ok {
+		return x.OneofDefaultedSfixed32
+	}
+	return Default_Message_OneofDefaultedSfixed32
+}
+
+func (m *Message) GetOneofDefaultedFloat() float32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedFloat); ok {
+		return x.OneofDefaultedFloat
+	}
+	return Default_Message_OneofDefaultedFloat
+}
+
+func (m *Message) GetOneofDefaultedFixed64() uint64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedFixed64); ok {
+		return x.OneofDefaultedFixed64
+	}
+	return Default_Message_OneofDefaultedFixed64
+}
+
+func (m *Message) GetOneofDefaultedSfixed64() int64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedSfixed64); ok {
+		return x.OneofDefaultedSfixed64
+	}
+	return Default_Message_OneofDefaultedSfixed64
+}
+
+func (m *Message) GetOneofDefaultedDouble() float64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedDouble); ok {
+		return x.OneofDefaultedDouble
+	}
+	return Default_Message_OneofDefaultedDouble
+}
+
+func (m *Message) GetOneofDefaultedString() string {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedString); ok {
+		return x.OneofDefaultedString
+	}
+	return Default_Message_OneofDefaultedString
+}
+
+func (m *Message) GetOneofDefaultedBytes() []byte {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedBytes); ok {
+		return x.OneofDefaultedBytes
+	}
+	return append([]byte(nil), Default_Message_OneofDefaultedBytes...)
+}
+
+func (m *Message) GetOneofDefaultedChildEnum() Message_ChildEnum {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedChildEnum); ok {
+		return x.OneofDefaultedChildEnum
+	}
+	return Default_Message_OneofDefaultedChildEnum
+}
+
+func (m *Message) GetOneofDefaultedSiblingEnum() SiblingEnum {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedSiblingEnum); ok {
+		return x.OneofDefaultedSiblingEnum
+	}
+	return Default_Message_OneofDefaultedSiblingEnum
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*Message) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+	return _Message_OneofMarshaler, _Message_OneofUnmarshaler, _Message_OneofSizer, []interface{}{
+		(*Message_OneofBool)(nil),
+		(*Message_OneofInt32)(nil),
+		(*Message_OneofSint32)(nil),
+		(*Message_OneofUint32)(nil),
+		(*Message_OneofInt64)(nil),
+		(*Message_OneofSint64)(nil),
+		(*Message_OneofUint64)(nil),
+		(*Message_OneofFixed32)(nil),
+		(*Message_OneofSfixed32)(nil),
+		(*Message_OneofFloat)(nil),
+		(*Message_OneofFixed64)(nil),
+		(*Message_OneofSfixed64)(nil),
+		(*Message_OneofDouble)(nil),
+		(*Message_OneofString)(nil),
+		(*Message_OneofBytes)(nil),
+		(*Message_OneofChildEnum)(nil),
+		(*Message_OneofChildMessage)(nil),
+		(*Message_OneofNamedGroup)(nil),
+		(*Message_OneofSiblingEnum)(nil),
+		(*Message_OneofSiblingMessage)(nil),
+		(*Message_Oneofgroup)(nil),
+		(*Message_OneofString1)(nil),
+		(*Message_OneofString2)(nil),
+		(*Message_OneofString3)(nil),
+		(*Message_OneofDefaultedBool)(nil),
+		(*Message_OneofDefaultedInt32)(nil),
+		(*Message_OneofDefaultedSint32)(nil),
+		(*Message_OneofDefaultedUint32)(nil),
+		(*Message_OneofDefaultedInt64)(nil),
+		(*Message_OneofDefaultedSint64)(nil),
+		(*Message_OneofDefaultedUint64)(nil),
+		(*Message_OneofDefaultedFixed32)(nil),
+		(*Message_OneofDefaultedSfixed32)(nil),
+		(*Message_OneofDefaultedFloat)(nil),
+		(*Message_OneofDefaultedFixed64)(nil),
+		(*Message_OneofDefaultedSfixed64)(nil),
+		(*Message_OneofDefaultedDouble)(nil),
+		(*Message_OneofDefaultedString)(nil),
+		(*Message_OneofDefaultedBytes)(nil),
+		(*Message_OneofDefaultedChildEnum)(nil),
+		(*Message_OneofDefaultedSiblingEnum)(nil),
+	}
+}
+
+func _Message_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*Message)
+	// oneof_union
+	switch x := m.OneofUnion.(type) {
+	case *Message_OneofBool:
+		t := uint64(0)
+		if x.OneofBool {
+			t = 1
+		}
+		b.EncodeVarint(700<<3 | proto.WireVarint)
+		b.EncodeVarint(t)
+	case *Message_OneofInt32:
+		b.EncodeVarint(701<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofInt32))
+	case *Message_OneofSint32:
+		b.EncodeVarint(702<<3 | proto.WireVarint)
+		b.EncodeZigzag32(uint64(x.OneofSint32))
+	case *Message_OneofUint32:
+		b.EncodeVarint(703<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofUint32))
+	case *Message_OneofInt64:
+		b.EncodeVarint(704<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofInt64))
+	case *Message_OneofSint64:
+		b.EncodeVarint(705<<3 | proto.WireVarint)
+		b.EncodeZigzag64(uint64(x.OneofSint64))
+	case *Message_OneofUint64:
+		b.EncodeVarint(706<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofUint64))
+	case *Message_OneofFixed32:
+		b.EncodeVarint(707<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(x.OneofFixed32))
+	case *Message_OneofSfixed32:
+		b.EncodeVarint(708<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(x.OneofSfixed32))
+	case *Message_OneofFloat:
+		b.EncodeVarint(709<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(math.Float32bits(x.OneofFloat)))
+	case *Message_OneofFixed64:
+		b.EncodeVarint(710<<3 | proto.WireFixed64)
+		b.EncodeFixed64(uint64(x.OneofFixed64))
+	case *Message_OneofSfixed64:
+		b.EncodeVarint(711<<3 | proto.WireFixed64)
+		b.EncodeFixed64(uint64(x.OneofSfixed64))
+	case *Message_OneofDouble:
+		b.EncodeVarint(712<<3 | proto.WireFixed64)
+		b.EncodeFixed64(math.Float64bits(x.OneofDouble))
+	case *Message_OneofString:
+		b.EncodeVarint(713<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString)
+	case *Message_OneofBytes:
+		b.EncodeVarint(714<<3 | proto.WireBytes)
+		b.EncodeRawBytes(x.OneofBytes)
+	case *Message_OneofChildEnum:
+		b.EncodeVarint(715<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofChildEnum))
+	case *Message_OneofChildMessage:
+		b.EncodeVarint(716<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.OneofChildMessage); err != nil {
+			return err
+		}
+	case *Message_OneofNamedGroup:
+		b.EncodeVarint(717<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.OneofNamedGroup); err != nil {
+			return err
+		}
+	case *Message_OneofSiblingEnum:
+		b.EncodeVarint(718<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofSiblingEnum))
+	case *Message_OneofSiblingMessage:
+		b.EncodeVarint(719<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.OneofSiblingMessage); err != nil {
+			return err
+		}
+	case *Message_Oneofgroup:
+		b.EncodeVarint(720<<3 | proto.WireStartGroup)
+		if err := b.Marshal(x.Oneofgroup); err != nil {
+			return err
+		}
+		b.EncodeVarint(720<<3 | proto.WireEndGroup)
+	case *Message_OneofString1:
+		b.EncodeVarint(721<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString1)
+	case *Message_OneofString2:
+		b.EncodeVarint(722<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString2)
+	case *Message_OneofString3:
+		b.EncodeVarint(723<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString3)
+	case nil:
+	default:
+		return fmt.Errorf("Message.OneofUnion has unexpected type %T", x)
+	}
+	// oneof_defaulted_union
+	switch x := m.OneofDefaultedUnion.(type) {
+	case *Message_OneofDefaultedBool:
+		t := uint64(0)
+		if x.OneofDefaultedBool {
+			t = 1
+		}
+		b.EncodeVarint(800<<3 | proto.WireVarint)
+		b.EncodeVarint(t)
+	case *Message_OneofDefaultedInt32:
+		b.EncodeVarint(801<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofDefaultedInt32))
+	case *Message_OneofDefaultedSint32:
+		b.EncodeVarint(802<<3 | proto.WireVarint)
+		b.EncodeZigzag32(uint64(x.OneofDefaultedSint32))
+	case *Message_OneofDefaultedUint32:
+		b.EncodeVarint(803<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofDefaultedUint32))
+	case *Message_OneofDefaultedInt64:
+		b.EncodeVarint(804<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofDefaultedInt64))
+	case *Message_OneofDefaultedSint64:
+		b.EncodeVarint(805<<3 | proto.WireVarint)
+		b.EncodeZigzag64(uint64(x.OneofDefaultedSint64))
+	case *Message_OneofDefaultedUint64:
+		b.EncodeVarint(806<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofDefaultedUint64))
+	case *Message_OneofDefaultedFixed32:
+		b.EncodeVarint(807<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(x.OneofDefaultedFixed32))
+	case *Message_OneofDefaultedSfixed32:
+		b.EncodeVarint(808<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(x.OneofDefaultedSfixed32))
+	case *Message_OneofDefaultedFloat:
+		b.EncodeVarint(809<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(math.Float32bits(x.OneofDefaultedFloat)))
+	case *Message_OneofDefaultedFixed64:
+		b.EncodeVarint(810<<3 | proto.WireFixed64)
+		b.EncodeFixed64(uint64(x.OneofDefaultedFixed64))
+	case *Message_OneofDefaultedSfixed64:
+		b.EncodeVarint(811<<3 | proto.WireFixed64)
+		b.EncodeFixed64(uint64(x.OneofDefaultedSfixed64))
+	case *Message_OneofDefaultedDouble:
+		b.EncodeVarint(812<<3 | proto.WireFixed64)
+		b.EncodeFixed64(math.Float64bits(x.OneofDefaultedDouble))
+	case *Message_OneofDefaultedString:
+		b.EncodeVarint(813<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofDefaultedString)
+	case *Message_OneofDefaultedBytes:
+		b.EncodeVarint(814<<3 | proto.WireBytes)
+		b.EncodeRawBytes(x.OneofDefaultedBytes)
+	case *Message_OneofDefaultedChildEnum:
+		b.EncodeVarint(815<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofDefaultedChildEnum))
+	case *Message_OneofDefaultedSiblingEnum:
+		b.EncodeVarint(816<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofDefaultedSiblingEnum))
+	case nil:
+	default:
+		return fmt.Errorf("Message.OneofDefaultedUnion has unexpected type %T", x)
+	}
+	return nil
+}
+
+func _Message_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*Message)
+	switch tag {
+	case 700: // oneof_union.oneof_bool
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofBool{x != 0}
+		return true, err
+	case 701: // oneof_union.oneof_int32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofInt32{int32(x)}
+		return true, err
+	case 702: // oneof_union.oneof_sint32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeZigzag32()
+		m.OneofUnion = &Message_OneofSint32{int32(x)}
+		return true, err
+	case 703: // oneof_union.oneof_uint32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofUint32{uint32(x)}
+		return true, err
+	case 704: // oneof_union.oneof_int64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofInt64{int64(x)}
+		return true, err
+	case 705: // oneof_union.oneof_sint64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeZigzag64()
+		m.OneofUnion = &Message_OneofSint64{int64(x)}
+		return true, err
+	case 706: // oneof_union.oneof_uint64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofUint64{x}
+		return true, err
+	case 707: // oneof_union.oneof_fixed32
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofUnion = &Message_OneofFixed32{uint32(x)}
+		return true, err
+	case 708: // oneof_union.oneof_sfixed32
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofUnion = &Message_OneofSfixed32{int32(x)}
+		return true, err
+	case 709: // oneof_union.oneof_float
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofUnion = &Message_OneofFloat{math.Float32frombits(uint32(x))}
+		return true, err
+	case 710: // oneof_union.oneof_fixed64
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofUnion = &Message_OneofFixed64{x}
+		return true, err
+	case 711: // oneof_union.oneof_sfixed64
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofUnion = &Message_OneofSfixed64{int64(x)}
+		return true, err
+	case 712: // oneof_union.oneof_double
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofUnion = &Message_OneofDouble{math.Float64frombits(x)}
+		return true, err
+	case 713: // oneof_union.oneof_string
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString{x}
+		return true, err
+	case 714: // oneof_union.oneof_bytes
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeRawBytes(true)
+		m.OneofUnion = &Message_OneofBytes{x}
+		return true, err
+	case 715: // oneof_union.oneof_child_enum
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofChildEnum{Message_ChildEnum(x)}
+		return true, err
+	case 716: // oneof_union.oneof_child_message
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(Message_ChildMessage)
+		err := b.DecodeMessage(msg)
+		m.OneofUnion = &Message_OneofChildMessage{msg}
+		return true, err
+	case 717: // oneof_union.oneof_named_group
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(Message_NamedGroup)
+		err := b.DecodeMessage(msg)
+		m.OneofUnion = &Message_OneofNamedGroup{msg}
+		return true, err
+	case 718: // oneof_union.oneof_sibling_enum
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofSiblingEnum{SiblingEnum(x)}
+		return true, err
+	case 719: // oneof_union.oneof_sibling_message
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(SiblingMessage)
+		err := b.DecodeMessage(msg)
+		m.OneofUnion = &Message_OneofSiblingMessage{msg}
+		return true, err
+	case 720: // oneof_union.oneofgroup
+		if wire != proto.WireStartGroup {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(Message_OneofGroup)
+		err := b.DecodeGroup(msg)
+		m.OneofUnion = &Message_Oneofgroup{msg}
+		return true, err
+	case 721: // oneof_union.oneof_string1
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString1{x}
+		return true, err
+	case 722: // oneof_union.oneof_string2
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString2{x}
+		return true, err
+	case 723: // oneof_union.oneof_string3
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString3{x}
+		return true, err
+	case 800: // oneof_defaulted_union.oneof_defaulted_bool
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedBool{x != 0}
+		return true, err
+	case 801: // oneof_defaulted_union.oneof_defaulted_int32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedInt32{int32(x)}
+		return true, err
+	case 802: // oneof_defaulted_union.oneof_defaulted_sint32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeZigzag32()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedSint32{int32(x)}
+		return true, err
+	case 803: // oneof_defaulted_union.oneof_defaulted_uint32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedUint32{uint32(x)}
+		return true, err
+	case 804: // oneof_defaulted_union.oneof_defaulted_int64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedInt64{int64(x)}
+		return true, err
+	case 805: // oneof_defaulted_union.oneof_defaulted_sint64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeZigzag64()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedSint64{int64(x)}
+		return true, err
+	case 806: // oneof_defaulted_union.oneof_defaulted_uint64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedUint64{x}
+		return true, err
+	case 807: // oneof_defaulted_union.oneof_defaulted_fixed32
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedFixed32{uint32(x)}
+		return true, err
+	case 808: // oneof_defaulted_union.oneof_defaulted_sfixed32
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedSfixed32{int32(x)}
+		return true, err
+	case 809: // oneof_defaulted_union.oneof_defaulted_float
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedFloat{math.Float32frombits(uint32(x))}
+		return true, err
+	case 810: // oneof_defaulted_union.oneof_defaulted_fixed64
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedFixed64{x}
+		return true, err
+	case 811: // oneof_defaulted_union.oneof_defaulted_sfixed64
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedSfixed64{int64(x)}
+		return true, err
+	case 812: // oneof_defaulted_union.oneof_defaulted_double
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedDouble{math.Float64frombits(x)}
+		return true, err
+	case 813: // oneof_defaulted_union.oneof_defaulted_string
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedString{x}
+		return true, err
+	case 814: // oneof_defaulted_union.oneof_defaulted_bytes
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeRawBytes(true)
+		m.OneofDefaultedUnion = &Message_OneofDefaultedBytes{x}
+		return true, err
+	case 815: // oneof_defaulted_union.oneof_defaulted_child_enum
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedChildEnum{Message_ChildEnum(x)}
+		return true, err
+	case 816: // oneof_defaulted_union.oneof_defaulted_sibling_enum
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedSiblingEnum{SiblingEnum(x)}
+		return true, err
+	default:
+		return false, nil
+	}
+}
+
+func _Message_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*Message)
+	// oneof_union
+	switch x := m.OneofUnion.(type) {
+	case *Message_OneofBool:
+		n += proto.SizeVarint(700<<3 | proto.WireVarint)
+		n += 1
+	case *Message_OneofInt32:
+		n += proto.SizeVarint(701<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofInt32))
+	case *Message_OneofSint32:
+		n += proto.SizeVarint(702<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64((uint32(x.OneofSint32) << 1) ^ uint32((int32(x.OneofSint32) >> 31))))
+	case *Message_OneofUint32:
+		n += proto.SizeVarint(703<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofUint32))
+	case *Message_OneofInt64:
+		n += proto.SizeVarint(704<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofInt64))
+	case *Message_OneofSint64:
+		n += proto.SizeVarint(705<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(uint64(x.OneofSint64<<1) ^ uint64((int64(x.OneofSint64) >> 63))))
+	case *Message_OneofUint64:
+		n += proto.SizeVarint(706<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofUint64))
+	case *Message_OneofFixed32:
+		n += proto.SizeVarint(707<<3 | proto.WireFixed32)
+		n += 4
+	case *Message_OneofSfixed32:
+		n += proto.SizeVarint(708<<3 | proto.WireFixed32)
+		n += 4
+	case *Message_OneofFloat:
+		n += proto.SizeVarint(709<<3 | proto.WireFixed32)
+		n += 4
+	case *Message_OneofFixed64:
+		n += proto.SizeVarint(710<<3 | proto.WireFixed64)
+		n += 8
+	case *Message_OneofSfixed64:
+		n += proto.SizeVarint(711<<3 | proto.WireFixed64)
+		n += 8
+	case *Message_OneofDouble:
+		n += proto.SizeVarint(712<<3 | proto.WireFixed64)
+		n += 8
+	case *Message_OneofString:
+		n += proto.SizeVarint(713<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofString)))
+		n += len(x.OneofString)
+	case *Message_OneofBytes:
+		n += proto.SizeVarint(714<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofBytes)))
+		n += len(x.OneofBytes)
+	case *Message_OneofChildEnum:
+		n += proto.SizeVarint(715<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofChildEnum))
+	case *Message_OneofChildMessage:
+		s := proto.Size(x.OneofChildMessage)
+		n += proto.SizeVarint(716<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *Message_OneofNamedGroup:
+		s := proto.Size(x.OneofNamedGroup)
+		n += proto.SizeVarint(717<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *Message_OneofSiblingEnum:
+		n += proto.SizeVarint(718<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofSiblingEnum))
+	case *Message_OneofSiblingMessage:
+		s := proto.Size(x.OneofSiblingMessage)
+		n += proto.SizeVarint(719<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *Message_Oneofgroup:
+		n += proto.SizeVarint(720<<3 | proto.WireStartGroup)
+		n += proto.Size(x.Oneofgroup)
+		n += proto.SizeVarint(720<<3 | proto.WireEndGroup)
+	case *Message_OneofString1:
+		n += proto.SizeVarint(721<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofString1)))
+		n += len(x.OneofString1)
+	case *Message_OneofString2:
+		n += proto.SizeVarint(722<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofString2)))
+		n += len(x.OneofString2)
+	case *Message_OneofString3:
+		n += proto.SizeVarint(723<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofString3)))
+		n += len(x.OneofString3)
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	// oneof_defaulted_union
+	switch x := m.OneofDefaultedUnion.(type) {
+	case *Message_OneofDefaultedBool:
+		n += proto.SizeVarint(800<<3 | proto.WireVarint)
+		n += 1
+	case *Message_OneofDefaultedInt32:
+		n += proto.SizeVarint(801<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofDefaultedInt32))
+	case *Message_OneofDefaultedSint32:
+		n += proto.SizeVarint(802<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64((uint32(x.OneofDefaultedSint32) << 1) ^ uint32((int32(x.OneofDefaultedSint32) >> 31))))
+	case *Message_OneofDefaultedUint32:
+		n += proto.SizeVarint(803<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofDefaultedUint32))
+	case *Message_OneofDefaultedInt64:
+		n += proto.SizeVarint(804<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofDefaultedInt64))
+	case *Message_OneofDefaultedSint64:
+		n += proto.SizeVarint(805<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(uint64(x.OneofDefaultedSint64<<1) ^ uint64((int64(x.OneofDefaultedSint64) >> 63))))
+	case *Message_OneofDefaultedUint64:
+		n += proto.SizeVarint(806<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofDefaultedUint64))
+	case *Message_OneofDefaultedFixed32:
+		n += proto.SizeVarint(807<<3 | proto.WireFixed32)
+		n += 4
+	case *Message_OneofDefaultedSfixed32:
+		n += proto.SizeVarint(808<<3 | proto.WireFixed32)
+		n += 4
+	case *Message_OneofDefaultedFloat:
+		n += proto.SizeVarint(809<<3 | proto.WireFixed32)
+		n += 4
+	case *Message_OneofDefaultedFixed64:
+		n += proto.SizeVarint(810<<3 | proto.WireFixed64)
+		n += 8
+	case *Message_OneofDefaultedSfixed64:
+		n += proto.SizeVarint(811<<3 | proto.WireFixed64)
+		n += 8
+	case *Message_OneofDefaultedDouble:
+		n += proto.SizeVarint(812<<3 | proto.WireFixed64)
+		n += 8
+	case *Message_OneofDefaultedString:
+		n += proto.SizeVarint(813<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofDefaultedString)))
+		n += len(x.OneofDefaultedString)
+	case *Message_OneofDefaultedBytes:
+		n += proto.SizeVarint(814<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofDefaultedBytes)))
+		n += len(x.OneofDefaultedBytes)
+	case *Message_OneofDefaultedChildEnum:
+		n += proto.SizeVarint(815<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofDefaultedChildEnum))
+	case *Message_OneofDefaultedSiblingEnum:
+		n += proto.SizeVarint(816<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofDefaultedSiblingEnum))
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	return n
+}
+
+var E_Message_ExtensionOptionalBool = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*bool)(nil),
+	Field:         10000,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_optional_bool",
+	Tag:           "varint,10000,opt,name=extension_optional_bool,json=extensionOptionalBool",
+}
+
+var E_Message_ExtensionOptionalInt32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         10001,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_optional_int32",
+	Tag:           "varint,10001,opt,name=extension_optional_int32,json=extensionOptionalInt32",
+}
+
+var E_Message_ExtensionOptionalSint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         10002,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_optional_sint32",
+	Tag:           "zigzag32,10002,opt,name=extension_optional_sint32,json=extensionOptionalSint32",
+}
+
+var E_Message_ExtensionOptionalUint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint32)(nil),
+	Field:         10003,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_optional_uint32",
+	Tag:           "varint,10003,opt,name=extension_optional_uint32,json=extensionOptionalUint32",
+}
+
+var E_Message_ExtensionOptionalInt64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         10004,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_optional_int64",
+	Tag:           "varint,10004,opt,name=extension_optional_int64,json=extensionOptionalInt64",
+}
+
+var E_Message_ExtensionOptionalSint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         10005,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_optional_sint64",
+	Tag:           "zigzag64,10005,opt,name=extension_optional_sint64,json=extensionOptionalSint64",
+}
+
+var E_Message_ExtensionOptionalUint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint64)(nil),
+	Field:         10006,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_optional_uint64",
+	Tag:           "varint,10006,opt,name=extension_optional_uint64,json=extensionOptionalUint64",
+}
+
+var E_Message_ExtensionOptionalFixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint32)(nil),
+	Field:         10007,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_optional_fixed32",
+	Tag:           "fixed32,10007,opt,name=extension_optional_fixed32,json=extensionOptionalFixed32",
+}
+
+var E_Message_ExtensionOptionalSfixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         10008,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_optional_sfixed32",
+	Tag:           "fixed32,10008,opt,name=extension_optional_sfixed32,json=extensionOptionalSfixed32",
+}
+
+var E_Message_ExtensionOptionalFloat = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*float32)(nil),
+	Field:         10009,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_optional_float",
+	Tag:           "fixed32,10009,opt,name=extension_optional_float,json=extensionOptionalFloat",
+}
+
+var E_Message_ExtensionOptionalFixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint64)(nil),
+	Field:         10010,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_optional_fixed64",
+	Tag:           "fixed64,10010,opt,name=extension_optional_fixed64,json=extensionOptionalFixed64",
+}
+
+var E_Message_ExtensionOptionalSfixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         10011,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_optional_sfixed64",
+	Tag:           "fixed64,10011,opt,name=extension_optional_sfixed64,json=extensionOptionalSfixed64",
+}
+
+var E_Message_ExtensionOptionalDouble = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*float64)(nil),
+	Field:         10012,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_optional_double",
+	Tag:           "fixed64,10012,opt,name=extension_optional_double,json=extensionOptionalDouble",
+}
+
+var E_Message_ExtensionOptionalString = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*string)(nil),
+	Field:         10013,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_optional_string",
+	Tag:           "bytes,10013,opt,name=extension_optional_string,json=extensionOptionalString",
+}
+
+var E_Message_ExtensionOptionalBytes = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]byte)(nil),
+	Field:         10014,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_optional_bytes",
+	Tag:           "bytes,10014,opt,name=extension_optional_bytes,json=extensionOptionalBytes",
+}
+
+var E_Message_ExtensionOptionalChildEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*Message_ChildEnum)(nil),
+	Field:         10015,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_optional_child_enum",
+	Tag:           "varint,10015,opt,name=extension_optional_child_enum,json=extensionOptionalChildEnum,enum=google.golang.org.proto2_20160225.Message_ChildEnum",
+}
+
+var E_Message_ExtensionOptionalChildMessage = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*Message_ChildMessage)(nil),
+	Field:         10016,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_optional_child_message",
+	Tag:           "bytes,10016,opt,name=extension_optional_child_message,json=extensionOptionalChildMessage",
+}
+
+var E_Message_ExtensionOptionalNamedGroup = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*Message_NamedGroup)(nil),
+	Field:         10017,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_optional_named_group",
+	Tag:           "bytes,10017,opt,name=extension_optional_named_group,json=extensionOptionalNamedGroup",
+}
+
+var E_Message_ExtensionOptionalSiblingEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*SiblingEnum)(nil),
+	Field:         10018,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_optional_sibling_enum",
+	Tag:           "varint,10018,opt,name=extension_optional_sibling_enum,json=extensionOptionalSiblingEnum,enum=google.golang.org.proto2_20160225.SiblingEnum",
+}
+
+var E_Message_ExtensionOptionalSiblingMessage = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*SiblingMessage)(nil),
+	Field:         10019,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_optional_sibling_message",
+	Tag:           "bytes,10019,opt,name=extension_optional_sibling_message,json=extensionOptionalSiblingMessage",
+}
+
+var E_Message_Extensionoptionalgroup = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*Message_ExtensionOptionalGroup)(nil),
+	Field:         10020,
+	Name:          "google.golang.org.proto2_20160225.Message.extensionoptionalgroup",
+	Tag:           "group,10020,opt,name=ExtensionOptionalGroup,json=extensionoptionalgroup",
+}
+
+var E_Message_ExtensionDefaultedBool = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*bool)(nil),
+	Field:         20000,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_defaulted_bool",
+	Tag:           "varint,20000,opt,name=extension_defaulted_bool,json=extensionDefaultedBool,def=1",
+}
+
+var E_Message_ExtensionDefaultedInt32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         20001,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_defaulted_int32",
+	Tag:           "varint,20001,opt,name=extension_defaulted_int32,json=extensionDefaultedInt32,def=-12345",
+}
+
+var E_Message_ExtensionDefaultedSint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         20002,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_defaulted_sint32",
+	Tag:           "zigzag32,20002,opt,name=extension_defaulted_sint32,json=extensionDefaultedSint32,def=-3200",
+}
+
+var E_Message_ExtensionDefaultedUint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint32)(nil),
+	Field:         20003,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_defaulted_uint32",
+	Tag:           "varint,20003,opt,name=extension_defaulted_uint32,json=extensionDefaultedUint32,def=3200",
+}
+
+var E_Message_ExtensionDefaultedInt64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         20004,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_defaulted_int64",
+	Tag:           "varint,20004,opt,name=extension_defaulted_int64,json=extensionDefaultedInt64,def=-123456789",
+}
+
+var E_Message_ExtensionDefaultedSint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         20005,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_defaulted_sint64",
+	Tag:           "zigzag64,20005,opt,name=extension_defaulted_sint64,json=extensionDefaultedSint64,def=-6400",
+}
+
+var E_Message_ExtensionDefaultedUint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint64)(nil),
+	Field:         20006,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_defaulted_uint64",
+	Tag:           "varint,20006,opt,name=extension_defaulted_uint64,json=extensionDefaultedUint64,def=6400",
+}
+
+var E_Message_ExtensionDefaultedFixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint32)(nil),
+	Field:         20007,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_defaulted_fixed32",
+	Tag:           "fixed32,20007,opt,name=extension_defaulted_fixed32,json=extensionDefaultedFixed32,def=320000",
+}
+
+var E_Message_ExtensionDefaultedSfixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         20008,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_defaulted_sfixed32",
+	Tag:           "fixed32,20008,opt,name=extension_defaulted_sfixed32,json=extensionDefaultedSfixed32,def=-320000",
+}
+
+var E_Message_ExtensionDefaultedFloat = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*float32)(nil),
+	Field:         20009,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_defaulted_float",
+	Tag:           "fixed32,20009,opt,name=extension_defaulted_float,json=extensionDefaultedFloat,def=3.14159",
+}
+
+var E_Message_ExtensionDefaultedFixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint64)(nil),
+	Field:         20010,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_defaulted_fixed64",
+	Tag:           "fixed64,20010,opt,name=extension_defaulted_fixed64,json=extensionDefaultedFixed64,def=640000",
+}
+
+var E_Message_ExtensionDefaultedSfixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         20011,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_defaulted_sfixed64",
+	Tag:           "fixed64,20011,opt,name=extension_defaulted_sfixed64,json=extensionDefaultedSfixed64,def=-640000",
+}
+
+var E_Message_ExtensionDefaultedDouble = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*float64)(nil),
+	Field:         20012,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_defaulted_double",
+	Tag:           "fixed64,20012,opt,name=extension_defaulted_double,json=extensionDefaultedDouble,def=3.14159265359",
+}
+
+var E_Message_ExtensionDefaultedString = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*string)(nil),
+	Field:         20013,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_defaulted_string",
+	Tag:           "bytes,20013,opt,name=extension_defaulted_string,json=extensionDefaultedString,def=hello, \"world!\"\n",
+}
+
+var E_Message_ExtensionDefaultedBytes = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]byte)(nil),
+	Field:         20014,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_defaulted_bytes",
+	Tag:           "bytes,20014,opt,name=extension_defaulted_bytes,json=extensionDefaultedBytes,def=dead\\336\\255\\276\\357beef",
+}
+
+var E_Message_ExtensionDefaultedChildEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*Message_ChildEnum)(nil),
+	Field:         20015,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_defaulted_child_enum",
+	Tag:           "varint,20015,opt,name=extension_defaulted_child_enum,json=extensionDefaultedChildEnum,enum=google.golang.org.proto2_20160225.Message_ChildEnum,def=0",
+}
+
+var E_Message_ExtensionDefaultedSiblingEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*SiblingEnum)(nil),
+	Field:         20016,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_defaulted_sibling_enum",
+	Tag:           "varint,20016,opt,name=extension_defaulted_sibling_enum,json=extensionDefaultedSiblingEnum,enum=google.golang.org.proto2_20160225.SiblingEnum,def=0",
+}
+
+var E_Message_ExtensionRepeatedBool = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]bool)(nil),
+	Field:         30000,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_repeated_bool",
+	Tag:           "varint,30000,rep,name=extension_repeated_bool,json=extensionRepeatedBool",
+}
+
+var E_Message_ExtensionRepeatedInt32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int32)(nil),
+	Field:         30001,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_repeated_int32",
+	Tag:           "varint,30001,rep,name=extension_repeated_int32,json=extensionRepeatedInt32",
+}
+
+var E_Message_ExtensionRepeatedSint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int32)(nil),
+	Field:         30002,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_repeated_sint32",
+	Tag:           "zigzag32,30002,rep,name=extension_repeated_sint32,json=extensionRepeatedSint32",
+}
+
+var E_Message_ExtensionRepeatedUint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]uint32)(nil),
+	Field:         30003,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_repeated_uint32",
+	Tag:           "varint,30003,rep,name=extension_repeated_uint32,json=extensionRepeatedUint32",
+}
+
+var E_Message_ExtensionRepeatedInt64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int64)(nil),
+	Field:         30004,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_repeated_int64",
+	Tag:           "varint,30004,rep,name=extension_repeated_int64,json=extensionRepeatedInt64",
+}
+
+var E_Message_ExtensionRepeatedSint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int64)(nil),
+	Field:         30005,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_repeated_sint64",
+	Tag:           "zigzag64,30005,rep,name=extension_repeated_sint64,json=extensionRepeatedSint64",
+}
+
+var E_Message_ExtensionRepeatedUint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]uint64)(nil),
+	Field:         30006,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_repeated_uint64",
+	Tag:           "varint,30006,rep,name=extension_repeated_uint64,json=extensionRepeatedUint64",
+}
+
+var E_Message_ExtensionRepeatedFixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]uint32)(nil),
+	Field:         30007,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_repeated_fixed32",
+	Tag:           "fixed32,30007,rep,name=extension_repeated_fixed32,json=extensionRepeatedFixed32",
+}
+
+var E_Message_ExtensionRepeatedSfixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int32)(nil),
+	Field:         30008,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_repeated_sfixed32",
+	Tag:           "fixed32,30008,rep,name=extension_repeated_sfixed32,json=extensionRepeatedSfixed32",
+}
+
+var E_Message_ExtensionRepeatedFloat = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]float32)(nil),
+	Field:         30009,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_repeated_float",
+	Tag:           "fixed32,30009,rep,name=extension_repeated_float,json=extensionRepeatedFloat",
+}
+
+var E_Message_ExtensionRepeatedFixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]uint64)(nil),
+	Field:         30010,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_repeated_fixed64",
+	Tag:           "fixed64,30010,rep,name=extension_repeated_fixed64,json=extensionRepeatedFixed64",
+}
+
+var E_Message_ExtensionRepeatedSfixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int64)(nil),
+	Field:         30011,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_repeated_sfixed64",
+	Tag:           "fixed64,30011,rep,name=extension_repeated_sfixed64,json=extensionRepeatedSfixed64",
+}
+
+var E_Message_ExtensionRepeatedDouble = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]float64)(nil),
+	Field:         30012,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_repeated_double",
+	Tag:           "fixed64,30012,rep,name=extension_repeated_double,json=extensionRepeatedDouble",
+}
+
+var E_Message_ExtensionRepeatedString = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]string)(nil),
+	Field:         30013,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_repeated_string",
+	Tag:           "bytes,30013,rep,name=extension_repeated_string,json=extensionRepeatedString",
+}
+
+var E_Message_ExtensionRepeatedBytes = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([][]byte)(nil),
+	Field:         30014,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_repeated_bytes",
+	Tag:           "bytes,30014,rep,name=extension_repeated_bytes,json=extensionRepeatedBytes",
+}
+
+var E_Message_ExtensionRepeatedChildEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]Message_ChildEnum)(nil),
+	Field:         30015,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_repeated_child_enum",
+	Tag:           "varint,30015,rep,name=extension_repeated_child_enum,json=extensionRepeatedChildEnum,enum=google.golang.org.proto2_20160225.Message_ChildEnum",
+}
+
+var E_Message_ExtensionRepeatedChildMessage = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]*Message_ChildMessage)(nil),
+	Field:         30016,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_repeated_child_message",
+	Tag:           "bytes,30016,rep,name=extension_repeated_child_message,json=extensionRepeatedChildMessage",
+}
+
+var E_Message_ExtensionRepeatedNamedGroup = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]*Message_NamedGroup)(nil),
+	Field:         30017,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_repeated_named_group",
+	Tag:           "bytes,30017,rep,name=extension_repeated_named_group,json=extensionRepeatedNamedGroup",
+}
+
+var E_Message_ExtensionRepeatedSiblingEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]SiblingEnum)(nil),
+	Field:         30018,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_repeated_sibling_enum",
+	Tag:           "varint,30018,rep,name=extension_repeated_sibling_enum,json=extensionRepeatedSiblingEnum,enum=google.golang.org.proto2_20160225.SiblingEnum",
+}
+
+var E_Message_ExtensionRepeatedSiblingMessage = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]*SiblingMessage)(nil),
+	Field:         30019,
+	Name:          "google.golang.org.proto2_20160225.Message.extension_repeated_sibling_message",
+	Tag:           "bytes,30019,rep,name=extension_repeated_sibling_message,json=extensionRepeatedSiblingMessage",
+}
+
+var E_Message_Extensionrepeatedgroup = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]*Message_ExtensionRepeatedGroup)(nil),
+	Field:         30020,
+	Name:          "google.golang.org.proto2_20160225.Message.extensionrepeatedgroup",
+	Tag:           "group,30020,rep,name=ExtensionRepeatedGroup,json=extensionrepeatedgroup",
+}
+
+type Message_ChildMessage 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"`
+	F4               *Message `protobuf:"bytes,4,opt,name=f4" json:"f4,omitempty"`
+	XXX_unrecognized []byte   `json:"-"`
+}
+
+func (m *Message_ChildMessage) Reset()                    { *m = Message_ChildMessage{} }
+func (m *Message_ChildMessage) String() string            { return proto.CompactTextString(m) }
+func (*Message_ChildMessage) ProtoMessage()               {}
+func (*Message_ChildMessage) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1, 0} }
+
+func (m *Message_ChildMessage) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_ChildMessage) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_ChildMessage) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+func (m *Message_ChildMessage) GetF4() *Message {
+	if m != nil {
+		return m.F4
+	}
+	return nil
+}
+
+type Message_NamedGroup 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"`
+	F4               *Message `protobuf:"bytes,4,opt,name=f4" json:"f4,omitempty"`
+	XXX_unrecognized []byte   `json:"-"`
+}
+
+func (m *Message_NamedGroup) Reset()                    { *m = Message_NamedGroup{} }
+func (m *Message_NamedGroup) String() string            { return proto.CompactTextString(m) }
+func (*Message_NamedGroup) ProtoMessage()               {}
+func (*Message_NamedGroup) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1, 1} }
+
+func (m *Message_NamedGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_NamedGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_NamedGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+func (m *Message_NamedGroup) GetF4() *Message {
+	if m != nil {
+		return m.F4
+	}
+	return nil
+}
+
+type Message_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_unrecognized []byte   `json:"-"`
+}
+
+func (m *Message_OptionalGroup) Reset()                    { *m = Message_OptionalGroup{} }
+func (m *Message_OptionalGroup) String() string            { return proto.CompactTextString(m) }
+func (*Message_OptionalGroup) ProtoMessage()               {}
+func (*Message_OptionalGroup) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1, 2} }
+
+func (m *Message_OptionalGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_OptionalGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_OptionalGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message_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_unrecognized []byte   `json:"-"`
+}
+
+func (m *Message_RequiredGroup) Reset()                    { *m = Message_RequiredGroup{} }
+func (m *Message_RequiredGroup) String() string            { return proto.CompactTextString(m) }
+func (*Message_RequiredGroup) ProtoMessage()               {}
+func (*Message_RequiredGroup) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1, 3} }
+
+func (m *Message_RequiredGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_RequiredGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_RequiredGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message_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_unrecognized []byte   `json:"-"`
+}
+
+func (m *Message_RepeatedGroup) Reset()                    { *m = Message_RepeatedGroup{} }
+func (m *Message_RepeatedGroup) String() string            { return proto.CompactTextString(m) }
+func (*Message_RepeatedGroup) ProtoMessage()               {}
+func (*Message_RepeatedGroup) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1, 4} }
+
+func (m *Message_RepeatedGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_RepeatedGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_RepeatedGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message_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_unrecognized []byte   `json:"-"`
+}
+
+func (m *Message_OneofGroup) Reset()                    { *m = Message_OneofGroup{} }
+func (m *Message_OneofGroup) String() string            { return proto.CompactTextString(m) }
+func (*Message_OneofGroup) ProtoMessage()               {}
+func (*Message_OneofGroup) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1, 33} }
+
+func (m *Message_OneofGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_OneofGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_OneofGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message_ExtensionOptionalGroup 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_unrecognized []byte   `json:"-"`
+}
+
+func (m *Message_ExtensionOptionalGroup) Reset()         { *m = Message_ExtensionOptionalGroup{} }
+func (m *Message_ExtensionOptionalGroup) String() string { return proto.CompactTextString(m) }
+func (*Message_ExtensionOptionalGroup) ProtoMessage()    {}
+func (*Message_ExtensionOptionalGroup) Descriptor() ([]byte, []int) {
+	return fileDescriptor0, []int{1, 34}
+}
+
+func (m *Message_ExtensionOptionalGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_ExtensionOptionalGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_ExtensionOptionalGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message_ExtensionRepeatedGroup 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_unrecognized []byte   `json:"-"`
+}
+
+func (m *Message_ExtensionRepeatedGroup) Reset()         { *m = Message_ExtensionRepeatedGroup{} }
+func (m *Message_ExtensionRepeatedGroup) String() string { return proto.CompactTextString(m) }
+func (*Message_ExtensionRepeatedGroup) ProtoMessage()    {}
+func (*Message_ExtensionRepeatedGroup) Descriptor() ([]byte, []int) {
+	return fileDescriptor0, []int{1, 35}
+}
+
+func (m *Message_ExtensionRepeatedGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_ExtensionRepeatedGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_ExtensionRepeatedGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*SiblingMessage)(nil), "google.golang.org.proto2_20160225.SiblingMessage")
+	proto.RegisterType((*Message)(nil), "google.golang.org.proto2_20160225.Message")
+	proto.RegisterType((*Message_ChildMessage)(nil), "google.golang.org.proto2_20160225.Message.ChildMessage")
+	proto.RegisterType((*Message_NamedGroup)(nil), "google.golang.org.proto2_20160225.Message.NamedGroup")
+	proto.RegisterType((*Message_OptionalGroup)(nil), "google.golang.org.proto2_20160225.Message.OptionalGroup")
+	proto.RegisterType((*Message_RequiredGroup)(nil), "google.golang.org.proto2_20160225.Message.RequiredGroup")
+	proto.RegisterType((*Message_RepeatedGroup)(nil), "google.golang.org.proto2_20160225.Message.RepeatedGroup")
+	proto.RegisterType((*Message_OneofGroup)(nil), "google.golang.org.proto2_20160225.Message.OneofGroup")
+	proto.RegisterType((*Message_ExtensionOptionalGroup)(nil), "google.golang.org.proto2_20160225.Message.ExtensionOptionalGroup")
+	proto.RegisterType((*Message_ExtensionRepeatedGroup)(nil), "google.golang.org.proto2_20160225.Message.ExtensionRepeatedGroup")
+	proto.RegisterEnum("google.golang.org.proto2_20160225.SiblingEnum", SiblingEnum_name, SiblingEnum_value)
+	proto.RegisterEnum("google.golang.org.proto2_20160225.Message_ChildEnum", Message_ChildEnum_name, Message_ChildEnum_value)
+	proto.RegisterExtension(E_Message_ExtensionOptionalBool)
+	proto.RegisterExtension(E_Message_ExtensionOptionalInt32)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSint32)
+	proto.RegisterExtension(E_Message_ExtensionOptionalUint32)
+	proto.RegisterExtension(E_Message_ExtensionOptionalInt64)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSint64)
+	proto.RegisterExtension(E_Message_ExtensionOptionalUint64)
+	proto.RegisterExtension(E_Message_ExtensionOptionalFixed32)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSfixed32)
+	proto.RegisterExtension(E_Message_ExtensionOptionalFloat)
+	proto.RegisterExtension(E_Message_ExtensionOptionalFixed64)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSfixed64)
+	proto.RegisterExtension(E_Message_ExtensionOptionalDouble)
+	proto.RegisterExtension(E_Message_ExtensionOptionalString)
+	proto.RegisterExtension(E_Message_ExtensionOptionalBytes)
+	proto.RegisterExtension(E_Message_ExtensionOptionalChildEnum)
+	proto.RegisterExtension(E_Message_ExtensionOptionalChildMessage)
+	proto.RegisterExtension(E_Message_ExtensionOptionalNamedGroup)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSiblingEnum)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSiblingMessage)
+	proto.RegisterExtension(E_Message_Extensionoptionalgroup)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedBool)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedInt32)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedSint32)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedUint32)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedInt64)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedSint64)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedUint64)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedFixed32)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedSfixed32)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedFloat)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedFixed64)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedSfixed64)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedDouble)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedString)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedBytes)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedChildEnum)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedSiblingEnum)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedBool)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedInt32)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSint32)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedUint32)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedInt64)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSint64)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedUint64)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedFixed32)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSfixed32)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedFloat)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedFixed64)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSfixed64)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedDouble)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedString)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedBytes)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedChildEnum)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedChildMessage)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedNamedGroup)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSiblingEnum)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSiblingMessage)
+	proto.RegisterExtension(E_Message_Extensionrepeatedgroup)
+}
+
+var fileDescriptor0 = []byte{
+	// 4469 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x5c, 0x69, 0x70, 0x23, 0xc7,
+	0x75, 0xe6, 0x00, 0x04, 0xb8, 0xec, 0x25, 0x48, 0x70, 0x76, 0x97, 0x9c, 0xa5, 0xa4, 0x08, 0x5e,
+	0x3b, 0x0e, 0xa2, 0x68, 0xb9, 0xe4, 0xb0, 0xd9, 0x2b, 0x21, 0x3a, 0xbc, 0x94, 0x56, 0x86, 0x1c,
+	0x0b, 0x72, 0x8d, 0x6a, 0x53, 0xa9, 0x94, 0x2a, 0x0c, 0x77, 0x09, 0x70, 0x29, 0xe1, 0xa0, 0x48,
+	0x40, 0xd2, 0xc6, 0x4e, 0x69, 0xe3, 0x9c, 0x3f, 0xe5, 0xfb, 0x82, 0x6d, 0x59, 0xb7, 0x2d, 0x69,
+	0x25, 0xdf, 0x97, 0x2e, 0x1f, 0x49, 0xe4, 0xfb, 0xca, 0xe1, 0x5c, 0xce, 0x7d, 0x39, 0xf7, 0x7d,
+	0x1f, 0xd5, 0xfd, 0xba, 0xa7, 0xbb, 0x67, 0x7a, 0x40, 0xf6, 0xc0, 0xa5, 0x1f, 0xaa, 0xd2, 0x36,
+	0x5e, 0xbf, 0xaf, 0xdf, 0x87, 0x7e, 0xef, 0x7d, 0xec, 0x99, 0x06, 0x7a, 0xe9, 0xd6, 0x76, 0xa7,
+	0xdb, 0xf1, 0x57, 0xfd, 0x85, 0x45, 0xb2, 0xe0, 0xfb, 0xcb, 0xab, 0x7e, 0xe3, 0xcc, 0xc2, 0xf2,
+	0xd2, 0x99, 0xe5, 0x63, 0xdd, 0xfa, 0x4e, 0x77, 0x9e, 0x7d, 0xea, 0xbe, 0x64, 0xa3, 0xd3, 0xd9,
+	0x68, 0xd6, 0xe7, 0x37, 0x3a, 0xcd, 0xb5, 0xf6, 0xc6, 0x7c, 0x67, 0x7b, 0x63, 0x3e, 0x32, 0xed,
+	0xc8, 0xeb, 0xd0, 0xe4, 0x2d, 0x9b, 0xa7, 0x9b, 0x9b, 0xed, 0x8d, 0x9b, 0xea, 0x3b, 0x3b, 0x6b,
+	0x1b, 0x75, 0x77, 0x12, 0x65, 0x1a, 0x8b, 0x9e, 0x53, 0x72, 0xca, 0xe3, 0x41, 0xa6, 0xb1, 0xc8,
+	0xfe, 0xed, 0x7b, 0x99, 0x52, 0x86, 0xfd, 0xdb, 0x67, 0xff, 0x5e, 0xf2, 0xb2, 0xa5, 0x2c, 0xfb,
+	0xf7, 0x92, 0x5b, 0x41, 0x99, 0x06, 0xf6, 0x46, 0x4b, 0x4e, 0x79, 0xbf, 0x7f, 0xd9, 0xfc, 0xae,
+	0x88, 0xf3, 0x1c, 0x27, 0xc8, 0x34, 0xf0, 0x91, 0xef, 0x3c, 0xe6, 0xa0, 0x31, 0x01, 0x7c, 0x0a,
+	0xa1, 0xf6, 0x5a, 0xab, 0xbe, 0xbe, 0xb1, 0xdd, 0xe9, 0x6d, 0xb1, 0x05, 0x20, 0x7f, 0x79, 0xef,
+	0x0e, 0xe7, 0x6b, 0x74, 0xf2, 0x2b, 0xe9, 0xe4, 0x40, 0x71, 0xe4, 0xbe, 0x14, 0x15, 0x3a, 0x5b,
+	0xdd, 0xcd, 0x4e, 0x7b, 0xad, 0xb9, 0x7a, 0xba, 0xd3, 0x69, 0x7a, 0xeb, 0x25, 0xa7, 0xbc, 0x2f,
+	0x98, 0x10, 0x83, 0x2b, 0x9d, 0x4e, 0xd3, 0xfd, 0x7e, 0x34, 0x19, 0x1a, 0x6d, 0xb6, 0xbb, 0x4b,
+	0xbe, 0x57, 0x2f, 0x39, 0xe5, 0x5c, 0x10, 0x4e, 0xbd, 0x91, 0x0e, 0xba, 0x3f, 0x80, 0xa6, 0x42,
+	0xb3, 0x1d, 0xb0, 0x6b, 0x94, 0x9c, 0xf2, 0x74, 0x10, 0xce, 0xbe, 0x65, 0x33, 0x66, 0xd8, 0x03,
+	0xc3, 0x8d, 0x92, 0x53, 0x2e, 0x48, 0xc3, 0x53, 0x60, 0x18, 0x01, 0x26, 0xd8, 0x3b, 0x5b, 0x72,
+	0xca, 0x59, 0x0d, 0x98, 0xe0, 0x18, 0x30, 0xc1, 0xde, 0x66, 0xc9, 0x29, 0xbb, 0x3a, 0x70, 0xc4,
+	0xb0, 0x07, 0x86, 0xb7, 0x95, 0x9c, 0xf2, 0xa8, 0x0e, 0x4c, 0xb0, 0xfb, 0x83, 0xa8, 0x18, 0x1a,
+	0x36, 0x36, 0xef, 0xae, 0xaf, 0x2f, 0xf9, 0xde, 0xed, 0x25, 0xa7, 0x3c, 0x16, 0x84, 0x0e, 0x6e,
+	0x80, 0x61, 0xf7, 0x87, 0xd0, 0xb4, 0x04, 0x17, 0xb6, 0xcd, 0x92, 0x53, 0x9e, 0x0a, 0x42, 0x1f,
+	0xb7, 0xf0, 0x71, 0x2d, 0xa0, 0x46, 0xb3, 0xb3, 0xd6, 0xf5, 0x5a, 0x25, 0xa7, 0x9c, 0x91, 0x01,
+	0xdd, 0x40, 0x07, 0xe3, 0xf0, 0x04, 0x7b, 0xed, 0x92, 0x53, 0xce, 0x47, 0xe0, 0x09, 0x36, 0xc0,
+	0x13, 0xec, 0x75, 0x4a, 0x4e, 0xb9, 0x18, 0x85, 0x8f, 0xc4, 0xbf, 0xde, 0xe9, 0x9d, 0x6e, 0xd6,
+	0xbd, 0xad, 0x92, 0x53, 0x76, 0x64, 0xfc, 0xd7, 0xb3, 0x51, 0x9d, 0xd1, 0xee, 0xf6, 0x66, 0x7b,
+	0xc3, 0xbb, 0x83, 0xed, 0x79, 0xc9, 0x28, 0x1b, 0xd5, 0x02, 0x3a, 0x7d, 0xae, 0x5b, 0xdf, 0xf1,
+	0xb6, 0x4b, 0x4e, 0x79, 0x42, 0x06, 0xb4, 0x42, 0x07, 0xdd, 0x75, 0x74, 0x20, 0x34, 0x3b, 0x73,
+	0x76, 0xb3, 0xb9, 0xbe, 0x5a, 0x6f, 0xf7, 0x5a, 0xde, 0x4e, 0xc9, 0x29, 0x4f, 0xfa, 0xd8, 0x62,
+	0x1b, 0x5f, 0x47, 0x27, 0x9f, 0x6c, 0xf7, 0x5a, 0x41, 0x18, 0x76, 0x38, 0xe4, 0xb6, 0xd0, 0x4c,
+	0x04, 0xa5, 0x05, 0xd3, 0xbc, 0x2e, 0x4b, 0xc0, 0xe3, 0xb6, 0x40, 0x22, 0x1b, 0x0f, 0x6a, 0x58,
+	0x22, 0x25, 0x37, 0x50, 0x38, 0xbe, 0xca, 0x52, 0x6a, 0x15, 0x92, 0xb3, 0xc7, 0xc0, 0x52, 0x26,
+	0xa7, 0x2b, 0x5c, 0xca, 0x31, 0xf7, 0x34, 0x3a, 0xa4, 0xec, 0x6f, 0x56, 0x8f, 0x80, 0xbf, 0x3b,
+	0x19, 0x7f, 0xf3, 0x7b, 0x40, 0xe2, 0x65, 0x8c, 0x31, 0x77, 0x40, 0x66, 0x45, 0x38, 0xe8, 0xde,
+	0x8e, 0xbc, 0x18, 0x86, 0x60, 0xef, 0x2e, 0x16, 0xd0, 0xe2, 0xde, 0x61, 0x04, 0x6f, 0x33, 0x11,
+	0x24, 0xc1, 0xdc, 0x4f, 0xc8, 0xaa, 0x03, 0x94, 0xdd, 0xcd, 0xea, 0xd9, 0x15, 0x16, 0x94, 0xdd,
+	0xcc, 0xe7, 0x03, 0x6b, 0xba, 0x3b, 0xf7, 0x72, 0x34, 0xb9, 0x5e, 0x6f, 0xac, 0xf5, 0x9a, 0xdd,
+	0xfa, 0x3a, 0x94, 0xb5, 0x17, 0x68, 0xc5, 0xdc, 0x57, 0x19, 0xed, 0x6e, 0xf7, 0xea, 0x41, 0x21,
+	0xfc, 0x90, 0x95, 0xb7, 0x05, 0x34, 0x25, 0xad, 0xa1, 0x1c, 0x7d, 0x81, 0x9a, 0xe7, 0x2a, 0xf9,
+	0xa3, 0x8b, 0xfe, 0x12, 0x5e, 0x0e, 0xa4, 0x37, 0xa8, 0x74, 0x8b, 0xa8, 0x28, 0x67, 0xf0, 0x52,
+	0xf7, 0x45, 0x3a, 0x65, 0xba, 0x92, 0x3b, 0xba, 0xe4, 0x2f, 0x2c, 0x04, 0xd2, 0x23, 0xaf, 0x79,
+	0x0b, 0xea, 0x14, 0x5e, 0xf4, 0xbe, 0x44, 0xa7, 0x14, 0x2a, 0xa3, 0x91, 0x19, 0xbc, 0xf8, 0xe1,
+	0xc8, 0xb2, 0x08, 0xf6, 0xbe, 0x4c, 0x27, 0x64, 0x2b, 0x08, 0x96, 0x45, 0x8e, 0x5f, 0x71, 0xa5,
+	0xbe, 0x34, 0x82, 0xe3, 0x4b, 0x23, 0xd8, 0xfb, 0x0a, 0x9d, 0xe6, 0x56, 0x72, 0x47, 0x09, 0x8e,
+	0x2d, 0x8d, 0xe0, 0xf8, 0xd2, 0x08, 0xf6, 0xbe, 0x4a, 0xa7, 0x8c, 0x56, 0x46, 0x23, 0x33, 0x78,
+	0x79, 0xc4, 0x68, 0x5a, 0xce, 0x10, 0x35, 0xef, 0x6b, 0x74, 0xca, 0x58, 0x25, 0x4f, 0xa3, 0x59,
+	0x58, 0x08, 0xa4, 0x4f, 0x51, 0x29, 0x8f, 0x23, 0x57, 0x59, 0x9a, 0x98, 0xf6, 0x75, 0x3a, 0x6d,
+	0xaa, 0x32, 0x76, 0x94, 0xcf, 0x93, 0x9e, 0xc3, 0xaa, 0xb9, 0xa8, 0x32, 0x01, 0x65, 0xf3, 0x1b,
+	0x74, 0x56, 0xa6, 0x32, 0xb6, 0x34, 0xbf, 0x88, 0x17, 0x97, 0x55, 0x1a, 0xa0, 0x82, 0xc6, 0x57,
+	0x48, 0xb0, 0xf7, 0x4d, 0x3a, 0x29, 0x5f, 0xc9, 0xd3, 0xa0, 0xe2, 0x2b, 0x24, 0xd8, 0xb4, 0x42,
+	0x82, 0xbd, 0x6f, 0xd1, 0x69, 0xc5, 0xca, 0xd8, 0x51, 0x3e, 0x2f, 0xba, 0x42, 0x82, 0xdd, 0x2b,
+	0x55, 0x0a, 0x79, 0x65, 0xfd, 0x35, 0x3a, 0xcd, 0xa9, 0x14, 0xf8, 0x12, 0x7d, 0xb2, 0xbc, 0xb4,
+	0x7c, 0xa5, 0xc2, 0x25, 0x2f, 0xb5, 0x57, 0x69, 0x5f, 0x18, 0xd4, 0xda, 0x5f, 0x67, 0x02, 0xa3,
+	0x52, 0x3c, 0x5b, 0x6f, 0x36, 0x3b, 0x97, 0x97, 0x8e, 0xdc, 0xd5, 0xd9, 0x6e, 0xae, 0xbf, 0xe4,
+	0x08, 0x52, 0xbf, 0x3b, 0xa8, 0xbf, 0x2b, 0x2a, 0x35, 0x50, 0x80, 0x7f, 0x83, 0x4e, 0x9e, 0xa8,
+	0x78, 0xeb, 0xf5, 0xb5, 0xf5, 0x5b, 0x97, 0x96, 0xc8, 0xad, 0xfe, 0xf2, 0xf2, 0xad, 0xfe, 0x71,
+	0x72, 0xeb, 0xd2, 0xf2, 0xf1, 0xd3, 0xf5, 0x7a, 0x43, 0xe1, 0x0a, 0x8a, 0x73, 0x1b, 0x1d, 0x94,
+	0x3e, 0x94, 0xea, 0xfc, 0x9b, 0x4e, 0xfa, 0xf2, 0x5c, 0xc9, 0x9d, 0x78, 0xf5, 0x6b, 0xaa, 0x27,
+	0x02, 0xc9, 0xa7, 0x2c, 0xd3, 0x4d, 0x34, 0xa3, 0x6e, 0x51, 0xa5, 0x9e, 0x7d, 0xdb, 0x49, 0x53,
+	0xd0, 0x04, 0xd6, 0x41, 0x65, 0x63, 0xcb, 0xc2, 0xf6, 0x32, 0x54, 0xd8, 0xae, 0xdf, 0xd1, 0xdb,
+	0xdc, 0x16, 0xa5, 0xe0, 0x71, 0xaa, 0xd6, 0xf6, 0x05, 0x13, 0x62, 0x94, 0xd5, 0x80, 0x97, 0xa3,
+	0xc9, 0xd0, 0x0a, 0x92, 0xf3, 0x09, 0x6a, 0x96, 0x0b, 0xc2, 0xc9, 0x90, 0xf9, 0x65, 0x34, 0x15,
+	0xda, 0xf1, 0xc4, 0xbf, 0x40, 0x0d, 0xa7, 0x83, 0x70, 0x3e, 0x4f, 0x78, 0xd5, 0x92, 0xe7, 0xfb,
+	0x93, 0xd4, 0xb2, 0x20, 0x2d, 0x79, 0xa2, 0x47, 0xb0, 0x09, 0xf6, 0x9e, 0xa2, 0x86, 0x59, 0x0d,
+	0x9b, 0xe0, 0x18, 0x36, 0xc1, 0xde, 0x07, 0xa9, 0xa1, 0xab, 0x63, 0x47, 0x2c, 0x79, 0x42, 0x7f,
+	0x88, 0x5a, 0x8e, 0xea, 0xd8, 0x04, 0xbb, 0x97, 0xa1, 0x62, 0x68, 0x29, 0x32, 0xf2, 0xc3, 0xd4,
+	0x74, 0x2c, 0x08, 0x5d, 0x88, 0xfc, 0xbd, 0x1c, 0x4d, 0x4b, 0x7c, 0x61, 0xfc, 0x11, 0x6a, 0x3c,
+	0x15, 0x84, 0x5e, 0xc2, 0xa4, 0x55, 0xa3, 0x82, 0x9c, 0xfd, 0x28, 0x35, 0xcd, 0xc8, 0xa8, 0x20,
+	0x53, 0x63, 0x2b, 0x20, 0xd8, 0xfb, 0x18, 0xb5, 0xcc, 0x47, 0x56, 0x40, 0xb0, 0x61, 0x05, 0x04,
+	0x7b, 0x1f, 0xa7, 0xc6, 0xc5, 0xe8, 0x0a, 0x22, 0x2c, 0xf0, 0x9c, 0xfc, 0x04, 0xb5, 0x75, 0x24,
+	0x0b, 0x3c, 0x07, 0x35, 0x66, 0x21, 0x05, 0x3f, 0x09, 0x9a, 0x5e, 0x32, 0x0b, 0xf9, 0xa6, 0x46,
+	0x05, 0xe9, 0xf6, 0x29, 0x6a, 0x38, 0x21, 0xa3, 0x82, 0x9c, 0xaa, 0xa3, 0x03, 0xa1, 0x9d, 0x92,
+	0x52, 0x9f, 0xa6, 0xc6, 0xa9, 0x15, 0x8f, 0xf0, 0x28, 0x53, 0xa9, 0x8d, 0x66, 0x22, 0x30, 0xa2,
+	0x67, 0x3f, 0x4d, 0x91, 0x86, 0x91, 0x3c, 0x1a, 0x98, 0x68, 0xdc, 0x67, 0x51, 0x38, 0xae, 0x49,
+	0x9e, 0x67, 0x00, 0x2d, 0xad, 0xe6, 0x11, 0x3e, 0x15, 0xcd, 0x73, 0x06, 0x1d, 0x52, 0x36, 0xbb,
+	0x52, 0x23, 0x9e, 0x05, 0x0a, 0xad, 0x45, 0x8f, 0x4c, 0x11, 0x59, 0x1b, 0x9a, 0xc8, 0x8b, 0x81,
+	0x08, 0x02, 0x9f, 0x83, 0x90, 0xd2, 0xa8, 0x9e, 0x08, 0x94, 0x20, 0x6f, 0x55, 0x56, 0x22, 0x60,
+	0xed, 0x79, 0x0a, 0x61, 0x27, 0x7b, 0x02, 0xee, 0x80, 0xcb, 0x1e, 0xcd, 0x9f, 0x7b, 0x35, 0x9a,
+	0x95, 0x1b, 0x5e, 0xd7, 0x3f, 0xf7, 0x66, 0x69, 0xd1, 0xe3, 0xfa, 0x27, 0x64, 0xf6, 0x7a, 0x4d,
+	0x07, 0x9d, 0x50, 0xd8, 0x88, 0x0a, 0xa2, 0x37, 0xd0, 0xf9, 0x52, 0x10, 0xcd, 0xc4, 0x3c, 0x40,
+	0x79, 0x5c, 0x41, 0x87, 0x0d, 0x2e, 0x78, 0xa1, 0x7c, 0x23, 0xf5, 0x11, 0x2a, 0xa4, 0xd9, 0x98,
+	0x0b, 0x5e, 0x38, 0x4f, 0x18, 0x7d, 0xf0, 0x12, 0xfa, 0x26, 0xea, 0x43, 0x48, 0xa6, 0xb8, 0x0b,
+	0x5e, 0x51, 0x4f, 0x26, 0x45, 0x42, 0xb0, 0xf7, 0x66, 0xea, 0x41, 0xd7, 0x50, 0xc6, 0x68, 0x08,
+	0x1e, 0x10, 0x0d, 0xc1, 0xde, 0x5b, 0xa8, 0x9f, 0x50, 0x54, 0x99, 0xa3, 0x21, 0x78, 0x40, 0x34,
+	0x04, 0x7b, 0x6f, 0xa5, 0x3e, 0x84, 0xca, 0x32, 0x47, 0x43, 0xb0, 0x7b, 0x12, 0xcd, 0x19, 0x5c,
+	0x88, 0x02, 0xfc, 0x36, 0xea, 0x43, 0xca, 0x2e, 0x2f, 0xe6, 0x45, 0x94, 0xef, 0x2a, 0xba, 0xc8,
+	0x14, 0x8d, 0xf0, 0xf3, 0x76, 0xea, 0x47, 0xd1, 0x61, 0x87, 0xe3, 0x11, 0x89, 0xd2, 0xbe, 0x62,
+	0xa4, 0x17, 0x8a, 0xfc, 0x3b, 0xa8, 0x1b, 0x45, 0x98, 0xc5, 0xb9, 0x85, 0xb2, 0x3f, 0x20, 0x28,
+	0x82, 0xbd, 0x77, 0x52, 0x2f, 0x52, 0xa9, 0x25, 0x04, 0x45, 0xf0, 0xc0, 0xa0, 0x08, 0xf6, 0xde,
+	0x45, 0xfd, 0x28, 0xd2, 0x2d, 0x29, 0x28, 0x82, 0xdd, 0x57, 0x19, 0xbf, 0x28, 0xde, 0x37, 0xfa,
+	0xd4, 0x4f, 0x4c, 0xcb, 0xc5, 0xbf, 0x31, 0xde, 0x4f, 0x6e, 0x32, 0x6f, 0x1c, 0xe8, 0x2c, 0xef,
+	0xa6, 0xbe, 0x4c, 0xe2, 0xce, 0xb0, 0x87, 0xa0, 0xe9, 0xdc, 0x62, 0xe4, 0x1b, 0xda, 0xcf, 0x7b,
+	0xa8, 0xb7, 0x41, 0x6a, 0x2f, 0xfe, 0x05, 0x40, 0x87, 0xba, 0x07, 0x5d, 0x62, 0x70, 0xaa, 0xf4,
+	0xaa, 0xf7, 0x66, 0xd3, 0xf7, 0x2a, 0x21, 0xc9, 0xe6, 0x62, 0xe0, 0xb2, 0x77, 0xfd, 0x34, 0xba,
+	0xd4, 0x98, 0x5d, 0x4a, 0xad, 0xbf, 0x2f, 0x9b, 0xa6, 0xd6, 0x0b, 0xf0, 0x8b, 0x0d, 0x39, 0x19,
+	0xd1, 0x85, 0x5b, 0xf5, 0xb5, 0xb0, 0x44, 0xfe, 0x73, 0xb6, 0x94, 0x05, 0x5d, 0x08, 0xa3, 0x52,
+	0x17, 0x72, 0x2b, 0xa8, 0x40, 0xff, 0x42, 0xcd, 0x98, 0x2e, 0x84, 0x61, 0x45, 0x17, 0x72, 0x3b,
+	0x5e, 0xee, 0xfe, 0x95, 0x1a, 0x32, 0x5d, 0x08, 0xe3, 0xaa, 0x2e, 0xe4, 0x96, 0xbc, 0xa8, 0xfd,
+	0x1b, 0xb5, 0x2c, 0x48, 0x4b, 0x55, 0x17, 0x4a, 0x6c, 0x82, 0xbd, 0x7f, 0xa7, 0x86, 0x59, 0x0d,
+	0x5b, 0xe8, 0x1c, 0x05, 0x9b, 0x60, 0xef, 0x3f, 0xa8, 0xa1, 0xab, 0x63, 0x47, 0x2c, 0x79, 0x09,
+	0xfa, 0x4f, 0x6a, 0x39, 0xaa, 0x63, 0x0b, 0x5d, 0xc8, 0x2d, 0x45, 0x85, 0xf8, 0x2f, 0x6a, 0xca,
+	0x74, 0x21, 0x7c, 0xa0, 0xe9, 0x42, 0x81, 0x2f, 0x8c, 0xff, 0x9b, 0x1a, 0x33, 0x5d, 0xc8, 0x57,
+	0xa0, 0xe9, 0x42, 0xe1, 0x99, 0x95, 0x8c, 0xff, 0xa1, 0xa6, 0x19, 0x19, 0x95, 0xa2, 0x0b, 0xd5,
+	0x15, 0x10, 0xec, 0xfd, 0x2f, 0xb5, 0xcc, 0x47, 0x56, 0x20, 0x74, 0xa1, 0xb6, 0x02, 0x82, 0xbd,
+	0xff, 0xa3, 0xc6, 0xc5, 0xe8, 0x0a, 0x22, 0x2c, 0xf0, 0xfc, 0x3e, 0x3f, 0x5a, 0xca, 0x82, 0x2e,
+	0x84, 0x71, 0x55, 0x17, 0x0a, 0xbf, 0x90, 0xbd, 0x3f, 0x33, 0xca, 0xce, 0x76, 0x25, 0xb3, 0x8a,
+	0x2e, 0x14, 0xbb, 0x89, 0x25, 0xe6, 0xeb, 0xa9, 0xe1, 0x84, 0x8c, 0x4a, 0xd1, 0x85, 0xdc, 0x4e,
+	0xc9, 0xb5, 0x9f, 0xa5, 0xc6, 0x43, 0xe8, 0x42, 0xf0, 0x18, 0xd1, 0x85, 0x1a, 0x8c, 0x90, 0x35,
+	0x3f, 0x47, 0x91, 0x86, 0xd3, 0x85, 0x0a, 0x98, 0xa6, 0x0b, 0x39, 0x9e, 0xaa, 0x0b, 0x7f, 0x1e,
+	0xd0, 0xd2, 0xeb, 0x42, 0xf0, 0x19, 0xd5, 0x85, 0xe1, 0x66, 0x57, 0x6a, 0xc5, 0x2f, 0x00, 0x85,
+	0x29, 0x74, 0xa1, 0x48, 0x91, 0x88, 0x2e, 0x8c, 0x80, 0x08, 0x02, 0x7f, 0x11, 0x42, 0x4a, 0xa7,
+	0x0b, 0x35, 0x28, 0x4d, 0x17, 0xc2, 0x27, 0xc0, 0xda, 0x2f, 0x51, 0x08, 0x5b, 0x5d, 0x08, 0x0e,
+	0x42, 0x5d, 0xa8, 0xf8, 0x73, 0x7f, 0x12, 0x15, 0x5a, 0x6b, 0x5b, 0xac, 0xca, 0x41, 0xa9, 0xfb,
+	0x36, 0xc4, 0xf0, 0xc3, 0x16, 0x00, 0x37, 0xad, 0x6d, 0xd1, 0x82, 0x48, 0xff, 0x3b, 0xd9, 0xee,
+	0x6e, 0x9f, 0x0b, 0xf6, 0xb7, 0xe4, 0x88, 0x7b, 0x06, 0x4d, 0x86, 0x08, 0x50, 0xd3, 0x7e, 0x0b,
+	0x20, 0xae, 0xb2, 0x87, 0x60, 0x05, 0x15, 0x30, 0x26, 0x5a, 0xca, 0x90, 0xdb, 0x40, 0x53, 0x21,
+	0x08, 0xaf, 0xb1, 0xbf, 0x0d, 0x28, 0x57, 0xdb, 0xa3, 0x40, 0x35, 0x06, 0x98, 0x42, 0x4b, 0x1d,
+	0xd3, 0x70, 0x78, 0x85, 0xfe, 0x9d, 0xd4, 0x38, 0xa7, 0x0c, 0x38, 0xbc, 0xbe, 0x47, 0x48, 0x23,
+	0xd8, 0xfb, 0xdd, 0x61, 0x48, 0x23, 0x38, 0x46, 0x1a, 0xc1, 0x31, 0xd2, 0x08, 0xf6, 0x7e, 0x6f,
+	0x28, 0xd2, 0x04, 0x8c, 0x4a, 0x5a, 0x04, 0x87, 0xb7, 0x96, 0xef, 0x0c, 0x45, 0x5a, 0x14, 0x87,
+	0x37, 0xa6, 0x4d, 0x54, 0x0c, 0x71, 0x44, 0xaf, 0xf9, 0x7d, 0x00, 0xba, 0xc6, 0x1e, 0x88, 0xb7,
+	0x30, 0x40, 0x9a, 0x6c, 0x69, 0x83, 0x6e, 0x13, 0x4d, 0x4b, 0xea, 0x04, 0xd6, 0x1f, 0x00, 0xd6,
+	0xb5, 0x29, 0xc8, 0x6b, 0xa8, 0x60, 0x53, 0x2d, 0x7d, 0x54, 0xdb, 0x0d, 0xd0, 0x17, 0xff, 0x30,
+	0xf5, 0x6e, 0x60, 0x1d, 0x54, 0xdf, 0x0d, 0xd0, 0x54, 0x63, 0xec, 0x11, 0xec, 0xfd, 0xd1, 0x70,
+	0xec, 0x89, 0xef, 0x49, 0x63, 0x8f, 0x60, 0x03, 0x7b, 0x04, 0x7b, 0x7f, 0x3c, 0x24, 0x7b, 0x02,
+	0x4c, 0x67, 0x2f, 0xb2, 0xfd, 0x78, 0x4f, 0xff, 0x93, 0xd4, 0xdb, 0x0f, 0xba, 0xbf, 0xbe, 0xfd,
+	0xb8, 0x22, 0xd0, 0xd2, 0x09, 0x14, 0xc1, 0x9f, 0xa6, 0x4f, 0x27, 0xe6, 0x20, 0x92, 0x4e, 0xa0,
+	0x27, 0xd4, 0xdd, 0x00, 0x7a, 0xe2, 0xcf, 0x52, 0xef, 0x06, 0xa6, 0x3c, 0xf4, 0xdd, 0x00, 0x62,
+	0x64, 0x0b, 0x1d, 0x08, 0x41, 0x14, 0x31, 0xf2, 0xe7, 0x80, 0xf4, 0x0a, 0x7b, 0xa4, 0x50, 0x80,
+	0x00, 0x5a, 0xb1, 0x15, 0x19, 0x76, 0xcf, 0xa1, 0x99, 0x08, 0xa2, 0x68, 0xab, 0x7f, 0x01, 0xa0,
+	0xd7, 0xa5, 0x04, 0xe5, 0x63, 0x80, 0x7b, 0xa0, 0x15, 0xff, 0xc4, 0xdd, 0x41, 0x07, 0x43, 0x68,
+	0x55, 0xa2, 0xfc, 0x25, 0x00, 0x9f, 0xb0, 0x07, 0x96, 0xaa, 0x04, 0x60, 0xa7, 0x5b, 0xd1, 0x71,
+	0xf7, 0x4e, 0x74, 0x48, 0xa9, 0xbe, 0x8a, 0x5a, 0xf9, 0x2e, 0xa0, 0xae, 0xa4, 0xa9, 0xc1, 0xa1,
+	0x4e, 0x01, 0x58, 0xb7, 0x15, 0xfb, 0xc0, 0xbd, 0x07, 0x79, 0x31, 0x5c, 0xc1, 0xf4, 0x5f, 0x01,
+	0xf4, 0xc9, 0xd4, 0xd0, 0x1a, 0xd7, 0x87, 0x5a, 0xa6, 0xcf, 0xc4, 0xfe, 0x65, 0x8d, 0x0e, 0x34,
+	0xc7, 0x5f, 0xa7, 0xda, 0xbf, 0xac, 0xf3, 0x4b, 0xd1, 0x41, 0xf7, 0x6f, 0x38, 0x24, 0x92, 0x71,
+	0x47, 0x41, 0xf9, 0x9b, 0x54, 0xc9, 0x08, 0x8d, 0x5f, 0xc2, 0xd0, 0x64, 0x94, 0x63, 0x02, 0xa7,
+	0xa7, 0xe0, 0xfc, 0x6d, 0x2a, 0x9c, 0x53, 0x06, 0x1c, 0x39, 0xa6, 0x90, 0x46, 0x30, 0xc0, 0xfc,
+	0x5d, 0x5a, 0xd2, 0x08, 0x8e, 0x91, 0x06, 0x43, 0x2a, 0x69, 0x02, 0xe5, 0xef, 0x53, 0x93, 0xa6,
+	0xc2, 0x08, 0xd2, 0x74, 0x9c, 0x9e, 0x82, 0xf3, 0x0f, 0xa9, 0x49, 0x8b, 0xe2, 0xc8, 0x31, 0xd1,
+	0xd2, 0x78, 0x1b, 0x05, 0xa0, 0x7f, 0x4c, 0xd5, 0xd2, 0x78, 0xdf, 0x97, 0x48, 0xf4, 0xdb, 0x50,
+	0x06, 0x43, 0xea, 0x58, 0x89, 0x06, 0xa4, 0x7f, 0x4a, 0x47, 0x1d, 0xf3, 0x10, 0xa1, 0x2e, 0x1c,
+	0x73, 0x4b, 0x08, 0x75, 0xda, 0xf5, 0x4e, 0x03, 0x20, 0x9e, 0xce, 0x95, 0x9c, 0xf2, 0xbe, 0xea,
+	0x48, 0x30, 0xce, 0x06, 0x99, 0xc5, 0x11, 0xb4, 0x1f, 0x2c, 0x40, 0x9e, 0x3e, 0x43, 0x4d, 0x72,
+	0xd5, 0x91, 0x00, 0xe6, 0x81, 0x5c, 0x7e, 0x19, 0x9a, 0x00, 0x1b, 0xae, 0x95, 0x9f, 0xa5, 0x46,
+	0xd3, 0xd5, 0x91, 0x00, 0xa6, 0x72, 0xb1, 0x1b, 0x5a, 0x71, 0xa5, 0xfb, 0x1c, 0xb5, 0x2a, 0x84,
+	0x56, 0x5c, 0xaa, 0xaa, 0x78, 0x04, 0x7b, 0xcf, 0x53, 0xa3, 0xac, 0x8a, 0x47, 0xb0, 0x8e, 0x47,
+	0xb0, 0xf7, 0x19, 0x6a, 0xe4, 0x6a, 0x78, 0xaa, 0x15, 0x17, 0x89, 0x9f, 0xa5, 0x56, 0xa3, 0x1a,
+	0x1e, 0xc1, 0xee, 0xcb, 0x51, 0x01, 0xac, 0x84, 0xec, 0xfa, 0x1c, 0x35, 0x1b, 0xab, 0x8e, 0x04,
+	0x30, 0x5b, 0x48, 0xb4, 0x32, 0x9a, 0xe4, 0x98, 0xc2, 0xf0, 0xf3, 0xd4, 0x70, 0xaa, 0x3a, 0x12,
+	0x80, 0x83, 0x50, 0x5e, 0x85, 0x11, 0x80, 0xb6, 0xfa, 0x65, 0x6a, 0x96, 0x09, 0x23, 0x00, 0x75,
+	0xa4, 0xa3, 0x12, 0xec, 0xfd, 0x0a, 0xb5, 0xca, 0xeb, 0xa8, 0xec, 0x00, 0x41, 0x43, 0x25, 0xd8,
+	0xfb, 0x55, 0x6a, 0x58, 0x8c, 0xa0, 0xaa, 0xd1, 0x72, 0x4d, 0xf2, 0x02, 0xb5, 0x73, 0xc2, 0x68,
+	0xb9, 0xa8, 0x90, 0xcc, 0x81, 0xa2, 0xf8, 0x02, 0xb5, 0x1a, 0x97, 0xcc, 0x81, 0x24, 0x08, 0x23,
+	0x00, 0x3d, 0xf0, 0x45, 0x6a, 0x34, 0x11, 0x46, 0x00, 0x1d, 0x7d, 0x0d, 0x15, 0xc1, 0x46, 0x69,
+	0xe7, 0x5f, 0xca, 0xa5, 0x7f, 0x8c, 0x5b, 0x1d, 0x09, 0x20, 0x54, 0xd9, 0xc2, 0x6f, 0x43, 0x07,
+	0x54, 0x08, 0xd1, 0x55, 0xbe, 0x9c, 0x1b, 0xea, 0x15, 0x9b, 0xea, 0x48, 0x30, 0x2d, 0x81, 0x44,
+	0x17, 0x59, 0x47, 0x30, 0xa8, 0x35, 0xec, 0xaf, 0xe4, 0x86, 0x78, 0xbf, 0xa6, 0x3a, 0x12, 0x4c,
+	0x31, 0x97, 0x4a, 0x93, 0x5e, 0x45, 0xae, 0xd8, 0xb8, 0x4a, 0x87, 0xfe, 0x6a, 0x2e, 0xcd, 0xb3,
+	0xe8, 0xea, 0x48, 0x50, 0xe4, 0xdb, 0x5d, 0x76, 0xe3, 0xb3, 0xe8, 0x90, 0x0e, 0x20, 0x48, 0xfb,
+	0x5a, 0x2e, 0xe5, 0x9b, 0x35, 0xd5, 0x91, 0xe0, 0x80, 0x0a, 0x23, 0x08, 0xfb, 0x31, 0x5e, 0x39,
+	0x80, 0xa9, 0xaf, 0xe7, 0xac, 0x5f, 0x13, 0xbc, 0x99, 0xce, 0x16, 0x4c, 0x29, 0xbe, 0x64, 0x6e,
+	0xc0, 0x1e, 0x5d, 0xf4, 0xbe, 0x21, 0x36, 0xe9, 0x84, 0xb2, 0x49, 0x17, 0xa3, 0x76, 0xbe, 0xf7,
+	0x4d, 0x93, 0x9d, 0x1f, 0xb5, 0x5b, 0xf2, 0xbe, 0x65, 0xb2, 0x5b, 0x72, 0xaf, 0x44, 0x07, 0x79,
+	0x06, 0xe9, 0x0f, 0xb4, 0xee, 0xcb, 0xcb, 0x17, 0x7a, 0xaa, 0x4e, 0x00, 0xdf, 0xa0, 0xfe, 0x3c,
+	0xeb, 0x6a, 0x41, 0x7b, 0xf4, 0x61, 0xd6, 0xfb, 0xf2, 0xea, 0xdb, 0x3d, 0x55, 0x87, 0x73, 0x19,
+	0x79, 0x96, 0x75, 0x0d, 0x9a, 0x89, 0x4e, 0xe7, 0x95, 0xf4, 0xfe, 0xbc, 0xf2, 0xaa, 0x4f, 0xd5,
+	0x09, 0x0e, 0xea, 0xd3, 0x79, 0x65, 0xbd, 0x3a, 0x3e, 0x9f, 0xd7, 0xd8, 0x07, 0xf2, 0xf2, 0xbd,
+	0x9f, 0xf8, 0xf4, 0x53, 0xe2, 0x31, 0x98, 0x69, 0xf5, 0x04, 0x7b, 0x0f, 0xe6, 0xa3, 0x2f, 0x01,
+	0x19, 0x23, 0x20, 0x38, 0x29, 0x02, 0x82, 0xbd, 0x87, 0xf2, 0xca, 0x1b, 0x41, 0xe6, 0x08, 0x08,
+	0x4e, 0x8a, 0x80, 0x60, 0xef, 0xe1, 0xbc, 0x7c, 0x3d, 0xc8, 0x1c, 0x01, 0x7b, 0xf4, 0x35, 0x1b,
+	0x9d, 0x2e, 0xaa, 0xf4, 0x23, 0x79, 0xf5, 0x5d, 0xa1, 0xaa, 0x13, 0x1c, 0xd2, 0x3d, 0x88, 0xfa,
+	0x7e, 0x3d, 0xf2, 0x62, 0x11, 0x08, 0x1f, 0x8f, 0xe6, 0xb5, 0x17, 0x87, 0xaa, 0x4e, 0x30, 0x13,
+	0x89, 0x42, 0xd4, 0xfe, 0x6b, 0xe2, 0x54, 0x42, 0x17, 0x78, 0x7f, 0x5e, 0x7b, 0x8b, 0x28, 0xce,
+	0x23, 0xf4, 0x85, 0xa4, 0x40, 0x08, 0xf6, 0x3e, 0x90, 0x57, 0x5f, 0x29, 0x4a, 0x08, 0x84, 0xe0,
+	0xe4, 0x40, 0x08, 0xf6, 0x1e, 0xcb, 0x6b, 0xef, 0x17, 0x25, 0x05, 0x42, 0xb0, 0x7b, 0x43, 0xfc,
+	0x0b, 0xe1, 0x8d, 0xe5, 0xf1, 0xbc, 0xe1, 0x65, 0xa3, 0xf8, 0x37, 0xc3, 0x1b, 0xce, 0x8d, 0x86,
+	0x8d, 0x01, 0xad, 0xe7, 0x89, 0xbc, 0xf9, 0xcd, 0x23, 0xc3, 0x1e, 0x81, 0xae, 0x74, 0x73, 0x9c,
+	0x5b, 0xe8, 0x4f, 0x17, 0xf2, 0x83, 0x5f, 0x43, 0x8a, 0x93, 0x0d, 0x2d, 0xec, 0xb5, 0x68, 0x2e,
+	0xea, 0x50, 0x69, 0x66, 0x4f, 0xe6, 0x87, 0x7e, 0x27, 0xa9, 0xea, 0x04, 0xb3, 0x3a, 0xb0, 0xfa,
+	0xf7, 0xe9, 0xc5, 0xf1, 0x8c, 0x51, 0x9a, 0xc2, 0x53, 0xf9, 0x21, 0x5e, 0x50, 0xaa, 0x3a, 0xc1,
+	0xe1, 0x68, 0x9e, 0x85, 0x36, 0x73, 0x3f, 0x85, 0x26, 0xb4, 0xde, 0xf7, 0x22, 0xbe, 0x69, 0x3e,
+	0x77, 0x37, 0x42, 0x4a, 0x3f, 0x7c, 0x31, 0x91, 0xaf, 0x45, 0x05, 0xed, 0x4d, 0x4e, 0x5b, 0x70,
+	0xea, 0x40, 0x7b, 0x27, 0x22, 0x9d, 0x03, 0xe5, 0xf0, 0xdc, 0xda, 0xc1, 0x35, 0xa8, 0x18, 0x3d,
+	0x1c, 0x77, 0x8b, 0x28, 0x7b, 0x7b, 0xfd, 0x1c, 0x73, 0xb2, 0x2f, 0xa0, 0xff, 0xeb, 0x1e, 0x44,
+	0xb9, 0x3b, 0xd7, 0x9a, 0xbd, 0xba, 0x97, 0x61, 0x63, 0xf0, 0x8f, 0x4a, 0xe6, 0x0a, 0x67, 0xee,
+	0x5a, 0x34, 0x1d, 0x3b, 0xf9, 0xde, 0xcd, 0x41, 0x4e, 0x75, 0xf0, 0x0a, 0xe4, 0xc6, 0x0f, 0xb5,
+	0x77, 0xf3, 0x30, 0x6d, 0xf6, 0x70, 0x6a, 0xef, 0x1e, 0x0a, 0x89, 0x41, 0xf0, 0x53, 0xba, 0xdd,
+	0x1c, 0x64, 0x93, 0x83, 0xd8, 0xa3, 0x07, 0x37, 0x39, 0x88, 0x3d, 0x7a, 0x18, 0x55, 0x3d, 0x9c,
+	0x40, 0x07, 0x0c, 0xe7, 0xc2, 0xbb, 0xb9, 0x18, 0x53, 0x5d, 0xac, 0xa0, 0x83, 0xa6, 0xe3, 0xde,
+	0xdd, 0x7c, 0x4c, 0x99, 0xb9, 0x94, 0xe7, 0xb8, 0xbb, 0x39, 0xc8, 0x0c, 0x88, 0x63, 0x8f, 0x54,
+	0xe4, 0x07, 0xc5, 0xb1, 0x47, 0x1f, 0x45, 0xf3, 0x17, 0xa2, 0x1c, 0xa8, 0xee, 0xe6, 0xc1, 0x49,
+	0xd8, 0x14, 0xf2, 0xa8, 0x74, 0x37, 0x0f, 0xe3, 0x66, 0x2e, 0xe5, 0x29, 0xe8, 0x6e, 0x0e, 0x26,
+	0x54, 0x07, 0xe7, 0xd0, 0x21, 0xe3, 0xe1, 0xa6, 0xc1, 0xc9, 0xab, 0x54, 0x27, 0x69, 0x1f, 0xe6,
+	0x2a, 0xd0, 0xf7, 0x20, 0x2f, 0xe9, 0x88, 0xd3, 0x80, 0x7e, 0x93, 0x8a, 0x3e, 0xc4, 0x03, 0x5e,
+	0x65, 0x01, 0xaf, 0x45, 0x33, 0xe6, 0xa3, 0x4e, 0x03, 0xfc, 0x8f, 0xe8, 0xf0, 0x29, 0x9f, 0xf8,
+	0x2a, 0xe0, 0x3d, 0x34, 0x9b, 0x70, 0xe2, 0x69, 0x40, 0xbf, 0x5e, 0xa7, 0xde, 0xf6, 0x21, 0xb0,
+	0x16, 0xf3, 0x5c, 0xf2, 0x69, 0xa7, 0x01, 0xf9, 0x95, 0x7a, 0xdc, 0x29, 0x1e, 0x0b, 0xc7, 0x76,
+	0xab, 0x7e, 0xe6, 0xa9, 0x62, 0xe6, 0x76, 0xeb, 0x25, 0x90, 0x30, 0x91, 0xe3, 0x4c, 0xd5, 0xc3,
+	0xf4, 0xde, 0x3c, 0x9c, 0x4a, 0xf6, 0x50, 0xd8, 0x5b, 0x3f, 0xd3, 0xcf, 0x20, 0x55, 0x07, 0xd9,
+	0xbd, 0x07, 0x91, 0xe0, 0xc1, 0xdd, 0x7b, 0x10, 0x09, 0x1e, 0x46, 0x77, 0xf3, 0x00, 0x25, 0x34,
+	0x7a, 0x22, 0xa8, 0xba, 0x18, 0xdb, 0x63, 0x18, 0xfa, 0x51, 0x9f, 0xea, 0x61, 0x7c, 0x37, 0x0f,
+	0x57, 0x21, 0x24, 0xff, 0x1e, 0xb7, 0xd6, 0x25, 0x55, 0x34, 0x73, 0xf2, 0xee, 0x6e, 0xbd, 0xbd,
+	0xb3, 0xd9, 0x69, 0x0f, 0xa7, 0xb1, 0x54, 0x4f, 0x43, 0x69, 0xa5, 0x23, 0xf3, 0x68, 0x5c, 0x8a,
+	0xed, 0x71, 0x04, 0xba, 0xb8, 0x38, 0x42, 0xff, 0x77, 0x25, 0x38, 0xf1, 0xa3, 0x37, 0x17, 0x1d,
+	0x77, 0x3f, 0x1a, 0xbb, 0xae, 0x7a, 0x22, 0x78, 0xf5, 0x8d, 0x27, 0x8b, 0x99, 0xcb, 0xc6, 0xf7,
+	0xdd, 0x5b, 0x2b, 0x9e, 0x3f, 0x7f, 0xfe, 0x7c, 0xc6, 0x3f, 0x83, 0x66, 0xeb, 0x62, 0x11, 0xab,
+	0xda, 0x9d, 0x45, 0xd7, 0x42, 0x74, 0x7a, 0xf7, 0xd6, 0x18, 0xcb, 0x87, 0xea, 0x51, 0x6a, 0xe8,
+	0x57, 0xe4, 0xd7, 0x91, 0x67, 0x00, 0x81, 0x3f, 0xc8, 0x6d, 0x50, 0xde, 0x50, 0x63, 0xd9, 0x3a,
+	0x13, 0x43, 0x61, 0xb9, 0xed, 0x6f, 0xa0, 0xc3, 0x06, 0x98, 0x1d, 0x7b, 0x9c, 0x37, 0xd6, 0x58,
+	0x4e, 0xcf, 0xc6, 0x70, 0xa0, 0x04, 0x24, 0x00, 0xf5, 0xec, 0x81, 0xde, 0x54, 0x63, 0xa9, 0x1f,
+	0x07, 0x82, 0x4a, 0x91, 0x4c, 0x1c, 0xc1, 0x56, 0x38, 0x6f, 0xae, 0xb1, 0x0a, 0x61, 0x24, 0x8e,
+	0xe0, 0x01, 0xc4, 0x59, 0xe2, 0xbc, 0xa5, 0xc6, 0xea, 0x88, 0x99, 0xb8, 0x44, 0xa0, 0x9e, 0x3d,
+	0xd0, 0x5b, 0x6b, 0xac, 0xdc, 0x98, 0x89, 0x23, 0xd8, 0xdf, 0x44, 0x73, 0x06, 0x20, 0x71, 0x72,
+	0x61, 0x83, 0xf4, 0xb6, 0x1a, 0xab, 0x4a, 0x5e, 0x0c, 0x89, 0x57, 0x31, 0xff, 0x76, 0x74, 0x91,
+	0x89, 0xbc, 0x34, 0x58, 0x6f, 0xaf, 0x31, 0xd1, 0x7a, 0x38, 0x4e, 0x1f, 0xf7, 0x96, 0xb0, 0x21,
+	0x1a, 0xf0, 0x6a, 0x9f, 0x05, 0xd2, 0x3b, 0x6a, 0x4c, 0xdd, 0xc6, 0x37, 0x04, 0xd3, 0xc6, 0x83,
+	0xe8, 0xb3, 0xfc, 0xa2, 0xde, 0x59, 0x63, 0x1a, 0x38, 0x81, 0x3e, 0x82, 0x07, 0xd2, 0x67, 0x89,
+	0xf5, 0xae, 0x1a, 0xd3, 0xca, 0x49, 0xf4, 0x25, 0xee, 0x3f, 0x38, 0xec, 0xb1, 0x82, 0xea, 0xd7,
+	0x98, 0xa8, 0x8e, 0xef, 0x3f, 0xd0, 0xe4, 0x49, 0x19, 0x05, 0x87, 0x3b, 0x36, 0x40, 0xef, 0xae,
+	0xb1, 0x2e, 0x60, 0xc8, 0x28, 0x38, 0xf1, 0x35, 0x6f, 0x08, 0x76, 0x56, 0x64, 0x85, 0xf3, 0x9e,
+	0x1a, 0x93, 0xe8, 0xf1, 0x0d, 0xc1, 0x04, 0xbe, 0xff, 0xa0, 0x83, 0x2e, 0x31, 0xe0, 0xc8, 0x23,
+	0x24, 0x2b, 0xb0, 0xf7, 0xd6, 0x86, 0x90, 0xf2, 0x73, 0xb1, 0x25, 0x86, 0x9f, 0xf9, 0x4f, 0x38,
+	0xa8, 0x94, 0xb8, 0x4c, 0xfe, 0x78, 0xc0, 0x6a, 0xa5, 0xf7, 0xd5, 0x86, 0x93, 0xfd, 0x97, 0x98,
+	0x17, 0xcb, 0x3f, 0xf6, 0x1f, 0x71, 0xd0, 0xf7, 0x19, 0xd6, 0xab, 0x3c, 0x97, 0xb1, 0x5a, 0xed,
+	0xfb, 0x6a, 0xc3, 0xfc, 0x95, 0x70, 0x51, 0x6c, 0xad, 0xf2, 0x43, 0xff, 0x7e, 0x07, 0x5d, 0x6a,
+	0xec, 0x11, 0xf2, 0x18, 0xcf, 0x6a, 0xa9, 0xf7, 0xd7, 0x52, 0xfd, 0x49, 0x71, 0xb1, 0xa1, 0xb3,
+	0x84, 0x9f, 0xfa, 0x8f, 0x39, 0xe8, 0xc8, 0x80, 0x45, 0xa6, 0xd9, 0x00, 0x0f, 0xd4, 0xd2, 0xfe,
+	0x01, 0x72, 0x69, 0xd2, 0x52, 0xc5, 0x97, 0xff, 0xb0, 0x83, 0x64, 0xba, 0xe9, 0x37, 0xad, 0x6d,
+	0x56, 0xf8, 0x60, 0x8d, 0x3d, 0x8e, 0xb2, 0x79, 0xd3, 0xc6, 0x2c, 0x60, 0x83, 0x84, 0xd5, 0xf8,
+	0x4d, 0xb5, 0xc6, 0xe8, 0x0f, 0x8c, 0xec, 0x92, 0xa9, 0xaf, 0x5e, 0x17, 0x97, 0x68, 0xda, 0xf3,
+	0x25, 0x7f, 0x4b, 0x2d, 0x9d, 0x91, 0x67, 0x4c, 0x76, 0xd9, 0xd0, 0xd7, 0xaf, 0x9b, 0xcf, 0xc6,
+	0x01, 0x41, 0x37, 0xde, 0xa1, 0x76, 0xbb, 0xe8, 0x63, 0x29, 0xbb, 0x5d, 0xdd, 0xd7, 0xae, 0xab,
+	0x7b, 0x71, 0x44, 0xae, 0x20, 0xb7, 0xcc, 0x90, 0x29, 0x24, 0xe4, 0x03, 0x7d, 0xf5, 0xba, 0xbb,
+	0x01, 0x91, 0x4b, 0xc9, 0x6e, 0x22, 0xad, 0x96, 0x5d, 0xf6, 0xc1, 0x7e, 0xfc, 0xba, 0xbc, 0x99,
+	0x5a, 0x82, 0x07, 0x51, 0x6b, 0x09, 0xfb, 0x50, 0x5f, 0xbb, 0x6e, 0x9f, 0x40, 0x2d, 0xc1, 0x83,
+	0xa8, 0xb5, 0x84, 0x7c, 0xb8, 0xaf, 0x5e, 0xd7, 0x4f, 0xa0, 0x96, 0x60, 0xbf, 0xab, 0x4a, 0x98,
+	0xd8, 0x53, 0x39, 0x2b, 0xc8, 0x47, 0xfa, 0xfa, 0x75, 0xff, 0xc3, 0x71, 0x50, 0xa1, 0x3b, 0xef,
+	0x42, 0x17, 0x1b, 0xa9, 0x4d, 0x03, 0xfb, 0x68, 0x3f, 0xf2, 0x73, 0x01, 0x73, 0x06, 0x7a, 0x85,
+	0x06, 0xbd, 0xc3, 0xbc, 0x93, 0xec, 0x45, 0xe8, 0xfb, 0xfb, 0x91, 0x9f, 0x1b, 0x30, 0x6c, 0x23,
+	0xd0, 0xa3, 0x83, 0x18, 0xb6, 0xfc, 0x52, 0x3f, 0xd0, 0xd7, 0x7f, 0xae, 0x20, 0x89, 0x61, 0x82,
+	0x07, 0x33, 0x6c, 0x09, 0xfb, 0x58, 0x3f, 0xf2, 0x73, 0x07, 0x89, 0x0c, 0x13, 0xec, 0x9f, 0x33,
+	0x6f, 0xe1, 0x14, 0x3a, 0xf5, 0xf1, 0xbe, 0xf1, 0xe7, 0x12, 0x0c, 0x7b, 0x99, 0x0b, 0xd7, 0xd7,
+	0x25, 0x24, 0xac, 0xbd, 0x72, 0x7d, 0xa2, 0x9f, 0xf4, 0x73, 0x0b, 0xa6, 0xdc, 0x05, 0x35, 0xfb,
+	0x7a, 0xc7, 0xbc, 0xb7, 0xec, 0xf5, 0xec, 0x85, 0xfe, 0x6e, 0xbf, 0xd7, 0x60, 0xd8, 0x6c, 0xa0,
+	0x75, 0x2f, 0x68, 0xa2, 0xcc, 0xf4, 0xbc, 0xd4, 0x6a, 0x25, 0x4f, 0xf6, 0xbf, 0x07, 0x3f, 0xf8,
+	0x70, 0x51, 0x7c, 0xb1, 0x52, 0xf5, 0x3e, 0xae, 0xa9, 0x5e, 0xf3, 0x33, 0x56, 0xab, 0x25, 0x3f,
+	0xd5, 0x1f, 0xea, 0x17, 0x23, 0x2e, 0x31, 0xd5, 0x66, 0xa9, 0xd2, 0xd6, 0xd5, 0x23, 0x27, 0xed,
+	0xb2, 0xa0, 0xdd, 0x22, 0xbf, 0xeb, 0xb0, 0x9b, 0x85, 0xf2, 0xcc, 0x29, 0x50, 0xae, 0x18, 0xfa,
+	0x0d, 0x55, 0xb4, 0xe8, 0x97, 0x0d, 0xad, 0x60, 0x3e, 0xc8, 0x60, 0xd4, 0x43, 0xa7, 0x40, 0xbd,
+	0xa2, 0xe8, 0x9f, 0x55, 0x77, 0x6c, 0xe4, 0xb2, 0xa2, 0x15, 0xd0, 0x87, 0x18, 0x90, 0x7a, 0xea,
+	0x14, 0x68, 0x57, 0x1c, 0x13, 0x90, 0x52, 0x48, 0x86, 0x0f, 0x33, 0xa4, 0x82, 0x01, 0x89, 0x6b,
+	0x85, 0x44, 0xee, 0x2c, 0x8b, 0xde, 0x47, 0x18, 0x50, 0xd6, 0xcc, 0x1d, 0xc1, 0x03, 0xb8, 0xb3,
+	0x04, 0xfa, 0x28, 0x03, 0x72, 0x13, 0xb8, 0x4b, 0x44, 0x4a, 0xa1, 0x09, 0x3e, 0xc6, 0x90, 0x46,
+	0x13, 0xb8, 0x23, 0xd8, 0xbf, 0x4d, 0x2d, 0xa0, 0xd1, 0xcb, 0x9e, 0x56, 0x50, 0x1f, 0x67, 0x50,
+	0xea, 0xd1, 0x53, 0xa0, 0x5f, 0x11, 0xf5, 0x9b, 0x6a, 0x5b, 0x8c, 0x5d, 0x16, 0xb5, 0x02, 0xfb,
+	0x04, 0x03, 0x53, 0xcf, 0x9e, 0x82, 0xc8, 0x15, 0xd3, 0x84, 0x5d, 0x61, 0xdf, 0xf6, 0x3f, 0xc9,
+	0xa0, 0x32, 0x86, 0x5d, 0x01, 0xcd, 0x7e, 0x00, 0x83, 0x96, 0x5f, 0xd6, 0xa7, 0x18, 0x52, 0x3e,
+	0x89, 0x41, 0x82, 0x07, 0x32, 0x68, 0x09, 0xf6, 0x69, 0x06, 0x56, 0x4c, 0x64, 0x30, 0x71, 0x17,
+	0xa6, 0x68, 0xeb, 0x4f, 0x33, 0x2c, 0xc7, 0xb0, 0x0b, 0x79, 0x1b, 0x4f, 0xc8, 0x2c, 0xfb, 0x2e,
+	0xfe, 0x0c, 0x43, 0x1a, 0x37, 0x65, 0x16, 0xb4, 0x6c, 0xf3, 0xae, 0xb0, 0x6f, 0xd8, 0xcf, 0x32,
+	0xa0, 0x09, 0xc3, 0xae, 0x80, 0xae, 0xfc, 0x90, 0x76, 0x02, 0x65, 0xb8, 0xed, 0x6b, 0x85, 0xf6,
+	0x1c, 0x43, 0x1b, 0xfe, 0x08, 0x2a, 0x88, 0xde, 0x11, 0xa6, 0xea, 0xa1, 0x94, 0xb8, 0xce, 0x34,
+	0x27, 0x10, 0xcf, 0xb3, 0xa5, 0x7e, 0x4f, 0xce, 0xa0, 0x02, 0xc3, 0x25, 0x63, 0xff, 0x51, 0x4d,
+	0xee, 0x98, 0xee, 0x1b, 0x5b, 0x2d, 0xf7, 0x33, 0x7c, 0xb9, 0x43, 0x1f, 0x42, 0x05, 0xb1, 0x5b,
+	0xca, 0xfe, 0x03, 0xda, 0x21, 0x94, 0xf1, 0xc2, 0xb2, 0xd5, 0x5a, 0x3f, 0xcb, 0x77, 0x41, 0xfa,
+	0x53, 0xa8, 0x20, 0x7e, 0xcd, 0x99, 0xca, 0xb1, 0x23, 0x03, 0x56, 0x99, 0x66, 0x0f, 0x7c, 0x8e,
+	0x93, 0x3a, 0xd4, 0x31, 0x54, 0x60, 0xbc, 0x27, 0xed, 0x3f, 0xa2, 0x1e, 0x43, 0xe9, 0x37, 0x9c,
+	0x6d, 0x96, 0xf8, 0x79, 0xb6, 0xc4, 0x94, 0xe7, 0x50, 0xfa, 0x3d, 0xeb, 0x84, 0xe5, 0xac, 0x14,
+	0xc4, 0xab, 0xfa, 0xbd, 0xf6, 0x66, 0xa7, 0xbd, 0x32, 0x1b, 0x7f, 0x47, 0x92, 0x7d, 0x70, 0xd9,
+	0x22, 0xda, 0xaf, 0xbe, 0x27, 0x6e, 0x7a, 0x20, 0x8a, 0xdc, 0x09, 0xf9, 0x40, 0xf4, 0x05, 0x67,
+	0xe5, 0x35, 0x3f, 0x5e, 0x8b, 0x2d, 0xfb, 0x18, 0x5b, 0xf6, 0xe9, 0x5e, 0xe3, 0xd8, 0x66, 0xbb,
+	0x5b, 0xdf, 0x6e, 0xaf, 0x35, 0xd9, 0xef, 0xdc, 0xb2, 0xd1, 0x9d, 0x63, 0xcd, 0xfa, 0xc6, 0xda,
+	0x99, 0x73, 0xc7, 0x92, 0x7e, 0x12, 0xf7, 0xff, 0x03, 0x00, 0x00, 0xff, 0xff, 0xe0, 0x96, 0xc9,
+	0xde, 0x2d, 0x57, 0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20160225_2fc053c5/test.proto b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20160225_2fc053c5/test.proto
new file mode 100644
index 000000000..56025e187
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20160225_2fc053c5/test.proto
@@ -0,0 +1,333 @@
+// 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.
+
+syntax = "proto2";
+
+package google.golang.org.proto2_20160225;
+option go_package = "google.golang.org/protobuf/internal/testprotos/legacy/proto2_20160225_2fc053c5";
+
+enum SiblingEnum {
+	ALPHA   = 0;
+	BRAVO   = 10;
+	CHARLIE = 200;
+}
+
+message SiblingMessage {
+	optional string  f1 = 1;
+	required string  f2 = 2;
+	repeated string  f3 = 3;
+	optional Message f4 = 4;
+}
+
+message Message {
+	enum ChildEnum {
+		ALPHA   = 0;
+		BRAVO   = 1;
+		CHARLIE = 2;
+	}
+	message ChildMessage {
+		optional string  f1 = 1;
+		required string  f2 = 2;
+		repeated string  f3 = 3;
+	    optional Message f4 = 4;
+	}
+	optional group NamedGroup = 1 {
+		optional string  f1 = 1;
+		required string  f2 = 2;
+		repeated string  f3 = 3;
+	    optional Message f4 = 4;
+	}
+
+	// Optional fields.
+	optional bool     optional_bool     = 100;
+	optional int32    optional_int32    = 101;
+	optional sint32   optional_sint32   = 102;
+	optional uint32   optional_uint32   = 103;
+	optional int64    optional_int64    = 104;
+	optional sint64   optional_sint64   = 105;
+	optional uint64   optional_uint64   = 106;
+	optional fixed32  optional_fixed32  = 107;
+	optional sfixed32 optional_sfixed32 = 108;
+	optional float    optional_float    = 109;
+	optional fixed64  optional_fixed64  = 110;
+	optional sfixed64 optional_sfixed64 = 111;
+	optional double   optional_double   = 112;
+	optional string   optional_string   = 113;
+	optional bytes    optional_bytes    = 114;
+
+	optional ChildEnum      optional_child_enum      = 115;
+	optional ChildMessage   optional_child_message   = 116;
+	optional NamedGroup     optional_named_group     = 117;
+	optional SiblingEnum    optional_sibling_enum    = 118;
+	optional SiblingMessage optional_sibling_message = 119;
+	optional group OptionalGroup = 120 {
+		optional string f1 = 1;
+		required string f2 = 2;
+		repeated string f3 = 3;
+	}
+
+	// Optional default fields.
+	optional bool      defaulted_bool     = 200 [default = true];
+	optional int32     defaulted_int32    = 201 [default = -12345];
+	optional sint32    defaulted_sint32   = 202 [default = -3200];
+	optional uint32    defaulted_uint32   = 203 [default = 3200];
+	optional int64     defaulted_int64    = 204 [default = -123456789];
+	optional sint64    defaulted_sint64   = 205 [default = -6400];
+	optional uint64    defaulted_uint64   = 206 [default = 6400];
+	optional fixed32   defaulted_fixed32  = 207 [default = 320000];
+	optional sfixed32  defaulted_sfixed32 = 208 [default = -320000];
+	optional float     defaulted_float    = 209 [default = 3.14159];
+	optional fixed64   defaulted_fixed64  = 210 [default = 640000];
+	optional sfixed64  defaulted_sfixed64 = 211 [default = -640000];
+	optional double    defaulted_double   = 212 [default = 3.14159265359];
+	optional string    defaulted_string   = 213 [default = "hello, \"world!\"\n"];
+	optional bytes     defaulted_bytes    = 214 [default = "dead\xde\xad\xbe\xefbeef"];
+
+	optional ChildEnum   defaulted_child_enum   = 215 [default = ALPHA];
+	optional SiblingEnum defaulted_sibling_enum = 216 [default = ALPHA];
+
+	// Required fields.
+	required bool     required_bool     = 300;
+	required int32    required_int32    = 301;
+	required sint32   required_sint32   = 302;
+	required uint32   required_uint32   = 303;
+	required int64    required_int64    = 304;
+	required sint64   required_sint64   = 305;
+	required uint64   required_uint64   = 306;
+	required fixed32  required_fixed32  = 307;
+	required sfixed32 required_sfixed32 = 308;
+	required float    required_float    = 309;
+	required fixed64  required_fixed64  = 310;
+	required sfixed64 required_sfixed64 = 311;
+	required double   required_double   = 312;
+	required string   required_string   = 313;
+	required bytes    required_bytes    = 314;
+
+	required ChildEnum      required_child_enum      = 315;
+	required ChildMessage   required_child_message   = 316;
+	required NamedGroup     required_named_group     = 317;
+	required SiblingEnum    required_sibling_enum    = 318;
+	required SiblingMessage required_sibling_message = 319;
+	required group RequiredGroup = 320 {
+		optional string f1 = 1;
+		required string f2 = 2;
+		repeated string f3 = 3;
+	}
+	// Required default fields.
+	required bool      required_defaulted_bool     = 400 [default = true];
+	required int32     required_defaulted_int32    = 401 [default = -12345];
+	required sint32    required_defaulted_sint32   = 402 [default = -3200];
+	required uint32    required_defaulted_uint32   = 403 [default = 3200];
+	required int64     required_defaulted_int64    = 404 [default = -123456789];
+	required sint64    required_defaulted_sint64   = 405 [default = -6400];
+	required uint64    required_defaulted_uint64   = 406 [default = 6400];
+	required fixed32   required_defaulted_fixed32  = 407 [default = 320000];
+	required sfixed32  required_defaulted_sfixed32 = 408 [default = -320000];
+	required float     required_defaulted_float    = 409 [default = 3.14159];
+	required fixed64   required_defaulted_fixed64  = 410 [default = 640000];
+	required sfixed64  required_defaulted_sfixed64 = 411 [default = -640000];
+	required double    required_defaulted_double   = 412 [default = 3.14159265359];
+	required string    required_defaulted_string   = 413 [default = "hello, \"world!\"\n"];
+	required bytes     required_defaulted_bytes    = 414 [default = "dead\xde\xad\xbe\xefbeef"];
+
+	required ChildEnum   required_defaulted_child_enum   = 415 [default = ALPHA];
+	required SiblingEnum required_defaulted_sibling_enum = 416 [default = ALPHA];
+
+	// Repeated fields.
+	repeated bool     repeated_bool     = 500;
+	repeated int32    repeated_int32    = 501;
+	repeated sint32   repeated_sint32   = 502;
+	repeated uint32   repeated_uint32   = 503;
+	repeated int64    repeated_int64    = 504;
+	repeated sint64   repeated_sint64   = 505;
+	repeated uint64   repeated_uint64   = 506;
+	repeated fixed32  repeated_fixed32  = 507;
+	repeated sfixed32 repeated_sfixed32 = 508;
+	repeated float    repeated_float    = 509;
+	repeated fixed64  repeated_fixed64  = 510;
+	repeated sfixed64 repeated_sfixed64 = 511;
+	repeated double   repeated_double   = 512;
+	repeated string   repeated_string   = 513;
+	repeated bytes    repeated_bytes    = 514;
+
+	repeated ChildEnum      repeated_child_enum      = 515;
+	repeated ChildMessage   repeated_child_message   = 516;
+	repeated NamedGroup     repeated_named_group     = 517;
+	repeated SiblingEnum    repeated_sibling_enum    = 518;
+	repeated SiblingMessage repeated_sibling_message = 519;
+	repeated group RepeatedGroup = 520 {
+		optional string f1 = 1;
+		required string f2 = 2;
+		repeated string f3 = 3;
+	}
+
+	// Map fields.
+	map<bool, bool>     map_bool_bool     = 600;
+	map<bool, int32>    map_bool_int32    = 601;
+	map<bool, sint32>   map_bool_sint32   = 602;
+	map<bool, uint32>   map_bool_uint32   = 603;
+	map<bool, int64>    map_bool_int64    = 604;
+	map<bool, sint64>   map_bool_sint64   = 605;
+	map<bool, uint64>   map_bool_uint64   = 606;
+	map<bool, fixed32>  map_bool_fixed32  = 607;
+	map<bool, sfixed32> map_bool_sfixed32 = 608;
+	map<bool, float>    map_bool_float    = 609;
+	map<bool, fixed64>  map_bool_fixed64  = 610;
+	map<bool, sfixed64> map_bool_sfixed64 = 611;
+	map<bool, double>   map_bool_double   = 612;
+	map<bool, string>   map_bool_string   = 613;
+	map<bool, bytes>    map_bool_bytes    = 614;
+
+	map<bool, ChildEnum>      map_bool_child_enum      = 615;
+	map<bool, ChildMessage>   map_bool_child_message   = 616;
+	map<bool, NamedGroup>     map_bool_named_group     = 617;
+	map<bool, SiblingEnum>    map_bool_sibling_enum    = 618;
+	map<bool, SiblingMessage> map_bool_sibling_message = 619;
+
+	map<int32, bool>   map_int32_bool   = 620;
+	map<sint32, bool>  map_sint32_bool  = 621;
+	map<uint32, bool>  map_uint32_bool  = 622;
+	map<int64, bool>   map_int64_bool   = 623;
+	map<sint64, bool>  map_sint64_bool  = 624;
+	map<uint64, bool>  map_uint64_bool  = 625;
+	map<fixed32, bool> map_fixed32_bool = 626;
+	map<string, bool>  map_string_bool  = 627;
+
+	// Oneof fields.
+	oneof oneof_union {
+		bool     oneof_bool     = 700;
+		int32    oneof_int32    = 701;
+		sint32   oneof_sint32   = 702;
+		uint32   oneof_uint32   = 703;
+		int64    oneof_int64    = 704;
+		sint64   oneof_sint64   = 705;
+		uint64   oneof_uint64   = 706;
+		fixed32  oneof_fixed32  = 707;
+		sfixed32 oneof_sfixed32 = 708;
+		float    oneof_float    = 709;
+		fixed64  oneof_fixed64  = 710;
+		sfixed64 oneof_sfixed64 = 711;
+		double   oneof_double   = 712;
+		string   oneof_string   = 713;
+		bytes    oneof_bytes    = 714;
+
+		ChildEnum      oneof_child_enum      = 715;
+		ChildMessage   oneof_child_message   = 716;
+		NamedGroup     oneof_named_group     = 717;
+		SiblingEnum    oneof_sibling_enum    = 718;
+		SiblingMessage oneof_sibling_message = 719;
+		group OneofGroup = 720 {
+			optional string f1 = 1;
+			required string f2 = 2;
+			repeated string f3 = 3;
+		}
+
+		string oneof_string1 = 721;
+		string oneof_string2 = 722;
+		string oneof_string3 = 723;
+	}
+
+	// Oneof default fields.
+	oneof oneof_defaulted_union {
+		bool      oneof_defaulted_bool     = 800 [default = true];
+		int32     oneof_defaulted_int32    = 801 [default = -12345];
+		sint32    oneof_defaulted_sint32   = 802 [default = -3200];
+		uint32    oneof_defaulted_uint32   = 803 [default = 3200];
+		int64     oneof_defaulted_int64    = 804 [default = -123456789];
+		sint64    oneof_defaulted_sint64   = 805 [default = -6400];
+		uint64    oneof_defaulted_uint64   = 806 [default = 6400];
+		fixed32   oneof_defaulted_fixed32  = 807 [default = 320000];
+		sfixed32  oneof_defaulted_sfixed32 = 808 [default = -320000];
+		float     oneof_defaulted_float    = 809 [default = 3.14159];
+		fixed64   oneof_defaulted_fixed64  = 810 [default = 640000];
+		sfixed64  oneof_defaulted_sfixed64 = 811 [default = -640000];
+		double    oneof_defaulted_double   = 812 [default = 3.14159265359];
+		string    oneof_defaulted_string   = 813 [default = "hello, \"world!\"\n"];
+		bytes     oneof_defaulted_bytes    = 814 [default = "dead\xde\xad\xbe\xefbeef"];
+
+		ChildEnum   oneof_defaulted_child_enum   = 815 [default = ALPHA];
+		SiblingEnum oneof_defaulted_sibling_enum = 816 [default = ALPHA];
+	}
+
+	// Extension fields.
+	extend Message {
+		// Optional fields.
+		optional bool     extension_optional_bool     = 10000;
+		optional int32    extension_optional_int32    = 10001;
+		optional sint32   extension_optional_sint32   = 10002;
+		optional uint32   extension_optional_uint32   = 10003;
+		optional int64    extension_optional_int64    = 10004;
+		optional sint64   extension_optional_sint64   = 10005;
+		optional uint64   extension_optional_uint64   = 10006;
+		optional fixed32  extension_optional_fixed32  = 10007;
+		optional sfixed32 extension_optional_sfixed32 = 10008;
+		optional float    extension_optional_float    = 10009;
+		optional fixed64  extension_optional_fixed64  = 10010;
+		optional sfixed64 extension_optional_sfixed64 = 10011;
+		optional double   extension_optional_double   = 10012;
+		optional string   extension_optional_string   = 10013;
+		optional bytes    extension_optional_bytes    = 10014;
+
+		optional ChildEnum      extension_optional_child_enum      = 10015;
+		optional ChildMessage   extension_optional_child_message   = 10016;
+		optional NamedGroup     extension_optional_named_group     = 10017;
+		optional SiblingEnum    extension_optional_sibling_enum    = 10018;
+		optional SiblingMessage extension_optional_sibling_message = 10019;
+		optional group ExtensionOptionalGroup = 10020 {
+			optional string f1 = 1;
+			required string f2 = 2;
+			repeated string f3 = 3;
+		}
+
+		// Optional default fields.
+		optional bool      extension_defaulted_bool     = 20000 [default = true];
+		optional int32     extension_defaulted_int32    = 20001 [default = -12345];
+		optional sint32    extension_defaulted_sint32   = 20002 [default = -3200];
+		optional uint32    extension_defaulted_uint32   = 20003 [default = 3200];
+		optional int64     extension_defaulted_int64    = 20004 [default = -123456789];
+		optional sint64    extension_defaulted_sint64   = 20005 [default = -6400];
+		optional uint64    extension_defaulted_uint64   = 20006 [default = 6400];
+		optional fixed32   extension_defaulted_fixed32  = 20007 [default = 320000];
+		optional sfixed32  extension_defaulted_sfixed32 = 20008 [default = -320000];
+		optional float     extension_defaulted_float    = 20009 [default = 3.14159];
+		optional fixed64   extension_defaulted_fixed64  = 20010 [default = 640000];
+		optional sfixed64  extension_defaulted_sfixed64 = 20011 [default = -640000];
+		optional double    extension_defaulted_double   = 20012 [default = 3.14159265359];
+		optional string    extension_defaulted_string   = 20013 [default = "hello, \"world!\"\n"];
+		optional bytes     extension_defaulted_bytes    = 20014 [default = "dead\xde\xad\xbe\xefbeef"];
+
+		optional ChildEnum   extension_defaulted_child_enum   = 20015 [default = ALPHA];
+		optional SiblingEnum extension_defaulted_sibling_enum = 20016 [default = ALPHA];
+
+		// Repeated fields.
+		repeated bool     extension_repeated_bool     = 30000;
+		repeated int32    extension_repeated_int32    = 30001;
+		repeated sint32   extension_repeated_sint32   = 30002;
+		repeated uint32   extension_repeated_uint32   = 30003;
+		repeated int64    extension_repeated_int64    = 30004;
+		repeated sint64   extension_repeated_sint64   = 30005;
+		repeated uint64   extension_repeated_uint64   = 30006;
+		repeated fixed32  extension_repeated_fixed32  = 30007;
+		repeated sfixed32 extension_repeated_sfixed32 = 30008;
+		repeated float    extension_repeated_float    = 30009;
+		repeated fixed64  extension_repeated_fixed64  = 30010;
+		repeated sfixed64 extension_repeated_sfixed64 = 30011;
+		repeated double   extension_repeated_double   = 30012;
+		repeated string   extension_repeated_string   = 30013;
+		repeated bytes    extension_repeated_bytes    = 30014;
+
+		repeated ChildEnum      extension_repeated_child_enum      = 30015;
+		repeated ChildMessage   extension_repeated_child_message   = 30016;
+		repeated NamedGroup     extension_repeated_named_group     = 30017;
+		repeated SiblingEnum    extension_repeated_sibling_enum    = 30018;
+		repeated SiblingMessage extension_repeated_sibling_message = 30019;
+		repeated group ExtensionRepeatedGroup = 30020 {
+			optional string f1 = 1;
+			required string f2 = 2;
+			repeated string f3 = 3;
+		}
+	}
+
+	extensions 10000 to max;
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20160519_a4ab9ec5/test.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20160519_a4ab9ec5/test.pb.go
new file mode 100644
index 000000000..19bfe41a7
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20160519_a4ab9ec5/test.pb.go
@@ -0,0 +1,3532 @@
+// 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.
+
+// Code generated by protoc-gen-go.
+// source: proto2_20160519_a4ab9ec5/test.proto
+// DO NOT EDIT!
+
+/*
+Package proto2_20160519_a4ab9ec5 is a generated protocol buffer package.
+
+It is generated from these files:
+	proto2_20160519_a4ab9ec5/test.proto
+
+It has these top-level messages:
+	SiblingMessage
+	Message
+*/
+package proto2_20160519_a4ab9ec5
+
+import proto "google.golang.org/protobuf/internal/protolegacy"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+const _ = proto.ProtoPackageIsVersion1
+
+type SiblingEnum int32
+
+const (
+	SiblingEnum_ALPHA   SiblingEnum = 0
+	SiblingEnum_BRAVO   SiblingEnum = 10
+	SiblingEnum_CHARLIE SiblingEnum = 200
+)
+
+var SiblingEnum_name = map[int32]string{
+	0:   "ALPHA",
+	10:  "BRAVO",
+	200: "CHARLIE",
+}
+var SiblingEnum_value = map[string]int32{
+	"ALPHA":   0,
+	"BRAVO":   10,
+	"CHARLIE": 200,
+}
+
+func (x SiblingEnum) Enum() *SiblingEnum {
+	p := new(SiblingEnum)
+	*p = x
+	return p
+}
+func (x SiblingEnum) String() string {
+	return proto.EnumName(SiblingEnum_name, int32(x))
+}
+func (x *SiblingEnum) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(SiblingEnum_value, data, "SiblingEnum")
+	if err != nil {
+		return err
+	}
+	*x = SiblingEnum(value)
+	return nil
+}
+func (SiblingEnum) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+type Message_ChildEnum int32
+
+const (
+	Message_ALPHA   Message_ChildEnum = 0
+	Message_BRAVO   Message_ChildEnum = 1
+	Message_CHARLIE Message_ChildEnum = 2
+)
+
+var Message_ChildEnum_name = map[int32]string{
+	0: "ALPHA",
+	1: "BRAVO",
+	2: "CHARLIE",
+}
+var Message_ChildEnum_value = map[string]int32{
+	"ALPHA":   0,
+	"BRAVO":   1,
+	"CHARLIE": 2,
+}
+
+func (x Message_ChildEnum) Enum() *Message_ChildEnum {
+	p := new(Message_ChildEnum)
+	*p = x
+	return p
+}
+func (x Message_ChildEnum) String() string {
+	return proto.EnumName(Message_ChildEnum_name, int32(x))
+}
+func (x *Message_ChildEnum) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(Message_ChildEnum_value, data, "Message_ChildEnum")
+	if err != nil {
+		return err
+	}
+	*x = Message_ChildEnum(value)
+	return nil
+}
+func (Message_ChildEnum) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{1, 0} }
+
+type SiblingMessage 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"`
+	F4               *Message `protobuf:"bytes,4,opt,name=f4" json:"f4,omitempty"`
+	XXX_unrecognized []byte   `json:"-"`
+}
+
+func (m *SiblingMessage) Reset()                    { *m = SiblingMessage{} }
+func (m *SiblingMessage) String() string            { return proto.CompactTextString(m) }
+func (*SiblingMessage) ProtoMessage()               {}
+func (*SiblingMessage) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *SiblingMessage) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *SiblingMessage) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *SiblingMessage) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+func (m *SiblingMessage) GetF4() *Message {
+	if m != nil {
+		return m.F4
+	}
+	return nil
+}
+
+type Message struct {
+	Namedgroup *Message_NamedGroup `protobuf:"group,1,opt,name=NamedGroup,json=namedgroup" json:"namedgroup,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      *Message_ChildEnum     `protobuf:"varint,115,opt,name=optional_child_enum,json=optionalChildEnum,enum=google.golang.org.proto2_20160519.Message_ChildEnum" json:"optional_child_enum,omitempty"`
+	OptionalChildMessage   *Message_ChildMessage  `protobuf:"bytes,116,opt,name=optional_child_message,json=optionalChildMessage" json:"optional_child_message,omitempty"`
+	OptionalNamedGroup     *Message_NamedGroup    `protobuf:"bytes,117,opt,name=optional_named_group,json=optionalNamedGroup" json:"optional_named_group,omitempty"`
+	OptionalSiblingEnum    *SiblingEnum           `protobuf:"varint,118,opt,name=optional_sibling_enum,json=optionalSiblingEnum,enum=google.golang.org.proto2_20160519.SiblingEnum" json:"optional_sibling_enum,omitempty"`
+	OptionalSiblingMessage *SiblingMessage        `protobuf:"bytes,119,opt,name=optional_sibling_message,json=optionalSiblingMessage" json:"optional_sibling_message,omitempty"`
+	Optionalgroup          *Message_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   *Message_ChildEnum `protobuf:"varint,215,opt,name=defaulted_child_enum,json=defaultedChildEnum,enum=google.golang.org.proto2_20160519.Message_ChildEnum,def=0" json:"defaulted_child_enum,omitempty"`
+	DefaultedSiblingEnum *SiblingEnum       `protobuf:"varint,216,opt,name=defaulted_sibling_enum,json=defaultedSiblingEnum,enum=google.golang.org.proto2_20160519.SiblingEnum,def=0" 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      *Message_ChildEnum     `protobuf:"varint,315,req,name=required_child_enum,json=requiredChildEnum,enum=google.golang.org.proto2_20160519.Message_ChildEnum" json:"required_child_enum,omitempty"`
+	RequiredChildMessage   *Message_ChildMessage  `protobuf:"bytes,316,req,name=required_child_message,json=requiredChildMessage" json:"required_child_message,omitempty"`
+	RequiredNamedGroup     *Message_NamedGroup    `protobuf:"bytes,317,req,name=required_named_group,json=requiredNamedGroup" json:"required_named_group,omitempty"`
+	RequiredSiblingEnum    *SiblingEnum           `protobuf:"varint,318,req,name=required_sibling_enum,json=requiredSiblingEnum,enum=google.golang.org.proto2_20160519.SiblingEnum" json:"required_sibling_enum,omitempty"`
+	RequiredSiblingMessage *SiblingMessage        `protobuf:"bytes,319,req,name=required_sibling_message,json=requiredSiblingMessage" json:"required_sibling_message,omitempty"`
+	Requiredgroup          *Message_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   *Message_ChildEnum `protobuf:"varint,415,req,name=required_defaulted_child_enum,json=requiredDefaultedChildEnum,enum=google.golang.org.proto2_20160519.Message_ChildEnum,def=0" json:"required_defaulted_child_enum,omitempty"`
+	RequiredDefaultedSiblingEnum *SiblingEnum       `protobuf:"varint,416,req,name=required_defaulted_sibling_enum,json=requiredDefaultedSiblingEnum,enum=google.golang.org.proto2_20160519.SiblingEnum,def=0" 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      []Message_ChildEnum      `protobuf:"varint,515,rep,name=repeated_child_enum,json=repeatedChildEnum,enum=google.golang.org.proto2_20160519.Message_ChildEnum" json:"repeated_child_enum,omitempty"`
+	RepeatedChildMessage   []*Message_ChildMessage  `protobuf:"bytes,516,rep,name=repeated_child_message,json=repeatedChildMessage" json:"repeated_child_message,omitempty"`
+	RepeatedNamedGroup     []*Message_NamedGroup    `protobuf:"bytes,517,rep,name=repeated_named_group,json=repeatedNamedGroup" json:"repeated_named_group,omitempty"`
+	RepeatedSiblingEnum    []SiblingEnum            `protobuf:"varint,518,rep,name=repeated_sibling_enum,json=repeatedSiblingEnum,enum=google.golang.org.proto2_20160519.SiblingEnum" json:"repeated_sibling_enum,omitempty"`
+	RepeatedSiblingMessage []*SiblingMessage        `protobuf:"bytes,519,rep,name=repeated_sibling_message,json=repeatedSiblingMessage" json:"repeated_sibling_message,omitempty"`
+	Repeatedgroup          []*Message_RepeatedGroup `protobuf:"group,520,rep,name=RepeatedGroup,json=repeatedgroup" json:"repeatedgroup,omitempty"`
+	// Map fields.
+	MapBoolBool           map[bool]bool                  `protobuf:"bytes,600,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,601,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,602,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,603,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,604,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,605,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,606,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,607,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,608,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,609,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,610,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,611,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,612,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,613,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,614,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"`
+	MapBoolChildEnum      map[bool]Message_ChildEnum     `protobuf:"bytes,615,rep,name=map_bool_child_enum,json=mapBoolChildEnum" json:"map_bool_child_enum,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=google.golang.org.proto2_20160519.Message_ChildEnum"`
+	MapBoolChildMessage   map[bool]*Message_ChildMessage `protobuf:"bytes,616,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"`
+	MapBoolNamedGroup     map[bool]*Message_NamedGroup   `protobuf:"bytes,617,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"`
+	MapBoolSiblingEnum    map[bool]SiblingEnum           `protobuf:"bytes,618,rep,name=map_bool_sibling_enum,json=mapBoolSiblingEnum" json:"map_bool_sibling_enum,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=google.golang.org.proto2_20160519.SiblingEnum"`
+	MapBoolSiblingMessage map[bool]*SiblingMessage       `protobuf:"bytes,619,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"`
+	MapInt32Bool          map[int32]bool                 `protobuf:"bytes,620,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,621,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,622,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,623,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,624,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,625,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,626,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,627,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.
+	//
+	// Types that are valid to be assigned to OneofUnion:
+	//	*Message_OneofBool
+	//	*Message_OneofInt32
+	//	*Message_OneofSint32
+	//	*Message_OneofUint32
+	//	*Message_OneofInt64
+	//	*Message_OneofSint64
+	//	*Message_OneofUint64
+	//	*Message_OneofFixed32
+	//	*Message_OneofSfixed32
+	//	*Message_OneofFloat
+	//	*Message_OneofFixed64
+	//	*Message_OneofSfixed64
+	//	*Message_OneofDouble
+	//	*Message_OneofString
+	//	*Message_OneofBytes
+	//	*Message_OneofChildEnum
+	//	*Message_OneofChildMessage
+	//	*Message_OneofNamedGroup
+	//	*Message_OneofSiblingEnum
+	//	*Message_OneofSiblingMessage
+	//	*Message_Oneofgroup
+	//	*Message_OneofString1
+	//	*Message_OneofString2
+	//	*Message_OneofString3
+	OneofUnion isMessage_OneofUnion `protobuf_oneof:"oneof_union"`
+	// Oneof default fields.
+	//
+	// Types that are valid to be assigned to OneofDefaultedUnion:
+	//	*Message_OneofDefaultedBool
+	//	*Message_OneofDefaultedInt32
+	//	*Message_OneofDefaultedSint32
+	//	*Message_OneofDefaultedUint32
+	//	*Message_OneofDefaultedInt64
+	//	*Message_OneofDefaultedSint64
+	//	*Message_OneofDefaultedUint64
+	//	*Message_OneofDefaultedFixed32
+	//	*Message_OneofDefaultedSfixed32
+	//	*Message_OneofDefaultedFloat
+	//	*Message_OneofDefaultedFixed64
+	//	*Message_OneofDefaultedSfixed64
+	//	*Message_OneofDefaultedDouble
+	//	*Message_OneofDefaultedString
+	//	*Message_OneofDefaultedBytes
+	//	*Message_OneofDefaultedChildEnum
+	//	*Message_OneofDefaultedSiblingEnum
+	OneofDefaultedUnion isMessage_OneofDefaultedUnion `protobuf_oneof:"oneof_defaulted_union"`
+	XXX_extensions      map[int32]proto.Extension     `json:"-"`
+	XXX_unrecognized    []byte                        `json:"-"`
+}
+
+func (m *Message) Reset()                    { *m = Message{} }
+func (m *Message) String() string            { return proto.CompactTextString(m) }
+func (*Message) ProtoMessage()               {}
+func (*Message) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+var extRange_Message = []proto.ExtensionRange{
+	{10000, 536870911},
+}
+
+func (*Message) ExtensionRangeArray() []proto.ExtensionRange {
+	return extRange_Message
+}
+func (m *Message) ExtensionMap() map[int32]proto.Extension {
+	if m.XXX_extensions == nil {
+		m.XXX_extensions = make(map[int32]proto.Extension)
+	}
+	return m.XXX_extensions
+}
+
+const Default_Message_DefaultedBool bool = true
+const Default_Message_DefaultedInt32 int32 = -12345
+const Default_Message_DefaultedSint32 int32 = -3200
+const Default_Message_DefaultedUint32 uint32 = 3200
+const Default_Message_DefaultedInt64 int64 = -123456789
+const Default_Message_DefaultedSint64 int64 = -6400
+const Default_Message_DefaultedUint64 uint64 = 6400
+const Default_Message_DefaultedFixed32 uint32 = 320000
+const Default_Message_DefaultedSfixed32 int32 = -320000
+const Default_Message_DefaultedFloat float32 = 3.14159
+const Default_Message_DefaultedFixed64 uint64 = 640000
+const Default_Message_DefaultedSfixed64 int64 = -640000
+const Default_Message_DefaultedDouble float64 = 3.14159265359
+const Default_Message_DefaultedString string = "hello, \"world!\"\n"
+
+var Default_Message_DefaultedBytes []byte = []byte("dead\\336\\255\\276\\357beef")
+
+const Default_Message_DefaultedChildEnum Message_ChildEnum = Message_ALPHA
+const Default_Message_DefaultedSiblingEnum SiblingEnum = SiblingEnum_ALPHA
+const Default_Message_RequiredDefaultedBool bool = true
+const Default_Message_RequiredDefaultedInt32 int32 = -12345
+const Default_Message_RequiredDefaultedSint32 int32 = -3200
+const Default_Message_RequiredDefaultedUint32 uint32 = 3200
+const Default_Message_RequiredDefaultedInt64 int64 = -123456789
+const Default_Message_RequiredDefaultedSint64 int64 = -6400
+const Default_Message_RequiredDefaultedUint64 uint64 = 6400
+const Default_Message_RequiredDefaultedFixed32 uint32 = 320000
+const Default_Message_RequiredDefaultedSfixed32 int32 = -320000
+const Default_Message_RequiredDefaultedFloat float32 = 3.14159
+const Default_Message_RequiredDefaultedFixed64 uint64 = 640000
+const Default_Message_RequiredDefaultedSfixed64 int64 = -640000
+const Default_Message_RequiredDefaultedDouble float64 = 3.14159265359
+const Default_Message_RequiredDefaultedString string = "hello, \"world!\"\n"
+
+var Default_Message_RequiredDefaultedBytes []byte = []byte("dead\\336\\255\\276\\357beef")
+
+const Default_Message_RequiredDefaultedChildEnum Message_ChildEnum = Message_ALPHA
+const Default_Message_RequiredDefaultedSiblingEnum SiblingEnum = SiblingEnum_ALPHA
+const Default_Message_OneofDefaultedBool bool = true
+const Default_Message_OneofDefaultedInt32 int32 = -12345
+const Default_Message_OneofDefaultedSint32 int32 = -3200
+const Default_Message_OneofDefaultedUint32 uint32 = 3200
+const Default_Message_OneofDefaultedInt64 int64 = -123456789
+const Default_Message_OneofDefaultedSint64 int64 = -6400
+const Default_Message_OneofDefaultedUint64 uint64 = 6400
+const Default_Message_OneofDefaultedFixed32 uint32 = 320000
+const Default_Message_OneofDefaultedSfixed32 int32 = -320000
+const Default_Message_OneofDefaultedFloat float32 = 3.14159
+const Default_Message_OneofDefaultedFixed64 uint64 = 640000
+const Default_Message_OneofDefaultedSfixed64 int64 = -640000
+const Default_Message_OneofDefaultedDouble float64 = 3.14159265359
+const Default_Message_OneofDefaultedString string = "hello, \"world!\"\n"
+
+var Default_Message_OneofDefaultedBytes []byte = []byte("dead\\336\\255\\276\\357beef")
+
+const Default_Message_OneofDefaultedChildEnum Message_ChildEnum = Message_ALPHA
+const Default_Message_OneofDefaultedSiblingEnum SiblingEnum = SiblingEnum_ALPHA
+
+type isMessage_OneofUnion interface{ isMessage_OneofUnion() }
+type isMessage_OneofDefaultedUnion interface{ isMessage_OneofDefaultedUnion() }
+
+type Message_OneofBool struct {
+	OneofBool bool `protobuf:"varint,700,opt,name=oneof_bool,json=oneofBool,oneof"`
+}
+type Message_OneofInt32 struct {
+	OneofInt32 int32 `protobuf:"varint,701,opt,name=oneof_int32,json=oneofInt32,oneof"`
+}
+type Message_OneofSint32 struct {
+	OneofSint32 int32 `protobuf:"zigzag32,702,opt,name=oneof_sint32,json=oneofSint32,oneof"`
+}
+type Message_OneofUint32 struct {
+	OneofUint32 uint32 `protobuf:"varint,703,opt,name=oneof_uint32,json=oneofUint32,oneof"`
+}
+type Message_OneofInt64 struct {
+	OneofInt64 int64 `protobuf:"varint,704,opt,name=oneof_int64,json=oneofInt64,oneof"`
+}
+type Message_OneofSint64 struct {
+	OneofSint64 int64 `protobuf:"zigzag64,705,opt,name=oneof_sint64,json=oneofSint64,oneof"`
+}
+type Message_OneofUint64 struct {
+	OneofUint64 uint64 `protobuf:"varint,706,opt,name=oneof_uint64,json=oneofUint64,oneof"`
+}
+type Message_OneofFixed32 struct {
+	OneofFixed32 uint32 `protobuf:"fixed32,707,opt,name=oneof_fixed32,json=oneofFixed32,oneof"`
+}
+type Message_OneofSfixed32 struct {
+	OneofSfixed32 int32 `protobuf:"fixed32,708,opt,name=oneof_sfixed32,json=oneofSfixed32,oneof"`
+}
+type Message_OneofFloat struct {
+	OneofFloat float32 `protobuf:"fixed32,709,opt,name=oneof_float,json=oneofFloat,oneof"`
+}
+type Message_OneofFixed64 struct {
+	OneofFixed64 uint64 `protobuf:"fixed64,710,opt,name=oneof_fixed64,json=oneofFixed64,oneof"`
+}
+type Message_OneofSfixed64 struct {
+	OneofSfixed64 int64 `protobuf:"fixed64,711,opt,name=oneof_sfixed64,json=oneofSfixed64,oneof"`
+}
+type Message_OneofDouble struct {
+	OneofDouble float64 `protobuf:"fixed64,712,opt,name=oneof_double,json=oneofDouble,oneof"`
+}
+type Message_OneofString struct {
+	OneofString string `protobuf:"bytes,713,opt,name=oneof_string,json=oneofString,oneof"`
+}
+type Message_OneofBytes struct {
+	OneofBytes []byte `protobuf:"bytes,714,opt,name=oneof_bytes,json=oneofBytes,oneof"`
+}
+type Message_OneofChildEnum struct {
+	OneofChildEnum Message_ChildEnum `protobuf:"varint,715,opt,name=oneof_child_enum,json=oneofChildEnum,enum=google.golang.org.proto2_20160519.Message_ChildEnum,oneof"`
+}
+type Message_OneofChildMessage struct {
+	OneofChildMessage *Message_ChildMessage `protobuf:"bytes,716,opt,name=oneof_child_message,json=oneofChildMessage,oneof"`
+}
+type Message_OneofNamedGroup struct {
+	OneofNamedGroup *Message_NamedGroup `protobuf:"bytes,717,opt,name=oneof_named_group,json=oneofNamedGroup,oneof"`
+}
+type Message_OneofSiblingEnum struct {
+	OneofSiblingEnum SiblingEnum `protobuf:"varint,718,opt,name=oneof_sibling_enum,json=oneofSiblingEnum,enum=google.golang.org.proto2_20160519.SiblingEnum,oneof"`
+}
+type Message_OneofSiblingMessage struct {
+	OneofSiblingMessage *SiblingMessage `protobuf:"bytes,719,opt,name=oneof_sibling_message,json=oneofSiblingMessage,oneof"`
+}
+type Message_Oneofgroup struct {
+	Oneofgroup *Message_OneofGroup `protobuf:"group,720,opt,name=OneofGroup,json=oneofgroup,oneof"`
+}
+type Message_OneofString1 struct {
+	OneofString1 string `protobuf:"bytes,721,opt,name=oneof_string1,json=oneofString1,oneof"`
+}
+type Message_OneofString2 struct {
+	OneofString2 string `protobuf:"bytes,722,opt,name=oneof_string2,json=oneofString2,oneof"`
+}
+type Message_OneofString3 struct {
+	OneofString3 string `protobuf:"bytes,723,opt,name=oneof_string3,json=oneofString3,oneof"`
+}
+type Message_OneofDefaultedBool struct {
+	OneofDefaultedBool bool `protobuf:"varint,800,opt,name=oneof_defaulted_bool,json=oneofDefaultedBool,oneof,def=1"`
+}
+type Message_OneofDefaultedInt32 struct {
+	OneofDefaultedInt32 int32 `protobuf:"varint,801,opt,name=oneof_defaulted_int32,json=oneofDefaultedInt32,oneof,def=-12345"`
+}
+type Message_OneofDefaultedSint32 struct {
+	OneofDefaultedSint32 int32 `protobuf:"zigzag32,802,opt,name=oneof_defaulted_sint32,json=oneofDefaultedSint32,oneof,def=-3200"`
+}
+type Message_OneofDefaultedUint32 struct {
+	OneofDefaultedUint32 uint32 `protobuf:"varint,803,opt,name=oneof_defaulted_uint32,json=oneofDefaultedUint32,oneof,def=3200"`
+}
+type Message_OneofDefaultedInt64 struct {
+	OneofDefaultedInt64 int64 `protobuf:"varint,804,opt,name=oneof_defaulted_int64,json=oneofDefaultedInt64,oneof,def=-123456789"`
+}
+type Message_OneofDefaultedSint64 struct {
+	OneofDefaultedSint64 int64 `protobuf:"zigzag64,805,opt,name=oneof_defaulted_sint64,json=oneofDefaultedSint64,oneof,def=-6400"`
+}
+type Message_OneofDefaultedUint64 struct {
+	OneofDefaultedUint64 uint64 `protobuf:"varint,806,opt,name=oneof_defaulted_uint64,json=oneofDefaultedUint64,oneof,def=6400"`
+}
+type Message_OneofDefaultedFixed32 struct {
+	OneofDefaultedFixed32 uint32 `protobuf:"fixed32,807,opt,name=oneof_defaulted_fixed32,json=oneofDefaultedFixed32,oneof,def=320000"`
+}
+type Message_OneofDefaultedSfixed32 struct {
+	OneofDefaultedSfixed32 int32 `protobuf:"fixed32,808,opt,name=oneof_defaulted_sfixed32,json=oneofDefaultedSfixed32,oneof,def=-320000"`
+}
+type Message_OneofDefaultedFloat struct {
+	OneofDefaultedFloat float32 `protobuf:"fixed32,809,opt,name=oneof_defaulted_float,json=oneofDefaultedFloat,oneof,def=3.14159"`
+}
+type Message_OneofDefaultedFixed64 struct {
+	OneofDefaultedFixed64 uint64 `protobuf:"fixed64,810,opt,name=oneof_defaulted_fixed64,json=oneofDefaultedFixed64,oneof,def=640000"`
+}
+type Message_OneofDefaultedSfixed64 struct {
+	OneofDefaultedSfixed64 int64 `protobuf:"fixed64,811,opt,name=oneof_defaulted_sfixed64,json=oneofDefaultedSfixed64,oneof,def=-640000"`
+}
+type Message_OneofDefaultedDouble struct {
+	OneofDefaultedDouble float64 `protobuf:"fixed64,812,opt,name=oneof_defaulted_double,json=oneofDefaultedDouble,oneof,def=3.14159265359"`
+}
+type Message_OneofDefaultedString struct {
+	OneofDefaultedString string `protobuf:"bytes,813,opt,name=oneof_defaulted_string,json=oneofDefaultedString,oneof,def=hello, \"world!\"\n"`
+}
+type Message_OneofDefaultedBytes struct {
+	OneofDefaultedBytes []byte `protobuf:"bytes,814,opt,name=oneof_defaulted_bytes,json=oneofDefaultedBytes,oneof,def=dead\\336\\255\\276\\357beef"`
+}
+type Message_OneofDefaultedChildEnum struct {
+	OneofDefaultedChildEnum Message_ChildEnum `protobuf:"varint,815,opt,name=oneof_defaulted_child_enum,json=oneofDefaultedChildEnum,enum=google.golang.org.proto2_20160519.Message_ChildEnum,oneof,def=0"`
+}
+type Message_OneofDefaultedSiblingEnum struct {
+	OneofDefaultedSiblingEnum SiblingEnum `protobuf:"varint,816,opt,name=oneof_defaulted_sibling_enum,json=oneofDefaultedSiblingEnum,enum=google.golang.org.proto2_20160519.SiblingEnum,oneof,def=0"`
+}
+
+func (*Message_OneofBool) isMessage_OneofUnion()                          {}
+func (*Message_OneofInt32) isMessage_OneofUnion()                         {}
+func (*Message_OneofSint32) isMessage_OneofUnion()                        {}
+func (*Message_OneofUint32) isMessage_OneofUnion()                        {}
+func (*Message_OneofInt64) isMessage_OneofUnion()                         {}
+func (*Message_OneofSint64) isMessage_OneofUnion()                        {}
+func (*Message_OneofUint64) isMessage_OneofUnion()                        {}
+func (*Message_OneofFixed32) isMessage_OneofUnion()                       {}
+func (*Message_OneofSfixed32) isMessage_OneofUnion()                      {}
+func (*Message_OneofFloat) isMessage_OneofUnion()                         {}
+func (*Message_OneofFixed64) isMessage_OneofUnion()                       {}
+func (*Message_OneofSfixed64) isMessage_OneofUnion()                      {}
+func (*Message_OneofDouble) isMessage_OneofUnion()                        {}
+func (*Message_OneofString) isMessage_OneofUnion()                        {}
+func (*Message_OneofBytes) isMessage_OneofUnion()                         {}
+func (*Message_OneofChildEnum) isMessage_OneofUnion()                     {}
+func (*Message_OneofChildMessage) isMessage_OneofUnion()                  {}
+func (*Message_OneofNamedGroup) isMessage_OneofUnion()                    {}
+func (*Message_OneofSiblingEnum) isMessage_OneofUnion()                   {}
+func (*Message_OneofSiblingMessage) isMessage_OneofUnion()                {}
+func (*Message_Oneofgroup) isMessage_OneofUnion()                         {}
+func (*Message_OneofString1) isMessage_OneofUnion()                       {}
+func (*Message_OneofString2) isMessage_OneofUnion()                       {}
+func (*Message_OneofString3) isMessage_OneofUnion()                       {}
+func (*Message_OneofDefaultedBool) isMessage_OneofDefaultedUnion()        {}
+func (*Message_OneofDefaultedInt32) isMessage_OneofDefaultedUnion()       {}
+func (*Message_OneofDefaultedSint32) isMessage_OneofDefaultedUnion()      {}
+func (*Message_OneofDefaultedUint32) isMessage_OneofDefaultedUnion()      {}
+func (*Message_OneofDefaultedInt64) isMessage_OneofDefaultedUnion()       {}
+func (*Message_OneofDefaultedSint64) isMessage_OneofDefaultedUnion()      {}
+func (*Message_OneofDefaultedUint64) isMessage_OneofDefaultedUnion()      {}
+func (*Message_OneofDefaultedFixed32) isMessage_OneofDefaultedUnion()     {}
+func (*Message_OneofDefaultedSfixed32) isMessage_OneofDefaultedUnion()    {}
+func (*Message_OneofDefaultedFloat) isMessage_OneofDefaultedUnion()       {}
+func (*Message_OneofDefaultedFixed64) isMessage_OneofDefaultedUnion()     {}
+func (*Message_OneofDefaultedSfixed64) isMessage_OneofDefaultedUnion()    {}
+func (*Message_OneofDefaultedDouble) isMessage_OneofDefaultedUnion()      {}
+func (*Message_OneofDefaultedString) isMessage_OneofDefaultedUnion()      {}
+func (*Message_OneofDefaultedBytes) isMessage_OneofDefaultedUnion()       {}
+func (*Message_OneofDefaultedChildEnum) isMessage_OneofDefaultedUnion()   {}
+func (*Message_OneofDefaultedSiblingEnum) isMessage_OneofDefaultedUnion() {}
+
+func (m *Message) GetOneofUnion() isMessage_OneofUnion {
+	if m != nil {
+		return m.OneofUnion
+	}
+	return nil
+}
+func (m *Message) GetOneofDefaultedUnion() isMessage_OneofDefaultedUnion {
+	if m != nil {
+		return m.OneofDefaultedUnion
+	}
+	return nil
+}
+
+func (m *Message) GetNamedgroup() *Message_NamedGroup {
+	if m != nil {
+		return m.Namedgroup
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalBool() bool {
+	if m != nil && m.OptionalBool != nil {
+		return *m.OptionalBool
+	}
+	return false
+}
+
+func (m *Message) GetOptionalInt32() int32 {
+	if m != nil && m.OptionalInt32 != nil {
+		return *m.OptionalInt32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSint32() int32 {
+	if m != nil && m.OptionalSint32 != nil {
+		return *m.OptionalSint32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalUint32() uint32 {
+	if m != nil && m.OptionalUint32 != nil {
+		return *m.OptionalUint32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalInt64() int64 {
+	if m != nil && m.OptionalInt64 != nil {
+		return *m.OptionalInt64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSint64() int64 {
+	if m != nil && m.OptionalSint64 != nil {
+		return *m.OptionalSint64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalUint64() uint64 {
+	if m != nil && m.OptionalUint64 != nil {
+		return *m.OptionalUint64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalFixed32() uint32 {
+	if m != nil && m.OptionalFixed32 != nil {
+		return *m.OptionalFixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSfixed32() int32 {
+	if m != nil && m.OptionalSfixed32 != nil {
+		return *m.OptionalSfixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalFloat() float32 {
+	if m != nil && m.OptionalFloat != nil {
+		return *m.OptionalFloat
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalFixed64() uint64 {
+	if m != nil && m.OptionalFixed64 != nil {
+		return *m.OptionalFixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSfixed64() int64 {
+	if m != nil && m.OptionalSfixed64 != nil {
+		return *m.OptionalSfixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalDouble() float64 {
+	if m != nil && m.OptionalDouble != nil {
+		return *m.OptionalDouble
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalString() string {
+	if m != nil && m.OptionalString != nil {
+		return *m.OptionalString
+	}
+	return ""
+}
+
+func (m *Message) GetOptionalBytes() []byte {
+	if m != nil {
+		return m.OptionalBytes
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalChildEnum() Message_ChildEnum {
+	if m != nil && m.OptionalChildEnum != nil {
+		return *m.OptionalChildEnum
+	}
+	return Message_ALPHA
+}
+
+func (m *Message) GetOptionalChildMessage() *Message_ChildMessage {
+	if m != nil {
+		return m.OptionalChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalNamedGroup() *Message_NamedGroup {
+	if m != nil {
+		return m.OptionalNamedGroup
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalSiblingEnum() SiblingEnum {
+	if m != nil && m.OptionalSiblingEnum != nil {
+		return *m.OptionalSiblingEnum
+	}
+	return SiblingEnum_ALPHA
+}
+
+func (m *Message) GetOptionalSiblingMessage() *SiblingMessage {
+	if m != nil {
+		return m.OptionalSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalgroup() *Message_OptionalGroup {
+	if m != nil {
+		return m.Optionalgroup
+	}
+	return nil
+}
+
+func (m *Message) GetDefaultedBool() bool {
+	if m != nil && m.DefaultedBool != nil {
+		return *m.DefaultedBool
+	}
+	return Default_Message_DefaultedBool
+}
+
+func (m *Message) GetDefaultedInt32() int32 {
+	if m != nil && m.DefaultedInt32 != nil {
+		return *m.DefaultedInt32
+	}
+	return Default_Message_DefaultedInt32
+}
+
+func (m *Message) GetDefaultedSint32() int32 {
+	if m != nil && m.DefaultedSint32 != nil {
+		return *m.DefaultedSint32
+	}
+	return Default_Message_DefaultedSint32
+}
+
+func (m *Message) GetDefaultedUint32() uint32 {
+	if m != nil && m.DefaultedUint32 != nil {
+		return *m.DefaultedUint32
+	}
+	return Default_Message_DefaultedUint32
+}
+
+func (m *Message) GetDefaultedInt64() int64 {
+	if m != nil && m.DefaultedInt64 != nil {
+		return *m.DefaultedInt64
+	}
+	return Default_Message_DefaultedInt64
+}
+
+func (m *Message) GetDefaultedSint64() int64 {
+	if m != nil && m.DefaultedSint64 != nil {
+		return *m.DefaultedSint64
+	}
+	return Default_Message_DefaultedSint64
+}
+
+func (m *Message) GetDefaultedUint64() uint64 {
+	if m != nil && m.DefaultedUint64 != nil {
+		return *m.DefaultedUint64
+	}
+	return Default_Message_DefaultedUint64
+}
+
+func (m *Message) GetDefaultedFixed32() uint32 {
+	if m != nil && m.DefaultedFixed32 != nil {
+		return *m.DefaultedFixed32
+	}
+	return Default_Message_DefaultedFixed32
+}
+
+func (m *Message) GetDefaultedSfixed32() int32 {
+	if m != nil && m.DefaultedSfixed32 != nil {
+		return *m.DefaultedSfixed32
+	}
+	return Default_Message_DefaultedSfixed32
+}
+
+func (m *Message) GetDefaultedFloat() float32 {
+	if m != nil && m.DefaultedFloat != nil {
+		return *m.DefaultedFloat
+	}
+	return Default_Message_DefaultedFloat
+}
+
+func (m *Message) GetDefaultedFixed64() uint64 {
+	if m != nil && m.DefaultedFixed64 != nil {
+		return *m.DefaultedFixed64
+	}
+	return Default_Message_DefaultedFixed64
+}
+
+func (m *Message) GetDefaultedSfixed64() int64 {
+	if m != nil && m.DefaultedSfixed64 != nil {
+		return *m.DefaultedSfixed64
+	}
+	return Default_Message_DefaultedSfixed64
+}
+
+func (m *Message) GetDefaultedDouble() float64 {
+	if m != nil && m.DefaultedDouble != nil {
+		return *m.DefaultedDouble
+	}
+	return Default_Message_DefaultedDouble
+}
+
+func (m *Message) GetDefaultedString() string {
+	if m != nil && m.DefaultedString != nil {
+		return *m.DefaultedString
+	}
+	return Default_Message_DefaultedString
+}
+
+func (m *Message) GetDefaultedBytes() []byte {
+	if m != nil && m.DefaultedBytes != nil {
+		return m.DefaultedBytes
+	}
+	return append([]byte(nil), Default_Message_DefaultedBytes...)
+}
+
+func (m *Message) GetDefaultedChildEnum() Message_ChildEnum {
+	if m != nil && m.DefaultedChildEnum != nil {
+		return *m.DefaultedChildEnum
+	}
+	return Default_Message_DefaultedChildEnum
+}
+
+func (m *Message) GetDefaultedSiblingEnum() SiblingEnum {
+	if m != nil && m.DefaultedSiblingEnum != nil {
+		return *m.DefaultedSiblingEnum
+	}
+	return Default_Message_DefaultedSiblingEnum
+}
+
+func (m *Message) GetRequiredBool() bool {
+	if m != nil && m.RequiredBool != nil {
+		return *m.RequiredBool
+	}
+	return false
+}
+
+func (m *Message) GetRequiredInt32() int32 {
+	if m != nil && m.RequiredInt32 != nil {
+		return *m.RequiredInt32
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredSint32() int32 {
+	if m != nil && m.RequiredSint32 != nil {
+		return *m.RequiredSint32
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredUint32() uint32 {
+	if m != nil && m.RequiredUint32 != nil {
+		return *m.RequiredUint32
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredInt64() int64 {
+	if m != nil && m.RequiredInt64 != nil {
+		return *m.RequiredInt64
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredSint64() int64 {
+	if m != nil && m.RequiredSint64 != nil {
+		return *m.RequiredSint64
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredUint64() uint64 {
+	if m != nil && m.RequiredUint64 != nil {
+		return *m.RequiredUint64
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredFixed32() uint32 {
+	if m != nil && m.RequiredFixed32 != nil {
+		return *m.RequiredFixed32
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredSfixed32() int32 {
+	if m != nil && m.RequiredSfixed32 != nil {
+		return *m.RequiredSfixed32
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredFloat() float32 {
+	if m != nil && m.RequiredFloat != nil {
+		return *m.RequiredFloat
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredFixed64() uint64 {
+	if m != nil && m.RequiredFixed64 != nil {
+		return *m.RequiredFixed64
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredSfixed64() int64 {
+	if m != nil && m.RequiredSfixed64 != nil {
+		return *m.RequiredSfixed64
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredDouble() float64 {
+	if m != nil && m.RequiredDouble != nil {
+		return *m.RequiredDouble
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredString() string {
+	if m != nil && m.RequiredString != nil {
+		return *m.RequiredString
+	}
+	return ""
+}
+
+func (m *Message) GetRequiredBytes() []byte {
+	if m != nil {
+		return m.RequiredBytes
+	}
+	return nil
+}
+
+func (m *Message) GetRequiredChildEnum() Message_ChildEnum {
+	if m != nil && m.RequiredChildEnum != nil {
+		return *m.RequiredChildEnum
+	}
+	return Message_ALPHA
+}
+
+func (m *Message) GetRequiredChildMessage() *Message_ChildMessage {
+	if m != nil {
+		return m.RequiredChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRequiredNamedGroup() *Message_NamedGroup {
+	if m != nil {
+		return m.RequiredNamedGroup
+	}
+	return nil
+}
+
+func (m *Message) GetRequiredSiblingEnum() SiblingEnum {
+	if m != nil && m.RequiredSiblingEnum != nil {
+		return *m.RequiredSiblingEnum
+	}
+	return SiblingEnum_ALPHA
+}
+
+func (m *Message) GetRequiredSiblingMessage() *SiblingMessage {
+	if m != nil {
+		return m.RequiredSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRequiredgroup() *Message_RequiredGroup {
+	if m != nil {
+		return m.Requiredgroup
+	}
+	return nil
+}
+
+func (m *Message) GetRequiredDefaultedBool() bool {
+	if m != nil && m.RequiredDefaultedBool != nil {
+		return *m.RequiredDefaultedBool
+	}
+	return Default_Message_RequiredDefaultedBool
+}
+
+func (m *Message) GetRequiredDefaultedInt32() int32 {
+	if m != nil && m.RequiredDefaultedInt32 != nil {
+		return *m.RequiredDefaultedInt32
+	}
+	return Default_Message_RequiredDefaultedInt32
+}
+
+func (m *Message) GetRequiredDefaultedSint32() int32 {
+	if m != nil && m.RequiredDefaultedSint32 != nil {
+		return *m.RequiredDefaultedSint32
+	}
+	return Default_Message_RequiredDefaultedSint32
+}
+
+func (m *Message) GetRequiredDefaultedUint32() uint32 {
+	if m != nil && m.RequiredDefaultedUint32 != nil {
+		return *m.RequiredDefaultedUint32
+	}
+	return Default_Message_RequiredDefaultedUint32
+}
+
+func (m *Message) GetRequiredDefaultedInt64() int64 {
+	if m != nil && m.RequiredDefaultedInt64 != nil {
+		return *m.RequiredDefaultedInt64
+	}
+	return Default_Message_RequiredDefaultedInt64
+}
+
+func (m *Message) GetRequiredDefaultedSint64() int64 {
+	if m != nil && m.RequiredDefaultedSint64 != nil {
+		return *m.RequiredDefaultedSint64
+	}
+	return Default_Message_RequiredDefaultedSint64
+}
+
+func (m *Message) GetRequiredDefaultedUint64() uint64 {
+	if m != nil && m.RequiredDefaultedUint64 != nil {
+		return *m.RequiredDefaultedUint64
+	}
+	return Default_Message_RequiredDefaultedUint64
+}
+
+func (m *Message) GetRequiredDefaultedFixed32() uint32 {
+	if m != nil && m.RequiredDefaultedFixed32 != nil {
+		return *m.RequiredDefaultedFixed32
+	}
+	return Default_Message_RequiredDefaultedFixed32
+}
+
+func (m *Message) GetRequiredDefaultedSfixed32() int32 {
+	if m != nil && m.RequiredDefaultedSfixed32 != nil {
+		return *m.RequiredDefaultedSfixed32
+	}
+	return Default_Message_RequiredDefaultedSfixed32
+}
+
+func (m *Message) GetRequiredDefaultedFloat() float32 {
+	if m != nil && m.RequiredDefaultedFloat != nil {
+		return *m.RequiredDefaultedFloat
+	}
+	return Default_Message_RequiredDefaultedFloat
+}
+
+func (m *Message) GetRequiredDefaultedFixed64() uint64 {
+	if m != nil && m.RequiredDefaultedFixed64 != nil {
+		return *m.RequiredDefaultedFixed64
+	}
+	return Default_Message_RequiredDefaultedFixed64
+}
+
+func (m *Message) GetRequiredDefaultedSfixed64() int64 {
+	if m != nil && m.RequiredDefaultedSfixed64 != nil {
+		return *m.RequiredDefaultedSfixed64
+	}
+	return Default_Message_RequiredDefaultedSfixed64
+}
+
+func (m *Message) GetRequiredDefaultedDouble() float64 {
+	if m != nil && m.RequiredDefaultedDouble != nil {
+		return *m.RequiredDefaultedDouble
+	}
+	return Default_Message_RequiredDefaultedDouble
+}
+
+func (m *Message) GetRequiredDefaultedString() string {
+	if m != nil && m.RequiredDefaultedString != nil {
+		return *m.RequiredDefaultedString
+	}
+	return Default_Message_RequiredDefaultedString
+}
+
+func (m *Message) GetRequiredDefaultedBytes() []byte {
+	if m != nil && m.RequiredDefaultedBytes != nil {
+		return m.RequiredDefaultedBytes
+	}
+	return append([]byte(nil), Default_Message_RequiredDefaultedBytes...)
+}
+
+func (m *Message) GetRequiredDefaultedChildEnum() Message_ChildEnum {
+	if m != nil && m.RequiredDefaultedChildEnum != nil {
+		return *m.RequiredDefaultedChildEnum
+	}
+	return Default_Message_RequiredDefaultedChildEnum
+}
+
+func (m *Message) GetRequiredDefaultedSiblingEnum() SiblingEnum {
+	if m != nil && m.RequiredDefaultedSiblingEnum != nil {
+		return *m.RequiredDefaultedSiblingEnum
+	}
+	return Default_Message_RequiredDefaultedSiblingEnum
+}
+
+func (m *Message) GetRepeatedBool() []bool {
+	if m != nil {
+		return m.RepeatedBool
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedInt32() []int32 {
+	if m != nil {
+		return m.RepeatedInt32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSint32() []int32 {
+	if m != nil {
+		return m.RepeatedSint32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedUint32() []uint32 {
+	if m != nil {
+		return m.RepeatedUint32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedInt64() []int64 {
+	if m != nil {
+		return m.RepeatedInt64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSint64() []int64 {
+	if m != nil {
+		return m.RepeatedSint64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedUint64() []uint64 {
+	if m != nil {
+		return m.RepeatedUint64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedFixed32() []uint32 {
+	if m != nil {
+		return m.RepeatedFixed32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSfixed32() []int32 {
+	if m != nil {
+		return m.RepeatedSfixed32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedFloat() []float32 {
+	if m != nil {
+		return m.RepeatedFloat
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedFixed64() []uint64 {
+	if m != nil {
+		return m.RepeatedFixed64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSfixed64() []int64 {
+	if m != nil {
+		return m.RepeatedSfixed64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedDouble() []float64 {
+	if m != nil {
+		return m.RepeatedDouble
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedString() []string {
+	if m != nil {
+		return m.RepeatedString
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedBytes() [][]byte {
+	if m != nil {
+		return m.RepeatedBytes
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedChildEnum() []Message_ChildEnum {
+	if m != nil {
+		return m.RepeatedChildEnum
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedChildMessage() []*Message_ChildMessage {
+	if m != nil {
+		return m.RepeatedChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedNamedGroup() []*Message_NamedGroup {
+	if m != nil {
+		return m.RepeatedNamedGroup
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSiblingEnum() []SiblingEnum {
+	if m != nil {
+		return m.RepeatedSiblingEnum
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSiblingMessage() []*SiblingMessage {
+	if m != nil {
+		return m.RepeatedSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedgroup() []*Message_RepeatedGroup {
+	if m != nil {
+		return m.Repeatedgroup
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolBool() map[bool]bool {
+	if m != nil {
+		return m.MapBoolBool
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolInt32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolInt32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSint32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolSint32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolUint32() map[bool]uint32 {
+	if m != nil {
+		return m.MapBoolUint32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolInt64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolInt64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSint64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolSint64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolUint64() map[bool]uint64 {
+	if m != nil {
+		return m.MapBoolUint64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFixed32() map[bool]uint32 {
+	if m != nil {
+		return m.MapBoolFixed32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSfixed32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolSfixed32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFloat() map[bool]float32 {
+	if m != nil {
+		return m.MapBoolFloat
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFixed64() map[bool]uint64 {
+	if m != nil {
+		return m.MapBoolFixed64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSfixed64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolSfixed64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolDouble() map[bool]float64 {
+	if m != nil {
+		return m.MapBoolDouble
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolString() map[bool]string {
+	if m != nil {
+		return m.MapBoolString
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolBytes() map[bool][]byte {
+	if m != nil {
+		return m.MapBoolBytes
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolChildEnum() map[bool]Message_ChildEnum {
+	if m != nil {
+		return m.MapBoolChildEnum
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolChildMessage() map[bool]*Message_ChildMessage {
+	if m != nil {
+		return m.MapBoolChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolNamedGroup() map[bool]*Message_NamedGroup {
+	if m != nil {
+		return m.MapBoolNamedGroup
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSiblingEnum() map[bool]SiblingEnum {
+	if m != nil {
+		return m.MapBoolSiblingEnum
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSiblingMessage() map[bool]*SiblingMessage {
+	if m != nil {
+		return m.MapBoolSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetMapInt32Bool() map[int32]bool {
+	if m != nil {
+		return m.MapInt32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapSint32Bool() map[int32]bool {
+	if m != nil {
+		return m.MapSint32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapUint32Bool() map[uint32]bool {
+	if m != nil {
+		return m.MapUint32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapInt64Bool() map[int64]bool {
+	if m != nil {
+		return m.MapInt64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapSint64Bool() map[int64]bool {
+	if m != nil {
+		return m.MapSint64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapUint64Bool() map[uint64]bool {
+	if m != nil {
+		return m.MapUint64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapFixed32Bool() map[uint32]bool {
+	if m != nil {
+		return m.MapFixed32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapStringBool() map[string]bool {
+	if m != nil {
+		return m.MapStringBool
+	}
+	return nil
+}
+
+func (m *Message) GetOneofBool() bool {
+	if x, ok := m.GetOneofUnion().(*Message_OneofBool); ok {
+		return x.OneofBool
+	}
+	return false
+}
+
+func (m *Message) GetOneofInt32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofInt32); ok {
+		return x.OneofInt32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSint32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSint32); ok {
+		return x.OneofSint32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofUint32() uint32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofUint32); ok {
+		return x.OneofUint32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofInt64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofInt64); ok {
+		return x.OneofInt64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSint64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSint64); ok {
+		return x.OneofSint64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofUint64() uint64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofUint64); ok {
+		return x.OneofUint64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFixed32() uint32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFixed32); ok {
+		return x.OneofFixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSfixed32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSfixed32); ok {
+		return x.OneofSfixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFloat() float32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFloat); ok {
+		return x.OneofFloat
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFixed64() uint64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFixed64); ok {
+		return x.OneofFixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSfixed64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSfixed64); ok {
+		return x.OneofSfixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofDouble() float64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofDouble); ok {
+		return x.OneofDouble
+	}
+	return 0
+}
+
+func (m *Message) GetOneofString() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString); ok {
+		return x.OneofString
+	}
+	return ""
+}
+
+func (m *Message) GetOneofBytes() []byte {
+	if x, ok := m.GetOneofUnion().(*Message_OneofBytes); ok {
+		return x.OneofBytes
+	}
+	return nil
+}
+
+func (m *Message) GetOneofChildEnum() Message_ChildEnum {
+	if x, ok := m.GetOneofUnion().(*Message_OneofChildEnum); ok {
+		return x.OneofChildEnum
+	}
+	return Message_ALPHA
+}
+
+func (m *Message) GetOneofChildMessage() *Message_ChildMessage {
+	if x, ok := m.GetOneofUnion().(*Message_OneofChildMessage); ok {
+		return x.OneofChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOneofNamedGroup() *Message_NamedGroup {
+	if x, ok := m.GetOneofUnion().(*Message_OneofNamedGroup); ok {
+		return x.OneofNamedGroup
+	}
+	return nil
+}
+
+func (m *Message) GetOneofSiblingEnum() SiblingEnum {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSiblingEnum); ok {
+		return x.OneofSiblingEnum
+	}
+	return SiblingEnum_ALPHA
+}
+
+func (m *Message) GetOneofSiblingMessage() *SiblingMessage {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSiblingMessage); ok {
+		return x.OneofSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOneofgroup() *Message_OneofGroup {
+	if x, ok := m.GetOneofUnion().(*Message_Oneofgroup); ok {
+		return x.Oneofgroup
+	}
+	return nil
+}
+
+func (m *Message) GetOneofString1() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString1); ok {
+		return x.OneofString1
+	}
+	return ""
+}
+
+func (m *Message) GetOneofString2() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString2); ok {
+		return x.OneofString2
+	}
+	return ""
+}
+
+func (m *Message) GetOneofString3() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString3); ok {
+		return x.OneofString3
+	}
+	return ""
+}
+
+func (m *Message) GetOneofDefaultedBool() bool {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedBool); ok {
+		return x.OneofDefaultedBool
+	}
+	return Default_Message_OneofDefaultedBool
+}
+
+func (m *Message) GetOneofDefaultedInt32() int32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedInt32); ok {
+		return x.OneofDefaultedInt32
+	}
+	return Default_Message_OneofDefaultedInt32
+}
+
+func (m *Message) GetOneofDefaultedSint32() int32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedSint32); ok {
+		return x.OneofDefaultedSint32
+	}
+	return Default_Message_OneofDefaultedSint32
+}
+
+func (m *Message) GetOneofDefaultedUint32() uint32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedUint32); ok {
+		return x.OneofDefaultedUint32
+	}
+	return Default_Message_OneofDefaultedUint32
+}
+
+func (m *Message) GetOneofDefaultedInt64() int64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedInt64); ok {
+		return x.OneofDefaultedInt64
+	}
+	return Default_Message_OneofDefaultedInt64
+}
+
+func (m *Message) GetOneofDefaultedSint64() int64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedSint64); ok {
+		return x.OneofDefaultedSint64
+	}
+	return Default_Message_OneofDefaultedSint64
+}
+
+func (m *Message) GetOneofDefaultedUint64() uint64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedUint64); ok {
+		return x.OneofDefaultedUint64
+	}
+	return Default_Message_OneofDefaultedUint64
+}
+
+func (m *Message) GetOneofDefaultedFixed32() uint32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedFixed32); ok {
+		return x.OneofDefaultedFixed32
+	}
+	return Default_Message_OneofDefaultedFixed32
+}
+
+func (m *Message) GetOneofDefaultedSfixed32() int32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedSfixed32); ok {
+		return x.OneofDefaultedSfixed32
+	}
+	return Default_Message_OneofDefaultedSfixed32
+}
+
+func (m *Message) GetOneofDefaultedFloat() float32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedFloat); ok {
+		return x.OneofDefaultedFloat
+	}
+	return Default_Message_OneofDefaultedFloat
+}
+
+func (m *Message) GetOneofDefaultedFixed64() uint64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedFixed64); ok {
+		return x.OneofDefaultedFixed64
+	}
+	return Default_Message_OneofDefaultedFixed64
+}
+
+func (m *Message) GetOneofDefaultedSfixed64() int64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedSfixed64); ok {
+		return x.OneofDefaultedSfixed64
+	}
+	return Default_Message_OneofDefaultedSfixed64
+}
+
+func (m *Message) GetOneofDefaultedDouble() float64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedDouble); ok {
+		return x.OneofDefaultedDouble
+	}
+	return Default_Message_OneofDefaultedDouble
+}
+
+func (m *Message) GetOneofDefaultedString() string {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedString); ok {
+		return x.OneofDefaultedString
+	}
+	return Default_Message_OneofDefaultedString
+}
+
+func (m *Message) GetOneofDefaultedBytes() []byte {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedBytes); ok {
+		return x.OneofDefaultedBytes
+	}
+	return append([]byte(nil), Default_Message_OneofDefaultedBytes...)
+}
+
+func (m *Message) GetOneofDefaultedChildEnum() Message_ChildEnum {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedChildEnum); ok {
+		return x.OneofDefaultedChildEnum
+	}
+	return Default_Message_OneofDefaultedChildEnum
+}
+
+func (m *Message) GetOneofDefaultedSiblingEnum() SiblingEnum {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedSiblingEnum); ok {
+		return x.OneofDefaultedSiblingEnum
+	}
+	return Default_Message_OneofDefaultedSiblingEnum
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*Message) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+	return _Message_OneofMarshaler, _Message_OneofUnmarshaler, _Message_OneofSizer, []interface{}{
+		(*Message_OneofBool)(nil),
+		(*Message_OneofInt32)(nil),
+		(*Message_OneofSint32)(nil),
+		(*Message_OneofUint32)(nil),
+		(*Message_OneofInt64)(nil),
+		(*Message_OneofSint64)(nil),
+		(*Message_OneofUint64)(nil),
+		(*Message_OneofFixed32)(nil),
+		(*Message_OneofSfixed32)(nil),
+		(*Message_OneofFloat)(nil),
+		(*Message_OneofFixed64)(nil),
+		(*Message_OneofSfixed64)(nil),
+		(*Message_OneofDouble)(nil),
+		(*Message_OneofString)(nil),
+		(*Message_OneofBytes)(nil),
+		(*Message_OneofChildEnum)(nil),
+		(*Message_OneofChildMessage)(nil),
+		(*Message_OneofNamedGroup)(nil),
+		(*Message_OneofSiblingEnum)(nil),
+		(*Message_OneofSiblingMessage)(nil),
+		(*Message_Oneofgroup)(nil),
+		(*Message_OneofString1)(nil),
+		(*Message_OneofString2)(nil),
+		(*Message_OneofString3)(nil),
+		(*Message_OneofDefaultedBool)(nil),
+		(*Message_OneofDefaultedInt32)(nil),
+		(*Message_OneofDefaultedSint32)(nil),
+		(*Message_OneofDefaultedUint32)(nil),
+		(*Message_OneofDefaultedInt64)(nil),
+		(*Message_OneofDefaultedSint64)(nil),
+		(*Message_OneofDefaultedUint64)(nil),
+		(*Message_OneofDefaultedFixed32)(nil),
+		(*Message_OneofDefaultedSfixed32)(nil),
+		(*Message_OneofDefaultedFloat)(nil),
+		(*Message_OneofDefaultedFixed64)(nil),
+		(*Message_OneofDefaultedSfixed64)(nil),
+		(*Message_OneofDefaultedDouble)(nil),
+		(*Message_OneofDefaultedString)(nil),
+		(*Message_OneofDefaultedBytes)(nil),
+		(*Message_OneofDefaultedChildEnum)(nil),
+		(*Message_OneofDefaultedSiblingEnum)(nil),
+	}
+}
+
+func _Message_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*Message)
+	// oneof_union
+	switch x := m.OneofUnion.(type) {
+	case *Message_OneofBool:
+		t := uint64(0)
+		if x.OneofBool {
+			t = 1
+		}
+		b.EncodeVarint(700<<3 | proto.WireVarint)
+		b.EncodeVarint(t)
+	case *Message_OneofInt32:
+		b.EncodeVarint(701<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofInt32))
+	case *Message_OneofSint32:
+		b.EncodeVarint(702<<3 | proto.WireVarint)
+		b.EncodeZigzag32(uint64(x.OneofSint32))
+	case *Message_OneofUint32:
+		b.EncodeVarint(703<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofUint32))
+	case *Message_OneofInt64:
+		b.EncodeVarint(704<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofInt64))
+	case *Message_OneofSint64:
+		b.EncodeVarint(705<<3 | proto.WireVarint)
+		b.EncodeZigzag64(uint64(x.OneofSint64))
+	case *Message_OneofUint64:
+		b.EncodeVarint(706<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofUint64))
+	case *Message_OneofFixed32:
+		b.EncodeVarint(707<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(x.OneofFixed32))
+	case *Message_OneofSfixed32:
+		b.EncodeVarint(708<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(x.OneofSfixed32))
+	case *Message_OneofFloat:
+		b.EncodeVarint(709<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(math.Float32bits(x.OneofFloat)))
+	case *Message_OneofFixed64:
+		b.EncodeVarint(710<<3 | proto.WireFixed64)
+		b.EncodeFixed64(uint64(x.OneofFixed64))
+	case *Message_OneofSfixed64:
+		b.EncodeVarint(711<<3 | proto.WireFixed64)
+		b.EncodeFixed64(uint64(x.OneofSfixed64))
+	case *Message_OneofDouble:
+		b.EncodeVarint(712<<3 | proto.WireFixed64)
+		b.EncodeFixed64(math.Float64bits(x.OneofDouble))
+	case *Message_OneofString:
+		b.EncodeVarint(713<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString)
+	case *Message_OneofBytes:
+		b.EncodeVarint(714<<3 | proto.WireBytes)
+		b.EncodeRawBytes(x.OneofBytes)
+	case *Message_OneofChildEnum:
+		b.EncodeVarint(715<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofChildEnum))
+	case *Message_OneofChildMessage:
+		b.EncodeVarint(716<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.OneofChildMessage); err != nil {
+			return err
+		}
+	case *Message_OneofNamedGroup:
+		b.EncodeVarint(717<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.OneofNamedGroup); err != nil {
+			return err
+		}
+	case *Message_OneofSiblingEnum:
+		b.EncodeVarint(718<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofSiblingEnum))
+	case *Message_OneofSiblingMessage:
+		b.EncodeVarint(719<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.OneofSiblingMessage); err != nil {
+			return err
+		}
+	case *Message_Oneofgroup:
+		b.EncodeVarint(720<<3 | proto.WireStartGroup)
+		if err := b.Marshal(x.Oneofgroup); err != nil {
+			return err
+		}
+		b.EncodeVarint(720<<3 | proto.WireEndGroup)
+	case *Message_OneofString1:
+		b.EncodeVarint(721<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString1)
+	case *Message_OneofString2:
+		b.EncodeVarint(722<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString2)
+	case *Message_OneofString3:
+		b.EncodeVarint(723<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString3)
+	case nil:
+	default:
+		return fmt.Errorf("Message.OneofUnion has unexpected type %T", x)
+	}
+	// oneof_defaulted_union
+	switch x := m.OneofDefaultedUnion.(type) {
+	case *Message_OneofDefaultedBool:
+		t := uint64(0)
+		if x.OneofDefaultedBool {
+			t = 1
+		}
+		b.EncodeVarint(800<<3 | proto.WireVarint)
+		b.EncodeVarint(t)
+	case *Message_OneofDefaultedInt32:
+		b.EncodeVarint(801<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofDefaultedInt32))
+	case *Message_OneofDefaultedSint32:
+		b.EncodeVarint(802<<3 | proto.WireVarint)
+		b.EncodeZigzag32(uint64(x.OneofDefaultedSint32))
+	case *Message_OneofDefaultedUint32:
+		b.EncodeVarint(803<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofDefaultedUint32))
+	case *Message_OneofDefaultedInt64:
+		b.EncodeVarint(804<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofDefaultedInt64))
+	case *Message_OneofDefaultedSint64:
+		b.EncodeVarint(805<<3 | proto.WireVarint)
+		b.EncodeZigzag64(uint64(x.OneofDefaultedSint64))
+	case *Message_OneofDefaultedUint64:
+		b.EncodeVarint(806<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofDefaultedUint64))
+	case *Message_OneofDefaultedFixed32:
+		b.EncodeVarint(807<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(x.OneofDefaultedFixed32))
+	case *Message_OneofDefaultedSfixed32:
+		b.EncodeVarint(808<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(x.OneofDefaultedSfixed32))
+	case *Message_OneofDefaultedFloat:
+		b.EncodeVarint(809<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(math.Float32bits(x.OneofDefaultedFloat)))
+	case *Message_OneofDefaultedFixed64:
+		b.EncodeVarint(810<<3 | proto.WireFixed64)
+		b.EncodeFixed64(uint64(x.OneofDefaultedFixed64))
+	case *Message_OneofDefaultedSfixed64:
+		b.EncodeVarint(811<<3 | proto.WireFixed64)
+		b.EncodeFixed64(uint64(x.OneofDefaultedSfixed64))
+	case *Message_OneofDefaultedDouble:
+		b.EncodeVarint(812<<3 | proto.WireFixed64)
+		b.EncodeFixed64(math.Float64bits(x.OneofDefaultedDouble))
+	case *Message_OneofDefaultedString:
+		b.EncodeVarint(813<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofDefaultedString)
+	case *Message_OneofDefaultedBytes:
+		b.EncodeVarint(814<<3 | proto.WireBytes)
+		b.EncodeRawBytes(x.OneofDefaultedBytes)
+	case *Message_OneofDefaultedChildEnum:
+		b.EncodeVarint(815<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofDefaultedChildEnum))
+	case *Message_OneofDefaultedSiblingEnum:
+		b.EncodeVarint(816<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofDefaultedSiblingEnum))
+	case nil:
+	default:
+		return fmt.Errorf("Message.OneofDefaultedUnion has unexpected type %T", x)
+	}
+	return nil
+}
+
+func _Message_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*Message)
+	switch tag {
+	case 700: // oneof_union.oneof_bool
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofBool{x != 0}
+		return true, err
+	case 701: // oneof_union.oneof_int32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofInt32{int32(x)}
+		return true, err
+	case 702: // oneof_union.oneof_sint32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeZigzag32()
+		m.OneofUnion = &Message_OneofSint32{int32(x)}
+		return true, err
+	case 703: // oneof_union.oneof_uint32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofUint32{uint32(x)}
+		return true, err
+	case 704: // oneof_union.oneof_int64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofInt64{int64(x)}
+		return true, err
+	case 705: // oneof_union.oneof_sint64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeZigzag64()
+		m.OneofUnion = &Message_OneofSint64{int64(x)}
+		return true, err
+	case 706: // oneof_union.oneof_uint64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofUint64{x}
+		return true, err
+	case 707: // oneof_union.oneof_fixed32
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofUnion = &Message_OneofFixed32{uint32(x)}
+		return true, err
+	case 708: // oneof_union.oneof_sfixed32
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofUnion = &Message_OneofSfixed32{int32(x)}
+		return true, err
+	case 709: // oneof_union.oneof_float
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofUnion = &Message_OneofFloat{math.Float32frombits(uint32(x))}
+		return true, err
+	case 710: // oneof_union.oneof_fixed64
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofUnion = &Message_OneofFixed64{x}
+		return true, err
+	case 711: // oneof_union.oneof_sfixed64
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofUnion = &Message_OneofSfixed64{int64(x)}
+		return true, err
+	case 712: // oneof_union.oneof_double
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofUnion = &Message_OneofDouble{math.Float64frombits(x)}
+		return true, err
+	case 713: // oneof_union.oneof_string
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString{x}
+		return true, err
+	case 714: // oneof_union.oneof_bytes
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeRawBytes(true)
+		m.OneofUnion = &Message_OneofBytes{x}
+		return true, err
+	case 715: // oneof_union.oneof_child_enum
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofChildEnum{Message_ChildEnum(x)}
+		return true, err
+	case 716: // oneof_union.oneof_child_message
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(Message_ChildMessage)
+		err := b.DecodeMessage(msg)
+		m.OneofUnion = &Message_OneofChildMessage{msg}
+		return true, err
+	case 717: // oneof_union.oneof_named_group
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(Message_NamedGroup)
+		err := b.DecodeMessage(msg)
+		m.OneofUnion = &Message_OneofNamedGroup{msg}
+		return true, err
+	case 718: // oneof_union.oneof_sibling_enum
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofSiblingEnum{SiblingEnum(x)}
+		return true, err
+	case 719: // oneof_union.oneof_sibling_message
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(SiblingMessage)
+		err := b.DecodeMessage(msg)
+		m.OneofUnion = &Message_OneofSiblingMessage{msg}
+		return true, err
+	case 720: // oneof_union.oneofgroup
+		if wire != proto.WireStartGroup {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(Message_OneofGroup)
+		err := b.DecodeGroup(msg)
+		m.OneofUnion = &Message_Oneofgroup{msg}
+		return true, err
+	case 721: // oneof_union.oneof_string1
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString1{x}
+		return true, err
+	case 722: // oneof_union.oneof_string2
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString2{x}
+		return true, err
+	case 723: // oneof_union.oneof_string3
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString3{x}
+		return true, err
+	case 800: // oneof_defaulted_union.oneof_defaulted_bool
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedBool{x != 0}
+		return true, err
+	case 801: // oneof_defaulted_union.oneof_defaulted_int32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedInt32{int32(x)}
+		return true, err
+	case 802: // oneof_defaulted_union.oneof_defaulted_sint32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeZigzag32()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedSint32{int32(x)}
+		return true, err
+	case 803: // oneof_defaulted_union.oneof_defaulted_uint32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedUint32{uint32(x)}
+		return true, err
+	case 804: // oneof_defaulted_union.oneof_defaulted_int64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedInt64{int64(x)}
+		return true, err
+	case 805: // oneof_defaulted_union.oneof_defaulted_sint64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeZigzag64()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedSint64{int64(x)}
+		return true, err
+	case 806: // oneof_defaulted_union.oneof_defaulted_uint64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedUint64{x}
+		return true, err
+	case 807: // oneof_defaulted_union.oneof_defaulted_fixed32
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedFixed32{uint32(x)}
+		return true, err
+	case 808: // oneof_defaulted_union.oneof_defaulted_sfixed32
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedSfixed32{int32(x)}
+		return true, err
+	case 809: // oneof_defaulted_union.oneof_defaulted_float
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedFloat{math.Float32frombits(uint32(x))}
+		return true, err
+	case 810: // oneof_defaulted_union.oneof_defaulted_fixed64
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedFixed64{x}
+		return true, err
+	case 811: // oneof_defaulted_union.oneof_defaulted_sfixed64
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedSfixed64{int64(x)}
+		return true, err
+	case 812: // oneof_defaulted_union.oneof_defaulted_double
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedDouble{math.Float64frombits(x)}
+		return true, err
+	case 813: // oneof_defaulted_union.oneof_defaulted_string
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedString{x}
+		return true, err
+	case 814: // oneof_defaulted_union.oneof_defaulted_bytes
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeRawBytes(true)
+		m.OneofDefaultedUnion = &Message_OneofDefaultedBytes{x}
+		return true, err
+	case 815: // oneof_defaulted_union.oneof_defaulted_child_enum
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedChildEnum{Message_ChildEnum(x)}
+		return true, err
+	case 816: // oneof_defaulted_union.oneof_defaulted_sibling_enum
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedSiblingEnum{SiblingEnum(x)}
+		return true, err
+	default:
+		return false, nil
+	}
+}
+
+func _Message_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*Message)
+	// oneof_union
+	switch x := m.OneofUnion.(type) {
+	case *Message_OneofBool:
+		n += proto.SizeVarint(700<<3 | proto.WireVarint)
+		n += 1
+	case *Message_OneofInt32:
+		n += proto.SizeVarint(701<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofInt32))
+	case *Message_OneofSint32:
+		n += proto.SizeVarint(702<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64((uint32(x.OneofSint32) << 1) ^ uint32((int32(x.OneofSint32) >> 31))))
+	case *Message_OneofUint32:
+		n += proto.SizeVarint(703<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofUint32))
+	case *Message_OneofInt64:
+		n += proto.SizeVarint(704<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofInt64))
+	case *Message_OneofSint64:
+		n += proto.SizeVarint(705<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(uint64(x.OneofSint64<<1) ^ uint64((int64(x.OneofSint64) >> 63))))
+	case *Message_OneofUint64:
+		n += proto.SizeVarint(706<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofUint64))
+	case *Message_OneofFixed32:
+		n += proto.SizeVarint(707<<3 | proto.WireFixed32)
+		n += 4
+	case *Message_OneofSfixed32:
+		n += proto.SizeVarint(708<<3 | proto.WireFixed32)
+		n += 4
+	case *Message_OneofFloat:
+		n += proto.SizeVarint(709<<3 | proto.WireFixed32)
+		n += 4
+	case *Message_OneofFixed64:
+		n += proto.SizeVarint(710<<3 | proto.WireFixed64)
+		n += 8
+	case *Message_OneofSfixed64:
+		n += proto.SizeVarint(711<<3 | proto.WireFixed64)
+		n += 8
+	case *Message_OneofDouble:
+		n += proto.SizeVarint(712<<3 | proto.WireFixed64)
+		n += 8
+	case *Message_OneofString:
+		n += proto.SizeVarint(713<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofString)))
+		n += len(x.OneofString)
+	case *Message_OneofBytes:
+		n += proto.SizeVarint(714<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofBytes)))
+		n += len(x.OneofBytes)
+	case *Message_OneofChildEnum:
+		n += proto.SizeVarint(715<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofChildEnum))
+	case *Message_OneofChildMessage:
+		s := proto.Size(x.OneofChildMessage)
+		n += proto.SizeVarint(716<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *Message_OneofNamedGroup:
+		s := proto.Size(x.OneofNamedGroup)
+		n += proto.SizeVarint(717<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *Message_OneofSiblingEnum:
+		n += proto.SizeVarint(718<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofSiblingEnum))
+	case *Message_OneofSiblingMessage:
+		s := proto.Size(x.OneofSiblingMessage)
+		n += proto.SizeVarint(719<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *Message_Oneofgroup:
+		n += proto.SizeVarint(720<<3 | proto.WireStartGroup)
+		n += proto.Size(x.Oneofgroup)
+		n += proto.SizeVarint(720<<3 | proto.WireEndGroup)
+	case *Message_OneofString1:
+		n += proto.SizeVarint(721<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofString1)))
+		n += len(x.OneofString1)
+	case *Message_OneofString2:
+		n += proto.SizeVarint(722<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofString2)))
+		n += len(x.OneofString2)
+	case *Message_OneofString3:
+		n += proto.SizeVarint(723<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofString3)))
+		n += len(x.OneofString3)
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	// oneof_defaulted_union
+	switch x := m.OneofDefaultedUnion.(type) {
+	case *Message_OneofDefaultedBool:
+		n += proto.SizeVarint(800<<3 | proto.WireVarint)
+		n += 1
+	case *Message_OneofDefaultedInt32:
+		n += proto.SizeVarint(801<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofDefaultedInt32))
+	case *Message_OneofDefaultedSint32:
+		n += proto.SizeVarint(802<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64((uint32(x.OneofDefaultedSint32) << 1) ^ uint32((int32(x.OneofDefaultedSint32) >> 31))))
+	case *Message_OneofDefaultedUint32:
+		n += proto.SizeVarint(803<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofDefaultedUint32))
+	case *Message_OneofDefaultedInt64:
+		n += proto.SizeVarint(804<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofDefaultedInt64))
+	case *Message_OneofDefaultedSint64:
+		n += proto.SizeVarint(805<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(uint64(x.OneofDefaultedSint64<<1) ^ uint64((int64(x.OneofDefaultedSint64) >> 63))))
+	case *Message_OneofDefaultedUint64:
+		n += proto.SizeVarint(806<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofDefaultedUint64))
+	case *Message_OneofDefaultedFixed32:
+		n += proto.SizeVarint(807<<3 | proto.WireFixed32)
+		n += 4
+	case *Message_OneofDefaultedSfixed32:
+		n += proto.SizeVarint(808<<3 | proto.WireFixed32)
+		n += 4
+	case *Message_OneofDefaultedFloat:
+		n += proto.SizeVarint(809<<3 | proto.WireFixed32)
+		n += 4
+	case *Message_OneofDefaultedFixed64:
+		n += proto.SizeVarint(810<<3 | proto.WireFixed64)
+		n += 8
+	case *Message_OneofDefaultedSfixed64:
+		n += proto.SizeVarint(811<<3 | proto.WireFixed64)
+		n += 8
+	case *Message_OneofDefaultedDouble:
+		n += proto.SizeVarint(812<<3 | proto.WireFixed64)
+		n += 8
+	case *Message_OneofDefaultedString:
+		n += proto.SizeVarint(813<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofDefaultedString)))
+		n += len(x.OneofDefaultedString)
+	case *Message_OneofDefaultedBytes:
+		n += proto.SizeVarint(814<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofDefaultedBytes)))
+		n += len(x.OneofDefaultedBytes)
+	case *Message_OneofDefaultedChildEnum:
+		n += proto.SizeVarint(815<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofDefaultedChildEnum))
+	case *Message_OneofDefaultedSiblingEnum:
+		n += proto.SizeVarint(816<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofDefaultedSiblingEnum))
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	return n
+}
+
+var E_Message_ExtensionOptionalBool = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*bool)(nil),
+	Field:         10000,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_optional_bool",
+	Tag:           "varint,10000,opt,name=extension_optional_bool,json=extensionOptionalBool",
+}
+
+var E_Message_ExtensionOptionalInt32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         10001,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_optional_int32",
+	Tag:           "varint,10001,opt,name=extension_optional_int32,json=extensionOptionalInt32",
+}
+
+var E_Message_ExtensionOptionalSint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         10002,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_optional_sint32",
+	Tag:           "zigzag32,10002,opt,name=extension_optional_sint32,json=extensionOptionalSint32",
+}
+
+var E_Message_ExtensionOptionalUint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint32)(nil),
+	Field:         10003,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_optional_uint32",
+	Tag:           "varint,10003,opt,name=extension_optional_uint32,json=extensionOptionalUint32",
+}
+
+var E_Message_ExtensionOptionalInt64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         10004,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_optional_int64",
+	Tag:           "varint,10004,opt,name=extension_optional_int64,json=extensionOptionalInt64",
+}
+
+var E_Message_ExtensionOptionalSint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         10005,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_optional_sint64",
+	Tag:           "zigzag64,10005,opt,name=extension_optional_sint64,json=extensionOptionalSint64",
+}
+
+var E_Message_ExtensionOptionalUint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint64)(nil),
+	Field:         10006,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_optional_uint64",
+	Tag:           "varint,10006,opt,name=extension_optional_uint64,json=extensionOptionalUint64",
+}
+
+var E_Message_ExtensionOptionalFixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint32)(nil),
+	Field:         10007,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_optional_fixed32",
+	Tag:           "fixed32,10007,opt,name=extension_optional_fixed32,json=extensionOptionalFixed32",
+}
+
+var E_Message_ExtensionOptionalSfixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         10008,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_optional_sfixed32",
+	Tag:           "fixed32,10008,opt,name=extension_optional_sfixed32,json=extensionOptionalSfixed32",
+}
+
+var E_Message_ExtensionOptionalFloat = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*float32)(nil),
+	Field:         10009,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_optional_float",
+	Tag:           "fixed32,10009,opt,name=extension_optional_float,json=extensionOptionalFloat",
+}
+
+var E_Message_ExtensionOptionalFixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint64)(nil),
+	Field:         10010,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_optional_fixed64",
+	Tag:           "fixed64,10010,opt,name=extension_optional_fixed64,json=extensionOptionalFixed64",
+}
+
+var E_Message_ExtensionOptionalSfixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         10011,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_optional_sfixed64",
+	Tag:           "fixed64,10011,opt,name=extension_optional_sfixed64,json=extensionOptionalSfixed64",
+}
+
+var E_Message_ExtensionOptionalDouble = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*float64)(nil),
+	Field:         10012,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_optional_double",
+	Tag:           "fixed64,10012,opt,name=extension_optional_double,json=extensionOptionalDouble",
+}
+
+var E_Message_ExtensionOptionalString = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*string)(nil),
+	Field:         10013,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_optional_string",
+	Tag:           "bytes,10013,opt,name=extension_optional_string,json=extensionOptionalString",
+}
+
+var E_Message_ExtensionOptionalBytes = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]byte)(nil),
+	Field:         10014,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_optional_bytes",
+	Tag:           "bytes,10014,opt,name=extension_optional_bytes,json=extensionOptionalBytes",
+}
+
+var E_Message_ExtensionOptionalChildEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*Message_ChildEnum)(nil),
+	Field:         10015,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_optional_child_enum",
+	Tag:           "varint,10015,opt,name=extension_optional_child_enum,json=extensionOptionalChildEnum,enum=google.golang.org.proto2_20160519.Message_ChildEnum",
+}
+
+var E_Message_ExtensionOptionalChildMessage = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*Message_ChildMessage)(nil),
+	Field:         10016,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_optional_child_message",
+	Tag:           "bytes,10016,opt,name=extension_optional_child_message,json=extensionOptionalChildMessage",
+}
+
+var E_Message_ExtensionOptionalNamedGroup = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*Message_NamedGroup)(nil),
+	Field:         10017,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_optional_named_group",
+	Tag:           "bytes,10017,opt,name=extension_optional_named_group,json=extensionOptionalNamedGroup",
+}
+
+var E_Message_ExtensionOptionalSiblingEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*SiblingEnum)(nil),
+	Field:         10018,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_optional_sibling_enum",
+	Tag:           "varint,10018,opt,name=extension_optional_sibling_enum,json=extensionOptionalSiblingEnum,enum=google.golang.org.proto2_20160519.SiblingEnum",
+}
+
+var E_Message_ExtensionOptionalSiblingMessage = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*SiblingMessage)(nil),
+	Field:         10019,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_optional_sibling_message",
+	Tag:           "bytes,10019,opt,name=extension_optional_sibling_message,json=extensionOptionalSiblingMessage",
+}
+
+var E_Message_Extensionoptionalgroup = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*Message_ExtensionOptionalGroup)(nil),
+	Field:         10020,
+	Name:          "google.golang.org.proto2_20160519.Message.extensionoptionalgroup",
+	Tag:           "group,10020,opt,name=ExtensionOptionalGroup,json=extensionoptionalgroup",
+}
+
+var E_Message_ExtensionDefaultedBool = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*bool)(nil),
+	Field:         20000,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_defaulted_bool",
+	Tag:           "varint,20000,opt,name=extension_defaulted_bool,json=extensionDefaultedBool,def=1",
+}
+
+var E_Message_ExtensionDefaultedInt32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         20001,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_defaulted_int32",
+	Tag:           "varint,20001,opt,name=extension_defaulted_int32,json=extensionDefaultedInt32,def=-12345",
+}
+
+var E_Message_ExtensionDefaultedSint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         20002,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_defaulted_sint32",
+	Tag:           "zigzag32,20002,opt,name=extension_defaulted_sint32,json=extensionDefaultedSint32,def=-3200",
+}
+
+var E_Message_ExtensionDefaultedUint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint32)(nil),
+	Field:         20003,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_defaulted_uint32",
+	Tag:           "varint,20003,opt,name=extension_defaulted_uint32,json=extensionDefaultedUint32,def=3200",
+}
+
+var E_Message_ExtensionDefaultedInt64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         20004,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_defaulted_int64",
+	Tag:           "varint,20004,opt,name=extension_defaulted_int64,json=extensionDefaultedInt64,def=-123456789",
+}
+
+var E_Message_ExtensionDefaultedSint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         20005,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_defaulted_sint64",
+	Tag:           "zigzag64,20005,opt,name=extension_defaulted_sint64,json=extensionDefaultedSint64,def=-6400",
+}
+
+var E_Message_ExtensionDefaultedUint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint64)(nil),
+	Field:         20006,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_defaulted_uint64",
+	Tag:           "varint,20006,opt,name=extension_defaulted_uint64,json=extensionDefaultedUint64,def=6400",
+}
+
+var E_Message_ExtensionDefaultedFixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint32)(nil),
+	Field:         20007,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_defaulted_fixed32",
+	Tag:           "fixed32,20007,opt,name=extension_defaulted_fixed32,json=extensionDefaultedFixed32,def=320000",
+}
+
+var E_Message_ExtensionDefaultedSfixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         20008,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_defaulted_sfixed32",
+	Tag:           "fixed32,20008,opt,name=extension_defaulted_sfixed32,json=extensionDefaultedSfixed32,def=-320000",
+}
+
+var E_Message_ExtensionDefaultedFloat = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*float32)(nil),
+	Field:         20009,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_defaulted_float",
+	Tag:           "fixed32,20009,opt,name=extension_defaulted_float,json=extensionDefaultedFloat,def=3.14159",
+}
+
+var E_Message_ExtensionDefaultedFixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint64)(nil),
+	Field:         20010,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_defaulted_fixed64",
+	Tag:           "fixed64,20010,opt,name=extension_defaulted_fixed64,json=extensionDefaultedFixed64,def=640000",
+}
+
+var E_Message_ExtensionDefaultedSfixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         20011,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_defaulted_sfixed64",
+	Tag:           "fixed64,20011,opt,name=extension_defaulted_sfixed64,json=extensionDefaultedSfixed64,def=-640000",
+}
+
+var E_Message_ExtensionDefaultedDouble = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*float64)(nil),
+	Field:         20012,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_defaulted_double",
+	Tag:           "fixed64,20012,opt,name=extension_defaulted_double,json=extensionDefaultedDouble,def=3.14159265359",
+}
+
+var E_Message_ExtensionDefaultedString = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*string)(nil),
+	Field:         20013,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_defaulted_string",
+	Tag:           "bytes,20013,opt,name=extension_defaulted_string,json=extensionDefaultedString,def=hello, \"world!\"\n",
+}
+
+var E_Message_ExtensionDefaultedBytes = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]byte)(nil),
+	Field:         20014,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_defaulted_bytes",
+	Tag:           "bytes,20014,opt,name=extension_defaulted_bytes,json=extensionDefaultedBytes,def=dead\\336\\255\\276\\357beef",
+}
+
+var E_Message_ExtensionDefaultedChildEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*Message_ChildEnum)(nil),
+	Field:         20015,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_defaulted_child_enum",
+	Tag:           "varint,20015,opt,name=extension_defaulted_child_enum,json=extensionDefaultedChildEnum,enum=google.golang.org.proto2_20160519.Message_ChildEnum,def=0",
+}
+
+var E_Message_ExtensionDefaultedSiblingEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*SiblingEnum)(nil),
+	Field:         20016,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_defaulted_sibling_enum",
+	Tag:           "varint,20016,opt,name=extension_defaulted_sibling_enum,json=extensionDefaultedSiblingEnum,enum=google.golang.org.proto2_20160519.SiblingEnum,def=0",
+}
+
+var E_Message_ExtensionRepeatedBool = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]bool)(nil),
+	Field:         30000,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_repeated_bool",
+	Tag:           "varint,30000,rep,name=extension_repeated_bool,json=extensionRepeatedBool",
+}
+
+var E_Message_ExtensionRepeatedInt32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int32)(nil),
+	Field:         30001,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_repeated_int32",
+	Tag:           "varint,30001,rep,name=extension_repeated_int32,json=extensionRepeatedInt32",
+}
+
+var E_Message_ExtensionRepeatedSint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int32)(nil),
+	Field:         30002,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_repeated_sint32",
+	Tag:           "zigzag32,30002,rep,name=extension_repeated_sint32,json=extensionRepeatedSint32",
+}
+
+var E_Message_ExtensionRepeatedUint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]uint32)(nil),
+	Field:         30003,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_repeated_uint32",
+	Tag:           "varint,30003,rep,name=extension_repeated_uint32,json=extensionRepeatedUint32",
+}
+
+var E_Message_ExtensionRepeatedInt64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int64)(nil),
+	Field:         30004,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_repeated_int64",
+	Tag:           "varint,30004,rep,name=extension_repeated_int64,json=extensionRepeatedInt64",
+}
+
+var E_Message_ExtensionRepeatedSint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int64)(nil),
+	Field:         30005,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_repeated_sint64",
+	Tag:           "zigzag64,30005,rep,name=extension_repeated_sint64,json=extensionRepeatedSint64",
+}
+
+var E_Message_ExtensionRepeatedUint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]uint64)(nil),
+	Field:         30006,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_repeated_uint64",
+	Tag:           "varint,30006,rep,name=extension_repeated_uint64,json=extensionRepeatedUint64",
+}
+
+var E_Message_ExtensionRepeatedFixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]uint32)(nil),
+	Field:         30007,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_repeated_fixed32",
+	Tag:           "fixed32,30007,rep,name=extension_repeated_fixed32,json=extensionRepeatedFixed32",
+}
+
+var E_Message_ExtensionRepeatedSfixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int32)(nil),
+	Field:         30008,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_repeated_sfixed32",
+	Tag:           "fixed32,30008,rep,name=extension_repeated_sfixed32,json=extensionRepeatedSfixed32",
+}
+
+var E_Message_ExtensionRepeatedFloat = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]float32)(nil),
+	Field:         30009,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_repeated_float",
+	Tag:           "fixed32,30009,rep,name=extension_repeated_float,json=extensionRepeatedFloat",
+}
+
+var E_Message_ExtensionRepeatedFixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]uint64)(nil),
+	Field:         30010,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_repeated_fixed64",
+	Tag:           "fixed64,30010,rep,name=extension_repeated_fixed64,json=extensionRepeatedFixed64",
+}
+
+var E_Message_ExtensionRepeatedSfixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int64)(nil),
+	Field:         30011,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_repeated_sfixed64",
+	Tag:           "fixed64,30011,rep,name=extension_repeated_sfixed64,json=extensionRepeatedSfixed64",
+}
+
+var E_Message_ExtensionRepeatedDouble = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]float64)(nil),
+	Field:         30012,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_repeated_double",
+	Tag:           "fixed64,30012,rep,name=extension_repeated_double,json=extensionRepeatedDouble",
+}
+
+var E_Message_ExtensionRepeatedString = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]string)(nil),
+	Field:         30013,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_repeated_string",
+	Tag:           "bytes,30013,rep,name=extension_repeated_string,json=extensionRepeatedString",
+}
+
+var E_Message_ExtensionRepeatedBytes = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([][]byte)(nil),
+	Field:         30014,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_repeated_bytes",
+	Tag:           "bytes,30014,rep,name=extension_repeated_bytes,json=extensionRepeatedBytes",
+}
+
+var E_Message_ExtensionRepeatedChildEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]Message_ChildEnum)(nil),
+	Field:         30015,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_repeated_child_enum",
+	Tag:           "varint,30015,rep,name=extension_repeated_child_enum,json=extensionRepeatedChildEnum,enum=google.golang.org.proto2_20160519.Message_ChildEnum",
+}
+
+var E_Message_ExtensionRepeatedChildMessage = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]*Message_ChildMessage)(nil),
+	Field:         30016,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_repeated_child_message",
+	Tag:           "bytes,30016,rep,name=extension_repeated_child_message,json=extensionRepeatedChildMessage",
+}
+
+var E_Message_ExtensionRepeatedNamedGroup = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]*Message_NamedGroup)(nil),
+	Field:         30017,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_repeated_named_group",
+	Tag:           "bytes,30017,rep,name=extension_repeated_named_group,json=extensionRepeatedNamedGroup",
+}
+
+var E_Message_ExtensionRepeatedSiblingEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]SiblingEnum)(nil),
+	Field:         30018,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_repeated_sibling_enum",
+	Tag:           "varint,30018,rep,name=extension_repeated_sibling_enum,json=extensionRepeatedSiblingEnum,enum=google.golang.org.proto2_20160519.SiblingEnum",
+}
+
+var E_Message_ExtensionRepeatedSiblingMessage = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]*SiblingMessage)(nil),
+	Field:         30019,
+	Name:          "google.golang.org.proto2_20160519.Message.extension_repeated_sibling_message",
+	Tag:           "bytes,30019,rep,name=extension_repeated_sibling_message,json=extensionRepeatedSiblingMessage",
+}
+
+var E_Message_Extensionrepeatedgroup = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]*Message_ExtensionRepeatedGroup)(nil),
+	Field:         30020,
+	Name:          "google.golang.org.proto2_20160519.Message.extensionrepeatedgroup",
+	Tag:           "group,30020,rep,name=ExtensionRepeatedGroup,json=extensionrepeatedgroup",
+}
+
+type Message_ChildMessage 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"`
+	F4               *Message `protobuf:"bytes,4,opt,name=f4" json:"f4,omitempty"`
+	XXX_unrecognized []byte   `json:"-"`
+}
+
+func (m *Message_ChildMessage) Reset()                    { *m = Message_ChildMessage{} }
+func (m *Message_ChildMessage) String() string            { return proto.CompactTextString(m) }
+func (*Message_ChildMessage) ProtoMessage()               {}
+func (*Message_ChildMessage) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1, 0} }
+
+func (m *Message_ChildMessage) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_ChildMessage) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_ChildMessage) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+func (m *Message_ChildMessage) GetF4() *Message {
+	if m != nil {
+		return m.F4
+	}
+	return nil
+}
+
+type Message_NamedGroup 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"`
+	F4               *Message `protobuf:"bytes,4,opt,name=f4" json:"f4,omitempty"`
+	XXX_unrecognized []byte   `json:"-"`
+}
+
+func (m *Message_NamedGroup) Reset()                    { *m = Message_NamedGroup{} }
+func (m *Message_NamedGroup) String() string            { return proto.CompactTextString(m) }
+func (*Message_NamedGroup) ProtoMessage()               {}
+func (*Message_NamedGroup) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1, 1} }
+
+func (m *Message_NamedGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_NamedGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_NamedGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+func (m *Message_NamedGroup) GetF4() *Message {
+	if m != nil {
+		return m.F4
+	}
+	return nil
+}
+
+type Message_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_unrecognized []byte   `json:"-"`
+}
+
+func (m *Message_OptionalGroup) Reset()                    { *m = Message_OptionalGroup{} }
+func (m *Message_OptionalGroup) String() string            { return proto.CompactTextString(m) }
+func (*Message_OptionalGroup) ProtoMessage()               {}
+func (*Message_OptionalGroup) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1, 2} }
+
+func (m *Message_OptionalGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_OptionalGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_OptionalGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message_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_unrecognized []byte   `json:"-"`
+}
+
+func (m *Message_RequiredGroup) Reset()                    { *m = Message_RequiredGroup{} }
+func (m *Message_RequiredGroup) String() string            { return proto.CompactTextString(m) }
+func (*Message_RequiredGroup) ProtoMessage()               {}
+func (*Message_RequiredGroup) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1, 3} }
+
+func (m *Message_RequiredGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_RequiredGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_RequiredGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message_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_unrecognized []byte   `json:"-"`
+}
+
+func (m *Message_RepeatedGroup) Reset()                    { *m = Message_RepeatedGroup{} }
+func (m *Message_RepeatedGroup) String() string            { return proto.CompactTextString(m) }
+func (*Message_RepeatedGroup) ProtoMessage()               {}
+func (*Message_RepeatedGroup) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1, 4} }
+
+func (m *Message_RepeatedGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_RepeatedGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_RepeatedGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message_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_unrecognized []byte   `json:"-"`
+}
+
+func (m *Message_OneofGroup) Reset()                    { *m = Message_OneofGroup{} }
+func (m *Message_OneofGroup) String() string            { return proto.CompactTextString(m) }
+func (*Message_OneofGroup) ProtoMessage()               {}
+func (*Message_OneofGroup) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1, 33} }
+
+func (m *Message_OneofGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_OneofGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_OneofGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message_ExtensionOptionalGroup 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_unrecognized []byte   `json:"-"`
+}
+
+func (m *Message_ExtensionOptionalGroup) Reset()         { *m = Message_ExtensionOptionalGroup{} }
+func (m *Message_ExtensionOptionalGroup) String() string { return proto.CompactTextString(m) }
+func (*Message_ExtensionOptionalGroup) ProtoMessage()    {}
+func (*Message_ExtensionOptionalGroup) Descriptor() ([]byte, []int) {
+	return fileDescriptor0, []int{1, 34}
+}
+
+func (m *Message_ExtensionOptionalGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_ExtensionOptionalGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_ExtensionOptionalGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message_ExtensionRepeatedGroup 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_unrecognized []byte   `json:"-"`
+}
+
+func (m *Message_ExtensionRepeatedGroup) Reset()         { *m = Message_ExtensionRepeatedGroup{} }
+func (m *Message_ExtensionRepeatedGroup) String() string { return proto.CompactTextString(m) }
+func (*Message_ExtensionRepeatedGroup) ProtoMessage()    {}
+func (*Message_ExtensionRepeatedGroup) Descriptor() ([]byte, []int) {
+	return fileDescriptor0, []int{1, 35}
+}
+
+func (m *Message_ExtensionRepeatedGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_ExtensionRepeatedGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_ExtensionRepeatedGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*SiblingMessage)(nil), "google.golang.org.proto2_20160519.SiblingMessage")
+	proto.RegisterType((*Message)(nil), "google.golang.org.proto2_20160519.Message")
+	proto.RegisterType((*Message_ChildMessage)(nil), "google.golang.org.proto2_20160519.Message.ChildMessage")
+	proto.RegisterType((*Message_NamedGroup)(nil), "google.golang.org.proto2_20160519.Message.NamedGroup")
+	proto.RegisterType((*Message_OptionalGroup)(nil), "google.golang.org.proto2_20160519.Message.OptionalGroup")
+	proto.RegisterType((*Message_RequiredGroup)(nil), "google.golang.org.proto2_20160519.Message.RequiredGroup")
+	proto.RegisterType((*Message_RepeatedGroup)(nil), "google.golang.org.proto2_20160519.Message.RepeatedGroup")
+	proto.RegisterType((*Message_OneofGroup)(nil), "google.golang.org.proto2_20160519.Message.OneofGroup")
+	proto.RegisterType((*Message_ExtensionOptionalGroup)(nil), "google.golang.org.proto2_20160519.Message.ExtensionOptionalGroup")
+	proto.RegisterType((*Message_ExtensionRepeatedGroup)(nil), "google.golang.org.proto2_20160519.Message.ExtensionRepeatedGroup")
+	proto.RegisterEnum("google.golang.org.proto2_20160519.SiblingEnum", SiblingEnum_name, SiblingEnum_value)
+	proto.RegisterEnum("google.golang.org.proto2_20160519.Message_ChildEnum", Message_ChildEnum_name, Message_ChildEnum_value)
+	proto.RegisterExtension(E_Message_ExtensionOptionalBool)
+	proto.RegisterExtension(E_Message_ExtensionOptionalInt32)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSint32)
+	proto.RegisterExtension(E_Message_ExtensionOptionalUint32)
+	proto.RegisterExtension(E_Message_ExtensionOptionalInt64)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSint64)
+	proto.RegisterExtension(E_Message_ExtensionOptionalUint64)
+	proto.RegisterExtension(E_Message_ExtensionOptionalFixed32)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSfixed32)
+	proto.RegisterExtension(E_Message_ExtensionOptionalFloat)
+	proto.RegisterExtension(E_Message_ExtensionOptionalFixed64)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSfixed64)
+	proto.RegisterExtension(E_Message_ExtensionOptionalDouble)
+	proto.RegisterExtension(E_Message_ExtensionOptionalString)
+	proto.RegisterExtension(E_Message_ExtensionOptionalBytes)
+	proto.RegisterExtension(E_Message_ExtensionOptionalChildEnum)
+	proto.RegisterExtension(E_Message_ExtensionOptionalChildMessage)
+	proto.RegisterExtension(E_Message_ExtensionOptionalNamedGroup)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSiblingEnum)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSiblingMessage)
+	proto.RegisterExtension(E_Message_Extensionoptionalgroup)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedBool)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedInt32)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedSint32)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedUint32)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedInt64)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedSint64)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedUint64)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedFixed32)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedSfixed32)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedFloat)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedFixed64)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedSfixed64)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedDouble)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedString)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedBytes)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedChildEnum)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedSiblingEnum)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedBool)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedInt32)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSint32)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedUint32)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedInt64)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSint64)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedUint64)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedFixed32)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSfixed32)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedFloat)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedFixed64)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSfixed64)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedDouble)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedString)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedBytes)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedChildEnum)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedChildMessage)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedNamedGroup)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSiblingEnum)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSiblingMessage)
+	proto.RegisterExtension(E_Message_Extensionrepeatedgroup)
+}
+
+var fileDescriptor0 = []byte{
+	// 4468 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x5c, 0x69, 0x70, 0x23, 0xc7,
+	0x75, 0xe6, 0x00, 0x04, 0xb8, 0xec, 0x25, 0x48, 0x70, 0x76, 0x97, 0x9c, 0xa5, 0xa4, 0x08, 0x5e,
+	0x3b, 0x0e, 0xa2, 0x68, 0xb9, 0xcb, 0x61, 0xb3, 0x57, 0x8b, 0xe8, 0xf0, 0x52, 0x5a, 0x19, 0x72,
+	0x2c, 0xc8, 0x35, 0xaa, 0x4d, 0xa5, 0x52, 0xaa, 0x30, 0xe0, 0x12, 0xe4, 0x52, 0xc2, 0x41, 0x91,
+	0x80, 0xa4, 0x8d, 0x9d, 0xd2, 0xc6, 0x39, 0x7f, 0xca, 0xf7, 0x05, 0xdb, 0xb2, 0x6e, 0x5b, 0xa7,
+	0xef, 0x4b, 0x97, 0x8f, 0x24, 0xf2, 0x7d, 0xe5, 0x70, 0x2e, 0xe7, 0xbe, 0x9c, 0xfb, 0xbe, 0x8f,
+	0xea, 0x7e, 0xdd, 0xd3, 0xdd, 0x33, 0x3d, 0x20, 0x7b, 0xe0, 0xd2, 0x0f, 0x55, 0x69, 0x1b, 0xaf,
+	0xdf, 0xd7, 0xef, 0x43, 0xbf, 0xf7, 0x3e, 0xf6, 0x4c, 0x03, 0xbd, 0x74, 0x6b, 0xbb, 0xd3, 0xed,
+	0xf8, 0x2b, 0xfe, 0xf1, 0x05, 0x72, 0x7c, 0x69, 0xe1, 0xe4, 0x4a, 0x1d, 0xd7, 0x57, 0x4f, 0x36,
+	0xce, 0x2e, 0x1d, 0xeb, 0x36, 0x76, 0xba, 0xf3, 0xec, 0x53, 0xf7, 0x25, 0x1b, 0x9d, 0xce, 0x46,
+	0xb3, 0x31, 0xbf, 0xd1, 0x69, 0xd6, 0xdb, 0x1b, 0xf3, 0x9d, 0xed, 0x8d, 0xf9, 0xc8, 0xb4, 0x23,
+	0xaf, 0x43, 0x93, 0x37, 0x6f, 0xae, 0x36, 0x37, 0xdb, 0x1b, 0x37, 0x36, 0x76, 0x76, 0xea, 0x1b,
+	0x0d, 0x77, 0x12, 0x65, 0xd6, 0x17, 0x3c, 0xa7, 0xe4, 0x94, 0xc7, 0x83, 0xcc, 0xfa, 0x02, 0xfb,
+	0xb7, 0xef, 0x65, 0x4a, 0x19, 0xf6, 0x6f, 0x9f, 0xfd, 0x7b, 0xd1, 0xcb, 0x96, 0xb2, 0xec, 0xdf,
+	0x8b, 0x6e, 0x05, 0x65, 0xd6, 0xb1, 0x37, 0x5a, 0x72, 0xca, 0xfb, 0xfd, 0xcb, 0xe6, 0x77, 0x45,
+	0x9c, 0xe7, 0x38, 0x41, 0x66, 0x1d, 0x1f, 0xf9, 0xce, 0xa3, 0x0e, 0x1a, 0x13, 0xc0, 0x67, 0x10,
+	0x6a, 0xd7, 0x5b, 0x8d, 0xb5, 0x8d, 0xed, 0x4e, 0x6f, 0x8b, 0x2d, 0x00, 0xf9, 0x4b, 0x7b, 0x77,
+	0x38, 0x5f, 0xa3, 0x93, 0x5f, 0x49, 0x27, 0x07, 0x8a, 0x23, 0xf7, 0xa5, 0xa8, 0xd0, 0xd9, 0xea,
+	0x6e, 0x76, 0xda, 0xf5, 0xe6, 0xca, 0x6a, 0xa7, 0xd3, 0xf4, 0xd6, 0x4a, 0x4e, 0x79, 0x5f, 0x30,
+	0x21, 0x06, 0x97, 0x3b, 0x9d, 0xa6, 0xfb, 0xfd, 0x68, 0x32, 0x34, 0xda, 0x6c, 0x77, 0x17, 0x7d,
+	0xaf, 0x51, 0x72, 0xca, 0xb9, 0x20, 0x9c, 0x7a, 0x03, 0x1d, 0x74, 0x7f, 0x00, 0x4d, 0x85, 0x66,
+	0x3b, 0x60, 0xb7, 0x5e, 0x72, 0xca, 0xd3, 0x41, 0x38, 0xfb, 0xe6, 0xcd, 0x98, 0x61, 0x0f, 0x0c,
+	0x37, 0x4a, 0x4e, 0xb9, 0x20, 0x0d, 0xcf, 0x80, 0x61, 0x04, 0x98, 0x60, 0xef, 0x5c, 0xc9, 0x29,
+	0x67, 0x35, 0x60, 0x82, 0x63, 0xc0, 0x04, 0x7b, 0x9b, 0x25, 0xa7, 0xec, 0xea, 0xc0, 0x11, 0xc3,
+	0x1e, 0x18, 0xde, 0x5a, 0x72, 0xca, 0xa3, 0x3a, 0x30, 0xc1, 0xee, 0x0f, 0xa2, 0x62, 0x68, 0xb8,
+	0xbe, 0x79, 0x57, 0x63, 0x6d, 0xd1, 0xf7, 0x6e, 0x2b, 0x39, 0xe5, 0xb1, 0x20, 0x74, 0x70, 0x3d,
+	0x0c, 0xbb, 0x3f, 0x84, 0xa6, 0x25, 0xb8, 0xb0, 0x6d, 0x96, 0x9c, 0xf2, 0x54, 0x10, 0xfa, 0xb8,
+	0x99, 0x8f, 0x6b, 0x01, 0xad, 0x37, 0x3b, 0xf5, 0xae, 0xd7, 0x2a, 0x39, 0xe5, 0x8c, 0x0c, 0xe8,
+	0x7a, 0x3a, 0x18, 0x87, 0x27, 0xd8, 0x6b, 0x97, 0x9c, 0x72, 0x3e, 0x02, 0x4f, 0xb0, 0x01, 0x9e,
+	0x60, 0xaf, 0x53, 0x72, 0xca, 0xc5, 0x28, 0x7c, 0x24, 0xfe, 0xb5, 0x4e, 0x6f, 0xb5, 0xd9, 0xf0,
+	0xb6, 0x4a, 0x4e, 0xd9, 0x91, 0xf1, 0x5f, 0xc7, 0x46, 0x75, 0x46, 0xbb, 0xdb, 0x9b, 0xed, 0x0d,
+	0xef, 0x76, 0xb6, 0xe7, 0x25, 0xa3, 0x6c, 0x54, 0x0b, 0x68, 0xf5, 0x7c, 0xb7, 0xb1, 0xe3, 0x6d,
+	0x97, 0x9c, 0xf2, 0x84, 0x0c, 0x68, 0x99, 0x0e, 0xba, 0x6b, 0xe8, 0x40, 0x68, 0x76, 0xf6, 0xdc,
+	0x66, 0x73, 0x6d, 0xa5, 0xd1, 0xee, 0xb5, 0xbc, 0x9d, 0x92, 0x53, 0x9e, 0xf4, 0xb1, 0xc5, 0x36,
+	0xbe, 0x96, 0x4e, 0x3e, 0xdd, 0xee, 0xb5, 0x82, 0x30, 0xec, 0x70, 0xc8, 0x6d, 0xa1, 0x99, 0x08,
+	0x4a, 0x0b, 0xa6, 0x79, 0x5d, 0x96, 0x80, 0x27, 0x6c, 0x81, 0x44, 0x36, 0x1e, 0xd4, 0xb0, 0x44,
+	0x4a, 0x6e, 0xa0, 0x70, 0x7c, 0x85, 0xa5, 0xd4, 0x0a, 0x24, 0x67, 0x8f, 0x81, 0xa5, 0x4c, 0x4e,
+	0x57, 0xb8, 0x94, 0x63, 0xee, 0x2a, 0x3a, 0xa4, 0xec, 0x6f, 0x56, 0x8f, 0x80, 0xbf, 0x3b, 0x18,
+	0x7f, 0xf3, 0x7b, 0x40, 0xe2, 0x65, 0x8c, 0x31, 0x77, 0x40, 0x66, 0x45, 0x38, 0xe8, 0xde, 0x86,
+	0xbc, 0x18, 0x86, 0x60, 0xef, 0x4e, 0x16, 0xd0, 0xc2, 0xde, 0x61, 0x04, 0x6f, 0x33, 0x11, 0x24,
+	0xc1, 0xdc, 0x4f, 0xc8, 0xaa, 0x03, 0x94, 0xdd, 0xc5, 0xea, 0xd9, 0x15, 0x16, 0x94, 0xdd, 0xc4,
+	0xe7, 0x03, 0x6b, 0xba, 0x3b, 0xf7, 0x72, 0x34, 0xb9, 0xd6, 0x58, 0xaf, 0xf7, 0x9a, 0xdd, 0xc6,
+	0x1a, 0x94, 0xb5, 0x17, 0x68, 0xc5, 0xdc, 0x57, 0x19, 0xed, 0x6e, 0xf7, 0x1a, 0x41, 0x21, 0xfc,
+	0x90, 0x95, 0xb7, 0xe3, 0x68, 0x4a, 0x5a, 0x43, 0x39, 0xfa, 0x02, 0x35, 0xcf, 0x55, 0xf2, 0x47,
+	0x17, 0xfc, 0x45, 0xbc, 0x14, 0x48, 0x6f, 0x50, 0xe9, 0x16, 0x50, 0x51, 0xce, 0xe0, 0xa5, 0xee,
+	0x8b, 0x74, 0xca, 0x74, 0x25, 0x77, 0x74, 0xd1, 0x3f, 0x7e, 0x3c, 0x90, 0x1e, 0x79, 0xcd, 0x3b,
+	0xae, 0x4e, 0xe1, 0x45, 0xef, 0x4b, 0x74, 0x4a, 0xa1, 0x32, 0x1a, 0x99, 0xc1, 0x8b, 0x1f, 0x8e,
+	0x2c, 0x8b, 0x60, 0xef, 0xcb, 0x74, 0x42, 0xb6, 0x82, 0x60, 0x59, 0xe4, 0xc4, 0x15, 0x27, 0xf5,
+	0xa5, 0x11, 0x1c, 0x5f, 0x1a, 0xc1, 0xde, 0x57, 0xe8, 0x34, 0xb7, 0x92, 0x3b, 0x4a, 0x70, 0x6c,
+	0x69, 0x04, 0xc7, 0x97, 0x46, 0xb0, 0xf7, 0x55, 0x3a, 0x65, 0xb4, 0x32, 0x1a, 0x99, 0xc1, 0xcb,
+	0x23, 0x46, 0xd3, 0x72, 0x86, 0xa8, 0x79, 0x5f, 0xa3, 0x53, 0xc6, 0x2a, 0x79, 0x1a, 0xcd, 0xf1,
+	0xe3, 0x81, 0xf4, 0x29, 0x2a, 0xe5, 0x09, 0xe4, 0x2a, 0x4b, 0x13, 0xd3, 0xbe, 0x4e, 0xa7, 0x4d,
+	0x55, 0xc6, 0x8e, 0xf2, 0x79, 0xd2, 0x73, 0x58, 0x35, 0x17, 0x54, 0x26, 0xa0, 0x6c, 0x7e, 0x83,
+	0xce, 0xca, 0x54, 0xc6, 0x16, 0xe7, 0x17, 0xf0, 0xc2, 0x92, 0x4a, 0x03, 0x54, 0xd0, 0xf8, 0x0a,
+	0x09, 0xf6, 0xbe, 0x49, 0x27, 0xe5, 0x2b, 0x79, 0x1a, 0x54, 0x7c, 0x85, 0x04, 0x9b, 0x56, 0x48,
+	0xb0, 0xf7, 0x2d, 0x3a, 0xad, 0x58, 0x19, 0x3b, 0xca, 0xe7, 0x45, 0x57, 0x48, 0xb0, 0x7b, 0x52,
+	0xa5, 0x90, 0x57, 0xd6, 0x5f, 0xa3, 0xd3, 0x9c, 0x4a, 0x81, 0x2f, 0xd1, 0x27, 0x4b, 0x8b, 0x4b,
+	0x27, 0x15, 0x2e, 0x79, 0xa9, 0xbd, 0x52, 0xfb, 0xc2, 0xa0, 0xd6, 0xfe, 0x3a, 0x13, 0x18, 0x95,
+	0xe2, 0xb9, 0x46, 0xb3, 0xd9, 0xb9, 0xbc, 0x74, 0xe4, 0xce, 0xce, 0x76, 0x73, 0xed, 0x25, 0x47,
+	0x90, 0xfa, 0xdd, 0x41, 0xfd, 0x5d, 0x56, 0xa9, 0x81, 0x02, 0xfc, 0x1b, 0x74, 0xf2, 0x44, 0xc5,
+	0x5b, 0x6b, 0xd4, 0xd7, 0x6e, 0x59, 0x5c, 0x24, 0xb7, 0xf8, 0x4b, 0x4b, 0xb7, 0xf8, 0x27, 0xc8,
+	0x2d, 0x8b, 0x4b, 0x27, 0x56, 0x1b, 0x8d, 0x75, 0x85, 0x2b, 0x28, 0xce, 0x6d, 0x74, 0x50, 0xfa,
+	0x50, 0xaa, 0xf3, 0x6f, 0x3a, 0xe9, 0xcb, 0x73, 0x25, 0x77, 0xea, 0xd5, 0xaf, 0xa9, 0x9e, 0x0a,
+	0x24, 0x9f, 0xb2, 0x4c, 0x37, 0xd1, 0x8c, 0xba, 0x45, 0x95, 0x7a, 0xf6, 0x6d, 0x27, 0x4d, 0x41,
+	0x13, 0x58, 0x07, 0x95, 0x8d, 0x2d, 0x0b, 0xdb, 0xcb, 0x50, 0x61, 0xbb, 0x71, 0x7b, 0x6f, 0x73,
+	0x5b, 0x94, 0x82, 0xc7, 0xa8, 0x5a, 0xdb, 0x17, 0x4c, 0x88, 0x51, 0x56, 0x03, 0x5e, 0x8e, 0x26,
+	0x43, 0x2b, 0x48, 0xce, 0xc7, 0xa9, 0x59, 0x2e, 0x08, 0x27, 0x43, 0xe6, 0x97, 0xd1, 0x54, 0x68,
+	0xc7, 0x13, 0xff, 0x09, 0x6a, 0x38, 0x1d, 0x84, 0xf3, 0x79, 0xc2, 0xab, 0x96, 0x3c, 0xdf, 0x9f,
+	0xa4, 0x96, 0x05, 0x69, 0xc9, 0x13, 0x3d, 0x82, 0x4d, 0xb0, 0xf7, 0x14, 0x35, 0xcc, 0x6a, 0xd8,
+	0x04, 0xc7, 0xb0, 0x09, 0xf6, 0x3e, 0x48, 0x0d, 0x5d, 0x1d, 0x3b, 0x62, 0xc9, 0x13, 0xfa, 0x43,
+	0xd4, 0x72, 0x54, 0xc7, 0x26, 0xd8, 0xbd, 0x0c, 0x15, 0x43, 0x4b, 0x91, 0x91, 0x1f, 0xa6, 0xa6,
+	0x63, 0x41, 0xe8, 0x42, 0xe4, 0xef, 0xe5, 0x68, 0x5a, 0xe2, 0x0b, 0xe3, 0x8f, 0x50, 0xe3, 0xa9,
+	0x20, 0xf4, 0x12, 0x26, 0xad, 0x1a, 0x15, 0xe4, 0xec, 0x47, 0xa9, 0x69, 0x46, 0x46, 0x05, 0x99,
+	0x1a, 0x5b, 0x01, 0xc1, 0xde, 0xc7, 0xa8, 0x65, 0x3e, 0xb2, 0x02, 0x82, 0x0d, 0x2b, 0x20, 0xd8,
+	0xfb, 0x38, 0x35, 0x2e, 0x46, 0x57, 0x10, 0x61, 0x81, 0xe7, 0xe4, 0x27, 0xa8, 0xad, 0x23, 0x59,
+	0xe0, 0x39, 0xa8, 0x31, 0x0b, 0x29, 0xf8, 0x49, 0xd0, 0xf4, 0x92, 0x59, 0xc8, 0x37, 0x35, 0x2a,
+	0x48, 0xb7, 0x4f, 0x51, 0xc3, 0x09, 0x19, 0x15, 0xe4, 0x54, 0x03, 0x1d, 0x08, 0xed, 0x94, 0x94,
+	0xfa, 0x34, 0x35, 0x4e, 0xad, 0x78, 0x84, 0x47, 0x99, 0x4a, 0x6d, 0x34, 0x13, 0x81, 0x11, 0x3d,
+	0xfb, 0x69, 0x8a, 0x34, 0x8c, 0xe4, 0xd1, 0xc0, 0x44, 0xe3, 0x3e, 0x87, 0xc2, 0x71, 0x4d, 0xf2,
+	0x3c, 0x03, 0x68, 0x69, 0x35, 0x8f, 0xf0, 0xa9, 0x68, 0x9e, 0xb3, 0xe8, 0x90, 0xb2, 0xd9, 0x95,
+	0x1a, 0xf1, 0x2c, 0x50, 0x68, 0x2d, 0x7a, 0x64, 0x8a, 0xc8, 0xda, 0xd0, 0x44, 0x5e, 0x0c, 0x44,
+	0x10, 0xf8, 0x1c, 0x84, 0x94, 0x46, 0xf5, 0x44, 0xa0, 0x04, 0x79, 0x2b, 0xb2, 0x12, 0x01, 0x6b,
+	0xcf, 0x53, 0x08, 0x3b, 0xd9, 0x13, 0x70, 0x07, 0x5c, 0xf6, 0x68, 0xfe, 0xdc, 0xab, 0xd0, 0xac,
+	0xdc, 0xf0, 0xba, 0xfe, 0xb9, 0x27, 0x4b, 0x8b, 0x1e, 0xd7, 0x3f, 0x21, 0xb3, 0xd7, 0x69, 0x3a,
+	0xe8, 0x94, 0xc2, 0x46, 0x54, 0x10, 0xbd, 0x81, 0xce, 0x97, 0x82, 0x68, 0x26, 0xe6, 0x01, 0xca,
+	0xe3, 0x32, 0x3a, 0x6c, 0x70, 0xc1, 0x0b, 0xe5, 0x1b, 0xa9, 0x8f, 0x50, 0x21, 0xcd, 0xc6, 0x5c,
+	0xf0, 0xc2, 0x79, 0xca, 0xe8, 0x83, 0x97, 0xd0, 0x37, 0x51, 0x1f, 0x42, 0x32, 0xc5, 0x5d, 0xf0,
+	0x8a, 0x7a, 0x3a, 0x29, 0x12, 0x82, 0xbd, 0x37, 0x53, 0x0f, 0xba, 0x86, 0x32, 0x46, 0x43, 0xf0,
+	0x80, 0x68, 0x08, 0xf6, 0xde, 0x42, 0xfd, 0x84, 0xa2, 0xca, 0x1c, 0x0d, 0xc1, 0x03, 0xa2, 0x21,
+	0xd8, 0x7b, 0x2b, 0xf5, 0x21, 0x54, 0x96, 0x39, 0x1a, 0x82, 0xdd, 0xd3, 0x68, 0xce, 0xe0, 0x42,
+	0x14, 0xe0, 0xb7, 0x51, 0x1f, 0x52, 0x76, 0x79, 0x31, 0x2f, 0xa2, 0x7c, 0x57, 0xd1, 0x45, 0xa6,
+	0x68, 0x84, 0x9f, 0xb7, 0x53, 0x3f, 0x8a, 0x0e, 0x3b, 0x1c, 0x8f, 0x48, 0x94, 0xf6, 0x65, 0x23,
+	0xbd, 0x50, 0xe4, 0xdf, 0x41, 0xdd, 0x28, 0xc2, 0x2c, 0xce, 0x2d, 0x94, 0xfd, 0x01, 0x41, 0x11,
+	0xec, 0xbd, 0x93, 0x7a, 0x91, 0x4a, 0x2d, 0x21, 0x28, 0x82, 0x07, 0x06, 0x45, 0xb0, 0xf7, 0x2e,
+	0xea, 0x47, 0x91, 0x6e, 0x49, 0x41, 0x11, 0xec, 0xbe, 0xca, 0xf8, 0x45, 0xf1, 0xbe, 0xd1, 0xa7,
+	0x7e, 0x62, 0x5a, 0x2e, 0xfe, 0x8d, 0xf1, 0x7e, 0x72, 0xa3, 0x79, 0xe3, 0x40, 0x67, 0x79, 0x37,
+	0xf5, 0x65, 0x12, 0x77, 0x86, 0x3d, 0x04, 0x4d, 0xe7, 0x66, 0x23, 0xdf, 0xd0, 0x7e, 0xde, 0x43,
+	0xbd, 0x0d, 0x52, 0x7b, 0xf1, 0x2f, 0x00, 0x3a, 0xd4, 0xdd, 0xe8, 0x12, 0x83, 0x53, 0xa5, 0x57,
+	0xbd, 0x37, 0x9b, 0xbe, 0x57, 0x09, 0x49, 0x36, 0x17, 0x03, 0x97, 0xbd, 0xeb, 0xa7, 0xd1, 0xa5,
+	0xc6, 0xec, 0x52, 0x6a, 0xfd, 0xbd, 0xd9, 0x34, 0xb5, 0x5e, 0x80, 0x5f, 0x6c, 0xc8, 0xc9, 0x88,
+	0x2e, 0xdc, 0x6a, 0xd4, 0xc3, 0x12, 0xf9, 0xcf, 0xd9, 0x52, 0x16, 0x74, 0x21, 0x8c, 0x4a, 0x5d,
+	0xc8, 0xad, 0xa0, 0x02, 0xfd, 0x0b, 0x35, 0x63, 0xba, 0x10, 0x86, 0x15, 0x5d, 0xc8, 0xed, 0x78,
+	0xb9, 0xfb, 0x57, 0x6a, 0xc8, 0x74, 0x21, 0x8c, 0xab, 0xba, 0x90, 0x5b, 0xf2, 0xa2, 0xf6, 0x6f,
+	0xd4, 0xb2, 0x20, 0x2d, 0x55, 0x5d, 0x28, 0xb1, 0x09, 0xf6, 0xfe, 0x9d, 0x1a, 0x66, 0x35, 0x6c,
+	0xa1, 0x73, 0x14, 0x6c, 0x82, 0xbd, 0xff, 0xa0, 0x86, 0xae, 0x8e, 0x1d, 0xb1, 0xe4, 0x25, 0xe8,
+	0x3f, 0xa9, 0xe5, 0xa8, 0x8e, 0x2d, 0x74, 0x21, 0xb7, 0x14, 0x15, 0xe2, 0xbf, 0xa8, 0x29, 0xd3,
+	0x85, 0xf0, 0x81, 0xa6, 0x0b, 0x05, 0xbe, 0x30, 0xfe, 0x6f, 0x6a, 0xcc, 0x74, 0x21, 0x5f, 0x81,
+	0xa6, 0x0b, 0x85, 0x67, 0x56, 0x32, 0xfe, 0x87, 0x9a, 0x66, 0x64, 0x54, 0x8a, 0x2e, 0x54, 0x57,
+	0x40, 0xb0, 0xf7, 0xbf, 0xd4, 0x32, 0x1f, 0x59, 0x81, 0xd0, 0x85, 0xda, 0x0a, 0x08, 0xf6, 0xfe,
+	0x8f, 0x1a, 0x17, 0xa3, 0x2b, 0x88, 0xb0, 0xc0, 0xf3, 0xfb, 0xc2, 0x68, 0x29, 0x0b, 0xba, 0x10,
+	0xc6, 0x55, 0x5d, 0x28, 0xfc, 0x42, 0xf6, 0xfe, 0xcc, 0x28, 0x3b, 0xdb, 0x95, 0xcc, 0x2a, 0xba,
+	0x50, 0xec, 0x26, 0x96, 0x98, 0xaf, 0xa7, 0x86, 0x13, 0x32, 0x2a, 0x45, 0x17, 0x72, 0x3b, 0x25,
+	0xd7, 0x7e, 0x96, 0x1a, 0x0f, 0xa1, 0x0b, 0xc1, 0x63, 0x44, 0x17, 0x6a, 0x30, 0x42, 0xd6, 0xfc,
+	0x1c, 0x45, 0x1a, 0x4e, 0x17, 0x2a, 0x60, 0x9a, 0x2e, 0xe4, 0x78, 0xaa, 0x2e, 0xfc, 0x79, 0x40,
+	0x4b, 0xaf, 0x0b, 0xc1, 0x67, 0x54, 0x17, 0x86, 0x9b, 0x5d, 0xa9, 0x15, 0xbf, 0x00, 0x14, 0xa6,
+	0xd0, 0x85, 0x22, 0x45, 0x22, 0xba, 0x30, 0x02, 0x22, 0x08, 0xfc, 0x45, 0x08, 0x29, 0x9d, 0x2e,
+	0xd4, 0xa0, 0x34, 0x5d, 0x08, 0x9f, 0x00, 0x6b, 0xbf, 0x44, 0x21, 0x6c, 0x75, 0x21, 0x38, 0x08,
+	0x75, 0xa1, 0xe2, 0xcf, 0xfd, 0x49, 0x54, 0x68, 0xd5, 0xb7, 0x58, 0x95, 0x83, 0x52, 0xf7, 0x6d,
+	0x88, 0xe1, 0x87, 0x2d, 0x00, 0x6e, 0xac, 0x6f, 0xd1, 0x82, 0x48, 0xff, 0x3b, 0xdd, 0xee, 0x6e,
+	0x9f, 0x0f, 0xf6, 0xb7, 0xe4, 0x88, 0x7b, 0x16, 0x4d, 0x86, 0x08, 0x50, 0xd3, 0x7e, 0x0b, 0x20,
+	0xae, 0xb4, 0x87, 0x60, 0x05, 0x15, 0x30, 0x26, 0x5a, 0xca, 0x90, 0xbb, 0x8e, 0xa6, 0x42, 0x10,
+	0x5e, 0x63, 0x7f, 0x1b, 0x50, 0xae, 0xb2, 0x47, 0x81, 0x6a, 0x0c, 0x30, 0x85, 0x96, 0x3a, 0xa6,
+	0xe1, 0xf0, 0x0a, 0xfd, 0x3b, 0xa9, 0x71, 0xce, 0x18, 0x70, 0x78, 0x7d, 0x8f, 0x90, 0x46, 0xb0,
+	0xf7, 0xbb, 0xc3, 0x90, 0x46, 0x70, 0x8c, 0x34, 0x82, 0x63, 0xa4, 0x11, 0xec, 0xfd, 0xde, 0x50,
+	0xa4, 0x09, 0x18, 0x95, 0xb4, 0x08, 0x0e, 0x6f, 0x2d, 0xdf, 0x19, 0x8a, 0xb4, 0x28, 0x0e, 0x6f,
+	0x4c, 0x9b, 0xa8, 0x18, 0xe2, 0x88, 0x5e, 0xf3, 0xfb, 0x00, 0x74, 0xb5, 0x3d, 0x10, 0x6f, 0x61,
+	0x80, 0x34, 0xd9, 0xd2, 0x06, 0xdd, 0x26, 0x9a, 0x96, 0xd4, 0x09, 0xac, 0x3f, 0x00, 0xac, 0x6b,
+	0x52, 0x90, 0xb7, 0xae, 0x82, 0x4d, 0xb5, 0xf4, 0x51, 0x6d, 0x37, 0x40, 0x5f, 0xfc, 0xc3, 0xd4,
+	0xbb, 0x81, 0x75, 0x50, 0x7d, 0x37, 0x40, 0x53, 0x8d, 0xb1, 0x47, 0xb0, 0xf7, 0x47, 0xc3, 0xb1,
+	0x27, 0xbe, 0x27, 0x8d, 0x3d, 0x82, 0x0d, 0xec, 0x11, 0xec, 0xfd, 0xf1, 0x90, 0xec, 0x09, 0x30,
+	0x9d, 0xbd, 0xc8, 0xf6, 0xe3, 0x3d, 0xfd, 0x4f, 0x52, 0x6f, 0x3f, 0xe8, 0xfe, 0xfa, 0xf6, 0xe3,
+	0x8a, 0x40, 0x4b, 0x27, 0x50, 0x04, 0x7f, 0x9a, 0x3e, 0x9d, 0x98, 0x83, 0x48, 0x3a, 0x81, 0x9e,
+	0x50, 0x77, 0x03, 0xe8, 0x89, 0x3f, 0x4b, 0xbd, 0x1b, 0x98, 0xf2, 0xd0, 0x77, 0x03, 0x88, 0x91,
+	0x2d, 0x74, 0x20, 0x04, 0x51, 0xc4, 0xc8, 0x9f, 0x03, 0xd2, 0x2b, 0xec, 0x91, 0x42, 0x01, 0x02,
+	0x68, 0xc5, 0x56, 0x64, 0xd8, 0x3d, 0x8f, 0x66, 0x22, 0x88, 0xa2, 0xad, 0xfe, 0x05, 0x80, 0x5e,
+	0x9b, 0x12, 0x94, 0x8f, 0x01, 0xee, 0x81, 0x56, 0xfc, 0x13, 0x77, 0x07, 0x1d, 0x0c, 0xa1, 0x55,
+	0x89, 0xf2, 0x97, 0x00, 0x7c, 0xca, 0x1e, 0x58, 0xaa, 0x12, 0x80, 0x9d, 0x6e, 0x45, 0xc7, 0xdd,
+	0x3b, 0xd0, 0x21, 0xa5, 0xfa, 0x2a, 0x6a, 0xe5, 0xbb, 0x80, 0xba, 0x9c, 0xa6, 0x06, 0x87, 0x3a,
+	0x05, 0x60, 0xdd, 0x56, 0xec, 0x03, 0xf7, 0x6e, 0xe4, 0xc5, 0x70, 0x05, 0xd3, 0x7f, 0x05, 0xd0,
+	0xa7, 0x53, 0x43, 0x6b, 0x5c, 0x1f, 0x6a, 0x99, 0x3e, 0x13, 0xfb, 0x97, 0x35, 0x3a, 0xd0, 0x1c,
+	0x7f, 0x9d, 0x6a, 0xff, 0xb2, 0xce, 0x2f, 0x45, 0x07, 0xdd, 0xbf, 0xe1, 0x90, 0x48, 0xc6, 0x1d,
+	0x05, 0xe5, 0x6f, 0x52, 0x25, 0x23, 0x34, 0x7e, 0x09, 0x43, 0x93, 0x51, 0x8e, 0x09, 0x9c, 0x9e,
+	0x82, 0xf3, 0xb7, 0xa9, 0x70, 0xce, 0x18, 0x70, 0xe4, 0x98, 0x42, 0x1a, 0xc1, 0x00, 0xf3, 0x77,
+	0x69, 0x49, 0x23, 0x38, 0x46, 0x1a, 0x0c, 0xa9, 0xa4, 0x09, 0x94, 0xbf, 0x4f, 0x4d, 0x9a, 0x0a,
+	0x23, 0x48, 0xd3, 0x71, 0x7a, 0x0a, 0xce, 0x3f, 0xa4, 0x26, 0x2d, 0x8a, 0x23, 0xc7, 0x44, 0x4b,
+	0xe3, 0x6d, 0x14, 0x80, 0xfe, 0x31, 0x55, 0x4b, 0xe3, 0x7d, 0x5f, 0x22, 0xd1, 0x6f, 0x43, 0x19,
+	0x0c, 0xa9, 0x63, 0x25, 0x1a, 0x90, 0xfe, 0x29, 0x1d, 0x75, 0xcc, 0x43, 0x84, 0xba, 0x70, 0xcc,
+	0x2d, 0x21, 0xd4, 0x69, 0x37, 0x3a, 0xeb, 0x00, 0xf1, 0x74, 0xae, 0xe4, 0x94, 0xf7, 0x55, 0x47,
+	0x82, 0x71, 0x36, 0xc8, 0x2c, 0x8e, 0xa0, 0xfd, 0x60, 0x01, 0xf2, 0xf4, 0x19, 0x6a, 0x92, 0xab,
+	0x8e, 0x04, 0x30, 0x0f, 0xe4, 0xf2, 0xcb, 0xd0, 0x04, 0xd8, 0x70, 0xad, 0xfc, 0x2c, 0x35, 0x9a,
+	0xae, 0x8e, 0x04, 0x30, 0x95, 0x8b, 0xdd, 0xd0, 0x8a, 0x2b, 0xdd, 0xe7, 0xa8, 0x55, 0x21, 0xb4,
+	0xe2, 0x52, 0x55, 0xc5, 0x23, 0xd8, 0x7b, 0x9e, 0x1a, 0x65, 0x55, 0x3c, 0x82, 0x75, 0x3c, 0x82,
+	0xbd, 0xcf, 0x50, 0x23, 0x57, 0xc3, 0x53, 0xad, 0xb8, 0x48, 0xfc, 0x2c, 0xb5, 0x1a, 0xd5, 0xf0,
+	0x08, 0x76, 0x5f, 0x8e, 0x0a, 0x60, 0x25, 0x64, 0xd7, 0xe7, 0xa8, 0xd9, 0x58, 0x75, 0x24, 0x80,
+	0xd9, 0x42, 0xa2, 0x95, 0xd1, 0x24, 0xc7, 0x14, 0x86, 0x9f, 0xa7, 0x86, 0x53, 0xd5, 0x91, 0x00,
+	0x1c, 0x84, 0xf2, 0x2a, 0x8c, 0x00, 0xb4, 0xd5, 0x2f, 0x53, 0xb3, 0x4c, 0x18, 0x01, 0xa8, 0x23,
+	0x1d, 0x95, 0x60, 0xef, 0x57, 0xa8, 0x55, 0x5e, 0x47, 0x65, 0x07, 0x08, 0x1a, 0x2a, 0xc1, 0xde,
+	0xaf, 0x52, 0xc3, 0x62, 0x04, 0x55, 0x8d, 0x96, 0x6b, 0x92, 0x17, 0xa8, 0x9d, 0x13, 0x46, 0xcb,
+	0x45, 0x85, 0x64, 0x0e, 0x14, 0xc5, 0x17, 0xa8, 0xd5, 0xb8, 0x64, 0x0e, 0x24, 0x41, 0x18, 0x01,
+	0xe8, 0x81, 0x2f, 0x52, 0xa3, 0x89, 0x30, 0x02, 0xe8, 0xe8, 0x75, 0x54, 0x04, 0x1b, 0xa5, 0x9d,
+	0x7f, 0x29, 0x97, 0xfe, 0x31, 0x6e, 0x75, 0x24, 0x80, 0x50, 0x65, 0x0b, 0xbf, 0x15, 0x1d, 0x50,
+	0x21, 0x44, 0x57, 0xf9, 0x72, 0x6e, 0xa8, 0x57, 0x6c, 0xaa, 0x23, 0xc1, 0xb4, 0x04, 0x12, 0x5d,
+	0x64, 0x0d, 0xc1, 0xa0, 0xd6, 0xb0, 0xbf, 0x92, 0x1b, 0xe2, 0xfd, 0x9a, 0xea, 0x48, 0x30, 0xc5,
+	0x5c, 0x2a, 0x4d, 0x7a, 0x05, 0xb9, 0x62, 0xe3, 0x2a, 0x1d, 0xfa, 0xab, 0xb9, 0x34, 0xcf, 0xa2,
+	0xab, 0x23, 0x41, 0x91, 0x6f, 0x77, 0xd9, 0x8d, 0xcf, 0xa1, 0x43, 0x3a, 0x80, 0x20, 0xed, 0x6b,
+	0xb9, 0x94, 0x6f, 0xd6, 0x54, 0x47, 0x82, 0x03, 0x2a, 0x8c, 0x20, 0xec, 0xc7, 0x78, 0xe5, 0x00,
+	0xa6, 0xbe, 0x9e, 0xb3, 0x7e, 0x4d, 0xf0, 0x26, 0x3a, 0x5b, 0x30, 0xa5, 0xf8, 0x92, 0xb9, 0x01,
+	0x7b, 0x74, 0xc1, 0xfb, 0x86, 0xd8, 0xa4, 0x13, 0xca, 0x26, 0x5d, 0x88, 0xda, 0xf9, 0xde, 0x37,
+	0x4d, 0x76, 0x7e, 0xd4, 0x6e, 0xd1, 0xfb, 0x96, 0xc9, 0x6e, 0xd1, 0x3d, 0x89, 0x0e, 0xf2, 0x0c,
+	0xd2, 0x1f, 0x68, 0xdd, 0x9b, 0x97, 0x2f, 0xf4, 0x54, 0x9d, 0x00, 0xbe, 0x41, 0xfd, 0x79, 0xd6,
+	0x55, 0x82, 0xf6, 0xe8, 0xc3, 0xac, 0xf7, 0xe5, 0xd5, 0xb7, 0x7b, 0xaa, 0x0e, 0xe7, 0x32, 0xf2,
+	0x2c, 0xeb, 0x6a, 0x34, 0x13, 0x9d, 0xce, 0x2b, 0xe9, 0x7d, 0x79, 0xe5, 0x55, 0x9f, 0xaa, 0x13,
+	0x1c, 0xd4, 0xa7, 0xf3, 0xca, 0x7a, 0x55, 0x7c, 0x3e, 0xaf, 0xb1, 0xf7, 0xe7, 0xe5, 0x7b, 0x3f,
+	0xf1, 0xe9, 0x67, 0xc4, 0x63, 0x30, 0xd3, 0xea, 0x09, 0xf6, 0x1e, 0xc8, 0x47, 0x5f, 0x02, 0x32,
+	0x46, 0x40, 0x70, 0x52, 0x04, 0x04, 0x7b, 0x0f, 0xe6, 0x95, 0x37, 0x82, 0xcc, 0x11, 0x10, 0x9c,
+	0x14, 0x01, 0xc1, 0xde, 0x43, 0x79, 0xf9, 0x7a, 0x90, 0x39, 0x02, 0xf6, 0xe8, 0x6b, 0x36, 0x3a,
+	0x5d, 0x54, 0xe9, 0x87, 0xf3, 0xea, 0xbb, 0x42, 0x55, 0x27, 0x38, 0xa4, 0x7b, 0x10, 0xf5, 0xfd,
+	0x3a, 0xe4, 0xc5, 0x22, 0x10, 0x3e, 0x1e, 0xc9, 0x6b, 0x2f, 0x0e, 0x55, 0x9d, 0x60, 0x26, 0x12,
+	0x85, 0xa8, 0xfd, 0x57, 0xc7, 0xa9, 0x84, 0x2e, 0xf0, 0xfe, 0xbc, 0xf6, 0x16, 0x51, 0x9c, 0x47,
+	0xe8, 0x0b, 0x49, 0x81, 0x10, 0xec, 0x7d, 0x20, 0xaf, 0xbe, 0x52, 0x94, 0x10, 0x08, 0xc1, 0xc9,
+	0x81, 0x10, 0xec, 0x3d, 0x9a, 0xd7, 0xde, 0x2f, 0x4a, 0x0a, 0x84, 0x60, 0xf7, 0xfa, 0xf8, 0x17,
+	0xc2, 0x1b, 0xcb, 0x63, 0x79, 0xc3, 0xcb, 0x46, 0xf1, 0x6f, 0x86, 0x37, 0x9c, 0x1b, 0x0c, 0x1b,
+	0x03, 0x5a, 0xcf, 0xe3, 0x79, 0xf3, 0x9b, 0x47, 0x86, 0x3d, 0x02, 0x5d, 0xe9, 0xa6, 0x38, 0xb7,
+	0xd0, 0x9f, 0x9e, 0xc8, 0x0f, 0x7e, 0x0d, 0x29, 0x4e, 0x36, 0xb4, 0xb0, 0xd7, 0xa2, 0xb9, 0xa8,
+	0x43, 0xa5, 0x99, 0x3d, 0x99, 0x1f, 0xfa, 0x9d, 0xa4, 0xaa, 0x13, 0xcc, 0xea, 0xc0, 0xea, 0xdf,
+	0xa7, 0x17, 0xc7, 0x33, 0x46, 0x69, 0x0a, 0x4f, 0xe5, 0x87, 0x78, 0x41, 0xa9, 0xea, 0x04, 0x87,
+	0xa3, 0x79, 0x16, 0xda, 0xcc, 0xfd, 0x14, 0x9a, 0xd0, 0x7a, 0xdf, 0x8b, 0xf8, 0xa6, 0xf9, 0xdc,
+	0x5d, 0x08, 0x29, 0xfd, 0xf0, 0xc5, 0x44, 0xbe, 0x06, 0x15, 0xb4, 0x37, 0x39, 0x6d, 0xc1, 0xa9,
+	0x03, 0xed, 0x9d, 0x88, 0x74, 0x0e, 0x94, 0xc3, 0x73, 0x6b, 0x07, 0x57, 0xa3, 0x62, 0xf4, 0x70,
+	0xdc, 0x2d, 0xa2, 0xec, 0x6d, 0x8d, 0xf3, 0xcc, 0xc9, 0xbe, 0x80, 0xfe, 0xaf, 0x7b, 0x10, 0xe5,
+	0xee, 0xa8, 0x37, 0x7b, 0x0d, 0x2f, 0xc3, 0xc6, 0xe0, 0x1f, 0x95, 0xcc, 0x15, 0xce, 0xdc, 0x35,
+	0x68, 0x3a, 0x76, 0xf2, 0xbd, 0x9b, 0x83, 0x9c, 0xea, 0xe0, 0x15, 0xc8, 0x8d, 0x1f, 0x6a, 0xef,
+	0xe6, 0x61, 0xda, 0xec, 0xe1, 0xcc, 0xde, 0x3d, 0x14, 0x12, 0x83, 0xe0, 0xa7, 0x74, 0xbb, 0x39,
+	0xc8, 0x26, 0x07, 0xb1, 0x47, 0x0f, 0x6e, 0x72, 0x10, 0x7b, 0xf4, 0x30, 0xaa, 0x7a, 0x38, 0x85,
+	0x0e, 0x18, 0xce, 0x85, 0x77, 0x73, 0x31, 0xa6, 0xba, 0x58, 0x46, 0x07, 0x4d, 0xc7, 0xbd, 0xbb,
+	0xf9, 0x98, 0x32, 0x73, 0x29, 0xcf, 0x71, 0x77, 0x73, 0x90, 0x19, 0x10, 0xc7, 0x1e, 0xa9, 0xc8,
+	0x0f, 0x8a, 0x63, 0x8f, 0x3e, 0x8a, 0xe6, 0x2f, 0x44, 0x39, 0x50, 0xdd, 0xcd, 0x83, 0x93, 0xb0,
+	0x29, 0xe4, 0x51, 0xe9, 0x6e, 0x1e, 0xc6, 0xcd, 0x5c, 0xca, 0x53, 0xd0, 0xdd, 0x1c, 0x4c, 0xa8,
+	0x0e, 0xce, 0xa3, 0x43, 0xc6, 0xc3, 0x4d, 0x83, 0x93, 0x57, 0xa9, 0x4e, 0xd2, 0x3e, 0xcc, 0x55,
+	0xa0, 0xef, 0x46, 0x5e, 0xd2, 0x11, 0xa7, 0x01, 0xfd, 0x46, 0x15, 0x7d, 0x88, 0x07, 0xbc, 0xca,
+	0x02, 0x5e, 0x8b, 0x66, 0xcc, 0x47, 0x9d, 0x06, 0xf8, 0x1f, 0xd1, 0xe1, 0x53, 0x3e, 0xf1, 0x55,
+	0xc0, 0x7b, 0x68, 0x36, 0xe1, 0xc4, 0xd3, 0x80, 0x7e, 0x9d, 0x4e, 0xbd, 0xed, 0x43, 0x60, 0x2d,
+	0xe6, 0xb9, 0xe4, 0xd3, 0x4e, 0x03, 0xf2, 0x2b, 0xf5, 0xb8, 0x53, 0x3c, 0x16, 0x8e, 0xed, 0x56,
+	0xfd, 0xcc, 0x53, 0xc5, 0xcc, 0xed, 0xd6, 0x4b, 0x20, 0x61, 0x22, 0xc7, 0x99, 0xaa, 0x87, 0xe9,
+	0xbd, 0x79, 0x38, 0x93, 0xec, 0xa1, 0xb0, 0xb7, 0x7e, 0xa6, 0x9f, 0x41, 0xaa, 0x0e, 0xb2, 0x7b,
+	0x0f, 0x22, 0xc1, 0x83, 0xbb, 0xf7, 0x20, 0x12, 0x3c, 0x8c, 0xee, 0xe6, 0x01, 0x4a, 0x68, 0xf4,
+	0x44, 0x50, 0x75, 0x31, 0xb6, 0xc7, 0x30, 0xf4, 0xa3, 0x3e, 0xd5, 0xc3, 0xf8, 0x6e, 0x1e, 0xae,
+	0x44, 0x48, 0xfe, 0x3d, 0x6e, 0xad, 0x4b, 0xaa, 0x68, 0xe6, 0xf4, 0x5d, 0xdd, 0x46, 0x7b, 0x67,
+	0xb3, 0xd3, 0x1e, 0x4e, 0x63, 0xa9, 0x9e, 0x86, 0xd2, 0x4a, 0x47, 0xe6, 0xd1, 0xb8, 0x14, 0xdb,
+	0xe3, 0x08, 0x74, 0x71, 0x71, 0x84, 0xfe, 0xef, 0x72, 0x70, 0xea, 0x47, 0x6f, 0x2a, 0x3a, 0xee,
+	0x7e, 0x34, 0x76, 0x6d, 0xf5, 0x54, 0xf0, 0xea, 0x1b, 0x4e, 0x17, 0x33, 0x97, 0x8d, 0xef, 0xbb,
+	0xa7, 0x56, 0xbc, 0x70, 0xe1, 0xc2, 0x85, 0x8c, 0x7f, 0x16, 0xcd, 0x36, 0xc4, 0x22, 0x56, 0xb4,
+	0x3b, 0x8b, 0xae, 0x85, 0xe8, 0xf4, 0xee, 0xa9, 0x31, 0x96, 0x0f, 0x35, 0xa2, 0xd4, 0xd0, 0xaf,
+	0xc8, 0x6f, 0x20, 0xcf, 0x00, 0x02, 0x7f, 0x90, 0xdb, 0xa0, 0xbc, 0xa1, 0xc6, 0xb2, 0x75, 0x26,
+	0x86, 0xc2, 0x72, 0xdb, 0xdf, 0x40, 0x87, 0x0d, 0x30, 0x3b, 0xf6, 0x38, 0x6f, 0xac, 0xb1, 0x9c,
+	0x9e, 0x8d, 0xe1, 0x40, 0x09, 0x48, 0x00, 0xea, 0xd9, 0x03, 0xbd, 0xa9, 0xc6, 0x52, 0x3f, 0x0e,
+	0x04, 0x95, 0x22, 0x99, 0x38, 0x82, 0xad, 0x70, 0xde, 0x5c, 0x63, 0x15, 0xc2, 0x48, 0x1c, 0xc1,
+	0x03, 0x88, 0xb3, 0xc4, 0x79, 0x4b, 0x8d, 0xd5, 0x11, 0x33, 0x71, 0x89, 0x40, 0x3d, 0x7b, 0xa0,
+	0xb7, 0xd6, 0x58, 0xb9, 0x31, 0x13, 0x47, 0xb0, 0xbf, 0x89, 0xe6, 0x0c, 0x40, 0xe2, 0xe4, 0xc2,
+	0x06, 0xe9, 0x6d, 0x35, 0x56, 0x95, 0xbc, 0x18, 0x12, 0xaf, 0x62, 0xfe, 0x6d, 0xe8, 0x22, 0x13,
+	0x79, 0x69, 0xb0, 0xde, 0x5e, 0x63, 0xa2, 0xf5, 0x70, 0x9c, 0x3e, 0xee, 0x2d, 0x61, 0x43, 0xac,
+	0xc3, 0xab, 0x7d, 0x16, 0x48, 0xef, 0xa8, 0x31, 0x75, 0x1b, 0xdf, 0x10, 0x4c, 0x1b, 0x0f, 0xa2,
+	0xcf, 0xf2, 0x8b, 0x7a, 0x67, 0x8d, 0x69, 0xe0, 0x04, 0xfa, 0x08, 0x1e, 0x48, 0x9f, 0x25, 0xd6,
+	0xbb, 0x6a, 0x4c, 0x2b, 0x27, 0xd1, 0x97, 0xb8, 0xff, 0xe0, 0xb0, 0xc7, 0x0a, 0xaa, 0x5f, 0x63,
+	0xa2, 0x3a, 0xbe, 0xff, 0x40, 0x93, 0x27, 0x65, 0x14, 0x1c, 0xee, 0xd8, 0x00, 0xbd, 0xbb, 0xc6,
+	0xba, 0x80, 0x21, 0xa3, 0xe0, 0xc4, 0xd7, 0xbc, 0x21, 0xd8, 0x59, 0x91, 0x15, 0xce, 0x7b, 0x6a,
+	0x4c, 0xa2, 0xc7, 0x37, 0x04, 0x13, 0xf8, 0xfe, 0x03, 0x0e, 0xba, 0xc4, 0x80, 0x23, 0x8f, 0x90,
+	0xac, 0xc0, 0xde, 0x5b, 0x1b, 0x42, 0xca, 0xcf, 0xc5, 0x96, 0x18, 0x7e, 0xe6, 0x3f, 0xee, 0xa0,
+	0x52, 0xe2, 0x32, 0xf9, 0xe3, 0x01, 0xab, 0x95, 0xde, 0x5b, 0x1b, 0x4e, 0xf6, 0x5f, 0x62, 0x5e,
+	0x2c, 0xff, 0xd8, 0x7f, 0xd8, 0x41, 0xdf, 0x67, 0x58, 0xaf, 0xf2, 0x5c, 0xc6, 0x6a, 0xb5, 0xef,
+	0xab, 0x0d, 0xf3, 0x57, 0xc2, 0x45, 0xb1, 0xb5, 0xca, 0x0f, 0xfd, 0xfb, 0x1c, 0x74, 0xa9, 0xb1,
+	0x47, 0xc8, 0x63, 0x3c, 0xab, 0xa5, 0xde, 0x57, 0x4b, 0xf5, 0x27, 0xc5, 0xc5, 0x86, 0xce, 0x12,
+	0x7e, 0xea, 0x3f, 0xea, 0xa0, 0x23, 0x03, 0x16, 0x99, 0x66, 0x03, 0xdc, 0x5f, 0x4b, 0xfb, 0x07,
+	0xc8, 0xa5, 0x49, 0x4b, 0x15, 0x5f, 0xfe, 0x43, 0x0e, 0x92, 0xe9, 0xa6, 0xdf, 0xb4, 0xb6, 0x59,
+	0xe1, 0x03, 0x35, 0xf6, 0x38, 0xca, 0xe6, 0x4d, 0x1b, 0xb3, 0x80, 0x0d, 0x12, 0x56, 0xe3, 0x37,
+	0xd5, 0x1a, 0xa3, 0x3f, 0x30, 0xb2, 0x4b, 0xa6, 0xbe, 0x7a, 0x5d, 0x5c, 0xa2, 0x69, 0xcf, 0x97,
+	0xfc, 0x2d, 0xb5, 0x74, 0x46, 0x9e, 0x31, 0xd9, 0x65, 0x43, 0x5f, 0xbf, 0x6e, 0x3e, 0x1b, 0x07,
+	0x04, 0xdd, 0x78, 0xbb, 0xda, 0xed, 0xa2, 0x8f, 0xa5, 0xec, 0x76, 0x75, 0x5f, 0xbb, 0xae, 0xee,
+	0xc5, 0x11, 0xb9, 0x82, 0xdc, 0x32, 0x43, 0xa6, 0x90, 0x90, 0xf7, 0xf7, 0xd5, 0xeb, 0xee, 0x06,
+	0x44, 0x2e, 0x25, 0xbb, 0x89, 0xb4, 0x5a, 0x76, 0xd9, 0x07, 0xfa, 0xf1, 0xeb, 0xf2, 0x66, 0x6a,
+	0x09, 0x1e, 0x44, 0xad, 0x25, 0xec, 0x83, 0x7d, 0xed, 0xba, 0x7d, 0x02, 0xb5, 0x04, 0x0f, 0xa2,
+	0xd6, 0x12, 0xf2, 0xa1, 0xbe, 0x7a, 0x5d, 0x3f, 0x81, 0x5a, 0x82, 0xfd, 0xae, 0x2a, 0x61, 0x62,
+	0x4f, 0xe5, 0xac, 0x20, 0x1f, 0xee, 0xeb, 0xd7, 0xfd, 0x0f, 0xc7, 0x41, 0x85, 0xee, 0xbc, 0x13,
+	0x5d, 0x6c, 0xa4, 0x36, 0x0d, 0xec, 0x23, 0xfd, 0xc8, 0xcf, 0x05, 0xcc, 0x19, 0xe8, 0x15, 0x1a,
+	0xf4, 0x76, 0xf3, 0x4e, 0xb2, 0x17, 0xa1, 0xef, 0xef, 0x47, 0x7e, 0x6e, 0xc0, 0xb0, 0x8d, 0x40,
+	0x8f, 0x0e, 0x62, 0xd8, 0xf2, 0x4b, 0xfd, 0x40, 0x5f, 0xff, 0xb9, 0x82, 0x24, 0x86, 0x09, 0x1e,
+	0xcc, 0xb0, 0x25, 0xec, 0xa3, 0xfd, 0xc8, 0xcf, 0x1d, 0x24, 0x32, 0x4c, 0xb0, 0x7f, 0xde, 0xbc,
+	0x85, 0x53, 0xe8, 0xd4, 0xc7, 0xfa, 0xc6, 0x9f, 0x4b, 0x30, 0xec, 0x65, 0x2e, 0x5c, 0x5f, 0x97,
+	0x90, 0xb0, 0xf6, 0xca, 0xf5, 0xf1, 0x7e, 0xd2, 0xcf, 0x2d, 0x98, 0x72, 0x17, 0xd4, 0xec, 0xeb,
+	0x1d, 0xf3, 0xde, 0xb2, 0xd7, 0xb3, 0x4f, 0xf4, 0x77, 0xfb, 0xbd, 0x06, 0xc3, 0x66, 0x03, 0xad,
+	0xfb, 0x84, 0x26, 0xca, 0x4c, 0xcf, 0x4b, 0xad, 0x56, 0xf2, 0x64, 0xff, 0x7b, 0xf0, 0x83, 0x0f,
+	0x17, 0xc5, 0x17, 0x2b, 0x55, 0xef, 0x63, 0x9a, 0xea, 0x35, 0x3f, 0x63, 0xb5, 0x5a, 0xf2, 0x53,
+	0xfd, 0xa1, 0x7e, 0x31, 0xe2, 0x12, 0x53, 0x6d, 0x96, 0x2a, 0x6d, 0x4d, 0x3d, 0x72, 0xd2, 0x2e,
+	0x0b, 0xda, 0x2d, 0xf2, 0xbb, 0x0e, 0xbb, 0x59, 0x28, 0xcf, 0x9c, 0x02, 0xe5, 0x8a, 0xa1, 0xbf,
+	0xae, 0x8a, 0x16, 0xfd, 0xb2, 0xa1, 0x15, 0xcc, 0x07, 0x19, 0x8c, 0x7a, 0xe8, 0x14, 0xa8, 0x57,
+	0x14, 0xfd, 0x73, 0xea, 0x8e, 0x8d, 0x5c, 0x56, 0xb4, 0x02, 0xfa, 0x10, 0x03, 0x52, 0x4f, 0x9d,
+	0x02, 0xed, 0x8a, 0x63, 0x02, 0x52, 0x0a, 0xc9, 0xf0, 0x61, 0x86, 0x54, 0x30, 0x20, 0x71, 0xad,
+	0x90, 0xc8, 0x9d, 0x65, 0xd1, 0xfb, 0x08, 0x03, 0xca, 0x9a, 0xb9, 0x23, 0x78, 0x00, 0x77, 0x96,
+	0x40, 0x1f, 0x65, 0x40, 0x6e, 0x02, 0x77, 0x89, 0x48, 0x29, 0x34, 0xc1, 0xc7, 0x18, 0xd2, 0x68,
+	0x02, 0x77, 0x04, 0xfb, 0xb7, 0xaa, 0x05, 0x34, 0x7a, 0xd9, 0xd3, 0x0a, 0xea, 0xe3, 0x0c, 0x4a,
+	0x3d, 0x7a, 0x0a, 0xf4, 0x2b, 0xa2, 0x7e, 0x53, 0x6d, 0x8b, 0xb1, 0xcb, 0xa2, 0x56, 0x60, 0x9f,
+	0x60, 0x60, 0xea, 0xd9, 0x53, 0x10, 0xb9, 0x62, 0x9a, 0xb0, 0x2b, 0xec, 0xdb, 0xfe, 0x27, 0x19,
+	0x54, 0xc6, 0xb0, 0x2b, 0xa0, 0xd9, 0x0f, 0x60, 0xd0, 0xf2, 0xcb, 0xfa, 0x14, 0x43, 0xca, 0x27,
+	0x31, 0x48, 0xf0, 0x40, 0x06, 0x2d, 0xc1, 0x3e, 0xcd, 0xc0, 0x8a, 0x89, 0x0c, 0x26, 0xee, 0xc2,
+	0x14, 0x6d, 0xfd, 0x69, 0x86, 0xe5, 0x18, 0x76, 0x21, 0x6f, 0xe3, 0x09, 0x99, 0x65, 0xdf, 0xc5,
+	0x9f, 0x61, 0x48, 0xe3, 0xa6, 0xcc, 0x82, 0x96, 0x6d, 0xde, 0x15, 0xf6, 0x0d, 0xfb, 0x59, 0x06,
+	0x34, 0x61, 0xd8, 0x15, 0xd0, 0x95, 0x1f, 0xd4, 0x4e, 0xa0, 0x0c, 0xb7, 0x7d, 0xad, 0xd0, 0x9e,
+	0x63, 0x68, 0xc3, 0x1f, 0x41, 0x05, 0xd1, 0x3b, 0xc2, 0x54, 0x3d, 0x94, 0x12, 0xd7, 0x99, 0xe6,
+	0x04, 0xe2, 0x79, 0xb6, 0xd4, 0xef, 0xc9, 0x19, 0x54, 0x60, 0xb8, 0x64, 0xec, 0x3f, 0xa2, 0xc9,
+	0x1d, 0xd3, 0x7d, 0x63, 0xab, 0xe5, 0x7e, 0x86, 0x2f, 0x77, 0xe8, 0x43, 0xa8, 0x20, 0x76, 0x4b,
+	0xd9, 0xbf, 0x5f, 0x3b, 0x84, 0x32, 0x5e, 0x58, 0xb6, 0x5a, 0xeb, 0x67, 0xf9, 0x2e, 0x48, 0x7f,
+	0x0a, 0x15, 0xc4, 0xaf, 0x39, 0x53, 0x39, 0x76, 0x64, 0xc0, 0x2a, 0xd3, 0xec, 0x81, 0xcf, 0x71,
+	0x52, 0x87, 0x3a, 0x86, 0x0a, 0x8c, 0xf7, 0xa4, 0xfd, 0x87, 0xd5, 0x63, 0x28, 0xfd, 0x86, 0xb3,
+	0xcd, 0x12, 0x3f, 0xcf, 0x96, 0x98, 0xf2, 0x1c, 0x4a, 0xbf, 0x67, 0x9d, 0xb0, 0x9c, 0xe5, 0x82,
+	0x78, 0x55, 0xbf, 0xd7, 0xde, 0xec, 0xb4, 0x97, 0x67, 0xe3, 0xef, 0x48, 0xb2, 0x0f, 0x2e, 0x5b,
+	0x40, 0xfb, 0xd5, 0xf7, 0xc4, 0x4d, 0x0f, 0x44, 0x91, 0x3b, 0x21, 0x1f, 0x88, 0xbe, 0xe0, 0x2c,
+	0xbf, 0xe6, 0xc7, 0x6b, 0xb1, 0x65, 0x1f, 0x63, 0xcb, 0x5e, 0xed, 0xad, 0x1f, 0xdb, 0x6c, 0x77,
+	0x1b, 0xdb, 0xed, 0x7a, 0x93, 0xfd, 0xce, 0x2d, 0x1b, 0xdd, 0x39, 0xd6, 0x6c, 0x6c, 0xd4, 0xcf,
+	0x9e, 0x3f, 0x96, 0xf4, 0x93, 0xb8, 0xff, 0x1f, 0x00, 0x00, 0xff, 0xff, 0x83, 0x33, 0xd4, 0x34,
+	0x2d, 0x57, 0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20160519_a4ab9ec5/test.proto b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20160519_a4ab9ec5/test.proto
new file mode 100644
index 000000000..e765d6443
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20160519_a4ab9ec5/test.proto
@@ -0,0 +1,333 @@
+// 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.
+
+syntax = "proto2";
+
+package google.golang.org.proto2_20160519;
+option go_package = "google.golang.org/protobuf/internal/testprotos/legacy/proto2_20160519_a4ab9ec5";
+
+enum SiblingEnum {
+	ALPHA   = 0;
+	BRAVO   = 10;
+	CHARLIE = 200;
+}
+
+message SiblingMessage {
+	optional string  f1 = 1;
+	required string  f2 = 2;
+	repeated string  f3 = 3;
+	optional Message f4 = 4;
+}
+
+message Message {
+	enum ChildEnum {
+		ALPHA   = 0;
+		BRAVO   = 1;
+		CHARLIE = 2;
+	}
+	message ChildMessage {
+		optional string  f1 = 1;
+		required string  f2 = 2;
+		repeated string  f3 = 3;
+	    optional Message f4 = 4;
+	}
+	optional group NamedGroup = 1 {
+		optional string  f1 = 1;
+		required string  f2 = 2;
+		repeated string  f3 = 3;
+	    optional Message f4 = 4;
+	}
+
+	// Optional fields.
+	optional bool     optional_bool     = 100;
+	optional int32    optional_int32    = 101;
+	optional sint32   optional_sint32   = 102;
+	optional uint32   optional_uint32   = 103;
+	optional int64    optional_int64    = 104;
+	optional sint64   optional_sint64   = 105;
+	optional uint64   optional_uint64   = 106;
+	optional fixed32  optional_fixed32  = 107;
+	optional sfixed32 optional_sfixed32 = 108;
+	optional float    optional_float    = 109;
+	optional fixed64  optional_fixed64  = 110;
+	optional sfixed64 optional_sfixed64 = 111;
+	optional double   optional_double   = 112;
+	optional string   optional_string   = 113;
+	optional bytes    optional_bytes    = 114;
+
+	optional ChildEnum      optional_child_enum      = 115;
+	optional ChildMessage   optional_child_message   = 116;
+	optional NamedGroup     optional_named_group     = 117;
+	optional SiblingEnum    optional_sibling_enum    = 118;
+	optional SiblingMessage optional_sibling_message = 119;
+	optional group OptionalGroup = 120 {
+		optional string f1 = 1;
+		required string f2 = 2;
+		repeated string f3 = 3;
+	}
+
+	// Optional default fields.
+	optional bool      defaulted_bool     = 200 [default = true];
+	optional int32     defaulted_int32    = 201 [default = -12345];
+	optional sint32    defaulted_sint32   = 202 [default = -3200];
+	optional uint32    defaulted_uint32   = 203 [default = 3200];
+	optional int64     defaulted_int64    = 204 [default = -123456789];
+	optional sint64    defaulted_sint64   = 205 [default = -6400];
+	optional uint64    defaulted_uint64   = 206 [default = 6400];
+	optional fixed32   defaulted_fixed32  = 207 [default = 320000];
+	optional sfixed32  defaulted_sfixed32 = 208 [default = -320000];
+	optional float     defaulted_float    = 209 [default = 3.14159];
+	optional fixed64   defaulted_fixed64  = 210 [default = 640000];
+	optional sfixed64  defaulted_sfixed64 = 211 [default = -640000];
+	optional double    defaulted_double   = 212 [default = 3.14159265359];
+	optional string    defaulted_string   = 213 [default = "hello, \"world!\"\n"];
+	optional bytes     defaulted_bytes    = 214 [default = "dead\xde\xad\xbe\xefbeef"];
+
+	optional ChildEnum   defaulted_child_enum   = 215 [default = ALPHA];
+	optional SiblingEnum defaulted_sibling_enum = 216 [default = ALPHA];
+
+	// Required fields.
+	required bool     required_bool     = 300;
+	required int32    required_int32    = 301;
+	required sint32   required_sint32   = 302;
+	required uint32   required_uint32   = 303;
+	required int64    required_int64    = 304;
+	required sint64   required_sint64   = 305;
+	required uint64   required_uint64   = 306;
+	required fixed32  required_fixed32  = 307;
+	required sfixed32 required_sfixed32 = 308;
+	required float    required_float    = 309;
+	required fixed64  required_fixed64  = 310;
+	required sfixed64 required_sfixed64 = 311;
+	required double   required_double   = 312;
+	required string   required_string   = 313;
+	required bytes    required_bytes    = 314;
+
+	required ChildEnum      required_child_enum      = 315;
+	required ChildMessage   required_child_message   = 316;
+	required NamedGroup     required_named_group     = 317;
+	required SiblingEnum    required_sibling_enum    = 318;
+	required SiblingMessage required_sibling_message = 319;
+	required group RequiredGroup = 320 {
+		optional string f1 = 1;
+		required string f2 = 2;
+		repeated string f3 = 3;
+	}
+	// Required default fields.
+	required bool      required_defaulted_bool     = 400 [default = true];
+	required int32     required_defaulted_int32    = 401 [default = -12345];
+	required sint32    required_defaulted_sint32   = 402 [default = -3200];
+	required uint32    required_defaulted_uint32   = 403 [default = 3200];
+	required int64     required_defaulted_int64    = 404 [default = -123456789];
+	required sint64    required_defaulted_sint64   = 405 [default = -6400];
+	required uint64    required_defaulted_uint64   = 406 [default = 6400];
+	required fixed32   required_defaulted_fixed32  = 407 [default = 320000];
+	required sfixed32  required_defaulted_sfixed32 = 408 [default = -320000];
+	required float     required_defaulted_float    = 409 [default = 3.14159];
+	required fixed64   required_defaulted_fixed64  = 410 [default = 640000];
+	required sfixed64  required_defaulted_sfixed64 = 411 [default = -640000];
+	required double    required_defaulted_double   = 412 [default = 3.14159265359];
+	required string    required_defaulted_string   = 413 [default = "hello, \"world!\"\n"];
+	required bytes     required_defaulted_bytes    = 414 [default = "dead\xde\xad\xbe\xefbeef"];
+
+	required ChildEnum   required_defaulted_child_enum   = 415 [default = ALPHA];
+	required SiblingEnum required_defaulted_sibling_enum = 416 [default = ALPHA];
+
+	// Repeated fields.
+	repeated bool     repeated_bool     = 500;
+	repeated int32    repeated_int32    = 501;
+	repeated sint32   repeated_sint32   = 502;
+	repeated uint32   repeated_uint32   = 503;
+	repeated int64    repeated_int64    = 504;
+	repeated sint64   repeated_sint64   = 505;
+	repeated uint64   repeated_uint64   = 506;
+	repeated fixed32  repeated_fixed32  = 507;
+	repeated sfixed32 repeated_sfixed32 = 508;
+	repeated float    repeated_float    = 509;
+	repeated fixed64  repeated_fixed64  = 510;
+	repeated sfixed64 repeated_sfixed64 = 511;
+	repeated double   repeated_double   = 512;
+	repeated string   repeated_string   = 513;
+	repeated bytes    repeated_bytes    = 514;
+
+	repeated ChildEnum      repeated_child_enum      = 515;
+	repeated ChildMessage   repeated_child_message   = 516;
+	repeated NamedGroup     repeated_named_group     = 517;
+	repeated SiblingEnum    repeated_sibling_enum    = 518;
+	repeated SiblingMessage repeated_sibling_message = 519;
+	repeated group RepeatedGroup = 520 {
+		optional string f1 = 1;
+		required string f2 = 2;
+		repeated string f3 = 3;
+	}
+
+	// Map fields.
+	map<bool, bool>     map_bool_bool     = 600;
+	map<bool, int32>    map_bool_int32    = 601;
+	map<bool, sint32>   map_bool_sint32   = 602;
+	map<bool, uint32>   map_bool_uint32   = 603;
+	map<bool, int64>    map_bool_int64    = 604;
+	map<bool, sint64>   map_bool_sint64   = 605;
+	map<bool, uint64>   map_bool_uint64   = 606;
+	map<bool, fixed32>  map_bool_fixed32  = 607;
+	map<bool, sfixed32> map_bool_sfixed32 = 608;
+	map<bool, float>    map_bool_float    = 609;
+	map<bool, fixed64>  map_bool_fixed64  = 610;
+	map<bool, sfixed64> map_bool_sfixed64 = 611;
+	map<bool, double>   map_bool_double   = 612;
+	map<bool, string>   map_bool_string   = 613;
+	map<bool, bytes>    map_bool_bytes    = 614;
+
+	map<bool, ChildEnum>      map_bool_child_enum      = 615;
+	map<bool, ChildMessage>   map_bool_child_message   = 616;
+	map<bool, NamedGroup>     map_bool_named_group     = 617;
+	map<bool, SiblingEnum>    map_bool_sibling_enum    = 618;
+	map<bool, SiblingMessage> map_bool_sibling_message = 619;
+
+	map<int32, bool>   map_int32_bool   = 620;
+	map<sint32, bool>  map_sint32_bool  = 621;
+	map<uint32, bool>  map_uint32_bool  = 622;
+	map<int64, bool>   map_int64_bool   = 623;
+	map<sint64, bool>  map_sint64_bool  = 624;
+	map<uint64, bool>  map_uint64_bool  = 625;
+	map<fixed32, bool> map_fixed32_bool = 626;
+	map<string, bool>  map_string_bool  = 627;
+
+	// Oneof fields.
+	oneof oneof_union {
+		bool     oneof_bool     = 700;
+		int32    oneof_int32    = 701;
+		sint32   oneof_sint32   = 702;
+		uint32   oneof_uint32   = 703;
+		int64    oneof_int64    = 704;
+		sint64   oneof_sint64   = 705;
+		uint64   oneof_uint64   = 706;
+		fixed32  oneof_fixed32  = 707;
+		sfixed32 oneof_sfixed32 = 708;
+		float    oneof_float    = 709;
+		fixed64  oneof_fixed64  = 710;
+		sfixed64 oneof_sfixed64 = 711;
+		double   oneof_double   = 712;
+		string   oneof_string   = 713;
+		bytes    oneof_bytes    = 714;
+
+		ChildEnum      oneof_child_enum      = 715;
+		ChildMessage   oneof_child_message   = 716;
+		NamedGroup     oneof_named_group     = 717;
+		SiblingEnum    oneof_sibling_enum    = 718;
+		SiblingMessage oneof_sibling_message = 719;
+		group OneofGroup = 720 {
+			optional string f1 = 1;
+			required string f2 = 2;
+			repeated string f3 = 3;
+		}
+
+		string oneof_string1 = 721;
+		string oneof_string2 = 722;
+		string oneof_string3 = 723;
+	}
+
+	// Oneof default fields.
+	oneof oneof_defaulted_union {
+		bool      oneof_defaulted_bool     = 800 [default = true];
+		int32     oneof_defaulted_int32    = 801 [default = -12345];
+		sint32    oneof_defaulted_sint32   = 802 [default = -3200];
+		uint32    oneof_defaulted_uint32   = 803 [default = 3200];
+		int64     oneof_defaulted_int64    = 804 [default = -123456789];
+		sint64    oneof_defaulted_sint64   = 805 [default = -6400];
+		uint64    oneof_defaulted_uint64   = 806 [default = 6400];
+		fixed32   oneof_defaulted_fixed32  = 807 [default = 320000];
+		sfixed32  oneof_defaulted_sfixed32 = 808 [default = -320000];
+		float     oneof_defaulted_float    = 809 [default = 3.14159];
+		fixed64   oneof_defaulted_fixed64  = 810 [default = 640000];
+		sfixed64  oneof_defaulted_sfixed64 = 811 [default = -640000];
+		double    oneof_defaulted_double   = 812 [default = 3.14159265359];
+		string    oneof_defaulted_string   = 813 [default = "hello, \"world!\"\n"];
+		bytes     oneof_defaulted_bytes    = 814 [default = "dead\xde\xad\xbe\xefbeef"];
+
+		ChildEnum   oneof_defaulted_child_enum   = 815 [default = ALPHA];
+		SiblingEnum oneof_defaulted_sibling_enum = 816 [default = ALPHA];
+	}
+
+	// Extension fields.
+	extend Message {
+		// Optional fields.
+		optional bool     extension_optional_bool     = 10000;
+		optional int32    extension_optional_int32    = 10001;
+		optional sint32   extension_optional_sint32   = 10002;
+		optional uint32   extension_optional_uint32   = 10003;
+		optional int64    extension_optional_int64    = 10004;
+		optional sint64   extension_optional_sint64   = 10005;
+		optional uint64   extension_optional_uint64   = 10006;
+		optional fixed32  extension_optional_fixed32  = 10007;
+		optional sfixed32 extension_optional_sfixed32 = 10008;
+		optional float    extension_optional_float    = 10009;
+		optional fixed64  extension_optional_fixed64  = 10010;
+		optional sfixed64 extension_optional_sfixed64 = 10011;
+		optional double   extension_optional_double   = 10012;
+		optional string   extension_optional_string   = 10013;
+		optional bytes    extension_optional_bytes    = 10014;
+
+		optional ChildEnum      extension_optional_child_enum      = 10015;
+		optional ChildMessage   extension_optional_child_message   = 10016;
+		optional NamedGroup     extension_optional_named_group     = 10017;
+		optional SiblingEnum    extension_optional_sibling_enum    = 10018;
+		optional SiblingMessage extension_optional_sibling_message = 10019;
+		optional group ExtensionOptionalGroup = 10020 {
+			optional string f1 = 1;
+			required string f2 = 2;
+			repeated string f3 = 3;
+		}
+
+		// Optional default fields.
+		optional bool      extension_defaulted_bool     = 20000 [default = true];
+		optional int32     extension_defaulted_int32    = 20001 [default = -12345];
+		optional sint32    extension_defaulted_sint32   = 20002 [default = -3200];
+		optional uint32    extension_defaulted_uint32   = 20003 [default = 3200];
+		optional int64     extension_defaulted_int64    = 20004 [default = -123456789];
+		optional sint64    extension_defaulted_sint64   = 20005 [default = -6400];
+		optional uint64    extension_defaulted_uint64   = 20006 [default = 6400];
+		optional fixed32   extension_defaulted_fixed32  = 20007 [default = 320000];
+		optional sfixed32  extension_defaulted_sfixed32 = 20008 [default = -320000];
+		optional float     extension_defaulted_float    = 20009 [default = 3.14159];
+		optional fixed64   extension_defaulted_fixed64  = 20010 [default = 640000];
+		optional sfixed64  extension_defaulted_sfixed64 = 20011 [default = -640000];
+		optional double    extension_defaulted_double   = 20012 [default = 3.14159265359];
+		optional string    extension_defaulted_string   = 20013 [default = "hello, \"world!\"\n"];
+		optional bytes     extension_defaulted_bytes    = 20014 [default = "dead\xde\xad\xbe\xefbeef"];
+
+		optional ChildEnum   extension_defaulted_child_enum   = 20015 [default = ALPHA];
+		optional SiblingEnum extension_defaulted_sibling_enum = 20016 [default = ALPHA];
+
+		// Repeated fields.
+		repeated bool     extension_repeated_bool     = 30000;
+		repeated int32    extension_repeated_int32    = 30001;
+		repeated sint32   extension_repeated_sint32   = 30002;
+		repeated uint32   extension_repeated_uint32   = 30003;
+		repeated int64    extension_repeated_int64    = 30004;
+		repeated sint64   extension_repeated_sint64   = 30005;
+		repeated uint64   extension_repeated_uint64   = 30006;
+		repeated fixed32  extension_repeated_fixed32  = 30007;
+		repeated sfixed32 extension_repeated_sfixed32 = 30008;
+		repeated float    extension_repeated_float    = 30009;
+		repeated fixed64  extension_repeated_fixed64  = 30010;
+		repeated sfixed64 extension_repeated_sfixed64 = 30011;
+		repeated double   extension_repeated_double   = 30012;
+		repeated string   extension_repeated_string   = 30013;
+		repeated bytes    extension_repeated_bytes    = 30014;
+
+		repeated ChildEnum      extension_repeated_child_enum      = 30015;
+		repeated ChildMessage   extension_repeated_child_message   = 30016;
+		repeated NamedGroup     extension_repeated_named_group     = 30017;
+		repeated SiblingEnum    extension_repeated_sibling_enum    = 30018;
+		repeated SiblingMessage extension_repeated_sibling_message = 30019;
+		repeated group ExtensionRepeatedGroup = 30020 {
+			optional string f1 = 1;
+			required string f2 = 2;
+			repeated string f3 = 3;
+		}
+	}
+
+	extensions 10000 to max;
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20180125_92554152/test.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20180125_92554152/test.pb.go
new file mode 100644
index 000000000..782dd07d2
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20180125_92554152/test.pb.go
@@ -0,0 +1,3588 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: proto2_20180125_92554152/test.proto
+
+/*
+Package proto2_20180125_92554152 is a generated protocol buffer package.
+
+It is generated from these files:
+	proto2_20180125_92554152/test.proto
+
+It has these top-level messages:
+	SiblingMessage
+	Message
+*/
+package proto2_20180125_92554152
+
+import proto "google.golang.org/protobuf/internal/protolegacy"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type SiblingEnum int32
+
+const (
+	SiblingEnum_ALPHA   SiblingEnum = 0
+	SiblingEnum_BRAVO   SiblingEnum = 10
+	SiblingEnum_CHARLIE SiblingEnum = 200
+)
+
+var SiblingEnum_name = map[int32]string{
+	0:   "ALPHA",
+	10:  "BRAVO",
+	200: "CHARLIE",
+}
+var SiblingEnum_value = map[string]int32{
+	"ALPHA":   0,
+	"BRAVO":   10,
+	"CHARLIE": 200,
+}
+
+func (x SiblingEnum) Enum() *SiblingEnum {
+	p := new(SiblingEnum)
+	*p = x
+	return p
+}
+func (x SiblingEnum) String() string {
+	return proto.EnumName(SiblingEnum_name, int32(x))
+}
+func (x *SiblingEnum) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(SiblingEnum_value, data, "SiblingEnum")
+	if err != nil {
+		return err
+	}
+	*x = SiblingEnum(value)
+	return nil
+}
+func (SiblingEnum) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+type Message_ChildEnum int32
+
+const (
+	Message_ALPHA   Message_ChildEnum = 0
+	Message_BRAVO   Message_ChildEnum = 1
+	Message_CHARLIE Message_ChildEnum = 2
+)
+
+var Message_ChildEnum_name = map[int32]string{
+	0: "ALPHA",
+	1: "BRAVO",
+	2: "CHARLIE",
+}
+var Message_ChildEnum_value = map[string]int32{
+	"ALPHA":   0,
+	"BRAVO":   1,
+	"CHARLIE": 2,
+}
+
+func (x Message_ChildEnum) Enum() *Message_ChildEnum {
+	p := new(Message_ChildEnum)
+	*p = x
+	return p
+}
+func (x Message_ChildEnum) String() string {
+	return proto.EnumName(Message_ChildEnum_name, int32(x))
+}
+func (x *Message_ChildEnum) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(Message_ChildEnum_value, data, "Message_ChildEnum")
+	if err != nil {
+		return err
+	}
+	*x = Message_ChildEnum(value)
+	return nil
+}
+func (Message_ChildEnum) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{1, 0} }
+
+type SiblingMessage 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"`
+	F4               *Message `protobuf:"bytes,4,opt,name=f4" json:"f4,omitempty"`
+	XXX_unrecognized []byte   `json:"-"`
+}
+
+func (m *SiblingMessage) Reset()                    { *m = SiblingMessage{} }
+func (m *SiblingMessage) String() string            { return proto.CompactTextString(m) }
+func (*SiblingMessage) ProtoMessage()               {}
+func (*SiblingMessage) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *SiblingMessage) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *SiblingMessage) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *SiblingMessage) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+func (m *SiblingMessage) GetF4() *Message {
+	if m != nil {
+		return m.F4
+	}
+	return nil
+}
+
+type Message struct {
+	Namedgroup *Message_NamedGroup `protobuf:"group,1,opt,name=NamedGroup,json=namedgroup" json:"namedgroup,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      *Message_ChildEnum     `protobuf:"varint,115,opt,name=optional_child_enum,json=optionalChildEnum,enum=google.golang.org.proto2_20180125.Message_ChildEnum" json:"optional_child_enum,omitempty"`
+	OptionalChildMessage   *Message_ChildMessage  `protobuf:"bytes,116,opt,name=optional_child_message,json=optionalChildMessage" json:"optional_child_message,omitempty"`
+	OptionalNamedGroup     *Message_NamedGroup    `protobuf:"bytes,117,opt,name=optional_named_group,json=optionalNamedGroup" json:"optional_named_group,omitempty"`
+	OptionalSiblingEnum    *SiblingEnum           `protobuf:"varint,118,opt,name=optional_sibling_enum,json=optionalSiblingEnum,enum=google.golang.org.proto2_20180125.SiblingEnum" json:"optional_sibling_enum,omitempty"`
+	OptionalSiblingMessage *SiblingMessage        `protobuf:"bytes,119,opt,name=optional_sibling_message,json=optionalSiblingMessage" json:"optional_sibling_message,omitempty"`
+	Optionalgroup          *Message_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   *Message_ChildEnum `protobuf:"varint,215,opt,name=defaulted_child_enum,json=defaultedChildEnum,enum=google.golang.org.proto2_20180125.Message_ChildEnum,def=0" json:"defaulted_child_enum,omitempty"`
+	DefaultedSiblingEnum *SiblingEnum       `protobuf:"varint,216,opt,name=defaulted_sibling_enum,json=defaultedSiblingEnum,enum=google.golang.org.proto2_20180125.SiblingEnum,def=0" 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      *Message_ChildEnum     `protobuf:"varint,315,req,name=required_child_enum,json=requiredChildEnum,enum=google.golang.org.proto2_20180125.Message_ChildEnum" json:"required_child_enum,omitempty"`
+	RequiredChildMessage   *Message_ChildMessage  `protobuf:"bytes,316,req,name=required_child_message,json=requiredChildMessage" json:"required_child_message,omitempty"`
+	RequiredNamedGroup     *Message_NamedGroup    `protobuf:"bytes,317,req,name=required_named_group,json=requiredNamedGroup" json:"required_named_group,omitempty"`
+	RequiredSiblingEnum    *SiblingEnum           `protobuf:"varint,318,req,name=required_sibling_enum,json=requiredSiblingEnum,enum=google.golang.org.proto2_20180125.SiblingEnum" json:"required_sibling_enum,omitempty"`
+	RequiredSiblingMessage *SiblingMessage        `protobuf:"bytes,319,req,name=required_sibling_message,json=requiredSiblingMessage" json:"required_sibling_message,omitempty"`
+	Requiredgroup          *Message_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   *Message_ChildEnum `protobuf:"varint,415,req,name=required_defaulted_child_enum,json=requiredDefaultedChildEnum,enum=google.golang.org.proto2_20180125.Message_ChildEnum,def=0" json:"required_defaulted_child_enum,omitempty"`
+	RequiredDefaultedSiblingEnum *SiblingEnum       `protobuf:"varint,416,req,name=required_defaulted_sibling_enum,json=requiredDefaultedSiblingEnum,enum=google.golang.org.proto2_20180125.SiblingEnum,def=0" 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      []Message_ChildEnum      `protobuf:"varint,515,rep,name=repeated_child_enum,json=repeatedChildEnum,enum=google.golang.org.proto2_20180125.Message_ChildEnum" json:"repeated_child_enum,omitempty"`
+	RepeatedChildMessage   []*Message_ChildMessage  `protobuf:"bytes,516,rep,name=repeated_child_message,json=repeatedChildMessage" json:"repeated_child_message,omitempty"`
+	RepeatedNamedGroup     []*Message_NamedGroup    `protobuf:"bytes,517,rep,name=repeated_named_group,json=repeatedNamedGroup" json:"repeated_named_group,omitempty"`
+	RepeatedSiblingEnum    []SiblingEnum            `protobuf:"varint,518,rep,name=repeated_sibling_enum,json=repeatedSiblingEnum,enum=google.golang.org.proto2_20180125.SiblingEnum" json:"repeated_sibling_enum,omitempty"`
+	RepeatedSiblingMessage []*SiblingMessage        `protobuf:"bytes,519,rep,name=repeated_sibling_message,json=repeatedSiblingMessage" json:"repeated_sibling_message,omitempty"`
+	Repeatedgroup          []*Message_RepeatedGroup `protobuf:"group,520,rep,name=RepeatedGroup,json=repeatedgroup" json:"repeatedgroup,omitempty"`
+	// Map fields.
+	MapBoolBool           map[bool]bool                  `protobuf:"bytes,600,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,601,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,602,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,603,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,604,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,605,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,606,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,607,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,608,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,609,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,610,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,611,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,612,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,613,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,614,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"`
+	MapBoolChildEnum      map[bool]Message_ChildEnum     `protobuf:"bytes,615,rep,name=map_bool_child_enum,json=mapBoolChildEnum" json:"map_bool_child_enum,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=google.golang.org.proto2_20180125.Message_ChildEnum"`
+	MapBoolChildMessage   map[bool]*Message_ChildMessage `protobuf:"bytes,616,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"`
+	MapBoolNamedGroup     map[bool]*Message_NamedGroup   `protobuf:"bytes,617,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"`
+	MapBoolSiblingEnum    map[bool]SiblingEnum           `protobuf:"bytes,618,rep,name=map_bool_sibling_enum,json=mapBoolSiblingEnum" json:"map_bool_sibling_enum,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=google.golang.org.proto2_20180125.SiblingEnum"`
+	MapBoolSiblingMessage map[bool]*SiblingMessage       `protobuf:"bytes,619,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"`
+	MapInt32Bool          map[int32]bool                 `protobuf:"bytes,620,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,621,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,622,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,623,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,624,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,625,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,626,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,627,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.
+	//
+	// Types that are valid to be assigned to OneofUnion:
+	//	*Message_OneofBool
+	//	*Message_OneofInt32
+	//	*Message_OneofSint32
+	//	*Message_OneofUint32
+	//	*Message_OneofInt64
+	//	*Message_OneofSint64
+	//	*Message_OneofUint64
+	//	*Message_OneofFixed32
+	//	*Message_OneofSfixed32
+	//	*Message_OneofFloat
+	//	*Message_OneofFixed64
+	//	*Message_OneofSfixed64
+	//	*Message_OneofDouble
+	//	*Message_OneofString
+	//	*Message_OneofBytes
+	//	*Message_OneofChildEnum
+	//	*Message_OneofChildMessage
+	//	*Message_OneofNamedGroup
+	//	*Message_OneofSiblingEnum
+	//	*Message_OneofSiblingMessage
+	//	*Message_Oneofgroup
+	//	*Message_OneofString1
+	//	*Message_OneofString2
+	//	*Message_OneofString3
+	OneofUnion isMessage_OneofUnion `protobuf_oneof:"oneof_union"`
+	// Oneof default fields.
+	//
+	// Types that are valid to be assigned to OneofDefaultedUnion:
+	//	*Message_OneofDefaultedBool
+	//	*Message_OneofDefaultedInt32
+	//	*Message_OneofDefaultedSint32
+	//	*Message_OneofDefaultedUint32
+	//	*Message_OneofDefaultedInt64
+	//	*Message_OneofDefaultedSint64
+	//	*Message_OneofDefaultedUint64
+	//	*Message_OneofDefaultedFixed32
+	//	*Message_OneofDefaultedSfixed32
+	//	*Message_OneofDefaultedFloat
+	//	*Message_OneofDefaultedFixed64
+	//	*Message_OneofDefaultedSfixed64
+	//	*Message_OneofDefaultedDouble
+	//	*Message_OneofDefaultedString
+	//	*Message_OneofDefaultedBytes
+	//	*Message_OneofDefaultedChildEnum
+	//	*Message_OneofDefaultedSiblingEnum
+	OneofDefaultedUnion          isMessage_OneofDefaultedUnion `protobuf_oneof:"oneof_defaulted_union"`
+	proto.XXX_InternalExtensions `json:"-"`
+	XXX_unrecognized             []byte `json:"-"`
+}
+
+func (m *Message) Reset()                    { *m = Message{} }
+func (m *Message) String() string            { return proto.CompactTextString(m) }
+func (*Message) ProtoMessage()               {}
+func (*Message) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+var extRange_Message = []proto.ExtensionRange{
+	{10000, 536870911},
+}
+
+func (*Message) ExtensionRangeArray() []proto.ExtensionRange {
+	return extRange_Message
+}
+
+const Default_Message_DefaultedBool bool = true
+const Default_Message_DefaultedInt32 int32 = -12345
+const Default_Message_DefaultedSint32 int32 = -3200
+const Default_Message_DefaultedUint32 uint32 = 3200
+const Default_Message_DefaultedInt64 int64 = -123456789
+const Default_Message_DefaultedSint64 int64 = -6400
+const Default_Message_DefaultedUint64 uint64 = 6400
+const Default_Message_DefaultedFixed32 uint32 = 320000
+const Default_Message_DefaultedSfixed32 int32 = -320000
+const Default_Message_DefaultedFloat float32 = 3.14159
+const Default_Message_DefaultedFixed64 uint64 = 640000
+const Default_Message_DefaultedSfixed64 int64 = -640000
+const Default_Message_DefaultedDouble float64 = 3.14159265359
+const Default_Message_DefaultedString string = "hello, \"world!\"\n"
+
+var Default_Message_DefaultedBytes []byte = []byte("deadޭ\xbe\xefbeef")
+
+const Default_Message_DefaultedChildEnum Message_ChildEnum = Message_ALPHA
+const Default_Message_DefaultedSiblingEnum SiblingEnum = SiblingEnum_ALPHA
+const Default_Message_RequiredDefaultedBool bool = true
+const Default_Message_RequiredDefaultedInt32 int32 = -12345
+const Default_Message_RequiredDefaultedSint32 int32 = -3200
+const Default_Message_RequiredDefaultedUint32 uint32 = 3200
+const Default_Message_RequiredDefaultedInt64 int64 = -123456789
+const Default_Message_RequiredDefaultedSint64 int64 = -6400
+const Default_Message_RequiredDefaultedUint64 uint64 = 6400
+const Default_Message_RequiredDefaultedFixed32 uint32 = 320000
+const Default_Message_RequiredDefaultedSfixed32 int32 = -320000
+const Default_Message_RequiredDefaultedFloat float32 = 3.14159
+const Default_Message_RequiredDefaultedFixed64 uint64 = 640000
+const Default_Message_RequiredDefaultedSfixed64 int64 = -640000
+const Default_Message_RequiredDefaultedDouble float64 = 3.14159265359
+const Default_Message_RequiredDefaultedString string = "hello, \"world!\"\n"
+
+var Default_Message_RequiredDefaultedBytes []byte = []byte("deadޭ\xbe\xefbeef")
+
+const Default_Message_RequiredDefaultedChildEnum Message_ChildEnum = Message_ALPHA
+const Default_Message_RequiredDefaultedSiblingEnum SiblingEnum = SiblingEnum_ALPHA
+const Default_Message_OneofDefaultedBool bool = true
+const Default_Message_OneofDefaultedInt32 int32 = -12345
+const Default_Message_OneofDefaultedSint32 int32 = -3200
+const Default_Message_OneofDefaultedUint32 uint32 = 3200
+const Default_Message_OneofDefaultedInt64 int64 = -123456789
+const Default_Message_OneofDefaultedSint64 int64 = -6400
+const Default_Message_OneofDefaultedUint64 uint64 = 6400
+const Default_Message_OneofDefaultedFixed32 uint32 = 320000
+const Default_Message_OneofDefaultedSfixed32 int32 = -320000
+const Default_Message_OneofDefaultedFloat float32 = 3.14159
+const Default_Message_OneofDefaultedFixed64 uint64 = 640000
+const Default_Message_OneofDefaultedSfixed64 int64 = -640000
+const Default_Message_OneofDefaultedDouble float64 = 3.14159265359
+const Default_Message_OneofDefaultedString string = "hello, \"world!\"\n"
+
+var Default_Message_OneofDefaultedBytes []byte = []byte("deadޭ\xbe\xefbeef")
+
+const Default_Message_OneofDefaultedChildEnum Message_ChildEnum = Message_ALPHA
+const Default_Message_OneofDefaultedSiblingEnum SiblingEnum = SiblingEnum_ALPHA
+
+type isMessage_OneofUnion interface{ isMessage_OneofUnion() }
+type isMessage_OneofDefaultedUnion interface{ isMessage_OneofDefaultedUnion() }
+
+type Message_OneofBool struct {
+	OneofBool bool `protobuf:"varint,700,opt,name=oneof_bool,json=oneofBool,oneof"`
+}
+type Message_OneofInt32 struct {
+	OneofInt32 int32 `protobuf:"varint,701,opt,name=oneof_int32,json=oneofInt32,oneof"`
+}
+type Message_OneofSint32 struct {
+	OneofSint32 int32 `protobuf:"zigzag32,702,opt,name=oneof_sint32,json=oneofSint32,oneof"`
+}
+type Message_OneofUint32 struct {
+	OneofUint32 uint32 `protobuf:"varint,703,opt,name=oneof_uint32,json=oneofUint32,oneof"`
+}
+type Message_OneofInt64 struct {
+	OneofInt64 int64 `protobuf:"varint,704,opt,name=oneof_int64,json=oneofInt64,oneof"`
+}
+type Message_OneofSint64 struct {
+	OneofSint64 int64 `protobuf:"zigzag64,705,opt,name=oneof_sint64,json=oneofSint64,oneof"`
+}
+type Message_OneofUint64 struct {
+	OneofUint64 uint64 `protobuf:"varint,706,opt,name=oneof_uint64,json=oneofUint64,oneof"`
+}
+type Message_OneofFixed32 struct {
+	OneofFixed32 uint32 `protobuf:"fixed32,707,opt,name=oneof_fixed32,json=oneofFixed32,oneof"`
+}
+type Message_OneofSfixed32 struct {
+	OneofSfixed32 int32 `protobuf:"fixed32,708,opt,name=oneof_sfixed32,json=oneofSfixed32,oneof"`
+}
+type Message_OneofFloat struct {
+	OneofFloat float32 `protobuf:"fixed32,709,opt,name=oneof_float,json=oneofFloat,oneof"`
+}
+type Message_OneofFixed64 struct {
+	OneofFixed64 uint64 `protobuf:"fixed64,710,opt,name=oneof_fixed64,json=oneofFixed64,oneof"`
+}
+type Message_OneofSfixed64 struct {
+	OneofSfixed64 int64 `protobuf:"fixed64,711,opt,name=oneof_sfixed64,json=oneofSfixed64,oneof"`
+}
+type Message_OneofDouble struct {
+	OneofDouble float64 `protobuf:"fixed64,712,opt,name=oneof_double,json=oneofDouble,oneof"`
+}
+type Message_OneofString struct {
+	OneofString string `protobuf:"bytes,713,opt,name=oneof_string,json=oneofString,oneof"`
+}
+type Message_OneofBytes struct {
+	OneofBytes []byte `protobuf:"bytes,714,opt,name=oneof_bytes,json=oneofBytes,oneof"`
+}
+type Message_OneofChildEnum struct {
+	OneofChildEnum Message_ChildEnum `protobuf:"varint,715,opt,name=oneof_child_enum,json=oneofChildEnum,enum=google.golang.org.proto2_20180125.Message_ChildEnum,oneof"`
+}
+type Message_OneofChildMessage struct {
+	OneofChildMessage *Message_ChildMessage `protobuf:"bytes,716,opt,name=oneof_child_message,json=oneofChildMessage,oneof"`
+}
+type Message_OneofNamedGroup struct {
+	OneofNamedGroup *Message_NamedGroup `protobuf:"bytes,717,opt,name=oneof_named_group,json=oneofNamedGroup,oneof"`
+}
+type Message_OneofSiblingEnum struct {
+	OneofSiblingEnum SiblingEnum `protobuf:"varint,718,opt,name=oneof_sibling_enum,json=oneofSiblingEnum,enum=google.golang.org.proto2_20180125.SiblingEnum,oneof"`
+}
+type Message_OneofSiblingMessage struct {
+	OneofSiblingMessage *SiblingMessage `protobuf:"bytes,719,opt,name=oneof_sibling_message,json=oneofSiblingMessage,oneof"`
+}
+type Message_Oneofgroup struct {
+	Oneofgroup *Message_OneofGroup `protobuf:"group,720,opt,name=OneofGroup,json=oneofgroup,oneof"`
+}
+type Message_OneofString1 struct {
+	OneofString1 string `protobuf:"bytes,721,opt,name=oneof_string1,json=oneofString1,oneof"`
+}
+type Message_OneofString2 struct {
+	OneofString2 string `protobuf:"bytes,722,opt,name=oneof_string2,json=oneofString2,oneof"`
+}
+type Message_OneofString3 struct {
+	OneofString3 string `protobuf:"bytes,723,opt,name=oneof_string3,json=oneofString3,oneof"`
+}
+type Message_OneofDefaultedBool struct {
+	OneofDefaultedBool bool `protobuf:"varint,800,opt,name=oneof_defaulted_bool,json=oneofDefaultedBool,oneof,def=1"`
+}
+type Message_OneofDefaultedInt32 struct {
+	OneofDefaultedInt32 int32 `protobuf:"varint,801,opt,name=oneof_defaulted_int32,json=oneofDefaultedInt32,oneof,def=-12345"`
+}
+type Message_OneofDefaultedSint32 struct {
+	OneofDefaultedSint32 int32 `protobuf:"zigzag32,802,opt,name=oneof_defaulted_sint32,json=oneofDefaultedSint32,oneof,def=-3200"`
+}
+type Message_OneofDefaultedUint32 struct {
+	OneofDefaultedUint32 uint32 `protobuf:"varint,803,opt,name=oneof_defaulted_uint32,json=oneofDefaultedUint32,oneof,def=3200"`
+}
+type Message_OneofDefaultedInt64 struct {
+	OneofDefaultedInt64 int64 `protobuf:"varint,804,opt,name=oneof_defaulted_int64,json=oneofDefaultedInt64,oneof,def=-123456789"`
+}
+type Message_OneofDefaultedSint64 struct {
+	OneofDefaultedSint64 int64 `protobuf:"zigzag64,805,opt,name=oneof_defaulted_sint64,json=oneofDefaultedSint64,oneof,def=-6400"`
+}
+type Message_OneofDefaultedUint64 struct {
+	OneofDefaultedUint64 uint64 `protobuf:"varint,806,opt,name=oneof_defaulted_uint64,json=oneofDefaultedUint64,oneof,def=6400"`
+}
+type Message_OneofDefaultedFixed32 struct {
+	OneofDefaultedFixed32 uint32 `protobuf:"fixed32,807,opt,name=oneof_defaulted_fixed32,json=oneofDefaultedFixed32,oneof,def=320000"`
+}
+type Message_OneofDefaultedSfixed32 struct {
+	OneofDefaultedSfixed32 int32 `protobuf:"fixed32,808,opt,name=oneof_defaulted_sfixed32,json=oneofDefaultedSfixed32,oneof,def=-320000"`
+}
+type Message_OneofDefaultedFloat struct {
+	OneofDefaultedFloat float32 `protobuf:"fixed32,809,opt,name=oneof_defaulted_float,json=oneofDefaultedFloat,oneof,def=3.14159"`
+}
+type Message_OneofDefaultedFixed64 struct {
+	OneofDefaultedFixed64 uint64 `protobuf:"fixed64,810,opt,name=oneof_defaulted_fixed64,json=oneofDefaultedFixed64,oneof,def=640000"`
+}
+type Message_OneofDefaultedSfixed64 struct {
+	OneofDefaultedSfixed64 int64 `protobuf:"fixed64,811,opt,name=oneof_defaulted_sfixed64,json=oneofDefaultedSfixed64,oneof,def=-640000"`
+}
+type Message_OneofDefaultedDouble struct {
+	OneofDefaultedDouble float64 `protobuf:"fixed64,812,opt,name=oneof_defaulted_double,json=oneofDefaultedDouble,oneof,def=3.14159265359"`
+}
+type Message_OneofDefaultedString struct {
+	OneofDefaultedString string `protobuf:"bytes,813,opt,name=oneof_defaulted_string,json=oneofDefaultedString,oneof,def=hello, \"world!\"\n"`
+}
+type Message_OneofDefaultedBytes struct {
+	OneofDefaultedBytes []byte `protobuf:"bytes,814,opt,name=oneof_defaulted_bytes,json=oneofDefaultedBytes,oneof,def=dead\\336\\255\\276\\357beef"`
+}
+type Message_OneofDefaultedChildEnum struct {
+	OneofDefaultedChildEnum Message_ChildEnum `protobuf:"varint,815,opt,name=oneof_defaulted_child_enum,json=oneofDefaultedChildEnum,enum=google.golang.org.proto2_20180125.Message_ChildEnum,oneof,def=0"`
+}
+type Message_OneofDefaultedSiblingEnum struct {
+	OneofDefaultedSiblingEnum SiblingEnum `protobuf:"varint,816,opt,name=oneof_defaulted_sibling_enum,json=oneofDefaultedSiblingEnum,enum=google.golang.org.proto2_20180125.SiblingEnum,oneof,def=0"`
+}
+
+func (*Message_OneofBool) isMessage_OneofUnion()                          {}
+func (*Message_OneofInt32) isMessage_OneofUnion()                         {}
+func (*Message_OneofSint32) isMessage_OneofUnion()                        {}
+func (*Message_OneofUint32) isMessage_OneofUnion()                        {}
+func (*Message_OneofInt64) isMessage_OneofUnion()                         {}
+func (*Message_OneofSint64) isMessage_OneofUnion()                        {}
+func (*Message_OneofUint64) isMessage_OneofUnion()                        {}
+func (*Message_OneofFixed32) isMessage_OneofUnion()                       {}
+func (*Message_OneofSfixed32) isMessage_OneofUnion()                      {}
+func (*Message_OneofFloat) isMessage_OneofUnion()                         {}
+func (*Message_OneofFixed64) isMessage_OneofUnion()                       {}
+func (*Message_OneofSfixed64) isMessage_OneofUnion()                      {}
+func (*Message_OneofDouble) isMessage_OneofUnion()                        {}
+func (*Message_OneofString) isMessage_OneofUnion()                        {}
+func (*Message_OneofBytes) isMessage_OneofUnion()                         {}
+func (*Message_OneofChildEnum) isMessage_OneofUnion()                     {}
+func (*Message_OneofChildMessage) isMessage_OneofUnion()                  {}
+func (*Message_OneofNamedGroup) isMessage_OneofUnion()                    {}
+func (*Message_OneofSiblingEnum) isMessage_OneofUnion()                   {}
+func (*Message_OneofSiblingMessage) isMessage_OneofUnion()                {}
+func (*Message_Oneofgroup) isMessage_OneofUnion()                         {}
+func (*Message_OneofString1) isMessage_OneofUnion()                       {}
+func (*Message_OneofString2) isMessage_OneofUnion()                       {}
+func (*Message_OneofString3) isMessage_OneofUnion()                       {}
+func (*Message_OneofDefaultedBool) isMessage_OneofDefaultedUnion()        {}
+func (*Message_OneofDefaultedInt32) isMessage_OneofDefaultedUnion()       {}
+func (*Message_OneofDefaultedSint32) isMessage_OneofDefaultedUnion()      {}
+func (*Message_OneofDefaultedUint32) isMessage_OneofDefaultedUnion()      {}
+func (*Message_OneofDefaultedInt64) isMessage_OneofDefaultedUnion()       {}
+func (*Message_OneofDefaultedSint64) isMessage_OneofDefaultedUnion()      {}
+func (*Message_OneofDefaultedUint64) isMessage_OneofDefaultedUnion()      {}
+func (*Message_OneofDefaultedFixed32) isMessage_OneofDefaultedUnion()     {}
+func (*Message_OneofDefaultedSfixed32) isMessage_OneofDefaultedUnion()    {}
+func (*Message_OneofDefaultedFloat) isMessage_OneofDefaultedUnion()       {}
+func (*Message_OneofDefaultedFixed64) isMessage_OneofDefaultedUnion()     {}
+func (*Message_OneofDefaultedSfixed64) isMessage_OneofDefaultedUnion()    {}
+func (*Message_OneofDefaultedDouble) isMessage_OneofDefaultedUnion()      {}
+func (*Message_OneofDefaultedString) isMessage_OneofDefaultedUnion()      {}
+func (*Message_OneofDefaultedBytes) isMessage_OneofDefaultedUnion()       {}
+func (*Message_OneofDefaultedChildEnum) isMessage_OneofDefaultedUnion()   {}
+func (*Message_OneofDefaultedSiblingEnum) isMessage_OneofDefaultedUnion() {}
+
+func (m *Message) GetOneofUnion() isMessage_OneofUnion {
+	if m != nil {
+		return m.OneofUnion
+	}
+	return nil
+}
+func (m *Message) GetOneofDefaultedUnion() isMessage_OneofDefaultedUnion {
+	if m != nil {
+		return m.OneofDefaultedUnion
+	}
+	return nil
+}
+
+func (m *Message) GetNamedgroup() *Message_NamedGroup {
+	if m != nil {
+		return m.Namedgroup
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalBool() bool {
+	if m != nil && m.OptionalBool != nil {
+		return *m.OptionalBool
+	}
+	return false
+}
+
+func (m *Message) GetOptionalInt32() int32 {
+	if m != nil && m.OptionalInt32 != nil {
+		return *m.OptionalInt32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSint32() int32 {
+	if m != nil && m.OptionalSint32 != nil {
+		return *m.OptionalSint32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalUint32() uint32 {
+	if m != nil && m.OptionalUint32 != nil {
+		return *m.OptionalUint32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalInt64() int64 {
+	if m != nil && m.OptionalInt64 != nil {
+		return *m.OptionalInt64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSint64() int64 {
+	if m != nil && m.OptionalSint64 != nil {
+		return *m.OptionalSint64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalUint64() uint64 {
+	if m != nil && m.OptionalUint64 != nil {
+		return *m.OptionalUint64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalFixed32() uint32 {
+	if m != nil && m.OptionalFixed32 != nil {
+		return *m.OptionalFixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSfixed32() int32 {
+	if m != nil && m.OptionalSfixed32 != nil {
+		return *m.OptionalSfixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalFloat() float32 {
+	if m != nil && m.OptionalFloat != nil {
+		return *m.OptionalFloat
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalFixed64() uint64 {
+	if m != nil && m.OptionalFixed64 != nil {
+		return *m.OptionalFixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSfixed64() int64 {
+	if m != nil && m.OptionalSfixed64 != nil {
+		return *m.OptionalSfixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalDouble() float64 {
+	if m != nil && m.OptionalDouble != nil {
+		return *m.OptionalDouble
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalString() string {
+	if m != nil && m.OptionalString != nil {
+		return *m.OptionalString
+	}
+	return ""
+}
+
+func (m *Message) GetOptionalBytes() []byte {
+	if m != nil {
+		return m.OptionalBytes
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalChildEnum() Message_ChildEnum {
+	if m != nil && m.OptionalChildEnum != nil {
+		return *m.OptionalChildEnum
+	}
+	return Message_ALPHA
+}
+
+func (m *Message) GetOptionalChildMessage() *Message_ChildMessage {
+	if m != nil {
+		return m.OptionalChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalNamedGroup() *Message_NamedGroup {
+	if m != nil {
+		return m.OptionalNamedGroup
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalSiblingEnum() SiblingEnum {
+	if m != nil && m.OptionalSiblingEnum != nil {
+		return *m.OptionalSiblingEnum
+	}
+	return SiblingEnum_ALPHA
+}
+
+func (m *Message) GetOptionalSiblingMessage() *SiblingMessage {
+	if m != nil {
+		return m.OptionalSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalgroup() *Message_OptionalGroup {
+	if m != nil {
+		return m.Optionalgroup
+	}
+	return nil
+}
+
+func (m *Message) GetDefaultedBool() bool {
+	if m != nil && m.DefaultedBool != nil {
+		return *m.DefaultedBool
+	}
+	return Default_Message_DefaultedBool
+}
+
+func (m *Message) GetDefaultedInt32() int32 {
+	if m != nil && m.DefaultedInt32 != nil {
+		return *m.DefaultedInt32
+	}
+	return Default_Message_DefaultedInt32
+}
+
+func (m *Message) GetDefaultedSint32() int32 {
+	if m != nil && m.DefaultedSint32 != nil {
+		return *m.DefaultedSint32
+	}
+	return Default_Message_DefaultedSint32
+}
+
+func (m *Message) GetDefaultedUint32() uint32 {
+	if m != nil && m.DefaultedUint32 != nil {
+		return *m.DefaultedUint32
+	}
+	return Default_Message_DefaultedUint32
+}
+
+func (m *Message) GetDefaultedInt64() int64 {
+	if m != nil && m.DefaultedInt64 != nil {
+		return *m.DefaultedInt64
+	}
+	return Default_Message_DefaultedInt64
+}
+
+func (m *Message) GetDefaultedSint64() int64 {
+	if m != nil && m.DefaultedSint64 != nil {
+		return *m.DefaultedSint64
+	}
+	return Default_Message_DefaultedSint64
+}
+
+func (m *Message) GetDefaultedUint64() uint64 {
+	if m != nil && m.DefaultedUint64 != nil {
+		return *m.DefaultedUint64
+	}
+	return Default_Message_DefaultedUint64
+}
+
+func (m *Message) GetDefaultedFixed32() uint32 {
+	if m != nil && m.DefaultedFixed32 != nil {
+		return *m.DefaultedFixed32
+	}
+	return Default_Message_DefaultedFixed32
+}
+
+func (m *Message) GetDefaultedSfixed32() int32 {
+	if m != nil && m.DefaultedSfixed32 != nil {
+		return *m.DefaultedSfixed32
+	}
+	return Default_Message_DefaultedSfixed32
+}
+
+func (m *Message) GetDefaultedFloat() float32 {
+	if m != nil && m.DefaultedFloat != nil {
+		return *m.DefaultedFloat
+	}
+	return Default_Message_DefaultedFloat
+}
+
+func (m *Message) GetDefaultedFixed64() uint64 {
+	if m != nil && m.DefaultedFixed64 != nil {
+		return *m.DefaultedFixed64
+	}
+	return Default_Message_DefaultedFixed64
+}
+
+func (m *Message) GetDefaultedSfixed64() int64 {
+	if m != nil && m.DefaultedSfixed64 != nil {
+		return *m.DefaultedSfixed64
+	}
+	return Default_Message_DefaultedSfixed64
+}
+
+func (m *Message) GetDefaultedDouble() float64 {
+	if m != nil && m.DefaultedDouble != nil {
+		return *m.DefaultedDouble
+	}
+	return Default_Message_DefaultedDouble
+}
+
+func (m *Message) GetDefaultedString() string {
+	if m != nil && m.DefaultedString != nil {
+		return *m.DefaultedString
+	}
+	return Default_Message_DefaultedString
+}
+
+func (m *Message) GetDefaultedBytes() []byte {
+	if m != nil && m.DefaultedBytes != nil {
+		return m.DefaultedBytes
+	}
+	return append([]byte(nil), Default_Message_DefaultedBytes...)
+}
+
+func (m *Message) GetDefaultedChildEnum() Message_ChildEnum {
+	if m != nil && m.DefaultedChildEnum != nil {
+		return *m.DefaultedChildEnum
+	}
+	return Default_Message_DefaultedChildEnum
+}
+
+func (m *Message) GetDefaultedSiblingEnum() SiblingEnum {
+	if m != nil && m.DefaultedSiblingEnum != nil {
+		return *m.DefaultedSiblingEnum
+	}
+	return Default_Message_DefaultedSiblingEnum
+}
+
+func (m *Message) GetRequiredBool() bool {
+	if m != nil && m.RequiredBool != nil {
+		return *m.RequiredBool
+	}
+	return false
+}
+
+func (m *Message) GetRequiredInt32() int32 {
+	if m != nil && m.RequiredInt32 != nil {
+		return *m.RequiredInt32
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredSint32() int32 {
+	if m != nil && m.RequiredSint32 != nil {
+		return *m.RequiredSint32
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredUint32() uint32 {
+	if m != nil && m.RequiredUint32 != nil {
+		return *m.RequiredUint32
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredInt64() int64 {
+	if m != nil && m.RequiredInt64 != nil {
+		return *m.RequiredInt64
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredSint64() int64 {
+	if m != nil && m.RequiredSint64 != nil {
+		return *m.RequiredSint64
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredUint64() uint64 {
+	if m != nil && m.RequiredUint64 != nil {
+		return *m.RequiredUint64
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredFixed32() uint32 {
+	if m != nil && m.RequiredFixed32 != nil {
+		return *m.RequiredFixed32
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredSfixed32() int32 {
+	if m != nil && m.RequiredSfixed32 != nil {
+		return *m.RequiredSfixed32
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredFloat() float32 {
+	if m != nil && m.RequiredFloat != nil {
+		return *m.RequiredFloat
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredFixed64() uint64 {
+	if m != nil && m.RequiredFixed64 != nil {
+		return *m.RequiredFixed64
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredSfixed64() int64 {
+	if m != nil && m.RequiredSfixed64 != nil {
+		return *m.RequiredSfixed64
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredDouble() float64 {
+	if m != nil && m.RequiredDouble != nil {
+		return *m.RequiredDouble
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredString() string {
+	if m != nil && m.RequiredString != nil {
+		return *m.RequiredString
+	}
+	return ""
+}
+
+func (m *Message) GetRequiredBytes() []byte {
+	if m != nil {
+		return m.RequiredBytes
+	}
+	return nil
+}
+
+func (m *Message) GetRequiredChildEnum() Message_ChildEnum {
+	if m != nil && m.RequiredChildEnum != nil {
+		return *m.RequiredChildEnum
+	}
+	return Message_ALPHA
+}
+
+func (m *Message) GetRequiredChildMessage() *Message_ChildMessage {
+	if m != nil {
+		return m.RequiredChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRequiredNamedGroup() *Message_NamedGroup {
+	if m != nil {
+		return m.RequiredNamedGroup
+	}
+	return nil
+}
+
+func (m *Message) GetRequiredSiblingEnum() SiblingEnum {
+	if m != nil && m.RequiredSiblingEnum != nil {
+		return *m.RequiredSiblingEnum
+	}
+	return SiblingEnum_ALPHA
+}
+
+func (m *Message) GetRequiredSiblingMessage() *SiblingMessage {
+	if m != nil {
+		return m.RequiredSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRequiredgroup() *Message_RequiredGroup {
+	if m != nil {
+		return m.Requiredgroup
+	}
+	return nil
+}
+
+func (m *Message) GetRequiredDefaultedBool() bool {
+	if m != nil && m.RequiredDefaultedBool != nil {
+		return *m.RequiredDefaultedBool
+	}
+	return Default_Message_RequiredDefaultedBool
+}
+
+func (m *Message) GetRequiredDefaultedInt32() int32 {
+	if m != nil && m.RequiredDefaultedInt32 != nil {
+		return *m.RequiredDefaultedInt32
+	}
+	return Default_Message_RequiredDefaultedInt32
+}
+
+func (m *Message) GetRequiredDefaultedSint32() int32 {
+	if m != nil && m.RequiredDefaultedSint32 != nil {
+		return *m.RequiredDefaultedSint32
+	}
+	return Default_Message_RequiredDefaultedSint32
+}
+
+func (m *Message) GetRequiredDefaultedUint32() uint32 {
+	if m != nil && m.RequiredDefaultedUint32 != nil {
+		return *m.RequiredDefaultedUint32
+	}
+	return Default_Message_RequiredDefaultedUint32
+}
+
+func (m *Message) GetRequiredDefaultedInt64() int64 {
+	if m != nil && m.RequiredDefaultedInt64 != nil {
+		return *m.RequiredDefaultedInt64
+	}
+	return Default_Message_RequiredDefaultedInt64
+}
+
+func (m *Message) GetRequiredDefaultedSint64() int64 {
+	if m != nil && m.RequiredDefaultedSint64 != nil {
+		return *m.RequiredDefaultedSint64
+	}
+	return Default_Message_RequiredDefaultedSint64
+}
+
+func (m *Message) GetRequiredDefaultedUint64() uint64 {
+	if m != nil && m.RequiredDefaultedUint64 != nil {
+		return *m.RequiredDefaultedUint64
+	}
+	return Default_Message_RequiredDefaultedUint64
+}
+
+func (m *Message) GetRequiredDefaultedFixed32() uint32 {
+	if m != nil && m.RequiredDefaultedFixed32 != nil {
+		return *m.RequiredDefaultedFixed32
+	}
+	return Default_Message_RequiredDefaultedFixed32
+}
+
+func (m *Message) GetRequiredDefaultedSfixed32() int32 {
+	if m != nil && m.RequiredDefaultedSfixed32 != nil {
+		return *m.RequiredDefaultedSfixed32
+	}
+	return Default_Message_RequiredDefaultedSfixed32
+}
+
+func (m *Message) GetRequiredDefaultedFloat() float32 {
+	if m != nil && m.RequiredDefaultedFloat != nil {
+		return *m.RequiredDefaultedFloat
+	}
+	return Default_Message_RequiredDefaultedFloat
+}
+
+func (m *Message) GetRequiredDefaultedFixed64() uint64 {
+	if m != nil && m.RequiredDefaultedFixed64 != nil {
+		return *m.RequiredDefaultedFixed64
+	}
+	return Default_Message_RequiredDefaultedFixed64
+}
+
+func (m *Message) GetRequiredDefaultedSfixed64() int64 {
+	if m != nil && m.RequiredDefaultedSfixed64 != nil {
+		return *m.RequiredDefaultedSfixed64
+	}
+	return Default_Message_RequiredDefaultedSfixed64
+}
+
+func (m *Message) GetRequiredDefaultedDouble() float64 {
+	if m != nil && m.RequiredDefaultedDouble != nil {
+		return *m.RequiredDefaultedDouble
+	}
+	return Default_Message_RequiredDefaultedDouble
+}
+
+func (m *Message) GetRequiredDefaultedString() string {
+	if m != nil && m.RequiredDefaultedString != nil {
+		return *m.RequiredDefaultedString
+	}
+	return Default_Message_RequiredDefaultedString
+}
+
+func (m *Message) GetRequiredDefaultedBytes() []byte {
+	if m != nil && m.RequiredDefaultedBytes != nil {
+		return m.RequiredDefaultedBytes
+	}
+	return append([]byte(nil), Default_Message_RequiredDefaultedBytes...)
+}
+
+func (m *Message) GetRequiredDefaultedChildEnum() Message_ChildEnum {
+	if m != nil && m.RequiredDefaultedChildEnum != nil {
+		return *m.RequiredDefaultedChildEnum
+	}
+	return Default_Message_RequiredDefaultedChildEnum
+}
+
+func (m *Message) GetRequiredDefaultedSiblingEnum() SiblingEnum {
+	if m != nil && m.RequiredDefaultedSiblingEnum != nil {
+		return *m.RequiredDefaultedSiblingEnum
+	}
+	return Default_Message_RequiredDefaultedSiblingEnum
+}
+
+func (m *Message) GetRepeatedBool() []bool {
+	if m != nil {
+		return m.RepeatedBool
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedInt32() []int32 {
+	if m != nil {
+		return m.RepeatedInt32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSint32() []int32 {
+	if m != nil {
+		return m.RepeatedSint32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedUint32() []uint32 {
+	if m != nil {
+		return m.RepeatedUint32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedInt64() []int64 {
+	if m != nil {
+		return m.RepeatedInt64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSint64() []int64 {
+	if m != nil {
+		return m.RepeatedSint64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedUint64() []uint64 {
+	if m != nil {
+		return m.RepeatedUint64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedFixed32() []uint32 {
+	if m != nil {
+		return m.RepeatedFixed32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSfixed32() []int32 {
+	if m != nil {
+		return m.RepeatedSfixed32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedFloat() []float32 {
+	if m != nil {
+		return m.RepeatedFloat
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedFixed64() []uint64 {
+	if m != nil {
+		return m.RepeatedFixed64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSfixed64() []int64 {
+	if m != nil {
+		return m.RepeatedSfixed64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedDouble() []float64 {
+	if m != nil {
+		return m.RepeatedDouble
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedString() []string {
+	if m != nil {
+		return m.RepeatedString
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedBytes() [][]byte {
+	if m != nil {
+		return m.RepeatedBytes
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedChildEnum() []Message_ChildEnum {
+	if m != nil {
+		return m.RepeatedChildEnum
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedChildMessage() []*Message_ChildMessage {
+	if m != nil {
+		return m.RepeatedChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedNamedGroup() []*Message_NamedGroup {
+	if m != nil {
+		return m.RepeatedNamedGroup
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSiblingEnum() []SiblingEnum {
+	if m != nil {
+		return m.RepeatedSiblingEnum
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSiblingMessage() []*SiblingMessage {
+	if m != nil {
+		return m.RepeatedSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedgroup() []*Message_RepeatedGroup {
+	if m != nil {
+		return m.Repeatedgroup
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolBool() map[bool]bool {
+	if m != nil {
+		return m.MapBoolBool
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolInt32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolInt32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSint32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolSint32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolUint32() map[bool]uint32 {
+	if m != nil {
+		return m.MapBoolUint32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolInt64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolInt64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSint64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolSint64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolUint64() map[bool]uint64 {
+	if m != nil {
+		return m.MapBoolUint64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFixed32() map[bool]uint32 {
+	if m != nil {
+		return m.MapBoolFixed32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSfixed32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolSfixed32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFloat() map[bool]float32 {
+	if m != nil {
+		return m.MapBoolFloat
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFixed64() map[bool]uint64 {
+	if m != nil {
+		return m.MapBoolFixed64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSfixed64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolSfixed64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolDouble() map[bool]float64 {
+	if m != nil {
+		return m.MapBoolDouble
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolString() map[bool]string {
+	if m != nil {
+		return m.MapBoolString
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolBytes() map[bool][]byte {
+	if m != nil {
+		return m.MapBoolBytes
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolChildEnum() map[bool]Message_ChildEnum {
+	if m != nil {
+		return m.MapBoolChildEnum
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolChildMessage() map[bool]*Message_ChildMessage {
+	if m != nil {
+		return m.MapBoolChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolNamedGroup() map[bool]*Message_NamedGroup {
+	if m != nil {
+		return m.MapBoolNamedGroup
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSiblingEnum() map[bool]SiblingEnum {
+	if m != nil {
+		return m.MapBoolSiblingEnum
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSiblingMessage() map[bool]*SiblingMessage {
+	if m != nil {
+		return m.MapBoolSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetMapInt32Bool() map[int32]bool {
+	if m != nil {
+		return m.MapInt32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapSint32Bool() map[int32]bool {
+	if m != nil {
+		return m.MapSint32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapUint32Bool() map[uint32]bool {
+	if m != nil {
+		return m.MapUint32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapInt64Bool() map[int64]bool {
+	if m != nil {
+		return m.MapInt64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapSint64Bool() map[int64]bool {
+	if m != nil {
+		return m.MapSint64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapUint64Bool() map[uint64]bool {
+	if m != nil {
+		return m.MapUint64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapFixed32Bool() map[uint32]bool {
+	if m != nil {
+		return m.MapFixed32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapStringBool() map[string]bool {
+	if m != nil {
+		return m.MapStringBool
+	}
+	return nil
+}
+
+func (m *Message) GetOneofBool() bool {
+	if x, ok := m.GetOneofUnion().(*Message_OneofBool); ok {
+		return x.OneofBool
+	}
+	return false
+}
+
+func (m *Message) GetOneofInt32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofInt32); ok {
+		return x.OneofInt32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSint32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSint32); ok {
+		return x.OneofSint32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofUint32() uint32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofUint32); ok {
+		return x.OneofUint32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofInt64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofInt64); ok {
+		return x.OneofInt64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSint64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSint64); ok {
+		return x.OneofSint64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofUint64() uint64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofUint64); ok {
+		return x.OneofUint64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFixed32() uint32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFixed32); ok {
+		return x.OneofFixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSfixed32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSfixed32); ok {
+		return x.OneofSfixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFloat() float32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFloat); ok {
+		return x.OneofFloat
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFixed64() uint64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFixed64); ok {
+		return x.OneofFixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSfixed64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSfixed64); ok {
+		return x.OneofSfixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofDouble() float64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofDouble); ok {
+		return x.OneofDouble
+	}
+	return 0
+}
+
+func (m *Message) GetOneofString() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString); ok {
+		return x.OneofString
+	}
+	return ""
+}
+
+func (m *Message) GetOneofBytes() []byte {
+	if x, ok := m.GetOneofUnion().(*Message_OneofBytes); ok {
+		return x.OneofBytes
+	}
+	return nil
+}
+
+func (m *Message) GetOneofChildEnum() Message_ChildEnum {
+	if x, ok := m.GetOneofUnion().(*Message_OneofChildEnum); ok {
+		return x.OneofChildEnum
+	}
+	return Message_ALPHA
+}
+
+func (m *Message) GetOneofChildMessage() *Message_ChildMessage {
+	if x, ok := m.GetOneofUnion().(*Message_OneofChildMessage); ok {
+		return x.OneofChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOneofNamedGroup() *Message_NamedGroup {
+	if x, ok := m.GetOneofUnion().(*Message_OneofNamedGroup); ok {
+		return x.OneofNamedGroup
+	}
+	return nil
+}
+
+func (m *Message) GetOneofSiblingEnum() SiblingEnum {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSiblingEnum); ok {
+		return x.OneofSiblingEnum
+	}
+	return SiblingEnum_ALPHA
+}
+
+func (m *Message) GetOneofSiblingMessage() *SiblingMessage {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSiblingMessage); ok {
+		return x.OneofSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOneofgroup() *Message_OneofGroup {
+	if x, ok := m.GetOneofUnion().(*Message_Oneofgroup); ok {
+		return x.Oneofgroup
+	}
+	return nil
+}
+
+func (m *Message) GetOneofString1() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString1); ok {
+		return x.OneofString1
+	}
+	return ""
+}
+
+func (m *Message) GetOneofString2() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString2); ok {
+		return x.OneofString2
+	}
+	return ""
+}
+
+func (m *Message) GetOneofString3() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString3); ok {
+		return x.OneofString3
+	}
+	return ""
+}
+
+func (m *Message) GetOneofDefaultedBool() bool {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedBool); ok {
+		return x.OneofDefaultedBool
+	}
+	return Default_Message_OneofDefaultedBool
+}
+
+func (m *Message) GetOneofDefaultedInt32() int32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedInt32); ok {
+		return x.OneofDefaultedInt32
+	}
+	return Default_Message_OneofDefaultedInt32
+}
+
+func (m *Message) GetOneofDefaultedSint32() int32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedSint32); ok {
+		return x.OneofDefaultedSint32
+	}
+	return Default_Message_OneofDefaultedSint32
+}
+
+func (m *Message) GetOneofDefaultedUint32() uint32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedUint32); ok {
+		return x.OneofDefaultedUint32
+	}
+	return Default_Message_OneofDefaultedUint32
+}
+
+func (m *Message) GetOneofDefaultedInt64() int64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedInt64); ok {
+		return x.OneofDefaultedInt64
+	}
+	return Default_Message_OneofDefaultedInt64
+}
+
+func (m *Message) GetOneofDefaultedSint64() int64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedSint64); ok {
+		return x.OneofDefaultedSint64
+	}
+	return Default_Message_OneofDefaultedSint64
+}
+
+func (m *Message) GetOneofDefaultedUint64() uint64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedUint64); ok {
+		return x.OneofDefaultedUint64
+	}
+	return Default_Message_OneofDefaultedUint64
+}
+
+func (m *Message) GetOneofDefaultedFixed32() uint32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedFixed32); ok {
+		return x.OneofDefaultedFixed32
+	}
+	return Default_Message_OneofDefaultedFixed32
+}
+
+func (m *Message) GetOneofDefaultedSfixed32() int32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedSfixed32); ok {
+		return x.OneofDefaultedSfixed32
+	}
+	return Default_Message_OneofDefaultedSfixed32
+}
+
+func (m *Message) GetOneofDefaultedFloat() float32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedFloat); ok {
+		return x.OneofDefaultedFloat
+	}
+	return Default_Message_OneofDefaultedFloat
+}
+
+func (m *Message) GetOneofDefaultedFixed64() uint64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedFixed64); ok {
+		return x.OneofDefaultedFixed64
+	}
+	return Default_Message_OneofDefaultedFixed64
+}
+
+func (m *Message) GetOneofDefaultedSfixed64() int64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedSfixed64); ok {
+		return x.OneofDefaultedSfixed64
+	}
+	return Default_Message_OneofDefaultedSfixed64
+}
+
+func (m *Message) GetOneofDefaultedDouble() float64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedDouble); ok {
+		return x.OneofDefaultedDouble
+	}
+	return Default_Message_OneofDefaultedDouble
+}
+
+func (m *Message) GetOneofDefaultedString() string {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedString); ok {
+		return x.OneofDefaultedString
+	}
+	return Default_Message_OneofDefaultedString
+}
+
+func (m *Message) GetOneofDefaultedBytes() []byte {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedBytes); ok {
+		return x.OneofDefaultedBytes
+	}
+	return append([]byte(nil), Default_Message_OneofDefaultedBytes...)
+}
+
+func (m *Message) GetOneofDefaultedChildEnum() Message_ChildEnum {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedChildEnum); ok {
+		return x.OneofDefaultedChildEnum
+	}
+	return Default_Message_OneofDefaultedChildEnum
+}
+
+func (m *Message) GetOneofDefaultedSiblingEnum() SiblingEnum {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedSiblingEnum); ok {
+		return x.OneofDefaultedSiblingEnum
+	}
+	return Default_Message_OneofDefaultedSiblingEnum
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*Message) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+	return _Message_OneofMarshaler, _Message_OneofUnmarshaler, _Message_OneofSizer, []interface{}{
+		(*Message_OneofBool)(nil),
+		(*Message_OneofInt32)(nil),
+		(*Message_OneofSint32)(nil),
+		(*Message_OneofUint32)(nil),
+		(*Message_OneofInt64)(nil),
+		(*Message_OneofSint64)(nil),
+		(*Message_OneofUint64)(nil),
+		(*Message_OneofFixed32)(nil),
+		(*Message_OneofSfixed32)(nil),
+		(*Message_OneofFloat)(nil),
+		(*Message_OneofFixed64)(nil),
+		(*Message_OneofSfixed64)(nil),
+		(*Message_OneofDouble)(nil),
+		(*Message_OneofString)(nil),
+		(*Message_OneofBytes)(nil),
+		(*Message_OneofChildEnum)(nil),
+		(*Message_OneofChildMessage)(nil),
+		(*Message_OneofNamedGroup)(nil),
+		(*Message_OneofSiblingEnum)(nil),
+		(*Message_OneofSiblingMessage)(nil),
+		(*Message_Oneofgroup)(nil),
+		(*Message_OneofString1)(nil),
+		(*Message_OneofString2)(nil),
+		(*Message_OneofString3)(nil),
+		(*Message_OneofDefaultedBool)(nil),
+		(*Message_OneofDefaultedInt32)(nil),
+		(*Message_OneofDefaultedSint32)(nil),
+		(*Message_OneofDefaultedUint32)(nil),
+		(*Message_OneofDefaultedInt64)(nil),
+		(*Message_OneofDefaultedSint64)(nil),
+		(*Message_OneofDefaultedUint64)(nil),
+		(*Message_OneofDefaultedFixed32)(nil),
+		(*Message_OneofDefaultedSfixed32)(nil),
+		(*Message_OneofDefaultedFloat)(nil),
+		(*Message_OneofDefaultedFixed64)(nil),
+		(*Message_OneofDefaultedSfixed64)(nil),
+		(*Message_OneofDefaultedDouble)(nil),
+		(*Message_OneofDefaultedString)(nil),
+		(*Message_OneofDefaultedBytes)(nil),
+		(*Message_OneofDefaultedChildEnum)(nil),
+		(*Message_OneofDefaultedSiblingEnum)(nil),
+	}
+}
+
+func _Message_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*Message)
+	// oneof_union
+	switch x := m.OneofUnion.(type) {
+	case *Message_OneofBool:
+		t := uint64(0)
+		if x.OneofBool {
+			t = 1
+		}
+		b.EncodeVarint(700<<3 | proto.WireVarint)
+		b.EncodeVarint(t)
+	case *Message_OneofInt32:
+		b.EncodeVarint(701<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofInt32))
+	case *Message_OneofSint32:
+		b.EncodeVarint(702<<3 | proto.WireVarint)
+		b.EncodeZigzag32(uint64(x.OneofSint32))
+	case *Message_OneofUint32:
+		b.EncodeVarint(703<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofUint32))
+	case *Message_OneofInt64:
+		b.EncodeVarint(704<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofInt64))
+	case *Message_OneofSint64:
+		b.EncodeVarint(705<<3 | proto.WireVarint)
+		b.EncodeZigzag64(uint64(x.OneofSint64))
+	case *Message_OneofUint64:
+		b.EncodeVarint(706<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofUint64))
+	case *Message_OneofFixed32:
+		b.EncodeVarint(707<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(x.OneofFixed32))
+	case *Message_OneofSfixed32:
+		b.EncodeVarint(708<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(x.OneofSfixed32))
+	case *Message_OneofFloat:
+		b.EncodeVarint(709<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(math.Float32bits(x.OneofFloat)))
+	case *Message_OneofFixed64:
+		b.EncodeVarint(710<<3 | proto.WireFixed64)
+		b.EncodeFixed64(uint64(x.OneofFixed64))
+	case *Message_OneofSfixed64:
+		b.EncodeVarint(711<<3 | proto.WireFixed64)
+		b.EncodeFixed64(uint64(x.OneofSfixed64))
+	case *Message_OneofDouble:
+		b.EncodeVarint(712<<3 | proto.WireFixed64)
+		b.EncodeFixed64(math.Float64bits(x.OneofDouble))
+	case *Message_OneofString:
+		b.EncodeVarint(713<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString)
+	case *Message_OneofBytes:
+		b.EncodeVarint(714<<3 | proto.WireBytes)
+		b.EncodeRawBytes(x.OneofBytes)
+	case *Message_OneofChildEnum:
+		b.EncodeVarint(715<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofChildEnum))
+	case *Message_OneofChildMessage:
+		b.EncodeVarint(716<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.OneofChildMessage); err != nil {
+			return err
+		}
+	case *Message_OneofNamedGroup:
+		b.EncodeVarint(717<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.OneofNamedGroup); err != nil {
+			return err
+		}
+	case *Message_OneofSiblingEnum:
+		b.EncodeVarint(718<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofSiblingEnum))
+	case *Message_OneofSiblingMessage:
+		b.EncodeVarint(719<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.OneofSiblingMessage); err != nil {
+			return err
+		}
+	case *Message_Oneofgroup:
+		b.EncodeVarint(720<<3 | proto.WireStartGroup)
+		if err := b.Marshal(x.Oneofgroup); err != nil {
+			return err
+		}
+		b.EncodeVarint(720<<3 | proto.WireEndGroup)
+	case *Message_OneofString1:
+		b.EncodeVarint(721<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString1)
+	case *Message_OneofString2:
+		b.EncodeVarint(722<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString2)
+	case *Message_OneofString3:
+		b.EncodeVarint(723<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString3)
+	case nil:
+	default:
+		return fmt.Errorf("Message.OneofUnion has unexpected type %T", x)
+	}
+	// oneof_defaulted_union
+	switch x := m.OneofDefaultedUnion.(type) {
+	case *Message_OneofDefaultedBool:
+		t := uint64(0)
+		if x.OneofDefaultedBool {
+			t = 1
+		}
+		b.EncodeVarint(800<<3 | proto.WireVarint)
+		b.EncodeVarint(t)
+	case *Message_OneofDefaultedInt32:
+		b.EncodeVarint(801<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofDefaultedInt32))
+	case *Message_OneofDefaultedSint32:
+		b.EncodeVarint(802<<3 | proto.WireVarint)
+		b.EncodeZigzag32(uint64(x.OneofDefaultedSint32))
+	case *Message_OneofDefaultedUint32:
+		b.EncodeVarint(803<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofDefaultedUint32))
+	case *Message_OneofDefaultedInt64:
+		b.EncodeVarint(804<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofDefaultedInt64))
+	case *Message_OneofDefaultedSint64:
+		b.EncodeVarint(805<<3 | proto.WireVarint)
+		b.EncodeZigzag64(uint64(x.OneofDefaultedSint64))
+	case *Message_OneofDefaultedUint64:
+		b.EncodeVarint(806<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofDefaultedUint64))
+	case *Message_OneofDefaultedFixed32:
+		b.EncodeVarint(807<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(x.OneofDefaultedFixed32))
+	case *Message_OneofDefaultedSfixed32:
+		b.EncodeVarint(808<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(x.OneofDefaultedSfixed32))
+	case *Message_OneofDefaultedFloat:
+		b.EncodeVarint(809<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(math.Float32bits(x.OneofDefaultedFloat)))
+	case *Message_OneofDefaultedFixed64:
+		b.EncodeVarint(810<<3 | proto.WireFixed64)
+		b.EncodeFixed64(uint64(x.OneofDefaultedFixed64))
+	case *Message_OneofDefaultedSfixed64:
+		b.EncodeVarint(811<<3 | proto.WireFixed64)
+		b.EncodeFixed64(uint64(x.OneofDefaultedSfixed64))
+	case *Message_OneofDefaultedDouble:
+		b.EncodeVarint(812<<3 | proto.WireFixed64)
+		b.EncodeFixed64(math.Float64bits(x.OneofDefaultedDouble))
+	case *Message_OneofDefaultedString:
+		b.EncodeVarint(813<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofDefaultedString)
+	case *Message_OneofDefaultedBytes:
+		b.EncodeVarint(814<<3 | proto.WireBytes)
+		b.EncodeRawBytes(x.OneofDefaultedBytes)
+	case *Message_OneofDefaultedChildEnum:
+		b.EncodeVarint(815<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofDefaultedChildEnum))
+	case *Message_OneofDefaultedSiblingEnum:
+		b.EncodeVarint(816<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofDefaultedSiblingEnum))
+	case nil:
+	default:
+		return fmt.Errorf("Message.OneofDefaultedUnion has unexpected type %T", x)
+	}
+	return nil
+}
+
+func _Message_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*Message)
+	switch tag {
+	case 700: // oneof_union.oneof_bool
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofBool{x != 0}
+		return true, err
+	case 701: // oneof_union.oneof_int32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofInt32{int32(x)}
+		return true, err
+	case 702: // oneof_union.oneof_sint32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeZigzag32()
+		m.OneofUnion = &Message_OneofSint32{int32(x)}
+		return true, err
+	case 703: // oneof_union.oneof_uint32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofUint32{uint32(x)}
+		return true, err
+	case 704: // oneof_union.oneof_int64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofInt64{int64(x)}
+		return true, err
+	case 705: // oneof_union.oneof_sint64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeZigzag64()
+		m.OneofUnion = &Message_OneofSint64{int64(x)}
+		return true, err
+	case 706: // oneof_union.oneof_uint64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofUint64{x}
+		return true, err
+	case 707: // oneof_union.oneof_fixed32
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofUnion = &Message_OneofFixed32{uint32(x)}
+		return true, err
+	case 708: // oneof_union.oneof_sfixed32
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofUnion = &Message_OneofSfixed32{int32(x)}
+		return true, err
+	case 709: // oneof_union.oneof_float
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofUnion = &Message_OneofFloat{math.Float32frombits(uint32(x))}
+		return true, err
+	case 710: // oneof_union.oneof_fixed64
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofUnion = &Message_OneofFixed64{x}
+		return true, err
+	case 711: // oneof_union.oneof_sfixed64
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofUnion = &Message_OneofSfixed64{int64(x)}
+		return true, err
+	case 712: // oneof_union.oneof_double
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofUnion = &Message_OneofDouble{math.Float64frombits(x)}
+		return true, err
+	case 713: // oneof_union.oneof_string
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString{x}
+		return true, err
+	case 714: // oneof_union.oneof_bytes
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeRawBytes(true)
+		m.OneofUnion = &Message_OneofBytes{x}
+		return true, err
+	case 715: // oneof_union.oneof_child_enum
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofChildEnum{Message_ChildEnum(x)}
+		return true, err
+	case 716: // oneof_union.oneof_child_message
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(Message_ChildMessage)
+		err := b.DecodeMessage(msg)
+		m.OneofUnion = &Message_OneofChildMessage{msg}
+		return true, err
+	case 717: // oneof_union.oneof_named_group
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(Message_NamedGroup)
+		err := b.DecodeMessage(msg)
+		m.OneofUnion = &Message_OneofNamedGroup{msg}
+		return true, err
+	case 718: // oneof_union.oneof_sibling_enum
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofSiblingEnum{SiblingEnum(x)}
+		return true, err
+	case 719: // oneof_union.oneof_sibling_message
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(SiblingMessage)
+		err := b.DecodeMessage(msg)
+		m.OneofUnion = &Message_OneofSiblingMessage{msg}
+		return true, err
+	case 720: // oneof_union.oneofgroup
+		if wire != proto.WireStartGroup {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(Message_OneofGroup)
+		err := b.DecodeGroup(msg)
+		m.OneofUnion = &Message_Oneofgroup{msg}
+		return true, err
+	case 721: // oneof_union.oneof_string1
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString1{x}
+		return true, err
+	case 722: // oneof_union.oneof_string2
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString2{x}
+		return true, err
+	case 723: // oneof_union.oneof_string3
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString3{x}
+		return true, err
+	case 800: // oneof_defaulted_union.oneof_defaulted_bool
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedBool{x != 0}
+		return true, err
+	case 801: // oneof_defaulted_union.oneof_defaulted_int32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedInt32{int32(x)}
+		return true, err
+	case 802: // oneof_defaulted_union.oneof_defaulted_sint32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeZigzag32()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedSint32{int32(x)}
+		return true, err
+	case 803: // oneof_defaulted_union.oneof_defaulted_uint32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedUint32{uint32(x)}
+		return true, err
+	case 804: // oneof_defaulted_union.oneof_defaulted_int64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedInt64{int64(x)}
+		return true, err
+	case 805: // oneof_defaulted_union.oneof_defaulted_sint64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeZigzag64()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedSint64{int64(x)}
+		return true, err
+	case 806: // oneof_defaulted_union.oneof_defaulted_uint64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedUint64{x}
+		return true, err
+	case 807: // oneof_defaulted_union.oneof_defaulted_fixed32
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedFixed32{uint32(x)}
+		return true, err
+	case 808: // oneof_defaulted_union.oneof_defaulted_sfixed32
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedSfixed32{int32(x)}
+		return true, err
+	case 809: // oneof_defaulted_union.oneof_defaulted_float
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedFloat{math.Float32frombits(uint32(x))}
+		return true, err
+	case 810: // oneof_defaulted_union.oneof_defaulted_fixed64
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedFixed64{x}
+		return true, err
+	case 811: // oneof_defaulted_union.oneof_defaulted_sfixed64
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedSfixed64{int64(x)}
+		return true, err
+	case 812: // oneof_defaulted_union.oneof_defaulted_double
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedDouble{math.Float64frombits(x)}
+		return true, err
+	case 813: // oneof_defaulted_union.oneof_defaulted_string
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedString{x}
+		return true, err
+	case 814: // oneof_defaulted_union.oneof_defaulted_bytes
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeRawBytes(true)
+		m.OneofDefaultedUnion = &Message_OneofDefaultedBytes{x}
+		return true, err
+	case 815: // oneof_defaulted_union.oneof_defaulted_child_enum
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedChildEnum{Message_ChildEnum(x)}
+		return true, err
+	case 816: // oneof_defaulted_union.oneof_defaulted_sibling_enum
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedSiblingEnum{SiblingEnum(x)}
+		return true, err
+	default:
+		return false, nil
+	}
+}
+
+func _Message_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*Message)
+	// oneof_union
+	switch x := m.OneofUnion.(type) {
+	case *Message_OneofBool:
+		n += proto.SizeVarint(700<<3 | proto.WireVarint)
+		n += 1
+	case *Message_OneofInt32:
+		n += proto.SizeVarint(701<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofInt32))
+	case *Message_OneofSint32:
+		n += proto.SizeVarint(702<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64((uint32(x.OneofSint32) << 1) ^ uint32((int32(x.OneofSint32) >> 31))))
+	case *Message_OneofUint32:
+		n += proto.SizeVarint(703<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofUint32))
+	case *Message_OneofInt64:
+		n += proto.SizeVarint(704<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofInt64))
+	case *Message_OneofSint64:
+		n += proto.SizeVarint(705<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(uint64(x.OneofSint64<<1) ^ uint64((int64(x.OneofSint64) >> 63))))
+	case *Message_OneofUint64:
+		n += proto.SizeVarint(706<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofUint64))
+	case *Message_OneofFixed32:
+		n += proto.SizeVarint(707<<3 | proto.WireFixed32)
+		n += 4
+	case *Message_OneofSfixed32:
+		n += proto.SizeVarint(708<<3 | proto.WireFixed32)
+		n += 4
+	case *Message_OneofFloat:
+		n += proto.SizeVarint(709<<3 | proto.WireFixed32)
+		n += 4
+	case *Message_OneofFixed64:
+		n += proto.SizeVarint(710<<3 | proto.WireFixed64)
+		n += 8
+	case *Message_OneofSfixed64:
+		n += proto.SizeVarint(711<<3 | proto.WireFixed64)
+		n += 8
+	case *Message_OneofDouble:
+		n += proto.SizeVarint(712<<3 | proto.WireFixed64)
+		n += 8
+	case *Message_OneofString:
+		n += proto.SizeVarint(713<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofString)))
+		n += len(x.OneofString)
+	case *Message_OneofBytes:
+		n += proto.SizeVarint(714<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofBytes)))
+		n += len(x.OneofBytes)
+	case *Message_OneofChildEnum:
+		n += proto.SizeVarint(715<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofChildEnum))
+	case *Message_OneofChildMessage:
+		s := proto.Size(x.OneofChildMessage)
+		n += proto.SizeVarint(716<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *Message_OneofNamedGroup:
+		s := proto.Size(x.OneofNamedGroup)
+		n += proto.SizeVarint(717<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *Message_OneofSiblingEnum:
+		n += proto.SizeVarint(718<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofSiblingEnum))
+	case *Message_OneofSiblingMessage:
+		s := proto.Size(x.OneofSiblingMessage)
+		n += proto.SizeVarint(719<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *Message_Oneofgroup:
+		n += proto.SizeVarint(720<<3 | proto.WireStartGroup)
+		n += proto.Size(x.Oneofgroup)
+		n += proto.SizeVarint(720<<3 | proto.WireEndGroup)
+	case *Message_OneofString1:
+		n += proto.SizeVarint(721<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofString1)))
+		n += len(x.OneofString1)
+	case *Message_OneofString2:
+		n += proto.SizeVarint(722<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofString2)))
+		n += len(x.OneofString2)
+	case *Message_OneofString3:
+		n += proto.SizeVarint(723<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofString3)))
+		n += len(x.OneofString3)
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	// oneof_defaulted_union
+	switch x := m.OneofDefaultedUnion.(type) {
+	case *Message_OneofDefaultedBool:
+		n += proto.SizeVarint(800<<3 | proto.WireVarint)
+		n += 1
+	case *Message_OneofDefaultedInt32:
+		n += proto.SizeVarint(801<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofDefaultedInt32))
+	case *Message_OneofDefaultedSint32:
+		n += proto.SizeVarint(802<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64((uint32(x.OneofDefaultedSint32) << 1) ^ uint32((int32(x.OneofDefaultedSint32) >> 31))))
+	case *Message_OneofDefaultedUint32:
+		n += proto.SizeVarint(803<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofDefaultedUint32))
+	case *Message_OneofDefaultedInt64:
+		n += proto.SizeVarint(804<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofDefaultedInt64))
+	case *Message_OneofDefaultedSint64:
+		n += proto.SizeVarint(805<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(uint64(x.OneofDefaultedSint64<<1) ^ uint64((int64(x.OneofDefaultedSint64) >> 63))))
+	case *Message_OneofDefaultedUint64:
+		n += proto.SizeVarint(806<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofDefaultedUint64))
+	case *Message_OneofDefaultedFixed32:
+		n += proto.SizeVarint(807<<3 | proto.WireFixed32)
+		n += 4
+	case *Message_OneofDefaultedSfixed32:
+		n += proto.SizeVarint(808<<3 | proto.WireFixed32)
+		n += 4
+	case *Message_OneofDefaultedFloat:
+		n += proto.SizeVarint(809<<3 | proto.WireFixed32)
+		n += 4
+	case *Message_OneofDefaultedFixed64:
+		n += proto.SizeVarint(810<<3 | proto.WireFixed64)
+		n += 8
+	case *Message_OneofDefaultedSfixed64:
+		n += proto.SizeVarint(811<<3 | proto.WireFixed64)
+		n += 8
+	case *Message_OneofDefaultedDouble:
+		n += proto.SizeVarint(812<<3 | proto.WireFixed64)
+		n += 8
+	case *Message_OneofDefaultedString:
+		n += proto.SizeVarint(813<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofDefaultedString)))
+		n += len(x.OneofDefaultedString)
+	case *Message_OneofDefaultedBytes:
+		n += proto.SizeVarint(814<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofDefaultedBytes)))
+		n += len(x.OneofDefaultedBytes)
+	case *Message_OneofDefaultedChildEnum:
+		n += proto.SizeVarint(815<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofDefaultedChildEnum))
+	case *Message_OneofDefaultedSiblingEnum:
+		n += proto.SizeVarint(816<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofDefaultedSiblingEnum))
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	return n
+}
+
+var E_Message_ExtensionOptionalBool = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*bool)(nil),
+	Field:         10000,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_optional_bool",
+	Tag:           "varint,10000,opt,name=extension_optional_bool,json=extensionOptionalBool",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionOptionalInt32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         10001,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_optional_int32",
+	Tag:           "varint,10001,opt,name=extension_optional_int32,json=extensionOptionalInt32",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionOptionalSint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         10002,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_optional_sint32",
+	Tag:           "zigzag32,10002,opt,name=extension_optional_sint32,json=extensionOptionalSint32",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionOptionalUint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint32)(nil),
+	Field:         10003,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_optional_uint32",
+	Tag:           "varint,10003,opt,name=extension_optional_uint32,json=extensionOptionalUint32",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionOptionalInt64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         10004,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_optional_int64",
+	Tag:           "varint,10004,opt,name=extension_optional_int64,json=extensionOptionalInt64",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionOptionalSint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         10005,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_optional_sint64",
+	Tag:           "zigzag64,10005,opt,name=extension_optional_sint64,json=extensionOptionalSint64",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionOptionalUint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint64)(nil),
+	Field:         10006,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_optional_uint64",
+	Tag:           "varint,10006,opt,name=extension_optional_uint64,json=extensionOptionalUint64",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionOptionalFixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint32)(nil),
+	Field:         10007,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_optional_fixed32",
+	Tag:           "fixed32,10007,opt,name=extension_optional_fixed32,json=extensionOptionalFixed32",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionOptionalSfixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         10008,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_optional_sfixed32",
+	Tag:           "fixed32,10008,opt,name=extension_optional_sfixed32,json=extensionOptionalSfixed32",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionOptionalFloat = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*float32)(nil),
+	Field:         10009,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_optional_float",
+	Tag:           "fixed32,10009,opt,name=extension_optional_float,json=extensionOptionalFloat",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionOptionalFixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint64)(nil),
+	Field:         10010,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_optional_fixed64",
+	Tag:           "fixed64,10010,opt,name=extension_optional_fixed64,json=extensionOptionalFixed64",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionOptionalSfixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         10011,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_optional_sfixed64",
+	Tag:           "fixed64,10011,opt,name=extension_optional_sfixed64,json=extensionOptionalSfixed64",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionOptionalDouble = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*float64)(nil),
+	Field:         10012,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_optional_double",
+	Tag:           "fixed64,10012,opt,name=extension_optional_double,json=extensionOptionalDouble",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionOptionalString = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*string)(nil),
+	Field:         10013,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_optional_string",
+	Tag:           "bytes,10013,opt,name=extension_optional_string,json=extensionOptionalString",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionOptionalBytes = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]byte)(nil),
+	Field:         10014,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_optional_bytes",
+	Tag:           "bytes,10014,opt,name=extension_optional_bytes,json=extensionOptionalBytes",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionOptionalChildEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*Message_ChildEnum)(nil),
+	Field:         10015,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_optional_child_enum",
+	Tag:           "varint,10015,opt,name=extension_optional_child_enum,json=extensionOptionalChildEnum,enum=google.golang.org.proto2_20180125.Message_ChildEnum",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionOptionalChildMessage = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*Message_ChildMessage)(nil),
+	Field:         10016,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_optional_child_message",
+	Tag:           "bytes,10016,opt,name=extension_optional_child_message,json=extensionOptionalChildMessage",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionOptionalNamedGroup = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*Message_NamedGroup)(nil),
+	Field:         10017,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_optional_named_group",
+	Tag:           "bytes,10017,opt,name=extension_optional_named_group,json=extensionOptionalNamedGroup",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionOptionalSiblingEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*SiblingEnum)(nil),
+	Field:         10018,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_optional_sibling_enum",
+	Tag:           "varint,10018,opt,name=extension_optional_sibling_enum,json=extensionOptionalSiblingEnum,enum=google.golang.org.proto2_20180125.SiblingEnum",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionOptionalSiblingMessage = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*SiblingMessage)(nil),
+	Field:         10019,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_optional_sibling_message",
+	Tag:           "bytes,10019,opt,name=extension_optional_sibling_message,json=extensionOptionalSiblingMessage",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_Extensionoptionalgroup = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*Message_ExtensionOptionalGroup)(nil),
+	Field:         10020,
+	Name:          "google.golang.org.proto2_20180125.Message.extensionoptionalgroup",
+	Tag:           "group,10020,opt,name=ExtensionOptionalGroup,json=extensionoptionalgroup",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionDefaultedBool = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*bool)(nil),
+	Field:         20000,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_defaulted_bool",
+	Tag:           "varint,20000,opt,name=extension_defaulted_bool,json=extensionDefaultedBool,def=1",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionDefaultedInt32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         20001,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_defaulted_int32",
+	Tag:           "varint,20001,opt,name=extension_defaulted_int32,json=extensionDefaultedInt32,def=-12345",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionDefaultedSint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         20002,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_defaulted_sint32",
+	Tag:           "zigzag32,20002,opt,name=extension_defaulted_sint32,json=extensionDefaultedSint32,def=-3200",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionDefaultedUint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint32)(nil),
+	Field:         20003,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_defaulted_uint32",
+	Tag:           "varint,20003,opt,name=extension_defaulted_uint32,json=extensionDefaultedUint32,def=3200",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionDefaultedInt64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         20004,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_defaulted_int64",
+	Tag:           "varint,20004,opt,name=extension_defaulted_int64,json=extensionDefaultedInt64,def=-123456789",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionDefaultedSint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         20005,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_defaulted_sint64",
+	Tag:           "zigzag64,20005,opt,name=extension_defaulted_sint64,json=extensionDefaultedSint64,def=-6400",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionDefaultedUint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint64)(nil),
+	Field:         20006,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_defaulted_uint64",
+	Tag:           "varint,20006,opt,name=extension_defaulted_uint64,json=extensionDefaultedUint64,def=6400",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionDefaultedFixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint32)(nil),
+	Field:         20007,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_defaulted_fixed32",
+	Tag:           "fixed32,20007,opt,name=extension_defaulted_fixed32,json=extensionDefaultedFixed32,def=320000",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionDefaultedSfixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         20008,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_defaulted_sfixed32",
+	Tag:           "fixed32,20008,opt,name=extension_defaulted_sfixed32,json=extensionDefaultedSfixed32,def=-320000",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionDefaultedFloat = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*float32)(nil),
+	Field:         20009,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_defaulted_float",
+	Tag:           "fixed32,20009,opt,name=extension_defaulted_float,json=extensionDefaultedFloat,def=3.14159",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionDefaultedFixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint64)(nil),
+	Field:         20010,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_defaulted_fixed64",
+	Tag:           "fixed64,20010,opt,name=extension_defaulted_fixed64,json=extensionDefaultedFixed64,def=640000",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionDefaultedSfixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         20011,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_defaulted_sfixed64",
+	Tag:           "fixed64,20011,opt,name=extension_defaulted_sfixed64,json=extensionDefaultedSfixed64,def=-640000",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionDefaultedDouble = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*float64)(nil),
+	Field:         20012,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_defaulted_double",
+	Tag:           "fixed64,20012,opt,name=extension_defaulted_double,json=extensionDefaultedDouble,def=3.14159265359",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionDefaultedString = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*string)(nil),
+	Field:         20013,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_defaulted_string",
+	Tag:           "bytes,20013,opt,name=extension_defaulted_string,json=extensionDefaultedString,def=hello, \"world!\"\n",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionDefaultedBytes = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]byte)(nil),
+	Field:         20014,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_defaulted_bytes",
+	Tag:           "bytes,20014,opt,name=extension_defaulted_bytes,json=extensionDefaultedBytes,def=dead\\336\\255\\276\\357beef",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionDefaultedChildEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*Message_ChildEnum)(nil),
+	Field:         20015,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_defaulted_child_enum",
+	Tag:           "varint,20015,opt,name=extension_defaulted_child_enum,json=extensionDefaultedChildEnum,enum=google.golang.org.proto2_20180125.Message_ChildEnum,def=0",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionDefaultedSiblingEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*SiblingEnum)(nil),
+	Field:         20016,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_defaulted_sibling_enum",
+	Tag:           "varint,20016,opt,name=extension_defaulted_sibling_enum,json=extensionDefaultedSiblingEnum,enum=google.golang.org.proto2_20180125.SiblingEnum,def=0",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionRepeatedBool = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]bool)(nil),
+	Field:         30000,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_repeated_bool",
+	Tag:           "varint,30000,rep,name=extension_repeated_bool,json=extensionRepeatedBool",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionRepeatedInt32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int32)(nil),
+	Field:         30001,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_repeated_int32",
+	Tag:           "varint,30001,rep,name=extension_repeated_int32,json=extensionRepeatedInt32",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionRepeatedSint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int32)(nil),
+	Field:         30002,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_repeated_sint32",
+	Tag:           "zigzag32,30002,rep,name=extension_repeated_sint32,json=extensionRepeatedSint32",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionRepeatedUint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]uint32)(nil),
+	Field:         30003,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_repeated_uint32",
+	Tag:           "varint,30003,rep,name=extension_repeated_uint32,json=extensionRepeatedUint32",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionRepeatedInt64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int64)(nil),
+	Field:         30004,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_repeated_int64",
+	Tag:           "varint,30004,rep,name=extension_repeated_int64,json=extensionRepeatedInt64",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionRepeatedSint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int64)(nil),
+	Field:         30005,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_repeated_sint64",
+	Tag:           "zigzag64,30005,rep,name=extension_repeated_sint64,json=extensionRepeatedSint64",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionRepeatedUint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]uint64)(nil),
+	Field:         30006,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_repeated_uint64",
+	Tag:           "varint,30006,rep,name=extension_repeated_uint64,json=extensionRepeatedUint64",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionRepeatedFixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]uint32)(nil),
+	Field:         30007,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_repeated_fixed32",
+	Tag:           "fixed32,30007,rep,name=extension_repeated_fixed32,json=extensionRepeatedFixed32",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionRepeatedSfixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int32)(nil),
+	Field:         30008,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_repeated_sfixed32",
+	Tag:           "fixed32,30008,rep,name=extension_repeated_sfixed32,json=extensionRepeatedSfixed32",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionRepeatedFloat = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]float32)(nil),
+	Field:         30009,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_repeated_float",
+	Tag:           "fixed32,30009,rep,name=extension_repeated_float,json=extensionRepeatedFloat",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionRepeatedFixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]uint64)(nil),
+	Field:         30010,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_repeated_fixed64",
+	Tag:           "fixed64,30010,rep,name=extension_repeated_fixed64,json=extensionRepeatedFixed64",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionRepeatedSfixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int64)(nil),
+	Field:         30011,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_repeated_sfixed64",
+	Tag:           "fixed64,30011,rep,name=extension_repeated_sfixed64,json=extensionRepeatedSfixed64",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionRepeatedDouble = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]float64)(nil),
+	Field:         30012,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_repeated_double",
+	Tag:           "fixed64,30012,rep,name=extension_repeated_double,json=extensionRepeatedDouble",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionRepeatedString = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]string)(nil),
+	Field:         30013,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_repeated_string",
+	Tag:           "bytes,30013,rep,name=extension_repeated_string,json=extensionRepeatedString",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionRepeatedBytes = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([][]byte)(nil),
+	Field:         30014,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_repeated_bytes",
+	Tag:           "bytes,30014,rep,name=extension_repeated_bytes,json=extensionRepeatedBytes",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionRepeatedChildEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]Message_ChildEnum)(nil),
+	Field:         30015,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_repeated_child_enum",
+	Tag:           "varint,30015,rep,name=extension_repeated_child_enum,json=extensionRepeatedChildEnum,enum=google.golang.org.proto2_20180125.Message_ChildEnum",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionRepeatedChildMessage = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]*Message_ChildMessage)(nil),
+	Field:         30016,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_repeated_child_message",
+	Tag:           "bytes,30016,rep,name=extension_repeated_child_message,json=extensionRepeatedChildMessage",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionRepeatedNamedGroup = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]*Message_NamedGroup)(nil),
+	Field:         30017,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_repeated_named_group",
+	Tag:           "bytes,30017,rep,name=extension_repeated_named_group,json=extensionRepeatedNamedGroup",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionRepeatedSiblingEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]SiblingEnum)(nil),
+	Field:         30018,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_repeated_sibling_enum",
+	Tag:           "varint,30018,rep,name=extension_repeated_sibling_enum,json=extensionRepeatedSiblingEnum,enum=google.golang.org.proto2_20180125.SiblingEnum",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_ExtensionRepeatedSiblingMessage = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]*SiblingMessage)(nil),
+	Field:         30019,
+	Name:          "google.golang.org.proto2_20180125.Message.extension_repeated_sibling_message",
+	Tag:           "bytes,30019,rep,name=extension_repeated_sibling_message,json=extensionRepeatedSiblingMessage",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+var E_Message_Extensionrepeatedgroup = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]*Message_ExtensionRepeatedGroup)(nil),
+	Field:         30020,
+	Name:          "google.golang.org.proto2_20180125.Message.extensionrepeatedgroup",
+	Tag:           "group,30020,rep,name=ExtensionRepeatedGroup,json=extensionrepeatedgroup",
+	Filename:      "proto2_20180125_92554152/test.proto",
+}
+
+type Message_ChildMessage 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"`
+	F4               *Message `protobuf:"bytes,4,opt,name=f4" json:"f4,omitempty"`
+	XXX_unrecognized []byte   `json:"-"`
+}
+
+func (m *Message_ChildMessage) Reset()                    { *m = Message_ChildMessage{} }
+func (m *Message_ChildMessage) String() string            { return proto.CompactTextString(m) }
+func (*Message_ChildMessage) ProtoMessage()               {}
+func (*Message_ChildMessage) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1, 0} }
+
+func (m *Message_ChildMessage) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_ChildMessage) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_ChildMessage) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+func (m *Message_ChildMessage) GetF4() *Message {
+	if m != nil {
+		return m.F4
+	}
+	return nil
+}
+
+type Message_NamedGroup 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"`
+	F4               *Message `protobuf:"bytes,4,opt,name=f4" json:"f4,omitempty"`
+	XXX_unrecognized []byte   `json:"-"`
+}
+
+func (m *Message_NamedGroup) Reset()                    { *m = Message_NamedGroup{} }
+func (m *Message_NamedGroup) String() string            { return proto.CompactTextString(m) }
+func (*Message_NamedGroup) ProtoMessage()               {}
+func (*Message_NamedGroup) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1, 1} }
+
+func (m *Message_NamedGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_NamedGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_NamedGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+func (m *Message_NamedGroup) GetF4() *Message {
+	if m != nil {
+		return m.F4
+	}
+	return nil
+}
+
+type Message_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_unrecognized []byte   `json:"-"`
+}
+
+func (m *Message_OptionalGroup) Reset()                    { *m = Message_OptionalGroup{} }
+func (m *Message_OptionalGroup) String() string            { return proto.CompactTextString(m) }
+func (*Message_OptionalGroup) ProtoMessage()               {}
+func (*Message_OptionalGroup) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1, 2} }
+
+func (m *Message_OptionalGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_OptionalGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_OptionalGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message_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_unrecognized []byte   `json:"-"`
+}
+
+func (m *Message_RequiredGroup) Reset()                    { *m = Message_RequiredGroup{} }
+func (m *Message_RequiredGroup) String() string            { return proto.CompactTextString(m) }
+func (*Message_RequiredGroup) ProtoMessage()               {}
+func (*Message_RequiredGroup) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1, 3} }
+
+func (m *Message_RequiredGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_RequiredGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_RequiredGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message_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_unrecognized []byte   `json:"-"`
+}
+
+func (m *Message_RepeatedGroup) Reset()                    { *m = Message_RepeatedGroup{} }
+func (m *Message_RepeatedGroup) String() string            { return proto.CompactTextString(m) }
+func (*Message_RepeatedGroup) ProtoMessage()               {}
+func (*Message_RepeatedGroup) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1, 4} }
+
+func (m *Message_RepeatedGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_RepeatedGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_RepeatedGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message_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_unrecognized []byte   `json:"-"`
+}
+
+func (m *Message_OneofGroup) Reset()                    { *m = Message_OneofGroup{} }
+func (m *Message_OneofGroup) String() string            { return proto.CompactTextString(m) }
+func (*Message_OneofGroup) ProtoMessage()               {}
+func (*Message_OneofGroup) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1, 33} }
+
+func (m *Message_OneofGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_OneofGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_OneofGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message_ExtensionOptionalGroup 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_unrecognized []byte   `json:"-"`
+}
+
+func (m *Message_ExtensionOptionalGroup) Reset()         { *m = Message_ExtensionOptionalGroup{} }
+func (m *Message_ExtensionOptionalGroup) String() string { return proto.CompactTextString(m) }
+func (*Message_ExtensionOptionalGroup) ProtoMessage()    {}
+func (*Message_ExtensionOptionalGroup) Descriptor() ([]byte, []int) {
+	return fileDescriptor0, []int{1, 34}
+}
+
+func (m *Message_ExtensionOptionalGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_ExtensionOptionalGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_ExtensionOptionalGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message_ExtensionRepeatedGroup 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_unrecognized []byte   `json:"-"`
+}
+
+func (m *Message_ExtensionRepeatedGroup) Reset()         { *m = Message_ExtensionRepeatedGroup{} }
+func (m *Message_ExtensionRepeatedGroup) String() string { return proto.CompactTextString(m) }
+func (*Message_ExtensionRepeatedGroup) ProtoMessage()    {}
+func (*Message_ExtensionRepeatedGroup) Descriptor() ([]byte, []int) {
+	return fileDescriptor0, []int{1, 35}
+}
+
+func (m *Message_ExtensionRepeatedGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_ExtensionRepeatedGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_ExtensionRepeatedGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*SiblingMessage)(nil), "google.golang.org.proto2_20180125.SiblingMessage")
+	proto.RegisterType((*Message)(nil), "google.golang.org.proto2_20180125.Message")
+	proto.RegisterType((*Message_ChildMessage)(nil), "google.golang.org.proto2_20180125.Message.ChildMessage")
+	proto.RegisterType((*Message_NamedGroup)(nil), "google.golang.org.proto2_20180125.Message.NamedGroup")
+	proto.RegisterType((*Message_OptionalGroup)(nil), "google.golang.org.proto2_20180125.Message.OptionalGroup")
+	proto.RegisterType((*Message_RequiredGroup)(nil), "google.golang.org.proto2_20180125.Message.RequiredGroup")
+	proto.RegisterType((*Message_RepeatedGroup)(nil), "google.golang.org.proto2_20180125.Message.RepeatedGroup")
+	proto.RegisterType((*Message_OneofGroup)(nil), "google.golang.org.proto2_20180125.Message.OneofGroup")
+	proto.RegisterType((*Message_ExtensionOptionalGroup)(nil), "google.golang.org.proto2_20180125.Message.ExtensionOptionalGroup")
+	proto.RegisterType((*Message_ExtensionRepeatedGroup)(nil), "google.golang.org.proto2_20180125.Message.ExtensionRepeatedGroup")
+	proto.RegisterEnum("google.golang.org.proto2_20180125.SiblingEnum", SiblingEnum_name, SiblingEnum_value)
+	proto.RegisterEnum("google.golang.org.proto2_20180125.Message_ChildEnum", Message_ChildEnum_name, Message_ChildEnum_value)
+	proto.RegisterExtension(E_Message_ExtensionOptionalBool)
+	proto.RegisterExtension(E_Message_ExtensionOptionalInt32)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSint32)
+	proto.RegisterExtension(E_Message_ExtensionOptionalUint32)
+	proto.RegisterExtension(E_Message_ExtensionOptionalInt64)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSint64)
+	proto.RegisterExtension(E_Message_ExtensionOptionalUint64)
+	proto.RegisterExtension(E_Message_ExtensionOptionalFixed32)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSfixed32)
+	proto.RegisterExtension(E_Message_ExtensionOptionalFloat)
+	proto.RegisterExtension(E_Message_ExtensionOptionalFixed64)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSfixed64)
+	proto.RegisterExtension(E_Message_ExtensionOptionalDouble)
+	proto.RegisterExtension(E_Message_ExtensionOptionalString)
+	proto.RegisterExtension(E_Message_ExtensionOptionalBytes)
+	proto.RegisterExtension(E_Message_ExtensionOptionalChildEnum)
+	proto.RegisterExtension(E_Message_ExtensionOptionalChildMessage)
+	proto.RegisterExtension(E_Message_ExtensionOptionalNamedGroup)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSiblingEnum)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSiblingMessage)
+	proto.RegisterExtension(E_Message_Extensionoptionalgroup)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedBool)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedInt32)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedSint32)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedUint32)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedInt64)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedSint64)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedUint64)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedFixed32)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedSfixed32)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedFloat)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedFixed64)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedSfixed64)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedDouble)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedString)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedBytes)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedChildEnum)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedSiblingEnum)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedBool)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedInt32)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSint32)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedUint32)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedInt64)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSint64)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedUint64)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedFixed32)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSfixed32)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedFloat)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedFixed64)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSfixed64)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedDouble)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedString)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedBytes)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedChildEnum)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedChildMessage)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedNamedGroup)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSiblingEnum)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSiblingMessage)
+	proto.RegisterExtension(E_Message_Extensionrepeatedgroup)
+}
+
+func init() { proto.RegisterFile("proto2_20180125_92554152/test.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+	// 4468 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x5c, 0x67, 0x70, 0x24, 0xc7,
+	0x75, 0xc6, 0xec, 0x62, 0x17, 0x87, 0x3e, 0x2c, 0xb0, 0x98, 0xbb, 0x03, 0xe6, 0x40, 0xd2, 0x5c,
+	0x41, 0xb2, 0xbc, 0xa6, 0x79, 0x38, 0x60, 0xd0, 0xe8, 0xe3, 0xad, 0x19, 0x04, 0x90, 0x47, 0x2d,
+	0x65, 0x71, 0xa9, 0x1a, 0xd6, 0xb9, 0x5c, 0x2e, 0x96, 0x61, 0xdc, 0x61, 0x81, 0x03, 0xb9, 0x01,
+	0x04, 0x76, 0x49, 0x9e, 0x25, 0x17, 0xcf, 0x72, 0xfc, 0x49, 0xe5, 0xb4, 0x92, 0x28, 0x66, 0x89,
+	0x51, 0x39, 0x31, 0x29, 0xd8, 0xa6, 0x72, 0x72, 0x90, 0x93, 0x9c, 0x93, 0x9c, 0x73, 0x0e, 0xd5,
+	0xfd, 0xba, 0xa7, 0xbb, 0x67, 0x7a, 0x16, 0xe8, 0x59, 0x15, 0x7f, 0xb0, 0x8a, 0xd7, 0xfb, 0xfa,
+	0x7d, 0xfd, 0xbe, 0xed, 0xf7, 0xde, 0x87, 0x9e, 0xe9, 0x45, 0x2f, 0xdd, 0xde, 0x69, 0x77, 0xda,
+	0xfe, 0xaa, 0x3f, 0xbf, 0x70, 0xc5, 0xfc, 0x82, 0xbf, 0xb4, 0x7a, 0xd2, 0x5f, 0x5a, 0xc2, 0x0b,
+	0x4b, 0xfe, 0xf1, 0x4e, 0x7d, 0xb7, 0x33, 0xc7, 0x3e, 0x75, 0x5f, 0xb2, 0xd9, 0x6e, 0x6f, 0x36,
+	0xea, 0x73, 0x9b, 0xed, 0xc6, 0x5a, 0x6b, 0x73, 0xae, 0xbd, 0xb3, 0x39, 0x17, 0x99, 0x36, 0xfb,
+	0x3a, 0x34, 0x7e, 0xf3, 0xd6, 0x99, 0xc6, 0x56, 0x6b, 0xf3, 0xc6, 0xfa, 0xee, 0xee, 0xda, 0x66,
+	0xdd, 0x1d, 0x47, 0x99, 0x8d, 0x05, 0xcf, 0x29, 0x39, 0xe5, 0xd1, 0x20, 0xb3, 0xb1, 0xc0, 0xfe,
+	0xed, 0x7b, 0x99, 0x52, 0x86, 0xfd, 0xdb, 0x67, 0xff, 0x5e, 0xf4, 0xb2, 0xa5, 0x2c, 0xfb, 0xf7,
+	0xa2, 0x5b, 0x41, 0x99, 0x0d, 0xec, 0x0d, 0x97, 0x9c, 0xf2, 0x41, 0xff, 0xb2, 0xb9, 0x3d, 0x11,
+	0xe7, 0x38, 0x4e, 0x90, 0xd9, 0xc0, 0xb3, 0xdf, 0x79, 0xd4, 0x41, 0x23, 0x02, 0xf8, 0x34, 0x42,
+	0xad, 0xb5, 0x66, 0x7d, 0x7d, 0x73, 0xa7, 0xdd, 0xdd, 0x66, 0x0b, 0x40, 0xfe, 0xd2, 0xfe, 0x1d,
+	0xce, 0xd5, 0xe8, 0xe4, 0x57, 0xd2, 0xc9, 0x81, 0xe2, 0xc8, 0x7d, 0x29, 0x2a, 0xb4, 0xb7, 0x3b,
+	0x5b, 0xed, 0xd6, 0x5a, 0x63, 0xf5, 0x4c, 0xbb, 0xdd, 0xf0, 0xd6, 0x4b, 0x4e, 0xf9, 0x40, 0x30,
+	0x26, 0x06, 0x57, 0xda, 0xed, 0x86, 0xfb, 0xfd, 0x68, 0x3c, 0x34, 0xda, 0x6a, 0x75, 0x16, 0x7d,
+	0xaf, 0x5e, 0x72, 0xca, 0xb9, 0x20, 0x9c, 0x7a, 0x03, 0x1d, 0x74, 0x7f, 0x00, 0x4d, 0x84, 0x66,
+	0xbb, 0x60, 0xb7, 0x51, 0x72, 0xca, 0x93, 0x41, 0x38, 0xfb, 0xe6, 0xad, 0x98, 0x61, 0x17, 0x0c,
+	0x37, 0x4b, 0x4e, 0xb9, 0x20, 0x0d, 0x4f, 0x83, 0x61, 0x04, 0x98, 0x60, 0xef, 0x5c, 0xc9, 0x29,
+	0x67, 0x35, 0x60, 0x82, 0x63, 0xc0, 0x04, 0x7b, 0x5b, 0x25, 0xa7, 0xec, 0xea, 0xc0, 0x11, 0xc3,
+	0x2e, 0x18, 0xde, 0x5a, 0x72, 0xca, 0xc3, 0x3a, 0x30, 0xc1, 0xee, 0x0f, 0xa2, 0x62, 0x68, 0xb8,
+	0xb1, 0x75, 0x57, 0x7d, 0x7d, 0xd1, 0xf7, 0x6e, 0x2b, 0x39, 0xe5, 0x91, 0x20, 0x74, 0x70, 0x3d,
+	0x0c, 0xbb, 0x3f, 0x84, 0x26, 0x25, 0xb8, 0xb0, 0x6d, 0x94, 0x9c, 0xf2, 0x44, 0x10, 0xfa, 0xb8,
+	0x99, 0x8f, 0x6b, 0x01, 0x6d, 0x34, 0xda, 0x6b, 0x1d, 0xaf, 0x59, 0x72, 0xca, 0x19, 0x19, 0xd0,
+	0xf5, 0x74, 0x30, 0x0e, 0x4f, 0xb0, 0xd7, 0x2a, 0x39, 0xe5, 0x7c, 0x04, 0x9e, 0x60, 0x03, 0x3c,
+	0xc1, 0x5e, 0xbb, 0xe4, 0x94, 0x8b, 0x51, 0xf8, 0x48, 0xfc, 0xeb, 0xed, 0xee, 0x99, 0x46, 0xdd,
+	0xdb, 0x2e, 0x39, 0x65, 0x47, 0xc6, 0x7f, 0x1d, 0x1b, 0xd5, 0x19, 0xed, 0xec, 0x6c, 0xb5, 0x36,
+	0xbd, 0xdb, 0xd9, 0x9e, 0x97, 0x8c, 0xb2, 0x51, 0x2d, 0xa0, 0x33, 0xe7, 0x3b, 0xf5, 0x5d, 0x6f,
+	0xa7, 0xe4, 0x94, 0xc7, 0x64, 0x40, 0x2b, 0x74, 0xd0, 0x5d, 0x47, 0x87, 0x42, 0xb3, 0xb3, 0xe7,
+	0xb6, 0x1a, 0xeb, 0xab, 0xf5, 0x56, 0xb7, 0xe9, 0xed, 0x96, 0x9c, 0xf2, 0xb8, 0x8f, 0x2d, 0xb6,
+	0xf1, 0xb5, 0x74, 0xf2, 0xa9, 0x56, 0xb7, 0x19, 0x84, 0x61, 0x87, 0x43, 0x6e, 0x13, 0x4d, 0x45,
+	0x50, 0x9a, 0x30, 0xcd, 0xeb, 0xb0, 0x04, 0x3c, 0x61, 0x0b, 0x24, 0xb2, 0xf1, 0xb0, 0x86, 0x25,
+	0x52, 0x72, 0x13, 0x85, 0xe3, 0xab, 0x2c, 0xa5, 0x56, 0x21, 0x39, 0xbb, 0x0c, 0x2c, 0x65, 0x72,
+	0xba, 0xc2, 0xa5, 0x1c, 0x73, 0xcf, 0xa0, 0x23, 0xca, 0xfe, 0x66, 0xf5, 0x08, 0xf8, 0xbb, 0x83,
+	0xf1, 0x37, 0xb7, 0x0f, 0x24, 0x5e, 0xc6, 0x18, 0x73, 0x87, 0x64, 0x56, 0x84, 0x83, 0xee, 0x6d,
+	0xc8, 0x8b, 0x61, 0x08, 0xf6, 0xee, 0x64, 0x01, 0x2d, 0xec, 0x1f, 0x46, 0xf0, 0x36, 0x15, 0x41,
+	0x12, 0xcc, 0xfd, 0x84, 0xac, 0x3a, 0x40, 0xd9, 0x5d, 0xac, 0x9e, 0x5d, 0x61, 0x41, 0xd9, 0x4d,
+	0x7c, 0x3e, 0xb0, 0xa6, 0xbb, 0x73, 0x2f, 0x47, 0xe3, 0xeb, 0xf5, 0x8d, 0xb5, 0x6e, 0xa3, 0x53,
+	0x5f, 0x87, 0xb2, 0xf6, 0x02, 0xad, 0x98, 0x07, 0x2a, 0xc3, 0x9d, 0x9d, 0x6e, 0x3d, 0x28, 0x84,
+	0x1f, 0xb2, 0xf2, 0x36, 0x8f, 0x26, 0xa4, 0x35, 0x94, 0xa3, 0x2f, 0x50, 0xf3, 0x5c, 0x25, 0x7f,
+	0x6c, 0xc1, 0x5f, 0xc4, 0x4b, 0x81, 0xf4, 0x06, 0x95, 0x6e, 0x01, 0x15, 0xe5, 0x0c, 0x5e, 0xea,
+	0xbe, 0x48, 0xa7, 0x4c, 0x56, 0x72, 0xc7, 0x16, 0xfd, 0xf9, 0xf9, 0x40, 0x7a, 0xe4, 0x35, 0x6f,
+	0x5e, 0x9d, 0xc2, 0x8b, 0xde, 0x97, 0xe8, 0x94, 0x42, 0x65, 0x38, 0x32, 0x83, 0x17, 0x3f, 0x1c,
+	0x59, 0x16, 0xc1, 0xde, 0x97, 0xe9, 0x84, 0x6c, 0x05, 0xc1, 0xb2, 0xc8, 0x89, 0x2b, 0x4e, 0xea,
+	0x4b, 0x23, 0x38, 0xbe, 0x34, 0x82, 0xbd, 0xaf, 0xd0, 0x69, 0x6e, 0x25, 0x77, 0x8c, 0xe0, 0xd8,
+	0xd2, 0x08, 0x8e, 0x2f, 0x8d, 0x60, 0xef, 0xab, 0x74, 0xca, 0x70, 0x65, 0x38, 0x32, 0x83, 0x97,
+	0x47, 0x8c, 0x26, 0xe5, 0x0c, 0x51, 0xf3, 0xbe, 0x46, 0xa7, 0x8c, 0x54, 0xf2, 0x34, 0x9a, 0xf9,
+	0xf9, 0x40, 0xfa, 0x14, 0x95, 0xf2, 0x04, 0x72, 0x95, 0xa5, 0x89, 0x69, 0x5f, 0xa7, 0xd3, 0x26,
+	0x2a, 0x23, 0xc7, 0xf8, 0x3c, 0xe9, 0x39, 0xac, 0x9a, 0x0b, 0x2a, 0x13, 0x50, 0x36, 0xbf, 0x41,
+	0x67, 0x65, 0x2a, 0x23, 0x8b, 0x73, 0x0b, 0x78, 0x61, 0x49, 0xa5, 0x01, 0x2a, 0x68, 0x7c, 0x85,
+	0x04, 0x7b, 0xdf, 0xa4, 0x93, 0xf2, 0x95, 0x3c, 0x0d, 0x2a, 0xbe, 0x42, 0x82, 0x4d, 0x2b, 0x24,
+	0xd8, 0xfb, 0x16, 0x9d, 0x56, 0xac, 0x8c, 0x1c, 0xe3, 0xf3, 0xa2, 0x2b, 0x24, 0xd8, 0x3d, 0xa9,
+	0x52, 0xc8, 0x2b, 0xeb, 0xaf, 0xd1, 0x69, 0x4e, 0xa5, 0xc0, 0x97, 0xe8, 0x93, 0xa5, 0xc5, 0xa5,
+	0x93, 0x0a, 0x97, 0xbc, 0xd4, 0x5e, 0xa9, 0x7d, 0x61, 0x50, 0x6b, 0x7f, 0x9d, 0x09, 0x8c, 0x4a,
+	0xf1, 0x5c, 0xbd, 0xd1, 0x68, 0x5f, 0x5e, 0x9a, 0xbd, 0xb3, 0xbd, 0xd3, 0x58, 0x7f, 0xc9, 0x2c,
+	0x52, 0xbf, 0x3b, 0xa8, 0xbf, 0x2b, 0x2a, 0x35, 0x50, 0x80, 0x7f, 0x83, 0x4e, 0x1e, 0xab, 0x78,
+	0xeb, 0xf5, 0xb5, 0xf5, 0x5b, 0x16, 0x17, 0xc9, 0x2d, 0xfe, 0xd2, 0xd2, 0x2d, 0xfe, 0x09, 0x72,
+	0xcb, 0xe2, 0xd2, 0x89, 0x33, 0xf5, 0xfa, 0x86, 0xc2, 0x15, 0x14, 0xe7, 0x16, 0x3a, 0x2c, 0x7d,
+	0x28, 0xd5, 0xf9, 0x37, 0x9d, 0xf4, 0xe5, 0xb9, 0x92, 0x5b, 0x7e, 0xf5, 0x6b, 0xaa, 0xcb, 0x81,
+	0xe4, 0x53, 0x96, 0xe9, 0x06, 0x9a, 0x52, 0xb7, 0xa8, 0x52, 0xcf, 0xbe, 0xed, 0xa4, 0x29, 0x68,
+	0x02, 0xeb, 0xb0, 0xb2, 0xb1, 0x65, 0x61, 0x7b, 0x19, 0x2a, 0xec, 0xd4, 0x6f, 0xef, 0x6e, 0xed,
+	0x88, 0x52, 0xf0, 0x18, 0x55, 0x6b, 0x07, 0x82, 0x31, 0x31, 0xca, 0x6a, 0xc0, 0xcb, 0xd1, 0x78,
+	0x68, 0x05, 0xc9, 0xf9, 0x38, 0x35, 0xcb, 0x05, 0xe1, 0x64, 0xc8, 0xfc, 0x32, 0x9a, 0x08, 0xed,
+	0x78, 0xe2, 0x3f, 0x41, 0x0d, 0x27, 0x83, 0x70, 0x3e, 0x4f, 0x78, 0xd5, 0x92, 0xe7, 0xfb, 0x93,
+	0xd4, 0xb2, 0x20, 0x2d, 0x79, 0xa2, 0x47, 0xb0, 0x09, 0xf6, 0x9e, 0xa2, 0x86, 0x59, 0x0d, 0x9b,
+	0xe0, 0x18, 0x36, 0xc1, 0xde, 0x07, 0xa9, 0xa1, 0xab, 0x63, 0x47, 0x2c, 0x79, 0x42, 0x7f, 0x88,
+	0x5a, 0x0e, 0xeb, 0xd8, 0x04, 0xbb, 0x97, 0xa1, 0x62, 0x68, 0x29, 0x32, 0xf2, 0xc3, 0xd4, 0x74,
+	0x24, 0x08, 0x5d, 0x88, 0xfc, 0xbd, 0x1c, 0x4d, 0x4a, 0x7c, 0x61, 0xfc, 0x11, 0x6a, 0x3c, 0x11,
+	0x84, 0x5e, 0xc2, 0xa4, 0x55, 0xa3, 0x82, 0x9c, 0xfd, 0x28, 0x35, 0xcd, 0xc8, 0xa8, 0x20, 0x53,
+	0x63, 0x2b, 0x20, 0xd8, 0xfb, 0x18, 0xb5, 0xcc, 0x47, 0x56, 0x40, 0xb0, 0x61, 0x05, 0x04, 0x7b,
+	0x1f, 0xa7, 0xc6, 0xc5, 0xe8, 0x0a, 0x22, 0x2c, 0xf0, 0x9c, 0xfc, 0x04, 0xb5, 0x75, 0x24, 0x0b,
+	0x3c, 0x07, 0x35, 0x66, 0x21, 0x05, 0x3f, 0x09, 0x9a, 0x5e, 0x32, 0x0b, 0xf9, 0xa6, 0x46, 0x05,
+	0xe9, 0xf6, 0x29, 0x6a, 0x38, 0x26, 0xa3, 0x82, 0x9c, 0xaa, 0xa3, 0x43, 0xa1, 0x9d, 0x92, 0x52,
+	0x9f, 0xa6, 0xc6, 0xa9, 0x15, 0x8f, 0xf0, 0x28, 0x53, 0xa9, 0x85, 0xa6, 0x22, 0x30, 0xa2, 0x67,
+	0x3f, 0x4d, 0x91, 0x06, 0x91, 0x3c, 0x1a, 0x98, 0x68, 0xdc, 0xe7, 0x50, 0x38, 0xae, 0x49, 0x9e,
+	0x67, 0x00, 0x2d, 0xad, 0xe6, 0x11, 0x3e, 0x15, 0xcd, 0x73, 0x16, 0x1d, 0x51, 0x36, 0xbb, 0x52,
+	0x23, 0x9e, 0x05, 0x0a, 0xad, 0x45, 0x8f, 0x4c, 0x11, 0x59, 0x1b, 0x1a, 0xc8, 0x8b, 0x81, 0x08,
+	0x02, 0x9f, 0x83, 0x90, 0xd2, 0xa8, 0x9e, 0x08, 0x94, 0x20, 0x6f, 0x55, 0x56, 0x22, 0x60, 0xed,
+	0x79, 0x0a, 0x61, 0x27, 0x7b, 0x02, 0xee, 0x80, 0xcb, 0x1e, 0xcd, 0x9f, 0x7b, 0x15, 0x9a, 0x96,
+	0x1b, 0x5e, 0xd7, 0x3f, 0xf7, 0x64, 0x69, 0xd1, 0xe3, 0xfa, 0x27, 0x64, 0xf6, 0x3a, 0x4d, 0x07,
+	0x2d, 0x2b, 0x6c, 0x44, 0x05, 0xd1, 0x1b, 0xe8, 0x7c, 0x29, 0x88, 0xa6, 0x62, 0x1e, 0xa0, 0x3c,
+	0xae, 0xa0, 0xa3, 0x06, 0x17, 0xbc, 0x50, 0xbe, 0x91, 0xfa, 0x08, 0x15, 0xd2, 0x74, 0xcc, 0x05,
+	0x2f, 0x9c, 0xcb, 0x46, 0x1f, 0xbc, 0x84, 0xbe, 0x89, 0xfa, 0x10, 0x92, 0x29, 0xee, 0x82, 0x57,
+	0xd4, 0x53, 0x49, 0x91, 0x10, 0xec, 0xbd, 0x99, 0x7a, 0xd0, 0x35, 0x94, 0x31, 0x1a, 0x82, 0xfb,
+	0x44, 0x43, 0xb0, 0xf7, 0x16, 0xea, 0x27, 0x14, 0x55, 0xe6, 0x68, 0x08, 0xee, 0x13, 0x0d, 0xc1,
+	0xde, 0x5b, 0xa9, 0x0f, 0xa1, 0xb2, 0xcc, 0xd1, 0x10, 0xec, 0x9e, 0x42, 0x33, 0x06, 0x17, 0xa2,
+	0x00, 0xbf, 0x8d, 0xfa, 0x90, 0xb2, 0xcb, 0x8b, 0x79, 0x11, 0xe5, 0xbb, 0x8a, 0x2e, 0x32, 0x45,
+	0x23, 0xfc, 0xbc, 0x9d, 0xfa, 0x51, 0x74, 0xd8, 0xd1, 0x78, 0x44, 0xa2, 0xb4, 0xaf, 0x18, 0xe9,
+	0x85, 0x22, 0xff, 0x0e, 0xea, 0x46, 0x11, 0x66, 0x71, 0x6e, 0xa1, 0xec, 0xf7, 0x09, 0x8a, 0x60,
+	0xef, 0x9d, 0xd4, 0x8b, 0x54, 0x6a, 0x09, 0x41, 0x11, 0xdc, 0x37, 0x28, 0x82, 0xbd, 0x77, 0x51,
+	0x3f, 0x8a, 0x74, 0x4b, 0x0a, 0x8a, 0x60, 0xf7, 0x55, 0xc6, 0x2f, 0x8a, 0xf7, 0x8d, 0x1e, 0xf5,
+	0x13, 0xd3, 0x72, 0xf1, 0x6f, 0x8c, 0xf7, 0x93, 0x1b, 0xcd, 0x1b, 0x07, 0x3a, 0xcb, 0xbb, 0xa9,
+	0x2f, 0x93, 0xb8, 0x33, 0xec, 0x21, 0x68, 0x3a, 0x37, 0x1b, 0xf9, 0x86, 0xf6, 0xf3, 0x1e, 0xea,
+	0xad, 0x9f, 0xda, 0x8b, 0x7f, 0x01, 0xd0, 0xa1, 0xee, 0x46, 0x97, 0x18, 0x9c, 0x2a, 0xbd, 0xea,
+	0xbd, 0xd9, 0xf4, 0xbd, 0x4a, 0x48, 0xb2, 0x99, 0x18, 0xb8, 0xec, 0x5d, 0x3f, 0x8d, 0x2e, 0x35,
+	0x66, 0x97, 0x52, 0xeb, 0xef, 0xcd, 0xa6, 0xa9, 0xf5, 0x02, 0xfc, 0x62, 0x43, 0x4e, 0x46, 0x74,
+	0xe1, 0x76, 0x7d, 0x2d, 0x2c, 0x91, 0xff, 0x9c, 0x2d, 0x65, 0x41, 0x17, 0xc2, 0xa8, 0xd4, 0x85,
+	0xdc, 0x0a, 0x2a, 0xd0, 0xbf, 0x50, 0x33, 0xa6, 0x0b, 0x61, 0x58, 0xd1, 0x85, 0xdc, 0x8e, 0x97,
+	0xbb, 0x7f, 0xa5, 0x86, 0x4c, 0x17, 0xc2, 0xb8, 0xaa, 0x0b, 0xb9, 0x25, 0x2f, 0x6a, 0xff, 0x46,
+	0x2d, 0x0b, 0xd2, 0x52, 0xd5, 0x85, 0x12, 0x9b, 0x60, 0xef, 0xdf, 0xa9, 0x61, 0x56, 0xc3, 0x16,
+	0x3a, 0x47, 0xc1, 0x26, 0xd8, 0xfb, 0x0f, 0x6a, 0xe8, 0xea, 0xd8, 0x11, 0x4b, 0x5e, 0x82, 0xfe,
+	0x93, 0x5a, 0x0e, 0xeb, 0xd8, 0x42, 0x17, 0x72, 0x4b, 0x51, 0x21, 0xfe, 0x8b, 0x9a, 0x32, 0x5d,
+	0x08, 0x1f, 0x68, 0xba, 0x50, 0xe0, 0x0b, 0xe3, 0xff, 0xa6, 0xc6, 0x4c, 0x17, 0xf2, 0x15, 0x68,
+	0xba, 0x50, 0x78, 0x66, 0x25, 0xe3, 0x7f, 0xa8, 0x69, 0x46, 0x46, 0xa5, 0xe8, 0x42, 0x75, 0x05,
+	0x04, 0x7b, 0xff, 0x4b, 0x2d, 0xf3, 0x91, 0x15, 0x08, 0x5d, 0xa8, 0xad, 0x80, 0x60, 0xef, 0xff,
+	0xa8, 0x71, 0x31, 0xba, 0x82, 0x08, 0x0b, 0x3c, 0xbf, 0x2f, 0x0c, 0x97, 0xb2, 0xa0, 0x0b, 0x61,
+	0x5c, 0xd5, 0x85, 0xc2, 0x2f, 0x64, 0xef, 0xcf, 0x0c, 0xb3, 0xb3, 0x5d, 0xc9, 0xac, 0xa2, 0x0b,
+	0xc5, 0x6e, 0x62, 0x89, 0xf9, 0x7a, 0x6a, 0x38, 0x26, 0xa3, 0x52, 0x74, 0x21, 0xb7, 0x53, 0x72,
+	0xed, 0x67, 0xa9, 0xf1, 0x00, 0xba, 0x10, 0x3c, 0x46, 0x74, 0xa1, 0x06, 0x23, 0x64, 0xcd, 0xcf,
+	0x51, 0xa4, 0xc1, 0x74, 0xa1, 0x02, 0xa6, 0xe9, 0x42, 0x8e, 0xa7, 0xea, 0xc2, 0x9f, 0x07, 0xb4,
+	0xf4, 0xba, 0x10, 0x7c, 0x46, 0x75, 0x61, 0xb8, 0xd9, 0x95, 0x5a, 0xf1, 0x0b, 0x40, 0x61, 0x0a,
+	0x5d, 0x28, 0x52, 0x24, 0xa2, 0x0b, 0x23, 0x20, 0x82, 0xc0, 0x5f, 0x84, 0x90, 0xd2, 0xe9, 0x42,
+	0x0d, 0x4a, 0xd3, 0x85, 0xf0, 0x09, 0xb0, 0xf6, 0x4b, 0x14, 0xc2, 0x56, 0x17, 0x82, 0x83, 0x50,
+	0x17, 0x2a, 0xfe, 0xdc, 0x9f, 0x44, 0x85, 0xe6, 0xda, 0x36, 0xab, 0x72, 0x50, 0xea, 0xbe, 0x0d,
+	0x31, 0xfc, 0xb0, 0x05, 0xc0, 0x8d, 0x6b, 0xdb, 0xb4, 0x20, 0xd2, 0xff, 0x4e, 0xb5, 0x3a, 0x3b,
+	0xe7, 0x83, 0x83, 0x4d, 0x39, 0xe2, 0x9e, 0x45, 0xe3, 0x21, 0x02, 0xd4, 0xb4, 0xdf, 0x02, 0x88,
+	0x2b, 0xed, 0x21, 0x58, 0x41, 0x05, 0x8c, 0xb1, 0xa6, 0x32, 0xe4, 0x6e, 0xa0, 0x89, 0x10, 0x84,
+	0xd7, 0xd8, 0xdf, 0x06, 0x94, 0xab, 0xec, 0x51, 0xa0, 0x1a, 0x03, 0x4c, 0xa1, 0xa9, 0x8e, 0x69,
+	0x38, 0xbc, 0x42, 0xff, 0x4e, 0x6a, 0x9c, 0xd3, 0x06, 0x1c, 0x5e, 0xdf, 0x23, 0xa4, 0x11, 0xec,
+	0xfd, 0xee, 0x20, 0xa4, 0x11, 0x1c, 0x23, 0x8d, 0xe0, 0x18, 0x69, 0x04, 0x7b, 0xbf, 0x37, 0x10,
+	0x69, 0x02, 0x46, 0x25, 0x2d, 0x82, 0xc3, 0x5b, 0xcb, 0x77, 0x06, 0x22, 0x2d, 0x8a, 0xc3, 0x1b,
+	0xd3, 0x16, 0x2a, 0x86, 0x38, 0xa2, 0xd7, 0xfc, 0x3e, 0x00, 0x5d, 0x6d, 0x0f, 0xc4, 0x5b, 0x18,
+	0x20, 0x8d, 0x37, 0xb5, 0x41, 0xb7, 0x81, 0x26, 0x25, 0x75, 0x02, 0xeb, 0x0f, 0x00, 0xeb, 0x9a,
+	0x14, 0xe4, 0x6d, 0xa8, 0x60, 0x13, 0x4d, 0x7d, 0x54, 0xdb, 0x0d, 0xd0, 0x17, 0xff, 0x30, 0xf5,
+	0x6e, 0x60, 0x1d, 0x54, 0xdf, 0x0d, 0xd0, 0x54, 0x63, 0xec, 0x11, 0xec, 0xfd, 0xd1, 0x60, 0xec,
+	0x89, 0xef, 0x49, 0x63, 0x8f, 0x60, 0x03, 0x7b, 0x04, 0x7b, 0x7f, 0x3c, 0x20, 0x7b, 0x02, 0x4c,
+	0x67, 0x2f, 0xb2, 0xfd, 0x78, 0x4f, 0xff, 0x93, 0xd4, 0xdb, 0x0f, 0xba, 0xbf, 0xbe, 0xfd, 0xb8,
+	0x22, 0xd0, 0xd2, 0x09, 0x14, 0xc1, 0x9f, 0xa6, 0x4f, 0x27, 0xe6, 0x20, 0x92, 0x4e, 0xa0, 0x27,
+	0xd4, 0xdd, 0x00, 0x7a, 0xe2, 0xcf, 0x52, 0xef, 0x06, 0xa6, 0x3c, 0xf4, 0xdd, 0x00, 0x62, 0x64,
+	0x1b, 0x1d, 0x0a, 0x41, 0x14, 0x31, 0xf2, 0xe7, 0x80, 0xf4, 0x0a, 0x7b, 0xa4, 0x50, 0x80, 0x00,
+	0x5a, 0xb1, 0x19, 0x19, 0x76, 0xcf, 0xa3, 0xa9, 0x08, 0xa2, 0x68, 0xab, 0x7f, 0x01, 0xa0, 0xd7,
+	0xa6, 0x04, 0xe5, 0x63, 0x80, 0x7b, 0xa8, 0x19, 0xff, 0xc4, 0xdd, 0x45, 0x87, 0x43, 0x68, 0x55,
+	0xa2, 0xfc, 0x25, 0x00, 0x2f, 0xdb, 0x03, 0x4b, 0x55, 0x02, 0xb0, 0x93, 0xcd, 0xe8, 0xb8, 0x7b,
+	0x07, 0x3a, 0xa2, 0x54, 0x5f, 0x45, 0xad, 0x7c, 0x17, 0x50, 0x57, 0xd2, 0xd4, 0xe0, 0x50, 0xa7,
+	0x00, 0xac, 0xdb, 0x8c, 0x7d, 0xe0, 0xde, 0x8d, 0xbc, 0x18, 0xae, 0x60, 0xfa, 0xaf, 0x00, 0xfa,
+	0x54, 0x6a, 0x68, 0x8d, 0xeb, 0x23, 0x4d, 0xd3, 0x67, 0x62, 0xff, 0xb2, 0x46, 0x07, 0x9a, 0xe3,
+	0xaf, 0x53, 0xed, 0x5f, 0xd6, 0xf9, 0xa5, 0xe8, 0xa0, 0xfb, 0x37, 0x1c, 0x12, 0xc9, 0xb8, 0xab,
+	0xa0, 0xfc, 0x4d, 0xaa, 0x64, 0x84, 0xc6, 0x2f, 0x61, 0x68, 0x32, 0xca, 0x31, 0x81, 0xd3, 0x55,
+	0x70, 0xfe, 0x36, 0x15, 0xce, 0x69, 0x03, 0x8e, 0x1c, 0x53, 0x48, 0x23, 0x18, 0x60, 0xfe, 0x2e,
+	0x2d, 0x69, 0x04, 0xc7, 0x48, 0x83, 0x21, 0x95, 0x34, 0x81, 0xf2, 0xf7, 0xa9, 0x49, 0x53, 0x61,
+	0x04, 0x69, 0x3a, 0x4e, 0x57, 0xc1, 0xf9, 0x87, 0xd4, 0xa4, 0x45, 0x71, 0xe4, 0x98, 0x68, 0x69,
+	0xbc, 0x8d, 0x02, 0xd0, 0x3f, 0xa6, 0x6a, 0x69, 0xbc, 0xef, 0x4b, 0x24, 0xfa, 0x6d, 0x28, 0x83,
+	0x21, 0x75, 0xac, 0x44, 0x03, 0xd2, 0x3f, 0xa5, 0xa3, 0x8e, 0x79, 0x88, 0x50, 0x17, 0x8e, 0xb9,
+	0x25, 0x84, 0xda, 0xad, 0x7a, 0x7b, 0x03, 0x20, 0x9e, 0xce, 0x95, 0x9c, 0xf2, 0x81, 0xea, 0x50,
+	0x30, 0xca, 0x06, 0x99, 0xc5, 0x2c, 0x3a, 0x08, 0x16, 0x20, 0x4f, 0x9f, 0xa1, 0x26, 0xb9, 0xea,
+	0x50, 0x00, 0xf3, 0x40, 0x2e, 0xbf, 0x0c, 0x8d, 0x81, 0x0d, 0xd7, 0xca, 0xcf, 0x52, 0xa3, 0xc9,
+	0xea, 0x50, 0x00, 0x53, 0xb9, 0xd8, 0x0d, 0xad, 0xb8, 0xd2, 0x7d, 0x8e, 0x5a, 0x15, 0x42, 0x2b,
+	0x2e, 0x55, 0x55, 0x3c, 0x82, 0xbd, 0xe7, 0xa9, 0x51, 0x56, 0xc5, 0x23, 0x58, 0xc7, 0x23, 0xd8,
+	0xfb, 0x0c, 0x35, 0x72, 0x35, 0x3c, 0xd5, 0x8a, 0x8b, 0xc4, 0xcf, 0x52, 0xab, 0x61, 0x0d, 0x8f,
+	0x60, 0xf7, 0xe5, 0xa8, 0x00, 0x56, 0x42, 0x76, 0x7d, 0x8e, 0x9a, 0x8d, 0x54, 0x87, 0x02, 0x98,
+	0x2d, 0x24, 0x5a, 0x19, 0x8d, 0x73, 0x4c, 0x61, 0xf8, 0x79, 0x6a, 0x38, 0x51, 0x1d, 0x0a, 0xc0,
+	0x41, 0x28, 0xaf, 0xc2, 0x08, 0x40, 0x5b, 0xfd, 0x32, 0x35, 0xcb, 0x84, 0x11, 0x80, 0x3a, 0xd2,
+	0x51, 0x09, 0xf6, 0x7e, 0x85, 0x5a, 0xe5, 0x75, 0x54, 0x76, 0x80, 0xa0, 0xa1, 0x12, 0xec, 0xfd,
+	0x2a, 0x35, 0x2c, 0x46, 0x50, 0xd5, 0x68, 0xb9, 0x26, 0x79, 0x81, 0xda, 0x39, 0x61, 0xb4, 0x5c,
+	0x54, 0x48, 0xe6, 0x40, 0x51, 0x7c, 0x81, 0x5a, 0x8d, 0x4a, 0xe6, 0x40, 0x12, 0x84, 0x11, 0x80,
+	0x1e, 0xf8, 0x22, 0x35, 0x1a, 0x0b, 0x23, 0x80, 0x8e, 0xbe, 0x86, 0x8a, 0x60, 0xa3, 0xb4, 0xf3,
+	0x2f, 0xe5, 0xd2, 0x3f, 0xc6, 0xad, 0x0e, 0x05, 0x10, 0xaa, 0x6c, 0xe1, 0xb7, 0xa2, 0x43, 0x2a,
+	0x84, 0xe8, 0x2a, 0x5f, 0xce, 0x0d, 0xf4, 0x8a, 0x4d, 0x75, 0x28, 0x98, 0x94, 0x40, 0xa2, 0x8b,
+	0xac, 0x23, 0x18, 0xd4, 0x1a, 0xf6, 0x57, 0x72, 0x03, 0xbc, 0x5f, 0x53, 0x1d, 0x0a, 0x26, 0x98,
+	0x4b, 0xa5, 0x49, 0xaf, 0x22, 0x57, 0x6c, 0x5c, 0xa5, 0x43, 0x7f, 0x35, 0x97, 0xe6, 0x59, 0x74,
+	0x75, 0x28, 0x28, 0xf2, 0xed, 0x2e, 0xbb, 0xf1, 0x39, 0x74, 0x44, 0x07, 0x10, 0xa4, 0x7d, 0x2d,
+	0x97, 0xf2, 0xcd, 0x9a, 0xea, 0x50, 0x70, 0x48, 0x85, 0x11, 0x84, 0xfd, 0x18, 0xaf, 0x1c, 0xc0,
+	0xd4, 0xd7, 0x73, 0xd6, 0xaf, 0x09, 0xde, 0x44, 0x67, 0x0b, 0xa6, 0x14, 0x5f, 0x32, 0x37, 0x60,
+	0x8f, 0x2e, 0x78, 0xdf, 0x10, 0x9b, 0x74, 0x4c, 0xd9, 0xa4, 0x0b, 0x51, 0x3b, 0xdf, 0xfb, 0xa6,
+	0xc9, 0xce, 0x8f, 0xda, 0x2d, 0x7a, 0xdf, 0x32, 0xd9, 0x2d, 0xba, 0x27, 0xd1, 0x61, 0x9e, 0x41,
+	0xfa, 0x03, 0xad, 0x7b, 0xf3, 0xf2, 0x85, 0x9e, 0xaa, 0x13, 0xc0, 0x37, 0xa8, 0x3f, 0xcf, 0xba,
+	0x4a, 0xd0, 0x1e, 0x7d, 0x98, 0xf5, 0xbe, 0xbc, 0xfa, 0x76, 0x4f, 0xd5, 0xe1, 0x5c, 0x46, 0x9e,
+	0x65, 0x5d, 0x8d, 0xa6, 0xa2, 0xd3, 0x79, 0x25, 0xbd, 0x2f, 0xaf, 0xbc, 0xea, 0x53, 0x75, 0x82,
+	0xc3, 0xfa, 0x74, 0x5e, 0x59, 0xaf, 0x8a, 0xcf, 0xe7, 0x35, 0xf6, 0xfe, 0xbc, 0x7c, 0xef, 0x27,
+	0x3e, 0xfd, 0xb4, 0x78, 0x0c, 0x66, 0x5a, 0x3d, 0xc1, 0xde, 0x03, 0xf9, 0xe8, 0x4b, 0x40, 0xc6,
+	0x08, 0x08, 0x4e, 0x8a, 0x80, 0x60, 0xef, 0xc1, 0xbc, 0xf2, 0x46, 0x90, 0x39, 0x02, 0x82, 0x93,
+	0x22, 0x20, 0xd8, 0x7b, 0x28, 0x2f, 0x5f, 0x0f, 0x32, 0x47, 0xc0, 0x1e, 0x7d, 0x4d, 0x47, 0xa7,
+	0x8b, 0x2a, 0xfd, 0x70, 0x5e, 0x7d, 0x57, 0xa8, 0xea, 0x04, 0x47, 0x74, 0x0f, 0xa2, 0xbe, 0x5f,
+	0x87, 0xbc, 0x58, 0x04, 0xc2, 0xc7, 0x23, 0x79, 0xed, 0xc5, 0xa1, 0xaa, 0x13, 0x4c, 0x45, 0xa2,
+	0x10, 0xb5, 0xff, 0xea, 0x38, 0x95, 0xd0, 0x05, 0xde, 0x9f, 0xd7, 0xde, 0x22, 0x8a, 0xf3, 0x08,
+	0x7d, 0x21, 0x29, 0x10, 0x82, 0xbd, 0x0f, 0xe4, 0xd5, 0x57, 0x8a, 0x12, 0x02, 0x21, 0x38, 0x39,
+	0x10, 0x82, 0xbd, 0x47, 0xf3, 0xda, 0xfb, 0x45, 0x49, 0x81, 0x10, 0xec, 0x5e, 0x1f, 0xff, 0x42,
+	0x78, 0x63, 0x79, 0x2c, 0x6f, 0x78, 0xd9, 0x28, 0xfe, 0xcd, 0xf0, 0x86, 0x73, 0x83, 0x61, 0x63,
+	0x40, 0xeb, 0x79, 0x3c, 0x6f, 0x7e, 0xf3, 0xc8, 0xb0, 0x47, 0xa0, 0x2b, 0xdd, 0x14, 0xe7, 0x16,
+	0xfa, 0xd3, 0x13, 0xf9, 0xfe, 0xaf, 0x21, 0xc5, 0xc9, 0x86, 0x16, 0xf6, 0x5a, 0x34, 0x13, 0x75,
+	0xa8, 0x34, 0xb3, 0x27, 0xf3, 0x03, 0xbf, 0x93, 0x54, 0x75, 0x82, 0x69, 0x1d, 0x58, 0xfd, 0xfb,
+	0xf4, 0xe2, 0x78, 0xc6, 0x28, 0x4d, 0xe1, 0xa9, 0xfc, 0x00, 0x2f, 0x28, 0x55, 0x9d, 0xe0, 0x68,
+	0x34, 0xcf, 0x42, 0x9b, 0x99, 0x9f, 0x42, 0x63, 0x5a, 0xef, 0x7b, 0x11, 0xdf, 0x34, 0x9f, 0xb9,
+	0x0b, 0x21, 0xa5, 0x1f, 0xbe, 0x98, 0xc8, 0xd7, 0xa0, 0x82, 0xf6, 0x26, 0xa7, 0x2d, 0x38, 0x75,
+	0xa0, 0xbd, 0x13, 0x91, 0xce, 0x81, 0x72, 0x78, 0x6e, 0xed, 0xe0, 0x6a, 0x54, 0x8c, 0x1e, 0x8e,
+	0xbb, 0x45, 0x94, 0xbd, 0xad, 0x7e, 0x9e, 0x39, 0x39, 0x10, 0xd0, 0xff, 0x75, 0x0f, 0xa3, 0xdc,
+	0x1d, 0x6b, 0x8d, 0x6e, 0xdd, 0xcb, 0xb0, 0x31, 0xf8, 0x47, 0x25, 0x73, 0x85, 0x33, 0x73, 0x0d,
+	0x9a, 0x8c, 0x9d, 0x7c, 0xef, 0xe5, 0x20, 0xa7, 0x3a, 0x78, 0x05, 0x72, 0xe3, 0x87, 0xda, 0x7b,
+	0x79, 0x98, 0x34, 0x7b, 0x38, 0xbd, 0x7f, 0x0f, 0x85, 0xc4, 0x20, 0xf8, 0x29, 0xdd, 0x5e, 0x0e,
+	0xb2, 0xc9, 0x41, 0xec, 0xd3, 0x83, 0x9b, 0x1c, 0xc4, 0x3e, 0x3d, 0x0c, 0xab, 0x1e, 0x96, 0xd1,
+	0x21, 0xc3, 0xb9, 0xf0, 0x5e, 0x2e, 0x46, 0x54, 0x17, 0x2b, 0xe8, 0xb0, 0xe9, 0xb8, 0x77, 0x2f,
+	0x1f, 0x13, 0x66, 0x2e, 0xe5, 0x39, 0xee, 0x5e, 0x0e, 0x32, 0x7d, 0xe2, 0xd8, 0x27, 0x15, 0xf9,
+	0x7e, 0x71, 0xec, 0xd3, 0x47, 0xd1, 0xfc, 0x85, 0x28, 0x07, 0xaa, 0x7b, 0x79, 0x70, 0x12, 0x36,
+	0x85, 0x3c, 0x2a, 0xdd, 0xcb, 0xc3, 0xa8, 0x99, 0x4b, 0x79, 0x0a, 0xba, 0x97, 0x83, 0x31, 0xd5,
+	0xc1, 0x79, 0x74, 0xc4, 0x78, 0xb8, 0x69, 0x70, 0xf2, 0x2a, 0xd5, 0x49, 0xda, 0x87, 0xb9, 0x0a,
+	0xf4, 0xdd, 0xc8, 0x4b, 0x3a, 0xe2, 0x34, 0xa0, 0xdf, 0xa8, 0xa2, 0x0f, 0xf0, 0x80, 0x57, 0x59,
+	0xc0, 0x6b, 0xd1, 0x94, 0xf9, 0xa8, 0xd3, 0x00, 0xff, 0x23, 0x3a, 0x7c, 0xca, 0x27, 0xbe, 0x0a,
+	0x78, 0x17, 0x4d, 0x27, 0x9c, 0x78, 0x1a, 0xd0, 0xaf, 0xd3, 0xa9, 0xb7, 0x7d, 0x08, 0xac, 0xc5,
+	0x3c, 0x93, 0x7c, 0xda, 0x69, 0x40, 0x7e, 0xa5, 0x1e, 0x77, 0x8a, 0xc7, 0xc2, 0xb1, 0xdd, 0xaa,
+	0x9f, 0x79, 0xaa, 0x98, 0xb9, 0xbd, 0x7a, 0x09, 0x24, 0x4c, 0xe4, 0x38, 0x53, 0xf5, 0x30, 0xb9,
+	0x3f, 0x0f, 0xa7, 0x93, 0x3d, 0x14, 0xf6, 0xd7, 0xcf, 0xf4, 0x33, 0x48, 0xd5, 0x41, 0x76, 0xff,
+	0x41, 0x24, 0x78, 0x70, 0xf7, 0x1f, 0x44, 0x82, 0x87, 0xe1, 0xbd, 0x3c, 0x40, 0x09, 0x8d, 0x9e,
+	0x08, 0xaa, 0x2e, 0x46, 0xf6, 0x19, 0x86, 0x7e, 0xd4, 0xa7, 0x7a, 0x18, 0xdd, 0xcb, 0xc3, 0x95,
+	0x08, 0xc9, 0xbf, 0xc7, 0xad, 0x75, 0x49, 0x15, 0x4d, 0x9d, 0xba, 0xab, 0x53, 0x6f, 0xed, 0x6e,
+	0xb5, 0x5b, 0x83, 0x69, 0x2c, 0xd5, 0xd3, 0x40, 0x5a, 0x69, 0x76, 0x0e, 0x8d, 0x4a, 0xb1, 0x3d,
+	0x8a, 0x40, 0x17, 0x17, 0x87, 0xe8, 0xff, 0xae, 0x04, 0xcb, 0x3f, 0x7a, 0x53, 0xd1, 0x71, 0x0f,
+	0xa2, 0x91, 0x6b, 0xab, 0xcb, 0xc1, 0xab, 0x6f, 0x38, 0x55, 0xcc, 0x5c, 0x36, 0x7a, 0xe0, 0x9e,
+	0x5a, 0xf1, 0xc2, 0x85, 0x0b, 0x17, 0x32, 0xfe, 0x59, 0x34, 0x5d, 0x17, 0x8b, 0x58, 0xd5, 0xee,
+	0x2c, 0xba, 0x16, 0xa2, 0xd3, 0xbb, 0xa7, 0xc6, 0x58, 0x3e, 0x52, 0x8f, 0x52, 0x43, 0xbf, 0x22,
+	0xbf, 0x8e, 0x3c, 0x03, 0x08, 0xfc, 0x41, 0x6e, 0x83, 0xf2, 0x86, 0x1a, 0xcb, 0xd6, 0xa9, 0x18,
+	0x0a, 0xcb, 0x6d, 0x7f, 0x13, 0x1d, 0x35, 0xc0, 0xec, 0xda, 0xe3, 0xbc, 0xb1, 0xc6, 0x72, 0x7a,
+	0x3a, 0x86, 0x03, 0x25, 0x20, 0x01, 0xa8, 0x6b, 0x0f, 0xf4, 0xa6, 0x1a, 0x4b, 0xfd, 0x38, 0x10,
+	0x54, 0x8a, 0x64, 0xe2, 0x08, 0xb6, 0xc2, 0x79, 0x73, 0x8d, 0x55, 0x08, 0x23, 0x71, 0x04, 0xf7,
+	0x21, 0xce, 0x12, 0xe7, 0x2d, 0x35, 0x56, 0x47, 0xcc, 0xc4, 0x25, 0x02, 0x75, 0xed, 0x81, 0xde,
+	0x5a, 0x63, 0xe5, 0xc6, 0x4c, 0x1c, 0xc1, 0xfe, 0x16, 0x9a, 0x31, 0x00, 0x89, 0x93, 0x0b, 0x1b,
+	0xa4, 0xb7, 0xd5, 0x58, 0x55, 0xf2, 0x62, 0x48, 0xbc, 0x8a, 0xf9, 0xb7, 0xa1, 0x8b, 0x4c, 0xe4,
+	0xa5, 0xc1, 0x7a, 0x7b, 0x8d, 0x89, 0xd6, 0xa3, 0x71, 0xfa, 0xb8, 0xb7, 0x84, 0x0d, 0xb1, 0x01,
+	0xaf, 0xf6, 0x59, 0x20, 0xbd, 0xa3, 0xc6, 0xd4, 0x6d, 0x7c, 0x43, 0x30, 0x6d, 0xdc, 0x8f, 0x3e,
+	0xcb, 0x2f, 0xea, 0x9d, 0x35, 0xa6, 0x81, 0x13, 0xe8, 0x23, 0xb8, 0x2f, 0x7d, 0x96, 0x58, 0xef,
+	0xaa, 0x31, 0xad, 0x9c, 0x44, 0x5f, 0xe2, 0xfe, 0x83, 0xc3, 0x1e, 0x2b, 0xa8, 0x5e, 0x8d, 0x89,
+	0xea, 0xf8, 0xfe, 0x03, 0x4d, 0x9e, 0x94, 0x51, 0x70, 0xb8, 0x63, 0x03, 0xf4, 0xee, 0x1a, 0xeb,
+	0x02, 0x86, 0x8c, 0x82, 0x13, 0x5f, 0xf3, 0x86, 0x60, 0x67, 0x45, 0x56, 0x38, 0xef, 0xa9, 0x31,
+	0x89, 0x1e, 0xdf, 0x10, 0x4c, 0xe0, 0xfb, 0x0f, 0x38, 0xe8, 0x12, 0x03, 0x8e, 0x3c, 0x42, 0xb2,
+	0x02, 0x7b, 0x6f, 0x6d, 0x00, 0x29, 0x3f, 0x13, 0x5b, 0x62, 0xf8, 0x99, 0xff, 0xb8, 0x83, 0x4a,
+	0x89, 0xcb, 0xe4, 0x8f, 0x07, 0xac, 0x56, 0x7a, 0x6f, 0x6d, 0x30, 0xd9, 0x7f, 0x89, 0x79, 0xb1,
+	0xfc, 0x63, 0xff, 0x61, 0x07, 0x7d, 0x9f, 0x61, 0xbd, 0xca, 0x73, 0x19, 0xab, 0xd5, 0xbe, 0xaf,
+	0x36, 0xc8, 0x5f, 0x09, 0x17, 0xc5, 0xd6, 0x2a, 0x3f, 0xf4, 0xef, 0x73, 0xd0, 0xa5, 0xc6, 0x1e,
+	0x21, 0x8f, 0xf1, 0xac, 0x96, 0x7a, 0x5f, 0x2d, 0xd5, 0x9f, 0x14, 0x17, 0x1b, 0x3a, 0x4b, 0xf8,
+	0xa9, 0xff, 0xa8, 0x83, 0x66, 0xfb, 0x2c, 0x32, 0xcd, 0x06, 0xb8, 0xbf, 0x96, 0xf6, 0x0f, 0x90,
+	0x4b, 0x93, 0x96, 0x2a, 0xbe, 0xfc, 0x87, 0x1c, 0x24, 0xd3, 0x4d, 0xbf, 0x69, 0x6d, 0xb3, 0xc2,
+	0x07, 0x6a, 0xec, 0x71, 0x94, 0xcd, 0x9b, 0x36, 0x66, 0x01, 0x1b, 0x24, 0xac, 0xc6, 0x6f, 0xa8,
+	0x35, 0x46, 0x7f, 0x60, 0x64, 0x97, 0x4c, 0x3d, 0xf5, 0xba, 0xb8, 0x44, 0xd3, 0x9e, 0x2f, 0xf9,
+	0xdb, 0x6a, 0xe9, 0x8c, 0x3c, 0x63, 0xb2, 0xcb, 0x86, 0x9e, 0x7e, 0xdd, 0x7c, 0x3a, 0x0e, 0x08,
+	0xba, 0xf1, 0x76, 0xb5, 0xdb, 0x45, 0x1f, 0x4b, 0xd9, 0xed, 0xea, 0x9e, 0x76, 0x5d, 0xdd, 0x8b,
+	0x23, 0x72, 0x05, 0xb9, 0x6d, 0x86, 0x4c, 0x21, 0x21, 0xef, 0xef, 0xa9, 0xd7, 0xdd, 0x0d, 0x88,
+	0x5c, 0x4a, 0x76, 0x12, 0x69, 0xb5, 0xec, 0xb2, 0x0f, 0xf4, 0xe2, 0xd7, 0xe5, 0xcd, 0xd4, 0x12,
+	0xdc, 0x8f, 0x5a, 0x4b, 0xd8, 0x07, 0x7b, 0xda, 0x75, 0xfb, 0x04, 0x6a, 0x09, 0xee, 0x47, 0xad,
+	0x25, 0xe4, 0x43, 0x3d, 0xf5, 0xba, 0x7e, 0x02, 0xb5, 0x04, 0xfb, 0x1d, 0x55, 0xc2, 0xc4, 0x9e,
+	0xca, 0x59, 0x41, 0x3e, 0xdc, 0xd3, 0xaf, 0xfb, 0x1f, 0x8d, 0x83, 0x0a, 0xdd, 0x79, 0x27, 0xba,
+	0xd8, 0x48, 0x6d, 0x1a, 0xd8, 0x47, 0x7a, 0x91, 0x9f, 0x0b, 0x98, 0x31, 0xd0, 0x2b, 0x34, 0xe8,
+	0xed, 0xe6, 0x9d, 0x64, 0x2f, 0x42, 0xdf, 0xdf, 0x8b, 0xfc, 0xdc, 0x80, 0x61, 0x1b, 0x81, 0x1e,
+	0xed, 0xc7, 0xb0, 0xe5, 0x97, 0xfa, 0x81, 0x9e, 0xfe, 0x73, 0x05, 0x49, 0x0c, 0x13, 0xdc, 0x9f,
+	0x61, 0x4b, 0xd8, 0x47, 0x7b, 0x91, 0x9f, 0x3b, 0x48, 0x64, 0x98, 0x60, 0xff, 0xbc, 0x79, 0x0b,
+	0xa7, 0xd0, 0xa9, 0x8f, 0xf5, 0x8c, 0x3f, 0x97, 0x60, 0xd8, 0xcb, 0x5c, 0xb8, 0xbe, 0x2e, 0x21,
+	0x61, 0xed, 0x95, 0xeb, 0xe3, 0xbd, 0xa4, 0x9f, 0x5b, 0x30, 0xe5, 0x2e, 0xa8, 0xd9, 0xd7, 0x3b,
+	0xe6, 0xbd, 0x65, 0xaf, 0x67, 0x9f, 0xe8, 0xed, 0xf5, 0x7b, 0x0d, 0x86, 0xcd, 0x06, 0x5a, 0xf7,
+	0x09, 0x4d, 0x94, 0x99, 0x9e, 0x97, 0x5a, 0xad, 0xe4, 0xc9, 0xde, 0xf7, 0xe0, 0x07, 0x1f, 0x2e,
+	0x8a, 0x2f, 0x56, 0xaa, 0xde, 0xc7, 0x34, 0xd5, 0x6b, 0x7e, 0xc6, 0x6a, 0xb5, 0xe4, 0xa7, 0x7a,
+	0x03, 0xfd, 0x62, 0xc4, 0x25, 0xa6, 0xda, 0x2c, 0x55, 0xda, 0xba, 0x7a, 0xe4, 0xa4, 0x5d, 0x16,
+	0xb4, 0x5b, 0xe4, 0x77, 0x1d, 0x76, 0xb3, 0x50, 0x9e, 0x39, 0x05, 0xca, 0x15, 0x43, 0x7f, 0x43,
+	0x15, 0x2d, 0xfa, 0x65, 0x43, 0x2b, 0x98, 0x0f, 0x32, 0x18, 0xf5, 0xd0, 0x29, 0x50, 0xaf, 0x28,
+	0xfa, 0xe7, 0xd4, 0x1d, 0x1b, 0xb9, 0xac, 0x68, 0x05, 0xf4, 0x21, 0x06, 0xa4, 0x9e, 0x3a, 0x05,
+	0xda, 0x15, 0xc7, 0x04, 0xa4, 0x14, 0x92, 0xe1, 0xc3, 0x0c, 0xa9, 0x60, 0x40, 0xe2, 0x5a, 0x21,
+	0x91, 0x3b, 0xcb, 0xa2, 0xf7, 0x11, 0x06, 0x94, 0x35, 0x73, 0x47, 0x70, 0x1f, 0xee, 0x2c, 0x81,
+	0x3e, 0xca, 0x80, 0xdc, 0x04, 0xee, 0x12, 0x91, 0x52, 0x68, 0x82, 0x8f, 0x31, 0xa4, 0xe1, 0x04,
+	0xee, 0x08, 0xf6, 0x6f, 0x55, 0x0b, 0x68, 0xf4, 0xb2, 0xa7, 0x15, 0xd4, 0xc7, 0x19, 0x94, 0x7a,
+	0xf4, 0x14, 0xe8, 0x57, 0x44, 0xfd, 0x86, 0xda, 0x16, 0x63, 0x97, 0x45, 0xad, 0xc0, 0x3e, 0xc1,
+	0xc0, 0xd4, 0xb3, 0xa7, 0x20, 0x72, 0xc5, 0x34, 0x61, 0x57, 0xd8, 0xb7, 0xfd, 0x4f, 0x32, 0xa8,
+	0x8c, 0x61, 0x57, 0x40, 0xb3, 0xef, 0xc3, 0xa0, 0xe5, 0x97, 0xf5, 0x29, 0x86, 0x94, 0x4f, 0x62,
+	0x90, 0xe0, 0xbe, 0x0c, 0x5a, 0x82, 0x7d, 0x9a, 0x81, 0x15, 0x13, 0x19, 0x4c, 0xdc, 0x85, 0x29,
+	0xda, 0xfa, 0xd3, 0x0c, 0xcb, 0x31, 0xec, 0x42, 0xde, 0xc6, 0x13, 0x32, 0xcb, 0xbe, 0x8b, 0x3f,
+	0xc3, 0x90, 0x46, 0x4d, 0x99, 0x05, 0x2d, 0xdb, 0xbc, 0x2b, 0xec, 0x1b, 0xf6, 0xb3, 0x0c, 0x68,
+	0xcc, 0xb0, 0x2b, 0xa0, 0x2b, 0x3f, 0xa8, 0x9d, 0x40, 0x19, 0x6e, 0xfb, 0x5a, 0xa1, 0x3d, 0xc7,
+	0xd0, 0x06, 0x3f, 0x82, 0x0a, 0xa2, 0x77, 0x84, 0xa9, 0x7a, 0x28, 0x25, 0xae, 0x33, 0xcd, 0x09,
+	0xc4, 0xf3, 0x6c, 0xa9, 0xdf, 0x93, 0x33, 0xa8, 0xc0, 0x70, 0xc9, 0xd8, 0x7f, 0x44, 0x93, 0x3b,
+	0xa6, 0xfb, 0xc6, 0x56, 0xcb, 0xfd, 0x0c, 0x5f, 0xee, 0xc0, 0x87, 0x50, 0x41, 0xec, 0x96, 0xb2,
+	0x7f, 0xbf, 0x76, 0x08, 0x65, 0xbc, 0xb0, 0x6c, 0xb5, 0xd6, 0xcf, 0xf2, 0x5d, 0x90, 0xfe, 0x14,
+	0x2a, 0x88, 0x5f, 0x73, 0xa6, 0x72, 0x6c, 0xb6, 0xcf, 0x2a, 0xd3, 0xec, 0x81, 0xcf, 0x71, 0x52,
+	0x07, 0x3a, 0x86, 0x0a, 0x8c, 0xf7, 0xa4, 0xfd, 0x87, 0xd5, 0x63, 0x28, 0xfd, 0x86, 0xb3, 0xcd,
+	0x12, 0x3f, 0xcf, 0x96, 0x98, 0xf2, 0x1c, 0x4a, 0xbf, 0x67, 0x9d, 0xb0, 0x9c, 0x95, 0x82, 0x78,
+	0x55, 0xbf, 0xdb, 0xda, 0x6a, 0xb7, 0x56, 0xa6, 0xe3, 0xef, 0x48, 0xb2, 0x0f, 0x2e, 0x5b, 0x40,
+	0x07, 0xd5, 0xf7, 0xc4, 0x4d, 0x0f, 0x44, 0x91, 0x3b, 0x26, 0x1f, 0x88, 0xbe, 0xe0, 0xac, 0xbc,
+	0xe6, 0xc7, 0x6b, 0xb1, 0x65, 0x1f, 0x67, 0xcb, 0x3e, 0xd3, 0xdd, 0x38, 0xbe, 0xd5, 0xea, 0xd4,
+	0x77, 0x5a, 0x6b, 0x0d, 0xf6, 0x3b, 0xb7, 0x6c, 0x74, 0xf7, 0x78, 0xa3, 0xbe, 0xb9, 0x76, 0xf6,
+	0xfc, 0xf1, 0xa4, 0x9f, 0xc4, 0xfd, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x4a, 0x85, 0x2d, 0x80,
+	0x2d, 0x57, 0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20180125_92554152/test.proto b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20180125_92554152/test.proto
new file mode 100644
index 000000000..a714d830b
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20180125_92554152/test.proto
@@ -0,0 +1,333 @@
+// 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.
+
+syntax = "proto2";
+
+package google.golang.org.proto2_20180125;
+option go_package = "google.golang.org/protobuf/internal/testprotos/legacy/proto2_20180125_92554152";
+
+enum SiblingEnum {
+	ALPHA   = 0;
+	BRAVO   = 10;
+	CHARLIE = 200;
+}
+
+message SiblingMessage {
+	optional string  f1 = 1;
+	required string  f2 = 2;
+	repeated string  f3 = 3;
+	optional Message f4 = 4;
+}
+
+message Message {
+	enum ChildEnum {
+		ALPHA   = 0;
+		BRAVO   = 1;
+		CHARLIE = 2;
+	}
+	message ChildMessage {
+		optional string  f1 = 1;
+		required string  f2 = 2;
+		repeated string  f3 = 3;
+	    optional Message f4 = 4;
+	}
+	optional group NamedGroup = 1 {
+		optional string  f1 = 1;
+		required string  f2 = 2;
+		repeated string  f3 = 3;
+	    optional Message f4 = 4;
+	}
+
+	// Optional fields.
+	optional bool     optional_bool     = 100;
+	optional int32    optional_int32    = 101;
+	optional sint32   optional_sint32   = 102;
+	optional uint32   optional_uint32   = 103;
+	optional int64    optional_int64    = 104;
+	optional sint64   optional_sint64   = 105;
+	optional uint64   optional_uint64   = 106;
+	optional fixed32  optional_fixed32  = 107;
+	optional sfixed32 optional_sfixed32 = 108;
+	optional float    optional_float    = 109;
+	optional fixed64  optional_fixed64  = 110;
+	optional sfixed64 optional_sfixed64 = 111;
+	optional double   optional_double   = 112;
+	optional string   optional_string   = 113;
+	optional bytes    optional_bytes    = 114;
+
+	optional ChildEnum      optional_child_enum      = 115;
+	optional ChildMessage   optional_child_message   = 116;
+	optional NamedGroup     optional_named_group     = 117;
+	optional SiblingEnum    optional_sibling_enum    = 118;
+	optional SiblingMessage optional_sibling_message = 119;
+	optional group OptionalGroup = 120 {
+		optional string f1 = 1;
+		required string f2 = 2;
+		repeated string f3 = 3;
+	}
+
+	// Optional default fields.
+	optional bool      defaulted_bool     = 200 [default = true];
+	optional int32     defaulted_int32    = 201 [default = -12345];
+	optional sint32    defaulted_sint32   = 202 [default = -3200];
+	optional uint32    defaulted_uint32   = 203 [default = 3200];
+	optional int64     defaulted_int64    = 204 [default = -123456789];
+	optional sint64    defaulted_sint64   = 205 [default = -6400];
+	optional uint64    defaulted_uint64   = 206 [default = 6400];
+	optional fixed32   defaulted_fixed32  = 207 [default = 320000];
+	optional sfixed32  defaulted_sfixed32 = 208 [default = -320000];
+	optional float     defaulted_float    = 209 [default = 3.14159];
+	optional fixed64   defaulted_fixed64  = 210 [default = 640000];
+	optional sfixed64  defaulted_sfixed64 = 211 [default = -640000];
+	optional double    defaulted_double   = 212 [default = 3.14159265359];
+	optional string    defaulted_string   = 213 [default = "hello, \"world!\"\n"];
+	optional bytes     defaulted_bytes    = 214 [default = "dead\xde\xad\xbe\xefbeef"];
+
+	optional ChildEnum   defaulted_child_enum   = 215 [default = ALPHA];
+	optional SiblingEnum defaulted_sibling_enum = 216 [default = ALPHA];
+
+	// Required fields.
+	required bool     required_bool     = 300;
+	required int32    required_int32    = 301;
+	required sint32   required_sint32   = 302;
+	required uint32   required_uint32   = 303;
+	required int64    required_int64    = 304;
+	required sint64   required_sint64   = 305;
+	required uint64   required_uint64   = 306;
+	required fixed32  required_fixed32  = 307;
+	required sfixed32 required_sfixed32 = 308;
+	required float    required_float    = 309;
+	required fixed64  required_fixed64  = 310;
+	required sfixed64 required_sfixed64 = 311;
+	required double   required_double   = 312;
+	required string   required_string   = 313;
+	required bytes    required_bytes    = 314;
+
+	required ChildEnum      required_child_enum      = 315;
+	required ChildMessage   required_child_message   = 316;
+	required NamedGroup     required_named_group     = 317;
+	required SiblingEnum    required_sibling_enum    = 318;
+	required SiblingMessage required_sibling_message = 319;
+	required group RequiredGroup = 320 {
+		optional string f1 = 1;
+		required string f2 = 2;
+		repeated string f3 = 3;
+	}
+	// Required default fields.
+	required bool      required_defaulted_bool     = 400 [default = true];
+	required int32     required_defaulted_int32    = 401 [default = -12345];
+	required sint32    required_defaulted_sint32   = 402 [default = -3200];
+	required uint32    required_defaulted_uint32   = 403 [default = 3200];
+	required int64     required_defaulted_int64    = 404 [default = -123456789];
+	required sint64    required_defaulted_sint64   = 405 [default = -6400];
+	required uint64    required_defaulted_uint64   = 406 [default = 6400];
+	required fixed32   required_defaulted_fixed32  = 407 [default = 320000];
+	required sfixed32  required_defaulted_sfixed32 = 408 [default = -320000];
+	required float     required_defaulted_float    = 409 [default = 3.14159];
+	required fixed64   required_defaulted_fixed64  = 410 [default = 640000];
+	required sfixed64  required_defaulted_sfixed64 = 411 [default = -640000];
+	required double    required_defaulted_double   = 412 [default = 3.14159265359];
+	required string    required_defaulted_string   = 413 [default = "hello, \"world!\"\n"];
+	required bytes     required_defaulted_bytes    = 414 [default = "dead\xde\xad\xbe\xefbeef"];
+
+	required ChildEnum   required_defaulted_child_enum   = 415 [default = ALPHA];
+	required SiblingEnum required_defaulted_sibling_enum = 416 [default = ALPHA];
+
+	// Repeated fields.
+	repeated bool     repeated_bool     = 500;
+	repeated int32    repeated_int32    = 501;
+	repeated sint32   repeated_sint32   = 502;
+	repeated uint32   repeated_uint32   = 503;
+	repeated int64    repeated_int64    = 504;
+	repeated sint64   repeated_sint64   = 505;
+	repeated uint64   repeated_uint64   = 506;
+	repeated fixed32  repeated_fixed32  = 507;
+	repeated sfixed32 repeated_sfixed32 = 508;
+	repeated float    repeated_float    = 509;
+	repeated fixed64  repeated_fixed64  = 510;
+	repeated sfixed64 repeated_sfixed64 = 511;
+	repeated double   repeated_double   = 512;
+	repeated string   repeated_string   = 513;
+	repeated bytes    repeated_bytes    = 514;
+
+	repeated ChildEnum      repeated_child_enum      = 515;
+	repeated ChildMessage   repeated_child_message   = 516;
+	repeated NamedGroup     repeated_named_group     = 517;
+	repeated SiblingEnum    repeated_sibling_enum    = 518;
+	repeated SiblingMessage repeated_sibling_message = 519;
+	repeated group RepeatedGroup = 520 {
+		optional string f1 = 1;
+		required string f2 = 2;
+		repeated string f3 = 3;
+	}
+
+	// Map fields.
+	map<bool, bool>     map_bool_bool     = 600;
+	map<bool, int32>    map_bool_int32    = 601;
+	map<bool, sint32>   map_bool_sint32   = 602;
+	map<bool, uint32>   map_bool_uint32   = 603;
+	map<bool, int64>    map_bool_int64    = 604;
+	map<bool, sint64>   map_bool_sint64   = 605;
+	map<bool, uint64>   map_bool_uint64   = 606;
+	map<bool, fixed32>  map_bool_fixed32  = 607;
+	map<bool, sfixed32> map_bool_sfixed32 = 608;
+	map<bool, float>    map_bool_float    = 609;
+	map<bool, fixed64>  map_bool_fixed64  = 610;
+	map<bool, sfixed64> map_bool_sfixed64 = 611;
+	map<bool, double>   map_bool_double   = 612;
+	map<bool, string>   map_bool_string   = 613;
+	map<bool, bytes>    map_bool_bytes    = 614;
+
+	map<bool, ChildEnum>      map_bool_child_enum      = 615;
+	map<bool, ChildMessage>   map_bool_child_message   = 616;
+	map<bool, NamedGroup>     map_bool_named_group     = 617;
+	map<bool, SiblingEnum>    map_bool_sibling_enum    = 618;
+	map<bool, SiblingMessage> map_bool_sibling_message = 619;
+
+	map<int32, bool>   map_int32_bool   = 620;
+	map<sint32, bool>  map_sint32_bool  = 621;
+	map<uint32, bool>  map_uint32_bool  = 622;
+	map<int64, bool>   map_int64_bool   = 623;
+	map<sint64, bool>  map_sint64_bool  = 624;
+	map<uint64, bool>  map_uint64_bool  = 625;
+	map<fixed32, bool> map_fixed32_bool = 626;
+	map<string, bool>  map_string_bool  = 627;
+
+	// Oneof fields.
+	oneof oneof_union {
+		bool     oneof_bool     = 700;
+		int32    oneof_int32    = 701;
+		sint32   oneof_sint32   = 702;
+		uint32   oneof_uint32   = 703;
+		int64    oneof_int64    = 704;
+		sint64   oneof_sint64   = 705;
+		uint64   oneof_uint64   = 706;
+		fixed32  oneof_fixed32  = 707;
+		sfixed32 oneof_sfixed32 = 708;
+		float    oneof_float    = 709;
+		fixed64  oneof_fixed64  = 710;
+		sfixed64 oneof_sfixed64 = 711;
+		double   oneof_double   = 712;
+		string   oneof_string   = 713;
+		bytes    oneof_bytes    = 714;
+
+		ChildEnum      oneof_child_enum      = 715;
+		ChildMessage   oneof_child_message   = 716;
+		NamedGroup     oneof_named_group     = 717;
+		SiblingEnum    oneof_sibling_enum    = 718;
+		SiblingMessage oneof_sibling_message = 719;
+		group OneofGroup = 720 {
+			optional string f1 = 1;
+			required string f2 = 2;
+			repeated string f3 = 3;
+		}
+
+		string oneof_string1 = 721;
+		string oneof_string2 = 722;
+		string oneof_string3 = 723;
+	}
+
+	// Oneof default fields.
+	oneof oneof_defaulted_union {
+		bool      oneof_defaulted_bool     = 800 [default = true];
+		int32     oneof_defaulted_int32    = 801 [default = -12345];
+		sint32    oneof_defaulted_sint32   = 802 [default = -3200];
+		uint32    oneof_defaulted_uint32   = 803 [default = 3200];
+		int64     oneof_defaulted_int64    = 804 [default = -123456789];
+		sint64    oneof_defaulted_sint64   = 805 [default = -6400];
+		uint64    oneof_defaulted_uint64   = 806 [default = 6400];
+		fixed32   oneof_defaulted_fixed32  = 807 [default = 320000];
+		sfixed32  oneof_defaulted_sfixed32 = 808 [default = -320000];
+		float     oneof_defaulted_float    = 809 [default = 3.14159];
+		fixed64   oneof_defaulted_fixed64  = 810 [default = 640000];
+		sfixed64  oneof_defaulted_sfixed64 = 811 [default = -640000];
+		double    oneof_defaulted_double   = 812 [default = 3.14159265359];
+		string    oneof_defaulted_string   = 813 [default = "hello, \"world!\"\n"];
+		bytes     oneof_defaulted_bytes    = 814 [default = "dead\xde\xad\xbe\xefbeef"];
+
+		ChildEnum   oneof_defaulted_child_enum   = 815 [default = ALPHA];
+		SiblingEnum oneof_defaulted_sibling_enum = 816 [default = ALPHA];
+	}
+
+	// Extension fields.
+	extend Message {
+		// Optional fields.
+		optional bool     extension_optional_bool     = 10000;
+		optional int32    extension_optional_int32    = 10001;
+		optional sint32   extension_optional_sint32   = 10002;
+		optional uint32   extension_optional_uint32   = 10003;
+		optional int64    extension_optional_int64    = 10004;
+		optional sint64   extension_optional_sint64   = 10005;
+		optional uint64   extension_optional_uint64   = 10006;
+		optional fixed32  extension_optional_fixed32  = 10007;
+		optional sfixed32 extension_optional_sfixed32 = 10008;
+		optional float    extension_optional_float    = 10009;
+		optional fixed64  extension_optional_fixed64  = 10010;
+		optional sfixed64 extension_optional_sfixed64 = 10011;
+		optional double   extension_optional_double   = 10012;
+		optional string   extension_optional_string   = 10013;
+		optional bytes    extension_optional_bytes    = 10014;
+
+		optional ChildEnum      extension_optional_child_enum      = 10015;
+		optional ChildMessage   extension_optional_child_message   = 10016;
+		optional NamedGroup     extension_optional_named_group     = 10017;
+		optional SiblingEnum    extension_optional_sibling_enum    = 10018;
+		optional SiblingMessage extension_optional_sibling_message = 10019;
+		optional group ExtensionOptionalGroup = 10020 {
+			optional string f1 = 1;
+			required string f2 = 2;
+			repeated string f3 = 3;
+		}
+
+		// Optional default fields.
+		optional bool      extension_defaulted_bool     = 20000 [default = true];
+		optional int32     extension_defaulted_int32    = 20001 [default = -12345];
+		optional sint32    extension_defaulted_sint32   = 20002 [default = -3200];
+		optional uint32    extension_defaulted_uint32   = 20003 [default = 3200];
+		optional int64     extension_defaulted_int64    = 20004 [default = -123456789];
+		optional sint64    extension_defaulted_sint64   = 20005 [default = -6400];
+		optional uint64    extension_defaulted_uint64   = 20006 [default = 6400];
+		optional fixed32   extension_defaulted_fixed32  = 20007 [default = 320000];
+		optional sfixed32  extension_defaulted_sfixed32 = 20008 [default = -320000];
+		optional float     extension_defaulted_float    = 20009 [default = 3.14159];
+		optional fixed64   extension_defaulted_fixed64  = 20010 [default = 640000];
+		optional sfixed64  extension_defaulted_sfixed64 = 20011 [default = -640000];
+		optional double    extension_defaulted_double   = 20012 [default = 3.14159265359];
+		optional string    extension_defaulted_string   = 20013 [default = "hello, \"world!\"\n"];
+		optional bytes     extension_defaulted_bytes    = 20014 [default = "dead\xde\xad\xbe\xefbeef"];
+
+		optional ChildEnum   extension_defaulted_child_enum   = 20015 [default = ALPHA];
+		optional SiblingEnum extension_defaulted_sibling_enum = 20016 [default = ALPHA];
+
+		// Repeated fields.
+		repeated bool     extension_repeated_bool     = 30000;
+		repeated int32    extension_repeated_int32    = 30001;
+		repeated sint32   extension_repeated_sint32   = 30002;
+		repeated uint32   extension_repeated_uint32   = 30003;
+		repeated int64    extension_repeated_int64    = 30004;
+		repeated sint64   extension_repeated_sint64   = 30005;
+		repeated uint64   extension_repeated_uint64   = 30006;
+		repeated fixed32  extension_repeated_fixed32  = 30007;
+		repeated sfixed32 extension_repeated_sfixed32 = 30008;
+		repeated float    extension_repeated_float    = 30009;
+		repeated fixed64  extension_repeated_fixed64  = 30010;
+		repeated sfixed64 extension_repeated_sfixed64 = 30011;
+		repeated double   extension_repeated_double   = 30012;
+		repeated string   extension_repeated_string   = 30013;
+		repeated bytes    extension_repeated_bytes    = 30014;
+
+		repeated ChildEnum      extension_repeated_child_enum      = 30015;
+		repeated ChildMessage   extension_repeated_child_message   = 30016;
+		repeated NamedGroup     extension_repeated_named_group     = 30017;
+		repeated SiblingEnum    extension_repeated_sibling_enum    = 30018;
+		repeated SiblingMessage extension_repeated_sibling_message = 30019;
+		repeated group ExtensionRepeatedGroup = 30020 {
+			optional string f1 = 1;
+			required string f2 = 2;
+			repeated string f3 = 3;
+		}
+	}
+
+	extensions 10000 to max;
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20180430_b4deda09/test.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20180430_b4deda09/test.pb.go
new file mode 100644
index 000000000..b6e4899d1
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20180430_b4deda09/test.pb.go
@@ -0,0 +1,3822 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: proto2_20180430_b4deda09/test.proto
+
+package proto2_20180430_b4deda09 // import "google.golang.org/protobuf/internal/testprotos/legacy/proto2_20180430_b4deda09"
+
+import proto "google.golang.org/protobuf/internal/protolegacy"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type SiblingEnum int32
+
+const (
+	SiblingEnum_ALPHA   SiblingEnum = 0
+	SiblingEnum_BRAVO   SiblingEnum = 10
+	SiblingEnum_CHARLIE SiblingEnum = 200
+)
+
+var SiblingEnum_name = map[int32]string{
+	0:   "ALPHA",
+	10:  "BRAVO",
+	200: "CHARLIE",
+}
+var SiblingEnum_value = map[string]int32{
+	"ALPHA":   0,
+	"BRAVO":   10,
+	"CHARLIE": 200,
+}
+
+func (x SiblingEnum) Enum() *SiblingEnum {
+	p := new(SiblingEnum)
+	*p = x
+	return p
+}
+func (x SiblingEnum) String() string {
+	return proto.EnumName(SiblingEnum_name, int32(x))
+}
+func (x *SiblingEnum) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(SiblingEnum_value, data, "SiblingEnum")
+	if err != nil {
+		return err
+	}
+	*x = SiblingEnum(value)
+	return nil
+}
+func (SiblingEnum) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_test_a365478be18be824, []int{0}
+}
+
+type Message_ChildEnum int32
+
+const (
+	Message_ALPHA   Message_ChildEnum = 0
+	Message_BRAVO   Message_ChildEnum = 1
+	Message_CHARLIE Message_ChildEnum = 2
+)
+
+var Message_ChildEnum_name = map[int32]string{
+	0: "ALPHA",
+	1: "BRAVO",
+	2: "CHARLIE",
+}
+var Message_ChildEnum_value = map[string]int32{
+	"ALPHA":   0,
+	"BRAVO":   1,
+	"CHARLIE": 2,
+}
+
+func (x Message_ChildEnum) Enum() *Message_ChildEnum {
+	p := new(Message_ChildEnum)
+	*p = x
+	return p
+}
+func (x Message_ChildEnum) String() string {
+	return proto.EnumName(Message_ChildEnum_name, int32(x))
+}
+func (x *Message_ChildEnum) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(Message_ChildEnum_value, data, "Message_ChildEnum")
+	if err != nil {
+		return err
+	}
+	*x = Message_ChildEnum(value)
+	return nil
+}
+func (Message_ChildEnum) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_test_a365478be18be824, []int{1, 0}
+}
+
+type SiblingMessage 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"`
+	F4                   *Message `protobuf:"bytes,4,opt,name=f4" json:"f4,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *SiblingMessage) Reset()         { *m = SiblingMessage{} }
+func (m *SiblingMessage) String() string { return proto.CompactTextString(m) }
+func (*SiblingMessage) ProtoMessage()    {}
+func (*SiblingMessage) Descriptor() ([]byte, []int) {
+	return fileDescriptor_test_a365478be18be824, []int{0}
+}
+func (m *SiblingMessage) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_SiblingMessage.Unmarshal(m, b)
+}
+func (m *SiblingMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_SiblingMessage.Marshal(b, m, deterministic)
+}
+func (dst *SiblingMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SiblingMessage.Merge(dst, src)
+}
+func (m *SiblingMessage) XXX_Size() int {
+	return xxx_messageInfo_SiblingMessage.Size(m)
+}
+func (m *SiblingMessage) XXX_DiscardUnknown() {
+	xxx_messageInfo_SiblingMessage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SiblingMessage proto.InternalMessageInfo
+
+func (m *SiblingMessage) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *SiblingMessage) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *SiblingMessage) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+func (m *SiblingMessage) GetF4() *Message {
+	if m != nil {
+		return m.F4
+	}
+	return nil
+}
+
+type Message struct {
+	Namedgroup *Message_NamedGroup `protobuf:"group,1,opt,name=NamedGroup,json=namedgroup" json:"namedgroup,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      *Message_ChildEnum     `protobuf:"varint,115,opt,name=optional_child_enum,json=optionalChildEnum,enum=google.golang.org.proto2_20180430.Message_ChildEnum" json:"optional_child_enum,omitempty"`
+	OptionalChildMessage   *Message_ChildMessage  `protobuf:"bytes,116,opt,name=optional_child_message,json=optionalChildMessage" json:"optional_child_message,omitempty"`
+	OptionalNamedGroup     *Message_NamedGroup    `protobuf:"bytes,117,opt,name=optional_named_group,json=optionalNamedGroup" json:"optional_named_group,omitempty"`
+	OptionalSiblingEnum    *SiblingEnum           `protobuf:"varint,118,opt,name=optional_sibling_enum,json=optionalSiblingEnum,enum=google.golang.org.proto2_20180430.SiblingEnum" json:"optional_sibling_enum,omitempty"`
+	OptionalSiblingMessage *SiblingMessage        `protobuf:"bytes,119,opt,name=optional_sibling_message,json=optionalSiblingMessage" json:"optional_sibling_message,omitempty"`
+	Optionalgroup          *Message_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   *Message_ChildEnum `protobuf:"varint,215,opt,name=defaulted_child_enum,json=defaultedChildEnum,enum=google.golang.org.proto2_20180430.Message_ChildEnum,def=0" json:"defaulted_child_enum,omitempty"`
+	DefaultedSiblingEnum *SiblingEnum       `protobuf:"varint,216,opt,name=defaulted_sibling_enum,json=defaultedSiblingEnum,enum=google.golang.org.proto2_20180430.SiblingEnum,def=0" 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      *Message_ChildEnum     `protobuf:"varint,315,req,name=required_child_enum,json=requiredChildEnum,enum=google.golang.org.proto2_20180430.Message_ChildEnum" json:"required_child_enum,omitempty"`
+	RequiredChildMessage   *Message_ChildMessage  `protobuf:"bytes,316,req,name=required_child_message,json=requiredChildMessage" json:"required_child_message,omitempty"`
+	RequiredNamedGroup     *Message_NamedGroup    `protobuf:"bytes,317,req,name=required_named_group,json=requiredNamedGroup" json:"required_named_group,omitempty"`
+	RequiredSiblingEnum    *SiblingEnum           `protobuf:"varint,318,req,name=required_sibling_enum,json=requiredSiblingEnum,enum=google.golang.org.proto2_20180430.SiblingEnum" json:"required_sibling_enum,omitempty"`
+	RequiredSiblingMessage *SiblingMessage        `protobuf:"bytes,319,req,name=required_sibling_message,json=requiredSiblingMessage" json:"required_sibling_message,omitempty"`
+	Requiredgroup          *Message_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   *Message_ChildEnum `protobuf:"varint,415,req,name=required_defaulted_child_enum,json=requiredDefaultedChildEnum,enum=google.golang.org.proto2_20180430.Message_ChildEnum,def=0" json:"required_defaulted_child_enum,omitempty"`
+	RequiredDefaultedSiblingEnum *SiblingEnum       `protobuf:"varint,416,req,name=required_defaulted_sibling_enum,json=requiredDefaultedSiblingEnum,enum=google.golang.org.proto2_20180430.SiblingEnum,def=0" 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      []Message_ChildEnum      `protobuf:"varint,515,rep,name=repeated_child_enum,json=repeatedChildEnum,enum=google.golang.org.proto2_20180430.Message_ChildEnum" json:"repeated_child_enum,omitempty"`
+	RepeatedChildMessage   []*Message_ChildMessage  `protobuf:"bytes,516,rep,name=repeated_child_message,json=repeatedChildMessage" json:"repeated_child_message,omitempty"`
+	RepeatedNamedGroup     []*Message_NamedGroup    `protobuf:"bytes,517,rep,name=repeated_named_group,json=repeatedNamedGroup" json:"repeated_named_group,omitempty"`
+	RepeatedSiblingEnum    []SiblingEnum            `protobuf:"varint,518,rep,name=repeated_sibling_enum,json=repeatedSiblingEnum,enum=google.golang.org.proto2_20180430.SiblingEnum" json:"repeated_sibling_enum,omitempty"`
+	RepeatedSiblingMessage []*SiblingMessage        `protobuf:"bytes,519,rep,name=repeated_sibling_message,json=repeatedSiblingMessage" json:"repeated_sibling_message,omitempty"`
+	Repeatedgroup          []*Message_RepeatedGroup `protobuf:"group,520,rep,name=RepeatedGroup,json=repeatedgroup" json:"repeatedgroup,omitempty"`
+	// Map fields.
+	MapBoolBool           map[bool]bool                  `protobuf:"bytes,600,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,601,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,602,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,603,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,604,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,605,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,606,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,607,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,608,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,609,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,610,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,611,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,612,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,613,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,614,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"`
+	MapBoolChildEnum      map[bool]Message_ChildEnum     `protobuf:"bytes,615,rep,name=map_bool_child_enum,json=mapBoolChildEnum" json:"map_bool_child_enum,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=google.golang.org.proto2_20180430.Message_ChildEnum"`
+	MapBoolChildMessage   map[bool]*Message_ChildMessage `protobuf:"bytes,616,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"`
+	MapBoolNamedGroup     map[bool]*Message_NamedGroup   `protobuf:"bytes,617,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"`
+	MapBoolSiblingEnum    map[bool]SiblingEnum           `protobuf:"bytes,618,rep,name=map_bool_sibling_enum,json=mapBoolSiblingEnum" json:"map_bool_sibling_enum,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=google.golang.org.proto2_20180430.SiblingEnum"`
+	MapBoolSiblingMessage map[bool]*SiblingMessage       `protobuf:"bytes,619,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"`
+	MapInt32Bool          map[int32]bool                 `protobuf:"bytes,620,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,621,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,622,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,623,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,624,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,625,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,626,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,627,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.
+	//
+	// Types that are valid to be assigned to OneofUnion:
+	//	*Message_OneofBool
+	//	*Message_OneofInt32
+	//	*Message_OneofSint32
+	//	*Message_OneofUint32
+	//	*Message_OneofInt64
+	//	*Message_OneofSint64
+	//	*Message_OneofUint64
+	//	*Message_OneofFixed32
+	//	*Message_OneofSfixed32
+	//	*Message_OneofFloat
+	//	*Message_OneofFixed64
+	//	*Message_OneofSfixed64
+	//	*Message_OneofDouble
+	//	*Message_OneofString
+	//	*Message_OneofBytes
+	//	*Message_OneofChildEnum
+	//	*Message_OneofChildMessage
+	//	*Message_OneofNamedGroup
+	//	*Message_OneofSiblingEnum
+	//	*Message_OneofSiblingMessage
+	//	*Message_Oneofgroup
+	//	*Message_OneofString1
+	//	*Message_OneofString2
+	//	*Message_OneofString3
+	OneofUnion isMessage_OneofUnion `protobuf_oneof:"oneof_union"`
+	// Oneof default fields.
+	//
+	// Types that are valid to be assigned to OneofDefaultedUnion:
+	//	*Message_OneofDefaultedBool
+	//	*Message_OneofDefaultedInt32
+	//	*Message_OneofDefaultedSint32
+	//	*Message_OneofDefaultedUint32
+	//	*Message_OneofDefaultedInt64
+	//	*Message_OneofDefaultedSint64
+	//	*Message_OneofDefaultedUint64
+	//	*Message_OneofDefaultedFixed32
+	//	*Message_OneofDefaultedSfixed32
+	//	*Message_OneofDefaultedFloat
+	//	*Message_OneofDefaultedFixed64
+	//	*Message_OneofDefaultedSfixed64
+	//	*Message_OneofDefaultedDouble
+	//	*Message_OneofDefaultedString
+	//	*Message_OneofDefaultedBytes
+	//	*Message_OneofDefaultedChildEnum
+	//	*Message_OneofDefaultedSiblingEnum
+	OneofDefaultedUnion          isMessage_OneofDefaultedUnion `protobuf_oneof:"oneof_defaulted_union"`
+	XXX_NoUnkeyedLiteral         struct{}                      `json:"-"`
+	proto.XXX_InternalExtensions `json:"-"`
+	XXX_unrecognized             []byte `json:"-"`
+	XXX_sizecache                int32  `json:"-"`
+}
+
+func (m *Message) Reset()         { *m = Message{} }
+func (m *Message) String() string { return proto.CompactTextString(m) }
+func (*Message) ProtoMessage()    {}
+func (*Message) Descriptor() ([]byte, []int) {
+	return fileDescriptor_test_a365478be18be824, []int{1}
+}
+
+var extRange_Message = []proto.ExtensionRange{
+	{Start: 10000, End: 536870911},
+}
+
+func (*Message) ExtensionRangeArray() []proto.ExtensionRange {
+	return extRange_Message
+}
+func (m *Message) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Message.Unmarshal(m, b)
+}
+func (m *Message) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Message.Marshal(b, m, deterministic)
+}
+func (dst *Message) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Message.Merge(dst, src)
+}
+func (m *Message) XXX_Size() int {
+	return xxx_messageInfo_Message.Size(m)
+}
+func (m *Message) XXX_DiscardUnknown() {
+	xxx_messageInfo_Message.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message proto.InternalMessageInfo
+
+const Default_Message_DefaultedBool bool = true
+const Default_Message_DefaultedInt32 int32 = -12345
+const Default_Message_DefaultedSint32 int32 = -3200
+const Default_Message_DefaultedUint32 uint32 = 3200
+const Default_Message_DefaultedInt64 int64 = -123456789
+const Default_Message_DefaultedSint64 int64 = -6400
+const Default_Message_DefaultedUint64 uint64 = 6400
+const Default_Message_DefaultedFixed32 uint32 = 320000
+const Default_Message_DefaultedSfixed32 int32 = -320000
+const Default_Message_DefaultedFloat float32 = 3.14159
+const Default_Message_DefaultedFixed64 uint64 = 640000
+const Default_Message_DefaultedSfixed64 int64 = -640000
+const Default_Message_DefaultedDouble float64 = 3.14159265359
+const Default_Message_DefaultedString string = "hello, \"world!\"\n"
+
+var Default_Message_DefaultedBytes []byte = []byte("deadޭ\xbe\xefbeef")
+
+const Default_Message_DefaultedChildEnum Message_ChildEnum = Message_ALPHA
+const Default_Message_DefaultedSiblingEnum SiblingEnum = SiblingEnum_ALPHA
+const Default_Message_RequiredDefaultedBool bool = true
+const Default_Message_RequiredDefaultedInt32 int32 = -12345
+const Default_Message_RequiredDefaultedSint32 int32 = -3200
+const Default_Message_RequiredDefaultedUint32 uint32 = 3200
+const Default_Message_RequiredDefaultedInt64 int64 = -123456789
+const Default_Message_RequiredDefaultedSint64 int64 = -6400
+const Default_Message_RequiredDefaultedUint64 uint64 = 6400
+const Default_Message_RequiredDefaultedFixed32 uint32 = 320000
+const Default_Message_RequiredDefaultedSfixed32 int32 = -320000
+const Default_Message_RequiredDefaultedFloat float32 = 3.14159
+const Default_Message_RequiredDefaultedFixed64 uint64 = 640000
+const Default_Message_RequiredDefaultedSfixed64 int64 = -640000
+const Default_Message_RequiredDefaultedDouble float64 = 3.14159265359
+const Default_Message_RequiredDefaultedString string = "hello, \"world!\"\n"
+
+var Default_Message_RequiredDefaultedBytes []byte = []byte("deadޭ\xbe\xefbeef")
+
+const Default_Message_RequiredDefaultedChildEnum Message_ChildEnum = Message_ALPHA
+const Default_Message_RequiredDefaultedSiblingEnum SiblingEnum = SiblingEnum_ALPHA
+const Default_Message_OneofDefaultedBool bool = true
+const Default_Message_OneofDefaultedInt32 int32 = -12345
+const Default_Message_OneofDefaultedSint32 int32 = -3200
+const Default_Message_OneofDefaultedUint32 uint32 = 3200
+const Default_Message_OneofDefaultedInt64 int64 = -123456789
+const Default_Message_OneofDefaultedSint64 int64 = -6400
+const Default_Message_OneofDefaultedUint64 uint64 = 6400
+const Default_Message_OneofDefaultedFixed32 uint32 = 320000
+const Default_Message_OneofDefaultedSfixed32 int32 = -320000
+const Default_Message_OneofDefaultedFloat float32 = 3.14159
+const Default_Message_OneofDefaultedFixed64 uint64 = 640000
+const Default_Message_OneofDefaultedSfixed64 int64 = -640000
+const Default_Message_OneofDefaultedDouble float64 = 3.14159265359
+const Default_Message_OneofDefaultedString string = "hello, \"world!\"\n"
+
+var Default_Message_OneofDefaultedBytes []byte = []byte("deadޭ\xbe\xefbeef")
+
+const Default_Message_OneofDefaultedChildEnum Message_ChildEnum = Message_ALPHA
+const Default_Message_OneofDefaultedSiblingEnum SiblingEnum = SiblingEnum_ALPHA
+
+type isMessage_OneofUnion interface {
+	isMessage_OneofUnion()
+}
+type isMessage_OneofDefaultedUnion interface {
+	isMessage_OneofDefaultedUnion()
+}
+
+type Message_OneofBool struct {
+	OneofBool bool `protobuf:"varint,700,opt,name=oneof_bool,json=oneofBool,oneof"`
+}
+type Message_OneofInt32 struct {
+	OneofInt32 int32 `protobuf:"varint,701,opt,name=oneof_int32,json=oneofInt32,oneof"`
+}
+type Message_OneofSint32 struct {
+	OneofSint32 int32 `protobuf:"zigzag32,702,opt,name=oneof_sint32,json=oneofSint32,oneof"`
+}
+type Message_OneofUint32 struct {
+	OneofUint32 uint32 `protobuf:"varint,703,opt,name=oneof_uint32,json=oneofUint32,oneof"`
+}
+type Message_OneofInt64 struct {
+	OneofInt64 int64 `protobuf:"varint,704,opt,name=oneof_int64,json=oneofInt64,oneof"`
+}
+type Message_OneofSint64 struct {
+	OneofSint64 int64 `protobuf:"zigzag64,705,opt,name=oneof_sint64,json=oneofSint64,oneof"`
+}
+type Message_OneofUint64 struct {
+	OneofUint64 uint64 `protobuf:"varint,706,opt,name=oneof_uint64,json=oneofUint64,oneof"`
+}
+type Message_OneofFixed32 struct {
+	OneofFixed32 uint32 `protobuf:"fixed32,707,opt,name=oneof_fixed32,json=oneofFixed32,oneof"`
+}
+type Message_OneofSfixed32 struct {
+	OneofSfixed32 int32 `protobuf:"fixed32,708,opt,name=oneof_sfixed32,json=oneofSfixed32,oneof"`
+}
+type Message_OneofFloat struct {
+	OneofFloat float32 `protobuf:"fixed32,709,opt,name=oneof_float,json=oneofFloat,oneof"`
+}
+type Message_OneofFixed64 struct {
+	OneofFixed64 uint64 `protobuf:"fixed64,710,opt,name=oneof_fixed64,json=oneofFixed64,oneof"`
+}
+type Message_OneofSfixed64 struct {
+	OneofSfixed64 int64 `protobuf:"fixed64,711,opt,name=oneof_sfixed64,json=oneofSfixed64,oneof"`
+}
+type Message_OneofDouble struct {
+	OneofDouble float64 `protobuf:"fixed64,712,opt,name=oneof_double,json=oneofDouble,oneof"`
+}
+type Message_OneofString struct {
+	OneofString string `protobuf:"bytes,713,opt,name=oneof_string,json=oneofString,oneof"`
+}
+type Message_OneofBytes struct {
+	OneofBytes []byte `protobuf:"bytes,714,opt,name=oneof_bytes,json=oneofBytes,oneof"`
+}
+type Message_OneofChildEnum struct {
+	OneofChildEnum Message_ChildEnum `protobuf:"varint,715,opt,name=oneof_child_enum,json=oneofChildEnum,enum=google.golang.org.proto2_20180430.Message_ChildEnum,oneof"`
+}
+type Message_OneofChildMessage struct {
+	OneofChildMessage *Message_ChildMessage `protobuf:"bytes,716,opt,name=oneof_child_message,json=oneofChildMessage,oneof"`
+}
+type Message_OneofNamedGroup struct {
+	OneofNamedGroup *Message_NamedGroup `protobuf:"bytes,717,opt,name=oneof_named_group,json=oneofNamedGroup,oneof"`
+}
+type Message_OneofSiblingEnum struct {
+	OneofSiblingEnum SiblingEnum `protobuf:"varint,718,opt,name=oneof_sibling_enum,json=oneofSiblingEnum,enum=google.golang.org.proto2_20180430.SiblingEnum,oneof"`
+}
+type Message_OneofSiblingMessage struct {
+	OneofSiblingMessage *SiblingMessage `protobuf:"bytes,719,opt,name=oneof_sibling_message,json=oneofSiblingMessage,oneof"`
+}
+type Message_Oneofgroup struct {
+	Oneofgroup *Message_OneofGroup `protobuf:"group,720,opt,name=OneofGroup,json=oneofgroup,oneof"`
+}
+type Message_OneofString1 struct {
+	OneofString1 string `protobuf:"bytes,721,opt,name=oneof_string1,json=oneofString1,oneof"`
+}
+type Message_OneofString2 struct {
+	OneofString2 string `protobuf:"bytes,722,opt,name=oneof_string2,json=oneofString2,oneof"`
+}
+type Message_OneofString3 struct {
+	OneofString3 string `protobuf:"bytes,723,opt,name=oneof_string3,json=oneofString3,oneof"`
+}
+type Message_OneofDefaultedBool struct {
+	OneofDefaultedBool bool `protobuf:"varint,800,opt,name=oneof_defaulted_bool,json=oneofDefaultedBool,oneof,def=1"`
+}
+type Message_OneofDefaultedInt32 struct {
+	OneofDefaultedInt32 int32 `protobuf:"varint,801,opt,name=oneof_defaulted_int32,json=oneofDefaultedInt32,oneof,def=-12345"`
+}
+type Message_OneofDefaultedSint32 struct {
+	OneofDefaultedSint32 int32 `protobuf:"zigzag32,802,opt,name=oneof_defaulted_sint32,json=oneofDefaultedSint32,oneof,def=-3200"`
+}
+type Message_OneofDefaultedUint32 struct {
+	OneofDefaultedUint32 uint32 `protobuf:"varint,803,opt,name=oneof_defaulted_uint32,json=oneofDefaultedUint32,oneof,def=3200"`
+}
+type Message_OneofDefaultedInt64 struct {
+	OneofDefaultedInt64 int64 `protobuf:"varint,804,opt,name=oneof_defaulted_int64,json=oneofDefaultedInt64,oneof,def=-123456789"`
+}
+type Message_OneofDefaultedSint64 struct {
+	OneofDefaultedSint64 int64 `protobuf:"zigzag64,805,opt,name=oneof_defaulted_sint64,json=oneofDefaultedSint64,oneof,def=-6400"`
+}
+type Message_OneofDefaultedUint64 struct {
+	OneofDefaultedUint64 uint64 `protobuf:"varint,806,opt,name=oneof_defaulted_uint64,json=oneofDefaultedUint64,oneof,def=6400"`
+}
+type Message_OneofDefaultedFixed32 struct {
+	OneofDefaultedFixed32 uint32 `protobuf:"fixed32,807,opt,name=oneof_defaulted_fixed32,json=oneofDefaultedFixed32,oneof,def=320000"`
+}
+type Message_OneofDefaultedSfixed32 struct {
+	OneofDefaultedSfixed32 int32 `protobuf:"fixed32,808,opt,name=oneof_defaulted_sfixed32,json=oneofDefaultedSfixed32,oneof,def=-320000"`
+}
+type Message_OneofDefaultedFloat struct {
+	OneofDefaultedFloat float32 `protobuf:"fixed32,809,opt,name=oneof_defaulted_float,json=oneofDefaultedFloat,oneof,def=3.14159"`
+}
+type Message_OneofDefaultedFixed64 struct {
+	OneofDefaultedFixed64 uint64 `protobuf:"fixed64,810,opt,name=oneof_defaulted_fixed64,json=oneofDefaultedFixed64,oneof,def=640000"`
+}
+type Message_OneofDefaultedSfixed64 struct {
+	OneofDefaultedSfixed64 int64 `protobuf:"fixed64,811,opt,name=oneof_defaulted_sfixed64,json=oneofDefaultedSfixed64,oneof,def=-640000"`
+}
+type Message_OneofDefaultedDouble struct {
+	OneofDefaultedDouble float64 `protobuf:"fixed64,812,opt,name=oneof_defaulted_double,json=oneofDefaultedDouble,oneof,def=3.14159265359"`
+}
+type Message_OneofDefaultedString struct {
+	OneofDefaultedString string `protobuf:"bytes,813,opt,name=oneof_defaulted_string,json=oneofDefaultedString,oneof,def=hello, \"world!\"\n"`
+}
+type Message_OneofDefaultedBytes struct {
+	OneofDefaultedBytes []byte `protobuf:"bytes,814,opt,name=oneof_defaulted_bytes,json=oneofDefaultedBytes,oneof,def=dead\\336\\255\\276\\357beef"`
+}
+type Message_OneofDefaultedChildEnum struct {
+	OneofDefaultedChildEnum Message_ChildEnum `protobuf:"varint,815,opt,name=oneof_defaulted_child_enum,json=oneofDefaultedChildEnum,enum=google.golang.org.proto2_20180430.Message_ChildEnum,oneof,def=0"`
+}
+type Message_OneofDefaultedSiblingEnum struct {
+	OneofDefaultedSiblingEnum SiblingEnum `protobuf:"varint,816,opt,name=oneof_defaulted_sibling_enum,json=oneofDefaultedSiblingEnum,enum=google.golang.org.proto2_20180430.SiblingEnum,oneof,def=0"`
+}
+
+func (*Message_OneofBool) isMessage_OneofUnion()                          {}
+func (*Message_OneofInt32) isMessage_OneofUnion()                         {}
+func (*Message_OneofSint32) isMessage_OneofUnion()                        {}
+func (*Message_OneofUint32) isMessage_OneofUnion()                        {}
+func (*Message_OneofInt64) isMessage_OneofUnion()                         {}
+func (*Message_OneofSint64) isMessage_OneofUnion()                        {}
+func (*Message_OneofUint64) isMessage_OneofUnion()                        {}
+func (*Message_OneofFixed32) isMessage_OneofUnion()                       {}
+func (*Message_OneofSfixed32) isMessage_OneofUnion()                      {}
+func (*Message_OneofFloat) isMessage_OneofUnion()                         {}
+func (*Message_OneofFixed64) isMessage_OneofUnion()                       {}
+func (*Message_OneofSfixed64) isMessage_OneofUnion()                      {}
+func (*Message_OneofDouble) isMessage_OneofUnion()                        {}
+func (*Message_OneofString) isMessage_OneofUnion()                        {}
+func (*Message_OneofBytes) isMessage_OneofUnion()                         {}
+func (*Message_OneofChildEnum) isMessage_OneofUnion()                     {}
+func (*Message_OneofChildMessage) isMessage_OneofUnion()                  {}
+func (*Message_OneofNamedGroup) isMessage_OneofUnion()                    {}
+func (*Message_OneofSiblingEnum) isMessage_OneofUnion()                   {}
+func (*Message_OneofSiblingMessage) isMessage_OneofUnion()                {}
+func (*Message_Oneofgroup) isMessage_OneofUnion()                         {}
+func (*Message_OneofString1) isMessage_OneofUnion()                       {}
+func (*Message_OneofString2) isMessage_OneofUnion()                       {}
+func (*Message_OneofString3) isMessage_OneofUnion()                       {}
+func (*Message_OneofDefaultedBool) isMessage_OneofDefaultedUnion()        {}
+func (*Message_OneofDefaultedInt32) isMessage_OneofDefaultedUnion()       {}
+func (*Message_OneofDefaultedSint32) isMessage_OneofDefaultedUnion()      {}
+func (*Message_OneofDefaultedUint32) isMessage_OneofDefaultedUnion()      {}
+func (*Message_OneofDefaultedInt64) isMessage_OneofDefaultedUnion()       {}
+func (*Message_OneofDefaultedSint64) isMessage_OneofDefaultedUnion()      {}
+func (*Message_OneofDefaultedUint64) isMessage_OneofDefaultedUnion()      {}
+func (*Message_OneofDefaultedFixed32) isMessage_OneofDefaultedUnion()     {}
+func (*Message_OneofDefaultedSfixed32) isMessage_OneofDefaultedUnion()    {}
+func (*Message_OneofDefaultedFloat) isMessage_OneofDefaultedUnion()       {}
+func (*Message_OneofDefaultedFixed64) isMessage_OneofDefaultedUnion()     {}
+func (*Message_OneofDefaultedSfixed64) isMessage_OneofDefaultedUnion()    {}
+func (*Message_OneofDefaultedDouble) isMessage_OneofDefaultedUnion()      {}
+func (*Message_OneofDefaultedString) isMessage_OneofDefaultedUnion()      {}
+func (*Message_OneofDefaultedBytes) isMessage_OneofDefaultedUnion()       {}
+func (*Message_OneofDefaultedChildEnum) isMessage_OneofDefaultedUnion()   {}
+func (*Message_OneofDefaultedSiblingEnum) isMessage_OneofDefaultedUnion() {}
+
+func (m *Message) GetOneofUnion() isMessage_OneofUnion {
+	if m != nil {
+		return m.OneofUnion
+	}
+	return nil
+}
+func (m *Message) GetOneofDefaultedUnion() isMessage_OneofDefaultedUnion {
+	if m != nil {
+		return m.OneofDefaultedUnion
+	}
+	return nil
+}
+
+func (m *Message) GetNamedgroup() *Message_NamedGroup {
+	if m != nil {
+		return m.Namedgroup
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalBool() bool {
+	if m != nil && m.OptionalBool != nil {
+		return *m.OptionalBool
+	}
+	return false
+}
+
+func (m *Message) GetOptionalInt32() int32 {
+	if m != nil && m.OptionalInt32 != nil {
+		return *m.OptionalInt32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSint32() int32 {
+	if m != nil && m.OptionalSint32 != nil {
+		return *m.OptionalSint32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalUint32() uint32 {
+	if m != nil && m.OptionalUint32 != nil {
+		return *m.OptionalUint32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalInt64() int64 {
+	if m != nil && m.OptionalInt64 != nil {
+		return *m.OptionalInt64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSint64() int64 {
+	if m != nil && m.OptionalSint64 != nil {
+		return *m.OptionalSint64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalUint64() uint64 {
+	if m != nil && m.OptionalUint64 != nil {
+		return *m.OptionalUint64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalFixed32() uint32 {
+	if m != nil && m.OptionalFixed32 != nil {
+		return *m.OptionalFixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSfixed32() int32 {
+	if m != nil && m.OptionalSfixed32 != nil {
+		return *m.OptionalSfixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalFloat() float32 {
+	if m != nil && m.OptionalFloat != nil {
+		return *m.OptionalFloat
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalFixed64() uint64 {
+	if m != nil && m.OptionalFixed64 != nil {
+		return *m.OptionalFixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSfixed64() int64 {
+	if m != nil && m.OptionalSfixed64 != nil {
+		return *m.OptionalSfixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalDouble() float64 {
+	if m != nil && m.OptionalDouble != nil {
+		return *m.OptionalDouble
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalString() string {
+	if m != nil && m.OptionalString != nil {
+		return *m.OptionalString
+	}
+	return ""
+}
+
+func (m *Message) GetOptionalBytes() []byte {
+	if m != nil {
+		return m.OptionalBytes
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalChildEnum() Message_ChildEnum {
+	if m != nil && m.OptionalChildEnum != nil {
+		return *m.OptionalChildEnum
+	}
+	return Message_ALPHA
+}
+
+func (m *Message) GetOptionalChildMessage() *Message_ChildMessage {
+	if m != nil {
+		return m.OptionalChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalNamedGroup() *Message_NamedGroup {
+	if m != nil {
+		return m.OptionalNamedGroup
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalSiblingEnum() SiblingEnum {
+	if m != nil && m.OptionalSiblingEnum != nil {
+		return *m.OptionalSiblingEnum
+	}
+	return SiblingEnum_ALPHA
+}
+
+func (m *Message) GetOptionalSiblingMessage() *SiblingMessage {
+	if m != nil {
+		return m.OptionalSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalgroup() *Message_OptionalGroup {
+	if m != nil {
+		return m.Optionalgroup
+	}
+	return nil
+}
+
+func (m *Message) GetDefaultedBool() bool {
+	if m != nil && m.DefaultedBool != nil {
+		return *m.DefaultedBool
+	}
+	return Default_Message_DefaultedBool
+}
+
+func (m *Message) GetDefaultedInt32() int32 {
+	if m != nil && m.DefaultedInt32 != nil {
+		return *m.DefaultedInt32
+	}
+	return Default_Message_DefaultedInt32
+}
+
+func (m *Message) GetDefaultedSint32() int32 {
+	if m != nil && m.DefaultedSint32 != nil {
+		return *m.DefaultedSint32
+	}
+	return Default_Message_DefaultedSint32
+}
+
+func (m *Message) GetDefaultedUint32() uint32 {
+	if m != nil && m.DefaultedUint32 != nil {
+		return *m.DefaultedUint32
+	}
+	return Default_Message_DefaultedUint32
+}
+
+func (m *Message) GetDefaultedInt64() int64 {
+	if m != nil && m.DefaultedInt64 != nil {
+		return *m.DefaultedInt64
+	}
+	return Default_Message_DefaultedInt64
+}
+
+func (m *Message) GetDefaultedSint64() int64 {
+	if m != nil && m.DefaultedSint64 != nil {
+		return *m.DefaultedSint64
+	}
+	return Default_Message_DefaultedSint64
+}
+
+func (m *Message) GetDefaultedUint64() uint64 {
+	if m != nil && m.DefaultedUint64 != nil {
+		return *m.DefaultedUint64
+	}
+	return Default_Message_DefaultedUint64
+}
+
+func (m *Message) GetDefaultedFixed32() uint32 {
+	if m != nil && m.DefaultedFixed32 != nil {
+		return *m.DefaultedFixed32
+	}
+	return Default_Message_DefaultedFixed32
+}
+
+func (m *Message) GetDefaultedSfixed32() int32 {
+	if m != nil && m.DefaultedSfixed32 != nil {
+		return *m.DefaultedSfixed32
+	}
+	return Default_Message_DefaultedSfixed32
+}
+
+func (m *Message) GetDefaultedFloat() float32 {
+	if m != nil && m.DefaultedFloat != nil {
+		return *m.DefaultedFloat
+	}
+	return Default_Message_DefaultedFloat
+}
+
+func (m *Message) GetDefaultedFixed64() uint64 {
+	if m != nil && m.DefaultedFixed64 != nil {
+		return *m.DefaultedFixed64
+	}
+	return Default_Message_DefaultedFixed64
+}
+
+func (m *Message) GetDefaultedSfixed64() int64 {
+	if m != nil && m.DefaultedSfixed64 != nil {
+		return *m.DefaultedSfixed64
+	}
+	return Default_Message_DefaultedSfixed64
+}
+
+func (m *Message) GetDefaultedDouble() float64 {
+	if m != nil && m.DefaultedDouble != nil {
+		return *m.DefaultedDouble
+	}
+	return Default_Message_DefaultedDouble
+}
+
+func (m *Message) GetDefaultedString() string {
+	if m != nil && m.DefaultedString != nil {
+		return *m.DefaultedString
+	}
+	return Default_Message_DefaultedString
+}
+
+func (m *Message) GetDefaultedBytes() []byte {
+	if m != nil && m.DefaultedBytes != nil {
+		return m.DefaultedBytes
+	}
+	return append([]byte(nil), Default_Message_DefaultedBytes...)
+}
+
+func (m *Message) GetDefaultedChildEnum() Message_ChildEnum {
+	if m != nil && m.DefaultedChildEnum != nil {
+		return *m.DefaultedChildEnum
+	}
+	return Default_Message_DefaultedChildEnum
+}
+
+func (m *Message) GetDefaultedSiblingEnum() SiblingEnum {
+	if m != nil && m.DefaultedSiblingEnum != nil {
+		return *m.DefaultedSiblingEnum
+	}
+	return Default_Message_DefaultedSiblingEnum
+}
+
+func (m *Message) GetRequiredBool() bool {
+	if m != nil && m.RequiredBool != nil {
+		return *m.RequiredBool
+	}
+	return false
+}
+
+func (m *Message) GetRequiredInt32() int32 {
+	if m != nil && m.RequiredInt32 != nil {
+		return *m.RequiredInt32
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredSint32() int32 {
+	if m != nil && m.RequiredSint32 != nil {
+		return *m.RequiredSint32
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredUint32() uint32 {
+	if m != nil && m.RequiredUint32 != nil {
+		return *m.RequiredUint32
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredInt64() int64 {
+	if m != nil && m.RequiredInt64 != nil {
+		return *m.RequiredInt64
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredSint64() int64 {
+	if m != nil && m.RequiredSint64 != nil {
+		return *m.RequiredSint64
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredUint64() uint64 {
+	if m != nil && m.RequiredUint64 != nil {
+		return *m.RequiredUint64
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredFixed32() uint32 {
+	if m != nil && m.RequiredFixed32 != nil {
+		return *m.RequiredFixed32
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredSfixed32() int32 {
+	if m != nil && m.RequiredSfixed32 != nil {
+		return *m.RequiredSfixed32
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredFloat() float32 {
+	if m != nil && m.RequiredFloat != nil {
+		return *m.RequiredFloat
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredFixed64() uint64 {
+	if m != nil && m.RequiredFixed64 != nil {
+		return *m.RequiredFixed64
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredSfixed64() int64 {
+	if m != nil && m.RequiredSfixed64 != nil {
+		return *m.RequiredSfixed64
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredDouble() float64 {
+	if m != nil && m.RequiredDouble != nil {
+		return *m.RequiredDouble
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredString() string {
+	if m != nil && m.RequiredString != nil {
+		return *m.RequiredString
+	}
+	return ""
+}
+
+func (m *Message) GetRequiredBytes() []byte {
+	if m != nil {
+		return m.RequiredBytes
+	}
+	return nil
+}
+
+func (m *Message) GetRequiredChildEnum() Message_ChildEnum {
+	if m != nil && m.RequiredChildEnum != nil {
+		return *m.RequiredChildEnum
+	}
+	return Message_ALPHA
+}
+
+func (m *Message) GetRequiredChildMessage() *Message_ChildMessage {
+	if m != nil {
+		return m.RequiredChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRequiredNamedGroup() *Message_NamedGroup {
+	if m != nil {
+		return m.RequiredNamedGroup
+	}
+	return nil
+}
+
+func (m *Message) GetRequiredSiblingEnum() SiblingEnum {
+	if m != nil && m.RequiredSiblingEnum != nil {
+		return *m.RequiredSiblingEnum
+	}
+	return SiblingEnum_ALPHA
+}
+
+func (m *Message) GetRequiredSiblingMessage() *SiblingMessage {
+	if m != nil {
+		return m.RequiredSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRequiredgroup() *Message_RequiredGroup {
+	if m != nil {
+		return m.Requiredgroup
+	}
+	return nil
+}
+
+func (m *Message) GetRequiredDefaultedBool() bool {
+	if m != nil && m.RequiredDefaultedBool != nil {
+		return *m.RequiredDefaultedBool
+	}
+	return Default_Message_RequiredDefaultedBool
+}
+
+func (m *Message) GetRequiredDefaultedInt32() int32 {
+	if m != nil && m.RequiredDefaultedInt32 != nil {
+		return *m.RequiredDefaultedInt32
+	}
+	return Default_Message_RequiredDefaultedInt32
+}
+
+func (m *Message) GetRequiredDefaultedSint32() int32 {
+	if m != nil && m.RequiredDefaultedSint32 != nil {
+		return *m.RequiredDefaultedSint32
+	}
+	return Default_Message_RequiredDefaultedSint32
+}
+
+func (m *Message) GetRequiredDefaultedUint32() uint32 {
+	if m != nil && m.RequiredDefaultedUint32 != nil {
+		return *m.RequiredDefaultedUint32
+	}
+	return Default_Message_RequiredDefaultedUint32
+}
+
+func (m *Message) GetRequiredDefaultedInt64() int64 {
+	if m != nil && m.RequiredDefaultedInt64 != nil {
+		return *m.RequiredDefaultedInt64
+	}
+	return Default_Message_RequiredDefaultedInt64
+}
+
+func (m *Message) GetRequiredDefaultedSint64() int64 {
+	if m != nil && m.RequiredDefaultedSint64 != nil {
+		return *m.RequiredDefaultedSint64
+	}
+	return Default_Message_RequiredDefaultedSint64
+}
+
+func (m *Message) GetRequiredDefaultedUint64() uint64 {
+	if m != nil && m.RequiredDefaultedUint64 != nil {
+		return *m.RequiredDefaultedUint64
+	}
+	return Default_Message_RequiredDefaultedUint64
+}
+
+func (m *Message) GetRequiredDefaultedFixed32() uint32 {
+	if m != nil && m.RequiredDefaultedFixed32 != nil {
+		return *m.RequiredDefaultedFixed32
+	}
+	return Default_Message_RequiredDefaultedFixed32
+}
+
+func (m *Message) GetRequiredDefaultedSfixed32() int32 {
+	if m != nil && m.RequiredDefaultedSfixed32 != nil {
+		return *m.RequiredDefaultedSfixed32
+	}
+	return Default_Message_RequiredDefaultedSfixed32
+}
+
+func (m *Message) GetRequiredDefaultedFloat() float32 {
+	if m != nil && m.RequiredDefaultedFloat != nil {
+		return *m.RequiredDefaultedFloat
+	}
+	return Default_Message_RequiredDefaultedFloat
+}
+
+func (m *Message) GetRequiredDefaultedFixed64() uint64 {
+	if m != nil && m.RequiredDefaultedFixed64 != nil {
+		return *m.RequiredDefaultedFixed64
+	}
+	return Default_Message_RequiredDefaultedFixed64
+}
+
+func (m *Message) GetRequiredDefaultedSfixed64() int64 {
+	if m != nil && m.RequiredDefaultedSfixed64 != nil {
+		return *m.RequiredDefaultedSfixed64
+	}
+	return Default_Message_RequiredDefaultedSfixed64
+}
+
+func (m *Message) GetRequiredDefaultedDouble() float64 {
+	if m != nil && m.RequiredDefaultedDouble != nil {
+		return *m.RequiredDefaultedDouble
+	}
+	return Default_Message_RequiredDefaultedDouble
+}
+
+func (m *Message) GetRequiredDefaultedString() string {
+	if m != nil && m.RequiredDefaultedString != nil {
+		return *m.RequiredDefaultedString
+	}
+	return Default_Message_RequiredDefaultedString
+}
+
+func (m *Message) GetRequiredDefaultedBytes() []byte {
+	if m != nil && m.RequiredDefaultedBytes != nil {
+		return m.RequiredDefaultedBytes
+	}
+	return append([]byte(nil), Default_Message_RequiredDefaultedBytes...)
+}
+
+func (m *Message) GetRequiredDefaultedChildEnum() Message_ChildEnum {
+	if m != nil && m.RequiredDefaultedChildEnum != nil {
+		return *m.RequiredDefaultedChildEnum
+	}
+	return Default_Message_RequiredDefaultedChildEnum
+}
+
+func (m *Message) GetRequiredDefaultedSiblingEnum() SiblingEnum {
+	if m != nil && m.RequiredDefaultedSiblingEnum != nil {
+		return *m.RequiredDefaultedSiblingEnum
+	}
+	return Default_Message_RequiredDefaultedSiblingEnum
+}
+
+func (m *Message) GetRepeatedBool() []bool {
+	if m != nil {
+		return m.RepeatedBool
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedInt32() []int32 {
+	if m != nil {
+		return m.RepeatedInt32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSint32() []int32 {
+	if m != nil {
+		return m.RepeatedSint32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedUint32() []uint32 {
+	if m != nil {
+		return m.RepeatedUint32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedInt64() []int64 {
+	if m != nil {
+		return m.RepeatedInt64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSint64() []int64 {
+	if m != nil {
+		return m.RepeatedSint64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedUint64() []uint64 {
+	if m != nil {
+		return m.RepeatedUint64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedFixed32() []uint32 {
+	if m != nil {
+		return m.RepeatedFixed32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSfixed32() []int32 {
+	if m != nil {
+		return m.RepeatedSfixed32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedFloat() []float32 {
+	if m != nil {
+		return m.RepeatedFloat
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedFixed64() []uint64 {
+	if m != nil {
+		return m.RepeatedFixed64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSfixed64() []int64 {
+	if m != nil {
+		return m.RepeatedSfixed64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedDouble() []float64 {
+	if m != nil {
+		return m.RepeatedDouble
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedString() []string {
+	if m != nil {
+		return m.RepeatedString
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedBytes() [][]byte {
+	if m != nil {
+		return m.RepeatedBytes
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedChildEnum() []Message_ChildEnum {
+	if m != nil {
+		return m.RepeatedChildEnum
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedChildMessage() []*Message_ChildMessage {
+	if m != nil {
+		return m.RepeatedChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedNamedGroup() []*Message_NamedGroup {
+	if m != nil {
+		return m.RepeatedNamedGroup
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSiblingEnum() []SiblingEnum {
+	if m != nil {
+		return m.RepeatedSiblingEnum
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSiblingMessage() []*SiblingMessage {
+	if m != nil {
+		return m.RepeatedSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedgroup() []*Message_RepeatedGroup {
+	if m != nil {
+		return m.Repeatedgroup
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolBool() map[bool]bool {
+	if m != nil {
+		return m.MapBoolBool
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolInt32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolInt32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSint32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolSint32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolUint32() map[bool]uint32 {
+	if m != nil {
+		return m.MapBoolUint32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolInt64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolInt64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSint64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolSint64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolUint64() map[bool]uint64 {
+	if m != nil {
+		return m.MapBoolUint64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFixed32() map[bool]uint32 {
+	if m != nil {
+		return m.MapBoolFixed32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSfixed32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolSfixed32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFloat() map[bool]float32 {
+	if m != nil {
+		return m.MapBoolFloat
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFixed64() map[bool]uint64 {
+	if m != nil {
+		return m.MapBoolFixed64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSfixed64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolSfixed64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolDouble() map[bool]float64 {
+	if m != nil {
+		return m.MapBoolDouble
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolString() map[bool]string {
+	if m != nil {
+		return m.MapBoolString
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolBytes() map[bool][]byte {
+	if m != nil {
+		return m.MapBoolBytes
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolChildEnum() map[bool]Message_ChildEnum {
+	if m != nil {
+		return m.MapBoolChildEnum
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolChildMessage() map[bool]*Message_ChildMessage {
+	if m != nil {
+		return m.MapBoolChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolNamedGroup() map[bool]*Message_NamedGroup {
+	if m != nil {
+		return m.MapBoolNamedGroup
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSiblingEnum() map[bool]SiblingEnum {
+	if m != nil {
+		return m.MapBoolSiblingEnum
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSiblingMessage() map[bool]*SiblingMessage {
+	if m != nil {
+		return m.MapBoolSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetMapInt32Bool() map[int32]bool {
+	if m != nil {
+		return m.MapInt32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapSint32Bool() map[int32]bool {
+	if m != nil {
+		return m.MapSint32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapUint32Bool() map[uint32]bool {
+	if m != nil {
+		return m.MapUint32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapInt64Bool() map[int64]bool {
+	if m != nil {
+		return m.MapInt64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapSint64Bool() map[int64]bool {
+	if m != nil {
+		return m.MapSint64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapUint64Bool() map[uint64]bool {
+	if m != nil {
+		return m.MapUint64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapFixed32Bool() map[uint32]bool {
+	if m != nil {
+		return m.MapFixed32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapStringBool() map[string]bool {
+	if m != nil {
+		return m.MapStringBool
+	}
+	return nil
+}
+
+func (m *Message) GetOneofBool() bool {
+	if x, ok := m.GetOneofUnion().(*Message_OneofBool); ok {
+		return x.OneofBool
+	}
+	return false
+}
+
+func (m *Message) GetOneofInt32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofInt32); ok {
+		return x.OneofInt32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSint32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSint32); ok {
+		return x.OneofSint32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofUint32() uint32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofUint32); ok {
+		return x.OneofUint32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofInt64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofInt64); ok {
+		return x.OneofInt64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSint64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSint64); ok {
+		return x.OneofSint64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofUint64() uint64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofUint64); ok {
+		return x.OneofUint64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFixed32() uint32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFixed32); ok {
+		return x.OneofFixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSfixed32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSfixed32); ok {
+		return x.OneofSfixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFloat() float32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFloat); ok {
+		return x.OneofFloat
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFixed64() uint64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFixed64); ok {
+		return x.OneofFixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSfixed64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSfixed64); ok {
+		return x.OneofSfixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofDouble() float64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofDouble); ok {
+		return x.OneofDouble
+	}
+	return 0
+}
+
+func (m *Message) GetOneofString() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString); ok {
+		return x.OneofString
+	}
+	return ""
+}
+
+func (m *Message) GetOneofBytes() []byte {
+	if x, ok := m.GetOneofUnion().(*Message_OneofBytes); ok {
+		return x.OneofBytes
+	}
+	return nil
+}
+
+func (m *Message) GetOneofChildEnum() Message_ChildEnum {
+	if x, ok := m.GetOneofUnion().(*Message_OneofChildEnum); ok {
+		return x.OneofChildEnum
+	}
+	return Message_ALPHA
+}
+
+func (m *Message) GetOneofChildMessage() *Message_ChildMessage {
+	if x, ok := m.GetOneofUnion().(*Message_OneofChildMessage); ok {
+		return x.OneofChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOneofNamedGroup() *Message_NamedGroup {
+	if x, ok := m.GetOneofUnion().(*Message_OneofNamedGroup); ok {
+		return x.OneofNamedGroup
+	}
+	return nil
+}
+
+func (m *Message) GetOneofSiblingEnum() SiblingEnum {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSiblingEnum); ok {
+		return x.OneofSiblingEnum
+	}
+	return SiblingEnum_ALPHA
+}
+
+func (m *Message) GetOneofSiblingMessage() *SiblingMessage {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSiblingMessage); ok {
+		return x.OneofSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOneofgroup() *Message_OneofGroup {
+	if x, ok := m.GetOneofUnion().(*Message_Oneofgroup); ok {
+		return x.Oneofgroup
+	}
+	return nil
+}
+
+func (m *Message) GetOneofString1() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString1); ok {
+		return x.OneofString1
+	}
+	return ""
+}
+
+func (m *Message) GetOneofString2() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString2); ok {
+		return x.OneofString2
+	}
+	return ""
+}
+
+func (m *Message) GetOneofString3() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString3); ok {
+		return x.OneofString3
+	}
+	return ""
+}
+
+func (m *Message) GetOneofDefaultedBool() bool {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedBool); ok {
+		return x.OneofDefaultedBool
+	}
+	return Default_Message_OneofDefaultedBool
+}
+
+func (m *Message) GetOneofDefaultedInt32() int32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedInt32); ok {
+		return x.OneofDefaultedInt32
+	}
+	return Default_Message_OneofDefaultedInt32
+}
+
+func (m *Message) GetOneofDefaultedSint32() int32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedSint32); ok {
+		return x.OneofDefaultedSint32
+	}
+	return Default_Message_OneofDefaultedSint32
+}
+
+func (m *Message) GetOneofDefaultedUint32() uint32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedUint32); ok {
+		return x.OneofDefaultedUint32
+	}
+	return Default_Message_OneofDefaultedUint32
+}
+
+func (m *Message) GetOneofDefaultedInt64() int64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedInt64); ok {
+		return x.OneofDefaultedInt64
+	}
+	return Default_Message_OneofDefaultedInt64
+}
+
+func (m *Message) GetOneofDefaultedSint64() int64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedSint64); ok {
+		return x.OneofDefaultedSint64
+	}
+	return Default_Message_OneofDefaultedSint64
+}
+
+func (m *Message) GetOneofDefaultedUint64() uint64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedUint64); ok {
+		return x.OneofDefaultedUint64
+	}
+	return Default_Message_OneofDefaultedUint64
+}
+
+func (m *Message) GetOneofDefaultedFixed32() uint32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedFixed32); ok {
+		return x.OneofDefaultedFixed32
+	}
+	return Default_Message_OneofDefaultedFixed32
+}
+
+func (m *Message) GetOneofDefaultedSfixed32() int32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedSfixed32); ok {
+		return x.OneofDefaultedSfixed32
+	}
+	return Default_Message_OneofDefaultedSfixed32
+}
+
+func (m *Message) GetOneofDefaultedFloat() float32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedFloat); ok {
+		return x.OneofDefaultedFloat
+	}
+	return Default_Message_OneofDefaultedFloat
+}
+
+func (m *Message) GetOneofDefaultedFixed64() uint64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedFixed64); ok {
+		return x.OneofDefaultedFixed64
+	}
+	return Default_Message_OneofDefaultedFixed64
+}
+
+func (m *Message) GetOneofDefaultedSfixed64() int64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedSfixed64); ok {
+		return x.OneofDefaultedSfixed64
+	}
+	return Default_Message_OneofDefaultedSfixed64
+}
+
+func (m *Message) GetOneofDefaultedDouble() float64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedDouble); ok {
+		return x.OneofDefaultedDouble
+	}
+	return Default_Message_OneofDefaultedDouble
+}
+
+func (m *Message) GetOneofDefaultedString() string {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedString); ok {
+		return x.OneofDefaultedString
+	}
+	return Default_Message_OneofDefaultedString
+}
+
+func (m *Message) GetOneofDefaultedBytes() []byte {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedBytes); ok {
+		return x.OneofDefaultedBytes
+	}
+	return append([]byte(nil), Default_Message_OneofDefaultedBytes...)
+}
+
+func (m *Message) GetOneofDefaultedChildEnum() Message_ChildEnum {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedChildEnum); ok {
+		return x.OneofDefaultedChildEnum
+	}
+	return Default_Message_OneofDefaultedChildEnum
+}
+
+func (m *Message) GetOneofDefaultedSiblingEnum() SiblingEnum {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedSiblingEnum); ok {
+		return x.OneofDefaultedSiblingEnum
+	}
+	return Default_Message_OneofDefaultedSiblingEnum
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*Message) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+	return _Message_OneofMarshaler, _Message_OneofUnmarshaler, _Message_OneofSizer, []interface{}{
+		(*Message_OneofBool)(nil),
+		(*Message_OneofInt32)(nil),
+		(*Message_OneofSint32)(nil),
+		(*Message_OneofUint32)(nil),
+		(*Message_OneofInt64)(nil),
+		(*Message_OneofSint64)(nil),
+		(*Message_OneofUint64)(nil),
+		(*Message_OneofFixed32)(nil),
+		(*Message_OneofSfixed32)(nil),
+		(*Message_OneofFloat)(nil),
+		(*Message_OneofFixed64)(nil),
+		(*Message_OneofSfixed64)(nil),
+		(*Message_OneofDouble)(nil),
+		(*Message_OneofString)(nil),
+		(*Message_OneofBytes)(nil),
+		(*Message_OneofChildEnum)(nil),
+		(*Message_OneofChildMessage)(nil),
+		(*Message_OneofNamedGroup)(nil),
+		(*Message_OneofSiblingEnum)(nil),
+		(*Message_OneofSiblingMessage)(nil),
+		(*Message_Oneofgroup)(nil),
+		(*Message_OneofString1)(nil),
+		(*Message_OneofString2)(nil),
+		(*Message_OneofString3)(nil),
+		(*Message_OneofDefaultedBool)(nil),
+		(*Message_OneofDefaultedInt32)(nil),
+		(*Message_OneofDefaultedSint32)(nil),
+		(*Message_OneofDefaultedUint32)(nil),
+		(*Message_OneofDefaultedInt64)(nil),
+		(*Message_OneofDefaultedSint64)(nil),
+		(*Message_OneofDefaultedUint64)(nil),
+		(*Message_OneofDefaultedFixed32)(nil),
+		(*Message_OneofDefaultedSfixed32)(nil),
+		(*Message_OneofDefaultedFloat)(nil),
+		(*Message_OneofDefaultedFixed64)(nil),
+		(*Message_OneofDefaultedSfixed64)(nil),
+		(*Message_OneofDefaultedDouble)(nil),
+		(*Message_OneofDefaultedString)(nil),
+		(*Message_OneofDefaultedBytes)(nil),
+		(*Message_OneofDefaultedChildEnum)(nil),
+		(*Message_OneofDefaultedSiblingEnum)(nil),
+	}
+}
+
+func _Message_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*Message)
+	// oneof_union
+	switch x := m.OneofUnion.(type) {
+	case *Message_OneofBool:
+		t := uint64(0)
+		if x.OneofBool {
+			t = 1
+		}
+		b.EncodeVarint(700<<3 | proto.WireVarint)
+		b.EncodeVarint(t)
+	case *Message_OneofInt32:
+		b.EncodeVarint(701<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofInt32))
+	case *Message_OneofSint32:
+		b.EncodeVarint(702<<3 | proto.WireVarint)
+		b.EncodeZigzag32(uint64(x.OneofSint32))
+	case *Message_OneofUint32:
+		b.EncodeVarint(703<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofUint32))
+	case *Message_OneofInt64:
+		b.EncodeVarint(704<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofInt64))
+	case *Message_OneofSint64:
+		b.EncodeVarint(705<<3 | proto.WireVarint)
+		b.EncodeZigzag64(uint64(x.OneofSint64))
+	case *Message_OneofUint64:
+		b.EncodeVarint(706<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofUint64))
+	case *Message_OneofFixed32:
+		b.EncodeVarint(707<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(x.OneofFixed32))
+	case *Message_OneofSfixed32:
+		b.EncodeVarint(708<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(x.OneofSfixed32))
+	case *Message_OneofFloat:
+		b.EncodeVarint(709<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(math.Float32bits(x.OneofFloat)))
+	case *Message_OneofFixed64:
+		b.EncodeVarint(710<<3 | proto.WireFixed64)
+		b.EncodeFixed64(uint64(x.OneofFixed64))
+	case *Message_OneofSfixed64:
+		b.EncodeVarint(711<<3 | proto.WireFixed64)
+		b.EncodeFixed64(uint64(x.OneofSfixed64))
+	case *Message_OneofDouble:
+		b.EncodeVarint(712<<3 | proto.WireFixed64)
+		b.EncodeFixed64(math.Float64bits(x.OneofDouble))
+	case *Message_OneofString:
+		b.EncodeVarint(713<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString)
+	case *Message_OneofBytes:
+		b.EncodeVarint(714<<3 | proto.WireBytes)
+		b.EncodeRawBytes(x.OneofBytes)
+	case *Message_OneofChildEnum:
+		b.EncodeVarint(715<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofChildEnum))
+	case *Message_OneofChildMessage:
+		b.EncodeVarint(716<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.OneofChildMessage); err != nil {
+			return err
+		}
+	case *Message_OneofNamedGroup:
+		b.EncodeVarint(717<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.OneofNamedGroup); err != nil {
+			return err
+		}
+	case *Message_OneofSiblingEnum:
+		b.EncodeVarint(718<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofSiblingEnum))
+	case *Message_OneofSiblingMessage:
+		b.EncodeVarint(719<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.OneofSiblingMessage); err != nil {
+			return err
+		}
+	case *Message_Oneofgroup:
+		b.EncodeVarint(720<<3 | proto.WireStartGroup)
+		if err := b.Marshal(x.Oneofgroup); err != nil {
+			return err
+		}
+		b.EncodeVarint(720<<3 | proto.WireEndGroup)
+	case *Message_OneofString1:
+		b.EncodeVarint(721<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString1)
+	case *Message_OneofString2:
+		b.EncodeVarint(722<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString2)
+	case *Message_OneofString3:
+		b.EncodeVarint(723<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString3)
+	case nil:
+	default:
+		return fmt.Errorf("Message.OneofUnion has unexpected type %T", x)
+	}
+	// oneof_defaulted_union
+	switch x := m.OneofDefaultedUnion.(type) {
+	case *Message_OneofDefaultedBool:
+		t := uint64(0)
+		if x.OneofDefaultedBool {
+			t = 1
+		}
+		b.EncodeVarint(800<<3 | proto.WireVarint)
+		b.EncodeVarint(t)
+	case *Message_OneofDefaultedInt32:
+		b.EncodeVarint(801<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofDefaultedInt32))
+	case *Message_OneofDefaultedSint32:
+		b.EncodeVarint(802<<3 | proto.WireVarint)
+		b.EncodeZigzag32(uint64(x.OneofDefaultedSint32))
+	case *Message_OneofDefaultedUint32:
+		b.EncodeVarint(803<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofDefaultedUint32))
+	case *Message_OneofDefaultedInt64:
+		b.EncodeVarint(804<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofDefaultedInt64))
+	case *Message_OneofDefaultedSint64:
+		b.EncodeVarint(805<<3 | proto.WireVarint)
+		b.EncodeZigzag64(uint64(x.OneofDefaultedSint64))
+	case *Message_OneofDefaultedUint64:
+		b.EncodeVarint(806<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofDefaultedUint64))
+	case *Message_OneofDefaultedFixed32:
+		b.EncodeVarint(807<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(x.OneofDefaultedFixed32))
+	case *Message_OneofDefaultedSfixed32:
+		b.EncodeVarint(808<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(x.OneofDefaultedSfixed32))
+	case *Message_OneofDefaultedFloat:
+		b.EncodeVarint(809<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(math.Float32bits(x.OneofDefaultedFloat)))
+	case *Message_OneofDefaultedFixed64:
+		b.EncodeVarint(810<<3 | proto.WireFixed64)
+		b.EncodeFixed64(uint64(x.OneofDefaultedFixed64))
+	case *Message_OneofDefaultedSfixed64:
+		b.EncodeVarint(811<<3 | proto.WireFixed64)
+		b.EncodeFixed64(uint64(x.OneofDefaultedSfixed64))
+	case *Message_OneofDefaultedDouble:
+		b.EncodeVarint(812<<3 | proto.WireFixed64)
+		b.EncodeFixed64(math.Float64bits(x.OneofDefaultedDouble))
+	case *Message_OneofDefaultedString:
+		b.EncodeVarint(813<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofDefaultedString)
+	case *Message_OneofDefaultedBytes:
+		b.EncodeVarint(814<<3 | proto.WireBytes)
+		b.EncodeRawBytes(x.OneofDefaultedBytes)
+	case *Message_OneofDefaultedChildEnum:
+		b.EncodeVarint(815<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofDefaultedChildEnum))
+	case *Message_OneofDefaultedSiblingEnum:
+		b.EncodeVarint(816<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofDefaultedSiblingEnum))
+	case nil:
+	default:
+		return fmt.Errorf("Message.OneofDefaultedUnion has unexpected type %T", x)
+	}
+	return nil
+}
+
+func _Message_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*Message)
+	switch tag {
+	case 700: // oneof_union.oneof_bool
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofBool{x != 0}
+		return true, err
+	case 701: // oneof_union.oneof_int32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofInt32{int32(x)}
+		return true, err
+	case 702: // oneof_union.oneof_sint32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeZigzag32()
+		m.OneofUnion = &Message_OneofSint32{int32(x)}
+		return true, err
+	case 703: // oneof_union.oneof_uint32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofUint32{uint32(x)}
+		return true, err
+	case 704: // oneof_union.oneof_int64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofInt64{int64(x)}
+		return true, err
+	case 705: // oneof_union.oneof_sint64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeZigzag64()
+		m.OneofUnion = &Message_OneofSint64{int64(x)}
+		return true, err
+	case 706: // oneof_union.oneof_uint64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofUint64{x}
+		return true, err
+	case 707: // oneof_union.oneof_fixed32
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofUnion = &Message_OneofFixed32{uint32(x)}
+		return true, err
+	case 708: // oneof_union.oneof_sfixed32
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofUnion = &Message_OneofSfixed32{int32(x)}
+		return true, err
+	case 709: // oneof_union.oneof_float
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofUnion = &Message_OneofFloat{math.Float32frombits(uint32(x))}
+		return true, err
+	case 710: // oneof_union.oneof_fixed64
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofUnion = &Message_OneofFixed64{x}
+		return true, err
+	case 711: // oneof_union.oneof_sfixed64
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofUnion = &Message_OneofSfixed64{int64(x)}
+		return true, err
+	case 712: // oneof_union.oneof_double
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofUnion = &Message_OneofDouble{math.Float64frombits(x)}
+		return true, err
+	case 713: // oneof_union.oneof_string
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString{x}
+		return true, err
+	case 714: // oneof_union.oneof_bytes
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeRawBytes(true)
+		m.OneofUnion = &Message_OneofBytes{x}
+		return true, err
+	case 715: // oneof_union.oneof_child_enum
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofChildEnum{Message_ChildEnum(x)}
+		return true, err
+	case 716: // oneof_union.oneof_child_message
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(Message_ChildMessage)
+		err := b.DecodeMessage(msg)
+		m.OneofUnion = &Message_OneofChildMessage{msg}
+		return true, err
+	case 717: // oneof_union.oneof_named_group
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(Message_NamedGroup)
+		err := b.DecodeMessage(msg)
+		m.OneofUnion = &Message_OneofNamedGroup{msg}
+		return true, err
+	case 718: // oneof_union.oneof_sibling_enum
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofSiblingEnum{SiblingEnum(x)}
+		return true, err
+	case 719: // oneof_union.oneof_sibling_message
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(SiblingMessage)
+		err := b.DecodeMessage(msg)
+		m.OneofUnion = &Message_OneofSiblingMessage{msg}
+		return true, err
+	case 720: // oneof_union.oneofgroup
+		if wire != proto.WireStartGroup {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(Message_OneofGroup)
+		err := b.DecodeGroup(msg)
+		m.OneofUnion = &Message_Oneofgroup{msg}
+		return true, err
+	case 721: // oneof_union.oneof_string1
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString1{x}
+		return true, err
+	case 722: // oneof_union.oneof_string2
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString2{x}
+		return true, err
+	case 723: // oneof_union.oneof_string3
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString3{x}
+		return true, err
+	case 800: // oneof_defaulted_union.oneof_defaulted_bool
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedBool{x != 0}
+		return true, err
+	case 801: // oneof_defaulted_union.oneof_defaulted_int32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedInt32{int32(x)}
+		return true, err
+	case 802: // oneof_defaulted_union.oneof_defaulted_sint32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeZigzag32()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedSint32{int32(x)}
+		return true, err
+	case 803: // oneof_defaulted_union.oneof_defaulted_uint32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedUint32{uint32(x)}
+		return true, err
+	case 804: // oneof_defaulted_union.oneof_defaulted_int64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedInt64{int64(x)}
+		return true, err
+	case 805: // oneof_defaulted_union.oneof_defaulted_sint64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeZigzag64()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedSint64{int64(x)}
+		return true, err
+	case 806: // oneof_defaulted_union.oneof_defaulted_uint64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedUint64{x}
+		return true, err
+	case 807: // oneof_defaulted_union.oneof_defaulted_fixed32
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedFixed32{uint32(x)}
+		return true, err
+	case 808: // oneof_defaulted_union.oneof_defaulted_sfixed32
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedSfixed32{int32(x)}
+		return true, err
+	case 809: // oneof_defaulted_union.oneof_defaulted_float
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedFloat{math.Float32frombits(uint32(x))}
+		return true, err
+	case 810: // oneof_defaulted_union.oneof_defaulted_fixed64
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedFixed64{x}
+		return true, err
+	case 811: // oneof_defaulted_union.oneof_defaulted_sfixed64
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedSfixed64{int64(x)}
+		return true, err
+	case 812: // oneof_defaulted_union.oneof_defaulted_double
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedDouble{math.Float64frombits(x)}
+		return true, err
+	case 813: // oneof_defaulted_union.oneof_defaulted_string
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedString{x}
+		return true, err
+	case 814: // oneof_defaulted_union.oneof_defaulted_bytes
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeRawBytes(true)
+		m.OneofDefaultedUnion = &Message_OneofDefaultedBytes{x}
+		return true, err
+	case 815: // oneof_defaulted_union.oneof_defaulted_child_enum
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedChildEnum{Message_ChildEnum(x)}
+		return true, err
+	case 816: // oneof_defaulted_union.oneof_defaulted_sibling_enum
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedSiblingEnum{SiblingEnum(x)}
+		return true, err
+	default:
+		return false, nil
+	}
+}
+
+func _Message_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*Message)
+	// oneof_union
+	switch x := m.OneofUnion.(type) {
+	case *Message_OneofBool:
+		n += 2 // tag and wire
+		n += 1
+	case *Message_OneofInt32:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofInt32))
+	case *Message_OneofSint32:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64((uint32(x.OneofSint32) << 1) ^ uint32((int32(x.OneofSint32) >> 31))))
+	case *Message_OneofUint32:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofUint32))
+	case *Message_OneofInt64:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofInt64))
+	case *Message_OneofSint64:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(uint64(x.OneofSint64<<1) ^ uint64((int64(x.OneofSint64) >> 63))))
+	case *Message_OneofUint64:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofUint64))
+	case *Message_OneofFixed32:
+		n += 2 // tag and wire
+		n += 4
+	case *Message_OneofSfixed32:
+		n += 2 // tag and wire
+		n += 4
+	case *Message_OneofFloat:
+		n += 2 // tag and wire
+		n += 4
+	case *Message_OneofFixed64:
+		n += 2 // tag and wire
+		n += 8
+	case *Message_OneofSfixed64:
+		n += 2 // tag and wire
+		n += 8
+	case *Message_OneofDouble:
+		n += 2 // tag and wire
+		n += 8
+	case *Message_OneofString:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(len(x.OneofString)))
+		n += len(x.OneofString)
+	case *Message_OneofBytes:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(len(x.OneofBytes)))
+		n += len(x.OneofBytes)
+	case *Message_OneofChildEnum:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofChildEnum))
+	case *Message_OneofChildMessage:
+		s := proto.Size(x.OneofChildMessage)
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *Message_OneofNamedGroup:
+		s := proto.Size(x.OneofNamedGroup)
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *Message_OneofSiblingEnum:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofSiblingEnum))
+	case *Message_OneofSiblingMessage:
+		s := proto.Size(x.OneofSiblingMessage)
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *Message_Oneofgroup:
+		n += 2 // tag and wire
+		n += proto.Size(x.Oneofgroup)
+		n += 2 // tag and wire
+	case *Message_OneofString1:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(len(x.OneofString1)))
+		n += len(x.OneofString1)
+	case *Message_OneofString2:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(len(x.OneofString2)))
+		n += len(x.OneofString2)
+	case *Message_OneofString3:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(len(x.OneofString3)))
+		n += len(x.OneofString3)
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	// oneof_defaulted_union
+	switch x := m.OneofDefaultedUnion.(type) {
+	case *Message_OneofDefaultedBool:
+		n += 2 // tag and wire
+		n += 1
+	case *Message_OneofDefaultedInt32:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofDefaultedInt32))
+	case *Message_OneofDefaultedSint32:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64((uint32(x.OneofDefaultedSint32) << 1) ^ uint32((int32(x.OneofDefaultedSint32) >> 31))))
+	case *Message_OneofDefaultedUint32:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofDefaultedUint32))
+	case *Message_OneofDefaultedInt64:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofDefaultedInt64))
+	case *Message_OneofDefaultedSint64:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(uint64(x.OneofDefaultedSint64<<1) ^ uint64((int64(x.OneofDefaultedSint64) >> 63))))
+	case *Message_OneofDefaultedUint64:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofDefaultedUint64))
+	case *Message_OneofDefaultedFixed32:
+		n += 2 // tag and wire
+		n += 4
+	case *Message_OneofDefaultedSfixed32:
+		n += 2 // tag and wire
+		n += 4
+	case *Message_OneofDefaultedFloat:
+		n += 2 // tag and wire
+		n += 4
+	case *Message_OneofDefaultedFixed64:
+		n += 2 // tag and wire
+		n += 8
+	case *Message_OneofDefaultedSfixed64:
+		n += 2 // tag and wire
+		n += 8
+	case *Message_OneofDefaultedDouble:
+		n += 2 // tag and wire
+		n += 8
+	case *Message_OneofDefaultedString:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(len(x.OneofDefaultedString)))
+		n += len(x.OneofDefaultedString)
+	case *Message_OneofDefaultedBytes:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(len(x.OneofDefaultedBytes)))
+		n += len(x.OneofDefaultedBytes)
+	case *Message_OneofDefaultedChildEnum:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofDefaultedChildEnum))
+	case *Message_OneofDefaultedSiblingEnum:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofDefaultedSiblingEnum))
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	return n
+}
+
+var E_Message_ExtensionOptionalBool = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*bool)(nil),
+	Field:         10000,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_optional_bool",
+	Tag:           "varint,10000,opt,name=extension_optional_bool,json=extensionOptionalBool",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionOptionalInt32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         10001,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_optional_int32",
+	Tag:           "varint,10001,opt,name=extension_optional_int32,json=extensionOptionalInt32",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionOptionalSint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         10002,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_optional_sint32",
+	Tag:           "zigzag32,10002,opt,name=extension_optional_sint32,json=extensionOptionalSint32",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionOptionalUint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint32)(nil),
+	Field:         10003,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_optional_uint32",
+	Tag:           "varint,10003,opt,name=extension_optional_uint32,json=extensionOptionalUint32",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionOptionalInt64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         10004,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_optional_int64",
+	Tag:           "varint,10004,opt,name=extension_optional_int64,json=extensionOptionalInt64",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionOptionalSint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         10005,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_optional_sint64",
+	Tag:           "zigzag64,10005,opt,name=extension_optional_sint64,json=extensionOptionalSint64",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionOptionalUint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint64)(nil),
+	Field:         10006,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_optional_uint64",
+	Tag:           "varint,10006,opt,name=extension_optional_uint64,json=extensionOptionalUint64",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionOptionalFixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint32)(nil),
+	Field:         10007,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_optional_fixed32",
+	Tag:           "fixed32,10007,opt,name=extension_optional_fixed32,json=extensionOptionalFixed32",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionOptionalSfixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         10008,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_optional_sfixed32",
+	Tag:           "fixed32,10008,opt,name=extension_optional_sfixed32,json=extensionOptionalSfixed32",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionOptionalFloat = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*float32)(nil),
+	Field:         10009,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_optional_float",
+	Tag:           "fixed32,10009,opt,name=extension_optional_float,json=extensionOptionalFloat",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionOptionalFixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint64)(nil),
+	Field:         10010,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_optional_fixed64",
+	Tag:           "fixed64,10010,opt,name=extension_optional_fixed64,json=extensionOptionalFixed64",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionOptionalSfixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         10011,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_optional_sfixed64",
+	Tag:           "fixed64,10011,opt,name=extension_optional_sfixed64,json=extensionOptionalSfixed64",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionOptionalDouble = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*float64)(nil),
+	Field:         10012,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_optional_double",
+	Tag:           "fixed64,10012,opt,name=extension_optional_double,json=extensionOptionalDouble",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionOptionalString = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*string)(nil),
+	Field:         10013,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_optional_string",
+	Tag:           "bytes,10013,opt,name=extension_optional_string,json=extensionOptionalString",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionOptionalBytes = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]byte)(nil),
+	Field:         10014,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_optional_bytes",
+	Tag:           "bytes,10014,opt,name=extension_optional_bytes,json=extensionOptionalBytes",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionOptionalChildEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*Message_ChildEnum)(nil),
+	Field:         10015,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_optional_child_enum",
+	Tag:           "varint,10015,opt,name=extension_optional_child_enum,json=extensionOptionalChildEnum,enum=google.golang.org.proto2_20180430.Message_ChildEnum",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionOptionalChildMessage = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*Message_ChildMessage)(nil),
+	Field:         10016,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_optional_child_message",
+	Tag:           "bytes,10016,opt,name=extension_optional_child_message,json=extensionOptionalChildMessage",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionOptionalNamedGroup = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*Message_NamedGroup)(nil),
+	Field:         10017,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_optional_named_group",
+	Tag:           "bytes,10017,opt,name=extension_optional_named_group,json=extensionOptionalNamedGroup",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionOptionalSiblingEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*SiblingEnum)(nil),
+	Field:         10018,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_optional_sibling_enum",
+	Tag:           "varint,10018,opt,name=extension_optional_sibling_enum,json=extensionOptionalSiblingEnum,enum=google.golang.org.proto2_20180430.SiblingEnum",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionOptionalSiblingMessage = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*SiblingMessage)(nil),
+	Field:         10019,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_optional_sibling_message",
+	Tag:           "bytes,10019,opt,name=extension_optional_sibling_message,json=extensionOptionalSiblingMessage",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_Extensionoptionalgroup = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*Message_ExtensionOptionalGroup)(nil),
+	Field:         10020,
+	Name:          "google.golang.org.proto2_20180430.Message.extensionoptionalgroup",
+	Tag:           "group,10020,opt,name=ExtensionOptionalGroup,json=extensionoptionalgroup",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionDefaultedBool = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*bool)(nil),
+	Field:         20000,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_defaulted_bool",
+	Tag:           "varint,20000,opt,name=extension_defaulted_bool,json=extensionDefaultedBool,def=1",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionDefaultedInt32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         20001,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_defaulted_int32",
+	Tag:           "varint,20001,opt,name=extension_defaulted_int32,json=extensionDefaultedInt32,def=-12345",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionDefaultedSint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         20002,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_defaulted_sint32",
+	Tag:           "zigzag32,20002,opt,name=extension_defaulted_sint32,json=extensionDefaultedSint32,def=-3200",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionDefaultedUint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint32)(nil),
+	Field:         20003,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_defaulted_uint32",
+	Tag:           "varint,20003,opt,name=extension_defaulted_uint32,json=extensionDefaultedUint32,def=3200",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionDefaultedInt64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         20004,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_defaulted_int64",
+	Tag:           "varint,20004,opt,name=extension_defaulted_int64,json=extensionDefaultedInt64,def=-123456789",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionDefaultedSint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         20005,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_defaulted_sint64",
+	Tag:           "zigzag64,20005,opt,name=extension_defaulted_sint64,json=extensionDefaultedSint64,def=-6400",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionDefaultedUint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint64)(nil),
+	Field:         20006,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_defaulted_uint64",
+	Tag:           "varint,20006,opt,name=extension_defaulted_uint64,json=extensionDefaultedUint64,def=6400",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionDefaultedFixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint32)(nil),
+	Field:         20007,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_defaulted_fixed32",
+	Tag:           "fixed32,20007,opt,name=extension_defaulted_fixed32,json=extensionDefaultedFixed32,def=320000",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionDefaultedSfixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         20008,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_defaulted_sfixed32",
+	Tag:           "fixed32,20008,opt,name=extension_defaulted_sfixed32,json=extensionDefaultedSfixed32,def=-320000",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionDefaultedFloat = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*float32)(nil),
+	Field:         20009,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_defaulted_float",
+	Tag:           "fixed32,20009,opt,name=extension_defaulted_float,json=extensionDefaultedFloat,def=3.14159",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionDefaultedFixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint64)(nil),
+	Field:         20010,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_defaulted_fixed64",
+	Tag:           "fixed64,20010,opt,name=extension_defaulted_fixed64,json=extensionDefaultedFixed64,def=640000",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionDefaultedSfixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         20011,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_defaulted_sfixed64",
+	Tag:           "fixed64,20011,opt,name=extension_defaulted_sfixed64,json=extensionDefaultedSfixed64,def=-640000",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionDefaultedDouble = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*float64)(nil),
+	Field:         20012,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_defaulted_double",
+	Tag:           "fixed64,20012,opt,name=extension_defaulted_double,json=extensionDefaultedDouble,def=3.14159265359",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionDefaultedString = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*string)(nil),
+	Field:         20013,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_defaulted_string",
+	Tag:           "bytes,20013,opt,name=extension_defaulted_string,json=extensionDefaultedString,def=hello, \"world!\"\n",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionDefaultedBytes = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]byte)(nil),
+	Field:         20014,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_defaulted_bytes",
+	Tag:           "bytes,20014,opt,name=extension_defaulted_bytes,json=extensionDefaultedBytes,def=dead\\336\\255\\276\\357beef",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionDefaultedChildEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*Message_ChildEnum)(nil),
+	Field:         20015,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_defaulted_child_enum",
+	Tag:           "varint,20015,opt,name=extension_defaulted_child_enum,json=extensionDefaultedChildEnum,enum=google.golang.org.proto2_20180430.Message_ChildEnum,def=0",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionDefaultedSiblingEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*SiblingEnum)(nil),
+	Field:         20016,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_defaulted_sibling_enum",
+	Tag:           "varint,20016,opt,name=extension_defaulted_sibling_enum,json=extensionDefaultedSiblingEnum,enum=google.golang.org.proto2_20180430.SiblingEnum,def=0",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionRepeatedBool = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]bool)(nil),
+	Field:         30000,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_repeated_bool",
+	Tag:           "varint,30000,rep,name=extension_repeated_bool,json=extensionRepeatedBool",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionRepeatedInt32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int32)(nil),
+	Field:         30001,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_repeated_int32",
+	Tag:           "varint,30001,rep,name=extension_repeated_int32,json=extensionRepeatedInt32",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionRepeatedSint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int32)(nil),
+	Field:         30002,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_repeated_sint32",
+	Tag:           "zigzag32,30002,rep,name=extension_repeated_sint32,json=extensionRepeatedSint32",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionRepeatedUint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]uint32)(nil),
+	Field:         30003,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_repeated_uint32",
+	Tag:           "varint,30003,rep,name=extension_repeated_uint32,json=extensionRepeatedUint32",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionRepeatedInt64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int64)(nil),
+	Field:         30004,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_repeated_int64",
+	Tag:           "varint,30004,rep,name=extension_repeated_int64,json=extensionRepeatedInt64",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionRepeatedSint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int64)(nil),
+	Field:         30005,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_repeated_sint64",
+	Tag:           "zigzag64,30005,rep,name=extension_repeated_sint64,json=extensionRepeatedSint64",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionRepeatedUint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]uint64)(nil),
+	Field:         30006,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_repeated_uint64",
+	Tag:           "varint,30006,rep,name=extension_repeated_uint64,json=extensionRepeatedUint64",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionRepeatedFixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]uint32)(nil),
+	Field:         30007,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_repeated_fixed32",
+	Tag:           "fixed32,30007,rep,name=extension_repeated_fixed32,json=extensionRepeatedFixed32",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionRepeatedSfixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int32)(nil),
+	Field:         30008,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_repeated_sfixed32",
+	Tag:           "fixed32,30008,rep,name=extension_repeated_sfixed32,json=extensionRepeatedSfixed32",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionRepeatedFloat = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]float32)(nil),
+	Field:         30009,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_repeated_float",
+	Tag:           "fixed32,30009,rep,name=extension_repeated_float,json=extensionRepeatedFloat",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionRepeatedFixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]uint64)(nil),
+	Field:         30010,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_repeated_fixed64",
+	Tag:           "fixed64,30010,rep,name=extension_repeated_fixed64,json=extensionRepeatedFixed64",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionRepeatedSfixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int64)(nil),
+	Field:         30011,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_repeated_sfixed64",
+	Tag:           "fixed64,30011,rep,name=extension_repeated_sfixed64,json=extensionRepeatedSfixed64",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionRepeatedDouble = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]float64)(nil),
+	Field:         30012,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_repeated_double",
+	Tag:           "fixed64,30012,rep,name=extension_repeated_double,json=extensionRepeatedDouble",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionRepeatedString = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]string)(nil),
+	Field:         30013,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_repeated_string",
+	Tag:           "bytes,30013,rep,name=extension_repeated_string,json=extensionRepeatedString",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionRepeatedBytes = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([][]byte)(nil),
+	Field:         30014,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_repeated_bytes",
+	Tag:           "bytes,30014,rep,name=extension_repeated_bytes,json=extensionRepeatedBytes",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionRepeatedChildEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]Message_ChildEnum)(nil),
+	Field:         30015,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_repeated_child_enum",
+	Tag:           "varint,30015,rep,name=extension_repeated_child_enum,json=extensionRepeatedChildEnum,enum=google.golang.org.proto2_20180430.Message_ChildEnum",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionRepeatedChildMessage = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]*Message_ChildMessage)(nil),
+	Field:         30016,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_repeated_child_message",
+	Tag:           "bytes,30016,rep,name=extension_repeated_child_message,json=extensionRepeatedChildMessage",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionRepeatedNamedGroup = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]*Message_NamedGroup)(nil),
+	Field:         30017,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_repeated_named_group",
+	Tag:           "bytes,30017,rep,name=extension_repeated_named_group,json=extensionRepeatedNamedGroup",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionRepeatedSiblingEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]SiblingEnum)(nil),
+	Field:         30018,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_repeated_sibling_enum",
+	Tag:           "varint,30018,rep,name=extension_repeated_sibling_enum,json=extensionRepeatedSiblingEnum,enum=google.golang.org.proto2_20180430.SiblingEnum",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_ExtensionRepeatedSiblingMessage = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]*SiblingMessage)(nil),
+	Field:         30019,
+	Name:          "google.golang.org.proto2_20180430.Message.extension_repeated_sibling_message",
+	Tag:           "bytes,30019,rep,name=extension_repeated_sibling_message,json=extensionRepeatedSiblingMessage",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+var E_Message_Extensionrepeatedgroup = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]*Message_ExtensionRepeatedGroup)(nil),
+	Field:         30020,
+	Name:          "google.golang.org.proto2_20180430.Message.extensionrepeatedgroup",
+	Tag:           "group,30020,rep,name=ExtensionRepeatedGroup,json=extensionrepeatedgroup",
+	Filename:      "proto2_20180430_b4deda09/test.proto",
+}
+
+type Message_ChildMessage 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"`
+	F4                   *Message `protobuf:"bytes,4,opt,name=f4" json:"f4,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Message_ChildMessage) Reset()         { *m = Message_ChildMessage{} }
+func (m *Message_ChildMessage) String() string { return proto.CompactTextString(m) }
+func (*Message_ChildMessage) ProtoMessage()    {}
+func (*Message_ChildMessage) Descriptor() ([]byte, []int) {
+	return fileDescriptor_test_a365478be18be824, []int{1, 0}
+}
+func (m *Message_ChildMessage) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Message_ChildMessage.Unmarshal(m, b)
+}
+func (m *Message_ChildMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Message_ChildMessage.Marshal(b, m, deterministic)
+}
+func (dst *Message_ChildMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Message_ChildMessage.Merge(dst, src)
+}
+func (m *Message_ChildMessage) XXX_Size() int {
+	return xxx_messageInfo_Message_ChildMessage.Size(m)
+}
+func (m *Message_ChildMessage) XXX_DiscardUnknown() {
+	xxx_messageInfo_Message_ChildMessage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message_ChildMessage proto.InternalMessageInfo
+
+func (m *Message_ChildMessage) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_ChildMessage) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_ChildMessage) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+func (m *Message_ChildMessage) GetF4() *Message {
+	if m != nil {
+		return m.F4
+	}
+	return nil
+}
+
+type Message_NamedGroup 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"`
+	F4                   *Message `protobuf:"bytes,4,opt,name=f4" json:"f4,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Message_NamedGroup) Reset()         { *m = Message_NamedGroup{} }
+func (m *Message_NamedGroup) String() string { return proto.CompactTextString(m) }
+func (*Message_NamedGroup) ProtoMessage()    {}
+func (*Message_NamedGroup) Descriptor() ([]byte, []int) {
+	return fileDescriptor_test_a365478be18be824, []int{1, 1}
+}
+func (m *Message_NamedGroup) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Message_NamedGroup.Unmarshal(m, b)
+}
+func (m *Message_NamedGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Message_NamedGroup.Marshal(b, m, deterministic)
+}
+func (dst *Message_NamedGroup) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Message_NamedGroup.Merge(dst, src)
+}
+func (m *Message_NamedGroup) XXX_Size() int {
+	return xxx_messageInfo_Message_NamedGroup.Size(m)
+}
+func (m *Message_NamedGroup) XXX_DiscardUnknown() {
+	xxx_messageInfo_Message_NamedGroup.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message_NamedGroup proto.InternalMessageInfo
+
+func (m *Message_NamedGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_NamedGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_NamedGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+func (m *Message_NamedGroup) GetF4() *Message {
+	if m != nil {
+		return m.F4
+	}
+	return nil
+}
+
+type Message_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 (m *Message_OptionalGroup) Reset()         { *m = Message_OptionalGroup{} }
+func (m *Message_OptionalGroup) String() string { return proto.CompactTextString(m) }
+func (*Message_OptionalGroup) ProtoMessage()    {}
+func (*Message_OptionalGroup) Descriptor() ([]byte, []int) {
+	return fileDescriptor_test_a365478be18be824, []int{1, 2}
+}
+func (m *Message_OptionalGroup) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Message_OptionalGroup.Unmarshal(m, b)
+}
+func (m *Message_OptionalGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Message_OptionalGroup.Marshal(b, m, deterministic)
+}
+func (dst *Message_OptionalGroup) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Message_OptionalGroup.Merge(dst, src)
+}
+func (m *Message_OptionalGroup) XXX_Size() int {
+	return xxx_messageInfo_Message_OptionalGroup.Size(m)
+}
+func (m *Message_OptionalGroup) XXX_DiscardUnknown() {
+	xxx_messageInfo_Message_OptionalGroup.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message_OptionalGroup proto.InternalMessageInfo
+
+func (m *Message_OptionalGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_OptionalGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_OptionalGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message_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 (m *Message_RequiredGroup) Reset()         { *m = Message_RequiredGroup{} }
+func (m *Message_RequiredGroup) String() string { return proto.CompactTextString(m) }
+func (*Message_RequiredGroup) ProtoMessage()    {}
+func (*Message_RequiredGroup) Descriptor() ([]byte, []int) {
+	return fileDescriptor_test_a365478be18be824, []int{1, 3}
+}
+func (m *Message_RequiredGroup) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Message_RequiredGroup.Unmarshal(m, b)
+}
+func (m *Message_RequiredGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Message_RequiredGroup.Marshal(b, m, deterministic)
+}
+func (dst *Message_RequiredGroup) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Message_RequiredGroup.Merge(dst, src)
+}
+func (m *Message_RequiredGroup) XXX_Size() int {
+	return xxx_messageInfo_Message_RequiredGroup.Size(m)
+}
+func (m *Message_RequiredGroup) XXX_DiscardUnknown() {
+	xxx_messageInfo_Message_RequiredGroup.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message_RequiredGroup proto.InternalMessageInfo
+
+func (m *Message_RequiredGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_RequiredGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_RequiredGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message_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 (m *Message_RepeatedGroup) Reset()         { *m = Message_RepeatedGroup{} }
+func (m *Message_RepeatedGroup) String() string { return proto.CompactTextString(m) }
+func (*Message_RepeatedGroup) ProtoMessage()    {}
+func (*Message_RepeatedGroup) Descriptor() ([]byte, []int) {
+	return fileDescriptor_test_a365478be18be824, []int{1, 4}
+}
+func (m *Message_RepeatedGroup) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Message_RepeatedGroup.Unmarshal(m, b)
+}
+func (m *Message_RepeatedGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Message_RepeatedGroup.Marshal(b, m, deterministic)
+}
+func (dst *Message_RepeatedGroup) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Message_RepeatedGroup.Merge(dst, src)
+}
+func (m *Message_RepeatedGroup) XXX_Size() int {
+	return xxx_messageInfo_Message_RepeatedGroup.Size(m)
+}
+func (m *Message_RepeatedGroup) XXX_DiscardUnknown() {
+	xxx_messageInfo_Message_RepeatedGroup.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message_RepeatedGroup proto.InternalMessageInfo
+
+func (m *Message_RepeatedGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_RepeatedGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_RepeatedGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message_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 (m *Message_OneofGroup) Reset()         { *m = Message_OneofGroup{} }
+func (m *Message_OneofGroup) String() string { return proto.CompactTextString(m) }
+func (*Message_OneofGroup) ProtoMessage()    {}
+func (*Message_OneofGroup) Descriptor() ([]byte, []int) {
+	return fileDescriptor_test_a365478be18be824, []int{1, 33}
+}
+func (m *Message_OneofGroup) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Message_OneofGroup.Unmarshal(m, b)
+}
+func (m *Message_OneofGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Message_OneofGroup.Marshal(b, m, deterministic)
+}
+func (dst *Message_OneofGroup) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Message_OneofGroup.Merge(dst, src)
+}
+func (m *Message_OneofGroup) XXX_Size() int {
+	return xxx_messageInfo_Message_OneofGroup.Size(m)
+}
+func (m *Message_OneofGroup) XXX_DiscardUnknown() {
+	xxx_messageInfo_Message_OneofGroup.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message_OneofGroup proto.InternalMessageInfo
+
+func (m *Message_OneofGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_OneofGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_OneofGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message_ExtensionOptionalGroup 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 (m *Message_ExtensionOptionalGroup) Reset()         { *m = Message_ExtensionOptionalGroup{} }
+func (m *Message_ExtensionOptionalGroup) String() string { return proto.CompactTextString(m) }
+func (*Message_ExtensionOptionalGroup) ProtoMessage()    {}
+func (*Message_ExtensionOptionalGroup) Descriptor() ([]byte, []int) {
+	return fileDescriptor_test_a365478be18be824, []int{1, 34}
+}
+func (m *Message_ExtensionOptionalGroup) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Message_ExtensionOptionalGroup.Unmarshal(m, b)
+}
+func (m *Message_ExtensionOptionalGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Message_ExtensionOptionalGroup.Marshal(b, m, deterministic)
+}
+func (dst *Message_ExtensionOptionalGroup) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Message_ExtensionOptionalGroup.Merge(dst, src)
+}
+func (m *Message_ExtensionOptionalGroup) XXX_Size() int {
+	return xxx_messageInfo_Message_ExtensionOptionalGroup.Size(m)
+}
+func (m *Message_ExtensionOptionalGroup) XXX_DiscardUnknown() {
+	xxx_messageInfo_Message_ExtensionOptionalGroup.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message_ExtensionOptionalGroup proto.InternalMessageInfo
+
+func (m *Message_ExtensionOptionalGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_ExtensionOptionalGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_ExtensionOptionalGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message_ExtensionRepeatedGroup 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 (m *Message_ExtensionRepeatedGroup) Reset()         { *m = Message_ExtensionRepeatedGroup{} }
+func (m *Message_ExtensionRepeatedGroup) String() string { return proto.CompactTextString(m) }
+func (*Message_ExtensionRepeatedGroup) ProtoMessage()    {}
+func (*Message_ExtensionRepeatedGroup) Descriptor() ([]byte, []int) {
+	return fileDescriptor_test_a365478be18be824, []int{1, 35}
+}
+func (m *Message_ExtensionRepeatedGroup) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Message_ExtensionRepeatedGroup.Unmarshal(m, b)
+}
+func (m *Message_ExtensionRepeatedGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Message_ExtensionRepeatedGroup.Marshal(b, m, deterministic)
+}
+func (dst *Message_ExtensionRepeatedGroup) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Message_ExtensionRepeatedGroup.Merge(dst, src)
+}
+func (m *Message_ExtensionRepeatedGroup) XXX_Size() int {
+	return xxx_messageInfo_Message_ExtensionRepeatedGroup.Size(m)
+}
+func (m *Message_ExtensionRepeatedGroup) XXX_DiscardUnknown() {
+	xxx_messageInfo_Message_ExtensionRepeatedGroup.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message_ExtensionRepeatedGroup proto.InternalMessageInfo
+
+func (m *Message_ExtensionRepeatedGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_ExtensionRepeatedGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_ExtensionRepeatedGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*SiblingMessage)(nil), "google.golang.org.proto2_20180430.SiblingMessage")
+	proto.RegisterType((*Message)(nil), "google.golang.org.proto2_20180430.Message")
+	proto.RegisterMapType((map[bool]bool)(nil), "google.golang.org.proto2_20180430.Message.MapBoolBoolEntry")
+	proto.RegisterMapType((map[bool][]byte)(nil), "google.golang.org.proto2_20180430.Message.MapBoolBytesEntry")
+	proto.RegisterMapType((map[bool]Message_ChildEnum)(nil), "google.golang.org.proto2_20180430.Message.MapBoolChildEnumEntry")
+	proto.RegisterMapType((map[bool]*Message_ChildMessage)(nil), "google.golang.org.proto2_20180430.Message.MapBoolChildMessageEntry")
+	proto.RegisterMapType((map[bool]float64)(nil), "google.golang.org.proto2_20180430.Message.MapBoolDoubleEntry")
+	proto.RegisterMapType((map[bool]uint32)(nil), "google.golang.org.proto2_20180430.Message.MapBoolFixed32Entry")
+	proto.RegisterMapType((map[bool]uint64)(nil), "google.golang.org.proto2_20180430.Message.MapBoolFixed64Entry")
+	proto.RegisterMapType((map[bool]float32)(nil), "google.golang.org.proto2_20180430.Message.MapBoolFloatEntry")
+	proto.RegisterMapType((map[bool]int32)(nil), "google.golang.org.proto2_20180430.Message.MapBoolInt32Entry")
+	proto.RegisterMapType((map[bool]int64)(nil), "google.golang.org.proto2_20180430.Message.MapBoolInt64Entry")
+	proto.RegisterMapType((map[bool]*Message_NamedGroup)(nil), "google.golang.org.proto2_20180430.Message.MapBoolNamedGroupEntry")
+	proto.RegisterMapType((map[bool]int32)(nil), "google.golang.org.proto2_20180430.Message.MapBoolSfixed32Entry")
+	proto.RegisterMapType((map[bool]int64)(nil), "google.golang.org.proto2_20180430.Message.MapBoolSfixed64Entry")
+	proto.RegisterMapType((map[bool]SiblingEnum)(nil), "google.golang.org.proto2_20180430.Message.MapBoolSiblingEnumEntry")
+	proto.RegisterMapType((map[bool]*SiblingMessage)(nil), "google.golang.org.proto2_20180430.Message.MapBoolSiblingMessageEntry")
+	proto.RegisterMapType((map[bool]int32)(nil), "google.golang.org.proto2_20180430.Message.MapBoolSint32Entry")
+	proto.RegisterMapType((map[bool]int64)(nil), "google.golang.org.proto2_20180430.Message.MapBoolSint64Entry")
+	proto.RegisterMapType((map[bool]string)(nil), "google.golang.org.proto2_20180430.Message.MapBoolStringEntry")
+	proto.RegisterMapType((map[bool]uint32)(nil), "google.golang.org.proto2_20180430.Message.MapBoolUint32Entry")
+	proto.RegisterMapType((map[bool]uint64)(nil), "google.golang.org.proto2_20180430.Message.MapBoolUint64Entry")
+	proto.RegisterMapType((map[uint32]bool)(nil), "google.golang.org.proto2_20180430.Message.MapFixed32BoolEntry")
+	proto.RegisterMapType((map[int32]bool)(nil), "google.golang.org.proto2_20180430.Message.MapInt32BoolEntry")
+	proto.RegisterMapType((map[int64]bool)(nil), "google.golang.org.proto2_20180430.Message.MapInt64BoolEntry")
+	proto.RegisterMapType((map[int32]bool)(nil), "google.golang.org.proto2_20180430.Message.MapSint32BoolEntry")
+	proto.RegisterMapType((map[int64]bool)(nil), "google.golang.org.proto2_20180430.Message.MapSint64BoolEntry")
+	proto.RegisterMapType((map[string]bool)(nil), "google.golang.org.proto2_20180430.Message.MapStringBoolEntry")
+	proto.RegisterMapType((map[uint32]bool)(nil), "google.golang.org.proto2_20180430.Message.MapUint32BoolEntry")
+	proto.RegisterMapType((map[uint64]bool)(nil), "google.golang.org.proto2_20180430.Message.MapUint64BoolEntry")
+	proto.RegisterType((*Message_ChildMessage)(nil), "google.golang.org.proto2_20180430.Message.ChildMessage")
+	proto.RegisterType((*Message_NamedGroup)(nil), "google.golang.org.proto2_20180430.Message.NamedGroup")
+	proto.RegisterType((*Message_OptionalGroup)(nil), "google.golang.org.proto2_20180430.Message.OptionalGroup")
+	proto.RegisterType((*Message_RequiredGroup)(nil), "google.golang.org.proto2_20180430.Message.RequiredGroup")
+	proto.RegisterType((*Message_RepeatedGroup)(nil), "google.golang.org.proto2_20180430.Message.RepeatedGroup")
+	proto.RegisterType((*Message_OneofGroup)(nil), "google.golang.org.proto2_20180430.Message.OneofGroup")
+	proto.RegisterType((*Message_ExtensionOptionalGroup)(nil), "google.golang.org.proto2_20180430.Message.ExtensionOptionalGroup")
+	proto.RegisterType((*Message_ExtensionRepeatedGroup)(nil), "google.golang.org.proto2_20180430.Message.ExtensionRepeatedGroup")
+	proto.RegisterEnum("google.golang.org.proto2_20180430.SiblingEnum", SiblingEnum_name, SiblingEnum_value)
+	proto.RegisterEnum("google.golang.org.proto2_20180430.Message_ChildEnum", Message_ChildEnum_name, Message_ChildEnum_value)
+	proto.RegisterExtension(E_Message_ExtensionOptionalBool)
+	proto.RegisterExtension(E_Message_ExtensionOptionalInt32)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSint32)
+	proto.RegisterExtension(E_Message_ExtensionOptionalUint32)
+	proto.RegisterExtension(E_Message_ExtensionOptionalInt64)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSint64)
+	proto.RegisterExtension(E_Message_ExtensionOptionalUint64)
+	proto.RegisterExtension(E_Message_ExtensionOptionalFixed32)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSfixed32)
+	proto.RegisterExtension(E_Message_ExtensionOptionalFloat)
+	proto.RegisterExtension(E_Message_ExtensionOptionalFixed64)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSfixed64)
+	proto.RegisterExtension(E_Message_ExtensionOptionalDouble)
+	proto.RegisterExtension(E_Message_ExtensionOptionalString)
+	proto.RegisterExtension(E_Message_ExtensionOptionalBytes)
+	proto.RegisterExtension(E_Message_ExtensionOptionalChildEnum)
+	proto.RegisterExtension(E_Message_ExtensionOptionalChildMessage)
+	proto.RegisterExtension(E_Message_ExtensionOptionalNamedGroup)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSiblingEnum)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSiblingMessage)
+	proto.RegisterExtension(E_Message_Extensionoptionalgroup)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedBool)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedInt32)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedSint32)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedUint32)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedInt64)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedSint64)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedUint64)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedFixed32)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedSfixed32)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedFloat)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedFixed64)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedSfixed64)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedDouble)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedString)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedBytes)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedChildEnum)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedSiblingEnum)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedBool)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedInt32)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSint32)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedUint32)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedInt64)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSint64)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedUint64)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedFixed32)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSfixed32)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedFloat)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedFixed64)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSfixed64)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedDouble)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedString)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedBytes)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedChildEnum)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedChildMessage)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedNamedGroup)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSiblingEnum)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSiblingMessage)
+	proto.RegisterExtension(E_Message_Extensionrepeatedgroup)
+}
+
+func init() {
+	proto.RegisterFile("proto2_20180430_b4deda09/test.proto", fileDescriptor_test_a365478be18be824)
+}
+
+var fileDescriptor_test_a365478be18be824 = []byte{
+	// 4468 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x5c, 0x67, 0x70, 0x24, 0xc7,
+	0x75, 0xc6, 0xec, 0x62, 0x17, 0x87, 0x3e, 0x2c, 0xb0, 0x98, 0xbb, 0x03, 0xe6, 0x40, 0xd2, 0x5c,
+	0x9d, 0x64, 0x79, 0x4d, 0xf3, 0x70, 0xc0, 0xa0, 0xd1, 0xc7, 0x5b, 0x33, 0x08, 0x20, 0x8f, 0x5a,
+	0xca, 0xe2, 0x52, 0x35, 0xac, 0x73, 0xb9, 0x5c, 0x2c, 0xc3, 0xc0, 0x61, 0x81, 0x03, 0xb9, 0x01,
+	0x04, 0x76, 0x49, 0x9e, 0x25, 0x17, 0xcf, 0x72, 0xfc, 0x49, 0xe5, 0xb4, 0x92, 0x28, 0x66, 0x89,
+	0x51, 0x39, 0x31, 0x29, 0xd8, 0xa6, 0x72, 0x72, 0x90, 0x93, 0x9c, 0x93, 0x9c, 0x73, 0x0e, 0xd5,
+	0xfd, 0xba, 0xa7, 0xbb, 0x67, 0x7a, 0x16, 0xe8, 0x59, 0x15, 0x7f, 0xb0, 0x8a, 0xd7, 0xfb, 0xfa,
+	0x7d, 0xfd, 0xbe, 0xed, 0xf7, 0xde, 0x87, 0x9e, 0xe9, 0x45, 0x2f, 0xdd, 0xde, 0x69, 0x77, 0xda,
+	0xfe, 0x8a, 0x3f, 0x37, 0x7f, 0xc5, 0x1c, 0x5e, 0x98, 0x5b, 0x59, 0xc3, 0xeb, 0xf5, 0xf5, 0xd5,
+	0xb9, 0x53, 0x27, 0x3a, 0xf5, 0xdd, 0xce, 0x2c, 0xfb, 0xd4, 0x7d, 0xc9, 0x66, 0xbb, 0xbd, 0xd9,
+	0xa8, 0xcf, 0x6e, 0xb6, 0x1b, 0xab, 0xad, 0xcd, 0xd9, 0xf6, 0xce, 0xe6, 0x6c, 0x64, 0xda, 0xb1,
+	0xd7, 0xa1, 0xf1, 0x9b, 0xb7, 0xd6, 0x1a, 0x5b, 0xad, 0xcd, 0x1b, 0xeb, 0xbb, 0xbb, 0xab, 0x9b,
+	0x75, 0x77, 0x1c, 0x65, 0x36, 0xe6, 0x3d, 0xa7, 0xe4, 0x94, 0x47, 0x83, 0xcc, 0xc6, 0x3c, 0xfb,
+	0xb7, 0xef, 0x65, 0x4a, 0x19, 0xf6, 0x6f, 0x9f, 0xfd, 0x7b, 0xc1, 0xcb, 0x96, 0xb2, 0xec, 0xdf,
+	0x0b, 0x6e, 0x05, 0x65, 0x36, 0xb0, 0x37, 0x5c, 0x72, 0xca, 0x07, 0xfd, 0xcb, 0x66, 0xf7, 0x44,
+	0x9c, 0xe5, 0x38, 0x41, 0x66, 0x03, 0x1f, 0xfb, 0xce, 0xa3, 0x0e, 0x1a, 0x11, 0xc0, 0x67, 0x10,
+	0x6a, 0xad, 0x36, 0xeb, 0xeb, 0x9b, 0x3b, 0xed, 0xee, 0x36, 0x5b, 0x00, 0xf2, 0x17, 0xf7, 0xef,
+	0x70, 0xb6, 0x46, 0x27, 0xbf, 0x92, 0x4e, 0x0e, 0x14, 0x47, 0xee, 0x4b, 0x51, 0xa1, 0xbd, 0xdd,
+	0xd9, 0x6a, 0xb7, 0x56, 0x1b, 0x2b, 0x6b, 0xed, 0x76, 0xc3, 0x5b, 0x2f, 0x39, 0xe5, 0x03, 0xc1,
+	0x98, 0x18, 0x5c, 0x6e, 0xb7, 0x1b, 0xee, 0xf7, 0xa3, 0xf1, 0xd0, 0x68, 0xab, 0xd5, 0x59, 0xf0,
+	0xbd, 0x7a, 0xc9, 0x29, 0xe7, 0x82, 0x70, 0xea, 0x0d, 0x74, 0xd0, 0xfd, 0x01, 0x34, 0x11, 0x9a,
+	0xed, 0x82, 0xdd, 0x46, 0xc9, 0x29, 0x4f, 0x06, 0xe1, 0xec, 0x9b, 0xb7, 0x62, 0x86, 0x5d, 0x30,
+	0xdc, 0x2c, 0x39, 0xe5, 0x82, 0x34, 0x3c, 0x03, 0x86, 0x11, 0x60, 0x82, 0xbd, 0x73, 0x25, 0xa7,
+	0x9c, 0xd5, 0x80, 0x09, 0x8e, 0x01, 0x13, 0xec, 0x6d, 0x95, 0x9c, 0xb2, 0xab, 0x03, 0x47, 0x0c,
+	0xbb, 0x60, 0x78, 0x6b, 0xc9, 0x29, 0x0f, 0xeb, 0xc0, 0x04, 0xbb, 0x3f, 0x88, 0x8a, 0xa1, 0xe1,
+	0xc6, 0xd6, 0x5d, 0xf5, 0xf5, 0x05, 0xdf, 0xbb, 0xad, 0xe4, 0x94, 0x47, 0x82, 0xd0, 0xc1, 0xf5,
+	0x30, 0xec, 0xfe, 0x10, 0x9a, 0x94, 0xe0, 0xc2, 0xb6, 0x51, 0x72, 0xca, 0x13, 0x41, 0xe8, 0xe3,
+	0x66, 0x3e, 0xae, 0x05, 0xb4, 0xd1, 0x68, 0xaf, 0x76, 0xbc, 0x66, 0xc9, 0x29, 0x67, 0x64, 0x40,
+	0xd7, 0xd3, 0xc1, 0x38, 0x3c, 0xc1, 0x5e, 0xab, 0xe4, 0x94, 0xf3, 0x11, 0x78, 0x82, 0x0d, 0xf0,
+	0x04, 0x7b, 0xed, 0x92, 0x53, 0x2e, 0x46, 0xe1, 0x23, 0xf1, 0xaf, 0xb7, 0xbb, 0x6b, 0x8d, 0xba,
+	0xb7, 0x5d, 0x72, 0xca, 0x8e, 0x8c, 0xff, 0x3a, 0x36, 0xaa, 0x33, 0xda, 0xd9, 0xd9, 0x6a, 0x6d,
+	0x7a, 0xb7, 0xb3, 0x3d, 0x2f, 0x19, 0x65, 0xa3, 0x5a, 0x40, 0x6b, 0xe7, 0x3b, 0xf5, 0x5d, 0x6f,
+	0xa7, 0xe4, 0x94, 0xc7, 0x64, 0x40, 0xcb, 0x74, 0xd0, 0x5d, 0x47, 0x87, 0x42, 0xb3, 0xb3, 0xe7,
+	0xb6, 0x1a, 0xeb, 0x2b, 0xf5, 0x56, 0xb7, 0xe9, 0xed, 0x96, 0x9c, 0xf2, 0xb8, 0x8f, 0x2d, 0xb6,
+	0xf1, 0xb5, 0x74, 0xf2, 0xe9, 0x56, 0xb7, 0x19, 0x84, 0x61, 0x87, 0x43, 0x6e, 0x13, 0x4d, 0x45,
+	0x50, 0x9a, 0x30, 0xcd, 0xeb, 0xb0, 0x04, 0x3c, 0x69, 0x0b, 0x24, 0xb2, 0xf1, 0xb0, 0x86, 0x25,
+	0x52, 0x72, 0x13, 0x85, 0xe3, 0x2b, 0x2c, 0xa5, 0x56, 0x20, 0x39, 0xbb, 0x0c, 0x2c, 0x65, 0x72,
+	0xba, 0xc2, 0xa5, 0x1c, 0x73, 0xd7, 0xd0, 0x11, 0x65, 0x7f, 0xb3, 0x7a, 0x04, 0xfc, 0xdd, 0xc1,
+	0xf8, 0x9b, 0xdd, 0x07, 0x12, 0x2f, 0x63, 0x8c, 0xb9, 0x43, 0x32, 0x2b, 0xc2, 0x41, 0xf7, 0x36,
+	0xe4, 0xc5, 0x30, 0x04, 0x7b, 0x77, 0xb2, 0x80, 0xe6, 0xf7, 0x0f, 0x23, 0x78, 0x9b, 0x8a, 0x20,
+	0x09, 0xe6, 0x7e, 0x42, 0x56, 0x1d, 0xa0, 0xec, 0x2e, 0x56, 0xcf, 0xae, 0xb0, 0xa0, 0xec, 0x26,
+	0x3e, 0x1f, 0x58, 0xd3, 0xdd, 0xb9, 0x97, 0xa3, 0xf1, 0xf5, 0xfa, 0xc6, 0x6a, 0xb7, 0xd1, 0xa9,
+	0xaf, 0x43, 0x59, 0x7b, 0x81, 0x56, 0xcc, 0x03, 0x95, 0xe1, 0xce, 0x4e, 0xb7, 0x1e, 0x14, 0xc2,
+	0x0f, 0x59, 0x79, 0x9b, 0x43, 0x13, 0xd2, 0x1a, 0xca, 0xd1, 0x17, 0xa8, 0x79, 0xae, 0x92, 0x3f,
+	0x3e, 0xef, 0x2f, 0xe0, 0xc5, 0x40, 0x7a, 0x83, 0x4a, 0x37, 0x8f, 0x8a, 0x72, 0x06, 0x2f, 0x75,
+	0x5f, 0xa4, 0x53, 0x26, 0x2b, 0xb9, 0xe3, 0x0b, 0xfe, 0xdc, 0x5c, 0x20, 0x3d, 0xf2, 0x9a, 0x37,
+	0xa7, 0x4e, 0xe1, 0x45, 0xef, 0x4b, 0x74, 0x4a, 0xa1, 0x32, 0x1c, 0x99, 0xc1, 0x8b, 0x1f, 0x8e,
+	0x2c, 0x8b, 0x60, 0xef, 0xcb, 0x74, 0x42, 0xb6, 0x82, 0x60, 0x59, 0xe4, 0xe4, 0x15, 0xa7, 0xf4,
+	0xa5, 0x11, 0x1c, 0x5f, 0x1a, 0xc1, 0xde, 0x57, 0xe8, 0x34, 0xb7, 0x92, 0x3b, 0x4e, 0x70, 0x6c,
+	0x69, 0x04, 0xc7, 0x97, 0x46, 0xb0, 0xf7, 0x55, 0x3a, 0x65, 0xb8, 0x32, 0x1c, 0x99, 0xc1, 0xcb,
+	0x23, 0x46, 0x93, 0x72, 0x86, 0xa8, 0x79, 0x5f, 0xa3, 0x53, 0x46, 0x2a, 0x79, 0x1a, 0xcd, 0xdc,
+	0x5c, 0x20, 0x7d, 0x8a, 0x4a, 0x79, 0x12, 0xb9, 0xca, 0xd2, 0xc4, 0xb4, 0xaf, 0xd3, 0x69, 0x13,
+	0x95, 0x91, 0xe3, 0x7c, 0x9e, 0xf4, 0x1c, 0x56, 0xcd, 0x79, 0x95, 0x09, 0x28, 0x9b, 0xdf, 0xa0,
+	0xb3, 0x32, 0x95, 0x91, 0x85, 0xd9, 0x79, 0x3c, 0xbf, 0xa8, 0xd2, 0x00, 0x15, 0x34, 0xbe, 0x42,
+	0x82, 0xbd, 0x6f, 0xd2, 0x49, 0xf9, 0x4a, 0x9e, 0x06, 0x15, 0x5f, 0x21, 0xc1, 0xa6, 0x15, 0x12,
+	0xec, 0x7d, 0x8b, 0x4e, 0x2b, 0x56, 0x46, 0x8e, 0xf3, 0x79, 0xd1, 0x15, 0x12, 0xec, 0x9e, 0x52,
+	0x29, 0xe4, 0x95, 0xf5, 0xd7, 0xe8, 0x34, 0xa7, 0x52, 0xe0, 0x4b, 0xf4, 0xc9, 0xe2, 0xc2, 0xe2,
+	0x29, 0x85, 0x4b, 0x5e, 0x6a, 0xaf, 0xd4, 0xbe, 0x30, 0xa8, 0xb5, 0xbf, 0xce, 0x04, 0x46, 0xa5,
+	0x78, 0xae, 0xde, 0x68, 0xb4, 0x2f, 0x2f, 0x1d, 0xbb, 0xb3, 0xbd, 0xd3, 0x58, 0x7f, 0xc9, 0x31,
+	0xa4, 0x7e, 0x77, 0x50, 0x7f, 0x97, 0x55, 0x6a, 0xa0, 0x00, 0xff, 0x06, 0x9d, 0x3c, 0x56, 0xf1,
+	0xd6, 0xeb, 0xab, 0xeb, 0xb7, 0x2c, 0x2c, 0x90, 0x5b, 0xfc, 0xc5, 0xc5, 0x5b, 0xfc, 0x93, 0xe4,
+	0x96, 0x85, 0xc5, 0x93, 0x6b, 0xf5, 0xfa, 0x86, 0xc2, 0x15, 0x14, 0xe7, 0x16, 0x3a, 0x2c, 0x7d,
+	0x28, 0xd5, 0xf9, 0x37, 0x9d, 0xf4, 0xe5, 0xb9, 0x92, 0x5b, 0x7a, 0xf5, 0x6b, 0xaa, 0x4b, 0x81,
+	0xe4, 0x53, 0x96, 0xe9, 0x06, 0x9a, 0x52, 0xb7, 0xa8, 0x52, 0xcf, 0xbe, 0xed, 0xa4, 0x29, 0x68,
+	0x02, 0xeb, 0xb0, 0xb2, 0xb1, 0x65, 0x61, 0x7b, 0x19, 0x2a, 0xec, 0xd4, 0x6f, 0xef, 0x6e, 0xed,
+	0x88, 0x52, 0xf0, 0x18, 0x55, 0x6b, 0x07, 0x82, 0x31, 0x31, 0xca, 0x6a, 0xc0, 0xcb, 0xd1, 0x78,
+	0x68, 0x05, 0xc9, 0xf9, 0x38, 0x35, 0xcb, 0x05, 0xe1, 0x64, 0xc8, 0xfc, 0x32, 0x9a, 0x08, 0xed,
+	0x78, 0xe2, 0x3f, 0x41, 0x0d, 0x27, 0x83, 0x70, 0x3e, 0x4f, 0x78, 0xd5, 0x92, 0xe7, 0xfb, 0x93,
+	0xd4, 0xb2, 0x20, 0x2d, 0x79, 0xa2, 0x47, 0xb0, 0x09, 0xf6, 0x9e, 0xa2, 0x86, 0x59, 0x0d, 0x9b,
+	0xe0, 0x18, 0x36, 0xc1, 0xde, 0x07, 0xa9, 0xa1, 0xab, 0x63, 0x47, 0x2c, 0x79, 0x42, 0x7f, 0x88,
+	0x5a, 0x0e, 0xeb, 0xd8, 0x04, 0xbb, 0x97, 0xa1, 0x62, 0x68, 0x29, 0x32, 0xf2, 0xc3, 0xd4, 0x74,
+	0x24, 0x08, 0x5d, 0x88, 0xfc, 0xbd, 0x1c, 0x4d, 0x4a, 0x7c, 0x61, 0xfc, 0x11, 0x6a, 0x3c, 0x11,
+	0x84, 0x5e, 0xc2, 0xa4, 0x55, 0xa3, 0x82, 0x9c, 0xfd, 0x28, 0x35, 0xcd, 0xc8, 0xa8, 0x20, 0x53,
+	0x63, 0x2b, 0x20, 0xd8, 0xfb, 0x18, 0xb5, 0xcc, 0x47, 0x56, 0x40, 0xb0, 0x61, 0x05, 0x04, 0x7b,
+	0x1f, 0xa7, 0xc6, 0xc5, 0xe8, 0x0a, 0x22, 0x2c, 0xf0, 0x9c, 0xfc, 0x04, 0xb5, 0x75, 0x24, 0x0b,
+	0x3c, 0x07, 0x35, 0x66, 0x21, 0x05, 0x3f, 0x09, 0x9a, 0x5e, 0x32, 0x0b, 0xf9, 0xa6, 0x46, 0x05,
+	0xe9, 0xf6, 0x29, 0x6a, 0x38, 0x26, 0xa3, 0x82, 0x9c, 0xaa, 0xa3, 0x43, 0xa1, 0x9d, 0x92, 0x52,
+	0x9f, 0xa6, 0xc6, 0xa9, 0x15, 0x8f, 0xf0, 0x28, 0x53, 0xa9, 0x85, 0xa6, 0x22, 0x30, 0xa2, 0x67,
+	0x3f, 0x4d, 0x91, 0x06, 0x91, 0x3c, 0x1a, 0x98, 0x68, 0xdc, 0xe7, 0x50, 0x38, 0xae, 0x49, 0x9e,
+	0x67, 0x00, 0x2d, 0xad, 0xe6, 0x11, 0x3e, 0x15, 0xcd, 0x73, 0x16, 0x1d, 0x51, 0x36, 0xbb, 0x52,
+	0x23, 0x9e, 0x05, 0x0a, 0xad, 0x45, 0x8f, 0x4c, 0x11, 0x59, 0x1b, 0x1a, 0xc8, 0x8b, 0x81, 0x08,
+	0x02, 0x9f, 0x83, 0x90, 0xd2, 0xa8, 0x9e, 0x08, 0x94, 0x20, 0x6f, 0x45, 0x56, 0x22, 0x60, 0xed,
+	0x79, 0x0a, 0x61, 0x27, 0x7b, 0x02, 0xee, 0x80, 0xcb, 0x1e, 0xcd, 0x9f, 0x7b, 0x15, 0x9a, 0x96,
+	0x1b, 0x5e, 0xd7, 0x3f, 0xf7, 0x64, 0x69, 0xd1, 0xe3, 0xfa, 0x27, 0x64, 0xf6, 0x3a, 0x4d, 0x07,
+	0x2d, 0x29, 0x6c, 0x44, 0x05, 0xd1, 0x1b, 0xe8, 0x7c, 0x29, 0x88, 0xa6, 0x62, 0x1e, 0xa0, 0x3c,
+	0x2e, 0xa3, 0xa3, 0x06, 0x17, 0xbc, 0x50, 0xbe, 0x91, 0xfa, 0x08, 0x15, 0xd2, 0x74, 0xcc, 0x05,
+	0x2f, 0x9c, 0x4b, 0x46, 0x1f, 0xbc, 0x84, 0xbe, 0x89, 0xfa, 0x10, 0x92, 0x29, 0xee, 0x82, 0x57,
+	0xd4, 0xd3, 0x49, 0x91, 0x10, 0xec, 0xbd, 0x99, 0x7a, 0xd0, 0x35, 0x94, 0x31, 0x1a, 0x82, 0xfb,
+	0x44, 0x43, 0xb0, 0xf7, 0x16, 0xea, 0x27, 0x14, 0x55, 0xe6, 0x68, 0x08, 0xee, 0x13, 0x0d, 0xc1,
+	0xde, 0x5b, 0xa9, 0x0f, 0xa1, 0xb2, 0xcc, 0xd1, 0x10, 0xec, 0x9e, 0x46, 0x33, 0x06, 0x17, 0xa2,
+	0x00, 0xbf, 0x8d, 0xfa, 0x90, 0xb2, 0xcb, 0x8b, 0x79, 0x11, 0xe5, 0xbb, 0x8a, 0x2e, 0x32, 0x45,
+	0x23, 0xfc, 0xbc, 0x9d, 0xfa, 0x51, 0x74, 0xd8, 0xd1, 0x78, 0x44, 0xa2, 0xb4, 0x2f, 0x1b, 0xe9,
+	0x85, 0x22, 0xff, 0x0e, 0xea, 0x46, 0x11, 0x66, 0x71, 0x6e, 0xa1, 0xec, 0xf7, 0x09, 0x8a, 0x60,
+	0xef, 0x9d, 0xd4, 0x8b, 0x54, 0x6a, 0x09, 0x41, 0x11, 0xdc, 0x37, 0x28, 0x82, 0xbd, 0x77, 0x51,
+	0x3f, 0x8a, 0x74, 0x4b, 0x0a, 0x8a, 0x60, 0xf7, 0x55, 0xc6, 0x2f, 0x8a, 0xf7, 0x8d, 0x1e, 0xf5,
+	0x13, 0xd3, 0x72, 0xf1, 0x6f, 0x8c, 0xf7, 0x93, 0x1b, 0xcd, 0x1b, 0x07, 0x3a, 0xcb, 0xbb, 0xa9,
+	0x2f, 0x93, 0xb8, 0x33, 0xec, 0x21, 0x68, 0x3a, 0x37, 0x1b, 0xf9, 0x86, 0xf6, 0xf3, 0x1e, 0xea,
+	0xad, 0x9f, 0xda, 0x8b, 0x7f, 0x01, 0xd0, 0xa1, 0xee, 0x46, 0x97, 0x18, 0x9c, 0x2a, 0xbd, 0xea,
+	0xbd, 0xd9, 0xf4, 0xbd, 0x4a, 0x48, 0xb2, 0x99, 0x18, 0xb8, 0xec, 0x5d, 0x3f, 0x8d, 0x2e, 0x35,
+	0x66, 0x97, 0x52, 0xeb, 0xef, 0xcd, 0xa6, 0xa9, 0xf5, 0x02, 0xfc, 0x62, 0x43, 0x4e, 0x46, 0x74,
+	0xe1, 0x76, 0x7d, 0x35, 0x2c, 0x91, 0xff, 0x9c, 0x2d, 0x65, 0x41, 0x17, 0xc2, 0xa8, 0xd4, 0x85,
+	0xdc, 0x0a, 0x2a, 0xd0, 0xbf, 0x50, 0x33, 0xa6, 0x0b, 0x61, 0x58, 0xd1, 0x85, 0xdc, 0x8e, 0x97,
+	0xbb, 0x7f, 0xa5, 0x86, 0x4c, 0x17, 0xc2, 0xb8, 0xaa, 0x0b, 0xb9, 0x25, 0x2f, 0x6a, 0xff, 0x46,
+	0x2d, 0x0b, 0xd2, 0x52, 0xd5, 0x85, 0x12, 0x9b, 0x60, 0xef, 0xdf, 0xa9, 0x61, 0x56, 0xc3, 0x16,
+	0x3a, 0x47, 0xc1, 0x26, 0xd8, 0xfb, 0x0f, 0x6a, 0xe8, 0xea, 0xd8, 0x11, 0x4b, 0x5e, 0x82, 0xfe,
+	0x93, 0x5a, 0x0e, 0xeb, 0xd8, 0x42, 0x17, 0x72, 0x4b, 0x51, 0x21, 0xfe, 0x8b, 0x9a, 0x32, 0x5d,
+	0x08, 0x1f, 0x68, 0xba, 0x50, 0xe0, 0x0b, 0xe3, 0xff, 0xa6, 0xc6, 0x4c, 0x17, 0xf2, 0x15, 0x68,
+	0xba, 0x50, 0x78, 0x66, 0x25, 0xe3, 0x7f, 0xa8, 0x69, 0x46, 0x46, 0xa5, 0xe8, 0x42, 0x75, 0x05,
+	0x04, 0x7b, 0xff, 0x4b, 0x2d, 0xf3, 0x91, 0x15, 0x08, 0x5d, 0xa8, 0xad, 0x80, 0x60, 0xef, 0xff,
+	0xa8, 0x71, 0x31, 0xba, 0x82, 0x08, 0x0b, 0x3c, 0xbf, 0x2f, 0x0c, 0x97, 0xb2, 0xa0, 0x0b, 0x61,
+	0x5c, 0xd5, 0x85, 0xc2, 0x2f, 0x64, 0xef, 0xcf, 0x0c, 0xb3, 0xb3, 0x5d, 0xc9, 0xac, 0xa2, 0x0b,
+	0xc5, 0x6e, 0x62, 0x89, 0xf9, 0x7a, 0x6a, 0x38, 0x26, 0xa3, 0x52, 0x74, 0x21, 0xb7, 0x53, 0x72,
+	0xed, 0x67, 0xa9, 0xf1, 0x00, 0xba, 0x10, 0x3c, 0x46, 0x74, 0xa1, 0x06, 0x23, 0x64, 0xcd, 0xcf,
+	0x51, 0xa4, 0xc1, 0x74, 0xa1, 0x02, 0xa6, 0xe9, 0x42, 0x8e, 0xa7, 0xea, 0xc2, 0x9f, 0x07, 0xb4,
+	0xf4, 0xba, 0x10, 0x7c, 0x46, 0x75, 0x61, 0xb8, 0xd9, 0x95, 0x5a, 0xf1, 0x0b, 0x40, 0x61, 0x0a,
+	0x5d, 0x28, 0x52, 0x24, 0xa2, 0x0b, 0x23, 0x20, 0x82, 0xc0, 0x5f, 0x84, 0x90, 0xd2, 0xe9, 0x42,
+	0x0d, 0x4a, 0xd3, 0x85, 0xf0, 0x09, 0xb0, 0xf6, 0x4b, 0x14, 0xc2, 0x56, 0x17, 0x82, 0x83, 0x50,
+	0x17, 0x2a, 0xfe, 0xdc, 0x9f, 0x44, 0x85, 0xe6, 0xea, 0x36, 0xab, 0x72, 0x50, 0xea, 0xbe, 0x0d,
+	0x31, 0xfc, 0xb0, 0x05, 0xc0, 0x8d, 0xab, 0xdb, 0xb4, 0x20, 0xd2, 0xff, 0x4e, 0xb7, 0x3a, 0x3b,
+	0xe7, 0x83, 0x83, 0x4d, 0x39, 0xe2, 0x9e, 0x45, 0xe3, 0x21, 0x02, 0xd4, 0xb4, 0xdf, 0x02, 0x88,
+	0x2b, 0xed, 0x21, 0x58, 0x41, 0x05, 0x8c, 0xb1, 0xa6, 0x32, 0xe4, 0x6e, 0xa0, 0x89, 0x10, 0x84,
+	0xd7, 0xd8, 0xdf, 0x06, 0x94, 0xab, 0xec, 0x51, 0xa0, 0x1a, 0x03, 0x4c, 0xa1, 0xa9, 0x8e, 0x69,
+	0x38, 0xbc, 0x42, 0xff, 0x4e, 0x6a, 0x9c, 0x33, 0x06, 0x1c, 0x5e, 0xdf, 0x23, 0xa4, 0x11, 0xec,
+	0xfd, 0xee, 0x20, 0xa4, 0x11, 0x1c, 0x23, 0x8d, 0xe0, 0x18, 0x69, 0x04, 0x7b, 0xbf, 0x37, 0x10,
+	0x69, 0x02, 0x46, 0x25, 0x2d, 0x82, 0xc3, 0x5b, 0xcb, 0x77, 0x06, 0x22, 0x2d, 0x8a, 0xc3, 0x1b,
+	0xd3, 0x16, 0x2a, 0x86, 0x38, 0xa2, 0xd7, 0xfc, 0x3e, 0x00, 0x5d, 0x6d, 0x0f, 0xc4, 0x5b, 0x18,
+	0x20, 0x8d, 0x37, 0xb5, 0x41, 0xb7, 0x81, 0x26, 0x25, 0x75, 0x02, 0xeb, 0x0f, 0x00, 0xeb, 0x9a,
+	0x14, 0xe4, 0x6d, 0xa8, 0x60, 0x13, 0x4d, 0x7d, 0x54, 0xdb, 0x0d, 0xd0, 0x17, 0xff, 0x30, 0xf5,
+	0x6e, 0x60, 0x1d, 0x54, 0xdf, 0x0d, 0xd0, 0x54, 0x63, 0xec, 0x11, 0xec, 0xfd, 0xd1, 0x60, 0xec,
+	0x89, 0xef, 0x49, 0x63, 0x8f, 0x60, 0x03, 0x7b, 0x04, 0x7b, 0x7f, 0x3c, 0x20, 0x7b, 0x02, 0x4c,
+	0x67, 0x2f, 0xb2, 0xfd, 0x78, 0x4f, 0xff, 0x93, 0xd4, 0xdb, 0x0f, 0xba, 0xbf, 0xbe, 0xfd, 0xb8,
+	0x22, 0xd0, 0xd2, 0x09, 0x14, 0xc1, 0x9f, 0xa6, 0x4f, 0x27, 0xe6, 0x20, 0x92, 0x4e, 0xa0, 0x27,
+	0xd4, 0xdd, 0x00, 0x7a, 0xe2, 0xcf, 0x52, 0xef, 0x06, 0xa6, 0x3c, 0xf4, 0xdd, 0x00, 0x62, 0x64,
+	0x1b, 0x1d, 0x0a, 0x41, 0x14, 0x31, 0xf2, 0xe7, 0x80, 0xf4, 0x0a, 0x7b, 0xa4, 0x50, 0x80, 0x00,
+	0x5a, 0xb1, 0x19, 0x19, 0x76, 0xcf, 0xa3, 0xa9, 0x08, 0xa2, 0x68, 0xab, 0x7f, 0x01, 0xa0, 0xd7,
+	0xa6, 0x04, 0xe5, 0x63, 0x80, 0x7b, 0xa8, 0x19, 0xff, 0xc4, 0xdd, 0x45, 0x87, 0x43, 0x68, 0x55,
+	0xa2, 0xfc, 0x25, 0x00, 0x2f, 0xd9, 0x03, 0x4b, 0x55, 0x02, 0xb0, 0x93, 0xcd, 0xe8, 0xb8, 0x7b,
+	0x07, 0x3a, 0xa2, 0x54, 0x5f, 0x45, 0xad, 0x7c, 0x17, 0x50, 0x97, 0xd3, 0xd4, 0xe0, 0x50, 0xa7,
+	0x00, 0xac, 0xdb, 0x8c, 0x7d, 0xe0, 0xde, 0x8d, 0xbc, 0x18, 0xae, 0x60, 0xfa, 0xaf, 0x00, 0xfa,
+	0x74, 0x6a, 0x68, 0x8d, 0xeb, 0x23, 0x4d, 0xd3, 0x67, 0x62, 0xff, 0xb2, 0x46, 0x07, 0x9a, 0xe3,
+	0xaf, 0x53, 0xed, 0x5f, 0xd6, 0xf9, 0xa5, 0xe8, 0xa0, 0xfb, 0x37, 0x1c, 0x12, 0xc9, 0xb8, 0xab,
+	0xa0, 0xfc, 0x4d, 0xaa, 0x64, 0x84, 0xc6, 0x2f, 0x61, 0x68, 0x32, 0xca, 0x31, 0x81, 0xd3, 0x55,
+	0x70, 0xfe, 0x36, 0x15, 0xce, 0x19, 0x03, 0x8e, 0x1c, 0x53, 0x48, 0x23, 0x18, 0x60, 0xfe, 0x2e,
+	0x2d, 0x69, 0x04, 0xc7, 0x48, 0x83, 0x21, 0x95, 0x34, 0x81, 0xf2, 0xf7, 0xa9, 0x49, 0x53, 0x61,
+	0x04, 0x69, 0x3a, 0x4e, 0x57, 0xc1, 0xf9, 0x87, 0xd4, 0xa4, 0x45, 0x71, 0xe4, 0x98, 0x68, 0x69,
+	0xbc, 0x8d, 0x02, 0xd0, 0x3f, 0xa6, 0x6a, 0x69, 0xbc, 0xef, 0x4b, 0x24, 0xfa, 0x6d, 0x28, 0x83,
+	0x21, 0x75, 0xac, 0x44, 0x03, 0xd2, 0x3f, 0xa5, 0xa3, 0x8e, 0x79, 0x88, 0x50, 0x17, 0x8e, 0xb9,
+	0x25, 0x84, 0xda, 0xad, 0x7a, 0x7b, 0x03, 0x20, 0x9e, 0xce, 0x95, 0x9c, 0xf2, 0x81, 0xea, 0x50,
+	0x30, 0xca, 0x06, 0x99, 0xc5, 0x31, 0x74, 0x10, 0x2c, 0x40, 0x9e, 0x3e, 0x43, 0x4d, 0x72, 0xd5,
+	0xa1, 0x00, 0xe6, 0x81, 0x5c, 0x7e, 0x19, 0x1a, 0x03, 0x1b, 0xae, 0x95, 0x9f, 0xa5, 0x46, 0x93,
+	0xd5, 0xa1, 0x00, 0xa6, 0x72, 0xb1, 0x1b, 0x5a, 0x71, 0xa5, 0xfb, 0x1c, 0xb5, 0x2a, 0x84, 0x56,
+	0x5c, 0xaa, 0xaa, 0x78, 0x04, 0x7b, 0xcf, 0x53, 0xa3, 0xac, 0x8a, 0x47, 0xb0, 0x8e, 0x47, 0xb0,
+	0xf7, 0x19, 0x6a, 0xe4, 0x6a, 0x78, 0xaa, 0x15, 0x17, 0x89, 0x9f, 0xa5, 0x56, 0xc3, 0x1a, 0x1e,
+	0xc1, 0xee, 0xcb, 0x51, 0x01, 0xac, 0x84, 0xec, 0xfa, 0x1c, 0x35, 0x1b, 0xa9, 0x0e, 0x05, 0x30,
+	0x5b, 0x48, 0xb4, 0x32, 0x1a, 0xe7, 0x98, 0xc2, 0xf0, 0xf3, 0xd4, 0x70, 0xa2, 0x3a, 0x14, 0x80,
+	0x83, 0x50, 0x5e, 0x85, 0x11, 0x80, 0xb6, 0xfa, 0x65, 0x6a, 0x96, 0x09, 0x23, 0x00, 0x75, 0xa4,
+	0xa3, 0x12, 0xec, 0xfd, 0x0a, 0xb5, 0xca, 0xeb, 0xa8, 0xec, 0x00, 0x41, 0x43, 0x25, 0xd8, 0xfb,
+	0x55, 0x6a, 0x58, 0x8c, 0xa0, 0xaa, 0xd1, 0x72, 0x4d, 0xf2, 0x02, 0xb5, 0x73, 0xc2, 0x68, 0xb9,
+	0xa8, 0x90, 0xcc, 0x81, 0xa2, 0xf8, 0x02, 0xb5, 0x1a, 0x95, 0xcc, 0x81, 0x24, 0x08, 0x23, 0x00,
+	0x3d, 0xf0, 0x45, 0x6a, 0x34, 0x16, 0x46, 0x00, 0x1d, 0x7d, 0x15, 0x15, 0xc1, 0x46, 0x69, 0xe7,
+	0x5f, 0xca, 0xa5, 0x7f, 0x8c, 0x5b, 0x1d, 0x0a, 0x20, 0x54, 0xd9, 0xc2, 0x6f, 0x45, 0x87, 0x54,
+	0x08, 0xd1, 0x55, 0xbe, 0x9c, 0x1b, 0xe8, 0x15, 0x9b, 0xea, 0x50, 0x30, 0x29, 0x81, 0x44, 0x17,
+	0x59, 0x47, 0x30, 0xa8, 0x35, 0xec, 0xaf, 0xe4, 0x06, 0x78, 0xbf, 0xa6, 0x3a, 0x14, 0x4c, 0x30,
+	0x97, 0x4a, 0x93, 0x5e, 0x41, 0xae, 0xd8, 0xb8, 0x4a, 0x87, 0xfe, 0x6a, 0x2e, 0xcd, 0xb3, 0xe8,
+	0xea, 0x50, 0x50, 0xe4, 0xdb, 0x5d, 0x76, 0xe3, 0x73, 0xe8, 0x88, 0x0e, 0x20, 0x48, 0xfb, 0x5a,
+	0x2e, 0xe5, 0x9b, 0x35, 0xd5, 0xa1, 0xe0, 0x90, 0x0a, 0x23, 0x08, 0xfb, 0x31, 0x5e, 0x39, 0x80,
+	0xa9, 0xaf, 0xe7, 0xac, 0x5f, 0x13, 0xbc, 0x89, 0xce, 0x16, 0x4c, 0x29, 0xbe, 0x64, 0x6e, 0xc0,
+	0x1e, 0x9d, 0xf7, 0xbe, 0x21, 0x36, 0xe9, 0x98, 0xb2, 0x49, 0xe7, 0xa3, 0x76, 0xbe, 0xf7, 0x4d,
+	0x93, 0x9d, 0x1f, 0xb5, 0x5b, 0xf0, 0xbe, 0x65, 0xb2, 0x5b, 0x70, 0x4f, 0xa1, 0xc3, 0x3c, 0x83,
+	0xf4, 0x07, 0x5a, 0xf7, 0xe6, 0xe5, 0x0b, 0x3d, 0x55, 0x27, 0x80, 0x6f, 0x50, 0x7f, 0x9e, 0x75,
+	0x95, 0xa0, 0x3d, 0xfa, 0x30, 0xeb, 0x7d, 0x79, 0xf5, 0xed, 0x9e, 0xaa, 0xc3, 0xb9, 0x8c, 0x3c,
+	0xcb, 0xba, 0x1a, 0x4d, 0x45, 0xa7, 0xf3, 0x4a, 0x7a, 0x5f, 0x5e, 0x79, 0xd5, 0xa7, 0xea, 0x04,
+	0x87, 0xf5, 0xe9, 0xbc, 0xb2, 0x5e, 0x15, 0x9f, 0xcf, 0x6b, 0xec, 0xfd, 0x79, 0xf9, 0xde, 0x4f,
+	0x7c, 0xfa, 0x19, 0xf1, 0x18, 0xcc, 0xb4, 0x7a, 0x82, 0xbd, 0x07, 0xf2, 0xd1, 0x97, 0x80, 0x8c,
+	0x11, 0x10, 0x9c, 0x14, 0x01, 0xc1, 0xde, 0x83, 0x79, 0xe5, 0x8d, 0x20, 0x73, 0x04, 0x04, 0x27,
+	0x45, 0x40, 0xb0, 0xf7, 0x50, 0x5e, 0xbe, 0x1e, 0x64, 0x8e, 0x80, 0x3d, 0xfa, 0x9a, 0x8e, 0x4e,
+	0x17, 0x55, 0xfa, 0xe1, 0xbc, 0xfa, 0xae, 0x50, 0xd5, 0x09, 0x8e, 0xe8, 0x1e, 0x44, 0x7d, 0xbf,
+	0x0e, 0x79, 0xb1, 0x08, 0x84, 0x8f, 0x47, 0xf2, 0xda, 0x8b, 0x43, 0x55, 0x27, 0x98, 0x8a, 0x44,
+	0x21, 0x6a, 0xff, 0xd5, 0x71, 0x2a, 0xa1, 0x0b, 0xbc, 0x3f, 0xaf, 0xbd, 0x45, 0x14, 0xe7, 0x11,
+	0xfa, 0x42, 0x52, 0x20, 0x04, 0x7b, 0x1f, 0xc8, 0xab, 0xaf, 0x14, 0x25, 0x04, 0x42, 0x70, 0x72,
+	0x20, 0x04, 0x7b, 0x8f, 0xe6, 0xb5, 0xf7, 0x8b, 0x92, 0x02, 0x21, 0xd8, 0xbd, 0x3e, 0xfe, 0x85,
+	0xf0, 0xc6, 0xf2, 0x58, 0xde, 0xf0, 0xb2, 0x51, 0xfc, 0x9b, 0xe1, 0x0d, 0xe7, 0x06, 0xc3, 0xc6,
+	0x80, 0xd6, 0xf3, 0x78, 0xde, 0xfc, 0xe6, 0x91, 0x61, 0x8f, 0x40, 0x57, 0xba, 0x29, 0xce, 0x2d,
+	0xf4, 0xa7, 0x27, 0xf2, 0xfd, 0x5f, 0x43, 0x8a, 0x93, 0x0d, 0x2d, 0xec, 0xb5, 0x68, 0x26, 0xea,
+	0x50, 0x69, 0x66, 0x4f, 0xe6, 0x07, 0x7e, 0x27, 0xa9, 0xea, 0x04, 0xd3, 0x3a, 0xb0, 0xfa, 0xf7,
+	0xe9, 0xc5, 0xf1, 0x8c, 0x51, 0x9a, 0xc2, 0x53, 0xf9, 0x01, 0x5e, 0x50, 0xaa, 0x3a, 0xc1, 0xd1,
+	0x68, 0x9e, 0x85, 0x36, 0x33, 0x3f, 0x85, 0xc6, 0xb4, 0xde, 0xf7, 0x22, 0xbe, 0x69, 0x3e, 0x73,
+	0x17, 0x42, 0x4a, 0x3f, 0x7c, 0x31, 0x91, 0xaf, 0x41, 0x05, 0xed, 0x4d, 0x4e, 0x5b, 0x70, 0xea,
+	0x40, 0x7b, 0x27, 0x22, 0x9d, 0x03, 0xe5, 0xf0, 0xdc, 0xda, 0xc1, 0xd5, 0xa8, 0x18, 0x3d, 0x1c,
+	0x77, 0x8b, 0x28, 0x7b, 0x5b, 0xfd, 0x3c, 0x73, 0x72, 0x20, 0xa0, 0xff, 0xeb, 0x1e, 0x46, 0xb9,
+	0x3b, 0x56, 0x1b, 0xdd, 0xba, 0x97, 0x61, 0x63, 0xf0, 0x8f, 0x4a, 0xe6, 0x0a, 0x67, 0xe6, 0x1a,
+	0x34, 0x19, 0x3b, 0xf9, 0xde, 0xcb, 0x41, 0x4e, 0x75, 0xf0, 0x0a, 0xe4, 0xc6, 0x0f, 0xb5, 0xf7,
+	0xf2, 0x30, 0x69, 0xf6, 0x70, 0x66, 0xff, 0x1e, 0x0a, 0x89, 0x41, 0xf0, 0x53, 0xba, 0xbd, 0x1c,
+	0x64, 0x93, 0x83, 0xd8, 0xa7, 0x07, 0x37, 0x39, 0x88, 0x7d, 0x7a, 0x18, 0x56, 0x3d, 0x2c, 0xa1,
+	0x43, 0x86, 0x73, 0xe1, 0xbd, 0x5c, 0x8c, 0xa8, 0x2e, 0x96, 0xd1, 0x61, 0xd3, 0x71, 0xef, 0x5e,
+	0x3e, 0x26, 0xcc, 0x5c, 0xca, 0x73, 0xdc, 0xbd, 0x1c, 0x64, 0xfa, 0xc4, 0xb1, 0x4f, 0x2a, 0xf2,
+	0xfd, 0xe2, 0xd8, 0xa7, 0x8f, 0xa2, 0xf9, 0x0b, 0x51, 0x0e, 0x54, 0xf7, 0xf2, 0xe0, 0x24, 0x6c,
+	0x0a, 0x79, 0x54, 0xba, 0x97, 0x87, 0x51, 0x33, 0x97, 0xf2, 0x14, 0x74, 0x2f, 0x07, 0x63, 0xaa,
+	0x83, 0xf3, 0xe8, 0x88, 0xf1, 0x70, 0xd3, 0xe0, 0xe4, 0x55, 0xaa, 0x93, 0xb4, 0x0f, 0x73, 0x15,
+	0xe8, 0xbb, 0x91, 0x97, 0x74, 0xc4, 0x69, 0x40, 0xbf, 0x51, 0x45, 0x1f, 0xe0, 0x01, 0xaf, 0xb2,
+	0x80, 0xd7, 0xa2, 0x29, 0xf3, 0x51, 0xa7, 0x01, 0xfe, 0x47, 0x74, 0xf8, 0x94, 0x4f, 0x7c, 0x15,
+	0xf0, 0x2e, 0x9a, 0x4e, 0x38, 0xf1, 0x34, 0xa0, 0x5f, 0xa7, 0x53, 0x6f, 0xfb, 0x10, 0x58, 0x8b,
+	0x79, 0x26, 0xf9, 0xb4, 0xd3, 0x80, 0xfc, 0x4a, 0x3d, 0xee, 0x14, 0x8f, 0x85, 0x63, 0xbb, 0x55,
+	0x3f, 0xf3, 0x54, 0x31, 0x73, 0x7b, 0xf5, 0x12, 0x48, 0x98, 0xc8, 0x71, 0xa6, 0xea, 0x61, 0x72,
+	0x7f, 0x1e, 0xce, 0x24, 0x7b, 0x28, 0xec, 0xaf, 0x9f, 0xe9, 0x67, 0x90, 0xaa, 0x83, 0xec, 0xfe,
+	0x83, 0x48, 0xf0, 0xe0, 0xee, 0x3f, 0x88, 0x04, 0x0f, 0xc3, 0x7b, 0x79, 0x80, 0x12, 0x1a, 0x3d,
+	0x11, 0x54, 0x5d, 0x8c, 0xec, 0x33, 0x0c, 0xfd, 0xa8, 0x4f, 0xf5, 0x30, 0xba, 0x97, 0x87, 0x2b,
+	0x11, 0x92, 0x7f, 0x8f, 0x5b, 0xeb, 0x92, 0x2a, 0x9a, 0x3a, 0x7d, 0x57, 0xa7, 0xde, 0xda, 0xdd,
+	0x6a, 0xb7, 0x06, 0xd3, 0x58, 0xaa, 0xa7, 0x81, 0xb4, 0xd2, 0xb1, 0x59, 0x34, 0x2a, 0xc5, 0xf6,
+	0x28, 0x02, 0x5d, 0x5c, 0x1c, 0xa2, 0xff, 0xbb, 0x1c, 0x2c, 0xfd, 0xe8, 0x4d, 0x45, 0xc7, 0x3d,
+	0x88, 0x46, 0xae, 0xad, 0x2e, 0x05, 0xaf, 0xbe, 0xe1, 0x74, 0x31, 0x73, 0xd9, 0xe8, 0x81, 0x7b,
+	0x6a, 0xc5, 0x0b, 0x17, 0x2e, 0x5c, 0xc8, 0xf8, 0x67, 0xd1, 0x74, 0x5d, 0x2c, 0x62, 0x45, 0xbb,
+	0xb3, 0xe8, 0x5a, 0x88, 0x4e, 0xef, 0x9e, 0x1a, 0x63, 0xf9, 0x48, 0x3d, 0x4a, 0x0d, 0xfd, 0x8a,
+	0xfc, 0x3a, 0xf2, 0x0c, 0x20, 0xf0, 0x07, 0xb9, 0x0d, 0xca, 0x1b, 0x6a, 0x2c, 0x5b, 0xa7, 0x62,
+	0x28, 0x2c, 0xb7, 0xfd, 0x4d, 0x74, 0xd4, 0x00, 0xb3, 0x6b, 0x8f, 0xf3, 0xc6, 0x1a, 0xcb, 0xe9,
+	0xe9, 0x18, 0x0e, 0x94, 0x80, 0x04, 0xa0, 0xae, 0x3d, 0xd0, 0x9b, 0x6a, 0x2c, 0xf5, 0xe3, 0x40,
+	0x50, 0x29, 0x92, 0x89, 0x23, 0xd8, 0x0a, 0xe7, 0xcd, 0x35, 0x56, 0x21, 0x8c, 0xc4, 0x11, 0xdc,
+	0x87, 0x38, 0x4b, 0x9c, 0xb7, 0xd4, 0x58, 0x1d, 0x31, 0x13, 0x97, 0x08, 0xd4, 0xb5, 0x07, 0x7a,
+	0x6b, 0x8d, 0x95, 0x1b, 0x33, 0x71, 0x04, 0xfb, 0x5b, 0x68, 0xc6, 0x00, 0x24, 0x4e, 0x2e, 0x6c,
+	0x90, 0xde, 0x56, 0x63, 0x55, 0xc9, 0x8b, 0x21, 0xf1, 0x2a, 0xe6, 0xdf, 0x86, 0x2e, 0x32, 0x91,
+	0x97, 0x06, 0xeb, 0xed, 0x35, 0x26, 0x5a, 0x8f, 0xc6, 0xe9, 0xe3, 0xde, 0x12, 0x36, 0xc4, 0x06,
+	0xbc, 0xda, 0x67, 0x81, 0xf4, 0x8e, 0x1a, 0x53, 0xb7, 0xf1, 0x0d, 0xc1, 0xb4, 0x71, 0x3f, 0xfa,
+	0x2c, 0xbf, 0xa8, 0x77, 0xd6, 0x98, 0x06, 0x4e, 0xa0, 0x8f, 0xe0, 0xbe, 0xf4, 0x59, 0x62, 0xbd,
+	0xab, 0xc6, 0xb4, 0x72, 0x12, 0x7d, 0x89, 0xfb, 0x0f, 0x0e, 0x7b, 0xac, 0xa0, 0x7a, 0x35, 0x26,
+	0xaa, 0xe3, 0xfb, 0x0f, 0x34, 0x79, 0x52, 0x46, 0xc1, 0xe1, 0x8e, 0x0d, 0xd0, 0xbb, 0x6b, 0xac,
+	0x0b, 0x18, 0x32, 0x0a, 0x4e, 0x7c, 0xcd, 0x1b, 0x82, 0x9d, 0x15, 0x59, 0xe1, 0xbc, 0xa7, 0xc6,
+	0x24, 0x7a, 0x7c, 0x43, 0x30, 0x81, 0xef, 0x3f, 0xe0, 0xa0, 0x4b, 0x0c, 0x38, 0xf2, 0x08, 0xc9,
+	0x0a, 0xec, 0xbd, 0xb5, 0x01, 0xa4, 0xfc, 0x4c, 0x6c, 0x89, 0xe1, 0x67, 0xfe, 0xe3, 0x0e, 0x2a,
+	0x25, 0x2e, 0x93, 0x3f, 0x1e, 0xb0, 0x5a, 0xe9, 0xbd, 0xb5, 0xc1, 0x64, 0xff, 0x25, 0xe6, 0xc5,
+	0xf2, 0x8f, 0xfd, 0x87, 0x1d, 0xf4, 0x7d, 0x86, 0xf5, 0x2a, 0xcf, 0x65, 0xac, 0x56, 0xfb, 0xbe,
+	0xda, 0x20, 0x7f, 0x25, 0x5c, 0x14, 0x5b, 0xab, 0xfc, 0xd0, 0xbf, 0xcf, 0x41, 0x97, 0x1a, 0x7b,
+	0x84, 0x3c, 0xc6, 0xb3, 0x5a, 0xea, 0x7d, 0xb5, 0x54, 0x7f, 0x52, 0x5c, 0x6c, 0xe8, 0x2c, 0xe1,
+	0xa7, 0xfe, 0xa3, 0x0e, 0x3a, 0xd6, 0x67, 0x91, 0x69, 0x36, 0xc0, 0xfd, 0xb5, 0xb4, 0x7f, 0x80,
+	0x5c, 0x9a, 0xb4, 0x54, 0xf1, 0xe5, 0x3f, 0xe4, 0x20, 0x99, 0x6e, 0xfa, 0x4d, 0x6b, 0x9b, 0x15,
+	0x3e, 0x50, 0x63, 0x8f, 0xa3, 0x6c, 0xde, 0xb4, 0x31, 0x0b, 0xd8, 0x20, 0x61, 0x35, 0x7e, 0x43,
+	0xad, 0x31, 0xfa, 0x03, 0x23, 0xbb, 0x64, 0xea, 0xa9, 0xd7, 0xc5, 0x25, 0x9a, 0xf6, 0x7c, 0xc9,
+	0xdf, 0x56, 0x4b, 0x67, 0xe4, 0x19, 0x93, 0x5d, 0x36, 0xf4, 0xf4, 0xeb, 0xe6, 0xd3, 0x71, 0x40,
+	0xd0, 0x8d, 0xb7, 0xab, 0xdd, 0x2e, 0xfa, 0x58, 0xca, 0x6e, 0x57, 0xf7, 0xb4, 0xeb, 0xea, 0x5e,
+	0x1c, 0x91, 0x2b, 0xc8, 0x6d, 0x33, 0x64, 0x0a, 0x09, 0x79, 0x7f, 0x4f, 0xbd, 0xee, 0x6e, 0x40,
+	0xe4, 0x52, 0xb2, 0x93, 0x48, 0xab, 0x65, 0x97, 0x7d, 0xa0, 0x17, 0xbf, 0x2e, 0x6f, 0xa6, 0x96,
+	0xe0, 0x7e, 0xd4, 0x5a, 0xc2, 0x3e, 0xd8, 0xd3, 0xae, 0xdb, 0x27, 0x50, 0x4b, 0x70, 0x3f, 0x6a,
+	0x2d, 0x21, 0x1f, 0xea, 0xa9, 0xd7, 0xf5, 0x13, 0xa8, 0x25, 0xd8, 0xef, 0xa8, 0x12, 0x26, 0xf6,
+	0x54, 0xce, 0x0a, 0xf2, 0xe1, 0x9e, 0x7e, 0xdd, 0xff, 0x68, 0x1c, 0x54, 0xe8, 0xce, 0x3b, 0xd1,
+	0xc5, 0x46, 0x6a, 0xd3, 0xc0, 0x3e, 0xd2, 0x8b, 0xfc, 0x5c, 0xc0, 0x8c, 0x81, 0x5e, 0xa1, 0x41,
+	0x6f, 0x37, 0xef, 0x24, 0x7b, 0x11, 0xfa, 0xfe, 0x5e, 0xe4, 0xe7, 0x06, 0x0c, 0xdb, 0x08, 0xf4,
+	0x68, 0x3f, 0x86, 0x2d, 0xbf, 0xd4, 0x0f, 0xf4, 0xf4, 0x9f, 0x2b, 0x48, 0x62, 0x98, 0xe0, 0xfe,
+	0x0c, 0x5b, 0xc2, 0x3e, 0xda, 0x8b, 0xfc, 0xdc, 0x41, 0x22, 0xc3, 0x04, 0xfb, 0xe7, 0xcd, 0x5b,
+	0x38, 0x85, 0x4e, 0x7d, 0xac, 0x67, 0xfc, 0xb9, 0x04, 0xc3, 0x5e, 0xe6, 0xc2, 0xf5, 0x75, 0x09,
+	0x09, 0x6b, 0xaf, 0x5c, 0x1f, 0xef, 0x25, 0xfd, 0xdc, 0x82, 0x29, 0x77, 0x41, 0xcd, 0xbe, 0xde,
+	0x31, 0xef, 0x2d, 0x7b, 0x3d, 0xfb, 0x44, 0x6f, 0xaf, 0xdf, 0x6b, 0x30, 0x6c, 0x36, 0xd0, 0xba,
+	0x4f, 0x68, 0xa2, 0xcc, 0xf4, 0xbc, 0xd4, 0x6a, 0x25, 0x4f, 0xf6, 0xbe, 0x07, 0x3f, 0xf8, 0x70,
+	0x51, 0x7c, 0xb1, 0x52, 0xf5, 0x3e, 0xa6, 0xa9, 0x5e, 0xf3, 0x33, 0x56, 0xab, 0x25, 0x3f, 0xd5,
+	0x1b, 0xe8, 0x17, 0x23, 0x2e, 0x31, 0xd5, 0x66, 0xa9, 0xd2, 0xd6, 0xd5, 0x23, 0x27, 0xed, 0xb2,
+	0xa0, 0xdd, 0x22, 0xbf, 0xeb, 0xb0, 0x9b, 0x85, 0xf2, 0xcc, 0x29, 0x50, 0xae, 0x18, 0xfa, 0x1b,
+	0xaa, 0x68, 0xd1, 0x2f, 0x1b, 0x5a, 0xc1, 0x7c, 0x90, 0xc1, 0xa8, 0x87, 0x4e, 0x81, 0x7a, 0x45,
+	0xd1, 0x3f, 0xa7, 0xee, 0xd8, 0xc8, 0x65, 0x45, 0x2b, 0xa0, 0x0f, 0x31, 0x20, 0xf5, 0xd4, 0x29,
+	0xd0, 0xae, 0x38, 0x26, 0x20, 0xa5, 0x90, 0x0c, 0x1f, 0x66, 0x48, 0x05, 0x03, 0x12, 0xd7, 0x0a,
+	0x89, 0xdc, 0x59, 0x16, 0xbd, 0x8f, 0x30, 0xa0, 0xac, 0x99, 0x3b, 0x82, 0xfb, 0x70, 0x67, 0x09,
+	0xf4, 0x51, 0x06, 0xe4, 0x26, 0x70, 0x97, 0x88, 0x94, 0x42, 0x13, 0x7c, 0x8c, 0x21, 0x0d, 0x27,
+	0x70, 0x47, 0xb0, 0x7f, 0xab, 0x5a, 0x40, 0xa3, 0x97, 0x3d, 0xad, 0xa0, 0x3e, 0xce, 0xa0, 0xd4,
+	0xa3, 0xa7, 0x40, 0xbf, 0x22, 0xea, 0x37, 0xd4, 0xb6, 0x18, 0xbb, 0x2c, 0x6a, 0x05, 0xf6, 0x09,
+	0x06, 0xa6, 0x9e, 0x3d, 0x05, 0x91, 0x2b, 0xa6, 0x09, 0xbb, 0xc2, 0xbe, 0xed, 0x7f, 0x92, 0x41,
+	0x65, 0x0c, 0xbb, 0x02, 0x9a, 0x7d, 0x1f, 0x06, 0x2d, 0xbf, 0xac, 0x4f, 0x31, 0xa4, 0x7c, 0x12,
+	0x83, 0x04, 0xf7, 0x65, 0xd0, 0x12, 0xec, 0xd3, 0x0c, 0xac, 0x98, 0xc8, 0x60, 0xe2, 0x2e, 0x4c,
+	0xd1, 0xd6, 0x9f, 0x66, 0x58, 0x8e, 0x61, 0x17, 0xf2, 0x36, 0x9e, 0x90, 0x59, 0xf6, 0x5d, 0xfc,
+	0x19, 0x86, 0x34, 0x6a, 0xca, 0x2c, 0x68, 0xd9, 0xe6, 0x5d, 0x61, 0xdf, 0xb0, 0x9f, 0x65, 0x40,
+	0x63, 0x86, 0x5d, 0x01, 0x5d, 0xf9, 0x41, 0xed, 0x04, 0xca, 0x70, 0xdb, 0xd7, 0x0a, 0xed, 0x39,
+	0x86, 0x36, 0xf8, 0x11, 0x54, 0x10, 0xbd, 0x23, 0x4c, 0xd5, 0x43, 0x29, 0x71, 0x9d, 0x69, 0x4e,
+	0x20, 0x9e, 0x67, 0x4b, 0xfd, 0x9e, 0x9c, 0x41, 0x05, 0x86, 0x4b, 0xc6, 0xfe, 0x23, 0x9a, 0xdc,
+	0x31, 0xdd, 0x37, 0xb6, 0x5a, 0xee, 0x67, 0xf8, 0x72, 0x07, 0x3e, 0x84, 0x0a, 0x62, 0xb7, 0x94,
+	0xfd, 0xfb, 0xb5, 0x43, 0x28, 0xe3, 0x85, 0x65, 0xab, 0xb5, 0x7e, 0x96, 0xef, 0x82, 0xf4, 0xa7,
+	0x50, 0x41, 0xfc, 0x9a, 0x33, 0x95, 0x63, 0xc7, 0xfa, 0xac, 0x32, 0xcd, 0x1e, 0xf8, 0x1c, 0x27,
+	0x75, 0xa0, 0x63, 0xa8, 0xc0, 0x78, 0x4f, 0xda, 0x7f, 0x58, 0x3d, 0x86, 0xd2, 0x6f, 0x38, 0xdb,
+	0x2c, 0xf1, 0xf3, 0x6c, 0x89, 0x29, 0xcf, 0xa1, 0xf4, 0x7b, 0xd6, 0x09, 0xcb, 0x59, 0x2e, 0x88,
+	0x57, 0xf5, 0xbb, 0xad, 0xad, 0x76, 0x6b, 0x79, 0x3a, 0xfe, 0x8e, 0x24, 0xfb, 0xe0, 0xb2, 0x79,
+	0x74, 0x50, 0x7d, 0x4f, 0xdc, 0xf4, 0x40, 0x14, 0xb9, 0x63, 0xf2, 0x81, 0xe8, 0x0b, 0xce, 0xf2,
+	0x6b, 0x7e, 0xbc, 0x16, 0x5b, 0xf6, 0x09, 0xb6, 0xec, 0xb5, 0xee, 0xc6, 0x89, 0xad, 0x56, 0xa7,
+	0xbe, 0xd3, 0x5a, 0x6d, 0xb0, 0xdf, 0xb9, 0x65, 0xa3, 0xbb, 0x27, 0x1a, 0xf5, 0xcd, 0xd5, 0xb3,
+	0xe7, 0x4f, 0x24, 0xfd, 0x24, 0xee, 0xff, 0x07, 0x00, 0x00, 0xff, 0xff, 0x9d, 0x50, 0x42, 0x96,
+	0x2d, 0x57, 0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20180430_b4deda09/test.proto b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20180430_b4deda09/test.proto
new file mode 100644
index 000000000..d3850eb4d
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20180430_b4deda09/test.proto
@@ -0,0 +1,333 @@
+// 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.
+
+syntax = "proto2";
+
+package google.golang.org.proto2_20180430;
+option go_package = "google.golang.org/protobuf/internal/testprotos/legacy/proto2_20180430_b4deda09";
+
+enum SiblingEnum {
+	ALPHA   = 0;
+	BRAVO   = 10;
+	CHARLIE = 200;
+}
+
+message SiblingMessage {
+	optional string  f1 = 1;
+	required string  f2 = 2;
+	repeated string  f3 = 3;
+	optional Message f4 = 4;
+}
+
+message Message {
+	enum ChildEnum {
+		ALPHA   = 0;
+		BRAVO   = 1;
+		CHARLIE = 2;
+	}
+	message ChildMessage {
+		optional string  f1 = 1;
+		required string  f2 = 2;
+		repeated string  f3 = 3;
+	    optional Message f4 = 4;
+	}
+	optional group NamedGroup = 1 {
+		optional string  f1 = 1;
+		required string  f2 = 2;
+		repeated string  f3 = 3;
+	    optional Message f4 = 4;
+	}
+
+	// Optional fields.
+	optional bool     optional_bool     = 100;
+	optional int32    optional_int32    = 101;
+	optional sint32   optional_sint32   = 102;
+	optional uint32   optional_uint32   = 103;
+	optional int64    optional_int64    = 104;
+	optional sint64   optional_sint64   = 105;
+	optional uint64   optional_uint64   = 106;
+	optional fixed32  optional_fixed32  = 107;
+	optional sfixed32 optional_sfixed32 = 108;
+	optional float    optional_float    = 109;
+	optional fixed64  optional_fixed64  = 110;
+	optional sfixed64 optional_sfixed64 = 111;
+	optional double   optional_double   = 112;
+	optional string   optional_string   = 113;
+	optional bytes    optional_bytes    = 114;
+
+	optional ChildEnum      optional_child_enum      = 115;
+	optional ChildMessage   optional_child_message   = 116;
+	optional NamedGroup     optional_named_group     = 117;
+	optional SiblingEnum    optional_sibling_enum    = 118;
+	optional SiblingMessage optional_sibling_message = 119;
+	optional group OptionalGroup = 120 {
+		optional string f1 = 1;
+		required string f2 = 2;
+		repeated string f3 = 3;
+	}
+
+	// Optional default fields.
+	optional bool      defaulted_bool     = 200 [default = true];
+	optional int32     defaulted_int32    = 201 [default = -12345];
+	optional sint32    defaulted_sint32   = 202 [default = -3200];
+	optional uint32    defaulted_uint32   = 203 [default = 3200];
+	optional int64     defaulted_int64    = 204 [default = -123456789];
+	optional sint64    defaulted_sint64   = 205 [default = -6400];
+	optional uint64    defaulted_uint64   = 206 [default = 6400];
+	optional fixed32   defaulted_fixed32  = 207 [default = 320000];
+	optional sfixed32  defaulted_sfixed32 = 208 [default = -320000];
+	optional float     defaulted_float    = 209 [default = 3.14159];
+	optional fixed64   defaulted_fixed64  = 210 [default = 640000];
+	optional sfixed64  defaulted_sfixed64 = 211 [default = -640000];
+	optional double    defaulted_double   = 212 [default = 3.14159265359];
+	optional string    defaulted_string   = 213 [default = "hello, \"world!\"\n"];
+	optional bytes     defaulted_bytes    = 214 [default = "dead\xde\xad\xbe\xefbeef"];
+
+	optional ChildEnum   defaulted_child_enum   = 215 [default = ALPHA];
+	optional SiblingEnum defaulted_sibling_enum = 216 [default = ALPHA];
+
+	// Required fields.
+	required bool     required_bool     = 300;
+	required int32    required_int32    = 301;
+	required sint32   required_sint32   = 302;
+	required uint32   required_uint32   = 303;
+	required int64    required_int64    = 304;
+	required sint64   required_sint64   = 305;
+	required uint64   required_uint64   = 306;
+	required fixed32  required_fixed32  = 307;
+	required sfixed32 required_sfixed32 = 308;
+	required float    required_float    = 309;
+	required fixed64  required_fixed64  = 310;
+	required sfixed64 required_sfixed64 = 311;
+	required double   required_double   = 312;
+	required string   required_string   = 313;
+	required bytes    required_bytes    = 314;
+
+	required ChildEnum      required_child_enum      = 315;
+	required ChildMessage   required_child_message   = 316;
+	required NamedGroup     required_named_group     = 317;
+	required SiblingEnum    required_sibling_enum    = 318;
+	required SiblingMessage required_sibling_message = 319;
+	required group RequiredGroup = 320 {
+		optional string f1 = 1;
+		required string f2 = 2;
+		repeated string f3 = 3;
+	}
+	// Required default fields.
+	required bool      required_defaulted_bool     = 400 [default = true];
+	required int32     required_defaulted_int32    = 401 [default = -12345];
+	required sint32    required_defaulted_sint32   = 402 [default = -3200];
+	required uint32    required_defaulted_uint32   = 403 [default = 3200];
+	required int64     required_defaulted_int64    = 404 [default = -123456789];
+	required sint64    required_defaulted_sint64   = 405 [default = -6400];
+	required uint64    required_defaulted_uint64   = 406 [default = 6400];
+	required fixed32   required_defaulted_fixed32  = 407 [default = 320000];
+	required sfixed32  required_defaulted_sfixed32 = 408 [default = -320000];
+	required float     required_defaulted_float    = 409 [default = 3.14159];
+	required fixed64   required_defaulted_fixed64  = 410 [default = 640000];
+	required sfixed64  required_defaulted_sfixed64 = 411 [default = -640000];
+	required double    required_defaulted_double   = 412 [default = 3.14159265359];
+	required string    required_defaulted_string   = 413 [default = "hello, \"world!\"\n"];
+	required bytes     required_defaulted_bytes    = 414 [default = "dead\xde\xad\xbe\xefbeef"];
+
+	required ChildEnum   required_defaulted_child_enum   = 415 [default = ALPHA];
+	required SiblingEnum required_defaulted_sibling_enum = 416 [default = ALPHA];
+
+	// Repeated fields.
+	repeated bool     repeated_bool     = 500;
+	repeated int32    repeated_int32    = 501;
+	repeated sint32   repeated_sint32   = 502;
+	repeated uint32   repeated_uint32   = 503;
+	repeated int64    repeated_int64    = 504;
+	repeated sint64   repeated_sint64   = 505;
+	repeated uint64   repeated_uint64   = 506;
+	repeated fixed32  repeated_fixed32  = 507;
+	repeated sfixed32 repeated_sfixed32 = 508;
+	repeated float    repeated_float    = 509;
+	repeated fixed64  repeated_fixed64  = 510;
+	repeated sfixed64 repeated_sfixed64 = 511;
+	repeated double   repeated_double   = 512;
+	repeated string   repeated_string   = 513;
+	repeated bytes    repeated_bytes    = 514;
+
+	repeated ChildEnum      repeated_child_enum      = 515;
+	repeated ChildMessage   repeated_child_message   = 516;
+	repeated NamedGroup     repeated_named_group     = 517;
+	repeated SiblingEnum    repeated_sibling_enum    = 518;
+	repeated SiblingMessage repeated_sibling_message = 519;
+	repeated group RepeatedGroup = 520 {
+		optional string f1 = 1;
+		required string f2 = 2;
+		repeated string f3 = 3;
+	}
+
+	// Map fields.
+	map<bool, bool>     map_bool_bool     = 600;
+	map<bool, int32>    map_bool_int32    = 601;
+	map<bool, sint32>   map_bool_sint32   = 602;
+	map<bool, uint32>   map_bool_uint32   = 603;
+	map<bool, int64>    map_bool_int64    = 604;
+	map<bool, sint64>   map_bool_sint64   = 605;
+	map<bool, uint64>   map_bool_uint64   = 606;
+	map<bool, fixed32>  map_bool_fixed32  = 607;
+	map<bool, sfixed32> map_bool_sfixed32 = 608;
+	map<bool, float>    map_bool_float    = 609;
+	map<bool, fixed64>  map_bool_fixed64  = 610;
+	map<bool, sfixed64> map_bool_sfixed64 = 611;
+	map<bool, double>   map_bool_double   = 612;
+	map<bool, string>   map_bool_string   = 613;
+	map<bool, bytes>    map_bool_bytes    = 614;
+
+	map<bool, ChildEnum>      map_bool_child_enum      = 615;
+	map<bool, ChildMessage>   map_bool_child_message   = 616;
+	map<bool, NamedGroup>     map_bool_named_group     = 617;
+	map<bool, SiblingEnum>    map_bool_sibling_enum    = 618;
+	map<bool, SiblingMessage> map_bool_sibling_message = 619;
+
+	map<int32, bool>   map_int32_bool   = 620;
+	map<sint32, bool>  map_sint32_bool  = 621;
+	map<uint32, bool>  map_uint32_bool  = 622;
+	map<int64, bool>   map_int64_bool   = 623;
+	map<sint64, bool>  map_sint64_bool  = 624;
+	map<uint64, bool>  map_uint64_bool  = 625;
+	map<fixed32, bool> map_fixed32_bool = 626;
+	map<string, bool>  map_string_bool  = 627;
+
+	// Oneof fields.
+	oneof oneof_union {
+		bool     oneof_bool     = 700;
+		int32    oneof_int32    = 701;
+		sint32   oneof_sint32   = 702;
+		uint32   oneof_uint32   = 703;
+		int64    oneof_int64    = 704;
+		sint64   oneof_sint64   = 705;
+		uint64   oneof_uint64   = 706;
+		fixed32  oneof_fixed32  = 707;
+		sfixed32 oneof_sfixed32 = 708;
+		float    oneof_float    = 709;
+		fixed64  oneof_fixed64  = 710;
+		sfixed64 oneof_sfixed64 = 711;
+		double   oneof_double   = 712;
+		string   oneof_string   = 713;
+		bytes    oneof_bytes    = 714;
+
+		ChildEnum      oneof_child_enum      = 715;
+		ChildMessage   oneof_child_message   = 716;
+		NamedGroup     oneof_named_group     = 717;
+		SiblingEnum    oneof_sibling_enum    = 718;
+		SiblingMessage oneof_sibling_message = 719;
+		group OneofGroup = 720 {
+			optional string f1 = 1;
+			required string f2 = 2;
+			repeated string f3 = 3;
+		}
+
+		string oneof_string1 = 721;
+		string oneof_string2 = 722;
+		string oneof_string3 = 723;
+	}
+
+	// Oneof default fields.
+	oneof oneof_defaulted_union {
+		bool      oneof_defaulted_bool     = 800 [default = true];
+		int32     oneof_defaulted_int32    = 801 [default = -12345];
+		sint32    oneof_defaulted_sint32   = 802 [default = -3200];
+		uint32    oneof_defaulted_uint32   = 803 [default = 3200];
+		int64     oneof_defaulted_int64    = 804 [default = -123456789];
+		sint64    oneof_defaulted_sint64   = 805 [default = -6400];
+		uint64    oneof_defaulted_uint64   = 806 [default = 6400];
+		fixed32   oneof_defaulted_fixed32  = 807 [default = 320000];
+		sfixed32  oneof_defaulted_sfixed32 = 808 [default = -320000];
+		float     oneof_defaulted_float    = 809 [default = 3.14159];
+		fixed64   oneof_defaulted_fixed64  = 810 [default = 640000];
+		sfixed64  oneof_defaulted_sfixed64 = 811 [default = -640000];
+		double    oneof_defaulted_double   = 812 [default = 3.14159265359];
+		string    oneof_defaulted_string   = 813 [default = "hello, \"world!\"\n"];
+		bytes     oneof_defaulted_bytes    = 814 [default = "dead\xde\xad\xbe\xefbeef"];
+
+		ChildEnum   oneof_defaulted_child_enum   = 815 [default = ALPHA];
+		SiblingEnum oneof_defaulted_sibling_enum = 816 [default = ALPHA];
+	}
+
+	// Extension fields.
+	extend Message {
+		// Optional fields.
+		optional bool     extension_optional_bool     = 10000;
+		optional int32    extension_optional_int32    = 10001;
+		optional sint32   extension_optional_sint32   = 10002;
+		optional uint32   extension_optional_uint32   = 10003;
+		optional int64    extension_optional_int64    = 10004;
+		optional sint64   extension_optional_sint64   = 10005;
+		optional uint64   extension_optional_uint64   = 10006;
+		optional fixed32  extension_optional_fixed32  = 10007;
+		optional sfixed32 extension_optional_sfixed32 = 10008;
+		optional float    extension_optional_float    = 10009;
+		optional fixed64  extension_optional_fixed64  = 10010;
+		optional sfixed64 extension_optional_sfixed64 = 10011;
+		optional double   extension_optional_double   = 10012;
+		optional string   extension_optional_string   = 10013;
+		optional bytes    extension_optional_bytes    = 10014;
+
+		optional ChildEnum      extension_optional_child_enum      = 10015;
+		optional ChildMessage   extension_optional_child_message   = 10016;
+		optional NamedGroup     extension_optional_named_group     = 10017;
+		optional SiblingEnum    extension_optional_sibling_enum    = 10018;
+		optional SiblingMessage extension_optional_sibling_message = 10019;
+		optional group ExtensionOptionalGroup = 10020 {
+			optional string f1 = 1;
+			required string f2 = 2;
+			repeated string f3 = 3;
+		}
+
+		// Optional default fields.
+		optional bool      extension_defaulted_bool     = 20000 [default = true];
+		optional int32     extension_defaulted_int32    = 20001 [default = -12345];
+		optional sint32    extension_defaulted_sint32   = 20002 [default = -3200];
+		optional uint32    extension_defaulted_uint32   = 20003 [default = 3200];
+		optional int64     extension_defaulted_int64    = 20004 [default = -123456789];
+		optional sint64    extension_defaulted_sint64   = 20005 [default = -6400];
+		optional uint64    extension_defaulted_uint64   = 20006 [default = 6400];
+		optional fixed32   extension_defaulted_fixed32  = 20007 [default = 320000];
+		optional sfixed32  extension_defaulted_sfixed32 = 20008 [default = -320000];
+		optional float     extension_defaulted_float    = 20009 [default = 3.14159];
+		optional fixed64   extension_defaulted_fixed64  = 20010 [default = 640000];
+		optional sfixed64  extension_defaulted_sfixed64 = 20011 [default = -640000];
+		optional double    extension_defaulted_double   = 20012 [default = 3.14159265359];
+		optional string    extension_defaulted_string   = 20013 [default = "hello, \"world!\"\n"];
+		optional bytes     extension_defaulted_bytes    = 20014 [default = "dead\xde\xad\xbe\xefbeef"];
+
+		optional ChildEnum   extension_defaulted_child_enum   = 20015 [default = ALPHA];
+		optional SiblingEnum extension_defaulted_sibling_enum = 20016 [default = ALPHA];
+
+		// Repeated fields.
+		repeated bool     extension_repeated_bool     = 30000;
+		repeated int32    extension_repeated_int32    = 30001;
+		repeated sint32   extension_repeated_sint32   = 30002;
+		repeated uint32   extension_repeated_uint32   = 30003;
+		repeated int64    extension_repeated_int64    = 30004;
+		repeated sint64   extension_repeated_sint64   = 30005;
+		repeated uint64   extension_repeated_uint64   = 30006;
+		repeated fixed32  extension_repeated_fixed32  = 30007;
+		repeated sfixed32 extension_repeated_sfixed32 = 30008;
+		repeated float    extension_repeated_float    = 30009;
+		repeated fixed64  extension_repeated_fixed64  = 30010;
+		repeated sfixed64 extension_repeated_sfixed64 = 30011;
+		repeated double   extension_repeated_double   = 30012;
+		repeated string   extension_repeated_string   = 30013;
+		repeated bytes    extension_repeated_bytes    = 30014;
+
+		repeated ChildEnum      extension_repeated_child_enum      = 30015;
+		repeated ChildMessage   extension_repeated_child_message   = 30016;
+		repeated NamedGroup     extension_repeated_named_group     = 30017;
+		repeated SiblingEnum    extension_repeated_sibling_enum    = 30018;
+		repeated SiblingMessage extension_repeated_sibling_message = 30019;
+		repeated group ExtensionRepeatedGroup = 30020 {
+			optional string f1 = 1;
+			required string f2 = 2;
+			repeated string f3 = 3;
+		}
+	}
+
+	extensions 10000 to max;
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20180814_aa810b61/test.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20180814_aa810b61/test.pb.go
new file mode 100644
index 000000000..47e825a19
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20180814_aa810b61/test.pb.go
@@ -0,0 +1,3904 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: proto2_20180814_aa810b61/test.proto
+
+package proto2_20180814_aa810b61 // import "google.golang.org/protobuf/internal/testprotos/legacy/proto2_20180814_aa810b61"
+
+import proto "google.golang.org/protobuf/internal/protolegacy"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type SiblingEnum int32
+
+const (
+	SiblingEnum_ALPHA   SiblingEnum = 0
+	SiblingEnum_BRAVO   SiblingEnum = 10
+	SiblingEnum_CHARLIE SiblingEnum = 200
+)
+
+var SiblingEnum_name = map[int32]string{
+	0:   "ALPHA",
+	10:  "BRAVO",
+	200: "CHARLIE",
+}
+var SiblingEnum_value = map[string]int32{
+	"ALPHA":   0,
+	"BRAVO":   10,
+	"CHARLIE": 200,
+}
+
+func (x SiblingEnum) Enum() *SiblingEnum {
+	p := new(SiblingEnum)
+	*p = x
+	return p
+}
+func (x SiblingEnum) String() string {
+	return proto.EnumName(SiblingEnum_name, int32(x))
+}
+func (x *SiblingEnum) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(SiblingEnum_value, data, "SiblingEnum")
+	if err != nil {
+		return err
+	}
+	*x = SiblingEnum(value)
+	return nil
+}
+func (SiblingEnum) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_test_98b5676fa5dea40d, []int{0}
+}
+
+type Message_ChildEnum int32
+
+const (
+	Message_ALPHA   Message_ChildEnum = 0
+	Message_BRAVO   Message_ChildEnum = 1
+	Message_CHARLIE Message_ChildEnum = 2
+)
+
+var Message_ChildEnum_name = map[int32]string{
+	0: "ALPHA",
+	1: "BRAVO",
+	2: "CHARLIE",
+}
+var Message_ChildEnum_value = map[string]int32{
+	"ALPHA":   0,
+	"BRAVO":   1,
+	"CHARLIE": 2,
+}
+
+func (x Message_ChildEnum) Enum() *Message_ChildEnum {
+	p := new(Message_ChildEnum)
+	*p = x
+	return p
+}
+func (x Message_ChildEnum) String() string {
+	return proto.EnumName(Message_ChildEnum_name, int32(x))
+}
+func (x *Message_ChildEnum) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(Message_ChildEnum_value, data, "Message_ChildEnum")
+	if err != nil {
+		return err
+	}
+	*x = Message_ChildEnum(value)
+	return nil
+}
+func (Message_ChildEnum) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_test_98b5676fa5dea40d, []int{1, 0}
+}
+
+type SiblingMessage 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"`
+	F4                   *Message `protobuf:"bytes,4,opt,name=f4" json:"f4,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *SiblingMessage) Reset()         { *m = SiblingMessage{} }
+func (m *SiblingMessage) String() string { return proto.CompactTextString(m) }
+func (*SiblingMessage) ProtoMessage()    {}
+func (*SiblingMessage) Descriptor() ([]byte, []int) {
+	return fileDescriptor_test_98b5676fa5dea40d, []int{0}
+}
+func (m *SiblingMessage) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_SiblingMessage.Unmarshal(m, b)
+}
+func (m *SiblingMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_SiblingMessage.Marshal(b, m, deterministic)
+}
+func (dst *SiblingMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SiblingMessage.Merge(dst, src)
+}
+func (m *SiblingMessage) XXX_Size() int {
+	return xxx_messageInfo_SiblingMessage.Size(m)
+}
+func (m *SiblingMessage) XXX_DiscardUnknown() {
+	xxx_messageInfo_SiblingMessage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SiblingMessage proto.InternalMessageInfo
+
+func (m *SiblingMessage) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *SiblingMessage) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *SiblingMessage) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+func (m *SiblingMessage) GetF4() *Message {
+	if m != nil {
+		return m.F4
+	}
+	return nil
+}
+
+type Message struct {
+	Namedgroup *Message_NamedGroup `protobuf:"group,1,opt,name=NamedGroup,json=namedgroup" json:"namedgroup,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      *Message_ChildEnum     `protobuf:"varint,115,opt,name=optional_child_enum,json=optionalChildEnum,enum=google.golang.org.proto2_20180814.Message_ChildEnum" json:"optional_child_enum,omitempty"`
+	OptionalChildMessage   *Message_ChildMessage  `protobuf:"bytes,116,opt,name=optional_child_message,json=optionalChildMessage" json:"optional_child_message,omitempty"`
+	OptionalNamedGroup     *Message_NamedGroup    `protobuf:"bytes,117,opt,name=optional_named_group,json=optionalNamedGroup" json:"optional_named_group,omitempty"`
+	OptionalSiblingEnum    *SiblingEnum           `protobuf:"varint,118,opt,name=optional_sibling_enum,json=optionalSiblingEnum,enum=google.golang.org.proto2_20180814.SiblingEnum" json:"optional_sibling_enum,omitempty"`
+	OptionalSiblingMessage *SiblingMessage        `protobuf:"bytes,119,opt,name=optional_sibling_message,json=optionalSiblingMessage" json:"optional_sibling_message,omitempty"`
+	Optionalgroup          *Message_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   *Message_ChildEnum `protobuf:"varint,215,opt,name=defaulted_child_enum,json=defaultedChildEnum,enum=google.golang.org.proto2_20180814.Message_ChildEnum,def=0" json:"defaulted_child_enum,omitempty"`
+	DefaultedSiblingEnum *SiblingEnum       `protobuf:"varint,216,opt,name=defaulted_sibling_enum,json=defaultedSiblingEnum,enum=google.golang.org.proto2_20180814.SiblingEnum,def=0" 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      *Message_ChildEnum     `protobuf:"varint,315,req,name=required_child_enum,json=requiredChildEnum,enum=google.golang.org.proto2_20180814.Message_ChildEnum" json:"required_child_enum,omitempty"`
+	RequiredChildMessage   *Message_ChildMessage  `protobuf:"bytes,316,req,name=required_child_message,json=requiredChildMessage" json:"required_child_message,omitempty"`
+	RequiredNamedGroup     *Message_NamedGroup    `protobuf:"bytes,317,req,name=required_named_group,json=requiredNamedGroup" json:"required_named_group,omitempty"`
+	RequiredSiblingEnum    *SiblingEnum           `protobuf:"varint,318,req,name=required_sibling_enum,json=requiredSiblingEnum,enum=google.golang.org.proto2_20180814.SiblingEnum" json:"required_sibling_enum,omitempty"`
+	RequiredSiblingMessage *SiblingMessage        `protobuf:"bytes,319,req,name=required_sibling_message,json=requiredSiblingMessage" json:"required_sibling_message,omitempty"`
+	Requiredgroup          *Message_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   *Message_ChildEnum `protobuf:"varint,415,req,name=required_defaulted_child_enum,json=requiredDefaultedChildEnum,enum=google.golang.org.proto2_20180814.Message_ChildEnum,def=0" json:"required_defaulted_child_enum,omitempty"`
+	RequiredDefaultedSiblingEnum *SiblingEnum       `protobuf:"varint,416,req,name=required_defaulted_sibling_enum,json=requiredDefaultedSiblingEnum,enum=google.golang.org.proto2_20180814.SiblingEnum,def=0" 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      []Message_ChildEnum      `protobuf:"varint,515,rep,name=repeated_child_enum,json=repeatedChildEnum,enum=google.golang.org.proto2_20180814.Message_ChildEnum" json:"repeated_child_enum,omitempty"`
+	RepeatedChildMessage   []*Message_ChildMessage  `protobuf:"bytes,516,rep,name=repeated_child_message,json=repeatedChildMessage" json:"repeated_child_message,omitempty"`
+	RepeatedNamedGroup     []*Message_NamedGroup    `protobuf:"bytes,517,rep,name=repeated_named_group,json=repeatedNamedGroup" json:"repeated_named_group,omitempty"`
+	RepeatedSiblingEnum    []SiblingEnum            `protobuf:"varint,518,rep,name=repeated_sibling_enum,json=repeatedSiblingEnum,enum=google.golang.org.proto2_20180814.SiblingEnum" json:"repeated_sibling_enum,omitempty"`
+	RepeatedSiblingMessage []*SiblingMessage        `protobuf:"bytes,519,rep,name=repeated_sibling_message,json=repeatedSiblingMessage" json:"repeated_sibling_message,omitempty"`
+	Repeatedgroup          []*Message_RepeatedGroup `protobuf:"group,520,rep,name=RepeatedGroup,json=repeatedgroup" json:"repeatedgroup,omitempty"`
+	// Map fields.
+	MapBoolBool           map[bool]bool                  `protobuf:"bytes,600,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,601,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,602,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,603,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,604,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,605,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,606,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,607,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,608,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,609,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,610,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,611,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,612,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,613,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,614,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"`
+	MapBoolChildEnum      map[bool]Message_ChildEnum     `protobuf:"bytes,615,rep,name=map_bool_child_enum,json=mapBoolChildEnum" json:"map_bool_child_enum,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=google.golang.org.proto2_20180814.Message_ChildEnum"`
+	MapBoolChildMessage   map[bool]*Message_ChildMessage `protobuf:"bytes,616,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"`
+	MapBoolNamedGroup     map[bool]*Message_NamedGroup   `protobuf:"bytes,617,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"`
+	MapBoolSiblingEnum    map[bool]SiblingEnum           `protobuf:"bytes,618,rep,name=map_bool_sibling_enum,json=mapBoolSiblingEnum" json:"map_bool_sibling_enum,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=google.golang.org.proto2_20180814.SiblingEnum"`
+	MapBoolSiblingMessage map[bool]*SiblingMessage       `protobuf:"bytes,619,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"`
+	MapInt32Bool          map[int32]bool                 `protobuf:"bytes,620,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,621,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,622,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,623,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,624,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,625,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,626,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,627,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.
+	//
+	// Types that are valid to be assigned to OneofUnion:
+	//	*Message_OneofBool
+	//	*Message_OneofInt32
+	//	*Message_OneofSint32
+	//	*Message_OneofUint32
+	//	*Message_OneofInt64
+	//	*Message_OneofSint64
+	//	*Message_OneofUint64
+	//	*Message_OneofFixed32
+	//	*Message_OneofSfixed32
+	//	*Message_OneofFloat
+	//	*Message_OneofFixed64
+	//	*Message_OneofSfixed64
+	//	*Message_OneofDouble
+	//	*Message_OneofString
+	//	*Message_OneofBytes
+	//	*Message_OneofChildEnum
+	//	*Message_OneofChildMessage
+	//	*Message_OneofNamedGroup
+	//	*Message_OneofSiblingEnum
+	//	*Message_OneofSiblingMessage
+	//	*Message_Oneofgroup
+	//	*Message_OneofString1
+	//	*Message_OneofString2
+	//	*Message_OneofString3
+	OneofUnion isMessage_OneofUnion `protobuf_oneof:"oneof_union"`
+	// Oneof default fields.
+	//
+	// Types that are valid to be assigned to OneofDefaultedUnion:
+	//	*Message_OneofDefaultedBool
+	//	*Message_OneofDefaultedInt32
+	//	*Message_OneofDefaultedSint32
+	//	*Message_OneofDefaultedUint32
+	//	*Message_OneofDefaultedInt64
+	//	*Message_OneofDefaultedSint64
+	//	*Message_OneofDefaultedUint64
+	//	*Message_OneofDefaultedFixed32
+	//	*Message_OneofDefaultedSfixed32
+	//	*Message_OneofDefaultedFloat
+	//	*Message_OneofDefaultedFixed64
+	//	*Message_OneofDefaultedSfixed64
+	//	*Message_OneofDefaultedDouble
+	//	*Message_OneofDefaultedString
+	//	*Message_OneofDefaultedBytes
+	//	*Message_OneofDefaultedChildEnum
+	//	*Message_OneofDefaultedSiblingEnum
+	OneofDefaultedUnion          isMessage_OneofDefaultedUnion `protobuf_oneof:"oneof_defaulted_union"`
+	XXX_NoUnkeyedLiteral         struct{}                      `json:"-"`
+	proto.XXX_InternalExtensions `json:"-"`
+	XXX_unrecognized             []byte `json:"-"`
+	XXX_sizecache                int32  `json:"-"`
+}
+
+func (m *Message) Reset()         { *m = Message{} }
+func (m *Message) String() string { return proto.CompactTextString(m) }
+func (*Message) ProtoMessage()    {}
+func (*Message) Descriptor() ([]byte, []int) {
+	return fileDescriptor_test_98b5676fa5dea40d, []int{1}
+}
+
+var extRange_Message = []proto.ExtensionRange{
+	{Start: 10000, End: 536870911},
+}
+
+func (*Message) ExtensionRangeArray() []proto.ExtensionRange {
+	return extRange_Message
+}
+func (m *Message) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Message.Unmarshal(m, b)
+}
+func (m *Message) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Message.Marshal(b, m, deterministic)
+}
+func (dst *Message) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Message.Merge(dst, src)
+}
+func (m *Message) XXX_Size() int {
+	return xxx_messageInfo_Message.Size(m)
+}
+func (m *Message) XXX_DiscardUnknown() {
+	xxx_messageInfo_Message.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message proto.InternalMessageInfo
+
+const Default_Message_DefaultedBool bool = true
+const Default_Message_DefaultedInt32 int32 = -12345
+const Default_Message_DefaultedSint32 int32 = -3200
+const Default_Message_DefaultedUint32 uint32 = 3200
+const Default_Message_DefaultedInt64 int64 = -123456789
+const Default_Message_DefaultedSint64 int64 = -6400
+const Default_Message_DefaultedUint64 uint64 = 6400
+const Default_Message_DefaultedFixed32 uint32 = 320000
+const Default_Message_DefaultedSfixed32 int32 = -320000
+const Default_Message_DefaultedFloat float32 = 3.14159
+const Default_Message_DefaultedFixed64 uint64 = 640000
+const Default_Message_DefaultedSfixed64 int64 = -640000
+const Default_Message_DefaultedDouble float64 = 3.14159265359
+const Default_Message_DefaultedString string = "hello, \"world!\"\n"
+
+var Default_Message_DefaultedBytes []byte = []byte("deadޭ\xbe\xefbeef")
+
+const Default_Message_DefaultedChildEnum Message_ChildEnum = Message_ALPHA
+const Default_Message_DefaultedSiblingEnum SiblingEnum = SiblingEnum_ALPHA
+const Default_Message_RequiredDefaultedBool bool = true
+const Default_Message_RequiredDefaultedInt32 int32 = -12345
+const Default_Message_RequiredDefaultedSint32 int32 = -3200
+const Default_Message_RequiredDefaultedUint32 uint32 = 3200
+const Default_Message_RequiredDefaultedInt64 int64 = -123456789
+const Default_Message_RequiredDefaultedSint64 int64 = -6400
+const Default_Message_RequiredDefaultedUint64 uint64 = 6400
+const Default_Message_RequiredDefaultedFixed32 uint32 = 320000
+const Default_Message_RequiredDefaultedSfixed32 int32 = -320000
+const Default_Message_RequiredDefaultedFloat float32 = 3.14159
+const Default_Message_RequiredDefaultedFixed64 uint64 = 640000
+const Default_Message_RequiredDefaultedSfixed64 int64 = -640000
+const Default_Message_RequiredDefaultedDouble float64 = 3.14159265359
+const Default_Message_RequiredDefaultedString string = "hello, \"world!\"\n"
+
+var Default_Message_RequiredDefaultedBytes []byte = []byte("deadޭ\xbe\xefbeef")
+
+const Default_Message_RequiredDefaultedChildEnum Message_ChildEnum = Message_ALPHA
+const Default_Message_RequiredDefaultedSiblingEnum SiblingEnum = SiblingEnum_ALPHA
+const Default_Message_OneofDefaultedBool bool = true
+const Default_Message_OneofDefaultedInt32 int32 = -12345
+const Default_Message_OneofDefaultedSint32 int32 = -3200
+const Default_Message_OneofDefaultedUint32 uint32 = 3200
+const Default_Message_OneofDefaultedInt64 int64 = -123456789
+const Default_Message_OneofDefaultedSint64 int64 = -6400
+const Default_Message_OneofDefaultedUint64 uint64 = 6400
+const Default_Message_OneofDefaultedFixed32 uint32 = 320000
+const Default_Message_OneofDefaultedSfixed32 int32 = -320000
+const Default_Message_OneofDefaultedFloat float32 = 3.14159
+const Default_Message_OneofDefaultedFixed64 uint64 = 640000
+const Default_Message_OneofDefaultedSfixed64 int64 = -640000
+const Default_Message_OneofDefaultedDouble float64 = 3.14159265359
+const Default_Message_OneofDefaultedString string = "hello, \"world!\"\n"
+
+var Default_Message_OneofDefaultedBytes []byte = []byte("deadޭ\xbe\xefbeef")
+
+const Default_Message_OneofDefaultedChildEnum Message_ChildEnum = Message_ALPHA
+const Default_Message_OneofDefaultedSiblingEnum SiblingEnum = SiblingEnum_ALPHA
+
+func (m *Message) GetNamedgroup() *Message_NamedGroup {
+	if m != nil {
+		return m.Namedgroup
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalBool() bool {
+	if m != nil && m.OptionalBool != nil {
+		return *m.OptionalBool
+	}
+	return false
+}
+
+func (m *Message) GetOptionalInt32() int32 {
+	if m != nil && m.OptionalInt32 != nil {
+		return *m.OptionalInt32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSint32() int32 {
+	if m != nil && m.OptionalSint32 != nil {
+		return *m.OptionalSint32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalUint32() uint32 {
+	if m != nil && m.OptionalUint32 != nil {
+		return *m.OptionalUint32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalInt64() int64 {
+	if m != nil && m.OptionalInt64 != nil {
+		return *m.OptionalInt64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSint64() int64 {
+	if m != nil && m.OptionalSint64 != nil {
+		return *m.OptionalSint64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalUint64() uint64 {
+	if m != nil && m.OptionalUint64 != nil {
+		return *m.OptionalUint64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalFixed32() uint32 {
+	if m != nil && m.OptionalFixed32 != nil {
+		return *m.OptionalFixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSfixed32() int32 {
+	if m != nil && m.OptionalSfixed32 != nil {
+		return *m.OptionalSfixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalFloat() float32 {
+	if m != nil && m.OptionalFloat != nil {
+		return *m.OptionalFloat
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalFixed64() uint64 {
+	if m != nil && m.OptionalFixed64 != nil {
+		return *m.OptionalFixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSfixed64() int64 {
+	if m != nil && m.OptionalSfixed64 != nil {
+		return *m.OptionalSfixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalDouble() float64 {
+	if m != nil && m.OptionalDouble != nil {
+		return *m.OptionalDouble
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalString() string {
+	if m != nil && m.OptionalString != nil {
+		return *m.OptionalString
+	}
+	return ""
+}
+
+func (m *Message) GetOptionalBytes() []byte {
+	if m != nil {
+		return m.OptionalBytes
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalChildEnum() Message_ChildEnum {
+	if m != nil && m.OptionalChildEnum != nil {
+		return *m.OptionalChildEnum
+	}
+	return Message_ALPHA
+}
+
+func (m *Message) GetOptionalChildMessage() *Message_ChildMessage {
+	if m != nil {
+		return m.OptionalChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalNamedGroup() *Message_NamedGroup {
+	if m != nil {
+		return m.OptionalNamedGroup
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalSiblingEnum() SiblingEnum {
+	if m != nil && m.OptionalSiblingEnum != nil {
+		return *m.OptionalSiblingEnum
+	}
+	return SiblingEnum_ALPHA
+}
+
+func (m *Message) GetOptionalSiblingMessage() *SiblingMessage {
+	if m != nil {
+		return m.OptionalSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalgroup() *Message_OptionalGroup {
+	if m != nil {
+		return m.Optionalgroup
+	}
+	return nil
+}
+
+func (m *Message) GetDefaultedBool() bool {
+	if m != nil && m.DefaultedBool != nil {
+		return *m.DefaultedBool
+	}
+	return Default_Message_DefaultedBool
+}
+
+func (m *Message) GetDefaultedInt32() int32 {
+	if m != nil && m.DefaultedInt32 != nil {
+		return *m.DefaultedInt32
+	}
+	return Default_Message_DefaultedInt32
+}
+
+func (m *Message) GetDefaultedSint32() int32 {
+	if m != nil && m.DefaultedSint32 != nil {
+		return *m.DefaultedSint32
+	}
+	return Default_Message_DefaultedSint32
+}
+
+func (m *Message) GetDefaultedUint32() uint32 {
+	if m != nil && m.DefaultedUint32 != nil {
+		return *m.DefaultedUint32
+	}
+	return Default_Message_DefaultedUint32
+}
+
+func (m *Message) GetDefaultedInt64() int64 {
+	if m != nil && m.DefaultedInt64 != nil {
+		return *m.DefaultedInt64
+	}
+	return Default_Message_DefaultedInt64
+}
+
+func (m *Message) GetDefaultedSint64() int64 {
+	if m != nil && m.DefaultedSint64 != nil {
+		return *m.DefaultedSint64
+	}
+	return Default_Message_DefaultedSint64
+}
+
+func (m *Message) GetDefaultedUint64() uint64 {
+	if m != nil && m.DefaultedUint64 != nil {
+		return *m.DefaultedUint64
+	}
+	return Default_Message_DefaultedUint64
+}
+
+func (m *Message) GetDefaultedFixed32() uint32 {
+	if m != nil && m.DefaultedFixed32 != nil {
+		return *m.DefaultedFixed32
+	}
+	return Default_Message_DefaultedFixed32
+}
+
+func (m *Message) GetDefaultedSfixed32() int32 {
+	if m != nil && m.DefaultedSfixed32 != nil {
+		return *m.DefaultedSfixed32
+	}
+	return Default_Message_DefaultedSfixed32
+}
+
+func (m *Message) GetDefaultedFloat() float32 {
+	if m != nil && m.DefaultedFloat != nil {
+		return *m.DefaultedFloat
+	}
+	return Default_Message_DefaultedFloat
+}
+
+func (m *Message) GetDefaultedFixed64() uint64 {
+	if m != nil && m.DefaultedFixed64 != nil {
+		return *m.DefaultedFixed64
+	}
+	return Default_Message_DefaultedFixed64
+}
+
+func (m *Message) GetDefaultedSfixed64() int64 {
+	if m != nil && m.DefaultedSfixed64 != nil {
+		return *m.DefaultedSfixed64
+	}
+	return Default_Message_DefaultedSfixed64
+}
+
+func (m *Message) GetDefaultedDouble() float64 {
+	if m != nil && m.DefaultedDouble != nil {
+		return *m.DefaultedDouble
+	}
+	return Default_Message_DefaultedDouble
+}
+
+func (m *Message) GetDefaultedString() string {
+	if m != nil && m.DefaultedString != nil {
+		return *m.DefaultedString
+	}
+	return Default_Message_DefaultedString
+}
+
+func (m *Message) GetDefaultedBytes() []byte {
+	if m != nil && m.DefaultedBytes != nil {
+		return m.DefaultedBytes
+	}
+	return append([]byte(nil), Default_Message_DefaultedBytes...)
+}
+
+func (m *Message) GetDefaultedChildEnum() Message_ChildEnum {
+	if m != nil && m.DefaultedChildEnum != nil {
+		return *m.DefaultedChildEnum
+	}
+	return Default_Message_DefaultedChildEnum
+}
+
+func (m *Message) GetDefaultedSiblingEnum() SiblingEnum {
+	if m != nil && m.DefaultedSiblingEnum != nil {
+		return *m.DefaultedSiblingEnum
+	}
+	return Default_Message_DefaultedSiblingEnum
+}
+
+func (m *Message) GetRequiredBool() bool {
+	if m != nil && m.RequiredBool != nil {
+		return *m.RequiredBool
+	}
+	return false
+}
+
+func (m *Message) GetRequiredInt32() int32 {
+	if m != nil && m.RequiredInt32 != nil {
+		return *m.RequiredInt32
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredSint32() int32 {
+	if m != nil && m.RequiredSint32 != nil {
+		return *m.RequiredSint32
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredUint32() uint32 {
+	if m != nil && m.RequiredUint32 != nil {
+		return *m.RequiredUint32
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredInt64() int64 {
+	if m != nil && m.RequiredInt64 != nil {
+		return *m.RequiredInt64
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredSint64() int64 {
+	if m != nil && m.RequiredSint64 != nil {
+		return *m.RequiredSint64
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredUint64() uint64 {
+	if m != nil && m.RequiredUint64 != nil {
+		return *m.RequiredUint64
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredFixed32() uint32 {
+	if m != nil && m.RequiredFixed32 != nil {
+		return *m.RequiredFixed32
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredSfixed32() int32 {
+	if m != nil && m.RequiredSfixed32 != nil {
+		return *m.RequiredSfixed32
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredFloat() float32 {
+	if m != nil && m.RequiredFloat != nil {
+		return *m.RequiredFloat
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredFixed64() uint64 {
+	if m != nil && m.RequiredFixed64 != nil {
+		return *m.RequiredFixed64
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredSfixed64() int64 {
+	if m != nil && m.RequiredSfixed64 != nil {
+		return *m.RequiredSfixed64
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredDouble() float64 {
+	if m != nil && m.RequiredDouble != nil {
+		return *m.RequiredDouble
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredString() string {
+	if m != nil && m.RequiredString != nil {
+		return *m.RequiredString
+	}
+	return ""
+}
+
+func (m *Message) GetRequiredBytes() []byte {
+	if m != nil {
+		return m.RequiredBytes
+	}
+	return nil
+}
+
+func (m *Message) GetRequiredChildEnum() Message_ChildEnum {
+	if m != nil && m.RequiredChildEnum != nil {
+		return *m.RequiredChildEnum
+	}
+	return Message_ALPHA
+}
+
+func (m *Message) GetRequiredChildMessage() *Message_ChildMessage {
+	if m != nil {
+		return m.RequiredChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRequiredNamedGroup() *Message_NamedGroup {
+	if m != nil {
+		return m.RequiredNamedGroup
+	}
+	return nil
+}
+
+func (m *Message) GetRequiredSiblingEnum() SiblingEnum {
+	if m != nil && m.RequiredSiblingEnum != nil {
+		return *m.RequiredSiblingEnum
+	}
+	return SiblingEnum_ALPHA
+}
+
+func (m *Message) GetRequiredSiblingMessage() *SiblingMessage {
+	if m != nil {
+		return m.RequiredSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRequiredgroup() *Message_RequiredGroup {
+	if m != nil {
+		return m.Requiredgroup
+	}
+	return nil
+}
+
+func (m *Message) GetRequiredDefaultedBool() bool {
+	if m != nil && m.RequiredDefaultedBool != nil {
+		return *m.RequiredDefaultedBool
+	}
+	return Default_Message_RequiredDefaultedBool
+}
+
+func (m *Message) GetRequiredDefaultedInt32() int32 {
+	if m != nil && m.RequiredDefaultedInt32 != nil {
+		return *m.RequiredDefaultedInt32
+	}
+	return Default_Message_RequiredDefaultedInt32
+}
+
+func (m *Message) GetRequiredDefaultedSint32() int32 {
+	if m != nil && m.RequiredDefaultedSint32 != nil {
+		return *m.RequiredDefaultedSint32
+	}
+	return Default_Message_RequiredDefaultedSint32
+}
+
+func (m *Message) GetRequiredDefaultedUint32() uint32 {
+	if m != nil && m.RequiredDefaultedUint32 != nil {
+		return *m.RequiredDefaultedUint32
+	}
+	return Default_Message_RequiredDefaultedUint32
+}
+
+func (m *Message) GetRequiredDefaultedInt64() int64 {
+	if m != nil && m.RequiredDefaultedInt64 != nil {
+		return *m.RequiredDefaultedInt64
+	}
+	return Default_Message_RequiredDefaultedInt64
+}
+
+func (m *Message) GetRequiredDefaultedSint64() int64 {
+	if m != nil && m.RequiredDefaultedSint64 != nil {
+		return *m.RequiredDefaultedSint64
+	}
+	return Default_Message_RequiredDefaultedSint64
+}
+
+func (m *Message) GetRequiredDefaultedUint64() uint64 {
+	if m != nil && m.RequiredDefaultedUint64 != nil {
+		return *m.RequiredDefaultedUint64
+	}
+	return Default_Message_RequiredDefaultedUint64
+}
+
+func (m *Message) GetRequiredDefaultedFixed32() uint32 {
+	if m != nil && m.RequiredDefaultedFixed32 != nil {
+		return *m.RequiredDefaultedFixed32
+	}
+	return Default_Message_RequiredDefaultedFixed32
+}
+
+func (m *Message) GetRequiredDefaultedSfixed32() int32 {
+	if m != nil && m.RequiredDefaultedSfixed32 != nil {
+		return *m.RequiredDefaultedSfixed32
+	}
+	return Default_Message_RequiredDefaultedSfixed32
+}
+
+func (m *Message) GetRequiredDefaultedFloat() float32 {
+	if m != nil && m.RequiredDefaultedFloat != nil {
+		return *m.RequiredDefaultedFloat
+	}
+	return Default_Message_RequiredDefaultedFloat
+}
+
+func (m *Message) GetRequiredDefaultedFixed64() uint64 {
+	if m != nil && m.RequiredDefaultedFixed64 != nil {
+		return *m.RequiredDefaultedFixed64
+	}
+	return Default_Message_RequiredDefaultedFixed64
+}
+
+func (m *Message) GetRequiredDefaultedSfixed64() int64 {
+	if m != nil && m.RequiredDefaultedSfixed64 != nil {
+		return *m.RequiredDefaultedSfixed64
+	}
+	return Default_Message_RequiredDefaultedSfixed64
+}
+
+func (m *Message) GetRequiredDefaultedDouble() float64 {
+	if m != nil && m.RequiredDefaultedDouble != nil {
+		return *m.RequiredDefaultedDouble
+	}
+	return Default_Message_RequiredDefaultedDouble
+}
+
+func (m *Message) GetRequiredDefaultedString() string {
+	if m != nil && m.RequiredDefaultedString != nil {
+		return *m.RequiredDefaultedString
+	}
+	return Default_Message_RequiredDefaultedString
+}
+
+func (m *Message) GetRequiredDefaultedBytes() []byte {
+	if m != nil && m.RequiredDefaultedBytes != nil {
+		return m.RequiredDefaultedBytes
+	}
+	return append([]byte(nil), Default_Message_RequiredDefaultedBytes...)
+}
+
+func (m *Message) GetRequiredDefaultedChildEnum() Message_ChildEnum {
+	if m != nil && m.RequiredDefaultedChildEnum != nil {
+		return *m.RequiredDefaultedChildEnum
+	}
+	return Default_Message_RequiredDefaultedChildEnum
+}
+
+func (m *Message) GetRequiredDefaultedSiblingEnum() SiblingEnum {
+	if m != nil && m.RequiredDefaultedSiblingEnum != nil {
+		return *m.RequiredDefaultedSiblingEnum
+	}
+	return Default_Message_RequiredDefaultedSiblingEnum
+}
+
+func (m *Message) GetRepeatedBool() []bool {
+	if m != nil {
+		return m.RepeatedBool
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedInt32() []int32 {
+	if m != nil {
+		return m.RepeatedInt32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSint32() []int32 {
+	if m != nil {
+		return m.RepeatedSint32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedUint32() []uint32 {
+	if m != nil {
+		return m.RepeatedUint32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedInt64() []int64 {
+	if m != nil {
+		return m.RepeatedInt64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSint64() []int64 {
+	if m != nil {
+		return m.RepeatedSint64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedUint64() []uint64 {
+	if m != nil {
+		return m.RepeatedUint64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedFixed32() []uint32 {
+	if m != nil {
+		return m.RepeatedFixed32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSfixed32() []int32 {
+	if m != nil {
+		return m.RepeatedSfixed32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedFloat() []float32 {
+	if m != nil {
+		return m.RepeatedFloat
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedFixed64() []uint64 {
+	if m != nil {
+		return m.RepeatedFixed64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSfixed64() []int64 {
+	if m != nil {
+		return m.RepeatedSfixed64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedDouble() []float64 {
+	if m != nil {
+		return m.RepeatedDouble
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedString() []string {
+	if m != nil {
+		return m.RepeatedString
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedBytes() [][]byte {
+	if m != nil {
+		return m.RepeatedBytes
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedChildEnum() []Message_ChildEnum {
+	if m != nil {
+		return m.RepeatedChildEnum
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedChildMessage() []*Message_ChildMessage {
+	if m != nil {
+		return m.RepeatedChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedNamedGroup() []*Message_NamedGroup {
+	if m != nil {
+		return m.RepeatedNamedGroup
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSiblingEnum() []SiblingEnum {
+	if m != nil {
+		return m.RepeatedSiblingEnum
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSiblingMessage() []*SiblingMessage {
+	if m != nil {
+		return m.RepeatedSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedgroup() []*Message_RepeatedGroup {
+	if m != nil {
+		return m.Repeatedgroup
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolBool() map[bool]bool {
+	if m != nil {
+		return m.MapBoolBool
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolInt32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolInt32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSint32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolSint32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolUint32() map[bool]uint32 {
+	if m != nil {
+		return m.MapBoolUint32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolInt64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolInt64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSint64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolSint64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolUint64() map[bool]uint64 {
+	if m != nil {
+		return m.MapBoolUint64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFixed32() map[bool]uint32 {
+	if m != nil {
+		return m.MapBoolFixed32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSfixed32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolSfixed32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFloat() map[bool]float32 {
+	if m != nil {
+		return m.MapBoolFloat
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFixed64() map[bool]uint64 {
+	if m != nil {
+		return m.MapBoolFixed64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSfixed64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolSfixed64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolDouble() map[bool]float64 {
+	if m != nil {
+		return m.MapBoolDouble
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolString() map[bool]string {
+	if m != nil {
+		return m.MapBoolString
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolBytes() map[bool][]byte {
+	if m != nil {
+		return m.MapBoolBytes
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolChildEnum() map[bool]Message_ChildEnum {
+	if m != nil {
+		return m.MapBoolChildEnum
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolChildMessage() map[bool]*Message_ChildMessage {
+	if m != nil {
+		return m.MapBoolChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolNamedGroup() map[bool]*Message_NamedGroup {
+	if m != nil {
+		return m.MapBoolNamedGroup
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSiblingEnum() map[bool]SiblingEnum {
+	if m != nil {
+		return m.MapBoolSiblingEnum
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSiblingMessage() map[bool]*SiblingMessage {
+	if m != nil {
+		return m.MapBoolSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetMapInt32Bool() map[int32]bool {
+	if m != nil {
+		return m.MapInt32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapSint32Bool() map[int32]bool {
+	if m != nil {
+		return m.MapSint32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapUint32Bool() map[uint32]bool {
+	if m != nil {
+		return m.MapUint32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapInt64Bool() map[int64]bool {
+	if m != nil {
+		return m.MapInt64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapSint64Bool() map[int64]bool {
+	if m != nil {
+		return m.MapSint64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapUint64Bool() map[uint64]bool {
+	if m != nil {
+		return m.MapUint64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapFixed32Bool() map[uint32]bool {
+	if m != nil {
+		return m.MapFixed32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapStringBool() map[string]bool {
+	if m != nil {
+		return m.MapStringBool
+	}
+	return nil
+}
+
+type isMessage_OneofUnion interface {
+	isMessage_OneofUnion()
+}
+
+type Message_OneofBool struct {
+	OneofBool bool `protobuf:"varint,700,opt,name=oneof_bool,json=oneofBool,oneof"`
+}
+
+type Message_OneofInt32 struct {
+	OneofInt32 int32 `protobuf:"varint,701,opt,name=oneof_int32,json=oneofInt32,oneof"`
+}
+
+type Message_OneofSint32 struct {
+	OneofSint32 int32 `protobuf:"zigzag32,702,opt,name=oneof_sint32,json=oneofSint32,oneof"`
+}
+
+type Message_OneofUint32 struct {
+	OneofUint32 uint32 `protobuf:"varint,703,opt,name=oneof_uint32,json=oneofUint32,oneof"`
+}
+
+type Message_OneofInt64 struct {
+	OneofInt64 int64 `protobuf:"varint,704,opt,name=oneof_int64,json=oneofInt64,oneof"`
+}
+
+type Message_OneofSint64 struct {
+	OneofSint64 int64 `protobuf:"zigzag64,705,opt,name=oneof_sint64,json=oneofSint64,oneof"`
+}
+
+type Message_OneofUint64 struct {
+	OneofUint64 uint64 `protobuf:"varint,706,opt,name=oneof_uint64,json=oneofUint64,oneof"`
+}
+
+type Message_OneofFixed32 struct {
+	OneofFixed32 uint32 `protobuf:"fixed32,707,opt,name=oneof_fixed32,json=oneofFixed32,oneof"`
+}
+
+type Message_OneofSfixed32 struct {
+	OneofSfixed32 int32 `protobuf:"fixed32,708,opt,name=oneof_sfixed32,json=oneofSfixed32,oneof"`
+}
+
+type Message_OneofFloat struct {
+	OneofFloat float32 `protobuf:"fixed32,709,opt,name=oneof_float,json=oneofFloat,oneof"`
+}
+
+type Message_OneofFixed64 struct {
+	OneofFixed64 uint64 `protobuf:"fixed64,710,opt,name=oneof_fixed64,json=oneofFixed64,oneof"`
+}
+
+type Message_OneofSfixed64 struct {
+	OneofSfixed64 int64 `protobuf:"fixed64,711,opt,name=oneof_sfixed64,json=oneofSfixed64,oneof"`
+}
+
+type Message_OneofDouble struct {
+	OneofDouble float64 `protobuf:"fixed64,712,opt,name=oneof_double,json=oneofDouble,oneof"`
+}
+
+type Message_OneofString struct {
+	OneofString string `protobuf:"bytes,713,opt,name=oneof_string,json=oneofString,oneof"`
+}
+
+type Message_OneofBytes struct {
+	OneofBytes []byte `protobuf:"bytes,714,opt,name=oneof_bytes,json=oneofBytes,oneof"`
+}
+
+type Message_OneofChildEnum struct {
+	OneofChildEnum Message_ChildEnum `protobuf:"varint,715,opt,name=oneof_child_enum,json=oneofChildEnum,enum=google.golang.org.proto2_20180814.Message_ChildEnum,oneof"`
+}
+
+type Message_OneofChildMessage struct {
+	OneofChildMessage *Message_ChildMessage `protobuf:"bytes,716,opt,name=oneof_child_message,json=oneofChildMessage,oneof"`
+}
+
+type Message_OneofNamedGroup struct {
+	OneofNamedGroup *Message_NamedGroup `protobuf:"bytes,717,opt,name=oneof_named_group,json=oneofNamedGroup,oneof"`
+}
+
+type Message_OneofSiblingEnum struct {
+	OneofSiblingEnum SiblingEnum `protobuf:"varint,718,opt,name=oneof_sibling_enum,json=oneofSiblingEnum,enum=google.golang.org.proto2_20180814.SiblingEnum,oneof"`
+}
+
+type Message_OneofSiblingMessage struct {
+	OneofSiblingMessage *SiblingMessage `protobuf:"bytes,719,opt,name=oneof_sibling_message,json=oneofSiblingMessage,oneof"`
+}
+
+type Message_Oneofgroup struct {
+	Oneofgroup *Message_OneofGroup `protobuf:"group,720,opt,name=OneofGroup,json=oneofgroup,oneof"`
+}
+
+type Message_OneofString1 struct {
+	OneofString1 string `protobuf:"bytes,721,opt,name=oneof_string1,json=oneofString1,oneof"`
+}
+
+type Message_OneofString2 struct {
+	OneofString2 string `protobuf:"bytes,722,opt,name=oneof_string2,json=oneofString2,oneof"`
+}
+
+type Message_OneofString3 struct {
+	OneofString3 string `protobuf:"bytes,723,opt,name=oneof_string3,json=oneofString3,oneof"`
+}
+
+func (*Message_OneofBool) isMessage_OneofUnion() {}
+
+func (*Message_OneofInt32) isMessage_OneofUnion() {}
+
+func (*Message_OneofSint32) isMessage_OneofUnion() {}
+
+func (*Message_OneofUint32) isMessage_OneofUnion() {}
+
+func (*Message_OneofInt64) isMessage_OneofUnion() {}
+
+func (*Message_OneofSint64) isMessage_OneofUnion() {}
+
+func (*Message_OneofUint64) isMessage_OneofUnion() {}
+
+func (*Message_OneofFixed32) isMessage_OneofUnion() {}
+
+func (*Message_OneofSfixed32) isMessage_OneofUnion() {}
+
+func (*Message_OneofFloat) isMessage_OneofUnion() {}
+
+func (*Message_OneofFixed64) isMessage_OneofUnion() {}
+
+func (*Message_OneofSfixed64) isMessage_OneofUnion() {}
+
+func (*Message_OneofDouble) isMessage_OneofUnion() {}
+
+func (*Message_OneofString) isMessage_OneofUnion() {}
+
+func (*Message_OneofBytes) isMessage_OneofUnion() {}
+
+func (*Message_OneofChildEnum) isMessage_OneofUnion() {}
+
+func (*Message_OneofChildMessage) isMessage_OneofUnion() {}
+
+func (*Message_OneofNamedGroup) isMessage_OneofUnion() {}
+
+func (*Message_OneofSiblingEnum) isMessage_OneofUnion() {}
+
+func (*Message_OneofSiblingMessage) isMessage_OneofUnion() {}
+
+func (*Message_Oneofgroup) isMessage_OneofUnion() {}
+
+func (*Message_OneofString1) isMessage_OneofUnion() {}
+
+func (*Message_OneofString2) isMessage_OneofUnion() {}
+
+func (*Message_OneofString3) isMessage_OneofUnion() {}
+
+func (m *Message) GetOneofUnion() isMessage_OneofUnion {
+	if m != nil {
+		return m.OneofUnion
+	}
+	return nil
+}
+
+func (m *Message) GetOneofBool() bool {
+	if x, ok := m.GetOneofUnion().(*Message_OneofBool); ok {
+		return x.OneofBool
+	}
+	return false
+}
+
+func (m *Message) GetOneofInt32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofInt32); ok {
+		return x.OneofInt32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSint32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSint32); ok {
+		return x.OneofSint32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofUint32() uint32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofUint32); ok {
+		return x.OneofUint32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofInt64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofInt64); ok {
+		return x.OneofInt64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSint64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSint64); ok {
+		return x.OneofSint64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofUint64() uint64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofUint64); ok {
+		return x.OneofUint64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFixed32() uint32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFixed32); ok {
+		return x.OneofFixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSfixed32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSfixed32); ok {
+		return x.OneofSfixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFloat() float32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFloat); ok {
+		return x.OneofFloat
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFixed64() uint64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFixed64); ok {
+		return x.OneofFixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSfixed64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSfixed64); ok {
+		return x.OneofSfixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofDouble() float64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofDouble); ok {
+		return x.OneofDouble
+	}
+	return 0
+}
+
+func (m *Message) GetOneofString() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString); ok {
+		return x.OneofString
+	}
+	return ""
+}
+
+func (m *Message) GetOneofBytes() []byte {
+	if x, ok := m.GetOneofUnion().(*Message_OneofBytes); ok {
+		return x.OneofBytes
+	}
+	return nil
+}
+
+func (m *Message) GetOneofChildEnum() Message_ChildEnum {
+	if x, ok := m.GetOneofUnion().(*Message_OneofChildEnum); ok {
+		return x.OneofChildEnum
+	}
+	return Message_ALPHA
+}
+
+func (m *Message) GetOneofChildMessage() *Message_ChildMessage {
+	if x, ok := m.GetOneofUnion().(*Message_OneofChildMessage); ok {
+		return x.OneofChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOneofNamedGroup() *Message_NamedGroup {
+	if x, ok := m.GetOneofUnion().(*Message_OneofNamedGroup); ok {
+		return x.OneofNamedGroup
+	}
+	return nil
+}
+
+func (m *Message) GetOneofSiblingEnum() SiblingEnum {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSiblingEnum); ok {
+		return x.OneofSiblingEnum
+	}
+	return SiblingEnum_ALPHA
+}
+
+func (m *Message) GetOneofSiblingMessage() *SiblingMessage {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSiblingMessage); ok {
+		return x.OneofSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOneofgroup() *Message_OneofGroup {
+	if x, ok := m.GetOneofUnion().(*Message_Oneofgroup); ok {
+		return x.Oneofgroup
+	}
+	return nil
+}
+
+func (m *Message) GetOneofString1() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString1); ok {
+		return x.OneofString1
+	}
+	return ""
+}
+
+func (m *Message) GetOneofString2() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString2); ok {
+		return x.OneofString2
+	}
+	return ""
+}
+
+func (m *Message) GetOneofString3() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString3); ok {
+		return x.OneofString3
+	}
+	return ""
+}
+
+type isMessage_OneofDefaultedUnion interface {
+	isMessage_OneofDefaultedUnion()
+}
+
+type Message_OneofDefaultedBool struct {
+	OneofDefaultedBool bool `protobuf:"varint,800,opt,name=oneof_defaulted_bool,json=oneofDefaultedBool,oneof,def=1"`
+}
+
+type Message_OneofDefaultedInt32 struct {
+	OneofDefaultedInt32 int32 `protobuf:"varint,801,opt,name=oneof_defaulted_int32,json=oneofDefaultedInt32,oneof,def=-12345"`
+}
+
+type Message_OneofDefaultedSint32 struct {
+	OneofDefaultedSint32 int32 `protobuf:"zigzag32,802,opt,name=oneof_defaulted_sint32,json=oneofDefaultedSint32,oneof,def=-3200"`
+}
+
+type Message_OneofDefaultedUint32 struct {
+	OneofDefaultedUint32 uint32 `protobuf:"varint,803,opt,name=oneof_defaulted_uint32,json=oneofDefaultedUint32,oneof,def=3200"`
+}
+
+type Message_OneofDefaultedInt64 struct {
+	OneofDefaultedInt64 int64 `protobuf:"varint,804,opt,name=oneof_defaulted_int64,json=oneofDefaultedInt64,oneof,def=-123456789"`
+}
+
+type Message_OneofDefaultedSint64 struct {
+	OneofDefaultedSint64 int64 `protobuf:"zigzag64,805,opt,name=oneof_defaulted_sint64,json=oneofDefaultedSint64,oneof,def=-6400"`
+}
+
+type Message_OneofDefaultedUint64 struct {
+	OneofDefaultedUint64 uint64 `protobuf:"varint,806,opt,name=oneof_defaulted_uint64,json=oneofDefaultedUint64,oneof,def=6400"`
+}
+
+type Message_OneofDefaultedFixed32 struct {
+	OneofDefaultedFixed32 uint32 `protobuf:"fixed32,807,opt,name=oneof_defaulted_fixed32,json=oneofDefaultedFixed32,oneof,def=320000"`
+}
+
+type Message_OneofDefaultedSfixed32 struct {
+	OneofDefaultedSfixed32 int32 `protobuf:"fixed32,808,opt,name=oneof_defaulted_sfixed32,json=oneofDefaultedSfixed32,oneof,def=-320000"`
+}
+
+type Message_OneofDefaultedFloat struct {
+	OneofDefaultedFloat float32 `protobuf:"fixed32,809,opt,name=oneof_defaulted_float,json=oneofDefaultedFloat,oneof,def=3.14159"`
+}
+
+type Message_OneofDefaultedFixed64 struct {
+	OneofDefaultedFixed64 uint64 `protobuf:"fixed64,810,opt,name=oneof_defaulted_fixed64,json=oneofDefaultedFixed64,oneof,def=640000"`
+}
+
+type Message_OneofDefaultedSfixed64 struct {
+	OneofDefaultedSfixed64 int64 `protobuf:"fixed64,811,opt,name=oneof_defaulted_sfixed64,json=oneofDefaultedSfixed64,oneof,def=-640000"`
+}
+
+type Message_OneofDefaultedDouble struct {
+	OneofDefaultedDouble float64 `protobuf:"fixed64,812,opt,name=oneof_defaulted_double,json=oneofDefaultedDouble,oneof,def=3.14159265359"`
+}
+
+type Message_OneofDefaultedString struct {
+	OneofDefaultedString string `protobuf:"bytes,813,opt,name=oneof_defaulted_string,json=oneofDefaultedString,oneof,def=hello, \"world!\"\n"`
+}
+
+type Message_OneofDefaultedBytes struct {
+	OneofDefaultedBytes []byte `protobuf:"bytes,814,opt,name=oneof_defaulted_bytes,json=oneofDefaultedBytes,oneof,def=dead\\336\\255\\276\\357beef"`
+}
+
+type Message_OneofDefaultedChildEnum struct {
+	OneofDefaultedChildEnum Message_ChildEnum `protobuf:"varint,815,opt,name=oneof_defaulted_child_enum,json=oneofDefaultedChildEnum,enum=google.golang.org.proto2_20180814.Message_ChildEnum,oneof,def=0"`
+}
+
+type Message_OneofDefaultedSiblingEnum struct {
+	OneofDefaultedSiblingEnum SiblingEnum `protobuf:"varint,816,opt,name=oneof_defaulted_sibling_enum,json=oneofDefaultedSiblingEnum,enum=google.golang.org.proto2_20180814.SiblingEnum,oneof,def=0"`
+}
+
+func (*Message_OneofDefaultedBool) isMessage_OneofDefaultedUnion() {}
+
+func (*Message_OneofDefaultedInt32) isMessage_OneofDefaultedUnion() {}
+
+func (*Message_OneofDefaultedSint32) isMessage_OneofDefaultedUnion() {}
+
+func (*Message_OneofDefaultedUint32) isMessage_OneofDefaultedUnion() {}
+
+func (*Message_OneofDefaultedInt64) isMessage_OneofDefaultedUnion() {}
+
+func (*Message_OneofDefaultedSint64) isMessage_OneofDefaultedUnion() {}
+
+func (*Message_OneofDefaultedUint64) isMessage_OneofDefaultedUnion() {}
+
+func (*Message_OneofDefaultedFixed32) isMessage_OneofDefaultedUnion() {}
+
+func (*Message_OneofDefaultedSfixed32) isMessage_OneofDefaultedUnion() {}
+
+func (*Message_OneofDefaultedFloat) isMessage_OneofDefaultedUnion() {}
+
+func (*Message_OneofDefaultedFixed64) isMessage_OneofDefaultedUnion() {}
+
+func (*Message_OneofDefaultedSfixed64) isMessage_OneofDefaultedUnion() {}
+
+func (*Message_OneofDefaultedDouble) isMessage_OneofDefaultedUnion() {}
+
+func (*Message_OneofDefaultedString) isMessage_OneofDefaultedUnion() {}
+
+func (*Message_OneofDefaultedBytes) isMessage_OneofDefaultedUnion() {}
+
+func (*Message_OneofDefaultedChildEnum) isMessage_OneofDefaultedUnion() {}
+
+func (*Message_OneofDefaultedSiblingEnum) isMessage_OneofDefaultedUnion() {}
+
+func (m *Message) GetOneofDefaultedUnion() isMessage_OneofDefaultedUnion {
+	if m != nil {
+		return m.OneofDefaultedUnion
+	}
+	return nil
+}
+
+func (m *Message) GetOneofDefaultedBool() bool {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedBool); ok {
+		return x.OneofDefaultedBool
+	}
+	return Default_Message_OneofDefaultedBool
+}
+
+func (m *Message) GetOneofDefaultedInt32() int32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedInt32); ok {
+		return x.OneofDefaultedInt32
+	}
+	return Default_Message_OneofDefaultedInt32
+}
+
+func (m *Message) GetOneofDefaultedSint32() int32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedSint32); ok {
+		return x.OneofDefaultedSint32
+	}
+	return Default_Message_OneofDefaultedSint32
+}
+
+func (m *Message) GetOneofDefaultedUint32() uint32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedUint32); ok {
+		return x.OneofDefaultedUint32
+	}
+	return Default_Message_OneofDefaultedUint32
+}
+
+func (m *Message) GetOneofDefaultedInt64() int64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedInt64); ok {
+		return x.OneofDefaultedInt64
+	}
+	return Default_Message_OneofDefaultedInt64
+}
+
+func (m *Message) GetOneofDefaultedSint64() int64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedSint64); ok {
+		return x.OneofDefaultedSint64
+	}
+	return Default_Message_OneofDefaultedSint64
+}
+
+func (m *Message) GetOneofDefaultedUint64() uint64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedUint64); ok {
+		return x.OneofDefaultedUint64
+	}
+	return Default_Message_OneofDefaultedUint64
+}
+
+func (m *Message) GetOneofDefaultedFixed32() uint32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedFixed32); ok {
+		return x.OneofDefaultedFixed32
+	}
+	return Default_Message_OneofDefaultedFixed32
+}
+
+func (m *Message) GetOneofDefaultedSfixed32() int32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedSfixed32); ok {
+		return x.OneofDefaultedSfixed32
+	}
+	return Default_Message_OneofDefaultedSfixed32
+}
+
+func (m *Message) GetOneofDefaultedFloat() float32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedFloat); ok {
+		return x.OneofDefaultedFloat
+	}
+	return Default_Message_OneofDefaultedFloat
+}
+
+func (m *Message) GetOneofDefaultedFixed64() uint64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedFixed64); ok {
+		return x.OneofDefaultedFixed64
+	}
+	return Default_Message_OneofDefaultedFixed64
+}
+
+func (m *Message) GetOneofDefaultedSfixed64() int64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedSfixed64); ok {
+		return x.OneofDefaultedSfixed64
+	}
+	return Default_Message_OneofDefaultedSfixed64
+}
+
+func (m *Message) GetOneofDefaultedDouble() float64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedDouble); ok {
+		return x.OneofDefaultedDouble
+	}
+	return Default_Message_OneofDefaultedDouble
+}
+
+func (m *Message) GetOneofDefaultedString() string {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedString); ok {
+		return x.OneofDefaultedString
+	}
+	return Default_Message_OneofDefaultedString
+}
+
+func (m *Message) GetOneofDefaultedBytes() []byte {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedBytes); ok {
+		return x.OneofDefaultedBytes
+	}
+	return append([]byte(nil), Default_Message_OneofDefaultedBytes...)
+}
+
+func (m *Message) GetOneofDefaultedChildEnum() Message_ChildEnum {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedChildEnum); ok {
+		return x.OneofDefaultedChildEnum
+	}
+	return Default_Message_OneofDefaultedChildEnum
+}
+
+func (m *Message) GetOneofDefaultedSiblingEnum() SiblingEnum {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedSiblingEnum); ok {
+		return x.OneofDefaultedSiblingEnum
+	}
+	return Default_Message_OneofDefaultedSiblingEnum
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*Message) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+	return _Message_OneofMarshaler, _Message_OneofUnmarshaler, _Message_OneofSizer, []interface{}{
+		(*Message_OneofBool)(nil),
+		(*Message_OneofInt32)(nil),
+		(*Message_OneofSint32)(nil),
+		(*Message_OneofUint32)(nil),
+		(*Message_OneofInt64)(nil),
+		(*Message_OneofSint64)(nil),
+		(*Message_OneofUint64)(nil),
+		(*Message_OneofFixed32)(nil),
+		(*Message_OneofSfixed32)(nil),
+		(*Message_OneofFloat)(nil),
+		(*Message_OneofFixed64)(nil),
+		(*Message_OneofSfixed64)(nil),
+		(*Message_OneofDouble)(nil),
+		(*Message_OneofString)(nil),
+		(*Message_OneofBytes)(nil),
+		(*Message_OneofChildEnum)(nil),
+		(*Message_OneofChildMessage)(nil),
+		(*Message_OneofNamedGroup)(nil),
+		(*Message_OneofSiblingEnum)(nil),
+		(*Message_OneofSiblingMessage)(nil),
+		(*Message_Oneofgroup)(nil),
+		(*Message_OneofString1)(nil),
+		(*Message_OneofString2)(nil),
+		(*Message_OneofString3)(nil),
+		(*Message_OneofDefaultedBool)(nil),
+		(*Message_OneofDefaultedInt32)(nil),
+		(*Message_OneofDefaultedSint32)(nil),
+		(*Message_OneofDefaultedUint32)(nil),
+		(*Message_OneofDefaultedInt64)(nil),
+		(*Message_OneofDefaultedSint64)(nil),
+		(*Message_OneofDefaultedUint64)(nil),
+		(*Message_OneofDefaultedFixed32)(nil),
+		(*Message_OneofDefaultedSfixed32)(nil),
+		(*Message_OneofDefaultedFloat)(nil),
+		(*Message_OneofDefaultedFixed64)(nil),
+		(*Message_OneofDefaultedSfixed64)(nil),
+		(*Message_OneofDefaultedDouble)(nil),
+		(*Message_OneofDefaultedString)(nil),
+		(*Message_OneofDefaultedBytes)(nil),
+		(*Message_OneofDefaultedChildEnum)(nil),
+		(*Message_OneofDefaultedSiblingEnum)(nil),
+	}
+}
+
+func _Message_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*Message)
+	// oneof_union
+	switch x := m.OneofUnion.(type) {
+	case *Message_OneofBool:
+		t := uint64(0)
+		if x.OneofBool {
+			t = 1
+		}
+		b.EncodeVarint(700<<3 | proto.WireVarint)
+		b.EncodeVarint(t)
+	case *Message_OneofInt32:
+		b.EncodeVarint(701<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofInt32))
+	case *Message_OneofSint32:
+		b.EncodeVarint(702<<3 | proto.WireVarint)
+		b.EncodeZigzag32(uint64(x.OneofSint32))
+	case *Message_OneofUint32:
+		b.EncodeVarint(703<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofUint32))
+	case *Message_OneofInt64:
+		b.EncodeVarint(704<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofInt64))
+	case *Message_OneofSint64:
+		b.EncodeVarint(705<<3 | proto.WireVarint)
+		b.EncodeZigzag64(uint64(x.OneofSint64))
+	case *Message_OneofUint64:
+		b.EncodeVarint(706<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofUint64))
+	case *Message_OneofFixed32:
+		b.EncodeVarint(707<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(x.OneofFixed32))
+	case *Message_OneofSfixed32:
+		b.EncodeVarint(708<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(x.OneofSfixed32))
+	case *Message_OneofFloat:
+		b.EncodeVarint(709<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(math.Float32bits(x.OneofFloat)))
+	case *Message_OneofFixed64:
+		b.EncodeVarint(710<<3 | proto.WireFixed64)
+		b.EncodeFixed64(uint64(x.OneofFixed64))
+	case *Message_OneofSfixed64:
+		b.EncodeVarint(711<<3 | proto.WireFixed64)
+		b.EncodeFixed64(uint64(x.OneofSfixed64))
+	case *Message_OneofDouble:
+		b.EncodeVarint(712<<3 | proto.WireFixed64)
+		b.EncodeFixed64(math.Float64bits(x.OneofDouble))
+	case *Message_OneofString:
+		b.EncodeVarint(713<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString)
+	case *Message_OneofBytes:
+		b.EncodeVarint(714<<3 | proto.WireBytes)
+		b.EncodeRawBytes(x.OneofBytes)
+	case *Message_OneofChildEnum:
+		b.EncodeVarint(715<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofChildEnum))
+	case *Message_OneofChildMessage:
+		b.EncodeVarint(716<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.OneofChildMessage); err != nil {
+			return err
+		}
+	case *Message_OneofNamedGroup:
+		b.EncodeVarint(717<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.OneofNamedGroup); err != nil {
+			return err
+		}
+	case *Message_OneofSiblingEnum:
+		b.EncodeVarint(718<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofSiblingEnum))
+	case *Message_OneofSiblingMessage:
+		b.EncodeVarint(719<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.OneofSiblingMessage); err != nil {
+			return err
+		}
+	case *Message_Oneofgroup:
+		b.EncodeVarint(720<<3 | proto.WireStartGroup)
+		if err := b.Marshal(x.Oneofgroup); err != nil {
+			return err
+		}
+		b.EncodeVarint(720<<3 | proto.WireEndGroup)
+	case *Message_OneofString1:
+		b.EncodeVarint(721<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString1)
+	case *Message_OneofString2:
+		b.EncodeVarint(722<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString2)
+	case *Message_OneofString3:
+		b.EncodeVarint(723<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString3)
+	case nil:
+	default:
+		return fmt.Errorf("Message.OneofUnion has unexpected type %T", x)
+	}
+	// oneof_defaulted_union
+	switch x := m.OneofDefaultedUnion.(type) {
+	case *Message_OneofDefaultedBool:
+		t := uint64(0)
+		if x.OneofDefaultedBool {
+			t = 1
+		}
+		b.EncodeVarint(800<<3 | proto.WireVarint)
+		b.EncodeVarint(t)
+	case *Message_OneofDefaultedInt32:
+		b.EncodeVarint(801<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofDefaultedInt32))
+	case *Message_OneofDefaultedSint32:
+		b.EncodeVarint(802<<3 | proto.WireVarint)
+		b.EncodeZigzag32(uint64(x.OneofDefaultedSint32))
+	case *Message_OneofDefaultedUint32:
+		b.EncodeVarint(803<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofDefaultedUint32))
+	case *Message_OneofDefaultedInt64:
+		b.EncodeVarint(804<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofDefaultedInt64))
+	case *Message_OneofDefaultedSint64:
+		b.EncodeVarint(805<<3 | proto.WireVarint)
+		b.EncodeZigzag64(uint64(x.OneofDefaultedSint64))
+	case *Message_OneofDefaultedUint64:
+		b.EncodeVarint(806<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofDefaultedUint64))
+	case *Message_OneofDefaultedFixed32:
+		b.EncodeVarint(807<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(x.OneofDefaultedFixed32))
+	case *Message_OneofDefaultedSfixed32:
+		b.EncodeVarint(808<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(x.OneofDefaultedSfixed32))
+	case *Message_OneofDefaultedFloat:
+		b.EncodeVarint(809<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(math.Float32bits(x.OneofDefaultedFloat)))
+	case *Message_OneofDefaultedFixed64:
+		b.EncodeVarint(810<<3 | proto.WireFixed64)
+		b.EncodeFixed64(uint64(x.OneofDefaultedFixed64))
+	case *Message_OneofDefaultedSfixed64:
+		b.EncodeVarint(811<<3 | proto.WireFixed64)
+		b.EncodeFixed64(uint64(x.OneofDefaultedSfixed64))
+	case *Message_OneofDefaultedDouble:
+		b.EncodeVarint(812<<3 | proto.WireFixed64)
+		b.EncodeFixed64(math.Float64bits(x.OneofDefaultedDouble))
+	case *Message_OneofDefaultedString:
+		b.EncodeVarint(813<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofDefaultedString)
+	case *Message_OneofDefaultedBytes:
+		b.EncodeVarint(814<<3 | proto.WireBytes)
+		b.EncodeRawBytes(x.OneofDefaultedBytes)
+	case *Message_OneofDefaultedChildEnum:
+		b.EncodeVarint(815<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofDefaultedChildEnum))
+	case *Message_OneofDefaultedSiblingEnum:
+		b.EncodeVarint(816<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofDefaultedSiblingEnum))
+	case nil:
+	default:
+		return fmt.Errorf("Message.OneofDefaultedUnion has unexpected type %T", x)
+	}
+	return nil
+}
+
+func _Message_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*Message)
+	switch tag {
+	case 700: // oneof_union.oneof_bool
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofBool{x != 0}
+		return true, err
+	case 701: // oneof_union.oneof_int32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofInt32{int32(x)}
+		return true, err
+	case 702: // oneof_union.oneof_sint32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeZigzag32()
+		m.OneofUnion = &Message_OneofSint32{int32(x)}
+		return true, err
+	case 703: // oneof_union.oneof_uint32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofUint32{uint32(x)}
+		return true, err
+	case 704: // oneof_union.oneof_int64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofInt64{int64(x)}
+		return true, err
+	case 705: // oneof_union.oneof_sint64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeZigzag64()
+		m.OneofUnion = &Message_OneofSint64{int64(x)}
+		return true, err
+	case 706: // oneof_union.oneof_uint64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofUint64{x}
+		return true, err
+	case 707: // oneof_union.oneof_fixed32
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofUnion = &Message_OneofFixed32{uint32(x)}
+		return true, err
+	case 708: // oneof_union.oneof_sfixed32
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofUnion = &Message_OneofSfixed32{int32(x)}
+		return true, err
+	case 709: // oneof_union.oneof_float
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofUnion = &Message_OneofFloat{math.Float32frombits(uint32(x))}
+		return true, err
+	case 710: // oneof_union.oneof_fixed64
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofUnion = &Message_OneofFixed64{x}
+		return true, err
+	case 711: // oneof_union.oneof_sfixed64
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofUnion = &Message_OneofSfixed64{int64(x)}
+		return true, err
+	case 712: // oneof_union.oneof_double
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofUnion = &Message_OneofDouble{math.Float64frombits(x)}
+		return true, err
+	case 713: // oneof_union.oneof_string
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString{x}
+		return true, err
+	case 714: // oneof_union.oneof_bytes
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeRawBytes(true)
+		m.OneofUnion = &Message_OneofBytes{x}
+		return true, err
+	case 715: // oneof_union.oneof_child_enum
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofChildEnum{Message_ChildEnum(x)}
+		return true, err
+	case 716: // oneof_union.oneof_child_message
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(Message_ChildMessage)
+		err := b.DecodeMessage(msg)
+		m.OneofUnion = &Message_OneofChildMessage{msg}
+		return true, err
+	case 717: // oneof_union.oneof_named_group
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(Message_NamedGroup)
+		err := b.DecodeMessage(msg)
+		m.OneofUnion = &Message_OneofNamedGroup{msg}
+		return true, err
+	case 718: // oneof_union.oneof_sibling_enum
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofSiblingEnum{SiblingEnum(x)}
+		return true, err
+	case 719: // oneof_union.oneof_sibling_message
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(SiblingMessage)
+		err := b.DecodeMessage(msg)
+		m.OneofUnion = &Message_OneofSiblingMessage{msg}
+		return true, err
+	case 720: // oneof_union.oneofgroup
+		if wire != proto.WireStartGroup {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(Message_OneofGroup)
+		err := b.DecodeGroup(msg)
+		m.OneofUnion = &Message_Oneofgroup{msg}
+		return true, err
+	case 721: // oneof_union.oneof_string1
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString1{x}
+		return true, err
+	case 722: // oneof_union.oneof_string2
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString2{x}
+		return true, err
+	case 723: // oneof_union.oneof_string3
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString3{x}
+		return true, err
+	case 800: // oneof_defaulted_union.oneof_defaulted_bool
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedBool{x != 0}
+		return true, err
+	case 801: // oneof_defaulted_union.oneof_defaulted_int32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedInt32{int32(x)}
+		return true, err
+	case 802: // oneof_defaulted_union.oneof_defaulted_sint32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeZigzag32()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedSint32{int32(x)}
+		return true, err
+	case 803: // oneof_defaulted_union.oneof_defaulted_uint32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedUint32{uint32(x)}
+		return true, err
+	case 804: // oneof_defaulted_union.oneof_defaulted_int64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedInt64{int64(x)}
+		return true, err
+	case 805: // oneof_defaulted_union.oneof_defaulted_sint64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeZigzag64()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedSint64{int64(x)}
+		return true, err
+	case 806: // oneof_defaulted_union.oneof_defaulted_uint64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedUint64{x}
+		return true, err
+	case 807: // oneof_defaulted_union.oneof_defaulted_fixed32
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedFixed32{uint32(x)}
+		return true, err
+	case 808: // oneof_defaulted_union.oneof_defaulted_sfixed32
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedSfixed32{int32(x)}
+		return true, err
+	case 809: // oneof_defaulted_union.oneof_defaulted_float
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedFloat{math.Float32frombits(uint32(x))}
+		return true, err
+	case 810: // oneof_defaulted_union.oneof_defaulted_fixed64
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedFixed64{x}
+		return true, err
+	case 811: // oneof_defaulted_union.oneof_defaulted_sfixed64
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedSfixed64{int64(x)}
+		return true, err
+	case 812: // oneof_defaulted_union.oneof_defaulted_double
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedDouble{math.Float64frombits(x)}
+		return true, err
+	case 813: // oneof_defaulted_union.oneof_defaulted_string
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedString{x}
+		return true, err
+	case 814: // oneof_defaulted_union.oneof_defaulted_bytes
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeRawBytes(true)
+		m.OneofDefaultedUnion = &Message_OneofDefaultedBytes{x}
+		return true, err
+	case 815: // oneof_defaulted_union.oneof_defaulted_child_enum
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedChildEnum{Message_ChildEnum(x)}
+		return true, err
+	case 816: // oneof_defaulted_union.oneof_defaulted_sibling_enum
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofDefaultedUnion = &Message_OneofDefaultedSiblingEnum{SiblingEnum(x)}
+		return true, err
+	default:
+		return false, nil
+	}
+}
+
+func _Message_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*Message)
+	// oneof_union
+	switch x := m.OneofUnion.(type) {
+	case *Message_OneofBool:
+		n += 2 // tag and wire
+		n += 1
+	case *Message_OneofInt32:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofInt32))
+	case *Message_OneofSint32:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64((uint32(x.OneofSint32) << 1) ^ uint32((int32(x.OneofSint32) >> 31))))
+	case *Message_OneofUint32:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofUint32))
+	case *Message_OneofInt64:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofInt64))
+	case *Message_OneofSint64:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(uint64(x.OneofSint64<<1) ^ uint64((int64(x.OneofSint64) >> 63))))
+	case *Message_OneofUint64:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofUint64))
+	case *Message_OneofFixed32:
+		n += 2 // tag and wire
+		n += 4
+	case *Message_OneofSfixed32:
+		n += 2 // tag and wire
+		n += 4
+	case *Message_OneofFloat:
+		n += 2 // tag and wire
+		n += 4
+	case *Message_OneofFixed64:
+		n += 2 // tag and wire
+		n += 8
+	case *Message_OneofSfixed64:
+		n += 2 // tag and wire
+		n += 8
+	case *Message_OneofDouble:
+		n += 2 // tag and wire
+		n += 8
+	case *Message_OneofString:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(len(x.OneofString)))
+		n += len(x.OneofString)
+	case *Message_OneofBytes:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(len(x.OneofBytes)))
+		n += len(x.OneofBytes)
+	case *Message_OneofChildEnum:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofChildEnum))
+	case *Message_OneofChildMessage:
+		s := proto.Size(x.OneofChildMessage)
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *Message_OneofNamedGroup:
+		s := proto.Size(x.OneofNamedGroup)
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *Message_OneofSiblingEnum:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofSiblingEnum))
+	case *Message_OneofSiblingMessage:
+		s := proto.Size(x.OneofSiblingMessage)
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *Message_Oneofgroup:
+		n += 2 // tag and wire
+		n += proto.Size(x.Oneofgroup)
+		n += 2 // tag and wire
+	case *Message_OneofString1:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(len(x.OneofString1)))
+		n += len(x.OneofString1)
+	case *Message_OneofString2:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(len(x.OneofString2)))
+		n += len(x.OneofString2)
+	case *Message_OneofString3:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(len(x.OneofString3)))
+		n += len(x.OneofString3)
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	// oneof_defaulted_union
+	switch x := m.OneofDefaultedUnion.(type) {
+	case *Message_OneofDefaultedBool:
+		n += 2 // tag and wire
+		n += 1
+	case *Message_OneofDefaultedInt32:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofDefaultedInt32))
+	case *Message_OneofDefaultedSint32:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64((uint32(x.OneofDefaultedSint32) << 1) ^ uint32((int32(x.OneofDefaultedSint32) >> 31))))
+	case *Message_OneofDefaultedUint32:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofDefaultedUint32))
+	case *Message_OneofDefaultedInt64:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofDefaultedInt64))
+	case *Message_OneofDefaultedSint64:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(uint64(x.OneofDefaultedSint64<<1) ^ uint64((int64(x.OneofDefaultedSint64) >> 63))))
+	case *Message_OneofDefaultedUint64:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofDefaultedUint64))
+	case *Message_OneofDefaultedFixed32:
+		n += 2 // tag and wire
+		n += 4
+	case *Message_OneofDefaultedSfixed32:
+		n += 2 // tag and wire
+		n += 4
+	case *Message_OneofDefaultedFloat:
+		n += 2 // tag and wire
+		n += 4
+	case *Message_OneofDefaultedFixed64:
+		n += 2 // tag and wire
+		n += 8
+	case *Message_OneofDefaultedSfixed64:
+		n += 2 // tag and wire
+		n += 8
+	case *Message_OneofDefaultedDouble:
+		n += 2 // tag and wire
+		n += 8
+	case *Message_OneofDefaultedString:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(len(x.OneofDefaultedString)))
+		n += len(x.OneofDefaultedString)
+	case *Message_OneofDefaultedBytes:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(len(x.OneofDefaultedBytes)))
+		n += len(x.OneofDefaultedBytes)
+	case *Message_OneofDefaultedChildEnum:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofDefaultedChildEnum))
+	case *Message_OneofDefaultedSiblingEnum:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofDefaultedSiblingEnum))
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	return n
+}
+
+var E_Message_ExtensionOptionalBool = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*bool)(nil),
+	Field:         10000,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_optional_bool",
+	Tag:           "varint,10000,opt,name=extension_optional_bool,json=extensionOptionalBool",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionOptionalInt32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         10001,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_optional_int32",
+	Tag:           "varint,10001,opt,name=extension_optional_int32,json=extensionOptionalInt32",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionOptionalSint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         10002,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_optional_sint32",
+	Tag:           "zigzag32,10002,opt,name=extension_optional_sint32,json=extensionOptionalSint32",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionOptionalUint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint32)(nil),
+	Field:         10003,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_optional_uint32",
+	Tag:           "varint,10003,opt,name=extension_optional_uint32,json=extensionOptionalUint32",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionOptionalInt64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         10004,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_optional_int64",
+	Tag:           "varint,10004,opt,name=extension_optional_int64,json=extensionOptionalInt64",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionOptionalSint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         10005,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_optional_sint64",
+	Tag:           "zigzag64,10005,opt,name=extension_optional_sint64,json=extensionOptionalSint64",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionOptionalUint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint64)(nil),
+	Field:         10006,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_optional_uint64",
+	Tag:           "varint,10006,opt,name=extension_optional_uint64,json=extensionOptionalUint64",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionOptionalFixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint32)(nil),
+	Field:         10007,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_optional_fixed32",
+	Tag:           "fixed32,10007,opt,name=extension_optional_fixed32,json=extensionOptionalFixed32",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionOptionalSfixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         10008,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_optional_sfixed32",
+	Tag:           "fixed32,10008,opt,name=extension_optional_sfixed32,json=extensionOptionalSfixed32",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionOptionalFloat = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*float32)(nil),
+	Field:         10009,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_optional_float",
+	Tag:           "fixed32,10009,opt,name=extension_optional_float,json=extensionOptionalFloat",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionOptionalFixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint64)(nil),
+	Field:         10010,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_optional_fixed64",
+	Tag:           "fixed64,10010,opt,name=extension_optional_fixed64,json=extensionOptionalFixed64",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionOptionalSfixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         10011,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_optional_sfixed64",
+	Tag:           "fixed64,10011,opt,name=extension_optional_sfixed64,json=extensionOptionalSfixed64",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionOptionalDouble = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*float64)(nil),
+	Field:         10012,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_optional_double",
+	Tag:           "fixed64,10012,opt,name=extension_optional_double,json=extensionOptionalDouble",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionOptionalString = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*string)(nil),
+	Field:         10013,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_optional_string",
+	Tag:           "bytes,10013,opt,name=extension_optional_string,json=extensionOptionalString",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionOptionalBytes = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]byte)(nil),
+	Field:         10014,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_optional_bytes",
+	Tag:           "bytes,10014,opt,name=extension_optional_bytes,json=extensionOptionalBytes",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionOptionalChildEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*Message_ChildEnum)(nil),
+	Field:         10015,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_optional_child_enum",
+	Tag:           "varint,10015,opt,name=extension_optional_child_enum,json=extensionOptionalChildEnum,enum=google.golang.org.proto2_20180814.Message_ChildEnum",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionOptionalChildMessage = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*Message_ChildMessage)(nil),
+	Field:         10016,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_optional_child_message",
+	Tag:           "bytes,10016,opt,name=extension_optional_child_message,json=extensionOptionalChildMessage",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionOptionalNamedGroup = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*Message_NamedGroup)(nil),
+	Field:         10017,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_optional_named_group",
+	Tag:           "bytes,10017,opt,name=extension_optional_named_group,json=extensionOptionalNamedGroup",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionOptionalSiblingEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*SiblingEnum)(nil),
+	Field:         10018,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_optional_sibling_enum",
+	Tag:           "varint,10018,opt,name=extension_optional_sibling_enum,json=extensionOptionalSiblingEnum,enum=google.golang.org.proto2_20180814.SiblingEnum",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionOptionalSiblingMessage = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*SiblingMessage)(nil),
+	Field:         10019,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_optional_sibling_message",
+	Tag:           "bytes,10019,opt,name=extension_optional_sibling_message,json=extensionOptionalSiblingMessage",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_Extensionoptionalgroup = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*Message_ExtensionOptionalGroup)(nil),
+	Field:         10020,
+	Name:          "google.golang.org.proto2_20180814.Message.extensionoptionalgroup",
+	Tag:           "group,10020,opt,name=ExtensionOptionalGroup,json=extensionoptionalgroup",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionDefaultedBool = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*bool)(nil),
+	Field:         20000,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_defaulted_bool",
+	Tag:           "varint,20000,opt,name=extension_defaulted_bool,json=extensionDefaultedBool,def=1",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionDefaultedInt32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         20001,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_defaulted_int32",
+	Tag:           "varint,20001,opt,name=extension_defaulted_int32,json=extensionDefaultedInt32,def=-12345",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionDefaultedSint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         20002,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_defaulted_sint32",
+	Tag:           "zigzag32,20002,opt,name=extension_defaulted_sint32,json=extensionDefaultedSint32,def=-3200",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionDefaultedUint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint32)(nil),
+	Field:         20003,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_defaulted_uint32",
+	Tag:           "varint,20003,opt,name=extension_defaulted_uint32,json=extensionDefaultedUint32,def=3200",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionDefaultedInt64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         20004,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_defaulted_int64",
+	Tag:           "varint,20004,opt,name=extension_defaulted_int64,json=extensionDefaultedInt64,def=-123456789",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionDefaultedSint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         20005,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_defaulted_sint64",
+	Tag:           "zigzag64,20005,opt,name=extension_defaulted_sint64,json=extensionDefaultedSint64,def=-6400",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionDefaultedUint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint64)(nil),
+	Field:         20006,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_defaulted_uint64",
+	Tag:           "varint,20006,opt,name=extension_defaulted_uint64,json=extensionDefaultedUint64,def=6400",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionDefaultedFixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint32)(nil),
+	Field:         20007,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_defaulted_fixed32",
+	Tag:           "fixed32,20007,opt,name=extension_defaulted_fixed32,json=extensionDefaultedFixed32,def=320000",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionDefaultedSfixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         20008,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_defaulted_sfixed32",
+	Tag:           "fixed32,20008,opt,name=extension_defaulted_sfixed32,json=extensionDefaultedSfixed32,def=-320000",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionDefaultedFloat = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*float32)(nil),
+	Field:         20009,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_defaulted_float",
+	Tag:           "fixed32,20009,opt,name=extension_defaulted_float,json=extensionDefaultedFloat,def=3.14159",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionDefaultedFixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint64)(nil),
+	Field:         20010,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_defaulted_fixed64",
+	Tag:           "fixed64,20010,opt,name=extension_defaulted_fixed64,json=extensionDefaultedFixed64,def=640000",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionDefaultedSfixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         20011,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_defaulted_sfixed64",
+	Tag:           "fixed64,20011,opt,name=extension_defaulted_sfixed64,json=extensionDefaultedSfixed64,def=-640000",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionDefaultedDouble = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*float64)(nil),
+	Field:         20012,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_defaulted_double",
+	Tag:           "fixed64,20012,opt,name=extension_defaulted_double,json=extensionDefaultedDouble,def=3.14159265359",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionDefaultedString = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*string)(nil),
+	Field:         20013,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_defaulted_string",
+	Tag:           "bytes,20013,opt,name=extension_defaulted_string,json=extensionDefaultedString,def=hello, \"world!\"\n",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionDefaultedBytes = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]byte)(nil),
+	Field:         20014,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_defaulted_bytes",
+	Tag:           "bytes,20014,opt,name=extension_defaulted_bytes,json=extensionDefaultedBytes,def=dead\\336\\255\\276\\357beef",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionDefaultedChildEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*Message_ChildEnum)(nil),
+	Field:         20015,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_defaulted_child_enum",
+	Tag:           "varint,20015,opt,name=extension_defaulted_child_enum,json=extensionDefaultedChildEnum,enum=google.golang.org.proto2_20180814.Message_ChildEnum,def=0",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionDefaultedSiblingEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*SiblingEnum)(nil),
+	Field:         20016,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_defaulted_sibling_enum",
+	Tag:           "varint,20016,opt,name=extension_defaulted_sibling_enum,json=extensionDefaultedSiblingEnum,enum=google.golang.org.proto2_20180814.SiblingEnum,def=0",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionRepeatedBool = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]bool)(nil),
+	Field:         30000,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_repeated_bool",
+	Tag:           "varint,30000,rep,name=extension_repeated_bool,json=extensionRepeatedBool",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionRepeatedInt32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int32)(nil),
+	Field:         30001,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_repeated_int32",
+	Tag:           "varint,30001,rep,name=extension_repeated_int32,json=extensionRepeatedInt32",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionRepeatedSint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int32)(nil),
+	Field:         30002,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_repeated_sint32",
+	Tag:           "zigzag32,30002,rep,name=extension_repeated_sint32,json=extensionRepeatedSint32",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionRepeatedUint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]uint32)(nil),
+	Field:         30003,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_repeated_uint32",
+	Tag:           "varint,30003,rep,name=extension_repeated_uint32,json=extensionRepeatedUint32",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionRepeatedInt64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int64)(nil),
+	Field:         30004,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_repeated_int64",
+	Tag:           "varint,30004,rep,name=extension_repeated_int64,json=extensionRepeatedInt64",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionRepeatedSint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int64)(nil),
+	Field:         30005,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_repeated_sint64",
+	Tag:           "zigzag64,30005,rep,name=extension_repeated_sint64,json=extensionRepeatedSint64",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionRepeatedUint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]uint64)(nil),
+	Field:         30006,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_repeated_uint64",
+	Tag:           "varint,30006,rep,name=extension_repeated_uint64,json=extensionRepeatedUint64",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionRepeatedFixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]uint32)(nil),
+	Field:         30007,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_repeated_fixed32",
+	Tag:           "fixed32,30007,rep,name=extension_repeated_fixed32,json=extensionRepeatedFixed32",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionRepeatedSfixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int32)(nil),
+	Field:         30008,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_repeated_sfixed32",
+	Tag:           "fixed32,30008,rep,name=extension_repeated_sfixed32,json=extensionRepeatedSfixed32",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionRepeatedFloat = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]float32)(nil),
+	Field:         30009,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_repeated_float",
+	Tag:           "fixed32,30009,rep,name=extension_repeated_float,json=extensionRepeatedFloat",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionRepeatedFixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]uint64)(nil),
+	Field:         30010,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_repeated_fixed64",
+	Tag:           "fixed64,30010,rep,name=extension_repeated_fixed64,json=extensionRepeatedFixed64",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionRepeatedSfixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int64)(nil),
+	Field:         30011,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_repeated_sfixed64",
+	Tag:           "fixed64,30011,rep,name=extension_repeated_sfixed64,json=extensionRepeatedSfixed64",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionRepeatedDouble = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]float64)(nil),
+	Field:         30012,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_repeated_double",
+	Tag:           "fixed64,30012,rep,name=extension_repeated_double,json=extensionRepeatedDouble",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionRepeatedString = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]string)(nil),
+	Field:         30013,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_repeated_string",
+	Tag:           "bytes,30013,rep,name=extension_repeated_string,json=extensionRepeatedString",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionRepeatedBytes = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([][]byte)(nil),
+	Field:         30014,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_repeated_bytes",
+	Tag:           "bytes,30014,rep,name=extension_repeated_bytes,json=extensionRepeatedBytes",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionRepeatedChildEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]Message_ChildEnum)(nil),
+	Field:         30015,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_repeated_child_enum",
+	Tag:           "varint,30015,rep,name=extension_repeated_child_enum,json=extensionRepeatedChildEnum,enum=google.golang.org.proto2_20180814.Message_ChildEnum",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionRepeatedChildMessage = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]*Message_ChildMessage)(nil),
+	Field:         30016,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_repeated_child_message",
+	Tag:           "bytes,30016,rep,name=extension_repeated_child_message,json=extensionRepeatedChildMessage",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionRepeatedNamedGroup = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]*Message_NamedGroup)(nil),
+	Field:         30017,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_repeated_named_group",
+	Tag:           "bytes,30017,rep,name=extension_repeated_named_group,json=extensionRepeatedNamedGroup",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionRepeatedSiblingEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]SiblingEnum)(nil),
+	Field:         30018,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_repeated_sibling_enum",
+	Tag:           "varint,30018,rep,name=extension_repeated_sibling_enum,json=extensionRepeatedSiblingEnum,enum=google.golang.org.proto2_20180814.SiblingEnum",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_ExtensionRepeatedSiblingMessage = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]*SiblingMessage)(nil),
+	Field:         30019,
+	Name:          "google.golang.org.proto2_20180814.Message.extension_repeated_sibling_message",
+	Tag:           "bytes,30019,rep,name=extension_repeated_sibling_message,json=extensionRepeatedSiblingMessage",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+var E_Message_Extensionrepeatedgroup = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]*Message_ExtensionRepeatedGroup)(nil),
+	Field:         30020,
+	Name:          "google.golang.org.proto2_20180814.Message.extensionrepeatedgroup",
+	Tag:           "group,30020,rep,name=ExtensionRepeatedGroup,json=extensionrepeatedgroup",
+	Filename:      "proto2_20180814_aa810b61/test.proto",
+}
+
+type Message_ChildMessage 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"`
+	F4                   *Message `protobuf:"bytes,4,opt,name=f4" json:"f4,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Message_ChildMessage) Reset()         { *m = Message_ChildMessage{} }
+func (m *Message_ChildMessage) String() string { return proto.CompactTextString(m) }
+func (*Message_ChildMessage) ProtoMessage()    {}
+func (*Message_ChildMessage) Descriptor() ([]byte, []int) {
+	return fileDescriptor_test_98b5676fa5dea40d, []int{1, 0}
+}
+func (m *Message_ChildMessage) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Message_ChildMessage.Unmarshal(m, b)
+}
+func (m *Message_ChildMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Message_ChildMessage.Marshal(b, m, deterministic)
+}
+func (dst *Message_ChildMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Message_ChildMessage.Merge(dst, src)
+}
+func (m *Message_ChildMessage) XXX_Size() int {
+	return xxx_messageInfo_Message_ChildMessage.Size(m)
+}
+func (m *Message_ChildMessage) XXX_DiscardUnknown() {
+	xxx_messageInfo_Message_ChildMessage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message_ChildMessage proto.InternalMessageInfo
+
+func (m *Message_ChildMessage) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_ChildMessage) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_ChildMessage) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+func (m *Message_ChildMessage) GetF4() *Message {
+	if m != nil {
+		return m.F4
+	}
+	return nil
+}
+
+type Message_NamedGroup 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"`
+	F4                   *Message `protobuf:"bytes,4,opt,name=f4" json:"f4,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Message_NamedGroup) Reset()         { *m = Message_NamedGroup{} }
+func (m *Message_NamedGroup) String() string { return proto.CompactTextString(m) }
+func (*Message_NamedGroup) ProtoMessage()    {}
+func (*Message_NamedGroup) Descriptor() ([]byte, []int) {
+	return fileDescriptor_test_98b5676fa5dea40d, []int{1, 1}
+}
+func (m *Message_NamedGroup) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Message_NamedGroup.Unmarshal(m, b)
+}
+func (m *Message_NamedGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Message_NamedGroup.Marshal(b, m, deterministic)
+}
+func (dst *Message_NamedGroup) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Message_NamedGroup.Merge(dst, src)
+}
+func (m *Message_NamedGroup) XXX_Size() int {
+	return xxx_messageInfo_Message_NamedGroup.Size(m)
+}
+func (m *Message_NamedGroup) XXX_DiscardUnknown() {
+	xxx_messageInfo_Message_NamedGroup.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message_NamedGroup proto.InternalMessageInfo
+
+func (m *Message_NamedGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_NamedGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_NamedGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+func (m *Message_NamedGroup) GetF4() *Message {
+	if m != nil {
+		return m.F4
+	}
+	return nil
+}
+
+type Message_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 (m *Message_OptionalGroup) Reset()         { *m = Message_OptionalGroup{} }
+func (m *Message_OptionalGroup) String() string { return proto.CompactTextString(m) }
+func (*Message_OptionalGroup) ProtoMessage()    {}
+func (*Message_OptionalGroup) Descriptor() ([]byte, []int) {
+	return fileDescriptor_test_98b5676fa5dea40d, []int{1, 2}
+}
+func (m *Message_OptionalGroup) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Message_OptionalGroup.Unmarshal(m, b)
+}
+func (m *Message_OptionalGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Message_OptionalGroup.Marshal(b, m, deterministic)
+}
+func (dst *Message_OptionalGroup) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Message_OptionalGroup.Merge(dst, src)
+}
+func (m *Message_OptionalGroup) XXX_Size() int {
+	return xxx_messageInfo_Message_OptionalGroup.Size(m)
+}
+func (m *Message_OptionalGroup) XXX_DiscardUnknown() {
+	xxx_messageInfo_Message_OptionalGroup.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message_OptionalGroup proto.InternalMessageInfo
+
+func (m *Message_OptionalGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_OptionalGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_OptionalGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message_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 (m *Message_RequiredGroup) Reset()         { *m = Message_RequiredGroup{} }
+func (m *Message_RequiredGroup) String() string { return proto.CompactTextString(m) }
+func (*Message_RequiredGroup) ProtoMessage()    {}
+func (*Message_RequiredGroup) Descriptor() ([]byte, []int) {
+	return fileDescriptor_test_98b5676fa5dea40d, []int{1, 3}
+}
+func (m *Message_RequiredGroup) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Message_RequiredGroup.Unmarshal(m, b)
+}
+func (m *Message_RequiredGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Message_RequiredGroup.Marshal(b, m, deterministic)
+}
+func (dst *Message_RequiredGroup) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Message_RequiredGroup.Merge(dst, src)
+}
+func (m *Message_RequiredGroup) XXX_Size() int {
+	return xxx_messageInfo_Message_RequiredGroup.Size(m)
+}
+func (m *Message_RequiredGroup) XXX_DiscardUnknown() {
+	xxx_messageInfo_Message_RequiredGroup.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message_RequiredGroup proto.InternalMessageInfo
+
+func (m *Message_RequiredGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_RequiredGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_RequiredGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message_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 (m *Message_RepeatedGroup) Reset()         { *m = Message_RepeatedGroup{} }
+func (m *Message_RepeatedGroup) String() string { return proto.CompactTextString(m) }
+func (*Message_RepeatedGroup) ProtoMessage()    {}
+func (*Message_RepeatedGroup) Descriptor() ([]byte, []int) {
+	return fileDescriptor_test_98b5676fa5dea40d, []int{1, 4}
+}
+func (m *Message_RepeatedGroup) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Message_RepeatedGroup.Unmarshal(m, b)
+}
+func (m *Message_RepeatedGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Message_RepeatedGroup.Marshal(b, m, deterministic)
+}
+func (dst *Message_RepeatedGroup) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Message_RepeatedGroup.Merge(dst, src)
+}
+func (m *Message_RepeatedGroup) XXX_Size() int {
+	return xxx_messageInfo_Message_RepeatedGroup.Size(m)
+}
+func (m *Message_RepeatedGroup) XXX_DiscardUnknown() {
+	xxx_messageInfo_Message_RepeatedGroup.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message_RepeatedGroup proto.InternalMessageInfo
+
+func (m *Message_RepeatedGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_RepeatedGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_RepeatedGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message_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 (m *Message_OneofGroup) Reset()         { *m = Message_OneofGroup{} }
+func (m *Message_OneofGroup) String() string { return proto.CompactTextString(m) }
+func (*Message_OneofGroup) ProtoMessage()    {}
+func (*Message_OneofGroup) Descriptor() ([]byte, []int) {
+	return fileDescriptor_test_98b5676fa5dea40d, []int{1, 33}
+}
+func (m *Message_OneofGroup) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Message_OneofGroup.Unmarshal(m, b)
+}
+func (m *Message_OneofGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Message_OneofGroup.Marshal(b, m, deterministic)
+}
+func (dst *Message_OneofGroup) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Message_OneofGroup.Merge(dst, src)
+}
+func (m *Message_OneofGroup) XXX_Size() int {
+	return xxx_messageInfo_Message_OneofGroup.Size(m)
+}
+func (m *Message_OneofGroup) XXX_DiscardUnknown() {
+	xxx_messageInfo_Message_OneofGroup.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message_OneofGroup proto.InternalMessageInfo
+
+func (m *Message_OneofGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_OneofGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_OneofGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message_ExtensionOptionalGroup 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 (m *Message_ExtensionOptionalGroup) Reset()         { *m = Message_ExtensionOptionalGroup{} }
+func (m *Message_ExtensionOptionalGroup) String() string { return proto.CompactTextString(m) }
+func (*Message_ExtensionOptionalGroup) ProtoMessage()    {}
+func (*Message_ExtensionOptionalGroup) Descriptor() ([]byte, []int) {
+	return fileDescriptor_test_98b5676fa5dea40d, []int{1, 34}
+}
+func (m *Message_ExtensionOptionalGroup) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Message_ExtensionOptionalGroup.Unmarshal(m, b)
+}
+func (m *Message_ExtensionOptionalGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Message_ExtensionOptionalGroup.Marshal(b, m, deterministic)
+}
+func (dst *Message_ExtensionOptionalGroup) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Message_ExtensionOptionalGroup.Merge(dst, src)
+}
+func (m *Message_ExtensionOptionalGroup) XXX_Size() int {
+	return xxx_messageInfo_Message_ExtensionOptionalGroup.Size(m)
+}
+func (m *Message_ExtensionOptionalGroup) XXX_DiscardUnknown() {
+	xxx_messageInfo_Message_ExtensionOptionalGroup.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message_ExtensionOptionalGroup proto.InternalMessageInfo
+
+func (m *Message_ExtensionOptionalGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_ExtensionOptionalGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_ExtensionOptionalGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message_ExtensionRepeatedGroup 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 (m *Message_ExtensionRepeatedGroup) Reset()         { *m = Message_ExtensionRepeatedGroup{} }
+func (m *Message_ExtensionRepeatedGroup) String() string { return proto.CompactTextString(m) }
+func (*Message_ExtensionRepeatedGroup) ProtoMessage()    {}
+func (*Message_ExtensionRepeatedGroup) Descriptor() ([]byte, []int) {
+	return fileDescriptor_test_98b5676fa5dea40d, []int{1, 35}
+}
+func (m *Message_ExtensionRepeatedGroup) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Message_ExtensionRepeatedGroup.Unmarshal(m, b)
+}
+func (m *Message_ExtensionRepeatedGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Message_ExtensionRepeatedGroup.Marshal(b, m, deterministic)
+}
+func (dst *Message_ExtensionRepeatedGroup) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Message_ExtensionRepeatedGroup.Merge(dst, src)
+}
+func (m *Message_ExtensionRepeatedGroup) XXX_Size() int {
+	return xxx_messageInfo_Message_ExtensionRepeatedGroup.Size(m)
+}
+func (m *Message_ExtensionRepeatedGroup) XXX_DiscardUnknown() {
+	xxx_messageInfo_Message_ExtensionRepeatedGroup.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message_ExtensionRepeatedGroup proto.InternalMessageInfo
+
+func (m *Message_ExtensionRepeatedGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_ExtensionRepeatedGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_ExtensionRepeatedGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*SiblingMessage)(nil), "google.golang.org.proto2_20180814.SiblingMessage")
+	proto.RegisterType((*Message)(nil), "google.golang.org.proto2_20180814.Message")
+	proto.RegisterMapType((map[bool]bool)(nil), "google.golang.org.proto2_20180814.Message.MapBoolBoolEntry")
+	proto.RegisterMapType((map[bool][]byte)(nil), "google.golang.org.proto2_20180814.Message.MapBoolBytesEntry")
+	proto.RegisterMapType((map[bool]Message_ChildEnum)(nil), "google.golang.org.proto2_20180814.Message.MapBoolChildEnumEntry")
+	proto.RegisterMapType((map[bool]*Message_ChildMessage)(nil), "google.golang.org.proto2_20180814.Message.MapBoolChildMessageEntry")
+	proto.RegisterMapType((map[bool]float64)(nil), "google.golang.org.proto2_20180814.Message.MapBoolDoubleEntry")
+	proto.RegisterMapType((map[bool]uint32)(nil), "google.golang.org.proto2_20180814.Message.MapBoolFixed32Entry")
+	proto.RegisterMapType((map[bool]uint64)(nil), "google.golang.org.proto2_20180814.Message.MapBoolFixed64Entry")
+	proto.RegisterMapType((map[bool]float32)(nil), "google.golang.org.proto2_20180814.Message.MapBoolFloatEntry")
+	proto.RegisterMapType((map[bool]int32)(nil), "google.golang.org.proto2_20180814.Message.MapBoolInt32Entry")
+	proto.RegisterMapType((map[bool]int64)(nil), "google.golang.org.proto2_20180814.Message.MapBoolInt64Entry")
+	proto.RegisterMapType((map[bool]*Message_NamedGroup)(nil), "google.golang.org.proto2_20180814.Message.MapBoolNamedGroupEntry")
+	proto.RegisterMapType((map[bool]int32)(nil), "google.golang.org.proto2_20180814.Message.MapBoolSfixed32Entry")
+	proto.RegisterMapType((map[bool]int64)(nil), "google.golang.org.proto2_20180814.Message.MapBoolSfixed64Entry")
+	proto.RegisterMapType((map[bool]SiblingEnum)(nil), "google.golang.org.proto2_20180814.Message.MapBoolSiblingEnumEntry")
+	proto.RegisterMapType((map[bool]*SiblingMessage)(nil), "google.golang.org.proto2_20180814.Message.MapBoolSiblingMessageEntry")
+	proto.RegisterMapType((map[bool]int32)(nil), "google.golang.org.proto2_20180814.Message.MapBoolSint32Entry")
+	proto.RegisterMapType((map[bool]int64)(nil), "google.golang.org.proto2_20180814.Message.MapBoolSint64Entry")
+	proto.RegisterMapType((map[bool]string)(nil), "google.golang.org.proto2_20180814.Message.MapBoolStringEntry")
+	proto.RegisterMapType((map[bool]uint32)(nil), "google.golang.org.proto2_20180814.Message.MapBoolUint32Entry")
+	proto.RegisterMapType((map[bool]uint64)(nil), "google.golang.org.proto2_20180814.Message.MapBoolUint64Entry")
+	proto.RegisterMapType((map[uint32]bool)(nil), "google.golang.org.proto2_20180814.Message.MapFixed32BoolEntry")
+	proto.RegisterMapType((map[int32]bool)(nil), "google.golang.org.proto2_20180814.Message.MapInt32BoolEntry")
+	proto.RegisterMapType((map[int64]bool)(nil), "google.golang.org.proto2_20180814.Message.MapInt64BoolEntry")
+	proto.RegisterMapType((map[int32]bool)(nil), "google.golang.org.proto2_20180814.Message.MapSint32BoolEntry")
+	proto.RegisterMapType((map[int64]bool)(nil), "google.golang.org.proto2_20180814.Message.MapSint64BoolEntry")
+	proto.RegisterMapType((map[string]bool)(nil), "google.golang.org.proto2_20180814.Message.MapStringBoolEntry")
+	proto.RegisterMapType((map[uint32]bool)(nil), "google.golang.org.proto2_20180814.Message.MapUint32BoolEntry")
+	proto.RegisterMapType((map[uint64]bool)(nil), "google.golang.org.proto2_20180814.Message.MapUint64BoolEntry")
+	proto.RegisterType((*Message_ChildMessage)(nil), "google.golang.org.proto2_20180814.Message.ChildMessage")
+	proto.RegisterType((*Message_NamedGroup)(nil), "google.golang.org.proto2_20180814.Message.NamedGroup")
+	proto.RegisterType((*Message_OptionalGroup)(nil), "google.golang.org.proto2_20180814.Message.OptionalGroup")
+	proto.RegisterType((*Message_RequiredGroup)(nil), "google.golang.org.proto2_20180814.Message.RequiredGroup")
+	proto.RegisterType((*Message_RepeatedGroup)(nil), "google.golang.org.proto2_20180814.Message.RepeatedGroup")
+	proto.RegisterType((*Message_OneofGroup)(nil), "google.golang.org.proto2_20180814.Message.OneofGroup")
+	proto.RegisterType((*Message_ExtensionOptionalGroup)(nil), "google.golang.org.proto2_20180814.Message.ExtensionOptionalGroup")
+	proto.RegisterType((*Message_ExtensionRepeatedGroup)(nil), "google.golang.org.proto2_20180814.Message.ExtensionRepeatedGroup")
+	proto.RegisterEnum("google.golang.org.proto2_20180814.SiblingEnum", SiblingEnum_name, SiblingEnum_value)
+	proto.RegisterEnum("google.golang.org.proto2_20180814.Message_ChildEnum", Message_ChildEnum_name, Message_ChildEnum_value)
+	proto.RegisterExtension(E_Message_ExtensionOptionalBool)
+	proto.RegisterExtension(E_Message_ExtensionOptionalInt32)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSint32)
+	proto.RegisterExtension(E_Message_ExtensionOptionalUint32)
+	proto.RegisterExtension(E_Message_ExtensionOptionalInt64)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSint64)
+	proto.RegisterExtension(E_Message_ExtensionOptionalUint64)
+	proto.RegisterExtension(E_Message_ExtensionOptionalFixed32)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSfixed32)
+	proto.RegisterExtension(E_Message_ExtensionOptionalFloat)
+	proto.RegisterExtension(E_Message_ExtensionOptionalFixed64)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSfixed64)
+	proto.RegisterExtension(E_Message_ExtensionOptionalDouble)
+	proto.RegisterExtension(E_Message_ExtensionOptionalString)
+	proto.RegisterExtension(E_Message_ExtensionOptionalBytes)
+	proto.RegisterExtension(E_Message_ExtensionOptionalChildEnum)
+	proto.RegisterExtension(E_Message_ExtensionOptionalChildMessage)
+	proto.RegisterExtension(E_Message_ExtensionOptionalNamedGroup)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSiblingEnum)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSiblingMessage)
+	proto.RegisterExtension(E_Message_Extensionoptionalgroup)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedBool)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedInt32)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedSint32)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedUint32)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedInt64)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedSint64)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedUint64)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedFixed32)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedSfixed32)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedFloat)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedFixed64)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedSfixed64)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedDouble)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedString)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedBytes)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedChildEnum)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedSiblingEnum)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedBool)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedInt32)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSint32)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedUint32)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedInt64)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSint64)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedUint64)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedFixed32)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSfixed32)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedFloat)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedFixed64)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSfixed64)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedDouble)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedString)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedBytes)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedChildEnum)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedChildMessage)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedNamedGroup)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSiblingEnum)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSiblingMessage)
+	proto.RegisterExtension(E_Message_Extensionrepeatedgroup)
+}
+
+func init() {
+	proto.RegisterFile("proto2_20180814_aa810b61/test.proto", fileDescriptor_test_98b5676fa5dea40d)
+}
+
+var fileDescriptor_test_98b5676fa5dea40d = []byte{
+	// 4469 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x5c, 0x69, 0x70, 0x23, 0xc7,
+	0x75, 0xe6, 0x00, 0x04, 0xb8, 0xec, 0x25, 0x48, 0x70, 0x76, 0x97, 0x9c, 0xa5, 0xa4, 0x08, 0x5e,
+	0x3b, 0x0e, 0xa2, 0x68, 0xb9, 0xe4, 0xb0, 0xb7, 0x77, 0x85, 0xe8, 0xf0, 0x52, 0x5a, 0x19, 0x72,
+	0x2c, 0xc8, 0x35, 0xaa, 0x4d, 0xa5, 0x52, 0xaa, 0x30, 0xe0, 0x12, 0xe4, 0x52, 0xc2, 0x41, 0x91,
+	0x80, 0xa4, 0x8d, 0x9d, 0xd2, 0xc6, 0x39, 0x7f, 0xca, 0xf7, 0x05, 0xdb, 0xb2, 0x6e, 0x5b, 0xa7,
+	0xef, 0x4b, 0x97, 0x8f, 0x24, 0xf2, 0x7d, 0xe5, 0x70, 0x2e, 0xe7, 0xbe, 0x9c, 0xfb, 0xbe, 0x8f,
+	0xea, 0x7e, 0xdd, 0xd3, 0xdd, 0x33, 0x3d, 0x20, 0x7b, 0xe0, 0xd2, 0x0f, 0x55, 0x69, 0x1b, 0xaf,
+	0xdf, 0xd7, 0xef, 0x43, 0xbf, 0xf7, 0x3e, 0xf6, 0x4c, 0x03, 0xbd, 0x74, 0x6b, 0xbb, 0xd3, 0xed,
+	0xf8, 0x2b, 0xfe, 0xc2, 0xe2, 0xc9, 0x85, 0x93, 0x8b, 0x78, 0xa5, 0x5e, 0x3f, 0xb9, 0xb8, 0xb0,
+	0x4a, 0x16, 0x8f, 0x75, 0x1b, 0x3b, 0xdd, 0x79, 0xf6, 0xa9, 0xfb, 0x92, 0x8d, 0x4e, 0x67, 0xa3,
+	0xd9, 0x98, 0xdf, 0xe8, 0x34, 0xeb, 0xed, 0x8d, 0xf9, 0xce, 0xf6, 0xc6, 0x7c, 0x64, 0xda, 0x91,
+	0xd7, 0xa1, 0xc9, 0x9b, 0x37, 0x57, 0x9b, 0x9b, 0xed, 0x8d, 0x1b, 0x1b, 0x3b, 0x3b, 0xf5, 0x8d,
+	0x86, 0x3b, 0x89, 0x32, 0xeb, 0x8b, 0x9e, 0x53, 0x72, 0xca, 0xe3, 0x41, 0x66, 0x7d, 0x91, 0xfd,
+	0xdb, 0xf7, 0x32, 0xa5, 0x0c, 0xfb, 0xb7, 0xcf, 0xfe, 0xbd, 0xe4, 0x65, 0x4b, 0x59, 0xf6, 0xef,
+	0x25, 0xb7, 0x82, 0x32, 0xeb, 0xd8, 0x1b, 0x2d, 0x39, 0xe5, 0xfd, 0xfe, 0x65, 0xf3, 0xbb, 0x22,
+	0xce, 0x73, 0x9c, 0x20, 0xb3, 0x8e, 0x8f, 0x7c, 0xe7, 0x51, 0x07, 0x8d, 0x09, 0xe0, 0x33, 0x08,
+	0xb5, 0xeb, 0xad, 0xc6, 0xda, 0xc6, 0x76, 0xa7, 0xb7, 0xc5, 0x16, 0x80, 0xfc, 0xe3, 0x7b, 0x77,
+	0x38, 0x5f, 0xa3, 0x93, 0x5f, 0x49, 0x27, 0x07, 0x8a, 0x23, 0xf7, 0xa5, 0xa8, 0xd0, 0xd9, 0xea,
+	0x6e, 0x76, 0xda, 0xf5, 0xe6, 0xca, 0x6a, 0xa7, 0xd3, 0xf4, 0xd6, 0x4a, 0x4e, 0x79, 0x5f, 0x30,
+	0x21, 0x06, 0x97, 0x3b, 0x9d, 0xa6, 0xfb, 0xfd, 0x68, 0x32, 0x34, 0xda, 0x6c, 0x77, 0x97, 0x7c,
+	0xaf, 0x51, 0x72, 0xca, 0xb9, 0x20, 0x9c, 0x7a, 0x03, 0x1d, 0x74, 0x7f, 0x00, 0x4d, 0x85, 0x66,
+	0x3b, 0x60, 0xb7, 0x5e, 0x72, 0xca, 0xd3, 0x41, 0x38, 0xfb, 0xe6, 0xcd, 0x98, 0x61, 0x0f, 0x0c,
+	0x37, 0x4a, 0x4e, 0xb9, 0x20, 0x0d, 0xcf, 0x80, 0x61, 0x04, 0x98, 0x60, 0xef, 0x5c, 0xc9, 0x29,
+	0x67, 0x35, 0x60, 0x82, 0x63, 0xc0, 0x04, 0x7b, 0x9b, 0x25, 0xa7, 0xec, 0xea, 0xc0, 0x11, 0xc3,
+	0x1e, 0x18, 0xde, 0x5a, 0x72, 0xca, 0xa3, 0x3a, 0x30, 0xc1, 0xee, 0x0f, 0xa2, 0x62, 0x68, 0xb8,
+	0xbe, 0x79, 0x57, 0x63, 0x6d, 0xc9, 0xf7, 0x6e, 0x2b, 0x39, 0xe5, 0xb1, 0x20, 0x74, 0x70, 0x3d,
+	0x0c, 0xbb, 0x3f, 0x84, 0xa6, 0x25, 0xb8, 0xb0, 0x6d, 0x96, 0x9c, 0xf2, 0x54, 0x10, 0xfa, 0xb8,
+	0x99, 0x8f, 0x6b, 0x01, 0xad, 0x37, 0x3b, 0xf5, 0xae, 0xd7, 0x2a, 0x39, 0xe5, 0x8c, 0x0c, 0xe8,
+	0x7a, 0x3a, 0x18, 0x87, 0x27, 0xd8, 0x6b, 0x97, 0x9c, 0x72, 0x3e, 0x02, 0x4f, 0xb0, 0x01, 0x9e,
+	0x60, 0xaf, 0x53, 0x72, 0xca, 0xc5, 0x28, 0x7c, 0x24, 0xfe, 0xb5, 0x4e, 0x6f, 0xb5, 0xd9, 0xf0,
+	0xb6, 0x4a, 0x4e, 0xd9, 0x91, 0xf1, 0x5f, 0xc7, 0x46, 0x75, 0x46, 0xbb, 0xdb, 0x9b, 0xed, 0x0d,
+	0xef, 0x76, 0xb6, 0xe7, 0x25, 0xa3, 0x6c, 0x54, 0x0b, 0x68, 0xf5, 0x7c, 0xb7, 0xb1, 0xe3, 0x6d,
+	0x97, 0x9c, 0xf2, 0x84, 0x0c, 0x68, 0x99, 0x0e, 0xba, 0x6b, 0xe8, 0x40, 0x68, 0x76, 0xf6, 0xdc,
+	0x66, 0x73, 0x6d, 0xa5, 0xd1, 0xee, 0xb5, 0xbc, 0x9d, 0x92, 0x53, 0x9e, 0xf4, 0xb1, 0xc5, 0x36,
+	0xbe, 0x96, 0x4e, 0x3e, 0xdd, 0xee, 0xb5, 0x82, 0x30, 0xec, 0x70, 0xc8, 0x6d, 0xa1, 0x99, 0x08,
+	0x4a, 0x0b, 0xa6, 0x79, 0x5d, 0x96, 0x80, 0x27, 0x6c, 0x81, 0x44, 0x36, 0x1e, 0xd4, 0xb0, 0x44,
+	0x4a, 0x6e, 0xa0, 0x70, 0x7c, 0x85, 0xa5, 0xd4, 0x0a, 0x24, 0x67, 0x8f, 0x81, 0xa5, 0x4c, 0x4e,
+	0x57, 0xb8, 0x94, 0x63, 0xee, 0x2a, 0x3a, 0xa4, 0xec, 0x6f, 0x56, 0x8f, 0x80, 0xbf, 0x3b, 0x18,
+	0x7f, 0xf3, 0x7b, 0x40, 0xe2, 0x65, 0x8c, 0x31, 0x77, 0x40, 0x66, 0x45, 0x38, 0xe8, 0xde, 0x86,
+	0xbc, 0x18, 0x86, 0x60, 0xef, 0x4e, 0x16, 0xd0, 0xe2, 0xde, 0x61, 0x04, 0x6f, 0x33, 0x11, 0x24,
+	0xc1, 0xdc, 0x4f, 0xc8, 0xaa, 0x03, 0x94, 0xdd, 0xc5, 0xea, 0xd9, 0x49, 0x0b, 0xca, 0x6e, 0xe2,
+	0xf3, 0x81, 0x35, 0xdd, 0x9d, 0x7b, 0x39, 0x9a, 0x5c, 0x6b, 0xac, 0xd7, 0x7b, 0xcd, 0x6e, 0x63,
+	0x0d, 0xca, 0xda, 0x0b, 0xb4, 0x62, 0xee, 0xab, 0x8c, 0x76, 0xb7, 0x7b, 0x8d, 0xa0, 0x10, 0x7e,
+	0xc8, 0xca, 0xdb, 0x02, 0x9a, 0x92, 0xd6, 0x50, 0x8e, 0xbe, 0x40, 0xcd, 0x73, 0x95, 0xfc, 0xd1,
+	0x45, 0x7f, 0x09, 0x1f, 0x0f, 0xa4, 0x37, 0xa8, 0x74, 0x8b, 0xa8, 0x28, 0x67, 0xf0, 0x52, 0xf7,
+	0x45, 0x3a, 0x65, 0xba, 0x92, 0x3b, 0xba, 0xe4, 0x2f, 0x2c, 0x04, 0xd2, 0x23, 0xaf, 0x79, 0x0b,
+	0xea, 0x14, 0x5e, 0xf4, 0xbe, 0x44, 0xa7, 0x14, 0x2a, 0xa3, 0x91, 0x19, 0xbc, 0xf8, 0xe1, 0xc8,
+	0xb2, 0x08, 0xf6, 0xbe, 0x4c, 0x27, 0x64, 0x2b, 0x08, 0x96, 0x45, 0x4e, 0x9c, 0xbc, 0x42, 0x5f,
+	0x1a, 0xc1, 0xf1, 0xa5, 0x11, 0xec, 0x7d, 0x85, 0x4e, 0x73, 0x2b, 0xb9, 0xa3, 0x04, 0xc7, 0x96,
+	0x46, 0x70, 0x7c, 0x69, 0x04, 0x7b, 0x5f, 0xa5, 0x53, 0x46, 0x2b, 0xa3, 0x91, 0x19, 0xbc, 0x3c,
+	0x62, 0x34, 0x2d, 0x67, 0x88, 0x9a, 0xf7, 0x35, 0x3a, 0x65, 0xac, 0x92, 0xa7, 0xd1, 0x2c, 0x2c,
+	0x04, 0xd2, 0xa7, 0xa8, 0x94, 0x27, 0x90, 0xab, 0x2c, 0x4d, 0x4c, 0xfb, 0x3a, 0x9d, 0x36, 0x55,
+	0x19, 0x3b, 0xca, 0xe7, 0x49, 0xcf, 0x61, 0xd5, 0x5c, 0x54, 0x99, 0x80, 0xb2, 0xf9, 0x0d, 0x3a,
+	0x2b, 0x53, 0x19, 0x5b, 0x9a, 0x5f, 0xc4, 0x8b, 0xc7, 0x55, 0x1a, 0xa0, 0x82, 0xc6, 0x57, 0x48,
+	0xb0, 0xf7, 0x4d, 0x3a, 0x29, 0x5f, 0xc9, 0xd3, 0xa0, 0xe2, 0x2b, 0x24, 0xd8, 0xb4, 0x42, 0x82,
+	0xbd, 0x6f, 0xd1, 0x69, 0xc5, 0xca, 0xd8, 0x51, 0x3e, 0x2f, 0xba, 0x42, 0x82, 0xdd, 0x2b, 0x54,
+	0x0a, 0x79, 0x65, 0xfd, 0x35, 0x3a, 0xcd, 0xa9, 0x14, 0xf8, 0x12, 0x7d, 0x72, 0x7c, 0xe9, 0xf8,
+	0x15, 0x0a, 0x97, 0xbc, 0xd4, 0x5e, 0xa9, 0x7d, 0x61, 0x50, 0x6b, 0x7f, 0x9d, 0x09, 0x8c, 0x4a,
+	0xf1, 0x5c, 0xa3, 0xd9, 0xec, 0x5c, 0x5e, 0x3a, 0x72, 0x67, 0x67, 0xbb, 0xb9, 0xf6, 0x92, 0x23,
+	0x48, 0xfd, 0xee, 0xa0, 0xfe, 0x2e, 0xab, 0xd4, 0x40, 0x01, 0xfe, 0x0d, 0x3a, 0x79, 0xa2, 0xe2,
+	0xad, 0x35, 0xea, 0x6b, 0xb7, 0x2c, 0x2d, 0x91, 0x5b, 0xfc, 0xe3, 0xc7, 0x6f, 0xf1, 0x4f, 0x90,
+	0x5b, 0x96, 0x8e, 0x9f, 0x58, 0x6d, 0x34, 0xd6, 0x15, 0xae, 0xa0, 0x38, 0xb7, 0xd1, 0x41, 0xe9,
+	0x43, 0xa9, 0xce, 0xbf, 0xe9, 0xa4, 0x2f, 0xcf, 0x95, 0xdc, 0xa9, 0x57, 0xbf, 0xa6, 0x7a, 0x2a,
+	0x90, 0x7c, 0xca, 0x32, 0xdd, 0x44, 0x33, 0xea, 0x16, 0x55, 0xea, 0xd9, 0xb7, 0x9d, 0x34, 0x05,
+	0x4d, 0x60, 0x1d, 0x54, 0x36, 0xb6, 0x2c, 0x6c, 0x2f, 0x43, 0x85, 0xed, 0xc6, 0xed, 0xbd, 0xcd,
+	0x6d, 0x51, 0x0a, 0x1e, 0xa3, 0x6a, 0x6d, 0x5f, 0x30, 0x21, 0x46, 0x59, 0x0d, 0x78, 0x39, 0x9a,
+	0x0c, 0xad, 0x20, 0x39, 0x1f, 0xa7, 0x66, 0xb9, 0x20, 0x9c, 0x0c, 0x99, 0x5f, 0x46, 0x53, 0xa1,
+	0x1d, 0x4f, 0xfc, 0x27, 0xa8, 0xe1, 0x74, 0x10, 0xce, 0xe7, 0x09, 0xaf, 0x5a, 0xf2, 0x7c, 0x7f,
+	0x92, 0x5a, 0x16, 0xa4, 0x25, 0x4f, 0xf4, 0x08, 0x36, 0xc1, 0xde, 0x53, 0xd4, 0x30, 0xab, 0x61,
+	0x13, 0x1c, 0xc3, 0x26, 0xd8, 0xfb, 0x20, 0x35, 0x74, 0x75, 0xec, 0x88, 0x25, 0x4f, 0xe8, 0x0f,
+	0x51, 0xcb, 0x51, 0x1d, 0x9b, 0x60, 0xf7, 0x32, 0x54, 0x0c, 0x2d, 0x45, 0x46, 0x7e, 0x98, 0x9a,
+	0x8e, 0x05, 0xa1, 0x0b, 0x91, 0xbf, 0x97, 0xa3, 0x69, 0x89, 0x2f, 0x8c, 0x3f, 0x42, 0x8d, 0xa7,
+	0x82, 0xd0, 0x4b, 0x98, 0xb4, 0x6a, 0x54, 0x90, 0xb3, 0x1f, 0xa5, 0xa6, 0x19, 0x19, 0x15, 0x64,
+	0x6a, 0x6c, 0x05, 0x04, 0x7b, 0x1f, 0xa3, 0x96, 0xf9, 0xc8, 0x0a, 0x08, 0x36, 0xac, 0x80, 0x60,
+	0xef, 0xe3, 0xd4, 0xb8, 0x18, 0x5d, 0x41, 0x84, 0x05, 0x9e, 0x93, 0x9f, 0xa0, 0xb6, 0x8e, 0x64,
+	0x81, 0xe7, 0xa0, 0xc6, 0x2c, 0xa4, 0xe0, 0x27, 0x41, 0xd3, 0x4b, 0x66, 0x21, 0xdf, 0xd4, 0xa8,
+	0x20, 0xdd, 0x3e, 0x45, 0x0d, 0x27, 0x64, 0x54, 0x90, 0x53, 0x0d, 0x74, 0x20, 0xb4, 0x53, 0x52,
+	0xea, 0xd3, 0xd4, 0x38, 0xb5, 0xe2, 0x11, 0x1e, 0x65, 0x2a, 0xb5, 0xd1, 0x4c, 0x04, 0x46, 0xf4,
+	0xec, 0xa7, 0x29, 0xd2, 0x30, 0x92, 0x47, 0x03, 0x13, 0x8d, 0xfb, 0x1c, 0x0a, 0xc7, 0x35, 0xc9,
+	0xf3, 0x0c, 0xa0, 0xa5, 0xd5, 0x3c, 0xc2, 0xa7, 0xa2, 0x79, 0xce, 0xa2, 0x43, 0xca, 0x66, 0x57,
+	0x6a, 0xc4, 0xb3, 0x40, 0xa1, 0xb5, 0xe8, 0x91, 0x29, 0x22, 0x6b, 0x43, 0x13, 0x79, 0x31, 0x10,
+	0x41, 0xe0, 0x73, 0x10, 0x52, 0x1a, 0xd5, 0x13, 0x81, 0x12, 0xe4, 0xad, 0xc8, 0x4a, 0x04, 0xac,
+	0x3d, 0x4f, 0x21, 0xec, 0x64, 0x4f, 0xc0, 0x1d, 0x70, 0xd9, 0xa3, 0xf9, 0x73, 0xaf, 0x42, 0xb3,
+	0x72, 0xc3, 0xeb, 0xfa, 0xe7, 0x9e, 0x2c, 0x2d, 0x7a, 0x5c, 0xff, 0x84, 0xcc, 0x5e, 0xa7, 0xe9,
+	0xa0, 0x53, 0x0a, 0x1b, 0x51, 0x41, 0xf4, 0x06, 0x3a, 0x5f, 0x0a, 0xa2, 0x99, 0x98, 0x07, 0x28,
+	0x8f, 0xcb, 0xe8, 0xb0, 0xc1, 0x05, 0x2f, 0x94, 0x6f, 0xa4, 0x3e, 0x42, 0x85, 0x34, 0x1b, 0x73,
+	0xc1, 0x0b, 0xe7, 0x29, 0xa3, 0x0f, 0x5e, 0x42, 0xdf, 0x44, 0x7d, 0x08, 0xc9, 0x14, 0x77, 0xc1,
+	0x2b, 0xea, 0xe9, 0xa4, 0x48, 0x08, 0xf6, 0xde, 0x4c, 0x3d, 0xe8, 0x1a, 0xca, 0x18, 0x0d, 0xc1,
+	0x03, 0xa2, 0x21, 0xd8, 0x7b, 0x0b, 0xf5, 0x13, 0x8a, 0x2a, 0x73, 0x34, 0x04, 0x0f, 0x88, 0x86,
+	0x60, 0xef, 0xad, 0xd4, 0x87, 0x50, 0x59, 0xe6, 0x68, 0x08, 0x76, 0x4f, 0xa3, 0x39, 0x83, 0x0b,
+	0x51, 0x80, 0xdf, 0x46, 0x7d, 0x48, 0xd9, 0xe5, 0xc5, 0xbc, 0x88, 0xf2, 0x5d, 0x45, 0x17, 0x99,
+	0xa2, 0x11, 0x7e, 0xde, 0x4e, 0xfd, 0x28, 0x3a, 0xec, 0x70, 0x3c, 0x22, 0x51, 0xda, 0x97, 0x8d,
+	0xf4, 0x42, 0x91, 0x7f, 0x07, 0x75, 0xa3, 0x08, 0xb3, 0x38, 0xb7, 0x50, 0xf6, 0x07, 0x04, 0x45,
+	0xb0, 0xf7, 0x4e, 0xea, 0x45, 0x2a, 0xb5, 0x84, 0xa0, 0x08, 0x1e, 0x18, 0x14, 0xc1, 0xde, 0xbb,
+	0xa8, 0x1f, 0x45, 0xba, 0x25, 0x05, 0x45, 0xb0, 0xfb, 0x2a, 0xe3, 0x17, 0xc5, 0xfb, 0x46, 0x9f,
+	0xfa, 0x89, 0x69, 0xb9, 0xf8, 0x37, 0xc6, 0xfb, 0xc9, 0x8d, 0xe6, 0x8d, 0x03, 0x9d, 0xe5, 0xdd,
+	0xd4, 0x97, 0x49, 0xdc, 0x19, 0xf6, 0x10, 0x34, 0x9d, 0x9b, 0x8d, 0x7c, 0x43, 0xfb, 0x79, 0x0f,
+	0xf5, 0x36, 0x48, 0xed, 0xc5, 0xbf, 0x00, 0xe8, 0x50, 0x77, 0xa3, 0x4b, 0x0c, 0x4e, 0x95, 0x5e,
+	0xf5, 0xde, 0x6c, 0xfa, 0x5e, 0x25, 0x24, 0xd9, 0x5c, 0x0c, 0x5c, 0xf6, 0xae, 0x9f, 0x46, 0x97,
+	0x1a, 0xb3, 0x4b, 0xa9, 0xf5, 0xf7, 0x66, 0xd3, 0xd4, 0x7a, 0x01, 0x7e, 0xb1, 0x21, 0x27, 0x23,
+	0xba, 0x70, 0xab, 0x51, 0x0f, 0x4b, 0xe4, 0x3f, 0x67, 0x4b, 0x59, 0xd0, 0x85, 0x30, 0x2a, 0x75,
+	0x21, 0xb7, 0x82, 0x0a, 0xf4, 0x2f, 0xd4, 0x8c, 0xe9, 0x42, 0x18, 0x56, 0x74, 0x21, 0xb7, 0xe3,
+	0xe5, 0xee, 0x5f, 0xa9, 0x21, 0xd3, 0x85, 0x30, 0xae, 0xea, 0x42, 0x6e, 0xc9, 0x8b, 0xda, 0xbf,
+	0x51, 0xcb, 0x82, 0xb4, 0x54, 0x75, 0xa1, 0xc4, 0x26, 0xd8, 0xfb, 0x77, 0x6a, 0x98, 0xd5, 0xb0,
+	0x85, 0xce, 0x51, 0xb0, 0x09, 0xf6, 0xfe, 0x83, 0x1a, 0xba, 0x3a, 0x76, 0xc4, 0x92, 0x97, 0xa0,
+	0xff, 0xa4, 0x96, 0xa3, 0x3a, 0xb6, 0xd0, 0x85, 0xdc, 0x52, 0x54, 0x88, 0xff, 0xa2, 0xa6, 0x4c,
+	0x17, 0xc2, 0x07, 0x9a, 0x2e, 0x14, 0xf8, 0xc2, 0xf8, 0xbf, 0xa9, 0x31, 0xd3, 0x85, 0x7c, 0x05,
+	0x9a, 0x2e, 0x14, 0x9e, 0x59, 0xc9, 0xf8, 0x1f, 0x6a, 0x9a, 0x91, 0x51, 0x29, 0xba, 0x50, 0x5d,
+	0x01, 0xc1, 0xde, 0xff, 0x52, 0xcb, 0x7c, 0x64, 0x05, 0x42, 0x17, 0x6a, 0x2b, 0x20, 0xd8, 0xfb,
+	0x3f, 0x6a, 0x5c, 0x8c, 0xae, 0x20, 0xc2, 0x02, 0xcf, 0xef, 0x0b, 0xa3, 0xa5, 0x2c, 0xe8, 0x42,
+	0x18, 0x57, 0x75, 0xa1, 0xf0, 0x0b, 0xd9, 0xfb, 0x33, 0xa3, 0xec, 0x6c, 0x57, 0x32, 0xab, 0xe8,
+	0x42, 0xb1, 0x9b, 0x58, 0x62, 0xbe, 0x9e, 0x1a, 0x4e, 0xc8, 0xa8, 0x14, 0x5d, 0xc8, 0xed, 0x94,
+	0x5c, 0xfb, 0x59, 0x6a, 0x3c, 0x84, 0x2e, 0x04, 0x8f, 0x11, 0x5d, 0xa8, 0xc1, 0x08, 0x59, 0xf3,
+	0x73, 0x14, 0x69, 0x38, 0x5d, 0xa8, 0x80, 0x69, 0xba, 0x90, 0xe3, 0xa9, 0xba, 0xf0, 0xe7, 0x01,
+	0x2d, 0xbd, 0x2e, 0x04, 0x9f, 0x51, 0x5d, 0x18, 0x6e, 0x76, 0xa5, 0x56, 0xfc, 0x02, 0x50, 0x98,
+	0x42, 0x17, 0x8a, 0x14, 0x89, 0xe8, 0xc2, 0x08, 0x88, 0x20, 0xf0, 0x17, 0x21, 0xa4, 0x74, 0xba,
+	0x50, 0x83, 0xd2, 0x74, 0x21, 0x7c, 0x02, 0xac, 0xfd, 0x12, 0x85, 0xb0, 0xd5, 0x85, 0xe0, 0x20,
+	0xd4, 0x85, 0x8a, 0x3f, 0xf7, 0x27, 0x51, 0xa1, 0x55, 0xdf, 0x62, 0x55, 0x0e, 0x4a, 0xdd, 0xb7,
+	0x21, 0x86, 0x1f, 0xb6, 0x00, 0xb8, 0xb1, 0xbe, 0x45, 0x0b, 0x22, 0xfd, 0xef, 0x74, 0xbb, 0xbb,
+	0x7d, 0x3e, 0xd8, 0xdf, 0x92, 0x23, 0xee, 0x59, 0x34, 0x19, 0x22, 0x40, 0x4d, 0xfb, 0x2d, 0x80,
+	0xb8, 0xd2, 0x1e, 0x82, 0x15, 0x54, 0xc0, 0x98, 0x68, 0x29, 0x43, 0xee, 0x3a, 0x9a, 0x0a, 0x41,
+	0x78, 0x8d, 0xfd, 0x6d, 0x40, 0xb9, 0xca, 0x1e, 0x05, 0xaa, 0x31, 0xc0, 0x14, 0x5a, 0xea, 0x98,
+	0x86, 0xc3, 0x2b, 0xf4, 0xef, 0xa4, 0xc6, 0x39, 0x63, 0xc0, 0xe1, 0xf5, 0x3d, 0x42, 0x1a, 0xc1,
+	0xde, 0xef, 0x0e, 0x43, 0x1a, 0xc1, 0x31, 0xd2, 0x08, 0x8e, 0x91, 0x46, 0xb0, 0xf7, 0x7b, 0x43,
+	0x91, 0x26, 0x60, 0x54, 0xd2, 0x22, 0x38, 0xbc, 0xb5, 0x7c, 0x67, 0x28, 0xd2, 0xa2, 0x38, 0xbc,
+	0x31, 0x6d, 0xa2, 0x62, 0x88, 0x23, 0x7a, 0xcd, 0xef, 0x03, 0xd0, 0xd5, 0xf6, 0x40, 0xbc, 0x85,
+	0x01, 0xd2, 0x64, 0x4b, 0x1b, 0x74, 0x9b, 0x68, 0x5a, 0x52, 0x27, 0xb0, 0xfe, 0x00, 0xb0, 0xae,
+	0x49, 0x41, 0xde, 0xba, 0x0a, 0x36, 0xd5, 0xd2, 0x47, 0xb5, 0xdd, 0x00, 0x7d, 0xf1, 0x0f, 0x53,
+	0xef, 0x06, 0xd6, 0x41, 0xf5, 0xdd, 0x00, 0x4d, 0x35, 0xc6, 0x1e, 0xc1, 0xde, 0x1f, 0x0d, 0xc7,
+	0x9e, 0xf8, 0x9e, 0x34, 0xf6, 0x08, 0x36, 0xb0, 0x47, 0xb0, 0xf7, 0xc7, 0x43, 0xb2, 0x27, 0xc0,
+	0x74, 0xf6, 0x22, 0xdb, 0x8f, 0xf7, 0xf4, 0x3f, 0x49, 0xbd, 0xfd, 0xa0, 0xfb, 0xeb, 0xdb, 0x8f,
+	0x2b, 0x02, 0x2d, 0x9d, 0x40, 0x11, 0xfc, 0x69, 0xfa, 0x74, 0x62, 0x0e, 0x22, 0xe9, 0x04, 0x7a,
+	0x42, 0xdd, 0x0d, 0xa0, 0x27, 0xfe, 0x2c, 0xf5, 0x6e, 0x60, 0xca, 0x43, 0xdf, 0x0d, 0x20, 0x46,
+	0xb6, 0xd0, 0x81, 0x10, 0x44, 0x11, 0x23, 0x7f, 0x0e, 0x48, 0xaf, 0xb0, 0x47, 0x0a, 0x05, 0x08,
+	0xa0, 0x15, 0x5b, 0x91, 0x61, 0xf7, 0x3c, 0x9a, 0x89, 0x20, 0x8a, 0xb6, 0xfa, 0x17, 0x00, 0x7a,
+	0x6d, 0x4a, 0x50, 0x3e, 0x06, 0xb8, 0x07, 0x5a, 0xf1, 0x4f, 0xdc, 0x1d, 0x74, 0x30, 0x84, 0x56,
+	0x25, 0xca, 0x5f, 0x02, 0xf0, 0x29, 0x7b, 0x60, 0xa9, 0x4a, 0x00, 0x76, 0xba, 0x15, 0x1d, 0x77,
+	0xef, 0x40, 0x87, 0x94, 0xea, 0xab, 0xa8, 0x95, 0xef, 0x02, 0xea, 0x72, 0x9a, 0x1a, 0x1c, 0xea,
+	0x14, 0x80, 0x75, 0x5b, 0xb1, 0x0f, 0xdc, 0xbb, 0x91, 0x17, 0xc3, 0x15, 0x4c, 0xff, 0x15, 0x40,
+	0x9f, 0x4e, 0x0d, 0xad, 0x71, 0x7d, 0xa8, 0x65, 0xfa, 0x4c, 0xec, 0x5f, 0xd6, 0xe8, 0x40, 0x73,
+	0xfc, 0x75, 0xaa, 0xfd, 0xcb, 0x3a, 0xbf, 0x14, 0x1d, 0x74, 0xff, 0x86, 0x43, 0x22, 0x19, 0x77,
+	0x14, 0x94, 0xbf, 0x49, 0x95, 0x8c, 0xd0, 0xf8, 0x25, 0x0c, 0x4d, 0x46, 0x39, 0x26, 0x70, 0x7a,
+	0x0a, 0xce, 0xdf, 0xa6, 0xc2, 0x39, 0x63, 0xc0, 0x91, 0x63, 0x0a, 0x69, 0x04, 0x03, 0xcc, 0xdf,
+	0xa5, 0x25, 0x8d, 0xe0, 0x18, 0x69, 0x30, 0xa4, 0x92, 0x26, 0x50, 0xfe, 0x3e, 0x35, 0x69, 0x2a,
+	0x8c, 0x20, 0x4d, 0xc7, 0xe9, 0x29, 0x38, 0xff, 0x90, 0x9a, 0xb4, 0x28, 0x8e, 0x1c, 0x13, 0x2d,
+	0x8d, 0xb7, 0x51, 0x00, 0xfa, 0xc7, 0x54, 0x2d, 0x8d, 0xf7, 0x7d, 0x89, 0x44, 0xbf, 0x0d, 0x65,
+	0x30, 0xa4, 0x8e, 0x95, 0x68, 0x40, 0xfa, 0xa7, 0x74, 0xd4, 0x31, 0x0f, 0x11, 0xea, 0xc2, 0x31,
+	0xb7, 0x84, 0x50, 0xa7, 0xdd, 0xe8, 0xac, 0x03, 0xc4, 0xd3, 0xb9, 0x92, 0x53, 0xde, 0x57, 0x1d,
+	0x09, 0xc6, 0xd9, 0x20, 0xb3, 0x38, 0x82, 0xf6, 0x83, 0x05, 0xc8, 0xd3, 0x67, 0xa8, 0x49, 0xae,
+	0x3a, 0x12, 0xc0, 0x3c, 0x90, 0xcb, 0x2f, 0x43, 0x13, 0x60, 0xc3, 0xb5, 0xf2, 0xb3, 0xd4, 0x68,
+	0xba, 0x3a, 0x12, 0xc0, 0x54, 0x2e, 0x76, 0x43, 0x2b, 0xae, 0x74, 0x9f, 0xa3, 0x56, 0x85, 0xd0,
+	0x8a, 0x4b, 0x55, 0x15, 0x8f, 0x60, 0xef, 0x79, 0x6a, 0x94, 0x55, 0xf1, 0x08, 0xd6, 0xf1, 0x08,
+	0xf6, 0x3e, 0x43, 0x8d, 0x5c, 0x0d, 0x4f, 0xb5, 0xe2, 0x22, 0xf1, 0xb3, 0xd4, 0x6a, 0x54, 0xc3,
+	0x23, 0xd8, 0x7d, 0x39, 0x2a, 0x80, 0x95, 0x90, 0x5d, 0x9f, 0xa3, 0x66, 0x63, 0xd5, 0x91, 0x00,
+	0x66, 0x0b, 0x89, 0x56, 0x46, 0x93, 0x1c, 0x53, 0x18, 0x7e, 0x9e, 0x1a, 0x4e, 0x55, 0x47, 0x02,
+	0x70, 0x10, 0xca, 0xab, 0x30, 0x02, 0xd0, 0x56, 0xbf, 0x4c, 0xcd, 0x32, 0x61, 0x04, 0xa0, 0x8e,
+	0x74, 0x54, 0x82, 0xbd, 0x5f, 0xa1, 0x56, 0x79, 0x1d, 0x95, 0x1d, 0x20, 0x68, 0xa8, 0x04, 0x7b,
+	0xbf, 0x4a, 0x0d, 0x8b, 0x11, 0x54, 0x35, 0x5a, 0xae, 0x49, 0x5e, 0xa0, 0x76, 0x4e, 0x18, 0x2d,
+	0x17, 0x15, 0x92, 0x39, 0x50, 0x14, 0x5f, 0xa0, 0x56, 0xe3, 0x92, 0x39, 0x90, 0x04, 0x61, 0x04,
+	0xa0, 0x07, 0xbe, 0x48, 0x8d, 0x26, 0xc2, 0x08, 0xa0, 0xa3, 0xd7, 0x51, 0x11, 0x6c, 0x94, 0x76,
+	0xfe, 0xa5, 0x5c, 0xfa, 0xc7, 0xb8, 0xd5, 0x91, 0x00, 0x42, 0x95, 0x2d, 0xfc, 0x56, 0x74, 0x40,
+	0x85, 0x10, 0x5d, 0xe5, 0xcb, 0xb9, 0xa1, 0x5e, 0xb1, 0xa9, 0x8e, 0x04, 0xd3, 0x12, 0x48, 0x74,
+	0x91, 0x35, 0x04, 0x83, 0x5a, 0xc3, 0xfe, 0x4a, 0x6e, 0x88, 0xf7, 0x6b, 0xaa, 0x23, 0xc1, 0x14,
+	0x73, 0xa9, 0x34, 0xe9, 0x15, 0xe4, 0x8a, 0x8d, 0xab, 0x74, 0xe8, 0xaf, 0xe6, 0xd2, 0x3c, 0x8b,
+	0xae, 0x8e, 0x04, 0x45, 0xbe, 0xdd, 0x65, 0x37, 0x3e, 0x87, 0x0e, 0xe9, 0x00, 0x82, 0xb4, 0xaf,
+	0xe5, 0x52, 0xbe, 0x59, 0x53, 0x1d, 0x09, 0x0e, 0xa8, 0x30, 0x82, 0xb0, 0x1f, 0xe3, 0x95, 0x03,
+	0x98, 0xfa, 0x7a, 0xce, 0xfa, 0x35, 0xc1, 0x9b, 0xe8, 0x6c, 0xc1, 0x94, 0xe2, 0x4b, 0xe6, 0x06,
+	0xec, 0xd1, 0x45, 0xef, 0x1b, 0x62, 0x93, 0x4e, 0x28, 0x9b, 0x74, 0x31, 0x6a, 0xe7, 0x7b, 0xdf,
+	0x34, 0xd9, 0xf9, 0x51, 0xbb, 0x25, 0xef, 0x5b, 0x26, 0xbb, 0x25, 0xf7, 0x0a, 0x74, 0x90, 0x67,
+	0x90, 0xfe, 0x40, 0xeb, 0xde, 0xbc, 0x7c, 0xa1, 0xa7, 0xea, 0x04, 0xf0, 0x0d, 0xea, 0xcf, 0xb3,
+	0xae, 0x12, 0xb4, 0x47, 0x1f, 0x66, 0xbd, 0x2f, 0xaf, 0xbe, 0xdd, 0x53, 0x75, 0x38, 0x97, 0x91,
+	0x67, 0x59, 0x57, 0xa3, 0x99, 0xe8, 0x74, 0x5e, 0x49, 0xef, 0xcb, 0x2b, 0xaf, 0xfa, 0x54, 0x9d,
+	0xe0, 0xa0, 0x3e, 0x9d, 0x57, 0xd6, 0xab, 0xe2, 0xf3, 0x79, 0x8d, 0xbd, 0x3f, 0x2f, 0xdf, 0xfb,
+	0x89, 0x4f, 0x3f, 0x23, 0x1e, 0x83, 0x99, 0x56, 0x4f, 0xb0, 0xf7, 0x40, 0x3e, 0xfa, 0x12, 0x90,
+	0x31, 0x02, 0x82, 0x93, 0x22, 0x20, 0xd8, 0x7b, 0x30, 0xaf, 0xbc, 0x11, 0x64, 0x8e, 0x80, 0xe0,
+	0xa4, 0x08, 0x08, 0xf6, 0x1e, 0xca, 0xcb, 0xd7, 0x83, 0xcc, 0x11, 0xb0, 0x47, 0x5f, 0xb3, 0xd1,
+	0xe9, 0xa2, 0x4a, 0x3f, 0x9c, 0x57, 0xdf, 0x15, 0xaa, 0x3a, 0xc1, 0x21, 0xdd, 0x83, 0xa8, 0xef,
+	0xd7, 0x21, 0x2f, 0x16, 0x81, 0xf0, 0xf1, 0x48, 0x5e, 0x7b, 0x71, 0xa8, 0xea, 0x04, 0x33, 0x91,
+	0x28, 0x44, 0xed, 0xbf, 0x3a, 0x4e, 0x25, 0x74, 0x81, 0xf7, 0xe7, 0xb5, 0xb7, 0x88, 0xe2, 0x3c,
+	0x42, 0x5f, 0x48, 0x0a, 0x84, 0x60, 0xef, 0x03, 0x79, 0xf5, 0x95, 0xa2, 0x84, 0x40, 0x08, 0x4e,
+	0x0e, 0x84, 0x60, 0xef, 0xd1, 0xbc, 0xf6, 0x7e, 0x51, 0x52, 0x20, 0x04, 0xbb, 0xd7, 0xc7, 0xbf,
+	0x10, 0xde, 0x58, 0x1e, 0xcb, 0x1b, 0x5e, 0x36, 0x8a, 0x7f, 0x33, 0xbc, 0xe1, 0xdc, 0x60, 0xd8,
+	0x18, 0xd0, 0x7a, 0x1e, 0xcf, 0x9b, 0xdf, 0x3c, 0x32, 0xec, 0x11, 0xe8, 0x4a, 0x37, 0xc5, 0xb9,
+	0x85, 0xfe, 0xf4, 0x44, 0x7e, 0xf0, 0x6b, 0x48, 0x71, 0xb2, 0xa1, 0x85, 0xbd, 0x16, 0xcd, 0x45,
+	0x1d, 0x2a, 0xcd, 0xec, 0xc9, 0xfc, 0xd0, 0xef, 0x24, 0x55, 0x9d, 0x60, 0x56, 0x07, 0x56, 0xff,
+	0x3e, 0xbd, 0x38, 0x9e, 0x31, 0x4a, 0x53, 0x78, 0x2a, 0x3f, 0xc4, 0x0b, 0x4a, 0x55, 0x27, 0x38,
+	0x1c, 0xcd, 0xb3, 0xd0, 0x66, 0xee, 0xa7, 0xd0, 0x84, 0xd6, 0xfb, 0x5e, 0xc4, 0x37, 0xcd, 0xe7,
+	0xee, 0x42, 0x48, 0xe9, 0x87, 0x2f, 0x26, 0xf2, 0x35, 0xa8, 0xa0, 0xbd, 0xc9, 0x69, 0x0b, 0x4e,
+	0x1d, 0x68, 0xef, 0x44, 0xa4, 0x73, 0xa0, 0x1c, 0x9e, 0x5b, 0x3b, 0xb8, 0x1a, 0x15, 0xa3, 0x87,
+	0xe3, 0x6e, 0x11, 0x65, 0x6f, 0x6b, 0x9c, 0x67, 0x4e, 0xf6, 0x05, 0xf4, 0x7f, 0xdd, 0x83, 0x28,
+	0x77, 0x47, 0xbd, 0xd9, 0x6b, 0x78, 0x19, 0x36, 0x06, 0xff, 0xa8, 0x64, 0x4e, 0x3a, 0x73, 0xd7,
+	0xa0, 0xe9, 0xd8, 0xc9, 0xf7, 0x6e, 0x0e, 0x72, 0xaa, 0x83, 0x57, 0x20, 0x37, 0x7e, 0xa8, 0xbd,
+	0x9b, 0x87, 0x69, 0xb3, 0x87, 0x33, 0x7b, 0xf7, 0x50, 0x48, 0x0c, 0x82, 0x9f, 0xd2, 0xed, 0xe6,
+	0x20, 0x9b, 0x1c, 0xc4, 0x1e, 0x3d, 0xb8, 0xc9, 0x41, 0xec, 0xd1, 0xc3, 0xa8, 0xea, 0xe1, 0x14,
+	0x3a, 0x60, 0x38, 0x17, 0xde, 0xcd, 0xc5, 0x98, 0xea, 0x62, 0x19, 0x1d, 0x34, 0x1d, 0xf7, 0xee,
+	0xe6, 0x63, 0xca, 0xcc, 0xa5, 0x3c, 0xc7, 0xdd, 0xcd, 0x41, 0x66, 0x40, 0x1c, 0x7b, 0xa4, 0x22,
+	0x3f, 0x28, 0x8e, 0x3d, 0xfa, 0x28, 0x9a, 0xbf, 0x10, 0xe5, 0x40, 0x75, 0x37, 0x0f, 0x4e, 0xc2,
+	0xa6, 0x90, 0x47, 0xa5, 0xbb, 0x79, 0x18, 0x37, 0x73, 0x29, 0x4f, 0x41, 0x77, 0x73, 0x30, 0xa1,
+	0x3a, 0x38, 0x8f, 0x0e, 0x19, 0x0f, 0x37, 0x0d, 0x4e, 0x5e, 0xa5, 0x3a, 0x49, 0xfb, 0x30, 0x57,
+	0x81, 0xbe, 0x1b, 0x79, 0x49, 0x47, 0x9c, 0x06, 0xf4, 0x1b, 0x55, 0xf4, 0x21, 0x1e, 0xf0, 0x2a,
+	0x0b, 0x78, 0x2d, 0x9a, 0x31, 0x1f, 0x75, 0x1a, 0xe0, 0x7f, 0x44, 0x87, 0x4f, 0xf9, 0xc4, 0x57,
+	0x01, 0xef, 0xa1, 0xd9, 0x84, 0x13, 0x4f, 0x03, 0xfa, 0x75, 0x3a, 0xf5, 0xb6, 0x0f, 0x81, 0xb5,
+	0x98, 0xe7, 0x92, 0x4f, 0x3b, 0x0d, 0xc8, 0xaf, 0xd4, 0xe3, 0x4e, 0xf1, 0x58, 0x38, 0xb6, 0x5b,
+	0xf5, 0x33, 0x4f, 0x15, 0x33, 0xb7, 0x5b, 0x2f, 0x81, 0x84, 0x89, 0x1c, 0x67, 0xaa, 0x1e, 0xa6,
+	0xf7, 0xe6, 0xe1, 0x4c, 0xb2, 0x87, 0xc2, 0xde, 0xfa, 0x99, 0x7e, 0x06, 0xa9, 0x3a, 0xc8, 0xee,
+	0x3d, 0x88, 0x04, 0x0f, 0xee, 0xde, 0x83, 0x48, 0xf0, 0x30, 0xba, 0x9b, 0x07, 0x28, 0xa1, 0xd1,
+	0x13, 0x41, 0xd5, 0xc5, 0xd8, 0x1e, 0xc3, 0xd0, 0x8f, 0xfa, 0x54, 0x0f, 0xe3, 0xbb, 0x79, 0xb8,
+	0x12, 0x21, 0xf9, 0xf7, 0xb8, 0xb5, 0x2e, 0xa9, 0xa2, 0x99, 0xd3, 0x77, 0x75, 0x1b, 0xed, 0x9d,
+	0xcd, 0x4e, 0x7b, 0x38, 0x8d, 0xa5, 0x7a, 0x1a, 0x4a, 0x2b, 0x1d, 0x99, 0x47, 0xe3, 0x52, 0x6c,
+	0x8f, 0x23, 0xd0, 0xc5, 0xc5, 0x11, 0xfa, 0xbf, 0xcb, 0xc1, 0xa9, 0x1f, 0xbd, 0xa9, 0xe8, 0xb8,
+	0xfb, 0xd1, 0xd8, 0xb5, 0xd5, 0x53, 0xc1, 0xab, 0x6f, 0x38, 0x5d, 0xcc, 0x5c, 0x36, 0xbe, 0xef,
+	0x9e, 0x5a, 0xf1, 0xc2, 0x85, 0x0b, 0x17, 0x32, 0xfe, 0x59, 0x34, 0xdb, 0x10, 0x8b, 0x58, 0xd1,
+	0xee, 0x2c, 0xba, 0x16, 0xa2, 0xd3, 0xbb, 0xa7, 0xc6, 0x58, 0x3e, 0xd4, 0x88, 0x52, 0x43, 0xbf,
+	0x22, 0xbf, 0x81, 0x3c, 0x03, 0x08, 0xfc, 0x41, 0x6e, 0x83, 0xf2, 0x86, 0x1a, 0xcb, 0xd6, 0x99,
+	0x18, 0x0a, 0xcb, 0x6d, 0x7f, 0x03, 0x1d, 0x36, 0xc0, 0xec, 0xd8, 0xe3, 0xbc, 0xb1, 0xc6, 0x72,
+	0x7a, 0x36, 0x86, 0x03, 0x25, 0x20, 0x01, 0xa8, 0x67, 0x0f, 0xf4, 0xa6, 0x1a, 0x4b, 0xfd, 0x38,
+	0x10, 0x54, 0x8a, 0x64, 0xe2, 0x08, 0xb6, 0xc2, 0x79, 0x73, 0x8d, 0x55, 0x08, 0x23, 0x71, 0x04,
+	0x0f, 0x20, 0xce, 0x12, 0xe7, 0x2d, 0x35, 0x56, 0x47, 0xcc, 0xc4, 0x25, 0x02, 0xf5, 0xec, 0x81,
+	0xde, 0x5a, 0x63, 0xe5, 0xc6, 0x4c, 0x1c, 0xc1, 0xfe, 0x26, 0x9a, 0x33, 0x00, 0x89, 0x93, 0x0b,
+	0x1b, 0xa4, 0xb7, 0xd5, 0x58, 0x55, 0xf2, 0x62, 0x48, 0xbc, 0x8a, 0xf9, 0xb7, 0xa1, 0x8b, 0x4c,
+	0xe4, 0xa5, 0xc1, 0x7a, 0x7b, 0x8d, 0x89, 0xd6, 0xc3, 0x71, 0xfa, 0xb8, 0xb7, 0x84, 0x0d, 0xb1,
+	0x0e, 0xaf, 0xf6, 0x59, 0x20, 0xbd, 0xa3, 0xc6, 0xd4, 0x6d, 0x7c, 0x43, 0x30, 0x6d, 0x3c, 0x88,
+	0x3e, 0xcb, 0x2f, 0xea, 0x9d, 0x35, 0xa6, 0x81, 0x13, 0xe8, 0x23, 0x78, 0x20, 0x7d, 0x96, 0x58,
+	0xef, 0xaa, 0x31, 0xad, 0x9c, 0x44, 0x5f, 0xe2, 0xfe, 0x83, 0xc3, 0x1e, 0x2b, 0xa8, 0x7e, 0x8d,
+	0x89, 0xea, 0xf8, 0xfe, 0x03, 0x4d, 0x9e, 0x94, 0x51, 0x70, 0xb8, 0x63, 0x03, 0xf4, 0xee, 0x1a,
+	0xeb, 0x02, 0x86, 0x8c, 0x82, 0x13, 0x5f, 0xf3, 0x86, 0x60, 0x67, 0x45, 0x56, 0x38, 0xef, 0xa9,
+	0x31, 0x89, 0x1e, 0xdf, 0x10, 0x4c, 0xe0, 0xfb, 0x0f, 0x38, 0xe8, 0x12, 0x03, 0x8e, 0x3c, 0x42,
+	0xb2, 0x02, 0x7b, 0x6f, 0x6d, 0x08, 0x29, 0x3f, 0x17, 0x5b, 0x62, 0xf8, 0x99, 0xff, 0xb8, 0x83,
+	0x4a, 0x89, 0xcb, 0xe4, 0x8f, 0x07, 0xac, 0x56, 0x7a, 0x6f, 0x6d, 0x38, 0xd9, 0x7f, 0x89, 0x79,
+	0xb1, 0xfc, 0x63, 0xff, 0x61, 0x07, 0x7d, 0x9f, 0x61, 0xbd, 0xca, 0x73, 0x19, 0xab, 0xd5, 0xbe,
+	0xaf, 0x36, 0xcc, 0x5f, 0x09, 0x17, 0xc5, 0xd6, 0x2a, 0x3f, 0xf4, 0xef, 0x73, 0xd0, 0xa5, 0xc6,
+	0x1e, 0x21, 0x8f, 0xf1, 0xac, 0x96, 0x7a, 0x5f, 0x2d, 0xd5, 0x9f, 0x14, 0x17, 0x1b, 0x3a, 0x4b,
+	0xf8, 0xa9, 0xff, 0xa8, 0x83, 0x8e, 0x0c, 0x58, 0x64, 0x9a, 0x0d, 0x70, 0x7f, 0x2d, 0xed, 0x1f,
+	0x20, 0x97, 0x26, 0x2d, 0x55, 0x7c, 0xf9, 0x0f, 0x39, 0x48, 0xa6, 0x9b, 0x7e, 0xd3, 0xda, 0x66,
+	0x85, 0x0f, 0xd4, 0xd8, 0xe3, 0x28, 0x9b, 0x37, 0x6d, 0xcc, 0x02, 0x36, 0x48, 0x58, 0x8d, 0xdf,
+	0x54, 0x6b, 0x8c, 0xfe, 0xc0, 0xc8, 0x2e, 0x99, 0xfa, 0xea, 0x75, 0x71, 0x89, 0xa6, 0x3d, 0x5f,
+	0xf2, 0xb7, 0xd4, 0xd2, 0x19, 0x79, 0xc6, 0x64, 0x97, 0x0d, 0x7d, 0xfd, 0xba, 0xf9, 0x6c, 0x1c,
+	0x10, 0x74, 0xe3, 0xed, 0x6a, 0xb7, 0x8b, 0x3e, 0x96, 0xb2, 0xdb, 0xd5, 0x7d, 0xed, 0xba, 0xba,
+	0x17, 0x47, 0xe4, 0x0a, 0x72, 0xcb, 0x0c, 0x99, 0x42, 0x42, 0xde, 0xdf, 0x57, 0xaf, 0xbb, 0x1b,
+	0x10, 0xb9, 0x94, 0xec, 0x26, 0xd2, 0x6a, 0xd9, 0x65, 0x1f, 0xe8, 0xc7, 0xaf, 0xcb, 0x9b, 0xa9,
+	0x25, 0x78, 0x10, 0xb5, 0x96, 0xb0, 0x0f, 0xf6, 0xb5, 0xeb, 0xf6, 0x09, 0xd4, 0x12, 0x3c, 0x88,
+	0x5a, 0x4b, 0xc8, 0x87, 0xfa, 0xea, 0x75, 0xfd, 0x04, 0x6a, 0x09, 0xf6, 0xbb, 0xaa, 0x84, 0x89,
+	0x3d, 0x95, 0xb3, 0x82, 0x7c, 0xb8, 0xaf, 0x5f, 0xf7, 0x3f, 0x1c, 0x07, 0x15, 0xba, 0xf3, 0x4e,
+	0x74, 0xb1, 0x91, 0xda, 0x34, 0xb0, 0x8f, 0xf4, 0x23, 0x3f, 0x17, 0x30, 0x67, 0xa0, 0x57, 0x68,
+	0xd0, 0xdb, 0xcd, 0x3b, 0xc9, 0x5e, 0x84, 0xbe, 0xbf, 0x1f, 0xf9, 0xb9, 0x01, 0xc3, 0x36, 0x02,
+	0x3d, 0x3a, 0x88, 0x61, 0xcb, 0x2f, 0xf5, 0x03, 0x7d, 0xfd, 0xe7, 0x0a, 0x92, 0x18, 0x26, 0x78,
+	0x30, 0xc3, 0x96, 0xb0, 0x8f, 0xf6, 0x23, 0x3f, 0x77, 0x90, 0xc8, 0x30, 0xc1, 0xfe, 0x79, 0xf3,
+	0x16, 0x4e, 0xa1, 0x53, 0x1f, 0xeb, 0x1b, 0x7f, 0x2e, 0xc1, 0xb0, 0x97, 0xb9, 0x70, 0x7d, 0x5d,
+	0x42, 0xc2, 0xda, 0x2b, 0xd7, 0xc7, 0xfb, 0x49, 0x3f, 0xb7, 0x60, 0xca, 0x5d, 0x50, 0xb3, 0xaf,
+	0x77, 0xcc, 0x7b, 0xcb, 0x5e, 0xcf, 0x3e, 0xd1, 0xdf, 0xed, 0xf7, 0x1a, 0x0c, 0x9b, 0x0d, 0xb4,
+	0xee, 0x13, 0x9a, 0x28, 0x33, 0x3d, 0x2f, 0xb5, 0x5a, 0xc9, 0x93, 0xfd, 0xef, 0xc1, 0x0f, 0x3e,
+	0x5c, 0x14, 0x5f, 0xac, 0x54, 0xbd, 0x8f, 0x69, 0xaa, 0xd7, 0xfc, 0x8c, 0xd5, 0x6a, 0xc9, 0x4f,
+	0xf5, 0x87, 0xfa, 0xc5, 0x88, 0x4b, 0x4c, 0xb5, 0x59, 0xaa, 0xb4, 0x35, 0xf5, 0xc8, 0x49, 0xbb,
+	0x2c, 0x68, 0xb7, 0xc8, 0xef, 0x3a, 0xec, 0x66, 0xa1, 0x3c, 0x73, 0x0a, 0x94, 0x2b, 0x86, 0xfe,
+	0xba, 0x2a, 0x5a, 0xf4, 0xcb, 0x86, 0x56, 0x30, 0x1f, 0x64, 0x30, 0xea, 0xa1, 0x53, 0xa0, 0x5e,
+	0x51, 0xf4, 0xcf, 0xa9, 0x3b, 0x36, 0x72, 0x59, 0xd1, 0x0a, 0xe8, 0x43, 0x0c, 0x48, 0x3d, 0x75,
+	0x0a, 0xb4, 0x2b, 0x8e, 0x09, 0x48, 0x29, 0x24, 0xc3, 0x87, 0x19, 0x52, 0xc1, 0x80, 0xc4, 0xb5,
+	0x42, 0x22, 0x77, 0x96, 0x45, 0xef, 0x23, 0x0c, 0x28, 0x6b, 0xe6, 0x8e, 0xe0, 0x01, 0xdc, 0x59,
+	0x02, 0x7d, 0x94, 0x01, 0xb9, 0x09, 0xdc, 0x25, 0x22, 0xa5, 0xd0, 0x04, 0x1f, 0x63, 0x48, 0xa3,
+	0x09, 0xdc, 0x11, 0xec, 0xdf, 0xaa, 0x16, 0xd0, 0xe8, 0x65, 0x4f, 0x2b, 0xa8, 0x8f, 0x33, 0x28,
+	0xf5, 0xe8, 0x29, 0xd0, 0xaf, 0x88, 0xfa, 0x4d, 0xb5, 0x2d, 0xc6, 0x2e, 0x8b, 0x5a, 0x81, 0x7d,
+	0x82, 0x81, 0xa9, 0x67, 0x4f, 0x41, 0xe4, 0x8a, 0x69, 0xc2, 0xae, 0xb0, 0x6f, 0xfb, 0x9f, 0x64,
+	0x50, 0x19, 0xc3, 0xae, 0x80, 0x66, 0x3f, 0x80, 0x41, 0xcb, 0x2f, 0xeb, 0x53, 0x0c, 0x29, 0x9f,
+	0xc4, 0x20, 0xc1, 0x03, 0x19, 0xb4, 0x04, 0xfb, 0x34, 0x03, 0x2b, 0x26, 0x32, 0x98, 0xb8, 0x0b,
+	0x53, 0xb4, 0xf5, 0xa7, 0x19, 0x96, 0x63, 0xd8, 0x85, 0xbc, 0x8d, 0x27, 0x64, 0x96, 0x7d, 0x17,
+	0x7f, 0x86, 0x21, 0x8d, 0x9b, 0x32, 0x0b, 0x5a, 0xb6, 0x79, 0x57, 0xd8, 0x37, 0xec, 0x67, 0x19,
+	0xd0, 0x84, 0x61, 0x57, 0x40, 0x57, 0x7e, 0x50, 0x3b, 0x81, 0x32, 0xdc, 0xf6, 0xb5, 0x42, 0x7b,
+	0x8e, 0xa1, 0x0d, 0x7f, 0x04, 0x15, 0x44, 0xef, 0x08, 0x53, 0xf5, 0x50, 0x4a, 0x5c, 0x67, 0x9a,
+	0x13, 0x88, 0xe7, 0xd9, 0x52, 0xbf, 0x27, 0x67, 0x50, 0x81, 0xe1, 0x92, 0xb1, 0xff, 0x88, 0x26,
+	0x77, 0x4c, 0xf7, 0x8d, 0xad, 0x96, 0xfb, 0x19, 0xbe, 0xdc, 0xa1, 0x0f, 0xa1, 0x82, 0xd8, 0x2d,
+	0x65, 0xff, 0x7e, 0xed, 0x10, 0xca, 0x78, 0x61, 0xd9, 0x6a, 0xad, 0x9f, 0xe5, 0xbb, 0x20, 0xfd,
+	0x29, 0x54, 0x10, 0xbf, 0xe6, 0x4c, 0xe5, 0xd8, 0x91, 0x01, 0xab, 0x4c, 0xb3, 0x07, 0x3e, 0xc7,
+	0x49, 0x1d, 0xea, 0x18, 0x2a, 0x30, 0xde, 0x93, 0xf6, 0x1f, 0x56, 0x8f, 0xa1, 0xf4, 0x1b, 0xce,
+	0x36, 0x4b, 0xfc, 0x3c, 0x5b, 0x62, 0xca, 0x73, 0x28, 0xfd, 0x9e, 0x75, 0xc2, 0x72, 0x96, 0x0b,
+	0xe2, 0x55, 0xfd, 0x5e, 0x7b, 0xb3, 0xd3, 0x5e, 0x9e, 0x8d, 0xbf, 0x23, 0xc9, 0x3e, 0xb8, 0x6c,
+	0x11, 0xed, 0x57, 0xdf, 0x13, 0x37, 0x3d, 0x10, 0x45, 0xee, 0x84, 0x7c, 0x20, 0xfa, 0x82, 0xb3,
+	0xfc, 0x9a, 0x1f, 0xaf, 0xc5, 0x96, 0x7d, 0x8c, 0x2d, 0x7b, 0xb5, 0xb7, 0x7e, 0x6c, 0xb3, 0xdd,
+	0x6d, 0x6c, 0xb7, 0xeb, 0x4d, 0xf6, 0x3b, 0xb7, 0x6c, 0x74, 0xe7, 0x58, 0xb3, 0xb1, 0x51, 0x3f,
+	0x7b, 0xfe, 0x58, 0xd2, 0x4f, 0xe2, 0xfe, 0x7f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe2, 0xf2, 0x23,
+	0x9e, 0x2d, 0x57, 0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20180814_aa810b61/test.proto b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20180814_aa810b61/test.proto
new file mode 100644
index 000000000..b64ba1f1e
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20180814_aa810b61/test.proto
@@ -0,0 +1,333 @@
+// 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.
+
+syntax = "proto2";
+
+package google.golang.org.proto2_20180814;
+option go_package = "google.golang.org/protobuf/internal/testprotos/legacy/proto2_20180814_aa810b61";
+
+enum SiblingEnum {
+	ALPHA   = 0;
+	BRAVO   = 10;
+	CHARLIE = 200;
+}
+
+message SiblingMessage {
+	optional string  f1 = 1;
+	required string  f2 = 2;
+	repeated string  f3 = 3;
+	optional Message f4 = 4;
+}
+
+message Message {
+	enum ChildEnum {
+		ALPHA   = 0;
+		BRAVO   = 1;
+		CHARLIE = 2;
+	}
+	message ChildMessage {
+		optional string  f1 = 1;
+		required string  f2 = 2;
+		repeated string  f3 = 3;
+	    optional Message f4 = 4;
+	}
+	optional group NamedGroup = 1 {
+		optional string  f1 = 1;
+		required string  f2 = 2;
+		repeated string  f3 = 3;
+	    optional Message f4 = 4;
+	}
+
+	// Optional fields.
+	optional bool     optional_bool     = 100;
+	optional int32    optional_int32    = 101;
+	optional sint32   optional_sint32   = 102;
+	optional uint32   optional_uint32   = 103;
+	optional int64    optional_int64    = 104;
+	optional sint64   optional_sint64   = 105;
+	optional uint64   optional_uint64   = 106;
+	optional fixed32  optional_fixed32  = 107;
+	optional sfixed32 optional_sfixed32 = 108;
+	optional float    optional_float    = 109;
+	optional fixed64  optional_fixed64  = 110;
+	optional sfixed64 optional_sfixed64 = 111;
+	optional double   optional_double   = 112;
+	optional string   optional_string   = 113;
+	optional bytes    optional_bytes    = 114;
+
+	optional ChildEnum      optional_child_enum      = 115;
+	optional ChildMessage   optional_child_message   = 116;
+	optional NamedGroup     optional_named_group     = 117;
+	optional SiblingEnum    optional_sibling_enum    = 118;
+	optional SiblingMessage optional_sibling_message = 119;
+	optional group OptionalGroup = 120 {
+		optional string f1 = 1;
+		required string f2 = 2;
+		repeated string f3 = 3;
+	}
+
+	// Optional default fields.
+	optional bool      defaulted_bool     = 200 [default = true];
+	optional int32     defaulted_int32    = 201 [default = -12345];
+	optional sint32    defaulted_sint32   = 202 [default = -3200];
+	optional uint32    defaulted_uint32   = 203 [default = 3200];
+	optional int64     defaulted_int64    = 204 [default = -123456789];
+	optional sint64    defaulted_sint64   = 205 [default = -6400];
+	optional uint64    defaulted_uint64   = 206 [default = 6400];
+	optional fixed32   defaulted_fixed32  = 207 [default = 320000];
+	optional sfixed32  defaulted_sfixed32 = 208 [default = -320000];
+	optional float     defaulted_float    = 209 [default = 3.14159];
+	optional fixed64   defaulted_fixed64  = 210 [default = 640000];
+	optional sfixed64  defaulted_sfixed64 = 211 [default = -640000];
+	optional double    defaulted_double   = 212 [default = 3.14159265359];
+	optional string    defaulted_string   = 213 [default = "hello, \"world!\"\n"];
+	optional bytes     defaulted_bytes    = 214 [default = "dead\xde\xad\xbe\xefbeef"];
+
+	optional ChildEnum   defaulted_child_enum   = 215 [default = ALPHA];
+	optional SiblingEnum defaulted_sibling_enum = 216 [default = ALPHA];
+
+	// Required fields.
+	required bool     required_bool     = 300;
+	required int32    required_int32    = 301;
+	required sint32   required_sint32   = 302;
+	required uint32   required_uint32   = 303;
+	required int64    required_int64    = 304;
+	required sint64   required_sint64   = 305;
+	required uint64   required_uint64   = 306;
+	required fixed32  required_fixed32  = 307;
+	required sfixed32 required_sfixed32 = 308;
+	required float    required_float    = 309;
+	required fixed64  required_fixed64  = 310;
+	required sfixed64 required_sfixed64 = 311;
+	required double   required_double   = 312;
+	required string   required_string   = 313;
+	required bytes    required_bytes    = 314;
+
+	required ChildEnum      required_child_enum      = 315;
+	required ChildMessage   required_child_message   = 316;
+	required NamedGroup     required_named_group     = 317;
+	required SiblingEnum    required_sibling_enum    = 318;
+	required SiblingMessage required_sibling_message = 319;
+	required group RequiredGroup = 320 {
+		optional string f1 = 1;
+		required string f2 = 2;
+		repeated string f3 = 3;
+	}
+	// Required default fields.
+	required bool      required_defaulted_bool     = 400 [default = true];
+	required int32     required_defaulted_int32    = 401 [default = -12345];
+	required sint32    required_defaulted_sint32   = 402 [default = -3200];
+	required uint32    required_defaulted_uint32   = 403 [default = 3200];
+	required int64     required_defaulted_int64    = 404 [default = -123456789];
+	required sint64    required_defaulted_sint64   = 405 [default = -6400];
+	required uint64    required_defaulted_uint64   = 406 [default = 6400];
+	required fixed32   required_defaulted_fixed32  = 407 [default = 320000];
+	required sfixed32  required_defaulted_sfixed32 = 408 [default = -320000];
+	required float     required_defaulted_float    = 409 [default = 3.14159];
+	required fixed64   required_defaulted_fixed64  = 410 [default = 640000];
+	required sfixed64  required_defaulted_sfixed64 = 411 [default = -640000];
+	required double    required_defaulted_double   = 412 [default = 3.14159265359];
+	required string    required_defaulted_string   = 413 [default = "hello, \"world!\"\n"];
+	required bytes     required_defaulted_bytes    = 414 [default = "dead\xde\xad\xbe\xefbeef"];
+
+	required ChildEnum   required_defaulted_child_enum   = 415 [default = ALPHA];
+	required SiblingEnum required_defaulted_sibling_enum = 416 [default = ALPHA];
+
+	// Repeated fields.
+	repeated bool     repeated_bool     = 500;
+	repeated int32    repeated_int32    = 501;
+	repeated sint32   repeated_sint32   = 502;
+	repeated uint32   repeated_uint32   = 503;
+	repeated int64    repeated_int64    = 504;
+	repeated sint64   repeated_sint64   = 505;
+	repeated uint64   repeated_uint64   = 506;
+	repeated fixed32  repeated_fixed32  = 507;
+	repeated sfixed32 repeated_sfixed32 = 508;
+	repeated float    repeated_float    = 509;
+	repeated fixed64  repeated_fixed64  = 510;
+	repeated sfixed64 repeated_sfixed64 = 511;
+	repeated double   repeated_double   = 512;
+	repeated string   repeated_string   = 513;
+	repeated bytes    repeated_bytes    = 514;
+
+	repeated ChildEnum      repeated_child_enum      = 515;
+	repeated ChildMessage   repeated_child_message   = 516;
+	repeated NamedGroup     repeated_named_group     = 517;
+	repeated SiblingEnum    repeated_sibling_enum    = 518;
+	repeated SiblingMessage repeated_sibling_message = 519;
+	repeated group RepeatedGroup = 520 {
+		optional string f1 = 1;
+		required string f2 = 2;
+		repeated string f3 = 3;
+	}
+
+	// Map fields.
+	map<bool, bool>     map_bool_bool     = 600;
+	map<bool, int32>    map_bool_int32    = 601;
+	map<bool, sint32>   map_bool_sint32   = 602;
+	map<bool, uint32>   map_bool_uint32   = 603;
+	map<bool, int64>    map_bool_int64    = 604;
+	map<bool, sint64>   map_bool_sint64   = 605;
+	map<bool, uint64>   map_bool_uint64   = 606;
+	map<bool, fixed32>  map_bool_fixed32  = 607;
+	map<bool, sfixed32> map_bool_sfixed32 = 608;
+	map<bool, float>    map_bool_float    = 609;
+	map<bool, fixed64>  map_bool_fixed64  = 610;
+	map<bool, sfixed64> map_bool_sfixed64 = 611;
+	map<bool, double>   map_bool_double   = 612;
+	map<bool, string>   map_bool_string   = 613;
+	map<bool, bytes>    map_bool_bytes    = 614;
+
+	map<bool, ChildEnum>      map_bool_child_enum      = 615;
+	map<bool, ChildMessage>   map_bool_child_message   = 616;
+	map<bool, NamedGroup>     map_bool_named_group     = 617;
+	map<bool, SiblingEnum>    map_bool_sibling_enum    = 618;
+	map<bool, SiblingMessage> map_bool_sibling_message = 619;
+
+	map<int32, bool>   map_int32_bool   = 620;
+	map<sint32, bool>  map_sint32_bool  = 621;
+	map<uint32, bool>  map_uint32_bool  = 622;
+	map<int64, bool>   map_int64_bool   = 623;
+	map<sint64, bool>  map_sint64_bool  = 624;
+	map<uint64, bool>  map_uint64_bool  = 625;
+	map<fixed32, bool> map_fixed32_bool = 626;
+	map<string, bool>  map_string_bool  = 627;
+
+	// Oneof fields.
+	oneof oneof_union {
+		bool     oneof_bool     = 700;
+		int32    oneof_int32    = 701;
+		sint32   oneof_sint32   = 702;
+		uint32   oneof_uint32   = 703;
+		int64    oneof_int64    = 704;
+		sint64   oneof_sint64   = 705;
+		uint64   oneof_uint64   = 706;
+		fixed32  oneof_fixed32  = 707;
+		sfixed32 oneof_sfixed32 = 708;
+		float    oneof_float    = 709;
+		fixed64  oneof_fixed64  = 710;
+		sfixed64 oneof_sfixed64 = 711;
+		double   oneof_double   = 712;
+		string   oneof_string   = 713;
+		bytes    oneof_bytes    = 714;
+
+		ChildEnum      oneof_child_enum      = 715;
+		ChildMessage   oneof_child_message   = 716;
+		NamedGroup     oneof_named_group     = 717;
+		SiblingEnum    oneof_sibling_enum    = 718;
+		SiblingMessage oneof_sibling_message = 719;
+		group OneofGroup = 720 {
+			optional string f1 = 1;
+			required string f2 = 2;
+			repeated string f3 = 3;
+		}
+
+		string oneof_string1 = 721;
+		string oneof_string2 = 722;
+		string oneof_string3 = 723;
+	}
+
+	// Oneof default fields.
+	oneof oneof_defaulted_union {
+		bool      oneof_defaulted_bool     = 800 [default = true];
+		int32     oneof_defaulted_int32    = 801 [default = -12345];
+		sint32    oneof_defaulted_sint32   = 802 [default = -3200];
+		uint32    oneof_defaulted_uint32   = 803 [default = 3200];
+		int64     oneof_defaulted_int64    = 804 [default = -123456789];
+		sint64    oneof_defaulted_sint64   = 805 [default = -6400];
+		uint64    oneof_defaulted_uint64   = 806 [default = 6400];
+		fixed32   oneof_defaulted_fixed32  = 807 [default = 320000];
+		sfixed32  oneof_defaulted_sfixed32 = 808 [default = -320000];
+		float     oneof_defaulted_float    = 809 [default = 3.14159];
+		fixed64   oneof_defaulted_fixed64  = 810 [default = 640000];
+		sfixed64  oneof_defaulted_sfixed64 = 811 [default = -640000];
+		double    oneof_defaulted_double   = 812 [default = 3.14159265359];
+		string    oneof_defaulted_string   = 813 [default = "hello, \"world!\"\n"];
+		bytes     oneof_defaulted_bytes    = 814 [default = "dead\xde\xad\xbe\xefbeef"];
+
+		ChildEnum   oneof_defaulted_child_enum   = 815 [default = ALPHA];
+		SiblingEnum oneof_defaulted_sibling_enum = 816 [default = ALPHA];
+	}
+
+	// Extension fields.
+	extend Message {
+		// Optional fields.
+		optional bool     extension_optional_bool     = 10000;
+		optional int32    extension_optional_int32    = 10001;
+		optional sint32   extension_optional_sint32   = 10002;
+		optional uint32   extension_optional_uint32   = 10003;
+		optional int64    extension_optional_int64    = 10004;
+		optional sint64   extension_optional_sint64   = 10005;
+		optional uint64   extension_optional_uint64   = 10006;
+		optional fixed32  extension_optional_fixed32  = 10007;
+		optional sfixed32 extension_optional_sfixed32 = 10008;
+		optional float    extension_optional_float    = 10009;
+		optional fixed64  extension_optional_fixed64  = 10010;
+		optional sfixed64 extension_optional_sfixed64 = 10011;
+		optional double   extension_optional_double   = 10012;
+		optional string   extension_optional_string   = 10013;
+		optional bytes    extension_optional_bytes    = 10014;
+
+		optional ChildEnum      extension_optional_child_enum      = 10015;
+		optional ChildMessage   extension_optional_child_message   = 10016;
+		optional NamedGroup     extension_optional_named_group     = 10017;
+		optional SiblingEnum    extension_optional_sibling_enum    = 10018;
+		optional SiblingMessage extension_optional_sibling_message = 10019;
+		optional group ExtensionOptionalGroup = 10020 {
+			optional string f1 = 1;
+			required string f2 = 2;
+			repeated string f3 = 3;
+		}
+
+		// Optional default fields.
+		optional bool      extension_defaulted_bool     = 20000 [default = true];
+		optional int32     extension_defaulted_int32    = 20001 [default = -12345];
+		optional sint32    extension_defaulted_sint32   = 20002 [default = -3200];
+		optional uint32    extension_defaulted_uint32   = 20003 [default = 3200];
+		optional int64     extension_defaulted_int64    = 20004 [default = -123456789];
+		optional sint64    extension_defaulted_sint64   = 20005 [default = -6400];
+		optional uint64    extension_defaulted_uint64   = 20006 [default = 6400];
+		optional fixed32   extension_defaulted_fixed32  = 20007 [default = 320000];
+		optional sfixed32  extension_defaulted_sfixed32 = 20008 [default = -320000];
+		optional float     extension_defaulted_float    = 20009 [default = 3.14159];
+		optional fixed64   extension_defaulted_fixed64  = 20010 [default = 640000];
+		optional sfixed64  extension_defaulted_sfixed64 = 20011 [default = -640000];
+		optional double    extension_defaulted_double   = 20012 [default = 3.14159265359];
+		optional string    extension_defaulted_string   = 20013 [default = "hello, \"world!\"\n"];
+		optional bytes     extension_defaulted_bytes    = 20014 [default = "dead\xde\xad\xbe\xefbeef"];
+
+		optional ChildEnum   extension_defaulted_child_enum   = 20015 [default = ALPHA];
+		optional SiblingEnum extension_defaulted_sibling_enum = 20016 [default = ALPHA];
+
+		// Repeated fields.
+		repeated bool     extension_repeated_bool     = 30000;
+		repeated int32    extension_repeated_int32    = 30001;
+		repeated sint32   extension_repeated_sint32   = 30002;
+		repeated uint32   extension_repeated_uint32   = 30003;
+		repeated int64    extension_repeated_int64    = 30004;
+		repeated sint64   extension_repeated_sint64   = 30005;
+		repeated uint64   extension_repeated_uint64   = 30006;
+		repeated fixed32  extension_repeated_fixed32  = 30007;
+		repeated sfixed32 extension_repeated_sfixed32 = 30008;
+		repeated float    extension_repeated_float    = 30009;
+		repeated fixed64  extension_repeated_fixed64  = 30010;
+		repeated sfixed64 extension_repeated_sfixed64 = 30011;
+		repeated double   extension_repeated_double   = 30012;
+		repeated string   extension_repeated_string   = 30013;
+		repeated bytes    extension_repeated_bytes    = 30014;
+
+		repeated ChildEnum      extension_repeated_child_enum      = 30015;
+		repeated ChildMessage   extension_repeated_child_message   = 30016;
+		repeated NamedGroup     extension_repeated_named_group     = 30017;
+		repeated SiblingEnum    extension_repeated_sibling_enum    = 30018;
+		repeated SiblingMessage extension_repeated_sibling_message = 30019;
+		repeated group ExtensionRepeatedGroup = 30020 {
+			optional string f1 = 1;
+			required string f2 = 2;
+			repeated string f3 = 3;
+		}
+	}
+
+	extensions 10000 to max;
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20190205_c823c79e/test.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20190205_c823c79e/test.pb.go
new file mode 100644
index 000000000..38a43bc2b
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20190205_c823c79e/test.pb.go
@@ -0,0 +1,3315 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: proto2_20190205_c823c79e/test.proto
+
+package proto2_20190205_c823c79e
+
+import (
+	fmt "fmt"
+	math "math"
+
+	proto "google.golang.org/protobuf/internal/protolegacy"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
+
+type SiblingEnum int32
+
+const (
+	SiblingEnum_ALPHA   SiblingEnum = 0
+	SiblingEnum_BRAVO   SiblingEnum = 10
+	SiblingEnum_CHARLIE SiblingEnum = 200
+)
+
+var SiblingEnum_name = map[int32]string{
+	0:   "ALPHA",
+	10:  "BRAVO",
+	200: "CHARLIE",
+}
+
+var SiblingEnum_value = map[string]int32{
+	"ALPHA":   0,
+	"BRAVO":   10,
+	"CHARLIE": 200,
+}
+
+func (x SiblingEnum) Enum() *SiblingEnum {
+	p := new(SiblingEnum)
+	*p = x
+	return p
+}
+
+func (x SiblingEnum) String() string {
+	return proto.EnumName(SiblingEnum_name, int32(x))
+}
+
+func (x *SiblingEnum) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(SiblingEnum_value, data, "SiblingEnum")
+	if err != nil {
+		return err
+	}
+	*x = SiblingEnum(value)
+	return nil
+}
+
+func (SiblingEnum) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_3a17e2c63b2b3424, []int{0}
+}
+
+type Message_ChildEnum int32
+
+const (
+	Message_ALPHA   Message_ChildEnum = 0
+	Message_BRAVO   Message_ChildEnum = 1
+	Message_CHARLIE Message_ChildEnum = 2
+)
+
+var Message_ChildEnum_name = map[int32]string{
+	0: "ALPHA",
+	1: "BRAVO",
+	2: "CHARLIE",
+}
+
+var Message_ChildEnum_value = map[string]int32{
+	"ALPHA":   0,
+	"BRAVO":   1,
+	"CHARLIE": 2,
+}
+
+func (x Message_ChildEnum) Enum() *Message_ChildEnum {
+	p := new(Message_ChildEnum)
+	*p = x
+	return p
+}
+
+func (x Message_ChildEnum) String() string {
+	return proto.EnumName(Message_ChildEnum_name, int32(x))
+}
+
+func (x *Message_ChildEnum) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(Message_ChildEnum_value, data, "Message_ChildEnum")
+	if err != nil {
+		return err
+	}
+	*x = Message_ChildEnum(value)
+	return nil
+}
+
+func (Message_ChildEnum) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_3a17e2c63b2b3424, []int{1, 0}
+}
+
+type SiblingMessage 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"`
+	F4                   *Message `protobuf:"bytes,4,opt,name=f4" json:"f4,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *SiblingMessage) Reset()         { *m = SiblingMessage{} }
+func (m *SiblingMessage) String() string { return proto.CompactTextString(m) }
+func (*SiblingMessage) ProtoMessage()    {}
+func (*SiblingMessage) Descriptor() ([]byte, []int) {
+	return fileDescriptor_3a17e2c63b2b3424, []int{0}
+}
+
+func (m *SiblingMessage) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_SiblingMessage.Unmarshal(m, b)
+}
+func (m *SiblingMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_SiblingMessage.Marshal(b, m, deterministic)
+}
+func (m *SiblingMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SiblingMessage.Merge(m, src)
+}
+func (m *SiblingMessage) XXX_Size() int {
+	return xxx_messageInfo_SiblingMessage.Size(m)
+}
+func (m *SiblingMessage) XXX_DiscardUnknown() {
+	xxx_messageInfo_SiblingMessage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SiblingMessage proto.InternalMessageInfo
+
+func (m *SiblingMessage) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *SiblingMessage) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *SiblingMessage) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+func (m *SiblingMessage) GetF4() *Message {
+	if m != nil {
+		return m.F4
+	}
+	return nil
+}
+
+type Message struct {
+	Namedgroup *Message_NamedGroup `protobuf:"group,1,opt,name=NamedGroup,json=namedgroup" json:"namedgroup,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      *Message_ChildEnum     `protobuf:"varint,115,opt,name=optional_child_enum,json=optionalChildEnum,enum=google.golang.org.proto2_20190205.Message_ChildEnum" json:"optional_child_enum,omitempty"`
+	OptionalChildMessage   *Message_ChildMessage  `protobuf:"bytes,116,opt,name=optional_child_message,json=optionalChildMessage" json:"optional_child_message,omitempty"`
+	OptionalNamedGroup     *Message_NamedGroup    `protobuf:"bytes,117,opt,name=optional_named_group,json=optionalNamedGroup" json:"optional_named_group,omitempty"`
+	OptionalSiblingEnum    *SiblingEnum           `protobuf:"varint,118,opt,name=optional_sibling_enum,json=optionalSiblingEnum,enum=google.golang.org.proto2_20190205.SiblingEnum" json:"optional_sibling_enum,omitempty"`
+	OptionalSiblingMessage *SiblingMessage        `protobuf:"bytes,119,opt,name=optional_sibling_message,json=optionalSiblingMessage" json:"optional_sibling_message,omitempty"`
+	Optionalgroup          *Message_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   *Message_ChildEnum `protobuf:"varint,215,opt,name=defaulted_child_enum,json=defaultedChildEnum,enum=google.golang.org.proto2_20190205.Message_ChildEnum,def=0" json:"defaulted_child_enum,omitempty"`
+	DefaultedSiblingEnum *SiblingEnum       `protobuf:"varint,216,opt,name=defaulted_sibling_enum,json=defaultedSiblingEnum,enum=google.golang.org.proto2_20190205.SiblingEnum,def=0" 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      *Message_ChildEnum     `protobuf:"varint,315,req,name=required_child_enum,json=requiredChildEnum,enum=google.golang.org.proto2_20190205.Message_ChildEnum" json:"required_child_enum,omitempty"`
+	RequiredChildMessage   *Message_ChildMessage  `protobuf:"bytes,316,req,name=required_child_message,json=requiredChildMessage" json:"required_child_message,omitempty"`
+	RequiredNamedGroup     *Message_NamedGroup    `protobuf:"bytes,317,req,name=required_named_group,json=requiredNamedGroup" json:"required_named_group,omitempty"`
+	RequiredSiblingEnum    *SiblingEnum           `protobuf:"varint,318,req,name=required_sibling_enum,json=requiredSiblingEnum,enum=google.golang.org.proto2_20190205.SiblingEnum" json:"required_sibling_enum,omitempty"`
+	RequiredSiblingMessage *SiblingMessage        `protobuf:"bytes,319,req,name=required_sibling_message,json=requiredSiblingMessage" json:"required_sibling_message,omitempty"`
+	Requiredgroup          *Message_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   *Message_ChildEnum `protobuf:"varint,415,req,name=required_defaulted_child_enum,json=requiredDefaultedChildEnum,enum=google.golang.org.proto2_20190205.Message_ChildEnum,def=0" json:"required_defaulted_child_enum,omitempty"`
+	RequiredDefaultedSiblingEnum *SiblingEnum       `protobuf:"varint,416,req,name=required_defaulted_sibling_enum,json=requiredDefaultedSiblingEnum,enum=google.golang.org.proto2_20190205.SiblingEnum,def=0" 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      []Message_ChildEnum      `protobuf:"varint,515,rep,name=repeated_child_enum,json=repeatedChildEnum,enum=google.golang.org.proto2_20190205.Message_ChildEnum" json:"repeated_child_enum,omitempty"`
+	RepeatedChildMessage   []*Message_ChildMessage  `protobuf:"bytes,516,rep,name=repeated_child_message,json=repeatedChildMessage" json:"repeated_child_message,omitempty"`
+	RepeatedNamedGroup     []*Message_NamedGroup    `protobuf:"bytes,517,rep,name=repeated_named_group,json=repeatedNamedGroup" json:"repeated_named_group,omitempty"`
+	RepeatedSiblingEnum    []SiblingEnum            `protobuf:"varint,518,rep,name=repeated_sibling_enum,json=repeatedSiblingEnum,enum=google.golang.org.proto2_20190205.SiblingEnum" json:"repeated_sibling_enum,omitempty"`
+	RepeatedSiblingMessage []*SiblingMessage        `protobuf:"bytes,519,rep,name=repeated_sibling_message,json=repeatedSiblingMessage" json:"repeated_sibling_message,omitempty"`
+	Repeatedgroup          []*Message_RepeatedGroup `protobuf:"group,520,rep,name=RepeatedGroup,json=repeatedgroup" json:"repeatedgroup,omitempty"`
+	// Map fields.
+	MapBoolBool           map[bool]bool                  `protobuf:"bytes,600,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,601,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,602,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,603,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,604,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,605,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,606,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,607,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,608,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,609,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,610,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,611,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,612,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,613,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,614,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"`
+	MapBoolChildEnum      map[bool]Message_ChildEnum     `protobuf:"bytes,615,rep,name=map_bool_child_enum,json=mapBoolChildEnum" json:"map_bool_child_enum,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=google.golang.org.proto2_20190205.Message_ChildEnum"`
+	MapBoolChildMessage   map[bool]*Message_ChildMessage `protobuf:"bytes,616,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"`
+	MapBoolNamedGroup     map[bool]*Message_NamedGroup   `protobuf:"bytes,617,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"`
+	MapBoolSiblingEnum    map[bool]SiblingEnum           `protobuf:"bytes,618,rep,name=map_bool_sibling_enum,json=mapBoolSiblingEnum" json:"map_bool_sibling_enum,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=google.golang.org.proto2_20190205.SiblingEnum"`
+	MapBoolSiblingMessage map[bool]*SiblingMessage       `protobuf:"bytes,619,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"`
+	MapInt32Bool          map[int32]bool                 `protobuf:"bytes,620,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,621,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,622,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,623,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,624,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,625,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,626,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,627,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.
+	//
+	// Types that are valid to be assigned to OneofUnion:
+	//	*Message_OneofBool
+	//	*Message_OneofInt32
+	//	*Message_OneofSint32
+	//	*Message_OneofUint32
+	//	*Message_OneofInt64
+	//	*Message_OneofSint64
+	//	*Message_OneofUint64
+	//	*Message_OneofFixed32
+	//	*Message_OneofSfixed32
+	//	*Message_OneofFloat
+	//	*Message_OneofFixed64
+	//	*Message_OneofSfixed64
+	//	*Message_OneofDouble
+	//	*Message_OneofString
+	//	*Message_OneofBytes
+	//	*Message_OneofChildEnum
+	//	*Message_OneofChildMessage
+	//	*Message_OneofNamedGroup
+	//	*Message_OneofSiblingEnum
+	//	*Message_OneofSiblingMessage
+	//	*Message_Oneofgroup
+	//	*Message_OneofString1
+	//	*Message_OneofString2
+	//	*Message_OneofString3
+	OneofUnion isMessage_OneofUnion `protobuf_oneof:"oneof_union"`
+	// Oneof default fields.
+	//
+	// Types that are valid to be assigned to OneofDefaultedUnion:
+	//	*Message_OneofDefaultedBool
+	//	*Message_OneofDefaultedInt32
+	//	*Message_OneofDefaultedSint32
+	//	*Message_OneofDefaultedUint32
+	//	*Message_OneofDefaultedInt64
+	//	*Message_OneofDefaultedSint64
+	//	*Message_OneofDefaultedUint64
+	//	*Message_OneofDefaultedFixed32
+	//	*Message_OneofDefaultedSfixed32
+	//	*Message_OneofDefaultedFloat
+	//	*Message_OneofDefaultedFixed64
+	//	*Message_OneofDefaultedSfixed64
+	//	*Message_OneofDefaultedDouble
+	//	*Message_OneofDefaultedString
+	//	*Message_OneofDefaultedBytes
+	//	*Message_OneofDefaultedChildEnum
+	//	*Message_OneofDefaultedSiblingEnum
+	OneofDefaultedUnion          isMessage_OneofDefaultedUnion `protobuf_oneof:"oneof_defaulted_union"`
+	XXX_NoUnkeyedLiteral         struct{}                      `json:"-"`
+	proto.XXX_InternalExtensions `json:"-"`
+	XXX_unrecognized             []byte `json:"-"`
+	XXX_sizecache                int32  `json:"-"`
+}
+
+func (m *Message) Reset()         { *m = Message{} }
+func (m *Message) String() string { return proto.CompactTextString(m) }
+func (*Message) ProtoMessage()    {}
+func (*Message) Descriptor() ([]byte, []int) {
+	return fileDescriptor_3a17e2c63b2b3424, []int{1}
+}
+
+var extRange_Message = []proto.ExtensionRange{
+	{Start: 10000, End: 536870911},
+}
+
+func (*Message) ExtensionRangeArray() []proto.ExtensionRange {
+	return extRange_Message
+}
+
+func (m *Message) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Message.Unmarshal(m, b)
+}
+func (m *Message) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Message.Marshal(b, m, deterministic)
+}
+func (m *Message) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Message.Merge(m, src)
+}
+func (m *Message) XXX_Size() int {
+	return xxx_messageInfo_Message.Size(m)
+}
+func (m *Message) XXX_DiscardUnknown() {
+	xxx_messageInfo_Message.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message proto.InternalMessageInfo
+
+const Default_Message_DefaultedBool bool = true
+const Default_Message_DefaultedInt32 int32 = -12345
+const Default_Message_DefaultedSint32 int32 = -3200
+const Default_Message_DefaultedUint32 uint32 = 3200
+const Default_Message_DefaultedInt64 int64 = -123456789
+const Default_Message_DefaultedSint64 int64 = -6400
+const Default_Message_DefaultedUint64 uint64 = 6400
+const Default_Message_DefaultedFixed32 uint32 = 320000
+const Default_Message_DefaultedSfixed32 int32 = -320000
+const Default_Message_DefaultedFloat float32 = 3.14159
+const Default_Message_DefaultedFixed64 uint64 = 640000
+const Default_Message_DefaultedSfixed64 int64 = -640000
+const Default_Message_DefaultedDouble float64 = 3.14159265359
+const Default_Message_DefaultedString string = "hello, \"world!\"\n"
+
+var Default_Message_DefaultedBytes []byte = []byte("deadޭ\xbe\xefbeef")
+
+const Default_Message_DefaultedChildEnum Message_ChildEnum = Message_ALPHA
+const Default_Message_DefaultedSiblingEnum SiblingEnum = SiblingEnum_ALPHA
+const Default_Message_RequiredDefaultedBool bool = true
+const Default_Message_RequiredDefaultedInt32 int32 = -12345
+const Default_Message_RequiredDefaultedSint32 int32 = -3200
+const Default_Message_RequiredDefaultedUint32 uint32 = 3200
+const Default_Message_RequiredDefaultedInt64 int64 = -123456789
+const Default_Message_RequiredDefaultedSint64 int64 = -6400
+const Default_Message_RequiredDefaultedUint64 uint64 = 6400
+const Default_Message_RequiredDefaultedFixed32 uint32 = 320000
+const Default_Message_RequiredDefaultedSfixed32 int32 = -320000
+const Default_Message_RequiredDefaultedFloat float32 = 3.14159
+const Default_Message_RequiredDefaultedFixed64 uint64 = 640000
+const Default_Message_RequiredDefaultedSfixed64 int64 = -640000
+const Default_Message_RequiredDefaultedDouble float64 = 3.14159265359
+const Default_Message_RequiredDefaultedString string = "hello, \"world!\"\n"
+
+var Default_Message_RequiredDefaultedBytes []byte = []byte("deadޭ\xbe\xefbeef")
+
+const Default_Message_RequiredDefaultedChildEnum Message_ChildEnum = Message_ALPHA
+const Default_Message_RequiredDefaultedSiblingEnum SiblingEnum = SiblingEnum_ALPHA
+const Default_Message_OneofDefaultedBool bool = true
+const Default_Message_OneofDefaultedInt32 int32 = -12345
+const Default_Message_OneofDefaultedSint32 int32 = -3200
+const Default_Message_OneofDefaultedUint32 uint32 = 3200
+const Default_Message_OneofDefaultedInt64 int64 = -123456789
+const Default_Message_OneofDefaultedSint64 int64 = -6400
+const Default_Message_OneofDefaultedUint64 uint64 = 6400
+const Default_Message_OneofDefaultedFixed32 uint32 = 320000
+const Default_Message_OneofDefaultedSfixed32 int32 = -320000
+const Default_Message_OneofDefaultedFloat float32 = 3.14159
+const Default_Message_OneofDefaultedFixed64 uint64 = 640000
+const Default_Message_OneofDefaultedSfixed64 int64 = -640000
+const Default_Message_OneofDefaultedDouble float64 = 3.14159265359
+const Default_Message_OneofDefaultedString string = "hello, \"world!\"\n"
+
+var Default_Message_OneofDefaultedBytes []byte = []byte("deadޭ\xbe\xefbeef")
+
+const Default_Message_OneofDefaultedChildEnum Message_ChildEnum = Message_ALPHA
+const Default_Message_OneofDefaultedSiblingEnum SiblingEnum = SiblingEnum_ALPHA
+
+func (m *Message) GetNamedgroup() *Message_NamedGroup {
+	if m != nil {
+		return m.Namedgroup
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalBool() bool {
+	if m != nil && m.OptionalBool != nil {
+		return *m.OptionalBool
+	}
+	return false
+}
+
+func (m *Message) GetOptionalInt32() int32 {
+	if m != nil && m.OptionalInt32 != nil {
+		return *m.OptionalInt32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSint32() int32 {
+	if m != nil && m.OptionalSint32 != nil {
+		return *m.OptionalSint32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalUint32() uint32 {
+	if m != nil && m.OptionalUint32 != nil {
+		return *m.OptionalUint32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalInt64() int64 {
+	if m != nil && m.OptionalInt64 != nil {
+		return *m.OptionalInt64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSint64() int64 {
+	if m != nil && m.OptionalSint64 != nil {
+		return *m.OptionalSint64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalUint64() uint64 {
+	if m != nil && m.OptionalUint64 != nil {
+		return *m.OptionalUint64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalFixed32() uint32 {
+	if m != nil && m.OptionalFixed32 != nil {
+		return *m.OptionalFixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSfixed32() int32 {
+	if m != nil && m.OptionalSfixed32 != nil {
+		return *m.OptionalSfixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalFloat() float32 {
+	if m != nil && m.OptionalFloat != nil {
+		return *m.OptionalFloat
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalFixed64() uint64 {
+	if m != nil && m.OptionalFixed64 != nil {
+		return *m.OptionalFixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSfixed64() int64 {
+	if m != nil && m.OptionalSfixed64 != nil {
+		return *m.OptionalSfixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalDouble() float64 {
+	if m != nil && m.OptionalDouble != nil {
+		return *m.OptionalDouble
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalString() string {
+	if m != nil && m.OptionalString != nil {
+		return *m.OptionalString
+	}
+	return ""
+}
+
+func (m *Message) GetOptionalBytes() []byte {
+	if m != nil {
+		return m.OptionalBytes
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalChildEnum() Message_ChildEnum {
+	if m != nil && m.OptionalChildEnum != nil {
+		return *m.OptionalChildEnum
+	}
+	return Message_ALPHA
+}
+
+func (m *Message) GetOptionalChildMessage() *Message_ChildMessage {
+	if m != nil {
+		return m.OptionalChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalNamedGroup() *Message_NamedGroup {
+	if m != nil {
+		return m.OptionalNamedGroup
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalSiblingEnum() SiblingEnum {
+	if m != nil && m.OptionalSiblingEnum != nil {
+		return *m.OptionalSiblingEnum
+	}
+	return SiblingEnum_ALPHA
+}
+
+func (m *Message) GetOptionalSiblingMessage() *SiblingMessage {
+	if m != nil {
+		return m.OptionalSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalgroup() *Message_OptionalGroup {
+	if m != nil {
+		return m.Optionalgroup
+	}
+	return nil
+}
+
+func (m *Message) GetDefaultedBool() bool {
+	if m != nil && m.DefaultedBool != nil {
+		return *m.DefaultedBool
+	}
+	return Default_Message_DefaultedBool
+}
+
+func (m *Message) GetDefaultedInt32() int32 {
+	if m != nil && m.DefaultedInt32 != nil {
+		return *m.DefaultedInt32
+	}
+	return Default_Message_DefaultedInt32
+}
+
+func (m *Message) GetDefaultedSint32() int32 {
+	if m != nil && m.DefaultedSint32 != nil {
+		return *m.DefaultedSint32
+	}
+	return Default_Message_DefaultedSint32
+}
+
+func (m *Message) GetDefaultedUint32() uint32 {
+	if m != nil && m.DefaultedUint32 != nil {
+		return *m.DefaultedUint32
+	}
+	return Default_Message_DefaultedUint32
+}
+
+func (m *Message) GetDefaultedInt64() int64 {
+	if m != nil && m.DefaultedInt64 != nil {
+		return *m.DefaultedInt64
+	}
+	return Default_Message_DefaultedInt64
+}
+
+func (m *Message) GetDefaultedSint64() int64 {
+	if m != nil && m.DefaultedSint64 != nil {
+		return *m.DefaultedSint64
+	}
+	return Default_Message_DefaultedSint64
+}
+
+func (m *Message) GetDefaultedUint64() uint64 {
+	if m != nil && m.DefaultedUint64 != nil {
+		return *m.DefaultedUint64
+	}
+	return Default_Message_DefaultedUint64
+}
+
+func (m *Message) GetDefaultedFixed32() uint32 {
+	if m != nil && m.DefaultedFixed32 != nil {
+		return *m.DefaultedFixed32
+	}
+	return Default_Message_DefaultedFixed32
+}
+
+func (m *Message) GetDefaultedSfixed32() int32 {
+	if m != nil && m.DefaultedSfixed32 != nil {
+		return *m.DefaultedSfixed32
+	}
+	return Default_Message_DefaultedSfixed32
+}
+
+func (m *Message) GetDefaultedFloat() float32 {
+	if m != nil && m.DefaultedFloat != nil {
+		return *m.DefaultedFloat
+	}
+	return Default_Message_DefaultedFloat
+}
+
+func (m *Message) GetDefaultedFixed64() uint64 {
+	if m != nil && m.DefaultedFixed64 != nil {
+		return *m.DefaultedFixed64
+	}
+	return Default_Message_DefaultedFixed64
+}
+
+func (m *Message) GetDefaultedSfixed64() int64 {
+	if m != nil && m.DefaultedSfixed64 != nil {
+		return *m.DefaultedSfixed64
+	}
+	return Default_Message_DefaultedSfixed64
+}
+
+func (m *Message) GetDefaultedDouble() float64 {
+	if m != nil && m.DefaultedDouble != nil {
+		return *m.DefaultedDouble
+	}
+	return Default_Message_DefaultedDouble
+}
+
+func (m *Message) GetDefaultedString() string {
+	if m != nil && m.DefaultedString != nil {
+		return *m.DefaultedString
+	}
+	return Default_Message_DefaultedString
+}
+
+func (m *Message) GetDefaultedBytes() []byte {
+	if m != nil && m.DefaultedBytes != nil {
+		return m.DefaultedBytes
+	}
+	return append([]byte(nil), Default_Message_DefaultedBytes...)
+}
+
+func (m *Message) GetDefaultedChildEnum() Message_ChildEnum {
+	if m != nil && m.DefaultedChildEnum != nil {
+		return *m.DefaultedChildEnum
+	}
+	return Default_Message_DefaultedChildEnum
+}
+
+func (m *Message) GetDefaultedSiblingEnum() SiblingEnum {
+	if m != nil && m.DefaultedSiblingEnum != nil {
+		return *m.DefaultedSiblingEnum
+	}
+	return Default_Message_DefaultedSiblingEnum
+}
+
+func (m *Message) GetRequiredBool() bool {
+	if m != nil && m.RequiredBool != nil {
+		return *m.RequiredBool
+	}
+	return false
+}
+
+func (m *Message) GetRequiredInt32() int32 {
+	if m != nil && m.RequiredInt32 != nil {
+		return *m.RequiredInt32
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredSint32() int32 {
+	if m != nil && m.RequiredSint32 != nil {
+		return *m.RequiredSint32
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredUint32() uint32 {
+	if m != nil && m.RequiredUint32 != nil {
+		return *m.RequiredUint32
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredInt64() int64 {
+	if m != nil && m.RequiredInt64 != nil {
+		return *m.RequiredInt64
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredSint64() int64 {
+	if m != nil && m.RequiredSint64 != nil {
+		return *m.RequiredSint64
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredUint64() uint64 {
+	if m != nil && m.RequiredUint64 != nil {
+		return *m.RequiredUint64
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredFixed32() uint32 {
+	if m != nil && m.RequiredFixed32 != nil {
+		return *m.RequiredFixed32
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredSfixed32() int32 {
+	if m != nil && m.RequiredSfixed32 != nil {
+		return *m.RequiredSfixed32
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredFloat() float32 {
+	if m != nil && m.RequiredFloat != nil {
+		return *m.RequiredFloat
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredFixed64() uint64 {
+	if m != nil && m.RequiredFixed64 != nil {
+		return *m.RequiredFixed64
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredSfixed64() int64 {
+	if m != nil && m.RequiredSfixed64 != nil {
+		return *m.RequiredSfixed64
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredDouble() float64 {
+	if m != nil && m.RequiredDouble != nil {
+		return *m.RequiredDouble
+	}
+	return 0
+}
+
+func (m *Message) GetRequiredString() string {
+	if m != nil && m.RequiredString != nil {
+		return *m.RequiredString
+	}
+	return ""
+}
+
+func (m *Message) GetRequiredBytes() []byte {
+	if m != nil {
+		return m.RequiredBytes
+	}
+	return nil
+}
+
+func (m *Message) GetRequiredChildEnum() Message_ChildEnum {
+	if m != nil && m.RequiredChildEnum != nil {
+		return *m.RequiredChildEnum
+	}
+	return Message_ALPHA
+}
+
+func (m *Message) GetRequiredChildMessage() *Message_ChildMessage {
+	if m != nil {
+		return m.RequiredChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRequiredNamedGroup() *Message_NamedGroup {
+	if m != nil {
+		return m.RequiredNamedGroup
+	}
+	return nil
+}
+
+func (m *Message) GetRequiredSiblingEnum() SiblingEnum {
+	if m != nil && m.RequiredSiblingEnum != nil {
+		return *m.RequiredSiblingEnum
+	}
+	return SiblingEnum_ALPHA
+}
+
+func (m *Message) GetRequiredSiblingMessage() *SiblingMessage {
+	if m != nil {
+		return m.RequiredSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRequiredgroup() *Message_RequiredGroup {
+	if m != nil {
+		return m.Requiredgroup
+	}
+	return nil
+}
+
+func (m *Message) GetRequiredDefaultedBool() bool {
+	if m != nil && m.RequiredDefaultedBool != nil {
+		return *m.RequiredDefaultedBool
+	}
+	return Default_Message_RequiredDefaultedBool
+}
+
+func (m *Message) GetRequiredDefaultedInt32() int32 {
+	if m != nil && m.RequiredDefaultedInt32 != nil {
+		return *m.RequiredDefaultedInt32
+	}
+	return Default_Message_RequiredDefaultedInt32
+}
+
+func (m *Message) GetRequiredDefaultedSint32() int32 {
+	if m != nil && m.RequiredDefaultedSint32 != nil {
+		return *m.RequiredDefaultedSint32
+	}
+	return Default_Message_RequiredDefaultedSint32
+}
+
+func (m *Message) GetRequiredDefaultedUint32() uint32 {
+	if m != nil && m.RequiredDefaultedUint32 != nil {
+		return *m.RequiredDefaultedUint32
+	}
+	return Default_Message_RequiredDefaultedUint32
+}
+
+func (m *Message) GetRequiredDefaultedInt64() int64 {
+	if m != nil && m.RequiredDefaultedInt64 != nil {
+		return *m.RequiredDefaultedInt64
+	}
+	return Default_Message_RequiredDefaultedInt64
+}
+
+func (m *Message) GetRequiredDefaultedSint64() int64 {
+	if m != nil && m.RequiredDefaultedSint64 != nil {
+		return *m.RequiredDefaultedSint64
+	}
+	return Default_Message_RequiredDefaultedSint64
+}
+
+func (m *Message) GetRequiredDefaultedUint64() uint64 {
+	if m != nil && m.RequiredDefaultedUint64 != nil {
+		return *m.RequiredDefaultedUint64
+	}
+	return Default_Message_RequiredDefaultedUint64
+}
+
+func (m *Message) GetRequiredDefaultedFixed32() uint32 {
+	if m != nil && m.RequiredDefaultedFixed32 != nil {
+		return *m.RequiredDefaultedFixed32
+	}
+	return Default_Message_RequiredDefaultedFixed32
+}
+
+func (m *Message) GetRequiredDefaultedSfixed32() int32 {
+	if m != nil && m.RequiredDefaultedSfixed32 != nil {
+		return *m.RequiredDefaultedSfixed32
+	}
+	return Default_Message_RequiredDefaultedSfixed32
+}
+
+func (m *Message) GetRequiredDefaultedFloat() float32 {
+	if m != nil && m.RequiredDefaultedFloat != nil {
+		return *m.RequiredDefaultedFloat
+	}
+	return Default_Message_RequiredDefaultedFloat
+}
+
+func (m *Message) GetRequiredDefaultedFixed64() uint64 {
+	if m != nil && m.RequiredDefaultedFixed64 != nil {
+		return *m.RequiredDefaultedFixed64
+	}
+	return Default_Message_RequiredDefaultedFixed64
+}
+
+func (m *Message) GetRequiredDefaultedSfixed64() int64 {
+	if m != nil && m.RequiredDefaultedSfixed64 != nil {
+		return *m.RequiredDefaultedSfixed64
+	}
+	return Default_Message_RequiredDefaultedSfixed64
+}
+
+func (m *Message) GetRequiredDefaultedDouble() float64 {
+	if m != nil && m.RequiredDefaultedDouble != nil {
+		return *m.RequiredDefaultedDouble
+	}
+	return Default_Message_RequiredDefaultedDouble
+}
+
+func (m *Message) GetRequiredDefaultedString() string {
+	if m != nil && m.RequiredDefaultedString != nil {
+		return *m.RequiredDefaultedString
+	}
+	return Default_Message_RequiredDefaultedString
+}
+
+func (m *Message) GetRequiredDefaultedBytes() []byte {
+	if m != nil && m.RequiredDefaultedBytes != nil {
+		return m.RequiredDefaultedBytes
+	}
+	return append([]byte(nil), Default_Message_RequiredDefaultedBytes...)
+}
+
+func (m *Message) GetRequiredDefaultedChildEnum() Message_ChildEnum {
+	if m != nil && m.RequiredDefaultedChildEnum != nil {
+		return *m.RequiredDefaultedChildEnum
+	}
+	return Default_Message_RequiredDefaultedChildEnum
+}
+
+func (m *Message) GetRequiredDefaultedSiblingEnum() SiblingEnum {
+	if m != nil && m.RequiredDefaultedSiblingEnum != nil {
+		return *m.RequiredDefaultedSiblingEnum
+	}
+	return Default_Message_RequiredDefaultedSiblingEnum
+}
+
+func (m *Message) GetRepeatedBool() []bool {
+	if m != nil {
+		return m.RepeatedBool
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedInt32() []int32 {
+	if m != nil {
+		return m.RepeatedInt32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSint32() []int32 {
+	if m != nil {
+		return m.RepeatedSint32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedUint32() []uint32 {
+	if m != nil {
+		return m.RepeatedUint32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedInt64() []int64 {
+	if m != nil {
+		return m.RepeatedInt64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSint64() []int64 {
+	if m != nil {
+		return m.RepeatedSint64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedUint64() []uint64 {
+	if m != nil {
+		return m.RepeatedUint64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedFixed32() []uint32 {
+	if m != nil {
+		return m.RepeatedFixed32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSfixed32() []int32 {
+	if m != nil {
+		return m.RepeatedSfixed32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedFloat() []float32 {
+	if m != nil {
+		return m.RepeatedFloat
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedFixed64() []uint64 {
+	if m != nil {
+		return m.RepeatedFixed64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSfixed64() []int64 {
+	if m != nil {
+		return m.RepeatedSfixed64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedDouble() []float64 {
+	if m != nil {
+		return m.RepeatedDouble
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedString() []string {
+	if m != nil {
+		return m.RepeatedString
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedBytes() [][]byte {
+	if m != nil {
+		return m.RepeatedBytes
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedChildEnum() []Message_ChildEnum {
+	if m != nil {
+		return m.RepeatedChildEnum
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedChildMessage() []*Message_ChildMessage {
+	if m != nil {
+		return m.RepeatedChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedNamedGroup() []*Message_NamedGroup {
+	if m != nil {
+		return m.RepeatedNamedGroup
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSiblingEnum() []SiblingEnum {
+	if m != nil {
+		return m.RepeatedSiblingEnum
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSiblingMessage() []*SiblingMessage {
+	if m != nil {
+		return m.RepeatedSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedgroup() []*Message_RepeatedGroup {
+	if m != nil {
+		return m.Repeatedgroup
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolBool() map[bool]bool {
+	if m != nil {
+		return m.MapBoolBool
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolInt32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolInt32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSint32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolSint32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolUint32() map[bool]uint32 {
+	if m != nil {
+		return m.MapBoolUint32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolInt64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolInt64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSint64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolSint64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolUint64() map[bool]uint64 {
+	if m != nil {
+		return m.MapBoolUint64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFixed32() map[bool]uint32 {
+	if m != nil {
+		return m.MapBoolFixed32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSfixed32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolSfixed32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFloat() map[bool]float32 {
+	if m != nil {
+		return m.MapBoolFloat
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFixed64() map[bool]uint64 {
+	if m != nil {
+		return m.MapBoolFixed64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSfixed64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolSfixed64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolDouble() map[bool]float64 {
+	if m != nil {
+		return m.MapBoolDouble
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolString() map[bool]string {
+	if m != nil {
+		return m.MapBoolString
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolBytes() map[bool][]byte {
+	if m != nil {
+		return m.MapBoolBytes
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolChildEnum() map[bool]Message_ChildEnum {
+	if m != nil {
+		return m.MapBoolChildEnum
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolChildMessage() map[bool]*Message_ChildMessage {
+	if m != nil {
+		return m.MapBoolChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolNamedGroup() map[bool]*Message_NamedGroup {
+	if m != nil {
+		return m.MapBoolNamedGroup
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSiblingEnum() map[bool]SiblingEnum {
+	if m != nil {
+		return m.MapBoolSiblingEnum
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSiblingMessage() map[bool]*SiblingMessage {
+	if m != nil {
+		return m.MapBoolSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetMapInt32Bool() map[int32]bool {
+	if m != nil {
+		return m.MapInt32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapSint32Bool() map[int32]bool {
+	if m != nil {
+		return m.MapSint32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapUint32Bool() map[uint32]bool {
+	if m != nil {
+		return m.MapUint32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapInt64Bool() map[int64]bool {
+	if m != nil {
+		return m.MapInt64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapSint64Bool() map[int64]bool {
+	if m != nil {
+		return m.MapSint64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapUint64Bool() map[uint64]bool {
+	if m != nil {
+		return m.MapUint64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapFixed32Bool() map[uint32]bool {
+	if m != nil {
+		return m.MapFixed32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapStringBool() map[string]bool {
+	if m != nil {
+		return m.MapStringBool
+	}
+	return nil
+}
+
+type isMessage_OneofUnion interface {
+	isMessage_OneofUnion()
+}
+
+type Message_OneofBool struct {
+	OneofBool bool `protobuf:"varint,700,opt,name=oneof_bool,json=oneofBool,oneof"`
+}
+
+type Message_OneofInt32 struct {
+	OneofInt32 int32 `protobuf:"varint,701,opt,name=oneof_int32,json=oneofInt32,oneof"`
+}
+
+type Message_OneofSint32 struct {
+	OneofSint32 int32 `protobuf:"zigzag32,702,opt,name=oneof_sint32,json=oneofSint32,oneof"`
+}
+
+type Message_OneofUint32 struct {
+	OneofUint32 uint32 `protobuf:"varint,703,opt,name=oneof_uint32,json=oneofUint32,oneof"`
+}
+
+type Message_OneofInt64 struct {
+	OneofInt64 int64 `protobuf:"varint,704,opt,name=oneof_int64,json=oneofInt64,oneof"`
+}
+
+type Message_OneofSint64 struct {
+	OneofSint64 int64 `protobuf:"zigzag64,705,opt,name=oneof_sint64,json=oneofSint64,oneof"`
+}
+
+type Message_OneofUint64 struct {
+	OneofUint64 uint64 `protobuf:"varint,706,opt,name=oneof_uint64,json=oneofUint64,oneof"`
+}
+
+type Message_OneofFixed32 struct {
+	OneofFixed32 uint32 `protobuf:"fixed32,707,opt,name=oneof_fixed32,json=oneofFixed32,oneof"`
+}
+
+type Message_OneofSfixed32 struct {
+	OneofSfixed32 int32 `protobuf:"fixed32,708,opt,name=oneof_sfixed32,json=oneofSfixed32,oneof"`
+}
+
+type Message_OneofFloat struct {
+	OneofFloat float32 `protobuf:"fixed32,709,opt,name=oneof_float,json=oneofFloat,oneof"`
+}
+
+type Message_OneofFixed64 struct {
+	OneofFixed64 uint64 `protobuf:"fixed64,710,opt,name=oneof_fixed64,json=oneofFixed64,oneof"`
+}
+
+type Message_OneofSfixed64 struct {
+	OneofSfixed64 int64 `protobuf:"fixed64,711,opt,name=oneof_sfixed64,json=oneofSfixed64,oneof"`
+}
+
+type Message_OneofDouble struct {
+	OneofDouble float64 `protobuf:"fixed64,712,opt,name=oneof_double,json=oneofDouble,oneof"`
+}
+
+type Message_OneofString struct {
+	OneofString string `protobuf:"bytes,713,opt,name=oneof_string,json=oneofString,oneof"`
+}
+
+type Message_OneofBytes struct {
+	OneofBytes []byte `protobuf:"bytes,714,opt,name=oneof_bytes,json=oneofBytes,oneof"`
+}
+
+type Message_OneofChildEnum struct {
+	OneofChildEnum Message_ChildEnum `protobuf:"varint,715,opt,name=oneof_child_enum,json=oneofChildEnum,enum=google.golang.org.proto2_20190205.Message_ChildEnum,oneof"`
+}
+
+type Message_OneofChildMessage struct {
+	OneofChildMessage *Message_ChildMessage `protobuf:"bytes,716,opt,name=oneof_child_message,json=oneofChildMessage,oneof"`
+}
+
+type Message_OneofNamedGroup struct {
+	OneofNamedGroup *Message_NamedGroup `protobuf:"bytes,717,opt,name=oneof_named_group,json=oneofNamedGroup,oneof"`
+}
+
+type Message_OneofSiblingEnum struct {
+	OneofSiblingEnum SiblingEnum `protobuf:"varint,718,opt,name=oneof_sibling_enum,json=oneofSiblingEnum,enum=google.golang.org.proto2_20190205.SiblingEnum,oneof"`
+}
+
+type Message_OneofSiblingMessage struct {
+	OneofSiblingMessage *SiblingMessage `protobuf:"bytes,719,opt,name=oneof_sibling_message,json=oneofSiblingMessage,oneof"`
+}
+
+type Message_Oneofgroup struct {
+	Oneofgroup *Message_OneofGroup `protobuf:"group,720,opt,name=OneofGroup,json=oneofgroup,oneof"`
+}
+
+type Message_OneofString1 struct {
+	OneofString1 string `protobuf:"bytes,721,opt,name=oneof_string1,json=oneofString1,oneof"`
+}
+
+type Message_OneofString2 struct {
+	OneofString2 string `protobuf:"bytes,722,opt,name=oneof_string2,json=oneofString2,oneof"`
+}
+
+type Message_OneofString3 struct {
+	OneofString3 string `protobuf:"bytes,723,opt,name=oneof_string3,json=oneofString3,oneof"`
+}
+
+func (*Message_OneofBool) isMessage_OneofUnion() {}
+
+func (*Message_OneofInt32) isMessage_OneofUnion() {}
+
+func (*Message_OneofSint32) isMessage_OneofUnion() {}
+
+func (*Message_OneofUint32) isMessage_OneofUnion() {}
+
+func (*Message_OneofInt64) isMessage_OneofUnion() {}
+
+func (*Message_OneofSint64) isMessage_OneofUnion() {}
+
+func (*Message_OneofUint64) isMessage_OneofUnion() {}
+
+func (*Message_OneofFixed32) isMessage_OneofUnion() {}
+
+func (*Message_OneofSfixed32) isMessage_OneofUnion() {}
+
+func (*Message_OneofFloat) isMessage_OneofUnion() {}
+
+func (*Message_OneofFixed64) isMessage_OneofUnion() {}
+
+func (*Message_OneofSfixed64) isMessage_OneofUnion() {}
+
+func (*Message_OneofDouble) isMessage_OneofUnion() {}
+
+func (*Message_OneofString) isMessage_OneofUnion() {}
+
+func (*Message_OneofBytes) isMessage_OneofUnion() {}
+
+func (*Message_OneofChildEnum) isMessage_OneofUnion() {}
+
+func (*Message_OneofChildMessage) isMessage_OneofUnion() {}
+
+func (*Message_OneofNamedGroup) isMessage_OneofUnion() {}
+
+func (*Message_OneofSiblingEnum) isMessage_OneofUnion() {}
+
+func (*Message_OneofSiblingMessage) isMessage_OneofUnion() {}
+
+func (*Message_Oneofgroup) isMessage_OneofUnion() {}
+
+func (*Message_OneofString1) isMessage_OneofUnion() {}
+
+func (*Message_OneofString2) isMessage_OneofUnion() {}
+
+func (*Message_OneofString3) isMessage_OneofUnion() {}
+
+func (m *Message) GetOneofUnion() isMessage_OneofUnion {
+	if m != nil {
+		return m.OneofUnion
+	}
+	return nil
+}
+
+func (m *Message) GetOneofBool() bool {
+	if x, ok := m.GetOneofUnion().(*Message_OneofBool); ok {
+		return x.OneofBool
+	}
+	return false
+}
+
+func (m *Message) GetOneofInt32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofInt32); ok {
+		return x.OneofInt32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSint32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSint32); ok {
+		return x.OneofSint32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofUint32() uint32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofUint32); ok {
+		return x.OneofUint32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofInt64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofInt64); ok {
+		return x.OneofInt64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSint64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSint64); ok {
+		return x.OneofSint64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofUint64() uint64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofUint64); ok {
+		return x.OneofUint64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFixed32() uint32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFixed32); ok {
+		return x.OneofFixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSfixed32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSfixed32); ok {
+		return x.OneofSfixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFloat() float32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFloat); ok {
+		return x.OneofFloat
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFixed64() uint64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFixed64); ok {
+		return x.OneofFixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSfixed64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSfixed64); ok {
+		return x.OneofSfixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofDouble() float64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofDouble); ok {
+		return x.OneofDouble
+	}
+	return 0
+}
+
+func (m *Message) GetOneofString() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString); ok {
+		return x.OneofString
+	}
+	return ""
+}
+
+func (m *Message) GetOneofBytes() []byte {
+	if x, ok := m.GetOneofUnion().(*Message_OneofBytes); ok {
+		return x.OneofBytes
+	}
+	return nil
+}
+
+func (m *Message) GetOneofChildEnum() Message_ChildEnum {
+	if x, ok := m.GetOneofUnion().(*Message_OneofChildEnum); ok {
+		return x.OneofChildEnum
+	}
+	return Message_ALPHA
+}
+
+func (m *Message) GetOneofChildMessage() *Message_ChildMessage {
+	if x, ok := m.GetOneofUnion().(*Message_OneofChildMessage); ok {
+		return x.OneofChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOneofNamedGroup() *Message_NamedGroup {
+	if x, ok := m.GetOneofUnion().(*Message_OneofNamedGroup); ok {
+		return x.OneofNamedGroup
+	}
+	return nil
+}
+
+func (m *Message) GetOneofSiblingEnum() SiblingEnum {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSiblingEnum); ok {
+		return x.OneofSiblingEnum
+	}
+	return SiblingEnum_ALPHA
+}
+
+func (m *Message) GetOneofSiblingMessage() *SiblingMessage {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSiblingMessage); ok {
+		return x.OneofSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOneofgroup() *Message_OneofGroup {
+	if x, ok := m.GetOneofUnion().(*Message_Oneofgroup); ok {
+		return x.Oneofgroup
+	}
+	return nil
+}
+
+func (m *Message) GetOneofString1() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString1); ok {
+		return x.OneofString1
+	}
+	return ""
+}
+
+func (m *Message) GetOneofString2() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString2); ok {
+		return x.OneofString2
+	}
+	return ""
+}
+
+func (m *Message) GetOneofString3() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString3); ok {
+		return x.OneofString3
+	}
+	return ""
+}
+
+type isMessage_OneofDefaultedUnion interface {
+	isMessage_OneofDefaultedUnion()
+}
+
+type Message_OneofDefaultedBool struct {
+	OneofDefaultedBool bool `protobuf:"varint,800,opt,name=oneof_defaulted_bool,json=oneofDefaultedBool,oneof,def=1"`
+}
+
+type Message_OneofDefaultedInt32 struct {
+	OneofDefaultedInt32 int32 `protobuf:"varint,801,opt,name=oneof_defaulted_int32,json=oneofDefaultedInt32,oneof,def=-12345"`
+}
+
+type Message_OneofDefaultedSint32 struct {
+	OneofDefaultedSint32 int32 `protobuf:"zigzag32,802,opt,name=oneof_defaulted_sint32,json=oneofDefaultedSint32,oneof,def=-3200"`
+}
+
+type Message_OneofDefaultedUint32 struct {
+	OneofDefaultedUint32 uint32 `protobuf:"varint,803,opt,name=oneof_defaulted_uint32,json=oneofDefaultedUint32,oneof,def=3200"`
+}
+
+type Message_OneofDefaultedInt64 struct {
+	OneofDefaultedInt64 int64 `protobuf:"varint,804,opt,name=oneof_defaulted_int64,json=oneofDefaultedInt64,oneof,def=-123456789"`
+}
+
+type Message_OneofDefaultedSint64 struct {
+	OneofDefaultedSint64 int64 `protobuf:"zigzag64,805,opt,name=oneof_defaulted_sint64,json=oneofDefaultedSint64,oneof,def=-6400"`
+}
+
+type Message_OneofDefaultedUint64 struct {
+	OneofDefaultedUint64 uint64 `protobuf:"varint,806,opt,name=oneof_defaulted_uint64,json=oneofDefaultedUint64,oneof,def=6400"`
+}
+
+type Message_OneofDefaultedFixed32 struct {
+	OneofDefaultedFixed32 uint32 `protobuf:"fixed32,807,opt,name=oneof_defaulted_fixed32,json=oneofDefaultedFixed32,oneof,def=320000"`
+}
+
+type Message_OneofDefaultedSfixed32 struct {
+	OneofDefaultedSfixed32 int32 `protobuf:"fixed32,808,opt,name=oneof_defaulted_sfixed32,json=oneofDefaultedSfixed32,oneof,def=-320000"`
+}
+
+type Message_OneofDefaultedFloat struct {
+	OneofDefaultedFloat float32 `protobuf:"fixed32,809,opt,name=oneof_defaulted_float,json=oneofDefaultedFloat,oneof,def=3.14159"`
+}
+
+type Message_OneofDefaultedFixed64 struct {
+	OneofDefaultedFixed64 uint64 `protobuf:"fixed64,810,opt,name=oneof_defaulted_fixed64,json=oneofDefaultedFixed64,oneof,def=640000"`
+}
+
+type Message_OneofDefaultedSfixed64 struct {
+	OneofDefaultedSfixed64 int64 `protobuf:"fixed64,811,opt,name=oneof_defaulted_sfixed64,json=oneofDefaultedSfixed64,oneof,def=-640000"`
+}
+
+type Message_OneofDefaultedDouble struct {
+	OneofDefaultedDouble float64 `protobuf:"fixed64,812,opt,name=oneof_defaulted_double,json=oneofDefaultedDouble,oneof,def=3.14159265359"`
+}
+
+type Message_OneofDefaultedString struct {
+	OneofDefaultedString string `protobuf:"bytes,813,opt,name=oneof_defaulted_string,json=oneofDefaultedString,oneof,def=hello, \"world!\"\n"`
+}
+
+type Message_OneofDefaultedBytes struct {
+	OneofDefaultedBytes []byte `protobuf:"bytes,814,opt,name=oneof_defaulted_bytes,json=oneofDefaultedBytes,oneof,def=dead\\336\\255\\276\\357beef"`
+}
+
+type Message_OneofDefaultedChildEnum struct {
+	OneofDefaultedChildEnum Message_ChildEnum `protobuf:"varint,815,opt,name=oneof_defaulted_child_enum,json=oneofDefaultedChildEnum,enum=google.golang.org.proto2_20190205.Message_ChildEnum,oneof,def=0"`
+}
+
+type Message_OneofDefaultedSiblingEnum struct {
+	OneofDefaultedSiblingEnum SiblingEnum `protobuf:"varint,816,opt,name=oneof_defaulted_sibling_enum,json=oneofDefaultedSiblingEnum,enum=google.golang.org.proto2_20190205.SiblingEnum,oneof,def=0"`
+}
+
+func (*Message_OneofDefaultedBool) isMessage_OneofDefaultedUnion() {}
+
+func (*Message_OneofDefaultedInt32) isMessage_OneofDefaultedUnion() {}
+
+func (*Message_OneofDefaultedSint32) isMessage_OneofDefaultedUnion() {}
+
+func (*Message_OneofDefaultedUint32) isMessage_OneofDefaultedUnion() {}
+
+func (*Message_OneofDefaultedInt64) isMessage_OneofDefaultedUnion() {}
+
+func (*Message_OneofDefaultedSint64) isMessage_OneofDefaultedUnion() {}
+
+func (*Message_OneofDefaultedUint64) isMessage_OneofDefaultedUnion() {}
+
+func (*Message_OneofDefaultedFixed32) isMessage_OneofDefaultedUnion() {}
+
+func (*Message_OneofDefaultedSfixed32) isMessage_OneofDefaultedUnion() {}
+
+func (*Message_OneofDefaultedFloat) isMessage_OneofDefaultedUnion() {}
+
+func (*Message_OneofDefaultedFixed64) isMessage_OneofDefaultedUnion() {}
+
+func (*Message_OneofDefaultedSfixed64) isMessage_OneofDefaultedUnion() {}
+
+func (*Message_OneofDefaultedDouble) isMessage_OneofDefaultedUnion() {}
+
+func (*Message_OneofDefaultedString) isMessage_OneofDefaultedUnion() {}
+
+func (*Message_OneofDefaultedBytes) isMessage_OneofDefaultedUnion() {}
+
+func (*Message_OneofDefaultedChildEnum) isMessage_OneofDefaultedUnion() {}
+
+func (*Message_OneofDefaultedSiblingEnum) isMessage_OneofDefaultedUnion() {}
+
+func (m *Message) GetOneofDefaultedUnion() isMessage_OneofDefaultedUnion {
+	if m != nil {
+		return m.OneofDefaultedUnion
+	}
+	return nil
+}
+
+func (m *Message) GetOneofDefaultedBool() bool {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedBool); ok {
+		return x.OneofDefaultedBool
+	}
+	return Default_Message_OneofDefaultedBool
+}
+
+func (m *Message) GetOneofDefaultedInt32() int32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedInt32); ok {
+		return x.OneofDefaultedInt32
+	}
+	return Default_Message_OneofDefaultedInt32
+}
+
+func (m *Message) GetOneofDefaultedSint32() int32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedSint32); ok {
+		return x.OneofDefaultedSint32
+	}
+	return Default_Message_OneofDefaultedSint32
+}
+
+func (m *Message) GetOneofDefaultedUint32() uint32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedUint32); ok {
+		return x.OneofDefaultedUint32
+	}
+	return Default_Message_OneofDefaultedUint32
+}
+
+func (m *Message) GetOneofDefaultedInt64() int64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedInt64); ok {
+		return x.OneofDefaultedInt64
+	}
+	return Default_Message_OneofDefaultedInt64
+}
+
+func (m *Message) GetOneofDefaultedSint64() int64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedSint64); ok {
+		return x.OneofDefaultedSint64
+	}
+	return Default_Message_OneofDefaultedSint64
+}
+
+func (m *Message) GetOneofDefaultedUint64() uint64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedUint64); ok {
+		return x.OneofDefaultedUint64
+	}
+	return Default_Message_OneofDefaultedUint64
+}
+
+func (m *Message) GetOneofDefaultedFixed32() uint32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedFixed32); ok {
+		return x.OneofDefaultedFixed32
+	}
+	return Default_Message_OneofDefaultedFixed32
+}
+
+func (m *Message) GetOneofDefaultedSfixed32() int32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedSfixed32); ok {
+		return x.OneofDefaultedSfixed32
+	}
+	return Default_Message_OneofDefaultedSfixed32
+}
+
+func (m *Message) GetOneofDefaultedFloat() float32 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedFloat); ok {
+		return x.OneofDefaultedFloat
+	}
+	return Default_Message_OneofDefaultedFloat
+}
+
+func (m *Message) GetOneofDefaultedFixed64() uint64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedFixed64); ok {
+		return x.OneofDefaultedFixed64
+	}
+	return Default_Message_OneofDefaultedFixed64
+}
+
+func (m *Message) GetOneofDefaultedSfixed64() int64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedSfixed64); ok {
+		return x.OneofDefaultedSfixed64
+	}
+	return Default_Message_OneofDefaultedSfixed64
+}
+
+func (m *Message) GetOneofDefaultedDouble() float64 {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedDouble); ok {
+		return x.OneofDefaultedDouble
+	}
+	return Default_Message_OneofDefaultedDouble
+}
+
+func (m *Message) GetOneofDefaultedString() string {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedString); ok {
+		return x.OneofDefaultedString
+	}
+	return Default_Message_OneofDefaultedString
+}
+
+func (m *Message) GetOneofDefaultedBytes() []byte {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedBytes); ok {
+		return x.OneofDefaultedBytes
+	}
+	return append([]byte(nil), Default_Message_OneofDefaultedBytes...)
+}
+
+func (m *Message) GetOneofDefaultedChildEnum() Message_ChildEnum {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedChildEnum); ok {
+		return x.OneofDefaultedChildEnum
+	}
+	return Default_Message_OneofDefaultedChildEnum
+}
+
+func (m *Message) GetOneofDefaultedSiblingEnum() SiblingEnum {
+	if x, ok := m.GetOneofDefaultedUnion().(*Message_OneofDefaultedSiblingEnum); ok {
+		return x.OneofDefaultedSiblingEnum
+	}
+	return Default_Message_OneofDefaultedSiblingEnum
+}
+
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*Message) XXX_OneofWrappers() []interface{} {
+	return []interface{}{
+		(*Message_OneofBool)(nil),
+		(*Message_OneofInt32)(nil),
+		(*Message_OneofSint32)(nil),
+		(*Message_OneofUint32)(nil),
+		(*Message_OneofInt64)(nil),
+		(*Message_OneofSint64)(nil),
+		(*Message_OneofUint64)(nil),
+		(*Message_OneofFixed32)(nil),
+		(*Message_OneofSfixed32)(nil),
+		(*Message_OneofFloat)(nil),
+		(*Message_OneofFixed64)(nil),
+		(*Message_OneofSfixed64)(nil),
+		(*Message_OneofDouble)(nil),
+		(*Message_OneofString)(nil),
+		(*Message_OneofBytes)(nil),
+		(*Message_OneofChildEnum)(nil),
+		(*Message_OneofChildMessage)(nil),
+		(*Message_OneofNamedGroup)(nil),
+		(*Message_OneofSiblingEnum)(nil),
+		(*Message_OneofSiblingMessage)(nil),
+		(*Message_Oneofgroup)(nil),
+		(*Message_OneofString1)(nil),
+		(*Message_OneofString2)(nil),
+		(*Message_OneofString3)(nil),
+		(*Message_OneofDefaultedBool)(nil),
+		(*Message_OneofDefaultedInt32)(nil),
+		(*Message_OneofDefaultedSint32)(nil),
+		(*Message_OneofDefaultedUint32)(nil),
+		(*Message_OneofDefaultedInt64)(nil),
+		(*Message_OneofDefaultedSint64)(nil),
+		(*Message_OneofDefaultedUint64)(nil),
+		(*Message_OneofDefaultedFixed32)(nil),
+		(*Message_OneofDefaultedSfixed32)(nil),
+		(*Message_OneofDefaultedFloat)(nil),
+		(*Message_OneofDefaultedFixed64)(nil),
+		(*Message_OneofDefaultedSfixed64)(nil),
+		(*Message_OneofDefaultedDouble)(nil),
+		(*Message_OneofDefaultedString)(nil),
+		(*Message_OneofDefaultedBytes)(nil),
+		(*Message_OneofDefaultedChildEnum)(nil),
+		(*Message_OneofDefaultedSiblingEnum)(nil),
+	}
+}
+
+var E_Message_ExtensionOptionalBool = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*bool)(nil),
+	Field:         10000,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_optional_bool",
+	Tag:           "varint,10000,opt,name=extension_optional_bool",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionOptionalInt32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         10001,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_optional_int32",
+	Tag:           "varint,10001,opt,name=extension_optional_int32",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionOptionalSint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         10002,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_optional_sint32",
+	Tag:           "zigzag32,10002,opt,name=extension_optional_sint32",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionOptionalUint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint32)(nil),
+	Field:         10003,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_optional_uint32",
+	Tag:           "varint,10003,opt,name=extension_optional_uint32",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionOptionalInt64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         10004,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_optional_int64",
+	Tag:           "varint,10004,opt,name=extension_optional_int64",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionOptionalSint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         10005,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_optional_sint64",
+	Tag:           "zigzag64,10005,opt,name=extension_optional_sint64",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionOptionalUint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint64)(nil),
+	Field:         10006,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_optional_uint64",
+	Tag:           "varint,10006,opt,name=extension_optional_uint64",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionOptionalFixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint32)(nil),
+	Field:         10007,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_optional_fixed32",
+	Tag:           "fixed32,10007,opt,name=extension_optional_fixed32",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionOptionalSfixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         10008,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_optional_sfixed32",
+	Tag:           "fixed32,10008,opt,name=extension_optional_sfixed32",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionOptionalFloat = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*float32)(nil),
+	Field:         10009,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_optional_float",
+	Tag:           "fixed32,10009,opt,name=extension_optional_float",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionOptionalFixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint64)(nil),
+	Field:         10010,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_optional_fixed64",
+	Tag:           "fixed64,10010,opt,name=extension_optional_fixed64",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionOptionalSfixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         10011,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_optional_sfixed64",
+	Tag:           "fixed64,10011,opt,name=extension_optional_sfixed64",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionOptionalDouble = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*float64)(nil),
+	Field:         10012,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_optional_double",
+	Tag:           "fixed64,10012,opt,name=extension_optional_double",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionOptionalString = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*string)(nil),
+	Field:         10013,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_optional_string",
+	Tag:           "bytes,10013,opt,name=extension_optional_string",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionOptionalBytes = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]byte)(nil),
+	Field:         10014,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_optional_bytes",
+	Tag:           "bytes,10014,opt,name=extension_optional_bytes",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionOptionalChildEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*Message_ChildEnum)(nil),
+	Field:         10015,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_optional_child_enum",
+	Tag:           "varint,10015,opt,name=extension_optional_child_enum,enum=google.golang.org.proto2_20190205.Message_ChildEnum",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionOptionalChildMessage = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*Message_ChildMessage)(nil),
+	Field:         10016,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_optional_child_message",
+	Tag:           "bytes,10016,opt,name=extension_optional_child_message",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionOptionalNamedGroup = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*Message_NamedGroup)(nil),
+	Field:         10017,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_optional_named_group",
+	Tag:           "bytes,10017,opt,name=extension_optional_named_group",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionOptionalSiblingEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*SiblingEnum)(nil),
+	Field:         10018,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_optional_sibling_enum",
+	Tag:           "varint,10018,opt,name=extension_optional_sibling_enum,enum=google.golang.org.proto2_20190205.SiblingEnum",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionOptionalSiblingMessage = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*SiblingMessage)(nil),
+	Field:         10019,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_optional_sibling_message",
+	Tag:           "bytes,10019,opt,name=extension_optional_sibling_message",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_Extensionoptionalgroup = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*Message_ExtensionOptionalGroup)(nil),
+	Field:         10020,
+	Name:          "google.golang.org.proto2_20190205.Message.extensionoptionalgroup",
+	Tag:           "group,10020,opt,name=ExtensionOptionalGroup",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionDefaultedBool = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*bool)(nil),
+	Field:         20000,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_defaulted_bool",
+	Tag:           "varint,20000,opt,name=extension_defaulted_bool,def=1",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionDefaultedInt32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         20001,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_defaulted_int32",
+	Tag:           "varint,20001,opt,name=extension_defaulted_int32,def=-12345",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionDefaultedSint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         20002,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_defaulted_sint32",
+	Tag:           "zigzag32,20002,opt,name=extension_defaulted_sint32,def=-3200",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionDefaultedUint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint32)(nil),
+	Field:         20003,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_defaulted_uint32",
+	Tag:           "varint,20003,opt,name=extension_defaulted_uint32,def=3200",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionDefaultedInt64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         20004,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_defaulted_int64",
+	Tag:           "varint,20004,opt,name=extension_defaulted_int64,def=-123456789",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionDefaultedSint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         20005,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_defaulted_sint64",
+	Tag:           "zigzag64,20005,opt,name=extension_defaulted_sint64,def=-6400",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionDefaultedUint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint64)(nil),
+	Field:         20006,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_defaulted_uint64",
+	Tag:           "varint,20006,opt,name=extension_defaulted_uint64,def=6400",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionDefaultedFixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint32)(nil),
+	Field:         20007,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_defaulted_fixed32",
+	Tag:           "fixed32,20007,opt,name=extension_defaulted_fixed32,def=320000",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionDefaultedSfixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         20008,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_defaulted_sfixed32",
+	Tag:           "fixed32,20008,opt,name=extension_defaulted_sfixed32,def=-320000",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionDefaultedFloat = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*float32)(nil),
+	Field:         20009,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_defaulted_float",
+	Tag:           "fixed32,20009,opt,name=extension_defaulted_float,def=3.14159",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionDefaultedFixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*uint64)(nil),
+	Field:         20010,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_defaulted_fixed64",
+	Tag:           "fixed64,20010,opt,name=extension_defaulted_fixed64,def=640000",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionDefaultedSfixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*int64)(nil),
+	Field:         20011,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_defaulted_sfixed64",
+	Tag:           "fixed64,20011,opt,name=extension_defaulted_sfixed64,def=-640000",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionDefaultedDouble = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*float64)(nil),
+	Field:         20012,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_defaulted_double",
+	Tag:           "fixed64,20012,opt,name=extension_defaulted_double,def=3.14159265359",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionDefaultedString = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*string)(nil),
+	Field:         20013,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_defaulted_string",
+	Tag:           "bytes,20013,opt,name=extension_defaulted_string,def=hello, \"world!\"\n",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionDefaultedBytes = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]byte)(nil),
+	Field:         20014,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_defaulted_bytes",
+	Tag:           "bytes,20014,opt,name=extension_defaulted_bytes,def=dead\\336\\255\\276\\357beef",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionDefaultedChildEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*Message_ChildEnum)(nil),
+	Field:         20015,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_defaulted_child_enum",
+	Tag:           "varint,20015,opt,name=extension_defaulted_child_enum,enum=google.golang.org.proto2_20190205.Message_ChildEnum,def=0",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionDefaultedSiblingEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: (*SiblingEnum)(nil),
+	Field:         20016,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_defaulted_sibling_enum",
+	Tag:           "varint,20016,opt,name=extension_defaulted_sibling_enum,enum=google.golang.org.proto2_20190205.SiblingEnum,def=0",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionRepeatedBool = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]bool)(nil),
+	Field:         30000,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_repeated_bool",
+	Tag:           "varint,30000,rep,name=extension_repeated_bool",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionRepeatedInt32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int32)(nil),
+	Field:         30001,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_repeated_int32",
+	Tag:           "varint,30001,rep,name=extension_repeated_int32",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionRepeatedSint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int32)(nil),
+	Field:         30002,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_repeated_sint32",
+	Tag:           "zigzag32,30002,rep,name=extension_repeated_sint32",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionRepeatedUint32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]uint32)(nil),
+	Field:         30003,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_repeated_uint32",
+	Tag:           "varint,30003,rep,name=extension_repeated_uint32",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionRepeatedInt64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int64)(nil),
+	Field:         30004,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_repeated_int64",
+	Tag:           "varint,30004,rep,name=extension_repeated_int64",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionRepeatedSint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int64)(nil),
+	Field:         30005,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_repeated_sint64",
+	Tag:           "zigzag64,30005,rep,name=extension_repeated_sint64",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionRepeatedUint64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]uint64)(nil),
+	Field:         30006,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_repeated_uint64",
+	Tag:           "varint,30006,rep,name=extension_repeated_uint64",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionRepeatedFixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]uint32)(nil),
+	Field:         30007,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_repeated_fixed32",
+	Tag:           "fixed32,30007,rep,name=extension_repeated_fixed32",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionRepeatedSfixed32 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int32)(nil),
+	Field:         30008,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_repeated_sfixed32",
+	Tag:           "fixed32,30008,rep,name=extension_repeated_sfixed32",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionRepeatedFloat = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]float32)(nil),
+	Field:         30009,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_repeated_float",
+	Tag:           "fixed32,30009,rep,name=extension_repeated_float",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionRepeatedFixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]uint64)(nil),
+	Field:         30010,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_repeated_fixed64",
+	Tag:           "fixed64,30010,rep,name=extension_repeated_fixed64",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionRepeatedSfixed64 = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]int64)(nil),
+	Field:         30011,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_repeated_sfixed64",
+	Tag:           "fixed64,30011,rep,name=extension_repeated_sfixed64",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionRepeatedDouble = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]float64)(nil),
+	Field:         30012,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_repeated_double",
+	Tag:           "fixed64,30012,rep,name=extension_repeated_double",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionRepeatedString = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]string)(nil),
+	Field:         30013,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_repeated_string",
+	Tag:           "bytes,30013,rep,name=extension_repeated_string",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionRepeatedBytes = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([][]byte)(nil),
+	Field:         30014,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_repeated_bytes",
+	Tag:           "bytes,30014,rep,name=extension_repeated_bytes",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionRepeatedChildEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]Message_ChildEnum)(nil),
+	Field:         30015,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_repeated_child_enum",
+	Tag:           "varint,30015,rep,name=extension_repeated_child_enum,enum=google.golang.org.proto2_20190205.Message_ChildEnum",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionRepeatedChildMessage = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]*Message_ChildMessage)(nil),
+	Field:         30016,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_repeated_child_message",
+	Tag:           "bytes,30016,rep,name=extension_repeated_child_message",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionRepeatedNamedGroup = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]*Message_NamedGroup)(nil),
+	Field:         30017,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_repeated_named_group",
+	Tag:           "bytes,30017,rep,name=extension_repeated_named_group",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionRepeatedSiblingEnum = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]SiblingEnum)(nil),
+	Field:         30018,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_repeated_sibling_enum",
+	Tag:           "varint,30018,rep,name=extension_repeated_sibling_enum,enum=google.golang.org.proto2_20190205.SiblingEnum",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_ExtensionRepeatedSiblingMessage = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]*SiblingMessage)(nil),
+	Field:         30019,
+	Name:          "google.golang.org.proto2_20190205.Message.extension_repeated_sibling_message",
+	Tag:           "bytes,30019,rep,name=extension_repeated_sibling_message",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+var E_Message_Extensionrepeatedgroup = &proto.ExtensionDesc{
+	ExtendedType:  (*Message)(nil),
+	ExtensionType: ([]*Message_ExtensionRepeatedGroup)(nil),
+	Field:         30020,
+	Name:          "google.golang.org.proto2_20190205.Message.extensionrepeatedgroup",
+	Tag:           "group,30020,rep,name=ExtensionRepeatedGroup",
+	Filename:      "proto2_20190205_c823c79e/test.proto",
+}
+
+type Message_ChildMessage 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"`
+	F4                   *Message `protobuf:"bytes,4,opt,name=f4" json:"f4,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Message_ChildMessage) Reset()         { *m = Message_ChildMessage{} }
+func (m *Message_ChildMessage) String() string { return proto.CompactTextString(m) }
+func (*Message_ChildMessage) ProtoMessage()    {}
+func (*Message_ChildMessage) Descriptor() ([]byte, []int) {
+	return fileDescriptor_3a17e2c63b2b3424, []int{1, 0}
+}
+
+func (m *Message_ChildMessage) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Message_ChildMessage.Unmarshal(m, b)
+}
+func (m *Message_ChildMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Message_ChildMessage.Marshal(b, m, deterministic)
+}
+func (m *Message_ChildMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Message_ChildMessage.Merge(m, src)
+}
+func (m *Message_ChildMessage) XXX_Size() int {
+	return xxx_messageInfo_Message_ChildMessage.Size(m)
+}
+func (m *Message_ChildMessage) XXX_DiscardUnknown() {
+	xxx_messageInfo_Message_ChildMessage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message_ChildMessage proto.InternalMessageInfo
+
+func (m *Message_ChildMessage) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_ChildMessage) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_ChildMessage) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+func (m *Message_ChildMessage) GetF4() *Message {
+	if m != nil {
+		return m.F4
+	}
+	return nil
+}
+
+type Message_NamedGroup 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"`
+	F4                   *Message `protobuf:"bytes,4,opt,name=f4" json:"f4,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Message_NamedGroup) Reset()         { *m = Message_NamedGroup{} }
+func (m *Message_NamedGroup) String() string { return proto.CompactTextString(m) }
+func (*Message_NamedGroup) ProtoMessage()    {}
+func (*Message_NamedGroup) Descriptor() ([]byte, []int) {
+	return fileDescriptor_3a17e2c63b2b3424, []int{1, 1}
+}
+
+func (m *Message_NamedGroup) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Message_NamedGroup.Unmarshal(m, b)
+}
+func (m *Message_NamedGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Message_NamedGroup.Marshal(b, m, deterministic)
+}
+func (m *Message_NamedGroup) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Message_NamedGroup.Merge(m, src)
+}
+func (m *Message_NamedGroup) XXX_Size() int {
+	return xxx_messageInfo_Message_NamedGroup.Size(m)
+}
+func (m *Message_NamedGroup) XXX_DiscardUnknown() {
+	xxx_messageInfo_Message_NamedGroup.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message_NamedGroup proto.InternalMessageInfo
+
+func (m *Message_NamedGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_NamedGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_NamedGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+func (m *Message_NamedGroup) GetF4() *Message {
+	if m != nil {
+		return m.F4
+	}
+	return nil
+}
+
+type Message_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 (m *Message_OptionalGroup) Reset()         { *m = Message_OptionalGroup{} }
+func (m *Message_OptionalGroup) String() string { return proto.CompactTextString(m) }
+func (*Message_OptionalGroup) ProtoMessage()    {}
+func (*Message_OptionalGroup) Descriptor() ([]byte, []int) {
+	return fileDescriptor_3a17e2c63b2b3424, []int{1, 2}
+}
+
+func (m *Message_OptionalGroup) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Message_OptionalGroup.Unmarshal(m, b)
+}
+func (m *Message_OptionalGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Message_OptionalGroup.Marshal(b, m, deterministic)
+}
+func (m *Message_OptionalGroup) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Message_OptionalGroup.Merge(m, src)
+}
+func (m *Message_OptionalGroup) XXX_Size() int {
+	return xxx_messageInfo_Message_OptionalGroup.Size(m)
+}
+func (m *Message_OptionalGroup) XXX_DiscardUnknown() {
+	xxx_messageInfo_Message_OptionalGroup.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message_OptionalGroup proto.InternalMessageInfo
+
+func (m *Message_OptionalGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_OptionalGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_OptionalGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message_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 (m *Message_RequiredGroup) Reset()         { *m = Message_RequiredGroup{} }
+func (m *Message_RequiredGroup) String() string { return proto.CompactTextString(m) }
+func (*Message_RequiredGroup) ProtoMessage()    {}
+func (*Message_RequiredGroup) Descriptor() ([]byte, []int) {
+	return fileDescriptor_3a17e2c63b2b3424, []int{1, 3}
+}
+
+func (m *Message_RequiredGroup) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Message_RequiredGroup.Unmarshal(m, b)
+}
+func (m *Message_RequiredGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Message_RequiredGroup.Marshal(b, m, deterministic)
+}
+func (m *Message_RequiredGroup) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Message_RequiredGroup.Merge(m, src)
+}
+func (m *Message_RequiredGroup) XXX_Size() int {
+	return xxx_messageInfo_Message_RequiredGroup.Size(m)
+}
+func (m *Message_RequiredGroup) XXX_DiscardUnknown() {
+	xxx_messageInfo_Message_RequiredGroup.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message_RequiredGroup proto.InternalMessageInfo
+
+func (m *Message_RequiredGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_RequiredGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_RequiredGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message_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 (m *Message_RepeatedGroup) Reset()         { *m = Message_RepeatedGroup{} }
+func (m *Message_RepeatedGroup) String() string { return proto.CompactTextString(m) }
+func (*Message_RepeatedGroup) ProtoMessage()    {}
+func (*Message_RepeatedGroup) Descriptor() ([]byte, []int) {
+	return fileDescriptor_3a17e2c63b2b3424, []int{1, 4}
+}
+
+func (m *Message_RepeatedGroup) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Message_RepeatedGroup.Unmarshal(m, b)
+}
+func (m *Message_RepeatedGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Message_RepeatedGroup.Marshal(b, m, deterministic)
+}
+func (m *Message_RepeatedGroup) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Message_RepeatedGroup.Merge(m, src)
+}
+func (m *Message_RepeatedGroup) XXX_Size() int {
+	return xxx_messageInfo_Message_RepeatedGroup.Size(m)
+}
+func (m *Message_RepeatedGroup) XXX_DiscardUnknown() {
+	xxx_messageInfo_Message_RepeatedGroup.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message_RepeatedGroup proto.InternalMessageInfo
+
+func (m *Message_RepeatedGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_RepeatedGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_RepeatedGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message_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 (m *Message_OneofGroup) Reset()         { *m = Message_OneofGroup{} }
+func (m *Message_OneofGroup) String() string { return proto.CompactTextString(m) }
+func (*Message_OneofGroup) ProtoMessage()    {}
+func (*Message_OneofGroup) Descriptor() ([]byte, []int) {
+	return fileDescriptor_3a17e2c63b2b3424, []int{1, 33}
+}
+
+func (m *Message_OneofGroup) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Message_OneofGroup.Unmarshal(m, b)
+}
+func (m *Message_OneofGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Message_OneofGroup.Marshal(b, m, deterministic)
+}
+func (m *Message_OneofGroup) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Message_OneofGroup.Merge(m, src)
+}
+func (m *Message_OneofGroup) XXX_Size() int {
+	return xxx_messageInfo_Message_OneofGroup.Size(m)
+}
+func (m *Message_OneofGroup) XXX_DiscardUnknown() {
+	xxx_messageInfo_Message_OneofGroup.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message_OneofGroup proto.InternalMessageInfo
+
+func (m *Message_OneofGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_OneofGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_OneofGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message_ExtensionOptionalGroup 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 (m *Message_ExtensionOptionalGroup) Reset()         { *m = Message_ExtensionOptionalGroup{} }
+func (m *Message_ExtensionOptionalGroup) String() string { return proto.CompactTextString(m) }
+func (*Message_ExtensionOptionalGroup) ProtoMessage()    {}
+func (*Message_ExtensionOptionalGroup) Descriptor() ([]byte, []int) {
+	return fileDescriptor_3a17e2c63b2b3424, []int{1, 34}
+}
+
+func (m *Message_ExtensionOptionalGroup) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Message_ExtensionOptionalGroup.Unmarshal(m, b)
+}
+func (m *Message_ExtensionOptionalGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Message_ExtensionOptionalGroup.Marshal(b, m, deterministic)
+}
+func (m *Message_ExtensionOptionalGroup) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Message_ExtensionOptionalGroup.Merge(m, src)
+}
+func (m *Message_ExtensionOptionalGroup) XXX_Size() int {
+	return xxx_messageInfo_Message_ExtensionOptionalGroup.Size(m)
+}
+func (m *Message_ExtensionOptionalGroup) XXX_DiscardUnknown() {
+	xxx_messageInfo_Message_ExtensionOptionalGroup.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message_ExtensionOptionalGroup proto.InternalMessageInfo
+
+func (m *Message_ExtensionOptionalGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_ExtensionOptionalGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_ExtensionOptionalGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message_ExtensionRepeatedGroup 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 (m *Message_ExtensionRepeatedGroup) Reset()         { *m = Message_ExtensionRepeatedGroup{} }
+func (m *Message_ExtensionRepeatedGroup) String() string { return proto.CompactTextString(m) }
+func (*Message_ExtensionRepeatedGroup) ProtoMessage()    {}
+func (*Message_ExtensionRepeatedGroup) Descriptor() ([]byte, []int) {
+	return fileDescriptor_3a17e2c63b2b3424, []int{1, 35}
+}
+
+func (m *Message_ExtensionRepeatedGroup) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Message_ExtensionRepeatedGroup.Unmarshal(m, b)
+}
+func (m *Message_ExtensionRepeatedGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Message_ExtensionRepeatedGroup.Marshal(b, m, deterministic)
+}
+func (m *Message_ExtensionRepeatedGroup) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Message_ExtensionRepeatedGroup.Merge(m, src)
+}
+func (m *Message_ExtensionRepeatedGroup) XXX_Size() int {
+	return xxx_messageInfo_Message_ExtensionRepeatedGroup.Size(m)
+}
+func (m *Message_ExtensionRepeatedGroup) XXX_DiscardUnknown() {
+	xxx_messageInfo_Message_ExtensionRepeatedGroup.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message_ExtensionRepeatedGroup proto.InternalMessageInfo
+
+func (m *Message_ExtensionRepeatedGroup) GetF1() string {
+	if m != nil && m.F1 != nil {
+		return *m.F1
+	}
+	return ""
+}
+
+func (m *Message_ExtensionRepeatedGroup) GetF2() string {
+	if m != nil && m.F2 != nil {
+		return *m.F2
+	}
+	return ""
+}
+
+func (m *Message_ExtensionRepeatedGroup) GetF3() []string {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterEnum("google.golang.org.proto2_20190205.SiblingEnum", SiblingEnum_name, SiblingEnum_value)
+	proto.RegisterEnum("google.golang.org.proto2_20190205.Message_ChildEnum", Message_ChildEnum_name, Message_ChildEnum_value)
+	proto.RegisterType((*SiblingMessage)(nil), "google.golang.org.proto2_20190205.SiblingMessage")
+	proto.RegisterExtension(E_Message_ExtensionOptionalBool)
+	proto.RegisterExtension(E_Message_ExtensionOptionalInt32)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSint32)
+	proto.RegisterExtension(E_Message_ExtensionOptionalUint32)
+	proto.RegisterExtension(E_Message_ExtensionOptionalInt64)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSint64)
+	proto.RegisterExtension(E_Message_ExtensionOptionalUint64)
+	proto.RegisterExtension(E_Message_ExtensionOptionalFixed32)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSfixed32)
+	proto.RegisterExtension(E_Message_ExtensionOptionalFloat)
+	proto.RegisterExtension(E_Message_ExtensionOptionalFixed64)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSfixed64)
+	proto.RegisterExtension(E_Message_ExtensionOptionalDouble)
+	proto.RegisterExtension(E_Message_ExtensionOptionalString)
+	proto.RegisterExtension(E_Message_ExtensionOptionalBytes)
+	proto.RegisterExtension(E_Message_ExtensionOptionalChildEnum)
+	proto.RegisterExtension(E_Message_ExtensionOptionalChildMessage)
+	proto.RegisterExtension(E_Message_ExtensionOptionalNamedGroup)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSiblingEnum)
+	proto.RegisterExtension(E_Message_ExtensionOptionalSiblingMessage)
+	proto.RegisterExtension(E_Message_Extensionoptionalgroup)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedBool)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedInt32)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedSint32)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedUint32)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedInt64)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedSint64)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedUint64)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedFixed32)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedSfixed32)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedFloat)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedFixed64)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedSfixed64)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedDouble)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedString)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedBytes)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedChildEnum)
+	proto.RegisterExtension(E_Message_ExtensionDefaultedSiblingEnum)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedBool)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedInt32)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSint32)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedUint32)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedInt64)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSint64)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedUint64)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedFixed32)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSfixed32)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedFloat)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedFixed64)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSfixed64)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedDouble)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedString)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedBytes)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedChildEnum)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedChildMessage)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedNamedGroup)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSiblingEnum)
+	proto.RegisterExtension(E_Message_ExtensionRepeatedSiblingMessage)
+	proto.RegisterExtension(E_Message_Extensionrepeatedgroup)
+	proto.RegisterType((*Message)(nil), "google.golang.org.proto2_20190205.Message")
+	proto.RegisterMapType((map[bool]bool)(nil), "google.golang.org.proto2_20190205.Message.MapBoolBoolEntry")
+	proto.RegisterMapType((map[bool][]byte)(nil), "google.golang.org.proto2_20190205.Message.MapBoolBytesEntry")
+	proto.RegisterMapType((map[bool]Message_ChildEnum)(nil), "google.golang.org.proto2_20190205.Message.MapBoolChildEnumEntry")
+	proto.RegisterMapType((map[bool]*Message_ChildMessage)(nil), "google.golang.org.proto2_20190205.Message.MapBoolChildMessageEntry")
+	proto.RegisterMapType((map[bool]float64)(nil), "google.golang.org.proto2_20190205.Message.MapBoolDoubleEntry")
+	proto.RegisterMapType((map[bool]uint32)(nil), "google.golang.org.proto2_20190205.Message.MapBoolFixed32Entry")
+	proto.RegisterMapType((map[bool]uint64)(nil), "google.golang.org.proto2_20190205.Message.MapBoolFixed64Entry")
+	proto.RegisterMapType((map[bool]float32)(nil), "google.golang.org.proto2_20190205.Message.MapBoolFloatEntry")
+	proto.RegisterMapType((map[bool]int32)(nil), "google.golang.org.proto2_20190205.Message.MapBoolInt32Entry")
+	proto.RegisterMapType((map[bool]int64)(nil), "google.golang.org.proto2_20190205.Message.MapBoolInt64Entry")
+	proto.RegisterMapType((map[bool]*Message_NamedGroup)(nil), "google.golang.org.proto2_20190205.Message.MapBoolNamedGroupEntry")
+	proto.RegisterMapType((map[bool]int32)(nil), "google.golang.org.proto2_20190205.Message.MapBoolSfixed32Entry")
+	proto.RegisterMapType((map[bool]int64)(nil), "google.golang.org.proto2_20190205.Message.MapBoolSfixed64Entry")
+	proto.RegisterMapType((map[bool]SiblingEnum)(nil), "google.golang.org.proto2_20190205.Message.MapBoolSiblingEnumEntry")
+	proto.RegisterMapType((map[bool]*SiblingMessage)(nil), "google.golang.org.proto2_20190205.Message.MapBoolSiblingMessageEntry")
+	proto.RegisterMapType((map[bool]int32)(nil), "google.golang.org.proto2_20190205.Message.MapBoolSint32Entry")
+	proto.RegisterMapType((map[bool]int64)(nil), "google.golang.org.proto2_20190205.Message.MapBoolSint64Entry")
+	proto.RegisterMapType((map[bool]string)(nil), "google.golang.org.proto2_20190205.Message.MapBoolStringEntry")
+	proto.RegisterMapType((map[bool]uint32)(nil), "google.golang.org.proto2_20190205.Message.MapBoolUint32Entry")
+	proto.RegisterMapType((map[bool]uint64)(nil), "google.golang.org.proto2_20190205.Message.MapBoolUint64Entry")
+	proto.RegisterMapType((map[uint32]bool)(nil), "google.golang.org.proto2_20190205.Message.MapFixed32BoolEntry")
+	proto.RegisterMapType((map[int32]bool)(nil), "google.golang.org.proto2_20190205.Message.MapInt32BoolEntry")
+	proto.RegisterMapType((map[int64]bool)(nil), "google.golang.org.proto2_20190205.Message.MapInt64BoolEntry")
+	proto.RegisterMapType((map[int32]bool)(nil), "google.golang.org.proto2_20190205.Message.MapSint32BoolEntry")
+	proto.RegisterMapType((map[int64]bool)(nil), "google.golang.org.proto2_20190205.Message.MapSint64BoolEntry")
+	proto.RegisterMapType((map[string]bool)(nil), "google.golang.org.proto2_20190205.Message.MapStringBoolEntry")
+	proto.RegisterMapType((map[uint32]bool)(nil), "google.golang.org.proto2_20190205.Message.MapUint32BoolEntry")
+	proto.RegisterMapType((map[uint64]bool)(nil), "google.golang.org.proto2_20190205.Message.MapUint64BoolEntry")
+	proto.RegisterType((*Message_ChildMessage)(nil), "google.golang.org.proto2_20190205.Message.ChildMessage")
+	proto.RegisterType((*Message_NamedGroup)(nil), "google.golang.org.proto2_20190205.Message.NamedGroup")
+	proto.RegisterType((*Message_OptionalGroup)(nil), "google.golang.org.proto2_20190205.Message.OptionalGroup")
+	proto.RegisterType((*Message_RequiredGroup)(nil), "google.golang.org.proto2_20190205.Message.RequiredGroup")
+	proto.RegisterType((*Message_RepeatedGroup)(nil), "google.golang.org.proto2_20190205.Message.RepeatedGroup")
+	proto.RegisterType((*Message_OneofGroup)(nil), "google.golang.org.proto2_20190205.Message.OneofGroup")
+	proto.RegisterType((*Message_ExtensionOptionalGroup)(nil), "google.golang.org.proto2_20190205.Message.ExtensionOptionalGroup")
+	proto.RegisterType((*Message_ExtensionRepeatedGroup)(nil), "google.golang.org.proto2_20190205.Message.ExtensionRepeatedGroup")
+}
+
+func init() {
+	proto.RegisterFile("proto2_20190205_c823c79e/test.proto", fileDescriptor_3a17e2c63b2b3424)
+}
+
+var fileDescriptor_3a17e2c63b2b3424 = []byte{
+	// 4469 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x5c, 0x67, 0x70, 0x24, 0xc7,
+	0x75, 0xc6, 0xec, 0x62, 0x17, 0x87, 0x3e, 0x2c, 0xb0, 0x98, 0xbb, 0x03, 0xe6, 0x40, 0xd2, 0x5c,
+	0x41, 0xb2, 0xbc, 0xa6, 0x79, 0x38, 0x60, 0xd0, 0xe8, 0xe3, 0xad, 0x19, 0x04, 0x90, 0x47, 0x2d,
+	0x65, 0x71, 0xa9, 0x1a, 0xd6, 0xb9, 0x5c, 0x2e, 0x96, 0x61, 0xdc, 0x61, 0x81, 0x03, 0xb9, 0x01,
+	0x04, 0x76, 0x49, 0x9e, 0x25, 0x17, 0xcf, 0x72, 0xfc, 0x49, 0xe5, 0xb4, 0x92, 0x28, 0x66, 0x89,
+	0x51, 0x39, 0x31, 0x29, 0xd8, 0xa6, 0x72, 0x72, 0x90, 0x93, 0x9c, 0x93, 0x9c, 0x73, 0x0e, 0xd5,
+	0xfd, 0xba, 0xa7, 0xbb, 0x67, 0x7a, 0x16, 0xe8, 0x59, 0x15, 0x7f, 0xb0, 0x8a, 0xd7, 0xfb, 0xfa,
+	0x7d, 0xfd, 0xbe, 0xed, 0xf7, 0xde, 0x87, 0x9e, 0xe9, 0x45, 0x2f, 0xdd, 0xde, 0x69, 0x77, 0xda,
+	0xfe, 0xaa, 0x3f, 0xbf, 0x70, 0x72, 0xde, 0x9f, 0x5f, 0x5a, 0x3d, 0x7b, 0x85, 0xbf, 0x78, 0xf6,
+	0xc4, 0xc9, 0xfa, 0xf1, 0x4e, 0x7d, 0xb7, 0x33, 0xc7, 0x3e, 0x75, 0x5f, 0xb2, 0xd9, 0x6e, 0x6f,
+	0x36, 0xea, 0x73, 0x9b, 0xed, 0xc6, 0x5a, 0x6b, 0x73, 0xae, 0xbd, 0xb3, 0x39, 0x17, 0x99, 0x36,
+	0xfb, 0x3a, 0x34, 0x7e, 0xf3, 0xd6, 0x99, 0xc6, 0x56, 0x6b, 0xf3, 0xc6, 0xfa, 0xee, 0xee, 0xda,
+	0x66, 0xdd, 0x1d, 0x47, 0x99, 0x8d, 0x05, 0xcf, 0x29, 0x39, 0xe5, 0xd1, 0x20, 0xb3, 0xb1, 0xc0,
+	0xfe, 0xed, 0x7b, 0x99, 0x52, 0x86, 0xfd, 0xdb, 0x67, 0xff, 0x5e, 0xf4, 0xb2, 0xa5, 0x2c, 0xfb,
+	0xf7, 0xa2, 0x5b, 0x41, 0x99, 0x0d, 0xec, 0x0d, 0x97, 0x9c, 0xf2, 0x41, 0xff, 0xb2, 0xb9, 0x3d,
+	0x11, 0xe7, 0x38, 0x4e, 0x90, 0xd9, 0xc0, 0xb3, 0xdf, 0x79, 0xd4, 0x41, 0x23, 0x02, 0xf8, 0x34,
+	0x42, 0xad, 0xb5, 0x66, 0x7d, 0x7d, 0x73, 0xa7, 0xdd, 0xdd, 0x66, 0x0b, 0x40, 0xfe, 0xd2, 0xfe,
+	0x1d, 0xce, 0xd5, 0xe8, 0xe4, 0x57, 0xd2, 0xc9, 0x81, 0xe2, 0xc8, 0x7d, 0x29, 0x2a, 0xb4, 0xb7,
+	0x3b, 0x5b, 0xed, 0xd6, 0x5a, 0x63, 0xf5, 0x4c, 0xbb, 0xdd, 0xf0, 0xd6, 0x4b, 0x4e, 0xf9, 0x40,
+	0x30, 0x26, 0x06, 0x57, 0xda, 0xed, 0x86, 0xfb, 0xfd, 0x68, 0x3c, 0x34, 0xda, 0x6a, 0x75, 0x16,
+	0x7d, 0xaf, 0x5e, 0x72, 0xca, 0xb9, 0x20, 0x9c, 0x7a, 0x03, 0x1d, 0x74, 0x7f, 0x00, 0x4d, 0x84,
+	0x66, 0xbb, 0x60, 0xb7, 0x51, 0x72, 0xca, 0x93, 0x41, 0x38, 0xfb, 0xe6, 0xad, 0x98, 0x61, 0x17,
+	0x0c, 0x37, 0x4b, 0x4e, 0xb9, 0x20, 0x0d, 0x4f, 0x83, 0x61, 0x04, 0x98, 0x60, 0xef, 0x5c, 0xc9,
+	0x29, 0x67, 0x35, 0x60, 0x82, 0x63, 0xc0, 0x04, 0x7b, 0x5b, 0x25, 0xa7, 0xec, 0xea, 0xc0, 0x11,
+	0xc3, 0x2e, 0x18, 0xde, 0x5a, 0x72, 0xca, 0xc3, 0x3a, 0x30, 0xc1, 0xee, 0x0f, 0xa2, 0x62, 0x68,
+	0xb8, 0xb1, 0x75, 0x57, 0x7d, 0x7d, 0xd1, 0xf7, 0x6e, 0x2b, 0x39, 0xe5, 0x91, 0x20, 0x74, 0x70,
+	0x3d, 0x0c, 0xbb, 0x3f, 0x84, 0x26, 0x25, 0xb8, 0xb0, 0x6d, 0x94, 0x9c, 0xf2, 0x44, 0x10, 0xfa,
+	0xb8, 0x99, 0x8f, 0x6b, 0x01, 0x6d, 0x34, 0xda, 0x6b, 0x1d, 0xaf, 0x59, 0x72, 0xca, 0x19, 0x19,
+	0xd0, 0xf5, 0x74, 0x30, 0x0e, 0x4f, 0xb0, 0xd7, 0x2a, 0x39, 0xe5, 0x7c, 0x04, 0x9e, 0x60, 0x03,
+	0x3c, 0xc1, 0x5e, 0xbb, 0xe4, 0x94, 0x8b, 0x51, 0xf8, 0x48, 0xfc, 0xeb, 0xed, 0xee, 0x99, 0x46,
+	0xdd, 0xdb, 0x2e, 0x39, 0x65, 0x47, 0xc6, 0x7f, 0x1d, 0x1b, 0xd5, 0x19, 0xed, 0xec, 0x6c, 0xb5,
+	0x36, 0xbd, 0xdb, 0xd9, 0x9e, 0x97, 0x8c, 0xb2, 0x51, 0x2d, 0xa0, 0x33, 0xe7, 0x3b, 0xf5, 0x5d,
+	0x6f, 0xa7, 0xe4, 0x94, 0xc7, 0x64, 0x40, 0x2b, 0x74, 0xd0, 0x5d, 0x47, 0x87, 0x42, 0xb3, 0xb3,
+	0xe7, 0xb6, 0x1a, 0xeb, 0xab, 0xf5, 0x56, 0xb7, 0xe9, 0xed, 0x96, 0x9c, 0xf2, 0xb8, 0x8f, 0x2d,
+	0xb6, 0xf1, 0xb5, 0x74, 0xf2, 0xa9, 0x56, 0xb7, 0x19, 0x84, 0x61, 0x87, 0x43, 0x6e, 0x13, 0x4d,
+	0x45, 0x50, 0x9a, 0x30, 0xcd, 0xeb, 0xb0, 0x04, 0x3c, 0x61, 0x0b, 0x24, 0xb2, 0xf1, 0xb0, 0x86,
+	0x25, 0x52, 0x72, 0x13, 0x85, 0xe3, 0xab, 0x2c, 0xa5, 0x56, 0x21, 0x39, 0xbb, 0x0c, 0x2c, 0x65,
+	0x72, 0xba, 0xc2, 0xa5, 0x1c, 0x73, 0xcf, 0xa0, 0x23, 0xca, 0xfe, 0x66, 0xf5, 0x08, 0xf8, 0xbb,
+	0x83, 0xf1, 0x37, 0xb7, 0x0f, 0x24, 0x5e, 0xc6, 0x18, 0x73, 0x87, 0x64, 0x56, 0x84, 0x83, 0xee,
+	0x6d, 0xc8, 0x8b, 0x61, 0x08, 0xf6, 0xee, 0x64, 0x01, 0x2d, 0xec, 0x1f, 0x46, 0xf0, 0x36, 0x15,
+	0x41, 0x12, 0xcc, 0xfd, 0x84, 0xac, 0x3a, 0x40, 0xd9, 0x5d, 0xac, 0x9e, 0x5d, 0x61, 0x41, 0xd9,
+	0x4d, 0x7c, 0x3e, 0xb0, 0xa6, 0xbb, 0x73, 0x2f, 0x47, 0xe3, 0xeb, 0xf5, 0x8d, 0xb5, 0x6e, 0xa3,
+	0x53, 0x5f, 0x87, 0xb2, 0xf6, 0x02, 0xad, 0x98, 0x07, 0x2a, 0xc3, 0x9d, 0x9d, 0x6e, 0x3d, 0x28,
+	0x84, 0x1f, 0xb2, 0xf2, 0x36, 0x8f, 0x26, 0xa4, 0x35, 0x94, 0xa3, 0x2f, 0x50, 0xf3, 0x5c, 0x25,
+	0x7f, 0x6c, 0xc1, 0x5f, 0xc4, 0x4b, 0x81, 0xf4, 0x06, 0x95, 0x6e, 0x01, 0x15, 0xe5, 0x0c, 0x5e,
+	0xea, 0xbe, 0x48, 0xa7, 0x4c, 0x56, 0x72, 0xc7, 0x16, 0xfd, 0xf9, 0xf9, 0x40, 0x7a, 0xe4, 0x35,
+	0x6f, 0x5e, 0x9d, 0xc2, 0x8b, 0xde, 0x97, 0xe8, 0x94, 0x42, 0x65, 0x38, 0x32, 0x83, 0x17, 0x3f,
+	0x1c, 0x59, 0x16, 0xc1, 0xde, 0x97, 0xe9, 0x84, 0x6c, 0x05, 0xc1, 0xb2, 0xc8, 0x89, 0x2b, 0x4e,
+	0xea, 0x4b, 0x23, 0x38, 0xbe, 0x34, 0x82, 0xbd, 0xaf, 0xd0, 0x69, 0x6e, 0x25, 0x77, 0x8c, 0xe0,
+	0xd8, 0xd2, 0x08, 0x8e, 0x2f, 0x8d, 0x60, 0xef, 0xab, 0x74, 0xca, 0x70, 0x65, 0x38, 0x32, 0x83,
+	0x97, 0x47, 0x8c, 0x26, 0xe5, 0x0c, 0x51, 0xf3, 0xbe, 0x46, 0xa7, 0x8c, 0x54, 0xf2, 0x34, 0x9a,
+	0xf9, 0xf9, 0x40, 0xfa, 0x14, 0x95, 0xf2, 0x04, 0x72, 0x95, 0xa5, 0x89, 0x69, 0x5f, 0xa7, 0xd3,
+	0x26, 0x2a, 0x23, 0xc7, 0xf8, 0x3c, 0xe9, 0x39, 0xac, 0x9a, 0x0b, 0x2a, 0x13, 0x50, 0x36, 0xbf,
+	0x41, 0x67, 0x65, 0x2a, 0x23, 0x8b, 0x73, 0x0b, 0x78, 0x61, 0x49, 0xa5, 0x01, 0x2a, 0x68, 0x7c,
+	0x85, 0x04, 0x7b, 0xdf, 0xa4, 0x93, 0xf2, 0x95, 0x3c, 0x0d, 0x2a, 0xbe, 0x42, 0x82, 0x4d, 0x2b,
+	0x24, 0xd8, 0xfb, 0x16, 0x9d, 0x56, 0xac, 0x8c, 0x1c, 0xe3, 0xf3, 0xa2, 0x2b, 0x24, 0xd8, 0x3d,
+	0xa9, 0x52, 0xc8, 0x2b, 0xeb, 0xaf, 0xd1, 0x69, 0x4e, 0xa5, 0xc0, 0x97, 0xe8, 0x93, 0xa5, 0xc5,
+	0xa5, 0x93, 0x0a, 0x97, 0xbc, 0xd4, 0x5e, 0xa9, 0x7d, 0x61, 0x50, 0x6b, 0x7f, 0x9d, 0x09, 0x8c,
+	0x4a, 0xf1, 0x5c, 0xbd, 0xd1, 0x68, 0x5f, 0x5e, 0x9a, 0xbd, 0xb3, 0xbd, 0xd3, 0x58, 0x7f, 0xc9,
+	0x2c, 0x52, 0xbf, 0x3b, 0xa8, 0xbf, 0x2b, 0x2a, 0x35, 0x50, 0x80, 0x7f, 0x83, 0x4e, 0x1e, 0xab,
+	0x78, 0xeb, 0xf5, 0xb5, 0xf5, 0x5b, 0x16, 0x17, 0xc9, 0x2d, 0xfe, 0xd2, 0xd2, 0x2d, 0xfe, 0x09,
+	0x72, 0xcb, 0xe2, 0xd2, 0x89, 0x33, 0xf5, 0xfa, 0x86, 0xc2, 0x15, 0x14, 0xe7, 0x16, 0x3a, 0x2c,
+	0x7d, 0x28, 0xd5, 0xf9, 0x37, 0x9d, 0xf4, 0xe5, 0xb9, 0x92, 0x5b, 0x7e, 0xf5, 0x6b, 0xaa, 0xcb,
+	0x81, 0xe4, 0x53, 0x96, 0xe9, 0x06, 0x9a, 0x52, 0xb7, 0xa8, 0x52, 0xcf, 0xbe, 0xed, 0xa4, 0x29,
+	0x68, 0x02, 0xeb, 0xb0, 0xb2, 0xb1, 0x65, 0x61, 0x7b, 0x19, 0x2a, 0xec, 0xd4, 0x6f, 0xef, 0x6e,
+	0xed, 0x88, 0x52, 0xf0, 0x18, 0x55, 0x6b, 0x07, 0x82, 0x31, 0x31, 0xca, 0x6a, 0xc0, 0xcb, 0xd1,
+	0x78, 0x68, 0x05, 0xc9, 0xf9, 0x38, 0x35, 0xcb, 0x05, 0xe1, 0x64, 0xc8, 0xfc, 0x32, 0x9a, 0x08,
+	0xed, 0x78, 0xe2, 0x3f, 0x41, 0x0d, 0x27, 0x83, 0x70, 0x3e, 0x4f, 0x78, 0xd5, 0x92, 0xe7, 0xfb,
+	0x93, 0xd4, 0xb2, 0x20, 0x2d, 0x79, 0xa2, 0x47, 0xb0, 0x09, 0xf6, 0x9e, 0xa2, 0x86, 0x59, 0x0d,
+	0x9b, 0xe0, 0x18, 0x36, 0xc1, 0xde, 0x07, 0xa9, 0xa1, 0xab, 0x63, 0x47, 0x2c, 0x79, 0x42, 0x7f,
+	0x88, 0x5a, 0x0e, 0xeb, 0xd8, 0x04, 0xbb, 0x97, 0xa1, 0x62, 0x68, 0x29, 0x32, 0xf2, 0xc3, 0xd4,
+	0x74, 0x24, 0x08, 0x5d, 0x88, 0xfc, 0xbd, 0x1c, 0x4d, 0x4a, 0x7c, 0x61, 0xfc, 0x11, 0x6a, 0x3c,
+	0x11, 0x84, 0x5e, 0xc2, 0xa4, 0x55, 0xa3, 0x82, 0x9c, 0xfd, 0x28, 0x35, 0xcd, 0xc8, 0xa8, 0x20,
+	0x53, 0x63, 0x2b, 0x20, 0xd8, 0xfb, 0x18, 0xb5, 0xcc, 0x47, 0x56, 0x40, 0xb0, 0x61, 0x05, 0x04,
+	0x7b, 0x1f, 0xa7, 0xc6, 0xc5, 0xe8, 0x0a, 0x22, 0x2c, 0xf0, 0x9c, 0xfc, 0x04, 0xb5, 0x75, 0x24,
+	0x0b, 0x3c, 0x07, 0x35, 0x66, 0x21, 0x05, 0x3f, 0x09, 0x9a, 0x5e, 0x32, 0x0b, 0xf9, 0xa6, 0x46,
+	0x05, 0xe9, 0xf6, 0x29, 0x6a, 0x38, 0x26, 0xa3, 0x82, 0x9c, 0xaa, 0xa3, 0x43, 0xa1, 0x9d, 0x92,
+	0x52, 0x9f, 0xa6, 0xc6, 0xa9, 0x15, 0x8f, 0xf0, 0x28, 0x53, 0xa9, 0x85, 0xa6, 0x22, 0x30, 0xa2,
+	0x67, 0x3f, 0x4d, 0x91, 0x06, 0x91, 0x3c, 0x1a, 0x98, 0x68, 0xdc, 0xe7, 0x50, 0x38, 0xae, 0x49,
+	0x9e, 0x67, 0x00, 0x2d, 0xad, 0xe6, 0x11, 0x3e, 0x15, 0xcd, 0x73, 0x16, 0x1d, 0x51, 0x36, 0xbb,
+	0x52, 0x23, 0x9e, 0x05, 0x0a, 0xad, 0x45, 0x8f, 0x4c, 0x11, 0x59, 0x1b, 0x1a, 0xc8, 0x8b, 0x81,
+	0x08, 0x02, 0x9f, 0x83, 0x90, 0xd2, 0xa8, 0x9e, 0x08, 0x94, 0x20, 0x6f, 0x55, 0x56, 0x22, 0x60,
+	0xed, 0x79, 0x0a, 0x61, 0x27, 0x7b, 0x02, 0xee, 0x80, 0xcb, 0x1e, 0xcd, 0x9f, 0x7b, 0x15, 0x9a,
+	0x96, 0x1b, 0x5e, 0xd7, 0x3f, 0xf7, 0x64, 0x69, 0xd1, 0xe3, 0xfa, 0x27, 0x64, 0xf6, 0x3a, 0x4d,
+	0x07, 0x2d, 0x2b, 0x6c, 0x44, 0x05, 0xd1, 0x1b, 0xe8, 0x7c, 0x29, 0x88, 0xa6, 0x62, 0x1e, 0xa0,
+	0x3c, 0xae, 0xa0, 0xa3, 0x06, 0x17, 0xbc, 0x50, 0xbe, 0x91, 0xfa, 0x08, 0x15, 0xd2, 0x74, 0xcc,
+	0x05, 0x2f, 0x9c, 0xcb, 0x46, 0x1f, 0xbc, 0x84, 0xbe, 0x89, 0xfa, 0x10, 0x92, 0x29, 0xee, 0x82,
+	0x57, 0xd4, 0x53, 0x49, 0x91, 0x10, 0xec, 0xbd, 0x99, 0x7a, 0xd0, 0x35, 0x94, 0x31, 0x1a, 0x82,
+	0xfb, 0x44, 0x43, 0xb0, 0xf7, 0x16, 0xea, 0x27, 0x14, 0x55, 0xe6, 0x68, 0x08, 0xee, 0x13, 0x0d,
+	0xc1, 0xde, 0x5b, 0xa9, 0x0f, 0xa1, 0xb2, 0xcc, 0xd1, 0x10, 0xec, 0x9e, 0x42, 0x33, 0x06, 0x17,
+	0xa2, 0x00, 0xbf, 0x8d, 0xfa, 0x90, 0xb2, 0xcb, 0x8b, 0x79, 0x11, 0xe5, 0xbb, 0x8a, 0x2e, 0x32,
+	0x45, 0x23, 0xfc, 0xbc, 0x9d, 0xfa, 0x51, 0x74, 0xd8, 0xd1, 0x78, 0x44, 0xa2, 0xb4, 0xaf, 0x18,
+	0xe9, 0x85, 0x22, 0xff, 0x0e, 0xea, 0x46, 0x11, 0x66, 0x71, 0x6e, 0xa1, 0xec, 0xf7, 0x09, 0x8a,
+	0x60, 0xef, 0x9d, 0xd4, 0x8b, 0x54, 0x6a, 0x09, 0x41, 0x11, 0xdc, 0x37, 0x28, 0x82, 0xbd, 0x77,
+	0x51, 0x3f, 0x8a, 0x74, 0x4b, 0x0a, 0x8a, 0x60, 0xf7, 0x55, 0xc6, 0x2f, 0x8a, 0xf7, 0x8d, 0x1e,
+	0xf5, 0x13, 0xd3, 0x72, 0xf1, 0x6f, 0x8c, 0xf7, 0x93, 0x1b, 0xcd, 0x1b, 0x07, 0x3a, 0xcb, 0xbb,
+	0xa9, 0x2f, 0x93, 0xb8, 0x33, 0xec, 0x21, 0x68, 0x3a, 0x37, 0x1b, 0xf9, 0x86, 0xf6, 0xf3, 0x1e,
+	0xea, 0xad, 0x9f, 0xda, 0x8b, 0x7f, 0x01, 0xd0, 0xa1, 0xee, 0x46, 0x97, 0x18, 0x9c, 0x2a, 0xbd,
+	0xea, 0xbd, 0xd9, 0xf4, 0xbd, 0x4a, 0x48, 0xb2, 0x99, 0x18, 0xb8, 0xec, 0x5d, 0x3f, 0x8d, 0x2e,
+	0x35, 0x66, 0x97, 0x52, 0xeb, 0xef, 0xcd, 0xa6, 0xa9, 0xf5, 0x02, 0xfc, 0x62, 0x43, 0x4e, 0x46,
+	0x74, 0xe1, 0x76, 0x7d, 0x2d, 0x2c, 0x91, 0xff, 0x9c, 0x2d, 0x65, 0x41, 0x17, 0xc2, 0xa8, 0xd4,
+	0x85, 0xdc, 0x0a, 0x2a, 0xd0, 0xbf, 0x50, 0x33, 0xa6, 0x0b, 0x61, 0x58, 0xd1, 0x85, 0xdc, 0x8e,
+	0x97, 0xbb, 0x7f, 0xa5, 0x86, 0x4c, 0x17, 0xc2, 0xb8, 0xaa, 0x0b, 0xb9, 0x25, 0x2f, 0x6a, 0xff,
+	0x46, 0x2d, 0x0b, 0xd2, 0x52, 0xd5, 0x85, 0x12, 0x9b, 0x60, 0xef, 0xdf, 0xa9, 0x61, 0x56, 0xc3,
+	0x16, 0x3a, 0x47, 0xc1, 0x26, 0xd8, 0xfb, 0x0f, 0x6a, 0xe8, 0xea, 0xd8, 0x11, 0x4b, 0x5e, 0x82,
+	0xfe, 0x93, 0x5a, 0x0e, 0xeb, 0xd8, 0x42, 0x17, 0x72, 0x4b, 0x51, 0x21, 0xfe, 0x8b, 0x9a, 0x32,
+	0x5d, 0x08, 0x1f, 0x68, 0xba, 0x50, 0xe0, 0x0b, 0xe3, 0xff, 0xa6, 0xc6, 0x4c, 0x17, 0xf2, 0x15,
+	0x68, 0xba, 0x50, 0x78, 0x66, 0x25, 0xe3, 0x7f, 0xa8, 0x69, 0x46, 0x46, 0xa5, 0xe8, 0x42, 0x75,
+	0x05, 0x04, 0x7b, 0xff, 0x4b, 0x2d, 0xf3, 0x91, 0x15, 0x08, 0x5d, 0xa8, 0xad, 0x80, 0x60, 0xef,
+	0xff, 0xa8, 0x71, 0x31, 0xba, 0x82, 0x08, 0x0b, 0x3c, 0xbf, 0x2f, 0x0c, 0x97, 0xb2, 0xa0, 0x0b,
+	0x61, 0x5c, 0xd5, 0x85, 0xc2, 0x2f, 0x64, 0xef, 0xcf, 0x0c, 0xb3, 0xb3, 0x5d, 0xc9, 0xac, 0xa2,
+	0x0b, 0xc5, 0x6e, 0x62, 0x89, 0xf9, 0x7a, 0x6a, 0x38, 0x26, 0xa3, 0x52, 0x74, 0x21, 0xb7, 0x53,
+	0x72, 0xed, 0x67, 0xa9, 0xf1, 0x00, 0xba, 0x10, 0x3c, 0x46, 0x74, 0xa1, 0x06, 0x23, 0x64, 0xcd,
+	0xcf, 0x51, 0xa4, 0xc1, 0x74, 0xa1, 0x02, 0xa6, 0xe9, 0x42, 0x8e, 0xa7, 0xea, 0xc2, 0x9f, 0x07,
+	0xb4, 0xf4, 0xba, 0x10, 0x7c, 0x46, 0x75, 0x61, 0xb8, 0xd9, 0x95, 0x5a, 0xf1, 0x0b, 0x40, 0x61,
+	0x0a, 0x5d, 0x28, 0x52, 0x24, 0xa2, 0x0b, 0x23, 0x20, 0x82, 0xc0, 0x5f, 0x84, 0x90, 0xd2, 0xe9,
+	0x42, 0x0d, 0x4a, 0xd3, 0x85, 0xf0, 0x09, 0xb0, 0xf6, 0x4b, 0x14, 0xc2, 0x56, 0x17, 0x82, 0x83,
+	0x50, 0x17, 0x2a, 0xfe, 0xdc, 0x9f, 0x44, 0x85, 0xe6, 0xda, 0x36, 0xab, 0x72, 0x50, 0xea, 0xbe,
+	0x0d, 0x31, 0xfc, 0xb0, 0x05, 0xc0, 0x8d, 0x6b, 0xdb, 0xb4, 0x20, 0xd2, 0xff, 0x4e, 0xb5, 0x3a,
+	0x3b, 0xe7, 0x83, 0x83, 0x4d, 0x39, 0xe2, 0x9e, 0x45, 0xe3, 0x21, 0x02, 0xd4, 0xb4, 0xdf, 0x02,
+	0x88, 0x2b, 0xed, 0x21, 0x58, 0x41, 0x05, 0x8c, 0xb1, 0xa6, 0x32, 0xe4, 0x6e, 0xa0, 0x89, 0x10,
+	0x84, 0xd7, 0xd8, 0xdf, 0x06, 0x94, 0xab, 0xec, 0x51, 0xa0, 0x1a, 0x03, 0x4c, 0xa1, 0xa9, 0x8e,
+	0x69, 0x38, 0xbc, 0x42, 0xff, 0x4e, 0x6a, 0x9c, 0xd3, 0x06, 0x1c, 0x5e, 0xdf, 0x23, 0xa4, 0x11,
+	0xec, 0xfd, 0xee, 0x20, 0xa4, 0x11, 0x1c, 0x23, 0x8d, 0xe0, 0x18, 0x69, 0x04, 0x7b, 0xbf, 0x37,
+	0x10, 0x69, 0x02, 0x46, 0x25, 0x2d, 0x82, 0xc3, 0x5b, 0xcb, 0x77, 0x06, 0x22, 0x2d, 0x8a, 0xc3,
+	0x1b, 0xd3, 0x16, 0x2a, 0x86, 0x38, 0xa2, 0xd7, 0xfc, 0x3e, 0x00, 0x5d, 0x6d, 0x0f, 0xc4, 0x5b,
+	0x18, 0x20, 0x8d, 0x37, 0xb5, 0x41, 0xb7, 0x81, 0x26, 0x25, 0x75, 0x02, 0xeb, 0x0f, 0x00, 0xeb,
+	0x9a, 0x14, 0xe4, 0x6d, 0xa8, 0x60, 0x13, 0x4d, 0x7d, 0x54, 0xdb, 0x0d, 0xd0, 0x17, 0xff, 0x30,
+	0xf5, 0x6e, 0x60, 0x1d, 0x54, 0xdf, 0x0d, 0xd0, 0x54, 0x63, 0xec, 0x11, 0xec, 0xfd, 0xd1, 0x60,
+	0xec, 0x89, 0xef, 0x49, 0x63, 0x8f, 0x60, 0x03, 0x7b, 0x04, 0x7b, 0x7f, 0x3c, 0x20, 0x7b, 0x02,
+	0x4c, 0x67, 0x2f, 0xb2, 0xfd, 0x78, 0x4f, 0xff, 0x93, 0xd4, 0xdb, 0x0f, 0xba, 0xbf, 0xbe, 0xfd,
+	0xb8, 0x22, 0xd0, 0xd2, 0x09, 0x14, 0xc1, 0x9f, 0xa6, 0x4f, 0x27, 0xe6, 0x20, 0x92, 0x4e, 0xa0,
+	0x27, 0xd4, 0xdd, 0x00, 0x7a, 0xe2, 0xcf, 0x52, 0xef, 0x06, 0xa6, 0x3c, 0xf4, 0xdd, 0x00, 0x62,
+	0x64, 0x1b, 0x1d, 0x0a, 0x41, 0x14, 0x31, 0xf2, 0xe7, 0x80, 0xf4, 0x0a, 0x7b, 0xa4, 0x50, 0x80,
+	0x00, 0x5a, 0xb1, 0x19, 0x19, 0x76, 0xcf, 0xa3, 0xa9, 0x08, 0xa2, 0x68, 0xab, 0x7f, 0x01, 0xa0,
+	0xd7, 0xa6, 0x04, 0xe5, 0x63, 0x80, 0x7b, 0xa8, 0x19, 0xff, 0xc4, 0xdd, 0x45, 0x87, 0x43, 0x68,
+	0x55, 0xa2, 0xfc, 0x25, 0x00, 0x2f, 0xdb, 0x03, 0x4b, 0x55, 0x02, 0xb0, 0x93, 0xcd, 0xe8, 0xb8,
+	0x7b, 0x07, 0x3a, 0xa2, 0x54, 0x5f, 0x45, 0xad, 0x7c, 0x17, 0x50, 0x57, 0xd2, 0xd4, 0xe0, 0x50,
+	0xa7, 0x00, 0xac, 0xdb, 0x8c, 0x7d, 0xe0, 0xde, 0x8d, 0xbc, 0x18, 0xae, 0x60, 0xfa, 0xaf, 0x00,
+	0xfa, 0x54, 0x6a, 0x68, 0x8d, 0xeb, 0x23, 0x4d, 0xd3, 0x67, 0x62, 0xff, 0xb2, 0x46, 0x07, 0x9a,
+	0xe3, 0xaf, 0x53, 0xed, 0x5f, 0xd6, 0xf9, 0xa5, 0xe8, 0xa0, 0xfb, 0x37, 0x1c, 0x12, 0xc9, 0xb8,
+	0xab, 0xa0, 0xfc, 0x4d, 0xaa, 0x64, 0x84, 0xc6, 0x2f, 0x61, 0x68, 0x32, 0xca, 0x31, 0x81, 0xd3,
+	0x55, 0x70, 0xfe, 0x36, 0x15, 0xce, 0x69, 0x03, 0x8e, 0x1c, 0x53, 0x48, 0x23, 0x18, 0x60, 0xfe,
+	0x2e, 0x2d, 0x69, 0x04, 0xc7, 0x48, 0x83, 0x21, 0x95, 0x34, 0x81, 0xf2, 0xf7, 0xa9, 0x49, 0x53,
+	0x61, 0x04, 0x69, 0x3a, 0x4e, 0x57, 0xc1, 0xf9, 0x87, 0xd4, 0xa4, 0x45, 0x71, 0xe4, 0x98, 0x68,
+	0x69, 0xbc, 0x8d, 0x02, 0xd0, 0x3f, 0xa6, 0x6a, 0x69, 0xbc, 0xef, 0x4b, 0x24, 0xfa, 0x6d, 0x28,
+	0x83, 0x21, 0x75, 0xac, 0x44, 0x03, 0xd2, 0x3f, 0xa5, 0xa3, 0x8e, 0x79, 0x88, 0x50, 0x17, 0x8e,
+	0xb9, 0x25, 0x84, 0xda, 0xad, 0x7a, 0x7b, 0x03, 0x20, 0x9e, 0xce, 0x95, 0x9c, 0xf2, 0x81, 0xea,
+	0x50, 0x30, 0xca, 0x06, 0x99, 0xc5, 0x2c, 0x3a, 0x08, 0x16, 0x20, 0x4f, 0x9f, 0xa1, 0x26, 0xb9,
+	0xea, 0x50, 0x00, 0xf3, 0x40, 0x2e, 0xbf, 0x0c, 0x8d, 0x81, 0x0d, 0xd7, 0xca, 0xcf, 0x52, 0xa3,
+	0xc9, 0xea, 0x50, 0x00, 0x53, 0xb9, 0xd8, 0x0d, 0xad, 0xb8, 0xd2, 0x7d, 0x8e, 0x5a, 0x15, 0x42,
+	0x2b, 0x2e, 0x55, 0x55, 0x3c, 0x82, 0xbd, 0xe7, 0xa9, 0x51, 0x56, 0xc5, 0x23, 0x58, 0xc7, 0x23,
+	0xd8, 0xfb, 0x0c, 0x35, 0x72, 0x35, 0x3c, 0xd5, 0x8a, 0x8b, 0xc4, 0xcf, 0x52, 0xab, 0x61, 0x0d,
+	0x8f, 0x60, 0xf7, 0xe5, 0xa8, 0x00, 0x56, 0x42, 0x76, 0x7d, 0x8e, 0x9a, 0x8d, 0x54, 0x87, 0x02,
+	0x98, 0x2d, 0x24, 0x5a, 0x19, 0x8d, 0x73, 0x4c, 0x61, 0xf8, 0x79, 0x6a, 0x38, 0x51, 0x1d, 0x0a,
+	0xc0, 0x41, 0x28, 0xaf, 0xc2, 0x08, 0x40, 0x5b, 0xfd, 0x32, 0x35, 0xcb, 0x84, 0x11, 0x80, 0x3a,
+	0xd2, 0x51, 0x09, 0xf6, 0x7e, 0x85, 0x5a, 0xe5, 0x75, 0x54, 0x76, 0x80, 0xa0, 0xa1, 0x12, 0xec,
+	0xfd, 0x2a, 0x35, 0x2c, 0x46, 0x50, 0xd5, 0x68, 0xb9, 0x26, 0x79, 0x81, 0xda, 0x39, 0x61, 0xb4,
+	0x5c, 0x54, 0x48, 0xe6, 0x40, 0x51, 0x7c, 0x81, 0x5a, 0x8d, 0x4a, 0xe6, 0x40, 0x12, 0x84, 0x11,
+	0x80, 0x1e, 0xf8, 0x22, 0x35, 0x1a, 0x0b, 0x23, 0x80, 0x8e, 0xbe, 0x86, 0x8a, 0x60, 0xa3, 0xb4,
+	0xf3, 0x2f, 0xe5, 0xd2, 0x3f, 0xc6, 0xad, 0x0e, 0x05, 0x10, 0xaa, 0x6c, 0xe1, 0xb7, 0xa2, 0x43,
+	0x2a, 0x84, 0xe8, 0x2a, 0x5f, 0xce, 0x0d, 0xf4, 0x8a, 0x4d, 0x75, 0x28, 0x98, 0x94, 0x40, 0xa2,
+	0x8b, 0xac, 0x23, 0x18, 0xd4, 0x1a, 0xf6, 0x57, 0x72, 0x03, 0xbc, 0x5f, 0x53, 0x1d, 0x0a, 0x26,
+	0x98, 0x4b, 0xa5, 0x49, 0xaf, 0x22, 0x57, 0x6c, 0x5c, 0xa5, 0x43, 0x7f, 0x35, 0x97, 0xe6, 0x59,
+	0x74, 0x75, 0x28, 0x28, 0xf2, 0xed, 0x2e, 0xbb, 0xf1, 0x39, 0x74, 0x44, 0x07, 0x10, 0xa4, 0x7d,
+	0x2d, 0x97, 0xf2, 0xcd, 0x9a, 0xea, 0x50, 0x70, 0x48, 0x85, 0x11, 0x84, 0xfd, 0x18, 0xaf, 0x1c,
+	0xc0, 0xd4, 0xd7, 0x73, 0xd6, 0xaf, 0x09, 0xde, 0x44, 0x67, 0x0b, 0xa6, 0x14, 0x5f, 0x32, 0x37,
+	0x60, 0x8f, 0x2e, 0x78, 0xdf, 0x10, 0x9b, 0x74, 0x4c, 0xd9, 0xa4, 0x0b, 0x51, 0x3b, 0xdf, 0xfb,
+	0xa6, 0xc9, 0xce, 0x8f, 0xda, 0x2d, 0x7a, 0xdf, 0x32, 0xd9, 0x2d, 0xba, 0x27, 0xd1, 0x61, 0x9e,
+	0x41, 0xfa, 0x03, 0xad, 0x7b, 0xf3, 0xf2, 0x85, 0x9e, 0xaa, 0x13, 0xc0, 0x37, 0xa8, 0x3f, 0xcf,
+	0xba, 0x4a, 0xd0, 0x1e, 0x7d, 0x98, 0xf5, 0xbe, 0xbc, 0xfa, 0x76, 0x4f, 0xd5, 0xe1, 0x5c, 0x46,
+	0x9e, 0x65, 0x5d, 0x8d, 0xa6, 0xa2, 0xd3, 0x79, 0x25, 0xbd, 0x2f, 0xaf, 0xbc, 0xea, 0x53, 0x75,
+	0x82, 0xc3, 0xfa, 0x74, 0x5e, 0x59, 0xaf, 0x8a, 0xcf, 0xe7, 0x35, 0xf6, 0xfe, 0xbc, 0x7c, 0xef,
+	0x27, 0x3e, 0xfd, 0xb4, 0x78, 0x0c, 0x66, 0x5a, 0x3d, 0xc1, 0xde, 0x03, 0xf9, 0xe8, 0x4b, 0x40,
+	0xc6, 0x08, 0x08, 0x4e, 0x8a, 0x80, 0x60, 0xef, 0xc1, 0xbc, 0xf2, 0x46, 0x90, 0x39, 0x02, 0x82,
+	0x93, 0x22, 0x20, 0xd8, 0x7b, 0x28, 0x2f, 0x5f, 0x0f, 0x32, 0x47, 0xc0, 0x1e, 0x7d, 0x4d, 0x47,
+	0xa7, 0x8b, 0x2a, 0xfd, 0x70, 0x5e, 0x7d, 0x57, 0xa8, 0xea, 0x04, 0x47, 0x74, 0x0f, 0xa2, 0xbe,
+	0x5f, 0x87, 0xbc, 0x58, 0x04, 0xc2, 0xc7, 0x23, 0x79, 0xed, 0xc5, 0xa1, 0xaa, 0x13, 0x4c, 0x45,
+	0xa2, 0x10, 0xb5, 0xff, 0xea, 0x38, 0x95, 0xd0, 0x05, 0xde, 0x9f, 0xd7, 0xde, 0x22, 0x8a, 0xf3,
+	0x08, 0x7d, 0x21, 0x29, 0x10, 0x82, 0xbd, 0x0f, 0xe4, 0xd5, 0x57, 0x8a, 0x12, 0x02, 0x21, 0x38,
+	0x39, 0x10, 0x82, 0xbd, 0x47, 0xf3, 0xda, 0xfb, 0x45, 0x49, 0x81, 0x10, 0xec, 0x5e, 0x1f, 0xff,
+	0x42, 0x78, 0x63, 0x79, 0x2c, 0x6f, 0x78, 0xd9, 0x28, 0xfe, 0xcd, 0xf0, 0x86, 0x73, 0x83, 0x61,
+	0x63, 0x40, 0xeb, 0x79, 0x3c, 0x6f, 0x7e, 0xf3, 0xc8, 0xb0, 0x47, 0xa0, 0x2b, 0xdd, 0x14, 0xe7,
+	0x16, 0xfa, 0xd3, 0x13, 0xf9, 0xfe, 0xaf, 0x21, 0xc5, 0xc9, 0x86, 0x16, 0xf6, 0x5a, 0x34, 0x13,
+	0x75, 0xa8, 0x34, 0xb3, 0x27, 0xf3, 0x03, 0xbf, 0x93, 0x54, 0x75, 0x82, 0x69, 0x1d, 0x58, 0xfd,
+	0xfb, 0xf4, 0xe2, 0x78, 0xc6, 0x28, 0x4d, 0xe1, 0xa9, 0xfc, 0x00, 0x2f, 0x28, 0x55, 0x9d, 0xe0,
+	0x68, 0x34, 0xcf, 0x42, 0x9b, 0x99, 0x9f, 0x42, 0x63, 0x5a, 0xef, 0x7b, 0x11, 0xdf, 0x34, 0x9f,
+	0xb9, 0x0b, 0x21, 0xa5, 0x1f, 0xbe, 0x98, 0xc8, 0xd7, 0xa0, 0x82, 0xf6, 0x26, 0xa7, 0x2d, 0x38,
+	0x75, 0xa0, 0xbd, 0x13, 0x91, 0xce, 0x81, 0x72, 0x78, 0x6e, 0xed, 0xe0, 0x6a, 0x54, 0x8c, 0x1e,
+	0x8e, 0xbb, 0x45, 0x94, 0xbd, 0xad, 0x7e, 0x9e, 0x39, 0x39, 0x10, 0xd0, 0xff, 0x75, 0x0f, 0xa3,
+	0xdc, 0x1d, 0x6b, 0x8d, 0x6e, 0xdd, 0xcb, 0xb0, 0x31, 0xf8, 0x47, 0x25, 0x73, 0x85, 0x33, 0x73,
+	0x0d, 0x9a, 0x8c, 0x9d, 0x7c, 0xef, 0xe5, 0x20, 0xa7, 0x3a, 0x78, 0x05, 0x72, 0xe3, 0x87, 0xda,
+	0x7b, 0x79, 0x98, 0x34, 0x7b, 0x38, 0xbd, 0x7f, 0x0f, 0x85, 0xc4, 0x20, 0xf8, 0x29, 0xdd, 0x5e,
+	0x0e, 0xb2, 0xc9, 0x41, 0xec, 0xd3, 0x83, 0x9b, 0x1c, 0xc4, 0x3e, 0x3d, 0x0c, 0xab, 0x1e, 0x96,
+	0xd1, 0x21, 0xc3, 0xb9, 0xf0, 0x5e, 0x2e, 0x46, 0x54, 0x17, 0x2b, 0xe8, 0xb0, 0xe9, 0xb8, 0x77,
+	0x2f, 0x1f, 0x13, 0x66, 0x2e, 0xe5, 0x39, 0xee, 0x5e, 0x0e, 0x32, 0x7d, 0xe2, 0xd8, 0x27, 0x15,
+	0xf9, 0x7e, 0x71, 0xec, 0xd3, 0x47, 0xd1, 0xfc, 0x85, 0x28, 0x07, 0xaa, 0x7b, 0x79, 0x70, 0x12,
+	0x36, 0x85, 0x3c, 0x2a, 0xdd, 0xcb, 0xc3, 0xa8, 0x99, 0x4b, 0x79, 0x0a, 0xba, 0x97, 0x83, 0x31,
+	0xd5, 0xc1, 0x79, 0x74, 0xc4, 0x78, 0xb8, 0x69, 0x70, 0xf2, 0x2a, 0xd5, 0x49, 0xda, 0x87, 0xb9,
+	0x0a, 0xf4, 0xdd, 0xc8, 0x4b, 0x3a, 0xe2, 0x34, 0xa0, 0xdf, 0xa8, 0xa2, 0x0f, 0xf0, 0x80, 0x57,
+	0x59, 0xc0, 0x6b, 0xd1, 0x94, 0xf9, 0xa8, 0xd3, 0x00, 0xff, 0x23, 0x3a, 0x7c, 0xca, 0x27, 0xbe,
+	0x0a, 0x78, 0x17, 0x4d, 0x27, 0x9c, 0x78, 0x1a, 0xd0, 0xaf, 0xd3, 0xa9, 0xb7, 0x7d, 0x08, 0xac,
+	0xc5, 0x3c, 0x93, 0x7c, 0xda, 0x69, 0x40, 0x7e, 0xa5, 0x1e, 0x77, 0x8a, 0xc7, 0xc2, 0xb1, 0xdd,
+	0xaa, 0x9f, 0x79, 0xaa, 0x98, 0xb9, 0xbd, 0x7a, 0x09, 0x24, 0x4c, 0xe4, 0x38, 0x53, 0xf5, 0x30,
+	0xb9, 0x3f, 0x0f, 0xa7, 0x93, 0x3d, 0x14, 0xf6, 0xd7, 0xcf, 0xf4, 0x33, 0x48, 0xd5, 0x41, 0x76,
+	0xff, 0x41, 0x24, 0x78, 0x70, 0xf7, 0x1f, 0x44, 0x82, 0x87, 0xe1, 0xbd, 0x3c, 0x40, 0x09, 0x8d,
+	0x9e, 0x08, 0xaa, 0x2e, 0x46, 0xf6, 0x19, 0x86, 0x7e, 0xd4, 0xa7, 0x7a, 0x18, 0xdd, 0xcb, 0xc3,
+	0x95, 0x08, 0xc9, 0xbf, 0xc7, 0xad, 0x75, 0x49, 0x15, 0x4d, 0x9d, 0xba, 0xab, 0x53, 0x6f, 0xed,
+	0x6e, 0xb5, 0x5b, 0x83, 0x69, 0x2c, 0xd5, 0xd3, 0x40, 0x5a, 0x69, 0x76, 0x0e, 0x8d, 0x4a, 0xb1,
+	0x3d, 0x8a, 0x40, 0x17, 0x17, 0x87, 0xe8, 0xff, 0xae, 0x04, 0xcb, 0x3f, 0x7a, 0x53, 0xd1, 0x71,
+	0x0f, 0xa2, 0x91, 0x6b, 0xab, 0xcb, 0xc1, 0xab, 0x6f, 0x38, 0x55, 0xcc, 0x5c, 0x36, 0x7a, 0xe0,
+	0x9e, 0x5a, 0xf1, 0xc2, 0x85, 0x0b, 0x17, 0x32, 0xfe, 0x59, 0x34, 0x5d, 0x17, 0x8b, 0x58, 0xd5,
+	0xee, 0x2c, 0xba, 0x16, 0xa2, 0xd3, 0xbb, 0xa7, 0xc6, 0x58, 0x3e, 0x52, 0x8f, 0x52, 0x43, 0xbf,
+	0x22, 0xbf, 0x8e, 0x3c, 0x03, 0x08, 0xfc, 0x41, 0x6e, 0x83, 0xf2, 0x86, 0x1a, 0xcb, 0xd6, 0xa9,
+	0x18, 0x0a, 0xcb, 0x6d, 0x7f, 0x13, 0x1d, 0x35, 0xc0, 0xec, 0xda, 0xe3, 0xbc, 0xb1, 0xc6, 0x72,
+	0x7a, 0x3a, 0x86, 0x03, 0x25, 0x20, 0x01, 0xa8, 0x6b, 0x0f, 0xf4, 0xa6, 0x1a, 0x4b, 0xfd, 0x38,
+	0x10, 0x54, 0x8a, 0x64, 0xe2, 0x08, 0xb6, 0xc2, 0x79, 0x73, 0x8d, 0x55, 0x08, 0x23, 0x71, 0x04,
+	0xf7, 0x21, 0xce, 0x12, 0xe7, 0x2d, 0x35, 0x56, 0x47, 0xcc, 0xc4, 0x25, 0x02, 0x75, 0xed, 0x81,
+	0xde, 0x5a, 0x63, 0xe5, 0xc6, 0x4c, 0x1c, 0xc1, 0xfe, 0x16, 0x9a, 0x31, 0x00, 0x89, 0x93, 0x0b,
+	0x1b, 0xa4, 0xb7, 0xd5, 0x58, 0x55, 0xf2, 0x62, 0x48, 0xbc, 0x8a, 0xf9, 0xb7, 0xa1, 0x8b, 0x4c,
+	0xe4, 0xa5, 0xc1, 0x7a, 0x7b, 0x8d, 0x89, 0xd6, 0xa3, 0x71, 0xfa, 0xb8, 0xb7, 0x84, 0x0d, 0xb1,
+	0x01, 0xaf, 0xf6, 0x59, 0x20, 0xbd, 0xa3, 0xc6, 0xd4, 0x6d, 0x7c, 0x43, 0x30, 0x6d, 0xdc, 0x8f,
+	0x3e, 0xcb, 0x2f, 0xea, 0x9d, 0x35, 0xa6, 0x81, 0x13, 0xe8, 0x23, 0xb8, 0x2f, 0x7d, 0x96, 0x58,
+	0xef, 0xaa, 0x31, 0xad, 0x9c, 0x44, 0x5f, 0xe2, 0xfe, 0x83, 0xc3, 0x1e, 0x2b, 0xa8, 0x5e, 0x8d,
+	0x89, 0xea, 0xf8, 0xfe, 0x03, 0x4d, 0x9e, 0x94, 0x51, 0x70, 0xb8, 0x63, 0x03, 0xf4, 0xee, 0x1a,
+	0xeb, 0x02, 0x86, 0x8c, 0x82, 0x13, 0x5f, 0xf3, 0x86, 0x60, 0x67, 0x45, 0x56, 0x38, 0xef, 0xa9,
+	0x31, 0x89, 0x1e, 0xdf, 0x10, 0x4c, 0xe0, 0xfb, 0x0f, 0x38, 0xe8, 0x12, 0x03, 0x8e, 0x3c, 0x42,
+	0xb2, 0x02, 0x7b, 0x6f, 0x6d, 0x00, 0x29, 0x3f, 0x13, 0x5b, 0x62, 0xf8, 0x99, 0xff, 0xb8, 0x83,
+	0x4a, 0x89, 0xcb, 0xe4, 0x8f, 0x07, 0xac, 0x56, 0x7a, 0x6f, 0x6d, 0x30, 0xd9, 0x7f, 0x89, 0x79,
+	0xb1, 0xfc, 0x63, 0xff, 0x61, 0x07, 0x7d, 0x9f, 0x61, 0xbd, 0xca, 0x73, 0x19, 0xab, 0xd5, 0xbe,
+	0xaf, 0x36, 0xc8, 0x5f, 0x09, 0x17, 0xc5, 0xd6, 0x2a, 0x3f, 0xf4, 0xef, 0x73, 0xd0, 0xa5, 0xc6,
+	0x1e, 0x21, 0x8f, 0xf1, 0xac, 0x96, 0x7a, 0x5f, 0x2d, 0xd5, 0x9f, 0x14, 0x17, 0x1b, 0x3a, 0x4b,
+	0xf8, 0xa9, 0xff, 0xa8, 0x83, 0x66, 0xfb, 0x2c, 0x32, 0xcd, 0x06, 0xb8, 0xbf, 0x96, 0xf6, 0x0f,
+	0x90, 0x4b, 0x93, 0x96, 0x2a, 0xbe, 0xfc, 0x87, 0x1c, 0x24, 0xd3, 0x4d, 0xbf, 0x69, 0x6d, 0xb3,
+	0xc2, 0x07, 0x6a, 0xec, 0x71, 0x94, 0xcd, 0x9b, 0x36, 0x66, 0x01, 0x1b, 0x24, 0xac, 0xc6, 0x6f,
+	0xa8, 0x35, 0x46, 0x7f, 0x60, 0x64, 0x97, 0x4c, 0x3d, 0xf5, 0xba, 0xb8, 0x44, 0xd3, 0x9e, 0x2f,
+	0xf9, 0xdb, 0x6a, 0xe9, 0x8c, 0x3c, 0x63, 0xb2, 0xcb, 0x86, 0x9e, 0x7e, 0xdd, 0x7c, 0x3a, 0x0e,
+	0x08, 0xba, 0xf1, 0x76, 0xb5, 0xdb, 0x45, 0x1f, 0x4b, 0xd9, 0xed, 0xea, 0x9e, 0x76, 0x5d, 0xdd,
+	0x8b, 0x23, 0x72, 0x05, 0xb9, 0x6d, 0x86, 0x4c, 0x21, 0x21, 0xef, 0xef, 0xa9, 0xd7, 0xdd, 0x0d,
+	0x88, 0x5c, 0x4a, 0x76, 0x12, 0x69, 0xb5, 0xec, 0xb2, 0x0f, 0xf4, 0xe2, 0xd7, 0xe5, 0xcd, 0xd4,
+	0x12, 0xdc, 0x8f, 0x5a, 0x4b, 0xd8, 0x07, 0x7b, 0xda, 0x75, 0xfb, 0x04, 0x6a, 0x09, 0xee, 0x47,
+	0xad, 0x25, 0xe4, 0x43, 0x3d, 0xf5, 0xba, 0x7e, 0x02, 0xb5, 0x04, 0xfb, 0x1d, 0x55, 0xc2, 0xc4,
+	0x9e, 0xca, 0x59, 0x41, 0x3e, 0xdc, 0xd3, 0xaf, 0xfb, 0x1f, 0x8d, 0x83, 0x0a, 0xdd, 0x79, 0x27,
+	0xba, 0xd8, 0x48, 0x6d, 0x1a, 0xd8, 0x47, 0x7a, 0x91, 0x9f, 0x0b, 0x98, 0x31, 0xd0, 0x2b, 0x34,
+	0xe8, 0xed, 0xe6, 0x9d, 0x64, 0x2f, 0x42, 0xdf, 0xdf, 0x8b, 0xfc, 0xdc, 0x80, 0x61, 0x1b, 0x81,
+	0x1e, 0xed, 0xc7, 0xb0, 0xe5, 0x97, 0xfa, 0x81, 0x9e, 0xfe, 0x73, 0x05, 0x49, 0x0c, 0x13, 0xdc,
+	0x9f, 0x61, 0x4b, 0xd8, 0x47, 0x7b, 0x91, 0x9f, 0x3b, 0x48, 0x64, 0x98, 0x60, 0xff, 0xbc, 0x79,
+	0x0b, 0xa7, 0xd0, 0xa9, 0x8f, 0xf5, 0x8c, 0x3f, 0x97, 0x60, 0xd8, 0xcb, 0x5c, 0xb8, 0xbe, 0x2e,
+	0x21, 0x61, 0xed, 0x95, 0xeb, 0xe3, 0xbd, 0xa4, 0x9f, 0x5b, 0x30, 0xe5, 0x2e, 0xa8, 0xd9, 0xd7,
+	0x3b, 0xe6, 0xbd, 0x65, 0xaf, 0x67, 0x9f, 0xe8, 0xed, 0xf5, 0x7b, 0x0d, 0x86, 0xcd, 0x06, 0x5a,
+	0xf7, 0x09, 0x4d, 0x94, 0x99, 0x9e, 0x97, 0x5a, 0xad, 0xe4, 0xc9, 0xde, 0xf7, 0xe0, 0x07, 0x1f,
+	0x2e, 0x8a, 0x2f, 0x56, 0xaa, 0xde, 0xc7, 0x34, 0xd5, 0x6b, 0x7e, 0xc6, 0x6a, 0xb5, 0xe4, 0xa7,
+	0x7a, 0x03, 0xfd, 0x62, 0xc4, 0x25, 0xa6, 0xda, 0x2c, 0x55, 0xda, 0xba, 0x7a, 0xe4, 0xa4, 0x5d,
+	0x16, 0xb4, 0x5b, 0xe4, 0x77, 0x1d, 0x76, 0xb3, 0x50, 0x9e, 0x39, 0x05, 0xca, 0x15, 0x43, 0x7f,
+	0x43, 0x15, 0x2d, 0xfa, 0x65, 0x43, 0x2b, 0x98, 0x0f, 0x32, 0x18, 0xf5, 0xd0, 0x29, 0x50, 0xaf,
+	0x28, 0xfa, 0xe7, 0xd4, 0x1d, 0x1b, 0xb9, 0xac, 0x68, 0x05, 0xf4, 0x21, 0x06, 0xa4, 0x9e, 0x3a,
+	0x05, 0xda, 0x15, 0xc7, 0x04, 0xa4, 0x14, 0x92, 0xe1, 0xc3, 0x0c, 0xa9, 0x60, 0x40, 0xe2, 0x5a,
+	0x21, 0x91, 0x3b, 0xcb, 0xa2, 0xf7, 0x11, 0x06, 0x94, 0x35, 0x73, 0x47, 0x70, 0x1f, 0xee, 0x2c,
+	0x81, 0x3e, 0xca, 0x80, 0xdc, 0x04, 0xee, 0x12, 0x91, 0x52, 0x68, 0x82, 0x8f, 0x31, 0xa4, 0xe1,
+	0x04, 0xee, 0x08, 0xf6, 0x6f, 0x55, 0x0b, 0x68, 0xf4, 0xb2, 0xa7, 0x15, 0xd4, 0xc7, 0x19, 0x94,
+	0x7a, 0xf4, 0x14, 0xe8, 0x57, 0x44, 0xfd, 0x86, 0xda, 0x16, 0x63, 0x97, 0x45, 0xad, 0xc0, 0x3e,
+	0xc1, 0xc0, 0xd4, 0xb3, 0xa7, 0x20, 0x72, 0xc5, 0x34, 0x61, 0x57, 0xd8, 0xb7, 0xfd, 0x4f, 0x32,
+	0xa8, 0x8c, 0x61, 0x57, 0x40, 0xb3, 0xef, 0xc3, 0xa0, 0xe5, 0x97, 0xf5, 0x29, 0x86, 0x94, 0x4f,
+	0x62, 0x90, 0xe0, 0xbe, 0x0c, 0x5a, 0x82, 0x7d, 0x9a, 0x81, 0x15, 0x13, 0x19, 0x4c, 0xdc, 0x85,
+	0x29, 0xda, 0xfa, 0xd3, 0x0c, 0xcb, 0x31, 0xec, 0x42, 0xde, 0xc6, 0x13, 0x32, 0xcb, 0xbe, 0x8b,
+	0x3f, 0xc3, 0x90, 0x46, 0x4d, 0x99, 0x05, 0x2d, 0xdb, 0xbc, 0x2b, 0xec, 0x1b, 0xf6, 0xb3, 0x0c,
+	0x68, 0xcc, 0xb0, 0x2b, 0xa0, 0x2b, 0x3f, 0xa8, 0x9d, 0x40, 0x19, 0x6e, 0xfb, 0x5a, 0xa1, 0x3d,
+	0xc7, 0xd0, 0x06, 0x3f, 0x82, 0x0a, 0xa2, 0x77, 0x84, 0xa9, 0x7a, 0x28, 0x25, 0xae, 0x33, 0xcd,
+	0x09, 0xc4, 0xf3, 0x6c, 0xa9, 0xdf, 0x93, 0x33, 0xa8, 0xc0, 0x70, 0xc9, 0xd8, 0x7f, 0x44, 0x93,
+	0x3b, 0xa6, 0xfb, 0xc6, 0x56, 0xcb, 0xfd, 0x0c, 0x5f, 0xee, 0xc0, 0x87, 0x50, 0x41, 0xec, 0x96,
+	0xb2, 0x7f, 0xbf, 0x76, 0x08, 0x65, 0xbc, 0xb0, 0x6c, 0xb5, 0xd6, 0xcf, 0xf2, 0x5d, 0x90, 0xfe,
+	0x14, 0x2a, 0x88, 0x5f, 0x73, 0xa6, 0x72, 0x6c, 0xb6, 0xcf, 0x2a, 0xd3, 0xec, 0x81, 0xcf, 0x71,
+	0x52, 0x07, 0x3a, 0x86, 0x0a, 0x8c, 0xf7, 0xa4, 0xfd, 0x87, 0xd5, 0x63, 0x28, 0xfd, 0x86, 0xb3,
+	0xcd, 0x12, 0x3f, 0xcf, 0x96, 0x98, 0xf2, 0x1c, 0x4a, 0xbf, 0x67, 0x9d, 0xb0, 0x9c, 0x95, 0x82,
+	0x78, 0x55, 0xbf, 0xdb, 0xda, 0x6a, 0xb7, 0x56, 0xa6, 0xe3, 0xef, 0x48, 0xb2, 0x0f, 0x2e, 0x5b,
+	0x40, 0x07, 0xd5, 0xf7, 0xc4, 0x4d, 0x0f, 0x44, 0x91, 0x3b, 0x26, 0x1f, 0x88, 0xbe, 0xe0, 0xac,
+	0xbc, 0xe6, 0xc7, 0x6b, 0xb1, 0x65, 0x1f, 0x67, 0xcb, 0x3e, 0xd3, 0xdd, 0x38, 0xbe, 0xd5, 0xea,
+	0xd4, 0x77, 0x5a, 0x6b, 0x0d, 0xf6, 0x3b, 0xb7, 0x6c, 0x74, 0xf7, 0x78, 0xa3, 0xbe, 0xb9, 0x76,
+	0xf6, 0xfc, 0xf1, 0xa4, 0x9f, 0xc4, 0xfd, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x51, 0x2c, 0x45,
+	0xc2, 0x2d, 0x57, 0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20190205_c823c79e/test.proto b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20190205_c823c79e/test.proto
new file mode 100644
index 000000000..4ac2f748c
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto2_20190205_c823c79e/test.proto
@@ -0,0 +1,333 @@
+// 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.
+
+syntax = "proto2";
+
+package google.golang.org.proto2_20190205;
+option go_package = "google.golang.org/protobuf/internal/testprotos/legacy/proto2_20190205_c823c79e";
+
+enum SiblingEnum {
+	ALPHA   = 0;
+	BRAVO   = 10;
+	CHARLIE = 200;
+}
+
+message SiblingMessage {
+	optional string  f1 = 1;
+	required string  f2 = 2;
+	repeated string  f3 = 3;
+	optional Message f4 = 4;
+}
+
+message Message {
+	enum ChildEnum {
+		ALPHA   = 0;
+		BRAVO   = 1;
+		CHARLIE = 2;
+	}
+	message ChildMessage {
+		optional string  f1 = 1;
+		required string  f2 = 2;
+		repeated string  f3 = 3;
+	    optional Message f4 = 4;
+	}
+	optional group NamedGroup = 1 {
+		optional string  f1 = 1;
+		required string  f2 = 2;
+		repeated string  f3 = 3;
+	    optional Message f4 = 4;
+	}
+
+	// Optional fields.
+	optional bool     optional_bool     = 100;
+	optional int32    optional_int32    = 101;
+	optional sint32   optional_sint32   = 102;
+	optional uint32   optional_uint32   = 103;
+	optional int64    optional_int64    = 104;
+	optional sint64   optional_sint64   = 105;
+	optional uint64   optional_uint64   = 106;
+	optional fixed32  optional_fixed32  = 107;
+	optional sfixed32 optional_sfixed32 = 108;
+	optional float    optional_float    = 109;
+	optional fixed64  optional_fixed64  = 110;
+	optional sfixed64 optional_sfixed64 = 111;
+	optional double   optional_double   = 112;
+	optional string   optional_string   = 113;
+	optional bytes    optional_bytes    = 114;
+
+	optional ChildEnum      optional_child_enum      = 115;
+	optional ChildMessage   optional_child_message   = 116;
+	optional NamedGroup     optional_named_group     = 117;
+	optional SiblingEnum    optional_sibling_enum    = 118;
+	optional SiblingMessage optional_sibling_message = 119;
+	optional group OptionalGroup = 120 {
+		optional string f1 = 1;
+		required string f2 = 2;
+		repeated string f3 = 3;
+	}
+
+	// Optional default fields.
+	optional bool      defaulted_bool     = 200 [default = true];
+	optional int32     defaulted_int32    = 201 [default = -12345];
+	optional sint32    defaulted_sint32   = 202 [default = -3200];
+	optional uint32    defaulted_uint32   = 203 [default = 3200];
+	optional int64     defaulted_int64    = 204 [default = -123456789];
+	optional sint64    defaulted_sint64   = 205 [default = -6400];
+	optional uint64    defaulted_uint64   = 206 [default = 6400];
+	optional fixed32   defaulted_fixed32  = 207 [default = 320000];
+	optional sfixed32  defaulted_sfixed32 = 208 [default = -320000];
+	optional float     defaulted_float    = 209 [default = 3.14159];
+	optional fixed64   defaulted_fixed64  = 210 [default = 640000];
+	optional sfixed64  defaulted_sfixed64 = 211 [default = -640000];
+	optional double    defaulted_double   = 212 [default = 3.14159265359];
+	optional string    defaulted_string   = 213 [default = "hello, \"world!\"\n"];
+	optional bytes     defaulted_bytes    = 214 [default = "dead\xde\xad\xbe\xefbeef"];
+
+	optional ChildEnum   defaulted_child_enum   = 215 [default = ALPHA];
+	optional SiblingEnum defaulted_sibling_enum = 216 [default = ALPHA];
+
+	// Required fields.
+	required bool     required_bool     = 300;
+	required int32    required_int32    = 301;
+	required sint32   required_sint32   = 302;
+	required uint32   required_uint32   = 303;
+	required int64    required_int64    = 304;
+	required sint64   required_sint64   = 305;
+	required uint64   required_uint64   = 306;
+	required fixed32  required_fixed32  = 307;
+	required sfixed32 required_sfixed32 = 308;
+	required float    required_float    = 309;
+	required fixed64  required_fixed64  = 310;
+	required sfixed64 required_sfixed64 = 311;
+	required double   required_double   = 312;
+	required string   required_string   = 313;
+	required bytes    required_bytes    = 314;
+
+	required ChildEnum      required_child_enum      = 315;
+	required ChildMessage   required_child_message   = 316;
+	required NamedGroup     required_named_group     = 317;
+	required SiblingEnum    required_sibling_enum    = 318;
+	required SiblingMessage required_sibling_message = 319;
+	required group RequiredGroup = 320 {
+		optional string f1 = 1;
+		required string f2 = 2;
+		repeated string f3 = 3;
+	}
+	// Required default fields.
+	required bool      required_defaulted_bool     = 400 [default = true];
+	required int32     required_defaulted_int32    = 401 [default = -12345];
+	required sint32    required_defaulted_sint32   = 402 [default = -3200];
+	required uint32    required_defaulted_uint32   = 403 [default = 3200];
+	required int64     required_defaulted_int64    = 404 [default = -123456789];
+	required sint64    required_defaulted_sint64   = 405 [default = -6400];
+	required uint64    required_defaulted_uint64   = 406 [default = 6400];
+	required fixed32   required_defaulted_fixed32  = 407 [default = 320000];
+	required sfixed32  required_defaulted_sfixed32 = 408 [default = -320000];
+	required float     required_defaulted_float    = 409 [default = 3.14159];
+	required fixed64   required_defaulted_fixed64  = 410 [default = 640000];
+	required sfixed64  required_defaulted_sfixed64 = 411 [default = -640000];
+	required double    required_defaulted_double   = 412 [default = 3.14159265359];
+	required string    required_defaulted_string   = 413 [default = "hello, \"world!\"\n"];
+	required bytes     required_defaulted_bytes    = 414 [default = "dead\xde\xad\xbe\xefbeef"];
+
+	required ChildEnum   required_defaulted_child_enum   = 415 [default = ALPHA];
+	required SiblingEnum required_defaulted_sibling_enum = 416 [default = ALPHA];
+
+	// Repeated fields.
+	repeated bool     repeated_bool     = 500;
+	repeated int32    repeated_int32    = 501;
+	repeated sint32   repeated_sint32   = 502;
+	repeated uint32   repeated_uint32   = 503;
+	repeated int64    repeated_int64    = 504;
+	repeated sint64   repeated_sint64   = 505;
+	repeated uint64   repeated_uint64   = 506;
+	repeated fixed32  repeated_fixed32  = 507;
+	repeated sfixed32 repeated_sfixed32 = 508;
+	repeated float    repeated_float    = 509;
+	repeated fixed64  repeated_fixed64  = 510;
+	repeated sfixed64 repeated_sfixed64 = 511;
+	repeated double   repeated_double   = 512;
+	repeated string   repeated_string   = 513;
+	repeated bytes    repeated_bytes    = 514;
+
+	repeated ChildEnum      repeated_child_enum      = 515;
+	repeated ChildMessage   repeated_child_message   = 516;
+	repeated NamedGroup     repeated_named_group     = 517;
+	repeated SiblingEnum    repeated_sibling_enum    = 518;
+	repeated SiblingMessage repeated_sibling_message = 519;
+	repeated group RepeatedGroup = 520 {
+		optional string f1 = 1;
+		required string f2 = 2;
+		repeated string f3 = 3;
+	}
+
+	// Map fields.
+	map<bool, bool>     map_bool_bool     = 600;
+	map<bool, int32>    map_bool_int32    = 601;
+	map<bool, sint32>   map_bool_sint32   = 602;
+	map<bool, uint32>   map_bool_uint32   = 603;
+	map<bool, int64>    map_bool_int64    = 604;
+	map<bool, sint64>   map_bool_sint64   = 605;
+	map<bool, uint64>   map_bool_uint64   = 606;
+	map<bool, fixed32>  map_bool_fixed32  = 607;
+	map<bool, sfixed32> map_bool_sfixed32 = 608;
+	map<bool, float>    map_bool_float    = 609;
+	map<bool, fixed64>  map_bool_fixed64  = 610;
+	map<bool, sfixed64> map_bool_sfixed64 = 611;
+	map<bool, double>   map_bool_double   = 612;
+	map<bool, string>   map_bool_string   = 613;
+	map<bool, bytes>    map_bool_bytes    = 614;
+
+	map<bool, ChildEnum>      map_bool_child_enum      = 615;
+	map<bool, ChildMessage>   map_bool_child_message   = 616;
+	map<bool, NamedGroup>     map_bool_named_group     = 617;
+	map<bool, SiblingEnum>    map_bool_sibling_enum    = 618;
+	map<bool, SiblingMessage> map_bool_sibling_message = 619;
+
+	map<int32, bool>   map_int32_bool   = 620;
+	map<sint32, bool>  map_sint32_bool  = 621;
+	map<uint32, bool>  map_uint32_bool  = 622;
+	map<int64, bool>   map_int64_bool   = 623;
+	map<sint64, bool>  map_sint64_bool  = 624;
+	map<uint64, bool>  map_uint64_bool  = 625;
+	map<fixed32, bool> map_fixed32_bool = 626;
+	map<string, bool>  map_string_bool  = 627;
+
+	// Oneof fields.
+	oneof oneof_union {
+		bool     oneof_bool     = 700;
+		int32    oneof_int32    = 701;
+		sint32   oneof_sint32   = 702;
+		uint32   oneof_uint32   = 703;
+		int64    oneof_int64    = 704;
+		sint64   oneof_sint64   = 705;
+		uint64   oneof_uint64   = 706;
+		fixed32  oneof_fixed32  = 707;
+		sfixed32 oneof_sfixed32 = 708;
+		float    oneof_float    = 709;
+		fixed64  oneof_fixed64  = 710;
+		sfixed64 oneof_sfixed64 = 711;
+		double   oneof_double   = 712;
+		string   oneof_string   = 713;
+		bytes    oneof_bytes    = 714;
+
+		ChildEnum      oneof_child_enum      = 715;
+		ChildMessage   oneof_child_message   = 716;
+		NamedGroup     oneof_named_group     = 717;
+		SiblingEnum    oneof_sibling_enum    = 718;
+		SiblingMessage oneof_sibling_message = 719;
+		group OneofGroup = 720 {
+			optional string f1 = 1;
+			required string f2 = 2;
+			repeated string f3 = 3;
+		}
+
+		string oneof_string1 = 721;
+		string oneof_string2 = 722;
+		string oneof_string3 = 723;
+	}
+
+	// Oneof default fields.
+	oneof oneof_defaulted_union {
+		bool      oneof_defaulted_bool     = 800 [default = true];
+		int32     oneof_defaulted_int32    = 801 [default = -12345];
+		sint32    oneof_defaulted_sint32   = 802 [default = -3200];
+		uint32    oneof_defaulted_uint32   = 803 [default = 3200];
+		int64     oneof_defaulted_int64    = 804 [default = -123456789];
+		sint64    oneof_defaulted_sint64   = 805 [default = -6400];
+		uint64    oneof_defaulted_uint64   = 806 [default = 6400];
+		fixed32   oneof_defaulted_fixed32  = 807 [default = 320000];
+		sfixed32  oneof_defaulted_sfixed32 = 808 [default = -320000];
+		float     oneof_defaulted_float    = 809 [default = 3.14159];
+		fixed64   oneof_defaulted_fixed64  = 810 [default = 640000];
+		sfixed64  oneof_defaulted_sfixed64 = 811 [default = -640000];
+		double    oneof_defaulted_double   = 812 [default = 3.14159265359];
+		string    oneof_defaulted_string   = 813 [default = "hello, \"world!\"\n"];
+		bytes     oneof_defaulted_bytes    = 814 [default = "dead\xde\xad\xbe\xefbeef"];
+
+		ChildEnum   oneof_defaulted_child_enum   = 815 [default = ALPHA];
+		SiblingEnum oneof_defaulted_sibling_enum = 816 [default = ALPHA];
+	}
+
+	// Extension fields.
+	extend Message {
+		// Optional fields.
+		optional bool     extension_optional_bool     = 10000;
+		optional int32    extension_optional_int32    = 10001;
+		optional sint32   extension_optional_sint32   = 10002;
+		optional uint32   extension_optional_uint32   = 10003;
+		optional int64    extension_optional_int64    = 10004;
+		optional sint64   extension_optional_sint64   = 10005;
+		optional uint64   extension_optional_uint64   = 10006;
+		optional fixed32  extension_optional_fixed32  = 10007;
+		optional sfixed32 extension_optional_sfixed32 = 10008;
+		optional float    extension_optional_float    = 10009;
+		optional fixed64  extension_optional_fixed64  = 10010;
+		optional sfixed64 extension_optional_sfixed64 = 10011;
+		optional double   extension_optional_double   = 10012;
+		optional string   extension_optional_string   = 10013;
+		optional bytes    extension_optional_bytes    = 10014;
+
+		optional ChildEnum      extension_optional_child_enum      = 10015;
+		optional ChildMessage   extension_optional_child_message   = 10016;
+		optional NamedGroup     extension_optional_named_group     = 10017;
+		optional SiblingEnum    extension_optional_sibling_enum    = 10018;
+		optional SiblingMessage extension_optional_sibling_message = 10019;
+		optional group ExtensionOptionalGroup = 10020 {
+			optional string f1 = 1;
+			required string f2 = 2;
+			repeated string f3 = 3;
+		}
+
+		// Optional default fields.
+		optional bool      extension_defaulted_bool     = 20000 [default = true];
+		optional int32     extension_defaulted_int32    = 20001 [default = -12345];
+		optional sint32    extension_defaulted_sint32   = 20002 [default = -3200];
+		optional uint32    extension_defaulted_uint32   = 20003 [default = 3200];
+		optional int64     extension_defaulted_int64    = 20004 [default = -123456789];
+		optional sint64    extension_defaulted_sint64   = 20005 [default = -6400];
+		optional uint64    extension_defaulted_uint64   = 20006 [default = 6400];
+		optional fixed32   extension_defaulted_fixed32  = 20007 [default = 320000];
+		optional sfixed32  extension_defaulted_sfixed32 = 20008 [default = -320000];
+		optional float     extension_defaulted_float    = 20009 [default = 3.14159];
+		optional fixed64   extension_defaulted_fixed64  = 20010 [default = 640000];
+		optional sfixed64  extension_defaulted_sfixed64 = 20011 [default = -640000];
+		optional double    extension_defaulted_double   = 20012 [default = 3.14159265359];
+		optional string    extension_defaulted_string   = 20013 [default = "hello, \"world!\"\n"];
+		optional bytes     extension_defaulted_bytes    = 20014 [default = "dead\xde\xad\xbe\xefbeef"];
+
+		optional ChildEnum   extension_defaulted_child_enum   = 20015 [default = ALPHA];
+		optional SiblingEnum extension_defaulted_sibling_enum = 20016 [default = ALPHA];
+
+		// Repeated fields.
+		repeated bool     extension_repeated_bool     = 30000;
+		repeated int32    extension_repeated_int32    = 30001;
+		repeated sint32   extension_repeated_sint32   = 30002;
+		repeated uint32   extension_repeated_uint32   = 30003;
+		repeated int64    extension_repeated_int64    = 30004;
+		repeated sint64   extension_repeated_sint64   = 30005;
+		repeated uint64   extension_repeated_uint64   = 30006;
+		repeated fixed32  extension_repeated_fixed32  = 30007;
+		repeated sfixed32 extension_repeated_sfixed32 = 30008;
+		repeated float    extension_repeated_float    = 30009;
+		repeated fixed64  extension_repeated_fixed64  = 30010;
+		repeated sfixed64 extension_repeated_sfixed64 = 30011;
+		repeated double   extension_repeated_double   = 30012;
+		repeated string   extension_repeated_string   = 30013;
+		repeated bytes    extension_repeated_bytes    = 30014;
+
+		repeated ChildEnum      extension_repeated_child_enum      = 30015;
+		repeated ChildMessage   extension_repeated_child_message   = 30016;
+		repeated NamedGroup     extension_repeated_named_group     = 30017;
+		repeated SiblingEnum    extension_repeated_sibling_enum    = 30018;
+		repeated SiblingMessage extension_repeated_sibling_message = 30019;
+		repeated group ExtensionRepeatedGroup = 30020 {
+			optional string f1 = 1;
+			required string f2 = 2;
+			repeated string f3 = 3;
+		}
+	}
+
+	extensions 10000 to max;
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20160225_2fc053c5/test.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20160225_2fc053c5/test.pb.go
new file mode 100644
index 000000000..abae7ff9f
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20160225_2fc053c5/test.pb.go
@@ -0,0 +1,1185 @@
+// 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.
+
+// Code generated by protoc-gen-go.
+// source: proto3_20160225_2fc053c5/test.proto
+// DO NOT EDIT!
+
+/*
+Package proto3_20160225_2fc053c5 is a generated protocol buffer package.
+
+It is generated from these files:
+	proto3_20160225_2fc053c5/test.proto
+
+It has these top-level messages:
+	SiblingMessage
+	Message
+*/
+package proto3_20160225_2fc053c5
+
+import proto "google.golang.org/protobuf/internal/protolegacy"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+const _ = proto.ProtoPackageIsVersion1
+
+type SiblingEnum int32
+
+const (
+	SiblingEnum_ALPHA   SiblingEnum = 0
+	SiblingEnum_BRAVO   SiblingEnum = 10
+	SiblingEnum_CHARLIE SiblingEnum = 200
+)
+
+var SiblingEnum_name = map[int32]string{
+	0:   "ALPHA",
+	10:  "BRAVO",
+	200: "CHARLIE",
+}
+var SiblingEnum_value = map[string]int32{
+	"ALPHA":   0,
+	"BRAVO":   10,
+	"CHARLIE": 200,
+}
+
+func (x SiblingEnum) String() string {
+	return proto.EnumName(SiblingEnum_name, int32(x))
+}
+func (SiblingEnum) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+type Message_ChildEnum int32
+
+const (
+	Message_ALPHA   Message_ChildEnum = 0
+	Message_BRAVO   Message_ChildEnum = 1
+	Message_CHARLIE Message_ChildEnum = 2
+)
+
+var Message_ChildEnum_name = map[int32]string{
+	0: "ALPHA",
+	1: "BRAVO",
+	2: "CHARLIE",
+}
+var Message_ChildEnum_value = map[string]int32{
+	"ALPHA":   0,
+	"BRAVO":   1,
+	"CHARLIE": 2,
+}
+
+func (x Message_ChildEnum) String() string {
+	return proto.EnumName(Message_ChildEnum_name, int32(x))
+}
+func (Message_ChildEnum) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{1, 0} }
+
+type SiblingMessage struct {
+	F1 string   `protobuf:"bytes,1,opt,name=f1" json:"f1,omitempty"`
+	F2 []string `protobuf:"bytes,2,rep,name=f2" json:"f2,omitempty"`
+	F3 *Message `protobuf:"bytes,3,opt,name=f3" json:"f3,omitempty"`
+}
+
+func (m *SiblingMessage) Reset()                    { *m = SiblingMessage{} }
+func (m *SiblingMessage) String() string            { return proto.CompactTextString(m) }
+func (*SiblingMessage) ProtoMessage()               {}
+func (*SiblingMessage) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *SiblingMessage) GetF3() *Message {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message struct {
+	// 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,proto3" json:"optional_bytes,omitempty"`
+	OptionalChildEnum      Message_ChildEnum     `protobuf:"varint,115,opt,name=optional_child_enum,json=optionalChildEnum,enum=google.golang.org.proto3_20160225.Message_ChildEnum" json:"optional_child_enum,omitempty"`
+	OptionalChildMessage   *Message_ChildMessage `protobuf:"bytes,116,opt,name=optional_child_message,json=optionalChildMessage" json:"optional_child_message,omitempty"`
+	OptionalSiblingEnum    SiblingEnum           `protobuf:"varint,117,opt,name=optional_sibling_enum,json=optionalSiblingEnum,enum=google.golang.org.proto3_20160225.SiblingEnum" json:"optional_sibling_enum,omitempty"`
+	OptionalSiblingMessage *SiblingMessage       `protobuf:"bytes,118,opt,name=optional_sibling_message,json=optionalSiblingMessage" json:"optional_sibling_message,omitempty"`
+	// Repeated fields.
+	RepeatedBool           []bool                  `protobuf:"varint,200,rep,name=repeated_bool,json=repeatedBool" json:"repeated_bool,omitempty"`
+	RepeatedInt32          []int32                 `protobuf:"varint,201,rep,name=repeated_int32,json=repeatedInt32" json:"repeated_int32,omitempty"`
+	RepeatedSint32         []int32                 `protobuf:"zigzag32,202,rep,name=repeated_sint32,json=repeatedSint32" json:"repeated_sint32,omitempty"`
+	RepeatedUint32         []uint32                `protobuf:"varint,203,rep,name=repeated_uint32,json=repeatedUint32" json:"repeated_uint32,omitempty"`
+	RepeatedInt64          []int64                 `protobuf:"varint,204,rep,name=repeated_int64,json=repeatedInt64" json:"repeated_int64,omitempty"`
+	RepeatedSint64         []int64                 `protobuf:"zigzag64,205,rep,name=repeated_sint64,json=repeatedSint64" json:"repeated_sint64,omitempty"`
+	RepeatedUint64         []uint64                `protobuf:"varint,206,rep,name=repeated_uint64,json=repeatedUint64" json:"repeated_uint64,omitempty"`
+	RepeatedFixed32        []uint32                `protobuf:"fixed32,207,rep,name=repeated_fixed32,json=repeatedFixed32" json:"repeated_fixed32,omitempty"`
+	RepeatedSfixed32       []int32                 `protobuf:"fixed32,208,rep,name=repeated_sfixed32,json=repeatedSfixed32" json:"repeated_sfixed32,omitempty"`
+	RepeatedFloat          []float32               `protobuf:"fixed32,209,rep,name=repeated_float,json=repeatedFloat" json:"repeated_float,omitempty"`
+	RepeatedFixed64        []uint64                `protobuf:"fixed64,210,rep,name=repeated_fixed64,json=repeatedFixed64" json:"repeated_fixed64,omitempty"`
+	RepeatedSfixed64       []int64                 `protobuf:"fixed64,211,rep,name=repeated_sfixed64,json=repeatedSfixed64" json:"repeated_sfixed64,omitempty"`
+	RepeatedDouble         []float64               `protobuf:"fixed64,212,rep,name=repeated_double,json=repeatedDouble" json:"repeated_double,omitempty"`
+	RepeatedString         []string                `protobuf:"bytes,213,rep,name=repeated_string,json=repeatedString" json:"repeated_string,omitempty"`
+	RepeatedBytes          [][]byte                `protobuf:"bytes,214,rep,name=repeated_bytes,json=repeatedBytes,proto3" json:"repeated_bytes,omitempty"`
+	RepeatedChildEnum      []Message_ChildEnum     `protobuf:"varint,215,rep,name=repeated_child_enum,json=repeatedChildEnum,enum=google.golang.org.proto3_20160225.Message_ChildEnum" json:"repeated_child_enum,omitempty"`
+	RepeatedChildMessage   []*Message_ChildMessage `protobuf:"bytes,216,rep,name=repeated_child_message,json=repeatedChildMessage" json:"repeated_child_message,omitempty"`
+	RepeatedSiblingEnum    []SiblingEnum           `protobuf:"varint,217,rep,name=repeated_sibling_enum,json=repeatedSiblingEnum,enum=google.golang.org.proto3_20160225.SiblingEnum" json:"repeated_sibling_enum,omitempty"`
+	RepeatedSiblingMessage []*SiblingMessage       `protobuf:"bytes,218,rep,name=repeated_sibling_message,json=repeatedSiblingMessage" json:"repeated_sibling_message,omitempty"`
+	// Map fields.
+	MapBoolBool           map[bool]bool                  `protobuf:"bytes,300,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,301,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,302,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,303,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,304,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,305,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,306,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,307,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,308,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,309,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,310,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,311,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,312,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,313,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,314,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,proto3"`
+	MapBoolChildEnum      map[bool]Message_ChildEnum     `protobuf:"bytes,315,rep,name=map_bool_child_enum,json=mapBoolChildEnum" json:"map_bool_child_enum,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=google.golang.org.proto3_20160225.Message_ChildEnum"`
+	MapBoolChildMessage   map[bool]*Message_ChildMessage `protobuf:"bytes,316,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"`
+	MapBoolSiblingEnum    map[bool]SiblingEnum           `protobuf:"bytes,317,rep,name=map_bool_sibling_enum,json=mapBoolSiblingEnum" json:"map_bool_sibling_enum,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=google.golang.org.proto3_20160225.SiblingEnum"`
+	MapBoolSiblingMessage map[bool]*SiblingMessage       `protobuf:"bytes,318,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"`
+	MapInt32Bool          map[int32]bool                 `protobuf:"bytes,319,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,320,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,321,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,322,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,323,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,324,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,325,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,326,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.
+	//
+	// Types that are valid to be assigned to OneofUnion:
+	//	*Message_OneofBool
+	//	*Message_OneofInt32
+	//	*Message_OneofSint32
+	//	*Message_OneofUint32
+	//	*Message_OneofInt64
+	//	*Message_OneofSint64
+	//	*Message_OneofUint64
+	//	*Message_OneofFixed32
+	//	*Message_OneofSfixed32
+	//	*Message_OneofFloat
+	//	*Message_OneofFixed64
+	//	*Message_OneofSfixed64
+	//	*Message_OneofDouble
+	//	*Message_OneofString
+	//	*Message_OneofBytes
+	//	*Message_OneofChildEnum
+	//	*Message_OneofChildMessage
+	//	*Message_OneofSiblingEnum
+	//	*Message_OneofSiblingMessage
+	//	*Message_OneofString1
+	//	*Message_OneofString2
+	//	*Message_OneofString3
+	OneofUnion isMessage_OneofUnion `protobuf_oneof:"oneof_union"`
+}
+
+func (m *Message) Reset()                    { *m = Message{} }
+func (m *Message) String() string            { return proto.CompactTextString(m) }
+func (*Message) ProtoMessage()               {}
+func (*Message) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+type isMessage_OneofUnion interface{ isMessage_OneofUnion() }
+
+type Message_OneofBool struct {
+	OneofBool bool `protobuf:"varint,400,opt,name=oneof_bool,json=oneofBool,oneof"`
+}
+type Message_OneofInt32 struct {
+	OneofInt32 int32 `protobuf:"varint,401,opt,name=oneof_int32,json=oneofInt32,oneof"`
+}
+type Message_OneofSint32 struct {
+	OneofSint32 int32 `protobuf:"zigzag32,402,opt,name=oneof_sint32,json=oneofSint32,oneof"`
+}
+type Message_OneofUint32 struct {
+	OneofUint32 uint32 `protobuf:"varint,403,opt,name=oneof_uint32,json=oneofUint32,oneof"`
+}
+type Message_OneofInt64 struct {
+	OneofInt64 int64 `protobuf:"varint,404,opt,name=oneof_int64,json=oneofInt64,oneof"`
+}
+type Message_OneofSint64 struct {
+	OneofSint64 int64 `protobuf:"zigzag64,405,opt,name=oneof_sint64,json=oneofSint64,oneof"`
+}
+type Message_OneofUint64 struct {
+	OneofUint64 uint64 `protobuf:"varint,406,opt,name=oneof_uint64,json=oneofUint64,oneof"`
+}
+type Message_OneofFixed32 struct {
+	OneofFixed32 uint32 `protobuf:"fixed32,407,opt,name=oneof_fixed32,json=oneofFixed32,oneof"`
+}
+type Message_OneofSfixed32 struct {
+	OneofSfixed32 int32 `protobuf:"fixed32,408,opt,name=oneof_sfixed32,json=oneofSfixed32,oneof"`
+}
+type Message_OneofFloat struct {
+	OneofFloat float32 `protobuf:"fixed32,409,opt,name=oneof_float,json=oneofFloat,oneof"`
+}
+type Message_OneofFixed64 struct {
+	OneofFixed64 uint64 `protobuf:"fixed64,410,opt,name=oneof_fixed64,json=oneofFixed64,oneof"`
+}
+type Message_OneofSfixed64 struct {
+	OneofSfixed64 int64 `protobuf:"fixed64,411,opt,name=oneof_sfixed64,json=oneofSfixed64,oneof"`
+}
+type Message_OneofDouble struct {
+	OneofDouble float64 `protobuf:"fixed64,412,opt,name=oneof_double,json=oneofDouble,oneof"`
+}
+type Message_OneofString struct {
+	OneofString string `protobuf:"bytes,413,opt,name=oneof_string,json=oneofString,oneof"`
+}
+type Message_OneofBytes struct {
+	OneofBytes []byte `protobuf:"bytes,414,opt,name=oneof_bytes,json=oneofBytes,proto3,oneof"`
+}
+type Message_OneofChildEnum struct {
+	OneofChildEnum Message_ChildEnum `protobuf:"varint,415,opt,name=oneof_child_enum,json=oneofChildEnum,enum=google.golang.org.proto3_20160225.Message_ChildEnum,oneof"`
+}
+type Message_OneofChildMessage struct {
+	OneofChildMessage *Message_ChildMessage `protobuf:"bytes,416,opt,name=oneof_child_message,json=oneofChildMessage,oneof"`
+}
+type Message_OneofSiblingEnum struct {
+	OneofSiblingEnum SiblingEnum `protobuf:"varint,417,opt,name=oneof_sibling_enum,json=oneofSiblingEnum,enum=google.golang.org.proto3_20160225.SiblingEnum,oneof"`
+}
+type Message_OneofSiblingMessage struct {
+	OneofSiblingMessage *SiblingMessage `protobuf:"bytes,418,opt,name=oneof_sibling_message,json=oneofSiblingMessage,oneof"`
+}
+type Message_OneofString1 struct {
+	OneofString1 string `protobuf:"bytes,419,opt,name=oneof_string1,json=oneofString1,oneof"`
+}
+type Message_OneofString2 struct {
+	OneofString2 string `protobuf:"bytes,420,opt,name=oneof_string2,json=oneofString2,oneof"`
+}
+type Message_OneofString3 struct {
+	OneofString3 string `protobuf:"bytes,421,opt,name=oneof_string3,json=oneofString3,oneof"`
+}
+
+func (*Message_OneofBool) isMessage_OneofUnion()           {}
+func (*Message_OneofInt32) isMessage_OneofUnion()          {}
+func (*Message_OneofSint32) isMessage_OneofUnion()         {}
+func (*Message_OneofUint32) isMessage_OneofUnion()         {}
+func (*Message_OneofInt64) isMessage_OneofUnion()          {}
+func (*Message_OneofSint64) isMessage_OneofUnion()         {}
+func (*Message_OneofUint64) isMessage_OneofUnion()         {}
+func (*Message_OneofFixed32) isMessage_OneofUnion()        {}
+func (*Message_OneofSfixed32) isMessage_OneofUnion()       {}
+func (*Message_OneofFloat) isMessage_OneofUnion()          {}
+func (*Message_OneofFixed64) isMessage_OneofUnion()        {}
+func (*Message_OneofSfixed64) isMessage_OneofUnion()       {}
+func (*Message_OneofDouble) isMessage_OneofUnion()         {}
+func (*Message_OneofString) isMessage_OneofUnion()         {}
+func (*Message_OneofBytes) isMessage_OneofUnion()          {}
+func (*Message_OneofChildEnum) isMessage_OneofUnion()      {}
+func (*Message_OneofChildMessage) isMessage_OneofUnion()   {}
+func (*Message_OneofSiblingEnum) isMessage_OneofUnion()    {}
+func (*Message_OneofSiblingMessage) isMessage_OneofUnion() {}
+func (*Message_OneofString1) isMessage_OneofUnion()        {}
+func (*Message_OneofString2) isMessage_OneofUnion()        {}
+func (*Message_OneofString3) isMessage_OneofUnion()        {}
+
+func (m *Message) GetOneofUnion() isMessage_OneofUnion {
+	if m != nil {
+		return m.OneofUnion
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalChildMessage() *Message_ChildMessage {
+	if m != nil {
+		return m.OptionalChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalSiblingMessage() *SiblingMessage {
+	if m != nil {
+		return m.OptionalSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedChildMessage() []*Message_ChildMessage {
+	if m != nil {
+		return m.RepeatedChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSiblingMessage() []*SiblingMessage {
+	if m != nil {
+		return m.RepeatedSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolBool() map[bool]bool {
+	if m != nil {
+		return m.MapBoolBool
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolInt32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolInt32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSint32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolSint32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolUint32() map[bool]uint32 {
+	if m != nil {
+		return m.MapBoolUint32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolInt64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolInt64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSint64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolSint64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolUint64() map[bool]uint64 {
+	if m != nil {
+		return m.MapBoolUint64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFixed32() map[bool]uint32 {
+	if m != nil {
+		return m.MapBoolFixed32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSfixed32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolSfixed32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFloat() map[bool]float32 {
+	if m != nil {
+		return m.MapBoolFloat
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFixed64() map[bool]uint64 {
+	if m != nil {
+		return m.MapBoolFixed64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSfixed64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolSfixed64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolDouble() map[bool]float64 {
+	if m != nil {
+		return m.MapBoolDouble
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolString() map[bool]string {
+	if m != nil {
+		return m.MapBoolString
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolBytes() map[bool][]byte {
+	if m != nil {
+		return m.MapBoolBytes
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolChildEnum() map[bool]Message_ChildEnum {
+	if m != nil {
+		return m.MapBoolChildEnum
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolChildMessage() map[bool]*Message_ChildMessage {
+	if m != nil {
+		return m.MapBoolChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSiblingEnum() map[bool]SiblingEnum {
+	if m != nil {
+		return m.MapBoolSiblingEnum
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSiblingMessage() map[bool]*SiblingMessage {
+	if m != nil {
+		return m.MapBoolSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetMapInt32Bool() map[int32]bool {
+	if m != nil {
+		return m.MapInt32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapSint32Bool() map[int32]bool {
+	if m != nil {
+		return m.MapSint32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapUint32Bool() map[uint32]bool {
+	if m != nil {
+		return m.MapUint32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapInt64Bool() map[int64]bool {
+	if m != nil {
+		return m.MapInt64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapSint64Bool() map[int64]bool {
+	if m != nil {
+		return m.MapSint64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapUint64Bool() map[uint64]bool {
+	if m != nil {
+		return m.MapUint64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapFixed32Bool() map[uint32]bool {
+	if m != nil {
+		return m.MapFixed32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapStringBool() map[string]bool {
+	if m != nil {
+		return m.MapStringBool
+	}
+	return nil
+}
+
+func (m *Message) GetOneofBool() bool {
+	if x, ok := m.GetOneofUnion().(*Message_OneofBool); ok {
+		return x.OneofBool
+	}
+	return false
+}
+
+func (m *Message) GetOneofInt32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofInt32); ok {
+		return x.OneofInt32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSint32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSint32); ok {
+		return x.OneofSint32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofUint32() uint32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofUint32); ok {
+		return x.OneofUint32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofInt64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofInt64); ok {
+		return x.OneofInt64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSint64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSint64); ok {
+		return x.OneofSint64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofUint64() uint64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofUint64); ok {
+		return x.OneofUint64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFixed32() uint32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFixed32); ok {
+		return x.OneofFixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSfixed32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSfixed32); ok {
+		return x.OneofSfixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFloat() float32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFloat); ok {
+		return x.OneofFloat
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFixed64() uint64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFixed64); ok {
+		return x.OneofFixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSfixed64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSfixed64); ok {
+		return x.OneofSfixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofDouble() float64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofDouble); ok {
+		return x.OneofDouble
+	}
+	return 0
+}
+
+func (m *Message) GetOneofString() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString); ok {
+		return x.OneofString
+	}
+	return ""
+}
+
+func (m *Message) GetOneofBytes() []byte {
+	if x, ok := m.GetOneofUnion().(*Message_OneofBytes); ok {
+		return x.OneofBytes
+	}
+	return nil
+}
+
+func (m *Message) GetOneofChildEnum() Message_ChildEnum {
+	if x, ok := m.GetOneofUnion().(*Message_OneofChildEnum); ok {
+		return x.OneofChildEnum
+	}
+	return Message_ALPHA
+}
+
+func (m *Message) GetOneofChildMessage() *Message_ChildMessage {
+	if x, ok := m.GetOneofUnion().(*Message_OneofChildMessage); ok {
+		return x.OneofChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOneofSiblingEnum() SiblingEnum {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSiblingEnum); ok {
+		return x.OneofSiblingEnum
+	}
+	return SiblingEnum_ALPHA
+}
+
+func (m *Message) GetOneofSiblingMessage() *SiblingMessage {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSiblingMessage); ok {
+		return x.OneofSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOneofString1() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString1); ok {
+		return x.OneofString1
+	}
+	return ""
+}
+
+func (m *Message) GetOneofString2() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString2); ok {
+		return x.OneofString2
+	}
+	return ""
+}
+
+func (m *Message) GetOneofString3() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString3); ok {
+		return x.OneofString3
+	}
+	return ""
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*Message) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+	return _Message_OneofMarshaler, _Message_OneofUnmarshaler, _Message_OneofSizer, []interface{}{
+		(*Message_OneofBool)(nil),
+		(*Message_OneofInt32)(nil),
+		(*Message_OneofSint32)(nil),
+		(*Message_OneofUint32)(nil),
+		(*Message_OneofInt64)(nil),
+		(*Message_OneofSint64)(nil),
+		(*Message_OneofUint64)(nil),
+		(*Message_OneofFixed32)(nil),
+		(*Message_OneofSfixed32)(nil),
+		(*Message_OneofFloat)(nil),
+		(*Message_OneofFixed64)(nil),
+		(*Message_OneofSfixed64)(nil),
+		(*Message_OneofDouble)(nil),
+		(*Message_OneofString)(nil),
+		(*Message_OneofBytes)(nil),
+		(*Message_OneofChildEnum)(nil),
+		(*Message_OneofChildMessage)(nil),
+		(*Message_OneofSiblingEnum)(nil),
+		(*Message_OneofSiblingMessage)(nil),
+		(*Message_OneofString1)(nil),
+		(*Message_OneofString2)(nil),
+		(*Message_OneofString3)(nil),
+	}
+}
+
+func _Message_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*Message)
+	// oneof_union
+	switch x := m.OneofUnion.(type) {
+	case *Message_OneofBool:
+		t := uint64(0)
+		if x.OneofBool {
+			t = 1
+		}
+		b.EncodeVarint(400<<3 | proto.WireVarint)
+		b.EncodeVarint(t)
+	case *Message_OneofInt32:
+		b.EncodeVarint(401<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofInt32))
+	case *Message_OneofSint32:
+		b.EncodeVarint(402<<3 | proto.WireVarint)
+		b.EncodeZigzag32(uint64(x.OneofSint32))
+	case *Message_OneofUint32:
+		b.EncodeVarint(403<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofUint32))
+	case *Message_OneofInt64:
+		b.EncodeVarint(404<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofInt64))
+	case *Message_OneofSint64:
+		b.EncodeVarint(405<<3 | proto.WireVarint)
+		b.EncodeZigzag64(uint64(x.OneofSint64))
+	case *Message_OneofUint64:
+		b.EncodeVarint(406<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofUint64))
+	case *Message_OneofFixed32:
+		b.EncodeVarint(407<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(x.OneofFixed32))
+	case *Message_OneofSfixed32:
+		b.EncodeVarint(408<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(x.OneofSfixed32))
+	case *Message_OneofFloat:
+		b.EncodeVarint(409<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(math.Float32bits(x.OneofFloat)))
+	case *Message_OneofFixed64:
+		b.EncodeVarint(410<<3 | proto.WireFixed64)
+		b.EncodeFixed64(uint64(x.OneofFixed64))
+	case *Message_OneofSfixed64:
+		b.EncodeVarint(411<<3 | proto.WireFixed64)
+		b.EncodeFixed64(uint64(x.OneofSfixed64))
+	case *Message_OneofDouble:
+		b.EncodeVarint(412<<3 | proto.WireFixed64)
+		b.EncodeFixed64(math.Float64bits(x.OneofDouble))
+	case *Message_OneofString:
+		b.EncodeVarint(413<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString)
+	case *Message_OneofBytes:
+		b.EncodeVarint(414<<3 | proto.WireBytes)
+		b.EncodeRawBytes(x.OneofBytes)
+	case *Message_OneofChildEnum:
+		b.EncodeVarint(415<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofChildEnum))
+	case *Message_OneofChildMessage:
+		b.EncodeVarint(416<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.OneofChildMessage); err != nil {
+			return err
+		}
+	case *Message_OneofSiblingEnum:
+		b.EncodeVarint(417<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofSiblingEnum))
+	case *Message_OneofSiblingMessage:
+		b.EncodeVarint(418<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.OneofSiblingMessage); err != nil {
+			return err
+		}
+	case *Message_OneofString1:
+		b.EncodeVarint(419<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString1)
+	case *Message_OneofString2:
+		b.EncodeVarint(420<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString2)
+	case *Message_OneofString3:
+		b.EncodeVarint(421<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString3)
+	case nil:
+	default:
+		return fmt.Errorf("Message.OneofUnion has unexpected type %T", x)
+	}
+	return nil
+}
+
+func _Message_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*Message)
+	switch tag {
+	case 400: // oneof_union.oneof_bool
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofBool{x != 0}
+		return true, err
+	case 401: // oneof_union.oneof_int32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofInt32{int32(x)}
+		return true, err
+	case 402: // oneof_union.oneof_sint32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeZigzag32()
+		m.OneofUnion = &Message_OneofSint32{int32(x)}
+		return true, err
+	case 403: // oneof_union.oneof_uint32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofUint32{uint32(x)}
+		return true, err
+	case 404: // oneof_union.oneof_int64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofInt64{int64(x)}
+		return true, err
+	case 405: // oneof_union.oneof_sint64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeZigzag64()
+		m.OneofUnion = &Message_OneofSint64{int64(x)}
+		return true, err
+	case 406: // oneof_union.oneof_uint64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofUint64{x}
+		return true, err
+	case 407: // oneof_union.oneof_fixed32
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofUnion = &Message_OneofFixed32{uint32(x)}
+		return true, err
+	case 408: // oneof_union.oneof_sfixed32
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofUnion = &Message_OneofSfixed32{int32(x)}
+		return true, err
+	case 409: // oneof_union.oneof_float
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofUnion = &Message_OneofFloat{math.Float32frombits(uint32(x))}
+		return true, err
+	case 410: // oneof_union.oneof_fixed64
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofUnion = &Message_OneofFixed64{x}
+		return true, err
+	case 411: // oneof_union.oneof_sfixed64
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofUnion = &Message_OneofSfixed64{int64(x)}
+		return true, err
+	case 412: // oneof_union.oneof_double
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofUnion = &Message_OneofDouble{math.Float64frombits(x)}
+		return true, err
+	case 413: // oneof_union.oneof_string
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString{x}
+		return true, err
+	case 414: // oneof_union.oneof_bytes
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeRawBytes(true)
+		m.OneofUnion = &Message_OneofBytes{x}
+		return true, err
+	case 415: // oneof_union.oneof_child_enum
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofChildEnum{Message_ChildEnum(x)}
+		return true, err
+	case 416: // oneof_union.oneof_child_message
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(Message_ChildMessage)
+		err := b.DecodeMessage(msg)
+		m.OneofUnion = &Message_OneofChildMessage{msg}
+		return true, err
+	case 417: // oneof_union.oneof_sibling_enum
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofSiblingEnum{SiblingEnum(x)}
+		return true, err
+	case 418: // oneof_union.oneof_sibling_message
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(SiblingMessage)
+		err := b.DecodeMessage(msg)
+		m.OneofUnion = &Message_OneofSiblingMessage{msg}
+		return true, err
+	case 419: // oneof_union.oneof_string1
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString1{x}
+		return true, err
+	case 420: // oneof_union.oneof_string2
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString2{x}
+		return true, err
+	case 421: // oneof_union.oneof_string3
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString3{x}
+		return true, err
+	default:
+		return false, nil
+	}
+}
+
+func _Message_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*Message)
+	// oneof_union
+	switch x := m.OneofUnion.(type) {
+	case *Message_OneofBool:
+		n += proto.SizeVarint(400<<3 | proto.WireVarint)
+		n += 1
+	case *Message_OneofInt32:
+		n += proto.SizeVarint(401<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofInt32))
+	case *Message_OneofSint32:
+		n += proto.SizeVarint(402<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64((uint32(x.OneofSint32) << 1) ^ uint32((int32(x.OneofSint32) >> 31))))
+	case *Message_OneofUint32:
+		n += proto.SizeVarint(403<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofUint32))
+	case *Message_OneofInt64:
+		n += proto.SizeVarint(404<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofInt64))
+	case *Message_OneofSint64:
+		n += proto.SizeVarint(405<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(uint64(x.OneofSint64<<1) ^ uint64((int64(x.OneofSint64) >> 63))))
+	case *Message_OneofUint64:
+		n += proto.SizeVarint(406<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofUint64))
+	case *Message_OneofFixed32:
+		n += proto.SizeVarint(407<<3 | proto.WireFixed32)
+		n += 4
+	case *Message_OneofSfixed32:
+		n += proto.SizeVarint(408<<3 | proto.WireFixed32)
+		n += 4
+	case *Message_OneofFloat:
+		n += proto.SizeVarint(409<<3 | proto.WireFixed32)
+		n += 4
+	case *Message_OneofFixed64:
+		n += proto.SizeVarint(410<<3 | proto.WireFixed64)
+		n += 8
+	case *Message_OneofSfixed64:
+		n += proto.SizeVarint(411<<3 | proto.WireFixed64)
+		n += 8
+	case *Message_OneofDouble:
+		n += proto.SizeVarint(412<<3 | proto.WireFixed64)
+		n += 8
+	case *Message_OneofString:
+		n += proto.SizeVarint(413<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofString)))
+		n += len(x.OneofString)
+	case *Message_OneofBytes:
+		n += proto.SizeVarint(414<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofBytes)))
+		n += len(x.OneofBytes)
+	case *Message_OneofChildEnum:
+		n += proto.SizeVarint(415<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofChildEnum))
+	case *Message_OneofChildMessage:
+		s := proto.Size(x.OneofChildMessage)
+		n += proto.SizeVarint(416<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *Message_OneofSiblingEnum:
+		n += proto.SizeVarint(417<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofSiblingEnum))
+	case *Message_OneofSiblingMessage:
+		s := proto.Size(x.OneofSiblingMessage)
+		n += proto.SizeVarint(418<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *Message_OneofString1:
+		n += proto.SizeVarint(419<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofString1)))
+		n += len(x.OneofString1)
+	case *Message_OneofString2:
+		n += proto.SizeVarint(420<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofString2)))
+		n += len(x.OneofString2)
+	case *Message_OneofString3:
+		n += proto.SizeVarint(421<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofString3)))
+		n += len(x.OneofString3)
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	return n
+}
+
+type Message_ChildMessage struct {
+	F1 string   `protobuf:"bytes,1,opt,name=f1" json:"f1,omitempty"`
+	F2 []string `protobuf:"bytes,2,rep,name=f2" json:"f2,omitempty"`
+	F3 *Message `protobuf:"bytes,3,opt,name=f3" json:"f3,omitempty"`
+}
+
+func (m *Message_ChildMessage) Reset()                    { *m = Message_ChildMessage{} }
+func (m *Message_ChildMessage) String() string            { return proto.CompactTextString(m) }
+func (*Message_ChildMessage) ProtoMessage()               {}
+func (*Message_ChildMessage) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1, 0} }
+
+func (m *Message_ChildMessage) GetF3() *Message {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*SiblingMessage)(nil), "google.golang.org.proto3_20160225.SiblingMessage")
+	proto.RegisterType((*Message)(nil), "google.golang.org.proto3_20160225.Message")
+	proto.RegisterType((*Message_ChildMessage)(nil), "google.golang.org.proto3_20160225.Message.ChildMessage")
+	proto.RegisterEnum("google.golang.org.proto3_20160225.SiblingEnum", SiblingEnum_name, SiblingEnum_value)
+	proto.RegisterEnum("google.golang.org.proto3_20160225.Message_ChildEnum", Message_ChildEnum_name, Message_ChildEnum_value)
+}
+
+var fileDescriptor0 = []byte{
+	// 1946 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x9a, 0x57, 0x73, 0xdb, 0xca,
+	0x15, 0xc7, 0x09, 0x52, 0xc5, 0x5a, 0xb1, 0x82, 0x96, 0xb2, 0xa3, 0x27, 0x44, 0x76, 0x1c, 0xc4,
+	0xc9, 0x50, 0x16, 0x09, 0x23, 0x19, 0x27, 0xb1, 0x2d, 0xd9, 0x72, 0xe8, 0x8c, 0x9d, 0x78, 0xe0,
+	0x51, 0x1e, 0xf2, 0xa2, 0x50, 0x12, 0x48, 0xd3, 0x06, 0x09, 0x45, 0x24, 0x3d, 0xd1, 0xe4, 0xc1,
+	0x5f, 0x21, 0xf5, 0xf6, 0x5e, 0xde, 0x6e, 0xef, 0xbd, 0xfb, 0x8e, 0x6f, 0xef, 0xf5, 0xd3, 0xdc,
+	0x59, 0x1c, 0x6c, 0x03, 0x40, 0x93, 0x04, 0xe7, 0x3e, 0x78, 0x46, 0x3a, 0xfc, 0xef, 0xf9, 0xf1,
+	0x1c, 0x9c, 0x3d, 0x67, 0x17, 0x16, 0x3a, 0xb0, 0xb3, 0xeb, 0x76, 0xdd, 0xca, 0x46, 0xf9, 0xc8,
+	0xb2, 0x79, 0xa4, 0x5c, 0x3e, 0xba, 0x51, 0xae, 0x6f, 0x1d, 0x39, 0x5a, 0xd9, 0x3a, 0xba, 0xd4,
+	0xb5, 0x3b, 0xdd, 0x92, 0xf7, 0xa9, 0xfa, 0xd3, 0x86, 0xeb, 0x36, 0x1c, 0xbb, 0xd4, 0x70, 0x9d,
+	0x5a, 0xbb, 0x51, 0x72, 0x77, 0x1b, 0xa5, 0xc0, 0xb2, 0x45, 0x07, 0x65, 0x2f, 0x36, 0x37, 0x9d,
+	0x66, 0xbb, 0x71, 0xde, 0xee, 0x74, 0x6a, 0x0d, 0x5b, 0xcd, 0xa2, 0x64, 0x7d, 0x19, 0x2b, 0x9a,
+	0xa2, 0xcf, 0x58, 0xc9, 0xfa, 0xb2, 0xf7, 0x7b, 0x19, 0x27, 0xb5, 0x94, 0xf7, 0x7b, 0x59, 0x3d,
+	0x86, 0x92, 0xf5, 0x0a, 0x4e, 0x69, 0x8a, 0x3e, 0x5b, 0x3e, 0x5c, 0x1a, 0x48, 0x28, 0xf9, 0x7e,
+	0xad, 0x64, 0xbd, 0xb2, 0x78, 0xfd, 0x24, 0x9a, 0xa6, 0x9c, 0x03, 0x28, 0xe3, 0xee, 0x74, 0x9b,
+	0x6e, 0xbb, 0xe6, 0x6c, 0x6c, 0xba, 0xae, 0x83, 0xb7, 0x35, 0x45, 0xdf, 0x67, 0xa5, 0xa9, 0x71,
+	0xd5, 0x75, 0x1d, 0xf5, 0x67, 0x28, 0xcb, 0x44, 0xcd, 0x76, 0xb7, 0x52, 0xc6, 0xb6, 0xa6, 0xe8,
+	0x93, 0x16, 0x5b, 0x7a, 0x96, 0x18, 0xd5, 0x9f, 0xa3, 0x1c, 0x93, 0x75, 0x40, 0x57, 0xd7, 0x14,
+	0xbd, 0x60, 0xb1, 0xd5, 0x17, 0x9b, 0x21, 0x61, 0x0f, 0x84, 0x0d, 0x4d, 0xd1, 0x33, 0x5c, 0xb8,
+	0x0e, 0xc2, 0x00, 0xd8, 0x34, 0xf0, 0x25, 0x4d, 0xd1, 0x53, 0x12, 0xd8, 0x34, 0x42, 0x60, 0xd3,
+	0xc0, 0x4d, 0x4d, 0xd1, 0x55, 0x19, 0x1c, 0x10, 0xf6, 0x40, 0x78, 0x59, 0x53, 0xf4, 0x09, 0x19,
+	0x6c, 0x1a, 0xea, 0x2f, 0x50, 0x9e, 0x09, 0xeb, 0xcd, 0x7f, 0xd8, 0xdb, 0x95, 0x32, 0xbe, 0xa2,
+	0x29, 0xfa, 0xb4, 0xc5, 0x1c, 0x9c, 0x01, 0xb3, 0xfa, 0x4b, 0x54, 0xe0, 0x70, 0xaa, 0x75, 0x34,
+	0x45, 0xcf, 0x59, 0xcc, 0xc7, 0x45, 0xdf, 0x2e, 0x05, 0x54, 0x77, 0xdc, 0x5a, 0x17, 0xb7, 0x34,
+	0x45, 0x4f, 0xf2, 0x80, 0xce, 0x10, 0x63, 0x18, 0x6f, 0x1a, 0xb8, 0xad, 0x29, 0xfa, 0x54, 0x00,
+	0x6f, 0x1a, 0x11, 0x78, 0xd3, 0xc0, 0xae, 0xa6, 0xe8, 0xf9, 0x20, 0x3e, 0x10, 0xff, 0xb6, 0xdb,
+	0xdb, 0x74, 0x6c, 0xbc, 0xa3, 0x29, 0xba, 0xc2, 0xe3, 0x3f, 0xed, 0x59, 0xe5, 0x8c, 0x76, 0x77,
+	0x9b, 0xed, 0x06, 0xfe, 0xbb, 0x57, 0x8b, 0x3c, 0xa3, 0x9e, 0x55, 0x0a, 0x68, 0x73, 0xaf, 0x6b,
+	0x77, 0xf0, 0xae, 0xa6, 0xe8, 0x69, 0x1e, 0xd0, 0x2a, 0x31, 0xaa, 0xdb, 0xa8, 0xc8, 0x64, 0x5b,
+	0x97, 0x9a, 0xce, 0xf6, 0x86, 0xdd, 0xee, 0xb5, 0x70, 0x47, 0x53, 0xf4, 0x6c, 0xd9, 0x18, 0xbe,
+	0x7e, 0x4b, 0xa7, 0xc8, 0xe2, 0xb5, 0x76, 0xaf, 0x65, 0xb1, 0xb0, 0x99, 0x49, 0x6d, 0xa1, 0xf9,
+	0x00, 0xa5, 0x05, 0xcb, 0x70, 0xd7, 0xdb, 0x28, 0xbf, 0x1e, 0x15, 0x44, 0x77, 0xcd, 0x7e, 0x89,
+	0x45, 0xf7, 0xce, 0x26, 0x9a, 0x13, 0xca, 0xce, 0xdb, 0xbe, 0x10, 0x56, 0xcf, 0x0b, 0xab, 0x34,
+	0x04, 0xcd, 0xdf, 0xf5, 0x5e, 0x40, 0x45, 0x5e, 0xac, 0xcc, 0xa8, 0x5e, 0x41, 0x38, 0xc4, 0xa0,
+	0x41, 0x5d, 0xf5, 0x82, 0x5a, 0x1e, 0x1e, 0x43, 0xc3, 0x99, 0x0f, 0x90, 0x68, 0x40, 0x07, 0x51,
+	0x66, 0xd7, 0xde, 0xb1, 0x6b, 0x5d, 0x7b, 0x1b, 0x9a, 0xc1, 0x0d, 0x45, 0x4b, 0x91, 0x6e, 0x40,
+	0xad, 0x5e, 0x37, 0x38, 0x84, 0xb2, 0x4c, 0x05, 0x9b, 0xf7, 0x3d, 0x22, 0x9b, 0xb4, 0xd8, 0x62,
+	0x68, 0x07, 0x3a, 0xca, 0x31, 0x9d, 0xdf, 0x0e, 0xde, 0x27, 0xc2, 0x82, 0xc5, 0xd6, 0xfb, 0xfd,
+	0x40, 0x54, 0xfa, 0xfd, 0xe0, 0x03, 0xa2, 0xcc, 0x70, 0xa5, 0xdf, 0x10, 0x02, 0x6c, 0xd3, 0xc0,
+	0x1f, 0x12, 0x61, 0x4a, 0x62, 0x9b, 0x46, 0x88, 0x6d, 0x1a, 0xf8, 0x23, 0x22, 0x54, 0x65, 0x76,
+	0x40, 0xe9, 0xb7, 0x84, 0x8f, 0x89, 0x72, 0x42, 0x66, 0x9b, 0x86, 0x7a, 0x18, 0xe5, 0x99, 0x92,
+	0xee, 0xf3, 0x4f, 0x88, 0x74, 0xda, 0x62, 0x2e, 0x68, 0x53, 0xf8, 0x15, 0x2a, 0x70, 0x3e, 0x15,
+	0x7f, 0x4a, 0xc4, 0x39, 0x8b, 0x79, 0x61, 0x5d, 0x41, 0x8c, 0x0a, 0xba, 0xc2, 0x67, 0x44, 0x9a,
+	0xe4, 0x51, 0x41, 0x5b, 0x08, 0x7d, 0x03, 0xd3, 0xc0, 0x9f, 0x13, 0xe5, 0x54, 0xe0, 0x1b, 0x98,
+	0x46, 0xc4, 0x37, 0x30, 0x0d, 0xfc, 0x05, 0x11, 0xe7, 0x83, 0xdf, 0x20, 0x90, 0x05, 0xbf, 0x31,
+	0x7c, 0x49, 0xb4, 0x0a, 0xcf, 0x82, 0xdf, 0x19, 0xa4, 0xcc, 0x42, 0x67, 0xf8, 0x4a, 0xf1, 0xc6,
+	0x12, 0xcf, 0x2c, 0xb4, 0x06, 0x31, 0x2a, 0x68, 0x0d, 0x5f, 0x13, 0x61, 0x9a, 0x47, 0x05, 0xbd,
+	0xc1, 0x46, 0x45, 0xa6, 0x13, 0x7a, 0xc3, 0x37, 0x44, 0x1c, 0xbb, 0x39, 0x50, 0x8f, 0xbc, 0x39,
+	0xb4, 0xd1, 0x7c, 0x00, 0x43, 0xf7, 0xd1, 0xb7, 0x84, 0x34, 0x4e, 0x77, 0x90, 0x60, 0x74, 0x33,
+	0x6d, 0xa1, 0x39, 0xa1, 0x04, 0x85, 0xee, 0xf0, 0x1d, 0x04, 0x36, 0x72, 0x7b, 0xe0, 0x85, 0xcb,
+	0xdb, 0x83, 0x83, 0x70, 0x08, 0x42, 0xc3, 0xfa, 0x1e, 0xc2, 0x8a, 0xd3, 0x1f, 0x02, 0x28, 0x1a,
+	0xd2, 0xdf, 0x50, 0xa6, 0x55, 0xdb, 0xf1, 0x5a, 0x03, 0xf4, 0x87, 0x47, 0x92, 0x1e, 0xe2, 0xb7,
+	0x23, 0x64, 0xee, 0x7c, 0x6d, 0x87, 0x74, 0x11, 0xf2, 0x6f, 0xad, 0xdd, 0xdd, 0xdd, 0xb3, 0x66,
+	0x5b, 0xdc, 0xa2, 0x6e, 0xa1, 0x2c, 0x23, 0x40, 0x23, 0x78, 0x14, 0x10, 0xbf, 0x1b, 0x1d, 0xe1,
+	0x75, 0x21, 0x60, 0xa4, 0x5b, 0x82, 0x49, 0xad, 0xa3, 0x1c, 0x83, 0xf8, 0x8d, 0xe9, 0x31, 0xa0,
+	0xfc, 0x7e, 0x74, 0x0a, 0xb4, 0x30, 0xc0, 0x64, 0x5a, 0xa2, 0x4d, 0xe2, 0xf8, 0x6d, 0xed, 0xf1,
+	0xd8, 0x9c, 0xf5, 0x08, 0x8e, 0xdf, 0x14, 0x03, 0x49, 0x33, 0x0d, 0xfc, 0xc4, 0x38, 0x49, 0x33,
+	0x8d, 0x50, 0xd2, 0x4c, 0x23, 0x94, 0x34, 0xd3, 0xc0, 0x4f, 0x8e, 0x95, 0x34, 0x8a, 0x11, 0x93,
+	0x16, 0xe0, 0xf8, 0xfd, 0xf8, 0xa9, 0xb1, 0x92, 0x16, 0xe4, 0xf8, 0xdd, 0xbc, 0x89, 0xf2, 0x8c,
+	0x43, 0x1b, 0xf4, 0xd3, 0x00, 0x3a, 0x3e, 0x3a, 0xc8, 0xef, 0xfb, 0x40, 0xca, 0xb6, 0x24, 0xa3,
+	0xea, 0xa0, 0x02, 0x4f, 0x1d, 0x65, 0x3d, 0x03, 0xac, 0x13, 0x31, 0x92, 0x57, 0x17, 0x61, 0xb9,
+	0x96, 0x6c, 0x95, 0xaa, 0x01, 0x86, 0xc9, 0xb3, 0xb1, 0xab, 0xc1, 0x1b, 0x3b, 0x72, 0x35, 0xc0,
+	0x24, 0x0a, 0x65, 0xcf, 0x34, 0xf0, 0x73, 0xe3, 0x65, 0x8f, 0x3e, 0x27, 0x29, 0x7b, 0xa6, 0x11,
+	0x91, 0x3d, 0xd3, 0xc0, 0xcf, 0x8f, 0x99, 0x3d, 0x0a, 0x93, 0xb3, 0x17, 0x28, 0x3f, 0x7f, 0x10,
+	0xbe, 0x10, 0xbb, 0xfc, 0x60, 0x64, 0xca, 0xe5, 0xe7, 0x8f, 0x51, 0x69, 0x3b, 0xc1, 0x18, 0x7d,
+	0x31, 0xfe, 0x76, 0xf2, 0x1c, 0x04, 0xb6, 0x13, 0x0c, 0x61, 0xb1, 0x1a, 0x60, 0x08, 0xbf, 0x14,
+	0xbb, 0x1a, 0xbc, 0x71, 0x2d, 0x57, 0x03, 0x4c, 0xf0, 0x1d, 0x54, 0x64, 0x10, 0x61, 0x82, 0xbf,
+	0x0c, 0xa4, 0x93, 0xa3, 0x93, 0xd8, 0xd4, 0x06, 0x5a, 0xbe, 0x15, 0x30, 0xab, 0x7b, 0x68, 0x3e,
+	0x40, 0xa4, 0x53, 0xef, 0x15, 0x80, 0x9e, 0x8a, 0x09, 0xf5, 0x6d, 0xc0, 0x2d, 0xb6, 0xc2, 0x9f,
+	0xa8, 0x57, 0xd1, 0x9c, 0xd0, 0x08, 0x85, 0xb9, 0xfe, 0x2a, 0x90, 0x57, 0xe3, 0xb4, 0x43, 0x36,
+	0xd1, 0x01, 0xac, 0xb6, 0x42, 0x1f, 0xa8, 0xd7, 0x10, 0x0e, 0x71, 0x69, 0xd0, 0xaf, 0x01, 0x7a,
+	0x2d, 0x36, 0x5a, 0x0a, 0x7b, 0xae, 0x15, 0xf5, 0x19, 0x2d, 0x25, 0x6f, 0xe6, 0xc0, 0xf8, 0x7f,
+	0x3d, 0x56, 0x29, 0x79, 0x43, 0x98, 0xcf, 0x7f, 0x52, 0x4a, 0xcc, 0x44, 0xf7, 0x45, 0x47, 0xa0,
+	0xbc, 0x11, 0x6b, 0x5f, 0xc0, 0x0c, 0xe6, 0x18, 0xb2, 0x2f, 0xb8, 0x8d, 0x72, 0x7a, 0x02, 0xe7,
+	0xcd, 0x58, 0x9c, 0xf5, 0x08, 0x0e, 0xb7, 0x09, 0x49, 0x33, 0x0d, 0xc0, 0xbc, 0x15, 0x37, 0x69,
+	0xa6, 0x11, 0x4a, 0x1a, 0x98, 0xc4, 0xa4, 0x51, 0xca, 0xdb, 0xb1, 0x93, 0x26, 0x62, 0x68, 0xd2,
+	0x64, 0x4e, 0x4f, 0xe0, 0xbc, 0x13, 0x3b, 0x69, 0x41, 0x0e, 0xb7, 0xd1, 0xe9, 0xe2, 0x4f, 0x34,
+	0x00, 0x5d, 0x8f, 0x35, 0x5d, 0xfc, 0x11, 0xcc, 0x49, 0xe4, 0x69, 0x08, 0x46, 0x96, 0x3a, 0xaf,
+	0x5b, 0x02, 0xe9, 0xdd, 0x78, 0xa9, 0xf3, 0x3c, 0x04, 0x52, 0xc7, 0x6c, 0xaa, 0x86, 0x90, 0xdb,
+	0xb6, 0xdd, 0x3a, 0x20, 0xfe, 0x95, 0xd2, 0x14, 0x7d, 0x5f, 0x35, 0x61, 0xcd, 0x78, 0x46, 0x4f,
+	0xb1, 0x88, 0x66, 0x41, 0x01, 0x27, 0xc5, 0x7f, 0x13, 0xc9, 0x64, 0x35, 0x61, 0xc1, 0x3a, 0x38,
+	0xb9, 0x1e, 0x44, 0x69, 0xd0, 0xf8, 0xc7, 0xd6, 0xff, 0x10, 0x51, 0xa1, 0x9a, 0xb0, 0x60, 0xa9,
+	0x7f, 0xee, 0x64, 0x2a, 0xff, 0xd0, 0xf9, 0x5f, 0xa2, 0xca, 0x30, 0x95, 0x7f, 0x6a, 0x14, 0x79,
+	0xa6, 0x81, 0xff, 0x47, 0x44, 0x29, 0x91, 0x67, 0x1a, 0x32, 0xcf, 0x34, 0xf0, 0xff, 0x89, 0x48,
+	0x95, 0x78, 0xa2, 0xca, 0x3f, 0xaf, 0xdd, 0x42, 0x54, 0x13, 0x12, 0xcf, 0x34, 0xd4, 0x43, 0x28,
+	0x03, 0x2a, 0x7a, 0x02, 0xba, 0x95, 0xc8, 0xa6, 0xab, 0x09, 0x0b, 0x56, 0xd3, 0xd3, 0x92, 0x8e,
+	0xb2, 0x3e, 0x93, 0x0a, 0x6f, 0x23, 0xc2, 0x5c, 0x35, 0x61, 0x81, 0x03, 0x76, 0xd2, 0x61, 0x11,
+	0xc0, 0x31, 0xe7, 0x76, 0x22, 0x4b, 0xb2, 0x08, 0xe0, 0xa0, 0x22, 0x53, 0x4d, 0x03, 0xdf, 0x41,
+	0x54, 0x53, 0x32, 0xd5, 0xbb, 0x00, 0x4b, 0x54, 0xd3, 0xc0, 0x77, 0x12, 0x61, 0x3e, 0x40, 0x15,
+	0xa3, 0xf5, 0x8f, 0x07, 0x77, 0x11, 0x9d, 0xc2, 0xa2, 0xf5, 0xe7, 0x3b, 0xcf, 0x1c, 0x0c, 0xf7,
+	0xbb, 0x89, 0x6a, 0x86, 0x67, 0x0e, 0xa6, 0x33, 0x8b, 0x00, 0x46, 0xf3, 0x3d, 0x44, 0x94, 0x66,
+	0x11, 0xc0, 0x70, 0xad, 0xa1, 0x3c, 0x68, 0x84, 0xc9, 0x7a, 0x6f, 0x2a, 0xfe, 0x8b, 0xb3, 0x6a,
+	0xc2, 0x82, 0x50, 0xf9, 0x34, 0xbd, 0x8c, 0x8a, 0x22, 0x82, 0x4e, 0x95, 0xfb, 0x52, 0x63, 0xbd,
+	0x35, 0xab, 0x26, 0xac, 0x02, 0x07, 0xd1, 0x29, 0xb2, 0x81, 0x54, 0x5a, 0x52, 0xc2, 0xec, 0xbc,
+	0x3f, 0x15, 0xe7, 0x95, 0x59, 0x35, 0x61, 0xe5, 0xfd, 0x42, 0xe4, 0x73, 0xf2, 0x12, 0x9a, 0x93,
+	0x01, 0x34, 0x9c, 0x07, 0x52, 0x31, 0xdf, 0x97, 0x55, 0x13, 0x56, 0x51, 0xc4, 0xd0, 0x50, 0x58,
+	0x6d, 0xc1, 0x33, 0x5e, 0xc6, 0x0f, 0xd2, 0x87, 0x9c, 0x16, 0x1e, 0xf2, 0x72, 0x50, 0x57, 0xc6,
+	0x0f, 0x45, 0xe9, 0xca, 0x41, 0x5d, 0x05, 0x3f, 0x1c, 0xa5, 0xab, 0x2c, 0x5c, 0x46, 0x69, 0x29,
+	0xa5, 0x3f, 0xe2, 0xff, 0x15, 0x2c, 0x1c, 0x47, 0xf9, 0xe0, 0x8d, 0x5d, 0xcd, 0xa3, 0xd4, 0x15,
+	0x7b, 0xcf, 0x03, 0xee, 0xb3, 0xc8, 0x8f, 0xea, 0x7e, 0x34, 0x79, 0xb5, 0xe6, 0xf4, 0x6c, 0x9c,
+	0xf4, 0x6c, 0xf0, 0xcb, 0xb1, 0xe4, 0x6f, 0x94, 0x85, 0x13, 0xa8, 0x10, 0xba, 0x8e, 0x0f, 0x72,
+	0x30, 0x29, 0x3a, 0x38, 0x89, 0xd4, 0xf0, 0x4d, 0x7b, 0x90, 0x87, 0x42, 0xb4, 0x87, 0xf5, 0xe1,
+	0x3d, 0x64, 0xfa, 0x06, 0xe1, 0x5f, 0x1d, 0x06, 0x39, 0x48, 0xf5, 0x0f, 0x62, 0x48, 0x0f, 0x6a,
+	0xff, 0x20, 0x86, 0xf4, 0x30, 0x21, 0x7a, 0x58, 0x41, 0xc5, 0x88, 0xcb, 0xea, 0x20, 0x17, 0xd3,
+	0xa2, 0x8b, 0x55, 0xb4, 0x3f, 0xea, 0x0e, 0x3a, 0xc8, 0x47, 0x2e, 0x3a, 0x97, 0xfc, 0x72, 0x39,
+	0xc8, 0x41, 0xf2, 0x26, 0x71, 0x0c, 0x99, 0x8a, 0xa9, 0x9b, 0xc5, 0x31, 0xa4, 0x8f, 0x7c, 0xf4,
+	0x03, 0x11, 0x6e, 0x79, 0x83, 0x3c, 0x28, 0x7d, 0x8a, 0x82, 0xdf, 0xdf, 0x06, 0x79, 0x98, 0x89,
+	0xce, 0x25, 0xbf, 0x9a, 0x0d, 0x72, 0x90, 0x16, 0x1d, 0xec, 0xa1, 0xb9, 0xc8, 0x1b, 0x57, 0x84,
+	0x93, 0x3f, 0x8a, 0x4e, 0xe2, 0xbe, 0x96, 0x15, 0xd0, 0xd7, 0x10, 0xee, 0x77, 0xef, 0x8a, 0xa0,
+	0x9f, 0x17, 0xe9, 0x63, 0xbc, 0xaa, 0x15, 0xbe, 0x40, 0x0f, 0xfd, 0xa4, 0xcf, 0xf5, 0x2b, 0x82,
+	0x7f, 0x5a, 0x8e, 0x7e, 0xd4, 0x77, 0xb7, 0x02, 0xf6, 0x9f, 0x68, 0xa1, 0xff, 0xd5, 0x2b, 0x82,
+	0xfc, 0x07, 0x39, 0xf2, 0x18, 0x6f, 0x73, 0x43, 0x05, 0x23, 0x5f, 0xc0, 0x44, 0xe6, 0xe4, 0xa0,
+	0x76, 0x0e, 0x35, 0x1b, 0xb8, 0x5b, 0x89, 0x1e, 0x0a, 0xc3, 0x79, 0x58, 0xef, 0xef, 0x21, 0x33,
+	0xdc, 0x48, 0x91, 0x2f, 0x44, 0xa2, 0x83, 0xd4, 0xf0, 0x41, 0xf4, 0xf1, 0xa0, 0x0e, 0x1f, 0x44,
+	0x1f, 0x0f, 0x13, 0x83, 0x3c, 0x40, 0x17, 0x0b, 0x5e, 0x4f, 0x44, 0x17, 0xd3, 0x43, 0x86, 0x21,
+	0xdf, 0x3b, 0x44, 0x0f, 0x33, 0x03, 0x3c, 0x2c, 0x96, 0xd0, 0x0c, 0x3f, 0x04, 0xce, 0xa0, 0xc9,
+	0x95, 0x73, 0x17, 0xaa, 0x2b, 0xf9, 0x04, 0xf9, 0x71, 0xd5, 0x5a, 0xf9, 0xcb, 0x9f, 0xf3, 0x8a,
+	0x3a, 0x8b, 0xa6, 0x4f, 0x55, 0x57, 0xac, 0x73, 0x67, 0xd7, 0xf2, 0xc9, 0xd5, 0x0c, 0x3d, 0xae,
+	0xf6, 0xda, 0x4d, 0xb7, 0x7d, 0x78, 0x19, 0xcd, 0x8a, 0x07, 0xaf, 0x28, 0x07, 0x48, 0x4d, 0x73,
+	0x07, 0x37, 0x94, 0xd5, 0x0b, 0x7f, 0xfd, 0x53, 0xa8, 0x7e, 0x97, 0xbc, 0xfa, 0xdd, 0xec, 0xd5,
+	0x97, 0x9a, 0xed, 0xae, 0xbd, 0xdb, 0xae, 0x39, 0xde, 0x5f, 0x4f, 0x78, 0xd6, 0xce, 0x92, 0x63,
+	0x37, 0x6a, 0x5b, 0x7b, 0x4b, 0xfd, 0xfe, 0xd0, 0x62, 0x73, 0x0a, 0x3e, 0xf9, 0x21, 0x00, 0x00,
+	0xff, 0xff, 0x64, 0x49, 0xbf, 0xf0, 0x8b, 0x21, 0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20160225_2fc053c5/test.proto b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20160225_2fc053c5/test.proto
new file mode 100644
index 000000000..7a0a6f2af
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20160225_2fc053c5/test.proto
@@ -0,0 +1,136 @@
+// 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.
+
+syntax = "proto3";
+
+package google.golang.org.proto3_20160225;
+option go_package = "google.golang.org/protobuf/internal/testprotos/legacy/proto3_20160225_2fc053c5";
+
+enum SiblingEnum {
+	ALPHA   = 0;
+	BRAVO   = 10;
+	CHARLIE = 200;
+}
+
+message SiblingMessage {
+	string          f1 = 1;
+	repeated string f2 = 2;
+	Message         f3 = 3;
+}
+
+message Message {
+	enum ChildEnum {
+		ALPHA   = 0;
+		BRAVO   = 1;
+		CHARLIE = 2;
+	}
+	message ChildMessage {
+		string          f1 = 1;
+		repeated string f2 = 2;
+		Message         f3 = 3;
+	}
+
+	// Optional fields.
+	bool     optional_bool     = 100;
+	int32    optional_int32    = 101;
+	sint32   optional_sint32   = 102;
+	uint32   optional_uint32   = 103;
+	int64    optional_int64    = 104;
+	sint64   optional_sint64   = 105;
+	uint64   optional_uint64   = 106;
+	fixed32  optional_fixed32  = 107;
+	sfixed32 optional_sfixed32 = 108;
+	float    optional_float    = 109;
+	fixed64  optional_fixed64  = 110;
+	sfixed64 optional_sfixed64 = 111;
+	double   optional_double   = 112;
+	string   optional_string   = 113;
+	bytes    optional_bytes    = 114;
+
+	ChildEnum      optional_child_enum      = 115;
+	ChildMessage   optional_child_message   = 116;
+	SiblingEnum    optional_sibling_enum    = 117;
+	SiblingMessage optional_sibling_message = 118;
+
+	// Repeated fields.
+	repeated bool     repeated_bool     = 200;
+	repeated int32    repeated_int32    = 201;
+	repeated sint32   repeated_sint32   = 202;
+	repeated uint32   repeated_uint32   = 203;
+	repeated int64    repeated_int64    = 204;
+	repeated sint64   repeated_sint64   = 205;
+	repeated uint64   repeated_uint64   = 206;
+	repeated fixed32  repeated_fixed32  = 207;
+	repeated sfixed32 repeated_sfixed32 = 208;
+	repeated float    repeated_float    = 209;
+	repeated fixed64  repeated_fixed64  = 210;
+	repeated sfixed64 repeated_sfixed64 = 211;
+	repeated double   repeated_double   = 212;
+	repeated string   repeated_string   = 213;
+	repeated bytes    repeated_bytes    = 214;
+
+	repeated ChildEnum      repeated_child_enum      = 215;
+	repeated ChildMessage   repeated_child_message   = 216;
+	repeated SiblingEnum    repeated_sibling_enum    = 217;
+	repeated SiblingMessage repeated_sibling_message = 218;
+
+	// Map fields.
+	map<bool, bool>     map_bool_bool     = 300;
+	map<bool, int32>    map_bool_int32    = 301;
+	map<bool, sint32>   map_bool_sint32   = 302;
+	map<bool, uint32>   map_bool_uint32   = 303;
+	map<bool, int64>    map_bool_int64    = 304;
+	map<bool, sint64>   map_bool_sint64   = 305;
+	map<bool, uint64>   map_bool_uint64   = 306;
+	map<bool, fixed32>  map_bool_fixed32  = 307;
+	map<bool, sfixed32> map_bool_sfixed32 = 308;
+	map<bool, float>    map_bool_float    = 309;
+	map<bool, fixed64>  map_bool_fixed64  = 310;
+	map<bool, sfixed64> map_bool_sfixed64 = 311;
+	map<bool, double>   map_bool_double   = 312;
+	map<bool, string>   map_bool_string   = 313;
+	map<bool, bytes>    map_bool_bytes    = 314;
+
+	map<bool, ChildEnum>      map_bool_child_enum      = 315;
+	map<bool, ChildMessage>   map_bool_child_message   = 316;
+	map<bool, SiblingEnum>    map_bool_sibling_enum    = 317;
+	map<bool, SiblingMessage> map_bool_sibling_message = 318;
+
+	map<int32, bool>   map_int32_bool   = 319;
+	map<sint32, bool>  map_sint32_bool  = 320;
+	map<uint32, bool>  map_uint32_bool  = 321;
+	map<int64, bool>   map_int64_bool   = 322;
+	map<sint64, bool>  map_sint64_bool  = 323;
+	map<uint64, bool>  map_uint64_bool  = 324;
+	map<fixed32, bool> map_fixed32_bool = 325;
+	map<string, bool>  map_string_bool  = 326;
+
+	// Oneof fields.
+	oneof oneof_union {
+		bool     oneof_bool     = 400;
+		int32    oneof_int32    = 401;
+		sint32   oneof_sint32   = 402;
+		uint32   oneof_uint32   = 403;
+		int64    oneof_int64    = 404;
+		sint64   oneof_sint64   = 405;
+		uint64   oneof_uint64   = 406;
+		fixed32  oneof_fixed32  = 407;
+		sfixed32 oneof_sfixed32 = 408;
+		float    oneof_float    = 409;
+		fixed64  oneof_fixed64  = 410;
+		sfixed64 oneof_sfixed64 = 411;
+		double   oneof_double   = 412;
+		string   oneof_string   = 413;
+		bytes    oneof_bytes    = 414;
+
+		ChildEnum      oneof_child_enum      = 415;
+		ChildMessage   oneof_child_message   = 416;
+		SiblingEnum    oneof_sibling_enum    = 417;
+		SiblingMessage oneof_sibling_message = 418;
+
+		string oneof_string1 = 419;
+		string oneof_string2 = 420;
+		string oneof_string3 = 421;
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20160519_a4ab9ec5/test.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20160519_a4ab9ec5/test.pb.go
new file mode 100644
index 000000000..ac339fa50
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20160519_a4ab9ec5/test.pb.go
@@ -0,0 +1,1185 @@
+// 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.
+
+// Code generated by protoc-gen-go.
+// source: proto3_20160519_a4ab9ec5/test.proto
+// DO NOT EDIT!
+
+/*
+Package proto3_20160519_a4ab9ec5 is a generated protocol buffer package.
+
+It is generated from these files:
+	proto3_20160519_a4ab9ec5/test.proto
+
+It has these top-level messages:
+	SiblingMessage
+	Message
+*/
+package proto3_20160519_a4ab9ec5
+
+import proto "google.golang.org/protobuf/internal/protolegacy"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+const _ = proto.ProtoPackageIsVersion1
+
+type SiblingEnum int32
+
+const (
+	SiblingEnum_ALPHA   SiblingEnum = 0
+	SiblingEnum_BRAVO   SiblingEnum = 10
+	SiblingEnum_CHARLIE SiblingEnum = 200
+)
+
+var SiblingEnum_name = map[int32]string{
+	0:   "ALPHA",
+	10:  "BRAVO",
+	200: "CHARLIE",
+}
+var SiblingEnum_value = map[string]int32{
+	"ALPHA":   0,
+	"BRAVO":   10,
+	"CHARLIE": 200,
+}
+
+func (x SiblingEnum) String() string {
+	return proto.EnumName(SiblingEnum_name, int32(x))
+}
+func (SiblingEnum) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+type Message_ChildEnum int32
+
+const (
+	Message_ALPHA   Message_ChildEnum = 0
+	Message_BRAVO   Message_ChildEnum = 1
+	Message_CHARLIE Message_ChildEnum = 2
+)
+
+var Message_ChildEnum_name = map[int32]string{
+	0: "ALPHA",
+	1: "BRAVO",
+	2: "CHARLIE",
+}
+var Message_ChildEnum_value = map[string]int32{
+	"ALPHA":   0,
+	"BRAVO":   1,
+	"CHARLIE": 2,
+}
+
+func (x Message_ChildEnum) String() string {
+	return proto.EnumName(Message_ChildEnum_name, int32(x))
+}
+func (Message_ChildEnum) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{1, 0} }
+
+type SiblingMessage struct {
+	F1 string   `protobuf:"bytes,1,opt,name=f1" json:"f1,omitempty"`
+	F2 []string `protobuf:"bytes,2,rep,name=f2" json:"f2,omitempty"`
+	F3 *Message `protobuf:"bytes,3,opt,name=f3" json:"f3,omitempty"`
+}
+
+func (m *SiblingMessage) Reset()                    { *m = SiblingMessage{} }
+func (m *SiblingMessage) String() string            { return proto.CompactTextString(m) }
+func (*SiblingMessage) ProtoMessage()               {}
+func (*SiblingMessage) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *SiblingMessage) GetF3() *Message {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message struct {
+	// 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,proto3" json:"optional_bytes,omitempty"`
+	OptionalChildEnum      Message_ChildEnum     `protobuf:"varint,115,opt,name=optional_child_enum,json=optionalChildEnum,enum=google.golang.org.proto3_20160519.Message_ChildEnum" json:"optional_child_enum,omitempty"`
+	OptionalChildMessage   *Message_ChildMessage `protobuf:"bytes,116,opt,name=optional_child_message,json=optionalChildMessage" json:"optional_child_message,omitempty"`
+	OptionalSiblingEnum    SiblingEnum           `protobuf:"varint,117,opt,name=optional_sibling_enum,json=optionalSiblingEnum,enum=google.golang.org.proto3_20160519.SiblingEnum" json:"optional_sibling_enum,omitempty"`
+	OptionalSiblingMessage *SiblingMessage       `protobuf:"bytes,118,opt,name=optional_sibling_message,json=optionalSiblingMessage" json:"optional_sibling_message,omitempty"`
+	// Repeated fields.
+	RepeatedBool           []bool                  `protobuf:"varint,200,rep,name=repeated_bool,json=repeatedBool" json:"repeated_bool,omitempty"`
+	RepeatedInt32          []int32                 `protobuf:"varint,201,rep,name=repeated_int32,json=repeatedInt32" json:"repeated_int32,omitempty"`
+	RepeatedSint32         []int32                 `protobuf:"zigzag32,202,rep,name=repeated_sint32,json=repeatedSint32" json:"repeated_sint32,omitempty"`
+	RepeatedUint32         []uint32                `protobuf:"varint,203,rep,name=repeated_uint32,json=repeatedUint32" json:"repeated_uint32,omitempty"`
+	RepeatedInt64          []int64                 `protobuf:"varint,204,rep,name=repeated_int64,json=repeatedInt64" json:"repeated_int64,omitempty"`
+	RepeatedSint64         []int64                 `protobuf:"zigzag64,205,rep,name=repeated_sint64,json=repeatedSint64" json:"repeated_sint64,omitempty"`
+	RepeatedUint64         []uint64                `protobuf:"varint,206,rep,name=repeated_uint64,json=repeatedUint64" json:"repeated_uint64,omitempty"`
+	RepeatedFixed32        []uint32                `protobuf:"fixed32,207,rep,name=repeated_fixed32,json=repeatedFixed32" json:"repeated_fixed32,omitempty"`
+	RepeatedSfixed32       []int32                 `protobuf:"fixed32,208,rep,name=repeated_sfixed32,json=repeatedSfixed32" json:"repeated_sfixed32,omitempty"`
+	RepeatedFloat          []float32               `protobuf:"fixed32,209,rep,name=repeated_float,json=repeatedFloat" json:"repeated_float,omitempty"`
+	RepeatedFixed64        []uint64                `protobuf:"fixed64,210,rep,name=repeated_fixed64,json=repeatedFixed64" json:"repeated_fixed64,omitempty"`
+	RepeatedSfixed64       []int64                 `protobuf:"fixed64,211,rep,name=repeated_sfixed64,json=repeatedSfixed64" json:"repeated_sfixed64,omitempty"`
+	RepeatedDouble         []float64               `protobuf:"fixed64,212,rep,name=repeated_double,json=repeatedDouble" json:"repeated_double,omitempty"`
+	RepeatedString         []string                `protobuf:"bytes,213,rep,name=repeated_string,json=repeatedString" json:"repeated_string,omitempty"`
+	RepeatedBytes          [][]byte                `protobuf:"bytes,214,rep,name=repeated_bytes,json=repeatedBytes,proto3" json:"repeated_bytes,omitempty"`
+	RepeatedChildEnum      []Message_ChildEnum     `protobuf:"varint,215,rep,name=repeated_child_enum,json=repeatedChildEnum,enum=google.golang.org.proto3_20160519.Message_ChildEnum" json:"repeated_child_enum,omitempty"`
+	RepeatedChildMessage   []*Message_ChildMessage `protobuf:"bytes,216,rep,name=repeated_child_message,json=repeatedChildMessage" json:"repeated_child_message,omitempty"`
+	RepeatedSiblingEnum    []SiblingEnum           `protobuf:"varint,217,rep,name=repeated_sibling_enum,json=repeatedSiblingEnum,enum=google.golang.org.proto3_20160519.SiblingEnum" json:"repeated_sibling_enum,omitempty"`
+	RepeatedSiblingMessage []*SiblingMessage       `protobuf:"bytes,218,rep,name=repeated_sibling_message,json=repeatedSiblingMessage" json:"repeated_sibling_message,omitempty"`
+	// Map fields.
+	MapBoolBool           map[bool]bool                  `protobuf:"bytes,300,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,301,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,302,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,303,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,304,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,305,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,306,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,307,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,308,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,309,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,310,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,311,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,312,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,313,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,314,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,proto3"`
+	MapBoolChildEnum      map[bool]Message_ChildEnum     `protobuf:"bytes,315,rep,name=map_bool_child_enum,json=mapBoolChildEnum" json:"map_bool_child_enum,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=google.golang.org.proto3_20160519.Message_ChildEnum"`
+	MapBoolChildMessage   map[bool]*Message_ChildMessage `protobuf:"bytes,316,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"`
+	MapBoolSiblingEnum    map[bool]SiblingEnum           `protobuf:"bytes,317,rep,name=map_bool_sibling_enum,json=mapBoolSiblingEnum" json:"map_bool_sibling_enum,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=google.golang.org.proto3_20160519.SiblingEnum"`
+	MapBoolSiblingMessage map[bool]*SiblingMessage       `protobuf:"bytes,318,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"`
+	MapInt32Bool          map[int32]bool                 `protobuf:"bytes,319,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,320,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,321,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,322,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,323,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,324,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,325,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,326,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.
+	//
+	// Types that are valid to be assigned to OneofUnion:
+	//	*Message_OneofBool
+	//	*Message_OneofInt32
+	//	*Message_OneofSint32
+	//	*Message_OneofUint32
+	//	*Message_OneofInt64
+	//	*Message_OneofSint64
+	//	*Message_OneofUint64
+	//	*Message_OneofFixed32
+	//	*Message_OneofSfixed32
+	//	*Message_OneofFloat
+	//	*Message_OneofFixed64
+	//	*Message_OneofSfixed64
+	//	*Message_OneofDouble
+	//	*Message_OneofString
+	//	*Message_OneofBytes
+	//	*Message_OneofChildEnum
+	//	*Message_OneofChildMessage
+	//	*Message_OneofSiblingEnum
+	//	*Message_OneofSiblingMessage
+	//	*Message_OneofString1
+	//	*Message_OneofString2
+	//	*Message_OneofString3
+	OneofUnion isMessage_OneofUnion `protobuf_oneof:"oneof_union"`
+}
+
+func (m *Message) Reset()                    { *m = Message{} }
+func (m *Message) String() string            { return proto.CompactTextString(m) }
+func (*Message) ProtoMessage()               {}
+func (*Message) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+type isMessage_OneofUnion interface{ isMessage_OneofUnion() }
+
+type Message_OneofBool struct {
+	OneofBool bool `protobuf:"varint,400,opt,name=oneof_bool,json=oneofBool,oneof"`
+}
+type Message_OneofInt32 struct {
+	OneofInt32 int32 `protobuf:"varint,401,opt,name=oneof_int32,json=oneofInt32,oneof"`
+}
+type Message_OneofSint32 struct {
+	OneofSint32 int32 `protobuf:"zigzag32,402,opt,name=oneof_sint32,json=oneofSint32,oneof"`
+}
+type Message_OneofUint32 struct {
+	OneofUint32 uint32 `protobuf:"varint,403,opt,name=oneof_uint32,json=oneofUint32,oneof"`
+}
+type Message_OneofInt64 struct {
+	OneofInt64 int64 `protobuf:"varint,404,opt,name=oneof_int64,json=oneofInt64,oneof"`
+}
+type Message_OneofSint64 struct {
+	OneofSint64 int64 `protobuf:"zigzag64,405,opt,name=oneof_sint64,json=oneofSint64,oneof"`
+}
+type Message_OneofUint64 struct {
+	OneofUint64 uint64 `protobuf:"varint,406,opt,name=oneof_uint64,json=oneofUint64,oneof"`
+}
+type Message_OneofFixed32 struct {
+	OneofFixed32 uint32 `protobuf:"fixed32,407,opt,name=oneof_fixed32,json=oneofFixed32,oneof"`
+}
+type Message_OneofSfixed32 struct {
+	OneofSfixed32 int32 `protobuf:"fixed32,408,opt,name=oneof_sfixed32,json=oneofSfixed32,oneof"`
+}
+type Message_OneofFloat struct {
+	OneofFloat float32 `protobuf:"fixed32,409,opt,name=oneof_float,json=oneofFloat,oneof"`
+}
+type Message_OneofFixed64 struct {
+	OneofFixed64 uint64 `protobuf:"fixed64,410,opt,name=oneof_fixed64,json=oneofFixed64,oneof"`
+}
+type Message_OneofSfixed64 struct {
+	OneofSfixed64 int64 `protobuf:"fixed64,411,opt,name=oneof_sfixed64,json=oneofSfixed64,oneof"`
+}
+type Message_OneofDouble struct {
+	OneofDouble float64 `protobuf:"fixed64,412,opt,name=oneof_double,json=oneofDouble,oneof"`
+}
+type Message_OneofString struct {
+	OneofString string `protobuf:"bytes,413,opt,name=oneof_string,json=oneofString,oneof"`
+}
+type Message_OneofBytes struct {
+	OneofBytes []byte `protobuf:"bytes,414,opt,name=oneof_bytes,json=oneofBytes,proto3,oneof"`
+}
+type Message_OneofChildEnum struct {
+	OneofChildEnum Message_ChildEnum `protobuf:"varint,415,opt,name=oneof_child_enum,json=oneofChildEnum,enum=google.golang.org.proto3_20160519.Message_ChildEnum,oneof"`
+}
+type Message_OneofChildMessage struct {
+	OneofChildMessage *Message_ChildMessage `protobuf:"bytes,416,opt,name=oneof_child_message,json=oneofChildMessage,oneof"`
+}
+type Message_OneofSiblingEnum struct {
+	OneofSiblingEnum SiblingEnum `protobuf:"varint,417,opt,name=oneof_sibling_enum,json=oneofSiblingEnum,enum=google.golang.org.proto3_20160519.SiblingEnum,oneof"`
+}
+type Message_OneofSiblingMessage struct {
+	OneofSiblingMessage *SiblingMessage `protobuf:"bytes,418,opt,name=oneof_sibling_message,json=oneofSiblingMessage,oneof"`
+}
+type Message_OneofString1 struct {
+	OneofString1 string `protobuf:"bytes,419,opt,name=oneof_string1,json=oneofString1,oneof"`
+}
+type Message_OneofString2 struct {
+	OneofString2 string `protobuf:"bytes,420,opt,name=oneof_string2,json=oneofString2,oneof"`
+}
+type Message_OneofString3 struct {
+	OneofString3 string `protobuf:"bytes,421,opt,name=oneof_string3,json=oneofString3,oneof"`
+}
+
+func (*Message_OneofBool) isMessage_OneofUnion()           {}
+func (*Message_OneofInt32) isMessage_OneofUnion()          {}
+func (*Message_OneofSint32) isMessage_OneofUnion()         {}
+func (*Message_OneofUint32) isMessage_OneofUnion()         {}
+func (*Message_OneofInt64) isMessage_OneofUnion()          {}
+func (*Message_OneofSint64) isMessage_OneofUnion()         {}
+func (*Message_OneofUint64) isMessage_OneofUnion()         {}
+func (*Message_OneofFixed32) isMessage_OneofUnion()        {}
+func (*Message_OneofSfixed32) isMessage_OneofUnion()       {}
+func (*Message_OneofFloat) isMessage_OneofUnion()          {}
+func (*Message_OneofFixed64) isMessage_OneofUnion()        {}
+func (*Message_OneofSfixed64) isMessage_OneofUnion()       {}
+func (*Message_OneofDouble) isMessage_OneofUnion()         {}
+func (*Message_OneofString) isMessage_OneofUnion()         {}
+func (*Message_OneofBytes) isMessage_OneofUnion()          {}
+func (*Message_OneofChildEnum) isMessage_OneofUnion()      {}
+func (*Message_OneofChildMessage) isMessage_OneofUnion()   {}
+func (*Message_OneofSiblingEnum) isMessage_OneofUnion()    {}
+func (*Message_OneofSiblingMessage) isMessage_OneofUnion() {}
+func (*Message_OneofString1) isMessage_OneofUnion()        {}
+func (*Message_OneofString2) isMessage_OneofUnion()        {}
+func (*Message_OneofString3) isMessage_OneofUnion()        {}
+
+func (m *Message) GetOneofUnion() isMessage_OneofUnion {
+	if m != nil {
+		return m.OneofUnion
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalChildMessage() *Message_ChildMessage {
+	if m != nil {
+		return m.OptionalChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalSiblingMessage() *SiblingMessage {
+	if m != nil {
+		return m.OptionalSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedChildMessage() []*Message_ChildMessage {
+	if m != nil {
+		return m.RepeatedChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSiblingMessage() []*SiblingMessage {
+	if m != nil {
+		return m.RepeatedSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolBool() map[bool]bool {
+	if m != nil {
+		return m.MapBoolBool
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolInt32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolInt32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSint32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolSint32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolUint32() map[bool]uint32 {
+	if m != nil {
+		return m.MapBoolUint32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolInt64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolInt64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSint64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolSint64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolUint64() map[bool]uint64 {
+	if m != nil {
+		return m.MapBoolUint64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFixed32() map[bool]uint32 {
+	if m != nil {
+		return m.MapBoolFixed32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSfixed32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolSfixed32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFloat() map[bool]float32 {
+	if m != nil {
+		return m.MapBoolFloat
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFixed64() map[bool]uint64 {
+	if m != nil {
+		return m.MapBoolFixed64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSfixed64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolSfixed64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolDouble() map[bool]float64 {
+	if m != nil {
+		return m.MapBoolDouble
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolString() map[bool]string {
+	if m != nil {
+		return m.MapBoolString
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolBytes() map[bool][]byte {
+	if m != nil {
+		return m.MapBoolBytes
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolChildEnum() map[bool]Message_ChildEnum {
+	if m != nil {
+		return m.MapBoolChildEnum
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolChildMessage() map[bool]*Message_ChildMessage {
+	if m != nil {
+		return m.MapBoolChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSiblingEnum() map[bool]SiblingEnum {
+	if m != nil {
+		return m.MapBoolSiblingEnum
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSiblingMessage() map[bool]*SiblingMessage {
+	if m != nil {
+		return m.MapBoolSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetMapInt32Bool() map[int32]bool {
+	if m != nil {
+		return m.MapInt32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapSint32Bool() map[int32]bool {
+	if m != nil {
+		return m.MapSint32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapUint32Bool() map[uint32]bool {
+	if m != nil {
+		return m.MapUint32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapInt64Bool() map[int64]bool {
+	if m != nil {
+		return m.MapInt64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapSint64Bool() map[int64]bool {
+	if m != nil {
+		return m.MapSint64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapUint64Bool() map[uint64]bool {
+	if m != nil {
+		return m.MapUint64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapFixed32Bool() map[uint32]bool {
+	if m != nil {
+		return m.MapFixed32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapStringBool() map[string]bool {
+	if m != nil {
+		return m.MapStringBool
+	}
+	return nil
+}
+
+func (m *Message) GetOneofBool() bool {
+	if x, ok := m.GetOneofUnion().(*Message_OneofBool); ok {
+		return x.OneofBool
+	}
+	return false
+}
+
+func (m *Message) GetOneofInt32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofInt32); ok {
+		return x.OneofInt32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSint32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSint32); ok {
+		return x.OneofSint32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofUint32() uint32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofUint32); ok {
+		return x.OneofUint32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofInt64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofInt64); ok {
+		return x.OneofInt64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSint64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSint64); ok {
+		return x.OneofSint64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofUint64() uint64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofUint64); ok {
+		return x.OneofUint64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFixed32() uint32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFixed32); ok {
+		return x.OneofFixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSfixed32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSfixed32); ok {
+		return x.OneofSfixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFloat() float32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFloat); ok {
+		return x.OneofFloat
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFixed64() uint64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFixed64); ok {
+		return x.OneofFixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSfixed64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSfixed64); ok {
+		return x.OneofSfixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofDouble() float64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofDouble); ok {
+		return x.OneofDouble
+	}
+	return 0
+}
+
+func (m *Message) GetOneofString() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString); ok {
+		return x.OneofString
+	}
+	return ""
+}
+
+func (m *Message) GetOneofBytes() []byte {
+	if x, ok := m.GetOneofUnion().(*Message_OneofBytes); ok {
+		return x.OneofBytes
+	}
+	return nil
+}
+
+func (m *Message) GetOneofChildEnum() Message_ChildEnum {
+	if x, ok := m.GetOneofUnion().(*Message_OneofChildEnum); ok {
+		return x.OneofChildEnum
+	}
+	return Message_ALPHA
+}
+
+func (m *Message) GetOneofChildMessage() *Message_ChildMessage {
+	if x, ok := m.GetOneofUnion().(*Message_OneofChildMessage); ok {
+		return x.OneofChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOneofSiblingEnum() SiblingEnum {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSiblingEnum); ok {
+		return x.OneofSiblingEnum
+	}
+	return SiblingEnum_ALPHA
+}
+
+func (m *Message) GetOneofSiblingMessage() *SiblingMessage {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSiblingMessage); ok {
+		return x.OneofSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOneofString1() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString1); ok {
+		return x.OneofString1
+	}
+	return ""
+}
+
+func (m *Message) GetOneofString2() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString2); ok {
+		return x.OneofString2
+	}
+	return ""
+}
+
+func (m *Message) GetOneofString3() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString3); ok {
+		return x.OneofString3
+	}
+	return ""
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*Message) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+	return _Message_OneofMarshaler, _Message_OneofUnmarshaler, _Message_OneofSizer, []interface{}{
+		(*Message_OneofBool)(nil),
+		(*Message_OneofInt32)(nil),
+		(*Message_OneofSint32)(nil),
+		(*Message_OneofUint32)(nil),
+		(*Message_OneofInt64)(nil),
+		(*Message_OneofSint64)(nil),
+		(*Message_OneofUint64)(nil),
+		(*Message_OneofFixed32)(nil),
+		(*Message_OneofSfixed32)(nil),
+		(*Message_OneofFloat)(nil),
+		(*Message_OneofFixed64)(nil),
+		(*Message_OneofSfixed64)(nil),
+		(*Message_OneofDouble)(nil),
+		(*Message_OneofString)(nil),
+		(*Message_OneofBytes)(nil),
+		(*Message_OneofChildEnum)(nil),
+		(*Message_OneofChildMessage)(nil),
+		(*Message_OneofSiblingEnum)(nil),
+		(*Message_OneofSiblingMessage)(nil),
+		(*Message_OneofString1)(nil),
+		(*Message_OneofString2)(nil),
+		(*Message_OneofString3)(nil),
+	}
+}
+
+func _Message_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*Message)
+	// oneof_union
+	switch x := m.OneofUnion.(type) {
+	case *Message_OneofBool:
+		t := uint64(0)
+		if x.OneofBool {
+			t = 1
+		}
+		b.EncodeVarint(400<<3 | proto.WireVarint)
+		b.EncodeVarint(t)
+	case *Message_OneofInt32:
+		b.EncodeVarint(401<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofInt32))
+	case *Message_OneofSint32:
+		b.EncodeVarint(402<<3 | proto.WireVarint)
+		b.EncodeZigzag32(uint64(x.OneofSint32))
+	case *Message_OneofUint32:
+		b.EncodeVarint(403<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofUint32))
+	case *Message_OneofInt64:
+		b.EncodeVarint(404<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofInt64))
+	case *Message_OneofSint64:
+		b.EncodeVarint(405<<3 | proto.WireVarint)
+		b.EncodeZigzag64(uint64(x.OneofSint64))
+	case *Message_OneofUint64:
+		b.EncodeVarint(406<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofUint64))
+	case *Message_OneofFixed32:
+		b.EncodeVarint(407<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(x.OneofFixed32))
+	case *Message_OneofSfixed32:
+		b.EncodeVarint(408<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(x.OneofSfixed32))
+	case *Message_OneofFloat:
+		b.EncodeVarint(409<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(math.Float32bits(x.OneofFloat)))
+	case *Message_OneofFixed64:
+		b.EncodeVarint(410<<3 | proto.WireFixed64)
+		b.EncodeFixed64(uint64(x.OneofFixed64))
+	case *Message_OneofSfixed64:
+		b.EncodeVarint(411<<3 | proto.WireFixed64)
+		b.EncodeFixed64(uint64(x.OneofSfixed64))
+	case *Message_OneofDouble:
+		b.EncodeVarint(412<<3 | proto.WireFixed64)
+		b.EncodeFixed64(math.Float64bits(x.OneofDouble))
+	case *Message_OneofString:
+		b.EncodeVarint(413<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString)
+	case *Message_OneofBytes:
+		b.EncodeVarint(414<<3 | proto.WireBytes)
+		b.EncodeRawBytes(x.OneofBytes)
+	case *Message_OneofChildEnum:
+		b.EncodeVarint(415<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofChildEnum))
+	case *Message_OneofChildMessage:
+		b.EncodeVarint(416<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.OneofChildMessage); err != nil {
+			return err
+		}
+	case *Message_OneofSiblingEnum:
+		b.EncodeVarint(417<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofSiblingEnum))
+	case *Message_OneofSiblingMessage:
+		b.EncodeVarint(418<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.OneofSiblingMessage); err != nil {
+			return err
+		}
+	case *Message_OneofString1:
+		b.EncodeVarint(419<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString1)
+	case *Message_OneofString2:
+		b.EncodeVarint(420<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString2)
+	case *Message_OneofString3:
+		b.EncodeVarint(421<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString3)
+	case nil:
+	default:
+		return fmt.Errorf("Message.OneofUnion has unexpected type %T", x)
+	}
+	return nil
+}
+
+func _Message_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*Message)
+	switch tag {
+	case 400: // oneof_union.oneof_bool
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofBool{x != 0}
+		return true, err
+	case 401: // oneof_union.oneof_int32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofInt32{int32(x)}
+		return true, err
+	case 402: // oneof_union.oneof_sint32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeZigzag32()
+		m.OneofUnion = &Message_OneofSint32{int32(x)}
+		return true, err
+	case 403: // oneof_union.oneof_uint32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofUint32{uint32(x)}
+		return true, err
+	case 404: // oneof_union.oneof_int64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofInt64{int64(x)}
+		return true, err
+	case 405: // oneof_union.oneof_sint64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeZigzag64()
+		m.OneofUnion = &Message_OneofSint64{int64(x)}
+		return true, err
+	case 406: // oneof_union.oneof_uint64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofUint64{x}
+		return true, err
+	case 407: // oneof_union.oneof_fixed32
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofUnion = &Message_OneofFixed32{uint32(x)}
+		return true, err
+	case 408: // oneof_union.oneof_sfixed32
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofUnion = &Message_OneofSfixed32{int32(x)}
+		return true, err
+	case 409: // oneof_union.oneof_float
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofUnion = &Message_OneofFloat{math.Float32frombits(uint32(x))}
+		return true, err
+	case 410: // oneof_union.oneof_fixed64
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofUnion = &Message_OneofFixed64{x}
+		return true, err
+	case 411: // oneof_union.oneof_sfixed64
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofUnion = &Message_OneofSfixed64{int64(x)}
+		return true, err
+	case 412: // oneof_union.oneof_double
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofUnion = &Message_OneofDouble{math.Float64frombits(x)}
+		return true, err
+	case 413: // oneof_union.oneof_string
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString{x}
+		return true, err
+	case 414: // oneof_union.oneof_bytes
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeRawBytes(true)
+		m.OneofUnion = &Message_OneofBytes{x}
+		return true, err
+	case 415: // oneof_union.oneof_child_enum
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofChildEnum{Message_ChildEnum(x)}
+		return true, err
+	case 416: // oneof_union.oneof_child_message
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(Message_ChildMessage)
+		err := b.DecodeMessage(msg)
+		m.OneofUnion = &Message_OneofChildMessage{msg}
+		return true, err
+	case 417: // oneof_union.oneof_sibling_enum
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofSiblingEnum{SiblingEnum(x)}
+		return true, err
+	case 418: // oneof_union.oneof_sibling_message
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(SiblingMessage)
+		err := b.DecodeMessage(msg)
+		m.OneofUnion = &Message_OneofSiblingMessage{msg}
+		return true, err
+	case 419: // oneof_union.oneof_string1
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString1{x}
+		return true, err
+	case 420: // oneof_union.oneof_string2
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString2{x}
+		return true, err
+	case 421: // oneof_union.oneof_string3
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString3{x}
+		return true, err
+	default:
+		return false, nil
+	}
+}
+
+func _Message_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*Message)
+	// oneof_union
+	switch x := m.OneofUnion.(type) {
+	case *Message_OneofBool:
+		n += proto.SizeVarint(400<<3 | proto.WireVarint)
+		n += 1
+	case *Message_OneofInt32:
+		n += proto.SizeVarint(401<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofInt32))
+	case *Message_OneofSint32:
+		n += proto.SizeVarint(402<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64((uint32(x.OneofSint32) << 1) ^ uint32((int32(x.OneofSint32) >> 31))))
+	case *Message_OneofUint32:
+		n += proto.SizeVarint(403<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofUint32))
+	case *Message_OneofInt64:
+		n += proto.SizeVarint(404<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofInt64))
+	case *Message_OneofSint64:
+		n += proto.SizeVarint(405<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(uint64(x.OneofSint64<<1) ^ uint64((int64(x.OneofSint64) >> 63))))
+	case *Message_OneofUint64:
+		n += proto.SizeVarint(406<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofUint64))
+	case *Message_OneofFixed32:
+		n += proto.SizeVarint(407<<3 | proto.WireFixed32)
+		n += 4
+	case *Message_OneofSfixed32:
+		n += proto.SizeVarint(408<<3 | proto.WireFixed32)
+		n += 4
+	case *Message_OneofFloat:
+		n += proto.SizeVarint(409<<3 | proto.WireFixed32)
+		n += 4
+	case *Message_OneofFixed64:
+		n += proto.SizeVarint(410<<3 | proto.WireFixed64)
+		n += 8
+	case *Message_OneofSfixed64:
+		n += proto.SizeVarint(411<<3 | proto.WireFixed64)
+		n += 8
+	case *Message_OneofDouble:
+		n += proto.SizeVarint(412<<3 | proto.WireFixed64)
+		n += 8
+	case *Message_OneofString:
+		n += proto.SizeVarint(413<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofString)))
+		n += len(x.OneofString)
+	case *Message_OneofBytes:
+		n += proto.SizeVarint(414<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofBytes)))
+		n += len(x.OneofBytes)
+	case *Message_OneofChildEnum:
+		n += proto.SizeVarint(415<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofChildEnum))
+	case *Message_OneofChildMessage:
+		s := proto.Size(x.OneofChildMessage)
+		n += proto.SizeVarint(416<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *Message_OneofSiblingEnum:
+		n += proto.SizeVarint(417<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofSiblingEnum))
+	case *Message_OneofSiblingMessage:
+		s := proto.Size(x.OneofSiblingMessage)
+		n += proto.SizeVarint(418<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *Message_OneofString1:
+		n += proto.SizeVarint(419<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofString1)))
+		n += len(x.OneofString1)
+	case *Message_OneofString2:
+		n += proto.SizeVarint(420<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofString2)))
+		n += len(x.OneofString2)
+	case *Message_OneofString3:
+		n += proto.SizeVarint(421<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofString3)))
+		n += len(x.OneofString3)
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	return n
+}
+
+type Message_ChildMessage struct {
+	F1 string   `protobuf:"bytes,1,opt,name=f1" json:"f1,omitempty"`
+	F2 []string `protobuf:"bytes,2,rep,name=f2" json:"f2,omitempty"`
+	F3 *Message `protobuf:"bytes,3,opt,name=f3" json:"f3,omitempty"`
+}
+
+func (m *Message_ChildMessage) Reset()                    { *m = Message_ChildMessage{} }
+func (m *Message_ChildMessage) String() string            { return proto.CompactTextString(m) }
+func (*Message_ChildMessage) ProtoMessage()               {}
+func (*Message_ChildMessage) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1, 0} }
+
+func (m *Message_ChildMessage) GetF3() *Message {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*SiblingMessage)(nil), "google.golang.org.proto3_20160519.SiblingMessage")
+	proto.RegisterType((*Message)(nil), "google.golang.org.proto3_20160519.Message")
+	proto.RegisterType((*Message_ChildMessage)(nil), "google.golang.org.proto3_20160519.Message.ChildMessage")
+	proto.RegisterEnum("google.golang.org.proto3_20160519.SiblingEnum", SiblingEnum_name, SiblingEnum_value)
+	proto.RegisterEnum("google.golang.org.proto3_20160519.Message_ChildEnum", Message_ChildEnum_name, Message_ChildEnum_value)
+}
+
+var fileDescriptor0 = []byte{
+	// 1947 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x9a, 0x57, 0x73, 0xdb, 0xca,
+	0x15, 0xc7, 0x09, 0x52, 0xc5, 0x5a, 0xb1, 0x82, 0x96, 0xb2, 0xa3, 0x27, 0x44, 0x76, 0x1c, 0xc4,
+	0xc9, 0x50, 0x26, 0x05, 0x23, 0xb1, 0x93, 0xd8, 0x96, 0x6c, 0x39, 0x74, 0xc6, 0x4e, 0x3c, 0xf0,
+	0x28, 0x0f, 0x79, 0x51, 0x48, 0x09, 0xa4, 0x69, 0x83, 0x84, 0x22, 0x92, 0x9e, 0x68, 0xf2, 0xe0,
+	0xaf, 0x90, 0xde, 0xeb, 0x2d, 0x6f, 0xb7, 0xf7, 0xde, 0x7d, 0xc7, 0xb7, 0xf7, 0xfa, 0x69, 0xee,
+	0x2c, 0x0e, 0xb6, 0x01, 0xa0, 0x49, 0x82, 0x73, 0x1f, 0x3c, 0x23, 0x1d, 0xfe, 0xf7, 0xfc, 0x78,
+	0x0e, 0xce, 0x9e, 0xb3, 0x0b, 0x0b, 0x1d, 0xda, 0xdd, 0x73, 0x7b, 0xee, 0xea, 0x56, 0xe5, 0x58,
+	0xd9, 0x3c, 0x76, 0xbc, 0x7c, 0x62, 0xab, 0x66, 0xd4, 0xea, 0x27, 0xec, 0xed, 0xe3, 0x2b, 0x3d,
+	0xbb, 0xdb, 0x2b, 0x79, 0x9f, 0xaa, 0xdf, 0x6c, 0xba, 0x6e, 0xd3, 0xb1, 0x4b, 0x4d, 0xd7, 0xa9,
+	0x75, 0x9a, 0x25, 0x77, 0xaf, 0x59, 0x0a, 0x2c, 0x5b, 0x76, 0x50, 0xf6, 0x4a, 0xab, 0xee, 0xb4,
+	0x3a, 0xcd, 0x4b, 0x76, 0xb7, 0x5b, 0x6b, 0xda, 0x6a, 0x16, 0x25, 0x1b, 0x65, 0xac, 0x68, 0x8a,
+	0x3e, 0x67, 0x25, 0x1b, 0x65, 0xef, 0xf7, 0x0a, 0x4e, 0x6a, 0x29, 0xef, 0xf7, 0x8a, 0x7a, 0x12,
+	0x25, 0x1b, 0xab, 0x38, 0xa5, 0x29, 0xfa, 0x7c, 0xe5, 0x68, 0x69, 0x28, 0xa1, 0xe4, 0xfb, 0xb5,
+	0x92, 0x8d, 0xd5, 0xe5, 0x5b, 0x67, 0xd0, 0x2c, 0xe5, 0x1c, 0x42, 0x19, 0x77, 0xb7, 0xd7, 0x72,
+	0x3b, 0x35, 0x67, 0xab, 0xee, 0xba, 0x0e, 0xde, 0xd1, 0x14, 0xfd, 0x80, 0x95, 0xa6, 0xc6, 0x75,
+	0xd7, 0x75, 0xd4, 0x6f, 0xa1, 0x2c, 0x13, 0xb5, 0x3a, 0xbd, 0xd5, 0x0a, 0xb6, 0x35, 0x45, 0x9f,
+	0xb6, 0xd8, 0xd2, 0x0b, 0xc4, 0xa8, 0x7e, 0x1b, 0xe5, 0x98, 0xac, 0x0b, 0xba, 0x86, 0xa6, 0xe8,
+	0x05, 0x8b, 0xad, 0xbe, 0xd2, 0x0a, 0x09, 0xfb, 0x20, 0x6c, 0x6a, 0x8a, 0x9e, 0xe1, 0xc2, 0x4d,
+	0x10, 0x06, 0xc0, 0xa6, 0x81, 0xaf, 0x6a, 0x8a, 0x9e, 0x92, 0xc0, 0xa6, 0x11, 0x02, 0x9b, 0x06,
+	0x6e, 0x69, 0x8a, 0xae, 0xca, 0xe0, 0x80, 0xb0, 0x0f, 0xc2, 0x6b, 0x9a, 0xa2, 0x4f, 0xc9, 0x60,
+	0xd3, 0x50, 0xbf, 0x83, 0xf2, 0x4c, 0xd8, 0x68, 0xfd, 0xc6, 0xde, 0x59, 0xad, 0xe0, 0xeb, 0x9a,
+	0xa2, 0xcf, 0x5a, 0xcc, 0xc1, 0x79, 0x30, 0xab, 0xdf, 0x45, 0x05, 0x0e, 0xa7, 0x5a, 0x47, 0x53,
+	0xf4, 0x9c, 0xc5, 0x7c, 0x5c, 0xf1, 0xed, 0x52, 0x40, 0x0d, 0xc7, 0xad, 0xf5, 0x70, 0x5b, 0x53,
+	0xf4, 0x24, 0x0f, 0xe8, 0x3c, 0x31, 0x86, 0xf1, 0xa6, 0x81, 0x3b, 0x9a, 0xa2, 0xcf, 0x04, 0xf0,
+	0xa6, 0x11, 0x81, 0x37, 0x0d, 0xec, 0x6a, 0x8a, 0x9e, 0x0f, 0xe2, 0x03, 0xf1, 0xef, 0xb8, 0xfd,
+	0xba, 0x63, 0xe3, 0x5d, 0x4d, 0xd1, 0x15, 0x1e, 0xff, 0x39, 0xcf, 0x2a, 0x67, 0xb4, 0xb7, 0xd7,
+	0xea, 0x34, 0xf1, 0xaf, 0xbd, 0x5a, 0xe4, 0x19, 0xf5, 0xac, 0x52, 0x40, 0xf5, 0xfd, 0x9e, 0xdd,
+	0xc5, 0x7b, 0x9a, 0xa2, 0xa7, 0x79, 0x40, 0xeb, 0xc4, 0xa8, 0xee, 0xa0, 0x22, 0x93, 0x6d, 0x5f,
+	0x6d, 0x39, 0x3b, 0x5b, 0x76, 0xa7, 0xdf, 0xc6, 0x5d, 0x4d, 0xd1, 0xb3, 0x15, 0x63, 0xf4, 0xfa,
+	0x2d, 0x9d, 0x25, 0x8b, 0x37, 0x3a, 0xfd, 0xb6, 0xc5, 0xc2, 0x66, 0x26, 0xb5, 0x8d, 0x16, 0x03,
+	0x94, 0x36, 0x2c, 0xc3, 0x3d, 0x6f, 0xa3, 0x7c, 0x7f, 0x5c, 0x10, 0xdd, 0x35, 0x07, 0x25, 0x16,
+	0xdd, 0x3b, 0x75, 0xb4, 0x20, 0x94, 0x9d, 0xb7, 0x7d, 0x21, 0xac, 0xbe, 0x17, 0x56, 0x69, 0x04,
+	0x9a, 0xbf, 0xeb, 0xbd, 0x80, 0x8a, 0xbc, 0x58, 0x99, 0x51, 0xbd, 0x8e, 0x70, 0x88, 0x41, 0x83,
+	0xba, 0xe1, 0x05, 0x55, 0x1e, 0x1d, 0x43, 0xc3, 0x59, 0x0c, 0x90, 0x68, 0x40, 0x87, 0x51, 0x66,
+	0xcf, 0xde, 0xb5, 0x6b, 0x3d, 0x7b, 0x07, 0x9a, 0xc1, 0x6d, 0x45, 0x4b, 0x91, 0x6e, 0x40, 0xad,
+	0x5e, 0x37, 0x38, 0x82, 0xb2, 0x4c, 0x05, 0x9b, 0xf7, 0x0d, 0x22, 0x9b, 0xb6, 0xd8, 0x62, 0x68,
+	0x07, 0x3a, 0xca, 0x31, 0x9d, 0xdf, 0x0e, 0xde, 0x24, 0xc2, 0x82, 0xc5, 0xd6, 0xfb, 0xfd, 0x40,
+	0x54, 0xfa, 0xfd, 0xe0, 0x2d, 0xa2, 0xcc, 0x70, 0xa5, 0xdf, 0x10, 0x02, 0x6c, 0xd3, 0xc0, 0x6f,
+	0x13, 0x61, 0x4a, 0x62, 0x9b, 0x46, 0x88, 0x6d, 0x1a, 0xf8, 0x1d, 0x22, 0x54, 0x65, 0x76, 0x40,
+	0xe9, 0xb7, 0x84, 0x77, 0x89, 0x72, 0x4a, 0x66, 0x9b, 0x86, 0x7a, 0x14, 0xe5, 0x99, 0x92, 0xee,
+	0xf3, 0xf7, 0x88, 0x74, 0xd6, 0x62, 0x2e, 0x68, 0x53, 0xf8, 0x1e, 0x2a, 0x70, 0x3e, 0x15, 0xbf,
+	0x4f, 0xc4, 0x39, 0x8b, 0x79, 0x61, 0x5d, 0x41, 0x8c, 0x0a, 0xba, 0xc2, 0x07, 0x44, 0x9a, 0xe4,
+	0x51, 0x41, 0x5b, 0x08, 0x7d, 0x03, 0xd3, 0xc0, 0x1f, 0x12, 0xe5, 0x4c, 0xe0, 0x1b, 0x98, 0x46,
+	0xc4, 0x37, 0x30, 0x0d, 0xfc, 0x11, 0x11, 0xe7, 0x83, 0xdf, 0x20, 0x90, 0x05, 0xbf, 0x31, 0x7c,
+	0x4c, 0xb4, 0x0a, 0xcf, 0x82, 0xdf, 0x19, 0xa4, 0xcc, 0x42, 0x67, 0xf8, 0x44, 0xf1, 0xc6, 0x12,
+	0xcf, 0x2c, 0xb4, 0x06, 0x31, 0x2a, 0x68, 0x0d, 0x9f, 0x12, 0x61, 0x9a, 0x47, 0x05, 0xbd, 0xc1,
+	0x46, 0x45, 0xa6, 0x13, 0x7a, 0xc3, 0x67, 0x44, 0x1c, 0xbb, 0x39, 0x50, 0x8f, 0xbc, 0x39, 0x74,
+	0xd0, 0x62, 0x00, 0x43, 0xf7, 0xd1, 0xe7, 0x84, 0x34, 0x49, 0x77, 0x90, 0x60, 0x74, 0x33, 0x6d,
+	0xa3, 0x05, 0xa1, 0x04, 0x85, 0xee, 0xf0, 0x05, 0x04, 0x36, 0x76, 0x7b, 0xe0, 0x85, 0xcb, 0xdb,
+	0x83, 0x83, 0x70, 0x08, 0x42, 0xc3, 0xfa, 0x12, 0xc2, 0x8a, 0xd3, 0x1f, 0x02, 0x28, 0x1a, 0xd2,
+	0xaf, 0x50, 0xa6, 0x5d, 0xdb, 0xf5, 0x5a, 0x03, 0xf4, 0x87, 0xfb, 0x92, 0x1e, 0xe2, 0x87, 0x63,
+	0x64, 0xee, 0x52, 0x6d, 0x97, 0x74, 0x11, 0xf2, 0x6f, 0xa3, 0xd3, 0xdb, 0xdb, 0xb7, 0xe6, 0xdb,
+	0xdc, 0xa2, 0x6e, 0xa3, 0x2c, 0x23, 0x40, 0x23, 0xb8, 0x1f, 0x10, 0x3f, 0x1a, 0x1f, 0xe1, 0x75,
+	0x21, 0x60, 0xa4, 0xdb, 0x82, 0x49, 0x6d, 0xa0, 0x1c, 0x83, 0xf8, 0x8d, 0xe9, 0x01, 0xa0, 0xfc,
+	0x78, 0x7c, 0x0a, 0xb4, 0x30, 0xc0, 0x64, 0xda, 0xa2, 0x4d, 0xe2, 0xf8, 0x6d, 0xed, 0xc1, 0xd8,
+	0x9c, 0xcd, 0x08, 0x8e, 0xdf, 0x14, 0x03, 0x49, 0x33, 0x0d, 0xfc, 0xd0, 0x24, 0x49, 0x33, 0x8d,
+	0x50, 0xd2, 0x4c, 0x23, 0x94, 0x34, 0xd3, 0xc0, 0x0f, 0x4f, 0x94, 0x34, 0x8a, 0x11, 0x93, 0x16,
+	0xe0, 0xf8, 0xfd, 0xf8, 0x91, 0x89, 0x92, 0x16, 0xe4, 0xf8, 0xdd, 0xbc, 0x85, 0xf2, 0x8c, 0x43,
+	0x1b, 0xf4, 0xa3, 0x00, 0x3a, 0x35, 0x3e, 0xc8, 0xef, 0xfb, 0x40, 0xca, 0xb6, 0x25, 0xa3, 0xea,
+	0xa0, 0x02, 0x4f, 0x1d, 0x65, 0x3d, 0x06, 0xac, 0xd3, 0x31, 0x92, 0xd7, 0x10, 0x61, 0xb9, 0xb6,
+	0x6c, 0x95, 0xaa, 0x01, 0x86, 0xc9, 0xe3, 0xb1, 0xab, 0xc1, 0x1b, 0x3b, 0x72, 0x35, 0xc0, 0x24,
+	0x0a, 0x65, 0xcf, 0x34, 0xf0, 0x13, 0x93, 0x65, 0x8f, 0x3e, 0x27, 0x29, 0x7b, 0xa6, 0x11, 0x91,
+	0x3d, 0xd3, 0xc0, 0x4f, 0x4e, 0x98, 0x3d, 0x0a, 0x93, 0xb3, 0x17, 0x28, 0x3f, 0x7f, 0x10, 0x3e,
+	0x15, 0xbb, 0xfc, 0x60, 0x64, 0xca, 0xe5, 0xe7, 0x8f, 0x51, 0x69, 0x3b, 0xc1, 0x18, 0x7d, 0x3a,
+	0xfe, 0x76, 0xf2, 0x1c, 0x04, 0xb6, 0x13, 0x0c, 0x61, 0xb1, 0x1a, 0x60, 0x08, 0x3f, 0x13, 0xbb,
+	0x1a, 0xbc, 0x71, 0x2d, 0x57, 0x03, 0x4c, 0xf0, 0x5d, 0x54, 0x64, 0x10, 0x61, 0x82, 0x3f, 0x0b,
+	0xa4, 0x33, 0xe3, 0x93, 0xd8, 0xd4, 0x06, 0x5a, 0xbe, 0x1d, 0x30, 0xab, 0xfb, 0x68, 0x31, 0x40,
+	0xa4, 0x53, 0xef, 0x39, 0x80, 0x9e, 0x8d, 0x09, 0xf5, 0x6d, 0xc0, 0x2d, 0xb6, 0xc3, 0x9f, 0xa8,
+	0x37, 0xd0, 0x82, 0xd0, 0x08, 0x85, 0xb9, 0xfe, 0x3c, 0x90, 0xd7, 0xe3, 0xb4, 0x43, 0x36, 0xd1,
+	0x01, 0xac, 0xb6, 0x43, 0x1f, 0xa8, 0x37, 0x11, 0x0e, 0x71, 0x69, 0xd0, 0x2f, 0x00, 0x7a, 0x23,
+	0x36, 0x5a, 0x0a, 0x7b, 0xa1, 0x1d, 0xf5, 0x19, 0x2d, 0x25, 0x6f, 0xe6, 0xc0, 0xf8, 0x7f, 0x31,
+	0x56, 0x29, 0x79, 0x43, 0x98, 0xcf, 0x7f, 0x52, 0x4a, 0xcc, 0x44, 0xf7, 0x45, 0x57, 0xa0, 0xbc,
+	0x14, 0x6b, 0x5f, 0xc0, 0x0c, 0xe6, 0x18, 0xb2, 0x2f, 0xb8, 0x8d, 0x72, 0xfa, 0x02, 0xe7, 0xe5,
+	0x58, 0x9c, 0xcd, 0x08, 0x0e, 0xb7, 0x09, 0x49, 0x33, 0x0d, 0xc0, 0xbc, 0x12, 0x37, 0x69, 0xa6,
+	0x11, 0x4a, 0x1a, 0x98, 0xc4, 0xa4, 0x51, 0xca, 0xab, 0xb1, 0x93, 0x26, 0x62, 0x68, 0xd2, 0x64,
+	0x4e, 0x5f, 0xe0, 0xbc, 0x16, 0x3b, 0x69, 0x41, 0x0e, 0xb7, 0xd1, 0xe9, 0xe2, 0x4f, 0x34, 0x00,
+	0xdd, 0x8a, 0x35, 0x5d, 0xfc, 0x11, 0xcc, 0x49, 0xe4, 0x69, 0x08, 0x46, 0x96, 0x3a, 0xaf, 0x5b,
+	0x02, 0xe9, 0xf5, 0x78, 0xa9, 0xf3, 0x3c, 0x04, 0x52, 0xc7, 0x6c, 0xaa, 0x86, 0x90, 0xdb, 0xb1,
+	0xdd, 0x06, 0x20, 0x7e, 0x97, 0xd2, 0x14, 0xfd, 0x40, 0x35, 0x61, 0xcd, 0x79, 0x46, 0x4f, 0xb1,
+	0x8c, 0xe6, 0x41, 0x01, 0x27, 0xc5, 0xdf, 0x13, 0xc9, 0x74, 0x35, 0x61, 0xc1, 0x3a, 0x38, 0xb9,
+	0x1e, 0x46, 0x69, 0xd0, 0xf8, 0xc7, 0xd6, 0x3f, 0x10, 0x51, 0xa1, 0x9a, 0xb0, 0x60, 0xa9, 0x7f,
+	0xee, 0x64, 0x2a, 0xff, 0xd0, 0xf9, 0x47, 0xa2, 0xca, 0x30, 0x95, 0x7f, 0x6a, 0x14, 0x79, 0xa6,
+	0x81, 0xff, 0x44, 0x44, 0x29, 0x91, 0x67, 0x1a, 0x32, 0xcf, 0x34, 0xf0, 0x9f, 0x89, 0x48, 0x95,
+	0x78, 0xa2, 0xca, 0x3f, 0xaf, 0xfd, 0x85, 0xa8, 0xa6, 0x24, 0x9e, 0x69, 0xa8, 0x47, 0x50, 0x06,
+	0x54, 0xf4, 0x04, 0xf4, 0x57, 0x22, 0x9b, 0xad, 0x26, 0x2c, 0x58, 0x4d, 0x4f, 0x4b, 0x3a, 0xca,
+	0xfa, 0x4c, 0x2a, 0xfc, 0x1b, 0x11, 0xe6, 0xaa, 0x09, 0x0b, 0x1c, 0xb0, 0x93, 0x0e, 0x8b, 0x00,
+	0x8e, 0x39, 0x7f, 0x27, 0xb2, 0x24, 0x8b, 0x00, 0x0e, 0x2a, 0x32, 0xd5, 0x34, 0xf0, 0x3f, 0x88,
+	0x6a, 0x46, 0xa6, 0x7a, 0x17, 0x60, 0x89, 0x6a, 0x1a, 0xf8, 0x9f, 0x44, 0x98, 0x0f, 0x50, 0xc5,
+	0x68, 0xfd, 0xe3, 0xc1, 0xbf, 0x88, 0x4e, 0x61, 0xd1, 0xfa, 0xf3, 0x9d, 0x67, 0x0e, 0x86, 0xfb,
+	0xbf, 0x89, 0x6a, 0x8e, 0x67, 0x0e, 0xa6, 0x33, 0x8b, 0x00, 0x46, 0xf3, 0x7f, 0x88, 0x28, 0xcd,
+	0x22, 0x80, 0xe1, 0x5a, 0x43, 0x79, 0xd0, 0x08, 0x93, 0xf5, 0xbf, 0xa9, 0xf8, 0x2f, 0xce, 0xaa,
+	0x09, 0x0b, 0x42, 0xe5, 0xd3, 0xf4, 0x1a, 0x2a, 0x8a, 0x08, 0x3a, 0x55, 0xfe, 0x97, 0x9a, 0xe8,
+	0xad, 0x59, 0x35, 0x61, 0x15, 0x38, 0x88, 0x4e, 0x91, 0x2d, 0xa4, 0xd2, 0x92, 0x12, 0x66, 0xe7,
+	0xff, 0x53, 0x71, 0x5e, 0x99, 0x55, 0x13, 0x56, 0xde, 0x2f, 0x44, 0x3e, 0x27, 0xaf, 0xa2, 0x05,
+	0x19, 0x40, 0xc3, 0xb9, 0x2b, 0x15, 0xf3, 0x7d, 0x59, 0x35, 0x61, 0x15, 0x45, 0x0c, 0x0d, 0x85,
+	0xd5, 0x16, 0x3c, 0xe3, 0x32, 0xbe, 0x9b, 0x3e, 0xe4, 0xb4, 0xf0, 0x90, 0xcb, 0x41, 0x5d, 0x05,
+	0xdf, 0x13, 0xa5, 0xab, 0x04, 0x75, 0xab, 0xf8, 0xde, 0x28, 0xdd, 0xea, 0xd2, 0x35, 0x94, 0x96,
+	0x52, 0xfa, 0x35, 0xfe, 0x5f, 0xc1, 0xd2, 0x29, 0x94, 0x0f, 0xde, 0xd8, 0xd5, 0x3c, 0x4a, 0x5d,
+	0xb7, 0xf7, 0x3d, 0xe0, 0x01, 0x8b, 0xfc, 0xa8, 0x1e, 0x44, 0xd3, 0x37, 0x6a, 0x4e, 0xdf, 0xc6,
+	0x49, 0xcf, 0x06, 0xbf, 0x9c, 0x4c, 0xfe, 0x40, 0x59, 0x3a, 0x8d, 0x0a, 0xa1, 0xeb, 0xf8, 0x30,
+	0x07, 0xd3, 0xa2, 0x83, 0x33, 0x48, 0x0d, 0xdf, 0xb4, 0x87, 0x79, 0x28, 0x44, 0x7b, 0xd8, 0x1c,
+	0xdd, 0x43, 0x66, 0x60, 0x10, 0xfe, 0xd5, 0x61, 0x98, 0x83, 0xd4, 0xe0, 0x20, 0x46, 0xf4, 0xa0,
+	0x0e, 0x0e, 0x62, 0x44, 0x0f, 0x53, 0xa2, 0x87, 0x35, 0x54, 0x8c, 0xb8, 0xac, 0x0e, 0x73, 0x31,
+	0x2b, 0xba, 0x58, 0x47, 0x07, 0xa3, 0xee, 0xa0, 0xc3, 0x7c, 0xe4, 0xa2, 0x73, 0xc9, 0x2f, 0x97,
+	0xc3, 0x1c, 0x24, 0xef, 0x10, 0xc7, 0x88, 0xa9, 0x98, 0xb9, 0x53, 0x1c, 0x23, 0xfa, 0xc8, 0x47,
+	0x3f, 0x10, 0xe1, 0x96, 0x37, 0xcc, 0x83, 0x32, 0xa0, 0x28, 0xf8, 0xfd, 0x6d, 0x98, 0x87, 0xb9,
+	0xe8, 0x5c, 0xf2, 0xab, 0xd9, 0x30, 0x07, 0x69, 0xd1, 0xc1, 0x3e, 0x5a, 0x88, 0xbc, 0x71, 0x45,
+	0x38, 0xf9, 0xa9, 0xe8, 0x24, 0xee, 0x6b, 0x59, 0x01, 0x7d, 0x13, 0xe1, 0x41, 0xf7, 0xae, 0x08,
+	0xfa, 0x25, 0x91, 0x3e, 0xc1, 0xab, 0x5a, 0xe1, 0x0b, 0xf4, 0xd1, 0x37, 0x06, 0x5c, 0xbf, 0x22,
+	0xf8, 0xe7, 0xe4, 0xe8, 0xc7, 0x7d, 0x77, 0x2b, 0x60, 0x7f, 0x8b, 0x96, 0x06, 0x5f, 0xbd, 0x22,
+	0xc8, 0x3f, 0x91, 0x23, 0x8f, 0xf1, 0x36, 0x37, 0x54, 0x30, 0xf2, 0x05, 0x4c, 0x64, 0x4e, 0x0f,
+	0x6b, 0xe7, 0x50, 0xb3, 0x81, 0xbb, 0x95, 0xe8, 0xa1, 0x30, 0x9a, 0x87, 0xcd, 0xc1, 0x1e, 0x32,
+	0xa3, 0x8d, 0x14, 0xf9, 0x42, 0x24, 0x3a, 0x48, 0x8d, 0x1e, 0xc4, 0x00, 0x0f, 0xea, 0xe8, 0x41,
+	0x0c, 0xf0, 0x30, 0x35, 0xcc, 0x03, 0x74, 0xb1, 0xe0, 0xf5, 0x44, 0x74, 0x31, 0x3b, 0x62, 0x18,
+	0xf2, 0xbd, 0x43, 0xf4, 0x30, 0x37, 0xc4, 0xc3, 0x72, 0x09, 0xcd, 0xf1, 0x43, 0xe0, 0x1c, 0x9a,
+	0x5e, 0xbb, 0x78, 0xb9, 0xba, 0x96, 0x4f, 0x90, 0x1f, 0xd7, 0xad, 0xb5, 0x5f, 0xfc, 0x3c, 0xaf,
+	0xa8, 0xf3, 0x68, 0xf6, 0x6c, 0x75, 0xcd, 0xba, 0x78, 0x61, 0x23, 0x9f, 0x5c, 0xcf, 0xd0, 0xe3,
+	0x6a, 0xbf, 0xd3, 0x72, 0x3b, 0x47, 0xcb, 0x68, 0x5e, 0x3c, 0x78, 0x45, 0x39, 0x40, 0x6a, 0x9a,
+	0x3b, 0xb8, 0xad, 0xac, 0x5f, 0xfe, 0xe5, 0xcf, 0x42, 0xf5, 0xbb, 0xe2, 0xd5, 0x6f, 0xbd, 0xdf,
+	0x58, 0x69, 0x75, 0x7a, 0xf6, 0x5e, 0xa7, 0xe6, 0x78, 0x7f, 0x3d, 0xe1, 0x59, 0xbb, 0x2b, 0x8e,
+	0xdd, 0xac, 0x6d, 0xef, 0xaf, 0x0c, 0xfa, 0x43, 0x8b, 0xfa, 0x0c, 0x7c, 0xf2, 0x55, 0x00, 0x00,
+	0x00, 0xff, 0xff, 0xb9, 0x46, 0x32, 0x11, 0x8b, 0x21, 0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20160519_a4ab9ec5/test.proto b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20160519_a4ab9ec5/test.proto
new file mode 100644
index 000000000..6d031a42c
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20160519_a4ab9ec5/test.proto
@@ -0,0 +1,136 @@
+// 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.
+
+syntax = "proto3";
+
+package google.golang.org.proto3_20160519;
+option go_package = "google.golang.org/protobuf/internal/testprotos/legacy/proto3_20160519_a4ab9ec5";
+
+enum SiblingEnum {
+	ALPHA   = 0;
+	BRAVO   = 10;
+	CHARLIE = 200;
+}
+
+message SiblingMessage {
+	string          f1 = 1;
+	repeated string f2 = 2;
+	Message         f3 = 3;
+}
+
+message Message {
+	enum ChildEnum {
+		ALPHA   = 0;
+		BRAVO   = 1;
+		CHARLIE = 2;
+	}
+	message ChildMessage {
+		string          f1 = 1;
+		repeated string f2 = 2;
+		Message         f3 = 3;
+	}
+
+	// Optional fields.
+	bool     optional_bool     = 100;
+	int32    optional_int32    = 101;
+	sint32   optional_sint32   = 102;
+	uint32   optional_uint32   = 103;
+	int64    optional_int64    = 104;
+	sint64   optional_sint64   = 105;
+	uint64   optional_uint64   = 106;
+	fixed32  optional_fixed32  = 107;
+	sfixed32 optional_sfixed32 = 108;
+	float    optional_float    = 109;
+	fixed64  optional_fixed64  = 110;
+	sfixed64 optional_sfixed64 = 111;
+	double   optional_double   = 112;
+	string   optional_string   = 113;
+	bytes    optional_bytes    = 114;
+
+	ChildEnum      optional_child_enum      = 115;
+	ChildMessage   optional_child_message   = 116;
+	SiblingEnum    optional_sibling_enum    = 117;
+	SiblingMessage optional_sibling_message = 118;
+
+	// Repeated fields.
+	repeated bool     repeated_bool     = 200;
+	repeated int32    repeated_int32    = 201;
+	repeated sint32   repeated_sint32   = 202;
+	repeated uint32   repeated_uint32   = 203;
+	repeated int64    repeated_int64    = 204;
+	repeated sint64   repeated_sint64   = 205;
+	repeated uint64   repeated_uint64   = 206;
+	repeated fixed32  repeated_fixed32  = 207;
+	repeated sfixed32 repeated_sfixed32 = 208;
+	repeated float    repeated_float    = 209;
+	repeated fixed64  repeated_fixed64  = 210;
+	repeated sfixed64 repeated_sfixed64 = 211;
+	repeated double   repeated_double   = 212;
+	repeated string   repeated_string   = 213;
+	repeated bytes    repeated_bytes    = 214;
+
+	repeated ChildEnum      repeated_child_enum      = 215;
+	repeated ChildMessage   repeated_child_message   = 216;
+	repeated SiblingEnum    repeated_sibling_enum    = 217;
+	repeated SiblingMessage repeated_sibling_message = 218;
+
+	// Map fields.
+	map<bool, bool>     map_bool_bool     = 300;
+	map<bool, int32>    map_bool_int32    = 301;
+	map<bool, sint32>   map_bool_sint32   = 302;
+	map<bool, uint32>   map_bool_uint32   = 303;
+	map<bool, int64>    map_bool_int64    = 304;
+	map<bool, sint64>   map_bool_sint64   = 305;
+	map<bool, uint64>   map_bool_uint64   = 306;
+	map<bool, fixed32>  map_bool_fixed32  = 307;
+	map<bool, sfixed32> map_bool_sfixed32 = 308;
+	map<bool, float>    map_bool_float    = 309;
+	map<bool, fixed64>  map_bool_fixed64  = 310;
+	map<bool, sfixed64> map_bool_sfixed64 = 311;
+	map<bool, double>   map_bool_double   = 312;
+	map<bool, string>   map_bool_string   = 313;
+	map<bool, bytes>    map_bool_bytes    = 314;
+
+	map<bool, ChildEnum>      map_bool_child_enum      = 315;
+	map<bool, ChildMessage>   map_bool_child_message   = 316;
+	map<bool, SiblingEnum>    map_bool_sibling_enum    = 317;
+	map<bool, SiblingMessage> map_bool_sibling_message = 318;
+
+	map<int32, bool>   map_int32_bool   = 319;
+	map<sint32, bool>  map_sint32_bool  = 320;
+	map<uint32, bool>  map_uint32_bool  = 321;
+	map<int64, bool>   map_int64_bool   = 322;
+	map<sint64, bool>  map_sint64_bool  = 323;
+	map<uint64, bool>  map_uint64_bool  = 324;
+	map<fixed32, bool> map_fixed32_bool = 325;
+	map<string, bool>  map_string_bool  = 326;
+
+	// Oneof fields.
+	oneof oneof_union {
+		bool     oneof_bool     = 400;
+		int32    oneof_int32    = 401;
+		sint32   oneof_sint32   = 402;
+		uint32   oneof_uint32   = 403;
+		int64    oneof_int64    = 404;
+		sint64   oneof_sint64   = 405;
+		uint64   oneof_uint64   = 406;
+		fixed32  oneof_fixed32  = 407;
+		sfixed32 oneof_sfixed32 = 408;
+		float    oneof_float    = 409;
+		fixed64  oneof_fixed64  = 410;
+		sfixed64 oneof_sfixed64 = 411;
+		double   oneof_double   = 412;
+		string   oneof_string   = 413;
+		bytes    oneof_bytes    = 414;
+
+		ChildEnum      oneof_child_enum      = 415;
+		ChildMessage   oneof_child_message   = 416;
+		SiblingEnum    oneof_sibling_enum    = 417;
+		SiblingMessage oneof_sibling_message = 418;
+
+		string oneof_string1 = 419;
+		string oneof_string2 = 420;
+		string oneof_string3 = 421;
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20180125_92554152/test.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20180125_92554152/test.pb.go
new file mode 100644
index 000000000..35ac0a0b6
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20180125_92554152/test.pb.go
@@ -0,0 +1,1454 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: proto3_20180125_92554152/test.proto
+
+/*
+Package proto3_20180125_92554152 is a generated protocol buffer package.
+
+It is generated from these files:
+	proto3_20180125_92554152/test.proto
+
+It has these top-level messages:
+	SiblingMessage
+	Message
+*/
+package proto3_20180125_92554152
+
+import proto "google.golang.org/protobuf/internal/protolegacy"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type SiblingEnum int32
+
+const (
+	SiblingEnum_ALPHA   SiblingEnum = 0
+	SiblingEnum_BRAVO   SiblingEnum = 10
+	SiblingEnum_CHARLIE SiblingEnum = 200
+)
+
+var SiblingEnum_name = map[int32]string{
+	0:   "ALPHA",
+	10:  "BRAVO",
+	200: "CHARLIE",
+}
+var SiblingEnum_value = map[string]int32{
+	"ALPHA":   0,
+	"BRAVO":   10,
+	"CHARLIE": 200,
+}
+
+func (x SiblingEnum) String() string {
+	return proto.EnumName(SiblingEnum_name, int32(x))
+}
+func (SiblingEnum) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+type Message_ChildEnum int32
+
+const (
+	Message_ALPHA   Message_ChildEnum = 0
+	Message_BRAVO   Message_ChildEnum = 1
+	Message_CHARLIE Message_ChildEnum = 2
+)
+
+var Message_ChildEnum_name = map[int32]string{
+	0: "ALPHA",
+	1: "BRAVO",
+	2: "CHARLIE",
+}
+var Message_ChildEnum_value = map[string]int32{
+	"ALPHA":   0,
+	"BRAVO":   1,
+	"CHARLIE": 2,
+}
+
+func (x Message_ChildEnum) String() string {
+	return proto.EnumName(Message_ChildEnum_name, int32(x))
+}
+func (Message_ChildEnum) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{1, 0} }
+
+type SiblingMessage struct {
+	F1 string   `protobuf:"bytes,1,opt,name=f1" json:"f1,omitempty"`
+	F2 []string `protobuf:"bytes,2,rep,name=f2" json:"f2,omitempty"`
+	F3 *Message `protobuf:"bytes,3,opt,name=f3" json:"f3,omitempty"`
+}
+
+func (m *SiblingMessage) Reset()                    { *m = SiblingMessage{} }
+func (m *SiblingMessage) String() string            { return proto.CompactTextString(m) }
+func (*SiblingMessage) ProtoMessage()               {}
+func (*SiblingMessage) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *SiblingMessage) GetF1() string {
+	if m != nil {
+		return m.F1
+	}
+	return ""
+}
+
+func (m *SiblingMessage) GetF2() []string {
+	if m != nil {
+		return m.F2
+	}
+	return nil
+}
+
+func (m *SiblingMessage) GetF3() *Message {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message struct {
+	// 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,proto3" json:"optional_bytes,omitempty"`
+	OptionalChildEnum      Message_ChildEnum     `protobuf:"varint,115,opt,name=optional_child_enum,json=optionalChildEnum,enum=google.golang.org.proto3_20180125.Message_ChildEnum" json:"optional_child_enum,omitempty"`
+	OptionalChildMessage   *Message_ChildMessage `protobuf:"bytes,116,opt,name=optional_child_message,json=optionalChildMessage" json:"optional_child_message,omitempty"`
+	OptionalSiblingEnum    SiblingEnum           `protobuf:"varint,117,opt,name=optional_sibling_enum,json=optionalSiblingEnum,enum=google.golang.org.proto3_20180125.SiblingEnum" json:"optional_sibling_enum,omitempty"`
+	OptionalSiblingMessage *SiblingMessage       `protobuf:"bytes,118,opt,name=optional_sibling_message,json=optionalSiblingMessage" json:"optional_sibling_message,omitempty"`
+	// Repeated fields.
+	RepeatedBool           []bool                  `protobuf:"varint,200,rep,packed,name=repeated_bool,json=repeatedBool" json:"repeated_bool,omitempty"`
+	RepeatedInt32          []int32                 `protobuf:"varint,201,rep,packed,name=repeated_int32,json=repeatedInt32" json:"repeated_int32,omitempty"`
+	RepeatedSint32         []int32                 `protobuf:"zigzag32,202,rep,packed,name=repeated_sint32,json=repeatedSint32" json:"repeated_sint32,omitempty"`
+	RepeatedUint32         []uint32                `protobuf:"varint,203,rep,packed,name=repeated_uint32,json=repeatedUint32" json:"repeated_uint32,omitempty"`
+	RepeatedInt64          []int64                 `protobuf:"varint,204,rep,packed,name=repeated_int64,json=repeatedInt64" json:"repeated_int64,omitempty"`
+	RepeatedSint64         []int64                 `protobuf:"zigzag64,205,rep,packed,name=repeated_sint64,json=repeatedSint64" json:"repeated_sint64,omitempty"`
+	RepeatedUint64         []uint64                `protobuf:"varint,206,rep,packed,name=repeated_uint64,json=repeatedUint64" json:"repeated_uint64,omitempty"`
+	RepeatedFixed32        []uint32                `protobuf:"fixed32,207,rep,packed,name=repeated_fixed32,json=repeatedFixed32" json:"repeated_fixed32,omitempty"`
+	RepeatedSfixed32       []int32                 `protobuf:"fixed32,208,rep,packed,name=repeated_sfixed32,json=repeatedSfixed32" json:"repeated_sfixed32,omitempty"`
+	RepeatedFloat          []float32               `protobuf:"fixed32,209,rep,packed,name=repeated_float,json=repeatedFloat" json:"repeated_float,omitempty"`
+	RepeatedFixed64        []uint64                `protobuf:"fixed64,210,rep,packed,name=repeated_fixed64,json=repeatedFixed64" json:"repeated_fixed64,omitempty"`
+	RepeatedSfixed64       []int64                 `protobuf:"fixed64,211,rep,packed,name=repeated_sfixed64,json=repeatedSfixed64" json:"repeated_sfixed64,omitempty"`
+	RepeatedDouble         []float64               `protobuf:"fixed64,212,rep,packed,name=repeated_double,json=repeatedDouble" json:"repeated_double,omitempty"`
+	RepeatedString         []string                `protobuf:"bytes,213,rep,name=repeated_string,json=repeatedString" json:"repeated_string,omitempty"`
+	RepeatedBytes          [][]byte                `protobuf:"bytes,214,rep,name=repeated_bytes,json=repeatedBytes,proto3" json:"repeated_bytes,omitempty"`
+	RepeatedChildEnum      []Message_ChildEnum     `protobuf:"varint,215,rep,packed,name=repeated_child_enum,json=repeatedChildEnum,enum=google.golang.org.proto3_20180125.Message_ChildEnum" json:"repeated_child_enum,omitempty"`
+	RepeatedChildMessage   []*Message_ChildMessage `protobuf:"bytes,216,rep,name=repeated_child_message,json=repeatedChildMessage" json:"repeated_child_message,omitempty"`
+	RepeatedSiblingEnum    []SiblingEnum           `protobuf:"varint,217,rep,packed,name=repeated_sibling_enum,json=repeatedSiblingEnum,enum=google.golang.org.proto3_20180125.SiblingEnum" json:"repeated_sibling_enum,omitempty"`
+	RepeatedSiblingMessage []*SiblingMessage       `protobuf:"bytes,218,rep,name=repeated_sibling_message,json=repeatedSiblingMessage" json:"repeated_sibling_message,omitempty"`
+	// Map fields.
+	MapBoolBool           map[bool]bool                  `protobuf:"bytes,300,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,301,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,302,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,303,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,304,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,305,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,306,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,307,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,308,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,309,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,310,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,311,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,312,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,313,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,314,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,proto3"`
+	MapBoolChildEnum      map[bool]Message_ChildEnum     `protobuf:"bytes,315,rep,name=map_bool_child_enum,json=mapBoolChildEnum" json:"map_bool_child_enum,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=google.golang.org.proto3_20180125.Message_ChildEnum"`
+	MapBoolChildMessage   map[bool]*Message_ChildMessage `protobuf:"bytes,316,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"`
+	MapBoolSiblingEnum    map[bool]SiblingEnum           `protobuf:"bytes,317,rep,name=map_bool_sibling_enum,json=mapBoolSiblingEnum" json:"map_bool_sibling_enum,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=google.golang.org.proto3_20180125.SiblingEnum"`
+	MapBoolSiblingMessage map[bool]*SiblingMessage       `protobuf:"bytes,318,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"`
+	MapInt32Bool          map[int32]bool                 `protobuf:"bytes,319,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,320,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,321,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,322,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,323,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,324,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,325,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,326,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.
+	//
+	// Types that are valid to be assigned to OneofUnion:
+	//	*Message_OneofBool
+	//	*Message_OneofInt32
+	//	*Message_OneofSint32
+	//	*Message_OneofUint32
+	//	*Message_OneofInt64
+	//	*Message_OneofSint64
+	//	*Message_OneofUint64
+	//	*Message_OneofFixed32
+	//	*Message_OneofSfixed32
+	//	*Message_OneofFloat
+	//	*Message_OneofFixed64
+	//	*Message_OneofSfixed64
+	//	*Message_OneofDouble
+	//	*Message_OneofString
+	//	*Message_OneofBytes
+	//	*Message_OneofChildEnum
+	//	*Message_OneofChildMessage
+	//	*Message_OneofSiblingEnum
+	//	*Message_OneofSiblingMessage
+	//	*Message_OneofString1
+	//	*Message_OneofString2
+	//	*Message_OneofString3
+	OneofUnion isMessage_OneofUnion `protobuf_oneof:"oneof_union"`
+}
+
+func (m *Message) Reset()                    { *m = Message{} }
+func (m *Message) String() string            { return proto.CompactTextString(m) }
+func (*Message) ProtoMessage()               {}
+func (*Message) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+type isMessage_OneofUnion interface{ isMessage_OneofUnion() }
+
+type Message_OneofBool struct {
+	OneofBool bool `protobuf:"varint,400,opt,name=oneof_bool,json=oneofBool,oneof"`
+}
+type Message_OneofInt32 struct {
+	OneofInt32 int32 `protobuf:"varint,401,opt,name=oneof_int32,json=oneofInt32,oneof"`
+}
+type Message_OneofSint32 struct {
+	OneofSint32 int32 `protobuf:"zigzag32,402,opt,name=oneof_sint32,json=oneofSint32,oneof"`
+}
+type Message_OneofUint32 struct {
+	OneofUint32 uint32 `protobuf:"varint,403,opt,name=oneof_uint32,json=oneofUint32,oneof"`
+}
+type Message_OneofInt64 struct {
+	OneofInt64 int64 `protobuf:"varint,404,opt,name=oneof_int64,json=oneofInt64,oneof"`
+}
+type Message_OneofSint64 struct {
+	OneofSint64 int64 `protobuf:"zigzag64,405,opt,name=oneof_sint64,json=oneofSint64,oneof"`
+}
+type Message_OneofUint64 struct {
+	OneofUint64 uint64 `protobuf:"varint,406,opt,name=oneof_uint64,json=oneofUint64,oneof"`
+}
+type Message_OneofFixed32 struct {
+	OneofFixed32 uint32 `protobuf:"fixed32,407,opt,name=oneof_fixed32,json=oneofFixed32,oneof"`
+}
+type Message_OneofSfixed32 struct {
+	OneofSfixed32 int32 `protobuf:"fixed32,408,opt,name=oneof_sfixed32,json=oneofSfixed32,oneof"`
+}
+type Message_OneofFloat struct {
+	OneofFloat float32 `protobuf:"fixed32,409,opt,name=oneof_float,json=oneofFloat,oneof"`
+}
+type Message_OneofFixed64 struct {
+	OneofFixed64 uint64 `protobuf:"fixed64,410,opt,name=oneof_fixed64,json=oneofFixed64,oneof"`
+}
+type Message_OneofSfixed64 struct {
+	OneofSfixed64 int64 `protobuf:"fixed64,411,opt,name=oneof_sfixed64,json=oneofSfixed64,oneof"`
+}
+type Message_OneofDouble struct {
+	OneofDouble float64 `protobuf:"fixed64,412,opt,name=oneof_double,json=oneofDouble,oneof"`
+}
+type Message_OneofString struct {
+	OneofString string `protobuf:"bytes,413,opt,name=oneof_string,json=oneofString,oneof"`
+}
+type Message_OneofBytes struct {
+	OneofBytes []byte `protobuf:"bytes,414,opt,name=oneof_bytes,json=oneofBytes,proto3,oneof"`
+}
+type Message_OneofChildEnum struct {
+	OneofChildEnum Message_ChildEnum `protobuf:"varint,415,opt,name=oneof_child_enum,json=oneofChildEnum,enum=google.golang.org.proto3_20180125.Message_ChildEnum,oneof"`
+}
+type Message_OneofChildMessage struct {
+	OneofChildMessage *Message_ChildMessage `protobuf:"bytes,416,opt,name=oneof_child_message,json=oneofChildMessage,oneof"`
+}
+type Message_OneofSiblingEnum struct {
+	OneofSiblingEnum SiblingEnum `protobuf:"varint,417,opt,name=oneof_sibling_enum,json=oneofSiblingEnum,enum=google.golang.org.proto3_20180125.SiblingEnum,oneof"`
+}
+type Message_OneofSiblingMessage struct {
+	OneofSiblingMessage *SiblingMessage `protobuf:"bytes,418,opt,name=oneof_sibling_message,json=oneofSiblingMessage,oneof"`
+}
+type Message_OneofString1 struct {
+	OneofString1 string `protobuf:"bytes,419,opt,name=oneof_string1,json=oneofString1,oneof"`
+}
+type Message_OneofString2 struct {
+	OneofString2 string `protobuf:"bytes,420,opt,name=oneof_string2,json=oneofString2,oneof"`
+}
+type Message_OneofString3 struct {
+	OneofString3 string `protobuf:"bytes,421,opt,name=oneof_string3,json=oneofString3,oneof"`
+}
+
+func (*Message_OneofBool) isMessage_OneofUnion()           {}
+func (*Message_OneofInt32) isMessage_OneofUnion()          {}
+func (*Message_OneofSint32) isMessage_OneofUnion()         {}
+func (*Message_OneofUint32) isMessage_OneofUnion()         {}
+func (*Message_OneofInt64) isMessage_OneofUnion()          {}
+func (*Message_OneofSint64) isMessage_OneofUnion()         {}
+func (*Message_OneofUint64) isMessage_OneofUnion()         {}
+func (*Message_OneofFixed32) isMessage_OneofUnion()        {}
+func (*Message_OneofSfixed32) isMessage_OneofUnion()       {}
+func (*Message_OneofFloat) isMessage_OneofUnion()          {}
+func (*Message_OneofFixed64) isMessage_OneofUnion()        {}
+func (*Message_OneofSfixed64) isMessage_OneofUnion()       {}
+func (*Message_OneofDouble) isMessage_OneofUnion()         {}
+func (*Message_OneofString) isMessage_OneofUnion()         {}
+func (*Message_OneofBytes) isMessage_OneofUnion()          {}
+func (*Message_OneofChildEnum) isMessage_OneofUnion()      {}
+func (*Message_OneofChildMessage) isMessage_OneofUnion()   {}
+func (*Message_OneofSiblingEnum) isMessage_OneofUnion()    {}
+func (*Message_OneofSiblingMessage) isMessage_OneofUnion() {}
+func (*Message_OneofString1) isMessage_OneofUnion()        {}
+func (*Message_OneofString2) isMessage_OneofUnion()        {}
+func (*Message_OneofString3) isMessage_OneofUnion()        {}
+
+func (m *Message) GetOneofUnion() isMessage_OneofUnion {
+	if m != nil {
+		return m.OneofUnion
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalBool() bool {
+	if m != nil {
+		return m.OptionalBool
+	}
+	return false
+}
+
+func (m *Message) GetOptionalInt32() int32 {
+	if m != nil {
+		return m.OptionalInt32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSint32() int32 {
+	if m != nil {
+		return m.OptionalSint32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalUint32() uint32 {
+	if m != nil {
+		return m.OptionalUint32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalInt64() int64 {
+	if m != nil {
+		return m.OptionalInt64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSint64() int64 {
+	if m != nil {
+		return m.OptionalSint64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalUint64() uint64 {
+	if m != nil {
+		return m.OptionalUint64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalFixed32() uint32 {
+	if m != nil {
+		return m.OptionalFixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSfixed32() int32 {
+	if m != nil {
+		return m.OptionalSfixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalFloat() float32 {
+	if m != nil {
+		return m.OptionalFloat
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalFixed64() uint64 {
+	if m != nil {
+		return m.OptionalFixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSfixed64() int64 {
+	if m != nil {
+		return m.OptionalSfixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalDouble() float64 {
+	if m != nil {
+		return m.OptionalDouble
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalString() string {
+	if m != nil {
+		return m.OptionalString
+	}
+	return ""
+}
+
+func (m *Message) GetOptionalBytes() []byte {
+	if m != nil {
+		return m.OptionalBytes
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalChildEnum() Message_ChildEnum {
+	if m != nil {
+		return m.OptionalChildEnum
+	}
+	return Message_ALPHA
+}
+
+func (m *Message) GetOptionalChildMessage() *Message_ChildMessage {
+	if m != nil {
+		return m.OptionalChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalSiblingEnum() SiblingEnum {
+	if m != nil {
+		return m.OptionalSiblingEnum
+	}
+	return SiblingEnum_ALPHA
+}
+
+func (m *Message) GetOptionalSiblingMessage() *SiblingMessage {
+	if m != nil {
+		return m.OptionalSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedBool() []bool {
+	if m != nil {
+		return m.RepeatedBool
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedInt32() []int32 {
+	if m != nil {
+		return m.RepeatedInt32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSint32() []int32 {
+	if m != nil {
+		return m.RepeatedSint32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedUint32() []uint32 {
+	if m != nil {
+		return m.RepeatedUint32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedInt64() []int64 {
+	if m != nil {
+		return m.RepeatedInt64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSint64() []int64 {
+	if m != nil {
+		return m.RepeatedSint64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedUint64() []uint64 {
+	if m != nil {
+		return m.RepeatedUint64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedFixed32() []uint32 {
+	if m != nil {
+		return m.RepeatedFixed32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSfixed32() []int32 {
+	if m != nil {
+		return m.RepeatedSfixed32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedFloat() []float32 {
+	if m != nil {
+		return m.RepeatedFloat
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedFixed64() []uint64 {
+	if m != nil {
+		return m.RepeatedFixed64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSfixed64() []int64 {
+	if m != nil {
+		return m.RepeatedSfixed64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedDouble() []float64 {
+	if m != nil {
+		return m.RepeatedDouble
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedString() []string {
+	if m != nil {
+		return m.RepeatedString
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedBytes() [][]byte {
+	if m != nil {
+		return m.RepeatedBytes
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedChildEnum() []Message_ChildEnum {
+	if m != nil {
+		return m.RepeatedChildEnum
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedChildMessage() []*Message_ChildMessage {
+	if m != nil {
+		return m.RepeatedChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSiblingEnum() []SiblingEnum {
+	if m != nil {
+		return m.RepeatedSiblingEnum
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSiblingMessage() []*SiblingMessage {
+	if m != nil {
+		return m.RepeatedSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolBool() map[bool]bool {
+	if m != nil {
+		return m.MapBoolBool
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolInt32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolInt32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSint32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolSint32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolUint32() map[bool]uint32 {
+	if m != nil {
+		return m.MapBoolUint32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolInt64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolInt64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSint64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolSint64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolUint64() map[bool]uint64 {
+	if m != nil {
+		return m.MapBoolUint64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFixed32() map[bool]uint32 {
+	if m != nil {
+		return m.MapBoolFixed32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSfixed32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolSfixed32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFloat() map[bool]float32 {
+	if m != nil {
+		return m.MapBoolFloat
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFixed64() map[bool]uint64 {
+	if m != nil {
+		return m.MapBoolFixed64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSfixed64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolSfixed64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolDouble() map[bool]float64 {
+	if m != nil {
+		return m.MapBoolDouble
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolString() map[bool]string {
+	if m != nil {
+		return m.MapBoolString
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolBytes() map[bool][]byte {
+	if m != nil {
+		return m.MapBoolBytes
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolChildEnum() map[bool]Message_ChildEnum {
+	if m != nil {
+		return m.MapBoolChildEnum
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolChildMessage() map[bool]*Message_ChildMessage {
+	if m != nil {
+		return m.MapBoolChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSiblingEnum() map[bool]SiblingEnum {
+	if m != nil {
+		return m.MapBoolSiblingEnum
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSiblingMessage() map[bool]*SiblingMessage {
+	if m != nil {
+		return m.MapBoolSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetMapInt32Bool() map[int32]bool {
+	if m != nil {
+		return m.MapInt32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapSint32Bool() map[int32]bool {
+	if m != nil {
+		return m.MapSint32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapUint32Bool() map[uint32]bool {
+	if m != nil {
+		return m.MapUint32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapInt64Bool() map[int64]bool {
+	if m != nil {
+		return m.MapInt64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapSint64Bool() map[int64]bool {
+	if m != nil {
+		return m.MapSint64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapUint64Bool() map[uint64]bool {
+	if m != nil {
+		return m.MapUint64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapFixed32Bool() map[uint32]bool {
+	if m != nil {
+		return m.MapFixed32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapStringBool() map[string]bool {
+	if m != nil {
+		return m.MapStringBool
+	}
+	return nil
+}
+
+func (m *Message) GetOneofBool() bool {
+	if x, ok := m.GetOneofUnion().(*Message_OneofBool); ok {
+		return x.OneofBool
+	}
+	return false
+}
+
+func (m *Message) GetOneofInt32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofInt32); ok {
+		return x.OneofInt32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSint32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSint32); ok {
+		return x.OneofSint32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofUint32() uint32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofUint32); ok {
+		return x.OneofUint32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofInt64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofInt64); ok {
+		return x.OneofInt64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSint64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSint64); ok {
+		return x.OneofSint64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofUint64() uint64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofUint64); ok {
+		return x.OneofUint64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFixed32() uint32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFixed32); ok {
+		return x.OneofFixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSfixed32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSfixed32); ok {
+		return x.OneofSfixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFloat() float32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFloat); ok {
+		return x.OneofFloat
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFixed64() uint64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFixed64); ok {
+		return x.OneofFixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSfixed64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSfixed64); ok {
+		return x.OneofSfixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofDouble() float64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofDouble); ok {
+		return x.OneofDouble
+	}
+	return 0
+}
+
+func (m *Message) GetOneofString() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString); ok {
+		return x.OneofString
+	}
+	return ""
+}
+
+func (m *Message) GetOneofBytes() []byte {
+	if x, ok := m.GetOneofUnion().(*Message_OneofBytes); ok {
+		return x.OneofBytes
+	}
+	return nil
+}
+
+func (m *Message) GetOneofChildEnum() Message_ChildEnum {
+	if x, ok := m.GetOneofUnion().(*Message_OneofChildEnum); ok {
+		return x.OneofChildEnum
+	}
+	return Message_ALPHA
+}
+
+func (m *Message) GetOneofChildMessage() *Message_ChildMessage {
+	if x, ok := m.GetOneofUnion().(*Message_OneofChildMessage); ok {
+		return x.OneofChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOneofSiblingEnum() SiblingEnum {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSiblingEnum); ok {
+		return x.OneofSiblingEnum
+	}
+	return SiblingEnum_ALPHA
+}
+
+func (m *Message) GetOneofSiblingMessage() *SiblingMessage {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSiblingMessage); ok {
+		return x.OneofSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOneofString1() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString1); ok {
+		return x.OneofString1
+	}
+	return ""
+}
+
+func (m *Message) GetOneofString2() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString2); ok {
+		return x.OneofString2
+	}
+	return ""
+}
+
+func (m *Message) GetOneofString3() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString3); ok {
+		return x.OneofString3
+	}
+	return ""
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*Message) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+	return _Message_OneofMarshaler, _Message_OneofUnmarshaler, _Message_OneofSizer, []interface{}{
+		(*Message_OneofBool)(nil),
+		(*Message_OneofInt32)(nil),
+		(*Message_OneofSint32)(nil),
+		(*Message_OneofUint32)(nil),
+		(*Message_OneofInt64)(nil),
+		(*Message_OneofSint64)(nil),
+		(*Message_OneofUint64)(nil),
+		(*Message_OneofFixed32)(nil),
+		(*Message_OneofSfixed32)(nil),
+		(*Message_OneofFloat)(nil),
+		(*Message_OneofFixed64)(nil),
+		(*Message_OneofSfixed64)(nil),
+		(*Message_OneofDouble)(nil),
+		(*Message_OneofString)(nil),
+		(*Message_OneofBytes)(nil),
+		(*Message_OneofChildEnum)(nil),
+		(*Message_OneofChildMessage)(nil),
+		(*Message_OneofSiblingEnum)(nil),
+		(*Message_OneofSiblingMessage)(nil),
+		(*Message_OneofString1)(nil),
+		(*Message_OneofString2)(nil),
+		(*Message_OneofString3)(nil),
+	}
+}
+
+func _Message_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*Message)
+	// oneof_union
+	switch x := m.OneofUnion.(type) {
+	case *Message_OneofBool:
+		t := uint64(0)
+		if x.OneofBool {
+			t = 1
+		}
+		b.EncodeVarint(400<<3 | proto.WireVarint)
+		b.EncodeVarint(t)
+	case *Message_OneofInt32:
+		b.EncodeVarint(401<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofInt32))
+	case *Message_OneofSint32:
+		b.EncodeVarint(402<<3 | proto.WireVarint)
+		b.EncodeZigzag32(uint64(x.OneofSint32))
+	case *Message_OneofUint32:
+		b.EncodeVarint(403<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofUint32))
+	case *Message_OneofInt64:
+		b.EncodeVarint(404<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofInt64))
+	case *Message_OneofSint64:
+		b.EncodeVarint(405<<3 | proto.WireVarint)
+		b.EncodeZigzag64(uint64(x.OneofSint64))
+	case *Message_OneofUint64:
+		b.EncodeVarint(406<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofUint64))
+	case *Message_OneofFixed32:
+		b.EncodeVarint(407<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(x.OneofFixed32))
+	case *Message_OneofSfixed32:
+		b.EncodeVarint(408<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(x.OneofSfixed32))
+	case *Message_OneofFloat:
+		b.EncodeVarint(409<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(math.Float32bits(x.OneofFloat)))
+	case *Message_OneofFixed64:
+		b.EncodeVarint(410<<3 | proto.WireFixed64)
+		b.EncodeFixed64(uint64(x.OneofFixed64))
+	case *Message_OneofSfixed64:
+		b.EncodeVarint(411<<3 | proto.WireFixed64)
+		b.EncodeFixed64(uint64(x.OneofSfixed64))
+	case *Message_OneofDouble:
+		b.EncodeVarint(412<<3 | proto.WireFixed64)
+		b.EncodeFixed64(math.Float64bits(x.OneofDouble))
+	case *Message_OneofString:
+		b.EncodeVarint(413<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString)
+	case *Message_OneofBytes:
+		b.EncodeVarint(414<<3 | proto.WireBytes)
+		b.EncodeRawBytes(x.OneofBytes)
+	case *Message_OneofChildEnum:
+		b.EncodeVarint(415<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofChildEnum))
+	case *Message_OneofChildMessage:
+		b.EncodeVarint(416<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.OneofChildMessage); err != nil {
+			return err
+		}
+	case *Message_OneofSiblingEnum:
+		b.EncodeVarint(417<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofSiblingEnum))
+	case *Message_OneofSiblingMessage:
+		b.EncodeVarint(418<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.OneofSiblingMessage); err != nil {
+			return err
+		}
+	case *Message_OneofString1:
+		b.EncodeVarint(419<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString1)
+	case *Message_OneofString2:
+		b.EncodeVarint(420<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString2)
+	case *Message_OneofString3:
+		b.EncodeVarint(421<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString3)
+	case nil:
+	default:
+		return fmt.Errorf("Message.OneofUnion has unexpected type %T", x)
+	}
+	return nil
+}
+
+func _Message_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*Message)
+	switch tag {
+	case 400: // oneof_union.oneof_bool
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofBool{x != 0}
+		return true, err
+	case 401: // oneof_union.oneof_int32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofInt32{int32(x)}
+		return true, err
+	case 402: // oneof_union.oneof_sint32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeZigzag32()
+		m.OneofUnion = &Message_OneofSint32{int32(x)}
+		return true, err
+	case 403: // oneof_union.oneof_uint32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofUint32{uint32(x)}
+		return true, err
+	case 404: // oneof_union.oneof_int64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofInt64{int64(x)}
+		return true, err
+	case 405: // oneof_union.oneof_sint64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeZigzag64()
+		m.OneofUnion = &Message_OneofSint64{int64(x)}
+		return true, err
+	case 406: // oneof_union.oneof_uint64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofUint64{x}
+		return true, err
+	case 407: // oneof_union.oneof_fixed32
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofUnion = &Message_OneofFixed32{uint32(x)}
+		return true, err
+	case 408: // oneof_union.oneof_sfixed32
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofUnion = &Message_OneofSfixed32{int32(x)}
+		return true, err
+	case 409: // oneof_union.oneof_float
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofUnion = &Message_OneofFloat{math.Float32frombits(uint32(x))}
+		return true, err
+	case 410: // oneof_union.oneof_fixed64
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofUnion = &Message_OneofFixed64{x}
+		return true, err
+	case 411: // oneof_union.oneof_sfixed64
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofUnion = &Message_OneofSfixed64{int64(x)}
+		return true, err
+	case 412: // oneof_union.oneof_double
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofUnion = &Message_OneofDouble{math.Float64frombits(x)}
+		return true, err
+	case 413: // oneof_union.oneof_string
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString{x}
+		return true, err
+	case 414: // oneof_union.oneof_bytes
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeRawBytes(true)
+		m.OneofUnion = &Message_OneofBytes{x}
+		return true, err
+	case 415: // oneof_union.oneof_child_enum
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofChildEnum{Message_ChildEnum(x)}
+		return true, err
+	case 416: // oneof_union.oneof_child_message
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(Message_ChildMessage)
+		err := b.DecodeMessage(msg)
+		m.OneofUnion = &Message_OneofChildMessage{msg}
+		return true, err
+	case 417: // oneof_union.oneof_sibling_enum
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofSiblingEnum{SiblingEnum(x)}
+		return true, err
+	case 418: // oneof_union.oneof_sibling_message
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(SiblingMessage)
+		err := b.DecodeMessage(msg)
+		m.OneofUnion = &Message_OneofSiblingMessage{msg}
+		return true, err
+	case 419: // oneof_union.oneof_string1
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString1{x}
+		return true, err
+	case 420: // oneof_union.oneof_string2
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString2{x}
+		return true, err
+	case 421: // oneof_union.oneof_string3
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString3{x}
+		return true, err
+	default:
+		return false, nil
+	}
+}
+
+func _Message_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*Message)
+	// oneof_union
+	switch x := m.OneofUnion.(type) {
+	case *Message_OneofBool:
+		n += proto.SizeVarint(400<<3 | proto.WireVarint)
+		n += 1
+	case *Message_OneofInt32:
+		n += proto.SizeVarint(401<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofInt32))
+	case *Message_OneofSint32:
+		n += proto.SizeVarint(402<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64((uint32(x.OneofSint32) << 1) ^ uint32((int32(x.OneofSint32) >> 31))))
+	case *Message_OneofUint32:
+		n += proto.SizeVarint(403<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofUint32))
+	case *Message_OneofInt64:
+		n += proto.SizeVarint(404<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofInt64))
+	case *Message_OneofSint64:
+		n += proto.SizeVarint(405<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(uint64(x.OneofSint64<<1) ^ uint64((int64(x.OneofSint64) >> 63))))
+	case *Message_OneofUint64:
+		n += proto.SizeVarint(406<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofUint64))
+	case *Message_OneofFixed32:
+		n += proto.SizeVarint(407<<3 | proto.WireFixed32)
+		n += 4
+	case *Message_OneofSfixed32:
+		n += proto.SizeVarint(408<<3 | proto.WireFixed32)
+		n += 4
+	case *Message_OneofFloat:
+		n += proto.SizeVarint(409<<3 | proto.WireFixed32)
+		n += 4
+	case *Message_OneofFixed64:
+		n += proto.SizeVarint(410<<3 | proto.WireFixed64)
+		n += 8
+	case *Message_OneofSfixed64:
+		n += proto.SizeVarint(411<<3 | proto.WireFixed64)
+		n += 8
+	case *Message_OneofDouble:
+		n += proto.SizeVarint(412<<3 | proto.WireFixed64)
+		n += 8
+	case *Message_OneofString:
+		n += proto.SizeVarint(413<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofString)))
+		n += len(x.OneofString)
+	case *Message_OneofBytes:
+		n += proto.SizeVarint(414<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofBytes)))
+		n += len(x.OneofBytes)
+	case *Message_OneofChildEnum:
+		n += proto.SizeVarint(415<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofChildEnum))
+	case *Message_OneofChildMessage:
+		s := proto.Size(x.OneofChildMessage)
+		n += proto.SizeVarint(416<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *Message_OneofSiblingEnum:
+		n += proto.SizeVarint(417<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.OneofSiblingEnum))
+	case *Message_OneofSiblingMessage:
+		s := proto.Size(x.OneofSiblingMessage)
+		n += proto.SizeVarint(418<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *Message_OneofString1:
+		n += proto.SizeVarint(419<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofString1)))
+		n += len(x.OneofString1)
+	case *Message_OneofString2:
+		n += proto.SizeVarint(420<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofString2)))
+		n += len(x.OneofString2)
+	case *Message_OneofString3:
+		n += proto.SizeVarint(421<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.OneofString3)))
+		n += len(x.OneofString3)
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	return n
+}
+
+type Message_ChildMessage struct {
+	F1 string   `protobuf:"bytes,1,opt,name=f1" json:"f1,omitempty"`
+	F2 []string `protobuf:"bytes,2,rep,name=f2" json:"f2,omitempty"`
+	F3 *Message `protobuf:"bytes,3,opt,name=f3" json:"f3,omitempty"`
+}
+
+func (m *Message_ChildMessage) Reset()                    { *m = Message_ChildMessage{} }
+func (m *Message_ChildMessage) String() string            { return proto.CompactTextString(m) }
+func (*Message_ChildMessage) ProtoMessage()               {}
+func (*Message_ChildMessage) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1, 0} }
+
+func (m *Message_ChildMessage) GetF1() string {
+	if m != nil {
+		return m.F1
+	}
+	return ""
+}
+
+func (m *Message_ChildMessage) GetF2() []string {
+	if m != nil {
+		return m.F2
+	}
+	return nil
+}
+
+func (m *Message_ChildMessage) GetF3() *Message {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*SiblingMessage)(nil), "google.golang.org.proto3_20180125.SiblingMessage")
+	proto.RegisterType((*Message)(nil), "google.golang.org.proto3_20180125.Message")
+	proto.RegisterType((*Message_ChildMessage)(nil), "google.golang.org.proto3_20180125.Message.ChildMessage")
+	proto.RegisterEnum("google.golang.org.proto3_20180125.SiblingEnum", SiblingEnum_name, SiblingEnum_value)
+	proto.RegisterEnum("google.golang.org.proto3_20180125.Message_ChildEnum", Message_ChildEnum_name, Message_ChildEnum_value)
+}
+
+func init() { proto.RegisterFile("proto3_20180125_92554152/test.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+	// 1947 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x9a, 0x59, 0x73, 0xdb, 0xc8,
+	0x11, 0xc7, 0x09, 0x52, 0x87, 0x35, 0xe2, 0x09, 0x5a, 0xca, 0x94, 0x9e, 0x10, 0xd9, 0x71, 0x10,
+	0x27, 0x45, 0x99, 0x14, 0x84, 0x38, 0x4e, 0x62, 0x5b, 0xb2, 0xe5, 0xd0, 0x29, 0x3b, 0x71, 0xc1,
+	0xa5, 0x3c, 0xe4, 0x45, 0xa1, 0x24, 0x90, 0xa6, 0x0d, 0x12, 0x8a, 0x48, 0xba, 0xa2, 0xca, 0x83,
+	0xbf, 0x42, 0xee, 0x3b, 0x7b, 0xef, 0xdb, 0xde, 0xf7, 0x7d, 0x7b, 0xcb, 0x7b, 0xdf, 0xe7, 0xa7,
+	0xd9, 0x1a, 0x34, 0xe6, 0x02, 0x40, 0x93, 0x04, 0x6b, 0x1f, 0x5c, 0x25, 0x35, 0xff, 0xd3, 0x3f,
+	0x76, 0xa3, 0xa7, 0x7b, 0x06, 0x16, 0x3a, 0xb4, 0xbb, 0xe7, 0x76, 0xdd, 0xe5, 0xcd, 0xca, 0xb1,
+	0xf2, 0xf1, 0x63, 0xe5, 0xca, 0xca, 0xe6, 0x4f, 0x2a, 0x2b, 0x2b, 0x46, 0x79, 0xa5, 0xb2, 0xd4,
+	0xb5, 0x3b, 0xdd, 0x92, 0xf7, 0xa9, 0xfa, 0xdd, 0x86, 0xeb, 0x36, 0x1c, 0xbb, 0xd4, 0x70, 0x9d,
+	0x5a, 0xbb, 0x51, 0x72, 0xf7, 0x1a, 0xa5, 0xc0, 0xb2, 0x45, 0x07, 0x65, 0x2f, 0x37, 0xb7, 0x9c,
+	0x66, 0xbb, 0x71, 0xd1, 0xee, 0x74, 0x6a, 0x0d, 0x5b, 0xcd, 0xa2, 0x64, 0xbd, 0x8c, 0x15, 0x4d,
+	0xd1, 0x67, 0xac, 0x64, 0xbd, 0xec, 0xfd, 0x5e, 0xc1, 0x49, 0x2d, 0xe5, 0xfd, 0x5e, 0x51, 0x4f,
+	0xa0, 0x64, 0x7d, 0x19, 0xa7, 0x34, 0x45, 0x9f, 0xad, 0x1c, 0x2d, 0x0d, 0x24, 0x94, 0x7c, 0xbf,
+	0x56, 0xb2, 0xbe, 0xbc, 0x78, 0xf3, 0x34, 0x9a, 0xa6, 0x9c, 0x43, 0x28, 0xe3, 0xee, 0x76, 0x9b,
+	0x6e, 0xbb, 0xe6, 0x6c, 0x6e, 0xb9, 0xae, 0x83, 0x77, 0x34, 0x45, 0x3f, 0x60, 0xa5, 0xa9, 0x71,
+	0xcd, 0x75, 0x1d, 0xf5, 0x7b, 0x28, 0xcb, 0x44, 0xcd, 0x76, 0x77, 0xb9, 0x82, 0x6d, 0x4d, 0xd1,
+	0x27, 0x2d, 0xb6, 0xf4, 0x3c, 0x31, 0xaa, 0xdf, 0x47, 0x39, 0x26, 0xeb, 0x80, 0xae, 0xae, 0x29,
+	0x7a, 0xc1, 0x62, 0xab, 0x2f, 0x37, 0x43, 0xc2, 0x1e, 0x08, 0x1b, 0x9a, 0xa2, 0x67, 0xb8, 0x70,
+	0x03, 0x84, 0x01, 0xb0, 0x69, 0xe0, 0x2b, 0x9a, 0xa2, 0xa7, 0x24, 0xb0, 0x69, 0x84, 0xc0, 0xa6,
+	0x81, 0x9b, 0x9a, 0xa2, 0xab, 0x32, 0x38, 0x20, 0xec, 0x81, 0xf0, 0xaa, 0xa6, 0xe8, 0x13, 0x32,
+	0xd8, 0x34, 0xd4, 0x1f, 0xa0, 0x3c, 0x13, 0xd6, 0x9b, 0x7f, 0xb0, 0x77, 0x96, 0x2b, 0xf8, 0x9a,
+	0xa6, 0xe8, 0xd3, 0x16, 0x73, 0x70, 0x0e, 0xcc, 0xea, 0x0f, 0x51, 0x81, 0xc3, 0xa9, 0xd6, 0xd1,
+	0x14, 0x3d, 0x67, 0x31, 0x1f, 0x97, 0x7d, 0xbb, 0x14, 0x50, 0xdd, 0x71, 0x6b, 0x5d, 0xdc, 0xd2,
+	0x14, 0x3d, 0xc9, 0x03, 0x3a, 0x47, 0x8c, 0x61, 0xbc, 0x69, 0xe0, 0xb6, 0xa6, 0xe8, 0x53, 0x01,
+	0xbc, 0x69, 0x44, 0xe0, 0x4d, 0x03, 0xbb, 0x9a, 0xa2, 0xe7, 0x83, 0xf8, 0x40, 0xfc, 0x3b, 0x6e,
+	0x6f, 0xcb, 0xb1, 0xf1, 0xae, 0xa6, 0xe8, 0x0a, 0x8f, 0xff, 0xac, 0x67, 0x95, 0x33, 0xda, 0xdd,
+	0x6b, 0xb6, 0x1b, 0xf8, 0xf7, 0x5e, 0x2d, 0xf2, 0x8c, 0x7a, 0x56, 0x29, 0xa0, 0xad, 0xfd, 0xae,
+	0xdd, 0xc1, 0x7b, 0x9a, 0xa2, 0xa7, 0x79, 0x40, 0x6b, 0xc4, 0xa8, 0xee, 0xa0, 0x22, 0x93, 0x6d,
+	0x5f, 0x69, 0x3a, 0x3b, 0x9b, 0x76, 0xbb, 0xd7, 0xc2, 0x1d, 0x4d, 0xd1, 0xb3, 0x15, 0x63, 0xf8,
+	0xfa, 0x2d, 0x9d, 0x21, 0x8b, 0xd7, 0xdb, 0xbd, 0x96, 0xc5, 0xc2, 0x66, 0x26, 0xb5, 0x85, 0xe6,
+	0x03, 0x94, 0x16, 0x2c, 0xc3, 0x5d, 0x6f, 0xa3, 0xfc, 0x78, 0x54, 0x10, 0xdd, 0x35, 0x07, 0x25,
+	0x16, 0xdd, 0x3b, 0x5b, 0x68, 0x4e, 0x28, 0x3b, 0x6f, 0xfb, 0x42, 0x58, 0x3d, 0x2f, 0xac, 0xd2,
+	0x10, 0x34, 0x7f, 0xd7, 0x7b, 0x01, 0x15, 0x79, 0xb1, 0x32, 0xa3, 0x7a, 0x0d, 0xe1, 0x10, 0x83,
+	0x06, 0x75, 0xdd, 0x0b, 0xaa, 0x3c, 0x3c, 0x86, 0x86, 0x33, 0x1f, 0x20, 0xd1, 0x80, 0x0e, 0xa3,
+	0xcc, 0x9e, 0xbd, 0x6b, 0xd7, 0xba, 0xf6, 0x0e, 0x34, 0x83, 0x5b, 0x8a, 0x96, 0x22, 0xdd, 0x80,
+	0x5a, 0xbd, 0x6e, 0x70, 0x04, 0x65, 0x99, 0x0a, 0x36, 0xef, 0x5b, 0x44, 0x36, 0x69, 0xb1, 0xc5,
+	0xd0, 0x0e, 0x74, 0x94, 0x63, 0x3a, 0xbf, 0x1d, 0xbc, 0x4d, 0x84, 0x05, 0x8b, 0xad, 0xf7, 0xfb,
+	0x81, 0xa8, 0xf4, 0xfb, 0xc1, 0x3b, 0x44, 0x99, 0xe1, 0x4a, 0xbf, 0x21, 0x04, 0xd8, 0xa6, 0x81,
+	0xdf, 0x25, 0xc2, 0x94, 0xc4, 0x36, 0x8d, 0x10, 0xdb, 0x34, 0xf0, 0x7b, 0x44, 0xa8, 0xca, 0xec,
+	0x80, 0xd2, 0x6f, 0x09, 0xef, 0x13, 0xe5, 0x84, 0xcc, 0x36, 0x0d, 0xf5, 0x28, 0xca, 0x33, 0x25,
+	0xdd, 0xe7, 0x1f, 0x10, 0xe9, 0xb4, 0xc5, 0x5c, 0xd0, 0xa6, 0xf0, 0x23, 0x54, 0xe0, 0x7c, 0x2a,
+	0xfe, 0x90, 0x88, 0x73, 0x16, 0xf3, 0xc2, 0xba, 0x82, 0x18, 0x15, 0x74, 0x85, 0x8f, 0x88, 0x34,
+	0xc9, 0xa3, 0x82, 0xb6, 0x10, 0xfa, 0x06, 0xa6, 0x81, 0x3f, 0x26, 0xca, 0xa9, 0xc0, 0x37, 0x30,
+	0x8d, 0x88, 0x6f, 0x60, 0x1a, 0xf8, 0x13, 0x22, 0xce, 0x07, 0xbf, 0x41, 0x20, 0x0b, 0x7e, 0x63,
+	0xf8, 0x94, 0x68, 0x15, 0x9e, 0x05, 0xbf, 0x33, 0x48, 0x99, 0x85, 0xce, 0xf0, 0x99, 0xe2, 0x8d,
+	0x25, 0x9e, 0x59, 0x68, 0x0d, 0x62, 0x54, 0xd0, 0x1a, 0x3e, 0x27, 0xc2, 0x34, 0x8f, 0x0a, 0x7a,
+	0x83, 0x8d, 0x8a, 0x4c, 0x27, 0xf4, 0x86, 0x2f, 0x88, 0x38, 0x76, 0x73, 0xa0, 0x1e, 0x79, 0x73,
+	0x68, 0xa3, 0xf9, 0x00, 0x86, 0xee, 0xa3, 0x2f, 0x09, 0x69, 0x9c, 0xee, 0x20, 0xc1, 0xe8, 0x66,
+	0xda, 0x46, 0x73, 0x42, 0x09, 0x0a, 0xdd, 0xe1, 0x2b, 0x08, 0x6c, 0xe4, 0xf6, 0xc0, 0x0b, 0x97,
+	0xb7, 0x07, 0x07, 0xe1, 0x10, 0x84, 0x86, 0xf5, 0x35, 0x84, 0x15, 0xa7, 0x3f, 0x04, 0x50, 0x34,
+	0xa4, 0xdf, 0xa1, 0x4c, 0xab, 0xb6, 0xeb, 0xb5, 0x06, 0xe8, 0x0f, 0x0f, 0x24, 0x3d, 0xc4, 0x4f,
+	0x47, 0xc8, 0xdc, 0xc5, 0xda, 0x2e, 0xe9, 0x22, 0xe4, 0xdf, 0x7a, 0xbb, 0xbb, 0xb7, 0x6f, 0xcd,
+	0xb6, 0xb8, 0x45, 0xdd, 0x46, 0x59, 0x46, 0x80, 0x46, 0xf0, 0x20, 0x20, 0x7e, 0x36, 0x3a, 0xc2,
+	0xeb, 0x42, 0xc0, 0x48, 0xb7, 0x04, 0x93, 0x5a, 0x47, 0x39, 0x06, 0xf1, 0x1b, 0xd3, 0x43, 0x40,
+	0xf9, 0xf9, 0xe8, 0x14, 0x68, 0x61, 0x80, 0xc9, 0xb4, 0x44, 0x9b, 0xc4, 0xf1, 0xdb, 0xda, 0xc3,
+	0xb1, 0x39, 0x1b, 0x11, 0x1c, 0xbf, 0x29, 0x06, 0x92, 0x66, 0x1a, 0xf8, 0x91, 0x71, 0x92, 0x66,
+	0x1a, 0xa1, 0xa4, 0x99, 0x46, 0x28, 0x69, 0xa6, 0x81, 0x1f, 0x1d, 0x2b, 0x69, 0x14, 0x23, 0x26,
+	0x2d, 0xc0, 0xf1, 0xfb, 0xf1, 0x63, 0x63, 0x25, 0x2d, 0xc8, 0xf1, 0xbb, 0x79, 0x13, 0xe5, 0x19,
+	0x87, 0x36, 0xe8, 0xc7, 0x01, 0x74, 0x72, 0x74, 0x90, 0xdf, 0xf7, 0x81, 0x94, 0x6d, 0x49, 0x46,
+	0xd5, 0x41, 0x05, 0x9e, 0x3a, 0xca, 0x7a, 0x02, 0x58, 0xa7, 0x62, 0x24, 0xaf, 0x2e, 0xc2, 0x72,
+	0x2d, 0xd9, 0x2a, 0x55, 0x03, 0x0c, 0x93, 0x27, 0x63, 0x57, 0x83, 0x37, 0x76, 0xe4, 0x6a, 0x80,
+	0x49, 0x14, 0xca, 0x9e, 0x69, 0xe0, 0xa7, 0xc6, 0xcb, 0x1e, 0x7d, 0x4e, 0x52, 0xf6, 0x4c, 0x23,
+	0x22, 0x7b, 0xa6, 0x81, 0x9f, 0x1e, 0x33, 0x7b, 0x14, 0x26, 0x67, 0x2f, 0x50, 0x7e, 0xfe, 0x20,
+	0x7c, 0x26, 0x76, 0xf9, 0xc1, 0xc8, 0x94, 0xcb, 0xcf, 0x1f, 0xa3, 0xd2, 0x76, 0x82, 0x31, 0xfa,
+	0x6c, 0xfc, 0xed, 0xe4, 0x39, 0x08, 0x6c, 0x27, 0x18, 0xc2, 0x62, 0x35, 0xc0, 0x10, 0x7e, 0x2e,
+	0x76, 0x35, 0x78, 0xe3, 0x5a, 0xae, 0x06, 0x98, 0xe0, 0xbb, 0xa8, 0xc8, 0x20, 0xc2, 0x04, 0x7f,
+	0x1e, 0x48, 0xa7, 0x47, 0x27, 0xb1, 0xa9, 0x0d, 0xb4, 0x7c, 0x2b, 0x60, 0x56, 0xf7, 0xd1, 0x7c,
+	0x80, 0x48, 0xa7, 0xde, 0x0b, 0x00, 0x3d, 0x13, 0x13, 0xea, 0xdb, 0x80, 0x5b, 0x6c, 0x85, 0x3f,
+	0x51, 0xaf, 0xa3, 0x39, 0xa1, 0x11, 0x0a, 0x73, 0xfd, 0x45, 0x20, 0xaf, 0xc5, 0x69, 0x87, 0x6c,
+	0xa2, 0x03, 0x58, 0x6d, 0x85, 0x3e, 0x50, 0x6f, 0x20, 0x1c, 0xe2, 0xd2, 0xa0, 0x5f, 0x02, 0xf4,
+	0x7a, 0x6c, 0xb4, 0x14, 0xf6, 0x5c, 0x2b, 0xea, 0x33, 0x5a, 0x4a, 0xde, 0xcc, 0x81, 0xf1, 0xff,
+	0x72, 0xac, 0x52, 0xf2, 0x86, 0x30, 0x9f, 0xff, 0xa4, 0x94, 0x98, 0x89, 0xee, 0x8b, 0x8e, 0x40,
+	0x79, 0x25, 0xd6, 0xbe, 0x80, 0x19, 0xcc, 0x31, 0x64, 0x5f, 0x70, 0x1b, 0xe5, 0xf4, 0x04, 0xce,
+	0xab, 0xb1, 0x38, 0x1b, 0x11, 0x1c, 0x6e, 0x13, 0x92, 0x66, 0x1a, 0x80, 0x79, 0x2d, 0x6e, 0xd2,
+	0x4c, 0x23, 0x94, 0x34, 0x30, 0x89, 0x49, 0xa3, 0x94, 0xd7, 0x63, 0x27, 0x4d, 0xc4, 0xd0, 0xa4,
+	0xc9, 0x9c, 0x9e, 0xc0, 0x79, 0x23, 0x76, 0xd2, 0x82, 0x1c, 0x6e, 0xa3, 0xd3, 0xc5, 0x9f, 0x68,
+	0x00, 0xba, 0x19, 0x6b, 0xba, 0xf8, 0x23, 0x98, 0x93, 0xc8, 0xd3, 0x10, 0x8c, 0x2c, 0x75, 0x5e,
+	0xb7, 0x04, 0xd2, 0x9b, 0xf1, 0x52, 0xe7, 0x79, 0x08, 0xa4, 0x8e, 0xd9, 0x54, 0x0d, 0x21, 0xb7,
+	0x6d, 0xbb, 0x75, 0x40, 0xfc, 0x29, 0xa5, 0x29, 0xfa, 0x81, 0x6a, 0xc2, 0x9a, 0xf1, 0x8c, 0x9e,
+	0x62, 0x11, 0xcd, 0x82, 0x02, 0x4e, 0x8a, 0x7f, 0x26, 0x92, 0xc9, 0x6a, 0xc2, 0x82, 0x75, 0x70,
+	0x72, 0x3d, 0x8c, 0xd2, 0xa0, 0xf1, 0x8f, 0xad, 0x7f, 0x21, 0xa2, 0x42, 0x35, 0x61, 0xc1, 0x52,
+	0xff, 0xdc, 0xc9, 0x54, 0xfe, 0xa1, 0xf3, 0xaf, 0x44, 0x95, 0x61, 0x2a, 0xff, 0xd4, 0x28, 0xf2,
+	0x4c, 0x03, 0xff, 0x8d, 0x88, 0x52, 0x22, 0xcf, 0x34, 0x64, 0x9e, 0x69, 0xe0, 0xbf, 0x13, 0x91,
+	0x2a, 0xf1, 0x44, 0x95, 0x7f, 0x5e, 0xfb, 0x07, 0x51, 0x4d, 0x48, 0x3c, 0xd3, 0x50, 0x8f, 0xa0,
+	0x0c, 0xa8, 0xe8, 0x09, 0xe8, 0x9f, 0x44, 0x36, 0x5d, 0x4d, 0x58, 0xb0, 0x9a, 0x9e, 0x96, 0x74,
+	0x94, 0xf5, 0x99, 0x54, 0xf8, 0x2f, 0x22, 0xcc, 0x55, 0x13, 0x16, 0x38, 0x60, 0x27, 0x1d, 0x16,
+	0x01, 0x1c, 0x73, 0xfe, 0x4d, 0x64, 0x49, 0x16, 0x01, 0x1c, 0x54, 0x64, 0xaa, 0x69, 0xe0, 0xff,
+	0x10, 0xd5, 0x94, 0x4c, 0xf5, 0x2e, 0xc0, 0x12, 0xd5, 0x34, 0xf0, 0x7f, 0x89, 0x30, 0x1f, 0xa0,
+	0x8a, 0xd1, 0xfa, 0xc7, 0x83, 0xff, 0x11, 0x9d, 0xc2, 0xa2, 0xf5, 0xe7, 0x3b, 0xcf, 0x1c, 0x0c,
+	0xf7, 0xff, 0x13, 0xd5, 0x0c, 0xcf, 0x1c, 0x4c, 0x67, 0x16, 0x01, 0x8c, 0xe6, 0x3b, 0x88, 0x28,
+	0xcd, 0x22, 0x80, 0xe1, 0x5a, 0x43, 0x79, 0xd0, 0x08, 0x93, 0xf5, 0xce, 0x54, 0xfc, 0x17, 0x67,
+	0xd5, 0x84, 0x05, 0xa1, 0xf2, 0x69, 0x7a, 0x15, 0x15, 0x45, 0x04, 0x9d, 0x2a, 0x77, 0xa5, 0xc6,
+	0x7a, 0x6b, 0x56, 0x4d, 0x58, 0x05, 0x0e, 0xa2, 0x53, 0x64, 0x13, 0xa9, 0xb4, 0xa4, 0x84, 0xd9,
+	0x79, 0x77, 0x2a, 0xce, 0x2b, 0xb3, 0x6a, 0xc2, 0xca, 0xfb, 0x85, 0xc8, 0xe7, 0xe4, 0x15, 0x34,
+	0x27, 0x03, 0x68, 0x38, 0xf7, 0xa4, 0x62, 0xbe, 0x2f, 0xab, 0x26, 0xac, 0xa2, 0x88, 0xa1, 0xa1,
+	0xb0, 0xda, 0x82, 0x67, 0x5c, 0xc6, 0xf7, 0xd2, 0x87, 0x9c, 0x16, 0x1e, 0x72, 0x39, 0xa8, 0xab,
+	0xe0, 0xfb, 0xa2, 0x74, 0x95, 0xa0, 0x6e, 0x19, 0xdf, 0x1f, 0xa5, 0x5b, 0x5e, 0xb8, 0x8a, 0xd2,
+	0x52, 0x4a, 0xbf, 0xc5, 0xff, 0x2b, 0x58, 0x38, 0x89, 0xf2, 0xc1, 0x1b, 0xbb, 0x9a, 0x47, 0xa9,
+	0x6b, 0xf6, 0xbe, 0x07, 0x3c, 0x60, 0x91, 0x1f, 0xd5, 0x83, 0x68, 0xf2, 0x7a, 0xcd, 0xe9, 0xd9,
+	0x38, 0xe9, 0xd9, 0xe0, 0x97, 0x13, 0xc9, 0xe3, 0xca, 0xc2, 0x29, 0x54, 0x08, 0x5d, 0xc7, 0x07,
+	0x39, 0x98, 0x14, 0x1d, 0x9c, 0x46, 0x6a, 0xf8, 0xa6, 0x3d, 0xc8, 0x43, 0x21, 0xda, 0xc3, 0xc6,
+	0xf0, 0x1e, 0x32, 0x7d, 0x83, 0xf0, 0xaf, 0x0e, 0x83, 0x1c, 0xa4, 0xfa, 0x07, 0x31, 0xa4, 0x07,
+	0xb5, 0x7f, 0x10, 0x43, 0x7a, 0x98, 0x10, 0x3d, 0xac, 0xa2, 0x62, 0xc4, 0x65, 0x75, 0x90, 0x8b,
+	0x69, 0xd1, 0xc5, 0x1a, 0x3a, 0x18, 0x75, 0x07, 0x1d, 0xe4, 0x23, 0x17, 0x9d, 0x4b, 0x7e, 0xb9,
+	0x1c, 0xe4, 0x20, 0x79, 0x9b, 0x38, 0x86, 0x4c, 0xc5, 0xd4, 0xed, 0xe2, 0x18, 0xd2, 0x47, 0x3e,
+	0xfa, 0x81, 0x08, 0xb7, 0xbc, 0x41, 0x1e, 0x94, 0x3e, 0x45, 0xc1, 0xef, 0x6f, 0x83, 0x3c, 0xcc,
+	0x44, 0xe7, 0x92, 0x5f, 0xcd, 0x06, 0x39, 0x48, 0x8b, 0x0e, 0xf6, 0xd1, 0x5c, 0xe4, 0x8d, 0x2b,
+	0xc2, 0xc9, 0x2f, 0x45, 0x27, 0x71, 0x5f, 0xcb, 0x0a, 0xe8, 0x1b, 0x08, 0xf7, 0xbb, 0x77, 0x45,
+	0xd0, 0x2f, 0x8a, 0xf4, 0x31, 0x5e, 0xd5, 0x0a, 0x5f, 0xa0, 0x87, 0xbe, 0xd3, 0xe7, 0xfa, 0x15,
+	0xc1, 0x3f, 0x2b, 0x47, 0x3f, 0xea, 0xbb, 0x5b, 0x01, 0xfb, 0x47, 0xb4, 0xd0, 0xff, 0xea, 0x15,
+	0x41, 0xfe, 0x85, 0x1c, 0x79, 0x8c, 0xb7, 0xb9, 0xa1, 0x82, 0x91, 0x2f, 0x60, 0x22, 0x73, 0x72,
+	0x50, 0x3b, 0x87, 0x9a, 0x0d, 0xdc, 0xad, 0x44, 0x0f, 0x85, 0xe1, 0x3c, 0x6c, 0xf4, 0xf7, 0x90,
+	0x19, 0x6e, 0xa4, 0xc8, 0x17, 0x22, 0xd1, 0x41, 0x6a, 0xf8, 0x20, 0xfa, 0x78, 0x50, 0x87, 0x0f,
+	0xa2, 0x8f, 0x87, 0x89, 0x41, 0x1e, 0xa0, 0x8b, 0x05, 0xaf, 0x27, 0xa2, 0x8b, 0xe9, 0x21, 0xc3,
+	0x90, 0xef, 0x1d, 0xa2, 0x87, 0x99, 0x01, 0x1e, 0x16, 0x4b, 0x68, 0x86, 0x1f, 0x02, 0x67, 0xd0,
+	0xe4, 0xea, 0x85, 0x4b, 0xd5, 0xd5, 0x7c, 0x82, 0xfc, 0xb8, 0x66, 0xad, 0xfe, 0xe6, 0xd7, 0x79,
+	0x45, 0x9d, 0x45, 0xd3, 0x67, 0xaa, 0xab, 0xd6, 0x85, 0xf3, 0xeb, 0xf9, 0xe4, 0x5a, 0x86, 0x1e,
+	0x57, 0x7b, 0xed, 0xa6, 0xdb, 0x3e, 0x5a, 0x46, 0xb3, 0xe2, 0xc1, 0x2b, 0xca, 0x01, 0x52, 0xd3,
+	0xdc, 0xc1, 0x2d, 0x65, 0xed, 0xd2, 0x6f, 0x7f, 0x15, 0xaa, 0xdf, 0x25, 0xaf, 0x7e, 0xb7, 0x7a,
+	0xf5, 0xa5, 0x66, 0xbb, 0x6b, 0xef, 0xb5, 0x6b, 0x8e, 0xf7, 0xd7, 0x13, 0x9e, 0xb5, 0xb3, 0xe4,
+	0xd8, 0x8d, 0xda, 0xf6, 0xfe, 0x52, 0xbf, 0x3f, 0xb4, 0xd8, 0x9a, 0x82, 0x4f, 0xbe, 0x09, 0x00,
+	0x00, 0xff, 0xff, 0x64, 0xfb, 0xb5, 0x25, 0x8b, 0x21, 0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20180125_92554152/test.proto b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20180125_92554152/test.proto
new file mode 100644
index 000000000..63212afcd
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20180125_92554152/test.proto
@@ -0,0 +1,136 @@
+// 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.
+
+syntax = "proto3";
+
+package google.golang.org.proto3_20180125;
+option go_package = "google.golang.org/protobuf/internal/testprotos/legacy/proto3_20180125_92554152";
+
+enum SiblingEnum {
+	ALPHA   = 0;
+	BRAVO   = 10;
+	CHARLIE = 200;
+}
+
+message SiblingMessage {
+	string          f1 = 1;
+	repeated string f2 = 2;
+	Message         f3 = 3;
+}
+
+message Message {
+	enum ChildEnum {
+		ALPHA   = 0;
+		BRAVO   = 1;
+		CHARLIE = 2;
+	}
+	message ChildMessage {
+		string          f1 = 1;
+		repeated string f2 = 2;
+		Message         f3 = 3;
+	}
+
+	// Optional fields.
+	bool     optional_bool     = 100;
+	int32    optional_int32    = 101;
+	sint32   optional_sint32   = 102;
+	uint32   optional_uint32   = 103;
+	int64    optional_int64    = 104;
+	sint64   optional_sint64   = 105;
+	uint64   optional_uint64   = 106;
+	fixed32  optional_fixed32  = 107;
+	sfixed32 optional_sfixed32 = 108;
+	float    optional_float    = 109;
+	fixed64  optional_fixed64  = 110;
+	sfixed64 optional_sfixed64 = 111;
+	double   optional_double   = 112;
+	string   optional_string   = 113;
+	bytes    optional_bytes    = 114;
+
+	ChildEnum      optional_child_enum      = 115;
+	ChildMessage   optional_child_message   = 116;
+	SiblingEnum    optional_sibling_enum    = 117;
+	SiblingMessage optional_sibling_message = 118;
+
+	// Repeated fields.
+	repeated bool     repeated_bool     = 200;
+	repeated int32    repeated_int32    = 201;
+	repeated sint32   repeated_sint32   = 202;
+	repeated uint32   repeated_uint32   = 203;
+	repeated int64    repeated_int64    = 204;
+	repeated sint64   repeated_sint64   = 205;
+	repeated uint64   repeated_uint64   = 206;
+	repeated fixed32  repeated_fixed32  = 207;
+	repeated sfixed32 repeated_sfixed32 = 208;
+	repeated float    repeated_float    = 209;
+	repeated fixed64  repeated_fixed64  = 210;
+	repeated sfixed64 repeated_sfixed64 = 211;
+	repeated double   repeated_double   = 212;
+	repeated string   repeated_string   = 213;
+	repeated bytes    repeated_bytes    = 214;
+
+	repeated ChildEnum      repeated_child_enum      = 215;
+	repeated ChildMessage   repeated_child_message   = 216;
+	repeated SiblingEnum    repeated_sibling_enum    = 217;
+	repeated SiblingMessage repeated_sibling_message = 218;
+
+	// Map fields.
+	map<bool, bool>     map_bool_bool     = 300;
+	map<bool, int32>    map_bool_int32    = 301;
+	map<bool, sint32>   map_bool_sint32   = 302;
+	map<bool, uint32>   map_bool_uint32   = 303;
+	map<bool, int64>    map_bool_int64    = 304;
+	map<bool, sint64>   map_bool_sint64   = 305;
+	map<bool, uint64>   map_bool_uint64   = 306;
+	map<bool, fixed32>  map_bool_fixed32  = 307;
+	map<bool, sfixed32> map_bool_sfixed32 = 308;
+	map<bool, float>    map_bool_float    = 309;
+	map<bool, fixed64>  map_bool_fixed64  = 310;
+	map<bool, sfixed64> map_bool_sfixed64 = 311;
+	map<bool, double>   map_bool_double   = 312;
+	map<bool, string>   map_bool_string   = 313;
+	map<bool, bytes>    map_bool_bytes    = 314;
+
+	map<bool, ChildEnum>      map_bool_child_enum      = 315;
+	map<bool, ChildMessage>   map_bool_child_message   = 316;
+	map<bool, SiblingEnum>    map_bool_sibling_enum    = 317;
+	map<bool, SiblingMessage> map_bool_sibling_message = 318;
+
+	map<int32, bool>   map_int32_bool   = 319;
+	map<sint32, bool>  map_sint32_bool  = 320;
+	map<uint32, bool>  map_uint32_bool  = 321;
+	map<int64, bool>   map_int64_bool   = 322;
+	map<sint64, bool>  map_sint64_bool  = 323;
+	map<uint64, bool>  map_uint64_bool  = 324;
+	map<fixed32, bool> map_fixed32_bool = 325;
+	map<string, bool>  map_string_bool  = 326;
+
+	// Oneof fields.
+	oneof oneof_union {
+		bool     oneof_bool     = 400;
+		int32    oneof_int32    = 401;
+		sint32   oneof_sint32   = 402;
+		uint32   oneof_uint32   = 403;
+		int64    oneof_int64    = 404;
+		sint64   oneof_sint64   = 405;
+		uint64   oneof_uint64   = 406;
+		fixed32  oneof_fixed32  = 407;
+		sfixed32 oneof_sfixed32 = 408;
+		float    oneof_float    = 409;
+		fixed64  oneof_fixed64  = 410;
+		sfixed64 oneof_sfixed64 = 411;
+		double   oneof_double   = 412;
+		string   oneof_string   = 413;
+		bytes    oneof_bytes    = 414;
+
+		ChildEnum      oneof_child_enum      = 415;
+		ChildMessage   oneof_child_message   = 416;
+		SiblingEnum    oneof_sibling_enum    = 417;
+		SiblingMessage oneof_sibling_message = 418;
+
+		string oneof_string1 = 419;
+		string oneof_string2 = 420;
+		string oneof_string3 = 421;
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20180430_b4deda09/test.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20180430_b4deda09/test.pb.go
new file mode 100644
index 000000000..cd2631ade
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20180430_b4deda09/test.pb.go
@@ -0,0 +1,1545 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: proto3_20180430_b4deda09/test.proto
+
+package proto3_20180430_b4deda09 // import "google.golang.org/protobuf/internal/testprotos/legacy/proto3_20180430_b4deda09"
+
+import proto "google.golang.org/protobuf/internal/protolegacy"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type SiblingEnum int32
+
+const (
+	SiblingEnum_ALPHA   SiblingEnum = 0
+	SiblingEnum_BRAVO   SiblingEnum = 10
+	SiblingEnum_CHARLIE SiblingEnum = 200
+)
+
+var SiblingEnum_name = map[int32]string{
+	0:   "ALPHA",
+	10:  "BRAVO",
+	200: "CHARLIE",
+}
+var SiblingEnum_value = map[string]int32{
+	"ALPHA":   0,
+	"BRAVO":   10,
+	"CHARLIE": 200,
+}
+
+func (x SiblingEnum) String() string {
+	return proto.EnumName(SiblingEnum_name, int32(x))
+}
+func (SiblingEnum) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_test_b39f8dbfc888d45a, []int{0}
+}
+
+type Message_ChildEnum int32
+
+const (
+	Message_ALPHA   Message_ChildEnum = 0
+	Message_BRAVO   Message_ChildEnum = 1
+	Message_CHARLIE Message_ChildEnum = 2
+)
+
+var Message_ChildEnum_name = map[int32]string{
+	0: "ALPHA",
+	1: "BRAVO",
+	2: "CHARLIE",
+}
+var Message_ChildEnum_value = map[string]int32{
+	"ALPHA":   0,
+	"BRAVO":   1,
+	"CHARLIE": 2,
+}
+
+func (x Message_ChildEnum) String() string {
+	return proto.EnumName(Message_ChildEnum_name, int32(x))
+}
+func (Message_ChildEnum) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_test_b39f8dbfc888d45a, []int{1, 0}
+}
+
+type SiblingMessage struct {
+	F1                   string   `protobuf:"bytes,1,opt,name=f1" json:"f1,omitempty"`
+	F2                   []string `protobuf:"bytes,2,rep,name=f2" json:"f2,omitempty"`
+	F3                   *Message `protobuf:"bytes,3,opt,name=f3" json:"f3,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *SiblingMessage) Reset()         { *m = SiblingMessage{} }
+func (m *SiblingMessage) String() string { return proto.CompactTextString(m) }
+func (*SiblingMessage) ProtoMessage()    {}
+func (*SiblingMessage) Descriptor() ([]byte, []int) {
+	return fileDescriptor_test_b39f8dbfc888d45a, []int{0}
+}
+func (m *SiblingMessage) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_SiblingMessage.Unmarshal(m, b)
+}
+func (m *SiblingMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_SiblingMessage.Marshal(b, m, deterministic)
+}
+func (dst *SiblingMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SiblingMessage.Merge(dst, src)
+}
+func (m *SiblingMessage) XXX_Size() int {
+	return xxx_messageInfo_SiblingMessage.Size(m)
+}
+func (m *SiblingMessage) XXX_DiscardUnknown() {
+	xxx_messageInfo_SiblingMessage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SiblingMessage proto.InternalMessageInfo
+
+func (m *SiblingMessage) GetF1() string {
+	if m != nil {
+		return m.F1
+	}
+	return ""
+}
+
+func (m *SiblingMessage) GetF2() []string {
+	if m != nil {
+		return m.F2
+	}
+	return nil
+}
+
+func (m *SiblingMessage) GetF3() *Message {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message struct {
+	// 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,proto3" json:"optional_bytes,omitempty"`
+	OptionalChildEnum      Message_ChildEnum     `protobuf:"varint,115,opt,name=optional_child_enum,json=optionalChildEnum,enum=google.golang.org.proto3_20180430.Message_ChildEnum" json:"optional_child_enum,omitempty"`
+	OptionalChildMessage   *Message_ChildMessage `protobuf:"bytes,116,opt,name=optional_child_message,json=optionalChildMessage" json:"optional_child_message,omitempty"`
+	OptionalSiblingEnum    SiblingEnum           `protobuf:"varint,117,opt,name=optional_sibling_enum,json=optionalSiblingEnum,enum=google.golang.org.proto3_20180430.SiblingEnum" json:"optional_sibling_enum,omitempty"`
+	OptionalSiblingMessage *SiblingMessage       `protobuf:"bytes,118,opt,name=optional_sibling_message,json=optionalSiblingMessage" json:"optional_sibling_message,omitempty"`
+	// Repeated fields.
+	RepeatedBool           []bool                  `protobuf:"varint,200,rep,packed,name=repeated_bool,json=repeatedBool" json:"repeated_bool,omitempty"`
+	RepeatedInt32          []int32                 `protobuf:"varint,201,rep,packed,name=repeated_int32,json=repeatedInt32" json:"repeated_int32,omitempty"`
+	RepeatedSint32         []int32                 `protobuf:"zigzag32,202,rep,packed,name=repeated_sint32,json=repeatedSint32" json:"repeated_sint32,omitempty"`
+	RepeatedUint32         []uint32                `protobuf:"varint,203,rep,packed,name=repeated_uint32,json=repeatedUint32" json:"repeated_uint32,omitempty"`
+	RepeatedInt64          []int64                 `protobuf:"varint,204,rep,packed,name=repeated_int64,json=repeatedInt64" json:"repeated_int64,omitempty"`
+	RepeatedSint64         []int64                 `protobuf:"zigzag64,205,rep,packed,name=repeated_sint64,json=repeatedSint64" json:"repeated_sint64,omitempty"`
+	RepeatedUint64         []uint64                `protobuf:"varint,206,rep,packed,name=repeated_uint64,json=repeatedUint64" json:"repeated_uint64,omitempty"`
+	RepeatedFixed32        []uint32                `protobuf:"fixed32,207,rep,packed,name=repeated_fixed32,json=repeatedFixed32" json:"repeated_fixed32,omitempty"`
+	RepeatedSfixed32       []int32                 `protobuf:"fixed32,208,rep,packed,name=repeated_sfixed32,json=repeatedSfixed32" json:"repeated_sfixed32,omitempty"`
+	RepeatedFloat          []float32               `protobuf:"fixed32,209,rep,packed,name=repeated_float,json=repeatedFloat" json:"repeated_float,omitempty"`
+	RepeatedFixed64        []uint64                `protobuf:"fixed64,210,rep,packed,name=repeated_fixed64,json=repeatedFixed64" json:"repeated_fixed64,omitempty"`
+	RepeatedSfixed64       []int64                 `protobuf:"fixed64,211,rep,packed,name=repeated_sfixed64,json=repeatedSfixed64" json:"repeated_sfixed64,omitempty"`
+	RepeatedDouble         []float64               `protobuf:"fixed64,212,rep,packed,name=repeated_double,json=repeatedDouble" json:"repeated_double,omitempty"`
+	RepeatedString         []string                `protobuf:"bytes,213,rep,name=repeated_string,json=repeatedString" json:"repeated_string,omitempty"`
+	RepeatedBytes          [][]byte                `protobuf:"bytes,214,rep,name=repeated_bytes,json=repeatedBytes,proto3" json:"repeated_bytes,omitempty"`
+	RepeatedChildEnum      []Message_ChildEnum     `protobuf:"varint,215,rep,packed,name=repeated_child_enum,json=repeatedChildEnum,enum=google.golang.org.proto3_20180430.Message_ChildEnum" json:"repeated_child_enum,omitempty"`
+	RepeatedChildMessage   []*Message_ChildMessage `protobuf:"bytes,216,rep,name=repeated_child_message,json=repeatedChildMessage" json:"repeated_child_message,omitempty"`
+	RepeatedSiblingEnum    []SiblingEnum           `protobuf:"varint,217,rep,packed,name=repeated_sibling_enum,json=repeatedSiblingEnum,enum=google.golang.org.proto3_20180430.SiblingEnum" json:"repeated_sibling_enum,omitempty"`
+	RepeatedSiblingMessage []*SiblingMessage       `protobuf:"bytes,218,rep,name=repeated_sibling_message,json=repeatedSiblingMessage" json:"repeated_sibling_message,omitempty"`
+	// Map fields.
+	MapBoolBool           map[bool]bool                  `protobuf:"bytes,300,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,301,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,302,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,303,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,304,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,305,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,306,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,307,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,308,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,309,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,310,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,311,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,312,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,313,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,314,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,proto3"`
+	MapBoolChildEnum      map[bool]Message_ChildEnum     `protobuf:"bytes,315,rep,name=map_bool_child_enum,json=mapBoolChildEnum" json:"map_bool_child_enum,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=google.golang.org.proto3_20180430.Message_ChildEnum"`
+	MapBoolChildMessage   map[bool]*Message_ChildMessage `protobuf:"bytes,316,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"`
+	MapBoolSiblingEnum    map[bool]SiblingEnum           `protobuf:"bytes,317,rep,name=map_bool_sibling_enum,json=mapBoolSiblingEnum" json:"map_bool_sibling_enum,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=google.golang.org.proto3_20180430.SiblingEnum"`
+	MapBoolSiblingMessage map[bool]*SiblingMessage       `protobuf:"bytes,318,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"`
+	MapInt32Bool          map[int32]bool                 `protobuf:"bytes,319,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,320,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,321,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,322,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,323,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,324,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,325,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,326,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.
+	//
+	// Types that are valid to be assigned to OneofUnion:
+	//	*Message_OneofBool
+	//	*Message_OneofInt32
+	//	*Message_OneofSint32
+	//	*Message_OneofUint32
+	//	*Message_OneofInt64
+	//	*Message_OneofSint64
+	//	*Message_OneofUint64
+	//	*Message_OneofFixed32
+	//	*Message_OneofSfixed32
+	//	*Message_OneofFloat
+	//	*Message_OneofFixed64
+	//	*Message_OneofSfixed64
+	//	*Message_OneofDouble
+	//	*Message_OneofString
+	//	*Message_OneofBytes
+	//	*Message_OneofChildEnum
+	//	*Message_OneofChildMessage
+	//	*Message_OneofSiblingEnum
+	//	*Message_OneofSiblingMessage
+	//	*Message_OneofString1
+	//	*Message_OneofString2
+	//	*Message_OneofString3
+	OneofUnion           isMessage_OneofUnion `protobuf_oneof:"oneof_union"`
+	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
+	XXX_unrecognized     []byte               `json:"-"`
+	XXX_sizecache        int32                `json:"-"`
+}
+
+func (m *Message) Reset()         { *m = Message{} }
+func (m *Message) String() string { return proto.CompactTextString(m) }
+func (*Message) ProtoMessage()    {}
+func (*Message) Descriptor() ([]byte, []int) {
+	return fileDescriptor_test_b39f8dbfc888d45a, []int{1}
+}
+func (m *Message) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Message.Unmarshal(m, b)
+}
+func (m *Message) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Message.Marshal(b, m, deterministic)
+}
+func (dst *Message) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Message.Merge(dst, src)
+}
+func (m *Message) XXX_Size() int {
+	return xxx_messageInfo_Message.Size(m)
+}
+func (m *Message) XXX_DiscardUnknown() {
+	xxx_messageInfo_Message.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message proto.InternalMessageInfo
+
+type isMessage_OneofUnion interface {
+	isMessage_OneofUnion()
+}
+
+type Message_OneofBool struct {
+	OneofBool bool `protobuf:"varint,400,opt,name=oneof_bool,json=oneofBool,oneof"`
+}
+type Message_OneofInt32 struct {
+	OneofInt32 int32 `protobuf:"varint,401,opt,name=oneof_int32,json=oneofInt32,oneof"`
+}
+type Message_OneofSint32 struct {
+	OneofSint32 int32 `protobuf:"zigzag32,402,opt,name=oneof_sint32,json=oneofSint32,oneof"`
+}
+type Message_OneofUint32 struct {
+	OneofUint32 uint32 `protobuf:"varint,403,opt,name=oneof_uint32,json=oneofUint32,oneof"`
+}
+type Message_OneofInt64 struct {
+	OneofInt64 int64 `protobuf:"varint,404,opt,name=oneof_int64,json=oneofInt64,oneof"`
+}
+type Message_OneofSint64 struct {
+	OneofSint64 int64 `protobuf:"zigzag64,405,opt,name=oneof_sint64,json=oneofSint64,oneof"`
+}
+type Message_OneofUint64 struct {
+	OneofUint64 uint64 `protobuf:"varint,406,opt,name=oneof_uint64,json=oneofUint64,oneof"`
+}
+type Message_OneofFixed32 struct {
+	OneofFixed32 uint32 `protobuf:"fixed32,407,opt,name=oneof_fixed32,json=oneofFixed32,oneof"`
+}
+type Message_OneofSfixed32 struct {
+	OneofSfixed32 int32 `protobuf:"fixed32,408,opt,name=oneof_sfixed32,json=oneofSfixed32,oneof"`
+}
+type Message_OneofFloat struct {
+	OneofFloat float32 `protobuf:"fixed32,409,opt,name=oneof_float,json=oneofFloat,oneof"`
+}
+type Message_OneofFixed64 struct {
+	OneofFixed64 uint64 `protobuf:"fixed64,410,opt,name=oneof_fixed64,json=oneofFixed64,oneof"`
+}
+type Message_OneofSfixed64 struct {
+	OneofSfixed64 int64 `protobuf:"fixed64,411,opt,name=oneof_sfixed64,json=oneofSfixed64,oneof"`
+}
+type Message_OneofDouble struct {
+	OneofDouble float64 `protobuf:"fixed64,412,opt,name=oneof_double,json=oneofDouble,oneof"`
+}
+type Message_OneofString struct {
+	OneofString string `protobuf:"bytes,413,opt,name=oneof_string,json=oneofString,oneof"`
+}
+type Message_OneofBytes struct {
+	OneofBytes []byte `protobuf:"bytes,414,opt,name=oneof_bytes,json=oneofBytes,proto3,oneof"`
+}
+type Message_OneofChildEnum struct {
+	OneofChildEnum Message_ChildEnum `protobuf:"varint,415,opt,name=oneof_child_enum,json=oneofChildEnum,enum=google.golang.org.proto3_20180430.Message_ChildEnum,oneof"`
+}
+type Message_OneofChildMessage struct {
+	OneofChildMessage *Message_ChildMessage `protobuf:"bytes,416,opt,name=oneof_child_message,json=oneofChildMessage,oneof"`
+}
+type Message_OneofSiblingEnum struct {
+	OneofSiblingEnum SiblingEnum `protobuf:"varint,417,opt,name=oneof_sibling_enum,json=oneofSiblingEnum,enum=google.golang.org.proto3_20180430.SiblingEnum,oneof"`
+}
+type Message_OneofSiblingMessage struct {
+	OneofSiblingMessage *SiblingMessage `protobuf:"bytes,418,opt,name=oneof_sibling_message,json=oneofSiblingMessage,oneof"`
+}
+type Message_OneofString1 struct {
+	OneofString1 string `protobuf:"bytes,419,opt,name=oneof_string1,json=oneofString1,oneof"`
+}
+type Message_OneofString2 struct {
+	OneofString2 string `protobuf:"bytes,420,opt,name=oneof_string2,json=oneofString2,oneof"`
+}
+type Message_OneofString3 struct {
+	OneofString3 string `protobuf:"bytes,421,opt,name=oneof_string3,json=oneofString3,oneof"`
+}
+
+func (*Message_OneofBool) isMessage_OneofUnion()           {}
+func (*Message_OneofInt32) isMessage_OneofUnion()          {}
+func (*Message_OneofSint32) isMessage_OneofUnion()         {}
+func (*Message_OneofUint32) isMessage_OneofUnion()         {}
+func (*Message_OneofInt64) isMessage_OneofUnion()          {}
+func (*Message_OneofSint64) isMessage_OneofUnion()         {}
+func (*Message_OneofUint64) isMessage_OneofUnion()         {}
+func (*Message_OneofFixed32) isMessage_OneofUnion()        {}
+func (*Message_OneofSfixed32) isMessage_OneofUnion()       {}
+func (*Message_OneofFloat) isMessage_OneofUnion()          {}
+func (*Message_OneofFixed64) isMessage_OneofUnion()        {}
+func (*Message_OneofSfixed64) isMessage_OneofUnion()       {}
+func (*Message_OneofDouble) isMessage_OneofUnion()         {}
+func (*Message_OneofString) isMessage_OneofUnion()         {}
+func (*Message_OneofBytes) isMessage_OneofUnion()          {}
+func (*Message_OneofChildEnum) isMessage_OneofUnion()      {}
+func (*Message_OneofChildMessage) isMessage_OneofUnion()   {}
+func (*Message_OneofSiblingEnum) isMessage_OneofUnion()    {}
+func (*Message_OneofSiblingMessage) isMessage_OneofUnion() {}
+func (*Message_OneofString1) isMessage_OneofUnion()        {}
+func (*Message_OneofString2) isMessage_OneofUnion()        {}
+func (*Message_OneofString3) isMessage_OneofUnion()        {}
+
+func (m *Message) GetOneofUnion() isMessage_OneofUnion {
+	if m != nil {
+		return m.OneofUnion
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalBool() bool {
+	if m != nil {
+		return m.OptionalBool
+	}
+	return false
+}
+
+func (m *Message) GetOptionalInt32() int32 {
+	if m != nil {
+		return m.OptionalInt32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSint32() int32 {
+	if m != nil {
+		return m.OptionalSint32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalUint32() uint32 {
+	if m != nil {
+		return m.OptionalUint32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalInt64() int64 {
+	if m != nil {
+		return m.OptionalInt64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSint64() int64 {
+	if m != nil {
+		return m.OptionalSint64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalUint64() uint64 {
+	if m != nil {
+		return m.OptionalUint64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalFixed32() uint32 {
+	if m != nil {
+		return m.OptionalFixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSfixed32() int32 {
+	if m != nil {
+		return m.OptionalSfixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalFloat() float32 {
+	if m != nil {
+		return m.OptionalFloat
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalFixed64() uint64 {
+	if m != nil {
+		return m.OptionalFixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSfixed64() int64 {
+	if m != nil {
+		return m.OptionalSfixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalDouble() float64 {
+	if m != nil {
+		return m.OptionalDouble
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalString() string {
+	if m != nil {
+		return m.OptionalString
+	}
+	return ""
+}
+
+func (m *Message) GetOptionalBytes() []byte {
+	if m != nil {
+		return m.OptionalBytes
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalChildEnum() Message_ChildEnum {
+	if m != nil {
+		return m.OptionalChildEnum
+	}
+	return Message_ALPHA
+}
+
+func (m *Message) GetOptionalChildMessage() *Message_ChildMessage {
+	if m != nil {
+		return m.OptionalChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalSiblingEnum() SiblingEnum {
+	if m != nil {
+		return m.OptionalSiblingEnum
+	}
+	return SiblingEnum_ALPHA
+}
+
+func (m *Message) GetOptionalSiblingMessage() *SiblingMessage {
+	if m != nil {
+		return m.OptionalSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedBool() []bool {
+	if m != nil {
+		return m.RepeatedBool
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedInt32() []int32 {
+	if m != nil {
+		return m.RepeatedInt32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSint32() []int32 {
+	if m != nil {
+		return m.RepeatedSint32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedUint32() []uint32 {
+	if m != nil {
+		return m.RepeatedUint32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedInt64() []int64 {
+	if m != nil {
+		return m.RepeatedInt64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSint64() []int64 {
+	if m != nil {
+		return m.RepeatedSint64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedUint64() []uint64 {
+	if m != nil {
+		return m.RepeatedUint64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedFixed32() []uint32 {
+	if m != nil {
+		return m.RepeatedFixed32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSfixed32() []int32 {
+	if m != nil {
+		return m.RepeatedSfixed32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedFloat() []float32 {
+	if m != nil {
+		return m.RepeatedFloat
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedFixed64() []uint64 {
+	if m != nil {
+		return m.RepeatedFixed64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSfixed64() []int64 {
+	if m != nil {
+		return m.RepeatedSfixed64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedDouble() []float64 {
+	if m != nil {
+		return m.RepeatedDouble
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedString() []string {
+	if m != nil {
+		return m.RepeatedString
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedBytes() [][]byte {
+	if m != nil {
+		return m.RepeatedBytes
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedChildEnum() []Message_ChildEnum {
+	if m != nil {
+		return m.RepeatedChildEnum
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedChildMessage() []*Message_ChildMessage {
+	if m != nil {
+		return m.RepeatedChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSiblingEnum() []SiblingEnum {
+	if m != nil {
+		return m.RepeatedSiblingEnum
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSiblingMessage() []*SiblingMessage {
+	if m != nil {
+		return m.RepeatedSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolBool() map[bool]bool {
+	if m != nil {
+		return m.MapBoolBool
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolInt32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolInt32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSint32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolSint32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolUint32() map[bool]uint32 {
+	if m != nil {
+		return m.MapBoolUint32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolInt64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolInt64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSint64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolSint64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolUint64() map[bool]uint64 {
+	if m != nil {
+		return m.MapBoolUint64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFixed32() map[bool]uint32 {
+	if m != nil {
+		return m.MapBoolFixed32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSfixed32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolSfixed32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFloat() map[bool]float32 {
+	if m != nil {
+		return m.MapBoolFloat
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFixed64() map[bool]uint64 {
+	if m != nil {
+		return m.MapBoolFixed64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSfixed64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolSfixed64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolDouble() map[bool]float64 {
+	if m != nil {
+		return m.MapBoolDouble
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolString() map[bool]string {
+	if m != nil {
+		return m.MapBoolString
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolBytes() map[bool][]byte {
+	if m != nil {
+		return m.MapBoolBytes
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolChildEnum() map[bool]Message_ChildEnum {
+	if m != nil {
+		return m.MapBoolChildEnum
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolChildMessage() map[bool]*Message_ChildMessage {
+	if m != nil {
+		return m.MapBoolChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSiblingEnum() map[bool]SiblingEnum {
+	if m != nil {
+		return m.MapBoolSiblingEnum
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSiblingMessage() map[bool]*SiblingMessage {
+	if m != nil {
+		return m.MapBoolSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetMapInt32Bool() map[int32]bool {
+	if m != nil {
+		return m.MapInt32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapSint32Bool() map[int32]bool {
+	if m != nil {
+		return m.MapSint32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapUint32Bool() map[uint32]bool {
+	if m != nil {
+		return m.MapUint32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapInt64Bool() map[int64]bool {
+	if m != nil {
+		return m.MapInt64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapSint64Bool() map[int64]bool {
+	if m != nil {
+		return m.MapSint64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapUint64Bool() map[uint64]bool {
+	if m != nil {
+		return m.MapUint64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapFixed32Bool() map[uint32]bool {
+	if m != nil {
+		return m.MapFixed32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapStringBool() map[string]bool {
+	if m != nil {
+		return m.MapStringBool
+	}
+	return nil
+}
+
+func (m *Message) GetOneofBool() bool {
+	if x, ok := m.GetOneofUnion().(*Message_OneofBool); ok {
+		return x.OneofBool
+	}
+	return false
+}
+
+func (m *Message) GetOneofInt32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofInt32); ok {
+		return x.OneofInt32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSint32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSint32); ok {
+		return x.OneofSint32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofUint32() uint32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofUint32); ok {
+		return x.OneofUint32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofInt64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofInt64); ok {
+		return x.OneofInt64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSint64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSint64); ok {
+		return x.OneofSint64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofUint64() uint64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofUint64); ok {
+		return x.OneofUint64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFixed32() uint32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFixed32); ok {
+		return x.OneofFixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSfixed32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSfixed32); ok {
+		return x.OneofSfixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFloat() float32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFloat); ok {
+		return x.OneofFloat
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFixed64() uint64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFixed64); ok {
+		return x.OneofFixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSfixed64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSfixed64); ok {
+		return x.OneofSfixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofDouble() float64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofDouble); ok {
+		return x.OneofDouble
+	}
+	return 0
+}
+
+func (m *Message) GetOneofString() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString); ok {
+		return x.OneofString
+	}
+	return ""
+}
+
+func (m *Message) GetOneofBytes() []byte {
+	if x, ok := m.GetOneofUnion().(*Message_OneofBytes); ok {
+		return x.OneofBytes
+	}
+	return nil
+}
+
+func (m *Message) GetOneofChildEnum() Message_ChildEnum {
+	if x, ok := m.GetOneofUnion().(*Message_OneofChildEnum); ok {
+		return x.OneofChildEnum
+	}
+	return Message_ALPHA
+}
+
+func (m *Message) GetOneofChildMessage() *Message_ChildMessage {
+	if x, ok := m.GetOneofUnion().(*Message_OneofChildMessage); ok {
+		return x.OneofChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOneofSiblingEnum() SiblingEnum {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSiblingEnum); ok {
+		return x.OneofSiblingEnum
+	}
+	return SiblingEnum_ALPHA
+}
+
+func (m *Message) GetOneofSiblingMessage() *SiblingMessage {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSiblingMessage); ok {
+		return x.OneofSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOneofString1() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString1); ok {
+		return x.OneofString1
+	}
+	return ""
+}
+
+func (m *Message) GetOneofString2() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString2); ok {
+		return x.OneofString2
+	}
+	return ""
+}
+
+func (m *Message) GetOneofString3() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString3); ok {
+		return x.OneofString3
+	}
+	return ""
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*Message) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+	return _Message_OneofMarshaler, _Message_OneofUnmarshaler, _Message_OneofSizer, []interface{}{
+		(*Message_OneofBool)(nil),
+		(*Message_OneofInt32)(nil),
+		(*Message_OneofSint32)(nil),
+		(*Message_OneofUint32)(nil),
+		(*Message_OneofInt64)(nil),
+		(*Message_OneofSint64)(nil),
+		(*Message_OneofUint64)(nil),
+		(*Message_OneofFixed32)(nil),
+		(*Message_OneofSfixed32)(nil),
+		(*Message_OneofFloat)(nil),
+		(*Message_OneofFixed64)(nil),
+		(*Message_OneofSfixed64)(nil),
+		(*Message_OneofDouble)(nil),
+		(*Message_OneofString)(nil),
+		(*Message_OneofBytes)(nil),
+		(*Message_OneofChildEnum)(nil),
+		(*Message_OneofChildMessage)(nil),
+		(*Message_OneofSiblingEnum)(nil),
+		(*Message_OneofSiblingMessage)(nil),
+		(*Message_OneofString1)(nil),
+		(*Message_OneofString2)(nil),
+		(*Message_OneofString3)(nil),
+	}
+}
+
+func _Message_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*Message)
+	// oneof_union
+	switch x := m.OneofUnion.(type) {
+	case *Message_OneofBool:
+		t := uint64(0)
+		if x.OneofBool {
+			t = 1
+		}
+		b.EncodeVarint(400<<3 | proto.WireVarint)
+		b.EncodeVarint(t)
+	case *Message_OneofInt32:
+		b.EncodeVarint(401<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofInt32))
+	case *Message_OneofSint32:
+		b.EncodeVarint(402<<3 | proto.WireVarint)
+		b.EncodeZigzag32(uint64(x.OneofSint32))
+	case *Message_OneofUint32:
+		b.EncodeVarint(403<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofUint32))
+	case *Message_OneofInt64:
+		b.EncodeVarint(404<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofInt64))
+	case *Message_OneofSint64:
+		b.EncodeVarint(405<<3 | proto.WireVarint)
+		b.EncodeZigzag64(uint64(x.OneofSint64))
+	case *Message_OneofUint64:
+		b.EncodeVarint(406<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofUint64))
+	case *Message_OneofFixed32:
+		b.EncodeVarint(407<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(x.OneofFixed32))
+	case *Message_OneofSfixed32:
+		b.EncodeVarint(408<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(x.OneofSfixed32))
+	case *Message_OneofFloat:
+		b.EncodeVarint(409<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(math.Float32bits(x.OneofFloat)))
+	case *Message_OneofFixed64:
+		b.EncodeVarint(410<<3 | proto.WireFixed64)
+		b.EncodeFixed64(uint64(x.OneofFixed64))
+	case *Message_OneofSfixed64:
+		b.EncodeVarint(411<<3 | proto.WireFixed64)
+		b.EncodeFixed64(uint64(x.OneofSfixed64))
+	case *Message_OneofDouble:
+		b.EncodeVarint(412<<3 | proto.WireFixed64)
+		b.EncodeFixed64(math.Float64bits(x.OneofDouble))
+	case *Message_OneofString:
+		b.EncodeVarint(413<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString)
+	case *Message_OneofBytes:
+		b.EncodeVarint(414<<3 | proto.WireBytes)
+		b.EncodeRawBytes(x.OneofBytes)
+	case *Message_OneofChildEnum:
+		b.EncodeVarint(415<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofChildEnum))
+	case *Message_OneofChildMessage:
+		b.EncodeVarint(416<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.OneofChildMessage); err != nil {
+			return err
+		}
+	case *Message_OneofSiblingEnum:
+		b.EncodeVarint(417<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofSiblingEnum))
+	case *Message_OneofSiblingMessage:
+		b.EncodeVarint(418<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.OneofSiblingMessage); err != nil {
+			return err
+		}
+	case *Message_OneofString1:
+		b.EncodeVarint(419<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString1)
+	case *Message_OneofString2:
+		b.EncodeVarint(420<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString2)
+	case *Message_OneofString3:
+		b.EncodeVarint(421<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString3)
+	case nil:
+	default:
+		return fmt.Errorf("Message.OneofUnion has unexpected type %T", x)
+	}
+	return nil
+}
+
+func _Message_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*Message)
+	switch tag {
+	case 400: // oneof_union.oneof_bool
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofBool{x != 0}
+		return true, err
+	case 401: // oneof_union.oneof_int32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofInt32{int32(x)}
+		return true, err
+	case 402: // oneof_union.oneof_sint32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeZigzag32()
+		m.OneofUnion = &Message_OneofSint32{int32(x)}
+		return true, err
+	case 403: // oneof_union.oneof_uint32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofUint32{uint32(x)}
+		return true, err
+	case 404: // oneof_union.oneof_int64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofInt64{int64(x)}
+		return true, err
+	case 405: // oneof_union.oneof_sint64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeZigzag64()
+		m.OneofUnion = &Message_OneofSint64{int64(x)}
+		return true, err
+	case 406: // oneof_union.oneof_uint64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofUint64{x}
+		return true, err
+	case 407: // oneof_union.oneof_fixed32
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofUnion = &Message_OneofFixed32{uint32(x)}
+		return true, err
+	case 408: // oneof_union.oneof_sfixed32
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofUnion = &Message_OneofSfixed32{int32(x)}
+		return true, err
+	case 409: // oneof_union.oneof_float
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofUnion = &Message_OneofFloat{math.Float32frombits(uint32(x))}
+		return true, err
+	case 410: // oneof_union.oneof_fixed64
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofUnion = &Message_OneofFixed64{x}
+		return true, err
+	case 411: // oneof_union.oneof_sfixed64
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofUnion = &Message_OneofSfixed64{int64(x)}
+		return true, err
+	case 412: // oneof_union.oneof_double
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofUnion = &Message_OneofDouble{math.Float64frombits(x)}
+		return true, err
+	case 413: // oneof_union.oneof_string
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString{x}
+		return true, err
+	case 414: // oneof_union.oneof_bytes
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeRawBytes(true)
+		m.OneofUnion = &Message_OneofBytes{x}
+		return true, err
+	case 415: // oneof_union.oneof_child_enum
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofChildEnum{Message_ChildEnum(x)}
+		return true, err
+	case 416: // oneof_union.oneof_child_message
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(Message_ChildMessage)
+		err := b.DecodeMessage(msg)
+		m.OneofUnion = &Message_OneofChildMessage{msg}
+		return true, err
+	case 417: // oneof_union.oneof_sibling_enum
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofSiblingEnum{SiblingEnum(x)}
+		return true, err
+	case 418: // oneof_union.oneof_sibling_message
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(SiblingMessage)
+		err := b.DecodeMessage(msg)
+		m.OneofUnion = &Message_OneofSiblingMessage{msg}
+		return true, err
+	case 419: // oneof_union.oneof_string1
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString1{x}
+		return true, err
+	case 420: // oneof_union.oneof_string2
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString2{x}
+		return true, err
+	case 421: // oneof_union.oneof_string3
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString3{x}
+		return true, err
+	default:
+		return false, nil
+	}
+}
+
+func _Message_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*Message)
+	// oneof_union
+	switch x := m.OneofUnion.(type) {
+	case *Message_OneofBool:
+		n += 2 // tag and wire
+		n += 1
+	case *Message_OneofInt32:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofInt32))
+	case *Message_OneofSint32:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64((uint32(x.OneofSint32) << 1) ^ uint32((int32(x.OneofSint32) >> 31))))
+	case *Message_OneofUint32:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofUint32))
+	case *Message_OneofInt64:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofInt64))
+	case *Message_OneofSint64:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(uint64(x.OneofSint64<<1) ^ uint64((int64(x.OneofSint64) >> 63))))
+	case *Message_OneofUint64:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofUint64))
+	case *Message_OneofFixed32:
+		n += 2 // tag and wire
+		n += 4
+	case *Message_OneofSfixed32:
+		n += 2 // tag and wire
+		n += 4
+	case *Message_OneofFloat:
+		n += 2 // tag and wire
+		n += 4
+	case *Message_OneofFixed64:
+		n += 2 // tag and wire
+		n += 8
+	case *Message_OneofSfixed64:
+		n += 2 // tag and wire
+		n += 8
+	case *Message_OneofDouble:
+		n += 2 // tag and wire
+		n += 8
+	case *Message_OneofString:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(len(x.OneofString)))
+		n += len(x.OneofString)
+	case *Message_OneofBytes:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(len(x.OneofBytes)))
+		n += len(x.OneofBytes)
+	case *Message_OneofChildEnum:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofChildEnum))
+	case *Message_OneofChildMessage:
+		s := proto.Size(x.OneofChildMessage)
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *Message_OneofSiblingEnum:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofSiblingEnum))
+	case *Message_OneofSiblingMessage:
+		s := proto.Size(x.OneofSiblingMessage)
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *Message_OneofString1:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(len(x.OneofString1)))
+		n += len(x.OneofString1)
+	case *Message_OneofString2:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(len(x.OneofString2)))
+		n += len(x.OneofString2)
+	case *Message_OneofString3:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(len(x.OneofString3)))
+		n += len(x.OneofString3)
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	return n
+}
+
+type Message_ChildMessage struct {
+	F1                   string   `protobuf:"bytes,1,opt,name=f1" json:"f1,omitempty"`
+	F2                   []string `protobuf:"bytes,2,rep,name=f2" json:"f2,omitempty"`
+	F3                   *Message `protobuf:"bytes,3,opt,name=f3" json:"f3,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Message_ChildMessage) Reset()         { *m = Message_ChildMessage{} }
+func (m *Message_ChildMessage) String() string { return proto.CompactTextString(m) }
+func (*Message_ChildMessage) ProtoMessage()    {}
+func (*Message_ChildMessage) Descriptor() ([]byte, []int) {
+	return fileDescriptor_test_b39f8dbfc888d45a, []int{1, 0}
+}
+func (m *Message_ChildMessage) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Message_ChildMessage.Unmarshal(m, b)
+}
+func (m *Message_ChildMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Message_ChildMessage.Marshal(b, m, deterministic)
+}
+func (dst *Message_ChildMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Message_ChildMessage.Merge(dst, src)
+}
+func (m *Message_ChildMessage) XXX_Size() int {
+	return xxx_messageInfo_Message_ChildMessage.Size(m)
+}
+func (m *Message_ChildMessage) XXX_DiscardUnknown() {
+	xxx_messageInfo_Message_ChildMessage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message_ChildMessage proto.InternalMessageInfo
+
+func (m *Message_ChildMessage) GetF1() string {
+	if m != nil {
+		return m.F1
+	}
+	return ""
+}
+
+func (m *Message_ChildMessage) GetF2() []string {
+	if m != nil {
+		return m.F2
+	}
+	return nil
+}
+
+func (m *Message_ChildMessage) GetF3() *Message {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*SiblingMessage)(nil), "google.golang.org.proto3_20180430.SiblingMessage")
+	proto.RegisterType((*Message)(nil), "google.golang.org.proto3_20180430.Message")
+	proto.RegisterMapType((map[bool]bool)(nil), "google.golang.org.proto3_20180430.Message.MapBoolBoolEntry")
+	proto.RegisterMapType((map[bool][]byte)(nil), "google.golang.org.proto3_20180430.Message.MapBoolBytesEntry")
+	proto.RegisterMapType((map[bool]Message_ChildEnum)(nil), "google.golang.org.proto3_20180430.Message.MapBoolChildEnumEntry")
+	proto.RegisterMapType((map[bool]*Message_ChildMessage)(nil), "google.golang.org.proto3_20180430.Message.MapBoolChildMessageEntry")
+	proto.RegisterMapType((map[bool]float64)(nil), "google.golang.org.proto3_20180430.Message.MapBoolDoubleEntry")
+	proto.RegisterMapType((map[bool]uint32)(nil), "google.golang.org.proto3_20180430.Message.MapBoolFixed32Entry")
+	proto.RegisterMapType((map[bool]uint64)(nil), "google.golang.org.proto3_20180430.Message.MapBoolFixed64Entry")
+	proto.RegisterMapType((map[bool]float32)(nil), "google.golang.org.proto3_20180430.Message.MapBoolFloatEntry")
+	proto.RegisterMapType((map[bool]int32)(nil), "google.golang.org.proto3_20180430.Message.MapBoolInt32Entry")
+	proto.RegisterMapType((map[bool]int64)(nil), "google.golang.org.proto3_20180430.Message.MapBoolInt64Entry")
+	proto.RegisterMapType((map[bool]int32)(nil), "google.golang.org.proto3_20180430.Message.MapBoolSfixed32Entry")
+	proto.RegisterMapType((map[bool]int64)(nil), "google.golang.org.proto3_20180430.Message.MapBoolSfixed64Entry")
+	proto.RegisterMapType((map[bool]SiblingEnum)(nil), "google.golang.org.proto3_20180430.Message.MapBoolSiblingEnumEntry")
+	proto.RegisterMapType((map[bool]*SiblingMessage)(nil), "google.golang.org.proto3_20180430.Message.MapBoolSiblingMessageEntry")
+	proto.RegisterMapType((map[bool]int32)(nil), "google.golang.org.proto3_20180430.Message.MapBoolSint32Entry")
+	proto.RegisterMapType((map[bool]int64)(nil), "google.golang.org.proto3_20180430.Message.MapBoolSint64Entry")
+	proto.RegisterMapType((map[bool]string)(nil), "google.golang.org.proto3_20180430.Message.MapBoolStringEntry")
+	proto.RegisterMapType((map[bool]uint32)(nil), "google.golang.org.proto3_20180430.Message.MapBoolUint32Entry")
+	proto.RegisterMapType((map[bool]uint64)(nil), "google.golang.org.proto3_20180430.Message.MapBoolUint64Entry")
+	proto.RegisterMapType((map[uint32]bool)(nil), "google.golang.org.proto3_20180430.Message.MapFixed32BoolEntry")
+	proto.RegisterMapType((map[int32]bool)(nil), "google.golang.org.proto3_20180430.Message.MapInt32BoolEntry")
+	proto.RegisterMapType((map[int64]bool)(nil), "google.golang.org.proto3_20180430.Message.MapInt64BoolEntry")
+	proto.RegisterMapType((map[int32]bool)(nil), "google.golang.org.proto3_20180430.Message.MapSint32BoolEntry")
+	proto.RegisterMapType((map[int64]bool)(nil), "google.golang.org.proto3_20180430.Message.MapSint64BoolEntry")
+	proto.RegisterMapType((map[string]bool)(nil), "google.golang.org.proto3_20180430.Message.MapStringBoolEntry")
+	proto.RegisterMapType((map[uint32]bool)(nil), "google.golang.org.proto3_20180430.Message.MapUint32BoolEntry")
+	proto.RegisterMapType((map[uint64]bool)(nil), "google.golang.org.proto3_20180430.Message.MapUint64BoolEntry")
+	proto.RegisterType((*Message_ChildMessage)(nil), "google.golang.org.proto3_20180430.Message.ChildMessage")
+	proto.RegisterEnum("google.golang.org.proto3_20180430.SiblingEnum", SiblingEnum_name, SiblingEnum_value)
+	proto.RegisterEnum("google.golang.org.proto3_20180430.Message_ChildEnum", Message_ChildEnum_name, Message_ChildEnum_value)
+}
+
+func init() {
+	proto.RegisterFile("proto3_20180430_b4deda09/test.proto", fileDescriptor_test_b39f8dbfc888d45a)
+}
+
+var fileDescriptor_test_b39f8dbfc888d45a = []byte{
+	// 1946 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x9a, 0x57, 0x73, 0xdb, 0xca,
+	0x15, 0xc7, 0x09, 0x52, 0xc5, 0x5a, 0xb1, 0x82, 0x96, 0xb2, 0xa3, 0x27, 0x44, 0x76, 0x1c, 0xc4,
+	0xc9, 0x50, 0x12, 0xb9, 0x83, 0x38, 0x4e, 0x62, 0x5b, 0xb2, 0xe5, 0xd0, 0x19, 0x3b, 0xf1, 0xc0,
+	0xa3, 0x3c, 0xe4, 0x45, 0x21, 0x45, 0x90, 0xa6, 0x0d, 0x12, 0x8a, 0x48, 0x7a, 0xa2, 0xc9, 0x83,
+	0xbf, 0x42, 0x7a, 0xef, 0xe5, 0x2d, 0xbd, 0xf7, 0xee, 0x8c, 0xd3, 0xcb, 0xed, 0xf7, 0xd3, 0xdc,
+	0x59, 0x1c, 0x6c, 0x03, 0x40, 0x93, 0x04, 0xe7, 0x3e, 0x78, 0x46, 0x3a, 0xfc, 0xef, 0xf9, 0xf1,
+	0x1c, 0x9c, 0x3d, 0x67, 0x17, 0x16, 0x3a, 0x77, 0x7c, 0xe2, 0x0d, 0xbd, 0xda, 0x61, 0x75, 0x7b,
+	0xe7, 0xd2, 0x36, 0xa9, 0x6d, 0x1f, 0x36, 0x49, 0xcb, 0x69, 0x35, 0xb6, 0xdf, 0xb1, 0x35, 0x74,
+	0x06, 0xc3, 0x8a, 0xff, 0xa9, 0xfe, 0xc6, 0x8e, 0xe7, 0x75, 0x5c, 0xa7, 0xd2, 0xf1, 0xdc, 0x46,
+	0xbf, 0x53, 0xf1, 0x4e, 0x3a, 0x95, 0xd0, 0xb2, 0x4d, 0x17, 0xe5, 0xef, 0x75, 0x9b, 0x6e, 0xb7,
+	0xdf, 0xb9, 0xe3, 0x0c, 0x06, 0x8d, 0x8e, 0xa3, 0xe7, 0x51, 0xba, 0xbd, 0x83, 0x35, 0x43, 0x33,
+	0x57, 0xec, 0x74, 0x7b, 0xc7, 0xff, 0xbd, 0x8a, 0xd3, 0x46, 0xc6, 0xff, 0xbd, 0xaa, 0x5f, 0x46,
+	0xe9, 0x76, 0x0d, 0x67, 0x0c, 0xcd, 0x5c, 0xad, 0x5e, 0xac, 0x4c, 0x24, 0x54, 0x02, 0xbf, 0x76,
+	0xba, 0x5d, 0xdb, 0x7c, 0x72, 0x0d, 0x2d, 0x33, 0xce, 0x39, 0x94, 0xf3, 0x8e, 0x87, 0x5d, 0xaf,
+	0xdf, 0x70, 0x0f, 0x9b, 0x9e, 0xe7, 0xe2, 0x96, 0xa1, 0x99, 0x67, 0xec, 0x2c, 0x33, 0xee, 0x79,
+	0x9e, 0xab, 0xbf, 0x09, 0xe5, 0xb9, 0xa8, 0xdb, 0x1f, 0xd6, 0xaa, 0xd8, 0x31, 0x34, 0x73, 0xd1,
+	0xe6, 0x4b, 0x6f, 0x51, 0xa3, 0xfe, 0x66, 0x54, 0xe0, 0xb2, 0x01, 0xe8, 0xda, 0x86, 0x66, 0x96,
+	0x6c, 0xbe, 0xfa, 0x5e, 0x37, 0x22, 0x1c, 0x81, 0xb0, 0x63, 0x68, 0x66, 0x4e, 0x08, 0x0f, 0x40,
+	0x18, 0x02, 0x5b, 0x04, 0xdf, 0x37, 0x34, 0x33, 0xa3, 0x80, 0x2d, 0x12, 0x01, 0x5b, 0x04, 0x77,
+	0x0d, 0xcd, 0xd4, 0x55, 0x70, 0x48, 0x38, 0x02, 0xe1, 0x03, 0x43, 0x33, 0x17, 0x54, 0xb0, 0x45,
+	0xf4, 0xb7, 0xa0, 0x22, 0x17, 0xb6, 0xbb, 0x1f, 0x71, 0x5a, 0xb5, 0x2a, 0x7e, 0x68, 0x68, 0xe6,
+	0xb2, 0xcd, 0x1d, 0xdc, 0x04, 0xb3, 0xfe, 0x56, 0x54, 0x12, 0x70, 0xa6, 0x75, 0x0d, 0xcd, 0x2c,
+	0xd8, 0xdc, 0xc7, 0xbd, 0xc0, 0xae, 0x04, 0xd4, 0x76, 0xbd, 0xc6, 0x10, 0xf7, 0x0c, 0xcd, 0x4c,
+	0x8b, 0x80, 0x6e, 0x52, 0x63, 0x14, 0x6f, 0x11, 0xdc, 0x37, 0x34, 0x73, 0x29, 0x84, 0xb7, 0x48,
+	0x0c, 0xde, 0x22, 0xd8, 0x33, 0x34, 0xb3, 0x18, 0xc6, 0x87, 0xe2, 0x6f, 0x79, 0xa3, 0xa6, 0xeb,
+	0xe0, 0x63, 0x43, 0x33, 0x35, 0x11, 0xff, 0x0d, 0xdf, 0xaa, 0x66, 0x74, 0x78, 0xd2, 0xed, 0x77,
+	0xf0, 0x87, 0xfd, 0x5a, 0x14, 0x19, 0xf5, 0xad, 0x4a, 0x40, 0xcd, 0xd3, 0xa1, 0x33, 0xc0, 0x27,
+	0x86, 0x66, 0x66, 0x45, 0x40, 0x7b, 0xd4, 0xa8, 0xb7, 0x50, 0x99, 0xcb, 0x8e, 0xee, 0x77, 0xdd,
+	0xd6, 0xa1, 0xd3, 0x1f, 0xf5, 0xf0, 0xc0, 0xd0, 0xcc, 0x7c, 0x95, 0x4c, 0x5f, 0xbf, 0x95, 0xeb,
+	0x74, 0xf1, 0x7e, 0x7f, 0xd4, 0xb3, 0x79, 0xd8, 0xdc, 0xa4, 0xf7, 0xd0, 0x7a, 0x88, 0xd2, 0x83,
+	0x65, 0x78, 0xe8, 0x6f, 0x94, 0xb7, 0xcf, 0x0a, 0x62, 0xbb, 0xe6, 0xac, 0xc2, 0x62, 0x7b, 0xa7,
+	0x89, 0xd6, 0xa4, 0xb2, 0xf3, 0xb7, 0x2f, 0x84, 0x35, 0xf2, 0xc3, 0xaa, 0x4c, 0x41, 0x0b, 0x76,
+	0xbd, 0x1f, 0x50, 0x59, 0x14, 0x2b, 0x37, 0xea, 0x0f, 0x11, 0x8e, 0x30, 0x58, 0x50, 0x8f, 0xfc,
+	0xa0, 0x76, 0xa6, 0xc7, 0xb0, 0x70, 0xd6, 0x43, 0x24, 0x16, 0xd0, 0x79, 0x94, 0x3b, 0x71, 0x8e,
+	0x9d, 0xc6, 0xd0, 0x69, 0x41, 0x33, 0x78, 0xaa, 0x19, 0x19, 0xda, 0x0d, 0x98, 0xd5, 0xef, 0x06,
+	0x17, 0x50, 0x9e, 0xab, 0x60, 0xf3, 0xfe, 0x8d, 0xca, 0x16, 0x6d, 0xbe, 0x18, 0xda, 0x81, 0x89,
+	0x0a, 0x5c, 0x17, 0xb4, 0x83, 0xbf, 0x53, 0x61, 0xc9, 0xe6, 0xeb, 0x83, 0x7e, 0x20, 0x2b, 0x83,
+	0x7e, 0xf0, 0x0f, 0xaa, 0xcc, 0x09, 0x65, 0xd0, 0x10, 0x42, 0x6c, 0x8b, 0xe0, 0x7f, 0x52, 0x61,
+	0x46, 0x61, 0x5b, 0x24, 0xc2, 0xb6, 0x08, 0xfe, 0x17, 0x15, 0xea, 0x2a, 0x3b, 0xa4, 0x0c, 0x5a,
+	0xc2, 0xbf, 0xa9, 0x72, 0x41, 0x65, 0x5b, 0x44, 0xbf, 0x88, 0x8a, 0x5c, 0xc9, 0xf6, 0xf9, 0x7f,
+	0xa8, 0x74, 0xd9, 0xe6, 0x2e, 0x58, 0x53, 0x78, 0x1b, 0x2a, 0x09, 0x3e, 0x13, 0xff, 0x97, 0x8a,
+	0x0b, 0x36, 0xf7, 0xc2, 0xbb, 0x82, 0x1c, 0x15, 0x74, 0x85, 0xff, 0x51, 0x69, 0x5a, 0x44, 0x05,
+	0x6d, 0x21, 0xf2, 0x0d, 0x2c, 0x82, 0xff, 0x4f, 0x95, 0x4b, 0xa1, 0x6f, 0x60, 0x91, 0x98, 0x6f,
+	0x60, 0x11, 0xfc, 0x1c, 0x15, 0x17, 0xc3, 0xdf, 0x20, 0x94, 0x85, 0xa0, 0x31, 0x3c, 0x4f, 0xb5,
+	0x9a, 0xc8, 0x42, 0xd0, 0x19, 0x94, 0xcc, 0x42, 0x67, 0x78, 0x41, 0xf3, 0xc7, 0x92, 0xc8, 0x2c,
+	0xb4, 0x06, 0x39, 0x2a, 0x68, 0x0d, 0x2f, 0x52, 0x61, 0x56, 0x44, 0x05, 0xbd, 0xc1, 0x41, 0x65,
+	0xae, 0x93, 0x7a, 0xc3, 0x4b, 0x54, 0x9c, 0xb8, 0x39, 0x30, 0x8f, 0xa2, 0x39, 0xf4, 0xd1, 0x7a,
+	0x08, 0xc3, 0xf6, 0xd1, 0xcb, 0x94, 0x34, 0x4f, 0x77, 0x50, 0x60, 0x6c, 0x33, 0x1d, 0xa1, 0x35,
+	0xa9, 0x04, 0xa5, 0xee, 0xf0, 0x0a, 0x04, 0x36, 0x73, 0x7b, 0x10, 0x85, 0x2b, 0xda, 0x83, 0x8b,
+	0x70, 0x04, 0xc2, 0xc2, 0x7a, 0x15, 0xc2, 0x4a, 0xd2, 0x1f, 0x42, 0x28, 0x16, 0xd2, 0x87, 0x50,
+	0xae, 0xd7, 0x38, 0xf6, 0x5b, 0x03, 0xf4, 0x87, 0xef, 0xa4, 0x7d, 0xc4, 0x3b, 0x67, 0xc8, 0xdc,
+	0x9d, 0xc6, 0x31, 0xed, 0x22, 0xf4, 0xdf, 0x7e, 0x7f, 0x78, 0x72, 0x6a, 0xaf, 0xf6, 0x84, 0x45,
+	0x3f, 0x42, 0x79, 0x4e, 0x80, 0x46, 0xf0, 0x5d, 0x40, 0xbc, 0x6b, 0x76, 0x84, 0xdf, 0x85, 0x80,
+	0x91, 0xed, 0x49, 0x26, 0xbd, 0x8d, 0x0a, 0x1c, 0x12, 0x34, 0xa6, 0xef, 0x01, 0xe5, 0xdd, 0xb3,
+	0x53, 0xa0, 0x85, 0x01, 0x26, 0xd7, 0x93, 0x6d, 0x0a, 0x27, 0x68, 0x6b, 0xdf, 0x4f, 0xcc, 0x39,
+	0x88, 0xe1, 0x04, 0x4d, 0x31, 0x94, 0x34, 0x8b, 0xe0, 0x1f, 0xcc, 0x93, 0x34, 0x8b, 0x44, 0x92,
+	0x66, 0x91, 0x48, 0xd2, 0x2c, 0x82, 0x7f, 0x38, 0x57, 0xd2, 0x18, 0x46, 0x4e, 0x5a, 0x88, 0x13,
+	0xf4, 0xe3, 0x1f, 0xcd, 0x95, 0xb4, 0x30, 0x27, 0xe8, 0xe6, 0x5d, 0x54, 0xe4, 0x1c, 0xd6, 0xa0,
+	0x7f, 0x0c, 0xa0, 0x2b, 0xb3, 0x83, 0x82, 0xbe, 0x0f, 0xa4, 0x7c, 0x4f, 0x31, 0xea, 0x2e, 0x2a,
+	0x89, 0xd4, 0x31, 0xd6, 0x4f, 0x80, 0x75, 0x35, 0x41, 0xf2, 0xda, 0x32, 0xac, 0xd0, 0x53, 0xad,
+	0x4a, 0x35, 0xc0, 0x30, 0xf9, 0x69, 0xe2, 0x6a, 0xf0, 0xc7, 0x8e, 0x5a, 0x0d, 0x30, 0x89, 0x22,
+	0xd9, 0xb3, 0x08, 0xfe, 0xd9, 0x7c, 0xd9, 0x63, 0xcf, 0x49, 0xc9, 0x9e, 0x45, 0x62, 0xb2, 0x67,
+	0x11, 0xfc, 0xf3, 0x39, 0xb3, 0xc7, 0x60, 0x6a, 0xf6, 0x42, 0xe5, 0x17, 0x0c, 0xc2, 0x5f, 0x24,
+	0x2e, 0x3f, 0x18, 0x99, 0x6a, 0xf9, 0x05, 0x63, 0x54, 0xd9, 0x4e, 0x30, 0x46, 0x7f, 0x99, 0x7c,
+	0x3b, 0xf9, 0x0e, 0x42, 0xdb, 0x09, 0x86, 0xb0, 0x5c, 0x0d, 0x30, 0x84, 0x7f, 0x95, 0xb8, 0x1a,
+	0xfc, 0x71, 0xad, 0x56, 0x03, 0x4c, 0xf0, 0x63, 0x54, 0xe6, 0x10, 0x69, 0x82, 0xff, 0x1a, 0x48,
+	0xd7, 0x66, 0x27, 0xf1, 0xa9, 0x0d, 0xb4, 0x62, 0x2f, 0x64, 0xd6, 0x4f, 0xd1, 0x7a, 0x88, 0xc8,
+	0xa6, 0xde, 0x6f, 0x00, 0x7a, 0x3d, 0x21, 0x34, 0xb0, 0x01, 0xb7, 0xdc, 0x8b, 0x7e, 0xa2, 0x3f,
+	0x42, 0x6b, 0x52, 0x23, 0x94, 0xe6, 0xfa, 0x6f, 0x81, 0xbc, 0x97, 0xa4, 0x1d, 0xf2, 0x89, 0x0e,
+	0x60, 0xbd, 0x17, 0xf9, 0x40, 0x7f, 0x8c, 0x70, 0x84, 0xcb, 0x82, 0xfe, 0x1d, 0xa0, 0xf7, 0x13,
+	0xa3, 0x95, 0xb0, 0xd7, 0x7a, 0x71, 0x9f, 0xb1, 0x52, 0xf2, 0x67, 0x0e, 0x8c, 0xff, 0xdf, 0x27,
+	0x2a, 0x25, 0x7f, 0x08, 0x8b, 0xf9, 0x4f, 0x4b, 0x89, 0x9b, 0xd8, 0xbe, 0x18, 0x48, 0x94, 0x3f,
+	0x24, 0xda, 0x17, 0x30, 0x83, 0x05, 0x86, 0xee, 0x0b, 0x61, 0x63, 0x9c, 0x91, 0xc4, 0xf9, 0x63,
+	0x22, 0xce, 0x41, 0x0c, 0x47, 0xd8, 0xa4, 0xa4, 0x59, 0x04, 0x30, 0x7f, 0x4a, 0x9a, 0x34, 0x8b,
+	0x44, 0x92, 0x06, 0x26, 0x39, 0x69, 0x8c, 0xf2, 0xe7, 0xc4, 0x49, 0x93, 0x31, 0x2c, 0x69, 0x2a,
+	0x67, 0x24, 0x71, 0xfe, 0x92, 0x38, 0x69, 0x61, 0x8e, 0xb0, 0xb1, 0xe9, 0x12, 0x4c, 0x34, 0x00,
+	0x3d, 0x49, 0x34, 0x5d, 0x82, 0x11, 0x2c, 0x48, 0xf4, 0x69, 0x48, 0x46, 0x9e, 0x3a, 0xbf, 0x5b,
+	0x02, 0xe9, 0xaf, 0xc9, 0x52, 0xe7, 0x7b, 0x08, 0xa5, 0x8e, 0xdb, 0x74, 0x03, 0x21, 0xaf, 0xef,
+	0x78, 0x6d, 0x40, 0x7c, 0x2c, 0x63, 0x68, 0xe6, 0x99, 0x7a, 0xca, 0x5e, 0xf1, 0x8d, 0xbe, 0x62,
+	0x13, 0xad, 0x82, 0x02, 0x4e, 0x8a, 0x1f, 0xa7, 0x92, 0xc5, 0x7a, 0xca, 0x86, 0x75, 0x70, 0x72,
+	0x3d, 0x8f, 0xb2, 0xa0, 0x09, 0x8e, 0xad, 0x9f, 0xa0, 0xa2, 0x52, 0x3d, 0x65, 0xc3, 0xd2, 0xe0,
+	0xdc, 0xc9, 0x55, 0xc1, 0xa1, 0xf3, 0x93, 0x54, 0x95, 0xe3, 0xaa, 0xe0, 0xd4, 0x28, 0xf3, 0x2c,
+	0x82, 0x3f, 0x45, 0x45, 0x19, 0x99, 0x67, 0x11, 0x95, 0x67, 0x11, 0xfc, 0x69, 0x2a, 0xd2, 0x15,
+	0x9e, 0xac, 0x0a, 0xce, 0x6b, 0x9f, 0xa1, 0xaa, 0x05, 0x85, 0x67, 0x11, 0xfd, 0x02, 0xca, 0x81,
+	0x8a, 0x9d, 0x80, 0x3e, 0x4b, 0x65, 0xcb, 0xf5, 0x94, 0x0d, 0xab, 0xd9, 0x69, 0xc9, 0x44, 0xf9,
+	0x80, 0xc9, 0x84, 0x9f, 0xa3, 0xc2, 0x42, 0x3d, 0x65, 0x83, 0x03, 0x7e, 0xd2, 0xe1, 0x11, 0xc0,
+	0x31, 0xe7, 0xf3, 0x54, 0x96, 0xe6, 0x11, 0xc0, 0x41, 0x45, 0xa5, 0x5a, 0x04, 0x7f, 0x81, 0xaa,
+	0x96, 0x54, 0xaa, 0x7f, 0x01, 0x56, 0xa8, 0x16, 0xc1, 0x5f, 0xa4, 0xc2, 0x62, 0x88, 0x2a, 0x47,
+	0x1b, 0x1c, 0x0f, 0xbe, 0x44, 0x75, 0x1a, 0x8f, 0x36, 0x98, 0xef, 0x22, 0x73, 0x30, 0xdc, 0xbf,
+	0x4c, 0x55, 0x2b, 0x22, 0x73, 0x30, 0x9d, 0x79, 0x04, 0x30, 0x9a, 0xbf, 0x42, 0x45, 0x59, 0x1e,
+	0x01, 0x0c, 0xd7, 0x06, 0x2a, 0x82, 0x46, 0x9a, 0xac, 0x5f, 0xcd, 0x24, 0x7f, 0x71, 0x56, 0x4f,
+	0xd9, 0x10, 0xaa, 0x98, 0xa6, 0x0f, 0x50, 0x59, 0x46, 0xb0, 0xa9, 0xf2, 0xb5, 0xcc, 0x5c, 0x6f,
+	0xcd, 0xea, 0x29, 0xbb, 0x24, 0x40, 0x6c, 0x8a, 0x1c, 0x22, 0x9d, 0x95, 0x94, 0x34, 0x3b, 0xbf,
+	0x9e, 0x49, 0xf2, 0xca, 0xac, 0x9e, 0xb2, 0x8b, 0x41, 0x21, 0x8a, 0x39, 0x79, 0x1f, 0xad, 0xa9,
+	0x00, 0x16, 0xce, 0x37, 0x32, 0x09, 0xdf, 0x97, 0xd5, 0x53, 0x76, 0x59, 0xc6, 0xb0, 0x50, 0x78,
+	0x6d, 0xc1, 0x33, 0xde, 0xc1, 0xdf, 0x64, 0x0f, 0x39, 0x2b, 0x3d, 0xe4, 0x9d, 0xb0, 0xae, 0x8a,
+	0xbf, 0x15, 0xa7, 0xab, 0x86, 0x75, 0x35, 0xfc, 0xed, 0x38, 0x5d, 0x6d, 0xe3, 0x01, 0xca, 0x2a,
+	0x29, 0x7d, 0x1d, 0xff, 0xaf, 0x60, 0xe3, 0x0a, 0x2a, 0x86, 0x6f, 0xec, 0x7a, 0x11, 0x65, 0x1e,
+	0x3a, 0xa7, 0x3e, 0xf0, 0x8c, 0x4d, 0x7f, 0xd4, 0xcf, 0xa2, 0xc5, 0x47, 0x0d, 0x77, 0xe4, 0xe0,
+	0xb4, 0x6f, 0x83, 0x5f, 0x2e, 0xa7, 0x2f, 0x69, 0x1b, 0x57, 0x51, 0x29, 0x72, 0x1d, 0x9f, 0xe4,
+	0x60, 0x51, 0x76, 0x70, 0x0d, 0xe9, 0xd1, 0x9b, 0xf6, 0x24, 0x0f, 0xa5, 0x78, 0x0f, 0x07, 0xd3,
+	0x7b, 0xc8, 0x8d, 0x0d, 0x22, 0xb8, 0x3a, 0x4c, 0x72, 0x90, 0x19, 0x1f, 0xc4, 0x94, 0x1e, 0xf4,
+	0xf1, 0x41, 0x4c, 0xe9, 0x61, 0x41, 0xf6, 0xb0, 0x8b, 0xca, 0x31, 0x97, 0xd5, 0x49, 0x2e, 0x96,
+	0x65, 0x17, 0x7b, 0xe8, 0x6c, 0xdc, 0x1d, 0x74, 0x92, 0x8f, 0x42, 0x7c, 0x2e, 0xc5, 0xe5, 0x72,
+	0x92, 0x83, 0xf4, 0x33, 0xe2, 0x98, 0x32, 0x15, 0x4b, 0xcf, 0x8a, 0x63, 0x4a, 0x1f, 0xc5, 0xf8,
+	0x07, 0x22, 0xdd, 0xf2, 0x26, 0x79, 0xd0, 0xc6, 0x14, 0x85, 0xb8, 0xbf, 0x4d, 0xf2, 0xb0, 0x12,
+	0x9f, 0x4b, 0x71, 0x35, 0x9b, 0xe4, 0x20, 0x2b, 0x3b, 0x38, 0x45, 0x6b, 0xb1, 0x37, 0xae, 0x18,
+	0x27, 0xef, 0x95, 0x9d, 0x24, 0x7d, 0x2d, 0x2b, 0xa1, 0x1f, 0x23, 0x3c, 0xee, 0xde, 0x15, 0x43,
+	0xbf, 0x23, 0xd3, 0xe7, 0x78, 0x55, 0x2b, 0x7d, 0x81, 0x11, 0x7a, 0xc3, 0x98, 0xeb, 0x57, 0x0c,
+	0xff, 0x86, 0x1a, 0xfd, 0xac, 0xef, 0x6e, 0x25, 0xec, 0x47, 0xd1, 0xc6, 0xf8, 0xab, 0x57, 0x0c,
+	0xf9, 0x3d, 0x6a, 0xe4, 0x09, 0xde, 0xe6, 0x46, 0x0a, 0x46, 0xbd, 0x80, 0xc9, 0xcc, 0xc5, 0x49,
+	0xed, 0x1c, 0x6a, 0x36, 0x74, 0xb7, 0x92, 0x3d, 0x94, 0xa6, 0xf3, 0x70, 0x30, 0xde, 0x43, 0x6e,
+	0xba, 0x91, 0xa2, 0x5e, 0x88, 0x64, 0x07, 0x99, 0xe9, 0x83, 0x18, 0xe3, 0x41, 0x9f, 0x3e, 0x88,
+	0x31, 0x1e, 0x16, 0x26, 0x79, 0x80, 0x2e, 0x16, 0xbe, 0x9e, 0xc8, 0x2e, 0x96, 0xa7, 0x0c, 0x43,
+	0xbd, 0x77, 0xc8, 0x1e, 0x56, 0x26, 0x78, 0xd8, 0xac, 0xa0, 0x15, 0x71, 0x08, 0x5c, 0x41, 0x8b,
+	0xbb, 0xb7, 0xef, 0xd6, 0x77, 0x8b, 0x29, 0xfa, 0xe3, 0x9e, 0xbd, 0xfb, 0x81, 0xf7, 0x17, 0x35,
+	0x7d, 0x15, 0x2d, 0x5f, 0xaf, 0xef, 0xda, 0xb7, 0x6f, 0xed, 0x17, 0xd3, 0x7b, 0x39, 0x76, 0x5c,
+	0x1d, 0xf5, 0xbb, 0x5e, 0xff, 0xe2, 0x0e, 0x5a, 0x95, 0x0f, 0x5e, 0x71, 0x0e, 0x90, 0x9e, 0x15,
+	0x0e, 0x9e, 0x6a, 0x7b, 0x77, 0x3f, 0xf8, 0xbe, 0x48, 0xfd, 0x6e, 0xf9, 0xf5, 0xdb, 0x1c, 0xb5,
+	0xb7, 0xba, 0xfd, 0xa1, 0x73, 0xd2, 0x6f, 0xb8, 0xfe, 0x5f, 0x4f, 0xf8, 0xd6, 0xc1, 0x96, 0xeb,
+	0x74, 0x1a, 0x47, 0xa7, 0x5b, 0xe3, 0xfe, 0xd0, 0xa2, 0xb9, 0x04, 0x9f, 0xbc, 0x16, 0x00, 0x00,
+	0xff, 0xff, 0xc9, 0x66, 0x05, 0xd3, 0x8b, 0x21, 0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20180430_b4deda09/test.proto b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20180430_b4deda09/test.proto
new file mode 100644
index 000000000..b6a56afba
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20180430_b4deda09/test.proto
@@ -0,0 +1,136 @@
+// 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.
+
+syntax = "proto3";
+
+package google.golang.org.proto3_20180430;
+option go_package = "google.golang.org/protobuf/internal/testprotos/legacy/proto3_20180430_b4deda09";
+
+enum SiblingEnum {
+	ALPHA   = 0;
+	BRAVO   = 10;
+	CHARLIE = 200;
+}
+
+message SiblingMessage {
+	string          f1 = 1;
+	repeated string f2 = 2;
+	Message         f3 = 3;
+}
+
+message Message {
+	enum ChildEnum {
+		ALPHA   = 0;
+		BRAVO   = 1;
+		CHARLIE = 2;
+	}
+	message ChildMessage {
+		string          f1 = 1;
+		repeated string f2 = 2;
+		Message         f3 = 3;
+	}
+
+	// Optional fields.
+	bool     optional_bool     = 100;
+	int32    optional_int32    = 101;
+	sint32   optional_sint32   = 102;
+	uint32   optional_uint32   = 103;
+	int64    optional_int64    = 104;
+	sint64   optional_sint64   = 105;
+	uint64   optional_uint64   = 106;
+	fixed32  optional_fixed32  = 107;
+	sfixed32 optional_sfixed32 = 108;
+	float    optional_float    = 109;
+	fixed64  optional_fixed64  = 110;
+	sfixed64 optional_sfixed64 = 111;
+	double   optional_double   = 112;
+	string   optional_string   = 113;
+	bytes    optional_bytes    = 114;
+
+	ChildEnum      optional_child_enum      = 115;
+	ChildMessage   optional_child_message   = 116;
+	SiblingEnum    optional_sibling_enum    = 117;
+	SiblingMessage optional_sibling_message = 118;
+
+	// Repeated fields.
+	repeated bool     repeated_bool     = 200;
+	repeated int32    repeated_int32    = 201;
+	repeated sint32   repeated_sint32   = 202;
+	repeated uint32   repeated_uint32   = 203;
+	repeated int64    repeated_int64    = 204;
+	repeated sint64   repeated_sint64   = 205;
+	repeated uint64   repeated_uint64   = 206;
+	repeated fixed32  repeated_fixed32  = 207;
+	repeated sfixed32 repeated_sfixed32 = 208;
+	repeated float    repeated_float    = 209;
+	repeated fixed64  repeated_fixed64  = 210;
+	repeated sfixed64 repeated_sfixed64 = 211;
+	repeated double   repeated_double   = 212;
+	repeated string   repeated_string   = 213;
+	repeated bytes    repeated_bytes    = 214;
+
+	repeated ChildEnum      repeated_child_enum      = 215;
+	repeated ChildMessage   repeated_child_message   = 216;
+	repeated SiblingEnum    repeated_sibling_enum    = 217;
+	repeated SiblingMessage repeated_sibling_message = 218;
+
+	// Map fields.
+	map<bool, bool>     map_bool_bool     = 300;
+	map<bool, int32>    map_bool_int32    = 301;
+	map<bool, sint32>   map_bool_sint32   = 302;
+	map<bool, uint32>   map_bool_uint32   = 303;
+	map<bool, int64>    map_bool_int64    = 304;
+	map<bool, sint64>   map_bool_sint64   = 305;
+	map<bool, uint64>   map_bool_uint64   = 306;
+	map<bool, fixed32>  map_bool_fixed32  = 307;
+	map<bool, sfixed32> map_bool_sfixed32 = 308;
+	map<bool, float>    map_bool_float    = 309;
+	map<bool, fixed64>  map_bool_fixed64  = 310;
+	map<bool, sfixed64> map_bool_sfixed64 = 311;
+	map<bool, double>   map_bool_double   = 312;
+	map<bool, string>   map_bool_string   = 313;
+	map<bool, bytes>    map_bool_bytes    = 314;
+
+	map<bool, ChildEnum>      map_bool_child_enum      = 315;
+	map<bool, ChildMessage>   map_bool_child_message   = 316;
+	map<bool, SiblingEnum>    map_bool_sibling_enum    = 317;
+	map<bool, SiblingMessage> map_bool_sibling_message = 318;
+
+	map<int32, bool>   map_int32_bool   = 319;
+	map<sint32, bool>  map_sint32_bool  = 320;
+	map<uint32, bool>  map_uint32_bool  = 321;
+	map<int64, bool>   map_int64_bool   = 322;
+	map<sint64, bool>  map_sint64_bool  = 323;
+	map<uint64, bool>  map_uint64_bool  = 324;
+	map<fixed32, bool> map_fixed32_bool = 325;
+	map<string, bool>  map_string_bool  = 326;
+
+	// Oneof fields.
+	oneof oneof_union {
+		bool     oneof_bool     = 400;
+		int32    oneof_int32    = 401;
+		sint32   oneof_sint32   = 402;
+		uint32   oneof_uint32   = 403;
+		int64    oneof_int64    = 404;
+		sint64   oneof_sint64   = 405;
+		uint64   oneof_uint64   = 406;
+		fixed32  oneof_fixed32  = 407;
+		sfixed32 oneof_sfixed32 = 408;
+		float    oneof_float    = 409;
+		fixed64  oneof_fixed64  = 410;
+		sfixed64 oneof_sfixed64 = 411;
+		double   oneof_double   = 412;
+		string   oneof_string   = 413;
+		bytes    oneof_bytes    = 414;
+
+		ChildEnum      oneof_child_enum      = 415;
+		ChildMessage   oneof_child_message   = 416;
+		SiblingEnum    oneof_sibling_enum    = 417;
+		SiblingMessage oneof_sibling_message = 418;
+
+		string oneof_string1 = 419;
+		string oneof_string2 = 420;
+		string oneof_string3 = 421;
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20180814_aa810b61/test.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20180814_aa810b61/test.pb.go
new file mode 100644
index 000000000..97e40899f
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20180814_aa810b61/test.pb.go
@@ -0,0 +1,1587 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: proto3_20180814_aa810b61/test.proto
+
+package proto3_20180814_aa810b61 // import "google.golang.org/protobuf/internal/testprotos/legacy/proto3_20180814_aa810b61"
+
+import proto "google.golang.org/protobuf/internal/protolegacy"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type SiblingEnum int32
+
+const (
+	SiblingEnum_ALPHA   SiblingEnum = 0
+	SiblingEnum_BRAVO   SiblingEnum = 10
+	SiblingEnum_CHARLIE SiblingEnum = 200
+)
+
+var SiblingEnum_name = map[int32]string{
+	0:   "ALPHA",
+	10:  "BRAVO",
+	200: "CHARLIE",
+}
+var SiblingEnum_value = map[string]int32{
+	"ALPHA":   0,
+	"BRAVO":   10,
+	"CHARLIE": 200,
+}
+
+func (x SiblingEnum) String() string {
+	return proto.EnumName(SiblingEnum_name, int32(x))
+}
+func (SiblingEnum) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_test_14f9d28b9a7006c3, []int{0}
+}
+
+type Message_ChildEnum int32
+
+const (
+	Message_ALPHA   Message_ChildEnum = 0
+	Message_BRAVO   Message_ChildEnum = 1
+	Message_CHARLIE Message_ChildEnum = 2
+)
+
+var Message_ChildEnum_name = map[int32]string{
+	0: "ALPHA",
+	1: "BRAVO",
+	2: "CHARLIE",
+}
+var Message_ChildEnum_value = map[string]int32{
+	"ALPHA":   0,
+	"BRAVO":   1,
+	"CHARLIE": 2,
+}
+
+func (x Message_ChildEnum) String() string {
+	return proto.EnumName(Message_ChildEnum_name, int32(x))
+}
+func (Message_ChildEnum) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_test_14f9d28b9a7006c3, []int{1, 0}
+}
+
+type SiblingMessage 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"`
+	F3                   *Message `protobuf:"bytes,3,opt,name=f3,proto3" json:"f3,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *SiblingMessage) Reset()         { *m = SiblingMessage{} }
+func (m *SiblingMessage) String() string { return proto.CompactTextString(m) }
+func (*SiblingMessage) ProtoMessage()    {}
+func (*SiblingMessage) Descriptor() ([]byte, []int) {
+	return fileDescriptor_test_14f9d28b9a7006c3, []int{0}
+}
+func (m *SiblingMessage) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_SiblingMessage.Unmarshal(m, b)
+}
+func (m *SiblingMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_SiblingMessage.Marshal(b, m, deterministic)
+}
+func (dst *SiblingMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SiblingMessage.Merge(dst, src)
+}
+func (m *SiblingMessage) XXX_Size() int {
+	return xxx_messageInfo_SiblingMessage.Size(m)
+}
+func (m *SiblingMessage) XXX_DiscardUnknown() {
+	xxx_messageInfo_SiblingMessage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SiblingMessage proto.InternalMessageInfo
+
+func (m *SiblingMessage) GetF1() string {
+	if m != nil {
+		return m.F1
+	}
+	return ""
+}
+
+func (m *SiblingMessage) GetF2() []string {
+	if m != nil {
+		return m.F2
+	}
+	return nil
+}
+
+func (m *SiblingMessage) GetF3() *Message {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message 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      Message_ChildEnum     `protobuf:"varint,115,opt,name=optional_child_enum,json=optionalChildEnum,proto3,enum=google.golang.org.proto3_20180814.Message_ChildEnum" json:"optional_child_enum,omitempty"`
+	OptionalChildMessage   *Message_ChildMessage `protobuf:"bytes,116,opt,name=optional_child_message,json=optionalChildMessage,proto3" json:"optional_child_message,omitempty"`
+	OptionalSiblingEnum    SiblingEnum           `protobuf:"varint,117,opt,name=optional_sibling_enum,json=optionalSiblingEnum,proto3,enum=google.golang.org.proto3_20180814.SiblingEnum" json:"optional_sibling_enum,omitempty"`
+	OptionalSiblingMessage *SiblingMessage       `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      []Message_ChildEnum     `protobuf:"varint,215,rep,packed,name=repeated_child_enum,json=repeatedChildEnum,proto3,enum=google.golang.org.proto3_20180814.Message_ChildEnum" json:"repeated_child_enum,omitempty"`
+	RepeatedChildMessage   []*Message_ChildMessage `protobuf:"bytes,216,rep,name=repeated_child_message,json=repeatedChildMessage,proto3" json:"repeated_child_message,omitempty"`
+	RepeatedSiblingEnum    []SiblingEnum           `protobuf:"varint,217,rep,packed,name=repeated_sibling_enum,json=repeatedSiblingEnum,proto3,enum=google.golang.org.proto3_20180814.SiblingEnum" json:"repeated_sibling_enum,omitempty"`
+	RepeatedSiblingMessage []*SiblingMessage       `protobuf:"bytes,218,rep,name=repeated_sibling_message,json=repeatedSiblingMessage,proto3" json:"repeated_sibling_message,omitempty"`
+	// Map fields.
+	MapBoolBool           map[bool]bool                  `protobuf:"bytes,300,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,301,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,302,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,303,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,304,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,305,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,306,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,307,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,308,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,309,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,310,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,311,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,312,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,313,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,314,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]Message_ChildEnum     `protobuf:"bytes,315,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_20180814.Message_ChildEnum"`
+	MapBoolChildMessage   map[bool]*Message_ChildMessage `protobuf:"bytes,316,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"`
+	MapBoolSiblingEnum    map[bool]SiblingEnum           `protobuf:"bytes,317,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_20180814.SiblingEnum"`
+	MapBoolSiblingMessage map[bool]*SiblingMessage       `protobuf:"bytes,318,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,319,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,320,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,321,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,322,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,323,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,324,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,325,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,326,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.
+	//
+	// Types that are valid to be assigned to OneofUnion:
+	//	*Message_OneofBool
+	//	*Message_OneofInt32
+	//	*Message_OneofSint32
+	//	*Message_OneofUint32
+	//	*Message_OneofInt64
+	//	*Message_OneofSint64
+	//	*Message_OneofUint64
+	//	*Message_OneofFixed32
+	//	*Message_OneofSfixed32
+	//	*Message_OneofFloat
+	//	*Message_OneofFixed64
+	//	*Message_OneofSfixed64
+	//	*Message_OneofDouble
+	//	*Message_OneofString
+	//	*Message_OneofBytes
+	//	*Message_OneofChildEnum
+	//	*Message_OneofChildMessage
+	//	*Message_OneofSiblingEnum
+	//	*Message_OneofSiblingMessage
+	//	*Message_OneofString1
+	//	*Message_OneofString2
+	//	*Message_OneofString3
+	OneofUnion           isMessage_OneofUnion `protobuf_oneof:"oneof_union"`
+	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
+	XXX_unrecognized     []byte               `json:"-"`
+	XXX_sizecache        int32                `json:"-"`
+}
+
+func (m *Message) Reset()         { *m = Message{} }
+func (m *Message) String() string { return proto.CompactTextString(m) }
+func (*Message) ProtoMessage()    {}
+func (*Message) Descriptor() ([]byte, []int) {
+	return fileDescriptor_test_14f9d28b9a7006c3, []int{1}
+}
+func (m *Message) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Message.Unmarshal(m, b)
+}
+func (m *Message) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Message.Marshal(b, m, deterministic)
+}
+func (dst *Message) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Message.Merge(dst, src)
+}
+func (m *Message) XXX_Size() int {
+	return xxx_messageInfo_Message.Size(m)
+}
+func (m *Message) XXX_DiscardUnknown() {
+	xxx_messageInfo_Message.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message proto.InternalMessageInfo
+
+func (m *Message) GetOptionalBool() bool {
+	if m != nil {
+		return m.OptionalBool
+	}
+	return false
+}
+
+func (m *Message) GetOptionalInt32() int32 {
+	if m != nil {
+		return m.OptionalInt32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSint32() int32 {
+	if m != nil {
+		return m.OptionalSint32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalUint32() uint32 {
+	if m != nil {
+		return m.OptionalUint32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalInt64() int64 {
+	if m != nil {
+		return m.OptionalInt64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSint64() int64 {
+	if m != nil {
+		return m.OptionalSint64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalUint64() uint64 {
+	if m != nil {
+		return m.OptionalUint64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalFixed32() uint32 {
+	if m != nil {
+		return m.OptionalFixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSfixed32() int32 {
+	if m != nil {
+		return m.OptionalSfixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalFloat() float32 {
+	if m != nil {
+		return m.OptionalFloat
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalFixed64() uint64 {
+	if m != nil {
+		return m.OptionalFixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSfixed64() int64 {
+	if m != nil {
+		return m.OptionalSfixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalDouble() float64 {
+	if m != nil {
+		return m.OptionalDouble
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalString() string {
+	if m != nil {
+		return m.OptionalString
+	}
+	return ""
+}
+
+func (m *Message) GetOptionalBytes() []byte {
+	if m != nil {
+		return m.OptionalBytes
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalChildEnum() Message_ChildEnum {
+	if m != nil {
+		return m.OptionalChildEnum
+	}
+	return Message_ALPHA
+}
+
+func (m *Message) GetOptionalChildMessage() *Message_ChildMessage {
+	if m != nil {
+		return m.OptionalChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalSiblingEnum() SiblingEnum {
+	if m != nil {
+		return m.OptionalSiblingEnum
+	}
+	return SiblingEnum_ALPHA
+}
+
+func (m *Message) GetOptionalSiblingMessage() *SiblingMessage {
+	if m != nil {
+		return m.OptionalSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedBool() []bool {
+	if m != nil {
+		return m.RepeatedBool
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedInt32() []int32 {
+	if m != nil {
+		return m.RepeatedInt32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSint32() []int32 {
+	if m != nil {
+		return m.RepeatedSint32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedUint32() []uint32 {
+	if m != nil {
+		return m.RepeatedUint32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedInt64() []int64 {
+	if m != nil {
+		return m.RepeatedInt64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSint64() []int64 {
+	if m != nil {
+		return m.RepeatedSint64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedUint64() []uint64 {
+	if m != nil {
+		return m.RepeatedUint64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedFixed32() []uint32 {
+	if m != nil {
+		return m.RepeatedFixed32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSfixed32() []int32 {
+	if m != nil {
+		return m.RepeatedSfixed32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedFloat() []float32 {
+	if m != nil {
+		return m.RepeatedFloat
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedFixed64() []uint64 {
+	if m != nil {
+		return m.RepeatedFixed64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSfixed64() []int64 {
+	if m != nil {
+		return m.RepeatedSfixed64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedDouble() []float64 {
+	if m != nil {
+		return m.RepeatedDouble
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedString() []string {
+	if m != nil {
+		return m.RepeatedString
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedBytes() [][]byte {
+	if m != nil {
+		return m.RepeatedBytes
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedChildEnum() []Message_ChildEnum {
+	if m != nil {
+		return m.RepeatedChildEnum
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedChildMessage() []*Message_ChildMessage {
+	if m != nil {
+		return m.RepeatedChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSiblingEnum() []SiblingEnum {
+	if m != nil {
+		return m.RepeatedSiblingEnum
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSiblingMessage() []*SiblingMessage {
+	if m != nil {
+		return m.RepeatedSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolBool() map[bool]bool {
+	if m != nil {
+		return m.MapBoolBool
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolInt32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolInt32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSint32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolSint32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolUint32() map[bool]uint32 {
+	if m != nil {
+		return m.MapBoolUint32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolInt64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolInt64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSint64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolSint64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolUint64() map[bool]uint64 {
+	if m != nil {
+		return m.MapBoolUint64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFixed32() map[bool]uint32 {
+	if m != nil {
+		return m.MapBoolFixed32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSfixed32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolSfixed32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFloat() map[bool]float32 {
+	if m != nil {
+		return m.MapBoolFloat
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFixed64() map[bool]uint64 {
+	if m != nil {
+		return m.MapBoolFixed64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSfixed64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolSfixed64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolDouble() map[bool]float64 {
+	if m != nil {
+		return m.MapBoolDouble
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolString() map[bool]string {
+	if m != nil {
+		return m.MapBoolString
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolBytes() map[bool][]byte {
+	if m != nil {
+		return m.MapBoolBytes
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolChildEnum() map[bool]Message_ChildEnum {
+	if m != nil {
+		return m.MapBoolChildEnum
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolChildMessage() map[bool]*Message_ChildMessage {
+	if m != nil {
+		return m.MapBoolChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSiblingEnum() map[bool]SiblingEnum {
+	if m != nil {
+		return m.MapBoolSiblingEnum
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSiblingMessage() map[bool]*SiblingMessage {
+	if m != nil {
+		return m.MapBoolSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetMapInt32Bool() map[int32]bool {
+	if m != nil {
+		return m.MapInt32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapSint32Bool() map[int32]bool {
+	if m != nil {
+		return m.MapSint32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapUint32Bool() map[uint32]bool {
+	if m != nil {
+		return m.MapUint32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapInt64Bool() map[int64]bool {
+	if m != nil {
+		return m.MapInt64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapSint64Bool() map[int64]bool {
+	if m != nil {
+		return m.MapSint64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapUint64Bool() map[uint64]bool {
+	if m != nil {
+		return m.MapUint64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapFixed32Bool() map[uint32]bool {
+	if m != nil {
+		return m.MapFixed32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapStringBool() map[string]bool {
+	if m != nil {
+		return m.MapStringBool
+	}
+	return nil
+}
+
+type isMessage_OneofUnion interface {
+	isMessage_OneofUnion()
+}
+
+type Message_OneofBool struct {
+	OneofBool bool `protobuf:"varint,400,opt,name=oneof_bool,json=oneofBool,proto3,oneof"`
+}
+
+type Message_OneofInt32 struct {
+	OneofInt32 int32 `protobuf:"varint,401,opt,name=oneof_int32,json=oneofInt32,proto3,oneof"`
+}
+
+type Message_OneofSint32 struct {
+	OneofSint32 int32 `protobuf:"zigzag32,402,opt,name=oneof_sint32,json=oneofSint32,proto3,oneof"`
+}
+
+type Message_OneofUint32 struct {
+	OneofUint32 uint32 `protobuf:"varint,403,opt,name=oneof_uint32,json=oneofUint32,proto3,oneof"`
+}
+
+type Message_OneofInt64 struct {
+	OneofInt64 int64 `protobuf:"varint,404,opt,name=oneof_int64,json=oneofInt64,proto3,oneof"`
+}
+
+type Message_OneofSint64 struct {
+	OneofSint64 int64 `protobuf:"zigzag64,405,opt,name=oneof_sint64,json=oneofSint64,proto3,oneof"`
+}
+
+type Message_OneofUint64 struct {
+	OneofUint64 uint64 `protobuf:"varint,406,opt,name=oneof_uint64,json=oneofUint64,proto3,oneof"`
+}
+
+type Message_OneofFixed32 struct {
+	OneofFixed32 uint32 `protobuf:"fixed32,407,opt,name=oneof_fixed32,json=oneofFixed32,proto3,oneof"`
+}
+
+type Message_OneofSfixed32 struct {
+	OneofSfixed32 int32 `protobuf:"fixed32,408,opt,name=oneof_sfixed32,json=oneofSfixed32,proto3,oneof"`
+}
+
+type Message_OneofFloat struct {
+	OneofFloat float32 `protobuf:"fixed32,409,opt,name=oneof_float,json=oneofFloat,proto3,oneof"`
+}
+
+type Message_OneofFixed64 struct {
+	OneofFixed64 uint64 `protobuf:"fixed64,410,opt,name=oneof_fixed64,json=oneofFixed64,proto3,oneof"`
+}
+
+type Message_OneofSfixed64 struct {
+	OneofSfixed64 int64 `protobuf:"fixed64,411,opt,name=oneof_sfixed64,json=oneofSfixed64,proto3,oneof"`
+}
+
+type Message_OneofDouble struct {
+	OneofDouble float64 `protobuf:"fixed64,412,opt,name=oneof_double,json=oneofDouble,proto3,oneof"`
+}
+
+type Message_OneofString struct {
+	OneofString string `protobuf:"bytes,413,opt,name=oneof_string,json=oneofString,proto3,oneof"`
+}
+
+type Message_OneofBytes struct {
+	OneofBytes []byte `protobuf:"bytes,414,opt,name=oneof_bytes,json=oneofBytes,proto3,oneof"`
+}
+
+type Message_OneofChildEnum struct {
+	OneofChildEnum Message_ChildEnum `protobuf:"varint,415,opt,name=oneof_child_enum,json=oneofChildEnum,proto3,enum=google.golang.org.proto3_20180814.Message_ChildEnum,oneof"`
+}
+
+type Message_OneofChildMessage struct {
+	OneofChildMessage *Message_ChildMessage `protobuf:"bytes,416,opt,name=oneof_child_message,json=oneofChildMessage,proto3,oneof"`
+}
+
+type Message_OneofSiblingEnum struct {
+	OneofSiblingEnum SiblingEnum `protobuf:"varint,417,opt,name=oneof_sibling_enum,json=oneofSiblingEnum,proto3,enum=google.golang.org.proto3_20180814.SiblingEnum,oneof"`
+}
+
+type Message_OneofSiblingMessage struct {
+	OneofSiblingMessage *SiblingMessage `protobuf:"bytes,418,opt,name=oneof_sibling_message,json=oneofSiblingMessage,proto3,oneof"`
+}
+
+type Message_OneofString1 struct {
+	OneofString1 string `protobuf:"bytes,419,opt,name=oneof_string1,json=oneofString1,proto3,oneof"`
+}
+
+type Message_OneofString2 struct {
+	OneofString2 string `protobuf:"bytes,420,opt,name=oneof_string2,json=oneofString2,proto3,oneof"`
+}
+
+type Message_OneofString3 struct {
+	OneofString3 string `protobuf:"bytes,421,opt,name=oneof_string3,json=oneofString3,proto3,oneof"`
+}
+
+func (*Message_OneofBool) isMessage_OneofUnion() {}
+
+func (*Message_OneofInt32) isMessage_OneofUnion() {}
+
+func (*Message_OneofSint32) isMessage_OneofUnion() {}
+
+func (*Message_OneofUint32) isMessage_OneofUnion() {}
+
+func (*Message_OneofInt64) isMessage_OneofUnion() {}
+
+func (*Message_OneofSint64) isMessage_OneofUnion() {}
+
+func (*Message_OneofUint64) isMessage_OneofUnion() {}
+
+func (*Message_OneofFixed32) isMessage_OneofUnion() {}
+
+func (*Message_OneofSfixed32) isMessage_OneofUnion() {}
+
+func (*Message_OneofFloat) isMessage_OneofUnion() {}
+
+func (*Message_OneofFixed64) isMessage_OneofUnion() {}
+
+func (*Message_OneofSfixed64) isMessage_OneofUnion() {}
+
+func (*Message_OneofDouble) isMessage_OneofUnion() {}
+
+func (*Message_OneofString) isMessage_OneofUnion() {}
+
+func (*Message_OneofBytes) isMessage_OneofUnion() {}
+
+func (*Message_OneofChildEnum) isMessage_OneofUnion() {}
+
+func (*Message_OneofChildMessage) isMessage_OneofUnion() {}
+
+func (*Message_OneofSiblingEnum) isMessage_OneofUnion() {}
+
+func (*Message_OneofSiblingMessage) isMessage_OneofUnion() {}
+
+func (*Message_OneofString1) isMessage_OneofUnion() {}
+
+func (*Message_OneofString2) isMessage_OneofUnion() {}
+
+func (*Message_OneofString3) isMessage_OneofUnion() {}
+
+func (m *Message) GetOneofUnion() isMessage_OneofUnion {
+	if m != nil {
+		return m.OneofUnion
+	}
+	return nil
+}
+
+func (m *Message) GetOneofBool() bool {
+	if x, ok := m.GetOneofUnion().(*Message_OneofBool); ok {
+		return x.OneofBool
+	}
+	return false
+}
+
+func (m *Message) GetOneofInt32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofInt32); ok {
+		return x.OneofInt32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSint32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSint32); ok {
+		return x.OneofSint32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofUint32() uint32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofUint32); ok {
+		return x.OneofUint32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofInt64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofInt64); ok {
+		return x.OneofInt64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSint64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSint64); ok {
+		return x.OneofSint64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofUint64() uint64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofUint64); ok {
+		return x.OneofUint64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFixed32() uint32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFixed32); ok {
+		return x.OneofFixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSfixed32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSfixed32); ok {
+		return x.OneofSfixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFloat() float32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFloat); ok {
+		return x.OneofFloat
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFixed64() uint64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFixed64); ok {
+		return x.OneofFixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSfixed64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSfixed64); ok {
+		return x.OneofSfixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofDouble() float64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofDouble); ok {
+		return x.OneofDouble
+	}
+	return 0
+}
+
+func (m *Message) GetOneofString() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString); ok {
+		return x.OneofString
+	}
+	return ""
+}
+
+func (m *Message) GetOneofBytes() []byte {
+	if x, ok := m.GetOneofUnion().(*Message_OneofBytes); ok {
+		return x.OneofBytes
+	}
+	return nil
+}
+
+func (m *Message) GetOneofChildEnum() Message_ChildEnum {
+	if x, ok := m.GetOneofUnion().(*Message_OneofChildEnum); ok {
+		return x.OneofChildEnum
+	}
+	return Message_ALPHA
+}
+
+func (m *Message) GetOneofChildMessage() *Message_ChildMessage {
+	if x, ok := m.GetOneofUnion().(*Message_OneofChildMessage); ok {
+		return x.OneofChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOneofSiblingEnum() SiblingEnum {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSiblingEnum); ok {
+		return x.OneofSiblingEnum
+	}
+	return SiblingEnum_ALPHA
+}
+
+func (m *Message) GetOneofSiblingMessage() *SiblingMessage {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSiblingMessage); ok {
+		return x.OneofSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOneofString1() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString1); ok {
+		return x.OneofString1
+	}
+	return ""
+}
+
+func (m *Message) GetOneofString2() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString2); ok {
+		return x.OneofString2
+	}
+	return ""
+}
+
+func (m *Message) GetOneofString3() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString3); ok {
+		return x.OneofString3
+	}
+	return ""
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*Message) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+	return _Message_OneofMarshaler, _Message_OneofUnmarshaler, _Message_OneofSizer, []interface{}{
+		(*Message_OneofBool)(nil),
+		(*Message_OneofInt32)(nil),
+		(*Message_OneofSint32)(nil),
+		(*Message_OneofUint32)(nil),
+		(*Message_OneofInt64)(nil),
+		(*Message_OneofSint64)(nil),
+		(*Message_OneofUint64)(nil),
+		(*Message_OneofFixed32)(nil),
+		(*Message_OneofSfixed32)(nil),
+		(*Message_OneofFloat)(nil),
+		(*Message_OneofFixed64)(nil),
+		(*Message_OneofSfixed64)(nil),
+		(*Message_OneofDouble)(nil),
+		(*Message_OneofString)(nil),
+		(*Message_OneofBytes)(nil),
+		(*Message_OneofChildEnum)(nil),
+		(*Message_OneofChildMessage)(nil),
+		(*Message_OneofSiblingEnum)(nil),
+		(*Message_OneofSiblingMessage)(nil),
+		(*Message_OneofString1)(nil),
+		(*Message_OneofString2)(nil),
+		(*Message_OneofString3)(nil),
+	}
+}
+
+func _Message_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*Message)
+	// oneof_union
+	switch x := m.OneofUnion.(type) {
+	case *Message_OneofBool:
+		t := uint64(0)
+		if x.OneofBool {
+			t = 1
+		}
+		b.EncodeVarint(400<<3 | proto.WireVarint)
+		b.EncodeVarint(t)
+	case *Message_OneofInt32:
+		b.EncodeVarint(401<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofInt32))
+	case *Message_OneofSint32:
+		b.EncodeVarint(402<<3 | proto.WireVarint)
+		b.EncodeZigzag32(uint64(x.OneofSint32))
+	case *Message_OneofUint32:
+		b.EncodeVarint(403<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofUint32))
+	case *Message_OneofInt64:
+		b.EncodeVarint(404<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofInt64))
+	case *Message_OneofSint64:
+		b.EncodeVarint(405<<3 | proto.WireVarint)
+		b.EncodeZigzag64(uint64(x.OneofSint64))
+	case *Message_OneofUint64:
+		b.EncodeVarint(406<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofUint64))
+	case *Message_OneofFixed32:
+		b.EncodeVarint(407<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(x.OneofFixed32))
+	case *Message_OneofSfixed32:
+		b.EncodeVarint(408<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(x.OneofSfixed32))
+	case *Message_OneofFloat:
+		b.EncodeVarint(409<<3 | proto.WireFixed32)
+		b.EncodeFixed32(uint64(math.Float32bits(x.OneofFloat)))
+	case *Message_OneofFixed64:
+		b.EncodeVarint(410<<3 | proto.WireFixed64)
+		b.EncodeFixed64(uint64(x.OneofFixed64))
+	case *Message_OneofSfixed64:
+		b.EncodeVarint(411<<3 | proto.WireFixed64)
+		b.EncodeFixed64(uint64(x.OneofSfixed64))
+	case *Message_OneofDouble:
+		b.EncodeVarint(412<<3 | proto.WireFixed64)
+		b.EncodeFixed64(math.Float64bits(x.OneofDouble))
+	case *Message_OneofString:
+		b.EncodeVarint(413<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString)
+	case *Message_OneofBytes:
+		b.EncodeVarint(414<<3 | proto.WireBytes)
+		b.EncodeRawBytes(x.OneofBytes)
+	case *Message_OneofChildEnum:
+		b.EncodeVarint(415<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofChildEnum))
+	case *Message_OneofChildMessage:
+		b.EncodeVarint(416<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.OneofChildMessage); err != nil {
+			return err
+		}
+	case *Message_OneofSiblingEnum:
+		b.EncodeVarint(417<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.OneofSiblingEnum))
+	case *Message_OneofSiblingMessage:
+		b.EncodeVarint(418<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.OneofSiblingMessage); err != nil {
+			return err
+		}
+	case *Message_OneofString1:
+		b.EncodeVarint(419<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString1)
+	case *Message_OneofString2:
+		b.EncodeVarint(420<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString2)
+	case *Message_OneofString3:
+		b.EncodeVarint(421<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.OneofString3)
+	case nil:
+	default:
+		return fmt.Errorf("Message.OneofUnion has unexpected type %T", x)
+	}
+	return nil
+}
+
+func _Message_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*Message)
+	switch tag {
+	case 400: // oneof_union.oneof_bool
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofBool{x != 0}
+		return true, err
+	case 401: // oneof_union.oneof_int32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofInt32{int32(x)}
+		return true, err
+	case 402: // oneof_union.oneof_sint32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeZigzag32()
+		m.OneofUnion = &Message_OneofSint32{int32(x)}
+		return true, err
+	case 403: // oneof_union.oneof_uint32
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofUint32{uint32(x)}
+		return true, err
+	case 404: // oneof_union.oneof_int64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofInt64{int64(x)}
+		return true, err
+	case 405: // oneof_union.oneof_sint64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeZigzag64()
+		m.OneofUnion = &Message_OneofSint64{int64(x)}
+		return true, err
+	case 406: // oneof_union.oneof_uint64
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofUint64{x}
+		return true, err
+	case 407: // oneof_union.oneof_fixed32
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofUnion = &Message_OneofFixed32{uint32(x)}
+		return true, err
+	case 408: // oneof_union.oneof_sfixed32
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofUnion = &Message_OneofSfixed32{int32(x)}
+		return true, err
+	case 409: // oneof_union.oneof_float
+		if wire != proto.WireFixed32 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed32()
+		m.OneofUnion = &Message_OneofFloat{math.Float32frombits(uint32(x))}
+		return true, err
+	case 410: // oneof_union.oneof_fixed64
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofUnion = &Message_OneofFixed64{x}
+		return true, err
+	case 411: // oneof_union.oneof_sfixed64
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofUnion = &Message_OneofSfixed64{int64(x)}
+		return true, err
+	case 412: // oneof_union.oneof_double
+		if wire != proto.WireFixed64 {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeFixed64()
+		m.OneofUnion = &Message_OneofDouble{math.Float64frombits(x)}
+		return true, err
+	case 413: // oneof_union.oneof_string
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString{x}
+		return true, err
+	case 414: // oneof_union.oneof_bytes
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeRawBytes(true)
+		m.OneofUnion = &Message_OneofBytes{x}
+		return true, err
+	case 415: // oneof_union.oneof_child_enum
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofChildEnum{Message_ChildEnum(x)}
+		return true, err
+	case 416: // oneof_union.oneof_child_message
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(Message_ChildMessage)
+		err := b.DecodeMessage(msg)
+		m.OneofUnion = &Message_OneofChildMessage{msg}
+		return true, err
+	case 417: // oneof_union.oneof_sibling_enum
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.OneofUnion = &Message_OneofSiblingEnum{SiblingEnum(x)}
+		return true, err
+	case 418: // oneof_union.oneof_sibling_message
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(SiblingMessage)
+		err := b.DecodeMessage(msg)
+		m.OneofUnion = &Message_OneofSiblingMessage{msg}
+		return true, err
+	case 419: // oneof_union.oneof_string1
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString1{x}
+		return true, err
+	case 420: // oneof_union.oneof_string2
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString2{x}
+		return true, err
+	case 421: // oneof_union.oneof_string3
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.OneofUnion = &Message_OneofString3{x}
+		return true, err
+	default:
+		return false, nil
+	}
+}
+
+func _Message_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*Message)
+	// oneof_union
+	switch x := m.OneofUnion.(type) {
+	case *Message_OneofBool:
+		n += 2 // tag and wire
+		n += 1
+	case *Message_OneofInt32:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofInt32))
+	case *Message_OneofSint32:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64((uint32(x.OneofSint32) << 1) ^ uint32((int32(x.OneofSint32) >> 31))))
+	case *Message_OneofUint32:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofUint32))
+	case *Message_OneofInt64:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofInt64))
+	case *Message_OneofSint64:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(uint64(x.OneofSint64<<1) ^ uint64((int64(x.OneofSint64) >> 63))))
+	case *Message_OneofUint64:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofUint64))
+	case *Message_OneofFixed32:
+		n += 2 // tag and wire
+		n += 4
+	case *Message_OneofSfixed32:
+		n += 2 // tag and wire
+		n += 4
+	case *Message_OneofFloat:
+		n += 2 // tag and wire
+		n += 4
+	case *Message_OneofFixed64:
+		n += 2 // tag and wire
+		n += 8
+	case *Message_OneofSfixed64:
+		n += 2 // tag and wire
+		n += 8
+	case *Message_OneofDouble:
+		n += 2 // tag and wire
+		n += 8
+	case *Message_OneofString:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(len(x.OneofString)))
+		n += len(x.OneofString)
+	case *Message_OneofBytes:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(len(x.OneofBytes)))
+		n += len(x.OneofBytes)
+	case *Message_OneofChildEnum:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofChildEnum))
+	case *Message_OneofChildMessage:
+		s := proto.Size(x.OneofChildMessage)
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *Message_OneofSiblingEnum:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(x.OneofSiblingEnum))
+	case *Message_OneofSiblingMessage:
+		s := proto.Size(x.OneofSiblingMessage)
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *Message_OneofString1:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(len(x.OneofString1)))
+		n += len(x.OneofString1)
+	case *Message_OneofString2:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(len(x.OneofString2)))
+		n += len(x.OneofString2)
+	case *Message_OneofString3:
+		n += 2 // tag and wire
+		n += proto.SizeVarint(uint64(len(x.OneofString3)))
+		n += len(x.OneofString3)
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	return n
+}
+
+type Message_ChildMessage 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"`
+	F3                   *Message `protobuf:"bytes,3,opt,name=f3,proto3" json:"f3,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Message_ChildMessage) Reset()         { *m = Message_ChildMessage{} }
+func (m *Message_ChildMessage) String() string { return proto.CompactTextString(m) }
+func (*Message_ChildMessage) ProtoMessage()    {}
+func (*Message_ChildMessage) Descriptor() ([]byte, []int) {
+	return fileDescriptor_test_14f9d28b9a7006c3, []int{1, 0}
+}
+func (m *Message_ChildMessage) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Message_ChildMessage.Unmarshal(m, b)
+}
+func (m *Message_ChildMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Message_ChildMessage.Marshal(b, m, deterministic)
+}
+func (dst *Message_ChildMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Message_ChildMessage.Merge(dst, src)
+}
+func (m *Message_ChildMessage) XXX_Size() int {
+	return xxx_messageInfo_Message_ChildMessage.Size(m)
+}
+func (m *Message_ChildMessage) XXX_DiscardUnknown() {
+	xxx_messageInfo_Message_ChildMessage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message_ChildMessage proto.InternalMessageInfo
+
+func (m *Message_ChildMessage) GetF1() string {
+	if m != nil {
+		return m.F1
+	}
+	return ""
+}
+
+func (m *Message_ChildMessage) GetF2() []string {
+	if m != nil {
+		return m.F2
+	}
+	return nil
+}
+
+func (m *Message_ChildMessage) GetF3() *Message {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*SiblingMessage)(nil), "google.golang.org.proto3_20180814.SiblingMessage")
+	proto.RegisterType((*Message)(nil), "google.golang.org.proto3_20180814.Message")
+	proto.RegisterMapType((map[bool]bool)(nil), "google.golang.org.proto3_20180814.Message.MapBoolBoolEntry")
+	proto.RegisterMapType((map[bool][]byte)(nil), "google.golang.org.proto3_20180814.Message.MapBoolBytesEntry")
+	proto.RegisterMapType((map[bool]Message_ChildEnum)(nil), "google.golang.org.proto3_20180814.Message.MapBoolChildEnumEntry")
+	proto.RegisterMapType((map[bool]*Message_ChildMessage)(nil), "google.golang.org.proto3_20180814.Message.MapBoolChildMessageEntry")
+	proto.RegisterMapType((map[bool]float64)(nil), "google.golang.org.proto3_20180814.Message.MapBoolDoubleEntry")
+	proto.RegisterMapType((map[bool]uint32)(nil), "google.golang.org.proto3_20180814.Message.MapBoolFixed32Entry")
+	proto.RegisterMapType((map[bool]uint64)(nil), "google.golang.org.proto3_20180814.Message.MapBoolFixed64Entry")
+	proto.RegisterMapType((map[bool]float32)(nil), "google.golang.org.proto3_20180814.Message.MapBoolFloatEntry")
+	proto.RegisterMapType((map[bool]int32)(nil), "google.golang.org.proto3_20180814.Message.MapBoolInt32Entry")
+	proto.RegisterMapType((map[bool]int64)(nil), "google.golang.org.proto3_20180814.Message.MapBoolInt64Entry")
+	proto.RegisterMapType((map[bool]int32)(nil), "google.golang.org.proto3_20180814.Message.MapBoolSfixed32Entry")
+	proto.RegisterMapType((map[bool]int64)(nil), "google.golang.org.proto3_20180814.Message.MapBoolSfixed64Entry")
+	proto.RegisterMapType((map[bool]SiblingEnum)(nil), "google.golang.org.proto3_20180814.Message.MapBoolSiblingEnumEntry")
+	proto.RegisterMapType((map[bool]*SiblingMessage)(nil), "google.golang.org.proto3_20180814.Message.MapBoolSiblingMessageEntry")
+	proto.RegisterMapType((map[bool]int32)(nil), "google.golang.org.proto3_20180814.Message.MapBoolSint32Entry")
+	proto.RegisterMapType((map[bool]int64)(nil), "google.golang.org.proto3_20180814.Message.MapBoolSint64Entry")
+	proto.RegisterMapType((map[bool]string)(nil), "google.golang.org.proto3_20180814.Message.MapBoolStringEntry")
+	proto.RegisterMapType((map[bool]uint32)(nil), "google.golang.org.proto3_20180814.Message.MapBoolUint32Entry")
+	proto.RegisterMapType((map[bool]uint64)(nil), "google.golang.org.proto3_20180814.Message.MapBoolUint64Entry")
+	proto.RegisterMapType((map[uint32]bool)(nil), "google.golang.org.proto3_20180814.Message.MapFixed32BoolEntry")
+	proto.RegisterMapType((map[int32]bool)(nil), "google.golang.org.proto3_20180814.Message.MapInt32BoolEntry")
+	proto.RegisterMapType((map[int64]bool)(nil), "google.golang.org.proto3_20180814.Message.MapInt64BoolEntry")
+	proto.RegisterMapType((map[int32]bool)(nil), "google.golang.org.proto3_20180814.Message.MapSint32BoolEntry")
+	proto.RegisterMapType((map[int64]bool)(nil), "google.golang.org.proto3_20180814.Message.MapSint64BoolEntry")
+	proto.RegisterMapType((map[string]bool)(nil), "google.golang.org.proto3_20180814.Message.MapStringBoolEntry")
+	proto.RegisterMapType((map[uint32]bool)(nil), "google.golang.org.proto3_20180814.Message.MapUint32BoolEntry")
+	proto.RegisterMapType((map[uint64]bool)(nil), "google.golang.org.proto3_20180814.Message.MapUint64BoolEntry")
+	proto.RegisterType((*Message_ChildMessage)(nil), "google.golang.org.proto3_20180814.Message.ChildMessage")
+	proto.RegisterEnum("google.golang.org.proto3_20180814.SiblingEnum", SiblingEnum_name, SiblingEnum_value)
+	proto.RegisterEnum("google.golang.org.proto3_20180814.Message_ChildEnum", Message_ChildEnum_name, Message_ChildEnum_value)
+}
+
+func init() {
+	proto.RegisterFile("proto3_20180814_aa810b61/test.proto", fileDescriptor_test_14f9d28b9a7006c3)
+}
+
+var fileDescriptor_test_14f9d28b9a7006c3 = []byte{
+	// 1946 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x9a, 0x57, 0x73, 0xdb, 0xca,
+	0x15, 0xc7, 0x09, 0x52, 0xc5, 0x5a, 0xb1, 0x82, 0x96, 0xb2, 0xa3, 0x27, 0x44, 0x76, 0x1c, 0xc4,
+	0xc9, 0x50, 0x26, 0x85, 0x41, 0x34, 0x4e, 0x62, 0x5b, 0xb2, 0xe5, 0xd0, 0x19, 0x3b, 0xf1, 0xc0,
+	0xa3, 0x3c, 0xe4, 0x45, 0x21, 0x25, 0x90, 0xa6, 0x0d, 0x12, 0x8a, 0x48, 0x7a, 0xa2, 0xc9, 0x83,
+	0xbf, 0x42, 0x7a, 0x6f, 0xb7, 0xbd, 0xdd, 0xde, 0x7b, 0xf7, 0x1d, 0xdf, 0xde, 0xeb, 0xa7, 0xb9,
+	0xb3, 0x38, 0xd8, 0x06, 0x80, 0x26, 0x09, 0xce, 0x7d, 0xf0, 0x8c, 0x74, 0xf8, 0xdf, 0xf3, 0xe3,
+	0x39, 0x38, 0x7b, 0xce, 0x2e, 0x2c, 0x74, 0x64, 0x6f, 0xdf, 0xed, 0xb9, 0xab, 0xdb, 0x95, 0x13,
+	0xe5, 0xb5, 0x13, 0x6b, 0x65, 0x63, 0xbb, 0x56, 0x5b, 0x2b, 0x9f, 0xa8, 0x9b, 0xe5, 0x95, 0x9e,
+	0xdd, 0xed, 0x95, 0xbc, 0x4f, 0xd5, 0x6f, 0x37, 0x5d, 0xb7, 0xe9, 0xd8, 0xa5, 0xa6, 0xeb, 0xd4,
+	0x3a, 0xcd, 0x92, 0xbb, 0xdf, 0x2c, 0x05, 0x96, 0x2d, 0x3b, 0x28, 0x7b, 0xa5, 0x55, 0x77, 0x5a,
+	0x9d, 0xe6, 0x25, 0xbb, 0xdb, 0xad, 0x35, 0x6d, 0x35, 0x8b, 0x92, 0x8d, 0x32, 0x56, 0x34, 0x45,
+	0x9f, 0xb3, 0x92, 0x8d, 0xb2, 0xf7, 0x7b, 0x05, 0x27, 0xb5, 0x94, 0xf7, 0x7b, 0x45, 0x3d, 0x89,
+	0x92, 0x8d, 0x55, 0x9c, 0xd2, 0x14, 0x7d, 0xbe, 0x72, 0xbc, 0x34, 0x94, 0x50, 0xf2, 0xfd, 0x5a,
+	0xc9, 0xc6, 0xea, 0xf2, 0xad, 0x33, 0x68, 0x96, 0x72, 0x8e, 0xa0, 0x8c, 0xbb, 0xd7, 0x6b, 0xb9,
+	0x9d, 0x9a, 0xb3, 0x5d, 0x77, 0x5d, 0x07, 0xef, 0x6a, 0x8a, 0x7e, 0xc8, 0x4a, 0x53, 0xe3, 0x86,
+	0xeb, 0x3a, 0xea, 0x77, 0x50, 0x96, 0x89, 0x5a, 0x9d, 0xde, 0x6a, 0x05, 0xdb, 0x9a, 0xa2, 0x4f,
+	0x5b, 0x6c, 0xe9, 0x05, 0x62, 0x54, 0xbf, 0x8b, 0x72, 0x4c, 0xd6, 0x05, 0x5d, 0x43, 0x53, 0xf4,
+	0x82, 0xc5, 0x56, 0x5f, 0x69, 0x85, 0x84, 0x7d, 0x10, 0x36, 0x35, 0x45, 0xcf, 0x70, 0xe1, 0x16,
+	0x08, 0x03, 0x60, 0xd3, 0xc0, 0x57, 0x35, 0x45, 0x4f, 0x49, 0x60, 0xd3, 0x08, 0x81, 0x4d, 0x03,
+	0xb7, 0x34, 0x45, 0x57, 0x65, 0x70, 0x40, 0xd8, 0x07, 0xe1, 0x35, 0x4d, 0xd1, 0xa7, 0x64, 0xb0,
+	0x69, 0xa8, 0xdf, 0x43, 0x79, 0x26, 0x6c, 0xb4, 0x7e, 0x6b, 0xef, 0xae, 0x56, 0xf0, 0x75, 0x4d,
+	0xd1, 0x67, 0x2d, 0xe6, 0xe0, 0x3c, 0x98, 0xd5, 0xef, 0xa3, 0x02, 0x87, 0x53, 0xad, 0xa3, 0x29,
+	0x7a, 0xce, 0x62, 0x3e, 0xae, 0xf8, 0x76, 0x29, 0xa0, 0x86, 0xe3, 0xd6, 0x7a, 0xb8, 0xad, 0x29,
+	0x7a, 0x92, 0x07, 0x74, 0x9e, 0x18, 0xc3, 0x78, 0xd3, 0xc0, 0x1d, 0x4d, 0xd1, 0x67, 0x02, 0x78,
+	0xd3, 0x88, 0xc0, 0x9b, 0x06, 0x76, 0x35, 0x45, 0xcf, 0x07, 0xf1, 0x81, 0xf8, 0x77, 0xdd, 0x7e,
+	0xdd, 0xb1, 0xf1, 0x9e, 0xa6, 0xe8, 0x0a, 0x8f, 0xff, 0x9c, 0x67, 0x95, 0x33, 0xda, 0xdb, 0x6f,
+	0x75, 0x9a, 0xf8, 0x37, 0x5e, 0x2d, 0xf2, 0x8c, 0x7a, 0x56, 0x29, 0xa0, 0xfa, 0x41, 0xcf, 0xee,
+	0xe2, 0x7d, 0x4d, 0xd1, 0xd3, 0x3c, 0xa0, 0x0d, 0x62, 0x54, 0x77, 0x51, 0x91, 0xc9, 0x76, 0xae,
+	0xb6, 0x9c, 0xdd, 0x6d, 0xbb, 0xd3, 0x6f, 0xe3, 0xae, 0xa6, 0xe8, 0xd9, 0x8a, 0x31, 0x7a, 0xfd,
+	0x96, 0xce, 0x92, 0xc5, 0x9b, 0x9d, 0x7e, 0xdb, 0x62, 0x61, 0x33, 0x93, 0xda, 0x46, 0x8b, 0x01,
+	0x4a, 0x1b, 0x96, 0xe1, 0x9e, 0xb7, 0x51, 0x7e, 0x38, 0x2e, 0x88, 0xee, 0x9a, 0xc3, 0x12, 0x8b,
+	0xee, 0x9d, 0x3a, 0x5a, 0x10, 0xca, 0xce, 0xdb, 0xbe, 0x10, 0x56, 0xdf, 0x0b, 0xab, 0x34, 0x02,
+	0xcd, 0xdf, 0xf5, 0x5e, 0x40, 0x45, 0x5e, 0xac, 0xcc, 0xa8, 0x5e, 0x47, 0x38, 0xc4, 0xa0, 0x41,
+	0xdd, 0xf0, 0x82, 0x2a, 0x8f, 0x8e, 0xa1, 0xe1, 0x2c, 0x06, 0x48, 0x34, 0xa0, 0xa3, 0x28, 0xb3,
+	0x6f, 0xef, 0xd9, 0xb5, 0x9e, 0xbd, 0x0b, 0xcd, 0xe0, 0xb6, 0xa2, 0xa5, 0x48, 0x37, 0xa0, 0x56,
+	0xaf, 0x1b, 0x1c, 0x43, 0x59, 0xa6, 0x82, 0xcd, 0xfb, 0x26, 0x91, 0x4d, 0x5b, 0x6c, 0x31, 0xb4,
+	0x03, 0x1d, 0xe5, 0x98, 0xce, 0x6f, 0x07, 0x6f, 0x11, 0x61, 0xc1, 0x62, 0xeb, 0xfd, 0x7e, 0x20,
+	0x2a, 0xfd, 0x7e, 0xf0, 0x36, 0x51, 0x66, 0xb8, 0xd2, 0x6f, 0x08, 0x01, 0xb6, 0x69, 0xe0, 0x77,
+	0x88, 0x30, 0x25, 0xb1, 0x4d, 0x23, 0xc4, 0x36, 0x0d, 0xfc, 0x2e, 0x11, 0xaa, 0x32, 0x3b, 0xa0,
+	0xf4, 0x5b, 0xc2, 0x7b, 0x44, 0x39, 0x25, 0xb3, 0x4d, 0x43, 0x3d, 0x8e, 0xf2, 0x4c, 0x49, 0xf7,
+	0xf9, 0xfb, 0x44, 0x3a, 0x6b, 0x31, 0x17, 0xb4, 0x29, 0xfc, 0x00, 0x15, 0x38, 0x9f, 0x8a, 0x3f,
+	0x20, 0xe2, 0x9c, 0xc5, 0xbc, 0xb0, 0xae, 0x20, 0x46, 0x05, 0x5d, 0xe1, 0x43, 0x22, 0x4d, 0xf2,
+	0xa8, 0xa0, 0x2d, 0x84, 0xbe, 0x81, 0x69, 0xe0, 0x8f, 0x88, 0x72, 0x26, 0xf0, 0x0d, 0x4c, 0x23,
+	0xe2, 0x1b, 0x98, 0x06, 0xfe, 0x98, 0x88, 0xf3, 0xc1, 0x6f, 0x10, 0xc8, 0x82, 0xdf, 0x18, 0x3e,
+	0x21, 0x5a, 0x85, 0x67, 0xc1, 0xef, 0x0c, 0x52, 0x66, 0xa1, 0x33, 0x7c, 0xaa, 0x78, 0x63, 0x89,
+	0x67, 0x16, 0x5a, 0x83, 0x18, 0x15, 0xb4, 0x86, 0xcf, 0x88, 0x30, 0xcd, 0xa3, 0x82, 0xde, 0x60,
+	0xa3, 0x22, 0xd3, 0x09, 0xbd, 0xe1, 0x73, 0x22, 0x8e, 0xdd, 0x1c, 0xa8, 0x47, 0xde, 0x1c, 0x3a,
+	0x68, 0x31, 0x80, 0xa1, 0xfb, 0xe8, 0x0b, 0x42, 0x9a, 0xa4, 0x3b, 0x48, 0x30, 0xba, 0x99, 0x76,
+	0xd0, 0x82, 0x50, 0x82, 0x42, 0x77, 0xf8, 0x12, 0x02, 0x1b, 0xbb, 0x3d, 0xf0, 0xc2, 0xe5, 0xed,
+	0xc1, 0x41, 0x38, 0x04, 0xa1, 0x61, 0x7d, 0x05, 0x61, 0xc5, 0xe9, 0x0f, 0x01, 0x14, 0x0d, 0xe9,
+	0xd7, 0x28, 0xd3, 0xae, 0xed, 0x79, 0xad, 0x01, 0xfa, 0xc3, 0xfd, 0x49, 0x0f, 0xf1, 0xa3, 0x31,
+	0x32, 0x77, 0xa9, 0xb6, 0x47, 0xba, 0x08, 0xf9, 0xb7, 0xd9, 0xe9, 0xed, 0x1f, 0x58, 0xf3, 0x6d,
+	0x6e, 0x51, 0x77, 0x50, 0x96, 0x11, 0xa0, 0x11, 0x3c, 0x00, 0x88, 0x1f, 0x8f, 0x8f, 0xf0, 0xba,
+	0x10, 0x30, 0xd2, 0x6d, 0xc1, 0xa4, 0x36, 0x50, 0x8e, 0x41, 0xfc, 0xc6, 0xf4, 0x20, 0x50, 0x7e,
+	0x32, 0x3e, 0x05, 0x5a, 0x18, 0x60, 0x32, 0x6d, 0xd1, 0x26, 0x71, 0xfc, 0xb6, 0xf6, 0x50, 0x6c,
+	0xce, 0x56, 0x04, 0xc7, 0x6f, 0x8a, 0x81, 0xa4, 0x99, 0x06, 0x7e, 0x78, 0x92, 0xa4, 0x99, 0x46,
+	0x28, 0x69, 0xa6, 0x11, 0x4a, 0x9a, 0x69, 0xe0, 0x47, 0x26, 0x4a, 0x1a, 0xc5, 0x88, 0x49, 0x0b,
+	0x70, 0xfc, 0x7e, 0xfc, 0xe8, 0x44, 0x49, 0x0b, 0x72, 0xfc, 0x6e, 0xde, 0x42, 0x79, 0xc6, 0xa1,
+	0x0d, 0xfa, 0x31, 0x00, 0x9d, 0x1a, 0x1f, 0xe4, 0xf7, 0x7d, 0x20, 0x65, 0xdb, 0x92, 0x51, 0x75,
+	0x50, 0x81, 0xa7, 0x8e, 0xb2, 0x1e, 0x07, 0xd6, 0xe9, 0x18, 0xc9, 0x6b, 0x88, 0xb0, 0x5c, 0x5b,
+	0xb6, 0x4a, 0xd5, 0x00, 0xc3, 0xe4, 0x89, 0xd8, 0xd5, 0xe0, 0x8d, 0x1d, 0xb9, 0x1a, 0x60, 0x12,
+	0x85, 0xb2, 0x67, 0x1a, 0xf8, 0xc9, 0xc9, 0xb2, 0x47, 0x9f, 0x93, 0x94, 0x3d, 0xd3, 0x88, 0xc8,
+	0x9e, 0x69, 0xe0, 0xa7, 0x26, 0xcc, 0x1e, 0x85, 0xc9, 0xd9, 0x0b, 0x94, 0x9f, 0x3f, 0x08, 0x9f,
+	0x8e, 0x5d, 0x7e, 0x30, 0x32, 0xe5, 0xf2, 0xf3, 0xc7, 0xa8, 0xb4, 0x9d, 0x60, 0x8c, 0x3e, 0x13,
+	0x7f, 0x3b, 0x79, 0x0e, 0x02, 0xdb, 0x09, 0x86, 0xb0, 0x58, 0x0d, 0x30, 0x84, 0x9f, 0x8d, 0x5d,
+	0x0d, 0xde, 0xb8, 0x96, 0xab, 0x01, 0x26, 0xf8, 0x1e, 0x2a, 0x32, 0x88, 0x30, 0xc1, 0x9f, 0x03,
+	0xd2, 0x99, 0xf1, 0x49, 0x6c, 0x6a, 0x03, 0x2d, 0xdf, 0x0e, 0x98, 0xd5, 0x03, 0xb4, 0x18, 0x20,
+	0xd2, 0xa9, 0xf7, 0x3c, 0x40, 0xcf, 0xc6, 0x84, 0xfa, 0x36, 0xe0, 0x16, 0xdb, 0xe1, 0x4f, 0xd4,
+	0x1b, 0x68, 0x41, 0x68, 0x84, 0xc2, 0x5c, 0x7f, 0x01, 0xc8, 0x1b, 0x71, 0xda, 0x21, 0x9b, 0xe8,
+	0x00, 0x56, 0xdb, 0xa1, 0x0f, 0xd4, 0x9b, 0x08, 0x87, 0xb8, 0x34, 0xe8, 0x17, 0x01, 0xbd, 0x19,
+	0x1b, 0x2d, 0x85, 0xbd, 0xd0, 0x8e, 0xfa, 0x8c, 0x96, 0x92, 0x37, 0x73, 0x60, 0xfc, 0xbf, 0x14,
+	0xab, 0x94, 0xbc, 0x21, 0xcc, 0xe7, 0x3f, 0x29, 0x25, 0x66, 0xa2, 0xfb, 0xa2, 0x2b, 0x50, 0x5e,
+	0x8e, 0xb5, 0x2f, 0x60, 0x06, 0x73, 0x0c, 0xd9, 0x17, 0xdc, 0x46, 0x39, 0x7d, 0x81, 0xf3, 0x4a,
+	0x2c, 0xce, 0x56, 0x04, 0x87, 0xdb, 0x84, 0xa4, 0x99, 0x06, 0x60, 0x5e, 0x8d, 0x9b, 0x34, 0xd3,
+	0x08, 0x25, 0x0d, 0x4c, 0x62, 0xd2, 0x28, 0xe5, 0xb5, 0xd8, 0x49, 0x13, 0x31, 0x34, 0x69, 0x32,
+	0xa7, 0x2f, 0x70, 0x5e, 0x8f, 0x9d, 0xb4, 0x20, 0x87, 0xdb, 0xe8, 0x74, 0xf1, 0x27, 0x1a, 0x80,
+	0x6e, 0xc5, 0x9a, 0x2e, 0xfe, 0x08, 0xe6, 0x24, 0xf2, 0x34, 0x04, 0x23, 0x4b, 0x9d, 0xd7, 0x2d,
+	0x81, 0xf4, 0x46, 0xbc, 0xd4, 0x79, 0x1e, 0x02, 0xa9, 0x63, 0x36, 0x55, 0x43, 0xc8, 0xed, 0xd8,
+	0x6e, 0x03, 0x10, 0xbf, 0x4f, 0x69, 0x8a, 0x7e, 0xa8, 0x9a, 0xb0, 0xe6, 0x3c, 0xa3, 0xa7, 0x58,
+	0x46, 0xf3, 0xa0, 0x80, 0x93, 0xe2, 0x1f, 0x88, 0x64, 0xba, 0x9a, 0xb0, 0x60, 0x1d, 0x9c, 0x5c,
+	0x8f, 0xa2, 0x34, 0x68, 0xfc, 0x63, 0xeb, 0x1f, 0x89, 0xa8, 0x50, 0x4d, 0x58, 0xb0, 0xd4, 0x3f,
+	0x77, 0x32, 0x95, 0x7f, 0xe8, 0xfc, 0x13, 0x51, 0x65, 0x98, 0xca, 0x3f, 0x35, 0x8a, 0x3c, 0xd3,
+	0xc0, 0x7f, 0x26, 0xa2, 0x94, 0xc8, 0x33, 0x0d, 0x99, 0x67, 0x1a, 0xf8, 0x2f, 0x44, 0xa4, 0x4a,
+	0x3c, 0x51, 0xe5, 0x9f, 0xd7, 0xfe, 0x4a, 0x54, 0x53, 0x12, 0xcf, 0x34, 0xd4, 0x63, 0x28, 0x03,
+	0x2a, 0x7a, 0x02, 0xfa, 0x1b, 0x91, 0xcd, 0x56, 0x13, 0x16, 0xac, 0xa6, 0xa7, 0x25, 0x1d, 0x65,
+	0x7d, 0x26, 0x15, 0xfe, 0x9d, 0x08, 0x73, 0xd5, 0x84, 0x05, 0x0e, 0xd8, 0x49, 0x87, 0x45, 0x00,
+	0xc7, 0x9c, 0x7f, 0x10, 0x59, 0x92, 0x45, 0x00, 0x07, 0x15, 0x99, 0x6a, 0x1a, 0xf8, 0x9f, 0x44,
+	0x35, 0x23, 0x53, 0xbd, 0x0b, 0xb0, 0x44, 0x35, 0x0d, 0xfc, 0x2f, 0x22, 0xcc, 0x07, 0xa8, 0x62,
+	0xb4, 0xfe, 0xf1, 0xe0, 0xdf, 0x44, 0xa7, 0xb0, 0x68, 0xfd, 0xf9, 0xce, 0x33, 0x07, 0xc3, 0xfd,
+	0x3f, 0x44, 0x35, 0xc7, 0x33, 0x07, 0xd3, 0x99, 0x45, 0x00, 0xa3, 0xf9, 0xbf, 0x44, 0x94, 0x66,
+	0x11, 0xc0, 0x70, 0xad, 0xa1, 0x3c, 0x68, 0x84, 0xc9, 0xfa, 0xbf, 0x54, 0xfc, 0x17, 0x67, 0xd5,
+	0x84, 0x05, 0xa1, 0xf2, 0x69, 0x7a, 0x0d, 0x15, 0x45, 0x04, 0x9d, 0x2a, 0xff, 0x4f, 0x4d, 0xf4,
+	0xd6, 0xac, 0x9a, 0xb0, 0x0a, 0x1c, 0x44, 0xa7, 0xc8, 0x36, 0x52, 0x69, 0x49, 0x09, 0xb3, 0xf3,
+	0xae, 0x54, 0x9c, 0x57, 0x66, 0xd5, 0x84, 0x95, 0xf7, 0x0b, 0x91, 0xcf, 0xc9, 0xab, 0x68, 0x41,
+	0x06, 0xd0, 0x70, 0xee, 0x4e, 0xc5, 0x7c, 0x5f, 0x56, 0x4d, 0x58, 0x45, 0x11, 0x43, 0x43, 0x61,
+	0xb5, 0x05, 0xcf, 0xb8, 0x8c, 0xef, 0xa1, 0x0f, 0x39, 0x2d, 0x3c, 0xe4, 0x72, 0x50, 0x57, 0xc1,
+	0xf7, 0x46, 0xe9, 0x2a, 0x41, 0xdd, 0x2a, 0xbe, 0x2f, 0x4a, 0xb7, 0xba, 0x74, 0x0d, 0xa5, 0xa5,
+	0x94, 0x7e, 0x83, 0xff, 0x57, 0xb0, 0x74, 0x0a, 0xe5, 0x83, 0x37, 0x76, 0x35, 0x8f, 0x52, 0xd7,
+	0xed, 0x03, 0x0f, 0x78, 0xc8, 0x22, 0x3f, 0xaa, 0x87, 0xd1, 0xf4, 0x8d, 0x9a, 0xd3, 0xb7, 0x71,
+	0xd2, 0xb3, 0xc1, 0x2f, 0x27, 0x93, 0x6b, 0xca, 0xd2, 0x69, 0x54, 0x08, 0x5d, 0xc7, 0x87, 0x39,
+	0x98, 0x16, 0x1d, 0x9c, 0x41, 0x6a, 0xf8, 0xa6, 0x3d, 0xcc, 0x43, 0x21, 0xda, 0xc3, 0xd6, 0xe8,
+	0x1e, 0x32, 0x03, 0x83, 0xf0, 0xaf, 0x0e, 0xc3, 0x1c, 0xa4, 0x06, 0x07, 0x31, 0xa2, 0x07, 0x75,
+	0x70, 0x10, 0x23, 0x7a, 0x98, 0x12, 0x3d, 0xac, 0xa3, 0x62, 0xc4, 0x65, 0x75, 0x98, 0x8b, 0x59,
+	0xd1, 0xc5, 0x06, 0x3a, 0x1c, 0x75, 0x07, 0x1d, 0xe6, 0x23, 0x17, 0x9d, 0x4b, 0x7e, 0xb9, 0x1c,
+	0xe6, 0x20, 0x79, 0x87, 0x38, 0x46, 0x4c, 0xc5, 0xcc, 0x9d, 0xe2, 0x18, 0xd1, 0x47, 0x3e, 0xfa,
+	0x81, 0x08, 0xb7, 0xbc, 0x61, 0x1e, 0x94, 0x01, 0x45, 0xc1, 0xef, 0x6f, 0xc3, 0x3c, 0xcc, 0x45,
+	0xe7, 0x92, 0x5f, 0xcd, 0x86, 0x39, 0x48, 0x8b, 0x0e, 0x0e, 0xd0, 0x42, 0xe4, 0x8d, 0x2b, 0xc2,
+	0xc9, 0xcf, 0x44, 0x27, 0x71, 0x5f, 0xcb, 0x0a, 0xe8, 0x9b, 0x08, 0x0f, 0xba, 0x77, 0x45, 0xd0,
+	0x2f, 0x89, 0xf4, 0x09, 0x5e, 0xd5, 0x0a, 0x5f, 0xa0, 0x8f, 0xbe, 0x35, 0xe0, 0xfa, 0x15, 0xc1,
+	0x3f, 0x27, 0x47, 0x3f, 0xee, 0xbb, 0x5b, 0x01, 0xfb, 0x3b, 0xb4, 0x34, 0xf8, 0xea, 0x15, 0x41,
+	0xfe, 0xa9, 0x1c, 0x79, 0x8c, 0xb7, 0xb9, 0xa1, 0x82, 0x91, 0x2f, 0x60, 0x22, 0x73, 0x7a, 0x58,
+	0x3b, 0x87, 0x9a, 0x0d, 0xdc, 0xad, 0x44, 0x0f, 0x85, 0xd1, 0x3c, 0x6c, 0x0d, 0xf6, 0x90, 0x19,
+	0x6d, 0xa4, 0xc8, 0x17, 0x22, 0xd1, 0x41, 0x6a, 0xf4, 0x20, 0x06, 0x78, 0x50, 0x47, 0x0f, 0x62,
+	0x80, 0x87, 0xa9, 0x61, 0x1e, 0xa0, 0x8b, 0x05, 0xaf, 0x27, 0xa2, 0x8b, 0xd9, 0x11, 0xc3, 0x90,
+	0xef, 0x1d, 0xa2, 0x87, 0xb9, 0x21, 0x1e, 0x96, 0x4b, 0x68, 0x8e, 0x1f, 0x02, 0xe7, 0xd0, 0xf4,
+	0xfa, 0xc5, 0xcb, 0xd5, 0xf5, 0x7c, 0x82, 0xfc, 0xb8, 0x61, 0xad, 0xff, 0xf2, 0x17, 0x79, 0x45,
+	0x9d, 0x47, 0xb3, 0x67, 0xab, 0xeb, 0xd6, 0xc5, 0x0b, 0x9b, 0xf9, 0xe4, 0x46, 0x86, 0x1e, 0x57,
+	0xfb, 0x9d, 0x96, 0xdb, 0x39, 0x5e, 0x46, 0xf3, 0xe2, 0xc1, 0x2b, 0xca, 0x01, 0x52, 0xd3, 0xdc,
+	0xc1, 0x6d, 0x65, 0xe3, 0xf2, 0xaf, 0x7e, 0x1e, 0xaa, 0xdf, 0x15, 0xaf, 0x7e, 0xeb, 0xfd, 0xc6,
+	0x4a, 0xab, 0xd3, 0xb3, 0xf7, 0x3b, 0x35, 0xc7, 0xfb, 0xeb, 0x09, 0xcf, 0xda, 0x5d, 0x71, 0xec,
+	0x66, 0x6d, 0xe7, 0x60, 0x65, 0xd0, 0x1f, 0x5a, 0xd4, 0x67, 0xe0, 0x93, 0xaf, 0x03, 0x00, 0x00,
+	0xff, 0xff, 0xe8, 0x29, 0x22, 0xf1, 0x8b, 0x21, 0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20180814_aa810b61/test.proto b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20180814_aa810b61/test.proto
new file mode 100644
index 000000000..a278ad195
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20180814_aa810b61/test.proto
@@ -0,0 +1,136 @@
+// 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.
+
+syntax = "proto3";
+
+package google.golang.org.proto3_20180814;
+option go_package = "google.golang.org/protobuf/internal/testprotos/legacy/proto3_20180814_aa810b61";
+
+enum SiblingEnum {
+	ALPHA   = 0;
+	BRAVO   = 10;
+	CHARLIE = 200;
+}
+
+message SiblingMessage {
+	string          f1 = 1;
+	repeated string f2 = 2;
+	Message         f3 = 3;
+}
+
+message Message {
+	enum ChildEnum {
+		ALPHA   = 0;
+		BRAVO   = 1;
+		CHARLIE = 2;
+	}
+	message ChildMessage {
+		string          f1 = 1;
+		repeated string f2 = 2;
+		Message         f3 = 3;
+	}
+
+	// Optional fields.
+	bool     optional_bool     = 100;
+	int32    optional_int32    = 101;
+	sint32   optional_sint32   = 102;
+	uint32   optional_uint32   = 103;
+	int64    optional_int64    = 104;
+	sint64   optional_sint64   = 105;
+	uint64   optional_uint64   = 106;
+	fixed32  optional_fixed32  = 107;
+	sfixed32 optional_sfixed32 = 108;
+	float    optional_float    = 109;
+	fixed64  optional_fixed64  = 110;
+	sfixed64 optional_sfixed64 = 111;
+	double   optional_double   = 112;
+	string   optional_string   = 113;
+	bytes    optional_bytes    = 114;
+
+	ChildEnum      optional_child_enum      = 115;
+	ChildMessage   optional_child_message   = 116;
+	SiblingEnum    optional_sibling_enum    = 117;
+	SiblingMessage optional_sibling_message = 118;
+
+	// Repeated fields.
+	repeated bool     repeated_bool     = 200;
+	repeated int32    repeated_int32    = 201;
+	repeated sint32   repeated_sint32   = 202;
+	repeated uint32   repeated_uint32   = 203;
+	repeated int64    repeated_int64    = 204;
+	repeated sint64   repeated_sint64   = 205;
+	repeated uint64   repeated_uint64   = 206;
+	repeated fixed32  repeated_fixed32  = 207;
+	repeated sfixed32 repeated_sfixed32 = 208;
+	repeated float    repeated_float    = 209;
+	repeated fixed64  repeated_fixed64  = 210;
+	repeated sfixed64 repeated_sfixed64 = 211;
+	repeated double   repeated_double   = 212;
+	repeated string   repeated_string   = 213;
+	repeated bytes    repeated_bytes    = 214;
+
+	repeated ChildEnum      repeated_child_enum      = 215;
+	repeated ChildMessage   repeated_child_message   = 216;
+	repeated SiblingEnum    repeated_sibling_enum    = 217;
+	repeated SiblingMessage repeated_sibling_message = 218;
+
+	// Map fields.
+	map<bool, bool>     map_bool_bool     = 300;
+	map<bool, int32>    map_bool_int32    = 301;
+	map<bool, sint32>   map_bool_sint32   = 302;
+	map<bool, uint32>   map_bool_uint32   = 303;
+	map<bool, int64>    map_bool_int64    = 304;
+	map<bool, sint64>   map_bool_sint64   = 305;
+	map<bool, uint64>   map_bool_uint64   = 306;
+	map<bool, fixed32>  map_bool_fixed32  = 307;
+	map<bool, sfixed32> map_bool_sfixed32 = 308;
+	map<bool, float>    map_bool_float    = 309;
+	map<bool, fixed64>  map_bool_fixed64  = 310;
+	map<bool, sfixed64> map_bool_sfixed64 = 311;
+	map<bool, double>   map_bool_double   = 312;
+	map<bool, string>   map_bool_string   = 313;
+	map<bool, bytes>    map_bool_bytes    = 314;
+
+	map<bool, ChildEnum>      map_bool_child_enum      = 315;
+	map<bool, ChildMessage>   map_bool_child_message   = 316;
+	map<bool, SiblingEnum>    map_bool_sibling_enum    = 317;
+	map<bool, SiblingMessage> map_bool_sibling_message = 318;
+
+	map<int32, bool>   map_int32_bool   = 319;
+	map<sint32, bool>  map_sint32_bool  = 320;
+	map<uint32, bool>  map_uint32_bool  = 321;
+	map<int64, bool>   map_int64_bool   = 322;
+	map<sint64, bool>  map_sint64_bool  = 323;
+	map<uint64, bool>  map_uint64_bool  = 324;
+	map<fixed32, bool> map_fixed32_bool = 325;
+	map<string, bool>  map_string_bool  = 326;
+
+	// Oneof fields.
+	oneof oneof_union {
+		bool     oneof_bool     = 400;
+		int32    oneof_int32    = 401;
+		sint32   oneof_sint32   = 402;
+		uint32   oneof_uint32   = 403;
+		int64    oneof_int64    = 404;
+		sint64   oneof_sint64   = 405;
+		uint64   oneof_uint64   = 406;
+		fixed32  oneof_fixed32  = 407;
+		sfixed32 oneof_sfixed32 = 408;
+		float    oneof_float    = 409;
+		fixed64  oneof_fixed64  = 410;
+		sfixed64 oneof_sfixed64 = 411;
+		double   oneof_double   = 412;
+		string   oneof_string   = 413;
+		bytes    oneof_bytes    = 414;
+
+		ChildEnum      oneof_child_enum      = 415;
+		ChildMessage   oneof_child_message   = 416;
+		SiblingEnum    oneof_sibling_enum    = 417;
+		SiblingMessage oneof_sibling_message = 418;
+
+		string oneof_string1 = 419;
+		string oneof_string2 = 420;
+		string oneof_string3 = 421;
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20190205_c823c79e/test.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20190205_c823c79e/test.pb.go
new file mode 100644
index 000000000..250836c4f
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20190205_c823c79e/test.pb.go
@@ -0,0 +1,1262 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: proto3_20190205_c823c79e/test.proto
+
+package proto3_20190205_c823c79e
+
+import (
+	fmt "fmt"
+	math "math"
+
+	proto "google.golang.org/protobuf/internal/protolegacy"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
+
+type SiblingEnum int32
+
+const (
+	SiblingEnum_ALPHA   SiblingEnum = 0
+	SiblingEnum_BRAVO   SiblingEnum = 10
+	SiblingEnum_CHARLIE SiblingEnum = 200
+)
+
+var SiblingEnum_name = map[int32]string{
+	0:   "ALPHA",
+	10:  "BRAVO",
+	200: "CHARLIE",
+}
+
+var SiblingEnum_value = map[string]int32{
+	"ALPHA":   0,
+	"BRAVO":   10,
+	"CHARLIE": 200,
+}
+
+func (x SiblingEnum) String() string {
+	return proto.EnumName(SiblingEnum_name, int32(x))
+}
+
+func (SiblingEnum) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_95cd555ff3d1bc43, []int{0}
+}
+
+type Message_ChildEnum int32
+
+const (
+	Message_ALPHA   Message_ChildEnum = 0
+	Message_BRAVO   Message_ChildEnum = 1
+	Message_CHARLIE Message_ChildEnum = 2
+)
+
+var Message_ChildEnum_name = map[int32]string{
+	0: "ALPHA",
+	1: "BRAVO",
+	2: "CHARLIE",
+}
+
+var Message_ChildEnum_value = map[string]int32{
+	"ALPHA":   0,
+	"BRAVO":   1,
+	"CHARLIE": 2,
+}
+
+func (x Message_ChildEnum) String() string {
+	return proto.EnumName(Message_ChildEnum_name, int32(x))
+}
+
+func (Message_ChildEnum) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_95cd555ff3d1bc43, []int{1, 0}
+}
+
+type SiblingMessage 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"`
+	F3                   *Message `protobuf:"bytes,3,opt,name=f3,proto3" json:"f3,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *SiblingMessage) Reset()         { *m = SiblingMessage{} }
+func (m *SiblingMessage) String() string { return proto.CompactTextString(m) }
+func (*SiblingMessage) ProtoMessage()    {}
+func (*SiblingMessage) Descriptor() ([]byte, []int) {
+	return fileDescriptor_95cd555ff3d1bc43, []int{0}
+}
+
+func (m *SiblingMessage) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_SiblingMessage.Unmarshal(m, b)
+}
+func (m *SiblingMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_SiblingMessage.Marshal(b, m, deterministic)
+}
+func (m *SiblingMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SiblingMessage.Merge(m, src)
+}
+func (m *SiblingMessage) XXX_Size() int {
+	return xxx_messageInfo_SiblingMessage.Size(m)
+}
+func (m *SiblingMessage) XXX_DiscardUnknown() {
+	xxx_messageInfo_SiblingMessage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SiblingMessage proto.InternalMessageInfo
+
+func (m *SiblingMessage) GetF1() string {
+	if m != nil {
+		return m.F1
+	}
+	return ""
+}
+
+func (m *SiblingMessage) GetF2() []string {
+	if m != nil {
+		return m.F2
+	}
+	return nil
+}
+
+func (m *SiblingMessage) GetF3() *Message {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+type Message 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      Message_ChildEnum     `protobuf:"varint,115,opt,name=optional_child_enum,json=optionalChildEnum,proto3,enum=google.golang.org.proto3_20190205.Message_ChildEnum" json:"optional_child_enum,omitempty"`
+	OptionalChildMessage   *Message_ChildMessage `protobuf:"bytes,116,opt,name=optional_child_message,json=optionalChildMessage,proto3" json:"optional_child_message,omitempty"`
+	OptionalSiblingEnum    SiblingEnum           `protobuf:"varint,117,opt,name=optional_sibling_enum,json=optionalSiblingEnum,proto3,enum=google.golang.org.proto3_20190205.SiblingEnum" json:"optional_sibling_enum,omitempty"`
+	OptionalSiblingMessage *SiblingMessage       `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      []Message_ChildEnum     `protobuf:"varint,215,rep,packed,name=repeated_child_enum,json=repeatedChildEnum,proto3,enum=google.golang.org.proto3_20190205.Message_ChildEnum" json:"repeated_child_enum,omitempty"`
+	RepeatedChildMessage   []*Message_ChildMessage `protobuf:"bytes,216,rep,name=repeated_child_message,json=repeatedChildMessage,proto3" json:"repeated_child_message,omitempty"`
+	RepeatedSiblingEnum    []SiblingEnum           `protobuf:"varint,217,rep,packed,name=repeated_sibling_enum,json=repeatedSiblingEnum,proto3,enum=google.golang.org.proto3_20190205.SiblingEnum" json:"repeated_sibling_enum,omitempty"`
+	RepeatedSiblingMessage []*SiblingMessage       `protobuf:"bytes,218,rep,name=repeated_sibling_message,json=repeatedSiblingMessage,proto3" json:"repeated_sibling_message,omitempty"`
+	// Map fields.
+	MapBoolBool           map[bool]bool                  `protobuf:"bytes,300,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,301,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,302,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,303,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,304,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,305,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,306,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,307,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,308,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,309,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,310,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,311,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,312,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,313,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,314,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]Message_ChildEnum     `protobuf:"bytes,315,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_20190205.Message_ChildEnum"`
+	MapBoolChildMessage   map[bool]*Message_ChildMessage `protobuf:"bytes,316,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"`
+	MapBoolSiblingEnum    map[bool]SiblingEnum           `protobuf:"bytes,317,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_20190205.SiblingEnum"`
+	MapBoolSiblingMessage map[bool]*SiblingMessage       `protobuf:"bytes,318,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,319,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,320,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,321,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,322,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,323,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,324,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,325,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,326,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.
+	//
+	// Types that are valid to be assigned to OneofUnion:
+	//	*Message_OneofBool
+	//	*Message_OneofInt32
+	//	*Message_OneofSint32
+	//	*Message_OneofUint32
+	//	*Message_OneofInt64
+	//	*Message_OneofSint64
+	//	*Message_OneofUint64
+	//	*Message_OneofFixed32
+	//	*Message_OneofSfixed32
+	//	*Message_OneofFloat
+	//	*Message_OneofFixed64
+	//	*Message_OneofSfixed64
+	//	*Message_OneofDouble
+	//	*Message_OneofString
+	//	*Message_OneofBytes
+	//	*Message_OneofChildEnum
+	//	*Message_OneofChildMessage
+	//	*Message_OneofSiblingEnum
+	//	*Message_OneofSiblingMessage
+	//	*Message_OneofString1
+	//	*Message_OneofString2
+	//	*Message_OneofString3
+	OneofUnion           isMessage_OneofUnion `protobuf_oneof:"oneof_union"`
+	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
+	XXX_unrecognized     []byte               `json:"-"`
+	XXX_sizecache        int32                `json:"-"`
+}
+
+func (m *Message) Reset()         { *m = Message{} }
+func (m *Message) String() string { return proto.CompactTextString(m) }
+func (*Message) ProtoMessage()    {}
+func (*Message) Descriptor() ([]byte, []int) {
+	return fileDescriptor_95cd555ff3d1bc43, []int{1}
+}
+
+func (m *Message) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Message.Unmarshal(m, b)
+}
+func (m *Message) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Message.Marshal(b, m, deterministic)
+}
+func (m *Message) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Message.Merge(m, src)
+}
+func (m *Message) XXX_Size() int {
+	return xxx_messageInfo_Message.Size(m)
+}
+func (m *Message) XXX_DiscardUnknown() {
+	xxx_messageInfo_Message.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message proto.InternalMessageInfo
+
+func (m *Message) GetOptionalBool() bool {
+	if m != nil {
+		return m.OptionalBool
+	}
+	return false
+}
+
+func (m *Message) GetOptionalInt32() int32 {
+	if m != nil {
+		return m.OptionalInt32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSint32() int32 {
+	if m != nil {
+		return m.OptionalSint32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalUint32() uint32 {
+	if m != nil {
+		return m.OptionalUint32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalInt64() int64 {
+	if m != nil {
+		return m.OptionalInt64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSint64() int64 {
+	if m != nil {
+		return m.OptionalSint64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalUint64() uint64 {
+	if m != nil {
+		return m.OptionalUint64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalFixed32() uint32 {
+	if m != nil {
+		return m.OptionalFixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSfixed32() int32 {
+	if m != nil {
+		return m.OptionalSfixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalFloat() float32 {
+	if m != nil {
+		return m.OptionalFloat
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalFixed64() uint64 {
+	if m != nil {
+		return m.OptionalFixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalSfixed64() int64 {
+	if m != nil {
+		return m.OptionalSfixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalDouble() float64 {
+	if m != nil {
+		return m.OptionalDouble
+	}
+	return 0
+}
+
+func (m *Message) GetOptionalString() string {
+	if m != nil {
+		return m.OptionalString
+	}
+	return ""
+}
+
+func (m *Message) GetOptionalBytes() []byte {
+	if m != nil {
+		return m.OptionalBytes
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalChildEnum() Message_ChildEnum {
+	if m != nil {
+		return m.OptionalChildEnum
+	}
+	return Message_ALPHA
+}
+
+func (m *Message) GetOptionalChildMessage() *Message_ChildMessage {
+	if m != nil {
+		return m.OptionalChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOptionalSiblingEnum() SiblingEnum {
+	if m != nil {
+		return m.OptionalSiblingEnum
+	}
+	return SiblingEnum_ALPHA
+}
+
+func (m *Message) GetOptionalSiblingMessage() *SiblingMessage {
+	if m != nil {
+		return m.OptionalSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedBool() []bool {
+	if m != nil {
+		return m.RepeatedBool
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedInt32() []int32 {
+	if m != nil {
+		return m.RepeatedInt32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSint32() []int32 {
+	if m != nil {
+		return m.RepeatedSint32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedUint32() []uint32 {
+	if m != nil {
+		return m.RepeatedUint32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedInt64() []int64 {
+	if m != nil {
+		return m.RepeatedInt64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSint64() []int64 {
+	if m != nil {
+		return m.RepeatedSint64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedUint64() []uint64 {
+	if m != nil {
+		return m.RepeatedUint64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedFixed32() []uint32 {
+	if m != nil {
+		return m.RepeatedFixed32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSfixed32() []int32 {
+	if m != nil {
+		return m.RepeatedSfixed32
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedFloat() []float32 {
+	if m != nil {
+		return m.RepeatedFloat
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedFixed64() []uint64 {
+	if m != nil {
+		return m.RepeatedFixed64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSfixed64() []int64 {
+	if m != nil {
+		return m.RepeatedSfixed64
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedDouble() []float64 {
+	if m != nil {
+		return m.RepeatedDouble
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedString() []string {
+	if m != nil {
+		return m.RepeatedString
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedBytes() [][]byte {
+	if m != nil {
+		return m.RepeatedBytes
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedChildEnum() []Message_ChildEnum {
+	if m != nil {
+		return m.RepeatedChildEnum
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedChildMessage() []*Message_ChildMessage {
+	if m != nil {
+		return m.RepeatedChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSiblingEnum() []SiblingEnum {
+	if m != nil {
+		return m.RepeatedSiblingEnum
+	}
+	return nil
+}
+
+func (m *Message) GetRepeatedSiblingMessage() []*SiblingMessage {
+	if m != nil {
+		return m.RepeatedSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolBool() map[bool]bool {
+	if m != nil {
+		return m.MapBoolBool
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolInt32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolInt32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSint32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolSint32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolUint32() map[bool]uint32 {
+	if m != nil {
+		return m.MapBoolUint32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolInt64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolInt64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSint64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolSint64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolUint64() map[bool]uint64 {
+	if m != nil {
+		return m.MapBoolUint64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFixed32() map[bool]uint32 {
+	if m != nil {
+		return m.MapBoolFixed32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSfixed32() map[bool]int32 {
+	if m != nil {
+		return m.MapBoolSfixed32
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFloat() map[bool]float32 {
+	if m != nil {
+		return m.MapBoolFloat
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolFixed64() map[bool]uint64 {
+	if m != nil {
+		return m.MapBoolFixed64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSfixed64() map[bool]int64 {
+	if m != nil {
+		return m.MapBoolSfixed64
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolDouble() map[bool]float64 {
+	if m != nil {
+		return m.MapBoolDouble
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolString() map[bool]string {
+	if m != nil {
+		return m.MapBoolString
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolBytes() map[bool][]byte {
+	if m != nil {
+		return m.MapBoolBytes
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolChildEnum() map[bool]Message_ChildEnum {
+	if m != nil {
+		return m.MapBoolChildEnum
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolChildMessage() map[bool]*Message_ChildMessage {
+	if m != nil {
+		return m.MapBoolChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSiblingEnum() map[bool]SiblingEnum {
+	if m != nil {
+		return m.MapBoolSiblingEnum
+	}
+	return nil
+}
+
+func (m *Message) GetMapBoolSiblingMessage() map[bool]*SiblingMessage {
+	if m != nil {
+		return m.MapBoolSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetMapInt32Bool() map[int32]bool {
+	if m != nil {
+		return m.MapInt32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapSint32Bool() map[int32]bool {
+	if m != nil {
+		return m.MapSint32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapUint32Bool() map[uint32]bool {
+	if m != nil {
+		return m.MapUint32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapInt64Bool() map[int64]bool {
+	if m != nil {
+		return m.MapInt64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapSint64Bool() map[int64]bool {
+	if m != nil {
+		return m.MapSint64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapUint64Bool() map[uint64]bool {
+	if m != nil {
+		return m.MapUint64Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapFixed32Bool() map[uint32]bool {
+	if m != nil {
+		return m.MapFixed32Bool
+	}
+	return nil
+}
+
+func (m *Message) GetMapStringBool() map[string]bool {
+	if m != nil {
+		return m.MapStringBool
+	}
+	return nil
+}
+
+type isMessage_OneofUnion interface {
+	isMessage_OneofUnion()
+}
+
+type Message_OneofBool struct {
+	OneofBool bool `protobuf:"varint,400,opt,name=oneof_bool,json=oneofBool,proto3,oneof"`
+}
+
+type Message_OneofInt32 struct {
+	OneofInt32 int32 `protobuf:"varint,401,opt,name=oneof_int32,json=oneofInt32,proto3,oneof"`
+}
+
+type Message_OneofSint32 struct {
+	OneofSint32 int32 `protobuf:"zigzag32,402,opt,name=oneof_sint32,json=oneofSint32,proto3,oneof"`
+}
+
+type Message_OneofUint32 struct {
+	OneofUint32 uint32 `protobuf:"varint,403,opt,name=oneof_uint32,json=oneofUint32,proto3,oneof"`
+}
+
+type Message_OneofInt64 struct {
+	OneofInt64 int64 `protobuf:"varint,404,opt,name=oneof_int64,json=oneofInt64,proto3,oneof"`
+}
+
+type Message_OneofSint64 struct {
+	OneofSint64 int64 `protobuf:"zigzag64,405,opt,name=oneof_sint64,json=oneofSint64,proto3,oneof"`
+}
+
+type Message_OneofUint64 struct {
+	OneofUint64 uint64 `protobuf:"varint,406,opt,name=oneof_uint64,json=oneofUint64,proto3,oneof"`
+}
+
+type Message_OneofFixed32 struct {
+	OneofFixed32 uint32 `protobuf:"fixed32,407,opt,name=oneof_fixed32,json=oneofFixed32,proto3,oneof"`
+}
+
+type Message_OneofSfixed32 struct {
+	OneofSfixed32 int32 `protobuf:"fixed32,408,opt,name=oneof_sfixed32,json=oneofSfixed32,proto3,oneof"`
+}
+
+type Message_OneofFloat struct {
+	OneofFloat float32 `protobuf:"fixed32,409,opt,name=oneof_float,json=oneofFloat,proto3,oneof"`
+}
+
+type Message_OneofFixed64 struct {
+	OneofFixed64 uint64 `protobuf:"fixed64,410,opt,name=oneof_fixed64,json=oneofFixed64,proto3,oneof"`
+}
+
+type Message_OneofSfixed64 struct {
+	OneofSfixed64 int64 `protobuf:"fixed64,411,opt,name=oneof_sfixed64,json=oneofSfixed64,proto3,oneof"`
+}
+
+type Message_OneofDouble struct {
+	OneofDouble float64 `protobuf:"fixed64,412,opt,name=oneof_double,json=oneofDouble,proto3,oneof"`
+}
+
+type Message_OneofString struct {
+	OneofString string `protobuf:"bytes,413,opt,name=oneof_string,json=oneofString,proto3,oneof"`
+}
+
+type Message_OneofBytes struct {
+	OneofBytes []byte `protobuf:"bytes,414,opt,name=oneof_bytes,json=oneofBytes,proto3,oneof"`
+}
+
+type Message_OneofChildEnum struct {
+	OneofChildEnum Message_ChildEnum `protobuf:"varint,415,opt,name=oneof_child_enum,json=oneofChildEnum,proto3,enum=google.golang.org.proto3_20190205.Message_ChildEnum,oneof"`
+}
+
+type Message_OneofChildMessage struct {
+	OneofChildMessage *Message_ChildMessage `protobuf:"bytes,416,opt,name=oneof_child_message,json=oneofChildMessage,proto3,oneof"`
+}
+
+type Message_OneofSiblingEnum struct {
+	OneofSiblingEnum SiblingEnum `protobuf:"varint,417,opt,name=oneof_sibling_enum,json=oneofSiblingEnum,proto3,enum=google.golang.org.proto3_20190205.SiblingEnum,oneof"`
+}
+
+type Message_OneofSiblingMessage struct {
+	OneofSiblingMessage *SiblingMessage `protobuf:"bytes,418,opt,name=oneof_sibling_message,json=oneofSiblingMessage,proto3,oneof"`
+}
+
+type Message_OneofString1 struct {
+	OneofString1 string `protobuf:"bytes,419,opt,name=oneof_string1,json=oneofString1,proto3,oneof"`
+}
+
+type Message_OneofString2 struct {
+	OneofString2 string `protobuf:"bytes,420,opt,name=oneof_string2,json=oneofString2,proto3,oneof"`
+}
+
+type Message_OneofString3 struct {
+	OneofString3 string `protobuf:"bytes,421,opt,name=oneof_string3,json=oneofString3,proto3,oneof"`
+}
+
+func (*Message_OneofBool) isMessage_OneofUnion() {}
+
+func (*Message_OneofInt32) isMessage_OneofUnion() {}
+
+func (*Message_OneofSint32) isMessage_OneofUnion() {}
+
+func (*Message_OneofUint32) isMessage_OneofUnion() {}
+
+func (*Message_OneofInt64) isMessage_OneofUnion() {}
+
+func (*Message_OneofSint64) isMessage_OneofUnion() {}
+
+func (*Message_OneofUint64) isMessage_OneofUnion() {}
+
+func (*Message_OneofFixed32) isMessage_OneofUnion() {}
+
+func (*Message_OneofSfixed32) isMessage_OneofUnion() {}
+
+func (*Message_OneofFloat) isMessage_OneofUnion() {}
+
+func (*Message_OneofFixed64) isMessage_OneofUnion() {}
+
+func (*Message_OneofSfixed64) isMessage_OneofUnion() {}
+
+func (*Message_OneofDouble) isMessage_OneofUnion() {}
+
+func (*Message_OneofString) isMessage_OneofUnion() {}
+
+func (*Message_OneofBytes) isMessage_OneofUnion() {}
+
+func (*Message_OneofChildEnum) isMessage_OneofUnion() {}
+
+func (*Message_OneofChildMessage) isMessage_OneofUnion() {}
+
+func (*Message_OneofSiblingEnum) isMessage_OneofUnion() {}
+
+func (*Message_OneofSiblingMessage) isMessage_OneofUnion() {}
+
+func (*Message_OneofString1) isMessage_OneofUnion() {}
+
+func (*Message_OneofString2) isMessage_OneofUnion() {}
+
+func (*Message_OneofString3) isMessage_OneofUnion() {}
+
+func (m *Message) GetOneofUnion() isMessage_OneofUnion {
+	if m != nil {
+		return m.OneofUnion
+	}
+	return nil
+}
+
+func (m *Message) GetOneofBool() bool {
+	if x, ok := m.GetOneofUnion().(*Message_OneofBool); ok {
+		return x.OneofBool
+	}
+	return false
+}
+
+func (m *Message) GetOneofInt32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofInt32); ok {
+		return x.OneofInt32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSint32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSint32); ok {
+		return x.OneofSint32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofUint32() uint32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofUint32); ok {
+		return x.OneofUint32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofInt64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofInt64); ok {
+		return x.OneofInt64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSint64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSint64); ok {
+		return x.OneofSint64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofUint64() uint64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofUint64); ok {
+		return x.OneofUint64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFixed32() uint32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFixed32); ok {
+		return x.OneofFixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSfixed32() int32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSfixed32); ok {
+		return x.OneofSfixed32
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFloat() float32 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFloat); ok {
+		return x.OneofFloat
+	}
+	return 0
+}
+
+func (m *Message) GetOneofFixed64() uint64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofFixed64); ok {
+		return x.OneofFixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofSfixed64() int64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSfixed64); ok {
+		return x.OneofSfixed64
+	}
+	return 0
+}
+
+func (m *Message) GetOneofDouble() float64 {
+	if x, ok := m.GetOneofUnion().(*Message_OneofDouble); ok {
+		return x.OneofDouble
+	}
+	return 0
+}
+
+func (m *Message) GetOneofString() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString); ok {
+		return x.OneofString
+	}
+	return ""
+}
+
+func (m *Message) GetOneofBytes() []byte {
+	if x, ok := m.GetOneofUnion().(*Message_OneofBytes); ok {
+		return x.OneofBytes
+	}
+	return nil
+}
+
+func (m *Message) GetOneofChildEnum() Message_ChildEnum {
+	if x, ok := m.GetOneofUnion().(*Message_OneofChildEnum); ok {
+		return x.OneofChildEnum
+	}
+	return Message_ALPHA
+}
+
+func (m *Message) GetOneofChildMessage() *Message_ChildMessage {
+	if x, ok := m.GetOneofUnion().(*Message_OneofChildMessage); ok {
+		return x.OneofChildMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOneofSiblingEnum() SiblingEnum {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSiblingEnum); ok {
+		return x.OneofSiblingEnum
+	}
+	return SiblingEnum_ALPHA
+}
+
+func (m *Message) GetOneofSiblingMessage() *SiblingMessage {
+	if x, ok := m.GetOneofUnion().(*Message_OneofSiblingMessage); ok {
+		return x.OneofSiblingMessage
+	}
+	return nil
+}
+
+func (m *Message) GetOneofString1() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString1); ok {
+		return x.OneofString1
+	}
+	return ""
+}
+
+func (m *Message) GetOneofString2() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString2); ok {
+		return x.OneofString2
+	}
+	return ""
+}
+
+func (m *Message) GetOneofString3() string {
+	if x, ok := m.GetOneofUnion().(*Message_OneofString3); ok {
+		return x.OneofString3
+	}
+	return ""
+}
+
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*Message) XXX_OneofWrappers() []interface{} {
+	return []interface{}{
+		(*Message_OneofBool)(nil),
+		(*Message_OneofInt32)(nil),
+		(*Message_OneofSint32)(nil),
+		(*Message_OneofUint32)(nil),
+		(*Message_OneofInt64)(nil),
+		(*Message_OneofSint64)(nil),
+		(*Message_OneofUint64)(nil),
+		(*Message_OneofFixed32)(nil),
+		(*Message_OneofSfixed32)(nil),
+		(*Message_OneofFloat)(nil),
+		(*Message_OneofFixed64)(nil),
+		(*Message_OneofSfixed64)(nil),
+		(*Message_OneofDouble)(nil),
+		(*Message_OneofString)(nil),
+		(*Message_OneofBytes)(nil),
+		(*Message_OneofChildEnum)(nil),
+		(*Message_OneofChildMessage)(nil),
+		(*Message_OneofSiblingEnum)(nil),
+		(*Message_OneofSiblingMessage)(nil),
+		(*Message_OneofString1)(nil),
+		(*Message_OneofString2)(nil),
+		(*Message_OneofString3)(nil),
+	}
+}
+
+type Message_ChildMessage 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"`
+	F3                   *Message `protobuf:"bytes,3,opt,name=f3,proto3" json:"f3,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Message_ChildMessage) Reset()         { *m = Message_ChildMessage{} }
+func (m *Message_ChildMessage) String() string { return proto.CompactTextString(m) }
+func (*Message_ChildMessage) ProtoMessage()    {}
+func (*Message_ChildMessage) Descriptor() ([]byte, []int) {
+	return fileDescriptor_95cd555ff3d1bc43, []int{1, 0}
+}
+
+func (m *Message_ChildMessage) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Message_ChildMessage.Unmarshal(m, b)
+}
+func (m *Message_ChildMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Message_ChildMessage.Marshal(b, m, deterministic)
+}
+func (m *Message_ChildMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Message_ChildMessage.Merge(m, src)
+}
+func (m *Message_ChildMessage) XXX_Size() int {
+	return xxx_messageInfo_Message_ChildMessage.Size(m)
+}
+func (m *Message_ChildMessage) XXX_DiscardUnknown() {
+	xxx_messageInfo_Message_ChildMessage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message_ChildMessage proto.InternalMessageInfo
+
+func (m *Message_ChildMessage) GetF1() string {
+	if m != nil {
+		return m.F1
+	}
+	return ""
+}
+
+func (m *Message_ChildMessage) GetF2() []string {
+	if m != nil {
+		return m.F2
+	}
+	return nil
+}
+
+func (m *Message_ChildMessage) GetF3() *Message {
+	if m != nil {
+		return m.F3
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterEnum("google.golang.org.proto3_20190205.SiblingEnum", SiblingEnum_name, SiblingEnum_value)
+	proto.RegisterEnum("google.golang.org.proto3_20190205.Message_ChildEnum", Message_ChildEnum_name, Message_ChildEnum_value)
+	proto.RegisterType((*SiblingMessage)(nil), "google.golang.org.proto3_20190205.SiblingMessage")
+	proto.RegisterType((*Message)(nil), "google.golang.org.proto3_20190205.Message")
+	proto.RegisterMapType((map[bool]bool)(nil), "google.golang.org.proto3_20190205.Message.MapBoolBoolEntry")
+	proto.RegisterMapType((map[bool][]byte)(nil), "google.golang.org.proto3_20190205.Message.MapBoolBytesEntry")
+	proto.RegisterMapType((map[bool]Message_ChildEnum)(nil), "google.golang.org.proto3_20190205.Message.MapBoolChildEnumEntry")
+	proto.RegisterMapType((map[bool]*Message_ChildMessage)(nil), "google.golang.org.proto3_20190205.Message.MapBoolChildMessageEntry")
+	proto.RegisterMapType((map[bool]float64)(nil), "google.golang.org.proto3_20190205.Message.MapBoolDoubleEntry")
+	proto.RegisterMapType((map[bool]uint32)(nil), "google.golang.org.proto3_20190205.Message.MapBoolFixed32Entry")
+	proto.RegisterMapType((map[bool]uint64)(nil), "google.golang.org.proto3_20190205.Message.MapBoolFixed64Entry")
+	proto.RegisterMapType((map[bool]float32)(nil), "google.golang.org.proto3_20190205.Message.MapBoolFloatEntry")
+	proto.RegisterMapType((map[bool]int32)(nil), "google.golang.org.proto3_20190205.Message.MapBoolInt32Entry")
+	proto.RegisterMapType((map[bool]int64)(nil), "google.golang.org.proto3_20190205.Message.MapBoolInt64Entry")
+	proto.RegisterMapType((map[bool]int32)(nil), "google.golang.org.proto3_20190205.Message.MapBoolSfixed32Entry")
+	proto.RegisterMapType((map[bool]int64)(nil), "google.golang.org.proto3_20190205.Message.MapBoolSfixed64Entry")
+	proto.RegisterMapType((map[bool]SiblingEnum)(nil), "google.golang.org.proto3_20190205.Message.MapBoolSiblingEnumEntry")
+	proto.RegisterMapType((map[bool]*SiblingMessage)(nil), "google.golang.org.proto3_20190205.Message.MapBoolSiblingMessageEntry")
+	proto.RegisterMapType((map[bool]int32)(nil), "google.golang.org.proto3_20190205.Message.MapBoolSint32Entry")
+	proto.RegisterMapType((map[bool]int64)(nil), "google.golang.org.proto3_20190205.Message.MapBoolSint64Entry")
+	proto.RegisterMapType((map[bool]string)(nil), "google.golang.org.proto3_20190205.Message.MapBoolStringEntry")
+	proto.RegisterMapType((map[bool]uint32)(nil), "google.golang.org.proto3_20190205.Message.MapBoolUint32Entry")
+	proto.RegisterMapType((map[bool]uint64)(nil), "google.golang.org.proto3_20190205.Message.MapBoolUint64Entry")
+	proto.RegisterMapType((map[uint32]bool)(nil), "google.golang.org.proto3_20190205.Message.MapFixed32BoolEntry")
+	proto.RegisterMapType((map[int32]bool)(nil), "google.golang.org.proto3_20190205.Message.MapInt32BoolEntry")
+	proto.RegisterMapType((map[int64]bool)(nil), "google.golang.org.proto3_20190205.Message.MapInt64BoolEntry")
+	proto.RegisterMapType((map[int32]bool)(nil), "google.golang.org.proto3_20190205.Message.MapSint32BoolEntry")
+	proto.RegisterMapType((map[int64]bool)(nil), "google.golang.org.proto3_20190205.Message.MapSint64BoolEntry")
+	proto.RegisterMapType((map[string]bool)(nil), "google.golang.org.proto3_20190205.Message.MapStringBoolEntry")
+	proto.RegisterMapType((map[uint32]bool)(nil), "google.golang.org.proto3_20190205.Message.MapUint32BoolEntry")
+	proto.RegisterMapType((map[uint64]bool)(nil), "google.golang.org.proto3_20190205.Message.MapUint64BoolEntry")
+	proto.RegisterType((*Message_ChildMessage)(nil), "google.golang.org.proto3_20190205.Message.ChildMessage")
+}
+
+func init() {
+	proto.RegisterFile("proto3_20190205_c823c79e/test.proto", fileDescriptor_95cd555ff3d1bc43)
+}
+
+var fileDescriptor_95cd555ff3d1bc43 = []byte{
+	// 1947 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x9a, 0x59, 0x73, 0xdb, 0xc8,
+	0x11, 0xc7, 0x09, 0x52, 0x87, 0x35, 0xe2, 0x09, 0x5a, 0xca, 0x94, 0x9e, 0x10, 0xd9, 0x71, 0x10,
+	0x27, 0x45, 0x59, 0x24, 0x02, 0x1f, 0x49, 0x6c, 0x4b, 0xb6, 0x1c, 0x3a, 0x65, 0x27, 0x2e, 0xb8,
+	0x94, 0x87, 0xbc, 0x28, 0x94, 0x04, 0xd2, 0xb4, 0x41, 0x42, 0x11, 0x49, 0x57, 0x54, 0x79, 0xf0,
+	0x57, 0xc8, 0x7d, 0xef, 0xbd, 0xfb, 0xb6, 0xf7, 0x7d, 0xdf, 0xde, 0xf2, 0xde, 0xf7, 0xf9, 0x69,
+	0xb6, 0x06, 0x8d, 0xb9, 0x00, 0xd0, 0x24, 0xc1, 0xda, 0x07, 0x57, 0x49, 0xcd, 0xff, 0xf4, 0x8f,
+	0xdd, 0xe8, 0xe9, 0x9e, 0x81, 0x85, 0x0e, 0xec, 0xec, 0xba, 0x5d, 0xb7, 0xb2, 0x51, 0x3e, 0xb2,
+	0x7c, 0xfc, 0x48, 0xf9, 0xc8, 0x4f, 0x37, 0xb6, 0x8e, 0x95, 0x2b, 0x5b, 0x47, 0x8f, 0xdb, 0x4b,
+	0x5d, 0xbb, 0xd3, 0x2d, 0x79, 0x9f, 0xaa, 0xdf, 0x6f, 0xb8, 0x6e, 0xc3, 0xb1, 0x4b, 0x0d, 0xd7,
+	0xa9, 0xb5, 0x1b, 0x25, 0x77, 0xb7, 0x51, 0x0a, 0x2c, 0x5b, 0x74, 0x50, 0xf6, 0x72, 0x73, 0xd3,
+	0x69, 0xb6, 0x1b, 0x17, 0xed, 0x4e, 0xa7, 0xd6, 0xb0, 0xd5, 0x2c, 0x4a, 0xd6, 0x97, 0xb1, 0xa2,
+	0x29, 0xfa, 0x8c, 0x95, 0xac, 0x2f, 0x7b, 0xbf, 0x97, 0x71, 0x52, 0x4b, 0x79, 0xbf, 0x97, 0xd5,
+	0x13, 0x28, 0x59, 0xaf, 0xe0, 0x94, 0xa6, 0xe8, 0xb3, 0xe5, 0xc3, 0xa5, 0x81, 0x84, 0x92, 0xef,
+	0xd7, 0x4a, 0xd6, 0x2b, 0x8b, 0x37, 0x4f, 0xa3, 0x69, 0xca, 0x39, 0x80, 0x32, 0xee, 0x4e, 0xb7,
+	0xe9, 0xb6, 0x6b, 0xce, 0xc6, 0xa6, 0xeb, 0x3a, 0x78, 0x5b, 0x53, 0xf4, 0x7d, 0x56, 0x9a, 0x1a,
+	0x57, 0x5d, 0xd7, 0x51, 0x7f, 0x80, 0xb2, 0x4c, 0xd4, 0x6c, 0x77, 0x2b, 0x65, 0x6c, 0x6b, 0x8a,
+	0x3e, 0x69, 0xb1, 0xa5, 0xe7, 0x89, 0x51, 0xfd, 0x21, 0xca, 0x31, 0x59, 0x07, 0x74, 0x75, 0x4d,
+	0xd1, 0x0b, 0x16, 0x5b, 0x7d, 0xb9, 0x19, 0x12, 0xf6, 0x40, 0xd8, 0xd0, 0x14, 0x3d, 0xc3, 0x85,
+	0xeb, 0x20, 0x0c, 0x80, 0x4d, 0x03, 0x5f, 0xd1, 0x14, 0x3d, 0x25, 0x81, 0x4d, 0x23, 0x04, 0x36,
+	0x0d, 0xdc, 0xd4, 0x14, 0x5d, 0x95, 0xc1, 0x01, 0x61, 0x0f, 0x84, 0x57, 0x35, 0x45, 0x9f, 0x90,
+	0xc1, 0xa6, 0xa1, 0xfe, 0x08, 0xe5, 0x99, 0xb0, 0xde, 0xfc, 0xa3, 0xbd, 0x5d, 0x29, 0xe3, 0x6b,
+	0x9a, 0xa2, 0x4f, 0x5b, 0xcc, 0xc1, 0x39, 0x30, 0xab, 0x3f, 0x46, 0x05, 0x0e, 0xa7, 0x5a, 0x47,
+	0x53, 0xf4, 0x9c, 0xc5, 0x7c, 0x5c, 0xf6, 0xed, 0x52, 0x40, 0x75, 0xc7, 0xad, 0x75, 0x71, 0x4b,
+	0x53, 0xf4, 0x24, 0x0f, 0xe8, 0x1c, 0x31, 0x86, 0xf1, 0xa6, 0x81, 0xdb, 0x9a, 0xa2, 0x4f, 0x05,
+	0xf0, 0xa6, 0x11, 0x81, 0x37, 0x0d, 0xec, 0x6a, 0x8a, 0x9e, 0x0f, 0xe2, 0x03, 0xf1, 0x6f, 0xbb,
+	0xbd, 0x4d, 0xc7, 0xc6, 0x3b, 0x9a, 0xa2, 0x2b, 0x3c, 0xfe, 0xb3, 0x9e, 0x55, 0xce, 0x68, 0x77,
+	0xb7, 0xd9, 0x6e, 0xe0, 0x3f, 0x78, 0xb5, 0xc8, 0x33, 0xea, 0x59, 0xa5, 0x80, 0x36, 0xf7, 0xba,
+	0x76, 0x07, 0xef, 0x6a, 0x8a, 0x9e, 0xe6, 0x01, 0xad, 0x12, 0xa3, 0xba, 0x8d, 0x8a, 0x4c, 0xb6,
+	0x75, 0xa5, 0xe9, 0x6c, 0x6f, 0xd8, 0xed, 0x5e, 0x0b, 0x77, 0x34, 0x45, 0xcf, 0x96, 0x8d, 0xe1,
+	0xeb, 0xb7, 0x74, 0x86, 0x2c, 0x5e, 0x6b, 0xf7, 0x5a, 0x16, 0x0b, 0x9b, 0x99, 0xd4, 0x16, 0x9a,
+	0x0f, 0x50, 0x5a, 0xb0, 0x0c, 0x77, 0xbd, 0x8d, 0x72, 0x74, 0x54, 0x10, 0xdd, 0x35, 0xfb, 0x25,
+	0x16, 0xdd, 0x3b, 0x9b, 0x68, 0x4e, 0x28, 0x3b, 0x6f, 0xfb, 0x42, 0x58, 0x3d, 0x2f, 0xac, 0xd2,
+	0x10, 0x34, 0x7f, 0xd7, 0x7b, 0x01, 0x15, 0x79, 0xb1, 0x32, 0xa3, 0x7a, 0x0d, 0xe1, 0x10, 0x83,
+	0x06, 0x75, 0xdd, 0x0b, 0x6a, 0x79, 0x78, 0x0c, 0x0d, 0x67, 0x3e, 0x40, 0xa2, 0x01, 0x1d, 0x44,
+	0x99, 0x5d, 0x7b, 0xc7, 0xae, 0x75, 0xed, 0x6d, 0x68, 0x06, 0xb7, 0x14, 0x2d, 0x45, 0xba, 0x01,
+	0xb5, 0x7a, 0xdd, 0xe0, 0x10, 0xca, 0x32, 0x15, 0x6c, 0xde, 0xb7, 0x89, 0x6c, 0xd2, 0x62, 0x8b,
+	0xa1, 0x1d, 0xe8, 0x28, 0xc7, 0x74, 0x7e, 0x3b, 0x78, 0x87, 0x08, 0x0b, 0x16, 0x5b, 0xef, 0xf7,
+	0x03, 0x51, 0xe9, 0xf7, 0x83, 0x77, 0x89, 0x32, 0xc3, 0x95, 0x7e, 0x43, 0x08, 0xb0, 0x4d, 0x03,
+	0xbf, 0x47, 0x84, 0x29, 0x89, 0x6d, 0x1a, 0x21, 0xb6, 0x69, 0xe0, 0xf7, 0x89, 0x50, 0x95, 0xd9,
+	0x01, 0xa5, 0xdf, 0x12, 0x3e, 0x20, 0xca, 0x09, 0x99, 0x6d, 0x1a, 0xea, 0x61, 0x94, 0x67, 0x4a,
+	0xba, 0xcf, 0x3f, 0x24, 0xd2, 0x69, 0x8b, 0xb9, 0xa0, 0x4d, 0xe1, 0x27, 0xa8, 0xc0, 0xf9, 0x54,
+	0xfc, 0x11, 0x11, 0xe7, 0x2c, 0xe6, 0x85, 0x75, 0x05, 0x31, 0x2a, 0xe8, 0x0a, 0x1f, 0x13, 0x69,
+	0x92, 0x47, 0x05, 0x6d, 0x21, 0xf4, 0x0d, 0x4c, 0x03, 0x7f, 0x42, 0x94, 0x53, 0x81, 0x6f, 0x60,
+	0x1a, 0x11, 0xdf, 0xc0, 0x34, 0xf0, 0xa7, 0x44, 0x9c, 0x0f, 0x7e, 0x83, 0x40, 0x16, 0xfc, 0xc6,
+	0xf0, 0x19, 0xd1, 0x2a, 0x3c, 0x0b, 0x7e, 0x67, 0x90, 0x32, 0x0b, 0x9d, 0xe1, 0x73, 0xc5, 0x1b,
+	0x4b, 0x3c, 0xb3, 0xd0, 0x1a, 0xc4, 0xa8, 0xa0, 0x35, 0x7c, 0x41, 0x84, 0x69, 0x1e, 0x15, 0xf4,
+	0x06, 0x1b, 0x15, 0x99, 0x4e, 0xe8, 0x0d, 0x5f, 0x12, 0x71, 0xec, 0xe6, 0x40, 0x3d, 0xf2, 0xe6,
+	0xd0, 0x46, 0xf3, 0x01, 0x0c, 0xdd, 0x47, 0x5f, 0x11, 0xd2, 0x38, 0xdd, 0x41, 0x82, 0xd1, 0xcd,
+	0xb4, 0x85, 0xe6, 0x84, 0x12, 0x14, 0xba, 0xc3, 0xd7, 0x10, 0xd8, 0xc8, 0xed, 0x81, 0x17, 0x2e,
+	0x6f, 0x0f, 0x0e, 0xc2, 0x21, 0x08, 0x0d, 0xeb, 0x1b, 0x08, 0x2b, 0x4e, 0x7f, 0x08, 0xa0, 0x68,
+	0x48, 0xbf, 0x47, 0x99, 0x56, 0x6d, 0xc7, 0x6b, 0x0d, 0xd0, 0x1f, 0x1e, 0x4c, 0x7a, 0x88, 0x9f,
+	0x8d, 0x90, 0xb9, 0x8b, 0xb5, 0x1d, 0xd2, 0x45, 0xc8, 0xbf, 0xb5, 0x76, 0x77, 0x77, 0xcf, 0x9a,
+	0x6d, 0x71, 0x8b, 0xba, 0x85, 0xb2, 0x8c, 0x00, 0x8d, 0xe0, 0x21, 0x40, 0xfc, 0x7c, 0x74, 0x84,
+	0xd7, 0x85, 0x80, 0x91, 0x6e, 0x09, 0x26, 0xb5, 0x8e, 0x72, 0x0c, 0xe2, 0x37, 0xa6, 0x87, 0x81,
+	0xf2, 0x8b, 0xd1, 0x29, 0xd0, 0xc2, 0x00, 0x93, 0x69, 0x89, 0x36, 0x89, 0xe3, 0xb7, 0xb5, 0x47,
+	0x62, 0x73, 0xd6, 0x23, 0x38, 0x7e, 0x53, 0x0c, 0x24, 0xcd, 0x34, 0xf0, 0xa3, 0xe3, 0x24, 0xcd,
+	0x34, 0x42, 0x49, 0x33, 0x8d, 0x50, 0xd2, 0x4c, 0x03, 0x3f, 0x36, 0x56, 0xd2, 0x28, 0x46, 0x4c,
+	0x5a, 0x80, 0xe3, 0xf7, 0xe3, 0xc7, 0xc7, 0x4a, 0x5a, 0x90, 0xe3, 0x77, 0xf3, 0x26, 0xca, 0x33,
+	0x0e, 0x6d, 0xd0, 0x4f, 0x00, 0xe8, 0xe4, 0xe8, 0x20, 0xbf, 0xef, 0x03, 0x29, 0xdb, 0x92, 0x8c,
+	0xaa, 0x83, 0x0a, 0x3c, 0x75, 0x94, 0xf5, 0x24, 0xb0, 0x4e, 0xc5, 0x48, 0x5e, 0x5d, 0x84, 0xe5,
+	0x5a, 0xb2, 0x55, 0xaa, 0x06, 0x18, 0x26, 0x4f, 0xc5, 0xae, 0x06, 0x6f, 0xec, 0xc8, 0xd5, 0x00,
+	0x93, 0x28, 0x94, 0x3d, 0xd3, 0xc0, 0x4f, 0x8f, 0x97, 0x3d, 0xfa, 0x9c, 0xa4, 0xec, 0x99, 0x46,
+	0x44, 0xf6, 0x4c, 0x03, 0x3f, 0x33, 0x66, 0xf6, 0x28, 0x4c, 0xce, 0x5e, 0xa0, 0xfc, 0xfc, 0x41,
+	0xf8, 0x6c, 0xec, 0xf2, 0x83, 0x91, 0x29, 0x97, 0x9f, 0x3f, 0x46, 0xa5, 0xed, 0x04, 0x63, 0xf4,
+	0xb9, 0xf8, 0xdb, 0xc9, 0x73, 0x10, 0xd8, 0x4e, 0x30, 0x84, 0xc5, 0x6a, 0x80, 0x21, 0xfc, 0x7c,
+	0xec, 0x6a, 0xf0, 0xc6, 0xb5, 0x5c, 0x0d, 0x30, 0xc1, 0x77, 0x50, 0x91, 0x41, 0x84, 0x09, 0xfe,
+	0x02, 0x90, 0x4e, 0x8f, 0x4e, 0x62, 0x53, 0x1b, 0x68, 0xf9, 0x56, 0xc0, 0xac, 0xee, 0xa1, 0xf9,
+	0x00, 0x91, 0x4e, 0xbd, 0x17, 0x01, 0x7a, 0x26, 0x26, 0xd4, 0xb7, 0x01, 0xb7, 0xd8, 0x0a, 0x7f,
+	0xa2, 0x5e, 0x47, 0x73, 0x42, 0x23, 0x14, 0xe6, 0xfa, 0x4b, 0x40, 0x5e, 0x8d, 0xd3, 0x0e, 0xd9,
+	0x44, 0x07, 0xb0, 0xda, 0x0a, 0x7d, 0xa0, 0xde, 0x40, 0x38, 0xc4, 0xa5, 0x41, 0xbf, 0x0c, 0xe8,
+	0xb5, 0xd8, 0x68, 0x29, 0xec, 0xb9, 0x56, 0xd4, 0x67, 0xb4, 0x94, 0xbc, 0x99, 0x03, 0xe3, 0xff,
+	0x95, 0x58, 0xa5, 0xe4, 0x0d, 0x61, 0x3e, 0xff, 0x49, 0x29, 0x31, 0x13, 0xdd, 0x17, 0x1d, 0x81,
+	0xf2, 0x6a, 0xac, 0x7d, 0x01, 0x33, 0x98, 0x63, 0xc8, 0xbe, 0xe0, 0x36, 0xca, 0xe9, 0x09, 0x9c,
+	0xd7, 0x62, 0x71, 0xd6, 0x23, 0x38, 0xdc, 0x26, 0x24, 0xcd, 0x34, 0x00, 0xf3, 0x7a, 0xdc, 0xa4,
+	0x99, 0x46, 0x28, 0x69, 0x60, 0x12, 0x93, 0x46, 0x29, 0x6f, 0xc4, 0x4e, 0x9a, 0x88, 0xa1, 0x49,
+	0x93, 0x39, 0x3d, 0x81, 0xf3, 0x66, 0xec, 0xa4, 0x05, 0x39, 0xdc, 0x46, 0xa7, 0x8b, 0x3f, 0xd1,
+	0x00, 0x74, 0x33, 0xd6, 0x74, 0xf1, 0x47, 0x30, 0x27, 0x91, 0xa7, 0x21, 0x18, 0x59, 0xea, 0xbc,
+	0x6e, 0x09, 0xa4, 0xb7, 0xe2, 0xa5, 0xce, 0xf3, 0x10, 0x48, 0x1d, 0xb3, 0xa9, 0x1a, 0x42, 0x6e,
+	0xdb, 0x76, 0xeb, 0x80, 0xf8, 0x73, 0x4a, 0x53, 0xf4, 0x7d, 0xd5, 0x84, 0x35, 0xe3, 0x19, 0x3d,
+	0xc5, 0x22, 0x9a, 0x05, 0x05, 0x9c, 0x14, 0xff, 0x42, 0x24, 0x93, 0xd5, 0x84, 0x05, 0xeb, 0xe0,
+	0xe4, 0x7a, 0x10, 0xa5, 0x41, 0xe3, 0x1f, 0x5b, 0xff, 0x4a, 0x44, 0x85, 0x6a, 0xc2, 0x82, 0xa5,
+	0xfe, 0xb9, 0x93, 0xa9, 0xfc, 0x43, 0xe7, 0xdf, 0x88, 0x2a, 0xc3, 0x54, 0xfe, 0xa9, 0x51, 0xe4,
+	0x99, 0x06, 0xfe, 0x3b, 0x11, 0xa5, 0x44, 0x9e, 0x69, 0xc8, 0x3c, 0xd3, 0xc0, 0xff, 0x20, 0x22,
+	0x55, 0xe2, 0x89, 0x2a, 0xff, 0xbc, 0xf6, 0x4f, 0xa2, 0x9a, 0x90, 0x78, 0xa6, 0xa1, 0x1e, 0x42,
+	0x19, 0x50, 0xd1, 0x13, 0xd0, 0xbf, 0x88, 0x6c, 0xba, 0x9a, 0xb0, 0x60, 0x35, 0x3d, 0x2d, 0xe9,
+	0x28, 0xeb, 0x33, 0xa9, 0xf0, 0xdf, 0x44, 0x98, 0xab, 0x26, 0x2c, 0x70, 0xc0, 0x4e, 0x3a, 0x2c,
+	0x02, 0x38, 0xe6, 0xfc, 0x87, 0xc8, 0x92, 0x2c, 0x02, 0x38, 0xa8, 0xc8, 0x54, 0xd3, 0xc0, 0xff,
+	0x25, 0xaa, 0x29, 0x99, 0xea, 0x5d, 0x80, 0x25, 0xaa, 0x69, 0xe0, 0xff, 0x11, 0x61, 0x3e, 0x40,
+	0x15, 0xa3, 0xf5, 0x8f, 0x07, 0xff, 0x27, 0x3a, 0x85, 0x45, 0xeb, 0xcf, 0x77, 0x9e, 0x39, 0x18,
+	0xee, 0x77, 0x10, 0xd5, 0x0c, 0xcf, 0x1c, 0x4c, 0x67, 0x16, 0x01, 0x8c, 0xe6, 0x3b, 0x89, 0x28,
+	0xcd, 0x22, 0x80, 0xe1, 0x5a, 0x43, 0x79, 0xd0, 0x08, 0x93, 0xf5, 0xae, 0x54, 0xfc, 0x17, 0x67,
+	0xd5, 0x84, 0x05, 0xa1, 0xf2, 0x69, 0x7a, 0x15, 0x15, 0x45, 0x04, 0x9d, 0x2a, 0x77, 0xa7, 0xc6,
+	0x7a, 0x6b, 0x56, 0x4d, 0x58, 0x05, 0x0e, 0xa2, 0x53, 0x64, 0x03, 0xa9, 0xb4, 0xa4, 0x84, 0xd9,
+	0x79, 0x4f, 0x2a, 0xce, 0x2b, 0xb3, 0x6a, 0xc2, 0xca, 0xfb, 0x85, 0xc8, 0xe7, 0xe4, 0x15, 0x34,
+	0x27, 0x03, 0x68, 0x38, 0xf7, 0xa6, 0x62, 0xbe, 0x2f, 0xab, 0x26, 0xac, 0xa2, 0x88, 0xa1, 0xa1,
+	0xb0, 0xda, 0x82, 0x67, 0xbc, 0x8c, 0xef, 0xa3, 0x0f, 0x39, 0x2d, 0x3c, 0xe4, 0xe5, 0xa0, 0xae,
+	0x8c, 0xef, 0x8f, 0xd2, 0x95, 0x83, 0xba, 0x0a, 0x7e, 0x20, 0x4a, 0x57, 0x59, 0xb8, 0x8a, 0xd2,
+	0x52, 0x4a, 0xbf, 0xc3, 0xff, 0x2b, 0x58, 0x38, 0x89, 0xf2, 0xc1, 0x1b, 0xbb, 0x9a, 0x47, 0xa9,
+	0x6b, 0xf6, 0x9e, 0x07, 0xdc, 0x67, 0x91, 0x1f, 0xd5, 0xfd, 0x68, 0xf2, 0x7a, 0xcd, 0xe9, 0xd9,
+	0x38, 0xe9, 0xd9, 0xe0, 0x97, 0x13, 0xc9, 0x63, 0xca, 0xc2, 0x29, 0x54, 0x08, 0x5d, 0xc7, 0x07,
+	0x39, 0x98, 0x14, 0x1d, 0x9c, 0x46, 0x6a, 0xf8, 0xa6, 0x3d, 0xc8, 0x43, 0x21, 0xda, 0xc3, 0xfa,
+	0xf0, 0x1e, 0x32, 0x7d, 0x83, 0xf0, 0xaf, 0x0e, 0x83, 0x1c, 0xa4, 0xfa, 0x07, 0x31, 0xa4, 0x07,
+	0xb5, 0x7f, 0x10, 0x43, 0x7a, 0x98, 0x10, 0x3d, 0xac, 0xa0, 0x62, 0xc4, 0x65, 0x75, 0x90, 0x8b,
+	0x69, 0xd1, 0xc5, 0x2a, 0xda, 0x1f, 0x75, 0x07, 0x1d, 0xe4, 0x23, 0x17, 0x9d, 0x4b, 0x7e, 0xb9,
+	0x1c, 0xe4, 0x20, 0x79, 0x9b, 0x38, 0x86, 0x4c, 0xc5, 0xd4, 0xed, 0xe2, 0x18, 0xd2, 0x47, 0x3e,
+	0xfa, 0x81, 0x08, 0xb7, 0xbc, 0x41, 0x1e, 0x94, 0x3e, 0x45, 0xc1, 0xef, 0x6f, 0x83, 0x3c, 0xcc,
+	0x44, 0xe7, 0x92, 0x5f, 0xcd, 0x06, 0x39, 0x48, 0x8b, 0x0e, 0xf6, 0xd0, 0x5c, 0xe4, 0x8d, 0x2b,
+	0xc2, 0xc9, 0xaf, 0x44, 0x27, 0x71, 0x5f, 0xcb, 0x0a, 0xe8, 0x1b, 0x08, 0xf7, 0xbb, 0x77, 0x45,
+	0xd0, 0x2f, 0x8a, 0xf4, 0x31, 0x5e, 0xd5, 0x0a, 0x5f, 0xa0, 0x87, 0xbe, 0xd7, 0xe7, 0xfa, 0x15,
+	0xc1, 0x3f, 0x2b, 0x47, 0x3f, 0xea, 0xbb, 0x5b, 0x01, 0xfb, 0x27, 0xb4, 0xd0, 0xff, 0xea, 0x15,
+	0x41, 0xfe, 0xa5, 0x1c, 0x79, 0x8c, 0xb7, 0xb9, 0xa1, 0x82, 0x91, 0x2f, 0x60, 0x22, 0x73, 0x72,
+	0x50, 0x3b, 0x87, 0x9a, 0x0d, 0xdc, 0xad, 0x44, 0x0f, 0x85, 0xe1, 0x3c, 0xac, 0xf7, 0xf7, 0x90,
+	0x19, 0x6e, 0xa4, 0xc8, 0x17, 0x22, 0xd1, 0x41, 0x6a, 0xf8, 0x20, 0xfa, 0x78, 0x50, 0x87, 0x0f,
+	0xa2, 0x8f, 0x87, 0x89, 0x41, 0x1e, 0xa0, 0x8b, 0x05, 0xaf, 0x27, 0xa2, 0x8b, 0xe9, 0x21, 0xc3,
+	0x90, 0xef, 0x1d, 0xa2, 0x87, 0x99, 0x01, 0x1e, 0x16, 0x4b, 0x68, 0x86, 0x1f, 0x02, 0x67, 0xd0,
+	0xe4, 0xca, 0x85, 0x4b, 0xd5, 0x95, 0x7c, 0x82, 0xfc, 0xb8, 0x6a, 0xad, 0xfc, 0xf6, 0x37, 0x79,
+	0x45, 0x9d, 0x45, 0xd3, 0x67, 0xaa, 0x2b, 0xd6, 0x85, 0xf3, 0x6b, 0xf9, 0xe4, 0x6a, 0x86, 0x1e,
+	0x57, 0x7b, 0xed, 0xa6, 0xdb, 0x3e, 0xbc, 0x8c, 0x66, 0xc5, 0x83, 0x57, 0x94, 0x03, 0xa4, 0xa6,
+	0xb9, 0x83, 0x5b, 0xca, 0xea, 0xa5, 0xdf, 0xfd, 0x3a, 0x54, 0xbf, 0x4b, 0x5e, 0xfd, 0x6e, 0xf6,
+	0xea, 0x4b, 0xcd, 0x76, 0xd7, 0xde, 0x6d, 0xd7, 0x1c, 0xef, 0xaf, 0x27, 0x3c, 0x6b, 0x67, 0xc9,
+	0xb1, 0x1b, 0xb5, 0xad, 0xbd, 0xa5, 0x7e, 0x7f, 0x68, 0xb1, 0x39, 0x05, 0x9f, 0x7c, 0x1b, 0x00,
+	0x00, 0xff, 0xff, 0x57, 0xd9, 0x0f, 0xc0, 0x8b, 0x21, 0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20190205_c823c79e/test.proto b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20190205_c823c79e/test.proto
new file mode 100644
index 000000000..debdd30ea
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/legacy/proto3_20190205_c823c79e/test.proto
@@ -0,0 +1,136 @@
+// 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.
+
+syntax = "proto3";
+
+package google.golang.org.proto3_20190205;
+option go_package = "google.golang.org/protobuf/internal/testprotos/legacy/proto3_20190205_c823c79e";
+
+enum SiblingEnum {
+	ALPHA   = 0;
+	BRAVO   = 10;
+	CHARLIE = 200;
+}
+
+message SiblingMessage {
+	string          f1 = 1;
+	repeated string f2 = 2;
+	Message         f3 = 3;
+}
+
+message Message {
+	enum ChildEnum {
+		ALPHA   = 0;
+		BRAVO   = 1;
+		CHARLIE = 2;
+	}
+	message ChildMessage {
+		string          f1 = 1;
+		repeated string f2 = 2;
+		Message         f3 = 3;
+	}
+
+	// Optional fields.
+	bool     optional_bool     = 100;
+	int32    optional_int32    = 101;
+	sint32   optional_sint32   = 102;
+	uint32   optional_uint32   = 103;
+	int64    optional_int64    = 104;
+	sint64   optional_sint64   = 105;
+	uint64   optional_uint64   = 106;
+	fixed32  optional_fixed32  = 107;
+	sfixed32 optional_sfixed32 = 108;
+	float    optional_float    = 109;
+	fixed64  optional_fixed64  = 110;
+	sfixed64 optional_sfixed64 = 111;
+	double   optional_double   = 112;
+	string   optional_string   = 113;
+	bytes    optional_bytes    = 114;
+
+	ChildEnum      optional_child_enum      = 115;
+	ChildMessage   optional_child_message   = 116;
+	SiblingEnum    optional_sibling_enum    = 117;
+	SiblingMessage optional_sibling_message = 118;
+
+	// Repeated fields.
+	repeated bool     repeated_bool     = 200;
+	repeated int32    repeated_int32    = 201;
+	repeated sint32   repeated_sint32   = 202;
+	repeated uint32   repeated_uint32   = 203;
+	repeated int64    repeated_int64    = 204;
+	repeated sint64   repeated_sint64   = 205;
+	repeated uint64   repeated_uint64   = 206;
+	repeated fixed32  repeated_fixed32  = 207;
+	repeated sfixed32 repeated_sfixed32 = 208;
+	repeated float    repeated_float    = 209;
+	repeated fixed64  repeated_fixed64  = 210;
+	repeated sfixed64 repeated_sfixed64 = 211;
+	repeated double   repeated_double   = 212;
+	repeated string   repeated_string   = 213;
+	repeated bytes    repeated_bytes    = 214;
+
+	repeated ChildEnum      repeated_child_enum      = 215;
+	repeated ChildMessage   repeated_child_message   = 216;
+	repeated SiblingEnum    repeated_sibling_enum    = 217;
+	repeated SiblingMessage repeated_sibling_message = 218;
+
+	// Map fields.
+	map<bool, bool>     map_bool_bool     = 300;
+	map<bool, int32>    map_bool_int32    = 301;
+	map<bool, sint32>   map_bool_sint32   = 302;
+	map<bool, uint32>   map_bool_uint32   = 303;
+	map<bool, int64>    map_bool_int64    = 304;
+	map<bool, sint64>   map_bool_sint64   = 305;
+	map<bool, uint64>   map_bool_uint64   = 306;
+	map<bool, fixed32>  map_bool_fixed32  = 307;
+	map<bool, sfixed32> map_bool_sfixed32 = 308;
+	map<bool, float>    map_bool_float    = 309;
+	map<bool, fixed64>  map_bool_fixed64  = 310;
+	map<bool, sfixed64> map_bool_sfixed64 = 311;
+	map<bool, double>   map_bool_double   = 312;
+	map<bool, string>   map_bool_string   = 313;
+	map<bool, bytes>    map_bool_bytes    = 314;
+
+	map<bool, ChildEnum>      map_bool_child_enum      = 315;
+	map<bool, ChildMessage>   map_bool_child_message   = 316;
+	map<bool, SiblingEnum>    map_bool_sibling_enum    = 317;
+	map<bool, SiblingMessage> map_bool_sibling_message = 318;
+
+	map<int32, bool>   map_int32_bool   = 319;
+	map<sint32, bool>  map_sint32_bool  = 320;
+	map<uint32, bool>  map_uint32_bool  = 321;
+	map<int64, bool>   map_int64_bool   = 322;
+	map<sint64, bool>  map_sint64_bool  = 323;
+	map<uint64, bool>  map_uint64_bool  = 324;
+	map<fixed32, bool> map_fixed32_bool = 325;
+	map<string, bool>  map_string_bool  = 326;
+
+	// Oneof fields.
+	oneof oneof_union {
+		bool     oneof_bool     = 400;
+		int32    oneof_int32    = 401;
+		sint32   oneof_sint32   = 402;
+		uint32   oneof_uint32   = 403;
+		int64    oneof_int64    = 404;
+		sint64   oneof_sint64   = 405;
+		uint64   oneof_uint64   = 406;
+		fixed32  oneof_fixed32  = 407;
+		sfixed32 oneof_sfixed32 = 408;
+		float    oneof_float    = 409;
+		fixed64  oneof_fixed64  = 410;
+		sfixed64 oneof_sfixed64 = 411;
+		double   oneof_double   = 412;
+		string   oneof_string   = 413;
+		bytes    oneof_bytes    = 414;
+
+		ChildEnum      oneof_child_enum      = 415;
+		ChildMessage   oneof_child_message   = 416;
+		SiblingEnum    oneof_sibling_enum    = 417;
+		SiblingMessage oneof_sibling_message = 418;
+
+		string oneof_string1 = 419;
+		string oneof_string2 = 420;
+		string oneof_string3 = 421;
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/messageset/messagesetpb/message_set.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/messageset/messagesetpb/message_set.pb.go
new file mode 100644
index 000000000..d1c22b8b9
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/messageset/messagesetpb/message_set.pb.go
@@ -0,0 +1,213 @@
+// Copyright 2019 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: internal/testprotos/messageset/messagesetpb/message_set.proto
+
+package messagesetpb
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoiface "google.golang.org/protobuf/runtime/protoiface"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type MessageSet struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+}
+
+func (x *MessageSet) Reset() {
+	*x = MessageSet{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_messageset_messagesetpb_message_set_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MessageSet) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MessageSet) ProtoMessage() {}
+
+func (x *MessageSet) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_messageset_messagesetpb_message_set_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use MessageSet.ProtoReflect.Descriptor instead.
+func (*MessageSet) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_messageset_messagesetpb_message_set_proto_rawDescGZIP(), []int{0}
+}
+
+var extRange_MessageSet = []protoiface.ExtensionRangeV1{
+	{Start: 4, End: 2147483646},
+}
+
+// Deprecated: Use MessageSet.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*MessageSet) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_MessageSet
+}
+
+type MessageSetContainer struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	MessageSet *MessageSet `protobuf:"bytes,1,opt,name=message_set,json=messageSet" json:"message_set,omitempty"`
+}
+
+func (x *MessageSetContainer) Reset() {
+	*x = MessageSetContainer{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_messageset_messagesetpb_message_set_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MessageSetContainer) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MessageSetContainer) ProtoMessage() {}
+
+func (x *MessageSetContainer) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_messageset_messagesetpb_message_set_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use MessageSetContainer.ProtoReflect.Descriptor instead.
+func (*MessageSetContainer) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_messageset_messagesetpb_message_set_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *MessageSetContainer) GetMessageSet() *MessageSet {
+	if x != nil {
+		return x.MessageSet
+	}
+	return nil
+}
+
+var File_internal_testprotos_messageset_messagesetpb_message_set_proto protoreflect.FileDescriptor
+
+var file_internal_testprotos_messageset_messagesetpb_message_set_proto_rawDesc = []byte{
+	0x0a, 0x3d, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x65, 0x74,
+	0x2f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x65, 0x74, 0x70, 0x62, 0x2f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x65, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12,
+	0x18, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x65, 0x74, 0x22, 0x1a, 0x0a, 0x0a, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x2a, 0x08, 0x08, 0x04, 0x10, 0xff, 0xff, 0xff, 0xff,
+	0x07, 0x3a, 0x02, 0x08, 0x01, 0x22, 0x5c, 0x0a, 0x13, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x53, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x12, 0x45, 0x0a, 0x0b,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x65, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x65, 0x74, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x52, 0x0a, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x53, 0x65, 0x74, 0x42, 0x48, 0x5a, 0x46, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f,
+	0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x65, 0x74,
+	0x2f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x65, 0x74, 0x70, 0x62,
+}
+
+var (
+	file_internal_testprotos_messageset_messagesetpb_message_set_proto_rawDescOnce sync.Once
+	file_internal_testprotos_messageset_messagesetpb_message_set_proto_rawDescData = file_internal_testprotos_messageset_messagesetpb_message_set_proto_rawDesc
+)
+
+func file_internal_testprotos_messageset_messagesetpb_message_set_proto_rawDescGZIP() []byte {
+	file_internal_testprotos_messageset_messagesetpb_message_set_proto_rawDescOnce.Do(func() {
+		file_internal_testprotos_messageset_messagesetpb_message_set_proto_rawDescData = protoimpl.X.CompressGZIP(file_internal_testprotos_messageset_messagesetpb_message_set_proto_rawDescData)
+	})
+	return file_internal_testprotos_messageset_messagesetpb_message_set_proto_rawDescData
+}
+
+var file_internal_testprotos_messageset_messagesetpb_message_set_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
+var file_internal_testprotos_messageset_messagesetpb_message_set_proto_goTypes = []interface{}{
+	(*MessageSet)(nil),          // 0: goproto.proto.messageset.MessageSet
+	(*MessageSetContainer)(nil), // 1: goproto.proto.messageset.MessageSetContainer
+}
+var file_internal_testprotos_messageset_messagesetpb_message_set_proto_depIdxs = []int32{
+	0, // 0: goproto.proto.messageset.MessageSetContainer.message_set:type_name -> goproto.proto.messageset.MessageSet
+	1, // [1:1] is the sub-list for method output_type
+	1, // [1:1] is the sub-list for method input_type
+	1, // [1:1] is the sub-list for extension type_name
+	1, // [1:1] is the sub-list for extension extendee
+	0, // [0:1] is the sub-list for field type_name
+}
+
+func init() { file_internal_testprotos_messageset_messagesetpb_message_set_proto_init() }
+func file_internal_testprotos_messageset_messagesetpb_message_set_proto_init() {
+	if File_internal_testprotos_messageset_messagesetpb_message_set_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_internal_testprotos_messageset_messagesetpb_message_set_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MessageSet); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_messageset_messagesetpb_message_set_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MessageSetContainer); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_internal_testprotos_messageset_messagesetpb_message_set_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   2,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_internal_testprotos_messageset_messagesetpb_message_set_proto_goTypes,
+		DependencyIndexes: file_internal_testprotos_messageset_messagesetpb_message_set_proto_depIdxs,
+		MessageInfos:      file_internal_testprotos_messageset_messagesetpb_message_set_proto_msgTypes,
+	}.Build()
+	File_internal_testprotos_messageset_messagesetpb_message_set_proto = out.File
+	file_internal_testprotos_messageset_messagesetpb_message_set_proto_rawDesc = nil
+	file_internal_testprotos_messageset_messagesetpb_message_set_proto_goTypes = nil
+	file_internal_testprotos_messageset_messagesetpb_message_set_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/messageset/messagesetpb/message_set.proto b/vendor/google.golang.org/protobuf/internal/testprotos/messageset/messagesetpb/message_set.proto
new file mode 100644
index 000000000..4887977bb
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/messageset/messagesetpb/message_set.proto
@@ -0,0 +1,18 @@
+// Copyright 2019 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.
+
+syntax = "proto2";
+
+package goproto.proto.messageset;
+
+option go_package = "google.golang.org/protobuf/internal/testprotos/messageset/messagesetpb";
+
+message MessageSet {
+  option message_set_wire_format = true;
+  extensions 4 to max;
+}
+
+message MessageSetContainer {
+  optional MessageSet message_set = 1;
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/messageset/msetextpb/msetextpb.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/messageset/msetextpb/msetextpb.pb.go
new file mode 100644
index 000000000..af919baba
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/messageset/msetextpb/msetextpb.pb.go
@@ -0,0 +1,425 @@
+// Copyright 2019 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: internal/testprotos/messageset/msetextpb/msetextpb.proto
+
+package msetextpb
+
+import (
+	messagesetpb "google.golang.org/protobuf/internal/testprotos/messageset/messagesetpb"
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type Ext1 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Ext1Field1 *int32 `protobuf:"varint,1,opt,name=ext1_field1,json=ext1Field1" json:"ext1_field1,omitempty"`
+	Ext1Field2 *int32 `protobuf:"varint,2,opt,name=ext1_field2,json=ext1Field2" json:"ext1_field2,omitempty"`
+}
+
+func (x *Ext1) Reset() {
+	*x = Ext1{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_messageset_msetextpb_msetextpb_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Ext1) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Ext1) ProtoMessage() {}
+
+func (x *Ext1) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_messageset_msetextpb_msetextpb_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Ext1.ProtoReflect.Descriptor instead.
+func (*Ext1) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_messageset_msetextpb_msetextpb_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Ext1) GetExt1Field1() int32 {
+	if x != nil && x.Ext1Field1 != nil {
+		return *x.Ext1Field1
+	}
+	return 0
+}
+
+func (x *Ext1) GetExt1Field2() int32 {
+	if x != nil && x.Ext1Field2 != nil {
+		return *x.Ext1Field2
+	}
+	return 0
+}
+
+type Ext2 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Ext2Field1 *int32 `protobuf:"varint,1,opt,name=ext2_field1,json=ext2Field1" json:"ext2_field1,omitempty"`
+}
+
+func (x *Ext2) Reset() {
+	*x = Ext2{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_messageset_msetextpb_msetextpb_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Ext2) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Ext2) ProtoMessage() {}
+
+func (x *Ext2) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_messageset_msetextpb_msetextpb_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Ext2.ProtoReflect.Descriptor instead.
+func (*Ext2) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_messageset_msetextpb_msetextpb_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *Ext2) GetExt2Field1() int32 {
+	if x != nil && x.Ext2Field1 != nil {
+		return *x.Ext2Field1
+	}
+	return 0
+}
+
+type ExtRequired struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	RequiredField1 *int32 `protobuf:"varint,1,req,name=required_field1,json=requiredField1" json:"required_field1,omitempty"`
+}
+
+func (x *ExtRequired) Reset() {
+	*x = ExtRequired{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_messageset_msetextpb_msetextpb_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *ExtRequired) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ExtRequired) ProtoMessage() {}
+
+func (x *ExtRequired) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_messageset_msetextpb_msetextpb_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ExtRequired.ProtoReflect.Descriptor instead.
+func (*ExtRequired) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_messageset_msetextpb_msetextpb_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *ExtRequired) GetRequiredField1() int32 {
+	if x != nil && x.RequiredField1 != nil {
+		return *x.RequiredField1
+	}
+	return 0
+}
+
+type ExtLargeNumber struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *ExtLargeNumber) Reset() {
+	*x = ExtLargeNumber{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_messageset_msetextpb_msetextpb_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *ExtLargeNumber) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ExtLargeNumber) ProtoMessage() {}
+
+func (x *ExtLargeNumber) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_messageset_msetextpb_msetextpb_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ExtLargeNumber.ProtoReflect.Descriptor instead.
+func (*ExtLargeNumber) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_messageset_msetextpb_msetextpb_proto_rawDescGZIP(), []int{3}
+}
+
+var file_internal_testprotos_messageset_msetextpb_msetextpb_proto_extTypes = []protoimpl.ExtensionInfo{
+	{
+		ExtendedType:  (*messagesetpb.MessageSet)(nil),
+		ExtensionType: (*Ext1)(nil),
+		Field:         1000,
+		Name:          "goproto.proto.messageset.Ext1",
+		Tag:           "bytes,1000,opt,name=message_set_extension",
+		Filename:      "internal/testprotos/messageset/msetextpb/msetextpb.proto",
+	},
+	{
+		ExtendedType:  (*messagesetpb.MessageSet)(nil),
+		ExtensionType: (*Ext2)(nil),
+		Field:         1001,
+		Name:          "goproto.proto.messageset.Ext2",
+		Tag:           "bytes,1001,opt,name=message_set_extension",
+		Filename:      "internal/testprotos/messageset/msetextpb/msetextpb.proto",
+	},
+	{
+		ExtendedType:  (*messagesetpb.MessageSet)(nil),
+		ExtensionType: (*ExtRequired)(nil),
+		Field:         1002,
+		Name:          "goproto.proto.messageset.ExtRequired",
+		Tag:           "bytes,1002,opt,name=message_set_extension",
+		Filename:      "internal/testprotos/messageset/msetextpb/msetextpb.proto",
+	},
+	{
+		ExtendedType:  (*messagesetpb.MessageSet)(nil),
+		ExtensionType: (*ExtLargeNumber)(nil),
+		Field:         536870912,
+		Name:          "goproto.proto.messageset.ExtLargeNumber",
+		Tag:           "bytes,536870912,opt,name=message_set_extension",
+		Filename:      "internal/testprotos/messageset/msetextpb/msetextpb.proto",
+	},
+}
+
+// Extension fields to messagesetpb.MessageSet.
+var (
+	// optional goproto.proto.messageset.Ext1 message_set_extension = 1000;
+	E_Ext1_MessageSetExtension = &file_internal_testprotos_messageset_msetextpb_msetextpb_proto_extTypes[0]
+	// optional goproto.proto.messageset.Ext2 message_set_extension = 1001;
+	E_Ext2_MessageSetExtension = &file_internal_testprotos_messageset_msetextpb_msetextpb_proto_extTypes[1]
+	// optional goproto.proto.messageset.ExtRequired message_set_extension = 1002;
+	E_ExtRequired_MessageSetExtension = &file_internal_testprotos_messageset_msetextpb_msetextpb_proto_extTypes[2]
+	// optional goproto.proto.messageset.ExtLargeNumber message_set_extension = 536870912;
+	E_ExtLargeNumber_MessageSetExtension = &file_internal_testprotos_messageset_msetextpb_msetextpb_proto_extTypes[3] // 1<<29
+)
+
+var File_internal_testprotos_messageset_msetextpb_msetextpb_proto protoreflect.FileDescriptor
+
+var file_internal_testprotos_messageset_msetextpb_msetextpb_proto_rawDesc = []byte{
+	0x0a, 0x38, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x65, 0x74,
+	0x2f, 0x6d, 0x73, 0x65, 0x74, 0x65, 0x78, 0x74, 0x70, 0x62, 0x2f, 0x6d, 0x73, 0x65, 0x74, 0x65,
+	0x78, 0x74, 0x70, 0x62, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x18, 0x67, 0x6f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x73, 0x65, 0x74, 0x1a, 0x3d, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74,
+	0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x73, 0x65, 0x74, 0x2f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x65, 0x74, 0x70,
+	0x62, 0x2f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x65, 0x74, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x22, 0xc3, 0x01, 0x0a, 0x04, 0x45, 0x78, 0x74, 0x31, 0x12, 0x1f, 0x0a, 0x0b,
+	0x65, 0x78, 0x74, 0x31, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x0a, 0x65, 0x78, 0x74, 0x31, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x12, 0x1f, 0x0a,
+	0x0b, 0x65, 0x78, 0x74, 0x31, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x0a, 0x65, 0x78, 0x74, 0x31, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x32, 0x79,
+	0x0a, 0x15, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x65, 0x74, 0x5f, 0x65, 0x78,
+	0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x24, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73,
+	0x65, 0x74, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x18, 0xe8, 0x07,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x65, 0x74, 0x2e,
+	0x45, 0x78, 0x74, 0x31, 0x52, 0x13, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74,
+	0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0xa2, 0x01, 0x0a, 0x04, 0x45, 0x78,
+	0x74, 0x32, 0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x78, 0x74, 0x32, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x65, 0x78, 0x74, 0x32, 0x46, 0x69, 0x65,
+	0x6c, 0x64, 0x31, 0x32, 0x79, 0x0a, 0x15, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x73,
+	0x65, 0x74, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x24, 0x2e, 0x67,
+	0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x73, 0x65, 0x74, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53,
+	0x65, 0x74, 0x18, 0xe9, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x67, 0x6f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x73, 0x65, 0x74, 0x2e, 0x45, 0x78, 0x74, 0x32, 0x52, 0x13, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x53, 0x65, 0x74, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0xb9,
+	0x01, 0x0a, 0x0b, 0x45, 0x78, 0x74, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x12, 0x27,
+	0x0a, 0x0f, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x31, 0x18, 0x01, 0x20, 0x02, 0x28, 0x05, 0x52, 0x0e, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65,
+	0x64, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x80, 0x01, 0x0a, 0x15, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x5f, 0x73, 0x65, 0x74, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f,
+	0x6e, 0x12, 0x24, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x65, 0x74, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x18, 0xea, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25,
+	0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x65, 0x74, 0x2e, 0x45, 0x78, 0x74, 0x52, 0x65, 0x71,
+	0x75, 0x69, 0x72, 0x65, 0x64, 0x52, 0x13, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65,
+	0x74, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x99, 0x01, 0x0a, 0x0e, 0x45,
+	0x78, 0x74, 0x4c, 0x61, 0x72, 0x67, 0x65, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x32, 0x86, 0x01,
+	0x0a, 0x15, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x65, 0x74, 0x5f, 0x65, 0x78,
+	0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x24, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73,
+	0x65, 0x74, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x18, 0x80, 0x80,
+	0x80, 0x80, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73,
+	0x65, 0x74, 0x2e, 0x45, 0x78, 0x74, 0x4c, 0x61, 0x72, 0x67, 0x65, 0x4e, 0x75, 0x6d, 0x62, 0x65,
+	0x72, 0x52, 0x13, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x45, 0x78, 0x74,
+	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x42, 0x45, 0x5a, 0x43, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x62, 0x75, 0x66, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65,
+	0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x73, 0x65, 0x74, 0x2f, 0x6d, 0x73, 0x65, 0x74, 0x65, 0x78, 0x74, 0x70, 0x62,
+}
+
+var (
+	file_internal_testprotos_messageset_msetextpb_msetextpb_proto_rawDescOnce sync.Once
+	file_internal_testprotos_messageset_msetextpb_msetextpb_proto_rawDescData = file_internal_testprotos_messageset_msetextpb_msetextpb_proto_rawDesc
+)
+
+func file_internal_testprotos_messageset_msetextpb_msetextpb_proto_rawDescGZIP() []byte {
+	file_internal_testprotos_messageset_msetextpb_msetextpb_proto_rawDescOnce.Do(func() {
+		file_internal_testprotos_messageset_msetextpb_msetextpb_proto_rawDescData = protoimpl.X.CompressGZIP(file_internal_testprotos_messageset_msetextpb_msetextpb_proto_rawDescData)
+	})
+	return file_internal_testprotos_messageset_msetextpb_msetextpb_proto_rawDescData
+}
+
+var file_internal_testprotos_messageset_msetextpb_msetextpb_proto_msgTypes = make([]protoimpl.MessageInfo, 4)
+var file_internal_testprotos_messageset_msetextpb_msetextpb_proto_goTypes = []interface{}{
+	(*Ext1)(nil),                    // 0: goproto.proto.messageset.Ext1
+	(*Ext2)(nil),                    // 1: goproto.proto.messageset.Ext2
+	(*ExtRequired)(nil),             // 2: goproto.proto.messageset.ExtRequired
+	(*ExtLargeNumber)(nil),          // 3: goproto.proto.messageset.ExtLargeNumber
+	(*messagesetpb.MessageSet)(nil), // 4: goproto.proto.messageset.MessageSet
+}
+var file_internal_testprotos_messageset_msetextpb_msetextpb_proto_depIdxs = []int32{
+	4, // 0: goproto.proto.messageset.Ext1.message_set_extension:extendee -> goproto.proto.messageset.MessageSet
+	4, // 1: goproto.proto.messageset.Ext2.message_set_extension:extendee -> goproto.proto.messageset.MessageSet
+	4, // 2: goproto.proto.messageset.ExtRequired.message_set_extension:extendee -> goproto.proto.messageset.MessageSet
+	4, // 3: goproto.proto.messageset.ExtLargeNumber.message_set_extension:extendee -> goproto.proto.messageset.MessageSet
+	0, // 4: goproto.proto.messageset.Ext1.message_set_extension:type_name -> goproto.proto.messageset.Ext1
+	1, // 5: goproto.proto.messageset.Ext2.message_set_extension:type_name -> goproto.proto.messageset.Ext2
+	2, // 6: goproto.proto.messageset.ExtRequired.message_set_extension:type_name -> goproto.proto.messageset.ExtRequired
+	3, // 7: goproto.proto.messageset.ExtLargeNumber.message_set_extension:type_name -> goproto.proto.messageset.ExtLargeNumber
+	8, // [8:8] is the sub-list for method output_type
+	8, // [8:8] is the sub-list for method input_type
+	4, // [4:8] is the sub-list for extension type_name
+	0, // [0:4] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_internal_testprotos_messageset_msetextpb_msetextpb_proto_init() }
+func file_internal_testprotos_messageset_msetextpb_msetextpb_proto_init() {
+	if File_internal_testprotos_messageset_msetextpb_msetextpb_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_internal_testprotos_messageset_msetextpb_msetextpb_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Ext1); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_messageset_msetextpb_msetextpb_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Ext2); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_messageset_msetextpb_msetextpb_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ExtRequired); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_messageset_msetextpb_msetextpb_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ExtLargeNumber); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_internal_testprotos_messageset_msetextpb_msetextpb_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   4,
+			NumExtensions: 4,
+			NumServices:   0,
+		},
+		GoTypes:           file_internal_testprotos_messageset_msetextpb_msetextpb_proto_goTypes,
+		DependencyIndexes: file_internal_testprotos_messageset_msetextpb_msetextpb_proto_depIdxs,
+		MessageInfos:      file_internal_testprotos_messageset_msetextpb_msetextpb_proto_msgTypes,
+		ExtensionInfos:    file_internal_testprotos_messageset_msetextpb_msetextpb_proto_extTypes,
+	}.Build()
+	File_internal_testprotos_messageset_msetextpb_msetextpb_proto = out.File
+	file_internal_testprotos_messageset_msetextpb_msetextpb_proto_rawDesc = nil
+	file_internal_testprotos_messageset_msetextpb_msetextpb_proto_goTypes = nil
+	file_internal_testprotos_messageset_msetextpb_msetextpb_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/messageset/msetextpb/msetextpb.proto b/vendor/google.golang.org/protobuf/internal/testprotos/messageset/msetextpb/msetextpb.proto
new file mode 100644
index 000000000..231ded969
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/messageset/msetextpb/msetextpb.proto
@@ -0,0 +1,39 @@
+// Copyright 2019 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.
+
+syntax = "proto2";
+
+package goproto.proto.messageset;
+
+option go_package = "google.golang.org/protobuf/internal/testprotos/messageset/msetextpb";
+
+import "internal/testprotos/messageset/messagesetpb/message_set.proto";
+
+message Ext1 {
+  extend MessageSet {
+    optional Ext1 message_set_extension = 1000;
+  }
+  optional int32 ext1_field1 = 1;
+  optional int32 ext1_field2 = 2;
+}
+
+message Ext2 {
+  extend MessageSet {
+    optional Ext2 message_set_extension = 1001;
+  }
+  optional int32 ext2_field1 = 1;
+}
+
+message ExtRequired {
+  extend MessageSet {
+    optional ExtRequired message_set_extension = 1002;
+  }
+  required int32 required_field1 = 1;
+}
+
+message ExtLargeNumber {
+  extend MessageSet {
+    optional ExtLargeNumber message_set_extension = 536870912; // 1<<29
+  }
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/order/order.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/order/order.pb.go
new file mode 100644
index 000000000..07fa6584f
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/order/order.pb.go
@@ -0,0 +1,259 @@
+// Copyright 2019 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.
+
+// Messages in this file are used to test wire encoding order.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: internal/testprotos/order/order.proto
+
+package order
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoiface "google.golang.org/protobuf/runtime/protoiface"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type Message struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+
+	Field_2 *string `protobuf:"bytes,2,opt,name=field_2,json=field2" json:"field_2,omitempty"`
+	Field_1 *string `protobuf:"bytes,1,opt,name=field_1,json=field1" json:"field_1,omitempty"`
+	// Types that are assignable to Oneof_1:
+	//	*Message_Field_10
+	Oneof_1  isMessage_Oneof_1 `protobuf_oneof:"oneof_1"`
+	Field_20 *string           `protobuf:"bytes,20,opt,name=field_20,json=field20" json:"field_20,omitempty"`
+}
+
+func (x *Message) Reset() {
+	*x = Message{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_order_order_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message) ProtoMessage() {}
+
+func (x *Message) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_order_order_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message.ProtoReflect.Descriptor instead.
+func (*Message) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_order_order_proto_rawDescGZIP(), []int{0}
+}
+
+var extRange_Message = []protoiface.ExtensionRangeV1{
+	{Start: 30, End: 40},
+}
+
+// Deprecated: Use Message.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*Message) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_Message
+}
+
+func (x *Message) GetField_2() string {
+	if x != nil && x.Field_2 != nil {
+		return *x.Field_2
+	}
+	return ""
+}
+
+func (x *Message) GetField_1() string {
+	if x != nil && x.Field_1 != nil {
+		return *x.Field_1
+	}
+	return ""
+}
+
+func (m *Message) GetOneof_1() isMessage_Oneof_1 {
+	if m != nil {
+		return m.Oneof_1
+	}
+	return nil
+}
+
+func (x *Message) GetField_10() string {
+	if x, ok := x.GetOneof_1().(*Message_Field_10); ok {
+		return x.Field_10
+	}
+	return ""
+}
+
+func (x *Message) GetField_20() string {
+	if x != nil && x.Field_20 != nil {
+		return *x.Field_20
+	}
+	return ""
+}
+
+type isMessage_Oneof_1 interface {
+	isMessage_Oneof_1()
+}
+
+type Message_Field_10 struct {
+	Field_10 string `protobuf:"bytes,10,opt,name=field_10,json=field10,oneof"`
+}
+
+func (*Message_Field_10) isMessage_Oneof_1() {}
+
+var file_internal_testprotos_order_order_proto_extTypes = []protoimpl.ExtensionInfo{
+	{
+		ExtendedType:  (*Message)(nil),
+		ExtensionType: (*string)(nil),
+		Field:         30,
+		Name:          "goproto.proto.order.field_30",
+		Tag:           "bytes,30,opt,name=field_30",
+		Filename:      "internal/testprotos/order/order.proto",
+	},
+	{
+		ExtendedType:  (*Message)(nil),
+		ExtensionType: (*string)(nil),
+		Field:         31,
+		Name:          "goproto.proto.order.field_31",
+		Tag:           "bytes,31,opt,name=field_31",
+		Filename:      "internal/testprotos/order/order.proto",
+	},
+	{
+		ExtendedType:  (*Message)(nil),
+		ExtensionType: (*string)(nil),
+		Field:         32,
+		Name:          "goproto.proto.order.field_32",
+		Tag:           "bytes,32,opt,name=field_32",
+		Filename:      "internal/testprotos/order/order.proto",
+	},
+}
+
+// Extension fields to Message.
+var (
+	// optional string field_30 = 30;
+	E_Field_30 = &file_internal_testprotos_order_order_proto_extTypes[0]
+	// optional string field_31 = 31;
+	E_Field_31 = &file_internal_testprotos_order_order_proto_extTypes[1]
+	// optional string field_32 = 32;
+	E_Field_32 = &file_internal_testprotos_order_order_proto_extTypes[2]
+)
+
+var File_internal_testprotos_order_order_proto protoreflect.FileDescriptor
+
+var file_internal_testprotos_order_order_proto_rawDesc = []byte{
+	0x0a, 0x25, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x2f, 0x6f, 0x72, 0x64, 0x65,
+	0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x13, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x22, 0x84, 0x01, 0x0a,
+	0x07, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x17, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c,
+	0x64, 0x5f, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x12, 0x17, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x31, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x12, 0x1b, 0x0a, 0x08, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x5f, 0x31, 0x30, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x07,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x12, 0x19, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x5f, 0x32, 0x30, 0x18, 0x14, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x30, 0x2a, 0x04, 0x08, 0x1e, 0x10, 0x29, 0x42, 0x09, 0x0a, 0x07, 0x6f, 0x6e, 0x65, 0x6f,
+	0x66, 0x5f, 0x31, 0x3a, 0x37, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x33, 0x30, 0x12,
+	0x1c, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x6f, 0x72, 0x64, 0x65, 0x72, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x1e, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x30, 0x3a, 0x37, 0x0a, 0x08,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x33, 0x31, 0x12, 0x1c, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x1f, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x33, 0x31, 0x3a, 0x37, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x33,
+	0x32, 0x12, 0x1c, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18,
+	0x20, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x32, 0x42, 0x36,
+	0x5a, 0x34, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e,
+	0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x69, 0x6e, 0x74,
+	0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73,
+	0x2f, 0x6f, 0x72, 0x64, 0x65, 0x72,
+}
+
+var (
+	file_internal_testprotos_order_order_proto_rawDescOnce sync.Once
+	file_internal_testprotos_order_order_proto_rawDescData = file_internal_testprotos_order_order_proto_rawDesc
+)
+
+func file_internal_testprotos_order_order_proto_rawDescGZIP() []byte {
+	file_internal_testprotos_order_order_proto_rawDescOnce.Do(func() {
+		file_internal_testprotos_order_order_proto_rawDescData = protoimpl.X.CompressGZIP(file_internal_testprotos_order_order_proto_rawDescData)
+	})
+	return file_internal_testprotos_order_order_proto_rawDescData
+}
+
+var file_internal_testprotos_order_order_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_internal_testprotos_order_order_proto_goTypes = []interface{}{
+	(*Message)(nil), // 0: goproto.proto.order.Message
+}
+var file_internal_testprotos_order_order_proto_depIdxs = []int32{
+	0, // 0: goproto.proto.order.field_30:extendee -> goproto.proto.order.Message
+	0, // 1: goproto.proto.order.field_31:extendee -> goproto.proto.order.Message
+	0, // 2: goproto.proto.order.field_32:extendee -> goproto.proto.order.Message
+	3, // [3:3] is the sub-list for method output_type
+	3, // [3:3] is the sub-list for method input_type
+	3, // [3:3] is the sub-list for extension type_name
+	0, // [0:3] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_internal_testprotos_order_order_proto_init() }
+func file_internal_testprotos_order_order_proto_init() {
+	if File_internal_testprotos_order_order_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_internal_testprotos_order_order_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+	}
+	file_internal_testprotos_order_order_proto_msgTypes[0].OneofWrappers = []interface{}{
+		(*Message_Field_10)(nil),
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_internal_testprotos_order_order_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 3,
+			NumServices:   0,
+		},
+		GoTypes:           file_internal_testprotos_order_order_proto_goTypes,
+		DependencyIndexes: file_internal_testprotos_order_order_proto_depIdxs,
+		MessageInfos:      file_internal_testprotos_order_order_proto_msgTypes,
+		ExtensionInfos:    file_internal_testprotos_order_order_proto_extTypes,
+	}.Build()
+	File_internal_testprotos_order_order_proto = out.File
+	file_internal_testprotos_order_order_proto_rawDesc = nil
+	file_internal_testprotos_order_order_proto_goTypes = nil
+	file_internal_testprotos_order_order_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/order/order.proto b/vendor/google.golang.org/protobuf/internal/testprotos/order/order.proto
new file mode 100644
index 000000000..9333ace80
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/order/order.proto
@@ -0,0 +1,30 @@
+// Copyright 2019 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.
+
+// Messages in this file are used to test wire encoding order.
+
+syntax = "proto2";
+
+package goproto.proto.order;
+
+option go_package = "google.golang.org/protobuf/internal/testprotos/order";
+
+message Message {
+  optional string field_2 = 2;
+  optional string field_1 = 1;
+
+  oneof oneof_1 {
+    string field_10 = 10;
+  }
+
+  extensions 30 to 40;
+
+  optional string field_20 = 20;
+}
+
+extend Message {
+  optional string field_30 = 30;
+  optional string field_31 = 31;
+  optional string field_32 = 32;
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/registry/test.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/registry/test.pb.go
new file mode 100644
index 000000000..533cd3cbf
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/registry/test.pb.go
@@ -0,0 +1,583 @@
+// 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.
+
+// Different proto type definitions for testing the Types registry.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: internal/testprotos/registry/test.proto
+
+package registry
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoiface "google.golang.org/protobuf/runtime/protoiface"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type Enum1 int32
+
+const (
+	Enum1_ONE Enum1 = 1
+)
+
+// Enum value maps for Enum1.
+var (
+	Enum1_name = map[int32]string{
+		1: "ONE",
+	}
+	Enum1_value = map[string]int32{
+		"ONE": 1,
+	}
+)
+
+func (x Enum1) Enum() *Enum1 {
+	p := new(Enum1)
+	*p = x
+	return p
+}
+
+func (x Enum1) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum1) Descriptor() protoreflect.EnumDescriptor {
+	return file_internal_testprotos_registry_test_proto_enumTypes[0].Descriptor()
+}
+
+func (Enum1) Type() protoreflect.EnumType {
+	return &file_internal_testprotos_registry_test_proto_enumTypes[0]
+}
+
+func (x Enum1) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum1) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum1(num)
+	return nil
+}
+
+// Deprecated: Use Enum1.Descriptor instead.
+func (Enum1) EnumDescriptor() ([]byte, []int) {
+	return file_internal_testprotos_registry_test_proto_rawDescGZIP(), []int{0}
+}
+
+type Enum2 int32
+
+const (
+	Enum2_UNO Enum2 = 1
+)
+
+// Enum value maps for Enum2.
+var (
+	Enum2_name = map[int32]string{
+		1: "UNO",
+	}
+	Enum2_value = map[string]int32{
+		"UNO": 1,
+	}
+)
+
+func (x Enum2) Enum() *Enum2 {
+	p := new(Enum2)
+	*p = x
+	return p
+}
+
+func (x Enum2) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum2) Descriptor() protoreflect.EnumDescriptor {
+	return file_internal_testprotos_registry_test_proto_enumTypes[1].Descriptor()
+}
+
+func (Enum2) Type() protoreflect.EnumType {
+	return &file_internal_testprotos_registry_test_proto_enumTypes[1]
+}
+
+func (x Enum2) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum2) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum2(num)
+	return nil
+}
+
+// Deprecated: Use Enum2.Descriptor instead.
+func (Enum2) EnumDescriptor() ([]byte, []int) {
+	return file_internal_testprotos_registry_test_proto_rawDescGZIP(), []int{1}
+}
+
+type Enum3 int32
+
+const (
+	Enum3_YI Enum3 = 1
+)
+
+// Enum value maps for Enum3.
+var (
+	Enum3_name = map[int32]string{
+		1: "YI",
+	}
+	Enum3_value = map[string]int32{
+		"YI": 1,
+	}
+)
+
+func (x Enum3) Enum() *Enum3 {
+	p := new(Enum3)
+	*p = x
+	return p
+}
+
+func (x Enum3) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum3) Descriptor() protoreflect.EnumDescriptor {
+	return file_internal_testprotos_registry_test_proto_enumTypes[2].Descriptor()
+}
+
+func (Enum3) Type() protoreflect.EnumType {
+	return &file_internal_testprotos_registry_test_proto_enumTypes[2]
+}
+
+func (x Enum3) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum3) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum3(num)
+	return nil
+}
+
+// Deprecated: Use Enum3.Descriptor instead.
+func (Enum3) EnumDescriptor() ([]byte, []int) {
+	return file_internal_testprotos_registry_test_proto_rawDescGZIP(), []int{2}
+}
+
+type Message1 struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+}
+
+func (x *Message1) Reset() {
+	*x = Message1{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_registry_test_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message1) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message1) ProtoMessage() {}
+
+func (x *Message1) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_registry_test_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message1.ProtoReflect.Descriptor instead.
+func (*Message1) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_registry_test_proto_rawDescGZIP(), []int{0}
+}
+
+var extRange_Message1 = []protoiface.ExtensionRangeV1{
+	{Start: 10, End: 536870911},
+}
+
+// Deprecated: Use Message1.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*Message1) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_Message1
+}
+
+type Message2 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message2) Reset() {
+	*x = Message2{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_registry_test_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message2) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message2) ProtoMessage() {}
+
+func (x *Message2) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_registry_test_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message2.ProtoReflect.Descriptor instead.
+func (*Message2) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_registry_test_proto_rawDescGZIP(), []int{1}
+}
+
+type Message3 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message3) Reset() {
+	*x = Message3{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_registry_test_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message3) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message3) ProtoMessage() {}
+
+func (x *Message3) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_registry_test_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message3.ProtoReflect.Descriptor instead.
+func (*Message3) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_registry_test_proto_rawDescGZIP(), []int{2}
+}
+
+type Message4 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	BoolField *bool `protobuf:"varint,30,opt,name=bool_field,json=boolField" json:"bool_field,omitempty"`
+}
+
+func (x *Message4) Reset() {
+	*x = Message4{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_registry_test_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message4) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message4) ProtoMessage() {}
+
+func (x *Message4) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_registry_test_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message4.ProtoReflect.Descriptor instead.
+func (*Message4) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_registry_test_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *Message4) GetBoolField() bool {
+	if x != nil && x.BoolField != nil {
+		return *x.BoolField
+	}
+	return false
+}
+
+var file_internal_testprotos_registry_test_proto_extTypes = []protoimpl.ExtensionInfo{
+	{
+		ExtendedType:  (*Message1)(nil),
+		ExtensionType: (*string)(nil),
+		Field:         11,
+		Name:          "testprotos.string_field",
+		Tag:           "bytes,11,opt,name=string_field",
+		Filename:      "internal/testprotos/registry/test.proto",
+	},
+	{
+		ExtendedType:  (*Message1)(nil),
+		ExtensionType: (*Enum1)(nil),
+		Field:         12,
+		Name:          "testprotos.enum_field",
+		Tag:           "varint,12,opt,name=enum_field,enum=testprotos.Enum1",
+		Filename:      "internal/testprotos/registry/test.proto",
+	},
+	{
+		ExtendedType:  (*Message1)(nil),
+		ExtensionType: (*Message2)(nil),
+		Field:         13,
+		Name:          "testprotos.message_field",
+		Tag:           "bytes,13,opt,name=message_field",
+		Filename:      "internal/testprotos/registry/test.proto",
+	},
+	{
+		ExtendedType:  (*Message1)(nil),
+		ExtensionType: (*Message2)(nil),
+		Field:         21,
+		Name:          "testprotos.Message4.message_field",
+		Tag:           "bytes,21,opt,name=message_field",
+		Filename:      "internal/testprotos/registry/test.proto",
+	},
+	{
+		ExtendedType:  (*Message1)(nil),
+		ExtensionType: (*Enum1)(nil),
+		Field:         22,
+		Name:          "testprotos.Message4.enum_field",
+		Tag:           "varint,22,opt,name=enum_field,enum=testprotos.Enum1",
+		Filename:      "internal/testprotos/registry/test.proto",
+	},
+	{
+		ExtendedType:  (*Message1)(nil),
+		ExtensionType: (*string)(nil),
+		Field:         23,
+		Name:          "testprotos.Message4.string_field",
+		Tag:           "bytes,23,opt,name=string_field",
+		Filename:      "internal/testprotos/registry/test.proto",
+	},
+}
+
+// Extension fields to Message1.
+var (
+	// optional string string_field = 11;
+	E_StringField = &file_internal_testprotos_registry_test_proto_extTypes[0]
+	// optional testprotos.Enum1 enum_field = 12;
+	E_EnumField = &file_internal_testprotos_registry_test_proto_extTypes[1]
+	// optional testprotos.Message2 message_field = 13;
+	E_MessageField = &file_internal_testprotos_registry_test_proto_extTypes[2]
+	// optional testprotos.Message2 message_field = 21;
+	E_Message4_MessageField = &file_internal_testprotos_registry_test_proto_extTypes[3]
+	// optional testprotos.Enum1 enum_field = 22;
+	E_Message4_EnumField = &file_internal_testprotos_registry_test_proto_extTypes[4]
+	// optional string string_field = 23;
+	E_Message4_StringField = &file_internal_testprotos_registry_test_proto_extTypes[5]
+)
+
+var File_internal_testprotos_registry_test_proto protoreflect.FileDescriptor
+
+var file_internal_testprotos_registry_test_proto_rawDesc = []byte{
+	0x0a, 0x27, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x79, 0x2f, 0x74,
+	0x65, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0a, 0x74, 0x65, 0x73, 0x74, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x73, 0x22, 0x14, 0x0a, 0x08, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x31, 0x2a, 0x08, 0x08, 0x0a, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x22, 0x0a, 0x0a, 0x08, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x22, 0x0a, 0x0a, 0x08, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x33, 0x22, 0xfb, 0x01, 0x0a, 0x08, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x34,
+	0x12, 0x1d, 0x0a, 0x0a, 0x62, 0x6f, 0x6f, 0x6c, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x1e,
+	0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x62, 0x6f, 0x6f, 0x6c, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x4f, 0x0a, 0x0d, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x12, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x18, 0x15, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74,
+	0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x32, 0x52, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x46, 0x69, 0x65, 0x6c, 0x64,
+	0x32, 0x46, 0x0a, 0x0a, 0x65, 0x6e, 0x75, 0x6d, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x14,
+	0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x31, 0x18, 0x16, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x11, 0x2e, 0x74, 0x65, 0x73,
+	0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x52, 0x09, 0x65,
+	0x6e, 0x75, 0x6d, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x37, 0x0a, 0x0c, 0x73, 0x74, 0x72, 0x69,
+	0x6e, 0x67, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x18, 0x17,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x46, 0x69, 0x65, 0x6c,
+	0x64, 0x2a, 0x10, 0x0a, 0x05, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x12, 0x07, 0x0a, 0x03, 0x4f, 0x4e,
+	0x45, 0x10, 0x01, 0x2a, 0x10, 0x0a, 0x05, 0x45, 0x6e, 0x75, 0x6d, 0x32, 0x12, 0x07, 0x0a, 0x03,
+	0x55, 0x4e, 0x4f, 0x10, 0x01, 0x2a, 0x0f, 0x0a, 0x05, 0x45, 0x6e, 0x75, 0x6d, 0x33, 0x12, 0x06,
+	0x0a, 0x02, 0x59, 0x49, 0x10, 0x01, 0x3a, 0x37, 0x0a, 0x0c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67,
+	0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x73, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x18, 0x0b, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x0b, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x3a,
+	0x46, 0x0a, 0x0a, 0x65, 0x6e, 0x75, 0x6d, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x14, 0x2e,
+	0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x31, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x11, 0x2e, 0x74, 0x65, 0x73, 0x74,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x31, 0x52, 0x09, 0x65, 0x6e,
+	0x75, 0x6d, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x3a, 0x4f, 0x0a, 0x0d, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x18, 0x0d,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x73, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x52, 0x0c, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42, 0x39, 0x5a, 0x37, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f,
+	0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x72, 0x65, 0x67, 0x69, 0x73,
+	0x74, 0x72, 0x79,
+}
+
+var (
+	file_internal_testprotos_registry_test_proto_rawDescOnce sync.Once
+	file_internal_testprotos_registry_test_proto_rawDescData = file_internal_testprotos_registry_test_proto_rawDesc
+)
+
+func file_internal_testprotos_registry_test_proto_rawDescGZIP() []byte {
+	file_internal_testprotos_registry_test_proto_rawDescOnce.Do(func() {
+		file_internal_testprotos_registry_test_proto_rawDescData = protoimpl.X.CompressGZIP(file_internal_testprotos_registry_test_proto_rawDescData)
+	})
+	return file_internal_testprotos_registry_test_proto_rawDescData
+}
+
+var file_internal_testprotos_registry_test_proto_enumTypes = make([]protoimpl.EnumInfo, 3)
+var file_internal_testprotos_registry_test_proto_msgTypes = make([]protoimpl.MessageInfo, 4)
+var file_internal_testprotos_registry_test_proto_goTypes = []interface{}{
+	(Enum1)(0),       // 0: testprotos.Enum1
+	(Enum2)(0),       // 1: testprotos.Enum2
+	(Enum3)(0),       // 2: testprotos.Enum3
+	(*Message1)(nil), // 3: testprotos.Message1
+	(*Message2)(nil), // 4: testprotos.Message2
+	(*Message3)(nil), // 5: testprotos.Message3
+	(*Message4)(nil), // 6: testprotos.Message4
+}
+var file_internal_testprotos_registry_test_proto_depIdxs = []int32{
+	3,  // 0: testprotos.string_field:extendee -> testprotos.Message1
+	3,  // 1: testprotos.enum_field:extendee -> testprotos.Message1
+	3,  // 2: testprotos.message_field:extendee -> testprotos.Message1
+	3,  // 3: testprotos.Message4.message_field:extendee -> testprotos.Message1
+	3,  // 4: testprotos.Message4.enum_field:extendee -> testprotos.Message1
+	3,  // 5: testprotos.Message4.string_field:extendee -> testprotos.Message1
+	0,  // 6: testprotos.enum_field:type_name -> testprotos.Enum1
+	4,  // 7: testprotos.message_field:type_name -> testprotos.Message2
+	4,  // 8: testprotos.Message4.message_field:type_name -> testprotos.Message2
+	0,  // 9: testprotos.Message4.enum_field:type_name -> testprotos.Enum1
+	10, // [10:10] is the sub-list for method output_type
+	10, // [10:10] is the sub-list for method input_type
+	6,  // [6:10] is the sub-list for extension type_name
+	0,  // [0:6] is the sub-list for extension extendee
+	0,  // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_internal_testprotos_registry_test_proto_init() }
+func file_internal_testprotos_registry_test_proto_init() {
+	if File_internal_testprotos_registry_test_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_internal_testprotos_registry_test_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message1); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_registry_test_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message2); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_registry_test_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message3); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_registry_test_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message4); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_internal_testprotos_registry_test_proto_rawDesc,
+			NumEnums:      3,
+			NumMessages:   4,
+			NumExtensions: 6,
+			NumServices:   0,
+		},
+		GoTypes:           file_internal_testprotos_registry_test_proto_goTypes,
+		DependencyIndexes: file_internal_testprotos_registry_test_proto_depIdxs,
+		EnumInfos:         file_internal_testprotos_registry_test_proto_enumTypes,
+		MessageInfos:      file_internal_testprotos_registry_test_proto_msgTypes,
+		ExtensionInfos:    file_internal_testprotos_registry_test_proto_extTypes,
+	}.Build()
+	File_internal_testprotos_registry_test_proto = out.File
+	file_internal_testprotos_registry_test_proto_rawDesc = nil
+	file_internal_testprotos_registry_test_proto_goTypes = nil
+	file_internal_testprotos_registry_test_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/registry/test.proto b/vendor/google.golang.org/protobuf/internal/testprotos/registry/test.proto
new file mode 100644
index 000000000..32452b065
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/registry/test.proto
@@ -0,0 +1,45 @@
+// 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.
+
+// Different proto type definitions for testing the Types registry.
+syntax = "proto2";
+
+package testprotos;
+option go_package = "google.golang.org/protobuf/internal/testprotos/registry";
+
+message Message1 {
+  extensions 10 to max;
+}
+
+message Message2 {}
+
+message Message3 {}
+
+enum Enum1 {
+  ONE = 1;
+}
+
+enum Enum2 {
+  UNO = 1;
+}
+
+enum Enum3 {
+  YI = 1;
+}
+
+extend Message1 {
+  optional string string_field = 11;
+  optional Enum1 enum_field = 12;
+  optional Message2 message_field = 13;
+}
+
+message Message4 {
+  optional bool bool_field = 30;
+
+  extend Message1 {
+    optional Message2 message_field = 21;
+    optional Enum1 enum_field = 22;
+    optional string string_field = 23;
+  }
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/required/required.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/required/required.pb.go
new file mode 100644
index 000000000..065fcbf5e
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/required/required.pb.go
@@ -0,0 +1,1121 @@
+// Copyright 2020 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: internal/testprotos/required/required.proto
+
+package required
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type Int32 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	V *int32 `protobuf:"varint,1,req,name=v" json:"v,omitempty"`
+}
+
+func (x *Int32) Reset() {
+	*x = Int32{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_required_required_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Int32) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Int32) ProtoMessage() {}
+
+func (x *Int32) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_required_required_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Int32.ProtoReflect.Descriptor instead.
+func (*Int32) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_required_required_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Int32) GetV() int32 {
+	if x != nil && x.V != nil {
+		return *x.V
+	}
+	return 0
+}
+
+type Int64 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	V *int64 `protobuf:"varint,1,req,name=v" json:"v,omitempty"`
+}
+
+func (x *Int64) Reset() {
+	*x = Int64{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_required_required_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Int64) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Int64) ProtoMessage() {}
+
+func (x *Int64) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_required_required_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Int64.ProtoReflect.Descriptor instead.
+func (*Int64) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_required_required_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *Int64) GetV() int64 {
+	if x != nil && x.V != nil {
+		return *x.V
+	}
+	return 0
+}
+
+type Uint32 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	V *uint32 `protobuf:"varint,1,req,name=v" json:"v,omitempty"`
+}
+
+func (x *Uint32) Reset() {
+	*x = Uint32{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_required_required_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Uint32) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Uint32) ProtoMessage() {}
+
+func (x *Uint32) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_required_required_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Uint32.ProtoReflect.Descriptor instead.
+func (*Uint32) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_required_required_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *Uint32) GetV() uint32 {
+	if x != nil && x.V != nil {
+		return *x.V
+	}
+	return 0
+}
+
+type Uint64 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	V *uint64 `protobuf:"varint,1,req,name=v" json:"v,omitempty"`
+}
+
+func (x *Uint64) Reset() {
+	*x = Uint64{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_required_required_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Uint64) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Uint64) ProtoMessage() {}
+
+func (x *Uint64) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_required_required_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Uint64.ProtoReflect.Descriptor instead.
+func (*Uint64) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_required_required_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *Uint64) GetV() uint64 {
+	if x != nil && x.V != nil {
+		return *x.V
+	}
+	return 0
+}
+
+type Sint32 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	V *int32 `protobuf:"zigzag32,1,req,name=v" json:"v,omitempty"`
+}
+
+func (x *Sint32) Reset() {
+	*x = Sint32{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_required_required_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Sint32) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Sint32) ProtoMessage() {}
+
+func (x *Sint32) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_required_required_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Sint32.ProtoReflect.Descriptor instead.
+func (*Sint32) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_required_required_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *Sint32) GetV() int32 {
+	if x != nil && x.V != nil {
+		return *x.V
+	}
+	return 0
+}
+
+type Sint64 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	V *int64 `protobuf:"zigzag64,1,req,name=v" json:"v,omitempty"`
+}
+
+func (x *Sint64) Reset() {
+	*x = Sint64{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_required_required_proto_msgTypes[5]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Sint64) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Sint64) ProtoMessage() {}
+
+func (x *Sint64) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_required_required_proto_msgTypes[5]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Sint64.ProtoReflect.Descriptor instead.
+func (*Sint64) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_required_required_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *Sint64) GetV() int64 {
+	if x != nil && x.V != nil {
+		return *x.V
+	}
+	return 0
+}
+
+type Fixed32 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	V *uint32 `protobuf:"fixed32,1,req,name=v" json:"v,omitempty"`
+}
+
+func (x *Fixed32) Reset() {
+	*x = Fixed32{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_required_required_proto_msgTypes[6]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Fixed32) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Fixed32) ProtoMessage() {}
+
+func (x *Fixed32) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_required_required_proto_msgTypes[6]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Fixed32.ProtoReflect.Descriptor instead.
+func (*Fixed32) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_required_required_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *Fixed32) GetV() uint32 {
+	if x != nil && x.V != nil {
+		return *x.V
+	}
+	return 0
+}
+
+type Fixed64 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	V *uint64 `protobuf:"fixed64,1,req,name=v" json:"v,omitempty"`
+}
+
+func (x *Fixed64) Reset() {
+	*x = Fixed64{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_required_required_proto_msgTypes[7]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Fixed64) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Fixed64) ProtoMessage() {}
+
+func (x *Fixed64) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_required_required_proto_msgTypes[7]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Fixed64.ProtoReflect.Descriptor instead.
+func (*Fixed64) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_required_required_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *Fixed64) GetV() uint64 {
+	if x != nil && x.V != nil {
+		return *x.V
+	}
+	return 0
+}
+
+type Float struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	V *float32 `protobuf:"fixed32,1,req,name=v" json:"v,omitempty"`
+}
+
+func (x *Float) Reset() {
+	*x = Float{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_required_required_proto_msgTypes[8]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Float) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Float) ProtoMessage() {}
+
+func (x *Float) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_required_required_proto_msgTypes[8]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Float.ProtoReflect.Descriptor instead.
+func (*Float) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_required_required_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *Float) GetV() float32 {
+	if x != nil && x.V != nil {
+		return *x.V
+	}
+	return 0
+}
+
+type Double struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	V *float64 `protobuf:"fixed64,1,req,name=v" json:"v,omitempty"`
+}
+
+func (x *Double) Reset() {
+	*x = Double{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_required_required_proto_msgTypes[9]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Double) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Double) ProtoMessage() {}
+
+func (x *Double) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_required_required_proto_msgTypes[9]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Double.ProtoReflect.Descriptor instead.
+func (*Double) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_required_required_proto_rawDescGZIP(), []int{9}
+}
+
+func (x *Double) GetV() float64 {
+	if x != nil && x.V != nil {
+		return *x.V
+	}
+	return 0
+}
+
+type Bool struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	V *bool `protobuf:"varint,1,req,name=v" json:"v,omitempty"`
+}
+
+func (x *Bool) Reset() {
+	*x = Bool{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_required_required_proto_msgTypes[10]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Bool) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Bool) ProtoMessage() {}
+
+func (x *Bool) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_required_required_proto_msgTypes[10]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Bool.ProtoReflect.Descriptor instead.
+func (*Bool) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_required_required_proto_rawDescGZIP(), []int{10}
+}
+
+func (x *Bool) GetV() bool {
+	if x != nil && x.V != nil {
+		return *x.V
+	}
+	return false
+}
+
+type String struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	V *string `protobuf:"bytes,1,req,name=v" json:"v,omitempty"`
+}
+
+func (x *String) Reset() {
+	*x = String{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_required_required_proto_msgTypes[11]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *String) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*String) ProtoMessage() {}
+
+func (x *String) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_required_required_proto_msgTypes[11]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use String.ProtoReflect.Descriptor instead.
+func (*String) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_required_required_proto_rawDescGZIP(), []int{11}
+}
+
+func (x *String) GetV() string {
+	if x != nil && x.V != nil {
+		return *x.V
+	}
+	return ""
+}
+
+type Bytes struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	V []byte `protobuf:"bytes,1,req,name=v" json:"v,omitempty"`
+}
+
+func (x *Bytes) Reset() {
+	*x = Bytes{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_required_required_proto_msgTypes[12]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Bytes) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Bytes) ProtoMessage() {}
+
+func (x *Bytes) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_required_required_proto_msgTypes[12]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Bytes.ProtoReflect.Descriptor instead.
+func (*Bytes) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_required_required_proto_rawDescGZIP(), []int{12}
+}
+
+func (x *Bytes) GetV() []byte {
+	if x != nil {
+		return x.V
+	}
+	return nil
+}
+
+type Message struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	V *Message_M `protobuf:"bytes,1,req,name=v" json:"v,omitempty"`
+}
+
+func (x *Message) Reset() {
+	*x = Message{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_required_required_proto_msgTypes[13]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message) ProtoMessage() {}
+
+func (x *Message) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_required_required_proto_msgTypes[13]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message.ProtoReflect.Descriptor instead.
+func (*Message) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_required_required_proto_rawDescGZIP(), []int{13}
+}
+
+func (x *Message) GetV() *Message_M {
+	if x != nil {
+		return x.V
+	}
+	return nil
+}
+
+type Group struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Group *Group_Group `protobuf:"group,1,req,name=Group,json=group" json:"group,omitempty"`
+}
+
+func (x *Group) Reset() {
+	*x = Group{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_required_required_proto_msgTypes[14]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Group) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Group) ProtoMessage() {}
+
+func (x *Group) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_required_required_proto_msgTypes[14]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Group.ProtoReflect.Descriptor instead.
+func (*Group) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_required_required_proto_rawDescGZIP(), []int{14}
+}
+
+func (x *Group) GetGroup() *Group_Group {
+	if x != nil {
+		return x.Group
+	}
+	return nil
+}
+
+type Message_M struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Message_M) Reset() {
+	*x = Message_M{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_required_required_proto_msgTypes[15]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message_M) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message_M) ProtoMessage() {}
+
+func (x *Message_M) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_required_required_proto_msgTypes[15]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message_M.ProtoReflect.Descriptor instead.
+func (*Message_M) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_required_required_proto_rawDescGZIP(), []int{13, 0}
+}
+
+type Group_Group struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	V *int32 `protobuf:"varint,1,opt,name=v" json:"v,omitempty"`
+}
+
+func (x *Group_Group) Reset() {
+	*x = Group_Group{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_required_required_proto_msgTypes[16]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Group_Group) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Group_Group) ProtoMessage() {}
+
+func (x *Group_Group) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_required_required_proto_msgTypes[16]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Group_Group.ProtoReflect.Descriptor instead.
+func (*Group_Group) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_required_required_proto_rawDescGZIP(), []int{14, 0}
+}
+
+func (x *Group_Group) GetV() int32 {
+	if x != nil && x.V != nil {
+		return *x.V
+	}
+	return 0
+}
+
+var File_internal_testprotos_required_required_proto protoreflect.FileDescriptor
+
+var file_internal_testprotos_required_required_proto_rawDesc = []byte{
+	0x0a, 0x2b, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x2f, 0x72,
+	0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1a, 0x67,
+	0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73,
+	0x74, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x15, 0x0a, 0x05, 0x49, 0x6e, 0x74,
+	0x33, 0x32, 0x12, 0x0c, 0x0a, 0x01, 0x76, 0x18, 0x01, 0x20, 0x02, 0x28, 0x05, 0x52, 0x01, 0x76,
+	0x22, 0x15, 0x0a, 0x05, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x0c, 0x0a, 0x01, 0x76, 0x18, 0x01,
+	0x20, 0x02, 0x28, 0x03, 0x52, 0x01, 0x76, 0x22, 0x16, 0x0a, 0x06, 0x55, 0x69, 0x6e, 0x74, 0x33,
+	0x32, 0x12, 0x0c, 0x0a, 0x01, 0x76, 0x18, 0x01, 0x20, 0x02, 0x28, 0x0d, 0x52, 0x01, 0x76, 0x22,
+	0x16, 0x0a, 0x06, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x0c, 0x0a, 0x01, 0x76, 0x18, 0x01,
+	0x20, 0x02, 0x28, 0x04, 0x52, 0x01, 0x76, 0x22, 0x16, 0x0a, 0x06, 0x53, 0x69, 0x6e, 0x74, 0x33,
+	0x32, 0x12, 0x0c, 0x0a, 0x01, 0x76, 0x18, 0x01, 0x20, 0x02, 0x28, 0x11, 0x52, 0x01, 0x76, 0x22,
+	0x16, 0x0a, 0x06, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x0c, 0x0a, 0x01, 0x76, 0x18, 0x01,
+	0x20, 0x02, 0x28, 0x12, 0x52, 0x01, 0x76, 0x22, 0x17, 0x0a, 0x07, 0x46, 0x69, 0x78, 0x65, 0x64,
+	0x33, 0x32, 0x12, 0x0c, 0x0a, 0x01, 0x76, 0x18, 0x01, 0x20, 0x02, 0x28, 0x07, 0x52, 0x01, 0x76,
+	0x22, 0x17, 0x0a, 0x07, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x0c, 0x0a, 0x01, 0x76,
+	0x18, 0x01, 0x20, 0x02, 0x28, 0x06, 0x52, 0x01, 0x76, 0x22, 0x15, 0x0a, 0x05, 0x46, 0x6c, 0x6f,
+	0x61, 0x74, 0x12, 0x0c, 0x0a, 0x01, 0x76, 0x18, 0x01, 0x20, 0x02, 0x28, 0x02, 0x52, 0x01, 0x76,
+	0x22, 0x16, 0x0a, 0x06, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x0c, 0x0a, 0x01, 0x76, 0x18,
+	0x01, 0x20, 0x02, 0x28, 0x01, 0x52, 0x01, 0x76, 0x22, 0x14, 0x0a, 0x04, 0x42, 0x6f, 0x6f, 0x6c,
+	0x12, 0x0c, 0x0a, 0x01, 0x76, 0x18, 0x01, 0x20, 0x02, 0x28, 0x08, 0x52, 0x01, 0x76, 0x22, 0x16,
+	0x0a, 0x06, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x0c, 0x0a, 0x01, 0x76, 0x18, 0x01, 0x20,
+	0x02, 0x28, 0x09, 0x52, 0x01, 0x76, 0x22, 0x15, 0x0a, 0x05, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12,
+	0x0c, 0x0a, 0x01, 0x76, 0x18, 0x01, 0x20, 0x02, 0x28, 0x0c, 0x52, 0x01, 0x76, 0x22, 0x43, 0x0a,
+	0x07, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x33, 0x0a, 0x01, 0x76, 0x18, 0x01, 0x20,
+	0x02, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x4d, 0x52, 0x01, 0x76, 0x1a, 0x03, 0x0a,
+	0x01, 0x4d, 0x22, 0x5d, 0x0a, 0x05, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x3d, 0x0a, 0x05, 0x67,
+	0x72, 0x6f, 0x75, 0x70, 0x18, 0x01, 0x20, 0x02, 0x28, 0x0a, 0x32, 0x27, 0x2e, 0x67, 0x6f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x72,
+	0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x47, 0x72,
+	0x6f, 0x75, 0x70, 0x52, 0x05, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x1a, 0x15, 0x0a, 0x05, 0x47, 0x72,
+	0x6f, 0x75, 0x70, 0x12, 0x0c, 0x0a, 0x01, 0x76, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x01,
+	0x76, 0x42, 0x39, 0x5a, 0x37, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61,
+	0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f,
+	0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x73, 0x2f, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64,
+}
+
+var (
+	file_internal_testprotos_required_required_proto_rawDescOnce sync.Once
+	file_internal_testprotos_required_required_proto_rawDescData = file_internal_testprotos_required_required_proto_rawDesc
+)
+
+func file_internal_testprotos_required_required_proto_rawDescGZIP() []byte {
+	file_internal_testprotos_required_required_proto_rawDescOnce.Do(func() {
+		file_internal_testprotos_required_required_proto_rawDescData = protoimpl.X.CompressGZIP(file_internal_testprotos_required_required_proto_rawDescData)
+	})
+	return file_internal_testprotos_required_required_proto_rawDescData
+}
+
+var file_internal_testprotos_required_required_proto_msgTypes = make([]protoimpl.MessageInfo, 17)
+var file_internal_testprotos_required_required_proto_goTypes = []interface{}{
+	(*Int32)(nil),       // 0: goproto.proto.testrequired.Int32
+	(*Int64)(nil),       // 1: goproto.proto.testrequired.Int64
+	(*Uint32)(nil),      // 2: goproto.proto.testrequired.Uint32
+	(*Uint64)(nil),      // 3: goproto.proto.testrequired.Uint64
+	(*Sint32)(nil),      // 4: goproto.proto.testrequired.Sint32
+	(*Sint64)(nil),      // 5: goproto.proto.testrequired.Sint64
+	(*Fixed32)(nil),     // 6: goproto.proto.testrequired.Fixed32
+	(*Fixed64)(nil),     // 7: goproto.proto.testrequired.Fixed64
+	(*Float)(nil),       // 8: goproto.proto.testrequired.Float
+	(*Double)(nil),      // 9: goproto.proto.testrequired.Double
+	(*Bool)(nil),        // 10: goproto.proto.testrequired.Bool
+	(*String)(nil),      // 11: goproto.proto.testrequired.String
+	(*Bytes)(nil),       // 12: goproto.proto.testrequired.Bytes
+	(*Message)(nil),     // 13: goproto.proto.testrequired.Message
+	(*Group)(nil),       // 14: goproto.proto.testrequired.Group
+	(*Message_M)(nil),   // 15: goproto.proto.testrequired.Message.M
+	(*Group_Group)(nil), // 16: goproto.proto.testrequired.Group.Group
+}
+var file_internal_testprotos_required_required_proto_depIdxs = []int32{
+	15, // 0: goproto.proto.testrequired.Message.v:type_name -> goproto.proto.testrequired.Message.M
+	16, // 1: goproto.proto.testrequired.Group.group:type_name -> goproto.proto.testrequired.Group.Group
+	2,  // [2:2] is the sub-list for method output_type
+	2,  // [2:2] is the sub-list for method input_type
+	2,  // [2:2] is the sub-list for extension type_name
+	2,  // [2:2] is the sub-list for extension extendee
+	0,  // [0:2] is the sub-list for field type_name
+}
+
+func init() { file_internal_testprotos_required_required_proto_init() }
+func file_internal_testprotos_required_required_proto_init() {
+	if File_internal_testprotos_required_required_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_internal_testprotos_required_required_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Int32); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_required_required_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Int64); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_required_required_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Uint32); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_required_required_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Uint64); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_required_required_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Sint32); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_required_required_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Sint64); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_required_required_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Fixed32); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_required_required_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Fixed64); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_required_required_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Float); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_required_required_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Double); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_required_required_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Bool); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_required_required_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*String); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_required_required_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Bytes); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_required_required_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_required_required_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Group); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_required_required_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Message_M); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_required_required_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Group_Group); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_internal_testprotos_required_required_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   17,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_internal_testprotos_required_required_proto_goTypes,
+		DependencyIndexes: file_internal_testprotos_required_required_proto_depIdxs,
+		MessageInfos:      file_internal_testprotos_required_required_proto_msgTypes,
+	}.Build()
+	File_internal_testprotos_required_required_proto = out.File
+	file_internal_testprotos_required_required_proto_rawDesc = nil
+	file_internal_testprotos_required_required_proto_goTypes = nil
+	file_internal_testprotos_required_required_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/required/required.proto b/vendor/google.golang.org/protobuf/internal/testprotos/required/required.proto
new file mode 100644
index 000000000..53c419811
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/required/required.proto
@@ -0,0 +1,72 @@
+// Copyright 2020 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.
+
+syntax = "proto2";
+
+package goproto.proto.testrequired;
+
+option go_package = "google.golang.org/protobuf/internal/testprotos/required";
+
+message Int32 {
+  required int32 v = 1;
+}
+
+message Int64 {
+  required int64 v =  1;
+}
+
+message Uint32 {
+  required uint32 v =  1;
+}
+
+message Uint64 {
+  required uint64 v =  1;
+}
+
+message Sint32 {
+  required sint32 v =  1;
+}
+
+message Sint64 {
+  required sint64 v =  1;
+}
+
+message Fixed32 {
+  required fixed32 v =  1;
+}
+
+message Fixed64 {
+  required fixed64 v =  1;
+}
+
+message Float {
+  required float v =  1;
+}
+
+message Double {
+  required double v =  1;
+}
+
+message Bool {
+  required bool v =  1;
+}
+
+message String {
+  required string v =  1;
+}
+
+message Bytes {
+  required bytes v =  1;
+}
+
+message Message {
+  message M {}
+  required M v = 1;
+}
+
+message Group {
+  required group Group = 1 {
+    optional int32 v = 1;
+  }
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/test/ext.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/test/ext.pb.go
new file mode 100644
index 000000000..194b4c527
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/test/ext.pb.go
@@ -0,0 +1,90 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: internal/testprotos/test/ext.proto
+
+package test
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+)
+
+var file_internal_testprotos_test_ext_proto_extTypes = []protoimpl.ExtensionInfo{
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: (*int32)(nil),
+		Field:         2000,
+		Name:          "goproto.proto.test.foreign_int32_extension",
+		Tag:           "varint,2000,opt,name=foreign_int32_extension",
+		Filename:      "internal/testprotos/test/ext.proto",
+	},
+}
+
+// Extension fields to TestAllExtensions.
+var (
+	// optional int32 foreign_int32_extension = 2000;
+	E_ForeignInt32Extension = &file_internal_testprotos_test_ext_proto_extTypes[0]
+)
+
+var File_internal_testprotos_test_ext_proto protoreflect.FileDescriptor
+
+var file_internal_testprotos_test_ext_proto_rawDesc = []byte{
+	0x0a, 0x22, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x65, 0x78, 0x74, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e,
+	0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x74, 0x65,
+	0x73, 0x74, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x3a, 0x5e, 0x0a,
+	0x17, 0x66, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x65,
+	0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65,
+	0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18,
+	0xd0, 0x0f, 0x20, 0x01, 0x28, 0x05, 0x52, 0x15, 0x66, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x49,
+	0x6e, 0x74, 0x33, 0x32, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x42, 0x35, 0x5a,
+	0x33, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f,
+	0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x69, 0x6e, 0x74, 0x65,
+	0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f,
+	0x74, 0x65, 0x73, 0x74,
+}
+
+var file_internal_testprotos_test_ext_proto_goTypes = []interface{}{
+	(*TestAllExtensions)(nil), // 0: goproto.proto.test.TestAllExtensions
+}
+var file_internal_testprotos_test_ext_proto_depIdxs = []int32{
+	0, // 0: goproto.proto.test.foreign_int32_extension:extendee -> goproto.proto.test.TestAllExtensions
+	1, // [1:1] is the sub-list for method output_type
+	1, // [1:1] is the sub-list for method input_type
+	1, // [1:1] is the sub-list for extension type_name
+	0, // [0:1] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_internal_testprotos_test_ext_proto_init() }
+func file_internal_testprotos_test_ext_proto_init() {
+	if File_internal_testprotos_test_ext_proto != nil {
+		return
+	}
+	file_internal_testprotos_test_test_proto_init()
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_internal_testprotos_test_ext_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   0,
+			NumExtensions: 1,
+			NumServices:   0,
+		},
+		GoTypes:           file_internal_testprotos_test_ext_proto_goTypes,
+		DependencyIndexes: file_internal_testprotos_test_ext_proto_depIdxs,
+		ExtensionInfos:    file_internal_testprotos_test_ext_proto_extTypes,
+	}.Build()
+	File_internal_testprotos_test_ext_proto = out.File
+	file_internal_testprotos_test_ext_proto_rawDesc = nil
+	file_internal_testprotos_test_ext_proto_goTypes = nil
+	file_internal_testprotos_test_ext_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/test/ext.proto b/vendor/google.golang.org/protobuf/internal/testprotos/test/ext.proto
new file mode 100644
index 000000000..9ff1dd61a
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/test/ext.proto
@@ -0,0 +1,15 @@
+// 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.
+
+syntax = "proto2";
+
+package goproto.proto.test;
+
+import "internal/testprotos/test/test.proto";
+
+option go_package = "google.golang.org/protobuf/internal/testprotos/test";
+
+extend TestAllExtensions {
+  optional int32    foreign_int32_extension =  2000;
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/test/test.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/test/test.pb.go
new file mode 100644
index 000000000..2541f7f92
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/test/test.pb.go
@@ -0,0 +1,5266 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: internal/testprotos/test/test.proto
+
+package test
+
+import (
+	proto "google.golang.org/protobuf/proto"
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoiface "google.golang.org/protobuf/runtime/protoiface"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type ForeignEnum int32
+
+const (
+	ForeignEnum_FOREIGN_FOO ForeignEnum = 4
+	ForeignEnum_FOREIGN_BAR ForeignEnum = 5
+	ForeignEnum_FOREIGN_BAZ ForeignEnum = 6
+)
+
+// Enum value maps for ForeignEnum.
+var (
+	ForeignEnum_name = map[int32]string{
+		4: "FOREIGN_FOO",
+		5: "FOREIGN_BAR",
+		6: "FOREIGN_BAZ",
+	}
+	ForeignEnum_value = map[string]int32{
+		"FOREIGN_FOO": 4,
+		"FOREIGN_BAR": 5,
+		"FOREIGN_BAZ": 6,
+	}
+)
+
+func (x ForeignEnum) Enum() *ForeignEnum {
+	p := new(ForeignEnum)
+	*p = x
+	return p
+}
+
+func (x ForeignEnum) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (ForeignEnum) Descriptor() protoreflect.EnumDescriptor {
+	return file_internal_testprotos_test_test_proto_enumTypes[0].Descriptor()
+}
+
+func (ForeignEnum) Type() protoreflect.EnumType {
+	return &file_internal_testprotos_test_test_proto_enumTypes[0]
+}
+
+func (x ForeignEnum) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *ForeignEnum) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = ForeignEnum(num)
+	return nil
+}
+
+// Deprecated: Use ForeignEnum.Descriptor instead.
+func (ForeignEnum) EnumDescriptor() ([]byte, []int) {
+	return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{0}
+}
+
+type TestReservedEnumFields int32
+
+const (
+	TestReservedEnumFields_RESERVED_ENUM TestReservedEnumFields = 0
+)
+
+// Enum value maps for TestReservedEnumFields.
+var (
+	TestReservedEnumFields_name = map[int32]string{
+		0: "RESERVED_ENUM",
+	}
+	TestReservedEnumFields_value = map[string]int32{
+		"RESERVED_ENUM": 0,
+	}
+)
+
+func (x TestReservedEnumFields) Enum() *TestReservedEnumFields {
+	p := new(TestReservedEnumFields)
+	*p = x
+	return p
+}
+
+func (x TestReservedEnumFields) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (TestReservedEnumFields) Descriptor() protoreflect.EnumDescriptor {
+	return file_internal_testprotos_test_test_proto_enumTypes[1].Descriptor()
+}
+
+func (TestReservedEnumFields) Type() protoreflect.EnumType {
+	return &file_internal_testprotos_test_test_proto_enumTypes[1]
+}
+
+func (x TestReservedEnumFields) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *TestReservedEnumFields) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = TestReservedEnumFields(num)
+	return nil
+}
+
+// Deprecated: Use TestReservedEnumFields.Descriptor instead.
+func (TestReservedEnumFields) EnumDescriptor() ([]byte, []int) {
+	return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{1}
+}
+
+type TestAllTypes_NestedEnum int32
+
+const (
+	TestAllTypes_FOO TestAllTypes_NestedEnum = 0
+	TestAllTypes_BAR TestAllTypes_NestedEnum = 1
+	TestAllTypes_BAZ TestAllTypes_NestedEnum = 2
+	TestAllTypes_NEG TestAllTypes_NestedEnum = -1 // Intentionally negative.
+)
+
+// Enum value maps for TestAllTypes_NestedEnum.
+var (
+	TestAllTypes_NestedEnum_name = map[int32]string{
+		0:  "FOO",
+		1:  "BAR",
+		2:  "BAZ",
+		-1: "NEG",
+	}
+	TestAllTypes_NestedEnum_value = map[string]int32{
+		"FOO": 0,
+		"BAR": 1,
+		"BAZ": 2,
+		"NEG": -1,
+	}
+)
+
+func (x TestAllTypes_NestedEnum) Enum() *TestAllTypes_NestedEnum {
+	p := new(TestAllTypes_NestedEnum)
+	*p = x
+	return p
+}
+
+func (x TestAllTypes_NestedEnum) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (TestAllTypes_NestedEnum) Descriptor() protoreflect.EnumDescriptor {
+	return file_internal_testprotos_test_test_proto_enumTypes[2].Descriptor()
+}
+
+func (TestAllTypes_NestedEnum) Type() protoreflect.EnumType {
+	return &file_internal_testprotos_test_test_proto_enumTypes[2]
+}
+
+func (x TestAllTypes_NestedEnum) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *TestAllTypes_NestedEnum) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = TestAllTypes_NestedEnum(num)
+	return nil
+}
+
+// Deprecated: Use TestAllTypes_NestedEnum.Descriptor instead.
+func (TestAllTypes_NestedEnum) EnumDescriptor() ([]byte, []int) {
+	return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{0, 0}
+}
+
+// Deprecated: Do not use.
+type TestDeprecatedMessage_DeprecatedEnum int32
+
+const (
+	// Deprecated: Do not use.
+	TestDeprecatedMessage_DEPRECATED TestDeprecatedMessage_DeprecatedEnum = 0
+)
+
+// Enum value maps for TestDeprecatedMessage_DeprecatedEnum.
+var (
+	TestDeprecatedMessage_DeprecatedEnum_name = map[int32]string{
+		0: "DEPRECATED",
+	}
+	TestDeprecatedMessage_DeprecatedEnum_value = map[string]int32{
+		"DEPRECATED": 0,
+	}
+)
+
+func (x TestDeprecatedMessage_DeprecatedEnum) Enum() *TestDeprecatedMessage_DeprecatedEnum {
+	p := new(TestDeprecatedMessage_DeprecatedEnum)
+	*p = x
+	return p
+}
+
+func (x TestDeprecatedMessage_DeprecatedEnum) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (TestDeprecatedMessage_DeprecatedEnum) Descriptor() protoreflect.EnumDescriptor {
+	return file_internal_testprotos_test_test_proto_enumTypes[3].Descriptor()
+}
+
+func (TestDeprecatedMessage_DeprecatedEnum) Type() protoreflect.EnumType {
+	return &file_internal_testprotos_test_test_proto_enumTypes[3]
+}
+
+func (x TestDeprecatedMessage_DeprecatedEnum) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *TestDeprecatedMessage_DeprecatedEnum) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = TestDeprecatedMessage_DeprecatedEnum(num)
+	return nil
+}
+
+// Deprecated: Use TestDeprecatedMessage_DeprecatedEnum.Descriptor instead.
+func (TestDeprecatedMessage_DeprecatedEnum) EnumDescriptor() ([]byte, []int) {
+	return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{1, 0}
+}
+
+type TestAllTypes struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	OptionalInt32          *int32                                 `protobuf:"varint,1,opt,name=optional_int32,json=optionalInt32" json:"optional_int32,omitempty"`
+	OptionalInt64          *int64                                 `protobuf:"varint,2,opt,name=optional_int64,json=optionalInt64" json:"optional_int64,omitempty"`
+	OptionalUint32         *uint32                                `protobuf:"varint,3,opt,name=optional_uint32,json=optionalUint32" json:"optional_uint32,omitempty"`
+	OptionalUint64         *uint64                                `protobuf:"varint,4,opt,name=optional_uint64,json=optionalUint64" json:"optional_uint64,omitempty"`
+	OptionalSint32         *int32                                 `protobuf:"zigzag32,5,opt,name=optional_sint32,json=optionalSint32" json:"optional_sint32,omitempty"`
+	OptionalSint64         *int64                                 `protobuf:"zigzag64,6,opt,name=optional_sint64,json=optionalSint64" json:"optional_sint64,omitempty"`
+	OptionalFixed32        *uint32                                `protobuf:"fixed32,7,opt,name=optional_fixed32,json=optionalFixed32" json:"optional_fixed32,omitempty"`
+	OptionalFixed64        *uint64                                `protobuf:"fixed64,8,opt,name=optional_fixed64,json=optionalFixed64" json:"optional_fixed64,omitempty"`
+	OptionalSfixed32       *int32                                 `protobuf:"fixed32,9,opt,name=optional_sfixed32,json=optionalSfixed32" json:"optional_sfixed32,omitempty"`
+	OptionalSfixed64       *int64                                 `protobuf:"fixed64,10,opt,name=optional_sfixed64,json=optionalSfixed64" json:"optional_sfixed64,omitempty"`
+	OptionalFloat          *float32                               `protobuf:"fixed32,11,opt,name=optional_float,json=optionalFloat" json:"optional_float,omitempty"`
+	OptionalDouble         *float64                               `protobuf:"fixed64,12,opt,name=optional_double,json=optionalDouble" json:"optional_double,omitempty"`
+	OptionalBool           *bool                                  `protobuf:"varint,13,opt,name=optional_bool,json=optionalBool" json:"optional_bool,omitempty"`
+	OptionalString         *string                                `protobuf:"bytes,14,opt,name=optional_string,json=optionalString" json:"optional_string,omitempty"`
+	OptionalBytes          []byte                                 `protobuf:"bytes,15,opt,name=optional_bytes,json=optionalBytes" json:"optional_bytes,omitempty"`
+	Optionalgroup          *TestAllTypes_OptionalGroup            `protobuf:"group,16,opt,name=OptionalGroup,json=optionalgroup" json:"optionalgroup,omitempty"`
+	OptionalNestedMessage  *TestAllTypes_NestedMessage            `protobuf:"bytes,18,opt,name=optional_nested_message,json=optionalNestedMessage" json:"optional_nested_message,omitempty"`
+	OptionalForeignMessage *ForeignMessage                        `protobuf:"bytes,19,opt,name=optional_foreign_message,json=optionalForeignMessage" json:"optional_foreign_message,omitempty"`
+	OptionalImportMessage  *ImportMessage                         `protobuf:"bytes,20,opt,name=optional_import_message,json=optionalImportMessage" json:"optional_import_message,omitempty"`
+	OptionalNestedEnum     *TestAllTypes_NestedEnum               `protobuf:"varint,21,opt,name=optional_nested_enum,json=optionalNestedEnum,enum=goproto.proto.test.TestAllTypes_NestedEnum" json:"optional_nested_enum,omitempty"`
+	OptionalForeignEnum    *ForeignEnum                           `protobuf:"varint,22,opt,name=optional_foreign_enum,json=optionalForeignEnum,enum=goproto.proto.test.ForeignEnum" json:"optional_foreign_enum,omitempty"`
+	OptionalImportEnum     *ImportEnum                            `protobuf:"varint,23,opt,name=optional_import_enum,json=optionalImportEnum,enum=goproto.proto.test.ImportEnum" json:"optional_import_enum,omitempty"`
+	RepeatedInt32          []int32                                `protobuf:"varint,31,rep,name=repeated_int32,json=repeatedInt32" json:"repeated_int32,omitempty"`
+	RepeatedInt64          []int64                                `protobuf:"varint,32,rep,name=repeated_int64,json=repeatedInt64" json:"repeated_int64,omitempty"`
+	RepeatedUint32         []uint32                               `protobuf:"varint,33,rep,name=repeated_uint32,json=repeatedUint32" json:"repeated_uint32,omitempty"`
+	RepeatedUint64         []uint64                               `protobuf:"varint,34,rep,name=repeated_uint64,json=repeatedUint64" json:"repeated_uint64,omitempty"`
+	RepeatedSint32         []int32                                `protobuf:"zigzag32,35,rep,name=repeated_sint32,json=repeatedSint32" json:"repeated_sint32,omitempty"`
+	RepeatedSint64         []int64                                `protobuf:"zigzag64,36,rep,name=repeated_sint64,json=repeatedSint64" json:"repeated_sint64,omitempty"`
+	RepeatedFixed32        []uint32                               `protobuf:"fixed32,37,rep,name=repeated_fixed32,json=repeatedFixed32" json:"repeated_fixed32,omitempty"`
+	RepeatedFixed64        []uint64                               `protobuf:"fixed64,38,rep,name=repeated_fixed64,json=repeatedFixed64" json:"repeated_fixed64,omitempty"`
+	RepeatedSfixed32       []int32                                `protobuf:"fixed32,39,rep,name=repeated_sfixed32,json=repeatedSfixed32" json:"repeated_sfixed32,omitempty"`
+	RepeatedSfixed64       []int64                                `protobuf:"fixed64,40,rep,name=repeated_sfixed64,json=repeatedSfixed64" json:"repeated_sfixed64,omitempty"`
+	RepeatedFloat          []float32                              `protobuf:"fixed32,41,rep,name=repeated_float,json=repeatedFloat" json:"repeated_float,omitempty"`
+	RepeatedDouble         []float64                              `protobuf:"fixed64,42,rep,name=repeated_double,json=repeatedDouble" json:"repeated_double,omitempty"`
+	RepeatedBool           []bool                                 `protobuf:"varint,43,rep,name=repeated_bool,json=repeatedBool" json:"repeated_bool,omitempty"`
+	RepeatedString         []string                               `protobuf:"bytes,44,rep,name=repeated_string,json=repeatedString" json:"repeated_string,omitempty"`
+	RepeatedBytes          [][]byte                               `protobuf:"bytes,45,rep,name=repeated_bytes,json=repeatedBytes" json:"repeated_bytes,omitempty"`
+	Repeatedgroup          []*TestAllTypes_RepeatedGroup          `protobuf:"group,46,rep,name=RepeatedGroup,json=repeatedgroup" json:"repeatedgroup,omitempty"`
+	RepeatedNestedMessage  []*TestAllTypes_NestedMessage          `protobuf:"bytes,48,rep,name=repeated_nested_message,json=repeatedNestedMessage" json:"repeated_nested_message,omitempty"`
+	RepeatedForeignMessage []*ForeignMessage                      `protobuf:"bytes,49,rep,name=repeated_foreign_message,json=repeatedForeignMessage" json:"repeated_foreign_message,omitempty"`
+	RepeatedImportmessage  []*ImportMessage                       `protobuf:"bytes,50,rep,name=repeated_importmessage,json=repeatedImportmessage" json:"repeated_importmessage,omitempty"`
+	RepeatedNestedEnum     []TestAllTypes_NestedEnum              `protobuf:"varint,51,rep,name=repeated_nested_enum,json=repeatedNestedEnum,enum=goproto.proto.test.TestAllTypes_NestedEnum" json:"repeated_nested_enum,omitempty"`
+	RepeatedForeignEnum    []ForeignEnum                          `protobuf:"varint,52,rep,name=repeated_foreign_enum,json=repeatedForeignEnum,enum=goproto.proto.test.ForeignEnum" json:"repeated_foreign_enum,omitempty"`
+	RepeatedImportenum     []ImportEnum                           `protobuf:"varint,53,rep,name=repeated_importenum,json=repeatedImportenum,enum=goproto.proto.test.ImportEnum" json:"repeated_importenum,omitempty"`
+	MapInt32Int32          map[int32]int32                        `protobuf:"bytes,56,rep,name=map_int32_int32,json=mapInt32Int32" json:"map_int32_int32,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
+	MapInt64Int64          map[int64]int64                        `protobuf:"bytes,57,rep,name=map_int64_int64,json=mapInt64Int64" json:"map_int64_int64,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
+	MapUint32Uint32        map[uint32]uint32                      `protobuf:"bytes,58,rep,name=map_uint32_uint32,json=mapUint32Uint32" json:"map_uint32_uint32,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
+	MapUint64Uint64        map[uint64]uint64                      `protobuf:"bytes,59,rep,name=map_uint64_uint64,json=mapUint64Uint64" json:"map_uint64_uint64,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
+	MapSint32Sint32        map[int32]int32                        `protobuf:"bytes,60,rep,name=map_sint32_sint32,json=mapSint32Sint32" json:"map_sint32_sint32,omitempty" protobuf_key:"zigzag32,1,opt,name=key" protobuf_val:"zigzag32,2,opt,name=value"`
+	MapSint64Sint64        map[int64]int64                        `protobuf:"bytes,61,rep,name=map_sint64_sint64,json=mapSint64Sint64" json:"map_sint64_sint64,omitempty" protobuf_key:"zigzag64,1,opt,name=key" protobuf_val:"zigzag64,2,opt,name=value"`
+	MapFixed32Fixed32      map[uint32]uint32                      `protobuf:"bytes,62,rep,name=map_fixed32_fixed32,json=mapFixed32Fixed32" json:"map_fixed32_fixed32,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
+	MapFixed64Fixed64      map[uint64]uint64                      `protobuf:"bytes,63,rep,name=map_fixed64_fixed64,json=mapFixed64Fixed64" json:"map_fixed64_fixed64,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
+	MapSfixed32Sfixed32    map[int32]int32                        `protobuf:"bytes,64,rep,name=map_sfixed32_sfixed32,json=mapSfixed32Sfixed32" json:"map_sfixed32_sfixed32,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
+	MapSfixed64Sfixed64    map[int64]int64                        `protobuf:"bytes,65,rep,name=map_sfixed64_sfixed64,json=mapSfixed64Sfixed64" json:"map_sfixed64_sfixed64,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
+	MapInt32Float          map[int32]float32                      `protobuf:"bytes,66,rep,name=map_int32_float,json=mapInt32Float" json:"map_int32_float,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
+	MapInt32Double         map[int32]float64                      `protobuf:"bytes,67,rep,name=map_int32_double,json=mapInt32Double" json:"map_int32_double,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
+	MapBoolBool            map[bool]bool                          `protobuf:"bytes,68,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"`
+	MapStringString        map[string]string                      `protobuf:"bytes,69,rep,name=map_string_string,json=mapStringString" json:"map_string_string,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+	MapStringBytes         map[string][]byte                      `protobuf:"bytes,70,rep,name=map_string_bytes,json=mapStringBytes" json:"map_string_bytes,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+	MapStringNestedMessage map[string]*TestAllTypes_NestedMessage `protobuf:"bytes,71,rep,name=map_string_nested_message,json=mapStringNestedMessage" json:"map_string_nested_message,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+	MapStringNestedEnum    map[string]TestAllTypes_NestedEnum     `protobuf:"bytes,73,rep,name=map_string_nested_enum,json=mapStringNestedEnum" json:"map_string_nested_enum,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=goproto.proto.test.TestAllTypes_NestedEnum"`
+	// Singular with defaults
+	DefaultInt32       *int32                   `protobuf:"varint,81,opt,name=default_int32,json=defaultInt32,def=81" json:"default_int32,omitempty"`
+	DefaultInt64       *int64                   `protobuf:"varint,82,opt,name=default_int64,json=defaultInt64,def=82" json:"default_int64,omitempty"`
+	DefaultUint32      *uint32                  `protobuf:"varint,83,opt,name=default_uint32,json=defaultUint32,def=83" json:"default_uint32,omitempty"`
+	DefaultUint64      *uint64                  `protobuf:"varint,84,opt,name=default_uint64,json=defaultUint64,def=84" json:"default_uint64,omitempty"`
+	DefaultSint32      *int32                   `protobuf:"zigzag32,85,opt,name=default_sint32,json=defaultSint32,def=-85" json:"default_sint32,omitempty"`
+	DefaultSint64      *int64                   `protobuf:"zigzag64,86,opt,name=default_sint64,json=defaultSint64,def=86" json:"default_sint64,omitempty"`
+	DefaultFixed32     *uint32                  `protobuf:"fixed32,87,opt,name=default_fixed32,json=defaultFixed32,def=87" json:"default_fixed32,omitempty"`
+	DefaultFixed64     *uint64                  `protobuf:"fixed64,88,opt,name=default_fixed64,json=defaultFixed64,def=88" json:"default_fixed64,omitempty"`
+	DefaultSfixed32    *int32                   `protobuf:"fixed32,89,opt,name=default_sfixed32,json=defaultSfixed32,def=89" json:"default_sfixed32,omitempty"`
+	DefaultSfixed64    *int64                   `protobuf:"fixed64,80,opt,name=default_sfixed64,json=defaultSfixed64,def=-90" json:"default_sfixed64,omitempty"`
+	DefaultFloat       *float32                 `protobuf:"fixed32,91,opt,name=default_float,json=defaultFloat,def=91.5" json:"default_float,omitempty"`
+	DefaultDouble      *float64                 `protobuf:"fixed64,92,opt,name=default_double,json=defaultDouble,def=92000" json:"default_double,omitempty"`
+	DefaultBool        *bool                    `protobuf:"varint,93,opt,name=default_bool,json=defaultBool,def=1" json:"default_bool,omitempty"`
+	DefaultString      *string                  `protobuf:"bytes,94,opt,name=default_string,json=defaultString,def=hello" json:"default_string,omitempty"`
+	DefaultBytes       []byte                   `protobuf:"bytes,95,opt,name=default_bytes,json=defaultBytes,def=world" json:"default_bytes,omitempty"`
+	DefaultNestedEnum  *TestAllTypes_NestedEnum `protobuf:"varint,96,opt,name=default_nested_enum,json=defaultNestedEnum,enum=goproto.proto.test.TestAllTypes_NestedEnum,def=1" json:"default_nested_enum,omitempty"`
+	DefaultForeignEnum *ForeignEnum             `protobuf:"varint,97,opt,name=default_foreign_enum,json=defaultForeignEnum,enum=goproto.proto.test.ForeignEnum,def=5" json:"default_foreign_enum,omitempty"`
+	// Types that are assignable to OneofField:
+	//	*TestAllTypes_OneofUint32
+	//	*TestAllTypes_OneofNestedMessage
+	//	*TestAllTypes_OneofString
+	//	*TestAllTypes_OneofBytes
+	//	*TestAllTypes_OneofBool
+	//	*TestAllTypes_OneofUint64
+	//	*TestAllTypes_OneofFloat
+	//	*TestAllTypes_OneofDouble
+	//	*TestAllTypes_OneofEnum
+	//	*TestAllTypes_Oneofgroup
+	OneofField isTestAllTypes_OneofField `protobuf_oneof:"oneof_field"`
+	// A oneof with exactly one field.
+	//
+	// Types that are assignable to OneofOptional:
+	//	*TestAllTypes_OneofOptionalUint32
+	OneofOptional isTestAllTypes_OneofOptional `protobuf_oneof:"oneof_optional"`
+}
+
+// Default values for TestAllTypes fields.
+const (
+	Default_TestAllTypes_DefaultInt32       = int32(81)
+	Default_TestAllTypes_DefaultInt64       = int64(82)
+	Default_TestAllTypes_DefaultUint32      = uint32(83)
+	Default_TestAllTypes_DefaultUint64      = uint64(84)
+	Default_TestAllTypes_DefaultSint32      = int32(-85)
+	Default_TestAllTypes_DefaultSint64      = int64(86)
+	Default_TestAllTypes_DefaultFixed32     = uint32(87)
+	Default_TestAllTypes_DefaultFixed64     = uint64(88)
+	Default_TestAllTypes_DefaultSfixed32    = int32(89)
+	Default_TestAllTypes_DefaultSfixed64    = int64(-90)
+	Default_TestAllTypes_DefaultFloat       = float32(91.5)
+	Default_TestAllTypes_DefaultDouble      = float64(92000)
+	Default_TestAllTypes_DefaultBool        = bool(true)
+	Default_TestAllTypes_DefaultString      = string("hello")
+	Default_TestAllTypes_DefaultNestedEnum  = TestAllTypes_BAR
+	Default_TestAllTypes_DefaultForeignEnum = ForeignEnum_FOREIGN_BAR
+)
+
+// Default values for TestAllTypes fields.
+var (
+	Default_TestAllTypes_DefaultBytes = []byte("world")
+)
+
+func (x *TestAllTypes) Reset() {
+	*x = TestAllTypes{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_test_test_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *TestAllTypes) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TestAllTypes) ProtoMessage() {}
+
+func (x *TestAllTypes) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_test_test_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TestAllTypes.ProtoReflect.Descriptor instead.
+func (*TestAllTypes) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *TestAllTypes) GetOptionalInt32() int32 {
+	if x != nil && x.OptionalInt32 != nil {
+		return *x.OptionalInt32
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetOptionalInt64() int64 {
+	if x != nil && x.OptionalInt64 != nil {
+		return *x.OptionalInt64
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetOptionalUint32() uint32 {
+	if x != nil && x.OptionalUint32 != nil {
+		return *x.OptionalUint32
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetOptionalUint64() uint64 {
+	if x != nil && x.OptionalUint64 != nil {
+		return *x.OptionalUint64
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetOptionalSint32() int32 {
+	if x != nil && x.OptionalSint32 != nil {
+		return *x.OptionalSint32
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetOptionalSint64() int64 {
+	if x != nil && x.OptionalSint64 != nil {
+		return *x.OptionalSint64
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetOptionalFixed32() uint32 {
+	if x != nil && x.OptionalFixed32 != nil {
+		return *x.OptionalFixed32
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetOptionalFixed64() uint64 {
+	if x != nil && x.OptionalFixed64 != nil {
+		return *x.OptionalFixed64
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetOptionalSfixed32() int32 {
+	if x != nil && x.OptionalSfixed32 != nil {
+		return *x.OptionalSfixed32
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetOptionalSfixed64() int64 {
+	if x != nil && x.OptionalSfixed64 != nil {
+		return *x.OptionalSfixed64
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetOptionalFloat() float32 {
+	if x != nil && x.OptionalFloat != nil {
+		return *x.OptionalFloat
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetOptionalDouble() float64 {
+	if x != nil && x.OptionalDouble != nil {
+		return *x.OptionalDouble
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetOptionalBool() bool {
+	if x != nil && x.OptionalBool != nil {
+		return *x.OptionalBool
+	}
+	return false
+}
+
+func (x *TestAllTypes) GetOptionalString() string {
+	if x != nil && x.OptionalString != nil {
+		return *x.OptionalString
+	}
+	return ""
+}
+
+func (x *TestAllTypes) GetOptionalBytes() []byte {
+	if x != nil {
+		return x.OptionalBytes
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetOptionalgroup() *TestAllTypes_OptionalGroup {
+	if x != nil {
+		return x.Optionalgroup
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetOptionalNestedMessage() *TestAllTypes_NestedMessage {
+	if x != nil {
+		return x.OptionalNestedMessage
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetOptionalForeignMessage() *ForeignMessage {
+	if x != nil {
+		return x.OptionalForeignMessage
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetOptionalImportMessage() *ImportMessage {
+	if x != nil {
+		return x.OptionalImportMessage
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetOptionalNestedEnum() TestAllTypes_NestedEnum {
+	if x != nil && x.OptionalNestedEnum != nil {
+		return *x.OptionalNestedEnum
+	}
+	return TestAllTypes_FOO
+}
+
+func (x *TestAllTypes) GetOptionalForeignEnum() ForeignEnum {
+	if x != nil && x.OptionalForeignEnum != nil {
+		return *x.OptionalForeignEnum
+	}
+	return ForeignEnum_FOREIGN_FOO
+}
+
+func (x *TestAllTypes) GetOptionalImportEnum() ImportEnum {
+	if x != nil && x.OptionalImportEnum != nil {
+		return *x.OptionalImportEnum
+	}
+	return ImportEnum_IMPORT_ZERO
+}
+
+func (x *TestAllTypes) GetRepeatedInt32() []int32 {
+	if x != nil {
+		return x.RepeatedInt32
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedInt64() []int64 {
+	if x != nil {
+		return x.RepeatedInt64
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedUint32() []uint32 {
+	if x != nil {
+		return x.RepeatedUint32
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedUint64() []uint64 {
+	if x != nil {
+		return x.RepeatedUint64
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedSint32() []int32 {
+	if x != nil {
+		return x.RepeatedSint32
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedSint64() []int64 {
+	if x != nil {
+		return x.RepeatedSint64
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedFixed32() []uint32 {
+	if x != nil {
+		return x.RepeatedFixed32
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedFixed64() []uint64 {
+	if x != nil {
+		return x.RepeatedFixed64
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedSfixed32() []int32 {
+	if x != nil {
+		return x.RepeatedSfixed32
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedSfixed64() []int64 {
+	if x != nil {
+		return x.RepeatedSfixed64
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedFloat() []float32 {
+	if x != nil {
+		return x.RepeatedFloat
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedDouble() []float64 {
+	if x != nil {
+		return x.RepeatedDouble
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedBool() []bool {
+	if x != nil {
+		return x.RepeatedBool
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedString() []string {
+	if x != nil {
+		return x.RepeatedString
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedBytes() [][]byte {
+	if x != nil {
+		return x.RepeatedBytes
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedgroup() []*TestAllTypes_RepeatedGroup {
+	if x != nil {
+		return x.Repeatedgroup
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedNestedMessage() []*TestAllTypes_NestedMessage {
+	if x != nil {
+		return x.RepeatedNestedMessage
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedForeignMessage() []*ForeignMessage {
+	if x != nil {
+		return x.RepeatedForeignMessage
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedImportmessage() []*ImportMessage {
+	if x != nil {
+		return x.RepeatedImportmessage
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedNestedEnum() []TestAllTypes_NestedEnum {
+	if x != nil {
+		return x.RepeatedNestedEnum
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedForeignEnum() []ForeignEnum {
+	if x != nil {
+		return x.RepeatedForeignEnum
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedImportenum() []ImportEnum {
+	if x != nil {
+		return x.RepeatedImportenum
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetMapInt32Int32() map[int32]int32 {
+	if x != nil {
+		return x.MapInt32Int32
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetMapInt64Int64() map[int64]int64 {
+	if x != nil {
+		return x.MapInt64Int64
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetMapUint32Uint32() map[uint32]uint32 {
+	if x != nil {
+		return x.MapUint32Uint32
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetMapUint64Uint64() map[uint64]uint64 {
+	if x != nil {
+		return x.MapUint64Uint64
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetMapSint32Sint32() map[int32]int32 {
+	if x != nil {
+		return x.MapSint32Sint32
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetMapSint64Sint64() map[int64]int64 {
+	if x != nil {
+		return x.MapSint64Sint64
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetMapFixed32Fixed32() map[uint32]uint32 {
+	if x != nil {
+		return x.MapFixed32Fixed32
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetMapFixed64Fixed64() map[uint64]uint64 {
+	if x != nil {
+		return x.MapFixed64Fixed64
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetMapSfixed32Sfixed32() map[int32]int32 {
+	if x != nil {
+		return x.MapSfixed32Sfixed32
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetMapSfixed64Sfixed64() map[int64]int64 {
+	if x != nil {
+		return x.MapSfixed64Sfixed64
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetMapInt32Float() map[int32]float32 {
+	if x != nil {
+		return x.MapInt32Float
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetMapInt32Double() map[int32]float64 {
+	if x != nil {
+		return x.MapInt32Double
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetMapBoolBool() map[bool]bool {
+	if x != nil {
+		return x.MapBoolBool
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetMapStringString() map[string]string {
+	if x != nil {
+		return x.MapStringString
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetMapStringBytes() map[string][]byte {
+	if x != nil {
+		return x.MapStringBytes
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetMapStringNestedMessage() map[string]*TestAllTypes_NestedMessage {
+	if x != nil {
+		return x.MapStringNestedMessage
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetMapStringNestedEnum() map[string]TestAllTypes_NestedEnum {
+	if x != nil {
+		return x.MapStringNestedEnum
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetDefaultInt32() int32 {
+	if x != nil && x.DefaultInt32 != nil {
+		return *x.DefaultInt32
+	}
+	return Default_TestAllTypes_DefaultInt32
+}
+
+func (x *TestAllTypes) GetDefaultInt64() int64 {
+	if x != nil && x.DefaultInt64 != nil {
+		return *x.DefaultInt64
+	}
+	return Default_TestAllTypes_DefaultInt64
+}
+
+func (x *TestAllTypes) GetDefaultUint32() uint32 {
+	if x != nil && x.DefaultUint32 != nil {
+		return *x.DefaultUint32
+	}
+	return Default_TestAllTypes_DefaultUint32
+}
+
+func (x *TestAllTypes) GetDefaultUint64() uint64 {
+	if x != nil && x.DefaultUint64 != nil {
+		return *x.DefaultUint64
+	}
+	return Default_TestAllTypes_DefaultUint64
+}
+
+func (x *TestAllTypes) GetDefaultSint32() int32 {
+	if x != nil && x.DefaultSint32 != nil {
+		return *x.DefaultSint32
+	}
+	return Default_TestAllTypes_DefaultSint32
+}
+
+func (x *TestAllTypes) GetDefaultSint64() int64 {
+	if x != nil && x.DefaultSint64 != nil {
+		return *x.DefaultSint64
+	}
+	return Default_TestAllTypes_DefaultSint64
+}
+
+func (x *TestAllTypes) GetDefaultFixed32() uint32 {
+	if x != nil && x.DefaultFixed32 != nil {
+		return *x.DefaultFixed32
+	}
+	return Default_TestAllTypes_DefaultFixed32
+}
+
+func (x *TestAllTypes) GetDefaultFixed64() uint64 {
+	if x != nil && x.DefaultFixed64 != nil {
+		return *x.DefaultFixed64
+	}
+	return Default_TestAllTypes_DefaultFixed64
+}
+
+func (x *TestAllTypes) GetDefaultSfixed32() int32 {
+	if x != nil && x.DefaultSfixed32 != nil {
+		return *x.DefaultSfixed32
+	}
+	return Default_TestAllTypes_DefaultSfixed32
+}
+
+func (x *TestAllTypes) GetDefaultSfixed64() int64 {
+	if x != nil && x.DefaultSfixed64 != nil {
+		return *x.DefaultSfixed64
+	}
+	return Default_TestAllTypes_DefaultSfixed64
+}
+
+func (x *TestAllTypes) GetDefaultFloat() float32 {
+	if x != nil && x.DefaultFloat != nil {
+		return *x.DefaultFloat
+	}
+	return Default_TestAllTypes_DefaultFloat
+}
+
+func (x *TestAllTypes) GetDefaultDouble() float64 {
+	if x != nil && x.DefaultDouble != nil {
+		return *x.DefaultDouble
+	}
+	return Default_TestAllTypes_DefaultDouble
+}
+
+func (x *TestAllTypes) GetDefaultBool() bool {
+	if x != nil && x.DefaultBool != nil {
+		return *x.DefaultBool
+	}
+	return Default_TestAllTypes_DefaultBool
+}
+
+func (x *TestAllTypes) GetDefaultString() string {
+	if x != nil && x.DefaultString != nil {
+		return *x.DefaultString
+	}
+	return Default_TestAllTypes_DefaultString
+}
+
+func (x *TestAllTypes) GetDefaultBytes() []byte {
+	if x != nil && x.DefaultBytes != nil {
+		return x.DefaultBytes
+	}
+	return append([]byte(nil), Default_TestAllTypes_DefaultBytes...)
+}
+
+func (x *TestAllTypes) GetDefaultNestedEnum() TestAllTypes_NestedEnum {
+	if x != nil && x.DefaultNestedEnum != nil {
+		return *x.DefaultNestedEnum
+	}
+	return Default_TestAllTypes_DefaultNestedEnum
+}
+
+func (x *TestAllTypes) GetDefaultForeignEnum() ForeignEnum {
+	if x != nil && x.DefaultForeignEnum != nil {
+		return *x.DefaultForeignEnum
+	}
+	return Default_TestAllTypes_DefaultForeignEnum
+}
+
+func (m *TestAllTypes) GetOneofField() isTestAllTypes_OneofField {
+	if m != nil {
+		return m.OneofField
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetOneofUint32() uint32 {
+	if x, ok := x.GetOneofField().(*TestAllTypes_OneofUint32); ok {
+		return x.OneofUint32
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetOneofNestedMessage() *TestAllTypes_NestedMessage {
+	if x, ok := x.GetOneofField().(*TestAllTypes_OneofNestedMessage); ok {
+		return x.OneofNestedMessage
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetOneofString() string {
+	if x, ok := x.GetOneofField().(*TestAllTypes_OneofString); ok {
+		return x.OneofString
+	}
+	return ""
+}
+
+func (x *TestAllTypes) GetOneofBytes() []byte {
+	if x, ok := x.GetOneofField().(*TestAllTypes_OneofBytes); ok {
+		return x.OneofBytes
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetOneofBool() bool {
+	if x, ok := x.GetOneofField().(*TestAllTypes_OneofBool); ok {
+		return x.OneofBool
+	}
+	return false
+}
+
+func (x *TestAllTypes) GetOneofUint64() uint64 {
+	if x, ok := x.GetOneofField().(*TestAllTypes_OneofUint64); ok {
+		return x.OneofUint64
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetOneofFloat() float32 {
+	if x, ok := x.GetOneofField().(*TestAllTypes_OneofFloat); ok {
+		return x.OneofFloat
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetOneofDouble() float64 {
+	if x, ok := x.GetOneofField().(*TestAllTypes_OneofDouble); ok {
+		return x.OneofDouble
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetOneofEnum() TestAllTypes_NestedEnum {
+	if x, ok := x.GetOneofField().(*TestAllTypes_OneofEnum); ok {
+		return x.OneofEnum
+	}
+	return TestAllTypes_FOO
+}
+
+func (x *TestAllTypes) GetOneofgroup() *TestAllTypes_OneofGroup {
+	if x, ok := x.GetOneofField().(*TestAllTypes_Oneofgroup); ok {
+		return x.Oneofgroup
+	}
+	return nil
+}
+
+func (m *TestAllTypes) GetOneofOptional() isTestAllTypes_OneofOptional {
+	if m != nil {
+		return m.OneofOptional
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetOneofOptionalUint32() uint32 {
+	if x, ok := x.GetOneofOptional().(*TestAllTypes_OneofOptionalUint32); ok {
+		return x.OneofOptionalUint32
+	}
+	return 0
+}
+
+type isTestAllTypes_OneofField interface {
+	isTestAllTypes_OneofField()
+}
+
+type TestAllTypes_OneofUint32 struct {
+	OneofUint32 uint32 `protobuf:"varint,111,opt,name=oneof_uint32,json=oneofUint32,oneof"`
+}
+
+type TestAllTypes_OneofNestedMessage struct {
+	OneofNestedMessage *TestAllTypes_NestedMessage `protobuf:"bytes,112,opt,name=oneof_nested_message,json=oneofNestedMessage,oneof"`
+}
+
+type TestAllTypes_OneofString struct {
+	OneofString string `protobuf:"bytes,113,opt,name=oneof_string,json=oneofString,oneof"`
+}
+
+type TestAllTypes_OneofBytes struct {
+	OneofBytes []byte `protobuf:"bytes,114,opt,name=oneof_bytes,json=oneofBytes,oneof"`
+}
+
+type TestAllTypes_OneofBool struct {
+	OneofBool bool `protobuf:"varint,115,opt,name=oneof_bool,json=oneofBool,oneof"`
+}
+
+type TestAllTypes_OneofUint64 struct {
+	OneofUint64 uint64 `protobuf:"varint,116,opt,name=oneof_uint64,json=oneofUint64,oneof"`
+}
+
+type TestAllTypes_OneofFloat struct {
+	OneofFloat float32 `protobuf:"fixed32,117,opt,name=oneof_float,json=oneofFloat,oneof"`
+}
+
+type TestAllTypes_OneofDouble struct {
+	OneofDouble float64 `protobuf:"fixed64,118,opt,name=oneof_double,json=oneofDouble,oneof"`
+}
+
+type TestAllTypes_OneofEnum struct {
+	OneofEnum TestAllTypes_NestedEnum `protobuf:"varint,119,opt,name=oneof_enum,json=oneofEnum,enum=goproto.proto.test.TestAllTypes_NestedEnum,oneof"`
+}
+
+type TestAllTypes_Oneofgroup struct {
+	Oneofgroup *TestAllTypes_OneofGroup `protobuf:"group,121,opt,name=OneofGroup,json=oneofgroup,oneof"`
+}
+
+func (*TestAllTypes_OneofUint32) isTestAllTypes_OneofField() {}
+
+func (*TestAllTypes_OneofNestedMessage) isTestAllTypes_OneofField() {}
+
+func (*TestAllTypes_OneofString) isTestAllTypes_OneofField() {}
+
+func (*TestAllTypes_OneofBytes) isTestAllTypes_OneofField() {}
+
+func (*TestAllTypes_OneofBool) isTestAllTypes_OneofField() {}
+
+func (*TestAllTypes_OneofUint64) isTestAllTypes_OneofField() {}
+
+func (*TestAllTypes_OneofFloat) isTestAllTypes_OneofField() {}
+
+func (*TestAllTypes_OneofDouble) isTestAllTypes_OneofField() {}
+
+func (*TestAllTypes_OneofEnum) isTestAllTypes_OneofField() {}
+
+func (*TestAllTypes_Oneofgroup) isTestAllTypes_OneofField() {}
+
+type isTestAllTypes_OneofOptional interface {
+	isTestAllTypes_OneofOptional()
+}
+
+type TestAllTypes_OneofOptionalUint32 struct {
+	OneofOptionalUint32 uint32 `protobuf:"varint,120,opt,name=oneof_optional_uint32,json=oneofOptionalUint32,oneof"`
+}
+
+func (*TestAllTypes_OneofOptionalUint32) isTestAllTypes_OneofOptional() {}
+
+// Deprecated: Do not use.
+type TestDeprecatedMessage struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// Deprecated: Do not use.
+	DeprecatedInt32 *int32 `protobuf:"varint,1,opt,name=deprecated_int32,json=deprecatedInt32" json:"deprecated_int32,omitempty"`
+	// Types that are assignable to DeprecatedOneof:
+	//	*TestDeprecatedMessage_DeprecatedOneofField
+	DeprecatedOneof isTestDeprecatedMessage_DeprecatedOneof `protobuf_oneof:"deprecated_oneof"`
+}
+
+func (x *TestDeprecatedMessage) Reset() {
+	*x = TestDeprecatedMessage{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_test_test_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *TestDeprecatedMessage) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TestDeprecatedMessage) ProtoMessage() {}
+
+func (x *TestDeprecatedMessage) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_test_test_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TestDeprecatedMessage.ProtoReflect.Descriptor instead.
+func (*TestDeprecatedMessage) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{1}
+}
+
+// Deprecated: Do not use.
+func (x *TestDeprecatedMessage) GetDeprecatedInt32() int32 {
+	if x != nil && x.DeprecatedInt32 != nil {
+		return *x.DeprecatedInt32
+	}
+	return 0
+}
+
+func (m *TestDeprecatedMessage) GetDeprecatedOneof() isTestDeprecatedMessage_DeprecatedOneof {
+	if m != nil {
+		return m.DeprecatedOneof
+	}
+	return nil
+}
+
+// Deprecated: Do not use.
+func (x *TestDeprecatedMessage) GetDeprecatedOneofField() int32 {
+	if x, ok := x.GetDeprecatedOneof().(*TestDeprecatedMessage_DeprecatedOneofField); ok {
+		return x.DeprecatedOneofField
+	}
+	return 0
+}
+
+type isTestDeprecatedMessage_DeprecatedOneof interface {
+	isTestDeprecatedMessage_DeprecatedOneof()
+}
+
+type TestDeprecatedMessage_DeprecatedOneofField struct {
+	// Deprecated: Do not use.
+	DeprecatedOneofField int32 `protobuf:"varint,2,opt,name=deprecated_oneof_field,json=deprecatedOneofField,oneof"`
+}
+
+func (*TestDeprecatedMessage_DeprecatedOneofField) isTestDeprecatedMessage_DeprecatedOneof() {}
+
+type ForeignMessage struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	C *int32 `protobuf:"varint,1,opt,name=c" json:"c,omitempty"`
+	D *int32 `protobuf:"varint,2,opt,name=d" json:"d,omitempty"`
+}
+
+func (x *ForeignMessage) Reset() {
+	*x = ForeignMessage{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_test_test_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *ForeignMessage) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ForeignMessage) ProtoMessage() {}
+
+func (x *ForeignMessage) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_test_test_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ForeignMessage.ProtoReflect.Descriptor instead.
+func (*ForeignMessage) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *ForeignMessage) GetC() int32 {
+	if x != nil && x.C != nil {
+		return *x.C
+	}
+	return 0
+}
+
+func (x *ForeignMessage) GetD() int32 {
+	if x != nil && x.D != nil {
+		return *x.D
+	}
+	return 0
+}
+
+type TestReservedFields struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *TestReservedFields) Reset() {
+	*x = TestReservedFields{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_test_test_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *TestReservedFields) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TestReservedFields) ProtoMessage() {}
+
+func (x *TestReservedFields) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_test_test_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TestReservedFields.ProtoReflect.Descriptor instead.
+func (*TestReservedFields) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{3}
+}
+
+type TestAllExtensions struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+}
+
+func (x *TestAllExtensions) Reset() {
+	*x = TestAllExtensions{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_test_test_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *TestAllExtensions) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TestAllExtensions) ProtoMessage() {}
+
+func (x *TestAllExtensions) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_test_test_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TestAllExtensions.ProtoReflect.Descriptor instead.
+func (*TestAllExtensions) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{4}
+}
+
+var extRange_TestAllExtensions = []protoiface.ExtensionRangeV1{
+	{Start: 1, End: 536870911},
+}
+
+// Deprecated: Use TestAllExtensions.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*TestAllExtensions) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_TestAllExtensions
+}
+
+type OptionalGroup struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	A                     *int32                           `protobuf:"varint,17,opt,name=a" json:"a,omitempty"`
+	SameFieldNumber       *int32                           `protobuf:"varint,16,opt,name=same_field_number,json=sameFieldNumber" json:"same_field_number,omitempty"`
+	OptionalNestedMessage *TestAllExtensions_NestedMessage `protobuf:"bytes,1000,opt,name=optional_nested_message,json=optionalNestedMessage" json:"optional_nested_message,omitempty"`
+}
+
+func (x *OptionalGroup) Reset() {
+	*x = OptionalGroup{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_test_test_proto_msgTypes[5]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *OptionalGroup) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*OptionalGroup) ProtoMessage() {}
+
+func (x *OptionalGroup) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_test_test_proto_msgTypes[5]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use OptionalGroup.ProtoReflect.Descriptor instead.
+func (*OptionalGroup) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *OptionalGroup) GetA() int32 {
+	if x != nil && x.A != nil {
+		return *x.A
+	}
+	return 0
+}
+
+func (x *OptionalGroup) GetSameFieldNumber() int32 {
+	if x != nil && x.SameFieldNumber != nil {
+		return *x.SameFieldNumber
+	}
+	return 0
+}
+
+func (x *OptionalGroup) GetOptionalNestedMessage() *TestAllExtensions_NestedMessage {
+	if x != nil {
+		return x.OptionalNestedMessage
+	}
+	return nil
+}
+
+type RepeatedGroup struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	A                     *int32                           `protobuf:"varint,47,opt,name=a" json:"a,omitempty"`
+	OptionalNestedMessage *TestAllExtensions_NestedMessage `protobuf:"bytes,1001,opt,name=optional_nested_message,json=optionalNestedMessage" json:"optional_nested_message,omitempty"`
+}
+
+func (x *RepeatedGroup) Reset() {
+	*x = RepeatedGroup{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_test_test_proto_msgTypes[6]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *RepeatedGroup) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*RepeatedGroup) ProtoMessage() {}
+
+func (x *RepeatedGroup) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_test_test_proto_msgTypes[6]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use RepeatedGroup.ProtoReflect.Descriptor instead.
+func (*RepeatedGroup) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *RepeatedGroup) GetA() int32 {
+	if x != nil && x.A != nil {
+		return *x.A
+	}
+	return 0
+}
+
+func (x *RepeatedGroup) GetOptionalNestedMessage() *TestAllExtensions_NestedMessage {
+	if x != nil {
+		return x.OptionalNestedMessage
+	}
+	return nil
+}
+
+type TestNestedExtension struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *TestNestedExtension) Reset() {
+	*x = TestNestedExtension{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_test_test_proto_msgTypes[7]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *TestNestedExtension) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TestNestedExtension) ProtoMessage() {}
+
+func (x *TestNestedExtension) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_test_test_proto_msgTypes[7]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TestNestedExtension.ProtoReflect.Descriptor instead.
+func (*TestNestedExtension) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{7}
+}
+
+type TestRequired struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	RequiredField *int32 `protobuf:"varint,1,req,name=required_field,json=requiredField" json:"required_field,omitempty"`
+}
+
+func (x *TestRequired) Reset() {
+	*x = TestRequired{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_test_test_proto_msgTypes[8]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *TestRequired) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TestRequired) ProtoMessage() {}
+
+func (x *TestRequired) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_test_test_proto_msgTypes[8]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TestRequired.ProtoReflect.Descriptor instead.
+func (*TestRequired) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *TestRequired) GetRequiredField() int32 {
+	if x != nil && x.RequiredField != nil {
+		return *x.RequiredField
+	}
+	return 0
+}
+
+type TestRequiredForeign struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	OptionalMessage *TestRequired           `protobuf:"bytes,1,opt,name=optional_message,json=optionalMessage" json:"optional_message,omitempty"`
+	RepeatedMessage []*TestRequired         `protobuf:"bytes,2,rep,name=repeated_message,json=repeatedMessage" json:"repeated_message,omitempty"`
+	MapMessage      map[int32]*TestRequired `protobuf:"bytes,3,rep,name=map_message,json=mapMessage" json:"map_message,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+	// Types that are assignable to OneofField:
+	//	*TestRequiredForeign_OneofMessage
+	OneofField isTestRequiredForeign_OneofField `protobuf_oneof:"oneof_field"`
+}
+
+func (x *TestRequiredForeign) Reset() {
+	*x = TestRequiredForeign{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_test_test_proto_msgTypes[9]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *TestRequiredForeign) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TestRequiredForeign) ProtoMessage() {}
+
+func (x *TestRequiredForeign) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_test_test_proto_msgTypes[9]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TestRequiredForeign.ProtoReflect.Descriptor instead.
+func (*TestRequiredForeign) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{9}
+}
+
+func (x *TestRequiredForeign) GetOptionalMessage() *TestRequired {
+	if x != nil {
+		return x.OptionalMessage
+	}
+	return nil
+}
+
+func (x *TestRequiredForeign) GetRepeatedMessage() []*TestRequired {
+	if x != nil {
+		return x.RepeatedMessage
+	}
+	return nil
+}
+
+func (x *TestRequiredForeign) GetMapMessage() map[int32]*TestRequired {
+	if x != nil {
+		return x.MapMessage
+	}
+	return nil
+}
+
+func (m *TestRequiredForeign) GetOneofField() isTestRequiredForeign_OneofField {
+	if m != nil {
+		return m.OneofField
+	}
+	return nil
+}
+
+func (x *TestRequiredForeign) GetOneofMessage() *TestRequired {
+	if x, ok := x.GetOneofField().(*TestRequiredForeign_OneofMessage); ok {
+		return x.OneofMessage
+	}
+	return nil
+}
+
+type isTestRequiredForeign_OneofField interface {
+	isTestRequiredForeign_OneofField()
+}
+
+type TestRequiredForeign_OneofMessage struct {
+	OneofMessage *TestRequired `protobuf:"bytes,4,opt,name=oneof_message,json=oneofMessage,oneof"`
+}
+
+func (*TestRequiredForeign_OneofMessage) isTestRequiredForeign_OneofField() {}
+
+type TestRequiredGroupFields struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Optionalgroup *TestRequiredGroupFields_OptionalGroup   `protobuf:"group,1,opt,name=OptionalGroup,json=optionalgroup" json:"optionalgroup,omitempty"`
+	Repeatedgroup []*TestRequiredGroupFields_RepeatedGroup `protobuf:"group,3,rep,name=RepeatedGroup,json=repeatedgroup" json:"repeatedgroup,omitempty"`
+}
+
+func (x *TestRequiredGroupFields) Reset() {
+	*x = TestRequiredGroupFields{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_test_test_proto_msgTypes[10]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *TestRequiredGroupFields) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TestRequiredGroupFields) ProtoMessage() {}
+
+func (x *TestRequiredGroupFields) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_test_test_proto_msgTypes[10]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TestRequiredGroupFields.ProtoReflect.Descriptor instead.
+func (*TestRequiredGroupFields) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{10}
+}
+
+func (x *TestRequiredGroupFields) GetOptionalgroup() *TestRequiredGroupFields_OptionalGroup {
+	if x != nil {
+		return x.Optionalgroup
+	}
+	return nil
+}
+
+func (x *TestRequiredGroupFields) GetRepeatedgroup() []*TestRequiredGroupFields_RepeatedGroup {
+	if x != nil {
+		return x.Repeatedgroup
+	}
+	return nil
+}
+
+type TestWeak struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	weakFields    protoimpl.WeakFields
+	unknownFields protoimpl.UnknownFields
+
+	XXX_weak_WeakMessage1 struct{} `protobuf:"bytes,1,opt,name=weak_message1,json=weakMessage1,weak=goproto.proto.test.weak.WeakImportMessage1" json:"weak_message1,omitempty"`
+	XXX_weak_WeakMessage2 struct{} `protobuf:"bytes,2,opt,name=weak_message2,json=weakMessage2,weak=goproto.proto.test.weak.WeakImportMessage2" json:"weak_message2,omitempty"`
+}
+
+func (x *TestWeak) Reset() {
+	*x = TestWeak{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_test_test_proto_msgTypes[11]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *TestWeak) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TestWeak) ProtoMessage() {}
+
+func (x *TestWeak) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_test_test_proto_msgTypes[11]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TestWeak.ProtoReflect.Descriptor instead.
+func (*TestWeak) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{11}
+}
+
+func (x *TestWeak) GetWeakMessage1() proto.Message {
+	var w protoimpl.WeakFields
+	if x != nil {
+		w = x.weakFields
+	}
+	return protoimpl.X.GetWeak(w, 1, "goproto.proto.test.weak.WeakImportMessage1")
+}
+
+func (x *TestWeak) GetWeakMessage2() proto.Message {
+	var w protoimpl.WeakFields
+	if x != nil {
+		w = x.weakFields
+	}
+	return protoimpl.X.GetWeak(w, 2, "goproto.proto.test.weak.WeakImportMessage2")
+}
+
+func (x *TestWeak) SetWeakMessage1(v proto.Message) {
+	var w *protoimpl.WeakFields
+	if x != nil {
+		w = &x.weakFields
+	}
+	protoimpl.X.SetWeak(w, 1, "goproto.proto.test.weak.WeakImportMessage1", v)
+}
+
+func (x *TestWeak) SetWeakMessage2(v proto.Message) {
+	var w *protoimpl.WeakFields
+	if x != nil {
+		w = &x.weakFields
+	}
+	protoimpl.X.SetWeak(w, 2, "goproto.proto.test.weak.WeakImportMessage2", v)
+}
+
+type TestPackedTypes struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	PackedInt32    []int32       `protobuf:"varint,90,rep,packed,name=packed_int32,json=packedInt32" json:"packed_int32,omitempty"`
+	PackedInt64    []int64       `protobuf:"varint,91,rep,packed,name=packed_int64,json=packedInt64" json:"packed_int64,omitempty"`
+	PackedUint32   []uint32      `protobuf:"varint,92,rep,packed,name=packed_uint32,json=packedUint32" json:"packed_uint32,omitempty"`
+	PackedUint64   []uint64      `protobuf:"varint,93,rep,packed,name=packed_uint64,json=packedUint64" json:"packed_uint64,omitempty"`
+	PackedSint32   []int32       `protobuf:"zigzag32,94,rep,packed,name=packed_sint32,json=packedSint32" json:"packed_sint32,omitempty"`
+	PackedSint64   []int64       `protobuf:"zigzag64,95,rep,packed,name=packed_sint64,json=packedSint64" json:"packed_sint64,omitempty"`
+	PackedFixed32  []uint32      `protobuf:"fixed32,96,rep,packed,name=packed_fixed32,json=packedFixed32" json:"packed_fixed32,omitempty"`
+	PackedFixed64  []uint64      `protobuf:"fixed64,97,rep,packed,name=packed_fixed64,json=packedFixed64" json:"packed_fixed64,omitempty"`
+	PackedSfixed32 []int32       `protobuf:"fixed32,98,rep,packed,name=packed_sfixed32,json=packedSfixed32" json:"packed_sfixed32,omitempty"`
+	PackedSfixed64 []int64       `protobuf:"fixed64,99,rep,packed,name=packed_sfixed64,json=packedSfixed64" json:"packed_sfixed64,omitempty"`
+	PackedFloat    []float32     `protobuf:"fixed32,100,rep,packed,name=packed_float,json=packedFloat" json:"packed_float,omitempty"`
+	PackedDouble   []float64     `protobuf:"fixed64,101,rep,packed,name=packed_double,json=packedDouble" json:"packed_double,omitempty"`
+	PackedBool     []bool        `protobuf:"varint,102,rep,packed,name=packed_bool,json=packedBool" json:"packed_bool,omitempty"`
+	PackedEnum     []ForeignEnum `protobuf:"varint,103,rep,packed,name=packed_enum,json=packedEnum,enum=goproto.proto.test.ForeignEnum" json:"packed_enum,omitempty"`
+}
+
+func (x *TestPackedTypes) Reset() {
+	*x = TestPackedTypes{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_test_test_proto_msgTypes[12]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *TestPackedTypes) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TestPackedTypes) ProtoMessage() {}
+
+func (x *TestPackedTypes) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_test_test_proto_msgTypes[12]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TestPackedTypes.ProtoReflect.Descriptor instead.
+func (*TestPackedTypes) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{12}
+}
+
+func (x *TestPackedTypes) GetPackedInt32() []int32 {
+	if x != nil {
+		return x.PackedInt32
+	}
+	return nil
+}
+
+func (x *TestPackedTypes) GetPackedInt64() []int64 {
+	if x != nil {
+		return x.PackedInt64
+	}
+	return nil
+}
+
+func (x *TestPackedTypes) GetPackedUint32() []uint32 {
+	if x != nil {
+		return x.PackedUint32
+	}
+	return nil
+}
+
+func (x *TestPackedTypes) GetPackedUint64() []uint64 {
+	if x != nil {
+		return x.PackedUint64
+	}
+	return nil
+}
+
+func (x *TestPackedTypes) GetPackedSint32() []int32 {
+	if x != nil {
+		return x.PackedSint32
+	}
+	return nil
+}
+
+func (x *TestPackedTypes) GetPackedSint64() []int64 {
+	if x != nil {
+		return x.PackedSint64
+	}
+	return nil
+}
+
+func (x *TestPackedTypes) GetPackedFixed32() []uint32 {
+	if x != nil {
+		return x.PackedFixed32
+	}
+	return nil
+}
+
+func (x *TestPackedTypes) GetPackedFixed64() []uint64 {
+	if x != nil {
+		return x.PackedFixed64
+	}
+	return nil
+}
+
+func (x *TestPackedTypes) GetPackedSfixed32() []int32 {
+	if x != nil {
+		return x.PackedSfixed32
+	}
+	return nil
+}
+
+func (x *TestPackedTypes) GetPackedSfixed64() []int64 {
+	if x != nil {
+		return x.PackedSfixed64
+	}
+	return nil
+}
+
+func (x *TestPackedTypes) GetPackedFloat() []float32 {
+	if x != nil {
+		return x.PackedFloat
+	}
+	return nil
+}
+
+func (x *TestPackedTypes) GetPackedDouble() []float64 {
+	if x != nil {
+		return x.PackedDouble
+	}
+	return nil
+}
+
+func (x *TestPackedTypes) GetPackedBool() []bool {
+	if x != nil {
+		return x.PackedBool
+	}
+	return nil
+}
+
+func (x *TestPackedTypes) GetPackedEnum() []ForeignEnum {
+	if x != nil {
+		return x.PackedEnum
+	}
+	return nil
+}
+
+type TestUnpackedTypes struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	UnpackedInt32    []int32       `protobuf:"varint,90,rep,name=unpacked_int32,json=unpackedInt32" json:"unpacked_int32,omitempty"`
+	UnpackedInt64    []int64       `protobuf:"varint,91,rep,name=unpacked_int64,json=unpackedInt64" json:"unpacked_int64,omitempty"`
+	UnpackedUint32   []uint32      `protobuf:"varint,92,rep,name=unpacked_uint32,json=unpackedUint32" json:"unpacked_uint32,omitempty"`
+	UnpackedUint64   []uint64      `protobuf:"varint,93,rep,name=unpacked_uint64,json=unpackedUint64" json:"unpacked_uint64,omitempty"`
+	UnpackedSint32   []int32       `protobuf:"zigzag32,94,rep,name=unpacked_sint32,json=unpackedSint32" json:"unpacked_sint32,omitempty"`
+	UnpackedSint64   []int64       `protobuf:"zigzag64,95,rep,name=unpacked_sint64,json=unpackedSint64" json:"unpacked_sint64,omitempty"`
+	UnpackedFixed32  []uint32      `protobuf:"fixed32,96,rep,name=unpacked_fixed32,json=unpackedFixed32" json:"unpacked_fixed32,omitempty"`
+	UnpackedFixed64  []uint64      `protobuf:"fixed64,97,rep,name=unpacked_fixed64,json=unpackedFixed64" json:"unpacked_fixed64,omitempty"`
+	UnpackedSfixed32 []int32       `protobuf:"fixed32,98,rep,name=unpacked_sfixed32,json=unpackedSfixed32" json:"unpacked_sfixed32,omitempty"`
+	UnpackedSfixed64 []int64       `protobuf:"fixed64,99,rep,name=unpacked_sfixed64,json=unpackedSfixed64" json:"unpacked_sfixed64,omitempty"`
+	UnpackedFloat    []float32     `protobuf:"fixed32,100,rep,name=unpacked_float,json=unpackedFloat" json:"unpacked_float,omitempty"`
+	UnpackedDouble   []float64     `protobuf:"fixed64,101,rep,name=unpacked_double,json=unpackedDouble" json:"unpacked_double,omitempty"`
+	UnpackedBool     []bool        `protobuf:"varint,102,rep,name=unpacked_bool,json=unpackedBool" json:"unpacked_bool,omitempty"`
+	UnpackedEnum     []ForeignEnum `protobuf:"varint,103,rep,name=unpacked_enum,json=unpackedEnum,enum=goproto.proto.test.ForeignEnum" json:"unpacked_enum,omitempty"`
+}
+
+func (x *TestUnpackedTypes) Reset() {
+	*x = TestUnpackedTypes{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_test_test_proto_msgTypes[13]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *TestUnpackedTypes) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TestUnpackedTypes) ProtoMessage() {}
+
+func (x *TestUnpackedTypes) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_test_test_proto_msgTypes[13]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TestUnpackedTypes.ProtoReflect.Descriptor instead.
+func (*TestUnpackedTypes) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{13}
+}
+
+func (x *TestUnpackedTypes) GetUnpackedInt32() []int32 {
+	if x != nil {
+		return x.UnpackedInt32
+	}
+	return nil
+}
+
+func (x *TestUnpackedTypes) GetUnpackedInt64() []int64 {
+	if x != nil {
+		return x.UnpackedInt64
+	}
+	return nil
+}
+
+func (x *TestUnpackedTypes) GetUnpackedUint32() []uint32 {
+	if x != nil {
+		return x.UnpackedUint32
+	}
+	return nil
+}
+
+func (x *TestUnpackedTypes) GetUnpackedUint64() []uint64 {
+	if x != nil {
+		return x.UnpackedUint64
+	}
+	return nil
+}
+
+func (x *TestUnpackedTypes) GetUnpackedSint32() []int32 {
+	if x != nil {
+		return x.UnpackedSint32
+	}
+	return nil
+}
+
+func (x *TestUnpackedTypes) GetUnpackedSint64() []int64 {
+	if x != nil {
+		return x.UnpackedSint64
+	}
+	return nil
+}
+
+func (x *TestUnpackedTypes) GetUnpackedFixed32() []uint32 {
+	if x != nil {
+		return x.UnpackedFixed32
+	}
+	return nil
+}
+
+func (x *TestUnpackedTypes) GetUnpackedFixed64() []uint64 {
+	if x != nil {
+		return x.UnpackedFixed64
+	}
+	return nil
+}
+
+func (x *TestUnpackedTypes) GetUnpackedSfixed32() []int32 {
+	if x != nil {
+		return x.UnpackedSfixed32
+	}
+	return nil
+}
+
+func (x *TestUnpackedTypes) GetUnpackedSfixed64() []int64 {
+	if x != nil {
+		return x.UnpackedSfixed64
+	}
+	return nil
+}
+
+func (x *TestUnpackedTypes) GetUnpackedFloat() []float32 {
+	if x != nil {
+		return x.UnpackedFloat
+	}
+	return nil
+}
+
+func (x *TestUnpackedTypes) GetUnpackedDouble() []float64 {
+	if x != nil {
+		return x.UnpackedDouble
+	}
+	return nil
+}
+
+func (x *TestUnpackedTypes) GetUnpackedBool() []bool {
+	if x != nil {
+		return x.UnpackedBool
+	}
+	return nil
+}
+
+func (x *TestUnpackedTypes) GetUnpackedEnum() []ForeignEnum {
+	if x != nil {
+		return x.UnpackedEnum
+	}
+	return nil
+}
+
+type TestPackedExtensions struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+}
+
+func (x *TestPackedExtensions) Reset() {
+	*x = TestPackedExtensions{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_test_test_proto_msgTypes[14]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *TestPackedExtensions) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TestPackedExtensions) ProtoMessage() {}
+
+func (x *TestPackedExtensions) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_test_test_proto_msgTypes[14]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TestPackedExtensions.ProtoReflect.Descriptor instead.
+func (*TestPackedExtensions) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{14}
+}
+
+var extRange_TestPackedExtensions = []protoiface.ExtensionRangeV1{
+	{Start: 1, End: 536870911},
+}
+
+// Deprecated: Use TestPackedExtensions.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*TestPackedExtensions) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_TestPackedExtensions
+}
+
+type TestUnpackedExtensions struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+}
+
+func (x *TestUnpackedExtensions) Reset() {
+	*x = TestUnpackedExtensions{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_test_test_proto_msgTypes[15]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *TestUnpackedExtensions) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TestUnpackedExtensions) ProtoMessage() {}
+
+func (x *TestUnpackedExtensions) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_test_test_proto_msgTypes[15]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TestUnpackedExtensions.ProtoReflect.Descriptor instead.
+func (*TestUnpackedExtensions) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{15}
+}
+
+var extRange_TestUnpackedExtensions = []protoiface.ExtensionRangeV1{
+	{Start: 1, End: 536870911},
+}
+
+// Deprecated: Use TestUnpackedExtensions.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*TestUnpackedExtensions) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_TestUnpackedExtensions
+}
+
+// Test that RPC services work.
+type FooRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *FooRequest) Reset() {
+	*x = FooRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_test_test_proto_msgTypes[16]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *FooRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*FooRequest) ProtoMessage() {}
+
+func (x *FooRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_test_test_proto_msgTypes[16]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use FooRequest.ProtoReflect.Descriptor instead.
+func (*FooRequest) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{16}
+}
+
+type FooResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *FooResponse) Reset() {
+	*x = FooResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_test_test_proto_msgTypes[17]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *FooResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*FooResponse) ProtoMessage() {}
+
+func (x *FooResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_test_test_proto_msgTypes[17]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use FooResponse.ProtoReflect.Descriptor instead.
+func (*FooResponse) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{17}
+}
+
+type WeirdDefault struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	WeirdDefault []byte `protobuf:"bytes,1,opt,name=weird_default,json=weirdDefault,def=hello, \\\"world!\\\"\\ndead\\336\\255\\276\\357beef\x60" json:"weird_default,omitempty"`
+}
+
+// Default values for WeirdDefault fields.
+var (
+	Default_WeirdDefault_WeirdDefault = []byte("hello, \"world!\"\ndeadޭ\xbe\xefbeef`")
+)
+
+func (x *WeirdDefault) Reset() {
+	*x = WeirdDefault{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_test_test_proto_msgTypes[18]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *WeirdDefault) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*WeirdDefault) ProtoMessage() {}
+
+func (x *WeirdDefault) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_test_test_proto_msgTypes[18]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use WeirdDefault.ProtoReflect.Descriptor instead.
+func (*WeirdDefault) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{18}
+}
+
+func (x *WeirdDefault) GetWeirdDefault() []byte {
+	if x != nil && x.WeirdDefault != nil {
+		return x.WeirdDefault
+	}
+	return append([]byte(nil), Default_WeirdDefault_WeirdDefault...)
+}
+
+type TestAllTypes_NestedMessage struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	A           *int32        `protobuf:"varint,1,opt,name=a" json:"a,omitempty"`
+	Corecursive *TestAllTypes `protobuf:"bytes,2,opt,name=corecursive" json:"corecursive,omitempty"`
+}
+
+func (x *TestAllTypes_NestedMessage) Reset() {
+	*x = TestAllTypes_NestedMessage{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_test_test_proto_msgTypes[19]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *TestAllTypes_NestedMessage) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TestAllTypes_NestedMessage) ProtoMessage() {}
+
+func (x *TestAllTypes_NestedMessage) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_test_test_proto_msgTypes[19]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TestAllTypes_NestedMessage.ProtoReflect.Descriptor instead.
+func (*TestAllTypes_NestedMessage) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{0, 0}
+}
+
+func (x *TestAllTypes_NestedMessage) GetA() int32 {
+	if x != nil && x.A != nil {
+		return *x.A
+	}
+	return 0
+}
+
+func (x *TestAllTypes_NestedMessage) GetCorecursive() *TestAllTypes {
+	if x != nil {
+		return x.Corecursive
+	}
+	return nil
+}
+
+type TestAllTypes_OptionalGroup struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	A                     *int32                      `protobuf:"varint,17,opt,name=a" json:"a,omitempty"`
+	OptionalNestedMessage *TestAllTypes_NestedMessage `protobuf:"bytes,1000,opt,name=optional_nested_message,json=optionalNestedMessage" json:"optional_nested_message,omitempty"`
+	SameFieldNumber       *int32                      `protobuf:"varint,16,opt,name=same_field_number,json=sameFieldNumber" json:"same_field_number,omitempty"`
+}
+
+func (x *TestAllTypes_OptionalGroup) Reset() {
+	*x = TestAllTypes_OptionalGroup{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_test_test_proto_msgTypes[20]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *TestAllTypes_OptionalGroup) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TestAllTypes_OptionalGroup) ProtoMessage() {}
+
+func (x *TestAllTypes_OptionalGroup) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_test_test_proto_msgTypes[20]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TestAllTypes_OptionalGroup.ProtoReflect.Descriptor instead.
+func (*TestAllTypes_OptionalGroup) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{0, 1}
+}
+
+func (x *TestAllTypes_OptionalGroup) GetA() int32 {
+	if x != nil && x.A != nil {
+		return *x.A
+	}
+	return 0
+}
+
+func (x *TestAllTypes_OptionalGroup) GetOptionalNestedMessage() *TestAllTypes_NestedMessage {
+	if x != nil {
+		return x.OptionalNestedMessage
+	}
+	return nil
+}
+
+func (x *TestAllTypes_OptionalGroup) GetSameFieldNumber() int32 {
+	if x != nil && x.SameFieldNumber != nil {
+		return *x.SameFieldNumber
+	}
+	return 0
+}
+
+type TestAllTypes_RepeatedGroup struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	A                     *int32                      `protobuf:"varint,47,opt,name=a" json:"a,omitempty"`
+	OptionalNestedMessage *TestAllTypes_NestedMessage `protobuf:"bytes,1001,opt,name=optional_nested_message,json=optionalNestedMessage" json:"optional_nested_message,omitempty"`
+}
+
+func (x *TestAllTypes_RepeatedGroup) Reset() {
+	*x = TestAllTypes_RepeatedGroup{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_test_test_proto_msgTypes[21]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *TestAllTypes_RepeatedGroup) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TestAllTypes_RepeatedGroup) ProtoMessage() {}
+
+func (x *TestAllTypes_RepeatedGroup) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_test_test_proto_msgTypes[21]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TestAllTypes_RepeatedGroup.ProtoReflect.Descriptor instead.
+func (*TestAllTypes_RepeatedGroup) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{0, 2}
+}
+
+func (x *TestAllTypes_RepeatedGroup) GetA() int32 {
+	if x != nil && x.A != nil {
+		return *x.A
+	}
+	return 0
+}
+
+func (x *TestAllTypes_RepeatedGroup) GetOptionalNestedMessage() *TestAllTypes_NestedMessage {
+	if x != nil {
+		return x.OptionalNestedMessage
+	}
+	return nil
+}
+
+type TestAllTypes_OneofGroup struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	A *int32 `protobuf:"varint,1,opt,name=a" json:"a,omitempty"`
+	B *int32 `protobuf:"varint,2,opt,name=b" json:"b,omitempty"`
+}
+
+func (x *TestAllTypes_OneofGroup) Reset() {
+	*x = TestAllTypes_OneofGroup{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_test_test_proto_msgTypes[39]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *TestAllTypes_OneofGroup) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TestAllTypes_OneofGroup) ProtoMessage() {}
+
+func (x *TestAllTypes_OneofGroup) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_test_test_proto_msgTypes[39]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TestAllTypes_OneofGroup.ProtoReflect.Descriptor instead.
+func (*TestAllTypes_OneofGroup) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{0, 20}
+}
+
+func (x *TestAllTypes_OneofGroup) GetA() int32 {
+	if x != nil && x.A != nil {
+		return *x.A
+	}
+	return 0
+}
+
+func (x *TestAllTypes_OneofGroup) GetB() int32 {
+	if x != nil && x.B != nil {
+		return *x.B
+	}
+	return 0
+}
+
+type TestAllExtensions_NestedMessage struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	A           *int32             `protobuf:"varint,1,opt,name=a" json:"a,omitempty"`
+	Corecursive *TestAllExtensions `protobuf:"bytes,2,opt,name=corecursive" json:"corecursive,omitempty"`
+}
+
+func (x *TestAllExtensions_NestedMessage) Reset() {
+	*x = TestAllExtensions_NestedMessage{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_test_test_proto_msgTypes[40]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *TestAllExtensions_NestedMessage) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TestAllExtensions_NestedMessage) ProtoMessage() {}
+
+func (x *TestAllExtensions_NestedMessage) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_test_test_proto_msgTypes[40]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TestAllExtensions_NestedMessage.ProtoReflect.Descriptor instead.
+func (*TestAllExtensions_NestedMessage) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{4, 0}
+}
+
+func (x *TestAllExtensions_NestedMessage) GetA() int32 {
+	if x != nil && x.A != nil {
+		return *x.A
+	}
+	return 0
+}
+
+func (x *TestAllExtensions_NestedMessage) GetCorecursive() *TestAllExtensions {
+	if x != nil {
+		return x.Corecursive
+	}
+	return nil
+}
+
+type TestRequiredGroupFields_OptionalGroup struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	A *int32 `protobuf:"varint,2,req,name=a" json:"a,omitempty"`
+}
+
+func (x *TestRequiredGroupFields_OptionalGroup) Reset() {
+	*x = TestRequiredGroupFields_OptionalGroup{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_test_test_proto_msgTypes[42]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *TestRequiredGroupFields_OptionalGroup) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TestRequiredGroupFields_OptionalGroup) ProtoMessage() {}
+
+func (x *TestRequiredGroupFields_OptionalGroup) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_test_test_proto_msgTypes[42]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TestRequiredGroupFields_OptionalGroup.ProtoReflect.Descriptor instead.
+func (*TestRequiredGroupFields_OptionalGroup) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{10, 0}
+}
+
+func (x *TestRequiredGroupFields_OptionalGroup) GetA() int32 {
+	if x != nil && x.A != nil {
+		return *x.A
+	}
+	return 0
+}
+
+type TestRequiredGroupFields_RepeatedGroup struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	A *int32 `protobuf:"varint,4,req,name=a" json:"a,omitempty"`
+}
+
+func (x *TestRequiredGroupFields_RepeatedGroup) Reset() {
+	*x = TestRequiredGroupFields_RepeatedGroup{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_test_test_proto_msgTypes[43]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *TestRequiredGroupFields_RepeatedGroup) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TestRequiredGroupFields_RepeatedGroup) ProtoMessage() {}
+
+func (x *TestRequiredGroupFields_RepeatedGroup) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_test_test_proto_msgTypes[43]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TestRequiredGroupFields_RepeatedGroup.ProtoReflect.Descriptor instead.
+func (*TestRequiredGroupFields_RepeatedGroup) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{10, 1}
+}
+
+func (x *TestRequiredGroupFields_RepeatedGroup) GetA() int32 {
+	if x != nil && x.A != nil {
+		return *x.A
+	}
+	return 0
+}
+
+var file_internal_testprotos_test_test_proto_extTypes = []protoimpl.ExtensionInfo{
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: (*int32)(nil),
+		Field:         1,
+		Name:          "goproto.proto.test.optional_int32",
+		Tag:           "varint,1,opt,name=optional_int32",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: (*int64)(nil),
+		Field:         2,
+		Name:          "goproto.proto.test.optional_int64",
+		Tag:           "varint,2,opt,name=optional_int64",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: (*uint32)(nil),
+		Field:         3,
+		Name:          "goproto.proto.test.optional_uint32",
+		Tag:           "varint,3,opt,name=optional_uint32",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: (*uint64)(nil),
+		Field:         4,
+		Name:          "goproto.proto.test.optional_uint64",
+		Tag:           "varint,4,opt,name=optional_uint64",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: (*int32)(nil),
+		Field:         5,
+		Name:          "goproto.proto.test.optional_sint32",
+		Tag:           "zigzag32,5,opt,name=optional_sint32",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: (*int64)(nil),
+		Field:         6,
+		Name:          "goproto.proto.test.optional_sint64",
+		Tag:           "zigzag64,6,opt,name=optional_sint64",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: (*uint32)(nil),
+		Field:         7,
+		Name:          "goproto.proto.test.optional_fixed32",
+		Tag:           "fixed32,7,opt,name=optional_fixed32",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: (*uint64)(nil),
+		Field:         8,
+		Name:          "goproto.proto.test.optional_fixed64",
+		Tag:           "fixed64,8,opt,name=optional_fixed64",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: (*int32)(nil),
+		Field:         9,
+		Name:          "goproto.proto.test.optional_sfixed32",
+		Tag:           "fixed32,9,opt,name=optional_sfixed32",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: (*int64)(nil),
+		Field:         10,
+		Name:          "goproto.proto.test.optional_sfixed64",
+		Tag:           "fixed64,10,opt,name=optional_sfixed64",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: (*float32)(nil),
+		Field:         11,
+		Name:          "goproto.proto.test.optional_float",
+		Tag:           "fixed32,11,opt,name=optional_float",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: (*float64)(nil),
+		Field:         12,
+		Name:          "goproto.proto.test.optional_double",
+		Tag:           "fixed64,12,opt,name=optional_double",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: (*bool)(nil),
+		Field:         13,
+		Name:          "goproto.proto.test.optional_bool",
+		Tag:           "varint,13,opt,name=optional_bool",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: (*string)(nil),
+		Field:         14,
+		Name:          "goproto.proto.test.optional_string",
+		Tag:           "bytes,14,opt,name=optional_string",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: ([]byte)(nil),
+		Field:         15,
+		Name:          "goproto.proto.test.optional_bytes",
+		Tag:           "bytes,15,opt,name=optional_bytes",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: (*OptionalGroup)(nil),
+		Field:         16,
+		Name:          "goproto.proto.test.optionalgroup",
+		Tag:           "group,16,opt,name=OptionalGroup",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: (*TestAllExtensions_NestedMessage)(nil),
+		Field:         18,
+		Name:          "goproto.proto.test.optional_nested_message",
+		Tag:           "bytes,18,opt,name=optional_nested_message",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: (*TestAllTypes_NestedEnum)(nil),
+		Field:         21,
+		Name:          "goproto.proto.test.optional_nested_enum",
+		Tag:           "varint,21,opt,name=optional_nested_enum,enum=goproto.proto.test.TestAllTypes_NestedEnum",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: ([]int32)(nil),
+		Field:         31,
+		Name:          "goproto.proto.test.repeated_int32",
+		Tag:           "varint,31,rep,name=repeated_int32",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: ([]int64)(nil),
+		Field:         32,
+		Name:          "goproto.proto.test.repeated_int64",
+		Tag:           "varint,32,rep,name=repeated_int64",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: ([]uint32)(nil),
+		Field:         33,
+		Name:          "goproto.proto.test.repeated_uint32",
+		Tag:           "varint,33,rep,name=repeated_uint32",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: ([]uint64)(nil),
+		Field:         34,
+		Name:          "goproto.proto.test.repeated_uint64",
+		Tag:           "varint,34,rep,name=repeated_uint64",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: ([]int32)(nil),
+		Field:         35,
+		Name:          "goproto.proto.test.repeated_sint32",
+		Tag:           "zigzag32,35,rep,name=repeated_sint32",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: ([]int64)(nil),
+		Field:         36,
+		Name:          "goproto.proto.test.repeated_sint64",
+		Tag:           "zigzag64,36,rep,name=repeated_sint64",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: ([]uint32)(nil),
+		Field:         37,
+		Name:          "goproto.proto.test.repeated_fixed32",
+		Tag:           "fixed32,37,rep,name=repeated_fixed32",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: ([]uint64)(nil),
+		Field:         38,
+		Name:          "goproto.proto.test.repeated_fixed64",
+		Tag:           "fixed64,38,rep,name=repeated_fixed64",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: ([]int32)(nil),
+		Field:         39,
+		Name:          "goproto.proto.test.repeated_sfixed32",
+		Tag:           "fixed32,39,rep,name=repeated_sfixed32",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: ([]int64)(nil),
+		Field:         40,
+		Name:          "goproto.proto.test.repeated_sfixed64",
+		Tag:           "fixed64,40,rep,name=repeated_sfixed64",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: ([]float32)(nil),
+		Field:         41,
+		Name:          "goproto.proto.test.repeated_float",
+		Tag:           "fixed32,41,rep,name=repeated_float",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: ([]float64)(nil),
+		Field:         42,
+		Name:          "goproto.proto.test.repeated_double",
+		Tag:           "fixed64,42,rep,name=repeated_double",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: ([]bool)(nil),
+		Field:         43,
+		Name:          "goproto.proto.test.repeated_bool",
+		Tag:           "varint,43,rep,name=repeated_bool",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: ([]string)(nil),
+		Field:         44,
+		Name:          "goproto.proto.test.repeated_string",
+		Tag:           "bytes,44,rep,name=repeated_string",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: ([][]byte)(nil),
+		Field:         45,
+		Name:          "goproto.proto.test.repeated_bytes",
+		Tag:           "bytes,45,rep,name=repeated_bytes",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: ([]*RepeatedGroup)(nil),
+		Field:         46,
+		Name:          "goproto.proto.test.repeatedgroup",
+		Tag:           "group,46,rep,name=RepeatedGroup",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: ([]*TestAllExtensions_NestedMessage)(nil),
+		Field:         48,
+		Name:          "goproto.proto.test.repeated_nested_message",
+		Tag:           "bytes,48,rep,name=repeated_nested_message",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: ([]TestAllTypes_NestedEnum)(nil),
+		Field:         51,
+		Name:          "goproto.proto.test.repeated_nested_enum",
+		Tag:           "varint,51,rep,name=repeated_nested_enum,enum=goproto.proto.test.TestAllTypes_NestedEnum",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: (*int32)(nil),
+		Field:         81,
+		Name:          "goproto.proto.test.default_int32",
+		Tag:           "varint,81,opt,name=default_int32,def=81",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: (*int64)(nil),
+		Field:         82,
+		Name:          "goproto.proto.test.default_int64",
+		Tag:           "varint,82,opt,name=default_int64,def=82",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: (*uint32)(nil),
+		Field:         83,
+		Name:          "goproto.proto.test.default_uint32",
+		Tag:           "varint,83,opt,name=default_uint32,def=83",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: (*uint64)(nil),
+		Field:         84,
+		Name:          "goproto.proto.test.default_uint64",
+		Tag:           "varint,84,opt,name=default_uint64,def=84",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: (*int32)(nil),
+		Field:         85,
+		Name:          "goproto.proto.test.default_sint32",
+		Tag:           "zigzag32,85,opt,name=default_sint32,def=-85",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: (*int64)(nil),
+		Field:         86,
+		Name:          "goproto.proto.test.default_sint64",
+		Tag:           "zigzag64,86,opt,name=default_sint64,def=86",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: (*uint32)(nil),
+		Field:         87,
+		Name:          "goproto.proto.test.default_fixed32",
+		Tag:           "fixed32,87,opt,name=default_fixed32,def=87",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: (*uint64)(nil),
+		Field:         88,
+		Name:          "goproto.proto.test.default_fixed64",
+		Tag:           "fixed64,88,opt,name=default_fixed64,def=88",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: (*int32)(nil),
+		Field:         89,
+		Name:          "goproto.proto.test.default_sfixed32",
+		Tag:           "fixed32,89,opt,name=default_sfixed32,def=89",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: (*int64)(nil),
+		Field:         80,
+		Name:          "goproto.proto.test.default_sfixed64",
+		Tag:           "fixed64,80,opt,name=default_sfixed64,def=-90",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: (*float32)(nil),
+		Field:         91,
+		Name:          "goproto.proto.test.default_float",
+		Tag:           "fixed32,91,opt,name=default_float,def=91.5",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: (*float64)(nil),
+		Field:         92,
+		Name:          "goproto.proto.test.default_double",
+		Tag:           "fixed64,92,opt,name=default_double,def=92000",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: (*bool)(nil),
+		Field:         93,
+		Name:          "goproto.proto.test.default_bool",
+		Tag:           "varint,93,opt,name=default_bool,def=1",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: (*string)(nil),
+		Field:         94,
+		Name:          "goproto.proto.test.default_string",
+		Tag:           "bytes,94,opt,name=default_string,def=hello",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: ([]byte)(nil),
+		Field:         95,
+		Name:          "goproto.proto.test.default_bytes",
+		Tag:           "bytes,95,opt,name=default_bytes,def=world",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestPackedExtensions)(nil),
+		ExtensionType: ([]int32)(nil),
+		Field:         90,
+		Name:          "goproto.proto.test.packed_int32",
+		Tag:           "varint,90,rep,packed,name=packed_int32",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestPackedExtensions)(nil),
+		ExtensionType: ([]int64)(nil),
+		Field:         91,
+		Name:          "goproto.proto.test.packed_int64",
+		Tag:           "varint,91,rep,packed,name=packed_int64",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestPackedExtensions)(nil),
+		ExtensionType: ([]uint32)(nil),
+		Field:         92,
+		Name:          "goproto.proto.test.packed_uint32",
+		Tag:           "varint,92,rep,packed,name=packed_uint32",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestPackedExtensions)(nil),
+		ExtensionType: ([]uint64)(nil),
+		Field:         93,
+		Name:          "goproto.proto.test.packed_uint64",
+		Tag:           "varint,93,rep,packed,name=packed_uint64",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestPackedExtensions)(nil),
+		ExtensionType: ([]int32)(nil),
+		Field:         94,
+		Name:          "goproto.proto.test.packed_sint32",
+		Tag:           "zigzag32,94,rep,packed,name=packed_sint32",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestPackedExtensions)(nil),
+		ExtensionType: ([]int64)(nil),
+		Field:         95,
+		Name:          "goproto.proto.test.packed_sint64",
+		Tag:           "zigzag64,95,rep,packed,name=packed_sint64",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestPackedExtensions)(nil),
+		ExtensionType: ([]uint32)(nil),
+		Field:         96,
+		Name:          "goproto.proto.test.packed_fixed32",
+		Tag:           "fixed32,96,rep,packed,name=packed_fixed32",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestPackedExtensions)(nil),
+		ExtensionType: ([]uint64)(nil),
+		Field:         97,
+		Name:          "goproto.proto.test.packed_fixed64",
+		Tag:           "fixed64,97,rep,packed,name=packed_fixed64",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestPackedExtensions)(nil),
+		ExtensionType: ([]int32)(nil),
+		Field:         98,
+		Name:          "goproto.proto.test.packed_sfixed32",
+		Tag:           "fixed32,98,rep,packed,name=packed_sfixed32",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestPackedExtensions)(nil),
+		ExtensionType: ([]int64)(nil),
+		Field:         99,
+		Name:          "goproto.proto.test.packed_sfixed64",
+		Tag:           "fixed64,99,rep,packed,name=packed_sfixed64",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestPackedExtensions)(nil),
+		ExtensionType: ([]float32)(nil),
+		Field:         100,
+		Name:          "goproto.proto.test.packed_float",
+		Tag:           "fixed32,100,rep,packed,name=packed_float",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestPackedExtensions)(nil),
+		ExtensionType: ([]float64)(nil),
+		Field:         101,
+		Name:          "goproto.proto.test.packed_double",
+		Tag:           "fixed64,101,rep,packed,name=packed_double",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestPackedExtensions)(nil),
+		ExtensionType: ([]bool)(nil),
+		Field:         102,
+		Name:          "goproto.proto.test.packed_bool",
+		Tag:           "varint,102,rep,packed,name=packed_bool",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestPackedExtensions)(nil),
+		ExtensionType: ([]ForeignEnum)(nil),
+		Field:         103,
+		Name:          "goproto.proto.test.packed_enum",
+		Tag:           "varint,103,rep,packed,name=packed_enum,enum=goproto.proto.test.ForeignEnum",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestUnpackedExtensions)(nil),
+		ExtensionType: ([]int32)(nil),
+		Field:         90,
+		Name:          "goproto.proto.test.unpacked_int32",
+		Tag:           "varint,90,rep,name=unpacked_int32",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestUnpackedExtensions)(nil),
+		ExtensionType: ([]int64)(nil),
+		Field:         91,
+		Name:          "goproto.proto.test.unpacked_int64",
+		Tag:           "varint,91,rep,name=unpacked_int64",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestUnpackedExtensions)(nil),
+		ExtensionType: ([]uint32)(nil),
+		Field:         92,
+		Name:          "goproto.proto.test.unpacked_uint32",
+		Tag:           "varint,92,rep,name=unpacked_uint32",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestUnpackedExtensions)(nil),
+		ExtensionType: ([]uint64)(nil),
+		Field:         93,
+		Name:          "goproto.proto.test.unpacked_uint64",
+		Tag:           "varint,93,rep,name=unpacked_uint64",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestUnpackedExtensions)(nil),
+		ExtensionType: ([]int32)(nil),
+		Field:         94,
+		Name:          "goproto.proto.test.unpacked_sint32",
+		Tag:           "zigzag32,94,rep,name=unpacked_sint32",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestUnpackedExtensions)(nil),
+		ExtensionType: ([]int64)(nil),
+		Field:         95,
+		Name:          "goproto.proto.test.unpacked_sint64",
+		Tag:           "zigzag64,95,rep,name=unpacked_sint64",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestUnpackedExtensions)(nil),
+		ExtensionType: ([]uint32)(nil),
+		Field:         96,
+		Name:          "goproto.proto.test.unpacked_fixed32",
+		Tag:           "fixed32,96,rep,name=unpacked_fixed32",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestUnpackedExtensions)(nil),
+		ExtensionType: ([]uint64)(nil),
+		Field:         97,
+		Name:          "goproto.proto.test.unpacked_fixed64",
+		Tag:           "fixed64,97,rep,name=unpacked_fixed64",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestUnpackedExtensions)(nil),
+		ExtensionType: ([]int32)(nil),
+		Field:         98,
+		Name:          "goproto.proto.test.unpacked_sfixed32",
+		Tag:           "fixed32,98,rep,name=unpacked_sfixed32",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestUnpackedExtensions)(nil),
+		ExtensionType: ([]int64)(nil),
+		Field:         99,
+		Name:          "goproto.proto.test.unpacked_sfixed64",
+		Tag:           "fixed64,99,rep,name=unpacked_sfixed64",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestUnpackedExtensions)(nil),
+		ExtensionType: ([]float32)(nil),
+		Field:         100,
+		Name:          "goproto.proto.test.unpacked_float",
+		Tag:           "fixed32,100,rep,name=unpacked_float",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestUnpackedExtensions)(nil),
+		ExtensionType: ([]float64)(nil),
+		Field:         101,
+		Name:          "goproto.proto.test.unpacked_double",
+		Tag:           "fixed64,101,rep,name=unpacked_double",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestUnpackedExtensions)(nil),
+		ExtensionType: ([]bool)(nil),
+		Field:         102,
+		Name:          "goproto.proto.test.unpacked_bool",
+		Tag:           "varint,102,rep,name=unpacked_bool",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestUnpackedExtensions)(nil),
+		ExtensionType: ([]ForeignEnum)(nil),
+		Field:         103,
+		Name:          "goproto.proto.test.unpacked_enum",
+		Tag:           "varint,103,rep,name=unpacked_enum,enum=goproto.proto.test.ForeignEnum",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: (*string)(nil),
+		Field:         1003,
+		Name:          "goproto.proto.test.TestNestedExtension.nested_string_extension",
+		Tag:           "bytes,1003,opt,name=nested_string_extension",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: (*TestRequired)(nil),
+		Field:         1000,
+		Name:          "goproto.proto.test.TestRequired.single",
+		Tag:           "bytes,1000,opt,name=single",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+	{
+		ExtendedType:  (*TestAllExtensions)(nil),
+		ExtensionType: ([]*TestRequired)(nil),
+		Field:         1001,
+		Name:          "goproto.proto.test.TestRequired.multi",
+		Tag:           "bytes,1001,rep,name=multi",
+		Filename:      "internal/testprotos/test/test.proto",
+	},
+}
+
+// Extension fields to TestAllExtensions.
+var (
+	// optional int32 optional_int32 = 1;
+	E_OptionalInt32 = &file_internal_testprotos_test_test_proto_extTypes[0]
+	// optional int64 optional_int64 = 2;
+	E_OptionalInt64 = &file_internal_testprotos_test_test_proto_extTypes[1]
+	// optional uint32 optional_uint32 = 3;
+	E_OptionalUint32 = &file_internal_testprotos_test_test_proto_extTypes[2]
+	// optional uint64 optional_uint64 = 4;
+	E_OptionalUint64 = &file_internal_testprotos_test_test_proto_extTypes[3]
+	// optional sint32 optional_sint32 = 5;
+	E_OptionalSint32 = &file_internal_testprotos_test_test_proto_extTypes[4]
+	// optional sint64 optional_sint64 = 6;
+	E_OptionalSint64 = &file_internal_testprotos_test_test_proto_extTypes[5]
+	// optional fixed32 optional_fixed32 = 7;
+	E_OptionalFixed32 = &file_internal_testprotos_test_test_proto_extTypes[6]
+	// optional fixed64 optional_fixed64 = 8;
+	E_OptionalFixed64 = &file_internal_testprotos_test_test_proto_extTypes[7]
+	// optional sfixed32 optional_sfixed32 = 9;
+	E_OptionalSfixed32 = &file_internal_testprotos_test_test_proto_extTypes[8]
+	// optional sfixed64 optional_sfixed64 = 10;
+	E_OptionalSfixed64 = &file_internal_testprotos_test_test_proto_extTypes[9]
+	// optional float optional_float = 11;
+	E_OptionalFloat = &file_internal_testprotos_test_test_proto_extTypes[10]
+	// optional double optional_double = 12;
+	E_OptionalDouble = &file_internal_testprotos_test_test_proto_extTypes[11]
+	// optional bool optional_bool = 13;
+	E_OptionalBool = &file_internal_testprotos_test_test_proto_extTypes[12]
+	// optional string optional_string = 14;
+	E_OptionalString = &file_internal_testprotos_test_test_proto_extTypes[13]
+	// optional bytes optional_bytes = 15;
+	E_OptionalBytes = &file_internal_testprotos_test_test_proto_extTypes[14]
+	// optional goproto.proto.test.OptionalGroup optionalgroup = 16;
+	E_Optionalgroup = &file_internal_testprotos_test_test_proto_extTypes[15]
+	// optional goproto.proto.test.TestAllExtensions.NestedMessage optional_nested_message = 18;
+	E_OptionalNestedMessage = &file_internal_testprotos_test_test_proto_extTypes[16]
+	// optional goproto.proto.test.TestAllTypes.NestedEnum optional_nested_enum = 21;
+	E_OptionalNestedEnum = &file_internal_testprotos_test_test_proto_extTypes[17]
+	// repeated int32 repeated_int32 = 31;
+	E_RepeatedInt32 = &file_internal_testprotos_test_test_proto_extTypes[18]
+	// repeated int64 repeated_int64 = 32;
+	E_RepeatedInt64 = &file_internal_testprotos_test_test_proto_extTypes[19]
+	// repeated uint32 repeated_uint32 = 33;
+	E_RepeatedUint32 = &file_internal_testprotos_test_test_proto_extTypes[20]
+	// repeated uint64 repeated_uint64 = 34;
+	E_RepeatedUint64 = &file_internal_testprotos_test_test_proto_extTypes[21]
+	// repeated sint32 repeated_sint32 = 35;
+	E_RepeatedSint32 = &file_internal_testprotos_test_test_proto_extTypes[22]
+	// repeated sint64 repeated_sint64 = 36;
+	E_RepeatedSint64 = &file_internal_testprotos_test_test_proto_extTypes[23]
+	// repeated fixed32 repeated_fixed32 = 37;
+	E_RepeatedFixed32 = &file_internal_testprotos_test_test_proto_extTypes[24]
+	// repeated fixed64 repeated_fixed64 = 38;
+	E_RepeatedFixed64 = &file_internal_testprotos_test_test_proto_extTypes[25]
+	// repeated sfixed32 repeated_sfixed32 = 39;
+	E_RepeatedSfixed32 = &file_internal_testprotos_test_test_proto_extTypes[26]
+	// repeated sfixed64 repeated_sfixed64 = 40;
+	E_RepeatedSfixed64 = &file_internal_testprotos_test_test_proto_extTypes[27]
+	// repeated float repeated_float = 41;
+	E_RepeatedFloat = &file_internal_testprotos_test_test_proto_extTypes[28]
+	// repeated double repeated_double = 42;
+	E_RepeatedDouble = &file_internal_testprotos_test_test_proto_extTypes[29]
+	// repeated bool repeated_bool = 43;
+	E_RepeatedBool = &file_internal_testprotos_test_test_proto_extTypes[30]
+	// repeated string repeated_string = 44;
+	E_RepeatedString = &file_internal_testprotos_test_test_proto_extTypes[31]
+	// repeated bytes repeated_bytes = 45;
+	E_RepeatedBytes = &file_internal_testprotos_test_test_proto_extTypes[32]
+	// repeated goproto.proto.test.RepeatedGroup repeatedgroup = 46;
+	E_Repeatedgroup = &file_internal_testprotos_test_test_proto_extTypes[33]
+	// repeated goproto.proto.test.TestAllExtensions.NestedMessage repeated_nested_message = 48;
+	E_RepeatedNestedMessage = &file_internal_testprotos_test_test_proto_extTypes[34]
+	// repeated goproto.proto.test.TestAllTypes.NestedEnum repeated_nested_enum = 51;
+	E_RepeatedNestedEnum = &file_internal_testprotos_test_test_proto_extTypes[35]
+	// optional int32 default_int32 = 81;
+	E_DefaultInt32 = &file_internal_testprotos_test_test_proto_extTypes[36]
+	// optional int64 default_int64 = 82;
+	E_DefaultInt64 = &file_internal_testprotos_test_test_proto_extTypes[37]
+	// optional uint32 default_uint32 = 83;
+	E_DefaultUint32 = &file_internal_testprotos_test_test_proto_extTypes[38]
+	// optional uint64 default_uint64 = 84;
+	E_DefaultUint64 = &file_internal_testprotos_test_test_proto_extTypes[39]
+	// optional sint32 default_sint32 = 85;
+	E_DefaultSint32 = &file_internal_testprotos_test_test_proto_extTypes[40]
+	// optional sint64 default_sint64 = 86;
+	E_DefaultSint64 = &file_internal_testprotos_test_test_proto_extTypes[41]
+	// optional fixed32 default_fixed32 = 87;
+	E_DefaultFixed32 = &file_internal_testprotos_test_test_proto_extTypes[42]
+	// optional fixed64 default_fixed64 = 88;
+	E_DefaultFixed64 = &file_internal_testprotos_test_test_proto_extTypes[43]
+	// optional sfixed32 default_sfixed32 = 89;
+	E_DefaultSfixed32 = &file_internal_testprotos_test_test_proto_extTypes[44]
+	// optional sfixed64 default_sfixed64 = 80;
+	E_DefaultSfixed64 = &file_internal_testprotos_test_test_proto_extTypes[45]
+	// optional float default_float = 91;
+	E_DefaultFloat = &file_internal_testprotos_test_test_proto_extTypes[46]
+	// optional double default_double = 92;
+	E_DefaultDouble = &file_internal_testprotos_test_test_proto_extTypes[47]
+	// optional bool default_bool = 93;
+	E_DefaultBool = &file_internal_testprotos_test_test_proto_extTypes[48]
+	// optional string default_string = 94;
+	E_DefaultString = &file_internal_testprotos_test_test_proto_extTypes[49]
+	// optional bytes default_bytes = 95;
+	E_DefaultBytes = &file_internal_testprotos_test_test_proto_extTypes[50]
+	// optional string nested_string_extension = 1003;
+	E_TestNestedExtension_NestedStringExtension = &file_internal_testprotos_test_test_proto_extTypes[79]
+	// optional goproto.proto.test.TestRequired single = 1000;
+	E_TestRequired_Single = &file_internal_testprotos_test_test_proto_extTypes[80]
+	// repeated goproto.proto.test.TestRequired multi = 1001;
+	E_TestRequired_Multi = &file_internal_testprotos_test_test_proto_extTypes[81]
+)
+
+// Extension fields to TestPackedExtensions.
+var (
+	// repeated int32 packed_int32 = 90;
+	E_PackedInt32 = &file_internal_testprotos_test_test_proto_extTypes[51]
+	// repeated int64 packed_int64 = 91;
+	E_PackedInt64 = &file_internal_testprotos_test_test_proto_extTypes[52]
+	// repeated uint32 packed_uint32 = 92;
+	E_PackedUint32 = &file_internal_testprotos_test_test_proto_extTypes[53]
+	// repeated uint64 packed_uint64 = 93;
+	E_PackedUint64 = &file_internal_testprotos_test_test_proto_extTypes[54]
+	// repeated sint32 packed_sint32 = 94;
+	E_PackedSint32 = &file_internal_testprotos_test_test_proto_extTypes[55]
+	// repeated sint64 packed_sint64 = 95;
+	E_PackedSint64 = &file_internal_testprotos_test_test_proto_extTypes[56]
+	// repeated fixed32 packed_fixed32 = 96;
+	E_PackedFixed32 = &file_internal_testprotos_test_test_proto_extTypes[57]
+	// repeated fixed64 packed_fixed64 = 97;
+	E_PackedFixed64 = &file_internal_testprotos_test_test_proto_extTypes[58]
+	// repeated sfixed32 packed_sfixed32 = 98;
+	E_PackedSfixed32 = &file_internal_testprotos_test_test_proto_extTypes[59]
+	// repeated sfixed64 packed_sfixed64 = 99;
+	E_PackedSfixed64 = &file_internal_testprotos_test_test_proto_extTypes[60]
+	// repeated float packed_float = 100;
+	E_PackedFloat = &file_internal_testprotos_test_test_proto_extTypes[61]
+	// repeated double packed_double = 101;
+	E_PackedDouble = &file_internal_testprotos_test_test_proto_extTypes[62]
+	// repeated bool packed_bool = 102;
+	E_PackedBool = &file_internal_testprotos_test_test_proto_extTypes[63]
+	// repeated goproto.proto.test.ForeignEnum packed_enum = 103;
+	E_PackedEnum = &file_internal_testprotos_test_test_proto_extTypes[64]
+)
+
+// Extension fields to TestUnpackedExtensions.
+var (
+	// repeated int32 unpacked_int32 = 90;
+	E_UnpackedInt32 = &file_internal_testprotos_test_test_proto_extTypes[65]
+	// repeated int64 unpacked_int64 = 91;
+	E_UnpackedInt64 = &file_internal_testprotos_test_test_proto_extTypes[66]
+	// repeated uint32 unpacked_uint32 = 92;
+	E_UnpackedUint32 = &file_internal_testprotos_test_test_proto_extTypes[67]
+	// repeated uint64 unpacked_uint64 = 93;
+	E_UnpackedUint64 = &file_internal_testprotos_test_test_proto_extTypes[68]
+	// repeated sint32 unpacked_sint32 = 94;
+	E_UnpackedSint32 = &file_internal_testprotos_test_test_proto_extTypes[69]
+	// repeated sint64 unpacked_sint64 = 95;
+	E_UnpackedSint64 = &file_internal_testprotos_test_test_proto_extTypes[70]
+	// repeated fixed32 unpacked_fixed32 = 96;
+	E_UnpackedFixed32 = &file_internal_testprotos_test_test_proto_extTypes[71]
+	// repeated fixed64 unpacked_fixed64 = 97;
+	E_UnpackedFixed64 = &file_internal_testprotos_test_test_proto_extTypes[72]
+	// repeated sfixed32 unpacked_sfixed32 = 98;
+	E_UnpackedSfixed32 = &file_internal_testprotos_test_test_proto_extTypes[73]
+	// repeated sfixed64 unpacked_sfixed64 = 99;
+	E_UnpackedSfixed64 = &file_internal_testprotos_test_test_proto_extTypes[74]
+	// repeated float unpacked_float = 100;
+	E_UnpackedFloat = &file_internal_testprotos_test_test_proto_extTypes[75]
+	// repeated double unpacked_double = 101;
+	E_UnpackedDouble = &file_internal_testprotos_test_test_proto_extTypes[76]
+	// repeated bool unpacked_bool = 102;
+	E_UnpackedBool = &file_internal_testprotos_test_test_proto_extTypes[77]
+	// repeated goproto.proto.test.ForeignEnum unpacked_enum = 103;
+	E_UnpackedEnum = &file_internal_testprotos_test_test_proto_extTypes[78]
+)
+
+var File_internal_testprotos_test_test_proto protoreflect.FileDescriptor
+
+var file_internal_testprotos_test_test_proto_rawDesc = []byte{
+	0x0a, 0x23, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x69, 0x6e, 0x74, 0x65, 0x72,
+	0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x74,
+	0x65, 0x73, 0x74, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x2a, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f,
+	0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f,
+	0x74, 0x65, 0x73, 0x74, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x1a, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x77, 0x65, 0x61, 0x6b,
+	0x31, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x77, 0x65, 0x61, 0x6b, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x1a, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x77, 0x65, 0x61, 0x6b,
+	0x32, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x77, 0x65, 0x61, 0x6b, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x22, 0xa5, 0x3a, 0x0a, 0x0c, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70,
+	0x65, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x69,
+	0x6e, 0x74, 0x33, 0x32, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x61, 0x6c, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x25, 0x0a, 0x0e, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x03, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x49, 0x6e, 0x74, 0x36, 0x34,
+	0x12, 0x27, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x75, 0x69, 0x6e,
+	0x74, 0x33, 0x32, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x27, 0x0a, 0x0f, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x04, 0x20, 0x01,
+	0x28, 0x04, 0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x55, 0x69, 0x6e, 0x74,
+	0x36, 0x34, 0x12, 0x27, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x73,
+	0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x05, 0x20, 0x01, 0x28, 0x11, 0x52, 0x0e, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x27, 0x0a, 0x0f, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x06,
+	0x20, 0x01, 0x28, 0x12, 0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x69,
+	0x6e, 0x74, 0x36, 0x34, 0x12, 0x29, 0x0a, 0x10, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x07, 0x20, 0x01, 0x28, 0x07, 0x52, 0x0f,
+	0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12,
+	0x29, 0x0a, 0x10, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x66, 0x69, 0x78, 0x65,
+	0x64, 0x36, 0x34, 0x18, 0x08, 0x20, 0x01, 0x28, 0x06, 0x52, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x2b, 0x0a, 0x11, 0x6f, 0x70,
+	0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18,
+	0x09, 0x20, 0x01, 0x28, 0x0f, 0x52, 0x10, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53,
+	0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x2b, 0x0a, 0x11, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x0a, 0x20, 0x01,
+	0x28, 0x10, 0x52, 0x10, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x66, 0x69, 0x78,
+	0x65, 0x64, 0x36, 0x34, 0x12, 0x25, 0x0a, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0d, 0x6f, 0x70,
+	0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0x0c,
+	0x20, 0x01, 0x28, 0x01, 0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x44, 0x6f,
+	0x75, 0x62, 0x6c, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x27, 0x0a, 0x0f, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x0e, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x74, 0x72, 0x69,
+	0x6e, 0x67, 0x12, 0x25, 0x0a, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x62,
+	0x79, 0x74, 0x65, 0x73, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x61, 0x6c, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x54, 0x0a, 0x0d, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0a,
+	0x32, 0x2e, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70,
+	0x65, 0x73, 0x2e, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x47, 0x72, 0x6f, 0x75, 0x70,
+	0x52, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x12,
+	0x66, 0x0a, 0x17, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x6e, 0x65, 0x73, 0x74,
+	0x65, 0x64, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x12, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x2e, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70,
+	0x65, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x52, 0x15, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x5c, 0x0a, 0x18, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x5f, 0x66, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x18, 0x13, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x67, 0x6f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x46,
+	0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x16, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x59, 0x0a, 0x17, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x5f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x18, 0x14, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x49, 0x6d, 0x70, 0x6f,
+	0x72, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x15, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x12, 0x5d, 0x0a, 0x14, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x6e, 0x65, 0x73,
+	0x74, 0x65, 0x64, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x15, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2b,
+	0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74,
+	0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73,
+	0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x12, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x12,
+	0x53, 0x0a, 0x15, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x66, 0x6f, 0x72, 0x65,
+	0x69, 0x67, 0x6e, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x16, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1f,
+	0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74,
+	0x65, 0x73, 0x74, 0x2e, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x45, 0x6e, 0x75, 0x6d, 0x52,
+	0x13, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e,
+	0x45, 0x6e, 0x75, 0x6d, 0x12, 0x50, 0x0a, 0x14, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x5f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x17, 0x20, 0x01,
+	0x28, 0x0e, 0x32, 0x1e, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x45, 0x6e,
+	0x75, 0x6d, 0x52, 0x12, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x49, 0x6d, 0x70, 0x6f,
+	0x72, 0x74, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74,
+	0x65, 0x64, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x1f, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0d,
+	0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x25, 0x0a,
+	0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18,
+	0x20, 0x20, 0x03, 0x28, 0x03, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x49,
+	0x6e, 0x74, 0x36, 0x34, 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
+	0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x21, 0x20, 0x03, 0x28, 0x0d, 0x52, 0x0e, 0x72,
+	0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x27, 0x0a,
+	0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34,
+	0x18, 0x22, 0x20, 0x03, 0x28, 0x04, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
+	0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74,
+	0x65, 0x64, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x23, 0x20, 0x03, 0x28, 0x11, 0x52,
+	0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12,
+	0x27, 0x0a, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x73, 0x69, 0x6e, 0x74,
+	0x36, 0x34, 0x18, 0x24, 0x20, 0x03, 0x28, 0x12, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74,
+	0x65, 0x64, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x29, 0x0a, 0x10, 0x72, 0x65, 0x70, 0x65,
+	0x61, 0x74, 0x65, 0x64, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x25, 0x20, 0x03,
+	0x28, 0x07, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x46, 0x69, 0x78, 0x65,
+	0x64, 0x33, 0x32, 0x12, 0x29, 0x0a, 0x10, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f,
+	0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x26, 0x20, 0x03, 0x28, 0x06, 0x52, 0x0f, 0x72,
+	0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x2b,
+	0x0a, 0x11, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65,
+	0x64, 0x33, 0x32, 0x18, 0x27, 0x20, 0x03, 0x28, 0x0f, 0x52, 0x10, 0x72, 0x65, 0x70, 0x65, 0x61,
+	0x74, 0x65, 0x64, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x2b, 0x0a, 0x11, 0x72,
+	0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34,
+	0x18, 0x28, 0x20, 0x03, 0x28, 0x10, 0x52, 0x10, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
+	0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x70, 0x65,
+	0x61, 0x74, 0x65, 0x64, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x18, 0x29, 0x20, 0x03, 0x28, 0x02,
+	0x52, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12,
+	0x27, 0x0a, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x64, 0x6f, 0x75, 0x62,
+	0x6c, 0x65, 0x18, 0x2a, 0x20, 0x03, 0x28, 0x01, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74,
+	0x65, 0x64, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x70, 0x65,
+	0x61, 0x74, 0x65, 0x64, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18, 0x2b, 0x20, 0x03, 0x28, 0x08, 0x52,
+	0x0c, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x27, 0x0a,
+	0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67,
+	0x18, 0x2c, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
+	0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74,
+	0x65, 0x64, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x2d, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x0d,
+	0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x54, 0x0a,
+	0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x2e,
+	0x20, 0x03, 0x28, 0x0a, 0x32, 0x2e, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c,
+	0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x52, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x47,
+	0x72, 0x6f, 0x75, 0x70, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x67, 0x72,
+	0x6f, 0x75, 0x70, 0x12, 0x66, 0x0a, 0x17, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f,
+	0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x30,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c,
+	0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x52, 0x15, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x4e, 0x65,
+	0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x5c, 0x0a, 0x18, 0x72,
+	0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x66, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x31, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e,
+	0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65,
+	0x73, 0x74, 0x2e, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x52, 0x16, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x46, 0x6f, 0x72, 0x65, 0x69,
+	0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x58, 0x0a, 0x16, 0x72, 0x65, 0x70,
+	0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x18, 0x32, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x67, 0x6f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x49,
+	0x6d, 0x70, 0x6f, 0x72, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x15, 0x72, 0x65,
+	0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x12, 0x5d, 0x0a, 0x14, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f,
+	0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x33, 0x20, 0x03, 0x28,
+	0x0e, 0x32, 0x2b, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79,
+	0x70, 0x65, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x12,
+	0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e,
+	0x75, 0x6d, 0x12, 0x53, 0x0a, 0x15, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x66,
+	0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x34, 0x20, 0x03, 0x28,
+	0x0e, 0x32, 0x1f, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x45, 0x6e,
+	0x75, 0x6d, 0x52, 0x13, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x46, 0x6f, 0x72, 0x65,
+	0x69, 0x67, 0x6e, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x4f, 0x0a, 0x13, 0x72, 0x65, 0x70, 0x65, 0x61,
+	0x74, 0x65, 0x64, 0x5f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x35,
+	0x20, 0x03, 0x28, 0x0e, 0x32, 0x1e, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74,
+	0x45, 0x6e, 0x75, 0x6d, 0x52, 0x12, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x49, 0x6d,
+	0x70, 0x6f, 0x72, 0x74, 0x65, 0x6e, 0x75, 0x6d, 0x12, 0x5b, 0x0a, 0x0f, 0x6d, 0x61, 0x70, 0x5f,
+	0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x38, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x33, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79,
+	0x70, 0x65, 0x73, 0x2e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x49, 0x6e, 0x74, 0x33,
+	0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0d, 0x6d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x33, 0x32,
+	0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x5b, 0x0a, 0x0f, 0x6d, 0x61, 0x70, 0x5f, 0x69, 0x6e, 0x74,
+	0x36, 0x34, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x39, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x33,
+	0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74,
+	0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73,
+	0x2e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x45, 0x6e,
+	0x74, 0x72, 0x79, 0x52, 0x0d, 0x6d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x49, 0x6e, 0x74,
+	0x36, 0x34, 0x12, 0x61, 0x0a, 0x11, 0x6d, 0x61, 0x70, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32,
+	0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x3a, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x35, 0x2e,
+	0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65,
+	0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e,
+	0x4d, 0x61, 0x70, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x45,
+	0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x6d, 0x61, 0x70, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x55,
+	0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x61, 0x0a, 0x11, 0x6d, 0x61, 0x70, 0x5f, 0x75, 0x69, 0x6e,
+	0x74, 0x36, 0x34, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x3b, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x35, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70,
+	0x65, 0x73, 0x2e, 0x4d, 0x61, 0x70, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x55, 0x69, 0x6e, 0x74,
+	0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x6d, 0x61, 0x70, 0x55, 0x69, 0x6e, 0x74,
+	0x36, 0x34, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x61, 0x0a, 0x11, 0x6d, 0x61, 0x70, 0x5f,
+	0x73, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x3c, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c,
+	0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x53,
+	0x69, 0x6e, 0x74, 0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x6d, 0x61, 0x70, 0x53,
+	0x69, 0x6e, 0x74, 0x33, 0x32, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x61, 0x0a, 0x11, 0x6d,
+	0x61, 0x70, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x36, 0x34,
+	0x18, 0x3d, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74,
+	0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x69, 0x6e, 0x74,
+	0x36, 0x34, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x6d,
+	0x61, 0x70, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x67,
+	0x0a, 0x13, 0x6d, 0x61, 0x70, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x5f, 0x66, 0x69,
+	0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x3e, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x37, 0x2e, 0x67, 0x6f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74,
+	0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4d, 0x61,
+	0x70, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x45,
+	0x6e, 0x74, 0x72, 0x79, 0x52, 0x11, 0x6d, 0x61, 0x70, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32,
+	0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x67, 0x0a, 0x13, 0x6d, 0x61, 0x70, 0x5f, 0x66,
+	0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x3f,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x37, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c,
+	0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4d, 0x61, 0x70, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36,
+	0x34, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x11, 0x6d,
+	0x61, 0x70, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34,
+	0x12, 0x6d, 0x0a, 0x15, 0x6d, 0x61, 0x70, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32,
+	0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x40, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x39, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65,
+	0x73, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x53, 0x66, 0x69,
+	0x78, 0x65, 0x64, 0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x13, 0x6d, 0x61, 0x70, 0x53,
+	0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12,
+	0x6d, 0x0a, 0x15, 0x6d, 0x61, 0x70, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x5f,
+	0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x41, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x39,
+	0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74,
+	0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73,
+	0x2e, 0x4d, 0x61, 0x70, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x53, 0x66, 0x69, 0x78,
+	0x65, 0x64, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x13, 0x6d, 0x61, 0x70, 0x53, 0x66,
+	0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x5b,
+	0x0a, 0x0f, 0x6d, 0x61, 0x70, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x66, 0x6c, 0x6f, 0x61,
+	0x74, 0x18, 0x42, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x33, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73,
+	0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74,
+	0x33, 0x32, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0d, 0x6d, 0x61,
+	0x70, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x5e, 0x0a, 0x10, 0x6d,
+	0x61, 0x70, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18,
+	0x43, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41,
+	0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x33, 0x32,
+	0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, 0x6d, 0x61, 0x70,
+	0x49, 0x6e, 0x74, 0x33, 0x32, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x55, 0x0a, 0x0d, 0x6d,
+	0x61, 0x70, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18, 0x44, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x31, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54,
+	0x79, 0x70, 0x65, 0x73, 0x2e, 0x4d, 0x61, 0x70, 0x42, 0x6f, 0x6f, 0x6c, 0x42, 0x6f, 0x6f, 0x6c,
+	0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0b, 0x6d, 0x61, 0x70, 0x42, 0x6f, 0x6f, 0x6c, 0x42, 0x6f,
+	0x6f, 0x6c, 0x12, 0x61, 0x0a, 0x11, 0x6d, 0x61, 0x70, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67,
+	0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x45, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x35, 0x2e,
+	0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65,
+	0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e,
+	0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45,
+	0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x6d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53,
+	0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x5e, 0x0a, 0x10, 0x6d, 0x61, 0x70, 0x5f, 0x73, 0x74, 0x72,
+	0x69, 0x6e, 0x67, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x46, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x34, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65,
+	0x73, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x79, 0x74, 0x65, 0x73,
+	0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, 0x6d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67,
+	0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x77, 0x0a, 0x19, 0x6d, 0x61, 0x70, 0x5f, 0x73, 0x74, 0x72,
+	0x69, 0x6e, 0x67, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x18, 0x47, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3c, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65,
+	0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74,
+	0x72, 0x69, 0x6e, 0x67, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x16, 0x6d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e,
+	0x67, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x6e,
+	0x0a, 0x16, 0x6d, 0x61, 0x70, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x6e, 0x65, 0x73,
+	0x74, 0x65, 0x64, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x49, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x39,
+	0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74,
+	0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73,
+	0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64,
+	0x45, 0x6e, 0x75, 0x6d, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x13, 0x6d, 0x61, 0x70, 0x53, 0x74,
+	0x72, 0x69, 0x6e, 0x67, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x27,
+	0x0a, 0x0d, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18,
+	0x51, 0x20, 0x01, 0x28, 0x05, 0x3a, 0x02, 0x38, 0x31, 0x52, 0x0c, 0x64, 0x65, 0x66, 0x61, 0x75,
+	0x6c, 0x74, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x27, 0x0a, 0x0d, 0x64, 0x65, 0x66, 0x61, 0x75,
+	0x6c, 0x74, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x52, 0x20, 0x01, 0x28, 0x03, 0x3a, 0x02,
+	0x38, 0x32, 0x52, 0x0c, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x49, 0x6e, 0x74, 0x36, 0x34,
+	0x12, 0x29, 0x0a, 0x0e, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x75, 0x69, 0x6e, 0x74,
+	0x33, 0x32, 0x18, 0x53, 0x20, 0x01, 0x28, 0x0d, 0x3a, 0x02, 0x38, 0x33, 0x52, 0x0d, 0x64, 0x65,
+	0x66, 0x61, 0x75, 0x6c, 0x74, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x29, 0x0a, 0x0e, 0x64,
+	0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x54, 0x20,
+	0x01, 0x28, 0x04, 0x3a, 0x02, 0x38, 0x34, 0x52, 0x0d, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74,
+	0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x2a, 0x0a, 0x0e, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c,
+	0x74, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x55, 0x20, 0x01, 0x28, 0x11, 0x3a, 0x03,
+	0x2d, 0x38, 0x35, 0x52, 0x0d, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x53, 0x69, 0x6e, 0x74,
+	0x33, 0x32, 0x12, 0x29, 0x0a, 0x0e, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x73, 0x69,
+	0x6e, 0x74, 0x36, 0x34, 0x18, 0x56, 0x20, 0x01, 0x28, 0x12, 0x3a, 0x02, 0x38, 0x36, 0x52, 0x0d,
+	0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x2b, 0x0a,
+	0x0f, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32,
+	0x18, 0x57, 0x20, 0x01, 0x28, 0x07, 0x3a, 0x02, 0x38, 0x37, 0x52, 0x0e, 0x64, 0x65, 0x66, 0x61,
+	0x75, 0x6c, 0x74, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x2b, 0x0a, 0x0f, 0x64, 0x65,
+	0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x58, 0x20,
+	0x01, 0x28, 0x06, 0x3a, 0x02, 0x38, 0x38, 0x52, 0x0e, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74,
+	0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x2d, 0x0a, 0x10, 0x64, 0x65, 0x66, 0x61, 0x75,
+	0x6c, 0x74, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x59, 0x20, 0x01, 0x28,
+	0x0f, 0x3a, 0x02, 0x38, 0x39, 0x52, 0x0f, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x53, 0x66,
+	0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x2e, 0x0a, 0x10, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c,
+	0x74, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x50, 0x20, 0x01, 0x28, 0x10,
+	0x3a, 0x03, 0x2d, 0x39, 0x30, 0x52, 0x0f, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x53, 0x66,
+	0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x29, 0x0a, 0x0d, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c,
+	0x74, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x18, 0x5b, 0x20, 0x01, 0x28, 0x02, 0x3a, 0x04, 0x39,
+	0x31, 0x2e, 0x35, 0x52, 0x0c, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x46, 0x6c, 0x6f, 0x61,
+	0x74, 0x12, 0x2c, 0x0a, 0x0e, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x64, 0x6f, 0x75,
+	0x62, 0x6c, 0x65, 0x18, 0x5c, 0x20, 0x01, 0x28, 0x01, 0x3a, 0x05, 0x39, 0x32, 0x30, 0x30, 0x30,
+	0x52, 0x0d, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12,
+	0x27, 0x0a, 0x0c, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18,
+	0x5d, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x04, 0x74, 0x72, 0x75, 0x65, 0x52, 0x0b, 0x64, 0x65, 0x66,
+	0x61, 0x75, 0x6c, 0x74, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x2c, 0x0a, 0x0e, 0x64, 0x65, 0x66, 0x61,
+	0x75, 0x6c, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x5e, 0x20, 0x01, 0x28, 0x09,
+	0x3a, 0x05, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x52, 0x0d, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74,
+	0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x2a, 0x0a, 0x0d, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c,
+	0x74, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x5f, 0x20, 0x01, 0x28, 0x0c, 0x3a, 0x05, 0x77,
+	0x6f, 0x72, 0x6c, 0x64, 0x52, 0x0c, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x42, 0x79, 0x74,
+	0x65, 0x73, 0x12, 0x60, 0x0a, 0x13, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x6e, 0x65,
+	0x73, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x60, 0x20, 0x01, 0x28, 0x0e, 0x32,
+	0x2b, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65,
+	0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x3a, 0x03, 0x42, 0x41,
+	0x52, 0x52, 0x11, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64,
+	0x45, 0x6e, 0x75, 0x6d, 0x12, 0x5e, 0x0a, 0x14, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f,
+	0x66, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x61, 0x20, 0x01,
+	0x28, 0x0e, 0x32, 0x1f, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x45,
+	0x6e, 0x75, 0x6d, 0x3a, 0x0b, 0x46, 0x4f, 0x52, 0x45, 0x49, 0x47, 0x4e, 0x5f, 0x42, 0x41, 0x52,
+	0x52, 0x12, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e,
+	0x45, 0x6e, 0x75, 0x6d, 0x12, 0x23, 0x0a, 0x0c, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x75, 0x69,
+	0x6e, 0x74, 0x33, 0x32, 0x18, 0x6f, 0x20, 0x01, 0x28, 0x0d, 0x48, 0x00, 0x52, 0x0b, 0x6f, 0x6e,
+	0x65, 0x6f, 0x66, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x62, 0x0a, 0x14, 0x6f, 0x6e, 0x65,
+	0x6f, 0x66, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x18, 0x70, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73,
+	0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x48, 0x00, 0x52, 0x12, 0x6f, 0x6e, 0x65, 0x6f, 0x66,
+	0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x23, 0x0a,
+	0x0c, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x71, 0x20,
+	0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x53, 0x74, 0x72, 0x69,
+	0x6e, 0x67, 0x12, 0x21, 0x0a, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x62, 0x79, 0x74, 0x65,
+	0x73, 0x18, 0x72, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x0a, 0x6f, 0x6e, 0x65, 0x6f, 0x66,
+	0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x1f, 0x0a, 0x0a, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x62,
+	0x6f, 0x6f, 0x6c, 0x18, 0x73, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x09, 0x6f, 0x6e, 0x65,
+	0x6f, 0x66, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x23, 0x0a, 0x0c, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f,
+	0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x74, 0x20, 0x01, 0x28, 0x04, 0x48, 0x00, 0x52, 0x0b,
+	0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x21, 0x0a, 0x0b, 0x6f,
+	0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x18, 0x75, 0x20, 0x01, 0x28, 0x02,
+	0x48, 0x00, 0x52, 0x0a, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x23,
+	0x0a, 0x0c, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0x76,
+	0x20, 0x01, 0x28, 0x01, 0x48, 0x00, 0x52, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x44, 0x6f, 0x75,
+	0x62, 0x6c, 0x65, 0x12, 0x4c, 0x0a, 0x0a, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x65, 0x6e, 0x75,
+	0x6d, 0x18, 0x77, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2b, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73,
+	0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64,
+	0x45, 0x6e, 0x75, 0x6d, 0x48, 0x00, 0x52, 0x09, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x45, 0x6e, 0x75,
+	0x6d, 0x12, 0x4d, 0x0a, 0x0a, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18,
+	0x79, 0x20, 0x01, 0x28, 0x0a, 0x32, 0x2b, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41,
+	0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4f, 0x6e, 0x65, 0x6f, 0x66, 0x47, 0x72, 0x6f,
+	0x75, 0x70, 0x48, 0x00, 0x52, 0x0a, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x67, 0x72, 0x6f, 0x75, 0x70,
+	0x12, 0x34, 0x0a, 0x15, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+	0x61, 0x6c, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x78, 0x20, 0x01, 0x28, 0x0d, 0x48,
+	0x01, 0x52, 0x13, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x1a, 0x61, 0x0a, 0x0d, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x0c, 0x0a, 0x01, 0x61, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x01, 0x61, 0x12, 0x42, 0x0a, 0x0b, 0x63, 0x6f, 0x72, 0x65, 0x63, 0x75, 0x72,
+	0x73, 0x69, 0x76, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x67, 0x6f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e,
+	0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x52, 0x0b, 0x63, 0x6f,
+	0x72, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x76, 0x65, 0x1a, 0xb2, 0x01, 0x0a, 0x0d, 0x4f, 0x70,
+	0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x0c, 0x0a, 0x01, 0x61,
+	0x18, 0x11, 0x20, 0x01, 0x28, 0x05, 0x52, 0x01, 0x61, 0x12, 0x67, 0x0a, 0x17, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x18, 0xe8, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x67, 0x6f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74,
+	0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4e, 0x65,
+	0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x15, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x12, 0x2a, 0x0a, 0x11, 0x73, 0x61, 0x6d, 0x65, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64,
+	0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x10, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0f, 0x73,
+	0x61, 0x6d, 0x65, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x1a, 0x86,
+	0x01, 0x0a, 0x0d, 0x52, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70,
+	0x12, 0x0c, 0x0a, 0x01, 0x61, 0x18, 0x2f, 0x20, 0x01, 0x28, 0x05, 0x52, 0x01, 0x61, 0x12, 0x67,
+	0x0a, 0x17, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65,
+	0x64, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0xe9, 0x07, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x2e, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70,
+	0x65, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x52, 0x15, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x1a, 0x40, 0x0a, 0x12, 0x4d, 0x61, 0x70, 0x49, 0x6e,
+	0x74, 0x33, 0x32, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a,
+	0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12,
+	0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05,
+	0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x40, 0x0a, 0x12, 0x4d, 0x61, 0x70,
+	0x49, 0x6e, 0x74, 0x36, 0x34, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12,
+	0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65,
+	0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03,
+	0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x42, 0x0a, 0x14, 0x4d,
+	0x61, 0x70, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x45, 0x6e,
+	0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d,
+	0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a,
+	0x42, 0x0a, 0x14, 0x4d, 0x61, 0x70, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x55, 0x69, 0x6e, 0x74,
+	0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x04, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c,
+	0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a,
+	0x02, 0x38, 0x01, 0x1a, 0x42, 0x0a, 0x14, 0x4d, 0x61, 0x70, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32,
+	0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b,
+	0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x11, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a,
+	0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x11, 0x52, 0x05, 0x76, 0x61,
+	0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x42, 0x0a, 0x14, 0x4d, 0x61, 0x70, 0x53, 0x69,
+	0x6e, 0x74, 0x36, 0x34, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12,
+	0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x12, 0x52, 0x03, 0x6b, 0x65,
+	0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x12,
+	0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x44, 0x0a, 0x16, 0x4d,
+	0x61, 0x70, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32,
+	0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x07, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x07, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38,
+	0x01, 0x1a, 0x44, 0x0a, 0x16, 0x4d, 0x61, 0x70, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x46,
+	0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b,
+	0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x06, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a,
+	0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x06, 0x52, 0x05, 0x76, 0x61,
+	0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x46, 0x0a, 0x18, 0x4d, 0x61, 0x70, 0x53, 0x66,
+	0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x45, 0x6e,
+	0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0f,
+	0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x0f, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a,
+	0x46, 0x0a, 0x18, 0x4d, 0x61, 0x70, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x53, 0x66,
+	0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b,
+	0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x10, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a,
+	0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x10, 0x52, 0x05, 0x76, 0x61,
+	0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x40, 0x0a, 0x12, 0x4d, 0x61, 0x70, 0x49, 0x6e,
+	0x74, 0x33, 0x32, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a,
+	0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12,
+	0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x02, 0x52, 0x05,
+	0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x41, 0x0a, 0x13, 0x4d, 0x61, 0x70,
+	0x49, 0x6e, 0x74, 0x33, 0x32, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79,
+	0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x6b,
+	0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x01, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x3e, 0x0a, 0x10,
+	0x4d, 0x61, 0x70, 0x42, 0x6f, 0x6f, 0x6c, 0x42, 0x6f, 0x6f, 0x6c, 0x45, 0x6e, 0x74, 0x72, 0x79,
+	0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x03, 0x6b,
+	0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x08, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x42, 0x0a, 0x14,
+	0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45,
+	0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01,
+	0x1a, 0x41, 0x0a, 0x13, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x79, 0x74,
+	0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c,
+	0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a,
+	0x02, 0x38, 0x01, 0x1a, 0x79, 0x0a, 0x1b, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67,
+	0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x45, 0x6e, 0x74,
+	0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x03, 0x6b, 0x65, 0x79, 0x12, 0x44, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c,
+	0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x73,
+	0x0a, 0x18, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x4e, 0x65, 0x73, 0x74, 0x65,
+	0x64, 0x45, 0x6e, 0x75, 0x6d, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65,
+	0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x41, 0x0a, 0x05,
+	0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2b, 0x2e, 0x67, 0x6f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74,
+	0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4e, 0x65,
+	0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a,
+	0x02, 0x38, 0x01, 0x1a, 0x28, 0x0a, 0x0a, 0x4f, 0x6e, 0x65, 0x6f, 0x66, 0x47, 0x72, 0x6f, 0x75,
+	0x70, 0x12, 0x0c, 0x0a, 0x01, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x01, 0x61, 0x12,
+	0x0c, 0x0a, 0x01, 0x62, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x01, 0x62, 0x22, 0x39, 0x0a,
+	0x0a, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x07, 0x0a, 0x03, 0x46,
+	0x4f, 0x4f, 0x10, 0x00, 0x12, 0x07, 0x0a, 0x03, 0x42, 0x41, 0x52, 0x10, 0x01, 0x12, 0x07, 0x0a,
+	0x03, 0x42, 0x41, 0x5a, 0x10, 0x02, 0x12, 0x10, 0x0a, 0x03, 0x4e, 0x45, 0x47, 0x10, 0xff, 0xff,
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x42, 0x0d, 0x0a, 0x0b, 0x6f, 0x6e, 0x65, 0x6f,
+	0x66, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x42, 0x10, 0x0a, 0x0e, 0x6f, 0x6e, 0x65, 0x6f, 0x66,
+	0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x22, 0xc4, 0x01, 0x0a, 0x15, 0x54, 0x65,
+	0x73, 0x74, 0x44, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x12, 0x2d, 0x0a, 0x10, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65,
+	0x64, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x42, 0x02, 0x18,
+	0x01, 0x52, 0x0f, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x49, 0x6e, 0x74,
+	0x33, 0x32, 0x12, 0x3a, 0x0a, 0x16, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64,
+	0x5f, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x05, 0x42, 0x02, 0x18, 0x01, 0x48, 0x00, 0x52, 0x14, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63,
+	0x61, 0x74, 0x65, 0x64, 0x4f, 0x6e, 0x65, 0x6f, 0x66, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x22, 0x28,
+	0x0a, 0x0e, 0x44, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d,
+	0x12, 0x12, 0x0a, 0x0a, 0x44, 0x45, 0x50, 0x52, 0x45, 0x43, 0x41, 0x54, 0x45, 0x44, 0x10, 0x00,
+	0x1a, 0x02, 0x08, 0x01, 0x1a, 0x02, 0x18, 0x01, 0x3a, 0x02, 0x18, 0x01, 0x42, 0x12, 0x0a, 0x10,
+	0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x6e, 0x65, 0x6f, 0x66,
+	0x22, 0x2c, 0x0a, 0x0e, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x12, 0x0c, 0x0a, 0x01, 0x63, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x01, 0x63,
+	0x12, 0x0c, 0x0a, 0x01, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x01, 0x64, 0x22, 0x30,
+	0x0a, 0x12, 0x54, 0x65, 0x73, 0x74, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x46, 0x69,
+	0x65, 0x6c, 0x64, 0x73, 0x4a, 0x04, 0x08, 0x02, 0x10, 0x03, 0x4a, 0x04, 0x08, 0x0f, 0x10, 0x10,
+	0x4a, 0x04, 0x08, 0x09, 0x10, 0x0c, 0x52, 0x03, 0x62, 0x61, 0x72, 0x52, 0x03, 0x62, 0x61, 0x7a,
+	0x22, 0x85, 0x01, 0x0a, 0x11, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65,
+	0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x1a, 0x66, 0x0a, 0x0d, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x0c, 0x0a, 0x01, 0x61, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x01, 0x61, 0x12, 0x47, 0x0a, 0x0b, 0x63, 0x6f, 0x72, 0x65, 0x63, 0x75, 0x72,
+	0x73, 0x69, 0x76, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x67, 0x6f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e,
+	0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
+	0x73, 0x52, 0x0b, 0x63, 0x6f, 0x72, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x76, 0x65, 0x2a, 0x08,
+	0x08, 0x01, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x22, 0xb7, 0x01, 0x0a, 0x0d, 0x4f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x0c, 0x0a, 0x01, 0x61, 0x18,
+	0x11, 0x20, 0x01, 0x28, 0x05, 0x52, 0x01, 0x61, 0x12, 0x2a, 0x0a, 0x11, 0x73, 0x61, 0x6d, 0x65,
+	0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x10, 0x20,
+	0x01, 0x28, 0x05, 0x52, 0x0f, 0x73, 0x61, 0x6d, 0x65, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e, 0x75,
+	0x6d, 0x62, 0x65, 0x72, 0x12, 0x6c, 0x0a, 0x17, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18,
+	0xe8, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x33, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74,
+	0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x4e, 0x65,
+	0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x15, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x22, 0x8b, 0x01, 0x0a, 0x0d, 0x52, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x47,
+	0x72, 0x6f, 0x75, 0x70, 0x12, 0x0c, 0x0a, 0x01, 0x61, 0x18, 0x2f, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x01, 0x61, 0x12, 0x6c, 0x0a, 0x17, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x6e,
+	0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0xe9, 0x07,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x33, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c,
+	0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74,
+	0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x15, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x22, 0x75, 0x0a, 0x13, 0x54, 0x65, 0x73, 0x74, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x78,
+	0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x32, 0x5e, 0x0a, 0x17, 0x6e, 0x65, 0x73, 0x74, 0x65,
+	0x64, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69,
+	0x6f, 0x6e, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45,
+	0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xeb, 0x07, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x15, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x78,
+	0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0xf7, 0x01, 0x0a, 0x0c, 0x54, 0x65, 0x73, 0x74,
+	0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x71, 0x75,
+	0x69, 0x72, 0x65, 0x64, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x01, 0x20, 0x02, 0x28, 0x05,
+	0x52, 0x0d, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x32,
+	0x60, 0x0a, 0x06, 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54,
+	0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73,
+	0x18, 0xe8, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73,
+	0x74, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x52, 0x06, 0x73, 0x69, 0x6e, 0x67, 0x6c,
+	0x65, 0x32, 0x5e, 0x0a, 0x05, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e,
+	0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
+	0x73, 0x18, 0xe9, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65,
+	0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x52, 0x05, 0x6d, 0x75, 0x6c, 0x74,
+	0x69, 0x22, 0xc2, 0x03, 0x0a, 0x13, 0x54, 0x65, 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72,
+	0x65, 0x64, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x12, 0x4b, 0x0a, 0x10, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x52, 0x65, 0x71,
+	0x75, 0x69, 0x72, 0x65, 0x64, 0x52, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x4b, 0x0a, 0x10, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74,
+	0x65, 0x64, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x20, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72,
+	0x65, 0x64, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x12, 0x58, 0x0a, 0x0b, 0x6d, 0x61, 0x70, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x37, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65,
+	0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67,
+	0x6e, 0x2e, 0x4d, 0x61, 0x70, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x45, 0x6e, 0x74, 0x72,
+	0x79, 0x52, 0x0a, 0x6d, 0x61, 0x70, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x47, 0x0a,
+	0x0d, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x04,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x52, 0x65,
+	0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x48, 0x00, 0x52, 0x0c, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x1a, 0x5f, 0x0a, 0x0f, 0x4d, 0x61, 0x70, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x36, 0x0a, 0x05, 0x76,
+	0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x67, 0x6f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e,
+	0x54, 0x65, 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x52, 0x05, 0x76, 0x61,
+	0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x42, 0x0d, 0x0a, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66,
+	0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x22, 0x99, 0x02, 0x0a, 0x17, 0x54, 0x65, 0x73, 0x74, 0x52,
+	0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x46, 0x69, 0x65, 0x6c,
+	0x64, 0x73, 0x12, 0x5f, 0x0a, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x67, 0x72,
+	0x6f, 0x75, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0a, 0x32, 0x39, 0x2e, 0x67, 0x6f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54,
+	0x65, 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70,
+	0x46, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x2e, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x47,
+	0x72, 0x6f, 0x75, 0x70, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x67, 0x72,
+	0x6f, 0x75, 0x70, 0x12, 0x5f, 0x0a, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x67,
+	0x72, 0x6f, 0x75, 0x70, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0a, 0x32, 0x39, 0x2e, 0x67, 0x6f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e,
+	0x54, 0x65, 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x47, 0x72, 0x6f, 0x75,
+	0x70, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x2e, 0x52, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
+	0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x67,
+	0x72, 0x6f, 0x75, 0x70, 0x1a, 0x1d, 0x0a, 0x0d, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x0c, 0x0a, 0x01, 0x61, 0x18, 0x02, 0x20, 0x02, 0x28, 0x05,
+	0x52, 0x01, 0x61, 0x1a, 0x1d, 0x0a, 0x0d, 0x52, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x47,
+	0x72, 0x6f, 0x75, 0x70, 0x12, 0x0c, 0x0a, 0x01, 0x61, 0x18, 0x04, 0x20, 0x02, 0x28, 0x05, 0x52,
+	0x01, 0x61, 0x22, 0xb6, 0x01, 0x0a, 0x08, 0x54, 0x65, 0x73, 0x74, 0x57, 0x65, 0x61, 0x6b, 0x12,
+	0x54, 0x0a, 0x0d, 0x77, 0x65, 0x61, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x77, 0x65, 0x61, 0x6b,
+	0x2e, 0x57, 0x65, 0x61, 0x6b, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x31, 0x42, 0x02, 0x50, 0x01, 0x52, 0x0c, 0x77, 0x65, 0x61, 0x6b, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x31, 0x12, 0x54, 0x0a, 0x0d, 0x77, 0x65, 0x61, 0x6b, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x67,
+	0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73,
+	0x74, 0x2e, 0x77, 0x65, 0x61, 0x6b, 0x2e, 0x57, 0x65, 0x61, 0x6b, 0x49, 0x6d, 0x70, 0x6f, 0x72,
+	0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x42, 0x02, 0x50, 0x01, 0x52, 0x0c, 0x77,
+	0x65, 0x61, 0x6b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x22, 0xee, 0x04, 0x0a, 0x0f,
+	0x54, 0x65, 0x73, 0x74, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x54, 0x79, 0x70, 0x65, 0x73, 0x12,
+	0x25, 0x0a, 0x0c, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18,
+	0x5a, 0x20, 0x03, 0x28, 0x05, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0b, 0x70, 0x61, 0x63, 0x6b, 0x65,
+	0x64, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x25, 0x0a, 0x0c, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64,
+	0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x5b, 0x20, 0x03, 0x28, 0x03, 0x42, 0x02, 0x10, 0x01,
+	0x52, 0x0b, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x27, 0x0a,
+	0x0d, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x5c,
+	0x20, 0x03, 0x28, 0x0d, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0c, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64,
+	0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x27, 0x0a, 0x0d, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64,
+	0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x5d, 0x20, 0x03, 0x28, 0x04, 0x42, 0x02, 0x10,
+	0x01, 0x52, 0x0c, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12,
+	0x27, 0x0a, 0x0d, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x33, 0x32,
+	0x18, 0x5e, 0x20, 0x03, 0x28, 0x11, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0c, 0x70, 0x61, 0x63, 0x6b,
+	0x65, 0x64, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x27, 0x0a, 0x0d, 0x70, 0x61, 0x63, 0x6b,
+	0x65, 0x64, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x5f, 0x20, 0x03, 0x28, 0x12, 0x42,
+	0x02, 0x10, 0x01, 0x52, 0x0c, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x53, 0x69, 0x6e, 0x74, 0x36,
+	0x34, 0x12, 0x29, 0x0a, 0x0e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x66, 0x69, 0x78, 0x65,
+	0x64, 0x33, 0x32, 0x18, 0x60, 0x20, 0x03, 0x28, 0x07, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0d, 0x70,
+	0x61, 0x63, 0x6b, 0x65, 0x64, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x29, 0x0a, 0x0e,
+	0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x61,
+	0x20, 0x03, 0x28, 0x06, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0d, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64,
+	0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x2b, 0x0a, 0x0f, 0x70, 0x61, 0x63, 0x6b, 0x65,
+	0x64, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x62, 0x20, 0x03, 0x28, 0x0f,
+	0x42, 0x02, 0x10, 0x01, 0x52, 0x0e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x53, 0x66, 0x69, 0x78,
+	0x65, 0x64, 0x33, 0x32, 0x12, 0x2b, 0x0a, 0x0f, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x73,
+	0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x63, 0x20, 0x03, 0x28, 0x10, 0x42, 0x02, 0x10,
+	0x01, 0x52, 0x0e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36,
+	0x34, 0x12, 0x25, 0x0a, 0x0c, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x66, 0x6c, 0x6f, 0x61,
+	0x74, 0x18, 0x64, 0x20, 0x03, 0x28, 0x02, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0b, 0x70, 0x61, 0x63,
+	0x6b, 0x65, 0x64, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x27, 0x0a, 0x0d, 0x70, 0x61, 0x63, 0x6b,
+	0x65, 0x64, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0x65, 0x20, 0x03, 0x28, 0x01, 0x42,
+	0x02, 0x10, 0x01, 0x52, 0x0c, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x44, 0x6f, 0x75, 0x62, 0x6c,
+	0x65, 0x12, 0x23, 0x0a, 0x0b, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x62, 0x6f, 0x6f, 0x6c,
+	0x18, 0x66, 0x20, 0x03, 0x28, 0x08, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0a, 0x70, 0x61, 0x63, 0x6b,
+	0x65, 0x64, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x44, 0x0a, 0x0b, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64,
+	0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x67, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x1f, 0x2e, 0x67, 0x6f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74,
+	0x2e, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x45, 0x6e, 0x75, 0x6d, 0x42, 0x02, 0x10, 0x01,
+	0x52, 0x0a, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x22, 0xa8, 0x05, 0x0a,
+	0x11, 0x54, 0x65, 0x73, 0x74, 0x55, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x54, 0x79, 0x70,
+	0x65, 0x73, 0x12, 0x29, 0x0a, 0x0e, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x69,
+	0x6e, 0x74, 0x33, 0x32, 0x18, 0x5a, 0x20, 0x03, 0x28, 0x05, 0x42, 0x02, 0x10, 0x00, 0x52, 0x0d,
+	0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x29, 0x0a,
+	0x0e, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18,
+	0x5b, 0x20, 0x03, 0x28, 0x03, 0x42, 0x02, 0x10, 0x00, 0x52, 0x0d, 0x75, 0x6e, 0x70, 0x61, 0x63,
+	0x6b, 0x65, 0x64, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x2b, 0x0a, 0x0f, 0x75, 0x6e, 0x70, 0x61,
+	0x63, 0x6b, 0x65, 0x64, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x5c, 0x20, 0x03, 0x28,
+	0x0d, 0x42, 0x02, 0x10, 0x00, 0x52, 0x0e, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x55,
+	0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x2b, 0x0a, 0x0f, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65,
+	0x64, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x5d, 0x20, 0x03, 0x28, 0x04, 0x42, 0x02,
+	0x10, 0x00, 0x52, 0x0e, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x55, 0x69, 0x6e, 0x74,
+	0x36, 0x34, 0x12, 0x2b, 0x0a, 0x0f, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x73,
+	0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x5e, 0x20, 0x03, 0x28, 0x11, 0x42, 0x02, 0x10, 0x00, 0x52,
+	0x0e, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12,
+	0x2b, 0x0a, 0x0f, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x73, 0x69, 0x6e, 0x74,
+	0x36, 0x34, 0x18, 0x5f, 0x20, 0x03, 0x28, 0x12, 0x42, 0x02, 0x10, 0x00, 0x52, 0x0e, 0x75, 0x6e,
+	0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x2d, 0x0a, 0x10,
+	0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32,
+	0x18, 0x60, 0x20, 0x03, 0x28, 0x07, 0x42, 0x02, 0x10, 0x00, 0x52, 0x0f, 0x75, 0x6e, 0x70, 0x61,
+	0x63, 0x6b, 0x65, 0x64, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x2d, 0x0a, 0x10, 0x75,
+	0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18,
+	0x61, 0x20, 0x03, 0x28, 0x06, 0x42, 0x02, 0x10, 0x00, 0x52, 0x0f, 0x75, 0x6e, 0x70, 0x61, 0x63,
+	0x6b, 0x65, 0x64, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x2f, 0x0a, 0x11, 0x75, 0x6e,
+	0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18,
+	0x62, 0x20, 0x03, 0x28, 0x0f, 0x42, 0x02, 0x10, 0x00, 0x52, 0x10, 0x75, 0x6e, 0x70, 0x61, 0x63,
+	0x6b, 0x65, 0x64, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x2f, 0x0a, 0x11, 0x75,
+	0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34,
+	0x18, 0x63, 0x20, 0x03, 0x28, 0x10, 0x42, 0x02, 0x10, 0x00, 0x52, 0x10, 0x75, 0x6e, 0x70, 0x61,
+	0x63, 0x6b, 0x65, 0x64, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x29, 0x0a, 0x0e,
+	0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x18, 0x64,
+	0x20, 0x03, 0x28, 0x02, 0x42, 0x02, 0x10, 0x00, 0x52, 0x0d, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b,
+	0x65, 0x64, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x2b, 0x0a, 0x0f, 0x75, 0x6e, 0x70, 0x61, 0x63,
+	0x6b, 0x65, 0x64, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0x65, 0x20, 0x03, 0x28, 0x01,
+	0x42, 0x02, 0x10, 0x00, 0x52, 0x0e, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x44, 0x6f,
+	0x75, 0x62, 0x6c, 0x65, 0x12, 0x27, 0x0a, 0x0d, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64,
+	0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18, 0x66, 0x20, 0x03, 0x28, 0x08, 0x42, 0x02, 0x10, 0x00, 0x52,
+	0x0c, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x48, 0x0a,
+	0x0d, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x67,
+	0x20, 0x03, 0x28, 0x0e, 0x32, 0x1f, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67,
+	0x6e, 0x45, 0x6e, 0x75, 0x6d, 0x42, 0x02, 0x10, 0x00, 0x52, 0x0c, 0x75, 0x6e, 0x70, 0x61, 0x63,
+	0x6b, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x22, 0x20, 0x0a, 0x14, 0x54, 0x65, 0x73, 0x74, 0x50,
+	0x61, 0x63, 0x6b, 0x65, 0x64, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2a,
+	0x08, 0x08, 0x01, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x22, 0x22, 0x0a, 0x16, 0x54, 0x65, 0x73,
+	0x74, 0x55, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69,
+	0x6f, 0x6e, 0x73, 0x2a, 0x08, 0x08, 0x01, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x22, 0x0c, 0x0a,
+	0x0a, 0x46, 0x6f, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x0d, 0x0a, 0x0b, 0x46,
+	0x6f, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x61, 0x0a, 0x0c, 0x57, 0x65,
+	0x69, 0x72, 0x64, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x12, 0x51, 0x0a, 0x0d, 0x77, 0x65,
+	0x69, 0x72, 0x64, 0x5f, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x0c, 0x3a, 0x2c, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x2c, 0x20, 0x5c, 0x22, 0x77, 0x6f, 0x72, 0x6c,
+	0x64, 0x21, 0x5c, 0x22, 0x5c, 0x6e, 0x64, 0x65, 0x61, 0x64, 0x5c, 0x33, 0x33, 0x36, 0x5c, 0x32,
+	0x35, 0x35, 0x5c, 0x32, 0x37, 0x36, 0x5c, 0x33, 0x35, 0x37, 0x62, 0x65, 0x65, 0x66, 0x60, 0x52,
+	0x0c, 0x77, 0x65, 0x69, 0x72, 0x64, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x2a, 0x40, 0x0a,
+	0x0b, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x0f, 0x0a, 0x0b,
+	0x46, 0x4f, 0x52, 0x45, 0x49, 0x47, 0x4e, 0x5f, 0x46, 0x4f, 0x4f, 0x10, 0x04, 0x12, 0x0f, 0x0a,
+	0x0b, 0x46, 0x4f, 0x52, 0x45, 0x49, 0x47, 0x4e, 0x5f, 0x42, 0x41, 0x52, 0x10, 0x05, 0x12, 0x0f,
+	0x0a, 0x0b, 0x46, 0x4f, 0x52, 0x45, 0x49, 0x47, 0x4e, 0x5f, 0x42, 0x41, 0x5a, 0x10, 0x06, 0x2a,
+	0x47, 0x0a, 0x16, 0x54, 0x65, 0x73, 0x74, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x45,
+	0x6e, 0x75, 0x6d, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x12, 0x11, 0x0a, 0x0d, 0x52, 0x45, 0x53,
+	0x45, 0x52, 0x56, 0x45, 0x44, 0x5f, 0x45, 0x4e, 0x55, 0x4d, 0x10, 0x00, 0x22, 0x04, 0x08, 0x02,
+	0x10, 0x02, 0x22, 0x04, 0x08, 0x0f, 0x10, 0x0f, 0x22, 0x04, 0x08, 0x09, 0x10, 0x0b, 0x2a, 0x03,
+	0x42, 0x41, 0x52, 0x2a, 0x03, 0x42, 0x41, 0x5a, 0x32, 0xa8, 0x01, 0x0a, 0x0b, 0x54, 0x65, 0x73,
+	0x74, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x46, 0x0a, 0x03, 0x46, 0x6f, 0x6f, 0x12,
+	0x1e, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x74, 0x65, 0x73, 0x74, 0x2e, 0x46, 0x6f, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
+	0x1f, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x74, 0x65, 0x73, 0x74, 0x2e, 0x46, 0x6f, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x12, 0x51, 0x0a, 0x0a, 0x54, 0x65, 0x73, 0x74, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x12, 0x1e,
+	0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74,
+	0x65, 0x73, 0x74, 0x2e, 0x46, 0x6f, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f,
+	0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74,
+	0x65, 0x73, 0x74, 0x2e, 0x46, 0x6f, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x28,
+	0x01, 0x30, 0x01, 0x32, 0x85, 0x01, 0x0a, 0x15, 0x54, 0x65, 0x73, 0x74, 0x44, 0x65, 0x70, 0x72,
+	0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x67, 0x0a,
+	0x0a, 0x44, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x12, 0x29, 0x2e, 0x67, 0x6f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74,
+	0x2e, 0x54, 0x65, 0x73, 0x74, 0x44, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x1a, 0x29, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74,
+	0x44, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x22, 0x03, 0x88, 0x02, 0x01, 0x1a, 0x03, 0x88, 0x02, 0x01, 0x3a, 0x4c, 0x0a, 0x0e, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x25, 0x2e,
+	0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65,
+	0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73,
+	0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x61, 0x6c, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x3a, 0x4c, 0x0a, 0x0e, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x25, 0x2e, 0x67, 0x6f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74,
+	0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f,
+	0x6e, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+	0x61, 0x6c, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x3a, 0x4e, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e,
+	0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
+	0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x3a, 0x4e, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e,
+	0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
+	0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x3a, 0x4e, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e,
+	0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
+	0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x11, 0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x3a, 0x4e, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e,
+	0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
+	0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x12, 0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x3a, 0x50, 0x0a, 0x10, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x25, 0x2e, 0x67, 0x6f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74,
+	0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f,
+	0x6e, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x07, 0x52, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+	0x61, 0x6c, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x3a, 0x50, 0x0a, 0x10, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x25, 0x2e,
+	0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65,
+	0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73,
+	0x69, 0x6f, 0x6e, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x06, 0x52, 0x0f, 0x6f, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x61, 0x6c, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x3a, 0x52, 0x0a, 0x11, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32,
+	0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74,
+	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0f, 0x52, 0x10, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x3a,
+	0x52, 0x0a, 0x11, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x66, 0x69, 0x78,
+	0x65, 0x64, 0x36, 0x34, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c,
+	0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x0a, 0x20, 0x01, 0x28,
+	0x10, 0x52, 0x10, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x66, 0x69, 0x78, 0x65,
+	0x64, 0x36, 0x34, 0x3a, 0x4c, 0x0a, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f,
+	0x66, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41,
+	0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x0b, 0x20, 0x01,
+	0x28, 0x02, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x46, 0x6c, 0x6f, 0x61,
+	0x74, 0x3a, 0x4e, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x64, 0x6f,
+	0x75, 0x62, 0x6c, 0x65, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c,
+	0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x0c, 0x20, 0x01, 0x28,
+	0x01, 0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x44, 0x6f, 0x75, 0x62, 0x6c,
+	0x65, 0x3a, 0x4a, 0x0a, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x62, 0x6f,
+	0x6f, 0x6c, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45,
+	0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x0c, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x42, 0x6f, 0x6f, 0x6c, 0x3a, 0x4e, 0x0a,
+	0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67,
+	0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74,
+	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3a, 0x4c, 0x0a,
+	0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x12,
+	0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65,
+	0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x6f, 0x70,
+	0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x42, 0x79, 0x74, 0x65, 0x73, 0x3a, 0x6e, 0x0a, 0x0d, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x25, 0x2e, 0x67,
+	0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73,
+	0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69,
+	0x6f, 0x6e, 0x73, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0a, 0x32, 0x21, 0x2e, 0x67, 0x6f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x4f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x0d, 0x6f, 0x70,
+	0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x3a, 0x92, 0x01, 0x0a, 0x17,
+	0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73,
+	0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x12,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x33, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c,
+	0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74,
+	0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x15, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x3a, 0x84, 0x01, 0x0a, 0x14, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x6e, 0x65,
+	0x73, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54,
+	0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73,
+	0x18, 0x15, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2b, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74,
+	0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45,
+	0x6e, 0x75, 0x6d, 0x52, 0x12, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x4e, 0x65, 0x73,
+	0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x3a, 0x4c, 0x0a, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61,
+	0x74, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54,
+	0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73,
+	0x18, 0x1f, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
+	0x49, 0x6e, 0x74, 0x33, 0x32, 0x3a, 0x4c, 0x0a, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65,
+	0x64, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73,
+	0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x20,
+	0x20, 0x03, 0x28, 0x03, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x49, 0x6e,
+	0x74, 0x36, 0x34, 0x3a, 0x4e, 0x0a, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f,
+	0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74,
+	0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x21, 0x20,
+	0x03, 0x28, 0x0d, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x55, 0x69, 0x6e,
+	0x74, 0x33, 0x32, 0x3a, 0x4e, 0x0a, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f,
+	0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74,
+	0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x22, 0x20,
+	0x03, 0x28, 0x04, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x55, 0x69, 0x6e,
+	0x74, 0x36, 0x34, 0x3a, 0x4e, 0x0a, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f,
+	0x73, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74,
+	0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x23, 0x20,
+	0x03, 0x28, 0x11, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x53, 0x69, 0x6e,
+	0x74, 0x33, 0x32, 0x3a, 0x4e, 0x0a, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f,
+	0x73, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74,
+	0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x24, 0x20,
+	0x03, 0x28, 0x12, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x53, 0x69, 0x6e,
+	0x74, 0x36, 0x34, 0x3a, 0x50, 0x0a, 0x10, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f,
+	0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73,
+	0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x25,
+	0x20, 0x03, 0x28, 0x07, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x46, 0x69,
+	0x78, 0x65, 0x64, 0x33, 0x32, 0x3a, 0x50, 0x0a, 0x10, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65,
+	0x64, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54,
+	0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73,
+	0x18, 0x26, 0x20, 0x03, 0x28, 0x06, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
+	0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x3a, 0x52, 0x0a, 0x11, 0x72, 0x65, 0x70, 0x65, 0x61,
+	0x74, 0x65, 0x64, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x25, 0x2e, 0x67,
+	0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73,
+	0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69,
+	0x6f, 0x6e, 0x73, 0x18, 0x27, 0x20, 0x03, 0x28, 0x0f, 0x52, 0x10, 0x72, 0x65, 0x70, 0x65, 0x61,
+	0x74, 0x65, 0x64, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x3a, 0x52, 0x0a, 0x11, 0x72,
+	0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34,
+	0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74,
+	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x28, 0x20, 0x03, 0x28, 0x10, 0x52, 0x10, 0x72,
+	0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x3a,
+	0x4c, 0x0a, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x66, 0x6c, 0x6f, 0x61,
+	0x74, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78,
+	0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x29, 0x20, 0x03, 0x28, 0x02, 0x52, 0x0d,
+	0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x3a, 0x4e, 0x0a,
+	0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65,
+	0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74,
+	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x2a, 0x20, 0x03, 0x28, 0x01, 0x52, 0x0e, 0x72,
+	0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x3a, 0x4a, 0x0a,
+	0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x12, 0x25,
+	0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74,
+	0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e,
+	0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x2b, 0x20, 0x03, 0x28, 0x08, 0x52, 0x0c, 0x72, 0x65, 0x70,
+	0x65, 0x61, 0x74, 0x65, 0x64, 0x42, 0x6f, 0x6f, 0x6c, 0x3a, 0x4e, 0x0a, 0x0f, 0x72, 0x65, 0x70,
+	0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x25, 0x2e, 0x67,
+	0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73,
+	0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69,
+	0x6f, 0x6e, 0x73, 0x18, 0x2c, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61,
+	0x74, 0x65, 0x64, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3a, 0x4c, 0x0a, 0x0e, 0x72, 0x65, 0x70,
+	0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x12, 0x25, 0x2e, 0x67, 0x6f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74,
+	0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f,
+	0x6e, 0x73, 0x18, 0x2d, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74,
+	0x65, 0x64, 0x42, 0x79, 0x74, 0x65, 0x73, 0x3a, 0x6e, 0x0a, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61,
+	0x74, 0x65, 0x64, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65,
+	0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18,
+	0x2e, 0x20, 0x03, 0x28, 0x0a, 0x32, 0x21, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x52, 0x65, 0x70, 0x65, 0x61,
+	0x74, 0x65, 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74,
+	0x65, 0x64, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x3a, 0x92, 0x01, 0x0a, 0x17, 0x72, 0x65, 0x70, 0x65,
+	0x61, 0x74, 0x65, 0x64, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c,
+	0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x30, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x33, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74,
+	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x15, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x4e,
+	0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x3a, 0x84, 0x01, 0x0a,
+	0x14, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64,
+	0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41,
+	0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x33, 0x20, 0x03,
+	0x28, 0x0e, 0x32, 0x2b, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54,
+	0x79, 0x70, 0x65, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52,
+	0x12, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45,
+	0x6e, 0x75, 0x6d, 0x3a, 0x4e, 0x0a, 0x0d, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x69,
+	0x6e, 0x74, 0x33, 0x32, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c,
+	0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x51, 0x20, 0x01, 0x28,
+	0x05, 0x3a, 0x02, 0x38, 0x31, 0x52, 0x0c, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x49, 0x6e,
+	0x74, 0x33, 0x32, 0x3a, 0x4e, 0x0a, 0x0d, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x69,
+	0x6e, 0x74, 0x36, 0x34, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c,
+	0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x52, 0x20, 0x01, 0x28,
+	0x03, 0x3a, 0x02, 0x38, 0x32, 0x52, 0x0c, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x49, 0x6e,
+	0x74, 0x36, 0x34, 0x3a, 0x50, 0x0a, 0x0e, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x75,
+	0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41,
+	0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x53, 0x20, 0x01,
+	0x28, 0x0d, 0x3a, 0x02, 0x38, 0x33, 0x52, 0x0d, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x55,
+	0x69, 0x6e, 0x74, 0x33, 0x32, 0x3a, 0x50, 0x0a, 0x0e, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74,
+	0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73,
+	0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x54,
+	0x20, 0x01, 0x28, 0x04, 0x3a, 0x02, 0x38, 0x34, 0x52, 0x0d, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c,
+	0x74, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x3a, 0x51, 0x0a, 0x0e, 0x64, 0x65, 0x66, 0x61, 0x75,
+	0x6c, 0x74, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54,
+	0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73,
+	0x18, 0x55, 0x20, 0x01, 0x28, 0x11, 0x3a, 0x03, 0x2d, 0x38, 0x35, 0x52, 0x0d, 0x64, 0x65, 0x66,
+	0x61, 0x75, 0x6c, 0x74, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x3a, 0x50, 0x0a, 0x0e, 0x64, 0x65,
+	0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x25, 0x2e, 0x67,
+	0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73,
+	0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69,
+	0x6f, 0x6e, 0x73, 0x18, 0x56, 0x20, 0x01, 0x28, 0x12, 0x3a, 0x02, 0x38, 0x36, 0x52, 0x0d, 0x64,
+	0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x3a, 0x52, 0x0a, 0x0f,
+	0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12,
+	0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65,
+	0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x57, 0x20, 0x01, 0x28, 0x07, 0x3a, 0x02, 0x38, 0x37,
+	0x52, 0x0e, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32,
+	0x3a, 0x52, 0x0a, 0x0f, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x66, 0x69, 0x78, 0x65,
+	0x64, 0x36, 0x34, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c,
+	0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x58, 0x20, 0x01, 0x28, 0x06,
+	0x3a, 0x02, 0x38, 0x38, 0x52, 0x0e, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x46, 0x69, 0x78,
+	0x65, 0x64, 0x36, 0x34, 0x3a, 0x54, 0x0a, 0x10, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f,
+	0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65,
+	0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18,
+	0x59, 0x20, 0x01, 0x28, 0x0f, 0x3a, 0x02, 0x38, 0x39, 0x52, 0x0f, 0x64, 0x65, 0x66, 0x61, 0x75,
+	0x6c, 0x74, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x3a, 0x55, 0x0a, 0x10, 0x64, 0x65,
+	0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x25,
+	0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74,
+	0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e,
+	0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x50, 0x20, 0x01, 0x28, 0x10, 0x3a, 0x03, 0x2d, 0x39, 0x30,
+	0x52, 0x0f, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36,
+	0x34, 0x3a, 0x50, 0x0a, 0x0d, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x66, 0x6c, 0x6f,
+	0x61, 0x74, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45,
+	0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x5b, 0x20, 0x01, 0x28, 0x02, 0x3a,
+	0x04, 0x39, 0x31, 0x2e, 0x35, 0x52, 0x0c, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x46, 0x6c,
+	0x6f, 0x61, 0x74, 0x3a, 0x53, 0x0a, 0x0e, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x64,
+	0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41,
+	0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x5c, 0x20, 0x01,
+	0x28, 0x01, 0x3a, 0x05, 0x39, 0x32, 0x30, 0x30, 0x30, 0x52, 0x0d, 0x64, 0x65, 0x66, 0x61, 0x75,
+	0x6c, 0x74, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x3a, 0x4e, 0x0a, 0x0c, 0x64, 0x65, 0x66, 0x61,
+	0x75, 0x6c, 0x74, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65,
+	0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18,
+	0x5d, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x04, 0x74, 0x72, 0x75, 0x65, 0x52, 0x0b, 0x64, 0x65, 0x66,
+	0x61, 0x75, 0x6c, 0x74, 0x42, 0x6f, 0x6f, 0x6c, 0x3a, 0x53, 0x0a, 0x0e, 0x64, 0x65, 0x66, 0x61,
+	0x75, 0x6c, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x25, 0x2e, 0x67, 0x6f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e,
+	0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
+	0x73, 0x18, 0x5e, 0x20, 0x01, 0x28, 0x09, 0x3a, 0x05, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x52, 0x0d,
+	0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3a, 0x51, 0x0a,
+	0x0d, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x12, 0x25,
+	0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74,
+	0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e,
+	0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x5f, 0x20, 0x01, 0x28, 0x0c, 0x3a, 0x05, 0x77, 0x6f, 0x72,
+	0x6c, 0x64, 0x52, 0x0c, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x42, 0x79, 0x74, 0x65, 0x73,
+	0x3a, 0x4f, 0x0a, 0x0c, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32,
+	0x12, 0x28, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x64,
+	0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x5a, 0x20, 0x03, 0x28, 0x05,
+	0x42, 0x02, 0x10, 0x01, 0x52, 0x0b, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x49, 0x6e, 0x74, 0x33,
+	0x32, 0x3a, 0x4f, 0x0a, 0x0c, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x74, 0x36,
+	0x34, 0x12, 0x28, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x50, 0x61, 0x63, 0x6b, 0x65,
+	0x64, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x5b, 0x20, 0x03, 0x28,
+	0x03, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0b, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x49, 0x6e, 0x74,
+	0x36, 0x34, 0x3a, 0x51, 0x0a, 0x0d, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x75, 0x69, 0x6e,
+	0x74, 0x33, 0x32, 0x12, 0x28, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x50, 0x61, 0x63,
+	0x6b, 0x65, 0x64, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x5c, 0x20,
+	0x03, 0x28, 0x0d, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0c, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x55,
+	0x69, 0x6e, 0x74, 0x33, 0x32, 0x3a, 0x51, 0x0a, 0x0d, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f,
+	0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x28, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74,
+	0x50, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73,
+	0x18, 0x5d, 0x20, 0x03, 0x28, 0x04, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0c, 0x70, 0x61, 0x63, 0x6b,
+	0x65, 0x64, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x3a, 0x51, 0x0a, 0x0d, 0x70, 0x61, 0x63, 0x6b,
+	0x65, 0x64, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x28, 0x2e, 0x67, 0x6f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54,
+	0x65, 0x73, 0x74, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69,
+	0x6f, 0x6e, 0x73, 0x18, 0x5e, 0x20, 0x03, 0x28, 0x11, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0c, 0x70,
+	0x61, 0x63, 0x6b, 0x65, 0x64, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x3a, 0x51, 0x0a, 0x0d, 0x70,
+	0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x28, 0x2e, 0x67,
+	0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73,
+	0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x45, 0x78, 0x74, 0x65,
+	0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x5f, 0x20, 0x03, 0x28, 0x12, 0x42, 0x02, 0x10, 0x01,
+	0x52, 0x0c, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x3a, 0x53,
+	0x0a, 0x0e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32,
+	0x12, 0x28, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x64,
+	0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x60, 0x20, 0x03, 0x28, 0x07,
+	0x42, 0x02, 0x10, 0x01, 0x52, 0x0d, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x46, 0x69, 0x78, 0x65,
+	0x64, 0x33, 0x32, 0x3a, 0x53, 0x0a, 0x0e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x66, 0x69,
+	0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x28, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x50,
+	0x61, 0x63, 0x6b, 0x65, 0x64, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18,
+	0x61, 0x20, 0x03, 0x28, 0x06, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0d, 0x70, 0x61, 0x63, 0x6b, 0x65,
+	0x64, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x3a, 0x55, 0x0a, 0x0f, 0x70, 0x61, 0x63, 0x6b,
+	0x65, 0x64, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x28, 0x2e, 0x67, 0x6f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74,
+	0x2e, 0x54, 0x65, 0x73, 0x74, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x45, 0x78, 0x74, 0x65, 0x6e,
+	0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x62, 0x20, 0x03, 0x28, 0x0f, 0x42, 0x02, 0x10, 0x01, 0x52,
+	0x0e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x3a,
+	0x55, 0x0a, 0x0f, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64,
+	0x36, 0x34, 0x12, 0x28, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x50, 0x61, 0x63, 0x6b,
+	0x65, 0x64, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x63, 0x20, 0x03,
+	0x28, 0x10, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x53, 0x66,
+	0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x3a, 0x4f, 0x0a, 0x0c, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64,
+	0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x28, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74,
+	0x50, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73,
+	0x18, 0x64, 0x20, 0x03, 0x28, 0x02, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0b, 0x70, 0x61, 0x63, 0x6b,
+	0x65, 0x64, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x3a, 0x51, 0x0a, 0x0d, 0x70, 0x61, 0x63, 0x6b, 0x65,
+	0x64, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x28, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65,
+	0x73, 0x74, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f,
+	0x6e, 0x73, 0x18, 0x65, 0x20, 0x03, 0x28, 0x01, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0c, 0x70, 0x61,
+	0x63, 0x6b, 0x65, 0x64, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x3a, 0x4d, 0x0a, 0x0b, 0x70, 0x61,
+	0x63, 0x6b, 0x65, 0x64, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x12, 0x28, 0x2e, 0x67, 0x6f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54,
+	0x65, 0x73, 0x74, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69,
+	0x6f, 0x6e, 0x73, 0x18, 0x66, 0x20, 0x03, 0x28, 0x08, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0a, 0x70,
+	0x61, 0x63, 0x6b, 0x65, 0x64, 0x42, 0x6f, 0x6f, 0x6c, 0x3a, 0x6e, 0x0a, 0x0b, 0x70, 0x61, 0x63,
+	0x6b, 0x65, 0x64, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x12, 0x28, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65,
+	0x73, 0x74, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f,
+	0x6e, 0x73, 0x18, 0x67, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x1f, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x46, 0x6f,
+	0x72, 0x65, 0x69, 0x67, 0x6e, 0x45, 0x6e, 0x75, 0x6d, 0x42, 0x02, 0x10, 0x01, 0x52, 0x0a, 0x70,
+	0x61, 0x63, 0x6b, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x3a, 0x55, 0x0a, 0x0e, 0x75, 0x6e, 0x70,
+	0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x2a, 0x2e, 0x67, 0x6f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74,
+	0x2e, 0x54, 0x65, 0x73, 0x74, 0x55, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x45, 0x78, 0x74,
+	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x5a, 0x20, 0x03, 0x28, 0x05, 0x42, 0x02, 0x10,
+	0x00, 0x52, 0x0d, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x49, 0x6e, 0x74, 0x33, 0x32,
+	0x3a, 0x55, 0x0a, 0x0e, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x74,
+	0x36, 0x34, 0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x55, 0x6e, 0x70, 0x61,
+	0x63, 0x6b, 0x65, 0x64, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x5b,
+	0x20, 0x03, 0x28, 0x03, 0x42, 0x02, 0x10, 0x00, 0x52, 0x0d, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b,
+	0x65, 0x64, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x3a, 0x57, 0x0a, 0x0f, 0x75, 0x6e, 0x70, 0x61, 0x63,
+	0x6b, 0x65, 0x64, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e,
+	0x54, 0x65, 0x73, 0x74, 0x55, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x45, 0x78, 0x74, 0x65,
+	0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x5c, 0x20, 0x03, 0x28, 0x0d, 0x42, 0x02, 0x10, 0x00,
+	0x52, 0x0e, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32,
+	0x3a, 0x57, 0x0a, 0x0f, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x75, 0x69, 0x6e,
+	0x74, 0x36, 0x34, 0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x55, 0x6e, 0x70,
+	0x61, 0x63, 0x6b, 0x65, 0x64, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18,
+	0x5d, 0x20, 0x03, 0x28, 0x04, 0x42, 0x02, 0x10, 0x00, 0x52, 0x0e, 0x75, 0x6e, 0x70, 0x61, 0x63,
+	0x6b, 0x65, 0x64, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x3a, 0x57, 0x0a, 0x0f, 0x75, 0x6e, 0x70,
+	0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x2a, 0x2e, 0x67,
+	0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73,
+	0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x55, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x45, 0x78,
+	0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x5e, 0x20, 0x03, 0x28, 0x11, 0x42, 0x02,
+	0x10, 0x00, 0x52, 0x0e, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x53, 0x69, 0x6e, 0x74,
+	0x33, 0x32, 0x3a, 0x57, 0x0a, 0x0f, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x73,
+	0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x55,
+	0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
+	0x73, 0x18, 0x5f, 0x20, 0x03, 0x28, 0x12, 0x42, 0x02, 0x10, 0x00, 0x52, 0x0e, 0x75, 0x6e, 0x70,
+	0x61, 0x63, 0x6b, 0x65, 0x64, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x3a, 0x59, 0x0a, 0x10, 0x75,
+	0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12,
+	0x2a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x55, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65,
+	0x64, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x60, 0x20, 0x03, 0x28,
+	0x07, 0x42, 0x02, 0x10, 0x00, 0x52, 0x0f, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x46,
+	0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x3a, 0x59, 0x0a, 0x10, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b,
+	0x65, 0x64, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e,
+	0x54, 0x65, 0x73, 0x74, 0x55, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x45, 0x78, 0x74, 0x65,
+	0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x61, 0x20, 0x03, 0x28, 0x06, 0x42, 0x02, 0x10, 0x00,
+	0x52, 0x0f, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36,
+	0x34, 0x3a, 0x5b, 0x0a, 0x11, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x73, 0x66,
+	0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74,
+	0x55, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f,
+	0x6e, 0x73, 0x18, 0x62, 0x20, 0x03, 0x28, 0x0f, 0x42, 0x02, 0x10, 0x00, 0x52, 0x10, 0x75, 0x6e,
+	0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x3a, 0x5b,
+	0x0a, 0x11, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65,
+	0x64, 0x36, 0x34, 0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x55, 0x6e, 0x70,
+	0x61, 0x63, 0x6b, 0x65, 0x64, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18,
+	0x63, 0x20, 0x03, 0x28, 0x10, 0x42, 0x02, 0x10, 0x00, 0x52, 0x10, 0x75, 0x6e, 0x70, 0x61, 0x63,
+	0x6b, 0x65, 0x64, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x3a, 0x55, 0x0a, 0x0e, 0x75,
+	0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x2a, 0x2e,
+	0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65,
+	0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x55, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x45,
+	0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x64, 0x20, 0x03, 0x28, 0x02, 0x42,
+	0x02, 0x10, 0x00, 0x52, 0x0d, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x46, 0x6c, 0x6f,
+	0x61, 0x74, 0x3a, 0x57, 0x0a, 0x0f, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x64,
+	0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x55,
+	0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
+	0x73, 0x18, 0x65, 0x20, 0x03, 0x28, 0x01, 0x42, 0x02, 0x10, 0x00, 0x52, 0x0e, 0x75, 0x6e, 0x70,
+	0x61, 0x63, 0x6b, 0x65, 0x64, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x3a, 0x53, 0x0a, 0x0d, 0x75,
+	0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x12, 0x2a, 0x2e, 0x67,
+	0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73,
+	0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x55, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x45, 0x78,
+	0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x66, 0x20, 0x03, 0x28, 0x08, 0x42, 0x02,
+	0x10, 0x00, 0x52, 0x0c, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x42, 0x6f, 0x6f, 0x6c,
+	0x3a, 0x74, 0x0a, 0x0d, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x65, 0x6e, 0x75,
+	0x6d, 0x12, 0x2a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x55, 0x6e, 0x70, 0x61, 0x63,
+	0x6b, 0x65, 0x64, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x67, 0x20,
+	0x03, 0x28, 0x0e, 0x32, 0x1f, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e,
+	0x45, 0x6e, 0x75, 0x6d, 0x42, 0x02, 0x10, 0x00, 0x52, 0x0c, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b,
+	0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x42, 0x35, 0x5a, 0x33, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x62, 0x75, 0x66, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65,
+	0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x50, 0x01, 0x58,
+	0x02, 0x58, 0x03,
+}
+
+var (
+	file_internal_testprotos_test_test_proto_rawDescOnce sync.Once
+	file_internal_testprotos_test_test_proto_rawDescData = file_internal_testprotos_test_test_proto_rawDesc
+)
+
+func file_internal_testprotos_test_test_proto_rawDescGZIP() []byte {
+	file_internal_testprotos_test_test_proto_rawDescOnce.Do(func() {
+		file_internal_testprotos_test_test_proto_rawDescData = protoimpl.X.CompressGZIP(file_internal_testprotos_test_test_proto_rawDescData)
+	})
+	return file_internal_testprotos_test_test_proto_rawDescData
+}
+
+var file_internal_testprotos_test_test_proto_enumTypes = make([]protoimpl.EnumInfo, 4)
+var file_internal_testprotos_test_test_proto_msgTypes = make([]protoimpl.MessageInfo, 44)
+var file_internal_testprotos_test_test_proto_goTypes = []interface{}{
+	(ForeignEnum)(0),                          // 0: goproto.proto.test.ForeignEnum
+	(TestReservedEnumFields)(0),               // 1: goproto.proto.test.TestReservedEnumFields
+	(TestAllTypes_NestedEnum)(0),              // 2: goproto.proto.test.TestAllTypes.NestedEnum
+	(TestDeprecatedMessage_DeprecatedEnum)(0), // 3: goproto.proto.test.TestDeprecatedMessage.DeprecatedEnum
+	(*TestAllTypes)(nil),                      // 4: goproto.proto.test.TestAllTypes
+	(*TestDeprecatedMessage)(nil),             // 5: goproto.proto.test.TestDeprecatedMessage
+	(*ForeignMessage)(nil),                    // 6: goproto.proto.test.ForeignMessage
+	(*TestReservedFields)(nil),                // 7: goproto.proto.test.TestReservedFields
+	(*TestAllExtensions)(nil),                 // 8: goproto.proto.test.TestAllExtensions
+	(*OptionalGroup)(nil),                     // 9: goproto.proto.test.OptionalGroup
+	(*RepeatedGroup)(nil),                     // 10: goproto.proto.test.RepeatedGroup
+	(*TestNestedExtension)(nil),               // 11: goproto.proto.test.TestNestedExtension
+	(*TestRequired)(nil),                      // 12: goproto.proto.test.TestRequired
+	(*TestRequiredForeign)(nil),               // 13: goproto.proto.test.TestRequiredForeign
+	(*TestRequiredGroupFields)(nil),           // 14: goproto.proto.test.TestRequiredGroupFields
+	(*TestWeak)(nil),                          // 15: goproto.proto.test.TestWeak
+	(*TestPackedTypes)(nil),                   // 16: goproto.proto.test.TestPackedTypes
+	(*TestUnpackedTypes)(nil),                 // 17: goproto.proto.test.TestUnpackedTypes
+	(*TestPackedExtensions)(nil),              // 18: goproto.proto.test.TestPackedExtensions
+	(*TestUnpackedExtensions)(nil),            // 19: goproto.proto.test.TestUnpackedExtensions
+	(*FooRequest)(nil),                        // 20: goproto.proto.test.FooRequest
+	(*FooResponse)(nil),                       // 21: goproto.proto.test.FooResponse
+	(*WeirdDefault)(nil),                      // 22: goproto.proto.test.WeirdDefault
+	(*TestAllTypes_NestedMessage)(nil),        // 23: goproto.proto.test.TestAllTypes.NestedMessage
+	(*TestAllTypes_OptionalGroup)(nil),        // 24: goproto.proto.test.TestAllTypes.OptionalGroup
+	(*TestAllTypes_RepeatedGroup)(nil),        // 25: goproto.proto.test.TestAllTypes.RepeatedGroup
+	nil,                                       // 26: goproto.proto.test.TestAllTypes.MapInt32Int32Entry
+	nil,                                       // 27: goproto.proto.test.TestAllTypes.MapInt64Int64Entry
+	nil,                                       // 28: goproto.proto.test.TestAllTypes.MapUint32Uint32Entry
+	nil,                                       // 29: goproto.proto.test.TestAllTypes.MapUint64Uint64Entry
+	nil,                                       // 30: goproto.proto.test.TestAllTypes.MapSint32Sint32Entry
+	nil,                                       // 31: goproto.proto.test.TestAllTypes.MapSint64Sint64Entry
+	nil,                                       // 32: goproto.proto.test.TestAllTypes.MapFixed32Fixed32Entry
+	nil,                                       // 33: goproto.proto.test.TestAllTypes.MapFixed64Fixed64Entry
+	nil,                                       // 34: goproto.proto.test.TestAllTypes.MapSfixed32Sfixed32Entry
+	nil,                                       // 35: goproto.proto.test.TestAllTypes.MapSfixed64Sfixed64Entry
+	nil,                                       // 36: goproto.proto.test.TestAllTypes.MapInt32FloatEntry
+	nil,                                       // 37: goproto.proto.test.TestAllTypes.MapInt32DoubleEntry
+	nil,                                       // 38: goproto.proto.test.TestAllTypes.MapBoolBoolEntry
+	nil,                                       // 39: goproto.proto.test.TestAllTypes.MapStringStringEntry
+	nil,                                       // 40: goproto.proto.test.TestAllTypes.MapStringBytesEntry
+	nil,                                       // 41: goproto.proto.test.TestAllTypes.MapStringNestedMessageEntry
+	nil,                                       // 42: goproto.proto.test.TestAllTypes.MapStringNestedEnumEntry
+	(*TestAllTypes_OneofGroup)(nil),           // 43: goproto.proto.test.TestAllTypes.OneofGroup
+	(*TestAllExtensions_NestedMessage)(nil),   // 44: goproto.proto.test.TestAllExtensions.NestedMessage
+	nil,                                       // 45: goproto.proto.test.TestRequiredForeign.MapMessageEntry
+	(*TestRequiredGroupFields_OptionalGroup)(nil), // 46: goproto.proto.test.TestRequiredGroupFields.OptionalGroup
+	(*TestRequiredGroupFields_RepeatedGroup)(nil), // 47: goproto.proto.test.TestRequiredGroupFields.RepeatedGroup
+	(*ImportMessage)(nil),                         // 48: goproto.proto.test.ImportMessage
+	(ImportEnum)(0),                               // 49: goproto.proto.test.ImportEnum
+}
+var file_internal_testprotos_test_test_proto_depIdxs = []int32{
+	24,  // 0: goproto.proto.test.TestAllTypes.optionalgroup:type_name -> goproto.proto.test.TestAllTypes.OptionalGroup
+	23,  // 1: goproto.proto.test.TestAllTypes.optional_nested_message:type_name -> goproto.proto.test.TestAllTypes.NestedMessage
+	6,   // 2: goproto.proto.test.TestAllTypes.optional_foreign_message:type_name -> goproto.proto.test.ForeignMessage
+	48,  // 3: goproto.proto.test.TestAllTypes.optional_import_message:type_name -> goproto.proto.test.ImportMessage
+	2,   // 4: goproto.proto.test.TestAllTypes.optional_nested_enum:type_name -> goproto.proto.test.TestAllTypes.NestedEnum
+	0,   // 5: goproto.proto.test.TestAllTypes.optional_foreign_enum:type_name -> goproto.proto.test.ForeignEnum
+	49,  // 6: goproto.proto.test.TestAllTypes.optional_import_enum:type_name -> goproto.proto.test.ImportEnum
+	25,  // 7: goproto.proto.test.TestAllTypes.repeatedgroup:type_name -> goproto.proto.test.TestAllTypes.RepeatedGroup
+	23,  // 8: goproto.proto.test.TestAllTypes.repeated_nested_message:type_name -> goproto.proto.test.TestAllTypes.NestedMessage
+	6,   // 9: goproto.proto.test.TestAllTypes.repeated_foreign_message:type_name -> goproto.proto.test.ForeignMessage
+	48,  // 10: goproto.proto.test.TestAllTypes.repeated_importmessage:type_name -> goproto.proto.test.ImportMessage
+	2,   // 11: goproto.proto.test.TestAllTypes.repeated_nested_enum:type_name -> goproto.proto.test.TestAllTypes.NestedEnum
+	0,   // 12: goproto.proto.test.TestAllTypes.repeated_foreign_enum:type_name -> goproto.proto.test.ForeignEnum
+	49,  // 13: goproto.proto.test.TestAllTypes.repeated_importenum:type_name -> goproto.proto.test.ImportEnum
+	26,  // 14: goproto.proto.test.TestAllTypes.map_int32_int32:type_name -> goproto.proto.test.TestAllTypes.MapInt32Int32Entry
+	27,  // 15: goproto.proto.test.TestAllTypes.map_int64_int64:type_name -> goproto.proto.test.TestAllTypes.MapInt64Int64Entry
+	28,  // 16: goproto.proto.test.TestAllTypes.map_uint32_uint32:type_name -> goproto.proto.test.TestAllTypes.MapUint32Uint32Entry
+	29,  // 17: goproto.proto.test.TestAllTypes.map_uint64_uint64:type_name -> goproto.proto.test.TestAllTypes.MapUint64Uint64Entry
+	30,  // 18: goproto.proto.test.TestAllTypes.map_sint32_sint32:type_name -> goproto.proto.test.TestAllTypes.MapSint32Sint32Entry
+	31,  // 19: goproto.proto.test.TestAllTypes.map_sint64_sint64:type_name -> goproto.proto.test.TestAllTypes.MapSint64Sint64Entry
+	32,  // 20: goproto.proto.test.TestAllTypes.map_fixed32_fixed32:type_name -> goproto.proto.test.TestAllTypes.MapFixed32Fixed32Entry
+	33,  // 21: goproto.proto.test.TestAllTypes.map_fixed64_fixed64:type_name -> goproto.proto.test.TestAllTypes.MapFixed64Fixed64Entry
+	34,  // 22: goproto.proto.test.TestAllTypes.map_sfixed32_sfixed32:type_name -> goproto.proto.test.TestAllTypes.MapSfixed32Sfixed32Entry
+	35,  // 23: goproto.proto.test.TestAllTypes.map_sfixed64_sfixed64:type_name -> goproto.proto.test.TestAllTypes.MapSfixed64Sfixed64Entry
+	36,  // 24: goproto.proto.test.TestAllTypes.map_int32_float:type_name -> goproto.proto.test.TestAllTypes.MapInt32FloatEntry
+	37,  // 25: goproto.proto.test.TestAllTypes.map_int32_double:type_name -> goproto.proto.test.TestAllTypes.MapInt32DoubleEntry
+	38,  // 26: goproto.proto.test.TestAllTypes.map_bool_bool:type_name -> goproto.proto.test.TestAllTypes.MapBoolBoolEntry
+	39,  // 27: goproto.proto.test.TestAllTypes.map_string_string:type_name -> goproto.proto.test.TestAllTypes.MapStringStringEntry
+	40,  // 28: goproto.proto.test.TestAllTypes.map_string_bytes:type_name -> goproto.proto.test.TestAllTypes.MapStringBytesEntry
+	41,  // 29: goproto.proto.test.TestAllTypes.map_string_nested_message:type_name -> goproto.proto.test.TestAllTypes.MapStringNestedMessageEntry
+	42,  // 30: goproto.proto.test.TestAllTypes.map_string_nested_enum:type_name -> goproto.proto.test.TestAllTypes.MapStringNestedEnumEntry
+	2,   // 31: goproto.proto.test.TestAllTypes.default_nested_enum:type_name -> goproto.proto.test.TestAllTypes.NestedEnum
+	0,   // 32: goproto.proto.test.TestAllTypes.default_foreign_enum:type_name -> goproto.proto.test.ForeignEnum
+	23,  // 33: goproto.proto.test.TestAllTypes.oneof_nested_message:type_name -> goproto.proto.test.TestAllTypes.NestedMessage
+	2,   // 34: goproto.proto.test.TestAllTypes.oneof_enum:type_name -> goproto.proto.test.TestAllTypes.NestedEnum
+	43,  // 35: goproto.proto.test.TestAllTypes.oneofgroup:type_name -> goproto.proto.test.TestAllTypes.OneofGroup
+	44,  // 36: goproto.proto.test.OptionalGroup.optional_nested_message:type_name -> goproto.proto.test.TestAllExtensions.NestedMessage
+	44,  // 37: goproto.proto.test.RepeatedGroup.optional_nested_message:type_name -> goproto.proto.test.TestAllExtensions.NestedMessage
+	12,  // 38: goproto.proto.test.TestRequiredForeign.optional_message:type_name -> goproto.proto.test.TestRequired
+	12,  // 39: goproto.proto.test.TestRequiredForeign.repeated_message:type_name -> goproto.proto.test.TestRequired
+	45,  // 40: goproto.proto.test.TestRequiredForeign.map_message:type_name -> goproto.proto.test.TestRequiredForeign.MapMessageEntry
+	12,  // 41: goproto.proto.test.TestRequiredForeign.oneof_message:type_name -> goproto.proto.test.TestRequired
+	46,  // 42: goproto.proto.test.TestRequiredGroupFields.optionalgroup:type_name -> goproto.proto.test.TestRequiredGroupFields.OptionalGroup
+	47,  // 43: goproto.proto.test.TestRequiredGroupFields.repeatedgroup:type_name -> goproto.proto.test.TestRequiredGroupFields.RepeatedGroup
+	0,   // 44: goproto.proto.test.TestPackedTypes.packed_enum:type_name -> goproto.proto.test.ForeignEnum
+	0,   // 45: goproto.proto.test.TestUnpackedTypes.unpacked_enum:type_name -> goproto.proto.test.ForeignEnum
+	4,   // 46: goproto.proto.test.TestAllTypes.NestedMessage.corecursive:type_name -> goproto.proto.test.TestAllTypes
+	23,  // 47: goproto.proto.test.TestAllTypes.OptionalGroup.optional_nested_message:type_name -> goproto.proto.test.TestAllTypes.NestedMessage
+	23,  // 48: goproto.proto.test.TestAllTypes.RepeatedGroup.optional_nested_message:type_name -> goproto.proto.test.TestAllTypes.NestedMessage
+	23,  // 49: goproto.proto.test.TestAllTypes.MapStringNestedMessageEntry.value:type_name -> goproto.proto.test.TestAllTypes.NestedMessage
+	2,   // 50: goproto.proto.test.TestAllTypes.MapStringNestedEnumEntry.value:type_name -> goproto.proto.test.TestAllTypes.NestedEnum
+	8,   // 51: goproto.proto.test.TestAllExtensions.NestedMessage.corecursive:type_name -> goproto.proto.test.TestAllExtensions
+	12,  // 52: goproto.proto.test.TestRequiredForeign.MapMessageEntry.value:type_name -> goproto.proto.test.TestRequired
+	8,   // 53: goproto.proto.test.optional_int32:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 54: goproto.proto.test.optional_int64:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 55: goproto.proto.test.optional_uint32:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 56: goproto.proto.test.optional_uint64:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 57: goproto.proto.test.optional_sint32:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 58: goproto.proto.test.optional_sint64:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 59: goproto.proto.test.optional_fixed32:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 60: goproto.proto.test.optional_fixed64:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 61: goproto.proto.test.optional_sfixed32:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 62: goproto.proto.test.optional_sfixed64:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 63: goproto.proto.test.optional_float:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 64: goproto.proto.test.optional_double:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 65: goproto.proto.test.optional_bool:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 66: goproto.proto.test.optional_string:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 67: goproto.proto.test.optional_bytes:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 68: goproto.proto.test.optionalgroup:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 69: goproto.proto.test.optional_nested_message:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 70: goproto.proto.test.optional_nested_enum:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 71: goproto.proto.test.repeated_int32:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 72: goproto.proto.test.repeated_int64:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 73: goproto.proto.test.repeated_uint32:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 74: goproto.proto.test.repeated_uint64:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 75: goproto.proto.test.repeated_sint32:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 76: goproto.proto.test.repeated_sint64:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 77: goproto.proto.test.repeated_fixed32:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 78: goproto.proto.test.repeated_fixed64:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 79: goproto.proto.test.repeated_sfixed32:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 80: goproto.proto.test.repeated_sfixed64:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 81: goproto.proto.test.repeated_float:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 82: goproto.proto.test.repeated_double:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 83: goproto.proto.test.repeated_bool:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 84: goproto.proto.test.repeated_string:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 85: goproto.proto.test.repeated_bytes:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 86: goproto.proto.test.repeatedgroup:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 87: goproto.proto.test.repeated_nested_message:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 88: goproto.proto.test.repeated_nested_enum:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 89: goproto.proto.test.default_int32:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 90: goproto.proto.test.default_int64:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 91: goproto.proto.test.default_uint32:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 92: goproto.proto.test.default_uint64:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 93: goproto.proto.test.default_sint32:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 94: goproto.proto.test.default_sint64:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 95: goproto.proto.test.default_fixed32:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 96: goproto.proto.test.default_fixed64:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 97: goproto.proto.test.default_sfixed32:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 98: goproto.proto.test.default_sfixed64:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 99: goproto.proto.test.default_float:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 100: goproto.proto.test.default_double:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 101: goproto.proto.test.default_bool:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 102: goproto.proto.test.default_string:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 103: goproto.proto.test.default_bytes:extendee -> goproto.proto.test.TestAllExtensions
+	18,  // 104: goproto.proto.test.packed_int32:extendee -> goproto.proto.test.TestPackedExtensions
+	18,  // 105: goproto.proto.test.packed_int64:extendee -> goproto.proto.test.TestPackedExtensions
+	18,  // 106: goproto.proto.test.packed_uint32:extendee -> goproto.proto.test.TestPackedExtensions
+	18,  // 107: goproto.proto.test.packed_uint64:extendee -> goproto.proto.test.TestPackedExtensions
+	18,  // 108: goproto.proto.test.packed_sint32:extendee -> goproto.proto.test.TestPackedExtensions
+	18,  // 109: goproto.proto.test.packed_sint64:extendee -> goproto.proto.test.TestPackedExtensions
+	18,  // 110: goproto.proto.test.packed_fixed32:extendee -> goproto.proto.test.TestPackedExtensions
+	18,  // 111: goproto.proto.test.packed_fixed64:extendee -> goproto.proto.test.TestPackedExtensions
+	18,  // 112: goproto.proto.test.packed_sfixed32:extendee -> goproto.proto.test.TestPackedExtensions
+	18,  // 113: goproto.proto.test.packed_sfixed64:extendee -> goproto.proto.test.TestPackedExtensions
+	18,  // 114: goproto.proto.test.packed_float:extendee -> goproto.proto.test.TestPackedExtensions
+	18,  // 115: goproto.proto.test.packed_double:extendee -> goproto.proto.test.TestPackedExtensions
+	18,  // 116: goproto.proto.test.packed_bool:extendee -> goproto.proto.test.TestPackedExtensions
+	18,  // 117: goproto.proto.test.packed_enum:extendee -> goproto.proto.test.TestPackedExtensions
+	19,  // 118: goproto.proto.test.unpacked_int32:extendee -> goproto.proto.test.TestUnpackedExtensions
+	19,  // 119: goproto.proto.test.unpacked_int64:extendee -> goproto.proto.test.TestUnpackedExtensions
+	19,  // 120: goproto.proto.test.unpacked_uint32:extendee -> goproto.proto.test.TestUnpackedExtensions
+	19,  // 121: goproto.proto.test.unpacked_uint64:extendee -> goproto.proto.test.TestUnpackedExtensions
+	19,  // 122: goproto.proto.test.unpacked_sint32:extendee -> goproto.proto.test.TestUnpackedExtensions
+	19,  // 123: goproto.proto.test.unpacked_sint64:extendee -> goproto.proto.test.TestUnpackedExtensions
+	19,  // 124: goproto.proto.test.unpacked_fixed32:extendee -> goproto.proto.test.TestUnpackedExtensions
+	19,  // 125: goproto.proto.test.unpacked_fixed64:extendee -> goproto.proto.test.TestUnpackedExtensions
+	19,  // 126: goproto.proto.test.unpacked_sfixed32:extendee -> goproto.proto.test.TestUnpackedExtensions
+	19,  // 127: goproto.proto.test.unpacked_sfixed64:extendee -> goproto.proto.test.TestUnpackedExtensions
+	19,  // 128: goproto.proto.test.unpacked_float:extendee -> goproto.proto.test.TestUnpackedExtensions
+	19,  // 129: goproto.proto.test.unpacked_double:extendee -> goproto.proto.test.TestUnpackedExtensions
+	19,  // 130: goproto.proto.test.unpacked_bool:extendee -> goproto.proto.test.TestUnpackedExtensions
+	19,  // 131: goproto.proto.test.unpacked_enum:extendee -> goproto.proto.test.TestUnpackedExtensions
+	8,   // 132: goproto.proto.test.TestNestedExtension.nested_string_extension:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 133: goproto.proto.test.TestRequired.single:extendee -> goproto.proto.test.TestAllExtensions
+	8,   // 134: goproto.proto.test.TestRequired.multi:extendee -> goproto.proto.test.TestAllExtensions
+	9,   // 135: goproto.proto.test.optionalgroup:type_name -> goproto.proto.test.OptionalGroup
+	44,  // 136: goproto.proto.test.optional_nested_message:type_name -> goproto.proto.test.TestAllExtensions.NestedMessage
+	2,   // 137: goproto.proto.test.optional_nested_enum:type_name -> goproto.proto.test.TestAllTypes.NestedEnum
+	10,  // 138: goproto.proto.test.repeatedgroup:type_name -> goproto.proto.test.RepeatedGroup
+	44,  // 139: goproto.proto.test.repeated_nested_message:type_name -> goproto.proto.test.TestAllExtensions.NestedMessage
+	2,   // 140: goproto.proto.test.repeated_nested_enum:type_name -> goproto.proto.test.TestAllTypes.NestedEnum
+	0,   // 141: goproto.proto.test.packed_enum:type_name -> goproto.proto.test.ForeignEnum
+	0,   // 142: goproto.proto.test.unpacked_enum:type_name -> goproto.proto.test.ForeignEnum
+	12,  // 143: goproto.proto.test.TestRequired.single:type_name -> goproto.proto.test.TestRequired
+	12,  // 144: goproto.proto.test.TestRequired.multi:type_name -> goproto.proto.test.TestRequired
+	20,  // 145: goproto.proto.test.TestService.Foo:input_type -> goproto.proto.test.FooRequest
+	20,  // 146: goproto.proto.test.TestService.TestStream:input_type -> goproto.proto.test.FooRequest
+	5,   // 147: goproto.proto.test.TestDeprecatedService.Deprecated:input_type -> goproto.proto.test.TestDeprecatedMessage
+	21,  // 148: goproto.proto.test.TestService.Foo:output_type -> goproto.proto.test.FooResponse
+	21,  // 149: goproto.proto.test.TestService.TestStream:output_type -> goproto.proto.test.FooResponse
+	5,   // 150: goproto.proto.test.TestDeprecatedService.Deprecated:output_type -> goproto.proto.test.TestDeprecatedMessage
+	148, // [148:151] is the sub-list for method output_type
+	145, // [145:148] is the sub-list for method input_type
+	135, // [135:145] is the sub-list for extension type_name
+	53,  // [53:135] is the sub-list for extension extendee
+	0,   // [0:53] is the sub-list for field type_name
+}
+
+func init() { file_internal_testprotos_test_test_proto_init() }
+func file_internal_testprotos_test_test_proto_init() {
+	if File_internal_testprotos_test_test_proto != nil {
+		return
+	}
+	file_internal_testprotos_test_test_import_proto_init()
+	file_internal_testprotos_test_test_public_proto_init()
+	if !protoimpl.UnsafeEnabled {
+		file_internal_testprotos_test_test_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*TestAllTypes); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_test_test_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*TestDeprecatedMessage); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_test_test_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ForeignMessage); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_test_test_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*TestReservedFields); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_test_test_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*TestAllExtensions); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_test_test_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*OptionalGroup); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_test_test_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*RepeatedGroup); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_test_test_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*TestNestedExtension); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_test_test_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*TestRequired); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_test_test_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*TestRequiredForeign); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_test_test_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*TestRequiredGroupFields); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_test_test_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*TestWeak); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.weakFields
+			case 3:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_test_test_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*TestPackedTypes); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_test_test_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*TestUnpackedTypes); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_test_test_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*TestPackedExtensions); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_test_test_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*TestUnpackedExtensions); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_test_test_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*FooRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_test_test_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*FooResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_test_test_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*WeirdDefault); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_test_test_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*TestAllTypes_NestedMessage); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_test_test_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*TestAllTypes_OptionalGroup); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_test_test_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*TestAllTypes_RepeatedGroup); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_test_test_proto_msgTypes[39].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*TestAllTypes_OneofGroup); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_test_test_proto_msgTypes[40].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*TestAllExtensions_NestedMessage); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_test_test_proto_msgTypes[42].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*TestRequiredGroupFields_OptionalGroup); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_test_test_proto_msgTypes[43].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*TestRequiredGroupFields_RepeatedGroup); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	file_internal_testprotos_test_test_proto_msgTypes[0].OneofWrappers = []interface{}{
+		(*TestAllTypes_OneofUint32)(nil),
+		(*TestAllTypes_OneofNestedMessage)(nil),
+		(*TestAllTypes_OneofString)(nil),
+		(*TestAllTypes_OneofBytes)(nil),
+		(*TestAllTypes_OneofBool)(nil),
+		(*TestAllTypes_OneofUint64)(nil),
+		(*TestAllTypes_OneofFloat)(nil),
+		(*TestAllTypes_OneofDouble)(nil),
+		(*TestAllTypes_OneofEnum)(nil),
+		(*TestAllTypes_Oneofgroup)(nil),
+		(*TestAllTypes_OneofOptionalUint32)(nil),
+	}
+	file_internal_testprotos_test_test_proto_msgTypes[1].OneofWrappers = []interface{}{
+		(*TestDeprecatedMessage_DeprecatedOneofField)(nil),
+	}
+	file_internal_testprotos_test_test_proto_msgTypes[9].OneofWrappers = []interface{}{
+		(*TestRequiredForeign_OneofMessage)(nil),
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_internal_testprotos_test_test_proto_rawDesc,
+			NumEnums:      4,
+			NumMessages:   44,
+			NumExtensions: 82,
+			NumServices:   2,
+		},
+		GoTypes:           file_internal_testprotos_test_test_proto_goTypes,
+		DependencyIndexes: file_internal_testprotos_test_test_proto_depIdxs,
+		EnumInfos:         file_internal_testprotos_test_test_proto_enumTypes,
+		MessageInfos:      file_internal_testprotos_test_test_proto_msgTypes,
+		ExtensionInfos:    file_internal_testprotos_test_test_proto_extTypes,
+	}.Build()
+	File_internal_testprotos_test_test_proto = out.File
+	file_internal_testprotos_test_test_proto_rawDesc = nil
+	file_internal_testprotos_test_test_proto_goTypes = nil
+	file_internal_testprotos_test_test_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/test/test.proto b/vendor/google.golang.org/protobuf/internal/testprotos/test/test.proto
new file mode 100644
index 000000000..8a992fe2d
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/test/test.proto
@@ -0,0 +1,383 @@
+// 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.
+
+syntax = "proto2";
+
+package goproto.proto.test;
+
+import "internal/testprotos/test/test_import.proto";
+import public "internal/testprotos/test/test_public.proto";
+import weak "internal/testprotos/test/weak1/test_weak.proto";
+import weak "internal/testprotos/test/weak2/test_weak.proto";
+
+option go_package = "google.golang.org/protobuf/internal/testprotos/test";
+
+message TestAllTypes {
+  message NestedMessage {
+    optional int32 a = 1;
+    optional TestAllTypes corecursive = 2;
+  }
+
+  enum NestedEnum {
+    FOO = 0;
+    BAR = 1;
+    BAZ = 2;
+    NEG = -1;  // Intentionally negative.
+  }
+
+  optional int32         optional_int32    =  1;
+  optional int64         optional_int64    =  2;
+  optional uint32        optional_uint32   =  3;
+  optional uint64        optional_uint64   =  4;
+  optional sint32        optional_sint32   =  5;
+  optional sint64        optional_sint64   =  6;
+  optional fixed32       optional_fixed32  =  7;
+  optional fixed64       optional_fixed64  =  8;
+  optional sfixed32      optional_sfixed32 =  9;
+  optional sfixed64      optional_sfixed64 = 10;
+  optional float         optional_float    = 11;
+  optional double        optional_double   = 12;
+  optional bool          optional_bool     = 13;
+  optional string        optional_string   = 14;
+  optional bytes         optional_bytes    = 15;
+  optional group OptionalGroup = 16 {
+    optional int32 a = 17;
+    optional NestedMessage optional_nested_message = 1000;
+    optional int32 same_field_number = 16;
+  }
+  optional NestedMessage  optional_nested_message  = 18;
+  optional ForeignMessage optional_foreign_message = 19;
+  optional ImportMessage  optional_import_message  = 20;
+  optional NestedEnum     optional_nested_enum     = 21;
+  optional ForeignEnum    optional_foreign_enum    = 22;
+  optional ImportEnum     optional_import_enum     = 23;
+
+  repeated int32         repeated_int32    = 31;
+  repeated int64         repeated_int64    = 32;
+  repeated uint32        repeated_uint32   = 33;
+  repeated uint64        repeated_uint64   = 34;
+  repeated sint32        repeated_sint32   = 35;
+  repeated sint64        repeated_sint64   = 36;
+  repeated fixed32       repeated_fixed32  = 37;
+  repeated fixed64       repeated_fixed64  = 38;
+  repeated sfixed32      repeated_sfixed32 = 39;
+  repeated sfixed64      repeated_sfixed64 = 40;
+  repeated float         repeated_float    = 41;
+  repeated double        repeated_double   = 42;
+  repeated bool          repeated_bool     = 43;
+  repeated string        repeated_string   = 44;
+  repeated bytes         repeated_bytes    = 45;
+  repeated group RepeatedGroup = 46 {
+    optional int32 a = 47;
+    optional NestedMessage optional_nested_message = 1001;
+  }
+  repeated NestedMessage  repeated_nested_message  = 48;
+  repeated ForeignMessage repeated_foreign_message = 49;
+  repeated ImportMessage  repeated_importmessage   = 50;
+  repeated NestedEnum     repeated_nested_enum     = 51;
+  repeated ForeignEnum    repeated_foreign_enum    = 52;
+  repeated ImportEnum     repeated_importenum      = 53;
+
+  map <   int32, int32>         map_int32_int32           = 56;
+  map <   int64, int64>         map_int64_int64           = 57;
+  map <  uint32, uint32>        map_uint32_uint32         = 58;
+  map <  uint64, uint64>        map_uint64_uint64         = 59;
+  map <  sint32, sint32>        map_sint32_sint32         = 60;
+  map <  sint64, sint64>        map_sint64_sint64         = 61;
+  map < fixed32, fixed32>       map_fixed32_fixed32       = 62;
+  map < fixed64, fixed64>       map_fixed64_fixed64       = 63;
+  map <sfixed32, sfixed32>      map_sfixed32_sfixed32     = 64;
+  map <sfixed64, sfixed64>      map_sfixed64_sfixed64     = 65;
+  map <   int32, float>         map_int32_float           = 66;
+  map <   int32, double>        map_int32_double          = 67;
+  map <    bool, bool>          map_bool_bool             = 68;
+  map <  string, string>        map_string_string         = 69;
+  map <  string, bytes>         map_string_bytes          = 70;
+  map <  string, NestedMessage> map_string_nested_message = 71;
+  map <  string, NestedEnum>    map_string_nested_enum    = 73;
+
+  // Singular with defaults
+  optional    int32 default_int32    = 81 [default =  81    ];
+  optional    int64 default_int64    = 82 [default =  82    ];
+  optional   uint32 default_uint32   = 83 [default =  83    ];
+  optional   uint64 default_uint64   = 84 [default =  84    ];
+  optional   sint32 default_sint32   = 85 [default = -85    ];
+  optional   sint64 default_sint64   = 86 [default =  86    ];
+  optional  fixed32 default_fixed32  = 87 [default =  87    ];
+  optional  fixed64 default_fixed64  = 88 [default =  88    ];
+  optional sfixed32 default_sfixed32 = 89 [default =  89    ];
+  optional sfixed64 default_sfixed64 = 80 [default = -90    ];
+  optional    float default_float    = 91 [default =  91.5  ];
+  optional   double default_double   = 92 [default =  92e3  ];
+  optional     bool default_bool     = 93 [default = true   ];
+  optional   string default_string   = 94 [default = "hello"];
+  optional    bytes default_bytes    = 95 [default = "world"];
+  optional NestedEnum  default_nested_enum  = 96 [default = BAR        ];
+  optional ForeignEnum default_foreign_enum = 97 [default = FOREIGN_BAR];
+
+  oneof oneof_field {
+    uint32        oneof_uint32         = 111;
+    NestedMessage oneof_nested_message = 112;
+    string        oneof_string         = 113;
+    bytes         oneof_bytes          = 114;
+    bool          oneof_bool           = 115;
+    uint64        oneof_uint64         = 116;
+    float         oneof_float          = 117;
+    double        oneof_double         = 118;
+    NestedEnum    oneof_enum           = 119;
+    group OneofGroup = 121 {
+      optional int32 a = 1;
+      optional int32 b = 2;
+    }
+  }
+
+  // A oneof with exactly one field.
+  oneof oneof_optional {
+    uint32 oneof_optional_uint32 = 120;
+  }
+}
+
+message TestDeprecatedMessage {
+  option deprecated = true;
+  optional int32 deprecated_int32 = 1 [deprecated=true];
+  enum DeprecatedEnum {
+    option deprecated = true;
+    DEPRECATED = 0 [deprecated=true];
+  }
+  oneof deprecated_oneof {
+    int32 deprecated_oneof_field = 2 [deprecated = true];
+  }
+}
+
+message ForeignMessage {
+  optional int32 c = 1;
+  optional int32 d = 2;
+}
+
+enum ForeignEnum {
+  FOREIGN_FOO = 4;
+  FOREIGN_BAR = 5;
+  FOREIGN_BAZ = 6;
+}
+
+message TestReservedFields {
+  reserved 2, 15, 9 to 11;
+  reserved "bar", "baz";
+}
+
+enum TestReservedEnumFields {
+  RESERVED_ENUM = 0;
+  reserved 2, 15, 9 to 11;
+  reserved "BAR", "BAZ";
+}
+
+message TestAllExtensions {
+  message NestedMessage {
+    optional int32 a = 1;
+    optional TestAllExtensions corecursive = 2;
+  }
+
+  extensions 1 to max;
+}
+
+extend TestAllExtensions {
+  optional int32    optional_int32    =  1;
+  optional int64    optional_int64    =  2;
+  optional uint32   optional_uint32   =  3;
+  optional uint64   optional_uint64   =  4;
+  optional sint32   optional_sint32   =  5;
+  optional sint64   optional_sint64   =  6;
+  optional fixed32  optional_fixed32  =  7;
+  optional fixed64  optional_fixed64  =  8;
+  optional sfixed32 optional_sfixed32 =  9;
+  optional sfixed64 optional_sfixed64 = 10;
+  optional float    optional_float    = 11;
+  optional double   optional_double   = 12;
+  optional bool     optional_bool     = 13;
+  optional string   optional_string   = 14;
+  optional bytes    optional_bytes    = 15;
+
+  optional group OptionalGroup = 16 {
+    optional int32 a = 17;
+    optional int32 same_field_number = 16;
+    optional TestAllExtensions.NestedMessage optional_nested_message = 1000;
+  }
+
+  optional TestAllExtensions.NestedMessage optional_nested_message = 18;
+  optional TestAllTypes.NestedEnum optional_nested_enum = 21;
+
+  repeated int32    repeated_int32    = 31;
+  repeated int64    repeated_int64    = 32;
+  repeated uint32   repeated_uint32   = 33;
+  repeated uint64   repeated_uint64   = 34;
+  repeated sint32   repeated_sint32   = 35;
+  repeated sint64   repeated_sint64   = 36;
+  repeated fixed32  repeated_fixed32  = 37;
+  repeated fixed64  repeated_fixed64  = 38;
+  repeated sfixed32 repeated_sfixed32 = 39;
+  repeated sfixed64 repeated_sfixed64 = 40;
+  repeated float    repeated_float    = 41;
+  repeated double   repeated_double   = 42;
+  repeated bool     repeated_bool     = 43;
+  repeated string   repeated_string   = 44;
+  repeated bytes    repeated_bytes    = 45;
+
+  repeated group RepeatedGroup = 46 {
+    optional int32 a = 47;
+    optional TestAllExtensions.NestedMessage optional_nested_message = 1001;
+  }
+
+  repeated TestAllExtensions.NestedMessage repeated_nested_message = 48;
+  repeated TestAllTypes.NestedEnum repeated_nested_enum = 51;
+
+  optional int32    default_int32    = 81 [default =  81    ];
+  optional int64    default_int64    = 82 [default =  82    ];
+  optional uint32   default_uint32   = 83 [default =  83    ];
+  optional uint64   default_uint64   = 84 [default =  84    ];
+  optional sint32   default_sint32   = 85 [default = -85    ];
+  optional sint64   default_sint64   = 86 [default =  86    ];
+  optional fixed32  default_fixed32  = 87 [default =  87    ];
+  optional fixed64  default_fixed64  = 88 [default =  88    ];
+  optional sfixed32 default_sfixed32 = 89 [default =  89    ];
+  optional sfixed64 default_sfixed64 = 80 [default = -90    ];
+  optional float    default_float    = 91 [default =  91.5  ];
+  optional double   default_double   = 92 [default =  92e3  ];
+  optional bool     default_bool     = 93 [default = true   ];
+  optional string   default_string   = 94 [default = "hello"];
+  optional bytes    default_bytes    = 95 [default = "world"];
+}
+
+message TestNestedExtension {
+  extend TestAllExtensions {
+    optional string nested_string_extension = 1003;
+  }
+}
+
+message TestRequired {
+  required int32 required_field = 1;
+
+  extend TestAllExtensions {
+    optional TestRequired single = 1000;
+    repeated TestRequired multi  = 1001;
+  }
+}
+
+message TestRequiredForeign {
+  optional TestRequired    optional_message = 1;
+  repeated TestRequired    repeated_message = 2;
+  map<int32, TestRequired> map_message = 3;
+  oneof oneof_field {
+    TestRequired oneof_message = 4;
+  }
+}
+
+message TestRequiredGroupFields {
+  optional group OptionalGroup = 1 {
+    required int32 a = 2;
+  }
+  repeated group RepeatedGroup = 3 {
+    required int32 a = 4;
+  }
+}
+
+message TestWeak {
+  optional goproto.proto.test.weak.WeakImportMessage1 weak_message1 = 1 [weak=true];
+  optional goproto.proto.test.weak.WeakImportMessage2 weak_message2 = 2 [weak=true];
+}
+
+message TestPackedTypes {
+  repeated    int32 packed_int32    =  90 [packed = true];
+  repeated    int64 packed_int64    =  91 [packed = true];
+  repeated   uint32 packed_uint32   =  92 [packed = true];
+  repeated   uint64 packed_uint64   =  93 [packed = true];
+  repeated   sint32 packed_sint32   =  94 [packed = true];
+  repeated   sint64 packed_sint64   =  95 [packed = true];
+  repeated  fixed32 packed_fixed32  =  96 [packed = true];
+  repeated  fixed64 packed_fixed64  =  97 [packed = true];
+  repeated sfixed32 packed_sfixed32 =  98 [packed = true];
+  repeated sfixed64 packed_sfixed64 =  99 [packed = true];
+  repeated    float packed_float    = 100 [packed = true];
+  repeated   double packed_double   = 101 [packed = true];
+  repeated     bool packed_bool     = 102 [packed = true];
+  repeated ForeignEnum packed_enum  = 103 [packed = true];
+}
+
+message TestUnpackedTypes {
+  repeated    int32 unpacked_int32    =  90 [packed = false];
+  repeated    int64 unpacked_int64    =  91 [packed = false];
+  repeated   uint32 unpacked_uint32   =  92 [packed = false];
+  repeated   uint64 unpacked_uint64   =  93 [packed = false];
+  repeated   sint32 unpacked_sint32   =  94 [packed = false];
+  repeated   sint64 unpacked_sint64   =  95 [packed = false];
+  repeated  fixed32 unpacked_fixed32  =  96 [packed = false];
+  repeated  fixed64 unpacked_fixed64  =  97 [packed = false];
+  repeated sfixed32 unpacked_sfixed32 =  98 [packed = false];
+  repeated sfixed64 unpacked_sfixed64 =  99 [packed = false];
+  repeated    float unpacked_float    = 100 [packed = false];
+  repeated   double unpacked_double   = 101 [packed = false];
+  repeated     bool unpacked_bool     = 102 [packed = false];
+  repeated ForeignEnum unpacked_enum  = 103 [packed = false];
+}
+
+message TestPackedExtensions {
+  extensions 1 to max;
+}
+
+extend TestPackedExtensions {
+  repeated    int32 packed_int32    =  90 [packed = true];
+  repeated    int64 packed_int64    =  91 [packed = true];
+  repeated   uint32 packed_uint32   =  92 [packed = true];
+  repeated   uint64 packed_uint64   =  93 [packed = true];
+  repeated   sint32 packed_sint32   =  94 [packed = true];
+  repeated   sint64 packed_sint64   =  95 [packed = true];
+  repeated  fixed32 packed_fixed32  =  96 [packed = true];
+  repeated  fixed64 packed_fixed64  =  97 [packed = true];
+  repeated sfixed32 packed_sfixed32 =  98 [packed = true];
+  repeated sfixed64 packed_sfixed64 =  99 [packed = true];
+  repeated    float packed_float    = 100 [packed = true];
+  repeated   double packed_double   = 101 [packed = true];
+  repeated     bool packed_bool     = 102 [packed = true];
+  repeated ForeignEnum packed_enum  = 103 [packed = true];
+}
+
+message TestUnpackedExtensions {
+  extensions 1 to max;
+}
+
+extend TestUnpackedExtensions {
+  repeated    int32 unpacked_int32    =  90 [packed = false];
+  repeated    int64 unpacked_int64    =  91 [packed = false];
+  repeated   uint32 unpacked_uint32   =  92 [packed = false];
+  repeated   uint64 unpacked_uint64   =  93 [packed = false];
+  repeated   sint32 unpacked_sint32   =  94 [packed = false];
+  repeated   sint64 unpacked_sint64   =  95 [packed = false];
+  repeated  fixed32 unpacked_fixed32  =  96 [packed = false];
+  repeated  fixed64 unpacked_fixed64  =  97 [packed = false];
+  repeated sfixed32 unpacked_sfixed32 =  98 [packed = false];
+  repeated sfixed64 unpacked_sfixed64 =  99 [packed = false];
+  repeated    float unpacked_float    = 100 [packed = false];
+  repeated   double unpacked_double   = 101 [packed = false];
+  repeated     bool unpacked_bool     = 102 [packed = false];
+  repeated ForeignEnum unpacked_enum  = 103 [packed = false];
+}
+
+// Test that RPC services work.
+message FooRequest  {}
+message FooResponse {}
+
+service TestService {
+  rpc Foo(FooRequest) returns (FooResponse);
+  rpc TestStream(stream FooRequest) returns (stream FooResponse);
+}
+
+service TestDeprecatedService {
+  option deprecated = true;
+  rpc Deprecated(TestDeprecatedMessage) returns (TestDeprecatedMessage) {
+    option deprecated = true;
+  }
+}
+
+message WeirdDefault {
+  optional bytes weird_default = 1 [default = "hello, \"world!\"\ndead\xde\xad\xbe\xefbeef`"];
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/test/test_import.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/test/test_import.pb.go
new file mode 100644
index 000000000..6be93bdf9
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/test/test_import.pb.go
@@ -0,0 +1,188 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: internal/testprotos/test/test_import.proto
+
+package test
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type ImportEnum int32
+
+const (
+	ImportEnum_IMPORT_ZERO ImportEnum = 0
+)
+
+// Enum value maps for ImportEnum.
+var (
+	ImportEnum_name = map[int32]string{
+		0: "IMPORT_ZERO",
+	}
+	ImportEnum_value = map[string]int32{
+		"IMPORT_ZERO": 0,
+	}
+)
+
+func (x ImportEnum) Enum() *ImportEnum {
+	p := new(ImportEnum)
+	*p = x
+	return p
+}
+
+func (x ImportEnum) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (ImportEnum) Descriptor() protoreflect.EnumDescriptor {
+	return file_internal_testprotos_test_test_import_proto_enumTypes[0].Descriptor()
+}
+
+func (ImportEnum) Type() protoreflect.EnumType {
+	return &file_internal_testprotos_test_test_import_proto_enumTypes[0]
+}
+
+func (x ImportEnum) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *ImportEnum) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = ImportEnum(num)
+	return nil
+}
+
+// Deprecated: Use ImportEnum.Descriptor instead.
+func (ImportEnum) EnumDescriptor() ([]byte, []int) {
+	return file_internal_testprotos_test_test_import_proto_rawDescGZIP(), []int{0}
+}
+
+type ImportMessage struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *ImportMessage) Reset() {
+	*x = ImportMessage{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_test_test_import_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *ImportMessage) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ImportMessage) ProtoMessage() {}
+
+func (x *ImportMessage) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_test_test_import_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ImportMessage.ProtoReflect.Descriptor instead.
+func (*ImportMessage) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_test_test_import_proto_rawDescGZIP(), []int{0}
+}
+
+var File_internal_testprotos_test_test_import_proto protoreflect.FileDescriptor
+
+var file_internal_testprotos_test_test_import_proto_rawDesc = []byte{
+	0x0a, 0x2a, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x5f,
+	0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x67, 0x6f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74,
+	0x22, 0x0f, 0x0a, 0x0d, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x2a, 0x1d, 0x0a, 0x0a, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x45, 0x6e, 0x75, 0x6d, 0x12,
+	0x0f, 0x0a, 0x0b, 0x49, 0x4d, 0x50, 0x4f, 0x52, 0x54, 0x5f, 0x5a, 0x45, 0x52, 0x4f, 0x10, 0x00,
+	0x42, 0x35, 0x5a, 0x33, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e,
+	0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x69,
+	0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74,
+}
+
+var (
+	file_internal_testprotos_test_test_import_proto_rawDescOnce sync.Once
+	file_internal_testprotos_test_test_import_proto_rawDescData = file_internal_testprotos_test_test_import_proto_rawDesc
+)
+
+func file_internal_testprotos_test_test_import_proto_rawDescGZIP() []byte {
+	file_internal_testprotos_test_test_import_proto_rawDescOnce.Do(func() {
+		file_internal_testprotos_test_test_import_proto_rawDescData = protoimpl.X.CompressGZIP(file_internal_testprotos_test_test_import_proto_rawDescData)
+	})
+	return file_internal_testprotos_test_test_import_proto_rawDescData
+}
+
+var file_internal_testprotos_test_test_import_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
+var file_internal_testprotos_test_test_import_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_internal_testprotos_test_test_import_proto_goTypes = []interface{}{
+	(ImportEnum)(0),       // 0: goproto.proto.test.ImportEnum
+	(*ImportMessage)(nil), // 1: goproto.proto.test.ImportMessage
+}
+var file_internal_testprotos_test_test_import_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_internal_testprotos_test_test_import_proto_init() }
+func file_internal_testprotos_test_test_import_proto_init() {
+	if File_internal_testprotos_test_test_import_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_internal_testprotos_test_test_import_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ImportMessage); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_internal_testprotos_test_test_import_proto_rawDesc,
+			NumEnums:      1,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_internal_testprotos_test_test_import_proto_goTypes,
+		DependencyIndexes: file_internal_testprotos_test_test_import_proto_depIdxs,
+		EnumInfos:         file_internal_testprotos_test_test_import_proto_enumTypes,
+		MessageInfos:      file_internal_testprotos_test_test_import_proto_msgTypes,
+	}.Build()
+	File_internal_testprotos_test_test_import_proto = out.File
+	file_internal_testprotos_test_test_import_proto_rawDesc = nil
+	file_internal_testprotos_test_test_import_proto_goTypes = nil
+	file_internal_testprotos_test_test_import_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/test/test_import.proto b/vendor/google.golang.org/protobuf/internal/testprotos/test/test_import.proto
new file mode 100644
index 000000000..fa80cfab5
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/test/test_import.proto
@@ -0,0 +1,16 @@
+// 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.
+
+syntax = "proto2";
+
+package goproto.proto.test;
+
+option go_package = "google.golang.org/protobuf/internal/testprotos/test";
+
+message ImportMessage {
+}
+
+enum ImportEnum {
+ IMPORT_ZERO = 0;
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/test/test_public.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/test/test_public.pb.go
new file mode 100644
index 000000000..19797ea1a
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/test/test_public.pb.go
@@ -0,0 +1,130 @@
+// Copyright 2019 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: internal/testprotos/test/test_public.proto
+
+package test
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type PublicImportMessage struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *PublicImportMessage) Reset() {
+	*x = PublicImportMessage{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_test_test_public_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *PublicImportMessage) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*PublicImportMessage) ProtoMessage() {}
+
+func (x *PublicImportMessage) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_test_test_public_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use PublicImportMessage.ProtoReflect.Descriptor instead.
+func (*PublicImportMessage) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_test_test_public_proto_rawDescGZIP(), []int{0}
+}
+
+var File_internal_testprotos_test_test_public_proto protoreflect.FileDescriptor
+
+var file_internal_testprotos_test_test_public_proto_rawDesc = []byte{
+	0x0a, 0x2a, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x5f,
+	0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x67, 0x6f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74,
+	0x22, 0x15, 0x0a, 0x13, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x42, 0x35, 0x5a, 0x33, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74,
+	0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74,
+}
+
+var (
+	file_internal_testprotos_test_test_public_proto_rawDescOnce sync.Once
+	file_internal_testprotos_test_test_public_proto_rawDescData = file_internal_testprotos_test_test_public_proto_rawDesc
+)
+
+func file_internal_testprotos_test_test_public_proto_rawDescGZIP() []byte {
+	file_internal_testprotos_test_test_public_proto_rawDescOnce.Do(func() {
+		file_internal_testprotos_test_test_public_proto_rawDescData = protoimpl.X.CompressGZIP(file_internal_testprotos_test_test_public_proto_rawDescData)
+	})
+	return file_internal_testprotos_test_test_public_proto_rawDescData
+}
+
+var file_internal_testprotos_test_test_public_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_internal_testprotos_test_test_public_proto_goTypes = []interface{}{
+	(*PublicImportMessage)(nil), // 0: goproto.proto.test.PublicImportMessage
+}
+var file_internal_testprotos_test_test_public_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_internal_testprotos_test_test_public_proto_init() }
+func file_internal_testprotos_test_test_public_proto_init() {
+	if File_internal_testprotos_test_test_public_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_internal_testprotos_test_test_public_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*PublicImportMessage); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_internal_testprotos_test_test_public_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_internal_testprotos_test_test_public_proto_goTypes,
+		DependencyIndexes: file_internal_testprotos_test_test_public_proto_depIdxs,
+		MessageInfos:      file_internal_testprotos_test_test_public_proto_msgTypes,
+	}.Build()
+	File_internal_testprotos_test_test_public_proto = out.File
+	file_internal_testprotos_test_test_public_proto_rawDesc = nil
+	file_internal_testprotos_test_test_public_proto_goTypes = nil
+	file_internal_testprotos_test_test_public_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/test/test_public.proto b/vendor/google.golang.org/protobuf/internal/testprotos/test/test_public.proto
new file mode 100644
index 000000000..d2f14a78c
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/test/test_public.proto
@@ -0,0 +1,12 @@
+// Copyright 2019 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.
+
+syntax = "proto2";
+
+package goproto.proto.test;
+
+option go_package = "google.golang.org/protobuf/internal/testprotos/test";
+
+message PublicImportMessage {
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/test/weak1/test_weak.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/test/weak1/test_weak.pb.go
new file mode 100644
index 000000000..63203c529
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/test/weak1/test_weak.pb.go
@@ -0,0 +1,141 @@
+// Copyright 2019 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: internal/testprotos/test/weak1/test_weak.proto
+
+package weak1
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type WeakImportMessage1 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	A *int32 `protobuf:"varint,1,req,name=a" json:"a,omitempty"`
+}
+
+func (x *WeakImportMessage1) Reset() {
+	*x = WeakImportMessage1{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_test_weak1_test_weak_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *WeakImportMessage1) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*WeakImportMessage1) ProtoMessage() {}
+
+func (x *WeakImportMessage1) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_test_weak1_test_weak_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use WeakImportMessage1.ProtoReflect.Descriptor instead.
+func (*WeakImportMessage1) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_test_weak1_test_weak_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *WeakImportMessage1) GetA() int32 {
+	if x != nil && x.A != nil {
+		return *x.A
+	}
+	return 0
+}
+
+var File_internal_testprotos_test_weak1_test_weak_proto protoreflect.FileDescriptor
+
+var file_internal_testprotos_test_weak1_test_weak_proto_rawDesc = []byte{
+	0x0a, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x77, 0x65, 0x61, 0x6b, 0x31,
+	0x2f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x77, 0x65, 0x61, 0x6b, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x12, 0x17, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x74, 0x65, 0x73, 0x74, 0x2e, 0x77, 0x65, 0x61, 0x6b, 0x22, 0x22, 0x0a, 0x12, 0x57, 0x65, 0x61,
+	0x6b, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x31, 0x12,
+	0x0c, 0x0a, 0x01, 0x61, 0x18, 0x01, 0x20, 0x02, 0x28, 0x05, 0x52, 0x01, 0x61, 0x42, 0x3b, 0x5a,
+	0x39, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f,
+	0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x69, 0x6e, 0x74, 0x65,
+	0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f,
+	0x74, 0x65, 0x73, 0x74, 0x2f, 0x77, 0x65, 0x61, 0x6b, 0x31,
+}
+
+var (
+	file_internal_testprotos_test_weak1_test_weak_proto_rawDescOnce sync.Once
+	file_internal_testprotos_test_weak1_test_weak_proto_rawDescData = file_internal_testprotos_test_weak1_test_weak_proto_rawDesc
+)
+
+func file_internal_testprotos_test_weak1_test_weak_proto_rawDescGZIP() []byte {
+	file_internal_testprotos_test_weak1_test_weak_proto_rawDescOnce.Do(func() {
+		file_internal_testprotos_test_weak1_test_weak_proto_rawDescData = protoimpl.X.CompressGZIP(file_internal_testprotos_test_weak1_test_weak_proto_rawDescData)
+	})
+	return file_internal_testprotos_test_weak1_test_weak_proto_rawDescData
+}
+
+var file_internal_testprotos_test_weak1_test_weak_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_internal_testprotos_test_weak1_test_weak_proto_goTypes = []interface{}{
+	(*WeakImportMessage1)(nil), // 0: goproto.proto.test.weak.WeakImportMessage1
+}
+var file_internal_testprotos_test_weak1_test_weak_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_internal_testprotos_test_weak1_test_weak_proto_init() }
+func file_internal_testprotos_test_weak1_test_weak_proto_init() {
+	if File_internal_testprotos_test_weak1_test_weak_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_internal_testprotos_test_weak1_test_weak_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*WeakImportMessage1); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_internal_testprotos_test_weak1_test_weak_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_internal_testprotos_test_weak1_test_weak_proto_goTypes,
+		DependencyIndexes: file_internal_testprotos_test_weak1_test_weak_proto_depIdxs,
+		MessageInfos:      file_internal_testprotos_test_weak1_test_weak_proto_msgTypes,
+	}.Build()
+	File_internal_testprotos_test_weak1_test_weak_proto = out.File
+	file_internal_testprotos_test_weak1_test_weak_proto_rawDesc = nil
+	file_internal_testprotos_test_weak1_test_weak_proto_goTypes = nil
+	file_internal_testprotos_test_weak1_test_weak_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/test/weak1/test_weak.proto b/vendor/google.golang.org/protobuf/internal/testprotos/test/weak1/test_weak.proto
new file mode 100644
index 000000000..113ed1bca
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/test/weak1/test_weak.proto
@@ -0,0 +1,13 @@
+// Copyright 2019 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.
+
+syntax = "proto2";
+
+package goproto.proto.test.weak;
+
+option go_package = "google.golang.org/protobuf/internal/testprotos/test/weak1";
+
+message WeakImportMessage1 {
+	required int32 a = 1;
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/test/weak2/test_weak.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/test/weak2/test_weak.pb.go
new file mode 100644
index 000000000..7678dc9ae
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/test/weak2/test_weak.pb.go
@@ -0,0 +1,141 @@
+// Copyright 2019 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: internal/testprotos/test/weak2/test_weak.proto
+
+package weak2
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type WeakImportMessage2 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	A *int32 `protobuf:"varint,1,req,name=a" json:"a,omitempty"`
+}
+
+func (x *WeakImportMessage2) Reset() {
+	*x = WeakImportMessage2{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_test_weak2_test_weak_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *WeakImportMessage2) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*WeakImportMessage2) ProtoMessage() {}
+
+func (x *WeakImportMessage2) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_test_weak2_test_weak_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use WeakImportMessage2.ProtoReflect.Descriptor instead.
+func (*WeakImportMessage2) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_test_weak2_test_weak_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *WeakImportMessage2) GetA() int32 {
+	if x != nil && x.A != nil {
+		return *x.A
+	}
+	return 0
+}
+
+var File_internal_testprotos_test_weak2_test_weak_proto protoreflect.FileDescriptor
+
+var file_internal_testprotos_test_weak2_test_weak_proto_rawDesc = []byte{
+	0x0a, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x77, 0x65, 0x61, 0x6b, 0x32,
+	0x2f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x77, 0x65, 0x61, 0x6b, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x12, 0x17, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x74, 0x65, 0x73, 0x74, 0x2e, 0x77, 0x65, 0x61, 0x6b, 0x22, 0x22, 0x0a, 0x12, 0x57, 0x65, 0x61,
+	0x6b, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x12,
+	0x0c, 0x0a, 0x01, 0x61, 0x18, 0x01, 0x20, 0x02, 0x28, 0x05, 0x52, 0x01, 0x61, 0x42, 0x3b, 0x5a,
+	0x39, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f,
+	0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x69, 0x6e, 0x74, 0x65,
+	0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f,
+	0x74, 0x65, 0x73, 0x74, 0x2f, 0x77, 0x65, 0x61, 0x6b, 0x32,
+}
+
+var (
+	file_internal_testprotos_test_weak2_test_weak_proto_rawDescOnce sync.Once
+	file_internal_testprotos_test_weak2_test_weak_proto_rawDescData = file_internal_testprotos_test_weak2_test_weak_proto_rawDesc
+)
+
+func file_internal_testprotos_test_weak2_test_weak_proto_rawDescGZIP() []byte {
+	file_internal_testprotos_test_weak2_test_weak_proto_rawDescOnce.Do(func() {
+		file_internal_testprotos_test_weak2_test_weak_proto_rawDescData = protoimpl.X.CompressGZIP(file_internal_testprotos_test_weak2_test_weak_proto_rawDescData)
+	})
+	return file_internal_testprotos_test_weak2_test_weak_proto_rawDescData
+}
+
+var file_internal_testprotos_test_weak2_test_weak_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_internal_testprotos_test_weak2_test_weak_proto_goTypes = []interface{}{
+	(*WeakImportMessage2)(nil), // 0: goproto.proto.test.weak.WeakImportMessage2
+}
+var file_internal_testprotos_test_weak2_test_weak_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_internal_testprotos_test_weak2_test_weak_proto_init() }
+func file_internal_testprotos_test_weak2_test_weak_proto_init() {
+	if File_internal_testprotos_test_weak2_test_weak_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_internal_testprotos_test_weak2_test_weak_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*WeakImportMessage2); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_internal_testprotos_test_weak2_test_weak_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_internal_testprotos_test_weak2_test_weak_proto_goTypes,
+		DependencyIndexes: file_internal_testprotos_test_weak2_test_weak_proto_depIdxs,
+		MessageInfos:      file_internal_testprotos_test_weak2_test_weak_proto_msgTypes,
+	}.Build()
+	File_internal_testprotos_test_weak2_test_weak_proto = out.File
+	file_internal_testprotos_test_weak2_test_weak_proto_rawDesc = nil
+	file_internal_testprotos_test_weak2_test_weak_proto_goTypes = nil
+	file_internal_testprotos_test_weak2_test_weak_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/test/weak2/test_weak.proto b/vendor/google.golang.org/protobuf/internal/testprotos/test/weak2/test_weak.proto
new file mode 100644
index 000000000..61a03d641
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/test/weak2/test_weak.proto
@@ -0,0 +1,13 @@
+// Copyright 2019 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.
+
+syntax = "proto2";
+
+package goproto.proto.test.weak;
+
+option go_package = "google.golang.org/protobuf/internal/testprotos/test/weak2";
+
+message WeakImportMessage2 {
+	required int32 a = 1;
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/test3/test.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/test3/test.pb.go
new file mode 100644
index 000000000..6375d8f20
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/test3/test.pb.go
@@ -0,0 +1,1716 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: internal/testprotos/test3/test.proto
+
+package test3
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type ForeignEnum int32
+
+const (
+	ForeignEnum_FOREIGN_ZERO ForeignEnum = 0
+	ForeignEnum_FOREIGN_FOO  ForeignEnum = 4
+	ForeignEnum_FOREIGN_BAR  ForeignEnum = 5
+	ForeignEnum_FOREIGN_BAZ  ForeignEnum = 6
+)
+
+// Enum value maps for ForeignEnum.
+var (
+	ForeignEnum_name = map[int32]string{
+		0: "FOREIGN_ZERO",
+		4: "FOREIGN_FOO",
+		5: "FOREIGN_BAR",
+		6: "FOREIGN_BAZ",
+	}
+	ForeignEnum_value = map[string]int32{
+		"FOREIGN_ZERO": 0,
+		"FOREIGN_FOO":  4,
+		"FOREIGN_BAR":  5,
+		"FOREIGN_BAZ":  6,
+	}
+)
+
+func (x ForeignEnum) Enum() *ForeignEnum {
+	p := new(ForeignEnum)
+	*p = x
+	return p
+}
+
+func (x ForeignEnum) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (ForeignEnum) Descriptor() protoreflect.EnumDescriptor {
+	return file_internal_testprotos_test3_test_proto_enumTypes[0].Descriptor()
+}
+
+func (ForeignEnum) Type() protoreflect.EnumType {
+	return &file_internal_testprotos_test3_test_proto_enumTypes[0]
+}
+
+func (x ForeignEnum) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use ForeignEnum.Descriptor instead.
+func (ForeignEnum) EnumDescriptor() ([]byte, []int) {
+	return file_internal_testprotos_test3_test_proto_rawDescGZIP(), []int{0}
+}
+
+type TestAllTypes_NestedEnum int32
+
+const (
+	TestAllTypes_FOO TestAllTypes_NestedEnum = 0
+	TestAllTypes_BAR TestAllTypes_NestedEnum = 1
+	TestAllTypes_BAZ TestAllTypes_NestedEnum = 2
+	TestAllTypes_NEG TestAllTypes_NestedEnum = -1 // Intentionally negative.
+)
+
+// Enum value maps for TestAllTypes_NestedEnum.
+var (
+	TestAllTypes_NestedEnum_name = map[int32]string{
+		0:  "FOO",
+		1:  "BAR",
+		2:  "BAZ",
+		-1: "NEG",
+	}
+	TestAllTypes_NestedEnum_value = map[string]int32{
+		"FOO": 0,
+		"BAR": 1,
+		"BAZ": 2,
+		"NEG": -1,
+	}
+)
+
+func (x TestAllTypes_NestedEnum) Enum() *TestAllTypes_NestedEnum {
+	p := new(TestAllTypes_NestedEnum)
+	*p = x
+	return p
+}
+
+func (x TestAllTypes_NestedEnum) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (TestAllTypes_NestedEnum) Descriptor() protoreflect.EnumDescriptor {
+	return file_internal_testprotos_test3_test_proto_enumTypes[1].Descriptor()
+}
+
+func (TestAllTypes_NestedEnum) Type() protoreflect.EnumType {
+	return &file_internal_testprotos_test3_test_proto_enumTypes[1]
+}
+
+func (x TestAllTypes_NestedEnum) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use TestAllTypes_NestedEnum.Descriptor instead.
+func (TestAllTypes_NestedEnum) EnumDescriptor() ([]byte, []int) {
+	return file_internal_testprotos_test3_test_proto_rawDescGZIP(), []int{0, 0}
+}
+
+type TestAllTypes struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	SingularInt32          int32                                  `protobuf:"varint,81,opt,name=singular_int32,json=singularInt32,proto3" json:"singular_int32,omitempty"`
+	SingularInt64          int64                                  `protobuf:"varint,82,opt,name=singular_int64,json=singularInt64,proto3" json:"singular_int64,omitempty"`
+	SingularUint32         uint32                                 `protobuf:"varint,83,opt,name=singular_uint32,json=singularUint32,proto3" json:"singular_uint32,omitempty"`
+	SingularUint64         uint64                                 `protobuf:"varint,84,opt,name=singular_uint64,json=singularUint64,proto3" json:"singular_uint64,omitempty"`
+	SingularSint32         int32                                  `protobuf:"zigzag32,85,opt,name=singular_sint32,json=singularSint32,proto3" json:"singular_sint32,omitempty"`
+	SingularSint64         int64                                  `protobuf:"zigzag64,86,opt,name=singular_sint64,json=singularSint64,proto3" json:"singular_sint64,omitempty"`
+	SingularFixed32        uint32                                 `protobuf:"fixed32,87,opt,name=singular_fixed32,json=singularFixed32,proto3" json:"singular_fixed32,omitempty"`
+	SingularFixed64        uint64                                 `protobuf:"fixed64,88,opt,name=singular_fixed64,json=singularFixed64,proto3" json:"singular_fixed64,omitempty"`
+	SingularSfixed32       int32                                  `protobuf:"fixed32,89,opt,name=singular_sfixed32,json=singularSfixed32,proto3" json:"singular_sfixed32,omitempty"`
+	SingularSfixed64       int64                                  `protobuf:"fixed64,90,opt,name=singular_sfixed64,json=singularSfixed64,proto3" json:"singular_sfixed64,omitempty"`
+	SingularFloat          float32                                `protobuf:"fixed32,91,opt,name=singular_float,json=singularFloat,proto3" json:"singular_float,omitempty"`
+	SingularDouble         float64                                `protobuf:"fixed64,92,opt,name=singular_double,json=singularDouble,proto3" json:"singular_double,omitempty"`
+	SingularBool           bool                                   `protobuf:"varint,93,opt,name=singular_bool,json=singularBool,proto3" json:"singular_bool,omitempty"`
+	SingularString         string                                 `protobuf:"bytes,94,opt,name=singular_string,json=singularString,proto3" json:"singular_string,omitempty"`
+	SingularBytes          []byte                                 `protobuf:"bytes,95,opt,name=singular_bytes,json=singularBytes,proto3" json:"singular_bytes,omitempty"`
+	SingularNestedMessage  *TestAllTypes_NestedMessage            `protobuf:"bytes,98,opt,name=singular_nested_message,json=singularNestedMessage,proto3" json:"singular_nested_message,omitempty"`
+	SingularForeignMessage *ForeignMessage                        `protobuf:"bytes,99,opt,name=singular_foreign_message,json=singularForeignMessage,proto3" json:"singular_foreign_message,omitempty"`
+	SingularImportMessage  *ImportMessage                         `protobuf:"bytes,100,opt,name=singular_import_message,json=singularImportMessage,proto3" json:"singular_import_message,omitempty"`
+	SingularNestedEnum     TestAllTypes_NestedEnum                `protobuf:"varint,101,opt,name=singular_nested_enum,json=singularNestedEnum,proto3,enum=goproto.proto.test3.TestAllTypes_NestedEnum" json:"singular_nested_enum,omitempty"`
+	SingularForeignEnum    ForeignEnum                            `protobuf:"varint,102,opt,name=singular_foreign_enum,json=singularForeignEnum,proto3,enum=goproto.proto.test3.ForeignEnum" json:"singular_foreign_enum,omitempty"`
+	SingularImportEnum     ImportEnum                             `protobuf:"varint,103,opt,name=singular_import_enum,json=singularImportEnum,proto3,enum=goproto.proto.test3.ImportEnum" json:"singular_import_enum,omitempty"`
+	OptionalInt32          *int32                                 `protobuf:"varint,1,opt,name=optional_int32,json=optionalInt32,proto3,oneof" json:"optional_int32,omitempty"`
+	OptionalInt64          *int64                                 `protobuf:"varint,2,opt,name=optional_int64,json=optionalInt64,proto3,oneof" json:"optional_int64,omitempty"`
+	OptionalUint32         *uint32                                `protobuf:"varint,3,opt,name=optional_uint32,json=optionalUint32,proto3,oneof" json:"optional_uint32,omitempty"`
+	OptionalUint64         *uint64                                `protobuf:"varint,4,opt,name=optional_uint64,json=optionalUint64,proto3,oneof" json:"optional_uint64,omitempty"`
+	OptionalSint32         *int32                                 `protobuf:"zigzag32,5,opt,name=optional_sint32,json=optionalSint32,proto3,oneof" json:"optional_sint32,omitempty"`
+	OptionalSint64         *int64                                 `protobuf:"zigzag64,6,opt,name=optional_sint64,json=optionalSint64,proto3,oneof" json:"optional_sint64,omitempty"`
+	OptionalFixed32        *uint32                                `protobuf:"fixed32,7,opt,name=optional_fixed32,json=optionalFixed32,proto3,oneof" json:"optional_fixed32,omitempty"`
+	OptionalFixed64        *uint64                                `protobuf:"fixed64,8,opt,name=optional_fixed64,json=optionalFixed64,proto3,oneof" json:"optional_fixed64,omitempty"`
+	OptionalSfixed32       *int32                                 `protobuf:"fixed32,9,opt,name=optional_sfixed32,json=optionalSfixed32,proto3,oneof" json:"optional_sfixed32,omitempty"`
+	OptionalSfixed64       *int64                                 `protobuf:"fixed64,10,opt,name=optional_sfixed64,json=optionalSfixed64,proto3,oneof" json:"optional_sfixed64,omitempty"`
+	OptionalFloat          *float32                               `protobuf:"fixed32,11,opt,name=optional_float,json=optionalFloat,proto3,oneof" json:"optional_float,omitempty"`
+	OptionalDouble         *float64                               `protobuf:"fixed64,12,opt,name=optional_double,json=optionalDouble,proto3,oneof" json:"optional_double,omitempty"`
+	OptionalBool           *bool                                  `protobuf:"varint,13,opt,name=optional_bool,json=optionalBool,proto3,oneof" json:"optional_bool,omitempty"`
+	OptionalString         *string                                `protobuf:"bytes,14,opt,name=optional_string,json=optionalString,proto3,oneof" json:"optional_string,omitempty"`
+	OptionalBytes          []byte                                 `protobuf:"bytes,15,opt,name=optional_bytes,json=optionalBytes,proto3,oneof" json:"optional_bytes,omitempty"`
+	OptionalNestedMessage  *TestAllTypes_NestedMessage            `protobuf:"bytes,18,opt,name=optional_nested_message,json=optionalNestedMessage,proto3,oneof" json:"optional_nested_message,omitempty"`
+	OptionalForeignMessage *ForeignMessage                        `protobuf:"bytes,19,opt,name=optional_foreign_message,json=optionalForeignMessage,proto3,oneof" json:"optional_foreign_message,omitempty"`
+	OptionalImportMessage  *ImportMessage                         `protobuf:"bytes,20,opt,name=optional_import_message,json=optionalImportMessage,proto3,oneof" json:"optional_import_message,omitempty"`
+	OptionalNestedEnum     *TestAllTypes_NestedEnum               `protobuf:"varint,21,opt,name=optional_nested_enum,json=optionalNestedEnum,proto3,enum=goproto.proto.test3.TestAllTypes_NestedEnum,oneof" json:"optional_nested_enum,omitempty"`
+	OptionalForeignEnum    *ForeignEnum                           `protobuf:"varint,22,opt,name=optional_foreign_enum,json=optionalForeignEnum,proto3,enum=goproto.proto.test3.ForeignEnum,oneof" json:"optional_foreign_enum,omitempty"`
+	OptionalImportEnum     *ImportEnum                            `protobuf:"varint,23,opt,name=optional_import_enum,json=optionalImportEnum,proto3,enum=goproto.proto.test3.ImportEnum,oneof" json:"optional_import_enum,omitempty"`
+	RepeatedInt32          []int32                                `protobuf:"varint,31,rep,packed,name=repeated_int32,json=repeatedInt32,proto3" json:"repeated_int32,omitempty"`
+	RepeatedInt64          []int64                                `protobuf:"varint,32,rep,packed,name=repeated_int64,json=repeatedInt64,proto3" json:"repeated_int64,omitempty"`
+	RepeatedUint32         []uint32                               `protobuf:"varint,33,rep,packed,name=repeated_uint32,json=repeatedUint32,proto3" json:"repeated_uint32,omitempty"`
+	RepeatedUint64         []uint64                               `protobuf:"varint,34,rep,packed,name=repeated_uint64,json=repeatedUint64,proto3" json:"repeated_uint64,omitempty"`
+	RepeatedSint32         []int32                                `protobuf:"zigzag32,35,rep,packed,name=repeated_sint32,json=repeatedSint32,proto3" json:"repeated_sint32,omitempty"`
+	RepeatedSint64         []int64                                `protobuf:"zigzag64,36,rep,packed,name=repeated_sint64,json=repeatedSint64,proto3" json:"repeated_sint64,omitempty"`
+	RepeatedFixed32        []uint32                               `protobuf:"fixed32,37,rep,packed,name=repeated_fixed32,json=repeatedFixed32,proto3" json:"repeated_fixed32,omitempty"`
+	RepeatedFixed64        []uint64                               `protobuf:"fixed64,38,rep,packed,name=repeated_fixed64,json=repeatedFixed64,proto3" json:"repeated_fixed64,omitempty"`
+	RepeatedSfixed32       []int32                                `protobuf:"fixed32,39,rep,packed,name=repeated_sfixed32,json=repeatedSfixed32,proto3" json:"repeated_sfixed32,omitempty"`
+	RepeatedSfixed64       []int64                                `protobuf:"fixed64,40,rep,packed,name=repeated_sfixed64,json=repeatedSfixed64,proto3" json:"repeated_sfixed64,omitempty"`
+	RepeatedFloat          []float32                              `protobuf:"fixed32,41,rep,packed,name=repeated_float,json=repeatedFloat,proto3" json:"repeated_float,omitempty"`
+	RepeatedDouble         []float64                              `protobuf:"fixed64,42,rep,packed,name=repeated_double,json=repeatedDouble,proto3" json:"repeated_double,omitempty"`
+	RepeatedBool           []bool                                 `protobuf:"varint,43,rep,packed,name=repeated_bool,json=repeatedBool,proto3" json:"repeated_bool,omitempty"`
+	RepeatedString         []string                               `protobuf:"bytes,44,rep,name=repeated_string,json=repeatedString,proto3" json:"repeated_string,omitempty"`
+	RepeatedBytes          [][]byte                               `protobuf:"bytes,45,rep,name=repeated_bytes,json=repeatedBytes,proto3" json:"repeated_bytes,omitempty"`
+	RepeatedNestedMessage  []*TestAllTypes_NestedMessage          `protobuf:"bytes,48,rep,name=repeated_nested_message,json=repeatedNestedMessage,proto3" json:"repeated_nested_message,omitempty"`
+	RepeatedForeignMessage []*ForeignMessage                      `protobuf:"bytes,49,rep,name=repeated_foreign_message,json=repeatedForeignMessage,proto3" json:"repeated_foreign_message,omitempty"`
+	RepeatedImportmessage  []*ImportMessage                       `protobuf:"bytes,50,rep,name=repeated_importmessage,json=repeatedImportmessage,proto3" json:"repeated_importmessage,omitempty"`
+	RepeatedNestedEnum     []TestAllTypes_NestedEnum              `protobuf:"varint,51,rep,packed,name=repeated_nested_enum,json=repeatedNestedEnum,proto3,enum=goproto.proto.test3.TestAllTypes_NestedEnum" json:"repeated_nested_enum,omitempty"`
+	RepeatedForeignEnum    []ForeignEnum                          `protobuf:"varint,52,rep,packed,name=repeated_foreign_enum,json=repeatedForeignEnum,proto3,enum=goproto.proto.test3.ForeignEnum" json:"repeated_foreign_enum,omitempty"`
+	RepeatedImportenum     []ImportEnum                           `protobuf:"varint,53,rep,packed,name=repeated_importenum,json=repeatedImportenum,proto3,enum=goproto.proto.test3.ImportEnum" json:"repeated_importenum,omitempty"`
+	MapInt32Int32          map[int32]int32                        `protobuf:"bytes,56,rep,name=map_int32_int32,json=mapInt32Int32,proto3" json:"map_int32_int32,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+	MapInt64Int64          map[int64]int64                        `protobuf:"bytes,57,rep,name=map_int64_int64,json=mapInt64Int64,proto3" json:"map_int64_int64,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+	MapUint32Uint32        map[uint32]uint32                      `protobuf:"bytes,58,rep,name=map_uint32_uint32,json=mapUint32Uint32,proto3" json:"map_uint32_uint32,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+	MapUint64Uint64        map[uint64]uint64                      `protobuf:"bytes,59,rep,name=map_uint64_uint64,json=mapUint64Uint64,proto3" json:"map_uint64_uint64,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+	MapSint32Sint32        map[int32]int32                        `protobuf:"bytes,60,rep,name=map_sint32_sint32,json=mapSint32Sint32,proto3" json:"map_sint32_sint32,omitempty" protobuf_key:"zigzag32,1,opt,name=key,proto3" protobuf_val:"zigzag32,2,opt,name=value,proto3"`
+	MapSint64Sint64        map[int64]int64                        `protobuf:"bytes,61,rep,name=map_sint64_sint64,json=mapSint64Sint64,proto3" json:"map_sint64_sint64,omitempty" protobuf_key:"zigzag64,1,opt,name=key,proto3" protobuf_val:"zigzag64,2,opt,name=value,proto3"`
+	MapFixed32Fixed32      map[uint32]uint32                      `protobuf:"bytes,62,rep,name=map_fixed32_fixed32,json=mapFixed32Fixed32,proto3" json:"map_fixed32_fixed32,omitempty" protobuf_key:"fixed32,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"`
+	MapFixed64Fixed64      map[uint64]uint64                      `protobuf:"bytes,63,rep,name=map_fixed64_fixed64,json=mapFixed64Fixed64,proto3" json:"map_fixed64_fixed64,omitempty" protobuf_key:"fixed64,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"`
+	MapSfixed32Sfixed32    map[int32]int32                        `protobuf:"bytes,64,rep,name=map_sfixed32_sfixed32,json=mapSfixed32Sfixed32,proto3" json:"map_sfixed32_sfixed32,omitempty" protobuf_key:"fixed32,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"`
+	MapSfixed64Sfixed64    map[int64]int64                        `protobuf:"bytes,65,rep,name=map_sfixed64_sfixed64,json=mapSfixed64Sfixed64,proto3" json:"map_sfixed64_sfixed64,omitempty" protobuf_key:"fixed64,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"`
+	MapInt32Float          map[int32]float32                      `protobuf:"bytes,66,rep,name=map_int32_float,json=mapInt32Float,proto3" json:"map_int32_float,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"`
+	MapInt32Double         map[int32]float64                      `protobuf:"bytes,67,rep,name=map_int32_double,json=mapInt32Double,proto3" json:"map_int32_double,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"`
+	MapBoolBool            map[bool]bool                          `protobuf:"bytes,68,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"`
+	MapStringString        map[string]string                      `protobuf:"bytes,69,rep,name=map_string_string,json=mapStringString,proto3" json:"map_string_string,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	MapStringBytes         map[string][]byte                      `protobuf:"bytes,70,rep,name=map_string_bytes,json=mapStringBytes,proto3" json:"map_string_bytes,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	MapStringNestedMessage map[string]*TestAllTypes_NestedMessage `protobuf:"bytes,71,rep,name=map_string_nested_message,json=mapStringNestedMessage,proto3" json:"map_string_nested_message,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	MapStringNestedEnum    map[string]TestAllTypes_NestedEnum     `protobuf:"bytes,73,rep,name=map_string_nested_enum,json=mapStringNestedEnum,proto3" json:"map_string_nested_enum,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3,enum=goproto.proto.test3.TestAllTypes_NestedEnum"`
+	// Types that are assignable to OneofField:
+	//	*TestAllTypes_OneofUint32
+	//	*TestAllTypes_OneofNestedMessage
+	//	*TestAllTypes_OneofString
+	//	*TestAllTypes_OneofBytes
+	//	*TestAllTypes_OneofBool
+	//	*TestAllTypes_OneofUint64
+	//	*TestAllTypes_OneofFloat
+	//	*TestAllTypes_OneofDouble
+	//	*TestAllTypes_OneofEnum
+	OneofField isTestAllTypes_OneofField `protobuf_oneof:"oneof_field"`
+}
+
+func (x *TestAllTypes) Reset() {
+	*x = TestAllTypes{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_test3_test_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *TestAllTypes) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TestAllTypes) ProtoMessage() {}
+
+func (x *TestAllTypes) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_test3_test_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TestAllTypes.ProtoReflect.Descriptor instead.
+func (*TestAllTypes) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_test3_test_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *TestAllTypes) GetSingularInt32() int32 {
+	if x != nil {
+		return x.SingularInt32
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetSingularInt64() int64 {
+	if x != nil {
+		return x.SingularInt64
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetSingularUint32() uint32 {
+	if x != nil {
+		return x.SingularUint32
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetSingularUint64() uint64 {
+	if x != nil {
+		return x.SingularUint64
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetSingularSint32() int32 {
+	if x != nil {
+		return x.SingularSint32
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetSingularSint64() int64 {
+	if x != nil {
+		return x.SingularSint64
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetSingularFixed32() uint32 {
+	if x != nil {
+		return x.SingularFixed32
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetSingularFixed64() uint64 {
+	if x != nil {
+		return x.SingularFixed64
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetSingularSfixed32() int32 {
+	if x != nil {
+		return x.SingularSfixed32
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetSingularSfixed64() int64 {
+	if x != nil {
+		return x.SingularSfixed64
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetSingularFloat() float32 {
+	if x != nil {
+		return x.SingularFloat
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetSingularDouble() float64 {
+	if x != nil {
+		return x.SingularDouble
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetSingularBool() bool {
+	if x != nil {
+		return x.SingularBool
+	}
+	return false
+}
+
+func (x *TestAllTypes) GetSingularString() string {
+	if x != nil {
+		return x.SingularString
+	}
+	return ""
+}
+
+func (x *TestAllTypes) GetSingularBytes() []byte {
+	if x != nil {
+		return x.SingularBytes
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetSingularNestedMessage() *TestAllTypes_NestedMessage {
+	if x != nil {
+		return x.SingularNestedMessage
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetSingularForeignMessage() *ForeignMessage {
+	if x != nil {
+		return x.SingularForeignMessage
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetSingularImportMessage() *ImportMessage {
+	if x != nil {
+		return x.SingularImportMessage
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetSingularNestedEnum() TestAllTypes_NestedEnum {
+	if x != nil {
+		return x.SingularNestedEnum
+	}
+	return TestAllTypes_FOO
+}
+
+func (x *TestAllTypes) GetSingularForeignEnum() ForeignEnum {
+	if x != nil {
+		return x.SingularForeignEnum
+	}
+	return ForeignEnum_FOREIGN_ZERO
+}
+
+func (x *TestAllTypes) GetSingularImportEnum() ImportEnum {
+	if x != nil {
+		return x.SingularImportEnum
+	}
+	return ImportEnum_IMPORT_ZERO
+}
+
+func (x *TestAllTypes) GetOptionalInt32() int32 {
+	if x != nil && x.OptionalInt32 != nil {
+		return *x.OptionalInt32
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetOptionalInt64() int64 {
+	if x != nil && x.OptionalInt64 != nil {
+		return *x.OptionalInt64
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetOptionalUint32() uint32 {
+	if x != nil && x.OptionalUint32 != nil {
+		return *x.OptionalUint32
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetOptionalUint64() uint64 {
+	if x != nil && x.OptionalUint64 != nil {
+		return *x.OptionalUint64
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetOptionalSint32() int32 {
+	if x != nil && x.OptionalSint32 != nil {
+		return *x.OptionalSint32
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetOptionalSint64() int64 {
+	if x != nil && x.OptionalSint64 != nil {
+		return *x.OptionalSint64
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetOptionalFixed32() uint32 {
+	if x != nil && x.OptionalFixed32 != nil {
+		return *x.OptionalFixed32
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetOptionalFixed64() uint64 {
+	if x != nil && x.OptionalFixed64 != nil {
+		return *x.OptionalFixed64
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetOptionalSfixed32() int32 {
+	if x != nil && x.OptionalSfixed32 != nil {
+		return *x.OptionalSfixed32
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetOptionalSfixed64() int64 {
+	if x != nil && x.OptionalSfixed64 != nil {
+		return *x.OptionalSfixed64
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetOptionalFloat() float32 {
+	if x != nil && x.OptionalFloat != nil {
+		return *x.OptionalFloat
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetOptionalDouble() float64 {
+	if x != nil && x.OptionalDouble != nil {
+		return *x.OptionalDouble
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetOptionalBool() bool {
+	if x != nil && x.OptionalBool != nil {
+		return *x.OptionalBool
+	}
+	return false
+}
+
+func (x *TestAllTypes) GetOptionalString() string {
+	if x != nil && x.OptionalString != nil {
+		return *x.OptionalString
+	}
+	return ""
+}
+
+func (x *TestAllTypes) GetOptionalBytes() []byte {
+	if x != nil {
+		return x.OptionalBytes
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetOptionalNestedMessage() *TestAllTypes_NestedMessage {
+	if x != nil {
+		return x.OptionalNestedMessage
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetOptionalForeignMessage() *ForeignMessage {
+	if x != nil {
+		return x.OptionalForeignMessage
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetOptionalImportMessage() *ImportMessage {
+	if x != nil {
+		return x.OptionalImportMessage
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetOptionalNestedEnum() TestAllTypes_NestedEnum {
+	if x != nil && x.OptionalNestedEnum != nil {
+		return *x.OptionalNestedEnum
+	}
+	return TestAllTypes_FOO
+}
+
+func (x *TestAllTypes) GetOptionalForeignEnum() ForeignEnum {
+	if x != nil && x.OptionalForeignEnum != nil {
+		return *x.OptionalForeignEnum
+	}
+	return ForeignEnum_FOREIGN_ZERO
+}
+
+func (x *TestAllTypes) GetOptionalImportEnum() ImportEnum {
+	if x != nil && x.OptionalImportEnum != nil {
+		return *x.OptionalImportEnum
+	}
+	return ImportEnum_IMPORT_ZERO
+}
+
+func (x *TestAllTypes) GetRepeatedInt32() []int32 {
+	if x != nil {
+		return x.RepeatedInt32
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedInt64() []int64 {
+	if x != nil {
+		return x.RepeatedInt64
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedUint32() []uint32 {
+	if x != nil {
+		return x.RepeatedUint32
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedUint64() []uint64 {
+	if x != nil {
+		return x.RepeatedUint64
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedSint32() []int32 {
+	if x != nil {
+		return x.RepeatedSint32
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedSint64() []int64 {
+	if x != nil {
+		return x.RepeatedSint64
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedFixed32() []uint32 {
+	if x != nil {
+		return x.RepeatedFixed32
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedFixed64() []uint64 {
+	if x != nil {
+		return x.RepeatedFixed64
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedSfixed32() []int32 {
+	if x != nil {
+		return x.RepeatedSfixed32
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedSfixed64() []int64 {
+	if x != nil {
+		return x.RepeatedSfixed64
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedFloat() []float32 {
+	if x != nil {
+		return x.RepeatedFloat
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedDouble() []float64 {
+	if x != nil {
+		return x.RepeatedDouble
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedBool() []bool {
+	if x != nil {
+		return x.RepeatedBool
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedString() []string {
+	if x != nil {
+		return x.RepeatedString
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedBytes() [][]byte {
+	if x != nil {
+		return x.RepeatedBytes
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedNestedMessage() []*TestAllTypes_NestedMessage {
+	if x != nil {
+		return x.RepeatedNestedMessage
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedForeignMessage() []*ForeignMessage {
+	if x != nil {
+		return x.RepeatedForeignMessage
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedImportmessage() []*ImportMessage {
+	if x != nil {
+		return x.RepeatedImportmessage
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedNestedEnum() []TestAllTypes_NestedEnum {
+	if x != nil {
+		return x.RepeatedNestedEnum
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedForeignEnum() []ForeignEnum {
+	if x != nil {
+		return x.RepeatedForeignEnum
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetRepeatedImportenum() []ImportEnum {
+	if x != nil {
+		return x.RepeatedImportenum
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetMapInt32Int32() map[int32]int32 {
+	if x != nil {
+		return x.MapInt32Int32
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetMapInt64Int64() map[int64]int64 {
+	if x != nil {
+		return x.MapInt64Int64
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetMapUint32Uint32() map[uint32]uint32 {
+	if x != nil {
+		return x.MapUint32Uint32
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetMapUint64Uint64() map[uint64]uint64 {
+	if x != nil {
+		return x.MapUint64Uint64
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetMapSint32Sint32() map[int32]int32 {
+	if x != nil {
+		return x.MapSint32Sint32
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetMapSint64Sint64() map[int64]int64 {
+	if x != nil {
+		return x.MapSint64Sint64
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetMapFixed32Fixed32() map[uint32]uint32 {
+	if x != nil {
+		return x.MapFixed32Fixed32
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetMapFixed64Fixed64() map[uint64]uint64 {
+	if x != nil {
+		return x.MapFixed64Fixed64
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetMapSfixed32Sfixed32() map[int32]int32 {
+	if x != nil {
+		return x.MapSfixed32Sfixed32
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetMapSfixed64Sfixed64() map[int64]int64 {
+	if x != nil {
+		return x.MapSfixed64Sfixed64
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetMapInt32Float() map[int32]float32 {
+	if x != nil {
+		return x.MapInt32Float
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetMapInt32Double() map[int32]float64 {
+	if x != nil {
+		return x.MapInt32Double
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetMapBoolBool() map[bool]bool {
+	if x != nil {
+		return x.MapBoolBool
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetMapStringString() map[string]string {
+	if x != nil {
+		return x.MapStringString
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetMapStringBytes() map[string][]byte {
+	if x != nil {
+		return x.MapStringBytes
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetMapStringNestedMessage() map[string]*TestAllTypes_NestedMessage {
+	if x != nil {
+		return x.MapStringNestedMessage
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetMapStringNestedEnum() map[string]TestAllTypes_NestedEnum {
+	if x != nil {
+		return x.MapStringNestedEnum
+	}
+	return nil
+}
+
+func (m *TestAllTypes) GetOneofField() isTestAllTypes_OneofField {
+	if m != nil {
+		return m.OneofField
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetOneofUint32() uint32 {
+	if x, ok := x.GetOneofField().(*TestAllTypes_OneofUint32); ok {
+		return x.OneofUint32
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetOneofNestedMessage() *TestAllTypes_NestedMessage {
+	if x, ok := x.GetOneofField().(*TestAllTypes_OneofNestedMessage); ok {
+		return x.OneofNestedMessage
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetOneofString() string {
+	if x, ok := x.GetOneofField().(*TestAllTypes_OneofString); ok {
+		return x.OneofString
+	}
+	return ""
+}
+
+func (x *TestAllTypes) GetOneofBytes() []byte {
+	if x, ok := x.GetOneofField().(*TestAllTypes_OneofBytes); ok {
+		return x.OneofBytes
+	}
+	return nil
+}
+
+func (x *TestAllTypes) GetOneofBool() bool {
+	if x, ok := x.GetOneofField().(*TestAllTypes_OneofBool); ok {
+		return x.OneofBool
+	}
+	return false
+}
+
+func (x *TestAllTypes) GetOneofUint64() uint64 {
+	if x, ok := x.GetOneofField().(*TestAllTypes_OneofUint64); ok {
+		return x.OneofUint64
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetOneofFloat() float32 {
+	if x, ok := x.GetOneofField().(*TestAllTypes_OneofFloat); ok {
+		return x.OneofFloat
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetOneofDouble() float64 {
+	if x, ok := x.GetOneofField().(*TestAllTypes_OneofDouble); ok {
+		return x.OneofDouble
+	}
+	return 0
+}
+
+func (x *TestAllTypes) GetOneofEnum() TestAllTypes_NestedEnum {
+	if x, ok := x.GetOneofField().(*TestAllTypes_OneofEnum); ok {
+		return x.OneofEnum
+	}
+	return TestAllTypes_FOO
+}
+
+type isTestAllTypes_OneofField interface {
+	isTestAllTypes_OneofField()
+}
+
+type TestAllTypes_OneofUint32 struct {
+	OneofUint32 uint32 `protobuf:"varint,111,opt,name=oneof_uint32,json=oneofUint32,proto3,oneof"`
+}
+
+type TestAllTypes_OneofNestedMessage struct {
+	OneofNestedMessage *TestAllTypes_NestedMessage `protobuf:"bytes,112,opt,name=oneof_nested_message,json=oneofNestedMessage,proto3,oneof"`
+}
+
+type TestAllTypes_OneofString struct {
+	OneofString string `protobuf:"bytes,113,opt,name=oneof_string,json=oneofString,proto3,oneof"`
+}
+
+type TestAllTypes_OneofBytes struct {
+	OneofBytes []byte `protobuf:"bytes,114,opt,name=oneof_bytes,json=oneofBytes,proto3,oneof"`
+}
+
+type TestAllTypes_OneofBool struct {
+	OneofBool bool `protobuf:"varint,115,opt,name=oneof_bool,json=oneofBool,proto3,oneof"`
+}
+
+type TestAllTypes_OneofUint64 struct {
+	OneofUint64 uint64 `protobuf:"varint,116,opt,name=oneof_uint64,json=oneofUint64,proto3,oneof"`
+}
+
+type TestAllTypes_OneofFloat struct {
+	OneofFloat float32 `protobuf:"fixed32,117,opt,name=oneof_float,json=oneofFloat,proto3,oneof"`
+}
+
+type TestAllTypes_OneofDouble struct {
+	OneofDouble float64 `protobuf:"fixed64,118,opt,name=oneof_double,json=oneofDouble,proto3,oneof"`
+}
+
+type TestAllTypes_OneofEnum struct {
+	OneofEnum TestAllTypes_NestedEnum `protobuf:"varint,119,opt,name=oneof_enum,json=oneofEnum,proto3,enum=goproto.proto.test3.TestAllTypes_NestedEnum,oneof"`
+}
+
+func (*TestAllTypes_OneofUint32) isTestAllTypes_OneofField() {}
+
+func (*TestAllTypes_OneofNestedMessage) isTestAllTypes_OneofField() {}
+
+func (*TestAllTypes_OneofString) isTestAllTypes_OneofField() {}
+
+func (*TestAllTypes_OneofBytes) isTestAllTypes_OneofField() {}
+
+func (*TestAllTypes_OneofBool) isTestAllTypes_OneofField() {}
+
+func (*TestAllTypes_OneofUint64) isTestAllTypes_OneofField() {}
+
+func (*TestAllTypes_OneofFloat) isTestAllTypes_OneofField() {}
+
+func (*TestAllTypes_OneofDouble) isTestAllTypes_OneofField() {}
+
+func (*TestAllTypes_OneofEnum) isTestAllTypes_OneofField() {}
+
+type ForeignMessage struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	C int32 `protobuf:"varint,1,opt,name=c,proto3" json:"c,omitempty"`
+	D int32 `protobuf:"varint,2,opt,name=d,proto3" json:"d,omitempty"`
+}
+
+func (x *ForeignMessage) Reset() {
+	*x = ForeignMessage{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_test3_test_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *ForeignMessage) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ForeignMessage) ProtoMessage() {}
+
+func (x *ForeignMessage) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_test3_test_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ForeignMessage.ProtoReflect.Descriptor instead.
+func (*ForeignMessage) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_test3_test_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *ForeignMessage) GetC() int32 {
+	if x != nil {
+		return x.C
+	}
+	return 0
+}
+
+func (x *ForeignMessage) GetD() int32 {
+	if x != nil {
+		return x.D
+	}
+	return 0
+}
+
+type TestAllTypes_NestedMessage struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	A           int32         `protobuf:"varint,1,opt,name=a,proto3" json:"a,omitempty"`
+	Corecursive *TestAllTypes `protobuf:"bytes,2,opt,name=corecursive,proto3" json:"corecursive,omitempty"`
+}
+
+func (x *TestAllTypes_NestedMessage) Reset() {
+	*x = TestAllTypes_NestedMessage{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_test3_test_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *TestAllTypes_NestedMessage) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TestAllTypes_NestedMessage) ProtoMessage() {}
+
+func (x *TestAllTypes_NestedMessage) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_test3_test_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TestAllTypes_NestedMessage.ProtoReflect.Descriptor instead.
+func (*TestAllTypes_NestedMessage) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_test3_test_proto_rawDescGZIP(), []int{0, 0}
+}
+
+func (x *TestAllTypes_NestedMessage) GetA() int32 {
+	if x != nil {
+		return x.A
+	}
+	return 0
+}
+
+func (x *TestAllTypes_NestedMessage) GetCorecursive() *TestAllTypes {
+	if x != nil {
+		return x.Corecursive
+	}
+	return nil
+}
+
+var File_internal_testprotos_test3_test_proto protoreflect.FileDescriptor
+
+var file_internal_testprotos_test3_test_proto_rawDesc = []byte{
+	0x0a, 0x24, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2f, 0x74, 0x65, 0x73, 0x74,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x13, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x33, 0x1a, 0x2b, 0x69, 0x6e, 0x74,
+	0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73,
+	0x2f, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x69, 0x6d, 0x70, 0x6f,
+	0x72, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x90, 0x3c, 0x0a, 0x0c, 0x54, 0x65, 0x73,
+	0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x73, 0x69, 0x6e,
+	0x67, 0x75, 0x6c, 0x61, 0x72, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x51, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x0d, 0x73, 0x69, 0x6e, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x49, 0x6e, 0x74, 0x33, 0x32,
+	0x12, 0x25, 0x0a, 0x0e, 0x73, 0x69, 0x6e, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x5f, 0x69, 0x6e, 0x74,
+	0x36, 0x34, 0x18, 0x52, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x73, 0x69, 0x6e, 0x67, 0x75, 0x6c,
+	0x61, 0x72, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x27, 0x0a, 0x0f, 0x73, 0x69, 0x6e, 0x67, 0x75,
+	0x6c, 0x61, 0x72, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x53, 0x20, 0x01, 0x28, 0x0d,
+	0x52, 0x0e, 0x73, 0x69, 0x6e, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32,
+	0x12, 0x27, 0x0a, 0x0f, 0x73, 0x69, 0x6e, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x5f, 0x75, 0x69, 0x6e,
+	0x74, 0x36, 0x34, 0x18, 0x54, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e, 0x73, 0x69, 0x6e, 0x67, 0x75,
+	0x6c, 0x61, 0x72, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x27, 0x0a, 0x0f, 0x73, 0x69, 0x6e,
+	0x67, 0x75, 0x6c, 0x61, 0x72, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x55, 0x20, 0x01,
+	0x28, 0x11, 0x52, 0x0e, 0x73, 0x69, 0x6e, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x53, 0x69, 0x6e, 0x74,
+	0x33, 0x32, 0x12, 0x27, 0x0a, 0x0f, 0x73, 0x69, 0x6e, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x5f, 0x73,
+	0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x56, 0x20, 0x01, 0x28, 0x12, 0x52, 0x0e, 0x73, 0x69, 0x6e,
+	0x67, 0x75, 0x6c, 0x61, 0x72, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x29, 0x0a, 0x10, 0x73,
+	0x69, 0x6e, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18,
+	0x57, 0x20, 0x01, 0x28, 0x07, 0x52, 0x0f, 0x73, 0x69, 0x6e, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x46,
+	0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x29, 0x0a, 0x10, 0x73, 0x69, 0x6e, 0x67, 0x75, 0x6c,
+	0x61, 0x72, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x58, 0x20, 0x01, 0x28, 0x06,
+	0x52, 0x0f, 0x73, 0x69, 0x6e, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36,
+	0x34, 0x12, 0x2b, 0x0a, 0x11, 0x73, 0x69, 0x6e, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x5f, 0x73, 0x66,
+	0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x59, 0x20, 0x01, 0x28, 0x0f, 0x52, 0x10, 0x73, 0x69,
+	0x6e, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x2b,
+	0x0a, 0x11, 0x73, 0x69, 0x6e, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65,
+	0x64, 0x36, 0x34, 0x18, 0x5a, 0x20, 0x01, 0x28, 0x10, 0x52, 0x10, 0x73, 0x69, 0x6e, 0x67, 0x75,
+	0x6c, 0x61, 0x72, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x25, 0x0a, 0x0e, 0x73,
+	0x69, 0x6e, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x18, 0x5b, 0x20,
+	0x01, 0x28, 0x02, 0x52, 0x0d, 0x73, 0x69, 0x6e, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x46, 0x6c, 0x6f,
+	0x61, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x73, 0x69, 0x6e, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x5f, 0x64,
+	0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0x5c, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0e, 0x73, 0x69, 0x6e,
+	0x67, 0x75, 0x6c, 0x61, 0x72, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x73,
+	0x69, 0x6e, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18, 0x5d, 0x20, 0x01,
+	0x28, 0x08, 0x52, 0x0c, 0x73, 0x69, 0x6e, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x42, 0x6f, 0x6f, 0x6c,
+	0x12, 0x27, 0x0a, 0x0f, 0x73, 0x69, 0x6e, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x5f, 0x73, 0x74, 0x72,
+	0x69, 0x6e, 0x67, 0x18, 0x5e, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x73, 0x69, 0x6e, 0x67, 0x75,
+	0x6c, 0x61, 0x72, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x25, 0x0a, 0x0e, 0x73, 0x69, 0x6e,
+	0x67, 0x75, 0x6c, 0x61, 0x72, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x5f, 0x20, 0x01, 0x28,
+	0x0c, 0x52, 0x0d, 0x73, 0x69, 0x6e, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x42, 0x79, 0x74, 0x65, 0x73,
+	0x12, 0x67, 0x0a, 0x17, 0x73, 0x69, 0x6e, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x5f, 0x6e, 0x65, 0x73,
+	0x74, 0x65, 0x64, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x62, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x2f, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54,
+	0x79, 0x70, 0x65, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x52, 0x15, 0x73, 0x69, 0x6e, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x4e, 0x65, 0x73, 0x74,
+	0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x5d, 0x0a, 0x18, 0x73, 0x69, 0x6e,
+	0x67, 0x75, 0x6c, 0x61, 0x72, 0x5f, 0x66, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x63, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x67, 0x6f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74,
+	0x33, 0x2e, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x52, 0x16, 0x73, 0x69, 0x6e, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67,
+	0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x5a, 0x0a, 0x17, 0x73, 0x69, 0x6e, 0x67,
+	0x75, 0x6c, 0x61, 0x72, 0x5f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x18, 0x64, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x67, 0x6f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2e,
+	0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x15, 0x73,
+	0x69, 0x6e, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x12, 0x5e, 0x0a, 0x14, 0x73, 0x69, 0x6e, 0x67, 0x75, 0x6c, 0x61, 0x72,
+	0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x65, 0x20, 0x01,
+	0x28, 0x0e, 0x32, 0x2c, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c,
+	0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d,
+	0x52, 0x12, 0x73, 0x69, 0x6e, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64,
+	0x45, 0x6e, 0x75, 0x6d, 0x12, 0x54, 0x0a, 0x15, 0x73, 0x69, 0x6e, 0x67, 0x75, 0x6c, 0x61, 0x72,
+	0x5f, 0x66, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x66, 0x20,
+	0x01, 0x28, 0x0e, 0x32, 0x20, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2e, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67,
+	0x6e, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x13, 0x73, 0x69, 0x6e, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x46,
+	0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x51, 0x0a, 0x14, 0x73, 0x69,
+	0x6e, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x5f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x65, 0x6e,
+	0x75, 0x6d, 0x18, 0x67, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1f, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2e, 0x49,
+	0x6d, 0x70, 0x6f, 0x72, 0x74, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x12, 0x73, 0x69, 0x6e, 0x67, 0x75,
+	0x6c, 0x61, 0x72, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x2a, 0x0a,
+	0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x05, 0x48, 0x01, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x88, 0x01, 0x01, 0x12, 0x2a, 0x0a, 0x0e, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x03, 0x48, 0x02, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x49, 0x6e, 0x74,
+	0x36, 0x34, 0x88, 0x01, 0x01, 0x12, 0x2c, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x48, 0x03,
+	0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32,
+	0x88, 0x01, 0x01, 0x12, 0x2c, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f,
+	0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x48, 0x04, 0x52, 0x0e,
+	0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x88, 0x01,
+	0x01, 0x12, 0x2c, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x69,
+	0x6e, 0x74, 0x33, 0x32, 0x18, 0x05, 0x20, 0x01, 0x28, 0x11, 0x48, 0x05, 0x52, 0x0e, 0x6f, 0x70,
+	0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x88, 0x01, 0x01, 0x12,
+	0x2c, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x69, 0x6e, 0x74,
+	0x36, 0x34, 0x18, 0x06, 0x20, 0x01, 0x28, 0x12, 0x48, 0x06, 0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x88, 0x01, 0x01, 0x12, 0x2e, 0x0a,
+	0x10, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33,
+	0x32, 0x18, 0x07, 0x20, 0x01, 0x28, 0x07, 0x48, 0x07, 0x52, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x88, 0x01, 0x01, 0x12, 0x2e, 0x0a,
+	0x10, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36,
+	0x34, 0x18, 0x08, 0x20, 0x01, 0x28, 0x06, 0x48, 0x08, 0x52, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x88, 0x01, 0x01, 0x12, 0x30, 0x0a,
+	0x11, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64,
+	0x33, 0x32, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0f, 0x48, 0x09, 0x52, 0x10, 0x6f, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x88, 0x01, 0x01, 0x12,
+	0x30, 0x0a, 0x11, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x66, 0x69, 0x78,
+	0x65, 0x64, 0x36, 0x34, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x10, 0x48, 0x0a, 0x52, 0x10, 0x6f, 0x70,
+	0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x88, 0x01,
+	0x01, 0x12, 0x2a, 0x0a, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x66, 0x6c,
+	0x6f, 0x61, 0x74, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x02, 0x48, 0x0b, 0x52, 0x0d, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x88, 0x01, 0x01, 0x12, 0x2c, 0x0a,
+	0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65,
+	0x18, 0x0c, 0x20, 0x01, 0x28, 0x01, 0x48, 0x0c, 0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+	0x61, 0x6c, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x88, 0x01, 0x01, 0x12, 0x28, 0x0a, 0x0d, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18, 0x0d, 0x20, 0x01,
+	0x28, 0x08, 0x48, 0x0d, 0x52, 0x0c, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x42, 0x6f,
+	0x6f, 0x6c, 0x88, 0x01, 0x01, 0x12, 0x2c, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x09, 0x48, 0x0e,
+	0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67,
+	0x88, 0x01, 0x01, 0x12, 0x2a, 0x0a, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f,
+	0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x0f, 0x52, 0x0d, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x42, 0x79, 0x74, 0x65, 0x73, 0x88, 0x01, 0x01, 0x12,
+	0x6c, 0x0a, 0x17, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x6e, 0x65, 0x73, 0x74,
+	0x65, 0x64, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x12, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x2f, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79,
+	0x70, 0x65, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x48, 0x10, 0x52, 0x15, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x4e, 0x65, 0x73,
+	0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x88, 0x01, 0x01, 0x12, 0x62, 0x0a,
+	0x18, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x66, 0x6f, 0x72, 0x65, 0x69, 0x67,
+	0x6e, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x13, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x23, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x74, 0x65, 0x73, 0x74, 0x33, 0x2e, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x48, 0x11, 0x52, 0x16, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x88, 0x01,
+	0x01, 0x12, 0x5f, 0x0a, 0x17, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x69, 0x6d,
+	0x70, 0x6f, 0x72, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x14, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x22, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2e, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x48, 0x12, 0x52, 0x15, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+	0x61, 0x6c, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x88,
+	0x01, 0x01, 0x12, 0x63, 0x0a, 0x14, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x6e,
+	0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x15, 0x20, 0x01, 0x28, 0x0e,
+	0x32, 0x2c, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79,
+	0x70, 0x65, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x48, 0x13,
+	0x52, 0x12, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64,
+	0x45, 0x6e, 0x75, 0x6d, 0x88, 0x01, 0x01, 0x12, 0x59, 0x0a, 0x15, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x5f, 0x66, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x5f, 0x65, 0x6e, 0x75, 0x6d,
+	0x18, 0x16, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x20, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2e, 0x46, 0x6f, 0x72,
+	0x65, 0x69, 0x67, 0x6e, 0x45, 0x6e, 0x75, 0x6d, 0x48, 0x14, 0x52, 0x13, 0x6f, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x61, 0x6c, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x45, 0x6e, 0x75, 0x6d, 0x88,
+	0x01, 0x01, 0x12, 0x56, 0x0a, 0x14, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x69,
+	0x6d, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x17, 0x20, 0x01, 0x28, 0x0e,
+	0x32, 0x1f, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2e, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x45, 0x6e, 0x75,
+	0x6d, 0x48, 0x15, 0x52, 0x12, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x49, 0x6d, 0x70,
+	0x6f, 0x72, 0x74, 0x45, 0x6e, 0x75, 0x6d, 0x88, 0x01, 0x01, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65,
+	0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x1f, 0x20, 0x03,
+	0x28, 0x05, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x49, 0x6e, 0x74, 0x33,
+	0x32, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x69, 0x6e,
+	0x74, 0x36, 0x34, 0x18, 0x20, 0x20, 0x03, 0x28, 0x03, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61,
+	0x74, 0x65, 0x64, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x70, 0x65,
+	0x61, 0x74, 0x65, 0x64, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x21, 0x20, 0x03, 0x28,
+	0x0d, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x55, 0x69, 0x6e, 0x74, 0x33,
+	0x32, 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x75, 0x69,
+	0x6e, 0x74, 0x36, 0x34, 0x18, 0x22, 0x20, 0x03, 0x28, 0x04, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65,
+	0x61, 0x74, 0x65, 0x64, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65,
+	0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x23, 0x20,
+	0x03, 0x28, 0x11, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x53, 0x69, 0x6e,
+	0x74, 0x33, 0x32, 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f,
+	0x73, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x24, 0x20, 0x03, 0x28, 0x12, 0x52, 0x0e, 0x72, 0x65,
+	0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x29, 0x0a, 0x10,
+	0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32,
+	0x18, 0x25, 0x20, 0x03, 0x28, 0x07, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
+	0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x29, 0x0a, 0x10, 0x72, 0x65, 0x70, 0x65, 0x61,
+	0x74, 0x65, 0x64, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x26, 0x20, 0x03, 0x28,
+	0x06, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x46, 0x69, 0x78, 0x65, 0x64,
+	0x36, 0x34, 0x12, 0x2b, 0x0a, 0x11, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x73,
+	0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x27, 0x20, 0x03, 0x28, 0x0f, 0x52, 0x10, 0x72,
+	0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12,
+	0x2b, 0x0a, 0x11, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x73, 0x66, 0x69, 0x78,
+	0x65, 0x64, 0x36, 0x34, 0x18, 0x28, 0x20, 0x03, 0x28, 0x10, 0x52, 0x10, 0x72, 0x65, 0x70, 0x65,
+	0x61, 0x74, 0x65, 0x64, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x25, 0x0a, 0x0e,
+	0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x18, 0x29,
+	0x20, 0x03, 0x28, 0x02, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x46, 0x6c,
+	0x6f, 0x61, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f,
+	0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0x2a, 0x20, 0x03, 0x28, 0x01, 0x52, 0x0e, 0x72, 0x65,
+	0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x23, 0x0a, 0x0d,
+	0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18, 0x2b, 0x20,
+	0x03, 0x28, 0x08, 0x52, 0x0c, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x42, 0x6f, 0x6f,
+	0x6c, 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x73, 0x74,
+	0x72, 0x69, 0x6e, 0x67, 0x18, 0x2c, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65,
+	0x61, 0x74, 0x65, 0x64, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65,
+	0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x2d, 0x20, 0x03,
+	0x28, 0x0c, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x42, 0x79, 0x74, 0x65,
+	0x73, 0x12, 0x67, 0x0a, 0x17, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x6e, 0x65,
+	0x73, 0x74, 0x65, 0x64, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x30, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c,
+	0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x52, 0x15, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x4e, 0x65, 0x73,
+	0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x5d, 0x0a, 0x18, 0x72, 0x65,
+	0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x66, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x31, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x67,
+	0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73,
+	0x74, 0x33, 0x2e, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x52, 0x16, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x46, 0x6f, 0x72, 0x65, 0x69,
+	0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x59, 0x0a, 0x16, 0x72, 0x65, 0x70,
+	0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x18, 0x32, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x67, 0x6f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2e,
+	0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x15, 0x72,
+	0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x12, 0x5e, 0x0a, 0x14, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
+	0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x33, 0x20, 0x03,
+	0x28, 0x0e, 0x32, 0x2c, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c,
+	0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d,
+	0x52, 0x12, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64,
+	0x45, 0x6e, 0x75, 0x6d, 0x12, 0x54, 0x0a, 0x15, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
+	0x5f, 0x66, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x34, 0x20,
+	0x03, 0x28, 0x0e, 0x32, 0x20, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2e, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67,
+	0x6e, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x13, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x46,
+	0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x50, 0x0a, 0x13, 0x72, 0x65,
+	0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x6e, 0x75,
+	0x6d, 0x18, 0x35, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x1f, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2e, 0x49, 0x6d,
+	0x70, 0x6f, 0x72, 0x74, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x12, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74,
+	0x65, 0x64, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x6e, 0x75, 0x6d, 0x12, 0x5c, 0x0a, 0x0f,
+	0x6d, 0x61, 0x70, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18,
+	0x38, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74,
+	0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x33,
+	0x32, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0d, 0x6d, 0x61, 0x70,
+	0x49, 0x6e, 0x74, 0x33, 0x32, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x5c, 0x0a, 0x0f, 0x6d, 0x61,
+	0x70, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x39, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c,
+	0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x49,
+	0x6e, 0x74, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0d, 0x6d, 0x61, 0x70, 0x49, 0x6e,
+	0x74, 0x36, 0x34, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x62, 0x0a, 0x11, 0x6d, 0x61, 0x70, 0x5f,
+	0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x3a, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c,
+	0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4d, 0x61, 0x70, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32,
+	0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x6d, 0x61, 0x70,
+	0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x62, 0x0a, 0x11,
+	0x6d, 0x61, 0x70, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36,
+	0x34, 0x18, 0x3b, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2e, 0x54, 0x65,
+	0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4d, 0x61, 0x70, 0x55, 0x69,
+	0x6e, 0x74, 0x36, 0x34, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52,
+	0x0f, 0x6d, 0x61, 0x70, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34,
+	0x12, 0x62, 0x0a, 0x11, 0x6d, 0x61, 0x70, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x73,
+	0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x3c, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x67, 0x6f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74,
+	0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4d,
+	0x61, 0x70, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x45, 0x6e,
+	0x74, 0x72, 0x79, 0x52, 0x0f, 0x6d, 0x61, 0x70, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x53, 0x69,
+	0x6e, 0x74, 0x33, 0x32, 0x12, 0x62, 0x0a, 0x11, 0x6d, 0x61, 0x70, 0x5f, 0x73, 0x69, 0x6e, 0x74,
+	0x36, 0x34, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x3d, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x36, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x74, 0x65, 0x73, 0x74, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70,
+	0x65, 0x73, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x53, 0x69, 0x6e, 0x74,
+	0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x6d, 0x61, 0x70, 0x53, 0x69, 0x6e, 0x74,
+	0x36, 0x34, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x68, 0x0a, 0x13, 0x6d, 0x61, 0x70, 0x5f,
+	0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18,
+	0x3e, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x38, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74,
+	0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4d, 0x61, 0x70, 0x46, 0x69, 0x78, 0x65,
+	0x64, 0x33, 0x32, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52,
+	0x11, 0x6d, 0x61, 0x70, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x46, 0x69, 0x78, 0x65, 0x64,
+	0x33, 0x32, 0x12, 0x68, 0x0a, 0x13, 0x6d, 0x61, 0x70, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36,
+	0x34, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x3f, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x38, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x74, 0x65, 0x73, 0x74, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70,
+	0x65, 0x73, 0x2e, 0x4d, 0x61, 0x70, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x46, 0x69, 0x78,
+	0x65, 0x64, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x11, 0x6d, 0x61, 0x70, 0x46, 0x69,
+	0x78, 0x65, 0x64, 0x36, 0x34, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x6e, 0x0a, 0x15,
+	0x6d, 0x61, 0x70, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x5f, 0x73, 0x66, 0x69,
+	0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x40, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3a, 0x2e, 0x67, 0x6f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74,
+	0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4d,
+	0x61, 0x70, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64,
+	0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x13, 0x6d, 0x61, 0x70, 0x53, 0x66, 0x69, 0x78,
+	0x65, 0x64, 0x33, 0x32, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x6e, 0x0a, 0x15,
+	0x6d, 0x61, 0x70, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x5f, 0x73, 0x66, 0x69,
+	0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x41, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3a, 0x2e, 0x67, 0x6f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74,
+	0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4d,
+	0x61, 0x70, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64,
+	0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x13, 0x6d, 0x61, 0x70, 0x53, 0x66, 0x69, 0x78,
+	0x65, 0x64, 0x36, 0x34, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x5c, 0x0a, 0x0f,
+	0x6d, 0x61, 0x70, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x18,
+	0x42, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74,
+	0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x33,
+	0x32, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0d, 0x6d, 0x61, 0x70,
+	0x49, 0x6e, 0x74, 0x33, 0x32, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x5f, 0x0a, 0x10, 0x6d, 0x61,
+	0x70, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0x43,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41,
+	0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x33, 0x32,
+	0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, 0x6d, 0x61, 0x70,
+	0x49, 0x6e, 0x74, 0x33, 0x32, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x56, 0x0a, 0x0d, 0x6d,
+	0x61, 0x70, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18, 0x44, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x32, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c,
+	0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4d, 0x61, 0x70, 0x42, 0x6f, 0x6f, 0x6c, 0x42, 0x6f, 0x6f,
+	0x6c, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0b, 0x6d, 0x61, 0x70, 0x42, 0x6f, 0x6f, 0x6c, 0x42,
+	0x6f, 0x6f, 0x6c, 0x12, 0x62, 0x0a, 0x11, 0x6d, 0x61, 0x70, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e,
+	0x67, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x45, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x36,
+	0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74,
+	0x65, 0x73, 0x74, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65,
+	0x73, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e,
+	0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x6d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e,
+	0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x5f, 0x0a, 0x10, 0x6d, 0x61, 0x70, 0x5f, 0x73,
+	0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x46, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x35, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54,
+	0x79, 0x70, 0x65, 0x73, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x79,
+	0x74, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, 0x6d, 0x61, 0x70, 0x53, 0x74, 0x72,
+	0x69, 0x6e, 0x67, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x78, 0x0a, 0x19, 0x6d, 0x61, 0x70, 0x5f,
+	0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x47, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3d, 0x2e, 0x67, 0x6f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74,
+	0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4d,
+	0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x16, 0x6d, 0x61, 0x70, 0x53,
+	0x74, 0x72, 0x69, 0x6e, 0x67, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x12, 0x6f, 0x0a, 0x16, 0x6d, 0x61, 0x70, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67,
+	0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x49, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x3a, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c,
+	0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x4e,
+	0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x13,
+	0x6d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45,
+	0x6e, 0x75, 0x6d, 0x12, 0x23, 0x0a, 0x0c, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x75, 0x69, 0x6e,
+	0x74, 0x33, 0x32, 0x18, 0x6f, 0x20, 0x01, 0x28, 0x0d, 0x48, 0x00, 0x52, 0x0b, 0x6f, 0x6e, 0x65,
+	0x6f, 0x66, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x63, 0x0a, 0x14, 0x6f, 0x6e, 0x65, 0x6f,
+	0x66, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x18, 0x70, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2e, 0x54, 0x65, 0x73,
+	0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x48, 0x00, 0x52, 0x12, 0x6f, 0x6e, 0x65, 0x6f, 0x66,
+	0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x23, 0x0a,
+	0x0c, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x71, 0x20,
+	0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x53, 0x74, 0x72, 0x69,
+	0x6e, 0x67, 0x12, 0x21, 0x0a, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x62, 0x79, 0x74, 0x65,
+	0x73, 0x18, 0x72, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x0a, 0x6f, 0x6e, 0x65, 0x6f, 0x66,
+	0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x1f, 0x0a, 0x0a, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x62,
+	0x6f, 0x6f, 0x6c, 0x18, 0x73, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x09, 0x6f, 0x6e, 0x65,
+	0x6f, 0x66, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x23, 0x0a, 0x0c, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f,
+	0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x74, 0x20, 0x01, 0x28, 0x04, 0x48, 0x00, 0x52, 0x0b,
+	0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x21, 0x0a, 0x0b, 0x6f,
+	0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x18, 0x75, 0x20, 0x01, 0x28, 0x02,
+	0x48, 0x00, 0x52, 0x0a, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x23,
+	0x0a, 0x0c, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0x76,
+	0x20, 0x01, 0x28, 0x01, 0x48, 0x00, 0x52, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x44, 0x6f, 0x75,
+	0x62, 0x6c, 0x65, 0x12, 0x4d, 0x0a, 0x0a, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x65, 0x6e, 0x75,
+	0x6d, 0x18, 0x77, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2c, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2e, 0x54, 0x65,
+	0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65,
+	0x64, 0x45, 0x6e, 0x75, 0x6d, 0x48, 0x00, 0x52, 0x09, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x45, 0x6e,
+	0x75, 0x6d, 0x1a, 0x62, 0x0a, 0x0d, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x12, 0x0c, 0x0a, 0x01, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x01,
+	0x61, 0x12, 0x43, 0x0a, 0x0b, 0x63, 0x6f, 0x72, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x76, 0x65,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2e, 0x54, 0x65, 0x73,
+	0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x52, 0x0b, 0x63, 0x6f, 0x72, 0x65, 0x63,
+	0x75, 0x72, 0x73, 0x69, 0x76, 0x65, 0x1a, 0x40, 0x0a, 0x12, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74,
+	0x33, 0x32, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03,
+	0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14,
+	0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x76,
+	0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x40, 0x0a, 0x12, 0x4d, 0x61, 0x70, 0x49,
+	0x6e, 0x74, 0x36, 0x34, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10,
+	0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79,
+	0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52,
+	0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x42, 0x0a, 0x14, 0x4d, 0x61,
+	0x70, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x45, 0x6e, 0x74,
+	0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52,
+	0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x0d, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x42,
+	0x0a, 0x14, 0x4d, 0x61, 0x70, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x55, 0x69, 0x6e, 0x74, 0x36,
+	0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x04, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75,
+	0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02,
+	0x38, 0x01, 0x1a, 0x42, 0x0a, 0x14, 0x4d, 0x61, 0x70, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x53,
+	0x69, 0x6e, 0x74, 0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65,
+	0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x11, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05,
+	0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x11, 0x52, 0x05, 0x76, 0x61, 0x6c,
+	0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x42, 0x0a, 0x14, 0x4d, 0x61, 0x70, 0x53, 0x69, 0x6e,
+	0x74, 0x36, 0x34, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10,
+	0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x12, 0x52, 0x03, 0x6b, 0x65, 0x79,
+	0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x12, 0x52,
+	0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x44, 0x0a, 0x16, 0x4d, 0x61,
+	0x70, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x45,
+	0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x07, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x07, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01,
+	0x1a, 0x44, 0x0a, 0x16, 0x4d, 0x61, 0x70, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x46, 0x69,
+	0x78, 0x65, 0x64, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65,
+	0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x06, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05,
+	0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x06, 0x52, 0x05, 0x76, 0x61, 0x6c,
+	0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x46, 0x0a, 0x18, 0x4d, 0x61, 0x70, 0x53, 0x66, 0x69,
+	0x78, 0x65, 0x64, 0x33, 0x32, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x45, 0x6e, 0x74,
+	0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0f, 0x52,
+	0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x0f, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x46,
+	0x0a, 0x18, 0x4d, 0x61, 0x70, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x53, 0x66, 0x69,
+	0x78, 0x65, 0x64, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65,
+	0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x10, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05,
+	0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x10, 0x52, 0x05, 0x76, 0x61, 0x6c,
+	0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x40, 0x0a, 0x12, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74,
+	0x33, 0x32, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03,
+	0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14,
+	0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x02, 0x52, 0x05, 0x76,
+	0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x41, 0x0a, 0x13, 0x4d, 0x61, 0x70, 0x49,
+	0x6e, 0x74, 0x33, 0x32, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12,
+	0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x6b, 0x65,
+	0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01,
+	0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x3e, 0x0a, 0x10, 0x4d,
+	0x61, 0x70, 0x42, 0x6f, 0x6f, 0x6c, 0x42, 0x6f, 0x6f, 0x6c, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12,
+	0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x03, 0x6b, 0x65,
+	0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x42, 0x0a, 0x14, 0x4d,
+	0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e,
+	0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a,
+	0x41, 0x0a, 0x13, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x79, 0x74, 0x65,
+	0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75,
+	0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02,
+	0x38, 0x01, 0x1a, 0x7a, 0x0a, 0x1b, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x4e,
+	0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x45, 0x6e, 0x74, 0x72,
+	0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03,
+	0x6b, 0x65, 0x79, 0x12, 0x45, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c,
+	0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x74,
+	0x0a, 0x18, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x4e, 0x65, 0x73, 0x74, 0x65,
+	0x64, 0x45, 0x6e, 0x75, 0x6d, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65,
+	0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x42, 0x0a, 0x05,
+	0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2c, 0x2e, 0x67, 0x6f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74,
+	0x33, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4e,
+	0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
+	0x3a, 0x02, 0x38, 0x01, 0x22, 0x39, 0x0a, 0x0a, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e,
+	0x75, 0x6d, 0x12, 0x07, 0x0a, 0x03, 0x46, 0x4f, 0x4f, 0x10, 0x00, 0x12, 0x07, 0x0a, 0x03, 0x42,
+	0x41, 0x52, 0x10, 0x01, 0x12, 0x07, 0x0a, 0x03, 0x42, 0x41, 0x5a, 0x10, 0x02, 0x12, 0x10, 0x0a,
+	0x03, 0x4e, 0x45, 0x47, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x42,
+	0x0d, 0x0a, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x42, 0x11,
+	0x0a, 0x0f, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x69, 0x6e, 0x74, 0x33,
+	0x32, 0x42, 0x11, 0x0a, 0x0f, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x69,
+	0x6e, 0x74, 0x36, 0x34, 0x42, 0x12, 0x0a, 0x10, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x42, 0x12, 0x0a, 0x10, 0x5f, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x42, 0x12, 0x0a, 0x10,
+	0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x33, 0x32,
+	0x42, 0x12, 0x0a, 0x10, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x69,
+	0x6e, 0x74, 0x36, 0x34, 0x42, 0x13, 0x0a, 0x11, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x42, 0x13, 0x0a, 0x11, 0x5f, 0x6f, 0x70,
+	0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x42, 0x14,
+	0x0a, 0x12, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x66, 0x69, 0x78,
+	0x65, 0x64, 0x33, 0x32, 0x42, 0x14, 0x0a, 0x12, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x42, 0x11, 0x0a, 0x0f, 0x5f, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x42, 0x12, 0x0a,
+	0x10, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c,
+	0x65, 0x42, 0x10, 0x0a, 0x0e, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x62,
+	0x6f, 0x6f, 0x6c, 0x42, 0x12, 0x0a, 0x10, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x11, 0x0a, 0x0f, 0x5f, 0x6f, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x42, 0x1a, 0x0a, 0x18, 0x5f, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x42, 0x1b, 0x0a, 0x19, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x5f, 0x66, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x5f, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x42, 0x1a, 0x0a, 0x18, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x5f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x42,
+	0x17, 0x0a, 0x15, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x6e, 0x65, 0x73,
+	0x74, 0x65, 0x64, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x42, 0x18, 0x0a, 0x16, 0x5f, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x66, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x5f, 0x65, 0x6e,
+	0x75, 0x6d, 0x42, 0x17, 0x0a, 0x15, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f,
+	0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x22, 0x2c, 0x0a, 0x0e, 0x46,
+	0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x0c, 0x0a,
+	0x01, 0x63, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x01, 0x63, 0x12, 0x0c, 0x0a, 0x01, 0x64,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x01, 0x64, 0x2a, 0x52, 0x0a, 0x0b, 0x46, 0x6f, 0x72,
+	0x65, 0x69, 0x67, 0x6e, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x10, 0x0a, 0x0c, 0x46, 0x4f, 0x52, 0x45,
+	0x49, 0x47, 0x4e, 0x5f, 0x5a, 0x45, 0x52, 0x4f, 0x10, 0x00, 0x12, 0x0f, 0x0a, 0x0b, 0x46, 0x4f,
+	0x52, 0x45, 0x49, 0x47, 0x4e, 0x5f, 0x46, 0x4f, 0x4f, 0x10, 0x04, 0x12, 0x0f, 0x0a, 0x0b, 0x46,
+	0x4f, 0x52, 0x45, 0x49, 0x47, 0x4e, 0x5f, 0x42, 0x41, 0x52, 0x10, 0x05, 0x12, 0x0f, 0x0a, 0x0b,
+	0x46, 0x4f, 0x52, 0x45, 0x49, 0x47, 0x4e, 0x5f, 0x42, 0x41, 0x5a, 0x10, 0x06, 0x42, 0x36, 0x5a,
+	0x34, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f,
+	0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x69, 0x6e, 0x74, 0x65,
+	0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f,
+	0x74, 0x65, 0x73, 0x74, 0x33, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_internal_testprotos_test3_test_proto_rawDescOnce sync.Once
+	file_internal_testprotos_test3_test_proto_rawDescData = file_internal_testprotos_test3_test_proto_rawDesc
+)
+
+func file_internal_testprotos_test3_test_proto_rawDescGZIP() []byte {
+	file_internal_testprotos_test3_test_proto_rawDescOnce.Do(func() {
+		file_internal_testprotos_test3_test_proto_rawDescData = protoimpl.X.CompressGZIP(file_internal_testprotos_test3_test_proto_rawDescData)
+	})
+	return file_internal_testprotos_test3_test_proto_rawDescData
+}
+
+var file_internal_testprotos_test3_test_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
+var file_internal_testprotos_test3_test_proto_msgTypes = make([]protoimpl.MessageInfo, 20)
+var file_internal_testprotos_test3_test_proto_goTypes = []interface{}{
+	(ForeignEnum)(0),                   // 0: goproto.proto.test3.ForeignEnum
+	(TestAllTypes_NestedEnum)(0),       // 1: goproto.proto.test3.TestAllTypes.NestedEnum
+	(*TestAllTypes)(nil),               // 2: goproto.proto.test3.TestAllTypes
+	(*ForeignMessage)(nil),             // 3: goproto.proto.test3.ForeignMessage
+	(*TestAllTypes_NestedMessage)(nil), // 4: goproto.proto.test3.TestAllTypes.NestedMessage
+	nil,                                // 5: goproto.proto.test3.TestAllTypes.MapInt32Int32Entry
+	nil,                                // 6: goproto.proto.test3.TestAllTypes.MapInt64Int64Entry
+	nil,                                // 7: goproto.proto.test3.TestAllTypes.MapUint32Uint32Entry
+	nil,                                // 8: goproto.proto.test3.TestAllTypes.MapUint64Uint64Entry
+	nil,                                // 9: goproto.proto.test3.TestAllTypes.MapSint32Sint32Entry
+	nil,                                // 10: goproto.proto.test3.TestAllTypes.MapSint64Sint64Entry
+	nil,                                // 11: goproto.proto.test3.TestAllTypes.MapFixed32Fixed32Entry
+	nil,                                // 12: goproto.proto.test3.TestAllTypes.MapFixed64Fixed64Entry
+	nil,                                // 13: goproto.proto.test3.TestAllTypes.MapSfixed32Sfixed32Entry
+	nil,                                // 14: goproto.proto.test3.TestAllTypes.MapSfixed64Sfixed64Entry
+	nil,                                // 15: goproto.proto.test3.TestAllTypes.MapInt32FloatEntry
+	nil,                                // 16: goproto.proto.test3.TestAllTypes.MapInt32DoubleEntry
+	nil,                                // 17: goproto.proto.test3.TestAllTypes.MapBoolBoolEntry
+	nil,                                // 18: goproto.proto.test3.TestAllTypes.MapStringStringEntry
+	nil,                                // 19: goproto.proto.test3.TestAllTypes.MapStringBytesEntry
+	nil,                                // 20: goproto.proto.test3.TestAllTypes.MapStringNestedMessageEntry
+	nil,                                // 21: goproto.proto.test3.TestAllTypes.MapStringNestedEnumEntry
+	(*ImportMessage)(nil),              // 22: goproto.proto.test3.ImportMessage
+	(ImportEnum)(0),                    // 23: goproto.proto.test3.ImportEnum
+}
+var file_internal_testprotos_test3_test_proto_depIdxs = []int32{
+	4,  // 0: goproto.proto.test3.TestAllTypes.singular_nested_message:type_name -> goproto.proto.test3.TestAllTypes.NestedMessage
+	3,  // 1: goproto.proto.test3.TestAllTypes.singular_foreign_message:type_name -> goproto.proto.test3.ForeignMessage
+	22, // 2: goproto.proto.test3.TestAllTypes.singular_import_message:type_name -> goproto.proto.test3.ImportMessage
+	1,  // 3: goproto.proto.test3.TestAllTypes.singular_nested_enum:type_name -> goproto.proto.test3.TestAllTypes.NestedEnum
+	0,  // 4: goproto.proto.test3.TestAllTypes.singular_foreign_enum:type_name -> goproto.proto.test3.ForeignEnum
+	23, // 5: goproto.proto.test3.TestAllTypes.singular_import_enum:type_name -> goproto.proto.test3.ImportEnum
+	4,  // 6: goproto.proto.test3.TestAllTypes.optional_nested_message:type_name -> goproto.proto.test3.TestAllTypes.NestedMessage
+	3,  // 7: goproto.proto.test3.TestAllTypes.optional_foreign_message:type_name -> goproto.proto.test3.ForeignMessage
+	22, // 8: goproto.proto.test3.TestAllTypes.optional_import_message:type_name -> goproto.proto.test3.ImportMessage
+	1,  // 9: goproto.proto.test3.TestAllTypes.optional_nested_enum:type_name -> goproto.proto.test3.TestAllTypes.NestedEnum
+	0,  // 10: goproto.proto.test3.TestAllTypes.optional_foreign_enum:type_name -> goproto.proto.test3.ForeignEnum
+	23, // 11: goproto.proto.test3.TestAllTypes.optional_import_enum:type_name -> goproto.proto.test3.ImportEnum
+	4,  // 12: goproto.proto.test3.TestAllTypes.repeated_nested_message:type_name -> goproto.proto.test3.TestAllTypes.NestedMessage
+	3,  // 13: goproto.proto.test3.TestAllTypes.repeated_foreign_message:type_name -> goproto.proto.test3.ForeignMessage
+	22, // 14: goproto.proto.test3.TestAllTypes.repeated_importmessage:type_name -> goproto.proto.test3.ImportMessage
+	1,  // 15: goproto.proto.test3.TestAllTypes.repeated_nested_enum:type_name -> goproto.proto.test3.TestAllTypes.NestedEnum
+	0,  // 16: goproto.proto.test3.TestAllTypes.repeated_foreign_enum:type_name -> goproto.proto.test3.ForeignEnum
+	23, // 17: goproto.proto.test3.TestAllTypes.repeated_importenum:type_name -> goproto.proto.test3.ImportEnum
+	5,  // 18: goproto.proto.test3.TestAllTypes.map_int32_int32:type_name -> goproto.proto.test3.TestAllTypes.MapInt32Int32Entry
+	6,  // 19: goproto.proto.test3.TestAllTypes.map_int64_int64:type_name -> goproto.proto.test3.TestAllTypes.MapInt64Int64Entry
+	7,  // 20: goproto.proto.test3.TestAllTypes.map_uint32_uint32:type_name -> goproto.proto.test3.TestAllTypes.MapUint32Uint32Entry
+	8,  // 21: goproto.proto.test3.TestAllTypes.map_uint64_uint64:type_name -> goproto.proto.test3.TestAllTypes.MapUint64Uint64Entry
+	9,  // 22: goproto.proto.test3.TestAllTypes.map_sint32_sint32:type_name -> goproto.proto.test3.TestAllTypes.MapSint32Sint32Entry
+	10, // 23: goproto.proto.test3.TestAllTypes.map_sint64_sint64:type_name -> goproto.proto.test3.TestAllTypes.MapSint64Sint64Entry
+	11, // 24: goproto.proto.test3.TestAllTypes.map_fixed32_fixed32:type_name -> goproto.proto.test3.TestAllTypes.MapFixed32Fixed32Entry
+	12, // 25: goproto.proto.test3.TestAllTypes.map_fixed64_fixed64:type_name -> goproto.proto.test3.TestAllTypes.MapFixed64Fixed64Entry
+	13, // 26: goproto.proto.test3.TestAllTypes.map_sfixed32_sfixed32:type_name -> goproto.proto.test3.TestAllTypes.MapSfixed32Sfixed32Entry
+	14, // 27: goproto.proto.test3.TestAllTypes.map_sfixed64_sfixed64:type_name -> goproto.proto.test3.TestAllTypes.MapSfixed64Sfixed64Entry
+	15, // 28: goproto.proto.test3.TestAllTypes.map_int32_float:type_name -> goproto.proto.test3.TestAllTypes.MapInt32FloatEntry
+	16, // 29: goproto.proto.test3.TestAllTypes.map_int32_double:type_name -> goproto.proto.test3.TestAllTypes.MapInt32DoubleEntry
+	17, // 30: goproto.proto.test3.TestAllTypes.map_bool_bool:type_name -> goproto.proto.test3.TestAllTypes.MapBoolBoolEntry
+	18, // 31: goproto.proto.test3.TestAllTypes.map_string_string:type_name -> goproto.proto.test3.TestAllTypes.MapStringStringEntry
+	19, // 32: goproto.proto.test3.TestAllTypes.map_string_bytes:type_name -> goproto.proto.test3.TestAllTypes.MapStringBytesEntry
+	20, // 33: goproto.proto.test3.TestAllTypes.map_string_nested_message:type_name -> goproto.proto.test3.TestAllTypes.MapStringNestedMessageEntry
+	21, // 34: goproto.proto.test3.TestAllTypes.map_string_nested_enum:type_name -> goproto.proto.test3.TestAllTypes.MapStringNestedEnumEntry
+	4,  // 35: goproto.proto.test3.TestAllTypes.oneof_nested_message:type_name -> goproto.proto.test3.TestAllTypes.NestedMessage
+	1,  // 36: goproto.proto.test3.TestAllTypes.oneof_enum:type_name -> goproto.proto.test3.TestAllTypes.NestedEnum
+	2,  // 37: goproto.proto.test3.TestAllTypes.NestedMessage.corecursive:type_name -> goproto.proto.test3.TestAllTypes
+	4,  // 38: goproto.proto.test3.TestAllTypes.MapStringNestedMessageEntry.value:type_name -> goproto.proto.test3.TestAllTypes.NestedMessage
+	1,  // 39: goproto.proto.test3.TestAllTypes.MapStringNestedEnumEntry.value:type_name -> goproto.proto.test3.TestAllTypes.NestedEnum
+	40, // [40:40] is the sub-list for method output_type
+	40, // [40:40] is the sub-list for method input_type
+	40, // [40:40] is the sub-list for extension type_name
+	40, // [40:40] is the sub-list for extension extendee
+	0,  // [0:40] is the sub-list for field type_name
+}
+
+func init() { file_internal_testprotos_test3_test_proto_init() }
+func file_internal_testprotos_test3_test_proto_init() {
+	if File_internal_testprotos_test3_test_proto != nil {
+		return
+	}
+	file_internal_testprotos_test3_test_import_proto_init()
+	if !protoimpl.UnsafeEnabled {
+		file_internal_testprotos_test3_test_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*TestAllTypes); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_test3_test_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ForeignMessage); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_test3_test_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*TestAllTypes_NestedMessage); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	file_internal_testprotos_test3_test_proto_msgTypes[0].OneofWrappers = []interface{}{
+		(*TestAllTypes_OneofUint32)(nil),
+		(*TestAllTypes_OneofNestedMessage)(nil),
+		(*TestAllTypes_OneofString)(nil),
+		(*TestAllTypes_OneofBytes)(nil),
+		(*TestAllTypes_OneofBool)(nil),
+		(*TestAllTypes_OneofUint64)(nil),
+		(*TestAllTypes_OneofFloat)(nil),
+		(*TestAllTypes_OneofDouble)(nil),
+		(*TestAllTypes_OneofEnum)(nil),
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_internal_testprotos_test3_test_proto_rawDesc,
+			NumEnums:      2,
+			NumMessages:   20,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_internal_testprotos_test3_test_proto_goTypes,
+		DependencyIndexes: file_internal_testprotos_test3_test_proto_depIdxs,
+		EnumInfos:         file_internal_testprotos_test3_test_proto_enumTypes,
+		MessageInfos:      file_internal_testprotos_test3_test_proto_msgTypes,
+	}.Build()
+	File_internal_testprotos_test3_test_proto = out.File
+	file_internal_testprotos_test3_test_proto_rawDesc = nil
+	file_internal_testprotos_test3_test_proto_goTypes = nil
+	file_internal_testprotos_test3_test_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/test3/test.proto b/vendor/google.golang.org/protobuf/internal/testprotos/test3/test.proto
new file mode 100644
index 000000000..4d9a63c78
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/test3/test.proto
@@ -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.
+
+syntax = "proto3";
+
+package goproto.proto.test3;
+
+import "internal/testprotos/test3/test_import.proto";
+
+option go_package = "google.golang.org/protobuf/internal/testprotos/test3";
+
+message TestAllTypes {
+  message NestedMessage {
+    int32 a = 1;
+    TestAllTypes corecursive = 2;
+  }
+
+  enum NestedEnum {
+    FOO = 0;
+    BAR = 1;
+    BAZ = 2;
+    NEG = -1;  // Intentionally negative.
+  }
+
+  int32         singular_int32    = 81;
+  int64         singular_int64    = 82;
+  uint32        singular_uint32   = 83;
+  uint64        singular_uint64   = 84;
+  sint32        singular_sint32   = 85;
+  sint64        singular_sint64   = 86;
+  fixed32       singular_fixed32  = 87;
+  fixed64       singular_fixed64  = 88;
+  sfixed32      singular_sfixed32 = 89;
+  sfixed64      singular_sfixed64 = 90;
+  float         singular_float    = 91;
+  double        singular_double   = 92;
+  bool          singular_bool     = 93;
+  string        singular_string   = 94;
+  bytes         singular_bytes    = 95;
+  NestedMessage  singular_nested_message  = 98;
+  ForeignMessage singular_foreign_message = 99;
+  ImportMessage  singular_import_message  = 100;
+  NestedEnum     singular_nested_enum     = 101;
+  ForeignEnum    singular_foreign_enum    = 102;
+  ImportEnum     singular_import_enum     = 103;
+
+  optional int32         optional_int32    =  1;
+  optional int64         optional_int64    =  2;
+  optional uint32        optional_uint32   =  3;
+  optional uint64        optional_uint64   =  4;
+  optional sint32        optional_sint32   =  5;
+  optional sint64        optional_sint64   =  6;
+  optional fixed32       optional_fixed32  =  7;
+  optional fixed64       optional_fixed64  =  8;
+  optional sfixed32      optional_sfixed32 =  9;
+  optional sfixed64      optional_sfixed64 = 10;
+  optional float         optional_float    = 11;
+  optional double        optional_double   = 12;
+  optional bool          optional_bool     = 13;
+  optional string        optional_string   = 14;
+  optional bytes         optional_bytes    = 15;
+  optional NestedMessage  optional_nested_message  = 18;
+  optional ForeignMessage optional_foreign_message = 19;
+  optional ImportMessage  optional_import_message  = 20;
+  optional NestedEnum     optional_nested_enum     = 21;
+  optional ForeignEnum    optional_foreign_enum    = 22;
+  optional ImportEnum     optional_import_enum     = 23;
+
+  repeated int32         repeated_int32    = 31;
+  repeated int64         repeated_int64    = 32;
+  repeated uint32        repeated_uint32   = 33;
+  repeated uint64        repeated_uint64   = 34;
+  repeated sint32        repeated_sint32   = 35;
+  repeated sint64        repeated_sint64   = 36;
+  repeated fixed32       repeated_fixed32  = 37;
+  repeated fixed64       repeated_fixed64  = 38;
+  repeated sfixed32      repeated_sfixed32 = 39;
+  repeated sfixed64      repeated_sfixed64 = 40;
+  repeated float         repeated_float    = 41;
+  repeated double        repeated_double   = 42;
+  repeated bool          repeated_bool     = 43;
+  repeated string        repeated_string   = 44;
+  repeated bytes         repeated_bytes    = 45;
+  repeated NestedMessage  repeated_nested_message  = 48;
+  repeated ForeignMessage repeated_foreign_message = 49;
+  repeated ImportMessage  repeated_importmessage   = 50;
+  repeated NestedEnum     repeated_nested_enum     = 51;
+  repeated ForeignEnum    repeated_foreign_enum    = 52;
+  repeated ImportEnum     repeated_importenum      = 53;
+
+  map <   int32, int32>         map_int32_int32           = 56;
+  map <   int64, int64>         map_int64_int64           = 57;
+  map <  uint32, uint32>        map_uint32_uint32         = 58;
+  map <  uint64, uint64>        map_uint64_uint64         = 59;
+  map <  sint32, sint32>        map_sint32_sint32         = 60;
+  map <  sint64, sint64>        map_sint64_sint64         = 61;
+  map < fixed32, fixed32>       map_fixed32_fixed32       = 62;
+  map < fixed64, fixed64>       map_fixed64_fixed64       = 63;
+  map <sfixed32, sfixed32>      map_sfixed32_sfixed32     = 64;
+  map <sfixed64, sfixed64>      map_sfixed64_sfixed64     = 65;
+  map <   int32, float>         map_int32_float           = 66;
+  map <   int32, double>        map_int32_double          = 67;
+  map <    bool, bool>          map_bool_bool             = 68;
+  map <  string, string>        map_string_string         = 69;
+  map <  string, bytes>         map_string_bytes          = 70;
+  map <  string, NestedMessage> map_string_nested_message = 71;
+  map <  string, NestedEnum>    map_string_nested_enum    = 73;
+
+  oneof oneof_field {
+    uint32        oneof_uint32         = 111;
+    NestedMessage oneof_nested_message = 112;
+    string        oneof_string         = 113;
+    bytes         oneof_bytes          = 114;
+    bool          oneof_bool           = 115;
+    uint64        oneof_uint64         = 116;
+    float         oneof_float          = 117;
+    double        oneof_double         = 118;
+    NestedEnum    oneof_enum           = 119;
+  }
+}
+
+message ForeignMessage {
+  int32 c = 1;
+  int32 d = 2;
+}
+
+enum ForeignEnum {
+  FOREIGN_ZERO = 0;
+  FOREIGN_FOO = 4;
+  FOREIGN_BAR = 5;
+  FOREIGN_BAZ = 6;
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/test3/test_extension.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/test3/test_extension.pb.go
new file mode 100644
index 000000000..3105af820
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/test3/test_extension.pb.go
@@ -0,0 +1,650 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: internal/testprotos/test3/test_extension.proto
+
+package test3
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	descriptorpb "google.golang.org/protobuf/types/descriptorpb"
+	reflect "reflect"
+)
+
+var file_internal_testprotos_test3_test_extension_proto_extTypes = []protoimpl.ExtensionInfo{
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*int32)(nil),
+		Field:         1001,
+		Name:          "goproto.proto.test3.optional_int32",
+		Tag:           "varint,1001,opt,name=optional_int32",
+		Filename:      "internal/testprotos/test3/test_extension.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*int64)(nil),
+		Field:         1002,
+		Name:          "goproto.proto.test3.optional_int64",
+		Tag:           "varint,1002,opt,name=optional_int64",
+		Filename:      "internal/testprotos/test3/test_extension.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*uint32)(nil),
+		Field:         1003,
+		Name:          "goproto.proto.test3.optional_uint32",
+		Tag:           "varint,1003,opt,name=optional_uint32",
+		Filename:      "internal/testprotos/test3/test_extension.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*uint64)(nil),
+		Field:         1004,
+		Name:          "goproto.proto.test3.optional_uint64",
+		Tag:           "varint,1004,opt,name=optional_uint64",
+		Filename:      "internal/testprotos/test3/test_extension.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*int32)(nil),
+		Field:         1005,
+		Name:          "goproto.proto.test3.optional_sint32",
+		Tag:           "zigzag32,1005,opt,name=optional_sint32",
+		Filename:      "internal/testprotos/test3/test_extension.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*int64)(nil),
+		Field:         1006,
+		Name:          "goproto.proto.test3.optional_sint64",
+		Tag:           "zigzag64,1006,opt,name=optional_sint64",
+		Filename:      "internal/testprotos/test3/test_extension.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*uint32)(nil),
+		Field:         1007,
+		Name:          "goproto.proto.test3.optional_fixed32",
+		Tag:           "fixed32,1007,opt,name=optional_fixed32",
+		Filename:      "internal/testprotos/test3/test_extension.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*uint64)(nil),
+		Field:         1008,
+		Name:          "goproto.proto.test3.optional_fixed64",
+		Tag:           "fixed64,1008,opt,name=optional_fixed64",
+		Filename:      "internal/testprotos/test3/test_extension.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*int32)(nil),
+		Field:         1009,
+		Name:          "goproto.proto.test3.optional_sfixed32",
+		Tag:           "fixed32,1009,opt,name=optional_sfixed32",
+		Filename:      "internal/testprotos/test3/test_extension.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*int64)(nil),
+		Field:         1010,
+		Name:          "goproto.proto.test3.optional_sfixed64",
+		Tag:           "fixed64,1010,opt,name=optional_sfixed64",
+		Filename:      "internal/testprotos/test3/test_extension.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*float32)(nil),
+		Field:         1011,
+		Name:          "goproto.proto.test3.optional_float",
+		Tag:           "fixed32,1011,opt,name=optional_float",
+		Filename:      "internal/testprotos/test3/test_extension.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*float64)(nil),
+		Field:         1012,
+		Name:          "goproto.proto.test3.optional_double",
+		Tag:           "fixed64,1012,opt,name=optional_double",
+		Filename:      "internal/testprotos/test3/test_extension.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*bool)(nil),
+		Field:         1013,
+		Name:          "goproto.proto.test3.optional_bool",
+		Tag:           "varint,1013,opt,name=optional_bool",
+		Filename:      "internal/testprotos/test3/test_extension.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*string)(nil),
+		Field:         1014,
+		Name:          "goproto.proto.test3.optional_string",
+		Tag:           "bytes,1014,opt,name=optional_string",
+		Filename:      "internal/testprotos/test3/test_extension.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: ([]byte)(nil),
+		Field:         1015,
+		Name:          "goproto.proto.test3.optional_bytes",
+		Tag:           "bytes,1015,opt,name=optional_bytes",
+		Filename:      "internal/testprotos/test3/test_extension.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*ForeignMessage)(nil),
+		Field:         1016,
+		Name:          "goproto.proto.test3.optional_foreign_message",
+		Tag:           "bytes,1016,opt,name=optional_foreign_message",
+		Filename:      "internal/testprotos/test3/test_extension.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*ForeignEnum)(nil),
+		Field:         1017,
+		Name:          "goproto.proto.test3.optional_foreign_enum",
+		Tag:           "varint,1017,opt,name=optional_foreign_enum,enum=goproto.proto.test3.ForeignEnum",
+		Filename:      "internal/testprotos/test3/test_extension.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*int32)(nil),
+		Field:         2001,
+		Name:          "goproto.proto.test3.optional_optional_int32",
+		Tag:           "varint,2001,opt,name=optional_optional_int32",
+		Filename:      "internal/testprotos/test3/test_extension.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*int64)(nil),
+		Field:         2002,
+		Name:          "goproto.proto.test3.optional_optional_int64",
+		Tag:           "varint,2002,opt,name=optional_optional_int64",
+		Filename:      "internal/testprotos/test3/test_extension.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*uint32)(nil),
+		Field:         2003,
+		Name:          "goproto.proto.test3.optional_optional_uint32",
+		Tag:           "varint,2003,opt,name=optional_optional_uint32",
+		Filename:      "internal/testprotos/test3/test_extension.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*uint64)(nil),
+		Field:         2004,
+		Name:          "goproto.proto.test3.optional_optional_uint64",
+		Tag:           "varint,2004,opt,name=optional_optional_uint64",
+		Filename:      "internal/testprotos/test3/test_extension.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*int32)(nil),
+		Field:         2005,
+		Name:          "goproto.proto.test3.optional_optional_sint32",
+		Tag:           "zigzag32,2005,opt,name=optional_optional_sint32",
+		Filename:      "internal/testprotos/test3/test_extension.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*int64)(nil),
+		Field:         2006,
+		Name:          "goproto.proto.test3.optional_optional_sint64",
+		Tag:           "zigzag64,2006,opt,name=optional_optional_sint64",
+		Filename:      "internal/testprotos/test3/test_extension.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*uint32)(nil),
+		Field:         2007,
+		Name:          "goproto.proto.test3.optional_optional_fixed32",
+		Tag:           "fixed32,2007,opt,name=optional_optional_fixed32",
+		Filename:      "internal/testprotos/test3/test_extension.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*uint64)(nil),
+		Field:         2008,
+		Name:          "goproto.proto.test3.optional_optional_fixed64",
+		Tag:           "fixed64,2008,opt,name=optional_optional_fixed64",
+		Filename:      "internal/testprotos/test3/test_extension.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*int32)(nil),
+		Field:         2009,
+		Name:          "goproto.proto.test3.optional_optional_sfixed32",
+		Tag:           "fixed32,2009,opt,name=optional_optional_sfixed32",
+		Filename:      "internal/testprotos/test3/test_extension.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*int64)(nil),
+		Field:         2010,
+		Name:          "goproto.proto.test3.optional_optional_sfixed64",
+		Tag:           "fixed64,2010,opt,name=optional_optional_sfixed64",
+		Filename:      "internal/testprotos/test3/test_extension.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*float32)(nil),
+		Field:         2011,
+		Name:          "goproto.proto.test3.optional_optional_float",
+		Tag:           "fixed32,2011,opt,name=optional_optional_float",
+		Filename:      "internal/testprotos/test3/test_extension.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*float64)(nil),
+		Field:         2012,
+		Name:          "goproto.proto.test3.optional_optional_double",
+		Tag:           "fixed64,2012,opt,name=optional_optional_double",
+		Filename:      "internal/testprotos/test3/test_extension.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*bool)(nil),
+		Field:         2013,
+		Name:          "goproto.proto.test3.optional_optional_bool",
+		Tag:           "varint,2013,opt,name=optional_optional_bool",
+		Filename:      "internal/testprotos/test3/test_extension.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*string)(nil),
+		Field:         2014,
+		Name:          "goproto.proto.test3.optional_optional_string",
+		Tag:           "bytes,2014,opt,name=optional_optional_string",
+		Filename:      "internal/testprotos/test3/test_extension.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: ([]byte)(nil),
+		Field:         2015,
+		Name:          "goproto.proto.test3.optional_optional_bytes",
+		Tag:           "bytes,2015,opt,name=optional_optional_bytes",
+		Filename:      "internal/testprotos/test3/test_extension.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*ForeignMessage)(nil),
+		Field:         2016,
+		Name:          "goproto.proto.test3.optional_optional_foreign_message",
+		Tag:           "bytes,2016,opt,name=optional_optional_foreign_message",
+		Filename:      "internal/testprotos/test3/test_extension.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*ForeignEnum)(nil),
+		Field:         2017,
+		Name:          "goproto.proto.test3.optional_optional_foreign_enum",
+		Tag:           "varint,2017,opt,name=optional_optional_foreign_enum,enum=goproto.proto.test3.ForeignEnum",
+		Filename:      "internal/testprotos/test3/test_extension.proto",
+	},
+}
+
+// Extension fields to descriptorpb.MessageOptions.
+var (
+	// optional int32 optional_int32 = 1001;
+	E_OptionalInt32 = &file_internal_testprotos_test3_test_extension_proto_extTypes[0]
+	// optional int64 optional_int64 = 1002;
+	E_OptionalInt64 = &file_internal_testprotos_test3_test_extension_proto_extTypes[1]
+	// optional uint32 optional_uint32 = 1003;
+	E_OptionalUint32 = &file_internal_testprotos_test3_test_extension_proto_extTypes[2]
+	// optional uint64 optional_uint64 = 1004;
+	E_OptionalUint64 = &file_internal_testprotos_test3_test_extension_proto_extTypes[3]
+	// optional sint32 optional_sint32 = 1005;
+	E_OptionalSint32 = &file_internal_testprotos_test3_test_extension_proto_extTypes[4]
+	// optional sint64 optional_sint64 = 1006;
+	E_OptionalSint64 = &file_internal_testprotos_test3_test_extension_proto_extTypes[5]
+	// optional fixed32 optional_fixed32 = 1007;
+	E_OptionalFixed32 = &file_internal_testprotos_test3_test_extension_proto_extTypes[6]
+	// optional fixed64 optional_fixed64 = 1008;
+	E_OptionalFixed64 = &file_internal_testprotos_test3_test_extension_proto_extTypes[7]
+	// optional sfixed32 optional_sfixed32 = 1009;
+	E_OptionalSfixed32 = &file_internal_testprotos_test3_test_extension_proto_extTypes[8]
+	// optional sfixed64 optional_sfixed64 = 1010;
+	E_OptionalSfixed64 = &file_internal_testprotos_test3_test_extension_proto_extTypes[9]
+	// optional float optional_float = 1011;
+	E_OptionalFloat = &file_internal_testprotos_test3_test_extension_proto_extTypes[10]
+	// optional double optional_double = 1012;
+	E_OptionalDouble = &file_internal_testprotos_test3_test_extension_proto_extTypes[11]
+	// optional bool optional_bool = 1013;
+	E_OptionalBool = &file_internal_testprotos_test3_test_extension_proto_extTypes[12]
+	// optional string optional_string = 1014;
+	E_OptionalString = &file_internal_testprotos_test3_test_extension_proto_extTypes[13]
+	// optional bytes optional_bytes = 1015;
+	E_OptionalBytes = &file_internal_testprotos_test3_test_extension_proto_extTypes[14]
+	// optional goproto.proto.test3.ForeignMessage optional_foreign_message = 1016;
+	E_OptionalForeignMessage = &file_internal_testprotos_test3_test_extension_proto_extTypes[15]
+	// optional goproto.proto.test3.ForeignEnum optional_foreign_enum = 1017;
+	E_OptionalForeignEnum = &file_internal_testprotos_test3_test_extension_proto_extTypes[16]
+	// optional int32 optional_optional_int32 = 2001;
+	E_OptionalOptionalInt32 = &file_internal_testprotos_test3_test_extension_proto_extTypes[17]
+	// optional int64 optional_optional_int64 = 2002;
+	E_OptionalOptionalInt64 = &file_internal_testprotos_test3_test_extension_proto_extTypes[18]
+	// optional uint32 optional_optional_uint32 = 2003;
+	E_OptionalOptionalUint32 = &file_internal_testprotos_test3_test_extension_proto_extTypes[19]
+	// optional uint64 optional_optional_uint64 = 2004;
+	E_OptionalOptionalUint64 = &file_internal_testprotos_test3_test_extension_proto_extTypes[20]
+	// optional sint32 optional_optional_sint32 = 2005;
+	E_OptionalOptionalSint32 = &file_internal_testprotos_test3_test_extension_proto_extTypes[21]
+	// optional sint64 optional_optional_sint64 = 2006;
+	E_OptionalOptionalSint64 = &file_internal_testprotos_test3_test_extension_proto_extTypes[22]
+	// optional fixed32 optional_optional_fixed32 = 2007;
+	E_OptionalOptionalFixed32 = &file_internal_testprotos_test3_test_extension_proto_extTypes[23]
+	// optional fixed64 optional_optional_fixed64 = 2008;
+	E_OptionalOptionalFixed64 = &file_internal_testprotos_test3_test_extension_proto_extTypes[24]
+	// optional sfixed32 optional_optional_sfixed32 = 2009;
+	E_OptionalOptionalSfixed32 = &file_internal_testprotos_test3_test_extension_proto_extTypes[25]
+	// optional sfixed64 optional_optional_sfixed64 = 2010;
+	E_OptionalOptionalSfixed64 = &file_internal_testprotos_test3_test_extension_proto_extTypes[26]
+	// optional float optional_optional_float = 2011;
+	E_OptionalOptionalFloat = &file_internal_testprotos_test3_test_extension_proto_extTypes[27]
+	// optional double optional_optional_double = 2012;
+	E_OptionalOptionalDouble = &file_internal_testprotos_test3_test_extension_proto_extTypes[28]
+	// optional bool optional_optional_bool = 2013;
+	E_OptionalOptionalBool = &file_internal_testprotos_test3_test_extension_proto_extTypes[29]
+	// optional string optional_optional_string = 2014;
+	E_OptionalOptionalString = &file_internal_testprotos_test3_test_extension_proto_extTypes[30]
+	// optional bytes optional_optional_bytes = 2015;
+	E_OptionalOptionalBytes = &file_internal_testprotos_test3_test_extension_proto_extTypes[31]
+	// optional goproto.proto.test3.ForeignMessage optional_optional_foreign_message = 2016;
+	E_OptionalOptionalForeignMessage = &file_internal_testprotos_test3_test_extension_proto_extTypes[32]
+	// optional goproto.proto.test3.ForeignEnum optional_optional_foreign_enum = 2017;
+	E_OptionalOptionalForeignEnum = &file_internal_testprotos_test3_test_extension_proto_extTypes[33]
+)
+
+var File_internal_testprotos_test3_test_extension_proto protoreflect.FileDescriptor
+
+var file_internal_testprotos_test3_test_extension_proto_rawDesc = []byte{
+	0x0a, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2f, 0x74, 0x65, 0x73, 0x74,
+	0x5f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x12, 0x13, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x74, 0x65, 0x73, 0x74, 0x33, 0x1a, 0x20, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f,
+	0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x24, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61,
+	0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x74, 0x65, 0x73,
+	0x74, 0x33, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x3a, 0x47, 0x0a,
+	0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12,
+	0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73,
+	0x18, 0xe9, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x3a, 0x47, 0x0a, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+	0x61, 0x6c, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xea, 0x07, 0x20, 0x01, 0x28, 0x03,
+	0x52, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x3a,
+	0x49, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x75, 0x69, 0x6e, 0x74,
+	0x33, 0x32, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x73, 0x18, 0xeb, 0x07, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x61, 0x6c, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x3a, 0x49, 0x0a, 0x0f, 0x6f, 0x70,
+	0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x1f, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xec,
+	0x07, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x55,
+	0x69, 0x6e, 0x74, 0x36, 0x34, 0x3a, 0x49, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xed, 0x07, 0x20, 0x01, 0x28, 0x11,
+	0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32,
+	0x3a, 0x49, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x69, 0x6e,
+	0x74, 0x36, 0x34, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x73, 0x18, 0xee, 0x07, 0x20, 0x01, 0x28, 0x12, 0x52, 0x0e, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x3a, 0x4b, 0x0a, 0x10, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12,
+	0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73,
+	0x18, 0xef, 0x07, 0x20, 0x01, 0x28, 0x07, 0x52, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x3a, 0x4b, 0x0a, 0x10, 0x6f, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x1f, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xf0, 0x07,
+	0x20, 0x01, 0x28, 0x06, 0x52, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x46, 0x69,
+	0x78, 0x65, 0x64, 0x36, 0x34, 0x3a, 0x4d, 0x0a, 0x11, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xf1, 0x07, 0x20, 0x01,
+	0x28, 0x0f, 0x52, 0x10, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x66, 0x69, 0x78,
+	0x65, 0x64, 0x33, 0x32, 0x3a, 0x4d, 0x0a, 0x11, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xf2, 0x07, 0x20, 0x01, 0x28,
+	0x10, 0x52, 0x10, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x66, 0x69, 0x78, 0x65,
+	0x64, 0x36, 0x34, 0x3a, 0x47, 0x0a, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f,
+	0x66, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xf3, 0x07, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0d, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x3a, 0x49, 0x0a, 0x0f,
+	0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12,
+	0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73,
+	0x18, 0xf4, 0x07, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x3a, 0x45, 0x0a, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xf5, 0x07, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x0c, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x42, 0x6f, 0x6f, 0x6c, 0x3a, 0x49,
+	0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e,
+	0x67, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x73, 0x18, 0xf6, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3a, 0x47, 0x0a, 0x0e, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x12, 0x1f, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xf7, 0x07, 0x20,
+	0x01, 0x28, 0x0c, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x42, 0x79, 0x74,
+	0x65, 0x73, 0x3a, 0x7f, 0x0a, 0x18, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x66,
+	0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x1f,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18,
+	0xf8, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2e, 0x46, 0x6f, 0x72,
+	0x65, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x16, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x3a, 0x76, 0x0a, 0x15, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f,
+	0x66, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x12, 0x1f, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xf9, 0x07,
+	0x20, 0x01, 0x28, 0x0e, 0x32, 0x20, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2e, 0x46, 0x6f, 0x72, 0x65, 0x69,
+	0x67, 0x6e, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x13, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x45, 0x6e, 0x75, 0x6d, 0x3a, 0x5b, 0x0a, 0x17, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xd1, 0x0f, 0x20, 0x01, 0x28, 0x05, 0x52, 0x15,
+	0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x49, 0x6e, 0x74, 0x33, 0x32, 0x88, 0x01, 0x01, 0x3a, 0x5b, 0x0a, 0x17, 0x6f, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x69, 0x6e,
+	0x74, 0x36, 0x34, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x73, 0x18, 0xd2, 0x0f, 0x20, 0x01, 0x28, 0x03, 0x52, 0x15, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x49, 0x6e, 0x74,
+	0x36, 0x34, 0x88, 0x01, 0x01, 0x3a, 0x5d, 0x0a, 0x18, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33,
+	0x32, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x73, 0x18, 0xd3, 0x0f, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x16, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x55, 0x69, 0x6e, 0x74, 0x33,
+	0x32, 0x88, 0x01, 0x01, 0x3a, 0x5d, 0x0a, 0x18, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34,
+	0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
+	0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+	0x73, 0x18, 0xd4, 0x0f, 0x20, 0x01, 0x28, 0x04, 0x52, 0x16, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+	0x61, 0x6c, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34,
+	0x88, 0x01, 0x01, 0x3a, 0x5d, 0x0a, 0x18, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f,
+	0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12,
+	0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73,
+	0x18, 0xd5, 0x0f, 0x20, 0x01, 0x28, 0x11, 0x52, 0x16, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x88,
+	0x01, 0x01, 0x3a, 0x5d, 0x0a, 0x18, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x1f,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18,
+	0xd6, 0x0f, 0x20, 0x01, 0x28, 0x12, 0x52, 0x16, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x88, 0x01,
+	0x01, 0x3a, 0x5f, 0x0a, 0x19, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x6f, 0x70,
+	0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x1f,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
+	0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18,
+	0xd7, 0x0f, 0x20, 0x01, 0x28, 0x07, 0x52, 0x17, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x88,
+	0x01, 0x01, 0x3a, 0x5f, 0x0a, 0x19, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12,
+	0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73,
+	0x18, 0xd8, 0x0f, 0x20, 0x01, 0x28, 0x06, 0x52, 0x17, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34,
+	0x88, 0x01, 0x01, 0x3a, 0x61, 0x0a, 0x1a, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f,
+	0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33,
+	0x32, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x73, 0x18, 0xd9, 0x0f, 0x20, 0x01, 0x28, 0x0f, 0x52, 0x18, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x66, 0x69, 0x78, 0x65,
+	0x64, 0x33, 0x32, 0x88, 0x01, 0x01, 0x3a, 0x61, 0x0a, 0x1a, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+	0x61, 0x6c, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x66, 0x69, 0x78,
+	0x65, 0x64, 0x36, 0x34, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70,
+	0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xda, 0x0f, 0x20, 0x01, 0x28, 0x10, 0x52, 0x18, 0x6f, 0x70,
+	0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x66,
+	0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x88, 0x01, 0x01, 0x3a, 0x5b, 0x0a, 0x17, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x66,
+	0x6c, 0x6f, 0x61, 0x74, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70,
+	0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xdb, 0x0f, 0x20, 0x01, 0x28, 0x02, 0x52, 0x15, 0x6f, 0x70,
+	0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x46, 0x6c,
+	0x6f, 0x61, 0x74, 0x88, 0x01, 0x01, 0x3a, 0x5d, 0x0a, 0x18, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+	0x61, 0x6c, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x64, 0x6f, 0x75, 0x62,
+	0x6c, 0x65, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x73, 0x18, 0xdc, 0x0f, 0x20, 0x01, 0x28, 0x01, 0x52, 0x16, 0x6f, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x61, 0x6c, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x44, 0x6f, 0x75, 0x62,
+	0x6c, 0x65, 0x88, 0x01, 0x01, 0x3a, 0x59, 0x0a, 0x16, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x12,
+	0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73,
+	0x18, 0xdd, 0x0f, 0x20, 0x01, 0x28, 0x08, 0x52, 0x14, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x42, 0x6f, 0x6f, 0x6c, 0x88, 0x01, 0x01,
+	0x3a, 0x5d, 0x0a, 0x18, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x1f, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xde, 0x0f,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x16, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x4f, 0x70,
+	0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x88, 0x01, 0x01, 0x3a,
+	0x5b, 0x0a, 0x17, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x6f, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xdf, 0x0f, 0x20, 0x01,
+	0x28, 0x0c, 0x52, 0x15, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x4f, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x61, 0x6c, 0x42, 0x79, 0x74, 0x65, 0x73, 0x88, 0x01, 0x01, 0x3a, 0x93, 0x01, 0x0a,
+	0x21, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+	0x61, 0x6c, 0x5f, 0x66, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x73, 0x18, 0xe0, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x67, 0x6f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x33,
+	0x2e, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
+	0x1e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x88,
+	0x01, 0x01, 0x3a, 0x8a, 0x01, 0x0a, 0x1e, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f,
+	0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x66, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e,
+	0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xe1, 0x0f, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x20, 0x2e,
+	0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65,
+	0x73, 0x74, 0x33, 0x2e, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x45, 0x6e, 0x75, 0x6d, 0x52,
+	0x1b, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x45, 0x6e, 0x75, 0x6d, 0x88, 0x01, 0x01, 0x42,
+	0x36, 0x5a, 0x34, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67,
+	0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x69, 0x6e,
+	0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x73, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x33, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var file_internal_testprotos_test3_test_extension_proto_goTypes = []interface{}{
+	(*descriptorpb.MessageOptions)(nil), // 0: google.protobuf.MessageOptions
+	(*ForeignMessage)(nil),              // 1: goproto.proto.test3.ForeignMessage
+	(ForeignEnum)(0),                    // 2: goproto.proto.test3.ForeignEnum
+}
+var file_internal_testprotos_test3_test_extension_proto_depIdxs = []int32{
+	0,  // 0: goproto.proto.test3.optional_int32:extendee -> google.protobuf.MessageOptions
+	0,  // 1: goproto.proto.test3.optional_int64:extendee -> google.protobuf.MessageOptions
+	0,  // 2: goproto.proto.test3.optional_uint32:extendee -> google.protobuf.MessageOptions
+	0,  // 3: goproto.proto.test3.optional_uint64:extendee -> google.protobuf.MessageOptions
+	0,  // 4: goproto.proto.test3.optional_sint32:extendee -> google.protobuf.MessageOptions
+	0,  // 5: goproto.proto.test3.optional_sint64:extendee -> google.protobuf.MessageOptions
+	0,  // 6: goproto.proto.test3.optional_fixed32:extendee -> google.protobuf.MessageOptions
+	0,  // 7: goproto.proto.test3.optional_fixed64:extendee -> google.protobuf.MessageOptions
+	0,  // 8: goproto.proto.test3.optional_sfixed32:extendee -> google.protobuf.MessageOptions
+	0,  // 9: goproto.proto.test3.optional_sfixed64:extendee -> google.protobuf.MessageOptions
+	0,  // 10: goproto.proto.test3.optional_float:extendee -> google.protobuf.MessageOptions
+	0,  // 11: goproto.proto.test3.optional_double:extendee -> google.protobuf.MessageOptions
+	0,  // 12: goproto.proto.test3.optional_bool:extendee -> google.protobuf.MessageOptions
+	0,  // 13: goproto.proto.test3.optional_string:extendee -> google.protobuf.MessageOptions
+	0,  // 14: goproto.proto.test3.optional_bytes:extendee -> google.protobuf.MessageOptions
+	0,  // 15: goproto.proto.test3.optional_foreign_message:extendee -> google.protobuf.MessageOptions
+	0,  // 16: goproto.proto.test3.optional_foreign_enum:extendee -> google.protobuf.MessageOptions
+	0,  // 17: goproto.proto.test3.optional_optional_int32:extendee -> google.protobuf.MessageOptions
+	0,  // 18: goproto.proto.test3.optional_optional_int64:extendee -> google.protobuf.MessageOptions
+	0,  // 19: goproto.proto.test3.optional_optional_uint32:extendee -> google.protobuf.MessageOptions
+	0,  // 20: goproto.proto.test3.optional_optional_uint64:extendee -> google.protobuf.MessageOptions
+	0,  // 21: goproto.proto.test3.optional_optional_sint32:extendee -> google.protobuf.MessageOptions
+	0,  // 22: goproto.proto.test3.optional_optional_sint64:extendee -> google.protobuf.MessageOptions
+	0,  // 23: goproto.proto.test3.optional_optional_fixed32:extendee -> google.protobuf.MessageOptions
+	0,  // 24: goproto.proto.test3.optional_optional_fixed64:extendee -> google.protobuf.MessageOptions
+	0,  // 25: goproto.proto.test3.optional_optional_sfixed32:extendee -> google.protobuf.MessageOptions
+	0,  // 26: goproto.proto.test3.optional_optional_sfixed64:extendee -> google.protobuf.MessageOptions
+	0,  // 27: goproto.proto.test3.optional_optional_float:extendee -> google.protobuf.MessageOptions
+	0,  // 28: goproto.proto.test3.optional_optional_double:extendee -> google.protobuf.MessageOptions
+	0,  // 29: goproto.proto.test3.optional_optional_bool:extendee -> google.protobuf.MessageOptions
+	0,  // 30: goproto.proto.test3.optional_optional_string:extendee -> google.protobuf.MessageOptions
+	0,  // 31: goproto.proto.test3.optional_optional_bytes:extendee -> google.protobuf.MessageOptions
+	0,  // 32: goproto.proto.test3.optional_optional_foreign_message:extendee -> google.protobuf.MessageOptions
+	0,  // 33: goproto.proto.test3.optional_optional_foreign_enum:extendee -> google.protobuf.MessageOptions
+	1,  // 34: goproto.proto.test3.optional_foreign_message:type_name -> goproto.proto.test3.ForeignMessage
+	2,  // 35: goproto.proto.test3.optional_foreign_enum:type_name -> goproto.proto.test3.ForeignEnum
+	1,  // 36: goproto.proto.test3.optional_optional_foreign_message:type_name -> goproto.proto.test3.ForeignMessage
+	2,  // 37: goproto.proto.test3.optional_optional_foreign_enum:type_name -> goproto.proto.test3.ForeignEnum
+	38, // [38:38] is the sub-list for method output_type
+	38, // [38:38] is the sub-list for method input_type
+	34, // [34:38] is the sub-list for extension type_name
+	0,  // [0:34] is the sub-list for extension extendee
+	0,  // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_internal_testprotos_test3_test_extension_proto_init() }
+func file_internal_testprotos_test3_test_extension_proto_init() {
+	if File_internal_testprotos_test3_test_extension_proto != nil {
+		return
+	}
+	file_internal_testprotos_test3_test_proto_init()
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_internal_testprotos_test3_test_extension_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   0,
+			NumExtensions: 34,
+			NumServices:   0,
+		},
+		GoTypes:           file_internal_testprotos_test3_test_extension_proto_goTypes,
+		DependencyIndexes: file_internal_testprotos_test3_test_extension_proto_depIdxs,
+		ExtensionInfos:    file_internal_testprotos_test3_test_extension_proto_extTypes,
+	}.Build()
+	File_internal_testprotos_test3_test_extension_proto = out.File
+	file_internal_testprotos_test3_test_extension_proto_rawDesc = nil
+	file_internal_testprotos_test3_test_extension_proto_goTypes = nil
+	file_internal_testprotos_test3_test_extension_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/test3/test_extension.proto b/vendor/google.golang.org/protobuf/internal/testprotos/test3/test_extension.proto
new file mode 100644
index 000000000..18a83819b
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/test3/test_extension.proto
@@ -0,0 +1,50 @@
+// 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.
+
+syntax = "proto3";
+
+package goproto.proto.test3;
+
+import "google/protobuf/descriptor.proto";
+import "internal/testprotos/test3/test.proto";
+
+option go_package = "google.golang.org/protobuf/internal/testprotos/test3";
+
+extend google.protobuf.MessageOptions {
+  int32         optional_int32    = 1001;
+  int64         optional_int64    = 1002;
+  uint32        optional_uint32   = 1003;
+  uint64        optional_uint64   = 1004;
+  sint32        optional_sint32   = 1005;
+  sint64        optional_sint64   = 1006;
+  fixed32       optional_fixed32  = 1007;
+  fixed64       optional_fixed64  = 1008;
+  sfixed32      optional_sfixed32 = 1009;
+  sfixed64      optional_sfixed64 = 1010;
+  float         optional_float    = 1011;
+  double        optional_double   = 1012;
+  bool          optional_bool     = 1013;
+  string        optional_string   = 1014;
+  bytes         optional_bytes    = 1015;
+  ForeignMessage optional_foreign_message = 1016;
+  ForeignEnum    optional_foreign_enum    = 1017;
+
+  optional int32         optional_optional_int32    = 2001;
+  optional int64         optional_optional_int64    = 2002;
+  optional uint32        optional_optional_uint32   = 2003;
+  optional uint64        optional_optional_uint64   = 2004;
+  optional sint32        optional_optional_sint32   = 2005;
+  optional sint64        optional_optional_sint64   = 2006;
+  optional fixed32       optional_optional_fixed32  = 2007;
+  optional fixed64       optional_optional_fixed64  = 2008;
+  optional sfixed32      optional_optional_sfixed32 = 2009;
+  optional sfixed64      optional_optional_sfixed64 = 2010;
+  optional float         optional_optional_float    = 2011;
+  optional double        optional_optional_double   = 2012;
+  optional bool          optional_optional_bool     = 2013;
+  optional string        optional_optional_string   = 2014;
+  optional bytes         optional_optional_bytes    = 2015;
+  optional ForeignMessage optional_optional_foreign_message = 2016;
+  optional ForeignEnum    optional_optional_foreign_enum    = 2017;
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/test3/test_import.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/test3/test_import.pb.go
new file mode 100644
index 000000000..5fc60438b
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/test3/test_import.pb.go
@@ -0,0 +1,179 @@
+// 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.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: internal/testprotos/test3/test_import.proto
+
+package test3
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type ImportEnum int32
+
+const (
+	ImportEnum_IMPORT_ZERO ImportEnum = 0
+)
+
+// Enum value maps for ImportEnum.
+var (
+	ImportEnum_name = map[int32]string{
+		0: "IMPORT_ZERO",
+	}
+	ImportEnum_value = map[string]int32{
+		"IMPORT_ZERO": 0,
+	}
+)
+
+func (x ImportEnum) Enum() *ImportEnum {
+	p := new(ImportEnum)
+	*p = x
+	return p
+}
+
+func (x ImportEnum) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (ImportEnum) Descriptor() protoreflect.EnumDescriptor {
+	return file_internal_testprotos_test3_test_import_proto_enumTypes[0].Descriptor()
+}
+
+func (ImportEnum) Type() protoreflect.EnumType {
+	return &file_internal_testprotos_test3_test_import_proto_enumTypes[0]
+}
+
+func (x ImportEnum) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use ImportEnum.Descriptor instead.
+func (ImportEnum) EnumDescriptor() ([]byte, []int) {
+	return file_internal_testprotos_test3_test_import_proto_rawDescGZIP(), []int{0}
+}
+
+type ImportMessage struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *ImportMessage) Reset() {
+	*x = ImportMessage{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_test3_test_import_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *ImportMessage) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ImportMessage) ProtoMessage() {}
+
+func (x *ImportMessage) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_test3_test_import_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ImportMessage.ProtoReflect.Descriptor instead.
+func (*ImportMessage) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_test3_test_import_proto_rawDescGZIP(), []int{0}
+}
+
+var File_internal_testprotos_test3_test_import_proto protoreflect.FileDescriptor
+
+var file_internal_testprotos_test3_test_import_proto_rawDesc = []byte{
+	0x0a, 0x2b, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x33, 0x2f, 0x74, 0x65, 0x73, 0x74,
+	0x5f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x13, 0x67,
+	0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x65, 0x73,
+	0x74, 0x33, 0x22, 0x0f, 0x0a, 0x0d, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x2a, 0x1d, 0x0a, 0x0a, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x45, 0x6e, 0x75,
+	0x6d, 0x12, 0x0f, 0x0a, 0x0b, 0x49, 0x4d, 0x50, 0x4f, 0x52, 0x54, 0x5f, 0x5a, 0x45, 0x52, 0x4f,
+	0x10, 0x00, 0x42, 0x36, 0x5a, 0x34, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c,
+	0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
+	0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x33, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x33,
+}
+
+var (
+	file_internal_testprotos_test3_test_import_proto_rawDescOnce sync.Once
+	file_internal_testprotos_test3_test_import_proto_rawDescData = file_internal_testprotos_test3_test_import_proto_rawDesc
+)
+
+func file_internal_testprotos_test3_test_import_proto_rawDescGZIP() []byte {
+	file_internal_testprotos_test3_test_import_proto_rawDescOnce.Do(func() {
+		file_internal_testprotos_test3_test_import_proto_rawDescData = protoimpl.X.CompressGZIP(file_internal_testprotos_test3_test_import_proto_rawDescData)
+	})
+	return file_internal_testprotos_test3_test_import_proto_rawDescData
+}
+
+var file_internal_testprotos_test3_test_import_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
+var file_internal_testprotos_test3_test_import_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_internal_testprotos_test3_test_import_proto_goTypes = []interface{}{
+	(ImportEnum)(0),       // 0: goproto.proto.test3.ImportEnum
+	(*ImportMessage)(nil), // 1: goproto.proto.test3.ImportMessage
+}
+var file_internal_testprotos_test3_test_import_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_internal_testprotos_test3_test_import_proto_init() }
+func file_internal_testprotos_test3_test_import_proto_init() {
+	if File_internal_testprotos_test3_test_import_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_internal_testprotos_test3_test_import_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ImportMessage); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_internal_testprotos_test3_test_import_proto_rawDesc,
+			NumEnums:      1,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_internal_testprotos_test3_test_import_proto_goTypes,
+		DependencyIndexes: file_internal_testprotos_test3_test_import_proto_depIdxs,
+		EnumInfos:         file_internal_testprotos_test3_test_import_proto_enumTypes,
+		MessageInfos:      file_internal_testprotos_test3_test_import_proto_msgTypes,
+	}.Build()
+	File_internal_testprotos_test3_test_import_proto = out.File
+	file_internal_testprotos_test3_test_import_proto_rawDesc = nil
+	file_internal_testprotos_test3_test_import_proto_goTypes = nil
+	file_internal_testprotos_test3_test_import_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/test3/test_import.proto b/vendor/google.golang.org/protobuf/internal/testprotos/test3/test_import.proto
new file mode 100644
index 000000000..d639bd3d9
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/test3/test_import.proto
@@ -0,0 +1,16 @@
+// 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.
+
+syntax = "proto3";
+
+package goproto.proto.test3;
+
+option go_package = "google.golang.org/protobuf/internal/testprotos/test3";
+
+message ImportMessage {
+}
+
+enum ImportEnum {
+ IMPORT_ZERO = 0;
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/textpb2/test.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/textpb2/test.pb.go
new file mode 100644
index 000000000..8bda835c4
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/textpb2/test.pb.go
@@ -0,0 +1,2603 @@
+// Copyright 2019 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.
+
+// Test Protobuf definitions with proto2 syntax.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: internal/testprotos/textpb2/test.proto
+
+package textpb2
+
+import (
+	fieldmaskpb "google.golang.org/protobuf/internal/testprotos/fieldmaskpb"
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoiface "google.golang.org/protobuf/runtime/protoiface"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	anypb "google.golang.org/protobuf/types/known/anypb"
+	durationpb "google.golang.org/protobuf/types/known/durationpb"
+	emptypb "google.golang.org/protobuf/types/known/emptypb"
+	structpb "google.golang.org/protobuf/types/known/structpb"
+	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
+	wrapperspb "google.golang.org/protobuf/types/known/wrapperspb"
+	reflect "reflect"
+	sync "sync"
+)
+
+type Enum int32
+
+const (
+	Enum_ONE Enum = 1
+	Enum_TWO Enum = 2
+	Enum_TEN Enum = 10
+)
+
+// Enum value maps for Enum.
+var (
+	Enum_name = map[int32]string{
+		1:  "ONE",
+		2:  "TWO",
+		10: "TEN",
+	}
+	Enum_value = map[string]int32{
+		"ONE": 1,
+		"TWO": 2,
+		"TEN": 10,
+	}
+)
+
+func (x Enum) Enum() *Enum {
+	p := new(Enum)
+	*p = x
+	return p
+}
+
+func (x Enum) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum) Descriptor() protoreflect.EnumDescriptor {
+	return file_internal_testprotos_textpb2_test_proto_enumTypes[0].Descriptor()
+}
+
+func (Enum) Type() protoreflect.EnumType {
+	return &file_internal_testprotos_textpb2_test_proto_enumTypes[0]
+}
+
+func (x Enum) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enum) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enum(num)
+	return nil
+}
+
+// Deprecated: Use Enum.Descriptor instead.
+func (Enum) EnumDescriptor() ([]byte, []int) {
+	return file_internal_testprotos_textpb2_test_proto_rawDescGZIP(), []int{0}
+}
+
+type Enums_NestedEnum int32
+
+const (
+	Enums_UNO  Enums_NestedEnum = 1
+	Enums_DOS  Enums_NestedEnum = 2
+	Enums_DIEZ Enums_NestedEnum = 10
+)
+
+// Enum value maps for Enums_NestedEnum.
+var (
+	Enums_NestedEnum_name = map[int32]string{
+		1:  "UNO",
+		2:  "DOS",
+		10: "DIEZ",
+	}
+	Enums_NestedEnum_value = map[string]int32{
+		"UNO":  1,
+		"DOS":  2,
+		"DIEZ": 10,
+	}
+)
+
+func (x Enums_NestedEnum) Enum() *Enums_NestedEnum {
+	p := new(Enums_NestedEnum)
+	*p = x
+	return p
+}
+
+func (x Enums_NestedEnum) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enums_NestedEnum) Descriptor() protoreflect.EnumDescriptor {
+	return file_internal_testprotos_textpb2_test_proto_enumTypes[1].Descriptor()
+}
+
+func (Enums_NestedEnum) Type() protoreflect.EnumType {
+	return &file_internal_testprotos_textpb2_test_proto_enumTypes[1]
+}
+
+func (x Enums_NestedEnum) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Enums_NestedEnum) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Enums_NestedEnum(num)
+	return nil
+}
+
+// Deprecated: Use Enums_NestedEnum.Descriptor instead.
+func (Enums_NestedEnum) EnumDescriptor() ([]byte, []int) {
+	return file_internal_testprotos_textpb2_test_proto_rawDescGZIP(), []int{1, 0}
+}
+
+// Scalars contains optional scalar fields.
+type Scalars struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	OptBool     *bool    `protobuf:"varint,1,opt,name=opt_bool,json=optBool" json:"opt_bool,omitempty"`
+	OptInt32    *int32   `protobuf:"varint,2,opt,name=opt_int32,json=optInt32" json:"opt_int32,omitempty"`
+	OptInt64    *int64   `protobuf:"varint,3,opt,name=opt_int64,json=optInt64" json:"opt_int64,omitempty"`
+	OptUint32   *uint32  `protobuf:"varint,4,opt,name=opt_uint32,json=optUint32" json:"opt_uint32,omitempty"`
+	OptUint64   *uint64  `protobuf:"varint,5,opt,name=opt_uint64,json=optUint64" json:"opt_uint64,omitempty"`
+	OptSint32   *int32   `protobuf:"zigzag32,6,opt,name=opt_sint32,json=optSint32" json:"opt_sint32,omitempty"`
+	OptSint64   *int64   `protobuf:"zigzag64,7,opt,name=opt_sint64,json=optSint64" json:"opt_sint64,omitempty"`
+	OptFixed32  *uint32  `protobuf:"fixed32,8,opt,name=opt_fixed32,json=optFixed32" json:"opt_fixed32,omitempty"`
+	OptFixed64  *uint64  `protobuf:"fixed64,9,opt,name=opt_fixed64,json=optFixed64" json:"opt_fixed64,omitempty"`
+	OptSfixed32 *int32   `protobuf:"fixed32,10,opt,name=opt_sfixed32,json=optSfixed32" json:"opt_sfixed32,omitempty"`
+	OptSfixed64 *int64   `protobuf:"fixed64,11,opt,name=opt_sfixed64,json=optSfixed64" json:"opt_sfixed64,omitempty"`
+	OptFloat    *float32 `protobuf:"fixed32,20,opt,name=opt_float,json=optFloat" json:"opt_float,omitempty"`
+	OptDouble   *float64 `protobuf:"fixed64,21,opt,name=opt_double,json=optDouble" json:"opt_double,omitempty"`
+	OptBytes    []byte   `protobuf:"bytes,14,opt,name=opt_bytes,json=optBytes" json:"opt_bytes,omitempty"`
+	OptString   *string  `protobuf:"bytes,13,opt,name=opt_string,json=optString" json:"opt_string,omitempty"`
+}
+
+func (x *Scalars) Reset() {
+	*x = Scalars{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Scalars) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Scalars) ProtoMessage() {}
+
+func (x *Scalars) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Scalars.ProtoReflect.Descriptor instead.
+func (*Scalars) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_textpb2_test_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Scalars) GetOptBool() bool {
+	if x != nil && x.OptBool != nil {
+		return *x.OptBool
+	}
+	return false
+}
+
+func (x *Scalars) GetOptInt32() int32 {
+	if x != nil && x.OptInt32 != nil {
+		return *x.OptInt32
+	}
+	return 0
+}
+
+func (x *Scalars) GetOptInt64() int64 {
+	if x != nil && x.OptInt64 != nil {
+		return *x.OptInt64
+	}
+	return 0
+}
+
+func (x *Scalars) GetOptUint32() uint32 {
+	if x != nil && x.OptUint32 != nil {
+		return *x.OptUint32
+	}
+	return 0
+}
+
+func (x *Scalars) GetOptUint64() uint64 {
+	if x != nil && x.OptUint64 != nil {
+		return *x.OptUint64
+	}
+	return 0
+}
+
+func (x *Scalars) GetOptSint32() int32 {
+	if x != nil && x.OptSint32 != nil {
+		return *x.OptSint32
+	}
+	return 0
+}
+
+func (x *Scalars) GetOptSint64() int64 {
+	if x != nil && x.OptSint64 != nil {
+		return *x.OptSint64
+	}
+	return 0
+}
+
+func (x *Scalars) GetOptFixed32() uint32 {
+	if x != nil && x.OptFixed32 != nil {
+		return *x.OptFixed32
+	}
+	return 0
+}
+
+func (x *Scalars) GetOptFixed64() uint64 {
+	if x != nil && x.OptFixed64 != nil {
+		return *x.OptFixed64
+	}
+	return 0
+}
+
+func (x *Scalars) GetOptSfixed32() int32 {
+	if x != nil && x.OptSfixed32 != nil {
+		return *x.OptSfixed32
+	}
+	return 0
+}
+
+func (x *Scalars) GetOptSfixed64() int64 {
+	if x != nil && x.OptSfixed64 != nil {
+		return *x.OptSfixed64
+	}
+	return 0
+}
+
+func (x *Scalars) GetOptFloat() float32 {
+	if x != nil && x.OptFloat != nil {
+		return *x.OptFloat
+	}
+	return 0
+}
+
+func (x *Scalars) GetOptDouble() float64 {
+	if x != nil && x.OptDouble != nil {
+		return *x.OptDouble
+	}
+	return 0
+}
+
+func (x *Scalars) GetOptBytes() []byte {
+	if x != nil {
+		return x.OptBytes
+	}
+	return nil
+}
+
+func (x *Scalars) GetOptString() string {
+	if x != nil && x.OptString != nil {
+		return *x.OptString
+	}
+	return ""
+}
+
+// Message contains enum fields.
+type Enums struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	OptEnum       *Enum              `protobuf:"varint,1,opt,name=opt_enum,json=optEnum,enum=pb2.Enum" json:"opt_enum,omitempty"`
+	RptEnum       []Enum             `protobuf:"varint,2,rep,name=rpt_enum,json=rptEnum,enum=pb2.Enum" json:"rpt_enum,omitempty"`
+	OptNestedEnum *Enums_NestedEnum  `protobuf:"varint,3,opt,name=opt_nested_enum,json=optNestedEnum,enum=pb2.Enums_NestedEnum" json:"opt_nested_enum,omitempty"`
+	RptNestedEnum []Enums_NestedEnum `protobuf:"varint,4,rep,name=rpt_nested_enum,json=rptNestedEnum,enum=pb2.Enums_NestedEnum" json:"rpt_nested_enum,omitempty"`
+}
+
+func (x *Enums) Reset() {
+	*x = Enums{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Enums) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Enums) ProtoMessage() {}
+
+func (x *Enums) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Enums.ProtoReflect.Descriptor instead.
+func (*Enums) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_textpb2_test_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *Enums) GetOptEnum() Enum {
+	if x != nil && x.OptEnum != nil {
+		return *x.OptEnum
+	}
+	return Enum_ONE
+}
+
+func (x *Enums) GetRptEnum() []Enum {
+	if x != nil {
+		return x.RptEnum
+	}
+	return nil
+}
+
+func (x *Enums) GetOptNestedEnum() Enums_NestedEnum {
+	if x != nil && x.OptNestedEnum != nil {
+		return *x.OptNestedEnum
+	}
+	return Enums_UNO
+}
+
+func (x *Enums) GetRptNestedEnum() []Enums_NestedEnum {
+	if x != nil {
+		return x.RptNestedEnum
+	}
+	return nil
+}
+
+// Message contains repeated fields.
+type Repeats struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	RptBool   []bool    `protobuf:"varint,1,rep,name=rpt_bool,json=rptBool" json:"rpt_bool,omitempty"`
+	RptInt32  []int32   `protobuf:"varint,2,rep,name=rpt_int32,json=rptInt32" json:"rpt_int32,omitempty"`
+	RptInt64  []int64   `protobuf:"varint,3,rep,name=rpt_int64,json=rptInt64" json:"rpt_int64,omitempty"`
+	RptUint32 []uint32  `protobuf:"varint,4,rep,name=rpt_uint32,json=rptUint32" json:"rpt_uint32,omitempty"`
+	RptUint64 []uint64  `protobuf:"varint,5,rep,name=rpt_uint64,json=rptUint64" json:"rpt_uint64,omitempty"`
+	RptFloat  []float32 `protobuf:"fixed32,6,rep,name=rpt_float,json=rptFloat" json:"rpt_float,omitempty"`
+	RptDouble []float64 `protobuf:"fixed64,7,rep,name=rpt_double,json=rptDouble" json:"rpt_double,omitempty"`
+	RptString []string  `protobuf:"bytes,8,rep,name=rpt_string,json=rptString" json:"rpt_string,omitempty"`
+	RptBytes  [][]byte  `protobuf:"bytes,9,rep,name=rpt_bytes,json=rptBytes" json:"rpt_bytes,omitempty"`
+}
+
+func (x *Repeats) Reset() {
+	*x = Repeats{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Repeats) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Repeats) ProtoMessage() {}
+
+func (x *Repeats) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Repeats.ProtoReflect.Descriptor instead.
+func (*Repeats) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_textpb2_test_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *Repeats) GetRptBool() []bool {
+	if x != nil {
+		return x.RptBool
+	}
+	return nil
+}
+
+func (x *Repeats) GetRptInt32() []int32 {
+	if x != nil {
+		return x.RptInt32
+	}
+	return nil
+}
+
+func (x *Repeats) GetRptInt64() []int64 {
+	if x != nil {
+		return x.RptInt64
+	}
+	return nil
+}
+
+func (x *Repeats) GetRptUint32() []uint32 {
+	if x != nil {
+		return x.RptUint32
+	}
+	return nil
+}
+
+func (x *Repeats) GetRptUint64() []uint64 {
+	if x != nil {
+		return x.RptUint64
+	}
+	return nil
+}
+
+func (x *Repeats) GetRptFloat() []float32 {
+	if x != nil {
+		return x.RptFloat
+	}
+	return nil
+}
+
+func (x *Repeats) GetRptDouble() []float64 {
+	if x != nil {
+		return x.RptDouble
+	}
+	return nil
+}
+
+func (x *Repeats) GetRptString() []string {
+	if x != nil {
+		return x.RptString
+	}
+	return nil
+}
+
+func (x *Repeats) GetRptBytes() [][]byte {
+	if x != nil {
+		return x.RptBytes
+	}
+	return nil
+}
+
+// Message contains map fields.
+type Maps struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Int32ToStr  map[int32]string   `protobuf:"bytes,1,rep,name=int32_to_str,json=int32ToStr" json:"int32_to_str,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+	StrToNested map[string]*Nested `protobuf:"bytes,4,rep,name=str_to_nested,json=strToNested" json:"str_to_nested,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+}
+
+func (x *Maps) Reset() {
+	*x = Maps{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Maps) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Maps) ProtoMessage() {}
+
+func (x *Maps) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Maps.ProtoReflect.Descriptor instead.
+func (*Maps) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_textpb2_test_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *Maps) GetInt32ToStr() map[int32]string {
+	if x != nil {
+		return x.Int32ToStr
+	}
+	return nil
+}
+
+func (x *Maps) GetStrToNested() map[string]*Nested {
+	if x != nil {
+		return x.StrToNested
+	}
+	return nil
+}
+
+// Message type used as submessage.
+type Nested struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	OptString *string `protobuf:"bytes,1,opt,name=opt_string,json=optString" json:"opt_string,omitempty"`
+	OptNested *Nested `protobuf:"bytes,2,opt,name=opt_nested,json=optNested" json:"opt_nested,omitempty"`
+}
+
+func (x *Nested) Reset() {
+	*x = Nested{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Nested) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Nested) ProtoMessage() {}
+
+func (x *Nested) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Nested.ProtoReflect.Descriptor instead.
+func (*Nested) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_textpb2_test_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *Nested) GetOptString() string {
+	if x != nil && x.OptString != nil {
+		return *x.OptString
+	}
+	return ""
+}
+
+func (x *Nested) GetOptNested() *Nested {
+	if x != nil {
+		return x.OptNested
+	}
+	return nil
+}
+
+// Message contains message and group fields.
+type Nests struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	OptNested *Nested           `protobuf:"bytes,1,opt,name=opt_nested,json=optNested" json:"opt_nested,omitempty"`
+	Optgroup  *Nests_OptGroup   `protobuf:"group,2,opt,name=OptGroup,json=optgroup" json:"optgroup,omitempty"`
+	RptNested []*Nested         `protobuf:"bytes,4,rep,name=rpt_nested,json=rptNested" json:"rpt_nested,omitempty"`
+	Rptgroup  []*Nests_RptGroup `protobuf:"group,5,rep,name=RptGroup,json=rptgroup" json:"rptgroup,omitempty"`
+}
+
+func (x *Nests) Reset() {
+	*x = Nests{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[5]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Nests) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Nests) ProtoMessage() {}
+
+func (x *Nests) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[5]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Nests.ProtoReflect.Descriptor instead.
+func (*Nests) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_textpb2_test_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *Nests) GetOptNested() *Nested {
+	if x != nil {
+		return x.OptNested
+	}
+	return nil
+}
+
+func (x *Nests) GetOptgroup() *Nests_OptGroup {
+	if x != nil {
+		return x.Optgroup
+	}
+	return nil
+}
+
+func (x *Nests) GetRptNested() []*Nested {
+	if x != nil {
+		return x.RptNested
+	}
+	return nil
+}
+
+func (x *Nests) GetRptgroup() []*Nests_RptGroup {
+	if x != nil {
+		return x.Rptgroup
+	}
+	return nil
+}
+
+// Message contains required fields.
+type Requireds struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	ReqBool     *bool    `protobuf:"varint,1,req,name=req_bool,json=reqBool" json:"req_bool,omitempty"`
+	ReqSfixed64 *int64   `protobuf:"fixed64,2,req,name=req_sfixed64,json=reqSfixed64" json:"req_sfixed64,omitempty"`
+	ReqDouble   *float64 `protobuf:"fixed64,3,req,name=req_double,json=reqDouble" json:"req_double,omitempty"`
+	ReqString   *string  `protobuf:"bytes,4,req,name=req_string,json=reqString" json:"req_string,omitempty"`
+	ReqEnum     *Enum    `protobuf:"varint,5,req,name=req_enum,json=reqEnum,enum=pb2.Enum" json:"req_enum,omitempty"`
+	ReqNested   *Nested  `protobuf:"bytes,6,req,name=req_nested,json=reqNested" json:"req_nested,omitempty"`
+}
+
+func (x *Requireds) Reset() {
+	*x = Requireds{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[6]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Requireds) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Requireds) ProtoMessage() {}
+
+func (x *Requireds) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[6]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Requireds.ProtoReflect.Descriptor instead.
+func (*Requireds) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_textpb2_test_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *Requireds) GetReqBool() bool {
+	if x != nil && x.ReqBool != nil {
+		return *x.ReqBool
+	}
+	return false
+}
+
+func (x *Requireds) GetReqSfixed64() int64 {
+	if x != nil && x.ReqSfixed64 != nil {
+		return *x.ReqSfixed64
+	}
+	return 0
+}
+
+func (x *Requireds) GetReqDouble() float64 {
+	if x != nil && x.ReqDouble != nil {
+		return *x.ReqDouble
+	}
+	return 0
+}
+
+func (x *Requireds) GetReqString() string {
+	if x != nil && x.ReqString != nil {
+		return *x.ReqString
+	}
+	return ""
+}
+
+func (x *Requireds) GetReqEnum() Enum {
+	if x != nil && x.ReqEnum != nil {
+		return *x.ReqEnum
+	}
+	return Enum_ONE
+}
+
+func (x *Requireds) GetReqNested() *Nested {
+	if x != nil {
+		return x.ReqNested
+	}
+	return nil
+}
+
+// Message contains both required and optional fields.
+type PartialRequired struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	ReqString *string `protobuf:"bytes,1,req,name=req_string,json=reqString" json:"req_string,omitempty"`
+	OptString *string `protobuf:"bytes,2,opt,name=opt_string,json=optString" json:"opt_string,omitempty"`
+}
+
+func (x *PartialRequired) Reset() {
+	*x = PartialRequired{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[7]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *PartialRequired) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*PartialRequired) ProtoMessage() {}
+
+func (x *PartialRequired) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[7]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use PartialRequired.ProtoReflect.Descriptor instead.
+func (*PartialRequired) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_textpb2_test_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *PartialRequired) GetReqString() string {
+	if x != nil && x.ReqString != nil {
+		return *x.ReqString
+	}
+	return ""
+}
+
+func (x *PartialRequired) GetOptString() string {
+	if x != nil && x.OptString != nil {
+		return *x.OptString
+	}
+	return ""
+}
+
+type NestedWithRequired struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	ReqString *string `protobuf:"bytes,1,req,name=req_string,json=reqString" json:"req_string,omitempty"`
+}
+
+func (x *NestedWithRequired) Reset() {
+	*x = NestedWithRequired{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[8]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *NestedWithRequired) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*NestedWithRequired) ProtoMessage() {}
+
+func (x *NestedWithRequired) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[8]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use NestedWithRequired.ProtoReflect.Descriptor instead.
+func (*NestedWithRequired) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_textpb2_test_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *NestedWithRequired) GetReqString() string {
+	if x != nil && x.ReqString != nil {
+		return *x.ReqString
+	}
+	return ""
+}
+
+type IndirectRequired struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	OptNested   *NestedWithRequired            `protobuf:"bytes,1,opt,name=opt_nested,json=optNested" json:"opt_nested,omitempty"`
+	RptNested   []*NestedWithRequired          `protobuf:"bytes,2,rep,name=rpt_nested,json=rptNested" json:"rpt_nested,omitempty"`
+	StrToNested map[string]*NestedWithRequired `protobuf:"bytes,3,rep,name=str_to_nested,json=strToNested" json:"str_to_nested,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+	// Types that are assignable to Union:
+	//	*IndirectRequired_OneofNested
+	Union isIndirectRequired_Union `protobuf_oneof:"union"`
+}
+
+func (x *IndirectRequired) Reset() {
+	*x = IndirectRequired{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[9]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *IndirectRequired) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*IndirectRequired) ProtoMessage() {}
+
+func (x *IndirectRequired) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[9]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use IndirectRequired.ProtoReflect.Descriptor instead.
+func (*IndirectRequired) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_textpb2_test_proto_rawDescGZIP(), []int{9}
+}
+
+func (x *IndirectRequired) GetOptNested() *NestedWithRequired {
+	if x != nil {
+		return x.OptNested
+	}
+	return nil
+}
+
+func (x *IndirectRequired) GetRptNested() []*NestedWithRequired {
+	if x != nil {
+		return x.RptNested
+	}
+	return nil
+}
+
+func (x *IndirectRequired) GetStrToNested() map[string]*NestedWithRequired {
+	if x != nil {
+		return x.StrToNested
+	}
+	return nil
+}
+
+func (m *IndirectRequired) GetUnion() isIndirectRequired_Union {
+	if m != nil {
+		return m.Union
+	}
+	return nil
+}
+
+func (x *IndirectRequired) GetOneofNested() *NestedWithRequired {
+	if x, ok := x.GetUnion().(*IndirectRequired_OneofNested); ok {
+		return x.OneofNested
+	}
+	return nil
+}
+
+type isIndirectRequired_Union interface {
+	isIndirectRequired_Union()
+}
+
+type IndirectRequired_OneofNested struct {
+	OneofNested *NestedWithRequired `protobuf:"bytes,4,opt,name=oneof_nested,json=oneofNested,oneof"`
+}
+
+func (*IndirectRequired_OneofNested) isIndirectRequired_Union() {}
+
+type Extensions struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+
+	OptString *string `protobuf:"bytes,1,opt,name=opt_string,json=optString" json:"opt_string,omitempty"`
+	OptBool   *bool   `protobuf:"varint,101,opt,name=opt_bool,json=optBool" json:"opt_bool,omitempty"`
+	OptInt32  *int32  `protobuf:"varint,2,opt,name=opt_int32,json=optInt32" json:"opt_int32,omitempty"`
+}
+
+func (x *Extensions) Reset() {
+	*x = Extensions{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[10]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Extensions) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Extensions) ProtoMessage() {}
+
+func (x *Extensions) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[10]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Extensions.ProtoReflect.Descriptor instead.
+func (*Extensions) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_textpb2_test_proto_rawDescGZIP(), []int{10}
+}
+
+var extRange_Extensions = []protoiface.ExtensionRangeV1{
+	{Start: 20, End: 100},
+}
+
+// Deprecated: Use Extensions.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*Extensions) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_Extensions
+}
+
+func (x *Extensions) GetOptString() string {
+	if x != nil && x.OptString != nil {
+		return *x.OptString
+	}
+	return ""
+}
+
+func (x *Extensions) GetOptBool() bool {
+	if x != nil && x.OptBool != nil {
+		return *x.OptBool
+	}
+	return false
+}
+
+func (x *Extensions) GetOptInt32() int32 {
+	if x != nil && x.OptInt32 != nil {
+		return *x.OptInt32
+	}
+	return 0
+}
+
+type ExtensionsContainer struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *ExtensionsContainer) Reset() {
+	*x = ExtensionsContainer{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[11]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *ExtensionsContainer) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ExtensionsContainer) ProtoMessage() {}
+
+func (x *ExtensionsContainer) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[11]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ExtensionsContainer.ProtoReflect.Descriptor instead.
+func (*ExtensionsContainer) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_textpb2_test_proto_rawDescGZIP(), []int{11}
+}
+
+type MessageSet struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+}
+
+func (x *MessageSet) Reset() {
+	*x = MessageSet{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[12]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MessageSet) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MessageSet) ProtoMessage() {}
+
+func (x *MessageSet) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[12]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use MessageSet.ProtoReflect.Descriptor instead.
+func (*MessageSet) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_textpb2_test_proto_rawDescGZIP(), []int{12}
+}
+
+var extRange_MessageSet = []protoiface.ExtensionRangeV1{
+	{Start: 4, End: 2147483646},
+}
+
+// Deprecated: Use MessageSet.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*MessageSet) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_MessageSet
+}
+
+type MessageSetExtension struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	OptString *string `protobuf:"bytes,1,opt,name=opt_string,json=optString" json:"opt_string,omitempty"`
+}
+
+func (x *MessageSetExtension) Reset() {
+	*x = MessageSetExtension{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[13]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MessageSetExtension) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MessageSetExtension) ProtoMessage() {}
+
+func (x *MessageSetExtension) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[13]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use MessageSetExtension.ProtoReflect.Descriptor instead.
+func (*MessageSetExtension) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_textpb2_test_proto_rawDescGZIP(), []int{13}
+}
+
+func (x *MessageSetExtension) GetOptString() string {
+	if x != nil && x.OptString != nil {
+		return *x.OptString
+	}
+	return ""
+}
+
+type FakeMessageSet struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+}
+
+func (x *FakeMessageSet) Reset() {
+	*x = FakeMessageSet{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[14]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *FakeMessageSet) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*FakeMessageSet) ProtoMessage() {}
+
+func (x *FakeMessageSet) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[14]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use FakeMessageSet.ProtoReflect.Descriptor instead.
+func (*FakeMessageSet) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_textpb2_test_proto_rawDescGZIP(), []int{14}
+}
+
+var extRange_FakeMessageSet = []protoiface.ExtensionRangeV1{
+	{Start: 4, End: 536870911},
+}
+
+// Deprecated: Use FakeMessageSet.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*FakeMessageSet) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_FakeMessageSet
+}
+
+type FakeMessageSetExtension struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	OptString *string `protobuf:"bytes,1,opt,name=opt_string,json=optString" json:"opt_string,omitempty"`
+}
+
+func (x *FakeMessageSetExtension) Reset() {
+	*x = FakeMessageSetExtension{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[15]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *FakeMessageSetExtension) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*FakeMessageSetExtension) ProtoMessage() {}
+
+func (x *FakeMessageSetExtension) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[15]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use FakeMessageSetExtension.ProtoReflect.Descriptor instead.
+func (*FakeMessageSetExtension) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_textpb2_test_proto_rawDescGZIP(), []int{15}
+}
+
+func (x *FakeMessageSetExtension) GetOptString() string {
+	if x != nil && x.OptString != nil {
+		return *x.OptString
+	}
+	return ""
+}
+
+// Message contains well-known type fields.
+type KnownTypes struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	OptBool      *wrapperspb.BoolValue   `protobuf:"bytes,1,opt,name=opt_bool,json=optBool" json:"opt_bool,omitempty"`
+	OptInt32     *wrapperspb.Int32Value  `protobuf:"bytes,2,opt,name=opt_int32,json=optInt32" json:"opt_int32,omitempty"`
+	OptInt64     *wrapperspb.Int64Value  `protobuf:"bytes,3,opt,name=opt_int64,json=optInt64" json:"opt_int64,omitempty"`
+	OptUint32    *wrapperspb.UInt32Value `protobuf:"bytes,4,opt,name=opt_uint32,json=optUint32" json:"opt_uint32,omitempty"`
+	OptUint64    *wrapperspb.UInt64Value `protobuf:"bytes,5,opt,name=opt_uint64,json=optUint64" json:"opt_uint64,omitempty"`
+	OptFloat     *wrapperspb.FloatValue  `protobuf:"bytes,6,opt,name=opt_float,json=optFloat" json:"opt_float,omitempty"`
+	OptDouble    *wrapperspb.DoubleValue `protobuf:"bytes,7,opt,name=opt_double,json=optDouble" json:"opt_double,omitempty"`
+	OptString    *wrapperspb.StringValue `protobuf:"bytes,8,opt,name=opt_string,json=optString" json:"opt_string,omitempty"`
+	OptBytes     *wrapperspb.BytesValue  `protobuf:"bytes,9,opt,name=opt_bytes,json=optBytes" json:"opt_bytes,omitempty"`
+	OptDuration  *durationpb.Duration    `protobuf:"bytes,20,opt,name=opt_duration,json=optDuration" json:"opt_duration,omitempty"`
+	OptTimestamp *timestamppb.Timestamp  `protobuf:"bytes,21,opt,name=opt_timestamp,json=optTimestamp" json:"opt_timestamp,omitempty"`
+	OptStruct    *structpb.Struct        `protobuf:"bytes,25,opt,name=opt_struct,json=optStruct" json:"opt_struct,omitempty"`
+	OptList      *structpb.ListValue     `protobuf:"bytes,26,opt,name=opt_list,json=optList" json:"opt_list,omitempty"`
+	OptValue     *structpb.Value         `protobuf:"bytes,27,opt,name=opt_value,json=optValue" json:"opt_value,omitempty"`
+	OptNull      *structpb.NullValue     `protobuf:"varint,28,opt,name=opt_null,json=optNull,enum=google.protobuf.NullValue" json:"opt_null,omitempty"`
+	OptEmpty     *emptypb.Empty          `protobuf:"bytes,30,opt,name=opt_empty,json=optEmpty" json:"opt_empty,omitempty"`
+	OptAny       *anypb.Any              `protobuf:"bytes,32,opt,name=opt_any,json=optAny" json:"opt_any,omitempty"`
+	OptFieldmask *fieldmaskpb.FieldMask  `protobuf:"bytes,40,opt,name=opt_fieldmask,json=optFieldmask" json:"opt_fieldmask,omitempty"`
+}
+
+func (x *KnownTypes) Reset() {
+	*x = KnownTypes{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[16]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *KnownTypes) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*KnownTypes) ProtoMessage() {}
+
+func (x *KnownTypes) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[16]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use KnownTypes.ProtoReflect.Descriptor instead.
+func (*KnownTypes) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_textpb2_test_proto_rawDescGZIP(), []int{16}
+}
+
+func (x *KnownTypes) GetOptBool() *wrapperspb.BoolValue {
+	if x != nil {
+		return x.OptBool
+	}
+	return nil
+}
+
+func (x *KnownTypes) GetOptInt32() *wrapperspb.Int32Value {
+	if x != nil {
+		return x.OptInt32
+	}
+	return nil
+}
+
+func (x *KnownTypes) GetOptInt64() *wrapperspb.Int64Value {
+	if x != nil {
+		return x.OptInt64
+	}
+	return nil
+}
+
+func (x *KnownTypes) GetOptUint32() *wrapperspb.UInt32Value {
+	if x != nil {
+		return x.OptUint32
+	}
+	return nil
+}
+
+func (x *KnownTypes) GetOptUint64() *wrapperspb.UInt64Value {
+	if x != nil {
+		return x.OptUint64
+	}
+	return nil
+}
+
+func (x *KnownTypes) GetOptFloat() *wrapperspb.FloatValue {
+	if x != nil {
+		return x.OptFloat
+	}
+	return nil
+}
+
+func (x *KnownTypes) GetOptDouble() *wrapperspb.DoubleValue {
+	if x != nil {
+		return x.OptDouble
+	}
+	return nil
+}
+
+func (x *KnownTypes) GetOptString() *wrapperspb.StringValue {
+	if x != nil {
+		return x.OptString
+	}
+	return nil
+}
+
+func (x *KnownTypes) GetOptBytes() *wrapperspb.BytesValue {
+	if x != nil {
+		return x.OptBytes
+	}
+	return nil
+}
+
+func (x *KnownTypes) GetOptDuration() *durationpb.Duration {
+	if x != nil {
+		return x.OptDuration
+	}
+	return nil
+}
+
+func (x *KnownTypes) GetOptTimestamp() *timestamppb.Timestamp {
+	if x != nil {
+		return x.OptTimestamp
+	}
+	return nil
+}
+
+func (x *KnownTypes) GetOptStruct() *structpb.Struct {
+	if x != nil {
+		return x.OptStruct
+	}
+	return nil
+}
+
+func (x *KnownTypes) GetOptList() *structpb.ListValue {
+	if x != nil {
+		return x.OptList
+	}
+	return nil
+}
+
+func (x *KnownTypes) GetOptValue() *structpb.Value {
+	if x != nil {
+		return x.OptValue
+	}
+	return nil
+}
+
+func (x *KnownTypes) GetOptNull() structpb.NullValue {
+	if x != nil && x.OptNull != nil {
+		return *x.OptNull
+	}
+	return structpb.NullValue_NULL_VALUE
+}
+
+func (x *KnownTypes) GetOptEmpty() *emptypb.Empty {
+	if x != nil {
+		return x.OptEmpty
+	}
+	return nil
+}
+
+func (x *KnownTypes) GetOptAny() *anypb.Any {
+	if x != nil {
+		return x.OptAny
+	}
+	return nil
+}
+
+func (x *KnownTypes) GetOptFieldmask() *fieldmaskpb.FieldMask {
+	if x != nil {
+		return x.OptFieldmask
+	}
+	return nil
+}
+
+type Nests_OptGroup struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	OptString      *string                        `protobuf:"bytes,1,opt,name=opt_string,json=optString" json:"opt_string,omitempty"`
+	OptNested      *Nested                        `protobuf:"bytes,2,opt,name=opt_nested,json=optNested" json:"opt_nested,omitempty"`
+	Optnestedgroup *Nests_OptGroup_OptNestedGroup `protobuf:"group,3,opt,name=OptNestedGroup,json=optnestedgroup" json:"optnestedgroup,omitempty"`
+}
+
+func (x *Nests_OptGroup) Reset() {
+	*x = Nests_OptGroup{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[19]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Nests_OptGroup) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Nests_OptGroup) ProtoMessage() {}
+
+func (x *Nests_OptGroup) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[19]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Nests_OptGroup.ProtoReflect.Descriptor instead.
+func (*Nests_OptGroup) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_textpb2_test_proto_rawDescGZIP(), []int{5, 0}
+}
+
+func (x *Nests_OptGroup) GetOptString() string {
+	if x != nil && x.OptString != nil {
+		return *x.OptString
+	}
+	return ""
+}
+
+func (x *Nests_OptGroup) GetOptNested() *Nested {
+	if x != nil {
+		return x.OptNested
+	}
+	return nil
+}
+
+func (x *Nests_OptGroup) GetOptnestedgroup() *Nests_OptGroup_OptNestedGroup {
+	if x != nil {
+		return x.Optnestedgroup
+	}
+	return nil
+}
+
+type Nests_RptGroup struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	RptString []string `protobuf:"bytes,1,rep,name=rpt_string,json=rptString" json:"rpt_string,omitempty"`
+}
+
+func (x *Nests_RptGroup) Reset() {
+	*x = Nests_RptGroup{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[20]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Nests_RptGroup) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Nests_RptGroup) ProtoMessage() {}
+
+func (x *Nests_RptGroup) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[20]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Nests_RptGroup.ProtoReflect.Descriptor instead.
+func (*Nests_RptGroup) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_textpb2_test_proto_rawDescGZIP(), []int{5, 1}
+}
+
+func (x *Nests_RptGroup) GetRptString() []string {
+	if x != nil {
+		return x.RptString
+	}
+	return nil
+}
+
+type Nests_OptGroup_OptNestedGroup struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	OptFixed32 *uint32 `protobuf:"fixed32,1,opt,name=opt_fixed32,json=optFixed32" json:"opt_fixed32,omitempty"`
+}
+
+func (x *Nests_OptGroup_OptNestedGroup) Reset() {
+	*x = Nests_OptGroup_OptNestedGroup{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[21]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Nests_OptGroup_OptNestedGroup) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Nests_OptGroup_OptNestedGroup) ProtoMessage() {}
+
+func (x *Nests_OptGroup_OptNestedGroup) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_textpb2_test_proto_msgTypes[21]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Nests_OptGroup_OptNestedGroup.ProtoReflect.Descriptor instead.
+func (*Nests_OptGroup_OptNestedGroup) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_textpb2_test_proto_rawDescGZIP(), []int{5, 0, 0}
+}
+
+func (x *Nests_OptGroup_OptNestedGroup) GetOptFixed32() uint32 {
+	if x != nil && x.OptFixed32 != nil {
+		return *x.OptFixed32
+	}
+	return 0
+}
+
+var file_internal_testprotos_textpb2_test_proto_extTypes = []protoimpl.ExtensionInfo{
+	{
+		ExtendedType:  (*Extensions)(nil),
+		ExtensionType: (*bool)(nil),
+		Field:         21,
+		Name:          "pb2.opt_ext_bool",
+		Tag:           "varint,21,opt,name=opt_ext_bool",
+		Filename:      "internal/testprotos/textpb2/test.proto",
+	},
+	{
+		ExtendedType:  (*Extensions)(nil),
+		ExtensionType: (*string)(nil),
+		Field:         22,
+		Name:          "pb2.opt_ext_string",
+		Tag:           "bytes,22,opt,name=opt_ext_string",
+		Filename:      "internal/testprotos/textpb2/test.proto",
+	},
+	{
+		ExtendedType:  (*Extensions)(nil),
+		ExtensionType: (*Enum)(nil),
+		Field:         23,
+		Name:          "pb2.opt_ext_enum",
+		Tag:           "varint,23,opt,name=opt_ext_enum,enum=pb2.Enum",
+		Filename:      "internal/testprotos/textpb2/test.proto",
+	},
+	{
+		ExtendedType:  (*Extensions)(nil),
+		ExtensionType: (*Nested)(nil),
+		Field:         24,
+		Name:          "pb2.opt_ext_nested",
+		Tag:           "bytes,24,opt,name=opt_ext_nested",
+		Filename:      "internal/testprotos/textpb2/test.proto",
+	},
+	{
+		ExtendedType:  (*Extensions)(nil),
+		ExtensionType: (*PartialRequired)(nil),
+		Field:         25,
+		Name:          "pb2.opt_ext_partial",
+		Tag:           "bytes,25,opt,name=opt_ext_partial",
+		Filename:      "internal/testprotos/textpb2/test.proto",
+	},
+	{
+		ExtendedType:  (*Extensions)(nil),
+		ExtensionType: ([]uint32)(nil),
+		Field:         31,
+		Name:          "pb2.rpt_ext_fixed32",
+		Tag:           "fixed32,31,rep,name=rpt_ext_fixed32",
+		Filename:      "internal/testprotos/textpb2/test.proto",
+	},
+	{
+		ExtendedType:  (*Extensions)(nil),
+		ExtensionType: ([]Enum)(nil),
+		Field:         32,
+		Name:          "pb2.rpt_ext_enum",
+		Tag:           "varint,32,rep,name=rpt_ext_enum,enum=pb2.Enum",
+		Filename:      "internal/testprotos/textpb2/test.proto",
+	},
+	{
+		ExtendedType:  (*Extensions)(nil),
+		ExtensionType: ([]*Nested)(nil),
+		Field:         33,
+		Name:          "pb2.rpt_ext_nested",
+		Tag:           "bytes,33,rep,name=rpt_ext_nested",
+		Filename:      "internal/testprotos/textpb2/test.proto",
+	},
+	{
+		ExtendedType:  (*MessageSet)(nil),
+		ExtensionType: (*FakeMessageSetExtension)(nil),
+		Field:         50,
+		Name:          "pb2.message_set_extension",
+		Tag:           "bytes,50,opt,name=message_set_extension",
+		Filename:      "internal/testprotos/textpb2/test.proto",
+	},
+	{
+		ExtendedType:  (*Extensions)(nil),
+		ExtensionType: (*bool)(nil),
+		Field:         51,
+		Name:          "pb2.ExtensionsContainer.opt_ext_bool",
+		Tag:           "varint,51,opt,name=opt_ext_bool",
+		Filename:      "internal/testprotos/textpb2/test.proto",
+	},
+	{
+		ExtendedType:  (*Extensions)(nil),
+		ExtensionType: (*string)(nil),
+		Field:         52,
+		Name:          "pb2.ExtensionsContainer.opt_ext_string",
+		Tag:           "bytes,52,opt,name=opt_ext_string",
+		Filename:      "internal/testprotos/textpb2/test.proto",
+	},
+	{
+		ExtendedType:  (*Extensions)(nil),
+		ExtensionType: (*Enum)(nil),
+		Field:         53,
+		Name:          "pb2.ExtensionsContainer.opt_ext_enum",
+		Tag:           "varint,53,opt,name=opt_ext_enum,enum=pb2.Enum",
+		Filename:      "internal/testprotos/textpb2/test.proto",
+	},
+	{
+		ExtendedType:  (*Extensions)(nil),
+		ExtensionType: (*Nested)(nil),
+		Field:         54,
+		Name:          "pb2.ExtensionsContainer.opt_ext_nested",
+		Tag:           "bytes,54,opt,name=opt_ext_nested",
+		Filename:      "internal/testprotos/textpb2/test.proto",
+	},
+	{
+		ExtendedType:  (*Extensions)(nil),
+		ExtensionType: (*PartialRequired)(nil),
+		Field:         55,
+		Name:          "pb2.ExtensionsContainer.opt_ext_partial",
+		Tag:           "bytes,55,opt,name=opt_ext_partial",
+		Filename:      "internal/testprotos/textpb2/test.proto",
+	},
+	{
+		ExtendedType:  (*Extensions)(nil),
+		ExtensionType: ([]string)(nil),
+		Field:         61,
+		Name:          "pb2.ExtensionsContainer.rpt_ext_string",
+		Tag:           "bytes,61,rep,name=rpt_ext_string",
+		Filename:      "internal/testprotos/textpb2/test.proto",
+	},
+	{
+		ExtendedType:  (*Extensions)(nil),
+		ExtensionType: ([]Enum)(nil),
+		Field:         62,
+		Name:          "pb2.ExtensionsContainer.rpt_ext_enum",
+		Tag:           "varint,62,rep,name=rpt_ext_enum,enum=pb2.Enum",
+		Filename:      "internal/testprotos/textpb2/test.proto",
+	},
+	{
+		ExtendedType:  (*Extensions)(nil),
+		ExtensionType: ([]*Nested)(nil),
+		Field:         63,
+		Name:          "pb2.ExtensionsContainer.rpt_ext_nested",
+		Tag:           "bytes,63,rep,name=rpt_ext_nested",
+		Filename:      "internal/testprotos/textpb2/test.proto",
+	},
+	{
+		ExtendedType:  (*MessageSet)(nil),
+		ExtensionType: (*MessageSetExtension)(nil),
+		Field:         10,
+		Name:          "pb2.MessageSetExtension",
+		Tag:           "bytes,10,opt,name=message_set_extension",
+		Filename:      "internal/testprotos/textpb2/test.proto",
+	},
+	{
+		ExtendedType:  (*MessageSet)(nil),
+		ExtensionType: (*MessageSetExtension)(nil),
+		Field:         20,
+		Name:          "pb2.MessageSetExtension.not_message_set_extension",
+		Tag:           "bytes,20,opt,name=not_message_set_extension",
+		Filename:      "internal/testprotos/textpb2/test.proto",
+	},
+	{
+		ExtendedType:  (*MessageSet)(nil),
+		ExtensionType: (*Nested)(nil),
+		Field:         30,
+		Name:          "pb2.MessageSetExtension.ext_nested",
+		Tag:           "bytes,30,opt,name=ext_nested",
+		Filename:      "internal/testprotos/textpb2/test.proto",
+	},
+	{
+		ExtendedType:  (*FakeMessageSet)(nil),
+		ExtensionType: (*FakeMessageSetExtension)(nil),
+		Field:         10,
+		Name:          "pb2.FakeMessageSetExtension.message_set_extension",
+		Tag:           "bytes,10,opt,name=message_set_extension",
+		Filename:      "internal/testprotos/textpb2/test.proto",
+	},
+}
+
+// Extension fields to Extensions.
+var (
+	// optional bool opt_ext_bool = 21;
+	E_OptExtBool = &file_internal_testprotos_textpb2_test_proto_extTypes[0]
+	// optional string opt_ext_string = 22;
+	E_OptExtString = &file_internal_testprotos_textpb2_test_proto_extTypes[1]
+	// optional pb2.Enum opt_ext_enum = 23;
+	E_OptExtEnum = &file_internal_testprotos_textpb2_test_proto_extTypes[2]
+	// optional pb2.Nested opt_ext_nested = 24;
+	E_OptExtNested = &file_internal_testprotos_textpb2_test_proto_extTypes[3]
+	// optional pb2.PartialRequired opt_ext_partial = 25;
+	E_OptExtPartial = &file_internal_testprotos_textpb2_test_proto_extTypes[4]
+	// repeated fixed32 rpt_ext_fixed32 = 31;
+	E_RptExtFixed32 = &file_internal_testprotos_textpb2_test_proto_extTypes[5]
+	// repeated pb2.Enum rpt_ext_enum = 32;
+	E_RptExtEnum = &file_internal_testprotos_textpb2_test_proto_extTypes[6]
+	// repeated pb2.Nested rpt_ext_nested = 33;
+	E_RptExtNested = &file_internal_testprotos_textpb2_test_proto_extTypes[7]
+	// optional bool opt_ext_bool = 51;
+	E_ExtensionsContainer_OptExtBool = &file_internal_testprotos_textpb2_test_proto_extTypes[9]
+	// optional string opt_ext_string = 52;
+	E_ExtensionsContainer_OptExtString = &file_internal_testprotos_textpb2_test_proto_extTypes[10]
+	// optional pb2.Enum opt_ext_enum = 53;
+	E_ExtensionsContainer_OptExtEnum = &file_internal_testprotos_textpb2_test_proto_extTypes[11]
+	// optional pb2.Nested opt_ext_nested = 54;
+	E_ExtensionsContainer_OptExtNested = &file_internal_testprotos_textpb2_test_proto_extTypes[12]
+	// optional pb2.PartialRequired opt_ext_partial = 55;
+	E_ExtensionsContainer_OptExtPartial = &file_internal_testprotos_textpb2_test_proto_extTypes[13]
+	// repeated string rpt_ext_string = 61;
+	E_ExtensionsContainer_RptExtString = &file_internal_testprotos_textpb2_test_proto_extTypes[14]
+	// repeated pb2.Enum rpt_ext_enum = 62;
+	E_ExtensionsContainer_RptExtEnum = &file_internal_testprotos_textpb2_test_proto_extTypes[15]
+	// repeated pb2.Nested rpt_ext_nested = 63;
+	E_ExtensionsContainer_RptExtNested = &file_internal_testprotos_textpb2_test_proto_extTypes[16]
+)
+
+// Extension fields to MessageSet.
+var (
+	// optional pb2.FakeMessageSetExtension message_set_extension = 50;
+	E_MessageSetExtension = &file_internal_testprotos_textpb2_test_proto_extTypes[8]
+	// optional pb2.MessageSetExtension message_set_extension = 10;
+	E_MessageSetExtension_MessageSetExtension = &file_internal_testprotos_textpb2_test_proto_extTypes[17]
+	// optional pb2.MessageSetExtension not_message_set_extension = 20;
+	E_MessageSetExtension_NotMessageSetExtension = &file_internal_testprotos_textpb2_test_proto_extTypes[18]
+	// optional pb2.Nested ext_nested = 30;
+	E_MessageSetExtension_ExtNested = &file_internal_testprotos_textpb2_test_proto_extTypes[19]
+)
+
+// Extension fields to FakeMessageSet.
+var (
+	// optional pb2.FakeMessageSetExtension message_set_extension = 10;
+	E_FakeMessageSetExtension_MessageSetExtension = &file_internal_testprotos_textpb2_test_proto_extTypes[20]
+)
+
+var File_internal_testprotos_textpb2_test_proto protoreflect.FileDescriptor
+
+var file_internal_testprotos_textpb2_test_proto_rawDesc = []byte{
+	0x0a, 0x26, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x74, 0x65, 0x78, 0x74, 0x70, 0x62, 0x32, 0x2f, 0x74, 0x65,
+	0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x03, 0x70, 0x62, 0x32, 0x1a, 0x19, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x61,
+	0x6e, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1b, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x20, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x6d, 0x61, 0x73,
+	0x6b, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x73,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xda, 0x03, 0x0a, 0x07, 0x53, 0x63, 0x61, 0x6c, 0x61,
+	0x72, 0x73, 0x12, 0x19, 0x0a, 0x08, 0x6f, 0x70, 0x74, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x1b, 0x0a,
+	0x09, 0x6f, 0x70, 0x74, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x08, 0x6f, 0x70, 0x74, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x1b, 0x0a, 0x09, 0x6f, 0x70,
+	0x74, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x6f,
+	0x70, 0x74, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x70, 0x74, 0x5f, 0x75,
+	0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x09, 0x6f, 0x70, 0x74,
+	0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x70, 0x74, 0x5f, 0x75, 0x69,
+	0x6e, 0x74, 0x36, 0x34, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x6f, 0x70, 0x74, 0x55,
+	0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x70, 0x74, 0x5f, 0x73, 0x69, 0x6e,
+	0x74, 0x33, 0x32, 0x18, 0x06, 0x20, 0x01, 0x28, 0x11, 0x52, 0x09, 0x6f, 0x70, 0x74, 0x53, 0x69,
+	0x6e, 0x74, 0x33, 0x32, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x70, 0x74, 0x5f, 0x73, 0x69, 0x6e, 0x74,
+	0x36, 0x34, 0x18, 0x07, 0x20, 0x01, 0x28, 0x12, 0x52, 0x09, 0x6f, 0x70, 0x74, 0x53, 0x69, 0x6e,
+	0x74, 0x36, 0x34, 0x12, 0x1f, 0x0a, 0x0b, 0x6f, 0x70, 0x74, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64,
+	0x33, 0x32, 0x18, 0x08, 0x20, 0x01, 0x28, 0x07, 0x52, 0x0a, 0x6f, 0x70, 0x74, 0x46, 0x69, 0x78,
+	0x65, 0x64, 0x33, 0x32, 0x12, 0x1f, 0x0a, 0x0b, 0x6f, 0x70, 0x74, 0x5f, 0x66, 0x69, 0x78, 0x65,
+	0x64, 0x36, 0x34, 0x18, 0x09, 0x20, 0x01, 0x28, 0x06, 0x52, 0x0a, 0x6f, 0x70, 0x74, 0x46, 0x69,
+	0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x21, 0x0a, 0x0c, 0x6f, 0x70, 0x74, 0x5f, 0x73, 0x66, 0x69,
+	0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0f, 0x52, 0x0b, 0x6f, 0x70, 0x74,
+	0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x21, 0x0a, 0x0c, 0x6f, 0x70, 0x74, 0x5f,
+	0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x10, 0x52, 0x0b,
+	0x6f, 0x70, 0x74, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x1b, 0x0a, 0x09, 0x6f,
+	0x70, 0x74, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x18, 0x14, 0x20, 0x01, 0x28, 0x02, 0x52, 0x08,
+	0x6f, 0x70, 0x74, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x70, 0x74, 0x5f,
+	0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0x15, 0x20, 0x01, 0x28, 0x01, 0x52, 0x09, 0x6f, 0x70,
+	0x74, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x6f, 0x70, 0x74, 0x5f, 0x62,
+	0x79, 0x74, 0x65, 0x73, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x6f, 0x70, 0x74, 0x42,
+	0x79, 0x74, 0x65, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x70, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x69,
+	0x6e, 0x67, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6f, 0x70, 0x74, 0x53, 0x74, 0x72,
+	0x69, 0x6e, 0x67, 0x22, 0xfb, 0x01, 0x0a, 0x05, 0x45, 0x6e, 0x75, 0x6d, 0x73, 0x12, 0x24, 0x0a,
+	0x08, 0x6f, 0x70, 0x74, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32,
+	0x09, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x45,
+	0x6e, 0x75, 0x6d, 0x12, 0x24, 0x0a, 0x08, 0x72, 0x70, 0x74, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18,
+	0x02, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x09, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x45, 0x6e, 0x75, 0x6d,
+	0x52, 0x07, 0x72, 0x70, 0x74, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x3d, 0x0a, 0x0f, 0x6f, 0x70, 0x74,
+	0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x03, 0x20, 0x01,
+	0x28, 0x0e, 0x32, 0x15, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x73, 0x2e, 0x4e,
+	0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x4e, 0x65,
+	0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x3d, 0x0a, 0x0f, 0x72, 0x70, 0x74, 0x5f,
+	0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x04, 0x20, 0x03, 0x28,
+	0x0e, 0x32, 0x15, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x73, 0x2e, 0x4e, 0x65,
+	0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0d, 0x72, 0x70, 0x74, 0x4e, 0x65, 0x73,
+	0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x22, 0x28, 0x0a, 0x0a, 0x4e, 0x65, 0x73, 0x74, 0x65,
+	0x64, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x07, 0x0a, 0x03, 0x55, 0x4e, 0x4f, 0x10, 0x01, 0x12, 0x07,
+	0x0a, 0x03, 0x44, 0x4f, 0x53, 0x10, 0x02, 0x12, 0x08, 0x0a, 0x04, 0x44, 0x49, 0x45, 0x5a, 0x10,
+	0x0a, 0x22, 0x94, 0x02, 0x0a, 0x07, 0x52, 0x65, 0x70, 0x65, 0x61, 0x74, 0x73, 0x12, 0x19, 0x0a,
+	0x08, 0x72, 0x70, 0x74, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18, 0x01, 0x20, 0x03, 0x28, 0x08, 0x52,
+	0x07, 0x72, 0x70, 0x74, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x1b, 0x0a, 0x09, 0x72, 0x70, 0x74, 0x5f,
+	0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x02, 0x20, 0x03, 0x28, 0x05, 0x52, 0x08, 0x72, 0x70, 0x74,
+	0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x1b, 0x0a, 0x09, 0x72, 0x70, 0x74, 0x5f, 0x69, 0x6e, 0x74,
+	0x36, 0x34, 0x18, 0x03, 0x20, 0x03, 0x28, 0x03, 0x52, 0x08, 0x72, 0x70, 0x74, 0x49, 0x6e, 0x74,
+	0x36, 0x34, 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x70, 0x74, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32,
+	0x18, 0x04, 0x20, 0x03, 0x28, 0x0d, 0x52, 0x09, 0x72, 0x70, 0x74, 0x55, 0x69, 0x6e, 0x74, 0x33,
+	0x32, 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x70, 0x74, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18,
+	0x05, 0x20, 0x03, 0x28, 0x04, 0x52, 0x09, 0x72, 0x70, 0x74, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34,
+	0x12, 0x1b, 0x0a, 0x09, 0x72, 0x70, 0x74, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x18, 0x06, 0x20,
+	0x03, 0x28, 0x02, 0x52, 0x08, 0x72, 0x70, 0x74, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x1d, 0x0a,
+	0x0a, 0x72, 0x70, 0x74, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0x07, 0x20, 0x03, 0x28,
+	0x01, 0x52, 0x09, 0x72, 0x70, 0x74, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x1d, 0x0a, 0x0a,
+	0x72, 0x70, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x08, 0x20, 0x03, 0x28, 0x09,
+	0x52, 0x09, 0x72, 0x70, 0x74, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x1b, 0x0a, 0x09, 0x72,
+	0x70, 0x74, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x08,
+	0x72, 0x70, 0x74, 0x42, 0x79, 0x74, 0x65, 0x73, 0x22, 0x8f, 0x02, 0x0a, 0x04, 0x4d, 0x61, 0x70,
+	0x73, 0x12, 0x3b, 0x0a, 0x0c, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x74, 0x6f, 0x5f, 0x73, 0x74,
+	0x72, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x4d, 0x61,
+	0x70, 0x73, 0x2e, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x54, 0x6f, 0x53, 0x74, 0x72, 0x45, 0x6e, 0x74,
+	0x72, 0x79, 0x52, 0x0a, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x54, 0x6f, 0x53, 0x74, 0x72, 0x12, 0x3e,
+	0x0a, 0x0d, 0x73, 0x74, 0x72, 0x5f, 0x74, 0x6f, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x18,
+	0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x4d, 0x61, 0x70, 0x73,
+	0x2e, 0x53, 0x74, 0x72, 0x54, 0x6f, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x74, 0x72,
+	0x79, 0x52, 0x0b, 0x73, 0x74, 0x72, 0x54, 0x6f, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x1a, 0x3d,
+	0x0a, 0x0f, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x54, 0x6f, 0x53, 0x74, 0x72, 0x45, 0x6e, 0x74, 0x72,
+	0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03,
+	0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x4b, 0x0a,
+	0x10, 0x53, 0x74, 0x72, 0x54, 0x6f, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x74, 0x72,
+	0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03,
+	0x6b, 0x65, 0x79, 0x12, 0x21, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x0b, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x52,
+	0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x53, 0x0a, 0x06, 0x4e, 0x65,
+	0x73, 0x74, 0x65, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x70, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x69,
+	0x6e, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6f, 0x70, 0x74, 0x53, 0x74, 0x72,
+	0x69, 0x6e, 0x67, 0x12, 0x2a, 0x0a, 0x0a, 0x6f, 0x70, 0x74, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65,
+	0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0b, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x4e, 0x65,
+	0x73, 0x74, 0x65, 0x64, 0x52, 0x09, 0x6f, 0x70, 0x74, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x22,
+	0xd3, 0x03, 0x0a, 0x05, 0x4e, 0x65, 0x73, 0x74, 0x73, 0x12, 0x2a, 0x0a, 0x0a, 0x6f, 0x70, 0x74,
+	0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0b, 0x2e,
+	0x70, 0x62, 0x32, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x52, 0x09, 0x6f, 0x70, 0x74, 0x4e,
+	0x65, 0x73, 0x74, 0x65, 0x64, 0x12, 0x2f, 0x0a, 0x08, 0x6f, 0x70, 0x74, 0x67, 0x72, 0x6f, 0x75,
+	0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0a, 0x32, 0x13, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x4e, 0x65,
+	0x73, 0x74, 0x73, 0x2e, 0x4f, 0x70, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x08, 0x6f, 0x70,
+	0x74, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x2a, 0x0a, 0x0a, 0x72, 0x70, 0x74, 0x5f, 0x6e, 0x65,
+	0x73, 0x74, 0x65, 0x64, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0b, 0x2e, 0x70, 0x62, 0x32,
+	0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x52, 0x09, 0x72, 0x70, 0x74, 0x4e, 0x65, 0x73, 0x74,
+	0x65, 0x64, 0x12, 0x2f, 0x0a, 0x08, 0x72, 0x70, 0x74, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x05,
+	0x20, 0x03, 0x28, 0x0a, 0x32, 0x13, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x73,
+	0x2e, 0x52, 0x70, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x08, 0x72, 0x70, 0x74, 0x67, 0x72,
+	0x6f, 0x75, 0x70, 0x1a, 0xd4, 0x01, 0x0a, 0x08, 0x4f, 0x70, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70,
+	0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x70, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6f, 0x70, 0x74, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12,
+	0x2a, 0x0a, 0x0a, 0x6f, 0x70, 0x74, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x0b, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64,
+	0x52, 0x09, 0x6f, 0x70, 0x74, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x12, 0x4a, 0x0a, 0x0e, 0x6f,
+	0x70, 0x74, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x03, 0x20,
+	0x01, 0x28, 0x0a, 0x32, 0x22, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x73, 0x2e,
+	0x4f, 0x70, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x4f, 0x70, 0x74, 0x4e, 0x65, 0x73, 0x74,
+	0x65, 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x0e, 0x6f, 0x70, 0x74, 0x6e, 0x65, 0x73, 0x74,
+	0x65, 0x64, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x1a, 0x31, 0x0a, 0x0e, 0x4f, 0x70, 0x74, 0x4e, 0x65,
+	0x73, 0x74, 0x65, 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x1f, 0x0a, 0x0b, 0x6f, 0x70, 0x74,
+	0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x01, 0x20, 0x01, 0x28, 0x07, 0x52, 0x0a,
+	0x6f, 0x70, 0x74, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x1a, 0x29, 0x0a, 0x08, 0x52, 0x70,
+	0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x70, 0x74, 0x5f, 0x73, 0x74,
+	0x72, 0x69, 0x6e, 0x67, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x72, 0x70, 0x74, 0x53,
+	0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x0e, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x5f,
+	0x66, 0x69, 0x65, 0x6c, 0x64, 0x22, 0xd9, 0x01, 0x0a, 0x09, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72,
+	0x65, 0x64, 0x73, 0x12, 0x19, 0x0a, 0x08, 0x72, 0x65, 0x71, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18,
+	0x01, 0x20, 0x02, 0x28, 0x08, 0x52, 0x07, 0x72, 0x65, 0x71, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x21,
+	0x0a, 0x0c, 0x72, 0x65, 0x71, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x02,
+	0x20, 0x02, 0x28, 0x10, 0x52, 0x0b, 0x72, 0x65, 0x71, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36,
+	0x34, 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x65, 0x71, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18,
+	0x03, 0x20, 0x02, 0x28, 0x01, 0x52, 0x09, 0x72, 0x65, 0x71, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65,
+	0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x65, 0x71, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x04,
+	0x20, 0x02, 0x28, 0x09, 0x52, 0x09, 0x72, 0x65, 0x71, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12,
+	0x24, 0x0a, 0x08, 0x72, 0x65, 0x71, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x05, 0x20, 0x02, 0x28,
+	0x0e, 0x32, 0x09, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x07, 0x72, 0x65,
+	0x71, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x2a, 0x0a, 0x0a, 0x72, 0x65, 0x71, 0x5f, 0x6e, 0x65, 0x73,
+	0x74, 0x65, 0x64, 0x18, 0x06, 0x20, 0x02, 0x28, 0x0b, 0x32, 0x0b, 0x2e, 0x70, 0x62, 0x32, 0x2e,
+	0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x52, 0x09, 0x72, 0x65, 0x71, 0x4e, 0x65, 0x73, 0x74, 0x65,
+	0x64, 0x22, 0x4f, 0x0a, 0x0f, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75,
+	0x69, 0x72, 0x65, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x65, 0x71, 0x5f, 0x73, 0x74, 0x72, 0x69,
+	0x6e, 0x67, 0x18, 0x01, 0x20, 0x02, 0x28, 0x09, 0x52, 0x09, 0x72, 0x65, 0x71, 0x53, 0x74, 0x72,
+	0x69, 0x6e, 0x67, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x70, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e,
+	0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6f, 0x70, 0x74, 0x53, 0x74, 0x72, 0x69,
+	0x6e, 0x67, 0x22, 0x33, 0x0a, 0x12, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x57, 0x69, 0x74, 0x68,
+	0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x65, 0x71, 0x5f,
+	0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x01, 0x20, 0x02, 0x28, 0x09, 0x52, 0x09, 0x72, 0x65,
+	0x71, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0xee, 0x02, 0x0a, 0x10, 0x49, 0x6e, 0x64, 0x69,
+	0x72, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x12, 0x36, 0x0a, 0x0a,
+	0x6f, 0x70, 0x74, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x17, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x57, 0x69, 0x74,
+	0x68, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x52, 0x09, 0x6f, 0x70, 0x74, 0x4e, 0x65,
+	0x73, 0x74, 0x65, 0x64, 0x12, 0x36, 0x0a, 0x0a, 0x72, 0x70, 0x74, 0x5f, 0x6e, 0x65, 0x73, 0x74,
+	0x65, 0x64, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x4e,
+	0x65, 0x73, 0x74, 0x65, 0x64, 0x57, 0x69, 0x74, 0x68, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65,
+	0x64, 0x52, 0x09, 0x72, 0x70, 0x74, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x12, 0x4a, 0x0a, 0x0d,
+	0x73, 0x74, 0x72, 0x5f, 0x74, 0x6f, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x18, 0x03, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x49, 0x6e, 0x64, 0x69, 0x72, 0x65,
+	0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x2e, 0x53, 0x74, 0x72, 0x54, 0x6f,
+	0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0b, 0x73, 0x74, 0x72,
+	0x54, 0x6f, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x12, 0x3c, 0x0a, 0x0c, 0x6f, 0x6e, 0x65, 0x6f,
+	0x66, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17,
+	0x2e, 0x70, 0x62, 0x32, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x57, 0x69, 0x74, 0x68, 0x52,
+	0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x48, 0x00, 0x52, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66,
+	0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x1a, 0x57, 0x0a, 0x10, 0x53, 0x74, 0x72, 0x54, 0x6f, 0x4e,
+	0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65,
+	0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x2d, 0x0a, 0x05,
+	0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x70, 0x62,
+	0x32, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x57, 0x69, 0x74, 0x68, 0x52, 0x65, 0x71, 0x75,
+	0x69, 0x72, 0x65, 0x64, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x42,
+	0x07, 0x0a, 0x05, 0x75, 0x6e, 0x69, 0x6f, 0x6e, 0x22, 0x69, 0x0a, 0x0a, 0x45, 0x78, 0x74, 0x65,
+	0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x70, 0x74, 0x5f, 0x73, 0x74,
+	0x72, 0x69, 0x6e, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6f, 0x70, 0x74, 0x53,
+	0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x19, 0x0a, 0x08, 0x6f, 0x70, 0x74, 0x5f, 0x62, 0x6f, 0x6f,
+	0x6c, 0x18, 0x65, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x42, 0x6f, 0x6f, 0x6c,
+	0x12, 0x1b, 0x0a, 0x09, 0x6f, 0x70, 0x74, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x05, 0x52, 0x08, 0x6f, 0x70, 0x74, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x2a, 0x04, 0x08,
+	0x14, 0x10, 0x65, 0x22, 0x89, 0x04, 0x0a, 0x13, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f,
+	0x6e, 0x73, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x32, 0x31, 0x0a, 0x0c, 0x6f,
+	0x70, 0x74, 0x5f, 0x65, 0x78, 0x74, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x12, 0x0f, 0x2e, 0x70, 0x62,
+	0x32, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x33, 0x20, 0x01,
+	0x28, 0x08, 0x52, 0x0a, 0x6f, 0x70, 0x74, 0x45, 0x78, 0x74, 0x42, 0x6f, 0x6f, 0x6c, 0x32, 0x35,
+	0x0a, 0x0e, 0x6f, 0x70, 0x74, 0x5f, 0x65, 0x78, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67,
+	0x12, 0x0f, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
+	0x73, 0x18, 0x34, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x6f, 0x70, 0x74, 0x45, 0x78, 0x74, 0x53,
+	0x74, 0x72, 0x69, 0x6e, 0x67, 0x32, 0x3c, 0x0a, 0x0c, 0x6f, 0x70, 0x74, 0x5f, 0x65, 0x78, 0x74,
+	0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x12, 0x0f, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x45, 0x78, 0x74, 0x65,
+	0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x35, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x09, 0x2e, 0x70,
+	0x62, 0x32, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0a, 0x6f, 0x70, 0x74, 0x45, 0x78, 0x74, 0x45,
+	0x6e, 0x75, 0x6d, 0x32, 0x42, 0x0a, 0x0e, 0x6f, 0x70, 0x74, 0x5f, 0x65, 0x78, 0x74, 0x5f, 0x6e,
+	0x65, 0x73, 0x74, 0x65, 0x64, 0x12, 0x0f, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x45, 0x78, 0x74, 0x65,
+	0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x36, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0b, 0x2e, 0x70,
+	0x62, 0x32, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x52, 0x0c, 0x6f, 0x70, 0x74, 0x45, 0x78,
+	0x74, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x32, 0x4d, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x5f, 0x65,
+	0x78, 0x74, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x12, 0x0f, 0x2e, 0x70, 0x62, 0x32,
+	0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x37, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x14, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x52,
+	0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x45, 0x78, 0x74, 0x50,
+	0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x32, 0x35, 0x0a, 0x0e, 0x72, 0x70, 0x74, 0x5f, 0x65, 0x78,
+	0x74, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x0f, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x45,
+	0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x3d, 0x20, 0x03, 0x28, 0x09, 0x52,
+	0x0c, 0x72, 0x70, 0x74, 0x45, 0x78, 0x74, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x32, 0x3c, 0x0a,
+	0x0c, 0x72, 0x70, 0x74, 0x5f, 0x65, 0x78, 0x74, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x12, 0x0f, 0x2e,
+	0x70, 0x62, 0x32, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x3e,
+	0x20, 0x03, 0x28, 0x0e, 0x32, 0x09, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x52,
+	0x0a, 0x72, 0x70, 0x74, 0x45, 0x78, 0x74, 0x45, 0x6e, 0x75, 0x6d, 0x32, 0x42, 0x0a, 0x0e, 0x72,
+	0x70, 0x74, 0x5f, 0x65, 0x78, 0x74, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x12, 0x0f, 0x2e,
+	0x70, 0x62, 0x32, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x3f,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x0b, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65,
+	0x64, 0x52, 0x0c, 0x72, 0x70, 0x74, 0x45, 0x78, 0x74, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x22,
+	0x1a, 0x0a, 0x0a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x2a, 0x08, 0x08,
+	0x04, 0x10, 0xff, 0xff, 0xff, 0xff, 0x07, 0x3a, 0x02, 0x08, 0x01, 0x22, 0xb6, 0x02, 0x0a, 0x13,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73,
+	0x69, 0x6f, 0x6e, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x70, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e,
+	0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6f, 0x70, 0x74, 0x53, 0x74, 0x72, 0x69,
+	0x6e, 0x67, 0x32, 0x5d, 0x0a, 0x15, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x65,
+	0x74, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x0f, 0x2e, 0x70, 0x62,
+	0x32, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x18, 0x0a, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x18, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x53, 0x65, 0x74, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f,
+	0x6e, 0x32, 0x64, 0x0a, 0x19, 0x6e, 0x6f, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x5f, 0x73, 0x65, 0x74, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x0f,
+	0x2e, 0x70, 0x62, 0x32, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x18,
+	0x14, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52,
+	0x16, 0x6e, 0x6f, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x45, 0x78,
+	0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x32, 0x3b, 0x0a, 0x0a, 0x65, 0x78, 0x74, 0x5f, 0x6e,
+	0x65, 0x73, 0x74, 0x65, 0x64, 0x12, 0x0f, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x18, 0x1e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0b, 0x2e, 0x70,
+	0x62, 0x32, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x52, 0x09, 0x65, 0x78, 0x74, 0x4e, 0x65,
+	0x73, 0x74, 0x65, 0x64, 0x22, 0x1a, 0x0a, 0x0e, 0x46, 0x61, 0x6b, 0x65, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x2a, 0x08, 0x08, 0x04, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02,
+	0x22, 0x9f, 0x01, 0x0a, 0x17, 0x46, 0x61, 0x6b, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x53, 0x65, 0x74, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x1d, 0x0a, 0x0a,
+	0x6f, 0x70, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x09, 0x6f, 0x70, 0x74, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x32, 0x65, 0x0a, 0x15, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x65, 0x74, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x6e,
+	0x73, 0x69, 0x6f, 0x6e, 0x12, 0x13, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x46, 0x61, 0x6b, 0x65, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x1c, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x46, 0x61, 0x6b, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x53, 0x65, 0x74, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69,
+	0x6f, 0x6e, 0x22, 0x9e, 0x08, 0x0a, 0x0a, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x54, 0x79, 0x70, 0x65,
+	0x73, 0x12, 0x35, 0x0a, 0x08, 0x6f, 0x70, 0x74, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x42, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52,
+	0x07, 0x6f, 0x70, 0x74, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x38, 0x0a, 0x09, 0x6f, 0x70, 0x74, 0x5f,
+	0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x49, 0x6e,
+	0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x08, 0x6f, 0x70, 0x74, 0x49, 0x6e, 0x74,
+	0x33, 0x32, 0x12, 0x38, 0x0a, 0x09, 0x6f, 0x70, 0x74, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c,
+	0x75, 0x65, 0x52, 0x08, 0x6f, 0x70, 0x74, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x3b, 0x0a, 0x0a,
+	0x6f, 0x70, 0x74, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
+	0x75, 0x66, 0x2e, 0x55, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x09,
+	0x6f, 0x70, 0x74, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x3b, 0x0a, 0x0a, 0x6f, 0x70, 0x74,
+	0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
+	0x55, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x09, 0x6f, 0x70, 0x74,
+	0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x38, 0x0a, 0x09, 0x6f, 0x70, 0x74, 0x5f, 0x66, 0x6c,
+	0x6f, 0x61, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x6c, 0x6f, 0x61,
+	0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x08, 0x6f, 0x70, 0x74, 0x46, 0x6c, 0x6f, 0x61, 0x74,
+	0x12, 0x3b, 0x0a, 0x0a, 0x6f, 0x70, 0x74, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0x07,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x56, 0x61, 0x6c,
+	0x75, 0x65, 0x52, 0x09, 0x6f, 0x70, 0x74, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x3b, 0x0a,
+	0x0a, 0x6f, 0x70, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x08, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52,
+	0x09, 0x6f, 0x70, 0x74, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x38, 0x0a, 0x09, 0x6f, 0x70,
+	0x74, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
+	0x42, 0x79, 0x74, 0x65, 0x73, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x08, 0x6f, 0x70, 0x74, 0x42,
+	0x79, 0x74, 0x65, 0x73, 0x12, 0x3c, 0x0a, 0x0c, 0x6f, 0x70, 0x74, 0x5f, 0x64, 0x75, 0x72, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x18, 0x14, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0b, 0x6f, 0x70, 0x74, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x12, 0x3f, 0x0a, 0x0d, 0x6f, 0x70, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74,
+	0x61, 0x6d, 0x70, 0x18, 0x15, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65,
+	0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0c, 0x6f, 0x70, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74,
+	0x61, 0x6d, 0x70, 0x12, 0x36, 0x0a, 0x0a, 0x6f, 0x70, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x75, 0x63,
+	0x74, 0x18, 0x19, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74,
+	0x52, 0x09, 0x6f, 0x70, 0x74, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x12, 0x35, 0x0a, 0x08, 0x6f,
+	0x70, 0x74, 0x5f, 0x6c, 0x69, 0x73, 0x74, 0x18, 0x1a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
+	0x4c, 0x69, 0x73, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x4c, 0x69,
+	0x73, 0x74, 0x12, 0x33, 0x0a, 0x09, 0x6f, 0x70, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18,
+	0x1b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x08, 0x6f,
+	0x70, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x35, 0x0a, 0x08, 0x6f, 0x70, 0x74, 0x5f, 0x6e,
+	0x75, 0x6c, 0x6c, 0x18, 0x1c, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4e, 0x75, 0x6c, 0x6c,
+	0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x4e, 0x75, 0x6c, 0x6c, 0x12, 0x33,
+	0x0a, 0x09, 0x6f, 0x70, 0x74, 0x5f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x18, 0x1e, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x52, 0x08, 0x6f, 0x70, 0x74, 0x45, 0x6d,
+	0x70, 0x74, 0x79, 0x12, 0x2d, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x5f, 0x61, 0x6e, 0x79, 0x18, 0x20,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x52, 0x06, 0x6f, 0x70, 0x74, 0x41,
+	0x6e, 0x79, 0x12, 0x3f, 0x0a, 0x0d, 0x6f, 0x70, 0x74, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x6d,
+	0x61, 0x73, 0x6b, 0x18, 0x28, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c,
+	0x64, 0x4d, 0x61, 0x73, 0x6b, 0x52, 0x0c, 0x6f, 0x70, 0x74, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x6d,
+	0x61, 0x73, 0x6b, 0x2a, 0x21, 0x0a, 0x04, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x07, 0x0a, 0x03, 0x4f,
+	0x4e, 0x45, 0x10, 0x01, 0x12, 0x07, 0x0a, 0x03, 0x54, 0x57, 0x4f, 0x10, 0x02, 0x12, 0x07, 0x0a,
+	0x03, 0x54, 0x45, 0x4e, 0x10, 0x0a, 0x3a, 0x31, 0x0a, 0x0c, 0x6f, 0x70, 0x74, 0x5f, 0x65, 0x78,
+	0x74, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x12, 0x0f, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x45, 0x78, 0x74,
+	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x15, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x6f,
+	0x70, 0x74, 0x45, 0x78, 0x74, 0x42, 0x6f, 0x6f, 0x6c, 0x3a, 0x35, 0x0a, 0x0e, 0x6f, 0x70, 0x74,
+	0x5f, 0x65, 0x78, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x0f, 0x2e, 0x70, 0x62,
+	0x32, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x16, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x0c, 0x6f, 0x70, 0x74, 0x45, 0x78, 0x74, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67,
+	0x3a, 0x3c, 0x0a, 0x0c, 0x6f, 0x70, 0x74, 0x5f, 0x65, 0x78, 0x74, 0x5f, 0x65, 0x6e, 0x75, 0x6d,
+	0x12, 0x0f, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
+	0x73, 0x18, 0x17, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x09, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x45, 0x6e,
+	0x75, 0x6d, 0x52, 0x0a, 0x6f, 0x70, 0x74, 0x45, 0x78, 0x74, 0x45, 0x6e, 0x75, 0x6d, 0x3a, 0x42,
+	0x0a, 0x0e, 0x6f, 0x70, 0x74, 0x5f, 0x65, 0x78, 0x74, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64,
+	0x12, 0x0f, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
+	0x73, 0x18, 0x18, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0b, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x4e, 0x65,
+	0x73, 0x74, 0x65, 0x64, 0x52, 0x0c, 0x6f, 0x70, 0x74, 0x45, 0x78, 0x74, 0x4e, 0x65, 0x73, 0x74,
+	0x65, 0x64, 0x3a, 0x4d, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x5f, 0x65, 0x78, 0x74, 0x5f, 0x70, 0x61,
+	0x72, 0x74, 0x69, 0x61, 0x6c, 0x12, 0x0f, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x45, 0x78, 0x74, 0x65,
+	0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x19, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x70,
+	0x62, 0x32, 0x2e, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72,
+	0x65, 0x64, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x45, 0x78, 0x74, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61,
+	0x6c, 0x3a, 0x37, 0x0a, 0x0f, 0x72, 0x70, 0x74, 0x5f, 0x65, 0x78, 0x74, 0x5f, 0x66, 0x69, 0x78,
+	0x65, 0x64, 0x33, 0x32, 0x12, 0x0f, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e,
+	0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x1f, 0x20, 0x03, 0x28, 0x07, 0x52, 0x0d, 0x72, 0x70, 0x74,
+	0x45, 0x78, 0x74, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x3a, 0x3c, 0x0a, 0x0c, 0x72, 0x70,
+	0x74, 0x5f, 0x65, 0x78, 0x74, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x12, 0x0f, 0x2e, 0x70, 0x62, 0x32,
+	0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x20, 0x20, 0x03, 0x28,
+	0x0e, 0x32, 0x09, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0a, 0x72, 0x70,
+	0x74, 0x45, 0x78, 0x74, 0x45, 0x6e, 0x75, 0x6d, 0x3a, 0x42, 0x0a, 0x0e, 0x72, 0x70, 0x74, 0x5f,
+	0x65, 0x78, 0x74, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x12, 0x0f, 0x2e, 0x70, 0x62, 0x32,
+	0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x21, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x0b, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x52, 0x0c,
+	0x72, 0x70, 0x74, 0x45, 0x78, 0x74, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x3a, 0x61, 0x0a, 0x15,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x65, 0x74, 0x5f, 0x65, 0x78, 0x74, 0x65,
+	0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x0f, 0x2e, 0x70, 0x62, 0x32, 0x2e, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x18, 0x32, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x70,
+	0x62, 0x32, 0x2e, 0x46, 0x61, 0x6b, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65,
+	0x74, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x42,
+	0x38, 0x5a, 0x36, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67,
+	0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x69, 0x6e,
+	0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x73, 0x2f, 0x74, 0x65, 0x78, 0x74, 0x70, 0x62, 0x32,
+}
+
+var (
+	file_internal_testprotos_textpb2_test_proto_rawDescOnce sync.Once
+	file_internal_testprotos_textpb2_test_proto_rawDescData = file_internal_testprotos_textpb2_test_proto_rawDesc
+)
+
+func file_internal_testprotos_textpb2_test_proto_rawDescGZIP() []byte {
+	file_internal_testprotos_textpb2_test_proto_rawDescOnce.Do(func() {
+		file_internal_testprotos_textpb2_test_proto_rawDescData = protoimpl.X.CompressGZIP(file_internal_testprotos_textpb2_test_proto_rawDescData)
+	})
+	return file_internal_testprotos_textpb2_test_proto_rawDescData
+}
+
+var file_internal_testprotos_textpb2_test_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
+var file_internal_testprotos_textpb2_test_proto_msgTypes = make([]protoimpl.MessageInfo, 23)
+var file_internal_testprotos_textpb2_test_proto_goTypes = []interface{}{
+	(Enum)(0),                             // 0: pb2.Enum
+	(Enums_NestedEnum)(0),                 // 1: pb2.Enums.NestedEnum
+	(*Scalars)(nil),                       // 2: pb2.Scalars
+	(*Enums)(nil),                         // 3: pb2.Enums
+	(*Repeats)(nil),                       // 4: pb2.Repeats
+	(*Maps)(nil),                          // 5: pb2.Maps
+	(*Nested)(nil),                        // 6: pb2.Nested
+	(*Nests)(nil),                         // 7: pb2.Nests
+	(*Requireds)(nil),                     // 8: pb2.Requireds
+	(*PartialRequired)(nil),               // 9: pb2.PartialRequired
+	(*NestedWithRequired)(nil),            // 10: pb2.NestedWithRequired
+	(*IndirectRequired)(nil),              // 11: pb2.IndirectRequired
+	(*Extensions)(nil),                    // 12: pb2.Extensions
+	(*ExtensionsContainer)(nil),           // 13: pb2.ExtensionsContainer
+	(*MessageSet)(nil),                    // 14: pb2.MessageSet
+	(*MessageSetExtension)(nil),           // 15: pb2.MessageSetExtension
+	(*FakeMessageSet)(nil),                // 16: pb2.FakeMessageSet
+	(*FakeMessageSetExtension)(nil),       // 17: pb2.FakeMessageSetExtension
+	(*KnownTypes)(nil),                    // 18: pb2.KnownTypes
+	nil,                                   // 19: pb2.Maps.Int32ToStrEntry
+	nil,                                   // 20: pb2.Maps.StrToNestedEntry
+	(*Nests_OptGroup)(nil),                // 21: pb2.Nests.OptGroup
+	(*Nests_RptGroup)(nil),                // 22: pb2.Nests.RptGroup
+	(*Nests_OptGroup_OptNestedGroup)(nil), // 23: pb2.Nests.OptGroup.OptNestedGroup
+	nil,                                   // 24: pb2.IndirectRequired.StrToNestedEntry
+	(*wrapperspb.BoolValue)(nil),          // 25: google.protobuf.BoolValue
+	(*wrapperspb.Int32Value)(nil),         // 26: google.protobuf.Int32Value
+	(*wrapperspb.Int64Value)(nil),         // 27: google.protobuf.Int64Value
+	(*wrapperspb.UInt32Value)(nil),        // 28: google.protobuf.UInt32Value
+	(*wrapperspb.UInt64Value)(nil),        // 29: google.protobuf.UInt64Value
+	(*wrapperspb.FloatValue)(nil),         // 30: google.protobuf.FloatValue
+	(*wrapperspb.DoubleValue)(nil),        // 31: google.protobuf.DoubleValue
+	(*wrapperspb.StringValue)(nil),        // 32: google.protobuf.StringValue
+	(*wrapperspb.BytesValue)(nil),         // 33: google.protobuf.BytesValue
+	(*durationpb.Duration)(nil),           // 34: google.protobuf.Duration
+	(*timestamppb.Timestamp)(nil),         // 35: google.protobuf.Timestamp
+	(*structpb.Struct)(nil),               // 36: google.protobuf.Struct
+	(*structpb.ListValue)(nil),            // 37: google.protobuf.ListValue
+	(*structpb.Value)(nil),                // 38: google.protobuf.Value
+	(structpb.NullValue)(0),               // 39: google.protobuf.NullValue
+	(*emptypb.Empty)(nil),                 // 40: google.protobuf.Empty
+	(*anypb.Any)(nil),                     // 41: google.protobuf.Any
+	(*fieldmaskpb.FieldMask)(nil),         // 42: google.protobuf.FieldMask
+}
+var file_internal_testprotos_textpb2_test_proto_depIdxs = []int32{
+	0,  // 0: pb2.Enums.opt_enum:type_name -> pb2.Enum
+	0,  // 1: pb2.Enums.rpt_enum:type_name -> pb2.Enum
+	1,  // 2: pb2.Enums.opt_nested_enum:type_name -> pb2.Enums.NestedEnum
+	1,  // 3: pb2.Enums.rpt_nested_enum:type_name -> pb2.Enums.NestedEnum
+	19, // 4: pb2.Maps.int32_to_str:type_name -> pb2.Maps.Int32ToStrEntry
+	20, // 5: pb2.Maps.str_to_nested:type_name -> pb2.Maps.StrToNestedEntry
+	6,  // 6: pb2.Nested.opt_nested:type_name -> pb2.Nested
+	6,  // 7: pb2.Nests.opt_nested:type_name -> pb2.Nested
+	21, // 8: pb2.Nests.optgroup:type_name -> pb2.Nests.OptGroup
+	6,  // 9: pb2.Nests.rpt_nested:type_name -> pb2.Nested
+	22, // 10: pb2.Nests.rptgroup:type_name -> pb2.Nests.RptGroup
+	0,  // 11: pb2.Requireds.req_enum:type_name -> pb2.Enum
+	6,  // 12: pb2.Requireds.req_nested:type_name -> pb2.Nested
+	10, // 13: pb2.IndirectRequired.opt_nested:type_name -> pb2.NestedWithRequired
+	10, // 14: pb2.IndirectRequired.rpt_nested:type_name -> pb2.NestedWithRequired
+	24, // 15: pb2.IndirectRequired.str_to_nested:type_name -> pb2.IndirectRequired.StrToNestedEntry
+	10, // 16: pb2.IndirectRequired.oneof_nested:type_name -> pb2.NestedWithRequired
+	25, // 17: pb2.KnownTypes.opt_bool:type_name -> google.protobuf.BoolValue
+	26, // 18: pb2.KnownTypes.opt_int32:type_name -> google.protobuf.Int32Value
+	27, // 19: pb2.KnownTypes.opt_int64:type_name -> google.protobuf.Int64Value
+	28, // 20: pb2.KnownTypes.opt_uint32:type_name -> google.protobuf.UInt32Value
+	29, // 21: pb2.KnownTypes.opt_uint64:type_name -> google.protobuf.UInt64Value
+	30, // 22: pb2.KnownTypes.opt_float:type_name -> google.protobuf.FloatValue
+	31, // 23: pb2.KnownTypes.opt_double:type_name -> google.protobuf.DoubleValue
+	32, // 24: pb2.KnownTypes.opt_string:type_name -> google.protobuf.StringValue
+	33, // 25: pb2.KnownTypes.opt_bytes:type_name -> google.protobuf.BytesValue
+	34, // 26: pb2.KnownTypes.opt_duration:type_name -> google.protobuf.Duration
+	35, // 27: pb2.KnownTypes.opt_timestamp:type_name -> google.protobuf.Timestamp
+	36, // 28: pb2.KnownTypes.opt_struct:type_name -> google.protobuf.Struct
+	37, // 29: pb2.KnownTypes.opt_list:type_name -> google.protobuf.ListValue
+	38, // 30: pb2.KnownTypes.opt_value:type_name -> google.protobuf.Value
+	39, // 31: pb2.KnownTypes.opt_null:type_name -> google.protobuf.NullValue
+	40, // 32: pb2.KnownTypes.opt_empty:type_name -> google.protobuf.Empty
+	41, // 33: pb2.KnownTypes.opt_any:type_name -> google.protobuf.Any
+	42, // 34: pb2.KnownTypes.opt_fieldmask:type_name -> google.protobuf.FieldMask
+	6,  // 35: pb2.Maps.StrToNestedEntry.value:type_name -> pb2.Nested
+	6,  // 36: pb2.Nests.OptGroup.opt_nested:type_name -> pb2.Nested
+	23, // 37: pb2.Nests.OptGroup.optnestedgroup:type_name -> pb2.Nests.OptGroup.OptNestedGroup
+	10, // 38: pb2.IndirectRequired.StrToNestedEntry.value:type_name -> pb2.NestedWithRequired
+	12, // 39: pb2.opt_ext_bool:extendee -> pb2.Extensions
+	12, // 40: pb2.opt_ext_string:extendee -> pb2.Extensions
+	12, // 41: pb2.opt_ext_enum:extendee -> pb2.Extensions
+	12, // 42: pb2.opt_ext_nested:extendee -> pb2.Extensions
+	12, // 43: pb2.opt_ext_partial:extendee -> pb2.Extensions
+	12, // 44: pb2.rpt_ext_fixed32:extendee -> pb2.Extensions
+	12, // 45: pb2.rpt_ext_enum:extendee -> pb2.Extensions
+	12, // 46: pb2.rpt_ext_nested:extendee -> pb2.Extensions
+	14, // 47: pb2.message_set_extension:extendee -> pb2.MessageSet
+	12, // 48: pb2.ExtensionsContainer.opt_ext_bool:extendee -> pb2.Extensions
+	12, // 49: pb2.ExtensionsContainer.opt_ext_string:extendee -> pb2.Extensions
+	12, // 50: pb2.ExtensionsContainer.opt_ext_enum:extendee -> pb2.Extensions
+	12, // 51: pb2.ExtensionsContainer.opt_ext_nested:extendee -> pb2.Extensions
+	12, // 52: pb2.ExtensionsContainer.opt_ext_partial:extendee -> pb2.Extensions
+	12, // 53: pb2.ExtensionsContainer.rpt_ext_string:extendee -> pb2.Extensions
+	12, // 54: pb2.ExtensionsContainer.rpt_ext_enum:extendee -> pb2.Extensions
+	12, // 55: pb2.ExtensionsContainer.rpt_ext_nested:extendee -> pb2.Extensions
+	14, // 56: pb2.MessageSetExtension.message_set_extension:extendee -> pb2.MessageSet
+	14, // 57: pb2.MessageSetExtension.not_message_set_extension:extendee -> pb2.MessageSet
+	14, // 58: pb2.MessageSetExtension.ext_nested:extendee -> pb2.MessageSet
+	16, // 59: pb2.FakeMessageSetExtension.message_set_extension:extendee -> pb2.FakeMessageSet
+	0,  // 60: pb2.opt_ext_enum:type_name -> pb2.Enum
+	6,  // 61: pb2.opt_ext_nested:type_name -> pb2.Nested
+	9,  // 62: pb2.opt_ext_partial:type_name -> pb2.PartialRequired
+	0,  // 63: pb2.rpt_ext_enum:type_name -> pb2.Enum
+	6,  // 64: pb2.rpt_ext_nested:type_name -> pb2.Nested
+	17, // 65: pb2.message_set_extension:type_name -> pb2.FakeMessageSetExtension
+	0,  // 66: pb2.ExtensionsContainer.opt_ext_enum:type_name -> pb2.Enum
+	6,  // 67: pb2.ExtensionsContainer.opt_ext_nested:type_name -> pb2.Nested
+	9,  // 68: pb2.ExtensionsContainer.opt_ext_partial:type_name -> pb2.PartialRequired
+	0,  // 69: pb2.ExtensionsContainer.rpt_ext_enum:type_name -> pb2.Enum
+	6,  // 70: pb2.ExtensionsContainer.rpt_ext_nested:type_name -> pb2.Nested
+	15, // 71: pb2.MessageSetExtension.message_set_extension:type_name -> pb2.MessageSetExtension
+	15, // 72: pb2.MessageSetExtension.not_message_set_extension:type_name -> pb2.MessageSetExtension
+	6,  // 73: pb2.MessageSetExtension.ext_nested:type_name -> pb2.Nested
+	17, // 74: pb2.FakeMessageSetExtension.message_set_extension:type_name -> pb2.FakeMessageSetExtension
+	75, // [75:75] is the sub-list for method output_type
+	75, // [75:75] is the sub-list for method input_type
+	60, // [60:75] is the sub-list for extension type_name
+	39, // [39:60] is the sub-list for extension extendee
+	0,  // [0:39] is the sub-list for field type_name
+}
+
+func init() { file_internal_testprotos_textpb2_test_proto_init() }
+func file_internal_testprotos_textpb2_test_proto_init() {
+	if File_internal_testprotos_textpb2_test_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_internal_testprotos_textpb2_test_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Scalars); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_textpb2_test_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Enums); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_textpb2_test_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Repeats); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_textpb2_test_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Maps); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_textpb2_test_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Nested); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_textpb2_test_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Nests); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_textpb2_test_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Requireds); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_textpb2_test_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*PartialRequired); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_textpb2_test_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*NestedWithRequired); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_textpb2_test_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*IndirectRequired); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_textpb2_test_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Extensions); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_textpb2_test_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ExtensionsContainer); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_textpb2_test_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MessageSet); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_textpb2_test_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MessageSetExtension); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_textpb2_test_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*FakeMessageSet); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_textpb2_test_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*FakeMessageSetExtension); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_textpb2_test_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*KnownTypes); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_textpb2_test_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Nests_OptGroup); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_textpb2_test_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Nests_RptGroup); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_textpb2_test_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Nests_OptGroup_OptNestedGroup); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	file_internal_testprotos_textpb2_test_proto_msgTypes[9].OneofWrappers = []interface{}{
+		(*IndirectRequired_OneofNested)(nil),
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_internal_testprotos_textpb2_test_proto_rawDesc,
+			NumEnums:      2,
+			NumMessages:   23,
+			NumExtensions: 21,
+			NumServices:   0,
+		},
+		GoTypes:           file_internal_testprotos_textpb2_test_proto_goTypes,
+		DependencyIndexes: file_internal_testprotos_textpb2_test_proto_depIdxs,
+		EnumInfos:         file_internal_testprotos_textpb2_test_proto_enumTypes,
+		MessageInfos:      file_internal_testprotos_textpb2_test_proto_msgTypes,
+		ExtensionInfos:    file_internal_testprotos_textpb2_test_proto_extTypes,
+	}.Build()
+	File_internal_testprotos_textpb2_test_proto = out.File
+	file_internal_testprotos_textpb2_test_proto_rawDesc = nil
+	file_internal_testprotos_textpb2_test_proto_goTypes = nil
+	file_internal_testprotos_textpb2_test_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/textpb2/test.proto b/vendor/google.golang.org/protobuf/internal/testprotos/textpb2/test.proto
new file mode 100644
index 000000000..a23558b28
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/textpb2/test.proto
@@ -0,0 +1,234 @@
+// Copyright 2019 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.
+
+// Test Protobuf definitions with proto2 syntax.
+syntax = "proto2";
+
+package pb2;
+option go_package = "google.golang.org/protobuf/internal/testprotos/textpb2";
+
+import "google/protobuf/any.proto";
+import "google/protobuf/empty.proto";
+import "google/protobuf/field_mask.proto";
+import "google/protobuf/duration.proto";
+import "google/protobuf/struct.proto";
+import "google/protobuf/timestamp.proto";
+import "google/protobuf/wrappers.proto";
+
+// Scalars contains optional scalar fields.
+message Scalars {
+  optional bool opt_bool = 1;
+  optional int32 opt_int32 = 2;
+  optional int64 opt_int64 = 3;
+  optional uint32 opt_uint32 = 4;
+  optional uint64 opt_uint64 = 5;
+  optional sint32 opt_sint32 = 6;
+  optional sint64 opt_sint64 = 7;
+  optional fixed32 opt_fixed32 = 8;
+  optional fixed64 opt_fixed64 = 9;
+  optional sfixed32 opt_sfixed32 = 10;
+  optional sfixed64 opt_sfixed64 = 11;
+
+  // Textproto marshal outputs fields in the same order as this proto
+  // definition regardless of field number. Following fields are intended to
+  // test that assumption.
+
+  optional float opt_float = 20;
+  optional double opt_double = 21;
+
+  optional bytes opt_bytes = 14;
+  optional string opt_string = 13;
+}
+
+enum Enum {
+  ONE = 1;
+  TWO = 2;
+  TEN = 10;
+}
+
+// Message contains enum fields.
+message Enums {
+  optional Enum opt_enum = 1;
+  repeated Enum rpt_enum = 2;
+
+  enum NestedEnum {
+	UNO = 1;
+	DOS = 2;
+	DIEZ = 10;
+  }
+  optional NestedEnum opt_nested_enum = 3;
+  repeated NestedEnum rpt_nested_enum = 4;
+}
+
+// Message contains repeated fields.
+message Repeats {
+  repeated bool rpt_bool = 1;
+  repeated int32 rpt_int32 = 2;
+  repeated int64 rpt_int64 = 3;
+  repeated uint32 rpt_uint32 = 4;
+  repeated uint64 rpt_uint64 = 5;
+  repeated float rpt_float = 6;
+  repeated double rpt_double = 7;
+  repeated string rpt_string = 8;
+  repeated bytes rpt_bytes = 9;
+}
+
+// Message contains map fields.
+message Maps {
+  map<int32, string> int32_to_str = 1;
+  map<string, Nested> str_to_nested = 4;
+}
+
+// Message type used as submessage.
+message Nested {
+  optional string opt_string = 1;
+  optional Nested opt_nested = 2;
+}
+
+// Message contains message and group fields.
+message Nests {
+  optional Nested opt_nested = 1;
+  optional group OptGroup = 2 {
+    optional string opt_string = 1;
+    optional Nested opt_nested = 2;
+
+    optional group OptNestedGroup = 3 {
+      optional fixed32 opt_fixed32 = 1;
+    }
+  }
+
+  repeated Nested rpt_nested = 4;
+  repeated group RptGroup = 5 {
+    repeated string rpt_string = 1;
+  }
+
+  reserved "reserved_field";
+}
+
+// Message contains required fields.
+message Requireds {
+  required bool req_bool = 1;
+  required sfixed64 req_sfixed64 = 2;
+  required double req_double = 3;
+  required string req_string = 4;
+  required Enum req_enum = 5;
+  required Nested req_nested = 6;
+}
+
+// Message contains both required and optional fields.
+message PartialRequired {
+  required string req_string = 1;
+  optional string opt_string = 2;
+}
+
+// Following messages are for testing required field nested in optional, repeated and map fields.
+
+message NestedWithRequired {
+  required string req_string = 1;
+}
+
+message IndirectRequired {
+  optional NestedWithRequired opt_nested = 1;
+  repeated NestedWithRequired rpt_nested = 2;
+  map<string, NestedWithRequired> str_to_nested = 3;
+
+  oneof union {
+    NestedWithRequired oneof_nested = 4;
+  }
+}
+
+// Following messages are for testing extensions.
+
+message Extensions {
+  optional string opt_string = 1;
+  extensions 20 to 100;
+  optional bool opt_bool = 101;
+  optional int32 opt_int32 = 2;
+}
+
+extend Extensions {
+  optional bool opt_ext_bool = 21;
+  optional string opt_ext_string = 22;
+  optional Enum opt_ext_enum = 23;
+  optional Nested opt_ext_nested = 24;
+  optional PartialRequired opt_ext_partial = 25;
+
+  repeated fixed32 rpt_ext_fixed32 = 31;
+  repeated Enum rpt_ext_enum = 32;
+  repeated Nested rpt_ext_nested = 33;
+}
+
+message ExtensionsContainer {
+  extend Extensions {
+    optional bool opt_ext_bool = 51;
+    optional string opt_ext_string = 52;
+    optional Enum opt_ext_enum = 53;
+    optional Nested opt_ext_nested = 54;
+    optional PartialRequired opt_ext_partial = 55;
+
+    repeated string rpt_ext_string = 61;
+    repeated Enum rpt_ext_enum = 62;
+    repeated Nested rpt_ext_nested = 63;
+  }
+}
+
+// Following messages are for testing MessageSet.
+
+message MessageSet {
+  option message_set_wire_format = true;
+
+  extensions 4 to max;
+}
+
+message MessageSetExtension {
+  optional string opt_string = 1;
+
+  extend MessageSet {
+    optional MessageSetExtension message_set_extension = 10;
+    optional MessageSetExtension not_message_set_extension = 20;
+    optional Nested ext_nested = 30;
+  }
+}
+
+message FakeMessageSet {
+  extensions 4 to max;
+}
+
+message FakeMessageSetExtension {
+  optional string opt_string = 1;
+
+  extend FakeMessageSet {
+    optional FakeMessageSetExtension message_set_extension = 10;
+  }
+}
+
+extend MessageSet {
+  optional FakeMessageSetExtension message_set_extension = 50;
+}
+
+// Message contains well-known type fields.
+message KnownTypes {
+  optional google.protobuf.BoolValue opt_bool = 1;
+  optional google.protobuf.Int32Value opt_int32 = 2;
+  optional google.protobuf.Int64Value opt_int64 = 3;
+  optional google.protobuf.UInt32Value opt_uint32 = 4;
+  optional google.protobuf.UInt64Value opt_uint64 = 5;
+  optional google.protobuf.FloatValue opt_float = 6;
+  optional google.protobuf.DoubleValue opt_double = 7;
+  optional google.protobuf.StringValue opt_string = 8;
+  optional google.protobuf.BytesValue opt_bytes = 9;
+
+  optional google.protobuf.Duration opt_duration = 20;
+  optional google.protobuf.Timestamp opt_timestamp = 21;
+
+  optional google.protobuf.Struct opt_struct = 25;
+  optional google.protobuf.ListValue opt_list = 26;
+  optional google.protobuf.Value opt_value = 27;
+  optional google.protobuf.NullValue opt_null = 28;
+
+  optional google.protobuf.Empty opt_empty = 30;
+  optional google.protobuf.Any opt_any = 32;
+
+  optional google.protobuf.FieldMask opt_fieldmask = 40;
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/textpb3/test.pb.go b/vendor/google.golang.org/protobuf/internal/testprotos/textpb3/test.pb.go
new file mode 100644
index 000000000..51e94c8eb
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/textpb3/test.pb.go
@@ -0,0 +1,1269 @@
+// 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.
+
+// Test Protobuf definitions with proto3 syntax.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: internal/testprotos/textpb3/test.proto
+
+package textpb3
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type Enum int32
+
+const (
+	Enum_ZERO Enum = 0
+	Enum_ONE  Enum = 1
+	Enum_TWO  Enum = 2
+	Enum_TEN  Enum = 10
+)
+
+// Enum value maps for Enum.
+var (
+	Enum_name = map[int32]string{
+		0:  "ZERO",
+		1:  "ONE",
+		2:  "TWO",
+		10: "TEN",
+	}
+	Enum_value = map[string]int32{
+		"ZERO": 0,
+		"ONE":  1,
+		"TWO":  2,
+		"TEN":  10,
+	}
+)
+
+func (x Enum) Enum() *Enum {
+	p := new(Enum)
+	*p = x
+	return p
+}
+
+func (x Enum) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enum) Descriptor() protoreflect.EnumDescriptor {
+	return file_internal_testprotos_textpb3_test_proto_enumTypes[0].Descriptor()
+}
+
+func (Enum) Type() protoreflect.EnumType {
+	return &file_internal_testprotos_textpb3_test_proto_enumTypes[0]
+}
+
+func (x Enum) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use Enum.Descriptor instead.
+func (Enum) EnumDescriptor() ([]byte, []int) {
+	return file_internal_testprotos_textpb3_test_proto_rawDescGZIP(), []int{0}
+}
+
+type Enums_NestedEnum int32
+
+const (
+	Enums_CERO Enums_NestedEnum = 0
+	Enums_UNO  Enums_NestedEnum = 1
+	Enums_DOS  Enums_NestedEnum = 2
+	Enums_DIEZ Enums_NestedEnum = 10
+)
+
+// Enum value maps for Enums_NestedEnum.
+var (
+	Enums_NestedEnum_name = map[int32]string{
+		0:  "CERO",
+		1:  "UNO",
+		2:  "DOS",
+		10: "DIEZ",
+	}
+	Enums_NestedEnum_value = map[string]int32{
+		"CERO": 0,
+		"UNO":  1,
+		"DOS":  2,
+		"DIEZ": 10,
+	}
+)
+
+func (x Enums_NestedEnum) Enum() *Enums_NestedEnum {
+	p := new(Enums_NestedEnum)
+	*p = x
+	return p
+}
+
+func (x Enums_NestedEnum) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Enums_NestedEnum) Descriptor() protoreflect.EnumDescriptor {
+	return file_internal_testprotos_textpb3_test_proto_enumTypes[1].Descriptor()
+}
+
+func (Enums_NestedEnum) Type() protoreflect.EnumType {
+	return &file_internal_testprotos_textpb3_test_proto_enumTypes[1]
+}
+
+func (x Enums_NestedEnum) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use Enums_NestedEnum.Descriptor instead.
+func (Enums_NestedEnum) EnumDescriptor() ([]byte, []int) {
+	return file_internal_testprotos_textpb3_test_proto_rawDescGZIP(), []int{3, 0}
+}
+
+// Scalars contains scalar field types.
+type Scalars struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	SBool     bool    `protobuf:"varint,1,opt,name=s_bool,json=sBool,proto3" json:"s_bool,omitempty"`
+	SInt32    int32   `protobuf:"varint,2,opt,name=s_int32,json=sInt32,proto3" json:"s_int32,omitempty"`
+	SInt64    int64   `protobuf:"varint,3,opt,name=s_int64,json=sInt64,proto3" json:"s_int64,omitempty"`
+	SUint32   uint32  `protobuf:"varint,4,opt,name=s_uint32,json=sUint32,proto3" json:"s_uint32,omitempty"`
+	SUint64   uint64  `protobuf:"varint,5,opt,name=s_uint64,json=sUint64,proto3" json:"s_uint64,omitempty"`
+	SSint32   int32   `protobuf:"zigzag32,6,opt,name=s_sint32,json=sSint32,proto3" json:"s_sint32,omitempty"`
+	SSint64   int64   `protobuf:"zigzag64,7,opt,name=s_sint64,json=sSint64,proto3" json:"s_sint64,omitempty"`
+	SFixed32  uint32  `protobuf:"fixed32,8,opt,name=s_fixed32,json=sFixed32,proto3" json:"s_fixed32,omitempty"`
+	SFixed64  uint64  `protobuf:"fixed64,9,opt,name=s_fixed64,json=sFixed64,proto3" json:"s_fixed64,omitempty"`
+	SSfixed32 int32   `protobuf:"fixed32,10,opt,name=s_sfixed32,json=sSfixed32,proto3" json:"s_sfixed32,omitempty"`
+	SSfixed64 int64   `protobuf:"fixed64,11,opt,name=s_sfixed64,json=sSfixed64,proto3" json:"s_sfixed64,omitempty"`
+	SFloat    float32 `protobuf:"fixed32,20,opt,name=s_float,json=sFloat,proto3" json:"s_float,omitempty"`
+	SDouble   float64 `protobuf:"fixed64,21,opt,name=s_double,json=sDouble,proto3" json:"s_double,omitempty"`
+	SBytes    []byte  `protobuf:"bytes,14,opt,name=s_bytes,json=sBytes,proto3" json:"s_bytes,omitempty"`
+	SString   string  `protobuf:"bytes,13,opt,name=s_string,json=sString,proto3" json:"s_string,omitempty"`
+}
+
+func (x *Scalars) Reset() {
+	*x = Scalars{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_textpb3_test_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Scalars) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Scalars) ProtoMessage() {}
+
+func (x *Scalars) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_textpb3_test_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Scalars.ProtoReflect.Descriptor instead.
+func (*Scalars) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_textpb3_test_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Scalars) GetSBool() bool {
+	if x != nil {
+		return x.SBool
+	}
+	return false
+}
+
+func (x *Scalars) GetSInt32() int32 {
+	if x != nil {
+		return x.SInt32
+	}
+	return 0
+}
+
+func (x *Scalars) GetSInt64() int64 {
+	if x != nil {
+		return x.SInt64
+	}
+	return 0
+}
+
+func (x *Scalars) GetSUint32() uint32 {
+	if x != nil {
+		return x.SUint32
+	}
+	return 0
+}
+
+func (x *Scalars) GetSUint64() uint64 {
+	if x != nil {
+		return x.SUint64
+	}
+	return 0
+}
+
+func (x *Scalars) GetSSint32() int32 {
+	if x != nil {
+		return x.SSint32
+	}
+	return 0
+}
+
+func (x *Scalars) GetSSint64() int64 {
+	if x != nil {
+		return x.SSint64
+	}
+	return 0
+}
+
+func (x *Scalars) GetSFixed32() uint32 {
+	if x != nil {
+		return x.SFixed32
+	}
+	return 0
+}
+
+func (x *Scalars) GetSFixed64() uint64 {
+	if x != nil {
+		return x.SFixed64
+	}
+	return 0
+}
+
+func (x *Scalars) GetSSfixed32() int32 {
+	if x != nil {
+		return x.SSfixed32
+	}
+	return 0
+}
+
+func (x *Scalars) GetSSfixed64() int64 {
+	if x != nil {
+		return x.SSfixed64
+	}
+	return 0
+}
+
+func (x *Scalars) GetSFloat() float32 {
+	if x != nil {
+		return x.SFloat
+	}
+	return 0
+}
+
+func (x *Scalars) GetSDouble() float64 {
+	if x != nil {
+		return x.SDouble
+	}
+	return 0
+}
+
+func (x *Scalars) GetSBytes() []byte {
+	if x != nil {
+		return x.SBytes
+	}
+	return nil
+}
+
+func (x *Scalars) GetSString() string {
+	if x != nil {
+		return x.SString
+	}
+	return ""
+}
+
+// Message contains repeated fields.
+type Repeats struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	RptBool   []bool    `protobuf:"varint,1,rep,packed,name=rpt_bool,json=rptBool,proto3" json:"rpt_bool,omitempty"`
+	RptInt32  []int32   `protobuf:"varint,2,rep,packed,name=rpt_int32,json=rptInt32,proto3" json:"rpt_int32,omitempty"`
+	RptInt64  []int64   `protobuf:"varint,3,rep,packed,name=rpt_int64,json=rptInt64,proto3" json:"rpt_int64,omitempty"`
+	RptUint32 []uint32  `protobuf:"varint,4,rep,packed,name=rpt_uint32,json=rptUint32,proto3" json:"rpt_uint32,omitempty"`
+	RptUint64 []uint64  `protobuf:"varint,5,rep,packed,name=rpt_uint64,json=rptUint64,proto3" json:"rpt_uint64,omitempty"`
+	RptFloat  []float32 `protobuf:"fixed32,6,rep,packed,name=rpt_float,json=rptFloat,proto3" json:"rpt_float,omitempty"`
+	RptDouble []float64 `protobuf:"fixed64,7,rep,packed,name=rpt_double,json=rptDouble,proto3" json:"rpt_double,omitempty"`
+	RptString []string  `protobuf:"bytes,8,rep,name=rpt_string,json=rptString,proto3" json:"rpt_string,omitempty"`
+	RptBytes  [][]byte  `protobuf:"bytes,9,rep,name=rpt_bytes,json=rptBytes,proto3" json:"rpt_bytes,omitempty"`
+}
+
+func (x *Repeats) Reset() {
+	*x = Repeats{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_textpb3_test_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Repeats) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Repeats) ProtoMessage() {}
+
+func (x *Repeats) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_textpb3_test_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Repeats.ProtoReflect.Descriptor instead.
+func (*Repeats) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_textpb3_test_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *Repeats) GetRptBool() []bool {
+	if x != nil {
+		return x.RptBool
+	}
+	return nil
+}
+
+func (x *Repeats) GetRptInt32() []int32 {
+	if x != nil {
+		return x.RptInt32
+	}
+	return nil
+}
+
+func (x *Repeats) GetRptInt64() []int64 {
+	if x != nil {
+		return x.RptInt64
+	}
+	return nil
+}
+
+func (x *Repeats) GetRptUint32() []uint32 {
+	if x != nil {
+		return x.RptUint32
+	}
+	return nil
+}
+
+func (x *Repeats) GetRptUint64() []uint64 {
+	if x != nil {
+		return x.RptUint64
+	}
+	return nil
+}
+
+func (x *Repeats) GetRptFloat() []float32 {
+	if x != nil {
+		return x.RptFloat
+	}
+	return nil
+}
+
+func (x *Repeats) GetRptDouble() []float64 {
+	if x != nil {
+		return x.RptDouble
+	}
+	return nil
+}
+
+func (x *Repeats) GetRptString() []string {
+	if x != nil {
+		return x.RptString
+	}
+	return nil
+}
+
+func (x *Repeats) GetRptBytes() [][]byte {
+	if x != nil {
+		return x.RptBytes
+	}
+	return nil
+}
+
+type Proto3Optional struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	OptBool    *bool    `protobuf:"varint,1,opt,name=opt_bool,json=optBool,proto3,oneof" json:"opt_bool,omitempty"`
+	OptInt32   *int32   `protobuf:"varint,2,opt,name=opt_int32,json=optInt32,proto3,oneof" json:"opt_int32,omitempty"`
+	OptInt64   *int64   `protobuf:"varint,3,opt,name=opt_int64,json=optInt64,proto3,oneof" json:"opt_int64,omitempty"`
+	OptUint32  *uint32  `protobuf:"varint,4,opt,name=opt_uint32,json=optUint32,proto3,oneof" json:"opt_uint32,omitempty"`
+	OptUint64  *uint64  `protobuf:"varint,5,opt,name=opt_uint64,json=optUint64,proto3,oneof" json:"opt_uint64,omitempty"`
+	OptFloat   *float32 `protobuf:"fixed32,6,opt,name=opt_float,json=optFloat,proto3,oneof" json:"opt_float,omitempty"`
+	OptDouble  *float64 `protobuf:"fixed64,7,opt,name=opt_double,json=optDouble,proto3,oneof" json:"opt_double,omitempty"`
+	OptString  *string  `protobuf:"bytes,8,opt,name=opt_string,json=optString,proto3,oneof" json:"opt_string,omitempty"`
+	OptBytes   []byte   `protobuf:"bytes,9,opt,name=opt_bytes,json=optBytes,proto3,oneof" json:"opt_bytes,omitempty"`
+	OptEnum    *Enum    `protobuf:"varint,10,opt,name=opt_enum,json=optEnum,proto3,enum=pb3.Enum,oneof" json:"opt_enum,omitempty"`
+	OptMessage *Nested  `protobuf:"bytes,11,opt,name=opt_message,json=optMessage,proto3,oneof" json:"opt_message,omitempty"`
+}
+
+func (x *Proto3Optional) Reset() {
+	*x = Proto3Optional{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_textpb3_test_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Proto3Optional) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Proto3Optional) ProtoMessage() {}
+
+func (x *Proto3Optional) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_textpb3_test_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Proto3Optional.ProtoReflect.Descriptor instead.
+func (*Proto3Optional) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_textpb3_test_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *Proto3Optional) GetOptBool() bool {
+	if x != nil && x.OptBool != nil {
+		return *x.OptBool
+	}
+	return false
+}
+
+func (x *Proto3Optional) GetOptInt32() int32 {
+	if x != nil && x.OptInt32 != nil {
+		return *x.OptInt32
+	}
+	return 0
+}
+
+func (x *Proto3Optional) GetOptInt64() int64 {
+	if x != nil && x.OptInt64 != nil {
+		return *x.OptInt64
+	}
+	return 0
+}
+
+func (x *Proto3Optional) GetOptUint32() uint32 {
+	if x != nil && x.OptUint32 != nil {
+		return *x.OptUint32
+	}
+	return 0
+}
+
+func (x *Proto3Optional) GetOptUint64() uint64 {
+	if x != nil && x.OptUint64 != nil {
+		return *x.OptUint64
+	}
+	return 0
+}
+
+func (x *Proto3Optional) GetOptFloat() float32 {
+	if x != nil && x.OptFloat != nil {
+		return *x.OptFloat
+	}
+	return 0
+}
+
+func (x *Proto3Optional) GetOptDouble() float64 {
+	if x != nil && x.OptDouble != nil {
+		return *x.OptDouble
+	}
+	return 0
+}
+
+func (x *Proto3Optional) GetOptString() string {
+	if x != nil && x.OptString != nil {
+		return *x.OptString
+	}
+	return ""
+}
+
+func (x *Proto3Optional) GetOptBytes() []byte {
+	if x != nil {
+		return x.OptBytes
+	}
+	return nil
+}
+
+func (x *Proto3Optional) GetOptEnum() Enum {
+	if x != nil && x.OptEnum != nil {
+		return *x.OptEnum
+	}
+	return Enum_ZERO
+}
+
+func (x *Proto3Optional) GetOptMessage() *Nested {
+	if x != nil {
+		return x.OptMessage
+	}
+	return nil
+}
+
+// Message contains enum fields.
+type Enums struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	SEnum       Enum             `protobuf:"varint,1,opt,name=s_enum,json=sEnum,proto3,enum=pb3.Enum" json:"s_enum,omitempty"`
+	SNestedEnum Enums_NestedEnum `protobuf:"varint,3,opt,name=s_nested_enum,json=sNestedEnum,proto3,enum=pb3.Enums_NestedEnum" json:"s_nested_enum,omitempty"`
+}
+
+func (x *Enums) Reset() {
+	*x = Enums{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_textpb3_test_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Enums) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Enums) ProtoMessage() {}
+
+func (x *Enums) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_textpb3_test_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Enums.ProtoReflect.Descriptor instead.
+func (*Enums) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_textpb3_test_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *Enums) GetSEnum() Enum {
+	if x != nil {
+		return x.SEnum
+	}
+	return Enum_ZERO
+}
+
+func (x *Enums) GetSNestedEnum() Enums_NestedEnum {
+	if x != nil {
+		return x.SNestedEnum
+	}
+	return Enums_CERO
+}
+
+// Message contains nested message field.
+type Nests struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	SNested *Nested `protobuf:"bytes,2,opt,name=s_nested,json=sNested,proto3" json:"s_nested,omitempty"`
+}
+
+func (x *Nests) Reset() {
+	*x = Nests{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_textpb3_test_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Nests) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Nests) ProtoMessage() {}
+
+func (x *Nests) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_textpb3_test_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Nests.ProtoReflect.Descriptor instead.
+func (*Nests) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_textpb3_test_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *Nests) GetSNested() *Nested {
+	if x != nil {
+		return x.SNested
+	}
+	return nil
+}
+
+// Message type used as submessage.
+type Nested struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	SString string  `protobuf:"bytes,1,opt,name=s_string,json=sString,proto3" json:"s_string,omitempty"`
+	SNested *Nested `protobuf:"bytes,2,opt,name=s_nested,json=sNested,proto3" json:"s_nested,omitempty"`
+}
+
+func (x *Nested) Reset() {
+	*x = Nested{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_textpb3_test_proto_msgTypes[5]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Nested) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Nested) ProtoMessage() {}
+
+func (x *Nested) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_textpb3_test_proto_msgTypes[5]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Nested.ProtoReflect.Descriptor instead.
+func (*Nested) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_textpb3_test_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *Nested) GetSString() string {
+	if x != nil {
+		return x.SString
+	}
+	return ""
+}
+
+func (x *Nested) GetSNested() *Nested {
+	if x != nil {
+		return x.SNested
+	}
+	return nil
+}
+
+// Message contains oneof field.
+type Oneofs struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// Types that are assignable to Union:
+	//	*Oneofs_OneofEnum
+	//	*Oneofs_OneofString
+	//	*Oneofs_OneofNested
+	Union isOneofs_Union `protobuf_oneof:"union"`
+}
+
+func (x *Oneofs) Reset() {
+	*x = Oneofs{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_textpb3_test_proto_msgTypes[6]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Oneofs) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Oneofs) ProtoMessage() {}
+
+func (x *Oneofs) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_textpb3_test_proto_msgTypes[6]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Oneofs.ProtoReflect.Descriptor instead.
+func (*Oneofs) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_textpb3_test_proto_rawDescGZIP(), []int{6}
+}
+
+func (m *Oneofs) GetUnion() isOneofs_Union {
+	if m != nil {
+		return m.Union
+	}
+	return nil
+}
+
+func (x *Oneofs) GetOneofEnum() Enum {
+	if x, ok := x.GetUnion().(*Oneofs_OneofEnum); ok {
+		return x.OneofEnum
+	}
+	return Enum_ZERO
+}
+
+func (x *Oneofs) GetOneofString() string {
+	if x, ok := x.GetUnion().(*Oneofs_OneofString); ok {
+		return x.OneofString
+	}
+	return ""
+}
+
+func (x *Oneofs) GetOneofNested() *Nested {
+	if x, ok := x.GetUnion().(*Oneofs_OneofNested); ok {
+		return x.OneofNested
+	}
+	return nil
+}
+
+type isOneofs_Union interface {
+	isOneofs_Union()
+}
+
+type Oneofs_OneofEnum struct {
+	OneofEnum Enum `protobuf:"varint,1,opt,name=oneof_enum,json=oneofEnum,proto3,enum=pb3.Enum,oneof"`
+}
+
+type Oneofs_OneofString struct {
+	OneofString string `protobuf:"bytes,2,opt,name=oneof_string,json=oneofString,proto3,oneof"`
+}
+
+type Oneofs_OneofNested struct {
+	OneofNested *Nested `protobuf:"bytes,3,opt,name=oneof_nested,json=oneofNested,proto3,oneof"`
+}
+
+func (*Oneofs_OneofEnum) isOneofs_Union() {}
+
+func (*Oneofs_OneofString) isOneofs_Union() {}
+
+func (*Oneofs_OneofNested) isOneofs_Union() {}
+
+// Message contains map fields.
+type Maps struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Int32ToStr   map[int32]string   `protobuf:"bytes,1,rep,name=int32_to_str,json=int32ToStr,proto3" json:"int32_to_str,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	BoolToUint32 map[bool]uint32    `protobuf:"bytes,2,rep,name=bool_to_uint32,json=boolToUint32,proto3" json:"bool_to_uint32,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+	Uint64ToEnum map[uint64]Enum    `protobuf:"bytes,3,rep,name=uint64_to_enum,json=uint64ToEnum,proto3" json:"uint64_to_enum,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3,enum=pb3.Enum"`
+	StrToNested  map[string]*Nested `protobuf:"bytes,4,rep,name=str_to_nested,json=strToNested,proto3" json:"str_to_nested,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	StrToOneofs  map[string]*Oneofs `protobuf:"bytes,5,rep,name=str_to_oneofs,json=strToOneofs,proto3" json:"str_to_oneofs,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+}
+
+func (x *Maps) Reset() {
+	*x = Maps{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_textpb3_test_proto_msgTypes[7]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Maps) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Maps) ProtoMessage() {}
+
+func (x *Maps) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_textpb3_test_proto_msgTypes[7]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Maps.ProtoReflect.Descriptor instead.
+func (*Maps) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_textpb3_test_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *Maps) GetInt32ToStr() map[int32]string {
+	if x != nil {
+		return x.Int32ToStr
+	}
+	return nil
+}
+
+func (x *Maps) GetBoolToUint32() map[bool]uint32 {
+	if x != nil {
+		return x.BoolToUint32
+	}
+	return nil
+}
+
+func (x *Maps) GetUint64ToEnum() map[uint64]Enum {
+	if x != nil {
+		return x.Uint64ToEnum
+	}
+	return nil
+}
+
+func (x *Maps) GetStrToNested() map[string]*Nested {
+	if x != nil {
+		return x.StrToNested
+	}
+	return nil
+}
+
+func (x *Maps) GetStrToOneofs() map[string]*Oneofs {
+	if x != nil {
+		return x.StrToOneofs
+	}
+	return nil
+}
+
+// Message for testing json_name option.
+type JSONNames struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	SString string `protobuf:"bytes,1,opt,name=s_string,json=foo_bar,proto3" json:"s_string,omitempty"`
+}
+
+func (x *JSONNames) Reset() {
+	*x = JSONNames{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_testprotos_textpb3_test_proto_msgTypes[8]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *JSONNames) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*JSONNames) ProtoMessage() {}
+
+func (x *JSONNames) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_testprotos_textpb3_test_proto_msgTypes[8]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use JSONNames.ProtoReflect.Descriptor instead.
+func (*JSONNames) Descriptor() ([]byte, []int) {
+	return file_internal_testprotos_textpb3_test_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *JSONNames) GetSString() string {
+	if x != nil {
+		return x.SString
+	}
+	return ""
+}
+
+var File_internal_testprotos_textpb3_test_proto protoreflect.FileDescriptor
+
+var file_internal_testprotos_textpb3_test_proto_rawDesc = []byte{
+	0x0a, 0x26, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x74, 0x65, 0x78, 0x74, 0x70, 0x62, 0x33, 0x2f, 0x74, 0x65,
+	0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x03, 0x70, 0x62, 0x33, 0x22, 0x9e, 0x03,
+	0x0a, 0x07, 0x53, 0x63, 0x61, 0x6c, 0x61, 0x72, 0x73, 0x12, 0x15, 0x0a, 0x06, 0x73, 0x5f, 0x62,
+	0x6f, 0x6f, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x73, 0x42, 0x6f, 0x6f, 0x6c,
+	0x12, 0x17, 0x0a, 0x07, 0x73, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x06, 0x73, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x17, 0x0a, 0x07, 0x73, 0x5f, 0x69,
+	0x6e, 0x74, 0x36, 0x34, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x73, 0x49, 0x6e, 0x74,
+	0x36, 0x34, 0x12, 0x19, 0x0a, 0x08, 0x73, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x04,
+	0x20, 0x01, 0x28, 0x0d, 0x52, 0x07, 0x73, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x19, 0x0a,
+	0x08, 0x73, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52,
+	0x07, 0x73, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x19, 0x0a, 0x08, 0x73, 0x5f, 0x73, 0x69,
+	0x6e, 0x74, 0x33, 0x32, 0x18, 0x06, 0x20, 0x01, 0x28, 0x11, 0x52, 0x07, 0x73, 0x53, 0x69, 0x6e,
+	0x74, 0x33, 0x32, 0x12, 0x19, 0x0a, 0x08, 0x73, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18,
+	0x07, 0x20, 0x01, 0x28, 0x12, 0x52, 0x07, 0x73, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x1b,
+	0x0a, 0x09, 0x73, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x08, 0x20, 0x01, 0x28,
+	0x07, 0x52, 0x08, 0x73, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x1b, 0x0a, 0x09, 0x73,
+	0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x09, 0x20, 0x01, 0x28, 0x06, 0x52, 0x08,
+	0x73, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x5f, 0x73, 0x66,
+	0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0f, 0x52, 0x09, 0x73, 0x53,
+	0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x5f, 0x73, 0x66, 0x69,
+	0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x10, 0x52, 0x09, 0x73, 0x53, 0x66,
+	0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x17, 0x0a, 0x07, 0x73, 0x5f, 0x66, 0x6c, 0x6f, 0x61,
+	0x74, 0x18, 0x14, 0x20, 0x01, 0x28, 0x02, 0x52, 0x06, 0x73, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12,
+	0x19, 0x0a, 0x08, 0x73, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0x15, 0x20, 0x01, 0x28,
+	0x01, 0x52, 0x07, 0x73, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x17, 0x0a, 0x07, 0x73, 0x5f,
+	0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x06, 0x73, 0x42, 0x79,
+	0x74, 0x65, 0x73, 0x12, 0x19, 0x0a, 0x08, 0x73, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18,
+	0x0d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x94,
+	0x02, 0x0a, 0x07, 0x52, 0x65, 0x70, 0x65, 0x61, 0x74, 0x73, 0x12, 0x19, 0x0a, 0x08, 0x72, 0x70,
+	0x74, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18, 0x01, 0x20, 0x03, 0x28, 0x08, 0x52, 0x07, 0x72, 0x70,
+	0x74, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x1b, 0x0a, 0x09, 0x72, 0x70, 0x74, 0x5f, 0x69, 0x6e, 0x74,
+	0x33, 0x32, 0x18, 0x02, 0x20, 0x03, 0x28, 0x05, 0x52, 0x08, 0x72, 0x70, 0x74, 0x49, 0x6e, 0x74,
+	0x33, 0x32, 0x12, 0x1b, 0x0a, 0x09, 0x72, 0x70, 0x74, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18,
+	0x03, 0x20, 0x03, 0x28, 0x03, 0x52, 0x08, 0x72, 0x70, 0x74, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x12,
+	0x1d, 0x0a, 0x0a, 0x72, 0x70, 0x74, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x04, 0x20,
+	0x03, 0x28, 0x0d, 0x52, 0x09, 0x72, 0x70, 0x74, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x1d,
+	0x0a, 0x0a, 0x72, 0x70, 0x74, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x05, 0x20, 0x03,
+	0x28, 0x04, 0x52, 0x09, 0x72, 0x70, 0x74, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x1b, 0x0a,
+	0x09, 0x72, 0x70, 0x74, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x18, 0x06, 0x20, 0x03, 0x28, 0x02,
+	0x52, 0x08, 0x72, 0x70, 0x74, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x70,
+	0x74, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0x07, 0x20, 0x03, 0x28, 0x01, 0x52, 0x09,
+	0x72, 0x70, 0x74, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x70, 0x74,
+	0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x08, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x72,
+	0x70, 0x74, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x1b, 0x0a, 0x09, 0x72, 0x70, 0x74, 0x5f,
+	0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x08, 0x72, 0x70, 0x74,
+	0x42, 0x79, 0x74, 0x65, 0x73, 0x22, 0xc4, 0x04, 0x0a, 0x0e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x12, 0x1e, 0x0a, 0x08, 0x6f, 0x70, 0x74, 0x5f,
+	0x62, 0x6f, 0x6f, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x07, 0x6f, 0x70,
+	0x74, 0x42, 0x6f, 0x6f, 0x6c, 0x88, 0x01, 0x01, 0x12, 0x20, 0x0a, 0x09, 0x6f, 0x70, 0x74, 0x5f,
+	0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x48, 0x01, 0x52, 0x08, 0x6f,
+	0x70, 0x74, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x88, 0x01, 0x01, 0x12, 0x20, 0x0a, 0x09, 0x6f, 0x70,
+	0x74, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x48, 0x02, 0x52,
+	0x08, 0x6f, 0x70, 0x74, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x88, 0x01, 0x01, 0x12, 0x22, 0x0a, 0x0a,
+	0x6f, 0x70, 0x74, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d,
+	0x48, 0x03, 0x52, 0x09, 0x6f, 0x70, 0x74, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x88, 0x01, 0x01,
+	0x12, 0x22, 0x0a, 0x0a, 0x6f, 0x70, 0x74, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x05,
+	0x20, 0x01, 0x28, 0x04, 0x48, 0x04, 0x52, 0x09, 0x6f, 0x70, 0x74, 0x55, 0x69, 0x6e, 0x74, 0x36,
+	0x34, 0x88, 0x01, 0x01, 0x12, 0x20, 0x0a, 0x09, 0x6f, 0x70, 0x74, 0x5f, 0x66, 0x6c, 0x6f, 0x61,
+	0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x02, 0x48, 0x05, 0x52, 0x08, 0x6f, 0x70, 0x74, 0x46, 0x6c,
+	0x6f, 0x61, 0x74, 0x88, 0x01, 0x01, 0x12, 0x22, 0x0a, 0x0a, 0x6f, 0x70, 0x74, 0x5f, 0x64, 0x6f,
+	0x75, 0x62, 0x6c, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x01, 0x48, 0x06, 0x52, 0x09, 0x6f, 0x70,
+	0x74, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x88, 0x01, 0x01, 0x12, 0x22, 0x0a, 0x0a, 0x6f, 0x70,
+	0x74, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x48, 0x07,
+	0x52, 0x09, 0x6f, 0x70, 0x74, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x88, 0x01, 0x01, 0x12, 0x20,
+	0x0a, 0x09, 0x6f, 0x70, 0x74, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28,
+	0x0c, 0x48, 0x08, 0x52, 0x08, 0x6f, 0x70, 0x74, 0x42, 0x79, 0x74, 0x65, 0x73, 0x88, 0x01, 0x01,
+	0x12, 0x29, 0x0a, 0x08, 0x6f, 0x70, 0x74, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x0a, 0x20, 0x01,
+	0x28, 0x0e, 0x32, 0x09, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x48, 0x09, 0x52,
+	0x07, 0x6f, 0x70, 0x74, 0x45, 0x6e, 0x75, 0x6d, 0x88, 0x01, 0x01, 0x12, 0x31, 0x0a, 0x0b, 0x6f,
+	0x70, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x0b, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x48, 0x0a, 0x52,
+	0x0a, 0x6f, 0x70, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x88, 0x01, 0x01, 0x42, 0x0b,
+	0x0a, 0x09, 0x5f, 0x6f, 0x70, 0x74, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x42, 0x0c, 0x0a, 0x0a, 0x5f,
+	0x6f, 0x70, 0x74, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x42, 0x0c, 0x0a, 0x0a, 0x5f, 0x6f, 0x70,
+	0x74, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x42, 0x0d, 0x0a, 0x0b, 0x5f, 0x6f, 0x70, 0x74, 0x5f,
+	0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x42, 0x0d, 0x0a, 0x0b, 0x5f, 0x6f, 0x70, 0x74, 0x5f, 0x75,
+	0x69, 0x6e, 0x74, 0x36, 0x34, 0x42, 0x0c, 0x0a, 0x0a, 0x5f, 0x6f, 0x70, 0x74, 0x5f, 0x66, 0x6c,
+	0x6f, 0x61, 0x74, 0x42, 0x0d, 0x0a, 0x0b, 0x5f, 0x6f, 0x70, 0x74, 0x5f, 0x64, 0x6f, 0x75, 0x62,
+	0x6c, 0x65, 0x42, 0x0d, 0x0a, 0x0b, 0x5f, 0x6f, 0x70, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e,
+	0x67, 0x42, 0x0c, 0x0a, 0x0a, 0x5f, 0x6f, 0x70, 0x74, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x42,
+	0x0b, 0x0a, 0x09, 0x5f, 0x6f, 0x70, 0x74, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x42, 0x0e, 0x0a, 0x0c,
+	0x5f, 0x6f, 0x70, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x98, 0x01, 0x0a,
+	0x05, 0x45, 0x6e, 0x75, 0x6d, 0x73, 0x12, 0x20, 0x0a, 0x06, 0x73, 0x5f, 0x65, 0x6e, 0x75, 0x6d,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x09, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x45, 0x6e, 0x75,
+	0x6d, 0x52, 0x05, 0x73, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x39, 0x0a, 0x0d, 0x73, 0x5f, 0x6e, 0x65,
+	0x73, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32,
+	0x15, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74,
+	0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0b, 0x73, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45,
+	0x6e, 0x75, 0x6d, 0x22, 0x32, 0x0a, 0x0a, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75,
+	0x6d, 0x12, 0x08, 0x0a, 0x04, 0x43, 0x45, 0x52, 0x4f, 0x10, 0x00, 0x12, 0x07, 0x0a, 0x03, 0x55,
+	0x4e, 0x4f, 0x10, 0x01, 0x12, 0x07, 0x0a, 0x03, 0x44, 0x4f, 0x53, 0x10, 0x02, 0x12, 0x08, 0x0a,
+	0x04, 0x44, 0x49, 0x45, 0x5a, 0x10, 0x0a, 0x22, 0x2f, 0x0a, 0x05, 0x4e, 0x65, 0x73, 0x74, 0x73,
+	0x12, 0x26, 0x0a, 0x08, 0x73, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x0b, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x52,
+	0x07, 0x73, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x22, 0x4b, 0x0a, 0x06, 0x4e, 0x65, 0x73, 0x74,
+	0x65, 0x64, 0x12, 0x19, 0x0a, 0x08, 0x73, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x26, 0x0a,
+	0x08, 0x73, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x0b, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x52, 0x07, 0x73, 0x4e,
+	0x65, 0x73, 0x74, 0x65, 0x64, 0x22, 0x94, 0x01, 0x0a, 0x06, 0x4f, 0x6e, 0x65, 0x6f, 0x66, 0x73,
+	0x12, 0x2a, 0x0a, 0x0a, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x0e, 0x32, 0x09, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x48,
+	0x00, 0x52, 0x09, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x23, 0x0a, 0x0c,
+	0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x09, 0x48, 0x00, 0x52, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x53, 0x74, 0x72, 0x69, 0x6e,
+	0x67, 0x12, 0x30, 0x0a, 0x0c, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65,
+	0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0b, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x4e, 0x65,
+	0x73, 0x74, 0x65, 0x64, 0x48, 0x00, 0x52, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x4e, 0x65, 0x73,
+	0x74, 0x65, 0x64, 0x42, 0x07, 0x0a, 0x05, 0x75, 0x6e, 0x69, 0x6f, 0x6e, 0x22, 0xaf, 0x05, 0x0a,
+	0x04, 0x4d, 0x61, 0x70, 0x73, 0x12, 0x3b, 0x0a, 0x0c, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x74,
+	0x6f, 0x5f, 0x73, 0x74, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x70, 0x62,
+	0x33, 0x2e, 0x4d, 0x61, 0x70, 0x73, 0x2e, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x54, 0x6f, 0x53, 0x74,
+	0x72, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0a, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x54, 0x6f, 0x53,
+	0x74, 0x72, 0x12, 0x41, 0x0a, 0x0e, 0x62, 0x6f, 0x6f, 0x6c, 0x5f, 0x74, 0x6f, 0x5f, 0x75, 0x69,
+	0x6e, 0x74, 0x33, 0x32, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x70, 0x62, 0x33,
+	0x2e, 0x4d, 0x61, 0x70, 0x73, 0x2e, 0x42, 0x6f, 0x6f, 0x6c, 0x54, 0x6f, 0x55, 0x69, 0x6e, 0x74,
+	0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0c, 0x62, 0x6f, 0x6f, 0x6c, 0x54, 0x6f, 0x55,
+	0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x41, 0x0a, 0x0e, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x5f,
+	0x74, 0x6f, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e,
+	0x70, 0x62, 0x33, 0x2e, 0x4d, 0x61, 0x70, 0x73, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x54,
+	0x6f, 0x45, 0x6e, 0x75, 0x6d, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0c, 0x75, 0x69, 0x6e, 0x74,
+	0x36, 0x34, 0x54, 0x6f, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x3e, 0x0a, 0x0d, 0x73, 0x74, 0x72, 0x5f,
+	0x74, 0x6f, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x1a, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x4d, 0x61, 0x70, 0x73, 0x2e, 0x53, 0x74, 0x72, 0x54, 0x6f,
+	0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0b, 0x73, 0x74, 0x72,
+	0x54, 0x6f, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x12, 0x3e, 0x0a, 0x0d, 0x73, 0x74, 0x72, 0x5f,
+	0x74, 0x6f, 0x5f, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x1a, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x4d, 0x61, 0x70, 0x73, 0x2e, 0x53, 0x74, 0x72, 0x54, 0x6f,
+	0x4f, 0x6e, 0x65, 0x6f, 0x66, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0b, 0x73, 0x74, 0x72,
+	0x54, 0x6f, 0x4f, 0x6e, 0x65, 0x6f, 0x66, 0x73, 0x1a, 0x3d, 0x0a, 0x0f, 0x49, 0x6e, 0x74, 0x33,
+	0x32, 0x54, 0x6f, 0x53, 0x74, 0x72, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b,
+	0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a,
+	0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61,
+	0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x3f, 0x0a, 0x11, 0x42, 0x6f, 0x6f, 0x6c, 0x54,
+	0x6f, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03,
+	0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14,
+	0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x76,
+	0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x4a, 0x0a, 0x11, 0x55, 0x69, 0x6e, 0x74,
+	0x36, 0x34, 0x54, 0x6f, 0x45, 0x6e, 0x75, 0x6d, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a,
+	0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12,
+	0x1f, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x09,
+	0x2e, 0x70, 0x62, 0x33, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
+	0x3a, 0x02, 0x38, 0x01, 0x1a, 0x4b, 0x0a, 0x10, 0x53, 0x74, 0x72, 0x54, 0x6f, 0x4e, 0x65, 0x73,
+	0x74, 0x65, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x21, 0x0a, 0x05, 0x76, 0x61,
+	0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0b, 0x2e, 0x70, 0x62, 0x33, 0x2e,
+	0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38,
+	0x01, 0x1a, 0x4b, 0x0a, 0x10, 0x53, 0x74, 0x72, 0x54, 0x6f, 0x4f, 0x6e, 0x65, 0x6f, 0x66, 0x73,
+	0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x21, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0b, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x4f, 0x6e, 0x65,
+	0x6f, 0x66, 0x73, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x26,
+	0x0a, 0x09, 0x4a, 0x53, 0x4f, 0x4e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x12, 0x19, 0x0a, 0x08, 0x73,
+	0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x66,
+	0x6f, 0x6f, 0x5f, 0x62, 0x61, 0x72, 0x2a, 0x2b, 0x0a, 0x04, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x08,
+	0x0a, 0x04, 0x5a, 0x45, 0x52, 0x4f, 0x10, 0x00, 0x12, 0x07, 0x0a, 0x03, 0x4f, 0x4e, 0x45, 0x10,
+	0x01, 0x12, 0x07, 0x0a, 0x03, 0x54, 0x57, 0x4f, 0x10, 0x02, 0x12, 0x07, 0x0a, 0x03, 0x54, 0x45,
+	0x4e, 0x10, 0x0a, 0x42, 0x38, 0x5a, 0x36, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f,
+	0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x74, 0x65, 0x78, 0x74, 0x70, 0x62, 0x33, 0x62, 0x06, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_internal_testprotos_textpb3_test_proto_rawDescOnce sync.Once
+	file_internal_testprotos_textpb3_test_proto_rawDescData = file_internal_testprotos_textpb3_test_proto_rawDesc
+)
+
+func file_internal_testprotos_textpb3_test_proto_rawDescGZIP() []byte {
+	file_internal_testprotos_textpb3_test_proto_rawDescOnce.Do(func() {
+		file_internal_testprotos_textpb3_test_proto_rawDescData = protoimpl.X.CompressGZIP(file_internal_testprotos_textpb3_test_proto_rawDescData)
+	})
+	return file_internal_testprotos_textpb3_test_proto_rawDescData
+}
+
+var file_internal_testprotos_textpb3_test_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
+var file_internal_testprotos_textpb3_test_proto_msgTypes = make([]protoimpl.MessageInfo, 14)
+var file_internal_testprotos_textpb3_test_proto_goTypes = []interface{}{
+	(Enum)(0),              // 0: pb3.Enum
+	(Enums_NestedEnum)(0),  // 1: pb3.Enums.NestedEnum
+	(*Scalars)(nil),        // 2: pb3.Scalars
+	(*Repeats)(nil),        // 3: pb3.Repeats
+	(*Proto3Optional)(nil), // 4: pb3.Proto3Optional
+	(*Enums)(nil),          // 5: pb3.Enums
+	(*Nests)(nil),          // 6: pb3.Nests
+	(*Nested)(nil),         // 7: pb3.Nested
+	(*Oneofs)(nil),         // 8: pb3.Oneofs
+	(*Maps)(nil),           // 9: pb3.Maps
+	(*JSONNames)(nil),      // 10: pb3.JSONNames
+	nil,                    // 11: pb3.Maps.Int32ToStrEntry
+	nil,                    // 12: pb3.Maps.BoolToUint32Entry
+	nil,                    // 13: pb3.Maps.Uint64ToEnumEntry
+	nil,                    // 14: pb3.Maps.StrToNestedEntry
+	nil,                    // 15: pb3.Maps.StrToOneofsEntry
+}
+var file_internal_testprotos_textpb3_test_proto_depIdxs = []int32{
+	0,  // 0: pb3.Proto3Optional.opt_enum:type_name -> pb3.Enum
+	7,  // 1: pb3.Proto3Optional.opt_message:type_name -> pb3.Nested
+	0,  // 2: pb3.Enums.s_enum:type_name -> pb3.Enum
+	1,  // 3: pb3.Enums.s_nested_enum:type_name -> pb3.Enums.NestedEnum
+	7,  // 4: pb3.Nests.s_nested:type_name -> pb3.Nested
+	7,  // 5: pb3.Nested.s_nested:type_name -> pb3.Nested
+	0,  // 6: pb3.Oneofs.oneof_enum:type_name -> pb3.Enum
+	7,  // 7: pb3.Oneofs.oneof_nested:type_name -> pb3.Nested
+	11, // 8: pb3.Maps.int32_to_str:type_name -> pb3.Maps.Int32ToStrEntry
+	12, // 9: pb3.Maps.bool_to_uint32:type_name -> pb3.Maps.BoolToUint32Entry
+	13, // 10: pb3.Maps.uint64_to_enum:type_name -> pb3.Maps.Uint64ToEnumEntry
+	14, // 11: pb3.Maps.str_to_nested:type_name -> pb3.Maps.StrToNestedEntry
+	15, // 12: pb3.Maps.str_to_oneofs:type_name -> pb3.Maps.StrToOneofsEntry
+	0,  // 13: pb3.Maps.Uint64ToEnumEntry.value:type_name -> pb3.Enum
+	7,  // 14: pb3.Maps.StrToNestedEntry.value:type_name -> pb3.Nested
+	8,  // 15: pb3.Maps.StrToOneofsEntry.value:type_name -> pb3.Oneofs
+	16, // [16:16] is the sub-list for method output_type
+	16, // [16:16] is the sub-list for method input_type
+	16, // [16:16] is the sub-list for extension type_name
+	16, // [16:16] is the sub-list for extension extendee
+	0,  // [0:16] is the sub-list for field type_name
+}
+
+func init() { file_internal_testprotos_textpb3_test_proto_init() }
+func file_internal_testprotos_textpb3_test_proto_init() {
+	if File_internal_testprotos_textpb3_test_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_internal_testprotos_textpb3_test_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Scalars); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_textpb3_test_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Repeats); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_textpb3_test_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Proto3Optional); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_textpb3_test_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Enums); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_textpb3_test_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Nests); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_textpb3_test_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Nested); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_textpb3_test_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Oneofs); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_textpb3_test_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Maps); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_testprotos_textpb3_test_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*JSONNames); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	file_internal_testprotos_textpb3_test_proto_msgTypes[2].OneofWrappers = []interface{}{}
+	file_internal_testprotos_textpb3_test_proto_msgTypes[6].OneofWrappers = []interface{}{
+		(*Oneofs_OneofEnum)(nil),
+		(*Oneofs_OneofString)(nil),
+		(*Oneofs_OneofNested)(nil),
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_internal_testprotos_textpb3_test_proto_rawDesc,
+			NumEnums:      2,
+			NumMessages:   14,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_internal_testprotos_textpb3_test_proto_goTypes,
+		DependencyIndexes: file_internal_testprotos_textpb3_test_proto_depIdxs,
+		EnumInfos:         file_internal_testprotos_textpb3_test_proto_enumTypes,
+		MessageInfos:      file_internal_testprotos_textpb3_test_proto_msgTypes,
+	}.Build()
+	File_internal_testprotos_textpb3_test_proto = out.File
+	file_internal_testprotos_textpb3_test_proto_rawDesc = nil
+	file_internal_testprotos_textpb3_test_proto_goTypes = nil
+	file_internal_testprotos_textpb3_test_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/internal/testprotos/textpb3/test.proto b/vendor/google.golang.org/protobuf/internal/testprotos/textpb3/test.proto
new file mode 100644
index 000000000..8b1c7db58
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/testprotos/textpb3/test.proto
@@ -0,0 +1,115 @@
+// 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.
+
+// Test Protobuf definitions with proto3 syntax.
+syntax = "proto3";
+
+package pb3;
+option go_package = "google.golang.org/protobuf/internal/testprotos/textpb3";
+
+// Scalars contains scalar field types.
+message Scalars {
+  bool s_bool = 1;
+  int32 s_int32 = 2;
+  int64 s_int64 = 3;
+  uint32 s_uint32 = 4;
+  uint64 s_uint64 = 5;
+  sint32 s_sint32 = 6;
+  sint64 s_sint64 = 7;
+  fixed32 s_fixed32 = 8;
+  fixed64 s_fixed64 = 9;
+  sfixed32 s_sfixed32 = 10;
+  sfixed64 s_sfixed64 = 11;
+
+  // Textproto marshal outputs fields in the same order as this proto
+  // definition regardless of field number. Following fields are intended to
+  // test that assumption.
+
+  float s_float = 20;
+  double s_double = 21;
+
+  bytes s_bytes = 14;
+  string s_string = 13;
+}
+
+// Message contains repeated fields.
+message Repeats {
+  repeated bool rpt_bool = 1;
+  repeated int32 rpt_int32 = 2;
+  repeated int64 rpt_int64 = 3;
+  repeated uint32 rpt_uint32 = 4;
+  repeated uint64 rpt_uint64 = 5;
+  repeated float rpt_float = 6;
+  repeated double rpt_double = 7;
+  repeated string rpt_string = 8;
+  repeated bytes rpt_bytes = 9;
+}
+
+message Proto3Optional {
+  optional bool opt_bool = 1;
+  optional int32 opt_int32 = 2;
+  optional int64 opt_int64 = 3;
+  optional uint32 opt_uint32 = 4;
+  optional uint64 opt_uint64 = 5;
+  optional float opt_float = 6;
+  optional double opt_double = 7;
+  optional string opt_string = 8;
+  optional bytes opt_bytes = 9;
+  optional Enum opt_enum = 10;
+  optional Nested opt_message = 11;
+}
+
+enum Enum {
+  ZERO = 0;
+  ONE = 1;
+  TWO = 2;
+  TEN = 10;
+}
+
+// Message contains enum fields.
+message Enums {
+  Enum s_enum = 1;
+
+  enum NestedEnum {
+  	CERO = 0;
+	UNO = 1;
+	DOS = 2;
+	DIEZ = 10;
+  }
+  NestedEnum s_nested_enum = 3;
+}
+
+// Message contains nested message field.
+message Nests {
+  Nested s_nested = 2;
+}
+
+// Message type used as submessage.
+message Nested {
+  string s_string = 1;
+  Nested s_nested = 2;
+}
+
+// Message contains oneof field.
+message Oneofs {
+  oneof union {
+    Enum oneof_enum = 1;
+    string oneof_string = 2;
+    Nested oneof_nested = 3;
+  }
+}
+
+// Message contains map fields.
+message Maps {
+  map<int32, string> int32_to_str = 1;
+  map<bool, uint32> bool_to_uint32 = 2;
+  map<uint64, Enum> uint64_to_enum = 3;
+  map<string, Nested> str_to_nested = 4;
+  map<string, Oneofs> str_to_oneofs = 5;
+}
+
+// Message for testing json_name option.
+message JSONNames {
+  string s_string = 1 [json_name = "foo_bar"];
+}
diff --git a/vendor/google.golang.org/protobuf/internal/version/version.go b/vendor/google.golang.org/protobuf/internal/version/version.go
new file mode 100644
index 000000000..4088e59c6
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/version/version.go
@@ -0,0 +1,79 @@
+// Copyright 2019 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 version records versioning information about this module.
+package version
+
+import (
+	"fmt"
+	"strings"
+)
+
+// These constants determine the current version of this module.
+//
+//
+// For our release process, we enforce the following rules:
+//	* Tagged releases use a tag that is identical to String.
+//	* Tagged releases never reference a commit where the String
+//	contains "devel".
+//	* The set of all commits in this repository where String
+//	does not contain "devel" must have a unique String.
+//
+//
+// Steps for tagging a new release:
+//	1. Create a new CL.
+//
+//	2. Update Minor, Patch, and/or PreRelease as necessary.
+//	PreRelease must not contain the string "devel".
+//
+//	3. Since the last released minor version, have there been any changes to
+//	generator that relies on new functionality in the runtime?
+//	If yes, then increment RequiredGenerated.
+//
+//	4. Since the last released minor version, have there been any changes to
+//	the runtime that removes support for old .pb.go source code?
+//	If yes, then increment SupportMinimum.
+//
+//	5. Send out the CL for review and submit it.
+//	Note that the next CL in step 8 must be submitted after this CL
+//	without any other CLs in-between.
+//
+//	6. Tag a new version, where the tag is is the current String.
+//
+//	7. Write release notes for all notable changes
+//	between this release and the last release.
+//
+//	8. Create a new CL.
+//
+//	9. Update PreRelease to include the string "devel".
+//	For example: "" -> "devel" or "rc.1" -> "rc.1.devel"
+//
+//	10. Send out the CL for review and submit it.
+const (
+	Major      = 1
+	Minor      = 23
+	Patch      = 0
+	PreRelease = ""
+)
+
+// String formats the version string for this module in semver format.
+//
+// Examples:
+//	v1.20.1
+//	v1.21.0-rc.1
+func String() string {
+	v := fmt.Sprintf("v%d.%d.%d", Major, Minor, Patch)
+	if PreRelease != "" {
+		v += "-" + PreRelease
+
+		// TODO: Add metadata about the commit or build hash.
+		// See https://golang.org/issue/29814
+		// See https://golang.org/issue/33533
+		var metadata string
+		if strings.Contains(PreRelease, "devel") && metadata != "" {
+			v += "+" + metadata
+		}
+	}
+	return v
+}
diff --git a/vendor/google.golang.org/protobuf/internal/weakdeps/doc.go b/vendor/google.golang.org/protobuf/internal/weakdeps/doc.go
new file mode 100644
index 000000000..bc7d7c506
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/weakdeps/doc.go
@@ -0,0 +1,12 @@
+// Copyright 2020 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 weakdeps exists to add weak module dependencies.
+//
+// We want to ensure that this module is used with a minimum
+// version of certain other modules, without actually importing
+// those modules in normal builds. We do that by adding an
+// import of a package in the module under a build constraint
+// that is never satisfied in normal usage.
+package weakdeps
diff --git a/vendor/google.golang.org/protobuf/internal/weakdeps/weakdeps.go b/vendor/google.golang.org/protobuf/internal/weakdeps/weakdeps.go
new file mode 100644
index 000000000..456fbfdfb
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/weakdeps/weakdeps.go
@@ -0,0 +1,11 @@
+// Copyright 2020 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.
+
+// +build weak_dependency
+
+package weakdeps
+
+// Ensure that any program using "github.com/golang/protobuf"
+// uses a version that wraps this module.
+import _ "github.com/golang/protobuf/proto"
diff --git a/vendor/google.golang.org/protobuf/proto/bench_test.go b/vendor/google.golang.org/protobuf/proto/bench_test.go
new file mode 100644
index 000000000..55bce593d
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/proto/bench_test.go
@@ -0,0 +1,61 @@
+// Copyright 2019 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 proto_test
+
+import (
+	"flag"
+	"fmt"
+	"reflect"
+	"testing"
+
+	"google.golang.org/protobuf/proto"
+)
+
+// The results of these microbenchmarks are unlikely to correspond well
+// to real world peformance. They are mainly useful as a quick check to
+// detect unexpected regressions and for profiling specific cases.
+
+var (
+	allowPartial = flag.Bool("allow_partial", false, "set AllowPartial")
+)
+
+// BenchmarkEncode benchmarks encoding all the test messages.
+func BenchmarkEncode(b *testing.B) {
+	for _, test := range testValidMessages {
+		for _, want := range test.decodeTo {
+			opts := proto.MarshalOptions{AllowPartial: *allowPartial}
+			b.Run(fmt.Sprintf("%s (%T)", test.desc, want), func(b *testing.B) {
+				b.RunParallel(func(pb *testing.PB) {
+					for pb.Next() {
+						_, err := opts.Marshal(want)
+						if err != nil && !test.partial {
+							b.Fatal(err)
+						}
+					}
+				})
+			})
+		}
+	}
+}
+
+// BenchmarkDecode benchmarks decoding all the test messages.
+func BenchmarkDecode(b *testing.B) {
+	for _, test := range testValidMessages {
+		for _, want := range test.decodeTo {
+			opts := proto.UnmarshalOptions{AllowPartial: *allowPartial}
+			b.Run(fmt.Sprintf("%s (%T)", test.desc, want), func(b *testing.B) {
+				b.RunParallel(func(pb *testing.PB) {
+					for pb.Next() {
+						m := reflect.New(reflect.TypeOf(want).Elem()).Interface().(proto.Message)
+						err := opts.Unmarshal(test.wire, m)
+						if err != nil && !test.partial {
+							b.Fatal(err)
+						}
+					}
+				})
+			})
+		}
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/proto/checkinit.go b/vendor/google.golang.org/protobuf/proto/checkinit.go
new file mode 100644
index 000000000..3e9a6a2f6
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/proto/checkinit.go
@@ -0,0 +1,71 @@
+// Copyright 2019 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 proto
+
+import (
+	"google.golang.org/protobuf/internal/errors"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/runtime/protoiface"
+)
+
+// CheckInitialized returns an error if any required fields in m are not set.
+func CheckInitialized(m Message) error {
+	// Treat a nil message interface as an "untyped" empty message,
+	// which we assume to have no required fields.
+	if m == nil {
+		return nil
+	}
+
+	return checkInitialized(m.ProtoReflect())
+}
+
+// CheckInitialized returns an error if any required fields in m are not set.
+func checkInitialized(m protoreflect.Message) error {
+	if methods := protoMethods(m); methods != nil && methods.CheckInitialized != nil {
+		_, err := methods.CheckInitialized(protoiface.CheckInitializedInput{
+			Message: m,
+		})
+		return err
+	}
+	return checkInitializedSlow(m)
+}
+
+func checkInitializedSlow(m protoreflect.Message) error {
+	md := m.Descriptor()
+	fds := md.Fields()
+	for i, nums := 0, md.RequiredNumbers(); i < nums.Len(); i++ {
+		fd := fds.ByNumber(nums.Get(i))
+		if !m.Has(fd) {
+			return errors.RequiredNotSet(string(fd.FullName()))
+		}
+	}
+	var err error
+	m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
+		switch {
+		case fd.IsList():
+			if fd.Message() == nil {
+				return true
+			}
+			for i, list := 0, v.List(); i < list.Len() && err == nil; i++ {
+				err = checkInitialized(list.Get(i).Message())
+			}
+		case fd.IsMap():
+			if fd.MapValue().Message() == nil {
+				return true
+			}
+			v.Map().Range(func(key protoreflect.MapKey, v protoreflect.Value) bool {
+				err = checkInitialized(v.Message())
+				return err == nil
+			})
+		default:
+			if fd.Message() == nil {
+				return true
+			}
+			err = checkInitialized(v.Message())
+		}
+		return err == nil
+	})
+	return err
+}
diff --git a/vendor/google.golang.org/protobuf/proto/checkinit_test.go b/vendor/google.golang.org/protobuf/proto/checkinit_test.go
new file mode 100644
index 000000000..29c9a9a4c
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/proto/checkinit_test.go
@@ -0,0 +1,89 @@
+// Copyright 2019 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 proto_test
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"google.golang.org/protobuf/encoding/prototext"
+	"google.golang.org/protobuf/internal/flags"
+	"google.golang.org/protobuf/proto"
+
+	testpb "google.golang.org/protobuf/internal/testprotos/test"
+	weakpb "google.golang.org/protobuf/internal/testprotos/test/weak1"
+)
+
+func TestCheckInitializedErrors(t *testing.T) {
+	type test struct {
+		m    proto.Message
+		want string
+		skip bool
+	}
+	tests := []test{{
+		m:    &testpb.TestRequired{},
+		want: `goproto.proto.test.TestRequired.required_field`,
+	}, {
+		m: &testpb.TestRequiredForeign{
+			OptionalMessage: &testpb.TestRequired{},
+		},
+		want: `goproto.proto.test.TestRequired.required_field`,
+	}, {
+		m: &testpb.TestRequiredForeign{
+			RepeatedMessage: []*testpb.TestRequired{
+				{RequiredField: proto.Int32(1)},
+				{},
+			},
+		},
+		want: `goproto.proto.test.TestRequired.required_field`,
+	}, {
+		m: &testpb.TestRequiredForeign{
+			MapMessage: map[int32]*testpb.TestRequired{
+				1: {},
+			},
+		},
+		want: `goproto.proto.test.TestRequired.required_field`,
+	}, {
+		m:    &testpb.TestWeak{},
+		want: `<nil>`,
+		skip: !flags.ProtoLegacy,
+	}, {
+		m: func() proto.Message {
+			m := &testpb.TestWeak{}
+			m.SetWeakMessage1(&weakpb.WeakImportMessage1{})
+			return m
+		}(),
+		want: `goproto.proto.test.weak.WeakImportMessage1.a`,
+		skip: !flags.ProtoLegacy,
+	}, {
+		m: func() proto.Message {
+			m := &testpb.TestWeak{}
+			m.SetWeakMessage1(&weakpb.WeakImportMessage1{
+				A: proto.Int32(1),
+			})
+			return m
+		}(),
+		want: `<nil>`,
+		skip: !flags.ProtoLegacy,
+	}}
+
+	for _, tt := range tests {
+		t.Run("", func(t *testing.T) {
+			if tt.skip {
+				t.SkipNow()
+			}
+
+			err := proto.CheckInitialized(tt.m)
+			got := "<nil>"
+			if err != nil {
+				got = fmt.Sprintf("%q", err)
+			}
+			if !strings.Contains(got, tt.want) {
+				t.Errorf("CheckInitialized(m):\n got: %v\nwant contains: %v\nMessage:\n%v", got, tt.want, prototext.Format(tt.m))
+			}
+		})
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/proto/decode.go b/vendor/google.golang.org/protobuf/proto/decode.go
new file mode 100644
index 000000000..128214760
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/proto/decode.go
@@ -0,0 +1,270 @@
+// 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 proto
+
+import (
+	"google.golang.org/protobuf/encoding/protowire"
+	"google.golang.org/protobuf/internal/encoding/messageset"
+	"google.golang.org/protobuf/internal/errors"
+	"google.golang.org/protobuf/internal/flags"
+	"google.golang.org/protobuf/internal/pragma"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/reflect/protoregistry"
+	"google.golang.org/protobuf/runtime/protoiface"
+)
+
+// UnmarshalOptions configures the unmarshaler.
+//
+// Example usage:
+//   err := UnmarshalOptions{DiscardUnknown: true}.Unmarshal(b, m)
+type UnmarshalOptions struct {
+	pragma.NoUnkeyedLiterals
+
+	// Merge merges the input into the destination message.
+	// The default behavior is to always reset the message before unmarshaling,
+	// unless Merge is specified.
+	Merge bool
+
+	// AllowPartial accepts input for messages that will result in missing
+	// required fields. If AllowPartial is false (the default), Unmarshal will
+	// return an error if there are any missing required fields.
+	AllowPartial bool
+
+	// If DiscardUnknown is set, unknown fields are ignored.
+	DiscardUnknown bool
+
+	// Resolver is used for looking up types when unmarshaling extension fields.
+	// If nil, this defaults to using protoregistry.GlobalTypes.
+	Resolver interface {
+		FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error)
+		FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error)
+	}
+}
+
+// Unmarshal parses the wire-format message in b and places the result in m.
+func Unmarshal(b []byte, m Message) error {
+	_, err := UnmarshalOptions{}.unmarshal(b, m.ProtoReflect())
+	return err
+}
+
+// Unmarshal parses the wire-format message in b and places the result in m.
+func (o UnmarshalOptions) Unmarshal(b []byte, m Message) error {
+	_, err := o.unmarshal(b, m.ProtoReflect())
+	return err
+}
+
+// UnmarshalState parses a wire-format message and places the result in m.
+//
+// This method permits fine-grained control over the unmarshaler.
+// Most users should use Unmarshal instead.
+func (o UnmarshalOptions) UnmarshalState(in protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+	return o.unmarshal(in.Buf, in.Message)
+}
+
+func (o UnmarshalOptions) unmarshal(b []byte, m protoreflect.Message) (out protoiface.UnmarshalOutput, err error) {
+	if o.Resolver == nil {
+		o.Resolver = protoregistry.GlobalTypes
+	}
+	if !o.Merge {
+		Reset(m.Interface()) // TODO
+	}
+	allowPartial := o.AllowPartial
+	o.Merge = true
+	o.AllowPartial = true
+	methods := protoMethods(m)
+	if methods != nil && methods.Unmarshal != nil &&
+		!(o.DiscardUnknown && methods.Flags&protoiface.SupportUnmarshalDiscardUnknown == 0) {
+		in := protoiface.UnmarshalInput{
+			Message:  m,
+			Buf:      b,
+			Resolver: o.Resolver,
+		}
+		if o.DiscardUnknown {
+			in.Flags |= protoiface.UnmarshalDiscardUnknown
+		}
+		out, err = methods.Unmarshal(in)
+	} else {
+		err = o.unmarshalMessageSlow(b, m)
+	}
+	if err != nil {
+		return out, err
+	}
+	if allowPartial || (out.Flags&protoiface.UnmarshalInitialized != 0) {
+		return out, nil
+	}
+	return out, checkInitialized(m)
+}
+
+func (o UnmarshalOptions) unmarshalMessage(b []byte, m protoreflect.Message) error {
+	_, err := o.unmarshal(b, m)
+	return err
+}
+
+func (o UnmarshalOptions) unmarshalMessageSlow(b []byte, m protoreflect.Message) error {
+	md := m.Descriptor()
+	if messageset.IsMessageSet(md) {
+		return unmarshalMessageSet(b, m, o)
+	}
+	fields := md.Fields()
+	for len(b) > 0 {
+		// Parse the tag (field number and wire type).
+		num, wtyp, tagLen := protowire.ConsumeTag(b)
+		if tagLen < 0 {
+			return protowire.ParseError(tagLen)
+		}
+		if num > protowire.MaxValidNumber {
+			return errors.New("invalid field number")
+		}
+
+		// Find the field descriptor for this field number.
+		fd := fields.ByNumber(num)
+		if fd == nil && md.ExtensionRanges().Has(num) {
+			extType, err := o.Resolver.FindExtensionByNumber(md.FullName(), num)
+			if err != nil && err != protoregistry.NotFound {
+				return errors.New("%v: unable to resolve extension %v: %v", md.FullName(), num, err)
+			}
+			if extType != nil {
+				fd = extType.TypeDescriptor()
+			}
+		}
+		var err error
+		if fd == nil {
+			err = errUnknown
+		} else if flags.ProtoLegacy {
+			if fd.IsWeak() && fd.Message().IsPlaceholder() {
+				err = errUnknown // weak referent is not linked in
+			}
+		}
+
+		// Parse the field value.
+		var valLen int
+		switch {
+		case err != nil:
+		case fd.IsList():
+			valLen, err = o.unmarshalList(b[tagLen:], wtyp, m.Mutable(fd).List(), fd)
+		case fd.IsMap():
+			valLen, err = o.unmarshalMap(b[tagLen:], wtyp, m.Mutable(fd).Map(), fd)
+		default:
+			valLen, err = o.unmarshalSingular(b[tagLen:], wtyp, m, fd)
+		}
+		if err != nil {
+			if err != errUnknown {
+				return err
+			}
+			valLen = protowire.ConsumeFieldValue(num, wtyp, b[tagLen:])
+			if valLen < 0 {
+				return protowire.ParseError(valLen)
+			}
+			if !o.DiscardUnknown {
+				m.SetUnknown(append(m.GetUnknown(), b[:tagLen+valLen]...))
+			}
+		}
+		b = b[tagLen+valLen:]
+	}
+	return nil
+}
+
+func (o UnmarshalOptions) unmarshalSingular(b []byte, wtyp protowire.Type, m protoreflect.Message, fd protoreflect.FieldDescriptor) (n int, err error) {
+	v, n, err := o.unmarshalScalar(b, wtyp, fd)
+	if err != nil {
+		return 0, err
+	}
+	switch fd.Kind() {
+	case protoreflect.GroupKind, protoreflect.MessageKind:
+		m2 := m.Mutable(fd).Message()
+		if err := o.unmarshalMessage(v.Bytes(), m2); err != nil {
+			return n, err
+		}
+	default:
+		// Non-message scalars replace the previous value.
+		m.Set(fd, v)
+	}
+	return n, nil
+}
+
+func (o UnmarshalOptions) unmarshalMap(b []byte, wtyp protowire.Type, mapv protoreflect.Map, fd protoreflect.FieldDescriptor) (n int, err error) {
+	if wtyp != protowire.BytesType {
+		return 0, errUnknown
+	}
+	b, n = protowire.ConsumeBytes(b)
+	if n < 0 {
+		return 0, protowire.ParseError(n)
+	}
+	var (
+		keyField = fd.MapKey()
+		valField = fd.MapValue()
+		key      protoreflect.Value
+		val      protoreflect.Value
+		haveKey  bool
+		haveVal  bool
+	)
+	switch valField.Kind() {
+	case protoreflect.GroupKind, protoreflect.MessageKind:
+		val = mapv.NewValue()
+	}
+	// Map entries are represented as a two-element message with fields
+	// containing the key and value.
+	for len(b) > 0 {
+		num, wtyp, n := protowire.ConsumeTag(b)
+		if n < 0 {
+			return 0, protowire.ParseError(n)
+		}
+		if num > protowire.MaxValidNumber {
+			return 0, errors.New("invalid field number")
+		}
+		b = b[n:]
+		err = errUnknown
+		switch num {
+		case 1:
+			key, n, err = o.unmarshalScalar(b, wtyp, keyField)
+			if err != nil {
+				break
+			}
+			haveKey = true
+		case 2:
+			var v protoreflect.Value
+			v, n, err = o.unmarshalScalar(b, wtyp, valField)
+			if err != nil {
+				break
+			}
+			switch valField.Kind() {
+			case protoreflect.GroupKind, protoreflect.MessageKind:
+				if err := o.unmarshalMessage(v.Bytes(), val.Message()); err != nil {
+					return 0, err
+				}
+			default:
+				val = v
+			}
+			haveVal = true
+		}
+		if err == errUnknown {
+			n = protowire.ConsumeFieldValue(num, wtyp, b)
+			if n < 0 {
+				return 0, protowire.ParseError(n)
+			}
+		} else if err != nil {
+			return 0, err
+		}
+		b = b[n:]
+	}
+	// Every map entry should have entries for key and value, but this is not strictly required.
+	if !haveKey {
+		key = keyField.Default()
+	}
+	if !haveVal {
+		switch valField.Kind() {
+		case protoreflect.GroupKind, protoreflect.MessageKind:
+		default:
+			val = valField.Default()
+		}
+	}
+	mapv.Set(key.MapKey(), val)
+	return n, nil
+}
+
+// errUnknown is used internally to indicate fields which should be added
+// to the unknown field set of a message. It is never returned from an exported
+// function.
+var errUnknown = errors.New("BUG: internal error (unknown)")
diff --git a/vendor/google.golang.org/protobuf/proto/decode_gen.go b/vendor/google.golang.org/protobuf/proto/decode_gen.go
new file mode 100644
index 000000000..d6dc904dc
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/proto/decode_gen.go
@@ -0,0 +1,603 @@
+// 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.
+
+// Code generated by generate-types. DO NOT EDIT.
+
+package proto
+
+import (
+	"math"
+	"unicode/utf8"
+
+	"google.golang.org/protobuf/encoding/protowire"
+	"google.golang.org/protobuf/internal/errors"
+	"google.golang.org/protobuf/internal/strs"
+	"google.golang.org/protobuf/reflect/protoreflect"
+)
+
+// unmarshalScalar decodes a value of the given kind.
+//
+// Message values are decoded into a []byte which aliases the input data.
+func (o UnmarshalOptions) unmarshalScalar(b []byte, wtyp protowire.Type, fd protoreflect.FieldDescriptor) (val protoreflect.Value, n int, err error) {
+	switch fd.Kind() {
+	case protoreflect.BoolKind:
+		if wtyp != protowire.VarintType {
+			return val, 0, errUnknown
+		}
+		v, n := protowire.ConsumeVarint(b)
+		if n < 0 {
+			return val, 0, protowire.ParseError(n)
+		}
+		return protoreflect.ValueOfBool(protowire.DecodeBool(v)), n, nil
+	case protoreflect.EnumKind:
+		if wtyp != protowire.VarintType {
+			return val, 0, errUnknown
+		}
+		v, n := protowire.ConsumeVarint(b)
+		if n < 0 {
+			return val, 0, protowire.ParseError(n)
+		}
+		return protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)), n, nil
+	case protoreflect.Int32Kind:
+		if wtyp != protowire.VarintType {
+			return val, 0, errUnknown
+		}
+		v, n := protowire.ConsumeVarint(b)
+		if n < 0 {
+			return val, 0, protowire.ParseError(n)
+		}
+		return protoreflect.ValueOfInt32(int32(v)), n, nil
+	case protoreflect.Sint32Kind:
+		if wtyp != protowire.VarintType {
+			return val, 0, errUnknown
+		}
+		v, n := protowire.ConsumeVarint(b)
+		if n < 0 {
+			return val, 0, protowire.ParseError(n)
+		}
+		return protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))), n, nil
+	case protoreflect.Uint32Kind:
+		if wtyp != protowire.VarintType {
+			return val, 0, errUnknown
+		}
+		v, n := protowire.ConsumeVarint(b)
+		if n < 0 {
+			return val, 0, protowire.ParseError(n)
+		}
+		return protoreflect.ValueOfUint32(uint32(v)), n, nil
+	case protoreflect.Int64Kind:
+		if wtyp != protowire.VarintType {
+			return val, 0, errUnknown
+		}
+		v, n := protowire.ConsumeVarint(b)
+		if n < 0 {
+			return val, 0, protowire.ParseError(n)
+		}
+		return protoreflect.ValueOfInt64(int64(v)), n, nil
+	case protoreflect.Sint64Kind:
+		if wtyp != protowire.VarintType {
+			return val, 0, errUnknown
+		}
+		v, n := protowire.ConsumeVarint(b)
+		if n < 0 {
+			return val, 0, protowire.ParseError(n)
+		}
+		return protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)), n, nil
+	case protoreflect.Uint64Kind:
+		if wtyp != protowire.VarintType {
+			return val, 0, errUnknown
+		}
+		v, n := protowire.ConsumeVarint(b)
+		if n < 0 {
+			return val, 0, protowire.ParseError(n)
+		}
+		return protoreflect.ValueOfUint64(v), n, nil
+	case protoreflect.Sfixed32Kind:
+		if wtyp != protowire.Fixed32Type {
+			return val, 0, errUnknown
+		}
+		v, n := protowire.ConsumeFixed32(b)
+		if n < 0 {
+			return val, 0, protowire.ParseError(n)
+		}
+		return protoreflect.ValueOfInt32(int32(v)), n, nil
+	case protoreflect.Fixed32Kind:
+		if wtyp != protowire.Fixed32Type {
+			return val, 0, errUnknown
+		}
+		v, n := protowire.ConsumeFixed32(b)
+		if n < 0 {
+			return val, 0, protowire.ParseError(n)
+		}
+		return protoreflect.ValueOfUint32(uint32(v)), n, nil
+	case protoreflect.FloatKind:
+		if wtyp != protowire.Fixed32Type {
+			return val, 0, errUnknown
+		}
+		v, n := protowire.ConsumeFixed32(b)
+		if n < 0 {
+			return val, 0, protowire.ParseError(n)
+		}
+		return protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))), n, nil
+	case protoreflect.Sfixed64Kind:
+		if wtyp != protowire.Fixed64Type {
+			return val, 0, errUnknown
+		}
+		v, n := protowire.ConsumeFixed64(b)
+		if n < 0 {
+			return val, 0, protowire.ParseError(n)
+		}
+		return protoreflect.ValueOfInt64(int64(v)), n, nil
+	case protoreflect.Fixed64Kind:
+		if wtyp != protowire.Fixed64Type {
+			return val, 0, errUnknown
+		}
+		v, n := protowire.ConsumeFixed64(b)
+		if n < 0 {
+			return val, 0, protowire.ParseError(n)
+		}
+		return protoreflect.ValueOfUint64(v), n, nil
+	case protoreflect.DoubleKind:
+		if wtyp != protowire.Fixed64Type {
+			return val, 0, errUnknown
+		}
+		v, n := protowire.ConsumeFixed64(b)
+		if n < 0 {
+			return val, 0, protowire.ParseError(n)
+		}
+		return protoreflect.ValueOfFloat64(math.Float64frombits(v)), n, nil
+	case protoreflect.StringKind:
+		if wtyp != protowire.BytesType {
+			return val, 0, errUnknown
+		}
+		v, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return val, 0, protowire.ParseError(n)
+		}
+		if strs.EnforceUTF8(fd) && !utf8.Valid(v) {
+			return protoreflect.Value{}, 0, errors.InvalidUTF8(string(fd.FullName()))
+		}
+		return protoreflect.ValueOfString(string(v)), n, nil
+	case protoreflect.BytesKind:
+		if wtyp != protowire.BytesType {
+			return val, 0, errUnknown
+		}
+		v, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return val, 0, protowire.ParseError(n)
+		}
+		return protoreflect.ValueOfBytes(append(emptyBuf[:], v...)), n, nil
+	case protoreflect.MessageKind:
+		if wtyp != protowire.BytesType {
+			return val, 0, errUnknown
+		}
+		v, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return val, 0, protowire.ParseError(n)
+		}
+		return protoreflect.ValueOfBytes(v), n, nil
+	case protoreflect.GroupKind:
+		if wtyp != protowire.StartGroupType {
+			return val, 0, errUnknown
+		}
+		v, n := protowire.ConsumeGroup(fd.Number(), b)
+		if n < 0 {
+			return val, 0, protowire.ParseError(n)
+		}
+		return protoreflect.ValueOfBytes(v), n, nil
+	default:
+		return val, 0, errUnknown
+	}
+}
+
+func (o UnmarshalOptions) unmarshalList(b []byte, wtyp protowire.Type, list protoreflect.List, fd protoreflect.FieldDescriptor) (n int, err error) {
+	switch fd.Kind() {
+	case protoreflect.BoolKind:
+		if wtyp == protowire.BytesType {
+			buf, n := protowire.ConsumeBytes(b)
+			if n < 0 {
+				return 0, protowire.ParseError(n)
+			}
+			for len(buf) > 0 {
+				v, n := protowire.ConsumeVarint(buf)
+				if n < 0 {
+					return 0, protowire.ParseError(n)
+				}
+				buf = buf[n:]
+				list.Append(protoreflect.ValueOfBool(protowire.DecodeBool(v)))
+			}
+			return n, nil
+		}
+		if wtyp != protowire.VarintType {
+			return 0, errUnknown
+		}
+		v, n := protowire.ConsumeVarint(b)
+		if n < 0 {
+			return 0, protowire.ParseError(n)
+		}
+		list.Append(protoreflect.ValueOfBool(protowire.DecodeBool(v)))
+		return n, nil
+	case protoreflect.EnumKind:
+		if wtyp == protowire.BytesType {
+			buf, n := protowire.ConsumeBytes(b)
+			if n < 0 {
+				return 0, protowire.ParseError(n)
+			}
+			for len(buf) > 0 {
+				v, n := protowire.ConsumeVarint(buf)
+				if n < 0 {
+					return 0, protowire.ParseError(n)
+				}
+				buf = buf[n:]
+				list.Append(protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)))
+			}
+			return n, nil
+		}
+		if wtyp != protowire.VarintType {
+			return 0, errUnknown
+		}
+		v, n := protowire.ConsumeVarint(b)
+		if n < 0 {
+			return 0, protowire.ParseError(n)
+		}
+		list.Append(protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)))
+		return n, nil
+	case protoreflect.Int32Kind:
+		if wtyp == protowire.BytesType {
+			buf, n := protowire.ConsumeBytes(b)
+			if n < 0 {
+				return 0, protowire.ParseError(n)
+			}
+			for len(buf) > 0 {
+				v, n := protowire.ConsumeVarint(buf)
+				if n < 0 {
+					return 0, protowire.ParseError(n)
+				}
+				buf = buf[n:]
+				list.Append(protoreflect.ValueOfInt32(int32(v)))
+			}
+			return n, nil
+		}
+		if wtyp != protowire.VarintType {
+			return 0, errUnknown
+		}
+		v, n := protowire.ConsumeVarint(b)
+		if n < 0 {
+			return 0, protowire.ParseError(n)
+		}
+		list.Append(protoreflect.ValueOfInt32(int32(v)))
+		return n, nil
+	case protoreflect.Sint32Kind:
+		if wtyp == protowire.BytesType {
+			buf, n := protowire.ConsumeBytes(b)
+			if n < 0 {
+				return 0, protowire.ParseError(n)
+			}
+			for len(buf) > 0 {
+				v, n := protowire.ConsumeVarint(buf)
+				if n < 0 {
+					return 0, protowire.ParseError(n)
+				}
+				buf = buf[n:]
+				list.Append(protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))))
+			}
+			return n, nil
+		}
+		if wtyp != protowire.VarintType {
+			return 0, errUnknown
+		}
+		v, n := protowire.ConsumeVarint(b)
+		if n < 0 {
+			return 0, protowire.ParseError(n)
+		}
+		list.Append(protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))))
+		return n, nil
+	case protoreflect.Uint32Kind:
+		if wtyp == protowire.BytesType {
+			buf, n := protowire.ConsumeBytes(b)
+			if n < 0 {
+				return 0, protowire.ParseError(n)
+			}
+			for len(buf) > 0 {
+				v, n := protowire.ConsumeVarint(buf)
+				if n < 0 {
+					return 0, protowire.ParseError(n)
+				}
+				buf = buf[n:]
+				list.Append(protoreflect.ValueOfUint32(uint32(v)))
+			}
+			return n, nil
+		}
+		if wtyp != protowire.VarintType {
+			return 0, errUnknown
+		}
+		v, n := protowire.ConsumeVarint(b)
+		if n < 0 {
+			return 0, protowire.ParseError(n)
+		}
+		list.Append(protoreflect.ValueOfUint32(uint32(v)))
+		return n, nil
+	case protoreflect.Int64Kind:
+		if wtyp == protowire.BytesType {
+			buf, n := protowire.ConsumeBytes(b)
+			if n < 0 {
+				return 0, protowire.ParseError(n)
+			}
+			for len(buf) > 0 {
+				v, n := protowire.ConsumeVarint(buf)
+				if n < 0 {
+					return 0, protowire.ParseError(n)
+				}
+				buf = buf[n:]
+				list.Append(protoreflect.ValueOfInt64(int64(v)))
+			}
+			return n, nil
+		}
+		if wtyp != protowire.VarintType {
+			return 0, errUnknown
+		}
+		v, n := protowire.ConsumeVarint(b)
+		if n < 0 {
+			return 0, protowire.ParseError(n)
+		}
+		list.Append(protoreflect.ValueOfInt64(int64(v)))
+		return n, nil
+	case protoreflect.Sint64Kind:
+		if wtyp == protowire.BytesType {
+			buf, n := protowire.ConsumeBytes(b)
+			if n < 0 {
+				return 0, protowire.ParseError(n)
+			}
+			for len(buf) > 0 {
+				v, n := protowire.ConsumeVarint(buf)
+				if n < 0 {
+					return 0, protowire.ParseError(n)
+				}
+				buf = buf[n:]
+				list.Append(protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)))
+			}
+			return n, nil
+		}
+		if wtyp != protowire.VarintType {
+			return 0, errUnknown
+		}
+		v, n := protowire.ConsumeVarint(b)
+		if n < 0 {
+			return 0, protowire.ParseError(n)
+		}
+		list.Append(protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)))
+		return n, nil
+	case protoreflect.Uint64Kind:
+		if wtyp == protowire.BytesType {
+			buf, n := protowire.ConsumeBytes(b)
+			if n < 0 {
+				return 0, protowire.ParseError(n)
+			}
+			for len(buf) > 0 {
+				v, n := protowire.ConsumeVarint(buf)
+				if n < 0 {
+					return 0, protowire.ParseError(n)
+				}
+				buf = buf[n:]
+				list.Append(protoreflect.ValueOfUint64(v))
+			}
+			return n, nil
+		}
+		if wtyp != protowire.VarintType {
+			return 0, errUnknown
+		}
+		v, n := protowire.ConsumeVarint(b)
+		if n < 0 {
+			return 0, protowire.ParseError(n)
+		}
+		list.Append(protoreflect.ValueOfUint64(v))
+		return n, nil
+	case protoreflect.Sfixed32Kind:
+		if wtyp == protowire.BytesType {
+			buf, n := protowire.ConsumeBytes(b)
+			if n < 0 {
+				return 0, protowire.ParseError(n)
+			}
+			for len(buf) > 0 {
+				v, n := protowire.ConsumeFixed32(buf)
+				if n < 0 {
+					return 0, protowire.ParseError(n)
+				}
+				buf = buf[n:]
+				list.Append(protoreflect.ValueOfInt32(int32(v)))
+			}
+			return n, nil
+		}
+		if wtyp != protowire.Fixed32Type {
+			return 0, errUnknown
+		}
+		v, n := protowire.ConsumeFixed32(b)
+		if n < 0 {
+			return 0, protowire.ParseError(n)
+		}
+		list.Append(protoreflect.ValueOfInt32(int32(v)))
+		return n, nil
+	case protoreflect.Fixed32Kind:
+		if wtyp == protowire.BytesType {
+			buf, n := protowire.ConsumeBytes(b)
+			if n < 0 {
+				return 0, protowire.ParseError(n)
+			}
+			for len(buf) > 0 {
+				v, n := protowire.ConsumeFixed32(buf)
+				if n < 0 {
+					return 0, protowire.ParseError(n)
+				}
+				buf = buf[n:]
+				list.Append(protoreflect.ValueOfUint32(uint32(v)))
+			}
+			return n, nil
+		}
+		if wtyp != protowire.Fixed32Type {
+			return 0, errUnknown
+		}
+		v, n := protowire.ConsumeFixed32(b)
+		if n < 0 {
+			return 0, protowire.ParseError(n)
+		}
+		list.Append(protoreflect.ValueOfUint32(uint32(v)))
+		return n, nil
+	case protoreflect.FloatKind:
+		if wtyp == protowire.BytesType {
+			buf, n := protowire.ConsumeBytes(b)
+			if n < 0 {
+				return 0, protowire.ParseError(n)
+			}
+			for len(buf) > 0 {
+				v, n := protowire.ConsumeFixed32(buf)
+				if n < 0 {
+					return 0, protowire.ParseError(n)
+				}
+				buf = buf[n:]
+				list.Append(protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))))
+			}
+			return n, nil
+		}
+		if wtyp != protowire.Fixed32Type {
+			return 0, errUnknown
+		}
+		v, n := protowire.ConsumeFixed32(b)
+		if n < 0 {
+			return 0, protowire.ParseError(n)
+		}
+		list.Append(protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))))
+		return n, nil
+	case protoreflect.Sfixed64Kind:
+		if wtyp == protowire.BytesType {
+			buf, n := protowire.ConsumeBytes(b)
+			if n < 0 {
+				return 0, protowire.ParseError(n)
+			}
+			for len(buf) > 0 {
+				v, n := protowire.ConsumeFixed64(buf)
+				if n < 0 {
+					return 0, protowire.ParseError(n)
+				}
+				buf = buf[n:]
+				list.Append(protoreflect.ValueOfInt64(int64(v)))
+			}
+			return n, nil
+		}
+		if wtyp != protowire.Fixed64Type {
+			return 0, errUnknown
+		}
+		v, n := protowire.ConsumeFixed64(b)
+		if n < 0 {
+			return 0, protowire.ParseError(n)
+		}
+		list.Append(protoreflect.ValueOfInt64(int64(v)))
+		return n, nil
+	case protoreflect.Fixed64Kind:
+		if wtyp == protowire.BytesType {
+			buf, n := protowire.ConsumeBytes(b)
+			if n < 0 {
+				return 0, protowire.ParseError(n)
+			}
+			for len(buf) > 0 {
+				v, n := protowire.ConsumeFixed64(buf)
+				if n < 0 {
+					return 0, protowire.ParseError(n)
+				}
+				buf = buf[n:]
+				list.Append(protoreflect.ValueOfUint64(v))
+			}
+			return n, nil
+		}
+		if wtyp != protowire.Fixed64Type {
+			return 0, errUnknown
+		}
+		v, n := protowire.ConsumeFixed64(b)
+		if n < 0 {
+			return 0, protowire.ParseError(n)
+		}
+		list.Append(protoreflect.ValueOfUint64(v))
+		return n, nil
+	case protoreflect.DoubleKind:
+		if wtyp == protowire.BytesType {
+			buf, n := protowire.ConsumeBytes(b)
+			if n < 0 {
+				return 0, protowire.ParseError(n)
+			}
+			for len(buf) > 0 {
+				v, n := protowire.ConsumeFixed64(buf)
+				if n < 0 {
+					return 0, protowire.ParseError(n)
+				}
+				buf = buf[n:]
+				list.Append(protoreflect.ValueOfFloat64(math.Float64frombits(v)))
+			}
+			return n, nil
+		}
+		if wtyp != protowire.Fixed64Type {
+			return 0, errUnknown
+		}
+		v, n := protowire.ConsumeFixed64(b)
+		if n < 0 {
+			return 0, protowire.ParseError(n)
+		}
+		list.Append(protoreflect.ValueOfFloat64(math.Float64frombits(v)))
+		return n, nil
+	case protoreflect.StringKind:
+		if wtyp != protowire.BytesType {
+			return 0, errUnknown
+		}
+		v, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return 0, protowire.ParseError(n)
+		}
+		if strs.EnforceUTF8(fd) && !utf8.Valid(v) {
+			return 0, errors.InvalidUTF8(string(fd.FullName()))
+		}
+		list.Append(protoreflect.ValueOfString(string(v)))
+		return n, nil
+	case protoreflect.BytesKind:
+		if wtyp != protowire.BytesType {
+			return 0, errUnknown
+		}
+		v, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return 0, protowire.ParseError(n)
+		}
+		list.Append(protoreflect.ValueOfBytes(append(emptyBuf[:], v...)))
+		return n, nil
+	case protoreflect.MessageKind:
+		if wtyp != protowire.BytesType {
+			return 0, errUnknown
+		}
+		v, n := protowire.ConsumeBytes(b)
+		if n < 0 {
+			return 0, protowire.ParseError(n)
+		}
+		m := list.NewElement()
+		if err := o.unmarshalMessage(v, m.Message()); err != nil {
+			return 0, err
+		}
+		list.Append(m)
+		return n, nil
+	case protoreflect.GroupKind:
+		if wtyp != protowire.StartGroupType {
+			return 0, errUnknown
+		}
+		v, n := protowire.ConsumeGroup(fd.Number(), b)
+		if n < 0 {
+			return 0, protowire.ParseError(n)
+		}
+		m := list.NewElement()
+		if err := o.unmarshalMessage(v, m.Message()); err != nil {
+			return 0, err
+		}
+		list.Append(m)
+		return n, nil
+	default:
+		return 0, errUnknown
+	}
+}
+
+// We append to an empty array rather than a nil []byte to get non-nil zero-length byte slices.
+var emptyBuf [0]byte
diff --git a/vendor/google.golang.org/protobuf/proto/decode_test.go b/vendor/google.golang.org/protobuf/proto/decode_test.go
new file mode 100644
index 000000000..3f64dd433
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/proto/decode_test.go
@@ -0,0 +1,154 @@
+// 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 proto_test
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+	"testing"
+
+	"google.golang.org/protobuf/encoding/prototext"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/testing/protopack"
+
+	testpb "google.golang.org/protobuf/internal/testprotos/test"
+	test3pb "google.golang.org/protobuf/internal/testprotos/test3"
+)
+
+func TestDecode(t *testing.T) {
+	for _, test := range testValidMessages {
+		if len(test.decodeTo) == 0 {
+			t.Errorf("%v: no test message types", test.desc)
+		}
+		for _, want := range test.decodeTo {
+			t.Run(fmt.Sprintf("%s (%T)", test.desc, want), func(t *testing.T) {
+				opts := test.unmarshalOptions
+				opts.AllowPartial = test.partial
+				wire := append(([]byte)(nil), test.wire...)
+				got := reflect.New(reflect.TypeOf(want).Elem()).Interface().(proto.Message)
+				if err := opts.Unmarshal(wire, got); err != nil {
+					t.Errorf("Unmarshal error: %v\nMessage:\n%v", err, prototext.Format(want))
+					return
+				}
+
+				// Aliasing check: Unmarshal shouldn't modify the original wire
+				// bytes, and modifying the original wire bytes shouldn't affect
+				// the unmarshaled message.
+				if !bytes.Equal(test.wire, wire) {
+					t.Errorf("Unmarshal unexpectedly modified its input")
+				}
+				for i := range wire {
+					wire[i] = 0
+				}
+				if !proto.Equal(got, want) && got.ProtoReflect().IsValid() && want.ProtoReflect().IsValid() {
+					t.Errorf("Unmarshal returned unexpected result; got:\n%v\nwant:\n%v", prototext.Format(got), prototext.Format(want))
+				}
+			})
+		}
+	}
+}
+
+func TestDecodeRequiredFieldChecks(t *testing.T) {
+	for _, test := range testValidMessages {
+		if !test.partial {
+			continue
+		}
+		for _, m := range test.decodeTo {
+			t.Run(fmt.Sprintf("%s (%T)", test.desc, m), func(t *testing.T) {
+				opts := test.unmarshalOptions
+				opts.AllowPartial = false
+				got := reflect.New(reflect.TypeOf(m).Elem()).Interface().(proto.Message)
+				if err := proto.Unmarshal(test.wire, got); err == nil {
+					t.Fatalf("Unmarshal succeeded (want error)\nMessage:\n%v", prototext.Format(got))
+				}
+			})
+		}
+	}
+}
+
+func TestDecodeInvalidMessages(t *testing.T) {
+	for _, test := range testInvalidMessages {
+		if len(test.decodeTo) == 0 {
+			t.Errorf("%v: no test message types", test.desc)
+		}
+		for _, want := range test.decodeTo {
+			t.Run(fmt.Sprintf("%s (%T)", test.desc, want), func(t *testing.T) {
+				opts := test.unmarshalOptions
+				opts.AllowPartial = test.partial
+				got := want.ProtoReflect().New().Interface()
+				if err := opts.Unmarshal(test.wire, got); err == nil {
+					t.Errorf("Unmarshal unexpectedly succeeded\ninput bytes: [%x]\nMessage:\n%v", test.wire, prototext.Format(got))
+				}
+			})
+		}
+	}
+}
+
+func TestDecodeZeroLengthBytes(t *testing.T) {
+	// Verify that proto3 bytes fields don't give the mistaken
+	// impression that they preserve presence.
+	wire := protopack.Message{
+		protopack.Tag{94, protopack.BytesType}, protopack.Bytes(nil),
+	}.Marshal()
+	m := &test3pb.TestAllTypes{}
+	if err := proto.Unmarshal(wire, m); err != nil {
+		t.Fatal(err)
+	}
+	if m.OptionalBytes != nil {
+		t.Errorf("unmarshal zero-length proto3 bytes field: got %v, want nil", m.OptionalBytes)
+	}
+}
+
+func TestDecodeOneofNilWrapper(t *testing.T) {
+	wire := protopack.Message{
+		protopack.Tag{111, protopack.VarintType}, protopack.Varint(1111),
+	}.Marshal()
+	m := &testpb.TestAllTypes{OneofField: (*testpb.TestAllTypes_OneofUint32)(nil)}
+	if err := proto.Unmarshal(wire, m); err != nil {
+		t.Fatal(err)
+	}
+	if got := m.GetOneofUint32(); got != 1111 {
+		t.Errorf("GetOneofUint32() = %v, want %v", got, 1111)
+	}
+}
+
+func TestDecodeEmptyBytes(t *testing.T) {
+	// There's really nothing wrong with a nil entry in a [][]byte,
+	// but we take care to produce non-nil []bytes for zero-length
+	// byte strings, so test for it.
+	m := &testpb.TestAllTypes{}
+	b := protopack.Message{
+		protopack.Tag{45, protopack.BytesType}, protopack.Bytes(nil),
+	}.Marshal()
+	if err := proto.Unmarshal(b, m); err != nil {
+		t.Fatal(err)
+	}
+	if m.RepeatedBytes[0] == nil {
+		t.Errorf("unmarshaling repeated bytes field containing zero-length value: Got nil bytes, want non-nil")
+	}
+}
+
+func build(m proto.Message, opts ...buildOpt) proto.Message {
+	for _, opt := range opts {
+		opt(m)
+	}
+	return m
+}
+
+type buildOpt func(proto.Message)
+
+func unknown(raw protoreflect.RawFields) buildOpt {
+	return func(m proto.Message) {
+		m.ProtoReflect().SetUnknown(raw)
+	}
+}
+
+func extend(desc protoreflect.ExtensionType, value interface{}) buildOpt {
+	return func(m proto.Message) {
+		proto.SetExtension(m, desc, value)
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/proto/doc.go b/vendor/google.golang.org/protobuf/proto/doc.go
new file mode 100644
index 000000000..c52d8c4ab
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/proto/doc.go
@@ -0,0 +1,94 @@
+// Copyright 2019 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 proto provides functions operating on protocol buffer messages.
+//
+// For documentation on protocol buffers in general, see:
+//
+//   https://developers.google.com/protocol-buffers
+//
+// For a tutorial on using protocol buffers with Go, see:
+//
+//   https://developers.google.com/protocol-buffers/docs/gotutorial
+//
+// For a guide to generated Go protocol buffer code, see:
+//
+//   https://developers.google.com/protocol-buffers/docs/reference/go-generated
+//
+//
+// Binary serialization
+//
+// This package contains functions to convert to and from the wire format,
+// an efficient binary serialization of protocol buffers.
+//
+// • Size reports the size of a message in the wire format.
+//
+// • Marshal converts a message to the wire format.
+// The MarshalOptions type provides more control over wire marshaling.
+//
+// • Unmarshal converts a message from the wire format.
+// The UnmarshalOptions type provides more control over wire unmarshaling.
+//
+//
+// Basic message operations
+//
+// • Clone makes a deep copy of a message.
+//
+// • Merge merges the content of a message into another.
+//
+// • Equal compares two messages. For more control over comparisons
+// and detailed reporting of differences, see package
+// "google.golang.org/protobuf/testing/protocmp".
+//
+// • Reset clears the content of a message.
+//
+// • CheckInitialized reports whether all required fields in a message are set.
+//
+//
+// Optional scalar constructors
+//
+// The API for some generated messages represents optional scalar fields
+// as pointers to a value. For example, an optional string field has the
+// Go type *string.
+//
+// • Bool, Int32, Int64, Uint32, Uint64, Float32, Float64, and String
+// take a value and return a pointer to a new instance of it,
+// to simplify construction of optional field values.
+//
+// Generated enum types usually have an Enum method which performs the
+// same operation.
+//
+// Optional scalar fields are only supported in proto2.
+//
+//
+// Extension accessors
+//
+// • HasExtension, GetExtension, SetExtension, and ClearExtension
+// access extension field values in a protocol buffer message.
+//
+// Extension fields are only supported in proto2.
+//
+//
+// Related packages
+//
+// • Package "google.golang.org/protobuf/encoding/protojson" converts messages to
+// and from JSON.
+//
+// • Package "google.golang.org/protobuf/encoding/prototext" converts messages to
+// and from the text format.
+//
+// • Package "google.golang.org/protobuf/reflect/protoreflect" provides a
+// reflection interface for protocol buffer data types.
+//
+// • Package "google.golang.org/protobuf/testing/protocmp" provides features
+// to compare protocol buffer messages with the "github.com/google/go-cmp/cmp"
+// package.
+//
+// • Package "google.golang.org/protobuf/types/dynamicpb" provides a dynamic
+// message type, suitable for working with messages where the protocol buffer
+// type is only known at runtime.
+//
+// This module contains additional packages for more specialized use cases.
+// Consult the individual package documentation for details.
+package proto
diff --git a/vendor/google.golang.org/protobuf/proto/encode.go b/vendor/google.golang.org/protobuf/proto/encode.go
new file mode 100644
index 000000000..456bfda47
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/proto/encode.go
@@ -0,0 +1,343 @@
+// Copyright 2019 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 proto
+
+import (
+	"sort"
+
+	"google.golang.org/protobuf/encoding/protowire"
+	"google.golang.org/protobuf/internal/encoding/messageset"
+	"google.golang.org/protobuf/internal/fieldsort"
+	"google.golang.org/protobuf/internal/mapsort"
+	"google.golang.org/protobuf/internal/pragma"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/runtime/protoiface"
+)
+
+// MarshalOptions configures the marshaler.
+//
+// Example usage:
+//   b, err := MarshalOptions{Deterministic: true}.Marshal(m)
+type MarshalOptions struct {
+	pragma.NoUnkeyedLiterals
+
+	// AllowPartial allows messages that have missing required fields to marshal
+	// without returning an error. If AllowPartial is false (the default),
+	// Marshal will return an error if there are any missing required fields.
+	AllowPartial bool
+
+	// Deterministic controls whether the same message will always be
+	// serialized to the same bytes within the same binary.
+	//
+	// Setting this option guarantees that repeated serialization of
+	// the same message will return the same bytes, and that different
+	// processes of the same binary (which may be executing on different
+	// machines) will serialize equal messages to the same bytes.
+	// It has no effect on the resulting size of the encoded message compared
+	// to a non-deterministic marshal.
+	//
+	// Note that the deterministic serialization is NOT canonical across
+	// languages. It is not guaranteed to remain stable over time. It is
+	// unstable across different builds with schema changes due to unknown
+	// fields. Users who need canonical serialization (e.g., persistent
+	// storage in a canonical form, fingerprinting, etc.) must define
+	// their own canonicalization specification and implement their own
+	// serializer rather than relying on this API.
+	//
+	// If deterministic serialization is requested, map entries will be
+	// sorted by keys in lexographical order. This is an implementation
+	// detail and subject to change.
+	Deterministic bool
+
+	// UseCachedSize indicates that the result of a previous Size call
+	// may be reused.
+	//
+	// Setting this option asserts that:
+	//
+	// 1. Size has previously been called on this message with identical
+	// options (except for UseCachedSize itself).
+	//
+	// 2. The message and all its submessages have not changed in any
+	// way since the Size call.
+	//
+	// If either of these invariants is violated,
+	// the results are undefined and may include panics or corrupted output.
+	//
+	// Implementations MAY take this option into account to provide
+	// better performance, but there is no guarantee that they will do so.
+	// There is absolutely no guarantee that Size followed by Marshal with
+	// UseCachedSize set will perform equivalently to Marshal alone.
+	UseCachedSize bool
+}
+
+// Marshal returns the wire-format encoding of m.
+func Marshal(m Message) ([]byte, error) {
+	// Treat nil message interface as an empty message; nothing to output.
+	if m == nil {
+		return nil, nil
+	}
+
+	out, err := MarshalOptions{}.marshal(nil, m.ProtoReflect())
+	if len(out.Buf) == 0 && err == nil {
+		out.Buf = emptyBytesForMessage(m)
+	}
+	return out.Buf, err
+}
+
+// Marshal returns the wire-format encoding of m.
+func (o MarshalOptions) Marshal(m Message) ([]byte, error) {
+	// Treat nil message interface as an empty message; nothing to output.
+	if m == nil {
+		return nil, nil
+	}
+
+	out, err := o.marshal(nil, m.ProtoReflect())
+	if len(out.Buf) == 0 && err == nil {
+		out.Buf = emptyBytesForMessage(m)
+	}
+	return out.Buf, err
+}
+
+// emptyBytesForMessage returns a nil buffer if and only if m is invalid,
+// otherwise it returns a non-nil empty buffer.
+//
+// This is to assist the edge-case where user-code does the following:
+//	m1.OptionalBytes, _ = proto.Marshal(m2)
+// where they expect the proto2 "optional_bytes" field to be populated
+// if any only if m2 is a valid message.
+func emptyBytesForMessage(m Message) []byte {
+	if m == nil || !m.ProtoReflect().IsValid() {
+		return nil
+	}
+	return emptyBuf[:]
+}
+
+// MarshalAppend appends the wire-format encoding of m to b,
+// returning the result.
+func (o MarshalOptions) MarshalAppend(b []byte, m Message) ([]byte, error) {
+	// Treat nil message interface as an empty message; nothing to append.
+	if m == nil {
+		return b, nil
+	}
+
+	out, err := o.marshal(b, m.ProtoReflect())
+	return out.Buf, err
+}
+
+// MarshalState returns the wire-format encoding of a message.
+//
+// This method permits fine-grained control over the marshaler.
+// Most users should use Marshal instead.
+func (o MarshalOptions) MarshalState(in protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+	return o.marshal(in.Buf, in.Message)
+}
+
+func (o MarshalOptions) marshal(b []byte, m protoreflect.Message) (out protoiface.MarshalOutput, err error) {
+	allowPartial := o.AllowPartial
+	o.AllowPartial = true
+	if methods := protoMethods(m); methods != nil && methods.Marshal != nil &&
+		!(o.Deterministic && methods.Flags&protoiface.SupportMarshalDeterministic == 0) {
+		in := protoiface.MarshalInput{
+			Message: m,
+			Buf:     b,
+		}
+		if o.Deterministic {
+			in.Flags |= protoiface.MarshalDeterministic
+		}
+		if o.UseCachedSize {
+			in.Flags |= protoiface.MarshalUseCachedSize
+		}
+		if methods.Size != nil {
+			sout := methods.Size(protoiface.SizeInput{
+				Message: m,
+				Flags:   in.Flags,
+			})
+			if cap(b) < len(b)+sout.Size {
+				in.Buf = make([]byte, len(b), growcap(cap(b), len(b)+sout.Size))
+				copy(in.Buf, b)
+			}
+			in.Flags |= protoiface.MarshalUseCachedSize
+		}
+		out, err = methods.Marshal(in)
+	} else {
+		out.Buf, err = o.marshalMessageSlow(b, m)
+	}
+	if err != nil {
+		return out, err
+	}
+	if allowPartial {
+		return out, nil
+	}
+	return out, checkInitialized(m)
+}
+
+func (o MarshalOptions) marshalMessage(b []byte, m protoreflect.Message) ([]byte, error) {
+	out, err := o.marshal(b, m)
+	return out.Buf, err
+}
+
+// growcap scales up the capacity of a slice.
+//
+// Given a slice with a current capacity of oldcap and a desired
+// capacity of wantcap, growcap returns a new capacity >= wantcap.
+//
+// The algorithm is mostly identical to the one used by append as of Go 1.14.
+func growcap(oldcap, wantcap int) (newcap int) {
+	if wantcap > oldcap*2 {
+		newcap = wantcap
+	} else if oldcap < 1024 {
+		// The Go 1.14 runtime takes this case when len(s) < 1024,
+		// not when cap(s) < 1024. The difference doesn't seem
+		// significant here.
+		newcap = oldcap * 2
+	} else {
+		newcap = oldcap
+		for 0 < newcap && newcap < wantcap {
+			newcap += newcap / 4
+		}
+		if newcap <= 0 {
+			newcap = wantcap
+		}
+	}
+	return newcap
+}
+
+func (o MarshalOptions) marshalMessageSlow(b []byte, m protoreflect.Message) ([]byte, error) {
+	if messageset.IsMessageSet(m.Descriptor()) {
+		return marshalMessageSet(b, m, o)
+	}
+	// There are many choices for what order we visit fields in. The default one here
+	// is chosen for reasonable efficiency and simplicity given the protoreflect API.
+	// It is not deterministic, since Message.Range does not return fields in any
+	// defined order.
+	//
+	// When using deterministic serialization, we sort the known fields.
+	var err error
+	o.rangeFields(m, func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
+		b, err = o.marshalField(b, fd, v)
+		return err == nil
+	})
+	if err != nil {
+		return b, err
+	}
+	b = append(b, m.GetUnknown()...)
+	return b, nil
+}
+
+// rangeFields visits fields in a defined order when deterministic serialization is enabled.
+func (o MarshalOptions) rangeFields(m protoreflect.Message, f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if !o.Deterministic {
+		m.Range(f)
+		return
+	}
+	var fds []protoreflect.FieldDescriptor
+	m.Range(func(fd protoreflect.FieldDescriptor, _ protoreflect.Value) bool {
+		fds = append(fds, fd)
+		return true
+	})
+	sort.Slice(fds, func(a, b int) bool {
+		return fieldsort.Less(fds[a], fds[b])
+	})
+	for _, fd := range fds {
+		if !f(fd, m.Get(fd)) {
+			break
+		}
+	}
+}
+
+func (o MarshalOptions) marshalField(b []byte, fd protoreflect.FieldDescriptor, value protoreflect.Value) ([]byte, error) {
+	switch {
+	case fd.IsList():
+		return o.marshalList(b, fd, value.List())
+	case fd.IsMap():
+		return o.marshalMap(b, fd, value.Map())
+	default:
+		b = protowire.AppendTag(b, fd.Number(), wireTypes[fd.Kind()])
+		return o.marshalSingular(b, fd, value)
+	}
+}
+
+func (o MarshalOptions) marshalList(b []byte, fd protoreflect.FieldDescriptor, list protoreflect.List) ([]byte, error) {
+	if fd.IsPacked() && list.Len() > 0 {
+		b = protowire.AppendTag(b, fd.Number(), protowire.BytesType)
+		b, pos := appendSpeculativeLength(b)
+		for i, llen := 0, list.Len(); i < llen; i++ {
+			var err error
+			b, err = o.marshalSingular(b, fd, list.Get(i))
+			if err != nil {
+				return b, err
+			}
+		}
+		b = finishSpeculativeLength(b, pos)
+		return b, nil
+	}
+
+	kind := fd.Kind()
+	for i, llen := 0, list.Len(); i < llen; i++ {
+		var err error
+		b = protowire.AppendTag(b, fd.Number(), wireTypes[kind])
+		b, err = o.marshalSingular(b, fd, list.Get(i))
+		if err != nil {
+			return b, err
+		}
+	}
+	return b, nil
+}
+
+func (o MarshalOptions) marshalMap(b []byte, fd protoreflect.FieldDescriptor, mapv protoreflect.Map) ([]byte, error) {
+	keyf := fd.MapKey()
+	valf := fd.MapValue()
+	var err error
+	o.rangeMap(mapv, keyf.Kind(), func(key protoreflect.MapKey, value protoreflect.Value) bool {
+		b = protowire.AppendTag(b, fd.Number(), protowire.BytesType)
+		var pos int
+		b, pos = appendSpeculativeLength(b)
+
+		b, err = o.marshalField(b, keyf, key.Value())
+		if err != nil {
+			return false
+		}
+		b, err = o.marshalField(b, valf, value)
+		if err != nil {
+			return false
+		}
+		b = finishSpeculativeLength(b, pos)
+		return true
+	})
+	return b, err
+}
+
+func (o MarshalOptions) rangeMap(mapv protoreflect.Map, kind protoreflect.Kind, f func(protoreflect.MapKey, protoreflect.Value) bool) {
+	if !o.Deterministic {
+		mapv.Range(f)
+		return
+	}
+	mapsort.Range(mapv, kind, f)
+}
+
+// When encoding length-prefixed fields, we speculatively set aside some number of bytes
+// for the length, encode the data, and then encode the length (shifting the data if necessary
+// to make room).
+const speculativeLength = 1
+
+func appendSpeculativeLength(b []byte) ([]byte, int) {
+	pos := len(b)
+	b = append(b, "\x00\x00\x00\x00"[:speculativeLength]...)
+	return b, pos
+}
+
+func finishSpeculativeLength(b []byte, pos int) []byte {
+	mlen := len(b) - pos - speculativeLength
+	msiz := protowire.SizeVarint(uint64(mlen))
+	if msiz != speculativeLength {
+		for i := 0; i < msiz-speculativeLength; i++ {
+			b = append(b, 0)
+		}
+		copy(b[pos+msiz:], b[pos+speculativeLength:])
+		b = b[:pos+msiz+mlen]
+	}
+	protowire.AppendVarint(b[:pos], uint64(mlen))
+	return b
+}
diff --git a/vendor/google.golang.org/protobuf/proto/encode_gen.go b/vendor/google.golang.org/protobuf/proto/encode_gen.go
new file mode 100644
index 000000000..185dacfb4
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/proto/encode_gen.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.
+
+// Code generated by generate-types. DO NOT EDIT.
+
+package proto
+
+import (
+	"math"
+	"unicode/utf8"
+
+	"google.golang.org/protobuf/encoding/protowire"
+	"google.golang.org/protobuf/internal/errors"
+	"google.golang.org/protobuf/internal/strs"
+	"google.golang.org/protobuf/reflect/protoreflect"
+)
+
+var wireTypes = map[protoreflect.Kind]protowire.Type{
+	protoreflect.BoolKind:     protowire.VarintType,
+	protoreflect.EnumKind:     protowire.VarintType,
+	protoreflect.Int32Kind:    protowire.VarintType,
+	protoreflect.Sint32Kind:   protowire.VarintType,
+	protoreflect.Uint32Kind:   protowire.VarintType,
+	protoreflect.Int64Kind:    protowire.VarintType,
+	protoreflect.Sint64Kind:   protowire.VarintType,
+	protoreflect.Uint64Kind:   protowire.VarintType,
+	protoreflect.Sfixed32Kind: protowire.Fixed32Type,
+	protoreflect.Fixed32Kind:  protowire.Fixed32Type,
+	protoreflect.FloatKind:    protowire.Fixed32Type,
+	protoreflect.Sfixed64Kind: protowire.Fixed64Type,
+	protoreflect.Fixed64Kind:  protowire.Fixed64Type,
+	protoreflect.DoubleKind:   protowire.Fixed64Type,
+	protoreflect.StringKind:   protowire.BytesType,
+	protoreflect.BytesKind:    protowire.BytesType,
+	protoreflect.MessageKind:  protowire.BytesType,
+	protoreflect.GroupKind:    protowire.StartGroupType,
+}
+
+func (o MarshalOptions) marshalSingular(b []byte, fd protoreflect.FieldDescriptor, v protoreflect.Value) ([]byte, error) {
+	switch fd.Kind() {
+	case protoreflect.BoolKind:
+		b = protowire.AppendVarint(b, protowire.EncodeBool(v.Bool()))
+	case protoreflect.EnumKind:
+		b = protowire.AppendVarint(b, uint64(v.Enum()))
+	case protoreflect.Int32Kind:
+		b = protowire.AppendVarint(b, uint64(int32(v.Int())))
+	case protoreflect.Sint32Kind:
+		b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(int32(v.Int()))))
+	case protoreflect.Uint32Kind:
+		b = protowire.AppendVarint(b, uint64(uint32(v.Uint())))
+	case protoreflect.Int64Kind:
+		b = protowire.AppendVarint(b, uint64(v.Int()))
+	case protoreflect.Sint64Kind:
+		b = protowire.AppendVarint(b, protowire.EncodeZigZag(v.Int()))
+	case protoreflect.Uint64Kind:
+		b = protowire.AppendVarint(b, v.Uint())
+	case protoreflect.Sfixed32Kind:
+		b = protowire.AppendFixed32(b, uint32(v.Int()))
+	case protoreflect.Fixed32Kind:
+		b = protowire.AppendFixed32(b, uint32(v.Uint()))
+	case protoreflect.FloatKind:
+		b = protowire.AppendFixed32(b, math.Float32bits(float32(v.Float())))
+	case protoreflect.Sfixed64Kind:
+		b = protowire.AppendFixed64(b, uint64(v.Int()))
+	case protoreflect.Fixed64Kind:
+		b = protowire.AppendFixed64(b, v.Uint())
+	case protoreflect.DoubleKind:
+		b = protowire.AppendFixed64(b, math.Float64bits(v.Float()))
+	case protoreflect.StringKind:
+		if strs.EnforceUTF8(fd) && !utf8.ValidString(v.String()) {
+			return b, errors.InvalidUTF8(string(fd.FullName()))
+		}
+		b = protowire.AppendString(b, v.String())
+	case protoreflect.BytesKind:
+		b = protowire.AppendBytes(b, v.Bytes())
+	case protoreflect.MessageKind:
+		var pos int
+		var err error
+		b, pos = appendSpeculativeLength(b)
+		b, err = o.marshalMessage(b, v.Message())
+		if err != nil {
+			return b, err
+		}
+		b = finishSpeculativeLength(b, pos)
+	case protoreflect.GroupKind:
+		var err error
+		b, err = o.marshalMessage(b, v.Message())
+		if err != nil {
+			return b, err
+		}
+		b = protowire.AppendVarint(b, protowire.EncodeTag(fd.Number(), protowire.EndGroupType))
+	default:
+		return b, errors.New("invalid kind %v", fd.Kind())
+	}
+	return b, nil
+}
diff --git a/vendor/google.golang.org/protobuf/proto/encode_test.go b/vendor/google.golang.org/protobuf/proto/encode_test.go
new file mode 100644
index 000000000..852aa57b1
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/proto/encode_test.go
@@ -0,0 +1,274 @@
+// Copyright 2019 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 proto_test
+
+import (
+	"bytes"
+	"fmt"
+	"math"
+	"reflect"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+
+	"google.golang.org/protobuf/encoding/prototext"
+	"google.golang.org/protobuf/encoding/protowire"
+	"google.golang.org/protobuf/proto"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+
+	orderpb "google.golang.org/protobuf/internal/testprotos/order"
+	testpb "google.golang.org/protobuf/internal/testprotos/test"
+	test3pb "google.golang.org/protobuf/internal/testprotos/test3"
+)
+
+func TestEncode(t *testing.T) {
+	for _, test := range testValidMessages {
+		for _, want := range test.decodeTo {
+			t.Run(fmt.Sprintf("%s (%T)", test.desc, want), func(t *testing.T) {
+				opts := proto.MarshalOptions{
+					AllowPartial: test.partial,
+				}
+				wire, err := opts.Marshal(want)
+				if err != nil {
+					t.Fatalf("Marshal error: %v\nMessage:\n%v", err, prototext.Format(want))
+				}
+
+				size := proto.Size(want)
+				if size != len(wire) {
+					t.Errorf("Size and marshal disagree: Size(m)=%v; len(Marshal(m))=%v\nMessage:\n%v", size, len(wire), prototext.Format(want))
+				}
+
+				got := want.ProtoReflect().New().Interface()
+				uopts := proto.UnmarshalOptions{
+					AllowPartial: test.partial,
+				}
+				if err := uopts.Unmarshal(wire, got); err != nil {
+					t.Errorf("Unmarshal error: %v\nMessage:\n%v", err, prototext.Format(want))
+					return
+				}
+				if !proto.Equal(got, want) && got.ProtoReflect().IsValid() && want.ProtoReflect().IsValid() {
+					t.Errorf("Unmarshal returned unexpected result; got:\n%v\nwant:\n%v", prototext.Format(got), prototext.Format(want))
+				}
+			})
+		}
+	}
+}
+
+func TestEncodeDeterministic(t *testing.T) {
+	for _, test := range testValidMessages {
+		for _, want := range test.decodeTo {
+			t.Run(fmt.Sprintf("%s (%T)", test.desc, want), func(t *testing.T) {
+				opts := proto.MarshalOptions{
+					Deterministic: true,
+					AllowPartial:  test.partial,
+				}
+				wire, err := opts.Marshal(want)
+				if err != nil {
+					t.Fatalf("Marshal error: %v\nMessage:\n%v", err, prototext.Format(want))
+				}
+				wire2, err := opts.Marshal(want)
+				if err != nil {
+					t.Fatalf("Marshal error: %v\nMessage:\n%v", err, prototext.Format(want))
+				}
+				if !bytes.Equal(wire, wire2) {
+					t.Fatalf("deterministic marshal returned varying results:\n%v", cmp.Diff(wire, wire2))
+				}
+
+				got := want.ProtoReflect().New().Interface()
+				uopts := proto.UnmarshalOptions{
+					AllowPartial: test.partial,
+				}
+				if err := uopts.Unmarshal(wire, got); err != nil {
+					t.Errorf("Unmarshal error: %v\nMessage:\n%v", err, prototext.Format(want))
+					return
+				}
+				if !proto.Equal(got, want) && got.ProtoReflect().IsValid() && want.ProtoReflect().IsValid() {
+					t.Errorf("Unmarshal returned unexpected result; got:\n%v\nwant:\n%v", prototext.Format(got), prototext.Format(want))
+				}
+			})
+		}
+	}
+}
+
+func TestEncodeRequiredFieldChecks(t *testing.T) {
+	for _, test := range testValidMessages {
+		if !test.partial {
+			continue
+		}
+		for _, m := range test.decodeTo {
+			t.Run(fmt.Sprintf("%s (%T)", test.desc, m), func(t *testing.T) {
+				_, err := proto.Marshal(m)
+				if err == nil {
+					t.Fatalf("Marshal succeeded (want error)\nMessage:\n%v", prototext.Format(m))
+				}
+			})
+		}
+	}
+}
+
+func TestEncodeAppend(t *testing.T) {
+	want := []byte("prefix")
+	got := append([]byte(nil), want...)
+	got, err := proto.MarshalOptions{}.MarshalAppend(got, &test3pb.TestAllTypes{
+		SingularString: "value",
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !bytes.HasPrefix(got, want) {
+		t.Fatalf("MarshalAppend modified prefix: got %v, want prefix %v", got, want)
+	}
+}
+
+func TestEncodeInvalidMessages(t *testing.T) {
+	for _, test := range testInvalidMessages {
+		for _, m := range test.decodeTo {
+			if !m.ProtoReflect().IsValid() {
+				continue
+			}
+			t.Run(fmt.Sprintf("%s (%T)", test.desc, m), func(t *testing.T) {
+				opts := proto.MarshalOptions{
+					AllowPartial: test.partial,
+				}
+				got, err := opts.Marshal(m)
+				if err == nil {
+					t.Fatalf("Marshal unexpectedly succeeded\noutput bytes: [%x]\nMessage:\n%v", got, prototext.Format(m))
+				}
+			})
+		}
+	}
+}
+
+func TestEncodeOneofNilWrapper(t *testing.T) {
+	m := &testpb.TestAllTypes{OneofField: (*testpb.TestAllTypes_OneofUint32)(nil)}
+	b, err := proto.Marshal(m)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(b) > 0 {
+		t.Errorf("Marshal return non-empty, want empty")
+	}
+}
+
+func TestMarshalAppendAllocations(t *testing.T) {
+	m := &test3pb.TestAllTypes{SingularInt32: 1}
+	size := proto.Size(m)
+	const count = 1000
+	b := make([]byte, size)
+	// AllocsPerRun returns an integral value.
+	marshalAllocs := testing.AllocsPerRun(count, func() {
+		_, err := proto.MarshalOptions{}.MarshalAppend(b[:0], m)
+		if err != nil {
+			t.Fatal(err)
+		}
+	})
+	b = nil
+	marshalAppendAllocs := testing.AllocsPerRun(count, func() {
+		var err error
+		b, err = proto.MarshalOptions{}.MarshalAppend(b, m)
+		if err != nil {
+			t.Fatal(err)
+		}
+	})
+	if marshalAllocs != marshalAppendAllocs {
+		t.Errorf("%v allocs/op when writing to a preallocated buffer", marshalAllocs)
+		t.Errorf("%v allocs/op when repeatedly appending to a slice", marshalAppendAllocs)
+		t.Errorf("expect amortized allocs/op to be identical")
+	}
+}
+
+func TestEncodeOrder(t *testing.T) {
+	// We make no guarantees about the stability of wire marshal output.
+	// The order in which fields are marshaled may change over time.
+	// If deterministic marshaling is not enabled, it may change over
+	// successive calls to proto.Marshal in the same binary.
+	//
+	// Unfortunately, many users have come to rely on the specific current
+	// wire marshal output. Perhaps someday we will choose to deliberately
+	// change the marshal output; until that day comes, this test verifies
+	// that we don't unintentionally change it.
+	m := &orderpb.Message{
+		Field_1:  proto.String("one"),
+		Field_2:  proto.String("two"),
+		Field_20: proto.String("twenty"),
+		Oneof_1:  &orderpb.Message_Field_10{"ten"},
+	}
+	proto.SetExtension(m, orderpb.E_Field_30, "thirty")
+	proto.SetExtension(m, orderpb.E_Field_31, "thirty-one")
+	proto.SetExtension(m, orderpb.E_Field_32, "thirty-two")
+	want := []pref.FieldNumber{
+		30, 31, 32, // extensions first, in number order
+		1, 2, 20, // non-extension, non-oneof in number order
+		10, // oneofs last, undefined order
+	}
+
+	// Test with deterministic serialization, since fields are not sorted without
+	// it when -tags=protoreflect.
+	b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var got []pref.FieldNumber
+	for len(b) > 0 {
+		num, _, n := protowire.ConsumeField(b)
+		if n < 0 {
+			t.Fatal(protowire.ParseError(n))
+		}
+		b = b[n:]
+		got = append(got, num)
+	}
+	if !reflect.DeepEqual(got, want) {
+		t.Errorf("unexpected field marshal order:\ngot:  %v\nwant: %v\nmessage:\n%v", got, want, m)
+	}
+}
+
+func TestEncodeLarge(t *testing.T) {
+	// Encode/decode a message large enough to overflow a 32-bit size cache.
+	t.Skip("too slow and memory-hungry to run all the time")
+	size := math.MaxUint32 + 1
+	m := &testpb.TestAllTypes_NestedMessage{
+		Corecursive: &testpb.TestAllTypes{
+			OptionalBytes: make([]byte, size),
+		},
+	}
+	b, err := proto.Marshal(m)
+	if err != nil {
+		t.Fatalf("Marshal: %v", err)
+	}
+	if got, want := len(b), proto.Size(m); got != want {
+		t.Fatalf("Size(m) = %v, but len(Marshal(m)) = %v", got, want)
+	}
+	if err := proto.Unmarshal(b, m); err != nil {
+		t.Fatalf("Unmarshal: %v", err)
+	}
+	if got, want := len(m.Corecursive.OptionalBytes), size; got != want {
+		t.Errorf("after round-trip marshal, got len(m.OptionalBytes) = %v, want %v", got, want)
+	}
+}
+
+// TestEncodeEmpty tests for boundary conditions when producing an empty output.
+// These tests are not necessarily a statement of proper behavior,
+// but exist to detect accidental changes in behavior.
+func TestEncodeEmpty(t *testing.T) {
+	for _, m := range []proto.Message{nil, (*testpb.TestAllTypes)(nil), &testpb.TestAllTypes{}} {
+		isValid := m != nil && m.ProtoReflect().IsValid()
+
+		b, err := proto.Marshal(m)
+		if err != nil {
+			t.Errorf("proto.Marshal() = %v", err)
+		}
+		if isNil := b == nil; isNil == isValid {
+			t.Errorf("proto.Marshal() == nil: %v, want %v", isNil, !isValid)
+		}
+
+		b, err = proto.MarshalOptions{}.Marshal(m)
+		if err != nil {
+			t.Errorf("proto.MarshalOptions{}.Marshal() = %v", err)
+		}
+		if isNil := b == nil; isNil == isValid {
+			t.Errorf("proto.MarshalOptions{}.Marshal() = %v, want %v", isNil, !isValid)
+		}
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/proto/equal.go b/vendor/google.golang.org/protobuf/proto/equal.go
new file mode 100644
index 000000000..10902bd85
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/proto/equal.go
@@ -0,0 +1,154 @@
+// Copyright 2019 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 proto
+
+import (
+	"bytes"
+	"math"
+	"reflect"
+
+	"google.golang.org/protobuf/encoding/protowire"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+)
+
+// Equal reports whether two messages are equal.
+// If two messages marshal to the same bytes under deterministic serialization,
+// then Equal is guaranteed to report true.
+//
+// Two messages are equal if they belong to the same message descriptor,
+// have the same set of populated known and extension field values,
+// and the same set of unknown fields values. If either of the top-level
+// messages are invalid, then Equal reports true only if both are invalid.
+//
+// Scalar values are compared with the equivalent of the == operator in Go,
+// except bytes values which are compared using bytes.Equal and
+// floating point values which specially treat NaNs as equal.
+// Message values are compared by recursively calling Equal.
+// Lists are equal if each element value is also equal.
+// Maps are equal if they have the same set of keys, where the pair of values
+// for each key is also equal.
+func Equal(x, y Message) bool {
+	if x == nil || y == nil {
+		return x == nil && y == nil
+	}
+	mx := x.ProtoReflect()
+	my := y.ProtoReflect()
+	if mx.IsValid() != my.IsValid() {
+		return false
+	}
+	return equalMessage(mx, my)
+}
+
+// equalMessage compares two messages.
+func equalMessage(mx, my pref.Message) bool {
+	if mx.Descriptor() != my.Descriptor() {
+		return false
+	}
+
+	nx := 0
+	equal := true
+	mx.Range(func(fd pref.FieldDescriptor, vx pref.Value) bool {
+		nx++
+		vy := my.Get(fd)
+		equal = my.Has(fd) && equalField(fd, vx, vy)
+		return equal
+	})
+	if !equal {
+		return false
+	}
+	ny := 0
+	my.Range(func(fd pref.FieldDescriptor, vx pref.Value) bool {
+		ny++
+		return true
+	})
+	if nx != ny {
+		return false
+	}
+
+	return equalUnknown(mx.GetUnknown(), my.GetUnknown())
+}
+
+// equalField compares two fields.
+func equalField(fd pref.FieldDescriptor, x, y pref.Value) bool {
+	switch {
+	case fd.IsList():
+		return equalList(fd, x.List(), y.List())
+	case fd.IsMap():
+		return equalMap(fd, x.Map(), y.Map())
+	default:
+		return equalValue(fd, x, y)
+	}
+}
+
+// equalMap compares two maps.
+func equalMap(fd pref.FieldDescriptor, x, y pref.Map) bool {
+	if x.Len() != y.Len() {
+		return false
+	}
+	equal := true
+	x.Range(func(k pref.MapKey, vx pref.Value) bool {
+		vy := y.Get(k)
+		equal = y.Has(k) && equalValue(fd.MapValue(), vx, vy)
+		return equal
+	})
+	return equal
+}
+
+// equalList compares two lists.
+func equalList(fd pref.FieldDescriptor, x, y pref.List) bool {
+	if x.Len() != y.Len() {
+		return false
+	}
+	for i := x.Len() - 1; i >= 0; i-- {
+		if !equalValue(fd, x.Get(i), y.Get(i)) {
+			return false
+		}
+	}
+	return true
+}
+
+// equalValue compares two singular values.
+func equalValue(fd pref.FieldDescriptor, x, y pref.Value) bool {
+	switch {
+	case fd.Message() != nil:
+		return equalMessage(x.Message(), y.Message())
+	case fd.Kind() == pref.BytesKind:
+		return bytes.Equal(x.Bytes(), y.Bytes())
+	case fd.Kind() == pref.FloatKind, fd.Kind() == pref.DoubleKind:
+		fx := x.Float()
+		fy := y.Float()
+		if math.IsNaN(fx) || math.IsNaN(fy) {
+			return math.IsNaN(fx) && math.IsNaN(fy)
+		}
+		return fx == fy
+	default:
+		return x.Interface() == y.Interface()
+	}
+}
+
+// equalUnknown compares unknown fields by direct comparison on the raw bytes
+// of each individual field number.
+func equalUnknown(x, y pref.RawFields) bool {
+	if len(x) != len(y) {
+		return false
+	}
+	if bytes.Equal([]byte(x), []byte(y)) {
+		return true
+	}
+
+	mx := make(map[pref.FieldNumber]pref.RawFields)
+	my := make(map[pref.FieldNumber]pref.RawFields)
+	for len(x) > 0 {
+		fnum, _, n := protowire.ConsumeField(x)
+		mx[fnum] = append(mx[fnum], x[:n]...)
+		x = x[n:]
+	}
+	for len(y) > 0 {
+		fnum, _, n := protowire.ConsumeField(y)
+		my[fnum] = append(my[fnum], y[:n]...)
+		y = y[n:]
+	}
+	return reflect.DeepEqual(mx, my)
+}
diff --git a/vendor/google.golang.org/protobuf/proto/equal_test.go b/vendor/google.golang.org/protobuf/proto/equal_test.go
new file mode 100644
index 000000000..8d8539744
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/proto/equal_test.go
@@ -0,0 +1,495 @@
+// Copyright 2019 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 proto_test
+
+import (
+	"math"
+	"testing"
+
+	"google.golang.org/protobuf/encoding/prototext"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/testing/protopack"
+
+	testpb "google.golang.org/protobuf/internal/testprotos/test"
+	test3pb "google.golang.org/protobuf/internal/testprotos/test3"
+)
+
+func TestEqual(t *testing.T) {
+	tests := []struct {
+		x, y proto.Message
+		eq   bool
+	}{
+		{
+			x:  nil,
+			y:  nil,
+			eq: true,
+		}, {
+			x:  (*testpb.TestAllTypes)(nil),
+			y:  nil,
+			eq: false,
+		}, {
+			x:  (*testpb.TestAllTypes)(nil),
+			y:  (*testpb.TestAllTypes)(nil),
+			eq: true,
+		}, {
+			x:  new(testpb.TestAllTypes),
+			y:  (*testpb.TestAllTypes)(nil),
+			eq: false,
+		}, {
+			x:  new(testpb.TestAllTypes),
+			y:  new(testpb.TestAllTypes),
+			eq: true,
+		},
+		{
+			x:  (*testpb.TestAllTypes)(nil),
+			y:  (*testpb.TestAllExtensions)(nil),
+			eq: false,
+		},
+		{
+			x:  (*testpb.TestAllTypes)(nil),
+			y:  new(testpb.TestAllExtensions),
+			eq: false,
+		},
+		{
+			x:  new(testpb.TestAllTypes),
+			y:  new(testpb.TestAllExtensions),
+			eq: false,
+		},
+
+		// Proto2 scalars.
+		{
+			x: &testpb.TestAllTypes{OptionalInt32: proto.Int32(1)},
+			y: &testpb.TestAllTypes{OptionalInt32: proto.Int32(2)},
+		}, {
+			x: &testpb.TestAllTypes{OptionalInt64: proto.Int64(1)},
+			y: &testpb.TestAllTypes{OptionalInt64: proto.Int64(2)},
+		}, {
+			x: &testpb.TestAllTypes{OptionalUint32: proto.Uint32(1)},
+			y: &testpb.TestAllTypes{OptionalUint32: proto.Uint32(2)},
+		}, {
+			x: &testpb.TestAllTypes{OptionalUint64: proto.Uint64(1)},
+			y: &testpb.TestAllTypes{OptionalUint64: proto.Uint64(2)},
+		}, {
+			x: &testpb.TestAllTypes{OptionalSint32: proto.Int32(1)},
+			y: &testpb.TestAllTypes{OptionalSint32: proto.Int32(2)},
+		}, {
+			x: &testpb.TestAllTypes{OptionalSint64: proto.Int64(1)},
+			y: &testpb.TestAllTypes{OptionalSint64: proto.Int64(2)},
+		}, {
+			x: &testpb.TestAllTypes{OptionalFixed32: proto.Uint32(1)},
+			y: &testpb.TestAllTypes{OptionalFixed32: proto.Uint32(2)},
+		}, {
+			x: &testpb.TestAllTypes{OptionalFixed64: proto.Uint64(1)},
+			y: &testpb.TestAllTypes{OptionalFixed64: proto.Uint64(2)},
+		}, {
+			x: &testpb.TestAllTypes{OptionalSfixed32: proto.Int32(1)},
+			y: &testpb.TestAllTypes{OptionalSfixed32: proto.Int32(2)},
+		}, {
+			x: &testpb.TestAllTypes{OptionalSfixed64: proto.Int64(1)},
+			y: &testpb.TestAllTypes{OptionalSfixed64: proto.Int64(2)},
+		}, {
+			x: &testpb.TestAllTypes{OptionalFloat: proto.Float32(1)},
+			y: &testpb.TestAllTypes{OptionalFloat: proto.Float32(2)},
+		}, {
+			x: &testpb.TestAllTypes{OptionalDouble: proto.Float64(1)},
+			y: &testpb.TestAllTypes{OptionalDouble: proto.Float64(2)},
+		}, {
+			x: &testpb.TestAllTypes{OptionalFloat: proto.Float32(float32(math.NaN()))},
+			y: &testpb.TestAllTypes{OptionalFloat: proto.Float32(0)},
+		}, {
+			x: &testpb.TestAllTypes{OptionalDouble: proto.Float64(float64(math.NaN()))},
+			y: &testpb.TestAllTypes{OptionalDouble: proto.Float64(0)},
+		}, {
+			x: &testpb.TestAllTypes{OptionalBool: proto.Bool(true)},
+			y: &testpb.TestAllTypes{OptionalBool: proto.Bool(false)},
+		}, {
+			x: &testpb.TestAllTypes{OptionalString: proto.String("a")},
+			y: &testpb.TestAllTypes{OptionalString: proto.String("b")},
+		}, {
+			x: &testpb.TestAllTypes{OptionalBytes: []byte("a")},
+			y: &testpb.TestAllTypes{OptionalBytes: []byte("b")},
+		}, {
+			x: &testpb.TestAllTypes{OptionalNestedEnum: testpb.TestAllTypes_FOO.Enum()},
+			y: &testpb.TestAllTypes{OptionalNestedEnum: testpb.TestAllTypes_BAR.Enum()},
+		},
+
+		// Proto2 presence.
+		{
+			x: &testpb.TestAllTypes{},
+			y: &testpb.TestAllTypes{OptionalInt32: proto.Int32(0)},
+		}, {
+			x: &testpb.TestAllTypes{},
+			y: &testpb.TestAllTypes{OptionalInt64: proto.Int64(0)},
+		}, {
+			x: &testpb.TestAllTypes{},
+			y: &testpb.TestAllTypes{OptionalUint32: proto.Uint32(0)},
+		}, {
+			x: &testpb.TestAllTypes{},
+			y: &testpb.TestAllTypes{OptionalUint64: proto.Uint64(0)},
+		}, {
+			x: &testpb.TestAllTypes{},
+			y: &testpb.TestAllTypes{OptionalSint32: proto.Int32(0)},
+		}, {
+			x: &testpb.TestAllTypes{},
+			y: &testpb.TestAllTypes{OptionalSint64: proto.Int64(0)},
+		}, {
+			x: &testpb.TestAllTypes{},
+			y: &testpb.TestAllTypes{OptionalFixed32: proto.Uint32(0)},
+		}, {
+			x: &testpb.TestAllTypes{},
+			y: &testpb.TestAllTypes{OptionalFixed64: proto.Uint64(0)},
+		}, {
+			x: &testpb.TestAllTypes{},
+			y: &testpb.TestAllTypes{OptionalSfixed32: proto.Int32(0)},
+		}, {
+			x: &testpb.TestAllTypes{},
+			y: &testpb.TestAllTypes{OptionalSfixed64: proto.Int64(0)},
+		}, {
+			x: &testpb.TestAllTypes{},
+			y: &testpb.TestAllTypes{OptionalFloat: proto.Float32(0)},
+		}, {
+			x: &testpb.TestAllTypes{},
+			y: &testpb.TestAllTypes{OptionalDouble: proto.Float64(0)},
+		}, {
+			x: &testpb.TestAllTypes{},
+			y: &testpb.TestAllTypes{OptionalBool: proto.Bool(false)},
+		}, {
+			x: &testpb.TestAllTypes{},
+			y: &testpb.TestAllTypes{OptionalString: proto.String("")},
+		}, {
+			x: &testpb.TestAllTypes{},
+			y: &testpb.TestAllTypes{OptionalBytes: []byte{}},
+		}, {
+			x: &testpb.TestAllTypes{},
+			y: &testpb.TestAllTypes{OptionalNestedEnum: testpb.TestAllTypes_FOO.Enum()},
+		},
+
+		// Proto3 presence.
+		{
+			x: &test3pb.TestAllTypes{},
+			y: &test3pb.TestAllTypes{OptionalInt32: proto.Int32(0)},
+		}, {
+			x: &test3pb.TestAllTypes{},
+			y: &test3pb.TestAllTypes{OptionalInt64: proto.Int64(0)},
+		}, {
+			x: &test3pb.TestAllTypes{},
+			y: &test3pb.TestAllTypes{OptionalUint32: proto.Uint32(0)},
+		}, {
+			x: &test3pb.TestAllTypes{},
+			y: &test3pb.TestAllTypes{OptionalUint64: proto.Uint64(0)},
+		}, {
+			x: &test3pb.TestAllTypes{},
+			y: &test3pb.TestAllTypes{OptionalSint32: proto.Int32(0)},
+		}, {
+			x: &test3pb.TestAllTypes{},
+			y: &test3pb.TestAllTypes{OptionalSint64: proto.Int64(0)},
+		}, {
+			x: &test3pb.TestAllTypes{},
+			y: &test3pb.TestAllTypes{OptionalFixed32: proto.Uint32(0)},
+		}, {
+			x: &test3pb.TestAllTypes{},
+			y: &test3pb.TestAllTypes{OptionalFixed64: proto.Uint64(0)},
+		}, {
+			x: &test3pb.TestAllTypes{},
+			y: &test3pb.TestAllTypes{OptionalSfixed32: proto.Int32(0)},
+		}, {
+			x: &test3pb.TestAllTypes{},
+			y: &test3pb.TestAllTypes{OptionalSfixed64: proto.Int64(0)},
+		}, {
+			x: &test3pb.TestAllTypes{},
+			y: &test3pb.TestAllTypes{OptionalFloat: proto.Float32(0)},
+		}, {
+			x: &test3pb.TestAllTypes{},
+			y: &test3pb.TestAllTypes{OptionalDouble: proto.Float64(0)},
+		}, {
+			x: &test3pb.TestAllTypes{},
+			y: &test3pb.TestAllTypes{OptionalBool: proto.Bool(false)},
+		}, {
+			x: &test3pb.TestAllTypes{},
+			y: &test3pb.TestAllTypes{OptionalString: proto.String("")},
+		}, {
+			x: &test3pb.TestAllTypes{},
+			y: &test3pb.TestAllTypes{OptionalBytes: []byte{}},
+		}, {
+			x: &test3pb.TestAllTypes{},
+			y: &test3pb.TestAllTypes{OptionalNestedEnum: test3pb.TestAllTypes_FOO.Enum()},
+		},
+
+		// Proto2 default values are not considered by Equal, so the following are still unequal.
+		{
+			x: &testpb.TestAllTypes{DefaultInt32: proto.Int32(81)},
+			y: &testpb.TestAllTypes{},
+		}, {
+			x: &testpb.TestAllTypes{},
+			y: &testpb.TestAllTypes{DefaultInt32: proto.Int32(81)},
+		}, {
+			x: &testpb.TestAllTypes{},
+			y: &testpb.TestAllTypes{DefaultInt64: proto.Int64(82)},
+		}, {
+			x: &testpb.TestAllTypes{},
+			y: &testpb.TestAllTypes{DefaultUint32: proto.Uint32(83)},
+		}, {
+			x: &testpb.TestAllTypes{},
+			y: &testpb.TestAllTypes{DefaultUint64: proto.Uint64(84)},
+		}, {
+			x: &testpb.TestAllTypes{},
+			y: &testpb.TestAllTypes{DefaultSint32: proto.Int32(-85)},
+		}, {
+			x: &testpb.TestAllTypes{},
+			y: &testpb.TestAllTypes{DefaultSint64: proto.Int64(86)},
+		}, {
+			x: &testpb.TestAllTypes{},
+			y: &testpb.TestAllTypes{DefaultFixed32: proto.Uint32(87)},
+		}, {
+			x: &testpb.TestAllTypes{},
+			y: &testpb.TestAllTypes{DefaultFixed64: proto.Uint64(88)},
+		}, {
+			x: &testpb.TestAllTypes{},
+			y: &testpb.TestAllTypes{DefaultSfixed32: proto.Int32(89)},
+		}, {
+			x: &testpb.TestAllTypes{},
+			y: &testpb.TestAllTypes{DefaultSfixed64: proto.Int64(-90)},
+		}, {
+			x: &testpb.TestAllTypes{},
+			y: &testpb.TestAllTypes{DefaultFloat: proto.Float32(91.5)},
+		}, {
+			x: &testpb.TestAllTypes{},
+			y: &testpb.TestAllTypes{DefaultDouble: proto.Float64(92e3)},
+		}, {
+			x: &testpb.TestAllTypes{},
+			y: &testpb.TestAllTypes{DefaultBool: proto.Bool(true)},
+		}, {
+			x: &testpb.TestAllTypes{},
+			y: &testpb.TestAllTypes{DefaultString: proto.String("hello")},
+		}, {
+			x: &testpb.TestAllTypes{},
+			y: &testpb.TestAllTypes{DefaultBytes: []byte("world")},
+		}, {
+			x: &testpb.TestAllTypes{},
+			y: &testpb.TestAllTypes{DefaultNestedEnum: testpb.TestAllTypes_BAR.Enum()},
+		},
+
+		// Groups.
+		{
+			x: &testpb.TestAllTypes{Optionalgroup: &testpb.TestAllTypes_OptionalGroup{
+				A: proto.Int32(1),
+			}},
+			y: &testpb.TestAllTypes{Optionalgroup: &testpb.TestAllTypes_OptionalGroup{
+				A: proto.Int32(2),
+			}},
+		}, {
+			x: &testpb.TestAllTypes{},
+			y: &testpb.TestAllTypes{Optionalgroup: &testpb.TestAllTypes_OptionalGroup{}},
+		},
+
+		// Messages.
+		{
+			x: &testpb.TestAllTypes{OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{
+				A: proto.Int32(1),
+			}},
+			y: &testpb.TestAllTypes{OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{
+				A: proto.Int32(2),
+			}},
+		}, {
+			x: &testpb.TestAllTypes{},
+			y: &testpb.TestAllTypes{OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{}},
+		}, {
+			x: &test3pb.TestAllTypes{},
+			y: &test3pb.TestAllTypes{OptionalNestedMessage: &test3pb.TestAllTypes_NestedMessage{}},
+		},
+
+		// Lists.
+		{
+			x: &testpb.TestAllTypes{RepeatedInt32: []int32{1}},
+			y: &testpb.TestAllTypes{RepeatedInt32: []int32{1, 2}},
+		}, {
+			x: &testpb.TestAllTypes{RepeatedInt32: []int32{1, 2}},
+			y: &testpb.TestAllTypes{RepeatedInt32: []int32{1, 3}},
+		}, {
+			x: &testpb.TestAllTypes{RepeatedInt64: []int64{1, 2}},
+			y: &testpb.TestAllTypes{RepeatedInt64: []int64{1, 3}},
+		}, {
+			x: &testpb.TestAllTypes{RepeatedUint32: []uint32{1, 2}},
+			y: &testpb.TestAllTypes{RepeatedUint32: []uint32{1, 3}},
+		}, {
+			x: &testpb.TestAllTypes{RepeatedUint64: []uint64{1, 2}},
+			y: &testpb.TestAllTypes{RepeatedUint64: []uint64{1, 3}},
+		}, {
+			x: &testpb.TestAllTypes{RepeatedSint32: []int32{1, 2}},
+			y: &testpb.TestAllTypes{RepeatedSint32: []int32{1, 3}},
+		}, {
+			x: &testpb.TestAllTypes{RepeatedSint64: []int64{1, 2}},
+			y: &testpb.TestAllTypes{RepeatedSint64: []int64{1, 3}},
+		}, {
+			x: &testpb.TestAllTypes{RepeatedFixed32: []uint32{1, 2}},
+			y: &testpb.TestAllTypes{RepeatedFixed32: []uint32{1, 3}},
+		}, {
+			x: &testpb.TestAllTypes{RepeatedFixed64: []uint64{1, 2}},
+			y: &testpb.TestAllTypes{RepeatedFixed64: []uint64{1, 3}},
+		}, {
+			x: &testpb.TestAllTypes{RepeatedSfixed32: []int32{1, 2}},
+			y: &testpb.TestAllTypes{RepeatedSfixed32: []int32{1, 3}},
+		}, {
+			x: &testpb.TestAllTypes{RepeatedSfixed64: []int64{1, 2}},
+			y: &testpb.TestAllTypes{RepeatedSfixed64: []int64{1, 3}},
+		}, {
+			x: &testpb.TestAllTypes{RepeatedFloat: []float32{1, 2}},
+			y: &testpb.TestAllTypes{RepeatedFloat: []float32{1, 3}},
+		}, {
+			x: &testpb.TestAllTypes{RepeatedDouble: []float64{1, 2}},
+			y: &testpb.TestAllTypes{RepeatedDouble: []float64{1, 3}},
+		}, {
+			x: &testpb.TestAllTypes{RepeatedBool: []bool{true, false}},
+			y: &testpb.TestAllTypes{RepeatedBool: []bool{true, true}},
+		}, {
+			x: &testpb.TestAllTypes{RepeatedString: []string{"a", "b"}},
+			y: &testpb.TestAllTypes{RepeatedString: []string{"a", "c"}},
+		}, {
+			x: &testpb.TestAllTypes{RepeatedBytes: [][]byte{[]byte("a"), []byte("b")}},
+			y: &testpb.TestAllTypes{RepeatedBytes: [][]byte{[]byte("a"), []byte("c")}},
+		}, {
+			x: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_FOO}},
+			y: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAR}},
+		}, {
+			x: &testpb.TestAllTypes{Repeatedgroup: []*testpb.TestAllTypes_RepeatedGroup{
+				{A: proto.Int32(1)},
+				{A: proto.Int32(2)},
+			}},
+			y: &testpb.TestAllTypes{Repeatedgroup: []*testpb.TestAllTypes_RepeatedGroup{
+				{A: proto.Int32(1)},
+				{A: proto.Int32(3)},
+			}},
+		}, {
+			x: &testpb.TestAllTypes{RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{
+				{A: proto.Int32(1)},
+				{A: proto.Int32(2)},
+			}},
+			y: &testpb.TestAllTypes{RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{
+				{A: proto.Int32(1)},
+				{A: proto.Int32(3)},
+			}},
+		},
+
+		// Maps: various configurations.
+		{
+			x: &testpb.TestAllTypes{MapInt32Int32: map[int32]int32{1: 2}},
+			y: &testpb.TestAllTypes{MapInt32Int32: map[int32]int32{3: 4}},
+		}, {
+			x: &testpb.TestAllTypes{MapInt32Int32: map[int32]int32{1: 2}},
+			y: &testpb.TestAllTypes{MapInt32Int32: map[int32]int32{1: 2, 3: 4}},
+		}, {
+			x: &testpb.TestAllTypes{MapInt32Int32: map[int32]int32{1: 2, 3: 4}},
+			y: &testpb.TestAllTypes{MapInt32Int32: map[int32]int32{1: 2}},
+		},
+
+		// Maps: various types.
+		{
+			x: &testpb.TestAllTypes{MapInt32Int32: map[int32]int32{1: 2, 3: 4}},
+			y: &testpb.TestAllTypes{MapInt32Int32: map[int32]int32{1: 2, 3: 5}},
+		}, {
+			x: &testpb.TestAllTypes{MapInt64Int64: map[int64]int64{1: 2, 3: 4}},
+			y: &testpb.TestAllTypes{MapInt64Int64: map[int64]int64{1: 2, 3: 5}},
+		}, {
+			x: &testpb.TestAllTypes{MapUint32Uint32: map[uint32]uint32{1: 2, 3: 4}},
+			y: &testpb.TestAllTypes{MapUint32Uint32: map[uint32]uint32{1: 2, 3: 5}},
+		}, {
+			x: &testpb.TestAllTypes{MapUint64Uint64: map[uint64]uint64{1: 2, 3: 4}},
+			y: &testpb.TestAllTypes{MapUint64Uint64: map[uint64]uint64{1: 2, 3: 5}},
+		}, {
+			x: &testpb.TestAllTypes{MapSint32Sint32: map[int32]int32{1: 2, 3: 4}},
+			y: &testpb.TestAllTypes{MapSint32Sint32: map[int32]int32{1: 2, 3: 5}},
+		}, {
+			x: &testpb.TestAllTypes{MapSint64Sint64: map[int64]int64{1: 2, 3: 4}},
+			y: &testpb.TestAllTypes{MapSint64Sint64: map[int64]int64{1: 2, 3: 5}},
+		}, {
+			x: &testpb.TestAllTypes{MapFixed32Fixed32: map[uint32]uint32{1: 2, 3: 4}},
+			y: &testpb.TestAllTypes{MapFixed32Fixed32: map[uint32]uint32{1: 2, 3: 5}},
+		}, {
+			x: &testpb.TestAllTypes{MapFixed64Fixed64: map[uint64]uint64{1: 2, 3: 4}},
+			y: &testpb.TestAllTypes{MapFixed64Fixed64: map[uint64]uint64{1: 2, 3: 5}},
+		}, {
+			x: &testpb.TestAllTypes{MapSfixed32Sfixed32: map[int32]int32{1: 2, 3: 4}},
+			y: &testpb.TestAllTypes{MapSfixed32Sfixed32: map[int32]int32{1: 2, 3: 5}},
+		}, {
+			x: &testpb.TestAllTypes{MapSfixed64Sfixed64: map[int64]int64{1: 2, 3: 4}},
+			y: &testpb.TestAllTypes{MapSfixed64Sfixed64: map[int64]int64{1: 2, 3: 5}},
+		}, {
+			x: &testpb.TestAllTypes{MapInt32Float: map[int32]float32{1: 2, 3: 4}},
+			y: &testpb.TestAllTypes{MapInt32Float: map[int32]float32{1: 2, 3: 5}},
+		}, {
+			x: &testpb.TestAllTypes{MapInt32Double: map[int32]float64{1: 2, 3: 4}},
+			y: &testpb.TestAllTypes{MapInt32Double: map[int32]float64{1: 2, 3: 5}},
+		}, {
+			x: &testpb.TestAllTypes{MapBoolBool: map[bool]bool{true: false, false: true}},
+			y: &testpb.TestAllTypes{MapBoolBool: map[bool]bool{true: false, false: false}},
+		}, {
+			x: &testpb.TestAllTypes{MapStringString: map[string]string{"a": "b", "c": "d"}},
+			y: &testpb.TestAllTypes{MapStringString: map[string]string{"a": "b", "c": "e"}},
+		}, {
+			x: &testpb.TestAllTypes{MapStringBytes: map[string][]byte{"a": []byte("b"), "c": []byte("d")}},
+			y: &testpb.TestAllTypes{MapStringBytes: map[string][]byte{"a": []byte("b"), "c": []byte("e")}},
+		}, {
+			x: &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{
+				"a": {A: proto.Int32(1)},
+				"b": {A: proto.Int32(2)},
+			}},
+			y: &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{
+				"a": {A: proto.Int32(1)},
+				"b": {A: proto.Int32(3)},
+			}},
+		}, {
+			x: &testpb.TestAllTypes{MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{
+				"a": testpb.TestAllTypes_FOO,
+				"b": testpb.TestAllTypes_BAR,
+			}},
+			y: &testpb.TestAllTypes{MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{
+				"a": testpb.TestAllTypes_FOO,
+				"b": testpb.TestAllTypes_BAZ,
+			}},
+		},
+
+		// Extensions.
+		{
+			x: build(&testpb.TestAllExtensions{},
+				extend(testpb.E_OptionalInt32, int32(1)),
+			),
+			y: build(&testpb.TestAllExtensions{},
+				extend(testpb.E_OptionalInt32, int32(2)),
+			),
+		}, {
+			x: &testpb.TestAllExtensions{},
+			y: build(&testpb.TestAllExtensions{},
+				extend(testpb.E_OptionalInt32, int32(2)),
+			),
+		},
+
+		// Unknown fields.
+		{
+			x: build(&testpb.TestAllTypes{}, unknown(protopack.Message{
+				protopack.Tag{100000, protopack.VarintType}, protopack.Varint(1),
+			}.Marshal())),
+			y: build(&testpb.TestAllTypes{}, unknown(protopack.Message{
+				protopack.Tag{100000, protopack.VarintType}, protopack.Varint(2),
+			}.Marshal())),
+		}, {
+			x: build(&testpb.TestAllTypes{}, unknown(protopack.Message{
+				protopack.Tag{100000, protopack.VarintType}, protopack.Varint(1),
+			}.Marshal())),
+			y: &testpb.TestAllTypes{},
+		},
+	}
+
+	for _, tt := range tests {
+		if !tt.eq && !proto.Equal(tt.x, tt.x) {
+			t.Errorf("Equal(x, x) = false, want true\n==== x ====\n%v", prototext.Format(tt.x))
+		}
+		if !tt.eq && !proto.Equal(tt.y, tt.y) {
+			t.Errorf("Equal(y, y) = false, want true\n==== y ====\n%v", prototext.Format(tt.y))
+		}
+		if eq := proto.Equal(tt.x, tt.y); eq != tt.eq {
+			t.Errorf("Equal(x, y) = %v, want %v\n==== x ====\n%v==== y ====\n%v", eq, tt.eq, prototext.Format(tt.x), prototext.Format(tt.y))
+		}
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/proto/extension.go b/vendor/google.golang.org/protobuf/proto/extension.go
new file mode 100644
index 000000000..5f293cda8
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/proto/extension.go
@@ -0,0 +1,92 @@
+// Copyright 2019 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 proto
+
+import (
+	"google.golang.org/protobuf/reflect/protoreflect"
+)
+
+// HasExtension reports whether an extension field is populated.
+// It returns false if m is invalid or if xt does not extend m.
+func HasExtension(m Message, xt protoreflect.ExtensionType) bool {
+	// Treat nil message interface as an empty message; no populated fields.
+	if m == nil {
+		return false
+	}
+
+	// As a special-case, we reports invalid or mismatching descriptors
+	// as always not being populated (since they aren't).
+	if xt == nil || m.ProtoReflect().Descriptor() != xt.TypeDescriptor().ContainingMessage() {
+		return false
+	}
+
+	return m.ProtoReflect().Has(xt.TypeDescriptor())
+}
+
+// ClearExtension clears an extension field such that subsequent
+// HasExtension calls return false.
+// It panics if m is invalid or if xt does not extend m.
+func ClearExtension(m Message, xt protoreflect.ExtensionType) {
+	m.ProtoReflect().Clear(xt.TypeDescriptor())
+}
+
+// GetExtension retrieves the value for an extension field.
+// If the field is unpopulated, it returns the default value for
+// scalars and an immutable, empty value for lists or messages.
+// It panics if xt does not extend m.
+func GetExtension(m Message, xt protoreflect.ExtensionType) interface{} {
+	// Treat nil message interface as an empty message; return the default.
+	if m == nil {
+		return xt.InterfaceOf(xt.Zero())
+	}
+
+	return xt.InterfaceOf(m.ProtoReflect().Get(xt.TypeDescriptor()))
+}
+
+// SetExtension stores the value of an extension field.
+// It panics if m is invalid, xt does not extend m, or if type of v
+// is invalid for the specified extension field.
+func SetExtension(m Message, xt protoreflect.ExtensionType, v interface{}) {
+	xd := xt.TypeDescriptor()
+	pv := xt.ValueOf(v)
+
+	// Specially treat an invalid list, map, or message as clear.
+	isValid := true
+	switch {
+	case xd.IsList():
+		isValid = pv.List().IsValid()
+	case xd.IsMap():
+		isValid = pv.Map().IsValid()
+	case xd.Message() != nil:
+		isValid = pv.Message().IsValid()
+	}
+	if !isValid {
+		m.ProtoReflect().Clear(xd)
+		return
+	}
+
+	m.ProtoReflect().Set(xd, pv)
+}
+
+// RangeExtensions iterates over every populated extension field in m in an
+// undefined order, calling f for each extension type and value encountered.
+// It returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current extension field.
+func RangeExtensions(m Message, f func(protoreflect.ExtensionType, interface{}) bool) {
+	// Treat nil message interface as an empty message; nothing to range over.
+	if m == nil {
+		return
+	}
+
+	m.ProtoReflect().Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
+		if fd.IsExtension() {
+			xt := fd.(protoreflect.ExtensionTypeDescriptor).Type()
+			vi := xt.InterfaceOf(v)
+			return f(xt, vi)
+		}
+		return true
+	})
+}
diff --git a/vendor/google.golang.org/protobuf/proto/extension_test.go b/vendor/google.golang.org/protobuf/proto/extension_test.go
new file mode 100644
index 000000000..b3ab78828
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/proto/extension_test.go
@@ -0,0 +1,290 @@
+// Copyright 2019 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 proto_test
+
+import (
+	"fmt"
+	"reflect"
+	"sync"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/runtime/protoimpl"
+	"google.golang.org/protobuf/testing/protocmp"
+
+	legacy1pb "google.golang.org/protobuf/internal/testprotos/legacy/proto2_20160225_2fc053c5"
+	testpb "google.golang.org/protobuf/internal/testprotos/test"
+	test3pb "google.golang.org/protobuf/internal/testprotos/test3"
+	descpb "google.golang.org/protobuf/types/descriptorpb"
+)
+
+func TestExtensionFuncs(t *testing.T) {
+	for _, test := range []struct {
+		message     proto.Message
+		ext         pref.ExtensionType
+		wantDefault interface{}
+		value       interface{}
+	}{
+		{
+			message:     &testpb.TestAllExtensions{},
+			ext:         testpb.E_OptionalInt32,
+			wantDefault: int32(0),
+			value:       int32(1),
+		},
+		{
+			message:     &testpb.TestAllExtensions{},
+			ext:         testpb.E_RepeatedString,
+			wantDefault: ([]string)(nil),
+			value:       []string{"a", "b", "c"},
+		},
+		{
+			message:     protoimpl.X.MessageOf(&legacy1pb.Message{}).Interface(),
+			ext:         legacy1pb.E_Message_ExtensionOptionalBool,
+			wantDefault: false,
+			value:       true,
+		},
+	} {
+		desc := fmt.Sprintf("Extension %v, value %v", test.ext.TypeDescriptor().FullName(), test.value)
+		if proto.HasExtension(test.message, test.ext) {
+			t.Errorf("%v:\nbefore setting extension HasExtension(...) = true, want false", desc)
+		}
+		got := proto.GetExtension(test.message, test.ext)
+		if d := cmp.Diff(test.wantDefault, got); d != "" {
+			t.Errorf("%v:\nbefore setting extension GetExtension(...) returns unexpected value (-want,+got):\n%v", desc, d)
+		}
+		proto.SetExtension(test.message, test.ext, test.value)
+		if !proto.HasExtension(test.message, test.ext) {
+			t.Errorf("%v:\nafter setting extension HasExtension(...) = false, want true", desc)
+		}
+		got = proto.GetExtension(test.message, test.ext)
+		if d := cmp.Diff(test.value, got); d != "" {
+			t.Errorf("%v:\nafter setting extension GetExtension(...) returns unexpected value (-want,+got):\n%v", desc, d)
+		}
+		proto.ClearExtension(test.message, test.ext)
+		if proto.HasExtension(test.message, test.ext) {
+			t.Errorf("%v:\nafter clearing extension HasExtension(...) = true, want false", desc)
+		}
+	}
+}
+
+func TestIsValid(t *testing.T) {
+	tests := []struct {
+		xt   protoreflect.ExtensionType
+		vi   interface{}
+		want bool
+	}{
+		{testpb.E_OptionalBool, nil, false},
+		{testpb.E_OptionalBool, bool(true), true},
+		{testpb.E_OptionalBool, new(bool), false},
+		{testpb.E_OptionalInt32, nil, false},
+		{testpb.E_OptionalInt32, int32(0), true},
+		{testpb.E_OptionalInt32, new(int32), false},
+		{testpb.E_OptionalInt64, nil, false},
+		{testpb.E_OptionalInt64, int64(0), true},
+		{testpb.E_OptionalInt64, new(int64), false},
+		{testpb.E_OptionalUint32, nil, false},
+		{testpb.E_OptionalUint32, uint32(0), true},
+		{testpb.E_OptionalUint32, new(uint32), false},
+		{testpb.E_OptionalUint64, nil, false},
+		{testpb.E_OptionalUint64, uint64(0), true},
+		{testpb.E_OptionalUint64, new(uint64), false},
+		{testpb.E_OptionalFloat, nil, false},
+		{testpb.E_OptionalFloat, float32(0), true},
+		{testpb.E_OptionalFloat, new(float32), false},
+		{testpb.E_OptionalDouble, nil, false},
+		{testpb.E_OptionalDouble, float64(0), true},
+		{testpb.E_OptionalDouble, new(float32), false},
+		{testpb.E_OptionalString, nil, false},
+		{testpb.E_OptionalString, string(""), true},
+		{testpb.E_OptionalString, new(string), false},
+		{testpb.E_OptionalNestedEnum, nil, false},
+		{testpb.E_OptionalNestedEnum, testpb.TestAllTypes_BAZ, true},
+		{testpb.E_OptionalNestedEnum, testpb.TestAllTypes_BAZ.Enum(), false},
+		{testpb.E_OptionalNestedMessage, nil, false},
+		{testpb.E_OptionalNestedMessage, (*testpb.TestAllExtensions_NestedMessage)(nil), true},
+		{testpb.E_OptionalNestedMessage, new(testpb.TestAllExtensions_NestedMessage), true},
+		{testpb.E_OptionalNestedMessage, new(testpb.TestAllExtensions), false},
+		{testpb.E_RepeatedBool, nil, false},
+		{testpb.E_RepeatedBool, []bool(nil), true},
+		{testpb.E_RepeatedBool, []bool{}, true},
+		{testpb.E_RepeatedBool, []bool{false}, true},
+		{testpb.E_RepeatedBool, []*bool{}, false},
+		{testpb.E_RepeatedInt32, nil, false},
+		{testpb.E_RepeatedInt32, []int32(nil), true},
+		{testpb.E_RepeatedInt32, []int32{}, true},
+		{testpb.E_RepeatedInt32, []int32{0}, true},
+		{testpb.E_RepeatedInt32, []*int32{}, false},
+		{testpb.E_RepeatedInt64, nil, false},
+		{testpb.E_RepeatedInt64, []int64(nil), true},
+		{testpb.E_RepeatedInt64, []int64{}, true},
+		{testpb.E_RepeatedInt64, []int64{0}, true},
+		{testpb.E_RepeatedInt64, []*int64{}, false},
+		{testpb.E_RepeatedUint32, nil, false},
+		{testpb.E_RepeatedUint32, []uint32(nil), true},
+		{testpb.E_RepeatedUint32, []uint32{}, true},
+		{testpb.E_RepeatedUint32, []uint32{0}, true},
+		{testpb.E_RepeatedUint32, []*uint32{}, false},
+		{testpb.E_RepeatedUint64, nil, false},
+		{testpb.E_RepeatedUint64, []uint64(nil), true},
+		{testpb.E_RepeatedUint64, []uint64{}, true},
+		{testpb.E_RepeatedUint64, []uint64{0}, true},
+		{testpb.E_RepeatedUint64, []*uint64{}, false},
+		{testpb.E_RepeatedFloat, nil, false},
+		{testpb.E_RepeatedFloat, []float32(nil), true},
+		{testpb.E_RepeatedFloat, []float32{}, true},
+		{testpb.E_RepeatedFloat, []float32{0}, true},
+		{testpb.E_RepeatedFloat, []*float32{}, false},
+		{testpb.E_RepeatedDouble, nil, false},
+		{testpb.E_RepeatedDouble, []float64(nil), true},
+		{testpb.E_RepeatedDouble, []float64{}, true},
+		{testpb.E_RepeatedDouble, []float64{0}, true},
+		{testpb.E_RepeatedDouble, []*float64{}, false},
+		{testpb.E_RepeatedString, nil, false},
+		{testpb.E_RepeatedString, []string(nil), true},
+		{testpb.E_RepeatedString, []string{}, true},
+		{testpb.E_RepeatedString, []string{""}, true},
+		{testpb.E_RepeatedString, []*string{}, false},
+		{testpb.E_RepeatedNestedEnum, nil, false},
+		{testpb.E_RepeatedNestedEnum, []testpb.TestAllTypes_NestedEnum(nil), true},
+		{testpb.E_RepeatedNestedEnum, []testpb.TestAllTypes_NestedEnum{}, true},
+		{testpb.E_RepeatedNestedEnum, []testpb.TestAllTypes_NestedEnum{0}, true},
+		{testpb.E_RepeatedNestedEnum, []*testpb.TestAllTypes_NestedEnum{}, false},
+		{testpb.E_RepeatedNestedMessage, nil, false},
+		{testpb.E_RepeatedNestedMessage, []*testpb.TestAllExtensions_NestedMessage(nil), true},
+		{testpb.E_RepeatedNestedMessage, []*testpb.TestAllExtensions_NestedMessage{}, true},
+		{testpb.E_RepeatedNestedMessage, []*testpb.TestAllExtensions_NestedMessage{{}}, true},
+		{testpb.E_RepeatedNestedMessage, []*testpb.TestAllExtensions{}, false},
+	}
+
+	for _, tt := range tests {
+		// Check the results of IsValidInterface.
+		got := tt.xt.IsValidInterface(tt.vi)
+		if got != tt.want {
+			t.Errorf("%v.IsValidInterface() = %v, want %v", tt.xt.TypeDescriptor().FullName(), got, tt.want)
+		}
+		if !got {
+			continue
+		}
+
+		// Set the extension value and verify the results of Has.
+		wantHas := true
+		pv := tt.xt.ValueOf(tt.vi)
+		switch v := pv.Interface().(type) {
+		case protoreflect.List:
+			wantHas = v.Len() > 0
+		case protoreflect.Message:
+			wantHas = v.IsValid()
+		}
+		m := &testpb.TestAllExtensions{}
+		proto.SetExtension(m, tt.xt, tt.vi)
+		gotHas := proto.HasExtension(m, tt.xt)
+		if gotHas != wantHas {
+			t.Errorf("HasExtension(%q) = %v, want %v", tt.xt.TypeDescriptor().FullName(), gotHas, wantHas)
+		}
+
+		// Check consistency of IsValidInterface and IsValidValue.
+		got = tt.xt.IsValidValue(pv)
+		if got != tt.want {
+			t.Errorf("%v.IsValidValue() = %v, want %v", tt.xt.TypeDescriptor().FullName(), got, tt.want)
+		}
+		if !got {
+			continue
+		}
+
+		// Use of reflect.DeepEqual is intentional.
+		// We really do want to ensure that the memory layout is identical.
+		vi := tt.xt.InterfaceOf(pv)
+		if !reflect.DeepEqual(vi, tt.vi) {
+			t.Errorf("InterfaceOf(ValueOf(...)) round-trip mismatch: got %v, want %v", vi, tt.vi)
+		}
+	}
+}
+
+func TestExtensionRanger(t *testing.T) {
+	tests := []struct {
+		msg  proto.Message
+		want map[pref.ExtensionType]interface{}
+	}{{
+		msg: &testpb.TestAllExtensions{},
+		want: map[pref.ExtensionType]interface{}{
+			testpb.E_OptionalInt32:         int32(5),
+			testpb.E_OptionalString:        string("hello"),
+			testpb.E_OptionalNestedMessage: &testpb.TestAllExtensions_NestedMessage{},
+			testpb.E_OptionalNestedEnum:    testpb.TestAllTypes_BAZ,
+			testpb.E_RepeatedFloat:         []float32{+32.32, -32.32},
+			testpb.E_RepeatedNestedMessage: []*testpb.TestAllExtensions_NestedMessage{{}},
+			testpb.E_RepeatedNestedEnum:    []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAZ},
+		},
+	}, {
+		msg: &descpb.MessageOptions{},
+		want: map[pref.ExtensionType]interface{}{
+			test3pb.E_OptionalInt32:          int32(5),
+			test3pb.E_OptionalString:         string("hello"),
+			test3pb.E_OptionalForeignMessage: &test3pb.ForeignMessage{},
+			test3pb.E_OptionalForeignEnum:    test3pb.ForeignEnum_FOREIGN_BAR,
+
+			test3pb.E_OptionalOptionalInt32:          int32(5),
+			test3pb.E_OptionalOptionalString:         string("hello"),
+			test3pb.E_OptionalOptionalForeignMessage: &test3pb.ForeignMessage{},
+			test3pb.E_OptionalOptionalForeignEnum:    test3pb.ForeignEnum_FOREIGN_BAR,
+		},
+	}}
+
+	for _, tt := range tests {
+		for xt, v := range tt.want {
+			proto.SetExtension(tt.msg, xt, v)
+		}
+
+		got := make(map[pref.ExtensionType]interface{})
+		proto.RangeExtensions(tt.msg, func(xt pref.ExtensionType, v interface{}) bool {
+			got[xt] = v
+			return true
+		})
+
+		if diff := cmp.Diff(tt.want, got, protocmp.Transform()); diff != "" {
+			t.Errorf("proto.RangeExtensions mismatch (-want +got):\n%s", diff)
+		}
+	}
+}
+
+func TestExtensionGetRace(t *testing.T) {
+	// Concurrently fetch an extension value while marshaling the message containing it.
+	// Create the message with proto.Unmarshal to give lazy extension decoding (if present)
+	// a chance to occur.
+	want := int32(42)
+	m1 := &testpb.TestAllExtensions{}
+	proto.SetExtension(m1, testpb.E_OptionalNestedMessage, &testpb.TestAllExtensions_NestedMessage{A: proto.Int32(want)})
+	b, err := proto.Marshal(m1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	m := &testpb.TestAllExtensions{}
+	if err := proto.Unmarshal(b, m); err != nil {
+		t.Fatal(err)
+	}
+	var wg sync.WaitGroup
+	for i := 0; i < 3; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			if _, err := proto.Marshal(m); err != nil {
+				t.Error(err)
+			}
+		}()
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			got := proto.GetExtension(m, testpb.E_OptionalNestedMessage).(*testpb.TestAllExtensions_NestedMessage).GetA()
+			if got != want {
+				t.Errorf("GetExtension(optional_nested_message).a = %v, want %v", got, want)
+			}
+		}()
+	}
+	wg.Wait()
+}
diff --git a/vendor/google.golang.org/protobuf/proto/merge.go b/vendor/google.golang.org/protobuf/proto/merge.go
new file mode 100644
index 000000000..d761ab331
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/proto/merge.go
@@ -0,0 +1,139 @@
+// Copyright 2019 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 proto
+
+import (
+	"fmt"
+
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/runtime/protoiface"
+)
+
+// Merge merges src into dst, which must be a message with the same descriptor.
+//
+// Populated scalar fields in src are copied to dst, while populated
+// singular messages in src are merged into dst by recursively calling Merge.
+// The elements of every list field in src is appended to the corresponded
+// list fields in dst. The entries of every map field in src is copied into
+// the corresponding map field in dst, possibly replacing existing entries.
+// The unknown fields of src are appended to the unknown fields of dst.
+//
+// It is semantically equivalent to unmarshaling the encoded form of src
+// into dst with the UnmarshalOptions.Merge option specified.
+func Merge(dst, src Message) {
+	// TODO: Should nil src be treated as semantically equivalent to a
+	// untyped, read-only, empty message? What about a nil dst?
+
+	dstMsg, srcMsg := dst.ProtoReflect(), src.ProtoReflect()
+	if dstMsg.Descriptor() != srcMsg.Descriptor() {
+		if got, want := dstMsg.Descriptor().FullName(), srcMsg.Descriptor().FullName(); got != want {
+			panic(fmt.Sprintf("descriptor mismatch: %v != %v", got, want))
+		}
+		panic("descriptor mismatch")
+	}
+	mergeOptions{}.mergeMessage(dstMsg, srcMsg)
+}
+
+// Clone returns a deep copy of m.
+// If the top-level message is invalid, it returns an invalid message as well.
+func Clone(m Message) Message {
+	// NOTE: Most usages of Clone assume the following properties:
+	//	t := reflect.TypeOf(m)
+	//	t == reflect.TypeOf(m.ProtoReflect().New().Interface())
+	//	t == reflect.TypeOf(m.ProtoReflect().Type().Zero().Interface())
+	//
+	// Embedding protobuf messages breaks this since the parent type will have
+	// a forwarded ProtoReflect method, but the Interface method will return
+	// the underlying embedded message type.
+	if m == nil {
+		return nil
+	}
+	src := m.ProtoReflect()
+	if !src.IsValid() {
+		return src.Type().Zero().Interface()
+	}
+	dst := src.New()
+	mergeOptions{}.mergeMessage(dst, src)
+	return dst.Interface()
+}
+
+// mergeOptions provides a namespace for merge functions, and can be
+// exported in the future if we add user-visible merge options.
+type mergeOptions struct{}
+
+func (o mergeOptions) mergeMessage(dst, src protoreflect.Message) {
+	methods := protoMethods(dst)
+	if methods != nil && methods.Merge != nil {
+		in := protoiface.MergeInput{
+			Destination: dst,
+			Source:      src,
+		}
+		out := methods.Merge(in)
+		if out.Flags&protoiface.MergeComplete != 0 {
+			return
+		}
+	}
+
+	if !dst.IsValid() {
+		panic(fmt.Sprintf("cannot merge into invalid %v message", dst.Descriptor().FullName()))
+	}
+
+	src.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
+		switch {
+		case fd.IsList():
+			o.mergeList(dst.Mutable(fd).List(), v.List(), fd)
+		case fd.IsMap():
+			o.mergeMap(dst.Mutable(fd).Map(), v.Map(), fd.MapValue())
+		case fd.Message() != nil:
+			o.mergeMessage(dst.Mutable(fd).Message(), v.Message())
+		case fd.Kind() == protoreflect.BytesKind:
+			dst.Set(fd, o.cloneBytes(v))
+		default:
+			dst.Set(fd, v)
+		}
+		return true
+	})
+
+	if len(src.GetUnknown()) > 0 {
+		dst.SetUnknown(append(dst.GetUnknown(), src.GetUnknown()...))
+	}
+}
+
+func (o mergeOptions) mergeList(dst, src protoreflect.List, fd protoreflect.FieldDescriptor) {
+	// Merge semantics appends to the end of the existing list.
+	for i, n := 0, src.Len(); i < n; i++ {
+		switch v := src.Get(i); {
+		case fd.Message() != nil:
+			dstv := dst.NewElement()
+			o.mergeMessage(dstv.Message(), v.Message())
+			dst.Append(dstv)
+		case fd.Kind() == protoreflect.BytesKind:
+			dst.Append(o.cloneBytes(v))
+		default:
+			dst.Append(v)
+		}
+	}
+}
+
+func (o mergeOptions) mergeMap(dst, src protoreflect.Map, fd protoreflect.FieldDescriptor) {
+	// Merge semantics replaces, rather than merges into existing entries.
+	src.Range(func(k protoreflect.MapKey, v protoreflect.Value) bool {
+		switch {
+		case fd.Message() != nil:
+			dstv := dst.NewValue()
+			o.mergeMessage(dstv.Message(), v.Message())
+			dst.Set(k, dstv)
+		case fd.Kind() == protoreflect.BytesKind:
+			dst.Set(k, o.cloneBytes(v))
+		default:
+			dst.Set(k, v)
+		}
+		return true
+	})
+}
+
+func (o mergeOptions) cloneBytes(v protoreflect.Value) protoreflect.Value {
+	return protoreflect.ValueOfBytes(append([]byte{}, v.Bytes()...))
+}
diff --git a/vendor/google.golang.org/protobuf/proto/merge_test.go b/vendor/google.golang.org/protobuf/proto/merge_test.go
new file mode 100644
index 000000000..05978cb2f
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/proto/merge_test.go
@@ -0,0 +1,905 @@
+// Copyright 2019 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 proto_test
+
+import (
+	"fmt"
+	"reflect"
+	"sync"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+
+	"google.golang.org/protobuf/encoding/prototext"
+	"google.golang.org/protobuf/internal/protobuild"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/testing/protocmp"
+	"google.golang.org/protobuf/testing/protopack"
+	"google.golang.org/protobuf/types/dynamicpb"
+
+	legacypb "google.golang.org/protobuf/internal/testprotos/legacy"
+	testpb "google.golang.org/protobuf/internal/testprotos/test"
+	test3pb "google.golang.org/protobuf/internal/testprotos/test3"
+)
+
+type testMerge struct {
+	desc  string
+	dst   protobuild.Message
+	src   protobuild.Message
+	want  protobuild.Message // if dst and want are nil, want = src
+	types []proto.Message
+}
+
+var testMerges = []testMerge{{
+	desc: "clone a large message",
+	src: protobuild.Message{
+		"optional_int32":       1001,
+		"optional_int64":       1002,
+		"optional_uint32":      1003,
+		"optional_uint64":      1004,
+		"optional_sint32":      1005,
+		"optional_sint64":      1006,
+		"optional_fixed32":     1007,
+		"optional_fixed64":     1008,
+		"optional_sfixed32":    1009,
+		"optional_sfixed64":    1010,
+		"optional_float":       1011.5,
+		"optional_double":      1012.5,
+		"optional_bool":        true,
+		"optional_string":      "string",
+		"optional_bytes":       []byte("bytes"),
+		"optional_nested_enum": 1,
+		"optional_nested_message": protobuild.Message{
+			"a": 100,
+		},
+		"repeated_int32":       []int32{1001, 2001},
+		"repeated_int64":       []int64{1002, 2002},
+		"repeated_uint32":      []uint32{1003, 2003},
+		"repeated_uint64":      []uint64{1004, 2004},
+		"repeated_sint32":      []int32{1005, 2005},
+		"repeated_sint64":      []int64{1006, 2006},
+		"repeated_fixed32":     []uint32{1007, 2007},
+		"repeated_fixed64":     []uint64{1008, 2008},
+		"repeated_sfixed32":    []int32{1009, 2009},
+		"repeated_sfixed64":    []int64{1010, 2010},
+		"repeated_float":       []float32{1011.5, 2011.5},
+		"repeated_double":      []float64{1012.5, 2012.5},
+		"repeated_bool":        []bool{true, false},
+		"repeated_string":      []string{"foo", "bar"},
+		"repeated_bytes":       []string{"FOO", "BAR"},
+		"repeated_nested_enum": []string{"FOO", "BAR"},
+		"repeated_nested_message": []protobuild.Message{
+			{"a": 200},
+			{"a": 300},
+		},
+	},
+}, {
+	desc: "clone maps",
+	src: protobuild.Message{
+		"map_int32_int32":       map[int32]int32{1056: 1156, 2056: 2156},
+		"map_int64_int64":       map[int64]int64{1057: 1157, 2057: 2157},
+		"map_uint32_uint32":     map[uint32]uint32{1058: 1158, 2058: 2158},
+		"map_uint64_uint64":     map[uint64]uint64{1059: 1159, 2059: 2159},
+		"map_sint32_sint32":     map[int32]int32{1060: 1160, 2060: 2160},
+		"map_sint64_sint64":     map[int64]int64{1061: 1161, 2061: 2161},
+		"map_fixed32_fixed32":   map[uint32]uint32{1062: 1162, 2062: 2162},
+		"map_fixed64_fixed64":   map[uint64]uint64{1063: 1163, 2063: 2163},
+		"map_sfixed32_sfixed32": map[int32]int32{1064: 1164, 2064: 2164},
+		"map_sfixed64_sfixed64": map[int64]int64{1065: 1165, 2065: 2165},
+		"map_int32_float":       map[int32]float32{1066: 1166.5, 2066: 2166.5},
+		"map_int32_double":      map[int32]float64{1067: 1167.5, 2067: 2167.5},
+		"map_bool_bool":         map[bool]bool{true: false, false: true},
+		"map_string_string":     map[string]string{"69.1.key": "69.1.val", "69.2.key": "69.2.val"},
+		"map_string_bytes":      map[string][]byte{"70.1.key": []byte("70.1.val"), "70.2.key": []byte("70.2.val")},
+		"map_string_nested_message": map[string]protobuild.Message{
+			"71.1.key": {"a": 1171},
+			"71.2.key": {"a": 2171},
+		},
+		"map_string_nested_enum": map[string]string{"73.1.key": "FOO", "73.2.key": "BAR"},
+	},
+	types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
+}, {
+	desc: "clone oneof uint32",
+	src: protobuild.Message{
+		"oneof_uint32": 1111,
+	},
+	types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
+}, {
+	desc: "clone oneof string",
+	src: protobuild.Message{
+		"oneof_string": "string",
+	},
+	types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
+}, {
+	desc: "clone oneof bytes",
+	src: protobuild.Message{
+		"oneof_bytes": "bytes",
+	},
+	types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
+}, {
+	desc: "clone oneof bool",
+	src: protobuild.Message{
+		"oneof_bool": true,
+	},
+	types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
+}, {
+	desc: "clone oneof uint64",
+	src: protobuild.Message{
+		"oneof_uint64": 100,
+	},
+	types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
+}, {
+	desc: "clone oneof float",
+	src: protobuild.Message{
+		"oneof_float": 100,
+	},
+	types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
+}, {
+	desc: "clone oneof double",
+	src: protobuild.Message{
+		"oneof_double": 1111,
+	},
+	types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
+}, {
+	desc: "clone oneof enum",
+	src: protobuild.Message{
+		"oneof_enum": 1,
+	},
+	types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
+}, {
+	desc: "clone oneof message",
+	src: protobuild.Message{
+		"oneof_nested_message": protobuild.Message{
+			"a": 1,
+		},
+	},
+	types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
+}, {
+	desc: "clone oneof group",
+	src: protobuild.Message{
+		"oneofgroup": protobuild.Message{
+			"a": 1,
+		},
+	},
+	types: []proto.Message{&testpb.TestAllTypes{}},
+}, {
+	desc: "merge bytes",
+	dst: protobuild.Message{
+		"optional_bytes":   []byte{1, 2, 3},
+		"repeated_bytes":   [][]byte{{1, 2}, {3, 4}},
+		"map_string_bytes": map[string][]byte{"alpha": {1, 2, 3}},
+	},
+	src: protobuild.Message{
+		"optional_bytes":   []byte{4, 5, 6},
+		"repeated_bytes":   [][]byte{{5, 6}, {7, 8}},
+		"map_string_bytes": map[string][]byte{"alpha": {4, 5, 6}, "bravo": {1, 2, 3}},
+	},
+	want: protobuild.Message{
+		"optional_bytes":   []byte{4, 5, 6},
+		"repeated_bytes":   [][]byte{{1, 2}, {3, 4}, {5, 6}, {7, 8}},
+		"map_string_bytes": map[string][]byte{"alpha": {4, 5, 6}, "bravo": {1, 2, 3}},
+	},
+	types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
+}, {
+	desc: "merge singular fields",
+	dst: protobuild.Message{
+		"optional_int32":       1,
+		"optional_int64":       1,
+		"optional_uint32":      1,
+		"optional_uint64":      1,
+		"optional_sint32":      1,
+		"optional_sint64":      1,
+		"optional_fixed32":     1,
+		"optional_fixed64":     1,
+		"optional_sfixed32":    1,
+		"optional_sfixed64":    1,
+		"optional_float":       1,
+		"optional_double":      1,
+		"optional_bool":        false,
+		"optional_string":      "1",
+		"optional_bytes":       "1",
+		"optional_nested_enum": 1,
+		"optional_nested_message": protobuild.Message{
+			"a": 1,
+			"corecursive": protobuild.Message{
+				"optional_int64": 1,
+			},
+		},
+	},
+	src: protobuild.Message{
+		"optional_int32":       2,
+		"optional_int64":       2,
+		"optional_uint32":      2,
+		"optional_uint64":      2,
+		"optional_sint32":      2,
+		"optional_sint64":      2,
+		"optional_fixed32":     2,
+		"optional_fixed64":     2,
+		"optional_sfixed32":    2,
+		"optional_sfixed64":    2,
+		"optional_float":       2,
+		"optional_double":      2,
+		"optional_bool":        true,
+		"optional_string":      "2",
+		"optional_bytes":       "2",
+		"optional_nested_enum": 2,
+		"optional_nested_message": protobuild.Message{
+			"a": 2,
+			"corecursive": protobuild.Message{
+				"optional_int64": 2,
+			},
+		},
+	},
+	want: protobuild.Message{
+		"optional_int32":       2,
+		"optional_int64":       2,
+		"optional_uint32":      2,
+		"optional_uint64":      2,
+		"optional_sint32":      2,
+		"optional_sint64":      2,
+		"optional_fixed32":     2,
+		"optional_fixed64":     2,
+		"optional_sfixed32":    2,
+		"optional_sfixed64":    2,
+		"optional_float":       2,
+		"optional_double":      2,
+		"optional_bool":        true,
+		"optional_string":      "2",
+		"optional_bytes":       "2",
+		"optional_nested_enum": 2,
+		"optional_nested_message": protobuild.Message{
+			"a": 2,
+			"corecursive": protobuild.Message{
+				"optional_int64": 2,
+			},
+		},
+	},
+}, {
+	desc: "no merge of empty singular fields",
+	dst: protobuild.Message{
+		"optional_int32":       1,
+		"optional_int64":       1,
+		"optional_uint32":      1,
+		"optional_uint64":      1,
+		"optional_sint32":      1,
+		"optional_sint64":      1,
+		"optional_fixed32":     1,
+		"optional_fixed64":     1,
+		"optional_sfixed32":    1,
+		"optional_sfixed64":    1,
+		"optional_float":       1,
+		"optional_double":      1,
+		"optional_bool":        false,
+		"optional_string":      "1",
+		"optional_bytes":       "1",
+		"optional_nested_enum": 1,
+		"optional_nested_message": protobuild.Message{
+			"a": 1,
+			"corecursive": protobuild.Message{
+				"optional_int64": 1,
+			},
+		},
+	},
+	src: protobuild.Message{
+		"optional_nested_message": protobuild.Message{
+			"a": 1,
+			"corecursive": protobuild.Message{
+				"optional_int32": 2,
+			},
+		},
+	},
+	want: protobuild.Message{
+		"optional_int32":       1,
+		"optional_int64":       1,
+		"optional_uint32":      1,
+		"optional_uint64":      1,
+		"optional_sint32":      1,
+		"optional_sint64":      1,
+		"optional_fixed32":     1,
+		"optional_fixed64":     1,
+		"optional_sfixed32":    1,
+		"optional_sfixed64":    1,
+		"optional_float":       1,
+		"optional_double":      1,
+		"optional_bool":        false,
+		"optional_string":      "1",
+		"optional_bytes":       "1",
+		"optional_nested_enum": 1,
+		"optional_nested_message": protobuild.Message{
+			"a": 1,
+			"corecursive": protobuild.Message{
+				"optional_int32": 2,
+				"optional_int64": 1,
+			},
+		},
+	},
+}, {
+	desc: "merge list fields",
+	dst: protobuild.Message{
+		"repeated_int32":       []int32{1, 2, 3},
+		"repeated_int64":       []int64{1, 2, 3},
+		"repeated_uint32":      []uint32{1, 2, 3},
+		"repeated_uint64":      []uint64{1, 2, 3},
+		"repeated_sint32":      []int32{1, 2, 3},
+		"repeated_sint64":      []int64{1, 2, 3},
+		"repeated_fixed32":     []uint32{1, 2, 3},
+		"repeated_fixed64":     []uint64{1, 2, 3},
+		"repeated_sfixed32":    []int32{1, 2, 3},
+		"repeated_sfixed64":    []int64{1, 2, 3},
+		"repeated_float":       []float32{1, 2, 3},
+		"repeated_double":      []float64{1, 2, 3},
+		"repeated_bool":        []bool{true},
+		"repeated_string":      []string{"a", "b", "c"},
+		"repeated_bytes":       []string{"a", "b", "c"},
+		"repeated_nested_enum": []int{1, 2, 3},
+		"repeated_nested_message": []protobuild.Message{
+			{"a": 100},
+			{"a": 200},
+		},
+	},
+	src: protobuild.Message{
+		"repeated_int32":       []int32{4, 5, 6},
+		"repeated_int64":       []int64{4, 5, 6},
+		"repeated_uint32":      []uint32{4, 5, 6},
+		"repeated_uint64":      []uint64{4, 5, 6},
+		"repeated_sint32":      []int32{4, 5, 6},
+		"repeated_sint64":      []int64{4, 5, 6},
+		"repeated_fixed32":     []uint32{4, 5, 6},
+		"repeated_fixed64":     []uint64{4, 5, 6},
+		"repeated_sfixed32":    []int32{4, 5, 6},
+		"repeated_sfixed64":    []int64{4, 5, 6},
+		"repeated_float":       []float32{4, 5, 6},
+		"repeated_double":      []float64{4, 5, 6},
+		"repeated_bool":        []bool{false},
+		"repeated_string":      []string{"d", "e", "f"},
+		"repeated_bytes":       []string{"d", "e", "f"},
+		"repeated_nested_enum": []int{4, 5, 6},
+		"repeated_nested_message": []protobuild.Message{
+			{"a": 300},
+			{"a": 400},
+		},
+	},
+	want: protobuild.Message{
+		"repeated_int32":       []int32{1, 2, 3, 4, 5, 6},
+		"repeated_int64":       []int64{1, 2, 3, 4, 5, 6},
+		"repeated_uint32":      []uint32{1, 2, 3, 4, 5, 6},
+		"repeated_uint64":      []uint64{1, 2, 3, 4, 5, 6},
+		"repeated_sint32":      []int32{1, 2, 3, 4, 5, 6},
+		"repeated_sint64":      []int64{1, 2, 3, 4, 5, 6},
+		"repeated_fixed32":     []uint32{1, 2, 3, 4, 5, 6},
+		"repeated_fixed64":     []uint64{1, 2, 3, 4, 5, 6},
+		"repeated_sfixed32":    []int32{1, 2, 3, 4, 5, 6},
+		"repeated_sfixed64":    []int64{1, 2, 3, 4, 5, 6},
+		"repeated_float":       []float32{1, 2, 3, 4, 5, 6},
+		"repeated_double":      []float64{1, 2, 3, 4, 5, 6},
+		"repeated_bool":        []bool{true, false},
+		"repeated_string":      []string{"a", "b", "c", "d", "e", "f"},
+		"repeated_bytes":       []string{"a", "b", "c", "d", "e", "f"},
+		"repeated_nested_enum": []int{1, 2, 3, 4, 5, 6},
+		"repeated_nested_message": []protobuild.Message{
+			{"a": 100},
+			{"a": 200},
+			{"a": 300},
+			{"a": 400},
+		},
+	},
+}, {
+	desc: "merge map fields",
+	dst: protobuild.Message{
+		"map_int32_int32":       map[int]int{1: 1, 3: 1},
+		"map_int64_int64":       map[int]int{1: 1, 3: 1},
+		"map_uint32_uint32":     map[int]int{1: 1, 3: 1},
+		"map_uint64_uint64":     map[int]int{1: 1, 3: 1},
+		"map_sint32_sint32":     map[int]int{1: 1, 3: 1},
+		"map_sint64_sint64":     map[int]int{1: 1, 3: 1},
+		"map_fixed32_fixed32":   map[int]int{1: 1, 3: 1},
+		"map_fixed64_fixed64":   map[int]int{1: 1, 3: 1},
+		"map_sfixed32_sfixed32": map[int]int{1: 1, 3: 1},
+		"map_sfixed64_sfixed64": map[int]int{1: 1, 3: 1},
+		"map_int32_float":       map[int]int{1: 1, 3: 1},
+		"map_int32_double":      map[int]int{1: 1, 3: 1},
+		"map_bool_bool":         map[bool]bool{true: true},
+		"map_string_string":     map[string]string{"a": "1", "ab": "1"},
+		"map_string_bytes":      map[string]string{"a": "1", "ab": "1"},
+		"map_string_nested_message": map[string]protobuild.Message{
+			"a": {"a": 1},
+			"ab": {
+				"a": 1,
+				"corecursive": protobuild.Message{
+					"map_int32_int32": map[int]int{1: 1, 3: 1},
+				},
+			},
+		},
+		"map_string_nested_enum": map[string]int{"a": 1, "ab": 1},
+	},
+	src: protobuild.Message{
+		"map_int32_int32":       map[int]int{2: 2, 3: 2},
+		"map_int64_int64":       map[int]int{2: 2, 3: 2},
+		"map_uint32_uint32":     map[int]int{2: 2, 3: 2},
+		"map_uint64_uint64":     map[int]int{2: 2, 3: 2},
+		"map_sint32_sint32":     map[int]int{2: 2, 3: 2},
+		"map_sint64_sint64":     map[int]int{2: 2, 3: 2},
+		"map_fixed32_fixed32":   map[int]int{2: 2, 3: 2},
+		"map_fixed64_fixed64":   map[int]int{2: 2, 3: 2},
+		"map_sfixed32_sfixed32": map[int]int{2: 2, 3: 2},
+		"map_sfixed64_sfixed64": map[int]int{2: 2, 3: 2},
+		"map_int32_float":       map[int]int{2: 2, 3: 2},
+		"map_int32_double":      map[int]int{2: 2, 3: 2},
+		"map_bool_bool":         map[bool]bool{false: false},
+		"map_string_string":     map[string]string{"b": "2", "ab": "2"},
+		"map_string_bytes":      map[string]string{"b": "2", "ab": "2"},
+		"map_string_nested_message": map[string]protobuild.Message{
+			"b": {"a": 2},
+			"ab": {
+				"a": 2,
+				"corecursive": protobuild.Message{
+					"map_int32_int32": map[int]int{2: 2, 3: 2},
+				},
+			},
+		},
+		"map_string_nested_enum": map[string]int{"b": 2, "ab": 2},
+	},
+	want: protobuild.Message{
+		"map_int32_int32":       map[int]int{1: 1, 2: 2, 3: 2},
+		"map_int64_int64":       map[int]int{1: 1, 2: 2, 3: 2},
+		"map_uint32_uint32":     map[int]int{1: 1, 2: 2, 3: 2},
+		"map_uint64_uint64":     map[int]int{1: 1, 2: 2, 3: 2},
+		"map_sint32_sint32":     map[int]int{1: 1, 2: 2, 3: 2},
+		"map_sint64_sint64":     map[int]int{1: 1, 2: 2, 3: 2},
+		"map_fixed32_fixed32":   map[int]int{1: 1, 2: 2, 3: 2},
+		"map_fixed64_fixed64":   map[int]int{1: 1, 2: 2, 3: 2},
+		"map_sfixed32_sfixed32": map[int]int{1: 1, 2: 2, 3: 2},
+		"map_sfixed64_sfixed64": map[int]int{1: 1, 2: 2, 3: 2},
+		"map_int32_float":       map[int]int{1: 1, 2: 2, 3: 2},
+		"map_int32_double":      map[int]int{1: 1, 2: 2, 3: 2},
+		"map_bool_bool":         map[bool]bool{true: true, false: false},
+		"map_string_string":     map[string]string{"a": "1", "b": "2", "ab": "2"},
+		"map_string_bytes":      map[string]string{"a": "1", "b": "2", "ab": "2"},
+		"map_string_nested_message": map[string]protobuild.Message{
+			"a": {"a": 1},
+			"b": {"a": 2},
+			"ab": {
+				"a": 2,
+				"corecursive": protobuild.Message{
+					// The map item "ab" was entirely replaced, so
+					// this does not contain 1:1 from dst.
+					"map_int32_int32": map[int]int{2: 2, 3: 2},
+				},
+			},
+		},
+		"map_string_nested_enum": map[string]int{"a": 1, "b": 2, "ab": 2},
+	},
+	types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
+}, {
+	desc: "merge oneof message fields",
+	dst: protobuild.Message{
+		"oneof_nested_message": protobuild.Message{
+			"a": 100,
+		},
+	},
+	src: protobuild.Message{
+		"oneof_nested_message": protobuild.Message{
+			"corecursive": protobuild.Message{
+				"optional_int64": 1000,
+			},
+		},
+	},
+	want: protobuild.Message{
+		"oneof_nested_message": protobuild.Message{
+			"a": 100,
+			"corecursive": protobuild.Message{
+				"optional_int64": 1000,
+			},
+		},
+	},
+	types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
+}, {
+	desc: "merge oneof scalar fields",
+	dst: protobuild.Message{
+		"oneof_uint32": 100,
+	},
+	src: protobuild.Message{
+		"oneof_float": 3.14152,
+	},
+	want: protobuild.Message{
+		"oneof_float": 3.14152,
+	},
+	types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
+}, {
+	desc: "merge unknown fields",
+	dst: protobuild.Message{
+		protobuild.Unknown: protopack.Message{
+			protopack.Tag{Number: 50000, Type: protopack.VarintType}, protopack.Svarint(-5),
+		}.Marshal(),
+	},
+	src: protobuild.Message{
+		protobuild.Unknown: protopack.Message{
+			protopack.Tag{Number: 500000, Type: protopack.VarintType}, protopack.Svarint(-50),
+		}.Marshal(),
+	},
+	want: protobuild.Message{
+		protobuild.Unknown: protopack.Message{
+			protopack.Tag{Number: 50000, Type: protopack.VarintType}, protopack.Svarint(-5),
+			protopack.Tag{Number: 500000, Type: protopack.VarintType}, protopack.Svarint(-50),
+		}.Marshal(),
+	},
+}, {
+	desc: "clone legacy message",
+	src: protobuild.Message{"f1": protobuild.Message{
+		"optional_int32":        1,
+		"optional_int64":        1,
+		"optional_uint32":       1,
+		"optional_uint64":       1,
+		"optional_sint32":       1,
+		"optional_sint64":       1,
+		"optional_fixed32":      1,
+		"optional_fixed64":      1,
+		"optional_sfixed32":     1,
+		"optional_sfixed64":     1,
+		"optional_float":        1,
+		"optional_double":       1,
+		"optional_bool":         true,
+		"optional_string":       "string",
+		"optional_bytes":        "bytes",
+		"optional_sibling_enum": 1,
+		"optional_sibling_message": protobuild.Message{
+			"f1": "value",
+		},
+		"repeated_int32":        []int32{1},
+		"repeated_int64":        []int64{1},
+		"repeated_uint32":       []uint32{1},
+		"repeated_uint64":       []uint64{1},
+		"repeated_sint32":       []int32{1},
+		"repeated_sint64":       []int64{1},
+		"repeated_fixed32":      []uint32{1},
+		"repeated_fixed64":      []uint64{1},
+		"repeated_sfixed32":     []int32{1},
+		"repeated_sfixed64":     []int64{1},
+		"repeated_float":        []float32{1},
+		"repeated_double":       []float64{1},
+		"repeated_bool":         []bool{true},
+		"repeated_string":       []string{"string"},
+		"repeated_bytes":        []string{"bytes"},
+		"repeated_sibling_enum": []int{1},
+		"repeated_sibling_message": []protobuild.Message{
+			{"f1": "1"},
+		},
+		"map_bool_int32":    map[bool]int{true: 1},
+		"map_bool_int64":    map[bool]int{true: 1},
+		"map_bool_uint32":   map[bool]int{true: 1},
+		"map_bool_uint64":   map[bool]int{true: 1},
+		"map_bool_sint32":   map[bool]int{true: 1},
+		"map_bool_sint64":   map[bool]int{true: 1},
+		"map_bool_fixed32":  map[bool]int{true: 1},
+		"map_bool_fixed64":  map[bool]int{true: 1},
+		"map_bool_sfixed32": map[bool]int{true: 1},
+		"map_bool_sfixed64": map[bool]int{true: 1},
+		"map_bool_float":    map[bool]int{true: 1},
+		"map_bool_double":   map[bool]int{true: 1},
+		"map_bool_bool":     map[bool]bool{true: false},
+		"map_bool_string":   map[bool]string{true: "1"},
+		"map_bool_bytes":    map[bool]string{true: "1"},
+		"map_bool_sibling_message": map[bool]protobuild.Message{
+			true: {"f1": "1"},
+		},
+		"map_bool_sibling_enum": map[bool]int{true: 1},
+		"oneof_sibling_message": protobuild.Message{
+			"f1": "1",
+		},
+	}},
+	types: []proto.Message{&legacypb.Legacy{}},
+}}
+
+func TestMerge(t *testing.T) {
+	for _, tt := range testMerges {
+		for _, mt := range templateMessages(tt.types...) {
+			t.Run(fmt.Sprintf("%s (%v)", tt.desc, mt.Descriptor().FullName()), func(t *testing.T) {
+				dst := mt.New().Interface()
+				tt.dst.Build(dst.ProtoReflect())
+
+				src := mt.New().Interface()
+				tt.src.Build(src.ProtoReflect())
+
+				want := mt.New().Interface()
+				if tt.dst == nil && tt.want == nil {
+					tt.src.Build(want.ProtoReflect())
+				} else {
+					tt.want.Build(want.ProtoReflect())
+				}
+
+				// Merge should be semantically equivalent to unmarshaling the
+				// encoded form of src into the current dst.
+				b1, err := proto.MarshalOptions{AllowPartial: true}.Marshal(dst)
+				if err != nil {
+					t.Fatalf("Marshal(dst) error: %v", err)
+				}
+				b2, err := proto.MarshalOptions{AllowPartial: true}.Marshal(src)
+				if err != nil {
+					t.Fatalf("Marshal(src) error: %v", err)
+				}
+				unmarshaled := dst.ProtoReflect().New().Interface()
+				err = proto.UnmarshalOptions{AllowPartial: true}.Unmarshal(append(b1, b2...), unmarshaled)
+				if err != nil {
+					t.Fatalf("Unmarshal() error: %v", err)
+				}
+				if !proto.Equal(unmarshaled, want) {
+					t.Fatalf("Unmarshal(Marshal(dst)+Marshal(src)) mismatch:\n got %v\nwant %v\ndiff (-want,+got):\n%v", unmarshaled, want, cmp.Diff(want, unmarshaled, protocmp.Transform()))
+				}
+
+				// Test heterogeneous MessageTypes by merging into a
+				// dynamic message.
+				ddst := dynamicpb.NewMessage(mt.Descriptor())
+				tt.dst.Build(ddst.ProtoReflect())
+				proto.Merge(ddst, src)
+				if !proto.Equal(ddst, want) {
+					t.Fatalf("Merge() into dynamic message mismatch:\n got %v\nwant %v\ndiff (-want,+got):\n%v", ddst, want, cmp.Diff(want, ddst, protocmp.Transform()))
+				}
+
+				proto.Merge(dst, src)
+				if !proto.Equal(dst, want) {
+					t.Fatalf("Merge() mismatch:\n got %v\nwant %v\ndiff (-want,+got):\n%v", dst, want, cmp.Diff(want, dst, protocmp.Transform()))
+				}
+				mutateValue(protoreflect.ValueOfMessage(src.ProtoReflect()))
+				if !proto.Equal(dst, want) {
+					t.Fatalf("mutation observed after modifying source:\n got %v\nwant %v\ndiff (-want,+got):\n%v", dst, want, cmp.Diff(want, dst, protocmp.Transform()))
+				}
+			})
+		}
+	}
+}
+
+func TestMergeFromNil(t *testing.T) {
+	dst := &testpb.TestAllTypes{}
+	proto.Merge(dst, (*testpb.TestAllTypes)(nil))
+	if !proto.Equal(dst, &testpb.TestAllTypes{}) {
+		t.Errorf("destination should be empty after merging from nil message; got:\n%v", prototext.Format(dst))
+	}
+}
+
+// TestMergeAberrant tests inputs that are beyond the protobuf data model.
+// Just because there is a test for the current behavior does not mean that
+// this will behave the same way in the future.
+func TestMergeAberrant(t *testing.T) {
+	tests := []struct {
+		label string
+		dst   proto.Message
+		src   proto.Message
+		check func(proto.Message) bool
+	}{{
+		label: "Proto2EmptyBytes",
+		dst:   &testpb.TestAllTypes{OptionalBytes: nil},
+		src:   &testpb.TestAllTypes{OptionalBytes: []byte{}},
+		check: func(m proto.Message) bool {
+			return m.(*testpb.TestAllTypes).OptionalBytes != nil
+		},
+	}, {
+		label: "Proto3EmptyBytes",
+		dst:   &test3pb.TestAllTypes{SingularBytes: nil},
+		src:   &test3pb.TestAllTypes{SingularBytes: []byte{}},
+		check: func(m proto.Message) bool {
+			return m.(*test3pb.TestAllTypes).SingularBytes == nil
+		},
+	}, {
+		label: "EmptyList",
+		dst:   &testpb.TestAllTypes{RepeatedInt32: nil},
+		src:   &testpb.TestAllTypes{RepeatedInt32: []int32{}},
+		check: func(m proto.Message) bool {
+			return m.(*testpb.TestAllTypes).RepeatedInt32 == nil
+		},
+	}, {
+		label: "ListWithNilBytes",
+		dst:   &testpb.TestAllTypes{RepeatedBytes: nil},
+		src:   &testpb.TestAllTypes{RepeatedBytes: [][]byte{nil}},
+		check: func(m proto.Message) bool {
+			return reflect.DeepEqual(m.(*testpb.TestAllTypes).RepeatedBytes, [][]byte{{}})
+		},
+	}, {
+		label: "ListWithEmptyBytes",
+		dst:   &testpb.TestAllTypes{RepeatedBytes: nil},
+		src:   &testpb.TestAllTypes{RepeatedBytes: [][]byte{{}}},
+		check: func(m proto.Message) bool {
+			return reflect.DeepEqual(m.(*testpb.TestAllTypes).RepeatedBytes, [][]byte{{}})
+		},
+	}, {
+		label: "ListWithNilMessage",
+		dst:   &testpb.TestAllTypes{RepeatedNestedMessage: nil},
+		src:   &testpb.TestAllTypes{RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{nil}},
+		check: func(m proto.Message) bool {
+			return m.(*testpb.TestAllTypes).RepeatedNestedMessage[0] != nil
+		},
+	}, {
+		label: "EmptyMap",
+		dst:   &testpb.TestAllTypes{MapStringString: nil},
+		src:   &testpb.TestAllTypes{MapStringString: map[string]string{}},
+		check: func(m proto.Message) bool {
+			return m.(*testpb.TestAllTypes).MapStringString == nil
+		},
+	}, {
+		label: "MapWithNilBytes",
+		dst:   &testpb.TestAllTypes{MapStringBytes: nil},
+		src:   &testpb.TestAllTypes{MapStringBytes: map[string][]byte{"k": nil}},
+		check: func(m proto.Message) bool {
+			return reflect.DeepEqual(m.(*testpb.TestAllTypes).MapStringBytes, map[string][]byte{"k": {}})
+		},
+	}, {
+		label: "MapWithEmptyBytes",
+		dst:   &testpb.TestAllTypes{MapStringBytes: nil},
+		src:   &testpb.TestAllTypes{MapStringBytes: map[string][]byte{"k": {}}},
+		check: func(m proto.Message) bool {
+			return reflect.DeepEqual(m.(*testpb.TestAllTypes).MapStringBytes, map[string][]byte{"k": {}})
+		},
+	}, {
+		label: "MapWithNilMessage",
+		dst:   &testpb.TestAllTypes{MapStringNestedMessage: nil},
+		src:   &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"k": nil}},
+		check: func(m proto.Message) bool {
+			return m.(*testpb.TestAllTypes).MapStringNestedMessage["k"] != nil
+		},
+	}, {
+		label: "OneofWithTypedNilWrapper",
+		dst:   &testpb.TestAllTypes{OneofField: nil},
+		src:   &testpb.TestAllTypes{OneofField: (*testpb.TestAllTypes_OneofNestedMessage)(nil)},
+		check: func(m proto.Message) bool {
+			return m.(*testpb.TestAllTypes).OneofField == nil
+		},
+	}, {
+		label: "OneofWithNilMessage",
+		dst:   &testpb.TestAllTypes{OneofField: nil},
+		src:   &testpb.TestAllTypes{OneofField: &testpb.TestAllTypes_OneofNestedMessage{OneofNestedMessage: nil}},
+		check: func(m proto.Message) bool {
+			return m.(*testpb.TestAllTypes).OneofField.(*testpb.TestAllTypes_OneofNestedMessage).OneofNestedMessage != nil
+		},
+		// TODO: extension, nil message
+		// TODO: repeated extension, nil
+		// TODO: extension bytes
+		// TODO: repeated extension, nil message
+	}}
+
+	for _, tt := range tests {
+		t.Run(tt.label, func(t *testing.T) {
+			var pass bool
+			func() {
+				defer func() { recover() }()
+				proto.Merge(tt.dst, tt.src)
+				pass = tt.check(tt.dst)
+			}()
+			if !pass {
+				t.Error("check failed")
+			}
+		})
+	}
+}
+
+func TestMergeRace(t *testing.T) {
+	dst := new(testpb.TestAllTypes)
+	srcs := []*testpb.TestAllTypes{
+		{OptionalInt32: proto.Int32(1)},
+		{OptionalString: proto.String("hello")},
+		{RepeatedInt32: []int32{2, 3, 4}},
+		{RepeatedString: []string{"goodbye"}},
+		{MapStringString: map[string]string{"key": "value"}},
+		{OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{
+			A: proto.Int32(5),
+		}},
+		func() *testpb.TestAllTypes {
+			m := new(testpb.TestAllTypes)
+			m.ProtoReflect().SetUnknown(protopack.Message{
+				protopack.Tag{Number: 50000, Type: protopack.VarintType}, protopack.Svarint(-5),
+			}.Marshal())
+			return m
+		}(),
+	}
+
+	// It should be safe to concurrently merge non-overlapping fields.
+	var wg sync.WaitGroup
+	defer wg.Wait()
+	for _, src := range srcs {
+		wg.Add(1)
+		go func(src proto.Message) {
+			defer wg.Done()
+			proto.Merge(dst, src)
+		}(src)
+	}
+}
+
+func TestMergeSelf(t *testing.T) {
+	got := &testpb.TestAllTypes{
+		OptionalInt32:   proto.Int32(1),
+		OptionalString:  proto.String("hello"),
+		RepeatedInt32:   []int32{2, 3, 4},
+		RepeatedString:  []string{"goodbye"},
+		MapStringString: map[string]string{"key": "value"},
+		OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{
+			A: proto.Int32(5),
+		},
+	}
+	got.ProtoReflect().SetUnknown(protopack.Message{
+		protopack.Tag{Number: 50000, Type: protopack.VarintType}, protopack.Svarint(-5),
+	}.Marshal())
+	proto.Merge(got, got)
+
+	// The main impact of merging to self is that repeated fields and
+	// unknown fields are doubled.
+	want := &testpb.TestAllTypes{
+		OptionalInt32:   proto.Int32(1),
+		OptionalString:  proto.String("hello"),
+		RepeatedInt32:   []int32{2, 3, 4, 2, 3, 4},
+		RepeatedString:  []string{"goodbye", "goodbye"},
+		MapStringString: map[string]string{"key": "value"},
+		OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{
+			A: proto.Int32(5),
+		},
+	}
+	want.ProtoReflect().SetUnknown(protopack.Message{
+		protopack.Tag{Number: 50000, Type: protopack.VarintType}, protopack.Svarint(-5),
+		protopack.Tag{Number: 50000, Type: protopack.VarintType}, protopack.Svarint(-5),
+	}.Marshal())
+
+	if !proto.Equal(got, want) {
+		t.Errorf("Equal mismatch:\ngot  %v\nwant %v", got, want)
+	}
+}
+
+func TestClone(t *testing.T) {
+	want := &testpb.TestAllTypes{
+		OptionalInt32: proto.Int32(1),
+	}
+	got := proto.Clone(want).(*testpb.TestAllTypes)
+	if !proto.Equal(got, want) {
+		t.Errorf("Clone(src) != src:\n got %v\nwant %v", got, want)
+	}
+}
+
+// mutateValue changes a Value, returning a new value.
+//
+// For scalar values, it returns a value different from the input.
+// For Message, List, and Map values, it mutates the input and returns it.
+func mutateValue(v protoreflect.Value) protoreflect.Value {
+	switch v := v.Interface().(type) {
+	case bool:
+		return protoreflect.ValueOfBool(!v)
+	case protoreflect.EnumNumber:
+		return protoreflect.ValueOfEnum(v + 1)
+	case int32:
+		return protoreflect.ValueOfInt32(v + 1)
+	case int64:
+		return protoreflect.ValueOfInt64(v + 1)
+	case uint32:
+		return protoreflect.ValueOfUint32(v + 1)
+	case uint64:
+		return protoreflect.ValueOfUint64(v + 1)
+	case float32:
+		return protoreflect.ValueOfFloat32(v + 1)
+	case float64:
+		return protoreflect.ValueOfFloat64(v + 1)
+	case []byte:
+		for i := range v {
+			v[i]++
+		}
+		return protoreflect.ValueOfBytes(v)
+	case string:
+		return protoreflect.ValueOfString("_" + v)
+	case protoreflect.Message:
+		v.Range(func(fd protoreflect.FieldDescriptor, val protoreflect.Value) bool {
+			v.Set(fd, mutateValue(val))
+			return true
+		})
+		return protoreflect.ValueOfMessage(v)
+	case protoreflect.List:
+		for i := 0; i < v.Len(); i++ {
+			v.Set(i, mutateValue(v.Get(i)))
+		}
+		return protoreflect.ValueOfList(v)
+	case protoreflect.Map:
+		v.Range(func(mk protoreflect.MapKey, mv protoreflect.Value) bool {
+			v.Set(mk, mutateValue(mv))
+			return true
+		})
+		return protoreflect.ValueOfMap(v)
+	default:
+		panic(fmt.Sprintf("unknown value type %T", v))
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/proto/messageset.go b/vendor/google.golang.org/protobuf/proto/messageset.go
new file mode 100644
index 000000000..b6b3de591
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/proto/messageset.go
@@ -0,0 +1,88 @@
+// Copyright 2019 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 proto
+
+import (
+	"google.golang.org/protobuf/encoding/protowire"
+	"google.golang.org/protobuf/internal/encoding/messageset"
+	"google.golang.org/protobuf/internal/errors"
+	"google.golang.org/protobuf/internal/flags"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/reflect/protoregistry"
+)
+
+func sizeMessageSet(m protoreflect.Message) (size int) {
+	m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
+		size += messageset.SizeField(fd.Number())
+		size += protowire.SizeTag(messageset.FieldMessage)
+		size += protowire.SizeBytes(sizeMessage(v.Message()))
+		return true
+	})
+	size += messageset.SizeUnknown(m.GetUnknown())
+	return size
+}
+
+func marshalMessageSet(b []byte, m protoreflect.Message, o MarshalOptions) ([]byte, error) {
+	if !flags.ProtoLegacy {
+		return b, errors.New("no support for message_set_wire_format")
+	}
+	var err error
+	o.rangeFields(m, func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
+		b, err = marshalMessageSetField(b, fd, v, o)
+		return err == nil
+	})
+	if err != nil {
+		return b, err
+	}
+	return messageset.AppendUnknown(b, m.GetUnknown())
+}
+
+func marshalMessageSetField(b []byte, fd protoreflect.FieldDescriptor, value protoreflect.Value, o MarshalOptions) ([]byte, error) {
+	b = messageset.AppendFieldStart(b, fd.Number())
+	b = protowire.AppendTag(b, messageset.FieldMessage, protowire.BytesType)
+	b = protowire.AppendVarint(b, uint64(o.Size(value.Message().Interface())))
+	b, err := o.marshalMessage(b, value.Message())
+	if err != nil {
+		return b, err
+	}
+	b = messageset.AppendFieldEnd(b)
+	return b, nil
+}
+
+func unmarshalMessageSet(b []byte, m protoreflect.Message, o UnmarshalOptions) error {
+	if !flags.ProtoLegacy {
+		return errors.New("no support for message_set_wire_format")
+	}
+	return messageset.Unmarshal(b, false, func(num protowire.Number, v []byte) error {
+		err := unmarshalMessageSetField(m, num, v, o)
+		if err == errUnknown {
+			unknown := m.GetUnknown()
+			unknown = protowire.AppendTag(unknown, num, protowire.BytesType)
+			unknown = protowire.AppendBytes(unknown, v)
+			m.SetUnknown(unknown)
+			return nil
+		}
+		return err
+	})
+}
+
+func unmarshalMessageSetField(m protoreflect.Message, num protowire.Number, v []byte, o UnmarshalOptions) error {
+	md := m.Descriptor()
+	if !md.ExtensionRanges().Has(num) {
+		return errUnknown
+	}
+	xt, err := o.Resolver.FindExtensionByNumber(md.FullName(), num)
+	if err == protoregistry.NotFound {
+		return errUnknown
+	}
+	if err != nil {
+		return errors.New("%v: unable to resolve extension %v: %v", md.FullName(), num, err)
+	}
+	xd := xt.TypeDescriptor()
+	if err := o.unmarshalMessage(v, m.Mutable(xd).Message()); err != nil {
+		return err
+	}
+	return nil
+}
diff --git a/vendor/google.golang.org/protobuf/proto/messageset_test.go b/vendor/google.golang.org/protobuf/proto/messageset_test.go
new file mode 100644
index 000000000..e634112fa
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/proto/messageset_test.go
@@ -0,0 +1,312 @@
+// Copyright 2019 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 proto_test
+
+import (
+	"google.golang.org/protobuf/encoding/protowire"
+	"google.golang.org/protobuf/internal/flags"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/testing/protopack"
+
+	messagesetpb "google.golang.org/protobuf/internal/testprotos/messageset/messagesetpb"
+	msetextpb "google.golang.org/protobuf/internal/testprotos/messageset/msetextpb"
+)
+
+func init() {
+	if flags.ProtoLegacy {
+		testValidMessages = append(testValidMessages, messageSetTestProtos...)
+		testInvalidMessages = append(testInvalidMessages, messageSetInvalidTestProtos...)
+	}
+}
+
+var messageSetTestProtos = []testProto{
+	{
+		desc: "MessageSet type_id before message content",
+		decodeTo: []proto.Message{func() proto.Message {
+			m := &messagesetpb.MessageSetContainer{MessageSet: &messagesetpb.MessageSet{}}
+			proto.SetExtension(m.MessageSet, msetextpb.E_Ext1_MessageSetExtension, &msetextpb.Ext1{
+				Ext1Field1: proto.Int32(10),
+			})
+			return m
+		}()},
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.StartGroupType},
+				protopack.Tag{2, protopack.VarintType}, protopack.Varint(1000),
+				protopack.Tag{3, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+					protopack.Tag{1, protopack.VarintType}, protopack.Varint(10),
+				}),
+				protopack.Tag{1, protopack.EndGroupType},
+			}),
+		}.Marshal(),
+	},
+	{
+		desc: "MessageSet type_id after message content",
+		decodeTo: []proto.Message{func() proto.Message {
+			m := &messagesetpb.MessageSetContainer{MessageSet: &messagesetpb.MessageSet{}}
+			proto.SetExtension(m.MessageSet, msetextpb.E_Ext1_MessageSetExtension, &msetextpb.Ext1{
+				Ext1Field1: proto.Int32(10),
+			})
+			return m
+		}()},
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.StartGroupType},
+				protopack.Tag{3, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+					protopack.Tag{1, protopack.VarintType}, protopack.Varint(10),
+				}),
+				protopack.Tag{2, protopack.VarintType}, protopack.Varint(1000),
+				protopack.Tag{1, protopack.EndGroupType},
+			}),
+		}.Marshal(),
+	},
+	{
+		desc: "MessageSet does not preserve unknown field",
+		decodeTo: []proto.Message{build(
+			&messagesetpb.MessageSet{},
+			extend(msetextpb.E_Ext1_MessageSetExtension, &msetextpb.Ext1{
+				Ext1Field1: proto.Int32(10),
+			}),
+		)},
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.StartGroupType},
+			protopack.Tag{2, protopack.VarintType}, protopack.Varint(1000),
+			protopack.Tag{3, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(10),
+			}),
+			protopack.Tag{1, protopack.EndGroupType},
+			// Unknown field
+			protopack.Tag{4, protopack.VarintType}, protopack.Varint(30),
+		}.Marshal(),
+	},
+	{
+		desc: "MessageSet with unknown type_id",
+		decodeTo: []proto.Message{build(
+			&messagesetpb.MessageSet{},
+			unknown(protopack.Message{
+				protopack.Tag{999, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+					protopack.Tag{1, protopack.VarintType}, protopack.Varint(10),
+				}),
+			}.Marshal()),
+		)},
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.StartGroupType},
+			protopack.Tag{2, protopack.VarintType}, protopack.Varint(999),
+			protopack.Tag{3, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(10),
+			}),
+			protopack.Tag{1, protopack.EndGroupType},
+		}.Marshal(),
+	},
+	{
+		desc: "MessageSet merges repeated message fields in item",
+		decodeTo: []proto.Message{build(
+			&messagesetpb.MessageSet{},
+			extend(msetextpb.E_Ext1_MessageSetExtension, &msetextpb.Ext1{
+				Ext1Field1: proto.Int32(10),
+				Ext1Field2: proto.Int32(20),
+			}),
+		)},
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.StartGroupType},
+			protopack.Tag{2, protopack.VarintType}, protopack.Varint(1000),
+			protopack.Tag{3, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(10),
+			}),
+			protopack.Tag{3, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{2, protopack.VarintType}, protopack.Varint(20),
+			}),
+			protopack.Tag{1, protopack.EndGroupType},
+		}.Marshal(),
+	},
+	{
+		desc: "MessageSet merges message fields in repeated items",
+		decodeTo: []proto.Message{build(
+			&messagesetpb.MessageSet{},
+			extend(msetextpb.E_Ext1_MessageSetExtension, &msetextpb.Ext1{
+				Ext1Field1: proto.Int32(10),
+				Ext1Field2: proto.Int32(20),
+			}),
+			extend(msetextpb.E_Ext2_MessageSetExtension, &msetextpb.Ext2{
+				Ext2Field1: proto.Int32(30),
+			}),
+		)},
+		wire: protopack.Message{
+			// Ext1, field1
+			protopack.Tag{1, protopack.StartGroupType},
+			protopack.Tag{2, protopack.VarintType}, protopack.Varint(1000),
+			protopack.Tag{3, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(10),
+			}),
+			protopack.Tag{1, protopack.EndGroupType},
+			// Ext2, field1
+			protopack.Tag{1, protopack.StartGroupType},
+			protopack.Tag{2, protopack.VarintType}, protopack.Varint(1001),
+			protopack.Tag{3, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(30),
+			}),
+			protopack.Tag{1, protopack.EndGroupType},
+			// Ext2, field2
+			protopack.Tag{1, protopack.StartGroupType},
+			protopack.Tag{2, protopack.VarintType}, protopack.Varint(1000),
+			protopack.Tag{3, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{2, protopack.VarintType}, protopack.Varint(20),
+			}),
+			protopack.Tag{1, protopack.EndGroupType},
+		}.Marshal(),
+	},
+	{
+		desc: "MessageSet with missing type_id",
+		decodeTo: []proto.Message{build(
+			&messagesetpb.MessageSet{},
+		)},
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.StartGroupType},
+			protopack.Tag{3, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(10),
+			}),
+			protopack.Tag{1, protopack.EndGroupType},
+		}.Marshal(),
+	},
+	{
+		desc: "MessageSet with missing message",
+		decodeTo: []proto.Message{build(
+			&messagesetpb.MessageSet{},
+			extend(msetextpb.E_Ext1_MessageSetExtension, &msetextpb.Ext1{}),
+		)},
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.StartGroupType},
+			protopack.Tag{2, protopack.VarintType}, protopack.Varint(1000),
+			protopack.Tag{1, protopack.EndGroupType},
+		}.Marshal(),
+	},
+	{
+		desc: "MessageSet with type id out of valid field number range",
+		decodeTo: []proto.Message{func() proto.Message {
+			m := &messagesetpb.MessageSetContainer{MessageSet: &messagesetpb.MessageSet{}}
+			proto.SetExtension(m.MessageSet, msetextpb.E_ExtLargeNumber_MessageSetExtension, &msetextpb.ExtLargeNumber{})
+			return m
+		}()},
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.StartGroupType},
+				protopack.Tag{2, protopack.VarintType}, protopack.Varint(protowire.MaxValidNumber + 1),
+				protopack.Tag{3, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{}),
+				protopack.Tag{1, protopack.EndGroupType},
+			}),
+		}.Marshal(),
+	},
+	{
+		desc: "MessageSet with unknown type id out of valid field number range",
+		decodeTo: []proto.Message{func() proto.Message {
+			m := &messagesetpb.MessageSetContainer{MessageSet: &messagesetpb.MessageSet{}}
+			m.MessageSet.ProtoReflect().SetUnknown(
+				protopack.Message{
+					protopack.Tag{protowire.MaxValidNumber + 2, protopack.BytesType}, protopack.LengthPrefix{},
+				}.Marshal(),
+			)
+			return m
+		}()},
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.StartGroupType},
+				protopack.Tag{2, protopack.VarintType}, protopack.Varint(protowire.MaxValidNumber + 2),
+				protopack.Tag{3, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{}),
+				protopack.Tag{1, protopack.EndGroupType},
+			}),
+		}.Marshal(),
+	},
+	{
+		desc: "MessageSet with unknown field",
+		decodeTo: []proto.Message{func() proto.Message {
+			m := &messagesetpb.MessageSetContainer{MessageSet: &messagesetpb.MessageSet{}}
+			proto.SetExtension(m.MessageSet, msetextpb.E_Ext1_MessageSetExtension, &msetextpb.Ext1{
+				Ext1Field1: proto.Int32(10),
+			})
+			return m
+		}()},
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.StartGroupType},
+				protopack.Tag{2, protopack.VarintType}, protopack.Varint(1000),
+				protopack.Tag{3, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+					protopack.Tag{1, protopack.VarintType}, protopack.Varint(10),
+				}),
+				protopack.Tag{4, protopack.VarintType}, protopack.Varint(0),
+				protopack.Tag{1, protopack.EndGroupType},
+			}),
+		}.Marshal(),
+	},
+	{
+		desc:          "MessageSet with required field set",
+		checkFastInit: true,
+		decodeTo: []proto.Message{func() proto.Message {
+			m := &messagesetpb.MessageSetContainer{MessageSet: &messagesetpb.MessageSet{}}
+			proto.SetExtension(m.MessageSet, msetextpb.E_ExtRequired_MessageSetExtension, &msetextpb.ExtRequired{
+				RequiredField1: proto.Int32(1),
+			})
+			return m
+		}()},
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.StartGroupType},
+				protopack.Tag{2, protopack.VarintType}, protopack.Varint(1002),
+				protopack.Tag{3, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+					protopack.Tag{1, protopack.VarintType}, protopack.Varint(1),
+				}),
+				protopack.Tag{1, protopack.EndGroupType},
+			}),
+		}.Marshal(),
+	},
+	{
+		desc:          "MessageSet with required field unset",
+		checkFastInit: true,
+		partial:       true,
+		decodeTo: []proto.Message{func() proto.Message {
+			m := &messagesetpb.MessageSetContainer{MessageSet: &messagesetpb.MessageSet{}}
+			proto.SetExtension(m.MessageSet, msetextpb.E_ExtRequired_MessageSetExtension, &msetextpb.ExtRequired{})
+			return m
+		}()},
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.StartGroupType},
+				protopack.Tag{2, protopack.VarintType}, protopack.Varint(1002),
+				protopack.Tag{3, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{}),
+				protopack.Tag{1, protopack.EndGroupType},
+			}),
+		}.Marshal(),
+	},
+}
+
+var messageSetInvalidTestProtos = []testProto{
+	{
+		desc: "MessageSet with type id 0",
+		decodeTo: []proto.Message{
+			(*messagesetpb.MessageSetContainer)(nil),
+		},
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.StartGroupType},
+				protopack.Tag{2, protopack.VarintType}, protopack.Uvarint(0),
+				protopack.Tag{3, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{}),
+				protopack.Tag{1, protopack.EndGroupType},
+			}),
+		}.Marshal(),
+	},
+	{
+		desc: "MessageSet with type id overflowing int32",
+		decodeTo: []proto.Message{
+			(*messagesetpb.MessageSetContainer)(nil),
+		},
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.StartGroupType},
+				protopack.Tag{2, protopack.VarintType}, protopack.Uvarint(0x80000000),
+				protopack.Tag{3, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{}),
+				protopack.Tag{1, protopack.EndGroupType},
+			}),
+		}.Marshal(),
+	},
+}
diff --git a/vendor/google.golang.org/protobuf/proto/methods_test.go b/vendor/google.golang.org/protobuf/proto/methods_test.go
new file mode 100644
index 000000000..b1dcce367
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/proto/methods_test.go
@@ -0,0 +1,184 @@
+// Copyright 2019 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.
+
+// The protoreflect tag disables fast-path methods, including legacy ones.
+// +build !protoreflect
+
+package proto_test
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"testing"
+
+	"google.golang.org/protobuf/internal/impl"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/runtime/protoiface"
+
+	legacypb "google.golang.org/protobuf/internal/testprotos/legacy"
+)
+
+type selfMarshaler struct {
+	bytes []byte
+	err   error
+}
+
+func (m selfMarshaler) Reset()        {}
+func (m selfMarshaler) ProtoMessage() {}
+
+func (m selfMarshaler) String() string {
+	return fmt.Sprintf("selfMarshaler{bytes:%v, err:%v}", m.bytes, m.err)
+}
+
+func (m selfMarshaler) Marshal() ([]byte, error) {
+	return m.bytes, m.err
+}
+
+func (m *selfMarshaler) Unmarshal(b []byte) error {
+	m.bytes = b
+	return m.err
+}
+
+func TestLegacyMarshalMethod(t *testing.T) {
+	for _, test := range []selfMarshaler{
+		{bytes: []byte("marshal")},
+		{bytes: []byte("marshal"), err: errors.New("some error")},
+	} {
+		m := impl.Export{}.MessageOf(test).Interface()
+		b, err := proto.Marshal(m)
+		if err != test.err || !bytes.Equal(b, test.bytes) {
+			t.Errorf("proto.Marshal(%v) = %v, %v; want %v, %v", test, b, err, test.bytes, test.err)
+		}
+		if gotSize, wantSize := proto.Size(m), len(test.bytes); gotSize != wantSize {
+			t.Fatalf("proto.Size(%v) = %v, want %v", test, gotSize, wantSize)
+		}
+
+		prefix := []byte("prefix")
+		want := append(prefix, test.bytes...)
+		b, err = proto.MarshalOptions{}.MarshalAppend(prefix, m)
+		if err != test.err || !bytes.Equal(b, want) {
+			t.Errorf("MarshalAppend(%v, %v) = %v, %v; want %v, %v", prefix, test, b, err, test.bytes, test.err)
+		}
+
+		b, err = proto.MarshalOptions{
+			Deterministic: true,
+		}.MarshalAppend(nil, m)
+		if err != test.err || !bytes.Equal(b, test.bytes) {
+			t.Errorf("MarshalOptions{Deterministic:true}.MarshalAppend(nil, %v) = %v, %v; want %v, %v", test, b, err, test.bytes, test.err)
+		}
+	}
+}
+
+func TestLegacyUnmarshalMethod(t *testing.T) {
+	sm := &selfMarshaler{}
+	m := impl.Export{}.MessageOf(sm).Interface()
+	want := []byte("unmarshal")
+	if err := proto.Unmarshal(want, m); err != nil {
+		t.Fatalf("proto.Unmarshal(selfMarshaler{}) = %v, want nil", err)
+	}
+	if !bytes.Equal(sm.bytes, want) {
+		t.Fatalf("proto.Unmarshal(selfMarshaler{}): Marshal method not called")
+	}
+}
+
+type descPanicSelfMarshaler struct{}
+
+const descPanicSelfMarshalerBytes = "bytes"
+
+func (m *descPanicSelfMarshaler) Reset()                      {}
+func (m *descPanicSelfMarshaler) ProtoMessage()               {}
+func (m *descPanicSelfMarshaler) Descriptor() ([]byte, []int) { panic("Descriptor method panics") }
+func (m *descPanicSelfMarshaler) String() string              { return "descPanicSelfMarshaler{}" }
+func (m *descPanicSelfMarshaler) Marshal() ([]byte, error) {
+	return []byte(descPanicSelfMarshalerBytes), nil
+}
+
+func TestSelfMarshalerDescriptorPanics(t *testing.T) {
+	m := &descPanicSelfMarshaler{}
+	got, err := proto.Marshal(impl.Export{}.MessageOf(m).Interface())
+	want := []byte(descPanicSelfMarshalerBytes)
+	if err != nil || !bytes.Equal(got, want) {
+		t.Fatalf("proto.Marshal(%v) = %v, %v; want %v, nil", m, got, err, want)
+	}
+}
+
+type descSelfMarshaler struct {
+	someField int // some non-generated field
+}
+
+const descSelfMarshalerBytes = "bytes"
+
+func (m *descSelfMarshaler) Reset()        {}
+func (m *descSelfMarshaler) ProtoMessage() {}
+func (m *descSelfMarshaler) Descriptor() ([]byte, []int) {
+	return ((*legacypb.Legacy)(nil)).GetF1().Descriptor()
+}
+func (m *descSelfMarshaler) String() string {
+	return "descSelfMarshaler{}"
+}
+func (m *descSelfMarshaler) Marshal() ([]byte, error) {
+	return []byte(descSelfMarshalerBytes), nil
+}
+
+func TestSelfMarshalerWithDescriptor(t *testing.T) {
+	m := &descSelfMarshaler{}
+	got, err := proto.Marshal(impl.Export{}.MessageOf(m).Interface())
+	want := []byte(descSelfMarshalerBytes)
+	if err != nil || !bytes.Equal(got, want) {
+		t.Fatalf("proto.Marshal(%v) = %v, %v; want %v, nil", m, got, err, want)
+	}
+}
+
+func TestDecodeFastCheckInitialized(t *testing.T) {
+	for _, test := range testValidMessages {
+		if !test.checkFastInit {
+			continue
+		}
+		for _, message := range test.decodeTo {
+			t.Run(fmt.Sprintf("%s (%T)", test.desc, message), func(t *testing.T) {
+				m := message.ProtoReflect().New()
+				opts := proto.UnmarshalOptions{
+					AllowPartial: true,
+				}
+				out, err := opts.UnmarshalState(protoiface.UnmarshalInput{
+					Buf:     test.wire,
+					Message: m,
+				})
+				if err != nil {
+					t.Fatalf("Unmarshal error: %v", err)
+				}
+				if got, want := (out.Flags&protoiface.UnmarshalInitialized != 0), !test.partial; got != want {
+					t.Errorf("out.Initialized = %v, want %v", got, want)
+				}
+			})
+		}
+	}
+}
+
+type selfMerger struct {
+	src protoiface.MessageV1
+}
+
+func (*selfMerger) Reset()         {}
+func (*selfMerger) ProtoMessage()  {}
+func (*selfMerger) String() string { return "selfMerger{}" }
+func (m *selfMerger) Merge(src protoiface.MessageV1) {
+	m.src = src
+}
+
+func TestLegacyMergeMethod(t *testing.T) {
+	src := &selfMerger{}
+	dst := &selfMerger{}
+	proto.Merge(
+		impl.Export{}.MessageOf(dst).Interface(),
+		impl.Export{}.MessageOf(src).Interface(),
+	)
+	if got, want := dst.src, src; got != want {
+		t.Errorf("Merge(dst, src): want dst.src = src, got %v", got)
+	}
+	if got := src.src; got != nil {
+		t.Errorf("Merge(dst, src): want src.src = nil, got %v", got)
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/proto/nil_test.go b/vendor/google.golang.org/protobuf/proto/nil_test.go
new file mode 100644
index 000000000..29d259d7d
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/proto/nil_test.go
@@ -0,0 +1,176 @@
+// Copyright 2020 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 proto_test
+
+import (
+	"testing"
+
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protoreflect"
+
+	testpb "google.golang.org/protobuf/internal/testprotos/test"
+)
+
+// TestNil tests for boundary conditions when nil and typed-nil messages
+// are passed to various top-level functions.
+// These tests are not necessarily a statement of proper behavior,
+// but exist to detect accidental changes in behavior.
+func TestNil(t *testing.T) {
+	nilMsg := (*testpb.TestAllExtensions)(nil)
+	extType := testpb.E_OptionalBool
+	extRanger := func(protoreflect.ExtensionType, interface{}) bool { return true }
+
+	tests := []struct {
+		label string
+		test  func()
+		panic bool
+	}{{
+		label: "Size",
+		test:  func() { proto.Size(nil) },
+	}, {
+		label: "Size",
+		test:  func() { proto.Size(nilMsg) },
+	}, {
+		label: "Marshal",
+		test:  func() { proto.Marshal(nil) },
+	}, {
+		label: "Marshal",
+		test:  func() { proto.Marshal(nilMsg) },
+	}, {
+		label: "Unmarshal",
+		test:  func() { proto.Unmarshal(nil, nil) },
+		panic: true,
+	}, {
+		label: "Unmarshal",
+		test:  func() { proto.Unmarshal(nil, nilMsg) },
+		panic: true,
+	}, {
+		label: "Merge",
+		test:  func() { proto.Merge(nil, nil) },
+		panic: true,
+	}, {
+		label: "Merge",
+		test:  func() { proto.Merge(nil, nilMsg) },
+		panic: true,
+	}, {
+		label: "Merge",
+		test:  func() { proto.Merge(nilMsg, nil) },
+		panic: true,
+	}, {
+		label: "Merge",
+		test:  func() { proto.Merge(nilMsg, nilMsg) },
+		panic: true,
+	}, {
+		label: "Clone",
+		test:  func() { proto.Clone(nil) },
+	}, {
+		label: "Clone",
+		test:  func() { proto.Clone(nilMsg) },
+	}, {
+		label: "Equal",
+		test:  func() { proto.Equal(nil, nil) },
+	}, {
+		label: "Equal",
+		test:  func() { proto.Equal(nil, nilMsg) },
+	}, {
+		label: "Equal",
+		test:  func() { proto.Equal(nilMsg, nil) },
+	}, {
+		label: "Equal",
+		test:  func() { proto.Equal(nilMsg, nilMsg) },
+	}, {
+		label: "Reset",
+		test:  func() { proto.Reset(nil) },
+		panic: true,
+	}, {
+		label: "Reset",
+		test:  func() { proto.Reset(nilMsg) },
+		panic: true,
+	}, {
+		label: "HasExtension",
+		test:  func() { proto.HasExtension(nil, nil) },
+	}, {
+		label: "HasExtension",
+		test:  func() { proto.HasExtension(nil, extType) },
+	}, {
+		label: "HasExtension",
+		test:  func() { proto.HasExtension(nilMsg, nil) },
+	}, {
+		label: "HasExtension",
+		test:  func() { proto.HasExtension(nilMsg, extType) },
+	}, {
+		label: "GetExtension",
+		test:  func() { proto.GetExtension(nil, nil) },
+		panic: true,
+	}, {
+		label: "GetExtension",
+		test:  func() { proto.GetExtension(nil, extType) },
+	}, {
+		label: "GetExtension",
+		test:  func() { proto.GetExtension(nilMsg, nil) },
+		panic: true,
+	}, {
+		label: "GetExtension",
+		test:  func() { proto.GetExtension(nilMsg, extType) },
+	}, {
+		label: "SetExtension",
+		test:  func() { proto.SetExtension(nil, nil, true) },
+		panic: true,
+	}, {
+		label: "SetExtension",
+		test:  func() { proto.SetExtension(nil, extType, true) },
+		panic: true,
+	}, {
+		label: "SetExtension",
+		test:  func() { proto.SetExtension(nilMsg, nil, true) },
+		panic: true,
+	}, {
+		label: "SetExtension",
+		test:  func() { proto.SetExtension(nilMsg, extType, true) },
+		panic: true,
+	}, {
+		label: "ClearExtension",
+		test:  func() { proto.ClearExtension(nil, nil) },
+		panic: true,
+	}, {
+		label: "ClearExtension",
+		test:  func() { proto.ClearExtension(nil, extType) },
+		panic: true,
+	}, {
+		label: "ClearExtension",
+		test:  func() { proto.ClearExtension(nilMsg, nil) },
+		panic: true,
+	}, {
+		label: "ClearExtension",
+		test:  func() { proto.ClearExtension(nilMsg, extType) },
+		panic: true,
+	}, {
+		label: "RangeExtensions",
+		test:  func() { proto.RangeExtensions(nil, nil) },
+	}, {
+		label: "RangeExtensions",
+		test:  func() { proto.RangeExtensions(nil, extRanger) },
+	}, {
+		label: "RangeExtensions",
+		test:  func() { proto.RangeExtensions(nilMsg, nil) },
+	}, {
+		label: "RangeExtensions",
+		test:  func() { proto.RangeExtensions(nilMsg, extRanger) },
+	}}
+
+	for _, tt := range tests {
+		t.Run(tt.label, func(t *testing.T) {
+			defer func() {
+				switch gotPanic := recover() != nil; {
+				case gotPanic && !tt.panic:
+					t.Errorf("unexpected panic")
+				case !gotPanic && tt.panic:
+					t.Errorf("expected panic")
+				}
+			}()
+			tt.test()
+		})
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/proto/noenforceutf8_test.go b/vendor/google.golang.org/protobuf/proto/noenforceutf8_test.go
new file mode 100644
index 000000000..2bd011efe
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/proto/noenforceutf8_test.go
@@ -0,0 +1,146 @@
+// Copyright 2019 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 proto_test
+
+import (
+	"reflect"
+
+	"google.golang.org/protobuf/encoding/prototext"
+	"google.golang.org/protobuf/internal/filedesc"
+	"google.golang.org/protobuf/internal/flags"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protodesc"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/runtime/protoimpl"
+	"google.golang.org/protobuf/testing/protopack"
+
+	"google.golang.org/protobuf/types/descriptorpb"
+)
+
+func init() {
+	if flags.ProtoLegacy {
+		testValidMessages = append(testValidMessages, noEnforceUTF8TestProtos...)
+	} else {
+		testInvalidMessages = append(testInvalidMessages, noEnforceUTF8TestProtos...)
+	}
+}
+
+var noEnforceUTF8TestProtos = []testProto{
+	{
+		desc: "invalid UTF-8 in optional string field",
+		decodeTo: []proto.Message{&TestNoEnforceUTF8{
+			OptionalString: string("abc\xff"),
+		}},
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.BytesType}, protopack.String("abc\xff"),
+		}.Marshal(),
+	},
+	{
+		desc: "invalid UTF-8 in optional string field of Go bytes",
+		decodeTo: []proto.Message{&TestNoEnforceUTF8{
+			OptionalBytes: []byte("abc\xff"),
+		}},
+		wire: protopack.Message{
+			protopack.Tag{2, protopack.BytesType}, protopack.String("abc\xff"),
+		}.Marshal(),
+	},
+	{
+		desc: "invalid UTF-8 in repeated string field",
+		decodeTo: []proto.Message{&TestNoEnforceUTF8{
+			RepeatedString: []string{string("foo"), string("abc\xff")},
+		}},
+		wire: protopack.Message{
+			protopack.Tag{3, protopack.BytesType}, protopack.String("foo"),
+			protopack.Tag{3, protopack.BytesType}, protopack.String("abc\xff"),
+		}.Marshal(),
+	},
+	{
+		desc: "invalid UTF-8 in repeated string field of Go bytes",
+		decodeTo: []proto.Message{&TestNoEnforceUTF8{
+			RepeatedBytes: [][]byte{[]byte("foo"), []byte("abc\xff")},
+		}},
+		wire: protopack.Message{
+			protopack.Tag{4, protopack.BytesType}, protopack.String("foo"),
+			protopack.Tag{4, protopack.BytesType}, protopack.String("abc\xff"),
+		}.Marshal(),
+	},
+	{
+		desc: "invalid UTF-8 in oneof string field",
+		decodeTo: []proto.Message{
+			&TestNoEnforceUTF8{OneofField: &TestNoEnforceUTF8_OneofString{string("abc\xff")}},
+		},
+		wire: protopack.Message{protopack.Tag{5, protopack.BytesType}, protopack.String("abc\xff")}.Marshal(),
+	},
+	{
+		desc: "invalid UTF-8 in oneof string field of Go bytes",
+		decodeTo: []proto.Message{
+			&TestNoEnforceUTF8{OneofField: &TestNoEnforceUTF8_OneofBytes{[]byte("abc\xff")}},
+		},
+		wire: protopack.Message{protopack.Tag{6, protopack.BytesType}, protopack.String("abc\xff")}.Marshal(),
+	},
+}
+
+type TestNoEnforceUTF8 struct {
+	OptionalString string       `protobuf:"bytes,1,opt,name=optional_string"`
+	OptionalBytes  []byte       `protobuf:"bytes,2,opt,name=optional_bytes"`
+	RepeatedString []string     `protobuf:"bytes,3,rep,name=repeated_string"`
+	RepeatedBytes  [][]byte     `protobuf:"bytes,4,rep,name=repeated_bytes"`
+	OneofField     isOneofField `protobuf_oneof:"oneof_field"`
+}
+
+type isOneofField interface{ isOneofField() }
+
+type TestNoEnforceUTF8_OneofString struct {
+	OneofString string `protobuf:"bytes,5,opt,name=oneof_string,oneof"`
+}
+type TestNoEnforceUTF8_OneofBytes struct {
+	OneofBytes []byte `protobuf:"bytes,6,opt,name=oneof_bytes,oneof"`
+}
+
+func (*TestNoEnforceUTF8_OneofString) isOneofField() {}
+func (*TestNoEnforceUTF8_OneofBytes) isOneofField()  {}
+
+func (m *TestNoEnforceUTF8) ProtoReflect() protoreflect.Message {
+	return messageInfo_TestNoEnforceUTF8.MessageOf(m)
+}
+
+var messageInfo_TestNoEnforceUTF8 = protoimpl.MessageInfo{
+	GoReflectType: reflect.TypeOf((*TestNoEnforceUTF8)(nil)),
+	Desc: func() protoreflect.MessageDescriptor {
+		pb := new(descriptorpb.FileDescriptorProto)
+		if err := prototext.Unmarshal([]byte(`
+				syntax:  "proto3"
+				name:    "test.proto"
+				message_type: [{
+					name: "TestNoEnforceUTF8"
+					field: [
+						{name:"optional_string" number:1 label:LABEL_OPTIONAL type:TYPE_STRING},
+						{name:"optional_bytes"  number:2 label:LABEL_OPTIONAL type:TYPE_STRING},
+						{name:"repeated_string" number:3 label:LABEL_REPEATED type:TYPE_STRING},
+						{name:"repeated_bytes"  number:4 label:LABEL_REPEATED type:TYPE_STRING},
+						{name:"oneof_string"    number:5 label:LABEL_OPTIONAL type:TYPE_STRING, oneof_index:0},
+						{name:"oneof_bytes"     number:6 label:LABEL_OPTIONAL type:TYPE_STRING, oneof_index:0}
+					]
+					oneof_decl: [{name:"oneof_field"}]
+				}]
+			`), pb); err != nil {
+			panic(err)
+		}
+		fd, err := protodesc.NewFile(pb, nil)
+		if err != nil {
+			panic(err)
+		}
+		md := fd.Messages().Get(0)
+		for i := 0; i < md.Fields().Len(); i++ {
+			md.Fields().Get(i).(*filedesc.Field).L1.HasEnforceUTF8 = true
+			md.Fields().Get(i).(*filedesc.Field).L1.EnforceUTF8 = false
+		}
+		return md
+	}(),
+	OneofWrappers: []interface{}{
+		(*TestNoEnforceUTF8_OneofString)(nil),
+		(*TestNoEnforceUTF8_OneofBytes)(nil),
+	},
+}
diff --git a/vendor/google.golang.org/protobuf/proto/proto.go b/vendor/google.golang.org/protobuf/proto/proto.go
new file mode 100644
index 000000000..ca14b09c3
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/proto/proto.go
@@ -0,0 +1,34 @@
+// 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 proto
+
+import (
+	"google.golang.org/protobuf/internal/errors"
+	"google.golang.org/protobuf/reflect/protoreflect"
+)
+
+// Message is the top-level interface that all messages must implement.
+// It provides access to a reflective view of a message.
+// Any implementation of this interface may be used with all functions in the
+// protobuf module that accept a Message, except where otherwise specified.
+//
+// This is the v2 interface definition for protobuf messages.
+// The v1 interface definition is "github.com/golang/protobuf/proto".Message.
+//
+// To convert a v1 message to a v2 message,
+// use "github.com/golang/protobuf/proto".MessageV2.
+// To convert a v2 message to a v1 message,
+// use "github.com/golang/protobuf/proto".MessageV1.
+type Message = protoreflect.ProtoMessage
+
+// Error matches all errors produced by packages in the protobuf module.
+//
+// That is, errors.Is(err, Error) reports whether an error is produced
+// by this module.
+var Error error
+
+func init() {
+	Error = errors.Error
+}
diff --git a/vendor/google.golang.org/protobuf/proto/proto_methods.go b/vendor/google.golang.org/protobuf/proto/proto_methods.go
new file mode 100644
index 000000000..d8dd604f6
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/proto/proto_methods.go
@@ -0,0 +1,19 @@
+// Copyright 2019 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.
+
+// The protoreflect build tag disables use of fast-path methods.
+// +build !protoreflect
+
+package proto
+
+import (
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/runtime/protoiface"
+)
+
+const hasProtoMethods = true
+
+func protoMethods(m protoreflect.Message) *protoiface.Methods {
+	return m.ProtoMethods()
+}
diff --git a/vendor/google.golang.org/protobuf/proto/proto_reflect.go b/vendor/google.golang.org/protobuf/proto/proto_reflect.go
new file mode 100644
index 000000000..b103d4320
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/proto/proto_reflect.go
@@ -0,0 +1,19 @@
+// Copyright 2019 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.
+
+// The protoreflect build tag disables use of fast-path methods.
+// +build protoreflect
+
+package proto
+
+import (
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/runtime/protoiface"
+)
+
+const hasProtoMethods = false
+
+func protoMethods(m protoreflect.Message) *protoiface.Methods {
+	return nil
+}
diff --git a/vendor/google.golang.org/protobuf/proto/reset.go b/vendor/google.golang.org/protobuf/proto/reset.go
new file mode 100644
index 000000000..3d7f89436
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/proto/reset.go
@@ -0,0 +1,43 @@
+// Copyright 2019 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 proto
+
+import (
+	"fmt"
+
+	"google.golang.org/protobuf/reflect/protoreflect"
+)
+
+// Reset clears every field in the message.
+// The resulting message shares no observable memory with its previous state
+// other than the memory for the message itself.
+func Reset(m Message) {
+	if mr, ok := m.(interface{ Reset() }); ok && hasProtoMethods {
+		mr.Reset()
+		return
+	}
+	resetMessage(m.ProtoReflect())
+}
+
+func resetMessage(m protoreflect.Message) {
+	if !m.IsValid() {
+		panic(fmt.Sprintf("cannot reset invalid %v message", m.Descriptor().FullName()))
+	}
+
+	// Clear all known fields.
+	fds := m.Descriptor().Fields()
+	for i := 0; i < fds.Len(); i++ {
+		m.Clear(fds.Get(i))
+	}
+
+	// Clear extension fields.
+	m.Range(func(fd protoreflect.FieldDescriptor, _ protoreflect.Value) bool {
+		m.Clear(fd)
+		return true
+	})
+
+	// Clear unknown fields.
+	m.SetUnknown(nil)
+}
diff --git a/vendor/google.golang.org/protobuf/proto/reset_test.go b/vendor/google.golang.org/protobuf/proto/reset_test.go
new file mode 100644
index 000000000..0048b566f
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/proto/reset_test.go
@@ -0,0 +1,58 @@
+// Copyright 2019 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 proto_test
+
+import (
+	"testing"
+
+	"google.golang.org/protobuf/proto"
+
+	testpb "google.golang.org/protobuf/internal/testprotos/test"
+)
+
+func TestReset(t *testing.T) {
+	m := &testpb.TestAllTypes{
+		OptionalSfixed64:       proto.Int64(5),
+		RepeatedInt32:          []int32{},
+		RepeatedFloat:          []float32{1.234, 5.678},
+		MapFixed64Fixed64:      map[uint64]uint64{5: 7},
+		MapStringString:        map[string]string{},
+		OptionalForeignMessage: &testpb.ForeignMessage{},
+		OneofField:             (*testpb.TestAllTypes_OneofUint32)(nil),
+		OneofOptional:          (*testpb.TestAllTypes_OneofOptionalUint32)(nil),
+	}
+	m.ProtoReflect().SetUnknown([]byte{})
+
+	proto.Reset(m)
+
+	if m.OptionalSfixed64 != nil {
+		t.Errorf("m.OptionalSfixed64 = %p, want nil", m.OptionalSfixed64)
+	}
+	if m.RepeatedInt32 != nil {
+		t.Errorf("m.RepeatedInt32 = %p, want nil", m.RepeatedInt32)
+	}
+	if m.RepeatedFloat != nil {
+		t.Errorf("m.RepeatedFloat = %p, want nil", m.RepeatedFloat)
+	}
+	if m.MapFixed64Fixed64 != nil {
+		t.Errorf("m.MapFixed64Fixed64 = %p, want nil", m.MapFixed64Fixed64)
+	}
+	if m.MapStringString != nil {
+		t.Errorf("m.MapStringString = %p, want nil", m.MapStringString)
+	}
+	if m.OptionalForeignMessage != nil {
+		t.Errorf("m.OptionalForeignMessage = %p, want nil", m.OptionalForeignMessage)
+	}
+	if m.OneofField != nil {
+		t.Errorf("m.OneofField = %p, want nil", m.OneofField)
+	}
+	if m.OneofOptional != nil {
+		t.Errorf("m.OneofOptional = %p, want nil", m.OneofOptional)
+	}
+
+	if got := m.ProtoReflect().GetUnknown(); got != nil {
+		t.Errorf("m.ProtoReflect().GetUnknown() = %d, want nil", got)
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/proto/size.go b/vendor/google.golang.org/protobuf/proto/size.go
new file mode 100644
index 000000000..11ba84146
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/proto/size.go
@@ -0,0 +1,94 @@
+// Copyright 2019 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 proto
+
+import (
+	"google.golang.org/protobuf/encoding/protowire"
+	"google.golang.org/protobuf/internal/encoding/messageset"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/runtime/protoiface"
+)
+
+// Size returns the size in bytes of the wire-format encoding of m.
+func Size(m Message) int {
+	return MarshalOptions{}.Size(m)
+}
+
+// Size returns the size in bytes of the wire-format encoding of m.
+func (o MarshalOptions) Size(m Message) int {
+	// Treat a nil message interface as an empty message; nothing to output.
+	if m == nil {
+		return 0
+	}
+
+	return sizeMessage(m.ProtoReflect())
+}
+
+func sizeMessage(m protoreflect.Message) (size int) {
+	methods := protoMethods(m)
+	if methods != nil && methods.Size != nil {
+		out := methods.Size(protoiface.SizeInput{
+			Message: m,
+		})
+		return out.Size
+	}
+	if methods != nil && methods.Marshal != nil {
+		// This is not efficient, but we don't have any choice.
+		// This case is mainly used for legacy types with a Marshal method.
+		out, _ := methods.Marshal(protoiface.MarshalInput{
+			Message: m,
+		})
+		return len(out.Buf)
+	}
+	return sizeMessageSlow(m)
+}
+
+func sizeMessageSlow(m protoreflect.Message) (size int) {
+	if messageset.IsMessageSet(m.Descriptor()) {
+		return sizeMessageSet(m)
+	}
+	m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
+		size += sizeField(fd, v)
+		return true
+	})
+	size += len(m.GetUnknown())
+	return size
+}
+
+func sizeField(fd protoreflect.FieldDescriptor, value protoreflect.Value) (size int) {
+	num := fd.Number()
+	switch {
+	case fd.IsList():
+		return sizeList(num, fd, value.List())
+	case fd.IsMap():
+		return sizeMap(num, fd, value.Map())
+	default:
+		return protowire.SizeTag(num) + sizeSingular(num, fd.Kind(), value)
+	}
+}
+
+func sizeList(num protowire.Number, fd protoreflect.FieldDescriptor, list protoreflect.List) (size int) {
+	if fd.IsPacked() && list.Len() > 0 {
+		content := 0
+		for i, llen := 0, list.Len(); i < llen; i++ {
+			content += sizeSingular(num, fd.Kind(), list.Get(i))
+		}
+		return protowire.SizeTag(num) + protowire.SizeBytes(content)
+	}
+
+	for i, llen := 0, list.Len(); i < llen; i++ {
+		size += protowire.SizeTag(num) + sizeSingular(num, fd.Kind(), list.Get(i))
+	}
+	return size
+}
+
+func sizeMap(num protowire.Number, fd protoreflect.FieldDescriptor, mapv protoreflect.Map) (size int) {
+	mapv.Range(func(key protoreflect.MapKey, value protoreflect.Value) bool {
+		size += protowire.SizeTag(num)
+		size += protowire.SizeBytes(sizeField(fd.MapKey(), key.Value()) + sizeField(fd.MapValue(), value))
+		return true
+	})
+	return size
+}
diff --git a/vendor/google.golang.org/protobuf/proto/size_gen.go b/vendor/google.golang.org/protobuf/proto/size_gen.go
new file mode 100644
index 000000000..1118460f6
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/proto/size_gen.go
@@ -0,0 +1,55 @@
+// 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.
+
+// Code generated by generate-types. DO NOT EDIT.
+
+package proto
+
+import (
+	"google.golang.org/protobuf/encoding/protowire"
+	"google.golang.org/protobuf/reflect/protoreflect"
+)
+
+func sizeSingular(num protowire.Number, kind protoreflect.Kind, v protoreflect.Value) int {
+	switch kind {
+	case protoreflect.BoolKind:
+		return protowire.SizeVarint(protowire.EncodeBool(v.Bool()))
+	case protoreflect.EnumKind:
+		return protowire.SizeVarint(uint64(v.Enum()))
+	case protoreflect.Int32Kind:
+		return protowire.SizeVarint(uint64(int32(v.Int())))
+	case protoreflect.Sint32Kind:
+		return protowire.SizeVarint(protowire.EncodeZigZag(int64(int32(v.Int()))))
+	case protoreflect.Uint32Kind:
+		return protowire.SizeVarint(uint64(uint32(v.Uint())))
+	case protoreflect.Int64Kind:
+		return protowire.SizeVarint(uint64(v.Int()))
+	case protoreflect.Sint64Kind:
+		return protowire.SizeVarint(protowire.EncodeZigZag(v.Int()))
+	case protoreflect.Uint64Kind:
+		return protowire.SizeVarint(v.Uint())
+	case protoreflect.Sfixed32Kind:
+		return protowire.SizeFixed32()
+	case protoreflect.Fixed32Kind:
+		return protowire.SizeFixed32()
+	case protoreflect.FloatKind:
+		return protowire.SizeFixed32()
+	case protoreflect.Sfixed64Kind:
+		return protowire.SizeFixed64()
+	case protoreflect.Fixed64Kind:
+		return protowire.SizeFixed64()
+	case protoreflect.DoubleKind:
+		return protowire.SizeFixed64()
+	case protoreflect.StringKind:
+		return protowire.SizeBytes(len(v.String()))
+	case protoreflect.BytesKind:
+		return protowire.SizeBytes(len(v.Bytes()))
+	case protoreflect.MessageKind:
+		return protowire.SizeBytes(sizeMessage(v.Message()))
+	case protoreflect.GroupKind:
+		return protowire.SizeGroup(num, sizeMessage(v.Message()))
+	default:
+		return 0
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/proto/testmessages_test.go b/vendor/google.golang.org/protobuf/proto/testmessages_test.go
new file mode 100644
index 000000000..9979d7796
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/proto/testmessages_test.go
@@ -0,0 +1,2025 @@
+// Copyright 2019 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 proto_test
+
+import (
+	"google.golang.org/protobuf/encoding/protowire"
+	"google.golang.org/protobuf/internal/impl"
+	"google.golang.org/protobuf/internal/protobuild"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/reflect/protoregistry"
+	"google.golang.org/protobuf/testing/protopack"
+
+	legacypb "google.golang.org/protobuf/internal/testprotos/legacy"
+	requiredpb "google.golang.org/protobuf/internal/testprotos/required"
+	testpb "google.golang.org/protobuf/internal/testprotos/test"
+	test3pb "google.golang.org/protobuf/internal/testprotos/test3"
+)
+
+type testProto struct {
+	desc             string
+	decodeTo         []proto.Message
+	wire             []byte
+	partial          bool
+	noEncode         bool
+	checkFastInit    bool
+	unmarshalOptions proto.UnmarshalOptions
+	validationStatus impl.ValidationStatus
+	nocheckValidInit bool
+}
+
+func makeMessages(in protobuild.Message, messages ...proto.Message) []proto.Message {
+	if len(messages) == 0 {
+		messages = []proto.Message{
+			&testpb.TestAllTypes{},
+			&test3pb.TestAllTypes{},
+			&testpb.TestAllExtensions{},
+		}
+	}
+	for _, m := range messages {
+		in.Build(m.ProtoReflect())
+	}
+	return messages
+}
+
+func templateMessages(messages ...proto.Message) []protoreflect.MessageType {
+	if len(messages) == 0 {
+		messages = []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+			(*test3pb.TestAllTypes)(nil),
+			(*testpb.TestAllExtensions)(nil),
+		}
+	}
+	var out []protoreflect.MessageType
+	for _, m := range messages {
+		out = append(out, m.ProtoReflect().Type())
+	}
+	return out
+
+}
+
+var testValidMessages = []testProto{
+	{
+		desc:          "basic scalar types",
+		checkFastInit: true,
+		decodeTo: makeMessages(protobuild.Message{
+			"optional_int32":       1001,
+			"optional_int64":       1002,
+			"optional_uint32":      1003,
+			"optional_uint64":      1004,
+			"optional_sint32":      1005,
+			"optional_sint64":      1006,
+			"optional_fixed32":     1007,
+			"optional_fixed64":     1008,
+			"optional_sfixed32":    1009,
+			"optional_sfixed64":    1010,
+			"optional_float":       1011.5,
+			"optional_double":      1012.5,
+			"optional_bool":        true,
+			"optional_string":      "string",
+			"optional_bytes":       []byte("bytes"),
+			"optional_nested_enum": "BAR",
+		}),
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.VarintType}, protopack.Varint(1001),
+			protopack.Tag{2, protopack.VarintType}, protopack.Varint(1002),
+			protopack.Tag{3, protopack.VarintType}, protopack.Uvarint(1003),
+			protopack.Tag{4, protopack.VarintType}, protopack.Uvarint(1004),
+			protopack.Tag{5, protopack.VarintType}, protopack.Svarint(1005),
+			protopack.Tag{6, protopack.VarintType}, protopack.Svarint(1006),
+			protopack.Tag{7, protopack.Fixed32Type}, protopack.Uint32(1007),
+			protopack.Tag{8, protopack.Fixed64Type}, protopack.Uint64(1008),
+			protopack.Tag{9, protopack.Fixed32Type}, protopack.Int32(1009),
+			protopack.Tag{10, protopack.Fixed64Type}, protopack.Int64(1010),
+			protopack.Tag{11, protopack.Fixed32Type}, protopack.Float32(1011.5),
+			protopack.Tag{12, protopack.Fixed64Type}, protopack.Float64(1012.5),
+			protopack.Tag{13, protopack.VarintType}, protopack.Bool(true),
+			protopack.Tag{14, protopack.BytesType}, protopack.String("string"),
+			protopack.Tag{15, protopack.BytesType}, protopack.Bytes([]byte("bytes")),
+			protopack.Tag{21, protopack.VarintType}, protopack.Varint(int(testpb.TestAllTypes_BAR)),
+		}.Marshal(),
+	},
+	{
+		desc: "zero values",
+		decodeTo: makeMessages(protobuild.Message{
+			"optional_int32":    0,
+			"optional_int64":    0,
+			"optional_uint32":   0,
+			"optional_uint64":   0,
+			"optional_sint32":   0,
+			"optional_sint64":   0,
+			"optional_fixed32":  0,
+			"optional_fixed64":  0,
+			"optional_sfixed32": 0,
+			"optional_sfixed64": 0,
+			"optional_float":    0,
+			"optional_double":   0,
+			"optional_bool":     false,
+			"optional_string":   "",
+			"optional_bytes":    []byte{},
+		}),
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.VarintType}, protopack.Varint(0),
+			protopack.Tag{2, protopack.VarintType}, protopack.Varint(0),
+			protopack.Tag{3, protopack.VarintType}, protopack.Uvarint(0),
+			protopack.Tag{4, protopack.VarintType}, protopack.Uvarint(0),
+			protopack.Tag{5, protopack.VarintType}, protopack.Svarint(0),
+			protopack.Tag{6, protopack.VarintType}, protopack.Svarint(0),
+			protopack.Tag{7, protopack.Fixed32Type}, protopack.Uint32(0),
+			protopack.Tag{8, protopack.Fixed64Type}, protopack.Uint64(0),
+			protopack.Tag{9, protopack.Fixed32Type}, protopack.Int32(0),
+			protopack.Tag{10, protopack.Fixed64Type}, protopack.Int64(0),
+			protopack.Tag{11, protopack.Fixed32Type}, protopack.Float32(0),
+			protopack.Tag{12, protopack.Fixed64Type}, protopack.Float64(0),
+			protopack.Tag{13, protopack.VarintType}, protopack.Bool(false),
+			protopack.Tag{14, protopack.BytesType}, protopack.String(""),
+			protopack.Tag{15, protopack.BytesType}, protopack.Bytes(nil),
+		}.Marshal(),
+	},
+	{
+		desc: "proto3 zero values",
+		decodeTo: makeMessages(protobuild.Message{
+			"singular_int32":    0,
+			"singular_int64":    0,
+			"singular_uint32":   0,
+			"singular_uint64":   0,
+			"singular_sint32":   0,
+			"singular_sint64":   0,
+			"singular_fixed32":  0,
+			"singular_fixed64":  0,
+			"singular_sfixed32": 0,
+			"singular_sfixed64": 0,
+			"singular_float":    0,
+			"singular_double":   0,
+			"singular_bool":     false,
+			"singular_string":   "",
+			"singular_bytes":    []byte{},
+		}, &test3pb.TestAllTypes{}),
+		wire: protopack.Message{
+			protopack.Tag{81, protopack.VarintType}, protopack.Varint(0),
+			protopack.Tag{82, protopack.VarintType}, protopack.Varint(0),
+			protopack.Tag{83, protopack.VarintType}, protopack.Uvarint(0),
+			protopack.Tag{84, protopack.VarintType}, protopack.Uvarint(0),
+			protopack.Tag{85, protopack.VarintType}, protopack.Svarint(0),
+			protopack.Tag{86, protopack.VarintType}, protopack.Svarint(0),
+			protopack.Tag{87, protopack.Fixed32Type}, protopack.Uint32(0),
+			protopack.Tag{88, protopack.Fixed64Type}, protopack.Uint64(0),
+			protopack.Tag{89, protopack.Fixed32Type}, protopack.Int32(0),
+			protopack.Tag{90, protopack.Fixed64Type}, protopack.Int64(0),
+			protopack.Tag{91, protopack.Fixed32Type}, protopack.Float32(0),
+			protopack.Tag{92, protopack.Fixed64Type}, protopack.Float64(0),
+			protopack.Tag{93, protopack.VarintType}, protopack.Bool(false),
+			protopack.Tag{94, protopack.BytesType}, protopack.String(""),
+			protopack.Tag{95, protopack.BytesType}, protopack.Bytes(nil),
+		}.Marshal(),
+	},
+	{
+		desc: "groups",
+		decodeTo: makeMessages(protobuild.Message{
+			"optionalgroup": protobuild.Message{
+				"a":                 1017,
+				"same_field_number": 1016,
+			},
+		}, &testpb.TestAllTypes{}, &testpb.TestAllExtensions{}),
+		wire: protopack.Message{
+			protopack.Tag{16, protopack.StartGroupType},
+			protopack.Tag{17, protopack.VarintType}, protopack.Varint(1017),
+			protopack.Tag{16, protopack.VarintType}, protopack.Varint(1016),
+			protopack.Tag{16, protopack.EndGroupType},
+		}.Marshal(),
+	},
+	{
+		desc: "groups (field overridden)",
+		decodeTo: makeMessages(protobuild.Message{
+			"optionalgroup": protobuild.Message{
+				"a": 2,
+			},
+		}, &testpb.TestAllTypes{}, &testpb.TestAllExtensions{}),
+		wire: protopack.Message{
+			protopack.Tag{16, protopack.StartGroupType},
+			protopack.Tag{17, protopack.VarintType}, protopack.Varint(1),
+			protopack.Tag{16, protopack.EndGroupType},
+			protopack.Tag{16, protopack.StartGroupType},
+			protopack.Tag{17, protopack.VarintType}, protopack.Varint(2),
+			protopack.Tag{16, protopack.EndGroupType},
+		}.Marshal(),
+	},
+	{
+		desc: "messages",
+		decodeTo: makeMessages(protobuild.Message{
+			"optional_nested_message": protobuild.Message{
+				"a": 42,
+				"corecursive": protobuild.Message{
+					"optional_int32": 43,
+				},
+			},
+		}),
+		wire: protopack.Message{
+			protopack.Tag{18, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(42),
+				protopack.Tag{2, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+					protopack.Tag{1, protopack.VarintType}, protopack.Varint(43),
+				}),
+			}),
+		}.Marshal(),
+	},
+	{
+		desc: "messages (split across multiple tags)",
+		decodeTo: makeMessages(protobuild.Message{
+			"optional_nested_message": protobuild.Message{
+				"a": 42,
+				"corecursive": protobuild.Message{
+					"optional_int32": 43,
+				},
+			},
+		}),
+		wire: protopack.Message{
+			protopack.Tag{18, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(42),
+			}),
+			protopack.Tag{18, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{2, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+					protopack.Tag{1, protopack.VarintType}, protopack.Varint(43),
+				}),
+			}),
+		}.Marshal(),
+	},
+	{
+		desc: "messages (field overridden)",
+		decodeTo: makeMessages(protobuild.Message{
+			"optional_nested_message": protobuild.Message{
+				"a": 2,
+			},
+		}),
+		wire: protopack.Message{
+			protopack.Tag{18, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(1),
+			}),
+			protopack.Tag{18, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(2),
+			}),
+		}.Marshal(),
+	},
+	{
+		desc: "basic repeated types",
+		decodeTo: makeMessages(protobuild.Message{
+			"repeated_int32":       []int32{1001, 2001},
+			"repeated_int64":       []int64{1002, 2002},
+			"repeated_uint32":      []uint32{1003, 2003},
+			"repeated_uint64":      []uint64{1004, 2004},
+			"repeated_sint32":      []int32{1005, 2005},
+			"repeated_sint64":      []int64{1006, 2006},
+			"repeated_fixed32":     []uint32{1007, 2007},
+			"repeated_fixed64":     []uint64{1008, 2008},
+			"repeated_sfixed32":    []int32{1009, 2009},
+			"repeated_sfixed64":    []int64{1010, 2010},
+			"repeated_float":       []float32{1011.5, 2011.5},
+			"repeated_double":      []float64{1012.5, 2012.5},
+			"repeated_bool":        []bool{true, false},
+			"repeated_string":      []string{"foo", "bar"},
+			"repeated_bytes":       []string{"FOO", "BAR"},
+			"repeated_nested_enum": []string{"FOO", "BAR"},
+		}),
+		wire: protopack.Message{
+			protopack.Tag{31, protopack.VarintType}, protopack.Varint(1001),
+			protopack.Tag{31, protopack.VarintType}, protopack.Varint(2001),
+			protopack.Tag{32, protopack.VarintType}, protopack.Varint(1002),
+			protopack.Tag{32, protopack.VarintType}, protopack.Varint(2002),
+			protopack.Tag{33, protopack.VarintType}, protopack.Uvarint(1003),
+			protopack.Tag{33, protopack.VarintType}, protopack.Uvarint(2003),
+			protopack.Tag{34, protopack.VarintType}, protopack.Uvarint(1004),
+			protopack.Tag{34, protopack.VarintType}, protopack.Uvarint(2004),
+			protopack.Tag{35, protopack.VarintType}, protopack.Svarint(1005),
+			protopack.Tag{35, protopack.VarintType}, protopack.Svarint(2005),
+			protopack.Tag{36, protopack.VarintType}, protopack.Svarint(1006),
+			protopack.Tag{36, protopack.VarintType}, protopack.Svarint(2006),
+			protopack.Tag{37, protopack.Fixed32Type}, protopack.Uint32(1007),
+			protopack.Tag{37, protopack.Fixed32Type}, protopack.Uint32(2007),
+			protopack.Tag{38, protopack.Fixed64Type}, protopack.Uint64(1008),
+			protopack.Tag{38, protopack.Fixed64Type}, protopack.Uint64(2008),
+			protopack.Tag{39, protopack.Fixed32Type}, protopack.Int32(1009),
+			protopack.Tag{39, protopack.Fixed32Type}, protopack.Int32(2009),
+			protopack.Tag{40, protopack.Fixed64Type}, protopack.Int64(1010),
+			protopack.Tag{40, protopack.Fixed64Type}, protopack.Int64(2010),
+			protopack.Tag{41, protopack.Fixed32Type}, protopack.Float32(1011.5),
+			protopack.Tag{41, protopack.Fixed32Type}, protopack.Float32(2011.5),
+			protopack.Tag{42, protopack.Fixed64Type}, protopack.Float64(1012.5),
+			protopack.Tag{42, protopack.Fixed64Type}, protopack.Float64(2012.5),
+			protopack.Tag{43, protopack.VarintType}, protopack.Bool(true),
+			protopack.Tag{43, protopack.VarintType}, protopack.Bool(false),
+			protopack.Tag{44, protopack.BytesType}, protopack.String("foo"),
+			protopack.Tag{44, protopack.BytesType}, protopack.String("bar"),
+			protopack.Tag{45, protopack.BytesType}, protopack.Bytes([]byte("FOO")),
+			protopack.Tag{45, protopack.BytesType}, protopack.Bytes([]byte("BAR")),
+			protopack.Tag{51, protopack.VarintType}, protopack.Varint(int(testpb.TestAllTypes_FOO)),
+			protopack.Tag{51, protopack.VarintType}, protopack.Varint(int(testpb.TestAllTypes_BAR)),
+		}.Marshal(),
+	},
+	{
+		desc: "basic repeated types (packed encoding)",
+		decodeTo: makeMessages(protobuild.Message{
+			"repeated_int32":       []int32{1001, 2001},
+			"repeated_int64":       []int64{1002, 2002},
+			"repeated_uint32":      []uint32{1003, 2003},
+			"repeated_uint64":      []uint64{1004, 2004},
+			"repeated_sint32":      []int32{1005, 2005},
+			"repeated_sint64":      []int64{1006, 2006},
+			"repeated_fixed32":     []uint32{1007, 2007},
+			"repeated_fixed64":     []uint64{1008, 2008},
+			"repeated_sfixed32":    []int32{1009, 2009},
+			"repeated_sfixed64":    []int64{1010, 2010},
+			"repeated_float":       []float32{1011.5, 2011.5},
+			"repeated_double":      []float64{1012.5, 2012.5},
+			"repeated_bool":        []bool{true, false},
+			"repeated_nested_enum": []string{"FOO", "BAR"},
+		}),
+		wire: protopack.Message{
+			protopack.Tag{31, protopack.BytesType}, protopack.LengthPrefix{
+				protopack.Varint(1001), protopack.Varint(2001),
+			},
+			protopack.Tag{32, protopack.BytesType}, protopack.LengthPrefix{
+				protopack.Varint(1002), protopack.Varint(2002),
+			},
+			protopack.Tag{33, protopack.BytesType}, protopack.LengthPrefix{
+				protopack.Uvarint(1003), protopack.Uvarint(2003),
+			},
+			protopack.Tag{34, protopack.BytesType}, protopack.LengthPrefix{
+				protopack.Uvarint(1004), protopack.Uvarint(2004),
+			},
+			protopack.Tag{35, protopack.BytesType}, protopack.LengthPrefix{
+				protopack.Svarint(1005), protopack.Svarint(2005),
+			},
+			protopack.Tag{36, protopack.BytesType}, protopack.LengthPrefix{
+				protopack.Svarint(1006), protopack.Svarint(2006),
+			},
+			protopack.Tag{37, protopack.BytesType}, protopack.LengthPrefix{
+				protopack.Uint32(1007), protopack.Uint32(2007),
+			},
+			protopack.Tag{38, protopack.BytesType}, protopack.LengthPrefix{
+				protopack.Uint64(1008), protopack.Uint64(2008),
+			},
+			protopack.Tag{39, protopack.BytesType}, protopack.LengthPrefix{
+				protopack.Int32(1009), protopack.Int32(2009),
+			},
+			protopack.Tag{40, protopack.BytesType}, protopack.LengthPrefix{
+				protopack.Int64(1010), protopack.Int64(2010),
+			},
+			protopack.Tag{41, protopack.BytesType}, protopack.LengthPrefix{
+				protopack.Float32(1011.5), protopack.Float32(2011.5),
+			},
+			protopack.Tag{42, protopack.BytesType}, protopack.LengthPrefix{
+				protopack.Float64(1012.5), protopack.Float64(2012.5),
+			},
+			protopack.Tag{43, protopack.BytesType}, protopack.LengthPrefix{
+				protopack.Bool(true), protopack.Bool(false),
+			},
+			protopack.Tag{51, protopack.BytesType}, protopack.LengthPrefix{
+				protopack.Varint(int(testpb.TestAllTypes_FOO)),
+				protopack.Varint(int(testpb.TestAllTypes_BAR)),
+			},
+		}.Marshal(),
+	},
+	{
+		desc: "basic repeated types (zero-length packed encoding)",
+		decodeTo: makeMessages(protobuild.Message{
+			"repeated_int32":       []int32{},
+			"repeated_int64":       []int64{},
+			"repeated_uint32":      []uint32{},
+			"repeated_uint64":      []uint64{},
+			"repeated_sint32":      []int32{},
+			"repeated_sint64":      []int64{},
+			"repeated_fixed32":     []uint32{},
+			"repeated_fixed64":     []uint64{},
+			"repeated_sfixed32":    []int32{},
+			"repeated_sfixed64":    []int64{},
+			"repeated_float":       []float32{},
+			"repeated_double":      []float64{},
+			"repeated_bool":        []bool{},
+			"repeated_nested_enum": []string{},
+		}),
+		wire: protopack.Message{
+			protopack.Tag{31, protopack.BytesType}, protopack.LengthPrefix{},
+			protopack.Tag{32, protopack.BytesType}, protopack.LengthPrefix{},
+			protopack.Tag{33, protopack.BytesType}, protopack.LengthPrefix{},
+			protopack.Tag{34, protopack.BytesType}, protopack.LengthPrefix{},
+			protopack.Tag{35, protopack.BytesType}, protopack.LengthPrefix{},
+			protopack.Tag{36, protopack.BytesType}, protopack.LengthPrefix{},
+			protopack.Tag{37, protopack.BytesType}, protopack.LengthPrefix{},
+			protopack.Tag{38, protopack.BytesType}, protopack.LengthPrefix{},
+			protopack.Tag{39, protopack.BytesType}, protopack.LengthPrefix{},
+			protopack.Tag{40, protopack.BytesType}, protopack.LengthPrefix{},
+			protopack.Tag{41, protopack.BytesType}, protopack.LengthPrefix{},
+			protopack.Tag{42, protopack.BytesType}, protopack.LengthPrefix{},
+			protopack.Tag{43, protopack.BytesType}, protopack.LengthPrefix{},
+			protopack.Tag{51, protopack.BytesType}, protopack.LengthPrefix{},
+		}.Marshal(),
+	},
+	{
+		desc: "packed repeated types",
+		decodeTo: makeMessages(protobuild.Message{
+			"packed_int32":    []int32{1001, 2001},
+			"packed_int64":    []int64{1002, 2002},
+			"packed_uint32":   []uint32{1003, 2003},
+			"packed_uint64":   []uint64{1004, 2004},
+			"packed_sint32":   []int32{1005, 2005},
+			"packed_sint64":   []int64{1006, 2006},
+			"packed_fixed32":  []uint32{1007, 2007},
+			"packed_fixed64":  []uint64{1008, 2008},
+			"packed_sfixed32": []int32{1009, 2009},
+			"packed_sfixed64": []int64{1010, 2010},
+			"packed_float":    []float32{1011.5, 2011.5},
+			"packed_double":   []float64{1012.5, 2012.5},
+			"packed_bool":     []bool{true, false},
+			"packed_enum":     []string{"FOREIGN_FOO", "FOREIGN_BAR"},
+		}, &testpb.TestPackedTypes{}, &testpb.TestPackedExtensions{}),
+		wire: protopack.Message{
+			protopack.Tag{90, protopack.BytesType}, protopack.LengthPrefix{
+				protopack.Varint(1001), protopack.Varint(2001),
+			},
+			protopack.Tag{91, protopack.BytesType}, protopack.LengthPrefix{
+				protopack.Varint(1002), protopack.Varint(2002),
+			},
+			protopack.Tag{92, protopack.BytesType}, protopack.LengthPrefix{
+				protopack.Uvarint(1003), protopack.Uvarint(2003),
+			},
+			protopack.Tag{93, protopack.BytesType}, protopack.LengthPrefix{
+				protopack.Uvarint(1004), protopack.Uvarint(2004),
+			},
+			protopack.Tag{94, protopack.BytesType}, protopack.LengthPrefix{
+				protopack.Svarint(1005), protopack.Svarint(2005),
+			},
+			protopack.Tag{95, protopack.BytesType}, protopack.LengthPrefix{
+				protopack.Svarint(1006), protopack.Svarint(2006),
+			},
+			protopack.Tag{96, protopack.BytesType}, protopack.LengthPrefix{
+				protopack.Uint32(1007), protopack.Uint32(2007),
+			},
+			protopack.Tag{97, protopack.BytesType}, protopack.LengthPrefix{
+				protopack.Uint64(1008), protopack.Uint64(2008),
+			},
+			protopack.Tag{98, protopack.BytesType}, protopack.LengthPrefix{
+				protopack.Int32(1009), protopack.Int32(2009),
+			},
+			protopack.Tag{99, protopack.BytesType}, protopack.LengthPrefix{
+				protopack.Int64(1010), protopack.Int64(2010),
+			},
+			protopack.Tag{100, protopack.BytesType}, protopack.LengthPrefix{
+				protopack.Float32(1011.5), protopack.Float32(2011.5),
+			},
+			protopack.Tag{101, protopack.BytesType}, protopack.LengthPrefix{
+				protopack.Float64(1012.5), protopack.Float64(2012.5),
+			},
+			protopack.Tag{102, protopack.BytesType}, protopack.LengthPrefix{
+				protopack.Bool(true), protopack.Bool(false),
+			},
+			protopack.Tag{103, protopack.BytesType}, protopack.LengthPrefix{
+				protopack.Varint(int(testpb.ForeignEnum_FOREIGN_FOO)),
+				protopack.Varint(int(testpb.ForeignEnum_FOREIGN_BAR)),
+			},
+		}.Marshal(),
+	},
+	{
+		desc: "packed repeated types (zero length)",
+		decodeTo: makeMessages(protobuild.Message{
+			"packed_int32":    []int32{},
+			"packed_int64":    []int64{},
+			"packed_uint32":   []uint32{},
+			"packed_uint64":   []uint64{},
+			"packed_sint32":   []int32{},
+			"packed_sint64":   []int64{},
+			"packed_fixed32":  []uint32{},
+			"packed_fixed64":  []uint64{},
+			"packed_sfixed32": []int32{},
+			"packed_sfixed64": []int64{},
+			"packed_float":    []float32{},
+			"packed_double":   []float64{},
+			"packed_bool":     []bool{},
+			"packed_enum":     []string{},
+		}, &testpb.TestPackedTypes{}, &testpb.TestPackedExtensions{}),
+		wire: protopack.Message{
+			protopack.Tag{90, protopack.BytesType}, protopack.LengthPrefix{},
+			protopack.Tag{91, protopack.BytesType}, protopack.LengthPrefix{},
+			protopack.Tag{92, protopack.BytesType}, protopack.LengthPrefix{},
+			protopack.Tag{93, protopack.BytesType}, protopack.LengthPrefix{},
+			protopack.Tag{94, protopack.BytesType}, protopack.LengthPrefix{},
+			protopack.Tag{95, protopack.BytesType}, protopack.LengthPrefix{},
+			protopack.Tag{96, protopack.BytesType}, protopack.LengthPrefix{},
+			protopack.Tag{97, protopack.BytesType}, protopack.LengthPrefix{},
+			protopack.Tag{98, protopack.BytesType}, protopack.LengthPrefix{},
+			protopack.Tag{99, protopack.BytesType}, protopack.LengthPrefix{},
+			protopack.Tag{100, protopack.BytesType}, protopack.LengthPrefix{},
+			protopack.Tag{101, protopack.BytesType}, protopack.LengthPrefix{},
+			protopack.Tag{102, protopack.BytesType}, protopack.LengthPrefix{},
+			protopack.Tag{103, protopack.BytesType}, protopack.LengthPrefix{},
+		}.Marshal(),
+	},
+	{
+		desc: "repeated messages",
+		decodeTo: makeMessages(protobuild.Message{
+			"repeated_nested_message": []protobuild.Message{
+				{"a": 1},
+				{},
+				{"a": 2},
+			},
+		}),
+		wire: protopack.Message{
+			protopack.Tag{48, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(1),
+			}),
+			protopack.Tag{48, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{}),
+			protopack.Tag{48, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(2),
+			}),
+		}.Marshal(),
+	},
+	{
+		desc: "repeated nil messages",
+		decodeTo: []proto.Message{&testpb.TestAllTypes{
+			RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{
+				{A: proto.Int32(1)},
+				nil,
+				{A: proto.Int32(2)},
+			},
+		}, &test3pb.TestAllTypes{
+			RepeatedNestedMessage: []*test3pb.TestAllTypes_NestedMessage{
+				{A: 1},
+				nil,
+				{A: 2},
+			},
+		}, build(
+			&testpb.TestAllExtensions{},
+			extend(testpb.E_RepeatedNestedMessage, []*testpb.TestAllExtensions_NestedMessage{
+				{A: proto.Int32(1)},
+				nil,
+				{A: proto.Int32(2)},
+			}),
+		)},
+		wire: protopack.Message{
+			protopack.Tag{48, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(1),
+			}),
+			protopack.Tag{48, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{}),
+			protopack.Tag{48, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(2),
+			}),
+		}.Marshal(),
+	},
+	{
+		desc: "repeated groups",
+		decodeTo: makeMessages(protobuild.Message{
+			"repeatedgroup": []protobuild.Message{
+				{"a": 1017},
+				{},
+				{"a": 2017},
+			},
+		}, &testpb.TestAllTypes{}, &testpb.TestAllExtensions{}),
+		wire: protopack.Message{
+			protopack.Tag{46, protopack.StartGroupType},
+			protopack.Tag{47, protopack.VarintType}, protopack.Varint(1017),
+			protopack.Tag{46, protopack.EndGroupType},
+			protopack.Tag{46, protopack.StartGroupType},
+			protopack.Tag{46, protopack.EndGroupType},
+			protopack.Tag{46, protopack.StartGroupType},
+			protopack.Tag{47, protopack.VarintType}, protopack.Varint(2017),
+			protopack.Tag{46, protopack.EndGroupType},
+		}.Marshal(),
+	},
+	{
+		desc: "repeated nil groups",
+		decodeTo: []proto.Message{&testpb.TestAllTypes{
+			Repeatedgroup: []*testpb.TestAllTypes_RepeatedGroup{
+				{A: proto.Int32(1017)},
+				nil,
+				{A: proto.Int32(2017)},
+			},
+		}, build(
+			&testpb.TestAllExtensions{},
+			extend(testpb.E_Repeatedgroup, []*testpb.RepeatedGroup{
+				{A: proto.Int32(1017)},
+				nil,
+				{A: proto.Int32(2017)},
+			}),
+		)},
+		wire: protopack.Message{
+			protopack.Tag{46, protopack.StartGroupType},
+			protopack.Tag{47, protopack.VarintType}, protopack.Varint(1017),
+			protopack.Tag{46, protopack.EndGroupType},
+			protopack.Tag{46, protopack.StartGroupType},
+			protopack.Tag{46, protopack.EndGroupType},
+			protopack.Tag{46, protopack.StartGroupType},
+			protopack.Tag{47, protopack.VarintType}, protopack.Varint(2017),
+			protopack.Tag{46, protopack.EndGroupType},
+		}.Marshal(),
+	},
+	{
+		desc: "maps",
+		decodeTo: makeMessages(protobuild.Message{
+			"map_int32_int32":       map[int32]int32{1056: 1156, 2056: 2156},
+			"map_int64_int64":       map[int64]int64{1057: 1157, 2057: 2157},
+			"map_uint32_uint32":     map[uint32]uint32{1058: 1158, 2058: 2158},
+			"map_uint64_uint64":     map[uint64]uint64{1059: 1159, 2059: 2159},
+			"map_sint32_sint32":     map[int32]int32{1060: 1160, 2060: 2160},
+			"map_sint64_sint64":     map[int64]int64{1061: 1161, 2061: 2161},
+			"map_fixed32_fixed32":   map[uint32]uint32{1062: 1162, 2062: 2162},
+			"map_fixed64_fixed64":   map[uint64]uint64{1063: 1163, 2063: 2163},
+			"map_sfixed32_sfixed32": map[int32]int32{1064: 1164, 2064: 2164},
+			"map_sfixed64_sfixed64": map[int64]int64{1065: 1165, 2065: 2165},
+			"map_int32_float":       map[int32]float32{1066: 1166.5, 2066: 2166.5},
+			"map_int32_double":      map[int32]float64{1067: 1167.5, 2067: 2167.5},
+			"map_bool_bool":         map[bool]bool{true: false, false: true},
+			"map_string_string":     map[string]string{"69.1.key": "69.1.val", "69.2.key": "69.2.val"},
+			"map_string_bytes":      map[string][]byte{"70.1.key": []byte("70.1.val"), "70.2.key": []byte("70.2.val")},
+			"map_string_nested_message": map[string]protobuild.Message{
+				"71.1.key": {"a": 1171},
+				"71.2.key": {"a": 2171},
+			},
+			"map_string_nested_enum": map[string]string{"73.1.key": "FOO", "73.2.key": "BAR"},
+		}, &testpb.TestAllTypes{}, &test3pb.TestAllTypes{}),
+		wire: protopack.Message{
+			protopack.Tag{56, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(1056),
+				protopack.Tag{2, protopack.VarintType}, protopack.Varint(1156),
+			}),
+			protopack.Tag{56, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(2056),
+				protopack.Tag{2, protopack.VarintType}, protopack.Varint(2156),
+			}),
+			protopack.Tag{57, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(1057),
+				protopack.Tag{2, protopack.VarintType}, protopack.Varint(1157),
+			}),
+			protopack.Tag{57, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(2057),
+				protopack.Tag{2, protopack.VarintType}, protopack.Varint(2157),
+			}),
+			protopack.Tag{58, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(1058),
+				protopack.Tag{2, protopack.VarintType}, protopack.Varint(1158),
+			}),
+			protopack.Tag{58, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(2058),
+				protopack.Tag{2, protopack.VarintType}, protopack.Varint(2158),
+			}),
+			protopack.Tag{59, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(1059),
+				protopack.Tag{2, protopack.VarintType}, protopack.Varint(1159),
+			}),
+			protopack.Tag{59, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(2059),
+				protopack.Tag{2, protopack.VarintType}, protopack.Varint(2159),
+			}),
+			protopack.Tag{60, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Svarint(1060),
+				protopack.Tag{2, protopack.VarintType}, protopack.Svarint(1160),
+			}),
+			protopack.Tag{60, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Svarint(2060),
+				protopack.Tag{2, protopack.VarintType}, protopack.Svarint(2160),
+			}),
+			protopack.Tag{61, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Svarint(1061),
+				protopack.Tag{2, protopack.VarintType}, protopack.Svarint(1161),
+			}),
+			protopack.Tag{61, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Svarint(2061),
+				protopack.Tag{2, protopack.VarintType}, protopack.Svarint(2161),
+			}),
+			protopack.Tag{62, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.Fixed32Type}, protopack.Int32(1062),
+				protopack.Tag{2, protopack.Fixed32Type}, protopack.Int32(1162),
+			}),
+			protopack.Tag{62, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.Fixed32Type}, protopack.Int32(2062),
+				protopack.Tag{2, protopack.Fixed32Type}, protopack.Int32(2162),
+			}),
+			protopack.Tag{63, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.Fixed64Type}, protopack.Int64(1063),
+				protopack.Tag{2, protopack.Fixed64Type}, protopack.Int64(1163),
+			}),
+			protopack.Tag{63, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.Fixed64Type}, protopack.Int64(2063),
+				protopack.Tag{2, protopack.Fixed64Type}, protopack.Int64(2163),
+			}),
+			protopack.Tag{64, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.Fixed32Type}, protopack.Int32(1064),
+				protopack.Tag{2, protopack.Fixed32Type}, protopack.Int32(1164),
+			}),
+			protopack.Tag{64, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.Fixed32Type}, protopack.Int32(2064),
+				protopack.Tag{2, protopack.Fixed32Type}, protopack.Int32(2164),
+			}),
+			protopack.Tag{65, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.Fixed64Type}, protopack.Int64(1065),
+				protopack.Tag{2, protopack.Fixed64Type}, protopack.Int64(1165),
+			}),
+			protopack.Tag{65, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.Fixed64Type}, protopack.Int64(2065),
+				protopack.Tag{2, protopack.Fixed64Type}, protopack.Int64(2165),
+			}),
+			protopack.Tag{66, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(1066),
+				protopack.Tag{2, protopack.Fixed32Type}, protopack.Float32(1166.5),
+			}),
+			protopack.Tag{66, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(2066),
+				protopack.Tag{2, protopack.Fixed32Type}, protopack.Float32(2166.5),
+			}),
+			protopack.Tag{67, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(1067),
+				protopack.Tag{2, protopack.Fixed64Type}, protopack.Float64(1167.5),
+			}),
+			protopack.Tag{67, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(2067),
+				protopack.Tag{2, protopack.Fixed64Type}, protopack.Float64(2167.5),
+			}),
+			protopack.Tag{68, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Bool(true),
+				protopack.Tag{2, protopack.VarintType}, protopack.Bool(false),
+			}),
+			protopack.Tag{68, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Bool(false),
+				protopack.Tag{2, protopack.VarintType}, protopack.Bool(true),
+			}),
+			protopack.Tag{69, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.BytesType}, protopack.String("69.1.key"),
+				protopack.Tag{2, protopack.BytesType}, protopack.String("69.1.val"),
+			}),
+			protopack.Tag{69, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.BytesType}, protopack.String("69.2.key"),
+				protopack.Tag{2, protopack.BytesType}, protopack.String("69.2.val"),
+			}),
+			protopack.Tag{70, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.BytesType}, protopack.String("70.1.key"),
+				protopack.Tag{2, protopack.BytesType}, protopack.String("70.1.val"),
+			}),
+			protopack.Tag{70, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.BytesType}, protopack.String("70.2.key"),
+				protopack.Tag{2, protopack.BytesType}, protopack.String("70.2.val"),
+			}),
+			protopack.Tag{71, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.BytesType}, protopack.String("71.1.key"),
+				protopack.Tag{2, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+					protopack.Tag{1, protopack.VarintType}, protopack.Varint(1171),
+				}),
+			}),
+			protopack.Tag{71, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.BytesType}, protopack.String("71.2.key"),
+				protopack.Tag{2, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+					protopack.Tag{1, protopack.VarintType}, protopack.Varint(2171),
+				}),
+			}),
+			protopack.Tag{73, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.BytesType}, protopack.String("73.1.key"),
+				protopack.Tag{2, protopack.VarintType}, protopack.Varint(int(testpb.TestAllTypes_FOO)),
+			}),
+			protopack.Tag{73, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.BytesType}, protopack.String("73.2.key"),
+				protopack.Tag{2, protopack.VarintType}, protopack.Varint(int(testpb.TestAllTypes_BAR)),
+			}),
+		}.Marshal(),
+	},
+	{
+		desc: "map with value before key",
+		decodeTo: makeMessages(protobuild.Message{
+			"map_int32_int32": map[int32]int32{1056: 1156},
+			"map_string_nested_message": map[string]protobuild.Message{
+				"71.1.key": {"a": 1171},
+			},
+		}, &testpb.TestAllTypes{}, &test3pb.TestAllTypes{}),
+		wire: protopack.Message{
+			protopack.Tag{56, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{2, protopack.VarintType}, protopack.Varint(1156),
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(1056),
+			}),
+			protopack.Tag{71, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{2, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+					protopack.Tag{1, protopack.VarintType}, protopack.Varint(1171),
+				}),
+				protopack.Tag{1, protopack.BytesType}, protopack.String("71.1.key"),
+			}),
+		}.Marshal(),
+	},
+	{
+		desc: "map with repeated key and value",
+		decodeTo: makeMessages(protobuild.Message{
+			"map_int32_int32": map[int32]int32{1056: 1156},
+			"map_string_nested_message": map[string]protobuild.Message{
+				"71.1.key": {"a": 1171},
+			},
+		}, &testpb.TestAllTypes{}, &test3pb.TestAllTypes{}),
+		wire: protopack.Message{
+			protopack.Tag{56, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(0),
+				protopack.Tag{2, protopack.VarintType}, protopack.Varint(0),
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(1056),
+				protopack.Tag{2, protopack.VarintType}, protopack.Varint(1156),
+			}),
+			protopack.Tag{71, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.BytesType}, protopack.String(0),
+				protopack.Tag{2, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{}),
+				protopack.Tag{1, protopack.BytesType}, protopack.String("71.1.key"),
+				protopack.Tag{2, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+					protopack.Tag{1, protopack.VarintType}, protopack.Varint(1171),
+				}),
+			}),
+		}.Marshal(),
+	},
+	{
+		desc: "oneof (uint32)",
+		decodeTo: makeMessages(protobuild.Message{
+			"oneof_uint32": 1111,
+		}, &testpb.TestAllTypes{}, &test3pb.TestAllTypes{}),
+		wire: protopack.Message{protopack.Tag{111, protopack.VarintType}, protopack.Varint(1111)}.Marshal(),
+	},
+	{
+		desc: "oneof (message)",
+		decodeTo: makeMessages(protobuild.Message{
+			"oneof_nested_message": protobuild.Message{
+				"a": 1112,
+			},
+		}, &testpb.TestAllTypes{}, &test3pb.TestAllTypes{}),
+		wire: protopack.Message{protopack.Tag{112, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+			protopack.Message{protopack.Tag{1, protopack.VarintType}, protopack.Varint(1112)},
+		})}.Marshal(),
+	},
+	{
+		desc: "oneof (empty message)",
+		decodeTo: makeMessages(protobuild.Message{
+			"oneof_nested_message": protobuild.Message{},
+		}, &testpb.TestAllTypes{}, &test3pb.TestAllTypes{}),
+		wire: protopack.Message{protopack.Tag{112, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{})}.Marshal(),
+	},
+	{
+		desc: "oneof (merged message)",
+		decodeTo: makeMessages(protobuild.Message{
+			"oneof_nested_message": protobuild.Message{
+				"a": 1,
+				"corecursive": protobuild.Message{
+					"optional_int32": 43,
+				},
+			},
+		}, &testpb.TestAllTypes{}, &test3pb.TestAllTypes{}),
+		wire: protopack.Message{
+			protopack.Tag{112, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Message{protopack.Tag{1, protopack.VarintType}, protopack.Varint(1)},
+			}),
+			protopack.Tag{112, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{2, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+					protopack.Tag{1, protopack.VarintType}, protopack.Varint(43),
+				}),
+			}),
+		}.Marshal(),
+	},
+	{
+		desc: "oneof (group)",
+		decodeTo: makeMessages(protobuild.Message{
+			"oneofgroup": protobuild.Message{
+				"a": 1,
+			},
+		}, &testpb.TestAllTypes{}),
+		wire: protopack.Message{
+			protopack.Tag{121, protopack.StartGroupType},
+			protopack.Tag{1, protopack.VarintType}, protopack.Varint(1),
+			protopack.Tag{121, protopack.EndGroupType},
+		}.Marshal(),
+	},
+	{
+		desc: "oneof (empty group)",
+		decodeTo: makeMessages(protobuild.Message{
+			"oneofgroup": protobuild.Message{},
+		}, &testpb.TestAllTypes{}),
+		wire: protopack.Message{
+			protopack.Tag{121, protopack.StartGroupType},
+			protopack.Tag{121, protopack.EndGroupType},
+		}.Marshal(),
+	},
+	{
+		desc: "oneof (merged group)",
+		decodeTo: makeMessages(protobuild.Message{
+			"oneofgroup": protobuild.Message{
+				"a": 1,
+				"b": 2,
+			},
+		}, &testpb.TestAllTypes{}),
+		wire: protopack.Message{
+			protopack.Tag{121, protopack.StartGroupType},
+			protopack.Tag{1, protopack.VarintType}, protopack.Varint(1),
+			protopack.Tag{121, protopack.EndGroupType},
+			protopack.Tag{121, protopack.StartGroupType},
+			protopack.Tag{2, protopack.VarintType}, protopack.Varint(2),
+			protopack.Tag{121, protopack.EndGroupType},
+		}.Marshal(),
+	},
+	{
+		desc: "oneof (string)",
+		decodeTo: makeMessages(protobuild.Message{
+			"oneof_string": "1113",
+		}, &testpb.TestAllTypes{}, &test3pb.TestAllTypes{}),
+		wire: protopack.Message{protopack.Tag{113, protopack.BytesType}, protopack.String("1113")}.Marshal(),
+	},
+	{
+		desc: "oneof (bytes)",
+		decodeTo: makeMessages(protobuild.Message{
+			"oneof_bytes": "1114",
+		}, &testpb.TestAllTypes{}, &test3pb.TestAllTypes{}),
+		wire: protopack.Message{protopack.Tag{114, protopack.BytesType}, protopack.String("1114")}.Marshal(),
+	},
+	{
+		desc: "oneof (bool)",
+		decodeTo: makeMessages(protobuild.Message{
+			"oneof_bool": true,
+		}, &testpb.TestAllTypes{}, &test3pb.TestAllTypes{}),
+		wire: protopack.Message{protopack.Tag{115, protopack.VarintType}, protopack.Bool(true)}.Marshal(),
+	},
+	{
+		desc: "oneof (uint64)",
+		decodeTo: makeMessages(protobuild.Message{
+			"oneof_uint64": 116,
+		}, &testpb.TestAllTypes{}, &test3pb.TestAllTypes{}),
+		wire: protopack.Message{protopack.Tag{116, protopack.VarintType}, protopack.Varint(116)}.Marshal(),
+	},
+	{
+		desc: "oneof (float)",
+		decodeTo: makeMessages(protobuild.Message{
+			"oneof_float": 117.5,
+		}, &testpb.TestAllTypes{}, &test3pb.TestAllTypes{}),
+		wire: protopack.Message{protopack.Tag{117, protopack.Fixed32Type}, protopack.Float32(117.5)}.Marshal(),
+	},
+	{
+		desc: "oneof (double)",
+		decodeTo: makeMessages(protobuild.Message{
+			"oneof_double": 118.5,
+		}, &testpb.TestAllTypes{}, &test3pb.TestAllTypes{}),
+		wire: protopack.Message{protopack.Tag{118, protopack.Fixed64Type}, protopack.Float64(118.5)}.Marshal(),
+	},
+	{
+		desc: "oneof (enum)",
+		decodeTo: makeMessages(protobuild.Message{
+			"oneof_enum": "BAR",
+		}, &testpb.TestAllTypes{}, &test3pb.TestAllTypes{}),
+		wire: protopack.Message{protopack.Tag{119, protopack.VarintType}, protopack.Varint(int(testpb.TestAllTypes_BAR))}.Marshal(),
+	},
+	{
+		desc: "oneof (zero)",
+		decodeTo: makeMessages(protobuild.Message{
+			"oneof_uint64": 0,
+		}, &testpb.TestAllTypes{}, &test3pb.TestAllTypes{}),
+		wire: protopack.Message{protopack.Tag{116, protopack.VarintType}, protopack.Varint(0)}.Marshal(),
+	},
+	{
+		desc: "oneof (overridden value)",
+		decodeTo: makeMessages(protobuild.Message{
+			"oneof_uint64": 2,
+		}, &testpb.TestAllTypes{}, &test3pb.TestAllTypes{}),
+		wire: protopack.Message{
+			protopack.Tag{111, protopack.VarintType}, protopack.Varint(1),
+			protopack.Tag{116, protopack.VarintType}, protopack.Varint(2),
+		}.Marshal(),
+	},
+	// TODO: More unknown field tests for ordering, repeated fields, etc.
+	//
+	// It is currently impossible to produce results that the v1 Equal
+	// considers equivalent to those of the v1 decoder. Figure out if
+	// that's a problem or not.
+	{
+		desc:          "unknown fields",
+		checkFastInit: true,
+		decodeTo: makeMessages(protobuild.Message{
+			protobuild.Unknown: protopack.Message{
+				protopack.Tag{100000, protopack.VarintType}, protopack.Varint(1),
+			}.Marshal(),
+		}),
+		wire: protopack.Message{
+			protopack.Tag{100000, protopack.VarintType}, protopack.Varint(1),
+		}.Marshal(),
+	},
+	{
+		desc: "discarded unknown fields",
+		unmarshalOptions: proto.UnmarshalOptions{
+			DiscardUnknown: true,
+		},
+		decodeTo: makeMessages(protobuild.Message{}),
+		wire: protopack.Message{
+			protopack.Tag{100000, protopack.VarintType}, protopack.Varint(1),
+		}.Marshal(),
+	},
+	{
+		desc: "field type mismatch",
+		decodeTo: makeMessages(protobuild.Message{
+			protobuild.Unknown: protopack.Message{
+				protopack.Tag{1, protopack.BytesType}, protopack.String("string"),
+			}.Marshal(),
+		}),
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.BytesType}, protopack.String("string"),
+		}.Marshal(),
+	},
+	{
+		desc: "map field element mismatch",
+		decodeTo: makeMessages(protobuild.Message{
+			"map_int32_int32": map[int32]int32{1: 0},
+		}, &testpb.TestAllTypes{}, &test3pb.TestAllTypes{}),
+		wire: protopack.Message{
+			protopack.Tag{56, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(1),
+				protopack.Tag{2, protopack.BytesType}, protopack.String("string"),
+			}),
+		}.Marshal(),
+	},
+	{
+		desc:          "required field in nil message unset",
+		checkFastInit: true,
+		partial:       true,
+		decodeTo:      []proto.Message{(*testpb.TestRequired)(nil)},
+	},
+	{
+		desc:          "required int32 unset",
+		checkFastInit: true,
+		partial:       true,
+		decodeTo:      makeMessages(protobuild.Message{}, &requiredpb.Int32{}),
+	},
+	{
+		desc:          "required int32 set",
+		checkFastInit: true,
+		decodeTo: makeMessages(protobuild.Message{
+			"v": 1,
+		}, &requiredpb.Int32{}),
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.VarintType}, protopack.Varint(1),
+		}.Marshal(),
+	},
+	{
+		desc:          "required fixed32 unset",
+		checkFastInit: true,
+		partial:       true,
+		decodeTo:      makeMessages(protobuild.Message{}, &requiredpb.Fixed32{}),
+	},
+	{
+		desc:          "required fixed32 set",
+		checkFastInit: true,
+		decodeTo: makeMessages(protobuild.Message{
+			"v": 1,
+		}, &requiredpb.Fixed32{}),
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.Fixed32Type}, protopack.Int32(1),
+		}.Marshal(),
+	},
+	{
+		desc:          "required fixed64 unset",
+		checkFastInit: true,
+		partial:       true,
+		decodeTo:      makeMessages(protobuild.Message{}, &requiredpb.Fixed64{}),
+	},
+	{
+		desc:          "required fixed64 set",
+		checkFastInit: true,
+		decodeTo: makeMessages(protobuild.Message{
+			"v": 1,
+		}, &requiredpb.Fixed64{}),
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.Fixed64Type}, protopack.Int64(1),
+		}.Marshal(),
+	},
+	{
+		desc:          "required bytes unset",
+		checkFastInit: true,
+		partial:       true,
+		decodeTo:      makeMessages(protobuild.Message{}, &requiredpb.Bytes{}),
+	},
+	{
+		desc:          "required bytes set",
+		checkFastInit: true,
+		decodeTo: makeMessages(protobuild.Message{
+			"v": "",
+		}, &requiredpb.Bytes{}),
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.BytesType}, protopack.Bytes(nil),
+		}.Marshal(),
+	},
+	{
+		desc:          "required message unset",
+		checkFastInit: true,
+		partial:       true,
+		decodeTo:      makeMessages(protobuild.Message{}, &requiredpb.Message{}),
+	},
+	{
+		desc:          "required message set",
+		checkFastInit: true,
+		decodeTo: makeMessages(protobuild.Message{
+			"v": protobuild.Message{},
+		}, &requiredpb.Message{}),
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{}),
+		}.Marshal(),
+	},
+	{
+		desc:          "required group unset",
+		checkFastInit: true,
+		partial:       true,
+		decodeTo:      makeMessages(protobuild.Message{}, &requiredpb.Group{}),
+	},
+	{
+		desc:          "required group set",
+		checkFastInit: true,
+		decodeTo: makeMessages(protobuild.Message{
+			"group": protobuild.Message{},
+		}, &requiredpb.Group{}),
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.StartGroupType},
+			protopack.Tag{1, protopack.EndGroupType},
+		}.Marshal(),
+	},
+	{
+		desc:          "required field with incompatible wire type",
+		checkFastInit: true,
+		partial:       true,
+		decodeTo: []proto.Message{build(
+			&testpb.TestRequired{},
+			unknown(protopack.Message{
+				protopack.Tag{1, protopack.Fixed32Type}, protopack.Int32(2),
+			}.Marshal()),
+		)},
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.Fixed32Type}, protopack.Int32(2),
+		}.Marshal(),
+	},
+	{
+		desc:          "required field in optional message unset",
+		checkFastInit: true,
+		partial:       true,
+		decodeTo: makeMessages(protobuild.Message{
+			"optional_message": protobuild.Message{},
+		}, &testpb.TestRequiredForeign{}),
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{}),
+		}.Marshal(),
+	},
+	{
+		desc:          "required field in optional message set",
+		checkFastInit: true,
+		decodeTo: makeMessages(protobuild.Message{
+			"optional_message": protobuild.Message{
+				"required_field": 1,
+			},
+		}, &testpb.TestRequiredForeign{}),
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(1),
+			}),
+		}.Marshal(),
+	},
+	{
+		desc:             "required field in optional message set (split across multiple tags)",
+		checkFastInit:    false, // fast init checks don't handle split messages
+		nocheckValidInit: true,  // validation doesn't either
+		decodeTo: makeMessages(protobuild.Message{
+			"optional_message": protobuild.Message{
+				"required_field": 1,
+			},
+		}, &testpb.TestRequiredForeign{}),
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{}),
+			protopack.Tag{1, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(1),
+			}),
+		}.Marshal(),
+	},
+	{
+		desc:          "required field in repeated message unset",
+		checkFastInit: true,
+		partial:       true,
+		decodeTo: makeMessages(protobuild.Message{
+			"repeated_message": []protobuild.Message{
+				{"required_field": 1},
+				{},
+			},
+		}, &testpb.TestRequiredForeign{}),
+		wire: protopack.Message{
+			protopack.Tag{2, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(1),
+			}),
+			protopack.Tag{2, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{}),
+		}.Marshal(),
+	},
+	{
+		desc:          "required field in repeated message set",
+		checkFastInit: true,
+		decodeTo: makeMessages(protobuild.Message{
+			"repeated_message": []protobuild.Message{
+				{"required_field": 1},
+				{"required_field": 2},
+			},
+		}, &testpb.TestRequiredForeign{}),
+		wire: protopack.Message{
+			protopack.Tag{2, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(1),
+			}),
+			protopack.Tag{2, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(2),
+			}),
+		}.Marshal(),
+	},
+	{
+		desc:          "required field in map message unset",
+		checkFastInit: true,
+		partial:       true,
+		decodeTo: makeMessages(protobuild.Message{
+			"map_message": map[int32]protobuild.Message{
+				1: {"required_field": 1},
+				2: {},
+			},
+		}, &testpb.TestRequiredForeign{}),
+		wire: protopack.Message{
+			protopack.Tag{3, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(1),
+				protopack.Tag{2, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+					protopack.Tag{1, protopack.VarintType}, protopack.Varint(1),
+				}),
+			}),
+			protopack.Tag{3, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(2),
+				protopack.Tag{2, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{}),
+			}),
+		}.Marshal(),
+	},
+	{
+		desc:          "required field in absent map message value",
+		checkFastInit: true,
+		partial:       true,
+		decodeTo: makeMessages(protobuild.Message{
+			"map_message": map[int32]protobuild.Message{
+				2: {},
+			},
+		}, &testpb.TestRequiredForeign{}),
+		wire: protopack.Message{
+			protopack.Tag{3, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(2),
+			}),
+		}.Marshal(),
+	},
+	{
+		desc:          "required field in map message set",
+		checkFastInit: true,
+		decodeTo: makeMessages(protobuild.Message{
+			"map_message": map[int32]protobuild.Message{
+				1: {"required_field": 1},
+				2: {"required_field": 2},
+			},
+		}, &testpb.TestRequiredForeign{}),
+		wire: protopack.Message{
+			protopack.Tag{3, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(1),
+				protopack.Tag{2, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+					protopack.Tag{1, protopack.VarintType}, protopack.Varint(1),
+				}),
+			}),
+			protopack.Tag{3, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(2),
+				protopack.Tag{2, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+					protopack.Tag{1, protopack.VarintType}, protopack.Varint(2),
+				}),
+			}),
+		}.Marshal(),
+	},
+	{
+		desc:          "required field in optional group unset",
+		checkFastInit: true,
+		partial:       true,
+		decodeTo: makeMessages(protobuild.Message{
+			"optionalgroup": protobuild.Message{},
+		}, &testpb.TestRequiredGroupFields{}),
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.StartGroupType},
+			protopack.Tag{1, protopack.EndGroupType},
+		}.Marshal(),
+	},
+	{
+		desc:          "required field in optional group set",
+		checkFastInit: true,
+		decodeTo: makeMessages(protobuild.Message{
+			"optionalgroup": protobuild.Message{
+				"a": 1,
+			},
+		}, &testpb.TestRequiredGroupFields{}),
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.StartGroupType},
+			protopack.Tag{2, protopack.VarintType}, protopack.Varint(1),
+			protopack.Tag{1, protopack.EndGroupType},
+		}.Marshal(),
+	},
+	{
+		desc:          "required field in repeated group unset",
+		checkFastInit: true,
+		partial:       true,
+		decodeTo: makeMessages(protobuild.Message{
+			"repeatedgroup": []protobuild.Message{
+				{"a": 1},
+				{},
+			},
+		}, &testpb.TestRequiredGroupFields{}),
+		wire: protopack.Message{
+			protopack.Tag{3, protopack.StartGroupType},
+			protopack.Tag{4, protopack.VarintType}, protopack.Varint(1),
+			protopack.Tag{3, protopack.EndGroupType},
+			protopack.Tag{3, protopack.StartGroupType},
+			protopack.Tag{3, protopack.EndGroupType},
+		}.Marshal(),
+	},
+	{
+		desc:          "required field in repeated group set",
+		checkFastInit: true,
+		decodeTo: makeMessages(protobuild.Message{
+			"repeatedgroup": []protobuild.Message{
+				{"a": 1},
+				{"a": 2},
+			},
+		}, &testpb.TestRequiredGroupFields{}),
+		wire: protopack.Message{
+			protopack.Tag{3, protopack.StartGroupType},
+			protopack.Tag{4, protopack.VarintType}, protopack.Varint(1),
+			protopack.Tag{3, protopack.EndGroupType},
+			protopack.Tag{3, protopack.StartGroupType},
+			protopack.Tag{4, protopack.VarintType}, protopack.Varint(2),
+			protopack.Tag{3, protopack.EndGroupType},
+		}.Marshal(),
+	},
+	{
+		desc:          "required field in oneof message unset",
+		checkFastInit: true,
+		partial:       true,
+		decodeTo: makeMessages(protobuild.Message{
+			"oneof_message": protobuild.Message{},
+		}, &testpb.TestRequiredForeign{}),
+		wire: protopack.Message{protopack.Tag{4, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{})}.Marshal(),
+	},
+	{
+		desc:          "required field in oneof message set",
+		checkFastInit: true,
+		decodeTo: makeMessages(protobuild.Message{
+			"oneof_message": protobuild.Message{
+				"required_field": 1,
+			},
+		}, &testpb.TestRequiredForeign{}),
+		wire: protopack.Message{protopack.Tag{4, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+			protopack.Tag{1, protopack.VarintType}, protopack.Varint(1),
+		})}.Marshal(),
+	},
+	{
+		desc:          "required field in extension message unset",
+		checkFastInit: true,
+		partial:       true,
+		decodeTo: makeMessages(protobuild.Message{
+			"single": protobuild.Message{},
+		}, &testpb.TestAllExtensions{}),
+		wire: protopack.Message{
+			protopack.Tag{1000, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{}),
+		}.Marshal(),
+	},
+	{
+		desc:          "required field in extension message set",
+		checkFastInit: true,
+		decodeTo: makeMessages(protobuild.Message{
+			"single": protobuild.Message{
+				"required_field": 1,
+			},
+		}, &testpb.TestAllExtensions{}),
+		wire: protopack.Message{
+			protopack.Tag{1000, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(1),
+			}),
+		}.Marshal(),
+	},
+	{
+		desc:          "required field in repeated extension message unset",
+		checkFastInit: true,
+		partial:       true,
+		decodeTo: makeMessages(protobuild.Message{
+			"multi": []protobuild.Message{
+				{"required_field": 1},
+				{},
+			},
+		}, &testpb.TestAllExtensions{}),
+		wire: protopack.Message{
+			protopack.Tag{1001, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(1),
+			}),
+			protopack.Tag{1001, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{}),
+		}.Marshal(),
+	},
+	{
+		desc:          "required field in repeated extension message set",
+		checkFastInit: true,
+		decodeTo: makeMessages(protobuild.Message{
+			"multi": []protobuild.Message{
+				{"required_field": 1},
+				{"required_field": 2},
+			},
+		}, &testpb.TestAllExtensions{}),
+		wire: protopack.Message{
+			protopack.Tag{1001, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(1),
+			}),
+			protopack.Tag{1001, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(2),
+			}),
+		}.Marshal(),
+	},
+	{
+		desc: "nil messages",
+		decodeTo: []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+			(*test3pb.TestAllTypes)(nil),
+			(*testpb.TestAllExtensions)(nil),
+		},
+	},
+	{
+		desc:    "legacy",
+		partial: true,
+		decodeTo: makeMessages(protobuild.Message{
+			"f1": protobuild.Message{
+				"optional_int32":      1,
+				"optional_child_enum": "ALPHA",
+				"optional_child_message": protobuild.Message{
+					"f1": "x",
+				},
+				"optionalgroup": protobuild.Message{
+					"f1": "x",
+				},
+				"repeated_child_message": []protobuild.Message{
+					{"f1": "x"},
+				},
+				"repeatedgroup": []protobuild.Message{
+					{"f1": "x"},
+				},
+				"map_bool_child_message": map[bool]protobuild.Message{
+					true: {"f1": "x"},
+				},
+				"oneof_child_message": protobuild.Message{
+					"f1": "x",
+				},
+			},
+		}, &legacypb.Legacy{}),
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{101, protopack.VarintType}, protopack.Varint(1),
+				protopack.Tag{115, protopack.VarintType}, protopack.Varint(0),
+				protopack.Tag{116, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+					protopack.Tag{1, protopack.BytesType}, protopack.String("x"),
+				}),
+				protopack.Tag{120, protopack.StartGroupType},
+				protopack.Tag{1, protopack.BytesType}, protopack.String("x"),
+				protopack.Tag{120, protopack.EndGroupType},
+				protopack.Tag{516, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+					protopack.Tag{1, protopack.BytesType}, protopack.String("x"),
+				}),
+				protopack.Tag{520, protopack.StartGroupType},
+				protopack.Tag{1, protopack.BytesType}, protopack.String("x"),
+				protopack.Tag{520, protopack.EndGroupType},
+				protopack.Tag{616, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+					protopack.Tag{1, protopack.VarintType}, protopack.Varint(1),
+					protopack.Tag{2, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+						protopack.Tag{1, protopack.BytesType}, protopack.String("x"),
+					}),
+				}),
+				protopack.Tag{716, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+					protopack.Tag{1, protopack.BytesType}, protopack.String("x"),
+				}),
+			}),
+		}.Marshal(),
+		validationStatus: impl.ValidationUnknown,
+	},
+	{
+		desc: "first reserved field number",
+		decodeTo: makeMessages(protobuild.Message{
+			protobuild.Unknown: protopack.Message{
+				protopack.Tag{protopack.FirstReservedNumber, protopack.VarintType}, protopack.Varint(1004),
+			}.Marshal(),
+		}),
+		wire: protopack.Message{
+			protopack.Tag{protopack.FirstReservedNumber, protopack.VarintType}, protopack.Varint(1004),
+		}.Marshal(),
+	},
+	{
+		desc: "last reserved field number",
+		decodeTo: makeMessages(protobuild.Message{
+			protobuild.Unknown: protopack.Message{
+				protopack.Tag{protopack.LastReservedNumber, protopack.VarintType}, protopack.Varint(1005),
+			}.Marshal(),
+		}),
+		wire: protopack.Message{
+			protopack.Tag{protopack.LastReservedNumber, protopack.VarintType}, protopack.Varint(1005),
+		}.Marshal(),
+	},
+	{
+		desc: "nested unknown extension",
+		unmarshalOptions: proto.UnmarshalOptions{
+			DiscardUnknown: true,
+			Resolver: filterResolver{
+				filter: func(name protoreflect.FullName) bool {
+					switch name.Name() {
+					case "optional_nested_message",
+						"optional_int32":
+						return true
+					}
+					return false
+				},
+				resolver: protoregistry.GlobalTypes,
+			},
+		},
+		decodeTo: makeMessages(protobuild.Message{
+			"optional_nested_message": protobuild.Message{
+				"corecursive": protobuild.Message{
+					"optional_nested_message": protobuild.Message{
+						"corecursive": protobuild.Message{
+							"optional_int32": 42,
+						},
+					},
+				},
+			},
+		}, &testpb.TestAllExtensions{}),
+		wire: protopack.Message{
+			protopack.Tag{18, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{2, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+					protopack.Tag{18, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+						protopack.Tag{2, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+							protopack.Tag{1, protopack.VarintType}, protopack.Varint(42),
+							protopack.Tag{2, protopack.VarintType}, protopack.Varint(43),
+						}),
+					}),
+				}),
+			}),
+		}.Marshal(),
+	},
+}
+
+var testInvalidMessages = []testProto{
+	{
+		desc: "invalid UTF-8 in optional string field",
+		decodeTo: makeMessages(protobuild.Message{
+			"optional_string": "abc\xff",
+		}, &test3pb.TestAllTypes{}),
+		wire: protopack.Message{
+			protopack.Tag{14, protopack.BytesType}, protopack.String("abc\xff"),
+		}.Marshal(),
+	},
+	{
+		desc: "invalid UTF-8 in singular string field",
+		decodeTo: makeMessages(protobuild.Message{
+			"singular_string": "abc\xff",
+		}, &test3pb.TestAllTypes{}),
+		wire: protopack.Message{
+			protopack.Tag{94, protopack.BytesType}, protopack.String("abc\xff"),
+		}.Marshal(),
+	},
+	{
+		desc: "invalid UTF-8 in repeated string field",
+		decodeTo: makeMessages(protobuild.Message{
+			"repeated_string": []string{"foo", "abc\xff"},
+		}, &test3pb.TestAllTypes{}),
+		wire: protopack.Message{
+			protopack.Tag{44, protopack.BytesType}, protopack.String("foo"),
+			protopack.Tag{44, protopack.BytesType}, protopack.String("abc\xff"),
+		}.Marshal(),
+	},
+	{
+		desc: "invalid UTF-8 in nested message",
+		decodeTo: makeMessages(protobuild.Message{
+			"optional_nested_message": protobuild.Message{
+				"corecursive": protobuild.Message{
+					"singular_string": "abc\xff",
+				},
+			},
+		}, &test3pb.TestAllTypes{}),
+		wire: protopack.Message{
+			protopack.Tag{18, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{2, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+					protopack.Tag{94, protopack.BytesType}, protopack.String("abc\xff"),
+				}),
+			}),
+		}.Marshal(),
+	},
+	{
+		desc: "invalid UTF-8 in oneof field",
+		decodeTo: makeMessages(protobuild.Message{
+			"oneof_string": "abc\xff",
+		}, &test3pb.TestAllTypes{}),
+		wire: protopack.Message{protopack.Tag{113, protopack.BytesType}, protopack.String("abc\xff")}.Marshal(),
+	},
+	{
+		desc: "invalid UTF-8 in map key",
+		decodeTo: makeMessages(protobuild.Message{
+			"map_string_string": map[string]string{"key\xff": "val"},
+		}, &test3pb.TestAllTypes{}),
+		wire: protopack.Message{
+			protopack.Tag{69, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.BytesType}, protopack.String("key\xff"),
+				protopack.Tag{2, protopack.BytesType}, protopack.String("val"),
+			}),
+		}.Marshal(),
+	},
+	{
+		desc: "invalid UTF-8 in map value",
+		decodeTo: makeMessages(protobuild.Message{
+			"map_string_string": map[string]string{"key": "val\xff"},
+		}, &test3pb.TestAllTypes{}),
+		wire: protopack.Message{
+			protopack.Tag{69, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.BytesType}, protopack.String("key"),
+				protopack.Tag{2, protopack.BytesType}, protopack.String("val\xff"),
+			}),
+		}.Marshal(),
+	},
+	{
+		desc: "invalid field number zero",
+		decodeTo: []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+			(*testpb.TestAllExtensions)(nil),
+		},
+		wire: protopack.Message{
+			protopack.Tag{protopack.MinValidNumber - 1, protopack.VarintType}, protopack.Varint(1001),
+		}.Marshal(),
+	},
+	{
+		desc: "invalid field numbers zero and one",
+		decodeTo: []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+			(*testpb.TestAllExtensions)(nil),
+		},
+		wire: protopack.Message{
+			protopack.Tag{protopack.MinValidNumber - 1, protopack.VarintType}, protopack.Varint(1002),
+			protopack.Tag{protopack.MinValidNumber, protopack.VarintType}, protopack.Varint(1003),
+		}.Marshal(),
+	},
+	{
+		desc: "invalid field numbers max and max+1",
+		decodeTo: []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+			(*testpb.TestAllExtensions)(nil),
+		},
+		wire: protopack.Message{
+			protopack.Tag{protopack.MaxValidNumber, protopack.VarintType}, protopack.Varint(1006),
+			protopack.Tag{protopack.MaxValidNumber + 1, protopack.VarintType}, protopack.Varint(1007),
+		}.Marshal(),
+	},
+	{
+		desc: "invalid field number max+1",
+		decodeTo: []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+			(*testpb.TestAllExtensions)(nil),
+		},
+		wire: protopack.Message{
+			protopack.Tag{protopack.MaxValidNumber + 1, protopack.VarintType}, protopack.Varint(1008),
+		}.Marshal(),
+	},
+	{
+		desc: "invalid field number wraps int32",
+		decodeTo: []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+			(*testpb.TestAllExtensions)(nil),
+		},
+		wire: protopack.Message{
+			protopack.Varint(2234993595104), protopack.Varint(0),
+		}.Marshal(),
+	},
+	{
+		desc:     "invalid field number in map",
+		decodeTo: []proto.Message{(*testpb.TestAllTypes)(nil)},
+		wire: protopack.Message{
+			protopack.Tag{56, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(1056),
+				protopack.Tag{2, protopack.VarintType}, protopack.Varint(1156),
+				protopack.Tag{protopack.MaxValidNumber + 1, protopack.VarintType}, protopack.Varint(0),
+			}),
+		}.Marshal(),
+	},
+	{
+		desc: "invalid tag varint",
+		decodeTo: []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+			(*testpb.TestAllExtensions)(nil),
+		},
+		wire: []byte{0xff},
+	},
+	{
+		desc: "field number too small",
+		decodeTo: []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+			(*testpb.TestAllExtensions)(nil),
+		},
+		wire: protopack.Message{
+			protopack.Tag{0, protopack.VarintType}, protopack.Varint(0),
+		}.Marshal(),
+	},
+	{
+		desc: "field number too large",
+		decodeTo: []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+			(*testpb.TestAllExtensions)(nil),
+		},
+		wire: protopack.Message{
+			protopack.Tag{protowire.MaxValidNumber + 1, protopack.VarintType}, protopack.Varint(0),
+		}.Marshal(),
+	},
+	{
+		desc: "invalid tag varint in message field",
+		decodeTo: []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+			(*testpb.TestAllExtensions)(nil),
+		},
+		wire: protopack.Message{
+			protopack.Tag{18, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Raw{0xff},
+			}),
+		}.Marshal(),
+	},
+	{
+		desc: "invalid tag varint in repeated message field",
+		decodeTo: []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+			(*testpb.TestAllExtensions)(nil),
+		},
+		wire: protopack.Message{
+			protopack.Tag{48, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Raw{0xff},
+			}),
+		}.Marshal(),
+	},
+	{
+		desc: "invalid varint in group field",
+		decodeTo: []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+			(*testpb.TestAllExtensions)(nil),
+		},
+		wire: protopack.Message{
+			protopack.Tag{16, protopack.StartGroupType},
+			protopack.Tag{1000, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Raw{0xff},
+			}),
+			protopack.Tag{16, protopack.EndGroupType},
+		}.Marshal(),
+	},
+	{
+		desc: "invalid varint in repeated group field",
+		decodeTo: []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+			(*testpb.TestAllExtensions)(nil),
+		},
+		wire: protopack.Message{
+			protopack.Tag{46, protopack.StartGroupType},
+			protopack.Tag{1001, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Raw{0xff},
+			}),
+			protopack.Tag{46, protopack.EndGroupType},
+		}.Marshal(),
+	},
+	{
+		desc: "unterminated repeated group field",
+		decodeTo: []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+			(*testpb.TestAllExtensions)(nil),
+		},
+		wire: protopack.Message{
+			protopack.Tag{46, protopack.StartGroupType},
+		}.Marshal(),
+	},
+	{
+		desc: "invalid tag varint in map item",
+		decodeTo: []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+		},
+		wire: protopack.Message{
+			protopack.Tag{56, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(0),
+				protopack.Tag{2, protopack.VarintType}, protopack.Varint(0),
+				protopack.Raw{0xff},
+			}),
+		}.Marshal(),
+	},
+	{
+		desc: "invalid tag varint in map message value",
+		decodeTo: []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+		},
+		wire: protopack.Message{
+			protopack.Tag{71, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(0),
+				protopack.Tag{2, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+					protopack.Raw{0xff},
+				}),
+			}),
+		}.Marshal(),
+	},
+	{
+		desc: "invalid packed int32 field",
+		decodeTo: []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+			(*testpb.TestAllExtensions)(nil),
+		},
+		wire: protopack.Message{
+			protopack.Tag{31, protopack.BytesType}, protopack.Bytes{0xff},
+		}.Marshal(),
+	},
+	{
+		desc: "invalid packed int64 field",
+		decodeTo: []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+			(*testpb.TestAllExtensions)(nil),
+		},
+		wire: protopack.Message{
+			protopack.Tag{32, protopack.BytesType}, protopack.Bytes{0xff},
+		}.Marshal(),
+	},
+	{
+		desc: "invalid packed uint32 field",
+		decodeTo: []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+			(*testpb.TestAllExtensions)(nil),
+		},
+		wire: protopack.Message{
+			protopack.Tag{33, protopack.BytesType}, protopack.Bytes{0xff},
+		}.Marshal(),
+	},
+	{
+		desc: "invalid packed uint64 field",
+		decodeTo: []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+			(*testpb.TestAllExtensions)(nil),
+		},
+		wire: protopack.Message{
+			protopack.Tag{34, protopack.BytesType}, protopack.Bytes{0xff},
+		}.Marshal(),
+	},
+	{
+		desc: "invalid packed sint32 field",
+		decodeTo: []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+			(*testpb.TestAllExtensions)(nil),
+		},
+		wire: protopack.Message{
+			protopack.Tag{35, protopack.BytesType}, protopack.Bytes{0xff},
+		}.Marshal(),
+	},
+	{
+		desc: "invalid packed sint64 field",
+		decodeTo: []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+			(*testpb.TestAllExtensions)(nil),
+		},
+		wire: protopack.Message{
+			protopack.Tag{36, protopack.BytesType}, protopack.Bytes{0xff},
+		}.Marshal(),
+	},
+	{
+		desc: "invalid packed fixed32 field",
+		decodeTo: []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+			(*testpb.TestAllExtensions)(nil),
+		},
+		wire: protopack.Message{
+			protopack.Tag{37, protopack.BytesType}, protopack.Bytes{0x00},
+		}.Marshal(),
+	},
+	{
+		desc: "invalid packed fixed64 field",
+		decodeTo: []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+			(*testpb.TestAllExtensions)(nil),
+		},
+		wire: protopack.Message{
+			protopack.Tag{38, protopack.BytesType}, protopack.Bytes{0x00},
+		}.Marshal(),
+	},
+	{
+		desc: "invalid packed sfixed32 field",
+		decodeTo: []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+			(*testpb.TestAllExtensions)(nil),
+		},
+		wire: protopack.Message{
+			protopack.Tag{39, protopack.BytesType}, protopack.Bytes{0x00},
+		}.Marshal(),
+	},
+	{
+		desc: "invalid packed sfixed64 field",
+		decodeTo: []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+			(*testpb.TestAllExtensions)(nil),
+		},
+		wire: protopack.Message{
+			protopack.Tag{40, protopack.BytesType}, protopack.Bytes{0x00},
+		}.Marshal(),
+	},
+	{
+		desc: "invalid packed float field",
+		decodeTo: []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+			(*testpb.TestAllExtensions)(nil),
+		},
+		wire: protopack.Message{
+			protopack.Tag{41, protopack.BytesType}, protopack.Bytes{0x00},
+		}.Marshal(),
+	},
+	{
+		desc: "invalid packed double field",
+		decodeTo: []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+			(*testpb.TestAllExtensions)(nil),
+		},
+		wire: protopack.Message{
+			protopack.Tag{42, protopack.BytesType}, protopack.Bytes{0x00},
+		}.Marshal(),
+	},
+	{
+		desc: "invalid packed bool field",
+		decodeTo: []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+			(*testpb.TestAllExtensions)(nil),
+		},
+		wire: protopack.Message{
+			protopack.Tag{43, protopack.BytesType}, protopack.Bytes{0xff},
+		}.Marshal(),
+	},
+	{
+		desc: "bytes field overruns message",
+		decodeTo: []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+			(*testpb.TestAllExtensions)(nil),
+		},
+		wire: protopack.Message{
+			protopack.Tag{18, protopack.BytesType}, protopack.LengthPrefix{protopack.Message{
+				protopack.Tag{2, protopack.BytesType}, protopack.LengthPrefix{protopack.Message{
+					protopack.Tag{15, protopack.BytesType}, protopack.Varint(2),
+				}},
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(0),
+			}},
+		}.Marshal(),
+	},
+	{
+		desc: "varint field overruns message",
+		decodeTo: []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+			(*testpb.TestAllExtensions)(nil),
+		},
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.VarintType},
+		}.Marshal(),
+	},
+	{
+		desc: "bytes field lacks size",
+		decodeTo: []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+			(*testpb.TestAllExtensions)(nil),
+		},
+		wire: protopack.Message{
+			protopack.Tag{18, protopack.BytesType},
+		}.Marshal(),
+	},
+	{
+		desc: "varint overflow",
+		decodeTo: []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+			(*testpb.TestAllExtensions)(nil),
+		},
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.VarintType},
+			protopack.Raw("\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02"),
+		}.Marshal(),
+	},
+	{
+		desc: "varint length overrun",
+		decodeTo: []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+			(*testpb.TestAllExtensions)(nil),
+		},
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.VarintType},
+			protopack.Raw("\xff\xff\xff\xff\xff\xff\xff\xff\xff"),
+		}.Marshal(),
+	},
+}
+
+type filterResolver struct {
+	filter   func(name protoreflect.FullName) bool
+	resolver protoregistry.ExtensionTypeResolver
+}
+
+func (f filterResolver) FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error) {
+	if !f.filter(field) {
+		return nil, protoregistry.NotFound
+	}
+	return f.resolver.FindExtensionByName(field)
+}
+
+func (f filterResolver) FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error) {
+	xt, err := f.resolver.FindExtensionByNumber(message, field)
+	if err != nil {
+		return nil, err
+	}
+	if !f.filter(xt.TypeDescriptor().FullName()) {
+		return nil, protoregistry.NotFound
+	}
+	return xt, nil
+}
diff --git a/vendor/google.golang.org/protobuf/proto/validate_test.go b/vendor/google.golang.org/protobuf/proto/validate_test.go
new file mode 100644
index 000000000..e8069983d
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/proto/validate_test.go
@@ -0,0 +1,58 @@
+// Copyright 2019 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 proto_test
+
+import (
+	"fmt"
+	"testing"
+
+	"google.golang.org/protobuf/internal/impl"
+	piface "google.golang.org/protobuf/runtime/protoiface"
+)
+
+// TestValidate tests the internal message validator.
+//
+// Despite being more properly associated with the internal/impl package,
+// it is located here to take advantage of the test wire encoder/decoder inputs.
+
+func TestValidateValid(t *testing.T) {
+	for _, test := range testValidMessages {
+		for _, m := range test.decodeTo {
+			t.Run(fmt.Sprintf("%s (%T)", test.desc, m), func(t *testing.T) {
+				mt := m.ProtoReflect().Type()
+				want := impl.ValidationValid
+				if test.validationStatus != 0 {
+					want = test.validationStatus
+				}
+				out, status := impl.Validate(mt, piface.UnmarshalInput{
+					Buf: test.wire,
+				})
+				if status != want {
+					t.Errorf("Validate(%x) = %v, want %v", test.wire, status, want)
+				}
+				if got, want := (out.Flags&piface.UnmarshalInitialized != 0), !test.partial; got != want && !test.nocheckValidInit && status == impl.ValidationValid {
+					t.Errorf("Validate(%x): initialized = %v, want %v", test.wire, got, want)
+				}
+			})
+		}
+	}
+}
+
+func TestValidateInvalid(t *testing.T) {
+	for _, test := range testInvalidMessages {
+		for _, m := range test.decodeTo {
+			t.Run(fmt.Sprintf("%s (%T)", test.desc, m), func(t *testing.T) {
+				mt := m.ProtoReflect().Type()
+				_, got := impl.Validate(mt, piface.UnmarshalInput{
+					Buf: test.wire,
+				})
+				want := impl.ValidationInvalid
+				if got != want {
+					t.Errorf("Validate(%x) = %v, want %v", test.wire, got, want)
+				}
+			})
+		}
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/proto/weak_test.go b/vendor/google.golang.org/protobuf/proto/weak_test.go
new file mode 100644
index 000000000..79340e395
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/proto/weak_test.go
@@ -0,0 +1,125 @@
+// Copyright 2019 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 proto_test
+
+import (
+	"testing"
+
+	"google.golang.org/protobuf/internal/flags"
+	"google.golang.org/protobuf/internal/protobuild"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/testing/protopack"
+
+	testpb "google.golang.org/protobuf/internal/testprotos/test"
+	weakpb "google.golang.org/protobuf/internal/testprotos/test/weak1"
+)
+
+func init() {
+	if flags.ProtoLegacy {
+		testValidMessages = append(testValidMessages, testWeakValidMessages...)
+		testInvalidMessages = append(testInvalidMessages, testWeakInvalidMessages...)
+		testMerges = append(testMerges, testWeakMerges...)
+	}
+}
+
+var testWeakValidMessages = []testProto{
+	{
+		desc: "weak message",
+		decodeTo: []proto.Message{
+			func() proto.Message {
+				if !flags.ProtoLegacy {
+					return nil
+				}
+				m := &testpb.TestWeak{}
+				m.SetWeakMessage1(&weakpb.WeakImportMessage1{
+					A: proto.Int32(1000),
+				})
+				m.ProtoReflect().SetUnknown(protopack.Message{
+					protopack.Tag{2, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+						protopack.Tag{1, protopack.VarintType}, protopack.Varint(2000),
+					}),
+				}.Marshal())
+				return m
+			}(),
+		},
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(1000),
+			}),
+			protopack.Tag{2, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{1, protopack.VarintType}, protopack.Varint(2000),
+			}),
+		}.Marshal(),
+	},
+}
+
+var testWeakInvalidMessages = []testProto{
+	{
+		desc:     "invalid field number 0 in weak message",
+		decodeTo: []proto.Message{(*testpb.TestWeak)(nil)},
+		wire: protopack.Message{
+			protopack.Tag{1, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+				protopack.Tag{0, protopack.VarintType}, protopack.Varint(1000),
+			}),
+		}.Marshal(),
+	},
+}
+
+var testWeakMerges = []testMerge{
+	{
+		desc: "clone weak message",
+		src: protobuild.Message{
+			"weak_message1": protobuild.Message{
+				"a": 1,
+			},
+		},
+		types: []proto.Message{&testpb.TestWeak{}},
+	}, {
+		desc: "merge weak message",
+		dst: protobuild.Message{
+			"weak_message1": protobuild.Message{
+				"a": 1,
+			},
+		},
+		src: protobuild.Message{
+			"weak_message1": protobuild.Message{
+				"a": 2,
+			},
+		},
+		want: protobuild.Message{
+			"weak_message1": protobuild.Message{
+				"a": 2,
+			},
+		},
+		types: []proto.Message{&testpb.TestWeak{}},
+	},
+}
+
+func TestWeakNil(t *testing.T) {
+	if !flags.ProtoLegacy {
+		t.SkipNow()
+	}
+
+	m := new(testpb.TestWeak)
+	if v, ok := m.GetWeakMessage1().(*weakpb.WeakImportMessage1); !ok || v != nil {
+		t.Errorf("m.GetWeakMessage1() = type %[1]T(%[1]v), want (*weakpb.WeakImportMessage1)", v)
+	}
+}
+
+func TestWeakMarshalNil(t *testing.T) {
+	if !flags.ProtoLegacy {
+		t.SkipNow()
+	}
+
+	m := new(testpb.TestWeak)
+	m.SetWeakMessage1(nil)
+	if b, err := proto.Marshal(m); err != nil || len(b) != 0 {
+		t.Errorf("Marshal(weak field set to nil) = [%x], %v; want [], nil", b, err)
+	}
+	m.SetWeakMessage1((*weakpb.WeakImportMessage1)(nil))
+	if b, err := proto.Marshal(m); err != nil || len(b) != 0 {
+		t.Errorf("Marshal(weak field set to typed nil) = [%x], %v; want [], nil", b, err)
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/proto/wrappers.go b/vendor/google.golang.org/protobuf/proto/wrappers.go
new file mode 100644
index 000000000..653b12c3a
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/proto/wrappers.go
@@ -0,0 +1,29 @@
+// Copyright 2019 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 proto
+
+// Bool stores v in a new bool value and returns a pointer to it.
+func Bool(v bool) *bool { return &v }
+
+// Int32 stores v in a new int32 value and returns a pointer to it.
+func Int32(v int32) *int32 { return &v }
+
+// Int64 stores v in a new int64 value and returns a pointer to it.
+func Int64(v int64) *int64 { return &v }
+
+// Float32 stores v in a new float32 value and returns a pointer to it.
+func Float32(v float32) *float32 { return &v }
+
+// Float64 stores v in a new float64 value and returns a pointer to it.
+func Float64(v float64) *float64 { return &v }
+
+// Uint32 stores v in a new uint32 value and returns a pointer to it.
+func Uint32(v uint32) *uint32 { return &v }
+
+// Uint64 stores v in a new uint64 value and returns a pointer to it.
+func Uint64(v uint64) *uint64 { return &v }
+
+// String stores v in a new string value and returns a pointer to it.
+func String(v string) *string { return &v }
diff --git a/vendor/google.golang.org/protobuf/reflect/protodesc/desc.go b/vendor/google.golang.org/protobuf/reflect/protodesc/desc.go
new file mode 100644
index 000000000..37f254d4c
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/reflect/protodesc/desc.go
@@ -0,0 +1,275 @@
+// 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 protodesc provides functionality for converting
+// FileDescriptorProto messages to/from protoreflect.FileDescriptor values.
+//
+// The google.protobuf.FileDescriptorProto is a protobuf message that describes
+// the type information for a .proto file in a form that is easily serializable.
+// The protoreflect.FileDescriptor is a more structured representation of
+// the FileDescriptorProto message where references and remote dependencies
+// can be directly followed.
+package protodesc
+
+import (
+	"google.golang.org/protobuf/internal/errors"
+	"google.golang.org/protobuf/internal/filedesc"
+	"google.golang.org/protobuf/internal/pragma"
+	"google.golang.org/protobuf/internal/strs"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/reflect/protoregistry"
+
+	"google.golang.org/protobuf/types/descriptorpb"
+)
+
+// Resolver is the resolver used by NewFile to resolve dependencies.
+// The enums and messages provided must belong to some parent file,
+// which is also registered.
+//
+// It is implemented by protoregistry.Files.
+type Resolver interface {
+	FindFileByPath(string) (protoreflect.FileDescriptor, error)
+	FindDescriptorByName(protoreflect.FullName) (protoreflect.Descriptor, error)
+}
+
+// FileOptions configures the construction of file descriptors.
+type FileOptions struct {
+	pragma.NoUnkeyedLiterals
+
+	// AllowUnresolvable configures New to permissively allow unresolvable
+	// file, enum, or message dependencies. Unresolved dependencies are replaced
+	// by placeholder equivalents.
+	//
+	// The following dependencies may be left unresolved:
+	//	• Resolving an imported file.
+	//	• Resolving the type for a message field or extension field.
+	//	If the kind of the field is unknown, then a placeholder is used for both
+	//	the Enum and Message accessors on the protoreflect.FieldDescriptor.
+	//	• Resolving an enum value set as the default for an optional enum field.
+	//	If unresolvable, the protoreflect.FieldDescriptor.Default is set to the
+	//	first value in the associated enum (or zero if the also enum dependency
+	//	is also unresolvable). The protoreflect.FieldDescriptor.DefaultEnumValue
+	//	is populated with a placeholder.
+	//	• Resolving the extended message type for an extension field.
+	//	• Resolving the input or output message type for a service method.
+	//
+	// If the unresolved dependency uses a relative name,
+	// then the placeholder will contain an invalid FullName with a "*." prefix,
+	// indicating that the starting prefix of the full name is unknown.
+	AllowUnresolvable bool
+}
+
+// NewFile creates a new protoreflect.FileDescriptor from the provided
+// file descriptor message. See FileOptions.New for more information.
+func NewFile(fd *descriptorpb.FileDescriptorProto, r Resolver) (protoreflect.FileDescriptor, error) {
+	return FileOptions{}.New(fd, r)
+}
+
+// NewFiles creates a new protoregistry.Files from the provided
+// FileDescriptorSet message. See FileOptions.NewFiles for more information.
+func NewFiles(fd *descriptorpb.FileDescriptorSet) (*protoregistry.Files, error) {
+	return FileOptions{}.NewFiles(fd)
+}
+
+// New creates a new protoreflect.FileDescriptor from the provided
+// file descriptor message. The file must represent a valid proto file according
+// to protobuf semantics. The returned descriptor is a deep copy of the input.
+//
+// Any imported files, enum types, or message types referenced in the file are
+// resolved using the provided registry. When looking up an import file path,
+// the path must be unique. The newly created file descriptor is not registered
+// back into the provided file registry.
+func (o FileOptions) New(fd *descriptorpb.FileDescriptorProto, r Resolver) (protoreflect.FileDescriptor, error) {
+	if r == nil {
+		r = (*protoregistry.Files)(nil) // empty resolver
+	}
+
+	// Handle the file descriptor content.
+	f := &filedesc.File{L2: &filedesc.FileL2{}}
+	switch fd.GetSyntax() {
+	case "proto2", "":
+		f.L1.Syntax = protoreflect.Proto2
+	case "proto3":
+		f.L1.Syntax = protoreflect.Proto3
+	default:
+		return nil, errors.New("invalid syntax: %q", fd.GetSyntax())
+	}
+	f.L1.Path = fd.GetName()
+	if f.L1.Path == "" {
+		return nil, errors.New("file path must be populated")
+	}
+	f.L1.Package = protoreflect.FullName(fd.GetPackage())
+	if !f.L1.Package.IsValid() && f.L1.Package != "" {
+		return nil, errors.New("invalid package: %q", f.L1.Package)
+	}
+	if opts := fd.GetOptions(); opts != nil {
+		opts = proto.Clone(opts).(*descriptorpb.FileOptions)
+		f.L2.Options = func() protoreflect.ProtoMessage { return opts }
+	}
+
+	f.L2.Imports = make(filedesc.FileImports, len(fd.GetDependency()))
+	for _, i := range fd.GetPublicDependency() {
+		if !(0 <= i && int(i) < len(f.L2.Imports)) || f.L2.Imports[i].IsPublic {
+			return nil, errors.New("invalid or duplicate public import index: %d", i)
+		}
+		f.L2.Imports[i].IsPublic = true
+	}
+	for _, i := range fd.GetWeakDependency() {
+		if !(0 <= i && int(i) < len(f.L2.Imports)) || f.L2.Imports[i].IsWeak {
+			return nil, errors.New("invalid or duplicate weak import index: %d", i)
+		}
+		f.L2.Imports[i].IsWeak = true
+	}
+	imps := importSet{f.Path(): true}
+	for i, path := range fd.GetDependency() {
+		imp := &f.L2.Imports[i]
+		f, err := r.FindFileByPath(path)
+		if err == protoregistry.NotFound && (o.AllowUnresolvable || imp.IsWeak) {
+			f = filedesc.PlaceholderFile(path)
+		} else if err != nil {
+			return nil, errors.New("could not resolve import %q: %v", path, err)
+		}
+		imp.FileDescriptor = f
+
+		if imps[imp.Path()] {
+			return nil, errors.New("already imported %q", path)
+		}
+		imps[imp.Path()] = true
+	}
+	for i := range fd.GetDependency() {
+		imp := &f.L2.Imports[i]
+		imps.importPublic(imp.Imports())
+	}
+
+	// Handle source locations.
+	for _, loc := range fd.GetSourceCodeInfo().GetLocation() {
+		var l protoreflect.SourceLocation
+		// TODO: Validate that the path points to an actual declaration?
+		l.Path = protoreflect.SourcePath(loc.GetPath())
+		s := loc.GetSpan()
+		switch len(s) {
+		case 3:
+			l.StartLine, l.StartColumn, l.EndLine, l.EndColumn = int(s[0]), int(s[1]), int(s[0]), int(s[2])
+		case 4:
+			l.StartLine, l.StartColumn, l.EndLine, l.EndColumn = int(s[0]), int(s[1]), int(s[2]), int(s[3])
+		default:
+			return nil, errors.New("invalid span: %v", s)
+		}
+		// TODO: Validate that the span information is sensible?
+		// See https://github.com/protocolbuffers/protobuf/issues/6378.
+		if false && (l.EndLine < l.StartLine || l.StartLine < 0 || l.StartColumn < 0 || l.EndColumn < 0 ||
+			(l.StartLine == l.EndLine && l.EndColumn <= l.StartColumn)) {
+			return nil, errors.New("invalid span: %v", s)
+		}
+		l.LeadingDetachedComments = loc.GetLeadingDetachedComments()
+		l.LeadingComments = loc.GetLeadingComments()
+		l.TrailingComments = loc.GetTrailingComments()
+		f.L2.Locations.List = append(f.L2.Locations.List, l)
+	}
+
+	// Step 1: Allocate and derive the names for all declarations.
+	// This copies all fields from the descriptor proto except:
+	//	google.protobuf.FieldDescriptorProto.type_name
+	//	google.protobuf.FieldDescriptorProto.default_value
+	//	google.protobuf.FieldDescriptorProto.oneof_index
+	//	google.protobuf.FieldDescriptorProto.extendee
+	//	google.protobuf.MethodDescriptorProto.input
+	//	google.protobuf.MethodDescriptorProto.output
+	var err error
+	sb := new(strs.Builder)
+	r1 := make(descsByName)
+	if f.L1.Enums.List, err = r1.initEnumDeclarations(fd.GetEnumType(), f, sb); err != nil {
+		return nil, err
+	}
+	if f.L1.Messages.List, err = r1.initMessagesDeclarations(fd.GetMessageType(), f, sb); err != nil {
+		return nil, err
+	}
+	if f.L1.Extensions.List, err = r1.initExtensionDeclarations(fd.GetExtension(), f, sb); err != nil {
+		return nil, err
+	}
+	if f.L1.Services.List, err = r1.initServiceDeclarations(fd.GetService(), f, sb); err != nil {
+		return nil, err
+	}
+
+	// Step 2: Resolve every dependency reference not handled by step 1.
+	r2 := &resolver{local: r1, remote: r, imports: imps, allowUnresolvable: o.AllowUnresolvable}
+	if err := r2.resolveMessageDependencies(f.L1.Messages.List, fd.GetMessageType()); err != nil {
+		return nil, err
+	}
+	if err := r2.resolveExtensionDependencies(f.L1.Extensions.List, fd.GetExtension()); err != nil {
+		return nil, err
+	}
+	if err := r2.resolveServiceDependencies(f.L1.Services.List, fd.GetService()); err != nil {
+		return nil, err
+	}
+
+	// Step 3: Validate every enum, message, and extension declaration.
+	if err := validateEnumDeclarations(f.L1.Enums.List, fd.GetEnumType()); err != nil {
+		return nil, err
+	}
+	if err := validateMessageDeclarations(f.L1.Messages.List, fd.GetMessageType()); err != nil {
+		return nil, err
+	}
+	if err := validateExtensionDeclarations(f.L1.Extensions.List, fd.GetExtension()); err != nil {
+		return nil, err
+	}
+
+	return f, nil
+}
+
+type importSet map[string]bool
+
+func (is importSet) importPublic(imps protoreflect.FileImports) {
+	for i := 0; i < imps.Len(); i++ {
+		if imp := imps.Get(i); imp.IsPublic {
+			is[imp.Path()] = true
+			is.importPublic(imp.Imports())
+		}
+	}
+}
+
+// NewFiles creates a new protoregistry.Files from the provided
+// FileDescriptorSet message. The descriptor set must include only
+// valid files according to protobuf semantics. The returned descriptors
+// are a deep copy of the input.
+func (o FileOptions) NewFiles(fds *descriptorpb.FileDescriptorSet) (*protoregistry.Files, error) {
+	files := make(map[string]*descriptorpb.FileDescriptorProto)
+	for _, fd := range fds.File {
+		if _, ok := files[fd.GetName()]; ok {
+			return nil, errors.New("file appears multiple times: %q", fd.GetName())
+		}
+		files[fd.GetName()] = fd
+	}
+	r := &protoregistry.Files{}
+	for _, fd := range files {
+		if err := o.addFileDeps(r, fd, files); err != nil {
+			return nil, err
+		}
+	}
+	return r, nil
+}
+func (o FileOptions) addFileDeps(r *protoregistry.Files, fd *descriptorpb.FileDescriptorProto, files map[string]*descriptorpb.FileDescriptorProto) error {
+	// Set the entry to nil while descending into a file's dependencies to detect cycles.
+	files[fd.GetName()] = nil
+	for _, dep := range fd.Dependency {
+		depfd, ok := files[dep]
+		if depfd == nil {
+			if ok {
+				return errors.New("import cycle in file: %q", dep)
+			}
+			continue
+		}
+		if err := o.addFileDeps(r, depfd, files); err != nil {
+			return err
+		}
+	}
+	// Delete the entry once dependencies are processed.
+	delete(files, fd.GetName())
+	f, err := o.New(fd, r)
+	if err != nil {
+		return err
+	}
+	return r.RegisterFile(f)
+}
diff --git a/vendor/google.golang.org/protobuf/reflect/protodesc/desc_init.go b/vendor/google.golang.org/protobuf/reflect/protodesc/desc_init.go
new file mode 100644
index 000000000..673a230e7
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/reflect/protodesc/desc_init.go
@@ -0,0 +1,248 @@
+// Copyright 2019 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 protodesc
+
+import (
+	"google.golang.org/protobuf/internal/errors"
+	"google.golang.org/protobuf/internal/filedesc"
+	"google.golang.org/protobuf/internal/strs"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protoreflect"
+
+	"google.golang.org/protobuf/types/descriptorpb"
+)
+
+type descsByName map[protoreflect.FullName]protoreflect.Descriptor
+
+func (r descsByName) initEnumDeclarations(eds []*descriptorpb.EnumDescriptorProto, parent protoreflect.Descriptor, sb *strs.Builder) (es []filedesc.Enum, err error) {
+	es = make([]filedesc.Enum, len(eds)) // allocate up-front to ensure stable pointers
+	for i, ed := range eds {
+		e := &es[i]
+		e.L2 = new(filedesc.EnumL2)
+		if e.L0, err = r.makeBase(e, parent, ed.GetName(), i, sb); err != nil {
+			return nil, err
+		}
+		if opts := ed.GetOptions(); opts != nil {
+			opts = proto.Clone(opts).(*descriptorpb.EnumOptions)
+			e.L2.Options = func() protoreflect.ProtoMessage { return opts }
+		}
+		for _, s := range ed.GetReservedName() {
+			e.L2.ReservedNames.List = append(e.L2.ReservedNames.List, protoreflect.Name(s))
+		}
+		for _, rr := range ed.GetReservedRange() {
+			e.L2.ReservedRanges.List = append(e.L2.ReservedRanges.List, [2]protoreflect.EnumNumber{
+				protoreflect.EnumNumber(rr.GetStart()),
+				protoreflect.EnumNumber(rr.GetEnd()),
+			})
+		}
+		if e.L2.Values.List, err = r.initEnumValuesFromDescriptorProto(ed.GetValue(), e, sb); err != nil {
+			return nil, err
+		}
+	}
+	return es, nil
+}
+
+func (r descsByName) initEnumValuesFromDescriptorProto(vds []*descriptorpb.EnumValueDescriptorProto, parent protoreflect.Descriptor, sb *strs.Builder) (vs []filedesc.EnumValue, err error) {
+	vs = make([]filedesc.EnumValue, len(vds)) // allocate up-front to ensure stable pointers
+	for i, vd := range vds {
+		v := &vs[i]
+		if v.L0, err = r.makeBase(v, parent, vd.GetName(), i, sb); err != nil {
+			return nil, err
+		}
+		if opts := vd.GetOptions(); opts != nil {
+			opts = proto.Clone(opts).(*descriptorpb.EnumValueOptions)
+			v.L1.Options = func() protoreflect.ProtoMessage { return opts }
+		}
+		v.L1.Number = protoreflect.EnumNumber(vd.GetNumber())
+	}
+	return vs, nil
+}
+
+func (r descsByName) initMessagesDeclarations(mds []*descriptorpb.DescriptorProto, parent protoreflect.Descriptor, sb *strs.Builder) (ms []filedesc.Message, err error) {
+	ms = make([]filedesc.Message, len(mds)) // allocate up-front to ensure stable pointers
+	for i, md := range mds {
+		m := &ms[i]
+		m.L2 = new(filedesc.MessageL2)
+		if m.L0, err = r.makeBase(m, parent, md.GetName(), i, sb); err != nil {
+			return nil, err
+		}
+		if opts := md.GetOptions(); opts != nil {
+			opts = proto.Clone(opts).(*descriptorpb.MessageOptions)
+			m.L2.Options = func() protoreflect.ProtoMessage { return opts }
+			m.L1.IsMapEntry = opts.GetMapEntry()
+			m.L1.IsMessageSet = opts.GetMessageSetWireFormat()
+		}
+		for _, s := range md.GetReservedName() {
+			m.L2.ReservedNames.List = append(m.L2.ReservedNames.List, protoreflect.Name(s))
+		}
+		for _, rr := range md.GetReservedRange() {
+			m.L2.ReservedRanges.List = append(m.L2.ReservedRanges.List, [2]protoreflect.FieldNumber{
+				protoreflect.FieldNumber(rr.GetStart()),
+				protoreflect.FieldNumber(rr.GetEnd()),
+			})
+		}
+		for _, xr := range md.GetExtensionRange() {
+			m.L2.ExtensionRanges.List = append(m.L2.ExtensionRanges.List, [2]protoreflect.FieldNumber{
+				protoreflect.FieldNumber(xr.GetStart()),
+				protoreflect.FieldNumber(xr.GetEnd()),
+			})
+			var optsFunc func() protoreflect.ProtoMessage
+			if opts := xr.GetOptions(); opts != nil {
+				opts = proto.Clone(opts).(*descriptorpb.ExtensionRangeOptions)
+				optsFunc = func() protoreflect.ProtoMessage { return opts }
+			}
+			m.L2.ExtensionRangeOptions = append(m.L2.ExtensionRangeOptions, optsFunc)
+		}
+		if m.L2.Fields.List, err = r.initFieldsFromDescriptorProto(md.GetField(), m, sb); err != nil {
+			return nil, err
+		}
+		if m.L2.Oneofs.List, err = r.initOneofsFromDescriptorProto(md.GetOneofDecl(), m, sb); err != nil {
+			return nil, err
+		}
+		if m.L1.Enums.List, err = r.initEnumDeclarations(md.GetEnumType(), m, sb); err != nil {
+			return nil, err
+		}
+		if m.L1.Messages.List, err = r.initMessagesDeclarations(md.GetNestedType(), m, sb); err != nil {
+			return nil, err
+		}
+		if m.L1.Extensions.List, err = r.initExtensionDeclarations(md.GetExtension(), m, sb); err != nil {
+			return nil, err
+		}
+	}
+	return ms, nil
+}
+
+func (r descsByName) initFieldsFromDescriptorProto(fds []*descriptorpb.FieldDescriptorProto, parent protoreflect.Descriptor, sb *strs.Builder) (fs []filedesc.Field, err error) {
+	fs = make([]filedesc.Field, len(fds)) // allocate up-front to ensure stable pointers
+	for i, fd := range fds {
+		f := &fs[i]
+		if f.L0, err = r.makeBase(f, parent, fd.GetName(), i, sb); err != nil {
+			return nil, err
+		}
+		f.L1.IsProto3Optional = fd.GetProto3Optional()
+		if opts := fd.GetOptions(); opts != nil {
+			opts = proto.Clone(opts).(*descriptorpb.FieldOptions)
+			f.L1.Options = func() protoreflect.ProtoMessage { return opts }
+			f.L1.IsWeak = opts.GetWeak()
+			f.L1.HasPacked = opts.Packed != nil
+			f.L1.IsPacked = opts.GetPacked()
+		}
+		f.L1.Number = protoreflect.FieldNumber(fd.GetNumber())
+		f.L1.Cardinality = protoreflect.Cardinality(fd.GetLabel())
+		if fd.Type != nil {
+			f.L1.Kind = protoreflect.Kind(fd.GetType())
+		}
+		if fd.JsonName != nil {
+			f.L1.JSONName.Init(fd.GetJsonName())
+		}
+	}
+	return fs, nil
+}
+
+func (r descsByName) initOneofsFromDescriptorProto(ods []*descriptorpb.OneofDescriptorProto, parent protoreflect.Descriptor, sb *strs.Builder) (os []filedesc.Oneof, err error) {
+	os = make([]filedesc.Oneof, len(ods)) // allocate up-front to ensure stable pointers
+	for i, od := range ods {
+		o := &os[i]
+		if o.L0, err = r.makeBase(o, parent, od.GetName(), i, sb); err != nil {
+			return nil, err
+		}
+		if opts := od.GetOptions(); opts != nil {
+			opts = proto.Clone(opts).(*descriptorpb.OneofOptions)
+			o.L1.Options = func() protoreflect.ProtoMessage { return opts }
+		}
+	}
+	return os, nil
+}
+
+func (r descsByName) initExtensionDeclarations(xds []*descriptorpb.FieldDescriptorProto, parent protoreflect.Descriptor, sb *strs.Builder) (xs []filedesc.Extension, err error) {
+	xs = make([]filedesc.Extension, len(xds)) // allocate up-front to ensure stable pointers
+	for i, xd := range xds {
+		x := &xs[i]
+		x.L2 = new(filedesc.ExtensionL2)
+		if x.L0, err = r.makeBase(x, parent, xd.GetName(), i, sb); err != nil {
+			return nil, err
+		}
+		if opts := xd.GetOptions(); opts != nil {
+			opts = proto.Clone(opts).(*descriptorpb.FieldOptions)
+			x.L2.Options = func() protoreflect.ProtoMessage { return opts }
+			x.L2.IsPacked = opts.GetPacked()
+		}
+		x.L1.Number = protoreflect.FieldNumber(xd.GetNumber())
+		x.L1.Cardinality = protoreflect.Cardinality(xd.GetLabel())
+		if xd.Type != nil {
+			x.L1.Kind = protoreflect.Kind(xd.GetType())
+		}
+		if xd.JsonName != nil {
+			x.L2.JSONName.Init(xd.GetJsonName())
+		}
+	}
+	return xs, nil
+}
+
+func (r descsByName) initServiceDeclarations(sds []*descriptorpb.ServiceDescriptorProto, parent protoreflect.Descriptor, sb *strs.Builder) (ss []filedesc.Service, err error) {
+	ss = make([]filedesc.Service, len(sds)) // allocate up-front to ensure stable pointers
+	for i, sd := range sds {
+		s := &ss[i]
+		s.L2 = new(filedesc.ServiceL2)
+		if s.L0, err = r.makeBase(s, parent, sd.GetName(), i, sb); err != nil {
+			return nil, err
+		}
+		if opts := sd.GetOptions(); opts != nil {
+			opts = proto.Clone(opts).(*descriptorpb.ServiceOptions)
+			s.L2.Options = func() protoreflect.ProtoMessage { return opts }
+		}
+		if s.L2.Methods.List, err = r.initMethodsFromDescriptorProto(sd.GetMethod(), s, sb); err != nil {
+			return nil, err
+		}
+	}
+	return ss, nil
+}
+
+func (r descsByName) initMethodsFromDescriptorProto(mds []*descriptorpb.MethodDescriptorProto, parent protoreflect.Descriptor, sb *strs.Builder) (ms []filedesc.Method, err error) {
+	ms = make([]filedesc.Method, len(mds)) // allocate up-front to ensure stable pointers
+	for i, md := range mds {
+		m := &ms[i]
+		if m.L0, err = r.makeBase(m, parent, md.GetName(), i, sb); err != nil {
+			return nil, err
+		}
+		if opts := md.GetOptions(); opts != nil {
+			opts = proto.Clone(opts).(*descriptorpb.MethodOptions)
+			m.L1.Options = func() protoreflect.ProtoMessage { return opts }
+		}
+		m.L1.IsStreamingClient = md.GetClientStreaming()
+		m.L1.IsStreamingServer = md.GetServerStreaming()
+	}
+	return ms, nil
+}
+
+func (r descsByName) makeBase(child, parent protoreflect.Descriptor, name string, idx int, sb *strs.Builder) (filedesc.BaseL0, error) {
+	if !protoreflect.Name(name).IsValid() {
+		return filedesc.BaseL0{}, errors.New("descriptor %q has an invalid nested name: %q", parent.FullName(), name)
+	}
+
+	// Derive the full name of the child.
+	// Note that enum values are a sibling to the enum parent in the namespace.
+	var fullName protoreflect.FullName
+	if _, ok := parent.(protoreflect.EnumDescriptor); ok {
+		fullName = sb.AppendFullName(parent.FullName().Parent(), protoreflect.Name(name))
+	} else {
+		fullName = sb.AppendFullName(parent.FullName(), protoreflect.Name(name))
+	}
+	if _, ok := r[fullName]; ok {
+		return filedesc.BaseL0{}, errors.New("descriptor %q already declared", fullName)
+	}
+	r[fullName] = child
+
+	// TODO: Verify that the full name does not already exist in the resolver?
+	// This is not as critical since most usages of NewFile will register
+	// the created file back into the registry, which will perform this check.
+
+	return filedesc.BaseL0{
+		FullName:   fullName,
+		ParentFile: parent.ParentFile().(*filedesc.File),
+		Parent:     parent,
+		Index:      idx,
+	}, nil
+}
diff --git a/vendor/google.golang.org/protobuf/reflect/protodesc/desc_resolve.go b/vendor/google.golang.org/protobuf/reflect/protodesc/desc_resolve.go
new file mode 100644
index 000000000..cebb36cda
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/reflect/protodesc/desc_resolve.go
@@ -0,0 +1,286 @@
+// Copyright 2019 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 protodesc
+
+import (
+	"google.golang.org/protobuf/internal/encoding/defval"
+	"google.golang.org/protobuf/internal/errors"
+	"google.golang.org/protobuf/internal/filedesc"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/reflect/protoregistry"
+
+	"google.golang.org/protobuf/types/descriptorpb"
+)
+
+// resolver is a wrapper around a local registry of declarations within the file
+// and the remote resolver. The remote resolver is restricted to only return
+// descriptors that have been imported.
+type resolver struct {
+	local   descsByName
+	remote  Resolver
+	imports importSet
+
+	allowUnresolvable bool
+}
+
+func (r *resolver) resolveMessageDependencies(ms []filedesc.Message, mds []*descriptorpb.DescriptorProto) (err error) {
+	for i, md := range mds {
+		m := &ms[i]
+		for j, fd := range md.GetField() {
+			f := &m.L2.Fields.List[j]
+			if f.L1.Cardinality == protoreflect.Required {
+				m.L2.RequiredNumbers.List = append(m.L2.RequiredNumbers.List, f.L1.Number)
+			}
+			if fd.OneofIndex != nil {
+				k := int(fd.GetOneofIndex())
+				if !(0 <= k && k < len(md.GetOneofDecl())) {
+					return errors.New("message field %q has an invalid oneof index: %d", f.FullName(), k)
+				}
+				o := &m.L2.Oneofs.List[k]
+				f.L1.ContainingOneof = o
+				o.L1.Fields.List = append(o.L1.Fields.List, f)
+			}
+
+			if f.L1.Kind, f.L1.Enum, f.L1.Message, err = r.findTarget(f.Kind(), f.Parent().FullName(), partialName(fd.GetTypeName()), f.IsWeak()); err != nil {
+				return errors.New("message field %q cannot resolve type: %v", f.FullName(), err)
+			}
+			if fd.DefaultValue != nil {
+				v, ev, err := unmarshalDefault(fd.GetDefaultValue(), f, r.allowUnresolvable)
+				if err != nil {
+					return errors.New("message field %q has invalid default: %v", f.FullName(), err)
+				}
+				f.L1.Default = filedesc.DefaultValue(v, ev)
+			}
+		}
+
+		if err := r.resolveMessageDependencies(m.L1.Messages.List, md.GetNestedType()); err != nil {
+			return err
+		}
+		if err := r.resolveExtensionDependencies(m.L1.Extensions.List, md.GetExtension()); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (r *resolver) resolveExtensionDependencies(xs []filedesc.Extension, xds []*descriptorpb.FieldDescriptorProto) (err error) {
+	for i, xd := range xds {
+		x := &xs[i]
+		if x.L1.Extendee, err = r.findMessageDescriptor(x.Parent().FullName(), partialName(xd.GetExtendee()), false); err != nil {
+			return errors.New("extension field %q cannot resolve extendee: %v", x.FullName(), err)
+		}
+		if x.L1.Kind, x.L2.Enum, x.L2.Message, err = r.findTarget(x.Kind(), x.Parent().FullName(), partialName(xd.GetTypeName()), false); err != nil {
+			return errors.New("extension field %q cannot resolve type: %v", x.FullName(), err)
+		}
+		if xd.DefaultValue != nil {
+			v, ev, err := unmarshalDefault(xd.GetDefaultValue(), x, r.allowUnresolvable)
+			if err != nil {
+				return errors.New("extension field %q has invalid default: %v", x.FullName(), err)
+			}
+			x.L2.Default = filedesc.DefaultValue(v, ev)
+		}
+	}
+	return nil
+}
+
+func (r *resolver) resolveServiceDependencies(ss []filedesc.Service, sds []*descriptorpb.ServiceDescriptorProto) (err error) {
+	for i, sd := range sds {
+		s := &ss[i]
+		for j, md := range sd.GetMethod() {
+			m := &s.L2.Methods.List[j]
+			m.L1.Input, err = r.findMessageDescriptor(m.Parent().FullName(), partialName(md.GetInputType()), false)
+			if err != nil {
+				return errors.New("service method %q cannot resolve input: %v", m.FullName(), err)
+			}
+			m.L1.Output, err = r.findMessageDescriptor(s.FullName(), partialName(md.GetOutputType()), false)
+			if err != nil {
+				return errors.New("service method %q cannot resolve output: %v", m.FullName(), err)
+			}
+		}
+	}
+	return nil
+}
+
+// findTarget finds an enum or message descriptor if k is an enum, message,
+// group, or unknown. If unknown, and the name could be resolved, the kind
+// returned kind is set based on the type of the resolved descriptor.
+func (r *resolver) findTarget(k protoreflect.Kind, scope protoreflect.FullName, ref partialName, isWeak bool) (protoreflect.Kind, protoreflect.EnumDescriptor, protoreflect.MessageDescriptor, error) {
+	switch k {
+	case protoreflect.EnumKind:
+		ed, err := r.findEnumDescriptor(scope, ref, isWeak)
+		if err != nil {
+			return 0, nil, nil, err
+		}
+		return k, ed, nil, nil
+	case protoreflect.MessageKind, protoreflect.GroupKind:
+		md, err := r.findMessageDescriptor(scope, ref, isWeak)
+		if err != nil {
+			return 0, nil, nil, err
+		}
+		return k, nil, md, nil
+	case 0:
+		// Handle unspecified kinds (possible with parsers that operate
+		// on a per-file basis without knowledge of dependencies).
+		d, err := r.findDescriptor(scope, ref)
+		if err == protoregistry.NotFound && (r.allowUnresolvable || isWeak) {
+			return k, filedesc.PlaceholderEnum(ref.FullName()), filedesc.PlaceholderMessage(ref.FullName()), nil
+		} else if err == protoregistry.NotFound {
+			return 0, nil, nil, errors.New("%q not found", ref.FullName())
+		} else if err != nil {
+			return 0, nil, nil, err
+		}
+		switch d := d.(type) {
+		case protoreflect.EnumDescriptor:
+			return protoreflect.EnumKind, d, nil, nil
+		case protoreflect.MessageDescriptor:
+			return protoreflect.MessageKind, nil, d, nil
+		default:
+			return 0, nil, nil, errors.New("unknown kind")
+		}
+	default:
+		if ref != "" {
+			return 0, nil, nil, errors.New("target name cannot be specified for %v", k)
+		}
+		if !k.IsValid() {
+			return 0, nil, nil, errors.New("invalid kind: %d", k)
+		}
+		return k, nil, nil, nil
+	}
+}
+
+// findDescriptor finds the descriptor by name,
+// which may be a relative name within some scope.
+//
+// Suppose the scope was "fizz.buzz" and the reference was "Foo.Bar",
+// then the following full names are searched:
+//	* fizz.buzz.Foo.Bar
+//	* fizz.Foo.Bar
+//	* Foo.Bar
+func (r *resolver) findDescriptor(scope protoreflect.FullName, ref partialName) (protoreflect.Descriptor, error) {
+	if !ref.IsValid() {
+		return nil, errors.New("invalid name reference: %q", ref)
+	}
+	if ref.IsFull() {
+		scope, ref = "", ref[1:]
+	}
+	var foundButNotImported protoreflect.Descriptor
+	for {
+		// Derive the full name to search.
+		s := protoreflect.FullName(ref)
+		if scope != "" {
+			s = scope + "." + s
+		}
+
+		// Check the current file for the descriptor.
+		if d, ok := r.local[s]; ok {
+			return d, nil
+		}
+
+		// Check the remote registry for the descriptor.
+		d, err := r.remote.FindDescriptorByName(s)
+		if err == nil {
+			// Only allow descriptors covered by one of the imports.
+			if r.imports[d.ParentFile().Path()] {
+				return d, nil
+			}
+			foundButNotImported = d
+		} else if err != protoregistry.NotFound {
+			return nil, errors.Wrap(err, "%q", s)
+		}
+
+		// Continue on at a higher level of scoping.
+		if scope == "" {
+			if d := foundButNotImported; d != nil {
+				return nil, errors.New("resolved %q, but %q is not imported", d.FullName(), d.ParentFile().Path())
+			}
+			return nil, protoregistry.NotFound
+		}
+		scope = scope.Parent()
+	}
+}
+
+func (r *resolver) findEnumDescriptor(scope protoreflect.FullName, ref partialName, isWeak bool) (protoreflect.EnumDescriptor, error) {
+	d, err := r.findDescriptor(scope, ref)
+	if err == protoregistry.NotFound && (r.allowUnresolvable || isWeak) {
+		return filedesc.PlaceholderEnum(ref.FullName()), nil
+	} else if err == protoregistry.NotFound {
+		return nil, errors.New("%q not found", ref.FullName())
+	} else if err != nil {
+		return nil, err
+	}
+	ed, ok := d.(protoreflect.EnumDescriptor)
+	if !ok {
+		return nil, errors.New("resolved %q, but it is not an enum", d.FullName())
+	}
+	return ed, nil
+}
+
+func (r *resolver) findMessageDescriptor(scope protoreflect.FullName, ref partialName, isWeak bool) (protoreflect.MessageDescriptor, error) {
+	d, err := r.findDescriptor(scope, ref)
+	if err == protoregistry.NotFound && (r.allowUnresolvable || isWeak) {
+		return filedesc.PlaceholderMessage(ref.FullName()), nil
+	} else if err == protoregistry.NotFound {
+		return nil, errors.New("%q not found", ref.FullName())
+	} else if err != nil {
+		return nil, err
+	}
+	md, ok := d.(protoreflect.MessageDescriptor)
+	if !ok {
+		return nil, errors.New("resolved %q, but it is not an message", d.FullName())
+	}
+	return md, nil
+}
+
+// partialName is the partial name. A leading dot means that the name is full,
+// otherwise the name is relative to some current scope.
+// See google.protobuf.FieldDescriptorProto.type_name.
+type partialName string
+
+func (s partialName) IsFull() bool {
+	return len(s) > 0 && s[0] == '.'
+}
+
+func (s partialName) IsValid() bool {
+	if s.IsFull() {
+		return protoreflect.FullName(s[1:]).IsValid()
+	}
+	return protoreflect.FullName(s).IsValid()
+}
+
+const unknownPrefix = "*."
+
+// FullName converts the partial name to a full name on a best-effort basis.
+// If relative, it creates an invalid full name, using a "*." prefix
+// to indicate that the start of the full name is unknown.
+func (s partialName) FullName() protoreflect.FullName {
+	if s.IsFull() {
+		return protoreflect.FullName(s[1:])
+	}
+	return protoreflect.FullName(unknownPrefix + s)
+}
+
+func unmarshalDefault(s string, fd protoreflect.FieldDescriptor, allowUnresolvable bool) (protoreflect.Value, protoreflect.EnumValueDescriptor, error) {
+	var evs protoreflect.EnumValueDescriptors
+	if fd.Enum() != nil {
+		evs = fd.Enum().Values()
+	}
+	v, ev, err := defval.Unmarshal(s, fd.Kind(), evs, defval.Descriptor)
+	if err != nil && allowUnresolvable && evs != nil && protoreflect.Name(s).IsValid() {
+		v = protoreflect.ValueOfEnum(0)
+		if evs.Len() > 0 {
+			v = protoreflect.ValueOfEnum(evs.Get(0).Number())
+		}
+		ev = filedesc.PlaceholderEnumValue(fd.Enum().FullName().Parent().Append(protoreflect.Name(s)))
+	} else if err != nil {
+		return v, ev, err
+	}
+	if fd.Syntax() == protoreflect.Proto3 {
+		return v, ev, errors.New("cannot be specified under proto3 semantics")
+	}
+	if fd.Kind() == protoreflect.MessageKind || fd.Kind() == protoreflect.GroupKind || fd.Cardinality() == protoreflect.Repeated {
+		return v, ev, errors.New("cannot be specified on composite types")
+	}
+	return v, ev, nil
+}
diff --git a/vendor/google.golang.org/protobuf/reflect/protodesc/desc_validate.go b/vendor/google.golang.org/protobuf/reflect/protodesc/desc_validate.go
new file mode 100644
index 000000000..cf9641ab9
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/reflect/protodesc/desc_validate.go
@@ -0,0 +1,370 @@
+// Copyright 2019 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 protodesc
+
+import (
+	"strings"
+	"unicode"
+
+	"google.golang.org/protobuf/encoding/protowire"
+	"google.golang.org/protobuf/internal/errors"
+	"google.golang.org/protobuf/internal/filedesc"
+	"google.golang.org/protobuf/internal/flags"
+	"google.golang.org/protobuf/internal/strs"
+	"google.golang.org/protobuf/reflect/protoreflect"
+
+	"google.golang.org/protobuf/types/descriptorpb"
+)
+
+func validateEnumDeclarations(es []filedesc.Enum, eds []*descriptorpb.EnumDescriptorProto) error {
+	for i, ed := range eds {
+		e := &es[i]
+		if err := e.L2.ReservedNames.CheckValid(); err != nil {
+			return errors.New("enum %q reserved names has %v", e.FullName(), err)
+		}
+		if err := e.L2.ReservedRanges.CheckValid(); err != nil {
+			return errors.New("enum %q reserved ranges has %v", e.FullName(), err)
+		}
+		if len(ed.GetValue()) == 0 {
+			return errors.New("enum %q must contain at least one value declaration", e.FullName())
+		}
+		allowAlias := ed.GetOptions().GetAllowAlias()
+		foundAlias := false
+		for i := 0; i < e.Values().Len(); i++ {
+			v1 := e.Values().Get(i)
+			if v2 := e.Values().ByNumber(v1.Number()); v1 != v2 {
+				foundAlias = true
+				if !allowAlias {
+					return errors.New("enum %q has conflicting non-aliased values on number %d: %q with %q", e.FullName(), v1.Number(), v1.Name(), v2.Name())
+				}
+			}
+		}
+		if allowAlias && !foundAlias {
+			return errors.New("enum %q allows aliases, but none were found", e.FullName())
+		}
+		if e.Syntax() == protoreflect.Proto3 {
+			if v := e.Values().Get(0); v.Number() != 0 {
+				return errors.New("enum %q using proto3 semantics must have zero number for the first value", v.FullName())
+			}
+			// Verify that value names in proto3 do not conflict if the
+			// case-insensitive prefix is removed.
+			// See protoc v3.8.0: src/google/protobuf/descriptor.cc:4991-5055
+			names := map[string]protoreflect.EnumValueDescriptor{}
+			prefix := strings.Replace(strings.ToLower(string(e.Name())), "_", "", -1)
+			for i := 0; i < e.Values().Len(); i++ {
+				v1 := e.Values().Get(i)
+				s := strs.EnumValueName(strs.TrimEnumPrefix(string(v1.Name()), prefix))
+				if v2, ok := names[s]; ok && v1.Number() != v2.Number() {
+					return errors.New("enum %q using proto3 semantics has conflict: %q with %q", e.FullName(), v1.Name(), v2.Name())
+				}
+				names[s] = v1
+			}
+		}
+
+		for j, vd := range ed.GetValue() {
+			v := &e.L2.Values.List[j]
+			if vd.Number == nil {
+				return errors.New("enum value %q must have a specified number", v.FullName())
+			}
+			if e.L2.ReservedNames.Has(v.Name()) {
+				return errors.New("enum value %q must not use reserved name", v.FullName())
+			}
+			if e.L2.ReservedRanges.Has(v.Number()) {
+				return errors.New("enum value %q must not use reserved number %d", v.FullName(), v.Number())
+			}
+		}
+	}
+	return nil
+}
+
+func validateMessageDeclarations(ms []filedesc.Message, mds []*descriptorpb.DescriptorProto) error {
+	for i, md := range mds {
+		m := &ms[i]
+
+		// Handle the message descriptor itself.
+		isMessageSet := md.GetOptions().GetMessageSetWireFormat()
+		if err := m.L2.ReservedNames.CheckValid(); err != nil {
+			return errors.New("message %q reserved names has %v", m.FullName(), err)
+		}
+		if err := m.L2.ReservedRanges.CheckValid(isMessageSet); err != nil {
+			return errors.New("message %q reserved ranges has %v", m.FullName(), err)
+		}
+		if err := m.L2.ExtensionRanges.CheckValid(isMessageSet); err != nil {
+			return errors.New("message %q extension ranges has %v", m.FullName(), err)
+		}
+		if err := (*filedesc.FieldRanges).CheckOverlap(&m.L2.ReservedRanges, &m.L2.ExtensionRanges); err != nil {
+			return errors.New("message %q reserved and extension ranges has %v", m.FullName(), err)
+		}
+		for i := 0; i < m.Fields().Len(); i++ {
+			f1 := m.Fields().Get(i)
+			if f2 := m.Fields().ByNumber(f1.Number()); f1 != f2 {
+				return errors.New("message %q has conflicting fields: %q with %q", m.FullName(), f1.Name(), f2.Name())
+			}
+		}
+		if isMessageSet && !flags.ProtoLegacy {
+			return errors.New("message %q is a MessageSet, which is a legacy proto1 feature that is no longer supported", m.FullName())
+		}
+		if isMessageSet && (m.Syntax() != protoreflect.Proto2 || m.Fields().Len() > 0 || m.ExtensionRanges().Len() == 0) {
+			return errors.New("message %q is an invalid proto1 MessageSet", m.FullName())
+		}
+		if m.Syntax() == protoreflect.Proto3 {
+			if m.ExtensionRanges().Len() > 0 {
+				return errors.New("message %q using proto3 semantics cannot have extension ranges", m.FullName())
+			}
+			// Verify that field names in proto3 do not conflict if lowercased
+			// with all underscores removed.
+			// See protoc v3.8.0: src/google/protobuf/descriptor.cc:5830-5847
+			names := map[string]protoreflect.FieldDescriptor{}
+			for i := 0; i < m.Fields().Len(); i++ {
+				f1 := m.Fields().Get(i)
+				s := strings.Replace(strings.ToLower(string(f1.Name())), "_", "", -1)
+				if f2, ok := names[s]; ok {
+					return errors.New("message %q using proto3 semantics has conflict: %q with %q", m.FullName(), f1.Name(), f2.Name())
+				}
+				names[s] = f1
+			}
+		}
+
+		for j, fd := range md.GetField() {
+			f := &m.L2.Fields.List[j]
+			if m.L2.ReservedNames.Has(f.Name()) {
+				return errors.New("message field %q must not use reserved name", f.FullName())
+			}
+			if !f.Number().IsValid() {
+				return errors.New("message field %q has an invalid number: %d", f.FullName(), f.Number())
+			}
+			if !f.Cardinality().IsValid() {
+				return errors.New("message field %q has an invalid cardinality: %d", f.FullName(), f.Cardinality())
+			}
+			if m.L2.ReservedRanges.Has(f.Number()) {
+				return errors.New("message field %q must not use reserved number %d", f.FullName(), f.Number())
+			}
+			if m.L2.ExtensionRanges.Has(f.Number()) {
+				return errors.New("message field %q with number %d in extension range", f.FullName(), f.Number())
+			}
+			if fd.Extendee != nil {
+				return errors.New("message field %q may not have extendee: %q", f.FullName(), fd.GetExtendee())
+			}
+			if f.L1.IsProto3Optional {
+				if f.Syntax() != protoreflect.Proto3 {
+					return errors.New("message field %q under proto3 optional semantics must be specified in the proto3 syntax", f.FullName())
+				}
+				if f.Cardinality() != protoreflect.Optional {
+					return errors.New("message field %q under proto3 optional semantics must have optional cardinality", f.FullName())
+				}
+				if f.ContainingOneof() != nil && f.ContainingOneof().Fields().Len() != 1 {
+					return errors.New("message field %q under proto3 optional semantics must be within a single element oneof", f.FullName())
+				}
+			}
+			if f.IsWeak() && !flags.ProtoLegacy {
+				return errors.New("message field %q is a weak field, which is a legacy proto1 feature that is no longer supported", f.FullName())
+			}
+			if f.IsWeak() && (f.Syntax() != protoreflect.Proto2 || !isOptionalMessage(f) || f.ContainingOneof() != nil) {
+				return errors.New("message field %q may only be weak for an optional message", f.FullName())
+			}
+			if f.IsPacked() && !isPackable(f) {
+				return errors.New("message field %q is not packable", f.FullName())
+			}
+			if err := checkValidGroup(f); err != nil {
+				return errors.New("message field %q is an invalid group: %v", f.FullName(), err)
+			}
+			if err := checkValidMap(f); err != nil {
+				return errors.New("message field %q is an invalid map: %v", f.FullName(), err)
+			}
+			if f.Syntax() == protoreflect.Proto3 {
+				if f.Cardinality() == protoreflect.Required {
+					return errors.New("message field %q using proto3 semantics cannot be required", f.FullName())
+				}
+				if f.Enum() != nil && !f.Enum().IsPlaceholder() && f.Enum().Syntax() != protoreflect.Proto3 {
+					return errors.New("message field %q using proto3 semantics may only depend on a proto3 enum", f.FullName())
+				}
+			}
+		}
+		seenSynthetic := false // synthetic oneofs for proto3 optional must come after real oneofs
+		for j := range md.GetOneofDecl() {
+			o := &m.L2.Oneofs.List[j]
+			if o.Fields().Len() == 0 {
+				return errors.New("message oneof %q must contain at least one field declaration", o.FullName())
+			}
+			if n := o.Fields().Len(); n-1 != (o.Fields().Get(n-1).Index() - o.Fields().Get(0).Index()) {
+				return errors.New("message oneof %q must have consecutively declared fields", o.FullName())
+			}
+
+			if o.IsSynthetic() {
+				seenSynthetic = true
+				continue
+			}
+			if !o.IsSynthetic() && seenSynthetic {
+				return errors.New("message oneof %q must be declared before synthetic oneofs", o.FullName())
+			}
+
+			for i := 0; i < o.Fields().Len(); i++ {
+				f := o.Fields().Get(i)
+				if f.Cardinality() != protoreflect.Optional {
+					return errors.New("message field %q belongs in a oneof and must be optional", f.FullName())
+				}
+				if f.IsWeak() {
+					return errors.New("message field %q belongs in a oneof and must not be a weak reference", f.FullName())
+				}
+			}
+		}
+
+		if err := validateEnumDeclarations(m.L1.Enums.List, md.GetEnumType()); err != nil {
+			return err
+		}
+		if err := validateMessageDeclarations(m.L1.Messages.List, md.GetNestedType()); err != nil {
+			return err
+		}
+		if err := validateExtensionDeclarations(m.L1.Extensions.List, md.GetExtension()); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func validateExtensionDeclarations(xs []filedesc.Extension, xds []*descriptorpb.FieldDescriptorProto) error {
+	for i, xd := range xds {
+		x := &xs[i]
+		// NOTE: Avoid using the IsValid method since extensions to MessageSet
+		// may have a field number higher than normal. This check only verifies
+		// that the number is not negative or reserved. We check again later
+		// if we know that the extendee is definitely not a MessageSet.
+		if n := x.Number(); n < 0 || (protowire.FirstReservedNumber <= n && n <= protowire.LastReservedNumber) {
+			return errors.New("extension field %q has an invalid number: %d", x.FullName(), x.Number())
+		}
+		if !x.Cardinality().IsValid() || x.Cardinality() == protoreflect.Required {
+			return errors.New("extension field %q has an invalid cardinality: %d", x.FullName(), x.Cardinality())
+		}
+		if xd.JsonName != nil {
+			if xd.GetJsonName() != strs.JSONCamelCase(string(x.Name())) {
+				return errors.New("extension field %q may not have an explicitly set JSON name: %q", x.FullName(), xd.GetJsonName())
+			}
+		}
+		if xd.OneofIndex != nil {
+			return errors.New("extension field %q may not be part of a oneof", x.FullName())
+		}
+		if md := x.ContainingMessage(); !md.IsPlaceholder() {
+			if !md.ExtensionRanges().Has(x.Number()) {
+				return errors.New("extension field %q extends %q with non-extension field number: %d", x.FullName(), md.FullName(), x.Number())
+			}
+			isMessageSet := md.Options().(*descriptorpb.MessageOptions).GetMessageSetWireFormat()
+			if isMessageSet && !isOptionalMessage(x) {
+				return errors.New("extension field %q extends MessageSet and must be an optional message", x.FullName())
+			}
+			if !isMessageSet && !x.Number().IsValid() {
+				return errors.New("extension field %q has an invalid number: %d", x.FullName(), x.Number())
+			}
+		}
+		if xd.GetOptions().GetWeak() {
+			return errors.New("extension field %q cannot be a weak reference", x.FullName())
+		}
+		if x.IsPacked() && !isPackable(x) {
+			return errors.New("extension field %q is not packable", x.FullName())
+		}
+		if err := checkValidGroup(x); err != nil {
+			return errors.New("extension field %q is an invalid group: %v", x.FullName(), err)
+		}
+		if md := x.Message(); md != nil && md.IsMapEntry() {
+			return errors.New("extension field %q cannot be a map entry", x.FullName())
+		}
+		if x.Syntax() == protoreflect.Proto3 {
+			switch x.ContainingMessage().FullName() {
+			case (*descriptorpb.FileOptions)(nil).ProtoReflect().Descriptor().FullName():
+			case (*descriptorpb.EnumOptions)(nil).ProtoReflect().Descriptor().FullName():
+			case (*descriptorpb.EnumValueOptions)(nil).ProtoReflect().Descriptor().FullName():
+			case (*descriptorpb.MessageOptions)(nil).ProtoReflect().Descriptor().FullName():
+			case (*descriptorpb.FieldOptions)(nil).ProtoReflect().Descriptor().FullName():
+			case (*descriptorpb.OneofOptions)(nil).ProtoReflect().Descriptor().FullName():
+			case (*descriptorpb.ExtensionRangeOptions)(nil).ProtoReflect().Descriptor().FullName():
+			case (*descriptorpb.ServiceOptions)(nil).ProtoReflect().Descriptor().FullName():
+			case (*descriptorpb.MethodOptions)(nil).ProtoReflect().Descriptor().FullName():
+			default:
+				return errors.New("extension field %q cannot be declared in proto3 unless extended descriptor options", x.FullName())
+			}
+		}
+	}
+	return nil
+}
+
+// isOptionalMessage reports whether this is an optional message.
+// If the kind is unknown, it is assumed to be a message.
+func isOptionalMessage(fd protoreflect.FieldDescriptor) bool {
+	return (fd.Kind() == 0 || fd.Kind() == protoreflect.MessageKind) && fd.Cardinality() == protoreflect.Optional
+}
+
+// isPackable checks whether the pack option can be specified.
+func isPackable(fd protoreflect.FieldDescriptor) bool {
+	switch fd.Kind() {
+	case protoreflect.StringKind, protoreflect.BytesKind, protoreflect.MessageKind, protoreflect.GroupKind:
+		return false
+	}
+	return fd.IsList()
+}
+
+// checkValidGroup reports whether fd is a valid group according to the same
+// rules that protoc imposes.
+func checkValidGroup(fd protoreflect.FieldDescriptor) error {
+	md := fd.Message()
+	switch {
+	case fd.Kind() != protoreflect.GroupKind:
+		return nil
+	case fd.Syntax() != protoreflect.Proto2:
+		return errors.New("invalid under proto2 semantics")
+	case md == nil || md.IsPlaceholder():
+		return errors.New("message must be resolvable")
+	case fd.FullName().Parent() != md.FullName().Parent():
+		return errors.New("message and field must be declared in the same scope")
+	case !unicode.IsUpper(rune(md.Name()[0])):
+		return errors.New("message name must start with an uppercase")
+	case fd.Name() != protoreflect.Name(strings.ToLower(string(md.Name()))):
+		return errors.New("field name must be lowercased form of the message name")
+	}
+	return nil
+}
+
+// checkValidMap checks whether the field is a valid map according to the same
+// rules that protoc imposes.
+// See protoc v3.8.0: src/google/protobuf/descriptor.cc:6045-6115
+func checkValidMap(fd protoreflect.FieldDescriptor) error {
+	md := fd.Message()
+	switch {
+	case md == nil || !md.IsMapEntry():
+		return nil
+	case fd.FullName().Parent() != md.FullName().Parent():
+		return errors.New("message and field must be declared in the same scope")
+	case md.Name() != protoreflect.Name(strs.MapEntryName(string(fd.Name()))):
+		return errors.New("incorrect implicit map entry name")
+	case fd.Cardinality() != protoreflect.Repeated:
+		return errors.New("field must be repeated")
+	case md.Fields().Len() != 2:
+		return errors.New("message must have exactly two fields")
+	case md.ExtensionRanges().Len() > 0:
+		return errors.New("message must not have any extension ranges")
+	case md.Enums().Len()+md.Messages().Len()+md.Extensions().Len() > 0:
+		return errors.New("message must not have any nested declarations")
+	}
+	kf := md.Fields().Get(0)
+	vf := md.Fields().Get(1)
+	switch {
+	case kf.Name() != "key" || kf.Number() != 1 || kf.Cardinality() != protoreflect.Optional || kf.ContainingOneof() != nil || kf.HasDefault():
+		return errors.New("invalid key field")
+	case vf.Name() != "value" || vf.Number() != 2 || vf.Cardinality() != protoreflect.Optional || vf.ContainingOneof() != nil || vf.HasDefault():
+		return errors.New("invalid value field")
+	}
+	switch kf.Kind() {
+	case protoreflect.BoolKind: // bool
+	case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind: // int32
+	case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind: // int64
+	case protoreflect.Uint32Kind, protoreflect.Fixed32Kind: // uint32
+	case protoreflect.Uint64Kind, protoreflect.Fixed64Kind: // uint64
+	case protoreflect.StringKind: // string
+	default:
+		return errors.New("invalid key kind: %v", kf.Kind())
+	}
+	if e := vf.Enum(); e != nil && e.Values().Len() > 0 && e.Values().Get(0).Number() != 0 {
+		return errors.New("map enum value must have zero number for the first value")
+	}
+	return nil
+}
diff --git a/vendor/google.golang.org/protobuf/reflect/protodesc/file_test.go b/vendor/google.golang.org/protobuf/reflect/protodesc/file_test.go
new file mode 100644
index 000000000..9b7e8dd4e
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/reflect/protodesc/file_test.go
@@ -0,0 +1,996 @@
+// Copyright 2019 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 protodesc
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"google.golang.org/protobuf/encoding/prototext"
+	"google.golang.org/protobuf/internal/flags"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/reflect/protoregistry"
+
+	"google.golang.org/protobuf/types/descriptorpb"
+)
+
+func mustParseFile(s string) *descriptorpb.FileDescriptorProto {
+	pb := new(descriptorpb.FileDescriptorProto)
+	if err := prototext.Unmarshal([]byte(s), pb); err != nil {
+		panic(err)
+	}
+	return pb
+}
+
+func cloneFile(in *descriptorpb.FileDescriptorProto) *descriptorpb.FileDescriptorProto {
+	return proto.Clone(in).(*descriptorpb.FileDescriptorProto)
+}
+
+var (
+	proto2Enum = mustParseFile(`
+		syntax:    "proto2"
+		name:      "proto2_enum.proto"
+		package:   "test.proto2"
+		enum_type: [{name:"Enum" value:[{name:"ONE" number:1}]}]
+	`)
+	proto3Message = mustParseFile(`
+		syntax:    "proto3"
+		name:      "proto3_message.proto"
+		package:   "test.proto3"
+		message_type: [{
+			name:  "Message"
+			field: [
+				{name:"foo" number:1 label:LABEL_OPTIONAL type:TYPE_STRING},
+				{name:"bar" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}
+			]
+		}]
+	`)
+	extendableMessage = mustParseFile(`
+		syntax:       "proto2"
+		name:         "extendable_message.proto"
+		package:      "test.proto2"
+		message_type: [{name:"Message" extension_range:[{start:1 end:1000}]}]
+	`)
+	importPublicFile1 = mustParseFile(`
+		syntax:            "proto3"
+		name:              "import_public1.proto"
+		dependency:        ["proto2_enum.proto", "proto3_message.proto", "extendable_message.proto"]
+		message_type:      [{name:"Public1"}]
+	`)
+	importPublicFile2 = mustParseFile(`
+		syntax:            "proto3"
+		name:              "import_public2.proto"
+		dependency:        ["import_public1.proto"]
+		public_dependency: [0]
+		message_type:      [{name:"Public2"}]
+	`)
+	importPublicFile3 = mustParseFile(`
+		syntax:            "proto3"
+		name:              "import_public3.proto"
+		dependency:        ["import_public2.proto", "extendable_message.proto"]
+		public_dependency: [0]
+		message_type:      [{name:"Public3"}]
+	`)
+	importPublicFile4 = mustParseFile(`
+		syntax:            "proto3"
+		name:              "import_public4.proto"
+		dependency:        ["import_public2.proto", "import_public3.proto", "proto2_enum.proto"]
+		public_dependency: [0, 1]
+		message_type:      [{name:"Public4"}]
+	`)
+)
+
+func TestNewFile(t *testing.T) {
+	tests := []struct {
+		label    string
+		inDeps   []*descriptorpb.FileDescriptorProto
+		inDesc   *descriptorpb.FileDescriptorProto
+		inOpts   FileOptions
+		wantDesc *descriptorpb.FileDescriptorProto
+		wantErr  string
+	}{{
+		label:   "empty path",
+		inDesc:  mustParseFile(``),
+		wantErr: `path must be populated`,
+	}, {
+		label:  "empty package and syntax",
+		inDesc: mustParseFile(`name:"weird" package:""`),
+	}, {
+		label:   "invalid syntax",
+		inDesc:  mustParseFile(`name:"weird" syntax:"proto9"`),
+		wantErr: `invalid syntax: "proto9"`,
+	}, {
+		label:   "bad package",
+		inDesc:  mustParseFile(`name:"weird" package:"$"`),
+		wantErr: `invalid package: "$"`,
+	}, {
+		label: "unresolvable import",
+		inDesc: mustParseFile(`
+			name:       "test.proto"
+			package:    ""
+			dependency: "dep.proto"
+		`),
+		wantErr: `could not resolve import "dep.proto": not found`,
+	}, {
+		label: "unresolvable import but allowed",
+		inDesc: mustParseFile(`
+			name:       "test.proto"
+			package:    ""
+			dependency: "dep.proto"
+		`),
+		inOpts: FileOptions{AllowUnresolvable: true},
+	}, {
+		label: "duplicate import",
+		inDesc: mustParseFile(`
+			name:       "test.proto"
+			package:    ""
+			dependency: ["dep.proto", "dep.proto"]
+		`),
+		inOpts:  FileOptions{AllowUnresolvable: true},
+		wantErr: `already imported "dep.proto"`,
+	}, {
+		label: "invalid weak import",
+		inDesc: mustParseFile(`
+			name:            "test.proto"
+			package:         ""
+			dependency:      "dep.proto"
+			weak_dependency: [-23]
+		`),
+		inOpts:  FileOptions{AllowUnresolvable: true},
+		wantErr: `invalid or duplicate weak import index: -23`,
+	}, {
+		label: "normal weak and public import",
+		inDesc: mustParseFile(`
+			name:              "test.proto"
+			package:           ""
+			dependency:        "dep.proto"
+			weak_dependency:   [0]
+			public_dependency: [0]
+		`),
+		inOpts: FileOptions{AllowUnresolvable: true},
+	}, {
+		label: "import public indirect dependency duplicate",
+		inDeps: []*descriptorpb.FileDescriptorProto{
+			mustParseFile(`name:"leaf.proto"`),
+			mustParseFile(`name:"public.proto" dependency:"leaf.proto" public_dependency:0`),
+		},
+		inDesc: mustParseFile(`
+			name: "test.proto"
+			package: ""
+			dependency: ["public.proto", "leaf.proto"]
+		`),
+	}, {
+		label: "import public graph",
+		inDeps: []*descriptorpb.FileDescriptorProto{
+			cloneFile(proto2Enum),
+			cloneFile(proto3Message),
+			cloneFile(extendableMessage),
+			cloneFile(importPublicFile1),
+			cloneFile(importPublicFile2),
+			cloneFile(importPublicFile3),
+			cloneFile(importPublicFile4),
+		},
+		inDesc: mustParseFile(`
+			name:       "test.proto"
+			package:    "test.graph"
+			dependency: ["import_public4.proto"],
+		`),
+		// TODO: Test import public
+	}, {
+		label: "preserve source code locations",
+		inDesc: mustParseFile(`
+			name: "test.proto"
+			package: "fizz.buzz"
+			source_code_info: {location: [{
+				span: [39,0,882,1]
+			}, {
+				path: [12]
+				span: [39,0,18]
+				leading_detached_comments: [" foo\n"," bar\n"]
+			}, {
+				path: [8,9]
+				span: [51,0,28]
+				leading_comments: " Comment\n"
+			}]}
+		`),
+	}, {
+		label: "invalid source code span",
+		inDesc: mustParseFile(`
+			name: "test.proto"
+			package: "fizz.buzz"
+			source_code_info: {location: [{
+				span: [39]
+			}]}
+		`),
+		wantErr: `invalid span: [39]`,
+	}, {
+		label: "resolve relative reference",
+		inDesc: mustParseFile(`
+			name: "test.proto"
+			package: "fizz.buzz"
+			message_type: [{
+				name: "A"
+				field: [{name:"F" number:1 label:LABEL_OPTIONAL type:TYPE_MESSAGE type_name:"B.C"}]
+				nested_type: [{name: "B"}]
+			}, {
+				name: "B"
+				nested_type: [{name: "C"}]
+			}]
+		`),
+		wantDesc: mustParseFile(`
+			name: "test.proto"
+			package: "fizz.buzz"
+			message_type: [{
+				name: "A"
+				field: [{name:"F" number:1 label:LABEL_OPTIONAL type:TYPE_MESSAGE type_name:".fizz.buzz.B.C"}]
+				nested_type: [{name: "B"}]
+			}, {
+				name: "B"
+				nested_type: [{name: "C"}]
+			}]
+		`),
+	}, {
+		label: "resolve the wrong type",
+		inDesc: mustParseFile(`
+			name: "test.proto"
+			package: ""
+			message_type: [{
+				name: "M"
+				field: [{name:"F" number:1 label:LABEL_OPTIONAL type:TYPE_MESSAGE type_name:"E"}]
+				enum_type: [{name: "E" value: [{name:"V0" number:0}, {name:"V1" number:1}]}]
+			}]
+		`),
+		wantErr: `message field "M.F" cannot resolve type: resolved "M.E", but it is not an message`,
+	}, {
+		label: "auto-resolve unknown kind",
+		inDesc: mustParseFile(`
+			name: "test.proto"
+			package: ""
+			message_type: [{
+				name: "M"
+				field: [{name:"F" number:1 label:LABEL_OPTIONAL type_name:"E"}]
+				enum_type: [{name: "E" value: [{name:"V0" number:0}, {name:"V1" number:1}]}]
+			}]
+		`),
+		wantDesc: mustParseFile(`
+			name: "test.proto"
+			package: ""
+			message_type: [{
+				name: "M"
+				field: [{name:"F" number:1 label:LABEL_OPTIONAL type:TYPE_ENUM type_name:".M.E"}]
+				enum_type: [{name: "E" value: [{name:"V0" number:0}, {name:"V1" number:1}]}]
+			}]
+		`),
+	}, {
+		label: "unresolved import",
+		inDesc: mustParseFile(`
+			name: "test.proto"
+			package: "fizz.buzz"
+			dependency: "remote.proto"
+		`),
+		wantErr: `could not resolve import "remote.proto": not found`,
+	}, {
+		label: "unresolved message field",
+		inDesc: mustParseFile(`
+			name: "test.proto"
+			package: "fizz.buzz"
+			message_type: [{
+				name: "M"
+				field: [{name:"F1" number:1 label:LABEL_OPTIONAL type:TYPE_ENUM type_name:"some.other.enum" default_value:"UNKNOWN"}]
+			}]
+		`),
+		wantErr: `message field "fizz.buzz.M.F1" cannot resolve type: "*.some.other.enum" not found`,
+	}, {
+		label: "unresolved default enum value",
+		inDesc: mustParseFile(`
+			name: "test.proto"
+			package: "fizz.buzz"
+			message_type: [{
+				name: "M"
+				field: [{name:"F1" number:1 label:LABEL_OPTIONAL type:TYPE_ENUM type_name:"E" default_value:"UNKNOWN"}]
+				enum_type: [{name:"E" value:[{name:"V0" number:0}]}]
+			}]
+		`),
+		wantErr: `message field "fizz.buzz.M.F1" has invalid default: could not parse value for enum: "UNKNOWN"`,
+	}, {
+		label: "allowed unresolved default enum value",
+		inDesc: mustParseFile(`
+			name: "test.proto"
+			package: "fizz.buzz"
+			message_type: [{
+				name: "M"
+				field: [{name:"F1" number:1 label:LABEL_OPTIONAL type:TYPE_ENUM type_name:".fizz.buzz.M.E" default_value:"UNKNOWN"}]
+				enum_type: [{name:"E" value:[{name:"V0" number:0}]}]
+			}]
+		`),
+		inOpts: FileOptions{AllowUnresolvable: true},
+	}, {
+		label: "unresolved extendee",
+		inDesc: mustParseFile(`
+			name: "test.proto"
+			package: "fizz.buzz"
+			extension: [{name:"X" number:1 label:LABEL_OPTIONAL extendee:"some.extended.message" type:TYPE_MESSAGE type_name:"some.other.message"}]
+		`),
+		wantErr: `extension field "fizz.buzz.X" cannot resolve extendee: "*.some.extended.message" not found`,
+	}, {
+		label: "unresolved method input",
+		inDesc: mustParseFile(`
+			name: "test.proto"
+			package: "fizz.buzz"
+			service: [{
+				name: "S"
+				method: [{name:"M" input_type:"foo.bar.input" output_type:".absolute.foo.bar.output"}]
+			}]
+		`),
+		wantErr: `service method "fizz.buzz.S.M" cannot resolve input: "*.foo.bar.input" not found`,
+	}, {
+		label: "allowed unresolved references",
+		inDesc: mustParseFile(`
+			name: "test.proto"
+			package: "fizz.buzz"
+			dependency: "remote.proto"
+			message_type: [{
+				name: "M"
+				field: [{name:"F1" number:1 label:LABEL_OPTIONAL type_name:"some.other.enum" default_value:"UNKNOWN"}]
+			}]
+			extension: [{name:"X" number:1 label:LABEL_OPTIONAL extendee:"some.extended.message" type:TYPE_MESSAGE type_name:"some.other.message"}]
+			service: [{
+				name: "S"
+				method: [{name:"M" input_type:"foo.bar.input" output_type:".absolute.foo.bar.output"}]
+			}]
+		`),
+		inOpts: FileOptions{AllowUnresolvable: true},
+	}, {
+		label: "resolved but not imported",
+		inDeps: []*descriptorpb.FileDescriptorProto{mustParseFile(`
+			name: "dep.proto"
+			package: "fizz"
+			message_type: [{name:"M" nested_type:[{name:"M"}]}]
+		`)},
+		inDesc: mustParseFile(`
+			name: "test.proto"
+			package: "fizz.buzz"
+			message_type: [{
+				name: "M"
+				field: [{name:"F" number:1 label:LABEL_OPTIONAL type:TYPE_MESSAGE type_name:"M.M"}]
+			}]
+		`),
+		wantErr: `message field "fizz.buzz.M.F" cannot resolve type: resolved "fizz.M.M", but "dep.proto" is not imported`,
+	}, {
+		label: "resolved from remote import",
+		inDeps: []*descriptorpb.FileDescriptorProto{mustParseFile(`
+			name: "dep.proto"
+			package: "fizz"
+			message_type: [{name:"M" nested_type:[{name:"M"}]}]
+		`)},
+		inDesc: mustParseFile(`
+			name: "test.proto"
+			package: "fizz.buzz"
+			dependency: "dep.proto"
+			message_type: [{
+				name: "M"
+				field: [{name:"F" number:1 label:LABEL_OPTIONAL type:TYPE_MESSAGE type_name:"M.M"}]
+			}]
+		`),
+		wantDesc: mustParseFile(`
+			name: "test.proto"
+			package: "fizz.buzz"
+			dependency: "dep.proto"
+			message_type: [{
+				name: "M"
+				field: [{name:"F" number:1 label:LABEL_OPTIONAL type:TYPE_MESSAGE type_name:".fizz.M.M"}]
+			}]
+		`),
+	}, {
+		label: "namespace conflict on enum value",
+		inDesc: mustParseFile(`
+			name:    "test.proto"
+			package: ""
+			enum_type: [{
+				name: "foo"
+				value: [{name:"foo" number:0}]
+			}]
+		`),
+		wantErr: `descriptor "foo" already declared`,
+	}, {
+		label: "no namespace conflict on message field",
+		inDesc: mustParseFile(`
+			name:    "test.proto"
+			package: ""
+			message_type: [{
+				name: "foo"
+				field: [{name:"foo" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}]
+			}]
+		`),
+	}, {
+		label: "invalid name",
+		inDesc: mustParseFile(`
+			name:    "test.proto"
+			package: ""
+			message_type: [{name: "$"}]
+		`),
+		wantErr: `descriptor "" has an invalid nested name: "$"`,
+	}, {
+		label: "invalid empty enum",
+		inDesc: mustParseFile(`
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" enum_type:[{name:"E"}]}]
+		`),
+		wantErr: `enum "M.E" must contain at least one value declaration`,
+	}, {
+		label: "invalid enum value without number",
+		inDesc: mustParseFile(`
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" enum_type:[{name:"E" value:[{name:"one"}]}]}]
+		`),
+		wantErr: `enum value "M.one" must have a specified number`,
+	}, {
+		label: "valid enum",
+		inDesc: mustParseFile(`
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" enum_type:[{name:"E" value:[{name:"one" number:1}]}]}]
+		`),
+	}, {
+		label: "invalid enum reserved names",
+		inDesc: mustParseFile(`
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" enum_type:[{
+				name:          "E"
+				reserved_name: [""]
+				value: [{name:"V" number:0}]
+			}]}]
+		`),
+		// NOTE: In theory this should be an error.
+		// See https://github.com/protocolbuffers/protobuf/issues/6335.
+		/*wantErr: `enum "M.E" reserved names has invalid name: ""`,*/
+	}, {
+		label: "duplicate enum reserved names",
+		inDesc: mustParseFile(`
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" enum_type:[{
+				name:          "E"
+				reserved_name: ["foo", "foo"]
+			}]}]
+		`),
+		wantErr: `enum "M.E" reserved names has duplicate name: "foo"`,
+	}, {
+		label: "valid enum reserved names",
+		inDesc: mustParseFile(`
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" enum_type:[{
+				name:          "E"
+				reserved_name: ["foo", "bar"]
+				value:         [{name:"baz" number:1}]
+			}]}]
+		`),
+	}, {
+		label: "use of enum reserved names",
+		inDesc: mustParseFile(`
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" enum_type:[{
+				name:          "E"
+				reserved_name: ["foo", "bar"]
+				value:         [{name:"foo" number:1}]
+			}]}]
+		`),
+		wantErr: `enum value "M.foo" must not use reserved name`,
+	}, {
+		label: "invalid enum reserved ranges",
+		inDesc: mustParseFile(`
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" enum_type:[{
+				name:           "E"
+				reserved_range: [{start:5 end:4}]
+			}]}]
+		`),
+		wantErr: `enum "M.E" reserved ranges has invalid range: 5 to 4`,
+	}, {
+		label: "overlapping enum reserved ranges",
+		inDesc: mustParseFile(`
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" enum_type:[{
+				name:           "E"
+				reserved_range: [{start:1 end:1000}, {start:10 end:100}]
+			}]}]
+		`),
+		wantErr: `enum "M.E" reserved ranges has overlapping ranges: 1 to 1000 with 10 to 100`,
+	}, {
+		label: "valid enum reserved names",
+		inDesc: mustParseFile(`
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" enum_type:[{
+				name:           "E"
+				reserved_range: [{start:1 end:10}, {start:100 end:1000}]
+				value:          [{name:"baz" number:50}]
+			}]}]
+		`),
+	}, {
+		label: "use of enum reserved range",
+		inDesc: mustParseFile(`
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" enum_type:[{
+				name:           "E"
+				reserved_range: [{start:1 end:10}, {start:100 end:1000}]
+				value:          [{name:"baz" number:500}]
+			}]}]
+		`),
+		wantErr: `enum value "M.baz" must not use reserved number 500`,
+	}, {
+		label: "unused enum alias feature",
+		inDesc: mustParseFile(`
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" enum_type:[{
+				name:    "E"
+				value:   [{name:"baz" number:500}]
+				options: {allow_alias:true}
+			}]}]
+		`),
+		wantErr: `enum "M.E" allows aliases, but none were found`,
+	}, {
+		label: "enum number conflicts",
+		inDesc: mustParseFile(`
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" enum_type:[{
+				name:  "E"
+				value: [{name:"foo" number:0}, {name:"bar" number:1}, {name:"baz" number:1}]
+			}]}]
+		`),
+		wantErr: `enum "M.E" has conflicting non-aliased values on number 1: "baz" with "bar"`,
+	}, {
+		label: "aliased enum numbers",
+		inDesc: mustParseFile(`
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" enum_type:[{
+				name:    "E"
+				value:   [{name:"foo" number:0}, {name:"bar" number:1}, {name:"baz" number:1}]
+				options: {allow_alias:true}
+			}]}]
+		`),
+	}, {
+		label: "invalid proto3 enum",
+		inDesc: mustParseFile(`
+			syntax:  "proto3"
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" enum_type:[{
+				name:  "E"
+				value: [{name:"baz" number:500}]
+			}]}]
+		`),
+		wantErr: `enum "M.baz" using proto3 semantics must have zero number for the first value`,
+	}, {
+		label: "valid proto3 enum",
+		inDesc: mustParseFile(`
+			syntax:  "proto3"
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" enum_type:[{
+				name:  "E"
+				value: [{name:"baz" number:0}]
+			}]}]
+		`),
+	}, {
+		label: "proto3 enum name prefix conflict",
+		inDesc: mustParseFile(`
+			syntax:  "proto3"
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" enum_type:[{
+				name:  "E"
+				value: [{name:"e_Foo" number:0}, {name:"fOo" number:1}]
+			}]}]
+		`),
+		wantErr: `enum "M.E" using proto3 semantics has conflict: "fOo" with "e_Foo"`,
+	}, {
+		label: "proto2 enum has name prefix check",
+		inDesc: mustParseFile(`
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" enum_type:[{
+				name:  "E"
+				value: [{name:"e_Foo" number:0}, {name:"fOo" number:1}]
+			}]}]
+		`),
+	}, {
+		label: "proto3 enum same name prefix with number conflict",
+		inDesc: mustParseFile(`
+			syntax:  "proto3"
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" enum_type:[{
+				name:  "E"
+				value: [{name:"e_Foo" number:0}, {name:"fOo" number:0}]
+			}]}]
+		`),
+		wantErr: `enum "M.E" has conflicting non-aliased values on number 0: "fOo" with "e_Foo"`,
+	}, {
+		label: "proto3 enum same name prefix with alias numbers",
+		inDesc: mustParseFile(`
+			syntax:  "proto3"
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" enum_type:[{
+				name:    "E"
+				value:   [{name:"e_Foo" number:0}, {name:"fOo" number:0}]
+				options: {allow_alias: true}
+			}]}]
+		`),
+	}, {
+		label: "invalid message reserved names",
+		inDesc: mustParseFile(`
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" nested_type:[{
+				name:          "M"
+				reserved_name: ["$"]
+			}]}]
+		`),
+		// NOTE: In theory this should be an error.
+		// See https://github.com/protocolbuffers/protobuf/issues/6335.
+		/*wantErr: `message "M.M" reserved names has invalid name: "$"`,*/
+	}, {
+		label: "valid message reserved names",
+		inDesc: mustParseFile(`
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" nested_type:[{
+				name:          "M"
+				reserved_name: ["foo", "bar"]
+				field:         [{name:"foo" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}]
+			}]}]
+		`),
+		wantErr: `message field "M.M.foo" must not use reserved name`,
+	}, {
+		label: "valid message reserved names",
+		inDesc: mustParseFile(`
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" nested_type:[{
+				name:          "M"
+				reserved_name: ["foo", "bar"]
+				field:         [{name:"baz" number:1 label:LABEL_OPTIONAL type:TYPE_STRING oneof_index:0}]
+				oneof_decl:    [{name:"foo"}] # not affected by reserved_name
+			}]}]
+		`),
+	}, {
+		label: "invalid reserved number",
+		inDesc: mustParseFile(`
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" nested_type:[{
+				name:           "M"
+				reserved_range: [{start:1 end:1}]
+				field:          [{name:"baz" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}]
+			}]}]
+		`),
+		wantErr: `message "M.M" reserved ranges has invalid field number: 0`,
+	}, {
+		label: "invalid reserved ranges",
+		inDesc: mustParseFile(`
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" nested_type:[{
+				name:           "M"
+				reserved_range: [{start:2 end:2}]
+				field:          [{name:"baz" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}]
+			}]}]
+		`),
+		wantErr: `message "M.M" reserved ranges has invalid range: 2 to 1`,
+	}, {
+		label: "overlapping reserved ranges",
+		inDesc: mustParseFile(`
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" nested_type:[{
+				name:           "M"
+				reserved_range: [{start:1 end:10}, {start:2 end:9}]
+				field:          [{name:"baz" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}]
+			}]}]
+		`),
+		wantErr: `message "M.M" reserved ranges has overlapping ranges: 1 to 9 with 2 to 8`,
+	}, {
+		label: "use of reserved message field number",
+		inDesc: mustParseFile(`
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" nested_type:[{
+				name:           "M"
+				reserved_range: [{start:10 end:20}, {start:20 end:30}, {start:30 end:31}]
+				field:          [{name:"baz" number:30 label:LABEL_OPTIONAL type:TYPE_STRING}]
+			}]}]
+		`),
+		wantErr: `message field "M.M.baz" must not use reserved number 30`,
+	}, {
+		label: "invalid extension ranges",
+		inDesc: mustParseFile(`
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" nested_type:[{
+				name:            "M"
+				extension_range: [{start:-500 end:2}]
+				field:           [{name:"baz" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}]
+			}]}]
+		`),
+		wantErr: `message "M.M" extension ranges has invalid field number: -500`,
+	}, {
+		label: "overlapping reserved and extension ranges",
+		inDesc: mustParseFile(`
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" nested_type:[{
+				name:            "M"
+				reserved_range:  [{start:15 end:20}, {start:1 end:3}, {start:7 end:10}]
+				extension_range: [{start:8 end:9}, {start:3 end:5}]
+			}]}]
+		`),
+		wantErr: `message "M.M" reserved and extension ranges has overlapping ranges: 7 to 9 with 8`,
+	}, {
+		label: "message field conflicting number",
+		inDesc: mustParseFile(`
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" nested_type:[{
+				name:            "M"
+				field: [
+					{name:"one" number:1 label:LABEL_OPTIONAL type:TYPE_STRING},
+					{name:"One" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}
+				]
+			}]}]
+		`),
+		wantErr: `message "M.M" has conflicting fields: "One" with "one"`,
+	}, {
+		label: "invalid MessageSet",
+		inDesc: mustParseFile(`
+			syntax:  "proto3"
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" nested_type:[{
+				name:    "M"
+				options: {message_set_wire_format:true}
+			}]}]
+		`),
+		wantErr: func() string {
+			if flags.ProtoLegacy {
+				return `message "M.M" is an invalid proto1 MessageSet`
+			} else {
+				return `message "M.M" is a MessageSet, which is a legacy proto1 feature that is no longer supported`
+			}
+		}(),
+	}, {
+		label: "valid MessageSet",
+		inDesc: mustParseFile(`
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" nested_type:[{
+				name:            "M"
+				extension_range: [{start:1 end:100000}]
+				options:         {message_set_wire_format:true}
+			}]}]
+		`),
+		wantErr: func() string {
+			if flags.ProtoLegacy {
+				return ""
+			} else {
+				return `message "M.M" is a MessageSet, which is a legacy proto1 feature that is no longer supported`
+			}
+		}(),
+	}, {
+		label: "invalid extension ranges in proto3",
+		inDesc: mustParseFile(`
+			syntax:  "proto3"
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" nested_type:[{
+				name:            "M"
+				extension_range: [{start:1 end:100000}]
+			}]}]
+		`),
+		wantErr: `message "M.M" using proto3 semantics cannot have extension ranges`,
+	}, {
+		label: "proto3 message fields conflict",
+		inDesc: mustParseFile(`
+			syntax:  "proto3"
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" nested_type:[{
+				name: "M"
+				field: [
+					{name:"_b_a_z_" number:1 label:LABEL_OPTIONAL type:TYPE_STRING},
+					{name:"baz" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}
+				]
+			}]}]
+		`),
+		wantErr: `message "M.M" using proto3 semantics has conflict: "baz" with "_b_a_z_"`,
+	}, {
+		label: "proto3 message fields",
+		inDesc: mustParseFile(`
+			syntax:  "proto3"
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" nested_type:[{
+				name:       "M"
+				field:      [{name:"_b_a_z_" number:1 label:LABEL_OPTIONAL type:TYPE_STRING oneof_index:0}]
+				oneof_decl: [{name:"baz"}] # proto3 name conflict logic does not include oneof
+			}]}]
+		`),
+	}, {
+		label: "proto2 message fields with no conflict",
+		inDesc: mustParseFile(`
+			name:    "test.proto"
+			package: ""
+			message_type: [{name:"M" nested_type:[{
+				name: "M"
+				field: [
+					{name:"_b_a_z_" number:1 label:LABEL_OPTIONAL type:TYPE_STRING},
+					{name:"baz" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}
+				]
+			}]}]
+		`),
+	}, {
+		label: "proto3 message with unresolved enum",
+		inDesc: mustParseFile(`
+			name:    "test.proto"
+			package: ""
+			syntax:  "proto3"
+			message_type: [{
+				name: "M"
+				field: [
+					{name:"enum" number:1 label:LABEL_OPTIONAL type:TYPE_ENUM type_name:".fizz.buzz.Enum"}
+				]
+			}]
+		`),
+		inOpts: FileOptions{AllowUnresolvable: true},
+		// TODO: Test field and oneof handling in validateMessageDeclarations
+		// TODO: Test unmarshalDefault
+		// TODO: Test validateExtensionDeclarations
+		// TODO: Test checkValidGroup
+		// TODO: Test checkValidMap
+	}, {
+		label: "empty service",
+		inDesc: mustParseFile(`
+			name:    "test.proto"
+			package: ""
+			service: [{name:"service"}]
+		`),
+	}, {
+		label: "service with method with unresolved",
+		inDesc: mustParseFile(`
+			name:    "test.proto"
+			package: ""
+			service: [{
+				name: "service"
+				method: [{
+					name:"method"
+					input_type:"foo"
+					output_type:".foo.bar.baz"
+				}]
+			}]
+		`),
+		inOpts: FileOptions{AllowUnresolvable: true},
+	}, {
+		label: "service with wrong reference type",
+		inDeps: []*descriptorpb.FileDescriptorProto{
+			cloneFile(proto3Message),
+			cloneFile(proto2Enum),
+		},
+		inDesc: mustParseFile(`
+			name:    "test.proto"
+			package: ""
+			dependency: ["proto2_enum.proto", "proto3_message.proto"]
+			service: [{
+				name: "service"
+				method: [{
+					name:        "method"
+					input_type:  ".test.proto2.Enum",
+					output_type: ".test.proto3.Message"
+				}]
+			}]
+		`),
+		wantErr: `service method "service.method" cannot resolve input: resolved "test.proto2.Enum", but it is not an message`,
+	}}
+
+	for _, tt := range tests {
+		t.Run(tt.label, func(t *testing.T) {
+			r := new(protoregistry.Files)
+			for i, dep := range tt.inDeps {
+				f, err := tt.inOpts.New(dep, r)
+				if err != nil {
+					t.Fatalf("dependency %d: unexpected NewFile() error: %v", i, err)
+				}
+				if err := r.RegisterFile(f); err != nil {
+					t.Fatalf("dependency %d: unexpected Register() error: %v", i, err)
+				}
+			}
+			var gotDesc *descriptorpb.FileDescriptorProto
+			if tt.wantErr == "" && tt.wantDesc == nil {
+				tt.wantDesc = cloneFile(tt.inDesc)
+			}
+			gotFile, err := tt.inOpts.New(tt.inDesc, r)
+			if gotFile != nil {
+				gotDesc = ToFileDescriptorProto(gotFile)
+			}
+			if !proto.Equal(gotDesc, tt.wantDesc) {
+				t.Errorf("NewFile() mismatch:\ngot  %v\nwant %v", gotDesc, tt.wantDesc)
+			}
+			if ((err == nil) != (tt.wantErr == "")) || !strings.Contains(fmt.Sprint(err), tt.wantErr) {
+				t.Errorf("NewFile() error:\ngot:  %v\nwant: %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestNewFiles(t *testing.T) {
+	fdset := &descriptorpb.FileDescriptorSet{
+		File: []*descriptorpb.FileDescriptorProto{
+			mustParseFile(`
+				name: "test.proto"
+				package: "fizz"
+				dependency: "dep.proto"
+				message_type: [{
+					name: "M2"
+					field: [{name:"F" number:1 label:LABEL_OPTIONAL type:TYPE_MESSAGE type_name:"M1"}]
+				}]
+			`),
+			// Inputs deliberately out of order.
+			mustParseFile(`
+				name: "dep.proto"
+				package: "fizz"
+				message_type: [{name:"M1"}]
+			`),
+		},
+	}
+	f, err := NewFiles(fdset)
+	if err != nil {
+		t.Fatal(err)
+	}
+	m1, err := f.FindDescriptorByName("fizz.M1")
+	if err != nil {
+		t.Fatalf(`f.FindDescriptorByName("fizz.M1") = %v`, err)
+	}
+	m2, err := f.FindDescriptorByName("fizz.M2")
+	if err != nil {
+		t.Fatalf(`f.FindDescriptorByName("fizz.M2") = %v`, err)
+	}
+	if m2.(protoreflect.MessageDescriptor).Fields().ByName("F").Message() != m1 {
+		t.Fatalf(`m1.Fields().ByName("F").Message() != m2`)
+	}
+}
+
+func TestNewFilesImportCycle(t *testing.T) {
+	fdset := &descriptorpb.FileDescriptorSet{
+		File: []*descriptorpb.FileDescriptorProto{
+			mustParseFile(`
+				name: "test.proto"
+				package: "fizz"
+				dependency: "dep.proto"
+			`),
+			mustParseFile(`
+				name: "dep.proto"
+				package: "fizz"
+				dependency: "test.proto"
+			`),
+		},
+	}
+	_, err := NewFiles(fdset)
+	if err == nil {
+		t.Fatal("NewFiles with import cycle: success, want error")
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/reflect/protodesc/proto.go b/vendor/google.golang.org/protobuf/reflect/protodesc/proto.go
new file mode 100644
index 000000000..00d35e02e
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/reflect/protodesc/proto.go
@@ -0,0 +1,242 @@
+// Copyright 2019 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 protodesc
+
+import (
+	"fmt"
+	"strings"
+
+	"google.golang.org/protobuf/internal/encoding/defval"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protoreflect"
+
+	"google.golang.org/protobuf/types/descriptorpb"
+)
+
+// ToFileDescriptorProto copies a protoreflect.FileDescriptor into a
+// google.protobuf.FileDescriptorProto message.
+func ToFileDescriptorProto(file protoreflect.FileDescriptor) *descriptorpb.FileDescriptorProto {
+	p := &descriptorpb.FileDescriptorProto{
+		Name:    proto.String(file.Path()),
+		Package: proto.String(string(file.Package())),
+		Options: proto.Clone(file.Options()).(*descriptorpb.FileOptions),
+	}
+	for i, imports := 0, file.Imports(); i < imports.Len(); i++ {
+		imp := imports.Get(i)
+		p.Dependency = append(p.Dependency, imp.Path())
+		if imp.IsPublic {
+			p.PublicDependency = append(p.PublicDependency, int32(i))
+		}
+		if imp.IsWeak {
+			p.WeakDependency = append(p.WeakDependency, int32(i))
+		}
+	}
+	for i, locs := 0, file.SourceLocations(); i < locs.Len(); i++ {
+		loc := locs.Get(i)
+		l := &descriptorpb.SourceCodeInfo_Location{}
+		l.Path = append(l.Path, loc.Path...)
+		if loc.StartLine == loc.EndLine {
+			l.Span = []int32{int32(loc.StartLine), int32(loc.StartColumn), int32(loc.EndColumn)}
+		} else {
+			l.Span = []int32{int32(loc.StartLine), int32(loc.StartColumn), int32(loc.EndLine), int32(loc.EndColumn)}
+		}
+		l.LeadingDetachedComments = append([]string(nil), loc.LeadingDetachedComments...)
+		if loc.LeadingComments != "" {
+			l.LeadingComments = proto.String(loc.LeadingComments)
+		}
+		if loc.TrailingComments != "" {
+			l.TrailingComments = proto.String(loc.TrailingComments)
+		}
+		if p.SourceCodeInfo == nil {
+			p.SourceCodeInfo = &descriptorpb.SourceCodeInfo{}
+		}
+		p.SourceCodeInfo.Location = append(p.SourceCodeInfo.Location, l)
+
+	}
+	for i, messages := 0, file.Messages(); i < messages.Len(); i++ {
+		p.MessageType = append(p.MessageType, ToDescriptorProto(messages.Get(i)))
+	}
+	for i, enums := 0, file.Enums(); i < enums.Len(); i++ {
+		p.EnumType = append(p.EnumType, ToEnumDescriptorProto(enums.Get(i)))
+	}
+	for i, services := 0, file.Services(); i < services.Len(); i++ {
+		p.Service = append(p.Service, ToServiceDescriptorProto(services.Get(i)))
+	}
+	for i, exts := 0, file.Extensions(); i < exts.Len(); i++ {
+		p.Extension = append(p.Extension, ToFieldDescriptorProto(exts.Get(i)))
+	}
+	if syntax := file.Syntax(); syntax != protoreflect.Proto2 {
+		p.Syntax = proto.String(file.Syntax().String())
+	}
+	return p
+}
+
+// ToDescriptorProto copies a protoreflect.MessageDescriptor into a
+// google.protobuf.DescriptorProto message.
+func ToDescriptorProto(message protoreflect.MessageDescriptor) *descriptorpb.DescriptorProto {
+	p := &descriptorpb.DescriptorProto{
+		Name:    proto.String(string(message.Name())),
+		Options: proto.Clone(message.Options()).(*descriptorpb.MessageOptions),
+	}
+	for i, fields := 0, message.Fields(); i < fields.Len(); i++ {
+		p.Field = append(p.Field, ToFieldDescriptorProto(fields.Get(i)))
+	}
+	for i, exts := 0, message.Extensions(); i < exts.Len(); i++ {
+		p.Extension = append(p.Extension, ToFieldDescriptorProto(exts.Get(i)))
+	}
+	for i, messages := 0, message.Messages(); i < messages.Len(); i++ {
+		p.NestedType = append(p.NestedType, ToDescriptorProto(messages.Get(i)))
+	}
+	for i, enums := 0, message.Enums(); i < enums.Len(); i++ {
+		p.EnumType = append(p.EnumType, ToEnumDescriptorProto(enums.Get(i)))
+	}
+	for i, xranges := 0, message.ExtensionRanges(); i < xranges.Len(); i++ {
+		xrange := xranges.Get(i)
+		p.ExtensionRange = append(p.ExtensionRange, &descriptorpb.DescriptorProto_ExtensionRange{
+			Start:   proto.Int32(int32(xrange[0])),
+			End:     proto.Int32(int32(xrange[1])),
+			Options: proto.Clone(message.ExtensionRangeOptions(i)).(*descriptorpb.ExtensionRangeOptions),
+		})
+	}
+	for i, oneofs := 0, message.Oneofs(); i < oneofs.Len(); i++ {
+		p.OneofDecl = append(p.OneofDecl, ToOneofDescriptorProto(oneofs.Get(i)))
+	}
+	for i, ranges := 0, message.ReservedRanges(); i < ranges.Len(); i++ {
+		rrange := ranges.Get(i)
+		p.ReservedRange = append(p.ReservedRange, &descriptorpb.DescriptorProto_ReservedRange{
+			Start: proto.Int32(int32(rrange[0])),
+			End:   proto.Int32(int32(rrange[1])),
+		})
+	}
+	for i, names := 0, message.ReservedNames(); i < names.Len(); i++ {
+		p.ReservedName = append(p.ReservedName, string(names.Get(i)))
+	}
+	return p
+}
+
+// ToFieldDescriptorProto copies a protoreflect.FieldDescriptor into a
+// google.protobuf.FieldDescriptorProto message.
+func ToFieldDescriptorProto(field protoreflect.FieldDescriptor) *descriptorpb.FieldDescriptorProto {
+	p := &descriptorpb.FieldDescriptorProto{
+		Name:    proto.String(string(field.Name())),
+		Number:  proto.Int32(int32(field.Number())),
+		Label:   descriptorpb.FieldDescriptorProto_Label(field.Cardinality()).Enum(),
+		Options: proto.Clone(field.Options()).(*descriptorpb.FieldOptions),
+	}
+	if field.IsExtension() {
+		p.Extendee = fullNameOf(field.ContainingMessage())
+	}
+	if field.Kind().IsValid() {
+		p.Type = descriptorpb.FieldDescriptorProto_Type(field.Kind()).Enum()
+	}
+	if field.Enum() != nil {
+		p.TypeName = fullNameOf(field.Enum())
+	}
+	if field.Message() != nil {
+		p.TypeName = fullNameOf(field.Message())
+	}
+	if field.HasJSONName() {
+		p.JsonName = proto.String(field.JSONName())
+	}
+	if field.Syntax() == protoreflect.Proto3 && field.HasOptionalKeyword() {
+		p.Proto3Optional = proto.Bool(true)
+	}
+	if field.HasDefault() {
+		def, err := defval.Marshal(field.Default(), field.DefaultEnumValue(), field.Kind(), defval.Descriptor)
+		if err != nil && field.DefaultEnumValue() != nil {
+			def = string(field.DefaultEnumValue().Name()) // occurs for unresolved enum values
+		} else if err != nil {
+			panic(fmt.Sprintf("%v: %v", field.FullName(), err))
+		}
+		p.DefaultValue = proto.String(def)
+	}
+	if oneof := field.ContainingOneof(); oneof != nil {
+		p.OneofIndex = proto.Int32(int32(oneof.Index()))
+	}
+	return p
+}
+
+// ToOneofDescriptorProto copies a protoreflect.OneofDescriptor into a
+// google.protobuf.OneofDescriptorProto message.
+func ToOneofDescriptorProto(oneof protoreflect.OneofDescriptor) *descriptorpb.OneofDescriptorProto {
+	return &descriptorpb.OneofDescriptorProto{
+		Name:    proto.String(string(oneof.Name())),
+		Options: proto.Clone(oneof.Options()).(*descriptorpb.OneofOptions),
+	}
+}
+
+// ToEnumDescriptorProto copies a protoreflect.EnumDescriptor into a
+// google.protobuf.EnumDescriptorProto message.
+func ToEnumDescriptorProto(enum protoreflect.EnumDescriptor) *descriptorpb.EnumDescriptorProto {
+	p := &descriptorpb.EnumDescriptorProto{
+		Name:    proto.String(string(enum.Name())),
+		Options: proto.Clone(enum.Options()).(*descriptorpb.EnumOptions),
+	}
+	for i, values := 0, enum.Values(); i < values.Len(); i++ {
+		p.Value = append(p.Value, ToEnumValueDescriptorProto(values.Get(i)))
+	}
+	for i, ranges := 0, enum.ReservedRanges(); i < ranges.Len(); i++ {
+		rrange := ranges.Get(i)
+		p.ReservedRange = append(p.ReservedRange, &descriptorpb.EnumDescriptorProto_EnumReservedRange{
+			Start: proto.Int32(int32(rrange[0])),
+			End:   proto.Int32(int32(rrange[1])),
+		})
+	}
+	for i, names := 0, enum.ReservedNames(); i < names.Len(); i++ {
+		p.ReservedName = append(p.ReservedName, string(names.Get(i)))
+	}
+	return p
+}
+
+// ToEnumValueDescriptorProto copies a protoreflect.EnumValueDescriptor into a
+// google.protobuf.EnumValueDescriptorProto message.
+func ToEnumValueDescriptorProto(value protoreflect.EnumValueDescriptor) *descriptorpb.EnumValueDescriptorProto {
+	return &descriptorpb.EnumValueDescriptorProto{
+		Name:    proto.String(string(value.Name())),
+		Number:  proto.Int32(int32(value.Number())),
+		Options: proto.Clone(value.Options()).(*descriptorpb.EnumValueOptions),
+	}
+}
+
+// ToServiceDescriptorProto copies a protoreflect.ServiceDescriptor into a
+// google.protobuf.ServiceDescriptorProto message.
+func ToServiceDescriptorProto(service protoreflect.ServiceDescriptor) *descriptorpb.ServiceDescriptorProto {
+	p := &descriptorpb.ServiceDescriptorProto{
+		Name:    proto.String(string(service.Name())),
+		Options: proto.Clone(service.Options()).(*descriptorpb.ServiceOptions),
+	}
+	for i, methods := 0, service.Methods(); i < methods.Len(); i++ {
+		p.Method = append(p.Method, ToMethodDescriptorProto(methods.Get(i)))
+	}
+	return p
+}
+
+// ToMethodDescriptorProto copies a protoreflect.MethodDescriptor into a
+// google.protobuf.MethodDescriptorProto message.
+func ToMethodDescriptorProto(method protoreflect.MethodDescriptor) *descriptorpb.MethodDescriptorProto {
+	p := &descriptorpb.MethodDescriptorProto{
+		Name:       proto.String(string(method.Name())),
+		InputType:  fullNameOf(method.Input()),
+		OutputType: fullNameOf(method.Output()),
+		Options:    proto.Clone(method.Options()).(*descriptorpb.MethodOptions),
+	}
+	if method.IsStreamingClient() {
+		p.ClientStreaming = proto.Bool(true)
+	}
+	if method.IsStreamingServer() {
+		p.ServerStreaming = proto.Bool(true)
+	}
+	return p
+}
+
+func fullNameOf(d protoreflect.Descriptor) *string {
+	if d == nil {
+		return nil
+	}
+	if strings.HasPrefix(string(d.FullName()), unknownPrefix) {
+		return proto.String(string(d.FullName()[len(unknownPrefix):]))
+	}
+	return proto.String("." + string(d.FullName()))
+}
diff --git a/vendor/google.golang.org/protobuf/reflect/protoreflect/methods.go b/vendor/google.golang.org/protobuf/reflect/protoreflect/methods.go
new file mode 100644
index 000000000..6be5d16e9
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/reflect/protoreflect/methods.go
@@ -0,0 +1,77 @@
+// Copyright 2020 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 protoreflect
+
+import (
+	"google.golang.org/protobuf/internal/pragma"
+)
+
+// The following types are used by the fast-path Message.ProtoMethods method.
+//
+// To avoid polluting the public protoreflect API with types used only by
+// low-level implementations, the canonical definitions of these types are
+// in the runtime/protoiface package. The definitions here and in protoiface
+// must be kept in sync.
+type (
+	methods = struct {
+		pragma.NoUnkeyedLiterals
+		Flags            supportFlags
+		Size             func(sizeInput) sizeOutput
+		Marshal          func(marshalInput) (marshalOutput, error)
+		Unmarshal        func(unmarshalInput) (unmarshalOutput, error)
+		Merge            func(mergeInput) mergeOutput
+		CheckInitialized func(checkInitializedInput) (checkInitializedOutput, error)
+	}
+	supportFlags = uint64
+	sizeInput    = struct {
+		pragma.NoUnkeyedLiterals
+		Message Message
+		Flags   uint8
+	}
+	sizeOutput = struct {
+		pragma.NoUnkeyedLiterals
+		Size int
+	}
+	marshalInput = struct {
+		pragma.NoUnkeyedLiterals
+		Message Message
+		Buf     []byte
+		Flags   uint8
+	}
+	marshalOutput = struct {
+		pragma.NoUnkeyedLiterals
+		Buf []byte
+	}
+	unmarshalInput = struct {
+		pragma.NoUnkeyedLiterals
+		Message  Message
+		Buf      []byte
+		Flags    uint8
+		Resolver interface {
+			FindExtensionByName(field FullName) (ExtensionType, error)
+			FindExtensionByNumber(message FullName, field FieldNumber) (ExtensionType, error)
+		}
+	}
+	unmarshalOutput = struct {
+		pragma.NoUnkeyedLiterals
+		Flags uint8
+	}
+	mergeInput = struct {
+		pragma.NoUnkeyedLiterals
+		Source      Message
+		Destination Message
+	}
+	mergeOutput = struct {
+		pragma.NoUnkeyedLiterals
+		Flags uint8
+	}
+	checkInitializedInput = struct {
+		pragma.NoUnkeyedLiterals
+		Message Message
+	}
+	checkInitializedOutput = struct {
+		pragma.NoUnkeyedLiterals
+	}
+)
diff --git a/vendor/google.golang.org/protobuf/reflect/protoreflect/proto.go b/vendor/google.golang.org/protobuf/reflect/protoreflect/proto.go
new file mode 100644
index 000000000..b669a4e76
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/reflect/protoreflect/proto.go
@@ -0,0 +1,478 @@
+// 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 protoreflect provides interfaces to dynamically manipulate messages.
+//
+// This package includes type descriptors which describe the structure of types
+// defined in proto source files and value interfaces which provide the
+// ability to examine and manipulate the contents of messages.
+//
+//
+// Protocol Buffer Descriptors
+//
+// Protobuf descriptors (e.g., EnumDescriptor or MessageDescriptor)
+// are immutable objects that represent protobuf type information.
+// They are wrappers around the messages declared in descriptor.proto.
+// Protobuf descriptors alone lack any information regarding Go types.
+//
+// Enums and messages generated by this module implement Enum and ProtoMessage,
+// where the Descriptor and ProtoReflect.Descriptor accessors respectively
+// return the protobuf descriptor for the values.
+//
+// The protobuf descriptor interfaces are not meant to be implemented by
+// user code since they might need to be extended in the future to support
+// additions to the protobuf language.
+// The "google.golang.org/protobuf/reflect/protodesc" package converts between
+// google.protobuf.DescriptorProto messages and protobuf descriptors.
+//
+//
+// Go Type Descriptors
+//
+// A type descriptor (e.g., EnumType or MessageType) is a constructor for
+// a concrete Go type that represents the associated protobuf descriptor.
+// There is commonly a one-to-one relationship between protobuf descriptors and
+// Go type descriptors, but it can potentially be a one-to-many relationship.
+//
+// Enums and messages generated by this module implement Enum and ProtoMessage,
+// where the Type and ProtoReflect.Type accessors respectively
+// return the protobuf descriptor for the values.
+//
+// The "google.golang.org/protobuf/types/dynamicpb" package can be used to
+// create Go type descriptors from protobuf descriptors.
+//
+//
+// Value Interfaces
+//
+// The Enum and Message interfaces provide a reflective view over an
+// enum or message instance. For enums, it provides the ability to retrieve
+// the enum value number for any concrete enum type. For messages, it provides
+// the ability to access or manipulate fields of the message.
+//
+// To convert a proto.Message to a protoreflect.Message, use the
+// former's ProtoReflect method. Since the ProtoReflect method is new to the
+// v2 message interface, it may not be present on older message implementations.
+// The "github.com/golang/protobuf/proto".MessageReflect function can be used
+// to obtain a reflective view on older messages.
+//
+//
+// Relationships
+//
+// The following diagrams demonstrate the relationships between
+// various types declared in this package.
+//
+//
+//	                       ┌───────────────────────────────────┐
+//	                       V                                   │
+//	   ┌────────────── New(n) ─────────────┐                   │
+//	   │                                   │                   │
+//	   │      ┌──── Descriptor() ──┐       │  ┌── Number() ──┐ │
+//	   │      │                    V       V  │              V │
+//	╔════════════╗  ╔════════════════╗  ╔════════╗  ╔════════════╗
+//	║  EnumType  ║  ║ EnumDescriptor ║  ║  Enum  ║  ║ EnumNumber ║
+//	╚════════════╝  ╚════════════════╝  ╚════════╝  ╚════════════╝
+//	      Λ           Λ                   │ │
+//	      │           └─── Descriptor() ──┘ │
+//	      │                                 │
+//	      └────────────────── Type() ───────┘
+//
+// • An EnumType describes a concrete Go enum type.
+// It has an EnumDescriptor and can construct an Enum instance.
+//
+// • An EnumDescriptor describes an abstract protobuf enum type.
+//
+// • An Enum is a concrete enum instance. Generated enums implement Enum.
+//
+//
+//	  ┌──────────────── New() ─────────────────┐
+//	  │                                        │
+//	  │         ┌─── Descriptor() ─────┐       │   ┌── Interface() ───┐
+//	  │         │                      V       V   │                  V
+//	╔═════════════╗  ╔═══════════════════╗  ╔═════════╗  ╔══════════════╗
+//	║ MessageType ║  ║ MessageDescriptor ║  ║ Message ║  ║ ProtoMessage ║
+//	╚═════════════╝  ╚═══════════════════╝  ╚═════════╝  ╚══════════════╝
+//	       Λ           Λ                      │ │  Λ                  │
+//	       │           └──── Descriptor() ────┘ │  └─ ProtoReflect() ─┘
+//	       │                                    │
+//	       └─────────────────── Type() ─────────┘
+//
+// • A MessageType describes a concrete Go message type.
+// It has a MessageDescriptor and can construct a Message instance.
+//
+// • A MessageDescriptor describes an abstract protobuf message type.
+//
+// • A Message is a concrete message instance. Generated messages implement
+// ProtoMessage, which can convert to/from a Message.
+//
+//
+//	      ┌── TypeDescriptor() ──┐    ┌───── Descriptor() ─────┐
+//	      │                      V    │                        V
+//	╔═══════════════╗  ╔═════════════════════════╗  ╔═════════════════════╗
+//	║ ExtensionType ║  ║ ExtensionTypeDescriptor ║  ║ ExtensionDescriptor ║
+//	╚═══════════════╝  ╚═════════════════════════╝  ╚═════════════════════╝
+//	      Λ                      │   │ Λ                      │ Λ
+//	      └─────── Type() ───────┘   │ └─── may implement ────┘ │
+//	                                 │                          │
+//	                                 └────── implements ────────┘
+//
+// • An ExtensionType describes a concrete Go implementation of an extension.
+// It has an ExtensionTypeDescriptor and can convert to/from
+// abstract Values and Go values.
+//
+// • An ExtensionTypeDescriptor is an ExtensionDescriptor
+// which also has an ExtensionType.
+//
+// • An ExtensionDescriptor describes an abstract protobuf extension field and
+// may not always be an ExtensionTypeDescriptor.
+package protoreflect
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+
+	"google.golang.org/protobuf/encoding/protowire"
+	"google.golang.org/protobuf/internal/pragma"
+)
+
+type doNotImplement pragma.DoNotImplement
+
+// ProtoMessage is the top-level interface that all proto messages implement.
+// This is declared in the protoreflect package to avoid a cyclic dependency;
+// use the proto.Message type instead, which aliases this type.
+type ProtoMessage interface{ ProtoReflect() Message }
+
+// Syntax is the language version of the proto file.
+type Syntax syntax
+
+type syntax int8 // keep exact type opaque as the int type may change
+
+const (
+	Proto2 Syntax = 2
+	Proto3 Syntax = 3
+)
+
+// IsValid reports whether the syntax is valid.
+func (s Syntax) IsValid() bool {
+	switch s {
+	case Proto2, Proto3:
+		return true
+	default:
+		return false
+	}
+}
+
+// String returns s as a proto source identifier (e.g., "proto2").
+func (s Syntax) String() string {
+	switch s {
+	case Proto2:
+		return "proto2"
+	case Proto3:
+		return "proto3"
+	default:
+		return fmt.Sprintf("<unknown:%d>", s)
+	}
+}
+
+// GoString returns s as a Go source identifier (e.g., "Proto2").
+func (s Syntax) GoString() string {
+	switch s {
+	case Proto2:
+		return "Proto2"
+	case Proto3:
+		return "Proto3"
+	default:
+		return fmt.Sprintf("Syntax(%d)", s)
+	}
+}
+
+// Cardinality determines whether a field is optional, required, or repeated.
+type Cardinality cardinality
+
+type cardinality int8 // keep exact type opaque as the int type may change
+
+// Constants as defined by the google.protobuf.Cardinality enumeration.
+const (
+	Optional Cardinality = 1 // appears zero or one times
+	Required Cardinality = 2 // appears exactly one time; invalid with Proto3
+	Repeated Cardinality = 3 // appears zero or more times
+)
+
+// IsValid reports whether the cardinality is valid.
+func (c Cardinality) IsValid() bool {
+	switch c {
+	case Optional, Required, Repeated:
+		return true
+	default:
+		return false
+	}
+}
+
+// String returns c as a proto source identifier (e.g., "optional").
+func (c Cardinality) String() string {
+	switch c {
+	case Optional:
+		return "optional"
+	case Required:
+		return "required"
+	case Repeated:
+		return "repeated"
+	default:
+		return fmt.Sprintf("<unknown:%d>", c)
+	}
+}
+
+// GoString returns c as a Go source identifier (e.g., "Optional").
+func (c Cardinality) GoString() string {
+	switch c {
+	case Optional:
+		return "Optional"
+	case Required:
+		return "Required"
+	case Repeated:
+		return "Repeated"
+	default:
+		return fmt.Sprintf("Cardinality(%d)", c)
+	}
+}
+
+// Kind indicates the basic proto kind of a field.
+type Kind kind
+
+type kind int8 // keep exact type opaque as the int type may change
+
+// Constants as defined by the google.protobuf.Field.Kind enumeration.
+const (
+	BoolKind     Kind = 8
+	EnumKind     Kind = 14
+	Int32Kind    Kind = 5
+	Sint32Kind   Kind = 17
+	Uint32Kind   Kind = 13
+	Int64Kind    Kind = 3
+	Sint64Kind   Kind = 18
+	Uint64Kind   Kind = 4
+	Sfixed32Kind Kind = 15
+	Fixed32Kind  Kind = 7
+	FloatKind    Kind = 2
+	Sfixed64Kind Kind = 16
+	Fixed64Kind  Kind = 6
+	DoubleKind   Kind = 1
+	StringKind   Kind = 9
+	BytesKind    Kind = 12
+	MessageKind  Kind = 11
+	GroupKind    Kind = 10
+)
+
+// IsValid reports whether the kind is valid.
+func (k Kind) IsValid() bool {
+	switch k {
+	case BoolKind, EnumKind,
+		Int32Kind, Sint32Kind, Uint32Kind,
+		Int64Kind, Sint64Kind, Uint64Kind,
+		Sfixed32Kind, Fixed32Kind, FloatKind,
+		Sfixed64Kind, Fixed64Kind, DoubleKind,
+		StringKind, BytesKind, MessageKind, GroupKind:
+		return true
+	default:
+		return false
+	}
+}
+
+// String returns k as a proto source identifier (e.g., "bool").
+func (k Kind) String() string {
+	switch k {
+	case BoolKind:
+		return "bool"
+	case EnumKind:
+		return "enum"
+	case Int32Kind:
+		return "int32"
+	case Sint32Kind:
+		return "sint32"
+	case Uint32Kind:
+		return "uint32"
+	case Int64Kind:
+		return "int64"
+	case Sint64Kind:
+		return "sint64"
+	case Uint64Kind:
+		return "uint64"
+	case Sfixed32Kind:
+		return "sfixed32"
+	case Fixed32Kind:
+		return "fixed32"
+	case FloatKind:
+		return "float"
+	case Sfixed64Kind:
+		return "sfixed64"
+	case Fixed64Kind:
+		return "fixed64"
+	case DoubleKind:
+		return "double"
+	case StringKind:
+		return "string"
+	case BytesKind:
+		return "bytes"
+	case MessageKind:
+		return "message"
+	case GroupKind:
+		return "group"
+	default:
+		return fmt.Sprintf("<unknown:%d>", k)
+	}
+}
+
+// GoString returns k as a Go source identifier (e.g., "BoolKind").
+func (k Kind) GoString() string {
+	switch k {
+	case BoolKind:
+		return "BoolKind"
+	case EnumKind:
+		return "EnumKind"
+	case Int32Kind:
+		return "Int32Kind"
+	case Sint32Kind:
+		return "Sint32Kind"
+	case Uint32Kind:
+		return "Uint32Kind"
+	case Int64Kind:
+		return "Int64Kind"
+	case Sint64Kind:
+		return "Sint64Kind"
+	case Uint64Kind:
+		return "Uint64Kind"
+	case Sfixed32Kind:
+		return "Sfixed32Kind"
+	case Fixed32Kind:
+		return "Fixed32Kind"
+	case FloatKind:
+		return "FloatKind"
+	case Sfixed64Kind:
+		return "Sfixed64Kind"
+	case Fixed64Kind:
+		return "Fixed64Kind"
+	case DoubleKind:
+		return "DoubleKind"
+	case StringKind:
+		return "StringKind"
+	case BytesKind:
+		return "BytesKind"
+	case MessageKind:
+		return "MessageKind"
+	case GroupKind:
+		return "GroupKind"
+	default:
+		return fmt.Sprintf("Kind(%d)", k)
+	}
+}
+
+// FieldNumber is the field number in a message.
+type FieldNumber = protowire.Number
+
+// FieldNumbers represent a list of field numbers.
+type FieldNumbers interface {
+	// Len reports the number of fields in the list.
+	Len() int
+	// Get returns the ith field number. It panics if out of bounds.
+	Get(i int) FieldNumber
+	// Has reports whether n is within the list of fields.
+	Has(n FieldNumber) bool
+
+	doNotImplement
+}
+
+// FieldRanges represent a list of field number ranges.
+type FieldRanges interface {
+	// Len reports the number of ranges in the list.
+	Len() int
+	// Get returns the ith range. It panics if out of bounds.
+	Get(i int) [2]FieldNumber // start inclusive; end exclusive
+	// Has reports whether n is within any of the ranges.
+	Has(n FieldNumber) bool
+
+	doNotImplement
+}
+
+// EnumNumber is the numeric value for an enum.
+type EnumNumber int32
+
+// EnumRanges represent a list of enum number ranges.
+type EnumRanges interface {
+	// Len reports the number of ranges in the list.
+	Len() int
+	// Get returns the ith range. It panics if out of bounds.
+	Get(i int) [2]EnumNumber // start inclusive; end inclusive
+	// Has reports whether n is within any of the ranges.
+	Has(n EnumNumber) bool
+
+	doNotImplement
+}
+
+var (
+	regexName     = regexp.MustCompile(`^[_a-zA-Z][_a-zA-Z0-9]*$`)
+	regexFullName = regexp.MustCompile(`^[_a-zA-Z][_a-zA-Z0-9]*(\.[_a-zA-Z][_a-zA-Z0-9]*)*$`)
+)
+
+// Name is the short name for a proto declaration. This is not the name
+// as used in Go source code, which might not be identical to the proto name.
+type Name string // e.g., "Kind"
+
+// IsValid reports whether n is a syntactically valid name.
+// An empty name is invalid.
+func (n Name) IsValid() bool {
+	return regexName.MatchString(string(n))
+}
+
+// Names represent a list of names.
+type Names interface {
+	// Len reports the number of names in the list.
+	Len() int
+	// Get returns the ith name. It panics if out of bounds.
+	Get(i int) Name
+	// Has reports whether s matches any names in the list.
+	Has(s Name) bool
+
+	doNotImplement
+}
+
+// FullName is a qualified name that uniquely identifies a proto declaration.
+// A qualified name is the concatenation of the proto package along with the
+// fully-declared name (i.e., name of parent preceding the name of the child),
+// with a '.' delimiter placed between each Name.
+//
+// This should not have any leading or trailing dots.
+type FullName string // e.g., "google.protobuf.Field.Kind"
+
+// IsValid reports whether n is a syntactically valid full name.
+// An empty full name is invalid.
+func (n FullName) IsValid() bool {
+	return regexFullName.MatchString(string(n))
+}
+
+// Name returns the short name, which is the last identifier segment.
+// A single segment FullName is the Name itself.
+func (n FullName) Name() Name {
+	if i := strings.LastIndexByte(string(n), '.'); i >= 0 {
+		return Name(n[i+1:])
+	}
+	return Name(n)
+}
+
+// Parent returns the full name with the trailing identifier removed.
+// A single segment FullName has no parent.
+func (n FullName) Parent() FullName {
+	if i := strings.LastIndexByte(string(n), '.'); i >= 0 {
+		return n[:i]
+	}
+	return ""
+}
+
+// Append returns the qualified name appended with the provided short name.
+//
+// Invariant: n == n.Parent().Append(n.Name()) // assuming n is valid
+func (n FullName) Append(s Name) FullName {
+	if n == "" {
+		return FullName(s)
+	}
+	return n + "." + FullName(s)
+}
diff --git a/vendor/google.golang.org/protobuf/reflect/protoreflect/proto_test.go b/vendor/google.golang.org/protobuf/reflect/protoreflect/proto_test.go
new file mode 100644
index 000000000..a62a00436
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/reflect/protoreflect/proto_test.go
@@ -0,0 +1,74 @@
+// 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 protoreflect
+
+import "testing"
+
+func TestNameIsValid(t *testing.T) {
+	tests := []struct {
+		in   Name
+		want bool
+	}{
+		{"", false},
+		{"a", true},
+		{".", false},
+		{"_", true}, // odd, but permitted by protoc
+		{".foo", false},
+		{"foo.", false},
+		{"foo", true},
+		{"one1_two2_three3", true},
+		{"1one", false},
+	}
+
+	for _, tt := range tests {
+		if got := tt.in.IsValid(); got != tt.want {
+			t.Errorf("Name(%q).IsValid() = %v, want %v", tt.in, got, tt.want)
+		}
+	}
+}
+
+func TestFullNameIsValid(t *testing.T) {
+	tests := []struct {
+		in   FullName
+		want bool
+	}{
+		{"", false},
+		{"a", true},
+		{"a.b", true},
+		{"a.b.c", true},
+		{".", false},
+		{"_._._", true}, // odd, but permitted by protoc
+		{".foo", false},
+		{"foo.", false},
+		{"foo", true},
+		{"one1_two2_three3", true},
+		{"one1.two2.three3", true},
+		{".one1.two2.three3", false},
+		{"one1.two2.three3.", false},
+		{"foo.1one", false},
+	}
+
+	for _, tt := range tests {
+		if got := tt.in.IsValid(); got != tt.want {
+			t.Errorf("Name(%q).IsValid() = %v, want %v", tt.in, got, tt.want)
+		}
+	}
+}
+
+func TestNameAppend(t *testing.T) {
+	tests := []FullName{
+		"",
+		"a",
+		"a.b",
+		"a.b.c",
+		"one1.two2.three3",
+	}
+
+	for _, tt := range tests {
+		if got := tt.Parent().Append(tt.Name()); got != tt {
+			t.Errorf("FullName.Parent().Append(FullName.Name()) = %q, want %q", got, tt)
+		}
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/reflect/protoreflect/source.go b/vendor/google.golang.org/protobuf/reflect/protoreflect/source.go
new file mode 100644
index 000000000..32ea3d98c
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/reflect/protoreflect/source.go
@@ -0,0 +1,52 @@
+// Copyright 2019 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 protoreflect
+
+// SourceLocations is a list of source locations.
+type SourceLocations interface {
+	// Len reports the number of source locations in the proto file.
+	Len() int
+	// Get returns the ith SourceLocation. It panics if out of bounds.
+	Get(int) SourceLocation
+
+	doNotImplement
+
+	// TODO: Add ByPath and ByDescriptor helper methods.
+}
+
+// SourceLocation describes a source location and
+// corresponds with the google.protobuf.SourceCodeInfo.Location message.
+type SourceLocation struct {
+	// Path is the path to the declaration from the root file descriptor.
+	// The contents of this slice must not be mutated.
+	Path SourcePath
+
+	// StartLine and StartColumn are the zero-indexed starting location
+	// in the source file for the declaration.
+	StartLine, StartColumn int
+	// EndLine and EndColumn are the zero-indexed ending location
+	// in the source file for the declaration.
+	// In the descriptor.proto, the end line may be omitted if it is identical
+	// to the start line. Here, it is always populated.
+	EndLine, EndColumn int
+
+	// LeadingDetachedComments are the leading detached comments
+	// for the declaration. The contents of this slice must not be mutated.
+	LeadingDetachedComments []string
+	// LeadingComments is the leading attached comment for the declaration.
+	LeadingComments string
+	// TrailingComments is the trailing attached comment for the declaration.
+	TrailingComments string
+}
+
+// SourcePath identifies part of a file descriptor for a source location.
+// The SourcePath is a sequence of either field numbers or indexes into
+// a repeated field that form a path starting from the root file descriptor.
+//
+// See google.protobuf.SourceCodeInfo.Location.path.
+type SourcePath []int32
+
+// TODO: Add SourcePath.String method to pretty-print the path. For example:
+//	".message_type[6].nested_type[15].field[3]"
diff --git a/vendor/google.golang.org/protobuf/reflect/protoreflect/type.go b/vendor/google.golang.org/protobuf/reflect/protoreflect/type.go
new file mode 100644
index 000000000..5be14a725
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/reflect/protoreflect/type.go
@@ -0,0 +1,631 @@
+// 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 protoreflect
+
+// Descriptor provides a set of accessors that are common to every descriptor.
+// Each descriptor type wraps the equivalent google.protobuf.XXXDescriptorProto,
+// but provides efficient lookup and immutability.
+//
+// Each descriptor is comparable. Equality implies that the two types are
+// exactly identical. However, it is possible for the same semantically
+// identical proto type to be represented by multiple type descriptors.
+//
+// For example, suppose we have t1 and t2 which are both MessageDescriptors.
+// If t1 == t2, then the types are definitely equal and all accessors return
+// the same information. However, if t1 != t2, then it is still possible that
+// they still represent the same proto type (e.g., t1.FullName == t2.FullName).
+// This can occur if a descriptor type is created dynamically, or multiple
+// versions of the same proto type are accidentally linked into the Go binary.
+type Descriptor interface {
+	// ParentFile returns the parent file descriptor that this descriptor
+	// is declared within. The parent file for the file descriptor is itself.
+	//
+	// Support for this functionality is optional and may return nil.
+	ParentFile() FileDescriptor
+
+	// Parent returns the parent containing this descriptor declaration.
+	// The following shows the mapping from child type to possible parent types:
+	//
+	//	╔═════════════════════╤═══════════════════════════════════╗
+	//	║ Child type          │ Possible parent types             ║
+	//	╠═════════════════════╪═══════════════════════════════════╣
+	//	║ FileDescriptor      │ nil                               ║
+	//	║ MessageDescriptor   │ FileDescriptor, MessageDescriptor ║
+	//	║ FieldDescriptor     │ FileDescriptor, MessageDescriptor ║
+	//	║ OneofDescriptor     │ MessageDescriptor                 ║
+	//	║ EnumDescriptor      │ FileDescriptor, MessageDescriptor ║
+	//	║ EnumValueDescriptor │ EnumDescriptor                    ║
+	//	║ ServiceDescriptor   │ FileDescriptor                    ║
+	//	║ MethodDescriptor    │ ServiceDescriptor                 ║
+	//	╚═════════════════════╧═══════════════════════════════════╝
+	//
+	// Support for this functionality is optional and may return nil.
+	Parent() Descriptor
+
+	// Index returns the index of this descriptor within its parent.
+	// It returns 0 if the descriptor does not have a parent or if the parent
+	// is unknown.
+	Index() int
+
+	// Syntax is the protobuf syntax.
+	Syntax() Syntax // e.g., Proto2 or Proto3
+
+	// Name is the short name of the declaration (i.e., FullName.Name).
+	Name() Name // e.g., "Any"
+
+	// FullName is the fully-qualified name of the declaration.
+	//
+	// The FullName is a concatenation of the full name of the type that this
+	// type is declared within and the declaration name. For example,
+	// field "foo_field" in message "proto.package.MyMessage" is
+	// uniquely identified as "proto.package.MyMessage.foo_field".
+	// Enum values are an exception to the rule (see EnumValueDescriptor).
+	FullName() FullName // e.g., "google.protobuf.Any"
+
+	// IsPlaceholder reports whether type information is missing since a
+	// dependency is not resolved, in which case only name information is known.
+	//
+	// Placeholder types may only be returned by the following accessors
+	// as a result of unresolved dependencies or weak imports:
+	//
+	//	╔═══════════════════════════════════╤═════════════════════╗
+	//	║ Accessor                          │ Descriptor          ║
+	//	╠═══════════════════════════════════╪═════════════════════╣
+	//	║ FileImports.FileDescriptor        │ FileDescriptor      ║
+	//	║ FieldDescriptor.Enum              │ EnumDescriptor      ║
+	//	║ FieldDescriptor.Message           │ MessageDescriptor   ║
+	//	║ FieldDescriptor.DefaultEnumValue  │ EnumValueDescriptor ║
+	//	║ FieldDescriptor.ContainingMessage │ MessageDescriptor   ║
+	//	║ MethodDescriptor.Input            │ MessageDescriptor   ║
+	//	║ MethodDescriptor.Output           │ MessageDescriptor   ║
+	//	╚═══════════════════════════════════╧═════════════════════╝
+	//
+	// If true, only Name and FullName are valid.
+	// For FileDescriptor, the Path is also valid.
+	IsPlaceholder() bool
+
+	// Options returns the descriptor options. The caller must not modify
+	// the returned value.
+	//
+	// To avoid a dependency cycle, this function returns a proto.Message value.
+	// The proto message type returned for each descriptor type is as follows:
+	//	╔═════════════════════╤══════════════════════════════════════════╗
+	//	║ Go type             │ Protobuf message type                    ║
+	//	╠═════════════════════╪══════════════════════════════════════════╣
+	//	║ FileDescriptor      │ google.protobuf.FileOptions              ║
+	//	║ EnumDescriptor      │ google.protobuf.EnumOptions              ║
+	//	║ EnumValueDescriptor │ google.protobuf.EnumValueOptions         ║
+	//	║ MessageDescriptor   │ google.protobuf.MessageOptions           ║
+	//	║ FieldDescriptor     │ google.protobuf.FieldOptions             ║
+	//	║ OneofDescriptor     │ google.protobuf.OneofOptions             ║
+	//	║ ServiceDescriptor   │ google.protobuf.ServiceOptions           ║
+	//	║ MethodDescriptor    │ google.protobuf.MethodOptions            ║
+	//	╚═════════════════════╧══════════════════════════════════════════╝
+	//
+	// This method returns a typed nil-pointer if no options are present.
+	// The caller must import the descriptorpb package to use this.
+	Options() ProtoMessage
+
+	doNotImplement
+}
+
+// FileDescriptor describes the types in a complete proto file and
+// corresponds with the google.protobuf.FileDescriptorProto message.
+//
+// Top-level declarations:
+// EnumDescriptor, MessageDescriptor, FieldDescriptor, and/or ServiceDescriptor.
+type FileDescriptor interface {
+	Descriptor // Descriptor.FullName is identical to Package
+
+	// Path returns the file name, relative to the source tree root.
+	Path() string // e.g., "path/to/file.proto"
+	// Package returns the protobuf package namespace.
+	Package() FullName // e.g., "google.protobuf"
+
+	// Imports is a list of imported proto files.
+	Imports() FileImports
+
+	// Enums is a list of the top-level enum declarations.
+	Enums() EnumDescriptors
+	// Messages is a list of the top-level message declarations.
+	Messages() MessageDescriptors
+	// Extensions is a list of the top-level extension declarations.
+	Extensions() ExtensionDescriptors
+	// Services is a list of the top-level service declarations.
+	Services() ServiceDescriptors
+
+	// SourceLocations is a list of source locations.
+	SourceLocations() SourceLocations
+
+	isFileDescriptor
+}
+type isFileDescriptor interface{ ProtoType(FileDescriptor) }
+
+// FileImports is a list of file imports.
+type FileImports interface {
+	// Len reports the number of files imported by this proto file.
+	Len() int
+	// Get returns the ith FileImport. It panics if out of bounds.
+	Get(i int) FileImport
+
+	doNotImplement
+}
+
+// FileImport is the declaration for a proto file import.
+type FileImport struct {
+	// FileDescriptor is the file type for the given import.
+	// It is a placeholder descriptor if IsWeak is set or if a dependency has
+	// not been regenerated to implement the new reflection APIs.
+	FileDescriptor
+
+	// IsPublic reports whether this is a public import, which causes this file
+	// to alias declarations within the imported file. The intended use cases
+	// for this feature is the ability to move proto files without breaking
+	// existing dependencies.
+	//
+	// The current file and the imported file must be within proto package.
+	IsPublic bool
+
+	// IsWeak reports whether this is a weak import, which does not impose
+	// a direct dependency on the target file.
+	//
+	// Weak imports are a legacy proto1 feature. Equivalent behavior is
+	// achieved using proto2 extension fields or proto3 Any messages.
+	IsWeak bool
+}
+
+// MessageDescriptor describes a message and
+// corresponds with the google.protobuf.DescriptorProto message.
+//
+// Nested declarations:
+// FieldDescriptor, OneofDescriptor, FieldDescriptor, EnumDescriptor,
+// and/or MessageDescriptor.
+type MessageDescriptor interface {
+	Descriptor
+
+	// IsMapEntry indicates that this is an auto-generated message type to
+	// represent the entry type for a map field.
+	//
+	// Map entry messages have only two fields:
+	//	• a "key" field with a field number of 1
+	//	• a "value" field with a field number of 2
+	// The key and value types are determined by these two fields.
+	//
+	// If IsMapEntry is true, it implies that FieldDescriptor.IsMap is true
+	// for some field with this message type.
+	IsMapEntry() bool
+
+	// Fields is a list of nested field declarations.
+	Fields() FieldDescriptors
+	// Oneofs is a list of nested oneof declarations.
+	Oneofs() OneofDescriptors
+
+	// ReservedNames is a list of reserved field names.
+	ReservedNames() Names
+	// ReservedRanges is a list of reserved ranges of field numbers.
+	ReservedRanges() FieldRanges
+	// RequiredNumbers is a list of required field numbers.
+	// In Proto3, it is always an empty list.
+	RequiredNumbers() FieldNumbers
+	// ExtensionRanges is the field ranges used for extension fields.
+	// In Proto3, it is always an empty ranges.
+	ExtensionRanges() FieldRanges
+	// ExtensionRangeOptions returns the ith extension range options.
+	//
+	// To avoid a dependency cycle, this method returns a proto.Message value,
+	// which always contains a google.protobuf.ExtensionRangeOptions message.
+	// This method returns a typed nil-pointer if no options are present.
+	// The caller must import the descriptorpb package to use this.
+	ExtensionRangeOptions(i int) ProtoMessage
+
+	// Enums is a list of nested enum declarations.
+	Enums() EnumDescriptors
+	// Messages is a list of nested message declarations.
+	Messages() MessageDescriptors
+	// Extensions is a list of nested extension declarations.
+	Extensions() ExtensionDescriptors
+
+	isMessageDescriptor
+}
+type isMessageDescriptor interface{ ProtoType(MessageDescriptor) }
+
+// MessageType encapsulates a MessageDescriptor with a concrete Go implementation.
+type MessageType interface {
+	// New returns a newly allocated empty message.
+	New() Message
+
+	// Zero returns an empty, read-only message.
+	Zero() Message
+
+	// Descriptor returns the message descriptor.
+	//
+	// Invariant: t.Descriptor() == t.New().Descriptor()
+	Descriptor() MessageDescriptor
+}
+
+// MessageDescriptors is a list of message declarations.
+type MessageDescriptors interface {
+	// Len reports the number of messages.
+	Len() int
+	// Get returns the ith MessageDescriptor. It panics if out of bounds.
+	Get(i int) MessageDescriptor
+	// ByName returns the MessageDescriptor for a message named s.
+	// It returns nil if not found.
+	ByName(s Name) MessageDescriptor
+
+	doNotImplement
+}
+
+// FieldDescriptor describes a field within a message and
+// corresponds with the google.protobuf.FieldDescriptorProto message.
+//
+// It is used for both normal fields defined within the parent message
+// (e.g., MessageDescriptor.Fields) and fields that extend some remote message
+// (e.g., FileDescriptor.Extensions or MessageDescriptor.Extensions).
+type FieldDescriptor interface {
+	Descriptor
+
+	// Number reports the unique number for this field.
+	Number() FieldNumber
+	// Cardinality reports the cardinality for this field.
+	Cardinality() Cardinality
+	// Kind reports the basic kind for this field.
+	Kind() Kind
+
+	// HasJSONName reports whether this field has an explicitly set JSON name.
+	HasJSONName() bool
+
+	// JSONName reports the name used for JSON serialization.
+	// It is usually the camel-cased form of the field name.
+	JSONName() string
+
+	// HasPresence reports whether the field distinguishes between unpopulated
+	// and default values.
+	HasPresence() bool
+
+	// IsExtension reports whether this is an extension field. If false,
+	// then Parent and ContainingMessage refer to the same message.
+	// Otherwise, ContainingMessage and Parent likely differ.
+	IsExtension() bool
+
+	// HasOptionalKeyword reports whether the "optional" keyword was explicitly
+	// specified in the source .proto file.
+	HasOptionalKeyword() bool
+
+	// IsWeak reports whether this is a weak field, which does not impose a
+	// direct dependency on the target type.
+	// If true, then Message returns a placeholder type.
+	IsWeak() bool
+
+	// IsPacked reports whether repeated primitive numeric kinds should be
+	// serialized using a packed encoding.
+	// If true, then it implies Cardinality is Repeated.
+	IsPacked() bool
+
+	// IsList reports whether this field represents a list,
+	// where the value type for the associated field is a List.
+	// It is equivalent to checking whether Cardinality is Repeated and
+	// that IsMap reports false.
+	IsList() bool
+
+	// IsMap reports whether this field represents a map,
+	// where the value type for the associated field is a Map.
+	// It is equivalent to checking whether Cardinality is Repeated,
+	// that the Kind is MessageKind, and that Message.IsMapEntry reports true.
+	IsMap() bool
+
+	// MapKey returns the field descriptor for the key in the map entry.
+	// It returns nil if IsMap reports false.
+	MapKey() FieldDescriptor
+
+	// MapValue returns the field descriptor for the value in the map entry.
+	// It returns nil if IsMap reports false.
+	MapValue() FieldDescriptor
+
+	// HasDefault reports whether this field has a default value.
+	HasDefault() bool
+
+	// Default returns the default value for scalar fields.
+	// For proto2, it is the default value as specified in the proto file,
+	// or the zero value if unspecified.
+	// For proto3, it is always the zero value of the scalar.
+	// The Value type is determined by the Kind.
+	Default() Value
+
+	// DefaultEnumValue returns the enum value descriptor for the default value
+	// of an enum field, and is nil for any other kind of field.
+	DefaultEnumValue() EnumValueDescriptor
+
+	// ContainingOneof is the containing oneof that this field belongs to,
+	// and is nil if this field is not part of a oneof.
+	ContainingOneof() OneofDescriptor
+
+	// ContainingMessage is the containing message that this field belongs to.
+	// For extension fields, this may not necessarily be the parent message
+	// that the field is declared within.
+	ContainingMessage() MessageDescriptor
+
+	// Enum is the enum descriptor if Kind is EnumKind.
+	// It returns nil for any other Kind.
+	Enum() EnumDescriptor
+
+	// Message is the message descriptor if Kind is
+	// MessageKind or GroupKind. It returns nil for any other Kind.
+	Message() MessageDescriptor
+
+	isFieldDescriptor
+}
+type isFieldDescriptor interface{ ProtoType(FieldDescriptor) }
+
+// FieldDescriptors is a list of field declarations.
+type FieldDescriptors interface {
+	// Len reports the number of fields.
+	Len() int
+	// Get returns the ith FieldDescriptor. It panics if out of bounds.
+	Get(i int) FieldDescriptor
+	// ByName returns the FieldDescriptor for a field named s.
+	// It returns nil if not found.
+	ByName(s Name) FieldDescriptor
+	// ByJSONName returns the FieldDescriptor for a field with s as the JSON name.
+	// It returns nil if not found.
+	ByJSONName(s string) FieldDescriptor
+	// ByNumber returns the FieldDescriptor for a field numbered n.
+	// It returns nil if not found.
+	ByNumber(n FieldNumber) FieldDescriptor
+
+	doNotImplement
+}
+
+// OneofDescriptor describes a oneof field set within a given message and
+// corresponds with the google.protobuf.OneofDescriptorProto message.
+type OneofDescriptor interface {
+	Descriptor
+
+	// IsSynthetic reports whether this is a synthetic oneof created to support
+	// proto3 optional semantics. If true, Fields contains exactly one field
+	// with HasOptionalKeyword specified.
+	IsSynthetic() bool
+
+	// Fields is a list of fields belonging to this oneof.
+	Fields() FieldDescriptors
+
+	isOneofDescriptor
+}
+type isOneofDescriptor interface{ ProtoType(OneofDescriptor) }
+
+// OneofDescriptors is a list of oneof declarations.
+type OneofDescriptors interface {
+	// Len reports the number of oneof fields.
+	Len() int
+	// Get returns the ith OneofDescriptor. It panics if out of bounds.
+	Get(i int) OneofDescriptor
+	// ByName returns the OneofDescriptor for a oneof named s.
+	// It returns nil if not found.
+	ByName(s Name) OneofDescriptor
+
+	doNotImplement
+}
+
+// ExtensionDescriptor is an alias of FieldDescriptor for documentation.
+type ExtensionDescriptor = FieldDescriptor
+
+// ExtensionTypeDescriptor is an ExtensionDescriptor with an associated ExtensionType.
+type ExtensionTypeDescriptor interface {
+	ExtensionDescriptor
+
+	// Type returns the associated ExtensionType.
+	Type() ExtensionType
+
+	// Descriptor returns the plain ExtensionDescriptor without the
+	// associated ExtensionType.
+	Descriptor() ExtensionDescriptor
+}
+
+// ExtensionDescriptors is a list of field declarations.
+type ExtensionDescriptors interface {
+	// Len reports the number of fields.
+	Len() int
+	// Get returns the ith ExtensionDescriptor. It panics if out of bounds.
+	Get(i int) ExtensionDescriptor
+	// ByName returns the ExtensionDescriptor for a field named s.
+	// It returns nil if not found.
+	ByName(s Name) ExtensionDescriptor
+
+	doNotImplement
+}
+
+// ExtensionType encapsulates an ExtensionDescriptor with a concrete
+// Go implementation. The nested field descriptor must be for a extension field.
+//
+// While a normal field is a member of the parent message that it is declared
+// within (see Descriptor.Parent), an extension field is a member of some other
+// target message (see ExtensionDescriptor.Extendee) and may have no
+// relationship with the parent. However, the full name of an extension field is
+// relative to the parent that it is declared within.
+//
+// For example:
+//	syntax = "proto2";
+//	package example;
+//	message FooMessage {
+//		extensions 100 to max;
+//	}
+//	message BarMessage {
+//		extends FooMessage { optional BarMessage bar_field = 100; }
+//	}
+//
+// Field "bar_field" is an extension of FooMessage, but its full name is
+// "example.BarMessage.bar_field" instead of "example.FooMessage.bar_field".
+type ExtensionType interface {
+	// New returns a new value for the field.
+	// For scalars, this returns the default value in native Go form.
+	New() Value
+
+	// Zero returns a new value for the field.
+	// For scalars, this returns the default value in native Go form.
+	// For composite types, this returns an empty, read-only message, list, or map.
+	Zero() Value
+
+	// TypeDescriptor returns the extension type descriptor.
+	TypeDescriptor() ExtensionTypeDescriptor
+
+	// ValueOf wraps the input and returns it as a Value.
+	// ValueOf panics if the input value is invalid or not the appropriate type.
+	//
+	// ValueOf is more extensive than protoreflect.ValueOf for a given field's
+	// value as it has more type information available.
+	ValueOf(interface{}) Value
+
+	// InterfaceOf completely unwraps the Value to the underlying Go type.
+	// InterfaceOf panics if the input is nil or does not represent the
+	// appropriate underlying Go type. For composite types, it panics if the
+	// value is not mutable.
+	//
+	// InterfaceOf is able to unwrap the Value further than Value.Interface
+	// as it has more type information available.
+	InterfaceOf(Value) interface{}
+
+	// IsValidValue reports whether the Value is valid to assign to the field.
+	IsValidValue(Value) bool
+
+	// IsValidInterface reports whether the input is valid to assign to the field.
+	IsValidInterface(interface{}) bool
+}
+
+// EnumDescriptor describes an enum and
+// corresponds with the google.protobuf.EnumDescriptorProto message.
+//
+// Nested declarations:
+// EnumValueDescriptor.
+type EnumDescriptor interface {
+	Descriptor
+
+	// Values is a list of nested enum value declarations.
+	Values() EnumValueDescriptors
+
+	// ReservedNames is a list of reserved enum names.
+	ReservedNames() Names
+	// ReservedRanges is a list of reserved ranges of enum numbers.
+	ReservedRanges() EnumRanges
+
+	isEnumDescriptor
+}
+type isEnumDescriptor interface{ ProtoType(EnumDescriptor) }
+
+// EnumType encapsulates an EnumDescriptor with a concrete Go implementation.
+type EnumType interface {
+	// New returns an instance of this enum type with its value set to n.
+	New(n EnumNumber) Enum
+
+	// Descriptor returns the enum descriptor.
+	//
+	// Invariant: t.Descriptor() == t.New(0).Descriptor()
+	Descriptor() EnumDescriptor
+}
+
+// EnumDescriptors is a list of enum declarations.
+type EnumDescriptors interface {
+	// Len reports the number of enum types.
+	Len() int
+	// Get returns the ith EnumDescriptor. It panics if out of bounds.
+	Get(i int) EnumDescriptor
+	// ByName returns the EnumDescriptor for an enum named s.
+	// It returns nil if not found.
+	ByName(s Name) EnumDescriptor
+
+	doNotImplement
+}
+
+// EnumValueDescriptor describes an enum value and
+// corresponds with the google.protobuf.EnumValueDescriptorProto message.
+//
+// All other proto declarations are in the namespace of the parent.
+// However, enum values do not follow this rule and are within the namespace
+// of the parent's parent (i.e., they are a sibling of the containing enum).
+// Thus, a value named "FOO_VALUE" declared within an enum uniquely identified
+// as "proto.package.MyEnum" has a full name of "proto.package.FOO_VALUE".
+type EnumValueDescriptor interface {
+	Descriptor
+
+	// Number returns the enum value as an integer.
+	Number() EnumNumber
+
+	isEnumValueDescriptor
+}
+type isEnumValueDescriptor interface{ ProtoType(EnumValueDescriptor) }
+
+// EnumValueDescriptors is a list of enum value declarations.
+type EnumValueDescriptors interface {
+	// Len reports the number of enum values.
+	Len() int
+	// Get returns the ith EnumValueDescriptor. It panics if out of bounds.
+	Get(i int) EnumValueDescriptor
+	// ByName returns the EnumValueDescriptor for the enum value named s.
+	// It returns nil if not found.
+	ByName(s Name) EnumValueDescriptor
+	// ByNumber returns the EnumValueDescriptor for the enum value numbered n.
+	// If multiple have the same number, the first one defined is returned
+	// It returns nil if not found.
+	ByNumber(n EnumNumber) EnumValueDescriptor
+
+	doNotImplement
+}
+
+// ServiceDescriptor describes a service and
+// corresponds with the google.protobuf.ServiceDescriptorProto message.
+//
+// Nested declarations: MethodDescriptor.
+type ServiceDescriptor interface {
+	Descriptor
+
+	// Methods is a list of nested message declarations.
+	Methods() MethodDescriptors
+
+	isServiceDescriptor
+}
+type isServiceDescriptor interface{ ProtoType(ServiceDescriptor) }
+
+// ServiceDescriptors is a list of service declarations.
+type ServiceDescriptors interface {
+	// Len reports the number of services.
+	Len() int
+	// Get returns the ith ServiceDescriptor. It panics if out of bounds.
+	Get(i int) ServiceDescriptor
+	// ByName returns the ServiceDescriptor for a service named s.
+	// It returns nil if not found.
+	ByName(s Name) ServiceDescriptor
+
+	doNotImplement
+}
+
+// MethodDescriptor describes a method and
+// corresponds with the google.protobuf.MethodDescriptorProto message.
+type MethodDescriptor interface {
+	Descriptor
+
+	// Input is the input message descriptor.
+	Input() MessageDescriptor
+	// Output is the output message descriptor.
+	Output() MessageDescriptor
+	// IsStreamingClient reports whether the client streams multiple messages.
+	IsStreamingClient() bool
+	// IsStreamingServer reports whether the server streams multiple messages.
+	IsStreamingServer() bool
+
+	isMethodDescriptor
+}
+type isMethodDescriptor interface{ ProtoType(MethodDescriptor) }
+
+// MethodDescriptors is a list of method declarations.
+type MethodDescriptors interface {
+	// Len reports the number of methods.
+	Len() int
+	// Get returns the ith MethodDescriptor. It panics if out of bounds.
+	Get(i int) MethodDescriptor
+	// ByName returns the MethodDescriptor for a service method named s.
+	// It returns nil if not found.
+	ByName(s Name) MethodDescriptor
+
+	doNotImplement
+}
diff --git a/vendor/google.golang.org/protobuf/reflect/protoreflect/value.go b/vendor/google.golang.org/protobuf/reflect/protoreflect/value.go
new file mode 100644
index 000000000..f31981077
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/reflect/protoreflect/value.go
@@ -0,0 +1,285 @@
+// 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 protoreflect
+
+import "google.golang.org/protobuf/encoding/protowire"
+
+// Enum is a reflection interface for a concrete enum value,
+// which provides type information and a getter for the enum number.
+// Enum does not provide a mutable API since enums are commonly backed by
+// Go constants, which are not addressable.
+type Enum interface {
+	// Descriptor returns enum descriptor, which contains only the protobuf
+	// type information for the enum.
+	Descriptor() EnumDescriptor
+
+	// Type returns the enum type, which encapsulates both Go and protobuf
+	// type information. If the Go type information is not needed,
+	// it is recommended that the enum descriptor be used instead.
+	Type() EnumType
+
+	// Number returns the enum value as an integer.
+	Number() EnumNumber
+}
+
+// Message is a reflective interface for a concrete message value,
+// encapsulating both type and value information for the message.
+//
+// Accessor/mutators for individual fields are keyed by FieldDescriptor.
+// For non-extension fields, the descriptor must exactly match the
+// field known by the parent message.
+// For extension fields, the descriptor must implement ExtensionTypeDescriptor,
+// extend the parent message (i.e., have the same message FullName), and
+// be within the parent's extension range.
+//
+// Each field Value can be a scalar or a composite type (Message, List, or Map).
+// See Value for the Go types associated with a FieldDescriptor.
+// Providing a Value that is invalid or of an incorrect type panics.
+type Message interface {
+	// Descriptor returns message descriptor, which contains only the protobuf
+	// type information for the message.
+	Descriptor() MessageDescriptor
+
+	// Type returns the message type, which encapsulates both Go and protobuf
+	// type information. If the Go type information is not needed,
+	// it is recommended that the message descriptor be used instead.
+	Type() MessageType
+
+	// New returns a newly allocated and mutable empty message.
+	New() Message
+
+	// Interface unwraps the message reflection interface and
+	// returns the underlying ProtoMessage interface.
+	Interface() ProtoMessage
+
+	// Range iterates over every populated field in an undefined order,
+	// calling f for each field descriptor and value encountered.
+	// Range returns immediately if f returns false.
+	// While iterating, mutating operations may only be performed
+	// on the current field descriptor.
+	Range(f func(FieldDescriptor, Value) bool)
+
+	// Has reports whether a field is populated.
+	//
+	// Some fields have the property of nullability where it is possible to
+	// distinguish between the default value of a field and whether the field
+	// was explicitly populated with the default value. Singular message fields,
+	// member fields of a oneof, and proto2 scalar fields are nullable. Such
+	// fields are populated only if explicitly set.
+	//
+	// In other cases (aside from the nullable cases above),
+	// a proto3 scalar field is populated if it contains a non-zero value, and
+	// a repeated field is populated if it is non-empty.
+	Has(FieldDescriptor) bool
+
+	// Clear clears the field such that a subsequent Has call reports false.
+	//
+	// Clearing an extension field clears both the extension type and value
+	// associated with the given field number.
+	//
+	// Clear is a mutating operation and unsafe for concurrent use.
+	Clear(FieldDescriptor)
+
+	// Get retrieves the value for a field.
+	//
+	// For unpopulated scalars, it returns the default value, where
+	// the default value of a bytes scalar is guaranteed to be a copy.
+	// For unpopulated composite types, it returns an empty, read-only view
+	// of the value; to obtain a mutable reference, use Mutable.
+	Get(FieldDescriptor) Value
+
+	// Set stores the value for a field.
+	//
+	// For a field belonging to a oneof, it implicitly clears any other field
+	// that may be currently set within the same oneof.
+	// For extension fields, it implicitly stores the provided ExtensionType.
+	// When setting a composite type, it is unspecified whether the stored value
+	// aliases the source's memory in any way. If the composite value is an
+	// empty, read-only value, then it panics.
+	//
+	// Set is a mutating operation and unsafe for concurrent use.
+	Set(FieldDescriptor, Value)
+
+	// Mutable returns a mutable reference to a composite type.
+	//
+	// If the field is unpopulated, it may allocate a composite value.
+	// For a field belonging to a oneof, it implicitly clears any other field
+	// that may be currently set within the same oneof.
+	// For extension fields, it implicitly stores the provided ExtensionType
+	// if not already stored.
+	// It panics if the field does not contain a composite type.
+	//
+	// Mutable is a mutating operation and unsafe for concurrent use.
+	Mutable(FieldDescriptor) Value
+
+	// NewField returns a new value that is assignable to the field
+	// for the given descriptor. For scalars, this returns the default value.
+	// For lists, maps, and messages, this returns a new, empty, mutable value.
+	NewField(FieldDescriptor) Value
+
+	// WhichOneof reports which field within the oneof is populated,
+	// returning nil if none are populated.
+	// It panics if the oneof descriptor does not belong to this message.
+	WhichOneof(OneofDescriptor) FieldDescriptor
+
+	// GetUnknown retrieves the entire list of unknown fields.
+	// The caller may only mutate the contents of the RawFields
+	// if the mutated bytes are stored back into the message with SetUnknown.
+	GetUnknown() RawFields
+
+	// SetUnknown stores an entire list of unknown fields.
+	// The raw fields must be syntactically valid according to the wire format.
+	// An implementation may panic if this is not the case.
+	// Once stored, the caller must not mutate the content of the RawFields.
+	// An empty RawFields may be passed to clear the fields.
+	//
+	// SetUnknown is a mutating operation and unsafe for concurrent use.
+	SetUnknown(RawFields)
+
+	// IsValid reports whether the message is valid.
+	//
+	// An invalid message is an empty, read-only value.
+	//
+	// An invalid message often corresponds to a nil pointer of the concrete
+	// message type, but the details are implementation dependent.
+	// Validity is not part of the protobuf data model, and may not
+	// be preserved in marshaling or other operations.
+	IsValid() bool
+
+	// ProtoMethods returns optional fast-path implementions of various operations.
+	// This method may return nil.
+	//
+	// The returned methods type is identical to
+	// "google.golang.org/protobuf/runtime/protoiface".Methods.
+	// Consult the protoiface package documentation for details.
+	ProtoMethods() *methods
+}
+
+// RawFields is the raw bytes for an ordered sequence of fields.
+// Each field contains both the tag (representing field number and wire type),
+// and also the wire data itself.
+type RawFields []byte
+
+// IsValid reports whether b is syntactically correct wire format.
+func (b RawFields) IsValid() bool {
+	for len(b) > 0 {
+		_, _, n := protowire.ConsumeField(b)
+		if n < 0 {
+			return false
+		}
+		b = b[n:]
+	}
+	return true
+}
+
+// List is a zero-indexed, ordered list.
+// The element Value type is determined by FieldDescriptor.Kind.
+// Providing a Value that is invalid or of an incorrect type panics.
+type List interface {
+	// Len reports the number of entries in the List.
+	// Get, Set, and Truncate panic with out of bound indexes.
+	Len() int
+
+	// Get retrieves the value at the given index.
+	// It never returns an invalid value.
+	Get(int) Value
+
+	// Set stores a value for the given index.
+	// When setting a composite type, it is unspecified whether the set
+	// value aliases the source's memory in any way.
+	//
+	// Set is a mutating operation and unsafe for concurrent use.
+	Set(int, Value)
+
+	// Append appends the provided value to the end of the list.
+	// When appending a composite type, it is unspecified whether the appended
+	// value aliases the source's memory in any way.
+	//
+	// Append is a mutating operation and unsafe for concurrent use.
+	Append(Value)
+
+	// AppendMutable appends a new, empty, mutable message value to the end
+	// of the list and returns it.
+	// It panics if the list does not contain a message type.
+	AppendMutable() Value
+
+	// Truncate truncates the list to a smaller length.
+	//
+	// Truncate is a mutating operation and unsafe for concurrent use.
+	Truncate(int)
+
+	// NewElement returns a new value for a list element.
+	// For enums, this returns the first enum value.
+	// For other scalars, this returns the zero value.
+	// For messages, this returns a new, empty, mutable value.
+	NewElement() Value
+
+	// IsValid reports whether the list is valid.
+	//
+	// An invalid list is an empty, read-only value.
+	//
+	// Validity is not part of the protobuf data model, and may not
+	// be preserved in marshaling or other operations.
+	IsValid() bool
+}
+
+// Map is an unordered, associative map.
+// The entry MapKey type is determined by FieldDescriptor.MapKey.Kind.
+// The entry Value type is determined by FieldDescriptor.MapValue.Kind.
+// Providing a MapKey or Value that is invalid or of an incorrect type panics.
+type Map interface {
+	// Len reports the number of elements in the map.
+	Len() int
+
+	// Range iterates over every map entry in an undefined order,
+	// calling f for each key and value encountered.
+	// Range calls f Len times unless f returns false, which stops iteration.
+	// While iterating, mutating operations may only be performed
+	// on the current map key.
+	Range(f func(MapKey, Value) bool)
+
+	// Has reports whether an entry with the given key is in the map.
+	Has(MapKey) bool
+
+	// Clear clears the entry associated with they given key.
+	// The operation does nothing if there is no entry associated with the key.
+	//
+	// Clear is a mutating operation and unsafe for concurrent use.
+	Clear(MapKey)
+
+	// Get retrieves the value for an entry with the given key.
+	// It returns an invalid value for non-existent entries.
+	Get(MapKey) Value
+
+	// Set stores the value for an entry with the given key.
+	// It panics when given a key or value that is invalid or the wrong type.
+	// When setting a composite type, it is unspecified whether the set
+	// value aliases the source's memory in any way.
+	//
+	// Set is a mutating operation and unsafe for concurrent use.
+	Set(MapKey, Value)
+
+	// Mutable retrieves a mutable reference to the entry for the given key.
+	// If no entry exists for the key, it creates a new, empty, mutable value
+	// and stores it as the entry for the key.
+	// It panics if the map value is not a message.
+	Mutable(MapKey) Value
+
+	// NewValue returns a new value assignable as a map value.
+	// For enums, this returns the first enum value.
+	// For other scalars, this returns the zero value.
+	// For messages, this returns a new, empty, mutable value.
+	NewValue() Value
+
+	// IsValid reports whether the map is valid.
+	//
+	// An invalid map is an empty, read-only value.
+	//
+	// An invalid message often corresponds to a nil Go map value,
+	// but the details are implementation dependent.
+	// Validity is not part of the protobuf data model, and may not
+	// be preserved in marshaling or other operations.
+	IsValid() bool
+}
diff --git a/vendor/google.golang.org/protobuf/reflect/protoreflect/value_pure.go b/vendor/google.golang.org/protobuf/reflect/protoreflect/value_pure.go
new file mode 100644
index 000000000..918e685e1
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/reflect/protoreflect/value_pure.go
@@ -0,0 +1,59 @@
+// 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.
+
+// +build purego appengine
+
+package protoreflect
+
+import "google.golang.org/protobuf/internal/pragma"
+
+type valueType int
+
+const (
+	nilType valueType = iota
+	boolType
+	int32Type
+	int64Type
+	uint32Type
+	uint64Type
+	float32Type
+	float64Type
+	stringType
+	bytesType
+	enumType
+	ifaceType
+)
+
+// value is a union where only one type can be represented at a time.
+// This uses a distinct field for each type. This is type safe in Go, but
+// occupies more memory than necessary (72B).
+type value struct {
+	pragma.DoNotCompare // 0B
+
+	typ   valueType   // 8B
+	num   uint64      // 8B
+	str   string      // 16B
+	bin   []byte      // 24B
+	iface interface{} // 16B
+}
+
+func valueOfString(v string) Value {
+	return Value{typ: stringType, str: v}
+}
+func valueOfBytes(v []byte) Value {
+	return Value{typ: bytesType, bin: v}
+}
+func valueOfIface(v interface{}) Value {
+	return Value{typ: ifaceType, iface: v}
+}
+
+func (v Value) getString() string {
+	return v.str
+}
+func (v Value) getBytes() []byte {
+	return v.bin
+}
+func (v Value) getIface() interface{} {
+	return v.iface
+}
diff --git a/vendor/google.golang.org/protobuf/reflect/protoreflect/value_test.go b/vendor/google.golang.org/protobuf/reflect/protoreflect/value_test.go
new file mode 100644
index 000000000..c6bbb5841
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/reflect/protoreflect/value_test.go
@@ -0,0 +1,147 @@
+// 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 protoreflect
+
+import (
+	"bytes"
+	"math"
+	"reflect"
+	"testing"
+)
+
+func TestValue(t *testing.T) {
+	fakeMessage := new(struct{ Message })
+	fakeList := new(struct{ List })
+	fakeMap := new(struct{ Map })
+
+	tests := []struct {
+		in   Value
+		want interface{}
+	}{
+		{in: Value{}},
+		{in: ValueOf(nil)},
+		{in: ValueOf(true), want: true},
+		{in: ValueOf(int32(math.MaxInt32)), want: int32(math.MaxInt32)},
+		{in: ValueOf(int64(math.MaxInt64)), want: int64(math.MaxInt64)},
+		{in: ValueOf(uint32(math.MaxUint32)), want: uint32(math.MaxUint32)},
+		{in: ValueOf(uint64(math.MaxUint64)), want: uint64(math.MaxUint64)},
+		{in: ValueOf(float32(math.MaxFloat32)), want: float32(math.MaxFloat32)},
+		{in: ValueOf(float64(math.MaxFloat64)), want: float64(math.MaxFloat64)},
+		{in: ValueOf(string("hello")), want: string("hello")},
+		{in: ValueOf([]byte("hello")), want: []byte("hello")},
+		{in: ValueOf(fakeMessage), want: fakeMessage},
+		{in: ValueOf(fakeList), want: fakeList},
+		{in: ValueOf(fakeMap), want: fakeMap},
+	}
+
+	for _, tt := range tests {
+		got := tt.in.Interface()
+		if !reflect.DeepEqual(got, tt.want) {
+			t.Errorf("Value(%v).Interface() = %v, want %v", tt.in, got, tt.want)
+		}
+
+		if got := tt.in.IsValid(); got != (tt.want != nil) {
+			t.Errorf("Value(%v).IsValid() = %v, want %v", tt.in, got, tt.want != nil)
+		}
+		switch want := tt.want.(type) {
+		case int32:
+			if got := tt.in.Int(); got != int64(want) {
+				t.Errorf("Value(%v).Int() = %v, want %v", tt.in, got, tt.want)
+			}
+		case int64:
+			if got := tt.in.Int(); got != int64(want) {
+				t.Errorf("Value(%v).Int() = %v, want %v", tt.in, got, tt.want)
+			}
+		case uint32:
+			if got := tt.in.Uint(); got != uint64(want) {
+				t.Errorf("Value(%v).Uint() = %v, want %v", tt.in, got, tt.want)
+			}
+		case uint64:
+			if got := tt.in.Uint(); got != uint64(want) {
+				t.Errorf("Value(%v).Uint() = %v, want %v", tt.in, got, tt.want)
+			}
+		case float32:
+			if got := tt.in.Float(); got != float64(want) {
+				t.Errorf("Value(%v).Float() = %v, want %v", tt.in, got, tt.want)
+			}
+		case float64:
+			if got := tt.in.Float(); got != float64(want) {
+				t.Errorf("Value(%v).Float() = %v, want %v", tt.in, got, tt.want)
+			}
+		case string:
+			if got := tt.in.String(); got != string(want) {
+				t.Errorf("Value(%v).String() = %v, want %v", tt.in, got, tt.want)
+			}
+		case []byte:
+			if got := tt.in.Bytes(); !bytes.Equal(got, want) {
+				t.Errorf("Value(%v).Bytes() = %v, want %v", tt.in, got, tt.want)
+			}
+		case EnumNumber:
+			if got := tt.in.Enum(); got != want {
+				t.Errorf("Value(%v).Enum() = %v, want %v", tt.in, got, tt.want)
+			}
+		case Message:
+			if got := tt.in.Message(); got != want {
+				t.Errorf("Value(%v).Message() = %v, want %v", tt.in, got, tt.want)
+			}
+		case List:
+			if got := tt.in.List(); got != want {
+				t.Errorf("Value(%v).List() = %v, want %v", tt.in, got, tt.want)
+			}
+		case Map:
+			if got := tt.in.Map(); got != want {
+				t.Errorf("Value(%v).Map() = %v, want %v", tt.in, got, tt.want)
+			}
+		}
+	}
+}
+
+func BenchmarkValue(b *testing.B) {
+	const testdata = "The quick brown fox jumped over the lazy dog."
+	var sink1 string
+	var sink2 Value
+	var sink3 interface{}
+
+	// Baseline measures the time to store a string into a native variable.
+	b.Run("Baseline", func(b *testing.B) {
+		b.ReportAllocs()
+		for i := 0; i < b.N; i++ {
+			sink1 = testdata[:len(testdata)%(i+1)]
+		}
+	})
+
+	// Inline measures the time to store a string into a Value,
+	// assuming that the compiler could inline the ValueOf function call.
+	b.Run("Inline", func(b *testing.B) {
+		b.ReportAllocs()
+		for i := 0; i < b.N; i++ {
+			sink2 = valueOfString(testdata[:len(testdata)%(i+1)])
+		}
+	})
+
+	// Value measures the time to store a string into a Value using the general
+	// ValueOf function call. This should be identical to Inline.
+	//
+	// NOTE: As of Go1.11, this is not as efficient as Inline due to the lack
+	// of some compiler optimizations:
+	//	https://golang.org/issue/22310
+	//	https://golang.org/issue/25189
+	b.Run("Value", func(b *testing.B) {
+		b.ReportAllocs()
+		for i := 0; i < b.N; i++ {
+			sink2 = ValueOf(string(testdata[:len(testdata)%(i+1)]))
+		}
+	})
+
+	// Interface measures the time to store a string into an interface.
+	b.Run("Interface", func(b *testing.B) {
+		b.ReportAllocs()
+		for i := 0; i < b.N; i++ {
+			sink3 = string(testdata[:len(testdata)%(i+1)])
+		}
+	})
+
+	_, _, _ = sink1, sink2, sink3
+}
diff --git a/vendor/google.golang.org/protobuf/reflect/protoreflect/value_union.go b/vendor/google.golang.org/protobuf/reflect/protoreflect/value_union.go
new file mode 100644
index 000000000..f334f71bc
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/reflect/protoreflect/value_union.go
@@ -0,0 +1,409 @@
+// 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 protoreflect
+
+import (
+	"fmt"
+	"math"
+)
+
+// Value is a union where only one Go type may be set at a time.
+// The Value is used to represent all possible values a field may take.
+// The following shows which Go type is used to represent each proto Kind:
+//
+//	╔════════════╤═════════════════════════════════════╗
+//	║ Go type    │ Protobuf kind                       ║
+//	╠════════════╪═════════════════════════════════════╣
+//	║ bool       │ BoolKind                            ║
+//	║ int32      │ Int32Kind, Sint32Kind, Sfixed32Kind ║
+//	║ int64      │ Int64Kind, Sint64Kind, Sfixed64Kind ║
+//	║ uint32     │ Uint32Kind, Fixed32Kind             ║
+//	║ uint64     │ Uint64Kind, Fixed64Kind             ║
+//	║ float32    │ FloatKind                           ║
+//	║ float64    │ DoubleKind                          ║
+//	║ string     │ StringKind                          ║
+//	║ []byte     │ BytesKind                           ║
+//	║ EnumNumber │ EnumKind                            ║
+//	║ Message    │ MessageKind, GroupKind              ║
+//	╚════════════╧═════════════════════════════════════╝
+//
+// Multiple protobuf Kinds may be represented by a single Go type if the type
+// can losslessly represent the information for the proto kind. For example,
+// Int64Kind, Sint64Kind, and Sfixed64Kind are all represented by int64,
+// but use different integer encoding methods.
+//
+// The List or Map types are used if the field cardinality is repeated.
+// A field is a List if FieldDescriptor.IsList reports true.
+// A field is a Map if FieldDescriptor.IsMap reports true.
+//
+// Converting to/from a Value and a concrete Go value panics on type mismatch.
+// For example, ValueOf("hello").Int() panics because this attempts to
+// retrieve an int64 from a string.
+type Value value
+
+// The protoreflect API uses a custom Value union type instead of interface{}
+// to keep the future open for performance optimizations. Using an interface{}
+// always incurs an allocation for primitives (e.g., int64) since it needs to
+// be boxed on the heap (as interfaces can only contain pointers natively).
+// Instead, we represent the Value union as a flat struct that internally keeps
+// track of which type is set. Using unsafe, the Value union can be reduced
+// down to 24B, which is identical in size to a slice.
+//
+// The latest compiler (Go1.11) currently suffers from some limitations:
+//	• With inlining, the compiler should be able to statically prove that
+//	only one of these switch cases are taken and inline one specific case.
+//	See https://golang.org/issue/22310.
+
+// ValueOf returns a Value initialized with the concrete value stored in v.
+// This panics if the type does not match one of the allowed types in the
+// Value union.
+func ValueOf(v interface{}) Value {
+	switch v := v.(type) {
+	case nil:
+		return Value{}
+	case bool:
+		return ValueOfBool(v)
+	case int32:
+		return ValueOfInt32(v)
+	case int64:
+		return ValueOfInt64(v)
+	case uint32:
+		return ValueOfUint32(v)
+	case uint64:
+		return ValueOfUint64(v)
+	case float32:
+		return ValueOfFloat32(v)
+	case float64:
+		return ValueOfFloat64(v)
+	case string:
+		return ValueOfString(v)
+	case []byte:
+		return ValueOfBytes(v)
+	case EnumNumber:
+		return ValueOfEnum(v)
+	case Message, List, Map:
+		return valueOfIface(v)
+	default:
+		panic(fmt.Sprintf("invalid type: %T", v))
+	}
+}
+
+// ValueOfBool returns a new boolean value.
+func ValueOfBool(v bool) Value {
+	if v {
+		return Value{typ: boolType, num: 1}
+	} else {
+		return Value{typ: boolType, num: 0}
+	}
+}
+
+// ValueOfInt32 returns a new int32 value.
+func ValueOfInt32(v int32) Value {
+	return Value{typ: int32Type, num: uint64(v)}
+}
+
+// ValueOfInt64 returns a new int64 value.
+func ValueOfInt64(v int64) Value {
+	return Value{typ: int64Type, num: uint64(v)}
+}
+
+// ValueOfUint32 returns a new uint32 value.
+func ValueOfUint32(v uint32) Value {
+	return Value{typ: uint32Type, num: uint64(v)}
+}
+
+// ValueOfUint64 returns a new uint64 value.
+func ValueOfUint64(v uint64) Value {
+	return Value{typ: uint64Type, num: v}
+}
+
+// ValueOfFloat32 returns a new float32 value.
+func ValueOfFloat32(v float32) Value {
+	return Value{typ: float32Type, num: uint64(math.Float64bits(float64(v)))}
+}
+
+// ValueOfFloat64 returns a new float64 value.
+func ValueOfFloat64(v float64) Value {
+	return Value{typ: float64Type, num: uint64(math.Float64bits(float64(v)))}
+}
+
+// ValueOfString returns a new string value.
+func ValueOfString(v string) Value {
+	return valueOfString(v)
+}
+
+// ValueOfBytes returns a new bytes value.
+func ValueOfBytes(v []byte) Value {
+	return valueOfBytes(v[:len(v):len(v)])
+}
+
+// ValueOfEnum returns a new enum value.
+func ValueOfEnum(v EnumNumber) Value {
+	return Value{typ: enumType, num: uint64(v)}
+}
+
+// ValueOfMessage returns a new Message value.
+func ValueOfMessage(v Message) Value {
+	return valueOfIface(v)
+}
+
+// ValueOfList returns a new List value.
+func ValueOfList(v List) Value {
+	return valueOfIface(v)
+}
+
+// ValueOfMap returns a new Map value.
+func ValueOfMap(v Map) Value {
+	return valueOfIface(v)
+}
+
+// IsValid reports whether v is populated with a value.
+func (v Value) IsValid() bool {
+	return v.typ != nilType
+}
+
+// Interface returns v as an interface{}.
+//
+// Invariant: v == ValueOf(v).Interface()
+func (v Value) Interface() interface{} {
+	switch v.typ {
+	case nilType:
+		return nil
+	case boolType:
+		return v.Bool()
+	case int32Type:
+		return int32(v.Int())
+	case int64Type:
+		return int64(v.Int())
+	case uint32Type:
+		return uint32(v.Uint())
+	case uint64Type:
+		return uint64(v.Uint())
+	case float32Type:
+		return float32(v.Float())
+	case float64Type:
+		return float64(v.Float())
+	case stringType:
+		return v.String()
+	case bytesType:
+		return v.Bytes()
+	case enumType:
+		return v.Enum()
+	default:
+		return v.getIface()
+	}
+}
+
+func (v Value) typeName() string {
+	switch v.typ {
+	case nilType:
+		return "nil"
+	case boolType:
+		return "bool"
+	case int32Type:
+		return "int32"
+	case int64Type:
+		return "int64"
+	case uint32Type:
+		return "uint32"
+	case uint64Type:
+		return "uint64"
+	case float32Type:
+		return "float32"
+	case float64Type:
+		return "float64"
+	case stringType:
+		return "string"
+	case bytesType:
+		return "bytes"
+	case enumType:
+		return "enum"
+	default:
+		switch v := v.getIface().(type) {
+		case Message:
+			return "message"
+		case List:
+			return "list"
+		case Map:
+			return "map"
+		default:
+			return fmt.Sprintf("<unknown: %T>", v)
+		}
+	}
+}
+
+func (v Value) panicMessage(what string) string {
+	return fmt.Sprintf("type mismatch: cannot convert %v to %s", v.typeName(), what)
+}
+
+// Bool returns v as a bool and panics if the type is not a bool.
+func (v Value) Bool() bool {
+	switch v.typ {
+	case boolType:
+		return v.num > 0
+	default:
+		panic(v.panicMessage("bool"))
+	}
+}
+
+// Int returns v as a int64 and panics if the type is not a int32 or int64.
+func (v Value) Int() int64 {
+	switch v.typ {
+	case int32Type, int64Type:
+		return int64(v.num)
+	default:
+		panic(v.panicMessage("int"))
+	}
+}
+
+// Uint returns v as a uint64 and panics if the type is not a uint32 or uint64.
+func (v Value) Uint() uint64 {
+	switch v.typ {
+	case uint32Type, uint64Type:
+		return uint64(v.num)
+	default:
+		panic(v.panicMessage("uint"))
+	}
+}
+
+// Float returns v as a float64 and panics if the type is not a float32 or float64.
+func (v Value) Float() float64 {
+	switch v.typ {
+	case float32Type, float64Type:
+		return math.Float64frombits(uint64(v.num))
+	default:
+		panic(v.panicMessage("float"))
+	}
+}
+
+// String returns v as a string. Since this method implements fmt.Stringer,
+// this returns the formatted string value for any non-string type.
+func (v Value) String() string {
+	switch v.typ {
+	case stringType:
+		return v.getString()
+	default:
+		return fmt.Sprint(v.Interface())
+	}
+}
+
+// Bytes returns v as a []byte and panics if the type is not a []byte.
+func (v Value) Bytes() []byte {
+	switch v.typ {
+	case bytesType:
+		return v.getBytes()
+	default:
+		panic(v.panicMessage("bytes"))
+	}
+}
+
+// Enum returns v as a EnumNumber and panics if the type is not a EnumNumber.
+func (v Value) Enum() EnumNumber {
+	switch v.typ {
+	case enumType:
+		return EnumNumber(v.num)
+	default:
+		panic(v.panicMessage("enum"))
+	}
+}
+
+// Message returns v as a Message and panics if the type is not a Message.
+func (v Value) Message() Message {
+	switch vi := v.getIface().(type) {
+	case Message:
+		return vi
+	default:
+		panic(v.panicMessage("message"))
+	}
+}
+
+// List returns v as a List and panics if the type is not a List.
+func (v Value) List() List {
+	switch vi := v.getIface().(type) {
+	case List:
+		return vi
+	default:
+		panic(v.panicMessage("list"))
+	}
+}
+
+// Map returns v as a Map and panics if the type is not a Map.
+func (v Value) Map() Map {
+	switch vi := v.getIface().(type) {
+	case Map:
+		return vi
+	default:
+		panic(v.panicMessage("map"))
+	}
+}
+
+// MapKey returns v as a MapKey and panics for invalid MapKey types.
+func (v Value) MapKey() MapKey {
+	switch v.typ {
+	case boolType, int32Type, int64Type, uint32Type, uint64Type, stringType:
+		return MapKey(v)
+	default:
+		panic(v.panicMessage("map key"))
+	}
+}
+
+// MapKey is used to index maps, where the Go type of the MapKey must match
+// the specified key Kind (see MessageDescriptor.IsMapEntry).
+// The following shows what Go type is used to represent each proto Kind:
+//
+//	╔═════════╤═════════════════════════════════════╗
+//	║ Go type │ Protobuf kind                       ║
+//	╠═════════╪═════════════════════════════════════╣
+//	║ bool    │ BoolKind                            ║
+//	║ int32   │ Int32Kind, Sint32Kind, Sfixed32Kind ║
+//	║ int64   │ Int64Kind, Sint64Kind, Sfixed64Kind ║
+//	║ uint32  │ Uint32Kind, Fixed32Kind             ║
+//	║ uint64  │ Uint64Kind, Fixed64Kind             ║
+//	║ string  │ StringKind                          ║
+//	╚═════════╧═════════════════════════════════════╝
+//
+// A MapKey is constructed and accessed through a Value:
+//	k := ValueOf("hash").MapKey() // convert string to MapKey
+//	s := k.String()               // convert MapKey to string
+//
+// The MapKey is a strict subset of valid types used in Value;
+// converting a Value to a MapKey with an invalid type panics.
+type MapKey value
+
+// IsValid reports whether k is populated with a value.
+func (k MapKey) IsValid() bool {
+	return Value(k).IsValid()
+}
+
+// Interface returns k as an interface{}.
+func (k MapKey) Interface() interface{} {
+	return Value(k).Interface()
+}
+
+// Bool returns k as a bool and panics if the type is not a bool.
+func (k MapKey) Bool() bool {
+	return Value(k).Bool()
+}
+
+// Int returns k as a int64 and panics if the type is not a int32 or int64.
+func (k MapKey) Int() int64 {
+	return Value(k).Int()
+}
+
+// Uint returns k as a uint64 and panics if the type is not a uint32 or uint64.
+func (k MapKey) Uint() uint64 {
+	return Value(k).Uint()
+}
+
+// String returns k as a string. Since this method implements fmt.Stringer,
+// this returns the formatted string value for any non-string type.
+func (k MapKey) String() string {
+	return Value(k).String()
+}
+
+// Value returns k as a Value.
+func (k MapKey) Value() Value {
+	return Value(k)
+}
diff --git a/vendor/google.golang.org/protobuf/reflect/protoreflect/value_unsafe.go b/vendor/google.golang.org/protobuf/reflect/protoreflect/value_unsafe.go
new file mode 100644
index 000000000..c45debdca
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/reflect/protoreflect/value_unsafe.go
@@ -0,0 +1,98 @@
+// 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.
+
+// +build !purego,!appengine
+
+package protoreflect
+
+import (
+	"unsafe"
+
+	"google.golang.org/protobuf/internal/pragma"
+)
+
+type (
+	stringHeader struct {
+		Data unsafe.Pointer
+		Len  int
+	}
+	sliceHeader struct {
+		Data unsafe.Pointer
+		Len  int
+		Cap  int
+	}
+	ifaceHeader struct {
+		Type unsafe.Pointer
+		Data unsafe.Pointer
+	}
+)
+
+var (
+	nilType     = typeOf(nil)
+	boolType    = typeOf(*new(bool))
+	int32Type   = typeOf(*new(int32))
+	int64Type   = typeOf(*new(int64))
+	uint32Type  = typeOf(*new(uint32))
+	uint64Type  = typeOf(*new(uint64))
+	float32Type = typeOf(*new(float32))
+	float64Type = typeOf(*new(float64))
+	stringType  = typeOf(*new(string))
+	bytesType   = typeOf(*new([]byte))
+	enumType    = typeOf(*new(EnumNumber))
+)
+
+// typeOf returns a pointer to the Go type information.
+// The pointer is comparable and equal if and only if the types are identical.
+func typeOf(t interface{}) unsafe.Pointer {
+	return (*ifaceHeader)(unsafe.Pointer(&t)).Type
+}
+
+// value is a union where only one type can be represented at a time.
+// The struct is 24B large on 64-bit systems and requires the minimum storage
+// necessary to represent each possible type.
+//
+// The Go GC needs to be able to scan variables containing pointers.
+// As such, pointers and non-pointers cannot be intermixed.
+type value struct {
+	pragma.DoNotCompare // 0B
+
+	// typ stores the type of the value as a pointer to the Go type.
+	typ unsafe.Pointer // 8B
+
+	// ptr stores the data pointer for a String, Bytes, or interface value.
+	ptr unsafe.Pointer // 8B
+
+	// num stores a Bool, Int32, Int64, Uint32, Uint64, Float32, Float64, or
+	// Enum value as a raw uint64.
+	//
+	// It is also used to store the length of a String or Bytes value;
+	// the capacity is ignored.
+	num uint64 // 8B
+}
+
+func valueOfString(v string) Value {
+	p := (*stringHeader)(unsafe.Pointer(&v))
+	return Value{typ: stringType, ptr: p.Data, num: uint64(len(v))}
+}
+func valueOfBytes(v []byte) Value {
+	p := (*sliceHeader)(unsafe.Pointer(&v))
+	return Value{typ: bytesType, ptr: p.Data, num: uint64(len(v))}
+}
+func valueOfIface(v interface{}) Value {
+	p := (*ifaceHeader)(unsafe.Pointer(&v))
+	return Value{typ: p.Type, ptr: p.Data}
+}
+
+func (v Value) getString() (x string) {
+	*(*stringHeader)(unsafe.Pointer(&x)) = stringHeader{Data: v.ptr, Len: int(v.num)}
+	return x
+}
+func (v Value) getBytes() (x []byte) {
+	*(*sliceHeader)(unsafe.Pointer(&x)) = sliceHeader{Data: v.ptr, Len: int(v.num), Cap: int(v.num)}
+	return x
+}
+func (v Value) getIface() (x interface{}) {
+	*(*ifaceHeader)(unsafe.Pointer(&x)) = ifaceHeader{Type: v.typ, Data: v.ptr}
+	return x
+}
diff --git a/vendor/google.golang.org/protobuf/reflect/protoregistry/registry.go b/vendor/google.golang.org/protobuf/reflect/protoregistry/registry.go
new file mode 100644
index 000000000..43f16c616
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/reflect/protoregistry/registry.go
@@ -0,0 +1,768 @@
+// 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 protoregistry provides data structures to register and lookup
+// protobuf descriptor types.
+//
+// The Files registry contains file descriptors and provides the ability
+// to iterate over the files or lookup a specific descriptor within the files.
+// Files only contains protobuf descriptors and has no understanding of Go
+// type information that may be associated with each descriptor.
+//
+// The Types registry contains descriptor types for which there is a known
+// Go type associated with that descriptor. It provides the ability to iterate
+// over the registered types or lookup a type by name.
+package protoregistry
+
+import (
+	"fmt"
+	"log"
+	"strings"
+	"sync"
+
+	"google.golang.org/protobuf/internal/errors"
+	"google.golang.org/protobuf/reflect/protoreflect"
+)
+
+// ignoreConflict reports whether to ignore a registration conflict
+// given the descriptor being registered and the error.
+// It is a variable so that the behavior is easily overridden in another file.
+var ignoreConflict = func(d protoreflect.Descriptor, err error) bool {
+	log.Printf(""+
+		"WARNING: %v\n"+
+		"A future release will panic on registration conflicts. See:\n"+
+		"https://developers.google.com/protocol-buffers/docs/reference/go/faq#namespace-conflict\n"+
+		"\n", err)
+	return true
+}
+
+var globalMutex sync.RWMutex
+
+// GlobalFiles is a global registry of file descriptors.
+var GlobalFiles *Files = new(Files)
+
+// GlobalTypes is the registry used by default for type lookups
+// unless a local registry is provided by the user.
+var GlobalTypes *Types = new(Types)
+
+// NotFound is a sentinel error value to indicate that the type was not found.
+//
+// Since registry lookup can happen in the critical performance path, resolvers
+// must return this exact error value, not an error wrapping it.
+var NotFound = errors.New("not found")
+
+// Files is a registry for looking up or iterating over files and the
+// descriptors contained within them.
+// The Find and Range methods are safe for concurrent use.
+type Files struct {
+	// The map of descsByName contains:
+	//	EnumDescriptor
+	//	EnumValueDescriptor
+	//	MessageDescriptor
+	//	ExtensionDescriptor
+	//	ServiceDescriptor
+	//	*packageDescriptor
+	//
+	// Note that files are stored as a slice, since a package may contain
+	// multiple files. Only top-level declarations are registered.
+	// Note that enum values are in the top-level since that are in the same
+	// scope as the parent enum.
+	descsByName map[protoreflect.FullName]interface{}
+	filesByPath map[string]protoreflect.FileDescriptor
+}
+
+type packageDescriptor struct {
+	files []protoreflect.FileDescriptor
+}
+
+// RegisterFile registers the provided file descriptor.
+//
+// If any descriptor within the file conflicts with the descriptor of any
+// previously registered file (e.g., two enums with the same full name),
+// then the file is not registered and an error is returned.
+//
+// It is permitted for multiple files to have the same file path.
+func (r *Files) RegisterFile(file protoreflect.FileDescriptor) error {
+	if r == GlobalFiles {
+		globalMutex.Lock()
+		defer globalMutex.Unlock()
+	}
+	if r.descsByName == nil {
+		r.descsByName = map[protoreflect.FullName]interface{}{
+			"": &packageDescriptor{},
+		}
+		r.filesByPath = make(map[string]protoreflect.FileDescriptor)
+	}
+	path := file.Path()
+	if prev := r.filesByPath[path]; prev != nil {
+		err := errors.New("file %q is already registered", file.Path())
+		err = amendErrorWithCaller(err, prev, file)
+		if r == GlobalFiles && ignoreConflict(file, err) {
+			err = nil
+		}
+		return err
+	}
+
+	for name := file.Package(); name != ""; name = name.Parent() {
+		switch prev := r.descsByName[name]; prev.(type) {
+		case nil, *packageDescriptor:
+		default:
+			err := errors.New("file %q has a package name conflict over %v", file.Path(), name)
+			err = amendErrorWithCaller(err, prev, file)
+			if r == GlobalFiles && ignoreConflict(file, err) {
+				err = nil
+			}
+			return err
+		}
+	}
+	var err error
+	var hasConflict bool
+	rangeTopLevelDescriptors(file, func(d protoreflect.Descriptor) {
+		if prev := r.descsByName[d.FullName()]; prev != nil {
+			hasConflict = true
+			err = errors.New("file %q has a name conflict over %v", file.Path(), d.FullName())
+			err = amendErrorWithCaller(err, prev, file)
+			if r == GlobalFiles && ignoreConflict(d, err) {
+				err = nil
+			}
+		}
+	})
+	if hasConflict {
+		return err
+	}
+
+	for name := file.Package(); name != ""; name = name.Parent() {
+		if r.descsByName[name] == nil {
+			r.descsByName[name] = &packageDescriptor{}
+		}
+	}
+	p := r.descsByName[file.Package()].(*packageDescriptor)
+	p.files = append(p.files, file)
+	rangeTopLevelDescriptors(file, func(d protoreflect.Descriptor) {
+		r.descsByName[d.FullName()] = d
+	})
+	r.filesByPath[path] = file
+	return nil
+}
+
+// FindDescriptorByName looks up a descriptor by the full name.
+//
+// This returns (nil, NotFound) if not found.
+func (r *Files) FindDescriptorByName(name protoreflect.FullName) (protoreflect.Descriptor, error) {
+	if r == nil {
+		return nil, NotFound
+	}
+	if r == GlobalFiles {
+		globalMutex.RLock()
+		defer globalMutex.RUnlock()
+	}
+	prefix := name
+	suffix := nameSuffix("")
+	for prefix != "" {
+		if d, ok := r.descsByName[prefix]; ok {
+			switch d := d.(type) {
+			case protoreflect.EnumDescriptor:
+				if d.FullName() == name {
+					return d, nil
+				}
+			case protoreflect.EnumValueDescriptor:
+				if d.FullName() == name {
+					return d, nil
+				}
+			case protoreflect.MessageDescriptor:
+				if d.FullName() == name {
+					return d, nil
+				}
+				if d := findDescriptorInMessage(d, suffix); d != nil && d.FullName() == name {
+					return d, nil
+				}
+			case protoreflect.ExtensionDescriptor:
+				if d.FullName() == name {
+					return d, nil
+				}
+			case protoreflect.ServiceDescriptor:
+				if d.FullName() == name {
+					return d, nil
+				}
+				if d := d.Methods().ByName(suffix.Pop()); d != nil && d.FullName() == name {
+					return d, nil
+				}
+			}
+			return nil, NotFound
+		}
+		prefix = prefix.Parent()
+		suffix = nameSuffix(name[len(prefix)+len("."):])
+	}
+	return nil, NotFound
+}
+
+func findDescriptorInMessage(md protoreflect.MessageDescriptor, suffix nameSuffix) protoreflect.Descriptor {
+	name := suffix.Pop()
+	if suffix == "" {
+		if ed := md.Enums().ByName(name); ed != nil {
+			return ed
+		}
+		for i := md.Enums().Len() - 1; i >= 0; i-- {
+			if vd := md.Enums().Get(i).Values().ByName(name); vd != nil {
+				return vd
+			}
+		}
+		if xd := md.Extensions().ByName(name); xd != nil {
+			return xd
+		}
+		if fd := md.Fields().ByName(name); fd != nil {
+			return fd
+		}
+		if od := md.Oneofs().ByName(name); od != nil {
+			return od
+		}
+	}
+	if md := md.Messages().ByName(name); md != nil {
+		if suffix == "" {
+			return md
+		}
+		return findDescriptorInMessage(md, suffix)
+	}
+	return nil
+}
+
+type nameSuffix string
+
+func (s *nameSuffix) Pop() (name protoreflect.Name) {
+	if i := strings.IndexByte(string(*s), '.'); i >= 0 {
+		name, *s = protoreflect.Name((*s)[:i]), (*s)[i+1:]
+	} else {
+		name, *s = protoreflect.Name((*s)), ""
+	}
+	return name
+}
+
+// FindFileByPath looks up a file by the path.
+//
+// This returns (nil, NotFound) if not found.
+func (r *Files) FindFileByPath(path string) (protoreflect.FileDescriptor, error) {
+	if r == nil {
+		return nil, NotFound
+	}
+	if r == GlobalFiles {
+		globalMutex.RLock()
+		defer globalMutex.RUnlock()
+	}
+	if fd, ok := r.filesByPath[path]; ok {
+		return fd, nil
+	}
+	return nil, NotFound
+}
+
+// NumFiles reports the number of registered files.
+func (r *Files) NumFiles() int {
+	if r == nil {
+		return 0
+	}
+	if r == GlobalFiles {
+		globalMutex.RLock()
+		defer globalMutex.RUnlock()
+	}
+	return len(r.filesByPath)
+}
+
+// RangeFiles iterates over all registered files while f returns true.
+// The iteration order is undefined.
+func (r *Files) RangeFiles(f func(protoreflect.FileDescriptor) bool) {
+	if r == nil {
+		return
+	}
+	if r == GlobalFiles {
+		globalMutex.RLock()
+		defer globalMutex.RUnlock()
+	}
+	for _, file := range r.filesByPath {
+		if !f(file) {
+			return
+		}
+	}
+}
+
+// NumFilesByPackage reports the number of registered files in a proto package.
+func (r *Files) NumFilesByPackage(name protoreflect.FullName) int {
+	if r == nil {
+		return 0
+	}
+	if r == GlobalFiles {
+		globalMutex.RLock()
+		defer globalMutex.RUnlock()
+	}
+	p, ok := r.descsByName[name].(*packageDescriptor)
+	if !ok {
+		return 0
+	}
+	return len(p.files)
+}
+
+// RangeFilesByPackage iterates over all registered files in a given proto package
+// while f returns true. The iteration order is undefined.
+func (r *Files) RangeFilesByPackage(name protoreflect.FullName, f func(protoreflect.FileDescriptor) bool) {
+	if r == nil {
+		return
+	}
+	if r == GlobalFiles {
+		globalMutex.RLock()
+		defer globalMutex.RUnlock()
+	}
+	p, ok := r.descsByName[name].(*packageDescriptor)
+	if !ok {
+		return
+	}
+	for _, file := range p.files {
+		if !f(file) {
+			return
+		}
+	}
+}
+
+// rangeTopLevelDescriptors iterates over all top-level descriptors in a file
+// which will be directly entered into the registry.
+func rangeTopLevelDescriptors(fd protoreflect.FileDescriptor, f func(protoreflect.Descriptor)) {
+	eds := fd.Enums()
+	for i := eds.Len() - 1; i >= 0; i-- {
+		f(eds.Get(i))
+		vds := eds.Get(i).Values()
+		for i := vds.Len() - 1; i >= 0; i-- {
+			f(vds.Get(i))
+		}
+	}
+	mds := fd.Messages()
+	for i := mds.Len() - 1; i >= 0; i-- {
+		f(mds.Get(i))
+	}
+	xds := fd.Extensions()
+	for i := xds.Len() - 1; i >= 0; i-- {
+		f(xds.Get(i))
+	}
+	sds := fd.Services()
+	for i := sds.Len() - 1; i >= 0; i-- {
+		f(sds.Get(i))
+	}
+}
+
+// MessageTypeResolver is an interface for looking up messages.
+//
+// A compliant implementation must deterministically return the same type
+// if no error is encountered.
+//
+// The Types type implements this interface.
+type MessageTypeResolver interface {
+	// FindMessageByName looks up a message by its full name.
+	// E.g., "google.protobuf.Any"
+	//
+	// This return (nil, NotFound) if not found.
+	FindMessageByName(message protoreflect.FullName) (protoreflect.MessageType, error)
+
+	// FindMessageByURL looks up a message by a URL identifier.
+	// See documentation on google.protobuf.Any.type_url for the URL format.
+	//
+	// This returns (nil, NotFound) if not found.
+	FindMessageByURL(url string) (protoreflect.MessageType, error)
+}
+
+// ExtensionTypeResolver is an interface for looking up extensions.
+//
+// A compliant implementation must deterministically return the same type
+// if no error is encountered.
+//
+// The Types type implements this interface.
+type ExtensionTypeResolver interface {
+	// FindExtensionByName looks up a extension field by the field's full name.
+	// Note that this is the full name of the field as determined by
+	// where the extension is declared and is unrelated to the full name of the
+	// message being extended.
+	//
+	// This returns (nil, NotFound) if not found.
+	FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error)
+
+	// FindExtensionByNumber looks up a extension field by the field number
+	// within some parent message, identified by full name.
+	//
+	// This returns (nil, NotFound) if not found.
+	FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error)
+}
+
+var (
+	_ MessageTypeResolver   = (*Types)(nil)
+	_ ExtensionTypeResolver = (*Types)(nil)
+)
+
+// Types is a registry for looking up or iterating over descriptor types.
+// The Find and Range methods are safe for concurrent use.
+type Types struct {
+	typesByName         typesByName
+	extensionsByMessage extensionsByMessage
+
+	numEnums      int
+	numMessages   int
+	numExtensions int
+}
+
+type (
+	typesByName         map[protoreflect.FullName]interface{}
+	extensionsByMessage map[protoreflect.FullName]extensionsByNumber
+	extensionsByNumber  map[protoreflect.FieldNumber]protoreflect.ExtensionType
+)
+
+// RegisterMessage registers the provided message type.
+//
+// If a naming conflict occurs, the type is not registered and an error is returned.
+func (r *Types) RegisterMessage(mt protoreflect.MessageType) error {
+	// Under rare circumstances getting the descriptor might recursively
+	// examine the registry, so fetch it before locking.
+	md := mt.Descriptor()
+
+	if r == GlobalTypes {
+		globalMutex.Lock()
+		defer globalMutex.Unlock()
+	}
+
+	if err := r.register("message", md, mt); err != nil {
+		return err
+	}
+	r.numMessages++
+	return nil
+}
+
+// RegisterEnum registers the provided enum type.
+//
+// If a naming conflict occurs, the type is not registered and an error is returned.
+func (r *Types) RegisterEnum(et protoreflect.EnumType) error {
+	// Under rare circumstances getting the descriptor might recursively
+	// examine the registry, so fetch it before locking.
+	ed := et.Descriptor()
+
+	if r == GlobalTypes {
+		globalMutex.Lock()
+		defer globalMutex.Unlock()
+	}
+
+	if err := r.register("enum", ed, et); err != nil {
+		return err
+	}
+	r.numEnums++
+	return nil
+}
+
+// RegisterExtension registers the provided extension type.
+//
+// If a naming conflict occurs, the type is not registered and an error is returned.
+func (r *Types) RegisterExtension(xt protoreflect.ExtensionType) error {
+	// Under rare circumstances getting the descriptor might recursively
+	// examine the registry, so fetch it before locking.
+	//
+	// A known case where this can happen: Fetching the TypeDescriptor for a
+	// legacy ExtensionDesc can consult the global registry.
+	xd := xt.TypeDescriptor()
+
+	if r == GlobalTypes {
+		globalMutex.Lock()
+		defer globalMutex.Unlock()
+	}
+
+	field := xd.Number()
+	message := xd.ContainingMessage().FullName()
+	if prev := r.extensionsByMessage[message][field]; prev != nil {
+		err := errors.New("extension number %d is already registered on message %v", field, message)
+		err = amendErrorWithCaller(err, prev, xt)
+		if !(r == GlobalTypes && ignoreConflict(xd, err)) {
+			return err
+		}
+	}
+
+	if err := r.register("extension", xd, xt); err != nil {
+		return err
+	}
+	if r.extensionsByMessage == nil {
+		r.extensionsByMessage = make(extensionsByMessage)
+	}
+	if r.extensionsByMessage[message] == nil {
+		r.extensionsByMessage[message] = make(extensionsByNumber)
+	}
+	r.extensionsByMessage[message][field] = xt
+	r.numExtensions++
+	return nil
+}
+
+func (r *Types) register(kind string, desc protoreflect.Descriptor, typ interface{}) error {
+	name := desc.FullName()
+	prev := r.typesByName[name]
+	if prev != nil {
+		err := errors.New("%v %v is already registered", kind, name)
+		err = amendErrorWithCaller(err, prev, typ)
+		if !(r == GlobalTypes && ignoreConflict(desc, err)) {
+			return err
+		}
+	}
+	if r.typesByName == nil {
+		r.typesByName = make(typesByName)
+	}
+	r.typesByName[name] = typ
+	return nil
+}
+
+// FindEnumByName looks up an enum by its full name.
+// E.g., "google.protobuf.Field.Kind".
+//
+// This returns (nil, NotFound) if not found.
+func (r *Types) FindEnumByName(enum protoreflect.FullName) (protoreflect.EnumType, error) {
+	if r == nil {
+		return nil, NotFound
+	}
+	if r == GlobalTypes {
+		globalMutex.RLock()
+		defer globalMutex.RUnlock()
+	}
+	if v := r.typesByName[enum]; v != nil {
+		if et, _ := v.(protoreflect.EnumType); et != nil {
+			return et, nil
+		}
+		return nil, errors.New("found wrong type: got %v, want enum", typeName(v))
+	}
+	return nil, NotFound
+}
+
+// FindMessageByName looks up a message by its full name.
+// E.g., "google.protobuf.Any"
+//
+// This return (nil, NotFound) if not found.
+func (r *Types) FindMessageByName(message protoreflect.FullName) (protoreflect.MessageType, error) {
+	// The full name by itself is a valid URL.
+	return r.FindMessageByURL(string(message))
+}
+
+// FindMessageByURL looks up a message by a URL identifier.
+// See documentation on google.protobuf.Any.type_url for the URL format.
+//
+// This returns (nil, NotFound) if not found.
+func (r *Types) FindMessageByURL(url string) (protoreflect.MessageType, error) {
+	if r == nil {
+		return nil, NotFound
+	}
+	if r == GlobalTypes {
+		globalMutex.RLock()
+		defer globalMutex.RUnlock()
+	}
+	message := protoreflect.FullName(url)
+	if i := strings.LastIndexByte(url, '/'); i >= 0 {
+		message = message[i+len("/"):]
+	}
+
+	if v := r.typesByName[message]; v != nil {
+		if mt, _ := v.(protoreflect.MessageType); mt != nil {
+			return mt, nil
+		}
+		return nil, errors.New("found wrong type: got %v, want message", typeName(v))
+	}
+	return nil, NotFound
+}
+
+// FindExtensionByName looks up a extension field by the field's full name.
+// Note that this is the full name of the field as determined by
+// where the extension is declared and is unrelated to the full name of the
+// message being extended.
+//
+// This returns (nil, NotFound) if not found.
+func (r *Types) FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error) {
+	if r == nil {
+		return nil, NotFound
+	}
+	if r == GlobalTypes {
+		globalMutex.RLock()
+		defer globalMutex.RUnlock()
+	}
+	if v := r.typesByName[field]; v != nil {
+		if xt, _ := v.(protoreflect.ExtensionType); xt != nil {
+			return xt, nil
+		}
+		return nil, errors.New("found wrong type: got %v, want extension", typeName(v))
+	}
+	return nil, NotFound
+}
+
+// FindExtensionByNumber looks up a extension field by the field number
+// within some parent message, identified by full name.
+//
+// This returns (nil, NotFound) if not found.
+func (r *Types) FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error) {
+	if r == nil {
+		return nil, NotFound
+	}
+	if r == GlobalTypes {
+		globalMutex.RLock()
+		defer globalMutex.RUnlock()
+	}
+	if xt, ok := r.extensionsByMessage[message][field]; ok {
+		return xt, nil
+	}
+	return nil, NotFound
+}
+
+// NumEnums reports the number of registered enums.
+func (r *Types) NumEnums() int {
+	if r == nil {
+		return 0
+	}
+	if r == GlobalTypes {
+		globalMutex.RLock()
+		defer globalMutex.RUnlock()
+	}
+	return r.numEnums
+}
+
+// RangeEnums iterates over all registered enums while f returns true.
+// Iteration order is undefined.
+func (r *Types) RangeEnums(f func(protoreflect.EnumType) bool) {
+	if r == nil {
+		return
+	}
+	if r == GlobalTypes {
+		globalMutex.RLock()
+		defer globalMutex.RUnlock()
+	}
+	for _, typ := range r.typesByName {
+		if et, ok := typ.(protoreflect.EnumType); ok {
+			if !f(et) {
+				return
+			}
+		}
+	}
+}
+
+// NumMessages reports the number of registered messages.
+func (r *Types) NumMessages() int {
+	if r == nil {
+		return 0
+	}
+	if r == GlobalTypes {
+		globalMutex.RLock()
+		defer globalMutex.RUnlock()
+	}
+	return r.numMessages
+}
+
+// RangeMessages iterates over all registered messages while f returns true.
+// Iteration order is undefined.
+func (r *Types) RangeMessages(f func(protoreflect.MessageType) bool) {
+	if r == nil {
+		return
+	}
+	if r == GlobalTypes {
+		globalMutex.RLock()
+		defer globalMutex.RUnlock()
+	}
+	for _, typ := range r.typesByName {
+		if mt, ok := typ.(protoreflect.MessageType); ok {
+			if !f(mt) {
+				return
+			}
+		}
+	}
+}
+
+// NumExtensions reports the number of registered extensions.
+func (r *Types) NumExtensions() int {
+	if r == nil {
+		return 0
+	}
+	if r == GlobalTypes {
+		globalMutex.RLock()
+		defer globalMutex.RUnlock()
+	}
+	return r.numExtensions
+}
+
+// RangeExtensions iterates over all registered extensions while f returns true.
+// Iteration order is undefined.
+func (r *Types) RangeExtensions(f func(protoreflect.ExtensionType) bool) {
+	if r == nil {
+		return
+	}
+	if r == GlobalTypes {
+		globalMutex.RLock()
+		defer globalMutex.RUnlock()
+	}
+	for _, typ := range r.typesByName {
+		if xt, ok := typ.(protoreflect.ExtensionType); ok {
+			if !f(xt) {
+				return
+			}
+		}
+	}
+}
+
+// NumExtensionsByMessage reports the number of registered extensions for
+// a given message type.
+func (r *Types) NumExtensionsByMessage(message protoreflect.FullName) int {
+	if r == nil {
+		return 0
+	}
+	if r == GlobalTypes {
+		globalMutex.RLock()
+		defer globalMutex.RUnlock()
+	}
+	return len(r.extensionsByMessage[message])
+}
+
+// RangeExtensionsByMessage iterates over all registered extensions filtered
+// by a given message type while f returns true. Iteration order is undefined.
+func (r *Types) RangeExtensionsByMessage(message protoreflect.FullName, f func(protoreflect.ExtensionType) bool) {
+	if r == nil {
+		return
+	}
+	if r == GlobalTypes {
+		globalMutex.RLock()
+		defer globalMutex.RUnlock()
+	}
+	for _, xt := range r.extensionsByMessage[message] {
+		if !f(xt) {
+			return
+		}
+	}
+}
+
+func typeName(t interface{}) string {
+	switch t.(type) {
+	case protoreflect.EnumType:
+		return "enum"
+	case protoreflect.MessageType:
+		return "message"
+	case protoreflect.ExtensionType:
+		return "extension"
+	default:
+		return fmt.Sprintf("%T", t)
+	}
+}
+
+func amendErrorWithCaller(err error, prev, curr interface{}) error {
+	prevPkg := goPackage(prev)
+	currPkg := goPackage(curr)
+	if prevPkg == "" || currPkg == "" || prevPkg == currPkg {
+		return err
+	}
+	return errors.New("%s\n\tpreviously from: %q\n\tcurrently from:  %q", err, prevPkg, currPkg)
+}
+
+func goPackage(v interface{}) string {
+	switch d := v.(type) {
+	case protoreflect.EnumType:
+		v = d.Descriptor()
+	case protoreflect.MessageType:
+		v = d.Descriptor()
+	case protoreflect.ExtensionType:
+		v = d.TypeDescriptor()
+	}
+	if d, ok := v.(protoreflect.Descriptor); ok {
+		v = d.ParentFile()
+	}
+	if d, ok := v.(interface{ GoPackagePath() string }); ok {
+		return d.GoPackagePath()
+	}
+	return ""
+}
diff --git a/vendor/google.golang.org/protobuf/reflect/protoregistry/registry_test.go b/vendor/google.golang.org/protobuf/reflect/protoregistry/registry_test.go
new file mode 100644
index 000000000..446e03650
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/reflect/protoregistry/registry_test.go
@@ -0,0 +1,649 @@
+// 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 protoregistry_test
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/cmpopts"
+
+	"google.golang.org/protobuf/encoding/prototext"
+	pimpl "google.golang.org/protobuf/internal/impl"
+	pdesc "google.golang.org/protobuf/reflect/protodesc"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+	preg "google.golang.org/protobuf/reflect/protoregistry"
+
+	testpb "google.golang.org/protobuf/internal/testprotos/registry"
+	"google.golang.org/protobuf/types/descriptorpb"
+)
+
+func mustMakeFile(s string) pref.FileDescriptor {
+	pb := new(descriptorpb.FileDescriptorProto)
+	if err := prototext.Unmarshal([]byte(s), pb); err != nil {
+		panic(err)
+	}
+	fd, err := pdesc.NewFile(pb, nil)
+	if err != nil {
+		panic(err)
+	}
+	return fd
+}
+
+func TestFiles(t *testing.T) {
+	type (
+		file struct {
+			Path string
+			Pkg  pref.FullName
+		}
+		testFile struct {
+			inFile  pref.FileDescriptor
+			wantErr string
+		}
+		testFindDesc struct {
+			inName    pref.FullName
+			wantFound bool
+		}
+		testRangePkg struct {
+			inPkg     pref.FullName
+			wantFiles []file
+		}
+		testFindPath struct {
+			inPath    string
+			wantFiles []file
+		}
+	)
+
+	tests := []struct {
+		files     []testFile
+		findDescs []testFindDesc
+		rangePkgs []testRangePkg
+		findPaths []testFindPath
+	}{{
+		// Test that overlapping packages and files are permitted.
+		files: []testFile{
+			{inFile: mustMakeFile(`syntax:"proto2" name:"test1.proto" package:"foo.bar"`)},
+			{inFile: mustMakeFile(`syntax:"proto2" name:"foo/bar/test.proto" package:"my.test"`)},
+			{inFile: mustMakeFile(`syntax:"proto2" name:"foo/bar/test.proto" package:"foo.bar.baz"`), wantErr: "already registered"},
+			{inFile: mustMakeFile(`syntax:"proto2" name:"test2.proto" package:"my.test.package"`)},
+			{inFile: mustMakeFile(`syntax:"proto2" name:"weird" package:"foo.bar"`)},
+			{inFile: mustMakeFile(`syntax:"proto2" name:"foo/bar/baz/../test.proto" package:"my.test"`)},
+		},
+
+		rangePkgs: []testRangePkg{{
+			inPkg: "nothing",
+		}, {
+			inPkg: "",
+		}, {
+			inPkg: ".",
+		}, {
+			inPkg: "foo",
+		}, {
+			inPkg: "foo.",
+		}, {
+			inPkg: "foo..",
+		}, {
+			inPkg: "foo.bar",
+			wantFiles: []file{
+				{"test1.proto", "foo.bar"},
+				{"weird", "foo.bar"},
+			},
+		}, {
+			inPkg: "my.test",
+			wantFiles: []file{
+				{"foo/bar/baz/../test.proto", "my.test"},
+				{"foo/bar/test.proto", "my.test"},
+			},
+		}, {
+			inPkg: "fo",
+		}},
+
+		findPaths: []testFindPath{{
+			inPath: "nothing",
+		}, {
+			inPath: "weird",
+			wantFiles: []file{
+				{"weird", "foo.bar"},
+			},
+		}, {
+			inPath: "foo/bar/test.proto",
+			wantFiles: []file{
+				{"foo/bar/test.proto", "my.test"},
+			},
+		}},
+	}, {
+		// Test when new enum conflicts with existing package.
+		files: []testFile{{
+			inFile: mustMakeFile(`syntax:"proto2" name:"test1a.proto" package:"foo.bar.baz"`),
+		}, {
+			inFile:  mustMakeFile(`syntax:"proto2" name:"test1b.proto" enum_type:[{name:"foo" value:[{name:"VALUE" number:0}]}]`),
+			wantErr: `file "test1b.proto" has a name conflict over foo`,
+		}},
+	}, {
+		// Test when new package conflicts with existing enum.
+		files: []testFile{{
+			inFile: mustMakeFile(`syntax:"proto2" name:"test2a.proto" enum_type:[{name:"foo" value:[{name:"VALUE" number:0}]}]`),
+		}, {
+			inFile:  mustMakeFile(`syntax:"proto2" name:"test2b.proto" package:"foo.bar.baz"`),
+			wantErr: `file "test2b.proto" has a package name conflict over foo`,
+		}},
+	}, {
+		// Test when new enum conflicts with existing enum in same package.
+		files: []testFile{{
+			inFile: mustMakeFile(`syntax:"proto2" name:"test3a.proto" package:"foo" enum_type:[{name:"BAR" value:[{name:"VALUE" number:0}]}]`),
+		}, {
+			inFile:  mustMakeFile(`syntax:"proto2" name:"test3b.proto" package:"foo" enum_type:[{name:"BAR" value:[{name:"VALUE2" number:0}]}]`),
+			wantErr: `file "test3b.proto" has a name conflict over foo.BAR`,
+		}},
+	}, {
+		files: []testFile{{
+			inFile: mustMakeFile(`
+				syntax:  "proto2"
+				name:    "test1.proto"
+				package: "fizz.buzz"
+				message_type: [{
+					name: "Message"
+					field: [
+						{name:"Field" number:1 label:LABEL_OPTIONAL type:TYPE_STRING oneof_index:0}
+					]
+					oneof_decl:      [{name:"Oneof"}]
+					extension_range: [{start:1000 end:2000}]
+
+					enum_type: [
+						{name:"Enum" value:[{name:"EnumValue" number:0}]}
+					]
+					nested_type: [
+						{name:"Message" field:[{name:"Field" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}]}
+					]
+					extension: [
+						{name:"Extension" number:1001 label:LABEL_OPTIONAL type:TYPE_STRING extendee:".fizz.buzz.Message"}
+					]
+				}]
+				enum_type: [{
+					name:  "Enum"
+					value: [{name:"EnumValue" number:0}]
+				}]
+				extension: [
+					{name:"Extension" number:1000 label:LABEL_OPTIONAL type:TYPE_STRING extendee:".fizz.buzz.Message"}
+				]
+				service: [{
+					name: "Service"
+					method: [{
+						name:             "Method"
+						input_type:       ".fizz.buzz.Message"
+						output_type:      ".fizz.buzz.Message"
+						client_streaming: true
+						server_streaming: true
+					}]
+				}]
+			`),
+		}, {
+			inFile: mustMakeFile(`
+				syntax:  "proto2"
+				name:    "test2.proto"
+				package: "fizz.buzz.gazz"
+				enum_type: [{
+					name:  "Enum"
+					value: [{name:"EnumValue" number:0}]
+				}]
+			`),
+		}, {
+			inFile: mustMakeFile(`
+				syntax:  "proto2"
+				name:    "test3.proto"
+				package: "fizz.buzz"
+				enum_type: [{
+					name:  "Enum1"
+					value: [{name:"EnumValue1" number:0}]
+				}, {
+					name:  "Enum2"
+					value: [{name:"EnumValue2" number:0}]
+				}]
+			`),
+		}, {
+			// Make sure we can register without package name.
+			inFile: mustMakeFile(`
+				name:   "weird"
+				syntax: "proto2"
+				message_type: [{
+					name: "Message"
+					nested_type: [{
+						name: "Message"
+						nested_type: [{
+							name: "Message"
+						}]
+					}]
+				}]
+			`),
+		}},
+		findDescs: []testFindDesc{
+			{inName: "fizz.buzz.message", wantFound: false},
+			{inName: "fizz.buzz.Message", wantFound: true},
+			{inName: "fizz.buzz.Message.X", wantFound: false},
+			{inName: "fizz.buzz.Field", wantFound: false},
+			{inName: "fizz.buzz.Oneof", wantFound: false},
+			{inName: "fizz.buzz.Message.Field", wantFound: true},
+			{inName: "fizz.buzz.Message.Field.X", wantFound: false},
+			{inName: "fizz.buzz.Message.Oneof", wantFound: true},
+			{inName: "fizz.buzz.Message.Oneof.X", wantFound: false},
+			{inName: "fizz.buzz.Message.Message", wantFound: true},
+			{inName: "fizz.buzz.Message.Message.X", wantFound: false},
+			{inName: "fizz.buzz.Message.Enum", wantFound: true},
+			{inName: "fizz.buzz.Message.Enum.X", wantFound: false},
+			{inName: "fizz.buzz.Message.EnumValue", wantFound: true},
+			{inName: "fizz.buzz.Message.EnumValue.X", wantFound: false},
+			{inName: "fizz.buzz.Message.Extension", wantFound: true},
+			{inName: "fizz.buzz.Message.Extension.X", wantFound: false},
+			{inName: "fizz.buzz.enum", wantFound: false},
+			{inName: "fizz.buzz.Enum", wantFound: true},
+			{inName: "fizz.buzz.Enum.X", wantFound: false},
+			{inName: "fizz.buzz.EnumValue", wantFound: true},
+			{inName: "fizz.buzz.EnumValue.X", wantFound: false},
+			{inName: "fizz.buzz.Enum.EnumValue", wantFound: false},
+			{inName: "fizz.buzz.Extension", wantFound: true},
+			{inName: "fizz.buzz.Extension.X", wantFound: false},
+			{inName: "fizz.buzz.service", wantFound: false},
+			{inName: "fizz.buzz.Service", wantFound: true},
+			{inName: "fizz.buzz.Service.X", wantFound: false},
+			{inName: "fizz.buzz.Method", wantFound: false},
+			{inName: "fizz.buzz.Service.Method", wantFound: true},
+			{inName: "fizz.buzz.Service.Method.X", wantFound: false},
+
+			{inName: "fizz.buzz.gazz", wantFound: false},
+			{inName: "fizz.buzz.gazz.Enum", wantFound: true},
+			{inName: "fizz.buzz.gazz.EnumValue", wantFound: true},
+			{inName: "fizz.buzz.gazz.Enum.EnumValue", wantFound: false},
+
+			{inName: "fizz.buzz", wantFound: false},
+			{inName: "fizz.buzz.Enum1", wantFound: true},
+			{inName: "fizz.buzz.EnumValue1", wantFound: true},
+			{inName: "fizz.buzz.Enum1.EnumValue1", wantFound: false},
+			{inName: "fizz.buzz.Enum2", wantFound: true},
+			{inName: "fizz.buzz.EnumValue2", wantFound: true},
+			{inName: "fizz.buzz.Enum2.EnumValue2", wantFound: false},
+			{inName: "fizz.buzz.Enum3", wantFound: false},
+
+			{inName: "", wantFound: false},
+			{inName: "Message", wantFound: true},
+			{inName: "Message.Message", wantFound: true},
+			{inName: "Message.Message.Message", wantFound: true},
+			{inName: "Message.Message.Message.Message", wantFound: false},
+		},
+	}}
+
+	sortFiles := cmpopts.SortSlices(func(x, y file) bool {
+		return x.Path < y.Path || (x.Path == y.Path && x.Pkg < y.Pkg)
+	})
+	for _, tt := range tests {
+		t.Run("", func(t *testing.T) {
+			var files preg.Files
+			for i, tc := range tt.files {
+				gotErr := files.RegisterFile(tc.inFile)
+				if ((gotErr == nil) != (tc.wantErr == "")) || !strings.Contains(fmt.Sprint(gotErr), tc.wantErr) {
+					t.Errorf("file %d, Register() = %v, want %v", i, gotErr, tc.wantErr)
+				}
+			}
+
+			for _, tc := range tt.findDescs {
+				d, _ := files.FindDescriptorByName(tc.inName)
+				gotFound := d != nil
+				if gotFound != tc.wantFound {
+					t.Errorf("FindDescriptorByName(%v) find mismatch: got %v, want %v", tc.inName, gotFound, tc.wantFound)
+				}
+			}
+
+			for _, tc := range tt.rangePkgs {
+				var gotFiles []file
+				var gotCnt int
+				wantCnt := files.NumFilesByPackage(tc.inPkg)
+				files.RangeFilesByPackage(tc.inPkg, func(fd pref.FileDescriptor) bool {
+					gotFiles = append(gotFiles, file{fd.Path(), fd.Package()})
+					gotCnt++
+					return true
+				})
+				if gotCnt != wantCnt {
+					t.Errorf("NumFilesByPackage(%v) = %v, want %v", tc.inPkg, gotCnt, wantCnt)
+				}
+				if diff := cmp.Diff(tc.wantFiles, gotFiles, sortFiles); diff != "" {
+					t.Errorf("RangeFilesByPackage(%v) mismatch (-want +got):\n%v", tc.inPkg, diff)
+				}
+			}
+
+			for _, tc := range tt.findPaths {
+				var gotFiles []file
+				if fd, err := files.FindFileByPath(tc.inPath); err == nil {
+					gotFiles = append(gotFiles, file{fd.Path(), fd.Package()})
+				}
+				if diff := cmp.Diff(tc.wantFiles, gotFiles, sortFiles); diff != "" {
+					t.Errorf("FindFileByPath(%v) mismatch (-want +got):\n%v", tc.inPath, diff)
+				}
+			}
+		})
+	}
+}
+
+func TestTypes(t *testing.T) {
+	mt1 := pimpl.Export{}.MessageTypeOf(&testpb.Message1{})
+	et1 := pimpl.Export{}.EnumTypeOf(testpb.Enum1_ONE)
+	xt1 := testpb.E_StringField
+	xt2 := testpb.E_Message4_MessageField
+	registry := new(preg.Types)
+	if err := registry.RegisterMessage(mt1); err != nil {
+		t.Fatalf("registry.RegisterMessage(%v) returns unexpected error: %v", mt1.Descriptor().FullName(), err)
+	}
+	if err := registry.RegisterEnum(et1); err != nil {
+		t.Fatalf("registry.RegisterEnum(%v) returns unexpected error: %v", et1.Descriptor().FullName(), err)
+	}
+	if err := registry.RegisterExtension(xt1); err != nil {
+		t.Fatalf("registry.RegisterExtension(%v) returns unexpected error: %v", xt1.TypeDescriptor().FullName(), err)
+	}
+	if err := registry.RegisterExtension(xt2); err != nil {
+		t.Fatalf("registry.RegisterExtension(%v) returns unexpected error: %v", xt2.TypeDescriptor().FullName(), err)
+	}
+
+	t.Run("FindMessageByName", func(t *testing.T) {
+		tests := []struct {
+			name         string
+			messageType  pref.MessageType
+			wantErr      bool
+			wantNotFound bool
+		}{{
+			name:        "testprotos.Message1",
+			messageType: mt1,
+		}, {
+			name:         "testprotos.NoSuchMessage",
+			wantErr:      true,
+			wantNotFound: true,
+		}, {
+			name:    "testprotos.Enum1",
+			wantErr: true,
+		}, {
+			name:    "testprotos.Enum2",
+			wantErr: true,
+		}, {
+			name:    "testprotos.Enum3",
+			wantErr: true,
+		}}
+		for _, tc := range tests {
+			got, err := registry.FindMessageByName(pref.FullName(tc.name))
+			gotErr := err != nil
+			if gotErr != tc.wantErr {
+				t.Errorf("FindMessageByName(%v) = (_, %v), want error? %t", tc.name, err, tc.wantErr)
+				continue
+			}
+			if tc.wantNotFound && err != preg.NotFound {
+				t.Errorf("FindMessageByName(%v) got error: %v, want NotFound error", tc.name, err)
+				continue
+			}
+			if got != tc.messageType {
+				t.Errorf("FindMessageByName(%v) got wrong value: %v", tc.name, got)
+			}
+		}
+	})
+
+	t.Run("FindMessageByURL", func(t *testing.T) {
+		tests := []struct {
+			name         string
+			messageType  pref.MessageType
+			wantErr      bool
+			wantNotFound bool
+		}{{
+			name:        "testprotos.Message1",
+			messageType: mt1,
+		}, {
+			name:         "type.googleapis.com/testprotos.Nada",
+			wantErr:      true,
+			wantNotFound: true,
+		}, {
+			name:    "testprotos.Enum1",
+			wantErr: true,
+		}}
+		for _, tc := range tests {
+			got, err := registry.FindMessageByURL(tc.name)
+			gotErr := err != nil
+			if gotErr != tc.wantErr {
+				t.Errorf("FindMessageByURL(%v) = (_, %v), want error? %t", tc.name, err, tc.wantErr)
+				continue
+			}
+			if tc.wantNotFound && err != preg.NotFound {
+				t.Errorf("FindMessageByURL(%v) got error: %v, want NotFound error", tc.name, err)
+				continue
+			}
+			if got != tc.messageType {
+				t.Errorf("FindMessageByURL(%v) got wrong value: %v", tc.name, got)
+			}
+		}
+	})
+
+	t.Run("FindEnumByName", func(t *testing.T) {
+		tests := []struct {
+			name         string
+			enumType     pref.EnumType
+			wantErr      bool
+			wantNotFound bool
+		}{{
+			name:     "testprotos.Enum1",
+			enumType: et1,
+		}, {
+			name:         "testprotos.None",
+			wantErr:      true,
+			wantNotFound: true,
+		}, {
+			name:    "testprotos.Message1",
+			wantErr: true,
+		}}
+		for _, tc := range tests {
+			got, err := registry.FindEnumByName(pref.FullName(tc.name))
+			gotErr := err != nil
+			if gotErr != tc.wantErr {
+				t.Errorf("FindEnumByName(%v) = (_, %v), want error? %t", tc.name, err, tc.wantErr)
+				continue
+			}
+			if tc.wantNotFound && err != preg.NotFound {
+				t.Errorf("FindEnumByName(%v) got error: %v, want NotFound error", tc.name, err)
+				continue
+			}
+			if got != tc.enumType {
+				t.Errorf("FindEnumByName(%v) got wrong value: %v", tc.name, got)
+			}
+		}
+	})
+
+	t.Run("FindExtensionByName", func(t *testing.T) {
+		tests := []struct {
+			name          string
+			extensionType pref.ExtensionType
+			wantErr       bool
+			wantNotFound  bool
+		}{{
+			name:          "testprotos.string_field",
+			extensionType: xt1,
+		}, {
+			name:          "testprotos.Message4.message_field",
+			extensionType: xt2,
+		}, {
+			name:         "testprotos.None",
+			wantErr:      true,
+			wantNotFound: true,
+		}, {
+			name:    "testprotos.Message1",
+			wantErr: true,
+		}}
+		for _, tc := range tests {
+			got, err := registry.FindExtensionByName(pref.FullName(tc.name))
+			gotErr := err != nil
+			if gotErr != tc.wantErr {
+				t.Errorf("FindExtensionByName(%v) = (_, %v), want error? %t", tc.name, err, tc.wantErr)
+				continue
+			}
+			if tc.wantNotFound && err != preg.NotFound {
+				t.Errorf("FindExtensionByName(%v) got error: %v, want NotFound error", tc.name, err)
+				continue
+			}
+			if got != tc.extensionType {
+				t.Errorf("FindExtensionByName(%v) got wrong value: %v", tc.name, got)
+			}
+		}
+	})
+
+	t.Run("FindExtensionByNumber", func(t *testing.T) {
+		tests := []struct {
+			parent        string
+			number        int32
+			extensionType pref.ExtensionType
+			wantErr       bool
+			wantNotFound  bool
+		}{{
+			parent:        "testprotos.Message1",
+			number:        11,
+			extensionType: xt1,
+		}, {
+			parent:       "testprotos.Message1",
+			number:       13,
+			wantErr:      true,
+			wantNotFound: true,
+		}, {
+			parent:        "testprotos.Message1",
+			number:        21,
+			extensionType: xt2,
+		}, {
+			parent:       "testprotos.Message1",
+			number:       23,
+			wantErr:      true,
+			wantNotFound: true,
+		}, {
+			parent:       "testprotos.NoSuchMessage",
+			number:       11,
+			wantErr:      true,
+			wantNotFound: true,
+		}, {
+			parent:       "testprotos.Message1",
+			number:       30,
+			wantErr:      true,
+			wantNotFound: true,
+		}, {
+			parent:       "testprotos.Message1",
+			number:       99,
+			wantErr:      true,
+			wantNotFound: true,
+		}}
+		for _, tc := range tests {
+			got, err := registry.FindExtensionByNumber(pref.FullName(tc.parent), pref.FieldNumber(tc.number))
+			gotErr := err != nil
+			if gotErr != tc.wantErr {
+				t.Errorf("FindExtensionByNumber(%v, %d) = (_, %v), want error? %t", tc.parent, tc.number, err, tc.wantErr)
+				continue
+			}
+			if tc.wantNotFound && err != preg.NotFound {
+				t.Errorf("FindExtensionByNumber(%v, %d) got error %v, want NotFound error", tc.parent, tc.number, err)
+				continue
+			}
+			if got != tc.extensionType {
+				t.Errorf("FindExtensionByNumber(%v, %d) got wrong value: %v", tc.parent, tc.number, got)
+			}
+		}
+	})
+
+	sortTypes := cmp.Options{
+		cmpopts.SortSlices(func(x, y pref.EnumType) bool {
+			return x.Descriptor().FullName() < y.Descriptor().FullName()
+		}),
+		cmpopts.SortSlices(func(x, y pref.MessageType) bool {
+			return x.Descriptor().FullName() < y.Descriptor().FullName()
+		}),
+		cmpopts.SortSlices(func(x, y pref.ExtensionType) bool {
+			return x.TypeDescriptor().FullName() < y.TypeDescriptor().FullName()
+		}),
+	}
+	compare := cmp.Options{
+		cmp.Comparer(func(x, y pref.EnumType) bool {
+			return x == y
+		}),
+		cmp.Comparer(func(x, y pref.ExtensionType) bool {
+			return x == y
+		}),
+		cmp.Comparer(func(x, y pref.MessageType) bool {
+			return x == y
+		}),
+	}
+
+	t.Run("RangeEnums", func(t *testing.T) {
+		want := []pref.EnumType{et1}
+		var got []pref.EnumType
+		var gotCnt int
+		wantCnt := registry.NumEnums()
+		registry.RangeEnums(func(et pref.EnumType) bool {
+			got = append(got, et)
+			gotCnt++
+			return true
+		})
+
+		if gotCnt != wantCnt {
+			t.Errorf("NumEnums() = %v, want %v", gotCnt, wantCnt)
+		}
+		if diff := cmp.Diff(want, got, sortTypes, compare); diff != "" {
+			t.Errorf("RangeEnums() mismatch (-want +got):\n%v", diff)
+		}
+	})
+
+	t.Run("RangeMessages", func(t *testing.T) {
+		want := []pref.MessageType{mt1}
+		var got []pref.MessageType
+		var gotCnt int
+		wantCnt := registry.NumMessages()
+		registry.RangeMessages(func(mt pref.MessageType) bool {
+			got = append(got, mt)
+			gotCnt++
+			return true
+		})
+
+		if gotCnt != wantCnt {
+			t.Errorf("NumMessages() = %v, want %v", gotCnt, wantCnt)
+		}
+		if diff := cmp.Diff(want, got, sortTypes, compare); diff != "" {
+			t.Errorf("RangeMessages() mismatch (-want +got):\n%v", diff)
+		}
+	})
+
+	t.Run("RangeExtensions", func(t *testing.T) {
+		want := []pref.ExtensionType{xt1, xt2}
+		var got []pref.ExtensionType
+		var gotCnt int
+		wantCnt := registry.NumExtensions()
+		registry.RangeExtensions(func(xt pref.ExtensionType) bool {
+			got = append(got, xt)
+			gotCnt++
+			return true
+		})
+
+		if gotCnt != wantCnt {
+			t.Errorf("NumExtensions() = %v, want %v", gotCnt, wantCnt)
+		}
+		if diff := cmp.Diff(want, got, sortTypes, compare); diff != "" {
+			t.Errorf("RangeExtensions() mismatch (-want +got):\n%v", diff)
+		}
+	})
+
+	t.Run("RangeExtensionsByMessage", func(t *testing.T) {
+		want := []pref.ExtensionType{xt1, xt2}
+		var got []pref.ExtensionType
+		var gotCnt int
+		wantCnt := registry.NumExtensionsByMessage("testprotos.Message1")
+		registry.RangeExtensionsByMessage("testprotos.Message1", func(xt pref.ExtensionType) bool {
+			got = append(got, xt)
+			gotCnt++
+			return true
+		})
+
+		if gotCnt != wantCnt {
+			t.Errorf("NumExtensionsByMessage() = %v, want %v", gotCnt, wantCnt)
+		}
+		if diff := cmp.Diff(want, got, sortTypes, compare); diff != "" {
+			t.Errorf("RangeExtensionsByMessage() mismatch (-want +got):\n%v", diff)
+		}
+	})
+}
diff --git a/vendor/google.golang.org/protobuf/regenerate.bash b/vendor/google.golang.org/protobuf/regenerate.bash
new file mode 100644
index 000000000..71f7cdd0b
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/regenerate.bash
@@ -0,0 +1,8 @@
+#!/bin/bash
+# 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.
+
+cd "$(git rev-parse --show-toplevel)"
+go test -v -mod=vendor -timeout=60m -count=1 integration_test.go "$@" -regenerate
+exit $?
diff --git a/vendor/google.golang.org/protobuf/release.bash b/vendor/google.golang.org/protobuf/release.bash
new file mode 100644
index 000000000..95049ed50
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/release.bash
@@ -0,0 +1,94 @@
+#!/bin/bash
+# Copyright 2019 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.
+
+cd "$(git rev-parse --show-toplevel)"
+
+read -p "What is the next release version (e.g., 'v1.26.0')?  " VERSION
+SEMVER_REGEX='^v\([0-9]*\)[.]\([0-9]*\)[.]\([0-9]*\)\([.a-zA-Z0-9A-Z-]*\)$'
+if ! [[ -z $(echo $VERSION | sed -e "s/$SEMVER_REGEX//") ]]; then
+	echo; echo "invalid: must be a semver string"; exit 1
+fi
+VERSION_MAJOR=$(echo $VERSION | sed -e "s/$SEMVER_REGEX/\1/")
+VERSION_MINOR=$(echo $VERSION | sed -e "s/$SEMVER_REGEX/\2/")
+VERSION_PATCH=$(echo $VERSION | sed -e "s/$SEMVER_REGEX/\3/")
+VERSION_PRERELEASE=$(echo $VERSION | sed -e "s/$SEMVER_REGEX/\4/")
+if ! [[ "$VERSION_MAJOR" =~ ^1$ ]]; then
+	echo; echo "invalid: major version must be 1"; exit 1
+fi
+if ! [[ -z $VERSION_PRERELEASE ]] && ! [[ "$VERSION_PRERELEASE" =~ ^-rc[.][0-9]+$ ]]; then
+	echo; echo "invalid: pre-release suffix must be empty or '-rc.X'"; exit 1
+fi
+VERSION_PRERELEASE=${VERSION_PRERELEASE#"-"} # trim possible leading dash
+
+function version_string() {
+	VERSION_STRING="v${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}"
+	if ! [[ -z $VERSION_PRERELEASE ]]; then
+		VERSION_STRING="${VERSION_STRING}-${VERSION_PRERELEASE}"
+	fi
+	echo $VERSION_STRING
+}
+
+read -p "Were there any changes to the generator that relies on new runtime functionality?  " YN
+case $YN in
+[Yy]* )
+	read -p "  What minor version of the runtime is required now?  " GEN_VERSION
+	if ! [[ "$GEN_VERSION" =~ ^[0-9]+$ ]]; then echo; echo "invalid: must be an integer"; exit 1; fi;;
+[Nn]* ) ;;
+* ) echo; echo "invalid: must be 'yes' or 'no'"; exit 1;;
+esac
+
+read -p "Were there any dropped functionality in the runtime for old generated code?  " YN
+case $YN in
+[Yy]* )
+	read -p "  What minor version of the runtime is required now?  " MIN_VERSION
+	if ! [[ "$MIN_VERSION" =~ ^[0-9]+$ ]]; then echo; echo "invalid: must be an integer"; exit 1; fi;;
+[Nn]* ) ;;
+* ) echo; echo "invalid: must be 'yes' or 'no'"; exit 1;;
+esac
+
+
+echo
+echo "Preparing changes to release $(version_string)."
+echo
+
+set -e
+
+# Create a new branch to contain the release changes.
+if [[ $(git branch --list release) ]]; then
+	echo "error: release branch already exists"; exit 1
+fi
+git change release
+git sync
+
+# Create commit for actual release.
+sed -i -e "s/\(\s*Minor\s*=\s*\)[0-9]*/\1$VERSION_MINOR/" internal/version/version.go
+sed -i -e "s/\(\s*Patch\s*=\s*\)[0-9]*/\1$VERSION_PATCH/" internal/version/version.go
+sed -i -e "s/\(\s*PreRelease\s*=\s*\)\"[^\"]*\"/\1\"$VERSION_PRERELEASE\"/" internal/version/version.go
+if ! [[ -z $GEN_VERSION ]]; then
+	sed -i -e "s/\(\s*GenVersion\s*=\s*\)[0-9]*/\1$GEN_VERSION/" runtime/protoimpl/version.go
+fi
+if ! [[ -z $MIN_VERSION ]]; then
+	sed -i -e "s/\(\s*MinVersion\s*=\s*\)[0-9]*/\1$MIN_VERSION/" runtime/protoimpl/version.go
+fi
+git commit -a -m "all: release $(version_string)"
+
+# Build release binaries.
+go test -mod=vendor -timeout=60m -count=1 integration_test.go "$@" -buildRelease
+
+# Create commit to start development after release.
+VERSION_PRERELEASE="${VERSION_PRERELEASE}.devel" # append ".devel"
+VERSION_PRERELEASE="${VERSION_PRERELEASE#"."}"   # trim possible leading "."
+sed -i -e "s/\(\s*PreRelease\s*=\s*\)\"[^\"]*\"/\1\"$VERSION_PRERELEASE\"/" internal/version/version.go
+git commit -a -m "all: start $(version_string)"
+
+echo
+echo "Release changes prepared. Additional steps:"
+echo "  1) Submit the changes:"
+echo "    a. Mail out the changes: git mail HEAD"
+echo "    b. Request a review on the changes and merge them."
+echo "  2) Tag a new release on GitHub:"
+echo "    a. Write release notes highlighting notable changes."
+echo "    b. Attach pre-compiled binaries as assets to the release."
+echo
diff --git a/vendor/google.golang.org/protobuf/runtime/protoiface/legacy.go b/vendor/google.golang.org/protobuf/runtime/protoiface/legacy.go
new file mode 100644
index 000000000..c58727675
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/runtime/protoiface/legacy.go
@@ -0,0 +1,15 @@
+// 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 protoiface
+
+type MessageV1 interface {
+	Reset()
+	String() string
+	ProtoMessage()
+}
+
+type ExtensionRangeV1 struct {
+	Start, End int32 // both inclusive
+}
diff --git a/vendor/google.golang.org/protobuf/runtime/protoiface/methods.go b/vendor/google.golang.org/protobuf/runtime/protoiface/methods.go
new file mode 100644
index 000000000..32c04f67e
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/runtime/protoiface/methods.go
@@ -0,0 +1,167 @@
+// Copyright 2019 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 protoiface contains types referenced or implemented by messages.
+//
+// WARNING: This package should only be imported by message implementations.
+// The functionality found in this package should be accessed through
+// higher-level abstractions provided by the proto package.
+package protoiface
+
+import (
+	"google.golang.org/protobuf/internal/pragma"
+	"google.golang.org/protobuf/reflect/protoreflect"
+)
+
+// Methods is a set of optional fast-path implementations of various operations.
+type Methods = struct {
+	pragma.NoUnkeyedLiterals
+
+	// Flags indicate support for optional features.
+	Flags SupportFlags
+
+	// Size returns the size in bytes of the wire-format encoding of a message.
+	// Marshal must be provided if a custom Size is provided.
+	Size func(SizeInput) SizeOutput
+
+	// Marshal formats a message in the wire-format encoding to the provided buffer.
+	// Size should be provided if a custom Marshal is provided.
+	// It must not return an error for a partial message.
+	Marshal func(MarshalInput) (MarshalOutput, error)
+
+	// Unmarshal parses the wire-format encoding and merges the result into a message.
+	// It must not reset the target message or return an error for a partial message.
+	Unmarshal func(UnmarshalInput) (UnmarshalOutput, error)
+
+	// Merge merges the contents of a source message into a destination message.
+	Merge func(MergeInput) MergeOutput
+
+	// CheckInitialized returns an error if any required fields in the message are not set.
+	CheckInitialized func(CheckInitializedInput) (CheckInitializedOutput, error)
+}
+
+// SupportFlags indicate support for optional features.
+type SupportFlags = uint64
+
+const (
+	// SupportMarshalDeterministic reports whether MarshalOptions.Deterministic is supported.
+	SupportMarshalDeterministic SupportFlags = 1 << iota
+
+	// SupportUnmarshalDiscardUnknown reports whether UnmarshalOptions.DiscardUnknown is supported.
+	SupportUnmarshalDiscardUnknown
+)
+
+// SizeInput is input to the Size method.
+type SizeInput = struct {
+	pragma.NoUnkeyedLiterals
+
+	Message protoreflect.Message
+	Flags   MarshalInputFlags
+}
+
+// SizeOutput is output from the Size method.
+type SizeOutput = struct {
+	pragma.NoUnkeyedLiterals
+
+	Size int
+}
+
+// MarshalInput is input to the Marshal method.
+type MarshalInput = struct {
+	pragma.NoUnkeyedLiterals
+
+	Message protoreflect.Message
+	Buf     []byte // output is appended to this buffer
+	Flags   MarshalInputFlags
+}
+
+// MarshalOutput is output from the Marshal method.
+type MarshalOutput = struct {
+	pragma.NoUnkeyedLiterals
+
+	Buf []byte // contains marshaled message
+}
+
+// MarshalInputFlags configure the marshaler.
+// Most flags correspond to fields in proto.MarshalOptions.
+type MarshalInputFlags = uint8
+
+const (
+	MarshalDeterministic MarshalInputFlags = 1 << iota
+	MarshalUseCachedSize
+)
+
+// UnmarshalInput is input to the Unmarshal method.
+type UnmarshalInput = struct {
+	pragma.NoUnkeyedLiterals
+
+	Message  protoreflect.Message
+	Buf      []byte // input buffer
+	Flags    UnmarshalInputFlags
+	Resolver interface {
+		FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error)
+		FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error)
+	}
+}
+
+// UnmarshalOutput is output from the Unmarshal method.
+type UnmarshalOutput = struct {
+	pragma.NoUnkeyedLiterals
+
+	Flags UnmarshalOutputFlags
+}
+
+// UnmarshalInputFlags configure the unmarshaler.
+// Most flags correspond to fields in proto.UnmarshalOptions.
+type UnmarshalInputFlags = uint8
+
+const (
+	UnmarshalDiscardUnknown UnmarshalInputFlags = 1 << iota
+)
+
+// UnmarshalOutputFlags are output from the Unmarshal method.
+type UnmarshalOutputFlags = uint8
+
+const (
+	// UnmarshalInitialized may be set on return if all required fields are known to be set.
+	// If unset, then it does not necessarily indicate that the message is uninitialized,
+	// only that its status could not be confirmed.
+	UnmarshalInitialized UnmarshalOutputFlags = 1 << iota
+)
+
+// MergeInput is input to the Merge method.
+type MergeInput = struct {
+	pragma.NoUnkeyedLiterals
+
+	Source      protoreflect.Message
+	Destination protoreflect.Message
+}
+
+// MergeOutput is output from the Merge method.
+type MergeOutput = struct {
+	pragma.NoUnkeyedLiterals
+
+	Flags MergeOutputFlags
+}
+
+// MergeOutputFlags are output from the Merge method.
+type MergeOutputFlags = uint8
+
+const (
+	// MergeComplete reports whether the merge was performed.
+	// If unset, the merger must have made no changes to the destination.
+	MergeComplete MergeOutputFlags = 1 << iota
+)
+
+// CheckInitializedInput is input to the CheckInitialized method.
+type CheckInitializedInput = struct {
+	pragma.NoUnkeyedLiterals
+
+	Message protoreflect.Message
+}
+
+// CheckInitializedOutput is output from the CheckInitialized method.
+type CheckInitializedOutput = struct {
+	pragma.NoUnkeyedLiterals
+}
diff --git a/vendor/google.golang.org/protobuf/runtime/protoimpl/impl.go b/vendor/google.golang.org/protobuf/runtime/protoimpl/impl.go
new file mode 100644
index 000000000..4a1ab7fb3
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/runtime/protoimpl/impl.go
@@ -0,0 +1,44 @@
+// 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 protoimpl contains the default implementation for messages
+// generated by protoc-gen-go.
+//
+// WARNING: This package should only ever be imported by generated messages.
+// The compatibility agreement covers nothing except for functionality needed
+// to keep existing generated messages operational. Breakages that occur due
+// to unauthorized usages of this package are not the author's responsibility.
+package protoimpl
+
+import (
+	"google.golang.org/protobuf/internal/filedesc"
+	"google.golang.org/protobuf/internal/filetype"
+	"google.golang.org/protobuf/internal/impl"
+)
+
+// UnsafeEnabled specifies whether package unsafe can be used.
+const UnsafeEnabled = impl.UnsafeEnabled
+
+type (
+	// Types used by generated code in init functions.
+	DescBuilder = filedesc.Builder
+	TypeBuilder = filetype.Builder
+
+	// Types used by generated code to implement EnumType, MessageType, and ExtensionType.
+	EnumInfo      = impl.EnumInfo
+	MessageInfo   = impl.MessageInfo
+	ExtensionInfo = impl.ExtensionInfo
+
+	// Types embedded in generated messages.
+	MessageState     = impl.MessageState
+	SizeCache        = impl.SizeCache
+	WeakFields       = impl.WeakFields
+	UnknownFields    = impl.UnknownFields
+	ExtensionFields  = impl.ExtensionFields
+	ExtensionFieldV1 = impl.ExtensionField
+
+	Pointer = impl.Pointer
+)
+
+var X impl.Export
diff --git a/vendor/google.golang.org/protobuf/runtime/protoimpl/version.go b/vendor/google.golang.org/protobuf/runtime/protoimpl/version.go
new file mode 100644
index 000000000..ff094e1ba
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/runtime/protoimpl/version.go
@@ -0,0 +1,56 @@
+// Copyright 2019 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 protoimpl
+
+import (
+	"google.golang.org/protobuf/internal/version"
+)
+
+const (
+	// MaxVersion is the maximum supported version for generated .pb.go files.
+	// It is always the current version of the module.
+	MaxVersion = version.Minor
+
+	// GenVersion is the runtime version required by generated .pb.go files.
+	// This is incremented when generated code relies on new functionality
+	// in the runtime.
+	GenVersion = 20
+
+	// MinVersion is the minimum supported version for generated .pb.go files.
+	// This is incremented when the runtime drops support for old code.
+	MinVersion = 0
+)
+
+// EnforceVersion is used by code generated by protoc-gen-go
+// to statically enforce minimum and maximum versions of this package.
+// A compilation failure implies either that:
+//	* the runtime package is too old and needs to be updated OR
+//	* the generated code is too old and needs to be regenerated.
+//
+// The runtime package can be upgraded by running:
+//	go get google.golang.org/protobuf
+//
+// The generated code can be regenerated by running:
+//	protoc --go_out=${PROTOC_GEN_GO_ARGS} ${PROTO_FILES}
+//
+// Example usage by generated code:
+//	const (
+//		// Verify that this generated code is sufficiently up-to-date.
+//		_ = protoimpl.EnforceVersion(genVersion - protoimpl.MinVersion)
+//		// Verify that runtime/protoimpl is sufficiently up-to-date.
+//		_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - genVersion)
+//	)
+//
+// The genVersion is the current minor version used to generated the code.
+// This compile-time check relies on negative integer overflow of a uint
+// being a compilation failure (guaranteed by the Go specification).
+type EnforceVersion uint
+
+// This enforces the following invariant:
+//	MinVersion ≤ GenVersion ≤ MaxVersion
+const (
+	_ = EnforceVersion(GenVersion - MinVersion)
+	_ = EnforceVersion(MaxVersion - GenVersion)
+)
diff --git a/vendor/google.golang.org/protobuf/test.bash b/vendor/google.golang.org/protobuf/test.bash
new file mode 100644
index 000000000..2db962157
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/test.bash
@@ -0,0 +1,8 @@
+#!/bin/bash
+# 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.
+
+cd "$(git rev-parse --show-toplevel)"
+go test -v -mod=vendor -timeout=60m -count=1 integration_test.go -failfast "$@"
+exit $?
diff --git a/vendor/google.golang.org/protobuf/testing/protocmp/reflect.go b/vendor/google.golang.org/protobuf/testing/protocmp/reflect.go
new file mode 100644
index 000000000..62c646f9e
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/testing/protocmp/reflect.go
@@ -0,0 +1,260 @@
+// Copyright 2020 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 protocmp
+
+import (
+	"reflect"
+	"sort"
+	"strconv"
+	"strings"
+
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/runtime/protoiface"
+)
+
+func reflectValueOf(v interface{}) protoreflect.Value {
+	switch v := v.(type) {
+	case Enum:
+		return protoreflect.ValueOfEnum(v.Number())
+	case Message:
+		return protoreflect.ValueOfMessage(v.ProtoReflect())
+	case []byte:
+		return protoreflect.ValueOfBytes(v) // avoid overlap with reflect.Slice check below
+	default:
+		switch rv := reflect.ValueOf(v); {
+		case rv.Kind() == reflect.Slice:
+			return protoreflect.ValueOfList(reflectList{rv})
+		case rv.Kind() == reflect.Map:
+			return protoreflect.ValueOfMap(reflectMap{rv})
+		default:
+			return protoreflect.ValueOf(v)
+		}
+	}
+}
+
+type reflectMessage Message
+
+func (m reflectMessage) stringKey(fd protoreflect.FieldDescriptor) string {
+	if m.Descriptor() != fd.ContainingMessage() {
+		panic("mismatching containing message")
+	}
+	if fd.IsExtension() {
+		return string("[" + fd.FullName() + "]")
+	}
+	return string(fd.Name())
+}
+
+func (m reflectMessage) Descriptor() protoreflect.MessageDescriptor {
+	return (Message)(m).Descriptor()
+}
+func (m reflectMessage) Type() protoreflect.MessageType {
+	return reflectMessageType{m.Descriptor()}
+}
+func (m reflectMessage) New() protoreflect.Message {
+	return m.Type().New()
+}
+func (m reflectMessage) Interface() protoreflect.ProtoMessage {
+	return Message(m)
+}
+func (m reflectMessage) Range(f func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool) {
+	// Range over populated known fields.
+	fds := m.Descriptor().Fields()
+	for i := 0; i < fds.Len(); i++ {
+		fd := fds.Get(i)
+		if m.Has(fd) && !f(fd, m.Get(fd)) {
+			return
+		}
+	}
+
+	// Range over populated extension fields.
+	for _, xd := range m[messageTypeKey].(messageType).xds {
+		if m.Has(xd) && !f(xd, m.Get(xd)) {
+			return
+		}
+	}
+}
+func (m reflectMessage) Has(fd protoreflect.FieldDescriptor) bool {
+	_, ok := m[m.stringKey(fd)]
+	return ok
+}
+func (m reflectMessage) Clear(protoreflect.FieldDescriptor) {
+	panic("invalid mutation of read-only message")
+}
+func (m reflectMessage) Get(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	v, ok := m[m.stringKey(fd)]
+	if !ok {
+		switch {
+		case fd.IsList():
+			return protoreflect.ValueOfList(reflectList{})
+		case fd.IsMap():
+			return protoreflect.ValueOfMap(reflectMap{})
+		case fd.Message() != nil:
+			return protoreflect.ValueOfMessage(reflectMessage{
+				messageTypeKey: messageType{md: m.Descriptor()},
+			})
+		default:
+			return fd.Default()
+		}
+	}
+
+	// The transformation may leave Any messages in structured form.
+	// If so, convert them back to a raw-encoded form.
+	if fd.FullName() == "google.protobuf.Any.value" {
+		if m, ok := v.(Message); ok {
+			b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
+			if err != nil {
+				panic("BUG: " + err.Error())
+			}
+			return protoreflect.ValueOfBytes(b)
+		}
+	}
+
+	return reflectValueOf(v)
+}
+func (m reflectMessage) Set(protoreflect.FieldDescriptor, protoreflect.Value) {
+	panic("invalid mutation of read-only message")
+}
+func (m reflectMessage) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	panic("invalid mutation of read-only message")
+}
+func (m reflectMessage) NewField(protoreflect.FieldDescriptor) protoreflect.Value {
+	panic("not implemented")
+}
+func (m reflectMessage) WhichOneof(od protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	if m.Descriptor().Oneofs().ByName(od.Name()) != od {
+		panic("oneof descriptor does not belong to this message")
+	}
+	fds := od.Fields()
+	for i := 0; i < fds.Len(); i++ {
+		fd := fds.Get(i)
+		if _, ok := m[m.stringKey(fd)]; ok {
+			return fd
+		}
+	}
+	return nil
+}
+func (m reflectMessage) GetUnknown() protoreflect.RawFields {
+	var nums []protoreflect.FieldNumber
+	for k := range m {
+		if len(strings.Trim(k, "0123456789")) == 0 {
+			n, _ := strconv.ParseUint(k, 10, 32)
+			nums = append(nums, protoreflect.FieldNumber(n))
+		}
+	}
+	sort.Slice(nums, func(i, j int) bool { return nums[i] < nums[j] })
+
+	var raw protoreflect.RawFields
+	for _, num := range nums {
+		b, _ := m[strconv.FormatUint(uint64(num), 10)].(protoreflect.RawFields)
+		raw = append(raw, b...)
+	}
+	return raw
+}
+func (m reflectMessage) SetUnknown(protoreflect.RawFields) {
+	panic("invalid mutation of read-only message")
+}
+func (m reflectMessage) IsValid() bool {
+	invalid, _ := m[messageInvalidKey].(bool)
+	return !invalid
+}
+func (m reflectMessage) ProtoMethods() *protoiface.Methods {
+	return nil
+}
+
+type reflectMessageType struct{ protoreflect.MessageDescriptor }
+
+func (t reflectMessageType) New() protoreflect.Message {
+	panic("not implemented")
+}
+func (t reflectMessageType) Zero() protoreflect.Message {
+	panic("not implemented")
+}
+func (t reflectMessageType) Descriptor() protoreflect.MessageDescriptor {
+	return t.MessageDescriptor
+}
+
+type reflectList struct{ v reflect.Value }
+
+func (ls reflectList) Len() int {
+	if !ls.IsValid() {
+		return 0
+	}
+	return ls.v.Len()
+}
+func (ls reflectList) Get(i int) protoreflect.Value {
+	return reflectValueOf(ls.v.Index(i).Interface())
+}
+func (ls reflectList) Set(int, protoreflect.Value) {
+	panic("invalid mutation of read-only list")
+}
+func (ls reflectList) Append(protoreflect.Value) {
+	panic("invalid mutation of read-only list")
+}
+func (ls reflectList) AppendMutable() protoreflect.Value {
+	panic("invalid mutation of read-only list")
+}
+func (ls reflectList) Truncate(int) {
+	panic("invalid mutation of read-only list")
+}
+func (ls reflectList) NewElement() protoreflect.Value {
+	panic("not implemented")
+}
+func (ls reflectList) IsValid() bool {
+	return ls.v.IsValid()
+}
+
+type reflectMap struct{ v reflect.Value }
+
+func (ms reflectMap) Len() int {
+	if !ms.IsValid() {
+		return 0
+	}
+	return ms.v.Len()
+}
+func (ms reflectMap) Range(f func(protoreflect.MapKey, protoreflect.Value) bool) {
+	if !ms.IsValid() {
+		return
+	}
+	ks := ms.v.MapKeys()
+	for _, k := range ks {
+		pk := reflectValueOf(k.Interface()).MapKey()
+		pv := reflectValueOf(ms.v.MapIndex(k).Interface())
+		if !f(pk, pv) {
+			return
+		}
+	}
+}
+func (ms reflectMap) Has(k protoreflect.MapKey) bool {
+	if !ms.IsValid() {
+		return false
+	}
+	return ms.v.MapIndex(reflect.ValueOf(k.Interface())).IsValid()
+}
+func (ms reflectMap) Clear(protoreflect.MapKey) {
+	panic("invalid mutation of read-only list")
+}
+func (ms reflectMap) Get(k protoreflect.MapKey) protoreflect.Value {
+	if !ms.IsValid() {
+		return protoreflect.Value{}
+	}
+	v := ms.v.MapIndex(reflect.ValueOf(k.Interface()))
+	if !v.IsValid() {
+		return protoreflect.Value{}
+	}
+	return reflectValueOf(v.Interface())
+}
+func (ms reflectMap) Set(protoreflect.MapKey, protoreflect.Value) {
+	panic("invalid mutation of read-only list")
+}
+func (ms reflectMap) Mutable(k protoreflect.MapKey) protoreflect.Value {
+	panic("invalid mutation of read-only list")
+}
+func (ms reflectMap) NewValue() protoreflect.Value {
+	panic("not implemented")
+}
+func (ms reflectMap) IsValid() bool {
+	return ms.v.IsValid()
+}
diff --git a/vendor/google.golang.org/protobuf/testing/protocmp/reflect_test.go b/vendor/google.golang.org/protobuf/testing/protocmp/reflect_test.go
new file mode 100644
index 000000000..07489e9d5
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/testing/protocmp/reflect_test.go
@@ -0,0 +1,159 @@
+// Copyright 2020 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 protocmp
+
+import (
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+
+	"google.golang.org/protobuf/proto"
+
+	testpb "google.golang.org/protobuf/internal/testprotos/test"
+	textpb "google.golang.org/protobuf/internal/testprotos/textpb2"
+	anypb "google.golang.org/protobuf/types/known/anypb"
+	wrapperspb "google.golang.org/protobuf/types/known/wrapperspb"
+)
+
+func TestReflect(t *testing.T) {
+	optMsg := &testpb.TestAllTypes{
+		OptionalInt32:         proto.Int32(-32),
+		OptionalInt64:         proto.Int64(-64),
+		OptionalUint32:        proto.Uint32(32),
+		OptionalUint64:        proto.Uint64(64),
+		OptionalFloat:         proto.Float32(32.32),
+		OptionalDouble:        proto.Float64(64.64),
+		OptionalBool:          proto.Bool(true),
+		OptionalString:        proto.String("string"),
+		OptionalBytes:         []byte("bytes"),
+		OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{A: proto.Int32(-32)},
+		OptionalNestedEnum:    testpb.TestAllTypes_NEG.Enum(),
+	}
+	repMsg := &testpb.TestAllTypes{
+		RepeatedInt32:         []int32{-32, +32},
+		RepeatedInt64:         []int64{-64, +64},
+		RepeatedUint32:        []uint32{0, 32},
+		RepeatedUint64:        []uint64{0, 64},
+		RepeatedFloat:         []float32{-32.32, +32.32},
+		RepeatedDouble:        []float64{-64.64, +64.64},
+		RepeatedBool:          []bool{false, true},
+		RepeatedString:        []string{"hello", "goodbye"},
+		RepeatedBytes:         [][]byte{[]byte("hello"), []byte("goodbye")},
+		RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{{A: proto.Int32(-32)}, {A: proto.Int32(+32)}},
+		RepeatedNestedEnum:    []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_FOO, testpb.TestAllTypes_NEG},
+	}
+	mapMsg := &testpb.TestAllTypes{
+		MapInt32Int32:          map[int32]int32{-1: -32, +1: +32},
+		MapInt64Int64:          map[int64]int64{-1: -32, +1: +64},
+		MapUint32Uint32:        map[uint32]uint32{0: 0, 1: 32},
+		MapUint64Uint64:        map[uint64]uint64{0: 0, 1: 64},
+		MapInt32Float:          map[int32]float32{-1: -32.32, +1: +32.32},
+		MapInt32Double:         map[int32]float64{-1: -64.64, +1: +64.64},
+		MapBoolBool:            map[bool]bool{false: true, true: false},
+		MapStringString:        map[string]string{"k1": "v1", "k2": "v2"},
+		MapStringBytes:         map[string][]byte{"k1": []byte("v1"), "k2": []byte("v2")},
+		MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"k1": {A: proto.Int32(-32)}, "k2": {A: proto.Int32(+32)}},
+		MapStringNestedEnum:    map[string]testpb.TestAllTypes_NestedEnum{"k1": testpb.TestAllTypes_FOO, "k2": testpb.TestAllTypes_NEG},
+	}
+
+	tests := []proto.Message{
+		optMsg,
+		repMsg,
+		mapMsg,
+		&testpb.TestAllTypes{
+			OneofField: &testpb.TestAllTypes_OneofUint32{32},
+		},
+		&testpb.TestAllTypes{
+			OneofField: &testpb.TestAllTypes_OneofUint64{64},
+		},
+		&testpb.TestAllTypes{
+			OneofField: &testpb.TestAllTypes_OneofFloat{32.32},
+		},
+		&testpb.TestAllTypes{
+			OneofField: &testpb.TestAllTypes_OneofDouble{64.64},
+		},
+		&testpb.TestAllTypes{
+			OneofField: &testpb.TestAllTypes_OneofBool{true},
+		},
+		&testpb.TestAllTypes{
+			OneofField: &testpb.TestAllTypes_OneofString{"string"},
+		},
+		&testpb.TestAllTypes{
+			OneofField: &testpb.TestAllTypes_OneofBytes{[]byte("bytes")},
+		},
+		&testpb.TestAllTypes{
+			OneofField: &testpb.TestAllTypes_OneofNestedMessage{&testpb.TestAllTypes_NestedMessage{A: proto.Int32(-32)}},
+		},
+		&testpb.TestAllTypes{
+			OneofField: &testpb.TestAllTypes_OneofEnum{testpb.TestAllTypes_NEG},
+		},
+		func() proto.Message {
+			m := new(testpb.TestAllExtensions)
+			proto.SetExtension(m, testpb.E_OptionalInt32, int32(-32))
+			proto.SetExtension(m, testpb.E_OptionalInt64, int64(-64))
+			proto.SetExtension(m, testpb.E_OptionalUint32, uint32(32))
+			proto.SetExtension(m, testpb.E_OptionalUint64, uint64(64))
+			proto.SetExtension(m, testpb.E_OptionalFloat, float32(32.32))
+			proto.SetExtension(m, testpb.E_OptionalDouble, float64(64.64))
+			proto.SetExtension(m, testpb.E_OptionalBool, bool(true))
+			proto.SetExtension(m, testpb.E_OptionalString, string("string"))
+			proto.SetExtension(m, testpb.E_OptionalBytes, []byte("bytes"))
+			proto.SetExtension(m, testpb.E_OptionalNestedMessage, &testpb.TestAllExtensions_NestedMessage{A: proto.Int32(-32)})
+			proto.SetExtension(m, testpb.E_OptionalNestedEnum, testpb.TestAllTypes_NEG)
+			return m
+		}(),
+		func() proto.Message {
+			m := new(testpb.TestAllExtensions)
+			proto.SetExtension(m, testpb.E_RepeatedInt32, []int32{-32, +32})
+			proto.SetExtension(m, testpb.E_RepeatedInt64, []int64{-64, +64})
+			proto.SetExtension(m, testpb.E_RepeatedUint32, []uint32{0, 32})
+			proto.SetExtension(m, testpb.E_RepeatedUint64, []uint64{0, 64})
+			proto.SetExtension(m, testpb.E_RepeatedFloat, []float32{-32.32, +32.32})
+			proto.SetExtension(m, testpb.E_RepeatedDouble, []float64{-64.64, +64.64})
+			proto.SetExtension(m, testpb.E_RepeatedBool, []bool{false, true})
+			proto.SetExtension(m, testpb.E_RepeatedString, []string{"hello", "goodbye"})
+			proto.SetExtension(m, testpb.E_RepeatedBytes, [][]byte{[]byte("hello"), []byte("goodbye")})
+			proto.SetExtension(m, testpb.E_RepeatedNestedMessage, []*testpb.TestAllExtensions_NestedMessage{{A: proto.Int32(-32)}, {A: proto.Int32(+32)}})
+			proto.SetExtension(m, testpb.E_RepeatedNestedEnum, []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_FOO, testpb.TestAllTypes_NEG})
+			return m
+		}(),
+		&textpb.KnownTypes{
+			OptBool:   &wrapperspb.BoolValue{Value: true},
+			OptInt32:  &wrapperspb.Int32Value{Value: -32},
+			OptInt64:  &wrapperspb.Int64Value{Value: -64},
+			OptUint32: &wrapperspb.UInt32Value{Value: +32},
+			OptUint64: &wrapperspb.UInt64Value{Value: +64},
+			OptFloat:  &wrapperspb.FloatValue{Value: 32.32},
+			OptDouble: &wrapperspb.DoubleValue{Value: 64.64},
+			OptString: &wrapperspb.StringValue{Value: "string"},
+			OptBytes:  &wrapperspb.BytesValue{Value: []byte("bytes")},
+		},
+		&textpb.KnownTypes{
+			OptAny: &anypb.Any{
+				TypeUrl: "google.golang.org/goproto.proto.test.TestAllTypes",
+				Value: func() []byte {
+					b1, _ := proto.MarshalOptions{Deterministic: true}.Marshal(optMsg)
+					b2, _ := proto.MarshalOptions{Deterministic: true}.Marshal(repMsg)
+					b3, _ := proto.MarshalOptions{Deterministic: true}.Marshal(mapMsg)
+					return append(append(append([]byte(nil), b1...), b2...), b3...)
+				}(),
+			},
+		},
+		&textpb.KnownTypes{
+			OptAny: &anypb.Any{
+				TypeUrl: "unknown_type",
+				Value:   []byte("invalid_value"),
+			},
+		},
+	}
+
+	for _, src := range tests {
+		dst := src.ProtoReflect().Type().New().Interface()
+		proto.Merge(dst, transformMessage(src.ProtoReflect()))
+		if diff := cmp.Diff(src, dst, Transform()); diff != "" {
+			t.Errorf("Merge mismatch (-want +got):\n%s", diff)
+		}
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/testing/protocmp/util.go b/vendor/google.golang.org/protobuf/testing/protocmp/util.go
new file mode 100644
index 000000000..668bb2e99
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/testing/protocmp/util.go
@@ -0,0 +1,679 @@
+// Copyright 2019 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 protocmp
+
+import (
+	"bytes"
+	"fmt"
+	"math"
+	"reflect"
+	"strings"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/cmpopts"
+
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protoreflect"
+)
+
+var (
+	enumReflectType    = reflect.TypeOf(Enum{})
+	messageReflectType = reflect.TypeOf(Message{})
+)
+
+// FilterEnum filters opt to only be applicable on standalone Enums,
+// singular fields of enums, list fields of enums, or map fields of enum values,
+// where the enum is the same type as the specified enum.
+//
+// The Go type of the last path step may be an:
+//	• Enum for singular fields, elements of a repeated field,
+//	values of a map field, or standalone Enums
+//	• []Enum for list fields
+//	• map[K]Enum for map fields
+//	• interface{} for a Message map entry value
+//
+// This must be used in conjunction with Transform.
+func FilterEnum(enum protoreflect.Enum, opt cmp.Option) cmp.Option {
+	return FilterDescriptor(enum.Descriptor(), opt)
+}
+
+// FilterMessage filters opt to only be applicable on standalone Messages,
+// singular fields of messages, list fields of messages, or map fields of
+// message values, where the message is the same type as the specified message.
+//
+// The Go type of the last path step may be an:
+//	• Message for singular fields, elements of a repeated field,
+//	values of a map field, or standalone Messages
+//	• []Message for list fields
+//	• map[K]Message for map fields
+//	• interface{} for a Message map entry value
+//
+// This must be used in conjunction with Transform.
+func FilterMessage(message proto.Message, opt cmp.Option) cmp.Option {
+	return FilterDescriptor(message.ProtoReflect().Descriptor(), opt)
+}
+
+// FilterField filters opt to only be applicable on the specified field
+// in the message. It panics if a field of the given name does not exist.
+//
+// The Go type of the last path step may be an:
+//	• T for singular fields
+//	• []T for list fields
+//	• map[K]T for map fields
+//	• interface{} for a Message map entry value
+//
+// This must be used in conjunction with Transform.
+func FilterField(message proto.Message, name protoreflect.Name, opt cmp.Option) cmp.Option {
+	md := message.ProtoReflect().Descriptor()
+	return FilterDescriptor(mustFindFieldDescriptor(md, name), opt)
+}
+
+// FilterOneof filters opt to only be applicable on all fields within the
+// specified oneof in the message. It panics if a oneof of the given name
+// does not exist.
+//
+// The Go type of the last path step may be an:
+//	• T for singular fields
+//	• []T for list fields
+//	• map[K]T for map fields
+//	• interface{} for a Message map entry value
+//
+// This must be used in conjunction with Transform.
+func FilterOneof(message proto.Message, name protoreflect.Name, opt cmp.Option) cmp.Option {
+	md := message.ProtoReflect().Descriptor()
+	return FilterDescriptor(mustFindOneofDescriptor(md, name), opt)
+}
+
+// FilterDescriptor ignores the specified descriptor.
+//
+// The following descriptor types may be specified:
+//	• protoreflect.EnumDescriptor
+//	• protoreflect.MessageDescriptor
+//	• protoreflect.FieldDescriptor
+//	• protoreflect.OneofDescriptor
+//
+// For the behavior of each, see the corresponding filter function.
+// Since this filter accepts a protoreflect.FieldDescriptor, it can be used
+// to also filter for extension fields as a protoreflect.ExtensionDescriptor
+// is just an alias to protoreflect.FieldDescriptor.
+//
+// This must be used in conjunction with Transform.
+func FilterDescriptor(desc protoreflect.Descriptor, opt cmp.Option) cmp.Option {
+	f := newNameFilters(desc)
+	return cmp.FilterPath(f.Filter, opt)
+}
+
+// IgnoreEnums ignores all enums of the specified types.
+// It is equivalent to FilterEnum(enum, cmp.Ignore()) for each enum.
+//
+// This must be used in conjunction with Transform.
+func IgnoreEnums(enums ...protoreflect.Enum) cmp.Option {
+	var ds []protoreflect.Descriptor
+	for _, e := range enums {
+		ds = append(ds, e.Descriptor())
+	}
+	return IgnoreDescriptors(ds...)
+}
+
+// IgnoreMessages ignores all messages of the specified types.
+// It is equivalent to FilterMessage(message, cmp.Ignore()) for each message.
+//
+// This must be used in conjunction with Transform.
+func IgnoreMessages(messages ...proto.Message) cmp.Option {
+	var ds []protoreflect.Descriptor
+	for _, m := range messages {
+		ds = append(ds, m.ProtoReflect().Descriptor())
+	}
+	return IgnoreDescriptors(ds...)
+}
+
+// IgnoreFields ignores the specified fields in the specified message.
+// It is equivalent to FilterField(message, name, cmp.Ignore()) for each field
+// in the message.
+//
+// This must be used in conjunction with Transform.
+func IgnoreFields(message proto.Message, names ...protoreflect.Name) cmp.Option {
+	var ds []protoreflect.Descriptor
+	md := message.ProtoReflect().Descriptor()
+	for _, s := range names {
+		ds = append(ds, mustFindFieldDescriptor(md, s))
+	}
+	return IgnoreDescriptors(ds...)
+}
+
+// IgnoreOneofs ignores fields of the specified oneofs in the specified message.
+// It is equivalent to FilterOneof(message, name, cmp.Ignore()) for each oneof
+// in the message.
+//
+// This must be used in conjunction with Transform.
+func IgnoreOneofs(message proto.Message, names ...protoreflect.Name) cmp.Option {
+	var ds []protoreflect.Descriptor
+	md := message.ProtoReflect().Descriptor()
+	for _, s := range names {
+		ds = append(ds, mustFindOneofDescriptor(md, s))
+	}
+	return IgnoreDescriptors(ds...)
+}
+
+// IgnoreDescriptors ignores the specified set of descriptors.
+// It is equivalent to FilterDescriptor(desc, cmp.Ignore()) for each descriptor.
+//
+// This must be used in conjunction with Transform.
+func IgnoreDescriptors(descs ...protoreflect.Descriptor) cmp.Option {
+	return cmp.FilterPath(newNameFilters(descs...).Filter, cmp.Ignore())
+}
+
+func mustFindFieldDescriptor(md protoreflect.MessageDescriptor, s protoreflect.Name) protoreflect.FieldDescriptor {
+	d := findDescriptor(md, s)
+	if fd, ok := d.(protoreflect.FieldDescriptor); ok && fd.Name() == s {
+		return fd
+	}
+
+	var suggestion string
+	switch d.(type) {
+	case protoreflect.FieldDescriptor:
+		suggestion = fmt.Sprintf("; consider specifying field %q instead", d.Name())
+	case protoreflect.OneofDescriptor:
+		suggestion = fmt.Sprintf("; consider specifying oneof %q with IgnoreOneofs instead", d.Name())
+	}
+	panic(fmt.Sprintf("message %q has no field %q%s", md.FullName(), s, suggestion))
+}
+
+func mustFindOneofDescriptor(md protoreflect.MessageDescriptor, s protoreflect.Name) protoreflect.OneofDescriptor {
+	d := findDescriptor(md, s)
+	if od, ok := d.(protoreflect.OneofDescriptor); ok && d.Name() == s {
+		return od
+	}
+
+	var suggestion string
+	switch d.(type) {
+	case protoreflect.OneofDescriptor:
+		suggestion = fmt.Sprintf("; consider specifying oneof %q instead", d.Name())
+	case protoreflect.FieldDescriptor:
+		suggestion = fmt.Sprintf("; consider specifying field %q with IgnoreFields instead", d.Name())
+	}
+	panic(fmt.Sprintf("message %q has no oneof %q%s", md.FullName(), s, suggestion))
+}
+
+func findDescriptor(md protoreflect.MessageDescriptor, s protoreflect.Name) protoreflect.Descriptor {
+	// Exact match.
+	if fd := md.Fields().ByName(s); fd != nil {
+		return fd
+	}
+	if od := md.Oneofs().ByName(s); od != nil {
+		return od
+	}
+
+	// Best-effort match.
+	//
+	// It's a common user mistake to use the CameCased field name as it appears
+	// in the generated Go struct. Instead of complaining that it doesn't exist,
+	// suggest the real protobuf name that the user may have desired.
+	normalize := func(s protoreflect.Name) string {
+		return strings.Replace(strings.ToLower(string(s)), "_", "", -1)
+	}
+	for i := 0; i < md.Fields().Len(); i++ {
+		if fd := md.Fields().Get(i); normalize(fd.Name()) == normalize(s) {
+			return fd
+		}
+	}
+	for i := 0; i < md.Oneofs().Len(); i++ {
+		if od := md.Oneofs().Get(i); normalize(od.Name()) == normalize(s) {
+			return od
+		}
+	}
+	return nil
+}
+
+type nameFilters struct {
+	names map[protoreflect.FullName]bool
+}
+
+func newNameFilters(descs ...protoreflect.Descriptor) *nameFilters {
+	f := &nameFilters{names: make(map[protoreflect.FullName]bool)}
+	for _, d := range descs {
+		switch d := d.(type) {
+		case protoreflect.EnumDescriptor:
+			f.names[d.FullName()] = true
+		case protoreflect.MessageDescriptor:
+			f.names[d.FullName()] = true
+		case protoreflect.FieldDescriptor:
+			f.names[d.FullName()] = true
+		case protoreflect.OneofDescriptor:
+			for i := 0; i < d.Fields().Len(); i++ {
+				f.names[d.Fields().Get(i).FullName()] = true
+			}
+		default:
+			panic("invalid descriptor type")
+		}
+	}
+	return f
+}
+
+func (f *nameFilters) Filter(p cmp.Path) bool {
+	vx, vy := p.Last().Values()
+	return (f.filterValue(vx) && f.filterValue(vy)) || f.filterFields(p)
+}
+
+func (f *nameFilters) filterFields(p cmp.Path) bool {
+	// Trim off trailing type-assertions so that the filter can match on the
+	// concrete value held within an interface value.
+	if _, ok := p.Last().(cmp.TypeAssertion); ok {
+		p = p[:len(p)-1]
+	}
+
+	// Filter for Message maps.
+	mi, ok := p.Index(-1).(cmp.MapIndex)
+	if !ok {
+		return false
+	}
+	ps := p.Index(-2)
+	if ps.Type() != messageReflectType {
+		return false
+	}
+
+	// Check field name.
+	vx, vy := ps.Values()
+	mx := vx.Interface().(Message)
+	my := vy.Interface().(Message)
+	k := mi.Key().String()
+	if f.filterFieldName(mx, k) && f.filterFieldName(my, k) {
+		return true
+	}
+
+	// Check field value.
+	vx, vy = mi.Values()
+	if f.filterFieldValue(vx) && f.filterFieldValue(vy) {
+		return true
+	}
+
+	return false
+}
+
+func (f *nameFilters) filterFieldName(m Message, k string) bool {
+	if md := m.Descriptor(); md != nil {
+		switch {
+		case protoreflect.Name(k).IsValid():
+			return f.names[md.Fields().ByName(protoreflect.Name(k)).FullName()]
+		case strings.HasPrefix(k, "[") && strings.HasSuffix(k, "]"):
+			return f.names[protoreflect.FullName(k[1:len(k)-1])]
+		}
+	}
+	return false
+}
+
+func (f *nameFilters) filterFieldValue(v reflect.Value) bool {
+	if !v.IsValid() {
+		return true // implies missing slice element or map entry
+	}
+	v = v.Elem() // map entries are always populated values
+	switch t := v.Type(); {
+	case t == enumReflectType || t == messageReflectType:
+		// Check for singular message or enum field.
+		return f.filterValue(v)
+	case t.Kind() == reflect.Slice && (t.Elem() == enumReflectType || t.Elem() == messageReflectType):
+		// Check for list field of enum or message type.
+		return f.filterValue(v.Index(0))
+	case t.Kind() == reflect.Map && (t.Elem() == enumReflectType || t.Elem() == messageReflectType):
+		// Check for map field of enum or message type.
+		return f.filterValue(v.MapIndex(v.MapKeys()[0]))
+	}
+	return false
+}
+
+func (f *nameFilters) filterValue(v reflect.Value) bool {
+	if !v.IsValid() {
+		return true // implies missing slice element or map entry
+	}
+	if !v.CanInterface() {
+		return false // implies unexported struct field
+	}
+	switch v := v.Interface().(type) {
+	case Enum:
+		return v.Descriptor() != nil && f.names[v.Descriptor().FullName()]
+	case Message:
+		return v.Descriptor() != nil && f.names[v.Descriptor().FullName()]
+	}
+	return false
+}
+
+// IgnoreDefaultScalars ignores singular scalars that are unpopulated or
+// explicitly set to the default value.
+// This option does not effect elements in a list or entries in a map.
+//
+// This must be used in conjunction with Transform.
+func IgnoreDefaultScalars() cmp.Option {
+	return cmp.FilterPath(func(p cmp.Path) bool {
+		// Filter for Message maps.
+		mi, ok := p.Index(-1).(cmp.MapIndex)
+		if !ok {
+			return false
+		}
+		ps := p.Index(-2)
+		if ps.Type() != messageReflectType {
+			return false
+		}
+
+		// Check whether both fields are default or unpopulated scalars.
+		vx, vy := ps.Values()
+		mx := vx.Interface().(Message)
+		my := vy.Interface().(Message)
+		k := mi.Key().String()
+		return isDefaultScalar(mx, k) && isDefaultScalar(my, k)
+	}, cmp.Ignore())
+}
+
+func isDefaultScalar(m Message, k string) bool {
+	if _, ok := m[k]; !ok {
+		return true
+	}
+
+	var fd protoreflect.FieldDescriptor
+	switch mt := m[messageTypeKey].(messageType); {
+	case protoreflect.Name(k).IsValid():
+		fd = mt.md.Fields().ByName(protoreflect.Name(k))
+	case strings.HasPrefix(k, "[") && strings.HasSuffix(k, "]"):
+		fd = mt.xds[protoreflect.FullName(k[1:len(k)-1])]
+	}
+	if fd == nil || !fd.Default().IsValid() {
+		return false
+	}
+	switch fd.Kind() {
+	case protoreflect.BytesKind:
+		v, ok := m[k].([]byte)
+		return ok && bytes.Equal(fd.Default().Bytes(), v)
+	case protoreflect.FloatKind:
+		v, ok := m[k].(float32)
+		return ok && equalFloat64(fd.Default().Float(), float64(v))
+	case protoreflect.DoubleKind:
+		v, ok := m[k].(float64)
+		return ok && equalFloat64(fd.Default().Float(), float64(v))
+	case protoreflect.EnumKind:
+		v, ok := m[k].(Enum)
+		return ok && fd.Default().Enum() == v.Number()
+	default:
+		return reflect.DeepEqual(fd.Default().Interface(), m[k])
+	}
+}
+
+func equalFloat64(x, y float64) bool {
+	return x == y || (math.IsNaN(x) && math.IsNaN(y))
+}
+
+// IgnoreEmptyMessages ignores messages that are empty or unpopulated.
+// It applies to standalone Messages, singular message fields,
+// list fields of messages, and map fields of message values.
+//
+// This must be used in conjunction with Transform.
+func IgnoreEmptyMessages() cmp.Option {
+	return cmp.FilterPath(func(p cmp.Path) bool {
+		vx, vy := p.Last().Values()
+		return (isEmptyMessage(vx) && isEmptyMessage(vy)) || isEmptyMessageFields(p)
+	}, cmp.Ignore())
+}
+
+func isEmptyMessageFields(p cmp.Path) bool {
+	// Filter for Message maps.
+	mi, ok := p.Index(-1).(cmp.MapIndex)
+	if !ok {
+		return false
+	}
+	ps := p.Index(-2)
+	if ps.Type() != messageReflectType {
+		return false
+	}
+
+	// Check field value.
+	vx, vy := mi.Values()
+	if isEmptyMessageFieldValue(vx) && isEmptyMessageFieldValue(vy) {
+		return true
+	}
+
+	return false
+}
+
+func isEmptyMessageFieldValue(v reflect.Value) bool {
+	if !v.IsValid() {
+		return true // implies missing slice element or map entry
+	}
+	v = v.Elem() // map entries are always populated values
+	switch t := v.Type(); {
+	case t == messageReflectType:
+		// Check singular field for empty message.
+		if !isEmptyMessage(v) {
+			return false
+		}
+	case t.Kind() == reflect.Slice && t.Elem() == messageReflectType:
+		// Check list field for all empty message elements.
+		for i := 0; i < v.Len(); i++ {
+			if !isEmptyMessage(v.Index(i)) {
+				return false
+			}
+		}
+	case t.Kind() == reflect.Map && t.Elem() == messageReflectType:
+		// Check map field for all empty message values.
+		for _, k := range v.MapKeys() {
+			if !isEmptyMessage(v.MapIndex(k)) {
+				return false
+			}
+		}
+	default:
+		return false
+	}
+	return true
+}
+
+func isEmptyMessage(v reflect.Value) bool {
+	if !v.IsValid() {
+		return true // implies missing slice element or map entry
+	}
+	if !v.CanInterface() {
+		return false // implies unexported struct field
+	}
+	if m, ok := v.Interface().(Message); ok {
+		for k := range m {
+			if k != messageTypeKey && k != messageInvalidKey {
+				return false
+			}
+		}
+		return true
+	}
+	return false
+}
+
+// IgnoreUnknown ignores unknown fields in all messages.
+//
+// This must be used in conjunction with Transform.
+func IgnoreUnknown() cmp.Option {
+	return cmp.FilterPath(func(p cmp.Path) bool {
+		// Filter for Message maps.
+		mi, ok := p.Index(-1).(cmp.MapIndex)
+		if !ok {
+			return false
+		}
+		ps := p.Index(-2)
+		if ps.Type() != messageReflectType {
+			return false
+		}
+
+		// Filter for unknown fields (which always have a numeric map key).
+		return strings.Trim(mi.Key().String(), "0123456789") == ""
+	}, cmp.Ignore())
+}
+
+// SortRepeated sorts repeated fields of the specified element type.
+// The less function must be of the form "func(T, T) bool" where T is the
+// Go element type for the repeated field kind.
+//
+// The element type T can be one of the following:
+//	• Go type for a protobuf scalar kind except for an enum
+//	  (i.e., bool, int32, int64, uint32, uint64, float32, float64, string, and []byte)
+//	• E where E is a concrete enum type that implements protoreflect.Enum
+//	• M where M is a concrete message type that implement proto.Message
+//
+// This option only applies to repeated fields within a protobuf message.
+// It does not operate on higher-order Go types that seem like a repeated field.
+// For example, a []T outside the context of a protobuf message will not be
+// handled by this option. To sort Go slices that are not repeated fields,
+// consider using "github.com/google/go-cmp/cmp/cmpopts".SortSlices instead.
+//
+// This must be used in conjunction with Transform.
+func SortRepeated(lessFunc interface{}) cmp.Option {
+	t, ok := checkTTBFunc(lessFunc)
+	if !ok {
+		panic(fmt.Sprintf("invalid less function: %T", lessFunc))
+	}
+
+	var opt cmp.Option
+	var sliceType reflect.Type
+	switch vf := reflect.ValueOf(lessFunc); {
+	case t.Implements(enumV2Type):
+		et := reflect.Zero(t).Interface().(protoreflect.Enum).Type()
+		lessFunc = func(x, y Enum) bool {
+			vx := reflect.ValueOf(et.New(x.Number()))
+			vy := reflect.ValueOf(et.New(y.Number()))
+			return vf.Call([]reflect.Value{vx, vy})[0].Bool()
+		}
+		opt = FilterDescriptor(et.Descriptor(), cmpopts.SortSlices(lessFunc))
+		sliceType = reflect.SliceOf(enumReflectType)
+	case t.Implements(messageV2Type):
+		mt := reflect.Zero(t).Interface().(protoreflect.ProtoMessage).ProtoReflect().Type()
+		lessFunc = func(x, y Message) bool {
+			mx := mt.New().Interface()
+			my := mt.New().Interface()
+			proto.Merge(mx, x)
+			proto.Merge(my, y)
+			vx := reflect.ValueOf(mx)
+			vy := reflect.ValueOf(my)
+			return vf.Call([]reflect.Value{vx, vy})[0].Bool()
+		}
+		opt = FilterDescriptor(mt.Descriptor(), cmpopts.SortSlices(lessFunc))
+		sliceType = reflect.SliceOf(messageReflectType)
+	default:
+		switch t {
+		case reflect.TypeOf(bool(false)):
+		case reflect.TypeOf(int32(0)):
+		case reflect.TypeOf(int64(0)):
+		case reflect.TypeOf(uint32(0)):
+		case reflect.TypeOf(uint64(0)):
+		case reflect.TypeOf(float32(0)):
+		case reflect.TypeOf(float64(0)):
+		case reflect.TypeOf(string("")):
+		case reflect.TypeOf([]byte(nil)):
+		default:
+			panic(fmt.Sprintf("invalid element type: %v", t))
+		}
+		opt = cmpopts.SortSlices(lessFunc)
+		sliceType = reflect.SliceOf(t)
+	}
+
+	return cmp.FilterPath(func(p cmp.Path) bool {
+		// Filter to only apply to repeated fields within a message.
+		if t := p.Index(-1).Type(); t == nil || t != sliceType {
+			return false
+		}
+		if t := p.Index(-2).Type(); t == nil || t.Kind() != reflect.Interface {
+			return false
+		}
+		if t := p.Index(-3).Type(); t == nil || t != messageReflectType {
+			return false
+		}
+		return true
+	}, opt)
+}
+
+func checkTTBFunc(lessFunc interface{}) (reflect.Type, bool) {
+	switch t := reflect.TypeOf(lessFunc); {
+	case t == nil:
+		return nil, false
+	case t.NumIn() != 2 || t.In(0) != t.In(1) || t.IsVariadic():
+		return nil, false
+	case t.NumOut() != 1 || t.Out(0) != reflect.TypeOf(false):
+		return nil, false
+	default:
+		return t.In(0), true
+	}
+}
+
+// SortRepeatedFields sorts the specified repeated fields.
+// Sorting a repeated field is useful for treating the list as a multiset
+// (i.e., a set where each value can appear multiple times).
+// It panics if the field does not exist or is not a repeated field.
+//
+// The sort ordering is as follows:
+//	• Booleans are sorted where false is sorted before true.
+//	• Integers are sorted in ascending order.
+//	• Floating-point numbers are sorted in ascending order according to
+//	  the total ordering defined by IEEE-754 (section 5.10).
+//	• Strings and bytes are sorted lexicographically in ascending order.
+//	• Enums are sorted in ascending order based on its numeric value.
+//	• Messages are sorted according to some arbitrary ordering
+//	  which is undefined and may change in future implementations.
+//
+// The ordering chosen for repeated messages is unlikely to be aesthetically
+// preferred by humans. Consider using a custom sort function:
+//
+//	FilterField(m, "foo_field", SortRepeated(func(x, y *foopb.MyMessage) bool {
+//	    ... // user-provided definition for less
+//	}))
+//
+// This must be used in conjunction with Transform.
+func SortRepeatedFields(message proto.Message, names ...protoreflect.Name) cmp.Option {
+	var opts cmp.Options
+	md := message.ProtoReflect().Descriptor()
+	for _, name := range names {
+		fd := mustFindFieldDescriptor(md, name)
+		if !fd.IsList() {
+			panic(fmt.Sprintf("message field %q is not repeated", fd.FullName()))
+		}
+
+		var lessFunc interface{}
+		switch fd.Kind() {
+		case protoreflect.BoolKind:
+			lessFunc = func(x, y bool) bool { return !x && y }
+		case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
+			lessFunc = func(x, y int32) bool { return x < y }
+		case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
+			lessFunc = func(x, y int64) bool { return x < y }
+		case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
+			lessFunc = func(x, y uint32) bool { return x < y }
+		case protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
+			lessFunc = func(x, y uint64) bool { return x < y }
+		case protoreflect.FloatKind:
+			lessFunc = lessF32
+		case protoreflect.DoubleKind:
+			lessFunc = lessF64
+		case protoreflect.StringKind:
+			lessFunc = func(x, y string) bool { return x < y }
+		case protoreflect.BytesKind:
+			lessFunc = func(x, y []byte) bool { return bytes.Compare(x, y) < 0 }
+		case protoreflect.EnumKind:
+			lessFunc = func(x, y Enum) bool { return x.Number() < y.Number() }
+		case protoreflect.MessageKind, protoreflect.GroupKind:
+			lessFunc = func(x, y Message) bool { return x.String() < y.String() }
+		default:
+			panic(fmt.Sprintf("invalid kind: %v", fd.Kind()))
+		}
+		opts = append(opts, FilterDescriptor(fd, cmpopts.SortSlices(lessFunc)))
+	}
+	return opts
+}
+
+func lessF32(x, y float32) bool {
+	// Bit-wise implementation of IEEE-754, section 5.10.
+	xi := int32(math.Float32bits(x))
+	yi := int32(math.Float32bits(y))
+	xi ^= int32(uint32(xi>>31) >> 1)
+	yi ^= int32(uint32(yi>>31) >> 1)
+	return xi < yi
+}
+func lessF64(x, y float64) bool {
+	// Bit-wise implementation of IEEE-754, section 5.10.
+	xi := int64(math.Float64bits(x))
+	yi := int64(math.Float64bits(y))
+	xi ^= int64(uint64(xi>>63) >> 1)
+	yi ^= int64(uint64(yi>>63) >> 1)
+	return xi < yi
+}
diff --git a/vendor/google.golang.org/protobuf/testing/protocmp/util_test.go b/vendor/google.golang.org/protobuf/testing/protocmp/util_test.go
new file mode 100644
index 000000000..ed386e447
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/testing/protocmp/util_test.go
@@ -0,0 +1,1399 @@
+// Copyright 2019 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 protocmp
+
+import (
+	"math"
+	"math/rand"
+	"sort"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/testing/protopack"
+	"google.golang.org/protobuf/types/dynamicpb"
+
+	testpb "google.golang.org/protobuf/internal/testprotos/test"
+)
+
+func TestEqual(t *testing.T) {
+	type test struct {
+		x, y interface{}
+		opts cmp.Options
+		want bool
+	}
+	var tests []test
+
+	allTypesDesc := (*testpb.TestAllTypes)(nil).ProtoReflect().Descriptor()
+
+	// Test nil and empty messages of differing types.
+	tests = append(tests, []test{{
+		x:    (*testpb.TestAllTypes)(nil),
+		y:    (*testpb.TestAllTypes)(nil),
+		opts: cmp.Options{Transform()},
+		want: true,
+	}, {
+		x:    (*testpb.TestAllTypes)(nil),
+		y:    (*testpb.TestAllExtensions)(nil),
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x:    (*testpb.TestAllTypes)(nil),
+		y:    new(testpb.TestAllTypes),
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x:    (*testpb.TestAllTypes)(nil),
+		y:    dynamicpb.NewMessage(allTypesDesc),
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x:    (*testpb.TestAllTypes)(nil),
+		y:    new(testpb.TestAllTypes),
+		opts: cmp.Options{Transform(), IgnoreEmptyMessages()},
+		want: true,
+	}, {
+		x:    (*testpb.TestAllTypes)(nil),
+		y:    dynamicpb.NewMessage(allTypesDesc),
+		opts: cmp.Options{Transform(), IgnoreEmptyMessages()},
+		want: true,
+	}, {
+		x:    new(testpb.TestAllTypes),
+		y:    new(testpb.TestAllTypes),
+		opts: cmp.Options{Transform()},
+		want: true,
+	}, {
+		x:    new(testpb.TestAllTypes),
+		y:    dynamicpb.NewMessage(allTypesDesc),
+		opts: cmp.Options{Transform()},
+		want: true,
+	}, {
+		x:    new(testpb.TestAllTypes),
+		y:    new(testpb.TestAllExtensions),
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x:    struct{ I interface{} }{(*testpb.TestAllTypes)(nil)},
+		y:    struct{ I interface{} }{(*testpb.TestAllTypes)(nil)},
+		opts: cmp.Options{Transform()},
+		want: true,
+	}, {
+		x:    struct{ I interface{} }{(*testpb.TestAllTypes)(nil)},
+		y:    struct{ I interface{} }{new(testpb.TestAllTypes)},
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x:    struct{ I interface{} }{(*testpb.TestAllTypes)(nil)},
+		y:    struct{ I interface{} }{dynamicpb.NewMessage(allTypesDesc)},
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x:    struct{ I interface{} }{(*testpb.TestAllTypes)(nil)},
+		y:    struct{ I interface{} }{new(testpb.TestAllTypes)},
+		opts: cmp.Options{Transform(), IgnoreEmptyMessages()},
+		want: true,
+	}, {
+		x:    struct{ I interface{} }{(*testpb.TestAllTypes)(nil)},
+		y:    struct{ I interface{} }{dynamicpb.NewMessage(allTypesDesc)},
+		opts: cmp.Options{Transform(), IgnoreEmptyMessages()},
+		want: true,
+	}, {
+		x:    struct{ I interface{} }{new(testpb.TestAllTypes)},
+		y:    struct{ I interface{} }{new(testpb.TestAllTypes)},
+		opts: cmp.Options{Transform()},
+		want: true,
+	}, {
+		x:    struct{ I interface{} }{new(testpb.TestAllTypes)},
+		y:    struct{ I interface{} }{dynamicpb.NewMessage(allTypesDesc)},
+		opts: cmp.Options{Transform()},
+		want: true,
+	}, {
+		x:    struct{ M proto.Message }{(*testpb.TestAllTypes)(nil)},
+		y:    struct{ M proto.Message }{(*testpb.TestAllTypes)(nil)},
+		opts: cmp.Options{Transform()},
+		want: true,
+	}, {
+		x:    struct{ M proto.Message }{(*testpb.TestAllTypes)(nil)},
+		y:    struct{ M proto.Message }{new(testpb.TestAllTypes)},
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x:    struct{ M proto.Message }{(*testpb.TestAllTypes)(nil)},
+		y:    struct{ M proto.Message }{dynamicpb.NewMessage(allTypesDesc)},
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x:    struct{ M proto.Message }{(*testpb.TestAllTypes)(nil)},
+		y:    struct{ M proto.Message }{new(testpb.TestAllTypes)},
+		opts: cmp.Options{Transform(), IgnoreEmptyMessages()},
+		want: true,
+	}, {
+		x:    struct{ M proto.Message }{(*testpb.TestAllTypes)(nil)},
+		y:    struct{ M proto.Message }{dynamicpb.NewMessage(allTypesDesc)},
+		opts: cmp.Options{Transform(), IgnoreEmptyMessages()},
+		want: true,
+	}, {
+		x:    struct{ M proto.Message }{new(testpb.TestAllTypes)},
+		y:    struct{ M proto.Message }{new(testpb.TestAllTypes)},
+		opts: cmp.Options{Transform()},
+		want: true,
+	}, {
+		x:    struct{ M proto.Message }{new(testpb.TestAllTypes)},
+		y:    struct{ M proto.Message }{dynamicpb.NewMessage(allTypesDesc)},
+		opts: cmp.Options{Transform()},
+		want: true,
+	}}...)
+
+	// Test message values.
+	tests = append(tests, []test{{
+		x:    testpb.TestAllTypes{OptionalSint64: proto.Int64(1)},
+		y:    testpb.TestAllTypes{OptionalSint64: proto.Int64(1)},
+		opts: cmp.Options{Transform()},
+		want: true,
+	}, {
+		x:    testpb.TestAllTypes{OptionalSint64: proto.Int64(1)},
+		y:    testpb.TestAllTypes{OptionalSint64: proto.Int64(2)},
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x:    struct{ M testpb.TestAllTypes }{M: testpb.TestAllTypes{OptionalSint64: proto.Int64(1)}},
+		y:    struct{ M testpb.TestAllTypes }{M: testpb.TestAllTypes{OptionalSint64: proto.Int64(1)}},
+		opts: cmp.Options{Transform()},
+		want: true,
+	}, {
+		x:    struct{ M testpb.TestAllTypes }{M: testpb.TestAllTypes{OptionalSint64: proto.Int64(1)}},
+		y:    struct{ M testpb.TestAllTypes }{M: testpb.TestAllTypes{OptionalSint64: proto.Int64(2)}},
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x:    struct{ M []testpb.TestAllTypes }{M: []testpb.TestAllTypes{{OptionalSint64: proto.Int64(1)}}},
+		y:    struct{ M []testpb.TestAllTypes }{M: []testpb.TestAllTypes{{OptionalSint64: proto.Int64(1)}}},
+		opts: cmp.Options{Transform()},
+		want: true,
+	}, {
+		x:    struct{ M []testpb.TestAllTypes }{M: []testpb.TestAllTypes{{OptionalSint64: proto.Int64(1)}}},
+		y:    struct{ M []testpb.TestAllTypes }{M: []testpb.TestAllTypes{{OptionalSint64: proto.Int64(2)}}},
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x: struct {
+			M map[string]testpb.TestAllTypes
+		}{
+			M: map[string]testpb.TestAllTypes{"k": {OptionalSint64: proto.Int64(1)}},
+		},
+		y: struct {
+			M map[string]testpb.TestAllTypes
+		}{
+			M: map[string]testpb.TestAllTypes{"k": {OptionalSint64: proto.Int64(1)}},
+		},
+		opts: cmp.Options{Transform()},
+		want: true,
+	}, {
+		x: struct {
+			M map[string]testpb.TestAllTypes
+		}{
+			M: map[string]testpb.TestAllTypes{"k": {OptionalSint64: proto.Int64(1)}},
+		},
+		y: struct {
+			M map[string]testpb.TestAllTypes
+		}{
+			M: map[string]testpb.TestAllTypes{"k": {OptionalSint64: proto.Int64(2)}},
+		},
+		opts: cmp.Options{Transform()},
+		want: false,
+	}}...)
+
+	// Test IgnoreUnknown.
+	raw := protopack.Message{
+		protopack.Tag{1, protopack.BytesType}, protopack.String("Hello, goodbye!"),
+	}.Marshal()
+	tests = append(tests, []test{{
+		x:    apply(&testpb.TestAllTypes{OptionalSint64: proto.Int64(5)}, setUnknown{raw}),
+		y:    &testpb.TestAllTypes{OptionalSint64: proto.Int64(5)},
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x:    apply(&testpb.TestAllTypes{OptionalSint64: proto.Int64(5)}, setUnknown{raw}),
+		y:    &testpb.TestAllTypes{OptionalSint64: proto.Int64(5)},
+		opts: cmp.Options{Transform(), IgnoreUnknown()},
+		want: true,
+	}, {
+		x:    apply(&testpb.TestAllTypes{OptionalSint64: proto.Int64(5)}, setUnknown{raw}),
+		y:    &testpb.TestAllTypes{OptionalSint64: proto.Int64(6)},
+		opts: cmp.Options{Transform(), IgnoreUnknown()},
+		want: false,
+	}, {
+		x:    apply(&testpb.TestAllTypes{OptionalSint64: proto.Int64(5)}, setUnknown{raw}),
+		y:    apply(dynamicpb.NewMessage(allTypesDesc), setField{6, int64(5)}),
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x:    apply(&testpb.TestAllTypes{OptionalSint64: proto.Int64(5)}, setUnknown{raw}),
+		y:    apply(dynamicpb.NewMessage(allTypesDesc), setField{6, int64(5)}),
+		opts: cmp.Options{Transform(), IgnoreUnknown()},
+		want: true,
+	}}...)
+
+	// Test IgnoreDefaultScalars.
+	tests = append(tests, []test{{
+		x: &testpb.TestAllTypes{
+			DefaultInt32:  proto.Int32(81),
+			DefaultUint32: proto.Uint32(83),
+			DefaultFloat:  proto.Float32(91.5),
+			DefaultBool:   proto.Bool(true),
+			DefaultBytes:  []byte("world"),
+		},
+		y: &testpb.TestAllTypes{
+			DefaultInt64:       proto.Int64(82),
+			DefaultUint64:      proto.Uint64(84),
+			DefaultDouble:      proto.Float64(92e3),
+			DefaultString:      proto.String("hello"),
+			DefaultForeignEnum: testpb.ForeignEnum_FOREIGN_BAR.Enum(),
+		},
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x: &testpb.TestAllTypes{
+			DefaultInt32:  proto.Int32(81),
+			DefaultUint32: proto.Uint32(83),
+			DefaultFloat:  proto.Float32(91.5),
+			DefaultBool:   proto.Bool(true),
+			DefaultBytes:  []byte("world"),
+		},
+		y: &testpb.TestAllTypes{
+			DefaultInt64:       proto.Int64(82),
+			DefaultUint64:      proto.Uint64(84),
+			DefaultDouble:      proto.Float64(92e3),
+			DefaultString:      proto.String("hello"),
+			DefaultForeignEnum: testpb.ForeignEnum_FOREIGN_BAR.Enum(),
+		},
+		opts: cmp.Options{Transform(), IgnoreDefaultScalars()},
+		want: true,
+	}, {
+		x: &testpb.TestAllTypes{
+			OptionalInt32:  proto.Int32(81),
+			OptionalUint32: proto.Uint32(83),
+			OptionalFloat:  proto.Float32(91.5),
+			OptionalBool:   proto.Bool(true),
+			OptionalBytes:  []byte("world"),
+		},
+		y: &testpb.TestAllTypes{
+			OptionalInt64:       proto.Int64(82),
+			OptionalUint64:      proto.Uint64(84),
+			OptionalDouble:      proto.Float64(92e3),
+			OptionalString:      proto.String("hello"),
+			OptionalForeignEnum: testpb.ForeignEnum_FOREIGN_BAR.Enum(),
+		},
+		opts: cmp.Options{Transform(), IgnoreDefaultScalars()},
+		want: false,
+	}, {
+		x: &testpb.TestAllTypes{
+			OptionalInt32:  proto.Int32(0),
+			OptionalUint32: proto.Uint32(0),
+			OptionalFloat:  proto.Float32(0),
+			OptionalBool:   proto.Bool(false),
+			OptionalBytes:  []byte(""),
+		},
+		y: &testpb.TestAllTypes{
+			OptionalInt64:       proto.Int64(0),
+			OptionalUint64:      proto.Uint64(0),
+			OptionalDouble:      proto.Float64(0),
+			OptionalString:      proto.String(""),
+			OptionalForeignEnum: testpb.ForeignEnum_FOREIGN_FOO.Enum(),
+		},
+		opts: cmp.Options{Transform(), IgnoreDefaultScalars()},
+		want: true,
+	}, {
+		x: apply(new(testpb.TestAllExtensions),
+			setExtension{testpb.E_DefaultInt32, int32(81)},
+			setExtension{testpb.E_DefaultUint32, uint32(83)},
+			setExtension{testpb.E_DefaultFloat, float32(91.5)},
+			setExtension{testpb.E_DefaultBool, bool(true)},
+			setExtension{testpb.E_DefaultBytes, []byte("world")}),
+		y: apply(new(testpb.TestAllExtensions),
+			setExtension{testpb.E_DefaultInt64, int64(82)},
+			setExtension{testpb.E_DefaultUint64, uint64(84)},
+			setExtension{testpb.E_DefaultDouble, float64(92e3)},
+			setExtension{testpb.E_DefaultString, string("hello")}),
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x: apply(new(testpb.TestAllExtensions),
+			setExtension{testpb.E_DefaultInt32, int32(81)},
+			setExtension{testpb.E_DefaultUint32, uint32(83)},
+			setExtension{testpb.E_DefaultFloat, float32(91.5)},
+			setExtension{testpb.E_DefaultBool, bool(true)},
+			setExtension{testpb.E_DefaultBytes, []byte("world")}),
+		y: apply(new(testpb.TestAllExtensions),
+			setExtension{testpb.E_DefaultInt64, int64(82)},
+			setExtension{testpb.E_DefaultUint64, uint64(84)},
+			setExtension{testpb.E_DefaultDouble, float64(92e3)},
+			setExtension{testpb.E_DefaultString, string("hello")}),
+		opts: cmp.Options{Transform(), IgnoreDefaultScalars()},
+		want: true,
+	}, {
+		x: apply(new(testpb.TestAllExtensions),
+			setExtension{testpb.E_OptionalInt32, int32(0)},
+			setExtension{testpb.E_OptionalUint32, uint32(0)},
+			setExtension{testpb.E_OptionalFloat, float32(0)},
+			setExtension{testpb.E_OptionalBool, bool(false)},
+			setExtension{testpb.E_OptionalBytes, []byte("")}),
+		y: apply(new(testpb.TestAllExtensions),
+			setExtension{testpb.E_OptionalInt64, int64(0)},
+			setExtension{testpb.E_OptionalUint64, uint64(0)},
+			setExtension{testpb.E_OptionalDouble, float64(0)},
+			setExtension{testpb.E_OptionalString, string("")}),
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x: apply(new(testpb.TestAllExtensions),
+			setExtension{testpb.E_OptionalInt32, int32(0)},
+			setExtension{testpb.E_OptionalUint32, uint32(0)},
+			setExtension{testpb.E_OptionalFloat, float32(0)},
+			setExtension{testpb.E_OptionalBool, bool(false)},
+			setExtension{testpb.E_OptionalBytes, []byte("")}),
+		y: apply(new(testpb.TestAllExtensions),
+			setExtension{testpb.E_OptionalInt64, int64(0)},
+			setExtension{testpb.E_OptionalUint64, uint64(0)},
+			setExtension{testpb.E_OptionalDouble, float64(0)},
+			setExtension{testpb.E_OptionalString, string("")}),
+		opts: cmp.Options{Transform(), IgnoreDefaultScalars()},
+		want: true,
+	}, {
+		x: &testpb.TestAllTypes{
+			DefaultFloat: proto.Float32(91.6),
+		},
+		y:    &testpb.TestAllTypes{},
+		opts: cmp.Options{Transform(), IgnoreDefaultScalars()},
+		want: false,
+	}, {
+		x: &testpb.TestAllTypes{
+			OptionalForeignMessage: &testpb.ForeignMessage{},
+		},
+		y:    &testpb.TestAllTypes{},
+		opts: cmp.Options{Transform(), IgnoreDefaultScalars()},
+		want: false,
+	}}...)
+
+	// Test IgnoreEmptyMessages.
+	tests = append(tests, []test{{
+		x:    []*testpb.TestAllTypes{nil, {}, {OptionalInt32: proto.Int32(5)}},
+		y:    []*testpb.TestAllTypes{nil, {}, {OptionalInt32: proto.Int32(5)}},
+		opts: cmp.Options{Transform()},
+		want: true,
+	}, {
+		x:    []*testpb.TestAllTypes{nil, {}, {OptionalInt32: proto.Int32(5)}},
+		y:    []*testpb.TestAllTypes{{OptionalInt32: proto.Int32(5)}},
+		opts: cmp.Options{Transform(), IgnoreEmptyMessages()},
+		want: false,
+	}, {
+		x:    &testpb.TestAllTypes{OptionalForeignMessage: &testpb.ForeignMessage{}},
+		y:    &testpb.TestAllTypes{OptionalForeignMessage: nil},
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x:    &testpb.TestAllTypes{OptionalForeignMessage: &testpb.ForeignMessage{}},
+		y:    &testpb.TestAllTypes{OptionalForeignMessage: nil},
+		opts: cmp.Options{Transform(), IgnoreEmptyMessages()},
+		want: true,
+	}, {
+		x:    &testpb.TestAllTypes{OptionalForeignMessage: &testpb.ForeignMessage{C: proto.Int32(5)}},
+		y:    &testpb.TestAllTypes{OptionalForeignMessage: nil},
+		opts: cmp.Options{Transform(), IgnoreEmptyMessages()},
+		want: false,
+	}, {
+		x:    &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{}},
+		y:    &testpb.TestAllTypes{RepeatedForeignMessage: nil},
+		opts: cmp.Options{Transform()},
+		want: true,
+	}, {
+		x:    &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{nil, {}}},
+		y:    &testpb.TestAllTypes{RepeatedForeignMessage: nil},
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x:    &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{nil, {}}},
+		y:    &testpb.TestAllTypes{RepeatedForeignMessage: nil},
+		opts: cmp.Options{Transform(), IgnoreEmptyMessages()},
+		want: true,
+	}, {
+		x:    &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{nil, {C: proto.Int32(5)}, {}}},
+		y:    &testpb.TestAllTypes{RepeatedForeignMessage: nil},
+		opts: cmp.Options{Transform(), IgnoreEmptyMessages()},
+		want: false,
+	}, {
+		x:    &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{nil, {C: proto.Int32(5)}, {}}},
+		y:    &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{{}, {}, nil, {}, {C: proto.Int32(5)}, {}}},
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x:    &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{nil, {C: proto.Int32(5)}, {}}},
+		y:    &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{{}, {}, nil, {}, {C: proto.Int32(5)}, {}}},
+		opts: cmp.Options{Transform(), IgnoreEmptyMessages()},
+		want: true,
+	}, {
+		x:    &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{}},
+		y:    &testpb.TestAllTypes{MapStringNestedMessage: nil},
+		opts: cmp.Options{Transform()},
+		want: true,
+	}, {
+		x:    &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"1": nil, "2": {}}},
+		y:    &testpb.TestAllTypes{MapStringNestedMessage: nil},
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x:    &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"1": nil, "2": {}}},
+		y:    &testpb.TestAllTypes{MapStringNestedMessage: nil},
+		opts: cmp.Options{Transform(), IgnoreEmptyMessages()},
+		want: true,
+	}, {
+		x:    &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"1": nil, "2": {A: proto.Int32(5)}, "3": {}}},
+		y:    &testpb.TestAllTypes{MapStringNestedMessage: nil},
+		opts: cmp.Options{Transform(), IgnoreEmptyMessages()},
+		want: false,
+	}, {
+		x:    &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"1": nil, "2": {A: proto.Int32(5)}, "3": {}}},
+		y:    &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"1": {}, "1a": {}, "1b": nil, "2": {A: proto.Int32(5)}, "4": {}}},
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x:    &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"1": nil, "2": {A: proto.Int32(5)}, "3": {}}},
+		y:    &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"1": {}, "1a": {}, "1b": nil, "2": {A: proto.Int32(5)}, "4": {}}},
+		opts: cmp.Options{Transform(), IgnoreEmptyMessages()},
+		want: true,
+	}}...)
+
+	// Test IgnoreEnums and IgnoreMessages.
+	tests = append(tests, []test{{
+		x: &testpb.TestAllTypes{
+			OptionalNestedMessage:  &testpb.TestAllTypes_NestedMessage{A: proto.Int32(1)},
+			RepeatedNestedMessage:  []*testpb.TestAllTypes_NestedMessage{{A: proto.Int32(2)}},
+			MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"3": {A: proto.Int32(3)}},
+		},
+		y:    &testpb.TestAllTypes{},
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x: &testpb.TestAllTypes{
+			OptionalNestedMessage:  &testpb.TestAllTypes_NestedMessage{A: proto.Int32(1)},
+			RepeatedNestedMessage:  []*testpb.TestAllTypes_NestedMessage{{A: proto.Int32(2)}},
+			MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"3": {A: proto.Int32(3)}},
+		},
+		y:    &testpb.TestAllTypes{},
+		opts: cmp.Options{Transform(), IgnoreMessages(&testpb.TestAllTypes{})},
+		want: true,
+	}, {
+		x: &testpb.TestAllTypes{
+			OptionalNestedEnum:  testpb.TestAllTypes_FOO.Enum(),
+			RepeatedNestedEnum:  []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAR},
+			MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{"baz": testpb.TestAllTypes_BAZ},
+		},
+		y:    &testpb.TestAllTypes{},
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x: &testpb.TestAllTypes{
+			OptionalNestedEnum:  testpb.TestAllTypes_FOO.Enum(),
+			RepeatedNestedEnum:  []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAR},
+			MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{"baz": testpb.TestAllTypes_BAZ},
+		},
+		y:    &testpb.TestAllTypes{},
+		opts: cmp.Options{Transform(), IgnoreEnums(testpb.TestAllTypes_NestedEnum(0))},
+		want: true,
+	}, {
+		x: &testpb.TestAllTypes{
+			OptionalNestedEnum:  testpb.TestAllTypes_FOO.Enum(),
+			RepeatedNestedEnum:  []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAR},
+			MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{"baz": testpb.TestAllTypes_BAZ},
+
+			OptionalNestedMessage:  &testpb.TestAllTypes_NestedMessage{A: proto.Int32(1)},
+			RepeatedNestedMessage:  []*testpb.TestAllTypes_NestedMessage{{A: proto.Int32(2)}},
+			MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"3": {A: proto.Int32(3)}},
+		},
+		y: &testpb.TestAllTypes{},
+		opts: cmp.Options{Transform(),
+			IgnoreMessages(&testpb.TestAllExtensions{}),
+			IgnoreEnums(testpb.ForeignEnum(0)),
+		},
+		want: false,
+	}}...)
+
+	// Test IgnoreFields and IgnoreOneofs.
+	tests = append(tests, []test{{
+		x:    &testpb.TestAllTypes{OptionalInt32: proto.Int32(5)},
+		y:    &testpb.TestAllTypes{OptionalInt32: proto.Int32(6)},
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x: &testpb.TestAllTypes{OptionalInt32: proto.Int32(5)},
+		y: &testpb.TestAllTypes{},
+		opts: cmp.Options{Transform(),
+			IgnoreFields(&testpb.TestAllTypes{}, "optional_int32")},
+		want: true,
+	}, {
+		x: &testpb.TestAllTypes{OptionalInt32: proto.Int32(5)},
+		y: &testpb.TestAllTypes{OptionalInt32: proto.Int32(6)},
+		opts: cmp.Options{Transform(),
+			IgnoreFields(&testpb.TestAllTypes{}, "optional_int32")},
+		want: true,
+	}, {
+		x: &testpb.TestAllTypes{OptionalInt32: proto.Int32(5)},
+		y: &testpb.TestAllTypes{OptionalInt32: proto.Int32(6)},
+		opts: cmp.Options{Transform(),
+			IgnoreFields(&testpb.TestAllTypes{}, "optional_int64")},
+		want: false,
+	}, {
+		x:    &testpb.TestAllTypes{OneofField: &testpb.TestAllTypes_OneofUint32{5}},
+		y:    &testpb.TestAllTypes{OneofField: &testpb.TestAllTypes_OneofString{"5"}},
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x: &testpb.TestAllTypes{OneofField: &testpb.TestAllTypes_OneofUint32{5}},
+		y: &testpb.TestAllTypes{OneofField: &testpb.TestAllTypes_OneofString{"5"}},
+		opts: cmp.Options{Transform(),
+			IgnoreFields(&testpb.TestAllTypes{}, "oneof_uint32"),
+			IgnoreFields(&testpb.TestAllTypes{}, "oneof_string")},
+		want: true,
+	}, {
+		x: &testpb.TestAllTypes{OneofField: &testpb.TestAllTypes_OneofUint32{5}},
+		y: &testpb.TestAllTypes{OneofField: &testpb.TestAllTypes_OneofString{"5"}},
+		opts: cmp.Options{Transform(),
+			IgnoreOneofs(&testpb.TestAllTypes{}, "oneof_field")},
+		want: true,
+	}, {
+		x: apply(new(testpb.TestAllExtensions),
+			setExtension{testpb.E_OptionalString, "hello"}),
+		y: apply(new(testpb.TestAllExtensions),
+			setExtension{testpb.E_OptionalString, "goodbye"}),
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x: apply(new(testpb.TestAllExtensions),
+			setExtension{testpb.E_OptionalString, "hello"}),
+		y: new(testpb.TestAllExtensions),
+		opts: cmp.Options{Transform(),
+			IgnoreDescriptors(testpb.E_OptionalString.TypeDescriptor())},
+		want: true,
+	}, {
+		x: apply(new(testpb.TestAllExtensions),
+			setExtension{testpb.E_OptionalString, "hello"}),
+		y: apply(new(testpb.TestAllExtensions),
+			setExtension{testpb.E_OptionalString, "goodbye"}),
+		opts: cmp.Options{Transform(),
+			IgnoreDescriptors(testpb.E_OptionalString.TypeDescriptor())},
+		want: true,
+	}, {
+		x: apply(new(testpb.TestAllExtensions),
+			setExtension{testpb.E_OptionalString, "hello"}),
+		y: apply(new(testpb.TestAllExtensions),
+			setExtension{testpb.E_OptionalString, "goodbye"}),
+		opts: cmp.Options{Transform(),
+			IgnoreDescriptors(testpb.E_OptionalInt32.TypeDescriptor())},
+		want: false,
+	}}...)
+
+	// Test FilterEnum.
+	tests = append(tests, []test{{
+		x:    &testpb.TestAllTypes{OptionalNestedEnum: testpb.TestAllTypes_FOO.Enum()},
+		y:    &testpb.TestAllTypes{OptionalNestedEnum: testpb.TestAllTypes_BAR.Enum()},
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x: &testpb.TestAllTypes{OptionalNestedEnum: testpb.TestAllTypes_FOO.Enum()},
+		y: &testpb.TestAllTypes{OptionalNestedEnum: testpb.TestAllTypes_BAR.Enum()},
+		opts: cmp.Options{
+			Transform(),
+			FilterEnum(testpb.ForeignEnum(0), cmp.Comparer(func(x, y interface{}) bool { return true })),
+		},
+		want: false, // mismatching filter type
+	}, {
+		x: &testpb.TestAllTypes{OptionalNestedEnum: testpb.TestAllTypes_FOO.Enum()},
+		y: &testpb.TestAllTypes{OptionalNestedEnum: testpb.TestAllTypes_BAR.Enum()},
+		opts: cmp.Options{
+			Transform(),
+			FilterEnum(testpb.TestAllTypes_NestedEnum(0), cmp.Comparer(func(x, y int) bool { return true })),
+		},
+		want: false, // matching filter type, but mismatching comparer type
+	}, {
+		x: &testpb.TestAllTypes{OptionalNestedEnum: testpb.TestAllTypes_FOO.Enum()},
+		y: &testpb.TestAllTypes{OptionalNestedEnum: testpb.TestAllTypes_BAR.Enum()},
+		opts: cmp.Options{
+			Transform(),
+			FilterEnum(testpb.TestAllTypes_NestedEnum(0), cmp.Comparer(func(x, y testpb.TestAllTypes_NestedEnum) bool { return true })),
+		},
+		want: false, // matching filter type, but mismatching comparer type
+	}, {
+		x: &testpb.TestAllTypes{OptionalNestedEnum: testpb.TestAllTypes_FOO.Enum()},
+		y: &testpb.TestAllTypes{OptionalNestedEnum: testpb.TestAllTypes_BAR.Enum()},
+		opts: cmp.Options{
+			Transform(),
+			FilterEnum(testpb.TestAllTypes_NestedEnum(0), cmp.Comparer(func(x, y interface{}) bool { return true })),
+		},
+		want: true,
+	}, {
+		x: &testpb.TestAllTypes{OptionalNestedEnum: testpb.TestAllTypes_FOO.Enum()},
+		y: &testpb.TestAllTypes{OptionalNestedEnum: testpb.TestAllTypes_BAR.Enum()},
+		opts: cmp.Options{
+			Transform(),
+			FilterEnum(testpb.TestAllTypes_NestedEnum(0), cmp.Comparer(func(x, y Enum) bool { return true })),
+		},
+		want: true,
+	}, {
+		x:    &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_FOO}},
+		y:    &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAR}},
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_FOO}},
+		y: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAR}},
+		opts: cmp.Options{
+			Transform(),
+			FilterEnum(testpb.ForeignEnum(0), cmp.Comparer(func(x, y interface{}) bool { return true })),
+		},
+		want: false, // mismatching filter type
+	}, {
+		x: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_FOO}},
+		y: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAR}},
+		opts: cmp.Options{
+			Transform(),
+			FilterEnum(testpb.TestAllTypes_NestedEnum(0), cmp.Comparer(func(x, y int) bool { return true })),
+		},
+		want: false, // matching filter type, but mismatching comparer type
+	}, {
+		x: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_FOO}},
+		y: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAR}},
+		opts: cmp.Options{
+			Transform(),
+			FilterEnum(testpb.TestAllTypes_NestedEnum(0), cmp.Comparer(func(x, y []testpb.TestAllTypes_NestedEnum) bool { return true })),
+		},
+		want: false, // matching filter type, but mismatching comparer type
+	}, {
+		x: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_FOO}},
+		y: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAR}},
+		opts: cmp.Options{
+			Transform(),
+			FilterEnum(testpb.TestAllTypes_NestedEnum(0), cmp.Comparer(func(x, y interface{}) bool { return true })),
+		},
+		want: true,
+	}, {
+		x: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_FOO}},
+		y: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAR}},
+		opts: cmp.Options{
+			Transform(),
+			FilterEnum(testpb.TestAllTypes_NestedEnum(0), cmp.Comparer(func(x, y []Enum) bool { return true })),
+		},
+		want: true,
+	}, {
+		x:    &testpb.TestAllTypes{MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{"k": testpb.TestAllTypes_FOO}},
+		y:    &testpb.TestAllTypes{MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{"k": testpb.TestAllTypes_BAR}},
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x: &testpb.TestAllTypes{MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{"k": testpb.TestAllTypes_FOO}},
+		y: &testpb.TestAllTypes{MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{"k": testpb.TestAllTypes_BAR}},
+		opts: cmp.Options{
+			Transform(),
+			FilterEnum(testpb.ForeignEnum(0), cmp.Comparer(func(x, y interface{}) bool { return true })),
+		},
+		want: false, // mismatching filter type
+	}, {
+		x: &testpb.TestAllTypes{MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{"k": testpb.TestAllTypes_FOO}},
+		y: &testpb.TestAllTypes{MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{"k": testpb.TestAllTypes_BAR}},
+		opts: cmp.Options{
+			Transform(),
+			FilterEnum(testpb.TestAllTypes_NestedEnum(0), cmp.Comparer(func(x, y int) bool { return true })),
+		},
+		want: false, // matching filter type, but mismatching comparer type
+	}, {
+		x: &testpb.TestAllTypes{MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{"k": testpb.TestAllTypes_FOO}},
+		y: &testpb.TestAllTypes{MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{"k": testpb.TestAllTypes_BAR}},
+		opts: cmp.Options{
+			Transform(),
+			FilterEnum(testpb.TestAllTypes_NestedEnum(0), cmp.Comparer(func(x, y map[string]testpb.TestAllTypes_NestedEnum) bool { return true })),
+		},
+		want: false, // matching filter type, but mismatching comparer type
+	}, {
+		x: &testpb.TestAllTypes{MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{"k": testpb.TestAllTypes_FOO}},
+		y: &testpb.TestAllTypes{MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{"k": testpb.TestAllTypes_BAR}},
+		opts: cmp.Options{
+			Transform(),
+			FilterEnum(testpb.TestAllTypes_NestedEnum(0), cmp.Comparer(func(x, y interface{}) bool { return true })),
+		},
+		want: true,
+	}, {
+		x: &testpb.TestAllTypes{MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{"k": testpb.TestAllTypes_FOO}},
+		y: &testpb.TestAllTypes{MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{"k": testpb.TestAllTypes_BAR}},
+		opts: cmp.Options{
+			Transform(),
+			FilterEnum(testpb.TestAllTypes_NestedEnum(0), cmp.Comparer(func(x, y map[string]Enum) bool { return true })),
+		},
+		want: true,
+	}}...)
+
+	// Test FilterMessage.
+	tests = append(tests, []test{{
+		x:    &testpb.TestAllTypes{OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{A: proto.Int32(1)}},
+		y:    &testpb.TestAllTypes{OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{A: proto.Int32(2)}},
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x: &testpb.TestAllTypes{OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{A: proto.Int32(1)}},
+		y: &testpb.TestAllTypes{OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{A: proto.Int32(2)}},
+		opts: cmp.Options{
+			Transform(),
+			FilterMessage(new(testpb.TestAllExtensions), cmp.Comparer(func(x, y interface{}) bool { return true })),
+		},
+		want: false, // mismatching filter type
+	}, {
+		x: &testpb.TestAllTypes{OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{A: proto.Int32(1)}},
+		y: &testpb.TestAllTypes{OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{A: proto.Int32(2)}},
+		opts: cmp.Options{
+			Transform(),
+			FilterMessage(new(testpb.TestAllTypes_NestedMessage), cmp.Comparer(func(x, y int) bool { return true })),
+		},
+		want: false, // matching filter type, but mismatching comparer type
+	}, {
+		x: &testpb.TestAllTypes{OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{A: proto.Int32(1)}},
+		y: &testpb.TestAllTypes{OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{A: proto.Int32(2)}},
+		opts: cmp.Options{
+			Transform(),
+			FilterMessage(new(testpb.TestAllTypes_NestedMessage), cmp.Comparer(func(x, y *testpb.TestAllTypes_NestedMessage) bool { return true })),
+		},
+		want: false, // matching filter type, but mismatching comparer type
+	}, {
+		x: &testpb.TestAllTypes{OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{A: proto.Int32(1)}},
+		y: &testpb.TestAllTypes{OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{A: proto.Int32(2)}},
+		opts: cmp.Options{
+			Transform(),
+			FilterMessage(new(testpb.TestAllTypes_NestedMessage), cmp.Comparer(func(x, y interface{}) bool { return true })),
+		},
+		want: true,
+	}, {
+		x: &testpb.TestAllTypes{OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{A: proto.Int32(1)}},
+		y: &testpb.TestAllTypes{OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{A: proto.Int32(2)}},
+		opts: cmp.Options{
+			Transform(),
+			FilterMessage(new(testpb.TestAllTypes_NestedMessage), cmp.Comparer(func(x, y Message) bool { return true })),
+		},
+		want: true,
+	}, {
+		x:    &testpb.TestAllTypes{RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{{A: proto.Int32(1)}}},
+		y:    &testpb.TestAllTypes{RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{{A: proto.Int32(2)}}},
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x: &testpb.TestAllTypes{RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{{A: proto.Int32(1)}}},
+		y: &testpb.TestAllTypes{RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{{A: proto.Int32(2)}}},
+		opts: cmp.Options{
+			Transform(),
+			FilterMessage(new(testpb.TestAllExtensions), cmp.Comparer(func(x, y interface{}) bool { return true })),
+		},
+		want: false, // mismatching filter type
+	}, {
+		x: &testpb.TestAllTypes{RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{{A: proto.Int32(1)}}},
+		y: &testpb.TestAllTypes{RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{{A: proto.Int32(2)}}},
+		opts: cmp.Options{
+			Transform(),
+			FilterMessage(new(testpb.TestAllTypes_NestedMessage), cmp.Comparer(func(x, y int) bool { return true })),
+		},
+		want: false, // matching filter type, but mismatching comparer type
+	}, {
+		x: &testpb.TestAllTypes{RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{{A: proto.Int32(1)}}},
+		y: &testpb.TestAllTypes{RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{{A: proto.Int32(2)}}},
+		opts: cmp.Options{
+			Transform(),
+			FilterMessage(new(testpb.TestAllTypes_NestedMessage), cmp.Comparer(func(x, y []*testpb.TestAllTypes_NestedMessage) bool { return true })),
+		},
+		want: false, // matching filter type, but mismatching comparer type
+	}, {
+		x: &testpb.TestAllTypes{RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{{A: proto.Int32(1)}}},
+		y: &testpb.TestAllTypes{RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{{A: proto.Int32(2)}}},
+		opts: cmp.Options{
+			Transform(),
+			FilterMessage(new(testpb.TestAllTypes_NestedMessage), cmp.Comparer(func(x, y interface{}) bool { return true })),
+		},
+		want: true,
+	}, {
+		x: &testpb.TestAllTypes{RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{{A: proto.Int32(1)}}},
+		y: &testpb.TestAllTypes{RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{{A: proto.Int32(2)}}},
+		opts: cmp.Options{
+			Transform(),
+			FilterMessage(new(testpb.TestAllTypes_NestedMessage), cmp.Comparer(func(x, y []Message) bool { return true })),
+		},
+		want: true,
+	}, {
+		x:    &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"k": {A: proto.Int32(1)}}},
+		y:    &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"k": {A: proto.Int32(2)}}},
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x: &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"k": {A: proto.Int32(1)}}},
+		y: &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"k": {A: proto.Int32(2)}}},
+		opts: cmp.Options{
+			Transform(),
+			FilterMessage(new(testpb.TestAllExtensions), cmp.Comparer(func(x, y interface{}) bool { return true })),
+		},
+		want: false, // mismatching filter type
+	}, {
+		x: &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"k": {A: proto.Int32(1)}}},
+		y: &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"k": {A: proto.Int32(2)}}},
+		opts: cmp.Options{
+			Transform(),
+			FilterMessage(new(testpb.TestAllTypes_NestedMessage), cmp.Comparer(func(x, y int) bool { return true })),
+		},
+		want: false, // matching filter type, but mismatching comparer type
+	}, {
+		x: &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"k": {A: proto.Int32(1)}}},
+		y: &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"k": {A: proto.Int32(2)}}},
+		opts: cmp.Options{
+			Transform(),
+			FilterMessage(new(testpb.TestAllTypes_NestedMessage), cmp.Comparer(func(x, y map[string]*testpb.TestAllTypes_NestedMessage) bool { return true })),
+		},
+		want: false, // matching filter type, but mismatching comparer type
+	}, {
+		x: &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"k": {A: proto.Int32(1)}}},
+		y: &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"k": {A: proto.Int32(2)}}},
+		opts: cmp.Options{
+			Transform(),
+			FilterMessage(new(testpb.TestAllTypes_NestedMessage), cmp.Comparer(func(x, y interface{}) bool { return true })),
+		},
+		want: true,
+	}, {
+		x: &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"k": {A: proto.Int32(1)}}},
+		y: &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"k": {A: proto.Int32(2)}}},
+		opts: cmp.Options{
+			Transform(),
+			FilterMessage(new(testpb.TestAllTypes_NestedMessage), cmp.Comparer(func(x, y map[string]Message) bool { return true })),
+		},
+		want: true,
+	}}...)
+
+	// Test FilterField.
+	tests = append(tests, []test{{
+		x:    &testpb.TestAllTypes{OptionalInt32: proto.Int32(1)},
+		y:    &testpb.TestAllTypes{OptionalInt32: proto.Int32(2)},
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x: &testpb.TestAllTypes{OptionalInt32: proto.Int32(1)},
+		y: &testpb.TestAllTypes{OptionalInt32: proto.Int32(2)},
+		opts: cmp.Options{
+			Transform(),
+			FilterField(new(testpb.TestAllTypes), "optional_int64", cmp.Comparer(func(x, y interface{}) bool { return true })),
+		},
+		want: false, // mismatching filter name
+	}, {
+		x: &testpb.TestAllTypes{OptionalInt32: proto.Int32(1)},
+		y: &testpb.TestAllTypes{OptionalInt32: proto.Int32(2)},
+		opts: cmp.Options{
+			Transform(),
+			FilterField(new(testpb.TestAllTypes), "optional_int32", cmp.Comparer(func(x, y int64) bool { return true })),
+		},
+		want: false, // matching filter name, but mismatching comparer type
+	}, {
+		x: &testpb.TestAllTypes{OptionalInt32: proto.Int32(1)},
+		y: &testpb.TestAllTypes{OptionalInt32: proto.Int32(2)},
+		opts: cmp.Options{
+			Transform(),
+			FilterField(new(testpb.TestAllTypes), "optional_int32", cmp.Comparer(func(x, y interface{}) bool { return true })),
+		},
+		want: true,
+	}, {
+		x: &testpb.TestAllTypes{OptionalInt32: proto.Int32(1)},
+		y: &testpb.TestAllTypes{OptionalInt32: proto.Int32(2)},
+		opts: cmp.Options{
+			Transform(),
+			FilterField(new(testpb.TestAllTypes), "optional_int32", cmp.Comparer(func(x, y int32) bool { return true })),
+		},
+		want: true,
+	}, {
+		x:    &testpb.TestAllTypes{RepeatedInt32: []int32{1}},
+		y:    &testpb.TestAllTypes{RepeatedInt32: []int32{2}},
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x: &testpb.TestAllTypes{RepeatedInt32: []int32{1}},
+		y: &testpb.TestAllTypes{RepeatedInt32: []int32{2}},
+		opts: cmp.Options{
+			Transform(),
+			FilterField(new(testpb.TestAllTypes), "repeated_int64", cmp.Comparer(func(x, y interface{}) bool { return true })),
+		},
+		want: false, // mismatching filter name
+	}, {
+		x: &testpb.TestAllTypes{RepeatedInt32: []int32{1}},
+		y: &testpb.TestAllTypes{RepeatedInt32: []int32{2}},
+		opts: cmp.Options{
+			Transform(),
+			FilterField(new(testpb.TestAllTypes), "repeated_int32", cmp.Comparer(func(x, y []int64) bool { return true })),
+		},
+		want: false, // matching filter name, but mismatching comparer type
+	}, {
+		x: &testpb.TestAllTypes{RepeatedInt32: []int32{1}},
+		y: &testpb.TestAllTypes{RepeatedInt32: []int32{2}},
+		opts: cmp.Options{
+			Transform(),
+			FilterField(new(testpb.TestAllTypes), "repeated_int32", cmp.Comparer(func(x, y interface{}) bool { return true })),
+		},
+		want: true,
+	}, {
+		x: &testpb.TestAllTypes{RepeatedInt32: []int32{1}},
+		y: &testpb.TestAllTypes{RepeatedInt32: []int32{2}},
+		opts: cmp.Options{
+			Transform(),
+			FilterField(new(testpb.TestAllTypes), "repeated_int32", cmp.Comparer(func(x, y []int32) bool { return true })),
+		},
+		want: true,
+	}, {
+		x:    &testpb.TestAllTypes{MapInt32Int32: map[int32]int32{1: 1}},
+		y:    &testpb.TestAllTypes{MapInt32Int32: map[int32]int32{2: 2}},
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x: &testpb.TestAllTypes{MapInt32Int32: map[int32]int32{1: 1}},
+		y: &testpb.TestAllTypes{MapInt32Int32: map[int32]int32{2: 2}},
+		opts: cmp.Options{
+			Transform(),
+			FilterField(new(testpb.TestAllTypes), "map_int64_int64", cmp.Comparer(func(x, y interface{}) bool { return true })),
+		},
+		want: false, // mismatching filter name
+	}, {
+		x: &testpb.TestAllTypes{MapInt32Int32: map[int32]int32{1: 1}},
+		y: &testpb.TestAllTypes{MapInt32Int32: map[int32]int32{2: 2}},
+		opts: cmp.Options{
+			Transform(),
+			FilterField(new(testpb.TestAllTypes), "map_int32_int32", cmp.Comparer(func(x, y map[int64]int64) bool { return true })),
+		},
+		want: false, // matching filter name, but mismatching comparer type
+	}, {
+		x: &testpb.TestAllTypes{MapInt32Int32: map[int32]int32{1: 1}},
+		y: &testpb.TestAllTypes{MapInt32Int32: map[int32]int32{2: 2}},
+		opts: cmp.Options{
+			Transform(),
+			FilterField(new(testpb.TestAllTypes), "map_int32_int32", cmp.Comparer(func(x, y interface{}) bool { return true })),
+		},
+		want: true,
+	}, {
+		x: &testpb.TestAllTypes{MapInt32Int32: map[int32]int32{1: 1}},
+		y: &testpb.TestAllTypes{MapInt32Int32: map[int32]int32{2: 2}},
+		opts: cmp.Options{
+			Transform(),
+			FilterField(new(testpb.TestAllTypes), "map_int32_int32", cmp.Comparer(func(x, y map[int32]int32) bool { return true })),
+		},
+		want: true,
+	}}...)
+
+	// Test FilterOneof
+	tests = append(tests, []test{{
+		x:    &testpb.TestAllTypes{OneofField: &testpb.TestAllTypes_OneofUint32{1}},
+		y:    &testpb.TestAllTypes{OneofField: &testpb.TestAllTypes_OneofUint32{2}},
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x: &testpb.TestAllTypes{OneofField: &testpb.TestAllTypes_OneofUint32{1}},
+		y: &testpb.TestAllTypes{OneofField: &testpb.TestAllTypes_OneofUint32{2}},
+		opts: cmp.Options{
+			Transform(),
+			FilterOneof(new(testpb.TestAllTypes), "oneof_optional", cmp.Comparer(func(x, y interface{}) bool { return true })),
+		},
+		want: false, // mismatching filter name
+	}, {
+		x: &testpb.TestAllTypes{OneofField: &testpb.TestAllTypes_OneofUint32{1}},
+		y: &testpb.TestAllTypes{OneofField: &testpb.TestAllTypes_OneofUint32{2}},
+		opts: cmp.Options{
+			Transform(),
+			FilterOneof(new(testpb.TestAllTypes), "oneof_field", cmp.Comparer(func(x, y string) bool { return true })),
+		},
+		want: false, // matching filter name, but mismatching comparer type
+	}, {
+		x: &testpb.TestAllTypes{OneofField: &testpb.TestAllTypes_OneofUint32{1}},
+		y: &testpb.TestAllTypes{OneofField: &testpb.TestAllTypes_OneofUint32{2}},
+		opts: cmp.Options{
+			Transform(),
+			FilterOneof(new(testpb.TestAllTypes), "oneof_field", cmp.Comparer(func(x, y uint32) bool { return true })),
+		},
+		want: true,
+	}, {
+		x: &testpb.TestAllTypes{OneofField: &testpb.TestAllTypes_OneofUint32{1}},
+		y: &testpb.TestAllTypes{OneofField: &testpb.TestAllTypes_OneofUint32{2}},
+		opts: cmp.Options{
+			Transform(),
+			FilterOneof(new(testpb.TestAllTypes), "oneof_field", cmp.Comparer(func(x, y interface{}) bool { return true })),
+		},
+		want: true,
+	}}...)
+
+	// Test SortRepeated.
+	type higherOrderType struct {
+		M    *testpb.TestAllTypes
+		I32s []int32
+		Es   []testpb.TestAllTypes_NestedEnum
+		Ms   []*testpb.ForeignMessage
+	}
+	tests = append(tests, []test{{
+		x:    &testpb.TestAllTypes{RepeatedInt32: []int32{3, 2, 1, 2, 3, 3}},
+		y:    &testpb.TestAllTypes{RepeatedInt32: []int32{2, 3, 3, 2, 1, 3}},
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x: &testpb.TestAllTypes{RepeatedInt32: []int32{3, 2, 1, 2, 3, 3}},
+		y: &testpb.TestAllTypes{RepeatedInt32: []int32{2, 3, 3, 2, 1, 3}},
+		opts: cmp.Options{
+			Transform(),
+			SortRepeated(func(x, y int32) bool { return x < y }),
+		},
+		want: true,
+	}, {
+		x: higherOrderType{
+			M:    &testpb.TestAllTypes{RepeatedInt32: []int32{3, 2, 1, 2, 3, 3}},
+			I32s: []int32{3, 2, 1, 2, 3, 3},
+		},
+		y: higherOrderType{
+			M:    &testpb.TestAllTypes{RepeatedInt32: []int32{2, 3, 3, 2, 1, 3}},
+			I32s: []int32{2, 3, 3, 2, 1, 3},
+		},
+		opts: cmp.Options{
+			Transform(),
+			SortRepeated(func(x, y int32) bool { return x < y }),
+		},
+		want: false, // sort does not apply to []int32 outside of a message
+	}, {
+		x: &testpb.TestAllTypes{RepeatedInt32: []int32{3, 2, 1, 2, 3, 3}},
+		y: &testpb.TestAllTypes{RepeatedInt32: []int32{2, 3, 3, 2, 1, 3}},
+		opts: cmp.Options{
+			Transform(),
+			SortRepeated(func(x, y int64) bool { return x < y }),
+		},
+		want: false, // wrong sort type: int32 != int64
+	}, {
+		x:    &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_FOO, testpb.TestAllTypes_BAR, testpb.TestAllTypes_BAZ}},
+		y:    &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAR, testpb.TestAllTypes_FOO, testpb.TestAllTypes_BAZ}},
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_FOO, testpb.TestAllTypes_BAR, testpb.TestAllTypes_BAZ}},
+		y: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAR, testpb.TestAllTypes_FOO, testpb.TestAllTypes_BAZ}},
+		opts: cmp.Options{
+			Transform(),
+			SortRepeated(func(x, y testpb.TestAllTypes_NestedEnum) bool { return x < y }),
+		},
+		want: true,
+	}, {
+		x: higherOrderType{
+			M:  &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_FOO, testpb.TestAllTypes_BAR, testpb.TestAllTypes_BAZ}},
+			Es: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_FOO, testpb.TestAllTypes_BAR, testpb.TestAllTypes_BAZ},
+		},
+		y: higherOrderType{
+			M:  &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAR, testpb.TestAllTypes_FOO, testpb.TestAllTypes_BAZ}},
+			Es: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAR, testpb.TestAllTypes_FOO, testpb.TestAllTypes_BAZ},
+		},
+		opts: cmp.Options{
+			Transform(),
+			SortRepeated(func(x, y testpb.TestAllTypes_NestedEnum) bool { return x < y }),
+		},
+		want: false, // sort does not apply to []testpb.TestAllTypes_NestedEnum outside of a message
+	}, {
+		x: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_FOO, testpb.TestAllTypes_BAR, testpb.TestAllTypes_BAZ}},
+		y: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAR, testpb.TestAllTypes_FOO, testpb.TestAllTypes_BAZ}},
+		opts: cmp.Options{
+			Transform(),
+			SortRepeated(func(x, y testpb.ForeignEnum) bool { return x < y }),
+		},
+		want: false, // wrong sort type: testpb.TestAllTypes_NestedEnum != testpb.ForeignEnum
+	}, {
+		x:    &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{{}, {C: proto.Int32(3)}, nil, {C: proto.Int32(3)}, {C: proto.Int32(5)}, {C: proto.Int32(4)}}},
+		y:    &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{nil, {C: proto.Int32(3)}, {}, {C: proto.Int32(4)}, {C: proto.Int32(3)}, {C: proto.Int32(5)}}},
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x: &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{{}, {C: proto.Int32(3)}, nil, {C: proto.Int32(3)}, {C: proto.Int32(5)}, {C: proto.Int32(4)}}},
+		y: &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{nil, {C: proto.Int32(3)}, {}, {C: proto.Int32(4)}, {C: proto.Int32(3)}, {C: proto.Int32(5)}}},
+		opts: cmp.Options{
+			Transform(),
+			SortRepeated(func(x, y *testpb.ForeignMessage) bool { return x.GetC() < y.GetC() }),
+		},
+		want: true,
+	}, {
+		x: higherOrderType{
+			M:  &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{{}, {C: proto.Int32(3)}, nil, {C: proto.Int32(3)}, {C: proto.Int32(5)}, {C: proto.Int32(4)}}},
+			Ms: []*testpb.ForeignMessage{{}, {C: proto.Int32(3)}, nil, {C: proto.Int32(3)}, {C: proto.Int32(5)}, {C: proto.Int32(4)}},
+		},
+		y: higherOrderType{
+			M:  &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{nil, {C: proto.Int32(3)}, {}, {C: proto.Int32(4)}, {C: proto.Int32(3)}, {C: proto.Int32(5)}}},
+			Ms: []*testpb.ForeignMessage{nil, {C: proto.Int32(3)}, {}, {C: proto.Int32(4)}, {C: proto.Int32(3)}, {C: proto.Int32(5)}},
+		},
+		opts: cmp.Options{
+			Transform(),
+			SortRepeated(func(x, y *testpb.ForeignMessage) bool { return x.GetC() < y.GetC() }),
+		},
+		want: false, // sort does not apply to []*testpb.ForeignMessage outside of a message
+	}, {
+		x: &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{{}, {C: proto.Int32(3)}, nil, {C: proto.Int32(3)}, {C: proto.Int32(5)}, {C: proto.Int32(4)}}},
+		y: &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{nil, {C: proto.Int32(3)}, {}, {C: proto.Int32(4)}, {C: proto.Int32(3)}, {C: proto.Int32(5)}}},
+		opts: cmp.Options{
+			Transform(),
+			SortRepeated(func(x, y *testpb.TestAllTypes_NestedMessage) bool { return x.GetA() < y.GetA() }),
+		},
+		want: false, // wrong sort type: *testpb.ForeignMessage != *testpb.TestAllTypes_NestedMessage
+	}, {
+		x: &testpb.TestAllTypes{
+			RepeatedInt32:    []int32{-32, +32},
+			RepeatedSint32:   []int32{-32, +32},
+			RepeatedSfixed32: []int32{-32, +32},
+			RepeatedInt64:    []int64{-64, +64},
+			RepeatedSint64:   []int64{-64, +64},
+			RepeatedSfixed64: []int64{-64, +64},
+			RepeatedUint32:   []uint32{0, 32},
+			RepeatedFixed32:  []uint32{0, 32},
+			RepeatedUint64:   []uint64{0, 64},
+			RepeatedFixed64:  []uint64{0, 64},
+		},
+		y: &testpb.TestAllTypes{
+			RepeatedInt32:    []int32{+32, -32},
+			RepeatedSint32:   []int32{+32, -32},
+			RepeatedSfixed32: []int32{+32, -32},
+			RepeatedInt64:    []int64{+64, -64},
+			RepeatedSint64:   []int64{+64, -64},
+			RepeatedSfixed64: []int64{+64, -64},
+			RepeatedUint32:   []uint32{32, 0},
+			RepeatedFixed32:  []uint32{32, 0},
+			RepeatedUint64:   []uint64{64, 0},
+			RepeatedFixed64:  []uint64{64, 0},
+		},
+		opts: cmp.Options{
+			Transform(),
+			SortRepeated(func(x, y int32) bool { return x < y }),
+			SortRepeated(func(x, y int64) bool { return x < y }),
+			SortRepeated(func(x, y uint32) bool { return x < y }),
+			SortRepeated(func(x, y uint64) bool { return x < y }),
+		},
+		want: true,
+	}}...)
+
+	// Test SortRepeatedFields.
+	tests = append(tests, []test{{
+		x:    &testpb.TestAllTypes{RepeatedInt32: []int32{3, 2, 1, 2, 3, 3}},
+		y:    &testpb.TestAllTypes{RepeatedInt32: []int32{2, 3, 3, 2, 1, 3}},
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x: &testpb.TestAllTypes{RepeatedInt32: []int32{3, 2, 1, 2, 3, 3}},
+		y: &testpb.TestAllTypes{RepeatedInt32: []int32{2, 3, 3, 2, 1, 3}},
+		opts: cmp.Options{
+			Transform(),
+			SortRepeatedFields(new(testpb.TestAllTypes), "repeated_int32"),
+		},
+		want: true,
+	}, {
+		x: &testpb.TestAllTypes{RepeatedInt32: []int32{3, 2, 1, 2, 3, 3}},
+		y: &testpb.TestAllTypes{RepeatedInt32: []int32{2, 3, 3, 2, 1, 3}},
+		opts: cmp.Options{
+			Transform(),
+			SortRepeatedFields(new(testpb.TestAllTypes), "repeated_int64"),
+		},
+		want: false, // wrong field: repeated_int32 != repeated_int64
+	}, {
+		x:    &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_FOO, testpb.TestAllTypes_BAR, testpb.TestAllTypes_BAZ}},
+		y:    &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAR, testpb.TestAllTypes_FOO, testpb.TestAllTypes_BAZ}},
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_FOO, testpb.TestAllTypes_BAR, testpb.TestAllTypes_BAZ}},
+		y: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAR, testpb.TestAllTypes_FOO, testpb.TestAllTypes_BAZ}},
+		opts: cmp.Options{
+			Transform(),
+			SortRepeatedFields(new(testpb.TestAllTypes), "repeated_nested_enum"),
+		},
+		want: true,
+	}, {
+		x: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_FOO, testpb.TestAllTypes_BAR, testpb.TestAllTypes_BAZ}},
+		y: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAR, testpb.TestAllTypes_FOO, testpb.TestAllTypes_BAZ}},
+		opts: cmp.Options{
+			Transform(),
+			SortRepeatedFields(new(testpb.TestAllTypes), "repeated_foreign_enum"),
+		},
+		want: false, // wrong field: repeated_nested_enum != repeated_foreign_enum
+	}, {
+		x:    &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{{}, {C: proto.Int32(3)}, nil, {C: proto.Int32(3)}, {C: proto.Int32(5)}, {C: proto.Int32(4)}}},
+		y:    &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{nil, {C: proto.Int32(3)}, {}, {C: proto.Int32(4)}, {C: proto.Int32(3)}, {C: proto.Int32(5)}}},
+		opts: cmp.Options{Transform()},
+		want: false,
+	}, {
+		x: &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{{}, {C: proto.Int32(3)}, nil, {C: proto.Int32(3)}, {C: proto.Int32(5)}, {C: proto.Int32(4)}}},
+		y: &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{nil, {C: proto.Int32(3)}, {}, {C: proto.Int32(4)}, {C: proto.Int32(3)}, {C: proto.Int32(5)}}},
+		opts: cmp.Options{
+			Transform(),
+			SortRepeatedFields(new(testpb.TestAllTypes), "repeated_foreign_message"),
+		},
+		want: true,
+	}, {
+		x: &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{{}, {C: proto.Int32(3)}, nil, {C: proto.Int32(3)}, {C: proto.Int32(5)}, {C: proto.Int32(4)}}},
+		y: &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{nil, {C: proto.Int32(3)}, {}, {C: proto.Int32(4)}, {C: proto.Int32(3)}, {C: proto.Int32(5)}}},
+		opts: cmp.Options{
+			Transform(),
+			SortRepeatedFields(new(testpb.TestAllTypes), "repeated_nested_message"),
+		},
+		want: false, // wrong field: repeated_foreign_message != repeated_nested_message
+	}, {
+		x: &testpb.TestAllTypes{
+			RepeatedBool:           []bool{false, true},
+			RepeatedInt32:          []int32{-32, +32},
+			RepeatedInt64:          []int64{-64, +64},
+			RepeatedUint32:         []uint32{0, 32},
+			RepeatedUint64:         []uint64{0, 64},
+			RepeatedFloat:          []float32{-32.32, +32.32},
+			RepeatedDouble:         []float64{-64.64, +64.64},
+			RepeatedString:         []string{"hello", "world"},
+			RepeatedBytes:          [][]byte{[]byte("hello"), []byte("world")},
+			RepeatedForeignEnum:    []testpb.ForeignEnum{testpb.ForeignEnum_FOREIGN_FOO, testpb.ForeignEnum_FOREIGN_BAR},
+			RepeatedForeignMessage: []*testpb.ForeignMessage{{C: proto.Int32(-1)}, {C: proto.Int32(+1)}},
+		},
+		y: &testpb.TestAllTypes{
+			RepeatedBool:           []bool{true, false},
+			RepeatedInt32:          []int32{+32, -32},
+			RepeatedInt64:          []int64{+64, -64},
+			RepeatedUint32:         []uint32{32, 0},
+			RepeatedUint64:         []uint64{64, 0},
+			RepeatedFloat:          []float32{+32.32, -32.32},
+			RepeatedDouble:         []float64{+64.64, -64.64},
+			RepeatedString:         []string{"world", "hello"},
+			RepeatedBytes:          [][]byte{[]byte("world"), []byte("hello")},
+			RepeatedForeignEnum:    []testpb.ForeignEnum{testpb.ForeignEnum_FOREIGN_BAR, testpb.ForeignEnum_FOREIGN_FOO},
+			RepeatedForeignMessage: []*testpb.ForeignMessage{{C: proto.Int32(+1)}, {C: proto.Int32(-1)}},
+		},
+		opts: cmp.Options{
+			Transform(),
+			SortRepeatedFields(new(testpb.TestAllTypes),
+				"repeated_bool",
+				"repeated_int32",
+				"repeated_int64",
+				"repeated_uint32",
+				"repeated_uint64",
+				"repeated_float",
+				"repeated_double",
+				"repeated_string",
+				"repeated_bytes",
+				"repeated_foreign_enum",
+				"repeated_foreign_message",
+			),
+		},
+		want: true,
+	}}...)
+
+	for _, tt := range tests {
+		t.Run("", func(t *testing.T) {
+			got := cmp.Equal(tt.x, tt.y, tt.opts)
+			if got != tt.want {
+				if !got {
+					t.Errorf("cmp.Equal = false, want true; diff:\n%v", cmp.Diff(tt.x, tt.y, tt.opts))
+				} else {
+					t.Errorf("cmp.Equal = true, want false")
+				}
+			}
+		})
+	}
+}
+
+type setField struct {
+	num protoreflect.FieldNumber
+	val interface{}
+}
+type setUnknown struct {
+	raw protoreflect.RawFields
+}
+type setExtension struct {
+	typ protoreflect.ExtensionType
+	val interface{}
+}
+
+// apply applies a sequence of mutating operations to m.
+func apply(m proto.Message, ops ...interface{}) proto.Message {
+	mr := m.ProtoReflect()
+	md := mr.Descriptor()
+	for _, op := range ops {
+		switch op := op.(type) {
+		case setField:
+			fd := md.Fields().ByNumber(op.num)
+			mr.Set(fd, protoreflect.ValueOf(op.val))
+		case setUnknown:
+			mr.SetUnknown(op.raw)
+		case setExtension:
+			mr.Set(op.typ.TypeDescriptor(), protoreflect.ValueOf(op.val))
+		}
+	}
+	return m
+}
+
+func TestSort(t *testing.T) {
+	t.Run("F32", func(t *testing.T) {
+		want := []float32{
+			float32(math.Float32frombits(0xffc00000)), // -NaN
+			float32(math.Inf(-1)),
+			float32(-math.MaxFloat32),
+			float32(-123.456),
+			float32(-math.SmallestNonzeroFloat32),
+			float32(math.Copysign(0, -1)),
+			float32(math.Copysign(0, +1)),
+			float32(+math.SmallestNonzeroFloat32),
+			float32(+123.456),
+			float32(+math.MaxFloat32),
+			float32(math.Inf(+1)),
+			float32(math.Float32frombits(0x7fc00000)), // +NaN
+		}
+		for i := 0; i < 10; i++ {
+			t.Run("", func(t *testing.T) {
+				got := append([]float32(nil), want...)
+				rn := rand.New(rand.NewSource(int64(i)))
+				for i, j := range rn.Perm(len(got)) {
+					got[i], got[j] = got[j], got[i]
+				}
+				sort.Slice(got, func(i, j int) bool {
+					return lessF32(got[i], got[j])
+				})
+				cmpF32s := cmp.Comparer(func(x, y float32) bool {
+					return math.Float32bits(x) == math.Float32bits(y)
+				})
+				if diff := cmp.Diff(want, got, cmpF32s); diff != "" {
+					t.Errorf("Sort mismatch (-want +got):\n%s", diff)
+				}
+			})
+		}
+	})
+	t.Run("F64", func(t *testing.T) {
+		want := []float64{
+			float64(math.Float64frombits(0xfff8000000000001)), // -NaN
+			float64(math.Inf(-1)),
+			float64(-math.MaxFloat64),
+			float64(-123.456),
+			float64(-math.SmallestNonzeroFloat64),
+			float64(math.Copysign(0, -1)),
+			float64(math.Copysign(0, +1)),
+			float64(+math.SmallestNonzeroFloat64),
+			float64(+123.456),
+			float64(+math.MaxFloat64),
+			float64(math.Inf(+1)),
+			float64(math.Float64frombits(0x7ff8000000000001)), // +NaN
+		}
+		for i := 0; i < 10; i++ {
+			t.Run("", func(t *testing.T) {
+				got := append([]float64(nil), want...)
+				rn := rand.New(rand.NewSource(int64(i)))
+				for i, j := range rn.Perm(len(got)) {
+					got[i], got[j] = got[j], got[i]
+				}
+				sort.Slice(got, func(i, j int) bool {
+					return lessF64(got[i], got[j])
+				})
+				cmpF64s := cmp.Comparer(func(x, y float64) bool {
+					return math.Float64bits(x) == math.Float64bits(y)
+				})
+				if diff := cmp.Diff(want, got, cmpF64s); diff != "" {
+					t.Errorf("Sort mismatch (-want +got):\n%s", diff)
+				}
+			})
+		}
+	})
+}
diff --git a/vendor/google.golang.org/protobuf/testing/protocmp/xform.go b/vendor/google.golang.org/protobuf/testing/protocmp/xform.go
new file mode 100644
index 000000000..78d43e394
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/testing/protocmp/xform.go
@@ -0,0 +1,331 @@
+// Copyright 2019 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 protocmp provides protobuf specific options for the
+// "github.com/google/go-cmp/cmp" package.
+//
+// The primary feature is the Transform option, which transform proto.Message
+// types into a Message map that is suitable for cmp to introspect upon.
+// All other options in this package must be used in conjunction with Transform.
+package protocmp
+
+import (
+	"reflect"
+	"strconv"
+
+	"github.com/google/go-cmp/cmp"
+
+	"google.golang.org/protobuf/encoding/protowire"
+	"google.golang.org/protobuf/internal/msgfmt"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/reflect/protoregistry"
+	"google.golang.org/protobuf/runtime/protoiface"
+	"google.golang.org/protobuf/runtime/protoimpl"
+)
+
+var (
+	enumV2Type    = reflect.TypeOf((*protoreflect.Enum)(nil)).Elem()
+	messageV1Type = reflect.TypeOf((*protoiface.MessageV1)(nil)).Elem()
+	messageV2Type = reflect.TypeOf((*proto.Message)(nil)).Elem()
+)
+
+// Enum is a dynamic representation of a protocol buffer enum that is
+// suitable for cmp.Equal and cmp.Diff to compare upon.
+type Enum struct {
+	num protoreflect.EnumNumber
+	ed  protoreflect.EnumDescriptor
+}
+
+// Descriptor returns the enum descriptor.
+// It returns nil for a zero Enum value.
+func (e Enum) Descriptor() protoreflect.EnumDescriptor {
+	return e.ed
+}
+
+// Number returns the enum value as an integer.
+func (e Enum) Number() protoreflect.EnumNumber {
+	return e.num
+}
+
+// Equal reports whether e1 and e2 represent the same enum value.
+func (e1 Enum) Equal(e2 Enum) bool {
+	if e1.ed.FullName() != e2.ed.FullName() {
+		return false
+	}
+	return e1.num == e2.num
+}
+
+// String returns the name of the enum value if known (e.g., "ENUM_VALUE"),
+// otherwise it returns the formatted decimal enum number (e.g., "14").
+func (e Enum) String() string {
+	if ev := e.ed.Values().ByNumber(e.num); ev != nil {
+		return string(ev.Name())
+	}
+	return strconv.Itoa(int(e.num))
+}
+
+const (
+	messageTypeKey    = "@type"
+	messageInvalidKey = "@invalid"
+)
+
+type messageType struct {
+	md  protoreflect.MessageDescriptor
+	xds map[protoreflect.FullName]protoreflect.ExtensionDescriptor
+}
+
+func (t messageType) String() string {
+	return string(t.md.FullName())
+}
+
+func (t1 messageType) Equal(t2 messageType) bool {
+	return t1.md.FullName() == t2.md.FullName()
+}
+
+// Message is a dynamic representation of a protocol buffer message that is
+// suitable for cmp.Equal and cmp.Diff to directly operate upon.
+//
+// Every populated known field (excluding extension fields) is stored in the map
+// with the key being the short name of the field (e.g., "field_name") and
+// the value determined by the kind and cardinality of the field.
+//
+// Singular scalars are represented by the same Go type as protoreflect.Value,
+// singular messages are represented by the Message type,
+// singular enums are represented by the Enum type,
+// list fields are represented as a Go slice, and
+// map fields are represented as a Go map.
+//
+// Every populated extension field is stored in the map with the key being the
+// full name of the field surrounded by brackets (e.g., "[extension.full.name]")
+// and the value determined according to the same rules as known fields.
+//
+// Every unknown field is stored in the map with the key being the field number
+// encoded as a decimal string (e.g., "132") and the value being the raw bytes
+// of the encoded field (as the protoreflect.RawFields type).
+//
+// Message values must not be created by or mutated by users.
+type Message map[string]interface{}
+
+// Descriptor return the message descriptor.
+// It returns nil for a zero Message value.
+func (m Message) Descriptor() protoreflect.MessageDescriptor {
+	mt, _ := m[messageTypeKey].(messageType)
+	return mt.md
+}
+
+// ProtoReflect returns a reflective view of m.
+// It only implements the read-only operations of protoreflect.Message.
+// Calling any mutating operations on m panics.
+func (m Message) ProtoReflect() protoreflect.Message {
+	return (reflectMessage)(m)
+}
+
+// ProtoMessage is a marker method from the legacy message interface.
+func (m Message) ProtoMessage() {}
+
+// Reset is the required Reset method from the legacy message interface.
+func (m Message) Reset() {
+	panic("invalid mutation of a read-only message")
+}
+
+// String returns a formatted string for the message.
+// It is intended for human debugging and has no guarantees about its
+// exact format or the stability of its output.
+func (m Message) String() string {
+	switch {
+	case m == nil:
+		return "<nil>"
+	case !m.ProtoReflect().IsValid():
+		return "<invalid>"
+	default:
+		return msgfmt.Format(m)
+	}
+}
+
+type option struct{}
+
+// Transform returns a cmp.Option that converts each proto.Message to a Message.
+// The transformation does not mutate nor alias any converted messages.
+//
+// The google.protobuf.Any message is automatically unmarshaled such that the
+// "value" field is a Message representing the underlying message value
+// assuming it could be resolved and properly unmarshaled.
+//
+// This does not directly transform higher-order composite Go types.
+// For example, []*foopb.Message is not transformed into []Message,
+// but rather the individual message elements of the slice are transformed.
+func Transform(...option) cmp.Option {
+	// NOTE: There are currently no custom options for Transform,
+	// but the use of an unexported type keeps the future open.
+
+	// addrType returns a pointer to t if t isn't a pointer or interface.
+	addrType := func(t reflect.Type) reflect.Type {
+		if k := t.Kind(); k == reflect.Interface || k == reflect.Ptr {
+			return t
+		}
+		return reflect.PtrTo(t)
+	}
+
+	// TODO: Should this transform protoreflect.Enum types to Enum as well?
+	return cmp.FilterPath(func(p cmp.Path) bool {
+		ps := p.Last()
+		if isMessageType(addrType(ps.Type())) {
+			return true
+		}
+
+		// Check whether the concrete values of an interface both satisfy
+		// the Message interface.
+		if ps.Type().Kind() == reflect.Interface {
+			vx, vy := ps.Values()
+			if !vx.IsValid() || vx.IsNil() || !vy.IsValid() || vy.IsNil() {
+				return false
+			}
+			return isMessageType(addrType(vx.Elem().Type())) && isMessageType(addrType(vy.Elem().Type()))
+		}
+
+		return false
+	}, cmp.Transformer("protocmp.Transform", func(v interface{}) Message {
+		// For user convenience, shallow copy the message value if necessary
+		// in order for it to implement the message interface.
+		if rv := reflect.ValueOf(v); rv.IsValid() && rv.Kind() != reflect.Ptr && !isMessageType(rv.Type()) {
+			pv := reflect.New(rv.Type())
+			pv.Elem().Set(rv)
+			v = pv.Interface()
+		}
+
+		m := protoimpl.X.MessageOf(v)
+		switch {
+		case m == nil:
+			return nil
+		case !m.IsValid():
+			return Message{messageTypeKey: messageType{md: m.Descriptor()}, messageInvalidKey: true}
+		default:
+			return transformMessage(m)
+		}
+	}))
+}
+
+func isMessageType(t reflect.Type) bool {
+	// Avoid tranforming the Message itself.
+	if t == reflect.TypeOf(Message(nil)) || t == reflect.TypeOf((*Message)(nil)) {
+		return false
+	}
+	return t.Implements(messageV1Type) || t.Implements(messageV2Type)
+}
+
+func transformMessage(m protoreflect.Message) Message {
+	mx := Message{}
+	mt := messageType{md: m.Descriptor(), xds: make(map[protoreflect.FullName]protoreflect.FieldDescriptor)}
+
+	// Handle known and extension fields.
+	m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
+		s := string(fd.Name())
+		if fd.IsExtension() {
+			s = "[" + string(fd.FullName()) + "]"
+			mt.xds[fd.FullName()] = fd
+		}
+		switch {
+		case fd.IsList():
+			mx[s] = transformList(fd, v.List())
+		case fd.IsMap():
+			mx[s] = transformMap(fd, v.Map())
+		default:
+			mx[s] = transformSingular(fd, v)
+		}
+		return true
+	})
+
+	// Handle unknown fields.
+	for b := m.GetUnknown(); len(b) > 0; {
+		num, _, n := protowire.ConsumeField(b)
+		s := strconv.Itoa(int(num))
+		b2, _ := mx[s].(protoreflect.RawFields)
+		mx[s] = append(b2, b[:n]...)
+		b = b[n:]
+	}
+
+	// Expand Any messages.
+	if mt.md.FullName() == "google.protobuf.Any" {
+		// TODO: Expose Transform option to specify a custom resolver?
+		s, _ := mx["type_url"].(string)
+		b, _ := mx["value"].([]byte)
+		mt, err := protoregistry.GlobalTypes.FindMessageByURL(s)
+		if mt != nil && err == nil {
+			m2 := mt.New()
+			err := proto.UnmarshalOptions{AllowPartial: true}.Unmarshal(b, m2.Interface())
+			if err == nil {
+				mx["value"] = transformMessage(m2)
+			}
+		}
+	}
+
+	mx[messageTypeKey] = mt
+	return mx
+}
+
+func transformList(fd protoreflect.FieldDescriptor, lv protoreflect.List) interface{} {
+	t := protoKindToGoType(fd.Kind())
+	rv := reflect.MakeSlice(reflect.SliceOf(t), lv.Len(), lv.Len())
+	for i := 0; i < lv.Len(); i++ {
+		v := reflect.ValueOf(transformSingular(fd, lv.Get(i)))
+		rv.Index(i).Set(v)
+	}
+	return rv.Interface()
+}
+
+func transformMap(fd protoreflect.FieldDescriptor, mv protoreflect.Map) interface{} {
+	kfd := fd.MapKey()
+	vfd := fd.MapValue()
+	kt := protoKindToGoType(kfd.Kind())
+	vt := protoKindToGoType(vfd.Kind())
+	rv := reflect.MakeMapWithSize(reflect.MapOf(kt, vt), mv.Len())
+	mv.Range(func(k protoreflect.MapKey, v protoreflect.Value) bool {
+		kv := reflect.ValueOf(transformSingular(kfd, k.Value()))
+		vv := reflect.ValueOf(transformSingular(vfd, v))
+		rv.SetMapIndex(kv, vv)
+		return true
+	})
+	return rv.Interface()
+}
+
+func transformSingular(fd protoreflect.FieldDescriptor, v protoreflect.Value) interface{} {
+	switch fd.Kind() {
+	case protoreflect.EnumKind:
+		return Enum{num: v.Enum(), ed: fd.Enum()}
+	case protoreflect.MessageKind, protoreflect.GroupKind:
+		return transformMessage(v.Message())
+	default:
+		return v.Interface()
+	}
+}
+
+func protoKindToGoType(k protoreflect.Kind) reflect.Type {
+	switch k {
+	case protoreflect.BoolKind:
+		return reflect.TypeOf(bool(false))
+	case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
+		return reflect.TypeOf(int32(0))
+	case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
+		return reflect.TypeOf(int64(0))
+	case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
+		return reflect.TypeOf(uint32(0))
+	case protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
+		return reflect.TypeOf(uint64(0))
+	case protoreflect.FloatKind:
+		return reflect.TypeOf(float32(0))
+	case protoreflect.DoubleKind:
+		return reflect.TypeOf(float64(0))
+	case protoreflect.StringKind:
+		return reflect.TypeOf(string(""))
+	case protoreflect.BytesKind:
+		return reflect.TypeOf([]byte(nil))
+	case protoreflect.EnumKind:
+		return reflect.TypeOf(Enum{})
+	case protoreflect.MessageKind, protoreflect.GroupKind:
+		return reflect.TypeOf(Message{})
+	default:
+		panic("invalid kind")
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/testing/protocmp/xform_test.go b/vendor/google.golang.org/protobuf/testing/protocmp/xform_test.go
new file mode 100644
index 000000000..7fc3f6879
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/testing/protocmp/xform_test.go
@@ -0,0 +1,271 @@
+// Copyright 2019 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 protocmp
+
+import (
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+
+	"google.golang.org/protobuf/internal/detrand"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/testing/protopack"
+
+	testpb "google.golang.org/protobuf/internal/testprotos/test"
+)
+
+func init() {
+	detrand.Disable()
+}
+
+func TestTransform(t *testing.T) {
+	tests := []struct {
+		in   proto.Message
+		want Message
+	}{{
+		in: &testpb.TestAllTypes{
+			OptionalBool:          proto.Bool(false),
+			OptionalInt32:         proto.Int32(-32),
+			OptionalInt64:         proto.Int64(-64),
+			OptionalUint32:        proto.Uint32(32),
+			OptionalUint64:        proto.Uint64(64),
+			OptionalFloat:         proto.Float32(32.32),
+			OptionalDouble:        proto.Float64(64.64),
+			OptionalString:        proto.String("string"),
+			OptionalBytes:         []byte("bytes"),
+			OptionalNestedEnum:    testpb.TestAllTypes_NEG.Enum(),
+			OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{A: proto.Int32(5)},
+		},
+		want: Message{
+			messageTypeKey:            messageTypeOf(&testpb.TestAllTypes{}),
+			"optional_bool":           bool(false),
+			"optional_int32":          int32(-32),
+			"optional_int64":          int64(-64),
+			"optional_uint32":         uint32(32),
+			"optional_uint64":         uint64(64),
+			"optional_float":          float32(32.32),
+			"optional_double":         float64(64.64),
+			"optional_string":         string("string"),
+			"optional_bytes":          []byte("bytes"),
+			"optional_nested_enum":    enumOf(testpb.TestAllTypes_NEG),
+			"optional_nested_message": Message{messageTypeKey: messageTypeOf(&testpb.TestAllTypes_NestedMessage{}), "a": int32(5)},
+		},
+	}, {
+		in: &testpb.TestAllTypes{
+			RepeatedBool:   []bool{false, true},
+			RepeatedInt32:  []int32{32, -32},
+			RepeatedInt64:  []int64{64, -64},
+			RepeatedUint32: []uint32{0, 32},
+			RepeatedUint64: []uint64{0, 64},
+			RepeatedFloat:  []float32{0, 32.32},
+			RepeatedDouble: []float64{0, 64.64},
+			RepeatedString: []string{"s1", "s2"},
+			RepeatedBytes:  [][]byte{{1}, {2}},
+			RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{
+				testpb.TestAllTypes_FOO,
+				testpb.TestAllTypes_BAR,
+			},
+			RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{
+				{A: proto.Int32(5)},
+				{A: proto.Int32(-5)},
+			},
+		},
+		want: Message{
+			messageTypeKey:    messageTypeOf(&testpb.TestAllTypes{}),
+			"repeated_bool":   []bool{false, true},
+			"repeated_int32":  []int32{32, -32},
+			"repeated_int64":  []int64{64, -64},
+			"repeated_uint32": []uint32{0, 32},
+			"repeated_uint64": []uint64{0, 64},
+			"repeated_float":  []float32{0, 32.32},
+			"repeated_double": []float64{0, 64.64},
+			"repeated_string": []string{"s1", "s2"},
+			"repeated_bytes":  [][]byte{{1}, {2}},
+			"repeated_nested_enum": []Enum{
+				enumOf(testpb.TestAllTypes_FOO),
+				enumOf(testpb.TestAllTypes_BAR),
+			},
+			"repeated_nested_message": []Message{
+				{messageTypeKey: messageTypeOf(&testpb.TestAllTypes_NestedMessage{}), "a": int32(5)},
+				{messageTypeKey: messageTypeOf(&testpb.TestAllTypes_NestedMessage{}), "a": int32(-5)},
+			},
+		},
+	}, {
+		in: &testpb.TestAllTypes{
+			MapBoolBool:     map[bool]bool{true: false},
+			MapInt32Int32:   map[int32]int32{-32: 32},
+			MapInt64Int64:   map[int64]int64{-64: 64},
+			MapUint32Uint32: map[uint32]uint32{0: 32},
+			MapUint64Uint64: map[uint64]uint64{0: 64},
+			MapInt32Float:   map[int32]float32{32: 32.32},
+			MapInt32Double:  map[int32]float64{64: 64.64},
+			MapStringString: map[string]string{"k": "v"},
+			MapStringBytes:  map[string][]byte{"k": []byte("v")},
+			MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{
+				"k": testpb.TestAllTypes_FOO,
+			},
+			MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{
+				"k": {A: proto.Int32(5)},
+			},
+		},
+		want: Message{
+			messageTypeKey:      messageTypeOf(&testpb.TestAllTypes{}),
+			"map_bool_bool":     map[bool]bool{true: false},
+			"map_int32_int32":   map[int32]int32{-32: 32},
+			"map_int64_int64":   map[int64]int64{-64: 64},
+			"map_uint32_uint32": map[uint32]uint32{0: 32},
+			"map_uint64_uint64": map[uint64]uint64{0: 64},
+			"map_int32_float":   map[int32]float32{32: 32.32},
+			"map_int32_double":  map[int32]float64{64: 64.64},
+			"map_string_string": map[string]string{"k": "v"},
+			"map_string_bytes":  map[string][]byte{"k": []byte("v")},
+			"map_string_nested_enum": map[string]Enum{
+				"k": enumOf(testpb.TestAllTypes_FOO),
+			},
+			"map_string_nested_message": map[string]Message{
+				"k": {messageTypeKey: messageTypeOf(&testpb.TestAllTypes_NestedMessage{}), "a": int32(5)},
+			},
+		},
+	}, {
+		in: func() proto.Message {
+			m := &testpb.TestAllExtensions{}
+			proto.SetExtension(m, testpb.E_OptionalBool, bool(false))
+			proto.SetExtension(m, testpb.E_OptionalInt32, int32(-32))
+			proto.SetExtension(m, testpb.E_OptionalInt64, int64(-64))
+			proto.SetExtension(m, testpb.E_OptionalUint32, uint32(32))
+			proto.SetExtension(m, testpb.E_OptionalUint64, uint64(64))
+			proto.SetExtension(m, testpb.E_OptionalFloat, float32(32.32))
+			proto.SetExtension(m, testpb.E_OptionalDouble, float64(64.64))
+			proto.SetExtension(m, testpb.E_OptionalString, string("string"))
+			proto.SetExtension(m, testpb.E_OptionalBytes, []byte("bytes"))
+			proto.SetExtension(m, testpb.E_OptionalNestedEnum, testpb.TestAllTypes_NEG)
+			proto.SetExtension(m, testpb.E_OptionalNestedMessage, &testpb.TestAllExtensions_NestedMessage{A: proto.Int32(5)})
+			return m
+		}(),
+		want: Message{
+			messageTypeKey:                                 messageTypeOf(&testpb.TestAllExtensions{}),
+			"[goproto.proto.test.optional_bool]":           bool(false),
+			"[goproto.proto.test.optional_int32]":          int32(-32),
+			"[goproto.proto.test.optional_int64]":          int64(-64),
+			"[goproto.proto.test.optional_uint32]":         uint32(32),
+			"[goproto.proto.test.optional_uint64]":         uint64(64),
+			"[goproto.proto.test.optional_float]":          float32(32.32),
+			"[goproto.proto.test.optional_double]":         float64(64.64),
+			"[goproto.proto.test.optional_string]":         string("string"),
+			"[goproto.proto.test.optional_bytes]":          []byte("bytes"),
+			"[goproto.proto.test.optional_nested_enum]":    enumOf(testpb.TestAllTypes_NEG),
+			"[goproto.proto.test.optional_nested_message]": Message{messageTypeKey: messageTypeOf(&testpb.TestAllExtensions_NestedMessage{}), "a": int32(5)},
+		},
+	}, {
+		in: func() proto.Message {
+			m := &testpb.TestAllExtensions{}
+			proto.SetExtension(m, testpb.E_RepeatedBool, []bool{false, true})
+			proto.SetExtension(m, testpb.E_RepeatedInt32, []int32{32, -32})
+			proto.SetExtension(m, testpb.E_RepeatedInt64, []int64{64, -64})
+			proto.SetExtension(m, testpb.E_RepeatedUint32, []uint32{0, 32})
+			proto.SetExtension(m, testpb.E_RepeatedUint64, []uint64{0, 64})
+			proto.SetExtension(m, testpb.E_RepeatedFloat, []float32{0, 32.32})
+			proto.SetExtension(m, testpb.E_RepeatedDouble, []float64{0, 64.64})
+			proto.SetExtension(m, testpb.E_RepeatedString, []string{"s1", "s2"})
+			proto.SetExtension(m, testpb.E_RepeatedBytes, [][]byte{{1}, {2}})
+			proto.SetExtension(m, testpb.E_RepeatedNestedEnum, []testpb.TestAllTypes_NestedEnum{
+				testpb.TestAllTypes_FOO,
+				testpb.TestAllTypes_BAR,
+			})
+			proto.SetExtension(m, testpb.E_RepeatedNestedMessage, []*testpb.TestAllExtensions_NestedMessage{
+				{A: proto.Int32(5)},
+				{A: proto.Int32(-5)},
+			})
+			return m
+		}(),
+		want: Message{
+			messageTypeKey:                         messageTypeOf(&testpb.TestAllExtensions{}),
+			"[goproto.proto.test.repeated_bool]":   []bool{false, true},
+			"[goproto.proto.test.repeated_int32]":  []int32{32, -32},
+			"[goproto.proto.test.repeated_int64]":  []int64{64, -64},
+			"[goproto.proto.test.repeated_uint32]": []uint32{0, 32},
+			"[goproto.proto.test.repeated_uint64]": []uint64{0, 64},
+			"[goproto.proto.test.repeated_float]":  []float32{0, 32.32},
+			"[goproto.proto.test.repeated_double]": []float64{0, 64.64},
+			"[goproto.proto.test.repeated_string]": []string{"s1", "s2"},
+			"[goproto.proto.test.repeated_bytes]":  [][]byte{{1}, {2}},
+			"[goproto.proto.test.repeated_nested_enum]": []Enum{
+				enumOf(testpb.TestAllTypes_FOO),
+				enumOf(testpb.TestAllTypes_BAR),
+			},
+			"[goproto.proto.test.repeated_nested_message]": []Message{
+				{messageTypeKey: messageTypeOf(&testpb.TestAllExtensions_NestedMessage{}), "a": int32(5)},
+				{messageTypeKey: messageTypeOf(&testpb.TestAllExtensions_NestedMessage{}), "a": int32(-5)},
+			},
+		},
+	}, {
+		in: func() proto.Message {
+			m := &testpb.TestAllTypes{}
+			m.ProtoReflect().SetUnknown(protopack.Message{
+				protopack.Tag{Number: 50000, Type: protopack.VarintType}, protopack.Uvarint(100),
+				protopack.Tag{Number: 50001, Type: protopack.Fixed32Type}, protopack.Uint32(200),
+				protopack.Tag{Number: 50002, Type: protopack.Fixed64Type}, protopack.Uint64(300),
+				protopack.Tag{Number: 50003, Type: protopack.BytesType}, protopack.String("hello"),
+				protopack.Message{
+					protopack.Tag{Number: 50004, Type: protopack.StartGroupType},
+					protopack.Tag{Number: 1, Type: protopack.VarintType}, protopack.Uvarint(100),
+					protopack.Tag{Number: 1, Type: protopack.Fixed32Type}, protopack.Uint32(200),
+					protopack.Tag{Number: 1, Type: protopack.Fixed64Type}, protopack.Uint64(300),
+					protopack.Tag{Number: 1, Type: protopack.BytesType}, protopack.String("hello"),
+					protopack.Message{
+						protopack.Tag{Number: 1, Type: protopack.StartGroupType},
+						protopack.Tag{Number: 1, Type: protopack.VarintType}, protopack.Uvarint(100),
+						protopack.Tag{Number: 1, Type: protopack.Fixed32Type}, protopack.Uint32(200),
+						protopack.Tag{Number: 1, Type: protopack.Fixed64Type}, protopack.Uint64(300),
+						protopack.Tag{Number: 1, Type: protopack.BytesType}, protopack.String("hello"),
+						protopack.Tag{Number: 1, Type: protopack.EndGroupType},
+					},
+					protopack.Tag{Number: 50004, Type: protopack.EndGroupType},
+				},
+			}.Marshal())
+			return m
+		}(),
+		want: Message{
+			messageTypeKey: messageTypeOf(&testpb.TestAllTypes{}),
+			"50000":        protoreflect.RawFields(protopack.Message{protopack.Tag{Number: 50000, Type: protopack.VarintType}, protopack.Uvarint(100)}.Marshal()),
+			"50001":        protoreflect.RawFields(protopack.Message{protopack.Tag{Number: 50001, Type: protopack.Fixed32Type}, protopack.Uint32(200)}.Marshal()),
+			"50002":        protoreflect.RawFields(protopack.Message{protopack.Tag{Number: 50002, Type: protopack.Fixed64Type}, protopack.Uint64(300)}.Marshal()),
+			"50003":        protoreflect.RawFields(protopack.Message{protopack.Tag{Number: 50003, Type: protopack.BytesType}, protopack.String("hello")}.Marshal()),
+			"50004": protoreflect.RawFields(protopack.Message{
+				protopack.Tag{Number: 50004, Type: protopack.StartGroupType},
+				protopack.Tag{Number: 1, Type: protopack.VarintType}, protopack.Uvarint(100),
+				protopack.Tag{Number: 1, Type: protopack.Fixed32Type}, protopack.Uint32(200),
+				protopack.Tag{Number: 1, Type: protopack.Fixed64Type}, protopack.Uint64(300),
+				protopack.Tag{Number: 1, Type: protopack.BytesType}, protopack.String("hello"),
+				protopack.Message{
+					protopack.Tag{Number: 1, Type: protopack.StartGroupType},
+					protopack.Tag{Number: 1, Type: protopack.VarintType}, protopack.Uvarint(100),
+					protopack.Tag{Number: 1, Type: protopack.Fixed32Type}, protopack.Uint32(200),
+					protopack.Tag{Number: 1, Type: protopack.Fixed64Type}, protopack.Uint64(300),
+					protopack.Tag{Number: 1, Type: protopack.BytesType}, protopack.String("hello"),
+					protopack.Tag{Number: 1, Type: protopack.EndGroupType},
+				},
+				protopack.Tag{Number: 50004, Type: protopack.EndGroupType},
+			}.Marshal()),
+		},
+	}}
+	for _, tt := range tests {
+		t.Run("", func(t *testing.T) {
+			got := transformMessage(tt.in.ProtoReflect())
+			if diff := cmp.Diff(tt.want, got); diff != "" {
+				t.Errorf("Transform() mismatch (-want +got):\n%v", diff)
+			}
+		})
+	}
+}
+
+func enumOf(e protoreflect.Enum) Enum {
+	return Enum{e.Number(), e.Descriptor()}
+}
+
+func messageTypeOf(m protoreflect.ProtoMessage) messageType {
+	return messageType{md: m.ProtoReflect().Descriptor()}
+}
diff --git a/vendor/google.golang.org/protobuf/testing/protopack/pack.go b/vendor/google.golang.org/protobuf/testing/protopack/pack.go
new file mode 100644
index 000000000..5d28450c6
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/testing/protopack/pack.go
@@ -0,0 +1,683 @@
+// 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 protopack enables manual encoding and decoding of protobuf wire data.
+//
+// This package is intended for use in debugging and/or creation of test data.
+// Proper usage of this package requires knowledge of the wire format.
+//
+// See https://developers.google.com/protocol-buffers/docs/encoding.
+package protopack
+
+import (
+	"fmt"
+	"io"
+	"math"
+	"path"
+	"reflect"
+	"strconv"
+	"strings"
+	"unicode"
+	"unicode/utf8"
+
+	"google.golang.org/protobuf/encoding/protowire"
+	"google.golang.org/protobuf/reflect/protoreflect"
+)
+
+// Number is the field number; aliased from the protowire package for convenience.
+type Number = protowire.Number
+
+// Number type constants; copied from the protowire package for convenience.
+const (
+	MinValidNumber      Number = protowire.MinValidNumber
+	FirstReservedNumber Number = protowire.FirstReservedNumber
+	LastReservedNumber  Number = protowire.LastReservedNumber
+	MaxValidNumber      Number = protowire.MaxValidNumber
+)
+
+// Type is the wire type; aliased from the protowire package for convenience.
+type Type = protowire.Type
+
+// Wire type constants; copied from the protowire package for convenience.
+const (
+	VarintType     Type = protowire.VarintType
+	Fixed32Type    Type = protowire.Fixed32Type
+	Fixed64Type    Type = protowire.Fixed64Type
+	BytesType      Type = protowire.BytesType
+	StartGroupType Type = protowire.StartGroupType
+	EndGroupType   Type = protowire.EndGroupType
+)
+
+type (
+	// Token is any other type (e.g., Message, Tag, Varint, Float32, etc).
+	Token token
+	// Message is an ordered sequence of  Tokens, where certain tokens may
+	// contain other tokens. It is functionally a concrete syntax tree that
+	// losslessly represents any arbitrary wire data (including invalid input).
+	Message []Token
+
+	// Tag is a tuple of the field number and the wire type.
+	Tag struct {
+		Number Number
+		Type   Type
+	}
+	// Bool is a boolean.
+	Bool bool
+	// Varint is a signed varint using 64-bit two's complement encoding.
+	Varint int64
+	// Svarint is a signed varint using zig-zag encoding.
+	Svarint int64
+	// Uvarint is a unsigned varint.
+	Uvarint uint64
+
+	// Int32 is a signed 32-bit fixed-width integer.
+	Int32 int32
+	// Uint32 is an unsigned 32-bit fixed-width integer.
+	Uint32 uint32
+	// Float32 is a 32-bit fixed-width floating point number.
+	Float32 float32
+
+	// Int64 is a signed 64-bit fixed-width integer.
+	Int64 int64
+	// Uint64 is an unsigned 64-bit fixed-width integer.
+	Uint64 uint64
+	// Float64 is a 64-bit fixed-width floating point number.
+	Float64 float64
+
+	// String is a length-prefixed string.
+	String string
+	// Bytes is a length-prefixed bytes.
+	Bytes []byte
+	// LengthPrefix is a length-prefixed message.
+	LengthPrefix Message
+
+	// Denormalized is a denormalized varint value, where a varint is encoded
+	// using more bytes than is strictly necessary. The number of extra bytes
+	// alone is sufficient to losslessly represent the denormalized varint.
+	//
+	// The value may be one of Tag, Bool, Varint, Svarint, or Uvarint,
+	// where the varint representation of each token is denormalized.
+	//
+	// Alternatively, the value may be one of String, Bytes, or LengthPrefix,
+	// where the varint representation of the length-prefix is denormalized.
+	Denormalized struct {
+		Count uint // number of extra bytes
+		Value Token
+	}
+
+	// Raw are bytes directly appended to output.
+	Raw []byte
+)
+
+type token interface {
+	isToken()
+}
+
+func (Message) isToken()      {}
+func (Tag) isToken()          {}
+func (Bool) isToken()         {}
+func (Varint) isToken()       {}
+func (Svarint) isToken()      {}
+func (Uvarint) isToken()      {}
+func (Int32) isToken()        {}
+func (Uint32) isToken()       {}
+func (Float32) isToken()      {}
+func (Int64) isToken()        {}
+func (Uint64) isToken()       {}
+func (Float64) isToken()      {}
+func (String) isToken()       {}
+func (Bytes) isToken()        {}
+func (LengthPrefix) isToken() {}
+func (Denormalized) isToken() {}
+func (Raw) isToken()          {}
+
+// Size reports the size in bytes of the marshaled message.
+func (m Message) Size() int {
+	var n int
+	for _, v := range m {
+		switch v := v.(type) {
+		case Message:
+			n += v.Size()
+		case Tag:
+			n += protowire.SizeTag(v.Number)
+		case Bool:
+			n += protowire.SizeVarint(protowire.EncodeBool(false))
+		case Varint:
+			n += protowire.SizeVarint(uint64(v))
+		case Svarint:
+			n += protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
+		case Uvarint:
+			n += protowire.SizeVarint(uint64(v))
+		case Int32, Uint32, Float32:
+			n += protowire.SizeFixed32()
+		case Int64, Uint64, Float64:
+			n += protowire.SizeFixed64()
+		case String:
+			n += protowire.SizeBytes(len(v))
+		case Bytes:
+			n += protowire.SizeBytes(len(v))
+		case LengthPrefix:
+			n += protowire.SizeBytes(Message(v).Size())
+		case Denormalized:
+			n += int(v.Count) + Message{v.Value}.Size()
+		case Raw:
+			n += len(v)
+		default:
+			panic(fmt.Sprintf("unknown type: %T", v))
+		}
+	}
+	return n
+}
+
+// Marshal encodes a syntax tree into the protobuf wire format.
+//
+// Example message definition:
+//	message MyMessage {
+//		string field1 = 1;
+//		int64 field2 = 2;
+//		repeated float32 field3 = 3;
+//	}
+//
+// Example encoded message:
+//	b := Message{
+//		Tag{1, BytesType}, String("Hello, world!"),
+//		Tag{2, VarintType}, Varint(-10),
+//		Tag{3, BytesType}, LengthPrefix{
+//			Float32(1.1), Float32(2.2), Float32(3.3),
+//		},
+//	}.Marshal()
+//
+// Resulting wire data:
+//	0x0000  0a 0d 48 65 6c 6c 6f 2c  20 77 6f 72 6c 64 21 10  |..Hello, world!.|
+//	0x0010  f6 ff ff ff ff ff ff ff  ff 01 1a 0c cd cc 8c 3f  |...............?|
+//	0x0020  cd cc 0c 40 33 33 53 40                           |...@33S@|
+func (m Message) Marshal() []byte {
+	var out []byte
+	for _, v := range m {
+		switch v := v.(type) {
+		case Message:
+			out = append(out, v.Marshal()...)
+		case Tag:
+			out = protowire.AppendTag(out, v.Number, v.Type)
+		case Bool:
+			out = protowire.AppendVarint(out, protowire.EncodeBool(bool(v)))
+		case Varint:
+			out = protowire.AppendVarint(out, uint64(v))
+		case Svarint:
+			out = protowire.AppendVarint(out, protowire.EncodeZigZag(int64(v)))
+		case Uvarint:
+			out = protowire.AppendVarint(out, uint64(v))
+		case Int32:
+			out = protowire.AppendFixed32(out, uint32(v))
+		case Uint32:
+			out = protowire.AppendFixed32(out, uint32(v))
+		case Float32:
+			out = protowire.AppendFixed32(out, math.Float32bits(float32(v)))
+		case Int64:
+			out = protowire.AppendFixed64(out, uint64(v))
+		case Uint64:
+			out = protowire.AppendFixed64(out, uint64(v))
+		case Float64:
+			out = protowire.AppendFixed64(out, math.Float64bits(float64(v)))
+		case String:
+			out = protowire.AppendBytes(out, []byte(v))
+		case Bytes:
+			out = protowire.AppendBytes(out, []byte(v))
+		case LengthPrefix:
+			out = protowire.AppendBytes(out, Message(v).Marshal())
+		case Denormalized:
+			b := Message{v.Value}.Marshal()
+			_, n := protowire.ConsumeVarint(b)
+			out = append(out, b[:n]...)
+			for i := uint(0); i < v.Count; i++ {
+				out[len(out)-1] |= 0x80 // set continuation bit on previous
+				out = append(out, 0)
+			}
+			out = append(out, b[n:]...)
+		case Raw:
+			return append(out, v...)
+		default:
+			panic(fmt.Sprintf("unknown type: %T", v))
+		}
+	}
+	return out
+}
+
+// Unmarshal parses the input protobuf wire data as a syntax tree.
+// Any parsing error results in the remainder of the input being
+// concatenated to the message as a Raw type.
+//
+// Each tag (a tuple of the field number and wire type) encountered is
+// inserted into the syntax tree as a Tag.
+//
+// The contents of each wire type is mapped to the following Go types:
+//	VarintType   => Uvarint
+//	Fixed32Type  => Uint32
+//	Fixed64Type  => Uint64
+//	BytesType    => Bytes
+//	GroupType    => Message
+//
+// Since the wire format is not self-describing, this function cannot parse
+// sub-messages and will leave them as the Bytes type. Further manual parsing
+// can be performed as such:
+//	var m, m1, m2 Message
+//	m.Unmarshal(b)
+//	m1.Unmarshal(m[3].(Bytes))
+//	m[3] = LengthPrefix(m1)
+//	m2.Unmarshal(m[3].(LengthPrefix)[1].(Bytes))
+//	m[3].(LengthPrefix)[1] = LengthPrefix(m2)
+//
+// Unmarshal is useful for debugging the protobuf wire format.
+func (m *Message) Unmarshal(in []byte) {
+	m.UnmarshalDescriptor(in, nil)
+}
+
+// UnmarshalDescriptor parses the input protobuf wire data as a syntax tree
+// using the provided message descriptor for more accurate parsing of fields.
+// It operates like Unmarshal, but may use a wider range of Go types to
+// represent the wire data.
+//
+// The contents of each wire type is mapped to one of the following Go types:
+//	VarintType   => Bool, Varint, Svarint, Uvarint
+//	Fixed32Type  => Int32, Uint32, Float32
+//	Fixed64Type  => Uint32, Uint64, Float64
+//	BytesType    => String, Bytes, LengthPrefix
+//	GroupType    => Message
+//
+// If the field is unknown, it uses the same mapping as Unmarshal.
+// Known sub-messages are parsed as a Message and packed repeated fields are
+// parsed as a LengthPrefix.
+func (m *Message) UnmarshalDescriptor(in []byte, desc protoreflect.MessageDescriptor) {
+	p := parser{in: in, out: *m}
+	p.parseMessage(desc, false)
+	*m = p.out
+}
+
+type parser struct {
+	in  []byte
+	out []Token
+}
+
+func (p *parser) parseMessage(msgDesc protoreflect.MessageDescriptor, group bool) {
+	for len(p.in) > 0 {
+		v, n := protowire.ConsumeVarint(p.in)
+		num, typ := protowire.DecodeTag(v)
+		if n < 0 || num < 0 || v > math.MaxUint32 {
+			p.out, p.in = append(p.out, Raw(p.in)), nil
+			return
+		}
+		if typ == EndGroupType && group {
+			return // if inside a group, then stop
+		}
+		p.out, p.in = append(p.out, Tag{num, typ}), p.in[n:]
+		if m := n - protowire.SizeVarint(v); m > 0 {
+			p.out[len(p.out)-1] = Denormalized{uint(m), p.out[len(p.out)-1]}
+		}
+
+		// If descriptor is available, use it for more accurate parsing.
+		var isPacked bool
+		var kind protoreflect.Kind
+		var subDesc protoreflect.MessageDescriptor
+		if msgDesc != nil && !msgDesc.IsPlaceholder() {
+			if fieldDesc := msgDesc.Fields().ByNumber(num); fieldDesc != nil {
+				isPacked = fieldDesc.IsPacked()
+				kind = fieldDesc.Kind()
+				switch kind {
+				case protoreflect.MessageKind, protoreflect.GroupKind:
+					subDesc = fieldDesc.Message()
+					if subDesc == nil || subDesc.IsPlaceholder() {
+						kind = 0
+					}
+				}
+			}
+		}
+
+		switch typ {
+		case VarintType:
+			p.parseVarint(kind)
+		case Fixed32Type:
+			p.parseFixed32(kind)
+		case Fixed64Type:
+			p.parseFixed64(kind)
+		case BytesType:
+			p.parseBytes(isPacked, kind, subDesc)
+		case StartGroupType:
+			p.parseGroup(subDesc)
+		case EndGroupType:
+			// Handled above.
+		default:
+			p.out, p.in = append(p.out, Raw(p.in)), nil
+		}
+	}
+}
+
+func (p *parser) parseVarint(kind protoreflect.Kind) {
+	v, n := protowire.ConsumeVarint(p.in)
+	if n < 0 {
+		p.out, p.in = append(p.out, Raw(p.in)), nil
+		return
+	}
+	switch kind {
+	case protoreflect.BoolKind:
+		switch v {
+		case 0:
+			p.out, p.in = append(p.out, Bool(false)), p.in[n:]
+		case 1:
+			p.out, p.in = append(p.out, Bool(true)), p.in[n:]
+		default:
+			p.out, p.in = append(p.out, Uvarint(v)), p.in[n:]
+		}
+	case protoreflect.Int32Kind, protoreflect.Int64Kind:
+		p.out, p.in = append(p.out, Varint(v)), p.in[n:]
+	case protoreflect.Sint32Kind, protoreflect.Sint64Kind:
+		p.out, p.in = append(p.out, Svarint(protowire.DecodeZigZag(v))), p.in[n:]
+	default:
+		p.out, p.in = append(p.out, Uvarint(v)), p.in[n:]
+	}
+	if m := n - protowire.SizeVarint(v); m > 0 {
+		p.out[len(p.out)-1] = Denormalized{uint(m), p.out[len(p.out)-1]}
+	}
+}
+
+func (p *parser) parseFixed32(kind protoreflect.Kind) {
+	v, n := protowire.ConsumeFixed32(p.in)
+	if n < 0 {
+		p.out, p.in = append(p.out, Raw(p.in)), nil
+		return
+	}
+	switch kind {
+	case protoreflect.FloatKind:
+		p.out, p.in = append(p.out, Float32(math.Float32frombits(v))), p.in[n:]
+	case protoreflect.Sfixed32Kind:
+		p.out, p.in = append(p.out, Int32(v)), p.in[n:]
+	default:
+		p.out, p.in = append(p.out, Uint32(v)), p.in[n:]
+	}
+}
+
+func (p *parser) parseFixed64(kind protoreflect.Kind) {
+	v, n := protowire.ConsumeFixed64(p.in)
+	if n < 0 {
+		p.out, p.in = append(p.out, Raw(p.in)), nil
+		return
+	}
+	switch kind {
+	case protoreflect.DoubleKind:
+		p.out, p.in = append(p.out, Float64(math.Float64frombits(v))), p.in[n:]
+	case protoreflect.Sfixed64Kind:
+		p.out, p.in = append(p.out, Int64(v)), p.in[n:]
+	default:
+		p.out, p.in = append(p.out, Uint64(v)), p.in[n:]
+	}
+}
+
+func (p *parser) parseBytes(isPacked bool, kind protoreflect.Kind, desc protoreflect.MessageDescriptor) {
+	v, n := protowire.ConsumeVarint(p.in)
+	if n < 0 {
+		p.out, p.in = append(p.out, Raw(p.in)), nil
+		return
+	}
+	p.out, p.in = append(p.out, Uvarint(v)), p.in[n:]
+	if m := n - protowire.SizeVarint(v); m > 0 {
+		p.out[len(p.out)-1] = Denormalized{uint(m), p.out[len(p.out)-1]}
+	}
+	if v > uint64(len(p.in)) {
+		p.out, p.in = append(p.out, Raw(p.in)), nil
+		return
+	}
+	p.out = p.out[:len(p.out)-1] // subsequent tokens contain prefix-length
+
+	if isPacked {
+		p.parsePacked(int(v), kind)
+	} else {
+		switch kind {
+		case protoreflect.MessageKind:
+			p2 := parser{in: p.in[:v]}
+			p2.parseMessage(desc, false)
+			p.out, p.in = append(p.out, LengthPrefix(p2.out)), p.in[v:]
+		case protoreflect.StringKind:
+			p.out, p.in = append(p.out, String(p.in[:v])), p.in[v:]
+		default:
+			p.out, p.in = append(p.out, Bytes(p.in[:v])), p.in[v:]
+		}
+	}
+	if m := n - protowire.SizeVarint(v); m > 0 {
+		p.out[len(p.out)-1] = Denormalized{uint(m), p.out[len(p.out)-1]}
+	}
+}
+
+func (p *parser) parsePacked(n int, kind protoreflect.Kind) {
+	p2 := parser{in: p.in[:n]}
+	for len(p2.in) > 0 {
+		switch kind {
+		case protoreflect.BoolKind, protoreflect.EnumKind,
+			protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Uint32Kind,
+			protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Uint64Kind:
+			p2.parseVarint(kind)
+		case protoreflect.Fixed32Kind, protoreflect.Sfixed32Kind, protoreflect.FloatKind:
+			p2.parseFixed32(kind)
+		case protoreflect.Fixed64Kind, protoreflect.Sfixed64Kind, protoreflect.DoubleKind:
+			p2.parseFixed64(kind)
+		default:
+			panic(fmt.Sprintf("invalid packed kind: %v", kind))
+		}
+	}
+	p.out, p.in = append(p.out, LengthPrefix(p2.out)), p.in[n:]
+}
+
+func (p *parser) parseGroup(desc protoreflect.MessageDescriptor) {
+	p2 := parser{in: p.in}
+	p2.parseMessage(desc, true)
+	if len(p2.out) > 0 {
+		p.out = append(p.out, Message(p2.out))
+	}
+	p.in = p2.in
+
+	// Append the trailing end group.
+	v, n := protowire.ConsumeVarint(p.in)
+	if num, typ := protowire.DecodeTag(v); typ == EndGroupType {
+		p.out, p.in = append(p.out, Tag{num, typ}), p.in[n:]
+		if m := n - protowire.SizeVarint(v); m > 0 {
+			p.out[len(p.out)-1] = Denormalized{uint(m), p.out[len(p.out)-1]}
+		}
+	}
+}
+
+// Format implements a custom formatter to visualize the syntax tree.
+// Using "%#v" formats the Message in Go source code.
+func (m Message) Format(s fmt.State, r rune) {
+	switch r {
+	case 'x':
+		io.WriteString(s, fmt.Sprintf("%x", m.Marshal()))
+	case 'X':
+		io.WriteString(s, fmt.Sprintf("%X", m.Marshal()))
+	case 'v':
+		switch {
+		case s.Flag('#'):
+			io.WriteString(s, m.format(true, true))
+		case s.Flag('+'):
+			io.WriteString(s, m.format(false, true))
+		default:
+			io.WriteString(s, m.format(false, false))
+		}
+	default:
+		panic("invalid verb: " + string(r))
+	}
+}
+
+// format formats the message.
+// If source is enabled, this emits valid Go source.
+// If multi is enabled, the output may span multiple lines.
+func (m Message) format(source, multi bool) string {
+	var ss []string
+	var prefix, nextPrefix string
+	for _, v := range m {
+		// Ensure certain tokens have preceding or succeeding newlines.
+		prefix, nextPrefix = nextPrefix, " "
+		if multi {
+			switch v := v.(type) {
+			case Tag: // only has preceding newline
+				prefix = "\n"
+			case Denormalized: // only has preceding newline
+				if _, ok := v.Value.(Tag); ok {
+					prefix = "\n"
+				}
+			case Message, Raw: // has preceding and succeeding newlines
+				prefix, nextPrefix = "\n", "\n"
+			}
+		}
+
+		s := formatToken(v, source, multi)
+		ss = append(ss, prefix+s+",")
+	}
+
+	var s string
+	if len(ss) > 0 {
+		s = strings.TrimSpace(strings.Join(ss, ""))
+		if multi {
+			s = "\n\t" + strings.Join(strings.Split(s, "\n"), "\n\t") + "\n"
+		} else {
+			s = strings.TrimSuffix(s, ",")
+		}
+	}
+	s = fmt.Sprintf("%T{%s}", m, s)
+	if !source {
+		s = trimPackage(s)
+	}
+	return s
+}
+
+// formatToken formats a single token.
+func formatToken(t Token, source, multi bool) (s string) {
+	switch v := t.(type) {
+	case Message:
+		s = v.format(source, multi)
+	case LengthPrefix:
+		s = formatPacked(v, source, multi)
+		if s == "" {
+			ms := Message(v).format(source, multi)
+			s = fmt.Sprintf("%T(%s)", v, ms)
+		}
+	case Tag:
+		s = fmt.Sprintf("%T{%d, %s}", v, v.Number, formatType(v.Type, source))
+	case Bool, Varint, Svarint, Uvarint, Int32, Uint32, Float32, Int64, Uint64, Float64:
+		if source {
+			// Print floats in a way that preserves exact precision.
+			if f, _ := v.(Float32); math.IsNaN(float64(f)) || math.IsInf(float64(f), 0) {
+				switch {
+				case f > 0:
+					s = fmt.Sprintf("%T(math.Inf(+1))", v)
+				case f < 0:
+					s = fmt.Sprintf("%T(math.Inf(-1))", v)
+				case math.Float32bits(float32(math.NaN())) == math.Float32bits(float32(f)):
+					s = fmt.Sprintf("%T(math.NaN())", v)
+				default:
+					s = fmt.Sprintf("%T(math.Float32frombits(0x%08x))", v, math.Float32bits(float32(f)))
+				}
+				break
+			}
+			if f, _ := v.(Float64); math.IsNaN(float64(f)) || math.IsInf(float64(f), 0) {
+				switch {
+				case f > 0:
+					s = fmt.Sprintf("%T(math.Inf(+1))", v)
+				case f < 0:
+					s = fmt.Sprintf("%T(math.Inf(-1))", v)
+				case math.Float64bits(float64(math.NaN())) == math.Float64bits(float64(f)):
+					s = fmt.Sprintf("%T(math.NaN())", v)
+				default:
+					s = fmt.Sprintf("%T(math.Float64frombits(0x%08x))", v, math.Float64bits(float64(f)))
+				}
+				break
+			}
+		}
+		s = fmt.Sprintf("%T(%v)", v, v)
+	case String, Bytes, Raw:
+		s = fmt.Sprintf("%s", v)
+		s = fmt.Sprintf("%T(%s)", v, formatString(s))
+	case Denormalized:
+		s = fmt.Sprintf("%T{+%d, %v}", v, v.Count, formatToken(v.Value, source, multi))
+	default:
+		panic(fmt.Sprintf("unknown type: %T", v))
+	}
+	if !source {
+		s = trimPackage(s)
+	}
+	return s
+}
+
+// formatPacked returns a non-empty string if LengthPrefix looks like a packed
+// repeated field of primitives.
+func formatPacked(v LengthPrefix, source, multi bool) string {
+	var ss []string
+	for _, v := range v {
+		switch v.(type) {
+		case Bool, Varint, Svarint, Uvarint, Int32, Uint32, Float32, Int64, Uint64, Float64, Denormalized, Raw:
+			if v, ok := v.(Denormalized); ok {
+				switch v.Value.(type) {
+				case Bool, Varint, Svarint, Uvarint:
+				default:
+					return ""
+				}
+			}
+			ss = append(ss, formatToken(v, source, multi))
+		default:
+			return ""
+		}
+	}
+	s := fmt.Sprintf("%T{%s}", v, strings.Join(ss, ", "))
+	if !source {
+		s = trimPackage(s)
+	}
+	return s
+}
+
+// formatType returns the name for Type.
+func formatType(t Type, source bool) (s string) {
+	switch t {
+	case VarintType:
+		s = pkg + ".VarintType"
+	case Fixed32Type:
+		s = pkg + ".Fixed32Type"
+	case Fixed64Type:
+		s = pkg + ".Fixed64Type"
+	case BytesType:
+		s = pkg + ".BytesType"
+	case StartGroupType:
+		s = pkg + ".StartGroupType"
+	case EndGroupType:
+		s = pkg + ".EndGroupType"
+	default:
+		s = fmt.Sprintf("Type(%d)", t)
+	}
+	if !source {
+		s = strings.TrimSuffix(trimPackage(s), "Type")
+	}
+	return s
+}
+
+// formatString returns a quoted string for s.
+func formatString(s string) string {
+	// Use quoted string if it the same length as a raw string literal.
+	// Otherwise, attempt to use the raw string form.
+	qs := strconv.Quote(s)
+	if len(qs) == 1+len(s)+1 {
+		return qs
+	}
+
+	// Disallow newlines to ensure output is a single line.
+	// Disallow non-printable runes for readability purposes.
+	rawInvalid := func(r rune) bool {
+		return r == '`' || r == '\n' || r == utf8.RuneError || !unicode.IsPrint(r)
+	}
+	if strings.IndexFunc(s, rawInvalid) < 0 {
+		return "`" + s + "`"
+	}
+	return qs
+}
+
+var pkg = path.Base(reflect.TypeOf(Tag{}).PkgPath())
+
+func trimPackage(s string) string {
+	return strings.TrimPrefix(strings.TrimPrefix(s, pkg), ".")
+}
diff --git a/vendor/google.golang.org/protobuf/testing/protopack/pack_test.go b/vendor/google.golang.org/protobuf/testing/protopack/pack_test.go
new file mode 100644
index 000000000..97525497d
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/testing/protopack/pack_test.go
@@ -0,0 +1,366 @@
+// 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 protopack
+
+import (
+	"bytes"
+	"encoding/hex"
+	"fmt"
+	"math"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+
+	"google.golang.org/protobuf/encoding/prototext"
+	pdesc "google.golang.org/protobuf/reflect/protodesc"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+
+	"google.golang.org/protobuf/types/descriptorpb"
+)
+
+var msgDesc = func() pref.MessageDescriptor {
+	const s = `
+		name:   "test.proto"
+		syntax: "proto2"
+		message_type: [{
+			name: "Message"
+			field: [
+				{name:"f1"  number:1  label:LABEL_REPEATED type:TYPE_BOOL     options:{packed:true}},
+				{name:"f2"  number:2  label:LABEL_REPEATED type:TYPE_INT64    options:{packed:true}},
+				{name:"f3"  number:3  label:LABEL_REPEATED type:TYPE_SINT64   options:{packed:true}},
+				{name:"f4"  number:4  label:LABEL_REPEATED type:TYPE_UINT64   options:{packed:true}},
+				{name:"f5"  number:5  label:LABEL_REPEATED type:TYPE_FIXED32  options:{packed:true}},
+				{name:"f6"  number:6  label:LABEL_REPEATED type:TYPE_SFIXED32 options:{packed:true}},
+				{name:"f7"  number:7  label:LABEL_REPEATED type:TYPE_FLOAT    options:{packed:true}},
+				{name:"f8"  number:8  label:LABEL_REPEATED type:TYPE_FIXED64  options:{packed:true}},
+				{name:"f9"  number:9  label:LABEL_REPEATED type:TYPE_SFIXED64 options:{packed:true}},
+				{name:"f10" number:10 label:LABEL_REPEATED type:TYPE_DOUBLE   options:{packed:true}},
+				{name:"f11" number:11 label:LABEL_OPTIONAL type:TYPE_STRING},
+				{name:"f12" number:12 label:LABEL_OPTIONAL type:TYPE_BYTES},
+				{name:"f13" number:13 label:LABEL_OPTIONAL type:TYPE_MESSAGE type_name:".Message"},
+				{name:"f14" number:14 label:LABEL_OPTIONAL type:TYPE_GROUP   type_name:".Message.F14"}
+			]
+			nested_type: [{name: "F14"}]
+		}]
+	`
+	pb := new(descriptorpb.FileDescriptorProto)
+	if err := prototext.Unmarshal([]byte(s), pb); err != nil {
+		panic(err)
+	}
+	fd, err := pdesc.NewFile(pb, nil)
+	if err != nil {
+		panic(err)
+	}
+	return fd.Messages().Get(0)
+}()
+
+// dhex decodes a hex-string and returns the bytes and panics if s is invalid.
+func dhex(s string) []byte {
+	b, err := hex.DecodeString(s)
+	if err != nil {
+		panic(err)
+	}
+	return b
+}
+
+func TestPack(t *testing.T) {
+	tests := []struct {
+		raw []byte
+		msg Message
+
+		wantOutCompact string
+		wantOutMulti   string
+		wantOutSource  string
+	}{{
+		raw: dhex("080088808080800002088280808080000a09010002828080808000"),
+		msg: Message{
+			Tag{1, VarintType}, Bool(false),
+			Denormalized{5, Tag{1, VarintType}}, Uvarint(2),
+			Tag{1, VarintType}, Denormalized{5, Uvarint(2)},
+			Tag{1, BytesType}, LengthPrefix{Bool(true), Bool(false), Uvarint(2), Denormalized{5, Uvarint(2)}},
+		},
+		wantOutSource: `protopack.Message{
+	protopack.Tag{1, protopack.VarintType}, protopack.Bool(false),
+	protopack.Denormalized{+5, protopack.Tag{1, protopack.VarintType}}, protopack.Uvarint(2),
+	protopack.Tag{1, protopack.VarintType}, protopack.Denormalized{+5, protopack.Uvarint(2)},
+	protopack.Tag{1, protopack.BytesType}, protopack.LengthPrefix{protopack.Bool(true), protopack.Bool(false), protopack.Uvarint(2), protopack.Denormalized{+5, protopack.Uvarint(2)}},
+}`,
+	}, {
+		raw: dhex("100010828080808000121980808080808080808001ffffffffffffffff7f828080808000"),
+		msg: Message{
+			Tag{2, VarintType}, Varint(0),
+			Tag{2, VarintType}, Denormalized{5, Varint(2)},
+			Tag{2, BytesType}, LengthPrefix{Varint(math.MinInt64), Varint(math.MaxInt64), Denormalized{5, Varint(2)}},
+		},
+		wantOutCompact: `Message{Tag{2, Varint}, Varint(0), Tag{2, Varint}, Denormalized{+5, Varint(2)}, Tag{2, Bytes}, LengthPrefix{Varint(-9223372036854775808), Varint(9223372036854775807), Denormalized{+5, Varint(2)}}}`,
+	}, {
+		raw: dhex("1801188180808080001a1affffffffffffffffff01feffffffffffffffff01818080808000"),
+		msg: Message{
+			Tag{3, VarintType}, Svarint(-1),
+			Tag{3, VarintType}, Denormalized{5, Svarint(-1)},
+			Tag{3, BytesType}, LengthPrefix{Svarint(math.MinInt64), Svarint(math.MaxInt64), Denormalized{5, Svarint(-1)}},
+		},
+		wantOutMulti: `Message{
+	Tag{3, Varint}, Svarint(-1),
+	Tag{3, Varint}, Denormalized{+5, Svarint(-1)},
+	Tag{3, Bytes}, LengthPrefix{Svarint(-9223372036854775808), Svarint(9223372036854775807), Denormalized{+5, Svarint(-1)}},
+}`,
+	}, {
+		raw: dhex("200120818080808000221100ffffffffffffffffff01818080808000"),
+		msg: Message{
+			Tag{4, VarintType}, Uvarint(+1),
+			Tag{4, VarintType}, Denormalized{5, Uvarint(+1)},
+			Tag{4, BytesType}, LengthPrefix{Uvarint(0), Uvarint(math.MaxUint64), Denormalized{5, Uvarint(+1)}},
+		},
+		wantOutSource: `protopack.Message{
+	protopack.Tag{4, protopack.VarintType}, protopack.Uvarint(1),
+	protopack.Tag{4, protopack.VarintType}, protopack.Denormalized{+5, protopack.Uvarint(1)},
+	protopack.Tag{4, protopack.BytesType}, protopack.LengthPrefix{protopack.Uvarint(0), protopack.Uvarint(18446744073709551615), protopack.Denormalized{+5, protopack.Uvarint(1)}},
+}`,
+	}, {
+		raw: dhex("2d010000002a0800000000ffffffff"),
+		msg: Message{
+			Tag{5, Fixed32Type}, Uint32(+1),
+			Tag{5, BytesType}, LengthPrefix{Uint32(0), Uint32(math.MaxUint32)},
+		},
+		wantOutCompact: `Message{Tag{5, Fixed32}, Uint32(1), Tag{5, Bytes}, LengthPrefix{Uint32(0), Uint32(4294967295)}}`,
+	}, {
+		raw: dhex("35ffffffff320800000080ffffff7f"),
+		msg: Message{
+			Tag{6, Fixed32Type}, Int32(-1),
+			Tag{6, BytesType}, LengthPrefix{Int32(math.MinInt32), Int32(math.MaxInt32)},
+		},
+		wantOutMulti: `Message{
+	Tag{6, Fixed32}, Int32(-1),
+	Tag{6, Bytes}, LengthPrefix{Int32(-2147483648), Int32(2147483647)},
+}`,
+	}, {
+		raw: dhex("3ddb0f49403a1001000000ffff7f7f0000807f000080ff"),
+		msg: Message{
+			Tag{7, Fixed32Type}, Float32(math.Pi),
+			Tag{7, BytesType}, LengthPrefix{Float32(math.SmallestNonzeroFloat32), Float32(math.MaxFloat32), Float32(math.Inf(+1)), Float32(math.Inf(-1))},
+		},
+		wantOutSource: `protopack.Message{
+	protopack.Tag{7, protopack.Fixed32Type}, protopack.Float32(3.1415927),
+	protopack.Tag{7, protopack.BytesType}, protopack.LengthPrefix{protopack.Float32(1e-45), protopack.Float32(3.4028235e+38), protopack.Float32(math.Inf(+1)), protopack.Float32(math.Inf(-1))},
+}`,
+	}, {
+		raw: dhex("41010000000000000042100000000000000000ffffffffffffffff"),
+		msg: Message{
+			Tag{8, Fixed64Type}, Uint64(+1),
+			Tag{8, BytesType}, LengthPrefix{Uint64(0), Uint64(math.MaxUint64)},
+		},
+		wantOutCompact: `Message{Tag{8, Fixed64}, Uint64(1), Tag{8, Bytes}, LengthPrefix{Uint64(0), Uint64(18446744073709551615)}}`,
+	}, {
+		raw: dhex("49ffffffffffffffff4a100000000000000080ffffffffffffff7f"),
+		msg: Message{
+			Tag{9, Fixed64Type}, Int64(-1),
+			Tag{9, BytesType}, LengthPrefix{Int64(math.MinInt64), Int64(math.MaxInt64)},
+		},
+		wantOutMulti: `Message{
+	Tag{9, Fixed64}, Int64(-1),
+	Tag{9, Bytes}, LengthPrefix{Int64(-9223372036854775808), Int64(9223372036854775807)},
+}`,
+	}, {
+		raw: dhex("51182d4454fb21094052200100000000000000ffffffffffffef7f000000000000f07f000000000000f0ff"),
+		msg: Message{
+			Tag{10, Fixed64Type}, Float64(math.Pi),
+			Tag{10, BytesType}, LengthPrefix{Float64(math.SmallestNonzeroFloat64), Float64(math.MaxFloat64), Float64(math.Inf(+1)), Float64(math.Inf(-1))},
+		},
+		wantOutMulti: `Message{
+	Tag{10, Fixed64}, Float64(3.141592653589793),
+	Tag{10, Bytes}, LengthPrefix{Float64(5e-324), Float64(1.7976931348623157e+308), Float64(+Inf), Float64(-Inf)},
+}`,
+	}, {
+		raw: dhex("5a06737472696e675a868080808000737472696e67"),
+		msg: Message{
+			Tag{11, BytesType}, String("string"),
+			Tag{11, BytesType}, Denormalized{+5, String("string")},
+		},
+		wantOutCompact: `Message{Tag{11, Bytes}, String("string"), Tag{11, Bytes}, Denormalized{+5, String("string")}}`,
+	}, {
+		raw: dhex("62056279746573628580808080006279746573"),
+		msg: Message{
+			Tag{12, BytesType}, Bytes("bytes"),
+			Tag{12, BytesType}, Denormalized{+5, Bytes("bytes")},
+		},
+		wantOutMulti: `Message{
+	Tag{12, Bytes}, Bytes("bytes"),
+	Tag{12, Bytes}, Denormalized{+5, Bytes("bytes")},
+}`,
+	}, {
+		raw: dhex("6a28a006ffffffffffffffffff01a506ffffffffa106ffffffffffffffffa206056279746573a306a406"),
+		msg: Message{
+			Tag{13, BytesType}, LengthPrefix(Message{
+				Tag{100, VarintType}, Uvarint(math.MaxUint64),
+				Tag{100, Fixed32Type}, Uint32(math.MaxUint32),
+				Tag{100, Fixed64Type}, Uint64(math.MaxUint64),
+				Tag{100, BytesType}, Bytes("bytes"),
+				Tag{100, StartGroupType}, Tag{100, EndGroupType},
+			}),
+		},
+		wantOutSource: `protopack.Message{
+	protopack.Tag{13, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{
+		protopack.Tag{100, protopack.VarintType}, protopack.Uvarint(18446744073709551615),
+		protopack.Tag{100, protopack.Fixed32Type}, protopack.Uint32(4294967295),
+		protopack.Tag{100, protopack.Fixed64Type}, protopack.Uint64(18446744073709551615),
+		protopack.Tag{100, protopack.BytesType}, protopack.Bytes("bytes"),
+		protopack.Tag{100, protopack.StartGroupType},
+		protopack.Tag{100, protopack.EndGroupType},
+	}),
+}`,
+	}, {
+		raw: dhex("6aa88080808000a006ffffffffffffffffff01a506ffffffffa106ffffffffffffffffa206056279746573a306a406"),
+		msg: Message{
+			Tag{13, BytesType}, Denormalized{5, LengthPrefix(Message{
+				Tag{100, VarintType}, Uvarint(math.MaxUint64),
+				Tag{100, Fixed32Type}, Uint32(math.MaxUint32),
+				Tag{100, Fixed64Type}, Uint64(math.MaxUint64),
+				Tag{100, BytesType}, Bytes("bytes"),
+				Tag{100, StartGroupType}, Tag{100, EndGroupType},
+			})},
+		},
+		wantOutCompact: `Message{Tag{13, Bytes}, Denormalized{+5, LengthPrefix(Message{Tag{100, Varint}, Uvarint(18446744073709551615), Tag{100, Fixed32}, Uint32(4294967295), Tag{100, Fixed64}, Uint64(18446744073709551615), Tag{100, Bytes}, Bytes("bytes"), Tag{100, StartGroup}, Tag{100, EndGroup}})}}`,
+	}, {
+		raw: dhex("73a006ffffffffffffffffff01a506ffffffffa106ffffffffffffffffa206056279746573a306a40674"),
+		msg: Message{
+			Tag{14, StartGroupType}, Message{
+				Tag{100, VarintType}, Uvarint(math.MaxUint64),
+				Tag{100, Fixed32Type}, Uint32(math.MaxUint32),
+				Tag{100, Fixed64Type}, Uint64(math.MaxUint64),
+				Tag{100, BytesType}, Bytes("bytes"),
+				Tag{100, StartGroupType}, Tag{100, EndGroupType},
+			},
+			Tag{14, EndGroupType},
+		},
+		wantOutMulti: `Message{
+	Tag{14, StartGroup},
+	Message{
+		Tag{100, Varint}, Uvarint(18446744073709551615),
+		Tag{100, Fixed32}, Uint32(4294967295),
+		Tag{100, Fixed64}, Uint64(18446744073709551615),
+		Tag{100, Bytes}, Bytes("bytes"),
+		Tag{100, StartGroup},
+		Tag{100, EndGroup},
+	},
+	Tag{14, EndGroup},
+}`,
+	}, {
+		raw: dhex("d0faa972cd02a5f09051c2d8aa0d6a26a89c311eddef024b423c0f6f47b64227a1600db56e3f73d4113096c9a88e2b99f2d847516853d76a1a6e9811c85a2ab3"),
+		msg: Message{
+			Tag{29970346, VarintType}, Uvarint(333),
+			Tag{21268228, Fixed32Type}, Uint32(229300418),
+			Tag{13, BytesType}, LengthPrefix(Message{
+				Tag{100805, VarintType}, Uvarint(30),
+				Tag{5883, Fixed32Type}, Uint32(255607371),
+				Tag{13, Type(7)},
+				Raw("G\xb6B'\xa1`\r\xb5n?s\xd4\x110\x96ɨ\x8e+\x99\xf2\xd8GQhS"),
+			}),
+			Tag{1706, Type(7)},
+			Raw("\x1an\x98\x11\xc8Z*\xb3"),
+		},
+	}, {
+		raw: dhex("3d08d0e57f"),
+		msg: Message{
+			Tag{7, Fixed32Type}, Float32(math.Float32frombits(
+				// TODO: Remove workaround for compiler bug (see https://golang.org/issues/27193).
+				func() uint32 { return 0x7fe5d008 }(),
+			)),
+		},
+		wantOutSource: `protopack.Message{
+	protopack.Tag{7, protopack.Fixed32Type}, protopack.Float32(math.Float32frombits(0x7fe5d008)),
+}`,
+	}, {
+		raw: dhex("51a8d65110771bf97f"),
+		msg: Message{
+			Tag{10, Fixed64Type}, Float64(math.Float64frombits(0x7ff91b771051d6a8)),
+		},
+		wantOutSource: `protopack.Message{
+	protopack.Tag{10, protopack.Fixed64Type}, protopack.Float64(math.Float64frombits(0x7ff91b771051d6a8)),
+}`,
+	}, {
+		raw: dhex("ab2c14481ab3e9a76d937fb4dd5e6c616ef311f62b7fe888785fca5609ffe81c1064e50dd7a9edb408d317e2891c0d54c719446938d41ab0ccf8e61dc28b0ebb"),
+		msg: Message{
+			Tag{709, StartGroupType},
+			Tag{2, EndGroupType},
+			Tag{9, VarintType}, Uvarint(26),
+			Tag{28655254, StartGroupType},
+			Message{
+				Tag{2034, StartGroupType},
+				Tag{194006, EndGroupType},
+			},
+			Tag{13, EndGroupType},
+			Tag{12, Fixed64Type}, Uint64(9865274810543764334),
+			Tag{15, VarintType}, Uvarint(95),
+			Tag{1385, BytesType}, Bytes("\xff\xe8\x1c\x10d\xe5\rש"),
+			Tag{17229, Fixed32Type}, Uint32(2313295827),
+			Tag{3, EndGroupType},
+			Tag{1, Fixed32Type}, Uint32(1142540116),
+			Tag{13, Fixed64Type}, Uint64(2154683029754926136),
+			Tag{28856, BytesType},
+			Raw("\xbb"),
+		},
+	}, {
+		raw: dhex("29baa4ac1c1e0a20183393bac434b8d3559337ec940050038770eaa9937f98e4"),
+		msg: Message{
+			Tag{5, Fixed64Type}, Uint64(1738400580611384506),
+			Tag{6, StartGroupType},
+			Message{
+				Tag{13771682, StartGroupType},
+				Message{
+					Tag{175415, VarintType}, Uvarint(7059),
+				},
+				Denormalized{+1, Tag{333, EndGroupType}},
+				Tag{10, VarintType}, Uvarint(3),
+				Tag{1792, Type(7)},
+				Raw("꩓\u007f\x98\xe4"),
+			},
+		},
+	}}
+
+	equateFloatBits := cmp.Options{
+		cmp.Comparer(func(x, y Float32) bool {
+			return math.Float32bits(float32(x)) == math.Float32bits(float32(y))
+		}),
+		cmp.Comparer(func(x, y Float64) bool {
+			return math.Float64bits(float64(x)) == math.Float64bits(float64(y))
+		}),
+	}
+	for _, tt := range tests {
+		t.Run("", func(t *testing.T) {
+			var msg Message
+			raw := tt.msg.Marshal()
+			msg.UnmarshalDescriptor(tt.raw, msgDesc)
+
+			if !bytes.Equal(raw, tt.raw) {
+				t.Errorf("Marshal() mismatch:\ngot  %x\nwant %x", raw, tt.raw)
+			}
+			if !cmp.Equal(msg, tt.msg, equateFloatBits) {
+				t.Errorf("Unmarshal() mismatch:\ngot  %+v\nwant %+v", msg, tt.msg)
+			}
+			if got, want := tt.msg.Size(), len(tt.raw); got != want {
+				t.Errorf("Size() = %v, want %v", got, want)
+			}
+			if tt.wantOutCompact != "" {
+				gotOut := fmt.Sprintf("%v", tt.msg)
+				if string(gotOut) != tt.wantOutCompact {
+					t.Errorf("fmt.Sprintf(%q, msg):\ngot:  %s\nwant: %s", "%v", gotOut, tt.wantOutCompact)
+				}
+			}
+			if tt.wantOutMulti != "" {
+				gotOut := fmt.Sprintf("%+v", tt.msg)
+				if string(gotOut) != tt.wantOutMulti {
+					t.Errorf("fmt.Sprintf(%q, msg):\ngot:  %s\nwant: %s", "%+v", gotOut, tt.wantOutMulti)
+				}
+			}
+			if tt.wantOutSource != "" {
+				gotOut := fmt.Sprintf("%#v", tt.msg)
+				if string(gotOut) != tt.wantOutSource {
+					t.Errorf("fmt.Sprintf(%q, msg):\ngot:  %s\nwant: %s", "%#v", gotOut, tt.wantOutSource)
+				}
+			}
+		})
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/testing/prototest/prototest.go b/vendor/google.golang.org/protobuf/testing/prototest/prototest.go
new file mode 100644
index 000000000..55a61aea2
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/testing/prototest/prototest.go
@@ -0,0 +1,786 @@
+// Copyright 2019 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 prototest exercises protobuf reflection.
+package prototest
+
+import (
+	"bytes"
+	"fmt"
+	"math"
+	"reflect"
+	"sort"
+	"testing"
+
+	"google.golang.org/protobuf/encoding/prototext"
+	"google.golang.org/protobuf/encoding/protowire"
+	"google.golang.org/protobuf/proto"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/reflect/protoregistry"
+)
+
+// TODO: Test invalid field descriptors or oneof descriptors.
+// TODO: This should test the functionality that can be provided by fast-paths.
+
+// Message tests a message implemention.
+type Message struct {
+	// Resolver is used to determine the list of extension fields to test with.
+	// If nil, this defaults to using protoregistry.GlobalTypes.
+	Resolver interface {
+		FindExtensionByName(field pref.FullName) (pref.ExtensionType, error)
+		FindExtensionByNumber(message pref.FullName, field pref.FieldNumber) (pref.ExtensionType, error)
+		RangeExtensionsByMessage(message pref.FullName, f func(pref.ExtensionType) bool)
+	}
+}
+
+// Test performs tests on a MessageType implementation.
+func (test Message) Test(t testing.TB, mt pref.MessageType) {
+	testType(t, mt)
+
+	md := mt.Descriptor()
+	m1 := mt.New()
+	for i := 0; i < md.Fields().Len(); i++ {
+		fd := md.Fields().Get(i)
+		testField(t, m1, fd)
+	}
+	if test.Resolver == nil {
+		test.Resolver = protoregistry.GlobalTypes
+	}
+	var extTypes []pref.ExtensionType
+	test.Resolver.RangeExtensionsByMessage(md.FullName(), func(e pref.ExtensionType) bool {
+		extTypes = append(extTypes, e)
+		return true
+	})
+	for _, xt := range extTypes {
+		testField(t, m1, xt.TypeDescriptor())
+	}
+	for i := 0; i < md.Oneofs().Len(); i++ {
+		testOneof(t, m1, md.Oneofs().Get(i))
+	}
+	testUnknown(t, m1)
+
+	// Test round-trip marshal/unmarshal.
+	m2 := mt.New().Interface()
+	populateMessage(m2.ProtoReflect(), 1, nil)
+	for _, xt := range extTypes {
+		m2.ProtoReflect().Set(xt.TypeDescriptor(), newValue(m2.ProtoReflect(), xt.TypeDescriptor(), 1, nil))
+	}
+	b, err := proto.MarshalOptions{
+		AllowPartial: true,
+	}.Marshal(m2)
+	if err != nil {
+		t.Errorf("Marshal() = %v, want nil\n%v", err, prototext.Format(m2))
+	}
+	m3 := mt.New().Interface()
+	if err := (proto.UnmarshalOptions{
+		AllowPartial: true,
+		Resolver:     test.Resolver,
+	}.Unmarshal(b, m3)); err != nil {
+		t.Errorf("Unmarshal() = %v, want nil\n%v", err, prototext.Format(m2))
+	}
+	if !proto.Equal(m2, m3) {
+		t.Errorf("round-trip marshal/unmarshal did not preserve message\nOriginal:\n%v\nNew:\n%v", prototext.Format(m2), prototext.Format(m3))
+	}
+}
+
+func testType(t testing.TB, mt pref.MessageType) {
+	m := mt.New().Interface()
+	want := reflect.TypeOf(m)
+	if got := reflect.TypeOf(m.ProtoReflect().Interface()); got != want {
+		t.Errorf("type mismatch: reflect.TypeOf(m) != reflect.TypeOf(m.ProtoReflect().Interface()): %v != %v", got, want)
+	}
+	if got := reflect.TypeOf(m.ProtoReflect().New().Interface()); got != want {
+		t.Errorf("type mismatch: reflect.TypeOf(m) != reflect.TypeOf(m.ProtoReflect().New().Interface()): %v != %v", got, want)
+	}
+	if got := reflect.TypeOf(m.ProtoReflect().Type().Zero().Interface()); got != want {
+		t.Errorf("type mismatch: reflect.TypeOf(m) != reflect.TypeOf(m.ProtoReflect().Type().Zero().Interface()): %v != %v", got, want)
+	}
+}
+
+// testField exercises set/get/has/clear of a field.
+func testField(t testing.TB, m pref.Message, fd pref.FieldDescriptor) {
+	name := fd.FullName()
+	num := fd.Number()
+
+	switch {
+	case fd.IsList():
+		testFieldList(t, m, fd)
+	case fd.IsMap():
+		testFieldMap(t, m, fd)
+	case fd.Message() != nil:
+	default:
+		if got, want := m.NewField(fd), fd.Default(); !valueEqual(got, want) {
+			t.Errorf("Message.NewField(%v) = %v, want default value %v", name, formatValue(got), formatValue(want))
+		}
+		if fd.Kind() == pref.FloatKind || fd.Kind() == pref.DoubleKind {
+			testFieldFloat(t, m, fd)
+		}
+	}
+
+	// Set to a non-zero value, the zero value, different non-zero values.
+	for _, n := range []seed{1, 0, minVal, maxVal} {
+		v := newValue(m, fd, n, nil)
+		m.Set(fd, v)
+		wantHas := true
+		if n == 0 {
+			if fd.Syntax() == pref.Proto3 && fd.Message() == nil {
+				wantHas = false
+			}
+			if fd.IsExtension() {
+				wantHas = true
+			}
+			if fd.Cardinality() == pref.Repeated {
+				wantHas = false
+			}
+			if fd.ContainingOneof() != nil {
+				wantHas = true
+			}
+		}
+		if fd.Syntax() == pref.Proto3 && fd.Cardinality() != pref.Repeated && fd.ContainingOneof() == nil && fd.Kind() == pref.EnumKind && v.Enum() == 0 {
+			wantHas = false
+		}
+		if got, want := m.Has(fd), wantHas; got != want {
+			t.Errorf("after setting %q to %v:\nMessage.Has(%v) = %v, want %v", name, formatValue(v), num, got, want)
+		}
+		if got, want := m.Get(fd), v; !valueEqual(got, want) {
+			t.Errorf("after setting %q:\nMessage.Get(%v) = %v, want %v", name, num, formatValue(got), formatValue(want))
+		}
+		found := false
+		m.Range(func(d pref.FieldDescriptor, got pref.Value) bool {
+			if fd != d {
+				return true
+			}
+			found = true
+			if want := v; !valueEqual(got, want) {
+				t.Errorf("after setting %q:\nMessage.Range got value %v, want %v", name, formatValue(got), formatValue(want))
+			}
+			return true
+		})
+		if got, want := wantHas, found; got != want {
+			t.Errorf("after setting %q:\nMessageRange saw field: %v, want %v", name, got, want)
+		}
+	}
+
+	m.Clear(fd)
+	if got, want := m.Has(fd), false; got != want {
+		t.Errorf("after clearing %q:\nMessage.Has(%v) = %v, want %v", name, num, got, want)
+	}
+	switch {
+	case fd.IsList():
+		if got := m.Get(fd); got.List().Len() != 0 {
+			t.Errorf("after clearing %q:\nMessage.Get(%v) = %v, want empty list", name, num, formatValue(got))
+		}
+	case fd.IsMap():
+		if got := m.Get(fd); got.Map().Len() != 0 {
+			t.Errorf("after clearing %q:\nMessage.Get(%v) = %v, want empty map", name, num, formatValue(got))
+		}
+	case fd.Message() == nil:
+		if got, want := m.Get(fd), fd.Default(); !valueEqual(got, want) {
+			t.Errorf("after clearing %q:\nMessage.Get(%v) = %v, want default %v", name, num, formatValue(got), formatValue(want))
+		}
+	}
+
+	// Set to the default value.
+	switch {
+	case fd.IsList() || fd.IsMap():
+		m.Set(fd, m.Mutable(fd))
+		if got, want := m.Has(fd), (fd.IsExtension() && fd.Cardinality() != pref.Repeated) || fd.ContainingOneof() != nil; got != want {
+			t.Errorf("after setting %q to default:\nMessage.Has(%v) = %v, want %v", name, num, got, want)
+		}
+	case fd.Message() == nil:
+		m.Set(fd, m.Get(fd))
+		if got, want := m.Get(fd), fd.Default(); !valueEqual(got, want) {
+			t.Errorf("after setting %q to default:\nMessage.Get(%v) = %v, want default %v", name, num, formatValue(got), formatValue(want))
+		}
+	}
+	m.Clear(fd)
+
+	// Set to the wrong type.
+	v := pref.ValueOfString("")
+	if fd.Kind() == pref.StringKind {
+		v = pref.ValueOfInt32(0)
+	}
+	if !panics(func() {
+		m.Set(fd, v)
+	}) {
+		t.Errorf("setting %v to %T succeeds, want panic", name, v.Interface())
+	}
+}
+
+// testFieldMap tests set/get/has/clear of entries in a map field.
+func testFieldMap(t testing.TB, m pref.Message, fd pref.FieldDescriptor) {
+	name := fd.FullName()
+	num := fd.Number()
+
+	// New values.
+	m.Clear(fd) // start with an empty map
+	mapv := m.Get(fd).Map()
+	if mapv.IsValid() {
+		t.Errorf("after clearing field: message.Get(%v).IsValid() = true, want false", name)
+	}
+	if got, want := mapv.NewValue(), newMapValue(fd, mapv, 0, nil); !valueEqual(got, want) {
+		t.Errorf("message.Get(%v).NewValue() = %v, want %v", name, formatValue(got), formatValue(want))
+	}
+	if !panics(func() {
+		m.Set(fd, pref.ValueOfMap(mapv))
+	}) {
+		t.Errorf("message.Set(%v, <invalid>) does not panic", name)
+	}
+	if !panics(func() {
+		mapv.Set(newMapKey(fd, 0), newMapValue(fd, mapv, 0, nil))
+	}) {
+		t.Errorf("message.Get(%v).Set(...) of invalid map does not panic", name)
+	}
+	mapv = m.Mutable(fd).Map() // mutable map
+	if !mapv.IsValid() {
+		t.Errorf("message.Mutable(%v).IsValid() = false, want true", name)
+	}
+	if got, want := mapv.NewValue(), newMapValue(fd, mapv, 0, nil); !valueEqual(got, want) {
+		t.Errorf("message.Mutable(%v).NewValue() = %v, want %v", name, formatValue(got), formatValue(want))
+	}
+
+	// Add values.
+	want := make(testMap)
+	for i, n := range []seed{1, 0, minVal, maxVal} {
+		if got, want := m.Has(fd), i > 0; got != want {
+			t.Errorf("after inserting %d elements to %q:\nMessage.Has(%v) = %v, want %v", i, name, num, got, want)
+		}
+
+		k := newMapKey(fd, n)
+		v := newMapValue(fd, mapv, n, nil)
+		mapv.Set(k, v)
+		want.Set(k, v)
+		if got, want := m.Get(fd), pref.ValueOfMap(want); !valueEqual(got, want) {
+			t.Errorf("after inserting %d elements to %q:\nMessage.Get(%v) = %v, want %v", i, name, num, formatValue(got), formatValue(want))
+		}
+	}
+
+	// Set values.
+	want.Range(func(k pref.MapKey, v pref.Value) bool {
+		nv := newMapValue(fd, mapv, 10, nil)
+		mapv.Set(k, nv)
+		want.Set(k, nv)
+		if got, want := m.Get(fd), pref.ValueOfMap(want); !valueEqual(got, want) {
+			t.Errorf("after setting element %v of %q:\nMessage.Get(%v) = %v, want %v", formatValue(k.Value()), name, num, formatValue(got), formatValue(want))
+		}
+		return true
+	})
+
+	// Clear values.
+	want.Range(func(k pref.MapKey, v pref.Value) bool {
+		mapv.Clear(k)
+		want.Clear(k)
+		if got, want := m.Has(fd), want.Len() > 0; got != want {
+			t.Errorf("after clearing elements of %q:\nMessage.Has(%v) = %v, want %v", name, num, got, want)
+		}
+		if got, want := m.Get(fd), pref.ValueOfMap(want); !valueEqual(got, want) {
+			t.Errorf("after clearing elements of %q:\nMessage.Get(%v) = %v, want %v", name, num, formatValue(got), formatValue(want))
+		}
+		return true
+	})
+	if mapv := m.Get(fd).Map(); mapv.IsValid() {
+		t.Errorf("after clearing all elements: message.Get(%v).IsValid() = true, want false %v", name, formatValue(pref.ValueOfMap(mapv)))
+	}
+
+	// Non-existent map keys.
+	missingKey := newMapKey(fd, 1)
+	if got, want := mapv.Has(missingKey), false; got != want {
+		t.Errorf("non-existent map key in %q: Map.Has(%v) = %v, want %v", name, formatValue(missingKey.Value()), got, want)
+	}
+	if got, want := mapv.Get(missingKey).IsValid(), false; got != want {
+		t.Errorf("non-existent map key in %q: Map.Get(%v).IsValid() = %v, want %v", name, formatValue(missingKey.Value()), got, want)
+	}
+	mapv.Clear(missingKey) // noop
+
+	// Mutable.
+	if fd.MapValue().Message() == nil {
+		if !panics(func() {
+			mapv.Mutable(newMapKey(fd, 1))
+		}) {
+			t.Errorf("Mutable on %q succeeds, want panic", name)
+		}
+	} else {
+		k := newMapKey(fd, 1)
+		v := mapv.Mutable(k)
+		if got, want := mapv.Len(), 1; got != want {
+			t.Errorf("after Mutable on %q, Map.Len() = %v, want %v", name, got, want)
+		}
+		populateMessage(v.Message(), 1, nil)
+		if !valueEqual(mapv.Get(k), v) {
+			t.Errorf("after Mutable on %q, changing new mutable value does not change map entry", name)
+		}
+		mapv.Clear(k)
+	}
+}
+
+type testMap map[interface{}]pref.Value
+
+func (m testMap) Get(k pref.MapKey) pref.Value     { return m[k.Interface()] }
+func (m testMap) Set(k pref.MapKey, v pref.Value)  { m[k.Interface()] = v }
+func (m testMap) Has(k pref.MapKey) bool           { return m.Get(k).IsValid() }
+func (m testMap) Clear(k pref.MapKey)              { delete(m, k.Interface()) }
+func (m testMap) Mutable(k pref.MapKey) pref.Value { panic("unimplemented") }
+func (m testMap) Len() int                         { return len(m) }
+func (m testMap) NewValue() pref.Value             { panic("unimplemented") }
+func (m testMap) Range(f func(pref.MapKey, pref.Value) bool) {
+	for k, v := range m {
+		if !f(pref.ValueOf(k).MapKey(), v) {
+			return
+		}
+	}
+}
+func (m testMap) IsValid() bool { return true }
+
+// testFieldList exercises set/get/append/truncate of values in a list.
+func testFieldList(t testing.TB, m pref.Message, fd pref.FieldDescriptor) {
+	name := fd.FullName()
+	num := fd.Number()
+
+	m.Clear(fd) // start with an empty list
+	list := m.Get(fd).List()
+	if list.IsValid() {
+		t.Errorf("message.Get(%v).IsValid() = true, want false", name)
+	}
+	if !panics(func() {
+		m.Set(fd, pref.ValueOfList(list))
+	}) {
+		t.Errorf("message.Set(%v, <invalid>) does not panic", name)
+	}
+	if !panics(func() {
+		list.Append(newListElement(fd, list, 0, nil))
+	}) {
+		t.Errorf("message.Get(%v).Append(...) of invalid list does not panic", name)
+	}
+	if got, want := list.NewElement(), newListElement(fd, list, 0, nil); !valueEqual(got, want) {
+		t.Errorf("message.Get(%v).NewElement() = %v, want %v", name, formatValue(got), formatValue(want))
+	}
+	list = m.Mutable(fd).List() // mutable list
+	if !list.IsValid() {
+		t.Errorf("message.Get(%v).IsValid() = false, want true", name)
+	}
+	if got, want := list.NewElement(), newListElement(fd, list, 0, nil); !valueEqual(got, want) {
+		t.Errorf("message.Mutable(%v).NewElement() = %v, want %v", name, formatValue(got), formatValue(want))
+	}
+
+	// Append values.
+	var want pref.List = &testList{}
+	for i, n := range []seed{1, 0, minVal, maxVal} {
+		if got, want := m.Has(fd), i > 0; got != want {
+			t.Errorf("after appending %d elements to %q:\nMessage.Has(%v) = %v, want %v", i, name, num, got, want)
+		}
+		v := newListElement(fd, list, n, nil)
+		want.Append(v)
+		list.Append(v)
+
+		if got, want := m.Get(fd), pref.ValueOfList(want); !valueEqual(got, want) {
+			t.Errorf("after appending %d elements to %q:\nMessage.Get(%v) = %v, want %v", i+1, name, num, formatValue(got), formatValue(want))
+		}
+	}
+
+	// Set values.
+	for i := 0; i < want.Len(); i++ {
+		v := newListElement(fd, list, seed(i+10), nil)
+		want.Set(i, v)
+		list.Set(i, v)
+		if got, want := m.Get(fd), pref.ValueOfList(want); !valueEqual(got, want) {
+			t.Errorf("after setting element %d of %q:\nMessage.Get(%v) = %v, want %v", i, name, num, formatValue(got), formatValue(want))
+		}
+	}
+
+	// Truncate.
+	for want.Len() > 0 {
+		n := want.Len() - 1
+		want.Truncate(n)
+		list.Truncate(n)
+		if got, want := m.Has(fd), want.Len() > 0; got != want {
+			t.Errorf("after truncating %q to %d:\nMessage.Has(%v) = %v, want %v", name, n, num, got, want)
+		}
+		if got, want := m.Get(fd), pref.ValueOfList(want); !valueEqual(got, want) {
+			t.Errorf("after truncating %q to %d:\nMessage.Get(%v) = %v, want %v", name, n, num, formatValue(got), formatValue(want))
+		}
+	}
+
+	// AppendMutable.
+	if fd.Message() == nil {
+		if !panics(func() {
+			list.AppendMutable()
+		}) {
+			t.Errorf("AppendMutable on %q succeeds, want panic", name)
+		}
+	} else {
+		v := list.AppendMutable()
+		if got, want := list.Len(), 1; got != want {
+			t.Errorf("after AppendMutable on %q, list.Len() = %v, want %v", name, got, want)
+		}
+		populateMessage(v.Message(), 1, nil)
+		if !valueEqual(list.Get(0), v) {
+			t.Errorf("after AppendMutable on %q, changing new mutable value does not change list item 0", name)
+		}
+		want.Truncate(0)
+	}
+}
+
+type testList struct {
+	a []pref.Value
+}
+
+func (l *testList) Append(v pref.Value)       { l.a = append(l.a, v) }
+func (l *testList) AppendMutable() pref.Value { panic("unimplemented") }
+func (l *testList) Get(n int) pref.Value      { return l.a[n] }
+func (l *testList) Len() int                  { return len(l.a) }
+func (l *testList) Set(n int, v pref.Value)   { l.a[n] = v }
+func (l *testList) Truncate(n int)            { l.a = l.a[:n] }
+func (l *testList) NewElement() pref.Value    { panic("unimplemented") }
+func (l *testList) IsValid() bool             { return true }
+
+// testFieldFloat exercises some interesting floating-point scalar field values.
+func testFieldFloat(t testing.TB, m pref.Message, fd pref.FieldDescriptor) {
+	name := fd.FullName()
+	num := fd.Number()
+
+	for _, v := range []float64{math.Inf(-1), math.Inf(1), math.NaN(), math.Copysign(0, -1)} {
+		var val pref.Value
+		if fd.Kind() == pref.FloatKind {
+			val = pref.ValueOfFloat32(float32(v))
+		} else {
+			val = pref.ValueOfFloat64(float64(v))
+		}
+		m.Set(fd, val)
+		// Note that Has is true for -0.
+		if got, want := m.Has(fd), true; got != want {
+			t.Errorf("after setting %v to %v: Message.Has(%v) = %v, want %v", name, v, num, got, want)
+		}
+		if got, want := m.Get(fd), val; !valueEqual(got, want) {
+			t.Errorf("after setting %v: Message.Get(%v) = %v, want %v", name, num, formatValue(got), formatValue(want))
+		}
+	}
+}
+
+// testOneof tests the behavior of fields in a oneof.
+func testOneof(t testing.TB, m pref.Message, od pref.OneofDescriptor) {
+	for _, mutable := range []bool{false, true} {
+		for i := 0; i < od.Fields().Len(); i++ {
+			fda := od.Fields().Get(i)
+			if mutable {
+				// Set fields by requesting a mutable reference.
+				if !fda.IsMap() && !fda.IsList() && fda.Message() == nil {
+					continue
+				}
+				_ = m.Mutable(fda)
+			} else {
+				// Set fields explicitly.
+				m.Set(fda, newValue(m, fda, 1, nil))
+			}
+			if got, want := m.WhichOneof(od), fda; got != want {
+				t.Errorf("after setting oneof field %q:\nWhichOneof(%q) = %v, want %v", fda.FullName(), fda.Name(), got, want)
+			}
+			for j := 0; j < od.Fields().Len(); j++ {
+				fdb := od.Fields().Get(j)
+				if got, want := m.Has(fdb), i == j; got != want {
+					t.Errorf("after setting oneof field %q:\nGet(%q) = %v, want %v", fda.FullName(), fdb.FullName(), got, want)
+				}
+			}
+		}
+	}
+}
+
+// testUnknown tests the behavior of unknown fields.
+func testUnknown(t testing.TB, m pref.Message) {
+	var b []byte
+	b = protowire.AppendTag(b, 1000, protowire.VarintType)
+	b = protowire.AppendVarint(b, 1001)
+	m.SetUnknown(pref.RawFields(b))
+	if got, want := []byte(m.GetUnknown()), b; !bytes.Equal(got, want) {
+		t.Errorf("after setting unknown fields:\nGetUnknown() = %v, want %v", got, want)
+	}
+}
+
+func formatValue(v pref.Value) string {
+	switch v := v.Interface().(type) {
+	case pref.List:
+		var buf bytes.Buffer
+		buf.WriteString("list[")
+		for i := 0; i < v.Len(); i++ {
+			if i > 0 {
+				buf.WriteString(" ")
+			}
+			buf.WriteString(formatValue(v.Get(i)))
+		}
+		buf.WriteString("]")
+		return buf.String()
+	case pref.Map:
+		var buf bytes.Buffer
+		buf.WriteString("map[")
+		var keys []pref.MapKey
+		v.Range(func(k pref.MapKey, v pref.Value) bool {
+			keys = append(keys, k)
+			return true
+		})
+		sort.Slice(keys, func(i, j int) bool {
+			return keys[i].String() < keys[j].String()
+		})
+		for i, k := range keys {
+			if i > 0 {
+				buf.WriteString(" ")
+			}
+			buf.WriteString(formatValue(k.Value()))
+			buf.WriteString(":")
+			buf.WriteString(formatValue(v.Get(k)))
+		}
+		buf.WriteString("]")
+		return buf.String()
+	case pref.Message:
+		b, err := prototext.Marshal(v.Interface())
+		if err != nil {
+			return fmt.Sprintf("<%v>", err)
+		}
+		return fmt.Sprintf("%v{%v}", v.Descriptor().FullName(), string(b))
+	case string:
+		return fmt.Sprintf("%q", v)
+	default:
+		return fmt.Sprint(v)
+	}
+}
+
+func valueEqual(a, b pref.Value) bool {
+	ai, bi := a.Interface(), b.Interface()
+	switch ai.(type) {
+	case pref.Message:
+		return proto.Equal(
+			a.Message().Interface(),
+			b.Message().Interface(),
+		)
+	case pref.List:
+		lista, listb := a.List(), b.List()
+		if lista.Len() != listb.Len() {
+			return false
+		}
+		for i := 0; i < lista.Len(); i++ {
+			if !valueEqual(lista.Get(i), listb.Get(i)) {
+				return false
+			}
+		}
+		return true
+	case pref.Map:
+		mapa, mapb := a.Map(), b.Map()
+		if mapa.Len() != mapb.Len() {
+			return false
+		}
+		equal := true
+		mapa.Range(func(k pref.MapKey, v pref.Value) bool {
+			if !valueEqual(v, mapb.Get(k)) {
+				equal = false
+				return false
+			}
+			return true
+		})
+		return equal
+	case []byte:
+		return bytes.Equal(a.Bytes(), b.Bytes())
+	case float32:
+		// NaNs are equal, but must be the same NaN.
+		return math.Float32bits(ai.(float32)) == math.Float32bits(bi.(float32))
+	case float64:
+		// NaNs are equal, but must be the same NaN.
+		return math.Float64bits(ai.(float64)) == math.Float64bits(bi.(float64))
+	default:
+		return ai == bi
+	}
+}
+
+// A seed is used to vary the content of a value.
+//
+// A seed of 0 is the zero value. Messages do not have a zero-value; a 0-seeded messages
+// is unpopulated.
+//
+// A seed of minVal or maxVal is the least or greatest value of the value type.
+type seed int
+
+const (
+	minVal seed = -1
+	maxVal seed = -2
+)
+
+// newSeed creates new seed values from a base, for example to create seeds for the
+// elements in a list. If the input seed is minVal or maxVal, so is the output.
+func newSeed(n seed, adjust ...int) seed {
+	switch n {
+	case minVal, maxVal:
+		return n
+	}
+	for _, a := range adjust {
+		n = 10*n + seed(a)
+	}
+	return n
+}
+
+// newValue returns a new value assignable to a field.
+//
+// The stack parameter is used to avoid infinite recursion when populating circular
+// data structures.
+func newValue(m pref.Message, fd pref.FieldDescriptor, n seed, stack []pref.MessageDescriptor) pref.Value {
+	switch {
+	case fd.IsList():
+		if n == 0 {
+			return m.New().Mutable(fd)
+		}
+		list := m.NewField(fd).List()
+		list.Append(newListElement(fd, list, 0, stack))
+		list.Append(newListElement(fd, list, minVal, stack))
+		list.Append(newListElement(fd, list, maxVal, stack))
+		list.Append(newListElement(fd, list, n, stack))
+		return pref.ValueOfList(list)
+	case fd.IsMap():
+		if n == 0 {
+			return m.New().Mutable(fd)
+		}
+		mapv := m.NewField(fd).Map()
+		mapv.Set(newMapKey(fd, 0), newMapValue(fd, mapv, 0, stack))
+		mapv.Set(newMapKey(fd, minVal), newMapValue(fd, mapv, minVal, stack))
+		mapv.Set(newMapKey(fd, maxVal), newMapValue(fd, mapv, maxVal, stack))
+		mapv.Set(newMapKey(fd, n), newMapValue(fd, mapv, newSeed(n, 0), stack))
+		return pref.ValueOfMap(mapv)
+	case fd.Message() != nil:
+		return populateMessage(m.NewField(fd).Message(), n, stack)
+	default:
+		return newScalarValue(fd, n)
+	}
+}
+
+func newListElement(fd pref.FieldDescriptor, list pref.List, n seed, stack []pref.MessageDescriptor) pref.Value {
+	if fd.Message() == nil {
+		return newScalarValue(fd, n)
+	}
+	return populateMessage(list.NewElement().Message(), n, stack)
+}
+
+func newMapKey(fd pref.FieldDescriptor, n seed) pref.MapKey {
+	kd := fd.MapKey()
+	return newScalarValue(kd, n).MapKey()
+}
+
+func newMapValue(fd pref.FieldDescriptor, mapv pref.Map, n seed, stack []pref.MessageDescriptor) pref.Value {
+	vd := fd.MapValue()
+	if vd.Message() == nil {
+		return newScalarValue(vd, n)
+	}
+	return populateMessage(mapv.NewValue().Message(), n, stack)
+}
+
+func newScalarValue(fd pref.FieldDescriptor, n seed) pref.Value {
+	switch fd.Kind() {
+	case pref.BoolKind:
+		return pref.ValueOfBool(n != 0)
+	case pref.EnumKind:
+		vals := fd.Enum().Values()
+		var i int
+		switch n {
+		case minVal:
+			i = 0
+		case maxVal:
+			i = vals.Len() - 1
+		default:
+			i = int(n) % vals.Len()
+		}
+		return pref.ValueOfEnum(vals.Get(i).Number())
+	case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
+		switch n {
+		case minVal:
+			return pref.ValueOfInt32(math.MinInt32)
+		case maxVal:
+			return pref.ValueOfInt32(math.MaxInt32)
+		default:
+			return pref.ValueOfInt32(int32(n))
+		}
+	case pref.Uint32Kind, pref.Fixed32Kind:
+		switch n {
+		case minVal:
+			// Only use 0 for the zero value.
+			return pref.ValueOfUint32(1)
+		case maxVal:
+			return pref.ValueOfUint32(math.MaxInt32)
+		default:
+			return pref.ValueOfUint32(uint32(n))
+		}
+	case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
+		switch n {
+		case minVal:
+			return pref.ValueOfInt64(math.MinInt64)
+		case maxVal:
+			return pref.ValueOfInt64(math.MaxInt64)
+		default:
+			return pref.ValueOfInt64(int64(n))
+		}
+	case pref.Uint64Kind, pref.Fixed64Kind:
+		switch n {
+		case minVal:
+			// Only use 0 for the zero value.
+			return pref.ValueOfUint64(1)
+		case maxVal:
+			return pref.ValueOfUint64(math.MaxInt64)
+		default:
+			return pref.ValueOfUint64(uint64(n))
+		}
+	case pref.FloatKind:
+		switch n {
+		case minVal:
+			return pref.ValueOfFloat32(math.SmallestNonzeroFloat32)
+		case maxVal:
+			return pref.ValueOfFloat32(math.MaxFloat32)
+		default:
+			return pref.ValueOfFloat32(1.5 * float32(n))
+		}
+	case pref.DoubleKind:
+		switch n {
+		case minVal:
+			return pref.ValueOfFloat64(math.SmallestNonzeroFloat64)
+		case maxVal:
+			return pref.ValueOfFloat64(math.MaxFloat64)
+		default:
+			return pref.ValueOfFloat64(1.5 * float64(n))
+		}
+	case pref.StringKind:
+		if n == 0 {
+			return pref.ValueOfString("")
+		}
+		return pref.ValueOfString(fmt.Sprintf("%d", n))
+	case pref.BytesKind:
+		if n == 0 {
+			return pref.ValueOfBytes(nil)
+		}
+		return pref.ValueOfBytes([]byte{byte(n >> 24), byte(n >> 16), byte(n >> 8), byte(n)})
+	}
+	panic("unhandled kind")
+}
+
+func populateMessage(m pref.Message, n seed, stack []pref.MessageDescriptor) pref.Value {
+	if n == 0 {
+		return pref.ValueOfMessage(m)
+	}
+	md := m.Descriptor()
+	for _, x := range stack {
+		if md == x {
+			return pref.ValueOfMessage(m)
+		}
+	}
+	stack = append(stack, md)
+	for i := 0; i < md.Fields().Len(); i++ {
+		fd := md.Fields().Get(i)
+		if fd.IsWeak() {
+			continue
+		}
+		m.Set(fd, newValue(m, fd, newSeed(n, i), stack))
+	}
+	return pref.ValueOfMessage(m)
+}
+
+func panics(f func()) (didPanic bool) {
+	defer func() {
+		if err := recover(); err != nil {
+			didPanic = true
+		}
+	}()
+	f()
+	return false
+}
diff --git a/vendor/google.golang.org/protobuf/testing/prototest/prototest_test.go b/vendor/google.golang.org/protobuf/testing/prototest/prototest_test.go
new file mode 100644
index 000000000..4307d447c
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/testing/prototest/prototest_test.go
@@ -0,0 +1,44 @@
+// Copyright 2019 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 prototest_test
+
+import (
+	"fmt"
+	"testing"
+
+	"google.golang.org/protobuf/internal/flags"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/runtime/protoimpl"
+	"google.golang.org/protobuf/testing/prototest"
+
+	irregularpb "google.golang.org/protobuf/internal/testprotos/irregular"
+	legacypb "google.golang.org/protobuf/internal/testprotos/legacy"
+	legacy1pb "google.golang.org/protobuf/internal/testprotos/legacy/proto2_20160225_2fc053c5"
+	testpb "google.golang.org/protobuf/internal/testprotos/test"
+	_ "google.golang.org/protobuf/internal/testprotos/test/weak1"
+	_ "google.golang.org/protobuf/internal/testprotos/test/weak2"
+	test3pb "google.golang.org/protobuf/internal/testprotos/test3"
+)
+
+func Test(t *testing.T) {
+	ms := []proto.Message{
+		(*testpb.TestAllTypes)(nil),
+		(*test3pb.TestAllTypes)(nil),
+		(*testpb.TestRequired)(nil),
+		(*irregularpb.Message)(nil),
+		(*testpb.TestAllExtensions)(nil),
+		(*legacypb.Legacy)(nil),
+		protoimpl.X.MessageOf((*legacy1pb.Message)(nil)).Interface(),
+	}
+	if flags.ProtoLegacy {
+		ms = append(ms, (*testpb.TestWeak)(nil))
+	}
+
+	for _, m := range ms {
+		t.Run(fmt.Sprintf("%T", m), func(t *testing.T) {
+			prototest.Message{}.Test(t, m.ProtoReflect().Type())
+		})
+	}
+}
diff --git a/vendor/google.golang.org/protobuf/types/descriptorpb/descriptor.pb.go b/vendor/google.golang.org/protobuf/types/descriptorpb/descriptor.pb.go
new file mode 100644
index 000000000..824237856
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/types/descriptorpb/descriptor.pb.go
@@ -0,0 +1,4040 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// The messages in this file describe the definitions found in .proto files.
+// A valid .proto file can be translated directly to a FileDescriptorProto
+// without any other information (e.g. without reading its imports).
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google/protobuf/descriptor.proto
+
+package descriptorpb
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoiface "google.golang.org/protobuf/runtime/protoiface"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+type FieldDescriptorProto_Type int32
+
+const (
+	// 0 is reserved for errors.
+	// Order is weird for historical reasons.
+	FieldDescriptorProto_TYPE_DOUBLE FieldDescriptorProto_Type = 1
+	FieldDescriptorProto_TYPE_FLOAT  FieldDescriptorProto_Type = 2
+	// Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT64 if
+	// negative values are likely.
+	FieldDescriptorProto_TYPE_INT64  FieldDescriptorProto_Type = 3
+	FieldDescriptorProto_TYPE_UINT64 FieldDescriptorProto_Type = 4
+	// Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT32 if
+	// negative values are likely.
+	FieldDescriptorProto_TYPE_INT32   FieldDescriptorProto_Type = 5
+	FieldDescriptorProto_TYPE_FIXED64 FieldDescriptorProto_Type = 6
+	FieldDescriptorProto_TYPE_FIXED32 FieldDescriptorProto_Type = 7
+	FieldDescriptorProto_TYPE_BOOL    FieldDescriptorProto_Type = 8
+	FieldDescriptorProto_TYPE_STRING  FieldDescriptorProto_Type = 9
+	// Tag-delimited aggregate.
+	// Group type is deprecated and not supported in proto3. However, Proto3
+	// implementations should still be able to parse the group wire format and
+	// treat group fields as unknown fields.
+	FieldDescriptorProto_TYPE_GROUP   FieldDescriptorProto_Type = 10
+	FieldDescriptorProto_TYPE_MESSAGE FieldDescriptorProto_Type = 11 // Length-delimited aggregate.
+	// New in version 2.
+	FieldDescriptorProto_TYPE_BYTES    FieldDescriptorProto_Type = 12
+	FieldDescriptorProto_TYPE_UINT32   FieldDescriptorProto_Type = 13
+	FieldDescriptorProto_TYPE_ENUM     FieldDescriptorProto_Type = 14
+	FieldDescriptorProto_TYPE_SFIXED32 FieldDescriptorProto_Type = 15
+	FieldDescriptorProto_TYPE_SFIXED64 FieldDescriptorProto_Type = 16
+	FieldDescriptorProto_TYPE_SINT32   FieldDescriptorProto_Type = 17 // Uses ZigZag encoding.
+	FieldDescriptorProto_TYPE_SINT64   FieldDescriptorProto_Type = 18 // Uses ZigZag encoding.
+)
+
+// Enum value maps for FieldDescriptorProto_Type.
+var (
+	FieldDescriptorProto_Type_name = map[int32]string{
+		1:  "TYPE_DOUBLE",
+		2:  "TYPE_FLOAT",
+		3:  "TYPE_INT64",
+		4:  "TYPE_UINT64",
+		5:  "TYPE_INT32",
+		6:  "TYPE_FIXED64",
+		7:  "TYPE_FIXED32",
+		8:  "TYPE_BOOL",
+		9:  "TYPE_STRING",
+		10: "TYPE_GROUP",
+		11: "TYPE_MESSAGE",
+		12: "TYPE_BYTES",
+		13: "TYPE_UINT32",
+		14: "TYPE_ENUM",
+		15: "TYPE_SFIXED32",
+		16: "TYPE_SFIXED64",
+		17: "TYPE_SINT32",
+		18: "TYPE_SINT64",
+	}
+	FieldDescriptorProto_Type_value = map[string]int32{
+		"TYPE_DOUBLE":   1,
+		"TYPE_FLOAT":    2,
+		"TYPE_INT64":    3,
+		"TYPE_UINT64":   4,
+		"TYPE_INT32":    5,
+		"TYPE_FIXED64":  6,
+		"TYPE_FIXED32":  7,
+		"TYPE_BOOL":     8,
+		"TYPE_STRING":   9,
+		"TYPE_GROUP":    10,
+		"TYPE_MESSAGE":  11,
+		"TYPE_BYTES":    12,
+		"TYPE_UINT32":   13,
+		"TYPE_ENUM":     14,
+		"TYPE_SFIXED32": 15,
+		"TYPE_SFIXED64": 16,
+		"TYPE_SINT32":   17,
+		"TYPE_SINT64":   18,
+	}
+)
+
+func (x FieldDescriptorProto_Type) Enum() *FieldDescriptorProto_Type {
+	p := new(FieldDescriptorProto_Type)
+	*p = x
+	return p
+}
+
+func (x FieldDescriptorProto_Type) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (FieldDescriptorProto_Type) Descriptor() protoreflect.EnumDescriptor {
+	return file_google_protobuf_descriptor_proto_enumTypes[0].Descriptor()
+}
+
+func (FieldDescriptorProto_Type) Type() protoreflect.EnumType {
+	return &file_google_protobuf_descriptor_proto_enumTypes[0]
+}
+
+func (x FieldDescriptorProto_Type) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *FieldDescriptorProto_Type) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = FieldDescriptorProto_Type(num)
+	return nil
+}
+
+// Deprecated: Use FieldDescriptorProto_Type.Descriptor instead.
+func (FieldDescriptorProto_Type) EnumDescriptor() ([]byte, []int) {
+	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{4, 0}
+}
+
+type FieldDescriptorProto_Label int32
+
+const (
+	// 0 is reserved for errors
+	FieldDescriptorProto_LABEL_OPTIONAL FieldDescriptorProto_Label = 1
+	FieldDescriptorProto_LABEL_REQUIRED FieldDescriptorProto_Label = 2
+	FieldDescriptorProto_LABEL_REPEATED FieldDescriptorProto_Label = 3
+)
+
+// Enum value maps for FieldDescriptorProto_Label.
+var (
+	FieldDescriptorProto_Label_name = map[int32]string{
+		1: "LABEL_OPTIONAL",
+		2: "LABEL_REQUIRED",
+		3: "LABEL_REPEATED",
+	}
+	FieldDescriptorProto_Label_value = map[string]int32{
+		"LABEL_OPTIONAL": 1,
+		"LABEL_REQUIRED": 2,
+		"LABEL_REPEATED": 3,
+	}
+)
+
+func (x FieldDescriptorProto_Label) Enum() *FieldDescriptorProto_Label {
+	p := new(FieldDescriptorProto_Label)
+	*p = x
+	return p
+}
+
+func (x FieldDescriptorProto_Label) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (FieldDescriptorProto_Label) Descriptor() protoreflect.EnumDescriptor {
+	return file_google_protobuf_descriptor_proto_enumTypes[1].Descriptor()
+}
+
+func (FieldDescriptorProto_Label) Type() protoreflect.EnumType {
+	return &file_google_protobuf_descriptor_proto_enumTypes[1]
+}
+
+func (x FieldDescriptorProto_Label) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *FieldDescriptorProto_Label) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = FieldDescriptorProto_Label(num)
+	return nil
+}
+
+// Deprecated: Use FieldDescriptorProto_Label.Descriptor instead.
+func (FieldDescriptorProto_Label) EnumDescriptor() ([]byte, []int) {
+	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{4, 1}
+}
+
+// Generated classes can be optimized for speed or code size.
+type FileOptions_OptimizeMode int32
+
+const (
+	FileOptions_SPEED FileOptions_OptimizeMode = 1 // Generate complete code for parsing, serialization,
+	// etc.
+	FileOptions_CODE_SIZE    FileOptions_OptimizeMode = 2 // Use ReflectionOps to implement these methods.
+	FileOptions_LITE_RUNTIME FileOptions_OptimizeMode = 3 // Generate code using MessageLite and the lite runtime.
+)
+
+// Enum value maps for FileOptions_OptimizeMode.
+var (
+	FileOptions_OptimizeMode_name = map[int32]string{
+		1: "SPEED",
+		2: "CODE_SIZE",
+		3: "LITE_RUNTIME",
+	}
+	FileOptions_OptimizeMode_value = map[string]int32{
+		"SPEED":        1,
+		"CODE_SIZE":    2,
+		"LITE_RUNTIME": 3,
+	}
+)
+
+func (x FileOptions_OptimizeMode) Enum() *FileOptions_OptimizeMode {
+	p := new(FileOptions_OptimizeMode)
+	*p = x
+	return p
+}
+
+func (x FileOptions_OptimizeMode) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (FileOptions_OptimizeMode) Descriptor() protoreflect.EnumDescriptor {
+	return file_google_protobuf_descriptor_proto_enumTypes[2].Descriptor()
+}
+
+func (FileOptions_OptimizeMode) Type() protoreflect.EnumType {
+	return &file_google_protobuf_descriptor_proto_enumTypes[2]
+}
+
+func (x FileOptions_OptimizeMode) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *FileOptions_OptimizeMode) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = FileOptions_OptimizeMode(num)
+	return nil
+}
+
+// Deprecated: Use FileOptions_OptimizeMode.Descriptor instead.
+func (FileOptions_OptimizeMode) EnumDescriptor() ([]byte, []int) {
+	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{10, 0}
+}
+
+type FieldOptions_CType int32
+
+const (
+	// Default mode.
+	FieldOptions_STRING       FieldOptions_CType = 0
+	FieldOptions_CORD         FieldOptions_CType = 1
+	FieldOptions_STRING_PIECE FieldOptions_CType = 2
+)
+
+// Enum value maps for FieldOptions_CType.
+var (
+	FieldOptions_CType_name = map[int32]string{
+		0: "STRING",
+		1: "CORD",
+		2: "STRING_PIECE",
+	}
+	FieldOptions_CType_value = map[string]int32{
+		"STRING":       0,
+		"CORD":         1,
+		"STRING_PIECE": 2,
+	}
+)
+
+func (x FieldOptions_CType) Enum() *FieldOptions_CType {
+	p := new(FieldOptions_CType)
+	*p = x
+	return p
+}
+
+func (x FieldOptions_CType) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (FieldOptions_CType) Descriptor() protoreflect.EnumDescriptor {
+	return file_google_protobuf_descriptor_proto_enumTypes[3].Descriptor()
+}
+
+func (FieldOptions_CType) Type() protoreflect.EnumType {
+	return &file_google_protobuf_descriptor_proto_enumTypes[3]
+}
+
+func (x FieldOptions_CType) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *FieldOptions_CType) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = FieldOptions_CType(num)
+	return nil
+}
+
+// Deprecated: Use FieldOptions_CType.Descriptor instead.
+func (FieldOptions_CType) EnumDescriptor() ([]byte, []int) {
+	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{12, 0}
+}
+
+type FieldOptions_JSType int32
+
+const (
+	// Use the default type.
+	FieldOptions_JS_NORMAL FieldOptions_JSType = 0
+	// Use JavaScript strings.
+	FieldOptions_JS_STRING FieldOptions_JSType = 1
+	// Use JavaScript numbers.
+	FieldOptions_JS_NUMBER FieldOptions_JSType = 2
+)
+
+// Enum value maps for FieldOptions_JSType.
+var (
+	FieldOptions_JSType_name = map[int32]string{
+		0: "JS_NORMAL",
+		1: "JS_STRING",
+		2: "JS_NUMBER",
+	}
+	FieldOptions_JSType_value = map[string]int32{
+		"JS_NORMAL": 0,
+		"JS_STRING": 1,
+		"JS_NUMBER": 2,
+	}
+)
+
+func (x FieldOptions_JSType) Enum() *FieldOptions_JSType {
+	p := new(FieldOptions_JSType)
+	*p = x
+	return p
+}
+
+func (x FieldOptions_JSType) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (FieldOptions_JSType) Descriptor() protoreflect.EnumDescriptor {
+	return file_google_protobuf_descriptor_proto_enumTypes[4].Descriptor()
+}
+
+func (FieldOptions_JSType) Type() protoreflect.EnumType {
+	return &file_google_protobuf_descriptor_proto_enumTypes[4]
+}
+
+func (x FieldOptions_JSType) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *FieldOptions_JSType) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = FieldOptions_JSType(num)
+	return nil
+}
+
+// Deprecated: Use FieldOptions_JSType.Descriptor instead.
+func (FieldOptions_JSType) EnumDescriptor() ([]byte, []int) {
+	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{12, 1}
+}
+
+// Is this method side-effect-free (or safe in HTTP parlance), or idempotent,
+// or neither? HTTP based RPC implementation may choose GET verb for safe
+// methods, and PUT verb for idempotent methods instead of the default POST.
+type MethodOptions_IdempotencyLevel int32
+
+const (
+	MethodOptions_IDEMPOTENCY_UNKNOWN MethodOptions_IdempotencyLevel = 0
+	MethodOptions_NO_SIDE_EFFECTS     MethodOptions_IdempotencyLevel = 1 // implies idempotent
+	MethodOptions_IDEMPOTENT          MethodOptions_IdempotencyLevel = 2 // idempotent, but may have side effects
+)
+
+// Enum value maps for MethodOptions_IdempotencyLevel.
+var (
+	MethodOptions_IdempotencyLevel_name = map[int32]string{
+		0: "IDEMPOTENCY_UNKNOWN",
+		1: "NO_SIDE_EFFECTS",
+		2: "IDEMPOTENT",
+	}
+	MethodOptions_IdempotencyLevel_value = map[string]int32{
+		"IDEMPOTENCY_UNKNOWN": 0,
+		"NO_SIDE_EFFECTS":     1,
+		"IDEMPOTENT":          2,
+	}
+)
+
+func (x MethodOptions_IdempotencyLevel) Enum() *MethodOptions_IdempotencyLevel {
+	p := new(MethodOptions_IdempotencyLevel)
+	*p = x
+	return p
+}
+
+func (x MethodOptions_IdempotencyLevel) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (MethodOptions_IdempotencyLevel) Descriptor() protoreflect.EnumDescriptor {
+	return file_google_protobuf_descriptor_proto_enumTypes[5].Descriptor()
+}
+
+func (MethodOptions_IdempotencyLevel) Type() protoreflect.EnumType {
+	return &file_google_protobuf_descriptor_proto_enumTypes[5]
+}
+
+func (x MethodOptions_IdempotencyLevel) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *MethodOptions_IdempotencyLevel) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = MethodOptions_IdempotencyLevel(num)
+	return nil
+}
+
+// Deprecated: Use MethodOptions_IdempotencyLevel.Descriptor instead.
+func (MethodOptions_IdempotencyLevel) EnumDescriptor() ([]byte, []int) {
+	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{17, 0}
+}
+
+// The protocol compiler can output a FileDescriptorSet containing the .proto
+// files it parses.
+type FileDescriptorSet struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	File []*FileDescriptorProto `protobuf:"bytes,1,rep,name=file" json:"file,omitempty"`
+}
+
+func (x *FileDescriptorSet) Reset() {
+	*x = FileDescriptorSet{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_descriptor_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *FileDescriptorSet) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*FileDescriptorSet) ProtoMessage() {}
+
+func (x *FileDescriptorSet) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_descriptor_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use FileDescriptorSet.ProtoReflect.Descriptor instead.
+func (*FileDescriptorSet) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *FileDescriptorSet) GetFile() []*FileDescriptorProto {
+	if x != nil {
+		return x.File
+	}
+	return nil
+}
+
+// Describes a complete .proto file.
+type FileDescriptorProto struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Name    *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`       // file name, relative to root of source tree
+	Package *string `protobuf:"bytes,2,opt,name=package" json:"package,omitempty"` // e.g. "foo", "foo.bar", etc.
+	// Names of files imported by this file.
+	Dependency []string `protobuf:"bytes,3,rep,name=dependency" json:"dependency,omitempty"`
+	// Indexes of the public imported files in the dependency list above.
+	PublicDependency []int32 `protobuf:"varint,10,rep,name=public_dependency,json=publicDependency" json:"public_dependency,omitempty"`
+	// Indexes of the weak imported files in the dependency list.
+	// For Google-internal migration only. Do not use.
+	WeakDependency []int32 `protobuf:"varint,11,rep,name=weak_dependency,json=weakDependency" json:"weak_dependency,omitempty"`
+	// All top-level definitions in this file.
+	MessageType []*DescriptorProto        `protobuf:"bytes,4,rep,name=message_type,json=messageType" json:"message_type,omitempty"`
+	EnumType    []*EnumDescriptorProto    `protobuf:"bytes,5,rep,name=enum_type,json=enumType" json:"enum_type,omitempty"`
+	Service     []*ServiceDescriptorProto `protobuf:"bytes,6,rep,name=service" json:"service,omitempty"`
+	Extension   []*FieldDescriptorProto   `protobuf:"bytes,7,rep,name=extension" json:"extension,omitempty"`
+	Options     *FileOptions              `protobuf:"bytes,8,opt,name=options" json:"options,omitempty"`
+	// This field contains optional information about the original source code.
+	// You may safely remove this entire field without harming runtime
+	// functionality of the descriptors -- the information is needed only by
+	// development tools.
+	SourceCodeInfo *SourceCodeInfo `protobuf:"bytes,9,opt,name=source_code_info,json=sourceCodeInfo" json:"source_code_info,omitempty"`
+	// The syntax of the proto file.
+	// The supported values are "proto2" and "proto3".
+	Syntax *string `protobuf:"bytes,12,opt,name=syntax" json:"syntax,omitempty"`
+}
+
+func (x *FileDescriptorProto) Reset() {
+	*x = FileDescriptorProto{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_descriptor_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *FileDescriptorProto) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*FileDescriptorProto) ProtoMessage() {}
+
+func (x *FileDescriptorProto) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_descriptor_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use FileDescriptorProto.ProtoReflect.Descriptor instead.
+func (*FileDescriptorProto) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *FileDescriptorProto) GetName() string {
+	if x != nil && x.Name != nil {
+		return *x.Name
+	}
+	return ""
+}
+
+func (x *FileDescriptorProto) GetPackage() string {
+	if x != nil && x.Package != nil {
+		return *x.Package
+	}
+	return ""
+}
+
+func (x *FileDescriptorProto) GetDependency() []string {
+	if x != nil {
+		return x.Dependency
+	}
+	return nil
+}
+
+func (x *FileDescriptorProto) GetPublicDependency() []int32 {
+	if x != nil {
+		return x.PublicDependency
+	}
+	return nil
+}
+
+func (x *FileDescriptorProto) GetWeakDependency() []int32 {
+	if x != nil {
+		return x.WeakDependency
+	}
+	return nil
+}
+
+func (x *FileDescriptorProto) GetMessageType() []*DescriptorProto {
+	if x != nil {
+		return x.MessageType
+	}
+	return nil
+}
+
+func (x *FileDescriptorProto) GetEnumType() []*EnumDescriptorProto {
+	if x != nil {
+		return x.EnumType
+	}
+	return nil
+}
+
+func (x *FileDescriptorProto) GetService() []*ServiceDescriptorProto {
+	if x != nil {
+		return x.Service
+	}
+	return nil
+}
+
+func (x *FileDescriptorProto) GetExtension() []*FieldDescriptorProto {
+	if x != nil {
+		return x.Extension
+	}
+	return nil
+}
+
+func (x *FileDescriptorProto) GetOptions() *FileOptions {
+	if x != nil {
+		return x.Options
+	}
+	return nil
+}
+
+func (x *FileDescriptorProto) GetSourceCodeInfo() *SourceCodeInfo {
+	if x != nil {
+		return x.SourceCodeInfo
+	}
+	return nil
+}
+
+func (x *FileDescriptorProto) GetSyntax() string {
+	if x != nil && x.Syntax != nil {
+		return *x.Syntax
+	}
+	return ""
+}
+
+// Describes a message type.
+type DescriptorProto struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Name           *string                           `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+	Field          []*FieldDescriptorProto           `protobuf:"bytes,2,rep,name=field" json:"field,omitempty"`
+	Extension      []*FieldDescriptorProto           `protobuf:"bytes,6,rep,name=extension" json:"extension,omitempty"`
+	NestedType     []*DescriptorProto                `protobuf:"bytes,3,rep,name=nested_type,json=nestedType" json:"nested_type,omitempty"`
+	EnumType       []*EnumDescriptorProto            `protobuf:"bytes,4,rep,name=enum_type,json=enumType" json:"enum_type,omitempty"`
+	ExtensionRange []*DescriptorProto_ExtensionRange `protobuf:"bytes,5,rep,name=extension_range,json=extensionRange" json:"extension_range,omitempty"`
+	OneofDecl      []*OneofDescriptorProto           `protobuf:"bytes,8,rep,name=oneof_decl,json=oneofDecl" json:"oneof_decl,omitempty"`
+	Options        *MessageOptions                   `protobuf:"bytes,7,opt,name=options" json:"options,omitempty"`
+	ReservedRange  []*DescriptorProto_ReservedRange  `protobuf:"bytes,9,rep,name=reserved_range,json=reservedRange" json:"reserved_range,omitempty"`
+	// Reserved field names, which may not be used by fields in the same message.
+	// A given name may only be reserved once.
+	ReservedName []string `protobuf:"bytes,10,rep,name=reserved_name,json=reservedName" json:"reserved_name,omitempty"`
+}
+
+func (x *DescriptorProto) Reset() {
+	*x = DescriptorProto{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_descriptor_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *DescriptorProto) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DescriptorProto) ProtoMessage() {}
+
+func (x *DescriptorProto) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_descriptor_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use DescriptorProto.ProtoReflect.Descriptor instead.
+func (*DescriptorProto) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *DescriptorProto) GetName() string {
+	if x != nil && x.Name != nil {
+		return *x.Name
+	}
+	return ""
+}
+
+func (x *DescriptorProto) GetField() []*FieldDescriptorProto {
+	if x != nil {
+		return x.Field
+	}
+	return nil
+}
+
+func (x *DescriptorProto) GetExtension() []*FieldDescriptorProto {
+	if x != nil {
+		return x.Extension
+	}
+	return nil
+}
+
+func (x *DescriptorProto) GetNestedType() []*DescriptorProto {
+	if x != nil {
+		return x.NestedType
+	}
+	return nil
+}
+
+func (x *DescriptorProto) GetEnumType() []*EnumDescriptorProto {
+	if x != nil {
+		return x.EnumType
+	}
+	return nil
+}
+
+func (x *DescriptorProto) GetExtensionRange() []*DescriptorProto_ExtensionRange {
+	if x != nil {
+		return x.ExtensionRange
+	}
+	return nil
+}
+
+func (x *DescriptorProto) GetOneofDecl() []*OneofDescriptorProto {
+	if x != nil {
+		return x.OneofDecl
+	}
+	return nil
+}
+
+func (x *DescriptorProto) GetOptions() *MessageOptions {
+	if x != nil {
+		return x.Options
+	}
+	return nil
+}
+
+func (x *DescriptorProto) GetReservedRange() []*DescriptorProto_ReservedRange {
+	if x != nil {
+		return x.ReservedRange
+	}
+	return nil
+}
+
+func (x *DescriptorProto) GetReservedName() []string {
+	if x != nil {
+		return x.ReservedName
+	}
+	return nil
+}
+
+type ExtensionRangeOptions struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+
+	// The parser stores options it doesn't recognize here. See above.
+	UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+}
+
+func (x *ExtensionRangeOptions) Reset() {
+	*x = ExtensionRangeOptions{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_descriptor_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *ExtensionRangeOptions) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ExtensionRangeOptions) ProtoMessage() {}
+
+func (x *ExtensionRangeOptions) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_descriptor_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ExtensionRangeOptions.ProtoReflect.Descriptor instead.
+func (*ExtensionRangeOptions) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{3}
+}
+
+var extRange_ExtensionRangeOptions = []protoiface.ExtensionRangeV1{
+	{Start: 1000, End: 536870911},
+}
+
+// Deprecated: Use ExtensionRangeOptions.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*ExtensionRangeOptions) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_ExtensionRangeOptions
+}
+
+func (x *ExtensionRangeOptions) GetUninterpretedOption() []*UninterpretedOption {
+	if x != nil {
+		return x.UninterpretedOption
+	}
+	return nil
+}
+
+// Describes a field within a message.
+type FieldDescriptorProto struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Name   *string                     `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+	Number *int32                      `protobuf:"varint,3,opt,name=number" json:"number,omitempty"`
+	Label  *FieldDescriptorProto_Label `protobuf:"varint,4,opt,name=label,enum=google.protobuf.FieldDescriptorProto_Label" json:"label,omitempty"`
+	// If type_name is set, this need not be set.  If both this and type_name
+	// are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.
+	Type *FieldDescriptorProto_Type `protobuf:"varint,5,opt,name=type,enum=google.protobuf.FieldDescriptorProto_Type" json:"type,omitempty"`
+	// For message and enum types, this is the name of the type.  If the name
+	// starts with a '.', it is fully-qualified.  Otherwise, C++-like scoping
+	// rules are used to find the type (i.e. first the nested types within this
+	// message are searched, then within the parent, on up to the root
+	// namespace).
+	TypeName *string `protobuf:"bytes,6,opt,name=type_name,json=typeName" json:"type_name,omitempty"`
+	// For extensions, this is the name of the type being extended.  It is
+	// resolved in the same manner as type_name.
+	Extendee *string `protobuf:"bytes,2,opt,name=extendee" json:"extendee,omitempty"`
+	// For numeric types, contains the original text representation of the value.
+	// For booleans, "true" or "false".
+	// For strings, contains the default text contents (not escaped in any way).
+	// For bytes, contains the C escaped value.  All bytes >= 128 are escaped.
+	// TODO(kenton):  Base-64 encode?
+	DefaultValue *string `protobuf:"bytes,7,opt,name=default_value,json=defaultValue" json:"default_value,omitempty"`
+	// If set, gives the index of a oneof in the containing type's oneof_decl
+	// list.  This field is a member of that oneof.
+	OneofIndex *int32 `protobuf:"varint,9,opt,name=oneof_index,json=oneofIndex" json:"oneof_index,omitempty"`
+	// JSON name of this field. The value is set by protocol compiler. If the
+	// user has set a "json_name" option on this field, that option's value
+	// will be used. Otherwise, it's deduced from the field's name by converting
+	// it to camelCase.
+	JsonName *string       `protobuf:"bytes,10,opt,name=json_name,json=jsonName" json:"json_name,omitempty"`
+	Options  *FieldOptions `protobuf:"bytes,8,opt,name=options" json:"options,omitempty"`
+	// If true, this is a proto3 "optional". When a proto3 field is optional, it
+	// tracks presence regardless of field type.
+	//
+	// When proto3_optional is true, this field must be belong to a oneof to
+	// signal to old proto3 clients that presence is tracked for this field. This
+	// oneof is known as a "synthetic" oneof, and this field must be its sole
+	// member (each proto3 optional field gets its own synthetic oneof). Synthetic
+	// oneofs exist in the descriptor only, and do not generate any API. Synthetic
+	// oneofs must be ordered after all "real" oneofs.
+	//
+	// For message fields, proto3_optional doesn't create any semantic change,
+	// since non-repeated message fields always track presence. However it still
+	// indicates the semantic detail of whether the user wrote "optional" or not.
+	// This can be useful for round-tripping the .proto file. For consistency we
+	// give message fields a synthetic oneof also, even though it is not required
+	// to track presence. This is especially important because the parser can't
+	// tell if a field is a message or an enum, so it must always create a
+	// synthetic oneof.
+	//
+	// Proto2 optional fields do not set this flag, because they already indicate
+	// optional with `LABEL_OPTIONAL`.
+	Proto3Optional *bool `protobuf:"varint,17,opt,name=proto3_optional,json=proto3Optional" json:"proto3_optional,omitempty"`
+}
+
+func (x *FieldDescriptorProto) Reset() {
+	*x = FieldDescriptorProto{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_descriptor_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *FieldDescriptorProto) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*FieldDescriptorProto) ProtoMessage() {}
+
+func (x *FieldDescriptorProto) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_descriptor_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use FieldDescriptorProto.ProtoReflect.Descriptor instead.
+func (*FieldDescriptorProto) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *FieldDescriptorProto) GetName() string {
+	if x != nil && x.Name != nil {
+		return *x.Name
+	}
+	return ""
+}
+
+func (x *FieldDescriptorProto) GetNumber() int32 {
+	if x != nil && x.Number != nil {
+		return *x.Number
+	}
+	return 0
+}
+
+func (x *FieldDescriptorProto) GetLabel() FieldDescriptorProto_Label {
+	if x != nil && x.Label != nil {
+		return *x.Label
+	}
+	return FieldDescriptorProto_LABEL_OPTIONAL
+}
+
+func (x *FieldDescriptorProto) GetType() FieldDescriptorProto_Type {
+	if x != nil && x.Type != nil {
+		return *x.Type
+	}
+	return FieldDescriptorProto_TYPE_DOUBLE
+}
+
+func (x *FieldDescriptorProto) GetTypeName() string {
+	if x != nil && x.TypeName != nil {
+		return *x.TypeName
+	}
+	return ""
+}
+
+func (x *FieldDescriptorProto) GetExtendee() string {
+	if x != nil && x.Extendee != nil {
+		return *x.Extendee
+	}
+	return ""
+}
+
+func (x *FieldDescriptorProto) GetDefaultValue() string {
+	if x != nil && x.DefaultValue != nil {
+		return *x.DefaultValue
+	}
+	return ""
+}
+
+func (x *FieldDescriptorProto) GetOneofIndex() int32 {
+	if x != nil && x.OneofIndex != nil {
+		return *x.OneofIndex
+	}
+	return 0
+}
+
+func (x *FieldDescriptorProto) GetJsonName() string {
+	if x != nil && x.JsonName != nil {
+		return *x.JsonName
+	}
+	return ""
+}
+
+func (x *FieldDescriptorProto) GetOptions() *FieldOptions {
+	if x != nil {
+		return x.Options
+	}
+	return nil
+}
+
+func (x *FieldDescriptorProto) GetProto3Optional() bool {
+	if x != nil && x.Proto3Optional != nil {
+		return *x.Proto3Optional
+	}
+	return false
+}
+
+// Describes a oneof.
+type OneofDescriptorProto struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Name    *string       `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+	Options *OneofOptions `protobuf:"bytes,2,opt,name=options" json:"options,omitempty"`
+}
+
+func (x *OneofDescriptorProto) Reset() {
+	*x = OneofDescriptorProto{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_descriptor_proto_msgTypes[5]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *OneofDescriptorProto) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*OneofDescriptorProto) ProtoMessage() {}
+
+func (x *OneofDescriptorProto) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_descriptor_proto_msgTypes[5]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use OneofDescriptorProto.ProtoReflect.Descriptor instead.
+func (*OneofDescriptorProto) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *OneofDescriptorProto) GetName() string {
+	if x != nil && x.Name != nil {
+		return *x.Name
+	}
+	return ""
+}
+
+func (x *OneofDescriptorProto) GetOptions() *OneofOptions {
+	if x != nil {
+		return x.Options
+	}
+	return nil
+}
+
+// Describes an enum type.
+type EnumDescriptorProto struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Name    *string                     `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+	Value   []*EnumValueDescriptorProto `protobuf:"bytes,2,rep,name=value" json:"value,omitempty"`
+	Options *EnumOptions                `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
+	// Range of reserved numeric values. Reserved numeric values may not be used
+	// by enum values in the same enum declaration. Reserved ranges may not
+	// overlap.
+	ReservedRange []*EnumDescriptorProto_EnumReservedRange `protobuf:"bytes,4,rep,name=reserved_range,json=reservedRange" json:"reserved_range,omitempty"`
+	// Reserved enum value names, which may not be reused. A given name may only
+	// be reserved once.
+	ReservedName []string `protobuf:"bytes,5,rep,name=reserved_name,json=reservedName" json:"reserved_name,omitempty"`
+}
+
+func (x *EnumDescriptorProto) Reset() {
+	*x = EnumDescriptorProto{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_descriptor_proto_msgTypes[6]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *EnumDescriptorProto) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*EnumDescriptorProto) ProtoMessage() {}
+
+func (x *EnumDescriptorProto) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_descriptor_proto_msgTypes[6]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use EnumDescriptorProto.ProtoReflect.Descriptor instead.
+func (*EnumDescriptorProto) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *EnumDescriptorProto) GetName() string {
+	if x != nil && x.Name != nil {
+		return *x.Name
+	}
+	return ""
+}
+
+func (x *EnumDescriptorProto) GetValue() []*EnumValueDescriptorProto {
+	if x != nil {
+		return x.Value
+	}
+	return nil
+}
+
+func (x *EnumDescriptorProto) GetOptions() *EnumOptions {
+	if x != nil {
+		return x.Options
+	}
+	return nil
+}
+
+func (x *EnumDescriptorProto) GetReservedRange() []*EnumDescriptorProto_EnumReservedRange {
+	if x != nil {
+		return x.ReservedRange
+	}
+	return nil
+}
+
+func (x *EnumDescriptorProto) GetReservedName() []string {
+	if x != nil {
+		return x.ReservedName
+	}
+	return nil
+}
+
+// Describes a value within an enum.
+type EnumValueDescriptorProto struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Name    *string           `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+	Number  *int32            `protobuf:"varint,2,opt,name=number" json:"number,omitempty"`
+	Options *EnumValueOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
+}
+
+func (x *EnumValueDescriptorProto) Reset() {
+	*x = EnumValueDescriptorProto{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_descriptor_proto_msgTypes[7]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *EnumValueDescriptorProto) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*EnumValueDescriptorProto) ProtoMessage() {}
+
+func (x *EnumValueDescriptorProto) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_descriptor_proto_msgTypes[7]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use EnumValueDescriptorProto.ProtoReflect.Descriptor instead.
+func (*EnumValueDescriptorProto) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *EnumValueDescriptorProto) GetName() string {
+	if x != nil && x.Name != nil {
+		return *x.Name
+	}
+	return ""
+}
+
+func (x *EnumValueDescriptorProto) GetNumber() int32 {
+	if x != nil && x.Number != nil {
+		return *x.Number
+	}
+	return 0
+}
+
+func (x *EnumValueDescriptorProto) GetOptions() *EnumValueOptions {
+	if x != nil {
+		return x.Options
+	}
+	return nil
+}
+
+// Describes a service.
+type ServiceDescriptorProto struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Name    *string                  `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+	Method  []*MethodDescriptorProto `protobuf:"bytes,2,rep,name=method" json:"method,omitempty"`
+	Options *ServiceOptions          `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
+}
+
+func (x *ServiceDescriptorProto) Reset() {
+	*x = ServiceDescriptorProto{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_descriptor_proto_msgTypes[8]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *ServiceDescriptorProto) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ServiceDescriptorProto) ProtoMessage() {}
+
+func (x *ServiceDescriptorProto) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_descriptor_proto_msgTypes[8]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ServiceDescriptorProto.ProtoReflect.Descriptor instead.
+func (*ServiceDescriptorProto) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *ServiceDescriptorProto) GetName() string {
+	if x != nil && x.Name != nil {
+		return *x.Name
+	}
+	return ""
+}
+
+func (x *ServiceDescriptorProto) GetMethod() []*MethodDescriptorProto {
+	if x != nil {
+		return x.Method
+	}
+	return nil
+}
+
+func (x *ServiceDescriptorProto) GetOptions() *ServiceOptions {
+	if x != nil {
+		return x.Options
+	}
+	return nil
+}
+
+// Describes a method of a service.
+type MethodDescriptorProto struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+	// Input and output type names.  These are resolved in the same way as
+	// FieldDescriptorProto.type_name, but must refer to a message type.
+	InputType  *string        `protobuf:"bytes,2,opt,name=input_type,json=inputType" json:"input_type,omitempty"`
+	OutputType *string        `protobuf:"bytes,3,opt,name=output_type,json=outputType" json:"output_type,omitempty"`
+	Options    *MethodOptions `protobuf:"bytes,4,opt,name=options" json:"options,omitempty"`
+	// Identifies if client streams multiple client messages
+	ClientStreaming *bool `protobuf:"varint,5,opt,name=client_streaming,json=clientStreaming,def=0" json:"client_streaming,omitempty"`
+	// Identifies if server streams multiple server messages
+	ServerStreaming *bool `protobuf:"varint,6,opt,name=server_streaming,json=serverStreaming,def=0" json:"server_streaming,omitempty"`
+}
+
+// Default values for MethodDescriptorProto fields.
+const (
+	Default_MethodDescriptorProto_ClientStreaming = bool(false)
+	Default_MethodDescriptorProto_ServerStreaming = bool(false)
+)
+
+func (x *MethodDescriptorProto) Reset() {
+	*x = MethodDescriptorProto{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_descriptor_proto_msgTypes[9]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MethodDescriptorProto) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MethodDescriptorProto) ProtoMessage() {}
+
+func (x *MethodDescriptorProto) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_descriptor_proto_msgTypes[9]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use MethodDescriptorProto.ProtoReflect.Descriptor instead.
+func (*MethodDescriptorProto) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{9}
+}
+
+func (x *MethodDescriptorProto) GetName() string {
+	if x != nil && x.Name != nil {
+		return *x.Name
+	}
+	return ""
+}
+
+func (x *MethodDescriptorProto) GetInputType() string {
+	if x != nil && x.InputType != nil {
+		return *x.InputType
+	}
+	return ""
+}
+
+func (x *MethodDescriptorProto) GetOutputType() string {
+	if x != nil && x.OutputType != nil {
+		return *x.OutputType
+	}
+	return ""
+}
+
+func (x *MethodDescriptorProto) GetOptions() *MethodOptions {
+	if x != nil {
+		return x.Options
+	}
+	return nil
+}
+
+func (x *MethodDescriptorProto) GetClientStreaming() bool {
+	if x != nil && x.ClientStreaming != nil {
+		return *x.ClientStreaming
+	}
+	return Default_MethodDescriptorProto_ClientStreaming
+}
+
+func (x *MethodDescriptorProto) GetServerStreaming() bool {
+	if x != nil && x.ServerStreaming != nil {
+		return *x.ServerStreaming
+	}
+	return Default_MethodDescriptorProto_ServerStreaming
+}
+
+type FileOptions struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+
+	// Sets the Java package where classes generated from this .proto will be
+	// placed.  By default, the proto package is used, but this is often
+	// inappropriate because proto packages do not normally start with backwards
+	// domain names.
+	JavaPackage *string `protobuf:"bytes,1,opt,name=java_package,json=javaPackage" json:"java_package,omitempty"`
+	// If set, all the classes from the .proto file are wrapped in a single
+	// outer class with the given name.  This applies to both Proto1
+	// (equivalent to the old "--one_java_file" option) and Proto2 (where
+	// a .proto always translates to a single class, but you may want to
+	// explicitly choose the class name).
+	JavaOuterClassname *string `protobuf:"bytes,8,opt,name=java_outer_classname,json=javaOuterClassname" json:"java_outer_classname,omitempty"`
+	// If set true, then the Java code generator will generate a separate .java
+	// file for each top-level message, enum, and service defined in the .proto
+	// file.  Thus, these types will *not* be nested inside the outer class
+	// named by java_outer_classname.  However, the outer class will still be
+	// generated to contain the file's getDescriptor() method as well as any
+	// top-level extensions defined in the file.
+	JavaMultipleFiles *bool `protobuf:"varint,10,opt,name=java_multiple_files,json=javaMultipleFiles,def=0" json:"java_multiple_files,omitempty"`
+	// This option does nothing.
+	//
+	// Deprecated: Do not use.
+	JavaGenerateEqualsAndHash *bool `protobuf:"varint,20,opt,name=java_generate_equals_and_hash,json=javaGenerateEqualsAndHash" json:"java_generate_equals_and_hash,omitempty"`
+	// If set true, then the Java2 code generator will generate code that
+	// throws an exception whenever an attempt is made to assign a non-UTF-8
+	// byte sequence to a string field.
+	// Message reflection will do the same.
+	// However, an extension field still accepts non-UTF-8 byte sequences.
+	// This option has no effect on when used with the lite runtime.
+	JavaStringCheckUtf8 *bool                     `protobuf:"varint,27,opt,name=java_string_check_utf8,json=javaStringCheckUtf8,def=0" json:"java_string_check_utf8,omitempty"`
+	OptimizeFor         *FileOptions_OptimizeMode `protobuf:"varint,9,opt,name=optimize_for,json=optimizeFor,enum=google.protobuf.FileOptions_OptimizeMode,def=1" json:"optimize_for,omitempty"`
+	// Sets the Go package where structs generated from this .proto will be
+	// placed. If omitted, the Go package will be derived from the following:
+	//   - The basename of the package import path, if provided.
+	//   - Otherwise, the package statement in the .proto file, if present.
+	//   - Otherwise, the basename of the .proto file, without extension.
+	GoPackage *string `protobuf:"bytes,11,opt,name=go_package,json=goPackage" json:"go_package,omitempty"`
+	// Should generic services be generated in each language?  "Generic" services
+	// are not specific to any particular RPC system.  They are generated by the
+	// main code generators in each language (without additional plugins).
+	// Generic services were the only kind of service generation supported by
+	// early versions of google.protobuf.
+	//
+	// Generic services are now considered deprecated in favor of using plugins
+	// that generate code specific to your particular RPC system.  Therefore,
+	// these default to false.  Old code which depends on generic services should
+	// explicitly set them to true.
+	CcGenericServices   *bool `protobuf:"varint,16,opt,name=cc_generic_services,json=ccGenericServices,def=0" json:"cc_generic_services,omitempty"`
+	JavaGenericServices *bool `protobuf:"varint,17,opt,name=java_generic_services,json=javaGenericServices,def=0" json:"java_generic_services,omitempty"`
+	PyGenericServices   *bool `protobuf:"varint,18,opt,name=py_generic_services,json=pyGenericServices,def=0" json:"py_generic_services,omitempty"`
+	PhpGenericServices  *bool `protobuf:"varint,42,opt,name=php_generic_services,json=phpGenericServices,def=0" json:"php_generic_services,omitempty"`
+	// Is this file deprecated?
+	// Depending on the target platform, this can emit Deprecated annotations
+	// for everything in the file, or it will be completely ignored; in the very
+	// least, this is a formalization for deprecating files.
+	Deprecated *bool `protobuf:"varint,23,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
+	// Enables the use of arenas for the proto messages in this file. This applies
+	// only to generated classes for C++.
+	CcEnableArenas *bool `protobuf:"varint,31,opt,name=cc_enable_arenas,json=ccEnableArenas,def=1" json:"cc_enable_arenas,omitempty"`
+	// Sets the objective c class prefix which is prepended to all objective c
+	// generated classes from this .proto. There is no default.
+	ObjcClassPrefix *string `protobuf:"bytes,36,opt,name=objc_class_prefix,json=objcClassPrefix" json:"objc_class_prefix,omitempty"`
+	// Namespace for generated classes; defaults to the package.
+	CsharpNamespace *string `protobuf:"bytes,37,opt,name=csharp_namespace,json=csharpNamespace" json:"csharp_namespace,omitempty"`
+	// By default Swift generators will take the proto package and CamelCase it
+	// replacing '.' with underscore and use that to prefix the types/symbols
+	// defined. When this options is provided, they will use this value instead
+	// to prefix the types/symbols defined.
+	SwiftPrefix *string `protobuf:"bytes,39,opt,name=swift_prefix,json=swiftPrefix" json:"swift_prefix,omitempty"`
+	// Sets the php class prefix which is prepended to all php generated classes
+	// from this .proto. Default is empty.
+	PhpClassPrefix *string `protobuf:"bytes,40,opt,name=php_class_prefix,json=phpClassPrefix" json:"php_class_prefix,omitempty"`
+	// Use this option to change the namespace of php generated classes. Default
+	// is empty. When this option is empty, the package name will be used for
+	// determining the namespace.
+	PhpNamespace *string `protobuf:"bytes,41,opt,name=php_namespace,json=phpNamespace" json:"php_namespace,omitempty"`
+	// Use this option to change the namespace of php generated metadata classes.
+	// Default is empty. When this option is empty, the proto file name will be
+	// used for determining the namespace.
+	PhpMetadataNamespace *string `protobuf:"bytes,44,opt,name=php_metadata_namespace,json=phpMetadataNamespace" json:"php_metadata_namespace,omitempty"`
+	// Use this option to change the package of ruby generated classes. Default
+	// is empty. When this option is not set, the package name will be used for
+	// determining the ruby package.
+	RubyPackage *string `protobuf:"bytes,45,opt,name=ruby_package,json=rubyPackage" json:"ruby_package,omitempty"`
+	// The parser stores options it doesn't recognize here.
+	// See the documentation for the "Options" section above.
+	UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+}
+
+// Default values for FileOptions fields.
+const (
+	Default_FileOptions_JavaMultipleFiles   = bool(false)
+	Default_FileOptions_JavaStringCheckUtf8 = bool(false)
+	Default_FileOptions_OptimizeFor         = FileOptions_SPEED
+	Default_FileOptions_CcGenericServices   = bool(false)
+	Default_FileOptions_JavaGenericServices = bool(false)
+	Default_FileOptions_PyGenericServices   = bool(false)
+	Default_FileOptions_PhpGenericServices  = bool(false)
+	Default_FileOptions_Deprecated          = bool(false)
+	Default_FileOptions_CcEnableArenas      = bool(true)
+)
+
+func (x *FileOptions) Reset() {
+	*x = FileOptions{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_descriptor_proto_msgTypes[10]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *FileOptions) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*FileOptions) ProtoMessage() {}
+
+func (x *FileOptions) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_descriptor_proto_msgTypes[10]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use FileOptions.ProtoReflect.Descriptor instead.
+func (*FileOptions) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{10}
+}
+
+var extRange_FileOptions = []protoiface.ExtensionRangeV1{
+	{Start: 1000, End: 536870911},
+}
+
+// Deprecated: Use FileOptions.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*FileOptions) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_FileOptions
+}
+
+func (x *FileOptions) GetJavaPackage() string {
+	if x != nil && x.JavaPackage != nil {
+		return *x.JavaPackage
+	}
+	return ""
+}
+
+func (x *FileOptions) GetJavaOuterClassname() string {
+	if x != nil && x.JavaOuterClassname != nil {
+		return *x.JavaOuterClassname
+	}
+	return ""
+}
+
+func (x *FileOptions) GetJavaMultipleFiles() bool {
+	if x != nil && x.JavaMultipleFiles != nil {
+		return *x.JavaMultipleFiles
+	}
+	return Default_FileOptions_JavaMultipleFiles
+}
+
+// Deprecated: Do not use.
+func (x *FileOptions) GetJavaGenerateEqualsAndHash() bool {
+	if x != nil && x.JavaGenerateEqualsAndHash != nil {
+		return *x.JavaGenerateEqualsAndHash
+	}
+	return false
+}
+
+func (x *FileOptions) GetJavaStringCheckUtf8() bool {
+	if x != nil && x.JavaStringCheckUtf8 != nil {
+		return *x.JavaStringCheckUtf8
+	}
+	return Default_FileOptions_JavaStringCheckUtf8
+}
+
+func (x *FileOptions) GetOptimizeFor() FileOptions_OptimizeMode {
+	if x != nil && x.OptimizeFor != nil {
+		return *x.OptimizeFor
+	}
+	return Default_FileOptions_OptimizeFor
+}
+
+func (x *FileOptions) GetGoPackage() string {
+	if x != nil && x.GoPackage != nil {
+		return *x.GoPackage
+	}
+	return ""
+}
+
+func (x *FileOptions) GetCcGenericServices() bool {
+	if x != nil && x.CcGenericServices != nil {
+		return *x.CcGenericServices
+	}
+	return Default_FileOptions_CcGenericServices
+}
+
+func (x *FileOptions) GetJavaGenericServices() bool {
+	if x != nil && x.JavaGenericServices != nil {
+		return *x.JavaGenericServices
+	}
+	return Default_FileOptions_JavaGenericServices
+}
+
+func (x *FileOptions) GetPyGenericServices() bool {
+	if x != nil && x.PyGenericServices != nil {
+		return *x.PyGenericServices
+	}
+	return Default_FileOptions_PyGenericServices
+}
+
+func (x *FileOptions) GetPhpGenericServices() bool {
+	if x != nil && x.PhpGenericServices != nil {
+		return *x.PhpGenericServices
+	}
+	return Default_FileOptions_PhpGenericServices
+}
+
+func (x *FileOptions) GetDeprecated() bool {
+	if x != nil && x.Deprecated != nil {
+		return *x.Deprecated
+	}
+	return Default_FileOptions_Deprecated
+}
+
+func (x *FileOptions) GetCcEnableArenas() bool {
+	if x != nil && x.CcEnableArenas != nil {
+		return *x.CcEnableArenas
+	}
+	return Default_FileOptions_CcEnableArenas
+}
+
+func (x *FileOptions) GetObjcClassPrefix() string {
+	if x != nil && x.ObjcClassPrefix != nil {
+		return *x.ObjcClassPrefix
+	}
+	return ""
+}
+
+func (x *FileOptions) GetCsharpNamespace() string {
+	if x != nil && x.CsharpNamespace != nil {
+		return *x.CsharpNamespace
+	}
+	return ""
+}
+
+func (x *FileOptions) GetSwiftPrefix() string {
+	if x != nil && x.SwiftPrefix != nil {
+		return *x.SwiftPrefix
+	}
+	return ""
+}
+
+func (x *FileOptions) GetPhpClassPrefix() string {
+	if x != nil && x.PhpClassPrefix != nil {
+		return *x.PhpClassPrefix
+	}
+	return ""
+}
+
+func (x *FileOptions) GetPhpNamespace() string {
+	if x != nil && x.PhpNamespace != nil {
+		return *x.PhpNamespace
+	}
+	return ""
+}
+
+func (x *FileOptions) GetPhpMetadataNamespace() string {
+	if x != nil && x.PhpMetadataNamespace != nil {
+		return *x.PhpMetadataNamespace
+	}
+	return ""
+}
+
+func (x *FileOptions) GetRubyPackage() string {
+	if x != nil && x.RubyPackage != nil {
+		return *x.RubyPackage
+	}
+	return ""
+}
+
+func (x *FileOptions) GetUninterpretedOption() []*UninterpretedOption {
+	if x != nil {
+		return x.UninterpretedOption
+	}
+	return nil
+}
+
+type MessageOptions struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+
+	// Set true to use the old proto1 MessageSet wire format for extensions.
+	// This is provided for backwards-compatibility with the MessageSet wire
+	// format.  You should not use this for any other reason:  It's less
+	// efficient, has fewer features, and is more complicated.
+	//
+	// The message must be defined exactly as follows:
+	//   message Foo {
+	//     option message_set_wire_format = true;
+	//     extensions 4 to max;
+	//   }
+	// Note that the message cannot have any defined fields; MessageSets only
+	// have extensions.
+	//
+	// All extensions of your type must be singular messages; e.g. they cannot
+	// be int32s, enums, or repeated messages.
+	//
+	// Because this is an option, the above two restrictions are not enforced by
+	// the protocol compiler.
+	MessageSetWireFormat *bool `protobuf:"varint,1,opt,name=message_set_wire_format,json=messageSetWireFormat,def=0" json:"message_set_wire_format,omitempty"`
+	// Disables the generation of the standard "descriptor()" accessor, which can
+	// conflict with a field of the same name.  This is meant to make migration
+	// from proto1 easier; new code should avoid fields named "descriptor".
+	NoStandardDescriptorAccessor *bool `protobuf:"varint,2,opt,name=no_standard_descriptor_accessor,json=noStandardDescriptorAccessor,def=0" json:"no_standard_descriptor_accessor,omitempty"`
+	// Is this message deprecated?
+	// Depending on the target platform, this can emit Deprecated annotations
+	// for the message, or it will be completely ignored; in the very least,
+	// this is a formalization for deprecating messages.
+	Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
+	// Whether the message is an automatically generated map entry type for the
+	// maps field.
+	//
+	// For maps fields:
+	//     map<KeyType, ValueType> map_field = 1;
+	// The parsed descriptor looks like:
+	//     message MapFieldEntry {
+	//         option map_entry = true;
+	//         optional KeyType key = 1;
+	//         optional ValueType value = 2;
+	//     }
+	//     repeated MapFieldEntry map_field = 1;
+	//
+	// Implementations may choose not to generate the map_entry=true message, but
+	// use a native map in the target language to hold the keys and values.
+	// The reflection APIs in such implementations still need to work as
+	// if the field is a repeated message field.
+	//
+	// NOTE: Do not set the option in .proto files. Always use the maps syntax
+	// instead. The option should only be implicitly set by the proto compiler
+	// parser.
+	MapEntry *bool `protobuf:"varint,7,opt,name=map_entry,json=mapEntry" json:"map_entry,omitempty"`
+	// The parser stores options it doesn't recognize here. See above.
+	UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+}
+
+// Default values for MessageOptions fields.
+const (
+	Default_MessageOptions_MessageSetWireFormat         = bool(false)
+	Default_MessageOptions_NoStandardDescriptorAccessor = bool(false)
+	Default_MessageOptions_Deprecated                   = bool(false)
+)
+
+func (x *MessageOptions) Reset() {
+	*x = MessageOptions{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_descriptor_proto_msgTypes[11]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MessageOptions) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MessageOptions) ProtoMessage() {}
+
+func (x *MessageOptions) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_descriptor_proto_msgTypes[11]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use MessageOptions.ProtoReflect.Descriptor instead.
+func (*MessageOptions) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{11}
+}
+
+var extRange_MessageOptions = []protoiface.ExtensionRangeV1{
+	{Start: 1000, End: 536870911},
+}
+
+// Deprecated: Use MessageOptions.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*MessageOptions) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_MessageOptions
+}
+
+func (x *MessageOptions) GetMessageSetWireFormat() bool {
+	if x != nil && x.MessageSetWireFormat != nil {
+		return *x.MessageSetWireFormat
+	}
+	return Default_MessageOptions_MessageSetWireFormat
+}
+
+func (x *MessageOptions) GetNoStandardDescriptorAccessor() bool {
+	if x != nil && x.NoStandardDescriptorAccessor != nil {
+		return *x.NoStandardDescriptorAccessor
+	}
+	return Default_MessageOptions_NoStandardDescriptorAccessor
+}
+
+func (x *MessageOptions) GetDeprecated() bool {
+	if x != nil && x.Deprecated != nil {
+		return *x.Deprecated
+	}
+	return Default_MessageOptions_Deprecated
+}
+
+func (x *MessageOptions) GetMapEntry() bool {
+	if x != nil && x.MapEntry != nil {
+		return *x.MapEntry
+	}
+	return false
+}
+
+func (x *MessageOptions) GetUninterpretedOption() []*UninterpretedOption {
+	if x != nil {
+		return x.UninterpretedOption
+	}
+	return nil
+}
+
+type FieldOptions struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+
+	// The ctype option instructs the C++ code generator to use a different
+	// representation of the field than it normally would.  See the specific
+	// options below.  This option is not yet implemented in the open source
+	// release -- sorry, we'll try to include it in a future version!
+	Ctype *FieldOptions_CType `protobuf:"varint,1,opt,name=ctype,enum=google.protobuf.FieldOptions_CType,def=0" json:"ctype,omitempty"`
+	// The packed option can be enabled for repeated primitive fields to enable
+	// a more efficient representation on the wire. Rather than repeatedly
+	// writing the tag and type for each element, the entire array is encoded as
+	// a single length-delimited blob. In proto3, only explicit setting it to
+	// false will avoid using packed encoding.
+	Packed *bool `protobuf:"varint,2,opt,name=packed" json:"packed,omitempty"`
+	// The jstype option determines the JavaScript type used for values of the
+	// field.  The option is permitted only for 64 bit integral and fixed types
+	// (int64, uint64, sint64, fixed64, sfixed64).  A field with jstype JS_STRING
+	// is represented as JavaScript string, which avoids loss of precision that
+	// can happen when a large value is converted to a floating point JavaScript.
+	// Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
+	// use the JavaScript "number" type.  The behavior of the default option
+	// JS_NORMAL is implementation dependent.
+	//
+	// This option is an enum to permit additional types to be added, e.g.
+	// goog.math.Integer.
+	Jstype *FieldOptions_JSType `protobuf:"varint,6,opt,name=jstype,enum=google.protobuf.FieldOptions_JSType,def=0" json:"jstype,omitempty"`
+	// Should this field be parsed lazily?  Lazy applies only to message-type
+	// fields.  It means that when the outer message is initially parsed, the
+	// inner message's contents will not be parsed but instead stored in encoded
+	// form.  The inner message will actually be parsed when it is first accessed.
+	//
+	// This is only a hint.  Implementations are free to choose whether to use
+	// eager or lazy parsing regardless of the value of this option.  However,
+	// setting this option true suggests that the protocol author believes that
+	// using lazy parsing on this field is worth the additional bookkeeping
+	// overhead typically needed to implement it.
+	//
+	// This option does not affect the public interface of any generated code;
+	// all method signatures remain the same.  Furthermore, thread-safety of the
+	// interface is not affected by this option; const methods remain safe to
+	// call from multiple threads concurrently, while non-const methods continue
+	// to require exclusive access.
+	//
+	//
+	// Note that implementations may choose not to check required fields within
+	// a lazy sub-message.  That is, calling IsInitialized() on the outer message
+	// may return true even if the inner message has missing required fields.
+	// This is necessary because otherwise the inner message would have to be
+	// parsed in order to perform the check, defeating the purpose of lazy
+	// parsing.  An implementation which chooses not to check required fields
+	// must be consistent about it.  That is, for any particular sub-message, the
+	// implementation must either *always* check its required fields, or *never*
+	// check its required fields, regardless of whether or not the message has
+	// been parsed.
+	Lazy *bool `protobuf:"varint,5,opt,name=lazy,def=0" json:"lazy,omitempty"`
+	// Is this field deprecated?
+	// Depending on the target platform, this can emit Deprecated annotations
+	// for accessors, or it will be completely ignored; in the very least, this
+	// is a formalization for deprecating fields.
+	Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
+	// For Google-internal migration only. Do not use.
+	Weak *bool `protobuf:"varint,10,opt,name=weak,def=0" json:"weak,omitempty"`
+	// The parser stores options it doesn't recognize here. See above.
+	UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+}
+
+// Default values for FieldOptions fields.
+const (
+	Default_FieldOptions_Ctype      = FieldOptions_STRING
+	Default_FieldOptions_Jstype     = FieldOptions_JS_NORMAL
+	Default_FieldOptions_Lazy       = bool(false)
+	Default_FieldOptions_Deprecated = bool(false)
+	Default_FieldOptions_Weak       = bool(false)
+)
+
+func (x *FieldOptions) Reset() {
+	*x = FieldOptions{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_descriptor_proto_msgTypes[12]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *FieldOptions) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*FieldOptions) ProtoMessage() {}
+
+func (x *FieldOptions) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_descriptor_proto_msgTypes[12]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use FieldOptions.ProtoReflect.Descriptor instead.
+func (*FieldOptions) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{12}
+}
+
+var extRange_FieldOptions = []protoiface.ExtensionRangeV1{
+	{Start: 1000, End: 536870911},
+}
+
+// Deprecated: Use FieldOptions.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*FieldOptions) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_FieldOptions
+}
+
+func (x *FieldOptions) GetCtype() FieldOptions_CType {
+	if x != nil && x.Ctype != nil {
+		return *x.Ctype
+	}
+	return Default_FieldOptions_Ctype
+}
+
+func (x *FieldOptions) GetPacked() bool {
+	if x != nil && x.Packed != nil {
+		return *x.Packed
+	}
+	return false
+}
+
+func (x *FieldOptions) GetJstype() FieldOptions_JSType {
+	if x != nil && x.Jstype != nil {
+		return *x.Jstype
+	}
+	return Default_FieldOptions_Jstype
+}
+
+func (x *FieldOptions) GetLazy() bool {
+	if x != nil && x.Lazy != nil {
+		return *x.Lazy
+	}
+	return Default_FieldOptions_Lazy
+}
+
+func (x *FieldOptions) GetDeprecated() bool {
+	if x != nil && x.Deprecated != nil {
+		return *x.Deprecated
+	}
+	return Default_FieldOptions_Deprecated
+}
+
+func (x *FieldOptions) GetWeak() bool {
+	if x != nil && x.Weak != nil {
+		return *x.Weak
+	}
+	return Default_FieldOptions_Weak
+}
+
+func (x *FieldOptions) GetUninterpretedOption() []*UninterpretedOption {
+	if x != nil {
+		return x.UninterpretedOption
+	}
+	return nil
+}
+
+type OneofOptions struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+
+	// The parser stores options it doesn't recognize here. See above.
+	UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+}
+
+func (x *OneofOptions) Reset() {
+	*x = OneofOptions{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_descriptor_proto_msgTypes[13]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *OneofOptions) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*OneofOptions) ProtoMessage() {}
+
+func (x *OneofOptions) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_descriptor_proto_msgTypes[13]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use OneofOptions.ProtoReflect.Descriptor instead.
+func (*OneofOptions) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{13}
+}
+
+var extRange_OneofOptions = []protoiface.ExtensionRangeV1{
+	{Start: 1000, End: 536870911},
+}
+
+// Deprecated: Use OneofOptions.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*OneofOptions) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_OneofOptions
+}
+
+func (x *OneofOptions) GetUninterpretedOption() []*UninterpretedOption {
+	if x != nil {
+		return x.UninterpretedOption
+	}
+	return nil
+}
+
+type EnumOptions struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+
+	// Set this option to true to allow mapping different tag names to the same
+	// value.
+	AllowAlias *bool `protobuf:"varint,2,opt,name=allow_alias,json=allowAlias" json:"allow_alias,omitempty"`
+	// Is this enum deprecated?
+	// Depending on the target platform, this can emit Deprecated annotations
+	// for the enum, or it will be completely ignored; in the very least, this
+	// is a formalization for deprecating enums.
+	Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
+	// The parser stores options it doesn't recognize here. See above.
+	UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+}
+
+// Default values for EnumOptions fields.
+const (
+	Default_EnumOptions_Deprecated = bool(false)
+)
+
+func (x *EnumOptions) Reset() {
+	*x = EnumOptions{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_descriptor_proto_msgTypes[14]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *EnumOptions) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*EnumOptions) ProtoMessage() {}
+
+func (x *EnumOptions) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_descriptor_proto_msgTypes[14]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use EnumOptions.ProtoReflect.Descriptor instead.
+func (*EnumOptions) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{14}
+}
+
+var extRange_EnumOptions = []protoiface.ExtensionRangeV1{
+	{Start: 1000, End: 536870911},
+}
+
+// Deprecated: Use EnumOptions.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*EnumOptions) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_EnumOptions
+}
+
+func (x *EnumOptions) GetAllowAlias() bool {
+	if x != nil && x.AllowAlias != nil {
+		return *x.AllowAlias
+	}
+	return false
+}
+
+func (x *EnumOptions) GetDeprecated() bool {
+	if x != nil && x.Deprecated != nil {
+		return *x.Deprecated
+	}
+	return Default_EnumOptions_Deprecated
+}
+
+func (x *EnumOptions) GetUninterpretedOption() []*UninterpretedOption {
+	if x != nil {
+		return x.UninterpretedOption
+	}
+	return nil
+}
+
+type EnumValueOptions struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+
+	// Is this enum value deprecated?
+	// Depending on the target platform, this can emit Deprecated annotations
+	// for the enum value, or it will be completely ignored; in the very least,
+	// this is a formalization for deprecating enum values.
+	Deprecated *bool `protobuf:"varint,1,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
+	// The parser stores options it doesn't recognize here. See above.
+	UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+}
+
+// Default values for EnumValueOptions fields.
+const (
+	Default_EnumValueOptions_Deprecated = bool(false)
+)
+
+func (x *EnumValueOptions) Reset() {
+	*x = EnumValueOptions{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_descriptor_proto_msgTypes[15]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *EnumValueOptions) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*EnumValueOptions) ProtoMessage() {}
+
+func (x *EnumValueOptions) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_descriptor_proto_msgTypes[15]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use EnumValueOptions.ProtoReflect.Descriptor instead.
+func (*EnumValueOptions) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{15}
+}
+
+var extRange_EnumValueOptions = []protoiface.ExtensionRangeV1{
+	{Start: 1000, End: 536870911},
+}
+
+// Deprecated: Use EnumValueOptions.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*EnumValueOptions) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_EnumValueOptions
+}
+
+func (x *EnumValueOptions) GetDeprecated() bool {
+	if x != nil && x.Deprecated != nil {
+		return *x.Deprecated
+	}
+	return Default_EnumValueOptions_Deprecated
+}
+
+func (x *EnumValueOptions) GetUninterpretedOption() []*UninterpretedOption {
+	if x != nil {
+		return x.UninterpretedOption
+	}
+	return nil
+}
+
+type ServiceOptions struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+
+	// Is this service deprecated?
+	// Depending on the target platform, this can emit Deprecated annotations
+	// for the service, or it will be completely ignored; in the very least,
+	// this is a formalization for deprecating services.
+	Deprecated *bool `protobuf:"varint,33,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
+	// The parser stores options it doesn't recognize here. See above.
+	UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+}
+
+// Default values for ServiceOptions fields.
+const (
+	Default_ServiceOptions_Deprecated = bool(false)
+)
+
+func (x *ServiceOptions) Reset() {
+	*x = ServiceOptions{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_descriptor_proto_msgTypes[16]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *ServiceOptions) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ServiceOptions) ProtoMessage() {}
+
+func (x *ServiceOptions) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_descriptor_proto_msgTypes[16]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ServiceOptions.ProtoReflect.Descriptor instead.
+func (*ServiceOptions) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{16}
+}
+
+var extRange_ServiceOptions = []protoiface.ExtensionRangeV1{
+	{Start: 1000, End: 536870911},
+}
+
+// Deprecated: Use ServiceOptions.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*ServiceOptions) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_ServiceOptions
+}
+
+func (x *ServiceOptions) GetDeprecated() bool {
+	if x != nil && x.Deprecated != nil {
+		return *x.Deprecated
+	}
+	return Default_ServiceOptions_Deprecated
+}
+
+func (x *ServiceOptions) GetUninterpretedOption() []*UninterpretedOption {
+	if x != nil {
+		return x.UninterpretedOption
+	}
+	return nil
+}
+
+type MethodOptions struct {
+	state           protoimpl.MessageState
+	sizeCache       protoimpl.SizeCache
+	unknownFields   protoimpl.UnknownFields
+	extensionFields protoimpl.ExtensionFields
+
+	// Is this method deprecated?
+	// Depending on the target platform, this can emit Deprecated annotations
+	// for the method, or it will be completely ignored; in the very least,
+	// this is a formalization for deprecating methods.
+	Deprecated       *bool                           `protobuf:"varint,33,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
+	IdempotencyLevel *MethodOptions_IdempotencyLevel `protobuf:"varint,34,opt,name=idempotency_level,json=idempotencyLevel,enum=google.protobuf.MethodOptions_IdempotencyLevel,def=0" json:"idempotency_level,omitempty"`
+	// The parser stores options it doesn't recognize here. See above.
+	UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+}
+
+// Default values for MethodOptions fields.
+const (
+	Default_MethodOptions_Deprecated       = bool(false)
+	Default_MethodOptions_IdempotencyLevel = MethodOptions_IDEMPOTENCY_UNKNOWN
+)
+
+func (x *MethodOptions) Reset() {
+	*x = MethodOptions{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_descriptor_proto_msgTypes[17]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MethodOptions) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MethodOptions) ProtoMessage() {}
+
+func (x *MethodOptions) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_descriptor_proto_msgTypes[17]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use MethodOptions.ProtoReflect.Descriptor instead.
+func (*MethodOptions) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{17}
+}
+
+var extRange_MethodOptions = []protoiface.ExtensionRangeV1{
+	{Start: 1000, End: 536870911},
+}
+
+// Deprecated: Use MethodOptions.ProtoReflect.Descriptor.ExtensionRanges instead.
+func (*MethodOptions) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
+	return extRange_MethodOptions
+}
+
+func (x *MethodOptions) GetDeprecated() bool {
+	if x != nil && x.Deprecated != nil {
+		return *x.Deprecated
+	}
+	return Default_MethodOptions_Deprecated
+}
+
+func (x *MethodOptions) GetIdempotencyLevel() MethodOptions_IdempotencyLevel {
+	if x != nil && x.IdempotencyLevel != nil {
+		return *x.IdempotencyLevel
+	}
+	return Default_MethodOptions_IdempotencyLevel
+}
+
+func (x *MethodOptions) GetUninterpretedOption() []*UninterpretedOption {
+	if x != nil {
+		return x.UninterpretedOption
+	}
+	return nil
+}
+
+// A message representing a option the parser does not recognize. This only
+// appears in options protos created by the compiler::Parser class.
+// DescriptorPool resolves these when building Descriptor objects. Therefore,
+// options protos in descriptor objects (e.g. returned by Descriptor::options(),
+// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
+// in them.
+type UninterpretedOption struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Name []*UninterpretedOption_NamePart `protobuf:"bytes,2,rep,name=name" json:"name,omitempty"`
+	// The value of the uninterpreted option, in whatever type the tokenizer
+	// identified it as during parsing. Exactly one of these should be set.
+	IdentifierValue  *string  `protobuf:"bytes,3,opt,name=identifier_value,json=identifierValue" json:"identifier_value,omitempty"`
+	PositiveIntValue *uint64  `protobuf:"varint,4,opt,name=positive_int_value,json=positiveIntValue" json:"positive_int_value,omitempty"`
+	NegativeIntValue *int64   `protobuf:"varint,5,opt,name=negative_int_value,json=negativeIntValue" json:"negative_int_value,omitempty"`
+	DoubleValue      *float64 `protobuf:"fixed64,6,opt,name=double_value,json=doubleValue" json:"double_value,omitempty"`
+	StringValue      []byte   `protobuf:"bytes,7,opt,name=string_value,json=stringValue" json:"string_value,omitempty"`
+	AggregateValue   *string  `protobuf:"bytes,8,opt,name=aggregate_value,json=aggregateValue" json:"aggregate_value,omitempty"`
+}
+
+func (x *UninterpretedOption) Reset() {
+	*x = UninterpretedOption{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_descriptor_proto_msgTypes[18]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *UninterpretedOption) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*UninterpretedOption) ProtoMessage() {}
+
+func (x *UninterpretedOption) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_descriptor_proto_msgTypes[18]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use UninterpretedOption.ProtoReflect.Descriptor instead.
+func (*UninterpretedOption) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{18}
+}
+
+func (x *UninterpretedOption) GetName() []*UninterpretedOption_NamePart {
+	if x != nil {
+		return x.Name
+	}
+	return nil
+}
+
+func (x *UninterpretedOption) GetIdentifierValue() string {
+	if x != nil && x.IdentifierValue != nil {
+		return *x.IdentifierValue
+	}
+	return ""
+}
+
+func (x *UninterpretedOption) GetPositiveIntValue() uint64 {
+	if x != nil && x.PositiveIntValue != nil {
+		return *x.PositiveIntValue
+	}
+	return 0
+}
+
+func (x *UninterpretedOption) GetNegativeIntValue() int64 {
+	if x != nil && x.NegativeIntValue != nil {
+		return *x.NegativeIntValue
+	}
+	return 0
+}
+
+func (x *UninterpretedOption) GetDoubleValue() float64 {
+	if x != nil && x.DoubleValue != nil {
+		return *x.DoubleValue
+	}
+	return 0
+}
+
+func (x *UninterpretedOption) GetStringValue() []byte {
+	if x != nil {
+		return x.StringValue
+	}
+	return nil
+}
+
+func (x *UninterpretedOption) GetAggregateValue() string {
+	if x != nil && x.AggregateValue != nil {
+		return *x.AggregateValue
+	}
+	return ""
+}
+
+// Encapsulates information about the original source file from which a
+// FileDescriptorProto was generated.
+type SourceCodeInfo struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// A Location identifies a piece of source code in a .proto file which
+	// corresponds to a particular definition.  This information is intended
+	// to be useful to IDEs, code indexers, documentation generators, and similar
+	// tools.
+	//
+	// For example, say we have a file like:
+	//   message Foo {
+	//     optional string foo = 1;
+	//   }
+	// Let's look at just the field definition:
+	//   optional string foo = 1;
+	//   ^       ^^     ^^  ^  ^^^
+	//   a       bc     de  f  ghi
+	// We have the following locations:
+	//   span   path               represents
+	//   [a,i)  [ 4, 0, 2, 0 ]     The whole field definition.
+	//   [a,b)  [ 4, 0, 2, 0, 4 ]  The label (optional).
+	//   [c,d)  [ 4, 0, 2, 0, 5 ]  The type (string).
+	//   [e,f)  [ 4, 0, 2, 0, 1 ]  The name (foo).
+	//   [g,h)  [ 4, 0, 2, 0, 3 ]  The number (1).
+	//
+	// Notes:
+	// - A location may refer to a repeated field itself (i.e. not to any
+	//   particular index within it).  This is used whenever a set of elements are
+	//   logically enclosed in a single code segment.  For example, an entire
+	//   extend block (possibly containing multiple extension definitions) will
+	//   have an outer location whose path refers to the "extensions" repeated
+	//   field without an index.
+	// - Multiple locations may have the same path.  This happens when a single
+	//   logical declaration is spread out across multiple places.  The most
+	//   obvious example is the "extend" block again -- there may be multiple
+	//   extend blocks in the same scope, each of which will have the same path.
+	// - A location's span is not always a subset of its parent's span.  For
+	//   example, the "extendee" of an extension declaration appears at the
+	//   beginning of the "extend" block and is shared by all extensions within
+	//   the block.
+	// - Just because a location's span is a subset of some other location's span
+	//   does not mean that it is a descendant.  For example, a "group" defines
+	//   both a type and a field in a single declaration.  Thus, the locations
+	//   corresponding to the type and field and their components will overlap.
+	// - Code which tries to interpret locations should probably be designed to
+	//   ignore those that it doesn't understand, as more types of locations could
+	//   be recorded in the future.
+	Location []*SourceCodeInfo_Location `protobuf:"bytes,1,rep,name=location" json:"location,omitempty"`
+}
+
+func (x *SourceCodeInfo) Reset() {
+	*x = SourceCodeInfo{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_descriptor_proto_msgTypes[19]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *SourceCodeInfo) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*SourceCodeInfo) ProtoMessage() {}
+
+func (x *SourceCodeInfo) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_descriptor_proto_msgTypes[19]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use SourceCodeInfo.ProtoReflect.Descriptor instead.
+func (*SourceCodeInfo) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{19}
+}
+
+func (x *SourceCodeInfo) GetLocation() []*SourceCodeInfo_Location {
+	if x != nil {
+		return x.Location
+	}
+	return nil
+}
+
+// Describes the relationship between generated code and its original source
+// file. A GeneratedCodeInfo message is associated with only one generated
+// source file, but may contain references to different source .proto files.
+type GeneratedCodeInfo struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// An Annotation connects some span of text in generated code to an element
+	// of its generating .proto file.
+	Annotation []*GeneratedCodeInfo_Annotation `protobuf:"bytes,1,rep,name=annotation" json:"annotation,omitempty"`
+}
+
+func (x *GeneratedCodeInfo) Reset() {
+	*x = GeneratedCodeInfo{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_descriptor_proto_msgTypes[20]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *GeneratedCodeInfo) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GeneratedCodeInfo) ProtoMessage() {}
+
+func (x *GeneratedCodeInfo) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_descriptor_proto_msgTypes[20]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use GeneratedCodeInfo.ProtoReflect.Descriptor instead.
+func (*GeneratedCodeInfo) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{20}
+}
+
+func (x *GeneratedCodeInfo) GetAnnotation() []*GeneratedCodeInfo_Annotation {
+	if x != nil {
+		return x.Annotation
+	}
+	return nil
+}
+
+type DescriptorProto_ExtensionRange struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Start   *int32                 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"` // Inclusive.
+	End     *int32                 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"`     // Exclusive.
+	Options *ExtensionRangeOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
+}
+
+func (x *DescriptorProto_ExtensionRange) Reset() {
+	*x = DescriptorProto_ExtensionRange{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_descriptor_proto_msgTypes[21]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *DescriptorProto_ExtensionRange) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DescriptorProto_ExtensionRange) ProtoMessage() {}
+
+func (x *DescriptorProto_ExtensionRange) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_descriptor_proto_msgTypes[21]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use DescriptorProto_ExtensionRange.ProtoReflect.Descriptor instead.
+func (*DescriptorProto_ExtensionRange) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{2, 0}
+}
+
+func (x *DescriptorProto_ExtensionRange) GetStart() int32 {
+	if x != nil && x.Start != nil {
+		return *x.Start
+	}
+	return 0
+}
+
+func (x *DescriptorProto_ExtensionRange) GetEnd() int32 {
+	if x != nil && x.End != nil {
+		return *x.End
+	}
+	return 0
+}
+
+func (x *DescriptorProto_ExtensionRange) GetOptions() *ExtensionRangeOptions {
+	if x != nil {
+		return x.Options
+	}
+	return nil
+}
+
+// Range of reserved tag numbers. Reserved tag numbers may not be used by
+// fields or extension ranges in the same message. Reserved ranges may
+// not overlap.
+type DescriptorProto_ReservedRange struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Start *int32 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"` // Inclusive.
+	End   *int32 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"`     // Exclusive.
+}
+
+func (x *DescriptorProto_ReservedRange) Reset() {
+	*x = DescriptorProto_ReservedRange{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_descriptor_proto_msgTypes[22]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *DescriptorProto_ReservedRange) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DescriptorProto_ReservedRange) ProtoMessage() {}
+
+func (x *DescriptorProto_ReservedRange) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_descriptor_proto_msgTypes[22]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use DescriptorProto_ReservedRange.ProtoReflect.Descriptor instead.
+func (*DescriptorProto_ReservedRange) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{2, 1}
+}
+
+func (x *DescriptorProto_ReservedRange) GetStart() int32 {
+	if x != nil && x.Start != nil {
+		return *x.Start
+	}
+	return 0
+}
+
+func (x *DescriptorProto_ReservedRange) GetEnd() int32 {
+	if x != nil && x.End != nil {
+		return *x.End
+	}
+	return 0
+}
+
+// Range of reserved numeric values. Reserved values may not be used by
+// entries in the same enum. Reserved ranges may not overlap.
+//
+// Note that this is distinct from DescriptorProto.ReservedRange in that it
+// is inclusive such that it can appropriately represent the entire int32
+// domain.
+type EnumDescriptorProto_EnumReservedRange struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Start *int32 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"` // Inclusive.
+	End   *int32 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"`     // Inclusive.
+}
+
+func (x *EnumDescriptorProto_EnumReservedRange) Reset() {
+	*x = EnumDescriptorProto_EnumReservedRange{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_descriptor_proto_msgTypes[23]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *EnumDescriptorProto_EnumReservedRange) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*EnumDescriptorProto_EnumReservedRange) ProtoMessage() {}
+
+func (x *EnumDescriptorProto_EnumReservedRange) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_descriptor_proto_msgTypes[23]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use EnumDescriptorProto_EnumReservedRange.ProtoReflect.Descriptor instead.
+func (*EnumDescriptorProto_EnumReservedRange) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{6, 0}
+}
+
+func (x *EnumDescriptorProto_EnumReservedRange) GetStart() int32 {
+	if x != nil && x.Start != nil {
+		return *x.Start
+	}
+	return 0
+}
+
+func (x *EnumDescriptorProto_EnumReservedRange) GetEnd() int32 {
+	if x != nil && x.End != nil {
+		return *x.End
+	}
+	return 0
+}
+
+// The name of the uninterpreted option.  Each string represents a segment in
+// a dot-separated name.  is_extension is true iff a segment represents an
+// extension (denoted with parentheses in options specs in .proto files).
+// E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents
+// "foo.(bar.baz).qux".
+type UninterpretedOption_NamePart struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	NamePart    *string `protobuf:"bytes,1,req,name=name_part,json=namePart" json:"name_part,omitempty"`
+	IsExtension *bool   `protobuf:"varint,2,req,name=is_extension,json=isExtension" json:"is_extension,omitempty"`
+}
+
+func (x *UninterpretedOption_NamePart) Reset() {
+	*x = UninterpretedOption_NamePart{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_descriptor_proto_msgTypes[24]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *UninterpretedOption_NamePart) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*UninterpretedOption_NamePart) ProtoMessage() {}
+
+func (x *UninterpretedOption_NamePart) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_descriptor_proto_msgTypes[24]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use UninterpretedOption_NamePart.ProtoReflect.Descriptor instead.
+func (*UninterpretedOption_NamePart) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{18, 0}
+}
+
+func (x *UninterpretedOption_NamePart) GetNamePart() string {
+	if x != nil && x.NamePart != nil {
+		return *x.NamePart
+	}
+	return ""
+}
+
+func (x *UninterpretedOption_NamePart) GetIsExtension() bool {
+	if x != nil && x.IsExtension != nil {
+		return *x.IsExtension
+	}
+	return false
+}
+
+type SourceCodeInfo_Location struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// Identifies which part of the FileDescriptorProto was defined at this
+	// location.
+	//
+	// Each element is a field number or an index.  They form a path from
+	// the root FileDescriptorProto to the place where the definition.  For
+	// example, this path:
+	//   [ 4, 3, 2, 7, 1 ]
+	// refers to:
+	//   file.message_type(3)  // 4, 3
+	//       .field(7)         // 2, 7
+	//       .name()           // 1
+	// This is because FileDescriptorProto.message_type has field number 4:
+	//   repeated DescriptorProto message_type = 4;
+	// and DescriptorProto.field has field number 2:
+	//   repeated FieldDescriptorProto field = 2;
+	// and FieldDescriptorProto.name has field number 1:
+	//   optional string name = 1;
+	//
+	// Thus, the above path gives the location of a field name.  If we removed
+	// the last element:
+	//   [ 4, 3, 2, 7 ]
+	// this path refers to the whole field declaration (from the beginning
+	// of the label to the terminating semicolon).
+	Path []int32 `protobuf:"varint,1,rep,packed,name=path" json:"path,omitempty"`
+	// Always has exactly three or four elements: start line, start column,
+	// end line (optional, otherwise assumed same as start line), end column.
+	// These are packed into a single field for efficiency.  Note that line
+	// and column numbers are zero-based -- typically you will want to add
+	// 1 to each before displaying to a user.
+	Span []int32 `protobuf:"varint,2,rep,packed,name=span" json:"span,omitempty"`
+	// If this SourceCodeInfo represents a complete declaration, these are any
+	// comments appearing before and after the declaration which appear to be
+	// attached to the declaration.
+	//
+	// A series of line comments appearing on consecutive lines, with no other
+	// tokens appearing on those lines, will be treated as a single comment.
+	//
+	// leading_detached_comments will keep paragraphs of comments that appear
+	// before (but not connected to) the current element. Each paragraph,
+	// separated by empty lines, will be one comment element in the repeated
+	// field.
+	//
+	// Only the comment content is provided; comment markers (e.g. //) are
+	// stripped out.  For block comments, leading whitespace and an asterisk
+	// will be stripped from the beginning of each line other than the first.
+	// Newlines are included in the output.
+	//
+	// Examples:
+	//
+	//   optional int32 foo = 1;  // Comment attached to foo.
+	//   // Comment attached to bar.
+	//   optional int32 bar = 2;
+	//
+	//   optional string baz = 3;
+	//   // Comment attached to baz.
+	//   // Another line attached to baz.
+	//
+	//   // Comment attached to qux.
+	//   //
+	//   // Another line attached to qux.
+	//   optional double qux = 4;
+	//
+	//   // Detached comment for corge. This is not leading or trailing comments
+	//   // to qux or corge because there are blank lines separating it from
+	//   // both.
+	//
+	//   // Detached comment for corge paragraph 2.
+	//
+	//   optional string corge = 5;
+	//   /* Block comment attached
+	//    * to corge.  Leading asterisks
+	//    * will be removed. */
+	//   /* Block comment attached to
+	//    * grault. */
+	//   optional int32 grault = 6;
+	//
+	//   // ignored detached comments.
+	LeadingComments         *string  `protobuf:"bytes,3,opt,name=leading_comments,json=leadingComments" json:"leading_comments,omitempty"`
+	TrailingComments        *string  `protobuf:"bytes,4,opt,name=trailing_comments,json=trailingComments" json:"trailing_comments,omitempty"`
+	LeadingDetachedComments []string `protobuf:"bytes,6,rep,name=leading_detached_comments,json=leadingDetachedComments" json:"leading_detached_comments,omitempty"`
+}
+
+func (x *SourceCodeInfo_Location) Reset() {
+	*x = SourceCodeInfo_Location{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_descriptor_proto_msgTypes[25]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *SourceCodeInfo_Location) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*SourceCodeInfo_Location) ProtoMessage() {}
+
+func (x *SourceCodeInfo_Location) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_descriptor_proto_msgTypes[25]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use SourceCodeInfo_Location.ProtoReflect.Descriptor instead.
+func (*SourceCodeInfo_Location) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{19, 0}
+}
+
+func (x *SourceCodeInfo_Location) GetPath() []int32 {
+	if x != nil {
+		return x.Path
+	}
+	return nil
+}
+
+func (x *SourceCodeInfo_Location) GetSpan() []int32 {
+	if x != nil {
+		return x.Span
+	}
+	return nil
+}
+
+func (x *SourceCodeInfo_Location) GetLeadingComments() string {
+	if x != nil && x.LeadingComments != nil {
+		return *x.LeadingComments
+	}
+	return ""
+}
+
+func (x *SourceCodeInfo_Location) GetTrailingComments() string {
+	if x != nil && x.TrailingComments != nil {
+		return *x.TrailingComments
+	}
+	return ""
+}
+
+func (x *SourceCodeInfo_Location) GetLeadingDetachedComments() []string {
+	if x != nil {
+		return x.LeadingDetachedComments
+	}
+	return nil
+}
+
+type GeneratedCodeInfo_Annotation struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// Identifies the element in the original source .proto file. This field
+	// is formatted the same as SourceCodeInfo.Location.path.
+	Path []int32 `protobuf:"varint,1,rep,packed,name=path" json:"path,omitempty"`
+	// Identifies the filesystem path to the original source .proto.
+	SourceFile *string `protobuf:"bytes,2,opt,name=source_file,json=sourceFile" json:"source_file,omitempty"`
+	// Identifies the starting offset in bytes in the generated code
+	// that relates to the identified object.
+	Begin *int32 `protobuf:"varint,3,opt,name=begin" json:"begin,omitempty"`
+	// Identifies the ending offset in bytes in the generated code that
+	// relates to the identified offset. The end offset should be one past
+	// the last relevant byte (so the length of the text = end - begin).
+	End *int32 `protobuf:"varint,4,opt,name=end" json:"end,omitempty"`
+}
+
+func (x *GeneratedCodeInfo_Annotation) Reset() {
+	*x = GeneratedCodeInfo_Annotation{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_descriptor_proto_msgTypes[26]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *GeneratedCodeInfo_Annotation) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GeneratedCodeInfo_Annotation) ProtoMessage() {}
+
+func (x *GeneratedCodeInfo_Annotation) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_descriptor_proto_msgTypes[26]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use GeneratedCodeInfo_Annotation.ProtoReflect.Descriptor instead.
+func (*GeneratedCodeInfo_Annotation) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{20, 0}
+}
+
+func (x *GeneratedCodeInfo_Annotation) GetPath() []int32 {
+	if x != nil {
+		return x.Path
+	}
+	return nil
+}
+
+func (x *GeneratedCodeInfo_Annotation) GetSourceFile() string {
+	if x != nil && x.SourceFile != nil {
+		return *x.SourceFile
+	}
+	return ""
+}
+
+func (x *GeneratedCodeInfo_Annotation) GetBegin() int32 {
+	if x != nil && x.Begin != nil {
+		return *x.Begin
+	}
+	return 0
+}
+
+func (x *GeneratedCodeInfo_Annotation) GetEnd() int32 {
+	if x != nil && x.End != nil {
+		return *x.End
+	}
+	return 0
+}
+
+var File_google_protobuf_descriptor_proto protoreflect.FileDescriptor
+
+var file_google_protobuf_descriptor_proto_rawDesc = []byte{
+	0x0a, 0x20, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x2f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x12, 0x0f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x62, 0x75, 0x66, 0x22, 0x4d, 0x0a, 0x11, 0x46, 0x69, 0x6c, 0x65, 0x44, 0x65, 0x73, 0x63, 0x72,
+	0x69, 0x70, 0x74, 0x6f, 0x72, 0x53, 0x65, 0x74, 0x12, 0x38, 0x0a, 0x04, 0x66, 0x69, 0x6c, 0x65,
+	0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x6c, 0x65, 0x44, 0x65, 0x73,
+	0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x04, 0x66, 0x69,
+	0x6c, 0x65, 0x22, 0xe4, 0x04, 0x0a, 0x13, 0x46, 0x69, 0x6c, 0x65, 0x44, 0x65, 0x73, 0x63, 0x72,
+	0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61,
+	0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x18,
+	0x0a, 0x07, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x07, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x65,
+	0x6e, 0x64, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x64, 0x65,
+	0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x2b, 0x0a, 0x11, 0x70, 0x75, 0x62, 0x6c,
+	0x69, 0x63, 0x5f, 0x64, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x0a, 0x20,
+	0x03, 0x28, 0x05, 0x52, 0x10, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x44, 0x65, 0x70, 0x65, 0x6e,
+	0x64, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x27, 0x0a, 0x0f, 0x77, 0x65, 0x61, 0x6b, 0x5f, 0x64, 0x65,
+	0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0e,
+	0x77, 0x65, 0x61, 0x6b, 0x44, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x43,
+	0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x04,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f,
+	0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x0b, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54,
+	0x79, 0x70, 0x65, 0x12, 0x41, 0x0a, 0x09, 0x65, 0x6e, 0x75, 0x6d, 0x5f, 0x74, 0x79, 0x70, 0x65,
+	0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x44, 0x65, 0x73,
+	0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x08, 0x65, 0x6e,
+	0x75, 0x6d, 0x54, 0x79, 0x70, 0x65, 0x12, 0x41, 0x0a, 0x07, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63,
+	0x65, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63,
+	0x65, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f,
+	0x52, 0x07, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x43, 0x0a, 0x09, 0x65, 0x78, 0x74,
+	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46,
+	0x69, 0x65, 0x6c, 0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72,
+	0x6f, 0x74, 0x6f, 0x52, 0x09, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x36,
+	0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x2e, 0x46, 0x69, 0x6c, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x49, 0x0a, 0x10, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65,
+	0x5f, 0x63, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
+	0x75, 0x66, 0x2e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66,
+	0x6f, 0x52, 0x0e, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66,
+	0x6f, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x18, 0x0c, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x06, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x22, 0xb9, 0x06, 0x0a, 0x0f, 0x44, 0x65,
+	0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x0a,
+	0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d,
+	0x65, 0x12, 0x3b, 0x0a, 0x05, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x25, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
+	0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74,
+	0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x05, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x43,
+	0x0a, 0x09, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x06, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x25, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70,
+	0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x09, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73,
+	0x69, 0x6f, 0x6e, 0x12, 0x41, 0x0a, 0x0b, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x74, 0x79,
+	0x70, 0x65, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x65, 0x73, 0x63, 0x72,
+	0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x0a, 0x6e, 0x65, 0x73, 0x74,
+	0x65, 0x64, 0x54, 0x79, 0x70, 0x65, 0x12, 0x41, 0x0a, 0x09, 0x65, 0x6e, 0x75, 0x6d, 0x5f, 0x74,
+	0x79, 0x70, 0x65, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d,
+	0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52,
+	0x08, 0x65, 0x6e, 0x75, 0x6d, 0x54, 0x79, 0x70, 0x65, 0x12, 0x58, 0x0a, 0x0f, 0x65, 0x78, 0x74,
+	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x05, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50,
+	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61,
+	0x6e, 0x67, 0x65, 0x52, 0x0e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61,
+	0x6e, 0x67, 0x65, 0x12, 0x44, 0x0a, 0x0a, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x64, 0x65, 0x63,
+	0x6c, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4f, 0x6e, 0x65, 0x6f, 0x66, 0x44,
+	0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x09,
+	0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x44, 0x65, 0x63, 0x6c, 0x12, 0x39, 0x0a, 0x07, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x73, 0x12, 0x55, 0x0a, 0x0e, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64,
+	0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44,
+	0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x52,
+	0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x0d, 0x72, 0x65,
+	0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x72,
+	0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x0a, 0x20, 0x03,
+	0x28, 0x09, 0x52, 0x0c, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x4e, 0x61, 0x6d, 0x65,
+	0x1a, 0x7a, 0x0a, 0x0e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61, 0x6e,
+	0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x65, 0x6e, 0x64, 0x12, 0x40, 0x0a, 0x07, 0x6f, 0x70,
+	0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x78,
+	0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1a, 0x37, 0x0a, 0x0d,
+	0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a,
+	0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x73, 0x74,
+	0x61, 0x72, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x03, 0x65, 0x6e, 0x64, 0x22, 0x7c, 0x0a, 0x15, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69,
+	0x6f, 0x6e, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x58,
+	0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f,
+	0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
+	0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x52, 0x13, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74,
+	0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80,
+	0x80, 0x80, 0x02, 0x22, 0xc1, 0x06, 0x0a, 0x14, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44, 0x65, 0x73,
+	0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x0a, 0x04,
+	0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65,
+	0x12, 0x16, 0x0a, 0x06, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x06, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x41, 0x0a, 0x05, 0x6c, 0x61, 0x62, 0x65,
+	0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44,
+	0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x4c,
+	0x61, 0x62, 0x65, 0x6c, 0x52, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x12, 0x3e, 0x0a, 0x04, 0x74,
+	0x79, 0x70, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2a, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c,
+	0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f,
+	0x2e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x74,
+	0x79, 0x70, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08,
+	0x74, 0x79, 0x70, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x74, 0x65,
+	0x6e, 0x64, 0x65, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x74, 0x65,
+	0x6e, 0x64, 0x65, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f,
+	0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x64, 0x65, 0x66,
+	0x61, 0x75, 0x6c, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x6f, 0x6e, 0x65,
+	0x6f, 0x66, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x09, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
+	0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x1b, 0x0a, 0x09, 0x6a, 0x73,
+	0x6f, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6a,
+	0x73, 0x6f, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x37, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64,
+	0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73,
+	0x12, 0x27, 0x0a, 0x0f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x18, 0x11, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x33, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x22, 0xb6, 0x02, 0x0a, 0x04, 0x54, 0x79,
+	0x70, 0x65, 0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x44, 0x4f, 0x55, 0x42, 0x4c,
+	0x45, 0x10, 0x01, 0x12, 0x0e, 0x0a, 0x0a, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x46, 0x4c, 0x4f, 0x41,
+	0x54, 0x10, 0x02, 0x12, 0x0e, 0x0a, 0x0a, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x49, 0x4e, 0x54, 0x36,
+	0x34, 0x10, 0x03, 0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x49, 0x4e, 0x54,
+	0x36, 0x34, 0x10, 0x04, 0x12, 0x0e, 0x0a, 0x0a, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x49, 0x4e, 0x54,
+	0x33, 0x32, 0x10, 0x05, 0x12, 0x10, 0x0a, 0x0c, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x46, 0x49, 0x58,
+	0x45, 0x44, 0x36, 0x34, 0x10, 0x06, 0x12, 0x10, 0x0a, 0x0c, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x46,
+	0x49, 0x58, 0x45, 0x44, 0x33, 0x32, 0x10, 0x07, 0x12, 0x0d, 0x0a, 0x09, 0x54, 0x59, 0x50, 0x45,
+	0x5f, 0x42, 0x4f, 0x4f, 0x4c, 0x10, 0x08, 0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, 0x45, 0x5f,
+	0x53, 0x54, 0x52, 0x49, 0x4e, 0x47, 0x10, 0x09, 0x12, 0x0e, 0x0a, 0x0a, 0x54, 0x59, 0x50, 0x45,
+	0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x10, 0x0a, 0x12, 0x10, 0x0a, 0x0c, 0x54, 0x59, 0x50, 0x45,
+	0x5f, 0x4d, 0x45, 0x53, 0x53, 0x41, 0x47, 0x45, 0x10, 0x0b, 0x12, 0x0e, 0x0a, 0x0a, 0x54, 0x59,
+	0x50, 0x45, 0x5f, 0x42, 0x59, 0x54, 0x45, 0x53, 0x10, 0x0c, 0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59,
+	0x50, 0x45, 0x5f, 0x55, 0x49, 0x4e, 0x54, 0x33, 0x32, 0x10, 0x0d, 0x12, 0x0d, 0x0a, 0x09, 0x54,
+	0x59, 0x50, 0x45, 0x5f, 0x45, 0x4e, 0x55, 0x4d, 0x10, 0x0e, 0x12, 0x11, 0x0a, 0x0d, 0x54, 0x59,
+	0x50, 0x45, 0x5f, 0x53, 0x46, 0x49, 0x58, 0x45, 0x44, 0x33, 0x32, 0x10, 0x0f, 0x12, 0x11, 0x0a,
+	0x0d, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, 0x46, 0x49, 0x58, 0x45, 0x44, 0x36, 0x34, 0x10, 0x10,
+	0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, 0x49, 0x4e, 0x54, 0x33, 0x32, 0x10,
+	0x11, 0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, 0x49, 0x4e, 0x54, 0x36, 0x34,
+	0x10, 0x12, 0x22, 0x43, 0x0a, 0x05, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x12, 0x12, 0x0a, 0x0e, 0x4c,
+	0x41, 0x42, 0x45, 0x4c, 0x5f, 0x4f, 0x50, 0x54, 0x49, 0x4f, 0x4e, 0x41, 0x4c, 0x10, 0x01, 0x12,
+	0x12, 0x0a, 0x0e, 0x4c, 0x41, 0x42, 0x45, 0x4c, 0x5f, 0x52, 0x45, 0x51, 0x55, 0x49, 0x52, 0x45,
+	0x44, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x4c, 0x41, 0x42, 0x45, 0x4c, 0x5f, 0x52, 0x45, 0x50,
+	0x45, 0x41, 0x54, 0x45, 0x44, 0x10, 0x03, 0x22, 0x63, 0x0a, 0x14, 0x4f, 0x6e, 0x65, 0x6f, 0x66,
+	0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12,
+	0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e,
+	0x61, 0x6d, 0x65, 0x12, 0x37, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4f, 0x6e, 0x65, 0x6f, 0x66, 0x4f, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0xe3, 0x02, 0x0a,
+	0x13, 0x45, 0x6e, 0x75, 0x6d, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50,
+	0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x3f, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75,
+	0x65, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x56, 0x61,
+	0x6c, 0x75, 0x65, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f,
+	0x74, 0x6f, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x36, 0x0a, 0x07, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75,
+	0x6d, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+	0x73, 0x12, 0x5d, 0x0a, 0x0e, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x5f, 0x72, 0x61,
+	0x6e, 0x67, 0x65, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d,
+	0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x45, 0x6e, 0x75, 0x6d, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x52, 0x61, 0x6e, 0x67,
+	0x65, 0x52, 0x0d, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x52, 0x61, 0x6e, 0x67, 0x65,
+	0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x5f, 0x6e, 0x61, 0x6d,
+	0x65, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0c, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65,
+	0x64, 0x4e, 0x61, 0x6d, 0x65, 0x1a, 0x3b, 0x0a, 0x11, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x65, 0x73,
+	0x65, 0x72, 0x76, 0x65, 0x64, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x74,
+	0x61, 0x72, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74,
+	0x12, 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x65,
+	0x6e, 0x64, 0x22, 0x83, 0x01, 0x0a, 0x18, 0x45, 0x6e, 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x75, 0x65,
+	0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12,
+	0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e,
+	0x61, 0x6d, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x05, 0x52, 0x06, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x3b, 0x0a, 0x07, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45,
+	0x6e, 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52,
+	0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0xa7, 0x01, 0x0a, 0x16, 0x53, 0x65, 0x72,
+	0x76, 0x69, 0x63, 0x65, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72,
+	0x6f, 0x74, 0x6f, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x3e, 0x0a, 0x06, 0x6d, 0x65, 0x74, 0x68, 0x6f,
+	0x64, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64,
+	0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52,
+	0x06, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x12, 0x39, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x65, 0x72, 0x76, 0x69,
+	0x63, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x73, 0x22, 0x89, 0x02, 0x0a, 0x15, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x44, 0x65, 0x73,
+	0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x0a, 0x04,
+	0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65,
+	0x12, 0x1d, 0x0a, 0x0a, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12,
+	0x1f, 0x0a, 0x0b, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x54, 0x79, 0x70, 0x65,
+	0x12, 0x38, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x1e, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+	0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x30, 0x0a, 0x10, 0x63, 0x6c,
+	0x69, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x69, 0x6e, 0x67, 0x18, 0x05,
+	0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x0f, 0x63, 0x6c, 0x69,
+	0x65, 0x6e, 0x74, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x69, 0x6e, 0x67, 0x12, 0x30, 0x0a, 0x10,
+	0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x69, 0x6e, 0x67,
+	0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x0f, 0x73,
+	0x65, 0x72, 0x76, 0x65, 0x72, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x69, 0x6e, 0x67, 0x22, 0x91,
+	0x09, 0x0a, 0x0b, 0x46, 0x69, 0x6c, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x21,
+	0x0a, 0x0c, 0x6a, 0x61, 0x76, 0x61, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6a, 0x61, 0x76, 0x61, 0x50, 0x61, 0x63, 0x6b, 0x61, 0x67,
+	0x65, 0x12, 0x30, 0x0a, 0x14, 0x6a, 0x61, 0x76, 0x61, 0x5f, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x5f,
+	0x63, 0x6c, 0x61, 0x73, 0x73, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x12, 0x6a, 0x61, 0x76, 0x61, 0x4f, 0x75, 0x74, 0x65, 0x72, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x6e,
+	0x61, 0x6d, 0x65, 0x12, 0x35, 0x0a, 0x13, 0x6a, 0x61, 0x76, 0x61, 0x5f, 0x6d, 0x75, 0x6c, 0x74,
+	0x69, 0x70, 0x6c, 0x65, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08,
+	0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x11, 0x6a, 0x61, 0x76, 0x61, 0x4d, 0x75, 0x6c,
+	0x74, 0x69, 0x70, 0x6c, 0x65, 0x46, 0x69, 0x6c, 0x65, 0x73, 0x12, 0x44, 0x0a, 0x1d, 0x6a, 0x61,
+	0x76, 0x61, 0x5f, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x5f, 0x65, 0x71, 0x75, 0x61,
+	0x6c, 0x73, 0x5f, 0x61, 0x6e, 0x64, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x14, 0x20, 0x01, 0x28,
+	0x08, 0x42, 0x02, 0x18, 0x01, 0x52, 0x19, 0x6a, 0x61, 0x76, 0x61, 0x47, 0x65, 0x6e, 0x65, 0x72,
+	0x61, 0x74, 0x65, 0x45, 0x71, 0x75, 0x61, 0x6c, 0x73, 0x41, 0x6e, 0x64, 0x48, 0x61, 0x73, 0x68,
+	0x12, 0x3a, 0x0a, 0x16, 0x6a, 0x61, 0x76, 0x61, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f,
+	0x63, 0x68, 0x65, 0x63, 0x6b, 0x5f, 0x75, 0x74, 0x66, 0x38, 0x18, 0x1b, 0x20, 0x01, 0x28, 0x08,
+	0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x13, 0x6a, 0x61, 0x76, 0x61, 0x53, 0x74, 0x72,
+	0x69, 0x6e, 0x67, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x55, 0x74, 0x66, 0x38, 0x12, 0x53, 0x0a, 0x0c,
+	0x6f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x18, 0x09, 0x20, 0x01,
+	0x28, 0x0e, 0x32, 0x29, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x6c, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73,
+	0x2e, 0x4f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x4d, 0x6f, 0x64, 0x65, 0x3a, 0x05, 0x53,
+	0x50, 0x45, 0x45, 0x44, 0x52, 0x0b, 0x6f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x46, 0x6f,
+	0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x67, 0x6f, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x18,
+	0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x67, 0x6f, 0x50, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65,
+	0x12, 0x35, 0x0a, 0x13, 0x63, 0x63, 0x5f, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x5f, 0x73,
+	0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x18, 0x10, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66,
+	0x61, 0x6c, 0x73, 0x65, 0x52, 0x11, 0x63, 0x63, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x53,
+	0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x12, 0x39, 0x0a, 0x15, 0x6a, 0x61, 0x76, 0x61, 0x5f,
+	0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73,
+	0x18, 0x11, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x13, 0x6a,
+	0x61, 0x76, 0x61, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63,
+	0x65, 0x73, 0x12, 0x35, 0x0a, 0x13, 0x70, 0x79, 0x5f, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63,
+	0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x18, 0x12, 0x20, 0x01, 0x28, 0x08, 0x3a,
+	0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x11, 0x70, 0x79, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69,
+	0x63, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x12, 0x37, 0x0a, 0x14, 0x70, 0x68, 0x70,
+	0x5f, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65,
+	0x73, 0x18, 0x2a, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x12,
+	0x70, 0x68, 0x70, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63,
+	0x65, 0x73, 0x12, 0x25, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64,
+	0x18, 0x17, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x0a, 0x64,
+	0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x12, 0x2e, 0x0a, 0x10, 0x63, 0x63, 0x5f,
+	0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x61, 0x72, 0x65, 0x6e, 0x61, 0x73, 0x18, 0x1f, 0x20,
+	0x01, 0x28, 0x08, 0x3a, 0x04, 0x74, 0x72, 0x75, 0x65, 0x52, 0x0e, 0x63, 0x63, 0x45, 0x6e, 0x61,
+	0x62, 0x6c, 0x65, 0x41, 0x72, 0x65, 0x6e, 0x61, 0x73, 0x12, 0x2a, 0x0a, 0x11, 0x6f, 0x62, 0x6a,
+	0x63, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x5f, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x18, 0x24,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x6f, 0x62, 0x6a, 0x63, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x50,
+	0x72, 0x65, 0x66, 0x69, 0x78, 0x12, 0x29, 0x0a, 0x10, 0x63, 0x73, 0x68, 0x61, 0x72, 0x70, 0x5f,
+	0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x25, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x0f, 0x63, 0x73, 0x68, 0x61, 0x72, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65,
+	0x12, 0x21, 0x0a, 0x0c, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78,
+	0x18, 0x27, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x73, 0x77, 0x69, 0x66, 0x74, 0x50, 0x72, 0x65,
+	0x66, 0x69, 0x78, 0x12, 0x28, 0x0a, 0x10, 0x70, 0x68, 0x70, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73,
+	0x5f, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x18, 0x28, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x70,
+	0x68, 0x70, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x12, 0x23, 0x0a,
+	0x0d, 0x70, 0x68, 0x70, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x29,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x70, 0x68, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61,
+	0x63, 0x65, 0x12, 0x34, 0x0a, 0x16, 0x70, 0x68, 0x70, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61,
+	0x74, 0x61, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x2c, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x14, 0x70, 0x68, 0x70, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x4e,
+	0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x72, 0x75, 0x62, 0x79,
+	0x5f, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x18, 0x2d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b,
+	0x72, 0x75, 0x62, 0x79, 0x50, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x12, 0x58, 0x0a, 0x14, 0x75,
+	0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x6e, 0x69,
+	0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+	0x52, 0x13, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x0a, 0x0c, 0x4f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a,
+	0x65, 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x09, 0x0a, 0x05, 0x53, 0x50, 0x45, 0x45, 0x44, 0x10, 0x01,
+	0x12, 0x0d, 0x0a, 0x09, 0x43, 0x4f, 0x44, 0x45, 0x5f, 0x53, 0x49, 0x5a, 0x45, 0x10, 0x02, 0x12,
+	0x10, 0x0a, 0x0c, 0x4c, 0x49, 0x54, 0x45, 0x5f, 0x52, 0x55, 0x4e, 0x54, 0x49, 0x4d, 0x45, 0x10,
+	0x03, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x4a, 0x04, 0x08, 0x26,
+	0x10, 0x27, 0x22, 0xd1, 0x02, 0x0a, 0x0e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70,
+	0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x3c, 0x0a, 0x17, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x5f, 0x73, 0x65, 0x74, 0x5f, 0x77, 0x69, 0x72, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x14, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x57, 0x69, 0x72, 0x65, 0x46, 0x6f, 0x72,
+	0x6d, 0x61, 0x74, 0x12, 0x4c, 0x0a, 0x1f, 0x6e, 0x6f, 0x5f, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x61,
+	0x72, 0x64, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x63,
+	0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61,
+	0x6c, 0x73, 0x65, 0x52, 0x1c, 0x6e, 0x6f, 0x53, 0x74, 0x61, 0x6e, 0x64, 0x61, 0x72, 0x64, 0x44,
+	0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f,
+	0x72, 0x12, 0x25, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x0a, 0x64, 0x65,
+	0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x6d, 0x61, 0x70, 0x5f,
+	0x65, 0x6e, 0x74, 0x72, 0x79, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x6d, 0x61, 0x70,
+	0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x58, 0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72,
+	0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72,
+	0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x75, 0x6e, 0x69, 0x6e,
+	0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2a,
+	0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x4a, 0x04, 0x08, 0x08, 0x10, 0x09,
+	0x4a, 0x04, 0x08, 0x09, 0x10, 0x0a, 0x22, 0xe2, 0x03, 0x0a, 0x0c, 0x46, 0x69, 0x65, 0x6c, 0x64,
+	0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x41, 0x0a, 0x05, 0x63, 0x74, 0x79, 0x70, 0x65,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x23, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f, 0x70,
+	0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x43, 0x54, 0x79, 0x70, 0x65, 0x3a, 0x06, 0x53, 0x54, 0x52,
+	0x49, 0x4e, 0x47, 0x52, 0x05, 0x63, 0x74, 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x70, 0x61,
+	0x63, 0x6b, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x70, 0x61, 0x63, 0x6b,
+	0x65, 0x64, 0x12, 0x47, 0x0a, 0x06, 0x6a, 0x73, 0x74, 0x79, 0x70, 0x65, 0x18, 0x06, 0x20, 0x01,
+	0x28, 0x0e, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+	0x73, 0x2e, 0x4a, 0x53, 0x54, 0x79, 0x70, 0x65, 0x3a, 0x09, 0x4a, 0x53, 0x5f, 0x4e, 0x4f, 0x52,
+	0x4d, 0x41, 0x4c, 0x52, 0x06, 0x6a, 0x73, 0x74, 0x79, 0x70, 0x65, 0x12, 0x19, 0x0a, 0x04, 0x6c,
+	0x61, 0x7a, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65,
+	0x52, 0x04, 0x6c, 0x61, 0x7a, 0x79, 0x12, 0x25, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63,
+	0x61, 0x74, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73,
+	0x65, 0x52, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x12, 0x19, 0x0a,
+	0x04, 0x77, 0x65, 0x61, 0x6b, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c,
+	0x73, 0x65, 0x52, 0x04, 0x77, 0x65, 0x61, 0x6b, 0x12, 0x58, 0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e,
+	0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+	0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65,
+	0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x75,
+	0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x22, 0x2f, 0x0a, 0x05, 0x43, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0a, 0x0a, 0x06, 0x53,
+	0x54, 0x52, 0x49, 0x4e, 0x47, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x43, 0x4f, 0x52, 0x44, 0x10,
+	0x01, 0x12, 0x10, 0x0a, 0x0c, 0x53, 0x54, 0x52, 0x49, 0x4e, 0x47, 0x5f, 0x50, 0x49, 0x45, 0x43,
+	0x45, 0x10, 0x02, 0x22, 0x35, 0x0a, 0x06, 0x4a, 0x53, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0d, 0x0a,
+	0x09, 0x4a, 0x53, 0x5f, 0x4e, 0x4f, 0x52, 0x4d, 0x41, 0x4c, 0x10, 0x00, 0x12, 0x0d, 0x0a, 0x09,
+	0x4a, 0x53, 0x5f, 0x53, 0x54, 0x52, 0x49, 0x4e, 0x47, 0x10, 0x01, 0x12, 0x0d, 0x0a, 0x09, 0x4a,
+	0x53, 0x5f, 0x4e, 0x55, 0x4d, 0x42, 0x45, 0x52, 0x10, 0x02, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10,
+	0x80, 0x80, 0x80, 0x80, 0x02, 0x4a, 0x04, 0x08, 0x04, 0x10, 0x05, 0x22, 0x73, 0x0a, 0x0c, 0x4f,
+	0x6e, 0x65, 0x6f, 0x66, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x58, 0x0a, 0x14, 0x75,
+	0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x6e, 0x69,
+	0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+	0x52, 0x13, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02,
+	0x22, 0xc0, 0x01, 0x0a, 0x0b, 0x45, 0x6e, 0x75, 0x6d, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73,
+	0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x41, 0x6c, 0x69, 0x61,
+	0x73, 0x12, 0x25, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x0a, 0x64, 0x65,
+	0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x12, 0x58, 0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e,
+	0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+	0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65,
+	0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x75,
+	0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x4a, 0x04, 0x08,
+	0x05, 0x10, 0x06, 0x22, 0x9e, 0x01, 0x0a, 0x10, 0x45, 0x6e, 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x75,
+	0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x25, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x72,
+	0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61,
+	0x6c, 0x73, 0x65, 0x52, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x12,
+	0x58, 0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64,
+	0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
+	0x2e, 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70,
+	0x74, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65,
+	0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80,
+	0x80, 0x80, 0x80, 0x02, 0x22, 0x9c, 0x01, 0x0a, 0x0e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65,
+	0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x25, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65,
+	0x63, 0x61, 0x74, 0x65, 0x64, 0x18, 0x21, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c,
+	0x73, 0x65, 0x52, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x12, 0x58,
+	0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f,
+	0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
+	0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x52, 0x13, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74,
+	0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80,
+	0x80, 0x80, 0x02, 0x22, 0xe0, 0x02, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x4f, 0x70,
+	0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x25, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61,
+	0x74, 0x65, 0x64, 0x18, 0x21, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65,
+	0x52, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x12, 0x71, 0x0a, 0x11,
+	0x69, 0x64, 0x65, 0x6d, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x63, 0x79, 0x5f, 0x6c, 0x65, 0x76, 0x65,
+	0x6c, 0x18, 0x22, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64,
+	0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x49, 0x64, 0x65, 0x6d, 0x70, 0x6f, 0x74, 0x65,
+	0x6e, 0x63, 0x79, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x3a, 0x13, 0x49, 0x44, 0x45, 0x4d, 0x50, 0x4f,
+	0x54, 0x45, 0x4e, 0x43, 0x59, 0x5f, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x52, 0x10, 0x69,
+	0x64, 0x65, 0x6d, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x63, 0x79, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12,
+	0x58, 0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64,
+	0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
+	0x2e, 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70,
+	0x74, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65,
+	0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x50, 0x0a, 0x10, 0x49, 0x64, 0x65,
+	0x6d, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x63, 0x79, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x17, 0x0a,
+	0x13, 0x49, 0x44, 0x45, 0x4d, 0x50, 0x4f, 0x54, 0x45, 0x4e, 0x43, 0x59, 0x5f, 0x55, 0x4e, 0x4b,
+	0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x4e, 0x4f, 0x5f, 0x53, 0x49, 0x44,
+	0x45, 0x5f, 0x45, 0x46, 0x46, 0x45, 0x43, 0x54, 0x53, 0x10, 0x01, 0x12, 0x0e, 0x0a, 0x0a, 0x49,
+	0x44, 0x45, 0x4d, 0x50, 0x4f, 0x54, 0x45, 0x4e, 0x54, 0x10, 0x02, 0x2a, 0x09, 0x08, 0xe8, 0x07,
+	0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x22, 0x9a, 0x03, 0x0a, 0x13, 0x55, 0x6e, 0x69, 0x6e, 0x74,
+	0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x41,
+	0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55,
+	0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x2e, 0x4e, 0x61, 0x6d, 0x65, 0x50, 0x61, 0x72, 0x74, 0x52, 0x04, 0x6e, 0x61, 0x6d,
+	0x65, 0x12, 0x29, 0x0a, 0x10, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x5f,
+	0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x69, 0x64, 0x65,
+	0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x2c, 0x0a, 0x12,
+	0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x69, 0x6e, 0x74, 0x5f, 0x76, 0x61, 0x6c,
+	0x75, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x10, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69,
+	0x76, 0x65, 0x49, 0x6e, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x2c, 0x0a, 0x12, 0x6e, 0x65,
+	0x67, 0x61, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x69, 0x6e, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65,
+	0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x6e, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65,
+	0x49, 0x6e, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x64, 0x6f, 0x75, 0x62,
+	0x6c, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0b,
+	0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x73,
+	0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28,
+	0x0c, 0x52, 0x0b, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x27,
+	0x0a, 0x0f, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x75,
+	0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61,
+	0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x1a, 0x4a, 0x0a, 0x08, 0x4e, 0x61, 0x6d, 0x65, 0x50,
+	0x61, 0x72, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x5f, 0x70, 0x61, 0x72, 0x74,
+	0x18, 0x01, 0x20, 0x02, 0x28, 0x09, 0x52, 0x08, 0x6e, 0x61, 0x6d, 0x65, 0x50, 0x61, 0x72, 0x74,
+	0x12, 0x21, 0x0a, 0x0c, 0x69, 0x73, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
+	0x18, 0x02, 0x20, 0x02, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x73, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73,
+	0x69, 0x6f, 0x6e, 0x22, 0xa7, 0x02, 0x0a, 0x0e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x6f,
+	0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x44, 0x0a, 0x08, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x6f, 0x75, 0x72, 0x63,
+	0x65, 0x43, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x52, 0x08, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0xce, 0x01, 0x0a,
+	0x08, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x04, 0x70, 0x61, 0x74,
+	0x68, 0x18, 0x01, 0x20, 0x03, 0x28, 0x05, 0x42, 0x02, 0x10, 0x01, 0x52, 0x04, 0x70, 0x61, 0x74,
+	0x68, 0x12, 0x16, 0x0a, 0x04, 0x73, 0x70, 0x61, 0x6e, 0x18, 0x02, 0x20, 0x03, 0x28, 0x05, 0x42,
+	0x02, 0x10, 0x01, 0x52, 0x04, 0x73, 0x70, 0x61, 0x6e, 0x12, 0x29, 0x0a, 0x10, 0x6c, 0x65, 0x61,
+	0x64, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x03, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x0f, 0x6c, 0x65, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6d, 0x6d,
+	0x65, 0x6e, 0x74, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x74, 0x72, 0x61, 0x69, 0x6c, 0x69, 0x6e, 0x67,
+	0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x10, 0x74, 0x72, 0x61, 0x69, 0x6c, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74,
+	0x73, 0x12, 0x3a, 0x0a, 0x19, 0x6c, 0x65, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x64, 0x65, 0x74,
+	0x61, 0x63, 0x68, 0x65, 0x64, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x06,
+	0x20, 0x03, 0x28, 0x09, 0x52, 0x17, 0x6c, 0x65, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x74,
+	0x61, 0x63, 0x68, 0x65, 0x64, 0x43, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x22, 0xd1, 0x01,
+	0x0a, 0x11, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x43, 0x6f, 0x64, 0x65, 0x49,
+	0x6e, 0x66, 0x6f, 0x12, 0x4d, 0x0a, 0x0a, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61,
+	0x74, 0x65, 0x64, 0x43, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x41, 0x6e, 0x6e, 0x6f,
+	0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x1a, 0x6d, 0x0a, 0x0a, 0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x12, 0x16, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x03, 0x28, 0x05, 0x42, 0x02,
+	0x10, 0x01, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x6f, 0x75, 0x72,
+	0x63, 0x65, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x73,
+	0x6f, 0x75, 0x72, 0x63, 0x65, 0x46, 0x69, 0x6c, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x62, 0x65, 0x67,
+	0x69, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x62, 0x65, 0x67, 0x69, 0x6e, 0x12,
+	0x10, 0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x65, 0x6e,
+	0x64, 0x42, 0x8f, 0x01, 0x0a, 0x13, 0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x42, 0x10, 0x44, 0x65, 0x73, 0x63, 0x72,
+	0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x48, 0x01, 0x5a, 0x3e, 0x67,
+	0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67,
+	0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63,
+	0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74,
+	0x6f, 0x72, 0x3b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0xf8, 0x01, 0x01,
+	0xa2, 0x02, 0x03, 0x47, 0x50, 0x42, 0xaa, 0x02, 0x1a, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
+	0x50, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x52, 0x65, 0x66, 0x6c, 0x65, 0x63, 0x74,
+	0x69, 0x6f, 0x6e,
+}
+
+var (
+	file_google_protobuf_descriptor_proto_rawDescOnce sync.Once
+	file_google_protobuf_descriptor_proto_rawDescData = file_google_protobuf_descriptor_proto_rawDesc
+)
+
+func file_google_protobuf_descriptor_proto_rawDescGZIP() []byte {
+	file_google_protobuf_descriptor_proto_rawDescOnce.Do(func() {
+		file_google_protobuf_descriptor_proto_rawDescData = protoimpl.X.CompressGZIP(file_google_protobuf_descriptor_proto_rawDescData)
+	})
+	return file_google_protobuf_descriptor_proto_rawDescData
+}
+
+var file_google_protobuf_descriptor_proto_enumTypes = make([]protoimpl.EnumInfo, 6)
+var file_google_protobuf_descriptor_proto_msgTypes = make([]protoimpl.MessageInfo, 27)
+var file_google_protobuf_descriptor_proto_goTypes = []interface{}{
+	(FieldDescriptorProto_Type)(0),                // 0: google.protobuf.FieldDescriptorProto.Type
+	(FieldDescriptorProto_Label)(0),               // 1: google.protobuf.FieldDescriptorProto.Label
+	(FileOptions_OptimizeMode)(0),                 // 2: google.protobuf.FileOptions.OptimizeMode
+	(FieldOptions_CType)(0),                       // 3: google.protobuf.FieldOptions.CType
+	(FieldOptions_JSType)(0),                      // 4: google.protobuf.FieldOptions.JSType
+	(MethodOptions_IdempotencyLevel)(0),           // 5: google.protobuf.MethodOptions.IdempotencyLevel
+	(*FileDescriptorSet)(nil),                     // 6: google.protobuf.FileDescriptorSet
+	(*FileDescriptorProto)(nil),                   // 7: google.protobuf.FileDescriptorProto
+	(*DescriptorProto)(nil),                       // 8: google.protobuf.DescriptorProto
+	(*ExtensionRangeOptions)(nil),                 // 9: google.protobuf.ExtensionRangeOptions
+	(*FieldDescriptorProto)(nil),                  // 10: google.protobuf.FieldDescriptorProto
+	(*OneofDescriptorProto)(nil),                  // 11: google.protobuf.OneofDescriptorProto
+	(*EnumDescriptorProto)(nil),                   // 12: google.protobuf.EnumDescriptorProto
+	(*EnumValueDescriptorProto)(nil),              // 13: google.protobuf.EnumValueDescriptorProto
+	(*ServiceDescriptorProto)(nil),                // 14: google.protobuf.ServiceDescriptorProto
+	(*MethodDescriptorProto)(nil),                 // 15: google.protobuf.MethodDescriptorProto
+	(*FileOptions)(nil),                           // 16: google.protobuf.FileOptions
+	(*MessageOptions)(nil),                        // 17: google.protobuf.MessageOptions
+	(*FieldOptions)(nil),                          // 18: google.protobuf.FieldOptions
+	(*OneofOptions)(nil),                          // 19: google.protobuf.OneofOptions
+	(*EnumOptions)(nil),                           // 20: google.protobuf.EnumOptions
+	(*EnumValueOptions)(nil),                      // 21: google.protobuf.EnumValueOptions
+	(*ServiceOptions)(nil),                        // 22: google.protobuf.ServiceOptions
+	(*MethodOptions)(nil),                         // 23: google.protobuf.MethodOptions
+	(*UninterpretedOption)(nil),                   // 24: google.protobuf.UninterpretedOption
+	(*SourceCodeInfo)(nil),                        // 25: google.protobuf.SourceCodeInfo
+	(*GeneratedCodeInfo)(nil),                     // 26: google.protobuf.GeneratedCodeInfo
+	(*DescriptorProto_ExtensionRange)(nil),        // 27: google.protobuf.DescriptorProto.ExtensionRange
+	(*DescriptorProto_ReservedRange)(nil),         // 28: google.protobuf.DescriptorProto.ReservedRange
+	(*EnumDescriptorProto_EnumReservedRange)(nil), // 29: google.protobuf.EnumDescriptorProto.EnumReservedRange
+	(*UninterpretedOption_NamePart)(nil),          // 30: google.protobuf.UninterpretedOption.NamePart
+	(*SourceCodeInfo_Location)(nil),               // 31: google.protobuf.SourceCodeInfo.Location
+	(*GeneratedCodeInfo_Annotation)(nil),          // 32: google.protobuf.GeneratedCodeInfo.Annotation
+}
+var file_google_protobuf_descriptor_proto_depIdxs = []int32{
+	7,  // 0: google.protobuf.FileDescriptorSet.file:type_name -> google.protobuf.FileDescriptorProto
+	8,  // 1: google.protobuf.FileDescriptorProto.message_type:type_name -> google.protobuf.DescriptorProto
+	12, // 2: google.protobuf.FileDescriptorProto.enum_type:type_name -> google.protobuf.EnumDescriptorProto
+	14, // 3: google.protobuf.FileDescriptorProto.service:type_name -> google.protobuf.ServiceDescriptorProto
+	10, // 4: google.protobuf.FileDescriptorProto.extension:type_name -> google.protobuf.FieldDescriptorProto
+	16, // 5: google.protobuf.FileDescriptorProto.options:type_name -> google.protobuf.FileOptions
+	25, // 6: google.protobuf.FileDescriptorProto.source_code_info:type_name -> google.protobuf.SourceCodeInfo
+	10, // 7: google.protobuf.DescriptorProto.field:type_name -> google.protobuf.FieldDescriptorProto
+	10, // 8: google.protobuf.DescriptorProto.extension:type_name -> google.protobuf.FieldDescriptorProto
+	8,  // 9: google.protobuf.DescriptorProto.nested_type:type_name -> google.protobuf.DescriptorProto
+	12, // 10: google.protobuf.DescriptorProto.enum_type:type_name -> google.protobuf.EnumDescriptorProto
+	27, // 11: google.protobuf.DescriptorProto.extension_range:type_name -> google.protobuf.DescriptorProto.ExtensionRange
+	11, // 12: google.protobuf.DescriptorProto.oneof_decl:type_name -> google.protobuf.OneofDescriptorProto
+	17, // 13: google.protobuf.DescriptorProto.options:type_name -> google.protobuf.MessageOptions
+	28, // 14: google.protobuf.DescriptorProto.reserved_range:type_name -> google.protobuf.DescriptorProto.ReservedRange
+	24, // 15: google.protobuf.ExtensionRangeOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
+	1,  // 16: google.protobuf.FieldDescriptorProto.label:type_name -> google.protobuf.FieldDescriptorProto.Label
+	0,  // 17: google.protobuf.FieldDescriptorProto.type:type_name -> google.protobuf.FieldDescriptorProto.Type
+	18, // 18: google.protobuf.FieldDescriptorProto.options:type_name -> google.protobuf.FieldOptions
+	19, // 19: google.protobuf.OneofDescriptorProto.options:type_name -> google.protobuf.OneofOptions
+	13, // 20: google.protobuf.EnumDescriptorProto.value:type_name -> google.protobuf.EnumValueDescriptorProto
+	20, // 21: google.protobuf.EnumDescriptorProto.options:type_name -> google.protobuf.EnumOptions
+	29, // 22: google.protobuf.EnumDescriptorProto.reserved_range:type_name -> google.protobuf.EnumDescriptorProto.EnumReservedRange
+	21, // 23: google.protobuf.EnumValueDescriptorProto.options:type_name -> google.protobuf.EnumValueOptions
+	15, // 24: google.protobuf.ServiceDescriptorProto.method:type_name -> google.protobuf.MethodDescriptorProto
+	22, // 25: google.protobuf.ServiceDescriptorProto.options:type_name -> google.protobuf.ServiceOptions
+	23, // 26: google.protobuf.MethodDescriptorProto.options:type_name -> google.protobuf.MethodOptions
+	2,  // 27: google.protobuf.FileOptions.optimize_for:type_name -> google.protobuf.FileOptions.OptimizeMode
+	24, // 28: google.protobuf.FileOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
+	24, // 29: google.protobuf.MessageOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
+	3,  // 30: google.protobuf.FieldOptions.ctype:type_name -> google.protobuf.FieldOptions.CType
+	4,  // 31: google.protobuf.FieldOptions.jstype:type_name -> google.protobuf.FieldOptions.JSType
+	24, // 32: google.protobuf.FieldOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
+	24, // 33: google.protobuf.OneofOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
+	24, // 34: google.protobuf.EnumOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
+	24, // 35: google.protobuf.EnumValueOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
+	24, // 36: google.protobuf.ServiceOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
+	5,  // 37: google.protobuf.MethodOptions.idempotency_level:type_name -> google.protobuf.MethodOptions.IdempotencyLevel
+	24, // 38: google.protobuf.MethodOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
+	30, // 39: google.protobuf.UninterpretedOption.name:type_name -> google.protobuf.UninterpretedOption.NamePart
+	31, // 40: google.protobuf.SourceCodeInfo.location:type_name -> google.protobuf.SourceCodeInfo.Location
+	32, // 41: google.protobuf.GeneratedCodeInfo.annotation:type_name -> google.protobuf.GeneratedCodeInfo.Annotation
+	9,  // 42: google.protobuf.DescriptorProto.ExtensionRange.options:type_name -> google.protobuf.ExtensionRangeOptions
+	43, // [43:43] is the sub-list for method output_type
+	43, // [43:43] is the sub-list for method input_type
+	43, // [43:43] is the sub-list for extension type_name
+	43, // [43:43] is the sub-list for extension extendee
+	0,  // [0:43] is the sub-list for field type_name
+}
+
+func init() { file_google_protobuf_descriptor_proto_init() }
+func file_google_protobuf_descriptor_proto_init() {
+	if File_google_protobuf_descriptor_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_google_protobuf_descriptor_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*FileDescriptorSet); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_descriptor_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*FileDescriptorProto); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_descriptor_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*DescriptorProto); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_descriptor_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ExtensionRangeOptions); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_descriptor_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*FieldDescriptorProto); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_descriptor_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*OneofDescriptorProto); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_descriptor_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*EnumDescriptorProto); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_descriptor_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*EnumValueDescriptorProto); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_descriptor_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ServiceDescriptorProto); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_descriptor_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MethodDescriptorProto); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_descriptor_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*FileOptions); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_descriptor_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MessageOptions); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_descriptor_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*FieldOptions); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_descriptor_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*OneofOptions); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_descriptor_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*EnumOptions); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_descriptor_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*EnumValueOptions); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_descriptor_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ServiceOptions); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_descriptor_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MethodOptions); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			case 3:
+				return &v.extensionFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_descriptor_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*UninterpretedOption); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_descriptor_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*SourceCodeInfo); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_descriptor_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GeneratedCodeInfo); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_descriptor_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*DescriptorProto_ExtensionRange); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_descriptor_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*DescriptorProto_ReservedRange); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_descriptor_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*EnumDescriptorProto_EnumReservedRange); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_descriptor_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*UninterpretedOption_NamePart); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_descriptor_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*SourceCodeInfo_Location); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_descriptor_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GeneratedCodeInfo_Annotation); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_google_protobuf_descriptor_proto_rawDesc,
+			NumEnums:      6,
+			NumMessages:   27,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_google_protobuf_descriptor_proto_goTypes,
+		DependencyIndexes: file_google_protobuf_descriptor_proto_depIdxs,
+		EnumInfos:         file_google_protobuf_descriptor_proto_enumTypes,
+		MessageInfos:      file_google_protobuf_descriptor_proto_msgTypes,
+	}.Build()
+	File_google_protobuf_descriptor_proto = out.File
+	file_google_protobuf_descriptor_proto_rawDesc = nil
+	file_google_protobuf_descriptor_proto_goTypes = nil
+	file_google_protobuf_descriptor_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/types/dynamicpb/dynamic.go b/vendor/google.golang.org/protobuf/types/dynamicpb/dynamic.go
new file mode 100644
index 000000000..7046ef208
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/types/dynamicpb/dynamic.go
@@ -0,0 +1,673 @@
+// Copyright 2019 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 dynamicpb creates protocol buffer messages using runtime type information.
+package dynamicpb
+
+import (
+	"math"
+
+	"google.golang.org/protobuf/internal/errors"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/runtime/protoiface"
+	"google.golang.org/protobuf/runtime/protoimpl"
+)
+
+// A Message is a dynamically constructed protocol buffer message.
+//
+// Message implements the proto.Message interface, and may be used with all
+// standard proto package functions such as Marshal, Unmarshal, and so forth.
+//
+// Message also implements the protoreflect.Message interface. See the protoreflect
+// package documentation for that interface for how to get and set fields and
+// otherwise interact with the contents of a Message.
+//
+// Reflection API functions which construct messages, such as NewField,
+// return new dynamic messages of the appropriate type. Functions which take
+// messages, such as Set for a message-value field, will accept any message
+// with a compatible type.
+//
+// Operations which modify a Message are not safe for concurrent use.
+type Message struct {
+	typ     messageType
+	known   map[pref.FieldNumber]pref.Value
+	ext     map[pref.FieldNumber]pref.FieldDescriptor
+	unknown pref.RawFields
+}
+
+var (
+	_ pref.Message         = (*Message)(nil)
+	_ pref.ProtoMessage    = (*Message)(nil)
+	_ protoiface.MessageV1 = (*Message)(nil)
+)
+
+// NewMessage creates a new message with the provided descriptor.
+func NewMessage(desc pref.MessageDescriptor) *Message {
+	return &Message{
+		typ:   messageType{desc},
+		known: make(map[pref.FieldNumber]pref.Value),
+		ext:   make(map[pref.FieldNumber]pref.FieldDescriptor),
+	}
+}
+
+// ProtoMessage implements the legacy message interface.
+func (m *Message) ProtoMessage() {}
+
+// ProtoReflect implements the protoreflect.ProtoMessage interface.
+func (m *Message) ProtoReflect() pref.Message {
+	return m
+}
+
+// String returns a string representation of a message.
+func (m *Message) String() string {
+	return protoimpl.X.MessageStringOf(m)
+}
+
+// Reset clears the message to be empty, but preserves the dynamic message type.
+func (m *Message) Reset() {
+	m.known = make(map[pref.FieldNumber]pref.Value)
+	m.ext = make(map[pref.FieldNumber]pref.FieldDescriptor)
+	m.unknown = nil
+}
+
+// Descriptor returns the message descriptor.
+func (m *Message) Descriptor() pref.MessageDescriptor {
+	return m.typ.desc
+}
+
+// Type returns the message type.
+func (m *Message) Type() pref.MessageType {
+	return m.typ
+}
+
+// New returns a newly allocated empty message with the same descriptor.
+// See protoreflect.Message for details.
+func (m *Message) New() pref.Message {
+	return m.Type().New()
+}
+
+// Interface returns the message.
+// See protoreflect.Message for details.
+func (m *Message) Interface() pref.ProtoMessage {
+	return m
+}
+
+// ProtoMethods is an internal detail of the protoreflect.Message interface.
+// Users should never call this directly.
+func (m *Message) ProtoMethods() *protoiface.Methods {
+	return nil
+}
+
+// Range visits every populated field in undefined order.
+// See protoreflect.Message for details.
+func (m *Message) Range(f func(pref.FieldDescriptor, pref.Value) bool) {
+	for num, v := range m.known {
+		fd := m.ext[num]
+		if fd == nil {
+			fd = m.Descriptor().Fields().ByNumber(num)
+		}
+		if !isSet(fd, v) {
+			continue
+		}
+		if !f(fd, v) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+// See protoreflect.Message for details.
+func (m *Message) Has(fd pref.FieldDescriptor) bool {
+	m.checkField(fd)
+	if fd.IsExtension() && m.ext[fd.Number()] != fd {
+		return false
+	}
+	v, ok := m.known[fd.Number()]
+	if !ok {
+		return false
+	}
+	return isSet(fd, v)
+}
+
+// Clear clears a field.
+// See protoreflect.Message for details.
+func (m *Message) Clear(fd pref.FieldDescriptor) {
+	m.checkField(fd)
+	num := fd.Number()
+	delete(m.known, num)
+	delete(m.ext, num)
+}
+
+// Get returns the value of a field.
+// See protoreflect.Message for details.
+func (m *Message) Get(fd pref.FieldDescriptor) pref.Value {
+	m.checkField(fd)
+	num := fd.Number()
+	if fd.IsExtension() {
+		if fd != m.ext[num] {
+			return fd.(pref.ExtensionTypeDescriptor).Type().Zero()
+		}
+		return m.known[num]
+	}
+	if v, ok := m.known[num]; ok {
+		switch {
+		case fd.IsMap():
+			if v.Map().Len() > 0 {
+				return v
+			}
+		case fd.IsList():
+			if v.List().Len() > 0 {
+				return v
+			}
+		default:
+			return v
+		}
+	}
+	switch {
+	case fd.IsMap():
+		return pref.ValueOfMap(&dynamicMap{desc: fd})
+	case fd.IsList():
+		return pref.ValueOfList(emptyList{desc: fd})
+	case fd.Message() != nil:
+		return pref.ValueOfMessage(&Message{typ: messageType{fd.Message()}})
+	case fd.Kind() == pref.BytesKind:
+		return pref.ValueOfBytes(append([]byte(nil), fd.Default().Bytes()...))
+	default:
+		return fd.Default()
+	}
+}
+
+// Mutable returns a mutable reference to a repeated, map, or message field.
+// See protoreflect.Message for details.
+func (m *Message) Mutable(fd pref.FieldDescriptor) pref.Value {
+	m.checkField(fd)
+	if !fd.IsMap() && !fd.IsList() && fd.Message() == nil {
+		panic(errors.New("%v: getting mutable reference to non-composite type", fd.FullName()))
+	}
+	if m.known == nil {
+		panic(errors.New("%v: modification of read-only message", fd.FullName()))
+	}
+	num := fd.Number()
+	if fd.IsExtension() {
+		if fd != m.ext[num] {
+			m.ext[num] = fd
+			m.known[num] = fd.(pref.ExtensionTypeDescriptor).Type().New()
+		}
+		return m.known[num]
+	}
+	if v, ok := m.known[num]; ok {
+		return v
+	}
+	m.clearOtherOneofFields(fd)
+	m.known[num] = m.NewField(fd)
+	if fd.IsExtension() {
+		m.ext[num] = fd
+	}
+	return m.known[num]
+}
+
+// Set stores a value in a field.
+// See protoreflect.Message for details.
+func (m *Message) Set(fd pref.FieldDescriptor, v pref.Value) {
+	m.checkField(fd)
+	if m.known == nil {
+		panic(errors.New("%v: modification of read-only message", fd.FullName()))
+	}
+	if fd.IsExtension() {
+		isValid := true
+		switch {
+		case !fd.(pref.ExtensionTypeDescriptor).Type().IsValidValue(v):
+			isValid = false
+		case fd.IsList():
+			isValid = v.List().IsValid()
+		case fd.IsMap():
+			isValid = v.Map().IsValid()
+		case fd.Message() != nil:
+			isValid = v.Message().IsValid()
+		}
+		if !isValid {
+			panic(errors.New("%v: assigning invalid type %T", fd.FullName(), v.Interface()))
+		}
+		m.ext[fd.Number()] = fd
+	} else {
+		typecheck(fd, v)
+	}
+	m.clearOtherOneofFields(fd)
+	m.known[fd.Number()] = v
+}
+
+func (m *Message) clearOtherOneofFields(fd pref.FieldDescriptor) {
+	od := fd.ContainingOneof()
+	if od == nil {
+		return
+	}
+	num := fd.Number()
+	for i := 0; i < od.Fields().Len(); i++ {
+		if n := od.Fields().Get(i).Number(); n != num {
+			delete(m.known, n)
+		}
+	}
+}
+
+// NewField returns a new value for assignable to the field of a given descriptor.
+// See protoreflect.Message for details.
+func (m *Message) NewField(fd pref.FieldDescriptor) pref.Value {
+	m.checkField(fd)
+	switch {
+	case fd.IsExtension():
+		return fd.(pref.ExtensionTypeDescriptor).Type().New()
+	case fd.IsMap():
+		return pref.ValueOfMap(&dynamicMap{
+			desc: fd,
+			mapv: make(map[interface{}]pref.Value),
+		})
+	case fd.IsList():
+		return pref.ValueOfList(&dynamicList{desc: fd})
+	case fd.Message() != nil:
+		return pref.ValueOfMessage(NewMessage(fd.Message()).ProtoReflect())
+	default:
+		return fd.Default()
+	}
+}
+
+// WhichOneof reports which field in a oneof is populated, returning nil if none are populated.
+// See protoreflect.Message for details.
+func (m *Message) WhichOneof(od pref.OneofDescriptor) pref.FieldDescriptor {
+	for i := 0; i < od.Fields().Len(); i++ {
+		fd := od.Fields().Get(i)
+		if m.Has(fd) {
+			return fd
+		}
+	}
+	return nil
+}
+
+// GetUnknown returns the raw unknown fields.
+// See protoreflect.Message for details.
+func (m *Message) GetUnknown() pref.RawFields {
+	return m.unknown
+}
+
+// SetUnknown sets the raw unknown fields.
+// See protoreflect.Message for details.
+func (m *Message) SetUnknown(r pref.RawFields) {
+	if m.known == nil {
+		panic(errors.New("%v: modification of read-only message", m.typ.desc.FullName()))
+	}
+	m.unknown = r
+}
+
+// IsValid reports whether the message is valid.
+// See protoreflect.Message for details.
+func (m *Message) IsValid() bool {
+	return m.known != nil
+}
+
+func (m *Message) checkField(fd pref.FieldDescriptor) {
+	if fd.IsExtension() && fd.ContainingMessage().FullName() == m.Descriptor().FullName() {
+		if _, ok := fd.(pref.ExtensionTypeDescriptor); !ok {
+			panic(errors.New("%v: extension field descriptor does not implement ExtensionTypeDescriptor", fd.FullName()))
+		}
+		return
+	}
+	if fd.Parent() == m.Descriptor() {
+		return
+	}
+	fields := m.Descriptor().Fields()
+	index := fd.Index()
+	if index >= fields.Len() || fields.Get(index) != fd {
+		panic(errors.New("%v: field descriptor does not belong to this message", fd.FullName()))
+	}
+}
+
+type messageType struct {
+	desc pref.MessageDescriptor
+}
+
+// NewMessageType creates a new MessageType with the provided descriptor.
+//
+// MessageTypes created by this package are equal if their descriptors are equal.
+// That is, if md1 == md2, then NewMessageType(md1) == NewMessageType(md2).
+func NewMessageType(desc pref.MessageDescriptor) pref.MessageType {
+	return messageType{desc}
+}
+
+func (mt messageType) New() pref.Message                  { return NewMessage(mt.desc) }
+func (mt messageType) Zero() pref.Message                 { return &Message{typ: messageType{mt.desc}} }
+func (mt messageType) Descriptor() pref.MessageDescriptor { return mt.desc }
+
+type emptyList struct {
+	desc pref.FieldDescriptor
+}
+
+func (x emptyList) Len() int                  { return 0 }
+func (x emptyList) Get(n int) pref.Value      { panic(errors.New("out of range")) }
+func (x emptyList) Set(n int, v pref.Value)   { panic(errors.New("modification of immutable list")) }
+func (x emptyList) Append(v pref.Value)       { panic(errors.New("modification of immutable list")) }
+func (x emptyList) AppendMutable() pref.Value { panic(errors.New("modification of immutable list")) }
+func (x emptyList) Truncate(n int)            { panic(errors.New("modification of immutable list")) }
+func (x emptyList) NewElement() pref.Value    { return newListEntry(x.desc) }
+func (x emptyList) IsValid() bool             { return false }
+
+type dynamicList struct {
+	desc pref.FieldDescriptor
+	list []pref.Value
+}
+
+func (x *dynamicList) Len() int {
+	return len(x.list)
+}
+
+func (x *dynamicList) Get(n int) pref.Value {
+	return x.list[n]
+}
+
+func (x *dynamicList) Set(n int, v pref.Value) {
+	typecheckSingular(x.desc, v)
+	x.list[n] = v
+}
+
+func (x *dynamicList) Append(v pref.Value) {
+	typecheckSingular(x.desc, v)
+	x.list = append(x.list, v)
+}
+
+func (x *dynamicList) AppendMutable() pref.Value {
+	if x.desc.Message() == nil {
+		panic(errors.New("%v: invalid AppendMutable on list with non-message type", x.desc.FullName()))
+	}
+	v := x.NewElement()
+	x.Append(v)
+	return v
+}
+
+func (x *dynamicList) Truncate(n int) {
+	// Zero truncated elements to avoid keeping data live.
+	for i := n; i < len(x.list); i++ {
+		x.list[i] = pref.Value{}
+	}
+	x.list = x.list[:n]
+}
+
+func (x *dynamicList) NewElement() pref.Value {
+	return newListEntry(x.desc)
+}
+
+func (x *dynamicList) IsValid() bool {
+	return true
+}
+
+type dynamicMap struct {
+	desc pref.FieldDescriptor
+	mapv map[interface{}]pref.Value
+}
+
+func (x *dynamicMap) Get(k pref.MapKey) pref.Value { return x.mapv[k.Interface()] }
+func (x *dynamicMap) Set(k pref.MapKey, v pref.Value) {
+	typecheckSingular(x.desc.MapKey(), k.Value())
+	typecheckSingular(x.desc.MapValue(), v)
+	x.mapv[k.Interface()] = v
+}
+func (x *dynamicMap) Has(k pref.MapKey) bool { return x.Get(k).IsValid() }
+func (x *dynamicMap) Clear(k pref.MapKey)    { delete(x.mapv, k.Interface()) }
+func (x *dynamicMap) Mutable(k pref.MapKey) pref.Value {
+	if x.desc.MapValue().Message() == nil {
+		panic(errors.New("%v: invalid Mutable on map with non-message value type", x.desc.FullName()))
+	}
+	v := x.Get(k)
+	if !v.IsValid() {
+		v = x.NewValue()
+		x.Set(k, v)
+	}
+	return v
+}
+func (x *dynamicMap) Len() int { return len(x.mapv) }
+func (x *dynamicMap) NewValue() pref.Value {
+	if md := x.desc.MapValue().Message(); md != nil {
+		return pref.ValueOfMessage(NewMessage(md).ProtoReflect())
+	}
+	return x.desc.MapValue().Default()
+}
+func (x *dynamicMap) IsValid() bool {
+	return x.mapv != nil
+}
+
+func (x *dynamicMap) Range(f func(pref.MapKey, pref.Value) bool) {
+	for k, v := range x.mapv {
+		if !f(pref.ValueOf(k).MapKey(), v) {
+			return
+		}
+	}
+}
+
+func isSet(fd pref.FieldDescriptor, v pref.Value) bool {
+	switch {
+	case fd.IsMap():
+		return v.Map().Len() > 0
+	case fd.IsList():
+		return v.List().Len() > 0
+	case fd.ContainingOneof() != nil:
+		return true
+	case fd.Syntax() == pref.Proto3 && !fd.IsExtension():
+		switch fd.Kind() {
+		case pref.BoolKind:
+			return v.Bool()
+		case pref.EnumKind:
+			return v.Enum() != 0
+		case pref.Int32Kind, pref.Sint32Kind, pref.Int64Kind, pref.Sint64Kind, pref.Sfixed32Kind, pref.Sfixed64Kind:
+			return v.Int() != 0
+		case pref.Uint32Kind, pref.Uint64Kind, pref.Fixed32Kind, pref.Fixed64Kind:
+			return v.Uint() != 0
+		case pref.FloatKind, pref.DoubleKind:
+			return v.Float() != 0 || math.Signbit(v.Float())
+		case pref.StringKind:
+			return v.String() != ""
+		case pref.BytesKind:
+			return len(v.Bytes()) > 0
+		}
+	}
+	return true
+}
+
+func typecheck(fd pref.FieldDescriptor, v pref.Value) {
+	if err := typeIsValid(fd, v); err != nil {
+		panic(err)
+	}
+}
+
+func typeIsValid(fd pref.FieldDescriptor, v pref.Value) error {
+	switch {
+	case !v.IsValid():
+		return errors.New("%v: assigning invalid value", fd.FullName())
+	case fd.IsMap():
+		if mapv, ok := v.Interface().(*dynamicMap); !ok || mapv.desc != fd || !mapv.IsValid() {
+			return errors.New("%v: assigning invalid type %T", fd.FullName(), v.Interface())
+		}
+		return nil
+	case fd.IsList():
+		switch list := v.Interface().(type) {
+		case *dynamicList:
+			if list.desc == fd && list.IsValid() {
+				return nil
+			}
+		case emptyList:
+			if list.desc == fd && list.IsValid() {
+				return nil
+			}
+		}
+		return errors.New("%v: assigning invalid type %T", fd.FullName(), v.Interface())
+	default:
+		return singularTypeIsValid(fd, v)
+	}
+}
+
+func typecheckSingular(fd pref.FieldDescriptor, v pref.Value) {
+	if err := singularTypeIsValid(fd, v); err != nil {
+		panic(err)
+	}
+}
+
+func singularTypeIsValid(fd pref.FieldDescriptor, v pref.Value) error {
+	vi := v.Interface()
+	var ok bool
+	switch fd.Kind() {
+	case pref.BoolKind:
+		_, ok = vi.(bool)
+	case pref.EnumKind:
+		// We could check against the valid set of enum values, but do not.
+		_, ok = vi.(pref.EnumNumber)
+	case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
+		_, ok = vi.(int32)
+	case pref.Uint32Kind, pref.Fixed32Kind:
+		_, ok = vi.(uint32)
+	case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
+		_, ok = vi.(int64)
+	case pref.Uint64Kind, pref.Fixed64Kind:
+		_, ok = vi.(uint64)
+	case pref.FloatKind:
+		_, ok = vi.(float32)
+	case pref.DoubleKind:
+		_, ok = vi.(float64)
+	case pref.StringKind:
+		_, ok = vi.(string)
+	case pref.BytesKind:
+		_, ok = vi.([]byte)
+	case pref.MessageKind, pref.GroupKind:
+		var m pref.Message
+		m, ok = vi.(pref.Message)
+		if ok && m.Descriptor().FullName() != fd.Message().FullName() {
+			return errors.New("%v: assigning invalid message type %v", fd.FullName(), m.Descriptor().FullName())
+		}
+		if dm, ok := vi.(*Message); ok && dm.known == nil {
+			return errors.New("%v: assigning invalid zero-value message", fd.FullName())
+		}
+	}
+	if !ok {
+		return errors.New("%v: assigning invalid type %T", fd.FullName(), v.Interface())
+	}
+	return nil
+}
+
+func newListEntry(fd pref.FieldDescriptor) pref.Value {
+	switch fd.Kind() {
+	case pref.BoolKind:
+		return pref.ValueOfBool(false)
+	case pref.EnumKind:
+		return pref.ValueOfEnum(fd.Enum().Values().Get(0).Number())
+	case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
+		return pref.ValueOfInt32(0)
+	case pref.Uint32Kind, pref.Fixed32Kind:
+		return pref.ValueOfUint32(0)
+	case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
+		return pref.ValueOfInt64(0)
+	case pref.Uint64Kind, pref.Fixed64Kind:
+		return pref.ValueOfUint64(0)
+	case pref.FloatKind:
+		return pref.ValueOfFloat32(0)
+	case pref.DoubleKind:
+		return pref.ValueOfFloat64(0)
+	case pref.StringKind:
+		return pref.ValueOfString("")
+	case pref.BytesKind:
+		return pref.ValueOfBytes(nil)
+	case pref.MessageKind, pref.GroupKind:
+		return pref.ValueOfMessage(NewMessage(fd.Message()).ProtoReflect())
+	}
+	panic(errors.New("%v: unknown kind %v", fd.FullName(), fd.Kind()))
+}
+
+// extensionType is a dynamic protoreflect.ExtensionType.
+type extensionType struct {
+	desc extensionTypeDescriptor
+}
+
+// NewExtensionType creates a new ExtensionType with the provided descriptor.
+//
+// Dynamic ExtensionTypes with the same descriptor compare as equal. That is,
+// if xd1 == xd2, then NewExtensionType(xd1) == NewExtensionType(xd2).
+//
+// The InterfaceOf and ValueOf methods of the extension type are defined as:
+//
+//	func (xt extensionType) ValueOf(iv interface{}) protoreflect.Value {
+//		return protoreflect.ValueOf(iv)
+//	}
+//
+//	func (xt extensionType) InterfaceOf(v protoreflect.Value) interface{} {
+//		return v.Interface()
+//	}
+//
+// The Go type used by the proto.GetExtension and proto.SetExtension functions
+// is determined by these methods, and is therefore equivalent to the Go type
+// used to represent a protoreflect.Value. See the protoreflect.Value
+// documentation for more details.
+func NewExtensionType(desc pref.ExtensionDescriptor) pref.ExtensionType {
+	if xt, ok := desc.(pref.ExtensionTypeDescriptor); ok {
+		desc = xt.Descriptor()
+	}
+	return extensionType{extensionTypeDescriptor{desc}}
+}
+
+func (xt extensionType) New() pref.Value {
+	switch {
+	case xt.desc.IsMap():
+		return pref.ValueOfMap(&dynamicMap{
+			desc: xt.desc,
+			mapv: make(map[interface{}]pref.Value),
+		})
+	case xt.desc.IsList():
+		return pref.ValueOfList(&dynamicList{desc: xt.desc})
+	case xt.desc.Message() != nil:
+		return pref.ValueOfMessage(NewMessage(xt.desc.Message()))
+	default:
+		return xt.desc.Default()
+	}
+}
+
+func (xt extensionType) Zero() pref.Value {
+	switch {
+	case xt.desc.IsMap():
+		return pref.ValueOfMap(&dynamicMap{desc: xt.desc})
+	case xt.desc.Cardinality() == pref.Repeated:
+		return pref.ValueOfList(emptyList{desc: xt.desc})
+	case xt.desc.Message() != nil:
+		return pref.ValueOfMessage(&Message{typ: messageType{xt.desc.Message()}})
+	default:
+		return xt.desc.Default()
+	}
+}
+
+func (xt extensionType) TypeDescriptor() pref.ExtensionTypeDescriptor {
+	return xt.desc
+}
+
+func (xt extensionType) ValueOf(iv interface{}) pref.Value {
+	v := pref.ValueOf(iv)
+	typecheck(xt.desc, v)
+	return v
+}
+
+func (xt extensionType) InterfaceOf(v pref.Value) interface{} {
+	typecheck(xt.desc, v)
+	return v.Interface()
+}
+
+func (xt extensionType) IsValidInterface(iv interface{}) bool {
+	return typeIsValid(xt.desc, pref.ValueOf(iv)) == nil
+}
+
+func (xt extensionType) IsValidValue(v pref.Value) bool {
+	return typeIsValid(xt.desc, v) == nil
+}
+
+type extensionTypeDescriptor struct {
+	pref.ExtensionDescriptor
+}
+
+func (xt extensionTypeDescriptor) Type() pref.ExtensionType {
+	return extensionType{xt}
+}
+
+func (xt extensionTypeDescriptor) Descriptor() pref.ExtensionDescriptor {
+	return xt.ExtensionDescriptor
+}
diff --git a/vendor/google.golang.org/protobuf/types/dynamicpb/dynamic_test.go b/vendor/google.golang.org/protobuf/types/dynamicpb/dynamic_test.go
new file mode 100644
index 000000000..78e93bb85
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/types/dynamicpb/dynamic_test.go
@@ -0,0 +1,64 @@
+// Copyright 2019 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 dynamicpb_test
+
+import (
+	"testing"
+
+	"google.golang.org/protobuf/proto"
+	pref "google.golang.org/protobuf/reflect/protoreflect"
+	preg "google.golang.org/protobuf/reflect/protoregistry"
+	"google.golang.org/protobuf/testing/prototest"
+	"google.golang.org/protobuf/types/dynamicpb"
+
+	testpb "google.golang.org/protobuf/internal/testprotos/test"
+	test3pb "google.golang.org/protobuf/internal/testprotos/test3"
+)
+
+func TestConformance(t *testing.T) {
+	for _, message := range []proto.Message{
+		(*testpb.TestAllTypes)(nil),
+		(*test3pb.TestAllTypes)(nil),
+		(*testpb.TestAllExtensions)(nil),
+	} {
+		mt := dynamicpb.NewMessageType(message.ProtoReflect().Descriptor())
+		prototest.Message{}.Test(t, mt)
+	}
+}
+
+func TestDynamicExtensions(t *testing.T) {
+	for _, message := range []proto.Message{
+		(*testpb.TestAllExtensions)(nil),
+	} {
+		mt := dynamicpb.NewMessageType(message.ProtoReflect().Descriptor())
+		prototest.Message{
+			Resolver: extResolver{},
+		}.Test(t, mt)
+	}
+}
+
+type extResolver struct{}
+
+func (extResolver) FindExtensionByName(field pref.FullName) (pref.ExtensionType, error) {
+	xt, err := preg.GlobalTypes.FindExtensionByName(field)
+	if err != nil {
+		return nil, err
+	}
+	return dynamicpb.NewExtensionType(xt.TypeDescriptor().Descriptor()), nil
+}
+
+func (extResolver) FindExtensionByNumber(message pref.FullName, field pref.FieldNumber) (pref.ExtensionType, error) {
+	xt, err := preg.GlobalTypes.FindExtensionByNumber(message, field)
+	if err != nil {
+		return nil, err
+	}
+	return dynamicpb.NewExtensionType(xt.TypeDescriptor().Descriptor()), nil
+}
+
+func (extResolver) RangeExtensionsByMessage(message pref.FullName, f func(pref.ExtensionType) bool) {
+	preg.GlobalTypes.RangeExtensionsByMessage(message, func(xt pref.ExtensionType) bool {
+		return f(dynamicpb.NewExtensionType(xt.TypeDescriptor().Descriptor()))
+	})
+}
diff --git a/vendor/google.golang.org/protobuf/types/known/anypb/any.pb.go b/vendor/google.golang.org/protobuf/types/known/anypb/any.pb.go
new file mode 100644
index 000000000..5f9498e4e
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/types/known/anypb/any.pb.go
@@ -0,0 +1,287 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google/protobuf/any.proto
+
+package anypb
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+// `Any` contains an arbitrary serialized protocol buffer message along with a
+// URL that describes the type of the serialized message.
+//
+// Protobuf library provides support to pack/unpack Any values in the form
+// of utility functions or additional generated methods of the Any type.
+//
+// Example 1: Pack and unpack a message in C++.
+//
+//     Foo foo = ...;
+//     Any any;
+//     any.PackFrom(foo);
+//     ...
+//     if (any.UnpackTo(&foo)) {
+//       ...
+//     }
+//
+// Example 2: Pack and unpack a message in Java.
+//
+//     Foo foo = ...;
+//     Any any = Any.pack(foo);
+//     ...
+//     if (any.is(Foo.class)) {
+//       foo = any.unpack(Foo.class);
+//     }
+//
+//  Example 3: Pack and unpack a message in Python.
+//
+//     foo = Foo(...)
+//     any = Any()
+//     any.Pack(foo)
+//     ...
+//     if any.Is(Foo.DESCRIPTOR):
+//       any.Unpack(foo)
+//       ...
+//
+//  Example 4: Pack and unpack a message in Go
+//
+//      foo := &pb.Foo{...}
+//      any, err := ptypes.MarshalAny(foo)
+//      ...
+//      foo := &pb.Foo{}
+//      if err := ptypes.UnmarshalAny(any, foo); err != nil {
+//        ...
+//      }
+//
+// The pack methods provided by protobuf library will by default use
+// 'type.googleapis.com/full.type.name' as the type URL and the unpack
+// methods only use the fully qualified type name after the last '/'
+// in the type URL, for example "foo.bar.com/x/y.z" will yield type
+// name "y.z".
+//
+//
+// JSON
+// ====
+// The JSON representation of an `Any` value uses the regular
+// representation of the deserialized, embedded message, with an
+// additional field `@type` which contains the type URL. Example:
+//
+//     package google.profile;
+//     message Person {
+//       string first_name = 1;
+//       string last_name = 2;
+//     }
+//
+//     {
+//       "@type": "type.googleapis.com/google.profile.Person",
+//       "firstName": <string>,
+//       "lastName": <string>
+//     }
+//
+// If the embedded message type is well-known and has a custom JSON
+// representation, that representation will be embedded adding a field
+// `value` which holds the custom JSON in addition to the `@type`
+// field. Example (for message [google.protobuf.Duration][]):
+//
+//     {
+//       "@type": "type.googleapis.com/google.protobuf.Duration",
+//       "value": "1.212s"
+//     }
+//
+type Any struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// A URL/resource name that uniquely identifies the type of the serialized
+	// protocol buffer message. This string must contain at least
+	// one "/" character. The last segment of the URL's path must represent
+	// the fully qualified name of the type (as in
+	// `path/google.protobuf.Duration`). The name should be in a canonical form
+	// (e.g., leading "." is not accepted).
+	//
+	// In practice, teams usually precompile into the binary all types that they
+	// expect it to use in the context of Any. However, for URLs which use the
+	// scheme `http`, `https`, or no scheme, one can optionally set up a type
+	// server that maps type URLs to message definitions as follows:
+	//
+	// * If no scheme is provided, `https` is assumed.
+	// * An HTTP GET on the URL must yield a [google.protobuf.Type][]
+	//   value in binary format, or produce an error.
+	// * Applications are allowed to cache lookup results based on the
+	//   URL, or have them precompiled into a binary to avoid any
+	//   lookup. Therefore, binary compatibility needs to be preserved
+	//   on changes to types. (Use versioned type names to manage
+	//   breaking changes.)
+	//
+	// Note: this functionality is not currently available in the official
+	// protobuf release, and it is not used for type URLs beginning with
+	// type.googleapis.com.
+	//
+	// Schemes other than `http`, `https` (or the empty scheme) might be
+	// used with implementation specific semantics.
+	//
+	TypeUrl string `protobuf:"bytes,1,opt,name=type_url,json=typeUrl,proto3" json:"type_url,omitempty"`
+	// Must be a valid serialized protocol buffer of the above specified type.
+	Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
+}
+
+func (x *Any) Reset() {
+	*x = Any{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_any_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Any) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Any) ProtoMessage() {}
+
+func (x *Any) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_any_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Any.ProtoReflect.Descriptor instead.
+func (*Any) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_any_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Any) GetTypeUrl() string {
+	if x != nil {
+		return x.TypeUrl
+	}
+	return ""
+}
+
+func (x *Any) GetValue() []byte {
+	if x != nil {
+		return x.Value
+	}
+	return nil
+}
+
+var File_google_protobuf_any_proto protoreflect.FileDescriptor
+
+var file_google_protobuf_any_proto_rawDesc = []byte{
+	0x0a, 0x19, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x2f, 0x61, 0x6e, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0f, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x22, 0x36, 0x0a, 0x03,
+	0x41, 0x6e, 0x79, 0x12, 0x19, 0x0a, 0x08, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x75, 0x72, 0x6c, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x74, 0x79, 0x70, 0x65, 0x55, 0x72, 0x6c, 0x12, 0x14,
+	0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x76,
+	0x61, 0x6c, 0x75, 0x65, 0x42, 0x6f, 0x0a, 0x13, 0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x42, 0x08, 0x41, 0x6e, 0x79,
+	0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x25, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e,
+	0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x61, 0x6e, 0x79, 0xa2, 0x02,
+	0x03, 0x47, 0x50, 0x42, 0xaa, 0x02, 0x1e, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x50, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x57, 0x65, 0x6c, 0x6c, 0x4b, 0x6e, 0x6f, 0x77, 0x6e,
+	0x54, 0x79, 0x70, 0x65, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_google_protobuf_any_proto_rawDescOnce sync.Once
+	file_google_protobuf_any_proto_rawDescData = file_google_protobuf_any_proto_rawDesc
+)
+
+func file_google_protobuf_any_proto_rawDescGZIP() []byte {
+	file_google_protobuf_any_proto_rawDescOnce.Do(func() {
+		file_google_protobuf_any_proto_rawDescData = protoimpl.X.CompressGZIP(file_google_protobuf_any_proto_rawDescData)
+	})
+	return file_google_protobuf_any_proto_rawDescData
+}
+
+var file_google_protobuf_any_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_google_protobuf_any_proto_goTypes = []interface{}{
+	(*Any)(nil), // 0: google.protobuf.Any
+}
+var file_google_protobuf_any_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_google_protobuf_any_proto_init() }
+func file_google_protobuf_any_proto_init() {
+	if File_google_protobuf_any_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_google_protobuf_any_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Any); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_google_protobuf_any_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_google_protobuf_any_proto_goTypes,
+		DependencyIndexes: file_google_protobuf_any_proto_depIdxs,
+		MessageInfos:      file_google_protobuf_any_proto_msgTypes,
+	}.Build()
+	File_google_protobuf_any_proto = out.File
+	file_google_protobuf_any_proto_rawDesc = nil
+	file_google_protobuf_any_proto_goTypes = nil
+	file_google_protobuf_any_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/types/known/durationpb/duration.pb.go b/vendor/google.golang.org/protobuf/types/known/durationpb/duration.pb.go
new file mode 100644
index 000000000..3997c604f
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/types/known/durationpb/duration.pb.go
@@ -0,0 +1,249 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google/protobuf/duration.proto
+
+package durationpb
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+// A Duration represents a signed, fixed-length span of time represented
+// as a count of seconds and fractions of seconds at nanosecond
+// resolution. It is independent of any calendar and concepts like "day"
+// or "month". It is related to Timestamp in that the difference between
+// two Timestamp values is a Duration and it can be added or subtracted
+// from a Timestamp. Range is approximately +-10,000 years.
+//
+// # Examples
+//
+// Example 1: Compute Duration from two Timestamps in pseudo code.
+//
+//     Timestamp start = ...;
+//     Timestamp end = ...;
+//     Duration duration = ...;
+//
+//     duration.seconds = end.seconds - start.seconds;
+//     duration.nanos = end.nanos - start.nanos;
+//
+//     if (duration.seconds < 0 && duration.nanos > 0) {
+//       duration.seconds += 1;
+//       duration.nanos -= 1000000000;
+//     } else if (duration.seconds > 0 && duration.nanos < 0) {
+//       duration.seconds -= 1;
+//       duration.nanos += 1000000000;
+//     }
+//
+// Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
+//
+//     Timestamp start = ...;
+//     Duration duration = ...;
+//     Timestamp end = ...;
+//
+//     end.seconds = start.seconds + duration.seconds;
+//     end.nanos = start.nanos + duration.nanos;
+//
+//     if (end.nanos < 0) {
+//       end.seconds -= 1;
+//       end.nanos += 1000000000;
+//     } else if (end.nanos >= 1000000000) {
+//       end.seconds += 1;
+//       end.nanos -= 1000000000;
+//     }
+//
+// Example 3: Compute Duration from datetime.timedelta in Python.
+//
+//     td = datetime.timedelta(days=3, minutes=10)
+//     duration = Duration()
+//     duration.FromTimedelta(td)
+//
+// # JSON Mapping
+//
+// In JSON format, the Duration type is encoded as a string rather than an
+// object, where the string ends in the suffix "s" (indicating seconds) and
+// is preceded by the number of seconds, with nanoseconds expressed as
+// fractional seconds. For example, 3 seconds with 0 nanoseconds should be
+// encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should
+// be expressed in JSON format as "3.000000001s", and 3 seconds and 1
+// microsecond should be expressed in JSON format as "3.000001s".
+//
+//
+type Duration struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// Signed seconds of the span of time. Must be from -315,576,000,000
+	// to +315,576,000,000 inclusive. Note: these bounds are computed from:
+	// 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
+	Seconds int64 `protobuf:"varint,1,opt,name=seconds,proto3" json:"seconds,omitempty"`
+	// Signed fractions of a second at nanosecond resolution of the span
+	// of time. Durations less than one second are represented with a 0
+	// `seconds` field and a positive or negative `nanos` field. For durations
+	// of one second or more, a non-zero value for the `nanos` field must be
+	// of the same sign as the `seconds` field. Must be from -999,999,999
+	// to +999,999,999 inclusive.
+	Nanos int32 `protobuf:"varint,2,opt,name=nanos,proto3" json:"nanos,omitempty"`
+}
+
+func (x *Duration) Reset() {
+	*x = Duration{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_duration_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Duration) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Duration) ProtoMessage() {}
+
+func (x *Duration) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_duration_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Duration.ProtoReflect.Descriptor instead.
+func (*Duration) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_duration_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Duration) GetSeconds() int64 {
+	if x != nil {
+		return x.Seconds
+	}
+	return 0
+}
+
+func (x *Duration) GetNanos() int32 {
+	if x != nil {
+		return x.Nanos
+	}
+	return 0
+}
+
+var File_google_protobuf_duration_proto protoreflect.FileDescriptor
+
+var file_google_protobuf_duration_proto_rawDesc = []byte{
+	0x0a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x12, 0x0f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x22, 0x3a, 0x0a, 0x08, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x18, 0x0a,
+	0x07, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07,
+	0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x6e, 0x61, 0x6e, 0x6f, 0x73,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x6e, 0x61, 0x6e, 0x6f, 0x73, 0x42, 0x7c, 0x0a,
+	0x13, 0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x62, 0x75, 0x66, 0x42, 0x0d, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72,
+	0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x2a, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f,
+	0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x2f, 0x70, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0xf8, 0x01, 0x01, 0xa2, 0x02, 0x03, 0x47, 0x50, 0x42, 0xaa, 0x02, 0x1e, 0x47, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x2e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x57, 0x65, 0x6c,
+	0x6c, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x33,
+}
+
+var (
+	file_google_protobuf_duration_proto_rawDescOnce sync.Once
+	file_google_protobuf_duration_proto_rawDescData = file_google_protobuf_duration_proto_rawDesc
+)
+
+func file_google_protobuf_duration_proto_rawDescGZIP() []byte {
+	file_google_protobuf_duration_proto_rawDescOnce.Do(func() {
+		file_google_protobuf_duration_proto_rawDescData = protoimpl.X.CompressGZIP(file_google_protobuf_duration_proto_rawDescData)
+	})
+	return file_google_protobuf_duration_proto_rawDescData
+}
+
+var file_google_protobuf_duration_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_google_protobuf_duration_proto_goTypes = []interface{}{
+	(*Duration)(nil), // 0: google.protobuf.Duration
+}
+var file_google_protobuf_duration_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_google_protobuf_duration_proto_init() }
+func file_google_protobuf_duration_proto_init() {
+	if File_google_protobuf_duration_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_google_protobuf_duration_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Duration); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_google_protobuf_duration_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_google_protobuf_duration_proto_goTypes,
+		DependencyIndexes: file_google_protobuf_duration_proto_depIdxs,
+		MessageInfos:      file_google_protobuf_duration_proto_msgTypes,
+	}.Build()
+	File_google_protobuf_duration_proto = out.File
+	file_google_protobuf_duration_proto_rawDesc = nil
+	file_google_protobuf_duration_proto_goTypes = nil
+	file_google_protobuf_duration_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/types/known/emptypb/empty.pb.go b/vendor/google.golang.org/protobuf/types/known/emptypb/empty.pb.go
new file mode 100644
index 000000000..32a583df5
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/types/known/emptypb/empty.pb.go
@@ -0,0 +1,168 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google/protobuf/empty.proto
+
+package emptypb
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+// A generic empty message that you can re-use to avoid defining duplicated
+// empty messages in your APIs. A typical example is to use it as the request
+// or the response type of an API method. For instance:
+//
+//     service Foo {
+//       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
+//     }
+//
+// The JSON representation for `Empty` is empty JSON object `{}`.
+type Empty struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Empty) Reset() {
+	*x = Empty{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_empty_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Empty) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Empty) ProtoMessage() {}
+
+func (x *Empty) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_empty_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Empty.ProtoReflect.Descriptor instead.
+func (*Empty) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_empty_proto_rawDescGZIP(), []int{0}
+}
+
+var File_google_protobuf_empty_proto protoreflect.FileDescriptor
+
+var file_google_protobuf_empty_proto_rawDesc = []byte{
+	0x0a, 0x1b, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x2f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0f, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x22, 0x07,
+	0x0a, 0x05, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x42, 0x76, 0x0a, 0x13, 0x63, 0x6f, 0x6d, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x42, 0x0a,
+	0x45, 0x6d, 0x70, 0x74, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x27, 0x67, 0x69,
+	0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f,
+	0x65, 0x6d, 0x70, 0x74, 0x79, 0xf8, 0x01, 0x01, 0xa2, 0x02, 0x03, 0x47, 0x50, 0x42, 0xaa, 0x02,
+	0x1e, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
+	0x2e, 0x57, 0x65, 0x6c, 0x6c, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x73, 0x62,
+	0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_google_protobuf_empty_proto_rawDescOnce sync.Once
+	file_google_protobuf_empty_proto_rawDescData = file_google_protobuf_empty_proto_rawDesc
+)
+
+func file_google_protobuf_empty_proto_rawDescGZIP() []byte {
+	file_google_protobuf_empty_proto_rawDescOnce.Do(func() {
+		file_google_protobuf_empty_proto_rawDescData = protoimpl.X.CompressGZIP(file_google_protobuf_empty_proto_rawDescData)
+	})
+	return file_google_protobuf_empty_proto_rawDescData
+}
+
+var file_google_protobuf_empty_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_google_protobuf_empty_proto_goTypes = []interface{}{
+	(*Empty)(nil), // 0: google.protobuf.Empty
+}
+var file_google_protobuf_empty_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_google_protobuf_empty_proto_init() }
+func file_google_protobuf_empty_proto_init() {
+	if File_google_protobuf_empty_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_google_protobuf_empty_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Empty); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_google_protobuf_empty_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_google_protobuf_empty_proto_goTypes,
+		DependencyIndexes: file_google_protobuf_empty_proto_depIdxs,
+		MessageInfos:      file_google_protobuf_empty_proto_msgTypes,
+	}.Build()
+	File_google_protobuf_empty_proto = out.File
+	file_google_protobuf_empty_proto_rawDesc = nil
+	file_google_protobuf_empty_proto_goTypes = nil
+	file_google_protobuf_empty_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/types/known/structpb/struct.pb.go b/vendor/google.golang.org/protobuf/types/known/structpb/struct.pb.go
new file mode 100644
index 000000000..df098137b
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/types/known/structpb/struct.pb.go
@@ -0,0 +1,505 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google/protobuf/struct.proto
+
+package structpb
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+// `NullValue` is a singleton enumeration to represent the null value for the
+// `Value` type union.
+//
+//  The JSON representation for `NullValue` is JSON `null`.
+type NullValue int32
+
+const (
+	// Null value.
+	NullValue_NULL_VALUE NullValue = 0
+)
+
+// Enum value maps for NullValue.
+var (
+	NullValue_name = map[int32]string{
+		0: "NULL_VALUE",
+	}
+	NullValue_value = map[string]int32{
+		"NULL_VALUE": 0,
+	}
+)
+
+func (x NullValue) Enum() *NullValue {
+	p := new(NullValue)
+	*p = x
+	return p
+}
+
+func (x NullValue) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (NullValue) Descriptor() protoreflect.EnumDescriptor {
+	return file_google_protobuf_struct_proto_enumTypes[0].Descriptor()
+}
+
+func (NullValue) Type() protoreflect.EnumType {
+	return &file_google_protobuf_struct_proto_enumTypes[0]
+}
+
+func (x NullValue) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use NullValue.Descriptor instead.
+func (NullValue) EnumDescriptor() ([]byte, []int) {
+	return file_google_protobuf_struct_proto_rawDescGZIP(), []int{0}
+}
+
+// `Struct` represents a structured data value, consisting of fields
+// which map to dynamically typed values. In some languages, `Struct`
+// might be supported by a native representation. For example, in
+// scripting languages like JS a struct is represented as an
+// object. The details of that representation are described together
+// with the proto support for the language.
+//
+// The JSON representation for `Struct` is JSON object.
+type Struct struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// Unordered map of dynamically typed values.
+	Fields map[string]*Value `protobuf:"bytes,1,rep,name=fields,proto3" json:"fields,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+}
+
+func (x *Struct) Reset() {
+	*x = Struct{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_struct_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Struct) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Struct) ProtoMessage() {}
+
+func (x *Struct) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_struct_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Struct.ProtoReflect.Descriptor instead.
+func (*Struct) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_struct_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Struct) GetFields() map[string]*Value {
+	if x != nil {
+		return x.Fields
+	}
+	return nil
+}
+
+// `Value` represents a dynamically typed value which can be either
+// null, a number, a string, a boolean, a recursive struct value, or a
+// list of values. A producer of value is expected to set one of that
+// variants, absence of any variant indicates an error.
+//
+// The JSON representation for `Value` is JSON value.
+type Value struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// The kind of value.
+	//
+	// Types that are assignable to Kind:
+	//	*Value_NullValue
+	//	*Value_NumberValue
+	//	*Value_StringValue
+	//	*Value_BoolValue
+	//	*Value_StructValue
+	//	*Value_ListValue
+	Kind isValue_Kind `protobuf_oneof:"kind"`
+}
+
+func (x *Value) Reset() {
+	*x = Value{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_struct_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Value) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Value) ProtoMessage() {}
+
+func (x *Value) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_struct_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Value.ProtoReflect.Descriptor instead.
+func (*Value) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_struct_proto_rawDescGZIP(), []int{1}
+}
+
+func (m *Value) GetKind() isValue_Kind {
+	if m != nil {
+		return m.Kind
+	}
+	return nil
+}
+
+func (x *Value) GetNullValue() NullValue {
+	if x, ok := x.GetKind().(*Value_NullValue); ok {
+		return x.NullValue
+	}
+	return NullValue_NULL_VALUE
+}
+
+func (x *Value) GetNumberValue() float64 {
+	if x, ok := x.GetKind().(*Value_NumberValue); ok {
+		return x.NumberValue
+	}
+	return 0
+}
+
+func (x *Value) GetStringValue() string {
+	if x, ok := x.GetKind().(*Value_StringValue); ok {
+		return x.StringValue
+	}
+	return ""
+}
+
+func (x *Value) GetBoolValue() bool {
+	if x, ok := x.GetKind().(*Value_BoolValue); ok {
+		return x.BoolValue
+	}
+	return false
+}
+
+func (x *Value) GetStructValue() *Struct {
+	if x, ok := x.GetKind().(*Value_StructValue); ok {
+		return x.StructValue
+	}
+	return nil
+}
+
+func (x *Value) GetListValue() *ListValue {
+	if x, ok := x.GetKind().(*Value_ListValue); ok {
+		return x.ListValue
+	}
+	return nil
+}
+
+type isValue_Kind interface {
+	isValue_Kind()
+}
+
+type Value_NullValue struct {
+	// Represents a null value.
+	NullValue NullValue `protobuf:"varint,1,opt,name=null_value,json=nullValue,proto3,enum=google.protobuf.NullValue,oneof"`
+}
+
+type Value_NumberValue struct {
+	// Represents a double value.
+	NumberValue float64 `protobuf:"fixed64,2,opt,name=number_value,json=numberValue,proto3,oneof"`
+}
+
+type Value_StringValue struct {
+	// Represents a string value.
+	StringValue string `protobuf:"bytes,3,opt,name=string_value,json=stringValue,proto3,oneof"`
+}
+
+type Value_BoolValue struct {
+	// Represents a boolean value.
+	BoolValue bool `protobuf:"varint,4,opt,name=bool_value,json=boolValue,proto3,oneof"`
+}
+
+type Value_StructValue struct {
+	// Represents a structured value.
+	StructValue *Struct `protobuf:"bytes,5,opt,name=struct_value,json=structValue,proto3,oneof"`
+}
+
+type Value_ListValue struct {
+	// Represents a repeated `Value`.
+	ListValue *ListValue `protobuf:"bytes,6,opt,name=list_value,json=listValue,proto3,oneof"`
+}
+
+func (*Value_NullValue) isValue_Kind() {}
+
+func (*Value_NumberValue) isValue_Kind() {}
+
+func (*Value_StringValue) isValue_Kind() {}
+
+func (*Value_BoolValue) isValue_Kind() {}
+
+func (*Value_StructValue) isValue_Kind() {}
+
+func (*Value_ListValue) isValue_Kind() {}
+
+// `ListValue` is a wrapper around a repeated field of values.
+//
+// The JSON representation for `ListValue` is JSON array.
+type ListValue struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// Repeated field of dynamically typed values.
+	Values []*Value `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"`
+}
+
+func (x *ListValue) Reset() {
+	*x = ListValue{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_struct_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *ListValue) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ListValue) ProtoMessage() {}
+
+func (x *ListValue) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_struct_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ListValue.ProtoReflect.Descriptor instead.
+func (*ListValue) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_struct_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *ListValue) GetValues() []*Value {
+	if x != nil {
+		return x.Values
+	}
+	return nil
+}
+
+var File_google_protobuf_struct_proto protoreflect.FileDescriptor
+
+var file_google_protobuf_struct_proto_rawDesc = []byte{
+	0x0a, 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x2f, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0f,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x22,
+	0x98, 0x01, 0x0a, 0x06, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x12, 0x3b, 0x0a, 0x06, 0x66, 0x69,
+	0x65, 0x6c, 0x64, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72,
+	0x75, 0x63, 0x74, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52,
+	0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x1a, 0x51, 0x0a, 0x0b, 0x46, 0x69, 0x65, 0x6c, 0x64,
+	0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x2c, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75,
+	0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52,
+	0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xb2, 0x02, 0x0a, 0x05, 0x56,
+	0x61, 0x6c, 0x75, 0x65, 0x12, 0x3b, 0x0a, 0x0a, 0x6e, 0x75, 0x6c, 0x6c, 0x5f, 0x76, 0x61, 0x6c,
+	0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4e, 0x75, 0x6c, 0x6c, 0x56,
+	0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, 0x09, 0x6e, 0x75, 0x6c, 0x6c, 0x56, 0x61, 0x6c, 0x75,
+	0x65, 0x12, 0x23, 0x0a, 0x0c, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x5f, 0x76, 0x61, 0x6c, 0x75,
+	0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x48, 0x00, 0x52, 0x0b, 0x6e, 0x75, 0x6d, 0x62, 0x65,
+	0x72, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x23, 0x0a, 0x0c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67,
+	0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b,
+	0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1f, 0x0a, 0x0a, 0x62,
+	0x6f, 0x6f, 0x6c, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x48,
+	0x00, 0x52, 0x09, 0x62, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x3c, 0x0a, 0x0c,
+	0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x05, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x48, 0x00, 0x52, 0x0b, 0x73,
+	0x74, 0x72, 0x75, 0x63, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x3b, 0x0a, 0x0a, 0x6c, 0x69,
+	0x73, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
+	0x2e, 0x4c, 0x69, 0x73, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, 0x09, 0x6c, 0x69,
+	0x73, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x06, 0x0a, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x22,
+	0x3b, 0x0a, 0x09, 0x4c, 0x69, 0x73, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x2e, 0x0a, 0x06,
+	0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x56,
+	0x61, 0x6c, 0x75, 0x65, 0x52, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x2a, 0x1b, 0x0a, 0x09,
+	0x4e, 0x75, 0x6c, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x0e, 0x0a, 0x0a, 0x4e, 0x55, 0x4c,
+	0x4c, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x10, 0x00, 0x42, 0x81, 0x01, 0x0a, 0x13, 0x63, 0x6f,
+	0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x42, 0x0b, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01,
+	0x5a, 0x31, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
+	0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79,
+	0x70, 0x65, 0x73, 0x2f, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x3b, 0x73, 0x74, 0x72, 0x75, 0x63,
+	0x74, 0x70, 0x62, 0xf8, 0x01, 0x01, 0xa2, 0x02, 0x03, 0x47, 0x50, 0x42, 0xaa, 0x02, 0x1e, 0x47,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x57,
+	0x65, 0x6c, 0x6c, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x73, 0x62, 0x06, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_google_protobuf_struct_proto_rawDescOnce sync.Once
+	file_google_protobuf_struct_proto_rawDescData = file_google_protobuf_struct_proto_rawDesc
+)
+
+func file_google_protobuf_struct_proto_rawDescGZIP() []byte {
+	file_google_protobuf_struct_proto_rawDescOnce.Do(func() {
+		file_google_protobuf_struct_proto_rawDescData = protoimpl.X.CompressGZIP(file_google_protobuf_struct_proto_rawDescData)
+	})
+	return file_google_protobuf_struct_proto_rawDescData
+}
+
+var file_google_protobuf_struct_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
+var file_google_protobuf_struct_proto_msgTypes = make([]protoimpl.MessageInfo, 4)
+var file_google_protobuf_struct_proto_goTypes = []interface{}{
+	(NullValue)(0),    // 0: google.protobuf.NullValue
+	(*Struct)(nil),    // 1: google.protobuf.Struct
+	(*Value)(nil),     // 2: google.protobuf.Value
+	(*ListValue)(nil), // 3: google.protobuf.ListValue
+	nil,               // 4: google.protobuf.Struct.FieldsEntry
+}
+var file_google_protobuf_struct_proto_depIdxs = []int32{
+	4, // 0: google.protobuf.Struct.fields:type_name -> google.protobuf.Struct.FieldsEntry
+	0, // 1: google.protobuf.Value.null_value:type_name -> google.protobuf.NullValue
+	1, // 2: google.protobuf.Value.struct_value:type_name -> google.protobuf.Struct
+	3, // 3: google.protobuf.Value.list_value:type_name -> google.protobuf.ListValue
+	2, // 4: google.protobuf.ListValue.values:type_name -> google.protobuf.Value
+	2, // 5: google.protobuf.Struct.FieldsEntry.value:type_name -> google.protobuf.Value
+	6, // [6:6] is the sub-list for method output_type
+	6, // [6:6] is the sub-list for method input_type
+	6, // [6:6] is the sub-list for extension type_name
+	6, // [6:6] is the sub-list for extension extendee
+	0, // [0:6] is the sub-list for field type_name
+}
+
+func init() { file_google_protobuf_struct_proto_init() }
+func file_google_protobuf_struct_proto_init() {
+	if File_google_protobuf_struct_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_google_protobuf_struct_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Struct); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_struct_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Value); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_struct_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ListValue); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	file_google_protobuf_struct_proto_msgTypes[1].OneofWrappers = []interface{}{
+		(*Value_NullValue)(nil),
+		(*Value_NumberValue)(nil),
+		(*Value_StringValue)(nil),
+		(*Value_BoolValue)(nil),
+		(*Value_StructValue)(nil),
+		(*Value_ListValue)(nil),
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_google_protobuf_struct_proto_rawDesc,
+			NumEnums:      1,
+			NumMessages:   4,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_google_protobuf_struct_proto_goTypes,
+		DependencyIndexes: file_google_protobuf_struct_proto_depIdxs,
+		EnumInfos:         file_google_protobuf_struct_proto_enumTypes,
+		MessageInfos:      file_google_protobuf_struct_proto_msgTypes,
+	}.Build()
+	File_google_protobuf_struct_proto = out.File
+	file_google_protobuf_struct_proto_rawDesc = nil
+	file_google_protobuf_struct_proto_goTypes = nil
+	file_google_protobuf_struct_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/types/known/timestamppb/timestamp.pb.go b/vendor/google.golang.org/protobuf/types/known/timestamppb/timestamp.pb.go
new file mode 100644
index 000000000..6fe6d42f1
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/types/known/timestamppb/timestamp.pb.go
@@ -0,0 +1,271 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google/protobuf/timestamp.proto
+
+package timestamppb
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+// A Timestamp represents a point in time independent of any time zone or local
+// calendar, encoded as a count of seconds and fractions of seconds at
+// nanosecond resolution. The count is relative to an epoch at UTC midnight on
+// January 1, 1970, in the proleptic Gregorian calendar which extends the
+// Gregorian calendar backwards to year one.
+//
+// All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
+// second table is needed for interpretation, using a [24-hour linear
+// smear](https://developers.google.com/time/smear).
+//
+// The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
+// restricting to that range, we ensure that we can convert to and from [RFC
+// 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
+//
+// # Examples
+//
+// Example 1: Compute Timestamp from POSIX `time()`.
+//
+//     Timestamp timestamp;
+//     timestamp.set_seconds(time(NULL));
+//     timestamp.set_nanos(0);
+//
+// Example 2: Compute Timestamp from POSIX `gettimeofday()`.
+//
+//     struct timeval tv;
+//     gettimeofday(&tv, NULL);
+//
+//     Timestamp timestamp;
+//     timestamp.set_seconds(tv.tv_sec);
+//     timestamp.set_nanos(tv.tv_usec * 1000);
+//
+// Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
+//
+//     FILETIME ft;
+//     GetSystemTimeAsFileTime(&ft);
+//     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
+//
+//     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
+//     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
+//     Timestamp timestamp;
+//     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
+//     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
+//
+// Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
+//
+//     long millis = System.currentTimeMillis();
+//
+//     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
+//         .setNanos((int) ((millis % 1000) * 1000000)).build();
+//
+//
+// Example 5: Compute Timestamp from current time in Python.
+//
+//     timestamp = Timestamp()
+//     timestamp.GetCurrentTime()
+//
+// # JSON Mapping
+//
+// In JSON format, the Timestamp type is encoded as a string in the
+// [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
+// format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
+// where {year} is always expressed using four digits while {month}, {day},
+// {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
+// seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
+// are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
+// is required. A proto3 JSON serializer should always use UTC (as indicated by
+// "Z") when printing the Timestamp type and a proto3 JSON parser should be
+// able to accept both UTC and other timezones (as indicated by an offset).
+//
+// For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
+// 01:30 UTC on January 15, 2017.
+//
+// In JavaScript, one can convert a Date object to this format using the
+// standard
+// [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
+// method. In Python, a standard `datetime.datetime` object can be converted
+// to this format using
+// [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
+// the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
+// the Joda Time's [`ISODateTimeFormat.dateTime()`](
+// http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D
+// ) to obtain a formatter capable of generating timestamps in this format.
+//
+//
+type Timestamp struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// Represents seconds of UTC time since Unix epoch
+	// 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
+	// 9999-12-31T23:59:59Z inclusive.
+	Seconds int64 `protobuf:"varint,1,opt,name=seconds,proto3" json:"seconds,omitempty"`
+	// Non-negative fractions of a second at nanosecond resolution. Negative
+	// second values with fractions must still have non-negative nanos values
+	// that count forward in time. Must be from 0 to 999,999,999
+	// inclusive.
+	Nanos int32 `protobuf:"varint,2,opt,name=nanos,proto3" json:"nanos,omitempty"`
+}
+
+func (x *Timestamp) Reset() {
+	*x = Timestamp{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_timestamp_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Timestamp) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Timestamp) ProtoMessage() {}
+
+func (x *Timestamp) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_timestamp_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Timestamp.ProtoReflect.Descriptor instead.
+func (*Timestamp) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_timestamp_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Timestamp) GetSeconds() int64 {
+	if x != nil {
+		return x.Seconds
+	}
+	return 0
+}
+
+func (x *Timestamp) GetNanos() int32 {
+	if x != nil {
+		return x.Nanos
+	}
+	return 0
+}
+
+var File_google_protobuf_timestamp_proto protoreflect.FileDescriptor
+
+var file_google_protobuf_timestamp_proto_rawDesc = []byte{
+	0x0a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x12, 0x0f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
+	0x75, 0x66, 0x22, 0x3b, 0x0a, 0x09, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12,
+	0x18, 0x0a, 0x07, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03,
+	0x52, 0x07, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x6e, 0x61, 0x6e,
+	0x6f, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x6e, 0x61, 0x6e, 0x6f, 0x73, 0x42,
+	0x7e, 0x0a, 0x13, 0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x42, 0x0e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d,
+	0x70, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x2b, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62,
+	0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x74, 0x69, 0x6d, 0x65,
+	0x73, 0x74, 0x61, 0x6d, 0x70, 0xf8, 0x01, 0x01, 0xa2, 0x02, 0x03, 0x47, 0x50, 0x42, 0xaa, 0x02,
+	0x1e, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
+	0x2e, 0x57, 0x65, 0x6c, 0x6c, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x73, 0x62,
+	0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_google_protobuf_timestamp_proto_rawDescOnce sync.Once
+	file_google_protobuf_timestamp_proto_rawDescData = file_google_protobuf_timestamp_proto_rawDesc
+)
+
+func file_google_protobuf_timestamp_proto_rawDescGZIP() []byte {
+	file_google_protobuf_timestamp_proto_rawDescOnce.Do(func() {
+		file_google_protobuf_timestamp_proto_rawDescData = protoimpl.X.CompressGZIP(file_google_protobuf_timestamp_proto_rawDescData)
+	})
+	return file_google_protobuf_timestamp_proto_rawDescData
+}
+
+var file_google_protobuf_timestamp_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_google_protobuf_timestamp_proto_goTypes = []interface{}{
+	(*Timestamp)(nil), // 0: google.protobuf.Timestamp
+}
+var file_google_protobuf_timestamp_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_google_protobuf_timestamp_proto_init() }
+func file_google_protobuf_timestamp_proto_init() {
+	if File_google_protobuf_timestamp_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_google_protobuf_timestamp_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Timestamp); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_google_protobuf_timestamp_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_google_protobuf_timestamp_proto_goTypes,
+		DependencyIndexes: file_google_protobuf_timestamp_proto_depIdxs,
+		MessageInfos:      file_google_protobuf_timestamp_proto_msgTypes,
+	}.Build()
+	File_google_protobuf_timestamp_proto = out.File
+	file_google_protobuf_timestamp_proto_rawDesc = nil
+	file_google_protobuf_timestamp_proto_goTypes = nil
+	file_google_protobuf_timestamp_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/types/known/wrapperspb/wrappers.pb.go b/vendor/google.golang.org/protobuf/types/known/wrapperspb/wrappers.pb.go
new file mode 100644
index 000000000..5c5ec2f10
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/types/known/wrapperspb/wrappers.pb.go
@@ -0,0 +1,714 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Wrappers for primitive (non-message) types. These types are useful
+// for embedding primitives in the `google.protobuf.Any` type and for places
+// where we need to distinguish between the absence of a primitive
+// typed field and its default value.
+//
+// These wrappers have no meaningful use within repeated fields as they lack
+// the ability to detect presence on individual elements.
+// These wrappers have no meaningful use within a map or a oneof since
+// individual entries of a map or fields of a oneof can already detect presence.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google/protobuf/wrappers.proto
+
+package wrapperspb
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+// Wrapper message for `double`.
+//
+// The JSON representation for `DoubleValue` is JSON number.
+type DoubleValue struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// The double value.
+	Value float64 `protobuf:"fixed64,1,opt,name=value,proto3" json:"value,omitempty"`
+}
+
+func (x *DoubleValue) Reset() {
+	*x = DoubleValue{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_wrappers_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *DoubleValue) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DoubleValue) ProtoMessage() {}
+
+func (x *DoubleValue) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_wrappers_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use DoubleValue.ProtoReflect.Descriptor instead.
+func (*DoubleValue) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_wrappers_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *DoubleValue) GetValue() float64 {
+	if x != nil {
+		return x.Value
+	}
+	return 0
+}
+
+// Wrapper message for `float`.
+//
+// The JSON representation for `FloatValue` is JSON number.
+type FloatValue struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// The float value.
+	Value float32 `protobuf:"fixed32,1,opt,name=value,proto3" json:"value,omitempty"`
+}
+
+func (x *FloatValue) Reset() {
+	*x = FloatValue{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_wrappers_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *FloatValue) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*FloatValue) ProtoMessage() {}
+
+func (x *FloatValue) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_wrappers_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use FloatValue.ProtoReflect.Descriptor instead.
+func (*FloatValue) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_wrappers_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *FloatValue) GetValue() float32 {
+	if x != nil {
+		return x.Value
+	}
+	return 0
+}
+
+// Wrapper message for `int64`.
+//
+// The JSON representation for `Int64Value` is JSON string.
+type Int64Value struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// The int64 value.
+	Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
+}
+
+func (x *Int64Value) Reset() {
+	*x = Int64Value{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_wrappers_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Int64Value) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Int64Value) ProtoMessage() {}
+
+func (x *Int64Value) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_wrappers_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Int64Value.ProtoReflect.Descriptor instead.
+func (*Int64Value) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_wrappers_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *Int64Value) GetValue() int64 {
+	if x != nil {
+		return x.Value
+	}
+	return 0
+}
+
+// Wrapper message for `uint64`.
+//
+// The JSON representation for `UInt64Value` is JSON string.
+type UInt64Value struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// The uint64 value.
+	Value uint64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
+}
+
+func (x *UInt64Value) Reset() {
+	*x = UInt64Value{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_wrappers_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *UInt64Value) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*UInt64Value) ProtoMessage() {}
+
+func (x *UInt64Value) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_wrappers_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use UInt64Value.ProtoReflect.Descriptor instead.
+func (*UInt64Value) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_wrappers_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *UInt64Value) GetValue() uint64 {
+	if x != nil {
+		return x.Value
+	}
+	return 0
+}
+
+// Wrapper message for `int32`.
+//
+// The JSON representation for `Int32Value` is JSON number.
+type Int32Value struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// The int32 value.
+	Value int32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
+}
+
+func (x *Int32Value) Reset() {
+	*x = Int32Value{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_wrappers_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Int32Value) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Int32Value) ProtoMessage() {}
+
+func (x *Int32Value) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_wrappers_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Int32Value.ProtoReflect.Descriptor instead.
+func (*Int32Value) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_wrappers_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *Int32Value) GetValue() int32 {
+	if x != nil {
+		return x.Value
+	}
+	return 0
+}
+
+// Wrapper message for `uint32`.
+//
+// The JSON representation for `UInt32Value` is JSON number.
+type UInt32Value struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// The uint32 value.
+	Value uint32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
+}
+
+func (x *UInt32Value) Reset() {
+	*x = UInt32Value{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_wrappers_proto_msgTypes[5]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *UInt32Value) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*UInt32Value) ProtoMessage() {}
+
+func (x *UInt32Value) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_wrappers_proto_msgTypes[5]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use UInt32Value.ProtoReflect.Descriptor instead.
+func (*UInt32Value) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_wrappers_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *UInt32Value) GetValue() uint32 {
+	if x != nil {
+		return x.Value
+	}
+	return 0
+}
+
+// Wrapper message for `bool`.
+//
+// The JSON representation for `BoolValue` is JSON `true` and `false`.
+type BoolValue struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// The bool value.
+	Value bool `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
+}
+
+func (x *BoolValue) Reset() {
+	*x = BoolValue{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_wrappers_proto_msgTypes[6]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *BoolValue) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BoolValue) ProtoMessage() {}
+
+func (x *BoolValue) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_wrappers_proto_msgTypes[6]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use BoolValue.ProtoReflect.Descriptor instead.
+func (*BoolValue) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_wrappers_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *BoolValue) GetValue() bool {
+	if x != nil {
+		return x.Value
+	}
+	return false
+}
+
+// Wrapper message for `string`.
+//
+// The JSON representation for `StringValue` is JSON string.
+type StringValue struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// The string value.
+	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
+}
+
+func (x *StringValue) Reset() {
+	*x = StringValue{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_wrappers_proto_msgTypes[7]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *StringValue) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*StringValue) ProtoMessage() {}
+
+func (x *StringValue) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_wrappers_proto_msgTypes[7]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use StringValue.ProtoReflect.Descriptor instead.
+func (*StringValue) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_wrappers_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *StringValue) GetValue() string {
+	if x != nil {
+		return x.Value
+	}
+	return ""
+}
+
+// Wrapper message for `bytes`.
+//
+// The JSON representation for `BytesValue` is JSON string.
+type BytesValue struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// The bytes value.
+	Value []byte `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
+}
+
+func (x *BytesValue) Reset() {
+	*x = BytesValue{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_wrappers_proto_msgTypes[8]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *BytesValue) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BytesValue) ProtoMessage() {}
+
+func (x *BytesValue) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_wrappers_proto_msgTypes[8]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use BytesValue.ProtoReflect.Descriptor instead.
+func (*BytesValue) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_wrappers_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *BytesValue) GetValue() []byte {
+	if x != nil {
+		return x.Value
+	}
+	return nil
+}
+
+var File_google_protobuf_wrappers_proto protoreflect.FileDescriptor
+
+var file_google_protobuf_wrappers_proto_rawDesc = []byte{
+	0x0a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x2f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x12, 0x0f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x22, 0x23, 0x0a, 0x0b, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
+	0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x01, 0x52,
+	0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x22, 0x0a, 0x0a, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x56,
+	0x61, 0x6c, 0x75, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x02, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x22, 0x0a, 0x0a, 0x49, 0x6e,
+	0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75,
+	0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x23,
+	0x0a, 0x0b, 0x55, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x14, 0x0a,
+	0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x76, 0x61,
+	0x6c, 0x75, 0x65, 0x22, 0x22, 0x0a, 0x0a, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75,
+	0x65, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x23, 0x0a, 0x0b, 0x55, 0x49, 0x6e, 0x74, 0x33,
+	0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x21, 0x0a, 0x09,
+	0x42, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c,
+	0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22,
+	0x23, 0x0a, 0x0b, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x14,
+	0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76,
+	0x61, 0x6c, 0x75, 0x65, 0x22, 0x22, 0x0a, 0x0a, 0x42, 0x79, 0x74, 0x65, 0x73, 0x56, 0x61, 0x6c,
+	0x75, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x0c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x7c, 0x0a, 0x13, 0x63, 0x6f, 0x6d, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x42,
+	0x0d, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01,
+	0x5a, 0x2a, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
+	0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79,
+	0x70, 0x65, 0x73, 0x2f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x73, 0xf8, 0x01, 0x01, 0xa2,
+	0x02, 0x03, 0x47, 0x50, 0x42, 0xaa, 0x02, 0x1e, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x50,
+	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x57, 0x65, 0x6c, 0x6c, 0x4b, 0x6e, 0x6f, 0x77,
+	0x6e, 0x54, 0x79, 0x70, 0x65, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_google_protobuf_wrappers_proto_rawDescOnce sync.Once
+	file_google_protobuf_wrappers_proto_rawDescData = file_google_protobuf_wrappers_proto_rawDesc
+)
+
+func file_google_protobuf_wrappers_proto_rawDescGZIP() []byte {
+	file_google_protobuf_wrappers_proto_rawDescOnce.Do(func() {
+		file_google_protobuf_wrappers_proto_rawDescData = protoimpl.X.CompressGZIP(file_google_protobuf_wrappers_proto_rawDescData)
+	})
+	return file_google_protobuf_wrappers_proto_rawDescData
+}
+
+var file_google_protobuf_wrappers_proto_msgTypes = make([]protoimpl.MessageInfo, 9)
+var file_google_protobuf_wrappers_proto_goTypes = []interface{}{
+	(*DoubleValue)(nil), // 0: google.protobuf.DoubleValue
+	(*FloatValue)(nil),  // 1: google.protobuf.FloatValue
+	(*Int64Value)(nil),  // 2: google.protobuf.Int64Value
+	(*UInt64Value)(nil), // 3: google.protobuf.UInt64Value
+	(*Int32Value)(nil),  // 4: google.protobuf.Int32Value
+	(*UInt32Value)(nil), // 5: google.protobuf.UInt32Value
+	(*BoolValue)(nil),   // 6: google.protobuf.BoolValue
+	(*StringValue)(nil), // 7: google.protobuf.StringValue
+	(*BytesValue)(nil),  // 8: google.protobuf.BytesValue
+}
+var file_google_protobuf_wrappers_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_google_protobuf_wrappers_proto_init() }
+func file_google_protobuf_wrappers_proto_init() {
+	if File_google_protobuf_wrappers_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_google_protobuf_wrappers_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*DoubleValue); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_wrappers_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*FloatValue); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_wrappers_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Int64Value); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_wrappers_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*UInt64Value); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_wrappers_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Int32Value); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_wrappers_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*UInt32Value); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_wrappers_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*BoolValue); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_wrappers_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*StringValue); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_wrappers_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*BytesValue); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_google_protobuf_wrappers_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   9,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_google_protobuf_wrappers_proto_goTypes,
+		DependencyIndexes: file_google_protobuf_wrappers_proto_depIdxs,
+		MessageInfos:      file_google_protobuf_wrappers_proto_msgTypes,
+	}.Build()
+	File_google_protobuf_wrappers_proto = out.File
+	file_google_protobuf_wrappers_proto_rawDesc = nil
+	file_google_protobuf_wrappers_proto_goTypes = nil
+	file_google_protobuf_wrappers_proto_depIdxs = nil
+}
diff --git a/vendor/google.golang.org/protobuf/types/pluginpb/plugin.pb.go b/vendor/google.golang.org/protobuf/types/pluginpb/plugin.pb.go
new file mode 100644
index 000000000..43ef7cb14
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/types/pluginpb/plugin.pb.go
@@ -0,0 +1,636 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//
+// WARNING:  The plugin interface is currently EXPERIMENTAL and is subject to
+//   change.
+//
+// protoc (aka the Protocol Compiler) can be extended via plugins.  A plugin is
+// just a program that reads a CodeGeneratorRequest from stdin and writes a
+// CodeGeneratorResponse to stdout.
+//
+// Plugins written using C++ can use google/protobuf/compiler/plugin.h instead
+// of dealing with the raw protocol defined here.
+//
+// A plugin executable needs only to be placed somewhere in the path.  The
+// plugin should be named "protoc-gen-$NAME", and will then be used when the
+// flag "--${NAME}_out" is passed to protoc.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google/protobuf/compiler/plugin.proto
+
+package pluginpb
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	descriptorpb "google.golang.org/protobuf/types/descriptorpb"
+	reflect "reflect"
+	sync "sync"
+)
+
+// Sync with code_generator.h.
+type CodeGeneratorResponse_Feature int32
+
+const (
+	CodeGeneratorResponse_FEATURE_NONE            CodeGeneratorResponse_Feature = 0
+	CodeGeneratorResponse_FEATURE_PROTO3_OPTIONAL CodeGeneratorResponse_Feature = 1
+)
+
+// Enum value maps for CodeGeneratorResponse_Feature.
+var (
+	CodeGeneratorResponse_Feature_name = map[int32]string{
+		0: "FEATURE_NONE",
+		1: "FEATURE_PROTO3_OPTIONAL",
+	}
+	CodeGeneratorResponse_Feature_value = map[string]int32{
+		"FEATURE_NONE":            0,
+		"FEATURE_PROTO3_OPTIONAL": 1,
+	}
+)
+
+func (x CodeGeneratorResponse_Feature) Enum() *CodeGeneratorResponse_Feature {
+	p := new(CodeGeneratorResponse_Feature)
+	*p = x
+	return p
+}
+
+func (x CodeGeneratorResponse_Feature) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (CodeGeneratorResponse_Feature) Descriptor() protoreflect.EnumDescriptor {
+	return file_google_protobuf_compiler_plugin_proto_enumTypes[0].Descriptor()
+}
+
+func (CodeGeneratorResponse_Feature) Type() protoreflect.EnumType {
+	return &file_google_protobuf_compiler_plugin_proto_enumTypes[0]
+}
+
+func (x CodeGeneratorResponse_Feature) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *CodeGeneratorResponse_Feature) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = CodeGeneratorResponse_Feature(num)
+	return nil
+}
+
+// Deprecated: Use CodeGeneratorResponse_Feature.Descriptor instead.
+func (CodeGeneratorResponse_Feature) EnumDescriptor() ([]byte, []int) {
+	return file_google_protobuf_compiler_plugin_proto_rawDescGZIP(), []int{2, 0}
+}
+
+// The version number of protocol compiler.
+type Version struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Major *int32 `protobuf:"varint,1,opt,name=major" json:"major,omitempty"`
+	Minor *int32 `protobuf:"varint,2,opt,name=minor" json:"minor,omitempty"`
+	Patch *int32 `protobuf:"varint,3,opt,name=patch" json:"patch,omitempty"`
+	// A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
+	// be empty for mainline stable releases.
+	Suffix *string `protobuf:"bytes,4,opt,name=suffix" json:"suffix,omitempty"`
+}
+
+func (x *Version) Reset() {
+	*x = Version{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_compiler_plugin_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Version) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Version) ProtoMessage() {}
+
+func (x *Version) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_compiler_plugin_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Version.ProtoReflect.Descriptor instead.
+func (*Version) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_compiler_plugin_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Version) GetMajor() int32 {
+	if x != nil && x.Major != nil {
+		return *x.Major
+	}
+	return 0
+}
+
+func (x *Version) GetMinor() int32 {
+	if x != nil && x.Minor != nil {
+		return *x.Minor
+	}
+	return 0
+}
+
+func (x *Version) GetPatch() int32 {
+	if x != nil && x.Patch != nil {
+		return *x.Patch
+	}
+	return 0
+}
+
+func (x *Version) GetSuffix() string {
+	if x != nil && x.Suffix != nil {
+		return *x.Suffix
+	}
+	return ""
+}
+
+// An encoded CodeGeneratorRequest is written to the plugin's stdin.
+type CodeGeneratorRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// The .proto files that were explicitly listed on the command-line.  The
+	// code generator should generate code only for these files.  Each file's
+	// descriptor will be included in proto_file, below.
+	FileToGenerate []string `protobuf:"bytes,1,rep,name=file_to_generate,json=fileToGenerate" json:"file_to_generate,omitempty"`
+	// The generator parameter passed on the command-line.
+	Parameter *string `protobuf:"bytes,2,opt,name=parameter" json:"parameter,omitempty"`
+	// FileDescriptorProtos for all files in files_to_generate and everything
+	// they import.  The files will appear in topological order, so each file
+	// appears before any file that imports it.
+	//
+	// protoc guarantees that all proto_files will be written after
+	// the fields above, even though this is not technically guaranteed by the
+	// protobuf wire format.  This theoretically could allow a plugin to stream
+	// in the FileDescriptorProtos and handle them one by one rather than read
+	// the entire set into memory at once.  However, as of this writing, this
+	// is not similarly optimized on protoc's end -- it will store all fields in
+	// memory at once before sending them to the plugin.
+	//
+	// Type names of fields and extensions in the FileDescriptorProto are always
+	// fully qualified.
+	ProtoFile []*descriptorpb.FileDescriptorProto `protobuf:"bytes,15,rep,name=proto_file,json=protoFile" json:"proto_file,omitempty"`
+	// The version number of protocol compiler.
+	CompilerVersion *Version `protobuf:"bytes,3,opt,name=compiler_version,json=compilerVersion" json:"compiler_version,omitempty"`
+}
+
+func (x *CodeGeneratorRequest) Reset() {
+	*x = CodeGeneratorRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_compiler_plugin_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *CodeGeneratorRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*CodeGeneratorRequest) ProtoMessage() {}
+
+func (x *CodeGeneratorRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_compiler_plugin_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use CodeGeneratorRequest.ProtoReflect.Descriptor instead.
+func (*CodeGeneratorRequest) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_compiler_plugin_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *CodeGeneratorRequest) GetFileToGenerate() []string {
+	if x != nil {
+		return x.FileToGenerate
+	}
+	return nil
+}
+
+func (x *CodeGeneratorRequest) GetParameter() string {
+	if x != nil && x.Parameter != nil {
+		return *x.Parameter
+	}
+	return ""
+}
+
+func (x *CodeGeneratorRequest) GetProtoFile() []*descriptorpb.FileDescriptorProto {
+	if x != nil {
+		return x.ProtoFile
+	}
+	return nil
+}
+
+func (x *CodeGeneratorRequest) GetCompilerVersion() *Version {
+	if x != nil {
+		return x.CompilerVersion
+	}
+	return nil
+}
+
+// The plugin writes an encoded CodeGeneratorResponse to stdout.
+type CodeGeneratorResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// Error message.  If non-empty, code generation failed.  The plugin process
+	// should exit with status code zero even if it reports an error in this way.
+	//
+	// This should be used to indicate errors in .proto files which prevent the
+	// code generator from generating correct code.  Errors which indicate a
+	// problem in protoc itself -- such as the input CodeGeneratorRequest being
+	// unparseable -- should be reported by writing a message to stderr and
+	// exiting with a non-zero status code.
+	Error *string `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"`
+	// A bitmask of supported features that the code generator supports.
+	// This is a bitwise "or" of values from the Feature enum.
+	SupportedFeatures *uint64                       `protobuf:"varint,2,opt,name=supported_features,json=supportedFeatures" json:"supported_features,omitempty"`
+	File              []*CodeGeneratorResponse_File `protobuf:"bytes,15,rep,name=file" json:"file,omitempty"`
+}
+
+func (x *CodeGeneratorResponse) Reset() {
+	*x = CodeGeneratorResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_compiler_plugin_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *CodeGeneratorResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*CodeGeneratorResponse) ProtoMessage() {}
+
+func (x *CodeGeneratorResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_compiler_plugin_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use CodeGeneratorResponse.ProtoReflect.Descriptor instead.
+func (*CodeGeneratorResponse) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_compiler_plugin_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *CodeGeneratorResponse) GetError() string {
+	if x != nil && x.Error != nil {
+		return *x.Error
+	}
+	return ""
+}
+
+func (x *CodeGeneratorResponse) GetSupportedFeatures() uint64 {
+	if x != nil && x.SupportedFeatures != nil {
+		return *x.SupportedFeatures
+	}
+	return 0
+}
+
+func (x *CodeGeneratorResponse) GetFile() []*CodeGeneratorResponse_File {
+	if x != nil {
+		return x.File
+	}
+	return nil
+}
+
+// Represents a single generated file.
+type CodeGeneratorResponse_File struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// The file name, relative to the output directory.  The name must not
+	// contain "." or ".." components and must be relative, not be absolute (so,
+	// the file cannot lie outside the output directory).  "/" must be used as
+	// the path separator, not "\".
+	//
+	// If the name is omitted, the content will be appended to the previous
+	// file.  This allows the generator to break large files into small chunks,
+	// and allows the generated text to be streamed back to protoc so that large
+	// files need not reside completely in memory at one time.  Note that as of
+	// this writing protoc does not optimize for this -- it will read the entire
+	// CodeGeneratorResponse before writing files to disk.
+	Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+	// If non-empty, indicates that the named file should already exist, and the
+	// content here is to be inserted into that file at a defined insertion
+	// point.  This feature allows a code generator to extend the output
+	// produced by another code generator.  The original generator may provide
+	// insertion points by placing special annotations in the file that look
+	// like:
+	//   @@protoc_insertion_point(NAME)
+	// The annotation can have arbitrary text before and after it on the line,
+	// which allows it to be placed in a comment.  NAME should be replaced with
+	// an identifier naming the point -- this is what other generators will use
+	// as the insertion_point.  Code inserted at this point will be placed
+	// immediately above the line containing the insertion point (thus multiple
+	// insertions to the same point will come out in the order they were added).
+	// The double-@ is intended to make it unlikely that the generated code
+	// could contain things that look like insertion points by accident.
+	//
+	// For example, the C++ code generator places the following line in the
+	// .pb.h files that it generates:
+	//   // @@protoc_insertion_point(namespace_scope)
+	// This line appears within the scope of the file's package namespace, but
+	// outside of any particular class.  Another plugin can then specify the
+	// insertion_point "namespace_scope" to generate additional classes or
+	// other declarations that should be placed in this scope.
+	//
+	// Note that if the line containing the insertion point begins with
+	// whitespace, the same whitespace will be added to every line of the
+	// inserted text.  This is useful for languages like Python, where
+	// indentation matters.  In these languages, the insertion point comment
+	// should be indented the same amount as any inserted code will need to be
+	// in order to work correctly in that context.
+	//
+	// The code generator that generates the initial file and the one which
+	// inserts into it must both run as part of a single invocation of protoc.
+	// Code generators are executed in the order in which they appear on the
+	// command line.
+	//
+	// If |insertion_point| is present, |name| must also be present.
+	InsertionPoint *string `protobuf:"bytes,2,opt,name=insertion_point,json=insertionPoint" json:"insertion_point,omitempty"`
+	// The file contents.
+	Content *string `protobuf:"bytes,15,opt,name=content" json:"content,omitempty"`
+}
+
+func (x *CodeGeneratorResponse_File) Reset() {
+	*x = CodeGeneratorResponse_File{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_google_protobuf_compiler_plugin_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *CodeGeneratorResponse_File) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*CodeGeneratorResponse_File) ProtoMessage() {}
+
+func (x *CodeGeneratorResponse_File) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_compiler_plugin_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use CodeGeneratorResponse_File.ProtoReflect.Descriptor instead.
+func (*CodeGeneratorResponse_File) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_compiler_plugin_proto_rawDescGZIP(), []int{2, 0}
+}
+
+func (x *CodeGeneratorResponse_File) GetName() string {
+	if x != nil && x.Name != nil {
+		return *x.Name
+	}
+	return ""
+}
+
+func (x *CodeGeneratorResponse_File) GetInsertionPoint() string {
+	if x != nil && x.InsertionPoint != nil {
+		return *x.InsertionPoint
+	}
+	return ""
+}
+
+func (x *CodeGeneratorResponse_File) GetContent() string {
+	if x != nil && x.Content != nil {
+		return *x.Content
+	}
+	return ""
+}
+
+var File_google_protobuf_compiler_plugin_proto protoreflect.FileDescriptor
+
+var file_google_protobuf_compiler_plugin_proto_rawDesc = []byte{
+	0x0a, 0x25, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x2f, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x72, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69,
+	0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x18, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65,
+	0x72, 0x1a, 0x20, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
+	0x75, 0x66, 0x2f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x22, 0x63, 0x0a, 0x07, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x14,
+	0x0a, 0x05, 0x6d, 0x61, 0x6a, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x6d,
+	0x61, 0x6a, 0x6f, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x6d, 0x69, 0x6e, 0x6f, 0x72, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x05, 0x52, 0x05, 0x6d, 0x69, 0x6e, 0x6f, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x61,
+	0x74, 0x63, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x70, 0x61, 0x74, 0x63, 0x68,
+	0x12, 0x16, 0x0a, 0x06, 0x73, 0x75, 0x66, 0x66, 0x69, 0x78, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x06, 0x73, 0x75, 0x66, 0x66, 0x69, 0x78, 0x22, 0xf1, 0x01, 0x0a, 0x14, 0x43, 0x6f, 0x64,
+	0x65, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x12, 0x28, 0x0a, 0x10, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x74, 0x6f, 0x5f, 0x67, 0x65, 0x6e,
+	0x65, 0x72, 0x61, 0x74, 0x65, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0e, 0x66, 0x69, 0x6c,
+	0x65, 0x54, 0x6f, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x70,
+	0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09,
+	0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x12, 0x43, 0x0a, 0x0a, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x0f, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
+	0x46, 0x69, 0x6c, 0x65, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72,
+	0x6f, 0x74, 0x6f, 0x52, 0x09, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x46, 0x69, 0x6c, 0x65, 0x12, 0x4c,
+	0x0a, 0x10, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x72, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69,
+	0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69,
+	0x6c, 0x65, 0x72, 0x2e, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x0f, 0x63, 0x6f, 0x6d,
+	0x70, 0x69, 0x6c, 0x65, 0x72, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0xbf, 0x02, 0x0a,
+	0x15, 0x43, 0x6f, 0x64, 0x65, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x2d, 0x0a, 0x12,
+	0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x5f, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72,
+	0x65, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x11, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72,
+	0x74, 0x65, 0x64, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x12, 0x48, 0x0a, 0x04, 0x66,
+	0x69, 0x6c, 0x65, 0x18, 0x0f, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x63, 0x6f, 0x6d, 0x70,
+	0x69, 0x6c, 0x65, 0x72, 0x2e, 0x43, 0x6f, 0x64, 0x65, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74,
+	0x6f, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x46, 0x69, 0x6c, 0x65, 0x52,
+	0x04, 0x66, 0x69, 0x6c, 0x65, 0x1a, 0x5d, 0x0a, 0x04, 0x46, 0x69, 0x6c, 0x65, 0x12, 0x12, 0x0a,
+	0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d,
+	0x65, 0x12, 0x27, 0x0a, 0x0f, 0x69, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70,
+	0x6f, 0x69, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x69, 0x6e, 0x73, 0x65,
+	0x72, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x6f,
+	0x6e, 0x74, 0x65, 0x6e, 0x74, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x6f, 0x6e,
+	0x74, 0x65, 0x6e, 0x74, 0x22, 0x38, 0x0a, 0x07, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x12,
+	0x10, 0x0a, 0x0c, 0x46, 0x45, 0x41, 0x54, 0x55, 0x52, 0x45, 0x5f, 0x4e, 0x4f, 0x4e, 0x45, 0x10,
+	0x00, 0x12, 0x1b, 0x0a, 0x17, 0x46, 0x45, 0x41, 0x54, 0x55, 0x52, 0x45, 0x5f, 0x50, 0x52, 0x4f,
+	0x54, 0x4f, 0x33, 0x5f, 0x4f, 0x50, 0x54, 0x49, 0x4f, 0x4e, 0x41, 0x4c, 0x10, 0x01, 0x42, 0x67,
+	0x0a, 0x1c, 0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x72, 0x42, 0x0c,
+	0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x5a, 0x39, 0x67, 0x69,
+	0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d,
+	0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x3b, 0x70, 0x6c,
+	0x75, 0x67, 0x69, 0x6e, 0x5f, 0x67, 0x6f,
+}
+
+var (
+	file_google_protobuf_compiler_plugin_proto_rawDescOnce sync.Once
+	file_google_protobuf_compiler_plugin_proto_rawDescData = file_google_protobuf_compiler_plugin_proto_rawDesc
+)
+
+func file_google_protobuf_compiler_plugin_proto_rawDescGZIP() []byte {
+	file_google_protobuf_compiler_plugin_proto_rawDescOnce.Do(func() {
+		file_google_protobuf_compiler_plugin_proto_rawDescData = protoimpl.X.CompressGZIP(file_google_protobuf_compiler_plugin_proto_rawDescData)
+	})
+	return file_google_protobuf_compiler_plugin_proto_rawDescData
+}
+
+var file_google_protobuf_compiler_plugin_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
+var file_google_protobuf_compiler_plugin_proto_msgTypes = make([]protoimpl.MessageInfo, 4)
+var file_google_protobuf_compiler_plugin_proto_goTypes = []interface{}{
+	(CodeGeneratorResponse_Feature)(0),       // 0: google.protobuf.compiler.CodeGeneratorResponse.Feature
+	(*Version)(nil),                          // 1: google.protobuf.compiler.Version
+	(*CodeGeneratorRequest)(nil),             // 2: google.protobuf.compiler.CodeGeneratorRequest
+	(*CodeGeneratorResponse)(nil),            // 3: google.protobuf.compiler.CodeGeneratorResponse
+	(*CodeGeneratorResponse_File)(nil),       // 4: google.protobuf.compiler.CodeGeneratorResponse.File
+	(*descriptorpb.FileDescriptorProto)(nil), // 5: google.protobuf.FileDescriptorProto
+}
+var file_google_protobuf_compiler_plugin_proto_depIdxs = []int32{
+	5, // 0: google.protobuf.compiler.CodeGeneratorRequest.proto_file:type_name -> google.protobuf.FileDescriptorProto
+	1, // 1: google.protobuf.compiler.CodeGeneratorRequest.compiler_version:type_name -> google.protobuf.compiler.Version
+	4, // 2: google.protobuf.compiler.CodeGeneratorResponse.file:type_name -> google.protobuf.compiler.CodeGeneratorResponse.File
+	3, // [3:3] is the sub-list for method output_type
+	3, // [3:3] is the sub-list for method input_type
+	3, // [3:3] is the sub-list for extension type_name
+	3, // [3:3] is the sub-list for extension extendee
+	0, // [0:3] is the sub-list for field type_name
+}
+
+func init() { file_google_protobuf_compiler_plugin_proto_init() }
+func file_google_protobuf_compiler_plugin_proto_init() {
+	if File_google_protobuf_compiler_plugin_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_google_protobuf_compiler_plugin_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Version); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_compiler_plugin_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*CodeGeneratorRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_compiler_plugin_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*CodeGeneratorResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_google_protobuf_compiler_plugin_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*CodeGeneratorResponse_File); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_google_protobuf_compiler_plugin_proto_rawDesc,
+			NumEnums:      1,
+			NumMessages:   4,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_google_protobuf_compiler_plugin_proto_goTypes,
+		DependencyIndexes: file_google_protobuf_compiler_plugin_proto_depIdxs,
+		EnumInfos:         file_google_protobuf_compiler_plugin_proto_enumTypes,
+		MessageInfos:      file_google_protobuf_compiler_plugin_proto_msgTypes,
+	}.Build()
+	File_google_protobuf_compiler_plugin_proto = out.File
+	file_google_protobuf_compiler_plugin_proto_rawDesc = nil
+	file_google_protobuf_compiler_plugin_proto_goTypes = nil
+	file_google_protobuf_compiler_plugin_proto_depIdxs = nil
+}
diff --git a/vendor/vendor.json b/vendor/vendor.json
index d074b7b8d..c5290c98e 100644
--- a/vendor/vendor.json
+++ b/vendor/vendor.json
@@ -347,6 +347,12 @@
 			"revisionTime": "2017-08-21T10:38:37Z",
 			"tree": true
 		},
+		{
+			"checksumSHA1": "o1LjRG/J2y9dNV2m0FGpgDuKjJo=",
+			"path": "github.com/karalabe/usb",
+			"revision": "4ea20957c2104ef4130bb8884e6a6dfb4201a4c8",
+			"revisionTime": "2021-05-18T09:18:19Z"
+		},
 		{
 			"checksumSHA1": "7hln62oZPZmyqEmgXaybf9WxQ7A=",
 			"path": "github.com/maruel/panicparse/stack",